diff --git a/.github/workflows/bench-main.yml b/.github/workflows/bench-main.yml index 98601c1ea..f41b4b190 100644 --- a/.github/workflows/bench-main.yml +++ b/.github/workflows/bench-main.yml @@ -80,9 +80,6 @@ jobs: - run: | mkdir -p ~/.local/bin echo | lake run install # copies ix -> ~/.local/bin/ix - lake build bench-typecheck - cp .lake/build/bin/bench-typecheck ~/.local/bin/ - chmod +x ~/.local/bin/bench-typecheck - uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0 with: path: ~/.local/bin diff --git a/.github/workflows/bench-pr.yml b/.github/workflows/bench-pr.yml index bf6b4868f..c3ad398e6 100644 --- a/.github/workflows/bench-pr.yml +++ b/.github/workflows/bench-pr.yml @@ -249,9 +249,9 @@ jobs: - name: Build benchmark binaries if: steps.parse.outputs.fresh == '1' || steps.bins.outputs.cache-hit != 'true' run: | - lake build ix bench-typecheck - cp .lake/build/bin/ix .lake/build/bin/bench-typecheck ~/.local/bin/ - chmod +x ~/.local/bin/ix ~/.local/bin/bench-typecheck + lake build ix + cp .lake/build/bin/ix ~/.local/bin/ + chmod +x ~/.local/bin/ix - if: steps.parse.outputs.fresh != '1' && steps.bins.outputs.cache-hit != 'true' uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0 with: @@ -260,7 +260,7 @@ jobs: - name: Package run binaries run: >- tar -C "$HOME/.local/bin" -cf benchmark-binaries.tar - ix bench-typecheck + ix - name: Upload run binaries uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: @@ -751,8 +751,8 @@ jobs: && cmp -s lean-toolchain base/lean-toolchain; then if [ "$BENV" != Mathlib ] || [ "$ixe" = true ]; then mkdir -p base/.lake/build/bin - mv ~/.local/bin/ix ~/.local/bin/bench-typecheck base/.lake/build/bin/ 2>/dev/null || true - [ -x base/.lake/build/bin/ix ] && [ -x base/.lake/build/bin/bench-typecheck ] \ + mv ~/.local/bin/ix base/.lake/build/bin/ 2>/dev/null || true + [ -x base/.lake/build/bin/ix ] \ && cached=true fi fi @@ -777,14 +777,14 @@ jobs: uses: $/.github/actions/log-cpu with: label: Base benchmark binary build CPU - - name: Build base (ix, bench-typecheck) + - name: Build base (ix) if: steps.decide.outputs.run-base == 'true' && steps.base-src.outputs.cached != 'true' uses: leanprover/lean-action@50fcf42d2e460296f1a34b402e990d1b24f8b596 # v1.6.0 with: lake-package-directory: base auto-config: false build: true - build-args: "ix bench-typecheck" + build-args: "ix" use-github-cache: false # For a mathlib-importing env (Mathlib, FLT), the base-side compile # resolves imports from the base tree's Benchmarks/Compile diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a15deb055..cb1866e29 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -36,7 +36,7 @@ jobs: sccache: s3 sticky_cache: | rust - custom,path=.lake,path=target + custom,path=.lake,path=Aiur/.lake,path=IxVM/.lake,path=MultiStark/.lake,path=target - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: $/.github/actions/setup-rust-toolchain with: @@ -55,18 +55,30 @@ jobs: test-args: "--wfail" lint-args: "-- --wfail -v" use-github-cache: false - - name: Check codegen'd IxVM kernel is up to date + - name: Check formal Aiur proofs, FFI, and IxVM packages + run: | + lake build aiur/Aiur ixvm/IxVM multiStark/MultiStark + lake build aiur/aiur_tests aiur/execution_tests aiur/trace_tests ixvm/ixvm + Aiur/.lake/build/bin/aiur_tests + Aiur/.lake/build/bin/execution_tests + Aiur/.lake/build/bin/trace_tests + - name: Check new IxVM execution and proof fixture 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 ixvm/ixvm export /tmp/ixvm-execution.json + cargo run --release --locked -p ixvm -- /tmp/ixvm-execution.json all + target/release/ixvm /tmp/ixvm-execution.json validate IxVM/IxVM/fixtures/nat-add-comm.json + lake exe ixvm/ixvm export-trace /tmp/ixvm-trace.json + cargo run --release --locked -p ixvm --features parallel --example ixvm_bench -- /tmp/ixvm-trace.json IxVM/IxVM/fixtures/nat-add-comm.json witness 1 + - name: Check formal claims, recursive verification, and aggregation if: github.event_name != 'push' - run: lake exe ix codegen --trace-bundle --check + run: bash tools/ixvm/check-formal.sh - name: Check Lean versions match for Ix, compiler bench, certified kernel and its model if: github.event_name != 'push' run: | diff lean-toolchain Benchmarks/Compile/lean-toolchain + diff lean-toolchain Aiur/lean-toolchain + diff lean-toolchain IxVM/lean-toolchain diff lean-toolchain IxC/lean-toolchain diff lean-toolchain Models/SetTheory/lean-toolchain - name: Test Ix CLI @@ -93,7 +105,7 @@ jobs: sccache: s3 sticky_cache: | rust - custom,path=.lake,path=target + custom,path=.lake,path=Aiur/.lake,path=IxVM/.lake,path=target - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: $/.github/actions/setup-rust-toolchain with: @@ -114,11 +126,11 @@ jobs: if: github.event_name != 'push' uses: actions-rust-lang/rustfmt@4066006ec54a31931b9b1fddfd38f2fdf2d27143 # v1.1.2 - name: Check clippy warnings - run: cargo clippy --release --workspace --all-targets --features ix-ffi/parallel,ix-ffi/net,ix-ffi/test-ffi -- -D warnings + run: cargo clippy --release --workspace --all-targets --features ix-ffi/parallel,ix-ffi/net,ix-ffi/test-ffi,aiur/parallel,ixvm/parallel -- -D warnings - name: Check *everything* compiles - run: cargo check --release --workspace --all-targets --features ix-ffi/parallel,ix-ffi/net,ix-ffi/test-ffi + run: cargo check --release --workspace --all-targets --features ix-ffi/parallel,ix-ffi/net,ix-ffi/test-ffi,aiur/parallel,ixvm/parallel - name: Tests - run: cargo nextest run --release --profile ci --workspace ${{ github.event_name == 'push' && '--no-run' || '' }} + run: cargo nextest run --release --profile ci --workspace --features aiur/parallel,ixvm/parallel ${{ github.event_name == 'push' && '--no-run' || '' }} - name: Get Rust version if: github.event_name != 'push' run: | @@ -134,8 +146,9 @@ jobs: with: rust-version: ${{ env.RUST_VERSION }} - # Compile and link the opt-in backend without requiring a GPU. Runtime and - # proof-byte equivalence are covered by multi-stark's NVIDIA smoke suite. + # Compile and link the opt-in backend without requiring a GPU. Application + # runtime/proof parity uses IX_TEST_CUDA=1 tools/ixvm/check-formal.sh on a + # GPU host; the CPU job also exercises that gate's CPU controls. cuda-compile: runs-on: runs-on=${{ github.run_id }}-cuda-compile-${{ github.run_attempt }}/cpu=8/family=r7i+r8i+r7a+r8a/image=ubuntu26-full-x64/volume=100gb/extras=s3-cache container: @@ -176,10 +189,11 @@ jobs: auto-config: false use-github-cache: false - name: Compile CUDA Rust targets - run: | - cargo check --release --locked --workspace --all-targets --features ix-ffi/parallel,ix-ffi/cuda,ix-proof-compression/cuda - - name: Link CUDA-enabled Lean executables - run: IX_CUDA=1 lake build ix bench-typecheck + run: cargo check --release --locked --workspace --all-targets --features ix-ffi/parallel,ix-ffi/cuda,ix-proof-compression/cuda,ixvm/cuda,stark-verifier/cuda,ix-prover/cuda + - name: Link separate Aiur CUDA hosts + run: cargo build --release --locked --target-dir target/formal-cuda -p ixvm -p stark-verifier -p ix-prover --features parallel,cuda --bin ixvm-proof --bin stark-verifier --bin ix-prover + - name: Link a CUDA-enabled Lean executable + run: IX_CUDA=1 lake build ix lints: name: Lint workflows diff --git a/.gitignore b/.gitignore index 9387cfe12..15677d429 100644 --- a/.gitignore +++ b/.gitignore @@ -17,3 +17,6 @@ refs # TruthMines corpus artifacts: a .ixc is a self-contained directory # (manifest + pieces + build cache) — never checked in. *.ixc/ + +# Python maintenance tools +__pycache__/ diff --git a/Aiur/.gitignore b/Aiur/.gitignore new file mode 100644 index 000000000..01f8cdb63 --- /dev/null +++ b/Aiur/.gitignore @@ -0,0 +1 @@ +.lake/ diff --git a/Aiur/Aiur.lean b/Aiur/Aiur.lean new file mode 100644 index 000000000..e47d7d014 --- /dev/null +++ b/Aiur/Aiur.lean @@ -0,0 +1,23 @@ +import Aiur.AST +import Aiur.Typecheck +import Aiur.Eval +import Aiur.Semantics +import Aiur.EvalCorrectness +import Aiur.Circuit +import Aiur.Correctness +import Aiur.Completeness +import Aiur.MemoCompleteness +import Aiur.MemoSoundness +import Aiur.Frontend +import Aiur.MemoryCorrectness +import Aiur.CheckerCorrectness +import Aiur.Generic +import Aiur.Modules +import Aiur.Optimized +import Aiur.HeapMono +import Aiur.StepLemmas +import Aiur.Library.List.Correctness +import Aiur.Library.Bytes.Correctness +import Aiur.Library.RBTreeMap.Correctness +import Aiur.Library.IxVMRep +import Aiur.Audit diff --git a/Aiur/Aiur/AST.lean b/Aiur/Aiur/AST.lean new file mode 100644 index 000000000..13f21bac6 --- /dev/null +++ b/Aiur/Aiur/AST.lean @@ -0,0 +1,438 @@ +import Std + +namespace Aiur + +/-- Tuple shape is part of the type, including empty and singleton tuples. -/ +inductive Ty where + | field + | tuple (items : List Ty) + | ptr (target : Ty) + | enum (name : String) + deriving Repr, BEq + +mutual + def Ty.decEq : (left right : Ty) → Decidable (left = right) + | .field, .field => .isTrue rfl + | .tuple xs, .tuple ys => + match Ty.listDecEq xs ys with + | .isTrue h => .isTrue (congrArg Ty.tuple h) + | .isFalse h => .isFalse (fun eq => h (Ty.tuple.inj eq)) + | .ptr x, .ptr y => + match Ty.decEq x y with + | .isTrue h => .isTrue (congrArg Ty.ptr h) + | .isFalse h => .isFalse (fun eq => h (Ty.ptr.inj eq)) + | .enum x, .enum y => + if h : x = y then .isTrue (by cases h; rfl) + else .isFalse (fun eq => h (Ty.enum.inj eq)) + | .enum _, .field | .enum _, .tuple _ | .enum _, .ptr _ | + .field, .enum _ | .tuple _, .enum _ | .ptr _, .enum _ | + .ptr _, .field | .ptr _, .tuple _ | .field, .ptr _ | .tuple _, .ptr _ => + .isFalse (by intro h; cases h) + | .field, .tuple _ => .isFalse (by intro h; cases h) + | .tuple _, .field => .isFalse (by intro h; cases h) + termination_by left _ => sizeOf left + + def Ty.listDecEq : (left right : List (Ty)) → Decidable (left = right) + | [], [] => .isTrue rfl + | [], _ :: _ => .isFalse (by intro h; cases h) + | _ :: _, [] => .isFalse (by intro h; cases h) + | x :: xs, y :: ys => match Ty.decEq x y, Ty.listDecEq xs ys with + | .isTrue h, .isTrue hs => .isTrue (by cases h; cases hs; rfl) + | .isFalse h, _ => .isFalse (fun eq => h (List.cons.inj eq).1) + | _, .isFalse h => .isFalse (fun eq => h (List.cons.inj eq).2) + termination_by left _ => sizeOf left +end + +instance : DecidableEq (Ty) := Ty.decEq + +/-- Constructor identity is nominal and independent of the chosen field. -/ +structure ConstructorDecl where + name : String + fields : List Ty + deriving Repr, BEq, DecidableEq + +structure EnumDecl where + name : String + constructors : List ConstructorDecl + deriving Repr, BEq, DecidableEq + +abbrev Declarations := List EnumDecl + +def Declarations.findEnum? (decls : Declarations) (name : String) : Option EnumDecl := + decls.find? (·.name == name) + +def Declarations.findConstructor? (decls : Declarations) (name constructor : String) : + Option ConstructorDecl := do + let decl ← decls.findEnum? name + decl.constructors.find? (·.name == constructor) + +inductive BinOp where + | add | sub | mul | div + deriving Repr, BEq, DecidableEq + +/-- A structured value whose leaves are field elements (or symbolic field expressions). -/ +inductive Value (α : Type) (Address : Type := α) where + | field (value : α) + | tuple (items : List (Value α Address)) + | ptr (target : Ty) (address : Address) + | construct (enumName constructor : String) (args : List (Value α Address)) + deriving Repr, BEq + +mutual + def Value.decEq [DecidableEq α] [DecidableEq Address] : + (left right : Value α Address) → Decidable (left = right) + | .field x, .field y => + if h : x = y then .isTrue (by cases h; rfl) + else .isFalse (fun eq => h (Value.field.inj eq)) + | .tuple xs, .tuple ys => + match Value.listDecEq xs ys with + | .isTrue h => .isTrue (congrArg Value.tuple h) + | .isFalse h => .isFalse (fun eq => h (Value.tuple.inj eq)) + | .ptr t x, .ptr u y => + if h : t = u ∧ x = y then .isTrue (by rcases h with ⟨rfl, rfl⟩; rfl) + else .isFalse (fun eq => h (Value.ptr.inj eq)) + | .construct e c xs, .construct e' c' ys => + if h : e = e' ∧ c = c' then + match Value.listDecEq xs ys with + | .isTrue hs => .isTrue (by rcases h with ⟨rfl, rfl⟩; cases hs; rfl) + | .isFalse hs => .isFalse (fun eq => hs (Value.construct.inj eq).2.2) + else .isFalse (fun eq => h ⟨(Value.construct.inj eq).1, (Value.construct.inj eq).2.1⟩) + | .construct _ _ _, .field _ | .construct _ _ _, .tuple _ | .construct _ _ _, .ptr _ _ | + .field _, .construct _ _ _ | .tuple _, .construct _ _ _ | .ptr _ _, .construct _ _ _ | + .field _, .tuple _ | .field _, .ptr _ _ | .tuple _, .field _ | + .tuple _, .ptr _ _ | .ptr _ _, .field _ | .ptr _ _, .tuple _ => + .isFalse (by intro h; cases h) + termination_by left _ => sizeOf left + + def Value.listDecEq [DecidableEq α] [DecidableEq Address] : + (left right : List (Value α Address)) → Decidable (left = right) + | [], [] => .isTrue rfl + | [], _ :: _ => .isFalse (by intro h; cases h) + | _ :: _, [] => .isFalse (by intro h; cases h) + | x :: xs, y :: ys => match Value.decEq x y, Value.listDecEq xs ys with + | .isTrue h, .isTrue hs => .isTrue (by cases h; cases hs; rfl) + | .isFalse h, _ => .isFalse (fun eq => h (List.cons.inj eq).1) + | _, .isFalse h => .isFalse (fun eq => h (List.cons.inj eq).2) + termination_by left _ => sizeOf left +end + +instance [DecidableEq α] [DecidableEq Address] : DecidableEq (Value α Address) := Value.decEq + +/-- Map every circuit leaf, including the field representation of a pointer. -/ +def Value.map (f : α → β) : Value α → Value β + | .field x => .field (f x) + | .tuple items => .tuple (items.map (Value.map f)) + | .ptr target address => .ptr target (f address) + | .construct name ctor args => .construct name ctor (args.map (Value.map f)) +termination_by value => sizeOf value + +/-- Change opaque addresses without changing field data. -/ +def Value.mapAddress (f : A → B) : Value F A → Value F B + | .field x => .field x + | .tuple items => .tuple (items.map (Value.mapAddress f)) + | .ptr target address => .ptr target (f address) + | .construct name ctor args => .construct name ctor (args.map (Value.mapAddress f)) +termination_by value => sizeOf value + +def Value.type : Value α Address → Ty + | .field _ => .field + | .tuple items => .tuple (items.map Value.type) + | .ptr target _ => .ptr target + | .construct name _ _ => .enum name +termination_by value => sizeOf value + +def Value.flatten : Value α → List α + | .field x => [x] + | .tuple items => items.flatMap Value.flatten + | .ptr _ address => [address] + | .construct _ _ args => args.flatMap Value.flatten +termination_by value => sizeOf value + +def Value.addresses : Value α Address → List Address + | .field _ => [] + | .tuple items => items.flatMap Value.addresses + | .ptr _ address => [address] + | .construct _ _ args => args.flatMap Value.addresses +termination_by value => sizeOf value + +/-- Only the selected constructor payload is part of an enum value. -/ +def Value.pointerFree : Value α Address → Bool + | .field _ => true + | .tuple items => (items.map Value.pointerFree).all id + | .ptr _ _ => false + | .construct _ _ args => (args.map Value.pointerFree).all id +termination_by value => sizeOf value + +instance [OfNat α n] : OfNat (Value α Address) n := ⟨.field (OfNat.ofNat n)⟩ + +/-- Runtime locations are distinct from field-valued circuit addresses. -/ +abbrev SourceValue (F : Type) := Value F Nat + +/-- Static values cannot contain an address, including in nested constructor payloads. -/ +abbrev Constant (α : Type) := Value α Empty + +def Constant.toValue (value : Constant α) : Value α Address := + value.mapAddress Empty.elim + +def Constant.map (f : α → β) : Constant α → Constant β + | .field value => .field (f value) + | .tuple items => .tuple (items.map (Constant.map f)) + | .construct name ctor args => .construct name ctor (args.map (Constant.map f)) + | .ptr _ address => nomatch address +termination_by value => sizeOf value + +/-- Forgetting opaque addresses succeeds exactly on pointer-free values. -/ +def Value.toConstant? : Value α Address → Option (Constant α) + | .field value => some (.field value) + | .tuple items => (.tuple ·) <$> items.mapM Value.toConstant? + | .construct name ctor args => (.construct name ctor ·) <$> args.mapM Value.toConstant? + | .ptr _ _ => none +termination_by value => sizeOf value + +/-- A named, precommitted trace of typed constant rows. -/ +structure Table (α : Type) where + name : String + rowType : Ty + rows : List (Constant α) + deriving Repr, BEq + +/-- The input trace's outer tuple is the argument list; its elements retain their types. -/ +structure MapDecl where + name : String + params : List (String × Ty) + result : Ty + input : String + output : String + deriving Repr, BEq, DecidableEq + +structure Signature where + params : List (String × Ty) + result : Ty + deriving Repr, BEq, DecidableEq + +/-- Patterns can test leaves, discard subtrees, or bind entire subtrees. -/ +inductive Pattern (α : Type) where + | literal (value : α) + | wildcard + | bind (name : String) + | tuple (items : List (Pattern α)) + | construct (enumName constructor : String) (args : List (Pattern α)) + deriving Repr, BEq + +mutual + def Pattern.decEq [DecidableEq α] : (left right : Pattern α) → Decidable (left = right) + | .literal x, .literal y => + if h : x = y then .isTrue (by cases h; rfl) + else .isFalse (fun eq => h (Pattern.literal.inj eq)) + | .wildcard, .wildcard => .isTrue rfl + | .bind x, .bind y => + if h : x = y then .isTrue (by cases h; rfl) + else .isFalse (fun eq => h (Pattern.bind.inj eq)) + | .tuple xs, .tuple ys => + match Pattern.listDecEq xs ys with + | .isTrue h => .isTrue (congrArg Pattern.tuple h) + | .isFalse h => .isFalse (fun eq => h (Pattern.tuple.inj eq)) + | .construct e c xs, .construct e' c' ys => + if h : e = e' ∧ c = c' then + match Pattern.listDecEq xs ys with + | .isTrue hs => .isTrue (by rcases h with ⟨rfl, rfl⟩; cases hs; rfl) + | .isFalse hs => .isFalse (fun eq => hs (Pattern.construct.inj eq).2.2) + else .isFalse (fun eq => h ⟨(Pattern.construct.inj eq).1, (Pattern.construct.inj eq).2.1⟩) + | .construct _ _ _, .literal _ | .construct _ _ _, .wildcard | + .construct _ _ _, .bind _ | .construct _ _ _, .tuple _ | + .literal _, .construct _ _ _ | .wildcard, .construct _ _ _ | + .bind _, .construct _ _ _ | .tuple _, .construct _ _ _ => + .isFalse (by intro h; cases h) + | .literal _, .wildcard => .isFalse (by intro h; cases h) + | .literal _, .bind _ => .isFalse (by intro h; cases h) + | .literal _, .tuple _ => .isFalse (by intro h; cases h) + | .wildcard, .literal _ => .isFalse (by intro h; cases h) + | .wildcard, .bind _ => .isFalse (by intro h; cases h) + | .wildcard, .tuple _ => .isFalse (by intro h; cases h) + | .bind _, .literal _ => .isFalse (by intro h; cases h) + | .bind _, .wildcard => .isFalse (by intro h; cases h) + | .bind _, .tuple _ => .isFalse (by intro h; cases h) + | .tuple _, .literal _ => .isFalse (by intro h; cases h) + | .tuple _, .wildcard => .isFalse (by intro h; cases h) + | .tuple _, .bind _ => .isFalse (by intro h; cases h) + termination_by left _ => sizeOf left + + def Pattern.listDecEq [DecidableEq α] : (left right : List (Pattern α)) → Decidable (left = right) + | [], [] => .isTrue rfl + | [], _ :: _ => .isFalse (by intro h; cases h) + | _ :: _, [] => .isFalse (by intro h; cases h) + | x :: xs, y :: ys => match Pattern.decEq x y, Pattern.listDecEq xs ys with + | .isTrue h, .isTrue hs => .isTrue (by cases h; cases hs; rfl) + | .isFalse h, _ => .isFalse (fun eq => h (List.cons.inj eq).1) + | _, .isFalse h => .isFalse (fun eq => h (List.cons.inj eq).2) + termination_by left _ => sizeOf left +end + +instance [DecidableEq α] : DecidableEq (Pattern α) := Pattern.decEq + +/-- Equality always holds in the semantics and circuit. `runtimeCheck` only +controls the optional check performed by the Rust execution backend. -/ +structure Assertion where + message : Option String := none + runtimeCheck : Bool := true + deriving Repr, BEq, DecidableEq, Inhabited + +inductive Expr (α : Type) where + | literal (value : α) + | var (name : String) + | tuple (items : List (Expr α)) + | construct (enumName constructor : String) (args : List (Expr α)) + | project (value : Expr α) (index : Nat) + | letValue (pattern : Pattern α) (value body : Expr α) + | store (value : Expr α) + | load (pointer : Expr α) + | hint (type : Ty) (key : Expr α) (channel : String := "") + | neg (value : Expr α) + | binary (op : BinOp) (left right : Expr α) + | assertEq (assertion : Assertion) (left right : Expr α) + | call (function : String) (args : List (Expr α)) + | matchValue (scrutinee : Expr α) (arms : List (Pattern α × Expr α)) + deriving Repr, BEq + +/-- A selected table result contains no executable user code or allocations. -/ +def Constant.toExpr : Constant α → Expr α + | .field value => .literal value + | .tuple items => .tuple (items.map Constant.toExpr) + | .construct name ctor args => .construct name ctor (args.map Constant.toExpr) + | .ptr _ address => nomatch address +termination_by value => sizeOf value + +structure Function (α : Type) where + name : String + params : List (String × Ty) + result : Ty + body : Expr α + deriving Repr, BEq + +structure Program (α : Type) where + functions : List (Function α) + enums : Declarations := [] + tables : List (Table α) := [] + maps : List MapDecl := [] + deriving Repr, BEq + +def Program.findFunction? (program : Program α) (name : String) : Option (Function α) := + program.functions.find? (·.name == name) + +def Program.findTable? (program : Program α) (name : String) : Option (Table α) := + program.tables.find? (·.name == name) + +def Program.findMap? (program : Program α) (name : String) : Option MapDecl := + program.maps.find? (·.name == name) + +def Program.findSignature? (program : Program α) (name : String) : Option Signature := + match program.findFunction? name with + | some fn => some ⟨fn.params, fn.result⟩ + | none => (program.findMap? name).map fun map => ⟨map.params, map.result⟩ + +/-- Row alignment, rather than independent membership, relates the two traces. -/ +def Program.mapRows (program : Program α) (map : MapDecl) : List (Constant α × Constant α) := + match program.findTable? map.input, program.findTable? map.output with + | some inputs, some outputs => inputs.rows.zip outputs.rows + | _, _ => [] + +structure MapEntry (α : Type) where + args : List (Constant α) + result : Constant α + deriving Repr, BEq, DecidableEq + +/-- A derived view of aligned traces; the program stores each table only once. -/ +def Program.mapEntries (program : Program α) (map : MapDecl) : List (MapEntry α) := + (program.mapRows map).filterMap fun + | (.tuple args, result) => some ⟨args, result⟩ + | _ => none + +def Pattern.map (f : α → β) : Pattern α → Pattern β + | .literal x => .literal (f x) + | .wildcard => .wildcard + | .bind name => .bind name + | .tuple items => .tuple (items.map (Pattern.map f)) + | .construct name ctor args => .construct name ctor (args.map (Pattern.map f)) +termination_by pattern => sizeOf pattern + +/-- Bindings and wildcards accept every value of their checked type. -/ +def Pattern.irrefutable (decls : Declarations) : Pattern α → Bool + | .literal _ => false + | .wildcard | .bind _ => true + | .tuple items => (items.map (Pattern.irrefutable decls)).all id + | .construct name ctor args => + match decls.findEnum? name with + | some ⟨_, [only]⟩ => only.name == ctor && (args.map (Pattern.irrefutable decls)).all id + | _ => false +termination_by pattern => sizeOf pattern + +/-- Ignore binder names when checking duplicate matching conditions. -/ +def Pattern.condition : Pattern α → Pattern α + | .bind _ => .wildcard + | .tuple items => .tuple (items.map Pattern.condition) + | .construct name ctor args => .construct name ctor (args.map Pattern.condition) + | pattern => pattern +termination_by pattern => sizeOf pattern + +def Expr.map (f : α → β) : Expr α → Expr β + | .literal value => .literal (f value) + | .var name => .var name + | .tuple items => .tuple (items.map (Expr.map f)) + | .construct name ctor args => .construct name ctor (args.map (Expr.map f)) + | .project value index => .project (value.map f) index + | .letValue pattern value body => .letValue (pattern.map f) (value.map f) (body.map f) + | .store value => .store (value.map f) + | .load pointer => .load (pointer.map f) + | .hint type key channel => .hint type (key.map f) channel + | .neg value => .neg (value.map f) + | .binary op left right => .binary op (left.map f) (right.map f) + | .assertEq message left right => .assertEq message (left.map f) (right.map f) + | .call name args => .call name (args.map (Expr.map f)) + | .matchValue scrutinee arms => + .matchValue (scrutinee.map f) (arms.map fun arm => (arm.1.map f, arm.2.map f)) +termination_by expr => sizeOf expr +decreasing_by + all_goals simp_wf + all_goals + first + | omega + | have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + first + | omega + | cases arm; simp_all only [Prod.mk.sizeOf_spec]; omega + +def Function.map (f : α → β) (function : Function α) : Function β := + { function with body := function.body.map f } + +def Program.map (f : α → β) (program : Program α) : Program β := + { program with + functions := program.functions.map (Function.map f) + tables := program.tables.map fun table => { table with rows := table.rows.map (Constant.map f) } } + +def Program.toField (F : Type) [NatCast F] (program : Program Nat) : Program F := + program.map (fun n => (Nat.cast n : F)) + +/-- A syntactic boundary for the original deterministic fragment. -/ +def Expr.noHints : Expr α → Bool + | .hint _ _ _ => false + | .literal _ | .var _ => true + | .tuple items | .construct _ _ items | .call _ items => + (items.map Expr.noHints).all id + | .project value _ | .store value | .load value | .neg value => value.noHints + | .letValue _ value body | .binary _ value body | .assertEq _ value body => value.noHints && body.noHints + | .matchValue value arms => value.noHints && (arms.map fun arm => arm.2.noHints).all id +termination_by expr => sizeOf expr +decreasing_by + all_goals simp_wf + all_goals + first + | omega + | have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + first + | omega + | cases arm; simp_all only [Prod.mk.sizeOf_spec]; omega + +def Program.noHints (program : Program α) : Bool := + (program.functions.map fun function => function.body.noHints).all id + +end Aiur diff --git a/Aiur/Aiur/Audit.lean b/Aiur/Aiur/Audit.lean new file mode 100644 index 000000000..a84a9aa77 --- /dev/null +++ b/Aiur/Aiur/Audit.lean @@ -0,0 +1,4648 @@ +import Aiur.Correctness +import Aiur.Completeness +import Aiur.MemoCompleteness +import Aiur.MemoSoundness +import Aiur.MemoryCorrectness +import Aiur.CheckerCorrectness +import Aiur.Generic +import Aiur.Modules +import Aiur.Optimized +import Aiur.HeapMono +import Aiur.StepLemmas +import Aiur.Library.Carry +import Aiur.Library.U8Facts +import Aiur.Library.U32.Correctness +import Aiur.Library.U32.Goldilocks +import Aiur.Library.U64.Correctness +import Aiur.Library.U64.Goldilocks +import Aiur.Library.List.Correctness +import Aiur.Library.Bytes.Correctness +import Aiur.Library.RBTreeMap.Correctness +import Aiur.Library.IxVMRep +import Aiur.Library.Blake3.Correctness +import Aiur.Library.Blake3.Goldilocks + +/-! +# Frozen Certification Audit for Aiur + +This module freezes the type signatures and audits the axiom footprints of all +top-level compiler, checker, physical/grouped/activated backend, and standard +library (`Carry`, `U8`, `U32`, `U64`, `Blake3`, `Goldilocks`) correctness +theorems in `Aiur`. + +Every theorem audited here depends strictly on a subset of the standard Lean +foundational axioms `[propext, Classical.choice, Quot.sound]`, with zero +`sorryAx` and zero custom or `bv_decide` axioms. +-/ + +namespace Aiur.Audit + +/-! ### 1. Core Compiler, Memory Realization, and Checker Theorems -/ + +/-- +info: @derivation_sound : ∀ {F : Type} {rom : WireROM F} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {system : Circuit.System F}, + Circuit.compile program = Except.ok system → + ∀ {message : Circuit.Message F} (derivation : Circuit.Derivation system rom message), + Circuit.Message.Evaluates program rom message +-/ +#guard_msgs in +#check @Aiur.derivation_sound +/-- info: 'Aiur.derivation_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.derivation_sound + +/-- +info: @compiler_sound : ∀ {F : Type} {rom : WireROM F} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {system : Circuit.System F}, + Circuit.compile program = Except.ok system → + ∀ {name : String} {args : List (WireValue F)} {result : WireValue F}, + Circuit.CircuitEvaluates system rom name args result → + ∀ {values : List (Value F)} {value : Value F}, + DecodesValues program.enums args values → + WireValue.decode program.enums result = some value → + ROMEvalCall (WireROM.decode program.enums rom) program name values value +-/ +#guard_msgs in +#check @Aiur.compiler_sound +/-- info: 'Aiur.compiler_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.compiler_sound + +/-- +info: @evaluation_complete : ∀ {F : Type} {rom : WireROM F} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {system : Circuit.System F}, + Circuit.compile program = Except.ok system → + ∀ {name : String} {args : List (Value F)} {result : Value F}, + ROMEvalCall (WireROM.decode program.enums rom) program name args result → + Circuit.EncodedEvaluates program.enums system rom name args result +-/ +#guard_msgs in +#check @Aiur.evaluation_complete +/-- info: 'Aiur.evaluation_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evaluation_complete + +/-- +info: @compiler_correct : ∀ {F : Type} {rom : WireROM F} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {system : Circuit.System F}, + Circuit.compile program = Except.ok system → + ∀ {name : String} {args : List (Value F)} {result : Value F}, + ROMEvalCall (WireROM.decode program.enums rom) program name args result ↔ + Circuit.EncodedEvaluates program.enums system rom name args result +-/ +#guard_msgs in +#check @Aiur.compiler_correct +/-- info: 'Aiur.compiler_correct' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.compiler_correct + +/-- +info: @memo_acyclic_sound : ∀ {F : Type} {rom : WireROM F} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {system : Circuit.System F}, + Circuit.compile program = Except.ok system → + ∀ {message : Circuit.Message F} (graph : Circuit.MemoDerivation system rom message), + graph.Acyclic → Circuit.Message.Evaluates program rom message +-/ +#guard_msgs in +#check @Aiur.memo_acyclic_sound +/-- info: 'Aiur.memo_acyclic_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.memo_acyclic_sound + +/-- +info: @compiler_heap_complete : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {system : Circuit.System F}, + Circuit.compile program = Except.ok system → + ∀ {name : String} {args : List (SourceValue F)} {value : SourceValue F} {heap : Heap F}, + checkEntry program name = Except.ok () → + EvalFn program name args [] value heap → + ∀ (encode : ℕ → F), + (∀ (i j : ℕ), i < List.length heap → j < List.length heap → encode i = encode j → i = j) → + Circuit.EncodedEntryDerives system name (entryValues args) (Value.mapAddress encode value) +-/ +#guard_msgs in +#check @Aiur.compiler_heap_complete +/-- info: 'Aiur.compiler_heap_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.compiler_heap_complete + +/-- +info: @compiler_heap_complete_finite : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] [inst_2 : Fintype F] + {program : Program F} {system : Circuit.System F}, + Circuit.compile program = Except.ok system → + ∀ {name : String} {args : List (SourceValue F)} {value : SourceValue F} {heap : Heap F}, + checkEntry program name = Except.ok () → + EvalFn program name args [] value heap → + List.length heap ≤ Fintype.card F → + ∃ encode, Circuit.EncodedEntryDerives system name (entryValues args) (Value.mapAddress encode value) +-/ +#guard_msgs in +#check @Aiur.compiler_heap_complete_finite +/-- info: 'Aiur.compiler_heap_complete_finite' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.compiler_heap_complete_finite + +/-- +info: @compiler_run_complete : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] [inst_2 : Fintype F] + {program : Program F} {system : Circuit.System F}, + Circuit.compile program = Except.ok system → + ∀ {name : String} {args : List (SourceValue F)} {fuel : ℕ} {value : SourceValue F} {heap : Heap F} + {hints : HintProvider F program.enums}, + run program name args fuel hints = Except.ok (value, heap) → + List.length heap ≤ Fintype.card F → + ∃ encode, Circuit.EncodedEntryDerives system name (entryValues args) (Value.mapAddress encode value) +-/ +#guard_msgs in +#check @Aiur.compiler_run_complete +/-- info: 'Aiur.compiler_run_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.compiler_run_complete + +/-- +info: @memo_run_complete : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] [inst_2 : Fintype F] {program : Program F} + {system : Circuit.System F}, + Circuit.compile program = Except.ok system → + ∀ {name : String} {args : List (SourceValue F)} {fuel : ℕ} {value : SourceValue F} {heap : Heap F} + {hints : HintProvider F program.enums}, + run program name args fuel hints = Except.ok (value, heap) → + List.length heap ≤ Fintype.card F → + ∃ encode, Circuit.EncodedMemoEntryDerives system name (entryValues args) (Value.mapAddress encode value) +-/ +#guard_msgs in +#check @Aiur.memo_run_complete +/-- info: 'Aiur.memo_run_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.memo_run_complete + +/-- +info: @compiler_heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {system : Circuit.System F}, + Circuit.compile program = Except.ok system → + ∀ {rom : WireROM F}, + rom.Valid → + ∀ {name : String} {args : List (SourceValue F)} {result : Value F}, + checkEntry program name = Except.ok () → + ∀ {wires : List (WireValue F)} {output : WireValue F}, + Circuit.CircuitEvaluates system rom name wires output → + DecodesValues program.enums wires (entryValues args) → + WireValue.decode program.enums output = some result → + ∃ source heap, + EvalFn program name args [] source heap ∧ + Represents (WireROM.decode program.enums rom) heap source result +-/ +#guard_msgs in +#check @Aiur.compiler_heap_sound +/-- info: 'Aiur.compiler_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.compiler_heap_sound + +/-- +info: @compiler_entry_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {system : Circuit.System F}, + Circuit.compile program = Except.ok system → + ∀ {name : String} {args : List (SourceValue F)} {result : Value F}, + Circuit.EncodedEntryDerives system name (entryValues args) result → + result.pointerFree = true → EvalCall program name args (Value.mapAddress (fun x => 0) result) +-/ +#guard_msgs in +#check @Aiur.compiler_entry_sound +/-- info: 'Aiur.compiler_entry_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.compiler_entry_sound + +/-- +info: @memo_acyclic_heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {system : Circuit.System F}, + Circuit.compile program = Except.ok system → + ∀ {rom : WireROM F}, + rom.Valid → + ∀ {name : String} {args : List (SourceValue F)} {result : Value F}, + checkEntry program name = Except.ok () → + ∀ {wires : List (WireValue F)} {output : WireValue F} + (graph : Circuit.MemoDerivation system rom { channel := name, args := wires, result := output }), + graph.Acyclic → + DecodesValues program.enums wires (entryValues args) → + WireValue.decode program.enums output = some result → + ∃ source heap, + EvalFn program name args [] source heap ∧ + Represents (WireROM.decode program.enums rom) heap source result +-/ +#guard_msgs in +#check @Aiur.memo_acyclic_heap_sound +/-- info: 'Aiur.memo_acyclic_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.memo_acyclic_heap_sound + +/-- +info: @checker_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {system : Circuit.System F}, + Circuit.compile program = Except.ok system → + ∀ {rom : WireROM F} {message : Circuit.Message F} {rows : List (Circuit.Row F)}, + system.check rom message rows = Except.ok () → Circuit.Message.Evaluates program rom message +-/ +#guard_msgs in +#check @Aiur.checker_sound +/-- info: 'Aiur.checker_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.checker_sound + +/-- +info: @checker_heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {system : Circuit.System F}, + Circuit.compile program = Except.ok system → + ∀ {rom : WireROM F} {name : String} {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} + {output : WireValue F} {rows : List (Circuit.Row F)}, + system.check rom { channel := name, args := wires, result := output } rows = Except.ok () → + checkEntry program name = Except.ok () → + DecodesValues program.enums wires (entryValues args) → + WireValue.decode program.enums output = some result → + ∃ source heap, + EvalFn program name args [] source heap ∧ + Represents (WireROM.decode program.enums rom) heap source result +-/ +#guard_msgs in +#check @Aiur.checker_heap_sound +/-- info: 'Aiur.checker_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.checker_heap_sound + +/-- +info: @checker_run_complete : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] [inst_2 : Fintype F] + {program : Program F} {system : Circuit.System F}, + Circuit.compile program = Except.ok system → + system.WellFormed → + ∀ {name : String} {args : List (SourceValue F)} {fuel : ℕ} {value : SourceValue F} {heap : Heap F} + {hints : HintProvider F program.enums}, + run program name args fuel hints = Except.ok (value, heap) → + List.length heap ≤ Fintype.card F → + ∃ encode wires output rom rows, + DecodesValues system.enums wires (entryValues args) ∧ + WireValue.decode system.enums output = some (Value.mapAddress encode value) ∧ + system.check rom { channel := name, args := wires, result := output } rows = Except.ok () +-/ +#guard_msgs in +#check @Aiur.checker_run_complete +/-- info: 'Aiur.checker_run_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.checker_run_complete + +/-- +info: @checkerMemo_run_complete : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] [inst_2 : Fintype F] + {program : Program F} {system : Circuit.System F}, + Circuit.compile program = Except.ok system → + system.WellFormed → + ∀ {name : String} {args : List (SourceValue F)} {fuel : ℕ} {value : SourceValue F} {heap : Heap F} + {hints : HintProvider F program.enums}, + run program name args fuel hints = Except.ok (value, heap) → + List.length heap ≤ Fintype.card F → + ∃ encode wires output rom rows, + DecodesValues system.enums wires (entryValues args) ∧ + WireValue.decode system.enums output = some (Value.mapAddress encode value) ∧ + system.checkMemo rom { channel := name, args := wires, result := output } rows = Except.ok () +-/ +#guard_msgs in +#check @Aiur.checkerMemo_run_complete +/-- info: 'Aiur.checkerMemo_run_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.checkerMemo_run_complete + +/-- +info: @checkerMemo_acyclic_heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {system : Circuit.System F}, + Circuit.compile program = Except.ok system → + ∀ {rom : WireROM F} {name : String} {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} + {output : WireValue F} {rows : List (Circuit.WeightedRow F)} + (checked : system.checkMemo rom { channel := name, args := wires, result := output } rows = Except.ok ()), + (Classical.choice ⋯).Acyclic → + checkEntry program name = Except.ok () → + DecodesValues program.enums wires (entryValues args) → + WireValue.decode program.enums output = some result → + ∃ source heap, + EvalFn program name args [] source heap ∧ + Represents (WireROM.decode program.enums rom) heap source result +-/ +#guard_msgs in +#check @Aiur.checkerMemo_acyclic_heap_sound +/-- info: 'Aiur.checkerMemo_acyclic_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.checkerMemo_acyclic_heap_sound + +/-! ### 2. Generic Source Specialization and Inlining Theorems -/ + +/-- +info: @Generic.Specialized.native_entry_iff : ∀ {F : Type} {entries : List String} {name : String} + {args : List (SourceValue F)} {result : SourceValue F} {heap : Heap F} [inst : Field F] [inst_1 : DecidableEq F] + {s : Generic.Source F} (q : Generic.Specialized s entries), + name ∈ entries → + (Generic.SourceSemantics.EvalFn s.world name args [] result heap ↔ EvalFn q.program name args [] result heap) +-/ +#guard_msgs in +#check @Aiur.Generic.Specialized.native_entry_iff +/-- info: 'Aiur.Generic.Specialized.native_entry_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Specialized.native_entry_iff + +/-- +info: @Generic.Specialized.native_evalCall_iff : ∀ {F : Type} {entries : List String} {name : String} + {args : List (SourceValue F)} {result : SourceValue F} [inst : Field F] [inst_1 : DecidableEq F] + {s : Generic.Source F} (q : Generic.Specialized s entries), + name ∈ entries → (s.EvalCall name args result ↔ EvalCall q.program name args result) +-/ +#guard_msgs in +#check @Aiur.Generic.Specialized.native_evalCall_iff +/-- info: 'Aiur.Generic.Specialized.native_evalCall_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Specialized.native_evalCall_iff + +/-- +info: @Generic.Specialized.heap_complete : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {s : Generic.Source F} + {entries : List String} {name : String} {args : List (SourceValue F)} {value : SourceValue F} {heap : Heap F} + (q : Generic.Specialized s entries), + name ∈ entries → + ∀ {system : Circuit.System F}, + Circuit.compile q.program = Except.ok system → + Generic.SourceSemantics.EvalFn s.world name args [] value heap → + ∀ (encode : ℕ → F), + (∀ (i j : ℕ), i < List.length heap → j < List.length heap → encode i = encode j → i = j) → + Circuit.EncodedEntryDerives system name (entryValues args) (Value.mapAddress encode value) +-/ +#guard_msgs in +#check @Aiur.Generic.Specialized.heap_complete +/-- info: 'Aiur.Generic.Specialized.heap_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Specialized.heap_complete + +/-- +info: @Generic.Specialized.heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {s : Generic.Source F} + {entries : List String} {name : String} (q : Generic.Specialized s entries), + name ∈ entries → + ∀ {system : Circuit.System F}, + Circuit.compile q.program = Except.ok system → + ∀ {rom : WireROM F}, + rom.Valid → + ∀ {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F}, + Circuit.CircuitEvaluates system rom name wires output → + DecodesValues q.program.enums wires (entryValues args) → + WireValue.decode q.program.enums output = some result → + ∃ value heap, + Generic.SourceSemantics.EvalFn s.world name args [] value heap ∧ + Represents (WireROM.decode q.program.enums rom) heap value result +-/ +#guard_msgs in +#check @Aiur.Generic.Specialized.heap_sound +/-- info: 'Aiur.Generic.Specialized.heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Specialized.heap_sound + +/-- +info: @Generic.Specialized.memo_acyclic_heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {s : Generic.Source F} {entries : List String} {name : String} (q : Generic.Specialized s entries), + name ∈ entries → + ∀ {system : Circuit.System F}, + Circuit.compile q.program = Except.ok system → + ∀ {rom : WireROM F}, + rom.Valid → + ∀ {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F} + (graph : Circuit.MemoDerivation system rom { channel := name, args := wires, result := output }), + graph.Acyclic → + DecodesValues q.program.enums wires (entryValues args) → + WireValue.decode q.program.enums output = some result → + ∃ value heap, + Generic.SourceSemantics.EvalFn s.world name args [] value heap ∧ + Represents (WireROM.decode q.program.enums rom) heap value result +-/ +#guard_msgs in +#check @Aiur.Generic.Specialized.memo_acyclic_heap_sound +/-- info: 'Aiur.Generic.Specialized.memo_acyclic_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Specialized.memo_acyclic_heap_sound + +/-- +info: @Generic.Specialized.checker_heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {s : Generic.Source F} + {entries : List String} {name : String} (q : Generic.Specialized s entries), + name ∈ entries → + ∀ {system : Circuit.System F}, + Circuit.compile q.program = Except.ok system → + ∀ {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} + {output : WireValue F} {rows : List (Circuit.Row F)}, + system.check rom { channel := name, args := wires, result := output } rows = Except.ok () → + DecodesValues q.program.enums wires (entryValues args) → + WireValue.decode q.program.enums output = some result → + ∃ value heap, + Generic.SourceSemantics.EvalFn s.world name args [] value heap ∧ + Represents (WireROM.decode q.program.enums rom) heap value result +-/ +#guard_msgs in +#check @Aiur.Generic.Specialized.checker_heap_sound +/-- info: 'Aiur.Generic.Specialized.checker_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Specialized.checker_heap_sound + +/-- +info: @Generic.Specialized.checkerMemo_acyclic_heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {s : Generic.Source F} {entries : List String} {name : String} (q : Generic.Specialized s entries), + name ∈ entries → + ∀ {system : Circuit.System F}, + Circuit.compile q.program = Except.ok system → + ∀ {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} + {output : WireValue F} {rows : List (Circuit.WeightedRow F)} + (checked : system.checkMemo rom { channel := name, args := wires, result := output } rows = Except.ok ()), + (Classical.choice ⋯).Acyclic → + DecodesValues q.program.enums wires (entryValues args) → + WireValue.decode q.program.enums output = some result → + ∃ value heap, + Generic.SourceSemantics.EvalFn s.world name args [] value heap ∧ + Represents (WireROM.decode q.program.enums rom) heap value result +-/ +#guard_msgs in +#check @Aiur.Generic.Specialized.checkerMemo_acyclic_heap_sound +/-- info: 'Aiur.Generic.Specialized.checkerMemo_acyclic_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Specialized.checkerMemo_acyclic_heap_sound + +/-- +info: @Generic.Compiled.native_entry_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {s : Generic.Source F} + {entries : List String} {name : String} {args : List (SourceValue F)} {result : SourceValue F} {heap : Heap F} + {q : Generic.Specialized s entries} (c : Generic.Compiled q), + name ∈ entries → + (Generic.SourceSemantics.EvalFn s.world name args [] result heap ↔ EvalFn c.program name args [] result heap) +-/ +#guard_msgs in +#check @Aiur.Generic.Compiled.native_entry_iff +/-- info: 'Aiur.Generic.Compiled.native_entry_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Compiled.native_entry_iff + +/-- +info: @Generic.Compiled.heap_complete : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {s : Generic.Source F} + {entries : List String} {name : String} {args : List (SourceValue F)} {value : SourceValue F} {heap : Heap F} + {q : Generic.Specialized s entries} (c : Generic.Compiled q), + name ∈ entries → + Generic.SourceSemantics.EvalFn s.world name args [] value heap → + ∀ (encode : ℕ → F), + (∀ (i j : ℕ), i < List.length heap → j < List.length heap → encode i = encode j → i = j) → + Circuit.EncodedEntryDerives c.system name (entryValues args) (Value.mapAddress encode value) +-/ +#guard_msgs in +#check @Aiur.Generic.Compiled.heap_complete +/-- info: 'Aiur.Generic.Compiled.heap_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Compiled.heap_complete + +/-- +info: @Generic.Compiled.heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {s : Generic.Source F} + {entries : List String} {name : String} {q : Generic.Specialized s entries} (c : Generic.Compiled q), + name ∈ entries → + ∀ {rom : WireROM F}, + rom.Valid → + ∀ {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F}, + Circuit.CircuitEvaluates c.system rom name wires output → + DecodesValues q.program.enums wires (entryValues args) → + WireValue.decode q.program.enums output = some result → + ∃ value heap, + Generic.SourceSemantics.EvalFn s.world name args [] value heap ∧ + Represents (WireROM.decode q.program.enums rom) heap value result +-/ +#guard_msgs in +#check @Aiur.Generic.Compiled.heap_sound +/-- info: 'Aiur.Generic.Compiled.heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Compiled.heap_sound + +/-- +info: @Generic.Compiled.checker_heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {s : Generic.Source F} + {entries : List String} {name : String} {q : Generic.Specialized s entries} (c : Generic.Compiled q), + name ∈ entries → + ∀ {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} + {output : WireValue F} {rows : List (Circuit.Row F)}, + c.system.check rom { channel := name, args := wires, result := output } rows = Except.ok () → + DecodesValues q.program.enums wires (entryValues args) → + WireValue.decode q.program.enums output = some result → + ∃ value heap, + Generic.SourceSemantics.EvalFn s.world name args [] value heap ∧ + Represents (WireROM.decode q.program.enums rom) heap value result +-/ +#guard_msgs in +#check @Aiur.Generic.Compiled.checker_heap_sound +/-- info: 'Aiur.Generic.Compiled.checker_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Compiled.checker_heap_sound + +/-- +info: @Generic.Compiled.checkerMemo_acyclic_heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {s : Generic.Source F} {entries : List String} {name : String} {q : Generic.Specialized s entries} + (c : Generic.Compiled q), + name ∈ entries → + ∀ {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} + {output : WireValue F} {rows : List (Circuit.WeightedRow F)} + (checked : c.system.checkMemo rom { channel := name, args := wires, result := output } rows = Except.ok ()), + (Classical.choice ⋯).Acyclic → + DecodesValues q.program.enums wires (entryValues args) → + WireValue.decode q.program.enums output = some result → + ∃ value heap, + Generic.SourceSemantics.EvalFn s.world name args [] value heap ∧ + Represents (WireROM.decode q.program.enums rom) heap value result +-/ +#guard_msgs in +#check @Aiur.Generic.Compiled.checkerMemo_acyclic_heap_sound +/-- info: 'Aiur.Generic.Compiled.checkerMemo_acyclic_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Compiled.checkerMemo_acyclic_heap_sound + +/-- +info: @Generic.Compiled.check_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {s : Generic.Source F} + {entries : List String} {name : String} {q : Generic.Specialized s entries} (c : Generic.Compiled q) {rom : WireROM F} + {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F} + {rows : List (Circuit.Row F)}, + c.check rom { channel := name, args := wires, result := output } rows = Except.ok () → + DecodesValues q.program.enums wires (entryValues args) → + WireValue.decode q.program.enums output = some result → + ∃ value heap, s.EvalCall name args value ∧ Represents (WireROM.decode q.program.enums rom) heap value result +-/ +#guard_msgs in +#check @Aiur.Generic.Compiled.check_sound +/-- info: 'Aiur.Generic.Compiled.check_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Compiled.check_sound + +/-- +info: @Generic.Compiled.checkMemo_acyclic_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {s : Generic.Source F} {entries : List String} {name : String} {q : Generic.Specialized s entries} + (c : Generic.Compiled q) {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} + {wires : List (WireValue F)} {output : WireValue F} {rows : List (Circuit.WeightedRow F)} + (checked : c.checkMemo rom { channel := name, args := wires, result := output } rows = Except.ok ()), + (Classical.choice ⋯).Acyclic → + DecodesValues q.program.enums wires (entryValues args) → + WireValue.decode q.program.enums output = some result → + ∃ value heap, s.EvalCall name args value ∧ Represents (WireROM.decode q.program.enums rom) heap value result +-/ +#guard_msgs in +#check @Aiur.Generic.Compiled.checkMemo_acyclic_sound +/-- info: 'Aiur.Generic.Compiled.checkMemo_acyclic_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Compiled.checkMemo_acyclic_sound + +/-! ### 3. Optimized Backend, Physical Type Erasure, Grouping, Activation, and End-to-End Theorems -/ + +/-- +info: @Optimized.GenericArtifact.native_entry_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {source : Generic.Source F} {entries : List String} {args : List (SourceValue F)} {value : SourceValue F} + {heap : Heap F} {prepared : Generic.Specialized source entries} (compiled : Optimized.GenericArtifact prepared) + {name : String}, + name ∈ entries → + (Generic.SourceSemantics.EvalFn source.world name args [] value heap ↔ + EvalFn compiled.inlined.program name args [] value heap) +-/ +#guard_msgs in +#check @Aiur.Optimized.GenericArtifact.native_entry_iff +/-- info: 'Aiur.Optimized.GenericArtifact.native_entry_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.GenericArtifact.native_entry_iff + +/-- +info: @Optimized.GenericArtifact.heap_complete : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {source : Generic.Source F} {entries : List String} {prepared : Generic.Specialized source entries} + (compiled : Optimized.GenericArtifact prepared) {name : String}, + name ∈ entries → + ∀ {args : List (SourceValue F)} {value : SourceValue F} {heap : Heap F}, + Generic.SourceSemantics.EvalFn source.world name args [] value heap → + ∀ (encode : ℕ → F), + (∀ (i j : ℕ), i < List.length heap → j < List.length heap → encode i = encode j → i = j) → + Circuit.EncodedEntryDerives compiled.system name (entryValues args) (Value.mapAddress encode value) +-/ +#guard_msgs in +#check @Aiur.Optimized.GenericArtifact.heap_complete +/-- info: 'Aiur.Optimized.GenericArtifact.heap_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.GenericArtifact.heap_complete + +/-- +info: @Optimized.GenericArtifact.heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {source : Generic.Source F} {entries : List String} {prepared : Generic.Specialized source entries} + (compiled : Optimized.GenericArtifact prepared) {name : String}, + name ∈ entries → + ∀ {rom : WireROM F}, + rom.Valid → + ∀ {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F}, + Circuit.CircuitEvaluates compiled.system rom name wires output → + DecodesValues prepared.program.enums wires (entryValues args) → + WireValue.decode prepared.program.enums output = some result → + ∃ value heap, + Generic.SourceSemantics.EvalFn source.world name args [] value heap ∧ + Represents (WireROM.decode prepared.program.enums rom) heap value result +-/ +#guard_msgs in +#check @Aiur.Optimized.GenericArtifact.heap_sound +/-- info: 'Aiur.Optimized.GenericArtifact.heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.GenericArtifact.heap_sound + +/-- +info: @Optimized.GenericArtifact.checker_heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {source : Generic.Source F} {entries : List String} {prepared : Generic.Specialized source entries} + (compiled : Optimized.GenericArtifact prepared) {name : String}, + name ∈ entries → + ∀ {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} + {output : WireValue F} {rows : List (Circuit.Row F)}, + compiled.system.check rom { channel := name, args := wires, result := output } rows = Except.ok () → + DecodesValues prepared.program.enums wires (entryValues args) → + WireValue.decode prepared.program.enums output = some result → + ∃ value heap, + Generic.SourceSemantics.EvalFn source.world name args [] value heap ∧ + Represents (WireROM.decode prepared.program.enums rom) heap value result +-/ +#guard_msgs in +#check @Aiur.Optimized.GenericArtifact.checker_heap_sound +/-- info: 'Aiur.Optimized.GenericArtifact.checker_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.GenericArtifact.checker_heap_sound + +/-- +info: @Optimized.GenericArtifact.checkerMemo_acyclic_heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {source : Generic.Source F} {entries : List String} {prepared : Generic.Specialized source entries} + (compiled : Optimized.GenericArtifact prepared) {name : String}, + name ∈ entries → + ∀ {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} + {output : WireValue F} {rows : List (Circuit.WeightedRow F)} + (checked : + compiled.system.checkMemo rom { channel := name, args := wires, result := output } rows = Except.ok ()), + (Classical.choice ⋯).Acyclic → + DecodesValues prepared.program.enums wires (entryValues args) → + WireValue.decode prepared.program.enums output = some result → + ∃ value heap, + Generic.SourceSemantics.EvalFn source.world name args [] value heap ∧ + Represents (WireROM.decode prepared.program.enums rom) heap value result +-/ +#guard_msgs in +#check @Aiur.Optimized.GenericArtifact.checkerMemo_acyclic_heap_sound +/-- +info: 'Aiur.Optimized.GenericArtifact.checkerMemo_acyclic_heap_sound' depends on axioms: [propext, + Classical.choice, + Quot.sound] +-/ +#guard_msgs in +#print axioms Aiur.Optimized.GenericArtifact.checkerMemo_acyclic_heap_sound + +/-- +info: @Optimized.GenericArtifact.check_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {source : Generic.Source F} {entries : List String} {prepared : Generic.Specialized source entries} + (compiled : Optimized.GenericArtifact prepared) {name : String} {rom : WireROM F} {args : List (SourceValue F)} + {result : Value F} {wires : List (WireValue F)} {output : WireValue F} {rows : List (Circuit.Row F)}, + compiled.artifact.check rom { channel := name, args := wires, result := output } rows = Except.ok () → + DecodesValues prepared.program.enums wires (entryValues args) → + WireValue.decode prepared.program.enums output = some result → + ∃ value heap, + source.EvalCall name args value ∧ Represents (WireROM.decode prepared.program.enums rom) heap value result +-/ +#guard_msgs in +#check @Aiur.Optimized.GenericArtifact.check_sound +/-- info: 'Aiur.Optimized.GenericArtifact.check_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.GenericArtifact.check_sound + +/-- +info: @Optimized.ModulesArtifact.check_complete : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {name : String} + {args : List (SourceValue F)} {value : SourceValue F} {heap : Heap F} [inst_2 : Fintype F] + {program : Modules.Program F} {prepared : Modules.Prepared program} (compiled : Optimized.ModulesArtifact prepared), + prepared.EvalFn name args value heap → + List.length heap ≤ Fintype.card F → + ∃ encode wires output rom rows, + DecodesValues compiled.circuit.system.enums wires (entryValues args) ∧ + WireValue.decode compiled.circuit.system.enums output = some (Value.mapAddress encode value) ∧ + compiled.check rom name wires output rows = Except.ok () +-/ +#guard_msgs in +#check @Aiur.Optimized.ModulesArtifact.check_complete +/-- info: 'Aiur.Optimized.ModulesArtifact.check_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.ModulesArtifact.check_complete + +/-- +info: @Optimized.ModulesArtifact.checkMemo_complete : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {name : String} + {args : List (SourceValue F)} {value : SourceValue F} {heap : Heap F} [inst_2 : Fintype F] + {program : Modules.Program F} {prepared : Modules.Prepared program} (compiled : Optimized.ModulesArtifact prepared), + prepared.EvalFn name args value heap → + List.length heap ≤ Fintype.card F → + ∃ encode wires output rom rows, + DecodesValues compiled.circuit.system.enums wires (entryValues args) ∧ + WireValue.decode compiled.circuit.system.enums output = some (Value.mapAddress encode value) ∧ + compiled.checkMemo rom name wires output rows = Except.ok () +-/ +#guard_msgs in +#check @Aiur.Optimized.ModulesArtifact.checkMemo_complete +/-- info: 'Aiur.Optimized.ModulesArtifact.checkMemo_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.ModulesArtifact.checkMemo_complete + +/-- +info: @Optimized.ModulesArtifact.check_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {name : String} + {program : Modules.Program F} {prepared : Modules.Prepared program} (compiled : Optimized.ModulesArtifact prepared) + {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F} + {rows : List (Circuit.Row F)}, + compiled.check rom name wires output rows = Except.ok () → + DecodesValues compiled.specialized.program.enums wires (entryValues args) → + WireValue.decode compiled.specialized.program.enums output = some result → + ∃ value heap, + prepared.EvalCall name args value ∧ + Represents (WireROM.decode compiled.specialized.program.enums rom) heap value result +-/ +#guard_msgs in +#check @Aiur.Optimized.ModulesArtifact.check_sound +/-- info: 'Aiur.Optimized.ModulesArtifact.check_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.ModulesArtifact.check_sound + +/-- +info: @Optimized.ModulesArtifact.checkMemo_acyclic_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {name : String} {program : Modules.Program F} {prepared : Modules.Prepared program} + (compiled : Optimized.ModulesArtifact prepared) + {entry : Modules.Selection program prepared.environment.assembly.instances} + (selected : prepared.find? name = some entry) {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} + {wires : List (WireValue F)} {output : WireValue F} {rows : List (Circuit.WeightedRow F)} + (checked : compiled.checkMemo rom name wires output rows = Except.ok ()), + (Classical.choice ⋯).Acyclic → + DecodesValues compiled.specialized.program.enums wires (entryValues args) → + WireValue.decode compiled.specialized.program.enums output = some result → + ∃ value heap, + prepared.EvalCall name args value ∧ + Represents (WireROM.decode compiled.specialized.program.enums rom) heap value result +-/ +#guard_msgs in +#check @Aiur.Optimized.ModulesArtifact.checkMemo_acyclic_sound +/-- info: 'Aiur.Optimized.ModulesArtifact.checkMemo_acyclic_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.ModulesArtifact.checkMemo_acyclic_sound + +/-- +info: @Optimized.ModulesArtifact.physical_heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {program : Modules.Program F} {prepared : Modules.Prepared program} (compiled : Optimized.ModulesArtifact prepared) + (physical : Optimized.Physical.Prepared compiled.circuit.artifact) {external : String} + {entry : Modules.Selection program prepared.environment.assembly.instances}, + prepared.find? external = some entry → + ∀ {rom : WidthROM F}, + rom.Valid → + ∀ {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F}, + Circuit.Erasure.Signed compiled.circuit.system + { channel := entry.resolved.name, args := wires, result := output } → + Circuit.Derives physical.system (Circuit.Erasure.rawROM rom) + (Circuit.Erasure.message compiled.circuit.system + { channel := entry.resolved.name, args := wires, result := output }) → + DecodesValues compiled.specialized.program.enums wires (entryValues args) → + WireValue.decode compiled.specialized.program.enums output = some result → + ∃ value heap, + prepared.EvalFn external args value heap ∧ + Represents + (WireROM.decode compiled.specialized.program.enums + (Circuit.Erasure.typedROM compiled.circuit.system rom)) + heap value result +-/ +#guard_msgs in +#check @Aiur.Optimized.ModulesArtifact.physical_heap_sound +/-- info: 'Aiur.Optimized.ModulesArtifact.physical_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.ModulesArtifact.physical_heap_sound + +/-- +info: @Optimized.ModulesArtifact.grouped_heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {id : String → Except String ℕ} {program : Modules.Program F} {prepared : Modules.Prepared program} + (compiled : Optimized.ModulesArtifact prepared) (physical : Optimized.Physical.Prepared compiled.circuit.artifact) + (plan : Optimized.Grouping.Plan physical.system id) {external : String} + {entry : Modules.Selection program prepared.environment.assembly.instances}, + prepared.find? external = some entry → + ∀ {rom : WidthROM F}, + rom.Valid → + ∀ {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F}, + Circuit.Erasure.Signed compiled.circuit.system + { channel := entry.resolved.name, args := wires, result := output } → + plan.Derives (Circuit.Erasure.rawROM rom) + (Circuit.Erasure.message compiled.circuit.system + { channel := entry.resolved.name, args := wires, result := output }) → + DecodesValues compiled.specialized.program.enums wires (entryValues args) → + WireValue.decode compiled.specialized.program.enums output = some result → + ∃ value heap, + prepared.EvalFn external args value heap ∧ + Represents + (WireROM.decode compiled.specialized.program.enums + (Circuit.Erasure.typedROM compiled.circuit.system rom)) + heap value result +-/ +#guard_msgs in +#check @Aiur.Optimized.ModulesArtifact.grouped_heap_sound +/-- info: 'Aiur.Optimized.ModulesArtifact.grouped_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.ModulesArtifact.grouped_heap_sound + +/-- +info: @Optimized.ModulesArtifact.grouped_activated_heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {id : String → Except String ℕ} {program : Modules.Program F} {prepared : Modules.Prepared program} + (compiled : Optimized.ModulesArtifact prepared) (physical : Optimized.Physical.Prepared compiled.circuit.artifact) + (plan : Optimized.Grouping.Plan physical.system id), + plan.WellFormedActivation → + ∀ {external : String} {entry : Modules.Selection program prepared.environment.assembly.instances}, + prepared.find? external = some entry → + ∀ {rom : WidthROM F}, + rom.Valid → + ∀ {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F}, + Circuit.Erasure.Signed compiled.circuit.system + { channel := entry.resolved.name, args := wires, result := output } → + plan.ActivatedDerives (Circuit.Erasure.rawROM rom) + (Circuit.Erasure.message compiled.circuit.system + { channel := entry.resolved.name, args := wires, result := output }) → + DecodesValues compiled.specialized.program.enums wires (entryValues args) → + WireValue.decode compiled.specialized.program.enums output = some result → + ∃ value heap, + prepared.EvalFn external args value heap ∧ + Represents + (WireROM.decode compiled.specialized.program.enums + (Circuit.Erasure.typedROM compiled.circuit.system rom)) + heap value result +-/ +#guard_msgs in +#check @Aiur.Optimized.ModulesArtifact.grouped_activated_heap_sound +/-- info: 'Aiur.Optimized.ModulesArtifact.grouped_activated_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.ModulesArtifact.grouped_activated_heap_sound + +/-- +info: @Optimized.Physical.Prepared.derives_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {artifact : Optimized.Artifact F} (prepared : Optimized.Physical.Prepared artifact) {rom : WidthROM F} + {root : Circuit.Message F}, + root.channel ∈ artifact.entries → + Circuit.Erasure.Signed artifact.system root → + (Circuit.Derives artifact.system (Circuit.Erasure.typedROM artifact.system rom) root ↔ + Circuit.Derives prepared.system (Circuit.Erasure.rawROM rom) (Circuit.Erasure.message artifact.system root)) +-/ +#guard_msgs in +#check @Aiur.Optimized.Physical.Prepared.derives_iff +/-- info: 'Aiur.Optimized.Physical.Prepared.derives_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.Physical.Prepared.derives_iff + +/-- +info: @Optimized.Physical.Prepared.entry_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {entries : List String} {config : Optimized.Config} {artifact : Optimized.Artifact F}, + Optimized.compile program entries config = Except.ok artifact → + ∀ (prepared : Optimized.Physical.Prepared artifact) {rom : WidthROM F}, + rom.Valid → + ∀ {root : Circuit.Message F}, + root.channel ∈ entries → + Circuit.Erasure.Signed artifact.system root → + Circuit.Message.PublicArguments program.enums root → + Circuit.Derives prepared.system (Circuit.Erasure.rawROM rom) + (Circuit.Erasure.message artifact.system root) → + Circuit.Message.Evaluates program (Circuit.Erasure.typedROM artifact.system rom) root +-/ +#guard_msgs in +#check @Aiur.Optimized.Physical.Prepared.entry_sound +/-- info: 'Aiur.Optimized.Physical.Prepared.entry_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.Physical.Prepared.entry_sound + +/-- +info: @Optimized.Physical.Prepared.native_heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {source : Generic.Source F} {entries : List String} {specialized : Generic.Specialized source entries} + (compiled : Optimized.GenericArtifact specialized) (prepared : Optimized.Physical.Prepared compiled.artifact) + {name : String}, + name ∈ entries → + ∀ {rom : WidthROM F}, + rom.Valid → + ∀ {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F}, + Circuit.Erasure.Signed compiled.system { channel := name, args := wires, result := output } → + Circuit.Derives prepared.system (Circuit.Erasure.rawROM rom) + (Circuit.Erasure.message compiled.system { channel := name, args := wires, result := output }) → + DecodesValues specialized.program.enums wires (entryValues args) → + WireValue.decode specialized.program.enums output = some result → + ∃ value heap, + Generic.SourceSemantics.EvalFn source.world name args [] value heap ∧ + Represents + (WireROM.decode specialized.program.enums (Circuit.Erasure.typedROM compiled.system rom)) heap + value result +-/ +#guard_msgs in +#check @Aiur.Optimized.Physical.Prepared.native_heap_sound +/-- info: 'Aiur.Optimized.Physical.Prepared.native_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.Physical.Prepared.native_heap_sound + +/-- +info: @Optimized.Physical.Prepared.grouped_native_heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {id : String → Except String ℕ} {source : Generic.Source F} {entries : List String} + {specialized : Generic.Specialized source entries} (compiled : Optimized.GenericArtifact specialized) + (prepared : Optimized.Physical.Prepared compiled.artifact) (plan : Optimized.Grouping.Plan prepared.system id) + {name : String}, + name ∈ entries → + ∀ {rom : WidthROM F}, + rom.Valid → + ∀ {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F}, + Circuit.Erasure.Signed compiled.system { channel := name, args := wires, result := output } → + plan.Derives (Circuit.Erasure.rawROM rom) + (Circuit.Erasure.message compiled.system { channel := name, args := wires, result := output }) → + DecodesValues specialized.program.enums wires (entryValues args) → + WireValue.decode specialized.program.enums output = some result → + ∃ value heap, + Generic.SourceSemantics.EvalFn source.world name args [] value heap ∧ + Represents + (WireROM.decode specialized.program.enums (Circuit.Erasure.typedROM compiled.system rom)) heap + value result +-/ +#guard_msgs in +#check @Aiur.Optimized.Physical.Prepared.grouped_native_heap_sound +/-- info: 'Aiur.Optimized.Physical.Prepared.grouped_native_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.Physical.Prepared.grouped_native_heap_sound + +/-- +info: @Optimized.Physical.Prepared.grouped_activated_native_heap_sound : ∀ {F : Type} [inst : Field F] + [inst_1 : DecidableEq F] {id : String → Except String ℕ} {source : Generic.Source F} {entries : List String} + {specialized : Generic.Specialized source entries} (compiled : Optimized.GenericArtifact specialized) + (prepared : Optimized.Physical.Prepared compiled.artifact) (plan : Optimized.Grouping.Plan prepared.system id), + plan.WellFormedActivation → + ∀ {name : String}, + name ∈ entries → + ∀ {rom : WidthROM F}, + rom.Valid → + ∀ {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F}, + Circuit.Erasure.Signed compiled.system { channel := name, args := wires, result := output } → + plan.ActivatedDerives (Circuit.Erasure.rawROM rom) + (Circuit.Erasure.message compiled.system { channel := name, args := wires, result := output }) → + DecodesValues specialized.program.enums wires (entryValues args) → + WireValue.decode specialized.program.enums output = some result → + ∃ value heap, + Generic.SourceSemantics.EvalFn source.world name args [] value heap ∧ + Represents + (WireROM.decode specialized.program.enums (Circuit.Erasure.typedROM compiled.system rom)) + heap value result +-/ +#guard_msgs in +#check @Aiur.Optimized.Physical.Prepared.grouped_activated_native_heap_sound +/-- +info: 'Aiur.Optimized.Physical.Prepared.grouped_activated_native_heap_sound' depends on axioms: [propext, + Classical.choice, + Quot.sound] +-/ +#guard_msgs in +#print axioms Aiur.Optimized.Physical.Prepared.grouped_activated_native_heap_sound + +/-- +info: @Optimized.Grouping.Plan.localRule_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {id : String → Except String ℕ} {source : Circuit.System F} (plan : Optimized.Grouping.Plan source id) + (rom : WireROM F) (root : Circuit.Message F) (premises : List (Circuit.Message F)), + plan.LocalRule rom root premises ↔ ∃ c, source.findChip? c.name = some c ∧ c.LocalRule rom root premises +-/ +#guard_msgs in +#check @Aiur.Optimized.Grouping.Plan.localRule_iff +/-- info: 'Aiur.Optimized.Grouping.Plan.localRule_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.Grouping.Plan.localRule_iff + +/-- +info: @Optimized.Grouping.Plan.derives_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {id : String → Except String ℕ} {source : Circuit.System F} (plan : Optimized.Grouping.Plan source id) + {rom : WireROM F} {root : Circuit.Message F}, plan.Derives rom root → Circuit.Derives source rom root +-/ +#guard_msgs in +#check @Aiur.Optimized.Grouping.Plan.derives_sound +/-- info: 'Aiur.Optimized.Grouping.Plan.derives_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.Grouping.Plan.derives_sound + +/-- +info: @Optimized.Grouping.Plan.derives_complete : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {id : String → Except String ℕ} {source : Circuit.System F} (plan : Optimized.Grouping.Plan source id) + {rom : WireROM F} {root : Circuit.Message F}, Circuit.Derives source rom root → plan.Derives rom root +-/ +#guard_msgs in +#check @Aiur.Optimized.Grouping.Plan.derives_complete +/-- info: 'Aiur.Optimized.Grouping.Plan.derives_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.Grouping.Plan.derives_complete + +/-- +info: @Optimized.Grouping.Plan.derives_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {id : String → Except String ℕ} {source : Circuit.System F} (plan : Optimized.Grouping.Plan source id) + {rom : WireROM F} {root : Circuit.Message F}, plan.Derives rom root ↔ Circuit.Derives source rom root +-/ +#guard_msgs in +#check @Aiur.Optimized.Grouping.Plan.derives_iff +/-- info: 'Aiur.Optimized.Grouping.Plan.derives_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.Grouping.Plan.derives_iff + +/-- +info: @Optimized.Grouping.Plan.activatedLocalRule_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {source : Circuit.System F} {id : String → Except String ℕ} (plan : Optimized.Grouping.Plan source id), + plan.WellFormedActivation → + ∀ (rom : WireROM F) (root : Circuit.Message F) (premises : List (Circuit.Message F)), + plan.ActivatedLocalRule rom root premises ↔ plan.LocalRule rom root premises +-/ +#guard_msgs in +#check @Aiur.Optimized.Grouping.Plan.activatedLocalRule_iff +/-- info: 'Aiur.Optimized.Grouping.Plan.activatedLocalRule_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.Grouping.Plan.activatedLocalRule_iff + +/-- +info: @Optimized.Grouping.Plan.activatedDerives_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {source : Circuit.System F} {id : String → Except String ℕ} (plan : Optimized.Grouping.Plan source id), + plan.WellFormedActivation → + ∀ {rom : WireROM F} {root : Circuit.Message F}, plan.ActivatedDerives rom root → Circuit.Derives source rom root +-/ +#guard_msgs in +#check @Aiur.Optimized.Grouping.Plan.activatedDerives_sound +/-- info: 'Aiur.Optimized.Grouping.Plan.activatedDerives_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.Grouping.Plan.activatedDerives_sound + +/-- +info: @Optimized.Grouping.Plan.activatedDerives_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {source : Circuit.System F} {id : String → Except String ℕ} (plan : Optimized.Grouping.Plan source id), + plan.WellFormedActivation → + ∀ {rom : WireROM F} {root : Circuit.Message F}, plan.ActivatedDerives rom root ↔ plan.Derives rom root +-/ +#guard_msgs in +#check @Aiur.Optimized.Grouping.Plan.activatedDerives_iff +/-- info: 'Aiur.Optimized.Grouping.Plan.activatedDerives_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.Grouping.Plan.activatedDerives_iff + +/-- +info: @Optimized.Activation.active_rule_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] (chip : Circuit.Chip F), + chip.wellFormed = true → + (Optimized.Activation.compile chip).wellFormed = true → + ∀ (rom : WireROM F) (root : Circuit.Message F) (premises : List (Circuit.Message F)), + (∃ row, + row.chip = chip.name ∧ + (Optimized.Activation.compile chip).ValidRow rom row ∧ + row.assignment chip.numVars = 1 ∧ + (Optimized.Activation.compile chip).receive row = root ∧ + (Optimized.Activation.compile chip).premises row = premises) ↔ + chip.LocalRule rom root premises +-/ +#guard_msgs in +#check @Aiur.Optimized.Activation.active_rule_iff +/-- info: 'Aiur.Optimized.Activation.active_rule_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.Activation.active_rule_iff + +/-- +info: @Optimized.Activation.activeRule_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] (chip : Circuit.Chip F), + chip.wellFormed = true → + (Optimized.Activation.compile chip).wellFormed = true → + ∀ (rom : WireROM F) (root : Circuit.Message F) (premises : List (Circuit.Message F)), + Optimized.Activation.ActiveRule chip rom root premises ↔ chip.LocalRule rom root premises +-/ +#guard_msgs in +#check @Aiur.Optimized.Activation.activeRule_iff +/-- info: 'Aiur.Optimized.Activation.activeRule_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Optimized.Activation.activeRule_iff + +/-- +info: @Modules.Prepared.physical_heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {program : Modules.Program F} (prepared : Modules.Prepared program) (compiled : Optimized.ModulesArtifact prepared) + (physical : Optimized.Physical.Prepared compiled.circuit.artifact) {external : String} + {entry : Modules.Selection program prepared.environment.assembly.instances}, + prepared.find? external = some entry → + ∀ {rom : WidthROM F}, + rom.Valid → + ∀ {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F}, + Circuit.Erasure.Signed compiled.circuit.system + { channel := entry.resolved.name, args := wires, result := output } → + Circuit.Derives physical.system (Circuit.Erasure.rawROM rom) + (Circuit.Erasure.message compiled.circuit.system + { channel := entry.resolved.name, args := wires, result := output }) → + DecodesValues compiled.specialized.program.enums wires (entryValues args) → + WireValue.decode compiled.specialized.program.enums output = some result → + ∃ value heap, + prepared.EvalFn external args value heap ∧ + Represents + (WireROM.decode compiled.specialized.program.enums + (Circuit.Erasure.typedROM compiled.circuit.system rom)) + heap value result +-/ +#guard_msgs in +#check @Aiur.Modules.Prepared.physical_heap_sound +/-- info: 'Aiur.Modules.Prepared.physical_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Modules.Prepared.physical_heap_sound + +/-- +info: @Modules.Prepared.grouped_heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {id : String → Except String ℕ} {program : Modules.Program F} (prepared : Modules.Prepared program) + (compiled : Optimized.ModulesArtifact prepared) (physical : Optimized.Physical.Prepared compiled.circuit.artifact) + (plan : Optimized.Grouping.Plan physical.system id) {external : String} + {entry : Modules.Selection program prepared.environment.assembly.instances}, + prepared.find? external = some entry → + ∀ {rom : WidthROM F}, + rom.Valid → + ∀ {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F}, + Circuit.Erasure.Signed compiled.circuit.system + { channel := entry.resolved.name, args := wires, result := output } → + plan.Derives (Circuit.Erasure.rawROM rom) + (Circuit.Erasure.message compiled.circuit.system + { channel := entry.resolved.name, args := wires, result := output }) → + DecodesValues compiled.specialized.program.enums wires (entryValues args) → + WireValue.decode compiled.specialized.program.enums output = some result → + ∃ value heap, + prepared.EvalFn external args value heap ∧ + Represents + (WireROM.decode compiled.specialized.program.enums + (Circuit.Erasure.typedROM compiled.circuit.system rom)) + heap value result +-/ +#guard_msgs in +#check @Aiur.Modules.Prepared.grouped_heap_sound +/-- info: 'Aiur.Modules.Prepared.grouped_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Modules.Prepared.grouped_heap_sound + +/-- +info: @Modules.Prepared.grouped_activated_heap_sound : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {id : String → Except String ℕ} {program : Modules.Program F} (prepared : Modules.Prepared program) + (compiled : Optimized.ModulesArtifact prepared) (physical : Optimized.Physical.Prepared compiled.circuit.artifact) + (plan : Optimized.Grouping.Plan physical.system id), + plan.WellFormedActivation → + ∀ {external : String} {entry : Modules.Selection program prepared.environment.assembly.instances}, + prepared.find? external = some entry → + ∀ {rom : WidthROM F}, + rom.Valid → + ∀ {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F}, + Circuit.Erasure.Signed compiled.circuit.system + { channel := entry.resolved.name, args := wires, result := output } → + plan.ActivatedDerives (Circuit.Erasure.rawROM rom) + (Circuit.Erasure.message compiled.circuit.system + { channel := entry.resolved.name, args := wires, result := output }) → + DecodesValues compiled.specialized.program.enums wires (entryValues args) → + WireValue.decode compiled.specialized.program.enums output = some result → + ∃ value heap, + prepared.EvalFn external args value heap ∧ + Represents + (WireROM.decode compiled.specialized.program.enums + (Circuit.Erasure.typedROM compiled.circuit.system rom)) + heap value result +-/ +#guard_msgs in +#check @Aiur.Modules.Prepared.grouped_activated_heap_sound +/-- info: 'Aiur.Modules.Prepared.grouped_activated_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Modules.Prepared.grouped_activated_heap_sound + +/-! ### 4. Standard Library: Carry, U8, U32, U64, Blake3, and Goldilocks -/ + +/-- +info: @Library.Carry.recover : ∀ {F : Type} [inst : Field F] (base n : ℕ), + ↑base ≠ 0 → (↑n - ↑(n % base)) / ↑base = ↑(n / base) +-/ +#guard_msgs in +#check @Aiur.Library.Carry.recover +/-- info: 'Aiur.Library.Carry.recover' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Carry.recover + +/-- +info: @Library.Carry.fullRows_iff : ∀ {F : Type} [inst : Field F] (base count : ℕ), + ↑base ≠ 0 → + ∀ (input byte carry : F), + (input, byte, carry) ∈ Library.Carry.fullRows F base count ↔ + (input, byte) ∈ Library.Carry.fieldRows F base count ∧ carry = (input - byte) / ↑base +-/ +#guard_msgs in +#check @Aiur.Library.Carry.fullRows_iff +/-- info: 'Aiur.Library.Carry.fullRows_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Carry.fullRows_iff + +/-- +info: @Library.Carry.mapEntries_iff : ∀ {F : Type} [inst : Field F] (base count : ℕ), + ↑base ≠ 0 → + ∀ (input byte carry : F), + { args := [Value.field input], result := Value.tuple [Value.field byte, Value.field carry] } ∈ + List.map + (fun x => + match x with + | (x, lo, hi) => { args := [Value.field x], result := Value.tuple [Value.field lo, Value.field hi] }) + (Library.Carry.fullRows F base count) ↔ + { args := [Value.field input], result := Value.field byte } ∈ + List.map + (fun x => + match x with + | (x, lo) => { args := [Value.field x], result := Value.field lo }) + (Library.Carry.fieldRows F base count) ∧ + carry = (input - byte) / ↑base +-/ +#guard_msgs in +#check @Aiur.Library.Carry.mapEntries_iff +/-- info: 'Aiur.Library.Carry.mapEntries_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Carry.mapEntries_iff + +/-- info: Library.U8.nat_xor_and_sum : ∀ (n m : ℕ), n + m = n.xor m + 2 * n.land m -/ +#guard_msgs in +#check @Aiur.Library.U8.nat_xor_and_sum +/-- info: 'Aiur.Library.U8.nat_xor_and_sum' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U8.nat_xor_and_sum + +/-- info: Library.U8.nat_xor_or_sum : ∀ (n m : ℕ), 2 * n.lor m = n + m + n.xor m -/ +#guard_msgs in +#check @Aiur.Library.U8.nat_xor_or_sum +/-- info: 'Aiur.Library.U8.nat_xor_or_sum' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U8.nat_xor_or_sum + +/-- info: Library.U8.xor_and_sum : ∀ (a b : BitVec 8), a.toNat + b.toNat = (a ^^^ b).toNat + 2 * (a &&& b).toNat -/ +#guard_msgs in +#check @Aiur.Library.U8.xor_and_sum +/-- info: 'Aiur.Library.U8.xor_and_sum' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U8.xor_and_sum + +/-- info: Library.U8.xor_or_sum : ∀ (a b : BitVec 8), 2 * (a ||| b).toNat = a.toNat + b.toNat + (a ^^^ b).toNat -/ +#guard_msgs in +#check @Aiur.Library.U8.xor_or_sum +/-- info: 'Aiur.Library.U8.xor_or_sum' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U8.xor_or_sum + +/-- +info: @Library.U8.and_field : ∀ {F : Type u_1} [inst : Field F], + 2 ≠ 0 → ∀ (a b : BitVec 8), (↑a.toNat + ↑b.toNat - ↑(a ^^^ b).toNat) / 2 = ↑(a &&& b).toNat +-/ +#guard_msgs in +#check @Aiur.Library.U8.and_field +/-- info: 'Aiur.Library.U8.and_field' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U8.and_field + +/-- +info: @Library.U8.or_field : ∀ {F : Type u_1} [inst : Field F], + 2 ≠ 0 → ∀ (a b : BitVec 8), (↑a.toNat + ↑b.toNat + ↑(a ^^^ b).toNat) / 2 = ↑(a ||| b).toNat +-/ +#guard_msgs in +#check @Aiur.Library.U8.or_field +/-- info: 'Aiur.Library.U8.or_field' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U8.or_field + +/-- info: @Library.U8Facts.xor_lt_256 : ∀ {a b : ℕ}, a < 256 → b < 256 → a.xor b < 256 -/ +#guard_msgs in +#check @Aiur.Library.U8Facts.xor_lt_256 +/-- info: 'Aiur.Library.U8Facts.xor_lt_256' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U8Facts.xor_lt_256 + +/-- info: Library.U8Facts.xor_and_identity : ∀ (a b : ℕ), a + b = a.xor b + 2 * a.land b -/ +#guard_msgs in +#check @Aiur.Library.U8Facts.xor_and_identity +/-- info: 'Aiur.Library.U8Facts.xor_and_identity' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U8Facts.xor_and_identity + +/-- info: Library.U8Facts.xor_or_identity : ∀ (a b : ℕ), 2 * a.lor b = a + b + a.xor b -/ +#guard_msgs in +#check @Aiur.Library.U8Facts.xor_or_identity +/-- info: 'Aiur.Library.U8Facts.xor_or_identity' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U8Facts.xor_or_identity + +/-- info: @Library.U8Facts.land_128_div : ∀ {a : ℕ}, a < 256 → a.land 128 / 128 = a / 128 -/ +#guard_msgs in +#check @Aiur.Library.U8Facts.land_128_div +/-- info: 'Aiur.Library.U8Facts.land_128_div' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U8Facts.land_128_div + +/-- +info: @Library.U32.add_check_iff : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {sum result : ℕ}, + sum < 2 * Library.U32.base → + result < Library.U32.base → + have carry := (↑sum - ↑result) / ↑Library.U32.base; + carry * (carry - 1) = 0 ↔ result = sum % Library.U32.base +-/ +#guard_msgs in +#check @Aiur.Library.U32.add_check_iff +/-- info: 'Aiur.Library.U32.add_check_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U32.add_check_iff + +/-- +info: @Library.U32.add3_check_iff : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {sum result : ℕ}, + sum < 3 * Library.U32.base → + result < Library.U32.base → + have carry := (↑sum - ↑result) / ↑Library.U32.base; + carry * (carry - 1) * (carry - 2) = 0 ↔ result = sum % Library.U32.base +-/ +#guard_msgs in +#check @Aiur.Library.U32.add3_check_iff +/-- info: 'Aiur.Library.U32.add3_check_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U32.add3_check_iff + +/-- +info: @Library.U32.add_words_check_iff : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {a b result : ℕ}, + a < Library.U32.base → + b < Library.U32.base → + result < Library.U32.base → + have carry := (↑a + ↑b - ↑result) / ↑Library.U32.base; + carry * (carry - 1) = 0 ↔ result = (a + b) % Library.U32.base +-/ +#guard_msgs in +#check @Aiur.Library.U32.add_words_check_iff +/-- info: 'Aiur.Library.U32.add_words_check_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U32.add_words_check_iff + +/-- +info: @Library.U32.add3_words_check_iff : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {a b c result : ℕ}, + a < Library.U32.base → + b < Library.U32.base → + c < Library.U32.base → + result < Library.U32.base → + have carry := (↑a + ↑b + ↑c - ↑result) / ↑Library.U32.base; + carry * (carry - 1) * (carry - 2) = 0 ↔ result = (a + b + c) % Library.U32.base +-/ +#guard_msgs in +#check @Aiur.Library.U32.add3_words_check_iff +/-- info: 'Aiur.Library.U32.add3_words_check_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U32.add3_words_check_iff + +/-- +info: @Library.U32.sub_sound : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {a b result : ℕ}, + a < Library.U32.base → + b < Library.U32.base → + result < Library.U32.base → + (have borrow := (↑result + ↑b - ↑a) / ↑Library.U32.base; + borrow * (borrow - 1) = 0) → + result = (a + Library.U32.base - b) % Library.U32.base ∧ + (↑result + ↑b - ↑a) / ↑Library.U32.base = if a < b then 1 else 0 +-/ +#guard_msgs in +#check @Aiur.Library.U32.sub_sound +/-- info: 'Aiur.Library.U32.sub_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U32.sub_sound + +/-- +info: @Library.U32.compare_fields_sound : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ (a b : F) {leftWord rightWord difference : ℕ}, + leftWord < Library.U32.base → + rightWord < Library.U32.base → + difference < Library.U32.base → + a = ↑leftWord → + b = ↑rightWord → + (have borrow := (↑difference + b - a) / ↑Library.U32.base; + borrow * (borrow - 1) = 0) → + (↑difference + b - a) / ↑Library.U32.base = if leftWord < rightWord then 1 else 0 +-/ +#guard_msgs in +#check @Aiur.Library.U32.compare_fields_sound +/-- info: 'Aiur.Library.U32.compare_fields_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U32.compare_fields_sound + +/-- info: Library.U32.Goldilocks.modulus_prime : Nat.Prime Library.U32.Goldilocks.modulus -/ +#guard_msgs in +#check @Aiur.Library.U32.Goldilocks.modulus_prime +/-- info: 'Aiur.Library.U32.Goldilocks.modulus_prime' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U32.Goldilocks.modulus_prime + +/-- info: Library.U32.Goldilocks.compatible : Library.U32.Compatible Library.U32.Goldilocks.F -/ +#guard_msgs in +#check @Aiur.Library.U32.Goldilocks.compatible +/-- info: 'Aiur.Library.U32.Goldilocks.compatible' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U32.Goldilocks.compatible + +/-- +info: @Library.U64.is_zero_sound : ∀ {F : Type} [inst : Field F], + Library.U64.Compatible F → + ∀ {b0 b1 b2 b3 b4 b5 b6 b7 : ℕ}, + b0 < 256 → + b1 < 256 → + b2 < 256 → + b3 < 256 → + b4 < 256 → + b5 < 256 → + b6 < 256 → + b7 < 256 → + (↑b0 = 0 ∧ ↑b1 = 0 ∧ ↑b2 = 0 ∧ ↑b3 = 0 ∧ ↑b4 = 0 ∧ ↑b5 = 0 ∧ ↑b6 = 0 ∧ ↑b7 = 0 ↔ + Library.U64.pack b0 b1 b2 b3 b4 b5 b6 b7 = 0) +-/ +#guard_msgs in +#check @Aiur.Library.U64.is_zero_sound +/-- info: 'Aiur.Library.U64.is_zero_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U64.is_zero_sound + +/-- +info: @Library.U64.eq_sound : ∀ {F : Type} [inst : Field F], + Library.U64.Compatible F → + ∀ {a0 a1 a2 a3 a4 a5 a6 a7 b0 b1 b2 b3 b4 b5 b6 b7 : ℕ}, + a0 < 256 → + a1 < 256 → + a2 < 256 → + a3 < 256 → + a4 < 256 → + a5 < 256 → + a6 < 256 → + a7 < 256 → + b0 < 256 → + b1 < 256 → + b2 < 256 → + b3 < 256 → + b4 < 256 → + b5 < 256 → + b6 < 256 → + b7 < 256 → + (↑a0 - ↑b0 = 0 ∧ + ↑a1 - ↑b1 = 0 ∧ + ↑a2 - ↑b2 = 0 ∧ + ↑a3 - ↑b3 = 0 ∧ + ↑a4 - ↑b4 = 0 ∧ ↑a5 - ↑b5 = 0 ∧ ↑a6 - ↑b6 = 0 ∧ ↑a7 - ↑b7 = 0 ↔ + Library.U64.pack a0 a1 a2 a3 a4 a5 a6 a7 = + Library.U64.pack b0 b1 b2 b3 b4 b5 b6 b7) +-/ +#guard_msgs in +#check @Aiur.Library.U64.eq_sound +/-- info: 'Aiur.Library.U64.eq_sound' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U64.eq_sound + +/-- +info: @Library.U64.add_sound : ∀ + {a0 a1 a2 a3 a4 a5 a6 a7 b0 b1 b2 b3 b4 b5 b6 b7 s0 s1 s2 s3 s4 s5 s6 s7 c1 c2 c3 c4 c5 c6 c7 c8 : ℕ}, + a0 < 256 → + a1 < 256 → + a2 < 256 → + a3 < 256 → + a4 < 256 → + a5 < 256 → + a6 < 256 → + a7 < 256 → + b0 < 256 → + b1 < 256 → + b2 < 256 → + b3 < 256 → + b4 < 256 → + b5 < 256 → + b6 < 256 → + b7 < 256 → + s0 < 256 → + s1 < 256 → + s2 < 256 → + s3 < 256 → + s4 < 256 → + s5 < 256 → + s6 < 256 → + s7 < 256 → + a0 + b0 = s0 + 256 * c1 → + a1 + b1 + c1 = s1 + 256 * c2 → + a2 + b2 + c2 = s2 + 256 * c3 → + a3 + b3 + c3 = s3 + 256 * c4 → + a4 + b4 + c4 = s4 + 256 * c5 → + a5 + b5 + c5 = s5 + 256 * c6 → + a6 + b6 + c6 = s6 + 256 * c7 → + a7 + b7 + c7 = s7 + 256 * c8 → + Library.U64.pack s0 s1 s2 s3 s4 s5 s6 s7 = + (Library.U64.pack a0 a1 a2 a3 a4 a5 a6 a7 + + Library.U64.pack b0 b1 b2 b3 b4 b5 b6 b7) % + Library.U64.base ∧ + c8 = + (Library.U64.pack a0 a1 a2 a3 a4 a5 a6 a7 + + Library.U64.pack b0 b1 b2 b3 b4 b5 b6 b7) / + Library.U64.base ∧ + c8 < 2 +-/ +#guard_msgs in +#check @Aiur.Library.U64.add_sound +/-- info: 'Aiur.Library.U64.add_sound' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U64.add_sound + +/-- +info: @Library.U64.wrapping_succ_sound : ∀ {b0 b1 b2 b3 b4 b5 b6 b7 : ℕ}, + b0 < 256 → + b1 < 256 → + b2 < 256 → + b3 < 256 → + b4 < 256 → + b5 < 256 → + b6 < 256 → + b7 < 256 → + match Library.U64.wrappingSuccBytes b0 b1 b2 b3 b4 b5 b6 b7 with + | (r0, r1, r2, r3, r4, r5, r6, r7) => + r0 < 256 ∧ + r1 < 256 ∧ + r2 < 256 ∧ + r3 < 256 ∧ + r4 < 256 ∧ + r5 < 256 ∧ + r6 < 256 ∧ + r7 < 256 ∧ + Library.U64.pack r0 r1 r2 r3 r4 r5 r6 r7 = + (Library.U64.pack b0 b1 b2 b3 b4 b5 b6 b7 + 1) % Library.U64.base +-/ +#guard_msgs in +#check @Aiur.Library.U64.wrapping_succ_sound +/-- info: 'Aiur.Library.U64.wrapping_succ_sound' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U64.wrapping_succ_sound + +/-- +info: @Library.U64.wrapping_succ_bytes_sound : ∀ {b0 b1 b2 b3 b4 b5 b6 b7 : ℕ}, + b0 < 256 → + b1 < 256 → + b2 < 256 → + b3 < 256 → + b4 < 256 → + b5 < 256 → + b6 < 256 → + b7 < 256 → + match Library.U64.wrappingSuccBytes b0 b1 b2 b3 b4 b5 b6 b7 with + | (r0, r1, r2, r3, r4, r5, r6, r7) => + r0 < 256 ∧ + r1 < 256 ∧ + r2 < 256 ∧ + r3 < 256 ∧ + r4 < 256 ∧ + r5 < 256 ∧ + r6 < 256 ∧ + r7 < 256 ∧ + Library.U64.pack r0 r1 r2 r3 r4 r5 r6 r7 = + (Library.U64.pack b0 b1 b2 b3 b4 b5 b6 b7 + 1) % Library.U64.base +-/ +#guard_msgs in +#check @Aiur.Library.U64.wrapping_succ_bytes_sound +/-- info: 'Aiur.Library.U64.wrapping_succ_bytes_sound' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U64.wrapping_succ_bytes_sound + +/-- +info: @Library.U64.saturating_pred_sound : ∀ {b0 b1 b2 b3 b4 b5 b6 b7 : ℕ}, + b0 < 256 → + b1 < 256 → + b2 < 256 → + b3 < 256 → + b4 < 256 → + b5 < 256 → + b6 < 256 → + b7 < 256 → + match Library.U64.saturatingPredBytes b0 b1 b2 b3 b4 b5 b6 b7 with + | (r0, r1, r2, r3, r4, r5, r6, r7) => + r0 < 256 ∧ + r1 < 256 ∧ + r2 < 256 ∧ + r3 < 256 ∧ + r4 < 256 ∧ + r5 < 256 ∧ + r6 < 256 ∧ + r7 < 256 ∧ + Library.U64.pack r0 r1 r2 r3 r4 r5 r6 r7 = + Library.U64.pack b0 b1 b2 b3 b4 b5 b6 b7 - 1 +-/ +#guard_msgs in +#check @Aiur.Library.U64.saturating_pred_sound +/-- info: 'Aiur.Library.U64.saturating_pred_sound' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U64.saturating_pred_sound + +/-- +info: @Library.U64.to_field_sound : ∀ {F : Type} [inst : Field F], + Library.U64.Compatible F → + ∀ {b0 b1 b2 b3 b4 b5 b6 b7 : ℕ}, + b0 < 256 → + b1 < 256 → + b2 < 256 → + b3 < 256 → + b4 < 256 → + b5 < 256 → + b6 < 256 → + b7 < 256 → + ↑b7 = 0 → + Library.U64.pack b0 b1 b2 b3 b4 b5 b6 b7 < Library.U64.fieldBound ∧ + ↑b0 + 256 * ↑b1 + 65536 * ↑b2 + 16777216 * ↑b3 + 4294967296 * ↑b4 + 1099511627776 * ↑b5 + + 281474976710656 * ↑b6 = + ↑(Library.U64.pack b0 b1 b2 b3 b4 b5 b6 b7) +-/ +#guard_msgs in +#check @Aiur.Library.U64.to_field_sound +/-- info: 'Aiur.Library.U64.to_field_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U64.to_field_sound + +/-- +info: @Library.U64.sub_with_borrow_sound : ∀ {F : Type} [inst : Field F] + {a0 a1 a2 a3 a4 a5 a6 a7 b0 b1 b2 b3 b4 b5 b6 b7 s0 s1 s2 s3 s4 s5 s6 s7 c1 c2 c3 c4 c5 c6 c7 c8 : ℕ}, + a0 < 256 → + a1 < 256 → + a2 < 256 → + a3 < 256 → + a4 < 256 → + a5 < 256 → + a6 < 256 → + a7 < 256 → + b0 < 256 → + b1 < 256 → + b2 < 256 → + b3 < 256 → + b4 < 256 → + b5 < 256 → + b6 < 256 → + b7 < 256 → + s0 < 256 → + s1 < 256 → + s2 < 256 → + s3 < 256 → + s4 < 256 → + s5 < 256 → + s6 < 256 → + s7 < 256 → + a0 + 256 - b0 = s0 + 256 * c1 → + a1 + 255 - b1 + c1 = s1 + 256 * c2 → + a2 + 255 - b2 + c2 = s2 + 256 * c3 → + a3 + 255 - b3 + c3 = s3 + 256 * c4 → + a4 + 255 - b4 + c4 = s4 + 256 * c5 → + a5 + 255 - b5 + c5 = s5 + 256 * c6 → + a6 + 255 - b6 + c6 = s6 + 256 * c7 → + a7 + 255 - b7 + c7 = s7 + 256 * c8 → + Library.U64.pack s0 s1 s2 s3 s4 s5 s6 s7 = + (Library.U64.pack a0 a1 a2 a3 a4 a5 a6 a7 + + Library.U64.base - + Library.U64.pack b0 b1 b2 b3 b4 b5 b6 b7) % + Library.U64.base ∧ + 1 - ↑c8 = + if + Library.U64.pack a0 a1 a2 a3 a4 a5 a6 a7 < + Library.U64.pack b0 b1 b2 b3 b4 b5 b6 + b7 then + 1 + else 0 +-/ +#guard_msgs in +#check @Aiur.Library.U64.sub_with_borrow_sound +/-- info: 'Aiur.Library.U64.sub_with_borrow_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U64.sub_with_borrow_sound + +/-- +info: @Library.U64.mul_column_sound : ∀ {F : Type} [inst : Field F], + Library.U64.Compatible F → + ∀ {val r0 r1 c0 c1 c2 : ℕ}, + val < Library.U64.fieldBound → + r0 < 256 → + r1 < 256 → + c0 < 256 → + c1 < 256 → + c2 < 256 → + ↑val = ↑r0 + 256 * ↑r1 + 65536 * (↑c0 + 256 * ↑c1 + 65536 * ↑c2) → + val = Library.U64.limb2 r0 r1 + 65536 * Library.U64.carry3 c0 c1 c2 ∧ + Library.U64.limb2 r0 r1 = val % 65536 ∧ Library.U64.carry3 c0 c1 c2 = val / 65536 +-/ +#guard_msgs in +#check @Aiur.Library.U64.mul_column_sound +/-- info: 'Aiur.Library.U64.mul_column_sound' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U64.mul_column_sound + +/-- +info: @Library.U64.mul_sound : ∀ + {a0 a1 a2 a3 a4 a5 a6 a7 b0 b1 b2 b3 b4 b5 b6 b7 r00 r01 r10 r11 r20 r21 r30 r31 r40 r41 r50 r51 r60 r61 c00 c01 c02 + c10 c11 c12 c20 c21 c22 c30 c31 c32 c40 c41 c42 c50 c51 c52 c60 c61 c62 : ℕ}, + r00 < 256 → + r01 < 256 → + r10 < 256 → + r11 < 256 → + r20 < 256 → + r21 < 256 → + r30 < 256 → + r31 < 256 → + r40 < 256 → + r41 < 256 → + r50 < 256 → + r51 < 256 → + r60 < 256 → + r61 < 256 → + c60 < 256 → + c61 < 256 → + Library.U64.limb2 a0 a1 * Library.U64.limb2 b0 b1 = + Library.U64.limb2 r00 r01 + 65536 * Library.U64.carry3 c00 c01 c02 → + Library.U64.limb2 a0 a1 * Library.U64.limb2 b2 b3 + + Library.U64.limb2 a2 a3 * Library.U64.limb2 b0 b1 + + Library.U64.carry3 c00 c01 c02 = + Library.U64.limb2 r10 r11 + 65536 * Library.U64.carry3 c10 c11 c12 → + Library.U64.limb2 a0 a1 * Library.U64.limb2 b4 b5 + + Library.U64.limb2 a2 a3 * Library.U64.limb2 b2 b3 + + Library.U64.limb2 a4 a5 * Library.U64.limb2 b0 b1 + + Library.U64.carry3 c10 c11 c12 = + Library.U64.limb2 r20 r21 + 65536 * Library.U64.carry3 c20 c21 c22 → + Library.U64.limb2 a0 a1 * Library.U64.limb2 b6 b7 + + Library.U64.limb2 a2 a3 * Library.U64.limb2 b4 b5 + + Library.U64.limb2 a4 a5 * Library.U64.limb2 b2 b3 + + Library.U64.limb2 a6 a7 * Library.U64.limb2 b0 b1 + + Library.U64.carry3 c20 c21 c22 = + Library.U64.limb2 r30 r31 + 65536 * Library.U64.carry3 c30 c31 c32 → + Library.U64.limb2 a2 a3 * Library.U64.limb2 b6 b7 + + Library.U64.limb2 a4 a5 * Library.U64.limb2 b4 b5 + + Library.U64.limb2 a6 a7 * Library.U64.limb2 b2 b3 + + Library.U64.carry3 c30 c31 c32 = + Library.U64.limb2 r40 r41 + 65536 * Library.U64.carry3 c40 c41 c42 → + Library.U64.limb2 a4 a5 * Library.U64.limb2 b6 b7 + + Library.U64.limb2 a6 a7 * Library.U64.limb2 b4 b5 + + Library.U64.carry3 c40 c41 c42 = + Library.U64.limb2 r50 r51 + 65536 * Library.U64.carry3 c50 c51 c52 → + Library.U64.limb2 a6 a7 * Library.U64.limb2 b6 b7 + + Library.U64.carry3 c50 c51 c52 = + Library.U64.limb2 r60 r61 + 65536 * Library.U64.carry3 c60 c61 c62 → + c62 = 0 → + have a := Library.U64.pack a0 a1 a2 a3 a4 a5 a6 a7; + have b := Library.U64.pack b0 b1 b2 b3 b4 b5 b6 b7; + have lo := Library.U64.pack r00 r01 r10 r11 r20 r21 r30 r31; + have hi := Library.U64.pack r40 r41 r50 r51 r60 r61 c60 c61; + a * b = lo + Library.U64.base * hi ∧ + lo = a * b % Library.U64.base ∧ + hi = a * b / Library.U64.base ∧ hi < Library.U64.base +-/ +#guard_msgs in +#check @Aiur.Library.U64.mul_sound +/-- info: 'Aiur.Library.U64.mul_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U64.mul_sound + +/-- +info: @Library.U64.and_sound : ∀ {F : Type} [inst : Field F], + Library.U64.Compatible F → + ∀ {a0 a1 a2 a3 a4 a5 a6 a7 b0 b1 b2 b3 b4 b5 b6 b7 : ℕ}, + a0 < 256 → + a1 < 256 → + a2 < 256 → + a3 < 256 → + a4 < 256 → + a5 < 256 → + a6 < 256 → + a7 < 256 → + b0 < 256 → + b1 < 256 → + b2 < 256 → + b3 < 256 → + b4 < 256 → + b5 < 256 → + b6 < 256 → + b7 < 256 → + (↑a0 + ↑b0 - ↑(a0.xor b0)) / 2 = ↑(a0.land b0) ∧ + Library.U64.pack (a0.land b0) (a1.land b1) (a2.land b2) (a3.land b3) + (a4.land b4) (a5.land b5) (a6.land b6) (a7.land b7) = + (Library.U64.pack a0 a1 a2 a3 a4 a5 a6 a7).land + (Library.U64.pack b0 b1 b2 b3 b4 b5 b6 b7) +-/ +#guard_msgs in +#check @Aiur.Library.U64.and_sound +/-- info: 'Aiur.Library.U64.and_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U64.and_sound + +/-- +info: @Library.U64.or_sound : ∀ {F : Type} [inst : Field F], + Library.U64.Compatible F → + ∀ {a0 a1 a2 a3 a4 a5 a6 a7 b0 b1 b2 b3 b4 b5 b6 b7 : ℕ}, + a0 < 256 → + a1 < 256 → + a2 < 256 → + a3 < 256 → + a4 < 256 → + a5 < 256 → + a6 < 256 → + a7 < 256 → + b0 < 256 → + b1 < 256 → + b2 < 256 → + b3 < 256 → + b4 < 256 → + b5 < 256 → + b6 < 256 → + b7 < 256 → + (↑a0 + ↑b0 + ↑(a0.xor b0)) / 2 = ↑(a0.lor b0) ∧ + Library.U64.pack (a0.lor b0) (a1.lor b1) (a2.lor b2) (a3.lor b3) (a4.lor b4) + (a5.lor b5) (a6.lor b6) (a7.lor b7) = + (Library.U64.pack a0 a1 a2 a3 a4 a5 a6 a7).lor + (Library.U64.pack b0 b1 b2 b3 b4 b5 b6 b7) +-/ +#guard_msgs in +#check @Aiur.Library.U64.or_sound +/-- info: 'Aiur.Library.U64.or_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U64.or_sound + +/-- +info: @Library.U64.xor_sound : ∀ {a0 a1 a2 a3 a4 a5 a6 a7 b0 b1 b2 b3 b4 b5 b6 b7 : ℕ}, + a0 < 256 → + a1 < 256 → + a2 < 256 → + a3 < 256 → + a4 < 256 → + a5 < 256 → + a6 < 256 → + a7 < 256 → + b0 < 256 → + b1 < 256 → + b2 < 256 → + b3 < 256 → + b4 < 256 → + b5 < 256 → + b6 < 256 → + b7 < 256 → + Library.U64.pack (a0.xor b0) (a1.xor b1) (a2.xor b2) (a3.xor b3) (a4.xor b4) + (a5.xor b5) (a6.xor b6) (a7.xor b7) = + (Library.U64.pack a0 a1 a2 a3 a4 a5 a6 a7).xor + (Library.U64.pack b0 b1 b2 b3 b4 b5 b6 b7) +-/ +#guard_msgs in +#check @Aiur.Library.U64.xor_sound +/-- info: 'Aiur.Library.U64.xor_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U64.xor_sound + +/-- +info: @Library.U64.from_field_sound : ∀ {F : Type} [inst : Field F], + Library.U64.Compatible F → + ∀ {value : F} {b0 b1 b2 b3 b4 b5 b6 b7 : ℕ}, + b0 < 256 → + b1 < 256 → + b2 < 256 → + b3 < 256 → + b4 < 256 → + b5 < 256 → + b6 < 256 → + b7 < 256 → + ↑b7 = 0 → + ↑b0 + 256 * ↑b1 + 65536 * ↑b2 + 16777216 * ↑b3 + 4294967296 * ↑b4 + 1099511627776 * ↑b5 + + 281474976710656 * ↑b6 = + value → + b7 = 0 ∧ + Library.U64.pack b0 b1 b2 b3 b4 b5 b6 b7 < Library.U64.fieldBound ∧ + ↑(Library.U64.pack b0 b1 b2 b3 b4 b5 b6 b7) = value +-/ +#guard_msgs in +#check @Aiur.Library.U64.from_field_sound +/-- info: 'Aiur.Library.U64.from_field_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U64.from_field_sound + +/-- +info: @Library.U64.from_field_unique : ∀ {F : Type} [inst : Field F], + Library.U64.Compatible F → + ∀ {n : ℕ}, + n < Library.U64.fieldBound → + ∀ {b0 b1 b2 b3 b4 b5 b6 b7 : ℕ}, + b0 < 256 → + b1 < 256 → + b2 < 256 → + b3 < 256 → + b4 < 256 → + b5 < 256 → + b6 < 256 → + b7 < 256 → + ↑b7 = 0 → + ↑b0 + 256 * ↑b1 + 65536 * ↑b2 + 16777216 * ↑b3 + 4294967296 * ↑b4 + 1099511627776 * ↑b5 + + 281474976710656 * ↑b6 = + ↑n → + Library.U64.pack b0 b1 b2 b3 b4 b5 b6 b7 = n +-/ +#guard_msgs in +#check @Aiur.Library.U64.from_field_unique +/-- info: 'Aiur.Library.U64.from_field_unique' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U64.from_field_unique + +/-- info: Library.U64.Goldilocks.compatible : Library.U64.Compatible Library.U64.Goldilocks.F -/ +#guard_msgs in +#check @Aiur.Library.U64.Goldilocks.compatible +/-- info: 'Aiur.Library.U64.Goldilocks.compatible' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.U64.Goldilocks.compatible + +/-- +info: Library.Blake3.iv_spec : #v[Library.Blake3.wordOfBytes 103 230 9 106, Library.Blake3.wordOfBytes 133 174 103 187, + Library.Blake3.wordOfBytes 114 243 110 60, Library.Blake3.wordOfBytes 58 245 79 165, + Library.Blake3.wordOfBytes 127 82 14 81, Library.Blake3.wordOfBytes 140 104 5 155, + Library.Blake3.wordOfBytes 171 217 131 31, Library.Blake3.wordOfBytes 25 205 224 91] = + Library.Blake3.iv +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.iv_spec +/-- info: 'Aiur.Library.Blake3.iv_spec' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.iv_spec + +/-- +info: Library.Blake3.rotr8_spec : ∀ (b0 b1 b2 b3 : UInt8), + Library.Blake3.rotateRight (Library.Blake3.wordOfBytes b0 b1 b2 b3) 8 = Library.Blake3.wordOfBytes b1 b2 b3 b0 +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.rotr8_spec +/-- info: 'Aiur.Library.Blake3.rotr8_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.rotr8_spec + +/-- +info: Library.Blake3.rotr16_spec : ∀ (b0 b1 b2 b3 : UInt8), + Library.Blake3.rotateRight (Library.Blake3.wordOfBytes b0 b1 b2 b3) 16 = Library.Blake3.wordOfBytes b2 b3 b0 b1 +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.rotr16_spec +/-- info: 'Aiur.Library.Blake3.rotr16_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.rotr16_spec + +/-- +info: Library.Blake3.xor_spec : ∀ (a0 a1 a2 a3 b0 b1 b2 b3 : UInt8), + Library.Blake3.wordOfBytes a0 a1 a2 a3 ^^^ Library.Blake3.wordOfBytes b0 b1 b2 b3 = + Library.Blake3.wordOfBytes (a0 ^^^ b0) (a1 ^^^ b1) (a2 ^^^ b2) (a3 ^^^ b3) +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.xor_spec +/-- info: 'Aiur.Library.Blake3.xor_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.xor_spec + +/-- +info: Library.Blake3.xor_rotr12_spec : ∀ (a0 a1 a2 a3 b0 b1 b2 b3 : UInt8), + have x0 := (a0 ^^^ b0).toNat; + have x1 := (a1 ^^^ b1).toNat; + have x2 := (a2 ^^^ b2).toNat; + have x3 := (a3 ^^^ b3).toNat; + have r0 := UInt8.ofNat (x1 / 16 + x2 % 16 * 16); + have r1 := UInt8.ofNat (x2 / 16 + x3 % 16 * 16); + have r2 := UInt8.ofNat (x3 / 16 + x0 % 16 * 16); + have r3 := UInt8.ofNat (x0 / 16 + x1 % 16 * 16); + Library.Blake3.rotateRight (Library.Blake3.wordOfBytes a0 a1 a2 a3 ^^^ Library.Blake3.wordOfBytes b0 b1 b2 b3) 12 = + Library.Blake3.wordOfBytes r0 r1 r2 r3 +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.xor_rotr12_spec +/-- info: 'Aiur.Library.Blake3.xor_rotr12_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.xor_rotr12_spec + +/-- +info: Library.Blake3.xor_rotr7_spec : ∀ (a0 a1 a2 a3 b0 b1 b2 b3 : UInt8), + have x0 := (a0 ^^^ b0).toNat; + have x1 := (a1 ^^^ b1).toNat; + have x2 := (a2 ^^^ b2).toNat; + have x3 := (a3 ^^^ b3).toNat; + have r0 := UInt8.ofNat (x0 / 128 + x1 % 128 * 2); + have r1 := UInt8.ofNat (x1 / 128 + x2 % 128 * 2); + have r2 := UInt8.ofNat (x2 / 128 + x3 % 128 * 2); + have r3 := UInt8.ofNat (x3 / 128 + x0 % 128 * 2); + Library.Blake3.rotateRight (Library.Blake3.wordOfBytes a0 a1 a2 a3 ^^^ Library.Blake3.wordOfBytes b0 b1 b2 b3) 7 = + Library.Blake3.wordOfBytes r0 r1 r2 r3 +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.xor_rotr7_spec +/-- info: 'Aiur.Library.Blake3.xor_rotr7_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.xor_rotr7_spec + +/-- +info: Library.Blake3.g_function_spec : ∀ (a b c d mx my : UInt32), + have a1 := a + b + mx; + have d1 := Library.Blake3.rotateRight (d ^^^ a1) 16; + have c1 := c + d1; + have b1 := Library.Blake3.rotateRight (b ^^^ c1) 12; + have a2 := a1 + b1 + my; + have d2 := Library.Blake3.rotateRight (d1 ^^^ a2) 8; + have c2 := c1 + d2; + have b2 := Library.Blake3.rotateRight (b1 ^^^ c2) 7; + #v[a2, b2, c2, d2] = Library.Blake3.mix a b c d mx my +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.g_function_spec +/-- info: 'Aiur.Library.Blake3.g_function_spec' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.g_function_spec + +/-- +info: Library.Blake3.g_spec : ∀ (state : Library.Blake3.Block) (j : Fin 8) (mx my : UInt32), + (match ↑j with + | 0 => Library.Blake3.g state 0 4 8 12 mx my + | 1 => Library.Blake3.g state 1 5 9 13 mx my + | 2 => Library.Blake3.g state 2 6 10 14 mx my + | 3 => Library.Blake3.g state 3 7 11 15 mx my + | 4 => Library.Blake3.g state 0 5 10 15 mx my + | 5 => Library.Blake3.g state 1 6 11 12 mx my + | 6 => Library.Blake3.g state 2 7 8 13 mx my + | x => Library.Blake3.g state 3 4 9 14 mx my) = + have cols := + #v[(0, 4, 8, 12), (1, 5, 9, 13), (2, 6, 10, 14), (3, 7, 11, 15), (0, 5, 10, 15), (1, 6, 11, 12), (2, 7, 8, 13), + (3, 4, 9, 14)]; + match cols[j] with + | (a, b, c, d) => Library.Blake3.g state a b c d mx my +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.g_spec +/-- info: 'Aiur.Library.Blake3.g_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.g_spec + +/-- +info: Library.Blake3.round_spec : ∀ (state m : Library.Blake3.Block), + Library.Blake3.compressInnerJ state m = Library.Blake3.round state m Library.Blake3.schedules[0] +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.round_spec +/-- info: 'Aiur.Library.Blake3.round_spec' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.round_spec + +/-- +info: Library.Blake3.permute_spec : ∀ (m : Library.Blake3.Block) (r : Fin 7) (k : Fin 16), + (Library.Blake3.permute^[↑r] m)[↑k] = m[Library.Blake3.schedules[r][↑k]] +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.permute_spec +/-- info: 'Aiur.Library.Blake3.permute_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.permute_spec + +/-- +info: Library.Blake3.compress_inner_i_spec : ∀ (state m : Library.Blake3.Block), + Library.Blake3.compressInnerI state m = + Vector.foldl (fun s sched => Library.Blake3.round s m sched) state Library.Blake3.schedules +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.compress_inner_i_spec +/-- info: 'Aiur.Library.Blake3.compress_inner_i_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.compress_inner_i_spec + +/-- +info: Library.Blake3.counter_split_spec : ∀ (c0 c1 c2 c3 c4 c5 c6 c7 : UInt8), + have counter := + UInt64.ofNat (Library.U64.pack c0.toNat c1.toNat c2.toNat c3.toNat c4.toNat c5.toNat c6.toNat c7.toNat); + counter.toUInt32 = Library.Blake3.wordOfBytes c0 c1 c2 c3 ∧ + (counter >>> 32).toUInt32 = Library.Blake3.wordOfBytes c4 c5 c6 c7 +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.counter_split_spec +/-- info: 'Aiur.Library.Blake3.counter_split_spec' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.counter_split_spec + +/-- +info: Library.Blake3.compress_spec : ∀ (cv : Library.Blake3.CV) (message : Library.Blake3.Block) (counter : UInt64) + (blockLen flags : UInt32), + Library.Blake3.finalizeState + (Library.Blake3.compressInnerI (Library.Blake3.initialWords cv counter blockLen flags) message) = + Library.Blake3.compress cv message counter blockLen flags +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.compress_spec +/-- info: 'Aiur.Library.Blake3.compress_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.compress_spec + +/-- +info: Library.Blake3.pad_block_spec : ∀ (acc : List UInt8), + (Library.Blake3.padBlock acc.reverse acc.length).reverse = acc ++ List.replicate (64 - acc.length) 0 +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.pad_block_spec +/-- info: 'Aiur.Library.Blake3.pad_block_spec' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.pad_block_spec + +/-- +info: Library.Blake3.bytes_to_block_spec : ∀ (acc : List UInt8), + acc.length ≤ 64 → + Library.Blake3.blockWords (acc ++ List.replicate (64 - acc.length) 0) = Library.Blake3.blockWords acc +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.bytes_to_block_spec +/-- info: 'Aiur.Library.Blake3.bytes_to_block_spec' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.bytes_to_block_spec + +/-- +info: Library.Blake3.chunk_single_root_spec : ∀ (input : List UInt8), + input.length ≤ 1024 → (Library.Blake3.chunkOutput 0 input).rootHash = Library.Blake3.digest input +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.chunk_single_root_spec +/-- info: 'Aiur.Library.Blake3.chunk_single_root_spec' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.chunk_single_root_spec + +/-- +info: Library.Blake3.next_layer_pair_spec : ∀ (left right : Library.Blake3.CV) (rest : List Library.Blake3.CV), + Library.Blake3.nextLayer (left :: right :: rest) = + Library.Blake3.compress Library.Blake3.iv (left ++ right) 0 64 4 :: Library.Blake3.nextLayer rest +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.next_layer_pair_spec +/-- info: 'Aiur.Library.Blake3.next_layer_pair_spec' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.next_layer_pair_spec + +/-- +info: Library.Blake3.compress_layer_two_spec : ∀ (left right : Library.Blake3.CV), + Library.Blake3.cvBytes (Library.Blake3.compressLayer [left, right]) = + (Library.Blake3.parentOutput left right).rootHash +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.compress_layer_two_spec +/-- info: 'Aiur.Library.Blake3.compress_layer_two_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.compress_layer_two_spec + +/-- +info: Library.Blake3.compress_layer_step_spec : ∀ (left right c : Library.Blake3.CV) (rest : List Library.Blake3.CV), + Library.Blake3.compressLayer (left :: right :: c :: rest) = + Library.Blake3.compressLayer (Library.Blake3.nextLayer (left :: right :: c :: rest)) +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.compress_layer_step_spec +/-- info: 'Aiur.Library.Blake3.compress_layer_step_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.compress_layer_step_spec + +/-- +info: Library.Blake3.digest_bytes_spec : ∀ (cv : Library.Blake3.CV) (i : Fin 32), + (Library.Blake3.cvBytes cv)[i] = (Library.Blake3.wordBytes cv[↑i / 4])[↑i % 4] +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.digest_bytes_spec +/-- info: 'Aiur.Library.Blake3.digest_bytes_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.digest_bytes_spec + +/-- +info: @Library.Blake3.cvBytes_inj : ∀ {cv1 cv2 : Library.Blake3.CV}, + Library.Blake3.cvBytes cv1 = Library.Blake3.cvBytes cv2 → cv1 = cv2 +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.cvBytes_inj +/-- info: 'Aiur.Library.Blake3.cvBytes_inj' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.cvBytes_inj + +/-- +info: @Library.Blake3.pack_digest_inj : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → Function.Injective (Library.Blake3.packDigest F) +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.pack_digest_inj +/-- info: 'Aiur.Library.Blake3.pack_digest_inj' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.pack_digest_inj + +/-- +info: @Library.Blake3.address_to_fields_inj : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → Function.Injective (Library.Blake3.addressToFields F) +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.address_to_fields_inj +/-- info: 'Aiur.Library.Blake3.address_to_fields_inj' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.address_to_fields_inj + +/-- +info: @Library.Blake3.verify_bytes_against_iff : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ (bytes : List UInt8) (expectedAddr : Library.Blake3.Digest), + Library.Blake3.addressToFields F (Library.Blake3.digest bytes) = Library.Blake3.addressToFields F expectedAddr ↔ + Library.Blake3.digest bytes = expectedAddr +-/ +#guard_msgs in +#check @Aiur.Library.Blake3.verify_bytes_against_iff +/-- info: 'Aiur.Library.Blake3.verify_bytes_against_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.verify_bytes_against_iff + +/-- info: Library.Blake3.Goldilocks.u64_compatible : Library.U64.Compatible Library.U32.Goldilocks.F -/ +#guard_msgs in +#check @Aiur.Library.Blake3.Goldilocks.u64_compatible +/-- info: 'Aiur.Library.Blake3.Goldilocks.u64_compatible' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Blake3.Goldilocks.u64_compatible + +/-! ### 5. Heap Monotonicity (`Aiur.HeapMono`) -/ + +/-- info: @Heap.Extends.refl : ∀ {F : Type} (h : Heap F), h.Extends h -/ +#guard_msgs in +#check @Aiur.Heap.Extends.refl +/-- info: 'Aiur.Heap.Extends.refl' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Heap.Extends.refl + +/-- info: @Heap.Extends.trans : ∀ {F : Type} {h₁ h₂ h₃ : Heap F}, h₁.Extends h₂ → h₂.Extends h₃ → h₁.Extends h₃ -/ +#guard_msgs in +#check @Aiur.Heap.Extends.trans +/-- info: 'Aiur.Heap.Extends.trans' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Heap.Extends.trans + +/-- info: @Heap.Extends.length_le : ∀ {F : Type} {h₁ h₂ : Heap F}, h₁.Extends h₂ → List.length h₁ ≤ List.length h₂ -/ +#guard_msgs in +#check @Aiur.Heap.Extends.length_le +/-- info: 'Aiur.Heap.Extends.length_le' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Heap.Extends.length_le + +/-- +info: @Heap.Extends.getElem?_eq : ∀ {F : Type} {h₁ h₂ : Heap F} {i : ℕ} {v : SourceValue F}, + h₁.Extends h₂ → h₁[i]? = some v → h₂[i]? = some v +-/ +#guard_msgs in +#check @Aiur.Heap.Extends.getElem?_eq +/-- info: 'Aiur.Heap.Extends.getElem?_eq' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Heap.Extends.getElem?_eq + +/-- +info: @Heap.Extends.loadValue_eq : ∀ {F : Type} {h₁ h₂ : Heap F} {ptr v : SourceValue F}, + h₁.Extends h₂ → loadValue h₁ ptr = Except.ok v → loadValue h₂ ptr = Except.ok v +-/ +#guard_msgs in +#check @Aiur.Heap.Extends.loadValue_eq +/-- info: 'Aiur.Heap.Extends.loadValue_eq' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Heap.Extends.loadValue_eq + +/-- +info: @EvalExpr.heap_extends : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {expr : Expr F} {before after : Heap F} {value : SourceValue F}, + EvalExpr program locals expr before value after → before.Extends after +-/ +#guard_msgs in +#check @Aiur.EvalExpr.heap_extends +/-- info: 'Aiur.EvalExpr.heap_extends' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.EvalExpr.heap_extends + +/-- +info: @EvalArgs.heap_extends : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {exprs : List (Expr F)} {before after : Heap F} {values : List (SourceValue F)}, + EvalArgs program locals exprs before values after → before.Extends after +-/ +#guard_msgs in +#check @Aiur.EvalArgs.heap_extends +/-- info: 'Aiur.EvalArgs.heap_extends' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.EvalArgs.heap_extends + +/-- +info: @EvalFn.heap_extends : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} {name : String} + {args : List (SourceValue F)} {before after : Heap F} {value : SourceValue F}, + EvalFn program name args before value after → before.Extends after +-/ +#guard_msgs in +#check @Aiur.EvalFn.heap_extends +/-- info: 'Aiur.EvalFn.heap_extends' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.EvalFn.heap_extends + +/-- +info: @Generic.SourceSemantics.EvalExpr.heap_extends : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {expr : Generic.Expr F} {before after : Heap F} {result : SourceValue F}, + Generic.SourceSemantics.EvalExpr world types locals expr before result after → before.Extends after +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.EvalExpr.heap_extends +/-- info: 'Aiur.Generic.SourceSemantics.EvalExpr.heap_extends' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.EvalExpr.heap_extends + +/-- +info: @Generic.SourceSemantics.EvalArgs.heap_extends : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {exprs : List (Generic.Expr F)} {before after : Heap F} {values : List (SourceValue F)}, + Generic.SourceSemantics.EvalArgs world types locals exprs before values after → before.Extends after +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.EvalArgs.heap_extends +/-- info: 'Aiur.Generic.SourceSemantics.EvalArgs.heap_extends' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.EvalArgs.heap_extends + +/-- +info: @Generic.SourceSemantics.EvalExit.heap_extends : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {expr : Generic.Expr F} {before after : Heap F} {target : Generic.ExitTarget} {result : SourceValue F}, + Generic.SourceSemantics.EvalExit world types locals expr before target result after → before.Extends after +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.EvalExit.heap_extends +/-- info: 'Aiur.Generic.SourceSemantics.EvalExit.heap_extends' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.EvalExit.heap_extends + +/-- +info: @Generic.SourceSemantics.EvalFn.heap_extends : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {name : String} {args : List (SourceValue F)} {before after : Heap F} + {result : SourceValue F}, Generic.SourceSemantics.EvalFn world name args before result after → before.Extends after +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.EvalFn.heap_extends +/-- info: 'Aiur.Generic.SourceSemantics.EvalFn.heap_extends' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.EvalFn.heap_extends + +/-- +info: @Generic.SourceSemantics.EvalArgsExit.heap_extends : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {exprs : List (Generic.Expr F)} {before after : Heap F} {target : Generic.ExitTarget} {result : SourceValue F}, + Generic.SourceSemantics.EvalArgsExit world types locals exprs before target result after → before.Extends after +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.EvalArgsExit.heap_extends +/-- info: 'Aiur.Generic.SourceSemantics.EvalArgsExit.heap_extends' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.EvalArgsExit.heap_extends + +/-- +info: @Generic.SourceSemantics.EvalList.heap_extends : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {exprs : List (Generic.Expr F)} {before after : Heap F} {values : List (SourceValue F)}, + Generic.SourceSemantics.EvalList world types locals exprs before values after → before.Extends after +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.EvalList.heap_extends +/-- info: 'Aiur.Generic.SourceSemantics.EvalList.heap_extends' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.EvalList.heap_extends + +/-- +info: @Generic.SourceSemantics.EvalFields.heap_extends : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {exprs : List (Generic.Expr F)} {before after : Heap F} {values : List (SourceValue F)}, + Generic.SourceSemantics.EvalFields world types locals exprs before values after → before.Extends after +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.EvalFields.heap_extends +/-- info: 'Aiur.Generic.SourceSemantics.EvalFields.heap_extends' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.EvalFields.heap_extends + +/-- +info: @Generic.SourceSemantics.EvalPath.heap_extends : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {exprs : List (Generic.Expr F)} {before after : Heap F} {values : List (SourceValue F)}, + Generic.SourceSemantics.EvalPath world types locals exprs before values after → before.Extends after +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.EvalPath.heap_extends +/-- info: 'Aiur.Generic.SourceSemantics.EvalPath.heap_extends' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.EvalPath.heap_extends + +/-- info: @HeapMono.const : ∀ {F : Type} {α : Type u_1} (Q : α → Prop), HeapMono fun x x_1 => Q x_1 -/ +#guard_msgs in +#check @Aiur.HeapMono.const +/-- info: 'Aiur.HeapMono.const' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.HeapMono.const + +/-- +info: @HeapMono.and : ∀ {F : Type} {α : Type u_1} {P Q : Heap F → α → Prop}, + HeapMono P → HeapMono Q → HeapMono fun h x => P h x ∧ Q h x +-/ +#guard_msgs in +#check @Aiur.HeapMono.and +/-- info: 'Aiur.HeapMono.and' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.HeapMono.and + +/-- +info: @HeapMono.or : ∀ {F : Type} {α : Type u_1} {P Q : Heap F → α → Prop}, + HeapMono P → HeapMono Q → HeapMono fun h x => P h x ∨ Q h x +-/ +#guard_msgs in +#check @Aiur.HeapMono.or +/-- info: 'Aiur.HeapMono.or' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.HeapMono.or + +/-- +info: @HeapMono.ex : ∀ {F : Type} {α : Type u_1} {β : Type u_2} {P : β → Heap F → α → Prop}, + (∀ (b : β), HeapMono (P b)) → HeapMono fun h x => ∃ b, P b h x +-/ +#guard_msgs in +#check @Aiur.HeapMono.ex +/-- info: 'Aiur.HeapMono.ex' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.HeapMono.ex + +/-- +info: @HeapMono.all : ∀ {F : Type} {α : Type u_1} {β : Type u_2} {P : β → Heap F → α → Prop}, + (∀ (b : β), HeapMono (P b)) → HeapMono fun h x => ∀ (b : β), P b h x +-/ +#guard_msgs in +#check @Aiur.HeapMono.all +/-- info: 'Aiur.HeapMono.all' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.HeapMono.all + +/-- +info: @HeapMono.derefTyped : ∀ {F : Type} {ty : Ty} {P : Heap F → SourceValue F → Prop}, + HeapMono P → HeapMono (DerefTyped ty P) +-/ +#guard_msgs in +#check @Aiur.HeapMono.derefTyped +/-- info: 'Aiur.HeapMono.derefTyped' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.HeapMono.derefTyped + +/-- info: @HeapMono.deref : ∀ {F : Type} {P : Heap F → SourceValue F → Prop}, HeapMono P → HeapMono (Deref P) -/ +#guard_msgs in +#check @Aiur.HeapMono.deref +/-- info: 'Aiur.HeapMono.deref' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.HeapMono.deref + +/-- +info: @Represents.heapMono : ∀ {F : Type} (rom : ROM F) (source : SourceValue F), + HeapMono fun h target => Represents rom h source target +-/ +#guard_msgs in +#check @Aiur.Represents.heapMono +/-- info: 'Aiur.Represents.heapMono' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Represents.heapMono + +/-- +info: @RepLinkedList.mono : ∀ {F : Type} {α : Type u_1} {enumName nilCtor consCtor : String} + {R : Heap F → α → SourceValue F → Prop}, + HeapMono₂ R → + ∀ {h₁ h₂ : Heap F} {xs : List α} {ptr : SourceValue F}, + h₁.Extends h₂ → + RepLinkedList enumName nilCtor consCtor R h₁ xs ptr → RepLinkedList enumName nilCtor consCtor R h₂ xs ptr +-/ +#guard_msgs in +#check @Aiur.RepLinkedList.mono +/-- info: 'Aiur.RepLinkedList.mono' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.RepLinkedList.mono + +/-- +info: @HeapMono.repLinkedList : ∀ {F : Type} {α : Type u_1} (enumName nilCtor consCtor : String) + {R : Heap F → α → SourceValue F → Prop}, + HeapMono₂ R → ∀ (xs : List α), HeapMono fun h ptr => RepLinkedList enumName nilCtor consCtor R h xs ptr +-/ +#guard_msgs in +#check @Aiur.HeapMono.repLinkedList +/-- info: 'Aiur.HeapMono.repLinkedList' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.HeapMono.repLinkedList + +/-- +info: @RepBinaryTree.mono : ∀ {F : Type} {α : Type u_1} {enumName leafCtor branchCtor : String} + {R : Heap F → α → SourceValue F → Prop}, + HeapMono₂ R → + ∀ {h₁ h₂ : Heap F} {t : BinaryTree α} {ptr : SourceValue F}, + h₁.Extends h₂ → + RepBinaryTree enumName leafCtor branchCtor R h₁ t ptr → RepBinaryTree enumName leafCtor branchCtor R h₂ t ptr +-/ +#guard_msgs in +#check @Aiur.RepBinaryTree.mono +/-- info: 'Aiur.RepBinaryTree.mono' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.RepBinaryTree.mono + +/-- +info: @HeapMono.repBinaryTree : ∀ {F : Type} {α : Type u_1} (enumName leafCtor branchCtor : String) + {R : Heap F → α → SourceValue F → Prop}, + HeapMono₂ R → ∀ (t : BinaryTree α), HeapMono fun h ptr => RepBinaryTree enumName leafCtor branchCtor R h t ptr +-/ +#guard_msgs in +#check @Aiur.HeapMono.repBinaryTree +/-- info: 'Aiur.HeapMono.repBinaryTree' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.HeapMono.repBinaryTree + +/-! ### 6. Standard Library Representation Predicates, `Lists`, `WordLists`, `Options`, and `Bytes` -/ + +/-- info: @Library.repU8_heapMono : ∀ {F : Type} [inst : NatCast F] (b : UInt8), HeapMono fun h v => Library.RepU8 h b v -/ +#guard_msgs in +#check @Aiur.Library.repU8_heapMono +/-- info: 'Aiur.Library.repU8_heapMono' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.Library.repU8_heapMono + +/-- +info: @Library.repU8_inj : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {h : Heap F} {a b : UInt8} {v : SourceValue F}, Library.RepU8 h a v → Library.RepU8 h b v → a = b +-/ +#guard_msgs in +#check @Aiur.Library.repU8_inj +/-- info: 'Aiur.Library.repU8_inj' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.repU8_inj + +/-- info: @Library.repU32_heapMono : ∀ {F : Type} [inst : NatCast F] (w : UInt32), HeapMono fun h v => Library.RepU32 h w v -/ +#guard_msgs in +#check @Aiur.Library.repU32_heapMono +/-- info: 'Aiur.Library.repU32_heapMono' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.repU32_heapMono + +/-- info: @Library.repU64_heapMono : ∀ {F : Type} [inst : NatCast F] (w : UInt64), HeapMono fun h v => Library.RepU64 h w v -/ +#guard_msgs in +#check @Aiur.Library.repU64_heapMono +/-- info: 'Aiur.Library.repU64_heapMono' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.repU64_heapMono + +/-- +info: @Library.RepOption.mono : ∀ {F : Type} {α : Type u_1} {enumName : String} {R : Heap F → α → SourceValue F → Prop}, + HeapMono₂ R → + ∀ {h₁ h₂ : Heap F} {opt : Option α} {v : SourceValue F}, + h₁.Extends h₂ → Library.RepOption enumName R h₁ opt v → Library.RepOption enumName R h₂ opt v +-/ +#guard_msgs in +#check @Aiur.Library.RepOption.mono +/-- info: 'Aiur.Library.RepOption.mono' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.Library.RepOption.mono + +/-- +info: @Library.repOption_heapMono : ∀ {F : Type} {α : Type u_1} (enumName : String) {R : Heap F → α → SourceValue F → Prop}, + HeapMono₂ R → ∀ (opt : Option α), HeapMono fun h v => Library.RepOption enumName R h opt v +-/ +#guard_msgs in +#check @Aiur.Library.repOption_heapMono +/-- info: 'Aiur.Library.repOption_heapMono' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.Library.repOption_heapMono + +/-- +info: @Library.List.repList_heapMono : ∀ {F : Type} {α : Type u_1} (enumName : String) + {R : Heap F → α → SourceValue F → Prop}, + HeapMono₂ R → ∀ (xs : List α), HeapMono fun h ptr => Library.List.RepList enumName R h xs ptr +-/ +#guard_msgs in +#check @Aiur.Library.List.repList_heapMono +/-- info: 'Aiur.Library.List.repList_heapMono' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.List.repList_heapMono + +/-- +info: @Library.List.repList_inj : ∀ {F : Type} {α : Type u_1} {enumName : String} {R : Heap F → α → SourceValue F → Prop} + {h : Heap F}, + (∀ {x₁ x₂ : α} {v : SourceValue F}, R h x₁ v → R h x₂ v → x₁ = x₂) → + ∀ {xs₁ xs₂ : List α} {ptr : SourceValue F}, + Library.List.RepList enumName R h xs₁ ptr → Library.List.RepList enumName R h xs₂ ptr → xs₁ = xs₂ +-/ +#guard_msgs in +#check @Aiur.Library.List.repList_inj +/-- info: 'Aiur.Library.List.repList_inj' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.List.repList_inj + +/-- +info: @Library.List.allocNil_extends : ∀ {F : Type} (enumName : String) (h : Heap F), + h.Extends (Library.List.allocNil enumName h).2 +-/ +#guard_msgs in +#check @Aiur.Library.List.allocNil_extends +/-- info: 'Aiur.Library.List.allocNil_extends' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.Library.List.allocNil_extends + +/-- +info: @Library.List.allocNil_rep : ∀ {F : Type} {α : Type u_1} (enumName : String) (R : Heap F → α → SourceValue F → Prop) + (h : Heap F), + Library.List.RepList enumName R (Library.List.allocNil enumName h).2 [] (Library.List.allocNil enumName h).1 +-/ +#guard_msgs in +#check @Aiur.Library.List.allocNil_rep +/-- info: 'Aiur.Library.List.allocNil_rep' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.List.allocNil_rep + +/-- +info: @Library.List.allocCons_extends : ∀ {F : Type} (enumName : String) (headVal tailPtr : SourceValue F) (h : Heap F), + h.Extends (Library.List.allocCons enumName headVal tailPtr h).2 +-/ +#guard_msgs in +#check @Aiur.Library.List.allocCons_extends +/-- info: 'Aiur.Library.List.allocCons_extends' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.Library.List.allocCons_extends + +/-- +info: @Library.List.allocCons_rep : ∀ {F : Type} {α : Type u_1} (enumName : String) {R : Heap F → α → SourceValue F → Prop}, + HeapMono₂ R → + ∀ {h : Heap F} {x : α} {xs : List α} {headVal tailPtr : SourceValue F}, + R h x headVal → + Library.List.RepList enumName R h xs tailPtr → + Library.List.RepList enumName R (Library.List.allocCons enumName headVal tailPtr h).2 (x :: xs) + (Library.List.allocCons enumName headVal tailPtr h).1 +-/ +#guard_msgs in +#check @Aiur.Library.List.allocCons_rep +/-- info: 'Aiur.Library.List.allocCons_rep' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.List.allocCons_rep + +/-- +info: @Library.List.allocValues_extends : ∀ {F : Type} (enumName : String) (h : Heap F) (vs : List (SourceValue F)), + h.Extends (Library.List.allocValues enumName h vs).2 +-/ +#guard_msgs in +#check @Aiur.Library.List.allocValues_extends +/-- info: 'Aiur.Library.List.allocValues_extends' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.List.allocValues_extends + +/-- +info: @Library.List.allocValues_rep : ∀ {F : Type} {α : Type u_1} (enumName : String) {R : Heap F → α → SourceValue F → Prop}, + HeapMono₂ R → + ∀ (h : Heap F) {xs : List α} {vs : List (SourceValue F)}, + List.Forall₂ (R h) xs vs → + Library.List.RepList enumName R (Library.List.allocValues enumName h vs).2 xs + (Library.List.allocValues enumName h vs).1 +-/ +#guard_msgs in +#check @Aiur.Library.List.allocValues_rep +/-- info: 'Aiur.Library.List.allocValues_rep' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.List.allocValues_rep + +/-- +info: @Library.List.is_empty_spec : ∀ {F : Type} {α : Type u_1} [inst : Field F] (xs : List α), + Library.List.isEmpty xs = if xs.isEmpty = true then 1 else 0 +-/ +#guard_msgs in +#check @Aiur.Library.List.is_empty_spec +/-- info: 'Aiur.Library.List.is_empty_spec' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.List.is_empty_spec + +/-- +info: @Library.List.is_empty_one_iff : ∀ {F : Type} {α : Type u_1} [inst : Field F] (xs : List α), + Library.List.isEmpty xs = 1 ↔ xs = [] +-/ +#guard_msgs in +#check @Aiur.Library.List.is_empty_one_iff +/-- info: 'Aiur.Library.List.is_empty_one_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.List.is_empty_one_iff + +/-- +info: @Library.List.is_empty_zero_iff : ∀ {F : Type} {α : Type u_1} [inst : Field F] (xs : List α), + Library.List.isEmpty xs = 0 ↔ xs ≠ [] +-/ +#guard_msgs in +#check @Aiur.Library.List.is_empty_zero_iff +/-- info: 'Aiur.Library.List.is_empty_zero_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.List.is_empty_zero_iff + +/-- info: @Library.List.reverse_acc_spec : ∀ {α : Type u_1} (xs acc : List α), Library.List.reverseAcc xs acc = xs.reverse ++ acc -/ +#guard_msgs in +#check @Aiur.Library.List.reverse_acc_spec +/-- info: 'Aiur.Library.List.reverse_acc_spec' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.List.reverse_acc_spec + +/-- info: @Library.List.reverse_spec : ∀ {α : Type u_1} (xs : List α), Library.List.reverseAcc xs [] = xs.reverse -/ +#guard_msgs in +#check @Aiur.Library.List.reverse_spec +/-- info: 'Aiur.Library.List.reverse_spec' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.List.reverse_spec + +/-- info: @Library.List.snoc_spec : ∀ {α : Type u_1} (xs : List α) (v : α), xs ++ [v] = xs.concat v -/ +#guard_msgs in +#check @Aiur.Library.List.snoc_spec +/-- info: 'Aiur.Library.List.snoc_spec' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.List.snoc_spec + +/-- +info: @Library.List.Word.checked_depth_succ_sound : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {depth difference : ℕ}, + depth < Library.U32.base → + difference < Library.U32.base → + (have borrow := (↑difference + ↑4294967295 - ↑depth) / ↑Library.U32.base; + borrow * (borrow - 1) = 0) → + (↑difference + ↑4294967295 - ↑depth) / ↑Library.U32.base = 1 → + depth < 4294967295 ∧ depth + 1 < Library.U32.base ∧ ↑depth + 1 = ↑(depth + 1) +-/ +#guard_msgs in +#check @Aiur.Library.List.Word.checked_depth_succ_sound +/-- info: 'Aiur.Library.List.Word.checked_depth_succ_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.List.Word.checked_depth_succ_sound + +/-- +info: @Library.List.Word.depth_checked_iff : ∀ {α : Type u_1} (xs : List α), + Library.List.Word.depthChecked xs = if xs.length < Library.U32.base then some xs.length else none +-/ +#guard_msgs in +#check @Aiur.Library.List.Word.depth_checked_iff +/-- info: 'Aiur.Library.List.Word.depth_checked_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.List.Word.depth_checked_iff + +/-- +info: @Library.List.Word.depth_checked_some_iff : ∀ {α : Type u_1} (xs : List α) (n : ℕ), + Library.List.Word.depthChecked xs = some n ↔ n = xs.length ∧ xs.length < Library.U32.base +-/ +#guard_msgs in +#check @Aiur.Library.List.Word.depth_checked_some_iff +/-- info: 'Aiur.Library.List.Word.depth_checked_some_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.List.Word.depth_checked_some_iff + +/-- +info: @Library.List.Word.length_u64_spec : ∀ {α : Type u_1} (xs : List α), + Library.List.Word.lengthU64 xs = UInt64.ofNat xs.length +-/ +#guard_msgs in +#check @Aiur.Library.List.Word.length_u64_spec +/-- info: 'Aiur.Library.List.Word.length_u64_spec' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.List.Word.length_u64_spec + +/-- +info: @Library.List.Word.length_u64_toNat_of_lt : ∀ {α : Type u_1} {xs : List α}, + xs.length < Library.U64.base → (Library.List.Word.lengthU64 xs).toNat = xs.length +-/ +#guard_msgs in +#check @Aiur.Library.List.Word.length_u64_toNat_of_lt +/-- info: 'Aiur.Library.List.Word.length_u64_toNat_of_lt' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.List.Word.length_u64_toNat_of_lt + +/-- +info: @Library.List.Word.length_u64_of_depth_checked : ∀ {α : Type u_1} {xs : List α} {n : ℕ}, + Library.List.Word.depthChecked xs = some n → (Library.List.Word.lengthU64 xs).toNat = xs.length ∧ n = xs.length +-/ +#guard_msgs in +#check @Aiur.Library.List.Word.length_u64_of_depth_checked +/-- info: 'Aiur.Library.List.Word.length_u64_of_depth_checked' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.List.Word.length_u64_of_depth_checked + +/-- +info: @Library.List.Word.lookup_u64_spec : ∀ {α : Type u_1} (xs : List α) (idx : UInt64), + Library.List.Word.lookupU64 xs idx = xs[idx.toNat]? +-/ +#guard_msgs in +#check @Aiur.Library.List.Word.lookup_u64_spec +/-- info: 'Aiur.Library.List.Word.lookup_u64_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.List.Word.lookup_u64_spec + +/-- +info: @Library.List.Word.lookup_u64_rep : ∀ {F : Type} {α : Type u_1} (enumName : String) + (R : Heap F → α → SourceValue F → Prop) {h : Heap F} {xs : List α} {ptr : SourceValue F}, + Library.List.RepList enumName R h xs ptr → + ∀ (idx : UInt64) {x : α}, Library.List.Word.lookupU64 xs idx = some x → ∃ v, R h x v +-/ +#guard_msgs in +#check @Aiur.Library.List.Word.lookup_u64_rep +/-- info: 'Aiur.Library.List.Word.lookup_u64_rep' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.List.Word.lookup_u64_rep + +/-- +info: @Library.Bytes.repAddress_heapMono : ∀ {F : Type} [inst : NatCast F] (addr : Library.Bytes.Address), + HeapMono fun h v => Library.Bytes.RepAddress h addr v +-/ +#guard_msgs in +#check @Aiur.Library.Bytes.repAddress_heapMono +/-- info: 'Aiur.Library.Bytes.repAddress_heapMono' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.Library.Bytes.repAddress_heapMono + +/-- +info: @Library.Bytes.repAddressRef_heapMono : ∀ {F : Type} [inst : NatCast F] (ty : Ty) (addr : Library.Bytes.Address), + HeapMono fun h ptr => Library.Bytes.RepAddressRef ty h addr ptr +-/ +#guard_msgs in +#check @Aiur.Library.Bytes.repAddressRef_heapMono +/-- info: 'Aiur.Library.Bytes.repAddressRef_heapMono' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.Bytes.repAddressRef_heapMono + +/-- +info: @Library.Bytes.repByteStream_heapMono : ∀ {F : Type} [inst : NatCast F] (enumName : String) (bytes : List UInt8), + HeapMono fun h ptr => Library.Bytes.RepByteStream enumName h bytes ptr +-/ +#guard_msgs in +#check @Aiur.Library.Bytes.repByteStream_heapMono +/-- info: 'Aiur.Library.Bytes.repByteStream_heapMono' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.Bytes.repByteStream_heapMono + +/-- +info: @Library.Bytes.repAddress_inj : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {h : Heap F} {a₁ a₂ : Library.Bytes.Address} {v : SourceValue F}, + Library.Bytes.RepAddress h a₁ v → Library.Bytes.RepAddress h a₂ v → a₁ = a₂ +-/ +#guard_msgs in +#check @Aiur.Library.Bytes.repAddress_inj +/-- info: 'Aiur.Library.Bytes.repAddress_inj' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Bytes.repAddress_inj + +/-- +info: @Library.Bytes.repAddressRef_inj : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {ty : Ty} {h : Heap F} {a₁ a₂ : Library.Bytes.Address} {ptr : SourceValue F}, + Library.Bytes.RepAddressRef ty h a₁ ptr → Library.Bytes.RepAddressRef ty h a₂ ptr → a₁ = a₂ +-/ +#guard_msgs in +#check @Aiur.Library.Bytes.repAddressRef_inj +/-- info: 'Aiur.Library.Bytes.repAddressRef_inj' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Bytes.repAddressRef_inj + +/-- +info: @Library.Bytes.repByteStream_inj : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {enumName : String} {h : Heap F} {bs₁ bs₂ : List UInt8} {ptr : SourceValue F}, + Library.Bytes.RepByteStream enumName h bs₁ ptr → Library.Bytes.RepByteStream enumName h bs₂ ptr → bs₁ = bs₂ +-/ +#guard_msgs in +#check @Aiur.Library.Bytes.repByteStream_inj +/-- info: 'Aiur.Library.Bytes.repByteStream_inj' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Bytes.repByteStream_inj + +/-- +info: @Library.Bytes.address_eq_spec : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F], + Library.U64.Compatible F → ∀ (a b : Library.Bytes.Address), Library.Bytes.addressEq F a b = if a = b then 1 else 0 +-/ +#guard_msgs in +#check @Aiur.Library.Bytes.address_eq_spec +/-- info: 'Aiur.Library.Bytes.address_eq_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Bytes.address_eq_spec + +/-- +info: @Library.Bytes.address_eq_one_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F], + Library.U64.Compatible F → ∀ (a b : Library.Bytes.Address), Library.Bytes.addressEq F a b = 1 ↔ a = b +-/ +#guard_msgs in +#check @Aiur.Library.Bytes.address_eq_one_iff +/-- info: 'Aiur.Library.Bytes.address_eq_one_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Bytes.address_eq_one_iff + +/-- +info: @Library.Bytes.address_eq_zero_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F], + Library.U64.Compatible F → ∀ (a b : Library.Bytes.Address), Library.Bytes.addressEq F a b = 0 ↔ a ≠ b +-/ +#guard_msgs in +#check @Aiur.Library.Bytes.address_eq_zero_iff +/-- info: 'Aiur.Library.Bytes.address_eq_zero_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Bytes.address_eq_zero_iff + +/-- +info: Library.Bytes.read_byte_stream_length : ∀ (stream : ℕ → UInt8) (idx len : ℕ), + (Library.Bytes.readByteStream stream idx len).length = len +-/ +#guard_msgs in +#check @Aiur.Library.Bytes.read_byte_stream_length +/-- info: 'Aiur.Library.Bytes.read_byte_stream_length' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.Bytes.read_byte_stream_length + +/-- +info: Library.Bytes.read_byte_stream_getElem : ∀ (stream : ℕ → UInt8) (idx len i : ℕ) (hi : i < len), + (Library.Bytes.readByteStream stream idx len)[i] = stream (idx + i) +-/ +#guard_msgs in +#check @Aiur.Library.Bytes.read_byte_stream_getElem +/-- info: 'Aiur.Library.Bytes.read_byte_stream_getElem' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Bytes.read_byte_stream_getElem + +/-- +info: @Library.Bytes.alloc_byte_stream_extends : ∀ {F : Type} [inst : NatCast F] (enumName : String) (h : Heap F) + (bytes : List UInt8), h.Extends (Library.Bytes.allocByteStream enumName h bytes).2 +-/ +#guard_msgs in +#check @Aiur.Library.Bytes.alloc_byte_stream_extends +/-- info: 'Aiur.Library.Bytes.alloc_byte_stream_extends' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.Bytes.alloc_byte_stream_extends + +/-- +info: @Library.Bytes.alloc_byte_stream_rep : ∀ {F : Type} [inst : NatCast F] (enumName : String) (h : Heap F) + (bytes : List UInt8), + Library.Bytes.RepByteStream enumName (Library.Bytes.allocByteStream enumName h bytes).2 bytes + (Library.Bytes.allocByteStream enumName h bytes).1 +-/ +#guard_msgs in +#check @Aiur.Library.Bytes.alloc_byte_stream_rep +/-- info: 'Aiur.Library.Bytes.alloc_byte_stream_rep' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Bytes.alloc_byte_stream_rep + +/-- +info: @Library.Bytes.read_byte_stream_spec : ∀ {F : Type} [inst : NatCast F] (enumName : String) (stream : ℕ → UInt8) + (idx len : ℕ) (h : Heap F), + have bytes := Library.Bytes.readByteStream stream idx len; + have allocated := Library.Bytes.allocByteStream enumName h bytes; + h.Extends allocated.2 ∧ Library.Bytes.RepByteStream enumName allocated.2 bytes allocated.1 ∧ bytes.length = len +-/ +#guard_msgs in +#check @Aiur.Library.Bytes.read_byte_stream_spec +/-- info: 'Aiur.Library.Bytes.read_byte_stream_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Bytes.read_byte_stream_spec + +/-- +info: @Library.Bytes.read_finite_byte_stream_spec : ∀ {F : Type} [inst : NatCast F] (enumName : String) (stream : ℕ → UInt8) + (idx len : ℕ) (h : Heap F), + have bytes := Library.Bytes.readByteStream stream idx len; + have allocated := Library.Bytes.allocByteStream enumName h bytes; + (Library.List.Word.depthChecked bytes = some len ↔ len < Library.U32.base) ∧ + h.Extends allocated.2 ∧ Library.Bytes.RepByteStream enumName allocated.2 bytes allocated.1 ∧ bytes.length = len +-/ +#guard_msgs in +#check @Aiur.Library.Bytes.read_finite_byte_stream_spec +/-- info: 'Aiur.Library.Bytes.read_finite_byte_stream_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.Bytes.read_finite_byte_stream_spec + +/-! ## Step & Inversion Lemmas and Hint-Invariance (`Aiur.StepLemmas`) -/ + +/-- +info: @evalExpr_literal_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {value : F} {before : Heap F} {result : SourceValue F} {after : Heap F}, + EvalExpr program locals (Expr.literal value) before result after ↔ result = Value.field value ∧ after = before +-/ +#guard_msgs in +#check @Aiur.evalExpr_literal_iff +/-- info: 'Aiur.evalExpr_literal_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalExpr_literal_iff + +/-- +info: @evalExpr_var_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {name : String} {before : Heap F} {result : SourceValue F} {after : Heap F}, + EvalExpr program locals (Expr.var name) before result after ↔ + List.find? (fun x => x.1 == name) locals = some (name, result) ∧ after = before +-/ +#guard_msgs in +#check @Aiur.evalExpr_var_iff +/-- info: 'Aiur.evalExpr_var_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalExpr_var_iff + +/-- +info: @evalExpr_tuple_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {exprs : List (Expr F)} {before : Heap F} {result : SourceValue F} {after : Heap F}, + EvalExpr program locals (Expr.tuple exprs) before result after ↔ + ∃ values, EvalArgs program locals exprs before values after ∧ result = Value.tuple values +-/ +#guard_msgs in +#check @Aiur.evalExpr_tuple_iff +/-- info: 'Aiur.evalExpr_tuple_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalExpr_tuple_iff + +/-- +info: @evalExpr_construct_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {name ctor : String} {exprs : List (Expr F)} {before : Heap F} {result : SourceValue F} + {after : Heap F}, + EvalExpr program locals (Expr.construct name ctor exprs) before result after ↔ + ∃ values, EvalArgs program locals exprs before values after ∧ result = Value.construct name ctor values +-/ +#guard_msgs in +#check @Aiur.evalExpr_construct_iff +/-- info: 'Aiur.evalExpr_construct_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalExpr_construct_iff + +/-- +info: @evalExpr_project_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {expr : Expr F} {index : ℕ} {before : Heap F} {result : SourceValue F} {after : Heap F}, + EvalExpr program locals (expr.project index) before result after ↔ + ∃ input, EvalExpr program locals expr before input after ∧ projectValue input index = Except.ok result +-/ +#guard_msgs in +#check @Aiur.evalExpr_project_iff +/-- info: 'Aiur.evalExpr_project_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalExpr_project_iff + +/-- +info: @evalExpr_letValue_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {pattern : Pattern F} {expr rest : Expr F} {before : Heap F} {result : SourceValue F} + {after : Heap F}, + EvalExpr program locals (Expr.letValue pattern expr rest) before result after ↔ + ∃ input middle bindings, + EvalExpr program locals expr before input middle ∧ + pattern.bindings input = some bindings ∧ EvalExpr program (bindings ++ locals) rest middle result after +-/ +#guard_msgs in +#check @Aiur.evalExpr_letValue_iff +/-- info: 'Aiur.evalExpr_letValue_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalExpr_letValue_iff + +/-- +info: @evalExpr_store_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {expr : Expr F} {before : Heap F} {result : SourceValue F} {after : Heap F}, + EvalExpr program locals expr.store before result after ↔ + ∃ input middle, + EvalExpr program locals expr before input middle ∧ + result = Value.ptr (Value.type input) (List.length middle) ∧ after = middle ++ [input] +-/ +#guard_msgs in +#check @Aiur.evalExpr_store_iff +/-- info: 'Aiur.evalExpr_store_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalExpr_store_iff + +/-- +info: @evalExpr_load_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {expr : Expr F} {before : Heap F} {result : SourceValue F} {after : Heap F}, + EvalExpr program locals expr.load before result after ↔ + ∃ input, EvalExpr program locals expr before input after ∧ loadValue after input = Except.ok result +-/ +#guard_msgs in +#check @Aiur.evalExpr_load_iff +/-- info: 'Aiur.evalExpr_load_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalExpr_load_iff + +/-- +info: @evalExpr_hint_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {type : Ty} {expr : Expr F} {channel : String} {before : Heap F} {result : SourceValue F} + {after : Heap F}, + EvalExpr program locals (Expr.hint type expr channel) before result after ↔ + ∃ input value, + EvalExpr program locals expr before input after ∧ + Value.WellTyped program.enums value type ∧ result = value.toValue +-/ +#guard_msgs in +#check @Aiur.evalExpr_hint_iff +/-- info: 'Aiur.evalExpr_hint_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalExpr_hint_iff + +/-- +info: @evalExpr_neg_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {expr : Expr F} {before : Heap F} {result : SourceValue F} {after : Heap F}, + EvalExpr program locals expr.neg before result after ↔ + ∃ input, EvalExpr program locals expr before input after ∧ evalNeg input = Except.ok result +-/ +#guard_msgs in +#check @Aiur.evalExpr_neg_iff +/-- info: 'Aiur.evalExpr_neg_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalExpr_neg_iff + +/-- +info: @evalExpr_assertEq_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {op : Assertion} {lhs rhs : Expr F} {before : Heap F} {result : SourceValue F} + {after : Heap F}, + EvalExpr program locals (Expr.assertEq op lhs rhs) before result after ↔ + ∃ x middle y, + EvalExpr program locals lhs before x middle ∧ + EvalExpr program locals rhs middle y after ∧ evalAssertEq op x y = Except.ok result +-/ +#guard_msgs in +#check @Aiur.evalExpr_assertEq_iff +/-- info: 'Aiur.evalExpr_assertEq_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalExpr_assertEq_iff + +/-- +info: @evalExpr_binary_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {op : BinOp} {lhs rhs : Expr F} {before : Heap F} {result : SourceValue F} + {after : Heap F}, + EvalExpr program locals (Expr.binary op lhs rhs) before result after ↔ + ∃ x middle y, + EvalExpr program locals lhs before x middle ∧ + EvalExpr program locals rhs middle y after ∧ evalBinOp op x y = Except.ok result +-/ +#guard_msgs in +#check @Aiur.evalExpr_binary_iff +/-- info: 'Aiur.evalExpr_binary_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalExpr_binary_iff + +/-- +info: @evalExpr_call_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {name : String} {args : List (Expr F)} {before : Heap F} {result : SourceValue F} + {after : Heap F}, + EvalExpr program locals (Expr.call name args) before result after ↔ + ∃ values middle, EvalArgs program locals args before values middle ∧ EvalFn program name values middle result after +-/ +#guard_msgs in +#check @Aiur.evalExpr_call_iff +/-- info: 'Aiur.evalExpr_call_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalExpr_call_iff + +/-- +info: @evalFn_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} {name : String} + {args : List (SourceValue F)} {before : Heap F} {result : SourceValue F} {after : Heap F}, + EvalFn program name args before result after ↔ + ∃ locals expr, + prepareCall program name args = Except.ok (locals, expr) ∧ EvalExpr program locals expr before result after +-/ +#guard_msgs in +#check @Aiur.evalFn_iff +/-- info: 'Aiur.evalFn_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalFn_iff + +/-- +info: @evalExpr_call_function_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {name : String} {«fn» : Function F} {args : List (Expr F)} {before : Heap F} + {result : SourceValue F} {after : Heap F}, + program.findFunction? name = some «fn» → + (EvalExpr program locals (Expr.call name args) before result after ↔ + ∃ values middle, + EvalArgs program locals args before values middle ∧ + List.map Prod.snd «fn».params = List.map Value.type values ∧ + (∀ arg ∈ values, Value.wellFormed program.enums arg = true) ∧ + EvalExpr program ((List.map Prod.fst «fn».params).zip values) «fn».body middle result after) +-/ +#guard_msgs in +#check @Aiur.evalExpr_call_function_iff +/-- info: 'Aiur.evalExpr_call_function_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalExpr_call_function_iff + +/-- +info: @evalExpr_call_table_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {name : String} {args : List (Expr F)} {before : Heap F} {result : SourceValue F} + {after : Heap F}, + program.findFunction? name = none → + (EvalExpr program locals (Expr.call name args) before result after ↔ + ∃ values value, + EvalArgs program locals args before values after ∧ + lookupMap program name values = Except.ok value ∧ result = value.toValue) +-/ +#guard_msgs in +#check @Aiur.evalExpr_call_table_iff +/-- info: 'Aiur.evalExpr_call_table_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalExpr_call_table_iff + +/-- +info: @evalExpr_matchValue_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {expr : Expr F} {arms : List (Pattern F × Expr F)} {before : Heap F} + {result : SourceValue F} {after : Heap F}, + EvalExpr program locals (expr.matchValue arms) before result after ↔ + ∃ input middle bindings body, + EvalExpr program locals expr before input middle ∧ + selectArm input arms = some (bindings, body) ∧ EvalExpr program (bindings ++ locals) body middle result after +-/ +#guard_msgs in +#check @Aiur.evalExpr_matchValue_iff +/-- info: 'Aiur.evalExpr_matchValue_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalExpr_matchValue_iff + +/-- +info: @evalArgs_nil_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {before : Heap F} {values : List (SourceValue F)} {after : Heap F}, + EvalArgs program locals [] before values after ↔ values = [] ∧ after = before +-/ +#guard_msgs in +#check @Aiur.evalArgs_nil_iff +/-- info: 'Aiur.evalArgs_nil_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalArgs_nil_iff + +/-- +info: @evalArgs_cons_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {expr : Expr F} {exprs : List (Expr F)} {before : Heap F} {results : List (SourceValue F)} + {after : Heap F}, + EvalArgs program locals (expr :: exprs) before results after ↔ + ∃ value middle values, + EvalExpr program locals expr before value middle ∧ + EvalArgs program locals exprs middle values after ∧ results = value :: values +-/ +#guard_msgs in +#check @Aiur.evalArgs_cons_iff +/-- info: 'Aiur.evalArgs_cons_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalArgs_cons_iff + +/-- +info: @evalExpr_let_hint_invariance : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} + {locals : Environment F ℕ} {pattern : Pattern F} {type : Ty} {keyExpr : Expr F} {channel : String} {rest : Expr F} + {before : Heap F} {result : SourceValue F} {after : Heap F} {P : Constant F → SourceValue F → Heap F → Prop}, + EvalExpr program locals (Expr.letValue pattern (Expr.hint type keyExpr channel) rest) before result after → + (∀ (c : Constant F) (middle : Heap F) (bindings : Environment F ℕ), + Value.WellTyped program.enums c type → + pattern.bindings c.toValue = some bindings → + EvalExpr program (bindings ++ locals) rest middle result after → P c result after) → + ∃ c, Value.WellTyped program.enums c type ∧ P c result after +-/ +#guard_msgs in +#check @Aiur.evalExpr_let_hint_invariance +/-- info: 'Aiur.evalExpr_let_hint_invariance' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalExpr_let_hint_invariance + +/-- +info: @evalFn_hint_invariance : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Program F} {name : String} + {«fn» : Function F} {args : List (SourceValue F)} {before : Heap F} {result : SourceValue F} {after : Heap F} + {pattern : Pattern F} {type : Ty} {keyExpr : Expr F} {channel : String} {rest : Expr F} + {P : Constant F → SourceValue F → Heap F → Prop}, + program.findFunction? name = some «fn» → + «fn».body = Expr.letValue pattern (Expr.hint type keyExpr channel) rest → + EvalFn program name args before result after → + (∀ (c : Constant F) (middle : Heap F) (bindings : Environment F ℕ), + Value.WellTyped program.enums c type → + pattern.bindings c.toValue = some bindings → + EvalExpr program (bindings ++ (List.map Prod.fst «fn».params).zip args) rest middle result after → + P c result after) → + ∃ c, Value.WellTyped program.enums c type ∧ P c result after +-/ +#guard_msgs in +#check @Aiur.evalFn_hint_invariance +/-- info: 'Aiur.evalFn_hint_invariance' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.evalFn_hint_invariance + +/-- +info: @Generic.SourceSemantics.evalExpr_literal_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {value : F} {before : Heap F} {result : SourceValue F} {after : Heap F}, + Generic.SourceSemantics.EvalExpr world types locals (Generic.Expr.literal value) before result after ↔ + result = Value.field value ∧ after = before +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.evalExpr_literal_iff +/-- info: 'Aiur.Generic.SourceSemantics.evalExpr_literal_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.evalExpr_literal_iff + +/-- +info: @Generic.SourceSemantics.evalExpr_var_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {name : String} {before : Heap F} {result : SourceValue F} {after : Heap F}, + Generic.SourceSemantics.EvalExpr world types locals (Generic.Expr.var name) before result after ↔ + List.find? (fun x => x.1 == name) locals = some (name, result) ∧ after = before +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.evalExpr_var_iff +/-- info: 'Aiur.Generic.SourceSemantics.evalExpr_var_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.evalExpr_var_iff + +/-- +info: @Generic.SourceSemantics.evalExpr_tuple_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {exprs : List (Generic.Expr F)} {before : Heap F} {result : SourceValue F} {after : Heap F}, + Generic.SourceSemantics.EvalExpr world types locals (Generic.Expr.tuple exprs) before result after ↔ + ∃ values, + Generic.SourceSemantics.EvalArgs world types locals exprs before values after ∧ result = Value.tuple values +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.evalExpr_tuple_iff +/-- info: 'Aiur.Generic.SourceSemantics.evalExpr_tuple_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.evalExpr_tuple_iff + +/-- +info: @Generic.SourceSemantics.evalExpr_array_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {exprs : List (Generic.Expr F)} {before : Heap F} {result : SourceValue F} {after : Heap F}, + Generic.SourceSemantics.EvalExpr world types locals (Generic.Expr.array exprs) before result after ↔ + ∃ values, + Generic.SourceSemantics.EvalArgs world types locals exprs before values after ∧ result = Value.tuple values +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.evalExpr_array_iff +/-- info: 'Aiur.Generic.SourceSemantics.evalExpr_array_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.evalExpr_array_iff + +/-- +info: @Generic.SourceSemantics.evalExpr_let_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {pattern : Generic.Pattern F} {expr rest : Generic.Expr F} {before : Heap F} {result : SourceValue F} + {after : Heap F}, + Generic.SourceSemantics.EvalExpr world types locals (Generic.Expr.letValue pattern expr rest) before result after ↔ + ∃ input middle bindings, + Generic.SourceSemantics.EvalExpr world types locals expr before input middle ∧ + world.matchPattern types middle pattern input = Except.ok (some bindings) ∧ + Generic.SourceSemantics.EvalExpr world types (bindings ++ locals) rest middle result after +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.evalExpr_let_iff +/-- info: 'Aiur.Generic.SourceSemantics.evalExpr_let_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.evalExpr_let_iff + +/-- +info: @Generic.SourceSemantics.evalExpr_store_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {expr : Generic.Expr F} {before : Heap F} {result : SourceValue F} {after : Heap F}, + Generic.SourceSemantics.EvalExpr world types locals expr.store before result after ↔ + ∃ input middle, + Generic.SourceSemantics.EvalExpr world types locals expr before input middle ∧ + result = Value.ptr (Value.type input) (List.length middle) ∧ after = middle ++ [input] +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.evalExpr_store_iff +/-- info: 'Aiur.Generic.SourceSemantics.evalExpr_store_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.evalExpr_store_iff + +/-- +info: @Generic.SourceSemantics.evalExpr_load_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {expr : Generic.Expr F} {before : Heap F} {result : SourceValue F} {after : Heap F}, + Generic.SourceSemantics.EvalExpr world types locals expr.load before result after ↔ + ∃ input, + Generic.SourceSemantics.EvalExpr world types locals expr before input after ∧ + loadValue after input = Except.ok result +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.evalExpr_load_iff +/-- info: 'Aiur.Generic.SourceSemantics.evalExpr_load_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.evalExpr_load_iff + +/-- +info: @Generic.SourceSemantics.evalExpr_hint_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {t : Generic.Ty} {expr : Generic.Expr F} {channel : String} {before : Heap F} {result : SourceValue F} + {after : Heap F}, + Generic.SourceSemantics.EvalExpr world types locals (Generic.Expr.hint t expr channel) before result after ↔ + ∃ input value, + Generic.SourceSemantics.EvalExpr world types locals expr before input after ∧ + world.typed (Generic.Ty.subst types t).toCore value = true ∧ result = value.toValue +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.evalExpr_hint_iff +/-- info: 'Aiur.Generic.SourceSemantics.evalExpr_hint_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.evalExpr_hint_iff + +/-- +info: @Generic.SourceSemantics.evalExpr_builtin_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {operation : Generic.Builtin} {exprs : List (Generic.Expr F)} {before : Heap F} {result : SourceValue F} + {after : Heap F}, + Generic.SourceSemantics.EvalExpr world types locals (Generic.Expr.builtin operation exprs) before result after ↔ + ∃ values, + Generic.SourceSemantics.EvalArgs world types locals exprs before values after ∧ + operation.apply values = Except.ok result +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.evalExpr_builtin_iff +/-- info: 'Aiur.Generic.SourceSemantics.evalExpr_builtin_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.evalExpr_builtin_iff + +/-- +info: @Generic.SourceSemantics.evalArgs_nil_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {before : Heap F} {values : List (SourceValue F)} {after : Heap F}, + Generic.SourceSemantics.EvalArgs world types locals [] before values after ↔ values = [] ∧ after = before +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.evalArgs_nil_iff +/-- info: 'Aiur.Generic.SourceSemantics.evalArgs_nil_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.evalArgs_nil_iff + +/-- +info: @Generic.SourceSemantics.evalArgs_cons_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {expr : Generic.Expr F} {exprs : List (Generic.Expr F)} {before : Heap F} {results : List (SourceValue F)} + {after : Heap F}, + Generic.SourceSemantics.EvalArgs world types locals (expr :: exprs) before results after ↔ + ∃ value middle values, + Generic.SourceSemantics.EvalExpr world types locals expr before value middle ∧ + Generic.SourceSemantics.EvalArgs world types locals exprs middle values after ∧ results = value :: values +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.evalArgs_cons_iff +/-- info: 'Aiur.Generic.SourceSemantics.evalArgs_cons_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.evalArgs_cons_iff + +/-- +info: @Generic.SourceSemantics.evalExpr_assertEq_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {assertion : Assertion} {lhs rhs : Generic.Expr F} {before : Heap F} {result : SourceValue F} {after : Heap F}, + Generic.SourceSemantics.EvalExpr world types locals + (Generic.Expr.builtin (Generic.Builtin.assertEq assertion) [lhs, rhs]) before result after ↔ + ∃ x middle y, + Generic.SourceSemantics.EvalExpr world types locals lhs before x middle ∧ + Generic.SourceSemantics.EvalExpr world types locals rhs middle y after ∧ + evalAssertEq assertion x y = Except.ok result +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.evalExpr_assertEq_iff +/-- info: 'Aiur.Generic.SourceSemantics.evalExpr_assertEq_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.evalExpr_assertEq_iff + +/-- +info: @Generic.SourceSemantics.evalExpr_binary_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {op : BinOp} {lhs rhs : Generic.Expr F} {before : Heap F} {result : SourceValue F} {after : Heap F}, + Generic.SourceSemantics.EvalExpr world types locals (Generic.Expr.binary op lhs rhs) before result after ↔ + ∃ x middle y, + Generic.SourceSemantics.EvalExpr world types locals lhs before x middle ∧ + Generic.SourceSemantics.EvalExpr world types locals rhs middle y after ∧ evalBinOp op x y = Except.ok result +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.evalExpr_binary_iff +/-- info: 'Aiur.Generic.SourceSemantics.evalExpr_binary_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.evalExpr_binary_iff + +/-- +info: @Generic.SourceSemantics.evalExpr_neg_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {expr : Generic.Expr F} {before : Heap F} {result : SourceValue F} {after : Heap F}, + Generic.SourceSemantics.EvalExpr world types locals expr.neg before result after ↔ + ∃ input, + Generic.SourceSemantics.EvalExpr world types locals expr before input after ∧ evalNeg input = Except.ok result +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.evalExpr_neg_iff +/-- info: 'Aiur.Generic.SourceSemantics.evalExpr_neg_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.evalExpr_neg_iff + +/-- +info: @Generic.SourceSemantics.evalExpr_block_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {label : String} {expr : Generic.Expr F} {before : Heap F} {result : SourceValue F} {after : Heap F}, + Generic.SourceSemantics.EvalExpr world types locals (Generic.Expr.control (Generic.Control.block label) expr) before + result after ↔ + Generic.SourceSemantics.EvalExpr world types locals expr before result after ∨ + Generic.SourceSemantics.EvalExit world types locals expr before (Generic.ExitTarget.block label) result after +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.evalExpr_block_iff +/-- info: 'Aiur.Generic.SourceSemantics.evalExpr_block_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.evalExpr_block_iff + +/-- +info: @Generic.SourceSemantics.evalExpr_call_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {name : String} {typeArgs : Option (List Generic.Ty)} {args : List (Generic.Expr F)} {before : Heap F} + {result : SourceValue F} {after : Heap F}, + Generic.SourceSemantics.EvalExpr world types locals (Generic.Expr.call name typeArgs args) before result after ↔ + ∃ values middle, + Generic.SourceSemantics.EvalArgs world types locals args before values middle ∧ + Generic.SourceSemantics.EvalFn world (Generic.SourceSemantics.instanceName types name typeArgs) values middle + result after +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.evalExpr_call_iff +/-- info: 'Aiur.Generic.SourceSemantics.evalExpr_call_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.evalExpr_call_iff + +/-- +info: @Generic.SourceSemantics.evalExpr_matchValue_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {expr : Generic.Expr F} {arms : List (Generic.Pattern F × Generic.Expr F)} {before : Heap F} {result : SourceValue F} + {after : Heap F}, + Generic.SourceSemantics.EvalExpr world types locals (expr.matchValue arms) before result after ↔ + ∃ input middle bindings body, + Generic.SourceSemantics.EvalExpr world types locals expr before input middle ∧ + Generic.SourceSemantics.selectArm world types middle input arms = Except.ok (some (bindings, body)) ∧ + Generic.SourceSemantics.EvalExpr world types (bindings ++ locals) body middle result after +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.evalExpr_matchValue_iff +/-- info: 'Aiur.Generic.SourceSemantics.evalExpr_matchValue_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.evalExpr_matchValue_iff + +/-- +info: @Generic.SourceSemantics.evalFn_step_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {name : String} {args : List (SourceValue F)} {before : Heap F} + {result : SourceValue F} {after : Heap F}, + Generic.SourceSemantics.EvalFn world name args before result after ↔ + ∃ types locals expr, + world.prepare name args = Except.ok (types, locals, expr) ∧ + (Generic.SourceSemantics.EvalExpr world types locals expr before result after ∨ + Generic.SourceSemantics.EvalExit world types locals expr before Generic.ExitTarget.function result after) +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.evalFn_step_iff +/-- info: 'Aiur.Generic.SourceSemantics.evalFn_step_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.evalFn_step_iff + +/-- +info: @Generic.SourceSemantics.evalExpr_let_hint_invariance : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] + {world : Generic.SourceSemantics.World F} {types : Generic.SourceSemantics.Types} {locals : Environment F ℕ} + {pattern : Generic.Pattern F} {t : Generic.Ty} {keyExpr : Generic.Expr F} {channel : String} {rest : Generic.Expr F} + {before : Heap F} {result : SourceValue F} {after : Heap F} {P : Constant F → SourceValue F → Heap F → Prop}, + Generic.SourceSemantics.EvalExpr world types locals + (Generic.Expr.letValue pattern (Generic.Expr.hint t keyExpr channel) rest) before result after → + (∀ (c : Constant F) (middle : Heap F) (bindings : Environment F ℕ), + world.typed (Generic.Ty.subst types t).toCore c = true → + world.matchPattern types middle pattern c.toValue = Except.ok (some bindings) → + Generic.SourceSemantics.EvalExpr world types (bindings ++ locals) rest middle result after → + P c result after) → + ∃ c, world.typed (Generic.Ty.subst types t).toCore c = true ∧ P c result after +-/ +#guard_msgs in +#check @Aiur.Generic.SourceSemantics.evalExpr_let_hint_invariance +/-- info: 'Aiur.Generic.SourceSemantics.evalExpr_let_hint_invariance' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.SourceSemantics.evalExpr_let_hint_invariance + +/-- +info: @Modules.Prepared.evalFn_iff : ∀ {F : Type} [inst : Field F] [inst_1 : DecidableEq F] {program : Modules.Program F} + {p : Modules.Prepared program} {name : String} {args : List (SourceValue F)} {value : SourceValue F} {heap : Heap F}, + p.EvalFn name args value heap ↔ + ∃ entry, + p.find? name = some entry ∧ + Generic.SourceSemantics.EvalFn p.environment.source.world entry.resolved.name args [] value heap +-/ +#guard_msgs in +#check @Aiur.Modules.Prepared.evalFn_iff +/-- info: 'Aiur.Modules.Prepared.evalFn_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Modules.Prepared.evalFn_iff + + +/-! ## Red-Black Tree (`RBTreeMap` / `RoleMap`) Correctness (`Aiur.Library.RBTreeMap.Correctness`) -/ + +/-- +info: @Library.RBTreeMap.LawfulCmp.cmp_refl : ∀ {K : Type u_1} {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → ∀ (x : K), cmp x x = Ordering.eq +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.LawfulCmp.cmp_refl +/-- info: 'Aiur.Library.RBTreeMap.LawfulCmp.cmp_refl' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.LawfulCmp.cmp_refl + +/-- +info: @Library.RBTreeMap.LawfulCmp.lt_irrefl : ∀ {K : Type u_1} {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → ∀ (x : K), cmp x x ≠ Ordering.lt +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.LawfulCmp.lt_irrefl +/-- info: 'Aiur.Library.RBTreeMap.LawfulCmp.lt_irrefl' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.LawfulCmp.lt_irrefl + +/-- +info: @Library.RBTreeMap.LawfulCmp.gt_irrefl : ∀ {K : Type u_1} {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → ∀ (x : K), cmp x x ≠ Ordering.gt +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.LawfulCmp.gt_irrefl +/-- info: 'Aiur.Library.RBTreeMap.LawfulCmp.gt_irrefl' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.LawfulCmp.gt_irrefl + +/-- +info: @Library.RBTreeMap.LawfulCmp.lt_asymm : ∀ {K : Type u_1} {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → ∀ {x y : K}, cmp x y = Ordering.lt → cmp y x ≠ Ordering.lt +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.LawfulCmp.lt_asymm +/-- info: 'Aiur.Library.RBTreeMap.LawfulCmp.lt_asymm' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.LawfulCmp.lt_asymm + +/-- +info: @Library.RBTreeMap.LawfulCmp.lt_ne : ∀ {K : Type u_1} {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → ∀ {x y : K}, cmp x y = Ordering.lt → x ≠ y +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.LawfulCmp.lt_ne +/-- info: 'Aiur.Library.RBTreeMap.LawfulCmp.lt_ne' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.LawfulCmp.lt_ne + +/-- +info: @Library.RBTreeMap.LawfulCmp.gt_of_lt : ∀ {K : Type u_1} {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → ∀ {x y : K}, cmp x y = Ordering.lt → cmp y x = Ordering.gt +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.LawfulCmp.gt_of_lt +/-- info: 'Aiur.Library.RBTreeMap.LawfulCmp.gt_of_lt' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.LawfulCmp.gt_of_lt + +/-- +info: @Library.RBTreeMap.LawfulCmp.lt_of_gt : ∀ {K : Type u_1} {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → ∀ {x y : K}, cmp x y = Ordering.gt → cmp y x = Ordering.lt +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.LawfulCmp.lt_of_gt +/-- info: 'Aiur.Library.RBTreeMap.LawfulCmp.lt_of_gt' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.LawfulCmp.lt_of_gt + +/-- +info: @Library.RBTreeMap.LawfulCmp.trichotomous : ∀ {K : Type u_1} {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → ∀ (x y : K), cmp x y = Ordering.lt ∨ x = y ∨ cmp y x = Ordering.lt +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.LawfulCmp.trichotomous +/-- info: 'Aiur.Library.RBTreeMap.LawfulCmp.trichotomous' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.LawfulCmp.trichotomous + +/-- info: Library.RBTreeMap.lawfulCmp_nat : Library.RBTreeMap.LawfulCmp compare -/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.lawfulCmp_nat +/-- info: 'Aiur.Library.RBTreeMap.lawfulCmp_nat' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.lawfulCmp_nat + +/-- +info: Library.RBTreeMap.canonOrdThen_assoc : ∀ (a b c : Ordering), + Library.RBTreeMap.canonOrdThen (Library.RBTreeMap.canonOrdThen a b) c = + Library.RBTreeMap.canonOrdThen a (Library.RBTreeMap.canonOrdThen b c) +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.canonOrdThen_assoc +/-- info: 'Aiur.Library.RBTreeMap.canonOrdThen_assoc' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.canonOrdThen_assoc + +/-- +info: @Library.RBTreeMap.lexCmpNat_append : ∀ {xs₁ ys₁ : List ℕ}, + xs₁.length = ys₁.length → + ∀ (xs₂ ys₂ : List ℕ), + Library.RBTreeMap.lexCmpNat (xs₁ ++ xs₂) (ys₁ ++ ys₂) = + Library.RBTreeMap.canonOrdThen (Library.RBTreeMap.lexCmpNat xs₁ ys₁) (Library.RBTreeMap.lexCmpNat xs₂ ys₂) +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.lexCmpNat_append +/-- info: 'Aiur.Library.RBTreeMap.lexCmpNat_append' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.lexCmpNat_append + +/-- info: Library.RBTreeMap.lawfulCmp_lexCmpNat : Library.RBTreeMap.LawfulCmp Library.RBTreeMap.lexCmpNat -/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.lawfulCmp_lexCmpNat +/-- info: 'Aiur.Library.RBTreeMap.lawfulCmp_lexCmpNat' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.lawfulCmp_lexCmpNat + +/-- +info: Library.RBTreeMap.compare_chunkVal_eq_lexCmpNat : ∀ (x0 x1 x2 x3 y0 y1 y2 y3 : UInt8), + compare (Library.RBTreeMap.chunkVal x0 x1 x2 x3) (Library.RBTreeMap.chunkVal y0 y1 y2 y3) = + Library.RBTreeMap.lexCmpNat [x0.toNat, x1.toNat, x2.toNat, x3.toNat] [y0.toNat, y1.toNat, y2.toNat, y3.toNat] +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.compare_chunkVal_eq_lexCmpNat +/-- info: 'Aiur.Library.RBTreeMap.compare_chunkVal_eq_lexCmpNat' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.compare_chunkVal_eq_lexCmpNat + +/-- info: Library.RBTreeMap.lawfulCmp_canonAddrCmp : Library.RBTreeMap.LawfulCmp Library.RBTreeMap.canonAddrCmp -/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.lawfulCmp_canonAddrCmp +/-- info: 'Aiur.Library.RBTreeMap.lawfulCmp_canonAddrCmp' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.lawfulCmp_canonAddrCmp + +/-- info: Library.RBTreeMap.canon_addr_cmp_refl : ∀ (x : Library.Bytes.Address), Library.RBTreeMap.canonAddrCmp x x = Ordering.eq -/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.canon_addr_cmp_refl +/-- info: 'Aiur.Library.RBTreeMap.canon_addr_cmp_refl' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.canon_addr_cmp_refl + +/-- +info: Library.RBTreeMap.canon_addr_cmp_eq_iff : ∀ (x y : Library.Bytes.Address), + Library.RBTreeMap.canonAddrCmp x y = Ordering.eq ↔ x = y +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.canon_addr_cmp_eq_iff +/-- info: 'Aiur.Library.RBTreeMap.canon_addr_cmp_eq_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.canon_addr_cmp_eq_iff + +/-- info: Library.RBTreeMap.canon_addr_cmp_irrefl : ∀ (x : Library.Bytes.Address), ¬Library.RBTreeMap.canonAddrLt x x -/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.canon_addr_cmp_irrefl +/-- info: 'Aiur.Library.RBTreeMap.canon_addr_cmp_irrefl' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.canon_addr_cmp_irrefl + +/-- +info: @Library.RBTreeMap.canon_addr_cmp_trans : ∀ {x y z : Library.Bytes.Address}, + Library.RBTreeMap.canonAddrLt x y → Library.RBTreeMap.canonAddrLt y z → Library.RBTreeMap.canonAddrLt x z +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.canon_addr_cmp_trans +/-- info: 'Aiur.Library.RBTreeMap.canon_addr_cmp_trans' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.canon_addr_cmp_trans + +/-- +info: @Library.RBTreeMap.canon_addr_cmp_asymm : ∀ {x y : Library.Bytes.Address}, + Library.RBTreeMap.canonAddrLt x y → ¬Library.RBTreeMap.canonAddrLt y x +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.canon_addr_cmp_asymm +/-- info: 'Aiur.Library.RBTreeMap.canon_addr_cmp_asymm' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.canon_addr_cmp_asymm + +/-- +info: Library.RBTreeMap.canon_addr_cmp_trichotomous : ∀ (x y : Library.Bytes.Address), + Library.RBTreeMap.canonAddrLt x y ∨ x = y ∨ Library.RBTreeMap.canonAddrLt y x +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.canon_addr_cmp_trichotomous +/-- info: 'Aiur.Library.RBTreeMap.canon_addr_cmp_trichotomous' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.canon_addr_cmp_trichotomous + +/-- +info: Library.RBTreeMap.canon_addr_cmp_gt_iff : ∀ (x y : Library.Bytes.Address), + Library.RBTreeMap.canonAddrCmp x y = Ordering.gt ↔ Library.RBTreeMap.canonAddrLt y x +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.canon_addr_cmp_gt_iff +/-- info: 'Aiur.Library.RBTreeMap.canon_addr_cmp_gt_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.canon_addr_cmp_gt_iff + +/-- +info: @Library.RBTreeMap.RBTree.ofBinaryTree_toBinaryTree : ∀ {K : Type u_1} {V : Type u_2} + (t : Library.RBTreeMap.RBTree K V), Library.RBTreeMap.RBTree.ofBinaryTree t.toBinaryTree = t +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.RBTree.ofBinaryTree_toBinaryTree +/-- info: 'Aiur.Library.RBTreeMap.RBTree.ofBinaryTree_toBinaryTree' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.RBTree.ofBinaryTree_toBinaryTree + +/-- +info: @Library.RBTreeMap.RBTree.toBinaryTree_ofBinaryTree : ∀ {K : Type u_1} {V : Type u_2} (t : BinaryTree (ℕ × K × V)), + (Library.RBTreeMap.RBTree.ofBinaryTree t).toBinaryTree = t +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.RBTree.toBinaryTree_ofBinaryTree +/-- info: 'Aiur.Library.RBTreeMap.RBTree.toBinaryTree_ofBinaryTree' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.RBTree.toBinaryTree_ofBinaryTree + +/-- +info: @Library.RBTreeMap.RepRBTreePtr.mono : ∀ {F : Type} {K : Type u_1} {V : Type u_2} {enumName nilCtor nodeCtor : String} + {RLabel : Heap F → ℕ × K × V → SourceValue F → Prop}, + HeapMono₂ RLabel → + ∀ {h₁ h₂ : Heap F} {t : Library.RBTreeMap.RBTree K V} {ptr : SourceValue F}, + h₁.Extends h₂ → + Library.RBTreeMap.RepRBTreePtr enumName nilCtor nodeCtor RLabel h₁ t ptr → + Library.RBTreeMap.RepRBTreePtr enumName nilCtor nodeCtor RLabel h₂ t ptr +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.RepRBTreePtr.mono +/-- info: 'Aiur.Library.RBTreeMap.RepRBTreePtr.mono' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.RepRBTreePtr.mono + +/-- +info: @Library.RBTreeMap.HeapMono.repRBTreePtr : ∀ {F : Type} {K : Type u_1} {V : Type u_2} + (enumName nilCtor nodeCtor : String) {RLabel : Heap F → ℕ × K × V → SourceValue F → Prop}, + HeapMono₂ RLabel → + ∀ (t : Library.RBTreeMap.RBTree K V), + HeapMono fun h ptr => Library.RBTreeMap.RepRBTreePtr enumName nilCtor nodeCtor RLabel h t ptr +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.HeapMono.repRBTreePtr +/-- info: 'Aiur.Library.RBTreeMap.HeapMono.repRBTreePtr' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.HeapMono.repRBTreePtr + +/-- +info: @Library.RBTreeMap.balanceFix_cases : ∀ {K : Type u_1} {V : Type u_2} (k : K) (v : V) + (left right : Library.RBTreeMap.RBTree K V), + (∃ yk yv xk xv a b c, + left = Library.RBTreeMap.RBTree.node 0 yk yv (Library.RBTreeMap.RBTree.node 0 xk xv a b) c ∧ + Library.RBTreeMap.balanceFix k v left right = + Library.RBTreeMap.RBTree.node 0 yk yv (Library.RBTreeMap.RBTree.node 1 xk xv a b) + (Library.RBTreeMap.RBTree.node 1 k v c right)) ∨ + (∃ xk xv a yk yv b c, + left = Library.RBTreeMap.RBTree.node 0 xk xv a (Library.RBTreeMap.RBTree.node 0 yk yv b c) ∧ + Library.RBTreeMap.balanceFix k v left right = + Library.RBTreeMap.RBTree.node 0 yk yv (Library.RBTreeMap.RBTree.node 1 xk xv a b) + (Library.RBTreeMap.RBTree.node 1 k v c right)) ∨ + (∃ zk zv yk yv b c d, + right = Library.RBTreeMap.RBTree.node 0 zk zv (Library.RBTreeMap.RBTree.node 0 yk yv b c) d ∧ + Library.RBTreeMap.balanceFix k v left right = + Library.RBTreeMap.RBTree.node 0 yk yv (Library.RBTreeMap.RBTree.node 1 k v left b) + (Library.RBTreeMap.RBTree.node 1 zk zv c d)) ∨ + (∃ yk yv b zk zv c d, + right = Library.RBTreeMap.RBTree.node 0 yk yv b (Library.RBTreeMap.RBTree.node 0 zk zv c d) ∧ + Library.RBTreeMap.balanceFix k v left right = + Library.RBTreeMap.RBTree.node 0 yk yv (Library.RBTreeMap.RBTree.node 1 k v left b) + (Library.RBTreeMap.RBTree.node 1 zk zv c d)) ∨ + Library.RBTreeMap.balanceFix k v left right = Library.RBTreeMap.RBTree.node 1 k v left right +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.balanceFix_cases +/-- info: 'Aiur.Library.RBTreeMap.balanceFix_cases' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.balanceFix_cases + +/-- +info: @Library.RBTreeMap.AllKeys.imp : ∀ {K : Type u_1} {V : Type u_2} {P Q : K → Prop}, + (∀ (x : K), P x → Q x) → + ∀ {t : Library.RBTreeMap.RBTree K V}, Library.RBTreeMap.AllKeys P t → Library.RBTreeMap.AllKeys Q t +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.AllKeys.imp +/-- info: 'Aiur.Library.RBTreeMap.AllKeys.imp' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.AllKeys.imp + +/-- +info: @Library.RBTreeMap.allKeys_balanceFix : ∀ {K : Type u_1} {V : Type u_2} (P : K → Prop) (k : K) (v : V) + (left right : Library.RBTreeMap.RBTree K V), + Library.RBTreeMap.AllKeys P (Library.RBTreeMap.balanceFix k v left right) ↔ + P k ∧ Library.RBTreeMap.AllKeys P left ∧ Library.RBTreeMap.AllKeys P right +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.allKeys_balanceFix +/-- info: 'Aiur.Library.RBTreeMap.allKeys_balanceFix' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.allKeys_balanceFix + +/-- +info: @Library.RBTreeMap.allKeys_balance : ∀ {K : Type u_1} {V : Type u_2} (P : K → Prop) (color : ℕ) (k : K) (v : V) + (left right : Library.RBTreeMap.RBTree K V), + Library.RBTreeMap.AllKeys P (Library.RBTreeMap.balance color k v left right) ↔ + P k ∧ Library.RBTreeMap.AllKeys P left ∧ Library.RBTreeMap.AllKeys P right +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.allKeys_balance +/-- info: 'Aiur.Library.RBTreeMap.allKeys_balance' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.allKeys_balance + +/-- +info: @Library.RBTreeMap.allKeys_ins : ∀ {K : Type u_1} {V : Type u_2} {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → + ∀ (P : K → Prop) (k : K) (v : V) (t : Library.RBTreeMap.RBTree K V), + Library.RBTreeMap.AllKeys P (Library.RBTreeMap.ins cmp k v t) ↔ P k ∧ Library.RBTreeMap.AllKeys P t +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.allKeys_ins +/-- info: 'Aiur.Library.RBTreeMap.allKeys_ins' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.allKeys_ins + +/-- +info: @Library.RBTreeMap.rbtree_bst_balance : ∀ {K : Type u_1} {V : Type u_2} {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → + ∀ (color : ℕ) (k : K) (v : V) (left right : Library.RBTreeMap.RBTree K V), + Library.RBTreeMap.AllKeys (fun x => cmp x k = Ordering.lt) left → + Library.RBTreeMap.AllKeys (fun x => cmp k x = Ordering.lt) right → + Library.RBTreeMap.BST cmp left → + Library.RBTreeMap.BST cmp right → Library.RBTreeMap.BST cmp (Library.RBTreeMap.balance color k v left right) +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.rbtree_bst_balance +/-- info: 'Aiur.Library.RBTreeMap.rbtree_bst_balance' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.rbtree_bst_balance + +/-- +info: @Library.RBTreeMap.rbtree_bst_ins : ∀ {K : Type u_1} {V : Type u_2} {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → + ∀ (k : K) (v : V) {t : Library.RBTreeMap.RBTree K V}, + Library.RBTreeMap.BST cmp t → Library.RBTreeMap.BST cmp (Library.RBTreeMap.ins cmp k v t) +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.rbtree_bst_ins +/-- info: 'Aiur.Library.RBTreeMap.rbtree_bst_ins' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.rbtree_bst_ins + +/-- +info: @Library.RBTreeMap.rbtree_bst_insert : ∀ {K : Type u_1} {V : Type u_2} {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → + ∀ (k : K) (v : V) {t : Library.RBTreeMap.RBTree K V}, + Library.RBTreeMap.BST cmp t → Library.RBTreeMap.BST cmp (Library.RBTreeMap.rbtreeInsert cmp k v t) +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.rbtree_bst_insert +/-- info: 'Aiur.Library.RBTreeMap.rbtree_bst_insert' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.rbtree_bst_insert + +/-- +info: @Library.RBTreeMap.balance_lookup_eq : ∀ {K : Type u_1} {V : Type u_2} {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → + ∀ (color : ℕ) (k : K) (v : V) (left right : Library.RBTreeMap.RBTree K V), + Library.RBTreeMap.AllKeys (fun x => cmp x k = Ordering.lt) left → + Library.RBTreeMap.AllKeys (fun x => cmp k x = Ordering.lt) right → + Library.RBTreeMap.BST cmp left → + Library.RBTreeMap.BST cmp right → + ∀ (q : K), + Library.RBTreeMap.rbtreeGet cmp q (Library.RBTreeMap.balance color k v left right) = + Library.RBTreeMap.rbtreeGet cmp q (Library.RBTreeMap.RBTree.node color k v left right) +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.balance_lookup_eq +/-- info: 'Aiur.Library.RBTreeMap.balance_lookup_eq' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.balance_lookup_eq + +/-- +info: @Library.RBTreeMap.ins_lookup_eq : ∀ {K : Type u_1} {V : Type u_2} [inst : DecidableEq K] {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → + ∀ (k : K) (v : V) {t : Library.RBTreeMap.RBTree K V}, + Library.RBTreeMap.BST cmp t → + ∀ (q : K), + Library.RBTreeMap.rbtreeGet cmp q (Library.RBTreeMap.ins cmp k v t) = + if q = k then some v else Library.RBTreeMap.rbtreeGet cmp q t +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.ins_lookup_eq +/-- info: 'Aiur.Library.RBTreeMap.ins_lookup_eq' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.ins_lookup_eq + +/-- +info: @Library.RBTreeMap.rbtree_get_insert : ∀ {K : Type u_1} {V : Type u_2} [inst : DecidableEq K] {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → + ∀ (k : K) (v : V) {t : Library.RBTreeMap.RBTree K V}, + Library.RBTreeMap.BST cmp t → + ∀ (q : K), + Library.RBTreeMap.rbtreeGet cmp q (Library.RBTreeMap.rbtreeInsert cmp k v t) = + if q = k then some v else Library.RBTreeMap.rbtreeGet cmp q t +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.rbtree_get_insert +/-- info: 'Aiur.Library.RBTreeMap.rbtree_get_insert' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.rbtree_get_insert + +/-- +info: @Library.RBTreeMap.rbtree_get_insert_self : ∀ {K : Type u_1} {V : Type u_2} [DecidableEq K] {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → + ∀ (k : K) (v : V) {t : Library.RBTreeMap.RBTree K V}, + Library.RBTreeMap.BST cmp t → + Library.RBTreeMap.rbtreeGet cmp k (Library.RBTreeMap.rbtreeInsert cmp k v t) = some v +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.rbtree_get_insert_self +/-- info: 'Aiur.Library.RBTreeMap.rbtree_get_insert_self' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.rbtree_get_insert_self + +/-- +info: @Library.RBTreeMap.rbtree_get_insert_ne : ∀ {K : Type u_1} {V : Type u_2} [DecidableEq K] {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → + ∀ (k : K) (v : V) {t : Library.RBTreeMap.RBTree K V}, + Library.RBTreeMap.BST cmp t → + ∀ {q : K}, + q ≠ k → + Library.RBTreeMap.rbtreeGet cmp q (Library.RBTreeMap.rbtreeInsert cmp k v t) = + Library.RBTreeMap.rbtreeGet cmp q t +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.rbtree_get_insert_ne +/-- info: 'Aiur.Library.RBTreeMap.rbtree_get_insert_ne' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.rbtree_get_insert_ne + +/-- +info: @Library.RBTreeMap.mem_toList_imp_allKeys : ∀ {K : Type u_1} {V : Type u_2} {P : K → Prop} + {t : Library.RBTreeMap.RBTree K V}, Library.RBTreeMap.AllKeys P t → ∀ {p : K × V}, p ∈ t.toList → P p.1 +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.mem_toList_imp_allKeys +/-- info: 'Aiur.Library.RBTreeMap.mem_toList_imp_allKeys' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.mem_toList_imp_allKeys + +/-- +info: @Library.RBTreeMap.allKeys_iff_forall_mem_toList : ∀ {K : Type u_1} {V : Type u_2} (P : K → Prop) + (t : Library.RBTreeMap.RBTree K V), Library.RBTreeMap.AllKeys P t ↔ ∀ p ∈ t.toList, P p.1 +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.allKeys_iff_forall_mem_toList +/-- info: 'Aiur.Library.RBTreeMap.allKeys_iff_forall_mem_toList' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.allKeys_iff_forall_mem_toList + +/-- +info: @Library.RBTreeMap.rbtreeGet_eq_some_iff_mem_toList : ∀ {K : Type u_1} {V : Type u_2} {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → + ∀ {t : Library.RBTreeMap.RBTree K V}, + Library.RBTreeMap.BST cmp t → ∀ (q : K) (v : V), Library.RBTreeMap.rbtreeGet cmp q t = some v ↔ (q, v) ∈ t.toList +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.rbtreeGet_eq_some_iff_mem_toList +/-- info: 'Aiur.Library.RBTreeMap.rbtreeGet_eq_some_iff_mem_toList' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.rbtreeGet_eq_some_iff_mem_toList + +/-- +info: @Library.RBTreeMap.rbtreeGet_eq_none_iff_forall_ne : ∀ {K : Type u_1} {V : Type u_2} {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → + ∀ {t : Library.RBTreeMap.RBTree K V}, + Library.RBTreeMap.BST cmp t → ∀ (q : K), Library.RBTreeMap.rbtreeGet cmp q t = none ↔ ∀ p ∈ t.toList, p.1 ≠ q +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.rbtreeGet_eq_none_iff_forall_ne +/-- info: 'Aiur.Library.RBTreeMap.rbtreeGet_eq_none_iff_forall_ne' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.rbtreeGet_eq_none_iff_forall_ne + +/-- +info: @Library.RBTreeMap.toList_buildBalancedTree : ∀ {K : Type u_1} {V : Type u_2} (entries : List (K × V)), + (Library.RBTreeMap.buildBalancedTree entries).toList = entries +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.toList_buildBalancedTree +/-- info: 'Aiur.Library.RBTreeMap.toList_buildBalancedTree' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.toList_buildBalancedTree + +/-- +info: @Library.RBTreeMap.bst_buildBalancedTree : ∀ {K : Type u_1} {V : Type u_2} {cmp : K → K → Ordering} + {entries : List (K × V)}, + List.Pairwise (fun a b => cmp a.1 b.1 = Ordering.lt) entries → + Library.RBTreeMap.BST cmp (Library.RBTreeMap.buildBalancedTree entries) +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.bst_buildBalancedTree +/-- info: 'Aiur.Library.RBTreeMap.bst_buildBalancedTree' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.bst_buildBalancedTree + +/-- +info: @Library.RBTreeMap.role_tree_get_eq_some_iff : ∀ {K : Type u_1} {V : Type u_2} {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → + ∀ {entries : List (K × V)}, + List.Pairwise (fun a b => cmp a.1 b.1 = Ordering.lt) entries → + ∀ (q : K) (v : V), + Library.RBTreeMap.rbtreeGet cmp q (Library.RBTreeMap.buildBalancedTree entries) = some v ↔ (q, v) ∈ entries +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.role_tree_get_eq_some_iff +/-- info: 'Aiur.Library.RBTreeMap.role_tree_get_eq_some_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.role_tree_get_eq_some_iff + +/-- +info: @Library.RBTreeMap.role_tree_get_eq_none_iff : ∀ {K : Type u_1} {V : Type u_2} {cmp : K → K → Ordering}, + Library.RBTreeMap.LawfulCmp cmp → + ∀ {entries : List (K × V)}, + List.Pairwise (fun a b => cmp a.1 b.1 = Ordering.lt) entries → + ∀ (q : K), + Library.RBTreeMap.rbtreeGet cmp q (Library.RBTreeMap.buildBalancedTree entries) = none ↔ + ∀ p ∈ entries, p.1 ≠ q +-/ +#guard_msgs in +#check @Aiur.Library.RBTreeMap.role_tree_get_eq_none_iff +/-- info: 'Aiur.Library.RBTreeMap.role_tree_get_eq_none_iff' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.RBTreeMap.role_tree_get_eq_none_iff + +/-! ### 9. `IxVM` Representation Predicates, Monotonicity, Determinism, and Deserialization (`IxVMRep`) -/ + +/-- +info: @Library.IxVMRep.nat_lt_256_inj : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → ∀ {a b : ℕ}, a < 256 → b < 256 → ↑a = ↑b → a = b +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.nat_lt_256_inj +/-- info: 'Aiur.Library.IxVMRep.nat_lt_256_inj' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.nat_lt_256_inj + +/-- +info: @Library.IxVMRep.repU32_det : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {h : Heap F} {w₁ w₂ : UInt32} {v : SourceValue F}, Library.RepU32 h w₁ v → Library.RepU32 h w₂ v → w₁ = w₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.repU32_det +/-- info: 'Aiur.Library.IxVMRep.repU32_det' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.repU32_det + +/-- +info: @Library.IxVMRep.repU64_det : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {h : Heap F} {w₁ w₂ : UInt64} {v : SourceValue F}, Library.RepU64 h w₁ v → Library.RepU64 h w₂ v → w₁ = w₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.repU64_det +/-- info: 'Aiur.Library.IxVMRep.repU64_det' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.repU64_det + +/-- +info: @Library.IxVMRep.repAddress_det : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {h : Heap F} {a₁ a₂ : Library.Bytes.Address} {v : SourceValue F}, + Library.Bytes.RepAddress h a₁ v → Library.Bytes.RepAddress h a₂ v → a₁ = a₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.repAddress_det +/-- info: 'Aiur.Library.IxVMRep.repAddress_det' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.repAddress_det + +/-- +info: @Library.IxVMRep.repAddressRef_det : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {ty : Ty} {h : Heap F} {a₁ a₂ : Library.Bytes.Address} {ptr : SourceValue F}, + Library.Bytes.RepAddressRef ty h a₁ ptr → Library.Bytes.RepAddressRef ty h a₂ ptr → a₁ = a₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.repAddressRef_det +/-- info: 'Aiur.Library.IxVMRep.repAddressRef_det' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.repAddressRef_det + +/-- +info: @Library.IxVMRep.repOption_det : ∀ {F : Type} {α : Type u_1} {enumName : String} {R : Heap F → α → SourceValue F → Prop} + {h : Heap F}, + (∀ {x₁ x₂ : α} {v : SourceValue F}, R h x₁ v → R h x₂ v → x₁ = x₂) → + ∀ {o₁ o₂ : Option α} {v : SourceValue F}, + Library.RepOption enumName R h o₁ v → Library.RepOption enumName R h o₂ v → o₁ = o₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.repOption_det +/-- info: 'Aiur.Library.IxVMRep.repOption_det' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.repOption_det + +/-- +info: @Library.IxVMRep.repLinkedList_det : ∀ {F : Type} {α : Type u_1} {enumName nilCtor consCtor : String}, + nilCtor ≠ consCtor → + ∀ {R : Heap F → α → SourceValue F → Prop} {h : Heap F}, + (∀ {x₁ x₂ : α} {v : SourceValue F}, R h x₁ v → R h x₂ v → x₁ = x₂) → + ∀ {xs₁ xs₂ : List α} {ptr : SourceValue F}, + RepLinkedList enumName nilCtor consCtor R h xs₁ ptr → + RepLinkedList enumName nilCtor consCtor R h xs₂ ptr → xs₁ = xs₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.repLinkedList_det +/-- info: 'Aiur.Library.IxVMRep.repLinkedList_det' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.repLinkedList_det + +/-- +info: @Library.IxVMRep.repList_det : ∀ {F : Type} {α : Type u_1} {enumName : String} {R : Heap F → α → SourceValue F → Prop} + {h : Heap F}, + (∀ {x₁ x₂ : α} {v : SourceValue F}, R h x₁ v → R h x₂ v → x₁ = x₂) → + ∀ {xs₁ xs₂ : List α} {ptr : SourceValue F}, + Library.List.RepList enumName R h xs₁ ptr → Library.List.RepList enumName R h xs₂ ptr → xs₁ = xs₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.repList_det +/-- info: 'Aiur.Library.IxVMRep.repList_det' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.repList_det + +/-- +info: @Library.IxVMRep.repBinaryTree_det : ∀ {F : Type} {α : Type u_1} {enumName leafCtor branchCtor : String}, + leafCtor ≠ branchCtor → + ∀ {R : Heap F → α → SourceValue F → Prop} {h : Heap F}, + (∀ {x₁ x₂ : α} {v : SourceValue F}, R h x₁ v → R h x₂ v → x₁ = x₂) → + ∀ {t₁ t₂ : BinaryTree α} {ptr : SourceValue F}, + RepBinaryTree enumName leafCtor branchCtor R h t₁ ptr → + RepBinaryTree enumName leafCtor branchCtor R h t₂ ptr → t₁ = t₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.repBinaryTree_det +/-- info: 'Aiur.Library.IxVMRep.repBinaryTree_det' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.repBinaryTree_det + +/-- +info: @Library.IxVMRep.repRBTreePtr_det : ∀ {F : Type} {K : Type u_1} {V : Type u_2} {enumName nilCtor nodeCtor : String}, + nilCtor ≠ nodeCtor → + ∀ {RLabel : Heap F → ℕ × K × V → SourceValue F → Prop} {h : Heap F}, + (∀ {x₁ x₂ : ℕ × K × V} {v : SourceValue F}, RLabel h x₁ v → RLabel h x₂ v → x₁ = x₂) → + ∀ {t₁ t₂ : Library.RBTreeMap.RBTree K V} {ptr : SourceValue F}, + Library.RBTreeMap.RepRBTreePtr enumName nilCtor nodeCtor RLabel h t₁ ptr → + Library.RBTreeMap.RepRBTreePtr enumName nilCtor nodeCtor RLabel h t₂ ptr → t₁ = t₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.repRBTreePtr_det +/-- info: 'Aiur.Library.IxVMRep.repRBTreePtr_det' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.repRBTreePtr_det + +/-- +info: @Library.IxVMRep.RepIxVMUniv.mono : ∀ {F : Type} [inst : NatCast F] {h₁ h₂ : Heap F} {u : Library.IxVMRep.IxVMUniv} + {v : SourceValue F}, h₁.Extends h₂ → Library.IxVMRep.RepIxVMUniv h₁ u v → Library.IxVMRep.RepIxVMUniv h₂ u v +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.RepIxVMUniv.mono +/-- info: 'Aiur.Library.IxVMRep.RepIxVMUniv.mono' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.RepIxVMUniv.mono + +/-- +info: @Library.IxVMRep.HeapMono.repIxVMUniv : ∀ {F : Type} [inst : NatCast F] (u : Library.IxVMRep.IxVMUniv), + HeapMono fun h v => Library.IxVMRep.RepIxVMUniv h u v +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.HeapMono.repIxVMUniv +/-- info: 'Aiur.Library.IxVMRep.HeapMono.repIxVMUniv' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.HeapMono.repIxVMUniv + +/-- +info: @Library.IxVMRep.RepIxVMUniv.det : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {h : Heap F} {u₁ u₂ : Library.IxVMRep.IxVMUniv} {v : SourceValue F}, + Library.IxVMRep.RepIxVMUniv h u₁ v → Library.IxVMRep.RepIxVMUniv h u₂ v → u₁ = u₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.RepIxVMUniv.det +/-- info: 'Aiur.Library.IxVMRep.RepIxVMUniv.det' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.RepIxVMUniv.det + +/-- +info: @Library.IxVMRep.RepIxVMIExpr.mono : ∀ {F : Type} [inst : NatCast F] {u64ListEnum : String} {h₁ h₂ : Heap F} + {e : Library.IxVMRep.IxVMIExpr F} {ptr : SourceValue F}, + h₁.Extends h₂ → Library.IxVMRep.RepIxVMIExpr u64ListEnum h₁ e ptr → Library.IxVMRep.RepIxVMIExpr u64ListEnum h₂ e ptr +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.RepIxVMIExpr.mono +/-- info: 'Aiur.Library.IxVMRep.RepIxVMIExpr.mono' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.RepIxVMIExpr.mono + +/-- +info: @Library.IxVMRep.HeapMono.repIxVMIExpr : ∀ {F : Type} [inst : NatCast F] (u64ListEnum : String) + (e : Library.IxVMRep.IxVMIExpr F), HeapMono fun h ptr => Library.IxVMRep.RepIxVMIExpr u64ListEnum h e ptr +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.HeapMono.repIxVMIExpr +/-- info: 'Aiur.Library.IxVMRep.HeapMono.repIxVMIExpr' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.HeapMono.repIxVMIExpr + +/-- +info: @Library.IxVMRep.RepIxVMIExpr.det : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {u64ListEnum : String} {h : Heap F} {e₁ e₂ : Library.IxVMRep.IxVMIExpr F} {ptr : SourceValue F}, + Library.IxVMRep.RepIxVMIExpr u64ListEnum h e₁ ptr → Library.IxVMRep.RepIxVMIExpr u64ListEnum h e₂ ptr → e₁ = e₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.RepIxVMIExpr.det +/-- info: 'Aiur.Library.IxVMRep.RepIxVMIExpr.det' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.RepIxVMIExpr.det + +/-- +info: @Library.IxVMRep.RepIxVMKUniv.mono : ∀ {F : Type} {h₁ h₂ : Heap F} {u : Library.IxVMRep.IxVMKUniv F} + {ptr : SourceValue F}, h₁.Extends h₂ → Library.IxVMRep.RepIxVMKUniv h₁ u ptr → Library.IxVMRep.RepIxVMKUniv h₂ u ptr +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.RepIxVMKUniv.mono +/-- info: 'Aiur.Library.IxVMRep.RepIxVMKUniv.mono' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.RepIxVMKUniv.mono + +/-- info: @Library.IxVMRep.repIxVMKUniv_heapMono₂ : ∀ {F : Type}, HeapMono₂ Library.IxVMRep.RepIxVMKUniv -/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.repIxVMKUniv_heapMono₂ +/-- info: 'Aiur.Library.IxVMRep.repIxVMKUniv_heapMono₂' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.repIxVMKUniv_heapMono₂ + +/-- +info: @Library.IxVMRep.HeapMono.repIxVMKUniv : ∀ {F : Type} (u : Library.IxVMRep.IxVMKUniv F), + HeapMono fun h ptr => Library.IxVMRep.RepIxVMKUniv h u ptr +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.HeapMono.repIxVMKUniv +/-- info: 'Aiur.Library.IxVMRep.HeapMono.repIxVMKUniv' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.HeapMono.repIxVMKUniv + +/-- +info: @Library.IxVMRep.RepIxVMKUniv.det : ∀ {F : Type} {h : Heap F} {u₁ u₂ : Library.IxVMRep.IxVMKUniv F} + {ptr : SourceValue F}, Library.IxVMRep.RepIxVMKUniv h u₁ ptr → Library.IxVMRep.RepIxVMKUniv h u₂ ptr → u₁ = u₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.RepIxVMKUniv.det +/-- info: 'Aiur.Library.IxVMRep.RepIxVMKUniv.det' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.RepIxVMKUniv.det + +/-- +info: @Library.IxVMRep.RepIxVMKExpr.mono : ∀ {F : Type} [inst : NatCast F] {addrTy : Ty} + {lvlListEnum limbListEnum byteListEnum : String} {h₁ h₂ : Heap F} {e : Library.IxVMRep.IxVMKExpr F} + {ptr : SourceValue F}, + h₁.Extends h₂ → + Library.IxVMRep.RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h₁ e ptr → + Library.IxVMRep.RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h₂ e ptr +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.RepIxVMKExpr.mono +/-- info: 'Aiur.Library.IxVMRep.RepIxVMKExpr.mono' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.RepIxVMKExpr.mono + +/-- +info: @Library.IxVMRep.HeapMono.repIxVMKExpr : ∀ {F : Type} [inst : NatCast F] (addrTy : Ty) + (lvlListEnum limbListEnum byteListEnum : String) (e : Library.IxVMRep.IxVMKExpr F), + HeapMono fun h ptr => Library.IxVMRep.RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h e ptr +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.HeapMono.repIxVMKExpr +/-- info: 'Aiur.Library.IxVMRep.HeapMono.repIxVMKExpr' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.HeapMono.repIxVMKExpr + +/-- +info: @Library.IxVMRep.RepIxVMKExpr.det : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {addrTy : Ty} {lvlListEnum limbListEnum byteListEnum : String} {h : Heap F} {e₁ e₂ : Library.IxVMRep.IxVMKExpr F} + {ptr : SourceValue F}, + Library.IxVMRep.RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h e₁ ptr → + Library.IxVMRep.RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h e₂ ptr → e₁ = e₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.RepIxVMKExpr.det +/-- info: 'Aiur.Library.IxVMRep.RepIxVMKExpr.det' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.RepIxVMKExpr.det + +/-- +info: @Library.IxVMRep.RepRoleEvidence.mono : ∀ {F : Type} [inst : NatCast F] {addrTy : Ty} {h₁ h₂ : Heap F} + {ev : Library.IxVMRep.IxVMRoleEvidence} {v : SourceValue F}, + h₁.Extends h₂ → Library.IxVMRep.RepRoleEvidence addrTy h₁ ev v → Library.IxVMRep.RepRoleEvidence addrTy h₂ ev v +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.RepRoleEvidence.mono +/-- info: 'Aiur.Library.IxVMRep.RepRoleEvidence.mono' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.RepRoleEvidence.mono + +/-- +info: @Library.IxVMRep.repRoleEvidence_heapMono₂ : ∀ {F : Type} [inst : NatCast F] (addrTy : Ty), + HeapMono₂ (Library.IxVMRep.RepRoleEvidence addrTy) +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.repRoleEvidence_heapMono₂ +/-- info: 'Aiur.Library.IxVMRep.repRoleEvidence_heapMono₂' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.repRoleEvidence_heapMono₂ + +/-- +info: @Library.IxVMRep.RepRoleEvidence.det : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {addrTy : Ty} {h : Heap F} {ev₁ ev₂ : Library.IxVMRep.IxVMRoleEvidence} {v : SourceValue F}, + Library.IxVMRep.RepRoleEvidence addrTy h ev₁ v → Library.IxVMRep.RepRoleEvidence addrTy h ev₂ v → ev₁ = ev₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.RepRoleEvidence.det +/-- info: 'Aiur.Library.IxVMRep.RepRoleEvidence.det' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.RepRoleEvidence.det + +/-- +info: @Library.IxVMRep.IxVMRoleTable.ext : ∀ {F : Type} {t₁ t₂ : Library.IxVMRep.IxVMRoleTable F}, + t₁.binding = t₂.binding → t₁.byRole = t₂.byRole → t₁.byAddr = t₂.byAddr → t₁ = t₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.IxVMRoleTable.ext +/-- info: 'Aiur.Library.IxVMRep.IxVMRoleTable.ext' does not depend on any axioms -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.IxVMRoleTable.ext + +/-- +info: @Library.IxVMRep.repRoleAddrLabel_heapMono₂ : ∀ {F : Type} [inst : NatCast F] (addrTy : Ty), + HeapMono₂ (Library.IxVMRep.RepRoleAddrLabel addrTy) +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.repRoleAddrLabel_heapMono₂ +/-- info: 'Aiur.Library.IxVMRep.repRoleAddrLabel_heapMono₂' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.repRoleAddrLabel_heapMono₂ + +/-- +info: @Library.IxVMRep.repRoleAddrLabel_det : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {addrTy : Ty} {h : Heap F} {l₁ l₂ : ℕ × F × Library.Bytes.Address} {v : SourceValue F}, + l₁.1 < 256 → + l₂.1 < 256 → + Library.IxVMRep.RepRoleAddrLabel addrTy h l₁ v → Library.IxVMRep.RepRoleAddrLabel addrTy h l₂ v → l₁ = l₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.repRoleAddrLabel_det +/-- info: 'Aiur.Library.IxVMRep.repRoleAddrLabel_det' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.repRoleAddrLabel_det + +/-- +info: @Library.IxVMRep.RepRoleCtx.mono : ∀ {F : Type} [inst : NatCast F] {addrTy : Ty} {byRoleEnum byAddrEnum : String} + {RByRole : Heap F → ℕ × F × Library.Bytes.Address → SourceValue F → Prop} + {RByAddr : Heap F → ℕ × Library.Bytes.Address × F → SourceValue F → Prop}, + HeapMono₂ RByRole → + HeapMono₂ RByAddr → + ∀ {h₁ h₂ : Heap F} {rc : Library.IxVMRep.IxVMRoleCtx F} {ptr : SourceValue F}, + h₁.Extends h₂ → + Library.IxVMRep.RepRoleCtx addrTy byRoleEnum byAddrEnum RByRole RByAddr h₁ rc ptr → + Library.IxVMRep.RepRoleCtx addrTy byRoleEnum byAddrEnum RByRole RByAddr h₂ rc ptr +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.RepRoleCtx.mono +/-- info: 'Aiur.Library.IxVMRep.RepRoleCtx.mono' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.RepRoleCtx.mono + +/-- +info: @Library.IxVMRep.HeapMono.repRoleCtx : ∀ {F : Type} [inst : NatCast F] (addrTy : Ty) (byRoleEnum byAddrEnum : String) + {RByRole : Heap F → ℕ × F × Library.Bytes.Address → SourceValue F → Prop} + {RByAddr : Heap F → ℕ × Library.Bytes.Address × F → SourceValue F → Prop}, + HeapMono₂ RByRole → + HeapMono₂ RByAddr → + ∀ (rc : Library.IxVMRep.IxVMRoleCtx F), + HeapMono fun h ptr => Library.IxVMRep.RepRoleCtx addrTy byRoleEnum byAddrEnum RByRole RByAddr h rc ptr +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.HeapMono.repRoleCtx +/-- info: 'Aiur.Library.IxVMRep.HeapMono.repRoleCtx' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.HeapMono.repRoleCtx + +/-- +info: @Library.IxVMRep.RepRoleCtx.det : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {addrTy : Ty} {byRoleEnum byAddrEnum : String} + {RByRole : Heap F → ℕ × F × Library.Bytes.Address → SourceValue F → Prop} + {RByAddr : Heap F → ℕ × Library.Bytes.Address × F → SourceValue F → Prop} {h : Heap F}, + (∀ {x₁ x₂ : ℕ × F × Library.Bytes.Address} {v : SourceValue F}, RByRole h x₁ v → RByRole h x₂ v → x₁ = x₂) → + (∀ {x₁ x₂ : ℕ × Library.Bytes.Address × F} {v : SourceValue F}, RByAddr h x₁ v → RByAddr h x₂ v → x₁ = x₂) → + ∀ {rc₁ rc₂ : Library.IxVMRep.IxVMRoleCtx F} {ptr : SourceValue F}, + Library.IxVMRep.RepRoleCtx addrTy byRoleEnum byAddrEnum RByRole RByAddr h rc₁ ptr → + Library.IxVMRep.RepRoleCtx addrTy byRoleEnum byAddrEnum RByRole RByAddr h rc₂ ptr → rc₁ = rc₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.RepRoleCtx.det +/-- info: 'Aiur.Library.IxVMRep.RepRoleCtx.det' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.RepRoleCtx.det + +/-- +info: @Library.IxVMRep.ingress_verify_stream_sound : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ (enumName : String) (stream : ℕ → UInt8) (idx len : ℕ) (h : Heap F) (expectedAddr : Library.Bytes.Address), + Library.List.Word.depthChecked (Library.Bytes.readByteStream stream idx len) = some len → + Library.Blake3.addressToFields F (Library.Blake3.digest (Library.Bytes.readByteStream stream idx len)) = + Library.Blake3.addressToFields F expectedAddr → + have bytes := Library.Bytes.readByteStream stream idx len; + have allocated := Library.Bytes.allocByteStream enumName h bytes; + h.Extends allocated.2 ∧ + Library.Bytes.RepByteStream enumName allocated.2 bytes allocated.1 ∧ + bytes.length = len ∧ len < Library.U32.base ∧ Library.Blake3.digest bytes = expectedAddr +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.ingress_verify_stream_sound +/-- info: 'Aiur.Library.IxVMRep.ingress_verify_stream_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.ingress_verify_stream_sound + +/-- info: @Library.IxVMRep.repTag4_heapMono₂ : ∀ {F : Type} [inst : NatCast F], HeapMono₂ Library.IxVMRep.RepTag4 -/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.repTag4_heapMono₂ +/-- info: 'Aiur.Library.IxVMRep.repTag4_heapMono₂' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.repTag4_heapMono₂ + +/-- +info: @Library.IxVMRep.repTag4_inj : ∀ {F : Type} [inst : Field F], + Library.U32.Compatible F → + ∀ {h : Heap F} {t₁ t₂ : UInt8 × UInt64} {v : SourceValue F}, + Library.IxVMRep.RepTag4 h t₁ v → Library.IxVMRep.RepTag4 h t₂ v → t₁ = t₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.repTag4_inj +/-- info: 'Aiur.Library.IxVMRep.repTag4_inj' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.repTag4_inj + +/-- +info: @Library.IxVMRep.tag_header_split_unique : ∀ {f₁ l₁ f₂ l₂ : ℕ}, + l₁ < 32 → l₂ < 32 → f₁ * 32 + l₁ = f₂ * 32 + l₂ → f₁ = f₂ ∧ l₁ = l₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.tag_header_split_unique +/-- info: 'Aiur.Library.IxVMRep.tag_header_split_unique' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.tag_header_split_unique + +/-- +info: @Library.IxVMRep.tagn4_header_split_unique : ∀ {l₁ c₁ f₁ l₂ c₂ f₂ : ℕ}, + l₁ < 8 → c₁ < 2 → l₂ < 8 → c₂ < 2 → l₁ + 8 * c₁ + 16 * f₁ = l₂ + 8 * c₂ + 16 * f₂ → l₁ = l₂ ∧ c₁ = c₂ ∧ f₁ = f₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.tagn4_header_split_unique +/-- info: 'Aiur.Library.IxVMRep.tagn4_header_split_unique' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.tagn4_header_split_unique + +/-- +info: @Library.IxVMRep.tagn2_header_split_unique : ∀ {l₁ c₁ f₁ l₂ c₂ f₂ : ℕ}, + l₁ < 32 → c₁ < 2 → l₂ < 32 → c₂ < 2 → l₁ + 32 * c₁ + 64 * f₁ = l₂ + 32 * c₂ + 64 * f₂ → l₁ = l₂ ∧ c₁ = c₂ ∧ f₁ = f₂ +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.tagn2_header_split_unique +/-- info: 'Aiur.Library.IxVMRep.tagn2_header_split_unique' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.tagn2_header_split_unique + +/-- +info: Library.IxVMRep.u64ValLeBytes_lt : ∀ (bytes : List UInt8), Library.IxVMRep.u64ValLeBytes bytes < 18446744073709551616 +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.u64ValLeBytes_lt +/-- info: 'Aiur.Library.IxVMRep.u64ValLeBytes_lt' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.u64ValLeBytes_lt + +/-- +info: Library.IxVMRep.toNat_u64OfLeBytes : ∀ (bytes : List UInt8), + (Library.IxVMRep.u64OfLeBytes bytes).toNat = Library.IxVMRep.u64ValLeBytes bytes +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.toNat_u64OfLeBytes +/-- info: 'Aiur.Library.IxVMRep.toNat_u64OfLeBytes' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.toNat_u64OfLeBytes + +/-- info: Library.IxVMRep.u64OfLeBytes_nil : (Library.IxVMRep.u64OfLeBytes []).toNat = 0 -/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.u64OfLeBytes_nil +/-- info: 'Aiur.Library.IxVMRep.u64OfLeBytes_nil' depends on axioms: [propext] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.u64OfLeBytes_nil + +/-- info: Library.IxVMRep.u64OfLeBytes_singleton : ∀ (b0 : UInt8), (Library.IxVMRep.u64OfLeBytes [b0]).toNat = b0.toNat -/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.u64OfLeBytes_singleton +/-- info: 'Aiur.Library.IxVMRep.u64OfLeBytes_singleton' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.u64OfLeBytes_singleton + +/-- +info: Library.IxVMRep.u64OfLeBytes_pair : ∀ (b0 b1 : UInt8), + (Library.IxVMRep.u64OfLeBytes [b0, b1]).toNat = b0.toNat + 256 * b1.toNat +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.u64OfLeBytes_pair +/-- info: 'Aiur.Library.IxVMRep.u64OfLeBytes_pair' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.u64OfLeBytes_pair + +/-- +info: Library.IxVMRep.tagn_tail_two_byte_spec : ∀ (lo v0 : UInt8) (q h carry : ℕ), + q < h → + h ≤ 64 → + carry < 2 → + lo.toNat + 2 * h = v0.toNat + 256 * carry → + (Library.IxVMRep.u64OfLeBytes [v0, UInt8.ofNat (q + carry)]).toNat = lo.toNat + 2 * h + 256 * q +-/ +#guard_msgs in +#check @Aiur.Library.IxVMRep.tagn_tail_two_byte_spec +/-- info: 'Aiur.Library.IxVMRep.tagn_tail_two_byte_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Library.IxVMRep.tagn_tail_two_byte_spec + +end Aiur.Audit diff --git a/Aiur/Aiur/CheckerCorrectness.lean b/Aiur/Aiur/CheckerCorrectness.lean new file mode 100644 index 000000000..e3f3edaf8 --- /dev/null +++ b/Aiur/Aiur/CheckerCorrectness.lean @@ -0,0 +1,66 @@ +import Aiur.Circuit.CheckerContext +import Aiur.MemoryCorrectness + +namespace Aiur + +variable {F : Type} [Field F] [DecidableEq F] + +/-- Unit balance feeds the existing compiler soundness proof through a finite tree. -/ +theorem checker_sound {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {rom : WireROM F} {message : Circuit.Message F} {rows : List (Circuit.Row F)} + (checked : system.check rom message rows = .ok ()) : message.Evaluates program rom := by + obtain ⟨tree⟩ := system.check_sound checked + exact derivation_sound compiled tree + +/-- The public checker also supplies ROM validity for the existing heap realization proof. -/ +theorem checker_heap_sound {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {rom : WireROM F} {name : String} {args : List (SourceValue F)} {result : Value F} + {wires : List (WireValue F)} {output : WireValue F} {rows : List (Circuit.Row F)} + (checked : system.check rom ⟨name, wires, output⟩ rows = .ok ()) + (entry : checkEntry program name = .ok ()) + (arguments : DecodesValues program.enums wires (entryValues args)) + (decoded : output.decode program.enums = some result) : + ∃ source heap, EvalFn program name args [] source heap ∧ + Represents (rom.decode program.enums) heap source result := + compiler_heap_sound compiled + (Circuit.System.checkContext_iff.mp (Circuit.System.check_iff.mp checked).1).2.2.1 + entry (system.check_sound checked) arguments decoded + +/-- A successful run has a unit-balanced trace when the system passes its global +namespace/layout checks and its allocations fit the field. -/ +theorem checker_run_complete [Fintype F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) (wellFormed : system.WellFormed) + {name : String} {args : List (SourceValue F)} {fuel : Nat} + {value : SourceValue F} {heap : Heap F} {hints : HintProvider F program.enums} + (executed : run program name args fuel hints = .ok (value, heap)) + (capacity : heap.length ≤ Fintype.card F) : + ∃ (encode : Nat → F), ∃ wires output rom rows, + DecodesValues system.enums wires (entryValues args) ∧ + output.decode system.enums = some (value.mapAddress encode) ∧ + system.check rom ⟨name, wires, output⟩ rows = .ok () := by + obtain ⟨encode, wires, output, arguments, decoded, accepted⟩ := + compiler_run_complete compiled executed capacity + obtain ⟨rom, rows, checked⟩ := (system.check_entry_iff wellFormed).mpr accepted + exact ⟨encode, wires, output, rom, rows, arguments, decoded, checked⟩ + +/-- The memoized version reuses execution completeness and the graph-to-trace bridge. -/ +theorem checkerMemo_run_complete [Fintype F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) (wellFormed : system.WellFormed) + {name : String} {args : List (SourceValue F)} {fuel : Nat} + {value : SourceValue F} {heap : Heap F} {hints : HintProvider F program.enums} + (executed : run program name args fuel hints = .ok (value, heap)) + (capacity : heap.length ≤ Fintype.card F) : + ∃ (encode : Nat → F), ∃ wires output rom rows, + DecodesValues system.enums wires (entryValues args) ∧ + output.decode system.enums = some (value.mapAddress encode) ∧ + system.checkMemo rom ⟨name, wires, output⟩ rows = .ok () := by + obtain ⟨encode, wires, output, arguments, decoded, accepted⟩ := + memo_run_complete compiled executed capacity + obtain ⟨rom, rows, checked⟩ := (system.checkMemo_entry_iff wellFormed).mpr accepted + exact ⟨encode, wires, output, rom, rows, arguments, decoded, checked⟩ + +end Aiur diff --git a/Aiur/Aiur/Circuit.lean b/Aiur/Aiur/Circuit.lean new file mode 100644 index 000000000..2534b727b --- /dev/null +++ b/Aiur/Aiur/Circuit.lean @@ -0,0 +1,9 @@ +import Aiur.Circuit.Basic +import Aiur.Circuit.Stats +import Aiur.Circuit.Compile +import Aiur.Circuit.PatternFacts +import Aiur.Circuit.Derivation +import Aiur.Circuit.MemoDerivation +import Aiur.Circuit.MemoAcyclic +import Aiur.Circuit.Entry +import Aiur.Circuit.CheckerContext diff --git a/Aiur/Aiur/Circuit/Accumulator.lean b/Aiur/Aiur/Circuit/Accumulator.lean new file mode 100644 index 000000000..9577d97b4 --- /dev/null +++ b/Aiur/Aiur/Circuit/Accumulator.lean @@ -0,0 +1,83 @@ +import Mathlib.Algebra.BigOperators.Group.List.Basic +import Mathlib.Data.List.Perm.Basic + +namespace Aiur.Circuit + +/-- A finite ledger of signed changes. Its value is the sum at each claim, +not the length of the ledger. Negative intermediate balances are permitted. -/ +abbrev Accumulator (α : Type) := List (α × Int) + +namespace Accumulator + +def value [DecidableEq α] (entries : Accumulator α) (claim : α) : Int := + (entries.map fun entry => if entry.1 = claim then entry.2 else 0).sum + +def isZero [DecidableEq α] (entries : Accumulator α) : Bool := + entries.all fun entry => decide (value entries entry.1 = 0) + +@[simp] theorem value_nil [DecidableEq α] (claim : α) : value [] claim = 0 := rfl + +@[simp] theorem value_cons [DecidableEq α] (entry : α × Int) (entries : Accumulator α) (claim : α) : + value (entry :: entries) claim = (if entry.1 = claim then entry.2 else 0) + value entries claim := by + simp [value] + +@[simp] theorem value_append [DecidableEq α] (xs ys : Accumulator α) (claim : α) : + value (xs ++ ys) claim = value xs claim + value ys claim := by simp [value] + +theorem value_of_absent [DecidableEq α] {entries : Accumulator α} {claim : α} + (absent : ∀ entry ∈ entries, entry.1 ≠ claim) : value entries claim = 0 := by + induction entries with + | nil => rfl + | cons entry entries ih => + simp [absent entry (by simp), ih (fun next h => absent next (by simp [h]))] + +theorem isZero_iff [DecidableEq α] (entries : Accumulator α) : + entries.isZero = true ↔ ∀ claim, entries.value claim = 0 := by + simp only [isZero, List.all_eq_true, decide_eq_true_eq] + constructor + · intro zero claim + by_cases present : ∃ entry ∈ entries, entry.1 = claim + · obtain ⟨entry, member, rfl⟩ := present + exact zero entry member + · exact value_of_absent (fun entry member same => present ⟨entry, member, same⟩) + · intro zero entry _; exact zero entry.1 + +/-- Add one occurrence of each requirement. -/ +def requires (claims : List α) : Accumulator α := claims.map (fun claim => (claim, 1)) + +/-- A provide subtracts its integer weight; requirements are never scaled. -/ +def provides (claims : List (α × Int)) : Accumulator α := claims.map (fun entry => (entry.1, -entry.2)) + +@[simp] theorem value_requires [DecidableEq α] (claims : List α) (claim : α) : + value (requires claims) claim = (claims.count claim : Int) := by + induction claims with + | nil => rfl + | cons head tail ih => + change value ((head, 1) :: requires tail) claim = _ + rw [value_cons, ih] + by_cases same : head = claim <;> simp [same, eq_comm, Int.add_comm] + +@[simp] theorem value_provides [DecidableEq α] (claims : List (α × Int)) (claim : α) : + value (provides claims) claim = -value claims claim := by + induction claims with + | nil => simp [provides] + | cons head tail ih => + change value ((head.1, -head.2) :: provides tail) claim = _ + rw [value_cons, value_cons, ih] + by_cases same : head.1 = claim <;> simp [same, neg_add_rev, Int.add_comm] + +/-- Exact integer balance with unit provides is exactly multiset equality. -/ +theorem unit_balance_iff [DecidableEq α] (required provided : List α) : + (requires required ++ provides (requires provided)).isZero = true ↔ required.Perm provided := by + rw [isZero_iff, List.perm_iff_count] + simp only [value_append, value_requires, value_provides] + constructor + · intro balanced claim + have := balanced claim + omega + · intro balanced claim + rw [balanced claim] + omega + +end Accumulator +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/Balance.lean b/Aiur/Aiur/Circuit/Balance.lean new file mode 100644 index 000000000..bb106f832 --- /dev/null +++ b/Aiur/Aiur/Circuit/Balance.lean @@ -0,0 +1,140 @@ +import Aiur.Circuit.Accumulator + +namespace Aiur.Circuit + +/-- A rule's conclusion and its active premise occurrences. -/ +abbrev RuleClaims (α : Type) := α × List α + +namespace Balance + +def required (static : α → Bool) (root : α) (rules : List (RuleClaims α)) : List α := + (root :: rules.flatMap Prod.snd).filter (fun claim => !static claim) + +def accumulator (static : α → Bool) (root : α) (rules : List (RuleClaims α × Int)) : Accumulator α := + Accumulator.requires (required static root (rules.map Prod.fst)) ++ + Accumulator.provides (rules.map fun rule => (rule.1.1, rule.2)) + +/-- A balanced integer ledger must provide every dynamically required claim, +even when provide weights are zero or negative. -/ +theorem provider_of_zero [DecidableEq α] {static : α → Bool} {root claim : α} + {rules : List (RuleClaims α × Int)} + (zero : (accumulator static root rules).isZero = true) + (needed : claim ∈ required static root (rules.map Prod.fst)) : + ∃ rule ∈ rules, rule.1.1 = claim := by + have balance := (Accumulator.isZero_iff _).mp zero claim + simp only [accumulator, Accumulator.value_append, Accumulator.value_requires, + Accumulator.value_provides] at balance + by_contra absent + have empty : Accumulator.value (rules.map fun rule => (rule.1.1, rule.2)) claim = 0 := by + apply Accumulator.value_of_absent + intro entry member same + obtain ⟨rule, belongs, rfl⟩ := List.mem_map.mp member + exact absent ⟨rule, belongs, same⟩ + have positive := List.count_pos_iff.mpr needed + rw [empty] at balance + omega + +/-- Exact unit balance establishes every property closed under the supplied rules +and the static leaves. In particular, take the property to be finite derivability. -/ +theorem property_of_unit_balance {static : α → Bool} {root : α} {rules : List (RuleClaims α)} + {property : α → Prop} + (leaves : ∀ claim, static claim = true → property claim) + (closed : ∀ rule ∈ rules, (∀ premise ∈ rule.2, property premise) → property rule.1) + (balanced : (required static root rules).Perm (rules.map Prod.fst)) : property root := by + classical + let bad : α → Bool := fun claim => decide (¬property claim) + have step (rule : RuleClaims α) (member : rule ∈ rules) : + (if bad rule.1 then 1 else 0) ≤ rule.2.countP bad := by + by_cases good : property rule.1 + · simp [bad, good] + · have existsBad : ∃ premise ∈ rule.2, bad premise = true := by + by_contra noBad + apply good + apply closed rule member + intro premise present + by_contra notGood + exact noBad ⟨premise, present, by simp [bad, notGood]⟩ + have positive := List.countP_pos_iff.mpr existsBad + simpa [bad, good] using positive + have total : (rules.map Prod.fst).countP bad ≤ (rules.flatMap Prod.snd).countP bad := by + clear closed balanced + induction rules with + | nil => simp + | cons rule rules ih => + have one := step rule (by simp) + have tail := ih (fun r h => step r (by simp [h])) + simp only [List.map_cons, List.countP_cons, List.flatMap_cons, List.countP_append] + omega + have filtered (claims : List α) : + (claims.filter (fun claim => !static claim)).countP bad = claims.countP bad := by + rw [List.countP_filter] + congr 1 + funext claim + by_cases s : static claim = true + · simp [s, bad, leaves claim s] + · simp [Bool.eq_false_iff.mpr s] + have counts := balanced.countP_eq bad + rw [required, filtered, List.countP_cons] at counts + by_contra notRoot + have badRoot : bad root = true := by simp [bad, notRoot] + rw [badRoot] at counts + simp only [Bool.true_eq, ite_true] at counts + omega + +/-- Allocate all demand for a conclusion to its first providing row. Repeated +providers get weight zero, while their premises remain ordinary requirements. -/ +def weigh [DecidableEq α] (demands : List α) : List (RuleClaims α) → List (RuleClaims α × Int) + | [] => [] + | rule :: rules => (rule, (demands.count rule.1 : Int)) :: + weigh (demands.filter (fun claim => decide (claim ≠ rule.1))) rules + +@[simp] theorem weigh_rules [DecidableEq α] (demands : List α) (rules : List (RuleClaims α)) : + (weigh demands rules).map Prod.fst = rules := by + induction rules generalizing demands with + | nil => rfl + | cons rule rules ih => simp [weigh, ih] + +private theorem count_filter_ne [DecidableEq α] (claims : List α) (removed claim : α) : + (claims.filter (fun x => decide (x ≠ removed))).count claim = + if claim = removed then 0 else claims.count claim := by + induction claims with + | nil => simp + | cons head tail ih => + by_cases a : head = removed <;> by_cases b : head = claim <;> + by_cases c : claim = removed <;> simp_all + +theorem weigh_value [DecidableEq α] {demands : List α} {rules : List (RuleClaims α)} + (covered : ∀ claim ∈ demands, ∃ rule ∈ rules, rule.1 = claim) (claim : α) : + Accumulator.value ((weigh demands rules).map fun rule => (rule.1.1, rule.2)) claim = + (demands.count claim : Int) := by + induction rules generalizing demands with + | nil => + have absent : claim ∉ demands := by intro h; simpa using covered claim h + simp [weigh, List.count_eq_zero.mpr absent] + | cons rule rules ih => + have rest : ∀ next ∈ demands.filter (fun x => decide (x ≠ rule.1)), + ∃ provider ∈ rules, provider.1 = next := by + intro next member + obtain ⟨present, different⟩ := List.mem_filter.mp member + obtain ⟨provider, member, same⟩ := covered next present + rcases List.mem_cons.mp member with rfl | member + · simp [same] at different + · exact ⟨provider, member, same⟩ + simp only [weigh, List.map_cons, Accumulator.value_cons] + rw [ih rest, count_filter_ne] + by_cases same : rule.1 = claim + · simp [same] + · simp [same, Ne.symm same] + +theorem weigh_balanced [DecidableEq α] {static : α → Bool} {root : α} + {rules : List (RuleClaims α)} + (covered : ∀ claim ∈ required static root rules, ∃ rule ∈ rules, rule.1 = claim) : + (accumulator static root (weigh (required static root rules) rules)).isZero = true := by + apply (Accumulator.isZero_iff _).mpr + intro claim + simp only [accumulator, weigh_rules, Accumulator.value_append, Accumulator.value_requires, + Accumulator.value_provides, weigh_value covered] + omega + +end Balance +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/Basic.lean b/Aiur/Aiur/Circuit/Basic.lean new file mode 100644 index 000000000..897ec0baf --- /dev/null +++ b/Aiur/Aiur/Circuit/Basic.lean @@ -0,0 +1,240 @@ +import Aiur.AST +import Aiur.Memory +import Aiur.Wire +import Aiur.Scalar.Circuit.Basic +import Aiur.Circuit.Balance + +namespace Aiur.Circuit + +abbrev Var := Scalar.Circuit.Var +abbrev ArithExpr := Scalar.Circuit.ArithExpr +abbrev Constraint := Scalar.Circuit.Constraint +abbrev Satisfies [Field F] (constraints : List (Constraint F)) (assignment : Var → F) := + Scalar.Circuit.Satisfies constraints assignment +abbrev Row := Scalar.Circuit.Row + +namespace ArithExpr +export Aiur.Scalar.Circuit.ArithExpr (const var add sub mul) +abbrev denote [Field F] (assignment : Var → F) (expr : ArithExpr F) : F := + Scalar.Circuit.ArithExpr.denote assignment expr +abbrev inBounds (numVars : Nat) (expr : ArithExpr F) : Bool := + Scalar.Circuit.ArithExpr.inBounds numVars expr +end ArithExpr + +namespace Row +abbrev assignment [Zero F] (row : Row F) (id : Var) : F := + Scalar.Circuit.Row.assignment row id +end Row + +/-- Tuple shape and every leaf are part of a call's claim. -/ +structure Message (F : Type) where + channel : String + args : List (WireValue F) + result : WireValue F + deriving Repr, BEq, DecidableEq + +abbrev CallRelation (F : Type) := String → List (WireValue F) → WireValue F → Prop +abbrev WireEnvironment (F : Type) := List (String × WireValue F) + +structure Send (F : Type) where + channel : String + args : List (WireValue (ArithExpr F)) + result : WireValue Var + enable : ArithExpr F + deriving Repr, BEq + +def Send.message [Field F] (send : Send F) (assignment : Var → F) : Message F := + ⟨send.channel, send.args.map (WireValue.map (ArithExpr.denote assignment)), send.result.map assignment⟩ + +def Send.inBounds (numVars : Nat) (send : Send F) : Bool := + send.result.words.all (· < numVars) && send.enable.inBounds numVars && + (send.args.flatMap WireValue.words).all (ArithExpr.inBounds numVars) + +/-- Both store and load require this same cell in the shared ROM. -/ +structure MemoryLookup (F : Type) where + address : ArithExpr F + value : WireValue (ArithExpr F) + enable : ArithExpr F + deriving Repr, BEq + +def MemoryLookup.inBounds (numVars : Nat) (lookup : MemoryLookup F) : Bool := + lookup.address.inBounds numVars && lookup.enable.inBounds numVars && + lookup.value.words.all (ArithExpr.inBounds numVars) + +def MemoryLookup.Valid [Field F] (rom : WireROM F) (assignment : Var → F) + (lookup : MemoryLookup F) : Prop := + lookup.enable.denote assignment = 1 → + (lookup.address.denote assignment, lookup.value.map (ArithExpr.denote assignment)) ∈ rom.entries + +/-- Structure lives in the interface; rows and equations contain only field elements. -/ +structure Chip (F : Type) where + name : String + inputs : List (WireValue Var) + /-- The provided result can reuse columns or contain expressions and constants. -/ + output : WireValue (ArithExpr F) + numVars : Nat + constraints : List (Constraint F) + sends : List (Send F) + memory : List (MemoryLookup F) + deriving Repr, BEq + +def Chip.wellFormed (chip : Chip F) : Bool := + (chip.inputs.flatMap WireValue.words).all (· < chip.numVars) && + chip.output.words.all (ArithExpr.inBounds chip.numVars) && + chip.constraints.all (ArithExpr.inBounds chip.numVars) && + chip.sends.all (Send.inBounds chip.numVars) && + chip.memory.all (MemoryLookup.inBounds chip.numVars) + +def Chip.ValidRow [Field F] (chip : Chip F) (rom : WireROM F) (row : Row F) : Prop := + chip.wellFormed = true ∧ row.values.length = chip.numVars ∧ + Satisfies chip.constraints row.assignment ∧ + ∀ lookup ∈ chip.memory, lookup.Valid rom row.assignment + +def Chip.receive [Field F] (chip : Chip F) (row : Row F) : Message F := + ⟨chip.name, chip.inputs.map (WireValue.map row.assignment), + chip.output.map (ArithExpr.denote row.assignment)⟩ + +def Chip.premises [Field F] [DecidableEq F] (chip : Chip F) (row : Row F) : List (Message F) := + chip.sends.filterMap fun send => + if send.enable.denote row.assignment = 1 then some (send.message row.assignment) else none + +structure System (F : Type) where + chips : List (Chip F) + enums : Declarations := [] + tables : List (Table F) := [] + maps : List MapDecl := [] + deriving Repr, BEq + +def System.findChip? (system : System F) (name : String) : Option (Chip F) := + system.chips.find? (·.name == name) + +def encodeMapEntry [NatCast F] [Zero F] (decls : Declarations) (name : String) + (entry : MapEntry F) : Option (Message F) := do + let args ← entry.args.mapM (fun value => value.toValue.encode decls) + let result ← entry.result.toValue.encode decls + return ⟨name, args, result⟩ + +/-- The finite membership relation supplied by the shared precommitted traces. -/ +def System.mapClaims [NatCast F] [Zero F] (system : System F) : List (Message F) := + let data : Program F := { + functions := [] + enums := system.enums + tables := system.tables + maps := system.maps + } + system.maps.flatMap fun map => + (data.mapEntries map).filterMap (encodeMapEntry system.enums map.name) + +def System.MapClaim [NatCast F] [Zero F] (system : System F) (message : Message F) : Prop := + message ∈ system.mapClaims + +instance [NatCast F] [Zero F] [DecidableEq F] (system : System F) (message : Message F) : + Decidable (system.MapClaim message) := by + unfold System.MapClaim + apply decidable_of_iff (system.mapClaims.any (fun claim => decide (claim = message)) = true) + constructor + · intro found + obtain ⟨claim, member, same⟩ := List.any_eq_true.mp found + have same : claim = message := of_decide_eq_true same + simpa only [same] using member + · intro member + exact List.any_eq_true.mpr ⟨message, member, by simp⟩ + +inductive WitnessError where + | duplicateChip (chip : String) + | invalidLayout (chip : String) + | wrongRowSize (chip : String) (expected actual : Nat) + | constraintNotZero (chip : String) (index : Nat) + | unknownChip (chip : String) + | unbalancedMessages + | pointerEntryArgument + | malformedEntry + | invalidROM + | missingCell (chip : String) (index : Nat) + deriving Repr, BEq, DecidableEq + +def Chip.checkRow [Field F] [DecidableEq F] (chip : Chip F) (rom : WireROM F) (row : Row F) : + Except WitnessError (Message F × List (Message F)) := do + if !chip.wellFormed then throw (.invalidLayout chip.name) + if row.values.length != chip.numVars then + throw (.wrongRowSize chip.name chip.numVars row.values.length) + let _ ← chip.constraints.zipIdx.mapM fun (polynomial, index) => + if polynomial.denote row.assignment ≠ 0 then + throw (.constraintNotZero chip.name index) else pure (() : Unit) + let _ ← chip.memory.zipIdx.mapM fun (lookup, index) => do + if lookup.enable.denote row.assignment = 1 then + if !rom.entries.any (fun entry => decide (entry = + (lookup.address.denote row.assignment, + lookup.value.map (ArithExpr.denote row.assignment)))) then + throw (.missingCell chip.name index) + pure (() : Unit) + return (chip.receive row, chip.premises row) + +/-- Check the whole chip namespace, including chips unused by a trace. -/ +def checkChips (seen : List String) : List (Chip F) → Except WitnessError Unit + | [] => .ok () + | chip :: chips => do + if chip.name ∈ seen then throw (.duplicateChip chip.name) + if !chip.wellFormed then throw (.invalidLayout chip.name) + checkChips (chip.name :: seen) chips + +/-- Checks shared by the unit and memoized trace checkers. -/ +def System.checkContext [Field F] [DecidableEq F] (system : System F) + (rom : WireROM F) (entry : Message F) : Except WitnessError Unit := do + let _ ← entry.args.mapM fun argument => do + if (argument.decode system.enums).isNone then throw .malformedEntry + if !argument.type.pointerFree system.enums then throw .pointerEntryArgument + pure (() : Unit) + if (entry.result.decode system.enums).isNone then throw .malformedEntry + if ¬rom.Valid then throw .invalidROM + checkChips [] system.chips + +/-- A row provides its conclusion with an exact integer weight. Its active +premises always have weight one, including when the provide weight is zero. -/ +structure WeightedRow (F : Type) where + row : Row F + multiplicity : Int + deriving Repr, BEq + +def System.inspectRow [Field F] [DecidableEq F] (system : System F) + (rom : WireROM F) (row : Row F) : Except WitnessError (RuleClaims (Message F)) := do + let some chip := system.findChip? row.chip | throw (.unknownChip row.chip) + chip.checkRow rom row + +def System.inspectRows [Field F] [DecidableEq F] (system : System F) + (rom : WireROM F) (rows : List (Row F)) : Except WitnessError (List (RuleClaims (Message F))) := + rows.mapM (system.inspectRow rom) + +def System.inspectWeightedRows [Field F] [DecidableEq F] (system : System F) + (rom : WireROM F) (rows : List (WeightedRow F)) : + Except WitnessError (List (RuleClaims (Message F) × Int)) := + rows.mapM fun weighted => do + let claims ← system.inspectRow rom weighted.row + return (claims, weighted.multiplicity) + +/-- Unordered, exact integer balance; every provided and required occurrence has weight one. -/ +def System.check [Field F] [DecidableEq F] (system : System F) + (rom : WireROM F) (entry : Message F) (rows : List (Row F)) : Except WitnessError Unit := do + system.checkContext rom entry + let rules ← system.inspectRows rom rows + let ledger := Balance.accumulator (fun claim => decide (system.MapClaim claim)) entry + (rules.map fun rule => (rule, 1)) + if ledger.isZero then pure () else throw .unbalancedMessages + +/-- The LogUp-style abstraction: arbitrary integer provide weights, unit requires. +This checks exact claims and integers, without a cryptographic accumulator or a field cast. -/ +def System.checkMemo [Field F] [DecidableEq F] (system : System F) + (rom : WireROM F) (entry : Message F) (rows : List (WeightedRow F)) : Except WitnessError Unit := do + system.checkContext rom entry + let rules ← system.inspectWeightedRows rom rows + let ledger := Balance.accumulator (fun claim => decide (system.MapClaim claim)) entry rules + if ledger.isZero then pure () else throw .unbalancedMessages + +def System.Accepts [Field F] [DecidableEq F] (system : System F) + (rom : WireROM F) (entry : Message F) (rows : List (Row F)) : Prop := system.check rom entry rows = .ok () + +def System.AcceptsMemo [Field F] [DecidableEq F] (system : System F) + (rom : WireROM F) (entry : Message F) (rows : List (WeightedRow F)) : Prop := + system.checkMemo rom entry rows = .ok () + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/BuildFacts.lean b/Aiur/Aiur/Circuit/BuildFacts.lean new file mode 100644 index 000000000..1f4675131 --- /dev/null +++ b/Aiur/Aiur/Circuit/BuildFacts.lean @@ -0,0 +1,204 @@ +import Aiur.Circuit.Compile +import Aiur.WireFacts +import Aiur.Scalar.Circuit.CompileFacts + +namespace Aiur.Circuit.Compiler + +variable {F : Type} {rom : WireROM F} + +def localsEnvironment [Field F] (locals : Locals F) (assignment : Var → F) : WireEnvironment F := + locals.map fun binding => (binding.1, binding.2.map (ArithExpr.denote assignment)) + +@[simp] theorem localsEnvironment_append [Field F] (left right : Locals F) (assignment : Var → F) : + localsEnvironment (left ++ right) assignment = + localsEnvironment left assignment ++ localsEnvironment right assignment := List.map_append + +/-- Validity of all equations and enabled calls in a simultaneous assignment. -/ +structure BuildState.Valid [Field F] (state : BuildState F) (rom : WireROM F) (calls : CallRelation F) + (assignment : Var → F) : Prop where + constraints : Satisfies state.constraints.toList assignment + calls : ∀ send ∈ state.sends.toList, send.enable.denote assignment = 1 → + calls send.channel (send.args.map (WireValue.map (ArithExpr.denote assignment))) + (send.result.map assignment) + memory : ∀ lookup ∈ state.memory.toList, lookup.Valid rom assignment + +theorem BuildState.Valid.of_subset [Field F] {before after : BuildState F} + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid rom calls assignment) + (constraints : ∀ polynomial ∈ before.constraints.toList, polynomial ∈ after.constraints.toList) + (sends : ∀ send ∈ before.sends.toList, send ∈ after.sends.toList) + (memory : ∀ lookup ∈ before.memory.toList, lookup ∈ after.memory.toList) : + before.Valid rom calls assignment := + ⟨fun polynomial member => valid.constraints polynomial (constraints polynomial member), + fun send member => valid.calls send (sends send member), + fun lookup member => valid.memory lookup (memory lookup member)⟩ + +theorem bind_ok {first : Build F α} {next : α → Build F β} + {before after : BuildState F} {result : β} : + (first >>= next) before = .ok (result, after) ↔ + ∃ value middle, first before = .ok (value, middle) ∧ next value middle = .ok (result, after) := by + cases run : first before with + | error error => simp [StateT.bind, bind, Except.bind, run] + | ok output => + rcases output with ⟨value, middle⟩ + simp [StateT.bind, bind, Except.bind, run] + +@[simp] theorem pure_ok {value result : α} {before after : BuildState F} : + (pure value : Build F α) before = .ok (result, after) ↔ value = result ∧ before = after := by + simp [pure, StateT.pure, Except.pure] + +@[simp] theorem lift_ok (value : α) (state : BuildState F) : + (liftM (.ok value : Except CompileError α) : Build F α) state = .ok (value, state) := rfl + +@[simp] theorem lift_error (error : CompileError) (state : BuildState F) : + (liftM (.error error : Except CompileError α) : Build F α) state = .error error := rfl + +@[simp] theorem throw_apply (error : CompileError) (state : BuildState F) : + (throw error : Build F α) state = .error error := rfl + +theorem lift_eq_ok {computation : Except CompileError α} {value : α} + {before after : BuildState F} + (compiled : (liftM computation : Build F α) before = .ok (value, after)) : + computation = .ok value ∧ before = after := by + cases computation with + | error error => simp [lift_error] at compiled + | ok result => + simp only [lift_ok, Except.ok.injEq, Prod.mk.injEq] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨rfl, rfl⟩ + +@[simp] theorem fresh_apply (state : BuildState F) : + fresh state = .ok (state.nextVar, { state with nextVar := state.nextVar + 1 }) := rfl + +@[simp] theorem constrain_apply (polynomial : ArithExpr F) (state : BuildState F) : + constrain polynomial state = + .ok ((), { state with constraints := state.constraints.push polynomial }) := rfl + +@[simp] theorem guarded_apply (enable polynomial : ArithExpr F) (state : BuildState F) : + guarded enable polynomial state = + .ok ((), { state with constraints := state.constraints.push (.mul enable polynomial) }) := rfl + +@[simp] theorem boolean_apply [Field F] (selector : ArithExpr F) (state : BuildState F) : + boolean selector state = .ok ((), { state with + constraints := state.constraints.push (.mul selector (.sub selector (.const 1))) }) := rfl + +theorem constrain_valid [Field F] {before after : BuildState F} {polynomial : ArithExpr F} + (compiled : constrain polynomial before = .ok ((), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid rom calls assignment) : + before.Valid rom calls assignment ∧ polynomial.denote assignment = 0 := by + simp only [constrain_apply, Except.ok.injEq, Prod.mk.injEq, true_and] at compiled + subst after + exact ⟨valid.of_subset (fun _ member => by simp [member]) (fun _ member => member) (fun _ member => member), + valid.constraints polynomial (by simp)⟩ + +theorem fresh_valid [Field F] {before after : BuildState F} {id : Var} + (compiled : fresh before = .ok (id, after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid rom calls assignment) : + before.Valid rom calls assignment := by + simp only [fresh_apply, Except.ok.injEq, Prod.mk.injEq] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨valid.constraints, valid.calls, valid.memory⟩ + +theorem boolean_valid [Field F] {before after : BuildState F} {selector : ArithExpr F} + (compiled : boolean selector before = .ok ((), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid rom calls assignment) : + before.Valid rom calls assignment ∧ + (selector.denote assignment = 0 ∨ selector.denote assignment = 1) := by + obtain ⟨beforeValid, equation⟩ := constrain_valid compiled valid + exact ⟨beforeValid, Scalar.Circuit.selector_boolean equation⟩ + +theorem asField_ok {value : Symbolic F} {polynomial : ArithExpr F} + {before after : BuildState F} (compiled : asField value before = .ok (polynomial, after)) : + value = .field polynomial ∧ before = after := by + rcases value with ⟨type, words⟩ + cases type with + | tuple | ptr | enum => simp [asField] at compiled + | field => + cases words with + | nil => simp [asField] at compiled + | cons word rest => + cases rest with + | cons => simp [asField] at compiled + | nil => + simpa [asField, WireValue.field, pure_ok] using compiled + +@[simp] theorem freshWords_apply (count : Nat) (state : BuildState F) : + freshWords count state = .ok (List.range' state.nextVar count, + { state with nextVar := state.nextVar + count }) := rfl + +theorem getLayout_eq {decls : Declarations} {type : Ty} {layout : Layout} + {before after : BuildState F} + (compiled : getLayout decls type before = .ok (layout, after)) : + decls.layout type = .ok layout ∧ before = after := by + cases expanded : decls.layout type with + | error error => simp [getLayout, expanded, Except.mapError] at compiled + | ok result => + simp only [getLayout, expanded, Except.mapError, lift_ok, Except.ok.injEq, Prod.mk.injEq] at compiled + rcases compiled with ⟨rfl, rfl⟩ + exact ⟨rfl, rfl⟩ + +theorem freshValue_eq {decls : Declarations} {type : Ty} {value : WireValue Var} + {before after : BuildState F} + (compiled : freshValue decls type before = .ok (value, after)) : + ∃ layout, decls.layout type = .ok layout ∧ + value = ⟨type, List.range' before.nextVar layout.width⟩ ∧ + after = { before with nextVar := before.nextVar + layout.width } := by + simp only [freshValue] at compiled + obtain ⟨layout, middle, expanded, rest⟩ := bind_ok.mp compiled + obtain ⟨layoutEq, rfl⟩ := getLayout_eq expanded + obtain ⟨words, last, allocated, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + simp only [freshWords_apply, Except.ok.injEq, Prod.mk.injEq] at allocated + rcases allocated with ⟨rfl, rfl⟩ + exact ⟨layout, layoutEq, rfl, rfl⟩ + +theorem freshValue_spec {decls : Declarations} {type : Ty} {value : WireValue Var} + {before after : BuildState F} + (compiled : freshValue decls type before = .ok (value, after)) : + after.constraints = before.constraints ∧ after.sends = before.sends ∧ + value.type = type ∧ after.memory = before.memory := by + obtain ⟨_, _, rfl, rfl⟩ := freshValue_eq compiled + exact ⟨rfl, rfl, rfl, rfl⟩ + +theorem freshValues_spec {decls : Declarations} {types : List Ty} {values : List (WireValue Var)} + {before after : BuildState F} + (compiled : freshValues decls types before = .ok (values, after)) : + after.constraints = before.constraints ∧ after.sends = before.sends ∧ + values.map WireValue.type = types ∧ after.memory = before.memory := by + induction types generalizing before values with + | nil => + simp only [freshValues, List.mapM_nil, pure_ok] at compiled + rcases compiled with ⟨rfl, rfl⟩ + exact ⟨rfl, rfl, rfl, rfl⟩ + | cons type types ih => + simp only [freshValues, List.mapM_cons] at compiled + obtain ⟨value, middle, head, rest⟩ := bind_ok.mp compiled + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨hc, hs, ht, hm⟩ := freshValue_spec head + obtain ⟨tc, ts, tt, tm⟩ := ih tailRun + exact ⟨tc.trans hc, ts.trans hs, by simp [ht, tt], tm.trans hm⟩ + +theorem freshValue_valid [Field F] {decls : Declarations} {type : Ty} {value : WireValue Var} + {before after : BuildState F} (compiled : freshValue decls type before = .ok (value, after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid rom calls assignment) : + before.Valid rom calls assignment := by + obtain ⟨constraints, sends, _, memory⟩ := freshValue_spec compiled + exact valid.of_subset (fun _ member => by rwa [constraints]) + (fun _ member => by rwa [sends]) (fun _ member => by rwa [memory]) + +@[simp] theorem requireCell_apply (enable address : ArithExpr F) (value : Symbolic F) + (state : BuildState F) : + requireCell enable address value state = .ok ((), + { state with memory := state.memory.push ⟨address, value, enable⟩ }) := rfl + +theorem requireCell_valid [Field F] {before after : BuildState F} + {enable address : ArithExpr F} {value : Symbolic F} + (compiled : requireCell enable address value before = .ok ((), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid rom calls assignment) : + before.Valid rom calls assignment ∧ (⟨address, value, enable⟩ : MemoryLookup F).Valid rom assignment := by + simp only [requireCell_apply, Except.ok.injEq, Prod.mk.injEq, true_and] at compiled + subst after + exact ⟨valid.of_subset (fun _ h => h) (fun _ h => h) (fun _ h => by simp [h]), + valid.memory _ (by simp)⟩ + +end Aiur.Circuit.Compiler diff --git a/Aiur/Aiur/Circuit/CheckerCompleteness.lean b/Aiur/Aiur/Circuit/CheckerCompleteness.lean new file mode 100644 index 000000000..df5387c03 --- /dev/null +++ b/Aiur/Aiur/Circuit/CheckerCompleteness.lean @@ -0,0 +1,157 @@ +import Aiur.Circuit.CheckerSoundness +import Aiur.Circuit.ForestBalance +import Mathlib.Data.List.OfFn + +namespace Aiur.Circuit + +variable {F : Type} [Field F] [DecidableEq F] {system : System F} {rom : WireROM F} + +private def ForestTrace (system : System F) (rom : WireROM F) (roots : List (Message F)) : Prop := + ∃ rows claims, system.inspectRows rom rows = .ok claims ∧ + Balance.Forest (fun c => decide (system.MapClaim c)) roots claims + +private theorem ForestTrace.append {left right : List (Message F)} + (a : ForestTrace system rom left) (b : ForestTrace system rom right) : + ForestTrace system rom (left ++ right) := by + obtain ⟨rowsA, claimsA, inspectedA, balancedA⟩ := a + obtain ⟨rowsB, claimsB, inspectedB, balancedB⟩ := b + refine ⟨rowsA ++ rowsB, claimsA ++ claimsB, ?_, Balance.forest_append balancedA balancedB⟩ + change rowsA.mapM _ = _ at inspectedA + change rowsB.mapM _ = _ at inspectedB + simp [System.inspectRows, List.mapM_append, inspectedA, inspectedB, bind, Except.bind, pure, Except.pure] + +/-- Flatten a proof to a checked forest. A static claim may be discharged directly, +even if the supplied tree happened to prove it using a chip with the same name. -/ +private theorem Derivation.forestTrace {root : Message F} (tree : Derivation system rom root) : + ForestTrace system rom [root] := by + induction tree using Derivation.rec + (motive_2 := fun roots _ => ForestTrace system rom roots) with + | node chip row lookup valid children ih => + by_cases static : system.MapClaim (chip.receive row) + · exact ⟨[], [], rfl, Balance.forest_static (by simp [static])⟩ + · obtain ⟨rows, claims, inspected, balanced⟩ := ih + refine ⟨row :: rows, (chip.receive row, chip.premises row) :: claims, ?_, + Balance.forest_node (by simp [static]) balanced⟩ + have checked := System.inspectRow_iff.mpr ⟨chip, lookup, valid, rfl⟩ + change rows.mapM _ = _ at inspected + simp [System.inspectRows, List.mapM_cons, checked, inspected, bind, Except.bind, pure, Except.pure] + | table member => exact ⟨[], [], rfl, Balance.forest_static (by simp [member])⟩ + | nil => exact ⟨[], [], rfl, Balance.forest_nil _⟩ + | cons _ _ head tail => exact head.append tail + +theorem Derivation.check_complete {root : Message F} (tree : Derivation system rom root) + (context : system.checkContext rom root = .ok ()) : + ∃ rows, system.check rom root rows = .ok () := by + obtain ⟨rows, claims, inspected, balanced⟩ := tree.forestTrace + exact ⟨rows, System.check_iff.mpr ⟨context, claims, inspected, balanced⟩⟩ + +theorem System.check_derives_iff {root : Message F} + (context : system.checkContext rom root = .ok ()) : + (∃ rows, system.check rom root rows = .ok ()) ↔ Derives system rom root := by + constructor + · rintro ⟨rows, checked⟩; exact system.check_sound checked + · rintro ⟨tree⟩; exact tree.check_complete context + +/-- Extract the chip rows; static leaves need no row. -/ +def RuleInstance.chipRows : List (RuleInstance system rom) → List (Row F) + | [] => [] + | .node _ row _ _ :: rules => row :: chipRows rules + | .table _ _ :: rules => chipRows rules + +def RuleInstance.chipClaims : List (RuleInstance system rom) → List (RuleClaims (Message F)) + | [] => [] + | rule@(.node _ _ _ _) :: rules => rule.claims :: chipClaims rules + | .table _ _ :: rules => chipClaims rules + +theorem RuleInstance.inspect_chipRows (rules : List (RuleInstance system rom)) : + system.inspectRows rom (chipRows rules) = .ok (chipClaims rules) := by + induction rules with + | nil => rfl + | cons rule rules ih => + cases rule with + | table claim member => exact ih + | node chip row lookup valid => + have checked := System.inspectRow_iff.mpr ⟨chip, lookup, valid, rfl⟩ + change (chipRows rules).mapM _ = _ at ih + simp [chipRows, chipClaims, RuleInstance.claims, RuleInstance.conclusion, RuleInstance.premises, + System.inspectRows, List.mapM_cons, checked, ih, bind, Except.bind, pure, Except.pure] + +theorem RuleInstance.chipClaims_origin {rules : List (RuleInstance system rom)} + {claim : RuleClaims (Message F)} (member : claim ∈ chipClaims rules) : + ∃ rule ∈ rules, rule.claims = claim := by + induction rules with + | nil => simp [chipClaims] at member + | cons rule rules ih => + cases rule with + | table c known => + obtain ⟨r, present, same⟩ := ih member + exact ⟨r, by simp [present], same⟩ + | node chip row lookup valid => + rcases List.mem_cons.mp member with rfl | member + · exact ⟨_, by simp, rfl⟩ + · obtain ⟨r, present, same⟩ := ih member + exact ⟨r, by simp [present], same⟩ + +theorem RuleInstance.dynamic_mem_chipClaims {rules : List (RuleInstance system rom)} + {rule : RuleInstance system rom} (member : rule ∈ rules) + (dynamic : ¬system.MapClaim rule.conclusion) : rule.claims ∈ chipClaims rules := by + induction rules with + | nil => simp at member + | cons head rules ih => + rcases List.mem_cons.mp member with rfl | member + · cases rule with + | node chip row lookup valid => simp [chipClaims] + | table claim known => exact (dynamic known).elim + · have present := ih member + cases head <;> simp [chipClaims, present] + +theorem System.inspectRows_weigh {rows : List (Row F)} {claims : List (RuleClaims (Message F))} + (inspected : system.inspectRows rom rows = .ok claims) (demands : List (Message F)) : + ∃ weighted, system.inspectWeightedRows rom weighted = .ok (Balance.weigh demands claims) := by + have related := mapM_ok_iff.mp inspected + clear inspected + induction related generalizing demands with + | nil => exact ⟨[], rfl⟩ + | @cons row claim rows claims head _ ih => + obtain ⟨weighted, inspected⟩ := ih (demands.filter (fun c => decide (c ≠ claim.1))) + refine ⟨⟨row, Accumulator.value (Accumulator.requires demands) claim.1⟩ :: weighted, ?_⟩ + apply mapM_ok_iff.mpr + apply List.Forall₂.cons + · simp [head, bind, Except.bind, pure, Except.pure] + · exact mapM_ok_iff.mp inspected + +/-- Every closed graph has an exact integer trace, including graphs with cycles. +The constructed provide weights count demands and are nonnegative. -/ +theorem MemoDerivation.check_complete {root : Message F} (graph : MemoDerivation system rom root) + (context : system.checkContext rom root = .ok ()) : + ∃ rows, system.checkMemo rom root rows = .ok () := by + let rules := List.ofFn graph.node + let claims := RuleInstance.chipClaims rules + let demands := Balance.required (fun c => decide (system.MapClaim c)) root claims + have covered : ∀ claim ∈ demands, ∃ provider ∈ claims, provider.1 = claim := by + intro claim member + obtain ⟨used, dynamic⟩ := List.mem_filter.mp member + have dynamic : ¬system.MapClaim claim := by simpa using dynamic + have provided : ∃ i, (graph.node i).conclusion = claim := by + rcases List.mem_cons.mp used with rfl | used + · exact ⟨graph.root, graph.root_claim⟩ + · obtain ⟨source, member, premise⟩ := List.mem_flatMap.mp used + obtain ⟨rule, present, same⟩ := RuleInstance.chipClaims_origin member + obtain ⟨i, rfl⟩ := List.mem_ofFn.mp present + have premise : claim ∈ (graph.node i).premises := by simpa [← same, RuleInstance.claims] using premise + exact graph.premise_mem i premise + obtain ⟨i, same⟩ := provided + exact ⟨(graph.node i).claims, + RuleInstance.dynamic_mem_chipClaims (List.mem_ofFn.mpr ⟨i, rfl⟩) (by simpa [same] using dynamic), same⟩ + obtain ⟨weighted, inspected⟩ := System.inspectRows_weigh (RuleInstance.inspect_chipRows rules) demands + exact ⟨weighted, System.checkMemo_iff.mpr ⟨context, Balance.weigh demands claims, inspected, + Balance.weigh_balanced covered⟩⟩ + +theorem System.checkMemo_derives_iff {root : Message F} + (context : system.checkContext rom root = .ok ()) : + (∃ rows, system.checkMemo rom root rows = .ok ()) ↔ MemoDerives system rom root := by + constructor + · rintro ⟨rows, checked⟩; exact system.checkMemo_sound checked + · rintro ⟨graph⟩; exact graph.check_complete context + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/CheckerContext.lean b/Aiur/Aiur/Circuit/CheckerContext.lean new file mode 100644 index 000000000..a7fec4dc5 --- /dev/null +++ b/Aiur/Aiur/Circuit/CheckerContext.lean @@ -0,0 +1,78 @@ +import Aiur.Circuit.CheckerCompleteness +import Aiur.Circuit.CompileFacts + +namespace Aiur.Circuit + +variable {F : Type} + +/-- Global layout and namespace checks, including unused chips. -/ +def System.WellFormed (system : System F) : Prop := + (system.chips.map Chip.name).Nodup ∧ ∀ chip ∈ system.chips, chip.wellFormed = true + +theorem checkChips_iff {seen : List String} {chips : List (Chip F)} : + checkChips seen chips = .ok () ↔ + (chips.map Chip.name).Nodup ∧ + (∀ chip ∈ chips, chip.wellFormed = true) ∧ + (∀ chip ∈ chips, chip.name ∉ seen) := by + induction chips generalizing seen with + | nil => simp [checkChips] + | cons chip chips ih => + by_cases fresh : chip.name ∈ seen + · simp [checkChips, fresh, bind, Except.bind] + · by_cases formed : chip.wellFormed = true + · simp [checkChips, fresh, formed, bind, Except.bind, pure, Except.pure, ih, + List.nodup_cons, List.mem_map, and_assoc, and_left_comm, and_comm] + grind + · simp [checkChips, fresh, formed, bind, Except.bind, pure, Except.pure] + +variable [Field F] [DecidableEq F] + +theorem compile_wellFormed {program : Program F} {system : System F} + (compiled : compile program = .ok system) : system.WellFormed := by + have checked := checkChips_iff.mp (compile_checkChips compiled) + exact ⟨checked.1, checked.2.1⟩ + +theorem System.checkContext_iff {system : System F} {rom : WireROM F} {root : Message F} : + system.checkContext rom root = .ok () ↔ + root.WellFormed system.enums ∧ root.PublicArguments system.enums ∧ + rom.Valid ∧ system.WellFormed := by + simp only [System.checkContext, except_bind_ok] + simp [mapM_unit_succeeds, Message.WellFormed, Message.PublicArguments, + checkChips_iff, System.WellFormed, pure, Except.pure, bind, Except.bind, + ite_eq_iff, forall_and, and_assoc, and_left_comm, and_comm, Option.ne_none_iff_exists] + simp only [eq_comm] + simp + +theorem System.check_entry_sound {system : System F} {rom : WireROM F} + {root : Message F} {rows : List (Row F)} + (checked : system.check rom root rows = .ok ()) : EntryDerives system root := by + obtain ⟨formed, free, valid, _⟩ := System.checkContext_iff.mp (System.check_iff.mp checked).1 + exact ⟨formed, free, rom, valid, system.check_sound checked⟩ + +theorem System.checkMemo_entry_sound {system : System F} {rom : WireROM F} + {root : Message F} {rows : List (WeightedRow F)} + (checked : system.checkMemo rom root rows = .ok ()) : MemoEntryDerives system root := by + obtain ⟨formed, free, valid, _⟩ := System.checkContext_iff.mp (System.checkMemo_iff.mp checked).1 + exact ⟨formed, free, rom, valid, system.checkMemo_sound checked⟩ + +theorem System.check_entry_iff {system : System F} (wellFormed : system.WellFormed) + {root : Message F} : + (∃ rom rows, system.check rom root rows = .ok ()) ↔ EntryDerives system root := by + constructor + · rintro ⟨rom, rows, checked⟩; exact system.check_entry_sound checked + · rintro ⟨formed, free, rom, valid, tree⟩ + obtain ⟨rows, checked⟩ := (system.check_derives_iff + (System.checkContext_iff.mpr ⟨formed, free, valid, wellFormed⟩)).mpr tree + exact ⟨rom, rows, checked⟩ + +theorem System.checkMemo_entry_iff {system : System F} (wellFormed : system.WellFormed) + {root : Message F} : + (∃ rom rows, system.checkMemo rom root rows = .ok ()) ↔ MemoEntryDerives system root := by + constructor + · rintro ⟨rom, rows, checked⟩; exact system.checkMemo_entry_sound checked + · rintro ⟨formed, free, rom, valid, graph⟩ + obtain ⟨rows, checked⟩ := (system.checkMemo_derives_iff + (System.checkContext_iff.mpr ⟨formed, free, valid, wellFormed⟩)).mpr graph + exact ⟨rom, rows, checked⟩ + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/CheckerFacts.lean b/Aiur/Aiur/Circuit/CheckerFacts.lean new file mode 100644 index 000000000..272126f86 --- /dev/null +++ b/Aiur/Aiur/Circuit/CheckerFacts.lean @@ -0,0 +1,98 @@ +import Aiur.Circuit.Entry +import Aiur.LayoutComposition + +namespace Aiur.Circuit + +theorem mapM_ok_iff {f : α → Except ε β} {xs : List α} {ys : List β} : + xs.mapM f = .ok ys ↔ List.Forall₂ (fun x y => f x = .ok y) xs ys := by + induction xs generalizing ys with + | nil => simp + | cons x xs ih => + cases hx : f x with + | error e => simp [List.mapM_cons, hx, List.forall₂_cons_left_iff, bind, Except.bind] + | ok y => + cases ht : xs.mapM f with + | error e => simp [List.mapM_cons, hx, ht, List.forall₂_cons_left_iff, ← ih, bind, Except.bind] + | ok rest => simp [List.mapM_cons, hx, ht, List.forall₂_cons_left_iff, ← ih, eq_comm, bind, Except.bind, pure, Except.pure] + +theorem mapM_unit_succeeds {f : α → Except ε Unit} {xs : List α} : + (∃ ys, xs.mapM f = .ok ys) ↔ ∀ x ∈ xs, f x = .ok () := by + induction xs with + | nil => simp + | cons x xs ih => + simp only [List.forall_mem_cons, ← ih] + cases hx : f x with + | error e => simp [List.mapM_cons, hx, bind, Except.bind] + | ok y => + cases y + cases ht : xs.mapM f with + | error e => simp [List.mapM_cons, hx, ht, bind, Except.bind] + | ok rest => simp [List.mapM_cons, hx, ht, bind, Except.bind] + +theorem zipIdx_forall {xs : List α} {p : α → Prop} : + (∀ x ∈ xs.zipIdx, p x.1) ↔ ∀ x ∈ xs, p x := by + simpa using (List.forall_mem_map (f := Prod.fst) (l := xs.zipIdx) (P := p)).symm + +theorem zipIdx_forall_pair {xs : List α} {p : α → Prop} : + (∀ a b, (a, b) ∈ xs.zipIdx → p a) ↔ ∀ a ∈ xs, p a := by + simpa only [Prod.forall] using (zipIdx_forall (xs := xs) (p := p)) + +variable {F : Type} [Field F] [DecidableEq F] + +theorem Chip.checkRow_iff {chip : Chip F} {rom : WireROM F} {row : Row F} + {claims : RuleClaims (Message F)} : + chip.checkRow rom row = .ok claims ↔ + chip.ValidRow rom row ∧ claims = (chip.receive row, chip.premises row) := by + by_cases formed : chip.wellFormed = true + · by_cases size : row.values.length = chip.numVars + · simp only [Chip.checkRow, formed, Bool.not_true, Bool.false_eq_true, if_false, + size, bne_self_eq_false] + simp only [except_bind_ok] + simp [mapM_unit_succeeds, Chip.ValidRow, formed, size, pure, Except.pure, bind, Except.bind, + Satisfies, Scalar.Circuit.Satisfies, MemoryLookup.Valid, zipIdx_forall_pair, and_assoc] + simp [eq_comm] + · simp [Chip.checkRow, Chip.ValidRow, formed, size, bind, Except.bind, pure, Except.pure] + · simp [Chip.checkRow, Chip.ValidRow, Bool.eq_false_iff.mpr formed, bind, Except.bind] + +theorem System.inspectRow_iff {system : System F} {rom : WireROM F} {row : Row F} + {claims : RuleClaims (Message F)} : + system.inspectRow rom row = .ok claims ↔ ∃ chip, + system.findChip? row.chip = some chip ∧ chip.ValidRow rom row ∧ + claims = (chip.receive row, chip.premises row) := by + unfold System.inspectRow + cases system.findChip? row.chip <;> simp [Chip.checkRow_iff] + +theorem System.check_iff {system : System F} {rom : WireROM F} {root : Message F} {rows : List (Row F)} : + system.check rom root rows = .ok () ↔ system.checkContext rom root = .ok () ∧ + ∃ rules, system.inspectRows rom rows = .ok rules ∧ + (Balance.required (fun c => decide (system.MapClaim c)) root rules).Perm (rules.map Prod.fst) := by + have unit (rules : List (RuleClaims (Message F))) : + (Balance.accumulator (fun c => decide (system.MapClaim c)) root + (rules.map fun rule => (rule, 1))).isZero = true ↔ + (Balance.required (fun c => decide (system.MapClaim c)) root rules).Perm (rules.map Prod.fst) := by + simpa [Balance.accumulator, Accumulator.requires, List.map_map, + Function.comp_def] using + (Accumulator.unit_balance_iff (Balance.required (fun c => decide (system.MapClaim c)) root rules) + (rules.map Prod.fst)) + cases ctx : system.checkContext rom root with + | error e => simp [System.check, ctx, bind, Except.bind] + | ok u => + cases u + cases inspected : system.inspectRows rom rows with + | error e => simp [System.check, ctx, inspected, bind, Except.bind] + | ok rules => simp [System.check, ctx, inspected, bind, Except.bind, pure, Except.pure, unit] + +theorem System.checkMemo_iff {system : System F} {rom : WireROM F} {root : Message F} + {rows : List (WeightedRow F)} : + system.checkMemo rom root rows = .ok () ↔ system.checkContext rom root = .ok () ∧ + ∃ rules, system.inspectWeightedRows rom rows = .ok rules ∧ + (Balance.accumulator (fun c => decide (system.MapClaim c)) root rules).isZero = true := by + cases ctx : system.checkContext rom root with + | error e => simp [System.checkMemo, ctx, bind, Except.bind] + | ok u => + cases u + cases inspected : system.inspectWeightedRows rom rows with + | error e => simp [System.checkMemo, ctx, inspected, bind, Except.bind] + | ok rules => simp [System.checkMemo, ctx, inspected, bind, Except.bind, pure, Except.pure] + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/CheckerSoundness.lean b/Aiur/Aiur/Circuit/CheckerSoundness.lean new file mode 100644 index 000000000..15aae4ea6 --- /dev/null +++ b/Aiur/Aiur/Circuit/CheckerSoundness.lean @@ -0,0 +1,100 @@ +import Aiur.Circuit.CheckerFacts + +namespace Aiur.Circuit + +variable {F : Type} [Field F] [DecidableEq F] {system : System F} {rom : WireROM F} + +def RuleInstance.claims (rule : RuleInstance system rom) : RuleClaims (Message F) := + (rule.conclusion, rule.premises) + +theorem RuleInstance.derives (rule : RuleInstance system rom) + (premises : ∀ claim ∈ rule.premises, Derives system rom claim) : Derives system rom rule.conclusion := by + obtain ⟨children⟩ := derivations_nonempty_iff.mpr premises + cases rule with + | node chip row lookup valid => exact ⟨.node chip row lookup valid children⟩ + | table claim member => exact ⟨.table member⟩ + +theorem System.inspectRows_rules {rows : List (Row F)} {claims : List (RuleClaims (Message F))} + (inspected : system.inspectRows rom rows = .ok claims) : + ∃ rules : List (RuleInstance system rom), claims = rules.map RuleInstance.claims := by + have related := mapM_ok_iff.mp inspected + clear inspected + induction related with + | nil => exact ⟨[], rfl⟩ + | cons head _ ih => + obtain ⟨rules, rfl⟩ := ih + obtain ⟨chip, lookup, valid, rfl⟩ := System.inspectRow_iff.mp head + exact ⟨.node chip _ lookup valid :: rules, rfl⟩ + +theorem System.inspectWeightedRows_rules {rows : List (WeightedRow F)} + {claims : List (RuleClaims (Message F) × Int)} + (inspected : system.inspectWeightedRows rom rows = .ok claims) : + ∃ rules : List (RuleInstance system rom × Int), + claims = rules.map (fun rule => (rule.1.claims, rule.2)) := by + have related := mapM_ok_iff.mp inspected + clear inspected + induction related with + | nil => exact ⟨[], rfl⟩ + | @cons row claim rows claims head _ ih => + obtain ⟨rules, rfl⟩ := ih + obtain ⟨info, checked, same⟩ := except_bind_ok.mp head + have same : (info, row.multiplicity) = claim := by simpa using same + subst claim + obtain ⟨chip, lookup, valid, rfl⟩ := System.inspectRow_iff.mp checked + exact ⟨(.node chip row.row lookup valid, row.multiplicity) :: rules, rfl⟩ + +/-- Soundness of the unit-multiplicity trace checker, independently of compilation. +Unreachable balanced components need not be part of the resulting finite tree. -/ +theorem System.check_sound {root : Message F} {rows : List (Row F)} + (checked : system.check rom root rows = .ok ()) : Derives system rom root := by + obtain ⟨_, claims, inspected, balanced⟩ := System.check_iff.mp checked + obtain ⟨rules, rfl⟩ := system.inspectRows_rules inspected + apply Balance.property_of_unit_balance (property := Derives system rom) ?_ ?_ balanced + · intro claim member + exact ⟨.table (of_decide_eq_true member)⟩ + · intro claim member premises + obtain ⟨rule, _, rfl⟩ := List.mem_map.mp member + exact rule.derives premises + +/-- Signed provide weights force the support condition of a closed memoized graph. +There is no acyclicity condition in this theorem. -/ +theorem memoDerives_of_balance {root : Message F} {rules : List (RuleInstance system rom × Int)} + (zero : (Balance.accumulator (fun c => decide (system.MapClaim c)) root + (rules.map fun rule => (rule.1.claims, rule.2))).isZero = true) : MemoDerives system rom root := by + let tables : List (RuleInstance system rom) := + system.mapClaims.attach.map fun claim => .table claim.val claim.property + let nodes := rules.map Prod.fst ++ tables + have locate (claim : Message F) + (used : claim = root ∨ ∃ rule ∈ rules, claim ∈ rule.1.premises) : + ∃ node ∈ nodes, node.conclusion = claim := by + by_cases static : system.MapClaim claim + · exact ⟨.table claim static, List.mem_append_right _ + (List.mem_map.mpr ⟨⟨claim, static⟩, List.mem_attach _ _, rfl⟩), rfl⟩ + · have needed : claim ∈ Balance.required (fun c => decide (system.MapClaim c)) root + ((rules.map fun rule => (rule.1.claims, rule.2)).map Prod.fst) := by + apply List.mem_filter.mpr + refine ⟨?_, by simp [static]⟩ + rcases used with rfl | ⟨rule, member, premise⟩ + · exact List.mem_cons_self + · apply List.mem_cons_of_mem + exact List.mem_flatMap.mpr ⟨rule.1.claims, + List.mem_map.mpr ⟨(rule.1.claims, rule.2), List.mem_map.mpr ⟨rule, member, rfl⟩, rfl⟩, + premise⟩ + obtain ⟨provider, member, same⟩ := Balance.provider_of_zero zero needed + obtain ⟨rule, belongs, rfl⟩ := List.mem_map.mp member + exact ⟨rule.1, List.mem_append_left _ (List.mem_map.mpr ⟨rule, belongs, rfl⟩), same⟩ + refine ⟨MemoDerivation.ofClosed nodes (locate root (Or.inl rfl)) ?_⟩ + intro rule member premise needed + rcases List.mem_append.mp member with dynamic | static + · obtain ⟨weighted, belongs, rfl⟩ := List.mem_map.mp dynamic + exact locate premise (Or.inr ⟨weighted, belongs, needed⟩) + · obtain ⟨claim, _, rfl⟩ := List.mem_map.mp static + simp [RuleInstance.premises] at needed + +theorem System.checkMemo_sound {root : Message F} {rows : List (WeightedRow F)} + (checked : system.checkMemo rom root rows = .ok ()) : MemoDerives system rom root := by + obtain ⟨_, claims, inspected, zero⟩ := System.checkMemo_iff.mp checked + obtain ⟨rules, rfl⟩ := system.inspectWeightedRows_rules inspected + exact memoDerives_of_balance zero + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/Compile.lean b/Aiur/Aiur/Circuit/Compile.lean new file mode 100644 index 000000000..fb861d037 --- /dev/null +++ b/Aiur/Aiur/Circuit/Compile.lean @@ -0,0 +1,364 @@ +import Aiur.Circuit.Basic +import Aiur.Typecheck + +namespace Aiur.Circuit + +inductive CompileError where + | invalidProgram (error : CheckError) + | duplicatePattern (function : String) + | tagCollision (enumName : String) + | invalidShape + deriving Repr, BEq + +namespace Compiler + +structure BuildState (F : Type) where + nextVar : Nat := 0 + constraints : Array (Constraint F) := #[] + sends : Array (Send F) := #[] + memory : Array (MemoryLookup F) := #[] + +abbrev Build (F : Type) := StateT (BuildState F) (Except CompileError) +abbrev Symbolic (F : Type) := WireValue (ArithExpr F) +abbrev Locals (F : Type) := List (String × Symbolic F) + +theorem enumParts_denote [Field F] {count : Nat} {words payload : List (ArithExpr F)} + {tag : ArithExpr F} + (parts : Layout.enumParts count (.const 0) words = some (tag, payload)) (assignment : Var → F) : + Layout.enumParts count (0 : F) (words.map (ArithExpr.denote assignment)) = + some (tag.denote assignment, payload.map (ArithExpr.denote assignment)) := by + simpa only [Scalar.Circuit.ArithExpr.denote, Nat.cast_zero] using + Layout.enumParts_map_of (ArithExpr.denote assignment) parts + +def fresh : Build F Var := do + let state ← get + set { state with nextVar := state.nextVar + 1 } + return state.nextVar + +def constrain (polynomial : ArithExpr F) : Build F Unit := + modify fun state => { state with constraints := state.constraints.push polynomial } + +def guarded (enable polynomial : ArithExpr F) : Build F Unit := constrain (.mul enable polynomial) + +def boolean [Field F] (selector : ArithExpr F) : Build F Unit := + constrain (.mul selector (.sub selector (.const 1))) + +def requireCell (enable address : ArithExpr F) (value : Symbolic F) : Build F Unit := + modify fun state => { state with memory := state.memory.push ⟨address, value, enable⟩ } + +def getLayout (decls : Declarations) (type : Ty) : Build F Layout := + liftM ((decls.layout type).mapError (CompileError.invalidProgram ∘ CheckError.invalidDeclarations)) + +def freshWords (count : Nat) : Build F (List Var) := do + let state ← get + set { state with nextVar := state.nextVar + count } + return List.range' state.nextVar count + +/-- An opaque result gets a variable for every column, including enum tags and padding. -/ +def freshValue (decls : Declarations) (type : Ty) : Build F (WireValue Var) := do + let layout ← getLayout decls type + return ⟨type, ← freshWords layout.width⟩ + +def freshValues (decls : Declarations) (types : List Ty) : Build F (List (WireValue Var)) := + types.mapM (freshValue decls) + +/-- Split a flat tuple/payload using its static types; no witness-dependent slicing occurs. -/ +def splitValues (decls : Declarations) : List Ty → List α → Build F (List (WireValue α)) + | [], [] => pure [] + | type :: types, words => do + let layout ← getLayout decls type + if words.length < layout.width then throw .invalidShape + return ⟨type, words.take layout.width⟩ :: + (← splitValues decls types (words.drop layout.width)) + | [], _ :: _ => throw .invalidShape + +/-- A zero test is exact in every field; inverses are auxiliary witnesses. -/ +def equalIndicator [Field F] (difference : ArithExpr F) : Build F (ArithExpr F) := do + let equal := ArithExpr.var (← fresh) + let inverse := ArithExpr.var (← fresh) + boolean equal + constrain (.mul difference equal) + constrain (.sub (.mul difference inverse) (.sub (.const 1) equal)) + return equal + +def zeroWords (enable : ArithExpr F) : List (ArithExpr F) → Build F Unit + | [] => pure () + | word :: words => do + guarded enable word + zeroWords enable words + +mutual + /-- Only the selected constructor's payload view is required to be canonical. -/ + def validate [Field F] : Layout → ArithExpr F → List (ArithExpr F) → Build F Unit + | .field, _, [_] | .ptr _, _, [_] => pure () + | .tuple layouts, enable, words => validateList layouts enable words + | .enum _ constructors, enable, words => do + let some (tag, payload) := Layout.enumParts constructors.length (.const 0) words + | throw .invalidShape + if payload.length != Layout.payloadWidth constructors then throw .invalidShape + let tests ← validateConstructors constructors enable tag payload 0 + guarded enable (.sub (tests.foldl ArithExpr.add (.const 0)) (.const 1)) + | _, _, _ => throw .invalidShape + termination_by layout _ _ => sizeOf layout + + def validateList [Field F] : List Layout → ArithExpr F → List (ArithExpr F) → Build F Unit + | [], _, [] => pure () + | layout :: layouts, enable, words => do + if words.length < layout.width then throw .invalidShape + validate layout enable (words.take layout.width) + validateList layouts enable (words.drop layout.width) + | [], _, _ :: _ => throw .invalidShape + termination_by layouts _ _ => sizeOf layouts + + def validateConstructors [Field F] : List (String × Layout) → ArithExpr F → ArithExpr F → + List (ArithExpr F) → Nat → Build F (List (ArithExpr F)) + | [], _, _, _, _ => pure [] + | (_, layout) :: constructors, enable, tag, payload, index => do + let test ← equalIndicator (.sub tag (.const (index : F))) + let selected := ArithExpr.mul enable test + validate layout selected (payload.take layout.width) + zeroWords selected (payload.drop layout.width) + return test :: (← validateConstructors constructors enable tag payload (index + 1)) + termination_by constructors _ _ _ _ => sizeOf constructors +end + +def validateValue [Field F] (decls : Declarations) (enable : ArithExpr F) (value : Symbolic F) : + Build F Unit := do + validate (← getLayout decls value.type) enable value.words + +def validateValues [Field F] (decls : Declarations) (enable : ArithExpr F) : + List (Symbolic F) → Build F Unit + | [] => pure () + | value :: values => do + validateValue decls enable value + validateValues decls enable values + +def checkPatterns [DecidableEq F] (decls : Declarations) (function : String) : + List (Pattern F × Expr F) → List (Pattern F) → Except CompileError Unit + | [], _ => pure () + | (pattern, _) :: rest, seen => do + if seen.any (fun other => decide (pattern.condition = other)) then + throw (.duplicatePattern function) + if pattern.irrefutable decls then return () + checkPatterns decls function rest (pattern.condition :: seen) + +mutual + def lowerPattern [Field F] (decls : Declarations) (pattern : Pattern F) (value : Symbolic F) : + Build F (ArithExpr F × Locals F) := do + match pattern with + | .wildcard => return (.const 1, []) + | .bind name => return (.const 1, [(name, value)]) + | .literal literal => + let ⟨.field, [word]⟩ := value | throw .invalidShape + return (← equalIndicator (.sub word (.const literal)), []) + | .tuple patterns => + let .tuple types := value.type | throw .invalidShape + lowerPatterns decls patterns (← splitValues decls types value.words) + | .construct name ctor patterns => + if value.type ≠ .enum name then throw .invalidShape + let some definition := decls.findEnum? name | throw .invalidShape + let index := definition.constructors.findIdx (·.name == ctor) + let some constructor := definition.constructors[index]? | throw .invalidShape + let some (tag, payload) := Layout.enumParts definition.constructors.length (.const 0) value.words + | throw .invalidShape + let layout ← getLayout decls (.tuple constructor.fields) + let values ← splitValues decls constructor.fields (payload.take layout.width) + let tagTest ← equalIndicator (.sub tag (.const (index : F))) + let (payloadTest, bindings) ← lowerPatterns decls patterns values + return (.mul tagTest payloadTest, bindings) + termination_by sizeOf pattern + + def lowerPatterns [Field F] (decls : Declarations) (patterns : List (Pattern F)) + (values : List (Symbolic F)) : Build F (ArithExpr F × Locals F) := do + match patterns, values with + | [], [] => return (.const 1, []) + | pattern :: patterns, value :: values => + let (test, bindings) ← lowerPattern decls pattern value + let (tests, rest) ← lowerPatterns decls patterns values + return (.mul test tests, bindings ++ rest) + | _, _ => throw .invalidShape + termination_by sizeOf patterns +end + +def constrainWords (enable : ArithExpr F) : List (ArithExpr F) → List (ArithExpr F) → Build F Unit + | [], [] => pure () + | x :: xs, y :: ys => do + guarded enable (.sub x y) + constrainWords enable xs ys + | _, _ => throw .invalidShape + +/-- Equality is componentwise on the entire canonical encoding. -/ +def constrainValue (enable : ArithExpr F) (left right : Symbolic F) : Build F Unit := do + if left.type ≠ right.type then throw .invalidShape + constrainWords enable left.words right.words + +def asField : Symbolic F → Build F (ArithExpr F) + | ⟨.field, [word]⟩ => pure word + | _ => throw .invalidShape + +def excludePairs (selectors : List (ArithExpr F)) : Build F Unit := do + match selectors with + | [] => return () + | selector :: rest => + for other in rest do constrain (.mul selector other) + excludePairs rest + +mutual + def lowerExpr [Field F] [DecidableEq F] (program : Program F) (function : String) + (locals : Locals F) (enable : ArithExpr F) (expr : Expr F) : Build F (Symbolic F) := do + match expr with + | .literal value => return .field (.const value) + | .var name => + let some (_, value) := locals.find? (·.1 == name) + | throw (.invalidProgram (.unboundVariable function name)) + return value + | .tuple items => return .tuple (← lowerArgs program function locals enable items) + | .construct name ctor args => + let some definition := program.enums.findEnum? name | throw .invalidShape + let index := definition.constructors.findIdx (·.name == ctor) + let some constructor := definition.constructors[index]? | throw .invalidShape + let values ← lowerArgs program function locals enable args + if values.map WireValue.type ≠ constructor.fields then throw .invalidShape + let layout ← getLayout program.enums (.enum name) + let payload := values.flatMap WireValue.words + let tagWidth := Layout.tagWidth definition.constructors.length + if payload.length + tagWidth > layout.width then throw .invalidShape + return ⟨.enum name, Layout.enumWords definition.constructors.length (.const (index : F)) + (payload ++ List.replicate (layout.width - tagWidth - payload.length) (.const 0))⟩ + | .project value index => + let value ← lowerExpr program function locals enable value + let .tuple types := value.type | throw .invalidShape + let items ← splitValues program.enums types value.words + let some result := items[index]? | throw .invalidShape + return result + | .letValue pattern value body => + let value ← lowerExpr program function locals enable value + let (test, bindings) ← lowerPattern program.enums pattern value + guarded enable (.sub test (.const 1)) + lowerExpr program function (bindings ++ locals) enable body + | .store operand => + let value ← lowerExpr program function locals enable operand + let address ← fresh + boolean enable + validateValue program.enums enable value + requireCell enable (.var address) value + return .ptr value.type (.var address) + | .load operand => + let pointer ← lowerExpr program function locals enable operand + let ⟨.ptr target, [address]⟩ := pointer | throw .invalidShape + let result ← freshValue program.enums target + let value := result.map ArithExpr.var + boolean enable + validateValue program.enums enable value + requireCell enable address value + return value + | .neg value => + return .field (.sub (.const 0) (← asField (← lowerExpr program function locals enable value))) + | .hint type key channel => + let _ ← lowerExpr program function locals enable key + if !type.pointerFree program.enums then throw .invalidShape + let result ← freshValue program.enums type + validateValue program.enums enable (result.map ArithExpr.var) + return result.map ArithExpr.var + | .assertEq _ left right => + let left ← lowerExpr program function locals enable left + let right ← lowerExpr program function locals enable right + if !left.type.pointerFree program.enums then throw .invalidShape + constrainValue enable left right + return .tuple [] + | .binary op left right => + let left ← asField (← lowerExpr program function locals enable left) + let right ← asField (← lowerExpr program function locals enable right) + match op with + | .add => return .field (.add left right) + | .sub => return .field (.sub left right) + | .mul => return .field (.mul left right) + | .div => + let inverse ← fresh + guarded enable (.sub (.mul right (.var inverse)) (.const 1)) + return .field (.mul left (.var inverse)) + | .call name args => + let some callee := program.findSignature? name + | throw (.invalidProgram (.unknownFunction function name)) + let args ← lowerArgs program function locals enable args + if args.map WireValue.type ≠ callee.params.map Prod.snd then throw .invalidShape + let result ← freshValue program.enums callee.result + boolean enable + validateValues program.enums enable args + validateValue program.enums enable (result.map ArithExpr.var) + modify fun state => { state with sends := state.sends.push ⟨name, args, result, enable⟩ } + return result.map ArithExpr.var + | .matchValue scrutinee arms => + liftM (checkPatterns program.enums function arms []) + let type ← liftM ((inferType program function + (locals.map fun (name, value) => (name, value.type)) expr).mapError CompileError.invalidProgram) + let scrutinee ← lowerExpr program function locals enable scrutinee + let result ← freshValue program.enums type + validateValue program.enums enable (result.map ArithExpr.var) + let selectors ← lowerArms program function locals scrutinee + (result.map ArithExpr.var) enable arms + excludePairs selectors + constrain (.sub (selectors.foldl ArithExpr.add (.const 0)) enable) + return result.map ArithExpr.var + termination_by sizeOf expr + + def lowerArgs [Field F] [DecidableEq F] (program : Program F) (function : String) + (locals : Locals F) (enable : ArithExpr F) (args : List (Expr F)) : + Build F (List (Symbolic F)) := do + match args with + | [] => return [] + | arg :: rest => + return (← lowerExpr program function locals enable arg) :: + (← lowerArgs program function locals enable rest) + termination_by sizeOf args + + def lowerArms [Field F] [DecidableEq F] (program : Program F) (function : String) + (locals : Locals F) (scrutinee result : Symbolic F) (remaining : ArithExpr F) + (arms : List (Pattern F × Expr F)) : Build F (List (ArithExpr F)) := do + match arms with + | [] => return [] + | (pattern, body) :: rest => + let (test, bindings) ← lowerPattern program.enums pattern scrutinee + let selector := ArithExpr.var (← fresh) + boolean selector + constrain (.sub selector (.mul remaining test)) + let body ← lowerExpr program function (bindings ++ locals) selector body + constrainValue selector result body + if pattern.irrefutable program.enums then return [selector] + let rest ← lowerArms program function locals scrutinee result + (.mul remaining (.sub (.const 1) test)) rest + return selector :: rest + termination_by sizeOf arms +end + +def lowerFunction [Field F] [DecidableEq F] (program : Program F) (fn : Function F) : + Except CompileError (Chip F) := do + let build : Build F (List (WireValue Var) × WireValue Var) := do + let inputs ← freshValues program.enums (fn.params.map Prod.snd) + let output ← freshValue program.enums fn.result + validateValues program.enums (.const 1) (inputs.map (WireValue.map ArithExpr.var)) + validateValue program.enums (.const 1) (output.map ArithExpr.var) + let locals := (fn.params.map Prod.fst).zip (inputs.map (WireValue.map ArithExpr.var)) + let body ← lowerExpr program fn.name locals (.const 1) fn.body + constrainValue (.const 1) (output.map ArithExpr.var) body + return (inputs, output) + let ((inputs, output), state) ← build.run {} + return ⟨fn.name, inputs, output.map ArithExpr.var, state.nextVar, state.constraints.toList, state.sends.toList, + state.memory.toList⟩ + +end Compiler + +def checkEnumTags (F : Type) [NatCast F] [DecidableEq F] (declaration : EnumDecl) : + Except CompileError Unit := + if ((List.range declaration.constructors.length).map (fun i : Nat => (i : F))).Nodup then + pure () + else throw (.tagCollision declaration.name) + +def compile [Field F] [DecidableEq F] (program : Program F) : Except CompileError (System F) := do + let _ ← (typecheck program).mapError CompileError.invalidProgram + for declaration in program.enums do checkEnumTags F declaration + let chips ← program.functions.mapM (Compiler.lowerFunction program) + let _ ← (checkChips [] chips).mapError (fun _ => CompileError.invalidShape) + return ⟨chips, program.enums, program.tables, program.maps⟩ + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/CompileFacts.lean b/Aiur/Aiur/Circuit/CompileFacts.lean new file mode 100644 index 000000000..5e150f687 --- /dev/null +++ b/Aiur/Aiur/Circuit/CompileFacts.lean @@ -0,0 +1,164 @@ +import Aiur.Circuit.BuildFacts +import Aiur.TypecheckFacts +import Aiur.EncodingTypes + +namespace Aiur.Circuit + +variable {F : Type} {rom : WireROM F} + +private theorem except_bind_ok {first : Except ε α} {next : α → Except ε β} {result : β} : + (first >>= next) = .ok result ↔ ∃ value, first = .ok value ∧ next value = .ok result := by + cases first <;> simp [bind, Except.bind] + +/-- Expose interface validation separately from the function body. -/ +theorem Compiler.lowerFunction_stages [Field F] [DecidableEq F] + {program : Program F} {fn : Function F} {chip : Chip F} + (compiled : Compiler.lowerFunction program fn = .ok chip) : + ∃ inputs output s₁ s₂ s₃ s₄ body s₅ s₆, + Compiler.freshValues program.enums (fn.params.map Prod.snd) {} = .ok (inputs, s₁) ∧ + Compiler.freshValue program.enums fn.result s₁ = .ok (output, s₂) ∧ + Compiler.validateValues program.enums (.const 1) + (inputs.map (WireValue.map ArithExpr.var)) s₂ = .ok ((), s₃) ∧ + Compiler.validateValue program.enums (.const 1) (output.map ArithExpr.var) s₃ = .ok ((), s₄) ∧ + Compiler.lowerExpr program fn.name + ((fn.params.map Prod.fst).zip (inputs.map (WireValue.map ArithExpr.var))) + (.const 1) fn.body s₄ = .ok (body, s₅) ∧ + Compiler.constrainValue (.const 1) (output.map ArithExpr.var) body s₅ = .ok ((), s₆) ∧ + chip = ⟨fn.name, inputs, output.map ArithExpr.var, s₆.nextVar, s₆.constraints.toList, s₆.sends.toList, s₆.memory.toList⟩ := by + unfold Compiler.lowerFunction at compiled + obtain ⟨⟨⟨inputs, output⟩, state⟩, run, finished⟩ := except_bind_ok.mp compiled + simp only [pure, Except.pure, Except.ok.injEq] at finished + subst chip + obtain ⟨inputs, s₁, inputsRun, rest⟩ := Compiler.bind_ok.mp run + obtain ⟨output, s₂, outputRun, rest⟩ := Compiler.bind_ok.mp rest + obtain ⟨⟨⟩, s₃, inputsValid, rest⟩ := Compiler.bind_ok.mp rest + obtain ⟨⟨⟩, s₄, outputValid, rest⟩ := Compiler.bind_ok.mp rest + obtain ⟨body, s₅, bodyRun, rest⟩ := Compiler.bind_ok.mp rest + obtain ⟨⟨⟩, s₆, constraintRun, rest⟩ := Compiler.bind_ok.mp rest + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := Compiler.pure_ok.mp rest + exact ⟨inputs, output, s₁, s₂, s₃, s₄, body, s₅, s₆, + inputsRun, outputRun, inputsValid, outputValid, bodyRun, constraintRun, rfl⟩ + +theorem Compiler.lowerFunction_interface [Field F] [DecidableEq F] + {program : Program F} {fn : Function F} {chip : Chip F} + (compiled : Compiler.lowerFunction program fn = .ok chip) : + chip.name = fn.name ∧ chip.inputs.map WireValue.type = fn.params.map Prod.snd ∧ + chip.output.type = fn.result := by + obtain ⟨_, _, _, _, _, _, _, _, _, inputsRun, outputRun, _, _, _, _, rfl⟩ := lowerFunction_stages compiled + exact ⟨rfl, (freshValues_spec inputsRun).2.2.1, (freshValue_spec outputRun).2.2.1⟩ + +/-- Compilation checks field tag injectivity independently of allocation capacity. -/ +theorem compile_stages [Field F] [DecidableEq F] {program : Program F} {system : System F} + (compiled : compile program = .ok system) : + typecheck program = .ok () ∧ program.enums.tagsValid F = true ∧ + program.functions.mapM (Compiler.lowerFunction program) = .ok system.chips ∧ + system.enums = program.enums ∧ system.tables = program.tables ∧ system.maps = program.maps := by + unfold compile at compiled + obtain ⟨⟨⟩, checked, rest⟩ := except_bind_ok.mp compiled + have checked : typecheck program = .ok () := by + cases h : typecheck program with + | error error => simp [h, Except.mapError] at checked + | ok unit => cases unit; rfl + obtain ⟨⟨⟩, tags, rest⟩ := except_bind_ok.mp rest + obtain ⟨chips, mapped, last⟩ := except_bind_ok.mp rest + obtain ⟨⟨⟩, _, finished⟩ := except_bind_ok.mp last + have same := except_pure_ok.mp finished + subst system + refine ⟨checked, ?_, mapped, rfl, rfl, rfl⟩ + apply (Declarations.tagsValid_spec program.enums).mpr + have each := forIn_ok (items := program.enums) (action := checkEnumTags F) (by + have combined := congrArg (fun r : Except CompileError PUnit => r >>= fun _ => + (pure () : Except CompileError Unit)) tags + simpa only [bind, Except.bind, pure, Except.pure] using combined) + intro decl member + have accepted := each decl member + unfold checkEnumTags at accepted + split at accepted + · assumption + · cases accepted + +/-- Successful compilation certifies the complete output namespace and +layouts, including functions unused by a particular execution. -/ +theorem compile_checkChips [Field F] [DecidableEq F] {program : Program F} {system : System F} + (compiled : compile program = .ok system) : checkChips [] system.chips = .ok () := by + unfold compile at compiled + obtain ⟨_, _, rest₁⟩ := except_bind_ok.mp compiled + obtain ⟨_, _, rest₂⟩ := except_bind_ok.mp rest₁ + obtain ⟨chips, _, rest₃⟩ := except_bind_ok.mp rest₂ + obtain ⟨_, formed, finished⟩ := except_bind_ok.mp rest₃ + obtain rfl := except_pure_ok.mp finished + cases checked : checkChips [] chips with + | error error => simp [checked, Except.mapError] at formed + | ok value => cases value; rfl + + +private theorem forall₂_of_mapM_ok {f : α → Except ε β} {xs : List α} {ys : List β} + (mapped : xs.mapM f = .ok ys) : List.Forall₂ (fun x y => f x = .ok y) xs ys := by + induction xs generalizing ys with + | nil => simp only [List.mapM_nil] at mapped; cases mapped; exact .nil + | cons x xs ih => + cases hx : f x with + | error error => simp [hx] at mapped; cases mapped + | ok y => + cases hxs : xs.mapM f with + | error error => simp [hx, hxs] at mapped; cases mapped + | ok rest => + simp [hx, hxs] at mapped + cases mapped + exact .cons hx (ih hxs) + +theorem compile_functions [Field F] [DecidableEq F] {program : Program F} {system : System F} + (compiled : compile program = .ok system) : + List.Forall₂ (fun fn chip => Compiler.lowerFunction program fn = .ok chip) + program.functions system.chips := by + exact forall₂_of_mapM_ok (compile_stages compiled).2.2.1 + +private theorem lookup_functions [Field F] [DecidableEq F] {program : Program F} + {fns : List (Function F)} {chips : List (Chip F)} + (compiled : List.Forall₂ (fun fn chip => Compiler.lowerFunction program fn = .ok chip) fns chips) + (name : String) : + Option.Rel (fun fn chip => Compiler.lowerFunction program fn = .ok chip) + (fns.find? (·.name == name)) (chips.find? (·.name == name)) := by + induction compiled with + | nil => exact .none + | cons head _ ih => + have names := (Compiler.lowerFunction_interface head).1 + simp only [List.find?_cons, names] + split + · exact .some head + · exact ih + +theorem compile_find_function [Field F] [DecidableEq F] + {program : Program F} {system : System F} (compiled : compile program = .ok system) + {name : String} {fn : Function F} (found : program.findFunction? name = some fn) : + ∃ chip, system.findChip? name = some chip ∧ Compiler.lowerFunction program fn = .ok chip := by + have related := lookup_functions (compile_functions compiled) name + change Option.Rel _ (program.findFunction? name) (system.findChip? name) at related + rw [found] at related + cases target : system.findChip? name with + | none => rw [target] at related; cases related + | some chip => + rw [target] at related + cases related with + | some lowered => exact ⟨chip, rfl, lowered⟩ + +theorem compile_find_chip [Field F] [DecidableEq F] + {program : Program F} {system : System F} (compiled : compile program = .ok system) + {name : String} {chip : Chip F} (found : system.findChip? name = some chip) : + ∃ fn, program.findFunction? name = some fn ∧ Compiler.lowerFunction program fn = .ok chip := by + have related := lookup_functions (compile_functions compiled) name + change Option.Rel _ (program.findFunction? name) (system.findChip? name) at related + rw [found] at related + cases source : program.findFunction? name with + | none => rw [source] at related; cases related + | some fn => + rw [source] at related + cases related with + | some lowered => exact ⟨fn, rfl, lowered⟩ + +theorem findFunction_name {program : Program F} {name : String} {fn : Function F} + (found : program.findFunction? name = some fn) : fn.name = name := by + have := List.find?_some found + simpa using this + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/Derivation.lean b/Aiur/Aiur/Circuit/Derivation.lean new file mode 100644 index 000000000..0912e3353 --- /dev/null +++ b/Aiur/Aiur/Circuit/Derivation.lean @@ -0,0 +1,94 @@ +import Aiur.Circuit.Basic + +namespace Aiur.Circuit + +variable {F : Type} {rom : WireROM F} + +mutual + /-- + A closed, finite derivation of a message. Local validity is a side condition; + all enabled calls must be discharged by child derivations. There is no assumption rule. + -/ + inductive Derivation [Field F] [DecidableEq F] (system : System F) (rom : WireROM F) : Message F → Type where + | node (chip : Chip F) (row : Row F) + (lookup : system.findChip? row.chip = some chip) + (valid : chip.ValidRow rom row) + (children : Derivations system rom (chip.premises row)) : + Derivation system rom (chip.receive row) + | table (member : system.MapClaim message) : Derivation system rom message + + /-- A finite list of proofs indexed by its list of premise occurrences. -/ + inductive Derivations [Field F] [DecidableEq F] (system : System F) (rom : WireROM F) : List (Message F) → Type where + | nil : Derivations system rom [] + | cons (head : Derivation system rom message) (tail : Derivations system rom messages) : + Derivations system rom (message :: messages) +end + +/-- Derivability asserts the existence of a closed derivation tree. -/ +def Derives [Field F] [DecidableEq F] (system : System F) (rom : WireROM F) (message : Message F) : Prop := + Nonempty (Derivation system rom message) + +/-- The circuit relation for one function's arguments and claimed result. -/ +def CircuitEvaluates [Field F] [DecidableEq F] (system : System F) (rom : WireROM F) + (function : String) (args : List (WireValue F)) (result : WireValue F) : Prop := + Derives system rom ⟨function, args, result⟩ + +/-- Assemble a forest from proofs of every premise, retaining repeated occurrences. -/ +theorem derivations_nonempty_iff [Field F] [DecidableEq F] {system : System F} + {messages : List (Message F)} : + Nonempty (Derivations system rom messages) ↔ ∀ message ∈ messages, Derives system rom message := by + induction messages with + | nil => + constructor + · intros; contradiction + · intro _; exact ⟨.nil⟩ + | cons message messages ih => + constructor + · rintro ⟨children⟩ + cases children with + | cons head tail => + intro next member + rcases List.mem_cons.mp member with same | member + · subst next; exact ⟨head⟩ + · exact ih.mp ⟨tail⟩ next member + · intro premises + obtain ⟨head⟩ := premises message (by simp) + obtain ⟨tail⟩ := ih.mpr (fun next member => premises next (by simp [member])) + exact ⟨.cons head tail⟩ + +mutual + /-- Flatten a tree to rows, retaining separate occurrences of identical calls. -/ + def Derivation.rows [Field F] [DecidableEq F] {system : System F} {message : Message F} : + Derivation system rom message → List (Row F) + | .node _ row _ _ children => row :: children.rows + | .table _ => [] + + def Derivations.rows [Field F] [DecidableEq F] {system : System F} {messages : List (Message F)} : + Derivations system rom messages → List (Row F) + | .nil => [] + | .cons head tail => head.rows ++ tail.rows +end + +theorem Derivation.rows_ne_nil [Field F] [DecidableEq F] {system : System F} + {message : Message F} (derivation : Derivation system rom message) + (dynamic : ¬ system.MapClaim message) : derivation.rows ≠ [] := by + cases derivation with + | node => simp [Derivation.rows] + | table member => exact (dynamic member).elim + +/-- If every valid rule requires a call, no finite closed derivation can start. -/ +theorem not_derives_of_no_leaves [Field F] [DecidableEq F] {system : System F} + (noTables : system.mapClaims = []) + (requiresCall : ∀ chip row, system.findChip? row.chip = some chip → + chip.ValidRow rom row → chip.premises row ≠ []) (message : Message F) : + ¬ Derives system rom message := by + rintro ⟨derivation⟩ + induction derivation using Derivation.rec + (motive_2 := fun messages _ => messages ≠ [] → False) with + | node chip row lookup valid _ childrenIH => + exact childrenIH (requiresCall chip row lookup valid) + | table member => simp [System.MapClaim, noTables] at member + | nil => exact absurd rfl ‹([] : List (Message F)) ≠ []› + | cons _ _ headIH _ => exact headIH + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/EncodingWitness.lean b/Aiur/Aiur/Circuit/EncodingWitness.lean new file mode 100644 index 000000000..4a4c9b1a1 --- /dev/null +++ b/Aiur/Aiur/Circuit/EncodingWitness.lean @@ -0,0 +1,106 @@ +import Aiur.Circuit.InactiveWitness +import Aiur.Circuit.ExpressionCorrectness + +namespace Aiur + +theorem WireValue.decode_injective [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) {left right : WireValue F} {value : Value F} + (first : left.decode decls = some value) (second : right.decode decls = some value) : left = right := by + have a := WireValue.encode_decode first (fun _ => Declarations.layout_namesUnique checked) + have b := WireValue.encode_decode second (fun _ => Declarations.layout_namesUnique checked) + exact Option.some.inj (a.symm.trans b) + +theorem WireValue.decode_sized [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) {wire : WireValue F} {value : Value F} + (decoded : wire.decode decls = some value) : wire.Sized decls := + Value.encode_sized (WireValue.encode_decode decoded (fun _ => Declarations.layout_namesUnique checked)) + +theorem DecodesValues.wires_unique [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) {left right : List (WireValue F)} {values : List (Value F)} + (first : DecodesValues decls left values) (second : DecodesValues decls right values) : left = right := by + induction first generalizing right with + | nil => cases second; rfl + | cons head tail ih => + cases second with + | cons head' tail' => simp [WireValue.decode_injective checked head head', ih tail'] + +theorem DecodesEnvironment.types [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + {wires : List (String × WireValue F)} {values : Environment F} + (decoded : DecodesEnvironment decls wires values) : + environmentTypes values = wires.map (fun binding => (binding.1, binding.2.type)) := by + induction decoded with + | nil => rfl + | cons head tail ih => simp [environmentTypes, head.1, (WireValue.decode_spec head.2).1] at ih ⊢; exact ih + +theorem DecodesValues.each [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + {wires : List (WireValue F)} {values : List (Value F)} (decoded : DecodesValues decls wires values) : + ∀ wire ∈ wires, ∃ value, wire.decode decls = some value := by + induction decoded with + | nil => simp + | cons head tail ih => simpa using And.intro ⟨_, head⟩ ih + +namespace Circuit.Compiler + +variable {F : Type} {rom : WireROM F} + +/-- Allocate an opaque result with a canonical encoding of the evaluated value. -/ +theorem freshValue_decoded_complete [Field F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) (tags : decls.tagsValid F = true) + {type : Ty} {vars : WireValue Var} {before after : BuildState F} + (compiled : freshValue decls type before = .ok (vars, after)) + {calls : Circuit.CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls initial) + (value : Value F) (shape : value.type = type) (formed : value.wellFormed decls = true) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + Bounded (F := F) after.nextVar (vars.map ArithExpr.var) ∧ + (vars.map assignment).decode decls = some value := by + obtain ⟨typeLayout, expanded, _⟩ := freshValue_eq compiled + obtain ⟨words, encoded⟩ := (Declarations.layout_describes expanded).encode_total shape formed + let desired : WireValue F := ⟨type, words⟩ + obtain ⟨assignment, ext, bound, assigned⟩ := freshValue_complete compiled layout valid desired rfl + ⟨typeLayout, expanded, Layout.encode_length encoded⟩ + refine ⟨assignment, ext, bound, ?_⟩ + rw [assigned] + exact WireValue.decode_of_layout checked expanded + (Layout.decode_encode (Declarations.layout_tagSafe tags expanded) encoded) + +theorem Extension.environment [Field F] [DecidableEq F] {decls : Declarations} + {calls : Circuit.CallRelation F} {before after : BuildState F} {a b : Var → F} + (extension : Extension rom calls before after a b) {locals : Locals F} {environment : Environment F} + (bounded : LocalsBounded before.nextVar locals) + (decoded : DecodesEnvironment decls (localsEnvironment locals a) environment) : + DecodesEnvironment decls (localsEnvironment locals b) environment := by + rwa [extension.locals bounded] + +theorem Extension.decoded_value [Field F] [DecidableEq F] {decls : Declarations} + {calls : Circuit.CallRelation F} {before after : BuildState F} {a b : Var → F} + (extension : Extension rom calls before after a b) {wire : Symbolic F} {value : Value F} + (bounded : Bounded before.nextVar wire) + (decoded : (wire.map (ArithExpr.denote a)).decode decls = some value) : + (wire.map (ArithExpr.denote b)).decode decls = some value := by + rwa [extension.value bounded] + +theorem Extension.decoded_values [Field F] [DecidableEq F] {decls : Declarations} + {calls : Circuit.CallRelation F} {before after : BuildState F} {a b : Var → F} + (extension : Extension rom calls before after a b) {wires : List (Symbolic F)} {values : List (Value F)} + (bounded : ∀ wire ∈ wires, Bounded before.nextVar wire) + (decoded : DecodesValues decls (wires.map (WireValue.map (ArithExpr.denote a))) values) : + DecodesValues decls (wires.map (WireValue.map (ArithExpr.denote b))) values := by + rwa [extension.values bounded] + +theorem constrainValue_decoded_complete [Field F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) {calls : Circuit.CallRelation F} + {enable : ArithExpr F} {left right : Symbolic F} {before after : BuildState F} + (compiled : constrainValue enable left right before = .ok ((), after)) {assignment : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls assignment) + (enableBound : enable.inBounds before.nextVar = true) + (leftBound : Bounded before.nextVar left) (rightBound : Bounded before.nextVar right) + {value : Value F} + (leftDecode : (left.map (ArithExpr.denote assignment)).decode decls = some value) + (rightDecode : (right.map (ArithExpr.denote assignment)).decode decls = some value) : + Extension rom calls before after assignment assignment := + constrainValue_complete compiled layout valid enableBound leftBound rightBound + (Or.inr (WireValue.decode_injective checked leftDecode rightDecode)) + +end Circuit.Compiler +end Aiur diff --git a/Aiur/Aiur/Circuit/Entry.lean b/Aiur/Aiur/Circuit/Entry.lean new file mode 100644 index 000000000..3df741001 --- /dev/null +++ b/Aiur/Aiur/Circuit/Entry.lean @@ -0,0 +1,31 @@ +import Aiur.Circuit.MemoDerivation + +namespace Aiur.Circuit + +/-- An admissible root encodes actual values. This does not assert its truth. -/ +def Message.WellFormed [Field F] [DecidableEq F] (decls : Declarations) + (message : Message F) : Prop := + (∀ argument ∈ message.args, ∃ value, argument.decode decls = some value) ∧ + ∃ value, message.result.decode decls = some value + +/-- The entire type of every public argument is pointer-free, across all constructors. -/ +def Message.PublicArguments (decls : Declarations) + (message : Message F) : Prop := + ∀ argument ∈ message.args, argument.type.pointerFree decls = true + +/-- Public acceptance uses a well-formed root and one prover-chosen functional table. -/ +def EntryDerives [Field F] [DecidableEq F] (system : System F) (message : Message F) : Prop := + message.WellFormed system.enums ∧ message.PublicArguments system.enums ∧ + ∃ rom : WireROM F, rom.Valid ∧ Derives system rom message + +/-- Public memoized acceptance permits shared and cyclic call references. -/ +def MemoEntryDerives [Field F] [DecidableEq F] (system : System F) (message : Message F) : Prop := + message.WellFormed system.enums ∧ message.PublicArguments system.enums ∧ + ∃ rom : WireROM F, rom.Valid ∧ MemoDerives system rom message + +theorem EntryDerives.memo [Field F] [DecidableEq F] {system : System F} {message : Message F} + (accepted : EntryDerives system message) : MemoEntryDerives system message := by + obtain ⟨formed, free, rom, valid, tree⟩ := accepted + exact ⟨formed, free, rom, valid, tree.memo⟩ + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/Erasure.lean b/Aiur/Aiur/Circuit/Erasure.lean new file mode 100644 index 000000000..ecc84d7b3 --- /dev/null +++ b/Aiur/Aiur/Circuit/Erasure.lean @@ -0,0 +1,319 @@ +import Aiur.Optimized.DedupCertificate +import Aiur.Memory.Partition + +/-! +The physical calling convention contains words, not nominal types or argument +grouping. Type erasure is a separate certified pass: the typed compiler and its +provenance invariant remain available when a physical derivation is lifted. +All equations, hint validation, guards, and memory widths are preserved. +-/ + +namespace Aiur.Circuit.Erasure + +def pack (words : List α) : WireValue α := + ⟨.tuple (List.replicate words.length .field), words⟩ + +@[simp] theorem pack_words (words : List α) : (pack words).words = words := rfl + +@[simp] theorem pack_map (f : α → β) (words : List α) : + (pack words).map f = pack (words.map f) := by + simp [pack, WireValue.map] + +def shape (wire : WireValue α) : Ty × Nat := (wire.type, wire.words.length) + +@[simp] theorem shape_map (f : α → β) (wire : WireValue α) : + shape (wire.map f) = shape wire := by simp [shape, WireValue.map] + +def readWords : List (Ty × Nat) → List α → List (WireValue α) + | [], _ => [] + | (type, width) :: rest, words => + ⟨type, words.take width⟩ :: readWords rest (words.drop width) + +theorem readWords_flatten (values : List (WireValue α)) : + readWords (values.map shape) (values.flatMap WireValue.words) = values := by + induction values with + | nil => rfl + | cons value rest ih => + simp only [List.map_cons, List.flatMap_cons, shape, readWords, + List.take_left, List.drop_left, ih] + +def messageShape (message : Message F) : List (Ty × Nat) × (Ty × Nat) := + (message.args.map shape, shape message.result) + +def flatten (message : Message F) : Message F := + ⟨message.channel, [pack (message.args.flatMap WireValue.words)], pack message.result.words⟩ + +theorem flatten_injective {a b : Message F} + (shapes : messageShape a = messageShape b) (same : flatten a = flatten b) : a = b := by + have names := congrArg Message.channel same + have args := congrArg (fun m => m.args.flatMap WireValue.words) same + have result := congrArg (fun m => m.result.words) same + have argShapes := congrArg Prod.fst shapes + have resultTypes := congrArg (fun s => s.2.1) shapes + have sameArgs : a.args = b.args := by + rw [← readWords_flatten a.args, ← readWords_flatten b.args] + change a.args.map shape = b.args.map shape at argShapes + simp only [flatten, List.flatMap_cons, List.flatMap_nil, pack_words, List.append_nil] at args + rw [argShapes, args] + cases a; cases b + simp only [flatten, pack, messageShape, shape] at * + cases names; cases sameArgs + congr 1 + cases ‹WireValue F›; cases ‹WireValue F› + simp_all only + +def dynamic (system : System F) (name : String) : Bool := (system.findChip? name).isSome + +def message (system : System F) (claim : Message F) : Message F := + if dynamic system claim.channel then flatten claim else claim + +def send (system : System F) (call : Send F) : Send F := + if dynamic system call.channel then + { call with args := [pack (call.args.flatMap WireValue.words)], result := pack call.result.words } + else call + +def memory (lookup : MemoryLookup F) : MemoryLookup F := + { lookup with value := pack lookup.value.words } + +def chip (system : System F) (original : Chip F) : Chip F := + { original with + inputs := [pack (original.inputs.flatMap WireValue.words)] + output := pack original.output.words + sends := original.sends.map (send system) + memory := original.memory.map memory } + +def system (original : System F) : System F := + { original with chips := original.chips.map (chip original) } + +def signature (chip : Chip F) : List (Ty × Nat) × (Ty × Nat) := + (chip.inputs.map shape, shape chip.output) + +/-- Calls keep the source signature in the proof, even after their physical +message has been flattened. This is a finite syntactic check, not a row check. -/ +def Compatible (source : System F) : Prop := + (∀ c ∈ source.chips, ∀ call ∈ c.sends, ∀ target, + source.findChip? call.channel = some target → + (call.args.map shape, shape call.result) = signature target) ∧ + (∀ c ∈ source.chips, ∀ lookup ∈ c.memory, + (source.enums.layout lookup.value.type).toOption.map Layout.width = some lookup.value.words.length) + +instance (source : System F) : Decidable (Compatible source) := by + unfold Compatible + letI (call : Send F) : Decidable (∀ target, source.findChip? call.channel = some target → + (call.args.map shape, shape call.result) = signature target) := by + cases found : source.findChip? call.channel with + | none => exact isTrue (by simp) + | some target => + exact decidable_of_iff ((call.args.map shape, shape call.result) = signature target) (by simp) + infer_instance + +def memoryTypes (source : System F) : List Ty := + source.chips.flatMap fun c => c.memory.map (·.value.type) + +def typedROM (source : System F) (rom : WidthROM F) : WireROM F := + rom.toWireROM source.enums (memoryTypes source) + +def rawROM (rom : WidthROM F) : WireROM F := + ⟨rom.entries.map fun (address, words) => (address, pack words)⟩ + +@[simp] theorem mem_rawROM {rom : WidthROM F} {address : F} {words : List F} : + (address, pack words) ∈ (rawROM rom).entries ↔ (address, words) ∈ rom.entries := by + simp only [rawROM, List.mem_map, Prod.exists, Prod.mk.injEq] + constructor + · rintro ⟨a, ws, member, rfl, equal⟩ + have same := congrArg WireValue.words equal + change ws = words at same + simpa only [same] using member + · intro member; exact ⟨address, words, member, rfl, rfl⟩ + +theorem rawROM_valid {rom : WidthROM F} (valid : rom.Valid) : (rawROM rom).Valid := by + rintro a ha b hb address types + obtain ⟨⟨x, xs⟩, hx, rfl⟩ := List.mem_map.mp ha + obtain ⟨⟨y, ys⟩, hy, rfl⟩ := List.mem_map.mp hb + have lengths : xs.length = ys.length := by + simp only [pack, Ty.tuple.injEq] at types + simpa using congrArg List.length types + have words := valid _ hx _ hy address lengths + exact congrArg pack words + +variable [Field F] [DecidableEq F] + +omit [DecidableEq F] in +theorem send_message (source : System F) (call : Send F) (assignment : Var → F) : + (send source call).message assignment = message source (call.message assignment) := by + simp only [send, message, Send.message] + split <;> simp_all [flatten, pack, WireValue.map, List.flatMap_map, List.map_flatMap] + +omit [DecidableEq F] in +theorem chip_receive (source : System F) (original : Chip F) (row : Row F) : + (chip source original).receive row = flatten (original.receive row) := by + simp [chip, Chip.receive, flatten, pack, WireValue.map, List.flatMap_map, + List.map_flatMap] + +theorem chip_premises (source : System F) (original : Chip F) (row : Row F) : + (chip source original).premises row = (original.premises row).map (message source) := by + simp only [chip, Chip.premises, List.filterMap_map, List.map_filterMap, Function.comp_def] + congr 1 + funext call + have enabled : (send source call).enable = call.enable := by unfold send; split <;> rfl + rw [enabled] + split <;> simp [send_message] + +omit [Field F] [DecidableEq F] in +@[simp] theorem chip_wellFormed (source : System F) (original : Chip F) : + (chip source original).wellFormed = original.wellFormed := by + have calls (call : Send F) : (send source call).inBounds original.numVars = call.inBounds original.numVars := by + unfold send + split <;> simp [Send.inBounds, pack] + simp only [chip, Chip.wellFormed, pack, MemoryLookup.inBounds, memory, List.all_map, + Function.comp_def, calls] + simp only [List.flatMap_cons, List.flatMap_nil, List.append_nil, List.all_flatMap] + rfl + +omit [DecidableEq F] in +theorem chip_validRow (source : System F) (compatible : Compatible source) + {original : Chip F} (member : original ∈ source.chips) (rom : WidthROM F) (row : Row F) : + (chip source original).ValidRow (rawROM rom) row ↔ original.ValidRow (typedROM source rom) row := by + simp only [Chip.ValidRow, chip_wellFormed] + change (_ ∧ _ ∧ _ ∧ ∀ lookup ∈ original.memory.map memory, + lookup.Valid (rawROM rom) row.assignment) ↔ _ + simp only [List.mem_map, forall_exists_index, and_imp, + forall_apply_eq_imp_iff₂] + apply and_congr_right'; apply and_congr_right'; apply and_congr_right' + apply forall_congr' + intro lookup + apply forall_congr' + intro lookupMember + have sized := compatible.2 original member lookup lookupMember + have typeMember : lookup.value.type ∈ memoryTypes source := + List.mem_flatMap.mpr ⟨original, member, List.mem_map.mpr ⟨lookup, lookupMember, rfl⟩⟩ + simp only [MemoryLookup.Valid, memory] + rw [pack_map, mem_rawROM] + simp only [typedROM, WidthROM.mem_toWireROM, WireValue.map, List.length_map] + simp only [typeMember, sized, and_true] + +omit [Field F] [DecidableEq F] in +@[simp] theorem system_findChip (source : System F) (name : String) : + (system source).findChip? name = (source.findChip? name).map (chip source) := by + simp [system, System.findChip?, List.find?_map, chip, Function.comp_def] + +omit [DecidableEq F] in +@[simp] theorem system_mapClaims (source : System F) : (system source).mapClaims = source.mapClaims := rfl + +omit [DecidableEq F] in +theorem receive_shape (original : Chip F) (row : Row F) : + messageShape (original.receive row) = signature original := by + simp [messageShape, Chip.receive, signature, List.map_map, Function.comp_def] + +omit [DecidableEq F] in +theorem send_shape (source : System F) (compatible : Compatible source) + {original : Chip F} (member : original ∈ source.chips) {call : Send F} (present : call ∈ original.sends) + {target : Chip F} (found : source.findChip? call.channel = some target) (assignment : Var → F) : + messageShape (call.message assignment) = signature target := by + simpa [messageShape, Send.message, List.map_map, Function.comp_def] using + compatible.1 original member call present target found + +def Signed (source : System F) (claim : Message F) : Prop := + ∀ target, source.findChip? claim.channel = some target → messageShape claim = signature target + +theorem premise_signed (source : System F) (compatible : Compatible source) + {original : Chip F} (member : original ∈ source.chips) (row : Row F) + {claim : Message F} (required : claim ∈ original.premises row) : Signed source claim := by + obtain ⟨call, present, equal⟩ := List.mem_filterMap.mp required + unfold Chip.premises at required + split at equal + · cases equal + exact fun target found => send_shape source compatible member present found row.assignment + · cases equal + +omit [Field F] [DecidableEq F] in +@[simp] theorem message_channel (source : System F) (claim : Message F) : + (message source claim).channel = claim.channel := by + unfold message; split <;> rfl + +theorem derives_forward (source : System F) (compatible : Compatible source) + (separated : ∀ claim, source.MapClaim claim → source.findChip? claim.channel = none) + {rom : WidthROM F} {root : Message F} + (derived : Derives source (typedROM source rom) root) : + Derives (system source) (rawROM rom) (message source root) := by + obtain ⟨tree⟩ := derived + induction tree using Derivation.rec + (motive_2 := fun messages _ => ∀ m ∈ messages, Derives (system source) (rawROM rom) (message source m)) with + | node original row found valid children ih => + have named := System.findChip_name found + have dynamicName : dynamic source original.name = true := by simp [dynamic, named, found] + have conclusion : message source (original.receive row) = (chip source original).receive row := by + rw [chip_receive]; simp [message, Chip.receive, dynamicName] + rw [conclusion] + apply (RuleInstance.node (chip source original) row (by simp [found]) + ((chip_validRow source compatible (List.mem_of_find?_eq_some found) rom row).mpr valid)).derives + intro claim required + rw [RuleInstance.premises, chip_premises] at required + obtain ⟨old, member, rfl⟩ := List.mem_map.mp required + exact ih old member + | table member => + rename_i claim + have unchanged : message source claim = claim := by simp [message, dynamic, separated _ member] + rw [unchanged] + exact ⟨.table member⟩ + | nil => simp_all + | cons _ _ head tail => + rename_i claim member + rcases List.mem_cons.mp member with rfl | member + · exact head + · exact tail claim member + +/-- A physical proof can be interpreted separately at every original call +signature. Sharing a row never requires a runtime type discriminator. -/ +theorem derives_backward (source : System F) (compatible : Compatible source) + (separated : ∀ claim, source.MapClaim claim → source.findChip? claim.channel = none) + {rom : WidthROM F} {root : Message F} (signed : Signed source root) + (derived : Derives (system source) (rawROM rom) (message source root)) : + Derives source (typedROM source rom) root := by + obtain ⟨tree⟩ := derived + have lift {m : Message F} (tree : Derivation (system source) (rawROM rom) m) : + ∀ claim, Signed source claim → message source claim = m → Derives source (typedROM source rom) claim := by + refine Derivation.rec + (motive_1 := fun m _ => ∀ claim, Signed source claim → message source claim = m → + Derives source (typedROM source rom) claim) + (motive_2 := fun messages _ => ∀ m ∈ messages, ∀ claim, Signed source claim → message source claim = m → + Derives source (typedROM source rom) claim) ?_ ?_ ?_ ?_ tree + · intro next row found valid children ih claim signed same + rw [system_findChip] at found + obtain ⟨original, originalFound, rfl⟩ := Option.map_eq_some_iff.mp found + have names : claim.channel = original.name := by + simpa [Chip.receive, chip] using congrArg Message.channel same + have foundClaim : source.findChip? claim.channel = some original := by + rw [names, System.findChip_name originalFound]; exact originalFound + have sameFlat : flatten claim = flatten (original.receive row) := by + simpa only [message, dynamic, foundClaim, Option.isSome_some, ↓reduceIte, chip_receive] using same + have equal : claim = original.receive row := + flatten_injective ((signed original foundClaim).trans (receive_shape original row).symm) sameFlat + rw [equal] + apply (RuleInstance.node original row originalFound + ((chip_validRow source compatible (List.mem_of_find?_eq_some originalFound) rom row).mp valid)).derives + intro required member + apply ih (message source required) ?_ required + (premise_signed source compatible (List.mem_of_find?_eq_some originalFound) row member) rfl + rw [chip_premises] + exact List.mem_map.mpr ⟨required, member, rfl⟩ + · intro m member claim _ same + have names : claim.channel = m.channel := by simpa using congrArg Message.channel same + have fixed : message source claim = claim := by + simp [message, dynamic, names, separated m member] + rw [fixed] at same + exact ⟨same.symm ▸ .table member⟩ + · simp + · intro head tail headTree tailTrees headIH tailIH m member claim signed same + rcases List.mem_cons.mp member with rfl | member + · exact headIH claim signed same + · exact tailIH m member claim signed same + exact lift tree root signed rfl + +theorem derives_iff (source : System F) (compatible : Compatible source) + (separated : ∀ claim, source.MapClaim claim → source.findChip? claim.channel = none) + {rom : WidthROM F} {root : Message F} (signed : Signed source root) : + Derives source (typedROM source rom) root ↔ Derives (system source) (rawROM rom) (message source root) := + ⟨derives_forward source compatible separated, derives_backward source compatible separated signed⟩ + +end Aiur.Circuit.Erasure diff --git a/Aiur/Aiur/Circuit/ExpressionCorrectness.lean b/Aiur/Aiur/Circuit/ExpressionCorrectness.lean new file mode 100644 index 000000000..560acdb2f --- /dev/null +++ b/Aiur/Aiur/Circuit/ExpressionCorrectness.lean @@ -0,0 +1,485 @@ +import Aiur.Circuit.PatternCorrectness +import Aiur.Circuit.ValueCorrectness +import Aiur.Circuit.ValidationCorrectness +import Aiur.WireComposition +import Aiur.WireMemory +import Aiur.InputTypes + +namespace Aiur.Circuit.Compiler + +variable {F : Type} {rom : WireROM F} + +set_option maxHeartbeats 2000000 +set_option maxRecDepth 4096 + +/-- Interpreting decoded call premises suffices for local compiler soundness. -/ +def CallsSound [Field F] [DecidableEq F] (decls : Declarations) + (calls : Circuit.CallRelation F) (sourceCalls : Aiur.CallRelation F) : Prop := + ∀ name args result, calls name args result → ∀ values value, + DecodesValues decls args values → result.decode decls = some value → sourceCalls name values value + +/-- The output's canonical encoding and its evaluation are proved together. -/ +def ExpressionMeaning [Field F] [DecidableEq F] (decls : Declarations) + (rom : WireROM F) (calls : Aiur.CallRelation F) (locals : Environment F) + (expr : Expr F) (output : WireValue F) : Prop := + ∃ value, output.decode decls = some value ∧ ROMEvalExprWith decls (rom.decode decls) calls locals expr value + +mutual + theorem lowerExpr_sound [Field F] [DecidableEq F] + {program : Program F} (checked : checkDeclarations program.enums = .ok ()) + (tags : program.enums.tagsValid F = true) + {calls : Circuit.CallRelation F} {sourceCalls : Aiur.CallRelation F} + (callSound : CallsSound program.enums calls sourceCalls) + {function : String} {locals : Locals F} {enable : ArithExpr F} {expr : Expr F} {output : Symbolic F} + {before after : BuildState F} + (compiled : lowerExpr program function locals enable expr before = .ok (output, after)) + {assignment : Var → F} (valid : after.Valid rom calls assignment) : + before.Valid rom calls assignment ∧ (enable.denote assignment = 1 → ∀ environment, + DecodesEnvironment program.enums (localsEnvironment locals assignment) environment → + ExpressionMeaning program.enums rom sourceCalls environment expr + (output.map (ArithExpr.denote assignment))) := by + cases expr with + | literal value => + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [lowerExpr] using compiled) + exact ⟨valid, fun _ _ _ => ⟨.field value, by simp [Scalar.Circuit.ArithExpr.denote], .literal⟩⟩ + | var name => + cases found : locals.find? (·.1 == name) with + | none => simp [lowerExpr, found] at compiled + | some binding => + rcases binding with ⟨bindingName, wire⟩ + have same : bindingName = name := by simpa using List.find?_some found + subst bindingName + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [lowerExpr, found] using compiled) + refine ⟨valid, fun _ environment decoded => ?_⟩ + obtain ⟨value, lookup, valueDecode⟩ := decoded.find name (wire := (name, wire.map (ArithExpr.denote assignment))) + (by simp [localsEnvironment, List.find?_map, Function.comp_def, found]) + exact ⟨value, valueDecode, .var lookup⟩ + | tuple items => + simp only [lowerExpr] at compiled + obtain ⟨wires, middle, argsRun, finished⟩ := bind_ok.mp compiled + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨previous, evaluated⟩ := lowerArgs_sound checked tags callSound argsRun valid + refine ⟨previous, fun active environment decoded => ?_⟩ + obtain ⟨values, decodedValues, evaluations⟩ := evaluated active environment decoded + exact ⟨.tuple values, by + simpa only [WireValue.map_tuple] using WireValue.decode_tuple checked tags decodedValues, + .tuple evaluations⟩ + | construct name ctor args => + cases found : program.enums.findEnum? name with + | none => simp [lowerExpr, found] at compiled + | some definition => + cases atIndex : definition.constructors[definition.constructors.findIdx (·.name == ctor)]? with + | none => simp [lowerExpr, found, atIndex] at compiled + | some constructor => + simp only [lowerExpr, found, atIndex] at compiled + obtain ⟨wires, s₁, argsRun, rest⟩ := bind_ok.mp compiled + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · rename_i types + obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨layout, middle, layoutRun, rest⟩ := bind_ok.mp rest + obtain ⟨expansion, rfl⟩ := getLayout_eq layoutRun + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · obtain ⟨⟨⟩, middle, unchanged, finished⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨previous, evaluated⟩ := lowerArgs_sound checked tags callSound argsRun valid + refine ⟨previous, fun active environment decoded => ?_⟩ + obtain ⟨values, argsDecode, argsEval⟩ := evaluated active environment decoded + have ctorName : constructor.name = ctor := by + simpa using List.findIdx_of_getElem?_eq_some atIndex + refine ⟨.construct name ctor values, ?_, .construct argsEval⟩ + have constructed := WireValue.decode_construct checked tags found atIndex argsDecode + (by simpa [Function.comp_def, WireValue.map] using (not_ne_iff.mp types)) expansion + simpa [ctorName, WireValue.map, List.map_flatMap, List.flatMap_map, + List.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using constructed + | project operand index => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, inputRun, rest⟩ := bind_ok.mp compiled + rcases input with ⟨type, words⟩ + cases type with + | field | ptr | enum => simp at rest + | tuple types => + dsimp only at rest + obtain ⟨wires, s₂, splitRun, rest⟩ := bind_ok.mp rest + have unchanged := (splitValues_spec splitRun).1 + subst s₂ + cases projected : wires[index]? with + | none => simp [projected] at rest + | some result => + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [projected] using rest) + obtain ⟨previous, evaluated⟩ := lowerExpr_sound checked tags callSound inputRun valid + refine ⟨previous, fun active environment decoded => ?_⟩ + obtain ⟨value, inputDecode, inputEval⟩ := evaluated active environment decoded + obtain ⟨values, rfl, decodedValues⟩ := splitValues_decode checked splitRun inputDecode + obtain ⟨value, valueAt, valueDecode⟩ := decodedValues.getElem (index := index) + (wire := result.map (ArithExpr.denote assignment)) + (by simp [List.getElem?_map, projected]) + exact ⟨value, valueDecode, .project inputEval (by simp [projectValue, valueAt, pure, Except.pure])⟩ + | letValue pattern operand body => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, inputRun, rest⟩ := bind_ok.mp compiled + obtain ⟨⟨test, bindings⟩, s₂, patternRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₃, guardRun, bodyRun⟩ := bind_ok.mp rest + obtain ⟨s₃valid, bodyEval⟩ := lowerExpr_sound checked tags callSound bodyRun valid + obtain ⟨s₂valid, equation⟩ := constrain_valid guardRun s₃valid + obtain ⟨s₁valid, _, matched⟩ := lowerPattern_sound checked tags patternRun s₂valid + obtain ⟨previous, inputEval⟩ := lowerExpr_sound checked tags callSound inputRun s₁valid + refine ⟨previous, fun active environment decoded => ?_⟩ + obtain ⟨inputValue, inputDecode, inputEval⟩ := inputEval active environment decoded + have testOne : test.denote assignment = 1 := by + change enable.denote assignment * (test.denote assignment - 1) = 0 at equation + simpa [active, sub_eq_zero] using equation + rcases matched inputValue inputDecode with ⟨values, matched, _, decodedBindings⟩ | ⟨_, zero⟩ + · obtain ⟨value, resultDecode, evaluated⟩ := bodyEval active (values ++ environment) + (by simpa only [localsEnvironment_append] using decodedBindings.append decoded) + exact ⟨value, resultDecode, .letValue inputEval matched evaluated⟩ + · exact (zero_ne_one (zero.symm.trans testOne)).elim + | store operand => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, inputRun, rest⟩ := bind_ok.mp compiled + obtain ⟨address, s₂, addressRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₃, booleanRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₄, validationRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₅, cellRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨s₄valid, cell⟩ := requireCell_valid cellRun valid + have s₃valid := (validateValue_sound checked validationRun s₄valid).1 + have s₂valid := (boolean_valid booleanRun s₃valid).1 + have s₁valid := fresh_valid addressRun s₂valid + obtain ⟨previous, evaluated⟩ := lowerExpr_sound checked tags callSound inputRun s₁valid + refine ⟨previous, fun active environment decoded => ?_⟩ + obtain ⟨value, valueDecode, valueEval⟩ := evaluated active environment decoded + obtain ⟨type, _, layout, expansion, _⟩ := WireValue.decode_spec valueDecode + have names := (Declarations.layout_parts expansion).1 + refine ⟨.ptr value.type (assignment address), ?_, .store valueEval ?_⟩ + · simpa only [WireValue.map_ptr, Scalar.Circuit.ArithExpr.denote, type, WireValue.map, WireValue.ptr, List.map_cons, List.map_nil] using + WireValue.decode_ptr names (assignment address) + · exact WireROM.mem_decode.mpr ⟨_, cell active, valueDecode⟩ + | load operand => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, inputRun, rest⟩ := bind_ok.mp compiled + rcases input with ⟨type, words⟩ + cases type with + | field | tuple | enum => simp at rest + | ptr target => + cases words with + | nil => simp at rest + | cons address words => cases words with + | cons => simp at rest + | nil => + dsimp only at rest + obtain ⟨result, s₂, resultRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₃, booleanRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₄, validationRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₅, cellRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨s₄valid, cell⟩ := requireCell_valid cellRun valid + obtain ⟨s₃valid, resultDecoded⟩ := validateValue_sound checked validationRun s₄valid + have s₂valid := (boolean_valid booleanRun s₃valid).1 + have s₁valid := freshValue_valid resultRun s₂valid + obtain ⟨previous, evaluated⟩ := lowerExpr_sound checked tags callSound inputRun s₁valid + refine ⟨previous, fun active environment decoded => ?_⟩ + obtain ⟨value, valueDecode, valueEval⟩ := evaluated active environment decoded + have same := WireValue.ptr_decoded_eq valueDecode + subst value + obtain ⟨value, resultDecode⟩ := resultDecoded active + refine ⟨value, resultDecode, .load valueEval (WireROM.mem_decode.mpr ⟨_, cell active, resultDecode⟩) ?_⟩ + exact (WireValue.decode_spec resultDecode).1.trans (freshValue_spec resultRun).2.2.1 + | hint type key channel => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, keyRun, rest⟩ := bind_ok.mp compiled + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · rename_i free + have free : type.pointerFree program.enums = true := by simpa using free + obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨result, s₂, freshRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₃, validationRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨s₂valid, resultDecoded⟩ := validateValue_sound checked validationRun valid + have s₁valid := freshValue_valid freshRun s₂valid + obtain ⟨previous, keyMeaning⟩ := lowerExpr_sound checked tags callSound keyRun s₁valid + refine ⟨previous, fun active environment decoded => ?_⟩ + obtain ⟨keyValue, _, keyEval⟩ := keyMeaning active environment decoded + obtain ⟨value, resultDecode⟩ := resultDecoded active + have spec := WireValue.decode_spec resultDecode + have shape : value.type = type := spec.1.trans (freshValue_spec freshRun).2.2.1 + have valueFree := Value.pointerFree_of_type (shape ▸ free) spec.2.1 + obtain ⟨constant, same⟩ := value.exists_constant valueFree + subst value + exact ⟨_, resultDecode, .hint keyEval (by + simpa [Value.WellTyped, Value.hasType] using And.intro shape spec.2.1)⟩ + | neg operand => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, inputRun, rest⟩ := bind_ok.mp compiled + obtain ⟨polynomial, s₂, fieldRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_ok fieldRun + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨previous, evaluated⟩ := lowerExpr_sound checked tags callSound inputRun valid + refine ⟨previous, fun active environment decoded => ?_⟩ + obtain ⟨value, valueDecode, valueEval⟩ := evaluated active environment decoded + simp only [WireValue.map_field, WireValue.decode_field, Option.some.injEq] at valueDecode + subst value + exact ⟨.field (0 - polynomial.denote assignment), by simp [Scalar.Circuit.ArithExpr.denote], + .neg valueEval (by simp [evalNeg])⟩ + | assertEq message left right => + simp only [lowerExpr] at compiled + obtain ⟨leftWire, s₁, leftRun, rest⟩ := bind_ok.mp compiled + obtain ⟨rightWire, s₂, rightRun, rest⟩ := bind_ok.mp rest + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · rename_i free + obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨⟨⟩, last, equated, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨valid₂, equal⟩ := constrainValue_sound equated valid + obtain ⟨valid₁, rightEval⟩ := lowerExpr_sound checked tags callSound rightRun valid₂ + obtain ⟨previous, leftEval⟩ := lowerExpr_sound checked tags callSound leftRun valid₁ + refine ⟨previous, fun active environment decoded => ?_⟩ + obtain ⟨x, xDecode, xEval⟩ := leftEval active environment decoded + obtain ⟨y, yDecode, yEval⟩ := rightEval active environment decoded + have same : x = y := Option.some.inj (xDecode.symm.trans ((equal active) ▸ yDecode)) + have data := WireValue.decode_spec xDecode + have pointerFree : x.pointerFree = true := Value.pointerFree_of_type + (by simpa [data.1, WireValue.type_map] using free) data.2.1 + exact ⟨.tuple [], by simpa only [WireValue.map_tuple, List.map_nil] using + WireValue.decode_tuple checked tags (.nil : DecodesValues program.enums [] []), + .assertEq xEval yEval (evalAssertEq_ok.mpr ⟨pointerFree, same, rfl⟩)⟩ + | binary op left right => + simp only [lowerExpr] at compiled + obtain ⟨leftWire, s₁, leftRun, rest⟩ := bind_ok.mp compiled + obtain ⟨leftPoly, s₂, leftField, rest⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_ok leftField + obtain ⟨rightWire, s₃, rightRun, rest⟩ := bind_ok.mp rest + obtain ⟨rightPoly, s₄, rightField, rest⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_ok rightField + cases op with + | add | sub | mul => + obtain ⟨rfl, rfl⟩ := pure_ok.mp rest + obtain ⟨s₁valid, rightEval⟩ := lowerExpr_sound checked tags callSound rightRun valid + obtain ⟨previous, leftEval⟩ := lowerExpr_sound checked tags callSound leftRun s₁valid + refine ⟨previous, fun active environment decoded => ?_⟩ + obtain ⟨x, xDecode, xEval⟩ := leftEval active environment decoded + obtain ⟨y, yDecode, yEval⟩ := rightEval active environment decoded + simp only [WireValue.map_field, WireValue.decode_field, Option.some.injEq] at xDecode yDecode + subst x; subst y + exact ⟨_, WireValue.decode_field _ _, .binary xEval yEval (by + simp [evalBinOp, Scalar.Circuit.ArithExpr.denote])⟩ + | div => + obtain ⟨inverse, s₅, inverseRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₆, equationRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨s₅valid, equation⟩ := constrain_valid equationRun valid + have s₃valid := fresh_valid inverseRun s₅valid + obtain ⟨s₁valid, rightEval⟩ := lowerExpr_sound checked tags callSound rightRun s₃valid + obtain ⟨previous, leftEval⟩ := lowerExpr_sound checked tags callSound leftRun s₁valid + refine ⟨previous, fun active environment decoded => ?_⟩ + obtain ⟨x, xDecode, xEval⟩ := leftEval active environment decoded + obtain ⟨y, yDecode, yEval⟩ := rightEval active environment decoded + simp only [WireValue.map_field, WireValue.decode_field, Option.some.injEq] at xDecode yDecode + subst x; subst y + change enable.denote assignment * (rightPoly.denote assignment * assignment inverse - 1) = 0 at equation + rw [active, one_mul] at equation + exact ⟨_, WireValue.decode_field _ _, .binary xEval yEval (by + simp [evalBinOp, Scalar.Circuit.ArithExpr.denote, Scalar.Circuit.inverse_nonzero equation, Scalar.Circuit.inverse_eq equation, + div_eq_mul_inv])⟩ + | call name args => + cases found : program.findSignature? name with + | none => simp [lowerExpr, found] at compiled + | some callee => + simp only [lowerExpr, found] at compiled + obtain ⟨arguments, s₁, argsRun, rest⟩ := bind_ok.mp compiled + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨result, s₂, resultRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₃, booleanRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₄, argsValidation, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₅, resultValidation, rest⟩ := bind_ok.mp rest + simp [StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at rest + obtain ⟨rfl, rfl⟩ := rest + have s₅valid : s₅.Valid rom calls assignment := valid.of_subset + (fun _ h => h) (fun _ h => by simp [h]) (fun _ h => h) + obtain ⟨s₄valid, resultDecoded⟩ := validateValue_sound checked resultValidation s₅valid + have s₃valid := (validateValues_sound checked argsValidation s₄valid).1 + have s₂valid := (boolean_valid booleanRun s₃valid).1 + have s₁valid := freshValue_valid resultRun s₂valid + obtain ⟨previous, argsEval⟩ := lowerArgs_sound checked tags callSound argsRun s₁valid + refine ⟨previous, fun active environment decoded => ?_⟩ + obtain ⟨values, argsDecode, argsEval⟩ := argsEval active environment decoded + obtain ⟨value, resultDecode⟩ := resultDecoded active + refine ⟨value, resultDecode, .call argsEval ?_⟩ + exact callSound name _ _ (valid.calls ⟨name, arguments, result, enable⟩ (by simp) active) + values value argsDecode (by simpa only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using resultDecode) + | matchValue scrutinee arms => + simp only [lowerExpr] at compiled + obtain ⟨⟨⟩, s₁, checkRun, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := lift_eq_ok checkRun + obtain ⟨type, s₂, typeRun, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := lift_eq_ok typeRun + obtain ⟨input, s₃, scrutineeRun, rest⟩ := bind_ok.mp rest + obtain ⟨result, s₄, resultRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₅, validationRun, rest⟩ := bind_ok.mp rest + obtain ⟨selectors, s₆, armsRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₇, exclusionRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₈, sumRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨s₇valid, equation⟩ := constrain_valid sumRun valid + have s₆valid := excludePairs_valid exclusionRun s₇valid + obtain ⟨s₅valid, armsEval⟩ := lowerArms_sound checked tags callSound armsRun s₆valid + have s₄valid := (validateValue_sound checked validationRun s₅valid).1 + have s₃valid := freshValue_valid resultRun s₄valid + obtain ⟨previous, inputEval⟩ := lowerExpr_sound checked tags callSound scrutineeRun s₃valid + refine ⟨previous, fun active environment decoded => ?_⟩ + obtain ⟨inputValue, inputDecode, evaluated⟩ := inputEval active environment decoded + have sum : (selectors.map (ArithExpr.denote assignment)).sum = 1 := by + simpa [Scalar.Circuit.ArithExpr.denote, Scalar.Circuit.ArithExpr.denote_foldl_add, + active, sub_eq_zero] using equation + have nonzero : ∃ selector ∈ selectors, selector.denote assignment ≠ 0 := by + by_contra absent + push Not at absent + have zero : (selectors.map (ArithExpr.denote assignment)).sum = 0 := + List.sum_eq_zero (by simpa using absent) + exact zero_ne_one (zero.symm.trans sum) + obtain ⟨selector, member, nonzero⟩ := nonzero + obtain ⟨_, bindings, body, selected, value, valueDecode, bodyEval⟩ := + armsEval environment decoded inputValue inputDecode selector member nonzero + exact ⟨value, valueDecode, .matchValue evaluated selected bodyEval⟩ + termination_by sizeOf expr + + theorem lowerArgs_sound [Field F] [DecidableEq F] + {program : Program F} (checked : checkDeclarations program.enums = .ok ()) + (tags : program.enums.tagsValid F = true) + {calls : Circuit.CallRelation F} {sourceCalls : Aiur.CallRelation F} + (callSound : CallsSound program.enums calls sourceCalls) + {function : String} {locals : Locals F} {enable : ArithExpr F} + {args : List (Expr F)} {outputs : List (Symbolic F)} {before after : BuildState F} + (compiled : lowerArgs program function locals enable args before = .ok (outputs, after)) + {assignment : Var → F} (valid : after.Valid rom calls assignment) : + before.Valid rom calls assignment ∧ (enable.denote assignment = 1 → ∀ environment, + DecodesEnvironment program.enums (localsEnvironment locals assignment) environment → ∃ values, + DecodesValues program.enums (outputs.map (WireValue.map (ArithExpr.denote assignment))) values ∧ + ROMEvalArgsWith program.enums (rom.decode program.enums) sourceCalls environment args values) := by + cases args with + | nil => + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [lowerArgs] using compiled) + exact ⟨valid, fun _ _ _ => ⟨[], .nil, .nil⟩⟩ + | cons arg args => + simp only [lowerArgs] at compiled + obtain ⟨head, middle, headRun, rest⟩ := bind_ok.mp compiled + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨middleValid, tailEval⟩ := lowerArgs_sound checked tags callSound tailRun valid + obtain ⟨previous, headEval⟩ := lowerExpr_sound checked tags callSound headRun middleValid + refine ⟨previous, fun active environment decoded => ?_⟩ + obtain ⟨head, headDecode, headEval⟩ := headEval active environment decoded + obtain ⟨tail, tailDecode, tailEval⟩ := tailEval active environment decoded + exact ⟨head :: tail, .cons headDecode tailDecode, .cons headEval tailEval⟩ + termination_by sizeOf args + + /-- A selected branch is exactly the first matching source arm, with decoded bindings. -/ + theorem lowerArms_sound [Field F] [DecidableEq F] + {program : Program F} (checked : checkDeclarations program.enums = .ok ()) + (tags : program.enums.tagsValid F = true) + {calls : Circuit.CallRelation F} {sourceCalls : Aiur.CallRelation F} + (callSound : CallsSound program.enums calls sourceCalls) + {function : String} {locals : Locals F} {scrutinee result : Symbolic F} {remaining : ArithExpr F} + {arms : List (Pattern F × Expr F)} {selectors : List (ArithExpr F)} {before after : BuildState F} + (compiled : lowerArms program function locals scrutinee result remaining arms before = .ok (selectors, after)) + {assignment : Var → F} (valid : after.Valid rom calls assignment) : + before.Valid rom calls assignment ∧ ∀ environment, + DecodesEnvironment program.enums (localsEnvironment locals assignment) environment → ∀ input, + (scrutinee.map (ArithExpr.denote assignment)).decode program.enums = some input → + ∀ selector ∈ selectors, selector.denote assignment ≠ 0 → + remaining.denote assignment ≠ 0 ∧ ∃ bindings body, + selectArm input arms = some (bindings, body) ∧ + ExpressionMeaning program.enums rom sourceCalls (bindings ++ environment) body + (result.map (ArithExpr.denote assignment)) := by + cases arms with + | nil => + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [lowerArms] using compiled) + exact ⟨valid, by simp⟩ + | cons arm arms => + rcases hArm : arm with ⟨pattern, body⟩ + simp only [hArm, lowerArms] at compiled + obtain ⟨⟨test, bindings⟩, s₁, patternRun, rest⟩ := bind_ok.mp compiled + obtain ⟨selector, s₂, selectorRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₃, booleanRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₄, equationRun, rest⟩ := bind_ok.mp rest + obtain ⟨bodyWire, s₅, bodyRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₆, valueRun, rest⟩ := bind_ok.mp rest + have headFacts (endValid : s₆.Valid rom calls assignment) : + before.Valid rom calls assignment ∧ + (∀ input, (scrutinee.map (ArithExpr.denote assignment)).decode program.enums = some input → + PatternTest program.enums (pattern.bindings input) (test.denote assignment) + (localsEnvironment bindings assignment)) ∧ + assignment selector = remaining.denote assignment * test.denote assignment ∧ + (assignment selector = 0 ∨ assignment selector = 1) ∧ + (assignment selector = 1 → ∀ environment, + DecodesEnvironment program.enums (localsEnvironment (bindings ++ locals) assignment) environment → + ExpressionMeaning program.enums rom sourceCalls environment body + (result.map (ArithExpr.denote assignment))) := by + obtain ⟨s₅valid, resultEq⟩ := constrainValue_sound valueRun endValid + obtain ⟨s₄valid, evaluated⟩ := lowerExpr_sound checked tags callSound bodyRun s₅valid + obtain ⟨s₃valid, equation⟩ := constrain_valid equationRun s₄valid + obtain ⟨s₂valid, boolean⟩ := boolean_valid booleanRun s₃valid + have s₁valid := fresh_valid selectorRun s₂valid + obtain ⟨previous, _, matched⟩ := lowerPattern_sound checked tags patternRun s₁valid + refine ⟨previous, matched, sub_eq_zero.mp equation, boolean, fun active environment decoded => ?_⟩ + rw [resultEq active] + exact evaluated active environment decoded + have headSelected (endValid : s₆.Valid rom calls assignment) (active : assignment selector ≠ 0) + (environment : Environment F) + (decoded : DecodesEnvironment program.enums (localsEnvironment locals assignment) environment) + (input : Value F) (inputDecode : (scrutinee.map (ArithExpr.denote assignment)).decode program.enums = some input) : + remaining.denote assignment ≠ 0 ∧ ∃ matched body', + selectArm input ((pattern, body) :: arms) = some (matched, body') ∧ + ExpressionMeaning program.enums rom sourceCalls (matched ++ environment) body' + (result.map (ArithExpr.denote assignment)) := by + obtain ⟨_, matched, equation, boolean, evaluated⟩ := headFacts endValid + have one := boolean.resolve_left active + have remainingNonzero : remaining.denote assignment ≠ 0 := by + intro zero + exact active (by simpa [zero] using equation) + rcases matched input inputDecode with ⟨values, matched, _, bindingsDecode⟩ | ⟨_, zero⟩ + · refine ⟨remainingNonzero, values, body, by simp [selectArm, matched], ?_⟩ + exact evaluated one (values ++ environment) + (by simpa only [localsEnvironment_append] using bindingsDecode.append decoded) + · exact (active (by simpa [zero] using equation)).elim + split at rest + · obtain ⟨rfl, rfl⟩ := pure_ok.mp rest + refine ⟨(headFacts valid).1, ?_⟩ + intro environment decoded input inputDecode chosen member active + obtain rfl := List.mem_singleton.mp member + exact headSelected valid active environment decoded input inputDecode + · simp only [pure_bind] at rest + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨s₆valid, tailEval⟩ := lowerArms_sound checked tags callSound tailRun valid + obtain ⟨previous, matched, _, _, _⟩ := headFacts s₆valid + refine ⟨previous, ?_⟩ + intro environment decoded input inputDecode chosen member active + rcases List.mem_cons.mp member with same | member + · subst chosen + exact headSelected s₆valid active environment decoded input inputDecode + · obtain ⟨remainingNonzero, selectedBindings, selectedBody, selected, evaluated⟩ := + tailEval environment decoded input inputDecode chosen member active + change remaining.denote assignment * (1 - test.denote assignment) ≠ 0 at remainingNonzero + have nonzero := (mul_ne_zero_iff.mp remainingNonzero).1 + refine ⟨nonzero, selectedBindings, selectedBody, ?_, evaluated⟩ + rcases matched input inputDecode with ⟨_, _, one, _⟩ | ⟨unmatched, _⟩ + · exact (remainingNonzero (by simp [one])).elim + · simpa only [selectArm, unmatched] using selected + termination_by sizeOf arms + decreasing_by + all_goals simp_all only [Prod.mk.sizeOf_spec, List.cons.sizeOf_spec] + all_goals omega +end + +end Aiur.Circuit.Compiler diff --git a/Aiur/Aiur/Circuit/ExpressionWitness.lean b/Aiur/Aiur/Circuit/ExpressionWitness.lean new file mode 100644 index 000000000..96dc25f62 --- /dev/null +++ b/Aiur/Aiur/Circuit/ExpressionWitness.lean @@ -0,0 +1,656 @@ +import Aiur.Circuit.EncodingWitness +import Aiur.Circuit.PatternIrrefutable + +namespace Aiur.Circuit.Compiler + +variable {F : Type} {rom : WireROM F} + +set_option maxHeartbeats 3000000 +set_option maxRecDepth 10000 + +/-- Correct source calls supply the corresponding canonical circuit premises. -/ +def CallsComplete [Field F] [DecidableEq F] (decls : Declarations) + (sourceCalls : Aiur.CallRelation F) (calls : Circuit.CallRelation F) : Prop := + ∀ name values value, sourceCalls name values value → ∀ args result, + DecodesValues decls args values → result.decode decls = some value → calls name args result + +theorem decoded_environment_types [Field F] [DecidableEq F] {decls : Declarations} + {locals : Locals F} {assignment : Var → F} {environment : Environment F} + (decoded : DecodesEnvironment decls (localsEnvironment locals assignment) environment) : + environmentTypes environment = locals.map (fun binding => (binding.1, binding.2.type)) := by + simpa [localsEnvironment, List.map_map, Function.comp_def] using decoded.types + +mutual + /-- Finite source evaluation supplies canonical witnesses for every active expression. -/ + theorem lowerExpr_complete [Field F] [DecidableEq F] + {program : Program F} (checked : checkDeclarations program.enums = .ok ()) + (tags : program.enums.tagsValid F = true) + {calls : Circuit.CallRelation F} {sourceCalls : Aiur.CallRelation F} + (typed : CallsTyped program sourceCalls) (callComplete : CallsComplete program.enums sourceCalls calls) + {function : String} {locals : Locals F} {enable : ArithExpr F} {expr : Expr F} {output : Symbolic F} + {before after : BuildState F} + (compiled : lowerExpr program function locals enable expr before = .ok (output, after)) + {initial : Var → F} (layout : before.WellFormed) (valid : before.Valid rom calls initial) + (localsBound : LocalsBounded before.nextVar locals) (enableBound : enable.inBounds before.nextVar = true) + (active : enable.denote initial = 1) {environment : Environment F} + (decoded : DecodesEnvironment program.enums (localsEnvironment locals initial) environment) + {value : Value F} (evaluated : ROMEvalExprWith program.enums (rom.decode program.enums) sourceCalls environment expr value) : + ∃ assignment, Extension rom calls before after initial assignment ∧ Bounded after.nextVar output ∧ + (output.map (ArithExpr.denote assignment)).decode program.enums = some value := by + cases expr with + | literal literal => + cases evaluated + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [lowerExpr] using compiled) + exact ⟨initial, .refl layout valid, bounded_field.mpr rfl, WireValue.decode_field _ _⟩ + | var name => + cases evaluated with + | var lookup => + cases found : locals.find? (·.1 == name) with + | none => simp [lowerExpr, found] at compiled + | some binding => + rcases binding with ⟨bindingName, result⟩ + have same : bindingName = name := by simpa using List.find?_some found + subst bindingName + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [lowerExpr, found] using compiled) + obtain ⟨actual, actualFound, valueDecode⟩ := decoded.find name + (wire := (name, result.map (ArithExpr.denote initial))) + (by simp [localsEnvironment, List.find?_map, Function.comp_def, found]) + have equal := (Prod.mk.inj (Option.some.inj (actualFound.symm.trans lookup))).2 + exact ⟨initial, .refl layout valid, localsBound _ (List.mem_of_find?_eq_some found), equal ▸ valueDecode⟩ + | tuple items => + cases evaluated with + | tuple itemsEval => + simp only [lowerExpr] at compiled + obtain ⟨wires, middle, argsRun, finished⟩ := bind_ok.mp compiled + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, ext, bounds, valuesDecode⟩ := lowerArgs_complete checked tags typed callComplete argsRun + layout valid localsBound enableBound active decoded itemsEval + exact ⟨a, ext, bounded_tuple.mpr bounds, by + simpa only [WireValue.map_tuple] using WireValue.decode_tuple checked tags valuesDecode⟩ + | construct name ctor args => + cases evaluated with + | construct argsEval => + cases found : program.enums.findEnum? name with + | none => simp [lowerExpr, found] at compiled + | some definition => + cases atIndex : definition.constructors[definition.constructors.findIdx (·.name == ctor)]? with + | none => simp [lowerExpr, found, atIndex] at compiled + | some constructor => + simp only [lowerExpr, found, atIndex] at compiled + obtain ⟨wires, s₁, argsRun, rest⟩ := bind_ok.mp compiled + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · rename_i types + obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨typeLayout, middle, layoutRun, rest⟩ := bind_ok.mp rest + obtain ⟨expansion, rfl⟩ := getLayout_eq layoutRun + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · obtain ⟨⟨⟩, middle, unchanged, finished⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, ext, valuesBound, argsDecode⟩ := lowerArgs_complete checked tags typed callComplete + argsRun layout valid localsBound enableBound active decoded argsEval + refine ⟨a, ext, ?_, ?_⟩ + · unfold Bounded + refine Layout.enumWords_all _ _ _ ?_ ?_ + · rfl + · intro polynomial member + simp only [List.mem_append] at member + rcases member with member | member + · obtain ⟨wire, member, leaf⟩ := List.mem_flatMap.mp member + exact valuesBound wire member polynomial leaf + · have zero : polynomial = .const 0 := List.eq_of_mem_replicate member + subst polynomial; rfl + · have ctorName : constructor.name = ctor := by + simpa using List.findIdx_of_getElem?_eq_some atIndex + have constructed := WireValue.decode_construct checked tags found atIndex argsDecode + (by simpa [Function.comp_def, WireValue.map] using not_ne_iff.mp types) expansion + simpa [ctorName, WireValue.map, List.map_flatMap, List.flatMap_map, + List.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using constructed + | project operand index => + cases evaluated with + | project inputEval projected => + simp only [lowerExpr] at compiled + obtain ⟨input, middle, inputRun, rest⟩ := bind_ok.mp compiled + rcases input with ⟨type, words⟩ + cases type with + | field | ptr | enum => simp at rest + | tuple types => + dsimp only at rest + obtain ⟨wires, last, splitRun, rest⟩ := bind_ok.mp rest + have unchanged := (splitValues_spec splitRun).1 + subst last + cases found : wires[index]? with + | none => simp [found] at rest + | some result => + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [found] using rest) + obtain ⟨a, ext, bounds, inputDecode⟩ := lowerExpr_complete checked tags typed callComplete inputRun + layout valid localsBound enableBound active decoded inputEval + obtain ⟨values, rfl, valuesDecode⟩ := splitValues_decode checked splitRun inputDecode + obtain ⟨actual, atValue, valueDecode⟩ := valuesDecode.getElem (index := index) + (wire := result.map (ArithExpr.denote a)) (by simp [List.getElem?_map, found]) + have same : actual = value := by simpa [projectValue, atValue, pure, Except.pure] using projected + exact ⟨a, ext, splitValues_bounded splitRun bounds result (List.mem_of_getElem? found), same ▸ valueDecode⟩ + | letValue pattern operand body => + cases evaluated with + | letValue inputEval matched bodyEval => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, inputRun, rest⟩ := bind_ok.mp compiled + obtain ⟨⟨test, bindings⟩, s₂, patternRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₃, guardRun, bodyRun⟩ := bind_ok.mp rest + obtain ⟨a, e₁, inputBound, inputDecode⟩ := lowerExpr_complete checked tags typed callComplete inputRun + layout valid localsBound enableBound active decoded inputEval + obtain ⟨b, e₂, testBound, bindingsBound⟩ := lowerPattern_complete patternRun e₁.layout e₁.valid inputBound + have chainExt := e₁.trans e₂ + have patternTest := (lowerPattern_sound checked tags patternRun e₂.valid).2.2 _ + (e₂.decoded_value inputBound inputDecode) + obtain ⟨bindingsDecode, testOne⟩ : DecodesEnvironment program.enums + (localsEnvironment bindings b) _ ∧ test.denote b = 1 := by + rcases patternTest with ⟨values, actualMatch, one, formed⟩ | ⟨absent, _⟩ + · have same := Option.some.inj (actualMatch.symm.trans matched) + exact ⟨same ▸ formed, one⟩ + · rw [matched] at absent; cases absent + have e₃ := guarded_complete guardRun e₂.layout e₂.valid (chainExt.bound enableBound) + (by simpa [Scalar.Circuit.ArithExpr.inBounds] using testBound) + (Or.inr (by change test.denote b - 1 = 0; simp [testOne])) + obtain ⟨c, e₄, bodyBound, resultDecode⟩ := lowerExpr_complete checked tags typed callComplete bodyRun + e₃.layout e₃.valid + (localsBounded_append.mpr ⟨bindingsBound.mono e₃.increase, localsBound.mono (chainExt.trans e₃).increase⟩) + ((chainExt.trans e₃).bound enableBound) (((chainExt.trans e₃).polynomial enableBound).trans active) + (by simpa only [localsEnvironment_append] using bindingsDecode.append (chainExt.environment localsBound decoded)) bodyEval + exact ⟨c, (chainExt.trans e₃).trans e₄, bodyBound, resultDecode⟩ + | store operand => + cases evaluated with + | @store _ _ stored address operandEval cell => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, inputRun, rest⟩ := bind_ok.mp compiled + obtain ⟨id, s₂, addressRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₃, booleanRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₄, validationRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₅, cellRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, e₁, inputBound, inputDecode⟩ := lowerExpr_complete checked tags typed callComplete inputRun + layout valid localsBound enableBound active decoded operandEval + obtain ⟨b, e₂, addressBound, addressEq⟩ := fresh_complete addressRun e₁.layout e₁.valid address + have chainExt := e₁.trans e₂ + have e₃ := boolean_complete booleanRun e₂.layout e₂.valid (chainExt.bound enableBound) + (Or.inr ((chainExt.polynomial enableBound).trans active)) + have ab : (ArithExpr.var id : ArithExpr F).inBounds s₂.nextVar = true := by + simpa [Scalar.Circuit.ArithExpr.inBounds] using addressBound + have throughBoolean := chainExt.trans e₃ + obtain ⟨c, e₄⟩ := validateValue_complete tags validationRun e₃.layout e₃.valid + (throughBoolean.bound enableBound) (inputBound.mono (e₂.trans e₃).increase) + (Or.inr ⟨stored, (e₂.trans e₃).decoded_value inputBound inputDecode⟩) + have throughValidation := throughBoolean.trans e₄ + have addressEqC : c id = address := ((e₃.trans e₄).polynomial ab).trans addressEq + have inputDecodeC := ((e₂.trans e₃).trans e₄).decoded_value inputBound inputDecode + have e₅ := requireCell_complete cellRun e₄.layout e₄.valid + (throughValidation.bound enableBound) ((e₃.trans e₄).bound ab) + (inputBound.mono ((e₂.trans e₃).trans e₄).increase) (by + intro _ + obtain ⟨wire, rawCell, storedDecode⟩ := WireROM.mem_decode.mp cell + have same := WireValue.decode_injective checked inputDecodeC storedDecode + change (c id, input.map (ArithExpr.denote c)) ∈ rom.entries + rw [addressEqC, same] + exact rawCell) + refine ⟨c, throughValidation.trans e₅, by + simpa only [bounded_ptr] using ((e₃.trans e₄).trans e₅).bound ab, ?_⟩ + obtain ⟨shape, _, typeLayout, expanded, _⟩ := WireValue.decode_spec inputDecode + have names := (Declarations.layout_parts expanded).1 + simpa only [WireValue.map_ptr, Scalar.Circuit.ArithExpr.denote, addressEqC, shape, WireValue.map, WireValue.ptr, List.map_cons, List.map_nil] using + WireValue.decode_ptr names address + | load operand => + cases evaluated with + | load pointerEval cell sourceType => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, inputRun, rest⟩ := bind_ok.mp compiled + rcases input with ⟨type, words⟩ + cases type with + | field | tuple | enum => simp at rest + | ptr target => + cases words with + | nil => simp at rest + | cons address words => cases words with + | cons => simp at rest + | nil => + dsimp only at rest + obtain ⟨result, s₂, resultRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₃, booleanRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₄, validationRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₅, cellRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, e₁, inputBound, pointerDecode⟩ := lowerExpr_complete checked tags typed callComplete inputRun + layout valid localsBound enableBound active decoded pointerEval + have pointerEq := WireValue.ptr_decoded_eq pointerDecode + rcases Value.ptr.inj pointerEq with ⟨rfl, addressEq⟩ + rw [addressEq] at cell + obtain ⟨wire, rawCell, valueDecode⟩ := WireROM.mem_decode.mp cell + obtain ⟨b, e₂, resultBound, assigned⟩ := freshValue_complete resultRun e₁.layout e₁.valid wire + ((WireValue.decode_spec valueDecode).1.symm.trans sourceType) (WireValue.decode_sized checked valueDecode) + have resultDecodeB : ((result.map ArithExpr.var).map (ArithExpr.denote b)).decode program.enums = some value := by + simp only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] + change (result.map b).decode program.enums = some value + rw [assigned]; exact valueDecode + have chainExt := e₁.trans e₂ + have e₃ := boolean_complete booleanRun e₂.layout e₂.valid (chainExt.bound enableBound) + (Or.inr ((chainExt.polynomial enableBound).trans active)) + have throughBoolean := chainExt.trans e₃ + obtain ⟨c, e₄⟩ := validateValue_complete tags validationRun e₃.layout e₃.valid + (throughBoolean.bound enableBound) (resultBound.mono e₃.increase) (Or.inr ⟨value, resultDecodeB⟩) + have throughValidation := throughBoolean.trans e₄ + have ab := inputBound address (by simp) + have outputEq : result.map c = wire := ((e₃.trans e₄).variables resultBound).trans assigned + have e₅ := requireCell_complete cellRun e₄.layout e₄.valid + (throughValidation.bound enableBound) (((e₂.trans e₃).trans e₄).bound ab) + (resultBound.mono (e₃.trans e₄).increase) (by + intro _ + simp only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] + change (address.denote c, result.map c) ∈ rom.entries + rw [outputEq, ((e₂.trans e₃).trans e₄).polynomial ab] + exact rawCell) + exact ⟨c, throughValidation.trans e₅, resultBound.mono ((e₃.trans e₄).trans e₅).increase, + by simp only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote]; change (result.map c).decode program.enums = some value + rw [outputEq]; exact valueDecode⟩ + | hint type key channel => + cases evaluated with + | hint keyEval valueTyped => + rename_i constant + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, keyRun, rest⟩ := bind_ok.mp compiled + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨result, s₂, freshRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₃, validationRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, e₁, _, _⟩ := lowerExpr_complete checked tags typed callComplete keyRun + layout valid localsBound enableBound active decoded keyEval + have valueTyped : constant.type = type ∧ constant.wellFormed program.enums = true := by + simpa [Value.WellTyped, Value.hasType] using valueTyped + obtain ⟨b, e₂, resultBound, resultDecode⟩ := freshValue_decoded_complete checked tags freshRun + e₁.layout e₁.valid constant.toValue (by simpa using valueTyped.1) + (by simpa using valueTyped.2) + have ext := e₁.trans e₂ + have decodedResult : ((result.map ArithExpr.var).map (ArithExpr.denote b)).decode program.enums = + some constant.toValue := by simpa only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using resultDecode + obtain ⟨c, e₃⟩ := validateValue_complete tags validationRun e₂.layout e₂.valid + (ext.bound enableBound) resultBound (Or.inr ⟨constant.toValue, decodedResult⟩) + exact ⟨c, ext.trans e₃, resultBound.mono e₃.increase, e₃.decoded_value resultBound decodedResult⟩ + | neg operand => + cases evaluated with + | neg inputEval operation => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, inputRun, rest⟩ := bind_ok.mp compiled + obtain ⟨polynomial, s₂, fieldRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_ok fieldRun + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, ext, bounded, inputDecode⟩ := lowerExpr_complete checked tags typed callComplete inputRun + layout valid localsBound enableBound active decoded inputEval + simp only [WireValue.map_field, WireValue.decode_field, Option.some.injEq] at inputDecode + rw [← inputDecode] at operation + refine ⟨a, ext, by simpa [Scalar.Circuit.ArithExpr.inBounds] using bounded, ?_⟩ + simpa [evalNeg, Scalar.Circuit.ArithExpr.denote] using operation + | assertEq message left right => + cases evaluated with + | assertEq leftEval rightEval operation => + obtain ⟨_, same, rfl⟩ := evalAssertEq_ok.mp operation + simp only [lowerExpr] at compiled + obtain ⟨leftWire, s₁, leftRun, rest⟩ := bind_ok.mp compiled + obtain ⟨rightWire, s₂, rightRun, rest⟩ := bind_ok.mp rest + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨⟨⟩, last, equated, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, e₁, leftBound, leftDecode⟩ := lowerExpr_complete checked tags typed callComplete leftRun + layout valid localsBound enableBound active decoded leftEval + obtain ⟨b, e₂, rightBound, rightDecode⟩ := lowerExpr_complete checked tags typed callComplete rightRun + e₁.layout e₁.valid (localsBound.mono e₁.increase) (e₁.bound enableBound) + ((e₁.polynomial enableBound).trans active) (e₁.environment localsBound decoded) rightEval + have chainExt := e₁.trans e₂ + have leftDecodeB := e₂.decoded_value leftBound leftDecode + rw [same] at leftDecodeB + have equal := WireValue.decode_injective checked leftDecodeB rightDecode + have e₃ := constrainValue_complete equated e₂.layout e₂.valid (chainExt.bound enableBound) + (leftBound.mono e₂.increase) rightBound (Or.inr equal) + exact ⟨b, chainExt.trans e₃, bounded_tuple.mpr (by simp), by + simpa only [WireValue.map_tuple, List.map_nil] using + WireValue.decode_tuple checked tags (.nil : DecodesValues program.enums [] [])⟩ + | binary op left right => + cases evaluated with + | binary leftEval rightEval operation => + simp only [lowerExpr] at compiled + obtain ⟨leftWire, s₁, leftRun, rest⟩ := bind_ok.mp compiled + obtain ⟨leftPoly, s₂, leftField, rest⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_ok leftField + obtain ⟨rightWire, s₃, rightRun, rest⟩ := bind_ok.mp rest + obtain ⟨rightPoly, s₄, rightField, rest⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_ok rightField + obtain ⟨a, e₁, leftBound, leftDecode⟩ := lowerExpr_complete checked tags typed callComplete leftRun + layout valid localsBound enableBound active decoded leftEval + obtain ⟨b, e₂, rightBound, rightDecode⟩ := lowerExpr_complete checked tags typed callComplete rightRun + e₁.layout e₁.valid (localsBound.mono e₁.increase) (e₁.bound enableBound) + ((e₁.polynomial enableBound).trans active) (e₁.environment localsBound decoded) rightEval + have chainExt := e₁.trans e₂ + have lb := bounded_field.mp (leftBound.mono e₂.increase) + have rb := bounded_field.mp rightBound + have leftDecodeB := e₂.decoded_value leftBound leftDecode + simp only [WireValue.map_field, WireValue.decode_field, Option.some.injEq] at leftDecodeB rightDecode + rw [← leftDecodeB, ← rightDecode] at operation + cases op with + | add | sub | mul => + obtain ⟨rfl, rfl⟩ := pure_ok.mp rest + exact ⟨b, chainExt, by + simpa [Scalar.Circuit.ArithExpr.inBounds] using And.intro lb rb, + by simpa [evalBinOp, Scalar.Circuit.ArithExpr.denote] using operation⟩ + | div => + have nonzero : rightPoly.denote b ≠ 0 := by + intro zero + simp [evalBinOp, zero] at operation + have quotient : Value.field (leftPoly.denote b / rightPoly.denote b) = value := by + simpa [evalBinOp, nonzero] using operation + obtain ⟨inverse, s₅, freshRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₆, inverseRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨c, e₃, invBound, invEq⟩ := fresh_complete freshRun e₂.layout e₂.valid (rightPoly.denote b)⁻¹ + have ib : (ArithExpr.var inverse : ArithExpr F).inBounds s₅.nextVar = true := by + simpa [Scalar.Circuit.ArithExpr.inBounds] using invBound + have e₄ := guarded_complete inverseRun e₃.layout e₃.valid ((chainExt.trans e₃).bound enableBound) + (by simpa [Scalar.Circuit.ArithExpr.inBounds] using And.intro (e₃.bound rb) ib) + (Or.inr (by + change rightPoly.denote c * c inverse - 1 = 0 + rw [e₃.polynomial rb, invEq] + simp [nonzero])) + refine ⟨c, (chainExt.trans e₃).trans e₄, ?_, ?_⟩ + · simpa [Scalar.Circuit.ArithExpr.inBounds] using And.intro ((e₃.trans e₄).bound lb) (e₄.bound ib) + · simp only [WireValue.map_field, WireValue.decode_field, Option.some.injEq] + change Value.field (leftPoly.denote c * c inverse) = value + rw [e₃.polynomial lb, invEq, ← div_eq_mul_inv] + exact quotient + | call name args => + cases evaluated with + | call argsEval calleeEval => + cases found : program.findSignature? name with + | none => simp [lowerExpr, found] at compiled + | some callee => + simp only [lowerExpr, found] at compiled + obtain ⟨arguments, s₁, argsRun, rest⟩ := bind_ok.mp compiled + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨result, s₂, resultRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₃, booleanRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₄, argsValidation, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₅, resultValidation, rest⟩ := bind_ok.mp rest + simp [StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at rest + obtain ⟨rfl, rfl⟩ := rest + obtain ⟨a, e₁, argsBound, argsDecode⟩ := lowerArgs_complete checked tags typed callComplete argsRun + layout valid localsBound enableBound active decoded argsEval + have resultType := typed _ _ _ calleeEval callee found + obtain ⟨b, e₂, resultBound, resultDecode⟩ := freshValue_decoded_complete checked tags resultRun + e₁.layout e₁.valid value resultType.1 resultType.2 + have resultDecodeB : ((result.map ArithExpr.var).map (ArithExpr.denote b)).decode program.enums = some value := by + simpa only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using resultDecode + have chainExt := e₁.trans e₂ + have e₃ := boolean_complete booleanRun e₂.layout e₂.valid (chainExt.bound enableBound) + (Or.inr ((chainExt.polynomial enableBound).trans active)) + have throughBoolean := chainExt.trans e₃ + obtain ⟨c, e₄⟩ := validateValues_complete tags argsValidation e₃.layout e₃.valid + (throughBoolean.bound enableBound) (fun w h => (argsBound w h).mono (e₂.trans e₃).increase) + (Or.inr (fun wire member => ((e₂.trans e₃).decoded_values argsBound argsDecode).each + (wire.map (ArithExpr.denote b)) (List.mem_map.mpr ⟨wire, member, rfl⟩))) + have throughArgs := throughBoolean.trans e₄ + obtain ⟨d, e₅⟩ := validateValue_complete tags resultValidation e₄.layout e₄.valid + (throughArgs.bound enableBound) (resultBound.mono (e₃.trans e₄).increase) + (Or.inr ⟨value, (e₃.trans e₄).decoded_value resultBound resultDecodeB⟩) + have throughResult := throughArgs.trans e₅ + have resultDecodeD := ((e₃.trans e₄).trans e₅).decoded_value resultBound resultDecodeB + have e₆ := send_complete e₅.layout e₅.valid ⟨name, arguments, result, enable⟩ + (send_bounded (fun w h => (argsBound w h).mono (((e₂.trans e₃).trans e₄).trans e₅).increase) + (resultBound.mono ((e₃.trans e₄).trans e₅).increase) (throughResult.bound enableBound)) (by + intro _ + exact callComplete name _ value calleeEval _ _ + ((((e₂.trans e₃).trans e₄).trans e₅).decoded_values argsBound argsDecode) + (by simpa only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using resultDecodeD)) + exact ⟨d, throughResult.trans e₆, resultBound.mono (((e₃.trans e₄).trans e₅).trans e₆).increase, + resultDecodeD⟩ + | matchValue scrutinee arms => + have allEval := evaluated + cases evaluated with + | matchValue inputEval selected branchEval => + simp only [lowerExpr] at compiled + obtain ⟨⟨⟩, s₁, checkRun, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := lift_eq_ok checkRun + obtain ⟨type, s₂, typeRun, rest⟩ := bind_ok.mp rest + obtain ⟨inferred, rfl⟩ := lift_eq_ok typeRun + have typeChecked : inferType program function (environmentTypes environment) + (.matchValue scrutinee arms) = .ok type := by + rw [decoded_environment_types decoded] + cases h : inferType program function (locals.map fun (name, value) => (name, value.type)) + (.matchValue scrutinee arms) <;> simp_all [Except.mapError] + have resultType := allEval.wellTyped typed (WireROM.decode_wellFormed program.enums rom) + decoded.wellFormed function type typeChecked + obtain ⟨input, s₃, inputRun, rest⟩ := bind_ok.mp rest + obtain ⟨result, s₄, resultRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₅, validationRun, rest⟩ := bind_ok.mp rest + obtain ⟨selectors, s₆, armsRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₇, exclusionRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₈, sumRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, e₁, inputBound, inputDecode⟩ := lowerExpr_complete checked tags typed callComplete inputRun + layout valid localsBound enableBound active decoded inputEval + obtain ⟨b, e₂, resultBound, resultDecode⟩ := freshValue_decoded_complete checked tags resultRun + e₁.layout e₁.valid value resultType.1 resultType.2 + have resultDecodeB : ((result.map ArithExpr.var).map (ArithExpr.denote b)).decode program.enums = some value := by + simpa only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using resultDecode + have initialExt := e₁.trans e₂ + obtain ⟨v, validationExt⟩ := validateValue_complete tags validationRun e₂.layout e₂.valid + (initialExt.bound enableBound) resultBound (Or.inr ⟨value, resultDecodeB⟩) + have chainExt := initialExt.trans validationExt + obtain ⟨c, e₃, selectorsBound, selection⟩ := lowerArms_complete checked tags typed callComplete armsRun + validationExt.layout validationExt.valid (localsBound.mono chainExt.increase) + (inputBound.mono (e₂.trans validationExt).increase) (resultBound.mono validationExt.increase) + (chainExt.bound enableBound) ((chainExt.polynomial enableBound).trans active) + (chainExt.environment localsBound decoded) ((e₂.trans validationExt).decoded_value inputBound inputDecode) + (validationExt.decoded_value resultBound resultDecodeB) selected branchEval + have e₄ := excludePairs_complete exclusionRun e₃.layout e₃.valid selectorsBound selection.exclusive + have e₅ := sum_complete sumRun e₄.layout e₄.valid + (fun p h => e₄.bound (selectorsBound p h)) (((chainExt.trans e₃).trans e₄).bound enableBound) + (by rw [((chainExt.trans e₃).trans e₄).polynomial enableBound, active]; exact selection.sum) + exact ⟨c, ((chainExt.trans e₃).trans e₄).trans e₅, + resultBound.mono (((validationExt.trans e₃).trans e₄).trans e₅).increase, + (validationExt.trans e₃).decoded_value resultBound resultDecodeB⟩ + termination_by sizeOf expr + + theorem lowerArgs_complete [Field F] [DecidableEq F] + {program : Program F} (checked : checkDeclarations program.enums = .ok ()) + (tags : program.enums.tagsValid F = true) + {calls : Circuit.CallRelation F} {sourceCalls : Aiur.CallRelation F} + (typed : CallsTyped program sourceCalls) (callComplete : CallsComplete program.enums sourceCalls calls) + {function : String} {locals : Locals F} {enable : ArithExpr F} + {args : List (Expr F)} {outputs : List (Symbolic F)} {before after : BuildState F} + (compiled : lowerArgs program function locals enable args before = .ok (outputs, after)) + {initial : Var → F} (layout : before.WellFormed) (valid : before.Valid rom calls initial) + (localsBound : LocalsBounded before.nextVar locals) (enableBound : enable.inBounds before.nextVar = true) + (active : enable.denote initial = 1) {environment : Environment F} + (decoded : DecodesEnvironment program.enums (localsEnvironment locals initial) environment) + {values : List (Value F)} (evaluated : ROMEvalArgsWith program.enums (rom.decode program.enums) sourceCalls environment args values) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + (∀ wire ∈ outputs, Bounded after.nextVar wire) ∧ + DecodesValues program.enums (outputs.map (WireValue.map (ArithExpr.denote assignment))) values := by + cases args with + | nil => + cases evaluated + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [lowerArgs] using compiled) + exact ⟨initial, .refl layout valid, by simp, .nil⟩ + | cons arg args => + cases evaluated with + | cons headEval tailEval => + simp only [lowerArgs] at compiled + obtain ⟨head, middle, headRun, rest⟩ := bind_ok.mp compiled + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, e₁, headBound, headDecode⟩ := lowerExpr_complete checked tags typed callComplete headRun + layout valid localsBound enableBound active decoded headEval + obtain ⟨b, e₂, tailBound, tailDecode⟩ := lowerArgs_complete checked tags typed callComplete tailRun + e₁.layout e₁.valid (localsBound.mono e₁.increase) (e₁.bound enableBound) + ((e₁.polynomial enableBound).trans active) (e₁.environment localsBound decoded) tailEval + refine ⟨b, e₁.trans e₂, ?_, .cons (e₂.decoded_value headBound headDecode) tailDecode⟩ + intro wire member + rcases List.mem_cons.mp member with rfl | member + · exact headBound.mono e₂.increase + · exact tailBound wire member + termination_by sizeOf args + + theorem lowerArms_complete [Field F] [DecidableEq F] + {program : Program F} (checked : checkDeclarations program.enums = .ok ()) + (tags : program.enums.tagsValid F = true) + {calls : Circuit.CallRelation F} {sourceCalls : Aiur.CallRelation F} + (typed : CallsTyped program sourceCalls) (callComplete : CallsComplete program.enums sourceCalls calls) + {function : String} {locals : Locals F} {scrutinee result : Symbolic F} {remaining : ArithExpr F} + {arms : List (Pattern F × Expr F)} {selectors : List (ArithExpr F)} {before after : BuildState F} + (compiled : lowerArms program function locals scrutinee result remaining arms before = .ok (selectors, after)) + {initial : Var → F} (layout : before.WellFormed) (valid : before.Valid rom calls initial) + (localsBound : LocalsBounded before.nextVar locals) + (inputBound : Bounded before.nextVar scrutinee) (resultBound : Bounded before.nextVar result) + (remainingBound : remaining.inBounds before.nextVar = true) (active : remaining.denote initial = 1) + {environment : Environment F} + (decoded : DecodesEnvironment program.enums (localsEnvironment locals initial) environment) + {input value : Value F} + (inputDecode : (scrutinee.map (ArithExpr.denote initial)).decode program.enums = some input) + (resultDecode : (result.map (ArithExpr.denote initial)).decode program.enums = some value) + {matched : Environment F} {body : Expr F} (selected : selectArm input arms = some (matched, body)) + (evaluated : ROMEvalExprWith program.enums (rom.decode program.enums) sourceCalls (matched ++ environment) body value) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + (∀ selector ∈ selectors, selector.inBounds after.nextVar = true) ∧ + Scalar.Circuit.SelectorsValid (1 : F) (selectors.map (ArithExpr.denote assignment)) := by + cases arms with + | nil => simp [selectArm] at selected + | cons arm arms => + rcases hArm : arm with ⟨pattern, branch⟩ + simp only [hArm, lowerArms] at compiled + obtain ⟨⟨test, bindings⟩, s₁, patternRun, rest⟩ := bind_ok.mp compiled + obtain ⟨selector, s₂, freshRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₃, booleanRun, rest⟩ := bind_ok.mp rest + cases finished + obtain ⟨finished, s₄, equationRun, rest⟩ := bind_ok.mp rest + cases finished + obtain ⟨bodyValue, s₅, bodyRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₆, valueRun, armsRest⟩ := bind_ok.mp rest + cases finished + obtain ⟨a, e₁, testBound, bindingsBound⟩ := lowerPattern_complete patternRun layout valid inputBound + have patternSound := lowerPattern_sound checked tags patternRun e₁.valid + have patternTest := patternSound.2.2 input (e₁.decoded_value inputBound inputDecode) + have testBool := patternSound.2.1 + obtain ⟨b, e₂, idBound, selEq⟩ := fresh_complete freshRun e₁.layout e₁.valid (test.denote a) + have selectorBound : (ArithExpr.var selector : ArithExpr F).inBounds s₂.nextVar = true := by + simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using idBound + have e₃ := boolean_complete booleanRun e₂.layout e₂.valid selectorBound (by + change b selector = 0 ∨ b selector = 1; rw [selEq]; exact testBool) + have chainExt := (e₁.trans e₂).trans e₃ + have e₄ := constrain_complete equationRun e₃.layout e₃.valid + (by simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + And.intro (e₃.bound selectorBound) (And.intro (chainExt.bound remainingBound) ((e₂.trans e₃).bound testBound))) + (by change b selector - remaining.denote b * test.denote b = 0 + rw [selEq, chainExt.polynomial remainingBound, active, e₂.polynomial testBound]; simp) + have localsBound' : LocalsBounded s₄.nextVar (bindings ++ locals) := + localsBounded_append.mpr ⟨bindingsBound.mono ((e₂.trans e₃).trans e₄).increase, + localsBound.mono (chainExt.trans e₄).increase⟩ + rcases patternTest with ⟨headValues, matchedHead, testOne, bindingsDecode⟩ | ⟨unmatchedHead, testZero⟩ + · have selectedHead : matched = headValues ∧ body = branch := by + simpa only [hArm, selectArm, matchedHead, Option.some.injEq, Prod.mk.injEq] using selected.symm + obtain ⟨rfl, rfl⟩ := selectedHead + have selOne : (ArithExpr.var selector : ArithExpr F).denote b = 1 := selEq.trans testOne + obtain ⟨c, e₅, bodyBound, bodyDecode⟩ := lowerExpr_complete checked tags typed callComplete bodyRun + e₄.layout e₄.valid localsBound' ((e₃.trans e₄).bound selectorBound) selOne + (by simpa only [localsEnvironment_append] using + (DecodesEnvironment.append (((e₂.trans e₃).trans e₄).environment bindingsBound bindingsDecode) + ((chainExt.trans e₄).environment localsBound decoded))) evaluated + have headExt := (chainExt.trans e₄).trans e₅ + have selOneC := (((e₃.trans e₄).trans e₅).polynomial selectorBound).trans selOne + have e₆ := constrainValue_decoded_complete checked valueRun e₅.layout e₅.valid + (((e₃.trans e₄).trans e₅).bound selectorBound) (resultBound.mono headExt.increase) bodyBound + (headExt.decoded_value resultBound resultDecode) bodyDecode + have total := headExt.trans e₆ + have finalBound := (((e₃.trans e₄).trans e₅).trans e₆).bound selectorBound + split at armsRest + · obtain ⟨rfl, rfl⟩ := pure_ok.mp armsRest + refine ⟨c, total, by simpa using finalBound, ?_⟩ + simpa only [List.map_cons, List.map_nil, selOneC, List.nil_append] using + (Scalar.Circuit.SelectorsValid.single (before := []) (after := []) (by simp) (by simp) : + Scalar.Circuit.SelectorsValid (1 : F) [1]) + · simp only [pure_bind] at armsRest + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp armsRest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + have testFinal := ((((e₂.trans e₃).trans e₄).trans e₅).trans e₆).bound testBound + have nextBound : (ArithExpr.mul remaining (.sub (.const 1) test)).inBounds s₆.nextVar = true := by + simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + And.intro (total.bound remainingBound) testFinal + have nextZero : (ArithExpr.mul remaining (.sub (.const 1) test)).denote c = 0 := by + change remaining.denote c * (1 - test.denote c) = 0 + rw [((((e₂.trans e₃).trans e₄).trans e₅).trans e₆).polynomial testBound, testOne] + simp + obtain ⟨d, tailExt, tailBound, tailZero⟩ := lowerArms_inactive tailRun total.layout total.valid + (localsBound.mono total.increase) (inputBound.mono total.increase) (resultBound.mono total.increase) + nextBound nextZero + refine ⟨d, total.trans tailExt, ?_, ?_⟩ + · intro p member + rcases List.mem_cons.mp member with rfl | member + · exact tailExt.bound finalBound + · exact tailBound p member + · have one := (tailExt.polynomial finalBound).trans selOneC + simp only [List.map_cons, one] + exact Scalar.Circuit.SelectorsValid.single (before := []) (by simp) + (by simpa only [List.forall_mem_map] using tailZero) + · have selectedTail : selectArm input arms = some (matched, body) := by + simpa only [hArm, selectArm, unmatchedHead] using selected + have selZero : (ArithExpr.var selector : ArithExpr F).denote b = 0 := selEq.trans testZero + obtain ⟨c, e₅, bodyBound⟩ := lowerExpr_inactive bodyRun e₄.layout e₄.valid localsBound' + ((e₃.trans e₄).bound selectorBound) selZero + have headExt := (chainExt.trans e₄).trans e₅ + have selZeroC := (((e₃.trans e₄).trans e₅).polynomial selectorBound).trans selZero + have e₆ := constrainValue_complete valueRun e₅.layout e₅.valid + (((e₃.trans e₄).trans e₅).bound selectorBound) (resultBound.mono headExt.increase) bodyBound (Or.inl selZeroC) + have total := headExt.trans e₆ + have finalBound := (((e₃.trans e₄).trans e₅).trans e₆).bound selectorBound + split at armsRest + · rename_i irrefutable + have one := lowerPattern_irrefutable checked tags patternRun irrefutable e₁.valid + (e₁.decoded_value inputBound inputDecode) + exact (zero_ne_one (testZero.symm.trans one)).elim + · simp only [pure_bind] at armsRest + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp armsRest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + have testFinal := ((((e₂.trans e₃).trans e₄).trans e₅).trans e₆).bound testBound + have nextBound : (ArithExpr.mul remaining (.sub (.const 1) test)).inBounds s₆.nextVar = true := by + simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + And.intro (total.bound remainingBound) testFinal + have nextOne : (ArithExpr.mul remaining (.sub (.const 1) test)).denote c = 1 := by + change remaining.denote c * (1 - test.denote c) = 1 + rw [total.polynomial remainingBound, active, + ((((e₂.trans e₃).trans e₄).trans e₅).trans e₆).polynomial testBound, testZero] + simp + obtain ⟨d, tailExt, tailBound, selection⟩ := lowerArms_complete checked tags typed callComplete tailRun + total.layout total.valid (localsBound.mono total.increase) + (inputBound.mono total.increase) (resultBound.mono total.increase) nextBound nextOne + (total.environment localsBound decoded) (total.decoded_value inputBound inputDecode) + (total.decoded_value resultBound resultDecode) selectedTail evaluated + refine ⟨d, total.trans tailExt, ?_, ?_⟩ + · intro p member + rcases List.mem_cons.mp member with rfl | member + · exact tailExt.bound finalBound + · exact tailBound p member + · have zero := (tailExt.polynomial finalBound).trans selZeroC + simpa only [List.map_cons, zero] using selection.zero_cons + termination_by sizeOf arms + decreasing_by + all_goals simp only [*, Prod.mk.sizeOf_spec, List.cons.sizeOf_spec] + all_goals omega +end + +end Aiur.Circuit.Compiler diff --git a/Aiur/Aiur/Circuit/ForestBalance.lean b/Aiur/Aiur/Circuit/ForestBalance.lean new file mode 100644 index 000000000..b8ea06af4 --- /dev/null +++ b/Aiur/Aiur/Circuit/ForestBalance.lean @@ -0,0 +1,29 @@ +import Aiur.Circuit.Balance + +namespace Aiur.Circuit.Balance + +def Forest (static : α → Bool) (roots : List α) (rules : List (RuleClaims α)) : Prop := + ((roots ++ rules.flatMap Prod.snd).filter (fun c => !static c)).Perm (rules.map Prod.fst) + +theorem forest_nil (static : α → Bool) : Forest static [] [] := .nil + +theorem forest_static {static : α → Bool} {root : α} (known : static root = true) : + Forest static [root] [] := by simp [Forest, known] + +theorem forest_node {static : α → Bool} {conclusion : α} {premises : List α} + {rules : List (RuleClaims α)} (dynamic : static conclusion = false) + (children : Forest static premises rules) : + Forest static [conclusion] ((conclusion, premises) :: rules) := by + simpa [Forest, dynamic] using List.Perm.cons conclusion children + +theorem forest_append [DecidableEq α] {static : α → Bool} {leftRoots rightRoots : List α} + {left right : List (RuleClaims α)} (a : Forest static leftRoots left) + (b : Forest static rightRoots right) : Forest static (leftRoots ++ rightRoots) (left ++ right) := by + simp only [Forest, List.perm_iff_count] at a b ⊢ + intro claim + have ha := a claim + have hb := b claim + simp only [List.filter_append, List.count_append, List.flatMap_append, List.map_append] at ha hb ⊢ + omega + +end Aiur.Circuit.Balance diff --git a/Aiur/Aiur/Circuit/InactiveBasics.lean b/Aiur/Aiur/Circuit/InactiveBasics.lean new file mode 100644 index 000000000..72b89608f --- /dev/null +++ b/Aiur/Aiur/Circuit/InactiveBasics.lean @@ -0,0 +1,55 @@ +import Aiur.Circuit.ValidationWitness +import Aiur.Circuit.ValueWitness +import Aiur.Circuit.SelectorWitness +import Aiur.Circuit.PatternWitness + +namespace Aiur.Circuit.Compiler + +variable {F : Type} {rom : WireROM F} + +theorem freshValue_zero_complete [Field F] {decls : Declarations} {type : Ty} {vars : WireValue Var} + {before after : BuildState F} (compiled : freshValue decls type before = .ok (vars, after)) + {calls : CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls initial) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + Bounded (F := F) after.nextVar (vars.map ArithExpr.var) := by + obtain ⟨typeLayout, expanded, _⟩ := freshValue_eq compiled + obtain ⟨assignment, ext, bound, _⟩ := freshValue_complete compiled layout valid + (zeroValue decls type) rfl (zeroValue_sized expanded) + exact ⟨assignment, ext, bound⟩ + +theorem validateValue_inactive [Field F] [DecidableEq F] {decls : Declarations} + {enable : ArithExpr F} {wire : Symbolic F} {before after : BuildState F} + (compiled : validateValue decls enable wire before = .ok ((), after)) + {calls : CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls initial) + (enableBound : enable.inBounds before.nextVar = true) (bounded : Bounded before.nextVar wire) + (zero : enable.denote initial = 0) : + ∃ assignment, Extension rom calls before after initial assignment := by + simp only [validateValue] at compiled + obtain ⟨type, middle, expanded, run⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := getLayout_eq expanded + exact validate_complete run layout valid enableBound bounded (Or.inl zero) + +theorem validateValues_inactive [Field F] [DecidableEq F] {decls : Declarations} + {enable : ArithExpr F} {wires : List (Symbolic F)} {before after : BuildState F} + (compiled : validateValues decls enable wires before = .ok ((), after)) + {calls : CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls initial) + (enableBound : enable.inBounds before.nextVar = true) + (bounded : ∀ wire ∈ wires, Bounded before.nextVar wire) (zero : enable.denote initial = 0) : + ∃ assignment, Extension rom calls before after initial assignment := by + induction wires generalizing before initial with + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp compiled + exact ⟨initial, .refl layout valid⟩ + | cons wire wires ih => + simp only [validateValues] at compiled + obtain ⟨⟨⟩, middle, headRun, tailRun⟩ := bind_ok.mp compiled + obtain ⟨a, headExt⟩ := validateValue_inactive headRun layout valid enableBound (bounded _ (by simp)) zero + obtain ⟨b, tailExt⟩ := ih tailRun headExt.layout headExt.valid (headExt.bound enableBound) + (fun w h => (bounded w (by simp [h])).mono headExt.increase) + ((headExt.polynomial enableBound).trans zero) + exact ⟨b, headExt.trans tailExt⟩ + +end Aiur.Circuit.Compiler diff --git a/Aiur/Aiur/Circuit/InactiveWitness.lean b/Aiur/Aiur/Circuit/InactiveWitness.lean new file mode 100644 index 000000000..7129f6982 --- /dev/null +++ b/Aiur/Aiur/Circuit/InactiveWitness.lean @@ -0,0 +1,426 @@ +import Aiur.Circuit.InactiveBasics + +namespace Aiur.Circuit.Compiler + +variable {F : Type} {rom : WireROM F} + +set_option maxHeartbeats 2000000 +set_option maxRecDepth 4096 + +mutual + /-- Disabled expressions still admit all unconditional pattern-test witnesses. -/ + theorem lowerExpr_inactive [Field F] [DecidableEq F] + {program : Program F} {function : String} {locals : Locals F} + {enable : ArithExpr F} {expr : Expr F} {output : Symbolic F} {before after : BuildState F} + (compiled : lowerExpr program function locals enable expr before = .ok (output, after)) + {calls : CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls initial) + (localsBound : LocalsBounded before.nextVar locals) + (enableBound : enable.inBounds before.nextVar = true) (inactive : enable.denote initial = 0) : + ∃ assignment, Extension rom calls before after initial assignment ∧ Bounded after.nextVar output := by + cases expr with + | literal value => + simp only [lowerExpr, pure_ok] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨initial, .refl layout valid, bounded_field.mpr rfl⟩ + | var name => + cases found : locals.find? (·.1 == name) with + | none => simp [lowerExpr, found] at compiled + | some binding => + obtain ⟨bindingName, value⟩ := binding + simp only [lowerExpr, found, pure_ok] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨initial, .refl layout valid, localsBound _ (List.mem_of_find?_eq_some found)⟩ + | tuple items => + simp only [lowerExpr] at compiled + obtain ⟨values, middle, itemsRun, finished⟩ := bind_ok.mp compiled + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨assignment, extension, bounded⟩ := + lowerArgs_inactive itemsRun layout valid localsBound enableBound inactive + exact ⟨assignment, extension, bounded_tuple.mpr bounded⟩ + | construct name ctor args => + cases found : program.enums.findEnum? name with + | none => simp [lowerExpr, found] at compiled + | some definition => + cases atIndex : definition.constructors[definition.constructors.findIdx (·.name == ctor)]? with + | none => simp [lowerExpr, found, atIndex] at compiled + | some constructor => + simp only [lowerExpr, found, atIndex] at compiled + obtain ⟨wires, s₁, argsRun, rest⟩ := bind_ok.mp compiled + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨typeLayout, middle, layoutRun, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := getLayout_eq layoutRun + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · obtain ⟨⟨⟩, middle, unchanged, finished⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, ext, valuesBound⟩ := lowerArgs_inactive argsRun layout valid localsBound enableBound inactive + refine ⟨a, ext, ?_⟩ + unfold Bounded + refine Layout.enumWords_all _ _ _ ?_ ?_ + · rfl + · intro polynomial member + simp only [List.mem_append] at member + rcases member with member | member + · obtain ⟨wire, member, leaf⟩ := List.mem_flatMap.mp member + exact valuesBound wire member polynomial leaf + · have zero : polynomial = .const 0 := List.eq_of_mem_replicate member + subst polynomial; rfl + | project value index => + simp only [lowerExpr] at compiled + obtain ⟨input, middle, valueRun, rest⟩ := bind_ok.mp compiled + rcases input with ⟨type, words⟩ + cases type with + | field | ptr | enum => simp at rest + | tuple types => + dsimp only at rest + obtain ⟨items, last, splitRun, rest⟩ := bind_ok.mp rest + have unchanged := (splitValues_spec splitRun).1 + subst last + cases projected : items[index]? with + | none => simp [projected] at rest + | some result => + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [projected] using rest) + obtain ⟨a, ext, bounded⟩ := lowerExpr_inactive valueRun layout valid localsBound enableBound inactive + exact ⟨a, ext, splitValues_bounded splitRun bounded result (List.mem_of_getElem? projected)⟩ + | letValue pattern value body => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, valueRun, rest⟩ := bind_ok.mp compiled + obtain ⟨⟨test, bindings⟩, s₂, patternRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₃, guardRun, bodyRun⟩ := bind_ok.mp rest + cases finished + obtain ⟨a, e₁, inputBound⟩ := lowerExpr_inactive valueRun layout valid localsBound enableBound inactive + obtain ⟨b, e₂, testBound, bindingsBound⟩ := lowerPattern_complete patternRun e₁.layout e₁.valid inputBound + have chainExt := e₁.trans e₂ + have e₃ := guarded_complete guardRun e₂.layout e₂.valid (chainExt.bound enableBound) + (by simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using testBound) + (Or.inl ((chainExt.polynomial enableBound).trans inactive)) + obtain ⟨c, e₄, bodyBound⟩ := lowerExpr_inactive bodyRun e₃.layout e₃.valid + (localsBounded_append.mpr ⟨bindingsBound.mono e₃.increase, localsBound.mono (chainExt.trans e₃).increase⟩) + ((chainExt.trans e₃).bound enableBound) (((chainExt.trans e₃).polynomial enableBound).trans inactive) + exact ⟨c, (chainExt.trans e₃).trans e₄, bodyBound⟩ + | store operand => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, operandRun, rest⟩ := bind_ok.mp compiled + obtain ⟨id, s₂, addressRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₃, booleanRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₄, validationRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₅, cellRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, e₁, inputBound⟩ := lowerExpr_inactive operandRun layout valid localsBound enableBound inactive + obtain ⟨b, e₂, addressBound, _⟩ := fresh_complete addressRun e₁.layout e₁.valid 0 + have chainExt := e₁.trans e₂ + have e₃ := boolean_complete booleanRun e₂.layout e₂.valid (chainExt.bound enableBound) + (Or.inl ((chainExt.polynomial enableBound).trans inactive)) + have ab : (ArithExpr.var id : ArithExpr F).inBounds s₂.nextVar = true := by + simpa [Scalar.Circuit.ArithExpr.inBounds] using addressBound + have throughBoolean := chainExt.trans e₃ + obtain ⟨c, e₄⟩ := validateValue_inactive validationRun e₃.layout e₃.valid + (throughBoolean.bound enableBound) (inputBound.mono (e₂.trans e₃).increase) + ((throughBoolean.polynomial enableBound).trans inactive) + have throughValidation := throughBoolean.trans e₄ + have e₅ := requireCell_complete cellRun e₄.layout e₄.valid + (throughValidation.bound enableBound) ((e₃.trans e₄).bound ab) + (inputBound.mono ((e₂.trans e₃).trans e₄).increase) (by + intro active + have zero := (throughValidation.polynomial enableBound).trans inactive + exact (zero_ne_one (zero.symm.trans active)).elim) + exact ⟨c, throughValidation.trans e₅, by + simpa only [bounded_ptr] using ((e₃.trans e₄).trans e₅).bound ab⟩ + | load operand => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, operandRun, rest⟩ := bind_ok.mp compiled + rcases input with ⟨type, words⟩ + cases type with + | field | tuple | enum => simp at rest + | ptr target => + cases words with + | nil => simp at rest + | cons address words => cases words with + | cons => simp at rest + | nil => + dsimp only at rest + obtain ⟨result, s₂, resultRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₃, booleanRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₄, validationRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₅, cellRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, e₁, inputBound⟩ := lowerExpr_inactive operandRun layout valid localsBound enableBound inactive + obtain ⟨b, e₂, resultBound⟩ := freshValue_zero_complete resultRun e₁.layout e₁.valid + have chainExt := e₁.trans e₂ + have e₃ := boolean_complete booleanRun e₂.layout e₂.valid (chainExt.bound enableBound) + (Or.inl ((chainExt.polynomial enableBound).trans inactive)) + have throughBoolean := chainExt.trans e₃ + obtain ⟨c, e₄⟩ := validateValue_inactive validationRun e₃.layout e₃.valid + (throughBoolean.bound enableBound) (resultBound.mono e₃.increase) + ((throughBoolean.polynomial enableBound).trans inactive) + have throughValidation := throughBoolean.trans e₄ + have e₅ := requireCell_complete cellRun e₄.layout e₄.valid + (throughValidation.bound enableBound) (((e₂.trans e₃).trans e₄).bound (inputBound address (by simp))) + (resultBound.mono (e₃.trans e₄).increase) (by + intro active + have zero := (throughValidation.polynomial enableBound).trans inactive + exact (zero_ne_one (zero.symm.trans active)).elim) + exact ⟨c, throughValidation.trans e₅, resultBound.mono ((e₃.trans e₄).trans e₅).increase⟩ + | hint type key channel => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, keyRun, rest⟩ := bind_ok.mp compiled + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨result, s₂, freshRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₃, validationRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, e₁, _⟩ := lowerExpr_inactive keyRun layout valid localsBound enableBound inactive + obtain ⟨b, e₂, resultBound⟩ := freshValue_zero_complete freshRun e₁.layout e₁.valid + have ext := e₁.trans e₂ + obtain ⟨c, e₃⟩ := validateValue_inactive validationRun e₂.layout e₂.valid + (ext.bound enableBound) resultBound ((ext.polynomial enableBound).trans inactive) + exact ⟨c, ext.trans e₃, resultBound.mono e₃.increase⟩ + | neg value => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, valueRun, rest⟩ := bind_ok.mp compiled + obtain ⟨polynomial, s₂, fieldRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_ok fieldRun + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, extension, bounded⟩ := lowerExpr_inactive valueRun layout valid localsBound enableBound inactive + exact ⟨a, extension, by simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using bounded⟩ + | assertEq message left right => + simp only [lowerExpr] at compiled + obtain ⟨leftWire, s₁, leftRun, rest⟩ := bind_ok.mp compiled + obtain ⟨rightWire, s₂, rightRun, rest⟩ := bind_ok.mp rest + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨⟨⟩, last, equated, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, e₁, leftBound⟩ := lowerExpr_inactive leftRun layout valid localsBound enableBound inactive + obtain ⟨b, e₂, rightBound⟩ := lowerExpr_inactive rightRun e₁.layout e₁.valid + (localsBound.mono e₁.increase) (e₁.bound enableBound) ((e₁.polynomial enableBound).trans inactive) + have chainExt := e₁.trans e₂ + have e₃ := constrainValue_complete equated e₂.layout e₂.valid (chainExt.bound enableBound) + (leftBound.mono e₂.increase) rightBound (Or.inl ((chainExt.polynomial enableBound).trans inactive)) + exact ⟨b, chainExt.trans e₃, bounded_tuple.mpr (by simp)⟩ + | binary op left right => + simp only [lowerExpr] at compiled + obtain ⟨leftValue, s₁, leftRun, rest⟩ := bind_ok.mp compiled + obtain ⟨leftPoly, s₂, leftField, rest⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_ok leftField + obtain ⟨rightValue, s₃, rightRun, rest⟩ := bind_ok.mp rest + obtain ⟨rightPoly, s₄, rightField, rest⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_ok rightField + obtain ⟨a, e₁, leftBound⟩ := lowerExpr_inactive leftRun layout valid localsBound enableBound inactive + obtain ⟨b, e₂, rightBound⟩ := lowerExpr_inactive rightRun e₁.layout e₁.valid + (localsBound.mono e₁.increase) (e₁.bound enableBound) ((e₁.polynomial enableBound).trans inactive) + have chainExt := e₁.trans e₂ + have lb := bounded_field.mp (leftBound.mono e₂.increase) + have rb := bounded_field.mp rightBound + cases op with + | add | sub | mul => + obtain ⟨rfl, rfl⟩ := pure_ok.mp rest + exact ⟨b, chainExt, by simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using And.intro lb rb⟩ + | div => + obtain ⟨inverse, s₅, freshRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₆, inverseRun, finishedRun⟩ := bind_ok.mp rest + cases finished + obtain ⟨rfl, rfl⟩ := pure_ok.mp finishedRun + obtain ⟨c, e₃, invBound, _⟩ := fresh_complete freshRun e₂.layout e₂.valid 0 + have ib : (ArithExpr.var inverse : ArithExpr F).inBounds s₅.nextVar = true := by + simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using invBound + have e₄ := guarded_complete inverseRun e₃.layout e₃.valid ((chainExt.trans e₃).bound enableBound) + (by simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using And.intro (e₃.bound rb) ib) + (Or.inl (((chainExt.trans e₃).polynomial enableBound).trans inactive)) + exact ⟨c, (chainExt.trans e₃).trans e₄, by + simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + And.intro ((e₃.trans e₄).bound lb) (e₄.bound ib)⟩ + | call name args => + cases found : program.findSignature? name with + | none => simp [lowerExpr, found] at compiled + | some callee => + simp only [lowerExpr, found] at compiled + obtain ⟨arguments, s₁, argsRun, rest⟩ := bind_ok.mp compiled + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨result, s₂, resultRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₃, booleanRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₄, argsValidation, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₅, resultValidation, rest⟩ := bind_ok.mp rest + simp [StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at rest + obtain ⟨rfl, rfl⟩ := rest + obtain ⟨a, e₁, argsBound⟩ := lowerArgs_inactive argsRun layout valid localsBound enableBound inactive + obtain ⟨b, e₂, resultBound⟩ := freshValue_zero_complete resultRun e₁.layout e₁.valid + have chainExt := e₁.trans e₂ + have e₃ := boolean_complete booleanRun e₂.layout e₂.valid (chainExt.bound enableBound) + (Or.inl ((chainExt.polynomial enableBound).trans inactive)) + have throughBoolean := chainExt.trans e₃ + obtain ⟨c, e₄⟩ := validateValues_inactive argsValidation e₃.layout e₃.valid + (throughBoolean.bound enableBound) (fun w h => (argsBound w h).mono (e₂.trans e₃).increase) + ((throughBoolean.polynomial enableBound).trans inactive) + have throughArgs := throughBoolean.trans e₄ + obtain ⟨d, e₅⟩ := validateValue_inactive resultValidation e₄.layout e₄.valid + (throughArgs.bound enableBound) (resultBound.mono (e₃.trans e₄).increase) + ((throughArgs.polynomial enableBound).trans inactive) + have throughResult := throughArgs.trans e₅ + have e₆ := send_complete e₅.layout e₅.valid ⟨name, arguments, result, enable⟩ + (send_bounded (fun value h => (argsBound value h).mono (((e₂.trans e₃).trans e₄).trans e₅).increase) + (resultBound.mono ((e₃.trans e₄).trans e₅).increase) (throughResult.bound enableBound)) (by + intro active + have zero := (throughResult.polynomial enableBound).trans inactive + exact (zero_ne_one (zero.symm.trans active)).elim) + exact ⟨d, throughResult.trans e₆, resultBound.mono (((e₃.trans e₄).trans e₅).trans e₆).increase⟩ + | matchValue scrutinee arms => + simp only [lowerExpr] at compiled + obtain ⟨checked, s₁, checkRun, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := lift_eq_ok checkRun + obtain ⟨type, s₂, typeRun, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := lift_eq_ok typeRun + obtain ⟨input, s₃, scrutineeRun, rest⟩ := bind_ok.mp rest + obtain ⟨result, s₄, resultRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₅, validationRun, rest⟩ := bind_ok.mp rest + obtain ⟨selectors, s₆, armsRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₇, exclusionRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₈, sumRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, e₁, inputBound⟩ := lowerExpr_inactive scrutineeRun layout valid localsBound enableBound inactive + obtain ⟨b, e₂, resultBound⟩ := freshValue_zero_complete resultRun e₁.layout e₁.valid + have initialExt := e₁.trans e₂ + obtain ⟨v, validationExt⟩ := validateValue_inactive validationRun e₂.layout e₂.valid + (initialExt.bound enableBound) resultBound ((initialExt.polynomial enableBound).trans inactive) + have chainExt := initialExt.trans validationExt + obtain ⟨c, e₃, selectorsBound, selectorsZero⟩ := lowerArms_inactive armsRun validationExt.layout validationExt.valid + (localsBound.mono chainExt.increase) (inputBound.mono (e₂.trans validationExt).increase) + (resultBound.mono validationExt.increase) + (chainExt.bound enableBound) ((chainExt.polynomial enableBound).trans inactive) + have selection := Scalar.Circuit.SelectorsValid.zeros + (selectors := selectors.map (ArithExpr.denote c)) (by + simpa only [List.forall_mem_map] using selectorsZero) + have e₄ := excludePairs_complete exclusionRun e₃.layout e₃.valid selectorsBound selection.exclusive + have e₅ := sum_complete sumRun e₄.layout e₄.valid + (fun p h => e₄.bound (selectorsBound p h)) (((chainExt.trans e₃).trans e₄).bound enableBound) + (by rw [((chainExt.trans e₃).trans e₄).polynomial enableBound, inactive]; exact selection.sum) + exact ⟨c, ((chainExt.trans e₃).trans e₄).trans e₅, + resultBound.mono (((validationExt.trans e₃).trans e₄).trans e₅).increase⟩ + termination_by sizeOf expr + + theorem lowerArgs_inactive [Field F] [DecidableEq F] + {program : Program F} {function : String} {locals : Locals F} {enable : ArithExpr F} + {args : List (Expr F)} {outputs : List (Symbolic F)} {before after : BuildState F} + (compiled : lowerArgs program function locals enable args before = .ok (outputs, after)) + {calls : CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls initial) + (localsBound : LocalsBounded before.nextVar locals) + (enableBound : enable.inBounds before.nextVar = true) (inactive : enable.denote initial = 0) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + ∀ value ∈ outputs, Bounded after.nextVar value := by + cases args with + | nil => + simp only [lowerArgs, pure_ok] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨initial, .refl layout valid, by simp⟩ + | cons arg args => + simp only [lowerArgs] at compiled + obtain ⟨head, middle, headRun, rest⟩ := bind_ok.mp compiled + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, e₁, headBound⟩ := lowerExpr_inactive headRun layout valid localsBound enableBound inactive + obtain ⟨b, e₂, tailBound⟩ := lowerArgs_inactive tailRun e₁.layout e₁.valid + (localsBound.mono e₁.increase) (e₁.bound enableBound) ((e₁.polynomial enableBound).trans inactive) + refine ⟨b, e₁.trans e₂, ?_⟩ + intro value member + rcases List.mem_cons.mp member with rfl | member + · exact headBound.mono e₂.increase + · exact tailBound value member + termination_by sizeOf args + + theorem lowerArms_inactive [Field F] [DecidableEq F] + {program : Program F} {function : String} {locals : Locals F} + {scrutinee result : Symbolic F} {remaining : ArithExpr F} + {arms : List (Pattern F × Expr F)} {selectors : List (ArithExpr F)} {before after : BuildState F} + (compiled : lowerArms program function locals scrutinee result remaining arms before = .ok (selectors, after)) + {calls : CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls initial) + (localsBound : LocalsBounded before.nextVar locals) + (inputBound : Bounded before.nextVar scrutinee) (resultBound : Bounded before.nextVar result) + (remainingBound : remaining.inBounds before.nextVar = true) (inactive : remaining.denote initial = 0) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + (∀ selector ∈ selectors, selector.inBounds after.nextVar = true) ∧ + (∀ selector ∈ selectors, selector.denote assignment = 0) := by + cases arms with + | nil => + simp only [lowerArms, pure_ok] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨initial, .refl layout valid, by simp, by simp⟩ + | cons arm arms => + rcases hArm : arm with ⟨pattern, body⟩ + simp only [hArm, lowerArms] at compiled + obtain ⟨⟨test, bindings⟩, s₁, patternRun, rest⟩ := bind_ok.mp compiled + obtain ⟨selector, s₂, freshRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₃, booleanRun, rest⟩ := bind_ok.mp rest + cases finished + obtain ⟨finished, s₄, equationRun, rest⟩ := bind_ok.mp rest + cases finished + obtain ⟨bodyValue, s₅, bodyRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₆, valueRun, rest⟩ := bind_ok.mp rest + cases finished + obtain ⟨a, e₁, testBound, bindingsBound⟩ := lowerPattern_complete patternRun layout valid inputBound + obtain ⟨b, e₂, idBound, selZero⟩ := fresh_complete freshRun e₁.layout e₁.valid 0 + have selectorBound : (ArithExpr.var selector : ArithExpr F).inBounds s₂.nextVar = true := by + simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using idBound + have e₃ := boolean_complete booleanRun e₂.layout e₂.valid selectorBound (Or.inl selZero) + have chainExt := (e₁.trans e₂).trans e₃ + have e₄ := constrain_complete equationRun e₃.layout e₃.valid + (by simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + And.intro (e₃.bound selectorBound) (And.intro (chainExt.bound remainingBound) ((e₂.trans e₃).bound testBound))) + (by change b selector - remaining.denote b * test.denote b = 0 + rw [selZero, chainExt.polynomial remainingBound, inactive]; simp) + obtain ⟨c, e₅, bodyBound⟩ := lowerExpr_inactive bodyRun e₄.layout e₄.valid + (localsBounded_append.mpr ⟨bindingsBound.mono ((e₂.trans e₃).trans e₄).increase, + localsBound.mono (chainExt.trans e₄).increase⟩) + ((e₃.trans e₄).bound selectorBound) + (by simpa only [ArithExpr.denote, Scalar.Circuit.ArithExpr.denote] using selZero) + have selZeroC : (ArithExpr.var selector : ArithExpr F).denote c = 0 := + ((e₃.trans e₄).trans e₅).polynomial selectorBound |>.trans selZero + have headExt := (chainExt.trans e₄).trans e₅ + have e₆ := constrainValue_complete valueRun e₅.layout e₅.valid + (((e₃.trans e₄).trans e₅).bound selectorBound) (resultBound.mono headExt.increase) bodyBound (Or.inl selZeroC) + have total := headExt.trans e₆ + have finalBound := (((e₃.trans e₄).trans e₅).trans e₆).bound selectorBound + split at rest + · obtain ⟨rfl, rfl⟩ := pure_ok.mp rest + exact ⟨c, total, by simpa using finalBound, by simpa using selZeroC⟩ + · simp only [pure_bind] at rest + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + have nextBound : (ArithExpr.mul remaining (.sub (.const 1) test)).inBounds s₆.nextVar = true := by + simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + And.intro (total.bound remainingBound) (((((e₂.trans e₃).trans e₄).trans e₅).trans e₆).bound testBound) + have nextZero : (ArithExpr.mul remaining (.sub (.const 1) test)).denote c = 0 := by + change remaining.denote c * (1 - test.denote c) = 0 + rw [total.polynomial remainingBound, inactive, zero_mul] + obtain ⟨d, tailExt, tailBound, tailZero⟩ := lowerArms_inactive tailRun total.layout total.valid + (localsBound.mono total.increase) (inputBound.mono total.increase) (resultBound.mono total.increase) + nextBound nextZero + refine ⟨d, total.trans tailExt, ?_, ?_⟩ + · intro p member + rcases List.mem_cons.mp member with rfl | member + · exact tailExt.bound finalBound + · exact tailBound p member + · intro p member + rcases List.mem_cons.mp member with rfl | member + · exact (tailExt.polynomial finalBound).trans selZeroC + · exact tailZero p member + termination_by sizeOf arms + decreasing_by + all_goals simp only [*, Prod.mk.sizeOf_spec, List.cons.sizeOf_spec] + all_goals omega +end + +end Aiur.Circuit.Compiler diff --git a/Aiur/Aiur/Circuit/Indicator.lean b/Aiur/Aiur/Circuit/Indicator.lean new file mode 100644 index 000000000..cdf7a33dc --- /dev/null +++ b/Aiur/Aiur/Circuit/Indicator.lean @@ -0,0 +1,23 @@ +import Aiur.Circuit.BuildFacts +import Aiur.Circuit.PatternFacts + +namespace Aiur.Circuit.Compiler + +variable {F : Type} {rom : WireROM F} + +theorem equalIndicator_sound [Field F] [DecidableEq F] + {difference test : ArithExpr F} {before after : BuildState F} + (compiled : equalIndicator difference before = .ok (test, after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid rom calls assignment) : + before.Valid rom calls assignment ∧ + test.denote assignment = if difference.denote assignment = 0 then 1 else 0 := by + simp [equalIndicator, StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at compiled + obtain ⟨rfl, rfl⟩ := compiled + refine ⟨valid.of_subset (fun _ member => by simp [member]) (fun _ member => member) (fun _ member => member), ?_⟩ + apply equality_indicator_sound + · exact valid.constraints (.mul difference (.var before.nextVar)) (by simp) + · exact valid.constraints + (.sub (.mul difference (.var (before.nextVar + 1))) + (.sub (.const 1) (.var before.nextVar))) (by simp) + +end Aiur.Circuit.Compiler diff --git a/Aiur/Aiur/Circuit/IndicatorWitness.lean b/Aiur/Aiur/Circuit/IndicatorWitness.lean new file mode 100644 index 000000000..2ecdd0668 --- /dev/null +++ b/Aiur/Aiur/Circuit/IndicatorWitness.lean @@ -0,0 +1,61 @@ +import Aiur.Circuit.WitnessBasic + +namespace Aiur.Circuit.Compiler + +variable {F : Type} {rom : WireROM F} + +theorem equalIndicator_complete [Field F] [DecidableEq F] + {difference test : ArithExpr F} {before after : BuildState F} + (compiled : equalIndicator difference before = .ok (test, after)) + {calls : CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls initial) + (bounded : difference.inBounds before.nextVar = true) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + test.inBounds after.nextVar = true := by + simp [equalIndicator, StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at compiled + obtain ⟨rfl, rfl⟩ := compiled + let equal : F := if difference.denote initial = 0 then 1 else 0 + let assignment := Function.update (Function.update initial before.nextVar equal) + (before.nextVar + 1) (difference.denote initial)⁻¹ + have agree : ∀ id < before.nextVar, assignment id = initial id := by + intro id bound + simp [assignment, Function.update_of_ne (by omega : id ≠ before.nextVar + 1), + Function.update_of_ne (by omega : id ≠ before.nextVar)] + have dEq : difference.denote assignment = difference.denote initial := + Scalar.Circuit.ArithExpr.denote_eq_of_agree agree bounded + have eEq : assignment before.nextVar = equal := by simp [assignment] + have uEq : assignment (before.nextVar + 1) = (difference.denote initial)⁻¹ := by simp [assignment] + have equations := equality_indicator_complete (difference.denote initial) + have grown := layout.grow (by omega : before.nextVar ≤ before.nextVar + 1 + 1) + have db := Scalar.Circuit.ArithExpr.inBounds_mono + (by omega : before.nextVar ≤ before.nextVar + 1 + 1) bounded + have lo : before.nextVar < before.nextVar + 1 + 1 := by omega + have hi : before.nextVar + 1 < before.nextVar + 1 + 1 := by omega + have firstBound : (ArithExpr.mul (.var before.nextVar) + (.sub (.var before.nextVar) (.const (1 : F)))).inBounds (before.nextVar + 1 + 1) = true := by + simp [Scalar.Circuit.ArithExpr.inBounds, lo] + have secondBound : (ArithExpr.mul difference (.var before.nextVar)).inBounds + (before.nextVar + 1 + 1) = true := by + simp [Scalar.Circuit.ArithExpr.inBounds, lo, db] + have thirdBound : (ArithExpr.sub (.mul difference (.var (before.nextVar + 1))) + (.sub (.const 1) (.var before.nextVar))).inBounds (before.nextVar + 1 + 1) = true := by + simp [Scalar.Circuit.ArithExpr.inBounds, lo, hi, db] + have grownValid : ({ before with nextVar := before.nextVar + 1 + 1 } : BuildState F).Valid rom calls assignment := + ⟨(valid.of_agree layout agree).constraints, (valid.of_agree layout agree).calls, (valid.of_agree layout agree).memory⟩ + have firstZero : (ArithExpr.mul (.var before.nextVar) + (.sub (.var before.nextVar) (.const (1 : F)))).denote assignment = 0 := by + simpa only [ArithExpr.denote, Scalar.Circuit.ArithExpr.denote, eEq, equal] using equations.1 + have secondZero : (ArithExpr.mul difference (.var before.nextVar)).denote assignment = 0 := by + change difference.denote assignment * assignment before.nextVar = 0 + simpa only [dEq, eEq, equal] using equations.2.1 + have thirdZero : (ArithExpr.sub (.mul difference (.var (before.nextVar + 1))) + (.sub (.const 1) (.var before.nextVar))).denote assignment = 0 := by + change difference.denote assignment * assignment (before.nextVar + 1) - (1 - assignment before.nextVar) = 0 + simpa only [dEq, uEq, eEq, equal] using equations.2.2 + exact ⟨assignment, ⟨by dsimp; omega, agree, + ((grown.constrain firstBound).constrain secondBound).constrain thirdBound, + ((grownValid.constrain firstZero).constrain secondZero).constrain thirdZero⟩, + by simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using lo⟩ + + +end Aiur.Circuit.Compiler diff --git a/Aiur/Aiur/Circuit/LocalCorrectness.lean b/Aiur/Aiur/Circuit/LocalCorrectness.lean new file mode 100644 index 000000000..05b67fdea --- /dev/null +++ b/Aiur/Aiur/Circuit/LocalCorrectness.lean @@ -0,0 +1,85 @@ +import Aiur.Circuit.ExpressionCorrectness +import Aiur.Circuit.CompileFacts + +namespace Aiur.Circuit + +variable {F : Type} {rom : WireROM F} + +theorem Chip.premises_forall [Field F] [DecidableEq F] (chip : Chip F) (row : Row F) + (property : Message F → Prop) : + (∀ message ∈ chip.premises row, property message) ↔ + ∀ send ∈ chip.sends, send.enable.denote row.assignment = 1 → + property (send.message row.assignment) := by + constructor + · intro valid send member enabled + apply valid (send.message row.assignment) + apply List.mem_filterMap.mpr + exact ⟨send, member, by simp [enabled]⟩ + · intro valid message member + obtain ⟨send, sendMember, selected⟩ := List.mem_filterMap.mp member + split at selected + · rename_i enabled + cases selected + exact valid send sendMember enabled + · cases selected + +namespace Compiler + +theorem parameter_environment [Field F] (names : List String) (inputs : List (WireValue Var)) + (assignment : Var → F) : + localsEnvironment (names.zip (inputs.map (WireValue.map ArithExpr.var))) assignment = + names.zip (inputs.map (WireValue.map assignment)) := by + induction names generalizing inputs with + | nil => simp [localsEnvironment] + | cons name names ih => + cases inputs with + | nil => simp [localsEnvironment] + | cons input inputs => + simp only [List.map_cons, List.zip_cons_cons] + change (name, _) :: localsEnvironment _ assignment = _ + rw [ih] + simp only [WireValue.map_map] + rfl + +/-- A valid row has canonical interface values and realizes its function body. -/ +theorem lowerFunction_sound [Field F] [DecidableEq F] + {program : Program F} (checked : checkDeclarations program.enums = .ok ()) + (tags : program.enums.tagsValid F = true) {fn : Function F} {chip : Chip F} + (compiled : lowerFunction program fn = .ok chip) + {sourceCalls : Aiur.CallRelation F} {row : Row F} (valid : chip.ValidRow rom row) + (premises : ∀ message ∈ chip.premises row, ∀ args result, + DecodesValues program.enums message.args args → message.result.decode program.enums = some result → + sourceCalls message.channel args result) : + ∃ args result, DecodesValues program.enums (chip.receive row).args args ∧ + (chip.receive row).result.decode program.enums = some result ∧ + ROMEvalExprWith program.enums (rom.decode program.enums) sourceCalls + ((fn.params.map Prod.fst).zip args) fn.body result := by + let calls : Circuit.CallRelation F := fun name args result => ⟨name, args, result⟩ ∈ chip.premises row + have callSound : CallsSound program.enums calls sourceCalls := fun name args result member => + premises ⟨name, args, result⟩ member + obtain ⟨inputs, output, s₁, s₂, s₃, s₄, body, s₅, s₆, + _, _, inputValidation, outputValidation, bodyRun, outputRun, rfl⟩ := lowerFunction_stages compiled + have stateValid : s₆.Valid rom calls row.assignment := ⟨valid.2.2.1, + (Chip.premises_forall _ row (fun message => calls message.channel message.args message.result)).mp + (fun _ h => h), valid.2.2.2⟩ + obtain ⟨s₅valid, resultEq⟩ := constrainValue_sound outputRun stateValid + obtain ⟨s₄valid, evaluated⟩ := lowerExpr_sound checked tags callSound bodyRun s₅valid + have s₃valid := (validateValue_sound checked outputValidation s₄valid).1 + have inputDecoded := (validateValues_sound checked inputValidation s₃valid).2 rfl + have allInputs : ∀ wire ∈ inputs.map (WireValue.map row.assignment), + ∃ value, wire.decode program.enums = some value := by + intro wire member + obtain ⟨input, inputMember, rfl⟩ := List.mem_map.mp member + simpa only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using inputDecoded (input.map ArithExpr.var) (List.mem_map.mpr ⟨input, inputMember, rfl⟩) + obtain ⟨args, decoded⟩ := DecodesValues.exists_of_each allInputs + obtain ⟨result, resultDecode, bodyEval⟩ := evaluated rfl ((fn.params.map Prod.fst).zip args) + (by simpa only [parameter_environment] using decoded.environment (fn.params.map Prod.fst)) + refine ⟨args, result, decoded, ?_, bodyEval⟩ + have equal := resultEq rfl + simp only [WireValue.map_map] at equal + change output.map row.assignment = body.map (ArithExpr.denote row.assignment) at equal + simpa only [Chip.receive, WireValue.map_map, Function.comp_def, + ArithExpr.denote, Scalar.Circuit.ArithExpr.denote, equal] using resultDecode + +end Compiler +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/LocalWitness.lean b/Aiur/Aiur/Circuit/LocalWitness.lean new file mode 100644 index 000000000..dee0934e8 --- /dev/null +++ b/Aiur/Aiur/Circuit/LocalWitness.lean @@ -0,0 +1,76 @@ +import Aiur.Circuit.ExpressionWitness +import Aiur.Circuit.ParameterWitness +import Aiur.Circuit.LocalCorrectness +import Aiur.Circuit.RowWitness + +namespace Aiur.Circuit.Compiler + +variable {F : Type} {rom : WireROM F} + +/-- Every finite source body evaluation supplies a row with canonical interface encodings. -/ +theorem lowerFunction_complete [Field F] [DecidableEq F] + {program : Program F} (declarations : checkDeclarations program.enums = .ok ()) + (tags : program.enums.tagsValid F = true) {fn : Function F} {chip : Chip F} + (compiled : lowerFunction program fn = .ok chip) + {calls : Circuit.CallRelation F} {sourceCalls : Aiur.CallRelation F} + (typed : CallsTyped program sourceCalls) (callComplete : CallsComplete program.enums sourceCalls calls) + (checked : inferType program fn.name fn.params fn.body = .ok fn.result) + {args : List (Value F)} {value : Value F} + (types : fn.params.map Prod.snd = args.map Value.type) + (formed : ∀ arg ∈ args, arg.wellFormed program.enums = true) + (evaluated : ROMEvalExprWith program.enums (rom.decode program.enums) sourceCalls + ((fn.params.map Prod.fst).zip args) fn.body value) : + ∃ row, row.chip = fn.name ∧ chip.ValidRow rom row ∧ + DecodesValues program.enums (chip.receive row).args args ∧ + (chip.receive row).result.decode program.enums = some value ∧ + ∀ message ∈ chip.premises row, calls message.channel message.args message.result := by + have resultType := evaluated.wellTyped typed (WireROM.decode_wellFormed program.enums rom) + (parameter_wellFormed formed) fn.name fn.result (by rw [parameter_types fn.params args types]; exact checked) + obtain ⟨inputs, output, s₁, s₂, s₃, s₄, body, s₅, s₆, + inputsRun, outputRun, inputsValidation, outputValidation, bodyRun, constraintRun, rfl⟩ := lowerFunction_stages compiled + have emptyLayout : ({} : BuildState F).WellFormed := ⟨by simp, by simp, by simp⟩ + have emptyValid : ({} : BuildState F).Valid rom calls (fun _ => 0) := + ⟨by simp [Satisfies, Scalar.Circuit.Satisfies], by simp, by simp⟩ + obtain ⟨a, e₁, inputsBound, inputsDecode⟩ := freshValues_decoded_complete declarations tags inputsRun + emptyLayout emptyValid args types.symm formed + have inputSymbolicBound : ∀ wire ∈ inputs.map (WireValue.map ArithExpr.var), Bounded (F := F) s₁.nextVar wire := by + simpa only [List.forall_mem_map] using inputsBound + have inputsDecodeA : DecodesValues program.enums + ((inputs.map (WireValue.map ArithExpr.var)).map (WireValue.map (ArithExpr.denote a))) args := by + simpa only [List.map_map, Function.comp_def, WireValue.map_map, ArithExpr.denote, Scalar.Circuit.ArithExpr.denote] using inputsDecode + obtain ⟨b, e₂, outputBound, outputDecode⟩ := freshValue_decoded_complete declarations tags outputRun + e₁.layout e₁.valid value resultType.1 resultType.2 + have outputDecodeB : ((output.map ArithExpr.var).map (ArithExpr.denote b)).decode program.enums = some value := by + simpa only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using outputDecode + obtain ⟨c, e₃⟩ := validateValues_complete tags inputsValidation e₂.layout e₂.valid rfl + (fun wire member => (inputSymbolicBound wire member).mono e₂.increase) + (Or.inr (fun wire member => (e₂.decoded_values inputSymbolicBound inputsDecodeA).each + (wire.map (ArithExpr.denote b)) (List.mem_map.mpr ⟨wire, member, rfl⟩))) + obtain ⟨d, e₄⟩ := validateValue_complete tags outputValidation e₃.layout e₃.valid rfl + (outputBound.mono e₃.increase) (Or.inr ⟨value, e₃.decoded_value outputBound outputDecodeB⟩) + have throughInterface := (e₂.trans e₃).trans e₄ + have argsDecodeD : DecodesValues program.enums (inputs.map (WireValue.map d)) args := by + simpa only [List.map_map, Function.comp_def, WireValue.map_map, ArithExpr.denote, Scalar.Circuit.ArithExpr.denote] using throughInterface.decoded_values inputSymbolicBound inputsDecodeA + obtain ⟨e, e₅, bodyBound, bodyDecode⟩ := lowerExpr_complete declarations tags typed callComplete bodyRun + e₄.layout e₄.valid (parameter_bounded (fun input member => (inputsBound input member).mono throughInterface.increase)) + rfl rfl (by simpa only [parameter_environment] using argsDecodeD.environment (fn.params.map Prod.fst)) evaluated + have throughOutput := (e₃.trans e₄).trans e₅ + have e₆ := constrainValue_decoded_complete declarations constraintRun e₅.layout e₅.valid rfl + (outputBound.mono throughOutput.increase) bodyBound (throughOutput.decoded_value outputBound outputDecodeB) bodyDecode + let row := Row.ofAssignment fn.name s₆.nextVar e + have finiteExt := BuildState.finite_witness e₆.layout e₆.valid fn.name + have inputFinal : ∀ input ∈ inputs, Bounded (F := F) s₆.nextVar (input.map ArithExpr.var) := + fun input member => (inputsBound input member).mono ((throughInterface.trans e₅).trans e₆).increase + have outputFinal := outputBound.mono (throughOutput.trans e₆).increase + have rowValid : (Chip.mk fn.name inputs (output.map ArithExpr.var) s₆.nextVar s₆.constraints.toList s₆.sends.toList s₆.memory.toList).ValidRow rom row := + ⟨chip_wellFormed e₆.layout inputFinal outputFinal, Row.ofAssignment_length _ _ _, + finiteExt.valid.constraints, finiteExt.valid.memory⟩ + refine ⟨row, rfl, rowValid, ?_, ?_, ?_⟩ + · simpa only [Chip.receive, List.map_map, Function.comp_def, WireValue.map_map, ArithExpr.denote, Scalar.Circuit.ArithExpr.denote] using + (((throughInterface.trans e₅).trans e₆).trans finiteExt).decoded_values inputSymbolicBound inputsDecodeA + · simpa only [Chip.receive, WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using + ((throughOutput.trans e₆).trans finiteExt).decoded_value outputBound outputDecodeB + · exact (Chip.premises_forall _ row (fun message => + calls message.channel message.args message.result)).mpr finiteExt.valid.calls + +end Aiur.Circuit.Compiler diff --git a/Aiur/Aiur/Circuit/MapFacts.lean b/Aiur/Aiur/Circuit/MapFacts.lean new file mode 100644 index 000000000..9229a7580 --- /dev/null +++ b/Aiur/Aiur/Circuit/MapFacts.lean @@ -0,0 +1,111 @@ +import Aiur.Circuit.CompileFacts +import Aiur.TableChecking +import Aiur.WireRelation +import Aiur.Memory.WireEncoding + +namespace Aiur.Circuit + +variable {F : Type} + +set_option linter.unusedSimpArgs false + +theorem compile_mapClaims [Field F] [DecidableEq F] + {program : Program F} {system : System F} (compiled : compile program = .ok system) + (message : Message F) : + system.MapClaim message ↔ ∃ map ∈ program.maps, ∃ entry ∈ program.mapEntries map, + encodeMapEntry program.enums map.name entry = some message := by + have stages := compile_stages compiled + simp only [System.MapClaim, System.mapClaims, stages.2.2.2.1, + stages.2.2.2.2.1, stages.2.2.2.2.2, List.mem_flatMap, List.mem_filterMap] + rfl + +theorem encodeMapEntry_spec [Field F] [DecidableEq F] {decls : Declarations} + (tags : decls.tagsValid F = true) {name : String} {entry : MapEntry F} {message : Message F} + (encoded : encodeMapEntry decls name entry = some message) : + message.channel = name ∧ DecodesValues decls message.args (entry.args.map Constant.toValue) ∧ + message.result.decode decls = some entry.result.toValue := by + unfold encodeMapEntry at encoded + obtain ⟨wires, arguments, rest⟩ := Option.bind_eq_some_iff.mp encoded + obtain ⟨output, result, finished⟩ := Option.bind_eq_some_iff.mp rest + cases finished + refine ⟨rfl, ?_, Value.decode_encode result (fun _ => Declarations.layout_tagSafe tags)⟩ + have related := StaticList.mapM_some_iff.mp arguments + apply List.forall₂_map_right_iff.mpr + exact related.flip.imp (fun _ _ head => + Value.decode_encode head (fun _ => Declarations.layout_tagSafe tags)) + +theorem encodeMapEntry_total [Field F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) (entry : MapEntry F) + (argsGood : ∀ arg ∈ entry.args, arg.wellFormed decls = true) + (resultGood : entry.result.wellFormed decls = true) : + ∃ message, encodeMapEntry decls name entry = some message := by + have values (items : List (Constant F)) (good : ∀ arg ∈ items, arg.wellFormed decls = true) : + ∃ wires, items.mapM (fun arg => arg.toValue.encode decls) = some wires := by + induction items with + | nil => exact ⟨[], rfl⟩ + | cons arg args ih => + obtain ⟨wire, encoded⟩ := Value.encode_total checked + ⟨by simpa using good arg (by simp), + Value.pointerNames_of_free (Constant.toValue_pointerFree arg)⟩ + obtain ⟨wires, rest⟩ := ih (fun arg h => good arg (by simp [h])) + exact ⟨wire :: wires, by simp [List.mapM_cons, encoded, rest]⟩ + obtain ⟨wires, arguments⟩ := values entry.args argsGood + obtain ⟨output, result⟩ := Value.encode_total checked + ⟨by simpa using resultGood, + Value.pointerNames_of_free (Constant.toValue_pointerFree entry.result)⟩ + exact ⟨⟨name, wires, output⟩, by simp [encodeMapEntry, arguments, result]⟩ + +/-- A static leaf gives exactly the source lookup, including its canonical encodings. -/ +theorem compile_map_spec [Field F] [DecidableEq F] + {program : Program F} {system : System F} (compiled : compile program = .ok system) + {message : Message F} (member : system.MapClaim message) : + ∃ args constant, DecodesValues program.enums message.args args ∧ + message.result.decode program.enums = some constant.toValue ∧ + program.findFunction? message.channel = none ∧ + lookupMap program message.channel args = .ok constant := by + obtain ⟨map, mapMember, entry, entryMember, encoded⟩ := (compile_mapClaims compiled message).mp member + have stages := compile_stages compiled + obtain ⟨name, arguments, result⟩ := encodeMapEntry_spec stages.2.1 encoded + exact ⟨entry.args.map Constant.toValue, entry.result, arguments, result, + by rw [name]; exact map_function_absent stages.1 mapMember, + by rw [name]; exact lookupMap_of_entry stages.1 mapMember entryMember⟩ + +/-- Lookup succeeds only at one of the fixed, aligned rows of the compiled traces. -/ +theorem compile_map_lookup [Field F] [DecidableEq F] + {program : Program F} {system : System F} (compiled : compile program = .ok system) + {name : String} {args : List (Value F)} {constant : Constant F} + (looked : lookupMap program name args = .ok constant) : + ∃ wires output, DecodesValues program.enums wires args ∧ + output.decode program.enums = some constant.toValue ∧ + system.MapClaim ⟨name, wires, output⟩ := by + obtain ⟨map, key, found, _, formed, extracted, row, outputTyped⟩ := lookupMap_spec looked + have mapped : map.name = name := by simpa using List.find?_some found + have reconstructed := Value.toConstant_spec extracted + cases key with + | field x => simp [show (Constant.toValue : Constant F → Value F _) = Value.mapAddress Empty.elim from rfl, Constant.toValue, Value.mapAddress] at reconstructed + | construct e c xs => simp [show (Constant.toValue : Constant F → Value F _) = Value.mapAddress Empty.elim from rfl, Constant.toValue, Value.mapAddress] at reconstructed + | ptr _ address => exact Empty.elim address + | tuple constants => + have same : constants.map (Constant.toValue (Address := F)) = args := by + simpa only [show (Constant.toValue : Constant F → Value F _) = Value.mapAddress Empty.elim from rfl, Constant.toValue, Value.mapAddress, Value.tuple.injEq] using reconstructed + let entry : MapEntry F := ⟨constants, constant⟩ + have argsGood : ∀ c ∈ constants, c.wellFormed program.enums = true := by + intro c member + have good := formed (Constant.toValue c) (by rw [← same]; exact List.mem_map.mpr ⟨c, member, rfl⟩) + simpa using good + have resultGood : constant.wellFormed program.enums = true := by + simp only [Value.hasType, Bool.and_eq_true] at outputTyped + exact outputTyped.2 + have stages := compile_stages compiled + obtain ⟨message, encoded⟩ := encodeMapEntry_total (name := name) + (typecheck_declarations stages.1) entry argsGood resultGood + obtain ⟨messageName, arguments, result⟩ := encodeMapEntry_spec stages.2.1 encoded + have claim : system.MapClaim message := (compile_mapClaims compiled message).mpr + ⟨map, List.mem_of_find?_eq_some found, entry, mapEntry_mem_iff.mpr row, + by simpa only [mapped] using encoded⟩ + refine ⟨message.args, message.result, ?_, result, ?_⟩ + · simpa only [entry, same] using arguments + · cases message + simpa only [Message.mk.injEq] using (messageName ▸ claim) + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/MemoAcyclic.lean b/Aiur/Aiur/Circuit/MemoAcyclic.lean new file mode 100644 index 000000000..34b245587 --- /dev/null +++ b/Aiur/Aiur/Circuit/MemoAcyclic.lean @@ -0,0 +1,51 @@ +import Aiur.Circuit.MemoDerivation +import Mathlib.Data.Fintype.Card +import Mathlib.Data.Fintype.Fin +import Mathlib.Logic.Relation +import Mathlib.Order.WellFounded + +namespace Aiur.Circuit.MemoDerivation + +variable {F : Type} {rom : WireROM F} + +variable [Field F] [DecidableEq F] {system : System F} {message : Message F} + +/-- An enabled premise of `parent` is supplied by `child`, oriented for induction. -/ +def Dependency (graph : MemoDerivation system rom message) (child parent : Fin graph.size) : Prop := + ∃ j : Fin (graph.node parent).premises.length, graph.target parent j = child + +/-- No node lies on a nonempty directed path back to itself. Sharing is allowed. -/ +def Acyclic (graph : MemoDerivation system rom message) : Prop := + ∀ i, ¬ Relation.TransGen graph.Dependency i i + +/-- On the finite node set, the absence of directed cycles permits dependency induction. -/ +theorem Acyclic.wellFounded {graph : MemoDerivation system rom message} + (acyclic : graph.Acyclic) : WellFounded graph.Dependency := by + letI : Std.Irrefl (Relation.TransGen graph.Dependency) := ⟨acyclic⟩ + exact (Finite.wellFounded_of_trans_of_irrefl (Relation.TransGen graph.Dependency)).mono + (fun _ _ edge => .single edge) + +/-- Unfold the dependencies of any node into a finite, closed derivation tree. -/ +theorem node_derives_of_acyclic (graph : MemoDerivation system rom message) + (acyclic : graph.Acyclic) (i : Fin graph.size) : + Derives system rom (graph.node i).conclusion := by + induction i using acyclic.wellFounded.induction with + | h i ih => + have premises : ∀ premise ∈ (graph.node i).premises, Derives system rom premise := by + intro premise member + obtain ⟨j, bounded, same⟩ := List.mem_iff_getElem.mp member + have child := ih (graph.target i ⟨j, bounded⟩) ⟨⟨j, bounded⟩, rfl⟩ + rwa [(graph.target_claim i ⟨j, bounded⟩).trans same] at child + obtain ⟨children⟩ := derivations_nonempty_iff.mpr premises + cases rule : graph.node i with + | node chip row lookup valid => + exact ⟨.node chip row lookup valid (by simpa [rule, RuleInstance.premises] using children)⟩ + | table message member => exact ⟨.table member⟩ + +/-- An acyclic memoized graph supplies an ordinary derivation of its root claim. -/ +theorem derives_of_acyclic (graph : MemoDerivation system rom message) + (acyclic : graph.Acyclic) : Derives system rom message := by + rw [← graph.root_claim] + exact graph.node_derives_of_acyclic acyclic graph.root + +end Aiur.Circuit.MemoDerivation diff --git a/Aiur/Aiur/Circuit/MemoDerivation.lean b/Aiur/Aiur/Circuit/MemoDerivation.lean new file mode 100644 index 000000000..53af898a0 --- /dev/null +++ b/Aiur/Aiur/Circuit/MemoDerivation.lean @@ -0,0 +1,161 @@ +import Aiur.Circuit.Derivation + +namespace Aiur.Circuit + +variable {F : Type} {rom : WireROM F} + +/-- One locally checked rule instance, without proofs of its call premises. -/ +inductive RuleInstance [Field F] (system : System F) (rom : WireROM F) where + | node (chip : Chip F) (row : Row F) + (lookup : system.findChip? row.chip = some chip) (valid : chip.ValidRow rom row) + | table (message : Message F) (member : system.MapClaim message) + +def RuleInstance.conclusion [Field F] {system : System F} + : RuleInstance system rom → Message F + | .node chip row _ _ => chip.receive row + | .table message _ => message + +def RuleInstance.premises [Field F] [DecidableEq F] {system : System F} + : RuleInstance system rom → List (Message F) + | .node chip row _ _ => chip.premises row + | .table _ _ => [] + +/-- +A finite graph of locally valid rules. Every enabled call has an explicit target +with the required conclusion. References may be shared or cyclic, including self-references. +There is no ordering, rank, multiplicity, or source-termination condition. +-/ +structure MemoDerivation [Field F] [DecidableEq F] (system : System F) (rom : WireROM F) + (message : Message F) where + size : Nat + node : Fin size → RuleInstance system rom + root : Fin size + root_claim : (node root).conclusion = message + target : (i : Fin size) → Fin (node i).premises.length → Fin size + target_claim : ∀ i j, (node (target i j)).conclusion = (node i).premises[j] + +/-- Memoized acceptance asserts the existence of a finite, possibly cyclic graph. -/ +def MemoDerives [Field F] [DecidableEq F] (system : System F) (rom : WireROM F) (message : Message F) : Prop := + Nonempty (MemoDerivation system rom message) + +def MemoAccepts [Field F] [DecidableEq F] (system : System F) (rom : WireROM F) + (function : String) (args : List (WireValue F)) (result : WireValue F) : Prop := + MemoDerives system rom ⟨function, args, result⟩ + +/-- The claims represented anywhere in a graph, including its root. -/ +def MemoDerivation.Claims [Field F] [DecidableEq F] {system : System F} {message : Message F} + (graph : MemoDerivation system rom message) (claim : Message F) : Prop := + ∃ i, (graph.node i).conclusion = claim + +theorem MemoDerivation.root_mem [Field F] [DecidableEq F] + {system : System F} {message : Message F} (graph : MemoDerivation system rom message) : + graph.Claims message := ⟨graph.root, graph.root_claim⟩ + +theorem MemoDerivation.premise_mem [Field F] [DecidableEq F] + {system : System F} {message : Message F} (graph : MemoDerivation system rom message) + (i : Fin graph.size) {premise : Message F} (member : premise ∈ (graph.node i).premises) : + graph.Claims premise := by + obtain ⟨j, bounded, same⟩ := List.mem_iff_getElem.mp member + exact ⟨graph.target i ⟨j, bounded⟩, (graph.target_claim i ⟨j, bounded⟩).trans same⟩ + +/-- Build explicit references from a finite table closed under call premises. -/ +noncomputable def MemoDerivation.ofClosed [Field F] [DecidableEq F] + {system : System F} {message : Message F} (rules : List (RuleInstance system rom)) + (root : ∃ rule ∈ rules, rule.conclusion = message) + (closed : ∀ rule ∈ rules, ∀ premise ∈ rule.premises, + ∃ provider ∈ rules, provider.conclusion = premise) : MemoDerivation system rom message := by + have locate {claim : Message F} (present : ∃ rule ∈ rules, rule.conclusion = claim) : + ∃ i : Fin rules.length, rules[i].conclusion = claim := by + obtain ⟨rule, member, conclusion⟩ := present + obtain ⟨i, bounded, same⟩ := List.mem_iff_getElem.mp member + exact ⟨⟨i, bounded⟩, by simpa [same] using conclusion⟩ + let rootIndex := Classical.choose (locate root) + have targets (i : Fin rules.length) (j : Fin rules[i].premises.length) : + ∃ target : Fin rules.length, rules[target].conclusion = rules[i].premises[j] := + locate (closed rules[i] (List.getElem_mem _) _ (List.getElem_mem _)) + exact { + size := rules.length + node := fun i => rules[i] + root := rootIndex + root_claim := Classical.choose_spec (locate root) + target := fun i j => Classical.choose (targets i j) + target_claim := fun i j => Classical.choose_spec (targets i j) + } + +mutual + /-- Keep each tree occurrence as a locally valid graph node. -/ + def Derivation.instances [Field F] [DecidableEq F] {system : System F} {message : Message F} : + Derivation system rom message → List (RuleInstance system rom) + | .node chip row lookup valid children => .node chip row lookup valid :: children.instances + | .table member => [.table _ member] + + def Derivations.instances [Field F] [DecidableEq F] {system : System F} {messages : List (Message F)} : + Derivations system rom messages → List (RuleInstance system rom) + | .nil => [] + | .cons head tail => head.instances ++ tail.instances +end + +theorem Derivation.root_instance [Field F] [DecidableEq F] + {system : System F} {message : Message F} (tree : Derivation system rom message) : + ∃ rule ∈ tree.instances, rule.conclusion = message := by + cases tree with + | node chip row lookup valid children => exact ⟨.node chip row lookup valid, by simp [instances], rfl⟩ + | table member => exact ⟨.table _ member, by simp [instances], rfl⟩ + +theorem Derivations.root_instances [Field F] [DecidableEq F] + {system : System F} {messages : List (Message F)} (trees : Derivations system rom messages) : + ∀ message ∈ messages, ∃ rule ∈ trees.instances, rule.conclusion = message := by + cases trees with + | nil => simp + | cons head tail => + intro message member + rcases List.mem_cons.mp member with rfl | member + · obtain ⟨rule, present, conclusion⟩ := head.root_instance + exact ⟨rule, by simp [instances, present], conclusion⟩ + · obtain ⟨rule, present, conclusion⟩ := tail.root_instances message member + exact ⟨rule, by simp [instances, present], conclusion⟩ +termination_by structural trees + +theorem Derivation.instances_closed [Field F] [DecidableEq F] + {system : System F} {message : Message F} (tree : Derivation system rom message) : + ∀ rule ∈ tree.instances, ∀ premise ∈ rule.premises, + ∃ provider ∈ tree.instances, provider.conclusion = premise := by + induction tree using Derivation.rec + (motive_2 := fun messages (trees : Derivations system rom messages) => + ∀ (rule : RuleInstance system rom), rule ∈ trees.instances → ∀ premise ∈ rule.premises, + ∃ provider ∈ trees.instances, provider.conclusion = premise) with + | node chip row lookup valid children ih => + intro rule member premise required + simp only [instances, List.mem_cons] at member + rcases member with rfl | member + · obtain ⟨provider, present, conclusion⟩ := children.root_instances premise required + exact ⟨provider, by simp [instances, present], conclusion⟩ + · obtain ⟨provider, present, conclusion⟩ := ih rule member premise required + exact ⟨provider, by simp [instances, present], conclusion⟩ + | table member => + intro rule present premise required + simp only [instances, List.mem_singleton] at present + subst rule + simp [RuleInstance.premises] at required + | nil => rename_i rule member premise required; simp [Derivations.instances] at member + | cons head tail headIH tailIH => + rename_i rule member premise required + simp only [Derivations.instances, List.mem_append] at member + rcases member with member | member + · obtain ⟨provider, present, conclusion⟩ := headIH rule member premise required + exact ⟨provider, by simp [Derivations.instances, present], conclusion⟩ + · obtain ⟨provider, present, conclusion⟩ := tailIH rule member premise required + exact ⟨provider, by simp [Derivations.instances, present], conclusion⟩ + +/-- Every ordinary derivation supplies a memoized graph; cycles are not required. -/ +noncomputable def Derivation.toMemo [Field F] [DecidableEq F] + {system : System F} {message : Message F} (tree : Derivation system rom message) : + MemoDerivation system rom message := + .ofClosed tree.instances tree.root_instance tree.instances_closed + +theorem Derives.memo [Field F] [DecidableEq F] {system : System F} {message : Message F} + (derives : Derives system rom message) : MemoDerives system rom message := by + obtain ⟨tree⟩ := derives + exact ⟨tree.toMemo⟩ + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/MemoTree.lean b/Aiur/Aiur/Circuit/MemoTree.lean new file mode 100644 index 000000000..712621a24 --- /dev/null +++ b/Aiur/Aiur/Circuit/MemoTree.lean @@ -0,0 +1,147 @@ +import Aiur.Circuit.MemoAcyclic + +namespace Aiur.Circuit + +variable {F : Type} [Field F] [DecidableEq F] +variable {system : System F} {rom : WireROM F} {message : Message F} + +/-- A finite natural rank decreasing along every reference rules out cycles. -/ +theorem MemoDerivation.acyclic_of_rank (graph : MemoDerivation system rom message) + (rank : Fin graph.size → Nat) + (decreases : ∀ i j, rank (graph.target i j) < rank i) : graph.Acyclic := by + have edge {child parent} (dependency : graph.Dependency child parent) : rank child < rank parent := by + obtain ⟨j, rfl⟩ := dependency + exact decreases parent j + have path {child parent} (steps : Relation.TransGen graph.Dependency child parent) : + rank child < rank parent := by + induction steps with + | single dependency => exact edge dependency + | tail _ dependency ih => exact ih.trans (edge dependency) + exact fun i cycle => (Nat.lt_irrefl (rank i)) (path cycle) + +/-- Build an acyclic graph from a finite collection of ranked rules, choosing +only providers of strictly smaller rank. Repeated claims need not be merged. -/ +theorem MemoDerivation.exists_acyclic_of_ranked + (rules : List (RuleInstance system rom × Nat)) + (root : ∃ rule ∈ rules, rule.1.conclusion = message) + (closed : ∀ rule ∈ rules, ∀ premise ∈ rule.1.premises, + ∃ provider ∈ rules, provider.1.conclusion = premise ∧ provider.2 < rule.2) : + ∃ graph : MemoDerivation system rom message, graph.Acyclic := by + classical + have locate {P : RuleInstance system rom × Nat → Prop} + (present : ∃ rule ∈ rules, P rule) : ∃ i : Fin rules.length, P rules[i] := by + obtain ⟨rule, member, property⟩ := present + obtain ⟨i, bounded, same⟩ := List.mem_iff_getElem.mp member + exact ⟨⟨i, bounded⟩, by simpa [same] using property⟩ + let rootIndex := Classical.choose (locate root) + have targets (i : Fin rules.length) (j : Fin rules[i].1.premises.length) : + ∃ target : Fin rules.length, + rules[target].1.conclusion = rules[i].1.premises[j] ∧ rules[target].2 < rules[i].2 := + locate (closed rules[i] (List.getElem_mem _) _ (List.getElem_mem _)) + let graph : MemoDerivation system rom message := { + size := rules.length + node := fun i => rules[i].1 + root := rootIndex + root_claim := Classical.choose_spec (locate root) + target := fun i j => Classical.choose (targets i j) + target_claim := fun i j => (Classical.choose_spec (targets i j)).1 + } + refine ⟨graph, graph.acyclic_of_rank (fun i => rules[i].2) ?_⟩ + exact fun i j => (Classical.choose_spec (targets i j)).2 + +mutual + /-- Height of a finite rule derivation. -/ + def Derivation.height {message : Message F} : Derivation system rom message → Nat + | .node _ _ _ _ children => children.height + 1 + | .table _ => 0 + + def Derivations.height {messages : List (Message F)} : Derivations system rom messages → Nat + | .nil => 0 + | .cons head tail => max head.height tail.height +end + +mutual + /-- Every occurrence is accompanied by its subtree height. -/ + def Derivation.rankedInstances {message : Message F} : + Derivation system rom message → List (RuleInstance system rom × Nat) + | .node chip row lookup valid children => + (.node chip row lookup valid, children.height + 1) :: children.rankedInstances + | .table member => [(.table _ member, 0)] + + def Derivations.rankedInstances {messages : List (Message F)} : + Derivations system rom messages → List (RuleInstance system rom × Nat) + | .nil => [] + | .cons head tail => head.rankedInstances ++ tail.rankedInstances +end + +theorem Derivation.root_rankedInstance (tree : Derivation system rom message) : + ∃ rule ∈ tree.rankedInstances, rule.1.conclusion = message ∧ rule.2 = tree.height := by + cases tree with + | node chip row lookup valid children => + exact ⟨(.node chip row lookup valid, children.height + 1), by simp [rankedInstances], rfl, rfl⟩ + | table member => exact ⟨(.table _ member, 0), by simp [rankedInstances], rfl, rfl⟩ + +theorem Derivations.root_rankedInstances {messages : List (Message F)} + (trees : Derivations system rom messages) : + ∀ message ∈ messages, ∃ rule ∈ trees.rankedInstances, + rule.1.conclusion = message ∧ rule.2 ≤ trees.height := by + cases trees with + | nil => simp + | cons head tail => + intro message member + rcases List.mem_cons.mp member with rfl | member + · obtain ⟨rule, present, conclusion, rank⟩ := head.root_rankedInstance + exact ⟨rule, by simp [rankedInstances, present], conclusion, + by simp [rank, height]⟩ + · obtain ⟨rule, present, conclusion, rank⟩ := tail.root_rankedInstances message member + exact ⟨rule, by simp [rankedInstances, present], conclusion, + rank.trans (Nat.le_max_right head.height tail.height)⟩ +termination_by structural trees + +theorem Derivation.rankedInstances_closed (tree : Derivation system rom message) : + ∀ rule ∈ tree.rankedInstances, ∀ premise ∈ rule.1.premises, + ∃ provider ∈ tree.rankedInstances, + provider.1.conclusion = premise ∧ provider.2 < rule.2 := by + induction tree using Derivation.rec + (motive_2 := fun messages (trees : Derivations system rom messages) => + ∀ rule ∈ trees.rankedInstances, ∀ premise ∈ rule.1.premises, + ∃ provider ∈ trees.rankedInstances, + provider.1.conclusion = premise ∧ provider.2 < rule.2) with + | node chip row lookup valid children ih => + intro rule member premise required + simp only [rankedInstances, List.mem_cons] at member + rcases member with rfl | member + · obtain ⟨provider, present, conclusion, rank⟩ := children.root_rankedInstances premise required + exact ⟨provider, by simp [rankedInstances, present], conclusion, + Nat.lt_succ_of_le rank⟩ + · obtain ⟨provider, present, conclusion, rank⟩ := ih rule member premise required + exact ⟨provider, by simp [rankedInstances, present], conclusion, rank⟩ + | table member => + intro rule present premise required + simp only [rankedInstances, List.mem_singleton] at present + subst rule + simp [RuleInstance.premises] at required + | nil => rename_i rule member premise required; simp [Derivations.rankedInstances] at member + | cons head tail headIH tailIH => + rename_i rule member premise required + simp only [Derivations.rankedInstances, List.mem_append] at member + rcases member with member | member + · obtain ⟨provider, present, conclusion, rank⟩ := headIH rule member premise required + exact ⟨provider, by simp [Derivations.rankedInstances, present], conclusion, rank⟩ + · obtain ⟨provider, present, conclusion, rank⟩ := tailIH rule member premise required + exact ⟨provider, by simp [Derivations.rankedInstances, present], conclusion, rank⟩ + +/-- A finite derivation always has an acyclic memoized representation, even +when the same claim occurs at different heights in the tree. -/ +theorem Derives.acyclic (derives : Derives system rom message) : + ∃ graph : MemoDerivation system rom message, graph.Acyclic := by + obtain ⟨tree⟩ := derives + obtain ⟨rule, present, conclusion, _⟩ := tree.root_rankedInstance + exact MemoDerivation.exists_acyclic_of_ranked tree.rankedInstances + ⟨rule, present, conclusion⟩ tree.rankedInstances_closed + +theorem derives_iff_acyclic_memo : + Derives system rom message ↔ ∃ graph : MemoDerivation system rom message, graph.Acyclic := + ⟨Derives.acyclic, fun ⟨graph, acyclic⟩ => graph.derives_of_acyclic acyclic⟩ + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/ParameterWitness.lean b/Aiur/Aiur/Circuit/ParameterWitness.lean new file mode 100644 index 000000000..2ed68dc2f --- /dev/null +++ b/Aiur/Aiur/Circuit/ParameterWitness.lean @@ -0,0 +1,67 @@ +import Aiur.Circuit.EncodingWitness + +namespace Aiur.Circuit.Compiler + +variable {F : Type} {rom : WireROM F} + +theorem freshValues_decoded_complete [Field F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) (tags : decls.tagsValid F = true) + {types : List Ty} {vars : List (WireValue Var)} {before after : BuildState F} + (compiled : freshValues decls types before = .ok (vars, after)) + {calls : Circuit.CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls initial) + (values : List (Value F)) (shape : values.map Value.type = types) + (formed : ∀ value ∈ values, value.wellFormed decls = true) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + (∀ wire ∈ vars, Bounded (F := F) after.nextVar (wire.map ArithExpr.var)) ∧ + DecodesValues decls (vars.map (WireValue.map assignment)) values := by + induction values generalizing vars types before initial with + | nil => + subst types + obtain ⟨rfl, rfl⟩ := pure_ok.mp compiled + exact ⟨initial, .refl layout valid, by simp, .nil⟩ + | cons value values ih => + subst types + simp only [List.map_cons, freshValues, List.mapM_cons] at compiled + obtain ⟨head, middle, headRun, rest⟩ := bind_ok.mp compiled + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, headExt, headBound, headDecode⟩ := freshValue_decoded_complete checked tags headRun + layout valid value rfl (formed _ (by simp)) + obtain ⟨b, tailExt, tailBound, tailDecode⟩ := ih tailRun headExt.layout headExt.valid rfl + (fun v h => formed v (by simp [h])) + refine ⟨b, headExt.trans tailExt, ?_, .cons ?_ tailDecode⟩ + · simpa using And.intro (headBound.mono tailExt.increase) tailBound + · rw [tailExt.variables headBound] + exact headDecode + +theorem parameter_types (params : List (String × Ty)) (args : List (Value F)) + (types : params.map Prod.snd = args.map Value.type) : + environmentTypes ((params.map Prod.fst).zip args) = params := by + induction params generalizing args with + | nil => cases args <;> simp_all [environmentTypes] + | cons param params ih => + cases args with + | nil => simp at types + | cons arg args => + simp only [List.map_cons, List.cons.injEq] at types + simp only [List.map_cons, List.zip_cons_cons, environmentTypes, List.map_cons] + rw [← types.1] + exact congrArg (param :: ·) (ih args types.2) + +theorem parameter_bounded {names : List String} {inputs : List (WireValue Var)} {bound : Nat} + (bounded : ∀ input ∈ inputs, Bounded (F := F) bound (input.map ArithExpr.var)) : + LocalsBounded (F := F) bound (names.zip (inputs.map (WireValue.map ArithExpr.var))) := by + intro binding member + obtain ⟨_, inside⟩ := List.of_mem_zip member + obtain ⟨input, inputMember, same⟩ := List.mem_map.mp inside + rw [← same] + exact bounded input inputMember + +theorem parameter_wellFormed {decls : Declarations} {names : List String} {values : List (Value F)} + (formed : ∀ value ∈ values, value.wellFormed decls = true) : + Environment.WellFormed decls (names.zip values) := by + intro binding member + exact formed binding.2 (List.of_mem_zip member).2 + +end Aiur.Circuit.Compiler diff --git a/Aiur/Aiur/Circuit/PatternCorrectness.lean b/Aiur/Aiur/Circuit/PatternCorrectness.lean new file mode 100644 index 000000000..93da8ca51 --- /dev/null +++ b/Aiur/Aiur/Circuit/PatternCorrectness.lean @@ -0,0 +1,191 @@ +import Aiur.Circuit.PatternEncoding +import Aiur.Circuit.Indicator + +namespace Aiur.Circuit.Compiler + +variable {F : Type} {rom : WireROM F} + +set_option maxHeartbeats 1600000 +set_option maxRecDepth 4096 + +/-- On a match, the symbolic bindings decode to exactly the source bindings. -/ +def PatternTest [Field F] [DecidableEq F] (decls : Declarations) + (matched : Option (Environment F)) (test : F) (bindings : WireEnvironment F) : Prop := + (∃ values, matched = some values ∧ test = 1 ∧ DecodesEnvironment decls bindings values) ∨ + (matched = none ∧ test = 0) + +mutual + /-- Pattern tests are Boolean even for inactive, noncanonical payload views. -/ + theorem lowerPattern_sound [Field F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) (tags : decls.tagsValid F = true) + {pattern : Pattern F} {wire : Symbolic F} {test : ArithExpr F} {bindings : Locals F} + {before after : BuildState F} + (compiled : lowerPattern decls pattern wire before = .ok ((test, bindings), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid rom calls assignment) : + before.Valid rom calls assignment ∧ (test.denote assignment = 0 ∨ test.denote assignment = 1) ∧ + ∀ value, (wire.map (ArithExpr.denote assignment)).decode decls = some value → + PatternTest decls (pattern.bindings value) (test.denote assignment) + (localsEnvironment bindings assignment) := by + cases pattern with + | wildcard => + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp (by simpa only [lowerPattern] using compiled) + exact ⟨valid, Or.inr rfl, fun value _ => Or.inl ⟨[], by simp [Pattern.bindings], rfl, .nil⟩⟩ + | bind name => + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp (by simpa only [lowerPattern] using compiled) + exact ⟨valid, Or.inr rfl, fun value decoded => Or.inl + ⟨[(name, value)], by simp [Pattern.bindings], rfl, .cons ⟨rfl, decoded⟩ .nil⟩⟩ + | literal literal => + rcases wire with ⟨type, words⟩ + cases type with + | tuple | ptr | enum => simp [lowerPattern] at compiled + | field => + cases words with + | nil => simp [lowerPattern] at compiled + | cons word rest => cases rest with + | cons => simp [lowerPattern] at compiled + | nil => + simp only [lowerPattern] at compiled + obtain ⟨indicator, middle, indicatorRun, finished⟩ := bind_ok.mp compiled + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp finished + obtain ⟨previous, exactTest⟩ := equalIndicator_sound indicatorRun valid + have exactTest : test.denote assignment = + if literal = word.denote assignment then 1 else 0 := by + change test.denote assignment = + (if word.denote assignment - literal = 0 then 1 else 0) at exactTest + simp only [sub_eq_zero] at exactTest + simpa only [eq_comm] using exactTest + refine ⟨previous, ?_, ?_⟩ + · rw [exactTest]; split <;> simp + · intro value decoded + have same : Value.field (word.denote assignment) = value := by + change (WireValue.field (word.denote assignment)).decode decls = some value at decoded + simpa only [WireValue.decode_field, Option.some.injEq] using decoded + subst value + by_cases matched : literal = word.denote assignment + · exact Or.inl ⟨[], by simp [Pattern.bindings, matched], by simp [exactTest, matched], .nil⟩ + · exact Or.inr ⟨by simp [Pattern.bindings, matched], by simp [exactTest, matched]⟩ + | tuple patterns => + rcases wire with ⟨type, words⟩ + cases type with + | field | ptr | enum => simp [lowerPattern] at compiled + | tuple types => + simp only [lowerPattern] at compiled + obtain ⟨wires, middle, splitRun, patternRun⟩ := bind_ok.mp compiled + have unchanged := (splitValues_spec splitRun).1 + subst middle + obtain ⟨previous, boolean, matched⟩ := lowerPatterns_sound checked tags patternRun valid + refine ⟨previous, boolean, fun value decoded => ?_⟩ + obtain ⟨values, rfl, valuesDecoded⟩ := splitValues_decode checked splitRun decoded + simpa only [Pattern.bindings] using matched values valuesDecoded + | construct name ctor patterns => + simp only [lowerPattern] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · rename_i typeEq + have typeEq : wire.type = .enum name := by simpa using typeEq + obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + cases found : decls.findEnum? name with + | none => simp [found] at rest + | some definition => + simp only [found] at rest + cases atIndex : definition.constructors[definition.constructors.findIdx (·.name == ctor)]? with + | none => simp [atIndex] at rest + | some constructor => + simp only [atIndex] at rest + have ctorName : constructor.name = ctor := by + simpa using List.findIdx_of_getElem?_eq_some atIndex + rcases wire with ⟨type, words⟩ + dsimp only at typeEq + subst type + cases parts : Layout.enumParts definition.constructors.length (.const 0) words with + | none => simp [parts] at rest + | some pair => + rcases pair with ⟨tag, payload⟩ + simp only [parts] at rest + obtain ⟨layout, s₁, layoutRun, rest⟩ := bind_ok.mp rest + obtain ⟨expansion, rfl⟩ := getLayout_eq layoutRun + obtain ⟨values, s₂, splitRun, rest⟩ := bind_ok.mp rest + have unchanged := (splitValues_spec splitRun).1 + subst s₂ + obtain ⟨tagTest, s₃, tagRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨payloadTest, payloadBindings⟩, s₄, payloadRun, finished⟩ := bind_ok.mp rest + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp finished + obtain ⟨s₃valid, payloadBoolean, payloadMatched⟩ := lowerPatterns_sound checked tags payloadRun valid + obtain ⟨previous, tagEq⟩ := equalIndicator_sound tagRun s₃valid + have tagEq : tagTest.denote assignment = + if tag.denote assignment = ((definition.constructors.findIdx (·.name == ctor) : Nat) : F) + then 1 else 0 := by + simpa [Scalar.Circuit.ArithExpr.denote, sub_eq_zero] using tagEq + refine ⟨previous, ?_, ?_⟩ + · change tagTest.denote assignment * payloadTest.denote assignment = 0 ∨ + tagTest.denote assignment * payloadTest.denote assignment = 1 + rw [tagEq] + split <;> simpa using payloadBoolean + · intro value decoded + obtain ⟨actual, args, rfl, tagMatch, payloadDecoded⟩ := + enum_payload_decoded checked tags found atIndex expansion parts splitRun decoded + rw [ctorName] at tagMatch payloadDecoded + by_cases same : actual = ctor + · have selected := tagMatch.mpr same + have matched := payloadMatched args (payloadDecoded same) + subst actual + simpa [PatternTest, Pattern.bindings, tagEq, selected, Scalar.Circuit.ArithExpr.denote] + using matched + · exact Or.inr ⟨by simp [Pattern.bindings, Ne.symm same], + by simp [Scalar.Circuit.ArithExpr.denote, tagEq, mt tagMatch.mp same]⟩ + termination_by sizeOf pattern + + theorem lowerPatterns_sound [Field F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) (tags : decls.tagsValid F = true) + {patterns : List (Pattern F)} {wires : List (Symbolic F)} + {test : ArithExpr F} {bindings : Locals F} {before after : BuildState F} + (compiled : lowerPatterns decls patterns wires before = .ok ((test, bindings), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid rom calls assignment) : + before.Valid rom calls assignment ∧ (test.denote assignment = 0 ∨ test.denote assignment = 1) ∧ + ∀ values, DecodesValues decls (wires.map (WireValue.map (ArithExpr.denote assignment))) values → + PatternTest decls (Pattern.bindingsList patterns values) (test.denote assignment) + (localsEnvironment bindings assignment) := by + cases patterns with + | nil => + cases wires with + | nil => + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp (by simpa only [lowerPatterns] using compiled) + refine ⟨valid, Or.inr rfl, fun values decoded => ?_⟩ + cases decoded + exact Or.inl ⟨[], by simp [Pattern.bindingsList], rfl, .nil⟩ + | cons => simp [lowerPatterns] at compiled + | cons pattern patterns => + cases wires with + | nil => simp [lowerPatterns] at compiled + | cons wire wires => + simp only [lowerPatterns] at compiled + obtain ⟨⟨head, headBindings⟩, middle, headRun, rest⟩ := bind_ok.mp compiled + obtain ⟨⟨tail, tailBindings⟩, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp finished + obtain ⟨middleValid, tailBoolean, tailTest⟩ := lowerPatterns_sound checked tags tailRun valid + obtain ⟨beforeValid, headBoolean, headTest⟩ := lowerPattern_sound checked tags headRun middleValid + refine ⟨beforeValid, ?_, ?_⟩ + · change head.denote assignment * tail.denote assignment = 0 ∨ + head.denote assignment * tail.denote assignment = 1 + rcases headBoolean with zero | one + · simp [zero] + · simpa [one] using tailBoolean + · intro values decoded + cases decoded with + | cons headDecode tailDecode => + rcases headTest _ headDecode with ⟨headValues, headMatch, headOne, headDecoded⟩ | ⟨headMatch, headZero⟩ <;> + rcases tailTest _ tailDecode with ⟨tailValues, tailMatch, tailOne, tailDecoded⟩ | ⟨tailMatch, tailZero⟩ + · exact Or.inl ⟨headValues ++ tailValues, by simp [Pattern.bindingsList, headMatch, tailMatch], + by simp [Scalar.Circuit.ArithExpr.denote, headOne, tailOne], + by simpa only [localsEnvironment_append] using headDecoded.append tailDecoded⟩ + · exact Or.inr ⟨by simp [Pattern.bindingsList, headMatch, tailMatch], + by simp [Scalar.Circuit.ArithExpr.denote, tailZero]⟩ + · exact Or.inr ⟨by simp [Pattern.bindingsList, headMatch], + by simp [Scalar.Circuit.ArithExpr.denote, headZero]⟩ + · exact Or.inr ⟨by simp [Pattern.bindingsList, headMatch], + by simp [Scalar.Circuit.ArithExpr.denote, headZero]⟩ + termination_by sizeOf patterns +end + +end Aiur.Circuit.Compiler diff --git a/Aiur/Aiur/Circuit/PatternEncoding.lean b/Aiur/Aiur/Circuit/PatternEncoding.lean new file mode 100644 index 000000000..a1cfa4ff1 --- /dev/null +++ b/Aiur/Aiur/Circuit/PatternEncoding.lean @@ -0,0 +1,58 @@ +import Aiur.Circuit.SplitFacts +import Aiur.ConstructorFacts + +namespace Aiur.Circuit.Compiler + +/-- A matching enum tag exposes exactly the declared payload tuple. -/ +theorem enum_payload_decoded [Field F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) (tags : decls.tagsValid F = true) + {name : String} {definition : EnumDecl} (found : decls.findEnum? name = some definition) + {index : Nat} {ctor : ConstructorDecl} (atIndex : definition.constructors[index]? = some ctor) + {layout : Layout} (expanded : decls.layout (.tuple ctor.fields) = .ok layout) + {tag : ArithExpr F} {payload : List (ArithExpr F)} {wires : List (Symbolic F)} + {words : List (ArithExpr F)} + (parts : Layout.enumParts definition.constructors.length (.const 0) words = some (tag, payload)) + {before after : BuildState F} + (splitRun : splitValues decls ctor.fields (payload.take layout.width) before = .ok (wires, after)) + {assignment : Var → F} {value : Value F} + (decoded : (WireValue.mk (.enum name) + (words.map (ArithExpr.denote assignment))).decode decls = some value) : + ∃ actual args, value = .construct name actual args ∧ + (tag.denote assignment = (index : F) ↔ actual = ctor.name) ∧ + (actual = ctor.name → DecodesValues decls + (wires.map (WireValue.map (ArithExpr.denote assignment))) args) := by + obtain ⟨_, _, overall, overallRun, rawDecode⟩ := WireValue.decode_spec decoded + have description := Declarations.layout_describes overallRun + cases description with + | @enum _ other constructors enumFound related => + have same := Option.some.inj (found.symm.trans enumFound) + subst other + obtain ⟨chosen, chosenAt, chosenDescription⟩ := related.at atIndex + have sameLayout := chosenDescription.unique (Declarations.layout_describes expanded) + subst chosen + have parts := enumParts_denote parts assignment + rw [← related.length] at parts + simp only [Layout.decode, Nat.cast_zero, parts, bind, Option.bind] at rawDecode + split at rawDecode + · obtain ⟨⟨actual, args⟩, ctorDecode, finished⟩ := Option.bind_eq_some_iff.mp rawDecode + simp only [Option.pure_def, Option.some.injEq] at finished + subst value + have unique := Declarations.layout_namesUnique checked overallRun + have safe := Declarations.layout_tagSafe tags overallRun + simp only [Layout.NamesUnique] at unique + simp only [Layout.TagSafe] at safe + obtain ⟨tagMatch, payloadDecode⟩ := Layout.decodeConstructor_match unique.1 safe.1 chosenAt ctorDecode + refine ⟨actual, args, rfl, by simpa using tagMatch, ?_⟩ + intro matched + have payloadDecoded := payloadDecode matched + cases chosenDescription with + | tuple components => + simp only [Layout.decode] at payloadDecoded + obtain ⟨values, valuesDecode, finished⟩ := Option.bind_eq_some_iff.mp payloadDecoded + simp only [Option.pure_def, Option.some.injEq, Value.tuple.injEq] at finished + subst values + exact splitValues_decodeList checked components splitRun + (by simpa only [List.map_take] using valuesDecode) + · cases rawDecode + +end Aiur.Circuit.Compiler diff --git a/Aiur/Aiur/Circuit/PatternFacts.lean b/Aiur/Aiur/Circuit/PatternFacts.lean new file mode 100644 index 000000000..249221e04 --- /dev/null +++ b/Aiur/Aiur/Circuit/PatternFacts.lean @@ -0,0 +1,22 @@ +import Aiur.Circuit.Basic + +namespace Aiur.Circuit + +/-- The equality-test equations determine the indicator in every field. -/ +theorem equality_indicator_sound [Field F] [DecidableEq F] {difference equal inverse : F} + (zero : difference * equal = 0) + (inverseEquation : difference * inverse - (1 - equal) = 0) : + equal = if difference = 0 then 1 else 0 := by + by_cases same : difference = 0 + · simp only [same, zero_mul, zero_sub, neg_eq_zero] at inverseEquation + simpa [same] using (sub_eq_zero.mp inverseEquation).symm + · simpa [same] using (mul_eq_zero.mp zero).resolve_left same + +/-- Every field difference has witnesses for the emitted equality-test equations. -/ +theorem equality_indicator_complete [Field F] [DecidableEq F] (difference : F) : + let equal : F := if difference = 0 then 1 else 0 + equal * (equal - 1) = 0 ∧ difference * equal = 0 ∧ + difference * difference⁻¹ - (1 - equal) = 0 := by + by_cases same : difference = 0 <;> simp [same] + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/PatternIrrefutable.lean b/Aiur/Aiur/Circuit/PatternIrrefutable.lean new file mode 100644 index 000000000..f34a26b9a --- /dev/null +++ b/Aiur/Aiur/Circuit/PatternIrrefutable.lean @@ -0,0 +1,134 @@ +import Aiur.Circuit.PatternCorrectness + +namespace Aiur.Circuit.Compiler + +set_option maxHeartbeats 1600000 +set_option maxRecDepth 4096 + +mutual + /-- An irrefutable pattern lowered for a canonical input always collects bindings. -/ + theorem lowerPattern_matches [Field F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) (tags : decls.tagsValid F = true) + {pattern : Pattern F} {wire : Symbolic F} {test : ArithExpr F} {bindings : Locals F} + {before after : BuildState F} + (compiled : lowerPattern decls pattern wire before = .ok ((test, bindings), after)) + (irrefutable : pattern.irrefutable decls = true) {assignment : Var → F} {value : Value F} + (decoded : (wire.map (ArithExpr.denote assignment)).decode decls = some value) : + ∃ values, pattern.bindings value = some values := by + cases pattern with + | wildcard => exact ⟨[], by simp [Pattern.bindings]⟩ + | bind name => exact ⟨[(name, value)], by simp [Pattern.bindings]⟩ + | literal => simp [Pattern.irrefutable] at irrefutable + | tuple patterns => + rcases wire with ⟨type, words⟩ + cases type with + | field | ptr | enum => simp [lowerPattern] at compiled + | tuple types => + simp only [lowerPattern] at compiled + obtain ⟨wires, middle, splitRun, patternRun⟩ := bind_ok.mp compiled + obtain ⟨values, rfl, valuesDecoded⟩ := splitValues_decode checked splitRun decoded + simpa only [Pattern.bindings] using lowerPatterns_matches checked tags patternRun + (by simpa [Pattern.irrefutable] using irrefutable) valuesDecoded + | construct name ctor patterns => + simp only [lowerPattern] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · rename_i typeEq + have typeEq : wire.type = .enum name := by simpa using typeEq + obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + cases found : decls.findEnum? name with + | none => simp [found] at rest + | some definition => + simp only [found] at rest + cases atIndex : definition.constructors[definition.constructors.findIdx (·.name == ctor)]? with + | none => simp [atIndex] at rest + | some constructor => + simp only [atIndex] at rest + have ctorName : constructor.name = ctor := by simpa using List.findIdx_of_getElem?_eq_some atIndex + have only : definition.constructors = [constructor] ∧ + (∀ p ∈ patterns, p.irrefutable decls = true) := by + rcases definition with ⟨defName, ctors⟩ + cases ctors with + | nil => simp [Pattern.irrefutable, found] at irrefutable + | cons first others => + cases others with + | cons => simp [Pattern.irrefutable, found] at irrefutable + | nil => + simp only [Pattern.irrefutable, found, Bool.and_eq_true, beq_iff_eq, + List.all_eq_true, List.mem_map, forall_exists_index, and_imp] at irrefutable + have same : first = constructor := by + simpa [List.findIdx_cons, irrefutable.1] using atIndex + subst first + exact ⟨rfl, by simpa using irrefutable.2⟩ + rcases wire with ⟨type, words⟩ + dsimp only at typeEq + subst type + cases parts : Layout.enumParts definition.constructors.length (.const 0) words with + | none => simp [parts] at rest + | some pair => + rcases pair with ⟨tag, payload⟩ + simp only [parts] at rest + obtain ⟨layout, s₁, layoutRun, rest⟩ := bind_ok.mp rest + obtain ⟨expansion, rfl⟩ := getLayout_eq layoutRun + obtain ⟨values, s₂, splitRun, rest⟩ := bind_ok.mp rest + obtain ⟨tagTest, s₃, tagRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨payloadTest, payloadBindings⟩, s₄, payloadRun, finished⟩ := bind_ok.mp rest + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp finished + obtain ⟨actual, args, rfl, _, payloadDecoded⟩ := + enum_payload_decoded checked tags found atIndex expansion parts splitRun decoded + have formed := (WireValue.decode_spec decoded).2.1 + have same : actual = ctor := by + by_contra different + simp [Value.wellFormed, Declarations.findConstructor?, found, only.1, + ctorName, Ne.symm different] at formed + obtain ⟨values, matched⟩ := lowerPatterns_matches checked tags payloadRun only.2 + (payloadDecoded (same.trans ctorName.symm)) + exact ⟨values, by simpa [Pattern.bindings, same] using matched⟩ + termination_by sizeOf pattern + + theorem lowerPatterns_matches [Field F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) (tags : decls.tagsValid F = true) + {patterns : List (Pattern F)} {wires : List (Symbolic F)} + {test : ArithExpr F} {bindings : Locals F} {before after : BuildState F} + (compiled : lowerPatterns decls patterns wires before = .ok ((test, bindings), after)) + (irrefutable : ∀ pattern ∈ patterns, pattern.irrefutable decls = true) + {assignment : Var → F} {values : List (Value F)} + (decoded : DecodesValues decls (wires.map (WireValue.map (ArithExpr.denote assignment))) values) : + ∃ bindings, Pattern.bindingsList patterns values = some bindings := by + cases patterns with + | nil => + cases wires with + | cons => simp [lowerPatterns] at compiled + | nil => cases decoded; exact ⟨[], by simp [Pattern.bindingsList]⟩ + | cons pattern patterns => + cases wires with + | nil => simp [lowerPatterns] at compiled + | cons wire wires => + simp only [lowerPatterns] at compiled + obtain ⟨⟨head, headBindings⟩, middle, headRun, rest⟩ := bind_ok.mp compiled + obtain ⟨⟨tail, tailBindings⟩, last, tailRun, finished⟩ := bind_ok.mp rest + cases decoded with + | cons headDecode tailDecode => + obtain ⟨head, matchedHead⟩ := lowerPattern_matches checked tags headRun (irrefutable _ (by simp)) headDecode + obtain ⟨tail, matchedTail⟩ := lowerPatterns_matches checked tags tailRun + (fun p h => irrefutable p (by simp [h])) tailDecode + exact ⟨head ++ tail, by simp [Pattern.bindingsList, matchedHead, matchedTail]⟩ + termination_by sizeOf patterns +end + +theorem lowerPattern_irrefutable [Field F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) (tags : decls.tagsValid F = true) + {pattern : Pattern F} {wire : Symbolic F} {test : ArithExpr F} {bindings : Locals F} + {before after : BuildState F} + (compiled : lowerPattern decls pattern wire before = .ok ((test, bindings), after)) + (irrefutable : pattern.irrefutable decls = true) {rom : WireROM F} {calls : CallRelation F} + {assignment : Var → F} (valid : after.Valid rom calls assignment) {value : Value F} + (decoded : (wire.map (ArithExpr.denote assignment)).decode decls = some value) : test.denote assignment = 1 := by + obtain ⟨values, matched⟩ := lowerPattern_matches checked tags compiled irrefutable decoded + have exactTest := (lowerPattern_sound checked tags compiled valid).2.2 value decoded + rcases exactTest with ⟨_, _, one, _⟩ | ⟨absent, _⟩ + · exact one + · rw [matched] at absent; cases absent + +end Aiur.Circuit.Compiler diff --git a/Aiur/Aiur/Circuit/PatternWitness.lean b/Aiur/Aiur/Circuit/PatternWitness.lean new file mode 100644 index 000000000..854f73cf8 --- /dev/null +++ b/Aiur/Aiur/Circuit/PatternWitness.lean @@ -0,0 +1,131 @@ +import Aiur.Circuit.PatternCorrectness +import Aiur.Circuit.IndicatorWitness + +namespace Aiur.Circuit.Compiler + +variable {F : Type} {rom : WireROM F} + +set_option maxHeartbeats 1600000 +set_option maxRecDepth 4096 + +mutual + /-- Exact pattern tests have witnesses for every payload view, including inactive views. -/ + theorem lowerPattern_complete [Field F] [DecidableEq F] {decls : Declarations} + {pattern : Pattern F} {wire : Symbolic F} {test : ArithExpr F} {bindings : Locals F} + {before after : BuildState F} + (compiled : lowerPattern decls pattern wire before = .ok ((test, bindings), after)) + {calls : CallRelation F} {initial : Var → F} + (stateLayout : before.WellFormed) (valid : before.Valid rom calls initial) + (bounded : Bounded before.nextVar wire) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + test.inBounds after.nextVar = true ∧ LocalsBounded after.nextVar bindings := by + cases pattern with + | wildcard => + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp (by simpa only [lowerPattern] using compiled) + exact ⟨initial, .refl stateLayout valid, rfl, by simp [LocalsBounded]⟩ + | bind name => + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp (by simpa only [lowerPattern] using compiled) + exact ⟨initial, .refl stateLayout valid, rfl, by simpa [LocalsBounded] using bounded⟩ + | literal literal => + rcases wire with ⟨type, words⟩ + cases type with + | tuple | ptr | enum => simp [lowerPattern] at compiled + | field => + cases words with + | nil => simp [lowerPattern] at compiled + | cons word rest => cases rest with + | cons => simp [lowerPattern] at compiled + | nil => + simp only [lowerPattern] at compiled + obtain ⟨indicator, middle, indicatorRun, finished⟩ := bind_ok.mp compiled + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp finished + obtain ⟨a, ext, bound⟩ := equalIndicator_complete indicatorRun stateLayout valid + (by simpa [Scalar.Circuit.ArithExpr.inBounds] using bounded word (by simp)) + exact ⟨a, ext, bound, by simp [LocalsBounded]⟩ + | tuple patterns => + rcases wire with ⟨type, words⟩ + cases type with + | field | ptr | enum => simp [lowerPattern] at compiled + | tuple types => + simp only [lowerPattern] at compiled + obtain ⟨wires, middle, splitRun, patternRun⟩ := bind_ok.mp compiled + have unchanged := (splitValues_spec splitRun).1 + subst middle + exact lowerPatterns_complete patternRun stateLayout valid (splitValues_bounded splitRun bounded) + | construct name ctor patterns => + simp only [lowerPattern] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + cases found : decls.findEnum? name with + | none => simp [found] at rest + | some definition => + simp only [found] at rest + cases atIndex : definition.constructors[definition.constructors.findIdx (·.name == ctor)]? with + | none => simp [atIndex] at rest + | some constructor => + simp only [atIndex] at rest + rcases wire with ⟨type, words⟩ + cases parts : Layout.enumParts definition.constructors.length (.const 0) words with + | none => simp [parts] at rest + | some pair => + rcases pair with ⟨tag, payload⟩ + simp only [parts] at rest + obtain ⟨headBound, tailBound⟩ := Layout.enumParts_all parts (by rfl) bounded + obtain ⟨layout, s₁, layoutRun, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := getLayout_eq layoutRun + obtain ⟨values, s₂, splitRun, rest⟩ := bind_ok.mp rest + have unchanged := (splitValues_spec splitRun).1 + subst s₂ + obtain ⟨tagTest, s₃, tagRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨payloadTest, payloadBindings⟩, s₄, payloadRun, finished⟩ := bind_ok.mp rest + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp finished + obtain ⟨a, tagExt, tagBound⟩ := equalIndicator_complete tagRun stateLayout valid + (by simpa [Scalar.Circuit.ArithExpr.inBounds] using headBound) + have valuesBound := splitValues_bounded splitRun (bound := before.nextVar) + (fun p h => tailBound p (List.mem_of_mem_take h)) + obtain ⟨b, payloadExt, payloadBound, localsBound⟩ := lowerPatterns_complete payloadRun + tagExt.layout tagExt.valid (fun w h => (valuesBound w h).mono tagExt.increase) + exact ⟨b, tagExt.trans payloadExt, by + simpa [Scalar.Circuit.ArithExpr.inBounds] using + And.intro (payloadExt.bound tagBound) payloadBound, localsBound⟩ + termination_by sizeOf pattern + + theorem lowerPatterns_complete [Field F] [DecidableEq F] {decls : Declarations} + {patterns : List (Pattern F)} {values : List (Symbolic F)} + {test : ArithExpr F} {bindings : Locals F} {before after : BuildState F} + (compiled : lowerPatterns decls patterns values before = .ok ((test, bindings), after)) + {calls : CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls initial) + (bounded : ∀ value ∈ values, Bounded before.nextVar value) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + test.inBounds after.nextVar = true ∧ LocalsBounded after.nextVar bindings := by + cases patterns with + | nil => + cases values with + | nil => + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp (by simpa only [lowerPatterns] using compiled) + exact ⟨initial, .refl layout valid, rfl, by simp [LocalsBounded]⟩ + | cons => simp [lowerPatterns] at compiled + | cons pattern patterns => + cases values with + | nil => simp [lowerPatterns] at compiled + | cons value values => + simp only [lowerPatterns] at compiled + obtain ⟨⟨head, headBindings⟩, middle, headRun, rest⟩ := bind_ok.mp compiled + obtain ⟨⟨tail, tailBindings⟩, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp finished + obtain ⟨a, headExt, headBound, headLocals⟩ := + lowerPattern_complete headRun layout valid (bounded value (by simp)) + obtain ⟨b, tailExt, tailBound, tailLocals⟩ := lowerPatterns_complete tailRun + headExt.layout headExt.valid + (fun value member => (bounded value (by simp [member])).mono headExt.increase) + exact ⟨b, headExt.trans tailExt, by + simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + And.intro (tailExt.bound headBound) tailBound, + localsBounded_append.mpr ⟨headLocals.mono tailExt.increase, tailLocals⟩⟩ + termination_by sizeOf patterns +end + +end Aiur.Circuit.Compiler diff --git a/Aiur/Aiur/Circuit/ProvenanceModel.lean b/Aiur/Aiur/Circuit/ProvenanceModel.lean new file mode 100644 index 000000000..cf8425537 --- /dev/null +++ b/Aiur/Aiur/Circuit/ProvenanceModel.lean @@ -0,0 +1,324 @@ +import Aiur.Circuit.SemanticMemory +import Aiur.Memory.WireProvenance + +namespace Aiur.Circuit + +variable {F : Type} [Field F] [DecidableEq F] + +/-- Local compiler correctness from canonical arguments with store provenance. +Return canonicality is a conclusion. The ROM need only be functional; unused +cells may be malformed. Completeness remains unconditional. -/ +structure System.ProvenanceModel (program : Program F) (system : System F) : Prop where + declarations : checkDeclarations program.enums = .ok () + argumentTypes : ∀ rom (rule : RuleInstance system rom) signature, + program.findSignature? rule.conclusion.channel = some signature → + rule.conclusion.args.map WireValue.type = signature.params.map Prod.snd + resultType : ∀ rom (rule : RuleInstance system rom) signature, + program.findSignature? rule.conclusion.channel = some signature → + rule.conclusion.result.type = signature.result + sound : ∀ rom, rom.Valid → ∀ (rule : RuleInstance system rom) (calls : Aiur.CallRelation F), + (∀ premise ∈ rule.premises, ∀ args, + DecodesValues program.enums premise.args args → + (∀ value ∈ args, (rom.decode program.enums).Provenance value) → + ∃ result, premise.result.decode program.enums = some result ∧ calls premise.channel args result) → + (∀ name args result, calls name args result → + (∀ value ∈ args, (rom.decode program.enums).Provenance value) → + (rom.decode program.enums).Provenance result) → + ∀ args, DecodesValues program.enums rule.conclusion.args args → + (∀ value ∈ args, (rom.decode program.enums).Provenance value) → + ∃ result, rule.conclusion.result.decode program.enums = some result ∧ + CallStep program rom calls rule.conclusion.channel args result ∧ + (rom.decode program.enums).Provenance result + complete : ∀ rom (calls : CallRelation F) (sourceCalls : Aiur.CallRelation F), + CallsTyped program sourceCalls → Compiler.CallsComplete program.enums sourceCalls calls → + ∀ name args result, CallStep program rom sourceCalls name args result → + ∃ rule : RuleInstance system rom, rule.conclusion.channel = name ∧ + DecodesValues program.enums rule.conclusion.args args ∧ + rule.conclusion.result.decode program.enums = some result ∧ + ∀ premise ∈ rule.premises, calls premise.channel premise.args premise.result + +variable {program : Program F} {system : System F} {rom : WireROM F} + +/-- Canonical arguments and store provenance flow down the finite call tree; +canonical results and source evaluation flow back up. No return encoding is +assumed to decode in this induction. -/ +theorem System.ProvenanceModel.derivation_sound (model : system.ProvenanceModel program) + (valid : rom.Valid) {message : Message F} (tree : Derivation system rom message) + {args : List (Value F)} (arguments : DecodesValues program.enums message.args args) + (trusted : ∀ value ∈ args, (rom.decode program.enums).Provenance value) : + ∃ result, message.result.decode program.enums = some result ∧ + ROMEvalCall (rom.decode program.enums) program message.channel args result ∧ + (rom.decode program.enums).Provenance result := by + suffices ∀ args, DecodesValues program.enums message.args args → + (∀ value ∈ args, (rom.decode program.enums).Provenance value) → + ∃ result, message.result.decode program.enums = some result ∧ + ROMEvalCall (rom.decode program.enums) program message.channel args result ∧ + (rom.decode program.enums).Provenance result from this args arguments trusted + clear arguments trusted args + induction tree using Derivation.rec + (motive_2 := fun messages _ => ∀ message ∈ messages, ∀ args, + DecodesValues program.enums message.args args → + (∀ value ∈ args, (rom.decode program.enums).Provenance value) → + ∃ result, message.result.decode program.enums = some result ∧ + ROMEvalCall (rom.decode program.enums) program message.channel args result ∧ + (rom.decode program.enums).Provenance result) with + | node chip row lookup rowValid children ih => + intro args arguments trusted + obtain ⟨result, decoded, ⟨locals, body, prepared, evaluated⟩, resultTrusted⟩ := + model.sound rom valid (.node chip row lookup rowValid) + (ROMEvalCall (rom.decode program.enums) program) (by + intro premise member args arguments trusted + obtain ⟨value, decoded, evaluated, _⟩ := ih premise member args arguments trusted + exact ⟨value, decoded, evaluated⟩) + (fun _ _ _ evaluated trusted => evaluated.provenance (WireROM.decode_valid valid) trusted) + args arguments trusted + exact ⟨result, decoded, .intro prepared evaluated.toEvalExpr, resultTrusted⟩ + | table member => + intro args arguments trusted + obtain ⟨result, decoded, ⟨locals, body, prepared, evaluated⟩, resultTrusted⟩ := + model.sound rom valid (.table _ member) (ROMEvalCall (rom.decode program.enums) program) + (by simp [RuleInstance.premises]) + (fun _ _ _ evaluated trusted => evaluated.provenance (WireROM.decode_valid valid) trusted) + args arguments trusted + exact ⟨result, decoded, .intro prepared evaluated.toEvalExpr, resultTrusted⟩ + | nil => simp_all + | cons _ _ head tail => + rename_i message member args arguments trusted + rcases List.mem_cons.mp member with rfl | member + · exact head args arguments trusted + · exact tail message member args arguments trusted + +theorem System.ProvenanceModel.sound_encoded (model : system.ProvenanceModel program) + (valid : rom.Valid) {name : String} {wires : List (WireValue F)} {output : WireValue F} + (derived : CircuitEvaluates system rom name wires output) + {args : List (Value F)} {result : Value F} + (arguments : DecodesValues program.enums wires args) (decoded : output.decode program.enums = some result) + (trusted : ∀ value ∈ args, (rom.decode program.enums).Provenance value) : + ROMEvalCall (rom.decode program.enums) program name args result := by + obtain ⟨tree⟩ := derived + obtain ⟨otherResult, otherDecoded, evaluated, _⟩ := model.derivation_sound valid tree arguments trusted + have sameResult := Option.some.inj (decoded.symm.trans otherDecoded) + subst otherResult + exact evaluated + +/-- Validated pointer-free public inputs start the induction. The decoded +return is a conclusion, not a public-input assumption. -/ +theorem System.ProvenanceModel.derivation_evaluates (model : system.ProvenanceModel program) + (valid : rom.Valid) {message : Message F} (free : message.PublicArguments program.enums) + (canonical : ∃ args, DecodesValues program.enums message.args args) + (tree : Derivation system rom message) : message.Evaluates program rom := by + obtain ⟨args, arguments⟩ := canonical + have trusted : ∀ value ∈ args, (rom.decode program.enums).Provenance value := by + intro value member + have typeMember : value.type ∈ message.args.map WireValue.type := by + rw [← arguments.types] + exact List.mem_map.mpr ⟨value, member, rfl⟩ + obtain ⟨wire, wireMember, same⟩ := List.mem_map.mp typeMember + exact .of_pointerFree value + (Value.pointerFree_of_type (same ▸ free wire wireMember) (arguments.wellFormed value member)) + obtain ⟨result, decoded, evaluated, _⟩ := model.derivation_sound valid tree arguments trusted + exact ⟨args, result, arguments, decoded, evaluated⟩ + +theorem System.ProvenanceModel.calls_typed (model : system.ProvenanceModel program) : + CallsTyped program (EncodedEvaluates program.enums system rom) := by + intro name args result evaluated signature found + obtain ⟨wires, output, _, decoded, ⟨tree⟩⟩ := evaluated + cases tree with + | node chip row lookup valid children => + have declared := model.resultType rom (.node chip row lookup valid) signature found + exact ⟨(WireValue.decode_spec decoded).1.trans declared, (WireValue.decode_spec decoded).2.1⟩ + | table member => + have declared := model.resultType rom (.table _ member) signature found + exact ⟨(WireValue.decode_spec decoded).1.trans declared, (WireValue.decode_spec decoded).2.1⟩ + +theorem System.ProvenanceModel.calls_complete (model : system.ProvenanceModel program) : + Compiler.CallsComplete program.enums (EncodedEvaluates program.enums system rom) + (CircuitEvaluates system rom) := by + intro name args result evaluated wires output arguments decoded + obtain ⟨oldWires, oldOutput, oldArguments, oldDecoded, derived⟩ := evaluated + have sameArgs := arguments.wires_unique model.declarations oldArguments + have sameResult := WireValue.decode_injective model.declarations decoded oldDecoded + simpa only [sameArgs, sameResult] using derived + +theorem System.ProvenanceModel.evaluation_complete (model : system.ProvenanceModel program) + {name : String} {args : List (Value F)} {result : Value F} + (evaluated : ROMEvalCall (rom.decode program.enums) program name args result) : + EncodedEvaluates program.enums system rom name args result := by + induction evaluated using ROMEvalCall.rec + (motive_1 := fun locals expr value _ => + ROMEvalExprWith program.enums (rom.decode program.enums) (EncodedEvaluates program.enums system rom) locals expr value) + (motive_2 := fun locals exprs values _ => + ROMEvalArgsWith program.enums (rom.decode program.enums) (EncodedEvaluates program.enums system rom) locals exprs values) with + | literal => exact .literal + | var lookup => exact .var lookup + | tuple _ ih => exact .tuple ih + | construct _ ih => exact .construct ih + | project _ projected ih => exact .project ih projected + | letValue _ matched _ inputIH bodyIH => exact .letValue inputIH matched bodyIH + | store _ cell ih => exact .store ih cell + | load _ cell typed ih => exact .load ih cell typed + | hint _ typed ih => exact .hint ih typed + | neg _ operation ih => exact .neg ih operation + | assertEq _ _ operation leftIH rightIH => exact .assertEq leftIH rightIH operation + | binary _ _ operation leftIH rightIH => exact .binary leftIH rightIH operation + | call _ _ argsIH calleeIH => exact .call argsIH calleeIH + | matchValue _ selected _ inputIH bodyIH => exact .matchValue inputIH selected bodyIH + | nil => exact .nil + | cons _ _ headIH tailIH => exact .cons headIH tailIH + | intro prepared _ bodyIH => + obtain ⟨rule, name, arguments, decoded, premises⟩ := + model.complete rom (CircuitEvaluates system rom) (EncodedEvaluates program.enums system rom) + model.calls_typed model.calls_complete _ _ _ ⟨_, _, prepared, bodyIH⟩ + refine ⟨rule.conclusion.args, rule.conclusion.result, arguments, decoded, ?_⟩ + have tree := rule.derives premises + simpa only [← name, CircuitEvaluates] using tree + +theorem System.ProvenanceModel.complete_encoded (model : system.ProvenanceModel program) + {name : String} {args : List (Value F)} {result : Value F} + (evaluated : ROMEvalCall (rom.decode program.enums) program name args result) + {wires : List (WireValue F)} {output : WireValue F} + (arguments : DecodesValues program.enums wires args) (decoded : output.decode program.enums = some result) : + CircuitEvaluates system rom name wires output := + model.calls_complete name args result (model.evaluation_complete evaluated) wires output arguments decoded + +theorem System.ProvenanceModel.evaluates_iff (model : system.ProvenanceModel program) + (valid : rom.Valid) {name : String} {args : List (Value F)} {result : Value F} + (trusted : ∀ value ∈ args, (rom.decode program.enums).Provenance value) : + ROMEvalCall (rom.decode program.enums) program name args result ↔ + EncodedEvaluates program.enums system rom name args result := by + refine ⟨model.evaluation_complete, ?_⟩ + rintro ⟨wires, output, arguments, decoded, derived⟩ + exact model.sound_encoded valid derived arguments decoded trusted + +/-- A compiler that validates every read refines a compiler whose completeness +uses the same source steps, including for cyclic memoized graphs. -/ +theorem System.SemanticModel.supportRefinesProvenance {source target : System F} + (sourceModel : source.SemanticModel program) (targetModel : target.ProvenanceModel program) : + source.SupportRefines target := by + intro rom rule supported + let calls : CallRelation F := fun name args result => ⟨name, args, result⟩ ∈ rule.premises + let sourceCalls : Aiur.CallRelation F := fun name args result => + ∃ wires output, DecodesValues program.enums wires args ∧ + output.decode program.enums = some result ∧ calls name wires output + have typed : CallsTyped program sourceCalls := by + intro name args result available signature found + obtain ⟨wires, output, arguments, decoded, member⟩ := available + obtain ⟨provider, same⟩ := supported ⟨name, wires, output⟩ member + have declared := sourceModel.resultType rom provider signature (by simpa only [same] using found) + refine ⟨(WireValue.decode_spec decoded).1.trans ?_, (WireValue.decode_spec decoded).2.1⟩ + simpa only [same] using declared + have callComplete : Compiler.CallsComplete program.enums sourceCalls calls := by + intro name args result available wires output arguments decoded + obtain ⟨previousArgs, previousResult, previousArguments, previousDecoded, member⟩ := available + have sameArgs := arguments.wires_unique sourceModel.declarations previousArguments + have sameResult := WireValue.decode_injective sourceModel.declarations decoded previousDecoded + simpa only [sameArgs, sameResult] using member + obtain ⟨args, result, arguments, decoded, step⟩ := sourceModel.sound rom rule sourceCalls + (fun premise member args result arguments decoded => + ⟨premise.args, premise.result, arguments, decoded, member⟩) + obtain ⟨next, name, nextArguments, nextDecoded, premises⟩ := + targetModel.complete rom calls sourceCalls typed callComplete rule.conclusion.channel args result step + have sameArgs := nextArguments.wires_unique sourceModel.declarations arguments + have sameResult := WireValue.decode_injective sourceModel.declarations nextDecoded decoded + refine ⟨next, ?_, ?_⟩ + · cases nextConclusion : next.conclusion + cases sourceConclusion : rule.conclusion + simp only [nextConclusion, sourceConclusion] at name sameArgs sameResult ⊢ + simp_all only [Message.mk.injEq] + · intro premise member + exact premises premise member + +private theorem provenance_public_arguments {decls : Declarations} + {wires : List (WireValue F)} {values : List (Value F)} + (arguments : DecodesValues decls wires values) + (free : ∀ value ∈ values, value.type.pointerFree decls = true) : + ∀ wire ∈ wires, wire.type.pointerFree decls = true := by + induction arguments with + | nil => simp + | @cons wire value wires values head tail ih => + have headFree := free value (by simp) + rw [(WireValue.decode_spec head).1] at headFree + simpa using And.intro headFree (ih (fun v h => free v (by simp [h]))) + +/-- Heap completeness only uses local compiler correctness. Addresses may be +chosen freely, provided distinct allocated cells have distinct field addresses. -/ +theorem System.ProvenanceModel.heap_complete (model : system.ProvenanceModel program) + (checked : typecheck program = .ok ()) (tags : program.enums.tagsValid F = true) + (enums : system.enums = program.enums) + {name : String} {args : List (SourceValue F)} {value : SourceValue F} {heap : Heap F} + (entry : checkEntry program name = .ok ()) (evaluated : EvalFn program name args [] value heap) + (encode : Nat → F) + (distinct : ∀ i j, i < heap.length → j < heap.length → encode i = encode j → i = j) : + EncodedEntryDerives system name (entryValues args) (value.mapAddress encode) := by + have free := evaluated.public_pointerFree entry + have heapGood := (evaluated.heap_good checked (by simp [Heap.Good]) + (fun arg member => Value.pointerNames_of_free (free arg member))).2 + let table := ROM.ofHeap heap encode + have good := ROM.ofHeap_good heapGood encode + have decodeTable := ROM.decode_encode model.declarations tags good + have body := evaluated.toROM (ROM.ofHeap_cells heap encode) + have encodedBody : ROMEvalCall ((table.encode program.enums).decode program.enums) program name + (args.map (Value.mapAddress encode)) (value.mapAddress encode) := by + rw [decodeTable]; exact body + obtain ⟨wires, output, arguments, decoded, derives⟩ := model.evaluation_complete encodedBody + rw [entryValues_eq free encode] at arguments + have argsFree : ∀ arg ∈ entryValues args, arg.type.pointerFree program.enums = true := by + intro arg member + obtain ⟨source, sourceMember, rfl⟩ := List.mem_map.mp member + simpa using (evaluated.publicArguments entry source sourceMember).1 + have tableValid := ROM.encode_valid model.declarations good (ROM.ofHeap_valid heap encode distinct) + refine ⟨wires, output, ?_, ?_, ?_⟩ + · simpa only [enums] using arguments + · simpa only [enums] using decoded + · refine ⟨?_, ?_, table.encode program.enums, tableValid, derives⟩ + · exact ⟨by simpa only [enums] using arguments.each, + by simpa only [enums] using + (show ∃ value, output.decode program.enums = some value from ⟨_, decoded⟩)⟩ + · simpa only [enums, Message.PublicArguments] using provenance_public_arguments arguments argsFree + +/-- The validated function interface establishes public input types before +provenance is used; this does not assume the desired evaluation judgment. -/ +theorem System.ProvenanceModel.publicArguments (model : system.ProvenanceModel program) + {message : Message F} (entry : checkEntry program message.channel = .ok ()) + (derived : Derives system rom message) : message.PublicArguments program.enums := by + obtain ⟨tree⟩ := derived + obtain ⟨rule, _, same⟩ := tree.root_instance + obtain ⟨signature, found, free⟩ := (checkEntry_ok program message.channel).mp entry + have types := model.argumentTypes rom rule signature (by simpa only [same] using found) + rw [same] at types + intro wire member + apply free wire.type + rw [← types] + exact List.mem_map.mpr ⟨wire, member, rfl⟩ + +theorem System.ProvenanceModel.heap_sound (model : system.ProvenanceModel program) + (valid : rom.Valid) {name : String} {args : List (SourceValue F)} {result : Value F} + (entry : checkEntry program name = .ok ()) {wires : List (WireValue F)} {output : WireValue F} + (derived : CircuitEvaluates system rom name wires output) + (arguments : DecodesValues program.enums wires (entryValues args)) + (decoded : output.decode program.enums = some result) : + ∃ source heap, EvalFn program name args [] source heap ∧ + Represents (rom.decode program.enums) heap source result := by + have publicArgs := model.publicArguments entry derived + have encodedFree : ∀ value ∈ entryValues args, value.pointerFree = true := by + intro value member + have typeMember : value.type ∈ wires.map WireValue.type := by + rw [← arguments.types] + exact List.mem_map.mpr ⟨value, member, rfl⟩ + obtain ⟨wire, wireMember, same⟩ := List.mem_map.mp typeMember + exact Value.pointerFree_of_type (same ▸ publicArgs wire wireMember) (arguments.wellFormed value member) + have trusted : ∀ value ∈ entryValues args, (rom.decode program.enums).Provenance value := + fun value member => .of_pointerFree value (encodedFree value member) + have evaluated := model.sound_encoded valid derived arguments decoded trusted + have free : ∀ value ∈ args, value.pointerFree = true := by + intro value member + have formed := evaluated.publicArguments entry (value.mapAddress (fun _ => 0)) + (List.mem_map.mpr ⟨value, member, rfl⟩) + exact Value.pointerFree_of_type (by simpa using formed.1) (by simpa using formed.2) + have relatedArgs : RepresentsArgs (rom.decode program.enums) [] args (entryValues args) := by + apply List.forall₂_map_right_iff.mpr + exact List.forall₂_same.mpr (fun value member => Represents.of_pointerFree value (free value member) _) + obtain ⟨source, heap, evaluated, _, related⟩ := evaluated.realize (WireROM.decode_valid valid) relatedArgs + exact ⟨source, heap, evaluated, related⟩ + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/RowWitness.lean b/Aiur/Aiur/Circuit/RowWitness.lean new file mode 100644 index 000000000..b766d0152 --- /dev/null +++ b/Aiur/Aiur/Circuit/RowWitness.lean @@ -0,0 +1,45 @@ +import Aiur.Circuit.WitnessBasic +import Mathlib.Data.List.OfFn + +namespace Aiur.Circuit + +variable {F : Type} {rom : WireROM F} + +/-- Store the allocated prefix of a witness assignment as a finite row. -/ +def Row.ofAssignment (name : String) (bound : Nat) (assignment : Var → F) : Row F := + ⟨name, List.ofFn (fun id : Fin bound => assignment id)⟩ + +@[simp] theorem Row.ofAssignment_length (name : String) (bound : Nat) (assignment : Var → F) : + (Row.ofAssignment name bound assignment).values.length = bound := by simp [Row.ofAssignment] + +theorem Row.ofAssignment_agree [Zero F] (name : String) (bound : Nat) (assignment : Var → F) + (id : Var) (inside : id < bound) : + (Row.ofAssignment name bound assignment).assignment id = assignment id := by + simp [Row.assignment, Scalar.Circuit.Row.assignment, Row.ofAssignment, inside] + +namespace Compiler + +@[simp] theorem bounded_vars {bound : Nat} {value : WireValue Var} : + Bounded (F := F) bound (value.map ArithExpr.var) ↔ ∀ id ∈ value.words, id < bound := by + simp [Bounded, WireValue.words_map, ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] + +theorem BuildState.finite_witness [Field F] {calls : CallRelation F} {state : BuildState F} + {assignment : Var → F} (layout : state.WellFormed) (valid : state.Valid rom calls assignment) + (name : String) : + Extension rom calls state state assignment (Row.ofAssignment name state.nextVar assignment).assignment := + ⟨le_rfl, Row.ofAssignment_agree _ _ _, layout, + valid.of_agree layout (Row.ofAssignment_agree _ _ _)⟩ + +theorem chip_wellFormed {name : String} {inputs : List (WireValue Var)} {output : WireValue Var} {state : BuildState F} + (layout : state.WellFormed) + (inputsBound : ∀ input ∈ inputs, Bounded (F := F) state.nextVar (input.map ArithExpr.var)) + (outputBound : Bounded (F := F) state.nextVar (output.map ArithExpr.var)) : + (Chip.mk name inputs (output.map ArithExpr.var) state.nextVar state.constraints.toList state.sends.toList state.memory.toList).wellFormed = true := by + simp only [Chip.wellFormed, Bool.and_eq_true, List.all_eq_true, decide_eq_true_eq] + refine ⟨⟨⟨⟨?_, outputBound⟩, layout.constraints⟩, layout.sends⟩, layout.memory⟩ + intro id member + obtain ⟨input, member, leaf⟩ := List.mem_flatMap.mp member + exact bounded_vars.mp (inputsBound input member) id leaf + +end Compiler +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/RuleEquivalence.lean b/Aiur/Aiur/Circuit/RuleEquivalence.lean new file mode 100644 index 000000000..6fbd5a16d --- /dev/null +++ b/Aiur/Aiur/Circuit/RuleEquivalence.lean @@ -0,0 +1,156 @@ +import Aiur.Circuit.CheckerContext +import Aiur.Circuit.MemoAcyclic + +namespace Aiur.Circuit + +variable {F : Type} [Field F] [DecidableEq F] + +/-- A local conclusion/premise relation. Auxiliary assignments are existential; +premises retain their multiplicities but may be reordered. Static maps are +zero-premise rules in this same interface. -/ +def System.Rule (system : System F) (rom : WireROM F) + (conclusion : Message F) (premises : List (Message F)) : Prop := + ∃ rule : RuleInstance system rom, + rule.conclusion = conclusion ∧ rule.premises.Perm premises + +def System.RuleRefines (source target : System F) : Prop := + ∀ rom conclusion premises, source.Rule rom conclusion premises → target.Rule rom conclusion premises + +def System.RuleEquiv (source target : System F) : Prop := + ∀ rom conclusion premises, source.Rule rom conclusion premises ↔ target.Rule rom conclusion premises + +theorem System.RuleEquiv.refl (system : System F) : system.RuleEquiv system := fun _ _ _ => Iff.rfl + +theorem System.RuleEquiv.symm {source target : System F} (same : source.RuleEquiv target) : + target.RuleEquiv source := fun rom conclusion premises => (same rom conclusion premises).symm + +theorem System.RuleEquiv.trans {a b c : System F} + (ab : a.RuleEquiv b) (bc : b.RuleEquiv c) : a.RuleEquiv c := + fun rom conclusion premises => (ab rom conclusion premises).trans (bc rom conclusion premises) + +theorem System.RuleEquiv.forward {source target : System F} (same : source.RuleEquiv target) : + source.RuleRefines target := fun rom conclusion premises => (same rom conclusion premises).mp + +theorem System.RuleRefines.derives {source target : System F} + (refines : source.RuleRefines target) {rom : WireROM F} {message : Message F} + (derived : Derives source rom message) : Derives target rom message := by + obtain ⟨tree⟩ := derived + induction tree using Derivation.rec + (motive_2 := fun messages _ => ∀ message ∈ messages, Derives target rom message) with + | node chip row lookup valid children ih => + obtain ⟨rule, conclusion, premises⟩ := refines rom _ _ + ⟨.node chip row lookup valid, rfl, List.Perm.refl _⟩ + change rule.conclusion = chip.receive row at conclusion + rw [← conclusion] + exact rule.derives (fun message member => ih message (premises.mem_iff.mp member)) + | table member => + obtain ⟨rule, conclusion, premises⟩ := refines rom _ _ + ⟨.table _ member, rfl, List.Perm.refl []⟩ + change rule.conclusion = _ at conclusion + dsimp only [RuleInstance.conclusion] at conclusion + rw [← conclusion] + exact rule.derives (fun message member => by simpa using premises.mem_iff.mp member) + | nil => simp_all + | cons _ _ head tail => + rename_i message member + rcases List.mem_cons.mp member with rfl | member + · exact head + · exact tail message member + +theorem System.RuleEquiv.derives_iff {source target : System F} + (same : source.RuleEquiv target) {rom : WireROM F} {message : Message F} : + Derives source rom message ↔ Derives target rom message := + ⟨same.forward.derives, same.symm.forward.derives⟩ + +/-- Pick a corresponding row separately for every proof node, without merging +nodes whose conclusions happen to agree. -/ +noncomputable def System.RuleRefines.instance {source target : System F} + (refines : source.RuleRefines target) {rom : WireROM F} + (rule : RuleInstance source rom) : RuleInstance target rom := + Classical.choose (refines rom rule.conclusion rule.premises ⟨rule, rfl, List.Perm.refl _⟩) + +theorem System.RuleRefines.instance_spec {source target : System F} + (refines : source.RuleRefines target) {rom : WireROM F} (rule : RuleInstance source rom) : + (refines.instance rule).conclusion = rule.conclusion ∧ + (refines.instance rule).premises.Perm rule.premises := + Classical.choose_spec (refines rom rule.conclusion rule.premises ⟨rule, rfl, List.Perm.refl _⟩) + +private theorem premise_index {source target : System F} + (refines : source.RuleRefines target) {rom : WireROM F} (rule : RuleInstance source rom) + (j : Fin (refines.instance rule).premises.length) : + ∃ k : Fin rule.premises.length, rule.premises[k] = (refines.instance rule).premises[j] := by + have member := (refines.instance_spec rule).2.mem_iff.mp + (List.getElem_mem (l := (refines.instance rule).premises) (n := j.val) j.isLt) + obtain ⟨k, bounded, same⟩ := List.mem_iff_getElem.mp member + exact ⟨⟨k, bounded⟩, same⟩ + +/-- Transport a graph with the same node indices. Each new premise occurrence +uses an edge of its corresponding old node; sharing and cycles are allowed. -/ +noncomputable def MemoDerivation.mapRules {source target : System F} {rom : WireROM F} + {message : Message F} (graph : MemoDerivation source rom message) + (refines : source.RuleRefines target) : MemoDerivation target rom message where + size := graph.size + node i := refines.instance (graph.node i) + root := graph.root + root_claim := (refines.instance_spec (graph.node graph.root)).1.trans graph.root_claim + target i j := graph.target i (Classical.choose (premise_index refines (graph.node i) j)) + target_claim i j := by + exact ((refines.instance_spec _).1.trans (graph.target_claim i _)).trans + (Classical.choose_spec (premise_index refines (graph.node i) j)) + +theorem MemoDerivation.mapRules_dependency {source target : System F} {rom : WireROM F} + {message : Message F} (graph : MemoDerivation source rom message) + (refines : source.RuleRefines target) {child parent : Fin graph.size} + (edge : (graph.mapRules refines).Dependency child parent) : graph.Dependency child parent := by + obtain ⟨j, same⟩ := edge + exact ⟨Classical.choose (premise_index refines (graph.node parent) j), same⟩ + +theorem MemoDerivation.mapRules_acyclic {source target : System F} {rom : WireROM F} + {message : Message F} (graph : MemoDerivation source rom message) + (refines : source.RuleRefines target) (acyclic : graph.Acyclic) : + (graph.mapRules refines).Acyclic := by + intro i cycle + exact acyclic i (Relation.TransGen.mono (fun _ _ edge => graph.mapRules_dependency refines edge) i i cycle) + +theorem System.RuleRefines.memoDerives {source target : System F} + (refines : source.RuleRefines target) {rom : WireROM F} {message : Message F} + (derived : MemoDerives source rom message) : MemoDerives target rom message := by + obtain ⟨graph⟩ := derived + exact ⟨graph.mapRules refines⟩ + +theorem System.RuleEquiv.memoDerives_iff {source target : System F} + (same : source.RuleEquiv target) {rom : WireROM F} {message : Message F} : + MemoDerives source rom message ↔ MemoDerives target rom message := + ⟨same.forward.memoDerives, same.symm.forward.memoDerives⟩ + +theorem System.RuleEquiv.acyclic_iff {source target : System F} + (same : source.RuleEquiv target) {rom : WireROM F} {message : Message F} : + (∃ graph : MemoDerivation source rom message, graph.Acyclic) ↔ + (∃ graph : MemoDerivation target rom message, graph.Acyclic) := by + constructor + · rintro ⟨graph, acyclic⟩ + exact ⟨graph.mapRules same.forward, graph.mapRules_acyclic same.forward acyclic⟩ + · rintro ⟨graph, acyclic⟩ + exact ⟨graph.mapRules same.symm.forward, graph.mapRules_acyclic same.symm.forward acyclic⟩ + +/-- Equality of local rules is sufficient for existential trace equivalence; +the rows and their auxiliary widths need not be the same. -/ +theorem System.RuleEquiv.check_iff {source target : System F} + (same : source.RuleEquiv target) {rom : WireROM F} {root : Message F} + (sourceContext : source.checkContext rom root = .ok ()) + (targetContext : target.checkContext rom root = .ok ()) : + (∃ rows, source.check rom root rows = .ok ()) ↔ + (∃ rows, target.check rom root rows = .ok ()) := by + rw [source.check_derives_iff sourceContext, target.check_derives_iff targetContext] + exact same.derives_iff + +theorem System.RuleEquiv.checkMemo_iff {source target : System F} + (same : source.RuleEquiv target) {rom : WireROM F} {root : Message F} + (sourceContext : source.checkContext rom root = .ok ()) + (targetContext : target.checkContext rom root = .ok ()) : + (∃ rows, source.checkMemo rom root rows = .ok ()) ↔ + (∃ rows, target.checkMemo rom root rows = .ok ()) := by + rw [source.checkMemo_derives_iff sourceContext, target.checkMemo_derives_iff targetContext] + exact same.memoDerives_iff + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/RuleTranslation.lean b/Aiur/Aiur/Circuit/RuleTranslation.lean new file mode 100644 index 000000000..0c0fd861e --- /dev/null +++ b/Aiur/Aiur/Circuit/RuleTranslation.lean @@ -0,0 +1,242 @@ +import Aiur.Circuit.RuleEquivalence +import Mathlib.Data.Fintype.Sigma + +namespace Aiur.Circuit + +variable {F : Type} [Field F] [DecidableEq F] + +def Message.rename (rename : String → String) (message : Message F) : Message F := + { message with channel := rename message.channel } + +/-- Uniform lifting is required for each original channel, not merely for the +union of the rules in an equivalence class. -/ +structure System.RuleTranslation (source target : System F) (rename : String → String) : Prop where + forward : ∀ rom (rule : RuleInstance source rom), ∃ next : RuleInstance target rom, + next.conclusion = rule.conclusion.rename rename ∧ + next.premises = rule.premises.map (Message.rename rename) + backward : ∀ rom (rule : RuleInstance target rom) (claim : Message F), + claim.rename rename = rule.conclusion → ∃ previous : RuleInstance source rom, + previous.conclusion = claim ∧ + previous.premises.map (Message.rename rename) = rule.premises + +theorem System.RuleTranslation.derives_forward {source target : System F} {rename : String → String} + (same : source.RuleTranslation target rename) {rom : WireROM F} {claim : Message F} + (derived : Derives source rom claim) : Derives target rom (claim.rename rename) := by + obtain ⟨tree⟩ := derived + induction tree using Derivation.rec + (motive_2 := fun messages _ => ∀ message ∈ messages, Derives target rom (message.rename rename)) with + | node chip row lookup valid children ih => + obtain ⟨rule, conclusion, premises⟩ := same.forward rom (.node chip row lookup valid) + change rule.conclusion = (chip.receive row).rename rename at conclusion + rw [← conclusion] + apply rule.derives + intro message member + rw [premises] at member + obtain ⟨old, oldMember, renamed⟩ := List.mem_map.mp member + rw [← renamed] + exact ih old oldMember + | table member => + obtain ⟨rule, conclusion, premises⟩ := same.forward rom (.table _ member) + dsimp only [RuleInstance.conclusion] at conclusion + rw [← conclusion] + have empty : rule.premises = [] := premises + exact rule.derives (by rw [empty]; simp) + | nil => simp_all + | cons _ _ head tail => + rename_i message member + rcases List.mem_cons.mp member with rfl | member + · exact head + · exact tail message member + +theorem System.RuleTranslation.derives_backward {source target : System F} {rename : String → String} + (same : source.RuleTranslation target rename) {rom : WireROM F} {claim : Message F} + (derived : Derives target rom (claim.rename rename)) : Derives source rom claim := by + obtain ⟨tree⟩ := derived + have lift {message : Message F} (tree : Derivation target rom message) : + ∀ claim, claim.rename rename = message → Derives source rom claim := by + refine Derivation.rec + (motive_1 := fun message _ => ∀ claim, claim.rename rename = message → Derives source rom claim) + (motive_2 := fun messages _ => ∀ message ∈ messages, ∀ claim, + claim.rename rename = message → Derives source rom claim) ?_ ?_ ?_ ?_ tree + · intro chip row lookup valid children ih claim renamed + obtain ⟨rule, conclusion, premises⟩ := same.backward rom (.node chip row lookup valid) claim renamed + change rule.premises.map (Message.rename rename) = chip.premises row at premises + rw [← conclusion] + apply rule.derives + intro premise member + exact ih (premise.rename rename) (by rw [← premises]; exact List.mem_map.mpr ⟨premise, member, rfl⟩) + premise rfl + · intro message member claim renamed + obtain ⟨rule, conclusion, premises⟩ := same.backward rom (.table _ member) claim renamed + rw [← conclusion] + have empty : rule.premises = [] := List.map_eq_nil_iff.mp premises + exact rule.derives (by simp [empty]) + · simp + · intro first rest headTree tailTrees head tail message member claim renamed + rcases List.mem_cons.mp member with rfl | member + · exact head claim renamed + · exact tail message member claim renamed + exact lift tree claim rfl + +theorem System.RuleTranslation.derives_iff {source target : System F} {rename : String → String} + (same : source.RuleTranslation target rename) {rom : WireROM F} {claim : Message F} : + Derives source rom claim ↔ Derives target rom (claim.rename rename) := + ⟨same.derives_forward, same.derives_backward⟩ + +/-- A finite index type is equivalent to the concrete finite indices used by +the graph datatype. This is also useful when a translated node needs copies. -/ +noncomputable def MemoDerivation.ofFinite {system : System F} {rom : WireROM F} {claim : Message F} + {I : Type} [Fintype I] (node : I → RuleInstance system rom) (root : I) + (root_claim : (node root).conclusion = claim) + (target : (i : I) → Fin (node i).premises.length → I) + (target_claim : ∀ i j, (node (target i j)).conclusion = (node i).premises[j]) : + MemoDerivation system rom claim where + size := Fintype.card I + node i := node ((Fintype.equivFin I).symm i) + root := Fintype.equivFin I root + root_claim := by simpa using root_claim + target i j := Fintype.equivFin I (target ((Fintype.equivFin I).symm i) j) + target_claim i j := by simpa using target_claim ((Fintype.equivFin I).symm i) j + +/-- Mapping graph nodes to another graph and preserving every edge preserves +acyclicity. The node map need not be injective. -/ +theorem MemoDerivation.acyclic_of_projection {source target : System F} {rom : WireROM F} + {a b : Message F} (original : MemoDerivation source rom a) (next : MemoDerivation target rom b) + (project : Fin next.size → Fin original.size) + (edges : ∀ {child parent}, next.Dependency child parent → + original.Dependency (project child) (project parent)) + (acyclic : original.Acyclic) : next.Acyclic := by + have paths {a b} (path : Relation.TransGen next.Dependency a b) : + Relation.TransGen original.Dependency (project a) (project b) := by + induction path with + | single edge => exact .single (edges edge) + | tail _ edge ih => exact .tail ih (edges edge) + exact fun i path => acyclic (project i) (paths path) + +noncomputable def System.RuleTranslation.forwardInstance {source target : System F} + {rename : String → String} (same : source.RuleTranslation target rename) + {rom : WireROM F} (rule : RuleInstance source rom) : RuleInstance target rom := + Classical.choose (same.forward rom rule) + +theorem System.RuleTranslation.forwardInstance_spec {source target : System F} + {rename : String → String} (same : source.RuleTranslation target rename) + {rom : WireROM F} (rule : RuleInstance source rom) : + (same.forwardInstance rule).conclusion = rule.conclusion.rename rename ∧ + (same.forwardInstance rule).premises = rule.premises.map (Message.rename rename) := + Classical.choose_spec (same.forward rom rule) + +noncomputable def MemoDerivation.renameRules {source target : System F} {rename : String → String} + {rom : WireROM F} {claim : Message F} (graph : MemoDerivation source rom claim) + (same : source.RuleTranslation target rename) : MemoDerivation target rom (claim.rename rename) where + size := graph.size + node i := same.forwardInstance (graph.node i) + root := graph.root + root_claim := (same.forwardInstance_spec _).1.trans (congrArg (Message.rename rename) graph.root_claim) + target i j := graph.target i ⟨j.val, by simpa [(same.forwardInstance_spec _).2] using j.isLt⟩ + target_claim i j := by + rw [(same.forwardInstance_spec _).1, graph.target_claim] + simp only [Fin.getElem_fin, (same.forwardInstance_spec _).2, List.getElem_map] + +theorem MemoDerivation.renameRules_acyclic {source target : System F} {rename : String → String} + {rom : WireROM F} {claim : Message F} (graph : MemoDerivation source rom claim) + (same : source.RuleTranslation target rename) (acyclic : graph.Acyclic) : + (graph.renameRules same).Acyclic := by + apply graph.acyclic_of_projection (graph.renameRules same) id ?_ acyclic + rintro child parent ⟨j, rfl⟩ + exact ⟨⟨j.val, by simpa only [renameRules, (same.forwardInstance_spec _).2, + List.length_map, id] using j.isLt⟩, rfl⟩ + +noncomputable def System.RuleTranslation.backwardInstance {source target : System F} + {rename : String → String} (same : source.RuleTranslation target rename) + {rom : WireROM F} (rule : RuleInstance target rom) (claim : Message F) + (renamed : claim.rename rename = rule.conclusion) : RuleInstance source rom := + Classical.choose (same.backward rom rule claim renamed) + +theorem System.RuleTranslation.backwardInstance_spec {source target : System F} + {rename : String → String} (same : source.RuleTranslation target rename) + {rom : WireROM F} (rule : RuleInstance target rom) (claim : Message F) + (renamed : claim.rename rename = rule.conclusion) : + (same.backwardInstance rule claim renamed).conclusion = claim ∧ + (same.backwardInstance rule claim renamed).premises.map (Message.rename rename) = rule.premises := + Classical.choose_spec (same.backward rom rule claim renamed) + +/-- Duplicate an optimized node when its incoming edges request different +original channels. Edges still project to edges of the optimized graph. -/ +theorem MemoDerivation.liftRules {source target : System F} {rename : String → String} + {rom : WireROM F} {claim : Message F} + (graph : MemoDerivation target rom (claim.rename rename)) + (same : source.RuleTranslation target rename) + (finite : ∀ message : Message F, Finite {c : Message F // c.rename rename = message}) : + ∃ lifted : MemoDerivation source rom claim, graph.Acyclic → lifted.Acyclic := by + classical + let I := (i : Fin graph.size) × {c : Message F // c.rename rename = (graph.node i).conclusion} + letI (i : Fin graph.size) : Fintype {c : Message F // c.rename rename = (graph.node i).conclusion} := + @Fintype.ofFinite _ (finite _) + letI : Fintype I := inferInstanceAs (Fintype ((i : Fin graph.size) × + {c : Message F // c.rename rename = (graph.node i).conclusion})) + let node : I → RuleInstance source rom := fun i => same.backwardInstance (graph.node i.1) i.2.val i.2.property + have spec (i : I) : (node i).conclusion = i.2.val ∧ + (node i).premises.map (Message.rename rename) = (graph.node i.1).premises := + same.backwardInstance_spec _ _ _ + let position (i : I) (j : Fin (node i).premises.length) : Fin (graph.node i.1).premises.length := + ⟨j.val, by simpa only [← (spec i).2, List.length_map, id] using j.isLt⟩ + have premise (i : I) (j : Fin (node i).premises.length) : + ((node i).premises[j]).rename rename = (graph.node i.1).premises[position i j] := by + simp only [Fin.getElem_fin, ← (spec i).2, List.getElem_map, position] + let target (i : I) (j : Fin (node i).premises.length) : I := + ⟨graph.target i.1 (position i j), + ⟨(node i).premises[j], (premise i j).trans (graph.target_claim i.1 (position i j)).symm⟩⟩ + let root : I := ⟨graph.root, ⟨claim, graph.root_claim.symm⟩⟩ + let lifted := MemoDerivation.ofFinite node root (spec root).1 target (fun i j => (spec (target i j)).1) + refine ⟨lifted, ?_⟩ + apply graph.acyclic_of_projection lifted (fun i => ((Fintype.equivFin I).symm i).1) + rintro child parent ⟨j, rfl⟩ + refine ⟨position ((Fintype.equivFin I).symm parent) j, ?_⟩ + simp [lifted, MemoDerivation.ofFinite, target] + +theorem System.RuleTranslation.memoDerives_iff {source target : System F} {rename : String → String} + (same : source.RuleTranslation target rename) + (finite : ∀ message : Message F, Finite {c : Message F // c.rename rename = message}) + {rom : WireROM F} {claim : Message F} : + MemoDerives source rom claim ↔ MemoDerives target rom (claim.rename rename) := by + constructor + · rintro ⟨graph⟩ + exact ⟨graph.renameRules same⟩ + · rintro ⟨graph⟩ + obtain ⟨lifted, _⟩ := graph.liftRules same finite + exact ⟨lifted⟩ + +theorem System.RuleTranslation.acyclic_iff {source target : System F} {rename : String → String} + (same : source.RuleTranslation target rename) + (finite : ∀ message : Message F, Finite {c : Message F // c.rename rename = message}) + {rom : WireROM F} {claim : Message F} : + (∃ graph : MemoDerivation source rom claim, graph.Acyclic) ↔ + (∃ graph : MemoDerivation target rom (claim.rename rename), graph.Acyclic) := by + constructor + · rintro ⟨graph, acyclic⟩ + exact ⟨graph.renameRules same, graph.renameRules_acyclic same acyclic⟩ + · rintro ⟨graph, acyclic⟩ + obtain ⟨lifted, preserves⟩ := graph.liftRules same finite + exact ⟨lifted, preserves acyclic⟩ + +theorem System.RuleTranslation.check_iff {source target : System F} {rename : String → String} + (same : source.RuleTranslation target rename) {rom : WireROM F} {root : Message F} + (sourceContext : source.checkContext rom root = .ok ()) + (targetContext : target.checkContext rom (root.rename rename) = .ok ()) : + (∃ rows, source.check rom root rows = .ok ()) ↔ + (∃ rows, target.check rom (root.rename rename) rows = .ok ()) := by + rw [source.check_derives_iff sourceContext, target.check_derives_iff targetContext] + exact same.derives_iff + +theorem System.RuleTranslation.checkMemo_iff {source target : System F} {rename : String → String} + (same : source.RuleTranslation target rename) + (finite : ∀ message : Message F, Finite {c : Message F // c.rename rename = message}) + {rom : WireROM F} {root : Message F} + (sourceContext : source.checkContext rom root = .ok ()) + (targetContext : target.checkContext rom (root.rename rename) = .ok ()) : + (∃ rows, source.checkMemo rom root rows = .ok ()) ↔ + (∃ rows, target.checkMemo rom (root.rename rename) rows = .ok ()) := by + rw [source.checkMemo_derives_iff sourceContext, target.checkMemo_derives_iff targetContext] + exact same.memoDerives_iff finite + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/SelectorWitness.lean b/Aiur/Aiur/Circuit/SelectorWitness.lean new file mode 100644 index 000000000..50a189d6b --- /dev/null +++ b/Aiur/Aiur/Circuit/SelectorWitness.lean @@ -0,0 +1,73 @@ +import Aiur.Circuit.IndicatorWitness +import Aiur.Scalar.Circuit.WitnessBasic + +namespace Aiur.Circuit.Compiler + +variable {F : Type} {rom : WireROM F} + +private theorem excludeHead_complete [Field F] {calls : CallRelation F} + (selector : ArithExpr F) (rest : List (ArithExpr F)) {before after : BuildState F} + (compiled : (forIn rest PUnit.unit (fun other _ => do + constrain (.mul selector other) + pure (ForInStep.yield PUnit.unit)) : Build F PUnit) before = .ok (PUnit.unit, after)) {assignment : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls assignment) + (headBound : selector.inBounds before.nextVar = true) + (tailBound : ∀ other ∈ rest, other.inBounds before.nextVar = true) + (zero : ∀ other ∈ rest, selector.denote assignment * other.denote assignment = 0) : + Extension rom calls before after assignment assignment := by + induction rest generalizing before with + | nil => + have same : before = after := by + simpa [List.forIn_nil, pure, StateT.pure, Except.pure] using compiled + subst after + exact .refl layout valid + | cons other rest ih => + simp only [List.forIn_cons] at compiled + simp [StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at compiled + have hb : (ArithExpr.mul selector other).inBounds before.nextVar = true := by + simp [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] at headBound ⊢ + exact ⟨headBound, tailBound other (by simp)⟩ + have extension := ih compiled (layout.constrain hb) + (valid.constrain (zero other (by simp))) headBound + (fun p h => tailBound p (by simp [h])) (fun p h => zero p (by simp [h])) + exact ⟨extension.increase, extension.agree, extension.layout, extension.valid⟩ + +theorem excludePairs_complete [Field F] {calls : CallRelation F} + {selectors : List (ArithExpr F)} {before after : BuildState F} + (compiled : excludePairs selectors before = .ok ((), after)) {assignment : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls assignment) + (bounded : ∀ selector ∈ selectors, selector.inBounds before.nextVar = true) + (exclusive : (selectors.map (ArithExpr.denote assignment)).Pairwise (fun x y => x * y = 0)) : + Extension rom calls before after assignment assignment := by + induction selectors generalizing before with + | nil => + simp only [excludePairs, pure_ok, true_and] at compiled + subst after + exact .refl layout valid + | cons selector rest ih => + simp only [excludePairs] at compiled + obtain ⟨finished, middle, pairs, restRun⟩ := bind_ok.mp compiled + cases finished + simp only [List.map_cons, List.pairwise_cons, List.forall_mem_map] at exclusive + have headExt := excludeHead_complete selector rest pairs layout valid + (bounded selector (by simp)) (fun p h => bounded p (by simp [h])) exclusive.1 + have tailExt := ih restRun headExt.layout headExt.valid + (fun p h => headExt.bound (bounded p (by simp [h]))) exclusive.2 + exact headExt.trans tailExt + +theorem sum_complete [Field F] {calls : CallRelation F} + {selectors : List (ArithExpr F)} {enable : ArithExpr F} {before after : BuildState F} + (compiled : constrain (.sub (selectors.foldl ArithExpr.add (.const 0)) enable) before = .ok ((), after)) + {assignment : Var → F} (layout : before.WellFormed) (valid : before.Valid rom calls assignment) + (bounded : ∀ selector ∈ selectors, selector.inBounds before.nextVar = true) + (enableBound : enable.inBounds before.nextVar = true) + (sum : (selectors.map (ArithExpr.denote assignment)).sum = enable.denote assignment) : + Extension rom calls before after assignment assignment := by + apply constrain_complete compiled layout valid + · simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + And.intro (Scalar.Circuit.Compiler.foldl_add_inBounds (initial := .const (0 : F)) rfl bounded) enableBound + · simp only [ArithExpr.denote, Scalar.Circuit.ArithExpr.denote, + Scalar.Circuit.ArithExpr.denote_foldl_add, zero_add, sub_eq_zero] + exact sum + +end Aiur.Circuit.Compiler diff --git a/Aiur/Aiur/Circuit/SemanticCorrectness.lean b/Aiur/Aiur/Circuit/SemanticCorrectness.lean new file mode 100644 index 000000000..1462126c9 --- /dev/null +++ b/Aiur/Aiur/Circuit/SemanticCorrectness.lean @@ -0,0 +1,115 @@ +import Aiur.Circuit.SemanticModel + +namespace Aiur.Circuit + +variable {F : Type} [Field F] [DecidableEq F] + {program : Program F} {system : System F} {rom : WireROM F} + +theorem System.SemanticModel.derivation_sound (model : system.SemanticModel program) + {message : Message F} (tree : Derivation system rom message) : message.Evaluates program rom := by + induction tree using Derivation.rec + (motive_2 := fun messages _ => ∀ message ∈ messages, message.Evaluates program rom) with + | node chip row lookup valid children ih => + obtain ⟨args, result, arguments, decoded, locals, body, prepared, evaluated⟩ := + model.sound rom (.node chip row lookup valid) (ROMEvalCall (rom.decode program.enums) program) (by + intro premise member args result arguments decoded + obtain ⟨oldArgs, oldResult, oldArguments, oldDecoded, evaluated⟩ := ih premise member + have sameArgs := arguments.unique oldArguments + have sameResult := Option.some.inj (decoded.symm.trans oldDecoded) + simpa only [sameArgs, sameResult] using evaluated) + exact ⟨args, result, arguments, decoded, .intro prepared evaluated.toEvalExpr⟩ + | table member => + obtain ⟨args, result, arguments, decoded, locals, body, prepared, evaluated⟩ := + model.sound rom (.table _ member) (ROMEvalCall (rom.decode program.enums) program) + (by simp [RuleInstance.premises]) + exact ⟨args, result, arguments, decoded, .intro prepared evaluated.toEvalExpr⟩ + | nil => simp_all + | cons _ _ head tail => + rename_i message member + rcases List.mem_cons.mp member with rfl | member + · exact head + · exact tail message member + +theorem System.SemanticModel.sound_encoded (model : system.SemanticModel program) + {name : String} {wires : List (WireValue F)} {output : WireValue F} + (derived : CircuitEvaluates system rom name wires output) + {args : List (Value F)} {result : Value F} + (arguments : DecodesValues program.enums wires args) (decoded : output.decode program.enums = some result) : + ROMEvalCall (rom.decode program.enums) program name args result := by + obtain ⟨tree⟩ := derived + obtain ⟨otherArgs, otherResult, otherArguments, otherDecoded, evaluated⟩ := model.derivation_sound tree + have sameArgs := arguments.unique otherArguments + have sameResult := Option.some.inj (decoded.symm.trans otherDecoded) + simpa only [sameArgs, sameResult] using evaluated + +theorem System.SemanticModel.calls_typed (model : system.SemanticModel program) : + CallsTyped program (EncodedEvaluates program.enums system rom) := by + intro name args result evaluated signature found + obtain ⟨wires, output, _, decoded, ⟨tree⟩⟩ := evaluated + cases tree with + | node chip row lookup valid children => + have declared := model.resultType rom (.node chip row lookup valid) signature found + exact ⟨(WireValue.decode_spec decoded).1.trans declared, (WireValue.decode_spec decoded).2.1⟩ + | table member => + have declared := model.resultType rom (.table _ member) signature found + exact ⟨(WireValue.decode_spec decoded).1.trans declared, (WireValue.decode_spec decoded).2.1⟩ + +theorem System.SemanticModel.calls_complete (model : system.SemanticModel program) : + Compiler.CallsComplete program.enums (EncodedEvaluates program.enums system rom) + (CircuitEvaluates system rom) := by + intro name args result evaluated wires output arguments decoded + obtain ⟨oldWires, oldOutput, oldArguments, oldDecoded, derived⟩ := evaluated + have sameArgs := arguments.wires_unique model.declarations oldArguments + have sameResult := WireValue.decode_injective model.declarations decoded oldDecoded + simpa only [sameArgs, sameResult] using derived + +theorem System.SemanticModel.evaluation_complete (model : system.SemanticModel program) + {name : String} {args : List (Value F)} {result : Value F} + (evaluated : ROMEvalCall (rom.decode program.enums) program name args result) : + EncodedEvaluates program.enums system rom name args result := by + induction evaluated using ROMEvalCall.rec + (motive_1 := fun locals expr value _ => + ROMEvalExprWith program.enums (rom.decode program.enums) (EncodedEvaluates program.enums system rom) locals expr value) + (motive_2 := fun locals exprs values _ => + ROMEvalArgsWith program.enums (rom.decode program.enums) (EncodedEvaluates program.enums system rom) locals exprs values) with + | literal => exact .literal + | var lookup => exact .var lookup + | tuple _ ih => exact .tuple ih + | construct _ ih => exact .construct ih + | project _ projected ih => exact .project ih projected + | letValue _ matched _ inputIH bodyIH => exact .letValue inputIH matched bodyIH + | store _ cell ih => exact .store ih cell + | load _ cell typed ih => exact .load ih cell typed + | hint _ typed ih => exact .hint ih typed + | neg _ operation ih => exact .neg ih operation + | assertEq _ _ operation leftIH rightIH => exact .assertEq leftIH rightIH operation + | binary _ _ operation leftIH rightIH => exact .binary leftIH rightIH operation + | call _ _ argsIH calleeIH => exact .call argsIH calleeIH + | matchValue _ selected _ inputIH bodyIH => exact .matchValue inputIH selected bodyIH + | nil => exact .nil + | cons _ _ headIH tailIH => exact .cons headIH tailIH + | intro prepared _ bodyIH => + obtain ⟨rule, name, arguments, decoded, premises⟩ := + model.complete rom (CircuitEvaluates system rom) (EncodedEvaluates program.enums system rom) + model.calls_typed model.calls_complete _ _ _ ⟨_, _, prepared, bodyIH⟩ + refine ⟨rule.conclusion.args, rule.conclusion.result, arguments, decoded, ?_⟩ + have tree := rule.derives premises + simpa only [← name, CircuitEvaluates] using tree + +theorem System.SemanticModel.complete_encoded (model : system.SemanticModel program) + {name : String} {args : List (Value F)} {result : Value F} + (evaluated : ROMEvalCall (rom.decode program.enums) program name args result) + {wires : List (WireValue F)} {output : WireValue F} + (arguments : DecodesValues program.enums wires args) (decoded : output.decode program.enums = some result) : + CircuitEvaluates system rom name wires output := + model.calls_complete name args result (model.evaluation_complete evaluated) wires output arguments decoded + +theorem System.SemanticModel.evaluates_iff (model : system.SemanticModel program) + {name : String} {args : List (Value F)} {result : Value F} : + ROMEvalCall (rom.decode program.enums) program name args result ↔ + EncodedEvaluates program.enums system rom name args result := by + refine ⟨model.evaluation_complete, ?_⟩ + rintro ⟨wires, output, arguments, decoded, derived⟩ + exact model.sound_encoded derived arguments decoded + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/SemanticMemory.lean b/Aiur/Aiur/Circuit/SemanticMemory.lean new file mode 100644 index 000000000..2d2e786b1 --- /dev/null +++ b/Aiur/Aiur/Circuit/SemanticMemory.lean @@ -0,0 +1,80 @@ +import Aiur.Circuit.SemanticCorrectness +import Aiur.MemoryCorrectness + +namespace Aiur.Circuit + +variable {F : Type} [Field F] [DecidableEq F] + {program : Program F} {system : System F} + +private theorem public_arguments {decls : Declarations} + {wires : List (WireValue F)} {values : List (Value F)} + (arguments : DecodesValues decls wires values) + (free : ∀ value ∈ values, value.type.pointerFree decls = true) : + ∀ wire ∈ wires, wire.type.pointerFree decls = true := by + induction arguments with + | nil => simp + | @cons wire value wires values head tail ih => + have headFree := free value (by simp) + rw [(WireValue.decode_spec head).1] at headFree + simpa using And.intro headFree (ih (fun v h => free v (by simp [h]))) + +/-- Heap completeness only uses local compiler correctness. Addresses may be +chosen freely, provided distinct allocated cells have distinct field addresses. -/ +theorem System.SemanticModel.heap_complete (model : system.SemanticModel program) + (checked : typecheck program = .ok ()) (tags : program.enums.tagsValid F = true) + (enums : system.enums = program.enums) + {name : String} {args : List (SourceValue F)} {value : SourceValue F} {heap : Heap F} + (entry : checkEntry program name = .ok ()) (evaluated : EvalFn program name args [] value heap) + (encode : Nat → F) + (distinct : ∀ i j, i < heap.length → j < heap.length → encode i = encode j → i = j) : + EncodedEntryDerives system name (entryValues args) (value.mapAddress encode) := by + have free := evaluated.public_pointerFree entry + have heapGood := (evaluated.heap_good checked (by simp [Heap.Good]) + (fun arg member => Value.pointerNames_of_free (free arg member))).2 + let table := ROM.ofHeap heap encode + have good := ROM.ofHeap_good heapGood encode + have decodeTable := ROM.decode_encode model.declarations tags good + have body := evaluated.toROM (ROM.ofHeap_cells heap encode) + have encodedBody : ROMEvalCall ((table.encode program.enums).decode program.enums) program name + (args.map (Value.mapAddress encode)) (value.mapAddress encode) := by + rw [decodeTable]; exact body + obtain ⟨wires, output, arguments, decoded, derives⟩ := model.evaluation_complete encodedBody + rw [entryValues_eq free encode] at arguments + have argsFree : ∀ arg ∈ entryValues args, arg.type.pointerFree program.enums = true := by + intro arg member + obtain ⟨source, sourceMember, rfl⟩ := List.mem_map.mp member + simpa using (evaluated.publicArguments entry source sourceMember).1 + have tableValid := ROM.encode_valid model.declarations good (ROM.ofHeap_valid heap encode distinct) + refine ⟨wires, output, ?_, ?_, ?_⟩ + · simpa only [enums] using arguments + · simpa only [enums] using decoded + · refine ⟨?_, ?_, table.encode program.enums, tableValid, derives⟩ + · exact ⟨by simpa only [enums] using arguments.each, + by simpa only [enums] using + (show ∃ value, output.decode program.enums = some value from ⟨_, decoded⟩)⟩ + · simpa only [enums, Message.PublicArguments] using public_arguments arguments argsFree + +/-- Acyclic evaluation is realized with ordinary fresh allocations, without +equating source addresses with prover-chosen ROM addresses. -/ +theorem System.SemanticModel.heap_sound (model : system.SemanticModel program) + {rom : WireROM F} (valid : rom.Valid) + {name : String} {args : List (SourceValue F)} {result : Value F} + (entry : checkEntry program name = .ok ()) {wires : List (WireValue F)} {output : WireValue F} + (derived : CircuitEvaluates system rom name wires output) + (arguments : DecodesValues program.enums wires (entryValues args)) + (decoded : output.decode program.enums = some result) : + ∃ source heap, EvalFn program name args [] source heap ∧ + Represents (rom.decode program.enums) heap source result := by + have evaluated := model.sound_encoded derived arguments decoded + have free : ∀ value ∈ args, value.pointerFree = true := by + intro value member + have valid := evaluated.publicArguments entry (value.mapAddress (fun _ => 0)) + (List.mem_map.mpr ⟨value, member, rfl⟩) + exact Value.pointerFree_of_type (by simpa using valid.1) (by simpa using valid.2) + have relatedArgs : RepresentsArgs (rom.decode program.enums) [] args (entryValues args) := by + apply List.forall₂_map_right_iff.mpr + exact List.forall₂_same.mpr (fun value member => Represents.of_pointerFree value (free value member) _) + obtain ⟨source, heap, evaluated, _, related⟩ := evaluated.realize (WireROM.decode_valid valid) relatedArgs + exact ⟨source, heap, evaluated, related⟩ + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/SemanticModel.lean b/Aiur/Aiur/Circuit/SemanticModel.lean new file mode 100644 index 000000000..edf860e4a --- /dev/null +++ b/Aiur/Aiur/Circuit/SemanticModel.lean @@ -0,0 +1,141 @@ +import Aiur.Circuit.SupportedEquivalence +import Aiur.Completeness + +namespace Aiur.Circuit + +variable {F : Type} [Field F] [DecidableEq F] + +/-- One source function or map step, with calls left as premises. The body +evaluation is finite even when the supplied premise relation is cyclic. -/ +def CallStep (program : Program F) (rom : WireROM F) (calls : Aiur.CallRelation F) + (name : String) (args : List (Value F)) (result : Value F) : Prop := + ∃ locals body, prepareCall program name args = .ok (locals, body) ∧ + ROMEvalExprWith program.enums (rom.decode program.enums) calls locals body result + +/-- A compiler's local obligations. These are proved once for its executable +function compiler; the global tree, graph, and checker transports are shared. -/ +structure System.SemanticModel (program : Program F) (system : System F) : Prop where + declarations : checkDeclarations program.enums = .ok () + resultType : ∀ rom (rule : RuleInstance system rom) signature, + program.findSignature? rule.conclusion.channel = some signature → + rule.conclusion.result.type = signature.result + sound : ∀ rom (rule : RuleInstance system rom) (calls : Aiur.CallRelation F), + (∀ premise ∈ rule.premises, ∀ args result, + DecodesValues program.enums premise.args args → premise.result.decode program.enums = some result → + calls premise.channel args result) → + ∃ args result, DecodesValues program.enums rule.conclusion.args args ∧ + rule.conclusion.result.decode program.enums = some result ∧ + CallStep program rom calls rule.conclusion.channel args result + complete : ∀ rom (calls : CallRelation F) (sourceCalls : Aiur.CallRelation F), + CallsTyped program sourceCalls → Compiler.CallsComplete program.enums sourceCalls calls → + ∀ name args result, CallStep program rom sourceCalls name args result → + ∃ rule : RuleInstance system rom, rule.conclusion.channel = name ∧ + DecodesValues program.enums rule.conclusion.args args ∧ + rule.conclusion.result.decode program.enums = some result ∧ + ∀ premise ∈ rule.premises, calls premise.channel premise.args premise.result + +theorem System.SemanticModel.supportRefines {program : Program F} {source target : System F} + (sourceModel : source.SemanticModel program) (targetModel : target.SemanticModel program) : + source.SupportRefines target := by + intro rom rule supported + let calls : CallRelation F := fun name args result => ⟨name, args, result⟩ ∈ rule.premises + let sourceCalls : Aiur.CallRelation F := fun name args result => + ∃ wires output, DecodesValues program.enums wires args ∧ + output.decode program.enums = some result ∧ calls name wires output + have typed : CallsTyped program sourceCalls := by + intro name args result available signature found + obtain ⟨wires, output, arguments, decoded, member⟩ := available + obtain ⟨provider, same⟩ := supported ⟨name, wires, output⟩ member + have declared := sourceModel.resultType rom provider signature (by simpa only [same] using found) + refine ⟨(WireValue.decode_spec decoded).1.trans ?_, (WireValue.decode_spec decoded).2.1⟩ + simpa only [same] using declared + have callComplete : Compiler.CallsComplete program.enums sourceCalls calls := by + intro name args result available wires output arguments decoded + obtain ⟨previousArgs, previousResult, previousArguments, previousDecoded, member⟩ := available + have sameArgs := arguments.wires_unique sourceModel.declarations previousArguments + have sameResult := WireValue.decode_injective sourceModel.declarations decoded previousDecoded + simpa only [sameArgs, sameResult] using member + obtain ⟨args, result, arguments, decoded, step⟩ := sourceModel.sound rom rule sourceCalls + (fun premise member args result arguments decoded => + ⟨premise.args, premise.result, arguments, decoded, member⟩) + obtain ⟨next, name, nextArguments, nextDecoded, premises⟩ := + targetModel.complete rom calls sourceCalls typed callComplete rule.conclusion.channel args result step + have sameArgs := nextArguments.wires_unique sourceModel.declarations arguments + have sameResult := WireValue.decode_injective sourceModel.declarations nextDecoded decoded + refine ⟨next, ?_, ?_⟩ + · cases nextConclusion : next.conclusion + cases sourceConclusion : rule.conclusion + simp only [nextConclusion, sourceConclusion] at name sameArgs sameResult ⊢ + simp_all only [Message.mk.injEq] + · intro premise member + exact premises premise member + +theorem System.SemanticModel.supportEquiv {program : Program F} {source target : System F} + (sourceModel : source.SemanticModel program) (targetModel : target.SemanticModel program) : + source.SupportEquiv target := + ⟨sourceModel.supportRefines targetModel, targetModel.supportRefines sourceModel⟩ + +/-- The reference compiler discharges the same local interface required of +the optimized compiler. Static maps remain zero-premise rules. -/ +theorem compile_semanticModel {program : Program F} {system : System F} + (compiled : compile program = .ok system) : system.SemanticModel program := by + have stages := compile_stages compiled + have declarations := typecheck_declarations stages.1 + refine ⟨declarations, ?_, ?_, ?_⟩ + · intro rom rule signature found + cases rule with + | node chip row lookup valid => + obtain ⟨function, functionFound, lowered⟩ := compile_find_chip compiled lookup + have interface := Compiler.lowerFunction_interface lowered + have names : chip.name = row.chip := by simpa using List.find?_some lookup + have sourceSignature : program.findSignature? chip.name = some ⟨function.params, function.result⟩ := by + rw [names] + exact Program.signature_of_function functionFound + change program.findSignature? chip.name = some signature at found + obtain rfl := Option.some.inj (found.symm.trans sourceSignature) + exact interface.2.2 + | table message member => + obtain ⟨args, constant, arguments, decoded, absent, looked⟩ := compile_map_spec compiled member + obtain ⟨map, _, mapFound, _, _, _, _, typed⟩ := lookupMap_spec looked + have signatureFound := Program.signature_of_map absent mapFound + obtain rfl := Option.some.inj (found.symm.trans signatureFound) + have resultType := (WireValue.decode_spec decoded).1 + simp only [Value.hasType, Bool.and_eq_true, decide_eq_true_eq] at typed + exact resultType.symm.trans (by simpa using typed.1) + · intro rom rule calls premises + cases rule with + | node chip row lookup valid => + obtain ⟨function, found, lowered⟩ := compile_find_chip compiled lookup + have interface := Compiler.lowerFunction_interface lowered + obtain ⟨args, result, arguments, decoded, body⟩ := + Compiler.lowerFunction_sound declarations stages.2.1 lowered valid premises + refine ⟨args, result, arguments, decoded, _, _, ?_, body⟩ + have types : function.params.map Prod.snd = args.map Value.type := by + rw [arguments.types] + simpa only [Chip.receive, List.map_map, Function.comp_def, WireValue.type_map] using interface.2.1.symm + apply prepareCall_of_types (fn := function) ?_ types arguments.wellFormed + change program.findFunction? chip.name = some function + rw [interface.1, findFunction_name found] + exact found + | table message member => + obtain ⟨args, constant, arguments, decoded, absent, looked⟩ := compile_map_spec compiled member + refine ⟨args, constant.toValue, arguments, decoded, _, _, prepareCall_map absent looked, ?_⟩ + exact (ROMEvalExprWith.constant_iff constant).mpr rfl + · intro rom calls sourceCalls typed callComplete name args result step + obtain ⟨locals, body, prepared, evaluated⟩ := step + rcases prepareCall_spec prepared with function | table + · obtain ⟨function, found, types, formed, rfl, rfl⟩ := function + obtain ⟨chip, lookup, lowered⟩ := compile_find_function compiled found + have checked := typecheck_function stages.1 (List.mem_of_find?_eq_some found) + obtain ⟨row, rowName, valid, arguments, decoded, premises⟩ := + Compiler.lowerFunction_complete declarations stages.2.1 lowered typed callComplete checked types formed evaluated + have functionName := findFunction_name found + have rowLookup : system.findChip? row.chip = some chip := by rw [rowName, functionName]; exact lookup + exact ⟨.node chip row rowLookup valid, (Compiler.lowerFunction_interface lowered).1.trans functionName, + arguments, decoded, premises⟩ + · obtain ⟨constant, _, looked, rfl, rfl⟩ := table + obtain rfl := (ROMEvalExprWith.constant_iff constant).mp evaluated + obtain ⟨wires, output, arguments, decoded, member⟩ := compile_map_lookup compiled looked + exact ⟨.table ⟨name, wires, output⟩ member, rfl, arguments, decoded, by simp [RuleInstance.premises]⟩ + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/SplitFacts.lean b/Aiur/Aiur/Circuit/SplitFacts.lean new file mode 100644 index 000000000..5acb6ca99 --- /dev/null +++ b/Aiur/Aiur/Circuit/SplitFacts.lean @@ -0,0 +1,109 @@ +import Aiur.Circuit.WitnessBasic +import Aiur.WireRelation +import Aiur.LayoutUnique + +namespace Aiur.Circuit.Compiler + +/-- Slicing is static and neither allocates variables nor adds constraints. -/ +theorem splitValues_spec {decls : Declarations} {types : List Ty} {words : List α} + {values : List (WireValue α)} {before after : BuildState F} + (compiled : splitValues decls types words before = .ok (values, after)) : + after = before ∧ values.map WireValue.type = types ∧ values.flatMap WireValue.words = words ∧ + ∀ value ∈ values, value.Sized decls := by + induction types generalizing words values before with + | nil => cases words with + | nil => + obtain ⟨rfl, rfl⟩ := pure_ok.mp compiled + exact ⟨rfl, rfl, rfl, by simp⟩ + | cons => simp [splitValues] at compiled + | cons type types ih => + simp only [splitValues] at compiled + obtain ⟨layout, middle, expanded, rest⟩ := bind_ok.mp compiled + obtain ⟨expansion, rfl⟩ := getLayout_eq expanded + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · rename_i width + obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨rfl, typesEq, wordsEq, shaped⟩ := ih tailRun + refine ⟨rfl, by simp [typesEq], ?_, ?_⟩ + · simp [wordsEq] + · intro value member + rcases List.mem_cons.mp member with rfl | member + · exact ⟨layout, expansion, by + change (words.take layout.width).length = layout.width + rw [List.length_take, Nat.min_eq_left (by omega)]⟩ + · exact shaped value member + +theorem splitValues_bounded {decls : Declarations} {types : List Ty} {words : List (ArithExpr F)} + {values : List (Symbolic F)} {before after : BuildState F} + (compiled : splitValues decls types words before = .ok (values, after)) {bound : Nat} + (bounded : ∀ word ∈ words, word.inBounds bound = true) : + ∀ value ∈ values, Bounded bound value := by + have flat := (splitValues_spec compiled).2.2.1 + intro value member p leaf + apply bounded + rw [← flat] + exact List.mem_flatMap.mpr ⟨value, member, leaf⟩ + +/-- Static slicing commutes with the canonical tuple decoder. -/ +theorem splitValues_decodeList [Field F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) {types : List Ty} {layouts : List Layout} + (described : LayoutsDescribe decls layouts types) + {words : List (ArithExpr F)} {wires : List (Symbolic F)} {before after : BuildState F} + (compiled : splitValues decls types words before = .ok (wires, after)) + {assignment : Var → F} {values : List (Value F)} + (decoded : Layout.decodeList layouts (words.map (ArithExpr.denote assignment)) = some values) : + DecodesValues decls (wires.map (WireValue.map (ArithExpr.denote assignment))) values := by + cases described with + | nil => + cases words with + | cons => simp [splitValues] at compiled + | nil => + obtain ⟨rfl, rfl⟩ := pure_ok.mp compiled + simp only [List.map_nil, Layout.decodeList, Option.some.injEq] at decoded + subst values + exact .nil + | @cons layout type layouts types head tail => + simp only [splitValues] at compiled + obtain ⟨expanded, middle, expansionRun, rest⟩ := bind_ok.mp compiled + obtain ⟨expansion, rfl⟩ := getLayout_eq expansionRun + have same := head.unique (Declarations.layout_describes expansion) + subst expanded + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨other, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + simp only [Layout.decodeList] at decoded + obtain ⟨value, headDecode, restDecode⟩ := Option.bind_eq_some_iff.mp decoded + obtain ⟨values, tailDecode, finished⟩ := Option.bind_eq_some_iff.mp restDecode + simp only [Option.pure_def, Option.some.injEq] at finished + subst finished + exact .cons (WireValue.decode_of_layout checked expansion (by + simpa only [WireValue.map, List.map_take] using headDecode)) + (splitValues_decodeList checked tail tailRun (by simpa only [List.map_drop] using tailDecode)) +termination_by sizeOf types + +/-- A decoded tuple splits into the encodings of exactly its components. -/ +theorem splitValues_decode [Field F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) {types : List Ty} {words : List (ArithExpr F)} + {wires : List (Symbolic F)} {before after : BuildState F} + (compiled : splitValues decls types words before = .ok (wires, after)) + {assignment : Var → F} {value : Value F} + (decoded : (WireValue.mk (.tuple types) (words.map (ArithExpr.denote assignment))).decode decls = some value) : + ∃ values, value = .tuple values ∧ + DecodesValues decls (wires.map (WireValue.map (ArithExpr.denote assignment))) values := by + obtain ⟨_, _, layout, expanded, decoded⟩ := WireValue.decode_spec decoded + have described := Declarations.layout_describes expanded + cases described with + | tuple relation => + simp only [Layout.decode] at decoded + obtain ⟨values, inner, finished⟩ := Option.bind_eq_some_iff.mp decoded + simp only [Option.pure_def, Option.some.injEq] at finished + exact ⟨values, finished.symm, splitValues_decodeList checked relation compiled inner⟩ + +end Aiur.Circuit.Compiler diff --git a/Aiur/Aiur/Circuit/Stats.lean b/Aiur/Aiur/Circuit/Stats.lean new file mode 100644 index 000000000..db3854c94 --- /dev/null +++ b/Aiur/Aiur/Circuit/Stats.lean @@ -0,0 +1,73 @@ +import Aiur.Circuit.Basic +import Aiur.Scalar.Circuit.Degree + +namespace Aiur.Circuit + +namespace ArithExpr +abbrev degree (expr : ArithExpr F) : Nat := Scalar.Circuit.ArithExpr.degree expr + +/-- Zero for an empty list of expressions. -/ +def maxDegree (expressions : List (ArithExpr F)) : Nat := + expressions.foldl (fun largest expr => max largest expr.degree) 0 +end ArithExpr + +/-- Includes arguments, result columns, and the enable expression. This is the +largest expression degree, not the degree of a future lookup protocol gadget. -/ +def Send.maxDegree (send : Send F) : Nat := + max (ArithExpr.maxDegree (send.enable :: send.args.flatMap WireValue.words)) + (if send.result.words.isEmpty then 0 else 1) + +/-- Includes the address, payload words, and enable expression. -/ +def MemoryLookup.maxDegree (lookup : MemoryLookup F) : Nat := + ArithExpr.maxDegree (lookup.enable :: lookup.address :: lookup.value.words) + +/-- Static costs of one chip row, independent of any assignment or trace. -/ +structure ChipStats where + name : String + /-- All allocated field columns; provided expressions need no dedicated columns. -/ + columns : Nat + maxConstraintDegree : Nat + /-- Function and map sends, counted with repetitions and inactive slots. -/ + callLookups : Nat + /-- Store/load requirements, counted with repetitions and inactive slots. -/ + romLookups : Nat + /-- Includes the provided input/output expressions as well as required lookups. -/ + maxLookupDegree : Nat + deriving Repr, BEq, DecidableEq + +/-- Required lookup slots; the chip's own provided conclusion is not a lookup. -/ +def ChipStats.lookups (stats : ChipStats) : Nat := stats.callLookups + stats.romLookups + +def Chip.stats (chip : Chip F) : ChipStats := { + name := chip.name + columns := chip.numVars + maxConstraintDegree := ArithExpr.maxDegree chip.constraints + callLookups := chip.sends.length + romLookups := chip.memory.length + maxLookupDegree := max + (max (ArithExpr.maxDegree chip.output.words) + (if (chip.inputs.flatMap WireValue.words).isEmpty then 0 else 1)) + (max ((chip.sends.map Send.maxDegree).foldl max 0) + ((chip.memory.map MemoryLookup.maxDegree).foldl max 0)) +} + +/-- Guards remain affine even when mutually exclusive payloads are combined. -/ +def Chip.maxLookupGuardDegree (chip : Chip F) : Nat := + ArithExpr.maxDegree (chip.sends.map Send.enable ++ chip.memory.map MemoryLookup.enable) + +/-- One record per chip, preserving circuit order. Static maps have no chip. -/ +def System.stats (system : System F) : List ChipStats := system.chips.map Chip.stats + +def ChipStats.format (stats : ChipStats) : String := + s!"{stats.name}: columns={stats.columns}, max constraint degree={stats.maxConstraintDegree}, " ++ + s!"lookups={stats.lookups} (calls={stats.callLookups}, ROM={stats.romLookups}), " ++ + s!"max lookup degree={stats.maxLookupDegree}" + +def System.formatStats (system : System F) : String := + if system.chips.isEmpty then "No chips." + else String.intercalate "\n" (system.stats.map ChipStats.format) + +/-- Print the per-chip report; no field operations or witness rows are needed. -/ +def System.printStats (system : System F) : IO Unit := IO.println system.formatStats + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/SupportedEquivalence.lean b/Aiur/Aiur/Circuit/SupportedEquivalence.lean new file mode 100644 index 000000000..d099ddef7 --- /dev/null +++ b/Aiur/Aiur/Circuit/SupportedEquivalence.lean @@ -0,0 +1,155 @@ +import Aiur.Circuit.RuleEquivalence + +namespace Aiur.Circuit + +variable {F : Type} [Field F] [DecidableEq F] + +/-- For closed proofs it suffices to reproduce a rule using its available +premises. Each premise has some locally valid provider; it need not already +have a finite derivation. This distinction retains cyclic memoized proofs. -/ +def System.SupportRefines (source target : System F) : Prop := + ∀ rom (rule : RuleInstance source rom), + (∀ premise ∈ rule.premises, ∃ provider : RuleInstance source rom, provider.conclusion = premise) → + ∃ next : RuleInstance target rom, + next.conclusion = rule.conclusion ∧ next.premises ⊆ rule.premises + +def System.SupportEquiv (source target : System F) : Prop := + source.SupportRefines target ∧ target.SupportRefines source + +theorem System.RuleRefines.supportRefines {source target : System F} + (refines : source.RuleRefines target) : source.SupportRefines target := by + intro rom rule _ + obtain ⟨next, conclusion, premises⟩ := refines rom rule.conclusion rule.premises + ⟨rule, rfl, List.Perm.refl _⟩ + exact ⟨next, conclusion, fun _ member => premises.mem_iff.mp member⟩ + +theorem System.SupportRefines.derives {source target : System F} + (refines : source.SupportRefines target) {rom : WireROM F} {message : Message F} + (derived : Derives source rom message) : Derives target rom message := by + obtain ⟨tree⟩ := derived + induction tree using Derivation.rec + (motive_2 := fun messages _ => ∀ message ∈ messages, Derives target rom message) with + | node chip row lookup valid children ih => + obtain ⟨next, conclusion, premises⟩ := refines rom (.node chip row lookup valid) (by + intro premise member + obtain ⟨provider, _, same⟩ := children.root_instances premise member + exact ⟨provider, same⟩) + change next.conclusion = chip.receive row at conclusion + rw [← conclusion] + exact next.derives (fun premise member => ih premise (premises member)) + | table member => + obtain ⟨next, conclusion, premises⟩ := refines rom (.table _ member) (by simp [RuleInstance.premises]) + dsimp only [RuleInstance.conclusion] at conclusion + rw [← conclusion] + exact next.derives (fun premise member => by simpa [RuleInstance.premises] using premises member) + | nil => simp_all + | cons _ _ head tail => + rename_i message member + rcases List.mem_cons.mp member with rfl | member + · exact head + · exact tail message member + +private theorem MemoDerivation.supported {source : System F} {rom : WireROM F} {message : Message F} + (graph : MemoDerivation source rom message) (i : Fin graph.size) : + ∀ premise ∈ (graph.node i).premises, + ∃ provider : RuleInstance source rom, provider.conclusion = premise := by + intro premise member + obtain ⟨index, same⟩ := graph.premise_mem i member + exact ⟨graph.node index, same⟩ + +noncomputable def MemoDerivation.supportInstance {source target : System F} + {rom : WireROM F} {message : Message F} (graph : MemoDerivation source rom message) + (refines : source.SupportRefines target) (i : Fin graph.size) : RuleInstance target rom := + Classical.choose (refines rom (graph.node i) (graph.supported i)) + +theorem MemoDerivation.supportInstance_spec {source target : System F} + {rom : WireROM F} {message : Message F} (graph : MemoDerivation source rom message) + (refines : source.SupportRefines target) (i : Fin graph.size) : + (graph.supportInstance refines i).conclusion = (graph.node i).conclusion ∧ + (graph.supportInstance refines i).premises ⊆ (graph.node i).premises := + Classical.choose_spec (refines rom (graph.node i) (graph.supported i)) + +private theorem MemoDerivation.supportIndex {source target : System F} + {rom : WireROM F} {message : Message F} (graph : MemoDerivation source rom message) + (refines : source.SupportRefines target) (i : Fin graph.size) + (j : Fin (graph.supportInstance refines i).premises.length) : + ∃ k : Fin (graph.node i).premises.length, + (graph.node i).premises[k] = (graph.supportInstance refines i).premises[j] := by + have member := (graph.supportInstance_spec refines i).2 + (List.getElem_mem (l := (graph.supportInstance refines i).premises) (n := j.val) j.isLt) + obtain ⟨k, bounded, same⟩ := List.mem_iff_getElem.mp member + exact ⟨⟨k, bounded⟩, same⟩ + +/-- Every new edge uses an old edge. This construction applies to shared and +cyclic graphs, and preserves acyclicity when the original graph is acyclic. -/ +noncomputable def MemoDerivation.mapSupport {source target : System F} + {rom : WireROM F} {message : Message F} (graph : MemoDerivation source rom message) + (refines : source.SupportRefines target) : MemoDerivation target rom message where + size := graph.size + node := graph.supportInstance refines + root := graph.root + root_claim := (graph.supportInstance_spec refines graph.root).1.trans graph.root_claim + target i j := graph.target i (Classical.choose (graph.supportIndex refines i j)) + target_claim i j := + ((graph.supportInstance_spec refines _).1.trans (graph.target_claim i _)).trans + (Classical.choose_spec (graph.supportIndex refines i j)) + +theorem MemoDerivation.mapSupport_dependency {source target : System F} + {rom : WireROM F} {message : Message F} (graph : MemoDerivation source rom message) + (refines : source.SupportRefines target) {child parent : Fin graph.size} + (edge : (graph.mapSupport refines).Dependency child parent) : graph.Dependency child parent := by + obtain ⟨j, same⟩ := edge + exact ⟨Classical.choose (graph.supportIndex refines parent j), same⟩ + +theorem MemoDerivation.mapSupport_acyclic {source target : System F} + {rom : WireROM F} {message : Message F} (graph : MemoDerivation source rom message) + (refines : source.SupportRefines target) (acyclic : graph.Acyclic) : + (graph.mapSupport refines).Acyclic := by + intro i cycle + exact acyclic i (Relation.TransGen.mono (fun _ _ edge => graph.mapSupport_dependency refines edge) i i cycle) + +theorem System.SupportRefines.memoDerives {source target : System F} + (refines : source.SupportRefines target) {rom : WireROM F} {message : Message F} + (derived : MemoDerives source rom message) : MemoDerives target rom message := by + obtain ⟨graph⟩ := derived + exact ⟨graph.mapSupport refines⟩ + +theorem System.SupportEquiv.derives_iff {source target : System F} + (same : source.SupportEquiv target) {rom : WireROM F} {message : Message F} : + Derives source rom message ↔ Derives target rom message := + ⟨same.1.derives, same.2.derives⟩ + +theorem System.SupportEquiv.memoDerives_iff {source target : System F} + (same : source.SupportEquiv target) {rom : WireROM F} {message : Message F} : + MemoDerives source rom message ↔ MemoDerives target rom message := + ⟨same.1.memoDerives, same.2.memoDerives⟩ + +theorem System.SupportEquiv.acyclic_iff {source target : System F} + (same : source.SupportEquiv target) {rom : WireROM F} {message : Message F} : + (∃ graph : MemoDerivation source rom message, graph.Acyclic) ↔ + (∃ graph : MemoDerivation target rom message, graph.Acyclic) := by + constructor + · rintro ⟨graph, acyclic⟩ + exact ⟨graph.mapSupport same.1, graph.mapSupport_acyclic same.1 acyclic⟩ + · rintro ⟨graph, acyclic⟩ + exact ⟨graph.mapSupport same.2, graph.mapSupport_acyclic same.2 acyclic⟩ + +theorem System.SupportEquiv.check_iff {source target : System F} + (same : source.SupportEquiv target) {rom : WireROM F} {root : Message F} + (sourceContext : source.checkContext rom root = .ok ()) + (targetContext : target.checkContext rom root = .ok ()) : + (∃ rows, source.check rom root rows = .ok ()) ↔ + (∃ rows, target.check rom root rows = .ok ()) := by + rw [source.check_derives_iff sourceContext, target.check_derives_iff targetContext] + exact same.derives_iff + +theorem System.SupportEquiv.checkMemo_iff {source target : System F} + (same : source.SupportEquiv target) {rom : WireROM F} {root : Message F} + (sourceContext : source.checkContext rom root = .ok ()) + (targetContext : target.checkContext rom root = .ok ()) : + (∃ rows, source.checkMemo rom root rows = .ok ()) ↔ + (∃ rows, target.checkMemo rom root rows = .ok ()) := by + rw [source.checkMemo_derives_iff sourceContext, target.checkMemo_derives_iff targetContext] + exact same.memoDerives_iff + +end Aiur.Circuit diff --git a/Aiur/Aiur/Circuit/ValidationCorrectness.lean b/Aiur/Aiur/Circuit/ValidationCorrectness.lean new file mode 100644 index 000000000..c79b7bf55 --- /dev/null +++ b/Aiur/Aiur/Circuit/ValidationCorrectness.lean @@ -0,0 +1,215 @@ +import Aiur.Circuit.Indicator +import Aiur.WireCodec +import Aiur.LayoutShape +import Aiur.EncodingTypes + +namespace Aiur.Circuit.Compiler + +variable {F : Type} {rom : WireROM F} + +set_option maxHeartbeats 1000000 + +theorem zeroWords_sound [Field F] {enable : ArithExpr F} {words : List (ArithExpr F)} + {before after : BuildState F} (compiled : zeroWords enable words before = .ok ((), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid rom calls assignment) : + before.Valid rom calls assignment ∧ + (enable.denote assignment = 1 → ∀ word ∈ words, word.denote assignment = 0) := by + induction words generalizing before with + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp compiled + exact ⟨valid, by simp⟩ + | cons word words ih => + simp only [zeroWords] at compiled + obtain ⟨⟨⟩, middle, headRun, tailRun⟩ := bind_ok.mp compiled + obtain ⟨middleValid, zeros⟩ := ih tailRun + obtain ⟨previous, equation⟩ := constrain_valid headRun middleValid + refine ⟨previous, fun active => ?_⟩ + change enable.denote assignment * word.denote assignment = 0 at equation + simp only [active, one_mul] at equation + simpa [equation] using zeros active + +mutual + /-- Satisfying the active validation equations guarantees a canonical decoded value. -/ + theorem validate_sound [Field F] [DecidableEq F] {layout : Layout} + (proper : layout.TuplePayloads) {enable : ArithExpr F} {words : List (ArithExpr F)} + {before after : BuildState F} (compiled : validate layout enable words before = .ok ((), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid rom calls assignment) : + before.Valid rom calls assignment ∧ (enable.denote assignment = 1 → + ∃ value, layout.decode (words.map (ArithExpr.denote assignment)) = some value) := by + cases layout with + | field => + cases words with + | nil => simp [validate] at compiled + | cons word rest => + cases rest with + | cons => simp [validate] at compiled + | nil => + simp only [validate] at compiled + obtain ⟨_, rfl⟩ := pure_ok.mp compiled + exact ⟨valid, fun _ => ⟨.field (word.denote assignment), by simp [Layout.decode]⟩⟩ + | ptr target => + cases words with + | nil => simp [validate] at compiled + | cons word rest => + cases rest with + | cons => simp [validate] at compiled + | nil => + simp only [validate] at compiled + obtain ⟨_, rfl⟩ := pure_ok.mp compiled + exact ⟨valid, fun _ => ⟨.ptr target (word.denote assignment), by simp [Layout.decode]⟩⟩ + | tuple layouts => + simp only [validate] at compiled + obtain ⟨previous, decoded⟩ := validateList_sound + (by simpa only [Layout.TuplePayloads] using proper) compiled valid + exact ⟨previous, fun active => by + obtain ⟨values, decoded⟩ := decoded active + exact ⟨.tuple values, by simp [Layout.decode, decoded]⟩⟩ + | enum name constructors => + simp only [validate] at compiled + cases parts : Layout.enumParts constructors.length (.const 0) words with + | none => simp [parts] at compiled + | some pair => + rcases pair with ⟨tag, payload⟩ + simp only [parts] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · rename_i length + have length : payload.length = Layout.payloadWidth constructors := by simpa using length + obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨tests, middle, ctorRun, sumRun⟩ := bind_ok.mp rest + obtain ⟨middleValid, sumEquation⟩ := constrain_valid sumRun valid + obtain ⟨previous, choices⟩ := validateConstructors_sound + (by simpa only [Layout.TuplePayloads] using proper) ctorRun middleValid + refine ⟨previous, fun active => ?_⟩ + rcases choices active with ⟨⟨ctor, args⟩, decoded⟩ | absent + · exact ⟨.construct name ctor args, by simp [Layout.decode, Circuit.Compiler.enumParts_denote parts assignment, length, decoded]⟩ + · have zero : (tests.map (ArithExpr.denote assignment)).sum = 0 := + List.sum_eq_zero (by simpa using absent) + have sum : (tests.map (ArithExpr.denote assignment)).sum = 1 := by + simpa [Scalar.Circuit.ArithExpr.denote, Scalar.Circuit.ArithExpr.denote_foldl_add, + active, sub_eq_zero] using sumEquation + exact (zero_ne_one (zero.symm.trans sum)).elim + termination_by sizeOf layout + + theorem validateList_sound [Field F] [DecidableEq F] {layouts : List Layout} + (proper : ∀ layout ∈ layouts, layout.TuplePayloads) {enable : ArithExpr F} {words : List (ArithExpr F)} + {before after : BuildState F} (compiled : validateList layouts enable words before = .ok ((), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid rom calls assignment) : + before.Valid rom calls assignment ∧ (enable.denote assignment = 1 → + ∃ values, Layout.decodeList layouts (words.map (ArithExpr.denote assignment)) = some values) := by + cases layouts with + | nil => + cases words with + | nil => + simp only [validateList] at compiled + obtain ⟨_, rfl⟩ := pure_ok.mp compiled + exact ⟨valid, fun _ => ⟨[], by simp [Layout.decodeList]⟩⟩ + | cons => simp [validateList] at compiled + | cons layout layouts => + simp only [validateList] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨⟨⟩, middle, headRun, tailRun⟩ := bind_ok.mp rest + obtain ⟨middleValid, tails⟩ := validateList_sound (fun l h => proper l (by simp [h])) tailRun valid + obtain ⟨previous, heads⟩ := validate_sound (proper _ (by simp)) headRun middleValid + refine ⟨previous, fun active => ?_⟩ + obtain ⟨head, headDecode⟩ := heads active + obtain ⟨tail, tailDecode⟩ := tails active + exact ⟨head :: tail, by simp [Layout.decodeList, ← List.map_take, ← List.map_drop, headDecode, tailDecode]⟩ + termination_by sizeOf layouts + + theorem validateConstructors_sound [Field F] [DecidableEq F] + {constructors : List (String × Layout)} + (proper : ∀ pair ∈ constructors, + (∃ layouts, pair.2 = .tuple layouts) ∧ pair.2.TuplePayloads) + {enable tag : ArithExpr F} {payload tests : List (ArithExpr F)} {index : Nat} + {before after : BuildState F} + (compiled : validateConstructors constructors enable tag payload index before = .ok (tests, after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid rom calls assignment) : + before.Valid rom calls assignment ∧ (enable.denote assignment = 1 → + (∃ value, Layout.decodeConstructor constructors (tag.denote assignment) + (payload.map (ArithExpr.denote assignment)) index = some value) ∨ + (∀ test ∈ tests, test.denote assignment = 0)) := by + cases constructors with + | nil => + simp only [validateConstructors] at compiled + obtain ⟨rfl, rfl⟩ := pure_ok.mp compiled + exact ⟨valid, fun _ => Or.inr (by simp)⟩ + | cons pair constructors => + rcases hpair : pair with ⟨name, layout⟩ + rw [hpair] at compiled proper + simp only [validateConstructors] at compiled + obtain ⟨test, s₁, indicatorRun, rest⟩ := bind_ok.mp compiled + obtain ⟨⟨⟩, s₂, payloadRun, rest⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₃, paddingRun, rest⟩ := bind_ok.mp rest + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨s₃valid, tails⟩ := validateConstructors_sound (fun p h => proper p (by simp [h])) tailRun valid + obtain ⟨s₂valid, padding⟩ := zeroWords_sound paddingRun s₃valid + obtain ⟨⟨layouts, tupleEq⟩, layoutProper⟩ := proper (name, layout) (by simp) + obtain ⟨s₁valid, payloads⟩ := validate_sound layoutProper payloadRun s₂valid + obtain ⟨previous, indicator⟩ := equalIndicator_sound indicatorRun s₁valid + refine ⟨previous, fun active => ?_⟩ + change test.denote assignment = if tag.denote assignment - (index : F) = 0 then 1 else 0 at indicator + by_cases matchedTag : tag.denote assignment = (index : F) + · have selected : (ArithExpr.mul enable test).denote assignment = 1 := by + simp [Scalar.Circuit.ArithExpr.denote, active, indicator, matchedTag] + obtain ⟨value, decoded⟩ := payloads selected + have type := Layout.decode_type decoded + rw [tupleEq, Layout.type] at type + cases value with + | field | ptr | construct => simp [Value.type] at type + | tuple values => + have zeros : ((payload.map (ArithExpr.denote assignment)).drop layout.width).all + (fun x => decide (x = 0)) = true := by + simpa [← List.map_drop] using padding selected + exact Or.inl ⟨(name, values), by + simp [Layout.decodeConstructor, matchedTag, ← List.map_take, decoded, zeros]⟩ + · simp only [sub_eq_zero, matchedTag, ↓reduceIte] at indicator + rcases tails active with ⟨value, decoded⟩ | absent + · exact Or.inl ⟨value, by simp [Layout.decodeConstructor, matchedTag, decoded]⟩ + · exact Or.inr (by simpa [indicator] using absent) + termination_by sizeOf constructors + decreasing_by + all_goals simp_all only [List.cons.sizeOf_spec, Prod.mk.sizeOf_spec] + all_goals omega +end + +/-- Active interface and ROM encodings have a well-formed nominal source value. -/ +theorem validateValue_sound [Field F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) {enable : ArithExpr F} {wire : Symbolic F} + {before after : BuildState F} + (compiled : validateValue decls enable wire before = .ok ((), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid rom calls assignment) : + before.Valid rom calls assignment ∧ (enable.denote assignment = 1 → + ∃ value, (wire.map (ArithExpr.denote assignment)).decode decls = some value) := by + simp only [validateValue] at compiled + obtain ⟨layout, middle, expanded, run⟩ := bind_ok.mp compiled + obtain ⟨expansion, rfl⟩ := getLayout_eq expanded + obtain ⟨previous, decoded⟩ := validate_sound (Declarations.layout_describes expansion).tuplePayloads run valid + refine ⟨previous, fun active => ?_⟩ + obtain ⟨value, decoded⟩ := decoded active + exact ⟨value, WireValue.decode_of_layout (wire := wire.map (ArithExpr.denote assignment)) checked expansion decoded⟩ + +theorem validateValues_sound [Field F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) {enable : ArithExpr F} {wires : List (Symbolic F)} + {before after : BuildState F} + (compiled : validateValues decls enable wires before = .ok ((), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid rom calls assignment) : + before.Valid rom calls assignment ∧ (enable.denote assignment = 1 → + ∀ wire ∈ wires, ∃ value, (wire.map (ArithExpr.denote assignment)).decode decls = some value) := by + induction wires generalizing before with + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp compiled + exact ⟨valid, by simp⟩ + | cons wire wires ih => + simp only [validateValues] at compiled + obtain ⟨⟨⟩, middle, headRun, tailRun⟩ := bind_ok.mp compiled + obtain ⟨middleValid, tails⟩ := ih tailRun + obtain ⟨beforeValid, head⟩ := validateValue_sound checked headRun middleValid + exact ⟨beforeValid, fun active => by simpa using And.intro (head active) (tails active)⟩ + +end Aiur.Circuit.Compiler diff --git a/Aiur/Aiur/Circuit/ValidationWitness.lean b/Aiur/Aiur/Circuit/ValidationWitness.lean new file mode 100644 index 000000000..9cb6e16cf --- /dev/null +++ b/Aiur/Aiur/Circuit/ValidationWitness.lean @@ -0,0 +1,288 @@ +import Aiur.Circuit.IndicatorWitness +import Aiur.Circuit.ValidationCorrectness +import Aiur.LayoutValidation +import Aiur.Scalar.Circuit.WitnessBasic + +namespace Aiur.Circuit.Compiler + +variable {F : Type} {rom : WireROM F} + +set_option maxHeartbeats 1600000 + +theorem Extension.words [Field F] {calls : CallRelation F} {before after : BuildState F} + {a b : Var → F} (extension : Extension rom calls before after a b) {words : List (ArithExpr F)} + (bounded : ∀ word ∈ words, word.inBounds before.nextVar = true) : + words.map (ArithExpr.denote b) = words.map (ArithExpr.denote a) := + List.map_congr_left (fun word member => extension.polynomial (bounded word member)) + +theorem zeroWords_complete [Field F] {enable : ArithExpr F} {words : List (ArithExpr F)} + {before after : BuildState F} (compiled : zeroWords enable words before = .ok ((), after)) + {calls : CallRelation F} {assignment : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls assignment) + (enableBound : enable.inBounds before.nextVar = true) + (bounded : ∀ word ∈ words, word.inBounds before.nextVar = true) + (zero : enable.denote assignment = 0 ∨ ∀ word ∈ words, word.denote assignment = 0) : + Extension rom calls before after assignment assignment := by + induction words generalizing before with + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp compiled + exact .refl layout valid + | cons word words ih => + simp only [zeroWords] at compiled + obtain ⟨⟨⟩, middle, headRun, tailRun⟩ := bind_ok.mp compiled + have ext := guarded_complete headRun layout valid enableBound (bounded _ (by simp)) + (zero.imp_right (fun zeros => zeros _ (by simp))) + exact ext.trans (ih tailRun ext.layout ext.valid (ext.bound enableBound) + (fun p h => ext.bound (bounded p (by simp [h]))) + (zero.imp_right (fun zeros p h => zeros p (by simp [h])))) + +mutual + /-- Validation adds witnesses for any canonical value, or for arbitrary inactive words. -/ + theorem validate_complete [Field F] [DecidableEq F] {type : Layout} + {enable : ArithExpr F} {words : List (ArithExpr F)} {before after : BuildState F} + (compiled : validate type enable words before = .ok ((), after)) + {calls : CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls initial) + (enableBound : enable.inBounds before.nextVar = true) + (bounded : ∀ word ∈ words, word.inBounds before.nextVar = true) + (admissible : enable.denote initial = 0 ∨ type.Admissible (words.map (ArithExpr.denote initial))) : + ∃ assignment, Extension rom calls before after initial assignment := by + cases type with + | field => + cases words with + | nil => simp [validate] at compiled + | cons word rest => cases rest with + | cons => simp [validate] at compiled + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp (by simpa only [validate] using compiled) + exact ⟨initial, .refl layout valid⟩ + | ptr target => + cases words with + | nil => simp [validate] at compiled + | cons word rest => cases rest with + | cons => simp [validate] at compiled + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp (by simpa only [validate] using compiled) + exact ⟨initial, .refl layout valid⟩ + | tuple layouts => + exact validateList_complete (by simpa only [validate] using compiled) layout valid enableBound bounded + (by simpa only [Layout.Admissible] using admissible) + | enum name constructors => + simp only [validate] at compiled + cases parts : Layout.enumParts constructors.length (.const 0) words with + | none => simp [parts] at compiled + | some pair => + rcases pair with ⟨tag, payload⟩ + simp only [parts] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨tests, middle, ctorRun, sumRun⟩ := bind_ok.mp rest + obtain ⟨tagBound, payloadBound⟩ := Layout.enumParts_all parts (by rfl) bounded + have choices : enable.denote initial = 0 ∨ Layout.AdmissibleConstructors constructors + (tag.denote initial) (payload.map (ArithExpr.denote initial)) 0 := by + rcases admissible with zero | formed + · exact Or.inl zero + · simp only [Layout.Admissible, Nat.cast_zero, Circuit.Compiler.enumParts_denote parts initial] at formed + exact Or.inr formed.2.2 + obtain ⟨a, ext, testsBound, testsEq⟩ := validateConstructors_complete ctorRun layout valid + enableBound tagBound payloadBound choices + have sumBound : (tests.foldl ArithExpr.add (.const (0 : F))).inBounds middle.nextVar = true := by + exact Scalar.Circuit.Compiler.foldl_add_inBounds (by rfl) testsBound + have zero : enable.denote a = 0 ∨ + (ArithExpr.sub (tests.foldl ArithExpr.add (.const (0 : F))) (.const 1)).denote a = 0 := by + rcases admissible with h | h + · exact Or.inl ((ext.polynomial enableBound).trans h) + · right + simp only [Layout.Admissible, Nat.cast_zero, Circuit.Compiler.enumParts_denote parts initial] at h + simpa [Scalar.Circuit.ArithExpr.denote, Scalar.Circuit.ArithExpr.denote_foldl_add, + testsEq, h.2.1] + have last := guarded_complete sumRun ext.layout ext.valid (ext.bound enableBound) + (by simpa [Scalar.Circuit.ArithExpr.inBounds] using sumBound) zero + exact ⟨a, ext.trans last⟩ + termination_by sizeOf type + + theorem validateList_complete [Field F] [DecidableEq F] {types : List Layout} + {enable : ArithExpr F} {words : List (ArithExpr F)} {before after : BuildState F} + (compiled : validateList types enable words before = .ok ((), after)) + {calls : CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls initial) + (enableBound : enable.inBounds before.nextVar = true) + (bounded : ∀ word ∈ words, word.inBounds before.nextVar = true) + (admissible : enable.denote initial = 0 ∨ Layout.AdmissibleList types (words.map (ArithExpr.denote initial))) : + ∃ assignment, Extension rom calls before after initial assignment := by + cases types with + | nil => cases words with + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp (by simpa only [validateList] using compiled) + exact ⟨initial, .refl layout valid⟩ + | cons => simp [validateList] at compiled + | cons type types => + simp only [validateList] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨⟨⟩, middle, headRun, tailRun⟩ := bind_ok.mp rest + have headBound : ∀ p ∈ words.take type.width, p.inBounds before.nextVar = true := + fun p h => bounded p (List.mem_of_mem_take h) + have tailBound : ∀ p ∈ words.drop type.width, p.inBounds before.nextVar = true := + fun p h => bounded p (List.mem_of_mem_drop h) + have headAdmissible : enable.denote initial = 0 ∨ + type.Admissible ((words.take type.width).map (ArithExpr.denote initial)) := by + rcases admissible with zero | good + · exact Or.inl zero + · simp only [Layout.AdmissibleList] at good + exact Or.inr (by simpa only [List.map_take] using good.1) + obtain ⟨a, headExt⟩ := validate_complete headRun layout valid enableBound headBound headAdmissible + have tailAdmissible : enable.denote a = 0 ∨ + Layout.AdmissibleList types ((words.drop type.width).map (ArithExpr.denote a)) := by + rw [headExt.polynomial enableBound, headExt.words tailBound] + rcases admissible with zero | good + · exact Or.inl zero + · simp only [Layout.AdmissibleList] at good + exact Or.inr (by simpa only [List.map_drop] using good.2) + obtain ⟨b, tailExt⟩ := validateList_complete tailRun headExt.layout headExt.valid + (headExt.bound enableBound) (fun p h => headExt.bound (tailBound p h)) tailAdmissible + exact ⟨b, headExt.trans tailExt⟩ + termination_by sizeOf types + + theorem validateConstructors_complete [Field F] [DecidableEq F] + {constructors : List (String × Layout)} {enable tag : ArithExpr F} + {payload tests : List (ArithExpr F)} {index : Nat} {before after : BuildState F} + (compiled : validateConstructors constructors enable tag payload index before = .ok (tests, after)) + {calls : CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls initial) + (enableBound : enable.inBounds before.nextVar = true) + (tagBound : tag.inBounds before.nextVar = true) + (bounded : ∀ word ∈ payload, word.inBounds before.nextVar = true) + (admissible : enable.denote initial = 0 ∨ Layout.AdmissibleConstructors constructors + (tag.denote initial) (payload.map (ArithExpr.denote initial)) index) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + (∀ test ∈ tests, test.inBounds after.nextVar = true) ∧ + tests.map (ArithExpr.denote assignment) = tagTests constructors.length (tag.denote initial) index := by + cases constructors with + | nil => + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [validateConstructors] using compiled) + exact ⟨initial, .refl layout valid, by simp, rfl⟩ + | cons pair rest => + rcases hpair : pair with ⟨name, type⟩ + rw [hpair] at compiled admissible + simp only [validateConstructors] at compiled + obtain ⟨test, s₁, indicatorRun, run⟩ := bind_ok.mp compiled + obtain ⟨⟨⟩, s₂, payloadRun, run⟩ := bind_ok.mp run + obtain ⟨⟨⟩, s₃, paddingRun, run⟩ := bind_ok.mp run + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp run + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, testExt, testBound⟩ := equalIndicator_complete indicatorRun layout valid + (by simpa [Scalar.Circuit.ArithExpr.inBounds] using tagBound) + have testEq : test.denote a = if tag.denote initial = (index : F) then 1 else 0 := by + have matched := (equalIndicator_sound indicatorRun testExt.valid).2 + simpa [Scalar.Circuit.ArithExpr.denote, testExt.polynomial tagBound, sub_eq_zero] using matched + have selectedBound : (ArithExpr.mul enable test).inBounds s₁.nextVar = true := by + simp [Scalar.Circuit.ArithExpr.inBounds, testExt.bound enableBound, testBound] + have headBound : ∀ p ∈ payload.take type.width, p.inBounds before.nextVar = true := + fun p h => bounded p (List.mem_of_mem_take h) + have padBound : ∀ p ∈ payload.drop type.width, p.inBounds before.nextVar = true := + fun p h => bounded p (List.mem_of_mem_drop h) + have headAdmissible : (ArithExpr.mul enable test).denote a = 0 ∨ + type.Admissible ((payload.take type.width).map (ArithExpr.denote a)) := by + rw [testExt.words headBound] + rcases admissible with zero | good + · left; simp [Scalar.Circuit.ArithExpr.denote, testExt.polynomial enableBound, zero] + · simp only [Layout.AdmissibleConstructors] at good + by_cases selected : tag.denote initial = (index : F) + · exact Or.inr (by simpa only [List.map_take] using (good.1 selected).1) + · left; simp [Scalar.Circuit.ArithExpr.denote, testEq, selected] + obtain ⟨b, payloadExt⟩ := validate_complete payloadRun testExt.layout testExt.valid selectedBound + (fun p h => testExt.bound (headBound p h)) headAdmissible + have untilPayload := testExt.trans payloadExt + have paddingZero : (ArithExpr.mul enable test).denote b = 0 ∨ + ∀ p ∈ payload.drop type.width, p.denote b = 0 := by + change ArithExpr.denote b (.mul enable test) = 0 ∨ _ + rw [payloadExt.polynomial selectedBound] + rcases admissible with zero | good + · left; simp [Scalar.Circuit.ArithExpr.denote, testExt.polynomial enableBound, zero] + · simp only [Layout.AdmissibleConstructors] at good + by_cases selected : tag.denote initial = (index : F) + · right + intro p member + rw [untilPayload.polynomial (padBound p member)] + exact (good.1 selected).2 _ (by rw [← List.map_drop]; exact List.mem_map.mpr ⟨p, member, rfl⟩) + · left; simp [Scalar.Circuit.ArithExpr.denote, testEq, selected] + have paddingExt := zeroWords_complete paddingRun payloadExt.layout payloadExt.valid + (payloadExt.bound selectedBound) (fun p h => untilPayload.bound (padBound p h)) paddingZero + have throughPadding := untilPayload.trans paddingExt + have tailAdmissible : enable.denote b = 0 ∨ Layout.AdmissibleConstructors rest + (tag.denote b) (payload.map (ArithExpr.denote b)) (index + 1) := by + rw [throughPadding.polynomial enableBound, throughPadding.polynomial tagBound, throughPadding.words bounded] + exact admissible.imp_right (fun good => by + simp only [Layout.AdmissibleConstructors] at good + exact good.2) + obtain ⟨c, tailExt, tailBound, tailEq⟩ := validateConstructors_complete tailRun throughPadding.layout throughPadding.valid + (throughPadding.bound enableBound) (throughPadding.bound tagBound) (fun p h => throughPadding.bound (bounded p h)) tailAdmissible + have suffix := (payloadExt.trans paddingExt).trans tailExt + refine ⟨c, throughPadding.trans tailExt, ?_, ?_⟩ + · simpa using And.intro (suffix.bound testBound) tailBound + · simp only [List.map_cons, suffix.polynomial testBound, testEq, tailEq, + throughPadding.polynomial tagBound, List.length_cons, tagTests] + termination_by sizeOf constructors + decreasing_by + all_goals simp_all only [List.cons.sizeOf_spec, Prod.mk.sizeOf_spec] + all_goals omega +end + +theorem validateValue_complete [Field F] [DecidableEq F] {decls : Declarations} + (tags : decls.tagsValid F = true) {enable : ArithExpr F} {wire : Symbolic F} + {before after : BuildState F} + (compiled : validateValue decls enable wire before = .ok ((), after)) + {calls : CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls initial) + (enableBound : enable.inBounds before.nextVar = true) (bounded : Bounded before.nextVar wire) + (decodable : enable.denote initial = 0 ∨ + ∃ value, (wire.map (ArithExpr.denote initial)).decode decls = some value) : + ∃ assignment, Extension rom calls before after initial assignment := by + simp only [validateValue] at compiled + obtain ⟨type, middle, expanded, run⟩ := bind_ok.mp compiled + obtain ⟨expansion, rfl⟩ := getLayout_eq expanded + apply validate_complete run layout valid enableBound bounded + rcases decodable with zero | ⟨value, decoded⟩ + · exact Or.inl zero + · obtain ⟨_, _, other, found, decoded⟩ := WireValue.decode_spec decoded + simp only [WireValue.type_map, expansion, Except.ok.injEq] at found + subst other + exact Or.inr (Layout.decode_admissible (Declarations.layout_tagSafe tags expansion) decoded) + +theorem validateValues_complete [Field F] [DecidableEq F] {decls : Declarations} + (tags : decls.tagsValid F = true) {enable : ArithExpr F} {wires : List (Symbolic F)} + {before after : BuildState F} + (compiled : validateValues decls enable wires before = .ok ((), after)) + {calls : CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls initial) + (enableBound : enable.inBounds before.nextVar = true) + (bounded : ∀ wire ∈ wires, Bounded before.nextVar wire) + (decodable : enable.denote initial = 0 ∨ + ∀ wire ∈ wires, ∃ value, (wire.map (ArithExpr.denote initial)).decode decls = some value) : + ∃ assignment, Extension rom calls before after initial assignment := by + induction wires generalizing before initial with + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp compiled + exact ⟨initial, .refl layout valid⟩ + | cons wire wires ih => + simp only [validateValues] at compiled + obtain ⟨⟨⟩, middle, headRun, tailRun⟩ := bind_ok.mp compiled + obtain ⟨a, headExt⟩ := validateValue_complete tags headRun layout valid enableBound + (bounded _ (by simp)) (decodable.imp_right (fun h => h _ (by simp))) + obtain ⟨b, tailExt⟩ := ih tailRun headExt.layout headExt.valid (headExt.bound enableBound) + (fun w h => (bounded w (by simp [h])).mono headExt.increase) (by + rw [headExt.polynomial enableBound] + rcases decodable with zero | good + · exact Or.inl zero + · right + intro w member + rw [headExt.value (bounded w (by simp [member]))] + exact good w (by simp [member])) + exact ⟨b, headExt.trans tailExt⟩ + +end Aiur.Circuit.Compiler diff --git a/Aiur/Aiur/Circuit/ValueCorrectness.lean b/Aiur/Aiur/Circuit/ValueCorrectness.lean new file mode 100644 index 000000000..81a9b03ac --- /dev/null +++ b/Aiur/Aiur/Circuit/ValueCorrectness.lean @@ -0,0 +1,79 @@ +import Aiur.Circuit.BuildFacts + +namespace Aiur.Circuit.Compiler + +variable {F : Type} {rom : WireROM F} + +theorem constrainWords_sound [Field F] {enable : ArithExpr F} + {left right : List (ArithExpr F)} {before after : BuildState F} + (compiled : constrainWords enable left right before = .ok ((), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid rom calls assignment) : + before.Valid rom calls assignment ∧ (enable.denote assignment = 1 → + left.map (ArithExpr.denote assignment) = right.map (ArithExpr.denote assignment)) := by + induction left generalizing right before with + | nil => + cases right with + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp compiled + exact ⟨valid, fun _ => rfl⟩ + | cons => simp [constrainWords] at compiled + | cons x xs ih => + cases right with + | nil => simp [constrainWords] at compiled + | cons y ys => + simp only [constrainWords] at compiled + obtain ⟨⟨⟩, middle, headRun, tailRun⟩ := bind_ok.mp compiled + obtain ⟨middleValid, tailEq⟩ := ih tailRun + obtain ⟨beforeValid, headEq⟩ := constrain_valid headRun middleValid + refine ⟨beforeValid, fun active => ?_⟩ + change enable.denote assignment * (x.denote assignment - y.denote assignment) = 0 at headEq + simp only [active, one_mul, sub_eq_zero] at headEq + simp [headEq, tailEq active] + +/-- Guarded equations equate every tag, payload and padding column. -/ +theorem constrainValue_sound [Field F] {enable : ArithExpr F} {left right : Symbolic F} + {before after : BuildState F} + (compiled : constrainValue enable left right before = .ok ((), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid rom calls assignment) : + before.Valid rom calls assignment ∧ (enable.denote assignment = 1 → + left.map (ArithExpr.denote assignment) = right.map (ArithExpr.denote assignment)) := by + simp only [constrainValue] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · rename_i same + obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + have same : left.type = right.type := by simpa using same + obtain ⟨previous, equal⟩ := constrainWords_sound rest valid + exact ⟨previous, fun active => by cases left; cases right; simp_all [WireValue.map]⟩ + +/-- Exclusion equations only add constraints, so earlier validity can be recovered. -/ +theorem excludePairs_valid [Field F] {selectors : List (ArithExpr F)} + {before after : BuildState F} + (compiled : excludePairs selectors before = .ok ((), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid rom calls assignment) : + before.Valid rom calls assignment := by + induction selectors generalizing before with + | nil => + simp only [excludePairs, pure_ok, true_and] at compiled + subst after + exact valid + | cons selector rest ih => + simp only [excludePairs] at compiled + obtain ⟨finished, middle, pairs, restRun⟩ := bind_ok.mp compiled + cases finished + have middleValid := ih restRun + clear ih restRun compiled valid + induction rest generalizing before with + | nil => + simpa [List.forIn_nil, pure, StateT.pure, Except.pure] using + (show before.Valid rom calls assignment from by + have same : before = middle := by simpa [List.forIn_nil, pure, StateT.pure, Except.pure] using pairs + simpa [same] using middleValid) + | cons other rest ih => + simp only [List.forIn_cons] at pairs + simp [StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at pairs + have previous := ih pairs + exact previous.of_subset (fun _ member => by simp [member]) (fun _ member => member) (fun _ member => member) + +end Aiur.Circuit.Compiler diff --git a/Aiur/Aiur/Circuit/ValueWitness.lean b/Aiur/Aiur/Circuit/ValueWitness.lean new file mode 100644 index 000000000..fcf7055bc --- /dev/null +++ b/Aiur/Aiur/Circuit/ValueWitness.lean @@ -0,0 +1,145 @@ +import Aiur.Circuit.WitnessBasic + +namespace Aiur.Circuit.Compiler + +variable {F : Type} {rom : WireROM F} + +set_option maxHeartbeats 1000000 + +def zeroValue [Zero F] (decls : Declarations) (type : Ty) : WireValue F := + ⟨type, List.replicate (((decls.layout type).toOption.map Layout.width).getD 0) 0⟩ + +@[simp] theorem zeroValue_type [Zero F] (decls : Declarations) (type : Ty) : + (zeroValue (F := F) decls type).type = type := rfl + +theorem zeroValue_sized [Zero F] {decls : Declarations} {type : Ty} {layout : Layout} + (expanded : decls.layout type = .ok layout) : + (zeroValue (F := F) decls type).Sized decls := by + exact ⟨layout, expanded, by simp [zeroValue, expanded, Except.toOption]⟩ + +/-- Bulk allocation permits any field words, including inactive noncanonical values. -/ +theorem freshValue_complete [Field F] {calls : CallRelation F} {before after : BuildState F} + {decls : Declarations} {type : Ty} {vars : WireValue Var} + (compiled : freshValue decls type before = .ok (vars, after)) {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls initial) + (value : WireValue F) (shape : value.type = type) (sized : value.Sized decls) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + Bounded (F := F) after.nextVar (vars.map ArithExpr.var) ∧ vars.map assignment = value := by + obtain ⟨expanded, expansion, rfl, rfl⟩ := freshValue_eq compiled + obtain ⟨other, otherExpansion, width⟩ := sized + rw [shape, expansion] at otherExpansion + cases otherExpansion + let assignment : Var → F := fun id => + if id < before.nextVar then initial id else value.words.getD (id - before.nextVar) 0 + have agree : ∀ id < before.nextVar, assignment id = initial id := by + intro id bound + simp [assignment, bound] + have assigned : (List.range' before.nextVar expanded.width).map assignment = value.words := by + apply List.ext_getElem + · simp [width] + · intro i leftBound rightBound + have bound : i < expanded.width := by simpa using leftBound + simp [assignment, List.getElem_range', Nat.add_sub_cancel_left, List.getD, + rightBound, Nat.not_lt.mpr (Nat.le_add_right _ _)] + have oldValid := valid.of_agree layout agree + refine ⟨assignment, ⟨by simp, agree, layout.grow (by simp), + ⟨oldValid.constraints, oldValid.calls, oldValid.memory⟩⟩, ?_, ?_⟩ + · intro p member + simp only [WireValue.words_map, List.mem_map] at member + obtain ⟨id, member, rfl⟩ := member + have bound : id < before.nextVar + expanded.width := by + obtain ⟨i, hi, rfl⟩ := List.mem_range'.mp member + simpa using Nat.add_lt_add_left hi before.nextVar + simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using bound + · cases value + simp_all [WireValue.map] + +theorem freshValues_complete [Field F] {calls : CallRelation F} {before after : BuildState F} + {decls : Declarations} {types : List Ty} {vars : List (WireValue Var)} + (compiled : freshValues decls types before = .ok (vars, after)) {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls initial) + (values : List (WireValue F)) (shape : values.map WireValue.type = types) + (sized : ∀ value ∈ values, value.Sized decls) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + (∀ value ∈ vars, Bounded (F := F) after.nextVar (value.map ArithExpr.var)) ∧ + vars.map (WireValue.map assignment) = values := by + induction values generalizing vars types before initial with + | nil => + subst types + simp only [freshValues, List.mapM_nil, pure_ok] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨initial, .refl layout valid, by simp, rfl⟩ + | cons value values ih => + subst types + simp only [List.map_cons, freshValues, List.mapM_cons] at compiled + obtain ⟨head, middle, headRun, rest⟩ := bind_ok.mp compiled + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, headExt, headBound, headValue⟩ := + freshValue_complete headRun layout valid value rfl (sized _ (by simp)) + obtain ⟨b, tailExt, tailBound, tailValue⟩ := + ih tailRun headExt.layout headExt.valid rfl (fun v h => sized v (by simp [h])) + refine ⟨b, headExt.trans tailExt, ?_, ?_⟩ + · intro tree member + rcases List.mem_cons.mp member with rfl | member + · exact headBound.mono tailExt.increase + · exact tailBound tree member + · simp only [List.map_cons, tailExt.variables headBound, headValue, tailValue] + +theorem constrainWords_complete [Field F] {calls : CallRelation F} + {enable : ArithExpr F} {left right : List (ArithExpr F)} {before after : BuildState F} + (compiled : constrainWords enable left right before = .ok ((), after)) {assignment : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls assignment) + (enableBound : enable.inBounds before.nextVar = true) + (leftBound : ∀ p ∈ left, p.inBounds before.nextVar = true) + (rightBound : ∀ p ∈ right, p.inBounds before.nextVar = true) + (equal : enable.denote assignment = 0 ∨ + left.map (ArithExpr.denote assignment) = right.map (ArithExpr.denote assignment)) : + Extension rom calls before after assignment assignment := by + induction left generalizing right before with + | nil => + cases right with + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp compiled + exact .refl layout valid + | cons => simp [constrainWords] at compiled + | cons x xs ih => + cases right with + | nil => simp [constrainWords] at compiled + | cons y ys => + simp only [constrainWords] at compiled + obtain ⟨⟨⟩, middle, headRun, tailRun⟩ := bind_ok.mp compiled + have headEq : enable.denote assignment = 0 ∨ x.denote assignment - y.denote assignment = 0 := by + rcases equal with h | h + · exact Or.inl h + · exact Or.inr (sub_eq_zero.mpr (List.cons.inj h).1) + have headExt := guarded_complete headRun layout valid enableBound + (by simpa [Scalar.Circuit.ArithExpr.inBounds] using + And.intro (leftBound _ (by simp)) (rightBound _ (by simp))) headEq + have tailEq : enable.denote assignment = 0 ∨ + xs.map (ArithExpr.denote assignment) = ys.map (ArithExpr.denote assignment) := by + rcases equal with h | h + · exact Or.inl h + · exact Or.inr (List.cons.inj h).2 + exact headExt.trans (ih tailRun headExt.layout headExt.valid (headExt.bound enableBound) + (fun p h => headExt.bound (leftBound p (by simp [h]))) + (fun p h => headExt.bound (rightBound p (by simp [h]))) tailEq) + +theorem constrainValue_complete [Field F] {calls : CallRelation F} + {enable : ArithExpr F} {left right : Symbolic F} {before after : BuildState F} + (compiled : constrainValue enable left right before = .ok ((), after)) {assignment : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls assignment) + (enableBound : enable.inBounds before.nextVar = true) + (leftBound : Bounded before.nextVar left) (rightBound : Bounded before.nextVar right) + (equal : enable.denote assignment = 0 ∨ + left.map (ArithExpr.denote assignment) = right.map (ArithExpr.denote assignment)) : + Extension rom calls before after assignment assignment := by + simp only [constrainValue] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + apply constrainWords_complete rest layout valid enableBound leftBound rightBound + exact equal.imp_right (congrArg WireValue.words) + +end Aiur.Circuit.Compiler diff --git a/Aiur/Aiur/Circuit/WitnessBasic.lean b/Aiur/Aiur/Circuit/WitnessBasic.lean new file mode 100644 index 000000000..278c37166 --- /dev/null +++ b/Aiur/Aiur/Circuit/WitnessBasic.lean @@ -0,0 +1,287 @@ +import Aiur.Circuit.Indicator + +namespace Aiur.Circuit.Compiler + +variable {F : Type} {rom : WireROM F} + +/-- All leaves of a symbolic tuple refer only to allocated variables. -/ +def Bounded (bound : Nat) (value : Symbolic F) : Prop := + ∀ polynomial ∈ value.words, polynomial.inBounds bound = true + +@[simp] theorem bounded_field {bound : Nat} {polynomial : ArithExpr F} : + Bounded bound (.field polynomial) ↔ polynomial.inBounds bound = true := by + simp [Bounded, WireValue.field, WireValue.ptr] + +@[simp] theorem bounded_ptr {bound : Nat} {target : Ty} {address : ArithExpr F} : + Bounded bound (.ptr target address) ↔ address.inBounds bound = true := by + simp [Bounded, WireValue.field, WireValue.ptr] + +@[simp] theorem bounded_tuple {bound : Nat} {values : List (Symbolic F)} : + Bounded bound (.tuple values) ↔ ∀ value ∈ values, Bounded bound value := by + simp only [Bounded, WireValue.tuple, List.mem_flatMap, forall_exists_index, and_imp] + constructor + · intro h value member p leaf + exact h p value member leaf + · intro h p value member leaf + exact h value member p leaf + +theorem Bounded.mono {before after : Nat} (increase : before ≤ after) + {value : Symbolic F} (bounded : Bounded before value) : Bounded after value := + fun p member => Scalar.Circuit.ArithExpr.inBounds_mono increase (bounded p member) + +def LocalsBounded (bound : Nat) (locals : Locals F) : Prop := + ∀ binding ∈ locals, Bounded bound binding.2 + +theorem LocalsBounded.mono {before after : Nat} (increase : before ≤ after) + {locals : Locals F} (bounded : LocalsBounded before locals) : LocalsBounded after locals := + fun binding member => (bounded binding member).mono increase + +@[simp] theorem localsBounded_append {bound : Nat} {left right : Locals F} : + LocalsBounded bound (left ++ right) ↔ LocalsBounded bound left ∧ LocalsBounded bound right := by + simp [LocalsBounded, or_imp, forall_and] + +structure BuildState.WellFormed (state : BuildState F) : Prop where + constraints : ∀ polynomial ∈ state.constraints.toList, polynomial.inBounds state.nextVar = true + sends : ∀ send ∈ state.sends.toList, send.inBounds state.nextVar = true + memory : ∀ lookup ∈ state.memory.toList, lookup.inBounds state.nextVar = true + +theorem Send_bounds_mono {send : Send F} {before after : Nat} (increase : before ≤ after) + (bounded : send.inBounds before = true) : send.inBounds after = true := by + simp only [Send.inBounds, Bool.and_eq_true, List.all_eq_true, decide_eq_true_eq] at bounded ⊢ + exact ⟨⟨fun id member => lt_of_lt_of_le (bounded.1.1 id member) increase, + Scalar.Circuit.ArithExpr.inBounds_mono increase bounded.1.2⟩, + fun polynomial member => Scalar.Circuit.ArithExpr.inBounds_mono increase (bounded.2 polynomial member)⟩ + +theorem MemoryLookup_bounds_mono {lookup : MemoryLookup F} {before after : Nat} + (increase : before ≤ after) (bounded : lookup.inBounds before = true) : + lookup.inBounds after = true := by + simp only [MemoryLookup.inBounds, Bool.and_eq_true, List.all_eq_true] at bounded ⊢ + exact ⟨⟨Scalar.Circuit.ArithExpr.inBounds_mono increase bounded.1.1, + Scalar.Circuit.ArithExpr.inBounds_mono increase bounded.1.2⟩, + fun p member => Scalar.Circuit.ArithExpr.inBounds_mono increase (bounded.2 p member)⟩ + +theorem BuildState.WellFormed.grow {state : BuildState F} (layout : state.WellFormed) + {bound : Nat} (increase : state.nextVar ≤ bound) : + { state with nextVar := bound }.WellFormed := + ⟨fun p member => Scalar.Circuit.ArithExpr.inBounds_mono increase (layout.constraints p member), + fun send member => Send_bounds_mono increase (layout.sends send member), + fun lookup member => MemoryLookup_bounds_mono increase (layout.memory lookup member)⟩ + +theorem BuildState.WellFormed.constrain {state : BuildState F} (layout : state.WellFormed) + {polynomial : ArithExpr F} (bounded : polynomial.inBounds state.nextVar = true) : + { state with constraints := state.constraints.push polynomial }.WellFormed := by + refine ⟨?_, layout.sends, layout.memory⟩ + intro p member + simp only [Array.toList_push, List.mem_append, List.mem_singleton] at member + rcases member with member | rfl + · exact layout.constraints p member + · exact bounded + +theorem BuildState.Valid.constrain [Field F] {state : BuildState F} {calls : CallRelation F} + {assignment : Var → F} (valid : state.Valid rom calls assignment) {polynomial : ArithExpr F} + (zero : polynomial.denote assignment = 0) : + { state with constraints := state.constraints.push polynomial }.Valid rom calls assignment := by + refine ⟨?_, valid.calls, valid.memory⟩ + intro p member + simp only [Array.toList_push, List.mem_append, List.mem_singleton] at member + rcases member with member | rfl + · exact valid.constraints p member + · exact zero + +theorem BuildState.Valid.of_agree [Field F] {state : BuildState F} {calls : CallRelation F} + {before after : Var → F} (valid : state.Valid rom calls before) (layout : state.WellFormed) + (agree : ∀ id < state.nextVar, after id = before id) : state.Valid rom calls after := by + constructor + · intro p member + rw [Scalar.Circuit.ArithExpr.denote_eq_of_agree agree (layout.constraints p member)] + exact valid.constraints p member + · intro send member active + have bounded := layout.sends send member + simp only [Send.inBounds, Bool.and_eq_true, List.all_eq_true, decide_eq_true_eq] at bounded + have enabled : send.enable.denote after = send.enable.denote before := + Scalar.Circuit.ArithExpr.denote_eq_of_agree agree bounded.1.2 + have result : send.result.map after = send.result.map before := + WireValue.map_congr _ (fun id inside => agree id (bounded.1.1 id inside)) + have args : send.args.map (WireValue.map (ArithExpr.denote after)) = + send.args.map (WireValue.map (ArithExpr.denote before)) := by + apply List.map_congr_left + intro value inside + apply WireValue.map_congr + intro p leaf + exact Scalar.Circuit.ArithExpr.denote_eq_of_agree agree + (bounded.2 p (List.mem_flatMap.mpr ⟨value, inside, leaf⟩)) + rw [args, result] + exact valid.calls send member (enabled.symm.trans active) + + · intro lookup member active + have bounded := layout.memory lookup member + simp only [MemoryLookup.inBounds, Bool.and_eq_true, List.all_eq_true] at bounded + have enabled := Scalar.Circuit.ArithExpr.denote_eq_of_agree agree bounded.1.2 + have address := Scalar.Circuit.ArithExpr.denote_eq_of_agree agree bounded.1.1 + have value := WireValue.map_congr lookup.value + (fun p leaf => Scalar.Circuit.ArithExpr.denote_eq_of_agree agree (bounded.2 p leaf)) + change (lookup.address.denote after, lookup.value.map (ArithExpr.denote after)) ∈ rom.entries + change lookup.address.denote after = lookup.address.denote before at address + rw [address, value] + exact valid.memory lookup member (enabled.symm.trans active) + +/-- A witness extends the allocation frontier and preserves every old variable. -/ +structure Extension [Field F] (rom : WireROM F) (calls : CallRelation F) (before after : BuildState F) + (initial assignment : Var → F) : Prop where + increase : before.nextVar ≤ after.nextVar + agree : ∀ id < before.nextVar, assignment id = initial id + layout : after.WellFormed + valid : after.Valid rom calls assignment + +theorem Extension.refl [Field F] {calls : CallRelation F} {state : BuildState F} + {assignment : Var → F} (layout : state.WellFormed) (valid : state.Valid rom calls assignment) : + Extension rom calls state state assignment assignment := ⟨le_rfl, by intros; rfl, layout, valid⟩ + +theorem Extension.trans [Field F] {calls : CallRelation F} {s₁ s₂ s₃ : BuildState F} + {a₁ a₂ a₃ : Var → F} (left : Extension rom calls s₁ s₂ a₁ a₂) + (right : Extension rom calls s₂ s₃ a₂ a₃) : Extension rom calls s₁ s₃ a₁ a₃ := + ⟨left.increase.trans right.increase, + fun id bound => (right.agree id (lt_of_lt_of_le bound left.increase)).trans (left.agree id bound), + right.layout, right.valid⟩ + +theorem Extension.polynomial [Field F] {calls : CallRelation F} {before after : BuildState F} + {a b : Var → F} (extension : Extension rom calls before after a b) {p : ArithExpr F} + (bounded : p.inBounds before.nextVar = true) : p.denote b = p.denote a := + Scalar.Circuit.ArithExpr.denote_eq_of_agree extension.agree bounded + +theorem Extension.value [Field F] {calls : CallRelation F} {before after : BuildState F} + {a b : Var → F} (extension : Extension rom calls before after a b) {value : Symbolic F} + (bounded : Bounded before.nextVar value) : + value.map (ArithExpr.denote b) = value.map (ArithExpr.denote a) := + WireValue.map_congr _ (fun p member => extension.polynomial (bounded p member)) + +theorem Extension.locals [Field F] {calls : CallRelation F} {before after : BuildState F} + {a b : Var → F} (extension : Extension rom calls before after a b) {locals : Locals F} + (bounded : LocalsBounded before.nextVar locals) : localsEnvironment locals b = localsEnvironment locals a := by + apply List.map_congr_left + intro binding member + simp only [extension.value (bounded binding member)] + +theorem Extension.variables [Field F] {calls : CallRelation F} {before after : BuildState F} + {a b : Var → F} (extension : Extension rom calls before after a b) {value : WireValue Var} + (bounded : Bounded (F := F) before.nextVar (value.map ArithExpr.var)) : value.map b = value.map a := by + simpa only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using extension.value bounded + +theorem fresh_complete [Field F] {calls : CallRelation F} {before after : BuildState F} {id : Var} + (compiled : fresh before = .ok (id, after)) {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls initial) (value : F) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + id < after.nextVar ∧ assignment id = value := by + simp only [fresh_apply, Except.ok.injEq, Prod.mk.injEq] at compiled + obtain ⟨rfl, rfl⟩ := compiled + let assignment := Function.update initial before.nextVar value + have agree : ∀ id < before.nextVar, assignment id = initial id := by + intro id bounded + exact Function.update_of_ne (Nat.ne_of_lt bounded) _ _ + have oldValid := valid.of_agree layout agree + exact ⟨assignment, ⟨Nat.le_succ _, agree, layout.grow (Nat.le_succ _), + ⟨oldValid.constraints, oldValid.calls, oldValid.memory⟩⟩, Nat.lt_succ_self _, by simp [assignment]⟩ + +theorem constrain_complete [Field F] {calls : CallRelation F} {before after : BuildState F} + {p : ArithExpr F} (compiled : constrain p before = .ok ((), after)) {assignment : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls assignment) + (bounded : p.inBounds before.nextVar = true) (zero : p.denote assignment = 0) : + Extension rom calls before after assignment assignment := by + simp only [constrain_apply, Except.ok.injEq, Prod.mk.injEq, true_and] at compiled + subst after + exact ⟨le_rfl, by intros; rfl, layout.constrain bounded, valid.constrain zero⟩ + +theorem boolean_complete [Field F] {calls : CallRelation F} {before after : BuildState F} + {p : ArithExpr F} (compiled : boolean p before = .ok ((), after)) {assignment : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls assignment) + (bounded : p.inBounds before.nextVar = true) (value : p.denote assignment = 0 ∨ p.denote assignment = 1) : + Extension rom calls before after assignment assignment := by + apply constrain_complete compiled layout valid + · simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using bounded + · rcases value with zero | one <;> + simp [ArithExpr.denote, Scalar.Circuit.ArithExpr.denote, *] + +theorem Extension.bound [Field F] {calls : CallRelation F} {before after : BuildState F} + {a b : Var → F} (extension : Extension rom calls before after a b) {p : ArithExpr F} + (bounded : p.inBounds before.nextVar = true) : p.inBounds after.nextVar = true := + Scalar.Circuit.ArithExpr.inBounds_mono extension.increase bounded + +theorem Extension.values [Field F] {calls : CallRelation F} {before after : BuildState F} + {a b : Var → F} (extension : Extension rom calls before after a b) {values : List (Symbolic F)} + (bounded : ∀ value ∈ values, Bounded before.nextVar value) : + values.map (WireValue.map (ArithExpr.denote b)) = values.map (WireValue.map (ArithExpr.denote a)) := + List.map_congr_left (fun value member => extension.value (bounded value member)) + +theorem send_complete [Field F] {calls : CallRelation F} {before : BuildState F} + {assignment : Var → F} (layout : before.WellFormed) (valid : before.Valid rom calls assignment) + (send : Send F) (bounded : send.inBounds before.nextVar = true) + (called : send.enable.denote assignment = 1 → + calls send.channel (send.args.map (WireValue.map (ArithExpr.denote assignment))) (send.result.map assignment)) : + Extension rom calls before { before with sends := before.sends.push send } assignment assignment := by + refine ⟨le_rfl, by intros; rfl, ⟨layout.constraints, ?_, layout.memory⟩, ⟨valid.constraints, ?_, valid.memory⟩⟩ + · intro next member + simp only [Array.toList_push, List.mem_append, List.mem_singleton] at member + rcases member with member | rfl + · exact layout.sends next member + · exact bounded + · intro next member active + simp only [Array.toList_push, List.mem_append, List.mem_singleton] at member + rcases member with member | rfl + · exact valid.calls next member active + · exact called active + +theorem send_bounded {name : String} {args : List (Symbolic F)} {result : WireValue Var} + {enable : ArithExpr F} {bound : Nat} + (argsBound : ∀ value ∈ args, Bounded bound value) + (resultBound : Bounded (F := F) bound (result.map ArithExpr.var)) + (enableBound : enable.inBounds bound = true) : + (⟨name, args, result, enable⟩ : Send F).inBounds bound = true := by + simp only [Send.inBounds, Bool.and_eq_true, List.all_eq_true, decide_eq_true_eq] + refine ⟨⟨?_, enableBound⟩, ?_⟩ + · intro id member + have := resultBound (.var id) (by simpa only [WireValue.words_map, List.mem_map] using + (show ∃ x ∈ result.words, ArithExpr.var x = .var id from ⟨id, member, rfl⟩)) + simpa only [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds, decide_eq_true_eq] using this + · intro p member + obtain ⟨value, member, leaf⟩ := List.mem_flatMap.mp member + exact argsBound value member p leaf + +theorem guarded_complete [Field F] {calls : CallRelation F} {before after : BuildState F} + {enable polynomial : ArithExpr F} + (compiled : guarded enable polynomial before = .ok ((), after)) {assignment : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls assignment) + (enableBound : enable.inBounds before.nextVar = true) + (polyBound : polynomial.inBounds before.nextVar = true) + (zero : enable.denote assignment = 0 ∨ polynomial.denote assignment = 0) : + Extension rom calls before after assignment assignment := by + apply constrain_complete compiled layout valid + · simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using And.intro enableBound polyBound + · change enable.denote assignment * polynomial.denote assignment = 0 + exact mul_eq_zero.mpr zero + +theorem requireCell_complete [Field F] {calls : CallRelation F} {before after : BuildState F} + {enable address : ArithExpr F} {value : Symbolic F} + (compiled : requireCell enable address value before = .ok ((), after)) {assignment : Var → F} + (layout : before.WellFormed) (valid : before.Valid rom calls assignment) + (enableBound : enable.inBounds before.nextVar = true) + (addressBound : address.inBounds before.nextVar = true) + (valueBound : Bounded before.nextVar value) + (cell : enable.denote assignment = 1 → + (address.denote assignment, value.map (ArithExpr.denote assignment)) ∈ rom.entries) : + Extension rom calls before after assignment assignment := by + simp only [requireCell_apply, Except.ok.injEq, Prod.mk.injEq, true_and] at compiled + subst after + refine ⟨le_rfl, by intros; rfl, ⟨layout.constraints, layout.sends, ?_⟩, + ⟨valid.constraints, valid.calls, ?_⟩⟩ + · intro lookup member + simp only [Array.toList_push, List.mem_append, List.mem_singleton] at member + rcases member with member | rfl + · exact layout.memory lookup member + · simpa [MemoryLookup.inBounds, List.all_eq_true] using ⟨⟨addressBound, enableBound⟩, valueBound⟩ + · intro lookup member + simp only [Array.toList_push, List.mem_append, List.mem_singleton] at member + rcases member with member | rfl + · exact valid.memory lookup member + · exact cell + +end Aiur.Circuit.Compiler diff --git a/Aiur/Aiur/Completeness.lean b/Aiur/Aiur/Completeness.lean new file mode 100644 index 000000000..0afada27c --- /dev/null +++ b/Aiur/Aiur/Completeness.lean @@ -0,0 +1,130 @@ +import Aiur.Correctness +import Aiur.Circuit.LocalWitness +import Aiur.Semantics.CallTypes + +namespace Aiur + +variable {F : Type} {rom : WireROM F} + +/-- Derivability of the canonical flat encodings of a semantic call. -/ +def Circuit.EncodedEvaluates [Field F] [DecidableEq F] (decls : Declarations) + (system : Circuit.System F) (rom : WireROM F) (name : String) + (args : List (Value F)) (result : Value F) : Prop := + ∃ wires output, DecodesValues decls wires args ∧ output.decode decls = some result ∧ + Circuit.CircuitEvaluates system rom name wires output + +/-- Compiled premises carry the declared result type and a well-formed nominal value. -/ +theorem circuit_calls_typed [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} (compiled : Circuit.compile program = .ok system) : + CallsTyped program (Circuit.EncodedEvaluates program.enums system rom) := by + intro name args result derives fn found + obtain ⟨wires, output, _, decoded, ⟨tree⟩⟩ := derives + cases tree with + | node chip row lookup valid children => + obtain ⟨source, sourceFound, lowered⟩ := Circuit.compile_find_chip compiled lookup + have names : chip.name = row.chip := by simpa using List.find?_some lookup + change program.findSignature? chip.name = some fn at found + have sourceSignature : program.findSignature? chip.name = some ⟨source.params, source.result⟩ := by + rw [names] + exact Program.signature_of_function sourceFound + have same := Option.some.inj (found.symm.trans sourceSignature) + subst fn + refine ⟨?_, (WireValue.decode_spec decoded).2.1⟩ + exact (WireValue.decode_spec decoded).1.trans (by + simpa only [Circuit.Chip.receive, WireValue.type_map] using + (Circuit.Compiler.lowerFunction_interface lowered).2.2) + | table member => + obtain ⟨_, constant, _, resultDecoded, absent, looked⟩ := Circuit.compile_map_spec compiled member + have same := Option.some.inj (decoded.symm.trans resultDecoded) + subst result + obtain ⟨map, _, mapFound, _, _, _, _, typed⟩ := lookupMap_spec looked + have signature := Program.signature_of_map absent mapFound + have sameSignature := Option.some.inj (found.symm.trans signature) + subst fn + simp only [Value.hasType, Bool.and_eq_true, decide_eq_true_eq] at typed + exact ⟨by simpa using typed.1, by simpa using typed.2⟩ + +theorem circuit_calls_complete [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} (compiled : Circuit.compile program = .ok system) : + Circuit.Compiler.CallsComplete program.enums (Circuit.EncodedEvaluates program.enums system rom) + (Circuit.CircuitEvaluates system rom) := by + intro name args result evaluated wires output arguments decoded + obtain ⟨otherArgs, otherResult, otherArguments, otherDecoded, derived⟩ := evaluated + have checked := typecheck_declarations (Circuit.compile_stages compiled).1 + have sameArgs := arguments.wires_unique checked otherArguments + have sameResult := WireValue.decode_injective checked decoded otherDecoded + simpa only [sameArgs, sameResult] using derived + +/-- Every finite ROM evaluation produces a closed derivation of its canonical encodings. -/ +theorem evaluation_complete [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {name : String} {args : List (Value F)} {result : Value F} + (evaluated : ROMEvalCall (rom.decode program.enums) program name args result) : + Circuit.EncodedEvaluates program.enums system rom name args result := by + have stages := Circuit.compile_stages compiled + have declarations := typecheck_declarations stages.1 + induction evaluated using ROMEvalCall.rec + (motive_1 := fun locals expr value _ => + ROMEvalExprWith program.enums (rom.decode program.enums) (Circuit.EncodedEvaluates program.enums system rom) locals expr value) + (motive_2 := fun locals exprs values _ => + ROMEvalArgsWith program.enums (rom.decode program.enums) (Circuit.EncodedEvaluates program.enums system rom) locals exprs values) with + | literal => exact .literal + | var lookup => exact .var lookup + | tuple _ ih => exact .tuple ih + | construct _ ih => exact .construct ih + | project _ projected ih => exact .project ih projected + | letValue _ matched _ inputIH bodyIH => exact .letValue inputIH matched bodyIH + | store _ cell ih => exact .store ih cell + | load _ cell typed ih => exact .load ih cell typed + | hint _ typed ih => exact .hint ih typed + | neg _ operation ih => exact .neg ih operation + | assertEq _ _ operation leftIH rightIH => exact .assertEq leftIH rightIH operation + | binary _ _ operation leftIH rightIH => exact .binary leftIH rightIH operation + | call _ _ argsIH calleeIH => exact .call argsIH calleeIH + | matchValue _ selected _ inputIH bodyIH => exact .matchValue inputIH selected bodyIH + | nil => exact .nil + | cons _ _ headIH tailIH => exact .cons headIH tailIH + | intro prepared _ bodyIH => + rcases prepareCall_spec prepared with function | table + · obtain ⟨fn, lookup, types, formed, rfl, rfl⟩ := function + obtain ⟨chip, found, lowered⟩ := Circuit.compile_find_function compiled lookup + have checked := typecheck_function stages.1 (List.mem_of_find?_eq_some lookup) + obtain ⟨row, rowName, valid, arguments, decoded, premises⟩ := Circuit.Compiler.lowerFunction_complete + declarations stages.2.1 lowered (circuit_calls_typed compiled) (circuit_calls_complete compiled) + checked types formed bodyIH + have name := Circuit.findFunction_name lookup + have rowLookup : system.findChip? row.chip = some chip := by rw [rowName, name]; exact found + obtain ⟨children⟩ := Circuit.derivations_nonempty_iff.mpr premises + have tree := Circuit.Derivation.node chip row rowLookup valid children + refine ⟨(chip.receive row).args, (chip.receive row).result, arguments, decoded, ?_⟩ + have chipName := (Circuit.Compiler.lowerFunction_interface lowered).1.trans name + simpa only [Circuit.Chip.receive, chipName, Circuit.CircuitEvaluates, Circuit.Derives] using Nonempty.intro tree + · obtain ⟨constant, _, looked, rfl, rfl⟩ := table + obtain rfl := (ROMEvalExprWith.constant_iff constant).mp bodyIH + obtain ⟨wires, output, arguments, decoded, member⟩ := Circuit.compile_map_lookup compiled looked + exact ⟨wires, output, arguments, decoded, ⟨.table member⟩⟩ + +/-- Completeness also holds for any supplied canonical encodings of the root values. -/ +theorem evaluation_complete_encoded [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {name : String} {args : List (Value F)} {result : Value F} + (evaluated : ROMEvalCall (rom.decode program.enums) program name args result) + {wires : List (WireValue F)} {output : WireValue F} + (arguments : DecodesValues program.enums wires args) (decoded : output.decode program.enums = some result) : + Circuit.CircuitEvaluates system rom name wires output := + circuit_calls_complete compiled name args result (evaluation_complete compiled evaluated) wires output arguments decoded + +/-- The compiled rules preserve and reflect evaluation of nominal, canonically encoded values. -/ +theorem compiler_correct [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {name : String} {args : List (Value F)} {result : Value F} : + ROMEvalCall (rom.decode program.enums) program name args result ↔ + Circuit.EncodedEvaluates program.enums system rom name args result := by + refine ⟨evaluation_complete compiled, ?_⟩ + rintro ⟨_, _, arguments, decoded, derived⟩ + exact compiler_sound compiled derived arguments decoded + +end Aiur diff --git a/Aiur/Aiur/Constant.lean b/Aiur/Aiur/Constant.lean new file mode 100644 index 000000000..06a4eb57f --- /dev/null +++ b/Aiur/Aiur/Constant.lean @@ -0,0 +1,201 @@ +import Aiur.Declarations +import Mathlib.Data.List.Basic +import Mathlib.Data.List.Forall2 + +namespace Aiur + +set_option linter.unusedSimpArgs false + +@[simp] theorem Value.type_mapAddress (encode : A → B) (value : Value F A) : + (value.mapAddress encode).type = value.type := by + cases value with + | field | ptr | construct => simp [Value.mapAddress, Value.type] + | tuple values => + simp only [Value.mapAddress, Value.type, List.map_map, Ty.tuple.injEq] + apply List.map_congr_left + intro value member + exact Value.type_mapAddress encode value +termination_by sizeOf value +decreasing_by + simp_wf + have := List.sizeOf_lt_of_mem ‹_ ∈ _› + omega + +@[simp] theorem Value.wellFormed_mapAddress (decls : Declarations) (encode : A → B) + (value : Value F A) : (value.mapAddress encode).wellFormed decls = value.wellFormed decls := by + cases value with + | field | ptr => simp [Value.mapAddress, Value.wellFormed] + | tuple values => + simp only [Value.mapAddress, Value.wellFormed, List.map_map] + congr 1 + apply List.map_congr_left + intro value member + exact Value.wellFormed_mapAddress decls encode value + | construct name ctor values => + simp only [Value.mapAddress, Value.wellFormed] + cases decls.findConstructor? name ctor with + | none => rfl + | some definition => + simp only [List.map_map, Function.comp_def, Value.type_mapAddress] + congr 2 + apply List.map_congr_left + intro value member + exact Value.wellFormed_mapAddress decls encode value +termination_by sizeOf value + + +namespace StaticList + +theorem mapM_some {f : α → Option β} {g : α → β} (xs : List α) + (each : ∀ x ∈ xs, f x = some (g x)) : xs.mapM f = some (xs.map g) := by + induction xs with + | nil => rfl + | cons x xs ih => + simp [List.mapM_cons, each x (by simp), ih (fun y h => each y (by simp [h]))] + +theorem mapM_congr (xs : List α) {f g : α → Option β} + (each : ∀ x ∈ xs, f x = g x) : xs.mapM f = xs.mapM g := by + induction xs with + | nil => rfl + | cons x xs ih => + simp only [List.mapM_cons, each x (by simp), ih (fun y h => each y (by simp [h]))] + +theorem mapM_some_iff {f : α → Option β} {xs : List α} {ys : List β} : + xs.mapM f = some ys ↔ List.Forall₂ (fun x y => f x = some y) xs ys := by + induction xs generalizing ys with + | nil => cases ys <;> simp + | cons x xs ih => + cases hx : f x <;> cases hs : xs.mapM f <;> + simp [List.mapM_cons, hx, hs, List.forall₂_cons_left_iff, ← ih, eq_comm] + +end StaticList + +@[simp] theorem Constant.toValue_type (value : Constant F) : + (value.toValue : Value F A).type = value.type := by + exact Value.type_mapAddress Empty.elim value + +@[simp] theorem Constant.toValue_mapAddress (value : Constant F) (encode : A → B) : + (value.toValue : Value F A).mapAddress encode = value.toValue := by + cases value with + | field => simp [Constant.toValue, Value.mapAddress] + | ptr _ address => exact Empty.elim address + | tuple values | construct _ _ values => + simp only [Constant.toValue, Value.mapAddress, List.map_map, + Value.tuple.injEq, Value.construct.injEq, true_and] + exact List.map_congr_left (fun value _ => Constant.toValue_mapAddress value encode) +termination_by sizeOf value + +@[simp] theorem Constant.toValue_wellFormed (decls : Declarations) (value : Constant F) : + (value.toValue : Value F A).wellFormed decls = value.wellFormed decls := by + exact Value.wellFormed_mapAddress decls Empty.elim value + +@[simp] theorem Constant.toValue_pointerFree (value : Constant F) : + (value.toValue : Value F A).pointerFree = true := by + cases value with + | field => simp [Constant.toValue, Value.mapAddress, Value.pointerFree, Value.toConstant?] + | ptr _ address => exact Empty.elim address + | tuple items | construct _ _ items => + simp only [Constant.toValue, Value.mapAddress, Value.pointerFree, List.map_map, + List.all_eq_true, List.mem_map, forall_exists_index, and_imp, forall_apply_eq_imp_iff₂] + intro value member + exact Constant.toValue_pointerFree value +termination_by sizeOf value + +@[simp] theorem Constant.toConstant_toValue (value : Constant F) : + (value.toValue : Value F A).toConstant? = some value := by + cases value with + | field => simp [Constant.toValue, Value.mapAddress, Value.pointerFree, Value.toConstant?] + | ptr _ address => exact Empty.elim address + | tuple items | construct _ _ items => + simp only [Constant.toValue, Value.mapAddress, Value.toConstant?, List.mapM_map] + have mapped := StaticList.mapM_some (f := fun item : Constant F => + (item.toValue : Value F A).toConstant?) (g := id) items + (fun item _ => Constant.toConstant_toValue item) + simp only [List.map_id] at mapped + change (Option.map _ (items.mapM _)) = _ + rw [show items.mapM (Value.toConstant? ∘ Value.mapAddress (Empty.elim : Empty → A)) = + some items from mapped] + rfl +termination_by sizeOf value + +@[simp] theorem Value.toConstant_mapAddress (value : Value F A) (encode : A → B) : + (value.mapAddress encode).toConstant? = value.toConstant? := by + cases value with + | field | ptr => simp [Value.mapAddress, Value.toConstant?] + | tuple items | construct _ _ items => + simp only [Value.mapAddress, Value.toConstant?, List.mapM_map] + congr 1 + apply StaticList.mapM_congr + intro item member + exact Value.toConstant_mapAddress item encode +termination_by sizeOf value + +/-- A successful extraction reconstructs exactly the original value. -/ +theorem Value.toConstant_spec {value : Value F A} {constant : Constant F} + (extracted : value.toConstant? = some constant) : constant.toValue = value := by + cases value with + | field x => + simp only [Value.toConstant?, Option.some.injEq] at extracted + subst constant + simp [Constant.toValue, Value.mapAddress] + | ptr => simp [Value.toConstant?] at extracted + | tuple items => + simp only [Value.toConstant?] at extracted + cases mapped : items.mapM Value.toConstant? with + | none => simp [mapped] at extracted + | some constants => + simp [mapped] at extracted + subst constant + simp only [Constant.toValue, Value.mapAddress, Value.tuple.injEq] + have related := StaticList.mapM_some_iff.mp mapped + have each : ∀ item ∈ items, ∀ c, item.toConstant? = some c → c.toValue = item := + fun item _ _ found => Value.toConstant_spec found + clear mapped + induction related with + | nil => rfl + | @cons item c items constants found rest ih => + exact congrArg₂ List.cons (each item (by simp) c found) + (ih (fun v h => each v (by simp [h]))) + | construct name ctor items => + simp only [Value.toConstant?] at extracted + cases mapped : items.mapM Value.toConstant? with + | none => simp [mapped] at extracted + | some constants => + simp [mapped] at extracted + subst constant + simp only [Constant.toValue, Value.mapAddress, Value.construct.injEq, true_and] + have related := StaticList.mapM_some_iff.mp mapped + have each : ∀ item ∈ items, ∀ c, item.toConstant? = some c → c.toValue = item := + fun item _ _ found => Value.toConstant_spec found + clear mapped + induction related with + | nil => rfl + | @cons item c items constants found rest ih => + exact congrArg₂ List.cons (each item (by simp) c found) + (ih (fun v h => each v (by simp [h]))) +termination_by sizeOf value + +/-- A pointer-free value has a constant representation in any address space. -/ +theorem Value.exists_constant (value : Value F A) : + value.pointerFree = true → ∃ constant : Constant F, constant.toValue = value := by + induction value using Value.rec + (motive_2 := fun values => (∀ value ∈ values, value.pointerFree = true) → + ∃ constants : List (Constant F), constants.map Constant.toValue = values) with + | field x => intro _; exact ⟨.field x, by simp [Constant.toValue, Value.mapAddress]⟩ + | ptr => simp [Value.pointerFree] + | tuple values ih => + intro free + obtain ⟨constants, rfl⟩ := ih (by simpa [Value.pointerFree] using free) + exact ⟨.tuple constants, by simp [Constant.toValue, Value.mapAddress]⟩ + | construct name ctor values ih => + intro free + obtain ⟨constants, rfl⟩ := ih (by simpa [Value.pointerFree] using free) + exact ⟨.construct name ctor constants, by simp [Constant.toValue, Value.mapAddress]⟩ + | nil => exact ⟨[], rfl⟩ + | cons head tail headIH tailIH => + rename_i free + obtain ⟨constant, rfl⟩ := headIH (free head (by simp)) + obtain ⟨constants, rfl⟩ := tailIH (fun v h => free v (by simp [h])) + exact ⟨constant :: constants, rfl⟩ + +end Aiur diff --git a/Aiur/Aiur/ConstructorFacts.lean b/Aiur/Aiur/ConstructorFacts.lean new file mode 100644 index 000000000..2cde0a237 --- /dev/null +++ b/Aiur/Aiur/ConstructorFacts.lean @@ -0,0 +1,99 @@ +import Aiur.LayoutUnique +import Aiur.EncodingTypes + +namespace Aiur + +theorem ConstructorsDescribe.at {decls : Declarations} {layouts : List (String × Layout)} + {constructors : List ConstructorDecl} (related : ConstructorsDescribe decls layouts constructors) + {index : Nat} {ctor : ConstructorDecl} (found : constructors[index]? = some ctor) : + ∃ layout, layouts[index]? = some (ctor.name, layout) ∧ layout.Describes decls (.tuple ctor.fields) := by + cases related with + | nil => simp at found + | @cons name layout layouts ctors head same described tail => + cases index with + | zero => + simp only [List.getElem?_cons_zero, Option.some.injEq] at found + subst ctor + exact ⟨layout, by simp [same], described⟩ + | succ index => + exact tail.at (by simpa using found) +termination_by sizeOf constructors + +theorem ConstructorsDescribe.length {decls : Declarations} {layouts : List (String × Layout)} + {constructors : List ConstructorDecl} (related : ConstructorsDescribe decls layouts constructors) : + layouts.length = constructors.length := by + cases related with + | nil => rfl + | cons _ _ tail => simp [tail.length] +termination_by sizeOf constructors + +/-- Decoding identifies an actual declaration position and its selected payload. -/ +theorem Layout.decodeConstructor_spec [NatCast F] [Zero F] [DecidableEq F] + {constructors : List (String × Layout)} {tag : F} {payload : List F} {start : Nat} + {ctor : String} {args : List (Value F)} + (decoded : Layout.decodeConstructor constructors tag payload start = some (ctor, args)) : + ∃ index layout, constructors[index]? = some (ctor, layout) ∧ + tag = ((start + index : Nat) : F) ∧ + layout.decode (payload.take layout.width) = some (.tuple args) := by + induction constructors generalizing start with + | nil => simp [Layout.decodeConstructor] at decoded + | cons pair rest ih => + rcases pair with ⟨name, layout⟩ + simp only [Layout.decodeConstructor] at decoded + split at decoded + · rename_i selected + obtain ⟨value, payloadRun, finished⟩ := Option.bind_eq_some_iff.mp decoded + cases value with + | field | ptr | construct => cases finished + | tuple values => + dsimp only at finished + split at finished + · simp only [Option.pure_def, Option.some.injEq, Prod.mk.injEq] at finished + rcases finished with ⟨rfl, rfl⟩ + exact ⟨0, layout, by simp, by simpa using selected, payloadRun⟩ + · cases finished + · obtain ⟨index, chosen, atIndex, tagEq, inner⟩ := ih decoded + exact ⟨index + 1, chosen, by simpa using atIndex, + by simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using tagEq, inner⟩ + +private theorem nodup_index {items : List α} (unique : items.Nodup) {i j : Nat} {value : α} + (left : items[i]? = some value) (right : items[j]? = some value) : i = j := by + obtain ⟨hi, left⟩ := List.getElem?_eq_some_iff.mp left + obtain ⟨hj, right⟩ := List.getElem?_eq_some_iff.mp right + exact unique.getElem_inj_iff.mp (left.trans right.symm) + +/-- Distinct representable tags are equivalent to the nominal constructor identity. -/ +theorem Layout.decodeConstructor_match [NatCast F] [Zero F] [DecidableEq F] + {constructors : List (String × Layout)} (names : (constructors.map Prod.fst).Nodup) + {start : Nat} (tags : TagsDistinct F start constructors.length) + {index : Nat} {ctor : String} {layout : Layout} + (found : constructors[index]? = some (ctor, layout)) + {tag : F} {payload : List F} {actual : String} {args : List (Value F)} + (decoded : Layout.decodeConstructor constructors tag payload start = some (actual, args)) : + (tag = ((start + index : Nat) : F) ↔ actual = ctor) ∧ + (actual = ctor → layout.decode (payload.take layout.width) = some (.tuple args)) := by + obtain ⟨selected, chosen, atSelected, tagEq, payloadRun⟩ := Layout.decodeConstructor_spec decoded + have hi := (List.getElem?_eq_some_iff.mp found).1 + have hs := (List.getElem?_eq_some_iff.mp atSelected).1 + have sameIndex : actual = ctor → selected = index := by + intro same + apply nodup_index names (value := ctor) + · simpa [List.getElem?_map, atSelected, same] + · simp [List.getElem?_map, found] + have samePair : selected = index → (actual, chosen) = (ctor, layout) := by + intro same + rw [same, found] at atSelected + exact Option.some.inj atSelected.symm + refine ⟨⟨?_, ?_⟩, ?_⟩ + · intro matchTag + have sumEq := tags (start + selected) (start + index) (by omega) (by omega) + (by omega) (by omega) (tagEq.symm.trans matchTag) + exact (Prod.mk.inj (samePair (by omega))).1 + · intro same + simpa [sameIndex same] using tagEq + · intro same + have pairEq := samePair (sameIndex same) + have layoutEq := (Prod.mk.inj pairEq).2 + simpa [layoutEq] using payloadRun + +end Aiur diff --git a/Aiur/Aiur/Correctness.lean b/Aiur/Aiur/Correctness.lean new file mode 100644 index 000000000..c2132e939 --- /dev/null +++ b/Aiur/Aiur/Correctness.lean @@ -0,0 +1,74 @@ +import Aiur.Circuit.LocalCorrectness +import Aiur.Circuit.Derivation +import Aiur.Circuit.MapFacts +import Aiur.Semantics.CallFacts + +namespace Aiur + +variable {F : Type} {rom : WireROM F} + +/-- A raw circuit claim represents well-formed arguments and a correct evaluated result. -/ +def Circuit.Message.Evaluates [Field F] [DecidableEq F] (program : Program F) (rom : WireROM F) + (message : Circuit.Message F) : Prop := + ∃ args result, DecodesValues program.enums message.args args ∧ + message.result.decode program.enums = some result ∧ + ROMEvalCall (rom.decode program.enums) program message.channel args result + +/-- Every closed derivation has canonical values and a finite evaluation against the decoded ROM. -/ +theorem derivation_sound [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) {message : Circuit.Message F} + (derivation : Circuit.Derivation system rom message) : message.Evaluates program rom := by + have stages := Circuit.compile_stages compiled + have checked := typecheck_declarations stages.1 + induction derivation using Circuit.Derivation.rec + (motive_2 := fun messages _ => ∀ message ∈ messages, message.Evaluates program rom) with + | node chip row lookup valid _ childrenIH => + obtain ⟨fn, found, lowered⟩ := Circuit.compile_find_chip compiled lookup + have interface := Circuit.Compiler.lowerFunction_interface lowered + obtain ⟨args, result, argsDecoded, resultDecoded, body⟩ := + Circuit.Compiler.lowerFunction_sound checked stages.2.1 lowered valid + (sourceCalls := ROMEvalCall (rom.decode program.enums) program) (by + intro message member args result argsDecode resultDecode + obtain ⟨otherArgs, otherResult, otherArgsDecode, otherResultDecode, evaluated⟩ := childrenIH message member + have sameArgs := argsDecode.unique otherArgsDecode + have sameResult := Option.some.inj (resultDecode.symm.trans otherResultDecode) + simpa only [sameArgs, sameResult] using evaluated) + refine ⟨args, result, argsDecoded, resultDecoded, ?_⟩ + have types : fn.params.map Prod.snd = args.map Value.type := by + rw [argsDecoded.types] + simpa only [Circuit.Chip.receive, List.map_map, Function.comp_def, WireValue.type_map] + using interface.2.1.symm + apply ROMEvalCall.intro (prepareCall_of_types (fn := fn) ?_ types argsDecoded.wellFormed) body.toEvalExpr + change program.findFunction? chip.name = some fn + rw [interface.1, Circuit.findFunction_name found] + exact found + | table member => + obtain ⟨args, constant, arguments, output, absent, looked⟩ := Circuit.compile_map_spec compiled member + refine ⟨args, constant.toValue, arguments, output, .intro (prepareCall_map absent looked) ?_⟩ + exact ((ROMEvalExprWith.constant_iff (rom := rom.decode program.enums) + (calls := ROMEvalCall (rom.decode program.enums) program) constant).mpr rfl).toEvalExpr + | nil => simp_all + | cons _ _ headIH tailIH => + rename_i message member + rcases List.mem_cons.mp member with same | member + · subst message; exact headIH + · exact tailIH message member + +/-- For a well-formed encoded root claim, derivability proves the claimed source result. -/ +theorem compiler_sound [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {name : String} {args : List (WireValue F)} {result : WireValue F} + (derives : Circuit.CircuitEvaluates system rom name args result) + {values : List (Value F)} {value : Value F} + (arguments : DecodesValues program.enums args values) + (output : result.decode program.enums = some value) : + ROMEvalCall (rom.decode program.enums) program name values value := by + obtain ⟨tree⟩ := derives + obtain ⟨otherArgs, otherResult, decodedArgs, decodedResult, evaluated⟩ := derivation_sound compiled tree + have sameArgs := arguments.unique decodedArgs + have sameResult := Option.some.inj (output.symm.trans decodedResult) + simpa only [sameArgs, sameResult] using evaluated + +end Aiur diff --git a/Aiur/Aiur/DeclarationChecks.lean b/Aiur/Aiur/DeclarationChecks.lean new file mode 100644 index 000000000..08784607c --- /dev/null +++ b/Aiur/Aiur/DeclarationChecks.lean @@ -0,0 +1,102 @@ +import Aiur.DeclarationFacts +import Aiur.WireCanonical +import Mathlib.Data.List.Nodup + +namespace Aiur + +private theorem duplicateName_none {names seen : List String} + (checked : duplicateName names seen = none) : names.Nodup ∧ ∀ name ∈ names, name ∉ seen := by + induction names generalizing seen with + | nil => simp + | cons name names ih => + simp only [duplicateName] at checked + split at checked + · cases checked + · rename_i fresh + obtain ⟨unique, absent⟩ := ih checked + refine ⟨List.nodup_cons.mpr ⟨?_, unique⟩, ?_⟩ + · intro member + exact absent name member (by simp) + · intro value member + rcases List.mem_cons.mp member with rfl | member + · exact fresh + · intro seenMember + exact absent value member (by simp [seenMember]) + +theorem checkDeclarations_names {decls : Declarations} (checked : checkDeclarations decls = .ok ()) : + (decls.map EnumDecl.name).Nodup ∧ ∀ decl ∈ decls, (decl.constructors.map ConstructorDecl.name).Nodup := by + unfold checkDeclarations at checked + cases duplicate : duplicateName (decls.map EnumDecl.name) [] with + | some name => simp [duplicate, bind, Except.bind] at checked + | none => + simp only [duplicate, pure_bind] at checked + obtain ⟨done, entries, _⟩ := except_bind_ok.mp checked + cases done + have each := forIn_ok (action := checkEnum decls) (by + have combined := congrArg (fun r : Except DeclError PUnit => r >>= fun _ => + (pure () : Except DeclError Unit)) entries + simpa only [bind, Except.bind, pure, Except.pure] using combined) + refine ⟨(duplicateName_none duplicate).1, ?_⟩ + intro decl member + have valid := each decl member + cases repeated : duplicateName (decl.constructors.map ConstructorDecl.name) [] with + | none => exact (duplicateName_none repeated).1 + | some name => + by_cases reserved : decl.name = "Field" + · simp [checkEnum, reserved, repeated, bind, Except.bind, pure, Except.pure] at valid + · cases empty : decl.constructors.isEmpty <;> + simp [checkEnum, reserved, empty, repeated, bind, Except.bind, pure, Except.pure] at valid + + +theorem Layout.Describes.namesUnique {decls : Declarations} + (names : ∀ decl ∈ decls, (decl.constructors.map ConstructorDecl.name).Nodup) + {layout : Layout} {ty : Ty} (described : layout.Describes decls ty) : layout.NamesUnique := by + refine Layout.Describes.rec + (motive_1 := fun layout _ _ => layout.NamesUnique) + (motive_2 := fun layouts _ _ => ∀ layout ∈ layouts, layout.NamesUnique) + (motive_3 := fun layouts ctors _ => layouts.map Prod.fst = ctors.map ConstructorDecl.name ∧ + ∀ pair ∈ layouts, pair.2.NamesUnique) + ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ described + · simp [Layout.NamesUnique] + · intro target; simp [Layout.NamesUnique] + · intro layouts types related ih + simpa only [Layout.NamesUnique] using ih + · intro name definition constructors found related ih + simp only [Layout.NamesUnique] + exact ⟨by rw [ih.1]; exact names _ (List.mem_of_find?_eq_some found), ih.2⟩ + · simp + · intro layout type layouts types head tail h t + simpa using And.intro h t + · simp + · intro name layout layouts ctors ctor same head tail h t + exact ⟨by simp [same, t.1], by simpa using And.intro h t.2⟩ + +theorem tagsDistinct_zero [NatCast F] {count : Nat} + (tags : ((List.range count).map (fun i : Nat => (i : F))).Nodup) : TagsDistinct F 0 count := by + intro i j _ hi _ hj same + exact List.inj_on_of_nodup_map tags (by simpa using hi) (by simpa using hj) same + +theorem Layout.Describes.tagSafe [NatCast F] + {decls : Declarations} (tags : ∀ decl ∈ decls, TagsDistinct F 0 decl.constructors.length) + {layout : Layout} {ty : Ty} (described : layout.Describes decls ty) : layout.TagSafe F := by + refine Layout.Describes.rec + (motive_1 := fun layout _ _ => layout.TagSafe F) + (motive_2 := fun layouts _ _ => ∀ layout ∈ layouts, layout.TagSafe F) + (motive_3 := fun layouts ctors _ => layouts.length = ctors.length ∧ + ∀ pair ∈ layouts, pair.2.TagSafe F) + ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ described + · simp [Layout.TagSafe] + · intro target; simp [Layout.TagSafe] + · intro layouts types related ih + simpa only [Layout.TagSafe] using ih + · intro name definition constructors found related ih + simp only [Layout.TagSafe] + exact ⟨by rw [ih.1]; exact tags _ (List.mem_of_find?_eq_some found), ih.2⟩ + · simp + · intro layout type layouts types head tail h t + simpa using And.intro h t + · simp + · intro name layout layouts ctors ctor same head tail h t + exact ⟨by simp [t.1], by simpa using And.intro h t.2⟩ + +end Aiur diff --git a/Aiur/Aiur/DeclarationFacts.lean b/Aiur/Aiur/DeclarationFacts.lean new file mode 100644 index 000000000..89d74dd6d --- /dev/null +++ b/Aiur/Aiur/DeclarationFacts.lean @@ -0,0 +1,129 @@ +import Aiur.Declarations +import Aiur.ExceptFacts +import Mathlib.Data.List.Monad +import Mathlib.Data.List.Forall2 + +namespace Aiur + +/- A finite layout is obtained by unfolding the declared nominal constructors. -/ +mutual + inductive Layout.Describes (decls : Declarations) : Layout → Ty → Prop where + | field : Layout.Describes decls .field .field + | ptr : Layout.Describes decls (.ptr target) (.ptr target) + | tuple : LayoutsDescribe decls layouts types → + Layout.Describes decls (.tuple layouts) (.tuple types) + | enum : decls.findEnum? name = some definition → + ConstructorsDescribe decls constructors definition.constructors → + Layout.Describes decls (.enum name constructors) (.enum name) + + inductive LayoutsDescribe (decls : Declarations) : List Layout → List Ty → Prop where + | nil : LayoutsDescribe decls [] [] + | cons : Layout.Describes decls layout type → LayoutsDescribe decls layouts types → + LayoutsDescribe decls (layout :: layouts) (type :: types) + + inductive ConstructorsDescribe (decls : Declarations) : + List (String × Layout) → List ConstructorDecl → Prop where + | nil : ConstructorsDescribe decls [] [] + | cons : name = ctor.name → Layout.Describes decls layout (.tuple ctor.fields) → + ConstructorsDescribe decls layouts ctors → + ConstructorsDescribe decls ((name, layout) :: layouts) (ctor :: ctors) +end + +private theorem mapM_describes {f : α → Except ε β} {xs : List α} {ys : List β} + (run : xs.mapM f = .ok ys) : List.Forall₂ (fun x y => f x = .ok y) xs ys := by + induction xs generalizing ys with + | nil => + simp [List.mapM_nil, pure, Except.pure] at run + subst ys + exact .nil + | cons x xs ih => + cases first : f x with + | error error => simp [List.mapM_cons, first, bind, Except.bind] at run + | ok y => + cases rest : xs.mapM f with + | error error => simp [List.mapM_cons, first, rest, bind, Except.bind] at run + | ok zs => + simp [List.mapM_cons, first, rest, bind, Except.bind, pure, Except.pure] at run + subst ys + exact .cons first (ih rest) + +private theorem layoutWith_describes {decls : Declarations} + {resolve : String → Except DeclError Layout} + (resolved : ∀ name layout, resolve name = .ok layout → Layout.Describes decls layout (.enum name)) + (type : Ty) {layout : Layout} (run : type.layoutWith resolve = .ok layout) : + Layout.Describes decls layout type := by + cases type with + | field => simp only [Ty.layoutWith, Except.ok.injEq] at run; subst layout; exact .field + | ptr => simp only [Ty.layoutWith, Except.ok.injEq] at run; subst layout; exact .ptr + | enum name => exact resolved name layout (by simpa [Ty.layoutWith] using run) + | tuple types => + cases mapped : types.mapM (Ty.layoutWith resolve) with + | error error => simp [Ty.layoutWith, mapped, bind, Except.bind] at run + | ok layouts => + simp [Ty.layoutWith, mapped, bind, Except.bind, pure, Except.pure] at run + subst layout + apply Layout.Describes.tuple + have paired := mapM_describes mapped + have recur : ∀ type ∈ types, ∀ layout, type.layoutWith resolve = .ok layout → + Layout.Describes decls layout type := fun type member layout run => + layoutWith_describes resolved type run + clear resolved mapped + induction paired with + | nil => exact .nil + | cons head tail ih => + exact .cons (recur _ (by simp) _ head) (ih (fun t h => recur t (by simp [h]))) +termination_by sizeOf type + +/-- Successful expansion, at any depth, describes precisely the declared type. -/ +theorem Declarations.expand_describes (decls : Declarations) (depth : Nat) (type : Ty) + {layout : Layout} (run : decls.expand depth type = .ok layout) : + Layout.Describes decls layout type := by + induction depth generalizing type layout with + | zero => + exact layoutWith_describes (decls := decls) (by intro name layout run; cases run) type run + | succ depth ih => + simp only [Declarations.expand] at run + apply layoutWith_describes (decls := decls) (type := type) (run := run) + intro name layout resolved + cases found : decls.findEnum? name with + | none => simp [found] at resolved + | some definition => + simp only [found] at resolved + obtain ⟨constructors, mapped, finished⟩ := except_bind_ok.mp resolved + have same := except_pure_ok.mp finished + subst layout + apply Layout.Describes.enum found + have paired := mapM_describes mapped + clear mapped run resolved found finished + generalize hdefs : definition.constructors = definitions at paired ⊢ + clear hdefs + induction paired with + | nil => exact .nil + | @cons ctor pair ctors pairs head tail recur => + obtain ⟨layouts, fields, finished⟩ := except_bind_ok.mp head + have same := except_pure_ok.mp finished + subst pair + refine .cons rfl (.tuple ?_) recur + have pairedFields := mapM_describes fields + clear fields head finished + generalize hfields : ctor.fields = types at pairedFields ⊢ + clear hfields + induction pairedFields with + | nil => exact .nil + | cons h hs recur => exact .cons (ih _ h) recur + +theorem Declarations.layout_describes {decls : Declarations} {type : Ty} {layout : Layout} + (run : decls.layout type = .ok layout) : Layout.Describes decls layout type := by + unfold Declarations.layout at run + cases names : type.checkNames decls with + | error error => simp [names, bind, Except.bind] at run + | ok done => exact decls.expand_describes _ type (by simpa [names, bind, Except.bind] using run) + +/-- Layout expansion preserves the nominal type, independently of field encodings. -/ +theorem Layout.Describes.type {decls : Declarations} {layout : Layout} {ty : Ty} + (described : layout.Describes decls ty) : layout.type = ty := by + induction described using Layout.Describes.rec + (motive_2 := fun layouts types _ => layouts.map Layout.type = types) + (motive_3 := fun _ _ _ => True) <;> simp_all [Layout.type] + +end Aiur diff --git a/Aiur/Aiur/DeclarationTotal.lean b/Aiur/Aiur/DeclarationTotal.lean new file mode 100644 index 000000000..40aab44fe --- /dev/null +++ b/Aiur/Aiur/DeclarationTotal.lean @@ -0,0 +1,60 @@ +import Aiur.LayoutComposition + +namespace Aiur + +private theorem forIn_values_ok {action : α → Except ε β} {items : List α} + (checked : (do for item in items do let _ ← action item : Except ε Unit) = .ok ()) : + ∀ item ∈ items, ∃ value, action item = .ok value := by + induction items with + | nil => simp + | cons item items ih => + cases first : action item with + | error error => simp [List.forIn_cons, first, bind, Except.bind] at checked + | ok value => + simp only [List.forIn_cons, first, bind, Except.bind, pure, Except.pure] at checked + intro other member + rcases List.mem_cons.mp member with rfl | member + · exact ⟨value, first⟩ + · exact ih checked other member + +theorem checkDeclarations_enum_layout {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) {decl : EnumDecl} (member : decl ∈ decls) : + ∃ layout, decls.layout (.enum decl.name) = .ok layout := by + unfold checkDeclarations at checked + split at checked + · cases checked + · simp only [pure_bind] at checked + obtain ⟨done, _, rest⟩ := except_bind_ok.mp checked + cases done + exact forIn_values_ok (action := fun decl : EnumDecl => decls.layout (.enum decl.name)) rest decl member + +/-- Checked declarations give a finite layout to every type whose names resolve. -/ +theorem Declarations.layout_total {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) {type : Ty} + (names : type.checkNames decls = .ok ()) : ∃ layout, decls.layout type = .ok layout := by + cases type with + | field => exact ⟨.field, Declarations.layout_field decls⟩ + | ptr target => exact ⟨.ptr target, Declarations.layout_ptr (by simpa only [Ty.checkNames] using names)⟩ + | enum name => + cases found : decls.findEnum? name with + | none => simp [Ty.checkNames, found] at names + | some decl => + have same : decl.name = name := by simpa using List.find?_some found + simpa only [same] using checkDeclarations_enum_layout checked (List.mem_of_find?_eq_some found) + | tuple types => + have each := forIn_ok (by simpa only [Ty.checkNames] using names) + have existsLayouts : ∀ type ∈ types, ∃ layout, decls.layout type = .ok layout := + fun type member => Declarations.layout_total checked (each type member) + have related : ∃ layouts, List.Forall₂ (fun type layout => decls.layout type = .ok layout) types layouts := by + clear names each + induction types with + | nil => exact ⟨[], .nil⟩ + | cons type types ih => + obtain ⟨layout, expanded⟩ := existsLayouts type (by simp) + obtain ⟨layouts, related⟩ := ih (fun t h => existsLayouts t (by simp [h])) + exact ⟨layout :: layouts, .cons expanded related⟩ + obtain ⟨layouts, related⟩ := related + exact ⟨.tuple layouts, Declarations.layout_tuple related⟩ +termination_by sizeOf type + +end Aiur diff --git a/Aiur/Aiur/Declarations.lean b/Aiur/Aiur/Declarations.lean new file mode 100644 index 000000000..f05c50659 --- /dev/null +++ b/Aiur/Aiur/Declarations.lean @@ -0,0 +1,197 @@ +import Aiur.AST + +namespace Aiur + +inductive DeclError where + | duplicateEnum (name : String) + | reservedType (name : String) + | emptyEnum (name : String) + | duplicateConstructor (enumName constructor : String) + | unknownType (name : String) + | inlineRecursion (name : String) + deriving Repr, BEq, DecidableEq + +instance : ToString DeclError where + toString + | .duplicateEnum name => s!"duplicate enum '{name}'" + | .reservedType name => s!"reserved type name '{name}'" + | .emptyEnum name => s!"enum '{name}' must have at least one constructor" + | .duplicateConstructor name ctor => s!"duplicate constructor '{name}::{ctor}'" + | .unknownType name => s!"unknown type '{name}'" + | .inlineRecursion name => s!"recursive type '{name}' must recurse through a pointer" + +/-- A finite inline layout. Pointer targets remain nominal type metadata. -/ +inductive Layout where + | field + | ptr (target : Ty) + | tuple (items : List Layout) + | enum (name : String) (constructors : List (String × Layout)) + deriving Repr, BEq + +def Layout.type : Layout → Ty + | .field => .field + | .ptr target => .ptr target + | .tuple items => .tuple (items.map Layout.type) + | .enum name _ => .enum name +termination_by layout => sizeOf layout + +/-- A unique constructor is determined by the nominal type alone. -/ +def Layout.tagWidth (count : Nat) : Nat := if count = 1 then 0 else 1 + +/-- Assemble an enum without storing its implicit tag when there is one constructor. -/ +def Layout.enumWords (count : Nat) (tag : α) (payload : List α) : List α := + if count = 1 then payload else tag :: payload + +/-- Recover the implicit tag for a single-constructor enum, even for an empty payload. -/ +def Layout.enumParts (count : Nat) (zero : α) (words : List α) : Option (α × List α) := + if count = 1 then some (zero, words) else + match words with | [] => none | tag :: payload => some (tag, payload) + +@[simp] theorem Layout.enumWords_length (count : Nat) (tag : α) (payload : List α) : + (enumWords count tag payload).length = tagWidth count + payload.length := by + simp [enumWords, tagWidth]; split <;> simp [Nat.add_comm] + +@[simp] theorem Layout.enumWords_map (f : α → β) (count : Nat) (tag : α) (payload : List α) : + (enumWords count tag payload).map f = enumWords count (f tag) (payload.map f) := by + unfold enumWords; split <;> rfl + +theorem Layout.enumParts_map (f : α → β) (count : Nat) (zero : α) (words : List α) : + enumParts count (f zero) (words.map f) = + (enumParts count zero words).map (fun pair => (f pair.1, pair.2.map f)) := by + unfold enumParts; split <;> cases words <;> rfl + +theorem Layout.enumParts_words {count : Nat} {zero tag : α} {words payload : List α} + (parts : enumParts count zero words = some (tag, payload)) : + enumWords count tag payload = words := by + unfold enumParts at parts + split at parts + · cases parts; simp [enumWords, *] + · cases words <;> simp_all [enumWords] + +theorem Layout.enumParts_enumWords {count : Nat} {zero tag : α} (payload : List α) + (implicit : count = 1 → tag = zero) : + enumParts count zero (enumWords count tag payload) = some (tag, payload) := by + unfold enumParts enumWords + split <;> simp_all + +theorem Layout.enumParts_map_of (f : α → β) {count : Nat} {zero tag : α} + {words payload : List α} (parts : enumParts count zero words = some (tag, payload)) : + enumParts count (f zero) (words.map f) = some (f tag, payload.map f) := by + rw [enumParts_map, parts]; rfl + +theorem Layout.enumParts_all {count : Nat} {zero tag : α} {words payload : List α} + (parts : enumParts count zero words = some (tag, payload)) {p : α → Prop} + (implicit : p zero) (all : ∀ word ∈ words, p word) : p tag ∧ ∀ word ∈ payload, p word := by + unfold enumParts at parts + split at parts + · cases parts; exact ⟨implicit, all⟩ + · cases words with + | nil => cases parts + | cons head tail => cases parts; simpa using all + +theorem Layout.enumWords_all (count : Nat) (tag : α) (payload : List α) {p : α → Prop} + (head : p tag) (tail : ∀ word ∈ payload, p word) : + ∀ word ∈ enumWords count tag payload, p word := by + unfold enumWords; split <;> simp_all + +def Layout.width : Layout → Nat + | .field | .ptr _ => 1 + | .tuple items => (items.map Layout.width).sum + | .enum _ constructors => Layout.tagWidth constructors.length + + ((constructors.map fun c => c.2.width).foldr max 0) +termination_by layout => sizeOf layout +decreasing_by + all_goals simp_wf + all_goals + have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + first | omega | cases ‹String × Layout›; simp_all only [Prod.mk.sizeOf_spec]; omega + +/-- Every constructor payload must be free of pointers, including unselected variants. -/ +def Layout.pointerFree : Layout → Bool + | .field => true + | .ptr _ => false + | .tuple items => (items.map Layout.pointerFree).all id + | .enum _ constructors => (constructors.map (fun ctor => ctor.2.pointerFree)).all id +termination_by layout => sizeOf layout +decreasing_by + all_goals simp_wf + all_goals + have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + first | omega | cases ‹String × Layout›; simp_all only [Prod.mk.sizeOf_spec]; omega + +def Ty.checkNames (decls : Declarations) : Ty → Except DeclError Unit + | .field => .ok () + | .ptr target => target.checkNames decls + | .tuple items => do + for item in items do item.checkNames decls + | .enum name => + if (decls.findEnum? name).isSome then .ok () else .error (.unknownType name) +termination_by type => sizeOf type + +/-- Traverse a structural type, leaving nominal references to a supplied resolver. -/ +def Ty.layoutWith (resolve : String → Except DeclError Layout) : Ty → Except DeclError Layout + | .field => .ok .field + | .ptr target => .ok (.ptr target) + | .tuple items => return .tuple (← items.mapM (Ty.layoutWith resolve)) + | .enum name => resolve name +termination_by type => sizeOf type + +/-- Only following an inline enum reference consumes depth. Pointers stop expansion. -/ +def Declarations.expand (decls : Declarations) : Nat → Ty → Except DeclError Layout + | 0, type => type.layoutWith (fun name => .error (.inlineRecursion name)) + | depth + 1, type => type.layoutWith fun name => do + let some decl := decls.findEnum? name | throw (.unknownType name) + let constructors ← decl.constructors.mapM fun ctor => do + return (ctor.name, Layout.tuple (← ctor.fields.mapM (decls.expand depth))) + return .enum name constructors + + +def Declarations.layout (decls : Declarations) (type : Ty) : Except DeclError Layout := do + type.checkNames decls + decls.expand (decls.length + 1) type + +/-- Public input and table types cannot contain pointers in any reachable constructor. -/ +def Ty.pointerFree (decls : Declarations) (type : Ty) : Bool := + match decls.layout type with + | .ok layout => layout.pointerFree + | .error _ => false + +def duplicateName : List String → List String → Option String + | [], _ => none + | name :: names, seen => if name ∈ seen then some name else duplicateName names (name :: seen) + +def checkEnum (decls : Declarations) (decl : EnumDecl) : Except DeclError Unit := do + if decl.name = "Field" then throw (.reservedType decl.name) + if decl.constructors.isEmpty then throw (.emptyEnum decl.name) + if let some name := duplicateName (decl.constructors.map ConstructorDecl.name) [] then + throw (.duplicateConstructor decl.name name) + for ctor in decl.constructors do + for type in ctor.fields do type.checkNames decls + +/-- Validate names, payload types, and all cycles in inline type dependencies. -/ +def checkDeclarations (decls : Declarations) : Except DeclError Unit := do + if let some name := duplicateName (decls.map EnumDecl.name) [] then + throw (.duplicateEnum name) + for decl in decls do checkEnum decls decl + for decl in decls do + let _ ← decls.layout (.enum decl.name) + +/-- Validate actual constructor payloads; type names are checked separately in declarations and signatures. -/ +def Value.wellFormed (decls : Declarations) : Value F Address → Bool + | .field _ => true + | .ptr _ _ => true + | .tuple values => (values.map (Value.wellFormed decls)).all id + | .construct name ctor values => + match decls.findConstructor? name ctor with + | none => false + | some definition => decide (values.map Value.type = definition.fields) && + (values.map (Value.wellFormed decls)).all id +termination_by value => sizeOf value + +def Value.hasType (decls : Declarations) (value : Value F Address) (type : Ty) : Bool := + decide (value.type = type) && value.wellFormed decls + +def Value.WellTyped (decls : Declarations) (value : Value F Address) (type : Ty) : Prop := + value.hasType decls type = true + +end Aiur diff --git a/Aiur/Aiur/EncodingTypes.lean b/Aiur/Aiur/EncodingTypes.lean new file mode 100644 index 000000000..9bcbaab72 --- /dev/null +++ b/Aiur/Aiur/EncodingTypes.lean @@ -0,0 +1,118 @@ +import Aiur.WireBoundary +import Aiur.DeclarationChecks + +namespace Aiur + +set_option maxHeartbeats 1000000 + +private def payloadFormed (decls : Declarations) (fields : List Ty) (args : List (Value F)) : Bool := + decide (args.map Value.type = fields) && (args.map (Value.wellFormed decls)).all id + +/-- Encoding is defined exactly for well-typed constructor data. -/ +theorem Layout.Describes.encode_isSome [NatCast F] [Zero F] {decls : Declarations} + {layout : Layout} {ty : Ty} (described : layout.Describes decls ty) : + ∀ value : Value F, (layout.encode value).isSome = value.hasType decls ty := by + refine Layout.Describes.rec + (motive_1 := fun layout ty _ => ∀ value : Value F, + (layout.encode value).isSome = value.hasType decls ty) + (motive_2 := fun layouts types _ => ∀ values : List (Value F), + (Layout.encodeList layouts values).isSome = payloadFormed decls types values) + (motive_3 := fun layouts ctors _ => ∀ name (args : List (Value F)) start, + (Layout.encodeConstructor layouts name args start).isSome = + match ctors.find? (·.name == name) with + | none => false + | some ctor => payloadFormed decls ctor.fields args) + ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ described + · + intro value + cases value <;> simp [Layout.encode, Value.hasType, Value.type] + · intro target value + cases value <;> simp [Layout.encode, Value.hasType, Value.type] + split <;> simp_all [eq_comm] + · intro layouts types typed ih value + cases value <;> simp [Layout.encode, Value.hasType, Value.type] + rename_i values + simpa [Value.wellFormed, payloadFormed] using ih values + · intro name definition constructors found typed ih value + cases value with + | field | ptr | tuple => simp [Layout.encode, Value.hasType, Value.type] + | construct actual ctor args => + by_cases same : name = actual + · subst actual + have inner := ih ctor args 0 + cases result : Layout.encodeConstructor constructors ctor args 0 with + | none => + cases lookup : definition.constructors.find? (·.name == ctor) <;> + simpa [Layout.encode, result, Value.hasType, Value.type, Value.wellFormed, + Declarations.findConstructor?, found, payloadFormed, lookup] using inner + | some pair => + cases lookup : definition.constructors.find? (·.name == ctor) <;> + simpa [Layout.encode, result, Value.hasType, Value.type, Value.wellFormed, + Declarations.findConstructor?, found, payloadFormed, lookup] using inner + · simp [Layout.encode, same, Value.hasType, Value.type, Ne.symm same] + · intro values + cases values <;> simp [Layout.encodeList, payloadFormed] + · intro layout type layouts types head tail headIH tailIH values + cases values with + | nil => simp [Layout.encodeList, payloadFormed] + | cons value values => + have h := headIH value + have t := tailIH values + cases headRun : layout.encode value <;> cases tailRun : Layout.encodeList layouts values <;> + simp_all [Layout.encodeList, payloadFormed, Value.hasType, Bool.and_assoc] + · intro name args start; simp [Layout.encodeConstructor] + · intro name layout layouts ctors ctor same head tail headIH tailIH requested args start + subst name + by_cases selected : ctor.name = requested + · have inner := headIH (.tuple args) + cases run : layout.encode (.tuple args) <;> + simp_all [Layout.encodeConstructor, List.find?_cons, selected, Value.hasType, + Value.type, Value.wellFormed, payloadFormed] + · simpa [Layout.encodeConstructor, List.find?_cons, selected] using tailIH requested args (start + 1) + +theorem Layout.Describes.encode_wellTyped [NatCast F] [Zero F] {decls : Declarations} + {layout : Layout} {ty : Ty} (described : layout.Describes decls ty) + {value : Value F} {words : List F} (encoded : layout.encode value = some words) : + value.type = ty ∧ value.wellFormed decls = true := by + have formed := described.encode_isSome value + simpa [encoded, Value.hasType] using formed.symm + +theorem Layout.Describes.encode_total [NatCast F] [Zero F] {decls : Declarations} + {layout : Layout} {ty : Ty} (described : layout.Describes decls ty) + {value : Value F} (type : value.type = ty) (formed : value.wellFormed decls = true) : + ∃ words, layout.encode value = some words := by + have some := described.encode_isSome (F := F) value + rw [Value.hasType, type] at some + simp only [decide_true, formed, Bool.and_self] at some + exact Option.isSome_iff_exists.mp some + +/-- Canonical decoding produces declared constructor payload types. -/ +theorem Layout.Describes.decode_wellTyped [NatCast F] [Zero F] [DecidableEq F] + {decls : Declarations} {layout : Layout} {ty : Ty} + (described : layout.Describes decls ty) (unique : layout.NamesUnique) + {words : List F} {value : Value F} (decoded : layout.decode words = some value) : + value.type = ty ∧ value.wellFormed decls = true := + described.encode_wellTyped (Layout.encode_decode unique decoded) + +theorem Declarations.layout_namesUnique {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) {ty : Ty} {layout : Layout} + (expanded : decls.layout ty = .ok layout) : layout.NamesUnique := + (Declarations.layout_describes expanded).namesUnique (checkDeclarations_names checked).2 + +theorem Declarations.layout_tagSafe [NatCast F] [DecidableEq F] {decls : Declarations} + (tags : decls.tagsValid F = true) {ty : Ty} {layout : Layout} + (expanded : decls.layout ty = .ok layout) : layout.TagSafe F := by + apply (Declarations.layout_describes expanded).tagSafe + intro decl member + exact tagsDistinct_zero (((Declarations.tagsValid_spec decls).mp tags) decl member) + +theorem WireValue.decode_of_layout [NatCast F] [Zero F] [DecidableEq F] + {decls : Declarations} (checked : checkDeclarations decls = .ok ()) + {wire : WireValue F} {layout : Layout} (expanded : decls.layout wire.type = .ok layout) + {value : Value F} (decoded : layout.decode wire.words = some value) : + wire.decode decls = some value := by + obtain ⟨typed, formed⟩ := (Declarations.layout_describes expanded).decode_wellTyped + (Declarations.layout_namesUnique checked expanded) decoded + simp [WireValue.decode, expanded, Except.toOption, decoded, Value.hasType, typed, formed] + +end Aiur diff --git a/Aiur/Aiur/Eval.lean b/Aiur/Aiur/Eval.lean new file mode 100644 index 000000000..9ff7ff0d3 --- /dev/null +++ b/Aiur/Aiur/Eval.lean @@ -0,0 +1,73 @@ +import Aiur.Runtime + +namespace Aiur + +abbrev Evaluation (F : Type) := StateT (Heap F) (Except EvalError) + +/-- Eager evaluation threads the allocation heap through operands and internal calls. -/ +def evalExprWith [Field F] [DecidableEq F] (program : Program F) (hints : HintProvider F program.enums) + (locals : Environment F Nat) : Nat → Expr F → Evaluation F (SourceValue F) + | 0, _ => throw .outOfFuel + | fuel + 1, expr => do + match expr with + | .literal value => return .field value + | .var name => + let some (_, value) := locals.find? (·.1 == name) | throw (.unboundVariable name) + return value + | .tuple items => return .tuple (← items.mapM (evalExprWith program hints locals fuel)) + | .construct name ctor args => + return .construct name ctor (← args.mapM (evalExprWith program hints locals fuel)) + | .project value index => liftM (projectValue (← evalExprWith program hints locals fuel value) index) + | .letValue pattern value body => + let value ← evalExprWith program hints locals fuel value + let some bindings := pattern.bindings value | throw .patternMismatch + evalExprWith program hints (bindings ++ locals) fuel body + | .store value => + let value ← evalExprWith program hints locals fuel value + let heap ← get + set (heap ++ [value]) + return .ptr value.type heap.length + | .load pointer => + let pointer ← evalExprWith program hints locals fuel pointer + liftM (loadValue (← get) pointer) + | .hint type key channel => + let key ← evalExprWith program hints locals fuel key + let value ← liftM ((hints channel key type).mapError EvalError.hint) + return value.val.toValue + | .neg value => liftM (evalNeg (← evalExprWith program hints locals fuel value)) + | .assertEq op left right => + liftM (evalAssertEq op (← evalExprWith program hints locals fuel left) (← evalExprWith program hints locals fuel right)) + | .binary op left right => + liftM (evalBinOp op (← evalExprWith program hints locals fuel left) (← evalExprWith program hints locals fuel right)) + | .call name args => + let values ← args.mapM (evalExprWith program hints locals fuel) + let (bindings, body) ← liftM (prepareCall program name values) + evalExprWith program hints bindings fuel body + | .matchValue scrutinee arms => + let value ← evalExprWith program hints locals fuel scrutinee + let some (bindings, body) := selectArm value arms | throw .noMatchingArm + evalExprWith program hints (bindings ++ locals) fuel body + +/-- The original evaluator uses a provider that reports unavailable hints. -/ +abbrev evalExpr [Field F] [DecidableEq F] (program : Program F) + (locals : Environment F Nat) (fuel : Nat) (expr : Expr F) : Evaluation F (SourceValue F) := + evalExprWith program HintProvider.unavailable locals fuel expr + +/-- Entry calls start with an empty heap and require entirely pointer-free argument types. -/ +def run [Field F] [DecidableEq F] (program : Program F) (name : String) + (args : List (SourceValue F)) (fuel : Nat := 1000) + (hints : HintProvider F program.enums := HintProvider.unavailable) : Except EvalError (SourceValue F × Heap F) := do + match typecheck program with + | .error error => throw (.invalidProgram error) + | .ok () => pure () + checkEntry program name + let (bindings, body) ← prepareCall program name args + evalExprWith program hints bindings fuel body [] + +/-- Return the program result; `run` also exposes its heap for inspecting pointer results. -/ +def eval [Field F] [DecidableEq F] (program : Program F) (name : String) + (args : List (SourceValue F)) (fuel : Nat := 1000) + (hints : HintProvider F program.enums := HintProvider.unavailable) : Except EvalError (SourceValue F) := + (run program name args fuel hints).map Prod.fst + +end Aiur diff --git a/Aiur/Aiur/EvalCorrectness.lean b/Aiur/Aiur/EvalCorrectness.lean new file mode 100644 index 000000000..3f77bff01 --- /dev/null +++ b/Aiur/Aiur/EvalCorrectness.lean @@ -0,0 +1,409 @@ +import Aiur.Semantics +import Aiur.Semantics.NoHints + +namespace Aiur + +variable {F : Type} {program : Program F} {hints : HintProvider F program.enums} + +set_option linter.unusedSimpArgs false + +namespace Evaluation + +theorem bind_ok {first : Evaluation F α} {next : α → Evaluation F β} + {before after : Heap F} {result : β} : + (first >>= next) before = .ok (result, after) ↔ + ∃ value middle, first before = .ok (value, middle) ∧ next value middle = .ok (result, after) := by + cases executed : first before with + | error error => simp [StateT.bind, bind, Except.bind, executed] + | ok output => + rcases output with ⟨value, middle⟩ + simp only [StateT.bind, bind, Except.bind, executed, Except.ok.injEq, Prod.mk.injEq] + constructor + · intro h; exact ⟨value, middle, ⟨rfl, rfl⟩, h⟩ + · rintro ⟨_, _, ⟨rfl, rfl⟩, h⟩; exact h + +@[simp] theorem pure_ok {value result : α} {before after : Heap F} : + (pure value : Evaluation F α) before = .ok (result, after) ↔ value = result ∧ before = after := by + simp [pure, StateT.pure, Except.pure] + +theorem lift_ok {computation : Except EvalError α} {value : α} {before after : Heap F} : + (liftM computation : Evaluation F α) before = .ok (value, after) ↔ + computation = .ok value ∧ before = after := by + cases computation with + | error error => + change (Except.error error : Except EvalError _) = .ok (value, after) ↔ _ + simp + | ok result => + change Except.ok (result, before) = (Except.ok (value, after) : Except EvalError _) ↔ _ + simp only [Except.ok.injEq, Prod.mk.injEq] + +@[simp] theorem lift_apply (computation : Except EvalError α) (heap : Heap F) : + (liftM computation : Evaluation F α) heap = computation.map (fun value => (value, heap)) := by + cases computation <;> rfl + +@[simp] theorem get_apply (heap : Heap F) : + (get : Evaluation F (Heap F)) heap = .ok (heap, heap) := rfl + +@[simp] theorem throw_apply (error : EvalError) (heap : Heap F) : + (throw error : Evaluation F α) heap = .error error := rfl + +end Evaluation + +private theorem evalArgs_of_mapM [Field F] [DecidableEq F] + {locals : Environment F Nat} {fuel : Nat} + (sound : ∀ expr before result after, + evalExprWith program hints locals fuel expr before = .ok (result, after) → + EvalExpr program locals expr before result after) + {args : List (Expr F)} {values : List (SourceValue F)} {before after : Heap F} + (executed : args.mapM (evalExprWith program hints locals fuel) before = .ok (values, after)) : + EvalArgs program locals args before values after := by + induction args generalizing before values with + | nil => + obtain ⟨rfl, rfl⟩ := Evaluation.pure_ok.mp executed + exact .nil + | cons head tail ih => + rw [List.mapM_cons] at executed + obtain ⟨value, middle, headRun, rest⟩ := Evaluation.bind_ok.mp executed + obtain ⟨results, last, tailRun, finished⟩ := Evaluation.bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := Evaluation.pure_ok.mp finished + exact .cons (sound head before value middle headRun) (ih tailRun) + +/-- Every successful run, including its final heap, has a fuel-free evaluation proof. -/ +theorem evalExpr_spec [Field F] [DecidableEq F] + {locals : Environment F Nat} {fuel : Nat} {expr : Expr F} + {before after : Heap F} {result : SourceValue F} + (executed : evalExprWith program hints locals fuel expr before = .ok (result, after)) : + EvalExpr program locals expr before result after := by + induction fuel generalizing locals expr before result after with + | zero => simp [evalExprWith] at executed + | succ fuel ih => + cases expr with + | literal value => + obtain ⟨rfl, rfl⟩ := Evaluation.pure_ok.mp executed + exact .literal + | var name => + cases found : locals.find? (·.1 == name) with + | none => simp [evalExprWith, found, Evaluation.throw_apply] at executed + | some binding => + rcases binding with ⟨key, value⟩ + have same : key = name := by simpa using List.find?_some found + subst key + simp only [evalExprWith, found] at executed + obtain ⟨rfl, rfl⟩ := Evaluation.pure_ok.mp executed + exact .var found + | tuple items => + simp only [evalExprWith] at executed + obtain ⟨values, middle, itemsRun, finished⟩ := Evaluation.bind_ok.mp executed + obtain ⟨rfl, rfl⟩ := Evaluation.pure_ok.mp finished + exact .tuple (evalArgs_of_mapM (fun _ _ _ _ h => ih h) itemsRun) + | construct name ctor items => + simp only [evalExprWith] at executed + obtain ⟨values, middle, itemsRun, finished⟩ := Evaluation.bind_ok.mp executed + obtain ⟨rfl, rfl⟩ := Evaluation.pure_ok.mp finished + exact .construct (evalArgs_of_mapM (fun _ _ _ _ h => ih h) itemsRun) + | project value index => + simp only [evalExprWith] at executed + obtain ⟨input, middle, operand, operation⟩ := Evaluation.bind_ok.mp executed + obtain ⟨projected, rfl⟩ := Evaluation.lift_ok.mp operation + exact .project (ih operand) projected + | hint type key channel => + simp only [evalExprWith] at executed + obtain ⟨input, middle, keyRun, rest⟩ := Evaluation.bind_ok.mp executed + obtain ⟨value, last, supplied, finished⟩ := Evaluation.bind_ok.mp rest + obtain ⟨_, rfl⟩ := Evaluation.lift_ok.mp supplied + obtain ⟨rfl, rfl⟩ := Evaluation.pure_ok.mp finished + exact .hint (ih keyRun) value.property + | neg value => + simp only [evalExprWith] at executed + obtain ⟨input, middle, operand, operation⟩ := Evaluation.bind_ok.mp executed + obtain ⟨negated, rfl⟩ := Evaluation.lift_ok.mp operation + exact .neg (ih operand) negated + | store value => + simp only [evalExprWith] at executed + obtain ⟨input, middle, operand, stored⟩ := Evaluation.bind_ok.mp executed + have same : (.ptr input.type middle.length, middle ++ [input]) = (result, after) := by + simpa [bind, StateT.bind, Evaluation.get_apply, set, StateT.set, + pure, StateT.pure, Except.pure, Except.bind] using stored + cases same + exact .store (ih operand) + | load value => + simp only [evalExprWith] at executed + obtain ⟨input, middle, operand, loaded⟩ := Evaluation.bind_ok.mp executed + have lifted : (liftM (loadValue middle input) : Evaluation F _) middle = .ok (result, after) := by + simpa [bind, StateT.bind, Evaluation.get_apply, Except.bind] using loaded + obtain ⟨loadOK, rfl⟩ := Evaluation.lift_ok.mp lifted + exact .load (ih operand) loadOK + | assertEq op left right => + simp only [evalExprWith] at executed + obtain ⟨leftValue, middle, leftRun, rest⟩ := Evaluation.bind_ok.mp executed + obtain ⟨rightValue, last, rightRun, operation⟩ := Evaluation.bind_ok.mp rest + obtain ⟨operationOK, rfl⟩ := Evaluation.lift_ok.mp operation + exact .assertEq (ih leftRun) (ih rightRun) operationOK + | binary op left right => + simp only [evalExprWith] at executed + obtain ⟨leftValue, middle, leftRun, rest⟩ := Evaluation.bind_ok.mp executed + obtain ⟨rightValue, last, rightRun, operation⟩ := Evaluation.bind_ok.mp rest + obtain ⟨operationOK, rfl⟩ := Evaluation.lift_ok.mp operation + exact .binary (ih leftRun) (ih rightRun) operationOK + | letValue pattern value body => + simp only [evalExprWith] at executed + obtain ⟨input, middle, operand, rest⟩ := Evaluation.bind_ok.mp executed + cases matched : pattern.bindings input with + | none => simp [matched] at rest + | some bindings => + exact .letValue (ih operand) matched (ih (by simpa only [matched] using rest)) + | matchValue scrutinee arms => + simp only [evalExprWith] at executed + obtain ⟨input, middle, operand, rest⟩ := Evaluation.bind_ok.mp executed + cases selected : selectArm input arms with + | none => simp [selected] at rest + | some binding => + rcases binding with ⟨bindings, body⟩ + exact .matchValue (ih operand) selected (ih (by simpa only [selected] using rest)) + | call name args => + simp only [evalExprWith] at executed + obtain ⟨values, middle, arguments, rest⟩ := Evaluation.bind_ok.mp executed + obtain ⟨⟨bindings, body⟩, last, prepared, called⟩ := Evaluation.bind_ok.mp rest + obtain ⟨prepareOK, rfl⟩ := Evaluation.lift_ok.mp prepared + exact .call (evalArgs_of_mapM (fun _ _ _ _ h => ih h) arguments) (.intro prepareOK (ih called)) + +/-- Evaluations in the hint-free fragment run with every provider and enough fuel. -/ +theorem EvalExpr.eventually_runs [Field F] [DecidableEq F] + {locals : Environment F Nat} {expr : Expr F} {result : SourceValue F} {before after : Heap F} + (evaluates : EvalExpr program locals expr before result after) (safe : program.noHints = true) : + expr.noHints = true → + ∃ minimum, ∀ fuel, minimum ≤ fuel → evalExprWith program hints locals fuel expr before = .ok (result, after) := by + induction evaluates using EvalExpr.rec + (motive_2 := fun locals exprs before values after _ => + (∀ expr ∈ exprs, expr.noHints = true) → ∃ minimum, ∀ fuel, minimum ≤ fuel → exprs.mapM (evalExprWith program hints locals fuel) before = .ok (values, after)) + (motive_3 := fun name args before result after _ => + ∃ minimum, ∀ fuel, minimum ≤ fuel → ∃ locals expr, + prepareCall program name args = .ok (locals, expr) ∧ + evalExprWith program hints locals fuel expr before = .ok (result, after)) with + | literal => + intro _ + refine ⟨1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => rfl + | var lookup => + intro _ + refine ⟨1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => simp [evalExprWith, lookup, pure, StateT.pure, Except.pure] + | tuple _ ih | construct _ ih => + intro exprSafe + obtain ⟨minimum, runs⟩ := ih (by simpa [Expr.noHints] using exprSafe) + refine ⟨minimum + 1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => simp [evalExprWith, runs fuel (by omega), bind, StateT.bind, Evaluation.lift_apply, Except.map, Evaluation.get_apply, pure, StateT.pure, Except.bind, Except.pure] + | project _ projected ih | neg _ projected ih | load _ projected ih => + intro exprSafe + obtain ⟨minimum, runs⟩ := ih (by simpa [Expr.noHints] using exprSafe) + refine ⟨minimum + 1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => simp [evalExprWith, runs fuel (by omega), projected, bind, StateT.bind, Except.bind, Evaluation.lift_apply, Except.map, Evaluation.get_apply] + | store _ ih => + intro exprSafe + obtain ⟨minimum, runs⟩ := ih (by simpa [Expr.noHints] using exprSafe) + refine ⟨minimum + 1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => + simp [evalExprWith, runs fuel (by omega), bind, StateT.bind, Except.bind, + Evaluation.get_apply, set, StateT.set, pure, StateT.pure, Except.pure] + | hint => intro impossible; simp [Expr.noHints] at impossible + | assertEq _ _ operation leftIH rightIH => + intro exprSafe + simp only [Expr.noHints, Bool.and_eq_true] at exprSafe + have safeParts := exprSafe + obtain ⟨leftMinimum, leftRuns⟩ := leftIH safeParts.1 + obtain ⟨rightMinimum, rightRuns⟩ := rightIH safeParts.2 + refine ⟨max leftMinimum rightMinimum + 1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => + simp [evalExprWith, leftRuns fuel (by omega), rightRuns fuel (by omega), + operation, bind, StateT.bind, Except.bind, Evaluation.lift_apply, Except.map, Evaluation.get_apply] + | binary _ _ operation leftIH rightIH => + intro exprSafe + simp only [Expr.noHints, Bool.and_eq_true] at exprSafe + have safeParts := exprSafe + obtain ⟨leftMinimum, leftRuns⟩ := leftIH safeParts.1 + obtain ⟨rightMinimum, rightRuns⟩ := rightIH safeParts.2 + refine ⟨max leftMinimum rightMinimum + 1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => + simp [evalExprWith, leftRuns fuel (by omega), rightRuns fuel (by omega), + operation, bind, StateT.bind, Except.bind, Evaluation.lift_apply, Except.map, Evaluation.get_apply] + | letValue _ matched _ valueIH bodyIH => + intro exprSafe + simp only [Expr.noHints, Bool.and_eq_true] at exprSafe + have safeParts := exprSafe + obtain ⟨valueMinimum, valueRuns⟩ := valueIH safeParts.1 + obtain ⟨bodyMinimum, bodyRuns⟩ := bodyIH safeParts.2 + refine ⟨max valueMinimum bodyMinimum + 1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => + simpa [evalExprWith, valueRuns fuel (by omega), matched, bind, StateT.bind, Except.bind, Evaluation.lift_apply, Except.map, Evaluation.get_apply] + using bodyRuns fuel (by omega) + | matchValue _ matched _ valueIH bodyIH => + intro exprSafe + simp only [Expr.noHints, Bool.and_eq_true] at exprSafe + have safeParts := exprSafe + obtain ⟨valueMinimum, valueRuns⟩ := valueIH safeParts.1 + obtain ⟨bodyMinimum, bodyRuns⟩ := bodyIH (selectArm_noHints (by simpa using safeParts.2) matched) + refine ⟨max valueMinimum bodyMinimum + 1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => + simpa [evalExprWith, valueRuns fuel (by omega), matched, bind, StateT.bind, Except.bind, Evaluation.lift_apply, Except.map, Evaluation.get_apply] + using bodyRuns fuel (by omega) + | call _ _ argsIH callIH => + intro exprSafe + obtain ⟨argsMinimum, argsRuns⟩ := argsIH (by simpa [Expr.noHints] using exprSafe) + obtain ⟨callMinimum, callRuns⟩ := callIH + refine ⟨max argsMinimum callMinimum + 1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => + obtain ⟨locals, expr, prepared, bodyRun⟩ := callRuns fuel (by omega) + simpa [evalExprWith, argsRuns fuel (by omega), prepared, bind, StateT.bind, Except.bind, Evaluation.lift_apply, Except.map, Evaluation.get_apply] using bodyRun + | nil => exact ⟨0, fun _ _ => rfl⟩ + | cons _ _ headIH tailIH => + rename_i exprSafe + obtain ⟨headMinimum, headRuns⟩ := headIH (exprSafe _ (by simp)) + obtain ⟨tailMinimum, tailRuns⟩ := tailIH (fun e h => exprSafe e (by simp [h])) + refine ⟨max headMinimum tailMinimum, ?_⟩ + intro fuel enough + simp [List.mapM_cons, headRuns fuel (by omega), tailRuns fuel (by omega), + bind, StateT.bind, Evaluation.lift_apply, Except.map, Evaluation.get_apply, pure, StateT.pure, Except.bind, Except.pure] + | intro prepared _ bodyIH => + obtain ⟨minimum, runs⟩ := bodyIH (prepareCall_noHints safe prepared) + exact ⟨minimum, fun fuel enough => ⟨_, _, prepared, runs fuel enough⟩⟩ + + + +theorem run_eq_ok_iff [Field F] [DecidableEq F] + {name : String} {args : List (SourceValue F)} {fuel : Nat} + {result : SourceValue F} {heap : Heap F} : + run program name args fuel hints = .ok (result, heap) ↔ + typecheck program = .ok () ∧ checkEntry program name = .ok () ∧ ∃ locals expr, + prepareCall program name args = .ok (locals, expr) ∧ + evalExprWith program hints locals fuel expr [] = .ok (result, heap) := by + cases checked : typecheck program with + | error error => simp [run, checked, bind, Except.bind] + | ok finished => + cases finished + cases entry : checkEntry program name with + | error error => simp [run, checked, entry, bind, Except.bind, pure, Except.pure] + | ok finished => + cases finished + cases prepared : prepareCall program name args with + | error error => simp [run, checked, entry, prepared, bind, Except.bind, pure, Except.pure] + | ok binding => + rcases binding with ⟨locals, expr⟩ + simp only [run, checked, entry, prepared, bind, pure, Except.bind, Except.pure, + Except.ok.injEq, Prod.mk.injEq, true_and] + constructor + · intro executed; exact ⟨locals, expr, ⟨rfl, rfl⟩, executed⟩ + · rintro ⟨_, _, ⟨rfl, rfl⟩, executed⟩; exact executed + +theorem eval_eq_ok_iff [Field F] [DecidableEq F] + {name : String} {args : List (SourceValue F)} {fuel : Nat} {result : SourceValue F} : + eval program name args fuel hints = .ok result ↔ ∃ heap, run program name args fuel hints = .ok (result, heap) := by + cases executed : run program name args fuel hints with + | error error => simp [eval, executed, Except.map] + | ok pair => cases pair; simp [eval, executed, Except.map] + +/-- Successful execution agrees with the allocation-aware evaluation predicate. -/ +theorem eval_spec [Field F] [DecidableEq F] + {name : String} {args : List (SourceValue F)} {fuel : Nat} {result : SourceValue F} + (executed : eval program name args fuel hints = .ok result) : EvalCall program name args result := by + obtain ⟨heap, executed⟩ := eval_eq_ok_iff.mp executed + obtain ⟨_, entry, locals, expr, prepared, body⟩ := run_eq_ok_iff.mp executed + exact ⟨entry, heap, .intro prepared (evalExpr_spec body)⟩ + +theorem EvalCall.eventually_eval [Field F] [DecidableEq F] + (checked : typecheck program = .ok ()) {name : String} + {args : List (SourceValue F)} {result : SourceValue F} (evaluates : EvalCall program name args result) + (safe : program.noHints = true) : + ∃ minimum, ∀ fuel, minimum ≤ fuel → eval program name args fuel hints = .ok result := by + obtain ⟨entry, heap, evaluated⟩ := evaluates + cases evaluated with + | intro prepared body => + obtain ⟨minimum, runs⟩ := body.eventually_runs safe (prepareCall_noHints safe prepared) + exact ⟨minimum, fun fuel enough => eval_eq_ok_iff.mpr + ⟨heap, run_eq_ok_iff.mpr ⟨checked, entry, _, _, prepared, runs fuel enough⟩⟩⟩ + +theorem eval_complete [Field F] [DecidableEq F] + (checked : typecheck program = .ok ()) {name : String} + {args : List (SourceValue F)} {result : SourceValue F} (evaluates : EvalCall program name args result) + (safe : program.noHints = true) : + ∃ fuel, eval program name args fuel hints = .ok result := by + obtain ⟨minimum, runs⟩ := evaluates.eventually_eval checked safe + exact ⟨minimum, runs minimum (Nat.le_refl _)⟩ + +theorem exists_eval_iff [Field F] [DecidableEq F] + {name : String} {args : List (SourceValue F)} {result : SourceValue F} + (safe : program.noHints = true) : + (∃ fuel, eval program name args fuel hints = .ok result) ↔ + typecheck program = .ok () ∧ EvalCall program name args result := by + constructor + · rintro ⟨fuel, executed⟩ + obtain ⟨heap, ran⟩ := eval_eq_ok_iff.mp executed + exact ⟨(run_eq_ok_iff.mp ran).1, eval_spec executed⟩ + · rintro ⟨checked, evaluated⟩ + exact eval_complete checked evaluated safe + +theorem EvalExpr.deterministic [Field F] [DecidableEq F] + {locals : Environment F Nat} {expr : Expr F} {before leftHeap rightHeap : Heap F} + {left right : SourceValue F} + (first : EvalExpr program locals expr before left leftHeap) + (second : EvalExpr program locals expr before right rightHeap) + (safe : program.noHints = true) (exprSafe : expr.noHints = true) : + left = right ∧ leftHeap = rightHeap := by + obtain ⟨a, leftRuns⟩ := first.eventually_runs (hints := HintProvider.unavailable) safe exprSafe + obtain ⟨b, rightRuns⟩ := second.eventually_runs (hints := HintProvider.unavailable) safe exprSafe + exact Prod.mk.inj (Except.ok.inj ((leftRuns (max a b) (Nat.le_max_left _ _)).symm.trans + (rightRuns (max a b) (Nat.le_max_right _ _)))) + +theorem EvalFn.deterministic [Field F] [DecidableEq F] + {name : String} {args : List (SourceValue F)} {before leftHeap rightHeap : Heap F} + {left right : SourceValue F} + (first : EvalFn program name args before left leftHeap) + (second : EvalFn program name args before right rightHeap) + (safe : program.noHints = true) : + left = right ∧ leftHeap = rightHeap := by + cases first with + | intro prepared body => + cases second with + | intro otherPrepared otherBody => + cases Except.ok.inj (prepared.symm.trans otherPrepared) + exact body.deterministic otherBody safe (prepareCall_noHints safe prepared) + +theorem EvalCall.deterministic [Field F] [DecidableEq F] + {name : String} {args : List (SourceValue F)} {left right : SourceValue F} + (first : EvalCall program name args left) (second : EvalCall program name args right) + (safe : program.noHints = true) : + left = right := by + obtain ⟨_, _, first⟩ := first + obtain ⟨_, _, second⟩ := second + exact (first.deterministic second safe).1 + +end Aiur diff --git a/Aiur/Aiur/ExceptFacts.lean b/Aiur/Aiur/ExceptFacts.lean new file mode 100644 index 000000000..785c59a31 --- /dev/null +++ b/Aiur/Aiur/ExceptFacts.lean @@ -0,0 +1,30 @@ +import Mathlib.Data.List.Basic + +namespace Aiur + +theorem except_bind_ok {first : Except ε α} {next : α → Except ε β} {result : β} : + (first >>= next) = .ok result ↔ ∃ value, first = .ok value ∧ next value = .ok result := by + cases first <;> simp [bind, Except.bind] + +theorem forIn_ok {action : α → Except ε Unit} {items : List α} + (checked : (do for item in items do action item : Except ε Unit) = .ok ()) : + ∀ item ∈ items, action item = .ok () := by + induction items with + | nil => simp + | cons item items ih => + cases first : action item with + | error error => simp [List.forIn_cons, first, bind, Except.bind] at checked + | ok finished => + cases finished + simp only [List.forIn_cons, first, bind, Except.bind, pure, Except.pure] at checked + intro value member + rcases List.mem_cons.mp member with rfl | member + · exact first + · exact ih checked value member + +@[simp] theorem except_pure_ok {value result : α} : + (pure value : Except ε α) = .ok result ↔ value = result := by simp [pure, Except.pure] + +@[simp] theorem except_throw_eq (error : ε) : (throw error : Except ε α) = .error error := rfl + +end Aiur diff --git a/Aiur/Aiur/Execution.lean b/Aiur/Aiur/Execution.lean new file mode 100644 index 000000000..4fb6bbcca --- /dev/null +++ b/Aiur/Aiur/Execution.lean @@ -0,0 +1,5 @@ +import Aiur.Execution.Compile +import Aiur.Execution.Interface +import Aiur.Execution.Hints +import Aiur.Execution.Encode +import Aiur.Execution.FFI diff --git a/Aiur/Aiur/Execution/Bytecode.lean b/Aiur/Aiur/Execution/Bytecode.lean new file mode 100644 index 000000000..23f757542 --- /dev/null +++ b/Aiur/Aiur/Execution/Bytecode.lean @@ -0,0 +1,59 @@ +import Aiur.Wire + +namespace Aiur.Execution + +abbrev Register := Nat + +/-- Execution instructions, independent of circuit columns and constraints. +Aggregate values occupy statically known register lists. -/ +inductive Instruction (F : Type) where + | literal (dest : Register) (value : F) + | copy (dest source : List Register) + | neg (dest source : Register) + | binary (dest : Register) (op : BinOp) (left right : Register) + | guard (tests : List (Register × F)) (message : String) + | branch (tests : List (Register × F)) (otherwise : Nat) + | jump (target : Nat) + | call (function : Nat) (args dest : List Register) + | store (type : Ty) (value : List Register) (dest : Register) + | load (type : Ty) (pointer : Register) (dest : List Register) + | hint (type keyType : Ty) (key dest : List Register) (channel : String := "") + | assertEq (left right : List Register) (assertion : Assertion) + | ret (value : List Register) + | fail (message : String) + deriving Repr, BEq + +structure Function (F : Type) where + name : String + params : List Ty + result : Ty + registers : Nat + code : Array (Instruction F) + deriving Repr, BEq + +/-- Callable IDs enumerate functions first, then maps. Table IDs preserve +sharing of an input trace across multiple maps. -/ +structure Map where + name : String + params : List Ty + result : Ty + input : Nat + output : Nat + deriving Repr, BEq + +structure Table (F : Type) where + name : String + type : Ty + rows : List (List F) + deriving Repr, BEq + +structure Bytecode (F : Type) where + functions : List (Function F) + enums : Declarations + tables : List (Table F) + maps : List Map + /-- Host-selected public spelling and resolved callable ID. -/ + entries : List (String × Nat) + deriving Repr, BEq + +end Aiur.Execution diff --git a/Aiur/Aiur/Execution/Compile.lean b/Aiur/Aiur/Execution/Compile.lean new file mode 100644 index 000000000..acc69f656 --- /dev/null +++ b/Aiur/Aiur/Execution/Compile.lean @@ -0,0 +1,243 @@ +import Aiur.Execution.Bytecode +import Aiur.Runtime +import Aiur.Generic.Specialize +import Aiur.Generic.Circuit +import Aiur.Inlining.Program +import Aiur.Modules.Link + +namespace Aiur.Execution + +namespace Compiler + +abbrev Value := WireValue Register +abbrev Locals := List (String × Value) + +structure State (F : Type) where + registers : Nat := 0 + code : Array (Instruction F) := #[] + +abbrev Build (F : Type) := StateT (State F) (Except String) + +def need (value : Option α) (message : String) : Except String α := + match value with | some x => .ok x | none => .error message + +def emit (instruction : Instruction F) : Build F Nat := do + let state ← get + set { state with code := state.code.push instruction } + return state.code.size + +def patch (pc : Nat) (instruction : Instruction F) : Build F Unit := do + let state ← get + if pc ≥ state.code.size then throw "invalid bytecode patch" + set { state with code := state.code.set! pc instruction } + +def fresh (type : Ty) (decls : Declarations) : Build F Value := do + let layout ← liftM ((decls.layout type).mapError reprStr) + let start := (← get).registers + modify fun state => { state with registers := start + layout.width } + return ⟨type, (List.range layout.width).map (start + ·)⟩ + +def scalar (value : Value) : Except String Register := + match value.words with + | [word] => return word + | _ => throw "expected one execution register" + +def split (decls : Declarations) : List Ty → List Register → Except String (List Value) + | [], [] => return [] + | type :: types, words => do + let layout ← (decls.layout type).mapError reprStr + if words.length < layout.width then throw "short execution value" + return ⟨type, words.take layout.width⟩ :: (← split decls types (words.drop layout.width)) + | [], _ :: _ => throw "long execution value" + +mutual + def pattern [NatCast F] (decls : Declarations) (pat : Pattern F) (value : Value) : + Except String (List (Register × F) × Locals) := do + match pat with + | .wildcard => return ([], []) + | .bind name => return ([], [(name, value)]) + | .literal constant => return ([(← scalar value, constant)], []) + | .tuple items => + let .tuple types := value.type | throw "tuple pattern on non-tuple" + patterns decls items (← split decls types value.words) + | .construct name ctor args => + let some decl := decls.findEnum? name | throw s!"unknown enum {name}" + let some constructor := decls.findConstructor? name ctor | throw s!"unknown constructor {ctor}" + let layout ← (decls.layout (.tuple constructor.fields)).mapError reprStr + let tagged := decl.constructors.length > 1 + let tests := if tagged then + [(value.words.headD 0, (decl.constructors.findIdx (·.name == ctor) : F))] + else [] + let payload := (value.words.drop (if tagged then 1 else 0)).take layout.width + let (more, bindings) ← patterns decls args (← split decls constructor.fields payload) + return (tests ++ more, bindings) + termination_by sizeOf pat + + def patterns [NatCast F] (decls : Declarations) (pats : List (Pattern F)) + (values : List Value) : Except String (List (Register × F) × Locals) := do + match pats, values with + | [], [] => return ([], []) + | pat :: pats, value :: values => + let (tests, bindings) ← pattern decls pat value + let (rest, locals) ← patterns decls pats values + return (tests ++ rest, bindings ++ locals) + | _, _ => throw "execution pattern arity mismatch" + termination_by sizeOf pats +end + +def callable (program : Aiur.Program F) (name : String) : Except String Nat := do + let names := program.functions.map (·.name) ++ program.maps.map (·.name) + if !names.contains name then throw s!"unknown callable {name}" + return names.idxOf name + +mutual + def expression [NatCast F] [Zero F] (program : Aiur.Program F) (caller : String) + (locals : Locals) (expr : Expr F) : Build F Value := do + let type ← liftM ((inferType program caller (locals.map fun (n, v) => (n, v.type)) expr).mapError reprStr) + match expr with + | .var name => + let some (_, value) := locals.find? (·.1 == name) | throw s!"unbound register {name}" + return value + | .literal constant => + let value ← fresh .field program.enums + let _ ← emit (.literal (← liftM (scalar value)) constant) + return value + | .tuple items => return WireValue.tuple (← expressions program caller locals items) + | .construct name ctor args => + let values ← expressions program caller locals args + let some decl := program.enums.findEnum? name | throw s!"unknown enum {name}" + let result ← fresh type program.enums + let tagged := decl.constructors.length > 1 + let payload := values.flatMap (·.words) + if tagged then + let _ ← emit (.literal (← liftM (need result.words.head? "missing enum tag")) + (decl.constructors.findIdx (·.name == ctor) : F)) + let dest := result.words.drop (if tagged then 1 else 0) + let _ ← emit (.copy (dest.take payload.length) payload) + for reg in dest.drop payload.length do let _ ← emit (.literal reg 0) + return result + | .project expr index => + let value ← expression program caller locals expr + let .tuple types := value.type | throw "projection on non-tuple" + let values ← liftM (split program.enums types value.words) + liftM (need values[index]? "projection out of bounds") + | .letValue pat value body => + let value ← expression program caller locals value + let (tests, bindings) ← liftM (pattern program.enums pat value) + let _ ← emit (.guard tests "let pattern mismatch") + expression program caller (bindings ++ locals) body + | .neg expr => + let value ← expression program caller locals expr + let result ← fresh type program.enums + let _ ← emit (.neg (← liftM (scalar result)) (← liftM (scalar value))) + return result + | .binary op left right => + let left ← expression program caller locals left + let right ← expression program caller locals right + let result ← fresh type program.enums + let _ ← emit (.binary (← liftM (scalar result)) op (← liftM (scalar left)) (← liftM (scalar right))) + return result + | .assertEq message left right => + let left ← expression program caller locals left + let right ← expression program caller locals right + let _ ← emit (.assertEq left.words right.words message) + return ⟨.tuple [], []⟩ + | .call name args => + let values ← expressions program caller locals args + let result ← fresh type program.enums + let _ ← emit (.call (← liftM (callable program name)) (values.flatMap (·.words)) result.words) + return result + | .store expr => + let value ← expression program caller locals expr + let result ← fresh type program.enums + let _ ← emit (.store value.type value.words (← liftM (scalar result))) + return result + | .load expr => + let pointer ← expression program caller locals expr + let result ← fresh type program.enums + let _ ← emit (.load type (← liftM (scalar pointer)) result.words) + return result + | .hint type key channel => + let key ← expression program caller locals key + let result ← fresh type program.enums + let _ ← emit (.hint type key.type key.words result.words channel) + return result + | .matchValue scrutinee arms => + let value ← expression program caller locals scrutinee + let result ← fresh type program.enums + let exits ← branches program caller locals value result arms + let _ ← emit (.fail "no matching arm") + let target := (← get).code.size + for exit in exits do patch exit (.jump target) + return result + termination_by sizeOf expr + + def expressions [NatCast F] [Zero F] (program : Aiur.Program F) (caller : String) + (locals : Locals) (items : List (Expr F)) : Build F (List Value) := do + match items with + | [] => return [] + | item :: items => + let value ← expression program caller locals item + return value :: (← expressions program caller locals items) + termination_by sizeOf items + + def branches [NatCast F] [Zero F] (program : Aiur.Program F) (caller : String) + (locals : Locals) (value result : Value) (arms : List (Pattern F × Expr F)) : Build F (List Nat) := do + match arms with + | [] => return [] + | (pat, body) :: arms => + let (tests, bindings) ← liftM (pattern program.enums pat value) + let branch ← emit (.branch tests 0) + let output ← expression program caller (bindings ++ locals) body + let _ ← emit (.copy result.words output.words) + let exit ← emit (.jump 0) + patch branch (.branch tests (← get).code.size) + return exit :: (← branches program caller locals value result arms) + termination_by sizeOf arms +end + +def function [NatCast F] [Zero F] (program : Aiur.Program F) (fn : Aiur.Function F) : + Except String (Function F) := do + let build : Build F Unit := do + let inputs ← fn.params.mapM fun (name, type) => return (name, ← fresh type program.enums) + let result ← expression program fn.name inputs fn.body + let _ ← emit (.ret result.words) + let (_, state) ← build.run {} + return ⟨fn.name, fn.params.map Prod.snd, fn.result, state.registers, state.code⟩ + +end Compiler + +/-- Executor compilation changes neither the source predicate nor the circuit +compiler. No circuit data or circuit layout is exported here. -/ +def compile [NatCast F] [Zero F] [DecidableEq F] (program : Aiur.Program F) + (entries : List String) : Except String (Bytecode F) := do + let _ ← (typecheck program).mapError reprStr + if !program.enums.tagsValid F then throw "enum tags collide in the execution field" + for entry in entries do let _ ← (checkEntry program entry).mapError reprStr + let functions ← program.functions.mapM (Compiler.function program) + let tables ← program.tables.mapM fun table => do + let layout ← (program.enums.layout table.rowType).mapError reprStr + let rows ← table.rows.mapM fun row => + Compiler.need (layout.encode row.toValue) s!"cannot encode table {table.name}" + return ⟨table.name, table.rowType, rows⟩ + let tableNames := program.tables.map (·.name) + let maps := program.maps.map fun map => + ⟨map.name, map.params.map Prod.snd, map.result, tableNames.idxOf map.input, tableNames.idxOf map.output⟩ + let entries ← entries.mapM fun name => return (name, ← Compiler.callable program name) + return ⟨functions, program.enums, tables, maps, entries⟩ + +end Aiur.Execution + +namespace Aiur.Modules + +/-- Reuse source preparation, specialization and mandatory inlining. -/ +def Prepared.compileExecution [NatCast F] [Zero F] [DecidableEq F] + (prepared : Prepared (program : Program F)) : Except String (Execution.Bytecode F) := do + let specialized ← Generic.specialize prepared.environment.source prepared.entries + let inlined ← Inlining.prepare specialized.program specialized.inlineNames prepared.entries + let code ← Execution.compile inlined.program prepared.entries + let entries ← prepared.selections.mapM fun entry => do + return (entry.external, ← Execution.Compiler.callable inlined.program entry.resolved.name) + return { code with entries } + +end Aiur.Modules diff --git a/Aiur/Aiur/Execution/Data.lean b/Aiur/Aiur/Execution/Data.lean new file mode 100644 index 000000000..4f9509bf2 --- /dev/null +++ b/Aiur/Aiur/Execution/Data.lean @@ -0,0 +1,77 @@ +import Aiur.Generic.Aliases +import Aiur.Wire + +namespace Aiur.Execution + +/-- Structured, address-free data supplied by the host. Array element types +are explicit so empty arrays still carry their complete type. Nominal values +use source types (including generic arguments), never layout tags or offsets. -/ +inductive DataValue (F : Type) where + | field (value : F) + | tuple (items : List (DataValue F)) + | array (element : Generic.Ty) (items : List (DataValue F)) + | record (type : Generic.Ty) (fields : List (String × DataValue F)) + | construct (type : Generic.Ty) (constructor : String) (args : List (DataValue F)) + deriving Repr, BEq + +instance [OfNat F n] : OfNat (DataValue F) n := ⟨.field (OfNat.ofNat n)⟩ + +def DataValue.type : DataValue F → Generic.Ty + | .field _ => .field + | .tuple items => .tuple (items.map DataValue.type) + | .array element items => .array element items.length + | .record type _ | .construct type _ _ => type +termination_by value => sizeOf value + +def DataValue.map (f : F → G) : DataValue F → DataValue G + | .field x => .field (f x) + | .tuple items => .tuple (items.map (DataValue.map f)) + | .array element items => .array element (items.map (DataValue.map f)) + | .record type fields => .record type (fields.map fun entry => (entry.1, entry.2.map f)) + | .construct type ctor args => .construct type ctor (args.map (DataValue.map f)) +termination_by value => sizeOf value +decreasing_by + all_goals simp_wf + all_goals first | omega | have := List.sizeOf_lt_of_mem ‹_ ∈ _› + all_goals first | omega | cases ‹String × DataValue F›; simp_all only [Prod.mk.sizeOf_spec]; omega + +/-- Retained only on the Lean side, for preparing structured execution data. +The Rust package still contains just concrete layouts and flat values. -/ +structure DataTypes where + enums : List Generic.EnumDecl := [] + structs : List Generic.StructDecl := [] + aliases : List Generic.AliasDecl := [] + opaqueNames : List String := [] + deriving Repr, BEq + +def DataTypes.ofSource (p : Generic.Program F) (opaqueNames : List String) : DataTypes := + ⟨p.enums, p.structs, p.aliases, opaqueNames⟩ + +def DataTypes.program (types : DataTypes) : Generic.Program Unit := + { functions := [], enums := types.enums, structs := types.structs, aliases := types.aliases } + +/-- Normalize transparent aliases and nominal arguments without erasing array +shapes or struct identity. The prepared program already checked alias cycles. -/ +def DataTypes.resolve (types : DataTypes) : Nat → Generic.Ty → Except String Generic.Ty + | 0, _ => throw "execution data type depth exceeded" + | fuel + 1, type => do + match type with + | .field => return .field + | .param _ => throw "execution data requires a concrete type" + | .ptr _ => throw "execution data cannot contain pointers" + | .tuple items => return .tuple (← items.mapM (types.resolve fuel)) + | .array element length => + Generic.checkArrayLength length + return .array (← types.resolve fuel element) length + | .named name args => + if types.opaqueNames.contains name then throw s!"execution data cannot contain opaque type {name}" + let args ← args.mapM (types.resolve fuel) + if let some decl := types.aliases.find? (·.name == name) then + let env ← Generic.arguments decl.typeParams args + types.resolve fuel (decl.target.subst env) + else + let some decl := types.program.findEnum? name | throw s!"unknown execution data type {name}" + let _ ← Generic.arguments decl.typeParams args + return .named name args + +end Aiur.Execution diff --git a/Aiur/Aiur/Execution/Encode.lean b/Aiur/Aiur/Execution/Encode.lean new file mode 100644 index 000000000..1d8785b76 --- /dev/null +++ b/Aiur/Aiur/Execution/Encode.lean @@ -0,0 +1,105 @@ +import Aiur.Execution.Hints +import Lean + +namespace Aiur.Execution +open Lean + +private def tagged (key tag : String) (fields : List (String × Json) := []) : Json := + Json.mkObj ((key, Lean.toJson tag) :: fields) + +def typeJson : Ty → Json + | .field => tagged "kind" "field" + | .ptr type => tagged "kind" "ptr" [("target", typeJson type)] + | .tuple types => tagged "kind" "tuple" [("items", Lean.toJson (types.map typeJson))] + | .enum name => tagged "kind" "enum" [("name", Lean.toJson name)] +termination_by type => sizeOf type + +def ioTypeJson : IOType → Json + | .field => tagged "kind" "field" + | .tuple items => tagged "kind" "tuple" [("items", Lean.toJson (items.map ioTypeJson))] + | .array element length => tagged "kind" "array" [("element", ioTypeJson element), ("length", Lean.toJson length)] + | .record name fields => tagged "kind" "struct" [("name", Lean.toJson name), + ("fields", Lean.toJson (fields.map fun entry => Lean.toJson [Lean.toJson entry.1, ioTypeJson entry.2]))] + | .enum name constructors => tagged "kind" "enum" [("name", Lean.toJson name), + ("constructors", Lean.toJson (constructors.map fun entry => Lean.toJson [Lean.toJson entry.1, Lean.toJson (entry.2.map ioTypeJson)]))] +termination_by type => sizeOf type +decreasing_by + all_goals simp_wf + all_goals + first + | omega + | have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + omega + | have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + cases ‹String × IOType› + simp_all only [Prod.mk.sizeOf_spec] + omega + | have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + have hp : sizeOf entry < sizeOf constructors := List.sizeOf_lt_of_mem (by assumption) + cases entry + simp_all only [Prod.mk.sizeOf_spec] + omega + +def instructionJson (encode : F → Nat) : Instruction F → Json + | .literal dest value => tagged "op" "literal" [("dest", Lean.toJson dest), ("value", Lean.toJson (encode value))] + | .copy dest source => tagged "op" "copy" [("dest", Lean.toJson dest), ("source", Lean.toJson source)] + | .neg dest source => tagged "op" "neg" [("dest", Lean.toJson dest), ("source", Lean.toJson source)] + | .binary dest op left right => tagged "op" "binary" [("dest", Lean.toJson dest), + ("operator", Lean.toJson (match op with | .add => "add" | .sub => "sub" | .mul => "mul" | .div => "div")), + ("left", Lean.toJson left), ("right", Lean.toJson right)] + | .guard tests message => tagged "op" "guard" + [("tests", Lean.toJson (tests.map fun (r,v) => [r, encode v])), ("message", Lean.toJson message)] + | .branch tests target => tagged "op" "branch" + [("tests", Lean.toJson (tests.map fun (r,v) => [r, encode v])), ("otherwise", Lean.toJson target)] + | .jump target => tagged "op" "jump" [("target", Lean.toJson target)] + | .call function args dest => tagged "op" "call" + [("function", Lean.toJson function), ("args", Lean.toJson args), ("dest", Lean.toJson dest)] + | .store type value dest => tagged "op" "store" + [("type", typeJson type), ("value", Lean.toJson value), ("dest", Lean.toJson dest)] + | .load type pointer dest => tagged "op" "load" + [("type", typeJson type), ("pointer", Lean.toJson pointer), ("dest", Lean.toJson dest)] + | .hint type keyType key dest channel => tagged "op" "hint" + [("channel", Lean.toJson channel), ("type", typeJson type), ("key_type", typeJson keyType), ("key", Lean.toJson key), ("dest", Lean.toJson dest)] + | .assertEq left right assertion => tagged "op" "assert_eq" + [("left", Lean.toJson left), ("right", Lean.toJson right), + ("message", Lean.toJson assertion.message), ("runtime_check", Lean.toJson assertion.runtimeCheck)] + | .ret value => tagged "op" "ret" [("value", Lean.toJson value)] + | .fail message => tagged "op" "fail" [("message", Lean.toJson message)] + +def FlatHintEntry.toJson (encode : F → Nat) (entry : FlatHintEntry F) : Json := + Json.mkObj [("channel", Lean.toJson entry.channel), ("type", typeJson entry.type), ("key_type", typeJson entry.keyType), + ("key", Lean.toJson (entry.key.map encode)), ("output", Lean.toJson (entry.output.map encode))] + +/-- Large witness datasets must not rely on specialization of Array.map's +generic monadic implementation. Build the JSON array with a direct fold. -/ +def hintsJson (encode : F → Nat) (entries : Array (FlatHintEntry F)) : Json := + .arr (entries.foldl (fun out entry => out.push (entry.toJson encode)) #[]) + +/-- Versioned data transported by the FFI. The initial Rust field backend +supports primes fitting UInt64; the bytecode compiler itself is field-generic. -/ +def Export.toJson (exported : Export F) (modulus : Nat) (encode : F → Nat) : Except String Json := do + if modulus < 2 || modulus ≥ 2^64 then throw "execution requires a prime modulus fitting UInt64" + let code := exported.bytecode + let entries ← code.entries.mapM fun (name, function) => do + let some interface := exported.interfaces.find? (·.name == name) + | throw s!"missing entry IO interface {name}" + return Json.mkObj [("name", Lean.toJson name), ("function", Lean.toJson function), + ("inputs", Lean.toJson (interface.inputs.map ioTypeJson)), + ("output", (interface.output.map ioTypeJson).getD Json.null)] + return Json.mkObj [ + ("version", Lean.toJson (2 : Nat)), ("modulus", Lean.toJson modulus), + ("functions", Lean.toJson (code.functions.map fun fn => Json.mkObj [ + ("name", Lean.toJson fn.name), ("params", Lean.toJson (fn.params.map typeJson)), + ("result", typeJson fn.result), ("registers", Lean.toJson fn.registers), + ("code", Lean.toJson (fn.code.map (instructionJson encode)))])), + ("enums", Lean.toJson (code.enums.map fun decl => Json.mkObj [ + ("name", Lean.toJson decl.name), ("constructors", Lean.toJson (decl.constructors.map fun c => + Json.mkObj [("name", Lean.toJson c.name), ("fields", Lean.toJson (c.fields.map typeJson))]))])), + ("tables", Lean.toJson (code.tables.map fun table => Json.mkObj [ + ("name", Lean.toJson table.name), ("type", typeJson table.type), ("rows", Lean.toJson (table.rows.map (List.map encode)))])), + ("maps", Lean.toJson (code.maps.map fun map => Json.mkObj [ + ("name", Lean.toJson map.name), ("params", Lean.toJson (map.params.map typeJson)), ("result", typeJson map.result), + ("input", Lean.toJson map.input), ("output", Lean.toJson map.output)])), + ("entries", Lean.toJson entries)] + +end Aiur.Execution diff --git a/Aiur/Aiur/Execution/FFI.lean b/Aiur/Aiur/Execution/FFI.lean new file mode 100644 index 000000000..0ce7c3cda --- /dev/null +++ b/Aiur/Aiur/Execution/FFI.lean @@ -0,0 +1,66 @@ +import Aiur.Execution.Encode +import Mathlib.Data.ZMod.Basic + +namespace Aiur.Execution +open Lean + +@[extern "aiur_lean_execute"] +private opaque executeJson (request : @& String) : IO String + +structure Query where + function : Nat + name : String + args : Array Nat + output : Array Nat + multiplicity : Nat + deriving Repr, FromJson + +structure MemoryEntry where + address : Nat + cell : Json + multiplicity : Nat + deriving Inhabited, FromJson + +structure Result where + output : Array Nat + pretty_output : Option String + queries : Array Query + memory : Array MemoryEntry + memory_types : Array (Json × Nat) + instructions : Nat + deriving FromJson + +private def executeRequest (program : Json) (entry : String) (key : String) (args hints : Json) : + IO (Except String Result) := do + let response ← executeJson (Json.mkObj [("program", program), ("entry", toJson entry), + (key, args), ("hints", hints)]).compress + return do + let json ← Json.parse response + if let .ok error := json.getObjValAs? String "error" then throw error + fromJson? (← json.getObjVal? "ok") + +/-- Structured JSON arguments are interpreted using the selected entry's source +types. Tuples/arrays use JSON arrays; structs use named objects; enum values use +single-constructor objects such as {"Some": [7]}. -/ +def Export.run (exported : Export (ZMod p)) [NeZero p] (entry : String) (args : Array Json) + (hints : Array (HintEntry (ZMod p)) := #[]) : + IO (Except String Result) := do + match (do + let program ← exported.toJson p ZMod.val + let hints ← exported.prepareHints hints + return (program, hintsJson ZMod.val hints)) with + | .error error => return .error error + | .ok (program, hints) => executeRequest program entry "args" (Lean.toJson args) hints + +/-- Low-level entry IO still checks canonical fields, enum tags and padding. -/ +def Export.runFlat (exported : Export (ZMod p)) [NeZero p] (entry : String) (args : Array Nat) + (hints : Array (HintEntry (ZMod p)) := #[]) : + IO (Except String Result) := do + match (do + let program ← exported.toJson p ZMod.val + let hints ← exported.prepareHints hints + return (program, hintsJson ZMod.val hints)) with + | .error error => return .error error + | .ok (program, hints) => executeRequest program entry "flat_args" (Lean.toJson args) hints + +end Aiur.Execution diff --git a/Aiur/Aiur/Execution/Hints.lean b/Aiur/Aiur/Execution/Hints.lean new file mode 100644 index 000000000..14821b7c0 --- /dev/null +++ b/Aiur/Aiur/Execution/Hints.lean @@ -0,0 +1,108 @@ +import Aiur.Execution.Interface + +namespace Aiur.Execution + +/-- A high-level channel entry. The expected output type is checked; lookup +identity is the channel and nominal constant key. -/ +structure HintEntry (F : Type) where + type : Generic.Ty + key : DataValue F + output : DataValue F + channel : String := "" + deriving Repr, BEq + +def HintEntry.map (f : F → G) (entry : HintEntry F) : HintEntry G := + ⟨entry.type, entry.key.map f, entry.output.map f, entry.channel⟩ + +/-- Nominal key types distinguish constants even when encodings coincide. +The result type describes the answer and is not an extra dispatch argument. -/ +structure FlatHintEntry (F : Type) where + type : Ty + keyType : Ty + key : List F + output : List F + channel : String := "" + deriving Repr, BEq + +instance : Inhabited (FlatHintEntry F) := ⟨⟨.field, .field, [], [], ""⟩⟩ + +namespace DataTypes + +def inputType (types : DataTypes) (type : Generic.Ty) : Except String Generic.Ty := do + let resolved ← types.resolve 1024 type + if (IOType.ofSource types.program types.opaqueNames 1024 type).isNone then + throw "execution data type contains an opaque component or has no finite public representation" + return resolved + +private def checkChildren (types : DataTypes) (expected actual : List Generic.Ty) : Except String Unit := do + let expected ← expected.mapM (types.resolve 1024) + if expected != actual then throw "execution data component type mismatch" + +/-- Check every child and order named fields using the declaration, then reuse +the semantic constant representation and the existing canonical layout codec. -/ +def value (types : DataTypes) (input : DataValue F) : Except String (Generic.Ty × Constant F) := do + let type ← types.inputType input.type + match input with + | .field x => return (type, .field x) + | .tuple items => + let values ← items.mapM types.value + return (type, .tuple (values.map Prod.snd)) + | .array element items => + let values ← items.mapM types.value + types.checkChildren (List.replicate items.length element) (values.map Prod.fst) + return (type, .tuple (values.map Prod.snd)) + | .record _ fields => + let .named name args := type | throw "struct data requires a nominal struct type" + let some decl := types.program.findStruct? name | throw s!"not a struct type: {name}" + let env ← Generic.arguments decl.typeParams args + if fields.length != decl.fields.length || (fields.map Prod.fst).eraseDups.length != fields.length then + throw "execution struct field count mismatch or duplicate field" + let values ← fields.mapM fun entry => return (entry.1, ← types.value entry.2) + let ordered ← decl.fields.mapM fun (name, expected) => do + let some (_, actual, value) := values.find? (·.1 == name) | throw s!"missing execution struct field {name}" + types.checkChildren [expected.subst env] [actual] + return value + return (type, .construct (Generic.Instance.symbol ⟨name, args⟩) Generic.structConstructor ordered) + | .construct _ ctor children => + let .named name args := type | throw "constructor data requires a nominal enum type" + let some decl := types.enums.find? (·.name == name) | throw s!"not an enum type: {name}" + let some constructor := decl.constructors.find? (·.name == ctor) | throw s!"unknown data constructor {name}::{ctor}" + let env ← Generic.arguments decl.typeParams args + let values ← children.mapM types.value + types.checkChildren (constructor.fields.map (·.subst env)) (values.map Prod.fst) + return (type, .construct (Generic.Instance.symbol ⟨name, args⟩) ctor (values.map Prod.snd)) +termination_by sizeOf input +decreasing_by + all_goals simp_wf + all_goals first | omega | have := List.sizeOf_lt_of_mem ‹_ ∈ _› + all_goals first | omega | cases ‹String × DataValue F›; simp_all only [Prod.mk.sizeOf_spec]; omega + +end DataTypes + +private def Export.prepareHint [NatCast F] [Zero F] (exported : Export F) + (entry : HintEntry F) : Except String (FlatHintEntry F) := do + let expected ← exported.dataTypes.inputType entry.type + let (keyType, key) ← exported.dataTypes.value entry.key + let (actual, output) ← exported.dataTypes.value entry.output + if expected != actual then throw "hint output type mismatch" + let keyLayout ← (exported.bytecode.enums.layout keyType.toCore).mapError reprStr + let outputLayout ← (exported.bytecode.enums.layout expected.toCore).mapError reprStr + let key ← Compiler.need (keyLayout.encode key.toValue) "cannot encode hint key" + let output ← Compiler.need (outputLayout.encode output.toValue) "cannot encode hint output" + return ⟨expected.toCore, keyType.toCore, key, output, entry.channel⟩ + +/-- Prepare per-execution witness data in Lean. Rust validates the transport +again and builds the index, coalescing identical rows and rejecting conflicts. +Use an explicit tail loop: the generic Array.mapM implementation can retain a +native continuation frame per row when invoked through the polymorphic FFI. -/ +def Export.prepareHints [NatCast F] [Zero F] (exported : Export F) + (entries : Array (HintEntry F)) : Except String (Array (FlatHintEntry F)) := + let rec go : List (HintEntry F) → Array (FlatHintEntry F) → Except String (Array (FlatHintEntry F)) + | [], acc => .ok acc + | entry :: rest, acc => + match exported.prepareHint entry with + | .error error => .error error + | .ok value => go rest (acc.push value) + go entries.toList #[] + +end Aiur.Execution diff --git a/Aiur/Aiur/Execution/Interface.lean b/Aiur/Aiur/Execution/Interface.lean new file mode 100644 index 000000000..32ac5dd3e --- /dev/null +++ b/Aiur/Aiur/Execution/Interface.lean @@ -0,0 +1,88 @@ +import Aiur.Execution.Compile +import Aiur.Execution.Data + +namespace Aiur.Execution + +/-- Source-facing descriptions survive only at the public boundary. There is +deliberately no pointer or opaque variant, even for zero-width arrays. -/ +inductive IOType where + | field + | tuple (items : List IOType) + | array (element : IOType) (length : Nat) + | record (name : String) (fields : List (String × IOType)) + | enum (name : String) (constructors : List (String × List IOType)) + deriving Repr, BEq + +structure Interface where + name : String + inputs : List IOType + output : Option IOType + deriving Repr, BEq + +def typeName : Generic.Ty → String + | .field => "Field" + | .param name => name + | .ptr type => "&" ++ typeName type + | .array type length => "[" ++ typeName type ++ "; " ++ toString length ++ "]" + | .tuple items => "(" ++ String.intercalate ", " (items.map typeName) ++ + (if items.length == 1 then ",)" else ")") + | .named name args => name ++ if args.isEmpty then "" else + "<" ++ String.intercalate ", " (args.map typeName) ++ ">" +termination_by type => sizeOf type + +/-- Inspect retained declarations before representation aliases disappear. -/ +def IOType.ofSource (p : Generic.Program α) (opaqueNames : List String) : + Nat → Generic.Ty → Option IOType + | 0, _ => none + | fuel + 1, type => do + match type with + | .field => return .field + | .ptr _ | .param _ => none + | .tuple items => return .tuple (← items.mapM (IOType.ofSource p opaqueNames fuel)) + | .array element length => return .array (← IOType.ofSource p opaqueNames fuel element) length + | .named name args => + if opaqueNames.contains name then none else do + if let some decl := p.aliases.find? (·.name == name) then + if decl.typeParams.length != args.length then none else + IOType.ofSource p opaqueNames fuel (decl.target.subst (decl.typeParams.zip args)) + else if let some decl := p.findStruct? name then + if decl.typeParams.length != args.length then none else do + let fields ← decl.fields.mapM fun (fieldName, type) => do + return (fieldName, ← IOType.ofSource p opaqueNames fuel (type.subst (decl.typeParams.zip args))) + return .record (typeName type) fields + else do + let decl ← p.findEnum? name + if decl.typeParams.length != args.length then none else do + let ctors ← decl.constructors.mapM fun ctor => do + let fields ← ctor.fields.mapM fun type => + IOType.ofSource p opaqueNames fuel (type.subst (decl.typeParams.zip args)) + return (ctor.name, fields) + return .enum (typeName type) ctors + +structure Export (F : Type) where + bytecode : Bytecode F + interfaces : List Interface + dataTypes : DataTypes := {} + deriving Repr, BEq + +end Aiur.Execution + +namespace Aiur.Modules + +def Prepared.exportExecution [NatCast F] [Zero F] [DecidableEq F] + (prepared : Prepared (program : Program F)) : Except String (Execution.Export F) := do + let code ← prepared.compileExecution + let (world, _) ← collect program (prepared.selections.map (·.external)) + let opaqueNames := opaqueNames program world (.mk "" []) + let source := prepared.environment.assembly.program + let interfaces ← prepared.selections.mapM fun entry => do + let some fn := source.findFunction? entry.resolved.name + | throw s!"missing source entry {entry.external}" + let inputs ← fn.params.mapM fun (_, type) => + Execution.Compiler.need (Execution.IOType.ofSource source opaqueNames 1024 type) + s!"entry {entry.external} has no public IO representation" + let output := Execution.IOType.ofSource source opaqueNames 1024 fn.result + return { name := entry.external, inputs, output : Execution.Interface } + return ⟨code, interfaces, Execution.DataTypes.ofSource source opaqueNames⟩ + +end Aiur.Modules diff --git a/Aiur/Aiur/Frontend.lean b/Aiur/Aiur/Frontend.lean new file mode 100644 index 000000000..eac6d2380 --- /dev/null +++ b/Aiur/Aiur/Frontend.lean @@ -0,0 +1,409 @@ +import Aiur.Typecheck +import Lean + +namespace Aiur.Frontend + +open Lean Elab Term + +declare_syntax_cat aiur_type +declare_syntax_cat aiur_expr +declare_syntax_cat aiur_pattern +declare_syntax_cat aiur_arm +declare_syntax_cat aiur_param +declare_syntax_cat aiur_function +declare_syntax_cat aiur_constructor +declare_syntax_cat aiur_enum +-- Declaration keywords need not reserve ordinary identifiers in surrounding Lean code. +declare_syntax_cat aiur_table (behavior := symbol) +declare_syntax_cat aiur_map (behavior := symbol) +declare_syntax_cat aiur_decl (behavior := symbol) +declare_syntax_cat aiur_program (behavior := symbol) + +syntax:75 (name := pointerType) "&" aiur_type:75 : aiur_type +syntax (name := namedType) ident : aiur_type +syntax (name := unitType) "(" ")" : aiur_type +syntax (name := typeParens) "(" aiur_type ")" : aiur_type +syntax (name := tupleType) "(" aiur_type "," sepBy(aiur_type, ",", ",", allowTrailingSep) ")" : aiur_type +syntax (name := unitExpr) "(" ")" : aiur_expr +syntax (name := tupleExpr) "(" aiur_expr "," sepBy(aiur_expr, ",", ",", allowTrailingSep) ")" : aiur_expr +syntax:80 (name := project) aiur_expr:80 "." num : aiur_expr +syntax (name := letValue) "let" aiur_pattern "=" aiur_expr ";" aiur_expr : aiur_expr +syntax (name := literal) num : aiur_expr +syntax (name := variableExpr) ident : aiur_expr +syntax (name := constructorExpr) ident "::" ident : aiur_expr +syntax (name := constructorCall) ident "::" ident "(" sepBy(aiur_expr, ",", ",", allowTrailingSep) ")" : aiur_expr +syntax (name := parens) "(" aiur_expr ")" : aiur_expr +syntax (name := block) "{" aiur_expr "}" : aiur_expr +syntax (name := call) ident "(" sepBy(aiur_expr, ",", ",", allowTrailingSep) ")" : aiur_expr +syntax (name := hintExpr) ident "::<" aiur_type ">" "(" aiur_expr ")" : aiur_expr +syntax (name := channelHintExpr) ident "::<" aiur_type ">" "(" str "," aiur_expr ")" : aiur_expr +syntax:75 (name := store) "&" aiur_expr:75 : aiur_expr +syntax:75 (name := load) "*" aiur_expr:75 : aiur_expr +syntax:75 (name := neg) "-" aiur_expr:75 : aiur_expr +syntax:70 (name := mul) aiur_expr:70 "*" aiur_expr:71 : aiur_expr +syntax:70 (name := div) aiur_expr:70 "/" aiur_expr:71 : aiur_expr +syntax:65 (name := add) aiur_expr:65 "+" aiur_expr:66 : aiur_expr +syntax:65 (name := sub) aiur_expr:65 "-" aiur_expr:66 : aiur_expr +syntax (name := literalPattern) num : aiur_pattern +syntax (name := wildcardPattern) "_" : aiur_pattern +syntax (name := bindPattern) ident : aiur_pattern +syntax (name := constructorPattern) ident "::" ident : aiur_pattern +syntax (name := constructorPatternArgs) ident "::" ident "(" sepBy(aiur_pattern, ",", ",", allowTrailingSep) ")" : aiur_pattern +syntax (name := unitPattern) "(" ")" : aiur_pattern +syntax (name := patternParens) "(" aiur_pattern ")" : aiur_pattern +syntax (name := tuplePattern) "(" aiur_pattern "," sepBy(aiur_pattern, ",", ",", allowTrailingSep) ")" : aiur_pattern +syntax (name := arm) aiur_pattern "=>" aiur_expr : aiur_arm +syntax (name := matchValue) "match" aiur_expr "{" + sepBy1(aiur_arm, ",", ",", allowTrailingSep) "}" : aiur_expr +syntax (name := param) aiur_pattern ":" aiur_type : aiur_param +syntax (name := function) "fn" ident "(" sepBy(aiur_param, ",", ",", allowTrailingSep) ")" + "->" aiur_type "{" aiur_expr "}" : aiur_function +syntax (name := nullaryConstructor) ident : aiur_constructor +syntax (name := payloadConstructor) ident "(" sepBy(aiur_type, ",", ",", allowTrailingSep) ")" : aiur_constructor +syntax (name := enumDefinition) "enum" ident "{" sepBy(aiur_constructor, ",", ",", allowTrailingSep) "}" : aiur_enum +syntax (name := tableDefinition) &"table" ident ":" aiur_type "{" + sepBy(aiur_expr, ",", ",", allowTrailingSep) "}" : aiur_table +syntax (name := mapDefinition) &"map" ident "(" sepBy(aiur_param, ",", ",", allowTrailingSep) ")" + "->" aiur_type "=" ident "=>" ident ";" : aiur_map +syntax (name := tableDecl) aiur_table : aiur_decl +syntax (name := mapDecl) aiur_map : aiur_decl +syntax (name := functionDecl) aiur_function : aiur_decl +syntax (name := enumDecl) aiur_enum : aiur_decl +syntax (name := program) aiur_decl* : aiur_program + +private def readName (stx : Syntax) : Except String String := + match stx.getId with + | .str .anonymous name => .ok name + | _ => .error "expected a simple function or parameter name" + +private partial def lowerType (stx : Syntax) : Except String Ty := do + if stx.getKind == ``pointerType then return .ptr (← lowerType stx[1]) + else if stx.getKind == ``namedType then + if stx[0].getId == `Field then return .field + else return .enum (← readName stx[0]) + else if stx.getKind == ``unitType then return .tuple [] + else if stx.getKind == ``typeParens then lowerType stx[1] + else if stx.getKind == ``tupleType then + return .tuple ((← lowerType stx[1]) :: (← stx[3].getSepArgs.toList.mapM lowerType)) + else throw "expected a field, tuple, pointer, or enum type" + +private partial def lowerPattern (stx : Syntax) : Except String (Pattern Nat) := do + if stx.getKind == `choice then + let mut error := "unsupported ambiguous pattern" + for alternative in stx.getArgs do + match lowerPattern alternative with + | .ok pattern => return pattern + | .error message => error := message + throw error + else if stx.getKind == ``literalPattern then + let some value := stx[0].isNatLit? | throw "expected a natural-number pattern" + return .literal value + else if stx.getKind == ``wildcardPattern then return .wildcard + else if stx.getKind == ``bindPattern then return .bind (← readName stx[0]) + else if stx.getKind == ``constructorPattern then + return .construct (← readName stx[0]) (← readName stx[2]) [] + else if stx.getKind == ``constructorPatternArgs then + return .construct (← readName stx[0]) (← readName stx[2]) + (← stx[4].getSepArgs.toList.mapM lowerPattern) + else if stx.getKind == ``unitPattern then return .tuple [] + else if stx.getKind == ``patternParens then lowerPattern stx[1] + else if stx.getKind == ``tuplePattern then + return .tuple ((← lowerPattern stx[1]) :: (← stx[3].getSepArgs.toList.mapM lowerPattern)) + else throw "expected a literal, wildcard, binding, or tuple pattern" + +/-- Lower Lean's syntax tree for the embedded language; no field is chosen here. -/ +private partial def lowerExpr (stx : Syntax) : Except String (Aiur.Expr Nat) := do + let kind := stx.getKind + if kind == `choice then + let mut error := "unsupported ambiguous expression" + for alternative in stx.getArgs do + match lowerExpr alternative with + | .ok expr => return expr + | .error message => error := message + throw error + else if kind == ``literal then + let some value := stx[0].isNatLit? | throw "expected a natural-number literal" + return .literal value + else if kind == ``constructorExpr then + return .construct (← readName stx[0]) (← readName stx[2]) [] + else if kind == ``constructorCall then + return .construct (← readName stx[0]) (← readName stx[2]) + (← stx[4].getSepArgs.toList.mapM lowerExpr) + else if kind == ``unitExpr then return .tuple [] + else if kind == ``tupleExpr then + return .tuple ((← lowerExpr stx[1]) :: (← stx[3].getSepArgs.toList.mapM lowerExpr)) + else if kind == ``project then + let some index := stx[2].isNatLit? | throw "expected a tuple index" + return .project (← lowerExpr stx[0]) index + else if kind == ``letValue then + return .letValue (← lowerPattern stx[1]) (← lowerExpr stx[3]) (← lowerExpr stx[5]) + else if kind == ``variableExpr then + return .var (← readName stx[0]) + else if kind == ``parens || kind == ``block then + lowerExpr stx[1] + else if kind == ``store then return .store (← lowerExpr stx[1]) + else if kind == ``load then return .load (← lowerExpr stx[1]) + else if kind == ``channelHintExpr then + if (← readName stx[0]) != "hint" then throw "only hint supports a channel" + return .hint (← lowerType stx[2]) (← lowerExpr stx[7]) (stx[5].isStrLit?.getD "") + else if kind == ``hintExpr then + if (← readName stx[0]) != "hint" then throw "only hint supports an explicit result type" + return .hint (← lowerType stx[2]) (← lowerExpr stx[5]) + else if kind == ``neg then + return .neg (← lowerExpr stx[1]) + else if kind == ``add || kind == ``sub || kind == ``mul || kind == ``div then + let op := if kind == ``add then BinOp.add else if kind == ``sub then .sub + else if kind == ``mul then .mul else .div + return .binary op (← lowerExpr stx[0]) (← lowerExpr stx[2]) + else if kind == ``call then + return .call (← readName stx[0]) (← stx[2].getSepArgs.toList.mapM lowerExpr) + else if kind == ``matchValue then + let scrutinee ← lowerExpr stx[1] + let arms ← stx[3].getSepArgs.toList.mapM fun arm => do + return (← lowerPattern arm[0], ← lowerExpr arm[2]) + return .matchValue scrutinee arms + else + throw s!"unsupported expression syntax: {kind}" + +private def lowerEnum (stx : Syntax) : Except String EnumDecl := do + let name ← readName stx[1] + let constructors ← stx[3].getSepArgs.toList.mapM fun ctor => do + let fields ← if ctor.getKind == ``payloadConstructor then + ctor[2].getSepArgs.toList.mapM lowerType + else pure [] + return { name := ← readName ctor[0], fields : ConstructorDecl } + return { name, constructors } + +private partial def lowerFunction (decls : Declarations) (stx : Syntax) : Except String (Aiur.Function Nat) := do + if stx.getKind == `choice then + let mut error := "unsupported ambiguous function" + for alternative in stx.getArgs do + match lowerFunction decls alternative with + | .ok definition => return definition + | .error message => error := message + throw error + let name ← readName stx[1] + let mut params := [] + let mut destructuring := [] + let mut names := [] + for (param, index) in stx[3].getSepArgs.toList.zipIdx do + let pattern ← lowerPattern param[0] + let type ← lowerType param[2] + if !pattern.irrefutable decls then throw s!"parameter patterns must be irrefutable in function '{name}'" + let bindings ← (checkPattern decls name pattern type).mapError toString + names := names ++ bindings.map Prod.fst + match pattern with + | .bind key => params := params ++ [(key, type)] + | _ => + let key := s!"$arg{index}" + params := params ++ [(key, type)] + destructuring := destructuring ++ [(pattern, key)] + if let some duplicate := findDuplicate names [] then + throw s!"duplicate parameter '{duplicate}' in function '{name}'" + let body ← lowerExpr stx[8] + return { + name, params + result := ← lowerType stx[6] + body := destructuring.foldr (fun (pattern, key) body => .letValue pattern (.var key) body) body + } + +private def constantOfExpr : Aiur.Expr Nat → Except String (Constant Nat) + | .literal value => pure (.field value) + | .tuple items => (.tuple ·) <$> items.mapM constantOfExpr + | .construct name ctor args => (.construct name ctor ·) <$> args.mapM constantOfExpr + | _ => throw "table rows must be constant literals, tuples, or enum constructors; pointers are forbidden" +termination_by expr => sizeOf expr + +private def lowerTable (stx : Syntax) : Except String (Table Nat) := do + return { + name := ← readName stx[1] + rowType := ← lowerType stx[3] + rows := ← stx[5].getSepArgs.toList.mapM fun row => do constantOfExpr (← lowerExpr row) + } + +private partial def lowerMap (stx : Syntax) : Except String MapDecl := do + if stx.getKind == `choice then + let mut error := "unsupported ambiguous map" + for alternative in stx.getArgs do + match lowerMap alternative with + | .ok decl => return decl + | .error message => error := message + throw error + let params ← stx[3].getSepArgs.toList.mapM fun param => do + let .bind name ← lowerPattern param[0] | throw "map parameters must be named bindings" + return (name, ← lowerType param[2]) + return { + name := ← readName stx[1] + params + result := ← lowerType stx[6] + input := ← readName stx[8] + output := ← readName stx[10] + } + +/-- Mask Rust comments before invoking Lean's parser, preserving lines and token boundaries. -/ +def maskComments : List Char → Nat → Bool → Except String (List Char) + | [], depth, _ => + if depth == 0 then .ok [] else .error "unterminated block comment" + | '/' :: '/' :: rest, 0, false => do + return ' ' :: ' ' :: (← maskComments rest 0 true) + | '/' :: '*' :: rest, depth, false => do + return ' ' :: ' ' :: (← maskComments rest (depth + 1) false) + | '*' :: '/' :: rest, depth + 1, false => do + return ' ' :: ' ' :: (← maskComments rest depth false) + | char :: rest, depth, inLine => do + let masked := if (inLine || depth > 0) && char != '\n' && char != '\r' then ' ' else char + return masked :: (← maskComments rest depth (inLine && char != '\n')) + +/-- Keep adjacent arithmetic operators from being interpreted as Lean comments. -/ +def normalizeWhitespace : List Char → List Char + | [] => [] + | '.' :: '.' :: '=' :: rest => ' ' :: '.' :: '.' :: '=' :: ' ' :: normalizeWhitespace rest + | '.' :: '.' :: rest => ' ' :: '.' :: '.' :: ' ' :: normalizeWhitespace rest + | char :: rest => + let normalized := if char == '\t' || char == '\r' then ' ' else char + -- Keep chained tuple indices such as `p.1.0` from becoming a decimal token. + if char == '&' || char == '*' then normalized :: ' ' :: normalizeWhitespace rest + else if char == '.' then ' ' :: '.' :: ' ' :: normalizeWhitespace rest + else if (char == '-' || char == '/') && rest.head? == some '-' then + normalized :: ' ' :: normalizeWhitespace rest + else + normalized :: normalizeWhitespace rest + +/-- Parse and typecheck a string using the syntax categories registered in Lean. -/ +def ofString (env : Environment) (source : String) : Except String (Program Nat) := do + let source := String.ofList (normalizeWhitespace (← maskComments source.toList 0 false)) + let stx ← Parser.runParserCategory env `aiur_program source "" + let declarations := stx[0].getArgs.toList + for d in declarations do + unless [``enumDecl, ``functionDecl, ``tableDecl, ``mapDecl].contains d.getKind do + throw "declaration requires the generic source frontend (Generic.Program Nat)" + let enums ← (declarations.filter (·.getKind == ``enumDecl)).mapM (fun d => lowerEnum d[0]) + (checkDeclarations enums).mapError toString + let program := { + functions := ← (declarations.filter (·.getKind == ``functionDecl)).mapM (fun d => lowerFunction enums d[0]) + enums + tables := ← (declarations.filter (·.getKind == ``tableDecl)).mapM (fun d => lowerTable d[0]) + maps := ← (declarations.filter (·.getKind == ``mapDecl)).mapM (fun d => lowerMap d[0]) + } + match typecheck program with + | .error error => throw (toString error) + | .ok () => pure program + +private def quoteList (type : Lean.Expr) (values : List Lean.Expr) : Lean.Expr := + values.foldr (fun value tail => mkApp3 (mkConst ``List.cons [0]) type value tail) + (mkApp (mkConst ``List.nil [0]) type) + +private def natType : Lean.Expr := mkConst ``Nat +private def exprType : Lean.Expr := mkApp (mkConst ``Aiur.Expr) natType +private def patternType : Lean.Expr := mkApp (mkConst ``Pattern) natType + +private def quoteOp : BinOp → Lean.Expr + | .add => mkConst ``BinOp.add + | .sub => mkConst ``BinOp.sub + | .mul => mkConst ``BinOp.mul + | .div => mkConst ``BinOp.div + +private def quoteTy : Ty → Lean.Expr + | .field => mkConst ``Ty.field + | .enum name => mkApp (mkConst ``Ty.enum) (toExpr name) + | .ptr target => mkApp (mkConst ``Ty.ptr) (quoteTy target) + | .tuple items => mkApp (mkConst ``Ty.tuple) (quoteList (mkConst ``Ty) (items.map quoteTy)) + +private def quotePattern : Pattern Nat → Lean.Expr + | .literal value => mkApp2 (mkConst ``Pattern.literal) natType (toExpr value) + | .wildcard => mkApp (mkConst ``Pattern.wildcard) natType + | .bind name => mkApp2 (mkConst ``Pattern.bind) natType (toExpr name) + | .tuple items => mkApp2 (mkConst ``Pattern.tuple) natType (quoteList patternType (items.map quotePattern)) + | .construct name ctor args => mkApp4 (mkConst ``Pattern.construct) natType (toExpr name) (toExpr ctor) + (quoteList patternType (args.map quotePattern)) + +private def quoteExpr : Aiur.Expr Nat → Lean.Expr + | .literal value => mkApp2 (mkConst ``Aiur.Expr.literal) natType (toExpr value) + | .var name => mkApp2 (mkConst ``Aiur.Expr.var) natType (toExpr name) + | .tuple items => mkApp2 (mkConst ``Aiur.Expr.tuple) natType (quoteList exprType (items.map quoteExpr)) + | .construct name ctor args => mkApp4 (mkConst ``Aiur.Expr.construct) natType (toExpr name) (toExpr ctor) + (quoteList exprType (args.map quoteExpr)) + | .project value index => mkApp3 (mkConst ``Aiur.Expr.project) natType (quoteExpr value) (toExpr index) + | .letValue pattern value body => + mkApp4 (mkConst ``Aiur.Expr.letValue) natType (quotePattern pattern) (quoteExpr value) (quoteExpr body) + | .store value => mkApp2 (mkConst ``Aiur.Expr.store) natType (quoteExpr value) + | .load pointer => mkApp2 (mkConst ``Aiur.Expr.load) natType (quoteExpr pointer) + | .hint type key channel => mkApp4 (mkConst ``Aiur.Expr.hint) natType (quoteTy type) (quoteExpr key) (toExpr channel) + | .neg value => mkApp2 (mkConst ``Aiur.Expr.neg) natType (quoteExpr value) + | .assertEq assertion left right => + let metadata := mkApp2 (mkConst ``Aiur.Assertion.mk) + (toExpr assertion.message) (toExpr assertion.runtimeCheck) + mkApp4 (mkConst ``Aiur.Expr.assertEq) natType metadata (quoteExpr left) (quoteExpr right) + | .binary op left right => + mkApp4 (mkConst ``Aiur.Expr.binary) natType (quoteOp op) (quoteExpr left) (quoteExpr right) + | .call name args => + mkApp3 (mkConst ``Aiur.Expr.call) natType (toExpr name) + (quoteList exprType (args.map quoteExpr)) + | .matchValue scrutinee arms => + let armType := mkApp2 (mkConst ``Prod [0, 0]) patternType exprType + let arms := arms.map fun arm => + mkApp4 (mkConst ``Prod.mk [0, 0]) patternType exprType + (quotePattern arm.1) (quoteExpr arm.2) + mkApp3 (mkConst ``Aiur.Expr.matchValue) natType (quoteExpr scrutinee) (quoteList armType arms) +termination_by expr => sizeOf expr +decreasing_by + all_goals simp_wf + all_goals + first + | omega + | have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + first + | omega + | cases arm + simp_all only [Prod.mk.sizeOf_spec] + omega + +private def quoteFunction (defn : Aiur.Function Nat) : Lean.Expr := + let paramType := mkApp2 (mkConst ``Prod [0, 0]) (mkConst ``String) (mkConst ``Ty) + let params := defn.params.map fun (name, type) => + mkApp4 (mkConst ``Prod.mk [0, 0]) (mkConst ``String) (mkConst ``Ty) (toExpr name) (quoteTy type) + mkApp5 (mkConst ``Aiur.Function.mk) natType (toExpr defn.name) (quoteList paramType params) + (quoteTy defn.result) (quoteExpr defn.body) + +private def quoteEnum (decl : EnumDecl) : Lean.Expr := + let constructors := decl.constructors.map fun ctor => + mkApp2 (mkConst ``ConstructorDecl.mk) (toExpr ctor.name) + (quoteList (mkConst ``Ty) (ctor.fields.map quoteTy)) + mkApp2 (mkConst ``EnumDecl.mk) (toExpr decl.name) + (quoteList (mkConst ``ConstructorDecl) constructors) + +private def quoteConstant : Constant Nat → Lean.Expr + | .field value => mkApp3 (mkConst ``Value.field) natType (mkConst ``Empty) (toExpr value) + | .tuple items => mkApp3 (mkConst ``Value.tuple) natType (mkConst ``Empty) + (quoteList (mkApp2 (mkConst ``Value) natType (mkConst ``Empty)) (items.map quoteConstant)) + | .construct name ctor args => mkApp5 (mkConst ``Value.construct) natType (mkConst ``Empty) + (toExpr name) (toExpr ctor) + (quoteList (mkApp2 (mkConst ``Value) natType (mkConst ``Empty)) (args.map quoteConstant)) + | .ptr _ address => nomatch address +termination_by value => sizeOf value + +private def quoteTable (trace : Table Nat) : Lean.Expr := + mkApp4 (mkConst ``Table.mk) natType (toExpr trace.name) (quoteTy trace.rowType) + (quoteList (mkApp (mkConst ``Constant) natType) (trace.rows.map quoteConstant)) + +private def quoteMap (definition : MapDecl) : Lean.Expr := + let paramType := mkApp2 (mkConst ``Prod [0, 0]) (mkConst ``String) (mkConst ``Ty) + let params := definition.params.map fun (name, type) => + mkApp4 (mkConst ``Prod.mk [0, 0]) (mkConst ``String) (mkConst ``Ty) (toExpr name) (quoteTy type) + mkApp5 (mkConst ``MapDecl.mk) (toExpr definition.name) (quoteList paramType params) + (quoteTy definition.result) (toExpr definition.input) (toExpr definition.output) + +private def quoteProgram (program : Program Nat) : Lean.Expr := + mkApp5 (mkConst ``Program.mk) natType + (quoteList (mkApp (mkConst ``Aiur.Function) natType) (program.functions.map quoteFunction)) + (quoteList (mkConst ``EnumDecl) (program.enums.map quoteEnum)) + (quoteList (mkApp (mkConst ``Table) natType) (program.tables.map quoteTable)) + (quoteList (mkConst ``MapDecl) (program.maps.map quoteMap)) + +/-- Elaborate a Rust-like source string directly to a checked `Program Nat`. -/ +elab (name := aiurTerm) "aiur% " source:str : term => do + match ofString (← getEnv) source.getString with + | .error error => throwErrorAt source "{error}" + | .ok program => return quoteProgram program + +end Aiur.Frontend diff --git a/Aiur/Aiur/Generic.lean b/Aiur/Aiur/Generic.lean new file mode 100644 index 000000000..2c0f912aa --- /dev/null +++ b/Aiur/Aiur/Generic.lean @@ -0,0 +1,16 @@ +import Aiur.Generic.Frontend +import Aiur.Generic.Diagnostics +import Aiur.Generic.SourceRules +import Aiur.Generic.AliasFacts +import Aiur.Generic.ConstFacts +import Aiur.Generic.PatternFacts +import Aiur.Generic.PatternRetentionFacts +import Aiur.Generic.PatternLoweringFacts +import Aiur.Generic.PatternTranslation +import Aiur.Generic.EnvironmentFacts +import Aiur.Generic.PreparationExpressionFacts +import Aiur.Generic.ArrayFacts +import Aiur.Generic.SliceFacts +import Aiur.Generic.Circuit +import Aiur.Generic.NativeCircuit +import Aiur.Generic.LoweringTypeFacts diff --git a/Aiur/Aiur/Generic/AST.lean b/Aiur/Aiur/Generic/AST.lean new file mode 100644 index 000000000..fe9543c43 --- /dev/null +++ b/Aiur/Aiur/Generic/AST.lean @@ -0,0 +1,425 @@ +import Aiur.AST +import Lean + +/-! The source language keeps type parameters; the existing `Aiur.Program` is +the concrete language consumed by the circuit compiler. -/ +deriving instance Lean.ToExpr for Aiur.BinOp +deriving instance Lean.ToExpr for Aiur.Assertion + +namespace Aiur.Generic + +inductive Ty where + | field + | tuple (items : List Ty) + | array (element : Ty) (length : Nat) + | ptr (target : Ty) + | param (name : String) + | named (name : String) (args : List Ty) + deriving Repr, BEq, Inhabited, Lean.ToExpr, Lean.ToJson, Lean.FromJson + +def Ty.subst (env : List (String × Ty)) : Ty → Ty + | .field => .field + | .tuple items => .tuple (items.map (Ty.subst env)) + | .array t n => .array (t.subst env) n + | .ptr target => .ptr (target.subst env) + | .param name => (env.lookup name).getD (.param name) + | .named name args => .named name (args.map (Ty.subst env)) +termination_by type => sizeOf type + +def Ty.parameters : Ty → List String + | .field => [] + | .tuple items | .named _ items => items.flatMap Ty.parameters + | .ptr target | .array target _ => target.parameters + | .param name => [name] +termination_by type => sizeOf type + +def Ty.concrete (type : Ty) : Bool := type.parameters.isEmpty + +/-- A computational size bound, independent of identifier spelling. -/ +def Ty.nodes : Ty → Nat + | .field | .param _ => 1 + | .ptr t => 1 + t.nodes + | .array t n => 1 + (n + 1) * t.nodes + | .tuple ts | .named _ ts => 1 + (ts.map Ty.nodes).sum +termination_by t => sizeOf t + +/-- Names are nominal. Type arguments are part of an instance's identity. -/ +structure Instance where + name : String + types : List Ty := [] + deriving Repr, BEq, Inhabited, Lean.ToExpr, Lean.ToJson, Lean.FromJson + +/-- `$` is reserved for generated names; source identifiers cannot contain it. +JSON gives an unambiguous encoding of nested types, including empty tuples. -/ +def Instance.symbol (key : Instance) : String := + if key.types.isEmpty then key.name else "$" ++ (Lean.toJson key).compress + +def Instance.ofSymbol (name : String) : Except String Instance := + if name.startsWith "$" then do + Lean.fromJson? (← Lean.Json.parse (name.drop 1).toString) + else return ⟨name, []⟩ + +def Ty.toCore : Ty → Aiur.Ty + | .field => .field + | .tuple items => .tuple (items.map Ty.toCore) + | .array t n => .tuple (List.replicate n t.toCore) + | .ptr target => .ptr target.toCore + | .param name => .enum ("$param:" ++ name) + | .named name args => .enum (Instance.symbol ⟨name, args⟩) +termination_by type => sizeOf type + +/-- Named fields stay in source order. The checker records their positions in + declaration order as type/layout information; `none` slots are omitted fields + in a pattern with `..`. An unannotated head is used only before checking. -/ +structure RecordHead where + type : Ty + fields : List String + rest : Bool := false + params : List String := [] + slots : Option (List (Option Nat)) := none + deriving Repr, BEq, Inhabited, Lean.ToExpr + +def RecordHead.positions (head : RecordHead) (length : Nat) : List (Option Nat) := + head.slots.getD ((List.range length).map some) + +def RecordHead.order (head : RecordHead) (items : List A) (fallback : A) : List A := + (head.positions items.length).map fun slot => (slot.bind (items[·]?)).getD fallback + +def RecordHead.subst (types : List (String × Ty)) (head : RecordHead) : RecordHead := + { head with type := head.type.subst types } + +/-- A checked named projection retains its source spelling and nominal owner. -/ +structure FieldRef where + name : String + owner : Option Ty := none + index : Nat := 0 + arity : Nat := 0 + deriving Repr, BEq, Inhabited, Lean.ToExpr + +def FieldRef.subst (types : List (String × Ty)) (field : FieldRef) : FieldRef := + { field with owner := field.owner.map (Ty.subst types) } + +/-- A source update selector. Widths and nominal owners are checker annotations; +indices remain natural numbers, never field literals. -/ +inductive UpdateStep where + | member (field : FieldRef) + | project (index : Nat) (arity : Nat := 0) + | index (index : Nat) (length : Nat := 0) + deriving Repr, BEq, Inhabited, Lean.ToExpr + +def UpdateStep.subst (types : List (String × Ty)) : UpdateStep → UpdateStep + | .member field => .member (field.subst types) + | .project i n => .project i n + | .index i n => .index i n + +def UpdateStep.position : UpdateStep → Nat + | .member field => field.index + | .project i _ | .index i _ => i + +def UpdateStep.width : UpdateStep → Nat + | .member field => field.arity + | .project _ n | .index _ n => n + +def UpdateStep.owner : UpdateStep → Option Ty + | .member field => some (field.owner.getD (.named "$invalid" [])) + | .project _ _ | .index _ _ => none + +abbrev UpdatePath := List UpdateStep + +/-- Internal semantic constructor for a nominal product. -/ +def structConstructor : String := "$struct" + +/-- Binding layout for an ordered pattern alternative. The left alternative +sets the canonical order; the checker records the right alternative's positions. +Renaming bindings leaves these positions unchanged. -/ +structure OrBindings where + names : List String + rightOrder : List Nat := [] + deriving Repr, BEq, Inhabited, Lean.ToExpr + +inductive Pattern (α : Type) where + | literal (value : α) + | wildcard + | bind (name : String) + /-- A rooted const reference. Checking records its inferred use type. -/ + | global (name : String) (type : Option Ty := none) + /-- Load the matched pointer, then match its contents. -/ + | load (pattern : Pattern α) + /-- Ordered alternatives. Each alternative binds the same names and types. -/ + | orElse (left right : Pattern α) (bindings : OrBindings) + | tuple (items : List (Pattern α)) + | array (items : List (Pattern α)) + | repeat (item : Pattern α) (length : Nat) + | record (head : RecordHead) (items : List (Pattern α)) + | construct (type : Ty) (constructor : String) (args : List (Pattern α)) + /-- An expanded constructor qualifier; `params` bind inference slots in `type`. + Elaboration replaces this with an ordinary nominal constructor pattern. -/ + | constructAs (params : List String) (type : Ty) (constructor : String) (args : List (Pattern α)) + deriving Repr, BEq, Inhabited, Lean.ToExpr + +/-- Targets are lexical. A function call always establishes a fresh function +boundary; labels never refer into a caller. -/ +inductive ExitTarget where + | function + | block (label : String) + deriving Repr, BEq, DecidableEq, ReflBEq, LawfulBEq, Inhabited, Lean.ToExpr + +inductive Control where + | block (label : String) + | exit (target : ExitTarget) + deriving Repr, BEq, DecidableEq, Inhabited, Lean.ToExpr + +/-- Source operations with an ordered argument list. Diagnostics are metadata; +their operands remain ordinary expressions throughout source evaluation. -/ +inductive Builtin where + | ascribe (type : Ty) + | debug (message : String) + | assertEq (assertion : Assertion) + deriving Repr, BEq, Inhabited, Lean.ToExpr + +def Builtin.subst (types : List (String × Ty)) : Builtin → Builtin + | .ascribe t => .ascribe (t.subst types) + | .debug message => .debug message + | .assertEq message => .assertEq message + +def Builtin.mapTypesM [Monad m] (f : Ty → m Ty) : Builtin → m Builtin + | .ascribe t => return .ascribe (← f t) + | .debug message => return .debug message + | .assertEq message => return .assertEq message + +def Builtin.types : Builtin → List Ty + | .ascribe t => [t] + | .debug _ => [] + | .assertEq _ => [] + +inductive Expr (α : Type) where + | literal (value : α) + | var (name : String) + /-- A rooted source reference, independent of local variable bindings. -/ + | global (name : String) (type : Option Ty := none) + | tuple (items : List (Expr α)) + | array (items : List (Expr α)) + /-- Evaluate the element once, then copy its value, including when length is zero. -/ + | repeat (value : Expr α) (length : Nat) + | index (value : Expr α) (index : Nat) + /-- Half-open bounds. Inference replaces an omitted end by the array length. -/ + | slice (value : Expr α) (start : Nat) (stop : Option Nat) + | construct (name : String) (types : Option (List Ty)) (constructor : String) (args : List (Expr α)) + /-- Alias-free constructor template, consumed by generic inference. -/ + | constructAs (params : List String) (type : Ty) (constructor : String) (args : List (Expr α)) + | record (head : RecordHead) (items : List (Expr α)) + | member (value : Expr α) (field : FieldRef) + /-- Functional updates retain their paths. Operands are the base followed by + replacements in written order; checking enforces one operand per path. -/ + | update (paths : List UpdatePath) (operands : List (Expr α)) + | builtin (operation : Builtin) (operands : List (Expr α)) + | project (value : Expr α) (index : Nat) + | letValue (pattern : Pattern α) (value body : Expr α) + | store (value : Expr α) + | load (pointer : Expr α) + | hint (type : Ty) (key : Expr α) (channel : String := "") + | neg (value : Expr α) + | binary (op : BinOp) (left right : Expr α) + | call (name : String) (types : Option (List Ty)) (args : List (Expr α)) + | matchValue (scrutinee : Expr α) (arms : List (Pattern α × Expr α)) + /-- Named blocks and exits remain explicit through checking and evaluation. -/ + | control (kind : Control) (body : Expr α) + deriving Repr, BEq, Inhabited, Lean.ToExpr + +structure Function (α : Type) where + name : String + typeParams : List String := [] + params : List (String × Ty) + result : Ty + body : Expr α + /-- Mandatory circuit-only expansion; execution still makes an ordinary call. -/ + isInline : Bool := false + deriving Repr, BEq, Inhabited, Lean.ToExpr + +structure ConstructorDecl where + name : String + fields : List Ty + deriving Repr, BEq, Inhabited, Lean.ToExpr + +structure EnumDecl where + name : String + typeParams : List String := [] + constructors : List ConstructorDecl + deriving Repr, BEq, Inhabited, Lean.ToExpr + +structure StructDecl where + name : String + typeParams : List String := [] + fields : List (String × Ty) + deriving Repr, BEq, Inhabited, Lean.ToExpr + +/-- Struct signatures reuse the nominal-product part of the type/layout model. +The source declaration itself remains a `StructDecl`. -/ +def StructDecl.signature (decl : StructDecl) : EnumDecl := + ⟨decl.name, decl.typeParams, [⟨structConstructor, decl.fields.map Prod.snd⟩]⟩ + +structure Table (α : Type) where + name : String + rowType : Ty + rows : List (Expr α) + deriving Repr, BEq, Inhabited, Lean.ToExpr + +structure MapDecl where + name : String + params : List (String × Ty) + result : Ty + input : String + output : String + deriving Repr, BEq, Inhabited, Lean.ToExpr + +structure AliasDecl where + name : String + typeParams : List String := [] + target : Ty + deriving Repr, BEq, Inhabited, Lean.ToExpr + +/-- A value/pattern template. Checking excludes binders and wildcards; `load` +denotes a read in patterns and a store in expressions. -/ +structure ConstDecl (α : Type) where + name : String + value : Pattern α + deriving Repr, BEq, Inhabited, Lean.ToExpr + +structure Program (α : Type) where + functions : List (Function α) + enums : List EnumDecl := [] + structs : List StructDecl := [] + tables : List (Table α) := [] + maps : List MapDecl := [] + /-- Transparent type declarations retained in the source program. -/ + aliases : List AliasDecl := [] + /-- Source value/pattern declarations; references remain through evaluation. -/ + consts : List (ConstDecl α) := [] + deriving Repr, BEq, Inhabited, Lean.ToExpr + +def Program.findFunction? (p : Program α) (name : String) := p.functions.find? (·.name == name) +def Program.nominals (p : Program α) : List EnumDecl := p.enums ++ p.structs.map StructDecl.signature +def Program.findStruct? (p : Program α) (name : String) := p.structs.find? (·.name == name) +def Program.findEnum? (p : Program α) (name : String) := p.nominals.find? (·.name == name) + +/-- Gather binding values using checker-recorded positions, assigning their +canonical names. No value comparison or memory read occurs here. -/ +def reorderBindings (names : List String) (positions : List Nat) (bindings : List (String × V)) : + Option (List (String × V)) := + match names, positions with + | [], [] => some [] + | name :: names, index :: positions => do + let (_, value) ← bindings[index]? + return (name, value) :: (← reorderBindings names positions bindings) + | _, _ => none + + +def Pattern.bindingNames : Pattern α → List String + | .literal _ | .wildcard | .global _ _ => [] + | .bind n => [n] + | .record head ps => (head.order (ps.map Pattern.bindingNames) []).flatten + | .orElse _ _ layout => layout.names + | .load p => p.bindingNames + | .repeat p n => (List.replicate n p.bindingNames).flatten + | .tuple ps | .array ps | .construct _ _ ps | .constructAs _ _ _ ps => ps.flatMap Pattern.bindingNames +termination_by p => sizeOf p + +def Pattern.hasLoads : Pattern α → Bool + | .literal _ | .wildcard | .bind _ | .global _ _ => false + | .orElse left right _ => left.hasLoads || right.hasLoads + | .load _ => true + | .record head ps => (head.order (ps.map Pattern.hasLoads) false).any id + | .repeat p n => n != 0 && p.hasLoads + | .tuple ps | .array ps | .construct _ _ ps | .constructAs _ _ _ ps => (ps.map Pattern.hasLoads).any id +termination_by p => sizeOf p + +def Pattern.irrefutable (enums : List EnumDecl) : Pattern α → Bool + | .literal _ | .global _ _ => false + | .record head ps => (head.order (ps.map (Pattern.irrefutable enums)) true).all id + | .wildcard | .bind _ => true + | .orElse left right _ => left.irrefutable enums || right.irrefutable enums + | .load p => p.irrefutable enums + | .tuple ps | .array ps => (ps.map (Pattern.irrefutable enums)).all id + | .repeat p n => n == 0 || p.irrefutable enums + | .construct (.named n _) c ps | .constructAs _ (.named n _) c ps => + (enums.find? (·.name == n)).any (fun d => d.constructors.length == 1 && d.constructors.any (·.name == c)) && + (ps.map (Pattern.irrefutable enums)).all id + | .construct _ _ _ | .constructAs _ _ _ _ => false +termination_by p => sizeOf p + +/-- Binder spelling does not change a pattern's matching condition. -/ +def Pattern.condition : Pattern α → Pattern α + | .literal x => .literal x + | .global n t => .global n t + | .wildcard | .bind _ => .wildcard + | .orElse left right _ => .orElse left.condition right.condition ⟨[], []⟩ + | .load p => .load p.condition + | .record head ps => .construct head.type structConstructor (head.order (ps.map Pattern.condition) .wildcard) + | .tuple ps | .array ps => .tuple (ps.map Pattern.condition) + | .repeat p n => .tuple (List.replicate n p.condition) + | .construct t c ps => .construct t c (ps.map Pattern.condition) + | .constructAs params t c ps => .constructAs params t c (ps.map Pattern.condition) +termination_by p => sizeOf p + +def Pattern.map (f : α → β) : Pattern α → Pattern β + | .literal x => .literal (f x) + | .wildcard => .wildcard + | .bind n => .bind n + | .global n t => .global n t + | .orElse left right names => .orElse (left.map f) (right.map f) names + | .load p => .load (p.map f) + | .record head xs => .record head (xs.map (Pattern.map f)) + | .tuple xs => .tuple (xs.map (Pattern.map f)) + | .array xs => .array (xs.map (Pattern.map f)) + | .repeat p n => .repeat (p.map f) n + | .construct t c xs => .construct t c (xs.map (Pattern.map f)) + | .constructAs ps t c xs => .constructAs ps t c (xs.map (Pattern.map f)) +termination_by p => sizeOf p + +def Expr.map (f : α → β) : Expr α → Expr β + | .literal x => .literal (f x) + | .var n => .var n + | .global n t => .global n t + | .tuple xs => .tuple (xs.map (Expr.map f)) + | .array xs => .array (xs.map (Expr.map f)) + | .repeat x n => .repeat (x.map f) n + | .index x i => .index (x.map f) i + | .slice x start stop => .slice (x.map f) start stop + | .construct n ts c xs => .construct n ts c (xs.map (Expr.map f)) + | .constructAs ps t c xs => .constructAs ps t c (xs.map (Expr.map f)) + | .record head xs => .record head (xs.map (Expr.map f)) + | .update paths xs => .update paths (xs.map (Expr.map f)) + | .builtin op xs => .builtin op (xs.map (Expr.map f)) + | .member x field => .member (x.map f) field + | .project x i => .project (x.map f) i + | .letValue p x b => .letValue (p.map f) (x.map f) (b.map f) + | .store x => .store (x.map f) + | .load x => .load (x.map f) + | .hint t k channel => .hint t (k.map f) channel + | .neg x => .neg (x.map f) + | .binary op x y => .binary op (x.map f) (y.map f) + | .call n ts xs => .call n ts (xs.map (Expr.map f)) + | .matchValue x arms => .matchValue (x.map f) (arms.map fun arm => (arm.1.map f, arm.2.map f)) + | .control kind body => .control kind (body.map f) +termination_by e => sizeOf e +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; try simp_all only [Prod.mk.sizeOf_spec] + all_goals first | omega | cases ‹Pattern α × Expr α›; simp_all only [Prod.mk.sizeOf_spec]; omega + +def ConstDecl.map (f : α → β) (d : ConstDecl α) : ConstDecl β := + { name := d.name, value := d.value.map f } + +def Program.map (f : α → β) (p : Program α) : Program β := { + functions := p.functions.map fun fn => { fn with body := fn.body.map f } + enums := p.enums + structs := p.structs + tables := p.tables.map fun table => { table with rows := table.rows.map (Expr.map f) } + maps := p.maps + aliases := p.aliases + consts := p.consts.map (ConstDecl.map f) +} + +def Program.toField (p : Program Nat) (F : Type) [NatCast F] : Program F := p.map Nat.cast + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/AliasFacts.lean b/Aiur/Aiur/Generic/AliasFacts.lean new file mode 100644 index 000000000..007d46e78 --- /dev/null +++ b/Aiur/Aiur/Generic/AliasFacts.lean @@ -0,0 +1,237 @@ +import Aiur.Generic.Aliases + +namespace Aiur.Generic +namespace Aliases + +set_option linter.unusedSimpArgs false + +private theorem map_pure (x : α) (f : α → β) : + (pure x : Except String α).map f = pure (f x) := rfl + +private theorem except_map_eq (f : α → β) (x : Except String α) : x.map f = f <$> x := rfl + +private theorem traverse_map (xs : List α) (input : α → β) (output : γ → δ) + (left : α → Except String γ) (right : β → Except String δ) + (agree : ∀ x ∈ xs, right (input x) = (left x).map output) : + (xs.map input).mapM right = (xs.mapM left).map (List.map output) := by + induction xs with + | nil => rfl + | cons x xs ih => + simp only [List.map_cons, List.mapM_cons] + rw [agree x (by simp), ih (fun y hy => agree y (by simp [hy]))] + cases left x <;> cases xs.mapM left <;> rfl + +private theorem traverse_same (xs : List α) (input : α → β) + (left : α → Except String γ) (right : β → Except String γ) + (agree : ∀ x ∈ xs, right (input x) = left x) : + (xs.map input).mapM right = xs.mapM left := by + simpa using traverse_map xs input id left right (by simpa using agree) + +theorem checkPatternTypes_map (enums aliases rigid) (f : α → β) (pat : Pattern α) : + checkPatternTypes enums aliases rigid (pat.map f) = checkPatternTypes enums aliases rigid pat := by + have sub (p : Pattern α) (hsize : sizeOf p < sizeOf pat) : + checkPatternTypes enums aliases rigid (p.map f) = checkPatternTypes enums aliases rigid p := + checkPatternTypes_map enums aliases rigid f p + have children (ps : List (Pattern α)) (h : ∀ q ∈ ps, sizeOf q < sizeOf pat) : + (ps.map (Pattern.map f)).mapM (checkPatternTypes enums aliases rigid) = + ps.mapM (checkPatternTypes enums aliases rigid) := + traverse_same ps _ _ _ (fun q hq => checkPatternTypes_map enums aliases rigid f q) + cases pat <;> simp only [Pattern.map, checkPatternTypes] + all_goals try rw [children _ (by intros; simp_all only [Pattern.tuple.sizeOf_spec, Pattern.array.sizeOf_spec, + Pattern.record.sizeOf_spec, Pattern.construct.sizeOf_spec, Pattern.constructAs.sizeOf_spec]; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega)] + all_goals first + | exact sub _ (by simp_wf <;> omega) + | rw [sub _ (by simp_wf; omega), sub _ (by simp_wf; omega)] +termination_by sizeOf pat +decreasing_by all_goals first | exact h q hq | exact hsize + +theorem expandPattern_map (aliases) (f : α → β) (pat : Pattern α) : + expandPattern aliases (pat.map f) = (expandPattern aliases pat).map (Pattern.map f) := by + have sub (p : Pattern α) (hsize : sizeOf p < sizeOf pat) : + expandPattern aliases (p.map f) = (expandPattern aliases p).map (Pattern.map f) := + expandPattern_map aliases f p + have children (ps : List (Pattern α)) (h : ∀ q ∈ ps, sizeOf q < sizeOf pat) : + (ps.map (Pattern.map f)).mapM (expandPattern aliases) = + (ps.mapM (expandPattern aliases)).map (List.map (Pattern.map f)) := + traverse_map ps _ _ _ _ (fun q hq => expandPattern_map aliases f q) + cases pat with + | literal | wildcard | bind | global => simp [Pattern.map, expandPattern, map_pure] + | orElse left right names => + simp only [Pattern.map, expandPattern, sub left (by simp_wf; omega), sub right (by simp_wf; omega)] + cases expandPattern aliases left <;> cases expandPattern aliases right <;> simp [Except.map, bind, Except.bind, pure, Except.pure, Pattern.map] + | load p | «repeat» p _ => + simp only [Pattern.map, expandPattern, sub p (by simp_wf <;> omega)] + simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map, Pattern.map] + | record head ps => + simp only [Pattern.map, expandPattern] + rw [children ps (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega)] + simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map, Pattern.map] + | tuple ps | array ps => + simp only [Pattern.map, expandPattern] + rw [children ps (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega)] + cases ps.mapM (expandPattern aliases) <;> + simp [Except.map, bind, Except.bind, pure, Except.pure, Pattern.map] + | construct t c ps => + simp only [Pattern.map, expandPattern] + rw [children ps (by intros; simp only [Pattern.construct.sizeOf_spec]; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega)] + cases ps.mapM (expandPattern aliases) <;> simp only [Except.map, bind, Except.bind] + cases t with + | field => cases expandType aliases .field <;> simp [pure, Except.pure, Except.map, bind, Except.bind, Pattern.map] + | tuple ts => cases expandType aliases (.tuple ts) <;> simp [pure, Except.pure, Except.map, bind, Except.bind, Pattern.map] + | array t n => cases expandType aliases (.array t n) <;> simp [pure, Except.pure, Except.map, bind, Except.bind, Pattern.map] + | ptr t => cases expandType aliases (.ptr t) <;> simp [pure, Except.pure, Except.map, bind, Except.bind, Pattern.map] + | param n => cases expandType aliases (.param n) <;> simp [pure, Except.pure, Except.map, bind, Except.bind, Pattern.map] + | named n ts => + cases found : aliases.find? (·.name == n) with + | none => + cases expandType aliases (.named n ts) <;> + simp [found, pure, Except.pure, Except.map, bind, Except.bind, Pattern.map] + | some d => + cases resolved : constructorType aliases d (if ts.isEmpty then none else some ts) <;> + simp only [found, resolved, pure, Except.pure, Except.map, bind, Except.bind, Pattern.map] + | constructAs params t c ps => + simp only [Pattern.map, expandPattern] + rw [children ps (by intros; simp only [Pattern.constructAs.sizeOf_spec]; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega)] + cases expandType aliases t <;> cases ps.mapM (expandPattern aliases) <;> + simp [Except.map, bind, Except.bind, pure, Except.pure, Pattern.map] +termination_by sizeOf pat +decreasing_by all_goals first | exact h q hq | exact hsize + +theorem checkExprTypes_map (enums aliases rigid) (f : α → β) (expr : Expr α) : + checkExprTypes enums aliases rigid (expr.map f) = checkExprTypes enums aliases rigid expr := by + have sub (x : Expr α) (hsize : sizeOf x < sizeOf expr) : + checkExprTypes enums aliases rigid (x.map f) = checkExprTypes enums aliases rigid x := + checkExprTypes_map enums aliases rigid f x + have children (xs : List (Expr α)) (h : ∀ x ∈ xs, sizeOf x < sizeOf expr) : + (xs.map (Expr.map f)).mapM (checkExprTypes enums aliases rigid) = + xs.mapM (checkExprTypes enums aliases rigid) := + traverse_same xs _ _ _ (fun x hx => checkExprTypes_map enums aliases rigid f x) + cases expr with + | literal | var | global => simp [Expr.map, checkExprTypes] + | builtin _ xs | update _ xs | record _ xs | tuple xs | array xs | construct _ _ _ xs | constructAs _ _ _ xs | call _ _ xs => + simp only [Expr.map, checkExprTypes] + rw [children xs (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega)] + | member x _ | control _ x | project x _ | index x _ | slice x _ _ | «repeat» x _ | store x | load x | hint _ x channel | neg x => + simp only [Expr.map, checkExprTypes, sub x (by simp_wf <;> omega)] + | letValue _ x b | binary _ x b => + simp only [Expr.map, checkExprTypes, checkPatternTypes_map, + sub x (by simp_wf <;> omega), sub b (by simp_wf <;> omega)] + | matchValue x arms => + simp only [Expr.map, checkExprTypes, sub x (by simp_wf <;> omega)] + congr 1 + funext _ + apply congrArg (fun v : Except String (List Unit) => v >>= fun _ => pure ()) + apply traverse_same + intro arm member + simp only [checkPatternTypes_map, + sub arm.2 (by have := List.sizeOf_lt_of_mem member; cases arm; simp_all [Prod.mk.sizeOf_spec]; omega)] +termination_by sizeOf expr +decreasing_by + all_goals first | exact h x hx | exact hsize + +theorem expandExpr_map (aliases) (f : α → β) (expr : Expr α) : + expandExpr aliases (expr.map f) = (expandExpr aliases expr).map (Expr.map f) := by + have sub (x : Expr α) (hsize : sizeOf x < sizeOf expr) : + expandExpr aliases (x.map f) = (expandExpr aliases x).map (Expr.map f) := + expandExpr_map aliases f x + have children (xs : List (Expr α)) (h : ∀ x ∈ xs, sizeOf x < sizeOf expr) : + (xs.map (Expr.map f)).mapM (expandExpr aliases) = + (xs.mapM (expandExpr aliases)).map (List.map (Expr.map f)) := + traverse_map xs _ _ _ _ (fun x hx => expandExpr_map aliases f x) + cases expr with + | literal | var | global => simp [Expr.map, expandExpr, map_pure] + | builtin _ xs | update _ xs | record _ xs | tuple xs | array xs | constructAs _ _ _ xs | call _ _ xs => + simp only [Expr.map, expandExpr] + rw [children xs (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega)] + all_goals simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map, Expr.map] + | construct n ts c xs => + simp only [Expr.map, expandExpr] + rw [children xs (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega)] + cases xs.mapM (expandExpr aliases) <;> simp only [Except.map, bind, Except.bind] + cases found : aliases.find? (·.name == n) with + | none => + cases ts.mapM (fun ts => ts.mapM (expandType aliases)) <;> + simp [found, pure, Except.pure, Except.map, bind, Except.bind, Expr.map] + | some d => + cases resolved : constructorType aliases d ts <;> + simp only [found, resolved, pure, Except.pure, Except.map, bind, Except.bind, Expr.map] + | member x _ | control _ x | project x _ | index x _ | slice x _ _ | «repeat» x _ | store x | load x | hint _ x channel | neg x => + simp only [Expr.map, expandExpr, sub x (by simp_wf <;> omega)] + all_goals simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map, Expr.map] + | letValue _ x b | binary _ x b => + simp only [Expr.map, expandExpr, expandPattern_map, + sub x (by simp_wf <;> omega), sub b (by simp_wf <;> omega)] + all_goals simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map, Expr.map] + | matchValue x arms => + have mapped := traverse_map arms + (fun arm => (arm.1.map f, arm.2.map f)) + (fun arm : Pattern α × Expr α => (arm.1.map f, arm.2.map f)) + (fun arm => do return (← expandPattern aliases arm.1, ← expandExpr aliases arm.2)) + (fun arm => do return (← expandPattern aliases arm.1, ← expandExpr aliases arm.2)) + (by + intro arm member + simp only [expandPattern_map, + sub arm.2 (by have := List.sizeOf_lt_of_mem member; cases arm; simp_all [Prod.mk.sizeOf_spec]; omega)] + simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map]) + simp only [Expr.map, expandExpr, sub x (by simp_wf <;> omega), mapped] + simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map, Expr.map] +termination_by sizeOf expr +decreasing_by + all_goals first | exact h x hx | exact hsize + +theorem expandFunction_map (enums raw aliases) (f : α → β) (fn : Function α) : + expandFunction enums raw aliases { fn with body := fn.body.map f } = + (expandFunction enums raw aliases fn).map (fun fn => { fn with body := fn.body.map f }) := by + simp only [expandFunction, checkExprTypes_map, expandExpr_map] + simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map] + +theorem expandTable_map (enums raw aliases) (f : α → β) (table : Table α) : + expandTable enums raw aliases { table with rows := table.rows.map (Expr.map f) } = + (expandTable enums raw aliases table).map (fun t => { t with rows := t.rows.map (Expr.map f) }) := by + have checked := traverse_same table.rows (Expr.map f) + (checkExprTypes enums raw []) (checkExprTypes enums raw []) + (fun x _ => checkExprTypes_map enums raw [] f x) + have expanded := traverse_map table.rows (Expr.map f) (Expr.map f) + (expandExpr aliases) (expandExpr aliases) (fun x _ => expandExpr_map aliases f x) + simp only [expandTable, checked, expanded] + simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map] + +theorem expandConst_map (enums raw aliases) (f : α → β) (d : ConstDecl α) : + expandConst enums raw aliases (d.map f) = (expandConst enums raw aliases d).map (ConstDecl.map f) := by + simp only [expandConst, ConstDecl.map, checkPatternTypes_map, expandPattern_map] + simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map, ConstDecl.map] + +theorem expandProgram_map (aliases) (f : α → β) (p : Program α) : + expandProgram aliases (p.map f) = (expandProgram aliases p).map (Program.map f) := by + have functions := traverse_map p.functions + (fun fn => { fn with body := fn.body.map f }) (fun fn => { fn with body := fn.body.map f }) + (expandFunction p.nominals p.aliases aliases) (expandFunction p.nominals p.aliases aliases) + (fun fn _ => expandFunction_map p.nominals p.aliases aliases f fn) + have tables := traverse_map p.tables + (fun t => { t with rows := t.rows.map (Expr.map f) }) (fun t => { t with rows := t.rows.map (Expr.map f) }) + (expandTable p.nominals p.aliases aliases) (expandTable p.nominals p.aliases aliases) + (fun t _ => expandTable_map p.nominals p.aliases aliases f t) + have consts := traverse_map p.consts (ConstDecl.map f) (ConstDecl.map f) + (expandConst p.nominals p.aliases aliases) (expandConst p.nominals p.aliases aliases) + (fun d _ => expandConst_map p.nominals p.aliases aliases f d) + change expandProgram aliases { p with functions := p.functions.map (fun fn => { fn with body := fn.body.map f }), tables := p.tables.map (fun t => { t with rows := t.rows.map (Expr.map f) }), consts := p.consts.map (ConstDecl.map f) } = _ + simp only [expandProgram, Program.nominals, Program.map] at functions tables consts ⊢ + rw [functions, tables, consts] + simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map, Program.map] + +end Aliases + +/-- Alias expansion depends only on types and names, not on literal values. -/ +theorem expandAliases_map (f : α → β) (p : Program α) : + expandAliases (p.map f) = (expandAliases p).map (Program.map f) := by + have resolved : Aliases.resolveDeclarations (p.map f) = Aliases.resolveDeclarations p := rfl + simp only [expandAliases, resolved, Aliases.expandProgram_map] + cases Aliases.resolveDeclarations p <;> rfl + +/-- Choosing a field after alias expansion gives exactly the same AST as +expanding after literal conversion, with the same expansion errors. -/ +theorem expandAliases_toField (p : Program Nat) (F : Type) [NatCast F] : + expandAliases (p.toField F) = (expandAliases p).map (fun q => q.toField F) := + expandAliases_map Nat.cast p + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/Aliases.lean b/Aiur/Aiur/Generic/Aliases.lean new file mode 100644 index 000000000..989829faa --- /dev/null +++ b/Aiur/Aiur/Generic/Aliases.lean @@ -0,0 +1,308 @@ +import Aiur.Generic.Lower + +/-! Transparent aliases are eliminated before generic inference, independently +of the representation of literals. Declaration templates are expanded once in +dependency order; nominal enum definitions are not unfolded. -/ + +namespace Aiur.Generic + +def checkIdentifier (name : String) : Except String Unit := + if name.isEmpty || name.contains '$' then throw "empty or reserved identifier" else pure () + +def checkParams (params : List String) : Except String Unit := do + if let some n := findDuplicate params [] then throw s!"duplicate type parameter '{n}'" + for n in params do + checkIdentifier n + if n == "Field" then throw "Field is a reserved type name" + +/-- Arrays are unrolled into finite tuples; reject unreasonable requests before allocation. -/ +def checkArrayLength (length : Nat) : Except String Unit := + if length > 65536 then throw "array length limit exceeded (65536)" else pure () + +namespace Aliases + +/-- Names in a type expression, including nominal enum arguments, but without +visiting enum definitions. Used to order alias declarations, not instances. -/ +def dependencies : Ty → List String + | .field | .param _ => [] + | .ptr t | .array t _ => dependencies t + | .tuple ts => ts.flatMap dependencies + | .named n ts => n :: ts.flatMap dependencies +termination_by t => sizeOf t + +def checkSurfaceType (enums : List EnumDecl) (aliases : List AliasDecl) (params : List String) : Ty → Except String Unit + | .field => pure () + | .param n => if params.contains n then pure () else throw s!"unbound type parameter '{n}'" + | .ptr t => checkSurfaceType enums aliases params t + | .array t n => do checkArrayLength n; checkSurfaceType enums aliases params t + | .tuple ts => do + for t in ts do checkSurfaceType enums aliases params t + | .named n ts => do + let binders ← match aliases.find? (·.name == n) with + | some d => pure d.typeParams + | none => match enums.find? (·.name == n) with + | some d => pure d.typeParams + | none => throw s!"unknown type '{n}'" + let _ ← arguments binders ts + for t in ts do checkSurfaceType enums aliases params t +termination_by t => sizeOf t + +/-- `aliases` contains already expanded templates. Actual arguments are +expanded before simultaneous substitution, so `Id>` is finite. -/ +def expandType (aliases : List AliasDecl) : Ty → Except String Ty + | .field => pure .field + | .param n => pure (.param n) + | .ptr t => return .ptr (← expandType aliases t) + | .array t n => return .array (← expandType aliases t) n + | .tuple ts => return .tuple (← ts.mapM (expandType aliases)) + | .named n ts => do + let ts ← ts.mapM (expandType aliases) + match aliases.find? (·.name == n) with + | none => return .named n ts + | some d => + let env ← arguments d.typeParams ts + let t := d.target.subst env + if t.nodes > 65536 then throw "alias expansion type-size limit exceeded" + return t +termination_by t => sizeOf t + +private def resolve (decls : List AliasDecl) : + Nat → List String → String → StateT (List AliasDecl) (Except String) Unit + | 0, _, _ => throw "alias dependency depth exceeded" + | fuel + 1, path, name => do + if path.contains name then + throw s!"cyclic type alias: {String.intercalate " -> " (path.reverse ++ [name])}" + if (← get).any (·.name == name) then return + let some d := decls.find? (·.name == name) | return + for dep in (dependencies d.target).eraseDups do + if decls.any (·.name == dep) then resolve decls fuel (name :: path) dep + let target ← liftM (expandType (← get) d.target) + modify (· ++ [{ d with target }]) + +/-- All declarations are checked, including unused aliases and arguments that +an alias erases. Aliases and enums share a namespace. Cycles through pointers +are rejected; recursion through a nominal enum remains available. -/ +def resolveDeclarations (p : Program α) : Except String (List AliasDecl) := do + if let some n := findDuplicate (p.nominals.map (·.name) ++ p.aliases.map (·.name)) [] then + throw s!"duplicate type '{n}'" + for d in p.aliases do + checkIdentifier d.name + if d.name == "Field" then throw "Field is a reserved type name" + checkParams d.typeParams + checkSurfaceType p.nominals p.aliases d.typeParams d.target + let (_, aliases) ← (p.aliases.forM fun d => resolve p.aliases (p.aliases.length + 1) [] d.name).run [] + return aliases + +/-- Omitted alias arguments become bound inference slots in the expanded +template. Explicit arguments are checked and substituted before inference. -/ +def constructorType (aliases : List AliasDecl) (d : AliasDecl) + (supplied : Option (List Ty)) : Except String (List String × Ty) := do + match supplied with + | none => return (d.typeParams, d.target) + | some ts => + let ts ← ts.mapM (expandType aliases) + let env ← arguments d.typeParams ts + return ([], d.target.subst env) + +def expandRecordHead (aliases : List AliasDecl) (head : RecordHead) : Except String RecordHead := do + if let .named name args := head.type then + if let some decl := aliases.find? (·.name == name) then + let (params, type) ← constructorType aliases decl (if args.isEmpty then none else some args) + return { head with params, type } + return { head with type := ← expandType aliases head.type } + +def expandPattern (aliases : List AliasDecl) : Pattern α → Except String (Pattern α) + | .literal x => pure (.literal x) + | .wildcard => pure .wildcard + | .bind n => pure (.bind n) + | .global n t => pure (.global n t) + | .record head ps => return .record (← expandRecordHead aliases head) (← ps.mapM (expandPattern aliases)) + | .orElse left right names => return .orElse (← expandPattern aliases left) (← expandPattern aliases right) names + | .load p => return .load (← expandPattern aliases p) + | .tuple ps => return .tuple (← ps.mapM (expandPattern aliases)) + | .array ps => return .array (← ps.mapM (expandPattern aliases)) + | .repeat p n => return .repeat (← expandPattern aliases p) n + | .construct t c ps => do + let ps ← ps.mapM (expandPattern aliases) + if let .named n ts := t then + if let some d := aliases.find? (·.name == n) then + let (params, target) ← constructorType aliases d (if ts.isEmpty then none else some ts) + return .constructAs params target c ps + return .construct (← expandType aliases t) c ps + | .constructAs params t c ps => + return .constructAs params (← expandType aliases t) c (← ps.mapM (expandPattern aliases)) +termination_by p => sizeOf p + +def expandExpr (aliases : List AliasDecl) : Expr α → Except String (Expr α) + | .control kind body => return .control kind (← expandExpr aliases body) + | .literal x => pure (.literal x) + | .var n => pure (.var n) + | .global n t => pure (.global n t) + | .tuple xs => return .tuple (← xs.mapM (expandExpr aliases)) + | .array xs => return .array (← xs.mapM (expandExpr aliases)) + | .repeat x n => return .repeat (← expandExpr aliases x) n + | .index x i => return .index (← expandExpr aliases x) i + | .slice x start stop => return .slice (← expandExpr aliases x) start stop + | .construct n ts c xs => do + let xs ← xs.mapM (expandExpr aliases) + if let some d := aliases.find? (·.name == n) then + let (params, target) ← constructorType aliases d ts + return .constructAs params target c xs + return .construct n (← ts.mapM (fun ts => ts.mapM (expandType aliases))) c xs + | .constructAs params t c xs => + return .constructAs params (← expandType aliases t) c (← xs.mapM (expandExpr aliases)) + | .builtin op xs => return .builtin (← op.mapTypesM (expandType aliases)) (← xs.mapM (expandExpr aliases)) + | .update paths xs => do + let paths ← paths.mapM fun path => path.mapM fun step => match step with + | .member field => return .member { field with owner := ← field.owner.mapM (expandType aliases) } + | step => pure step + return .update paths (← xs.mapM (expandExpr aliases)) + | .record head xs => return .record (← expandRecordHead aliases head) (← xs.mapM (expandExpr aliases)) + | .member x field => return .member (← expandExpr aliases x) { field with owner := ← field.owner.mapM (expandType aliases) } + | .project x i => return .project (← expandExpr aliases x) i + | .letValue pat x b => return .letValue (← expandPattern aliases pat) (← expandExpr aliases x) (← expandExpr aliases b) + | .store x => return .store (← expandExpr aliases x) + | .load x => return .load (← expandExpr aliases x) + | .hint t k channel => return .hint (← expandType aliases t) (← expandExpr aliases k) channel + | .neg x => return .neg (← expandExpr aliases x) + | .binary op x y => return .binary op (← expandExpr aliases x) (← expandExpr aliases y) + | .call n ts xs => + return .call n (← ts.mapM (fun ts => ts.mapM (expandType aliases))) (← xs.mapM (expandExpr aliases)) + | .matchValue x arms => + return .matchValue (← expandExpr aliases x) + (← arms.mapM fun arm => return (← expandPattern aliases arm.1, ← expandExpr aliases arm.2)) +termination_by e => sizeOf e +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; try simp_all only [Prod.mk.sizeOf_spec] + all_goals first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +/-- Check written type arguments before an alias can discard them. Inferred +constructor arguments remain the responsibility of generic elaboration. -/ +def checkPatternHead (enums : List EnumDecl) (aliases : List AliasDecl) (rigid : List String) + (t : Ty) : Except String Unit := + match t with + | .named _ [] => pure () + | _ => checkSurfaceType enums aliases rigid t + +def checkPatternTypes (enums : List EnumDecl) (aliases : List AliasDecl) (rigid : List String) : Pattern α → Except String Unit + | .literal _ | .wildcard | .bind _ | .global _ _ => pure () + | .orElse left right _ => do + checkPatternTypes enums aliases rigid left + checkPatternTypes enums aliases rigid right + | .load p | .repeat p _ => checkPatternTypes enums aliases rigid p + | .tuple ps | .array ps => do + let _ ← ps.mapM (checkPatternTypes enums aliases rigid) + pure () + | .record head ps => do + checkPatternHead enums aliases (head.params ++ rigid) head.type + let _ ← ps.mapM (checkPatternTypes enums aliases rigid) + pure () + | .construct t _ ps => do + checkPatternHead enums aliases rigid t + let _ ← ps.mapM (checkPatternTypes enums aliases rigid) + pure () + | .constructAs params t _ ps => do + checkSurfaceType enums aliases (params ++ rigid) t + let _ ← ps.mapM (checkPatternTypes enums aliases rigid) + pure () +termination_by pat => sizeOf pat + +def checkExprTypes (enums : List EnumDecl) (aliases : List AliasDecl) (rigid : List String) : Expr α → Except String Unit + | .literal _ | .var _ | .global _ _ => pure () + | .builtin op xs => do + op.types.forM (checkSurfaceType enums aliases rigid) + let _ ← xs.mapM (checkExprTypes enums aliases rigid) + pure () + | .update _ xs | .tuple xs | .array xs => do + let _ ← xs.mapM (checkExprTypes enums aliases rigid) + pure () + | .record head xs => do + checkPatternHead enums aliases (head.params ++ rigid) head.type + let _ ← xs.mapM (checkExprTypes enums aliases rigid) + pure () + | .member x field => do + field.owner.toList.forM (checkSurfaceType enums aliases rigid) + checkExprTypes enums aliases rigid x + | .construct _ ts _ xs | .call _ ts xs => do + (ts.getD []).forM (checkSurfaceType enums aliases rigid) + let _ ← xs.mapM (checkExprTypes enums aliases rigid) + pure () + | .constructAs params t _ xs => do + checkSurfaceType enums aliases (params ++ rigid) t + let _ ← xs.mapM (checkExprTypes enums aliases rigid) + pure () + | .control _ x | .project x _ | .index x _ | .slice x _ _ | .repeat x _ | .store x | .load x | .neg x => checkExprTypes enums aliases rigid x + | .hint t x channel => do checkSurfaceType enums aliases rigid t; checkExprTypes enums aliases rigid x + | .letValue pat x b => do + checkPatternTypes enums aliases rigid pat + checkExprTypes enums aliases rigid x + checkExprTypes enums aliases rigid b + | .binary _ x y => do checkExprTypes enums aliases rigid x; checkExprTypes enums aliases rigid y + | .matchValue x arms => do + checkExprTypes enums aliases rigid x + let _ ← arms.mapM fun arm => do + checkPatternTypes enums aliases rigid arm.1 + checkExprTypes enums aliases rigid arm.2 + pure () +termination_by e => sizeOf e +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; try simp_all only [Prod.mk.sizeOf_spec] + all_goals first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +def expandFunction (enums : List EnumDecl) (raw aliases : List AliasDecl) + (fn : Function α) : Except String (Function α) := do + (fn.params.map Prod.snd ++ [fn.result]).forM (checkSurfaceType enums raw fn.typeParams) + checkExprTypes enums raw fn.typeParams fn.body + return { fn with + params := ← fn.params.mapM (fun (n, t) => return (n, ← expandType aliases t)) + result := ← expandType aliases fn.result + body := ← expandExpr aliases fn.body } + +def expandEnum (enums : List EnumDecl) (raw aliases : List AliasDecl) + (d : EnumDecl) : Except String EnumDecl := do + return { d with constructors := ← d.constructors.mapM fun c => do + c.fields.forM (checkSurfaceType enums raw d.typeParams) + return { c with fields := ← c.fields.mapM (expandType aliases) } } + +def expandTable (enums : List EnumDecl) (raw aliases : List AliasDecl) + (t : Table α) : Except String (Table α) := do + checkSurfaceType enums raw [] t.rowType + let _ ← t.rows.mapM (checkExprTypes enums raw []) + return { t with rowType := ← expandType aliases t.rowType, rows := ← t.rows.mapM (expandExpr aliases) } + +def expandMap (enums : List EnumDecl) (raw aliases : List AliasDecl) + (m : MapDecl) : Except String MapDecl := do + (m.params.map Prod.snd ++ [m.result]).forM (checkSurfaceType enums raw []) + return { m with + params := ← m.params.mapM (fun (n, t) => return (n, ← expandType aliases t)) + result := ← expandType aliases m.result } + +def expandConst (enums : List EnumDecl) (raw aliases : List AliasDecl) + (d : ConstDecl α) : Except String (ConstDecl α) := do + checkPatternTypes enums raw [] d.value + return { d with value := ← expandPattern aliases d.value } + +def expandProgram (aliases : List AliasDecl) (p : Program α) : Except String (Program α) := do + let functions ← p.functions.mapM (expandFunction p.nominals p.aliases aliases) + let enums ← p.enums.mapM (expandEnum p.nominals p.aliases aliases) + let tables ← p.tables.mapM (expandTable p.nominals p.aliases aliases) + let maps ← p.maps.mapM (expandMap p.nominals p.aliases aliases) + let consts ← p.consts.mapM (expandConst p.nominals p.aliases aliases) + let structs ← p.structs.mapM fun decl => do + let fields ← decl.fields.mapM fun (name, type) => do + checkSurfaceType p.nominals p.aliases decl.typeParams type + return (name, ← expandType aliases type) + return { decl with fields } + return { functions, enums, structs, tables, maps, aliases := [], consts } + +end Aliases + +/-- Run before type inference. The string frontend invokes this while literals +are `Nat`; programmatically constructed ASTs use the same pass for any `α`. -/ +def expandAliases (p : Program α) : Except String (Program α) := do + let aliases ← Aliases.resolveDeclarations p + Aliases.expandProgram aliases p + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/ArrayFacts.lean b/Aiur/Aiur/Generic/ArrayFacts.lean new file mode 100644 index 000000000..52fad7c6f --- /dev/null +++ b/Aiur/Aiur/Generic/ArrayFacts.lean @@ -0,0 +1,140 @@ +import Aiur.Generic.Lower +import Aiur.Generic.OpenCore + +namespace Aiur.Generic + +variable {calls : CallRelation F} + + +@[simp] theorem array_toCore (element : Ty) (length : Nat) : + (Ty.array element length).toCore = .tuple (List.replicate length element.toCore) := by rw [Ty.toCore] + +@[simp] theorem lower_array (env) (items : List (Expr α)) : + (Expr.array items).lower env = .tuple (items.map (Expr.lower env)) := by rw [Expr.lower] + +@[simp] theorem lower_index (env) (value : Expr α) (index : Nat) : + (Expr.index value index).lower env = .project (value.lower env) index := by rw [Expr.lower] + +@[simp] theorem lower_repeat (env) (value : Expr α) (length : Nat) : + (Expr.repeat value length).lower env = ArrayLowering.repeatValue (value.lower env) length := by rw [Expr.lower] + +@[simp] theorem lower_slice (env) (value : Expr α) (start stop : Nat) : + (Expr.slice value start (some stop)).lower env = ArrayLowering.sliceValue (value.lower env) start stop := by rw [Expr.lower] + +namespace ArrayLowering +variable [Field F] [DecidableEq F] {world : Engine.World F} + +theorem repeatArgs_iff {locals : Environment F Nat} {name : String} {value : SourceValue F} + {length : Nat} {before after : Heap F} {values : List (SourceValue F)} : + OpenCore.EvalArgs world calls ((name, value) :: locals) (List.replicate length (.var name)) before values after ↔ + values = List.replicate length value ∧ after = before := by + induction length generalizing before values with + | zero => + constructor + · intro h; cases h; exact ⟨rfl, rfl⟩ + · rintro ⟨rfl, rfl⟩; exact .nil + | succ length ih => + constructor + · intro h + cases h with + | cons head tail => + cases head with + | var lookup => + simp only [List.find?_cons, beq_self_eq_true, + Option.some.injEq, Prod.mk.injEq, true_and] at lookup + cases lookup + obtain ⟨rfl, rfl⟩ := ih.mp tail + exact ⟨rfl, rfl⟩ + · rintro ⟨rfl, rfl⟩ + exact .cons (.var (by simp)) (ih.mpr ⟨rfl, rfl⟩) + +/-- Repetition executes its operand exactly once, sharing any allocated pointers +and nondeterministic result. This includes length zero and preserves the heap. -/ +theorem repeatValue_iff {locals : Environment F Nat} {operand : Aiur.Expr F} + {length : Nat} {before after : Heap F} {result : SourceValue F} : + OpenCore.EvalExpr world calls locals (repeatValue operand length) before result after ↔ + ∃ value, OpenCore.EvalExpr world calls locals operand before value after ∧ + result = .tuple (List.replicate length value) := by + constructor + · intro h + cases h with + | letValue value matched body => + simp only [Aiur.Pattern.bindings, Option.some.injEq] at matched + subst_vars + cases body with + | tuple items => + obtain ⟨rfl, rfl⟩ := repeatArgs_iff.mp items + exact ⟨_, value, rfl⟩ + · rintro ⟨value, evaluated, rfl⟩ + exact .letValue (bindings := [("$array", value)]) evaluated (by simp [Aiur.Pattern.bindings]) + (.tuple (repeatArgs_iff.mpr ⟨rfl, rfl⟩)) + +theorem projectArgs_iff {locals : Environment F Nat} {name : String} {value : SourceValue F} + {indices : List Nat} {before after : Heap F} {values : List (SourceValue F)} : + OpenCore.EvalArgs world calls ((name, value) :: locals) + (indices.map (fun i => .project (.var name) i)) before values after ↔ + indices.mapM (projectValue value) = .ok values ∧ after = before := by + induction indices generalizing before values with + | nil => + constructor + · intro h; cases h; exact ⟨rfl, rfl⟩ + · rintro ⟨h, rfl⟩ + have : values = [] := by simpa [pure, Except.pure] using h.symm + subst values + exact .nil + | cons index indices ih => + constructor + · intro h + cases h with + | cons head tail => + cases head with + | project expr projected => + cases expr with + | var lookup => + simp only [List.find?_cons, beq_self_eq_true, + Option.some.injEq, Prod.mk.injEq, true_and] at lookup + cases lookup + obtain ⟨rest, rfl⟩ := ih.mp tail + exact ⟨by simp [List.mapM_cons, projected, rest, bind, Except.bind, pure, Except.pure], rfl⟩ + · rintro ⟨h, rfl⟩ + cases projected : projectValue value index with + | error e => simp [List.mapM_cons, projected, bind, Except.bind, pure, Except.pure] at h + | ok head => + cases rest : indices.mapM (projectValue value) with + | error e => simp [List.mapM_cons, projected, rest, bind, Except.bind, pure, Except.pure] at h + | ok tail => + have : values = head :: tail := by simpa [List.mapM_cons, projected, rest, bind, Except.bind, pure, Except.pure] using h.symm + subst values + exact .cons (.project (.var (by simp)) projected) (ih.mpr ⟨rest, rfl⟩) + +/-- A slice evaluates the array once, then takes only the chosen fixed indices. +The projection sequence itself leaves the heap unchanged, including empty slices. -/ +theorem sliceValue_iff {locals : Environment F Nat} {operand : Aiur.Expr F} + {start stop : Nat} {before after : Heap F} {result : SourceValue F} : + OpenCore.EvalExpr world calls locals (sliceValue operand start stop) before result after ↔ + ∃ value values, OpenCore.EvalExpr world calls locals operand before value after ∧ + ((List.range (stop - start)).map (start + ·)).mapM (projectValue value) = .ok values ∧ + result = .tuple values := by + have indices : ((List.range (stop - start)).map (start + ·)).map + (fun i => (Aiur.Expr.project (.var "$array") i : Aiur.Expr F)) = + (List.range (stop - start)).map (fun i => .project (.var "$array") (start + i)) := by + simp only [List.map_map, Function.comp_def] + constructor + · intro h + cases h with + | letValue value matched body => + simp only [Aiur.Pattern.bindings, Option.some.injEq] at matched + subst_vars + cases body with + | tuple items => + rw [← indices] at items + obtain ⟨projected, rfl⟩ := projectArgs_iff.mp items + exact ⟨_, _, value, projected, rfl⟩ + · rintro ⟨value, values, evaluated, projected, rfl⟩ + apply OpenCore.EvalExpr.letValue (bindings := [("$array", value)]) evaluated (by simp [Aiur.Pattern.bindings]) + apply OpenCore.EvalExpr.tuple + rw [← indices] + exact projectArgs_iff.mpr ⟨projected, rfl⟩ + +end ArrayLowering +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/ArrayLowering.lean b/Aiur/Aiur/Generic/ArrayLowering.lean new file mode 100644 index 000000000..ae191a936 --- /dev/null +++ b/Aiur/Aiur/Generic/ArrayLowering.lean @@ -0,0 +1,19 @@ +import Aiur.Generic.AST + +/-! Late circuit lowering uses the core's tuple representation. The only bodies under these +generated bindings are generated variable references and projections, so they +cannot capture names in the operand, even in programmatically built ASTs. -/ + +namespace Aiur.Generic.ArrayLowering + +/-- Copy a value, not its computation. A zero repeat still evaluates `value`. -/ +def repeatValue (value : Aiur.Expr α) (length : Nat) : Aiur.Expr α := + .letValue (.bind "$array") value (.tuple (List.replicate length (.var "$array"))) + +/-- The caller has checked `start ≤ stop ≤ length`. An empty slice still +evaluates its operand. The projections add no calls, loads, or auxiliary columns. -/ +def sliceValue (value : Aiur.Expr α) (start stop : Nat) : Aiur.Expr α := + .letValue (.bind "$array") value + (.tuple ((List.range (stop - start)).map fun i => .project (.var "$array") (start + i))) + +end Aiur.Generic.ArrayLowering diff --git a/Aiur/Aiur/Generic/BindingOrderFacts.lean b/Aiur/Aiur/Generic/BindingOrderFacts.lean new file mode 100644 index 000000000..b8dbcac9f --- /dev/null +++ b/Aiur/Aiur/Generic/BindingOrderFacts.lean @@ -0,0 +1,97 @@ +import Aiur.Generic.AST +import Mathlib.Data.List.Forall2 + +namespace Aiur.Generic + +/-- Binding layouts determine names even for unchecked patterns. -/ +theorem reorderBindings_names {names positions} {bindings result : List (String × V)} + (ordered : reorderBindings names positions bindings = some result) : + result.map Prod.fst = names := by + induction names generalizing positions result with + | nil => cases positions <;> simp_all [reorderBindings] + | cons name names ih => + cases positions with + | nil => simp [reorderBindings] at ordered + | cons index positions => + cases found : bindings[index]? with + | none => simp [reorderBindings, found] at ordered + | some pair => + cases tail : reorderBindings names positions bindings with + | none => simp [reorderBindings, found, tail] at ordered + | some rest => + simp [reorderBindings, found, tail] at ordered + subst result + simp only [List.map_cons, ih tail] + +/-- Pattern renaming changes names, while recorded positions stay fixed. -/ +theorem reorderBindings_rename (rename : String → String) (names positions) + (bindings : List (String × V)) : + reorderBindings (names.map rename) positions + (bindings.map fun pair => (rename pair.1, pair.2)) = + (reorderBindings names positions bindings).map + (List.map fun pair => (rename pair.1, pair.2)) := by + induction names generalizing positions with + | nil => cases positions <;> rfl + | cons name names ih => + cases positions with + | nil => rfl + | cons index positions => + simp only [List.map_cons, reorderBindings, List.getElem?_map, ih] + cases bindings[index]? <;> cases reorderBindings names positions bindings <;> rfl + +/-- Changing only selected output names commutes with gathering values. -/ +theorem reorderBindings_mapNames (rename : String → String) (names positions) + (bindings : List (String × V)) : + reorderBindings (names.map rename) positions bindings = + (reorderBindings names positions bindings).map + (List.map fun pair => (rename pair.1, pair.2)) := by + induction names generalizing positions with + | nil => cases positions <;> rfl + | cons name names ih => + cases positions with + | nil => rfl + | cons index positions => + simp only [List.map_cons, reorderBindings, ih] + cases bindings[index]? <;> cases reorderBindings names positions bindings <;> rfl + +/-- Applying a value operation commutes with positional binding alignment. -/ +theorem reorderBindings_mapValues (f : V → W) (names positions) + (bindings : List (String × V)) : + reorderBindings names positions (bindings.map fun pair => (pair.1, f pair.2)) = + (reorderBindings names positions bindings).map + (List.map fun pair => (pair.1, f pair.2)) := by + induction names generalizing positions with + | nil => cases positions <;> rfl + | cons name names ih => + cases positions with + | nil => rfl + | cons index positions => + simp only [reorderBindings, List.getElem?_map, ih] + cases bindings[index]? <;> cases reorderBindings names positions bindings <;> rfl + +theorem reorderBindings_good {P : V → Prop} {names positions} + {bindings result : List (String × V)} + (good : ∀ b ∈ bindings, P b.2) + (ordered : reorderBindings names positions bindings = some result) : + ∀ b ∈ result, P b.2 := by + induction names generalizing positions result with + | nil => + cases positions <;> simp_all [reorderBindings] + | cons name names ih => + cases positions with + | nil => simp [reorderBindings] at ordered + | cons index positions => + cases found : bindings[index]? with + | none => simp [reorderBindings, found] at ordered + | some pair => + cases tail : reorderBindings names positions bindings with + | none => simp [reorderBindings, found, tail] at ordered + | some rest => + simp [reorderBindings, found, tail] at ordered + subst result + intro b member + rcases List.mem_cons.mp member with rfl | member + · exact good pair (List.mem_of_getElem? found) + · exact ih tail b member + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/Builtin.lean b/Aiur/Aiur/Generic/Builtin.lean new file mode 100644 index 000000000..0dc6a7ff2 --- /dev/null +++ b/Aiur/Aiur/Generic/Builtin.lean @@ -0,0 +1,21 @@ +import Aiur.Generic.AST +import Aiur.Runtime + +namespace Aiur.Generic + +/-- Type annotations have no runtime test. Debug output is executor-only; +evaluating its arguments is part of the ordinary source semantics. -/ +def Builtin.apply [DecidableEq F] (op : Builtin) (values : List (SourceValue F)) : Except EvalError (SourceValue F) := + match op with + | .ascribe _ => match values with + | [value] => .ok value + | _ => .error (.arityMismatch "type annotation" 1 values.length) + | .debug _ => .ok (.tuple []) + | .assertEq message => match values with + | [left, right] => evalAssertEq message left right + | _ => .error (.arityMismatch "assert_eq!" 2 values.length) + +@[simp] theorem Builtin.apply_subst [DecidableEq F] (op : Builtin) (types) (values : List (SourceValue F)) : + (op.subst types).apply values = op.apply values := by cases op <;> rfl + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/BuiltinFacts.lean b/Aiur/Aiur/Generic/BuiltinFacts.lean new file mode 100644 index 000000000..e2c2a9be4 --- /dev/null +++ b/Aiur/Aiur/Generic/BuiltinFacts.lean @@ -0,0 +1,107 @@ +import Aiur.Generic.Builtin +import Aiur.Generic.Lower +import Aiur.Generic.OpenCore + +namespace Aiur.Generic.BuiltinLowering + +variable [Field F] [DecidableEq F] {world : Engine.World F} {calls : CallRelation F} + +/-- Late compilation preserves operand evaluation, including heap effects. +Debug messages themselves impose no additional premise or constraint. -/ +theorem expression_iff {op : Builtin} {operands : List (Aiur.Expr F)} : + OpenCore.EvalExpr world calls locals (expression op operands) before result after ↔ + ∃ values, OpenCore.EvalArgs world calls locals operands before values after ∧ + op.apply values = .ok result := by + cases op with + | assertEq message => + constructor + · intro h + cases h with + | letValue value matched body => + cases value with + | tuple items => + rename_i values + cases values with + | nil => simp [Aiur.Pattern.bindings, Aiur.Pattern.bindingsList] at matched + | cons left rest => + cases rest with + | nil => simp [Aiur.Pattern.bindings, Aiur.Pattern.bindingsList] at matched + | cons right rest => + cases rest with + | cons => simp [Aiur.Pattern.bindings, Aiur.Pattern.bindingsList] at matched + | nil => + simp [Aiur.Pattern.bindings, Aiur.Pattern.bindingsList] at matched + subst_vars + cases body with + | assertEq lhs rhs applied => + cases lhs with + | var found => + simp at found + subst_vars + cases rhs with + | var found => + simp at found + subst_vars + exact ⟨_, items, applied⟩ + · rintro ⟨values, items, applied⟩ + cases values with + | nil => simp [Builtin.apply] at applied + | cons left rest => + cases rest with + | nil => simp [Builtin.apply] at applied + | cons right rest => + cases rest with + | cons => simp [Builtin.apply] at applied + | nil => + exact .letValue (bindings := [("$assertLeft", left), ("$assertRight", right)]) + (.tuple items) (by simp [Aiur.Pattern.bindings, Aiur.Pattern.bindingsList]) + (.assertEq (.var (by simp)) (.var (by simp)) applied) + | ascribe type => + constructor + · intro h + cases h with + | letValue value matched body => + cases value with + | tuple items => + rename_i values + cases values with + | nil => simp [Aiur.Pattern.bindings, Aiur.Pattern.bindingsList] at matched + | cons value rest => + cases rest with + | cons => simp [Aiur.Pattern.bindings, Aiur.Pattern.bindingsList] at matched + | nil => + simp [Aiur.Pattern.bindings, Aiur.Pattern.bindingsList] at matched + subst_vars + cases body with + | var lookup => + simp at lookup + subst_vars + exact ⟨_, items, rfl⟩ + · rintro ⟨values, items, applied⟩ + cases values with + | nil => simp [Builtin.apply] at applied + | cons value rest => + cases rest with + | cons => simp [Builtin.apply] at applied + | nil => + simp only [Builtin.apply, Except.ok.injEq] at applied + subst result + exact .letValue (bindings := [("$annotation", value)]) (.tuple items) (by simp [Aiur.Pattern.bindings, Aiur.Pattern.bindingsList]) + (.var (by simp)) + | debug message => + constructor + · intro h + cases h with + | letValue value matched body => + cases value with + | tuple items => + simp only [Aiur.Pattern.bindings, Option.some.injEq] at matched + subst_vars + cases body with + | tuple result => cases result; exact ⟨_, items, rfl⟩ + · rintro ⟨values, items, applied⟩ + simp only [Builtin.apply, Except.ok.injEq] at applied + subst result + exact .letValue (bindings := []) (.tuple items) (by simp [Aiur.Pattern.bindings]) (.tuple .nil) + +end Aiur.Generic.BuiltinLowering diff --git a/Aiur/Aiur/Generic/Circuit.lean b/Aiur/Aiur/Generic/Circuit.lean new file mode 100644 index 000000000..873ce46e2 --- /dev/null +++ b/Aiur/Aiur/Generic/Circuit.lean @@ -0,0 +1,167 @@ +import Aiur.Generic.Correctness +import Aiur.CheckerCorrectness +import Aiur.Circuit.Stats +import Aiur.Inlining.Program + +namespace Aiur.Generic + +variable {F : Type} [Field F] [DecidableEq F] +variable {s : Source F} {entries : List String} + +/-- The original declaration controls every concrete instance of a helper. -/ +def Specialized.inlineNames (q : Specialized s entries) : List String := + q.program.functions.filterMap fun f => + match Instance.ofSymbol f.name with + | .error _ => none + | .ok key => if (s.program.findFunction? key.name).any (·.isInline) then some f.name else none + +structure Compiled (q : Specialized s entries) where + inlined : Inlining.Prepared q.program q.inlineNames entries + system : Aiur.Circuit.System F + compiled : Aiur.Circuit.compile inlined.program = .ok system + +/-- The program actually passed to chip compilation, after mandatory inlining. -/ +def Compiled.program {q : Specialized s entries} (c : Compiled q) : Aiur.Program F := c.inlined.program + +def Specialized.compile (q : Specialized s entries) : Except String (Compiled q) := do + let inlined ← Inlining.prepare q.program q.inlineNames entries + match h : Aiur.Circuit.compile inlined.program with + | .error e => .error (reprStr e) + | .ok system => .ok ⟨inlined,system,h⟩ + +/-- Public checking retains the externally selected protocol interface. -/ +def Compiled.check {q : Specialized s entries} (c : Compiled q) (rom : WireROM F) + (root : Aiur.Circuit.Message F) (rows : List (Aiur.Circuit.Row F)) : Except String Unit := do + q.checkEntry root.channel + (c.system.check rom root rows).mapError reprStr + +def Compiled.checkMemo {q : Specialized s entries} (c : Compiled q) (rom : WireROM F) + (root : Aiur.Circuit.Message F) (rows : List (Aiur.Circuit.WeightedRow F)) : Except String Unit := do + q.checkEntry root.channel + (c.system.checkMemo rom root rows).mapError reprStr + +theorem Compiled.check_iff {q : Specialized s entries} (c : Compiled q) + {rom : WireROM F} {root : Aiur.Circuit.Message F} {rows : List (Aiur.Circuit.Row F)} : + c.check rom root rows = .ok () ↔ + root.channel ∈ entries ∧ c.system.check rom root rows = .ok () := by + cases entry : q.checkEntry root.channel with + | error e => + have absent : root.channel ∉ entries := by + intro h + have := q.checkEntry_iff.mpr h + simp [entry] at this + simp [Compiled.check, entry, absent, bind, Except.bind] + | ok u => + cases u + have selected := q.checkEntry_iff.mp entry + cases h : c.system.check rom root rows <;> + simp [Compiled.check, entry, selected, h, Except.mapError, bind, Except.bind] + +theorem Compiled.checkMemo_iff {q : Specialized s entries} (c : Compiled q) + {rom : WireROM F} {root : Aiur.Circuit.Message F} {rows : List (Aiur.Circuit.WeightedRow F)} : + c.checkMemo rom root rows = .ok () ↔ + root.channel ∈ entries ∧ c.system.checkMemo rom root rows = .ok () := by + cases entry : q.checkEntry root.channel with + | error e => + have absent : root.channel ∉ entries := by + intro h + have := q.checkEntry_iff.mpr h + simp [entry] at this + simp [Compiled.checkMemo, entry, absent, bind, Except.bind] + | ok u => + cases u + have selected := q.checkEntry_iff.mp entry + cases h : c.system.checkMemo rom root rows <;> + simp [Compiled.checkMemo, entry, selected, h, Except.mapError, bind, Except.bind] + +theorem Specialized.core_heap_complete (q : Specialized s entries) + (selected : name ∈ entries) {system : Aiur.Circuit.System F} + (compiled : Aiur.Circuit.compile q.program = .ok system) + (evaluated : Engine.EvalFn s.coreWorld name args [] value heap) (encode : Nat → F) + (distinct : ∀ i j, i < heap.length → j < heap.length → encode i = encode j → i = j) : + Aiur.Circuit.EncodedEntryDerives system name (entryValues args) (value.mapAddress encode) := by + have root := q.valid.2.2.2.2.2.2.2 name selected + exact compiler_heap_complete compiled root.2.2 ((q.coreEvalFn_iff root.1).mp evaluated) encode distinct + +theorem Specialized.core_run_complete [Fintype F] (q : Specialized s entries) + (selected : name ∈ entries) {system : Aiur.Circuit.System F} + (compiled : Aiur.Circuit.compile q.program = .ok system) + {hints : s.CoreHintProvider} + (executed : s.coreRun name args fuel hints = .ok (value, heap)) (capacity : heap.length ≤ Fintype.card F) : + ∃ encode : Nat → F, Aiur.Circuit.EncodedEntryDerives system name (entryValues args) (value.mapAddress encode) := by + obtain ⟨encode, distinct⟩ := heap_address_embedding heap capacity + exact ⟨encode, q.core_heap_complete selected compiled (Source.coreRun_spec executed).2 encode distinct⟩ + +theorem Specialized.core_memo_run_complete [Fintype F] (q : Specialized s entries) + (selected : name ∈ entries) {system : Aiur.Circuit.System F} + (compiled : Aiur.Circuit.compile q.program = .ok system) + {hints : s.CoreHintProvider} + (executed : s.coreRun name args fuel hints = .ok (value, heap)) (capacity : heap.length ≤ Fintype.card F) : + ∃ encode : Nat → F, Aiur.Circuit.EncodedMemoEntryDerives system name (entryValues args) (value.mapAddress encode) := by + obtain ⟨encode, tree⟩ := q.core_run_complete selected compiled executed capacity + exact ⟨encode, tree.memo⟩ + +theorem Specialized.core_heap_sound (q : Specialized s entries) (selected : name ∈ entries) + {system : Aiur.Circuit.System F} (compiled : Aiur.Circuit.compile q.program = .ok system) + {rom : WireROM F} (valid : rom.Valid) + {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F} + (derived : Aiur.Circuit.CircuitEvaluates system rom name wires output) + (arguments : DecodesValues q.program.enums wires (entryValues args)) + (decoded : output.decode q.program.enums = some result) : + ∃ value heap, Engine.EvalFn s.coreWorld name args [] value heap ∧ + Represents (rom.decode q.program.enums) heap value result := by + have root := q.valid.2.2.2.2.2.2.2 name selected + obtain ⟨value, heap, evaluated, related⟩ := compiler_heap_sound compiled valid root.2.2 derived arguments decoded + exact ⟨value, heap, (q.coreEvalFn_iff root.1).mpr evaluated, related⟩ + +theorem Specialized.core_memo_acyclic_heap_sound (q : Specialized s entries) (selected : name ∈ entries) + {system : Aiur.Circuit.System F} (compiled : Aiur.Circuit.compile q.program = .ok system) + {rom : WireROM F} (valid : rom.Valid) + {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F} + (graph : Aiur.Circuit.MemoDerivation system rom ⟨name, wires, output⟩) (acyclic : graph.Acyclic) + (arguments : DecodesValues q.program.enums wires (entryValues args)) + (decoded : output.decode q.program.enums = some result) : + ∃ value heap, Engine.EvalFn s.coreWorld name args [] value heap ∧ + Represents (rom.decode q.program.enums) heap value result := + q.core_heap_sound selected compiled valid (graph.derives_of_acyclic acyclic) arguments decoded + +theorem Specialized.core_checker_run_complete [Fintype F] (q : Specialized s entries) + (selected : name ∈ entries) {system : Aiur.Circuit.System F} + (compiled : Aiur.Circuit.compile q.program = .ok system) (wellFormed : system.WellFormed) + {hints : s.CoreHintProvider} + (executed : s.coreRun name args fuel hints = .ok (value, heap)) (capacity : heap.length ≤ Fintype.card F) : + ∃ (encode : Nat → F), ∃ wires output rom rows, + DecodesValues system.enums wires (entryValues args) ∧ + output.decode system.enums = some (value.mapAddress encode) ∧ + system.check rom ⟨name, wires, output⟩ rows = .ok () := by + obtain ⟨encode, wires, output, arguments, decoded, accepted⟩ := q.core_run_complete selected compiled executed capacity + obtain ⟨rom, rows, checked⟩ := (system.check_entry_iff wellFormed).mpr accepted + exact ⟨encode, wires, output, rom, rows, arguments, decoded, checked⟩ + +theorem Specialized.core_checkerMemo_run_complete [Fintype F] (q : Specialized s entries) + (selected : name ∈ entries) {system : Aiur.Circuit.System F} + (compiled : Aiur.Circuit.compile q.program = .ok system) (wellFormed : system.WellFormed) + {hints : s.CoreHintProvider} + (executed : s.coreRun name args fuel hints = .ok (value, heap)) (capacity : heap.length ≤ Fintype.card F) : + ∃ (encode : Nat → F), ∃ wires output rom rows, + DecodesValues system.enums wires (entryValues args) ∧ + output.decode system.enums = some (value.mapAddress encode) ∧ + system.checkMemo rom ⟨name, wires, output⟩ rows = .ok () := by + obtain ⟨encode, wires, output, arguments, decoded, accepted⟩ := q.core_memo_run_complete selected compiled executed capacity + obtain ⟨rom, rows, checked⟩ := (system.checkMemo_entry_iff wellFormed).mpr accepted + exact ⟨encode, wires, output, rom, rows, arguments, decoded, checked⟩ + +theorem Specialized.core_checker_heap_sound (q : Specialized s entries) (selected : name ∈ entries) + {system : Aiur.Circuit.System F} (compiled : Aiur.Circuit.compile q.program = .ok system) + {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} + {wires : List (WireValue F)} {output : WireValue F} {rows : List (Aiur.Circuit.Row F)} + (checked : system.check rom ⟨name, wires, output⟩ rows = .ok ()) + (arguments : DecodesValues q.program.enums wires (entryValues args)) + (decoded : output.decode q.program.enums = some result) : + ∃ value heap, Engine.EvalFn s.coreWorld name args [] value heap ∧ + Represents (rom.decode q.program.enums) heap value result := by + have root := q.valid.2.2.2.2.2.2.2 name selected + obtain ⟨value, heap, evaluated, related⟩ := Aiur.checker_heap_sound compiled checked root.2.2 arguments decoded + exact ⟨value, heap, (q.coreEvalFn_iff root.1).mpr evaluated, related⟩ + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/ConstFacts.lean b/Aiur/Aiur/Generic/ConstFacts.lean new file mode 100644 index 000000000..d3ae77f43 --- /dev/null +++ b/Aiur/Aiur/Generic/ConstFacts.lean @@ -0,0 +1,274 @@ +import Aiur.Generic.Consts +import Aiur.ExceptFacts + +namespace Aiur.Generic +namespace Consts + +set_option linter.unusedSimpArgs false + +private theorem except_map_eq (f : α → β) (x : Except String α) : x.map f = f <$> x := rfl + +private theorem traverse_map (xs : List α) (input : α → β) (output : γ → δ) + (left : α → Except String γ) (right : β → Except String δ) + (agree : ∀ x ∈ xs, right (input x) = (left x).map output) : + (xs.map input).mapM right = (xs.mapM left).map (List.map output) := by + induction xs with + | nil => rfl + | cons x xs ih => + simp only [List.map_cons, List.mapM_cons] + rw [agree x (by simp), ih (fun y hy => agree y (by simp [hy]))] + cases left x <;> cases xs.mapM left <;> rfl + +private theorem traverse_same (xs : List α) (input : α → β) + (left : α → Except String γ) (right : β → Except String γ) + (agree : ∀ x ∈ xs, right (input x) = left x) : + (xs.map input).mapM right = xs.mapM left := by + simpa using traverse_map xs input id left right (by simpa using agree) + +theorem checkBody_map (f : α → β) (pat : Pattern α) : checkBody (pat.map f) = checkBody pat := by + have sub (p : Pattern α) (hsize : sizeOf p < sizeOf pat) : checkBody (p.map f) = checkBody p := + checkBody_map f p + have children (ps : List (Pattern α)) (h : ∀ q ∈ ps, sizeOf q < sizeOf pat) : + (ps.map (Pattern.map f)).mapM checkBody = ps.mapM checkBody := + traverse_same ps _ _ _ (fun q hq => checkBody_map f q) + cases pat <;> simp only [Pattern.map, checkBody] + all_goals try rw [children _ (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega)] + all_goals exact sub _ (by simp_wf <;> omega) +termination_by sizeOf pat +decreasing_by all_goals first | exact h q hq | exact hsize + +theorem substitute_map (f : α → β) (pat : Pattern α) + (left : String → Except String (Pattern α)) (right : String → Except String (Pattern β)) + (agree : ∀ n, right n = (left n).map (Pattern.map f)) : + substitute right (pat.map f) = (substitute left pat).map (Pattern.map f) := by + have sub (p : Pattern α) (hsize : sizeOf p < sizeOf pat) : + substitute right (p.map f) = (substitute left p).map (Pattern.map f) := + substitute_map f p left right agree + have children (ps : List (Pattern α)) (h : ∀ q ∈ ps, sizeOf q < sizeOf pat) : + (ps.map (Pattern.map f)).mapM (substitute right) = + (ps.mapM (substitute left)).map (List.map (Pattern.map f)) := + traverse_map ps _ _ _ _ (fun q hq => substitute_map f q left right agree) + cases pat with + | global n ann => simpa only [Pattern.map, substitute] using agree n + | literal | wildcard | bind => simp [Pattern.map, substitute, Except.map, pure, Except.pure] + | orElse a b names => + simp only [Pattern.map, substitute, sub a (by simp_wf; omega), sub b (by simp_wf; omega)] + cases substitute left a <;> cases substitute left b <;> simp [Except.map, bind, Except.bind, pure, Except.pure, Pattern.map] + | load p | «repeat» p _ => + simp only [Pattern.map, substitute, sub p (by simp_wf <;> omega)] + simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map, Pattern.map] + | record _ ps | tuple ps | array ps | construct _ _ ps | constructAs _ _ _ ps => + simp only [Pattern.map, substitute] + rw [children ps (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega)] + simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map, Pattern.map] +termination_by sizeOf pat +decreasing_by all_goals first | exact h q hq | exact hsize + +theorem lookup_map (f : α → β) (decls : List (ConstDecl α)) (name : String) : + lookup (decls.map (ConstDecl.map f)) name = (lookup decls name).map (Pattern.map f) := by + simp only [lookup, List.find?_map, Function.comp_def] + have same : (fun d : ConstDecl α => (d.map f).name == name) = (fun d => d.name == name) := rfl + rw [same] + cases decls.find? (·.name == name) <;> rfl + +theorem resolve_map (f : α → β) (decls : List (ConstDecl α)) (fuel path name) : + resolve (decls.map (ConstDecl.map f)) fuel path name = + (resolve decls fuel path name).map (Pattern.map f) := by + induction fuel generalizing path name with + | zero => rfl + | succ fuel ih => + simp only [resolve, lookup_map] + by_cases cycle : path.contains name + · simp only [cycle, ↓reduceIte]; rfl + · simp only [cycle, Bool.false_eq_true, ↓reduceIte, pure_bind] + cases found : lookup decls name with + | error e => rfl + | ok pat => + simpa only [Except.map, bind, Except.bind, pure, Except.pure] using + substitute_map f pat (resolve decls fuel (name :: path)) + (resolve (decls.map (ConstDecl.map f)) fuel (name :: path)) (fun n => ih _ n) + +theorem checkDeclarations_map (f : α → β) (p : Program α) : + checkDeclarations (p.map f) = checkDeclarations p := by + have checked := traverse_same p.consts (ConstDecl.map f) + (checkDeclaration (p.functions.map (·.name) ++ p.maps.map (·.name))) + (checkDeclaration (p.functions.map (·.name) ++ p.maps.map (·.name))) + (fun d _ => by simp [checkDeclaration, ConstDecl.map, checkBody_map]) + simp only [checkDeclarations, Program.map, List.map_map, Function.comp_def] + have names : (fun d : ConstDecl α => (d.map f).name) = (fun d => d.name) := rfl + rw [names, checked] + +theorem resolveDeclarations_map (f : α → β) (p : Program α) : + resolveDeclarations (p.map f) = (resolveDeclarations p).map (List.map (ConstDecl.map f)) := by + have resolved := traverse_map p.consts (ConstDecl.map f) (ConstDecl.map f) + (fun d => do return { d with value := ← resolve p.consts (p.consts.length + 1) [] d.name }) + (fun d => do return { d with value := ← resolve (p.consts.map (ConstDecl.map f)) (p.consts.length + 1) [] d.name }) + (by + intro d _ + simp [ConstDecl.map, resolve_map, except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map]) + simp only [resolveDeclarations] + rw [checkDeclarations_map] + simp only [Program.map, List.length_map, resolved] + simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map] + +theorem toExpr_map (f : α → β) (pat : Pattern α) : + toExpr (pat.map f) = (toExpr pat).map (Expr.map f) := by + have sub (p : Pattern α) (hsize : sizeOf p < sizeOf pat) : + toExpr (p.map f) = (toExpr p).map (Expr.map f) := toExpr_map f p + have children (ps : List (Pattern α)) (h : ∀ q ∈ ps, sizeOf q < sizeOf pat) : + (ps.map (Pattern.map f)).mapM toExpr = (ps.mapM toExpr).map (List.map (Expr.map f)) := + traverse_map ps _ _ _ _ (fun q hq => toExpr_map f q) + cases pat with + | literal | wildcard | bind | global | orElse => + simp [Pattern.map, toExpr, Expr.map, Except.map, pure, Except.pure] + | load p | «repeat» p _ => + simp only [Pattern.map, toExpr, sub p (by simp_wf <;> omega)] + simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map, Expr.map] + | record _ ps | tuple ps | array ps | constructAs _ _ _ ps => + simp only [Pattern.map, toExpr] + rw [children ps (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega)] + simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map, Expr.map] + | construct t c ps => + cases t <;> simp only [Pattern.map, toExpr] + all_goals first | rfl | skip + rw [children ps (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega)] + simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map, Expr.map] +termination_by sizeOf pat +decreasing_by all_goals first | exact h q hq | exact hsize + +theorem bindingNames_map (f : α → β) (pat : Pattern α) : + (pat.map f).bindingNames = pat.bindingNames := by + cases pat with + | literal | wildcard | bind | global | orElse => simp [Pattern.map, Pattern.bindingNames] + | load p => simpa only [Pattern.map, Pattern.bindingNames] using bindingNames_map f p + | «repeat» p n => simp only [Pattern.map, Pattern.bindingNames, bindingNames_map f p] + | record head ps => + simp only [Pattern.map, Pattern.bindingNames, List.map_map] + congr 2 + apply List.map_congr_left + intro p member + exact bindingNames_map f p + | tuple ps | array ps | construct _ _ ps | constructAs _ _ _ ps => + simp only [Pattern.map, Pattern.bindingNames, List.flatMap_map] + apply List.flatMap_congr + intro p member + exact bindingNames_map f p +termination_by sizeOf pat +decreasing_by + all_goals simp_wf + all_goals try have := List.sizeOf_lt_of_mem member + all_goals omega + +theorem expandPattern_map (f : α → β) (decls : List (ConstDecl α)) (pat : Pattern α) : + expandPattern (decls.map (ConstDecl.map f)) (pat.map f) = + (expandPattern decls pat).map (Pattern.map f) := + substitute_map f pat _ _ (lookup_map f decls) + +theorem expression_map (f : α → β) (decls : List (ConstDecl α)) (name : String) : + expression (decls.map (ConstDecl.map f)) name = (expression decls name).map (Expr.map f) := by + simp only [expression, lookup_map] + cases lookup decls name with + | error e => rfl + | ok pat => exact toExpr_map f pat + +theorem expandExpr_map (f : α → β) (decls : List (ConstDecl α)) (locals) (expr : Expr α) : + expandExpr (decls.map (ConstDecl.map f)) locals (expr.map f) = + (expandExpr decls locals expr).map (Expr.map f) := by + have sub (x : Expr α) (hsize : sizeOf x < sizeOf expr) (locals) : + expandExpr (decls.map (ConstDecl.map f)) locals (x.map f) = + (expandExpr decls locals x).map (Expr.map f) := + expandExpr_map f decls locals x + have children (xs : List (Expr α)) (h : ∀ x ∈ xs, sizeOf x < sizeOf expr) : + (xs.map (Expr.map f)).mapM (expandExpr (decls.map (ConstDecl.map f)) locals) = + (xs.mapM (expandExpr decls locals)).map (List.map (Expr.map f)) := + traverse_map xs _ _ _ _ (fun x hx => expandExpr_map f decls locals x) + cases expr with + | literal => simp [Expr.map, expandExpr, Except.map, pure, Except.pure] + | var n => + simp only [Expr.map, expandExpr, List.any_map, Function.comp_def, ConstDecl.map] + split <;> simp [expression_map, Except.map, pure, Except.pure, Expr.map] + | global n ann => simpa only [Expr.map, expandExpr] using expression_map f decls n + | builtin _ xs | update _ xs | record _ xs | tuple xs | array xs | construct _ _ _ xs | constructAs _ _ _ xs | call _ _ xs => + simp only [Expr.map, expandExpr] + rw [children xs (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega)] + all_goals simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map, Expr.map] + | member x _ | control _ x | project x _ | index x _ | slice x _ _ | «repeat» x _ | store x | load x | hint _ x channel | neg x => + simp only [Expr.map, expandExpr, sub x (by simp_wf <;> omega)] + all_goals simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map, Expr.map] + | binary _ x b => + simp only [Expr.map, expandExpr, sub x (by simp_wf <;> omega), sub b (by simp_wf <;> omega)] + simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map, Expr.map] + | letValue pat x b => + simp only [Expr.map, expandExpr, expandPattern_map] + cases expandPattern decls pat with + | error e => rfl + | ok pat => + simp only [Except.map, bind, Except.bind, bindingNames_map, + sub x (by simp_wf <;> omega), sub b (by simp_wf <;> omega)] + cases expandExpr decls locals x <;> cases expandExpr decls (pat.bindingNames ++ locals) b <;> + simp [Except.map, bind, Except.bind, pure, Except.pure, Expr.map] + | matchValue x arms => + have mapped := traverse_map arms + (fun arm => (arm.1.map f, arm.2.map f)) + (fun arm : Pattern α × Expr α => (arm.1.map f, arm.2.map f)) + (fun arm => do + let pat ← expandPattern decls arm.1 + return (pat, ← expandExpr decls (pat.bindingNames ++ locals) arm.2)) + (fun arm => do + let pat ← expandPattern (decls.map (ConstDecl.map f)) arm.1 + return (pat, ← expandExpr (decls.map (ConstDecl.map f)) (pat.bindingNames ++ locals) arm.2)) + (by + intro arm member + simp only [expandPattern_map] + cases expandPattern decls arm.1 with + | error e => rfl + | ok pat => + simp only [Except.map, bind, Except.bind, bindingNames_map, + sub arm.2 (by have := List.sizeOf_lt_of_mem member; cases arm; simp_all [Prod.mk.sizeOf_spec]; omega)] + cases expandExpr decls (pat.bindingNames ++ locals) arm.2 <;> + simp [Except.map, bind, Except.bind, pure, Except.pure]) + simp only [Expr.map, expandExpr, sub x (by simp_wf <;> omega), mapped] + simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map, Expr.map] +termination_by sizeOf expr +decreasing_by all_goals first | exact h x hx | exact hsize + +theorem expandProgram_map (f : α → β) (decls : List (ConstDecl α)) (p : Program α) : + expandProgram (decls.map (ConstDecl.map f)) (p.map f) = + (expandProgram decls p).map (Program.map f) := by + have functions := traverse_map p.functions + (fun d => { d with body := d.body.map f }) (fun d => { d with body := d.body.map f }) + (fun d => do return { d with body := ← expandExpr decls (d.params.map Prod.fst) d.body }) + (fun d => do return { d with body := ← expandExpr (decls.map (ConstDecl.map f)) (d.params.map Prod.fst) d.body }) + (by + intro d _ + simp [expandExpr_map, except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map]) + have tables := traverse_map p.tables + (fun t => { t with rows := t.rows.map (Expr.map f) }) (fun t => { t with rows := t.rows.map (Expr.map f) }) + (fun t => do return { t with rows := ← t.rows.mapM (expandExpr decls []) }) + (fun t => do return { t with rows := ← t.rows.mapM (expandExpr (decls.map (ConstDecl.map f)) []) }) + (by + intro t _ + have rows := traverse_map t.rows (Expr.map f) (Expr.map f) + (expandExpr decls []) (expandExpr (decls.map (ConstDecl.map f)) []) + (fun x _ => expandExpr_map f decls [] x) + simp only [rows] + simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map]) + simp only [expandProgram, Program.map, functions, tables] + simp [except_map_eq, bind_map_left, _root_.map_bind, Functor.map_map, Program.map] + +end Consts + +/-- Literal conversion commutes with const resolution and substitution, +including every scope decision and expansion error. -/ +theorem expandConsts_map (f : α → β) (p : Program α) : + expandConsts (p.map f) = (expandConsts p).map (Program.map f) := by + simp only [expandConsts, Consts.resolveDeclarations_map] + cases Consts.resolveDeclarations p with + | error e => rfl + | ok decls => exact Consts.expandProgram_map f decls p + +theorem expandConsts_toField (p : Program Nat) (F : Type) [NatCast F] : + expandConsts (p.toField F) = (expandConsts p).map (fun q => q.toField F) := + expandConsts_map Nat.cast p + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/ConstScopeFacts.lean b/Aiur/Aiur/Generic/ConstScopeFacts.lean new file mode 100644 index 000000000..a47835fa0 --- /dev/null +++ b/Aiur/Aiur/Generic/ConstScopeFacts.lean @@ -0,0 +1,109 @@ +import Aiur.Generic.OpenSource +import Aiur.Generic.PreparationPatternFacts + +namespace Aiur.Generic.Consts +open SourceSemantics + +/-- Exactly the expression forms allowed in a closed declaration body. Global +references establish their own scope; there are no local variable reads. -/ +inductive Closed : Expr F → Prop where + | literal : Closed (.literal x) + | global : Closed (.global name type) + | tuple (items : ∀ e ∈ es, Closed e) : Closed (.tuple es) + | array (items : ∀ e ∈ es, Closed e) : Closed (.array es) + | «repeat» (item : Closed e) : Closed (.repeat e n) + | store (item : Closed e) : Closed (.store e) + | construct (items : ∀ e ∈ es, Closed e) : Closed (.construct name types ctor es) + | record (items : ∀ e ∈ es, Closed e) : Closed (.record head es) + | constructAs (items : ∀ e ∈ es, Closed e) : Closed (.constructAs params type ctor es) + +theorem toExpr_closed (pat : Pattern F) {expr : Expr F} + (interpreted : toExpr pat = .ok expr) : Closed expr := by + have sub (p : Pattern F) (smaller : sizeOf p < sizeOf pat) {e : Expr F} + (h : toExpr p = .ok e) : Closed e := toExpr_closed p h + have children (ps : List (Pattern F)) (smaller : ∀ p ∈ ps, sizeOf p < sizeOf pat) + (es : List (Expr F)) (mapped : ps.mapM toExpr = .ok es) : ∀ e ∈ es, Closed e := by + have rel := Preparation.mapM_relation mapped + have both : List.Forall₂ (fun p e => Closed e ∧ toExpr p = .ok e) ps es := by + have withMem : List.Forall₂ (fun p e => p ∈ ps ∧ toExpr p = .ok e) ps es := + (List.forall₂_and_left _ _).mpr ⟨fun _ h => h, rel⟩ + exact withMem.imp (fun p e h => ⟨sub p (smaller p h.1) h.2, h.2⟩) + intro e he + clear smaller mapped rel + induction both with + | nil => simp at he + | cons h _ ih => + rcases List.mem_cons.mp he with rfl | he + · exact h.1 + · exact ih he + cases pat with + | literal | global => + simp only [toExpr, except_pure_ok] at interpreted + subst expr + constructor + | wildcard | bind | orElse => simp [toExpr] at interpreted + | load p | «repeat» p n => + simp only [toExpr, except_bind_ok, except_pure_ok] at interpreted + obtain ⟨e, h, rfl⟩ := interpreted + constructor + exact sub p (by simp_wf <;> omega) h + | record _ ps | tuple ps | array ps | constructAs params t c ps => + simp only [toExpr, except_bind_ok, except_pure_ok] at interpreted + obtain ⟨es, h, rfl⟩ := interpreted + constructor + exact children ps (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) es h + | construct t c ps => + cases t <;> simp only [toExpr] at interpreted + all_goals first | contradiction | skip + simp only [except_bind_ok, except_pure_ok] at interpreted + obtain ⟨es, h, rfl⟩ := interpreted + constructor + exact children ps (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) es h +termination_by sizeOf pat +decreasing_by exact smaller + +/-- A const expression has the same value and allocation history in any +surrounding local scope. In particular, inlining cannot capture caller names. -/ +theorem Closed.openChangeLocals [Field F] [DecidableEq F] {world : World F} {calls : CallRelation F} + {expr : Expr F} (closed : Closed expr) + (evaluated : OpenSource.EvalExpr world calls types locals expr before result after) + (other : Environment F Nat) : OpenSource.EvalExpr world calls types other expr before result after := by + induction evaluated using OpenSource.EvalExpr.rec + (motive_2 := fun ts ls es b vs a _ => + (∀ e ∈ es, Closed e) → ∀ other, OpenSource.EvalArgs world calls ts other es b vs a) + (motive_3 := fun _ _ _ _ _ _ _ _ => True) + (motive_4 := fun _ _ _ _ _ _ _ _ => True) generalizing other with + | literal => exact .literal + | global lookup interpreted ev _ => exact .global lookup interpreted ev + | tuple _ ih => cases closed with | tuple h => exact .tuple (ih h other) + | array _ ih => cases closed with | array h => exact .array (ih h other) + | «repeat» _ ih => cases closed with | «repeat» h => exact .repeat (ih h other) + | construct _ ih => cases closed with | construct h => exact .construct (ih h other) + | record _ ih => cases closed with | record h => exact .record (ih h other) + | constructAs _ ih => cases closed with | constructAs h => exact .constructAs (ih h other) + | store _ ih => cases closed with | store h => exact .store (ih h other) + | nil => exact .nil + | cons _ _ ih1 ih2 => + rename_i h other + exact .cons (ih1 (h _ (by simp)) other) (ih2 (fun e he => h e (by simp [he])) other) + | _ => first | cases closed | trivial + +theorem Closed.openLocals_iff [Field F] [DecidableEq F] {world : World F} {calls : CallRelation F} + {expr : Expr F} (closed : Closed expr) : + OpenSource.EvalExpr world calls types left expr before result after ↔ + OpenSource.EvalExpr world calls types right expr before result after := + ⟨fun h => closed.openChangeLocals h right, fun h => closed.openChangeLocals h left⟩ + +theorem Closed.changeLocals [Field F] [DecidableEq F] {world : World F} + {expr : Expr F} (closed : Closed expr) + (evaluated : SourceSemantics.EvalExpr world types locals expr before result after) + (other : Environment F Nat) : SourceSemantics.EvalExpr world types other expr before result after := + (closed.openChangeLocals (OpenSource.of_closed evaluated) other).close + +theorem Closed.locals_iff [Field F] [DecidableEq F] {world : World F} + {expr : Expr F} (closed : Closed expr) : + SourceSemantics.EvalExpr world types left expr before result after ↔ + SourceSemantics.EvalExpr world types right expr before result after := + ⟨fun h => closed.changeLocals h right, fun h => closed.changeLocals h left⟩ + +end Aiur.Generic.Consts diff --git a/Aiur/Aiur/Generic/Consts.lean b/Aiur/Aiur/Generic/Consts.lean new file mode 100644 index 000000000..e17261c8c --- /dev/null +++ b/Aiur/Aiur/Generic/Consts.lean @@ -0,0 +1,196 @@ +import Aiur.Generic.Aliases + +/-! Consts are closed value/pattern declarations. Source checking and execution +retain references. The substitution functions in this file are compiler tools; +pointer syntax denotes allocation or matching according to its position. -/ + +namespace Aiur.Generic +namespace Consts + +/-- A declaration body is value syntax with no local scope. Its constructors +must also make sense as patterns; calls, arithmetic, projections and loads do +not. Bare names therefore become global references here. -/ +def ofExpr : Expr α → Except String (Pattern α) + | .literal x => pure (.literal x) + | .var n => pure (.global n) + | .global n t => pure (.global n t) + | .store x => return .load (← ofExpr x) + | .tuple xs => return .tuple (← xs.mapM ofExpr) + | .array xs => return .array (← xs.mapM ofExpr) + | .repeat x n => return .repeat (← ofExpr x) n + | .record head xs => return .record head (← xs.mapM ofExpr) + | .construct n ts c xs => return .construct (.named n (ts.getD [])) c (← xs.mapM ofExpr) + | .constructAs params t c xs => return .constructAs params t c (← xs.mapM ofExpr) + | _ => throw "const bodies require literals, tuples, arrays, constructors, stores, or const references" +termination_by e => sizeOf e + +def checkBody : Pattern α → Except String Unit + | .literal _ | .global _ _ => pure () + | .orElse _ _ _ => throw "const bodies must specify a single value; or-patterns are not allowed" + | .wildcard => throw "const bodies must specify complete values; wildcards are not allowed" + | .bind n => throw s!"const bodies cannot bind '{n}'; use '::{n}' for a global reference" + | .load p | .repeat p _ => checkBody p + | .record head ps => do + if head.rest then throw "const struct bodies must specify every field" + let _ ← ps.mapM checkBody + pure () + | .tuple ps | .array ps | .construct _ _ ps | .constructAs _ _ _ ps => do + let _ ← ps.mapM checkBody + pure () +termination_by p => sizeOf p + +/-- Replace global references while preserving every literal, constructor, +pointer layer, and local binder in the surrounding pattern. -/ +def substitute (lookup : String → Except String (Pattern α)) : Pattern α → Except String (Pattern α) + | .literal x => pure (.literal x) + | .wildcard => pure .wildcard + | .bind n => pure (.bind n) + | .global n _ => lookup n + | .record head ps => return .record head (← ps.mapM (substitute lookup)) + | .orElse left right names => return .orElse (← substitute lookup left) (← substitute lookup right) names + | .load p => return .load (← substitute lookup p) + | .tuple ps => return .tuple (← ps.mapM (substitute lookup)) + | .array ps => return .array (← ps.mapM (substitute lookup)) + | .repeat p n => return .repeat (← substitute lookup p) n + | .construct t c ps => return .construct t c (← ps.mapM (substitute lookup)) + | .constructAs params t c ps => return .constructAs params t c (← ps.mapM (substitute lookup)) +termination_by p => sizeOf p + +def lookup (decls : List (ConstDecl α)) (name : String) : Except String (Pattern α) := + match decls.find? (·.name == name) with + | some d => pure d.value + | none => throw s!"unknown const '::{name}'" + +/-- Only following a reference consumes depth. With one more than the number +of declarations, every acyclic dependency chain fits. Pointers do not break +cycles: these declarations are syntax to inline, not recursive heap objects. -/ +def resolve (decls : List (ConstDecl α)) : Nat → List String → String → Except String (Pattern α) + | 0, _, _ => throw "const dependency depth exceeded" + | fuel + 1, path, name => do + if path.contains name then + throw s!"cyclic const: {String.intercalate " -> " (path.reverse ++ [name])}" + let value ← lookup decls name + substitute (resolve decls fuel (name :: path)) value + +def checkDeclaration (callables : List String) (d : ConstDecl α) : Except String Unit := do + checkIdentifier d.name + if callables.contains d.name then throw s!"const '{d.name}' conflicts with a function or map" + checkBody d.value + +def checkDeclarations (p : Program α) : Except String Unit := do + if let some n := findDuplicate (p.consts.map (·.name)) [] then throw s!"duplicate const '{n}'" + let _ ← p.consts.mapM (checkDeclaration (p.functions.map (·.name) ++ p.maps.map (·.name))) + pure () + +def dependencies : Pattern α → List String + | .global name _ => [name] + | .orElse left right _ => dependencies left ++ dependencies right + | .load p | .repeat p _ => dependencies p + | .record _ ps | .tuple ps | .array ps | .construct _ _ ps | .constructAs _ _ _ ps => + ps.flatMap dependencies + | _ => [] +termination_by p => sizeOf p + +/-- Validate the reference graph without substituting any declaration body. +Even an unused declaration, or a reference underneath `&` or `[...; 0]`, must +have an acyclic dependency graph. -/ +def checkAcyclic (p : Program α) : Except String Unit := do + checkDeclarations p + let rec visit : Nat → List String → String → Except String Unit + | 0, _, _ => throw "const dependency depth exceeded" + | fuel + 1, path, name => do + if path.contains name then + throw s!"cyclic const: {String.intercalate " -> " (path.reverse ++ [name])}" + let body ← lookup p.consts name + (dependencies body).forM (visit fuel (name :: path)) + p.consts.forM fun d => visit (p.consts.length + 1) [] d.name + +/-- Forward references work. Every declaration is checked and resolved, +including unused declarations and cycles hidden underneath pointer syntax. -/ +def resolveDeclarations (p : Program α) : Except String (List (ConstDecl α)) := do + checkDeclarations p + p.consts.mapM fun d => do + return { d with value := ← resolve p.consts (p.consts.length + 1) [] d.name } + +def expandPattern (decls : List (ConstDecl α)) : Pattern α → Except String (Pattern α) := + substitute (lookup decls) + +/-- In expression position a pointer template constructs a fresh cell at each +use. This is separate from `Aiur.Constant`, which forbids pointers in tables. -/ +def toExpr : Pattern α → Except String (Expr α) + | .literal x => pure (.literal x) + | .record head ps => return .record head (← ps.mapM toExpr) + | .load p => return .store (← toExpr p) + | .tuple ps => return .tuple (← ps.mapM toExpr) + | .array ps => return .array (← ps.mapM toExpr) + | .repeat p n => return .repeat (← toExpr p) n + | .construct (.named n ts) c ps => + return .construct n (if ts.isEmpty then none else some ts) c (← ps.mapM toExpr) + | .constructAs params t c ps => return .constructAs params t c (← ps.mapM toExpr) + | .construct _ _ _ => throw "const constructor requires a nominal enum type" + | .global n t => pure (.global n t) + | .orElse _ _ _ => throw "const bodies must specify a single value; or-patterns are not allowed" + | .wildcard => throw "const bodies must specify complete values; wildcards are not allowed" + | .bind n => throw s!"const bodies cannot bind '{n}'; use '::{n}' for a global reference" +termination_by p => sizeOf p + +def expression (decls : List (ConstDecl α)) (name : String) : Except String (Expr α) := do + toExpr (← lookup decls name) + +/-- Bare expression names prefer lexical bindings, then consts. Rooted names +always refer to consts. Bare pattern names are always binders. -/ +def expandExpr (decls : List (ConstDecl α)) (locals : List String) : Expr α → Except String (Expr α) + | .literal x => pure (.literal x) + | .var n => + if locals.contains n || !(decls.any (·.name == n)) then pure (.var n) + else expression decls n + | .global n _ => expression decls n + | .control kind body => return .control kind (← expandExpr decls locals body) + | .tuple xs => return .tuple (← xs.mapM (expandExpr decls locals)) + | .array xs => return .array (← xs.mapM (expandExpr decls locals)) + | .repeat x n => return .repeat (← expandExpr decls locals x) n + | .index x i => return .index (← expandExpr decls locals x) i + | .slice x start stop => return .slice (← expandExpr decls locals x) start stop + | .construct n ts c xs => return .construct n ts c (← xs.mapM (expandExpr decls locals)) + | .constructAs params t c xs => return .constructAs params t c (← xs.mapM (expandExpr decls locals)) + | .builtin op xs => return .builtin op (← xs.mapM (expandExpr decls locals)) + | .update paths xs => return .update paths (← xs.mapM (expandExpr decls locals)) + | .record head xs => return .record head (← xs.mapM (expandExpr decls locals)) + | .member x field => return .member (← expandExpr decls locals x) field + | .project x i => return .project (← expandExpr decls locals x) i + | .letValue pat x b => do + let pat ← expandPattern decls pat + return .letValue pat (← expandExpr decls locals x) + (← expandExpr decls (pat.bindingNames ++ locals) b) + | .store x => return .store (← expandExpr decls locals x) + | .load x => return .load (← expandExpr decls locals x) + | .hint t k channel => return .hint t (← expandExpr decls locals k) channel + | .neg x => return .neg (← expandExpr decls locals x) + | .binary op x y => return .binary op (← expandExpr decls locals x) (← expandExpr decls locals y) + | .call n ts xs => return .call n ts (← xs.mapM (expandExpr decls locals)) + | .matchValue x arms => do + return .matchValue (← expandExpr decls locals x) (← arms.mapM fun arm => do + let pat ← expandPattern decls arm.1 + return (pat, ← expandExpr decls (pat.bindingNames ++ locals) arm.2)) +termination_by e => sizeOf e +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; try simp_all only [Prod.mk.sizeOf_spec] + all_goals first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +def expandProgram (decls : List (ConstDecl α)) (p : Program α) : Except String (Program α) := do + let functions ← p.functions.mapM fun d => do + return { d with body := ← expandExpr decls (d.params.map Prod.fst) d.body } + let tables ← p.tables.mapM fun t => do + return { t with rows := ← t.rows.mapM (expandExpr decls []) } + -- Retain resolved templates until their constructor/type shapes have been + -- checked, even when unused. Elaboration then removes the declarations. + return { p with functions, tables, consts := decls } + +end Consts + +def expandConsts (p : Program α) : Except String (Program α) := do + let decls ← Consts.resolveDeclarations p + Consts.expandProgram decls p + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/ControlBranchFacts.lean b/Aiur/Aiur/Generic/ControlBranchFacts.lean new file mode 100644 index 000000000..3a5fad56a --- /dev/null +++ b/Aiur/Aiur/Generic/ControlBranchFacts.lean @@ -0,0 +1,155 @@ +import Aiur.Generic.ControlContinuationFacts + +namespace Aiur.Generic.ControlLower +open SourceSemantics OpenSource +variable {F : Type} [Field F] [DecidableEq F] +variable {world : SourceSemantics.World F} {calls : CallRelation F} +variable {env bound : Renaming} {source target : Environment F Nat} +variable {next : Continuation F} {handlers : Handlers F} + +/-- The expression-level claim used in the compiler induction. The source +body still has lexical exits; the generated body invokes their continuations. -/ +def Correct (world : SourceSemantics.World F) (calls : CallRelation F) (env : Renaming) + (expr code : Expr F) (next : Continuation F) (handlers : Handlers F) : Prop := + ∀ source target before result after, ScopeRel env source target → + (OpenSource.EvalExpr world calls [] target code before result after ↔ + Exec world calls [] source expr + (fun v h => next.run world calls target v h result after) + (fun t v h => handlers.run world calls target t v h result after) before) + +def ArgsCorrect (world : SourceSemantics.World F) (calls : CallRelation F) (env : Renaming) + (exprs : List (Expr F)) (code : Expr F) (next : Continuation F) (handlers : Handlers F) : Prop := + ∀ source target before result after, ScopeRel env source target → + (OpenSource.EvalExpr world calls [] target code before result after ↔ + ExecArgs world calls [] source exprs + (fun vs h => next.run world calls target (.tuple vs) h result after) + (fun t v h => handlers.run world calls target t v h result after) before) + +theorem renamed_some (plain : Consts.dependencies pat = []) : + world.matchPattern [] heap (renamePattern bound pat) value = .ok (some output) ↔ + ∃ bs, world.matchPattern [] heap pat value = .ok (some bs) ∧ output = renameBindings bound bs := by + simp only [World.matchPattern, matchPattern_rename pat plain] + cases matched : matchPatternWith world.constant world.constDepth [] heap pat value with + | error e => simp [Except.map] + | ok bs => cases bs <;> simp [Except.map, eq_comm] + +theorem renamed_none (plain : Consts.dependencies pat = []) : + world.matchPattern [] heap (renamePattern bound pat) value = .ok none ↔ + world.matchPattern [] heap pat value = .ok none := by + simp only [World.matchPattern, matchPattern_rename pat plain] + cases matchPatternWith world.constant world.constDepth [] heap pat value with + | error e => simp [Except.map] + | ok bs => cases bs <;> simp [Except.map] + +/-- Entering a matched branch introduces renamed pattern bindings. The +continuations retain their surrounding scope, even if the source shadows it. -/ +theorem branch_iff + (built : bindings pat (reserved env next handlers) = .ok bound) + (compiled : Correct world calls (bound ++ env) body code next handlers) + (fresh : Fresh input env next handlers) (scope : ScopeRel env source target) : + (∃ bs, world.matchPattern [] heap (renamePattern bound pat) value = .ok (some bs) ∧ + OpenSource.EvalExpr world calls [] (bs ++ (input, value) :: target) code heap result after) ↔ + ∃ bs, world.matchPattern [] heap pat value = .ok (some bs) ∧ + Exec world calls [] (bs ++ source) body + (fun v h => next.run world calls target v h result after) + (fun t v h => handlers.run world calls target t v h result after) heap := by + obtain ⟨plain, unique, keys, unused⟩ := bindings_ok built + have branch (bs : Environment F Nat) + (matched : world.matchPattern [] heap pat value = .ok (some bs)) : + OpenSource.EvalExpr world calls [] (renameBindings bound bs ++ (input, value) :: target) + code heap result after ↔ + Exec world calls [] (bs ++ source) body + (fun v h => next.run world calls target v h result after) + (fun t v h => handlers.run world calls target t v h result after) heap := by + have names := matchPattern_names pat plain matched + have covered : ∀ n ∈ bs.map Prod.fst, n ∈ bound.map Prod.fst := by + intro n hn; exact (keys n).mpr (names ▸ hn) + have boundFresh : ∀ n ∈ bound.map Prod.snd, n ∉ env.map Prod.snd := by + intro n hn he; exact unused n hn (by simp [reserved, he]) + have relation := (scope.add fresh.scope value).extend unique (fun n => (keys n).trans (by rw [names])) boundFresh + rw [compiled _ _ _ _ _ relation] + have untouched (k : Continuation F) (hk : ∀ n ∈ k.names, n ∈ reserved env next handlers) : + ∀ n ∈ k.names, n ∉ (renameBindings bound bs).map Prod.fst := by + intro n hn bad + exact unused n (renameBindings_names covered n bad) (hk n hn) + apply Exec.congr + · intro v h + exact (next.run_prepend _ (untouched next (by intros; simp [reserved, *]))).trans + (next.run_add fresh.next) + · intro t v h + apply Iff.trans (Handlers.run_prepend _ ?_) (Handlers.run_add fresh.handlers) + intro t k found + apply untouched k + intro n hn + have member : (t, k) ∈ handlers := by + obtain ⟨left, right, rfl, _⟩ := List.lookup_eq_some_iff.mp found + simp + simp only [reserved, List.mem_append, List.mem_flatMap] + exact .inr ⟨_, member, hn⟩ + constructor + · rintro ⟨bs, matched, ev⟩ + obtain ⟨original, originalMatch, rfl⟩ := (renamed_some plain).mp matched + exact ⟨_, originalMatch, (branch _ originalMatch).mp ev⟩ + · rintro ⟨bs, matched, ev⟩ + exact ⟨_, (renamed_some plain).mpr ⟨bs, matched, rfl⟩, (branch _ matched).mpr ev⟩ + +def Selected (world : SourceSemantics.World F) (heap : Heap F) (value : SourceValue F) + (arms : List (Pattern F × Expr F)) (post : Environment F Nat → Expr F → Prop) : Prop := + ∃ bindings body, SourceSemantics.selectArm world [] heap value arms = .ok (some (bindings, body)) ∧ post bindings body + +theorem selected_nil : ¬ Selected world heap value [] post := by + simp [Selected, SourceSemantics.selectArm] + +theorem selected_cons : Selected world heap value ((pat, body) :: arms) post ↔ + (∃ bs, world.matchPattern [] heap pat value = .ok (some bs) ∧ post bs body) ∨ + (world.matchPattern [] heap pat value = .ok none ∧ Selected world heap value arms post) := by + cases matched : world.matchPattern [] heap pat value with + | error e => simp [Selected, SourceSemantics.selectArm, matched, bind, Except.bind] + | ok bs => cases bs <;> simp [Selected, SourceSemantics.selectArm, matched, bind, Except.bind, pure, Except.pure] + +theorem selected_congr {arms others : List (Pattern F × Expr F)} + {left right : Environment F Nat → Expr F → Prop} + (related : List.Forall₂ (fun a b => + ((∃ bs, world.matchPattern [] heap a.1 value = .ok (some bs) ∧ left bs a.2) ↔ + ∃ bs, world.matchPattern [] heap b.1 value = .ok (some bs) ∧ right bs b.2) ∧ + (world.matchPattern [] heap a.1 value = .ok none ↔ world.matchPattern [] heap b.1 value = .ok none)) arms others) : + Selected world heap value arms left ↔ Selected world heap value others right := by + induction related with + | nil => simp only [Selected, SourceSemantics.selectArm, except_pure_ok, reduceCtorEq, false_and, exists_false] + | @cons a b arms others first _ ih => + rcases a with ⟨pa, ea⟩; rcases b with ⟨pb, eb⟩ + rw [selected_cons, selected_cons, first.1, first.2, ih] + +theorem eval_let_var : + OpenSource.EvalExpr world calls [] ((input, value) :: target) + (.letValue pat (.var input) code) before result after ↔ + ∃ bs, world.matchPattern [] before pat value = .ok (some bs) ∧ + OpenSource.EvalExpr world calls [] (bs ++ (input, value) :: target) code before result after := by + constructor + · intro h; cases h with + | letValue ev matched body => + cases ev with + | var found => + have same := by simpa using found + obtain rfl := same + exact ⟨_, matched, body⟩ + · rintro ⟨bs, matched, ev⟩ + exact .letValue (.var (by simp)) matched ev + +theorem eval_match_var : + OpenSource.EvalExpr world calls [] ((input, value) :: target) + (.matchValue (.var input) arms) before result after ↔ + Selected world before value arms (fun bs body => + OpenSource.EvalExpr world calls [] (bs ++ (input, value) :: target) body before result after) := by + constructor + · intro h; cases h with + | matchValue ev selected body => + cases ev with + | var found => + have same := by simpa using found + obtain rfl := same + exact ⟨_, _, selected, body⟩ + · rintro ⟨bs, body, selected, ev⟩ + exact .matchValue (.var (by simp)) selected ev + +end Aiur.Generic.ControlLower diff --git a/Aiur/Aiur/Generic/ControlContinuationFacts.lean b/Aiur/Aiur/Generic/ControlContinuationFacts.lean new file mode 100644 index 000000000..bcc591d46 --- /dev/null +++ b/Aiur/Aiur/Generic/ControlContinuationFacts.lean @@ -0,0 +1,247 @@ +import Aiur.Generic.ControlScopeFacts +import Aiur.Generic.ControlRules + +namespace Aiur.Generic.ControlLower +open SourceSemantics OpenSource Engine +variable {F : Type} [Field F] [DecidableEq F] +variable {world : SourceSemantics.World F} {calls : CallRelation F} +variable {locals : Environment F Nat} {next : Continuation F} {handlers : Handlers F} + +/-- Interpret a compiler continuation in its captured lexical environment. -/ +def Continuation.run (next : Continuation F) (world : SourceSemantics.World F) (calls : CallRelation F) + (locals : Environment F Nat) (value : SourceValue F) (before : Heap F) (result : SourceValue F) (after : Heap F) : Prop := + OpenSource.EvalExpr world calls [] ((next.arg, value) :: locals) next.body before result after + +def Handlers.run (handlers : Handlers F) (world : SourceSemantics.World F) (calls : CallRelation F) + (locals : Environment F Nat) (target : ExitTarget) (value : SourceValue F) + (before : Heap F) (result : SourceValue F) (after : Heap F) : Prop := + ∃ next, handlers.lookup target = some next ∧ next.run world calls locals value before result after + +structure Fresh (name : String) (env : Renaming) (next : Continuation F) (handlers : Handlers F) : Prop where + scope : name ∉ env.map Prod.snd + next : name ∉ next.names + handlers : ∀ target next, handlers.lookup target = some next → name ∉ next.names + +theorem fresh_reserved (fresh : name ∉ reserved env next handlers) : Fresh name env next handlers := by + refine ⟨?_, ?_, ?_⟩ + · intro h; exact fresh (by simp [reserved, h]) + · intro h; exact fresh (by simp [reserved, h]) + · intro target k hk h + have member : (target, k) ∈ handlers := by + obtain ⟨left, right, rfl, _⟩ := List.lookup_eq_some_iff.mp hk + simp + exact fresh (by simp only [reserved, List.mem_append, List.mem_flatMap]; exact .inr ⟨_, member, h⟩) + +theorem env_prepend {names : List String} (extra : Environment F Nat) + (fresh : ∀ n ∈ names, n ∉ extra.map Prod.fst) : EnvAgrees names (extra ++ locals) locals := by + intro n hn + rw [List.find?_append, find_lookup, lookup_none (fresh n hn)] + rfl + +theorem Continuation.run_prepend (extra : Environment F Nat) + (fresh : ∀ n ∈ next.names, n ∉ extra.map Prod.fst) : + next.run world calls (extra ++ locals) value before result after ↔ + next.run world calls locals value before result after := by + apply OpenSource.evalExpr_env_iff + exact (env_prepend extra (fun n hn => fresh n (by simp [Continuation.names, hn]))).prepend [(next.arg, value)] + +theorem Continuation.run_add (fresh : name ∉ next.names) : + next.run world calls ((name, extra) :: locals) value before result after ↔ + next.run world calls locals value before result after := by + apply Continuation.run_prepend [(name, extra)] + intro n hn + simpa using (show n ≠ name from fun same => fresh (same ▸ hn)) + +theorem Handlers.run_add + (fresh : ∀ target next, handlers.lookup target = some next → name ∉ next.names) : + handlers.run world calls ((name, extra) :: locals) target value before result after ↔ + handlers.run world calls locals target value before result after := by + constructor <;> rintro ⟨next, found, ev⟩ + · exact ⟨next, found, (next.run_add (fresh _ _ found)).mp ev⟩ + · exact ⟨next, found, (next.run_add (fresh _ _ found)).mpr ev⟩ + +theorem Handlers.run_prepend (extra : Environment F Nat) + (fresh : ∀ target next, handlers.lookup target = some next → + ∀ n ∈ next.names, n ∉ extra.map Prod.fst) : + handlers.run world calls (extra ++ locals) target value before result after ↔ + handlers.run world calls locals target value before result after := by + constructor <;> rintro ⟨next, found, ev⟩ + · exact ⟨next, found, (next.run_prepend extra (fresh _ _ found)).mp ev⟩ + · exact ⟨next, found, (next.run_prepend extra (fresh _ _ found)).mpr ev⟩ + +theorem eval_apply : + OpenSource.EvalExpr world calls [] locals (next.apply expr) before result after ↔ + ∃ value middle, OpenSource.EvalExpr world calls [] locals expr before value middle ∧ + next.run world calls locals value middle result after := by + constructor + · intro h; cases h with + | letValue value matched body => + simp only [World.matchPattern, matchPatternWith, except_pure_ok, Option.some.injEq] at matched + subst matched + exact ⟨_, _, value, body⟩ + · rintro ⟨value, middle, ev, body⟩ + exact .letValue (bindings := [(next.arg, value)]) ev (by simp [World.matchPattern, matchPatternWith]) body + +theorem eval_apply_exec : + OpenSource.EvalExpr world calls [] locals (next.apply expr) before result after ↔ + Exec world calls [] locals expr + (fun value middle => next.run world calls locals value middle result after) (fun _ _ _ => False) before := by + rw [eval_apply] + simp only [Exec, and_false, exists_false, or_false] + +theorem exec_var_found (found : locals.find? (·.1 == name) = some (name, value)) : + Exec world calls [] locals (.var name) normal abrupt heap ↔ normal value heap := by + rw [exec_var, found] + simp only [Option.some.injEq, Prod.mk.injEq, true_and, exists_eq_left'] + +theorem exec_var_head : + Exec world calls [] ((name, value) :: locals) (.var name) normal abrupt heap ↔ normal value heap := + exec_var_found (by simp) + +theorem execArgs_pure {es : List (Expr F)} {vs : List (SourceValue F)} + (related : List.Forall₂ (fun e v => ∀ normal abrupt heap, + Exec world calls [] locals e normal abrupt heap ↔ normal v heap) es vs) : + ExecArgs world calls [] locals es normal abrupt heap ↔ normal vs heap := by + induction related generalizing normal with + | nil => exact execArgs_nil + | cons h _ ih => rw [execArgs_cons, h, ih] + +theorem exec_projects (found : locals.find? (·.1 == name) = some (name, .tuple values)) : + ExecArgs world calls [] locals (projects name values.length) normal abrupt heap ↔ normal values heap := by + apply execArgs_pure (vs := values) + apply List.forall₂_of_length_eq_of_get + · simp [projects] + · intro i hi hv normal abrupt heap + simp only [projects, List.get_eq_getElem, List.getElem_map, List.getElem_range] + rw [exec_project, exec_var_found found] + simp [projectValue, List.getElem?_eq_getElem hv, bind, Except.bind, pure, Except.pure] + +theorem run_repeat (fresh : input ∉ next.names) : + (Continuation.mk input (next.apply (.repeat (.var input) n))).run world calls locals value before result after ↔ + next.run world calls locals (.tuple (List.replicate n value)) before result after := by + change OpenSource.EvalExpr _ _ _ _ (next.apply _) _ _ _ ↔ _ + rw [eval_apply_exec, exec_repeat, exec_var_head] + simp only [Continuation.run_add fresh, Ty.subst_nil] + +theorem run_store (fresh : input ∉ next.names) : + (Continuation.mk input (next.apply (.store (.var input)))).run world calls locals value before result after ↔ + next.run world calls locals (.ptr value.type before.length) (before ++ [value]) result after := by + change OpenSource.EvalExpr _ _ _ _ (next.apply _) _ _ _ ↔ _ + rw [eval_apply_exec, exec_store, exec_var_head] + simp only [Continuation.run_add fresh, Ty.subst_nil] + +theorem run_index (fresh : input ∉ next.names) : + (Continuation.mk input (next.apply (.index (.var input) i))).run world calls locals value before result after ↔ + ∃ output, projectValue value i = .ok output ∧ next.run world calls locals output before result after := by + change OpenSource.EvalExpr _ _ _ _ (next.apply _) _ _ _ ↔ _ + rw [eval_apply_exec, exec_index, exec_var_head] + simp only [Continuation.run_add fresh, Ty.subst_nil] + +theorem run_project (fresh : input ∉ next.names) : + (Continuation.mk input (next.apply (.project (.var input) i))).run world calls locals value before result after ↔ + ∃ output, projectValue value i = .ok output ∧ next.run world calls locals output before result after := by + change OpenSource.EvalExpr _ _ _ _ (next.apply _) _ _ _ ↔ _ + rw [eval_apply_exec, exec_project, exec_var_head] + simp only [Continuation.run_add fresh, Ty.subst_nil] + +theorem run_member (fresh : input ∉ next.names) : + (Continuation.mk input (next.apply (.member (.var input) field))).run world calls locals value before result after ↔ + ∃ output, memberValue [] field value = .ok output ∧ next.run world calls locals output before result after := by + change OpenSource.EvalExpr _ _ _ _ (next.apply _) _ _ _ ↔ _ + rw [eval_apply_exec, exec_member, exec_var_head] + simp only [Continuation.run_add fresh, Ty.subst_nil] + +theorem run_slice (fresh : input ∉ next.names) : + (Continuation.mk input (next.apply (.slice (.var input) start stop))).run world calls locals value before result after ↔ + ∃ output, sliceValue value start stop = .ok output ∧ next.run world calls locals output before result after := by + change OpenSource.EvalExpr _ _ _ _ (next.apply _) _ _ _ ↔ _ + rw [eval_apply_exec, exec_slice, exec_var_head] + simp only [Continuation.run_add fresh, Ty.subst_nil] + +theorem run_load (fresh : input ∉ next.names) : + (Continuation.mk input (next.apply (.load (.var input)))).run world calls locals value before result after ↔ + ∃ output, loadValue before value = .ok output ∧ next.run world calls locals output before result after := by + change OpenSource.EvalExpr _ _ _ _ (next.apply _) _ _ _ ↔ _ + rw [eval_apply_exec, exec_load, exec_var_head] + simp only [Continuation.run_add fresh, Ty.subst_nil] + +theorem run_neg (fresh : input ∉ next.names) : + (Continuation.mk input (next.apply (.neg (.var input)))).run world calls locals value before result after ↔ + ∃ output, evalNeg value = .ok output ∧ next.run world calls locals output before result after := by + change OpenSource.EvalExpr _ _ _ _ (next.apply _) _ _ _ ↔ _ + rw [eval_apply_exec, exec_neg, exec_var_head] + simp only [Continuation.run_add fresh, Ty.subst_nil] + +theorem run_hint (fresh : input ∉ next.names) : + (Continuation.mk input (next.apply (.hint type (.var input) channel))).run world calls locals value before result after ↔ + ∃ output : Constant F, world.typed type.toCore output = true ∧ next.run world calls locals output.toValue before result after := by + change OpenSource.EvalExpr _ _ _ _ (next.apply _) _ _ _ ↔ _ + rw [eval_apply_exec, exec_hint, exec_var_head] + simp only [Continuation.run_add fresh, Ty.subst_nil] + +theorem run_construct (fresh : input ∉ next.names) : + (Continuation.mk input (next.apply (.construct name typeArgs ctor (projects input values.length)))).run world calls locals (.tuple values) before result after ↔ + next.run world calls locals (.construct (instanceName [] name typeArgs) ctor values) before result after := by + change OpenSource.EvalExpr _ _ _ _ (next.apply _) _ _ _ ↔ _ + rw [eval_apply_exec, exec_construct, exec_projects (by simp)] + simp only [Continuation.run_add fresh] + +theorem run_constructAs (fresh : input ∉ next.names) : + (Continuation.mk input (next.apply (.constructAs params type ctor (projects input values.length)))).run world calls locals (.tuple values) before result after ↔ + next.run world calls locals (.construct (constructorName [] type) ctor values) before result after := by + change OpenSource.EvalExpr _ _ _ _ (next.apply _) _ _ _ ↔ _ + rw [eval_apply_exec, exec_constructAs, exec_projects (by simp)] + simp only [Continuation.run_add fresh] + +theorem run_builtin (fresh : input ∉ next.names) : + (Continuation.mk input (next.apply (.builtin paths (projects input values.length)))).run + world calls locals (.tuple values) before result after ↔ + ∃ output, paths.apply values = .ok output ∧ + next.run world calls locals output before result after := by + change OpenSource.EvalExpr _ _ _ _ (next.apply _) _ _ _ ↔ _ + rw [eval_apply_exec, exec_builtin, exec_projects (by simp)] + simp only [Continuation.run_add fresh] + +theorem run_update (fresh : input ∉ next.names) : + (Continuation.mk input (next.apply (.update paths (projects input values.length)))).run + world calls locals (.tuple values) before result after ↔ + ∃ output, Update.value [] paths values = .ok output ∧ + next.run world calls locals output before result after := by + change OpenSource.EvalExpr _ _ _ _ (next.apply _) _ _ _ ↔ _ + rw [eval_apply_exec, exec_update, exec_projects (by simp)] + simp only [Continuation.run_add fresh] + +theorem run_record (fresh : input ∉ next.names) : + (Continuation.mk input (next.apply (.record head (projects input values.length)))).run world calls locals (.tuple values) before result after ↔ + next.run world calls locals (.construct (constructorName [] head.type) structConstructor (head.order values (.tuple []))) before result after := by + change OpenSource.EvalExpr _ _ _ _ (next.apply _) _ _ _ ↔ _ + rw [eval_apply_exec, exec_record, exec_projects (by simp)] + simp only [Continuation.run_add fresh] + +theorem run_call (fresh : input ∉ next.names) : + (Continuation.mk input (next.apply (.call name typeArgs (projects input values.length)))).run world calls locals (.tuple values) before result after ↔ + ∃ v a, calls (instanceName [] name typeArgs) values before v a ∧ next.run world calls locals v a result after := by + change OpenSource.EvalExpr _ _ _ _ (next.apply _) _ _ _ ↔ _ + rw [eval_apply_exec, exec_call, exec_projects (by simp)] + simp only [Continuation.run_add fresh] + +theorem run_binary (freshLeft : left ∉ next.names) (freshRight : right ∉ next.names) + (different : left ≠ right) : + (Continuation.mk right (next.apply (.binary op (.var left) (.var right)))).run + world calls ((left, x) :: locals) y before result after ↔ + ∃ output, evalBinOp op x y = .ok output ∧ next.run world calls locals output before result after := by + change OpenSource.EvalExpr _ _ _ _ (next.apply _) _ _ _ ↔ _ + rw [eval_apply_exec, exec_binary, exec_var_found (value := x) (by simp [different, Ne.symm different]), exec_var_head] + simp only [Continuation.run_add freshRight, Continuation.run_add freshLeft] + +theorem run_arguments (freshHead : head ∉ next.names) (freshTail : tail ∉ next.names) + (different : head ≠ tail) : + (Continuation.mk tail (next.apply (.tuple (.var head :: projects tail values.length)))).run + world calls ((head, value) :: locals) (.tuple values) before result after ↔ + next.run world calls locals (.tuple (value :: values)) before result after := by + change OpenSource.EvalExpr _ _ _ _ (next.apply _) _ _ _ ↔ _ + rw [eval_apply_exec, exec_tuple, execArgs_cons, + exec_var_found (value := value) (by simp [different, Ne.symm different]), exec_projects (by simp)] + simp only [Continuation.run_add freshTail, Continuation.run_add freshHead] + +end Aiur.Generic.ControlLower diff --git a/Aiur/Aiur/Generic/ControlEnvironment.lean b/Aiur/Aiur/Generic/ControlEnvironment.lean new file mode 100644 index 000000000..2ffd7cb75 --- /dev/null +++ b/Aiur/Aiur/Generic/ControlEnvironment.lean @@ -0,0 +1,333 @@ +import Aiur.Generic.EnvironmentFacts +import Aiur.Generic.ControlNoExit + +namespace Aiur.Generic.OpenSource +open SourceSemantics Engine +variable [Field F] [DecidableEq F] {world : SourceSemantics.World F} {calls : CallRelation F} + +theorem EvalExpr.changeLocals (ev : EvalExpr world calls types locals expr before value after) : + ∀ other, EnvAgrees (ControlLower.names expr) locals other → + EvalExpr world calls types other expr before value after := by + induction ev using EvalExpr.rec + (motive_2 := fun ts ls es b vs h _ => ∀ other, + EnvAgrees (es.flatMap ControlLower.names) ls other → EvalArgs world calls ts other es b vs h) + (motive_3 := fun ts ls e b target v h _ => ∀ other, + EnvAgrees (ControlLower.names e) ls other → EvalExit world calls ts other e b target v h) + (motive_4 := fun ts ls es b target v h _ => ∀ other, + EnvAgrees (es.flatMap ControlLower.names) ls other → EvalArgsExit world calls ts other es b target v h) with + | block _ ih => intro other agree; exact .block (ih other (by simpa only [ControlLower.names] using agree)) + | blockExit _ ih => intro other agree; exact .blockExit (ih other (by simpa only [ControlLower.names] using agree)) + | global found interpreted ev _ => intro _ _; exact .global found interpreted ev + | literal => intro _ _; exact .literal + | var lookup => + intro other agree + exact .var (by rw [← agree _ (by simp [ControlLower.names])]; exact lookup) + | array _ ih => intro other agree; exact .array (ih other (by simpa only [ControlLower.names] using agree)) + | constructAs _ ih => intro other agree; exact .constructAs (ih other (by simpa only [ControlLower.names] using agree)) + | builtin _ op ih => intro other agree; exact .builtin (ih other (by simpa only [ControlLower.names] using agree)) op + | update _ op ih => intro other agree; exact .update (ih other (by simpa only [ControlLower.names] using agree)) op + | record _ ih => intro other agree; exact .record (ih other (by simpa only [ControlLower.names] using agree)) + | «repeat» _ ih => intro other agree; exact .repeat (ih other (by simpa only [ControlLower.names] using agree)) + | index _ op ih => intro other agree; exact .index (ih other (by simpa only [ControlLower.names] using agree)) op + | slice _ op ih => intro other agree; exact .slice (ih other (by simpa only [ControlLower.names] using agree)) op + | tuple _ ih => intro other agree; exact .tuple (ih other (by simpa only [ControlLower.names] using agree)) + | construct _ ih => intro other agree; exact .construct (ih other (by simpa only [ControlLower.names] using agree)) + | project _ projected ih => intro other agree; exact .project (ih other (by simpa only [ControlLower.names] using agree)) projected + | member _ membered ih => intro other agree; exact .member (ih other (by simpa only [ControlLower.names] using agree)) membered + | letValue _ matched _ ih1 ih2 => + intro other agree + apply EvalExpr.letValue (ih1 other (agree.mono ?_)) matched + · apply ih2 _ ((agree.mono ?_).prepend _) + intro n hn + simp [ControlLower.names, hn] + · intro n hn + simp [ControlLower.names, hn] + | store _ ih => intro other agree; exact .store (ih other (by simpa only [ControlLower.names] using agree)) + | load _ loaded ih => intro other agree; exact .load (ih other (by simpa only [ControlLower.names] using agree)) loaded + | hint _ typed ih => intro other agree; exact .hint (ih other (by simpa only [ControlLower.names] using agree)) typed + | neg _ op ih => intro other agree; exact .neg (ih other (by simpa only [ControlLower.names] using agree)) op + | binary _ _ op ih1 ih2 => + intro other agree + exact .binary (ih1 other (agree.mono (by intros; simp [ControlLower.names, *]))) + (ih2 other (agree.mono (by intros; simp [ControlLower.names, *]))) op + | call _ callee ih => intro other agree; exact .call (ih other (by simpa only [ControlLower.names] using agree)) callee + | matchValue _ selected _ ih1 ih2 => + intro other agree + apply EvalExpr.matchValue + (ih1 other (agree.mono (by intros; simp [ControlLower.names, *]))) selected + apply ih2 _ ((agree.mono ?_).prepend _) + intro n hn + obtain ⟨pat, member⟩ := selected_member selected + simp only [ControlLower.names, List.mem_append, List.mem_flatMap] + exact Or.inr ⟨(pat, _), member, by simp [hn]⟩ + | nil => exact .nil + | cons _ _ ih1 ih2 => + rename_i other agree + exact .cons (ih1 other (agree.mono (by intros; simp [*]))) + (ih2 other (agree.mono (by intros; simp [*]))) + | exit _ ih => + rename_i other agree + exact .exit (ih other (by simpa only [ControlLower.names] using agree)) + | exitPayload _ ih => + rename_i other agree + exact .exitPayload (ih other (by simpa only [ControlLower.names] using agree)) + | fromBlock different _ ih => + rename_i other agree + exact .fromBlock different (ih other (by simpa only [ControlLower.names] using agree)) + | fromGlobal found interpreted ev _ => rename_i other _agree; exact .fromGlobal found interpreted ev + | fromTuple _ ih => + rename_i other agree + exact .fromTuple (ih other (by simpa only [ControlLower.names] using agree)) + | fromArray _ ih => + rename_i other agree + exact .fromArray (ih other (by simpa only [ControlLower.names] using agree)) + | fromRepeat _ ih => + rename_i other agree + exact .fromRepeat (ih other (by simpa only [ControlLower.names] using agree)) + | fromIndex _ ih => + rename_i other agree + exact .fromIndex (ih other (by simpa only [ControlLower.names] using agree)) + | fromSlice _ ih => + rename_i other agree + exact .fromSlice (ih other (by simpa only [ControlLower.names] using agree)) + | fromConstruct _ ih => + rename_i other agree + exact .fromConstruct (ih other (by simpa only [ControlLower.names] using agree)) + | fromConstructAs _ ih => + rename_i other agree + exact .fromConstructAs (ih other (by simpa only [ControlLower.names] using agree)) + | fromBuiltin _ ih => + rename_i other agree + exact .fromBuiltin (ih other (by simpa only [ControlLower.names] using agree)) + | fromUpdate _ ih => + rename_i other agree + exact .fromUpdate (ih other (by simpa only [ControlLower.names] using agree)) + | fromRecord _ ih => + rename_i other agree + exact .fromRecord (ih other (by simpa only [ControlLower.names] using agree)) + | fromProject _ ih => + rename_i other agree + exact .fromProject (ih other (by simpa only [ControlLower.names] using agree)) + | fromMember _ ih => + rename_i other agree + exact .fromMember (ih other (by simpa only [ControlLower.names] using agree)) + | fromStore _ ih => + rename_i other agree + exact .fromStore (ih other (by simpa only [ControlLower.names] using agree)) + | fromLoad _ ih => + rename_i other agree + exact .fromLoad (ih other (by simpa only [ControlLower.names] using agree)) + | fromHint _ ih => + rename_i other agree + exact .fromHint (ih other (by simpa only [ControlLower.names] using agree)) + | fromNeg _ ih => + rename_i other agree + exact .fromNeg (ih other (by simpa only [ControlLower.names] using agree)) + | fromCall _ ih => + rename_i other agree + exact .fromCall (ih other (by simpa only [ControlLower.names] using agree)) + | fromLetValue _ ih => + rename_i other agree + exact .fromLetValue (ih other (agree.mono (by intros; simp [ControlLower.names, *]))) + | binaryLeft _ ih => + rename_i other agree + exact .binaryLeft (ih other (agree.mono (by intros; simp [ControlLower.names, *]))) + | fromMatchValue _ ih => + rename_i other agree + exact .fromMatchValue (ih other (agree.mono (by intros; simp [ControlLower.names, *]))) + | letBody _ matched _ ih1 ih2 => + rename_i other agree + apply EvalExit.letBody (ih1 other (agree.mono ?_)) matched + · apply ih2 _ ((agree.mono ?_).prepend _) + intro n hn + simp [ControlLower.names, hn] + · intro n hn + simp [ControlLower.names, hn] + | binaryRight _ _ ih1 ih2 => + rename_i other agree + exact .binaryRight (ih1 other (agree.mono (by intros; simp [ControlLower.names, *]))) + (ih2 other (agree.mono (by intros; simp [ControlLower.names, *]))) + | matchBody _ selected _ ih1 ih2 => + rename_i other agree + apply EvalExit.matchBody + (ih1 other (agree.mono (by intros; simp [ControlLower.names, *]))) selected + apply ih2 _ ((agree.mono ?_).prepend _) + intro n hn + obtain ⟨pat, member⟩ := selected_member selected + simp only [ControlLower.names, List.mem_append, List.mem_flatMap] + exact Or.inr ⟨(pat, _), member, by simp [hn]⟩ + | head _ ih => + rename_i other agree + exact .head (ih other (agree.mono (by intros; simp [*]))) + | tail _ _ ih1 ih2 => + rename_i other agree + exact .tail (ih1 other (agree.mono (by intros; simp [*]))) + (ih2 other (agree.mono (by intros; simp [*]))) + +theorem EvalExit.changeLocals (ev : EvalExit world calls types locals expr before target value after) : + ∀ other, EnvAgrees (ControlLower.names expr) locals other → + EvalExit world calls types other expr before target value after := by + induction ev using EvalExit.rec + (motive_1 := fun ts ls e b v h _ => ∀ other, EnvAgrees (ControlLower.names e) ls other → EvalExpr world calls ts other e b v h) + (motive_2 := fun ts ls es b vs h _ => ∀ other, + EnvAgrees (es.flatMap ControlLower.names) ls other → EvalArgs world calls ts other es b vs h) + (motive_4 := fun ts ls es b target v h _ => ∀ other, + EnvAgrees (es.flatMap ControlLower.names) ls other → EvalArgsExit world calls ts other es b target v h) with + | block _ ih => rename_i other agree; exact .block (ih other (by simpa only [ControlLower.names] using agree)) + | blockExit _ ih => rename_i other agree; exact .blockExit (ih other (by simpa only [ControlLower.names] using agree)) + | global found interpreted ev _ => rename_i _other _agree; exact .global found interpreted ev + | literal => rename_i _other _agree; exact .literal + | var lookup => + rename_i other agree + exact .var (by rw [← agree _ (by simp [ControlLower.names])]; exact lookup) + | array _ ih => rename_i other agree; exact .array (ih other (by simpa only [ControlLower.names] using agree)) + | constructAs _ ih => rename_i other agree; exact .constructAs (ih other (by simpa only [ControlLower.names] using agree)) + | builtin _ op ih => rename_i other agree; exact .builtin (ih other (by simpa only [ControlLower.names] using agree)) op + | update _ op ih => rename_i other agree; exact .update (ih other (by simpa only [ControlLower.names] using agree)) op + | record _ ih => rename_i other agree; exact .record (ih other (by simpa only [ControlLower.names] using agree)) + | «repeat» _ ih => rename_i other agree; exact .repeat (ih other (by simpa only [ControlLower.names] using agree)) + | index _ op ih => rename_i other agree; exact .index (ih other (by simpa only [ControlLower.names] using agree)) op + | slice _ op ih => rename_i other agree; exact .slice (ih other (by simpa only [ControlLower.names] using agree)) op + | tuple _ ih => rename_i other agree; exact .tuple (ih other (by simpa only [ControlLower.names] using agree)) + | construct _ ih => rename_i other agree; exact .construct (ih other (by simpa only [ControlLower.names] using agree)) + | project _ projected ih => rename_i other agree; exact .project (ih other (by simpa only [ControlLower.names] using agree)) projected + | member _ membered ih => rename_i other agree; exact .member (ih other (by simpa only [ControlLower.names] using agree)) membered + | letValue _ matched _ ih1 ih2 => + rename_i other agree + apply EvalExpr.letValue (ih1 other (agree.mono ?_)) matched + · apply ih2 _ ((agree.mono ?_).prepend _) + intro n hn + simp [ControlLower.names, hn] + · intro n hn + simp [ControlLower.names, hn] + | store _ ih => rename_i other agree; exact .store (ih other (by simpa only [ControlLower.names] using agree)) + | load _ loaded ih => rename_i other agree; exact .load (ih other (by simpa only [ControlLower.names] using agree)) loaded + | hint _ typed ih => rename_i other agree; exact .hint (ih other (by simpa only [ControlLower.names] using agree)) typed + | neg _ op ih => rename_i other agree; exact .neg (ih other (by simpa only [ControlLower.names] using agree)) op + | binary _ _ op ih1 ih2 => + rename_i other agree + exact .binary (ih1 other (agree.mono (by intros; simp [ControlLower.names, *]))) + (ih2 other (agree.mono (by intros; simp [ControlLower.names, *]))) op + | call _ callee ih => rename_i other agree; exact .call (ih other (by simpa only [ControlLower.names] using agree)) callee + | matchValue _ selected _ ih1 ih2 => + rename_i other agree + apply EvalExpr.matchValue + (ih1 other (agree.mono (by intros; simp [ControlLower.names, *]))) selected + apply ih2 _ ((agree.mono ?_).prepend _) + intro n hn + obtain ⟨pat, member⟩ := selected_member selected + simp only [ControlLower.names, List.mem_append, List.mem_flatMap] + exact Or.inr ⟨(pat, _), member, by simp [hn]⟩ + | nil => exact .nil + | cons _ _ ih1 ih2 => + rename_i other agree + exact .cons (ih1 other (agree.mono (by intros; simp [*]))) + (ih2 other (agree.mono (by intros; simp [*]))) + | exit _ ih => + intro other agree + exact .exit (ih other (by simpa only [ControlLower.names] using agree)) + | exitPayload _ ih => + intro other agree + exact .exitPayload (ih other (by simpa only [ControlLower.names] using agree)) + | fromBlock different _ ih => + intro other agree + exact .fromBlock different (ih other (by simpa only [ControlLower.names] using agree)) + | fromGlobal found interpreted ev _ => intro other _agree; exact .fromGlobal found interpreted ev + | fromTuple _ ih => + intro other agree + exact .fromTuple (ih other (by simpa only [ControlLower.names] using agree)) + | fromArray _ ih => + intro other agree + exact .fromArray (ih other (by simpa only [ControlLower.names] using agree)) + | fromRepeat _ ih => + intro other agree + exact .fromRepeat (ih other (by simpa only [ControlLower.names] using agree)) + | fromIndex _ ih => + intro other agree + exact .fromIndex (ih other (by simpa only [ControlLower.names] using agree)) + | fromSlice _ ih => + intro other agree + exact .fromSlice (ih other (by simpa only [ControlLower.names] using agree)) + | fromConstruct _ ih => + intro other agree + exact .fromConstruct (ih other (by simpa only [ControlLower.names] using agree)) + | fromConstructAs _ ih => + intro other agree + exact .fromConstructAs (ih other (by simpa only [ControlLower.names] using agree)) + | fromBuiltin _ ih => + intro other agree + exact .fromBuiltin (ih other (by simpa only [ControlLower.names] using agree)) + | fromUpdate _ ih => + intro other agree + exact .fromUpdate (ih other (by simpa only [ControlLower.names] using agree)) + | fromRecord _ ih => + intro other agree + exact .fromRecord (ih other (by simpa only [ControlLower.names] using agree)) + | fromProject _ ih => + intro other agree + exact .fromProject (ih other (by simpa only [ControlLower.names] using agree)) + | fromMember _ ih => + intro other agree + exact .fromMember (ih other (by simpa only [ControlLower.names] using agree)) + | fromStore _ ih => + intro other agree + exact .fromStore (ih other (by simpa only [ControlLower.names] using agree)) + | fromLoad _ ih => + intro other agree + exact .fromLoad (ih other (by simpa only [ControlLower.names] using agree)) + | fromHint _ ih => + intro other agree + exact .fromHint (ih other (by simpa only [ControlLower.names] using agree)) + | fromNeg _ ih => + intro other agree + exact .fromNeg (ih other (by simpa only [ControlLower.names] using agree)) + | fromCall _ ih => + intro other agree + exact .fromCall (ih other (by simpa only [ControlLower.names] using agree)) + | fromLetValue _ ih => + intro other agree + exact .fromLetValue (ih other (agree.mono (by intros; simp [ControlLower.names, *]))) + | binaryLeft _ ih => + intro other agree + exact .binaryLeft (ih other (agree.mono (by intros; simp [ControlLower.names, *]))) + | fromMatchValue _ ih => + intro other agree + exact .fromMatchValue (ih other (agree.mono (by intros; simp [ControlLower.names, *]))) + | letBody _ matched _ ih1 ih2 => + intro other agree + apply EvalExit.letBody (ih1 other (agree.mono ?_)) matched + · apply ih2 _ ((agree.mono ?_).prepend _) + intro n hn + simp [ControlLower.names, hn] + · intro n hn + simp [ControlLower.names, hn] + | binaryRight _ _ ih1 ih2 => + intro other agree + exact .binaryRight (ih1 other (agree.mono (by intros; simp [ControlLower.names, *]))) + (ih2 other (agree.mono (by intros; simp [ControlLower.names, *]))) + | matchBody _ selected _ ih1 ih2 => + intro other agree + apply EvalExit.matchBody + (ih1 other (agree.mono (by intros; simp [ControlLower.names, *]))) selected + apply ih2 _ ((agree.mono ?_).prepend _) + intro n hn + obtain ⟨pat, member⟩ := selected_member selected + simp only [ControlLower.names, List.mem_append, List.mem_flatMap] + exact Or.inr ⟨(pat, _), member, by simp [hn]⟩ + | head _ ih => + rename_i other agree + exact .head (ih other (agree.mono (by intros; simp [*]))) + | tail _ _ ih1 ih2 => + rename_i other agree + exact .tail (ih1 other (agree.mono (by intros; simp [*]))) + (ih2 other (agree.mono (by intros; simp [*]))) + +theorem evalExpr_env_iff (agree : EnvAgrees (ControlLower.names expr) locals other) : + EvalExpr world calls types locals expr before value after ↔ EvalExpr world calls types other expr before value after := + ⟨fun h => h.changeLocals other agree, fun h => h.changeLocals locals agree.symm⟩ + +theorem evalExit_env_iff (agree : EnvAgrees (ControlLower.names expr) locals other) : + EvalExit world calls types locals expr before target value after ↔ EvalExit world calls types other expr before target value after := + ⟨fun h => h.changeLocals other agree, fun h => h.changeLocals locals agree.symm⟩ + +end Aiur.Generic.OpenSource diff --git a/Aiur/Aiur/Generic/ControlEval.lean b/Aiur/Aiur/Generic/ControlEval.lean new file mode 100644 index 000000000..7c916c4b3 --- /dev/null +++ b/Aiur/Aiur/Generic/ControlEval.lean @@ -0,0 +1,109 @@ +import Aiur.Generic.SourceSemantics + +namespace Aiur.Generic.SourceSemantics + +abbrev Outcome (F : Type) := Except (ExitTarget × SourceValue F) (SourceValue F) + +/-- The control effect is above the heap state: leaving a scope retains every +allocation already performed, while skipping the rest of its computation. -/ +abbrev FlowEvaluation (F : Type) := ExceptT (ExitTarget × SourceValue F) (Evaluation F) + +def Outcome.catch (target : ExitTarget) : Outcome F → Outcome F + | .ok value => .ok value + | .error (actual, value) => + if actual = target then .ok value else .error (actual, value) + +def flowError (error : EvalError) : FlowEvaluation F A := + ExceptT.mk (throw error) + +def catchExit (target : ExitTarget) (body : FlowEvaluation F (SourceValue F)) : + FlowEvaluation F (SourceValue F) := ExceptT.mk do + return Outcome.catch target (← body.run) + +def finishFunction (body : FlowEvaluation F (SourceValue F)) : Evaluation F (SourceValue F) := do + match ← (catchExit .function body).run with + | .ok value => return value + | .error (target, _) => throw (.unhandledExit (reprStr target)) + +def finishExpression (body : FlowEvaluation F (SourceValue F)) : Evaluation F (SourceValue F) := do + match ← body.run with + | .ok value => return value + | .error (target, _) => throw (.unhandledExit (reprStr target)) + +/-- Direct source execution. Neither exit propagation nor catching a block +invokes a source rewriting or circuit preparation pass. -/ +def evalOutcomeWith [Field F] [DecidableEq F] (world : World F) (hints : HintProvider world) + (types : Types) (locals : Environment F Nat) : Nat → Expr F → FlowEvaluation F (SourceValue F) + | 0, _ => flowError .outOfFuel + | fuel + 1, expr => do + match expr with + | .control (.block label) body => + catchExit (.block label) (evalOutcomeWith world hints types locals fuel body) + | .control (.exit target) value => + let value ← evalOutcomeWith world hints types locals fuel value + throw (target, value) + | .literal x => return .field x + | .var name => + let some (_, value) := locals.find? (·.1 == name) | flowError (.unboundVariable name) + return value + | .global name annotation => + let some type := annotation | flowError (.unboundVariable ("::" ++ name)) + let pattern ← liftM (world.constant name (type.subst types)) + let body ← liftM ((Consts.toExpr pattern).mapError (fun _ => EvalError.unboundVariable ("::" ++ name))) + evalOutcomeWith world hints [] [] fuel body + | .tuple items | .array items => return .tuple (← items.mapM (evalOutcomeWith world hints types locals fuel)) + | .repeat value n => return .tuple (List.replicate n (← evalOutcomeWith world hints types locals fuel value)) + | .index value i | .project value i => liftM (projectValue (← evalOutcomeWith world hints types locals fuel value) i) + | .slice value start stop => liftM (sliceValue (← evalOutcomeWith world hints types locals fuel value) start stop) + | .builtin op items => + liftM (op.apply (← items.mapM (evalOutcomeWith world hints types locals fuel))) + | .update paths items => + liftM (Update.value types paths (← items.mapM (evalOutcomeWith world hints types locals fuel))) + | .record head items => + let values ← items.mapM (evalOutcomeWith world hints types locals fuel) + return .construct (constructorName types head.type) structConstructor (head.order values (.tuple [])) + | .member value field => liftM (memberValue types field (← evalOutcomeWith world hints types locals fuel value)) + | .construct name args ctor items => + return .construct (instanceName types name args) ctor (← items.mapM (evalOutcomeWith world hints types locals fuel)) + | .constructAs _ t ctor items => + return .construct (constructorName types t) ctor (← items.mapM (evalOutcomeWith world hints types locals fuel)) + | .letValue pattern value body => + let value ← evalOutcomeWith world hints types locals fuel value + let some bindings ← liftM (world.matchPattern types (← get) pattern value) | flowError .patternMismatch + evalOutcomeWith world hints types (bindings ++ locals) fuel body + | .store value => + let value ← evalOutcomeWith world hints types locals fuel value + let heap ← get + set (heap ++ [value]) + return .ptr value.type heap.length + | .load pointer => + let pointer ← evalOutcomeWith world hints types locals fuel pointer + liftM (loadValue (← get) pointer) + | .hint t key channel => + let key ← evalOutcomeWith world hints types locals fuel key + let value ← liftM ((hints channel key (t.subst types).toCore).mapError EvalError.hint) + return value.val.toValue + | .neg value => liftM (evalNeg (← evalOutcomeWith world hints types locals fuel value)) + | .binary op left right => + liftM (evalBinOp op (← evalOutcomeWith world hints types locals fuel left) + (← evalOutcomeWith world hints types locals fuel right)) + | .call name args inputs => + let values ← inputs.mapM (evalOutcomeWith world hints types locals fuel) + let (calleeTypes, bindings, body) ← liftM (world.prepare (instanceName types name args) values) + liftM (finishFunction (evalOutcomeWith world hints calleeTypes bindings fuel body)) + | .matchValue scrutinee arms => + let value ← evalOutcomeWith world hints types locals fuel scrutinee + let some (bindings, body) ← liftM (selectArm world types (← get) value arms) | flowError .noMatchingArm + evalOutcomeWith world hints types (bindings ++ locals) fuel body + +/-- Execute a function body, handling its own return and rejecting an uncaught +block exit in an unchecked AST. The checker prevents the latter. -/ +def evalFunctionWith [Field F] [DecidableEq F] (world : World F) (hints : HintProvider world) + (types : Types) (locals : Environment F Nat) (fuel : Nat) (expr : Expr F) : Evaluation F (SourceValue F) := + finishFunction (evalOutcomeWith world hints types locals fuel expr) + +def evalExprWith [Field F] [DecidableEq F] (world : World F) (hints : HintProvider world) + (types : Types) (locals : Environment F Nat) (fuel : Nat) (expr : Expr F) : Evaluation F (SourceValue F) := + finishExpression (evalOutcomeWith world hints types locals fuel expr) + +end Aiur.Generic.SourceSemantics diff --git a/Aiur/Aiur/Generic/ControlEvalFacts.lean b/Aiur/Aiur/Generic/ControlEvalFacts.lean new file mode 100644 index 000000000..8b3ef8ff7 --- /dev/null +++ b/Aiur/Aiur/Generic/ControlEvalFacts.lean @@ -0,0 +1,121 @@ +import Aiur.Generic.ControlEval + +namespace Aiur.Generic.SourceSemantics + +set_option linter.unusedSimpArgs false + +namespace FlowEvaluation + +theorem pure_ok {value : A} {before after : Heap F} : + (pure value : FlowEvaluation F A).run before = .ok (outcome, after) ↔ + outcome = .ok value ∧ after = before := by + change Except.ok (.ok value, before) = Except.ok (outcome, after) ↔ _ + simp [eq_comm] + +theorem bind_ok {first : FlowEvaluation F A} {next : A → FlowEvaluation F B} + {before after : Heap F} : + (first >>= next).run before = .ok (outcome, after) ↔ + (∃ value middle, first.run before = .ok (.ok value, middle) ∧ + (next value).run middle = .ok (outcome, after)) ∨ + (∃ exit, first.run before = .ok (.error exit, after) ∧ outcome = .error exit) := by + simp only [bind, ExceptT.bind, ExceptT.mk, ExceptT.run, StateT.bind, + ExceptT.bindCont, pure, StateT.pure, Except.pure, Except.bind] + cases h : first before with + | error e => simp [h, Except.bind] + | ok pair => + rcases pair with ⟨result, heap⟩ + cases result with + | error exit => cases exit; simp [h, pure, StateT.pure, Except.pure, Prod.mk.injEq, eq_comm, and_comm] + | ok value => simp [h, Prod.mk.injEq] + +theorem lift_ok {action : Except EvalError A} {before after : Heap F} : + (liftM action : FlowEvaluation F A).run before = .ok (outcome, after) ↔ + ∃ value, action = .ok value ∧ outcome = .ok value ∧ after = before := by + cases action with + | error e => + change (Except.error e : Except EvalError _) = .ok (outcome, after) ↔ _ + simp + | ok value => + change Except.ok (.ok value, before) = Except.ok (outcome, after) ↔ _ + simp [eq_comm] + +theorem throw_ok {exit : ExitTarget × SourceValue F} {before after : Heap F} : + (throw exit : FlowEvaluation F A).run before = .ok (outcome, after) ↔ + outcome = .error exit ∧ after = before := by + change Except.ok (.error exit, before) = Except.ok (outcome, after) ↔ _ + simp [eq_comm] + +@[simp] theorem get_apply (heap : Heap F) : + (get : FlowEvaluation F (Heap F)).run heap = .ok (.ok heap, heap) := rfl + +@[simp] theorem set_apply (next heap : Heap F) : + (set next : FlowEvaluation F Unit).run heap = .ok (.ok (), next) := rfl + +@[simp] theorem error_apply (error : EvalError) (heap : Heap F) : + (flowError error : FlowEvaluation F A).run heap = .error error := rfl + +theorem liftEvaluation_apply (action : Evaluation F A) (heap : Heap F) : + (liftM action : FlowEvaluation F A).run heap = + (action heap).map (fun (value, after) => (.ok value, after)) := by + rfl + +theorem liftEvaluation_ok {action : Evaluation F A} {before after : Heap F} : + (liftM action : FlowEvaluation F A).run before = .ok (outcome, after) ↔ + ∃ value, action before = .ok (value, after) ∧ outcome = .ok value := by + rw [liftEvaluation_apply] + cases action before with + | error => simp [Except.map] + | ok pair => cases pair; simp [Except.map, eq_comm, and_comm] + +end FlowEvaluation + +theorem catchExit_ok {body : FlowEvaluation F (SourceValue F)} {before after : Heap F} : + (catchExit target body).run before = .ok (outcome, after) ↔ + ∃ input, body.run before = .ok (input, after) ∧ Outcome.catch target input = outcome := by + change (body.run >>= fun input => pure (Outcome.catch target input)) before = .ok (outcome, after) ↔ _ + simp only [Evaluation.bind_ok, Evaluation.pure_ok] + constructor + · rintro ⟨input, middle, run, result, rfl⟩; exact ⟨input, run, result⟩ + · rintro ⟨input, run, result⟩; exact ⟨input, after, run, result, rfl⟩ + +theorem finishFunction_ok {body : FlowEvaluation F (SourceValue F)} {before after : Heap F} : + finishFunction body before = .ok (value, after) ↔ + body.run before = .ok (.ok value, after) ∨ + body.run before = .ok (.error (.function, value), after) := by + cases h : body before with + | error error => simp [finishFunction, catchExit, Outcome.catch, ExceptT.run, ExceptT.mk, + bind, StateT.bind, Except.bind, h] + | ok pair => + rcases pair with ⟨result, heap⟩ + cases result with + | ok v => simp [finishFunction, catchExit, Outcome.catch, ExceptT.run, ExceptT.mk, + bind, StateT.bind, Except.bind, pure, StateT.pure, Except.pure, h, Prod.mk.injEq] + | error exit => + rcases exit with ⟨target, v⟩ + cases target <;> simp [finishFunction, catchExit, Outcome.catch, ExceptT.run, ExceptT.mk, + bind, StateT.bind, Except.bind, pure, StateT.pure, Except.pure, h, + throw, throwThe, MonadExceptOf.throw, StateT.lift, Prod.mk.injEq] + +theorem finishExpression_ok {body : FlowEvaluation F (SourceValue F)} {before after : Heap F} : + finishExpression body before = .ok (value, after) ↔ + body.run before = .ok (.ok value, after) := by + cases h : body before with + | error error => simp [finishExpression, ExceptT.run, bind, StateT.bind, Except.bind, h] + | ok pair => + rcases pair with ⟨result, heap⟩ + cases result <;> simp [finishExpression, ExceptT.run, bind, StateT.bind, + Except.bind, pure, StateT.pure, Except.pure, h, + throw, throwThe, MonadExceptOf.throw, StateT.lift, Prod.mk.injEq] + +def Outcome.Evaluates [Field F] [DecidableEq F] (world : World F) (types : Types) + (locals : Environment F Nat) (expr : Expr F) (before : Heap F) : Outcome F → Heap F → Prop + | .ok value, after => EvalExpr world types locals expr before value after + | .error (target, value), after => EvalExit world types locals expr before target value after + +def ArgsOutcome [Field F] [DecidableEq F] (world : World F) (types : Types) + (locals : Environment F Nat) (exprs : List (Expr F)) (before : Heap F) : + Except (ExitTarget × SourceValue F) (List (SourceValue F)) → Heap F → Prop + | .ok values, after => EvalArgs world types locals exprs before values after + | .error (target, value), after => EvalArgsExit world types locals exprs before target value after + +end Aiur.Generic.SourceSemantics diff --git a/Aiur/Aiur/Generic/ControlEvalSpec.lean b/Aiur/Aiur/Generic/ControlEvalSpec.lean new file mode 100644 index 000000000..0652c6e07 --- /dev/null +++ b/Aiur/Aiur/Generic/ControlEvalSpec.lean @@ -0,0 +1,224 @@ +import Aiur.Generic.ControlEvalFacts + +namespace Aiur.Generic.SourceSemantics + +variable {F : Type} [Field F] [DecidableEq F] +variable {world : World F} {types : Types} {hints : HintProvider world} + +private theorem args_spec {locals : Environment F Nat} {fuel : Nat} + (sound : ∀ expr before result after, + (evalOutcomeWith world hints types locals fuel expr).run before = .ok (result, after) → + Outcome.Evaluates world types locals expr before result after) + {args : List (Expr F)} {before after : Heap F} + (executed : (args.mapM (evalOutcomeWith world hints types locals fuel)).run before = .ok (outcome, after)) : + ArgsOutcome world types locals args before outcome after := by + induction args generalizing before outcome with + | nil => + obtain ⟨rfl, rfl⟩ := FlowEvaluation.pure_ok.mp executed + exact .nil + | cons head tail ih => + rw [List.mapM_cons] at executed + rcases FlowEvaluation.bind_ok.mp executed with ⟨value, middle, run, rest⟩ | ⟨⟨target, value⟩, run, rfl⟩ + · rcases FlowEvaluation.bind_ok.mp rest with ⟨values, last, tailRun, finished⟩ | ⟨⟨target, result⟩, tailRun, rfl⟩ + · obtain ⟨rfl, rfl⟩ := FlowEvaluation.pure_ok.mp finished + exact .cons (sound _ _ _ _ run) (ih tailRun) + · exact .tail (sound _ _ _ _ run) (ih tailRun) + · exact .head (sound _ _ _ _ run) + +/-- Successful execution gives either an ordinary evaluation or an explicit +exit derivation, including the exact heap retained at that point. -/ +theorem evalOutcome_spec {locals : Environment F Nat} {fuel : Nat} {expr : Expr F} + {before after : Heap F} {outcome : Outcome F} + (executed : (evalOutcomeWith world hints types locals fuel expr).run before = .ok (outcome, after)) : + Outcome.Evaluates world types locals expr before outcome after := by + induction fuel generalizing types locals expr before outcome after with + | zero => simp [evalOutcomeWith] at executed + | succ fuel ih => + cases expr with + | control kind body => + cases kind with + | block label => + obtain ⟨inner, run, caught⟩ := catchExit_ok.mp executed + cases inner with + | ok value => + simp only [Outcome.catch] at caught + subst outcome + exact .block (ih run) + | error exit => + rcases exit with ⟨target, value⟩ + by_cases same : target = .block label + · subst target + simp only [Outcome.catch, if_pos rfl] at caught + subst outcome + exact .blockExit (ih run) + · simp only [Outcome.catch, if_neg same] at caught + subst outcome + exact .fromBlock same (ih run) + | exit target => + rcases FlowEvaluation.bind_ok.mp executed with ⟨value, middle, run, rest⟩ | ⟨⟨other, value⟩, run, rfl⟩ + · obtain ⟨rfl, rfl⟩ := FlowEvaluation.throw_ok.mp rest + exact .exit (ih run) + · exact .exitPayload (ih run) + | literal value => + obtain ⟨rfl, rfl⟩ := FlowEvaluation.pure_ok.mp executed + exact .literal + | var name => + cases found : locals.find? (·.1 == name) with + | none => simp [evalOutcomeWith, found] at executed + | some binding => + rcases binding with ⟨key, value⟩ + have same : key = name := by simpa using List.find?_some found + subst key + simp only [evalOutcomeWith, found] at executed + obtain ⟨rfl, rfl⟩ := FlowEvaluation.pure_ok.mp executed + exact .var found + | builtin paths items => + simp only [evalOutcomeWith] at executed + rcases FlowEvaluation.bind_ok.mp executed with ⟨values, middle, run, operation⟩ | ⟨⟨target, value⟩, run, rfl⟩ + · obtain ⟨result, op, rfl, rfl⟩ := FlowEvaluation.lift_ok.mp operation + exact .builtin (args_spec (fun _ _ _ _ h => ih h) run) op + · exact .fromBuiltin (args_spec (fun _ _ _ _ h => ih h) run) + | update paths items => + simp only [evalOutcomeWith] at executed + rcases FlowEvaluation.bind_ok.mp executed with ⟨values, middle, run, operation⟩ | ⟨⟨target, value⟩, run, rfl⟩ + · obtain ⟨result, op, rfl, rfl⟩ := FlowEvaluation.lift_ok.mp operation + exact .update (args_spec (fun _ _ _ _ h => ih h) run) op + · exact .fromUpdate (args_spec (fun _ _ _ _ h => ih h) run) + | record head items | tuple items | array items | construct name args ctor items | constructAs params t ctor items => + simp only [evalOutcomeWith] at executed + rcases FlowEvaluation.bind_ok.mp executed with ⟨values, middle, run, finished⟩ | ⟨⟨target, value⟩, run, rfl⟩ + · obtain ⟨rfl, rfl⟩ := FlowEvaluation.pure_ok.mp finished + have args := args_spec (fun _ _ _ _ h => ih h) run + first | exact .record args | exact .tuple args | exact .array args | exact .construct args | exact .constructAs args + · have args := args_spec (fun _ _ _ _ h => ih h) run + first | exact .fromRecord args | exact .fromTuple args | exact .fromArray args | exact .fromConstruct args | exact .fromConstructAs args + | member value field | project value index | index value index | slice value start stop | neg value => + simp only [evalOutcomeWith] at executed + rcases FlowEvaluation.bind_ok.mp executed with ⟨input, middle, run, operation⟩ | ⟨⟨target, value⟩, run, rfl⟩ + · obtain ⟨result, op, rfl, rfl⟩ := FlowEvaluation.lift_ok.mp operation + first | exact .member (ih run) op | exact .project (ih run) op | exact .index (ih run) op + | exact .slice (ih run) op | exact .neg (ih run) op + · first | exact .fromMember (ih run) | exact .fromProject (ih run) | exact .fromIndex (ih run) + | exact .fromSlice (ih run) | exact .fromNeg (ih run) + | «repeat» value length => + simp only [evalOutcomeWith] at executed + rcases FlowEvaluation.bind_ok.mp executed with ⟨input, middle, run, finished⟩ | ⟨⟨target, result⟩, run, rfl⟩ + · obtain ⟨rfl, rfl⟩ := FlowEvaluation.pure_ok.mp finished + exact .repeat (ih run) + · exact .fromRepeat (ih run) + | global name ann => + cases ann with + | none => simp [evalOutcomeWith] at executed + | some type => + simp only [evalOutcomeWith] at executed + rcases FlowEvaluation.bind_ok.mp executed with ⟨pattern, middle, lookup, rest⟩ | ⟨exit, lookup, _⟩ + · obtain ⟨_, lookupOK, same, rfl⟩ := FlowEvaluation.lift_ok.mp lookup + cases same + rcases FlowEvaluation.bind_ok.mp rest with ⟨body, last, interpreted, run⟩ | ⟨exit, interpreted, _⟩ + · obtain ⟨_, interpretOK, same, rfl⟩ := FlowEvaluation.lift_ok.mp interpreted + cases same + have interpreted : Consts.toExpr pattern = .ok body := by + cases h : Consts.toExpr pattern <;> simp_all [Except.mapError] + cases outcome with + | ok => exact .global lookupOK interpreted (ih run) + | error exit => cases exit; exact .fromGlobal lookupOK interpreted (ih run) + · obtain ⟨_, _, impossible, _⟩ := FlowEvaluation.lift_ok.mp interpreted + cases impossible + · obtain ⟨_, _, impossible, _⟩ := FlowEvaluation.lift_ok.mp lookup + cases impossible + | hint type key channel => + simp only [evalOutcomeWith] at executed + rcases FlowEvaluation.bind_ok.mp executed with ⟨input, middle, run, rest⟩ | ⟨⟨target, value⟩, run, rfl⟩ + · rcases FlowEvaluation.bind_ok.mp rest with ⟨value, last, supplied, finished⟩ | ⟨exit, supplied, _⟩ + · obtain ⟨_, _, same, rfl⟩ := FlowEvaluation.lift_ok.mp supplied + cases same + obtain ⟨rfl, rfl⟩ := FlowEvaluation.pure_ok.mp finished + exact .hint (ih run) value.property + · obtain ⟨_, _, impossible, _⟩ := FlowEvaluation.lift_ok.mp supplied + cases impossible + · exact .fromHint (ih run) + | store value => + simp only [evalOutcomeWith] at executed + rcases FlowEvaluation.bind_ok.mp executed with ⟨input, middle, run, stored⟩ | ⟨⟨target, result⟩, run, rfl⟩ + · change Except.ok (.ok (.ptr input.type middle.length), middle ++ [input]) = .ok (outcome, after) at stored + cases Except.ok.inj stored + exact .store (ih run) + · exact .fromStore (ih run) + | load value => + simp only [evalOutcomeWith] at executed + rcases FlowEvaluation.bind_ok.mp executed with ⟨input, middle, run, loaded⟩ | ⟨⟨target, result⟩, run, rfl⟩ + · change (liftM (loadValue middle input) : FlowEvaluation F _).run middle = .ok (outcome, after) at loaded + obtain ⟨result, loadOK, rfl, rfl⟩ := FlowEvaluation.lift_ok.mp loaded + exact .load (ih run) loadOK + · exact .fromLoad (ih run) + | binary op left right => + simp only [evalOutcomeWith] at executed + rcases FlowEvaluation.bind_ok.mp executed with ⟨leftValue, middle, leftRun, rest⟩ | ⟨⟨target, result⟩, run, rfl⟩ + · rcases FlowEvaluation.bind_ok.mp rest with ⟨rightValue, last, rightRun, operation⟩ | ⟨⟨target, result⟩, rightRun, rfl⟩ + · obtain ⟨result, operationOK, rfl, rfl⟩ := FlowEvaluation.lift_ok.mp operation + exact .binary (ih leftRun) (ih rightRun) operationOK + · exact .binaryRight (ih leftRun) (ih rightRun) + · exact .binaryLeft (ih run) + | letValue pattern value body => + simp only [evalOutcomeWith] at executed + rcases FlowEvaluation.bind_ok.mp executed with ⟨input, middle, run, rest⟩ | ⟨⟨target, result⟩, run, rfl⟩ + · have rest' : (do + let some bindings ← liftM (world.matchPattern types middle pattern input) | flowError EvalError.patternMismatch + evalOutcomeWith world hints types (bindings ++ locals) fuel body : FlowEvaluation F _).run middle = .ok (outcome, after) := rest + rcases FlowEvaluation.bind_ok.mp rest' with ⟨bindings, last, matched, bodyRun⟩ | ⟨exit, matched, _⟩ + · obtain ⟨_, matchOK, same, rfl⟩ := FlowEvaluation.lift_ok.mp matched + cases same + cases bindings with + | none => simp at bodyRun + | some bindings => + cases outcome with + | ok => exact .letValue (ih run) matchOK (ih bodyRun) + | error exit => cases exit; exact .letBody (ih run) matchOK (ih bodyRun) + · obtain ⟨_, _, impossible, _⟩ := FlowEvaluation.lift_ok.mp matched + cases impossible + · exact .fromLetValue (ih run) + | matchValue scrutinee arms => + simp only [evalOutcomeWith] at executed + rcases FlowEvaluation.bind_ok.mp executed with ⟨input, middle, run, rest⟩ | ⟨⟨target, result⟩, run, rfl⟩ + · have rest' : (do + let some (bindings, body) ← liftM (selectArm world types middle input arms) | flowError EvalError.noMatchingArm + evalOutcomeWith world hints types (bindings ++ locals) fuel body : FlowEvaluation F _).run middle = .ok (outcome, after) := rest + rcases FlowEvaluation.bind_ok.mp rest' with ⟨selection, last, selected, bodyRun⟩ | ⟨exit, selected, _⟩ + · obtain ⟨_, selectionOK, same, rfl⟩ := FlowEvaluation.lift_ok.mp selected + cases same + cases selection with + | none => simp at bodyRun + | some pair => + rcases pair with ⟨bindings, body⟩ + cases outcome with + | ok => exact .matchValue (ih run) selectionOK (ih bodyRun) + | error exit => cases exit; exact .matchBody (ih run) selectionOK (ih bodyRun) + · obtain ⟨_, _, impossible, _⟩ := FlowEvaluation.lift_ok.mp selected + cases impossible + · exact .fromMatchValue (ih run) + | call name typeArgs args => + simp only [evalOutcomeWith] at executed + rcases FlowEvaluation.bind_ok.mp executed with ⟨values, middle, arguments, rest⟩ | ⟨⟨target, result⟩, arguments, rfl⟩ + · rcases FlowEvaluation.bind_ok.mp rest with ⟨⟨calleeTypes, bindings, body⟩, last, prepared, called⟩ | ⟨exit, prepared, _⟩ + · obtain ⟨_, prepareOK, same, rfl⟩ := FlowEvaluation.lift_ok.mp prepared + cases same + obtain ⟨result, functionRun, rfl⟩ := FlowEvaluation.liftEvaluation_ok + (action := finishFunction (evalOutcomeWith world hints calleeTypes bindings fuel body)) |>.mp called + apply EvalExpr.call (args_spec (fun _ _ _ _ h => ih h) arguments) + rcases finishFunction_ok.mp functionRun with normal | returned + · exact .intro prepareOK (ih normal) + · exact .returned prepareOK (ih returned) + · obtain ⟨_, _, impossible, _⟩ := FlowEvaluation.lift_ok.mp prepared + cases impossible + · exact .fromCall (args_spec (fun _ _ _ _ h => ih h) arguments) + +theorem evalFunction_spec {locals : Environment F Nat} {fuel : Nat} {expr : Expr F} + {before after : Heap F} + (prepared : world.prepare name args = .ok (types, locals, expr)) + (executed : evalFunctionWith world hints types locals fuel expr before = .ok (result, after)) : + EvalFn world name args before result after := by + rcases finishFunction_ok.mp executed with normal | returned + · exact .intro prepared (evalOutcome_spec normal) + · exact .returned prepared (evalOutcome_spec returned) + +end Aiur.Generic.SourceSemantics diff --git a/Aiur/Aiur/Generic/ControlLower.lean b/Aiur/Aiur/Generic/ControlLower.lean new file mode 100644 index 000000000..333112309 --- /dev/null +++ b/Aiur/Aiur/Generic/ControlLower.lean @@ -0,0 +1,185 @@ +import Aiur.Generic.PatternLowering +import Aiur.Generic.Consts + +/-! Eliminate lexical exits after source evaluation's semantic boundary. +Continuations are compiler syntax records, never Aiur function values. Every binder +is renamed before a continuation is placed beneath it, so an exiting scope +cannot capture a variable used after its target block. -/ + +namespace Aiur.Generic.ControlLower + +def hasControl : Expr α → Bool + | .control _ _ => true + | .literal _ | .var _ | .global _ _ => false + | .builtin _ xs | .update _ xs | .record _ xs | .tuple xs | .array xs | .construct _ _ _ xs | .constructAs _ _ _ xs | .call _ _ xs => + (xs.map hasControl).any id + | .member x _ | .repeat x _ | .index x _ | .slice x _ _ | .project x _ | .store x | .load x | .hint _ x channel | .neg x => hasControl x + | .letValue _ x b | .binary _ x b => hasControl x || hasControl b + | .matchValue x arms => hasControl x || (arms.map fun arm => hasControl arm.2).any id +termination_by expr => sizeOf expr +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +def names : Expr α → List String + | .literal _ | .global _ _ => [] + | .var name => [name] + | .builtin _ xs | .update _ xs | .record _ xs | .tuple xs | .array xs | .construct _ _ _ xs | .constructAs _ _ _ xs | .call _ _ xs => xs.flatMap names + | .member x _ | .control _ x | .repeat x _ | .index x _ | .slice x _ _ | .project x _ | .store x | .load x | .hint _ x channel | .neg x => names x + | .letValue pat x b => pat.bindingNames ++ names x ++ names b + | .binary _ x b => names x ++ names b + | .matchValue x arms => names x ++ arms.flatMap (fun arm => arm.1.bindingNames ++ names arm.2) +termination_by expr => sizeOf expr +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +abbrev Renaming := List (String × String) + +def rename (env : Renaming) (name : String) : String := (env.lookup name).getD name + +def renamePattern (env : Renaming) : Pattern α → Pattern α + | .literal x => .literal x + | .wildcard => .wildcard + | .bind name => .bind (rename env name) + | .global name type => .global name type + | .orElse left right names => .orElse (renamePattern env left) (renamePattern env right) { names with names := names.names.map (rename env) } + | .load p => .load (renamePattern env p) + | .record head ps => .record head (ps.map (renamePattern env)) + | .tuple ps => .tuple (ps.map (renamePattern env)) + | .array ps => .array (ps.map (renamePattern env)) + | .repeat p n => .repeat (renamePattern env p) n + | .construct t c ps => .construct t c (ps.map (renamePattern env)) + | .constructAs params t c ps => .constructAs params t c (ps.map (renamePattern env)) +termination_by pat => sizeOf pat + +/-- A continuation has one value parameter. Keeping it as syntax makes +freshness a finite check, including when it is copied into several arms. -/ +structure Continuation (α : Type) where + arg : String + body : Expr α + +abbrev Handlers (α : Type) := List (ExitTarget × Continuation α) + +def Continuation.names (next : Continuation α) : List String := next.arg :: ControlLower.names next.body + +def Continuation.apply (next : Continuation α) (value : Expr α) : Expr α := + .letValue (.bind next.arg) value next.body + +def reserved (env : Renaming) (next : Continuation α) (handlers : Handlers α) : List String := + env.map Prod.snd ++ next.names ++ handlers.flatMap (fun h => h.2.names) + +def fresh (used : List String) : Except String String := + let name := PatternLowering.freshPrefix used ++ "control" + if name ∈ used then .error "control temporary is not fresh" else .ok name + +def bindings (pat : Pattern α) (used : List String) : Except String Renaming := + let stem := PatternLowering.freshPrefix used ++ "control:" + let result := pat.bindingNames.eraseDups.zipIdx.map fun (name, i) => (name, stem ++ toString i) + if !(Consts.dependencies pat).isEmpty then .error "expand const patterns before control lowering" + else if !(result.map Prod.snd).Nodup then .error "duplicate control temporary" + else if !(result.all fun entry => !(used.contains entry.2)) then .error "control temporary captures a variable" + else .ok result + +def projects (name : String) (length : Nat) : List (Expr α) := + (List.range length).map (fun i => .project (.var name) i) + +mutual + def expression : Nat → Renaming → Expr α → Continuation α → Handlers α → Except String (Expr α) + | 0, _, _, _, _ => throw "control lowering depth exceeded" + | fuel + 1, env, expr, next, handlers => do + let used := reserved env next handlers + match expr with + | .control (.block label) body => + expression fuel env body next ((.block label, next) :: handlers) + | .control (.exit target) value => + let some handler := handlers.lookup target | throw s!"unbound control target {repr target}" + expression fuel env value handler handlers + | .literal value => return next.apply (.literal value) + | .var name => + let some renamed := env.lookup name | throw s!"unbound variable '{name}' during control lowering" + return next.apply (.var renamed) + | .global _ _ => throw "expand const expressions before control lowering" + | .tuple xs | .array xs => arguments fuel env xs next handlers + | .builtin op xs => + let input ← fresh (reserved env next handlers) + arguments fuel env xs ⟨input, next.apply (.builtin op (projects input xs.length))⟩ handlers + | .update paths xs => + let input ← fresh (reserved env next handlers) + arguments fuel env xs ⟨input, next.apply (.update paths (projects input xs.length))⟩ handlers + | .record head xs => + let input ← fresh used + arguments fuel env xs ⟨input, next.apply (.record head (projects input xs.length))⟩ handlers + | .construct name types ctor xs => + let input ← fresh used + arguments fuel env xs ⟨input, next.apply (.construct name types ctor (projects input xs.length))⟩ handlers + | .constructAs params t ctor xs => + let input ← fresh used + arguments fuel env xs ⟨input, next.apply (.constructAs params t ctor (projects input xs.length))⟩ handlers + | .call name types xs => + let input ← fresh used + arguments fuel env xs ⟨input, next.apply (.call name types (projects input xs.length))⟩ handlers + | .repeat x n => + let input ← fresh used + expression fuel env x ⟨input, next.apply (.repeat (.var input) n)⟩ handlers + | .index x i => + let input ← fresh used + expression fuel env x ⟨input, next.apply (.index (.var input) i)⟩ handlers + | .slice x start stop => + let input ← fresh used + expression fuel env x ⟨input, next.apply (.slice (.var input) start stop)⟩ handlers + | .member x field => + let input ← fresh used + expression fuel env x ⟨input, next.apply (.member (.var input) field)⟩ handlers + | .project x i => + let input ← fresh used + expression fuel env x ⟨input, next.apply (.project (.var input) i)⟩ handlers + | .store x => + let input ← fresh used + expression fuel env x ⟨input, next.apply (.store (.var input))⟩ handlers + | .load x => + let input ← fresh used + expression fuel env x ⟨input, next.apply (.load (.var input))⟩ handlers + | .hint t x channel => + let input ← fresh used + expression fuel env x ⟨input, next.apply (.hint t (.var input) channel)⟩ handlers + | .neg x => + let input ← fresh used + expression fuel env x ⟨input, next.apply (.neg (.var input))⟩ handlers + | .binary op x y => + let left ← fresh used + let right ← fresh (left :: used) + let rest ← expression fuel env y + ⟨right, next.apply (.binary op (.var left) (.var right))⟩ handlers + expression fuel env x ⟨left, rest⟩ handlers + | .letValue pat x body => + let bound ← bindings pat used + let input ← fresh ((bound.map Prod.snd) ++ used) + let rest ← expression fuel (bound ++ env) body next handlers + expression fuel env x ⟨input, .letValue (renamePattern bound pat) (.var input) rest⟩ handlers + | .matchValue x arms => + let input ← fresh used + let arms ← arms.mapM fun (pat, body) => do + let bound ← bindings pat used + return (renamePattern bound pat, ← expression fuel (bound ++ env) body next handlers) + expression fuel env x ⟨input, .matchValue (.var input) arms⟩ handlers + + def arguments : Nat → Renaming → List (Expr α) → Continuation α → Handlers α → Except String (Expr α) + | 0, _, _, _, _ => throw "control lowering depth exceeded" + | _ + 1, _, [], next, _ => return next.apply (.tuple []) + | fuel + 1, env, first :: rest, next, handlers => do + let used := reserved env next handlers + let head ← fresh used + let tail ← fresh (head :: used) + let remaining ← arguments fuel env rest + ⟨tail, next.apply (.tuple (.var head :: projects tail rest.length))⟩ handlers + expression fuel env first ⟨head, remaining⟩ handlers +end + +def function (expr : Expr α) (parameters : List String) : Except String (Expr α) := do + if !hasControl expr then return expr + let name ← fresh (parameters ++ names expr) + let next : Continuation α := ⟨name, .var name⟩ + expression 4096 (parameters.map fun name => (name, name)) expr next [(.function, next)] + +end Aiur.Generic.ControlLower diff --git a/Aiur/Aiur/Generic/ControlLoweringFacts.lean b/Aiur/Aiur/Generic/ControlLoweringFacts.lean new file mode 100644 index 000000000..a82022789 --- /dev/null +++ b/Aiur/Aiur/Generic/ControlLoweringFacts.lean @@ -0,0 +1,313 @@ +import Aiur.Generic.ControlBranchFacts +import Aiur.Generic.ControlNoExit +import Aiur.Generic.PreparationPatternFacts + +namespace Aiur.Generic.ControlLower +open SourceSemantics OpenSource +variable {F : Type} [Field F] [DecidableEq F] +variable {world : SourceSemantics.World F} {calls : CallRelation F} + +set_option maxRecDepth 4096 +set_option maxHeartbeats 1600000 + +mutual +/-- Concrete continuations preserve normal and abrupt source execution, +including the exact heap and every call premise. -/ +theorem expression_correct {env : Renaming} {expr code : Expr F} + {next : Continuation F} {handlers : Handlers F} + (built : expression fuel env expr next handlers = .ok code) : + Correct world calls env expr code next handlers := by + intro source target before result after scope + cases fuel with + | zero => simp [expression] at built + | succ fuel => + cases expr with + | literal value => + simp only [expression, except_pure_ok] at built + subst code + rw [eval_apply_exec, exec_literal, exec_literal] + | var name => + cases found : env.lookup name with + | none => simp [expression, found] at built + | some renamed => + simp only [expression, found, except_pure_ok] at built + subst code + rw [eval_apply_exec, exec_var, exec_var] + simp only [find_lookup_some, scope name renamed found] + | global name type => simp [expression] at built + | control kind body => + cases kind with + | block label => + rw [expression] at built + rw [expression_correct built _ _ _ _ _ scope, exec_block] + apply Exec.congr (fun _ _ => Iff.rfl) + intro t v h + by_cases same : t = .block label + · subst t; simp [Handlers.run] + · simp [Handlers.run, List.lookup_cons, beq_eq_false_iff_ne.mpr same, same] + | exit t => + cases found : handlers.lookup t with + | none => simp [expression, found] at built + | some handler => + simp only [expression, found] at built + rw [expression_correct built _ _ _ _ _ scope, exec_exit] + apply Exec.congr ?_ (fun _ _ _ => Iff.rfl) + intro v h + simp [Handlers.run, found] + | tuple xs => + rw [expression] at built + rw [arguments_correct built _ _ _ _ _ scope, exec_tuple] + | array xs => + rw [expression] at built + rw [arguments_correct built _ _ _ _ _ scope, exec_array] + | «repeat» x n => + simp only [expression, except_bind_ok] at built + obtain ⟨input, freshInput, child⟩ := built + have fresh := fresh_reserved (fresh_ok freshInput) + rw [expression_correct child _ _ _ _ _ scope, exec_repeat] + apply Exec.congr ?_ (fun _ _ _ => Iff.rfl) + intro v h + exact run_repeat fresh.next + | index x i => + simp only [expression, except_bind_ok] at built + obtain ⟨input, freshInput, child⟩ := built + have fresh := fresh_reserved (fresh_ok freshInput) + rw [expression_correct child _ _ _ _ _ scope, exec_index] + apply Exec.congr ?_ (fun _ _ _ => Iff.rfl) + intro v h + exact run_index fresh.next + | slice x start stop => + simp only [expression, except_bind_ok] at built + obtain ⟨input, freshInput, child⟩ := built + have fresh := fresh_reserved (fresh_ok freshInput) + rw [expression_correct child _ _ _ _ _ scope, exec_slice] + apply Exec.congr ?_ (fun _ _ _ => Iff.rfl) + intro v h + exact run_slice fresh.next + | project x i => + simp only [expression, except_bind_ok] at built + obtain ⟨input, freshInput, child⟩ := built + have fresh := fresh_reserved (fresh_ok freshInput) + rw [expression_correct child _ _ _ _ _ scope, exec_project] + apply Exec.congr ?_ (fun _ _ _ => Iff.rfl) + intro v h + exact run_project fresh.next + | member x field => + simp only [expression, except_bind_ok] at built + obtain ⟨input, freshInput, child⟩ := built + have fresh := fresh_reserved (fresh_ok freshInput) + rw [expression_correct child _ _ _ _ _ scope, exec_member] + apply Exec.congr ?_ (fun _ _ _ => Iff.rfl) + intro v h + exact run_member fresh.next + | store x => + simp only [expression, except_bind_ok] at built + obtain ⟨input, freshInput, child⟩ := built + have fresh := fresh_reserved (fresh_ok freshInput) + rw [expression_correct child _ _ _ _ _ scope, exec_store] + apply Exec.congr ?_ (fun _ _ _ => Iff.rfl) + intro v h + exact run_store fresh.next + | load x => + simp only [expression, except_bind_ok] at built + obtain ⟨input, freshInput, child⟩ := built + have fresh := fresh_reserved (fresh_ok freshInput) + rw [expression_correct child _ _ _ _ _ scope, exec_load] + apply Exec.congr ?_ (fun _ _ _ => Iff.rfl) + intro v h + exact run_load fresh.next + | hint type x channel => + simp only [expression, except_bind_ok] at built + obtain ⟨input, freshInput, child⟩ := built + have fresh := fresh_reserved (fresh_ok freshInput) + rw [expression_correct child _ _ _ _ _ scope, exec_hint] + apply Exec.congr ?_ (fun _ _ _ => Iff.rfl) + intro v h + simpa only [Ty.subst_nil] using (run_hint (world := world) (calls := calls) (locals := target) (type := type) (value := v) (before := h) (result := result) (after := after) fresh.next) + | neg x => + simp only [expression, except_bind_ok] at built + obtain ⟨input, freshInput, child⟩ := built + have fresh := fresh_reserved (fresh_ok freshInput) + rw [expression_correct child _ _ _ _ _ scope, exec_neg] + apply Exec.congr ?_ (fun _ _ _ => Iff.rfl) + intro v h + exact run_neg fresh.next + | construct name types ctor xs => + simp only [expression, except_bind_ok] at built + obtain ⟨input, freshInput, child⟩ := built + have fresh := fresh_reserved (fresh_ok freshInput) + rw [arguments_correct child _ _ _ _ _ scope, exec_construct] + apply ExecArgs.congr_length ?_ (fun _ _ _ => Iff.rfl) + intro vs h length + rw [← length] + exact run_construct fresh.next + | constructAs params type ctor xs => + simp only [expression, except_bind_ok] at built + obtain ⟨input, freshInput, child⟩ := built + have fresh := fresh_reserved (fresh_ok freshInput) + rw [arguments_correct child _ _ _ _ _ scope, exec_constructAs] + apply ExecArgs.congr_length ?_ (fun _ _ _ => Iff.rfl) + intro vs h length + rw [← length] + exact run_constructAs fresh.next + | builtin paths xs => + simp only [expression, except_bind_ok] at built + obtain ⟨input, freshInput, child⟩ := built + have fresh := fresh_reserved (fresh_ok freshInput) + rw [arguments_correct child _ _ _ _ _ scope, exec_builtin] + apply ExecArgs.congr_length ?_ (fun _ _ _ => Iff.rfl) + intro vs h length + rw [← length] + exact run_builtin fresh.next + | update paths xs => + simp only [expression, except_bind_ok] at built + obtain ⟨input, freshInput, child⟩ := built + have fresh := fresh_reserved (fresh_ok freshInput) + rw [arguments_correct child _ _ _ _ _ scope, exec_update] + apply ExecArgs.congr_length ?_ (fun _ _ _ => Iff.rfl) + intro vs h length + rw [← length] + exact run_update fresh.next + | record head xs => + simp only [expression, except_bind_ok] at built + obtain ⟨input, freshInput, child⟩ := built + have fresh := fresh_reserved (fresh_ok freshInput) + rw [arguments_correct child _ _ _ _ _ scope, exec_record] + apply ExecArgs.congr_length ?_ (fun _ _ _ => Iff.rfl) + intro vs h length + rw [← length] + exact run_record fresh.next + | call name types xs => + simp only [expression, except_bind_ok] at built + obtain ⟨input, freshInput, child⟩ := built + have fresh := fresh_reserved (fresh_ok freshInput) + rw [arguments_correct child _ _ _ _ _ scope, exec_call] + apply ExecArgs.congr_length ?_ (fun _ _ _ => Iff.rfl) + intro vs h length + rw [← length] + exact run_call fresh.next + | binary op x y => + simp only [expression, except_bind_ok] at built + obtain ⟨left, freshLeft, right, freshRight, rest, rightBuilt, leftBuilt⟩ := built + have fl := fresh_reserved (fresh_ok freshLeft) + have fr := fresh_reserved (show right ∉ reserved env next handlers from + fun h => fresh_ok freshRight (by simp [h])) + have different : left ≠ right := by intro h; subst right; exact fresh_ok freshRight (by simp) + rw [expression_correct leftBuilt _ _ _ _ _ scope, exec_binary] + apply Exec.congr ?_ (fun _ _ _ => Iff.rfl) + intro v h + change OpenSource.EvalExpr _ _ _ _ rest _ _ _ ↔ _ + rw [expression_correct rightBuilt _ _ _ _ _ (scope.add fl.scope v)] + apply Exec.congr ?_ ?_ + · intro w a; exact run_binary fl.next fr.next different + · intro t w a; exact Handlers.run_add fl.handlers + | letValue pat x body => + simp only [expression, except_bind_ok] at built + obtain ⟨bound, boundBuilt, input, freshInput, rest, bodyBuilt, xBuilt⟩ := built + have fresh := fresh_reserved (show input ∉ reserved env next handlers from + fun h => fresh_ok freshInput (by simp [h])) + rw [expression_correct xBuilt _ _ _ _ _ scope, exec_let] + apply Exec.congr ?_ (fun _ _ _ => Iff.rfl) + intro v h + change OpenSource.EvalExpr _ _ _ _ (.letValue _ (.var input) rest) _ _ _ ↔ _ + rw [eval_let_var] + exact branch_iff boundBuilt (expression_correct bodyBuilt) fresh scope + | matchValue x arms => + simp only [expression, except_bind_ok] at built + obtain ⟨input, freshInput, compiledArms, armsBuilt, xBuilt⟩ := built + have fresh := fresh_reserved (fresh_ok freshInput) + rw [expression_correct xBuilt _ _ _ _ _ scope, exec_match] + apply Exec.congr ?_ (fun _ _ _ => Iff.rfl) + intro v h + change OpenSource.EvalExpr _ _ _ _ (.matchValue (.var input) compiledArms) _ _ _ ↔ _ + rw [eval_match_var] + change Selected _ _ _ _ _ ↔ Selected _ _ _ _ _ + apply Iff.symm + apply selected_congr + apply (Preparation.mapM_relation armsBuilt).imp + intro a b built + rcases a with ⟨pat, body⟩ + simp only [except_bind_ok, except_pure_ok] at built + obtain ⟨bound, boundBuilt, rest, bodyBuilt, rfl⟩ := built + exact ⟨(branch_iff boundBuilt (expression_correct bodyBuilt) fresh scope).symm, + (renamed_none (bindings_ok boundBuilt).1).symm⟩ +termination_by fuel + +theorem arguments_correct {env : Renaming} {exprs : List (Expr F)} {code : Expr F} + {next : Continuation F} {handlers : Handlers F} + (built : arguments fuel env exprs next handlers = .ok code) : + ArgsCorrect world calls env exprs code next handlers := by + intro source target before result after scope + cases fuel with + | zero => simp [arguments] at built + | succ fuel => + cases exprs with + | nil => + simp only [arguments, except_pure_ok] at built + subst code + rw [eval_apply_exec, exec_tuple, execArgs_nil, execArgs_nil] + | cons first rest => + simp only [arguments, except_bind_ok] at built + obtain ⟨head, freshHead, tail, freshTail, remaining, tailBuilt, headBuilt⟩ := built + have fh := fresh_reserved (fresh_ok freshHead) + have ft := fresh_reserved (show tail ∉ reserved env next handlers from + fun h => fresh_ok freshTail (by simp [h])) + have different : head ≠ tail := by intro h; subst tail; exact fresh_ok freshTail (by simp) + rw [expression_correct headBuilt _ _ _ _ _ scope, execArgs_cons] + apply Exec.congr ?_ (fun _ _ _ => Iff.rfl) + intro v h + change OpenSource.EvalExpr _ _ _ _ remaining _ _ _ ↔ _ + rw [arguments_correct tailBuilt _ _ _ _ _ (scope.add fh.scope v)] + apply ExecArgs.congr_length ?_ ?_ + · intro vs a length + rw [← length] + exact run_arguments fh.next ft.next different + · intro t w a; exact Handlers.run_add fh.handlers +termination_by fuel +end + +/-- The final continuation simply returns its argument. -/ +theorem run_identity : + (Continuation.mk name (.var name)).run world calls locals value before result after ↔ + value = result ∧ before = after := by + constructor + · intro h; cases h with + | var found => exact ⟨by simpa using found, rfl⟩ + · rintro ⟨rfl, rfl⟩; exact .var (by simp) + +/-- A compiled function catches exactly its own return. Named exits are +resolved lexically inside the function, never across a call boundary. -/ +theorem function_correct (built : function expr parameters = .ok code) : + OpenSource.EvalExpr world calls [] locals code before result after ↔ + OpenSource.EvalExpr world calls [] locals expr before result after ∨ + OpenSource.EvalExit world calls [] locals expr before .function result after := by + unfold function at built + split at built + · rename_i absent + have absent : hasControl expr = false := by simpa using absent + obtain rfl := except_pure_ok.mp built + constructor + · exact Or.inl + · rintro (normal | abrupt) + · exact normal + · exact (abrupt.hasControl absent).elim + · simp only [except_bind_ok, except_pure_ok, exists_eq_left'] at built + obtain ⟨_, _, name, fresh, compiled⟩ := built + rw [expression_correct compiled _ _ _ _ _ (ScopeRel.identity parameters locals)] + simp only [Exec, run_identity, Handlers.run, List.lookup_cons, List.lookup_nil] + constructor + · rintro (⟨v, h, ev, rfl, rfl⟩ | ⟨t, v, h, ev, k, found, post⟩) + · exact .inl ev + · cases t with + | block label => cases found + | function => + have same : k = ⟨name, .var name⟩ := by simpa using found.symm + subst k + obtain ⟨rfl, rfl⟩ := run_identity.mp post + exact .inr ev + · rintro (normal | abrupt) + · exact .inl ⟨_, _, normal, rfl, rfl⟩ + · exact .inr ⟨.function, _, _, abrupt, ⟨name, .var name⟩, by simp, + run_identity.mpr ⟨rfl, rfl⟩⟩ + +end Aiur.Generic.ControlLower diff --git a/Aiur/Aiur/Generic/ControlNoExit.lean b/Aiur/Aiur/Generic/ControlNoExit.lean new file mode 100644 index 000000000..dbf6ca502 --- /dev/null +++ b/Aiur/Aiur/Generic/ControlNoExit.lean @@ -0,0 +1,77 @@ +import Aiur.Generic.ControlLower +import Aiur.Generic.ConstScopeFacts + +namespace Aiur.Generic +open SourceSemantics + +theorem Consts.Closed.noControl (closed : Consts.Closed expr) : + ControlLower.hasControl expr = false := by + induction closed with + | literal | global => simp [ControlLower.hasControl] + | «repeat» _ ih | store _ ih => simpa only [ControlLower.hasControl] using ih + | record _ ih | tuple _ ih | array _ ih | construct _ ih | constructAs _ ih => + simpa [ControlLower.hasControl, List.any_eq_false] using ih + +theorem selected_member [DecidableEq F] {world : World F} + {arms : List (Pattern F × Expr F)} + (selected : SourceSemantics.selectArm world types heap input arms = .ok (some (bindings, body))) : + ∃ pat, (pat, body) ∈ arms := by + induction arms with + | nil => simp [SourceSemantics.selectArm] at selected + | cons arm arms ih => + rcases arm with ⟨pat, expr⟩ + cases matched : world.matchPattern types heap pat input with + | error e => simp [SourceSemantics.selectArm, matched, bind, Except.bind] at selected + | ok bs => cases bs with + | none => + obtain ⟨p, hp⟩ := ih (by simpa [SourceSemantics.selectArm, matched, bind, Except.bind] using selected) + exact ⟨p, by simp [hp]⟩ + | some bs => + have same : bs = bindings ∧ expr = body := by + simpa [SourceSemantics.selectArm, matched, bind, Except.bind, pure, Except.pure] using selected + obtain ⟨rfl, rfl⟩ := same + exact ⟨pat, by simp⟩ + +namespace OpenSource +variable [Field F] [DecidableEq F] {world : World F} {calls : CallRelation F} + +/-- Calls catch their own returns; closed const templates cannot introduce +an exit. Thus only explicit control syntax can exit an expression. -/ +theorem EvalExit.hasControl (ev : EvalExit world calls types locals expr before target result after) : + ControlLower.hasControl expr = false → False := by + induction ev using EvalExit.rec + (motive_1 := fun _ _ _ _ _ _ _ => True) + (motive_2 := fun _ _ _ _ _ _ _ => True) + (motive_4 := fun _ _ es _ _ _ _ _ => + (∀ e ∈ es, ControlLower.hasControl e = false) → False) with + | exit | exitPayload | fromBlock => simp [ControlLower.hasControl] + | fromGlobal _ interpreted _ ih => + intro _ + exact ih (Consts.toExpr_closed _ interpreted).noControl + | fromBuiltin _ ih | fromUpdate _ ih | fromRecord _ ih | fromTuple _ ih | fromArray _ ih | fromConstruct _ ih | fromConstructAs _ ih | fromCall _ ih => + intro h + apply ih + simpa [ControlLower.hasControl, List.any_eq_false] using h + | fromMember _ ih | fromRepeat _ ih | fromIndex _ ih | fromSlice _ ih | fromProject _ ih + | fromStore _ ih | fromLoad _ ih | fromHint _ ih | fromNeg _ ih => + simpa only [ControlLower.hasControl] using ih + | fromLetValue _ ih | binaryLeft _ ih | fromMatchValue _ ih => + intro h + simp only [ControlLower.hasControl, Bool.or_eq_false_iff] at h + exact ih h.1 + | letBody _ _ _ _ ih | binaryRight _ _ _ ih => + intro h + simp only [ControlLower.hasControl, Bool.or_eq_false_iff] at h + exact ih h.2 + | matchBody _ selected _ _ ih => + intro h + obtain ⟨pat, member⟩ := selected_member selected + simp only [ControlLower.hasControl, Bool.or_eq_false_iff, + List.any_map, List.any_eq_false, Function.comp_def, id_eq] at h + exact ih (by simpa using h.2 _ member) + | head _ ih => rename_i h; exact ih (h _ (by simp)) + | tail _ _ _ ih => rename_i h; exact ih (fun e he => h e (by simp [he])) + | _ => trivial + +end OpenSource +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/ControlPatternFacts.lean b/Aiur/Aiur/Generic/ControlPatternFacts.lean new file mode 100644 index 000000000..f3aa50c73 --- /dev/null +++ b/Aiur/Aiur/Generic/ControlPatternFacts.lean @@ -0,0 +1,259 @@ +import Aiur.Generic.ControlEnvironment +import Aiur.Generic.BindingOrderFacts +import Mathlib.Data.List.Nodup + +namespace Aiur.Generic.ControlLower +set_option linter.unusedSimpArgs false +open SourceSemantics Preparation + +def renameBindings (env : Renaming) (bs : Environment F Nat) : Environment F Nat := + bs.map (fun (name, value) => (rename env name, value)) + +@[simp] theorem renameBindings_nil : renameBindings env ([] : Environment F Nat) = [] := rfl + +@[simp] theorem renameBindings_append (left right : Environment F Nat) : + renameBindings env (left ++ right) = renameBindings env left ++ renameBindings env right := + List.map_append + +theorem matchList_rename [DecidableEq F] + {left : A → SourceValue F → Except EvalError (Option (Environment F Nat))} + {right : B → SourceValue F → Except EvalError (Option (Environment F Nat))} + {xs : List A} {ys : List B} + (related : List.Forall₂ (fun x y => ∀ v, + right y v = (left x v).map (Option.map (renameBindings env))) xs ys) + (values : List (SourceValue F)) : + matchListWith right ys values = + (matchListWith left xs values).map (Option.map (renameBindings env)) := by + induction related generalizing values with + | nil => cases values <;> rfl + | @cons x y xs ys rel _ ih => + cases values with + | nil => rfl + | cons value values => + simp only [matchListWith, rel, ih] + cases left x value with + | error e => rfl + | ok bs => cases bs with + | none => rfl + | some bs => + cases matchListWith left xs values with + | error e => rfl + | ok rest => cases rest <;> + simp [Except.map, Option.map, bind, Except.bind, pure, Except.pure] + +/-- Renaming a pattern changes only the keys of its successful bindings. +It preserves failure, short-circuiting, and invalid-pointer errors exactly. -/ +theorem matchPattern_rename [DecidableEq F] + (pat : Pattern F) (plain : Consts.dependencies pat = []) + (env : Renaming) (constant depth types heap value) : + matchPatternWith constant depth types heap (renamePattern env pat) value = + (matchPatternWith constant depth types heap pat value).map (Option.map (renameBindings env)) := by + have sub (p : Pattern F) (smaller : sizeOf p < sizeOf pat) + (hp : Consts.dependencies p = []) (v : SourceValue F) : + matchPatternWith constant depth types heap (renamePattern env p) v = + (matchPatternWith constant depth types heap p v).map (Option.map (renameBindings env)) := + matchPattern_rename p hp env constant depth types heap v + have children (ps : List (Pattern F)) (small : ∀ p ∈ ps, sizeOf p < sizeOf pat) + (plain : ∀ p ∈ ps, Consts.dependencies p = []) (vs : List (SourceValue F)) : + matchListWith (fun p v => matchPatternWith constant depth types heap p.val v) + (ps.map (renamePattern env)).attach vs = + (matchListWith (fun p v => matchPatternWith constant depth types heap p.val v) ps.attach vs).map + (Option.map (renameBindings env)) := by + rw [matchList_attach, matchList_attach] + apply matchList_rename + apply List.forall₂_map_right_iff.mpr + exact List.forall₂_same.mpr (fun p hp => sub p (small p hp) (plain p hp)) + cases pat with + | literal x => + cases value <;> simp [renamePattern, matchPatternWith, Aiur.Pattern.bindings, renameBindings, pure, Except.pure, Except.map] + | wildcard | bind => simp [renamePattern, matchPatternWith, renameBindings, pure, Except.pure, Except.map] + | global => simp [Consts.dependencies] at plain + | orElse left right layout => + have plain := plain + simp only [Consts.dependencies, List.append_eq_nil_iff] at plain + simp only [renamePattern, matchPatternWith, + sub left (by simp_wf; omega) plain.1, sub right (by simp_wf; omega) plain.2] + cases hl : matchPatternWith constant depth types heap left value with + | error e => rfl + | ok selected => + cases selected with + | some bs => + simp only [Except.map, Option.map, bind, Except.bind, pure, Except.pure, + List.length_map, renameBindings, reorderBindings_rename] + cases reorderBindings layout.names (List.range layout.names.length) bs <;> rfl + | none => + cases hr : matchPatternWith constant depth types heap right value with + | error e => rfl + | ok selected => + cases selected with + | none => rfl + | some bs => + simp only [Except.map, Option.map, bind, Except.bind, pure, Except.pure, + List.length_map, renameBindings, reorderBindings_rename] + cases reorderBindings layout.names layout.rightOrder bs <;> rfl + | load p => + simp only [renamePattern, matchPatternWith] + cases loaded : loadValue heap value with + | error e => rfl + | ok v => exact sub p (by simp_wf <;> omega) (by simpa [Consts.dependencies] using plain) v + | record head ps => + have noGlobals : ∀ p ∈ ps, Consts.dependencies p = [] := by + simpa [Consts.dependencies, List.flatMap_eq_nil_iff] using plain + have rel : List.Forall₂ (fun p q => ∀ v, + matchPatternWith constant depth types heap q v = + (matchPatternWith constant depth types heap p v).map (Option.map (renameBindings env))) + ps (ps.map (renamePattern env)) := by + apply List.forall₂_map_right_iff.mpr + apply List.forall₂_same.mpr + intro p hp + exact sub p (by simp_wf; have := List.sizeOf_lt_of_mem hp; omega) (noGlobals p hp) + have ordered := head.order_rel rel (a := Pattern.wildcard) (b := Pattern.wildcard) + (by intro v; simp [matchPatternWith, renameBindings, pure, Except.pure, Except.map]) + cases value <;> simp only [renamePattern, match_record, ordered.length_eq] + all_goals first | rfl | skip + split + · rfl + · split + · rfl + · exact matchList_rename ordered _ + | tuple ps | array ps | construct _ _ ps | constructAs _ _ _ ps => + have noGlobals : ∀ p ∈ ps, Consts.dependencies p = [] := by + simpa [Consts.dependencies, List.flatMap_eq_nil_iff] using plain + have ih := children ps (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) noGlobals + cases value <;> simp only [renamePattern, matchPatternWith, List.length_map] + all_goals first | rfl | skip + all_goals split + all_goals first | rfl | apply ih + | «repeat» p n => + have hp : Consts.dependencies p = [] := by simpa [Consts.dependencies] using plain + cases value <;> simp only [renamePattern, matchPatternWith] + all_goals first | rfl | skip + split + · rfl + · apply matchList_rename + exact List.forall₂_same.mpr (fun _ _ v => sub p (by simp_wf <;> omega) hp v) +termination_by sizeOf pat +decreasing_by all_goals exact smaller + +theorem matchList_names + {run : A → SourceValue F → Except EvalError (Option (Environment F Nat))} + {xs : List A} {vs : List (SourceValue F)} {bs : Environment F Nat} + (getNames : A → List String) + (correct : ∀ x ∈ xs, ∀ v result, run x v = .ok (some result) → result.map Prod.fst = getNames x) + (matched : matchListWith run xs vs = .ok (some bs)) : + bs.map Prod.fst = xs.flatMap getNames := by + induction xs generalizing vs bs with + | nil => cases vs <;> simp_all [matchListWith, pure, Except.pure] + | cons x xs ih => + cases vs with + | nil => simp [matchListWith] at matched + | cons v vs => + cases hfirst : run x v with + | error e => simp [matchListWith, hfirst, bind, Except.bind] at matched + | ok first => cases first with + | none => simp [matchListWith, hfirst, bind, Except.bind] at matched + | some bindings => + cases hrest : matchListWith run xs vs with + | error e => simp [matchListWith, hfirst, hrest, bind, Except.bind] at matched + | ok rest => cases rest with + | none => simp [matchListWith, hfirst, hrest, bind, Except.bind] at matched + | some more => + have same : bindings ++ more = bs := by + simpa [matchListWith, hfirst, hrest, bind, Except.bind, pure, Except.pure] using matched + subst bs + simp only [List.map_append, List.flatMap_cons] + rw [correct x (by simp) _ _ hfirst, ih (fun y hy => correct y (by simp [hy])) hrest] + +theorem matchPattern_names [DecidableEq F] + (pat : Pattern F) (plain : Consts.dependencies pat = []) + {constant depth types heap value bs} + (matched : matchPatternWith constant depth types heap pat value = .ok (some bs)) : + bs.map Prod.fst = pat.bindingNames := by + have sub (p : Pattern F) (smaller : sizeOf p < sizeOf pat) + (hp : Consts.dependencies p = []) {v : SourceValue F} {bindings} + (h : matchPatternWith constant depth types heap p v = .ok (some bindings)) : + bindings.map Prod.fst = p.bindingNames := matchPattern_names p hp h + cases pat with + | literal x => + cases value <;> simp [matchPatternWith, Aiur.Pattern.bindings] at matched + simp_all [Pattern.bindingNames] + | wildcard | bind => + simp only [matchPatternWith, except_pure_ok, Option.some.injEq] at matched + subst bs + simp [Pattern.bindingNames] + | global => simp [Consts.dependencies] at plain + | orElse left right layout => + simp only [Pattern.bindingNames] + cases hl : matchPatternWith constant depth types heap left value with + | error e => simp [matchPatternWith, hl, bind, Except.bind] at matched + | ok selected => + cases selected with + | some first => + simp only [matchPatternWith, hl, bind, Except.bind, pure, Except.pure] at matched + cases ordered : reorderBindings layout.names (List.range layout.names.length) first with + | none => simp [ordered] at matched + | some result => + simp only [ordered, Except.ok.injEq, Option.some.injEq] at matched + subst bs + exact reorderBindings_names ordered + | none => + cases hr : matchPatternWith constant depth types heap right value with + | error e => simp [matchPatternWith, hl, hr, bind, Except.bind, pure, Except.pure, Except.map] at matched + | ok selected => + cases selected with + | none => simp [matchPatternWith, hl, hr, bind, Except.bind, pure, Except.pure, Except.map] at matched + | some second => + simp only [matchPatternWith, hl, hr, bind, Except.bind, pure, Except.pure, Except.map] at matched + cases ordered : reorderBindings layout.names layout.rightOrder second with + | none => simp [ordered] at matched + | some result => + simp only [ordered, Except.ok.injEq, Option.some.injEq] at matched + subst bs + exact reorderBindings_names ordered + | load p => + simp only [matchPatternWith, except_bind_ok] at matched + obtain ⟨v, _, matched⟩ := matched + simpa only [Pattern.bindingNames] using sub p (by simp_wf <;> omega) (by simpa [Consts.dependencies] using plain) matched + | record head ps => + have noGlobals : ∀ p ∈ ps, Consts.dependencies p = [] := by + simpa [Consts.dependencies, List.flatMap_eq_nil_iff] using plain + cases value <;> simp only [match_record] at matched + all_goals try simp only [Except.ok.injEq, reduceCtorEq] at matched + split at matched + · simp at matched + · split at matched + · simp at matched + · rw [record_bindingNames] + apply matchList_names Pattern.bindingNames _ matched + refine head.order_mem (P := fun x => ∀ v result, matchPatternWith constant depth types heap x v = .ok (some result) → result.map Prod.fst = x.bindingNames) ps Pattern.wildcard ?_ ?_ + · intro p hp v bindings h + exact sub p (by simp_wf; have := List.sizeOf_lt_of_mem hp; omega) (noGlobals p hp) h + · intro v bindings h + simp only [matchPatternWith, except_pure_ok, Option.some.injEq] at h + subst bindings + simp [Pattern.bindingNames] + | tuple ps | array ps | construct _ _ ps | constructAs _ _ _ ps => + have noGlobals : ∀ p ∈ ps, Consts.dependencies p = [] := by + simpa [Consts.dependencies, List.flatMap_eq_nil_iff] using plain + cases value <;> simp only [matchPatternWith, pure, Except.pure] at matched + all_goals try simp only [Except.ok.injEq, reduceCtorEq] at matched + all_goals split at matched + all_goals try simp only [Except.ok.injEq, reduceCtorEq] at matched + all_goals + rw [matchList_attach] at matched + simp only [Pattern.bindingNames] + apply matchList_names Pattern.bindingNames _ matched + intro p hp v bindings h + exact sub p (by simp_wf; have := List.sizeOf_lt_of_mem hp; omega) (noGlobals p hp) h + | «repeat» p n => + cases value <;> simp only [matchPatternWith, pure, Except.pure] at matched + all_goals try simp only [Except.ok.injEq, reduceCtorEq] at matched + split at matched + · simp at matched + · have h := matchList_names (fun (_ : Unit) => p.bindingNames) + (fun _ _ _ _ h => sub p (by simp_wf <;> omega) (by simpa [Consts.dependencies] using plain) h) matched + simpa [Pattern.bindingNames, List.flatMap_replicate] using h +termination_by sizeOf pat +decreasing_by all_goals exact smaller + +end Aiur.Generic.ControlLower diff --git a/Aiur/Aiur/Generic/ControlRules.lean b/Aiur/Aiur/Generic/ControlRules.lean new file mode 100644 index 000000000..2b31ba79e --- /dev/null +++ b/Aiur/Aiur/Generic/ControlRules.lean @@ -0,0 +1,345 @@ +import Aiur.Generic.ControlEnvironment + +namespace Aiur.Generic.OpenSource +open SourceSemantics + +abbrev Post (F : Type) := SourceValue F → Heap F → Prop +abbrev ExitPost (F : Type) := ExitTarget → SourceValue F → Heap F → Prop + +def Exec [Field F] [DecidableEq F] (world : World F) (calls : CallRelation F) + (types : Types) (locals : Environment F Nat) (expr : Expr F) + (normal : Post F) (abrupt : ExitPost F) (before : Heap F) : Prop := + (∃ value after, EvalExpr world calls types locals expr before value after ∧ normal value after) ∨ + ∃ target value after, EvalExit world calls types locals expr before target value after ∧ abrupt target value after + +def ExecArgs [Field F] [DecidableEq F] (world : World F) (calls : CallRelation F) + (types : Types) (locals : Environment F Nat) (exprs : List (Expr F)) + (normal : List (SourceValue F) → Heap F → Prop) (abrupt : ExitPost F) (before : Heap F) : Prop := + (∃ values after, EvalArgs world calls types locals exprs before values after ∧ normal values after) ∨ + ∃ target value after, EvalArgsExit world calls types locals exprs before target value after ∧ abrupt target value after + +variable [Field F] [DecidableEq F] {world : World F} {calls : CallRelation F} +variable {types : Types} {locals : Environment F Nat} {normal : Post F} {abrupt : ExitPost F} + +theorem Exec.congr (normalEq : ∀ v h, normal v h ↔ normal' v h) + (abruptEq : ∀ t v h, abrupt t v h ↔ abrupt' t v h) : + Exec world calls types locals expr normal abrupt heap ↔ + Exec world calls types locals expr normal' abrupt' heap := by + simp only [Exec, normalEq, abruptEq] + +theorem ExecArgs.congr (normalEq : ∀ vs h, next vs h ↔ next' vs h) + (abruptEq : ∀ t v h, abrupt t v h ↔ abrupt' t v h) : + ExecArgs world calls types locals exprs next abrupt heap ↔ + ExecArgs world calls types locals exprs next' abrupt' heap := by + simp only [ExecArgs, normalEq, abruptEq] + +theorem EvalArgs.length (ev : EvalArgs world calls types locals exprs before values after) : + values.length = exprs.length := by + induction exprs generalizing values before with + | nil => cases ev; rfl + | cons expr exprs ih => + cases ev with + | cons head tail => simpa using congrArg Nat.succ (ih tail) + +theorem ExecArgs.congr_length (normalEq : ∀ vs h, vs.length = exprs.length → (next vs h ↔ next' vs h)) + (abruptEq : ∀ t v h, abrupt t v h ↔ abrupt' t v h) : + ExecArgs world calls types locals exprs next abrupt heap ↔ + ExecArgs world calls types locals exprs next' abrupt' heap := by + constructor <;> rintro (⟨vs, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · exact .inl ⟨vs, h, ev, (normalEq vs h ev.length).mp post⟩ + · exact .inr ⟨t, v, h, ev, (abruptEq t v h).mp post⟩ + · exact .inl ⟨vs, h, ev, (normalEq vs h ev.length).mpr post⟩ + · exact .inr ⟨t, v, h, ev, (abruptEq t v h).mpr post⟩ + +theorem exec_literal : Exec world calls types locals (.literal x) normal abrupt heap ↔ normal (.field x) heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) <;> cases ev + exact post + · intro h; exact .inl ⟨_, _, .literal, h⟩ + +theorem exec_var : Exec world calls types locals (.var name) normal abrupt heap ↔ + ∃ value, locals.find? (·.1 == name) = some (name, value) ∧ normal value heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) <;> cases ev + exact ⟨_, ‹_›, post⟩ + · rintro ⟨v, lookup, post⟩; exact .inl ⟨_, _, .var lookup, post⟩ + +theorem exec_exit : Exec world calls types locals (.control (.exit target) expr) normal abrupt heap ↔ + Exec world calls types locals expr (abrupt target) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev + · cases ev with + | exit ev => exact .inl ⟨_, _, ev, post⟩ + | exitPayload ev => exact .inr ⟨_, _, _, ev, post⟩ + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · exact .inr ⟨_, _, _, .exit ev, post⟩ + · exact .inr ⟨_, _, _, .exitPayload ev, post⟩ + +theorem exec_block : Exec world calls types locals (.control (.block label) expr) normal abrupt heap ↔ + Exec world calls types locals expr normal + (fun target v h => if target = .block label then normal v h else abrupt target v h) heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with + | block ev => exact .inl ⟨_, _, ev, post⟩ + | blockExit ev => exact .inr ⟨_, _, _, ev, by simpa using post⟩ + · cases ev with + | fromBlock ne ev => exact .inr ⟨_, _, _, ev, by simpa only [if_neg ne] using post⟩ + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · exact .inl ⟨_, _, .block ev, post⟩ + · split at post + · rename_i same; subst t; exact .inl ⟨_, _, .blockExit ev, post⟩ + · exact .inr ⟨_, _, _, .fromBlock ‹_› ev, post⟩ + +theorem execArgs_nil : ExecArgs world calls types locals [] next abrupt heap ↔ next [] heap := by + constructor + · rintro (⟨vs, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) <;> cases ev + exact post + · intro h; exact .inl ⟨_, _, .nil, h⟩ + +theorem execArgs_cons : ExecArgs world calls types locals (expr :: exprs) next abrupt heap ↔ + Exec world calls types locals expr + (fun v h => ExecArgs world calls types locals exprs (fun vs a => next (v :: vs) a) abrupt h) abrupt heap := by + constructor + · rintro (⟨vs, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with + | cons head tail => exact .inl ⟨_, _, head, .inl ⟨_, _, tail, post⟩⟩ + · cases ev with + | head ev => exact .inr ⟨_, _, _, ev, post⟩ + | tail head tail => exact .inl ⟨_, _, head, .inr ⟨_, _, _, tail, post⟩⟩ + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · rcases post with ⟨vs, a, tail, post⟩ | ⟨t, v, a, tail, post⟩ + · exact .inl ⟨_, _, .cons ev tail, post⟩ + · exact .inr ⟨_, _, _, .tail ev tail, post⟩ + · exact .inr ⟨_, _, _, .head ev, post⟩ + +theorem exec_repeat : Exec world calls types locals (.repeat expr n) normal abrupt heap ↔ + Exec world calls types locals expr (fun v h => normal (.tuple (List.replicate n v)) h) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with | «repeat» value => exact .inl ⟨_, _, value, post⟩ + · cases ev with | fromRepeat ev => exact .inr ⟨_, _, _, ev, post⟩ + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · exact .inl ⟨_, _, .repeat ev, post⟩ + · exact .inr ⟨_, _, _, .fromRepeat ev, post⟩ + +theorem exec_store : Exec world calls types locals (.store expr) normal abrupt heap ↔ + Exec world calls types locals expr (fun v h => normal (.ptr v.type h.length) (h ++ [v])) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with | store value => exact .inl ⟨_, _, value, post⟩ + · cases ev with | fromStore ev => exact .inr ⟨_, _, _, ev, post⟩ + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · exact .inl ⟨_, _, .store ev, post⟩ + · exact .inr ⟨_, _, _, .fromStore ev, post⟩ + +theorem exec_index : Exec world calls types locals (.index expr i) normal abrupt heap ↔ + Exec world calls types locals expr (fun v h => ∃ result, projectValue v i = .ok result ∧ normal result h) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with | index value operation => exact .inl ⟨_, _, value, _, operation, post⟩ + · cases ev with | fromIndex ev => exact .inr ⟨_, _, _, ev, post⟩ + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · rcases post with ⟨result, operation, post⟩ + exact .inl ⟨_, _, .index ev operation, post⟩ + · exact .inr ⟨_, _, _, .fromIndex ev, post⟩ + +theorem exec_project : Exec world calls types locals (.project expr i) normal abrupt heap ↔ + Exec world calls types locals expr (fun v h => ∃ result, projectValue v i = .ok result ∧ normal result h) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with | project value operation => exact .inl ⟨_, _, value, _, operation, post⟩ + · cases ev with | fromProject ev => exact .inr ⟨_, _, _, ev, post⟩ + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · rcases post with ⟨result, operation, post⟩ + exact .inl ⟨_, _, .project ev operation, post⟩ + · exact .inr ⟨_, _, _, .fromProject ev, post⟩ + +theorem exec_member : Exec world calls types locals (.member expr field) normal abrupt heap ↔ + Exec world calls types locals expr (fun v h => ∃ result, memberValue types field v = .ok result ∧ normal result h) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with | member value operation => exact .inl ⟨_, _, value, _, operation, post⟩ + · cases ev with | fromMember ev => exact .inr ⟨_, _, _, ev, post⟩ + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · rcases post with ⟨result, operation, post⟩ + exact .inl ⟨_, _, .member ev operation, post⟩ + · exact .inr ⟨_, _, _, .fromMember ev, post⟩ + +theorem exec_slice : Exec world calls types locals (.slice expr start stop) normal abrupt heap ↔ + Exec world calls types locals expr (fun v h => ∃ result, sliceValue v start stop = .ok result ∧ normal result h) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with | slice value operation => exact .inl ⟨_, _, value, _, operation, post⟩ + · cases ev with | fromSlice ev => exact .inr ⟨_, _, _, ev, post⟩ + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · rcases post with ⟨result, operation, post⟩ + exact .inl ⟨_, _, .slice ev operation, post⟩ + · exact .inr ⟨_, _, _, .fromSlice ev, post⟩ + +theorem exec_load : Exec world calls types locals (.load expr) normal abrupt heap ↔ + Exec world calls types locals expr (fun v h => ∃ result, loadValue h v = .ok result ∧ normal result h) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with | load value operation => exact .inl ⟨_, _, value, _, operation, post⟩ + · cases ev with | fromLoad ev => exact .inr ⟨_, _, _, ev, post⟩ + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · rcases post with ⟨result, operation, post⟩ + exact .inl ⟨_, _, .load ev operation, post⟩ + · exact .inr ⟨_, _, _, .fromLoad ev, post⟩ + +theorem exec_neg : Exec world calls types locals (.neg expr) normal abrupt heap ↔ + Exec world calls types locals expr (fun v h => ∃ result, evalNeg v = .ok result ∧ normal result h) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with | neg value operation => exact .inl ⟨_, _, value, _, operation, post⟩ + · cases ev with | fromNeg ev => exact .inr ⟨_, _, _, ev, post⟩ + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · rcases post with ⟨result, operation, post⟩ + exact .inl ⟨_, _, .neg ev operation, post⟩ + · exact .inr ⟨_, _, _, .fromNeg ev, post⟩ + +theorem exec_hint : Exec world calls types locals (.hint type expr channel) normal abrupt heap ↔ + Exec world calls types locals expr (fun v h => ∃ value : Constant F, world.typed (type.subst types).toCore value = true ∧ normal value.toValue h) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with | hint value operation => exact .inl ⟨_, _, value, _, operation, post⟩ + · cases ev with | fromHint ev => exact .inr ⟨_, _, _, ev, post⟩ + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · rcases post with ⟨result, operation, post⟩ + exact .inl ⟨_, _, .hint ev operation, post⟩ + · exact .inr ⟨_, _, _, .fromHint ev, post⟩ + +theorem exec_tuple : Exec world calls types locals (.tuple exprs) normal abrupt heap ↔ + ExecArgs world calls types locals exprs (fun vs h => normal (.tuple vs) h) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with | tuple ev => exact .inl ⟨_, _, ev, post⟩ + · cases ev with | fromTuple ev => exact .inr ⟨_, _, _, ev, post⟩ + · rintro (⟨vs, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · exact .inl ⟨_, _, .tuple ev, post⟩ + · exact .inr ⟨_, _, _, .fromTuple ev, post⟩ + +theorem exec_array : Exec world calls types locals (.array exprs) normal abrupt heap ↔ + ExecArgs world calls types locals exprs (fun vs h => normal (.tuple vs) h) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with | array ev => exact .inl ⟨_, _, ev, post⟩ + · cases ev with | fromArray ev => exact .inr ⟨_, _, _, ev, post⟩ + · rintro (⟨vs, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · exact .inl ⟨_, _, .array ev, post⟩ + · exact .inr ⟨_, _, _, .fromArray ev, post⟩ + +theorem exec_construct : Exec world calls types locals (.construct name typeArgs ctor exprs) normal abrupt heap ↔ + ExecArgs world calls types locals exprs (fun vs h => normal (.construct (instanceName types name typeArgs) ctor vs) h) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with | construct ev => exact .inl ⟨_, _, ev, post⟩ + · cases ev with | fromConstruct ev => exact .inr ⟨_, _, _, ev, post⟩ + · rintro (⟨vs, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · exact .inl ⟨_, _, .construct ev, post⟩ + · exact .inr ⟨_, _, _, .fromConstruct ev, post⟩ + +theorem exec_constructAs : Exec world calls types locals (.constructAs params type ctor exprs) normal abrupt heap ↔ + ExecArgs world calls types locals exprs (fun vs h => normal (.construct (constructorName types type) ctor vs) h) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with | constructAs ev => exact .inl ⟨_, _, ev, post⟩ + · cases ev with | fromConstructAs ev => exact .inr ⟨_, _, _, ev, post⟩ + · rintro (⟨vs, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · exact .inl ⟨_, _, .constructAs ev, post⟩ + · exact .inr ⟨_, _, _, .fromConstructAs ev, post⟩ + +theorem exec_builtin : Exec world calls types locals (.builtin paths exprs) normal abrupt heap ↔ + ExecArgs world calls types locals exprs + (fun values h => ∃ result, paths.apply values = .ok result ∧ normal result h) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with | builtin args op => exact .inl ⟨_, _, args, _, op, post⟩ + · cases ev with | fromBuiltin args => exact .inr ⟨_, _, _, args, post⟩ + · rintro (⟨vs, h, ev, result, op, post⟩ | ⟨t, v, h, ev, post⟩) + · exact .inl ⟨_, _, .builtin ev op, post⟩ + · exact .inr ⟨_, _, _, .fromBuiltin ev, post⟩ + +theorem exec_update : Exec world calls types locals (.update paths exprs) normal abrupt heap ↔ + ExecArgs world calls types locals exprs + (fun values h => ∃ result, Update.value types paths values = .ok result ∧ normal result h) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with | update args op => exact .inl ⟨_, _, args, _, op, post⟩ + · cases ev with | fromUpdate args => exact .inr ⟨_, _, _, args, post⟩ + · rintro (⟨vs, h, ev, result, op, post⟩ | ⟨t, v, h, ev, post⟩) + · exact .inl ⟨_, _, .update ev op, post⟩ + · exact .inr ⟨_, _, _, .fromUpdate ev, post⟩ + +theorem exec_record : Exec world calls types locals (.record head exprs) normal abrupt heap ↔ + ExecArgs world calls types locals exprs (fun vs h => normal (.construct (constructorName types head.type) structConstructor (head.order vs (.tuple []))) h) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with | record ev => exact .inl ⟨_, _, ev, post⟩ + · cases ev with | fromRecord ev => exact .inr ⟨_, _, _, ev, post⟩ + · rintro (⟨vs, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · exact .inl ⟨_, _, .record ev, post⟩ + · exact .inr ⟨_, _, _, .fromRecord ev, post⟩ + +theorem exec_call : Exec world calls types locals (.call name typeArgs exprs) normal abrupt heap ↔ + ExecArgs world calls types locals exprs + (fun vs h => ∃ v a, calls (instanceName types name typeArgs) vs h v a ∧ normal v a) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with | call args callee => exact .inl ⟨_, _, args, _, _, callee, post⟩ + · cases ev with | fromCall args => exact .inr ⟨_, _, _, args, post⟩ + · rintro (⟨vs, h, ev, v, a, callee, post⟩ | ⟨t, v, h, ev, post⟩) + · exact .inl ⟨_, _, .call ev callee, post⟩ + · exact .inr ⟨_, _, _, .fromCall ev, post⟩ + +theorem exec_binary : Exec world calls types locals (.binary op lhs rhs) normal abrupt heap ↔ + Exec world calls types locals lhs (fun x h => + Exec world calls types locals rhs (fun y a => ∃ result, evalBinOp op x y = .ok result ∧ normal result a) + abrupt h) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with | binary left right operation => exact .inl ⟨_, _, left, .inl ⟨_, _, right, _, operation, post⟩⟩ + · cases ev with + | binaryLeft ev => exact .inr ⟨_, _, _, ev, post⟩ + | binaryRight left right => exact .inl ⟨_, _, left, .inr ⟨_, _, _, right, post⟩⟩ + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · rcases post with ⟨y, a, right, result, operation, post⟩ | ⟨t, v, a, right, post⟩ + · exact .inl ⟨_, _, .binary ev right operation, post⟩ + · exact .inr ⟨_, _, _, .binaryRight ev right, post⟩ + · exact .inr ⟨_, _, _, .binaryLeft ev, post⟩ + +theorem exec_let : Exec world calls types locals (.letValue pat value body) normal abrupt heap ↔ + Exec world calls types locals value (fun v h => ∃ bindings, + world.matchPattern types h pat v = .ok (some bindings) ∧ + Exec world calls types (bindings ++ locals) body normal abrupt h) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with | letValue value matched body => exact .inl ⟨_, _, value, _, matched, .inl ⟨_, _, body, post⟩⟩ + · cases ev with + | fromLetValue ev => exact .inr ⟨_, _, _, ev, post⟩ + | letBody value matched body => exact .inl ⟨_, _, value, _, matched, .inr ⟨_, _, _, body, post⟩⟩ + · rintro (⟨v, h, ev, bindings, matched, post⟩ | ⟨t, v, h, ev, post⟩) + · rcases post with ⟨v, a, body, post⟩ | ⟨t, v, a, body, post⟩ + · exact .inl ⟨_, _, .letValue ev matched body, post⟩ + · exact .inr ⟨_, _, _, .letBody ev matched body, post⟩ + · exact .inr ⟨_, _, _, .fromLetValue ev, post⟩ + +theorem exec_match : Exec world calls types locals (.matchValue value arms) normal abrupt heap ↔ + Exec world calls types locals value (fun v h => ∃ bindings body, + SourceSemantics.selectArm world types h v arms = .ok (some (bindings, body)) ∧ + Exec world calls types (bindings ++ locals) body normal abrupt h) abrupt heap := by + constructor + · rintro (⟨v, h, ev, post⟩ | ⟨t, v, h, ev, post⟩) + · cases ev with | matchValue value selected body => exact .inl ⟨_, _, value, _, _, selected, .inl ⟨_, _, body, post⟩⟩ + · cases ev with + | fromMatchValue ev => exact .inr ⟨_, _, _, ev, post⟩ + | matchBody value selected body => exact .inl ⟨_, _, value, _, _, selected, .inr ⟨_, _, _, body, post⟩⟩ + · rintro (⟨v, h, ev, bindings, body, selected, post⟩ | ⟨t, v, h, ev, post⟩) + · rcases post with ⟨v, a, body, post⟩ | ⟨t, v, a, body, post⟩ + · exact .inl ⟨_, _, .matchValue ev selected body, post⟩ + · exact .inr ⟨_, _, _, .matchBody ev selected body, post⟩ + · exact .inr ⟨_, _, _, .fromMatchValue ev, post⟩ + +end Aiur.Generic.OpenSource diff --git a/Aiur/Aiur/Generic/ControlScopeFacts.lean b/Aiur/Aiur/Generic/ControlScopeFacts.lean new file mode 100644 index 000000000..5d3a604af --- /dev/null +++ b/Aiur/Aiur/Generic/ControlScopeFacts.lean @@ -0,0 +1,175 @@ +import Aiur.Generic.ControlPatternFacts + +namespace Aiur.Generic.ControlLower +open SourceSemantics +set_option linter.unusedSimpArgs false +variable {F : Type} {source target bs : Environment F Nat} {env bound : Renaming} + +theorem lookup_mem {pairs : List (String × A)} (found : pairs.lookup name = some value) : + (name, value) ∈ pairs := by + obtain ⟨left, right, rfl, _⟩ := List.lookup_eq_some_iff.mp found + simp + +theorem lookup_some {pairs : List (String × A)} (member : name ∈ pairs.map Prod.fst) : + ∃ value, pairs.lookup name = some value := by + have present : (pairs.lookup name).isSome := by + obtain ⟨pair, hp, he⟩ := List.mem_map.mp member + exact List.lookup_isSome_iff.mpr ⟨pair, hp, by simp [he]⟩ + cases h : pairs.lookup name with + | none => simp [h] at present + | some v => exact ⟨v, rfl⟩ + +theorem lookup_none {pairs : List (String × A)} (absent : name ∉ pairs.map Prod.fst) : + pairs.lookup name = none := by + cases found : pairs.lookup name with + | none => rfl + | some value => exact (absent (List.mem_map.mpr ⟨_, lookup_mem found, rfl⟩)).elim + +theorem find_lookup (locals : Environment F Nat) (name : String) : + locals.find? (·.1 == name) = (locals.lookup name).map (fun value => (name, value)) := by + induction locals with + | nil => rfl + | cons pair locals ih => + rcases pair with ⟨key, value⟩ + by_cases same : name = key + · subst key; simp + · simp [List.find?_cons, List.lookup_cons, beq_eq_false_iff_ne.mpr same, + beq_eq_false_iff_ne.mpr (Ne.symm same), ih] + +theorem find_lookup_some (locals : Environment F Nat) (name : String) (value : SourceValue F) : + locals.find? (·.1 == name) = some (name, value) ↔ locals.lookup name = some value := by + rw [find_lookup] + cases locals.lookup name <;> simp + +/-- The source scope and generated scope agree under the current renaming. +Dead outer bindings need not be removed from either environment. -/ +def ScopeRel (env : Renaming) (source target : Environment F Nat) : Prop := + ∀ name renamed, env.lookup name = some renamed → target.lookup renamed = source.lookup name + +theorem ScopeRel.add (rel : ScopeRel env source target) + (fresh : name ∉ env.map Prod.snd) (value : SourceValue F) : + ScopeRel env source ((name, value) :: target) := by + intro n renamed found + have member : renamed ∈ env.map Prod.snd := List.mem_map.mpr ⟨_, lookup_mem found, rfl⟩ + have different : renamed ≠ name := fun same => fresh (same ▸ member) + simpa [List.lookup_cons, beq_eq_false_iff_ne.mpr different] using rel n renamed found + +theorem ScopeRel.identity (names : List String) (locals : Environment F Nat) : + ScopeRel (names.map fun name => (name, name)) locals locals := by + intro name renamed found + obtain ⟨n, _, eq⟩ := List.mem_map.mp (lookup_mem found) + have same : name = renamed := by cases eq; rfl + subst renamed + rfl + +theorem rename_found (found : env.lookup name = some value) : rename env name = value := by + simp only [rename, found, Option.getD_some] + +theorem rename_injective (unique : (env.map Prod.snd).Nodup) + (left : name ∈ env.map Prod.fst) (right : other ∈ env.map Prod.fst) : + rename env name = rename env other ↔ name = other := by + constructor + · intro same + obtain ⟨x, hx⟩ := lookup_some left + obtain ⟨y, hy⟩ := lookup_some right + rw [rename_found hx, rename_found hy] at same + have pair := List.inj_on_of_nodup_map unique (lookup_mem hx) (lookup_mem hy) same + exact congrArg Prod.fst pair + · intro same; cases same; rfl + +theorem renameBindings_lookup (unique : (env.map Prod.snd).Nodup) + (covered : ∀ n ∈ bs.map Prod.fst, n ∈ env.map Prod.fst) + (found : env.lookup name = some renamed) : + (renameBindings env bs).lookup renamed = bs.lookup name := by + have named : name ∈ env.map Prod.fst := List.mem_map.mpr ⟨_, lookup_mem found, rfl⟩ + induction bs with + | nil => rfl + | cons pair bs ih => + rcases pair with ⟨key, value⟩ + have keyMember := covered key (by simp) + have eq : renamed = rename env key ↔ name = key := by + rw [← rename_found found] + exact rename_injective unique named keyMember + simp only [renameBindings, List.map_cons, List.lookup_cons] + by_cases same : name = key + · simp [same, eq.mpr same] + · have ne : renamed ≠ rename env key := fun h => same (eq.mp h) + simp only [beq_eq_false_iff_ne.mpr ne, beq_eq_false_iff_ne.mpr same] + exact ih (fun n hn => covered n (by simp [hn])) + +theorem renameBindings_names (covered : ∀ n ∈ bs.map Prod.fst, n ∈ env.map Prod.fst) : + ∀ n ∈ (renameBindings env bs).map Prod.fst, n ∈ env.map Prod.snd := by + intro n member + simp only [renameBindings, List.map_map, List.mem_map] at member + obtain ⟨⟨key, value⟩, member, rfl⟩ := member + obtain ⟨renamed, found⟩ := lookup_some (covered key (List.mem_map.mpr ⟨_, member, rfl⟩)) + change rename env key ∈ env.map Prod.snd + rw [rename_found found] + exact List.mem_map.mpr ⟨_, lookup_mem found, rfl⟩ + +theorem ScopeRel.extend (rel : ScopeRel env source target) + (unique : (bound.map Prod.snd).Nodup) + (keys : ∀ n, n ∈ bound.map Prod.fst ↔ n ∈ bs.map Prod.fst) + (fresh : ∀ n ∈ bound.map Prod.snd, n ∉ env.map Prod.snd) : + ScopeRel (bound ++ env) (bs ++ source) (renameBindings bound bs ++ target) := by + have covered := fun n hn => (keys n).mpr hn + intro name renamed found + simp only [List.lookup_append] at found ⊢ + cases binding : bound.lookup name with + | some renamed' => + have same : renamed' = renamed := by simpa [binding] using found + subst renamed' + obtain ⟨value, valueFound⟩ := lookup_some ((keys name).mp + (List.mem_map.mpr ⟨_, lookup_mem binding, rfl⟩)) + rw [renameBindings_lookup unique covered binding, valueFound] + rfl + | none => + have old : env.lookup name = some renamed := by simpa [binding] using found + have absent : bs.lookup name = none := lookup_none (by + intro member + obtain ⟨v, hv⟩ := lookup_some ((keys name).mpr member) + simp [binding] at hv) + have targetAbsent : (renameBindings bound bs).lookup renamed = none := lookup_none (by + intro member + exact fresh _ (renameBindings_names covered _ member) + (List.mem_map.mpr ⟨_, lookup_mem old, rfl⟩)) + rw [absent, targetAbsent] + exact rel name renamed old + +theorem fresh_ok (built : fresh used = .ok name) : name ∉ used := by + simp only [fresh] at built + split at built + · cases built + · obtain rfl := Except.ok.inj built + assumption + +theorem bindings_ok (built : bindings pat used = .ok bound) : + Consts.dependencies pat = [] ∧ (bound.map Prod.snd).Nodup ∧ + (∀ n, n ∈ bound.map Prod.fst ↔ n ∈ pat.bindingNames) ∧ + (∀ n ∈ bound.map Prod.snd, n ∉ used) := by + simp only [bindings] at built + split at built + · cases built + · rename_i plain + split at built + · cases built + · rename_i unique + split at built + · cases built + · rename_i fresh + obtain rfl := Except.ok.inj built + refine ⟨by simpa using plain, by simpa using unique, ?_, ?_⟩ + · intro n + simp only [List.map_map, Function.comp_def] + rw [show (fun x : String × Nat => (x.1, PatternLowering.freshPrefix used ++ "control:" ++ toString x.2).1) = Prod.fst from rfl, + List.zipIdx_map_fst] + simp + · have good : ∀ x ∈ pat.bindingNames.eraseDups.zipIdx, + PatternLowering.freshPrefix used ++ "control:" ++ toString x.2 ∉ used := by simpa using fresh + intro n member + obtain ⟨pair, hPair, equal⟩ := List.mem_map.mp member + obtain ⟨original, hOriginal, rfl⟩ := List.mem_map.mp hPair + subst n + exact good original hOriginal + +end Aiur.Generic.ControlLower diff --git a/Aiur/Aiur/Generic/CoreCallInduction.lean b/Aiur/Aiur/Generic/CoreCallInduction.lean new file mode 100644 index 000000000..be4c75931 --- /dev/null +++ b/Aiur/Aiur/Generic/CoreCallInduction.lean @@ -0,0 +1,72 @@ +import Aiur.Generic.OpenCore +import Aiur.Generic.Simulation + +namespace Aiur.Generic.Engine + +theorem EvalExpr.openCalls [Field F] [DecidableEq F] + {world : World F} {calls : CallRelation F} {names : List String} {hintType : Aiur.Ty → Bool} + (closed : ∀ n ∈ names, ∀ args ls e, world.prepare n args = .ok (ls, e) → + inScope names hintType e = true) + (step : ∀ n ∈ names, ∀ args ls e b v a, + world.prepare n args = .ok (ls, e) → EvalExpr world ls e b v a → + OpenCore.EvalExpr world calls ls e b v a → calls n args b v a) + (ev : EvalExpr world locals expr before result after) : + inScope names hintType expr = true → OpenCore.EvalExpr world calls locals expr before result after := by + induction ev using EvalExpr.rec + (motive_2 := fun ls es b vs h _ => (∀ e ∈ es, inScope names hintType e = true) → OpenCore.EvalArgs world calls ls es b vs h) + (motive_3 := fun n xs b v h _ => n ∈ names → calls n xs b v h) with + | literal => intro _; exact .literal + | var h => intro _; exact .var h + | tuple _ ih => intro h; exact .tuple (ih (by simpa [inScope] using h)) + | construct _ ih => intro h; exact .construct (ih (by simpa [inScope] using h)) + | project _ op ih => intro h; exact .project (ih (by simpa [inScope] using h)) op + | letValue _ matched _ ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true] at h + exact .letValue (ih1 h.1) matched (ih2 h.2) + | store _ ih => intro h; exact .store (ih (by simpa [inScope] using h)) + | load _ op ih => intro h; exact .load (ih (by simpa [inScope] using h)) op + | hint _ typed ih => + intro h + simp only [inScope, Bool.and_eq_true] at h + exact .hint (ih h.2) typed + | neg _ op ih => intro h; exact .neg (ih (by simpa [inScope] using h)) op + | assertEq _ _ op ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true] at h + exact .assertEq (ih1 h.1) (ih2 h.2) op + | binary _ _ op ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true] at h + exact .binary (ih1 h.1) (ih2 h.2) op + | call _ _ ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true, List.contains_iff_mem, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .call (ih1 h.2) (ih2 h.1) + | matchValue _ selected _ ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .matchValue (ih1 h.1) selected (ih2 (selected_inScope selected h.2)) + | nil => exact .nil + | cons _ _ ih1 ih2 => + rename_i h + exact .cons (ih1 (h _ (by simp))) (ih2 (fun e he => h e (by simp [he]))) + | intro prepared body ih => + rename_i hn + exact step _ hn _ _ _ _ _ _ prepared body (ih (closed _ hn _ _ _ prepared)) + +theorem EvalFn.openCalls [Field F] [DecidableEq F] + {world : World F} {calls : CallRelation F} {names : List String} {hintType : Aiur.Ty → Bool} + (closed : ∀ n ∈ names, ∀ args ls e, world.prepare n args = .ok (ls, e) → + inScope names hintType e = true) + (step : ∀ n ∈ names, ∀ args ls e b v a, + world.prepare n args = .ok (ls, e) → EvalExpr world ls e b v a → + OpenCore.EvalExpr world calls ls e b v a → calls n args b v a) + (ev : EvalFn world name args before result after) (member : name ∈ names) : + calls name args before result after := by + cases ev with + | intro prepared body => + exact step _ member _ _ _ _ _ _ prepared body + (body.openCalls closed step (closed _ member _ _ _ prepared)) + +end Aiur.Generic.Engine diff --git a/Aiur/Aiur/Generic/CoreRuntime.lean b/Aiur/Aiur/Generic/CoreRuntime.lean new file mode 100644 index 000000000..ee40339cb --- /dev/null +++ b/Aiur/Aiur/Generic/CoreRuntime.lean @@ -0,0 +1,59 @@ +import Aiur.Generic.Preparation +import Aiur.Generic.Engine + +/-! Reference execution of the lowered compiler language. These definitions +are separate from source evaluation; their correctness statements must not be +used as a replacement for a source-to-core lowering theorem. -/ +namespace Aiur.Generic + +def prepareFunction (enums : String → Option Aiur.EnumDecl) (fn : Aiur.Function F) + (args : List (SourceValue F)) : Except EvalError (Environment F Nat × Aiur.Expr F) := + if fn.params.map Prod.snd = args.map Value.type ∧ (args.map (wellFormed enums)).all id = true then + .ok ((fn.params.map Prod.fst).zip args, fn.body) + else .error (.malformedValue (.tuple (args.map Value.type))) + +def Source.coreWorld [DecidableEq F] (s : Source F) : Engine.World F where + prepare name args := match s.compilerFunction? name with + | some fn => prepareFunction s.program.enum? fn args + | none => return ([], (← lookupMap s.tables name args).toExpr) + typed t v := hasType s.program.enum? t v + +abbrev Source.CoreHintProvider [DecidableEq F] (s : Source F) := Engine.HintProvider s.coreWorld + +def Source.coreCheckedHints [DecidableEq F] (s : Source F) + (dispatcher : HintDispatcher F) : s.CoreHintProvider := fun channel key t => do + let v ← dispatcher.provide channel key + if typed : s.coreWorld.typed t v = true then return ⟨v, typed⟩ + else throw (.invalidValue t v.type) + +def Source.coreRun [Field F] [DecidableEq F] (s : Source F) (name : String) + (args : List (SourceValue F)) (fuel : Nat := 1000) + (hints : s.CoreHintProvider := Engine.unavailable) : Except String (SourceValue F × Heap F) := do + s.checkEntry name + let (locals, body) ← (s.coreWorld.prepare name args).mapError reprStr + (Engine.evalExprWith s.coreWorld hints locals fuel body []).mapError reprStr + +def Source.CoreEvalCall [Field F] [DecidableEq F] (s : Source F) (name : String) + (args : List (SourceValue F)) (result : SourceValue F) : Prop := + s.checkEntry name = .ok () ∧ ∃ heap, Engine.EvalFn s.coreWorld name args [] result heap + +/-- Successful execution of the lowered reference runtime has a core +relational evaluation with the same value and heap. -/ +theorem Source.coreRun_spec [Field F] [DecidableEq F] {s : Source F} + {hints : s.CoreHintProvider} {name args fuel result heap} + (run : s.coreRun name args fuel hints = .ok (result, heap)) : + s.checkEntry name = .ok () ∧ Engine.EvalFn s.coreWorld name args [] result heap := by + cases entry : s.checkEntry name with + | error e => simp [Source.coreRun, entry, bind, Except.bind] at run + | ok u => + cases u + cases prepared : s.coreWorld.prepare name args with + | error e => simp [Source.coreRun, entry, prepared, Except.mapError, bind, Except.bind] at run + | ok pair => + rcases pair with ⟨locals, body⟩ + have executed : Engine.evalExprWith s.coreWorld hints locals fuel body [] = .ok (result, heap) := by + cases h : Engine.evalExprWith s.coreWorld hints locals fuel body [] <;> + simpa [Source.coreRun, entry, prepared, h, Except.mapError, bind, Except.bind] using run + exact ⟨rfl, .intro prepared (Engine.evalExpr_spec executed)⟩ + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/Correctness.lean b/Aiur/Aiur/Generic/Correctness.lean new file mode 100644 index 000000000..ceebd1851 --- /dev/null +++ b/Aiur/Aiur/Generic/Correctness.lean @@ -0,0 +1,228 @@ +import Aiur.Generic.Specialize +import Aiur.Generic.CoreRuntime +import Aiur.TableChecking + +namespace Aiur.Generic + +private theorem lookupMap_transfer [DecidableEq F] {p q : Aiur.Program F} + {n : String} {args : List (SourceValue F)} {value : Constant F} + (checked : typecheck q = .ok ()) (tables : p.tables = q.tables) (maps : p.maps = q.maps) + (looked : lookupMap p n args = .ok value) : lookupMap q n args = .ok value := by + obtain ⟨m, key, found, _, _, extracted, row, _⟩ := lookupMap_spec looked + have name : m.name = n := by simpa [Program.findMap?] using List.find?_some found + have member : m ∈ q.maps := by rw [← maps]; exact List.mem_of_find?_eq_some found + have same := Value.toConstant_spec extracted + cases key with + | field | construct => simp [show (Constant.toValue : Constant F → Value F _) = Value.mapAddress Empty.elim from rfl, Constant.toValue, Value.mapAddress] at same + | ptr _ address => exact Empty.elim address + | tuple constants => + have argsEq : constants.map Constant.toValue = args := by simpa [show (Constant.toValue : Constant F → Value F _) = Value.mapAddress Empty.elim from rfl, Constant.toValue, Value.mapAddress] using same + have rowQ : (.tuple constants, value) ∈ q.mapRows m := by + simpa only [Program.mapRows, Program.findTable?, tables] using row + have h := lookupMap_of_entry (A := Nat) (entry := ⟨constants, value⟩) checked member (mapEntry_mem_iff.mpr rowQ) + simpa only [name, argsEq] using h + +private theorem prepared_function_iff [DecidableEq F] {p : Aiur.Program F} + (found : p.findFunction? n = some fn) : + prepareCall p n args = .ok (locals, body) ↔ + fn.params.map Prod.snd = args.map Value.type ∧ + (∀ v ∈ args, v.wellFormed p.enums = true) ∧ + locals = (fn.params.map Prod.fst).zip args ∧ body = fn.body := by + constructor + · intro h + rcases prepareCall_spec h with ⟨f, hf, ht, hv, hl, hb⟩ | ⟨v, hf, _⟩ + · have : f = fn := Option.some.inj (hf.symm.trans found) + subst f + exact ⟨ht, hv, hl, hb⟩ + · simp [found] at hf + · rintro ⟨ht, hv, rfl, rfl⟩ + exact prepareCall_of_types found ht hv + +private theorem prepareFunction_iff : + prepareFunction enums fn args = .ok (locals, body) ↔ + fn.params.map Prod.snd = args.map Value.type ∧ + (∀ v ∈ args, wellFormed enums v = true) ∧ + locals = (fn.params.map Prod.fst).zip args ∧ body = fn.body := by + unfold prepareFunction + split + · rename_i h + simp only [List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + constructor + · intro same + obtain ⟨rfl, rfl⟩ := Prod.mk.inj (Except.ok.inj same) + exact ⟨h.1, h.2, rfl, rfl⟩ + · rintro ⟨_, _, rfl, rfl⟩ + rfl + · rename_i h + simp only [List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + simp only [reduceCtorEq, false_iff] + rintro ⟨ht, hv, _⟩ + exact h ⟨ht, hv⟩ + +private theorem constant_scope (v : Constant F) : Engine.inScope names hintType v.toExpr = true := by + cases v with + | field => simp [Constant.toExpr, Engine.inScope] + | ptr _ a => exact Empty.elim a + | tuple xs | construct n c xs => + simp only [Constant.toExpr, Engine.inScope, List.all_map, List.all_eq_true, Function.comp_def, id_eq] + intro x hx + exact constant_scope x +termination_by sizeOf v + +/-- Checked instance lookup and closed declarations imply the runtime +agreement needed by the general simulation theorem. -/ +theorem Specialized.coreAgreement [DecidableEq F] {s : Source F} {entries : List String} + (q : Specialized s entries) : + Engine.Agreement s.coreWorld (.ofProgram q.program) + (callableNames q.program) (knownType q.program.enums) := by + rcases q.valid with ⟨checked, tables, maps, functions, enums, closed, bodies, roots⟩ + have enumAgreement : ∀ n d, q.program.enums.findEnum? n = some d → s.program.enum? n = some d := by + intro n d found + have hn : d.name = n := by simpa [Declarations.findEnum?] using List.find?_some found + simpa [hn] using enums d (List.mem_of_find?_eq_some found) + have prep : ∀ n ∈ callableNames q.program, ∀ args locals body, + s.coreWorld.prepare n args = .ok (locals, body) ↔ prepareCall q.program n args = .ok (locals, body) := by + intro n hn args locals body + have fnAgreement := functions n hn + cases found : q.program.findFunction? n with + | none => + have absent : s.compilerFunction? n = none := fnAgreement.trans found + simp only [Source.coreWorld, absent, prepareCall, found] + simp only [except_bind_ok, except_pure_ok, Prod.mk.injEq] + constructor + · rintro ⟨v, hv, hl, hb⟩ + exact ⟨v, lookupMap_transfer checked tables.symm maps.symm hv, hl, hb⟩ + · rintro ⟨v, hv, hl, hb⟩ + exact ⟨v, lookupMap_transfer s.tablesChecked tables maps hv, hl, hb⟩ + | some fn => + have resolved : s.compilerFunction? n = some fn := fnAgreement.trans found + simp only [Source.coreWorld, resolved, prepareFunction_iff, prepared_function_iff found] + by_cases ht : fn.params.map Prod.snd = args.map Value.type + · have known := (bodies fn (List.mem_of_find?_eq_some found)).1 + have values : ∀ v ∈ args, wellFormed s.program.enum? v = v.wellFormed q.program.enums := by + intro v hv + apply formed_agrees enumAgreement closed + have mem : v.type ∈ fn.params.map Prod.snd := ht ▸ List.mem_map.mpr ⟨v, hv, rfl⟩ + obtain ⟨param, hp, same⟩ := List.mem_map.mp mem + simpa [same] using known param hp + simp only [ht, true_and] + apply and_congr _ Iff.rfl + constructor + · intro all v hv; rw [← values v hv]; exact all v hv + · intro all v hv; rw [values v hv]; exact all v hv + · simp [ht] + refine ⟨prep, ?_, ?_⟩ + · intro t ht v + exact congrArg (· = true) (hasType_agrees enumAgreement closed t ht v) |>.to_iff + · intro n hn args locals body prepared + have target := (prep n hn args locals body).mp prepared + rcases prepareCall_spec target with ⟨fn, found, _, _, _, rfl⟩ | ⟨v, _, _, _, rfl⟩ + · exact (bodies fn (List.mem_of_find?_eq_some found)).2 + · exact constant_scope v + +/-- The lowered reference interpreter and the concrete compiler program agree. +This core-level result is separate from source-level specialization. -/ +theorem Specialized.coreEvalFn_iff [Field F] [DecidableEq F] {s : Source F} {entries : List String} + (q : Specialized s entries) (reachable : name ∈ callableNames q.program) : + Engine.EvalFn s.coreWorld name args before result after ↔ + Aiur.EvalFn q.program name args before result after := + (Engine.evalFn_iff q.coreAgreement reachable).trans Engine.core_iff + +/-- Core-level equivalence at selected entries. -/ +theorem Specialized.coreEvalCall_iff [Field F] [DecidableEq F] {s : Source F} {entries : List String} + (q : Specialized s entries) (selected : name ∈ entries) : + s.CoreEvalCall name args result ↔ Aiur.EvalCall q.program name args result := by + have root := q.valid.2.2.2.2.2.2.2 name selected + simp only [Source.CoreEvalCall, Aiur.EvalCall, root.2.1, root.2.2, true_and] + exact exists_congr fun heap => q.coreEvalFn_iff root.1 + +private theorem cached_lookup {A : Type} (lookup : String → Option A) + {names : List String} {name : String} (member : name ∈ names) : + (((names.map fun n => (n, lookup n)).find? (·.1 == name)).bind Prod.snd) = lookup name := by + induction names with + | nil => simp at member + | cons n names ih => + by_cases same : n = name + · subst n; simp + · have hn := (List.mem_cons.mp member).resolve_left (Ne.symm same) + simpa [List.find?, same] using ih hn + +private theorem source_constant_scope (v : Constant F) : + SourceSemantics.inScope names (fun _ => true) types (constantExpr v) = true := by + cases v with + | field => simp [constantExpr, SourceSemantics.inScope] + | ptr _ a => exact Empty.elim a + | tuple xs | construct n c xs => + simp only [constantExpr, SourceSemantics.inScope, List.all_map, List.all_eq_true, Function.comp_def, id_eq] + intro x hx + exact source_constant_scope x +termination_by sizeOf v + +/-- Finite specialization preserves source bodies and concrete type bindings. +This agreement is independent of the later translation into core expressions. -/ +theorem Specialized.sourceAgreement [DecidableEq F] {s : Source F} {entries : List String} + (q : Specialized s entries) : + SourceSemantics.Agreement s.world q.world (callableNames q.program) (fun _ => true) := by + have prep : ∀ n ∈ callableNames q.program, ∀ args, + s.world.prepare n args = q.world.prepare n args := by + intro n hn args + simp only [Source.world, Specialized.world, Specialized.instances, sourceWorld, + cached_lookup s.program.sourceFunction? hn] + refine ⟨rfl, rfl, fun n hn args _ _ _ => (congrArg (· = _) (prep n hn args)).to_iff, + fun _ _ _ => Iff.rfl, ?_⟩ + intro n hn args types locals body prepared + cases found : s.program.sourceFunction? n with + | none => + simp only [Source.world, sourceWorld, found, except_bind_ok, except_pure_ok, + Prod.mk.injEq] at prepared + obtain ⟨v, _, rfl, rfl, rfl⟩ := prepared + exact source_constant_scope v + | some fn => + have closed := q.sourceClosed n hn + simp only [found, Option.all_some] at closed + simp only [Source.world, sourceWorld, found, SourceFunction.prepare] at prepared + split at prepared + · obtain ⟨rfl, rfl, rfl⟩ := Prod.mk.inj (Except.ok.inj prepared) |>.imp_right Prod.mk.inj + exact closed + · simp at prepared + +/-- Source-level specialization preserves and reflects every finite evaluation, +including native array operations, pointer patterns, hints, and the exact heap. -/ +theorem Specialized.evalFn_iff [Field F] [DecidableEq F] {s : Source F} {entries : List String} + (q : Specialized s entries) (reachable : name ∈ callableNames q.program) : + SourceSemantics.EvalFn s.world name args before result after ↔ + SourceSemantics.EvalFn q.world name args before result after := + SourceSemantics.evalFn_iff q.sourceAgreement reachable + +theorem Specialized.evalCall_iff [Field F] [DecidableEq F] {s : Source F} {entries : List String} + (q : Specialized s entries) (selected : name ∈ entries) : + s.EvalCall name args result ↔ q.EvalCall name args result := by + have root := q.valid.2.2.2.2.2.2.2 name selected + have entry := q.checkEntry_iff.mpr selected + simp only [Source.EvalCall, Specialized.EvalCall, root.2.1, entry, true_and] + exact exists_congr fun heap => q.evalFn_iff root.1 + +theorem Specialized.run_spec [Field F] [DecidableEq F] {s : Source F} {entries : List String} + {q : Specialized s entries} {hints : s.HintProvider} {name args fuel result heap} + (run : q.run name args fuel hints = .ok (result, heap)) : + q.checkEntry name = .ok () ∧ SourceSemantics.EvalFn q.world name args [] result heap := by + cases entry : q.checkEntry name with + | error e => simp [Specialized.run, entry, bind, Except.bind] at run + | ok u => + cases u + cases prepared : q.world.prepare name args with + | error e => simp [Specialized.run, entry, prepared, Except.mapError, bind, Except.bind] at run + | ok triple => + rcases triple with ⟨types, locals, body⟩ + have executed : SourceSemantics.evalFunctionWith q.world hints types locals fuel body [] = .ok (result, heap) := by + cases h : SourceSemantics.evalFunctionWith q.world hints types locals fuel body [] <;> + simpa [Specialized.run, entry, prepared, h, Except.mapError, bind, Except.bind] using run + exact ⟨rfl, SourceSemantics.evalFunction_spec prepared executed⟩ + +theorem Specialized.evalCall_of_run [Field F] [DecidableEq F] {s : Source F} {entries : List String} + {q : Specialized s entries} {hints : s.HintProvider} {name args fuel result heap} + (run : q.run name args fuel hints = .ok (result, heap)) : q.EvalCall name args result := by + obtain ⟨entry, evaluated⟩ := Specialized.run_spec run + exact ⟨entry, heap, evaluated⟩ + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/Diagnostics.lean b/Aiur/Aiur/Generic/Diagnostics.lean new file mode 100644 index 000000000..73df580eb --- /dev/null +++ b/Aiur/Aiur/Generic/Diagnostics.lean @@ -0,0 +1,64 @@ +import Aiur.Generic.Runtime +import Aiur.Generic.TraceFacts + +namespace Aiur.Generic + +structure ExecutionTrace (F : Type) where + result : Except String (SourceValue F × Heap F) + events : List (TraceEvent F) + deriving Repr + +/-- Active calls, innermost first. On failure their unmatched entry events give +a call trace; a normally completed execution leaves this list empty. -/ +def ExecutionTrace.activeCalls (execution : ExecutionTrace F) : List String := + execution.events.foldl (fun stack event => match event with + | .enter name _ => name :: stack + | .leave _ _ => stack.drop 1 + | .message _ _ => stack) [] + +def Source.runTraced [Field F] [DecidableEq F] (s : Source F) (name : String) + (args : List (SourceValue F)) (fuel : Nat := 1000) + (hints : s.HintProvider := SourceSemantics.unavailable) : ExecutionTrace F := + match s.checkEntry name with + | .error error => ⟨.error error, []⟩ + | .ok () => match s.world.prepare name args with + | .error error => ⟨.error (reprStr error), [.enter name args]⟩ + | .ok (types, locals, body) => + let (result, events) := Traced.finishFunction + (Traced.evalWithTrace s.world hints types locals fuel body) [] [.enter name args] + let events := match result with + | .ok (value, _) => TraceEvent.leave name value :: events + | .error _ => events + ⟨result.mapError reprStr, events.reverse⟩ + +/-- Exact erasure, for failures as well as successes. Logging does not change +fuel consumption, hint requests, return values, or allocations. -/ +theorem Source.runTraced_result [Field F] [DecidableEq F] (s : Source F) (name args fuel) + (hints : s.HintProvider) : + (s.runTraced name args fuel hints).result = s.run name args fuel hints := by + cases entry : s.checkEntry name with + | error error => simp [Source.runTraced, Source.run, entry, bind, Except.bind] + | ok unit => + cases unit + cases prepared : s.world.prepare name args with + | error error => simp [Source.runTraced, Source.run, entry, prepared, Except.mapError, bind, Except.bind] + | ok triple => + rcases triple with ⟨types, locals, body⟩ + have same := Traced.agrees_finish (Traced.eval_agrees s.world hints types locals fuel body) + [] [.enter name args] + cases traced : Traced.finishFunction + (Traced.evalWithTrace s.world hints types locals fuel body) [] [.enter name args] with + | mk outcome events => + rw [traced] at same + simp only [Prod.fst] at same + simp [Source.runTraced, Source.run, entry, prepared, traced, Except.mapError, + bind, Except.bind, SourceSemantics.evalFunctionWith, ← same] + +theorem Source.runTraced_spec [Field F] [DecidableEq F] {s : Source F} + {hints : s.HintProvider} {name args fuel result heap} + (run : (s.runTraced name args fuel hints).result = .ok (result, heap)) : + s.checkEntry name = .ok () ∧ SourceSemantics.EvalFn s.world name args [] result heap := by + rw [Source.runTraced_result] at run + exact Source.run_spec run + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/Elaborate.lean b/Aiur/Aiur/Generic/Elaborate.lean new file mode 100644 index 000000000..de26d5fe2 --- /dev/null +++ b/Aiur/Aiur/Generic/Elaborate.lean @@ -0,0 +1,709 @@ +import Aiur.Generic.Consts + +namespace Aiur.Generic + +def checkType (p : Program α) (params : List String) : Ty → Except String Unit + | .field => pure () + | .ptr t => checkType p params t + | .array t n => do checkArrayLength n; checkType p params t + | .tuple ts => do + for t in ts do checkType p params t + | .param n => if params.contains n then pure () else throw s!"unbound type parameter '{n}'" + | .named n ts => do + let some decl := p.findEnum? n | throw s!"unknown type '{n}'" + let _ ← arguments decl.typeParams ts + for t in ts do checkType p params t +termination_by t => sizeOf t + +/-- Preserve the source rule that recursive type cycles cross a pointer, even +when a zero-length array would erase the cycle from the concrete layout. -/ +def checkInlineType (p : Program α) : Nat → List Instance → Ty → Except String Unit + | 0, _, _ => throw "inline type check depth exceeded" + | fuel + 1, path, t => match t with + | .field | .param _ | .ptr _ => pure () + | .array t _ => checkInlineType p fuel path t + | .tuple ts => ts.forM (checkInlineType p fuel path) + | .named n ts => do + let key := Instance.mk n ts + if path.contains key then throw s!"inline recursive type '{n}' requires a pointer" + if (ts.map Ty.nodes).sum > 4096 then throw "enum instance type-size limit exceeded" + let some decl := p.findEnum? n | throw s!"unknown enum '{n}'" + let env ← arguments decl.typeParams ts + for ctor in decl.constructors do + for t in ctor.fields do checkInlineType p fuel (key :: path) (t.subst env) + +/-- Inspect source types before zero-length arrays erase their element layout. +All constructor payloads are checked, independently of inhabited values. -/ +def checkPointerFree (p : Program α) (context : String) : Nat → List Instance → Ty → Except String Unit + | 0, _, _ => throw "pointer-free type check depth exceeded" + | fuel + 1, seen, t => match t with + | .field => pure () + | .ptr _ => throw s!"pointer type is not allowed in {context}" + | .param _ => throw s!"{context} requires a concrete pointer-free type" + | .array t _ => checkPointerFree p context fuel seen t + | .tuple ts => ts.forM (checkPointerFree p context fuel seen) + | .named n ts => do + let key := Instance.mk n ts + if seen.contains key then return + let some decl := p.findEnum? n | throw s!"unknown enum '{n}'" + let env ← arguments decl.typeParams ts + for ctor in decl.constructors do + for t in ctor.fields do checkPointerFree p context fuel (key :: seen) (t.subst env) + +private structure Inference where + next : Nat := 0 + solutions : List (String × Ty) := [] + exits : List (ExitTarget × Ty) := [] + /-- A jump has no ordinary value. Its otherwise unconstrained result slot + may default to unit without making generic value inference permissive. -/ + dead : List String := [] + /-- Static interface checking may supply const types without their values. + Ordinary source checking always leaves this empty. -/ + interfaceConsts : List (String × Ty) := [] + +private abbrev Infer := StateT Inference (Except String) + +private def fresh : Infer Ty := do + let state ← get + set { state with next := state.next + 1 } + return .param s!"$infer{state.next}" + +private def normalizeAux (solutions : List (String × Ty)) : Nat → Ty → Ty + | 0, t => t + | fuel + 1, t => + if !t.parameters.any (·.startsWith "$infer") then t + else + let t' := t.subst solutions + if t' == t then t else normalizeAux solutions fuel t' + +private def normalize (s : Inference) (t : Ty) : Ty := + normalizeAux s.solutions (s.next + 1) t + +private def zonk (t : Ty) : Infer Ty := return normalize (← get) t + +private def finishType (s : Inference) (t : Ty) : Except String Ty := do + let defaults := s.dead.flatMap fun name => + match normalize s (.param name) with + | .param n => if n.startsWith "$infer" then [(n, Ty.tuple [])] else [] + | _ => [] + let t := (normalize s t).subst defaults + if t.parameters.any (·.startsWith "$infer") then + throw "cannot infer type arguments; add explicit ::<...> arguments or a result type" + return t + +private def bindMeta (name : String) (t : Ty) : Infer Unit := do + if t.parameters.contains name then throw "infinite type in type argument inference" + modify fun s => { s with solutions := (name, t) :: s.solutions } + +private def unify : Nat → Ty → Ty → Infer Unit + | 0, _, _ => throw "type inference depth limit exceeded" + | fuel + 1, a, b => do + let a ← zonk a + let b ← zonk b + if a == b then return + match a, b with + | .param n, t => + if n.startsWith "$infer" then bindMeta n t + else match t with + | .param m => + if m.startsWith "$infer" then bindMeta m a + else throw s!"type mismatch: {repr a} and {repr b}" + | _ => throw s!"type mismatch: {repr a} and {repr b}" + | t, .param n => + if n.startsWith "$infer" then bindMeta n t + else throw s!"type mismatch: {repr a} and {repr b}" + | .ptr a, .ptr b => unify fuel a b + | .array a n, .array b m => + if n != m then throw s!"array length mismatch: {n} and {m}" + unify fuel a b + | .tuple xs, .tuple ys | .named _ xs, .named _ ys => + match a, b with + | .named n _, .named m _ => if n != m then throw s!"different nominal types '{n}' and '{m}'" + | _, _ => pure () + if xs.length != ys.length then throw "type argument or tuple arity mismatch" + for (x, y) in xs.zip ys do unify fuel x y + | _, _ => throw s!"type mismatch: {repr a} and {repr b}" + +private def agree (a b : Ty) : Infer Unit := unify 1024 a b + +private def typeArgs (p : Program α) (rigid params : List String) (supplied : Option (List Ty)) : Infer (List Ty) := do + match supplied with + | some ts => + let _ ← liftM (arguments params ts) + liftM (ts.forM (checkType p rigid)) + return ts + | none => params.mapM fun _ => fresh + +private def ctorFields (p : Program α) (name ctor : String) (ts : List Ty) : Except String (List Ty) := do + let some decl := p.findEnum? name | throw s!"unknown enum '{name}'" + let env ← arguments decl.typeParams ts + let some c := decl.constructors.find? (·.name == ctor) | throw s!"unknown constructor '{name}::{ctor}'" + return c.fields.map (Ty.subst env) + +private def instantiateTemplate (p : Program α) (rigid params : List String) (target : Ty) : Infer Ty := do + liftM (checkParams params) + liftM (checkType p (params ++ rigid) target) + let ts ← params.mapM fun _ => fresh + return target.subst (params.zip ts) + +private def inferRecordHead (p : Program α) (rigid : List String) + (head : RecordHead) (count : Nat) (expected : Option Ty) : Infer (RecordHead × List Ty) := do + let type : Ty ← if head.params.isEmpty then do + let .named name supplied := head.type | throw "struct construction requires a nominal struct type" + let some decl := p.findStruct? name | throw s!"unknown struct '{name}'" + pure (Ty.named name (← typeArgs p rigid decl.typeParams (if supplied.isEmpty then none else some supplied))) + else instantiateTemplate p rigid head.params head.type + if let some expected := expected then agree type expected + let .named name types ← zonk type | throw "expected a known struct type" + let some decl := p.findStruct? name | throw s!"unknown struct '{name}'" + let env ← liftM (arguments decl.typeParams types) + if head.fields.length != count then throw "struct field/value count mismatch" + if let some field := findDuplicate head.fields [] then throw s!"duplicate struct field '{field}'" + let fieldTypes ← head.fields.mapM fun field => do + let some type := decl.fields.lookup field | throw s!"unknown field '{field}' in struct '{name}'" + pure (type.subst env) + if !head.rest then + for (field, _) in decl.fields do + if !head.fields.contains field then throw s!"missing field '{field}' in struct '{name}'" + let slots := decl.fields.map fun (field, _) => head.fields.findIdx? (· == field) + return ({ head with type := .named name types, params := [], slots := some slots }, fieldTypes) + +private def inferPattern (p : Program α) (rigid : List String) : Nat → Pattern α → Ty → Infer (Pattern α × List (String × Ty)) + | 0, _, _ => throw "pattern depth limit exceeded" + | fuel + 1, pat, expected => do + match pat with + | .record head ps => + let (head, types) ← inferRecordHead p rigid head ps.length (some expected) + let pairs ← (ps.zip types).mapM fun (pat, type) => inferPattern p rigid fuel pat type + return (.record head (pairs.map Prod.fst), (head.order (pairs.map Prod.snd) []).flatten) + | .literal x => agree .field expected; return (.literal x, []) + | .wildcard => return (.wildcard, []) + | .bind n => return (.bind n, [(n, expected)]) + | .global n annotation => + if let some t := annotation then agree t expected + if let some t := (← get).interfaceConsts.lookup n then + agree t expected + return (.global n (some expected), []) + let body ← liftM (Consts.lookup p.consts n) + let (_, bindings) ← inferPattern p rigid fuel body expected + if !bindings.isEmpty then throw s!"const '::{n}' contains a binder" + return (.global n (some expected), []) + | .orElse left right _ => + let (left, leftBindings) ← inferPattern p rigid fuel left expected + let (right, rightBindings) ← inferPattern p rigid fuel right expected + for bindings in [leftBindings, rightBindings] do + if let some n := findDuplicate (bindings.map Prod.fst) [] then + throw s!"duplicate pattern binding '{n}'" + if leftBindings.length != rightBindings.length then + throw "or-pattern alternatives must bind the same names" + for (name, type) in leftBindings do + let some other := rightBindings.lookup name | + throw s!"or-pattern alternative does not bind '{name}'" + agree type other + let names := leftBindings.map Prod.fst + let rightOrder := names.map fun name => rightBindings.findIdx (·.1 == name) + return (.orElse left right ⟨names, rightOrder⟩, leftBindings) + | .load pat => + let target ← fresh + agree (.ptr target) expected + let (pat, bindings) ← inferPattern p rigid fuel pat target + return (.load pat, bindings) + | .tuple ps => + let ts ← ps.mapM fun _ => fresh + agree (.tuple ts) expected + let pairs ← (ps.zip ts).mapM fun (pat, t) => inferPattern p rigid fuel pat t + return (.tuple (pairs.map Prod.fst), pairs.flatMap Prod.snd) + | .array ps => + liftM (checkArrayLength ps.length) + let t ← fresh + agree (.array t ps.length) expected + let pairs ← ps.mapM fun pat => inferPattern p rigid fuel pat t + return (.array (pairs.map Prod.fst), pairs.flatMap Prod.snd) + | .repeat pat n => + liftM (checkArrayLength n) + let t ← fresh + agree (.array t n) expected + let (pat, bindings) ← inferPattern p rigid fuel pat t + return (.repeat pat n, (List.replicate n bindings).flatten) + | .construct (.named n supplied) ctor ps => + let some decl := p.findEnum? n | throw s!"unknown enum '{n}'" + let ts ← typeArgs p rigid decl.typeParams (if supplied.isEmpty then none else some supplied) + agree (.named n ts) expected + let fields ← liftM (ctorFields p n ctor ts) + if ps.length != fields.length then throw s!"wrong arity for constructor '{n}::{ctor}'" + let pairs ← (ps.zip fields).mapM fun (pat, t) => inferPattern p rigid fuel pat t + return (.construct (.named n ts) ctor (pairs.map Prod.fst), pairs.flatMap Prod.snd) + | .construct _ _ _ => throw "constructor pattern requires a nominal enum type" + | .constructAs params target ctor ps => + let target ← instantiateTemplate p rigid params target + agree target expected + let .named n ts ← zonk target | throw "constructor pattern requires a known nominal enum type" + let fields ← liftM (ctorFields p n ctor ts) + if ps.length != fields.length then throw s!"wrong arity for constructor '{n}::{ctor}'" + let pairs ← (ps.zip fields).mapM fun (pat, t) => inferPattern p rigid fuel pat t + return (.construct (.named n ts) ctor (pairs.map Prod.fst), pairs.flatMap Prod.snd) + +private def pattern (p : Program α) (rigid : List String) (pat : Pattern α) (t : Ty) : Infer (Pattern α × List (String × Ty)) := do + let (pat, bindings) ← inferPattern p rigid 1024 pat t + if let some n := findDuplicate (bindings.map Prod.fst) [] then throw s!"duplicate pattern binding '{n}'" + return (pat, bindings) + +private def inferUpdatePath (p : Program α) : Ty → UpdatePath → Infer (Ty × UpdatePath) + | type, [] => pure (type, []) + | type, step :: rest => do + let type ← zonk type + let (target, step) ← match step, type with + | .member field, .named name types => do + let some decl := p.findStruct? name | throw "update field requires a struct" + let some index := decl.fields.findIdx? (fun pair => pair.1 == field.name) | + throw s!"unknown update field '{field.name}' in struct '{name}'" + let some target := decl.fields.lookup field.name | throw "unknown update field" + let env ← liftM (arguments decl.typeParams types) + pure (target.subst env, UpdateStep.member { field with owner := some type, index, arity := decl.fields.length }) + | .project index _, .tuple fields => do + let some target := fields[index]? | throw "tuple update index out of bounds" + pure (target, UpdateStep.project index fields.length) + | .index index _, .array element length => do + if index >= length then throw "array update index out of bounds" + pure (element, UpdateStep.index index length) + | _, .ptr _ => throw "update paths cannot follow pointers; load the value explicitly" + | .member _, _ => throw "update field requires a struct" + | .project _ _, _ => throw "tuple update requires a tuple" + | .index _ _, _ => throw "array update requires an array" + let (result, rest) ← inferUpdatePath p target rest + return (result, step :: rest) + +private def updateOverlap : UpdatePath → UpdatePath → Bool + | [], _ | _, [] => true + | a :: as, b :: bs => a.position == b.position && updateOverlap as bs + +private def infer (p : Program α) (rigid : List String) : + Nat → List (String × Ty) → Expr α → Option Ty → Infer (Ty × Expr α) + | 0, _, _, _ => throw "expression depth limit exceeded" + | fuel + 1, locals, e, expected => do + let (t, e) ← match e with + | .control (.block label) body => do + liftM (checkIdentifier label) + let target ← match expected with | some t => pure t | none => fresh + let previous := (← get).exits + modify fun s => { s with exits := (.block label, target) :: previous } + let (_, body) ← infer p rigid fuel locals body (some target) + modify fun s => { s with exits := previous } + pure (target, .control (.block label) body) + | .control (.exit target) value => do + let some result := (← get).exits.lookup target | + throw (match target with + | .function => "return outside a function" + | .block label => s!"unknown enclosing block label '{label}'") + let (_, value) ← infer p rigid fuel locals value (some result) + let t ← match expected with + | some t => pure t + | none => fresh + modify fun s => { s with dead := t.parameters ++ s.dead } + pure (t, .control (.exit target) value) + | .builtin op operands => do + match op with + | .ascribe type => + liftM (checkType p rigid type) + let [value] := operands | throw "type annotations take one expression" + if let some expected := expected then agree type expected + let (_, value) ← infer p rigid fuel locals value (some type) + pure (type, .builtin (.ascribe type) [value]) + | .assertEq message => + let [left, right] := operands | throw "assert_eq! takes two operands" + let (type, left) ← infer p rigid fuel locals left none + let (_, right) ← infer p rigid fuel locals right (some type) + let type ← zonk type + liftM (checkPointerFree p "assert_eq!" 1024 [] type) + pure (.tuple [], .builtin (.assertEq message) [left, right]) + | .debug message => + let pairs ← operands.mapM fun value => infer p rigid fuel locals value none + pure (.tuple [], .builtin (.debug message) (pairs.map Prod.snd)) + | .update paths operands => do + let base :: replacements := operands | throw "update requires a base value" + if paths.length != replacements.length then throw "update path/replacement count mismatch" + let (type, base) ← infer p rigid fuel locals base expected + let mut checkedPaths := [] + let mut checkedValues := [] + for (path, replacement) in paths.zip replacements do + if path.isEmpty then throw "update paths cannot be empty" + let (target, path) ← inferUpdatePath p type path + if checkedPaths.any (updateOverlap path) then throw "duplicate or overlapping update targets" + let (_, replacement) ← infer p rigid fuel locals replacement (some target) + checkedPaths := checkedPaths ++ [path] + checkedValues := checkedValues ++ [replacement] + pure (type, .update checkedPaths (base :: checkedValues)) + | .record head xs => do + if head.rest then throw "struct values must specify every field" + let (head, types) ← inferRecordHead p rigid head xs.length expected + let pairs ← (xs.zip types).mapM fun (expr, type) => infer p rigid fuel locals expr (some type) + pure (head.type, .record head (pairs.map Prod.snd)) + | .member value field => do + let (type, value) ← infer p rigid fuel locals value none + let .named name types ← zonk type | throw "named field access requires a struct" + let some decl := p.findStruct? name | throw "named field access requires a struct" + let some index := decl.fields.findIdx? (fun pair => pair.1 == field.name) | + throw s!"unknown field '{field.name}' in struct '{name}'" + let some type := decl.fields.lookup field.name | throw "unknown struct field" + let env ← liftM (arguments decl.typeParams types) + pure (type.subst env, .member value + { field with owner := some (.named name types), index, arity := decl.fields.length }) + | .literal x => pure (.field, .literal x) + | .var n => + match locals.lookup n with + | some t => pure (t, .var n) + | none => infer p rigid fuel [] (.global n) expected + | .global n annotation => do + let t ← match expected with | some t => pure t | none => fresh + if let some a := annotation then agree a t + if let some declared := (← get).interfaceConsts.lookup n then agree declared t + else + let body ← liftM (Consts.lookup p.consts n) + let (_, bindings) ← inferPattern p rigid fuel body t + if !bindings.isEmpty then throw s!"const '::{n}' contains a binder" + pure (t, .global n (some t)) + | .tuple xs => do + let ts ← match expected with + | some (.tuple ts) => + if ts.length == xs.length then pure ts + else + let ts ← xs.mapM fun _ => fresh + if let some expected := expected then agree (.tuple ts) expected + pure ts + | _ => + let ts ← xs.mapM fun _ => fresh + if let some expected := expected then agree (.tuple ts) expected + pure ts + let pairs ← (xs.zip ts).mapM fun (x, t) => infer p rigid fuel locals x (some t) + pure (.tuple ts, .tuple (pairs.map Prod.snd)) + | .array xs => do + liftM (checkArrayLength xs.length) + let t ← fresh + if let some expected := expected then agree (.array t xs.length) expected + let pairs ← xs.mapM fun x => infer p rigid fuel locals x (some t) + pure (.array t xs.length, .array (pairs.map Prod.snd)) + | .repeat x n => do + liftM (checkArrayLength n) + let t ← fresh + if let some expected := expected then agree (.array t n) expected + let (_, x) ← infer p rigid fuel locals x (some t) + pure (.array t n, .repeat x n) + | .index x i => do + let (t, x) ← infer p rigid fuel locals x none + let .array t n ← zonk t | throw "indexing requires a known array type" + if i >= n then throw s!"array index {i} out of bounds for length {n}" + pure (t, .index x i) + | .slice x start stop => do + let (t, x) ← infer p rigid fuel locals x none + let .array t n ← zonk t | throw "slicing requires a known array type" + let stop := stop.getD n + if start > stop || stop > n then throw s!"array slice {start}..{stop} out of bounds for length {n}" + pure (.array t (stop - start), .slice x start (some stop)) + | .construct n supplied ctor xs => do + let some decl := p.findEnum? n | throw s!"unknown enum '{n}'" + let ts ← match supplied, expected with + | none, some (.named m ts) => + if m == n && ts.length == decl.typeParams.length then pure ts + else + let ts ← typeArgs p rigid decl.typeParams none + if let some expected := expected then agree (.named n ts) expected + pure ts + | _, _ => + let ts ← typeArgs p rigid decl.typeParams supplied + if let some expected := expected then agree (.named n ts) expected + pure ts + let fields ← liftM (ctorFields p n ctor ts) + if xs.length != fields.length then throw s!"wrong arity for constructor '{n}::{ctor}'" + let pairs ← (xs.zip fields).mapM fun (x, t) => infer p rigid fuel locals x (some t) + pure (.named n ts, .construct n (some ts) ctor (pairs.map Prod.snd)) + | .constructAs params target ctor xs => do + let target ← instantiateTemplate p rigid params target + if let some expected := expected then agree target expected + let .named n ts ← zonk target | throw "constructor requires a known nominal enum type" + let fields ← liftM (ctorFields p n ctor ts) + if xs.length != fields.length then throw s!"wrong arity for constructor '{n}::{ctor}'" + let pairs ← (xs.zip fields).mapM fun (x, t) => infer p rigid fuel locals x (some t) + pure (.named n ts, .construct n (some ts) ctor (pairs.map Prod.snd)) + | .project x i => do + let (t, x) ← infer p rigid fuel locals x none + let .tuple ts ← zonk t | throw "projection requires a known tuple type" + let some t := ts[i]? | throw s!"tuple index {i} out of bounds" + pure (t, .project x i) + | .letValue pat x b => do + let (t, x) ← infer p rigid fuel locals x none + let (pat, bs) ← pattern p rigid pat t + let (t, b) ← infer p rigid fuel (bs ++ locals) b expected + pure (t, .letValue pat x b) + | .store x => do + let target ← match expected with + | some (.ptr t) => pure t + | _ => + let target ← fresh + if let some expected := expected then agree (.ptr target) expected + pure target + let (_, x) ← infer p rigid fuel locals x (some target) + pure (.ptr target, .store x) + | .load x => do + let target ← fresh + let (_, x) ← infer p rigid fuel locals x (some (.ptr target)) + pure (target, .load x) + | .hint t k channel => do + if !t.concrete then throw "hint result types must be concrete, including in generic functions" + liftM (checkType p [] t) + liftM (checkPointerFree p "hint result" 1024 [] t) + let decls ← liftM (collectEnums p [] 1024 [] (coreTypeNames t.toCore)) + let _ ← liftM ((checkHintType decls "generic function" t.toCore).mapError toString) + let (_, k) ← infer p rigid fuel locals k none + pure (t, .hint t k channel) + | .neg x => do + let (_, x) ← infer p rigid fuel locals x (some .field) + pure (.field, .neg x) + | .binary op x y => do + let (_, x) ← infer p rigid fuel locals x (some .field) + let (_, y) ← infer p rigid fuel locals y (some .field) + pure (.field, .binary op x y) + | .call n supplied xs => do + let (params, inputs, result) ← match p.findFunction? n with + | some fn => pure (fn.typeParams, fn.params.map Prod.snd, fn.result) + | none => match p.maps.find? (·.name == n) with + | some m => pure ([], m.params.map Prod.snd, m.result) + | none => throw s!"unknown function or map '{n}'" + let ts ← typeArgs p rigid params supplied + let env := params.zip ts + let result := result.subst env + if let some expected := expected then agree result expected + if xs.length != inputs.length then throw s!"wrong argument count for '{n}'" + let pairs ← (xs.zip inputs).mapM fun (x, t) => infer p rigid fuel locals x (some (t.subst env)) + pure (result, .call n (some ts) (pairs.map Prod.snd)) + | .matchValue x arms => do + if arms.isEmpty then throw "empty match" + let (t, x) ← infer p rigid fuel locals x none + let result ← match expected with | some t => pure t | none => fresh + let arms ← arms.mapM fun (pat, b) => do + let (pat, bs) ← pattern p rigid pat t + let (_, b) ← infer p rigid fuel (bs ++ locals) b (some result) + return (pat, b) + pure (result, .matchValue x arms) + if let some expected := expected then agree t expected + return (t, e) + +private def finishPattern (s : Inference) : Pattern α → Except String (Pattern α) + | .literal x => pure (.literal x) + | .wildcard => pure .wildcard + | .bind n => pure (.bind n) + | .global n t => return .global n (← t.mapM (finishType s)) + | .record head ps => return .record { head with type := ← finishType s head.type } (← ps.mapM (finishPattern s)) + | .orElse left right names => return .orElse (← finishPattern s left) (← finishPattern s right) names + | .load p => return .load (← finishPattern s p) + | .tuple ps => return .tuple (← ps.mapM (finishPattern s)) + | .array ps => return .array (← ps.mapM (finishPattern s)) + | .repeat p n => return .repeat (← finishPattern s p) n + | .construct t c ps => return .construct (← finishType s t) c (← ps.mapM (finishPattern s)) + | .constructAs _ _ _ _ => throw "unelaborated constructor pattern template" +termination_by p => sizeOf p + +private def finishExpr (s : Inference) : Expr α → Except String (Expr α) + | .control kind body => return .control kind (← finishExpr s body) + | .literal x => pure (.literal x) + | .var n => pure (.var n) + | .global n t => return .global n (← t.mapM (finishType s)) + | .tuple xs => return .tuple (← xs.mapM (finishExpr s)) + | .array xs => return .array (← xs.mapM (finishExpr s)) + | .repeat x n => return .repeat (← finishExpr s x) n + | .index x i => return .index (← finishExpr s x) i + | .slice x start stop => return .slice (← finishExpr s x) start stop + | .construct n ts c xs => return .construct n (some (← (ts.getD []).mapM (finishType s))) c (← xs.mapM (finishExpr s)) + | .constructAs _ _ _ _ => throw "unelaborated constructor template" + | .builtin op xs => return .builtin (← op.mapTypesM (finishType s)) (← xs.mapM (finishExpr s)) + | .update paths xs => do + let paths ← paths.mapM fun path => path.mapM fun step => match step with + | .member field => return .member { field with owner := ← field.owner.mapM (finishType s) } + | step => pure step + return .update paths (← xs.mapM (finishExpr s)) + | .record head xs => return .record { head with type := ← finishType s head.type } (← xs.mapM (finishExpr s)) + | .member x field => return .member (← finishExpr s x) { field with owner := ← field.owner.mapM (finishType s) } + | .project x i => return .project (← finishExpr s x) i + | .letValue p x b => return .letValue (← finishPattern s p) (← finishExpr s x) (← finishExpr s b) + | .store x => return .store (← finishExpr s x) + | .load x => return .load (← finishExpr s x) + | .hint t k channel => return .hint (← finishType s t) (← finishExpr s k) channel + | .neg x => return .neg (← finishExpr s x) + | .binary op x y => return .binary op (← finishExpr s x) (← finishExpr s y) + | .call n ts xs => return .call n (some (← (ts.getD []).mapM (finishType s))) (← xs.mapM (finishExpr s)) + | .matchValue x arms => + return .matchValue (← finishExpr s x) + (← arms.mapM fun arm => return (← finishPattern s arm.1, ← finishExpr s arm.2)) +termination_by e => sizeOf e +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; try simp_all only [Prod.mk.sizeOf_spec] + all_goals first | omega | cases ‹Pattern α × Expr α›; simp_all only [Prod.mk.sizeOf_spec]; omega + +def elaborateExpr (p : Program α) (rigid : List String) (locals : List (String × Ty)) + (e : Expr α) (expected : Ty) (inFunction : Bool := false) + (interfaceConsts : List (String × Ty) := []) : Except String (Expr α) := do + let ((_, e), state) ← infer p rigid 4096 locals e (some expected) + { exits := if inFunction then [(.function, expected)] else [], interfaceConsts } + finishExpr state e + +/-- Infer a module's exported constant type using only dependency interfaces. +The pattern is checked directly, without inventing values for abstract types. -/ +def inferInterfaceConst (p : Program α) (body : Pattern α) + (expected : Option Ty) (interfaceConsts : List (String × Ty)) + (requireConcrete : Bool := true) : Except String Ty := do + let (type, state) ← (do + let type ← match expected with | some type => pure type | none => fresh + let (_, bindings) ← inferPattern p [] 4096 body type + if !bindings.isEmpty then throw "const body contains binders" + zonk type : Infer Ty).run { interfaceConsts } + let type ← (zonk type).run' state + if requireConcrete && !type.concrete then throw "ambiguous exported const type; add a type annotation" + return type + +/-- Check one const body at its use type, retaining any nested references. +This supplies type information for context-dependent constructors such as +`Option::None`; it never inlines a referenced const. -/ +def elaborateConst (p : Program α) (name : String) (expected : Ty) : Except String (Pattern α) := do + let body ← Consts.lookup p.consts name + let ((body, _), state) ← inferPattern p expected.parameters 4096 body expected {} + finishPattern state body + +/-- Syntactic call dependencies retain every branch, including redundant ones. +Consts cannot contain calls, so a reference introduces no function dependency. -/ +def sourceCalls (types : List (String × Ty)) : Expr α → List Instance + | .call name supplied args => + ⟨name, (supplied.getD []).map (Ty.subst types)⟩ :: args.flatMap (sourceCalls types) + | .builtin _ xs | .update _ xs | .record _ xs | .tuple xs | .array xs | .construct _ _ _ xs | .constructAs _ _ _ xs => xs.flatMap (sourceCalls types) + | .member x _ | .control _ x | .project x _ | .index x _ | .slice x _ _ | .repeat x _ | .store x | .load x | .hint _ x channel | .neg x => sourceCalls types x + | .letValue _ x b | .binary _ x b => sourceCalls types x ++ sourceCalls types b + | .matchValue x arms => sourceCalls types x ++ arms.flatMap (fun a => sourceCalls types a.2) + | _ => [] +termination_by e => sizeOf e +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +/-- Whole-program conservative specialization admissibility. Ordinary recursion +closes a path; a change of recursive type arguments is rejected even in an +unused function. This is independent of termination of value evaluation. -/ +def checkGenericCycles (p : Program α) : Except String Unit := do + let rec visit : Nat → List Instance → Instance → Except String Unit + | 0, _, _ => throw "generic dependency depth exceeded" + | fuel + 1, path, key => do + let some fn := p.findFunction? key.name | return + if let some ancestor := path.find? (·.name == key.name) then + if ancestor != key then + throw s!"recursive call to '{key.name}' changes type arguments" + return + let types ← arguments fn.typeParams key.types + (sourceCalls types fn.body).forM (visit fuel (key :: path)) + -- Only a generic function can be revisited with different type arguments. + -- Every such function is checked from its own symbolic root, including paths + -- through ordinary functions. Starting again at every ordinary function adds + -- no check, but enumerates exponentially many paths in large recursive code. + (p.functions.filter (fun fn => !fn.typeParams.isEmpty)).forM fun fn => + visit (p.functions.length + 1) [] ⟨fn.name, fn.typeParams.map Ty.param⟩ + +/-- Only edges between mandatory-inline functions participate in this check. +An ordinary function call stops expansion, including on a recursive path. -/ +def checkInlineCycles (p : Program α) : Except String Unit := do + let rec visit : Nat → List String → String → Except String Unit + | 0, _, _ => throw "inline dependency depth exceeded" + | fuel + 1, path, name => do + let some fn := p.findFunction? name | return + if !fn.isInline then return + if path.contains name then throw s!"inline cycle through '{name}'" + for callee in sourceCalls [] fn.body do + visit fuel (name :: path) callee.name + for fn in p.functions do visit (p.functions.length + 1) [] fn.name + +/-- Check source expressions and infer their type metadata. Const references +remain references; only type information is normalized. -/ +def elaborate (p : Program α) : Except String (Program α) := do + Consts.checkAcyclic p + let aliases := p.aliases + let p ← expandAliases p + if let some n := findDuplicate (p.functions.map (·.name) ++ p.maps.map (·.name)) [] then + throw s!"duplicate function/map '{n}'" + if let some n := findDuplicate (p.enums.map (·.name)) [] then throw s!"duplicate enum '{n}'" + for d in p.structs do + checkIdentifier d.name + if d.name == "Field" then throw "Field is a reserved type name" + checkParams d.typeParams + if let some field := findDuplicate (d.fields.map Prod.fst) [] then throw s!"duplicate struct field '{field}'" + for (name, type) in d.fields do + checkIdentifier name + checkType p d.typeParams type + checkInlineType p 1024 [] (.named d.name (d.typeParams.map Ty.param)) + let name := (Instance.mk d.name (d.typeParams.map Ty.param)).symbol + let decls ← collectEnums p d.typeParams 1024 [] [name] + (checkDeclarations decls).mapError toString + for d in p.enums do + checkIdentifier d.name + if d.name == "Field" then throw "Field is a reserved type name" + checkParams d.typeParams + if d.constructors.isEmpty then throw s!"empty enum '{d.name}'" + if let some n := findDuplicate (d.constructors.map (·.name)) [] then throw s!"duplicate constructor '{n}'" + for c in d.constructors do + checkIdentifier c.name + c.fields.forM (checkType p d.typeParams) + let name := (Instance.mk d.name (d.typeParams.map Ty.param)).symbol + checkInlineType p 1024 [] (.named d.name (d.typeParams.map Ty.param)) + let decls ← collectEnums p d.typeParams 1024 [] [name] + (checkDeclarations decls).mapError toString + for d in p.consts do + -- Templates need not fix omitted constructor type arguments before a use + -- supplies context, but every template must admit a consistent type. + let _ ← (do + let target ← fresh + let _ ← inferPattern p [] 1024 d.value target + pure () : Infer Unit).run {} + let functions ← p.functions.mapM fun fn => do + checkIdentifier fn.name + checkParams fn.typeParams + if let some n := findDuplicate (fn.params.map Prod.fst) [] then throw s!"duplicate parameter '{n}'" + (fn.params.map Prod.snd ++ [fn.result]).forM (checkType p fn.typeParams) + let body ← elaborateExpr p fn.typeParams fn.params fn.body fn.result true + return { fn with body } + let tables ← p.tables.mapM fun t => do + checkType p [] t.rowType + checkPointerFree p s!"table '{t.name}'" 1024 [] t.rowType + let rows ← t.rows.mapM fun row => elaborateExpr p [] [] row t.rowType + return { t with rows } + for m in p.maps do + checkIdentifier m.name + (m.params.map Prod.snd ++ [m.result]).forM (checkType p []) + (m.params.map Prod.snd ++ [m.result]).forM (checkPointerFree p s!"map '{m.name}'" 1024 []) + let some input := p.tables.find? (·.name == m.input) | throw s!"unknown table '{m.input}'" + let some output := p.tables.find? (·.name == m.output) | throw s!"unknown table '{m.output}'" + if input.rowType != .tuple (m.params.map Prod.snd) then throw s!"input table type mismatch for map '{m.name}'" + if output.rowType != m.result then throw s!"output table type mismatch for map '{m.name}'" + let checked := { p with functions, tables, aliases } + checkGenericCycles checked + checkInlineCycles checked + return checked + +/-- Compiler preparation may inline consts after the source semantics boundary. +The source checker above does not use this transformation. -/ +def prepareTemplates (p : Program α) : Except String (Program α) := do + let p ← elaborate (← expandConsts p) + return { p with aliases := [], consts := [] } + +/-- Resolve pattern conditions for diagnostics and compiler preparation. The +original match arms remain unchanged. -/ +def inspectPattern (p : Program α) : Nat → Pattern α → Except String (Pattern α) + | 0, _ => throw "pattern inspection depth exceeded" + | fuel + 1, pat => match pat with + | .global name (some type) => do inspectPattern p fuel (← elaborateConst p name type) + | .global name none => throw s!"missing type information for const '::{name}'" + | .record head ps => return .record head (← ps.mapM (inspectPattern p fuel)) + | .orElse left right names => return .orElse (← inspectPattern p fuel left) (← inspectPattern p fuel right) names + | .load pat => return .load (← inspectPattern p fuel pat) + | .tuple ps => return .tuple (← ps.mapM (inspectPattern p fuel)) + | .array ps => return .array (← ps.mapM (inspectPattern p fuel)) + | .repeat pat n => return .repeat (← inspectPattern p fuel pat) n + | .construct t c ps => return .construct t c (← ps.mapM (inspectPattern p fuel)) + | .constructAs ts t c ps => return .constructAs ts t c (← ps.mapM (inspectPattern p fuel)) + | _ => pure pat + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/Engine.lean b/Aiur/Aiur/Generic/Engine.lean new file mode 100644 index 000000000..13bd55288 --- /dev/null +++ b/Aiur/Aiur/Generic/Engine.lean @@ -0,0 +1,246 @@ +import Aiur.EvalCorrectness + +namespace Aiur.Generic.Engine + +/-- An open runtime resolves calls on demand. The expression language and all +heap operations are the same as in the monomorphic core. -/ +structure World (F : Type) where + prepare : String → List (SourceValue F) → Except EvalError (Environment F Nat × Aiur.Expr F) + typed : Aiur.Ty → Constant F → Bool + +abbrev HintProvider (w : World F) := String → SourceValue F → (type : Aiur.Ty) → + Except HintError { value : Constant F // w.typed type value = true } + +def unavailable : HintProvider w := fun _ _ _ => .error .unavailable + +def World.ofProgram [DecidableEq F] (p : Aiur.Program F) : World F := + ⟨prepareCall p, fun t v => v.hasType p.enums t⟩ + +/-- Eager evaluation threads the allocation heap through operands and internal calls. -/ +def evalExprWith [Field F] [DecidableEq F] (world : World F) (hints : HintProvider world) + (locals : Environment F Nat) : Nat → Expr F → Evaluation F (SourceValue F) + | 0, _ => throw .outOfFuel + | fuel + 1, expr => do + match expr with + | .literal value => return .field value + | .var name => + let some (_, value) := locals.find? (·.1 == name) | throw (.unboundVariable name) + return value + | .tuple items => return .tuple (← items.mapM (evalExprWith world hints locals fuel)) + | .construct name ctor args => + return .construct name ctor (← args.mapM (evalExprWith world hints locals fuel)) + | .project value index => liftM (projectValue (← evalExprWith world hints locals fuel value) index) + | .letValue pattern value body => + let value ← evalExprWith world hints locals fuel value + let some bindings := pattern.bindings value | throw .patternMismatch + evalExprWith world hints (bindings ++ locals) fuel body + | .store value => + let value ← evalExprWith world hints locals fuel value + let heap ← get + set (heap ++ [value]) + return .ptr value.type heap.length + | .load pointer => + let pointer ← evalExprWith world hints locals fuel pointer + liftM (loadValue (← get) pointer) + | .hint type key channel => + let key ← evalExprWith world hints locals fuel key + let value ← liftM ((hints channel key type).mapError EvalError.hint) + return value.val.toValue + | .neg value => liftM (evalNeg (← evalExprWith world hints locals fuel value)) + | .assertEq op left right => + liftM (evalAssertEq op (← evalExprWith world hints locals fuel left) (← evalExprWith world hints locals fuel right)) + | .binary op left right => + liftM (evalBinOp op (← evalExprWith world hints locals fuel left) (← evalExprWith world hints locals fuel right)) + | .call name args => + let values ← args.mapM (evalExprWith world hints locals fuel) + let (bindings, body) ← liftM (world.prepare name values) + evalExprWith world hints bindings fuel body + | .matchValue scrutinee arms => + let value ← evalExprWith world hints locals fuel scrutinee + let some (bindings, body) := selectArm value arms | throw .noMatchingArm + evalExprWith world hints (bindings ++ locals) fuel body + + +mutual + /-- Finite source evaluation threads a fresh-allocation heap, with no fuel. -/ + inductive EvalExpr [Field F] [DecidableEq F] (world : World F) : + Environment F Nat → Expr F → Heap F → SourceValue F → Heap F → Prop where + | literal : EvalExpr world locals (.literal value) heap (.field value) heap + | var (lookup : locals.find? (·.1 == name) = some (name, value)) : + EvalExpr world locals (.var name) heap value heap + | tuple (items : EvalArgs world locals exprs before values after) : + EvalExpr world locals (.tuple exprs) before (.tuple values) after + | construct (items : EvalArgs world locals exprs before values after) : + EvalExpr world locals (.construct name ctor exprs) before (.construct name ctor values) after + | project (value : EvalExpr world locals expr before input after) + (projected : projectValue input index = .ok result) : + EvalExpr world locals (.project expr index) before result after + | letValue (value : EvalExpr world locals expr before input middle) + (matched : pattern.bindings input = some bindings) + (body : EvalExpr world (bindings ++ locals) rest middle result after) : + EvalExpr world locals (.letValue pattern expr rest) before result after + | store (value : EvalExpr world locals expr before input middle) : + EvalExpr world locals (.store expr) before (.ptr input.type middle.length) (middle ++ [input]) + | load (pointer : EvalExpr world locals expr before input after) + (loaded : loadValue after input = .ok result) : + EvalExpr world locals (.load expr) before result after + | hint (key : EvalExpr world locals expr before input after) + {value : Constant F} (typed : world.typed type value = true) : + EvalExpr world locals (.hint type expr channel) before value.toValue after + | neg (value : EvalExpr world locals expr before input after) + (operation : evalNeg input = .ok result) : + EvalExpr world locals (.neg expr) before result after + | assertEq (left : EvalExpr world locals lhs before x middle) + (right : EvalExpr world locals rhs middle y after) + (operation : evalAssertEq op x y = .ok result) : + EvalExpr world locals (.assertEq op lhs rhs) before result after + | binary (left : EvalExpr world locals lhs before x middle) + (right : EvalExpr world locals rhs middle y after) + (operation : evalBinOp op x y = .ok result) : + EvalExpr world locals (.binary op lhs rhs) before result after + | call (arguments : EvalArgs world locals args before values middle) + (callee : EvalFn world name values middle result after) : + EvalExpr world locals (.call name args) before result after + | matchValue (value : EvalExpr world locals expr before input middle) + (selected : selectArm input arms = some (bindings, body)) + (branch : EvalExpr world (bindings ++ locals) body middle result after) : + EvalExpr world locals (.matchValue expr arms) before result after + + inductive EvalArgs [Field F] [DecidableEq F] (world : World F) : + Environment F Nat → List (Expr F) → Heap F → List (SourceValue F) → Heap F → Prop where + | nil : EvalArgs world locals [] heap [] heap + | cons (head : EvalExpr world locals expr before value middle) + (tail : EvalArgs world locals exprs middle values after) : + EvalArgs world locals (expr :: exprs) before (value :: values) after + + /-- Internal calls share the caller's heap and may receive pointers. -/ + inductive EvalFn [Field F] [DecidableEq F] (world : World F) : + String → List (SourceValue F) → Heap F → SourceValue F → Heap F → Prop where + | intro (prepared : world.prepare name args = .ok (locals, expr)) + (body : EvalExpr world locals expr before result after) : + EvalFn world name args before result after +end + + +variable {F : Type} {world : World F} {hints : HintProvider world} + +private theorem evalArgs_of_mapM [Field F] [DecidableEq F] + {locals : Environment F Nat} {fuel : Nat} + (sound : ∀ expr before result after, + evalExprWith world hints locals fuel expr before = .ok (result, after) → + EvalExpr world locals expr before result after) + {args : List (Expr F)} {values : List (SourceValue F)} {before after : Heap F} + (executed : args.mapM (evalExprWith world hints locals fuel) before = .ok (values, after)) : + EvalArgs world locals args before values after := by + induction args generalizing before values with + | nil => + obtain ⟨rfl, rfl⟩ := Evaluation.pure_ok.mp executed + exact .nil + | cons head tail ih => + rw [List.mapM_cons] at executed + obtain ⟨value, middle, headRun, rest⟩ := Evaluation.bind_ok.mp executed + obtain ⟨results, last, tailRun, finished⟩ := Evaluation.bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := Evaluation.pure_ok.mp finished + exact .cons (sound head before value middle headRun) (ih tailRun) + +/-- Every successful run, including its final heap, has a fuel-free evaluation proof. -/ +theorem evalExpr_spec [Field F] [DecidableEq F] + {locals : Environment F Nat} {fuel : Nat} {expr : Expr F} + {before after : Heap F} {result : SourceValue F} + (executed : evalExprWith world hints locals fuel expr before = .ok (result, after)) : + EvalExpr world locals expr before result after := by + induction fuel generalizing locals expr before result after with + | zero => simp [evalExprWith] at executed + | succ fuel ih => + cases expr with + | literal value => + obtain ⟨rfl, rfl⟩ := Evaluation.pure_ok.mp executed + exact .literal + | var name => + cases found : locals.find? (·.1 == name) with + | none => simp [evalExprWith, found, Evaluation.throw_apply] at executed + | some binding => + rcases binding with ⟨key, value⟩ + have same : key = name := by simpa using List.find?_some found + subst key + simp only [evalExprWith, found] at executed + obtain ⟨rfl, rfl⟩ := Evaluation.pure_ok.mp executed + exact .var found + | tuple items => + simp only [evalExprWith] at executed + obtain ⟨values, middle, itemsRun, finished⟩ := Evaluation.bind_ok.mp executed + obtain ⟨rfl, rfl⟩ := Evaluation.pure_ok.mp finished + exact .tuple (evalArgs_of_mapM (fun _ _ _ _ h => ih h) itemsRun) + | construct name ctor items => + simp only [evalExprWith] at executed + obtain ⟨values, middle, itemsRun, finished⟩ := Evaluation.bind_ok.mp executed + obtain ⟨rfl, rfl⟩ := Evaluation.pure_ok.mp finished + exact .construct (evalArgs_of_mapM (fun _ _ _ _ h => ih h) itemsRun) + | project value index => + simp only [evalExprWith] at executed + obtain ⟨input, middle, operand, operation⟩ := Evaluation.bind_ok.mp executed + obtain ⟨projected, rfl⟩ := Evaluation.lift_ok.mp operation + exact .project (ih operand) projected + | hint type key channel => + simp only [evalExprWith] at executed + obtain ⟨input, middle, keyRun, rest⟩ := Evaluation.bind_ok.mp executed + obtain ⟨value, last, supplied, finished⟩ := Evaluation.bind_ok.mp rest + obtain ⟨_, rfl⟩ := Evaluation.lift_ok.mp supplied + obtain ⟨rfl, rfl⟩ := Evaluation.pure_ok.mp finished + exact .hint (ih keyRun) value.property + | neg value => + simp only [evalExprWith] at executed + obtain ⟨input, middle, operand, operation⟩ := Evaluation.bind_ok.mp executed + obtain ⟨negated, rfl⟩ := Evaluation.lift_ok.mp operation + exact .neg (ih operand) negated + | store value => + simp only [evalExprWith] at executed + obtain ⟨input, middle, operand, stored⟩ := Evaluation.bind_ok.mp executed + have same : (.ptr input.type middle.length, middle ++ [input]) = (result, after) := by + simpa [bind, StateT.bind, Evaluation.get_apply, set, StateT.set, + pure, StateT.pure, Except.pure, Except.bind] using stored + cases same + exact .store (ih operand) + | load value => + simp only [evalExprWith] at executed + obtain ⟨input, middle, operand, loaded⟩ := Evaluation.bind_ok.mp executed + have lifted : (liftM (loadValue middle input) : Evaluation F _) middle = .ok (result, after) := by + simpa [bind, StateT.bind, Evaluation.get_apply, Except.bind] using loaded + obtain ⟨loadOK, rfl⟩ := Evaluation.lift_ok.mp lifted + exact .load (ih operand) loadOK + | assertEq op left right => + simp only [evalExprWith] at executed + obtain ⟨leftValue, middle, leftRun, rest⟩ := Evaluation.bind_ok.mp executed + obtain ⟨rightValue, last, rightRun, operation⟩ := Evaluation.bind_ok.mp rest + obtain ⟨operationOK, rfl⟩ := Evaluation.lift_ok.mp operation + exact .assertEq (ih leftRun) (ih rightRun) operationOK + | binary op left right => + simp only [evalExprWith] at executed + obtain ⟨leftValue, middle, leftRun, rest⟩ := Evaluation.bind_ok.mp executed + obtain ⟨rightValue, last, rightRun, operation⟩ := Evaluation.bind_ok.mp rest + obtain ⟨operationOK, rfl⟩ := Evaluation.lift_ok.mp operation + exact .binary (ih leftRun) (ih rightRun) operationOK + | letValue pattern value body => + simp only [evalExprWith] at executed + obtain ⟨input, middle, operand, rest⟩ := Evaluation.bind_ok.mp executed + cases matched : pattern.bindings input with + | none => simp [matched] at rest + | some bindings => + exact .letValue (ih operand) matched (ih (by simpa only [matched] using rest)) + | matchValue scrutinee arms => + simp only [evalExprWith] at executed + obtain ⟨input, middle, operand, rest⟩ := Evaluation.bind_ok.mp executed + cases selected : selectArm input arms with + | none => simp [selected] at rest + | some binding => + rcases binding with ⟨bindings, body⟩ + exact .matchValue (ih operand) selected (ih (by simpa only [selected] using rest)) + | call name args => + simp only [evalExprWith] at executed + obtain ⟨values, middle, arguments, rest⟩ := Evaluation.bind_ok.mp executed + obtain ⟨⟨bindings, body⟩, last, prepared, called⟩ := Evaluation.bind_ok.mp rest + obtain ⟨prepareOK, rfl⟩ := Evaluation.lift_ok.mp prepared + exact .call (evalArgs_of_mapM (fun _ _ _ _ h => ih h) arguments) (.intro prepareOK (ih called)) + + +end Aiur.Generic.Engine diff --git a/Aiur/Aiur/Generic/EngineInversion.lean b/Aiur/Aiur/Generic/EngineInversion.lean new file mode 100644 index 000000000..12cda1def --- /dev/null +++ b/Aiur/Aiur/Generic/EngineInversion.lean @@ -0,0 +1,46 @@ +import Aiur.Generic.OpenCore + +namespace Aiur.Generic.OpenCore + +variable {calls : CallRelation F} + +variable [Field F] [DecidableEq F] {world : Engine.World F} + +theorem letValue_iff : + EvalExpr world calls locals (.letValue pat value body) before result after ↔ + ∃ input middle bindings, EvalExpr world calls locals value before input middle ∧ + pat.bindings input = some bindings ∧ + EvalExpr world calls (bindings ++ locals) body middle result after := by + constructor + · intro h; cases h with + | letValue v m b => exact ⟨_, _, _, v, m, b⟩ + · rintro ⟨_, _, _, v, m, b⟩; exact .letValue v m b + +theorem bind_iff : + EvalExpr world calls locals (.letValue (.bind name) value body) before result after ↔ + ∃ input middle, EvalExpr world calls locals value before input middle ∧ + EvalExpr world calls ((name, input) :: locals) body middle result after := by + simp only [letValue_iff, Aiur.Pattern.bindings, Option.some.injEq] + constructor + · rintro ⟨v, h, _, ev, rfl, eb⟩; exact ⟨v, h, ev, eb⟩ + · rintro ⟨v, h, ev, eb⟩; exact ⟨v, h, _, ev, rfl, eb⟩ + +theorem load_iff : + EvalExpr world calls locals (.load expr) before result after ↔ + ∃ input, EvalExpr world calls locals expr before input after ∧ loadValue after input = .ok result := by + constructor + · intro h; cases h with + | load ev loaded => exact ⟨_, ev, loaded⟩ + · rintro ⟨_, ev, loaded⟩; exact .load ev loaded + +theorem matchValue_iff : + EvalExpr world calls locals (.matchValue expr arms) before result after ↔ + ∃ input middle bindings body, EvalExpr world calls locals expr before input middle ∧ + Aiur.selectArm input arms = some (bindings, body) ∧ + EvalExpr world calls (bindings ++ locals) body middle result after := by + constructor + · intro h; cases h with + | matchValue v m b => exact ⟨_, _, _, _, v, m, b⟩ + · rintro ⟨_, _, _, _, v, m, b⟩; exact .matchValue v m b + +end Aiur.Generic.OpenCore diff --git a/Aiur/Aiur/Generic/EnvironmentFacts.lean b/Aiur/Aiur/Generic/EnvironmentFacts.lean new file mode 100644 index 000000000..bf4dcaee8 --- /dev/null +++ b/Aiur/Aiur/Generic/EnvironmentFacts.lean @@ -0,0 +1,106 @@ +import Aiur.Generic.PatternLowering +import Aiur.Generic.OpenCore + +namespace Aiur.Generic.Engine + +/-- An overapproximation of the names an expression may inspect is enough for +environment independence. Including bound names keeps this certificate simple. -/ +def EnvAgrees (names : List String) (left right : Environment F Nat) : Prop := + ∀ name ∈ names, left.find? (·.1 == name) = right.find? (·.1 == name) + +variable {F : Type} {names fewer : List String} {left right : Environment F Nat} + +theorem EnvAgrees.mono (h : EnvAgrees names left right) + (subset : ∀ n ∈ fewer, n ∈ names) : EnvAgrees fewer left right := + fun n hn => h n (subset n hn) + +theorem EnvAgrees.prepend (h : EnvAgrees names left right) (bindings : Environment F Nat) : + EnvAgrees names (bindings ++ left) (bindings ++ right) := by + intro n hn + simp only [List.find?_append, h n hn] + +theorem EnvAgrees.symm (h : EnvAgrees names left right) : EnvAgrees names right left := + fun n hn => (h n hn).symm + +private theorem selected_member [DecidableEq F] {arms : List (Aiur.Pattern F × Aiur.Expr F)} + (selected : Aiur.selectArm input arms = some (bindings, body)) : + ∃ pat, (pat, body) ∈ arms := by + induction arms with + | nil => simp [Aiur.selectArm] at selected + | cons arm arms ih => + rcases arm with ⟨pat, expr⟩ + cases h : pat.bindings input with + | none => + obtain ⟨p, hp⟩ := ih (by simpa [Aiur.selectArm, h] using selected) + exact ⟨p, by simp [hp]⟩ + | some bs => + have same : expr = body := by + have pair : bs = bindings ∧ expr = body := by + simpa only [Aiur.selectArm, h, Option.some.injEq, Prod.mk.injEq] using selected + exact pair.2 + subst expr + exact ⟨pat, by simp⟩ + +end Aiur.Generic.Engine + +namespace Aiur.Generic.OpenCore +open Engine +variable [Field F] [DecidableEq F] {world : Engine.World F} {calls : CallRelation F} + +/-- Compiler temporaries cannot affect an expression whose names they do not +shadow. Calls start in their own environments, and the heap is unchanged by +this change of local bindings. -/ +theorem EvalExpr.changeLocals (ev : EvalExpr world calls locals expr before value after) : + ∀ other, EnvAgrees (PatternLowering.exprNames expr) locals other → + EvalExpr world calls other expr before value after := by + induction ev using EvalExpr.rec + (motive_2 := fun ls es b vs h _ => ∀ other, + EnvAgrees (es.flatMap PatternLowering.exprNames) ls other → EvalArgs world calls other es b vs h) with + | literal => intro _ _; exact .literal + | var lookup => + intro other agree + exact .var (by rw [← agree _ (by simp [PatternLowering.exprNames])]; exact lookup) + | tuple _ ih => intro other agree; exact .tuple (ih other (by simpa only [PatternLowering.exprNames] using agree)) + | construct _ ih => intro other agree; exact .construct (ih other (by simpa only [PatternLowering.exprNames] using agree)) + | project _ projected ih => intro other agree; exact .project (ih other (by simpa only [PatternLowering.exprNames] using agree)) projected + | letValue _ matched _ ih1 ih2 => + intro other agree + apply EvalExpr.letValue (ih1 other (agree.mono ?_)) matched + · apply ih2 _ ((agree.mono ?_).prepend _) + intro n hn + simp [PatternLowering.exprNames, hn] + · intro n hn + simp [PatternLowering.exprNames, hn] + | store _ ih => intro other agree; exact .store (ih other (by simpa only [PatternLowering.exprNames] using agree)) + | load _ loaded ih => intro other agree; exact .load (ih other (by simpa only [PatternLowering.exprNames] using agree)) loaded + | hint _ typed ih => intro other agree; exact .hint (ih other (by simpa only [PatternLowering.exprNames] using agree)) typed + | neg _ op ih => intro other agree; exact .neg (ih other (by simpa only [PatternLowering.exprNames] using agree)) op + | assertEq _ _ op ih1 ih2 => + intro other agree + exact .assertEq (ih1 other (agree.mono (by intros; simp [PatternLowering.exprNames, *]))) + (ih2 other (agree.mono (by intros; simp [PatternLowering.exprNames, *]))) op + | binary _ _ op ih1 ih2 => + intro other agree + exact .binary (ih1 other (agree.mono (by intros; simp [PatternLowering.exprNames, *]))) + (ih2 other (agree.mono (by intros; simp [PatternLowering.exprNames, *]))) op + | call _ callee ih => intro other agree; exact .call (ih other (by simpa only [PatternLowering.exprNames] using agree)) callee + | matchValue _ selected _ ih1 ih2 => + intro other agree + apply EvalExpr.matchValue + (ih1 other (agree.mono (by intros; simp [PatternLowering.exprNames, *]))) selected + apply ih2 _ ((agree.mono ?_).prepend _) + intro n hn + obtain ⟨pat, member⟩ := selected_member selected + simp only [PatternLowering.exprNames, List.mem_append, List.mem_flatMap] + exact Or.inr ⟨(pat, _), member, by simp [hn]⟩ + | nil => exact .nil + | cons _ _ ih1 ih2 => + rename_i other agree + exact .cons (ih1 other (agree.mono (by intros; simp [*]))) + (ih2 other (agree.mono (by intros; simp [*]))) + +theorem evalExpr_env_iff (agree : EnvAgrees (PatternLowering.exprNames expr) locals other) : + EvalExpr world calls locals expr before value after ↔ EvalExpr world calls other expr before value after := + ⟨fun h => h.changeLocals other agree, fun h => h.changeLocals locals agree.symm⟩ + +end Aiur.Generic.OpenCore diff --git a/Aiur/Aiur/Generic/Equality.lean b/Aiur/Aiur/Generic/Equality.lean new file mode 100644 index 000000000..5fff0c4c0 --- /dev/null +++ b/Aiur/Aiur/Generic/Equality.lean @@ -0,0 +1,260 @@ +import Aiur.AST + +namespace Aiur.Generic + +mutual + def exprDecEq [DecidableEq α] (a b : Aiur.Expr α) : Decidable (a = b) := + match a, b with + | .literal x, .literal y => by + exact decidable_of_iff (x = y) (by simp only [Aiur.Expr.literal.injEq]) + | .var x, .var y => by + exact decidable_of_iff (x = y) (by simp only [Aiur.Expr.var.injEq]) + | .tuple xs, .tuple ys => by + letI := exprListDecEq xs ys + exact decidable_of_iff (xs = ys) (by simp only [Aiur.Expr.tuple.injEq]) + | .construct n c xs, .construct m d ys => by + letI := exprListDecEq xs ys + exact decidable_of_iff (n = m ∧ c = d ∧ xs = ys) (by simp only [Aiur.Expr.construct.injEq]) + | .project x i, .project y j => by + letI := exprDecEq x y + exact decidable_of_iff (x = y ∧ i = j) (by simp only [Aiur.Expr.project.injEq]) + | .letValue p x b, .letValue q y c => by + letI := exprDecEq x y + letI := exprDecEq b c + exact decidable_of_iff (p = q ∧ x = y ∧ b = c) (by simp only [Aiur.Expr.letValue.injEq]) + | .store x, .store y => by + letI := exprDecEq x y + exact decidable_of_iff (x = y) (by simp only [Aiur.Expr.store.injEq]) + | .load x, .load y => by + letI := exprDecEq x y + exact decidable_of_iff (x = y) (by simp only [Aiur.Expr.load.injEq]) + | .hint t x channel, .hint u y otherChannel => by + letI := exprDecEq x y + exact decidable_of_iff (t = u ∧ x = y ∧ channel = otherChannel) (by simp only [Aiur.Expr.hint.injEq]) + | .neg x, .neg y => by + letI := exprDecEq x y + exact decidable_of_iff (x = y) (by simp only [Aiur.Expr.neg.injEq]) + | .assertEq op x y, .assertEq oq z w => by + letI := exprDecEq x z + letI := exprDecEq y w + exact decidable_of_iff (op = oq ∧ x = z ∧ y = w) (by simp only [Aiur.Expr.assertEq.injEq]) | .binary op x y, .binary oq z w => by + letI := exprDecEq x z + letI := exprDecEq y w + exact decidable_of_iff (op = oq ∧ x = z ∧ y = w) (by simp only [Aiur.Expr.binary.injEq]) + | .call n xs, .call m ys => by + letI := exprListDecEq xs ys + exact decidable_of_iff (n = m ∧ xs = ys) (by simp only [Aiur.Expr.call.injEq]) + | .matchValue x arms, .matchValue y bs => by + letI := exprDecEq x y + letI := armListDecEq arms bs + exact decidable_of_iff (x = y ∧ arms = bs) (by simp only [Aiur.Expr.matchValue.injEq]) + | .literal _, .var _ => isFalse (by intro h; cases h) + | .literal _, .tuple _ => isFalse (by intro h; cases h) + | .literal _, .construct _ _ _ => isFalse (by intro h; cases h) + | .literal _, .project _ _ => isFalse (by intro h; cases h) + | .literal _, .letValue _ _ _ => isFalse (by intro h; cases h) + | .literal _, .store _ => isFalse (by intro h; cases h) + | .literal _, .load _ => isFalse (by intro h; cases h) + | .literal _, .hint _ _ _ => isFalse (by intro h; cases h) + | .literal _, .neg _ => isFalse (by intro h; cases h) + | .literal _, .binary _ _ _ => isFalse (by intro h; cases h) + | .literal _, .call _ _ => isFalse (by intro h; cases h) + | .literal _, .matchValue _ _ => isFalse (by intro h; cases h) + | .var _, .literal _ => isFalse (by intro h; cases h) + | .var _, .tuple _ => isFalse (by intro h; cases h) + | .var _, .construct _ _ _ => isFalse (by intro h; cases h) + | .var _, .project _ _ => isFalse (by intro h; cases h) + | .var _, .letValue _ _ _ => isFalse (by intro h; cases h) + | .var _, .store _ => isFalse (by intro h; cases h) + | .var _, .load _ => isFalse (by intro h; cases h) + | .var _, .hint _ _ _ => isFalse (by intro h; cases h) + | .var _, .neg _ => isFalse (by intro h; cases h) + | .var _, .binary _ _ _ => isFalse (by intro h; cases h) + | .var _, .call _ _ => isFalse (by intro h; cases h) + | .var _, .matchValue _ _ => isFalse (by intro h; cases h) + | .tuple _, .literal _ => isFalse (by intro h; cases h) + | .tuple _, .var _ => isFalse (by intro h; cases h) + | .tuple _, .construct _ _ _ => isFalse (by intro h; cases h) + | .tuple _, .project _ _ => isFalse (by intro h; cases h) + | .tuple _, .letValue _ _ _ => isFalse (by intro h; cases h) + | .tuple _, .store _ => isFalse (by intro h; cases h) + | .tuple _, .load _ => isFalse (by intro h; cases h) + | .tuple _, .hint _ _ _ => isFalse (by intro h; cases h) + | .tuple _, .neg _ => isFalse (by intro h; cases h) + | .tuple _, .binary _ _ _ => isFalse (by intro h; cases h) + | .tuple _, .call _ _ => isFalse (by intro h; cases h) + | .tuple _, .matchValue _ _ => isFalse (by intro h; cases h) + | .construct _ _ _, .literal _ => isFalse (by intro h; cases h) + | .construct _ _ _, .var _ => isFalse (by intro h; cases h) + | .construct _ _ _, .tuple _ => isFalse (by intro h; cases h) + | .construct _ _ _, .project _ _ => isFalse (by intro h; cases h) + | .construct _ _ _, .letValue _ _ _ => isFalse (by intro h; cases h) + | .construct _ _ _, .store _ => isFalse (by intro h; cases h) + | .construct _ _ _, .load _ => isFalse (by intro h; cases h) + | .construct _ _ _, .hint _ _ _ => isFalse (by intro h; cases h) + | .construct _ _ _, .neg _ => isFalse (by intro h; cases h) + | .construct _ _ _, .binary _ _ _ => isFalse (by intro h; cases h) + | .construct _ _ _, .call _ _ => isFalse (by intro h; cases h) + | .construct _ _ _, .matchValue _ _ => isFalse (by intro h; cases h) + | .project _ _, .literal _ => isFalse (by intro h; cases h) + | .project _ _, .var _ => isFalse (by intro h; cases h) + | .project _ _, .tuple _ => isFalse (by intro h; cases h) + | .project _ _, .construct _ _ _ => isFalse (by intro h; cases h) + | .project _ _, .letValue _ _ _ => isFalse (by intro h; cases h) + | .project _ _, .store _ => isFalse (by intro h; cases h) + | .project _ _, .load _ => isFalse (by intro h; cases h) + | .project _ _, .hint _ _ _ => isFalse (by intro h; cases h) + | .project _ _, .neg _ => isFalse (by intro h; cases h) + | .project _ _, .binary _ _ _ => isFalse (by intro h; cases h) + | .project _ _, .call _ _ => isFalse (by intro h; cases h) + | .project _ _, .matchValue _ _ => isFalse (by intro h; cases h) + | .letValue _ _ _, .literal _ => isFalse (by intro h; cases h) + | .letValue _ _ _, .var _ => isFalse (by intro h; cases h) + | .letValue _ _ _, .tuple _ => isFalse (by intro h; cases h) + | .letValue _ _ _, .construct _ _ _ => isFalse (by intro h; cases h) + | .letValue _ _ _, .project _ _ => isFalse (by intro h; cases h) + | .letValue _ _ _, .store _ => isFalse (by intro h; cases h) + | .letValue _ _ _, .load _ => isFalse (by intro h; cases h) + | .letValue _ _ _, .hint _ _ _ => isFalse (by intro h; cases h) + | .letValue _ _ _, .neg _ => isFalse (by intro h; cases h) + | .letValue _ _ _, .binary _ _ _ => isFalse (by intro h; cases h) + | .letValue _ _ _, .call _ _ => isFalse (by intro h; cases h) + | .letValue _ _ _, .matchValue _ _ => isFalse (by intro h; cases h) + | .store _, .literal _ => isFalse (by intro h; cases h) + | .store _, .var _ => isFalse (by intro h; cases h) + | .store _, .tuple _ => isFalse (by intro h; cases h) + | .store _, .construct _ _ _ => isFalse (by intro h; cases h) + | .store _, .project _ _ => isFalse (by intro h; cases h) + | .store _, .letValue _ _ _ => isFalse (by intro h; cases h) + | .store _, .load _ => isFalse (by intro h; cases h) + | .store _, .hint _ _ _ => isFalse (by intro h; cases h) + | .store _, .neg _ => isFalse (by intro h; cases h) + | .store _, .binary _ _ _ => isFalse (by intro h; cases h) + | .store _, .call _ _ => isFalse (by intro h; cases h) + | .store _, .matchValue _ _ => isFalse (by intro h; cases h) + | .load _, .literal _ => isFalse (by intro h; cases h) + | .load _, .var _ => isFalse (by intro h; cases h) + | .load _, .tuple _ => isFalse (by intro h; cases h) + | .load _, .construct _ _ _ => isFalse (by intro h; cases h) + | .load _, .project _ _ => isFalse (by intro h; cases h) + | .load _, .letValue _ _ _ => isFalse (by intro h; cases h) + | .load _, .store _ => isFalse (by intro h; cases h) + | .load _, .hint _ _ _ => isFalse (by intro h; cases h) + | .load _, .neg _ => isFalse (by intro h; cases h) + | .load _, .binary _ _ _ => isFalse (by intro h; cases h) + | .load _, .call _ _ => isFalse (by intro h; cases h) + | .load _, .matchValue _ _ => isFalse (by intro h; cases h) + | .hint _ _ _, .literal _ => isFalse (by intro h; cases h) + | .hint _ _ _, .var _ => isFalse (by intro h; cases h) + | .hint _ _ _, .tuple _ => isFalse (by intro h; cases h) + | .hint _ _ _, .construct _ _ _ => isFalse (by intro h; cases h) + | .hint _ _ _, .project _ _ => isFalse (by intro h; cases h) + | .hint _ _ _, .letValue _ _ _ => isFalse (by intro h; cases h) + | .hint _ _ _, .store _ => isFalse (by intro h; cases h) + | .hint _ _ _, .load _ => isFalse (by intro h; cases h) + | .hint _ _ _, .neg _ => isFalse (by intro h; cases h) + | .hint _ _ _, .binary _ _ _ => isFalse (by intro h; cases h) + | .hint _ _ _, .call _ _ => isFalse (by intro h; cases h) + | .hint _ _ _, .matchValue _ _ => isFalse (by intro h; cases h) + | .neg _, .literal _ => isFalse (by intro h; cases h) + | .neg _, .var _ => isFalse (by intro h; cases h) + | .neg _, .tuple _ => isFalse (by intro h; cases h) + | .neg _, .construct _ _ _ => isFalse (by intro h; cases h) + | .neg _, .project _ _ => isFalse (by intro h; cases h) + | .neg _, .letValue _ _ _ => isFalse (by intro h; cases h) + | .neg _, .store _ => isFalse (by intro h; cases h) + | .neg _, .load _ => isFalse (by intro h; cases h) + | .neg _, .hint _ _ _ => isFalse (by intro h; cases h) + | .neg _, .binary _ _ _ => isFalse (by intro h; cases h) + | .neg _, .call _ _ => isFalse (by intro h; cases h) + | .neg _, .matchValue _ _ => isFalse (by intro h; cases h) + | .binary _ _ _, .literal _ => isFalse (by intro h; cases h) + | .binary _ _ _, .var _ => isFalse (by intro h; cases h) + | .binary _ _ _, .tuple _ => isFalse (by intro h; cases h) + | .binary _ _ _, .construct _ _ _ => isFalse (by intro h; cases h) + | .binary _ _ _, .project _ _ => isFalse (by intro h; cases h) + | .binary _ _ _, .letValue _ _ _ => isFalse (by intro h; cases h) + | .binary _ _ _, .store _ => isFalse (by intro h; cases h) + | .binary _ _ _, .load _ => isFalse (by intro h; cases h) + | .binary _ _ _, .hint _ _ _ => isFalse (by intro h; cases h) + | .binary _ _ _, .neg _ => isFalse (by intro h; cases h) + | .binary _ _ _, .call _ _ => isFalse (by intro h; cases h) + | .binary _ _ _, .matchValue _ _ => isFalse (by intro h; cases h) + | .call _ _, .literal _ => isFalse (by intro h; cases h) + | .call _ _, .var _ => isFalse (by intro h; cases h) + | .call _ _, .tuple _ => isFalse (by intro h; cases h) + | .call _ _, .construct _ _ _ => isFalse (by intro h; cases h) + | .call _ _, .project _ _ => isFalse (by intro h; cases h) + | .call _ _, .letValue _ _ _ => isFalse (by intro h; cases h) + | .call _ _, .store _ => isFalse (by intro h; cases h) + | .call _ _, .load _ => isFalse (by intro h; cases h) + | .call _ _, .hint _ _ _ => isFalse (by intro h; cases h) + | .call _ _, .neg _ => isFalse (by intro h; cases h) + | .call _ _, .binary _ _ _ => isFalse (by intro h; cases h) + | .call _ _, .matchValue _ _ => isFalse (by intro h; cases h) + | .matchValue _ _, .literal _ => isFalse (by intro h; cases h) + | .matchValue _ _, .var _ => isFalse (by intro h; cases h) + | .matchValue _ _, .tuple _ => isFalse (by intro h; cases h) + | .matchValue _ _, .construct _ _ _ => isFalse (by intro h; cases h) + | .matchValue _ _, .project _ _ => isFalse (by intro h; cases h) + | .matchValue _ _, .letValue _ _ _ => isFalse (by intro h; cases h) + | .matchValue _ _, .store _ => isFalse (by intro h; cases h) + | .matchValue _ _, .load _ => isFalse (by intro h; cases h) + | .matchValue _ _, .hint _ _ _ => isFalse (by intro h; cases h) + | .matchValue _ _, .neg _ => isFalse (by intro h; cases h) + | .matchValue _ _, .binary _ _ _ => isFalse (by intro h; cases h) + | .matchValue _ _, .call _ _ => isFalse (by intro h; cases h) + | .assertEq _ _ _, .literal _ => isFalse (by intro h; cases h) + | .literal _, .assertEq _ _ _ => isFalse (by intro h; cases h) + | .assertEq _ _ _, .var _ => isFalse (by intro h; cases h) + | .var _, .assertEq _ _ _ => isFalse (by intro h; cases h) + | .assertEq _ _ _, .tuple _ => isFalse (by intro h; cases h) + | .tuple _, .assertEq _ _ _ => isFalse (by intro h; cases h) + | .assertEq _ _ _, .construct _ _ _ => isFalse (by intro h; cases h) + | .construct _ _ _, .assertEq _ _ _ => isFalse (by intro h; cases h) + | .assertEq _ _ _, .project _ _ => isFalse (by intro h; cases h) + | .project _ _, .assertEq _ _ _ => isFalse (by intro h; cases h) + | .assertEq _ _ _, .letValue _ _ _ => isFalse (by intro h; cases h) + | .letValue _ _ _, .assertEq _ _ _ => isFalse (by intro h; cases h) + | .assertEq _ _ _, .store _ => isFalse (by intro h; cases h) + | .store _, .assertEq _ _ _ => isFalse (by intro h; cases h) + | .assertEq _ _ _, .load _ => isFalse (by intro h; cases h) + | .load _, .assertEq _ _ _ => isFalse (by intro h; cases h) + | .assertEq _ _ _, .hint _ _ _ => isFalse (by intro h; cases h) + | .hint _ _ _, .assertEq _ _ _ => isFalse (by intro h; cases h) + | .assertEq _ _ _, .neg _ => isFalse (by intro h; cases h) + | .neg _, .assertEq _ _ _ => isFalse (by intro h; cases h) + | .assertEq _ _ _, .binary _ _ _ => isFalse (by intro h; cases h) + | .binary _ _ _, .assertEq _ _ _ => isFalse (by intro h; cases h) + | .assertEq _ _ _, .call _ _ => isFalse (by intro h; cases h) + | .call _ _, .assertEq _ _ _ => isFalse (by intro h; cases h) + | .assertEq _ _ _, .matchValue _ _ => isFalse (by intro h; cases h) + | .matchValue _ _, .assertEq _ _ _ => isFalse (by intro h; cases h) + termination_by sizeOf a + + def exprListDecEq [DecidableEq α] (a b : List (Aiur.Expr α)) : Decidable (a = b) := + match a, b with + | [], [] => isTrue rfl + | x :: xs, y :: ys => by + letI := exprDecEq x y + letI := exprListDecEq xs ys + exact decidable_of_iff (x = y ∧ xs = ys) (by simp only [List.cons.injEq]) + | [], _ :: _ | _ :: _, [] => isFalse (by intro h; cases h) + termination_by sizeOf a + + def armListDecEq [DecidableEq α] (a b : List (Aiur.Pattern α × Aiur.Expr α)) : Decidable (a = b) := + match a, b with + | [], [] => isTrue rfl + | (p, x) :: xs, (q, y) :: ys => by + letI := exprDecEq x y + letI := armListDecEq xs ys + exact decidable_of_iff (p = q ∧ x = y ∧ xs = ys) (by simp [and_assoc]) + | [], _ :: _ | _ :: _, [] => isFalse (by intro h; cases h) + termination_by sizeOf a +end + +instance [DecidableEq α] : DecidableEq (Aiur.Expr α) := exprDecEq + +deriving instance DecidableEq for Aiur.Function + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/Frontend.lean b/Aiur/Aiur/Generic/Frontend.lean new file mode 100644 index 000000000..4072b8075 --- /dev/null +++ b/Aiur/Aiur/Generic/Frontend.lean @@ -0,0 +1,443 @@ +import Aiur.Frontend +import Aiur.Generic.Runtime + +set_option backward.do.legacy false + +namespace Aiur.Generic.Frontend +open Lean Elab Term +open Aiur.Frontend + +declare_syntax_cat aiur_body (behavior := symbol) +syntax (name := bodyTail) aiur_expr : aiur_body +syntax (name := bodyEnd) aiur_expr ";" : aiur_body +syntax (name := bodySequence) aiur_expr ";" aiur_body : aiur_body +syntax (name := bodyLetEnd) "let" aiur_pattern "=" aiur_expr ";" : aiur_body +syntax (name := bodyLet) "let" aiur_pattern "=" aiur_expr ";" aiur_body : aiur_body +syntax (name := bodyLetTypedEnd) "let" aiur_pattern ":" aiur_type "=" aiur_expr ";" : aiur_body +syntax (name := bodyLetTyped) "let" aiur_pattern ":" aiur_type "=" aiur_expr ";" aiur_body : aiur_body +syntax (name := ascribeExpr) "(" aiur_expr ":" aiur_type ")" : aiur_expr +syntax (name := assertExpr) "assert_eq!" "(" aiur_expr "," aiur_expr (atomic("," str))? (",")? ")" : aiur_expr +syntax (name := constrainExpr) "constrain_eq!" "(" aiur_expr "," aiur_expr (atomic("," str))? (",")? ")" : aiur_expr +syntax (name := debugExpr) "debug!" "(" str ("," sepBy(aiur_expr, ",", ",", allowTrailingSep))? ")" : aiur_expr +syntax (name := blockStatements) "{" (aiur_body)? "}" : aiur_expr +syntax (name := functionStatements) "fn" ident + "(" sepBy(aiur_param, ",", ",", allowTrailingSep) ")" "->" aiur_type "{" (aiur_body)? "}" : aiur_function + +syntax (name := appliedType) ident "<" sepBy1(aiur_type, ",", ",", allowTrailingSep) ">" : aiur_type +syntax (name := genericFunction) "fn" ident "<" sepBy1(ident, ",", ",", allowTrailingSep) ">" + "(" sepBy(aiur_param, ",", ",", allowTrailingSep) ")" "->" aiur_type "{" (aiur_body)? "}" : aiur_function +syntax (name := inlineFunction) "inline" aiur_function : aiur_function +syntax (name := genericEnum) "enum" ident "<" sepBy1(ident, ",", ",", allowTrailingSep) ">" + "{" sepBy(aiur_constructor, ",", ",", allowTrailingSep) "}" : aiur_enum +syntax (name := genericCall) ident "::<" sepBy1(aiur_type, ",", ",", allowTrailingSep) ">" + "(" sepBy(aiur_expr, ",", ",", allowTrailingSep) ")" : aiur_expr +syntax (name := genericConstructor) ident "::<" sepBy1(aiur_type, ",", ",", allowTrailingSep) ">" "::" ident : aiur_expr +syntax (name := genericConstructorArgs) ident "::<" sepBy1(aiur_type, ",", ",", allowTrailingSep) ">" "::" ident + "(" sepBy(aiur_expr, ",", ",", allowTrailingSep) ")" : aiur_expr +declare_syntax_cat aiur_alias (behavior := symbol) +syntax (name := aliasDefinition) &"type" ident "=" aiur_type ";" : aiur_alias +syntax (name := genericAlias) &"type" ident "<" sepBy1(ident, ",", ",", allowTrailingSep) ">" + "=" aiur_type ";" : aiur_alias +syntax (name := aliasDecl) aiur_alias : aiur_decl +syntax:10 (name := orPattern) aiur_pattern:10 "|" aiur_pattern:11 : aiur_pattern +syntax:75 (name := loadPattern) "&" aiur_pattern:75 : aiur_pattern +syntax (name := globalPattern) "::" ident : aiur_pattern +syntax (name := globalExpr) "::" ident : aiur_expr +syntax (name := genericConstructorPattern) ident "::<" sepBy1(aiur_type, ",", ",", allowTrailingSep) ">" + "::" ident : aiur_pattern +syntax (name := genericConstructorPatternArgs) ident "::<" sepBy1(aiur_type, ",", ",", allowTrailingSep) ">" + "::" ident "(" sepBy(aiur_pattern, ",", ",", allowTrailingSep) ")" : aiur_pattern +declare_syntax_cat aiur_const (behavior := symbol) +syntax (name := constDefinition) &"const" ident "=" aiur_expr ";" : aiur_const +syntax (name := constDecl) aiur_const : aiur_decl +syntax (name := arrayType) "[" aiur_type ";" num "]" : aiur_type +syntax (name := arrayExpr) "[" sepBy(aiur_expr, ",", ",", allowTrailingSep) "]" : aiur_expr +syntax (name := repeatExpr) "[" aiur_expr ";" num "]" : aiur_expr +syntax (name := arrayPattern) "[" sepBy(aiur_pattern, ",", ",", allowTrailingSep) "]" : aiur_pattern +syntax (name := repeatPattern) "[" aiur_pattern ";" num "]" : aiur_pattern +syntax:80 (name := indexExpr) aiur_expr:80 "[" num "]" : aiur_expr +syntax:80 (name := sliceExpr) aiur_expr:80 "[" num ".." num "]" : aiur_expr +syntax:80 (name := sliceFromExpr) aiur_expr:80 "[" num ".." "]" : aiur_expr +syntax:80 (name := sliceToExpr) aiur_expr:80 "[" ".." num "]" : aiur_expr +syntax:80 (name := sliceAllExpr) aiur_expr:80 "[" ".." "]" : aiur_expr +syntax:80 (name := sliceInclusiveExpr) aiur_expr:80 "[" num "..=" num "]" : aiur_expr +syntax:80 (name := sliceToInclusiveExpr) aiur_expr:80 "[" "..=" num "]" : aiur_expr +syntax (name := namedBlock) "@" ident ":" "{" (aiur_body)? "}" : aiur_expr +syntax:10 (name := breakExpr) "break" "@" ident aiur_expr:11 : aiur_expr +syntax:10 (name := breakUnit) "break" "@" ident : aiur_expr +syntax:10 (name := returnExpr) "return" aiur_expr:11 : aiur_expr +syntax:10 (name := returnUnit) "return" : aiur_expr + +declare_syntax_cat aiur_struct_field (behavior := symbol) +declare_syntax_cat aiur_struct (behavior := symbol) +declare_syntax_cat aiur_record_value (behavior := symbol) +declare_syntax_cat aiur_record_pattern_field (behavior := symbol) +declare_syntax_cat aiur_record_patterns (behavior := symbol) +syntax (name := structField) ident ":" aiur_type : aiur_struct_field +syntax (name := structDefinition) &"struct" ident "{" sepBy(aiur_struct_field, ",", ",", allowTrailingSep) "}" : aiur_struct +syntax (name := genericStruct) &"struct" ident "<" sepBy1(ident, ",", ",", allowTrailingSep) ">" + "{" sepBy(aiur_struct_field, ",", ",", allowTrailingSep) "}" : aiur_struct +syntax (name := structDecl) aiur_struct : aiur_decl +syntax (name := recordValueField) ident ":" aiur_expr : aiur_record_value +syntax (name := recordValueShorthand) ident : aiur_record_value +syntax (name := recordExpr) atomic(ident "{" sepBy(aiur_record_value, ",", ",", allowTrailingSep) "}") : aiur_expr +syntax (name := genericRecordExpr) atomic(ident "::<" sepBy1(aiur_type, ",", ",", allowTrailingSep) ">" + "{" sepBy(aiur_record_value, ",", ",", allowTrailingSep) "}") : aiur_expr +syntax:80 (name := memberExpr) aiur_expr:80 "." ident : aiur_expr +syntax (name := recordPatternField) ident ":" aiur_pattern : aiur_record_pattern_field +syntax (name := recordPatternShorthand) ident : aiur_record_pattern_field +syntax (name := recordPatternFields) sepBy(aiur_record_pattern_field, ",", ",", allowTrailingSep) (".." (",")?)? : aiur_record_patterns +syntax (name := recordPattern) ident "{" aiur_record_patterns "}" : aiur_pattern +syntax (name := genericRecordPattern) ident "::<" sepBy1(aiur_type, ",", ",", allowTrailingSep) ">" + "{" aiur_record_patterns "}" : aiur_pattern + +declare_syntax_cat aiur_update_step (behavior := symbol) +declare_syntax_cat aiur_update_entry (behavior := symbol) +syntax (name := updateMember) "." ident : aiur_update_step +syntax (name := updateProject) "." num : aiur_update_step +syntax (name := updateIndex) "[" num "]" : aiur_update_step +syntax (name := updateEntry) aiur_update_step+ "=" aiur_expr : aiur_update_entry +syntax:15 (name := updateExpr) aiur_expr:15 &"with" "{" + sepBy(aiur_update_entry, ",", ",", allowTrailingSep) "}" : aiur_expr + +def readName (s : Syntax) : Except String String := + match s.getId with + | .str .anonymous n => .ok n + | _ => .error "expected a simple identifier" + +private def readLength (s : Syntax) : Except String Nat := do + let some n := s.isNatLit? | throw "array lengths must be natural-number literals" + checkArrayLength n + return n + +/-- Later frontends can extend shared syntax categories. Flat quotations keep +preferring their native alternatives when those extensions introduce ambiguity. -/ +def nativeChoice (s : Syntax) : Syntax := + if s.getKind != `choice then s else + (s.getArgs.find? fun child => + (`Aiur.Generic.Frontend).isPrefixOf child.getKind || + (`Aiur.Frontend).isPrefixOf child.getKind).getD s[0] + +partial def type (params : List String) (s : Syntax) : Except String Ty := do + if s.getKind == `choice then type params (nativeChoice s) + else if s.getKind == ``pointerType then return .ptr (← type params s[1]) + else if s.getKind == ``arrayType then return .array (← type params s[1]) (← readLength s[3]) + else if s.getKind == ``namedType then + let n ← readName s[0] + return if n == "Field" then .field else if params.contains n then .param n else .named n [] + else if s.getKind == ``appliedType then + let n ← readName s[0] + if params.contains n then throw s!"type parameter '{n}' does not take arguments" + return .named n (← s[2].getSepArgs.toList.mapM (type params)) + else if s.getKind == ``unitType then return .tuple [] + else if s.getKind == ``typeParens then type params s[1] + else if s.getKind == ``tupleType then + return .tuple ((← type params s[1]) :: (← s[3].getSepArgs.toList.mapM (type params))) + else throw "expected an Aiur type" + +partial def pattern (params : List String) (s : Syntax) : Except String (Pattern Nat) := do + if s.getKind == `choice then pattern params (nativeChoice s) + else if s.getKind == ``recordPattern || s.getKind == ``genericRecordPattern then + let generic := s.getKind == ``genericRecordPattern + let args ← if generic then s[2].getSepArgs.toList.mapM (type params) else pure [] + let fields := s[if generic then 5 else 2] + let rest := !fields[1].getArgs.isEmpty + let entries := fields[0].getSepArgs.toList + if rest && !entries.isEmpty && fields[0].getArgs.size % 2 != 0 then + throw "expected a comma before '..' in a struct pattern" + let named ← entries.mapM fun entry => do + let name ← readName entry[0] + let pat ← if entry.getKind == ``recordPatternShorthand then pure (.bind name) else pattern params entry[2] + return (name, pat) + return .record { type := .named (← readName s[0]) args, fields := named.map Prod.fst, rest } (named.map Prod.snd) + else if s.getKind == ``orPattern then + let left ← pattern params s[0] + return .orElse left (← pattern params s[2]) ⟨left.bindingNames, []⟩ + else if s.getKind == ``loadPattern then return .load (← pattern params s[1]) + else if s.getKind == ``globalPattern then return .global (← readName s[1]) + else if s.getKind == ``arrayPattern then return .array (← s[1].getSepArgs.toList.mapM (pattern params)) + else if s.getKind == ``repeatPattern then return .repeat (← pattern params s[1]) (← readLength s[3]) + else if s.getKind == ``literalPattern then return .literal (s[0].isNatLit?.getD 0) + else if s.getKind == ``wildcardPattern then return .wildcard + else if s.getKind == ``bindPattern then return .bind (← readName s[0]) + else if s.getKind == ``constructorPattern then return .construct (.named (← readName s[0]) []) (← readName s[2]) [] + else if s.getKind == ``constructorPatternArgs then + return .construct (.named (← readName s[0]) []) (← readName s[2]) (← s[4].getSepArgs.toList.mapM (pattern params)) + else if s.getKind == ``genericConstructorPattern || s.getKind == ``genericConstructorPatternArgs then + let ts ← s[2].getSepArgs.toList.mapM (type params) + let ps ← if s.getKind == ``genericConstructorPatternArgs then + s[7].getSepArgs.toList.mapM (pattern params) else pure [] + return .construct (.named (← readName s[0]) ts) (← readName s[5]) ps + else if s.getKind == ``unitPattern then return .tuple [] + else if s.getKind == ``patternParens then pattern params s[1] + else if s.getKind == ``tuplePattern then return .tuple ((← pattern params s[1]) :: (← s[3].getSepArgs.toList.mapM (pattern params))) + else throw "expected an Aiur pattern" + +/-- A terminal statement that can only exit has no implicit unit result. +Blocks are deliberately opaque here: their own breaks can complete normally. -/ +private def exitsOnly : Expr α → Bool + | .control (.exit _) _ => true + | .letValue _ value body => exitsOnly value || exitsOnly body + | .matchValue value arms => exitsOnly value || (!arms.isEmpty && (arms.map fun arm => exitsOnly arm.2).all id) + | _ => false +termination_by expr => sizeOf expr +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +partial def expr (params : List String) (s : Syntax) : Except String (Expr Nat) := do + let k := s.getKind + if k == `choice then + -- A let followed by a trailing statement has both an expression parse + -- and a statement parse. Preserve the lexical let scope in the latter. + -- Prefer the binding before a sequence whose first expression might itself + -- be a shorter let. Otherwise `let x = ...; check(x); x` loses x's scope. + let selected := (s.getArgs.find? fun child => + child.getKind == ``bodyLet || child.getKind == ``bodyLetTyped).orElse fun _ => + s.getArgs.find? (·.getKind == ``bodySequence) + expr params (selected.getD (nativeChoice s)) + else if k == ``bodyTail then expr params s[0] + else if k == ``bodyEnd then + let value ← expr params s[0] + return if exitsOnly value then value else .letValue .wildcard value (.tuple []) + else if k == ``bodySequence then return .letValue .wildcard (← expr params s[0]) (← expr params s[2]) + else if k == ``bodyLetEnd then return .letValue (← pattern params s[1]) (← expr params s[3]) (.tuple []) + else if k == ``bodyLet then return .letValue (← pattern params s[1]) (← expr params s[3]) (← expr params s[5]) + else if k == ``bodyLetTyped || k == ``bodyLetTypedEnd then + let body ← if k == ``bodyLetTyped then expr params s[7] else pure (.tuple []) + return .letValue (← pattern params s[1]) + (.builtin (.ascribe (← type params s[3])) [← expr params s[5]]) body + else if k == ``ascribeExpr then + return .builtin (.ascribe (← type params s[3])) [← expr params s[1]] + else if k == ``assertExpr || k == ``constrainExpr then + let message := if s[5].getArgs.isEmpty then none else s[5][1].isStrLit? + return .builtin (.assertEq ⟨message, k == ``assertExpr⟩) [← expr params s[2], ← expr params s[4]] + else if k == ``debugExpr then + let values ← if s[3].getArgs.isEmpty then pure [] else s[3][1].getSepArgs.toList.mapM (expr params) + return .builtin (.debug (s[2].isStrLit?.getD "")) values + else if k == ``blockStatements then + if s[1].getArgs.isEmpty then return .tuple [] else expr params s[1][0] + else if k == ``namedBlock then + return .control (.block (← readName s[1])) + (← if s[4].getArgs.isEmpty then pure (.tuple []) else expr params s[4][0]) + else if k == ``breakExpr then return .control (.exit (.block (← readName s[2]))) (← expr params s[3]) + else if k == ``breakUnit then return .control (.exit (.block (← readName s[2]))) (.tuple []) + else if k == ``returnExpr then return .control (.exit .function) (← expr params s[1]) + else if k == ``returnUnit then return .control (.exit .function) (.tuple []) + else if k == ``literal then return .literal (s[0].isNatLit?.getD 0) + else if k == ``variableExpr then return .var (← readName s[0]) + else if k == ``globalExpr then return .global (← readName s[1]) + else if k == ``arrayExpr then return .array (← s[1].getSepArgs.toList.mapM (expr params)) + else if k == ``repeatExpr then return .repeat (← expr params s[1]) (← readLength s[3]) + else if k == ``indexExpr then return .index (← expr params s[0]) (s[2].isNatLit?.getD 0) + else if k == ``sliceExpr || k == ``sliceInclusiveExpr then + let stop := s[4].isNatLit?.getD 0 + return .slice (← expr params s[0]) (s[2].isNatLit?.getD 0) + (some (if k == ``sliceInclusiveExpr then stop + 1 else stop)) + else if k == ``sliceFromExpr then return .slice (← expr params s[0]) (s[2].isNatLit?.getD 0) none + else if k == ``sliceToExpr || k == ``sliceToInclusiveExpr then + let stop := s[3].isNatLit?.getD 0 + return .slice (← expr params s[0]) 0 (some (if k == ``sliceToInclusiveExpr then stop + 1 else stop)) + else if k == ``sliceAllExpr then return .slice (← expr params s[0]) 0 none + else if k == ``unitExpr then return .tuple [] + else if k == ``tupleExpr then return .tuple ((← expr params s[1]) :: (← s[3].getSepArgs.toList.mapM (expr params))) + else if k == ``constructorExpr || k == ``constructorCall then + let xs ← if k == ``constructorCall then s[4].getSepArgs.toList.mapM (expr params) else pure [] + return .construct (← readName s[0]) none (← readName s[2]) xs + else if k == ``genericConstructor || k == ``genericConstructorArgs then + let xs ← if k == ``genericConstructorArgs then s[7].getSepArgs.toList.mapM (expr params) else pure [] + return .construct (← readName s[0]) (some (← s[2].getSepArgs.toList.mapM (type params))) (← readName s[5]) xs + else if k == ``call then return .call (← readName s[0]) none (← s[2].getSepArgs.toList.mapM (expr params)) + else if k == ``channelHintExpr then + if (← readName s[0]) != "hint" then throw "only hint supports a channel" + return .hint (← type params s[2]) (← expr params s[7]) (s[5].isStrLit?.getD "") + else if k == ``genericCall || k == ``hintExpr then + let n ← readName s[0] + let ts ← if k == ``hintExpr then List.singleton <$> type params s[2] else s[2].getSepArgs.toList.mapM (type params) + let xs ← if k == ``hintExpr then List.singleton <$> expr params s[5] else s[5].getSepArgs.toList.mapM (expr params) + if n == "hint" then + let [t] := ts | throw "hint takes one result type" + let [x] := xs | throw "hint takes one key" + return .hint t x + return .call n (some ts) xs + else if k == ``recordExpr || k == ``genericRecordExpr then + let generic := k == ``genericRecordExpr + let args ← if generic then s[2].getSepArgs.toList.mapM (type params) else pure [] + let named ← s[if generic then 5 else 2].getSepArgs.toList.mapM fun entry => do + let name ← readName entry[0] + let value ← if entry.getKind == ``recordValueShorthand then pure (.var name) else expr params entry[2] + return (name, value) + return .record { type := .named (← readName s[0]) args, fields := named.map Prod.fst } (named.map Prod.snd) + else if k == ``updateExpr then + let entries ← s[3].getSepArgs.toList.mapM fun entry => do + let path ← entry[0].getArgs.toList.mapM fun step => do + if step.getKind == ``updateMember then return UpdateStep.member { name := ← readName step[1] } + else if step.getKind == ``updateProject then return UpdateStep.project (step[1].isNatLit?.getD 0) + else if step.getKind == ``updateIndex then return UpdateStep.index (step[1].isNatLit?.getD 0) + else throw "expected a field or static index in an update path" + return (path, ← expr params entry[2]) + return .update (entries.map Prod.fst) ((← expr params s[0]) :: entries.map Prod.snd) + else if k == ``memberExpr then return .member (← expr params s[0]) { name := ← readName s[2] } + else if k == ``project then return .project (← expr params s[0]) (s[2].isNatLit?.getD 0) + else if k == ``letValue then return .letValue (← pattern params s[1]) (← expr params s[3]) (← expr params s[5]) + else if k == ``parens || k == ``block then expr params s[1] + else if k == ``store then return .store (← expr params s[1]) + else if k == ``load then return .load (← expr params s[1]) + else if k == ``neg then return .neg (← expr params s[1]) + else if k == ``add || k == ``sub || k == ``mul || k == ``div then + let op := if k == ``add then BinOp.add else if k == ``sub then .sub else if k == ``mul then .mul else .div + return .binary op (← expr params s[0]) (← expr params s[2]) + else if k == ``matchValue then + return .matchValue (← expr params s[1]) (← s[3].getSepArgs.toList.mapM fun arm => return (← pattern params arm[0], ← expr params arm[2])) + else throw s!"unsupported expression: {k}" + +def lowerEnum (s : Syntax) : Except String EnumDecl := do + let generic := s.getKind == ``genericEnum + let ps ← if generic then s[3].getSepArgs.toList.mapM readName else pure [] + let cs := if generic then s[6] else s[3] + return { + name := ← readName s[1], typeParams := ps + constructors := ← cs.getSepArgs.toList.mapM fun c => do + let fields ← if c.getKind == ``payloadConstructor then c[2].getSepArgs.toList.mapM (type ps) else pure [] + return { name := ← readName c[0], fields } + } + +def lowerStruct (s : Syntax) : Except String StructDecl := do + let generic := s.getKind == ``genericStruct + let params ← if generic then s[3].getSepArgs.toList.mapM readName else pure [] + let fields ← s[if generic then 6 else 3].getSepArgs.toList.mapM fun field => do + return (← readName field[0], ← type params field[2]) + return { name := ← readName s[1], typeParams := params, fields } + +def lowerAlias (s : Syntax) : Except String AliasDecl := do + let generic := s.getKind == ``genericAlias + let ps ← if generic then s[3].getSepArgs.toList.mapM readName else pure [] + return { + name := ← readName s[1], typeParams := ps + target := ← type ps s[if generic then 6 else 3] + } + +partial def lowerFunction (enums : List EnumDecl) (aliases : List AliasDecl) + (consts : List (ConstDecl Nat)) (s : Syntax) (checkParameters : Bool := true) : Except String (Function Nat) := do + let s := if s.getKind == `choice then s[0] else s + if s.getKind == ``inlineFunction then + let definition ← lowerFunction enums aliases consts s[1] checkParameters + if definition.isInline then throw "repeated inline modifier" + return {definition with isInline := true} + let generic := s.getKind == ``genericFunction + let ps ← if generic then s[3].getSepArgs.toList.mapM readName else pure [] + let offset := if generic then 3 else 0 + let mut destructuring := [] + let mut inputs := [] + let mut boundNames := [] + for (param, i) in s[3 + offset].getSepArgs.toList.zipIdx do + let pat ← pattern ps param[0] + boundNames := boundNames ++ pat.bindingNames + if checkParameters then + let inspected ← Consts.expandPattern consts pat + if !(← Aliases.expandPattern aliases inspected).irrefutable enums then throw "parameter patterns must be irrefutable" + let t ← type ps param[2] + match pat with + | .bind n => inputs := inputs ++ [(n, t)] + | _ => + let name := s!"$arg{i}" + inputs := inputs ++ [(name, t)] + destructuring := destructuring ++ [(pat, name)] + if let some n := findDuplicate boundNames [] then throw s!"duplicate parameter binding '{n}'" + let body ← if generic || s.getKind == ``functionStatements then + if s[8 + offset].getArgs.isEmpty then pure (.tuple []) else expr ps s[8 + offset][0] + else expr ps s[8 + offset] + return { + name := ← readName s[1], typeParams := ps, params := inputs + result := ← type ps s[6 + offset] + body := destructuring.foldr (fun (pat, n) b => .letValue pat (.var n) b) body + } + + +/-- Strings are diagnostic metadata: comment masking, label rewriting and +operator spacing must never change their contents. -/ +private inductive LexMode where + | code + | line + | comment (depth : Nat) + | string (escaped : Bool) + +-- Accumulate in reverse so source length does not consume the interpreter stack. +private def prepareChars : List Char → LexMode → List Char → Except String (List Char) + | [], .comment _, _ => .error "unterminated block comment" + | [], .string _, _ => .error "unterminated diagnostic string" + | [], _, acc => .ok acc.reverse + | c :: rest, .string escaped, acc => + let mode := if escaped then LexMode.string false + else if c == '\\' then .string true + else if c == '"' then .code else .string false + prepareChars rest mode (c :: acc) + | c :: rest, .line, acc => + if c == '\n' then prepareChars rest .code (c :: acc) + else prepareChars rest .line (' ' :: acc) + | '/' :: '*' :: rest, .comment depth, acc => + prepareChars rest (.comment (depth + 1)) (' ' :: ' ' :: acc) + | '*' :: '/' :: rest, .comment depth, acc => + prepareChars rest (if depth == 1 then .code else .comment (depth - 1)) (' ' :: ' ' :: acc) + | c :: rest, .comment depth, acc => + prepareChars rest (.comment depth) ((if c == '\n' then c else ' ') :: acc) + | '/' :: '/' :: rest, .code, acc => prepareChars rest .line (' ' :: ' ' :: acc) + | '/' :: '*' :: rest, .code, acc => prepareChars rest (.comment 1) (' ' :: ' ' :: acc) + | '"' :: rest, .code, acc => prepareChars rest (.string false) ('"' :: acc) + | '.' :: '.' :: '=' :: rest, .code, acc => + prepareChars rest .code (' ' :: '=' :: '.' :: '.' :: ' ' :: acc) + | '.' :: '.' :: rest, .code, acc => prepareChars rest .code (' ' :: '.' :: '.' :: ' ' :: acc) + | c :: rest, .code, acc => + if c == '@' then .error "unexpected '@' in Aiur source" else + if c == '\'' then prepareChars rest .code (' ' :: '@' :: acc) else + if c == '.' then prepareChars rest .code (' ' :: '.' :: ' ' :: acc) else + let c := if c == '\t' || c == '\r' then ' ' else c + if c == '>' || c == '&' || c == '*' || ((c == '-' || c == '/') && rest.head? == some '-') then + prepareChars rest .code (' ' :: c :: acc) + else prepareChars rest .code (c :: acc) + +/-- Shared lexical preparation for the modular frontend. -/ +def prepareSource (source : String) : Except String String := + String.ofList <$> prepareChars source.toList .code [] + +/-- Elaborates Rust-like syntax without choosing either a field or entrypoints. -/ +def ofString (env : Lean.Environment) (source : String) : Except String (Program Nat) := do + let source ← prepareSource source + let s ← Parser.runParserCategory env `aiur_program source "" + let ds := s[0].getArgs.toList + let enums ← (ds.filter (·.getKind == ``enumDecl)).mapM (fun d => lowerEnum d[0]) + let structs ← (ds.filter (·.getKind == ``structDecl)).mapM (fun d => lowerStruct d[0]) + let aliases ← (ds.filter (·.getKind == ``aliasDecl)).mapM (fun d => lowerAlias d[0]) + let consts ← (ds.filter (·.getKind == ``constDecl)).mapM fun d => do + return { name := ← readName d[0][1], value := ← Consts.ofExpr (← expr [] d[0][3]) : ConstDecl Nat } + let expanded ← Aliases.resolveDeclarations ({ functions := [], enums, structs, aliases } : Program Nat) + let resolved ← Consts.resolveDeclarations ({ functions := [], enums, structs, aliases, consts } : Program Nat) + let functions ← (ds.filter (·.getKind == ``functionDecl)).mapM (fun d => lowerFunction (enums ++ structs.map StructDecl.signature) expanded resolved d[0]) + let tables ← (ds.filter (·.getKind == ``tableDecl)).mapM fun d => do + let s := d[0] + return { name := ← readName s[1], rowType := ← type [] s[3], rows := ← s[5].getSepArgs.toList.mapM (expr []) : Table Nat } + let maps ← (ds.filter (·.getKind == ``mapDecl)).mapM fun d => do + let s := nativeChoice d[0] + let params ← s[3].getSepArgs.toList.mapM fun param => do + let .bind n ← pattern [] param[0] | throw "map parameters must be named bindings" + return (n, ← type [] param[2]) + return { name := ← readName s[1], params, result := ← type [] s[6], input := ← readName s[8], output := ← readName s[10] : MapDecl } + return (← prepare { functions, enums, structs, tables, maps, aliases, consts }).program + +/-- The ordinary quotation supports the source AST when that type is expected. +Existing quotations of the monomorphic core remain compatible. -/ +@[term_elab Aiur.Frontend.aiurTerm] +def elabGeneric : TermElab := fun stx expected => do + let some expected := expected | throwUnsupportedSyntax + unless (← Meta.whnf expected).isAppOf ``Program do throwUnsupportedSyntax + match ofString (← getEnv) (stx[1].isStrLit?.getD "") with + | .error e => throwErrorAt stx[1] "{e}" + | .ok p => return Lean.toExpr p + +/-- An explicit spelling is useful when the expected type is not yet known. -/ +elab "aiur_generic% " source:str : term => do + match ofString (← getEnv) source.getString with + | .error e => throwErrorAt source "{e}" + | .ok p => return Lean.toExpr p + +end Aiur.Generic.Frontend diff --git a/Aiur/Aiur/Generic/Lower.lean b/Aiur/Aiur/Generic/Lower.lean new file mode 100644 index 000000000..95ab31dd3 --- /dev/null +++ b/Aiur/Aiur/Generic/Lower.lean @@ -0,0 +1,224 @@ +import Aiur.Generic.PatternLowering +import Aiur.Generic.ArrayLowering +import Aiur.Typecheck + +namespace Aiur.Generic + +def arguments (params : List String) (types : List Ty) : Except String (List (String × Ty)) := do + if params.length != types.length then + throw s!"expected {params.length} type arguments, got {types.length}" + return params.zip types + +def resolveEnum (p : Program α) (key : Instance) : Except String Aiur.EnumDecl := do + let some decl := p.findEnum? key.name | throw s!"unknown enum '{key.name}'" + let env ← arguments decl.typeParams key.types + return { + name := key.symbol + constructors := decl.constructors.map fun ctor => + { name := ctor.name, fields := ctor.fields.map (fun t => (t.subst env).toCore) } + } + +namespace StructLowering + +def nominalName (types : List (String × Ty)) (type : Ty) : String := + match (type.subst types).toCore with | .enum name => name | _ => "$invalid" + +/-- Evaluate initializers once in written order, then arrange their values in + declaration order. The temporary's scope contains only generated syntax. -/ +def record (types : List (String × Ty)) (head : RecordHead) (items : List (Aiur.Expr α)) : Aiur.Expr α := + .letValue (.bind "$record") (.tuple items) + (.construct (nominalName types head.type) structConstructor + (head.order ((List.range items.length).map fun i => .project (.var "$record") i) (.tuple []))) + +def fieldPatterns : Nat → Nat → List (Aiur.Pattern α) + | 0, _ => [] + | n + 1, 0 => .bind "$member" :: List.replicate n .wildcard + | n + 1, i + 1 => .wildcard :: fieldPatterns n i + +def fieldPattern (field : FieldRef) : Aiur.Pattern α := + .construct (nominalName [] (field.owner.getD (.named "$invalid" []))) structConstructor + (fieldPatterns field.arity field.index) + +def member (types : List (String × Ty)) (value : Aiur.Expr α) (field : FieldRef) : Aiur.Expr α := + .letValue (fieldPattern (field.subst types)) value (.var "$member") + +end StructLowering + +namespace UpdateLowering + +def shape (types : List (String × Ty)) (step : UpdateStep) : Aiur.Pattern α := + match step.owner with + | none => .tuple (List.replicate step.width .wildcard) + | some type => .construct (StructLowering.nominalName types type) structConstructor + (List.replicate step.width .wildcard) + +def product (types : List (String × Ty)) (step : UpdateStep) (items : List (Aiur.Expr α)) : Aiur.Expr α := + match step.owner with + | none => .tuple items + | some type => .construct (StructLowering.nominalName types type) structConstructor items + +def component (types : List (String × Ty)) (step : UpdateStep) (index : Nat) : Aiur.Expr α := + match step.owner with + | none => .project (.var "$withBase") index + | some type => StructLowering.member types (.var "$withBase") + { name := "", owner := some type, index, arity := step.width } + +/-- Only generated code occurs inside these fixed temporary scopes. -/ +def path (types : List (String × Ty)) : UpdatePath → Aiur.Expr α → Aiur.Expr α + | [], input => .letValue .wildcard input (.var "$withNew") + | step :: rest, input => + .letValue (.bind "$withBase") input + (.letValue (shape types step) (.var "$withBase") + (product types step ((List.range step.width).map fun i => + if i == step.position then path types rest (component types step i) + else component types step i))) + +def sequence (types : List (String × Ty)) : List UpdatePath → Nat → Aiur.Expr α + | [], _ => .var "$withCurrent" + | target :: targets, index => + .letValue (.bind "$withNew") (.project (.var "$withInputs") index) + (.letValue (.bind "$withCurrent") (path types target (.var "$withCurrent")) + (sequence types targets (index + 1))) + +def expression (types : List (String × Ty)) (paths : List UpdatePath) (operands : List (Aiur.Expr α)) : Aiur.Expr α := + .letValue (.bind "$withInputs") (.tuple operands) + (.letValue (.tuple (List.replicate (paths.length + 1) .wildcard)) (.var "$withInputs") + (.letValue (.bind "$withCurrent") (.project (.var "$withInputs") 0) + (sequence types paths 1))) + +end UpdateLowering + +namespace BuiltinLowering + +/-- Only generated syntax occurs inside these temporary scopes. -/ +def expression (op : Builtin) (operands : List (Aiur.Expr α)) : Aiur.Expr α := + match op with + | .assertEq message => .letValue (.tuple [.bind "$assertLeft", .bind "$assertRight"]) (.tuple operands) + (.assertEq message (.var "$assertLeft") (.var "$assertRight")) + | .ascribe _ => .letValue (.tuple [.bind "$annotation"]) (.tuple operands) (.var "$annotation") + | .debug _ => .letValue .wildcard (.tuple operands) (.tuple []) + +end BuiltinLowering + +/-- Inference has filled in every call/constructor's type arguments before +circuit lowering. Source evaluation uses the original body with a type +environment and never calls this translation. -/ +def Expr.lower (env : List (String × Ty)) : Expr α → Aiur.Expr α + | .literal x => .literal x + | .var n => .var n + | .global n _ => .var ("$const:" ++ n) + | .control _ _ => .var "$unloweredControl" + | .tuple xs | .array xs => .tuple (xs.map (Expr.lower env)) + | .repeat x n => ArrayLowering.repeatValue (x.lower env) n + | .index x i => .project (x.lower env) i + | .slice x start (some stop) => ArrayLowering.sliceValue (x.lower env) start stop + | .slice _ _ none => .var "$unelaboratedSlice" + | .construct n ts c xs => + .construct (Instance.symbol ⟨n, (ts.getD []).map (Ty.subst env)⟩) c (xs.map (Expr.lower env)) + | .constructAs _ t c xs => + let name := match (t.subst env).toCore with | .enum n => n | _ => "$invalid" + .construct name c (xs.map (Expr.lower env)) + | .builtin op xs => BuiltinLowering.expression op (xs.map (Expr.lower env)) + | .update paths xs => UpdateLowering.expression env paths (xs.map (Expr.lower env)) + | .record head xs => StructLowering.record env head (xs.map (Expr.lower env)) + | .member x field => StructLowering.member env (x.lower env) field + | .project x i => .project (x.lower env) i + | .letValue p x b => PatternLowering.lowerLet env p (x.lower env) (b.lower env) + | .store x => .store (x.lower env) + | .load x => .load (x.lower env) + | .hint t k channel => .hint (t.subst env).toCore (k.lower env) channel + | .neg x => .neg (x.lower env) + | .binary op x y => .binary op (x.lower env) (y.lower env) + | .call n ts xs => + .call (Instance.symbol ⟨n, (ts.getD []).map (Ty.subst env)⟩) (xs.map (Expr.lower env)) + | .matchValue x arms => + PatternLowering.lowerMatch env (x.lower env) (arms.map fun arm => (arm.1, arm.2.lower env)) +termination_by e => sizeOf e +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; try simp_all only [Prod.mk.sizeOf_spec] + all_goals first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +def resolveFunction (p : Program α) (key : Instance) : Except String (Aiur.Function α) := do + let some fn := p.findFunction? key.name | throw s!"unknown function '{key.name}'" + let env ← arguments fn.typeParams key.types + return { + name := key.symbol + params := fn.params.map fun (n, t) => (n, (t.subst env).toCore) + result := (fn.result.subst env).toCore + body := fn.body.lower env + } + +/-- Lookup in the compiler language, decoding the canonical instance name and +lowering its body. Source execution uses `Program.sourceFunction?` instead. -/ +def Program.function? (p : Program α) (name : String) : Option (Aiur.Function α) := + (Instance.ofSymbol name >>= resolveFunction p).toOption + +def Program.enum? (p : Program α) (name : String) : Option Aiur.EnumDecl := + (Instance.ofSymbol name >>= resolveEnum p).toOption + +def coreTypeNames : Aiur.Ty → List String + | .field => [] + | .tuple ts => ts.flatMap coreTypeNames + | .ptr t => coreTypeNames t + | .enum n => [n] +termination_by t => sizeOf t + +def corePatternNames : Aiur.Pattern α → List String + | .literal _ | .wildcard | .bind _ => [] + | .tuple ps => ps.flatMap corePatternNames + | .construct n _ ps => n :: ps.flatMap corePatternNames +termination_by p => sizeOf p + +/-- Syntactic dependencies include inactive arms; specialization is independent +of a particular execution or a hint provider. -/ +def coreCalls : Aiur.Expr α → List String + | .literal _ | .var _ => [] + | .tuple xs | .construct _ _ xs => xs.flatMap coreCalls + | .call n xs => n :: xs.flatMap coreCalls + | .project x _ | .store x | .load x | .hint _ x channel | .neg x => coreCalls x + | .letValue _ x b | .binary _ x b | .assertEq _ x b => coreCalls x ++ coreCalls b + | .matchValue x arms => coreCalls x ++ arms.flatMap (fun a => coreCalls a.2) +termination_by e => sizeOf e +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; try simp_all only [Prod.mk.sizeOf_spec] + all_goals first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +def coreExprNames : Aiur.Expr α → List String + | .literal _ | .var _ => [] + | .tuple xs | .call _ xs => xs.flatMap coreExprNames + | .construct n _ xs => n :: xs.flatMap coreExprNames + | .project x _ | .store x | .load x | .neg x => coreExprNames x + | .hint t x channel => coreTypeNames t ++ coreExprNames x + | .letValue p x b => corePatternNames p ++ coreExprNames x ++ coreExprNames b + | .binary _ x b | .assertEq _ x b => coreExprNames x ++ coreExprNames b + | .matchValue x arms => coreExprNames x ++ arms.flatMap (fun a => corePatternNames a.1 ++ coreExprNames a.2) +termination_by e => sizeOf e +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; try simp_all only [Prod.mk.sizeOf_spec] + all_goals first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +/-- Finite type closure stops at identical instances. Different instances of +the same enum are essential for nested containers. A depth and type-size bound +rejects endlessly expanding families; the core checker rejects inline cycles. -/ +def collectEnums (p : Program α) (rigid : List String) : + Nat → List Instance → List String → Except String Aiur.Declarations + | 0, _, _ => .error "enum instance limit exceeded" + | fuel + 1, path, names => do + let mut result := [] + for name in names.eraseDups do + if name.startsWith "$param:" then + if !(rigid.contains (name.drop 7).toString) then throw "unresolved type parameter" + result := result ++ [{ name, constructors := [{ name := "$opaque", fields := [] }] }] + else + let key ← Instance.ofSymbol name + if (key.types.map Ty.nodes).sum > 4096 then throw "enum instance type-size limit exceeded" + if !path.contains key then + let decl ← resolveEnum p key + result := result ++ [decl] ++ (← collectEnums p rigid fuel (key :: path) + (decl.constructors.flatMap fun ctor => ctor.fields.flatMap coreTypeNames)) + return result.foldl (fun acc d => if acc.any (·.name == d.name) then acc else acc ++ [d]) [] + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/LoweringChecks.lean b/Aiur/Aiur/Generic/LoweringChecks.lean new file mode 100644 index 000000000..0d73c0433 --- /dev/null +++ b/Aiur/Aiur/Generic/LoweringChecks.lean @@ -0,0 +1,137 @@ +import Aiur.Generic.Consts + +set_option warn.classDefReducibility false + +/-! Finite hygiene checks for compiler-generated pattern names. These checks +refer only to syntax, not to evaluation, termination, or semantic equivalence. -/ + +namespace Aiur.Generic.PatternLowering + +def LetSafe (types : List (String × Ty)) : Pattern F → Aiur.Expr F → Aiur.Expr F → Prop + | .load pat, value, body => LetSafe types pat (.load value) body + | pat, value, body => + match pat.toCore? types with + | some _ => True + | none => + let stem := freshPrefix (pat.bindingNames ++ exprNames value ++ exprNames body) + let root := stem ++ "0" + let tree := (planTree types stem pat 1).1 + Consts.dependencies pat = [] ∧ (root :: tree.temps).Nodup ∧ + ∀ n ∈ exprNames body, n ∉ root :: tree.temps +termination_by pat _ _ => sizeOf pat + +instance decidableLetSafe (types : List (String × Ty)) (pat : Pattern F) (value body : Aiur.Expr F) : + Decidable (LetSafe types pat value body) := by + cases pat with + | load pat => unfold LetSafe; exact decidableLetSafe types pat (.load value) body + | _ => unfold LetSafe; split <;> infer_instance +termination_by sizeOf pat + +def ArmsSafe (types : List (String × Ty)) (stem root : String) : + List (Pattern F × Aiur.Expr F) → Nat → Prop + | [], _ => True + | (pat, body) :: arms, state => + let generated := planTree types stem pat state + let tree := generated.1 + let failure := (matchArms types stem root arms generated.2).1 + Consts.dependencies pat = [] ∧ (root :: tree.temps).Nodup ∧ + (∀ n ∈ exprNames body, n ∉ root :: tree.temps) ∧ + (∀ fallback ∈ failure.toList, ∀ n ∈ exprNames fallback, n ∉ tree.temps) ∧ + ArmsSafe types stem root arms generated.2 + +instance (types : List (String × Ty)) (stem root : String) + (arms : List (Pattern F × Aiur.Expr F)) (state : Nat) : + Decidable (ArmsSafe types stem root arms state) := by + cases arms with + | nil => unfold ArmsSafe; infer_instance + | cons arm arms => + rcases arm with ⟨pat, body⟩ + unfold ArmsSafe + haveI := instDecidableArmsSafe types stem root arms (planTree types stem pat state).2 + infer_instance + +def MatchSafe (types : List (String × Ty)) (value : Aiur.Expr F) + (arms : List (Pattern F × Aiur.Expr F)) : Prop := + match arms.mapM (fun arm => return (← arm.1.toCore? types, arm.2)) with + | some _ => True + | none => + let names := exprNames value ++ arms.flatMap (fun arm => arm.1.bindingNames ++ exprNames arm.2) + let stem := freshPrefix names + ArmsSafe types stem (stem ++ "0") arms 1 + +instance (types : List (String × Ty)) (value : Aiur.Expr F) (arms : List (Pattern F × Aiur.Expr F)) : + Decidable (MatchSafe types value arms) := by unfold MatchSafe; split <;> infer_instance + +end Aiur.Generic.PatternLowering + +namespace Aiur.Generic + +private def decideAll (xs : List A) (p : A → Prop) + (dec : ∀ x ∈ xs, Decidable (p x)) : Decidable (∀ x ∈ xs, p x) := by + cases xs with + | nil => exact isTrue (by simp) + | cons x xs => + haveI := dec x (by simp) + haveI := decideAll xs p (fun y hy => dec y (by simp [hy])) + exact decidable_of_iff (p x ∧ ∀ y ∈ xs, p y) (by simp) + +/-- Checked on the prepared expression, after const expansion and before +lowering. Rejection is a compiler error, not a new source-language behavior. -/ +def Expr.lowerSafe (types : List (String × Ty)) : Expr F → Prop + | .literal _ | .var _ => True + | .global _ _ | .control _ _ => False + | .builtin _ xs | .update _ xs | .record _ xs | .tuple xs | .array xs | .construct _ _ _ xs | .constructAs _ _ _ xs | .call _ _ xs => + ∀ x ∈ xs, x.lowerSafe types + | .repeat x _ | .index x _ | .project x _ | .store x | .load x | .hint _ x channel | .neg x => x.lowerSafe types + | .member x field => x.lowerSafe types ∧ field.index < field.arity + | .slice x start (some stop) => start ≤ stop ∧ x.lowerSafe types + | .slice _ _ none => False + | .binary _ left right => left.lowerSafe types ∧ right.lowerSafe types + | .letValue pat value body => + value.lowerSafe types ∧ body.lowerSafe types ∧ + PatternLowering.LetSafe types pat (value.lower types) (body.lower types) + | .matchValue value arms => + value.lowerSafe types ∧ (∀ arm ∈ arms, arm.2.lowerSafe types) ∧ + PatternLowering.MatchSafe types (value.lower types) (arms.map fun arm => (arm.1, arm.2.lower types)) +termination_by expr => sizeOf expr +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +instance decidableLowerSafe (types : List (String × Ty)) (expr : Expr F) : Decidable (expr.lowerSafe types) := by + have sub (e : Expr F) (smaller : sizeOf e < sizeOf expr) : Decidable (e.lowerSafe types) := + decidableLowerSafe types e + cases expr with + | literal _ | var _ | global _ _ | control _ _ => unfold Expr.lowerSafe; infer_instance + | builtin _ xs | update _ xs | record _ xs | tuple xs | array xs | construct _ _ _ xs | constructAs _ _ _ xs | call _ _ xs => + unfold Expr.lowerSafe + apply decideAll + intro e he + exact sub e (by simp_wf; have := List.sizeOf_lt_of_mem he; omega) + | «repeat» x _ | index x _ | project x _ | store x | load x | hint _ x channel | neg x => + unfold Expr.lowerSafe; exact sub x (by simp_wf <;> omega) + | member x field => + haveI := sub x (by simp_wf; omega) + unfold Expr.lowerSafe; infer_instance + | slice x start stop => + haveI := sub x (by simp_wf; omega) + cases stop <;> unfold Expr.lowerSafe <;> infer_instance + | binary _ left right => + haveI := sub left (by simp_wf; omega) + haveI := sub right (by simp_wf; omega) + unfold Expr.lowerSafe; infer_instance + | letValue pat value body => + haveI := sub value (by simp_wf; omega) + haveI := sub body (by simp_wf; omega) + unfold Expr.lowerSafe; infer_instance + | matchValue value arms => + haveI := sub value (by simp_wf; omega) + haveI : Decidable (∀ arm ∈ arms, arm.2.lowerSafe types) := by + apply decideAll + intro arm ha + exact sub arm.2 (by have := List.sizeOf_lt_of_mem ha; cases arm; simp_all only [Expr.matchValue.sizeOf_spec, Prod.mk.sizeOf_spec]; omega) + unfold Expr.lowerSafe; infer_instance +termination_by sizeOf expr +decreasing_by exact smaller + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/LoweringCompleteness.lean b/Aiur/Aiur/Generic/LoweringCompleteness.lean new file mode 100644 index 000000000..b2c2fd9d7 --- /dev/null +++ b/Aiur/Aiur/Generic/LoweringCompleteness.lean @@ -0,0 +1,104 @@ +import Aiur.Generic.BuiltinFacts +import Aiur.Generic.UpdateFacts +import Aiur.Generic.PatternLoweringFacts +import Aiur.Generic.OpenSource +import Aiur.Generic.ArrayFacts +import Aiur.Generic.SliceFacts +import Aiur.Generic.StructFacts + +namespace Aiur.Generic +open SourceSemantics PatternLowering + +/-- Expression lowering preserves native evaluation with function calls left +as premises. Recursion is handled separately by induction on the finite source +derivation; this lemma does not assume that recursive calls terminate. -/ +theorem lowering_complete [Field F] [DecidableEq F] + {source : SourceSemantics.World F} {core : Engine.World F} {calls : CallRelation F} + (typed : core.typed = source.typed) + (evaluated : OpenSource.EvalExpr source calls types locals expr before result after) + (safe : expr.lowerSafe types) : + OpenCore.EvalExpr core calls locals (expr.lower types) before result after := by + induction evaluated using OpenSource.EvalExpr.rec + (motive_2 := fun types locals exprs before values after _ => + (∀ e ∈ exprs, e.lowerSafe types) → + OpenCore.EvalArgs core calls locals (exprs.map (Expr.lower types)) before values after) + (motive_3 := fun _ _ _ _ _ _ _ _ => True) + (motive_4 := fun _ _ _ _ _ _ _ _ => True) with + | block | blockExit => simp [Expr.lowerSafe] at safe + | literal => simpa only [Expr.lower] using (OpenCore.EvalExpr.literal (world := core) (calls := calls)) + | var found => rw [Expr.lower]; exact OpenCore.EvalExpr.var found + | global => simp [Expr.lowerSafe] at safe + | tuple _ ih | array _ ih => + rw [Expr.lower] + exact OpenCore.EvalExpr.tuple (ih (by simpa only [Expr.lowerSafe] using safe)) + | «repeat» _ ih => + rw [Expr.lower] + exact ArrayLowering.repeatValue_iff.mpr ⟨_, ih (by simpa only [Expr.lowerSafe] using safe), rfl⟩ + | index _ projected ih | project _ projected ih => + rw [Expr.lower] + exact OpenCore.EvalExpr.project (ih (by simpa only [Expr.lowerSafe] using safe)) projected + | @slice types locals expr before input after start stop result _ sliced ih => + cases stop with + | none => simp [Expr.lowerSafe] at safe + | some stop => + rw [Expr.lowerSafe] at safe + obtain ⟨values, projected, rfl⟩ := ArrayLowering.projects_of_source_slice sliced + rw [Expr.lower] + exact ArrayLowering.sliceValue_iff.mpr + ⟨input, values, ih safe.2, projected, rfl⟩ + | builtin _ builtind ih => + rw [Expr.lower] + exact BuiltinLowering.expression_iff.mpr ⟨_, ih (by simpa only [Expr.lowerSafe] using safe), builtind⟩ + | update _ updated ih => + rw [Expr.lower] + exact UpdateLowering.expression_iff.mpr ⟨_, ih (by simpa only [Expr.lowerSafe] using safe), updated⟩ + | record _ ih => + rw [Expr.lower] + exact StructLowering.record_iff.mpr ⟨_, ih (by simpa only [Expr.lowerSafe] using safe), rfl⟩ + | member _ projected ih => + rw [Expr.lowerSafe] at safe + rw [Expr.lower] + exact (StructLowering.member_iff safe.2).mpr ⟨_, ih safe.1, projected⟩ + | construct _ ih => + rw [Expr.lower] + exact OpenCore.EvalExpr.construct (ih (by simpa only [Expr.lowerSafe] using safe)) + | constructAs _ ih => + rw [Expr.lower] + exact OpenCore.EvalExpr.construct (ih (by simpa only [Expr.lowerSafe] using safe)) + | letValue _ matched _ valueIH bodyIH => + rw [Expr.lowerSafe] at safe + obtain ⟨valueSafe, bodySafe, patternSafe⟩ := safe + rw [Expr.lower] + exact (lowerLet_open_iff _ _ _ _ patternSafe source.constant source.constDepth _ _ _ _).mpr + ⟨_, _, _, valueIH valueSafe, matched, bodyIH bodySafe⟩ + | store _ ih => rw [Expr.lower]; exact OpenCore.EvalExpr.store (ih (by simpa only [Expr.lowerSafe] using safe)) + | load _ loaded ih => rw [Expr.lower]; exact OpenCore.EvalExpr.load (ih (by simpa only [Expr.lowerSafe] using safe)) loaded + | hint _ formed ih => + rw [Expr.lower] + exact OpenCore.EvalExpr.hint (ih (by simpa only [Expr.lowerSafe] using safe)) (by rw [typed]; exact formed) + | neg _ operation ih => rw [Expr.lower]; exact OpenCore.EvalExpr.neg (ih (by simpa only [Expr.lowerSafe] using safe)) operation + | binary _ _ operation leftIH rightIH => + rw [Expr.lowerSafe] at safe + rw [Expr.lower] + exact OpenCore.EvalExpr.binary (leftIH safe.1) (rightIH safe.2) operation + | call _ callee argsIH => + rw [Expr.lower] + exact OpenCore.EvalExpr.call (argsIH (by simpa only [Expr.lowerSafe] using safe)) callee + | @matchValue types locals expr before input middle arms bindings body result after _ selected _ valueIH bodyIH => + rw [Expr.lowerSafe] at safe + obtain ⟨valueSafe, armsSafe, patternSafe⟩ := safe + have chosen : choose source.constant source.constDepth types middle input arms = .ok (some (bindings, body)) := by + rw [choose_source]; exact selected + obtain ⟨pat, member⟩ := choose_member chosen + rw [Expr.lower] + apply (lowerMatch_open_iff _ _ _ patternSafe source.constant source.constDepth _ _ _ _).mpr + refine ⟨input, middle, bindings, body.lower types, valueIH valueSafe, ?_, bodyIH (armsSafe _ member)⟩ + rw [choose_map, chosen] + rfl + | nil => exact .nil + | cons _ _ headIH tailIH => + rename_i safe + exact .cons (headIH (safe _ (by simp))) (tailIH (fun e he => safe e (by simp [he]))) + | _ => trivial + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/LoweringSoundness.lean b/Aiur/Aiur/Generic/LoweringSoundness.lean new file mode 100644 index 000000000..5a445bf2d --- /dev/null +++ b/Aiur/Aiur/Generic/LoweringSoundness.lean @@ -0,0 +1,243 @@ +import Aiur.Generic.BuiltinFacts +import Aiur.Generic.UpdateFacts +import Aiur.Generic.LoweringCompleteness +import Aiur.Generic.LoweringTypeFacts + +namespace Aiur.Generic +open SourceSemantics PatternLowering + +/-- Typed reflection for expressions. The hypotheses about calls are discharged +by induction on the enclosing core evaluation, rather than by a totality +assumption. The source predicate still interprets the original source forms. -/ +theorem lowering_sound [Field F] [DecidableEq F] + {program : Aiur.Program F} {source : SourceSemantics.World F} + {calls sourceCalls : CallRelation F} + (checkedProgram : typecheck program = .ok ()) + (closed : ∀ n args b v a, calls n args b v a → Aiur.EvalFn program n args b v a) + (reflect : ∀ n args b v a, calls n args b v a → b.Good program.enums → + (∀ arg ∈ args, arg.Good program.enums) → sourceCalls n args b v a) + (hints : ∀ t, knownType program.enums t = true → ∀ v, + (Engine.World.ofProgram program).typed t v = true → source.typed t v = true) + (expr : Expr F) (types : Types) (locals : Environment F Nat) + (before : Heap F) (result : SourceValue F) (after : Heap F) + (safe : expr.lowerSafe types) + {type : Aiur.Ty} (checked : expr.checkLowerTypes program types (environmentTypes locals) = some type) + (evaluated : OpenCore.EvalExpr (.ofProgram program) calls locals (expr.lower types) before result after) + (heapGood : before.Good program.enums) (localsGood : locals.Good program.enums) : + OpenSource.EvalExpr source sourceCalls types locals expr before result after := by + have sub (child : Expr F) (smaller : sizeOf child < sizeOf expr) + (ls : Environment F Nat) (b : Heap F) (v : SourceValue F) (a : Heap F) + (safe : child.lowerSafe types) {t : Aiur.Ty} + (checked : child.checkLowerTypes program types (environmentTypes ls) = some t) + (ev : OpenCore.EvalExpr (.ofProgram program) calls ls (child.lower types) b v a) + (hg : b.Good program.enums) (lg : ls.Good program.enums) : + OpenSource.EvalExpr source sourceCalls types ls child b v a := + lowering_sound checkedProgram closed reflect hints child types ls b v a safe checked ev hg lg + have children (es : List (Expr F)) + (smaller : ∀ e ∈ es, sizeOf e < sizeOf expr) + (safe : ∀ e ∈ es, e.lowerSafe types) + (typed : ∀ e ∈ es, ∃ t, e.checkLowerTypes program types (environmentTypes locals) = some t) + {b : Heap F} {values : List (SourceValue F)} {a : Heap F} + (ev : OpenCore.EvalArgs (.ofProgram program) calls locals (es.map (Expr.lower types)) b values a) + (hg : b.Good program.enums) : + OpenSource.EvalArgs source sourceCalls types locals es b values a ∧ + (∀ v ∈ values, v.Good program.enums) ∧ a.Good program.enums := by + induction es generalizing b values with + | nil => cases ev; exact ⟨.nil, by simp, hg⟩ + | cons e es ih => + cases ev with + | cons head tail => + obtain ⟨t, ht⟩ := typed e (by simp) + have info := head.lowerTyped checkedProgram closed hg localsGood ht + obtain ⟨rest, good, last⟩ := ih (fun x hx => smaller x (by simp [hx])) + (fun x hx => safe x (by simp [hx])) (fun x hx => typed x (by simp [hx])) tail info.2.2 + exact ⟨.cons (sub e (smaller e (by simp)) locals _ _ _ (safe e (by simp)) ht head hg localsGood) rest, + by simpa only [List.mem_cons, forall_eq_or_imp] using And.intro info.2.1 good, last⟩ + have inferred := Expr.checkLowerTypes_infer checked + have scope := Expr.checkLowerTypes_scope checked + rw [Expr.checkLowerTypes.eq_def] at checked + simp only [inferred, Except.toOption, Bind.bind, Option.bind] at checked + rw [if_neg (by simp [scope])] at checked + obtain ⟨unit, checks, _⟩ := Option.map_eq_some_iff.mp checked + cases unit + cases expr with + | control => simp [Expr.lowerSafe] at safe + | literal x => rw [Expr.lower] at evaluated; cases evaluated; exact .literal + | var name => rw [Expr.lower] at evaluated; cases evaluated with | var found => exact .var found + | global => simp [Expr.lowerSafe] at safe + | tuple es | array es => + rw [Expr.lower] at evaluated + cases evaluated with + | tuple items => + obtain ⟨_, mapped, _⟩ := Option.bind_eq_some_iff.mp checks + have args := (children es (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) + (by simpa only [Expr.lowerSafe] using safe) (option_mapM_hasResult mapped) items heapGood).1 + first | exact .tuple args | exact .array args + | builtin paths es => + rw [Expr.lower] at evaluated + obtain ⟨values, items, builtind⟩ := BuiltinLowering.expression_iff.mp evaluated + obtain ⟨_, mapped, _⟩ := Option.bind_eq_some_iff.mp checks + exact .builtin ((children es (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) + (by simpa only [Expr.lowerSafe] using safe) (option_mapM_hasResult mapped) items heapGood).1) builtind + | update paths es => + rw [Expr.lower] at evaluated + obtain ⟨values, items, updated⟩ := UpdateLowering.expression_iff.mp evaluated + obtain ⟨_, mapped, _⟩ := Option.bind_eq_some_iff.mp checks + exact .update ((children es (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) + (by simpa only [Expr.lowerSafe] using safe) (option_mapM_hasResult mapped) items heapGood).1) updated + | record head es => + rw [Expr.lower] at evaluated + obtain ⟨values, items, rfl⟩ := StructLowering.record_iff.mp evaluated + obtain ⟨_, mapped, _⟩ := Option.bind_eq_some_iff.mp checks + exact .record ((children es (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) + (by simpa only [Expr.lowerSafe] using safe) (option_mapM_hasResult mapped) items heapGood).1) + | member child field => + rw [Expr.lowerSafe] at safe + rw [Expr.lower] at evaluated + obtain ⟨value, ev, projected⟩ := (StructLowering.member_iff safe.2).mp evaluated + obtain ⟨_, typed, _⟩ := Option.bind_eq_some_iff.mp checks + exact .member (sub child (by simp_wf; omega) locals _ _ _ safe.1 typed ev heapGood localsGood) projected + | construct name args ctor es | constructAs params t ctor es => + rw [Expr.lower] at evaluated + cases evaluated with + | construct items => + obtain ⟨_, mapped, _⟩ := Option.bind_eq_some_iff.mp checks + have args := (children es (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) + (by simpa only [Expr.lowerSafe] using safe) (option_mapM_hasResult mapped) items heapGood).1 + first | exact .construct args | exact .constructAs args + | «repeat» child n => + rw [Expr.lower] at evaluated + obtain ⟨value, ev, rfl⟩ := ArrayLowering.repeatValue_iff.mp evaluated + obtain ⟨_, typed, _⟩ := Option.bind_eq_some_iff.mp checks + exact .repeat (sub child (by simp_wf <;> omega) locals _ _ _ + (by simpa only [Expr.lowerSafe] using safe) typed ev heapGood localsGood) + | index child i | project child i => + rw [Expr.lower] at evaluated + cases evaluated with + | project ev projected => + obtain ⟨_, typed, _⟩ := Option.bind_eq_some_iff.mp checks + have childEval := sub child (by simp_wf <;> omega) locals _ _ _ + (by simpa only [Expr.lowerSafe] using safe) typed ev heapGood localsGood + first | exact .index childEval projected | exact .project childEval projected + | store child => + rw [Expr.lower] at evaluated + cases evaluated with + | store ev => + obtain ⟨_, typed, _⟩ := Option.bind_eq_some_iff.mp checks + exact .store (sub child (by simp_wf <;> omega) locals _ _ _ + (by simpa only [Expr.lowerSafe] using safe) typed ev heapGood localsGood) + | load child => + rw [Expr.lower] at evaluated + cases evaluated with + | load ev loaded => + obtain ⟨_, typed, _⟩ := Option.bind_eq_some_iff.mp checks + exact .load (sub child (by simp_wf <;> omega) locals _ _ _ + (by simpa only [Expr.lowerSafe] using safe) typed ev heapGood localsGood) loaded + | hint t child channel => + simp only [Expr.lower, Engine.inScope, Bool.and_eq_true] at scope + rw [Expr.lower] at evaluated + cases evaluated with + | hint ev formed => + obtain ⟨_, typed, _⟩ := Option.bind_eq_some_iff.mp checks + exact .hint (sub child (by simp_wf <;> omega) locals _ _ _ + (by simpa only [Expr.lowerSafe] using safe) typed ev heapGood localsGood) + (hints _ scope.1 _ formed) + | neg child => + rw [Expr.lower] at evaluated + cases evaluated with + | neg ev operation => + obtain ⟨_, typed, _⟩ := Option.bind_eq_some_iff.mp checks + exact .neg (sub child (by simp_wf <;> omega) locals _ _ _ + (by simpa only [Expr.lowerSafe] using safe) typed ev heapGood localsGood) operation + | binary op left right => + rw [Expr.lowerSafe] at safe + rw [Expr.lower] at evaluated + cases evaluated with + | binary first second operation => + obtain ⟨_, leftType, rest⟩ := Option.bind_eq_some_iff.mp checks + obtain ⟨_, rightType, _⟩ := Option.bind_eq_some_iff.mp rest + have middleGood := (first.lowerTyped checkedProgram closed heapGood localsGood leftType).2.2 + exact .binary (sub left (by simp_wf <;> omega) locals _ _ _ safe.1 leftType first heapGood localsGood) + (sub right (by simp_wf <;> omega) locals _ _ _ safe.2 rightType second middleGood localsGood) operation + | call name args es => + rw [Expr.lower] at evaluated + cases evaluated with + | call argEval callee => + obtain ⟨_, mapped, _⟩ := Option.bind_eq_some_iff.mp checks + obtain ⟨argsEval, argsGood, middleGood⟩ := children es + (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) + (by simpa only [Expr.lowerSafe] using safe) (option_mapM_hasResult mapped) argEval heapGood + exact .call argsEval (reflect _ _ _ _ _ callee middleGood argsGood) + | slice child start stop => + cases stop with + | none => simp [Expr.lowerSafe] at safe + | some stop => + rw [Expr.lowerSafe] at safe + obtain ⟨inputType, childType, rest⟩ := Option.bind_eq_some_iff.mp checks + cases inputType <;> try cases rest + rename_i fields + dsimp only at rest + split at rest + · rename_i bounds + rw [Expr.lower] at evaluated + obtain ⟨input, values, childEval, projected, rfl⟩ := ArrayLowering.sliceValue_iff.mp evaluated + have shape := (childEval.lowerTyped checkedProgram closed heapGood localsGood childType).1 + cases input <;> simp only [Value.type] at shape + all_goals first | contradiction | skip + rename_i inputs + have bound : stop ≤ inputs.length := by + have length := congrArg List.length (Aiur.Ty.tuple.inj shape) + simp only [List.length_map] at length + omega + exact .slice (sub child (by simp_wf <;> omega) locals _ _ _ safe.2 childType childEval heapGood localsGood) + (ArrayLowering.source_slice_of_projects bounds.1 bound projected) + · cases rest + | letValue pat value body => + rw [Expr.lowerSafe] at safe + obtain ⟨inputType, valueType, rest⟩ := Option.bind_eq_some_iff.mp checks + obtain ⟨bindingTypes, patternType, rest⟩ := Option.bind_eq_some_iff.mp rest + obtain ⟨_, bodyType, _⟩ := Option.bind_eq_some_iff.mp rest + rw [Expr.lower] at evaluated + obtain ⟨input, middle, bindings, valueEval, matched, bodyEval⟩ := + (lowerLet_open_iff types pat _ _ safe.2.2 source.constant source.constDepth _ _ _ _).mp evaluated + obtain ⟨shape, inputGood, middleGood⟩ := valueEval.lowerTyped checkedProgram closed heapGood localsGood valueType + obtain ⟨bindingShape, bindingsGood⟩ := Pattern.lowerBindingTypes_sound middleGood inputGood matched + (by rw [shape]; exact patternType) + exact .letValue (sub value (by simp_wf <;> omega) locals _ _ _ safe.1 valueType valueEval heapGood localsGood) matched + (sub body (by simp_wf <;> omega) (bindings ++ locals) _ _ _ safe.2.1 + (by simpa only [environmentTypes_append, bindingShape] using bodyType) bodyEval middleGood + (Environment.good_append.mpr ⟨bindingsGood, localsGood⟩)) + | matchValue value arms => + rw [Expr.lowerSafe] at safe + obtain ⟨inputType, valueType, rest⟩ := Option.bind_eq_some_iff.mp checks + obtain ⟨_, armsTyped, _⟩ := Option.bind_eq_some_iff.mp rest + rw [Expr.lower] at evaluated + obtain ⟨input, middle, bindings, body, valueEval, selected, bodyEval⟩ := + (lowerMatch_open_iff types _ _ safe.2.2 source.constant source.constDepth _ _ _ _).mp evaluated + rw [choose_map] at selected + cases chosen : choose source.constant source.constDepth types middle input arms with + | error e => simp [chosen, Except.map] at selected + | ok selection => cases selection with + | none => simp [chosen, Except.map] at selected + | some selection => + rcases selection with ⟨bs, branch⟩ + have same : bs = bindings ∧ branch.lower types = body := by + simpa [chosen, Except.map] using selected + obtain ⟨rfl, rfl⟩ := same + obtain ⟨pat, member, matched⟩ := choose_matched chosen + obtain ⟨_, branchTypes⟩ := option_mapM_hasResult armsTyped (pat, branch) member + obtain ⟨bindingTypes, patType, branchType⟩ := Option.bind_eq_some_iff.mp branchTypes + obtain ⟨shape, inputGood, middleGood⟩ := valueEval.lowerTyped checkedProgram closed heapGood localsGood valueType + obtain ⟨bindingShape, bindingsGood⟩ := Pattern.lowerBindingTypes_sound middleGood inputGood matched + (by rw [shape]; exact patType) + apply OpenSource.EvalExpr.matchValue + (sub value (by simp_wf <;> omega) locals _ _ _ safe.1 valueType valueEval heapGood localsGood) + (by rw [← choose_source]; exact chosen) + exact sub branch (by simp_wf; have h := List.sizeOf_lt_of_mem member; simp only [Prod.mk.sizeOf_spec] at h; omega) + (bs ++ locals) _ _ _ (safe.2.1 _ member) + (by simpa only [environmentTypes_append, bindingShape] using branchType) bodyEval middleGood + (Environment.good_append.mpr ⟨bindingsGood, localsGood⟩) +termination_by sizeOf expr +decreasing_by exact smaller + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/LoweringTypeFacts.lean b/Aiur/Aiur/Generic/LoweringTypeFacts.lean new file mode 100644 index 000000000..a5db24f52 --- /dev/null +++ b/Aiur/Aiur/Generic/LoweringTypeFacts.lean @@ -0,0 +1,62 @@ +import Aiur.Generic.PatternTypeFacts +import Aiur.Generic.PatternTranslation +import Aiur.Generic.OpenCore +import Aiur.Generic.Simulation + +namespace Aiur.Generic + +theorem except_toOption_some_iff {value : Except E A} : value.toOption = some x ↔ value = .ok x := by + cases value <;> simp [Except.toOption] + +theorem option_mapM_hasResult {f : A → Option B} {xs : List A} {ys : List B} + (mapped : xs.mapM f = some ys) : ∀ x ∈ xs, ∃ y, f x = some y := by + have related := option_mapM_relation mapped + clear mapped + induction related with + | nil => simp + | @cons x y xs ys head _ ih => + intro value member + rcases List.mem_cons.mp member with rfl | member + · exact ⟨y, head⟩ + · exact ih value member + +theorem Expr.checkLowerTypes_infer {expr : Expr F} {program : Aiur.Program F} + (checked : expr.checkLowerTypes program types locals = some result) : + inferType program "$lower" locals (expr.lower types) = .ok result := by + rw [Expr.checkLowerTypes.eq_def] at checked + obtain ⟨type, inferred, checked⟩ := Option.bind_eq_some_iff.mp checked + split at checked + · cases checked + · obtain ⟨_, _, same⟩ := Option.map_eq_some_iff.mp checked + cases same + exact except_toOption_some_iff.mp inferred + +theorem Expr.checkLowerTypes_scope {expr : Expr F} {program : Aiur.Program F} + (checked : expr.checkLowerTypes program types locals = some result) : + Engine.inScope (program.functions.map (·.name) ++ program.maps.map (·.name)) + (knownType program.enums) (expr.lower types) = true := by + rw [Expr.checkLowerTypes.eq_def] at checked + obtain ⟨_, _, checked⟩ := Option.bind_eq_some_iff.mp checked + split at checked + · cases checked + · rename_i scope + simpa using scope + +theorem OpenCore.EvalExpr.toProgram [Field F] [DecidableEq F] {program : Aiur.Program F} + (evaluated : OpenCore.EvalExpr (.ofProgram program) calls locals expr before result after) + (closed : ∀ n args b v a, calls n args b v a → Aiur.EvalFn program n args b v a) : + Aiur.EvalExpr program locals expr before result after := + (evaluated.mapCalls (fun _ _ _ _ _ h => Engine.core_iff.mpr (closed _ _ _ _ _ h))).close.toCore + +theorem OpenCore.EvalExpr.lowerTyped [Field F] [DecidableEq F] {program : Aiur.Program F} + {expr : Expr F} + (checkedProgram : typecheck program = .ok ()) + (evaluated : OpenCore.EvalExpr (.ofProgram program) calls locals (expr.lower types) before result after) + (closed : ∀ n args b v a, calls n args b v a → Aiur.EvalFn program n args b v a) + (heapGood : before.Good program.enums) (localsGood : locals.Good program.enums) + (checked : expr.checkLowerTypes program types (environmentTypes locals) = some type) : + result.type = type ∧ result.Good program.enums ∧ after.Good program.enums := + (evaluated.toProgram closed).wellTyped checkedProgram heapGood localsGood "$lower" type + (Expr.checkLowerTypes_infer checked) + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/LoweringTypes.lean b/Aiur/Aiur/Generic/LoweringTypes.lean new file mode 100644 index 000000000..64c1c5dba --- /dev/null +++ b/Aiur/Aiur/Generic/LoweringTypes.lean @@ -0,0 +1,101 @@ +import Aiur.Generic.ValueTyping +import Aiur.Generic.Simulation + +namespace Aiur.Generic + +abbrev LocalTypes := List (String × Aiur.Ty) + +namespace PatternLowering + +def typeListWith (run : A → Aiur.Ty → Option LocalTypes) : List A → List Aiur.Ty → Option LocalTypes + | [], [] => some [] + | child :: children, type :: types => return (← run child type) ++ (← typeListWith run children types) + | _, _ => none + +/-- Recover user-binding types before eliminating pointer patterns. Temporary +names are irrelevant to this check. -/ +def PlanTree.bindTypes (decls : Declarations) : PlanTree F → Aiur.Ty → Option LocalTypes + | .literal _, .field => some [] + | .literal _, _ => none + | .wildcard, _ => some [] + | .bind name, type => some [(name, type)] + | .choice _ left right layout, type => do + let lbs ← left.bindTypes decls type + let rbs ← right.bindTypes decls type + let lhs ← reorderBindings layout.names (List.range layout.names.length) lbs + let rhs ← reorderBindings layout.names layout.rightOrder rbs + if lhs = rhs then some lhs else none + | .load _ child, .ptr target => child.bindTypes decls target + | .load _ _, _ => none + | .tuple children, .tuple types => + typeListWith (fun child type => child.val.2.bindTypes decls type) children.attach types + | .tuple _, _ => none + | .construct name ctor children, .enum actual => do + if actual != name then none else do + let definition ← decls.findConstructor? name ctor + typeListWith (fun child type => child.val.2.bindTypes decls type) children.attach definition.fields + | .construct _ _ _, _ => none +termination_by tree _ => sizeOf tree +decreasing_by + all_goals simp_wf + all_goals first | omega | skip + all_goals rcases child with ⟨⟨name, tree⟩, member⟩ + all_goals have h := List.sizeOf_lt_of_mem member + all_goals simp_all only [Prod.mk.sizeOf_spec] <;> omega + +end PatternLowering + +def Pattern.lowerBindingTypes (decls : Declarations) (types : SourceSemantics.Types) + (pat : Pattern F) (input : Aiur.Ty) : Option LocalTypes := + if Consts.dependencies pat = [] then + (PatternLowering.planTree types "" pat 0).1.bindTypes decls input + else none + +/-- A decidable typing certificate for lowering. The check follows source +subexpressions and user scopes, while using the existing core typechecker for +their representations. In particular, an empty slice still requires an array +operand and valid static bounds. -/ +def Expr.checkLowerTypes (program : Aiur.Program F) (types : SourceSemantics.Types) + (locals : LocalTypes) (expr : Expr F) : Option Aiur.Ty := do + let result ← (inferType program "$lower" locals (expr.lower types)).toOption + if !(Engine.inScope (program.functions.map (·.name) ++ program.maps.map (·.name)) + (knownType program.enums) (expr.lower types)) then none else do + let checks : Option Unit := match expr with + | .literal _ | .var _ => some () + | .global _ _ | .control _ _ => none + | .builtin _ children | .update _ children | .record _ children | .tuple children | .array children | .construct _ _ _ children | .constructAs _ _ _ children + | .call _ _ children => do + let _ ← children.mapM (Expr.checkLowerTypes program types locals) + some () + | .member child _ | .repeat child _ | .index child _ | .project child _ | .store child | .load child + | .hint _ child channel | .neg child => do + let _ ← child.checkLowerTypes program types locals + some () + | .slice _ _ none => none + | .slice child start (some stop) => do + let .tuple fields ← child.checkLowerTypes program types locals | none + if start ≤ stop ∧ stop ≤ fields.length then some () else none + | .binary _ left right => do + let _ ← left.checkLowerTypes program types locals + let _ ← right.checkLowerTypes program types locals + some () + | .letValue pat value body => do + let input ← value.checkLowerTypes program types locals + let bindings ← pat.lowerBindingTypes program.enums types input + let _ ← body.checkLowerTypes program types (bindings ++ locals) + some () + | .matchValue value arms => do + let input ← value.checkLowerTypes program types locals + let _ ← arms.mapM fun arm => do + let bindings ← arm.1.lowerBindingTypes program.enums types input + arm.2.checkLowerTypes program types (bindings ++ locals) + some () + checks.map (fun _ => result) +termination_by sizeOf expr +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + all_goals try cases ‹Pattern F × Expr F› + all_goals simp_all only [Prod.mk.sizeOf_spec] <;> omega + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/NativeCircuit.lean b/Aiur/Aiur/Generic/NativeCircuit.lean new file mode 100644 index 000000000..f1067e6b8 --- /dev/null +++ b/Aiur/Aiur/Generic/NativeCircuit.lean @@ -0,0 +1,249 @@ +import Aiur.Generic.NativeSoundness +import Aiur.Generic.Circuit + +namespace Aiur.Generic + +variable {F : Type} [Field F] [DecidableEq F] +variable {s : Source F} {entries : List String} + +/-- Completeness starts at the independent predicate on the original generic +source, before const expansion, array lowering, or function specialization. -/ +theorem Specialized.heap_complete (q : Specialized s entries) + (selected : name ∈ entries) {system : Aiur.Circuit.System F} + (compiled : Aiur.Circuit.compile q.program = .ok system) + (evaluated : SourceSemantics.EvalFn s.world name args [] value heap) (encode : Nat → F) + (distinct : ∀ i j, i < heap.length → j < heap.length → encode i = encode j → i = j) : + Aiur.Circuit.EncodedEntryDerives system name (entryValues args) (value.mapAddress encode) := by + have root := q.valid.2.2.2.2.2.2.2 name selected + exact q.core_heap_complete selected compiled (q.native_complete root.1 evaluated) encode distinct + +theorem Specialized.run_complete [Fintype F] (q : Specialized s entries) + (selected : name ∈ entries) {system : Aiur.Circuit.System F} + (compiled : Aiur.Circuit.compile q.program = .ok system) {hints : s.HintProvider} + (executed : s.run name args fuel hints = .ok (value, heap)) (capacity : heap.length ≤ Fintype.card F) : + ∃ encode : Nat → F, Aiur.Circuit.EncodedEntryDerives system name (entryValues args) (value.mapAddress encode) := by + obtain ⟨encode, distinct⟩ := heap_address_embedding heap capacity + exact ⟨encode, q.heap_complete selected compiled (Source.run_spec executed).2 encode distinct⟩ + +/-- Native evaluation produces a finite sequence accepted by the integer +one-for-one row checker, under the finite-field address-capacity condition. -/ +theorem Specialized.checker_heap_complete [Fintype F] (q : Specialized s entries) + (selected : name ∈ entries) {system : Aiur.Circuit.System F} + (compiled : Aiur.Circuit.compile q.program = .ok system) (wellFormed : system.WellFormed) + (evaluated : SourceSemantics.EvalFn s.world name args [] value heap) + (capacity : heap.length ≤ Fintype.card F) : + ∃ (encode : Nat → F), ∃ wires output rom rows, + DecodesValues system.enums wires (entryValues args) ∧ + output.decode system.enums = some (value.mapAddress encode) ∧ + system.check rom ⟨name, wires, output⟩ rows = .ok () := by + obtain ⟨encode, distinct⟩ := heap_address_embedding heap capacity + obtain ⟨wires, output, arguments, decoded, derived⟩ := q.heap_complete selected compiled evaluated encode distinct + obtain ⟨rom, rows, checked⟩ := (system.check_entry_iff wellFormed).mpr derived + exact ⟨encode, wires, output, rom, rows, arguments, decoded, checked⟩ + +/-- The same native evaluation also produces accepted memoized rows. Cycles +are permitted by that checker; completeness needs no acyclicity assumption. -/ +theorem Specialized.checkerMemo_heap_complete [Fintype F] (q : Specialized s entries) + (selected : name ∈ entries) {system : Aiur.Circuit.System F} + (compiled : Aiur.Circuit.compile q.program = .ok system) (wellFormed : system.WellFormed) + (evaluated : SourceSemantics.EvalFn s.world name args [] value heap) + (capacity : heap.length ≤ Fintype.card F) : + ∃ (encode : Nat → F), ∃ wires output rom rows, + DecodesValues system.enums wires (entryValues args) ∧ + output.decode system.enums = some (value.mapAddress encode) ∧ + system.checkMemo rom ⟨name, wires, output⟩ rows = .ok () := by + obtain ⟨encode, distinct⟩ := heap_address_embedding heap capacity + obtain ⟨wires, output, arguments, decoded, derived⟩ := + (q.heap_complete selected compiled evaluated encode distinct).memo + obtain ⟨rom, rows, checked⟩ := (system.checkMemo_entry_iff wellFormed).mpr derived + exact ⟨encode, wires, output, rom, rows, arguments, decoded, checked⟩ + +theorem Specialized.checker_run_complete [Fintype F] (q : Specialized s entries) + (selected : name ∈ entries) {system : Aiur.Circuit.System F} + (compiled : Aiur.Circuit.compile q.program = .ok system) (wellFormed : system.WellFormed) + {hints : s.HintProvider} + (executed : s.run name args fuel hints = .ok (value, heap)) (capacity : heap.length ≤ Fintype.card F) : + ∃ (encode : Nat → F), ∃ wires output rom rows, + DecodesValues system.enums wires (entryValues args) ∧ + output.decode system.enums = some (value.mapAddress encode) ∧ + system.check rom ⟨name, wires, output⟩ rows = .ok () := + q.checker_heap_complete selected compiled wellFormed (Source.run_spec executed).2 capacity + +theorem Specialized.checkerMemo_run_complete [Fintype F] (q : Specialized s entries) + (selected : name ∈ entries) {system : Aiur.Circuit.System F} + (compiled : Aiur.Circuit.compile q.program = .ok system) (wellFormed : system.WellFormed) + {hints : s.HintProvider} + (executed : s.run name args fuel hints = .ok (value, heap)) (capacity : heap.length ≤ Fintype.card F) : + ∃ (encode : Nat → F), ∃ wires output rom rows, + DecodesValues system.enums wires (entryValues args) ∧ + output.decode system.enums = some (value.mapAddress encode) ∧ + system.checkMemo rom ⟨name, wires, output⟩ rows = .ok () := + q.checkerMemo_heap_complete selected compiled wellFormed (Source.run_spec executed).2 capacity + +/-- A circuit derivation realizes an evaluation of the original generic source. +Pointer addresses are related through the ROM, not equated with source addresses. -/ +theorem Specialized.heap_sound (q : Specialized s entries) (selected : name ∈ entries) + {system : Aiur.Circuit.System F} (compiled : Aiur.Circuit.compile q.program = .ok system) + {rom : WireROM F} (valid : rom.Valid) + {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F} + (derived : Aiur.Circuit.CircuitEvaluates system rom name wires output) + (arguments : DecodesValues q.program.enums wires (entryValues args)) + (decoded : output.decode q.program.enums = some result) : + ∃ value heap, SourceSemantics.EvalFn s.world name args [] value heap ∧ + Represents (rom.decode q.program.enums) heap value result := by + have entry := (q.valid.2.2.2.2.2.2.2 name selected).2.2 + obtain ⟨value, heap, evaluated, related⟩ := + compiler_heap_sound compiled valid entry derived arguments decoded + exact ⟨value, heap, q.native_entry_sound selected evaluated, related⟩ + +/-- Sharing is allowed; acyclicity of this finite graph replaces any source +totality requirement. -/ +theorem Specialized.memo_acyclic_heap_sound (q : Specialized s entries) (selected : name ∈ entries) + {system : Aiur.Circuit.System F} (compiled : Aiur.Circuit.compile q.program = .ok system) + {rom : WireROM F} (valid : rom.Valid) + {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F} + (graph : Aiur.Circuit.MemoDerivation system rom ⟨name, wires, output⟩) (acyclic : graph.Acyclic) + (arguments : DecodesValues q.program.enums wires (entryValues args)) + (decoded : output.decode q.program.enums = some result) : + ∃ value heap, SourceSemantics.EvalFn s.world name args [] value heap ∧ + Represents (rom.decode q.program.enums) heap value result := + q.heap_sound selected compiled valid (graph.derives_of_acyclic acyclic) arguments decoded + +/-- Integer unit balance, including redundant rows, implies evaluation on the +original source AST. No source-to-core equivalence is assumed. -/ +theorem Specialized.checker_heap_sound (q : Specialized s entries) (selected : name ∈ entries) + {system : Aiur.Circuit.System F} (compiled : Aiur.Circuit.compile q.program = .ok system) + {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} + {wires : List (WireValue F)} {output : WireValue F} {rows : List (Aiur.Circuit.Row F)} + (checked : system.check rom ⟨name, wires, output⟩ rows = .ok ()) + (arguments : DecodesValues q.program.enums wires (entryValues args)) + (decoded : output.decode q.program.enums = some result) : + ∃ value heap, SourceSemantics.EvalFn s.world name args [] value heap ∧ + Represents (rom.decode q.program.enums) heap value result := by + have entry := (q.valid.2.2.2.2.2.2.2 name selected).2.2 + obtain ⟨value, heap, evaluated, related⟩ := Aiur.checker_heap_sound compiled checked entry arguments decoded + exact ⟨value, heap, q.native_entry_sound selected evaluated, related⟩ + +/-- Conditional soundness for weighted rows. Acceptance supplies a closed +support graph; the additional condition concerns that graph's edges, not +termination or totality of the source program. -/ +theorem Specialized.checkerMemo_acyclic_heap_sound (q : Specialized s entries) (selected : name ∈ entries) + {system : Aiur.Circuit.System F} (compiled : Aiur.Circuit.compile q.program = .ok system) + {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} + {wires : List (WireValue F)} {output : WireValue F} {rows : List (Aiur.Circuit.WeightedRow F)} + (checked : system.checkMemo rom ⟨name, wires, output⟩ rows = .ok ()) + (acyclic : (Classical.choice (system.checkMemo_sound checked)).Acyclic) + (arguments : DecodesValues q.program.enums wires (entryValues args)) + (decoded : output.decode q.program.enums = some result) : + ∃ value heap, SourceSemantics.EvalFn s.world name args [] value heap ∧ + Represents (rom.decode q.program.enums) heap value result := + q.memo_acyclic_heap_sound selected compiled + (Aiur.Circuit.System.checkContext_iff.mp (Aiur.Circuit.System.checkMemo_iff.mp checked).1).2.2.1 + (Classical.choice (system.checkMemo_sound checked)) acyclic arguments decoded + +/-- Inlining is downstream of the native source predicate. -/ +theorem Compiled.native_entry_iff {q : Specialized s entries} (c : Compiled q) + (selected : name ∈ entries) : + SourceSemantics.EvalFn s.world name args [] result heap ↔ + Aiur.EvalFn c.program name args [] result heap := + (q.native_entry_iff selected).trans (c.inlined.entry_iff selected) + +theorem Compiled.heap_complete {q : Specialized s entries} (c : Compiled q) + (selected : name ∈ entries) + (evaluated : SourceSemantics.EvalFn s.world name args [] value heap) (encode : Nat → F) + (distinct : ∀ i j, i < heap.length → j < heap.length → encode i = encode j → i = j) : + Aiur.Circuit.EncodedEntryDerives c.system name (entryValues args) (value.mapAddress encode) := + compiler_heap_complete c.compiled (c.inlined.valid.2.2 name selected).2 + ((c.native_entry_iff selected).mp evaluated) encode distinct + +theorem Compiled.heap_sound {q : Specialized s entries} (c : Compiled q) (selected : name ∈ entries) + {rom : WireROM F} (valid : rom.Valid) + {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F} + (derived : Aiur.Circuit.CircuitEvaluates c.system rom name wires output) + (arguments : DecodesValues q.program.enums wires (entryValues args)) + (decoded : output.decode q.program.enums = some result) : + ∃ value heap, SourceSemantics.EvalFn s.world name args [] value heap ∧ + Represents (rom.decode q.program.enums) heap value result := by + obtain ⟨value,heap,evaluated,related⟩ := compiler_heap_sound c.compiled valid + (c.inlined.valid.2.2 name selected).2 derived arguments decoded + exact ⟨value,heap,(c.native_entry_iff selected).mpr evaluated,related⟩ + +theorem Compiled.checker_heap_complete [Fintype F] {q : Specialized s entries} (c : Compiled q) + (selected : name ∈ entries) (wellFormed : c.system.WellFormed) + (evaluated : SourceSemantics.EvalFn s.world name args [] value heap) (capacity : heap.length ≤ Fintype.card F) : + ∃ (encode : Nat → F), ∃ wires output rom rows, + DecodesValues c.system.enums wires (entryValues args) ∧ + output.decode c.system.enums = some (value.mapAddress encode) ∧ + c.system.check rom ⟨name,wires,output⟩ rows = .ok () := by + obtain ⟨encode,distinct⟩ := heap_address_embedding heap capacity + obtain ⟨wires,output,arguments,decoded,derived⟩ := c.heap_complete selected evaluated encode distinct + obtain ⟨rom,rows,checked⟩ := (c.system.check_entry_iff wellFormed).mpr derived + exact ⟨encode,wires,output,rom,rows,arguments,decoded,checked⟩ + +theorem Compiled.checkerMemo_heap_complete [Fintype F] {q : Specialized s entries} (c : Compiled q) + (selected : name ∈ entries) (wellFormed : c.system.WellFormed) + (evaluated : SourceSemantics.EvalFn s.world name args [] value heap) (capacity : heap.length ≤ Fintype.card F) : + ∃ (encode : Nat → F), ∃ wires output rom rows, + DecodesValues c.system.enums wires (entryValues args) ∧ + output.decode c.system.enums = some (value.mapAddress encode) ∧ + c.system.checkMemo rom ⟨name,wires,output⟩ rows = .ok () := by + obtain ⟨encode,distinct⟩ := heap_address_embedding heap capacity + obtain ⟨wires,output,arguments,decoded,derived⟩ := (c.heap_complete selected evaluated encode distinct).memo + obtain ⟨rom,rows,checked⟩ := (c.system.checkMemo_entry_iff wellFormed).mpr derived + exact ⟨encode,wires,output,rom,rows,arguments,decoded,checked⟩ + +theorem Compiled.checker_heap_sound {q : Specialized s entries} (c : Compiled q) (selected : name ∈ entries) + {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} + {wires : List (WireValue F)} {output : WireValue F} {rows : List (Aiur.Circuit.Row F)} + (checked : c.system.check rom ⟨name,wires,output⟩ rows = .ok ()) + (arguments : DecodesValues q.program.enums wires (entryValues args)) + (decoded : output.decode q.program.enums = some result) : + ∃ value heap, SourceSemantics.EvalFn s.world name args [] value heap ∧ + Represents (rom.decode q.program.enums) heap value result := by + obtain ⟨value,heap,evaluated,related⟩ := Aiur.checker_heap_sound c.compiled checked + (c.inlined.valid.2.2 name selected).2 arguments decoded + exact ⟨value,heap,(c.native_entry_iff selected).mpr evaluated,related⟩ + +theorem Compiled.checkerMemo_acyclic_heap_sound {q : Specialized s entries} (c : Compiled q) + (selected : name ∈ entries) + {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} + {wires : List (WireValue F)} {output : WireValue F} {rows : List (Aiur.Circuit.WeightedRow F)} + (checked : c.system.checkMemo rom ⟨name,wires,output⟩ rows = .ok ()) + (acyclic : (Classical.choice (c.system.checkMemo_sound checked)).Acyclic) + (arguments : DecodesValues q.program.enums wires (entryValues args)) + (decoded : output.decode q.program.enums = some result) : + ∃ value heap, SourceSemantics.EvalFn s.world name args [] value heap ∧ + Represents (rom.decode q.program.enums) heap value result := + c.heap_sound selected + (Aiur.Circuit.System.checkContext_iff.mp (Aiur.Circuit.System.checkMemo_iff.mp checked).1).2.2.1 + ((Classical.choice (c.system.checkMemo_sound checked)).derives_of_acyclic acyclic) arguments decoded + +/-- The public checker supplies the selected-entry condition, so its soundness +statement concludes the public predicate on the original source. -/ +theorem Compiled.check_sound {q : Specialized s entries} (c : Compiled q) + {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} + {wires : List (WireValue F)} {output : WireValue F} {rows : List (Aiur.Circuit.Row F)} + (checked : c.check rom ⟨name, wires, output⟩ rows = .ok ()) + (arguments : DecodesValues q.program.enums wires (entryValues args)) + (decoded : output.decode q.program.enums = some result) : + ∃ value heap, s.EvalCall name args value ∧ + Represents (rom.decode q.program.enums) heap value result := by + obtain ⟨selected, checked⟩ := c.check_iff.mp checked + obtain ⟨value, heap, evaluated, related⟩ := c.checker_heap_sound selected checked arguments decoded + exact ⟨value, heap, ⟨(q.valid.2.2.2.2.2.2.2 name selected).2.1, heap, evaluated⟩, related⟩ + +theorem Compiled.checkMemo_acyclic_sound {q : Specialized s entries} (c : Compiled q) + {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} + {wires : List (WireValue F)} {output : WireValue F} {rows : List (Aiur.Circuit.WeightedRow F)} + (checked : c.checkMemo rom ⟨name, wires, output⟩ rows = .ok ()) + (acyclic : (Classical.choice (c.system.checkMemo_sound (c.checkMemo_iff.mp checked).2)).Acyclic) + (arguments : DecodesValues q.program.enums wires (entryValues args)) + (decoded : output.decode q.program.enums = some result) : + ∃ value heap, s.EvalCall name args value ∧ + Represents (rom.decode q.program.enums) heap value result := by + obtain ⟨selected, accepted⟩ := c.checkMemo_iff.mp checked + obtain ⟨value, heap, evaluated, related⟩ := + c.checkerMemo_acyclic_heap_sound selected accepted acyclic arguments decoded + exact ⟨value, heap, ⟨(q.valid.2.2.2.2.2.2.2 name selected).2.1, heap, evaluated⟩, related⟩ + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/NativeCompleteness.lean b/Aiur/Aiur/Generic/NativeCompleteness.lean new file mode 100644 index 000000000..fabfd2873 --- /dev/null +++ b/Aiur/Aiur/Generic/NativeCompleteness.lean @@ -0,0 +1,105 @@ +import Aiur.Generic.LoweringCompleteness +import Aiur.Generic.PreparationFunctionFacts +import Aiur.Generic.SourceCallInduction +import Aiur.Generic.Correctness + +namespace Aiur.Generic + +theorem constantExpr_lower (value : Constant F) : (constantExpr value).lower [] = value.toExpr := by + cases value with + | field => simp only [constantExpr, Expr.lower, Constant.toExpr] + | ptr _ address => exact Empty.elim address + | tuple values | construct name ctor values => + simp only [constantExpr, Expr.lower, Constant.toExpr, Option.getD_some, List.map_nil, + Instance.symbol, List.isEmpty_nil, ↓reduceIte, List.map_map] + congr 1 + apply List.map_congr_left + intro value hv + exact constantExpr_lower value +termination_by sizeOf value + +theorem constantExpr_safe (value : Constant F) : (constantExpr value).lowerSafe [] := by + cases value with + | field => simp only [constantExpr, Expr.lowerSafe] + | ptr _ address => exact Empty.elim address + | tuple values | construct name ctor values => + simp only [constantExpr, Expr.lowerSafe, List.forall_mem_map] + intro value hv + exact constantExpr_safe value +termination_by sizeOf value + +theorem constantExpr_closed (value : Constant F) : Consts.Closed (constantExpr value) := by + cases value with + | field => simpa only [constantExpr] using (Consts.Closed.literal (F := F) (x := _)) + | ptr _ address => exact Empty.elim address + | tuple values | construct name ctor values => + simp only [constantExpr] + constructor + intro expr member + obtain ⟨value, hv, rfl⟩ := List.mem_map.mp member + exact constantExpr_closed value +termination_by sizeOf value + +theorem Specialized.prepare_complete [Field F] [DecidableEq F] {s : Source F} + (q : Specialized s entries) (reachable : name ∈ callableNames q.program) + (prepared : s.world.prepare name args = .ok (types, locals, expr)) + (evaluated : OpenSource.EvalExpr s.world (Engine.EvalFn s.coreWorld) + types locals expr before result after ∨ + OpenSource.EvalExit s.world (Engine.EvalFn s.coreWorld) types locals expr before .function result after) : + Engine.EvalFn s.coreWorld name args before result after := by + cases compiled : s.compilerFunction? name with + | none => + have sourceAbsent : s.program.sourceFunction? name = none := by + have ready := q.loweringReady name reachable + cases found : s.program.sourceFunction? name with + | none => rfl + | some _ => simp [found, compiled] at ready + simp only [Source.world, sourceWorld, sourceAbsent, except_bind_ok, except_pure_ok, + Prod.mk.injEq] at prepared + obtain ⟨value, found, rfl, rfl, rfl⟩ := prepared + have evaluated : OpenSource.EvalExpr s.world (Engine.EvalFn s.coreWorld) [] [] + (constantExpr value) before result after := by + rcases evaluated with normal | abrupt + · exact normal + · exact (abrupt.hasControl (constantExpr_closed value).noControl).elim + have lowered := lowering_complete (core := s.coreWorld) rfl evaluated (constantExpr_safe value) + rw [constantExpr_lower] at lowered + exact .intro (by simp [Source.coreWorld, compiled, found, bind, Except.bind, pure, Except.pure]) lowered.close + | some core => + obtain ⟨source, preparedBody, body, found, expanded, control, safe, params, bodyEq⟩ := Source.compilerFunction_spec compiled + have prepared : source.prepare s.program.enum? args = .ok (types, locals, expr) := by + simpa only [Source.world, sourceWorld, found] using prepared + obtain ⟨argTypes, formed, rfl, rfl, rfl⟩ := SourceFunction.prepare_iff.mp prepared + have expandedEval : OpenSource.EvalExpr s.world (Engine.EvalFn s.coreWorld) [] + ((source.params.map Prod.fst).zip args) preparedBody before result after ∨ + OpenSource.EvalExit s.world (Engine.EvalFn s.coreWorld) [] + ((source.params.map Prod.fst).zip args) preparedBody before .function result after := by + rcases evaluated with normal | abrupt + · exact .inl ((SourceSemantics.expression_preparation_open_iff s.program s.world + (fun _ _ => rfl) rfl _ _ _ expanded _ _ _ _).mp normal) + · exact .inr ((SourceSemantics.exit_preparation_open_iff s.program s.world + (fun _ _ => rfl) rfl _ _ _ expanded _ _ _ _ _).mp abrupt) + have controlEval := (ControlLower.function_correct control).mpr expandedEval + have lowered := lowering_complete (core := s.coreWorld) rfl controlEval safe + rw [← bodyEq] at lowered + refine .intro (locals := (source.params.map Prod.fst).zip args) (expr := core.body) ?_ lowered.close + simp only [Source.coreWorld, compiled, prepareFunction, params] + rw [if_pos ⟨argTypes, formed⟩] + +/-- Every finite evaluation of the original generic source has an evaluation +of the compiled instance with the identical value and allocation heap. Consts, +native arrays, pointer patterns and nondeterministic hints are all included. -/ +theorem Specialized.native_complete [Field F] [DecidableEq F] {s : Source F} + (q : Specialized s entries) (reachable : name ∈ callableNames q.program) + (evaluated : SourceSemantics.EvalFn s.world name args before result after) : + Engine.EvalFn s.coreWorld name args before result after := by + apply evaluated.openCalls q.sourceAgreement.closed + (fun n hn args ts ls e b v a prep ev => q.prepare_complete hn prep ev) reachable + +theorem Specialized.native_core_complete [Field F] [DecidableEq F] {s : Source F} + (q : Specialized s entries) (reachable : name ∈ callableNames q.program) + (evaluated : SourceSemantics.EvalFn s.world name args before result after) : + Aiur.EvalFn q.program name args before result after := + (q.coreEvalFn_iff reachable).mp (q.native_complete reachable evaluated) + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/NativeConstantFacts.lean b/Aiur/Aiur/Generic/NativeConstantFacts.lean new file mode 100644 index 000000000..9844f8dda --- /dev/null +++ b/Aiur/Aiur/Generic/NativeConstantFacts.lean @@ -0,0 +1,30 @@ +import Aiur.Generic.Runtime + +namespace Aiur.Generic.SourceSemantics + +theorem constant_evaluates [Field F] [DecidableEq F] (world : World F) (value : Constant F) + (types : Types) (locals : Environment F Nat) (heap : Heap F) : + EvalExpr world types locals (constantExpr value) heap value.toValue heap := by + have children (values : List (Constant F)) + (smaller : ∀ v ∈ values, sizeOf v < sizeOf value) : + EvalArgs world types locals (values.map constantExpr) heap (values.map (Value.mapAddress Empty.elim)) heap := by + induction values with + | nil => exact .nil + | cons v vs ih => + exact .cons (constant_evaluates world v types locals heap) + (ih (fun x hx => smaller x (by simp [hx]))) + cases value with + | field => simp only [constantExpr, Constant.toValue, Value.mapAddress]; exact .literal + | ptr _ address => exact Empty.elim address + | tuple values => + simpa only [constantExpr, Constant.toValue, Value.mapAddress] using + EvalExpr.tuple (children values (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega)) + | construct name ctor values => + simpa only [constantExpr, Constant.toValue, Value.mapAddress, instanceName, + Option.getD_some, List.map_nil, Instance.symbol, List.isEmpty_nil, ↓reduceIte] using + EvalExpr.construct (name := name) (args := some []) (ctor := ctor) + (children values (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega)) +termination_by sizeOf value +decreasing_by exact smaller _ (by simp) + +end Aiur.Generic.SourceSemantics diff --git a/Aiur/Aiur/Generic/NativeSoundness.lean b/Aiur/Aiur/Generic/NativeSoundness.lean new file mode 100644 index 000000000..fd74fa54b --- /dev/null +++ b/Aiur/Aiur/Generic/NativeSoundness.lean @@ -0,0 +1,116 @@ +import Aiur.Generic.LoweringSoundness +import Aiur.Generic.NativeCompleteness +import Aiur.Generic.NativeConstantFacts +import Aiur.Generic.CoreCallInduction +import Aiur.InputTypes + +namespace Aiur.Generic + +theorem Specialized.prepare_sound [Field F] [DecidableEq F] {s : Source F} + (q : Specialized s entries) {calls : CallRelation F} + (closed : ∀ n args b v a, calls n args b v a → Aiur.EvalFn q.program n args b v a) + (reflect : ∀ n args b v a, calls n args b v a → b.Good q.program.enums → + (∀ arg ∈ args, arg.Good q.program.enums) → SourceSemantics.EvalFn s.world n args b v a) + (reachable : name ∈ callableNames q.program) + (prepared : (Engine.World.ofProgram q.program).prepare name args = .ok (locals, expr)) + (evaluated : OpenCore.EvalExpr (.ofProgram q.program) calls locals expr before result after) + (heapGood : before.Good q.program.enums) + (argsGood : ∀ arg ∈ args, arg.Good q.program.enums) : + SourceSemantics.EvalFn s.world name args before result after := by + have prepared := (q.coreAgreement.prepare name reachable args locals expr).mpr prepared + cases compiled : s.compilerFunction? name with + | none => + have sourceAbsent : s.program.sourceFunction? name = none := by + have ready := q.loweringReady name reachable + cases found : s.program.sourceFunction? name with + | none => rfl + | some _ => simp [found, compiled] at ready + simp only [Source.coreWorld, compiled, except_bind_ok, except_pure_ok, Prod.mk.injEq] at prepared + obtain ⟨value, found, rfl, rfl⟩ := prepared + obtain ⟨rfl, rfl⟩ := Aiur.EvalExpr.constant_result value (evaluated.toProgram closed) + exact .intro (types := []) (locals := []) (expr := constantExpr value) + (by simp [Source.world, sourceWorld, sourceAbsent, found, bind, Except.bind, pure, Except.pure]) + (SourceSemantics.constant_evaluates s.world value [] [] after) + | some core => + obtain ⟨source, preparedBody, body, found, expanded, control, safe, params, bodyEq⟩ := Source.compilerFunction_spec compiled + have check := q.typedLowering name reachable + simp only [found, Option.all_some, expanded, control] at check + cases bodyChecked : body.checkLowerTypes q.program [] source.params with + | none => simp [bodyChecked] at check + | some type => + simp only [Source.coreWorld, compiled, prepareFunction, params] at prepared + split at prepared + · rename_i valid + obtain ⟨rfl, rfl⟩ := Prod.mk.inj (Except.ok.inj prepared) + rw [bodyEq] at evaluated + have localsGood : Environment.Good q.program.enums ((source.params.map Prod.fst).zip args) := + fun binding member => argsGood binding.2 (List.of_mem_zip member).2 + have native := lowering_sound (source := s.world) q.valid.1 closed reflect + (fun t ht v hv => (q.coreAgreement.hint t ht v).mpr hv) + body [] _ _ _ _ safe + (by rw [parameterTypes source.params args valid.1]; exact bodyChecked) + evaluated heapGood localsGood + rcases (ControlLower.function_correct control).mp native with normal | abrupt + · have original := (SourceSemantics.expression_preparation_open_iff s.program s.world + (fun _ _ => rfl) rfl _ _ _ expanded _ _ _ _).mpr normal + exact .intro (by simp only [Source.world, sourceWorld, found, SourceFunction.prepare, if_pos valid]) + original.close + · have original := (SourceSemantics.exit_preparation_open_iff s.program s.world + (fun _ _ => rfl) rfl _ _ _ expanded _ _ _ _ _).mpr abrupt + exact .returned (by simp only [Source.world, sourceWorld, found, SourceFunction.prepare, if_pos valid]) + original.close + · cases prepared + +/-- Reflection at any reachable instance, with the ordinary well-formed heap +and argument invariants. The proof inducts on the finite core evaluation; +recursive source functions need not be total. -/ +theorem Specialized.native_sound [Field F] [DecidableEq F] {s : Source F} + (q : Specialized s entries) (reachable : name ∈ callableNames q.program) + (evaluated : Aiur.EvalFn q.program name args before result after) + (heapGood : before.Good q.program.enums) (argsGood : ∀ arg ∈ args, arg.Good q.program.enums) : + SourceSemantics.EvalFn s.world name args before result after := by + let calls : CallRelation F := fun n args b v a => + Aiur.EvalFn q.program n args b v a ∧ + (b.Good q.program.enums → (∀ arg ∈ args, arg.Good q.program.enums) → + SourceSemantics.EvalFn s.world n args b v a) + have closed : ∀ n args b v a, calls n args b v a → Aiur.EvalFn q.program n args b v a := + fun _ _ _ _ _ h => h.1 + have reflect : ∀ n args b v a, calls n args b v a → b.Good q.program.enums → + (∀ arg ∈ args, arg.Good q.program.enums) → SourceSemantics.EvalFn s.world n args b v a := + fun _ _ _ _ _ h => h.2 + have lifted : Engine.EvalFn (.ofProgram q.program) name args before result after := Engine.core_iff.mpr evaluated + have conclusion : calls name args before result after := lifted.openCalls q.coreAgreement.symm.closed + (fun n hn args ls e b v a prepared body ev => + ⟨.intro prepared body.toCore, fun hg ag => q.prepare_sound closed reflect hn prepared ev hg ag⟩) reachable + exact conclusion.2 heapGood argsGood + +theorem Specialized.native_entry_sound [Field F] [DecidableEq F] {s : Source F} + (q : Specialized s entries) (selected : name ∈ entries) + (evaluated : Aiur.EvalFn q.program name args [] result heap) : + SourceSemantics.EvalFn s.world name args [] result heap := by + have root := q.valid.2.2.2.2.2.2.2 name selected + exact q.native_sound root.1 evaluated (by simp [Heap.Good]) (fun arg member => + ⟨(evaluated.publicArguments root.2.2 arg member).2, + Value.pointerNames_of_free (evaluated.public_pointerFree root.2.2 arg member)⟩) + +/-- Selected entrypoint claims have identical finite source and compiled +evaluations, with the exact same result and allocation heap. -/ +theorem Specialized.native_entry_iff [Field F] [DecidableEq F] {s : Source F} + (q : Specialized s entries) (selected : name ∈ entries) : + SourceSemantics.EvalFn s.world name args [] result heap ↔ + Aiur.EvalFn q.program name args [] result heap := + ⟨q.native_core_complete (q.valid.2.2.2.2.2.2.2 name selected).1, q.native_entry_sound selected⟩ + +/-- The public claim predicates agree before and after compiler preparation. +The selected interface is external to the original source program. -/ +theorem Specialized.native_evalCall_iff [Field F] [DecidableEq F] {s : Source F} + (q : Specialized s entries) (selected : name ∈ entries) : + s.EvalCall name args result ↔ Aiur.EvalCall q.program name args result := by + have entry := q.valid.2.2.2.2.2.2.2 name selected + constructor + · rintro ⟨_, heap, evaluated⟩ + exact ⟨entry.2.2, heap, (q.native_entry_iff selected).mp evaluated⟩ + · rintro ⟨_, heap, evaluated⟩ + exact ⟨entry.2.1, heap, (q.native_entry_iff selected).mpr evaluated⟩ + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/OpenCore.lean b/Aiur/Aiur/Generic/OpenCore.lean new file mode 100644 index 000000000..9db3b8093 --- /dev/null +++ b/Aiur/Aiur/Generic/OpenCore.lean @@ -0,0 +1,145 @@ +import Aiur.Generic.Engine + +/-! A proof interface for expression evaluation with calls left as premises. +It adds no compiler or execution phase. Closing the premises with `EvalFn` +recovers the existing evaluator exactly. -/ + +namespace Aiur.Generic + +abbrev CallRelation (F : Type) := + String → List (SourceValue F) → Heap F → SourceValue F → Heap F → Prop + +namespace OpenCore + +mutual + /-- Finite source evaluation threads a fresh-allocation heap, with no fuel. -/ + inductive EvalExpr [Field F] [DecidableEq F] (world : Engine.World F) (calls : CallRelation F) : + Environment F Nat → Aiur.Expr F → Heap F → SourceValue F → Heap F → Prop where + | literal : EvalExpr world calls locals (.literal value) heap (.field value) heap + | var (lookup : locals.find? (·.1 == name) = some (name, value)) : + EvalExpr world calls locals (.var name) heap value heap + | tuple (items : EvalArgs world calls locals exprs before values after) : + EvalExpr world calls locals (.tuple exprs) before (.tuple values) after + | construct (items : EvalArgs world calls locals exprs before values after) : + EvalExpr world calls locals (.construct name ctor exprs) before (.construct name ctor values) after + | project (value : EvalExpr world calls locals expr before input after) + (projected : projectValue input index = .ok result) : + EvalExpr world calls locals (.project expr index) before result after + | letValue (value : EvalExpr world calls locals expr before input middle) + (matched : pattern.bindings input = some bindings) + (body : EvalExpr world calls (bindings ++ locals) rest middle result after) : + EvalExpr world calls locals (.letValue pattern expr rest) before result after + | store (value : EvalExpr world calls locals expr before input middle) : + EvalExpr world calls locals (.store expr) before (.ptr input.type middle.length) (middle ++ [input]) + | load (pointer : EvalExpr world calls locals expr before input after) + (loaded : loadValue after input = .ok result) : + EvalExpr world calls locals (.load expr) before result after + | hint (key : EvalExpr world calls locals expr before input after) + {value : Constant F} (typed : world.typed type value = true) : + EvalExpr world calls locals (.hint type expr channel) before value.toValue after + | neg (value : EvalExpr world calls locals expr before input after) + (operation : evalNeg input = .ok result) : + EvalExpr world calls locals (.neg expr) before result after + | assertEq (left : EvalExpr world calls locals lhs before x middle) + (right : EvalExpr world calls locals rhs middle y after) + (operation : evalAssertEq op x y = .ok result) : + EvalExpr world calls locals (.assertEq op lhs rhs) before result after + | binary (left : EvalExpr world calls locals lhs before x middle) + (right : EvalExpr world calls locals rhs middle y after) + (operation : evalBinOp op x y = .ok result) : + EvalExpr world calls locals (.binary op lhs rhs) before result after + | call (arguments : EvalArgs world calls locals args before values middle) + (callee : calls name values middle result after) : + EvalExpr world calls locals (.call name args) before result after + | matchValue (value : EvalExpr world calls locals expr before input middle) + (selected : selectArm input arms = some (bindings, body)) + (branch : EvalExpr world calls (bindings ++ locals) body middle result after) : + EvalExpr world calls locals (.matchValue expr arms) before result after + + inductive EvalArgs [Field F] [DecidableEq F] (world : Engine.World F) (calls : CallRelation F) : + Environment F Nat → List (Aiur.Expr F) → Heap F → List (SourceValue F) → Heap F → Prop where + | nil : EvalArgs world calls locals [] heap [] heap + | cons (head : EvalExpr world calls locals expr before value middle) + (tail : EvalArgs world calls locals exprs middle values after) : + EvalArgs world calls locals (expr :: exprs) before (value :: values) after + +end + +variable [Field F] [DecidableEq F] {world : Engine.World F} {calls other : CallRelation F} + +theorem EvalExpr.mapCalls + (h : EvalExpr world calls locals expr before result after) + (transfer : ∀ n args b v a, calls n args b v a → other n args b v a) : + EvalExpr world other locals expr before result after := by + induction h using EvalExpr.rec + (motive_2 := fun ls es b vs a _ => EvalArgs world other ls es b vs a) with + | literal => exact .literal + | var h => exact .var h + | tuple _ ih => exact .tuple ih + | construct _ ih => exact .construct ih + | project _ h ih => exact .project ih h + | letValue _ h _ ih1 ih2 => exact .letValue ih1 h ih2 + | store _ ih => exact .store ih + | load _ h ih => exact .load ih h + | hint _ h ih => exact .hint ih h + | neg _ h ih => exact .neg ih h + | assertEq _ _ h ih1 ih2 => exact .assertEq ih1 ih2 h + | binary _ _ h ih1 ih2 => exact .binary ih1 ih2 h + | matchValue _ h _ ih1 ih2 => exact .matchValue ih1 h ih2 + | nil => exact .nil + | cons _ _ ih1 ih2 => exact .cons ih1 ih2 + | call _ callee ih => exact .call ih (transfer _ _ _ _ _ callee) + +theorem EvalExpr.close + (h : EvalExpr world (Engine.EvalFn world) locals expr before result after) : + Engine.EvalExpr world locals expr before result after := by + induction h using EvalExpr.rec + (motive_2 := fun ls es b vs a _ => Engine.EvalArgs world ls es b vs a) with + | literal => exact .literal + | var h => exact .var h + | tuple _ ih => exact .tuple ih + | construct _ ih => exact .construct ih + | project _ h ih => exact .project ih h + | letValue _ h _ ih1 ih2 => exact .letValue ih1 h ih2 + | store _ ih => exact .store ih + | load _ h ih => exact .load ih h + | hint _ h ih => exact .hint ih h + | neg _ h ih => exact .neg ih h + | assertEq _ _ h ih1 ih2 => exact .assertEq ih1 ih2 h + | binary _ _ h ih1 ih2 => exact .binary ih1 ih2 h + | matchValue _ h _ ih1 ih2 => exact .matchValue ih1 h ih2 + | nil => exact .nil + | cons _ _ ih1 ih2 => exact .cons ih1 ih2 + | call _ callee ih => exact .call ih callee + +theorem of_closed + (h : Engine.EvalExpr world locals expr before result after) : + EvalExpr world (Engine.EvalFn world) locals expr before result after := by + induction h using Engine.EvalExpr.rec + (motive_2 := fun ls es b vs a _ => EvalArgs world (Engine.EvalFn world) ls es b vs a) + (motive_3 := fun _ _ _ _ _ _ => True) with + | literal => exact .literal + | var h => exact .var h + | tuple _ ih => exact .tuple ih + | construct _ ih => exact .construct ih + | project _ h ih => exact .project ih h + | letValue _ h _ ih1 ih2 => exact .letValue ih1 h ih2 + | store _ ih => exact .store ih + | load _ h ih => exact .load ih h + | hint _ h ih => exact .hint ih h + | neg _ h ih => exact .neg ih h + | assertEq _ _ h ih1 ih2 => exact .assertEq ih1 ih2 h + | binary _ _ h ih1 ih2 => exact .binary ih1 ih2 h + | matchValue _ h _ ih1 ih2 => exact .matchValue ih1 h ih2 + | nil => exact .nil + | cons _ _ ih1 ih2 => exact .cons ih1 ih2 + | call _ callee ih _ => exact .call ih callee + | intro => trivial + +theorem closed_iff : + EvalExpr world (Engine.EvalFn world) locals expr before result after ↔ + Engine.EvalExpr world locals expr before result after := + ⟨EvalExpr.close, of_closed⟩ + +end OpenCore +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/OpenSource.lean b/Aiur/Aiur/Generic/OpenSource.lean new file mode 100644 index 000000000..d469323d1 --- /dev/null +++ b/Aiur/Aiur/Generic/OpenSource.lean @@ -0,0 +1,279 @@ +import Aiur.Generic.OpenCore +import Aiur.Generic.SourceSemantics + +/-! Native expression and exit evaluation with function calls left as premises. +Closing those premises recovers the authoritative source predicate exactly. -/ +namespace Aiur.Generic.OpenSource +open SourceSemantics + +mutual + inductive EvalExpr [Field F] [DecidableEq F] (world : SourceSemantics.World F) (calls : CallRelation F) : + Types → Environment F Nat → Expr F → Heap F → SourceValue F → Heap F → Prop where + | block (body : EvalExpr world calls types locals expr before result after) : + EvalExpr world calls types locals (.control (.block label) expr) before result after + | blockExit (body : EvalExit world calls types locals expr before (.block label) result after) : + EvalExpr world calls types locals (.control (.block label) expr) before result after + | literal : EvalExpr world calls types locals (.literal value) heap (.field value) heap + | var (lookup : locals.find? (·.1 == name) = some (name, value)) : + EvalExpr world calls types locals (.var name) heap value heap + | global + (lookup : world.constant name (type.subst types) = .ok pattern) + (interpreted : Consts.toExpr pattern = .ok body) + (value : EvalExpr world calls [] [] body before result after) : + EvalExpr world calls types locals (.global name (some type)) before result after + | tuple (items : EvalArgs world calls types locals exprs before values after) : + EvalExpr world calls types locals (.tuple exprs) before (.tuple values) after + | array (items : EvalArgs world calls types locals exprs before values after) : + EvalExpr world calls types locals (.array exprs) before (.tuple values) after + | «repeat» (value : EvalExpr world calls types locals expr before input after) : + EvalExpr world calls types locals (.repeat expr length) before (.tuple (List.replicate length input)) after + | index (value : EvalExpr world calls types locals expr before input after) + (projected : projectValue input index = .ok result) : + EvalExpr world calls types locals (.index expr index) before result after + | slice (value : EvalExpr world calls types locals expr before input after) + (sliced : sliceValue input start stop = .ok result) : + EvalExpr world calls types locals (.slice expr start stop) before result after + | builtin (items : EvalArgs world calls types locals exprs before values after) + (applied : operation.apply values = .ok result) : + EvalExpr world calls types locals (.builtin operation exprs) before result after + | update (items : EvalArgs world calls types locals exprs before values after) + (updated : Update.value types paths values = .ok result) : + EvalExpr world calls types locals (.update paths exprs) before result after + | record (items : EvalArgs world calls types locals exprs before values after) : + EvalExpr world calls types locals (.record head exprs) before + (.construct (constructorName types head.type) structConstructor (head.order values (.tuple []))) after + | member (value : EvalExpr world calls types locals expr before input after) + (projected : memberValue types field input = .ok result) : + EvalExpr world calls types locals (.member expr field) before result after + | construct (items : EvalArgs world calls types locals exprs before values after) : + EvalExpr world calls types locals (.construct name args ctor exprs) before (.construct (instanceName types name args) ctor values) after + | constructAs (items : EvalArgs world calls types locals exprs before values after) : + EvalExpr world calls types locals (.constructAs params t ctor exprs) before (.construct (constructorName types t) ctor values) after + | project (value : EvalExpr world calls types locals expr before input after) + (projected : projectValue input index = .ok result) : + EvalExpr world calls types locals (.project expr index) before result after + | letValue (value : EvalExpr world calls types locals expr before input middle) + (matched : world.matchPattern types middle pattern input = .ok (some bindings)) + (body : EvalExpr world calls types (bindings ++ locals) rest middle result after) : + EvalExpr world calls types locals (.letValue pattern expr rest) before result after + | store (value : EvalExpr world calls types locals expr before input middle) : + EvalExpr world calls types locals (.store expr) before (.ptr input.type middle.length) (middle ++ [input]) + | load (pointer : EvalExpr world calls types locals expr before input after) + (loaded : loadValue after input = .ok result) : + EvalExpr world calls types locals (.load expr) before result after + | hint (key : EvalExpr world calls types locals expr before input after) + {value : Constant F} (typed : world.typed (t.subst types).toCore value = true) : + EvalExpr world calls types locals (.hint t expr channel) before value.toValue after + | neg (value : EvalExpr world calls types locals expr before input after) + (operation : evalNeg input = .ok result) : + EvalExpr world calls types locals (.neg expr) before result after + | binary (left : EvalExpr world calls types locals lhs before x middle) + (right : EvalExpr world calls types locals rhs middle y after) + (operation : evalBinOp op x y = .ok result) : + EvalExpr world calls types locals (.binary op lhs rhs) before result after + | call (arguments : EvalArgs world calls types locals args before values middle) + (callee : calls (instanceName types name typeArgs) values middle result after) : + EvalExpr world calls types locals (.call name typeArgs args) before result after + | matchValue (value : EvalExpr world calls types locals expr before input middle) + (selected : SourceSemantics.selectArm world types middle input arms = .ok (some (bindings, body))) + (branch : EvalExpr world calls types (bindings ++ locals) body middle result after) : + EvalExpr world calls types locals (.matchValue expr arms) before result after + + inductive EvalArgs [Field F] [DecidableEq F] (world : SourceSemantics.World F) (calls : CallRelation F) : + Types → Environment F Nat → List (Expr F) → Heap F → List (SourceValue F) → Heap F → Prop where + | nil : EvalArgs world calls types locals [] heap [] heap + | cons (head : EvalExpr world calls types locals expr before value middle) + (tail : EvalArgs world calls types locals exprs middle values after) : + EvalArgs world calls types locals (expr :: exprs) before (value :: values) after + + /-- Abrupt evaluation preserves the heap prefix already executed. It carries + a lexical target and is caught only by that block or the current function. -/ + inductive EvalExit [Field F] [DecidableEq F] (world : SourceSemantics.World F) (calls : CallRelation F) : + Types → Environment F Nat → Expr F → Heap F → ExitTarget → SourceValue F → Heap F → Prop where + | exit (value : EvalExpr world calls types locals expr before result after) : + EvalExit world calls types locals (.control (.exit target) expr) before target result after + | exitPayload (value : EvalExit world calls types locals expr before target result after) : + EvalExit world calls types locals (.control (.exit outer) expr) before target result after + | fromBlock (different : target ≠ .block label) + (body : EvalExit world calls types locals expr before target result after) : + EvalExit world calls types locals (.control (.block label) expr) before target result after + | fromGlobal (lookup : world.constant name (type.subst types) = .ok pattern) + (interpreted : Consts.toExpr pattern = .ok body) + (value : EvalExit world calls [] [] body before target result after) : + EvalExit world calls types locals (.global name (some type)) before target result after + | fromTuple (items : EvalArgsExit world calls types locals exprs before target result after) : + EvalExit world calls types locals (.tuple exprs) before target result after + | fromArray (items : EvalArgsExit world calls types locals exprs before target result after) : + EvalExit world calls types locals (.array exprs) before target result after + | fromRepeat (value : EvalExit world calls types locals expr before target result after) : + EvalExit world calls types locals (.repeat expr length) before target result after + | fromIndex (value : EvalExit world calls types locals expr before target result after) : + EvalExit world calls types locals (.index expr index) before target result after + | fromSlice (value : EvalExit world calls types locals expr before target result after) : + EvalExit world calls types locals (.slice expr start stop) before target result after + | fromBuiltin (items : EvalArgsExit world calls types locals exprs before target result after) : + EvalExit world calls types locals (.builtin operation exprs) before target result after + | fromUpdate (items : EvalArgsExit world calls types locals exprs before target result after) : + EvalExit world calls types locals (.update paths exprs) before target result after + | fromRecord (items : EvalArgsExit world calls types locals exprs before target result after) : + EvalExit world calls types locals (.record head exprs) before target result after + | fromMember (value : EvalExit world calls types locals expr before target result after) : + EvalExit world calls types locals (.member expr field) before target result after + | fromConstruct (items : EvalArgsExit world calls types locals exprs before target result after) : + EvalExit world calls types locals (.construct name args ctor exprs) before target result after + | fromConstructAs (items : EvalArgsExit world calls types locals exprs before target result after) : + EvalExit world calls types locals (.constructAs params t ctor exprs) before target result after + | fromProject (value : EvalExit world calls types locals expr before target result after) : + EvalExit world calls types locals (.project expr index) before target result after + | fromLetValue (value : EvalExit world calls types locals expr before target result after) : + EvalExit world calls types locals (.letValue pattern expr rest) before target result after + | letBody (value : EvalExpr world calls types locals expr before input middle) + (matched : world.matchPattern types middle pattern input = .ok (some bindings)) + (body : EvalExit world calls types (bindings ++ locals) rest middle target result after) : + EvalExit world calls types locals (.letValue pattern expr rest) before target result after + | fromStore (value : EvalExit world calls types locals expr before target result after) : + EvalExit world calls types locals (.store expr) before target result after + | fromLoad (value : EvalExit world calls types locals expr before target result after) : + EvalExit world calls types locals (.load expr) before target result after + | fromHint (value : EvalExit world calls types locals expr before target result after) : + EvalExit world calls types locals (.hint t expr channel) before target result after + | fromNeg (value : EvalExit world calls types locals expr before target result after) : + EvalExit world calls types locals (.neg expr) before target result after + | binaryLeft (value : EvalExit world calls types locals left before target result after) : + EvalExit world calls types locals (.binary op left right) before target result after + | binaryRight (left : EvalExpr world calls types locals lhs before input middle) + (right : EvalExit world calls types locals rhs middle target result after) : + EvalExit world calls types locals (.binary op lhs rhs) before target result after + | fromCall (arguments : EvalArgsExit world calls types locals args before target result after) : + EvalExit world calls types locals (.call name typeArgs args) before target result after + | fromMatchValue (value : EvalExit world calls types locals expr before target result after) : + EvalExit world calls types locals (.matchValue expr arms) before target result after + | matchBody (value : EvalExpr world calls types locals expr before input middle) + (selected : SourceSemantics.selectArm world types middle input arms = .ok (some (bindings, body))) + (branch : EvalExit world calls types (bindings ++ locals) body middle target result after) : + EvalExit world calls types locals (.matchValue expr arms) before target result after + + inductive EvalArgsExit [Field F] [DecidableEq F] (world : SourceSemantics.World F) (calls : CallRelation F) : + Types → Environment F Nat → List (Expr F) → Heap F → ExitTarget → SourceValue F → Heap F → Prop where + | head (value : EvalExit world calls types locals expr before target result after) : + EvalArgsExit world calls types locals (expr :: rest) before target result after + | tail (head : EvalExpr world calls types locals expr before value middle) + (tail : EvalArgsExit world calls types locals rest middle target result after) : + EvalArgsExit world calls types locals (expr :: rest) before target result after +end + +variable [Field F] [DecidableEq F] {world : SourceSemantics.World F} {calls other : CallRelation F} + +theorem EvalExpr.mapCalls + (h : EvalExpr world calls types locals expr before result after) + (transfer : ∀ n args b v a, calls n args b v a → other n args b v a) : + EvalExpr world other types locals expr before result after := by + induction h using EvalExpr.rec + (motive_2 := fun ts ls es b vs a _ => EvalArgs world other ts ls es b vs a) + (motive_3 := fun ts ls e b target v a _ => EvalExit world other ts ls e b target v a) + (motive_4 := fun ts ls es b target v a _ => EvalArgsExit world other ts ls es b target v a) + all_goals first + | solve | apply EvalExpr.block; assumption + | solve | apply EvalExpr.blockExit; assumption + | solve | apply EvalExpr.call; assumption; apply transfer; assumption + | solve | apply EvalExit.letBody <;> assumption + | solve | apply EvalExit.binaryRight <;> assumption + | solve | apply EvalExit.matchBody <;> assumption + | solve | apply EvalArgsExit.tail <;> assumption + | solve | constructor <;> assumption + +theorem EvalExpr.close + (h : EvalExpr world (SourceSemantics.EvalFn world) types locals expr before result after) : + SourceSemantics.EvalExpr world types locals expr before result after := by + induction h using EvalExpr.rec + (motive_2 := fun ts ls es b vs a _ => SourceSemantics.EvalArgs world ts ls es b vs a) + (motive_3 := fun ts ls e b target v a _ => SourceSemantics.EvalExit world ts ls e b target v a) + (motive_4 := fun ts ls es b target v a _ => SourceSemantics.EvalArgsExit world ts ls es b target v a) + all_goals first + | solve | apply SourceSemantics.EvalExpr.block; assumption + | solve | apply SourceSemantics.EvalExpr.blockExit; assumption + | solve | apply SourceSemantics.EvalExit.letBody <;> assumption + | solve | apply SourceSemantics.EvalExit.binaryRight <;> assumption + | solve | apply SourceSemantics.EvalExit.matchBody <;> assumption + | solve | apply SourceSemantics.EvalArgsExit.tail <;> assumption + | solve | constructor <;> assumption + +theorem of_closed + (h : SourceSemantics.EvalExpr world types locals expr before result after) : + EvalExpr world (SourceSemantics.EvalFn world) types locals expr before result after := by + induction h using SourceSemantics.EvalExpr.rec + (motive_2 := fun ts ls es b vs a _ => EvalArgs world (SourceSemantics.EvalFn world) ts ls es b vs a) + (motive_3 := fun _ _ _ _ _ _ => True) + (motive_4 := fun ts ls e b target v a _ => EvalExit world (SourceSemantics.EvalFn world) ts ls e b target v a) + (motive_5 := fun ts ls es b target v a _ => EvalArgsExit world (SourceSemantics.EvalFn world) ts ls es b target v a) + all_goals first + | solve | apply EvalExpr.block; assumption + | solve | apply EvalExpr.blockExit; assumption + | solve | apply EvalExit.letBody <;> assumption + | solve | apply EvalExit.binaryRight <;> assumption + | solve | apply EvalExit.matchBody <;> assumption + | solve | apply EvalArgsExit.tail <;> assumption + | solve | constructor <;> assumption + +theorem EvalExit.mapCalls + (h : EvalExit world calls types locals expr before target result after) + (transfer : ∀ n args b v a, calls n args b v a → other n args b v a) : + EvalExit world other types locals expr before target result after := by + induction h using EvalExit.rec + (motive_1 := fun ts ls e b v a _ => EvalExpr world other ts ls e b v a) + (motive_2 := fun ts ls es b vs a _ => EvalArgs world other ts ls es b vs a) + (motive_4 := fun ts ls es b target v a _ => EvalArgsExit world other ts ls es b target v a) + all_goals first + | solve | apply EvalExpr.block; assumption + | solve | apply EvalExpr.blockExit; assumption + | solve | apply EvalExpr.call; assumption; apply transfer; assumption + | solve | apply EvalExit.letBody <;> assumption + | solve | apply EvalExit.binaryRight <;> assumption + | solve | apply EvalExit.matchBody <;> assumption + | solve | apply EvalArgsExit.tail <;> assumption + | solve | constructor <;> assumption + +theorem EvalExit.close + (h : EvalExit world (SourceSemantics.EvalFn world) types locals expr before target result after) : + SourceSemantics.EvalExit world types locals expr before target result after := by + induction h using EvalExit.rec + (motive_1 := fun ts ls e b v a _ => SourceSemantics.EvalExpr world ts ls e b v a) + (motive_2 := fun ts ls es b vs a _ => SourceSemantics.EvalArgs world ts ls es b vs a) + (motive_4 := fun ts ls es b target v a _ => SourceSemantics.EvalArgsExit world ts ls es b target v a) + all_goals first + | solve | apply SourceSemantics.EvalExpr.block; assumption + | solve | apply SourceSemantics.EvalExpr.blockExit; assumption + | solve | apply SourceSemantics.EvalExit.letBody <;> assumption + | solve | apply SourceSemantics.EvalExit.binaryRight <;> assumption + | solve | apply SourceSemantics.EvalExit.matchBody <;> assumption + | solve | apply SourceSemantics.EvalArgsExit.tail <;> assumption + | solve | constructor <;> assumption + +theorem exit_of_closed + (h : SourceSemantics.EvalExit world types locals expr before target result after) : + EvalExit world (SourceSemantics.EvalFn world) types locals expr before target result after := by + induction h using SourceSemantics.EvalExit.rec + (motive_1 := fun ts ls e b v a _ => EvalExpr world (SourceSemantics.EvalFn world) ts ls e b v a) + (motive_2 := fun ts ls es b vs a _ => EvalArgs world (SourceSemantics.EvalFn world) ts ls es b vs a) + (motive_3 := fun _ _ _ _ _ _ => True) + (motive_5 := fun ts ls es b target v a _ => EvalArgsExit world (SourceSemantics.EvalFn world) ts ls es b target v a) + all_goals first + | solve | apply EvalExpr.block; assumption + | solve | apply EvalExpr.blockExit; assumption + | solve | apply EvalExit.letBody <;> assumption + | solve | apply EvalExit.binaryRight <;> assumption + | solve | apply EvalExit.matchBody <;> assumption + | solve | apply EvalArgsExit.tail <;> assumption + | solve | constructor <;> assumption + +theorem closed_iff : + EvalExpr world (SourceSemantics.EvalFn world) types locals expr before result after ↔ + SourceSemantics.EvalExpr world types locals expr before result after := + ⟨EvalExpr.close, of_closed⟩ + +theorem exit_closed_iff : + EvalExit world (SourceSemantics.EvalFn world) types locals expr before target result after ↔ + SourceSemantics.EvalExit world types locals expr before target result after := + ⟨EvalExit.close, exit_of_closed⟩ + +end Aiur.Generic.OpenSource diff --git a/Aiur/Aiur/Generic/OrPatternFacts.lean b/Aiur/Aiur/Generic/OrPatternFacts.lean new file mode 100644 index 000000000..e6124ae87 --- /dev/null +++ b/Aiur/Aiur/Generic/OrPatternFacts.lean @@ -0,0 +1,58 @@ +import Aiur.Generic.SourceSemantics +import Aiur.Generic.BindingOrderFacts + +namespace Aiur.Generic.SourceSemantics + +variable [DecidableEq F] {constant : String → Ty → Except EvalError (Pattern F)} + {depth : Nat} {types : Types} {heap : Heap F} {value : SourceValue F} + {left right : Pattern F} {layout : OrBindings} {bindings : Environment F Nat} + +/-- First-match choice is local to each or-pattern, including nested choices. -/ +theorem match_or_some_iff : + matchPatternWith constant depth types heap (.orElse left right layout) value = .ok (some bindings) ↔ + (∃ selected, + matchPatternWith constant depth types heap left value = .ok (some selected) ∧ + reorderBindings layout.names (List.range layout.names.length) selected = some bindings) ∨ + (matchPatternWith constant depth types heap left value = .ok none ∧ + ∃ selected, matchPatternWith constant depth types heap right value = .ok (some selected) ∧ + reorderBindings layout.names layout.rightOrder selected = some bindings) := by + cases hl : matchPatternWith constant depth types heap left value with + | error e => simp [matchPatternWith, hl, bind, Except.bind] + | ok selected => + cases selected with + | some first => + cases ordered : reorderBindings layout.names (List.range layout.names.length) first <;> + simp [matchPatternWith, hl, ordered, bind, Except.bind, pure, Except.pure] + | none => + cases hr : matchPatternWith constant depth types heap right value with + | error e => simp [matchPatternWith, hl, hr, Except.map, bind, Except.bind] + | ok selected => + cases selected with + | none => simp [matchPatternWith, hl, hr, Except.map, bind, Except.bind, pure, Except.pure] + | some second => + cases ordered : reorderBindings layout.names layout.rightOrder second <;> + simp [matchPatternWith, hl, hr, ordered, Except.map, bind, Except.bind, pure, Except.pure] + +/-- Neither an invalid load nor a malformed binding layout is a failed match. -/ +theorem match_or_none_iff : + matchPatternWith constant depth types heap (.orElse left right layout) value = .ok none ↔ + matchPatternWith constant depth types heap left value = .ok none ∧ + matchPatternWith constant depth types heap right value = .ok none := by + cases hl : matchPatternWith constant depth types heap left value with + | error e => simp [matchPatternWith, hl, bind, Except.bind] + | ok selected => + cases selected with + | some first => + cases ordered : reorderBindings layout.names (List.range layout.names.length) first <;> + simp [matchPatternWith, hl, ordered, bind, Except.bind, pure, Except.pure] + | none => + cases hr : matchPatternWith constant depth types heap right value with + | error e => simp [matchPatternWith, hl, hr, Except.map, bind, Except.bind] + | ok selected => + cases selected with + | none => simp [matchPatternWith, hl, hr, Except.map, bind, Except.bind, pure, Except.pure] + | some second => + cases ordered : reorderBindings layout.names layout.rightOrder second <;> + simp [matchPatternWith, hl, hr, ordered, Except.map, bind, Except.bind, pure, Except.pure] + +end Aiur.Generic.SourceSemantics diff --git a/Aiur/Aiur/Generic/PatternBindingsFacts.lean b/Aiur/Aiur/Generic/PatternBindingsFacts.lean new file mode 100644 index 000000000..7bbb956c3 --- /dev/null +++ b/Aiur/Aiur/Generic/PatternBindingsFacts.lean @@ -0,0 +1,225 @@ +import Aiur.Generic.PatternLowering +import Aiur.Generic.OpenCore +import Aiur.Generic.BindingOrderFacts +import Mathlib.Data.List.Forall2 + +namespace Aiur.Generic.PatternLowering + +variable {calls : CallRelation F} + + +def lookupValues (locals : Environment F Nat) : List String → Option (List (SourceValue F)) + | [] => some [] + | name :: names => do + let (_, value) ← locals.find? (·.1 == name) + return value :: (← lookupValues locals names) + +def resolveBindings (links : List (String × String)) (locals : Environment F Nat) : + Option (Environment F Nat) := + (lookupValues locals (links.map Prod.snd)).map ((links.map Prod.fst).zip ·) + +@[simp] theorem resolveBindings_nil : resolveBindings [] locals = some [] := rfl + +theorem resolveBindings_cons (user temp : String) (links : List (String × String)) + (locals : Environment F Nat) : + resolveBindings ((user, temp) :: links) locals = do + let (_, value) ← locals.find? (·.1 == temp) + return (user, value) :: (← resolveBindings links locals) := by + unfold resolveBindings + simp only [List.map_cons, lookupValues] + cases locals.find? (·.1 == temp) with + | none => rfl + | some pair => cases lookupValues locals (links.map Prod.snd) <;> rfl + +theorem resolveBindings_names {links : List (String × String)} + {locals bindings : Environment F Nat} (found : resolveBindings links locals = some bindings) : + bindings.map Prod.fst = links.map Prod.fst := by + induction links generalizing bindings with + | nil => simp_all + | cons link links ih => + rcases link with ⟨user, temp⟩ + rw [resolveBindings_cons] at found + cases head : locals.find? (·.1 == temp) with + | none => simp [head] at found + | some pair => + cases tail : resolveBindings links locals with + | none => simp [head, tail] at found + | some rest => + simp [head, tail] at found + subst bindings + simp only [List.map_cons, ih tail] + +theorem resolveBindings_append (left right : List (String × String)) (locals : Environment F Nat) : + resolveBindings (left ++ right) locals = do + return (← resolveBindings left locals) ++ (← resolveBindings right locals) := by + induction left with + | nil => + simp only [List.nil_append, resolveBindings_nil] + cases resolveBindings right locals <;> rfl + | cons pair left ih => + rcases pair with ⟨user, temp⟩ + rw [List.cons_append, resolveBindings_cons, resolveBindings_cons, ih] + cases locals.find? (·.1 == temp) <;> + cases resolveBindings left locals <;> cases resolveBindings right locals <;> rfl + +theorem resolveBindings_congr {links : List (String × String)} {left right : Environment F Nat} + (agree : ∀ name ∈ links.map Prod.snd, left.find? (·.1 == name) = right.find? (·.1 == name)) : + resolveBindings links left = resolveBindings links right := by + induction links with + | nil => rfl + | cons pair links ih => + rcases pair with ⟨user, temp⟩ + rw [resolveBindings_cons, resolveBindings_cons, agree temp (by simp), ih] + intro n hn; exact agree n (by simp [hn]) + +theorem lookupValues_length (found : lookupValues locals names = some values) : + names.length = values.length := by + induction names generalizing values with + | nil => simp [lookupValues] at found; subst values; rfl + | cons n ns ih => + cases head : locals.find? (·.1 == n) with + | none => simp [lookupValues, head] at found + | some pair => + cases tail : lookupValues locals ns with + | none => simp [lookupValues, List.mapM_cons, head, tail] at found + | some rest => + have same : pair.2 :: rest = values := by + simpa [lookupValues, List.mapM_cons, head, tail] using found + subst values + simp only [List.length_cons, ih tail] + +theorem bindingsList_binders [DecidableEq F] (names : List String) (values : List (SourceValue F)) + (lengths : names.length = values.length) : + Aiur.Pattern.bindingsList (names.map Aiur.Pattern.bind) values = some (names.zip values) := by + induction names generalizing values with + | nil => cases values <;> simp_all [Aiur.Pattern.bindingsList] + | cons name names ih => + cases values with + | nil => simp at lengths + | cons value values => + have len : names.length = values.length := by simpa using lengths + simp [Aiur.Pattern.bindingsList, Aiur.Pattern.bindings, ih values len] + +theorem bindingsList_binders_eq [DecidableEq F] (names : List String) (values : List (SourceValue F)) : + Aiur.Pattern.bindingsList (names.map Aiur.Pattern.bind) values = + if names.length = values.length then some (names.zip values) else none := by + induction names generalizing values with + | nil => cases values <;> simp [Aiur.Pattern.bindingsList] + | cons name names ih => + cases values with + | nil => simp [Aiur.Pattern.bindingsList] + | cons value values => + by_cases same : names.length = values.length <;> + simp [Aiur.Pattern.bindingsList, Aiur.Pattern.bindings, ih values, same] + +theorem lookup_zip [DecidableEq F] (names : List String) (values : List (SourceValue F)) + (locals : Environment F Nat) (unique : names.Nodup) (lengths : names.length = values.length) : + List.Forall₂ (fun name value => ((names.zip values) ++ locals).find? (·.1 == name) = some (name, value)) names values := by + induction names generalizing values with + | nil => cases values <;> simp_all + | cons name names ih => + cases values with + | nil => simp at lengths + | cons value values => + obtain ⟨absent, unique⟩ := List.nodup_cons.mp unique + have lengths : names.length = values.length := by simpa using lengths + have tail := ih values unique lengths + apply List.Forall₂.cons (by simp) + have withMem : List.Forall₂ (fun n v => n ∈ names ∧ + ((names.zip values) ++ locals).find? (·.1 == n) = some (n, v)) names values := + (List.forall₂_and_left _ _).mpr ⟨fun _ h => h, tail⟩ + apply withMem.imp + intro n v h + have ne : name ≠ n := by intro equal; apply absent; simpa only [equal] using h.1 + simpa [List.find?, ne] using h.2 + +variable [Field F] [DecidableEq F] {world : Engine.World F} + +theorem evalVars_iff {locals : Environment F Nat} {names : List String} + {values : List (SourceValue F)} {before after : Heap F} : + OpenCore.EvalArgs world calls locals (names.map Aiur.Expr.var) before values after ↔ + lookupValues locals names = some values ∧ after = before := by + induction names generalizing before values with + | nil => + constructor + · intro h; cases h; exact ⟨rfl, rfl⟩ + · rintro ⟨h, rfl⟩ + have same : values = [] := by simpa [lookupValues] using h.symm + subst values; exact .nil + | cons name names ih => + constructor + · intro h; cases h with + | cons head tail => + cases head with + | var found => + obtain ⟨rest, rfl⟩ := ih.mp tail + exact ⟨by simp [lookupValues, List.mapM_cons, found, rest], rfl⟩ + · rintro ⟨h, rfl⟩ + cases head : locals.find? (·.1 == name) with + | none => simp [lookupValues, List.mapM_cons, head] at h + | some pair => + rcases pair with ⟨n, value⟩ + have same : n = name := by simpa using List.find?_some head + subst n + cases rest : lookupValues locals names with + | none => simp [lookupValues, List.mapM_cons, head, rest] at h + | some vs => + have same : value :: vs = values := by + simpa [lookupValues, List.mapM_cons, head, rest] using h + subst values + exact .cons (.var head) (ih.mpr ⟨rest, rfl⟩) + +/-- User bindings are installed together, after all matching steps finish. +Reading every temporary before installing any user name avoids capture and +preserves the source matcher's left-to-right binding order. -/ +theorem bindUsers_iff {bindings : List (String × String)} {locals : Environment F Nat} + {body : Aiur.Expr F} {before after : Heap F} {result : SourceValue F} : + OpenCore.EvalExpr world calls locals (bindUsers bindings body) before result after ↔ + ∃ values, lookupValues locals (bindings.map Prod.snd) = some values ∧ + OpenCore.EvalExpr world calls (((bindings.map Prod.fst).zip values) ++ locals) body before result after := by + have sources : bindings.map (fun b => (Aiur.Expr.var b.2 : Aiur.Expr F)) = + (bindings.map Prod.snd).map Aiur.Expr.var := by simp only [List.map_map, Function.comp_def] + have names : bindings.map (fun b => (Aiur.Pattern.bind b.1 : Aiur.Pattern F)) = + (bindings.map Prod.fst).map Aiur.Pattern.bind := by simp only [List.map_map, Function.comp_def] + constructor + · intro h; cases h with + | letValue tuple matched body => + cases tuple with + | tuple items => + rename_i values + rw [sources] at items + obtain ⟨found, rfl⟩ := evalVars_iff.mp items + have len : (bindings.map Prod.fst).length = values.length := by + simpa only [List.length_map] using lookupValues_length found + have bs := bindingsList_binders (bindings.map Prod.fst) _ len + simp only [Aiur.Pattern.bindings, names, bs, Option.some.injEq] at matched + subst_vars + exact ⟨_, found, body⟩ + · rintro ⟨values, found, body⟩ + have len : (bindings.map Prod.fst).length = values.length := by + simpa only [List.length_map] using lookupValues_length found + apply OpenCore.EvalExpr.letValue (bindings := (bindings.map Prod.fst).zip values) + · apply OpenCore.EvalExpr.tuple + rw [sources] + exact evalVars_iff.mpr ⟨found, rfl⟩ + · simp only [Aiur.Pattern.bindings, names, bindingsList_binders _ _ len] + · exact body + +theorem bindUsers_resolved_iff {links : List (String × String)} {locals : Environment F Nat} + {body : Aiur.Expr F} {before after : Heap F} {result : SourceValue F} : + OpenCore.EvalExpr world calls locals (bindUsers links body) before result after ↔ + ∃ bindings, resolveBindings links locals = some bindings ∧ + OpenCore.EvalExpr world calls (bindings ++ locals) body before result after := by + rw [bindUsers_iff] + constructor + · rintro ⟨values, found, body⟩ + exact ⟨_, by simp only [resolveBindings, found, Option.map_some], body⟩ + · rintro ⟨bindings, found, body⟩ + cases values : lookupValues locals (links.map Prod.snd) with + | none => simp [resolveBindings, values] at found + | some vs => + have same : (links.map Prod.fst).zip vs = bindings := by + simpa only [resolveBindings, values, Option.map_some, Option.some.injEq] using found + exact ⟨vs, rfl, by simpa only [same] using body⟩ + +end Aiur.Generic.PatternLowering diff --git a/Aiur/Aiur/Generic/PatternChecks.lean b/Aiur/Aiur/Generic/PatternChecks.lean new file mode 100644 index 000000000..418f3a7b2 --- /dev/null +++ b/Aiur/Aiur/Generic/PatternChecks.lean @@ -0,0 +1,78 @@ +import Aiur.Generic.Elaborate + +namespace Aiur.Generic + +private def checkLoadArms [BEq α] (enums : List EnumDecl) (caller : String) : + List (Pattern α) → List (Pattern α) → Except String Unit + | [], _ => pure () + | pat :: rest, seen => do + if seen.any (· == pat.condition) then throw s!"duplicate match pattern in '{caller}'" + if pat.irrefutable enums then return + checkLoadArms enums caller rest (pat.condition :: seen) + +private def hasChoices : Pattern α → Bool + | .orElse _ _ _ => true + | .load pat | .repeat pat _ => hasChoices pat + | .tuple ps | .array ps | .record _ ps | .construct _ _ ps | .constructAs _ _ _ ps => + (ps.map hasChoices).any id + | _ => false +termination_by pat => sizeOf pat + +private def alternatives : Pattern α → List (Pattern α) + | .orElse left right _ => alternatives left ++ alternatives right + | pat => [pat] + +/-- Alternatives remain in the AST. Check their original conditions before +compilation separates their tests, including collisions after field conversion. -/ +def checkPatternChoices [BEq α] (caller : String) : Pattern α → Except String Unit + | .orElse left right _ => do + let rec unique : List (Pattern α) → List (Pattern α) → Except String Unit + | [], _ => pure () + | pat :: rest, seen => do + if seen.any (· == pat.condition) then throw s!"duplicate or-pattern alternative in '{caller}'" + unique rest (pat.condition :: seen) + unique (alternatives left ++ alternatives right) [] + checkPatternChoices caller left + checkPatternChoices caller right + | .load pat | .repeat pat _ => checkPatternChoices caller pat + | .tuple ps | .array ps | .record _ ps | .construct _ _ ps | .constructAs _ _ _ ps => + ps.attach.forM (fun pat => checkPatternChoices caller pat.val) + | _ => pure () +termination_by pat => sizeOf pat +decreasing_by + all_goals simp_wf + all_goals first | omega | have := List.sizeOf_lt_of_mem pat.property; omega + +/-- Late lowering separates native pointer and or-patterns into ordinary matches. +Check original conditions before that happens, including field-literal collisions +when preparation is repeated after `toField`. Conditions following an +irrefutable arm are discarded, as in the core compiler. -/ +def checkLoadPatterns [DecidableEq α] (program : Program α) (caller : String) : Expr α → Except String Unit + | .literal _ | .var _ => pure () + | .global _ _ => pure () + | .builtin _ xs | .update _ xs | .record _ xs | .tuple xs | .array xs | .construct _ _ _ xs | .constructAs _ _ _ xs | .call _ _ xs => do + for x in xs do checkLoadPatterns program caller x + | .member x _ | .control _ x | .project x _ | .index x _ | .slice x _ _ | .repeat x _ | .store x | .load x | .hint _ x channel | .neg x => checkLoadPatterns program caller x + | .letValue pat x b => do + let _ : BEq α := ⟨fun x y => decide (x = y)⟩ + checkPatternChoices caller (← inspectPattern program 4096 pat) + checkLoadPatterns program caller x + checkLoadPatterns program caller b + | .binary _ x b => do + checkLoadPatterns program caller x + checkLoadPatterns program caller b + | .matchValue x arms => do + let _ : BEq α := ⟨fun x y => decide (x = y)⟩ + let patterns ← arms.mapM fun arm => inspectPattern program 4096 arm.1 + patterns.forM (checkPatternChoices caller) + if patterns.any (fun pat => pat.hasLoads || hasChoices pat) then + checkLoadArms program.nominals caller patterns [] + checkLoadPatterns program caller x + for arm in arms do checkLoadPatterns program caller arm.2 +termination_by e => sizeOf e +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; try simp_all only [Prod.mk.sizeOf_spec] + all_goals first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/PatternChoiceFacts.lean b/Aiur/Aiur/Generic/PatternChoiceFacts.lean new file mode 100644 index 000000000..f194027dd --- /dev/null +++ b/Aiur/Aiur/Generic/PatternChoiceFacts.lean @@ -0,0 +1,147 @@ +import Aiur.Generic.PatternTreeNames + +namespace Aiur.Generic.PatternLowering + +/-- Resolution relates every link to its value at the same position. -/ +theorem resolveBindings_relation {links} {locals bindings : Environment F Nat} + (resolved : resolveBindings links locals = some bindings) : + List.Forall₂ (fun link binding => link.1 = binding.1 ∧ + locals.find? (·.1 == link.2) = some (link.2, binding.2)) links bindings := by + induction links generalizing bindings with + | nil => simp only [resolveBindings_nil, Option.some.injEq] at resolved; subst bindings; exact .nil + | cons link links ih => + rcases link with ⟨user, temp⟩ + rw [resolveBindings_cons] at resolved + cases found : locals.find? (·.1 == temp) with + | none => simp [found] at resolved + | some pair => + have name : pair.1 = temp := by simpa using List.find?_some found + cases tail : resolveBindings links locals with + | none => simp [found, tail] at resolved + | some rest => + simp [found, tail] at resolved + subst bindings + refine .cons ⟨rfl, ?_⟩ (ih tail) + simpa only [← name] using found + +/-- Gathering positions before or after resolving links has the same result. -/ +theorem resolveBindings_reorder {links} {locals bindings : Environment F Nat} + (resolved : resolveBindings links locals = some bindings) (names positions) : + (reorderBindings names positions links).bind (resolveBindings · locals) = + reorderBindings names positions bindings := by + have rel := resolveBindings_relation resolved + have atIndex (index : Nat) : + match links[index]?, bindings[index]? with + | none, none => True + | some link, some binding => link.1 = binding.1 ∧ + locals.find? (·.1 == link.2) = some (link.2, binding.2) + | _, _ => False := by + clear resolved + induction rel generalizing index with + | nil => simp + | cons head tail ih => cases index <;> simp_all + induction names generalizing positions with + | nil => cases positions <;> rfl + | cons name names ih => + cases positions with + | nil => rfl + | cons index positions => + have cell := atIndex index + cases left : links[index]? <;> cases right : bindings[index]? <;> + simp only [left, right] at cell + · simp [reorderBindings, left, right] + · rename_i link binding + cases tail : reorderBindings names positions links with + | none => + have rest := ih positions + simp only [tail, Option.bind_none] at rest + simp [reorderBindings, left, right, tail, ← rest] + | some rest => + have tailResolved := ih positions + simp only [tail, Option.bind_some] at tailResolved + simp only [reorderBindings, left, right, tail, bind, Option.bind, pure] + rw [resolveBindings_cons, cell.2, tailResolved] + rfl + +/-- Reading copied temporary bindings recovers the canonical user bindings. -/ +theorem resolveBindings_copied (rename : String → String) + (bindings locals : Environment F Nat) + (unique : (bindings.map fun binding => rename binding.1).Nodup) : + resolveBindings (bindings.map fun binding => (binding.1, rename binding.1)) + ((bindings.map fun binding => (rename binding.1, binding.2)) ++ locals) = some bindings := by + induction bindings with + | nil => rfl + | cons binding bindings ih => + rcases binding with ⟨name, value⟩ + obtain ⟨absent, unique⟩ := List.nodup_cons.mp unique + simp only [List.map_cons, List.cons_append, resolveBindings_cons, List.find?_cons, + beq_self_eq_true, ↓reduceIte] + have unchanged := resolveBindings_congr (links := bindings.map fun b => (b.1, rename b.1)) + (left := (rename name, value) :: ((bindings.map fun b => (rename b.1, b.2)) ++ locals)) + (right := (bindings.map fun b => (rename b.1, b.2)) ++ locals) (by + intro n member + have member : n ∈ bindings.map (fun b => rename b.1) := by simpa using member + have ne : rename name ≠ n := by intro h; apply absent; simpa only [h] using member + simp [List.find?_cons, ne]) + rw [unchanged, ih unique] + rfl + +/-- Selected alternatives copy only their ordered user bindings into common +slots; all branch-local names remain invisible to the surrounding expression. -/ +theorem choice_copied {stem : String} {names positions links} + {locals bindings : Environment F Nat} + (resolved : resolveBindings links locals = some bindings) + (unique : ((choiceBindings stem names).map Prod.snd).Nodup) : + ∀ aliases installed, + choiceLinks (choiceBindings stem names) links positions = some aliases → + resolveBindings aliases locals = some installed → + ∃ ordered, reorderBindings names positions bindings = some ordered ∧ + resolveBindings (choiceBindings stem names) (installed ++ locals) = some ordered := by + intro aliases installed aligned copied + have composed := resolveBindings_reorder resolved + ((choiceBindings stem names).map Prod.snd) positions + rw [show reorderBindings ((choiceBindings stem names).map Prod.snd) positions links = + some aliases from aligned, Option.bind_some, copied] at composed + have mapped : (choiceBindings stem names).map Prod.snd = + names.map (fun name => stem ++ ":or:" ++ name) := by simp [choiceBindings] + rw [mapped, reorderBindings_mapNames] at composed + cases result : reorderBindings names positions bindings with + | none => simp [result] at composed + | some ordered => + simp only [result, Option.map_some, Option.some.injEq] at composed + subst installed + refine ⟨ordered, rfl, ?_⟩ + have orderedNames := reorderBindings_names result + have slots : choiceBindings stem names = + ordered.map (fun binding => (binding.1, stem ++ ":or:" ++ binding.1)) := by + rw [← orderedNames] + simp [choiceBindings] + rw [slots] + apply resolveBindings_copied + simpa only [slots, List.map_map, Function.comp_def] using unique + +/-- The converse construction supplies exactly the copied bindings requested by +a successful native alternative. -/ +theorem choice_copy_exists {stem : String} {names positions links} + {locals bindings ordered : Environment F Nat} + (resolved : resolveBindings links locals = some bindings) + (reordered : reorderBindings names positions bindings = some ordered) : + ∃ aliases installed, + choiceLinks (choiceBindings stem names) links positions = some aliases ∧ + resolveBindings aliases locals = some installed := by + have composed := resolveBindings_reorder resolved + ((choiceBindings stem names).map Prod.snd) positions + have mapped : (choiceBindings stem names).map Prod.snd = + names.map (fun name => stem ++ ":or:" ++ name) := by simp [choiceBindings] + have result : reorderBindings ((choiceBindings stem names).map Prod.snd) positions bindings = + some (ordered.map fun pair => (stem ++ ":or:" ++ pair.1, pair.2)) := by + rw [mapped, reorderBindings_mapNames, reordered, Option.map_some] + rw [result] at composed + cases aligned : choiceLinks (choiceBindings stem names) links positions with + | none => simp only [choiceLinks] at aligned; rw [aligned, Option.bind_none] at composed; contradiction + | some aliases => + rw [show reorderBindings ((choiceBindings stem names).map Prod.snd) positions links = + some aliases from aligned, Option.bind_some] at composed + exact ⟨aliases, _, rfl, composed⟩ + +end Aiur.Generic.PatternLowering diff --git a/Aiur/Aiur/Generic/PatternContinuationFacts.lean b/Aiur/Aiur/Generic/PatternContinuationFacts.lean new file mode 100644 index 000000000..21f9cf2b5 --- /dev/null +++ b/Aiur/Aiur/Generic/PatternContinuationFacts.lean @@ -0,0 +1,116 @@ +import Aiur.Generic.PatternTreeCompleteness + +namespace Aiur.Generic.PatternLowering + +variable {calls : CallRelation F} + +open SourceSemantics + +variable [DecidableEq F] + +theorem PlanTree.success_iff (tree : PlanTree F) (input : String) + (safe : (input :: tree.temps).Nodup) + (constant : String → Ty → Except EvalError (Pattern F)) (depth : Nat) + (heap : Heap F) (value : SourceValue F) (locals : Environment F Nat) + (found : locals.find? (·.1 == input) = some (input, value)) : + matchPatternWith constant depth [] heap tree.erase value = .ok (some bindings) ↔ + ∃ final, Attempt heap (tree.toPlan input).steps locals true final ∧ + resolveBindings (tree.toPlan input).bindings final = some bindings := by + constructor + · intro matched + obtain ⟨final, attempted⟩ := tree.attempt_complete input safe constant depth heap value locals found matched + obtain ⟨bs, matched', produced⟩ := tree.attempt_sound input safe constant depth heap value locals found attempted + have same := Option.some.inj (Except.ok.inj (matched'.symm.trans matched)) + subst bs + exact ⟨final, attempted, produced⟩ + · rintro ⟨final, attempted, produced⟩ + obtain ⟨bs, matched, produced'⟩ := tree.attempt_sound input safe constant depth heap value locals found attempted + have same := Option.some.inj (produced'.symm.trans produced) + subst bs + exact matched + +theorem PlanTree.failure_iff (tree : PlanTree F) (input : String) + (safe : (input :: tree.temps).Nodup) + (constant : String → Ty → Except EvalError (Pattern F)) (depth : Nat) + (heap : Heap F) (value : SourceValue F) (locals : Environment F Nat) + (found : locals.find? (·.1 == input) = some (input, value)) : + matchPatternWith constant depth [] heap tree.erase value = .ok none ↔ + ∃ final, Attempt heap (tree.toPlan input).steps locals false final := by + constructor + · exact tree.attempt_complete input safe constant depth heap value locals found + · rintro ⟨final, attempted⟩ + exact tree.attempt_sound input safe constant depth heap value locals found attempted + +theorem PlanTree.untouched (tree : PlanTree F) {locals final : Environment F Nat} + (attempted : Attempt heap (tree.toPlan input).steps locals accepted final) + (fresh : ∀ n ∈ names, n ∉ tree.temps) : Engine.EnvAgrees names final locals := by + intro n hn + apply attempted.unchanged + rw [tree.written] + exact fresh n hn + +variable [Field F] {world : Engine.World F} + +/-- A generated let plan performs the native read-only match and then runs the +body in precisely the source binding scope. All temporary bindings are hidden. -/ +theorem PlanTree.let_iff (tree : PlanTree F) (input : String) + (safe : (input :: tree.temps).Nodup) + (constant : String → Ty → Except EvalError (Pattern F)) (depth : Nat) + (heap : Heap F) (value : SourceValue F) (locals : Environment F Nat) + (found : locals.find? (·.1 == input) = some (input, value)) + (body : Aiur.Expr F) (fresh : ∀ n ∈ exprNames body, n ∉ tree.temps) : + OpenCore.EvalExpr world calls locals (letSteps (tree.toPlan input).steps + (bindUsers (tree.toPlan input).bindings body)) heap result after ↔ + ∃ bindings, matchPatternWith constant depth [] heap tree.erase value = .ok (some bindings) ∧ + OpenCore.EvalExpr world calls (bindings ++ locals) body heap result after := by + rw [letSteps_iff] + constructor + · rintro ⟨final, attempted, bodyEval⟩ + obtain ⟨bindings, produced, evaluated⟩ := bindUsers_resolved_iff.mp bodyEval + exact ⟨bindings, (tree.success_iff input safe constant depth heap value locals found).mpr + ⟨final, attempted, produced⟩, + evaluated.changeLocals _ ((tree.untouched attempted fresh).prepend bindings)⟩ + · rintro ⟨bindings, matched, evaluated⟩ + obtain ⟨final, attempted, produced⟩ := (tree.success_iff input safe constant depth heap value locals found).mp matched + exact ⟨final, attempted, bindUsers_resolved_iff.mpr ⟨bindings, produced, + evaluated.changeLocals _ ((tree.untouched attempted fresh).symm.prepend bindings)⟩⟩ + +/-- The failure continuation runs with the unchanged caller scope. Only the +successful continuation receives user bindings from this pattern. -/ +theorem PlanTree.match_iff (tree : PlanTree F) (input : String) + (safe : (input :: tree.temps).Nodup) + (constant : String → Ty → Except EvalError (Pattern F)) (depth : Nat) + (heap : Heap F) (value : SourceValue F) (locals : Environment F Nat) + (found : locals.find? (·.1 == input) = some (input, value)) + (body : Aiur.Expr F) (failure : Option (Aiur.Expr F)) + (freshBody : ∀ n ∈ exprNames body, n ∉ tree.temps) + (freshFailure : ∀ fallback, failure = some fallback → ∀ n ∈ exprNames fallback, n ∉ tree.temps) : + OpenCore.EvalExpr world calls locals (matchSteps (tree.toPlan input).steps + (bindUsers (tree.toPlan input).bindings body) failure) heap result after ↔ + (∃ bindings, matchPatternWith constant depth [] heap tree.erase value = .ok (some bindings) ∧ + OpenCore.EvalExpr world calls (bindings ++ locals) body heap result after) ∨ + (matchPatternWith constant depth [] heap tree.erase value = .ok none ∧ + ∃ fallback, failure = some fallback ∧ OpenCore.EvalExpr world calls locals fallback heap result after) := by + rw [matchSteps_iff] + constructor + · rintro ⟨accepted, final, attempted, continued⟩ + cases accepted with + | true => + obtain ⟨bindings, produced, evaluated⟩ := bindUsers_resolved_iff.mp continued + exact Or.inl ⟨bindings, (tree.success_iff input safe constant depth heap value locals found).mpr + ⟨final, attempted, produced⟩, + evaluated.changeLocals _ ((tree.untouched attempted freshBody).prepend bindings)⟩ + | false => + obtain ⟨fallback, present, evaluated⟩ := continued + exact Or.inr ⟨(tree.failure_iff input safe constant depth heap value locals found).mpr ⟨final, attempted⟩, + fallback, present, evaluated.changeLocals _ (tree.untouched attempted (freshFailure fallback present))⟩ + · rintro (⟨bindings, matched, evaluated⟩ | ⟨matched, fallback, present, evaluated⟩) + · obtain ⟨final, attempted, produced⟩ := (tree.success_iff input safe constant depth heap value locals found).mp matched + refine ⟨true, final, attempted, ?_⟩ + exact bindUsers_resolved_iff.mpr ⟨bindings, produced, + evaluated.changeLocals _ ((tree.untouched attempted freshBody).symm.prepend bindings)⟩ + · obtain ⟨final, attempted⟩ := (tree.failure_iff input safe constant depth heap value locals found).mp matched + exact ⟨false, final, attempted, fallback, present, + evaluated.changeLocals _ (tree.untouched attempted (freshFailure fallback present)).symm⟩ + +end Aiur.Generic.PatternLowering diff --git a/Aiur/Aiur/Generic/PatternFacts.lean b/Aiur/Aiur/Generic/PatternFacts.lean new file mode 100644 index 000000000..0f7f69047 --- /dev/null +++ b/Aiur/Aiur/Generic/PatternFacts.lean @@ -0,0 +1,295 @@ +import Aiur.Generic.PatternLowering +import Aiur.Generic.OpenCore +import Aiur.Generic.PatternBindingsFacts + +namespace Aiur.Generic.PatternLowering + +variable {calls : CallRelation F} + + +/-- Removing one pointer-pattern layer is exactly an ordinary load, even when +the remaining pattern contains further loads. -/ +@[simp] theorem lowerLet_load (env) (pat : Pattern α) (value body : Aiur.Expr α) : + lowerLet env (.load pat) value body = lowerLet env pat (.load value) body := by + rw [lowerLet] + +@[simp] theorem lowerLet_load_bind (env) (name : String) (value body : Aiur.Expr α) : + lowerLet env (.load (.bind name)) value body = + .letValue (.bind name) (.load value) body := by + simp [lowerLet, Pattern.toCore?] + +/-- Read-only execution of a pattern plan. A failed test stops the attempt; +a bad load has no successful derivation and does not select a fallback. Only +temporary bindings have been installed when a test fails. -/ +inductive Attempt [DecidableEq F] (heap : Heap F) : + List (Step F) → Environment F Nat → Bool → Environment F Nat → Prop where + | done : Attempt heap [] locals true locals + | testHit + (lookup : locals.find? (·.1 == input) = some (input, value)) + (matched : pat.bindings value = some bindings) + (rest : Attempt heap steps (bindings ++ locals) accepted final) : + Attempt heap (.test pat input :: steps) locals accepted final + | testMiss + (lookup : locals.find? (·.1 == input) = some (input, value)) + (missed : pat.bindings value = none) : + Attempt heap (.test pat input :: steps) locals false locals + | load + (lookup : locals.find? (·.1 == input) = some (input, pointer)) + (loaded : loadValue heap pointer = .ok value) + (rest : Attempt heap steps ((name, value) :: locals) accepted final) : + Attempt heap (.load name input :: steps) locals accepted final + + | choiceLeft + (selected : Attempt heap left locals true middle) + (aligned : choiceLinks outputs leftBindings (List.range outputs.length) = some links) + (copied : resolveBindings links middle = some installed) + (rest : Attempt heap steps (installed ++ middle) accepted final) : + Attempt heap (.choice outputs left leftBindings right rightBindings order :: steps) locals accepted final + | choiceRight + (missed : Attempt heap left locals false rejected) + (selected : Attempt heap right rejected true middle) + (aligned : choiceLinks outputs rightBindings order = some links) + (copied : resolveBindings links middle = some installed) + (rest : Attempt heap steps (installed ++ middle) accepted final) : + Attempt heap (.choice outputs left leftBindings right rightBindings order :: steps) locals accepted final + | choiceMiss + (leftMissed : Attempt heap left locals false rejected) + (rightMissed : Attempt heap right rejected false final) : + Attempt heap (.choice outputs left leftBindings right rightBindings order :: steps) locals false final + +variable [Field F] [DecidableEq F] {world : Engine.World F} + +theorem choiceBody_iff {outputs bindings positions} {body : Aiur.Expr F} + {locals : Environment F Nat} {before after : Heap F} {result : SourceValue F} : + OpenCore.EvalExpr world calls locals (choiceBody outputs bindings positions body) before result after ↔ + ∃ links installed, choiceLinks outputs bindings positions = some links ∧ + resolveBindings links locals = some installed ∧ + OpenCore.EvalExpr world calls (installed ++ locals) body before result after := by + cases aligned : choiceLinks outputs bindings positions with + | none => + simp only [choiceBody, aligned] + constructor + · intro h; cases h with + | matchValue _ selected _ => simp [selectArm] at selected + · rintro ⟨_, _, h, _⟩; contradiction + | some links => + simp only [choiceBody, aligned] + rw [bindUsers_resolved_iff] + simp + +/-- `let &name = pointer; body` evaluates the pointer once, reads its cell, +and evaluates the body with the contents bound to `name`. -/ +theorem load_bind_iff {env} {name : String} {locals : Environment F Nat} + {pointer body : Aiur.Expr F} {before after : Heap F} {result : SourceValue F} : + OpenCore.EvalExpr world calls locals (lowerLet env (.load (.bind name)) pointer body) before result after ↔ + ∃ address middle value, + OpenCore.EvalExpr world calls locals pointer before address middle ∧ + loadValue middle address = .ok value ∧ + OpenCore.EvalExpr world calls ((name, value) :: locals) body middle result after := by + rw [lowerLet_load_bind] + constructor + · intro h + cases h with + | letValue value matched body => + cases value with + | load pointer loaded => + simp only [Aiur.Pattern.bindings, Option.some.injEq] at matched + subst_vars + exact ⟨_, _, _, pointer, loaded, body⟩ + · rintro ⟨address, middle, value, pointer, loaded, body⟩ + exact .letValue (bindings := [(name, value)]) (.load pointer loaded) + (by simp [Aiur.Pattern.bindings]) body + +/-- The selected continuation of a match attempt; no fallback means a partial +match cannot finish after a failed test. -/ +def Continuation (world : Engine.World F) (calls : CallRelation F) (accepted : Bool) (locals : Environment F Nat) + (body : Aiur.Expr F) (failure : Option (Aiur.Expr F)) + (before : Heap F) (result : SourceValue F) (after : Heap F) : Prop := + if accepted then OpenCore.EvalExpr world calls locals body before result after + else ∃ fallback, failure = some fallback ∧ OpenCore.EvalExpr world calls locals fallback before result after + +/-- Ordered match desugaring executes exactly the chosen plan continuation. +In particular, a failed earlier test bypasses all subsequent loads. -/ +theorem matchSteps_iff {steps : List (Step F)} {locals : Environment F Nat} + {body : Aiur.Expr F} {failure : Option (Aiur.Expr F)} + {before after : Heap F} {result : SourceValue F} : + OpenCore.EvalExpr world calls locals (matchSteps steps body failure) before result after ↔ + ∃ accepted final, Attempt before steps locals accepted final ∧ + Continuation world calls accepted final body failure before result after := by + have sub (ss : List (Step F)) (smaller : sizeOf ss < sizeOf steps) + (body : Aiur.Expr F) (failure : Option (Aiur.Expr F)) (locals : Environment F Nat) := + matchSteps_iff (steps := ss) (locals := locals) (body := body) (failure := failure) (before := before) (after := after) (result := result) + cases steps with + | nil => + rw [matchSteps] + constructor + · intro h; exact ⟨true, locals, .done, h⟩ + · rintro ⟨_, _, h, body⟩; cases h; exact body + | cons step tail => + have ih := sub tail (by simp_wf; omega) body failure + cases step with + | load name input => + rw [matchSteps] + constructor + · intro h + cases h with + | letValue value matched body => + cases value with + | load pointer loaded => + cases pointer with + | var lookup => + simp only [Aiur.Pattern.bindings, Option.some.injEq] at matched + subst_vars + obtain ⟨accepted, final, rest, body⟩ := (ih _).mp body + exact ⟨accepted, final, .load lookup loaded rest, body⟩ + · rintro ⟨accepted, final, h, body⟩ + cases h with + | load lookup loaded rest => + exact .letValue (bindings := [(name, _)]) (.load (.var lookup) loaded) (by simp [Aiur.Pattern.bindings]) ((ih _).mpr ⟨accepted, final, rest, body⟩) + | test pat input => + rw [matchSteps] + constructor + · intro h + cases h with + | matchValue value selected branch => + cases value with + | var lookup => + rename_i inputValue bindings selectedBody + cases matched : pat.bindings inputValue with + | some bindings => + simp only [selectArm, matched, Option.some.injEq, Prod.mk.injEq] at selected + obtain ⟨rfl, rfl⟩ := selected + obtain ⟨accepted, final, rest, body⟩ := (ih _).mp branch + exact ⟨accepted, final, .testHit lookup matched rest, body⟩ + | none => + cases failure with + | none => simp [selectArm, matched] at selected + | some fallback => + simp only [selectArm, matched, Option.toList_some, List.map_cons, + List.map_nil, Aiur.Pattern.bindings, Option.some.injEq, Prod.mk.injEq] at selected + obtain ⟨rfl, rfl⟩ := selected + exact ⟨false, _, .testMiss lookup matched, fallback, rfl, branch⟩ + · rintro ⟨accepted, final, h, body⟩ + cases h with + | testHit lookup matched rest => + exact .matchValue (.var lookup) (by simp [selectArm, matched, matchSteps]) + ((ih _).mpr ⟨accepted, final, rest, body⟩) + | testMiss lookup missed => + obtain ⟨fallback, rfl, branch⟩ := body + exact .matchValue (bindings := []) (body := fallback) (.var lookup) + (by simp [selectArm, missed, Aiur.Pattern.bindings]) branch + + | choice outputs left lbs right rbs order => + rw [matchSteps] + rw [sub left (by simp_wf; omega)] + constructor + · rintro ⟨accepted, middle, attempted, cont⟩ + cases accepted with + | true => + obtain ⟨links, installed, aligned, copied, rest⟩ := choiceBody_iff.mp cont + obtain ⟨accepted, final, rest, cont⟩ := (ih _).mp rest + exact ⟨accepted, final, .choiceLeft attempted aligned copied rest, cont⟩ + | false => + obtain ⟨fallback, eq, next⟩ := cont + cases Option.some.inj eq + obtain ⟨accepted, middle, rightAttempt, cont⟩ := + (sub right (by simp_wf; omega) _ _ _).mp next + cases accepted with + | true => + obtain ⟨links, installed, aligned, copied, rest⟩ := choiceBody_iff.mp cont + obtain ⟨accepted, final, rest, cont⟩ := (ih _).mp rest + exact ⟨accepted, final, .choiceRight attempted rightAttempt aligned copied rest, cont⟩ + | false => exact ⟨false, middle, .choiceMiss attempted rightAttempt, cont⟩ + · rintro ⟨accepted, final, attempted, cont⟩ + cases attempted with + | choiceLeft selected aligned copied rest => + exact ⟨true, _, selected, choiceBody_iff.mpr ⟨_, _, aligned, copied, + (ih _).mpr ⟨accepted, final, rest, cont⟩⟩⟩ + | choiceRight missed selected aligned copied rest => + refine ⟨false, _, missed, _, rfl, ?_⟩ + exact (sub right (by simp_wf; omega) _ _ _).mpr ⟨true, _, selected, + choiceBody_iff.mpr ⟨_, _, aligned, copied, + (ih _).mpr ⟨accepted, final, rest, cont⟩⟩⟩ + | choiceMiss missed selected => + exact ⟨false, _, missed, _, rfl, + (sub right (by simp_wf; omega) _ _ _).mpr ⟨false, final, selected, cont⟩⟩ +termination_by sizeOf steps +decreasing_by exact smaller + +/-- Let desugaring succeeds exactly when all pattern tests and loads succeed, +followed by evaluation of the body. Pattern steps do not change the heap. -/ +theorem letSteps_iff {steps : List (Step F)} {locals : Environment F Nat} + {body : Aiur.Expr F} {before after : Heap F} {result : SourceValue F} : + OpenCore.EvalExpr world calls locals (letSteps steps body) before result after ↔ + ∃ final, Attempt before steps locals true final ∧ + OpenCore.EvalExpr world calls final body before result after := by + induction steps generalizing locals with + | nil => + rw [letSteps] + constructor + · intro h; exact ⟨locals, .done, h⟩ + · rintro ⟨_, h, body⟩; cases h; exact body + | cons step steps ih => + cases step with + | test pat input => + rw [letSteps] + constructor + · intro h + cases h with + | letValue value matched body => + cases value with + | var lookup => + obtain ⟨final, rest, body⟩ := ih.mp body + exact ⟨final, .testHit lookup matched rest, body⟩ + · rintro ⟨final, h, body⟩ + cases h with + | testHit lookup matched rest => + exact .letValue (.var lookup) matched (ih.mpr ⟨final, rest, body⟩) + | load name input => + rw [letSteps] + constructor + · intro h + cases h with + | letValue value matched body => + cases value with + | load pointer loaded => + cases pointer with + | var lookup => + simp only [Aiur.Pattern.bindings, Option.some.injEq] at matched + subst_vars + obtain ⟨final, rest, body⟩ := ih.mp body + exact ⟨final, .load lookup loaded rest, body⟩ + · rintro ⟨final, h, body⟩ + cases h with + | load lookup loaded rest => + exact .letValue (bindings := [(name, _)]) (.load (.var lookup) loaded) (by simp [Aiur.Pattern.bindings]) (ih.mpr ⟨final, rest, body⟩) + + | choice outputs left lbs right rbs order => + rw [letSteps, matchSteps_iff] + constructor + · rintro ⟨accepted, middle, attempted, cont⟩ + cases accepted with + | true => + obtain ⟨links, installed, aligned, copied, rest⟩ := choiceBody_iff.mp cont + obtain ⟨final, rest, body⟩ := ih.mp rest + exact ⟨final, .choiceLeft attempted aligned copied rest, body⟩ + | false => + obtain ⟨fallback, eq, next⟩ := cont + cases Option.some.inj eq + obtain ⟨accepted, middle, rightAttempt, cont⟩ := matchSteps_iff.mp next + cases accepted with + | true => + obtain ⟨links, installed, aligned, copied, rest⟩ := choiceBody_iff.mp cont + obtain ⟨final, rest, body⟩ := ih.mp rest + exact ⟨final, .choiceRight attempted rightAttempt aligned copied rest, body⟩ + | false => obtain ⟨fallback, eq, _⟩ := cont; contradiction + · rintro ⟨final, attempted, body⟩ + cases attempted with + | choiceLeft selected aligned copied rest => + exact ⟨true, _, selected, choiceBody_iff.mpr ⟨_, _, aligned, copied, + ih.mpr ⟨final, rest, body⟩⟩⟩ + | choiceRight missed selected aligned copied rest => + exact ⟨false, _, missed, _, rfl, matchSteps_iff.mpr ⟨true, _, selected, + choiceBody_iff.mpr ⟨_, _, aligned, copied, ih.mpr ⟨final, rest, body⟩⟩⟩⟩ + +end Aiur.Generic.PatternLowering diff --git a/Aiur/Aiur/Generic/PatternLowering.lean b/Aiur/Aiur/Generic/PatternLowering.lean new file mode 100644 index 000000000..1d18250dc --- /dev/null +++ b/Aiur/Aiur/Generic/PatternLowering.lean @@ -0,0 +1,277 @@ +import Aiur.Generic.AST + +/-! Late compilation of native pointer and or-patterns to ordinary core loads +and pattern tests. Failed attempts introduce only fresh names; user bindings +are installed after all tests succeed. The scrutinee is evaluated once. -/ + +namespace Aiur.Generic + +def Pattern.toCore? (env : List (String × Ty)) : Pattern α → Option (Aiur.Pattern α) + | .literal x => some (.literal x) + | .wildcard => some .wildcard + | .bind n => some (.bind n) + | .global _ _ => none + | .load _ | .orElse _ _ _ => none + | .tuple ps | .array ps => return .tuple (← ps.mapM (Pattern.toCore? env)) + | .record head ps => do + let .enum n := (head.type.subst env).toCore | none + return .construct n structConstructor (head.order (← ps.mapM (Pattern.toCore? env)) .wildcard) + | .repeat p n => return .tuple (List.replicate n (← p.toCore? env)) + | .construct t c ps | .constructAs _ t c ps => do + let .enum n := (t.subst env).toCore | none + return .construct n c (← ps.mapM (Pattern.toCore? env)) +termination_by p => sizeOf p + +namespace PatternLowering + +def patternNames : Aiur.Pattern α → List String + | .literal _ | .wildcard => [] + | .bind n => [n] + | .tuple ps | .construct _ _ ps => ps.flatMap patternNames +termination_by p => sizeOf p + +def exprNames : Aiur.Expr α → List String + | .literal _ => [] + | .var n => [n] + | .tuple xs | .construct _ _ xs | .call _ xs => xs.flatMap exprNames + | .project x _ | .store x | .load x | .hint _ x channel | .neg x => exprNames x + | .letValue p x b => patternNames p ++ exprNames x ++ exprNames b + | .binary _ x y | .assertEq _ x y => exprNames x ++ exprNames y + | .matchValue x arms => exprNames x ++ arms.flatMap (fun arm => patternNames arm.1 ++ exprNames arm.2) +termination_by e => sizeOf e +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; try simp_all only [Prod.mk.sizeOf_spec] + all_goals first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +/-- Longer than every existing variable name, including names in already +lowered subexpressions. This also protects programmatically constructed ASTs. -/ +def freshPrefix (names : List String) : String := + "$pattern" ++ String.ofList (List.replicate (names.foldl (fun n s => max n s.length) 0 + 1) '_') ++ ":" + +def fresh (stem : String) : StateM Nat String := do + let n ← get + set (n + 1) + return stem ++ toString n + +inductive Step (α : Type) where + | test (pattern : Aiur.Pattern α) (input : String) + | load (name input : String) + | choice (outputs : List (String × String)) + (left : List (Step α)) (leftBindings : List (String × String)) + (right : List (Step α)) (rightBindings : List (String × String)) (rightOrder : List Nat) + deriving Repr + +structure Plan (α : Type) where + steps : List (Step α) := [] + bindings : List (String × String) := [] + deriving Repr + +/-- The tree records the nesting of a pattern before its read/test steps are +flattened. Names belong only to the compiler; `erase` recovers the pattern's +matching condition and user bindings. -/ +inductive PlanTree (α : Type) where + | literal (value : α) + | wildcard + | bind (name : String) + | load (name : String) (child : PlanTree α) + | choice (stem : String) (left right : PlanTree α) (bindings : OrBindings) + | tuple (children : List (String × PlanTree α)) + | construct (name ctor : String) (children : List (String × PlanTree α)) + deriving Repr + +def PlanTree.erase : PlanTree α → Pattern α + | .literal x => .literal x + | .wildcard => .wildcard + | .bind n => .bind n + | .load _ child => .load child.erase + | .choice _ left right names => .orElse left.erase right.erase names + | .tuple children => .tuple (children.map fun part => part.2.erase) + | .construct n c children => .construct (.named n []) c (children.map fun part => part.2.erase) +termination_by tree => sizeOf tree +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + all_goals try cases ‹String × PlanTree α› + all_goals simp_all only [Prod.mk.sizeOf_spec] <;> omega + +def choiceBindings (stem : String) (names : List String) : List (String × String) := + names.map fun name => (name, stem ++ ":or:" ++ name) + +/-- Copy an alternative's bindings into the shared result slots by recorded position. -/ +def choiceLinks (outputs bindings : List (String × String)) (positions : List Nat) : + Option (List (String × String)) := reorderBindings (outputs.map Prod.snd) positions bindings + +def PlanTree.temps : PlanTree F → List String + | .literal _ | .wildcard | .bind _ => [] + | .load name child => name :: child.temps + | .choice stem left right names => left.temps ++ right.temps ++ + (choiceBindings stem names.names).map Prod.snd + | .tuple parts | .construct _ _ parts => + parts.map Prod.fst ++ parts.flatMap (fun part => part.2.temps) +termination_by tree => sizeOf tree +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + all_goals try cases ‹String × PlanTree F› + all_goals simp_all only [Prod.mk.sizeOf_spec] <;> omega + + +def PlanTree.toPlan : PlanTree α → String → Plan α + | .literal x, input => ⟨[.test (.literal x) input], []⟩ + | .wildcard, _ => {} + | .bind n, input => ⟨[], [(n, input)]⟩ + | .choice stem left right names, input => + let l := left.toPlan input + let r := right.toPlan input + let outputs := choiceBindings stem names.names + ⟨[.choice outputs l.steps l.bindings r.steps r.bindings names.rightOrder], outputs⟩ + | .load n child, input => + let next := child.toPlan n + { next with steps := .load n input :: next.steps } + | .tuple children, input => + let parts := children.map fun part => (part.1, part.2.toPlan part.1) + { steps := .test (.tuple (parts.map (fun part => .bind part.1))) input :: parts.flatMap (·.2.steps) + bindings := parts.flatMap (·.2.bindings) } + | .construct n c children, input => + let parts := children.map fun part => (part.1, part.2.toPlan part.1) + { steps := .test (.construct n c (parts.map (fun part => .bind part.1))) input :: parts.flatMap (·.2.steps) + bindings := parts.flatMap (·.2.bindings) } +termination_by tree _ => sizeOf tree +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + all_goals try cases ‹String × PlanTree α› + all_goals simp_all only [Prod.mk.sizeOf_spec] <;> omega + +/-- Decompose from left to right. Constructor shape tests will precede payload +reads when the tree is flattened. Arrays retain the same ordered tuple shape. -/ +def planTree (env : List (String × Ty)) (stem : String) : Pattern α → StateM Nat (PlanTree α) + | .literal x => return .literal x + | .global n _ => return .construct ("$const:" ++ n) "$unexpanded" [] + | .wildcard => return .wildcard + | .bind n => return .bind n + | .orElse left right names => do + let left ← planTree env stem left + let right ← planTree env stem right + let name ← fresh stem + return .choice name left right names + | .load p => do + let name ← fresh stem + return .load name (← planTree env stem p) + | .tuple ps | .array ps => do + let parts ← ps.mapM fun p => do + let name ← fresh stem + return (name, ← planTree env stem p) + return .tuple parts + | .repeat p n => do + let parts ← (List.range n).mapM fun _ => do + let name ← fresh stem + return (name, ← planTree env stem p) + return .tuple parts + | .record head ps => do + let parts ← (head.order (ps.attach.map some) none).mapM fun child => do + let name ← fresh stem + let tree ← match child with + | some p => planTree env stem p.val + | none => pure .wildcard + return (name, tree) + let n := match (head.type.subst env).toCore with | .enum n => n | _ => "$invalid" + return .construct n structConstructor parts + | .construct t c ps | .constructAs _ t c ps => do + let parts ← ps.mapM fun p => do + let name ← fresh stem + return (name, ← planTree env stem p) + let n := match (t.subst env).toCore with | .enum n => n | _ => "$invalid" + return .construct n c parts +termination_by p => sizeOf p +decreasing_by + all_goals simp_wf + all_goals try have := List.sizeOf_lt_of_mem ‹_ ∈ _› + all_goals try have := List.sizeOf_lt_of_mem p.property + all_goals omega + +def plan (env : List (String × Ty)) (stem : String) (pat : Pattern α) (input : String) : + StateM Nat (Plan α) := do return (← planTree env stem pat).toPlan input + +def bindUsers (bindings : List (String × String)) (body : Aiur.Expr α) : Aiur.Expr α := + .letValue (.tuple (bindings.map fun binding => .bind binding.1)) + (.tuple (bindings.map fun binding => .var binding.2)) body + +/-- Installing selected bindings cannot evaluate the continuation when an +unchecked alternative is missing a required binder. -/ +def choiceBody (outputs bindings : List (String × String)) (positions : List Nat) (body : Aiur.Expr α) : Aiur.Expr α := + match choiceLinks outputs bindings positions with + | some links => bindUsers links body + | none => .matchValue (.tuple []) [] + +def matchSteps (steps : List (Step α)) (body : Aiur.Expr α) + (failure : Option (Aiur.Expr α)) : Aiur.Expr α := + match steps with + | [] => body + | .test p input :: steps => + .matchValue (.var input) ((p, matchSteps steps body failure) :: + failure.toList.map (fun e => (.wildcard, e))) + | .load name input :: steps => + .letValue (.bind name) (.load (.var input)) (matchSteps steps body failure) + | .choice outputs left lbs right rbs order :: steps => + let rest := matchSteps steps body failure + matchSteps left (choiceBody outputs lbs (List.range outputs.length) rest) + (some (matchSteps right (choiceBody outputs rbs order rest) failure)) +termination_by sizeOf steps + +def letSteps (steps : List (Step α)) (body : Aiur.Expr α) : Aiur.Expr α := + match steps with + | [] => body + | .test p input :: steps => .letValue p (.var input) (letSteps steps body) + | .load name input :: steps => .letValue (.bind name) (.load (.var input)) (letSteps steps body) + | .choice outputs left lbs right rbs order :: steps => + let rest := letSteps steps body + matchSteps left (choiceBody outputs lbs (List.range outputs.length) rest) + (some (matchSteps right (choiceBody outputs rbs order rest) none)) + +/-- Top-level `&p` is exactly `let p = *value`; ordinary patterns retain their +existing core representation. Only mixed nested patterns need fresh names. -/ +def lowerLet (env : List (String × Ty)) : Pattern α → Aiur.Expr α → Aiur.Expr α → Aiur.Expr α + | .load p, value, body => lowerLet env p (.load value) body + | p, value, body => + match p.toCore? env with + | some core => .letValue core value body + | none => + let stem := freshPrefix (p.bindingNames ++ exprNames value ++ exprNames body) + let root := stem ++ "0" + let result := ((plan env stem p root).run 1).1 + .letValue (.bind root) value (letSteps result.steps (bindUsers result.bindings body)) +termination_by p _ _ => sizeOf p + +/-- A vacuous final test keeps the next arm syntactically visible even when +this arm's pattern cannot fail. It adds no semantic requirement. -/ +def Plan.retainedSteps (p : Plan α) (root : String) : List (Step α) := + if p.steps.any (fun step => match step with + | .test _ _ => true | .load _ _ | .choice _ _ _ _ _ _ => false) then p.steps + else p.steps ++ [.test .wildcard root] + +def matchArms (env : List (String × Ty)) (stem root : String) : + List (Pattern α × Aiur.Expr α) → StateM Nat (Option (Aiur.Expr α)) + | [] => return none + | (pat, body) :: arms => do + let current ← plan env stem pat root + let next ← matchArms env stem root arms + -- Keep even unreachable alternatives syntactically visible to the + -- specialization dependency check. The core compiler discards them. + let steps := current.retainedSteps root + return some (matchSteps steps (bindUsers current.bindings body) next) + +def lowerMatch (env : List (String × Ty)) (value : Aiur.Expr α) + (arms : List (Pattern α × Aiur.Expr α)) : Aiur.Expr α := + match arms.mapM (fun arm => return (← arm.1.toCore? env, arm.2)) with + | some core => .matchValue value core + | none => + let names := exprNames value ++ arms.flatMap (fun arm => arm.1.bindingNames ++ exprNames arm.2) + let stem := freshPrefix names + let root := stem ++ "0" + let body := ((matchArms env stem root arms).run 1).1 + .letValue (.bind root) value (body.getD (.matchValue (.var root) [])) + +end PatternLowering +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/PatternLoweringFacts.lean b/Aiur/Aiur/Generic/PatternLoweringFacts.lean new file mode 100644 index 000000000..a9380fd57 --- /dev/null +++ b/Aiur/Aiur/Generic/PatternLoweringFacts.lean @@ -0,0 +1,276 @@ +import Aiur.Generic.LoweringChecks +import Aiur.Generic.PatternRetentionFacts +import Aiur.Generic.PatternTranslation +import Aiur.Generic.EngineInversion + +namespace Aiur.Generic.PatternLowering + +variable {calls : CallRelation F} + +open SourceSemantics + +variable [Field F] [DecidableEq F] {world : Engine.World F} + +theorem env_cons_fresh (fresh : ∀ n ∈ names, n ≠ root) : + Engine.EnvAgrees names ((root, value) :: locals) locals := by + intro n hn + simp only [List.find?_cons] + rw [show (root == n) = false from beq_eq_false_iff_ne.mpr (fresh n hn).symm] + +private theorem match_load_iff {pat : Pattern F} : + matchPatternWith constant depth types heap (.load pat) value = .ok outcome ↔ + ∃ loaded, loadValue heap value = .ok loaded ∧ + matchPatternWith constant depth types heap pat loaded = .ok outcome := by + cases h : loadValue heap value <;> simp [matchPatternWith, h, bind, Except.bind] + +/-- The full let-pattern translation preserves the native, heap-reading match. +The finite safety check accounts for all compiler-generated local names. -/ +theorem lowerLet_open_iff (types : Types) (pat : Pattern F) (value body : Aiur.Expr F) + (safe : LetSafe types pat value body) + (constant : String → Ty → Except EvalError (Pattern F)) (depth : Nat) + (locals : Environment F Nat) (before after : Heap F) (result : SourceValue F) : + OpenCore.EvalExpr world calls locals (lowerLet types pat value body) before result after ↔ + ∃ input middle bindings, OpenCore.EvalExpr world calls locals value before input middle ∧ + matchPatternWith constant depth types middle pat input = .ok (some bindings) ∧ + OpenCore.EvalExpr world calls (bindings ++ locals) body middle result after := by + cases pat with + | load pat => + rw [lowerLet_load, lowerLet_open_iff types pat (.load value) body (by simpa only [LetSafe] using safe) + constant depth locals before after result] + simp only [OpenCore.load_iff, match_load_iff] + constructor + · rintro ⟨loaded, middle, bs, ⟨input, ev, read⟩, matched, eb⟩ + exact ⟨input, middle, bs, ev, ⟨loaded, read, matched⟩, eb⟩ + · rintro ⟨input, middle, bs, ev, ⟨loaded, read, matched⟩, eb⟩ + exact ⟨loaded, middle, bs, ⟨input, ev, read⟩, matched, eb⟩ + | _ => + unfold lowerLet + split + · rename_i core lowered + rw [OpenCore.letValue_iff] + apply exists_congr; intro input + apply exists_congr; intro middle + apply exists_congr; intro bindings + rw [Pattern.toCore_match _ lowered] + simp only [Except.ok.injEq] + · rename_i lowered + simp only [LetSafe, lowered] at safe + obtain ⟨resolved, unique, fresh⟩ := safe + simp only [plan, StateT.run, state_map_result] + rw [OpenCore.bind_iff] + apply exists_congr; intro input + apply exists_congr; intro middle + rw [exists_and_left] + apply and_congr_right; intro _ + rw [PlanTree.let_iff _ _ unique constant depth middle input _ (by simp) + body (fun n hn h => fresh n hn (List.mem_cons_of_mem _ h))] + rw [← planTree_match _ resolved types _ 1 constant depth middle input] + apply exists_congr; intro bindings + apply and_congr_right; intro _ + apply OpenCore.evalExpr_env_iff + apply Engine.EnvAgrees.prepend + exact env_cons_fresh (fun n hn eq => fresh n hn (by simp [eq])) +termination_by sizeOf pat + +/-- Ordered selection, polymorphic in the branch body. This is the same native +pattern matcher used by source evaluation. -/ +def choose (constant : String → Ty → Except EvalError (Pattern F)) + (depth : Nat) (types : Types) (heap : Heap F) (input : SourceValue F) : + List (Pattern F × B) → Except EvalError (Option (Environment F Nat × B)) + | [] => pure none + | (pat, body) :: arms => do + match ← matchPatternWith constant depth types heap pat input with + | some bindings => return some (bindings, body) + | none => choose constant depth types heap input arms + +theorem choose_cons_iff {pat : Pattern F} : + choose constant depth types heap input ((pat, body) :: arms) = .ok (some (bindings, selected)) ↔ + (matchPatternWith constant depth types heap pat input = .ok (some bindings) ∧ body = selected) ∨ + (matchPatternWith constant depth types heap pat input = .ok none ∧ + choose constant depth types heap input arms = .ok (some (bindings, selected))) := by + cases h : matchPatternWith constant depth types heap pat input with + | error e => simp [choose, h, bind, Except.bind] + | ok matched => cases matched <;> simp [choose, h, bind, Except.bind, pure, Except.pure] + +theorem choose_member {arms : List (Pattern F × B)} + (selected : choose constant depth types heap input arms = .ok (some (bindings, body))) : + ∃ pat, (pat, body) ∈ arms := by + induction arms with + | nil => simp [choose, pure, Except.pure] at selected + | cons arm arms ih => + rcases arm with ⟨pat, head⟩ + rcases choose_cons_iff.mp selected with ⟨_, rfl⟩ | ⟨_, selected⟩ + · exact ⟨pat, by simp⟩ + · obtain ⟨pat, hp⟩ := ih selected + exact ⟨pat, by simp [hp]⟩ + +theorem choose_matched {arms : List (Pattern F × B)} + (selected : choose constant depth types heap input arms = .ok (some (bindings, body))) : + ∃ pat, (pat, body) ∈ arms ∧ + matchPatternWith constant depth types heap pat input = .ok (some bindings) := by + induction arms with + | nil => simp [choose, pure, Except.pure] at selected + | cons arm arms ih => + rcases arm with ⟨pat, head⟩ + rcases choose_cons_iff.mp selected with ⟨matched, rfl⟩ | ⟨_, selected⟩ + · exact ⟨pat, by simp, matched⟩ + · obtain ⟨pat, hp, matched⟩ := ih selected + exact ⟨pat, by simp [hp], matched⟩ + +theorem choose_map (f : A → B) (arms : List (Pattern F × A)) : + choose constant depth types heap input (arms.map fun arm => (arm.1, f arm.2)) = + (choose constant depth types heap input arms).map (Option.map fun selected => (selected.1, f selected.2)) := by + induction arms with + | nil => rfl + | cons arm arms ih => + rcases arm with ⟨pat, body⟩ + cases h : matchPatternWith constant depth types heap pat input with + | error e => simp [choose, h, bind, Except.bind, Except.map] + | ok result => cases result <;> simp [choose, h, ih, bind, Except.bind, Except.map, pure, Except.pure] + +theorem choose_source (source : SourceSemantics.World F) (types heap input) + (arms : List (Pattern F × Expr F)) : + choose source.constant source.constDepth types heap input arms = + SourceSemantics.selectArm source types heap input arms := by + induction arms with + | nil => rfl + | cons arm arms ih => + rcases arm with ⟨pat, body⟩ + simp only [choose, SourceSemantics.selectArm, SourceSemantics.World.matchPattern, ih] + rfl + +theorem matchArms_iff (types : Types) (stem root : String) + (arms : List (Pattern F × Aiur.Expr F)) (state : Nat) + (safe : ArmsSafe types stem root arms state) + (constant : String → Ty → Except EvalError (Pattern F)) (depth : Nat) + (heap : Heap F) (input : SourceValue F) (locals : Environment F Nat) + (found : locals.find? (·.1 == root) = some (root, input)) : + (∃ body, (matchArms types stem root arms state).1 = some body ∧ + OpenCore.EvalExpr world calls locals body heap result after) ↔ + ∃ bindings body, choose constant depth types heap input arms = .ok (some (bindings, body)) ∧ + OpenCore.EvalExpr world calls (bindings ++ locals) body heap result after := by + induction arms generalizing state with + | nil => simp [matchArms, choose, pure, StateT.pure, Except.pure] + | cons arm arms ih => + rcases arm with ⟨pat, branch⟩ + obtain ⟨resolved, unique, bodyFresh, fallbackFresh, tailSafe⟩ := safe + rw [matchArms] + simp only [plan, state_bind_run, state_pure_run, Option.some.injEq] + simp only [exists_eq_left'] + rw [Plan.retained_match_iff ((planTree types stem pat state).1.toPlan root) found + (by rw [PlanTree.written]; exact (List.nodup_cons.mp unique).1)] + rw [PlanTree.match_iff _ _ unique constant depth heap input locals found branch _ + (fun n hn h => bodyFresh n hn (List.mem_cons_of_mem _ h)) + (fun fallback present => fallbackFresh fallback (by simp [present]))] + rw [← planTree_match pat resolved types stem state constant depth heap input] + rw [ih _ tailSafe] + simp only [choose_cons_iff] + constructor + · rintro (⟨bindings, matched, ev⟩ | ⟨missed, bindings, body, selected, ev⟩) + · exact ⟨bindings, branch, Or.inl ⟨matched, rfl⟩, ev⟩ + · exact ⟨bindings, body, Or.inr ⟨missed, selected⟩, ev⟩ + · rintro ⟨bindings, body, (⟨matched, rfl⟩ | ⟨missed, selected⟩), ev⟩ + · exact Or.inl ⟨bindings, matched, ev⟩ + · exact Or.inr ⟨missed, bindings, body, selected, ev⟩ + +theorem armsSafe_fresh (safe : ArmsSafe types stem root arms state) + {pat : Pattern F} {body : Aiur.Expr F} (member : (pat, body) ∈ arms) : + ∀ n ∈ exprNames body, n ≠ root := by + induction arms generalizing state with + | nil => simp at member + | cons arm arms ih => + rcases arm with ⟨p, b⟩ + obtain ⟨_, _, fresh, _, safe⟩ := safe + rcases List.mem_cons.mp member with eq | member + · cases eq + exact fun n hn eq => fresh n hn (by simp [eq]) + · exact ih safe member + +private theorem choose_core (types : Types) (arms : List (Pattern F × Aiur.Expr F)) + {core : List (Aiur.Pattern F × Aiur.Expr F)} + (lowered : arms.mapM (fun arm => return (← arm.1.toCore? types, arm.2)) = some core) : + choose constant depth types heap input arms = .ok (Aiur.selectArm input core) := by + have related := option_mapM_relation lowered + clear lowered + induction related with + | nil => rfl + | @cons arm target arms core h _ ih => + rcases arm with ⟨pat, body⟩ + cases head : pat.toCore? types with + | none => simp [head] at h + | some cp => + have same : (cp, body) = target := by simpa [head] using h + subst target + rw [choose, Pattern.toCore_match pat head] + cases matched : cp.bindings input <;> + simp [bind, Except.bind, pure, Except.pure, Aiur.selectArm, matched, ih] + +/-- Ordered source matching and its circuit-language expression have exactly +the same successful branch, bindings, result, and heap. -/ +theorem lowerMatch_open_iff (types : Types) (value : Aiur.Expr F) (arms : List (Pattern F × Aiur.Expr F)) + (safe : MatchSafe types value arms) + (constant : String → Ty → Except EvalError (Pattern F)) (depth : Nat) + (locals : Environment F Nat) (before after : Heap F) (result : SourceValue F) : + OpenCore.EvalExpr world calls locals (lowerMatch types value arms) before result after ↔ + ∃ input middle bindings body, OpenCore.EvalExpr world calls locals value before input middle ∧ + choose constant depth types middle input arms = .ok (some (bindings, body)) ∧ + OpenCore.EvalExpr world calls (bindings ++ locals) body middle result after := by + unfold lowerMatch + split + · rename_i core lowered + rw [OpenCore.matchValue_iff] + apply exists_congr; intro input + apply exists_congr; intro middle + apply exists_congr; intro bindings + apply exists_congr; intro body + rw [choose_core types arms lowered] + simp only [Except.ok.injEq] + · rename_i lowered + simp only [MatchSafe, lowered] at safe + rw [OpenCore.bind_iff] + apply exists_congr; intro input + apply exists_congr; intro middle + simp only [exists_and_left] + apply and_congr_right; intro _ + let stem := freshPrefix (exprNames value ++ arms.flatMap (fun arm => arm.1.bindingNames ++ exprNames arm.2)) + let root := stem ++ "0" + have body_iff : OpenCore.EvalExpr world calls ((root, input) :: locals) + ((matchArms types stem root arms 1).1.getD (.matchValue (.var root) [])) middle result after ↔ + ∃ body, (matchArms types stem root arms 1).1 = some body ∧ + OpenCore.EvalExpr world calls ((root, input) :: locals) body middle result after := by + cases generated : (matchArms types stem root arms 1).1 with + | some body => simp only [Option.getD_some, Option.some.injEq, exists_eq_left'] + | none => + simp only [Option.getD_none, reduceCtorEq, false_and, exists_const, OpenCore.matchValue_iff, Aiur.selectArm] + simp + simp only [StateT.run] + rw [body_iff, matchArms_iff types stem root arms 1 safe constant depth middle input _ (by simp)] + apply exists_congr; intro bindings + apply exists_congr; intro body + apply and_congr_right; intro selected + obtain ⟨pat, member⟩ := choose_member selected + exact OpenCore.evalExpr_env_iff ((env_cons_fresh (armsSafe_fresh safe member)).prepend bindings) + +theorem lowerLet_iff (types : Types) (pat : Pattern F) (value body : Aiur.Expr F) + (safe : LetSafe types pat value body) + (constant : String → Ty → Except EvalError (Pattern F)) (depth : Nat) + (locals : Environment F Nat) (before after : Heap F) (result : SourceValue F) : + Engine.EvalExpr world locals (lowerLet types pat value body) before result after ↔ + ∃ input middle bindings, Engine.EvalExpr world locals value before input middle ∧ + matchPatternWith constant depth types middle pat input = .ok (some bindings) ∧ + Engine.EvalExpr world (bindings ++ locals) body middle result after := by + simpa only [OpenCore.closed_iff] using lowerLet_open_iff (world := world) (calls := Engine.EvalFn world) + types pat value body safe constant depth locals before after result + +theorem lowerMatch_iff (types : Types) (value : Aiur.Expr F) (arms : List (Pattern F × Aiur.Expr F)) + (safe : MatchSafe types value arms) + (constant : String → Ty → Except EvalError (Pattern F)) (depth : Nat) + (locals : Environment F Nat) (before after : Heap F) (result : SourceValue F) : + Engine.EvalExpr world locals (lowerMatch types value arms) before result after ↔ + ∃ input middle bindings body, Engine.EvalExpr world locals value before input middle ∧ + choose constant depth types middle input arms = .ok (some (bindings, body)) ∧ + Engine.EvalExpr world (bindings ++ locals) body middle result after := by + simpa only [OpenCore.closed_iff] using lowerMatch_open_iff (world := world) (calls := Engine.EvalFn world) + types value arms safe constant depth locals before after result + +end Aiur.Generic.PatternLowering diff --git a/Aiur/Aiur/Generic/PatternRetentionFacts.lean b/Aiur/Aiur/Generic/PatternRetentionFacts.lean new file mode 100644 index 000000000..0adc42c2f --- /dev/null +++ b/Aiur/Aiur/Generic/PatternRetentionFacts.lean @@ -0,0 +1,54 @@ +import Aiur.Generic.PatternContinuationFacts + +namespace Aiur.Generic.PatternLowering + +variable {calls : CallRelation F} + + +variable [DecidableEq F] {heap : Heap F} {locals final : Environment F Nat} + {steps : List (Step F)} {input : String} {value : SourceValue F} + +theorem Attempt.append_wildcard_iff + (found : locals.find? (·.1 == input) = some (input, value)) + (fresh : input ∉ writtenNames steps) : + Attempt heap (steps ++ [.test .wildcard input]) locals accepted final ↔ + Attempt heap steps locals accepted final := by + rw [Attempt.append_iff] + constructor + · rintro (⟨middle, first, last⟩ | ⟨rfl, failed⟩) + · cases last with + | testHit _ matched rest => + simp only [Aiur.Pattern.bindings, Option.some.injEq] at matched + subst_vars + cases rest + exact first + | testMiss _ missed => simp [Aiur.Pattern.bindings] at missed + · exact failed + · intro attempted + cases accepted with + | false => exact Or.inr ⟨rfl, attempted⟩ + | true => + exact Or.inl ⟨final, attempted, .testHit (bindings := []) + (by rw [attempted.unchanged fresh]; exact found) (by simp [Aiur.Pattern.bindings]) .done⟩ + +theorem Plan.retained_attempt_iff (p : Plan F) + (found : locals.find? (·.1 == input) = some (input, value)) + (fresh : input ∉ writtenNames p.steps) : + Attempt heap (p.retainedSteps input) locals accepted final ↔ Attempt heap p.steps locals accepted final := by + unfold Plan.retainedSteps + split + · rfl + · exact Attempt.append_wildcard_iff found fresh + +theorem Plan.retained_match_iff [Field F] {world : Engine.World F} + {failure : Option (Aiur.Expr F)} (p : Plan F) + (found : locals.find? (·.1 == input) = some (input, value)) + (fresh : input ∉ writtenNames p.steps) : + OpenCore.EvalExpr world calls locals (matchSteps (p.retainedSteps input) body failure) heap result after ↔ + OpenCore.EvalExpr world calls locals (matchSteps p.steps body failure) heap result after := by + rw [matchSteps_iff, matchSteps_iff] + apply exists_congr; intro accepted + apply exists_congr; intro final + exact and_congr (p.retained_attempt_iff found fresh) Iff.rfl + +end Aiur.Generic.PatternLowering diff --git a/Aiur/Aiur/Generic/PatternSequenceFacts.lean b/Aiur/Aiur/Generic/PatternSequenceFacts.lean new file mode 100644 index 000000000..1cfa21c51 --- /dev/null +++ b/Aiur/Aiur/Generic/PatternSequenceFacts.lean @@ -0,0 +1,153 @@ +import Aiur.Generic.PatternTreeNames + +namespace Aiur.Generic.PatternLowering +open SourceSemantics + +/-- Failure has no user bindings. On success, the temporary aliases recover +exactly the bindings returned by the native matcher. -/ +def Outcome (matched : Except EvalError (Option (Environment F Nat))) + (produced : Option (Environment F Nat)) (accepted : Bool) : Prop := + if accepted then ∃ bindings, matched = .ok (some bindings) ∧ produced = some bindings + else matched = .ok none + +theorem grouped_names_perm (parts : List A) (root : A → String) (temps : A → List String) : + (parts.map root ++ parts.flatMap temps).Perm (parts.flatMap fun part => root part :: temps part) := by + induction parts with + | nil => exact .refl _ + | cons part parts ih => + simp only [List.map_cons, List.flatMap_cons, List.cons_append] + apply List.Perm.cons + exact (List.perm_append_comm_assoc (parts.map root) (temps part) (parts.flatMap temps)).trans + (List.Perm.append_left _ ih) + +variable [DecidableEq F] + +theorem sequence_sound + (run : (String × PlanTree F) → SourceValue F → Except EvalError (Option (Environment F Nat))) + (parts : List (String × PlanTree F)) + (each : ∀ part ∈ parts, ∀ (locals : Environment F Nat) value accepted final, + (part.1 :: part.2.temps).Nodup → + locals.find? (·.1 == part.1) = some (part.1, value) → + Attempt heap (part.2.toPlan part.1).steps locals accepted final → + Outcome (run part value) (resolveBindings (part.2.toPlan part.1).bindings final) accepted) + (safe : (parts.flatMap fun part => part.1 :: part.2.temps).Nodup) + (inputs : List.Forall₂ (fun part value => locals.find? (·.1 == part.1) = some (part.1, value)) parts values) + (attempted : Attempt heap (parts.flatMap fun part => (part.2.toPlan part.1).steps) locals accepted final) : + Outcome (matchListWith run parts values) + (resolveBindings (parts.flatMap fun part => (part.2.toPlan part.1).bindings) final) accepted := by + induction parts generalizing locals values with + | nil => + cases inputs + cases attempted + exact ⟨[], rfl, rfl⟩ + | cons part parts ih => + cases inputs with + | cons head inputs => + rename_i value values + obtain ⟨partSafe, restSafe, separated⟩ := List.nodup_append.mp safe + rcases Attempt.append_iff.mp attempted with ⟨middle, first, rest⟩ | ⟨rfl, failed⟩ + · obtain ⟨bindings, matched, produced⟩ := each part (by simp) locals _ true middle partSafe head first + have nextInputs : List.Forall₂ + (fun part value => middle.find? (·.1 == part.1) = some (part.1, value)) parts values := by + have withMem : List.Forall₂ (fun p v => p ∈ parts ∧ locals.find? (·.1 == p.1) = some (p.1, v)) parts values := + (List.forall₂_and_left _ _).mpr ⟨fun _ h => h, inputs⟩ + apply withMem.imp + intro p v h + rw [first.unchanged] + · exact h.2 + · rw [PlanTree.written] + intro member + exact separated _ (by simp [member]) p.1 + (List.mem_flatMap.mpr ⟨p, h.1, by simp⟩) rfl + have tailOutcome := ih (fun p hp => each p (by simp [hp])) restSafe nextInputs rest + cases accepted with + | false => + simp only [Outcome, Bool.false_eq_true, ↓reduceIte] at tailOutcome ⊢ + simp only [matchListWith, matched, tailOutcome, bind, Except.bind, pure, Except.pure] + | true => + obtain ⟨tailBindings, tailMatched, tailProduced⟩ := tailOutcome + have firstProduced : resolveBindings (part.2.toPlan part.1).bindings final = some bindings := by + rw [resolveBindings_unchanged rest, produced] + intro n hn + have source := part.2.binding_sources part.1 n hn + change n ∉ writtenNames (parts.flatMap fun p => (p.2.toPlan p.1).steps) + rw [writtenNames_flatMap] + intro member + obtain ⟨p, hp, hn'⟩ := List.mem_flatMap.mp member + rw [PlanTree.written] at hn' + exact separated n (by simpa only [List.mem_cons] using source) n + (List.mem_flatMap.mpr ⟨p, hp, by simp [hn']⟩) rfl + refine ⟨bindings ++ tailBindings, ?_, ?_⟩ + · simp only [matchListWith, matched, tailMatched, bind, Except.bind, pure, Except.pure] + · simp only [List.flatMap_cons, resolveBindings_append, firstProduced, tailProduced, + bind, Option.bind, pure] + · have miss := each part (by simp) locals _ false final partSafe head failed + simp only [Outcome, Bool.false_eq_true, ↓reduceIte] at miss ⊢ + simp only [matchListWith, miss, bind, Except.bind, pure, Except.pure] + +/-- Successful native matching can execute the whole sequence of plans. +A failed earlier pattern needs no execution of any later pattern. -/ +theorem sequence_complete + (run : (String × PlanTree F) → SourceValue F → Except EvalError (Option (Environment F Nat))) + (parts : List (String × PlanTree F)) + (each : ∀ part ∈ parts, ∀ (locals : Environment F Nat) value outcome, + (part.1 :: part.2.temps).Nodup → + locals.find? (·.1 == part.1) = some (part.1, value) → + run part value = .ok outcome → + ∃ final, Attempt heap (part.2.toPlan part.1).steps locals outcome.isSome final) + (safe : (parts.flatMap fun part => part.1 :: part.2.temps).Nodup) + (inputs : List.Forall₂ (fun part value => locals.find? (·.1 == part.1) = some (part.1, value)) parts values) + (matched : matchListWith run parts values = .ok outcome) : + ∃ final, Attempt heap (parts.flatMap fun part => (part.2.toPlan part.1).steps) locals outcome.isSome final := by + induction parts generalizing locals values outcome with + | nil => + cases inputs + have same : outcome = some [] := by simpa [matchListWith, pure, Except.pure] using matched.symm + subst outcome + exact ⟨locals, .done⟩ + | cons part parts ih => + cases inputs with + | cons head inputs => + rename_i value values + obtain ⟨partSafe, restSafe, separated⟩ := List.nodup_append.mp safe + cases firstRun : run part value with + | error e => simp [matchListWith, firstRun, bind, Except.bind] at matched + | ok firstResult => + obtain ⟨middle, first⟩ := each part (by simp) locals value firstResult partSafe head firstRun + cases firstResult with + | none => + have same : outcome = none := by + simpa [matchListWith, firstRun, bind, Except.bind, pure, Except.pure] using matched.symm + subst outcome + exact ⟨middle, first.append_failed⟩ + | some bindings => + have nextInputs : List.Forall₂ + (fun part value => middle.find? (·.1 == part.1) = some (part.1, value)) parts values := by + have withMem : List.Forall₂ (fun p v => p ∈ parts ∧ locals.find? (·.1 == p.1) = some (p.1, v)) parts values := + (List.forall₂_and_left _ _).mpr ⟨fun _ h => h, inputs⟩ + apply withMem.imp + intro p v h + rw [first.unchanged] + · exact h.2 + · rw [PlanTree.written] + intro member + exact separated _ (by simp [member]) p.1 + (List.mem_flatMap.mpr ⟨p, h.1, by simp⟩) rfl + cases tailRun : matchListWith run parts values with + | error e => simp [matchListWith, firstRun, tailRun, bind, Except.bind] at matched + | ok tailResult => + obtain ⟨final, rest⟩ := ih (fun p hp => each p (by simp [hp])) restSafe nextInputs tailRun + have accepted : outcome.isSome = tailResult.isSome := by + cases tailResult with + | none => + have same : outcome = none := by + simpa [matchListWith, firstRun, tailRun, bind, Except.bind, pure, Except.pure] using matched.symm + simp only [same] + | some bs => + have same : outcome = some (bindings ++ bs) := by + simpa [matchListWith, firstRun, tailRun, bind, Except.bind, pure, Except.pure] using matched.symm + simp only [same, Option.isSome_some] + rw [accepted] + exact ⟨final, first.append rest⟩ + +end Aiur.Generic.PatternLowering diff --git a/Aiur/Aiur/Generic/PatternStepFacts.lean b/Aiur/Aiur/Generic/PatternStepFacts.lean new file mode 100644 index 000000000..78316f7e4 --- /dev/null +++ b/Aiur/Aiur/Generic/PatternStepFacts.lean @@ -0,0 +1,245 @@ +import Aiur.Generic.PatternFacts +import Aiur.Generic.EnvironmentFacts + +namespace Aiur.Generic.PatternLowering + +variable [DecidableEq F] {heap : Heap F} {front suffix steps : List (Step F)} + {locals middle final final' : Environment F Nat} + +theorem Attempt.append (first : Attempt heap front locals true middle) + (rest : Attempt heap suffix middle accepted final) : + Attempt heap (front ++ suffix) locals accepted final := by + induction front generalizing locals with + | nil => cases first; exact rest + | cons step front ih => + cases first with + | testHit found matched tail => exact .testHit found matched (ih tail) + | load found loaded tail => exact .load found loaded (ih tail) + | choiceLeft selected aligned copied tail => exact .choiceLeft selected aligned copied (ih tail) + | choiceRight missed selected aligned copied tail => exact .choiceRight missed selected aligned copied (ih tail) + +theorem Attempt.append_failed (first : Attempt heap front locals false final) : + Attempt heap (front ++ suffix) locals false final := by + induction front generalizing locals with + | nil => cases first + | cons step front ih => + cases first with + | testHit found matched tail => exact .testHit found matched (ih tail) + | testMiss found missed => exact .testMiss found missed + | choiceMiss left right => exact .choiceMiss left right + | load found loaded tail => exact .load found loaded (ih tail) + | choiceLeft selected aligned copied tail => exact .choiceLeft selected aligned copied (ih tail) + | choiceRight missed selected aligned copied tail => exact .choiceRight missed selected aligned copied (ih tail) + +/-- A rejected front never executes the suffix, even when it contains loads. -/ +theorem Attempt.append_iff : + Attempt heap (front ++ suffix) locals accepted final ↔ + (∃ middle, Attempt heap front locals true middle ∧ Attempt heap suffix middle accepted final) ∨ + (accepted = false ∧ Attempt heap front locals false final) := by + constructor + · intro attempted + induction front generalizing locals with + | nil => exact Or.inl ⟨locals, .done, attempted⟩ + | cons step front ih => + cases step with + | test pat input => + cases attempted with + | testHit found matched rest => + rcases ih rest with ⟨middle, first, last⟩ | ⟨rfl, first⟩ + · exact Or.inl ⟨middle, .testHit found matched first, last⟩ + · exact Or.inr ⟨rfl, .testHit found matched first⟩ + | testMiss found missed => exact Or.inr ⟨rfl, .testMiss found missed⟩ + | load name input => + cases attempted with + | load found loaded rest => + rcases ih rest with ⟨middle, first, last⟩ | ⟨rfl, first⟩ + · exact Or.inl ⟨middle, .load found loaded first, last⟩ + · exact Or.inr ⟨rfl, .load found loaded first⟩ + | choice outputs left lbs right rbs order => + cases attempted with + | choiceLeft selected aligned copied rest => + rcases ih rest with ⟨middle, first, last⟩ | ⟨rfl, first⟩ + · exact Or.inl ⟨middle, .choiceLeft selected aligned copied first, last⟩ + · exact Or.inr ⟨rfl, .choiceLeft selected aligned copied first⟩ + | choiceRight missed selected aligned copied rest => + rcases ih rest with ⟨middle, first, last⟩ | ⟨rfl, first⟩ + · exact Or.inl ⟨middle, .choiceRight missed selected aligned copied first, last⟩ + · exact Or.inr ⟨rfl, .choiceRight missed selected aligned copied first⟩ + | choiceMiss left right => exact Or.inr ⟨rfl, .choiceMiss left right⟩ + · rintro (⟨middle, first, rest⟩ | ⟨rfl, failed⟩) + · exact first.append rest + · exact failed.append_failed + +theorem Attempt.deterministic (left : Attempt heap steps locals accepted final) + (right : Attempt heap steps locals accepted' final') : accepted = accepted' ∧ final = final' := by + induction left generalizing accepted' final' with + | done => cases right; exact ⟨rfl, rfl⟩ + | testHit found matched rest ih => + cases right with + | testHit found' matched' rest' => + have same := Option.some.inj (found.symm.trans found') + cases Prod.mk.inj same |>.2 + have same := Option.some.inj (matched.symm.trans matched') + subst_vars + exact ih rest' + | testMiss found' missed => + have same := Option.some.inj (found.symm.trans found') + cases Prod.mk.inj same |>.2 + simp [matched] at missed + | testMiss found missed => + cases right with + | testHit found' matched rest' => + have same := Option.some.inj (found.symm.trans found') + cases Prod.mk.inj same |>.2 + simp [missed] at matched + | testMiss => exact ⟨rfl, rfl⟩ + | load found loaded rest ih => + cases right with + | load found' loaded' rest' => + have same := Option.some.inj (found.symm.trans found') + cases Prod.mk.inj same |>.2 + have same := Except.ok.inj (loaded.symm.trans loaded') + subst_vars + exact ih rest' + | choiceLeft selected aligned copied rest ihSelected ihRest => + cases right with + | choiceLeft selected' aligned' copied' rest' => + obtain ⟨_, rfl⟩ := ihSelected selected' + cases Option.some.inj (aligned.symm.trans aligned') + cases Option.some.inj (copied.symm.trans copied') + exact ihRest rest' + | choiceRight missed => cases (ihSelected missed).1 + | choiceMiss missed => cases (ihSelected missed).1 + | choiceRight missed selected aligned copied rest ihMissed ihSelected ihRest => + cases right with + | choiceLeft selected' => cases (ihMissed selected').1 + | choiceRight missed' selected' aligned' copied' rest' => + obtain ⟨_, rfl⟩ := ihMissed missed' + obtain ⟨_, rfl⟩ := ihSelected selected' + cases Option.some.inj (aligned.symm.trans aligned') + cases Option.some.inj (copied.symm.trans copied') + exact ihRest rest' + | choiceMiss missed' rejected' => + obtain ⟨_, rfl⟩ := ihMissed missed' + cases (ihSelected rejected').1 + | choiceMiss missed rejected ihMissed ihRejected => + cases right with + | choiceLeft selected' => cases (ihMissed selected').1 + | choiceRight missed' selected' => + obtain ⟨_, rfl⟩ := ihMissed missed' + cases (ihRejected selected').1 + | choiceMiss missed' rejected' => + obtain ⟨_, rfl⟩ := ihMissed missed' + exact ihRejected rejected' + +mutual + theorem bindings_names {pat : Aiur.Pattern F} {value : SourceValue F} + (matched : pat.bindings value = some bindings) : bindings.map Prod.fst = patternNames pat := by + cases pat with + | wildcard | bind => + simp only [Aiur.Pattern.bindings, Option.some.injEq] at matched + subst bindings; simp only [patternNames, List.map_cons, List.map_nil] + | literal x => + cases value <;> simp only [Aiur.Pattern.bindings] at matched + all_goals first | contradiction | skip + split at matched + · cases Option.some.inj matched; simp only [patternNames, List.map_nil, List.flatMap_nil] + · contradiction + | tuple ps => + cases value <;> simp only [Aiur.Pattern.bindings] at matched + all_goals first | contradiction | skip + simpa only [patternNames] using bindingsList_names matched + | construct n c ps => + cases value <;> simp only [Aiur.Pattern.bindings] at matched + all_goals first | contradiction | skip + split at matched + · simpa only [patternNames] using bindingsList_names matched + · contradiction + termination_by sizeOf pat + + theorem bindingsList_names {ps : List (Aiur.Pattern F)} {values : List (SourceValue F)} + (matched : Aiur.Pattern.bindingsList ps values = some bindings) : + bindings.map Prod.fst = ps.flatMap patternNames := by + cases ps with + | nil => + cases values <;> simp only [Aiur.Pattern.bindingsList] at matched + all_goals first | contradiction | skip + cases Option.some.inj matched; simp only [patternNames, List.map_nil, List.flatMap_nil] + | cons p ps => + cases values with + | nil => simp [Aiur.Pattern.bindingsList] at matched + | cons v vs => + cases head : p.bindings v with + | none => simp [Aiur.Pattern.bindingsList, head] at matched + | some first => + cases tail : Aiur.Pattern.bindingsList ps vs with + | none => simp [Aiur.Pattern.bindingsList, head, tail] at matched + | some rest => + have same : first ++ rest = bindings := by + simpa [Aiur.Pattern.bindingsList, head, tail] using matched + rw [← same, List.map_append, bindings_names head, bindingsList_names tail] + rfl + termination_by sizeOf ps +end + +def stepNames : Step F → List String + | .test p _ => patternNames p + | .load n _ => [n] + | .choice outputs left _ right _ _ => + left.flatMap stepNames ++ right.flatMap stepNames ++ outputs.map Prod.snd +termination_by step => sizeOf step + +def writtenNames (steps : List (Step F)) : List String := steps.flatMap stepNames + + +private theorem find_prepend_of_not_mem {added locals : Environment F Nat} + (fresh : name ∉ added.map Prod.fst) : + (added ++ locals).find? (·.1 == name) = locals.find? (·.1 == name) := by + induction added with + | nil => rfl + | cons b added ih => + have ne : b.1 ≠ name := by intro h; apply fresh; simp [h] + have rest : name ∉ added.map Prod.fst := fun h => fresh (by simp [h]) + simpa [List.find?, ne] using ih rest + +/-- A pattern attempt only shadows its listed temporary names. This holds on +failure as well as success, so an inactive arm cannot alter caller bindings. -/ +theorem Attempt.unchanged (attempted : Attempt heap steps locals accepted final) + (untouched : name ∉ writtenNames steps) : + final.find? (·.1 == name) = locals.find? (·.1 == name) := by + induction attempted with + | done | testMiss => rfl + | testHit found matched _ ih => + rw [ih (by + intro h + apply untouched + simp only [writtenNames, stepNames, List.flatMap_cons, List.mem_append] + exact Or.inr h)] + apply find_prepend_of_not_mem + rw [bindings_names matched] + intro h; apply untouched; simp [writtenNames, stepNames, h] + | load found loaded _ ih => + simp only [writtenNames, stepNames, List.flatMap_cons, List.singleton_append, List.mem_cons, not_or] at untouched + rw [ih untouched.2] + have notSame := beq_eq_false_iff_ne.mpr (Ne.symm untouched.1) + simp only [List.find?_cons, notSame, Bool.false_eq_true, ↓reduceIte] + | choiceLeft selected aligned copied rest ihSelected ihRest => + have fresh := untouched + simp only [writtenNames, stepNames, List.flatMap_cons, List.mem_append, not_or, and_assoc] at fresh + rw [ihRest fresh.2.2.2, find_prepend_of_not_mem, ihSelected fresh.1] + rw [resolveBindings_names copied] + rw [reorderBindings_names aligned] + exact fresh.2.2.1 + | choiceRight missed selected aligned copied rest ihMissed ihSelected ihRest => + have fresh := untouched + simp only [writtenNames, stepNames, List.flatMap_cons, List.mem_append, not_or, and_assoc] at fresh + rw [ihRest fresh.2.2.2, find_prepend_of_not_mem, ihSelected fresh.2.1, ihMissed fresh.1] + rw [resolveBindings_names copied] + rw [reorderBindings_names aligned] + exact fresh.2.2.1 + | choiceMiss missed rejected ihMissed ihRejected => + have fresh := untouched + simp only [writtenNames, stepNames, List.flatMap_cons, List.mem_append, not_or, and_assoc] at fresh + rw [ihRejected fresh.2.1, ihMissed fresh.1] + +end Aiur.Generic.PatternLowering diff --git a/Aiur/Aiur/Generic/PatternTranslation.lean b/Aiur/Aiur/Generic/PatternTranslation.lean new file mode 100644 index 000000000..c4a3a8bba --- /dev/null +++ b/Aiur/Aiur/Generic/PatternTranslation.lean @@ -0,0 +1,182 @@ +import Aiur.Generic.SourceSemantics +import Aiur.Generic.RecordFacts +import Aiur.Generic.PatternFacts +import Mathlib.Data.List.Forall2 + +namespace Aiur.Generic +open SourceSemantics + +theorem option_mapM_relation {f : A → Option B} {xs : List A} {ys : List B} + (mapped : xs.mapM f = some ys) : List.Forall₂ (fun x y => f x = some y) xs ys := by + induction xs generalizing ys with + | nil => simp at mapped; subst ys; exact .nil + | cons x xs ih => + cases head : f x with + | none => simp [List.mapM_cons, head] at mapped + | some y => + cases tail : xs.mapM f with + | none => simp [List.mapM_cons, head, tail] at mapped + | some rest => + have same : y :: rest = ys := by simpa [List.mapM_cons, head, tail] using mapped + subst ys + exact .cons head (ih tail) + +private theorem bindingsList_length [DecidableEq F] {ps : List (Aiur.Pattern F)} + {values : List (SourceValue F)} (different : ps.length ≠ values.length) : + Aiur.Pattern.bindingsList ps values = none := by + induction ps generalizing values with + | nil => cases values <;> simp_all [Aiur.Pattern.bindingsList] + | cons p ps ih => + cases values with + | nil => simp [Aiur.Pattern.bindingsList, matchListWith] + | cons v vs => + have h : ps.length ≠ vs.length := by simpa using different + simp [Aiur.Pattern.bindingsList, ih h] + +private theorem matchList_core [DecidableEq F] + {run : A → SourceValue F → Except EvalError (Option (Environment F Nat))} + {xs : List A} {ps : List (Aiur.Pattern F)} + (related : List.Forall₂ (fun x p => ∀ v, run x v = .ok (p.bindings v)) xs ps) + (values : List (SourceValue F)) : + matchListWith run xs values = .ok (Aiur.Pattern.bindingsList ps values) := by + induction related generalizing values with + | nil => cases values <;> simp [Aiur.Pattern.bindingsList, matchListWith] + | @cons x p xs ps h related ih => + cases values with + | nil => simp [Aiur.Pattern.bindingsList, matchListWith] + | cons v vs => + simp only [matchListWith, h, Aiur.Pattern.bindingsList] + cases matched : p.bindings v <;> cases tail : Aiur.Pattern.bindingsList ps vs <;> + simp [ih vs, tail, bind, Except.bind, pure, Except.pure] + +/-- Pure patterns are translated without changing their ordered bindings or +matching condition. Arrays and repeated patterns retain their source meaning +while using tuple storage in the compiler language. -/ +theorem Pattern.toCore_match [DecidableEq F] (pat : Pattern F) {core : Aiur.Pattern F} + (lowered : pat.toCore? types = some core) (value : SourceValue F) : + matchPatternWith constant depth types heap pat value = .ok (core.bindings value) := by + have sub (p : Pattern F) (smaller : sizeOf p < sizeOf pat) {c : Aiur.Pattern F} + (h : p.toCore? types = some c) (v : SourceValue F) : + matchPatternWith constant depth types heap p v = .ok (c.bindings v) := + Pattern.toCore_match p h v + have children (ps : List (Pattern F)) (smaller : ∀ p ∈ ps, sizeOf p < sizeOf pat) + (cs : List (Aiur.Pattern F)) (h : ps.mapM (Pattern.toCore? types) = some cs) + (vs : List (SourceValue F)) : + matchListWith (fun p v => matchPatternWith constant depth types heap p.val v) ps.attach vs = + .ok (Aiur.Pattern.bindingsList cs vs) := by + have rel := option_mapM_relation h + have attached : List.Forall₂ (fun p c => p.val.toCore? types = some c) ps.attach cs := by + apply (List.forall₂_map_left_iff (R := fun p c => p.toCore? types = some c) + (f := fun p : { p // p ∈ ps } => p.val)).mp + simpa using rel + apply matchList_core (attached.imp ?_) vs + intro p c hc v + exact sub p.val (smaller p.val p.property) hc v + cases pat with + | literal x | wildcard | bind name => + simp only [Pattern.toCore?, Option.some.injEq] at lowered + subst core + simp only [matchPatternWith, Aiur.Pattern.bindings, pure, Except.pure] + | global | load | orElse => simp [Pattern.toCore?] at lowered + | tuple ps | array ps => + cases mapped : ps.mapM (Pattern.toCore? types) with + | none => simp [Pattern.toCore?, mapped] at lowered + | some cs => + have same : Aiur.Pattern.tuple cs = core := by simpa [Pattern.toCore?, mapped] using lowered + subst core + have lengths := (option_mapM_relation mapped).length_eq + cases value <;> simp only [matchPatternWith, Aiur.Pattern.bindings, pure, Except.pure, bind, Except.bind] + rename_i vs + by_cases equal : ps.length = vs.length + · simp only [equal, bne_self_eq_false, Bool.false_eq_true, ↓reduceIte] + exact children ps (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) cs mapped vs + · have unequal : cs.length ≠ vs.length := by omega + simp [equal, bindingsList_length unequal] + | «repeat» p n => + cases mapped : p.toCore? types with + | none => simp [Pattern.toCore?, mapped] at lowered + | some c => + have same : Aiur.Pattern.tuple (List.replicate n c) = core := by + simpa [Pattern.toCore?, mapped] using lowered + subst core + cases value <;> simp only [matchPatternWith, Aiur.Pattern.bindings, pure, Except.pure, bind, Except.bind] + rename_i vs + by_cases equal : vs.length = n + · simp only [equal, bne_self_eq_false, Bool.false_eq_true, ↓reduceIte] + have single := sub p (by simp_wf <;> omega) mapped + have rel : ∀ k, List.Forall₂ + (fun (_ : Unit) (cp : Aiur.Pattern F) => ∀ v, + matchPatternWith constant depth types heap p v = .ok (cp.bindings v)) + (List.replicate k ()) (List.replicate k c) := by + intro k + induction k with + | zero => exact .nil + | succ k ih => exact .cons single ih + exact matchList_core (rel n) vs + · have unequal : (List.replicate n c).length ≠ vs.length := by simp; omega + simp [equal, bindingsList_length unequal] + | record head ps => + cases type : (head.type.subst types).toCore <;> simp only [Pattern.toCore?, type] at lowered + all_goals first | contradiction | skip + rename_i name + cases mapped : ps.mapM (Pattern.toCore? types) with + | none => simp [mapped] at lowered + | some cs => + have same : Aiur.Pattern.construct name structConstructor (head.order cs .wildcard) = core := by + simpa [mapped] using lowered + subst core + have base := option_mapM_relation mapped + have withMem : List.Forall₂ (fun p c => p ∈ ps ∧ p.toCore? types = some c) ps cs := + (List.forall₂_and_left _ _).mpr ⟨fun _ h => h, base⟩ + have rel : List.Forall₂ (fun p c => ∀ v, + matchPatternWith constant depth types heap p v = .ok (c.bindings v)) ps cs := by + apply withMem.imp + intro p c h v + exact sub p (by simp_wf; have := List.sizeOf_lt_of_mem h.1; omega) h.2 v + have ordered := head.order_rel rel (a := Pattern.wildcard) (b := Aiur.Pattern.wildcard) + (by intro v; simp [matchPatternWith, Aiur.Pattern.bindings]) + cases value <;> simp only [match_record, Aiur.Pattern.bindings, constructorName, type] + rename_i actual ctor vs + by_cases names : actual = name + · subst actual + by_cases ctors : ctor = structConstructor + · subst ctor + simp only [beq_self_eq_true, bne_self_eq_false, Bool.false_or, true_and, ↓reduceIte] + by_cases equal : (head.order ps Pattern.wildcard).length = vs.length + · simp only [equal, bne_self_eq_false, Bool.false_eq_true, ↓reduceIte] + exact matchList_core ordered vs + · have unequal : (head.order cs Aiur.Pattern.wildcard).length ≠ vs.length := by + rw [← ordered.length_eq]; exact equal + have different : (head.positions ps.length).length ≠ vs.length := by simpa using equal + simp [different, bindingsList_length unequal] + · simp [ctors, Ne.symm ctors] + · simp [names, Ne.symm names] + | construct t ctor ps | constructAs _ t ctor ps => + cases type : (t.subst types).toCore <;> simp only [Pattern.toCore?, type] at lowered + all_goals first | contradiction | skip + rename_i name + cases mapped : ps.mapM (Pattern.toCore? types) with + | none => simp [mapped] at lowered + | some cs => + have same : Aiur.Pattern.construct name ctor cs = core := by simpa [mapped] using lowered + subst core + have lengths := (option_mapM_relation mapped).length_eq + cases value <;> simp only [matchPatternWith, Aiur.Pattern.bindings, pure, Except.pure, bind, Except.bind] + rename_i other ctor' vs + by_cases names : name = other + · subst other + by_cases ctors : ctor = ctor' + · subst ctor' + simp only [constructorName, type, beq_self_eq_true, bne_self_eq_false, + Bool.false_or, true_and, ↓reduceIte] + by_cases equal : ps.length = vs.length + · simp only [equal, bne_self_eq_false, Bool.false_eq_true, ↓reduceIte] + exact children ps (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) cs mapped vs + · have unequal : cs.length ≠ vs.length := by omega + simp [equal, bindingsList_length unequal] + · simp [constructorName, type, ctors, Ne.symm ctors] + · simp [constructorName, type, names, Ne.symm names] +termination_by sizeOf pat +decreasing_by all_goals exact smaller + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/PatternTreeCompleteness.lean b/Aiur/Aiur/Generic/PatternTreeCompleteness.lean new file mode 100644 index 000000000..67c0324db --- /dev/null +++ b/Aiur/Aiur/Generic/PatternTreeCompleteness.lean @@ -0,0 +1,153 @@ +import Aiur.Generic.PatternTreeSoundness + +namespace Aiur.Generic.PatternLowering +open SourceSemantics + +/-- Every non-error native pattern result has a matching execution of its +read/test plan. Inactive later tests and loads are never prerequisites. -/ +theorem PlanTree.attempt_complete [DecidableEq F] (tree : PlanTree F) (input : String) + (safe : (input :: tree.temps).Nodup) + (constant : String → Ty → Except EvalError (Pattern F)) (depth : Nat) + (heap : Heap F) (value : SourceValue F) (locals : Environment F Nat) + (found : locals.find? (·.1 == input) = some (input, value)) + {outcome : Option (Environment F Nat)} + (matched : matchPatternWith constant depth [] heap tree.erase value = .ok outcome) : + ∃ final, Attempt heap (tree.toPlan input).steps locals outcome.isSome final := by + have sub (child : PlanTree F) (smaller : sizeOf child < sizeOf tree) (name : String) + (safe : (name :: child.temps).Nodup) (value : SourceValue F) (locals : Environment F Nat) + (found : locals.find? (·.1 == name) = some (name, value)) {outcome} + (matched : matchPatternWith constant depth [] heap child.erase value = .ok outcome) : + ∃ final, Attempt heap (child.toPlan name).steps locals outcome.isSome final := + PlanTree.attempt_complete child name safe constant depth heap value locals found matched + have children (parts : List (String × PlanTree F)) + (smaller : ∀ p ∈ parts, sizeOf p.2 < sizeOf tree) + (safe : (parts.map Prod.fst ++ parts.flatMap (fun p => p.2.temps)).Nodup) + (values : List (SourceValue F)) (lengths : parts.length = values.length) + (locals : Environment F Nat) {outcome} + (matched : matchListWith (fun p v => matchPatternWith constant depth [] heap p.2.erase v) parts values = .ok outcome) : + ∃ final, Attempt heap (parts.flatMap (fun p => (p.2.toPlan p.1).steps)) + (((parts.map Prod.fst).zip values) ++ locals) outcome.isSome final := by + apply sequence_complete _ parts _ ((grouped_names_perm parts Prod.fst (fun p => p.2.temps)).nodup_iff.mp safe) _ matched + · intro part hp locals value outcome safe found matched + exact sub part.2 (smaller part hp) part.1 safe value locals found matched + · apply (List.forall₂_map_left_iff + (R := fun name value => (((parts.map Prod.fst).zip values) ++ locals).find? (·.1 == name) = some (name, value)) + (f := Prod.fst)).mp + exact lookup_zip _ values locals (List.nodup_append.mp safe).1 (by simpa using lengths) + cases tree with + | literal x => + simp only [PlanTree.erase, matchPatternWith, pure, Except.pure, Except.ok.injEq] at matched + subst outcome + simp only [PlanTree.toPlan] + cases bindings : (Aiur.Pattern.literal x).bindings value with + | none => exact ⟨locals, .testMiss found bindings⟩ + | some bs => exact ⟨bs ++ locals, .testHit found bindings .done⟩ + | wildcard | bind => + simp only [PlanTree.erase, matchPatternWith, pure, Except.pure, Except.ok.injEq] at matched + subst outcome + simp only [PlanTree.toPlan] + exact ⟨locals, .done⟩ + | choice stem left right layout => + obtain ⟨safeLeft, safeRight, unique⟩ := PlanTree.safe_choice safe + simp only [PlanTree.erase] at matched + simp only [PlanTree.toPlan] + cases outcome with + | none => + obtain ⟨hmLeft, hmRight⟩ := match_or_none_iff.mp matched + obtain ⟨middle, missed⟩ := sub left (by simp_wf; omega) input safeLeft value locals found hmLeft + have nextFound := missed.unchanged (by rw [PlanTree.written]; exact (List.nodup_cons.mp safeLeft).1) + rw [found] at nextFound + obtain ⟨final, rejected⟩ := sub right (by simp_wf; omega) input safeRight value middle nextFound hmRight + exact ⟨final, .choiceMiss missed rejected⟩ + | some ordered => + rcases match_or_some_iff.mp matched with ⟨bs, hm, reordered⟩ | ⟨failed, bs, hm, reordered⟩ + · obtain ⟨middle, selected⟩ := sub left (by simp_wf; omega) input safeLeft value locals found hm + obtain ⟨actual, same, resolved⟩ := left.attempt_sound input safeLeft constant depth heap value locals found selected + have same := Except.ok.inj (hm.symm.trans same) + cases Option.some.inj same + obtain ⟨aliases, installed, aligned, copied⟩ := choice_copy_exists (stem := stem) resolved reordered + refine ⟨installed ++ middle, .choiceLeft selected ?_ copied .done⟩ + simpa only [choiceBindings, List.length_map] using aligned + · obtain ⟨rejected, missed⟩ := sub left (by simp_wf; omega) input safeLeft value locals found failed + have nextFound := missed.unchanged (by rw [PlanTree.written]; exact (List.nodup_cons.mp safeLeft).1) + rw [found] at nextFound + obtain ⟨middle, selected⟩ := sub right (by simp_wf; omega) input safeRight value rejected nextFound hm + obtain ⟨actual, same, resolved⟩ := right.attempt_sound input safeRight constant depth heap value rejected nextFound selected + have same := Except.ok.inj (hm.symm.trans same) + cases Option.some.inj same + obtain ⟨aliases, installed, aligned, copied⟩ := choice_copy_exists (stem := stem) resolved reordered + exact ⟨installed ++ middle, .choiceRight missed selected aligned copied .done⟩ + | load name child => + simp only [PlanTree.erase, matchPatternWith, except_bind_ok] at matched + obtain ⟨contents, loaded, matched⟩ := matched + obtain ⟨final, rest⟩ := sub child (by simp_wf <;> omega) name (PlanTree.safe_load safe) + contents ((name, contents) :: locals) (by simp) matched + simp only [PlanTree.toPlan] + exact ⟨final, .load found loaded rest⟩ + | tuple parts => + have safeParts : (parts.map Prod.fst ++ parts.flatMap (fun p => p.2.temps)).Nodup := by + simpa only [PlanTree.temps] using (List.nodup_cons.mp safe).2 + have pats : parts.map (fun p => (Aiur.Pattern.bind p.1 : Aiur.Pattern F)) = + (parts.map Prod.fst).map Aiur.Pattern.bind := by simp only [List.map_map, Function.comp_def] + simp only [PlanTree.toPlan, List.map_map, List.flatMap_map, Function.comp_def] + rw [pats] + cases value with + | tuple values => + simp only [PlanTree.erase, matchPatternWith, Preparation.matchList_attach, List.length_map, + matchList_map] at matched + by_cases lengths : parts.length = values.length + · have matched : matchListWith (fun p v => matchPatternWith constant depth [] heap p.2.erase v) parts values = .ok outcome := by + convert matched using 1 <;> simp only [lengths, bne_self_eq_false, Bool.false_eq_true, ↓reduceIte, bind, Except.bind, + pure, Except.pure] <;> rfl + obtain ⟨final, rest⟩ := children parts (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; cases ‹String × PlanTree F›; simp_all only [Prod.mk.sizeOf_spec]; omega) + safeParts values lengths locals matched + exact ⟨final, .testHit found (by simpa [Aiur.Pattern.bindings] using bindingsList_binders (parts.map Prod.fst) values (by simpa using lengths)) rest⟩ + · have same : outcome = none := by + simpa [lengths, bind, Except.bind, pure, Except.pure] using matched.symm + subst outcome + exact ⟨locals, .testMiss found (by simp only [Aiur.Pattern.bindings, and_self, ↓reduceIte, bindingsList_binders_eq, List.length_map, lengths])⟩ + | _ => + simp only [PlanTree.erase, matchPatternWith, pure, Except.pure, Except.ok.injEq] at matched + subst outcome + exact ⟨locals, .testMiss found (by simp only [Aiur.Pattern.bindings])⟩ + | construct name ctor parts => + have safeParts : (parts.map Prod.fst ++ parts.flatMap (fun p => p.2.temps)).Nodup := by + simpa only [PlanTree.temps] using (List.nodup_cons.mp safe).2 + have pats : parts.map (fun p => (Aiur.Pattern.bind p.1 : Aiur.Pattern F)) = + (parts.map Prod.fst).map Aiur.Pattern.bind := by simp only [List.map_map, Function.comp_def] + simp only [PlanTree.toPlan, List.map_map, List.flatMap_map, Function.comp_def] + rw [pats] + cases value with + | construct other ctor' values => + simp only [PlanTree.erase, matchPatternWith, nominal_name, Preparation.matchList_attach, + List.length_map, matchList_map] at matched + by_cases names : name = other ∧ ctor = ctor' + · rcases names with ⟨rfl, rfl⟩ + by_cases lengths : parts.length = values.length + · have matched : matchListWith (fun p v => matchPatternWith constant depth [] heap p.2.erase v) parts values = .ok outcome := by + convert matched using 1 <;> simp only [lengths, bne_self_eq_false, Bool.or_self, Bool.false_eq_true, ↓reduceIte, + bind, Except.bind, pure, Except.pure] <;> rfl + obtain ⟨final, rest⟩ := children parts (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; cases ‹String × PlanTree F›; simp_all only [Prod.mk.sizeOf_spec]; omega) + safeParts values lengths locals matched + exact ⟨final, .testHit found (by simpa [Aiur.Pattern.bindings] using bindingsList_binders (parts.map Prod.fst) values (by simpa using lengths)) rest⟩ + · have same : outcome = none := by + simpa [lengths, bind, Except.bind, pure, Except.pure] using matched.symm + subst outcome + exact ⟨locals, .testMiss found (by simp only [Aiur.Pattern.bindings, and_self, ↓reduceIte, bindingsList_binders_eq, List.length_map, lengths])⟩ + · have different : other ≠ name ∨ ctor' ≠ ctor := by + by_cases h : other = name + · right; intro hc; apply names; exact ⟨h.symm, hc.symm⟩ + · exact Or.inl h + have same : outcome = none := by + rcases different with h | h <;> + simpa [h, bind, Except.bind, pure, Except.pure] using matched.symm + subst outcome + exact ⟨locals, .testMiss found (by simp [Aiur.Pattern.bindings, names])⟩ + | _ => + simp only [PlanTree.erase, matchPatternWith, pure, Except.pure, Except.ok.injEq] at matched + subst outcome + exact ⟨locals, .testMiss found (by simp only [Aiur.Pattern.bindings])⟩ +termination_by sizeOf tree +decreasing_by exact smaller + +end Aiur.Generic.PatternLowering diff --git a/Aiur/Aiur/Generic/PatternTreeFacts.lean b/Aiur/Aiur/Generic/PatternTreeFacts.lean new file mode 100644 index 000000000..198a33728 --- /dev/null +++ b/Aiur/Aiur/Generic/PatternTreeFacts.lean @@ -0,0 +1,187 @@ +import Aiur.Generic.PatternBindingsFacts +import Aiur.Generic.PatternStepFacts +import Aiur.Generic.PreparationPatternFacts + +namespace Aiur.Generic.PatternLowering +open SourceSemantics + +theorem state_bind_run (f : StateM S A) (g : A → StateM S B) (s : S) : + (f >>= g) s = g (f s).1 (f s).2 := by + simp only [bind, StateT.bind] + cases f s; rfl + +theorem state_pure_run (value : A) (state : S) : (pure value : StateM S A) state = (value, state) := rfl + +theorem state_map_result (f : StateM S A) (g : A → B) (s : S) : + ((do let x ← f; pure (g x) : StateM S B) s).1 = g (f s).1 := by + rw [state_bind_run, state_pure_run] + +theorem fresh_run (stem : String) (n : Nat) : fresh stem n = (stem ++ toString n, n + 1) := rfl + +theorem state_mapM_relation (f : A → StateM S B) (xs : List A) (state : S) + {R : A → B → Prop} (each : ∀ x ∈ xs, ∀ s, R x (f x s).1) : + List.Forall₂ R xs (xs.mapM f state).1 := by + induction xs generalizing state with + | nil => exact .nil + | cons x xs ih => + simp only [List.mapM_cons, bind, StateT.bind, pure, StateT.pure] + exact .cons (each x (by simp) state) + (ih _ (fun x hx s => each x (by simp [hx]) s)) + +theorem matchList_map [DecidableEq F] + {run : B → SourceValue F → Except EvalError (Option (Environment F Nat))} + (f : A → B) (xs : List A) (values : List (SourceValue F)) : + matchListWith run (xs.map f) values = matchListWith (fun x v => run (f x) v) xs values := by + induction xs generalizing values with + | nil => cases values <;> rfl + | cons x xs ih => cases values <;> simp only [List.map_cons, matchListWith, ih] + +private theorem matches_tuple [DecidableEq F] (ps : List (Pattern F)) (value : SourceValue F) : + matchPatternWith constant depth types heap (.tuple ps) value = + match value with + | .tuple values => if ps.length != values.length then .ok none else + matchListWith (fun p v => matchPatternWith constant depth types heap p v) ps values + | _ => .ok none := by + cases value <;> simp only [matchPatternWith, Preparation.matchList_attach, pure, Except.pure, bind, Except.bind] + +/-- Naming compiler temporaries does not change a pattern. This theorem covers +nested loads, repeated patterns, nominal constructors and all failed matches. +Const references have already been unfolded by the proved preparation pass. -/ +theorem planTree_match [DecidableEq F] (pat : Pattern F) + (resolved : Consts.dependencies pat = []) (types stem state) + (constant : String → Ty → Except EvalError (Pattern F)) (depth : Nat) + (heap : Heap F) (value : SourceValue F) : + matchPatternWith constant depth types heap pat value = + matchPatternWith constant depth [] heap ((planTree types stem pat state).1.erase) value := by + have sub (p : Pattern F) (smaller : sizeOf p < sizeOf pat) + (resolved : Consts.dependencies p = []) (s : Nat) (v : SourceValue F) : + matchPatternWith constant depth types heap p v = + matchPatternWith constant depth [] heap ((planTree types stem p s).1.erase) v := + planTree_match p resolved types stem s constant depth heap v + have children (ps : List (Pattern F)) + (smaller : ∀ p ∈ ps, sizeOf p < sizeOf pat) + (resolved : ∀ p ∈ ps, Consts.dependencies p = []) (s : Nat) : + let parts := (ps.mapM (fun p => do + let n ← fresh stem + return (n, ← planTree types stem p)) s).1 + List.Forall₂ (fun p part => ∀ v, + matchPatternWith constant depth types heap p v = + matchPatternWith constant depth [] heap part.2.erase v) ps parts := by + apply state_mapM_relation + intro p hp s v + simp only [state_bind_run, state_pure_run, fresh_run] + exact sub p (smaller p hp) (resolved p hp) _ v + cases pat with + | literal x | wildcard | bind n => + simp only [planTree, pure, StateT.pure, PlanTree.erase, matchPatternWith] + | global n t => simp [Consts.dependencies] at resolved + | orElse left right layout => + have plain := resolved + simp only [Consts.dependencies, List.append_eq_nil_iff] at plain + simp only [planTree, state_bind_run, state_pure_run, fresh_run, PlanTree.erase, matchPatternWith] + rw [sub left (by simp_wf; omega) plain.1, sub right (by simp_wf; omega) plain.2] + | load p => + have hp : Consts.dependencies p = [] := by simpa only [Consts.dependencies] using resolved + simp only [planTree, state_bind_run, fresh_run, state_pure_run, PlanTree.erase, matchPatternWith] + cases loaded : loadValue heap value with + | error e => rfl + | ok v => exact sub p (by simp_wf <;> omega) hp _ v + | tuple ps | array ps => + have hp : ∀ p ∈ ps, Consts.dependencies p = [] := by + simpa only [Consts.dependencies, List.flatMap_eq_nil_iff] using resolved + have rel := children ps (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) hp state + have lengths := rel.length_eq + simp only [planTree, state_map_result, PlanTree.erase] + cases value <;> simp only [matchPatternWith, Preparation.matchList_attach, pure, Except.pure, bind, Except.bind, + List.length_map, lengths, matchList_map] + rename_i vs + split + · rfl + · exact Preparation.matchList_congr rel vs + | «repeat» p n => + have hp : Consts.dependencies p = [] := by simpa only [Consts.dependencies] using resolved + let parts := ((List.range n).mapM (fun (_ : Nat) => do + let name ← fresh stem + return (name, ← planTree types stem p)) state).1 + have rel : List.Forall₂ (fun (_ : Nat) part => ∀ v, + matchPatternWith constant depth types heap p v = + matchPatternWith constant depth [] heap part.2.erase v) (List.range n) parts := by + apply state_mapM_relation + intro _ _ s v + simp only [state_bind_run, state_pure_run, fresh_run] + exact sub p (by simp_wf; omega) hp _ v + have lengths : n = parts.length := by simpa only [List.length_range] using rel.length_eq + simp only [planTree, state_map_result, PlanTree.erase] + change matchPatternWith constant depth types heap (.repeat p n) value = + matchPatternWith constant depth [] heap (.tuple (parts.map fun part => part.2.erase)) value + cases value <;> simp only [matchPatternWith, Preparation.matchList_attach, List.length_map, + pure, Except.pure, bind, Except.bind] + rename_i vs + by_cases equal : vs.length = n + · simp only [← lengths, equal, bne_self_eq_false, Bool.false_eq_true, ↓reduceIte, matchList_map] + have units : (List.range n).map (fun _ => ()) = List.replicate n () := by simp + rw [← units, matchList_map] + exact Preparation.matchList_congr rel vs + · simp [← lengths, equal, Ne.symm equal] + | record head ps => + have hp : ∀ p ∈ ps, Consts.dependencies p = [] := by + simpa only [Consts.dependencies, List.flatMap_eq_nil_iff] using resolved + let selected : List (Option { p // p ∈ ps }) := head.order (ps.attach.map some) none + let parts : List (String × PlanTree F) := (selected.mapM (fun (child : Option { p // p ∈ ps }) => do + let name ← fresh stem + let tree ← match child with + | some p => planTree types stem p.val + | none => pure (PlanTree.wildcard : PlanTree F) + return (name, tree)) state).1 + have rel : List.Forall₂ (fun child part => ∀ v, + (match child with + | some p => matchPatternWith constant depth types heap p.val v + | none => pure (some [])) = + matchPatternWith constant depth [] heap part.2.erase v) selected parts := by + apply state_mapM_relation + intro child _ s v + cases child with + | none => simp [state_bind_run, state_pure_run, fresh_run, PlanTree.erase, matchPatternWith] + | some p => + simp only [state_bind_run, state_pure_run, fresh_run] + exact sub p.val (by simp_wf; have := List.sizeOf_lt_of_mem p.property; omega) (hp _ p.property) _ v + have lengths := rel.length_eq + simp only [planTree, state_map_result, PlanTree.erase] + change matchPatternWith constant depth types heap (.record head ps) value = + matchPatternWith constant depth [] heap + (.construct (.named (constructorName types head.type) []) structConstructor + (parts.map fun part => part.2.erase)) value + cases value <;> simp only [matchPatternWith, Preparation.matchList_attach, + constructorName, Ty.subst, Ty.toCore, Instance.symbol, List.map_nil, List.isEmpty_nil, + ↓reduceIte, pure, Except.pure, bind, Except.bind, List.length_map, matchList_map] + rename_i n c vs + change (if _ then _ else if selected.length != vs.length then _ else _) = _ + rw [lengths] + by_cases names : n = constructorName types head.type ∧ c = structConstructor + · obtain ⟨rfl, rfl⟩ := names + simp only [constructorName, bne_self_eq_false, Bool.false_or, Bool.false_eq_true, ↓reduceIte] + split + · rfl + · exact Preparation.matchList_congr rel _ + · have no : (n != constructorName types head.type || c != structConstructor) = true := by + simp only [Bool.or_eq_true, bne_iff_ne] + tauto + simp only [constructorName] at no + simp only [no, Bool.true_or, ↓reduceIte] + | construct t c ps | constructAs params t c ps => + have hp : ∀ p ∈ ps, Consts.dependencies p = [] := by + simpa only [Consts.dependencies, List.flatMap_eq_nil_iff] using resolved + have rel := children ps (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) hp state + have lengths := rel.length_eq + simp only [planTree, state_map_result, PlanTree.erase] + cases core : (t.subst types).toCore <;> + simp only [core, PlanTree.erase] + all_goals cases value <;> simp only [matchPatternWith, Preparation.matchList_attach, + constructorName, Ty.subst, Ty.toCore, Instance.symbol, List.map_nil, List.isEmpty_nil, + ↓reduceIte, core, pure, Except.pure, bind, Except.bind, List.length_map, lengths, matchList_map] + all_goals split + all_goals first | rfl | exact Preparation.matchList_congr rel _ +termination_by sizeOf pat +decreasing_by exact smaller + +end Aiur.Generic.PatternLowering diff --git a/Aiur/Aiur/Generic/PatternTreeNames.lean b/Aiur/Aiur/Generic/PatternTreeNames.lean new file mode 100644 index 000000000..c964d2f34 --- /dev/null +++ b/Aiur/Aiur/Generic/PatternTreeNames.lean @@ -0,0 +1,108 @@ +import Aiur.Generic.PatternTreeFacts +import Mathlib.Data.List.Nodup + +namespace Aiur.Generic.PatternLowering + + +theorem writtenNames_append (left right : List (Step F)) : + writtenNames (left ++ right) = writtenNames left ++ writtenNames right := by + simp only [writtenNames, stepNames, List.flatMap_append] + +theorem writtenNames_flatMap (parts : List A) (steps : A → List (Step F)) : + writtenNames (parts.flatMap steps) = parts.flatMap (fun part => writtenNames (steps part)) := by + simp only [writtenNames, stepNames, List.flatMap_assoc] + +theorem PlanTree.written (tree : PlanTree F) (input : String) : + writtenNames (tree.toPlan input).steps = tree.temps := by + have sub (t : PlanTree F) (smaller : sizeOf t < sizeOf tree) (n : String) : + writtenNames (t.toPlan n).steps = t.temps := PlanTree.written t n + cases tree with + | literal | wildcard | bind => simp only [PlanTree.toPlan, PlanTree.temps, writtenNames, stepNames, + List.flatMap_cons, List.flatMap_nil, patternNames, List.nil_append] + | choice stem left right layout => + simp only [PlanTree.toPlan, PlanTree.temps, writtenNames, stepNames, List.flatMap_cons, List.flatMap_nil, + stepNames, List.append_nil] + rw [← writtenNames, ← writtenNames, sub left (by simp_wf; omega), sub right (by simp_wf; omega)] + | load name child => + simpa only [PlanTree.toPlan, PlanTree.temps, writtenNames, stepNames, List.flatMap_cons, + List.singleton_append] using congrArg (name :: ·) (sub child (by simp_wf <;> omega) name) + | tuple parts | construct _ _ parts => + have children : parts.flatMap (fun part => writtenNames (part.2.toPlan part.1).steps) = + parts.flatMap (fun part => part.2.temps) := by + apply List.flatMap_congr + intro part hp + exact sub part.2 (by simp_wf; have := List.sizeOf_lt_of_mem hp; cases part; simp_all only [Prod.mk.sizeOf_spec]; omega) part.1 + simp only [PlanTree.toPlan, PlanTree.temps, writtenNames, stepNames, List.flatMap_cons, + patternNames, List.map_map, List.flatMap_map, Function.comp_def, List.flatMap_assoc] + change _ ++ parts.flatMap (fun part => writtenNames (part.2.toPlan part.1).steps) = _ + rw [children] + congr 1 + change parts.flatMap (fun part => [part.1]) = parts.map Prod.fst + exact List.map_eq_flatMap.symm +termination_by sizeOf tree +decreasing_by exact smaller + +/-- Every temporary used to recover a user binding belongs to this pattern's +input or its generated names. Later sibling patterns cannot change it. -/ +theorem PlanTree.binding_sources (tree : PlanTree F) (input : String) : + ∀ n ∈ (tree.toPlan input).bindings.map Prod.snd, n = input ∨ n ∈ tree.temps := by + have sub (t : PlanTree F) (smaller : sizeOf t < sizeOf tree) (input n : String) + (member : n ∈ (t.toPlan input).bindings.map Prod.snd) : n = input ∨ n ∈ t.temps := + PlanTree.binding_sources t input n member + cases tree with + | literal | wildcard => simp only [PlanTree.toPlan, List.map_nil, List.not_mem_nil, false_implies, implies_true] + | bind => simp only [PlanTree.toPlan, List.map_cons, List.map_nil, List.mem_singleton]; intros; exact Or.inl ‹_› + | choice stem left right layout => + intro n member + exact Or.inr (by simpa only [PlanTree.toPlan, PlanTree.temps, List.mem_append] using Or.inr member) + | load name child => + intro n member + rcases sub child (by simp_wf <;> omega) name n (by simpa only [PlanTree.toPlan] using member) with rfl | h + · exact Or.inr (by simp [PlanTree.temps]) + · exact Or.inr (by simp [PlanTree.temps, h]) + | tuple parts | construct _ _ parts => + intro n member + simp only [PlanTree.toPlan, List.flatMap_map, List.map_flatMap, List.mem_flatMap] at member + obtain ⟨part, hp, member⟩ := member + have h := sub part.2 (by simp_wf; have := List.sizeOf_lt_of_mem hp; cases part; simp_all only [Prod.mk.sizeOf_spec]; omega) part.1 n member + apply Or.inr + rcases h with rfl | h + · simp only [PlanTree.temps, List.mem_append, List.mem_map] + exact Or.inl ⟨part, hp, rfl⟩ + · simp only [PlanTree.temps, List.mem_append, List.mem_flatMap] + exact Or.inr ⟨part, hp, h⟩ +termination_by sizeOf tree +decreasing_by exact smaller + +theorem PlanTree.safe_choice {stem : String} {left right : PlanTree F} {layout : OrBindings} + (safe : (input :: (PlanTree.choice stem left right layout).temps).Nodup) : + (input :: left.temps).Nodup ∧ (input :: right.temps).Nodup ∧ + ((choiceBindings stem layout.names).map Prod.snd).Nodup := by + simp only [PlanTree.temps, List.nodup_cons, List.mem_append, not_or, List.nodup_append] at safe ⊢ + tauto + +theorem PlanTree.safe_load {name : String} {child : PlanTree F} + (safe : (input :: (PlanTree.load name child).temps).Nodup) : + (name :: child.temps).Nodup := by + simpa only [PlanTree.temps] using List.nodup_cons.mp safe |>.2 + +theorem PlanTree.safe_children {parts : List (String × PlanTree F)} + (safe : (parts.map Prod.fst ++ parts.flatMap (fun part => part.2.temps)).Nodup) + {part : String × PlanTree F} (member : part ∈ parts) : + (part.1 :: part.2.temps).Nodup := by + obtain ⟨names, temps, disjoint⟩ := List.nodup_append.mp safe + rw [List.nodup_cons] + constructor + · intro h + exact disjoint _ (List.mem_map.mpr ⟨part, member, rfl⟩) _ + (List.mem_flatMap.mpr ⟨part, member, h⟩) rfl + · exact (List.nodup_flatMap.mp temps).1 part member + +theorem resolveBindings_unchanged [DecidableEq F] + {heap : Heap F} {steps : List (Step F)} {locals final : Environment F Nat} + (attempted : Attempt heap steps locals accepted final) + (disjoint : ∀ n ∈ links.map Prod.snd, n ∉ writtenNames steps) : + resolveBindings links final = resolveBindings links locals := + resolveBindings_congr (fun n hn => attempted.unchanged (disjoint n hn)) + +end Aiur.Generic.PatternLowering diff --git a/Aiur/Aiur/Generic/PatternTreeSoundness.lean b/Aiur/Aiur/Generic/PatternTreeSoundness.lean new file mode 100644 index 000000000..e27f230d1 --- /dev/null +++ b/Aiur/Aiur/Generic/PatternTreeSoundness.lean @@ -0,0 +1,201 @@ +import Aiur.Generic.PatternSequenceFacts +import Aiur.Generic.PatternChoiceFacts +import Aiur.Generic.OrPatternFacts + +namespace Aiur.Generic.PatternLowering +open SourceSemantics + +theorem nominal_name (n : String) : constructorName [] (.named n []) = n := by + simp [constructorName, Ty.subst, Ty.toCore, Instance.symbol] + +private theorem tuple_miss [DecidableEq F] (patterns : List (Pattern F)) (names : List String) + (lengths : patterns.length = names.length) (value : SourceValue F) + (missed : (Aiur.Pattern.tuple (names.map Aiur.Pattern.bind)).bindings value = none) : + matchPatternWith constant depth [] heap (.tuple patterns) value = .ok none := by + cases value <;> simp only [matchPatternWith, pure, Except.pure, bind, Except.bind] + rename_i values + simp only [Aiur.Pattern.bindings, bindingsList_binders_eq] at missed + have different : names.length ≠ values.length := by intro h; simp [h] at missed + simp [lengths, different] + +private theorem construct_miss [DecidableEq F] (patterns : List (Pattern F)) (names : List String) + (lengths : patterns.length = names.length) (name ctor : String) (value : SourceValue F) + (missed : (Aiur.Pattern.construct name ctor (names.map Aiur.Pattern.bind)).bindings value = none) : + matchPatternWith constant depth [] heap (.construct (.named name []) ctor patterns) value = .ok none := by + cases value <;> simp only [matchPatternWith, nominal_name, pure, Except.pure, bind, Except.bind] + rename_i other ctor' values + by_cases namesEq : name = other + · subst other + by_cases ctorEq : ctor = ctor' + · subst ctor' + simp only [Aiur.Pattern.bindings, true_and, and_self, ↓reduceIte, bindingsList_binders_eq] at missed + have different : names.length ≠ values.length := by intro h; simp [h] at missed + simp [lengths, different] + · simp [ctorEq, Ne.symm ctorEq] + · simp [namesEq, Ne.symm namesEq] + +/-- Soundness of a flattened pattern plan, before its enclosing let or match +continuation runs. The result recovers exactly the native user bindings. -/ +theorem PlanTree.attempt_sound [DecidableEq F] (tree : PlanTree F) (input : String) + (safe : (input :: tree.temps).Nodup) + (constant : String → Ty → Except EvalError (Pattern F)) (depth : Nat) + (heap : Heap F) (value : SourceValue F) (locals : Environment F Nat) + (found : locals.find? (·.1 == input) = some (input, value)) + {accepted : Bool} {final : Environment F Nat} + (attempted : Attempt heap (tree.toPlan input).steps locals accepted final) : + Outcome (matchPatternWith constant depth [] heap tree.erase value) + (resolveBindings (tree.toPlan input).bindings final) accepted := by + have sub (child : PlanTree F) (smaller : sizeOf child < sizeOf tree) (name : String) + (safe : (name :: child.temps).Nodup) (value : SourceValue F) (locals : Environment F Nat) + (found : locals.find? (·.1 == name) = some (name, value)) {accepted final} + (attempted : Attempt heap (child.toPlan name).steps locals accepted final) : + Outcome (matchPatternWith constant depth [] heap child.erase value) + (resolveBindings (child.toPlan name).bindings final) accepted := + PlanTree.attempt_sound child name safe constant depth heap value locals found attempted + have children (parts : List (String × PlanTree F)) + (smaller : ∀ p ∈ parts, sizeOf p.2 < sizeOf tree) + (safe : (parts.map Prod.fst ++ parts.flatMap (fun p => p.2.temps)).Nodup) + (values : List (SourceValue F)) (lengths : parts.length = values.length) + (locals : Environment F Nat) {accepted final} + (attempted : Attempt heap (parts.flatMap (fun p => (p.2.toPlan p.1).steps)) + (((parts.map Prod.fst).zip values) ++ locals) accepted final) : + Outcome (matchListWith (fun p v => matchPatternWith constant depth [] heap p.2.erase v) parts values) + (resolveBindings (parts.flatMap fun p => (p.2.toPlan p.1).bindings) final) accepted := by + apply sequence_sound _ parts _ ((grouped_names_perm parts Prod.fst (fun p => p.2.temps)).nodup_iff.mp safe) _ attempted + · intro part hp locals value accepted final safe found attempted + exact sub part.2 (smaller part hp) part.1 safe value locals found attempted + · apply (List.forall₂_map_left_iff + (R := fun name value => (((parts.map Prod.fst).zip values) ++ locals).find? (·.1 == name) = some (name, value)) + (f := Prod.fst)).mp + exact lookup_zip _ values locals (List.nodup_append.mp safe).1 (by simpa using lengths) + cases tree with + | literal x => + simp only [PlanTree.toPlan] at attempted ⊢ + cases attempted with + | testHit found' matched rest => + have same := Option.some.inj (found'.symm.trans found) + cases Prod.mk.inj same |>.2 + have empty := bindings_names matched + simp only [patternNames, List.map_eq_nil_iff] at empty + subst_vars + cases rest + exact ⟨[], by simp only [PlanTree.erase, matchPatternWith, matched, pure, Except.pure], rfl⟩ + | testMiss found' missed => + have same := Option.some.inj (found'.symm.trans found) + cases Prod.mk.inj same |>.2 + simp only [Outcome, Bool.false_eq_true, ↓reduceIte, PlanTree.erase, matchPatternWith, + missed, pure, Except.pure] + | wildcard => + simp only [PlanTree.toPlan] at attempted ⊢ + cases attempted + exact ⟨[], by simp only [PlanTree.erase, matchPatternWith, pure, Except.pure], rfl⟩ + | bind name => + simp only [PlanTree.toPlan] at attempted ⊢ + cases attempted + refine ⟨[(name, value)], by simp only [PlanTree.erase, matchPatternWith, pure, Except.pure], ?_⟩ + simp [resolveBindings_cons, found] + | choice stem left right layout => + obtain ⟨safeLeft, safeRight, unique⟩ := PlanTree.safe_choice safe + simp only [PlanTree.toPlan, PlanTree.erase] at attempted ⊢ + cases attempted with + | choiceLeft selected aligned copied rest => + cases rest + obtain ⟨bs, hm, resolved⟩ := sub left (by simp_wf; omega) input safeLeft value locals found selected + have aligned := aligned + simp only [choiceBindings, List.length_map] at aligned + obtain ⟨ordered, reordered, recovered⟩ := choice_copied resolved unique _ _ aligned copied + refine ⟨ordered, ?_, recovered⟩ + exact match_or_some_iff.mpr (Or.inl ⟨bs, hm, reordered⟩) + | choiceRight missed selected aligned copied rest => + cases rest + have failed := sub left (by simp_wf; omega) input safeLeft value locals found missed + have nextFound := missed.unchanged (by rw [PlanTree.written]; exact (List.nodup_cons.mp safeLeft).1) + rw [found] at nextFound + obtain ⟨bs, hm, resolved⟩ := sub right (by simp_wf; omega) input safeRight value _ nextFound selected + obtain ⟨ordered, reordered, recovered⟩ := choice_copied resolved unique _ _ aligned copied + refine ⟨ordered, ?_, recovered⟩ + exact match_or_some_iff.mpr (Or.inr ⟨failed, bs, hm, reordered⟩) + | choiceMiss missed rejected => + have failed := sub left (by simp_wf; omega) input safeLeft value locals found missed + have nextFound := missed.unchanged (by rw [PlanTree.written]; exact (List.nodup_cons.mp safeLeft).1) + rw [found] at nextFound + have failedRight := sub right (by simp_wf; omega) input safeRight value _ nextFound rejected + exact match_or_none_iff.mpr ⟨failed, failedRight⟩ + | load name child => + simp only [PlanTree.toPlan] at attempted ⊢ + cases attempted with + | load found' loaded rest => + have same := Option.some.inj (found'.symm.trans found) + cases Prod.mk.inj same |>.2 + rename_i childValue + have ih := sub child (by simp_wf <;> omega) name (PlanTree.safe_load safe) + childValue ((name, childValue) :: locals) (by simp) rest + convert ih using 1 <;> simp only [PlanTree.erase, matchPatternWith, loaded, bind, Except.bind] <;> rfl + | tuple parts => + have safeParts : (parts.map Prod.fst ++ parts.flatMap (fun p => p.2.temps)).Nodup := by + simpa only [PlanTree.temps] using (List.nodup_cons.mp safe).2 + have pats : parts.map (fun p => (Aiur.Pattern.bind p.1 : Aiur.Pattern F)) = + (parts.map Prod.fst).map Aiur.Pattern.bind := by simp only [List.map_map, Function.comp_def] + simp only [PlanTree.toPlan, List.map_map, List.flatMap_map, Function.comp_def] at attempted ⊢ + rw [pats] at attempted + cases attempted with + | testHit found' matched rest => + have same := Option.some.inj (found'.symm.trans found) + cases Prod.mk.inj same |>.2 + cases value <;> simp only [Aiur.Pattern.bindings] at matched + all_goals first | contradiction | skip + rename_i values + simp only [bindingsList_binders_eq] at matched + split at matched + · rename_i lengths + have same := Option.some.inj matched + subst_vars + have result := children parts (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; cases ‹String × PlanTree F›; simp_all only [Prod.mk.sizeOf_spec]; omega) + safeParts values (by simpa using lengths) locals rest + convert result using 1 <;> simp only [PlanTree.erase, matchPatternWith, Preparation.matchList_attach, List.length_map, + ← lengths, List.length_map, bne_self_eq_false, Bool.false_eq_true, ↓reduceIte, + pure, Except.pure, bind, Except.bind, matchList_map] <;> rfl + · contradiction + | testMiss found' missed => + have same := Option.some.inj (found'.symm.trans found) + cases Prod.mk.inj same |>.2 + simpa only [Outcome, PlanTree.erase, Bool.false_eq_true, ↓reduceIte] using + tuple_miss (parts.map fun p => p.2.erase) (parts.map Prod.fst) (by simp) value missed + | construct name ctor parts => + have safeParts : (parts.map Prod.fst ++ parts.flatMap (fun p => p.2.temps)).Nodup := by + simpa only [PlanTree.temps] using (List.nodup_cons.mp safe).2 + have pats : parts.map (fun p => (Aiur.Pattern.bind p.1 : Aiur.Pattern F)) = + (parts.map Prod.fst).map Aiur.Pattern.bind := by simp only [List.map_map, Function.comp_def] + simp only [PlanTree.toPlan, List.map_map, List.flatMap_map, Function.comp_def] at attempted ⊢ + rw [pats] at attempted + cases attempted with + | testHit found' matched rest => + have same := Option.some.inj (found'.symm.trans found) + cases Prod.mk.inj same |>.2 + cases value <;> simp only [Aiur.Pattern.bindings] at matched + all_goals first | contradiction | skip + rename_i other ctor' values + split at matched + · rename_i names + rcases names with ⟨rfl, rfl⟩ + simp only [bindingsList_binders_eq] at matched + split at matched + · rename_i lengths + have same := Option.some.inj matched + subst_vars + have result := children parts (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; cases ‹String × PlanTree F›; simp_all only [Prod.mk.sizeOf_spec]; omega) + safeParts values (by simpa using lengths) locals rest + convert result using 1 <;> simp only [PlanTree.erase, matchPatternWith, nominal_name, Preparation.matchList_attach, List.length_map, + ← lengths, List.length_map, bne_self_eq_false, Bool.or_self, Bool.false_eq_true, ↓reduceIte, + pure, Except.pure, bind, Except.bind, matchList_map] <;> rfl + · contradiction + · contradiction + | testMiss found' missed => + have same := Option.some.inj (found'.symm.trans found) + cases Prod.mk.inj same |>.2 + simpa only [Outcome, PlanTree.erase, Bool.false_eq_true, ↓reduceIte] using + construct_miss (parts.map fun p => p.2.erase) (parts.map Prod.fst) (by simp) name ctor value missed +termination_by sizeOf tree +decreasing_by exact smaller + +end Aiur.Generic.PatternLowering diff --git a/Aiur/Aiur/Generic/PatternTypeFacts.lean b/Aiur/Aiur/Generic/PatternTypeFacts.lean new file mode 100644 index 000000000..68fa8b669 --- /dev/null +++ b/Aiur/Aiur/Generic/PatternTypeFacts.lean @@ -0,0 +1,211 @@ +import Aiur.Generic.LoweringTypes +import Aiur.Generic.OrPatternFacts +import Aiur.Generic.PatternTreeFacts +import Aiur.Generic.PatternTreeSoundness +import Aiur.Memory.Typing + +namespace Aiur.Generic.PatternLowering +open SourceSemantics + +theorem load_good {decls : Declarations} {heap : Heap F} {target : Aiur.Ty} + (good : heap.Good decls) (loaded : loadValue heap (.ptr target address) = .ok value) : + value.type = target ∧ value.Good decls := by + cases found : heap[address]? with + | none => simp [loadValue, found] at loaded + | some stored => + by_cases typed : stored.type = target + · simp [loadValue, found, typed, bind, Except.bind, pure, Except.pure] at loaded + subst value + exact ⟨typed, good _ (List.mem_of_getElem? found)⟩ + · simp [loadValue, found, typed] at loaded + +theorem typeList_map (run : B → Aiur.Ty → Option LocalTypes) (f : A → B) + (xs : List A) (types : List Aiur.Ty) : + typeListWith run (xs.map f) types = typeListWith (fun x t => run (f x) t) xs types := by + induction xs generalizing types with + | nil => cases types <;> rfl + | cons x xs ih => cases types <;> simp only [List.map_cons, typeListWith, ih] + +theorem typeList_attach (run : A → Aiur.Ty → Option LocalTypes) (xs : List A) (types : List Aiur.Ty) : + typeListWith (fun x t => run x.val t) xs.attach types = typeListWith run xs types := by + rw [← typeList_map run Subtype.val, List.attach_map_subtype_val] + +private theorem sequence_typed [DecidableEq F] + {run : A → SourceValue F → Except EvalError (Option (Environment F Nat))} + {check : A → Aiur.Ty → Option LocalTypes} {xs : List A} {values : List (SourceValue F)} + (each : ∀ x ∈ xs, ∀ value bindings types, value.Good decls → + run x value = .ok (some bindings) → check x value.type = some types → + environmentTypes bindings = types ∧ bindings.Good decls) + (good : ∀ value ∈ values, value.Good decls) + (matched : matchListWith run xs values = .ok (some bindings)) + (typed : typeListWith check xs (values.map Value.type) = some types) : + environmentTypes bindings = types ∧ bindings.Good decls := by + induction xs generalizing values bindings types with + | nil => + cases values <;> simp only [matchListWith, pure, Except.pure, Except.ok.injEq] at matched + · cases matched + cases typed + exact ⟨rfl, by simp [Environment.Good]⟩ + · cases matched + | cons x xs ih => + cases values with + | nil => simp [matchListWith, pure, Except.pure] at matched + | cons value values => + cases head : run x value with + | error e => simp [matchListWith, head, bind, Except.bind] at matched + | ok result => cases result with + | none => simp [matchListWith, head, bind, Except.bind, pure, Except.pure] at matched + | some first => + cases tail : matchListWith run xs values with + | error e => simp [matchListWith, head, tail, bind, Except.bind] at matched + | ok result => cases result with + | none => simp [matchListWith, head, tail, bind, Except.bind, pure, Except.pure] at matched + | some rest => + have same : first ++ rest = bindings := by + simpa [matchListWith, head, tail, bind, Except.bind, pure, Except.pure] using matched + subst bindings + cases headType : check x value.type with + | none => simp [typeListWith, headType] at typed + | some firstType => + cases tailType : typeListWith check xs (values.map Value.type) with + | none => simp [typeListWith, headType, tailType] at typed + | some restType => + have same : firstType ++ restType = types := by + simpa [typeListWith, headType, tailType] using typed + subst types + obtain ⟨hf, gf⟩ := each x (by simp) value first firstType (good _ (by simp)) head headType + obtain ⟨hr, gr⟩ := ih (fun y hy => each y (by simp [hy])) + (fun v hv => good v (by simp [hv])) tail tailType + exact ⟨by simp only [environmentTypes_append, hf, hr], Environment.good_append.mpr ⟨gf, gr⟩⟩ + +theorem reorder_typed {names positions} {bindings ordered : Environment F Nat} + (same : environmentTypes bindings = types) (good : bindings.Good decls) + (reordered : reorderBindings names positions bindings = some ordered) + (typed : reorderBindings names positions types = some orderedTypes) : + environmentTypes ordered = orderedTypes ∧ ordered.Good decls := by + have mapped := reorderBindings_mapValues (Value.type (α := F) (Address := Nat)) names positions bindings + change reorderBindings names positions (environmentTypes bindings) = + (reorderBindings names positions bindings).map environmentTypes at mapped + rw [same, typed, reordered, Option.map_some] at mapped + exact ⟨(Option.some.inj mapped).symm, reorderBindings_good good reordered⟩ + +/-- A successful native match produces exactly its statically inferred user +binding types. Read-only loads preserve well-formed values from the heap. -/ +theorem PlanTree.match_typed [DecidableEq F] (tree : PlanTree F) + (heapGood : heap.Good decls) (valueGood : value.Good decls) + (matched : matchPatternWith constant depth [] heap tree.erase value = .ok (some bindings)) + (typed : tree.bindTypes decls value.type = some types) : + environmentTypes bindings = types ∧ bindings.Good decls := by + have sub (child : PlanTree F) (smaller : sizeOf child < sizeOf tree) + (v : SourceValue F) (bs : Environment F Nat) (ts : LocalTypes) + (vg : v.Good decls) + (hm : matchPatternWith constant depth [] heap child.erase v = .ok (some bs)) + (ht : child.bindTypes decls v.type = some ts) : + environmentTypes bs = ts ∧ bs.Good decls := + child.match_typed heapGood vg hm ht + have children (parts : List (String × PlanTree F)) + (smaller : ∀ part ∈ parts, sizeOf part.2 < sizeOf tree) + (values : List (SourceValue F)) (good : ∀ v ∈ values, v.Good decls) + (matched : matchListWith (fun part v => matchPatternWith constant depth [] heap part.2.erase v) + parts values = .ok (some bindings)) + (typed : typeListWith (fun part type => part.2.bindTypes decls type) parts (values.map Value.type) = some types) : + environmentTypes bindings = types ∧ bindings.Good decls := + sequence_typed (fun part member v bs ts vg hm ht => sub part.2 (smaller part member) v bs ts vg hm ht) + good matched typed + cases tree with + | wildcard => + simp only [PlanTree.erase, matchPatternWith, pure, Except.pure, Except.ok.injEq, Option.some.injEq] at matched + subst bindings + simp only [PlanTree.bindTypes, Option.some.injEq] at typed + subst types + exact ⟨rfl, by simp [Environment.Good]⟩ + | bind name => + simp only [PlanTree.erase, matchPatternWith, pure, Except.pure, Except.ok.injEq, Option.some.injEq] at matched + subst bindings + simp only [PlanTree.bindTypes, Option.some.injEq] at typed + subst types + exact ⟨rfl, by simpa [Environment.Good] using valueGood⟩ + | literal x => + cases value <;> simp only [Value.type, PlanTree.bindTypes] at typed + all_goals first | contradiction | skip + cases typed + simp only [PlanTree.erase, matchPatternWith, Aiur.Pattern.bindings, pure, Except.pure] at matched + split at matched + · cases matched; exact ⟨rfl, by simp [Environment.Good]⟩ + · cases matched + | choice stem left right layout => + rw [PlanTree.bindTypes] at typed + obtain ⟨lts, leftTyped, typed⟩ := Option.bind_eq_some_iff.mp typed + obtain ⟨rts, rightTyped, typed⟩ := Option.bind_eq_some_iff.mp typed + obtain ⟨lhs, lhsTyped, typed⟩ := Option.bind_eq_some_iff.mp typed + obtain ⟨rhs, rhsTyped, typed⟩ := Option.bind_eq_some_iff.mp typed + split at typed + · rename_i equal + have equal : lhs = rhs := by simpa using equal + have result : lhs = types := Option.some.inj typed + subst types + simp only [PlanTree.erase] at matched + rcases match_or_some_iff.mp matched with ⟨bs, matched, reordered⟩ | ⟨_, bs, matched, reordered⟩ + · obtain ⟨same, good⟩ := sub left (by simp_wf; omega) value bs lts valueGood matched leftTyped + exact reorder_typed same good reordered lhsTyped + · obtain ⟨same, good⟩ := sub right (by simp_wf; omega) value bs rts valueGood matched rightTyped + simpa only [equal] using reorder_typed same good reordered rhsTyped + · contradiction + | load name child => + cases value <;> simp only [Value.type, PlanTree.bindTypes] at typed + all_goals first | contradiction | skip + rename_i target address + simp only [PlanTree.erase, matchPatternWith, except_bind_ok] at matched + obtain ⟨stored, loaded, matched⟩ := matched + obtain ⟨shape, good⟩ := load_good heapGood loaded + exact sub child (by simp_wf <;> omega) stored _ _ good matched (by rw [shape]; exact typed) + | tuple parts => + cases value <;> simp only [Value.type, PlanTree.bindTypes] at typed + all_goals first | contradiction | skip + rename_i values + simp only [PlanTree.erase, matchPatternWith, List.length_map] at matched + split at matched + · cases matched + · simp only [Preparation.matchList_attach, matchList_map, pure_bind] at matched + rw [typeList_attach (fun (part : String × PlanTree F) type => part.2.bindTypes decls type)] at typed + exact children parts (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; cases ‹String × PlanTree F›; simp_all only [Prod.mk.sizeOf_spec]; omega) + values ((Value.good_tuple _ _).mp valueGood) matched typed + | construct name ctor parts => + cases value <;> simp only [Value.type, PlanTree.bindTypes] at typed + all_goals first | contradiction | skip + rename_i actual constructor values + simp only [PlanTree.erase, matchPatternWith, nominal_name, List.length_map] at matched + split at matched + · cases matched + · rename_i names + simp only [Bool.or_eq_true, bne_iff_ne, not_or, not_not] at names + obtain ⟨⟨rfl, rfl⟩, _⟩ := names + obtain ⟨definition, found, shape, fieldsGood⟩ := (Value.wellFormed_construct _ _ _ _).mp valueGood.1 + simp only [bne_self_eq_false, Bool.false_eq_true, ↓reduceIte, found, pure_bind] at typed + change typeListWith (fun child type => child.val.2.bindTypes decls type) + parts.attach definition.fields = some types at typed + rw [typeList_attach (fun (part : String × PlanTree F) type => part.2.bindTypes decls type), ← shape] at typed + simp only [Preparation.matchList_attach, matchList_map, pure_bind] at matched + exact children parts (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; cases ‹String × PlanTree F›; simp_all only [Prod.mk.sizeOf_spec]; omega) + values (fun v hv => ⟨fieldsGood v hv, + (Value.pointerNames_construct _ _ _ _).mp valueGood.2 v hv⟩) matched typed +termination_by sizeOf tree +decreasing_by exact smaller + +end Aiur.Generic.PatternLowering + +namespace Aiur.Generic + +theorem Pattern.lowerBindingTypes_sound [DecidableEq F] {pat : Pattern F} + (heapGood : heap.Good decls) (valueGood : value.Good decls) + (matched : SourceSemantics.matchPatternWith constant depth types heap pat value = .ok (some bindings)) + (typed : pat.lowerBindingTypes decls types value.type = some bindingTypes) : + environmentTypes bindings = bindingTypes ∧ bindings.Good decls := by + unfold Pattern.lowerBindingTypes at typed + split at typed + · rename_i resolved + rw [PatternLowering.planTree_match pat resolved types "" 0] at matched + exact PatternLowering.PlanTree.match_typed _ heapGood valueGood matched typed + · cases typed + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/Preparation.lean b/Aiur/Aiur/Generic/Preparation.lean new file mode 100644 index 000000000..761fc0a34 --- /dev/null +++ b/Aiur/Aiur/Generic/Preparation.lean @@ -0,0 +1,103 @@ +import Aiur.Generic.Runtime +import Aiur.Generic.LoweringChecks +import Aiur.Generic.ControlLower + +/-! Compiler preparation begins after the source semantics boundary. It +instantiates type metadata and unfolds checked const references using the same +one-declaration lookup as the source evaluator. It does not rerun inference on +an inlined function body. -/ + +namespace Aiur.Generic.Preparation + +def pattern (p : Program F) (depth : Nat) (types : SourceSemantics.Types) : + Pattern F → Except String (Pattern F) + | .literal x => pure (.literal x) + | .wildcard => pure .wildcard + | .bind name => pure (.bind name) + | .global name annotation => do + let some type := annotation | throw s!"missing type information for const '::{name}'" + match depth with + | 0 => throw "const dependency depth exceeded" + | depth + 1 => pattern p depth [] (← elaborateConst p name (type.subst types)) + | .orElse left right names => return .orElse (← pattern p depth types left) (← pattern p depth types right) names + | .load child => return .load (← pattern p depth types child) + | .record head children => return .record (head.subst types) (← children.mapM (pattern p depth types)) + | .tuple children => return .tuple (← children.mapM (pattern p depth types)) + | .array children => return .array (← children.mapM (pattern p depth types)) + | .repeat child n => return .repeat (← pattern p depth types child) n + | .construct t c children => + return .construct (t.subst types) c (← children.mapM (pattern p depth types)) + | .constructAs params t c children => + return .constructAs params (t.subst types) c (← children.mapM (pattern p depth types)) +termination_by pat => (depth, sizeOf pat) +decreasing_by + all_goals simp_wf + all_goals first | omega | have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega + +def expression (p : Program F) (depth : Nat) (types : SourceSemantics.Types) : + Expr F → Except String (Expr F) + | .control kind body => return .control kind (← expression p depth types body) + | .literal x => pure (.literal x) + | .var name => pure (.var name) + | .global name annotation => do + let some type := annotation | throw s!"missing type information for const '::{name}'" + match depth with + | 0 => throw "const dependency depth exceeded" + | depth + 1 => + let body ← Consts.toExpr (← elaborateConst p name (type.subst types)) + expression p depth [] body + | .builtin op children => return .builtin (op.subst types) (← children.mapM (expression p depth types)) + | .update paths children => return .update (paths.map (List.map (UpdateStep.subst types))) (← children.mapM (expression p depth types)) + | .record head children => return .record (head.subst types) (← children.mapM (expression p depth types)) + | .member child field => return .member (← expression p depth types child) (field.subst types) + | .tuple children => return .tuple (← children.mapM (expression p depth types)) + | .array children => return .array (← children.mapM (expression p depth types)) + | .repeat child n => return .repeat (← expression p depth types child) n + | .index child i => return .index (← expression p depth types child) i + | .slice child start stop => return .slice (← expression p depth types child) start stop + | .construct name args ctor children => + return .construct name (some ((args.getD []).map (Ty.subst types))) ctor + (← children.mapM (expression p depth types)) + | .constructAs params t c children => + return .constructAs params (t.subst types) c (← children.mapM (expression p depth types)) + | .project child i => return .project (← expression p depth types child) i + | .letValue pat value body => + return .letValue (← pattern p (p.consts.length + 1) types pat) + (← expression p depth types value) (← expression p depth types body) + | .store child => return .store (← expression p depth types child) + | .load child => return .load (← expression p depth types child) + | .hint t key channel => return .hint (t.subst types) (← expression p depth types key) channel + | .neg child => return .neg (← expression p depth types child) + | .binary op left right => + return .binary op (← expression p depth types left) (← expression p depth types right) + | .call name args children => + return .call name (some ((args.getD []).map (Ty.subst types))) + (← children.mapM (expression p depth types)) + | .matchValue value arms => + return .matchValue (← expression p depth types value) (← arms.mapM fun arm => do + return (← pattern p (p.consts.length + 1) types arm.1, ← expression p depth types arm.2)) +termination_by expr => (depth, sizeOf expr) +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +def function (p : Program F) (key : Instance) : Except String (Aiur.Function F) := do + let some fn := p.findFunction? key.name | throw s!"unknown function '{key.name}'" + let types ← arguments fn.typeParams key.types + let prepared ← expression p (p.consts.length + 1) types fn.body + let body ← ControlLower.function prepared (fn.params.map Prod.fst) + if !decide (body.lowerSafe []) then throw "lowering failed its syntax and temporary-scope checks" + return { + name := key.symbol + params := fn.params.map fun (name, type) => (name, (type.subst types).toCore) + result := (fn.result.subst types).toCore + body := body.lower [] } + +end Aiur.Generic.Preparation + +namespace Aiur.Generic + +def Source.compilerFunction? [DecidableEq F] (s : Source F) (name : String) : Option (Aiur.Function F) := + ((Instance.ofSymbol name).bind (Preparation.function s.program)).toOption + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/PreparationExpressionFacts.lean b/Aiur/Aiur/Generic/PreparationExpressionFacts.lean new file mode 100644 index 000000000..048fe92f1 --- /dev/null +++ b/Aiur/Aiur/Generic/PreparationExpressionFacts.lean @@ -0,0 +1,565 @@ +import Aiur.Generic.UpdateSubstitution +import Aiur.Generic.ConstScopeFacts +import Aiur.Generic.ControlNoExit + +namespace Aiur.Generic.Preparation + +theorem expression_closed (program : Program F) (depth : Nat) (types) (expr : Expr F) + (closed : Consts.Closed expr) {prepared : Expr F} + (expanded : expression program depth types expr = .ok prepared) : Consts.Closed prepared := by + have sub (d ts e) (smaller : Prod.Lex (· < ·) (· < ·) (d, sizeOf e) (depth, sizeOf expr)) + (hc : Consts.Closed e) {q : Expr F} (h : expression program d ts e = .ok q) : Consts.Closed q := + expression_closed program d ts e hc h + cases closed with + | literal => + simp only [expression, except_pure_ok] at expanded + subst prepared; exact .literal + | global => + rename_i n annotation + cases annotation with + | none => simp [expression] at expanded + | some t => + cases depth with + | zero => simp [expression] at expanded + | succ d => + simp only [expression, except_bind_ok] at expanded + obtain ⟨pat, _, body, interpreted, expanded⟩ := expanded + exact sub d [] body (Prod.Lex.left _ _ (by omega)) (Consts.toExpr_closed _ interpreted) expanded + | store hc | «repeat» hc => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨q, hq, rfl⟩ := expanded + constructor + exact sub _ _ _ (by apply Prod.Lex.right; simp_wf <;> omega) hc hq + | record hc | tuple hc | array hc | construct hc | constructAs hc => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨qs, hqs, rfl⟩ := expanded + constructor + refine mapM_forall hqs ?_ + intro e he q hq + exact sub _ _ _ (by apply Prod.Lex.right; simp_wf; have := List.sizeOf_lt_of_mem he; omega) + (hc e he) hq +termination_by (depth, sizeOf expr) +decreasing_by all_goals exact smaller + +end Aiur.Generic.Preparation + +namespace Aiur.Generic.SourceSemantics +variable {calls : CallRelation F} +open Preparation + +private theorem args_congr [Field F] [DecidableEq F] {world : World F} + {left right : Types} {xs ys : List (Expr F)} + (related : List.Forall₂ (fun x y => ∀ locals before result after, + OpenSource.EvalExpr world calls left locals x before result after ↔ + OpenSource.EvalExpr world calls right locals y before result after) xs ys) + (locals before values after) : + OpenSource.EvalArgs world calls left locals xs before values after ↔ OpenSource.EvalArgs world calls right locals ys before values after := by + induction related generalizing before values with + | nil => constructor <;> intro h <;> cases h <;> exact .nil + | cons h _ ih => + constructor + · intro ev; cases ev with + | cons head tail => exact .cons ((h _ _ _ _).mp head) ((ih _ _).mp tail) + · intro ev; cases ev with + | cons head tail => exact .cons ((h _ _ _ _).mpr head) ((ih _ _).mpr tail) + +private theorem args_exit_congr [Field F] [DecidableEq F] {world : World F} + {left right : Types} {xs ys : List (Expr F)} + (related : List.Forall₂ (fun x y => + (∀ locals before result after, OpenSource.EvalExpr world calls left locals x before result after ↔ + OpenSource.EvalExpr world calls right locals y before result after) ∧ + (∀ locals before target result after, OpenSource.EvalExit world calls left locals x before target result after ↔ + OpenSource.EvalExit world calls right locals y before target result after)) xs ys) + (locals before target result after) : + OpenSource.EvalArgsExit world calls left locals xs before target result after ↔ + OpenSource.EvalArgsExit world calls right locals ys before target result after := by + induction related generalizing before with + | nil => constructor <;> intro h <;> cases h + | cons h _ ih => + constructor + · intro ev; cases ev with + | head head => exact .head ((h.2 _ _ _ _ _).mp head) + | tail head tail => exact .tail ((h.1 _ _ _ _).mp head) ((ih _).mp tail) + · intro ev; cases ev with + | head head => exact .head ((h.2 _ _ _ _ _).mpr head) + | tail head tail => exact .tail ((h.1 _ _ _ _).mpr head) ((ih _).mpr tail) + +private theorem select_transfer [DecidableEq F] {world : World F} + {left right : Types} {arms others : List (Pattern F × Expr F)} + {R : Expr F → Expr F → Prop} + (related : List.Forall₂ (fun a b => + (∀ heap value, world.matchPattern left heap a.1 value = world.matchPattern right heap b.1 value) ∧ + R a.2 b.2) arms others) + (selected : selectArm world left heap value arms = .ok (some (bindings, body))) : + ∃ other, selectArm world right heap value others = .ok (some (bindings, other)) ∧ R body other := by + induction related with + | nil => simp [selectArm] at selected + | @cons a b arms others h _ ih => + cases matched : world.matchPattern left heap a.1 value with + | error e => simp [selectArm, matched, bind, Except.bind] at selected + | ok result => cases result with + | none => + obtain ⟨other, hs, hr⟩ := ih (by simpa [selectArm, matched, bind, Except.bind] using selected) + exact ⟨other, by simpa [selectArm, ← h.1, matched, bind, Except.bind] using hs, hr⟩ + | some bs => + have same : bs = bindings ∧ a.2 = body := by + simpa [selectArm, matched, bind, Except.bind, pure, Except.pure] using selected + obtain ⟨rfl, rfl⟩ := same + exact ⟨b.2, by simp [selectArm, ← h.1, matched, bind, Except.bind, pure, Except.pure], h.2⟩ + +mutual +/-- Compiler preparation preserves and reflects the independent source +predicate. Calls retain their ordinary source semantics; only type metadata +and checked declaration references change in this pass. -/ +theorem expression_preparation_open_iff [Field F] [DecidableEq F] + (program : Program F) (world : World F) + (lookup : ∀ n t, world.constant n t = (elaborateConst program n t).mapError + (fun _ => EvalError.unboundVariable ("::" ++ n))) + (constDepth : world.constDepth = program.consts.length + 1) + (depth : Nat) (types : Types) (expr : Expr F) {prepared : Expr F} + (expanded : expression program depth types expr = .ok prepared) + (locals before result after) : + OpenSource.EvalExpr world calls types locals expr before result after ↔ + OpenSource.EvalExpr world calls [] locals prepared before result after := by + have sub (d ts e) (smaller : Prod.Lex (· < ·) (· < ·) (d, sizeOf e) (depth, sizeOf expr)) + {q : Expr F} (h : expression program d ts e = .ok q) (ls b v a) : + OpenSource.EvalExpr world calls ts ls e b v a ↔ OpenSource.EvalExpr world calls [] ls q b v a := + expression_preparation_open_iff program world lookup constDepth d ts e h ls b v a + have subExit (d ts e) (smaller : Prod.Lex (· < ·) (· < ·) (d, sizeOf e) (depth, sizeOf expr)) + {q : Expr F} (h : expression program d ts e = .ok q) (ls b target v a) : + OpenSource.EvalExit world calls ts ls e b target v a ↔ OpenSource.EvalExit world calls [] ls q b target v a := + exit_preparation_open_iff program world lookup constDepth d ts e h ls b target v a + have children (es : List (Expr F)) (smaller : ∀ e ∈ es, sizeOf e < sizeOf expr) + {qs : List (Expr F)} (mapped : es.mapM (expression program depth types) = .ok qs) : + List.Forall₂ (fun e q => ∀ ls b v a, + OpenSource.EvalExpr world calls types ls e b v a ↔ OpenSource.EvalExpr world calls [] ls q b v a) es qs := by + have rel := mapM_relation mapped + have both : List.Forall₂ (fun e q => e ∈ es ∧ expression program depth types e = .ok q) es qs := + (List.forall₂_and_left _ _).mpr ⟨fun _ h => h, rel⟩ + exact both.imp (fun e q h => sub depth types e (Prod.Lex.right _ (smaller e h.1)) h.2) + have patterns (pat q : Pattern F) (h : pattern program (program.consts.length + 1) types pat = .ok q) + (heap value) : world.matchPattern types heap pat value = world.matchPattern [] heap q value := by + simp only [World.matchPattern, constDepth] + exact pattern_match program world.constant lookup _ _ _ h world.constant _ heap value + cases expr with + | control kind e => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨q, hq, rfl⟩ := expanded + have ihn := sub depth types e (by apply Prod.Lex.right; simp_wf; omega) hq + have ihe := subExit depth types e (by apply Prod.Lex.right; simp_wf; omega) hq + cases kind with + | exit target => constructor <;> intro h <;> cases h + | block label => + constructor + · intro h; cases h with + | block ev => exact .block ((ihn _ _ _ _).mp ev) + | blockExit ev => exact .blockExit ((ihe _ _ _ _ _).mp ev) + · intro h; cases h with + | block ev => exact .block ((ihn _ _ _ _).mpr ev) + | blockExit ev => exact .blockExit ((ihe _ _ _ _ _).mpr ev) + | literal x | var n => + simp only [expression, except_pure_ok] at expanded + subst prepared + constructor <;> intro h <;> cases h <;> constructor <;> assumption + | global n annotation => + cases annotation with + | none => simp [expression] at expanded + | some t => + cases depth with + | zero => simp [expression] at expanded + | succ d => + simp only [expression, except_bind_ok] at expanded + obtain ⟨pat, found, body, interpreted, expanded⟩ := expanded + have resolved : world.constant n (t.subst types) = .ok pat := by + simp only [lookup, found, Except.mapError] + have bodyClosed := Consts.toExpr_closed _ interpreted + have preparedClosed := expression_closed program d [] body bodyClosed expanded + have ih := sub d [] body (Prod.Lex.left _ _ (by omega)) expanded [] before result after + constructor + · intro h; cases h with + | global found' interpreted' ev => + have same := found'.symm.trans resolved + cases Except.ok.inj same + have same := interpreted'.symm.trans interpreted + cases Except.ok.inj same + exact preparedClosed.openChangeLocals (ih.mp ev) locals + · intro h + exact .global resolved interpreted (ih.mpr (preparedClosed.openChangeLocals h [])) + | tuple es | array es => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨qs, hqs, rfl⟩ := expanded + have rel := children es (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) hqs + have ih := args_congr rel + constructor + · intro h; cases h + first | exact .tuple ((ih _ _ _ _).mp ‹_›) | exact .array ((ih _ _ _ _).mp ‹_›) + · intro h; cases h + first | exact .tuple ((ih _ _ _ _).mpr ‹_›) | exact .array ((ih _ _ _ _).mpr ‹_›) + | constructAs params t ctor es => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨qs, hqs, rfl⟩ := expanded + have rel := children es (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) hqs + have ih := args_congr rel + have names : constructorName [] (t.subst types) = constructorName types t := by + simp only [constructorName, Ty.subst_nil] + constructor + · intro h; cases h with + | constructAs ev => + simpa only [names] using (OpenSource.EvalExpr.constructAs (params := params) (t := t.subst types) + (ctor := ctor) ((ih _ _ _ _).mp ev)) + · intro h; cases h with + | constructAs ev => + simpa only [names] using (OpenSource.EvalExpr.constructAs (params := params) (t := t) + (ctor := ctor) ((ih _ _ _ _).mpr ev)) + | builtin paths es => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨qs, hqs, rfl⟩ := expanded + have rel := children es (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) hqs + have ih := args_congr rel + constructor + · intro h; cases h with + | builtin ev op => exact .builtin ((ih _ _ _ _).mp ev) (by simpa only [Builtin.apply_subst] using op) + · intro h; cases h with + | builtin ev op => exact .builtin ((ih _ _ _ _).mpr ev) (by simpa only [Builtin.apply_subst] using op) + | update paths es => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨qs, hqs, rfl⟩ := expanded + have rel := children es (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) hqs + have ih := args_congr rel + constructor + · intro h; cases h with + | update ev op => exact .update ((ih _ _ _ _).mp ev) (by simpa only [Update.value_subst] using op) + · intro h; cases h with + | update ev op => exact .update ((ih _ _ _ _).mpr ev) (by simpa only [Update.value_subst] using op) + | record head es => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨qs, hqs, rfl⟩ := expanded + have rel := children es (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) hqs + have ih := args_congr rel + have names : constructorName [] (head.subst types).type = constructorName types head.type := by + simp only [RecordHead.subst, constructorName, Ty.subst_nil] + constructor + · intro h; cases h with + | record ev => + simpa only [names, RecordHead.order_subst] using (OpenSource.EvalExpr.record (head := head.subst types) ((ih _ _ _ _).mp ev)) + · intro h; cases h with + | record ev => + simpa only [names, RecordHead.order_subst] using (OpenSource.EvalExpr.record (head := head) ((ih _ _ _ _).mpr ev)) + | construct n ts ctor es => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨qs, hqs, rfl⟩ := expanded + have rel := children es (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) hqs + have ih := args_congr rel + have names : instanceName [] n (some ((ts.getD []).map (Ty.subst types))) = instanceName types n ts := by + simp only [instanceName, Option.getD_some, List.map_map, Function.comp_def, Ty.subst_nil] + constructor + · intro h; cases h with + | construct ev => + simpa only [names] using (OpenSource.EvalExpr.construct (name := n) (args := some ((ts.getD []).map (Ty.subst types))) + (ctor := ctor) ((ih _ _ _ _).mp ev)) + · intro h; cases h with + | construct ev => + simpa only [names] using (OpenSource.EvalExpr.construct (name := n) (args := ts) + (ctor := ctor) ((ih _ _ _ _).mpr ev)) + | member e field => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨q, hq, rfl⟩ := expanded + have ih := sub depth types e (by apply Prod.Lex.right; simp_wf; omega) hq + constructor + · intro h; cases h with + | member ev op => exact .member ((ih _ _ _ _).mp ev) (by simpa only [memberValue_subst] using op) + · intro h; cases h with + | member ev op => exact .member ((ih _ _ _ _).mpr ev) (by simpa only [memberValue_subst] using op) + | «repeat» e n | index e i | project e i | slice e start stop | store e | load e | hint t e channel | neg e => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨q, hq, rfl⟩ := expanded + have ih := sub depth types e (by apply Prod.Lex.right; simp_wf <;> omega) hq + constructor + · intro h; cases h + first + | exact .repeat ((ih _ _ _ _).mp ‹_›) + | exact .store ((ih _ _ _ _).mp ‹_›) + | exact .index ((ih _ _ _ _).mp ‹_›) ‹_› + | exact .project ((ih _ _ _ _).mp ‹_›) ‹_› + | exact .slice ((ih _ _ _ _).mp ‹_›) ‹_› + | exact .load ((ih _ _ _ _).mp ‹_›) ‹_› + | exact .neg ((ih _ _ _ _).mp ‹_›) ‹_› + | exact .hint ((ih _ _ _ _).mp ‹_›) (by simpa using ‹world.typed _ _ = true›) + · intro h; cases h + first + | exact .repeat ((ih _ _ _ _).mpr ‹_›) + | exact .store ((ih _ _ _ _).mpr ‹_›) + | exact .index ((ih _ _ _ _).mpr ‹_›) ‹_› + | exact .project ((ih _ _ _ _).mpr ‹_›) ‹_› + | exact .slice ((ih _ _ _ _).mpr ‹_›) ‹_› + | exact .load ((ih _ _ _ _).mpr ‹_›) ‹_› + | exact .neg ((ih _ _ _ _).mpr ‹_›) ‹_› + | rename_i input value typed ev + exact .hint ((ih _ _ _ _).mpr ev) (by simpa only [Ty.subst_nil] using typed) + | binary op lhs rhs => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨left, hl, right, hr, rfl⟩ := expanded + have ihl := sub depth types lhs (by apply Prod.Lex.right; simp_wf; omega) hl + have ihr := sub depth types rhs (by apply Prod.Lex.right; simp_wf; omega) hr + constructor + · intro h; cases h with + | binary l r op => exact .binary ((ihl _ _ _ _).mp l) ((ihr _ _ _ _).mp r) op + · intro h; cases h with + | binary l r op => exact .binary ((ihl _ _ _ _).mpr l) ((ihr _ _ _ _).mpr r) op + | letValue pat operand body => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨qpat, hp, qvalue, hv, qbody, hb, rfl⟩ := expanded + have ihv := sub depth types operand (by apply Prod.Lex.right; simp_wf; omega) hv + have ihb := sub depth types body (by apply Prod.Lex.right; simp_wf; omega) hb + constructor + · intro h; cases h with + | letValue ev matched branch => + exact .letValue ((ihv _ _ _ _).mp ev) (by rw [← patterns _ _ hp]; exact matched) + ((ihb _ _ _ _).mp branch) + · intro h; cases h with + | letValue ev matched branch => + exact .letValue ((ihv _ _ _ _).mpr ev) (by rw [patterns _ _ hp]; exact matched) + ((ihb _ _ _ _).mpr branch) + | call n ts es => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨qs, hqs, rfl⟩ := expanded + have rel := children es (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) hqs + have ih := args_congr rel + have names : instanceName [] n (some ((ts.getD []).map (Ty.subst types))) = instanceName types n ts := by + simp only [instanceName, Option.getD_some, List.map_map, Function.comp_def, Ty.subst_nil] + constructor + · intro h; cases h with + | call args callee => exact .call ((ih _ _ _ _).mp args) (by simpa only [names] using callee) + · intro h; cases h with + | call args callee => exact .call ((ih _ _ _ _).mpr args) (by simpa only [names] using callee) + | matchValue operand arms => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨qvalue, hv, others, ho, rfl⟩ := expanded + have ihv := sub depth types operand (by apply Prod.Lex.right; simp_wf; omega) hv + let R := fun e q => ∀ ls b v a, OpenSource.EvalExpr world calls types ls e b v a ↔ OpenSource.EvalExpr world calls [] ls q b v a + have rel : List.Forall₂ (fun a b => + (∀ heap value, world.matchPattern types heap a.1 value = world.matchPattern [] heap b.1 value) ∧ + R a.2 b.2) arms others := by + have mapped := mapM_relation ho + have withMem := (List.forall₂_and_left arms others).mpr ⟨fun _ h => h, mapped⟩ + apply withMem.imp + intro a b h + rcases a with ⟨pat, body⟩ + simp only [except_bind_ok, except_pure_ok] at h + obtain ⟨ha, qpat, hp, qbody, hb, rfl⟩ := h + refine ⟨patterns _ _ hp, sub depth types body ?_ hb⟩ + apply Prod.Lex.right + have := List.sizeOf_lt_of_mem ha + simp only [Expr.matchValue.sizeOf_spec, Prod.mk.sizeOf_spec] at * + omega + constructor + · intro h; cases h with + | matchValue ev selected branch => + obtain ⟨other, selected', bodyRel⟩ := select_transfer rel selected + exact .matchValue ((ihv _ _ _ _).mp ev) selected' ((bodyRel _ _ _ _).mp branch) + · intro h; cases h with + | matchValue ev selected branch => + have reverse : List.Forall₂ (fun a b => + (∀ heap value, world.matchPattern [] heap a.1 value = world.matchPattern types heap b.1 value) ∧ + R b.2 a.2) others arms := + rel.flip.imp (fun a b h => ⟨fun heap value => (h.1 heap value).symm, h.2⟩) + obtain ⟨other, selected', bodyRel⟩ := select_transfer (R := fun a b => R b a) reverse selected + exact .matchValue ((ihv _ _ _ _).mpr ev) selected' ((bodyRel _ _ _ _).mpr branch) +termination_by (depth, sizeOf expr) +decreasing_by all_goals exact smaller + +theorem exit_preparation_open_iff [Field F] [DecidableEq F] + (program : Program F) (world : World F) + (lookup : ∀ n t, world.constant n t = (elaborateConst program n t).mapError + (fun _ => EvalError.unboundVariable ("::" ++ n))) + (constDepth : world.constDepth = program.consts.length + 1) + (depth : Nat) (types : Types) (expr : Expr F) {prepared : Expr F} + (expanded : expression program depth types expr = .ok prepared) + (locals before target result after) : + OpenSource.EvalExit world calls types locals expr before target result after ↔ + OpenSource.EvalExit world calls [] locals prepared before target result after := by + have sub (d ts e) (smaller : Prod.Lex (· < ·) (· < ·) (d, sizeOf e) (depth, sizeOf expr)) + {q : Expr F} (h : expression program d ts e = .ok q) (ls b target v a) : + OpenSource.EvalExit world calls ts ls e b target v a ↔ OpenSource.EvalExit world calls [] ls q b target v a := + exit_preparation_open_iff program world lookup constDepth d ts e h ls b target v a + have subNormal (d ts e) (smaller : Prod.Lex (· < ·) (· < ·) (d, sizeOf e) (depth, sizeOf expr)) + {q : Expr F} (h : expression program d ts e = .ok q) (ls b v a) : + OpenSource.EvalExpr world calls ts ls e b v a ↔ OpenSource.EvalExpr world calls [] ls q b v a := + expression_preparation_open_iff program world lookup constDepth d ts e h ls b v a + have children (es : List (Expr F)) (smaller : ∀ e ∈ es, sizeOf e < sizeOf expr) + {qs : List (Expr F)} (mapped : es.mapM (expression program depth types) = .ok qs) : + List.Forall₂ (fun e q => + (∀ ls b v a, OpenSource.EvalExpr world calls types ls e b v a ↔ OpenSource.EvalExpr world calls [] ls q b v a) ∧ + (∀ ls b t v a, OpenSource.EvalExit world calls types ls e b t v a ↔ OpenSource.EvalExit world calls [] ls q b t v a)) es qs := by + have rel := mapM_relation mapped + have both : List.Forall₂ (fun e q => e ∈ es ∧ expression program depth types e = .ok q) es qs := + (List.forall₂_and_left _ _).mpr ⟨fun _ h => h, rel⟩ + exact both.imp (fun e q h => ⟨subNormal depth types e (Prod.Lex.right _ (smaller e h.1)) h.2, + sub depth types e (Prod.Lex.right _ (smaller e h.1)) h.2⟩) + have patterns (pat q : Pattern F) (h : pattern program (program.consts.length + 1) types pat = .ok q) + (heap value) : world.matchPattern types heap pat value = world.matchPattern [] heap q value := by + simp only [World.matchPattern, constDepth] + exact pattern_match program world.constant lookup _ _ _ h world.constant _ heap value + cases expr with + | literal | var => + simp only [expression, except_pure_ok] at expanded + subst prepared + constructor <;> intro h <;> cases h + | global => + constructor + · intro h; exact (h.hasControl (by simp [ControlLower.hasControl])).elim + · intro h; exact (h.hasControl (expression_closed program depth types _ .global expanded).noControl).elim + | control kind e => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨q, hq, rfl⟩ := expanded + have ihn := subNormal depth types e (by apply Prod.Lex.right; simp_wf; omega) hq + have ihe := sub depth types e (by apply Prod.Lex.right; simp_wf; omega) hq + cases kind with + | block label => + constructor + · intro h; cases h with | fromBlock ne ev => exact .fromBlock ne ((ihe _ _ _ _ _).mp ev) + · intro h; cases h with | fromBlock ne ev => exact .fromBlock ne ((ihe _ _ _ _ _).mpr ev) + | exit target => + constructor + · intro h; cases h with + | exit ev => exact .exit ((ihn _ _ _ _).mp ev) + | exitPayload ev => exact .exitPayload ((ihe _ _ _ _ _).mp ev) + · intro h; cases h with + | exit ev => exact .exit ((ihn _ _ _ _).mpr ev) + | exitPayload ev => exact .exitPayload ((ihe _ _ _ _ _).mpr ev) + | builtin _ es | update _ es | record _ es | tuple es | array es | construct _ _ _ es | constructAs _ _ _ es | call _ _ es => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨qs, hqs, rfl⟩ := expanded + have ih := args_exit_congr (children es (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) hqs) + constructor + · intro h; cases h + first + | exact .fromTuple ((ih _ _ _ _ _).mp ‹_›) + | exact .fromArray ((ih _ _ _ _ _).mp ‹_›) + | exact .fromConstruct ((ih _ _ _ _ _).mp ‹_›) + | exact .fromBuiltin ((ih _ _ _ _ _).mp ‹_›) + | exact .fromUpdate ((ih _ _ _ _ _).mp ‹_›) + | exact .fromRecord ((ih _ _ _ _ _).mp ‹_›) + | exact .fromConstructAs ((ih _ _ _ _ _).mp ‹_›) + | exact .fromCall ((ih _ _ _ _ _).mp ‹_›) + · intro h; cases h + first + | exact .fromTuple ((ih _ _ _ _ _).mpr ‹_›) + | exact .fromArray ((ih _ _ _ _ _).mpr ‹_›) + | exact .fromConstruct ((ih _ _ _ _ _).mpr ‹_›) + | exact .fromBuiltin ((ih _ _ _ _ _).mpr ‹_›) + | exact .fromUpdate ((ih _ _ _ _ _).mpr ‹_›) + | exact .fromRecord ((ih _ _ _ _ _).mpr ‹_›) + | exact .fromConstructAs ((ih _ _ _ _ _).mpr ‹_›) + | exact .fromCall ((ih _ _ _ _ _).mpr ‹_›) + | member e field | «repeat» e n | index e i | project e i | slice e start stop | store e | load e | hint t e channel | neg e => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨q, hq, rfl⟩ := expanded + have ih := sub depth types e (by apply Prod.Lex.right; simp_wf <;> omega) hq + constructor + · intro h; cases h + first + | exact .fromRepeat ((ih _ _ _ _ _).mp ‹_›) + | exact .fromIndex ((ih _ _ _ _ _).mp ‹_›) + | exact .fromMember ((ih _ _ _ _ _).mp ‹_›) + | exact .fromProject ((ih _ _ _ _ _).mp ‹_›) + | exact .fromSlice ((ih _ _ _ _ _).mp ‹_›) + | exact .fromStore ((ih _ _ _ _ _).mp ‹_›) + | exact .fromLoad ((ih _ _ _ _ _).mp ‹_›) + | exact .fromHint ((ih _ _ _ _ _).mp ‹_›) + | exact .fromNeg ((ih _ _ _ _ _).mp ‹_›) + · intro h; cases h + first + | exact .fromRepeat ((ih _ _ _ _ _).mpr ‹_›) + | exact .fromIndex ((ih _ _ _ _ _).mpr ‹_›) + | exact .fromMember ((ih _ _ _ _ _).mpr ‹_›) + | exact .fromProject ((ih _ _ _ _ _).mpr ‹_›) + | exact .fromSlice ((ih _ _ _ _ _).mpr ‹_›) + | exact .fromStore ((ih _ _ _ _ _).mpr ‹_›) + | exact .fromLoad ((ih _ _ _ _ _).mpr ‹_›) + | exact .fromHint ((ih _ _ _ _ _).mpr ‹_›) + | exact .fromNeg ((ih _ _ _ _ _).mpr ‹_›) + | binary op lhs rhs => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨left, hl, right, hr, rfl⟩ := expanded + have ihl := sub depth types lhs (by apply Prod.Lex.right; simp_wf; omega) hl + have ihn := subNormal depth types lhs (by apply Prod.Lex.right; simp_wf; omega) hl + have ihr := sub depth types rhs (by apply Prod.Lex.right; simp_wf; omega) hr + constructor + · intro h; cases h with + | binaryLeft ev => exact .binaryLeft ((ihl _ _ _ _ _).mp ev) + | binaryRight l r => exact .binaryRight ((ihn _ _ _ _).mp l) ((ihr _ _ _ _ _).mp r) + · intro h; cases h with + | binaryLeft ev => exact .binaryLeft ((ihl _ _ _ _ _).mpr ev) + | binaryRight l r => exact .binaryRight ((ihn _ _ _ _).mpr l) ((ihr _ _ _ _ _).mpr r) + | letValue pat operand body => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨qpat, hp, qvalue, hv, qbody, hb, rfl⟩ := expanded + have ihv := sub depth types operand (by apply Prod.Lex.right; simp_wf; omega) hv + have ihn := subNormal depth types operand (by apply Prod.Lex.right; simp_wf; omega) hv + have ihb := sub depth types body (by apply Prod.Lex.right; simp_wf; omega) hb + constructor + · intro h; cases h with + | fromLetValue ev => exact .fromLetValue ((ihv _ _ _ _ _).mp ev) + | letBody ev matched branch => + exact .letBody ((ihn _ _ _ _).mp ev) (by rw [← patterns _ _ hp]; exact matched) + ((ihb _ _ _ _ _).mp branch) + · intro h; cases h with + | fromLetValue ev => exact .fromLetValue ((ihv _ _ _ _ _).mpr ev) + | letBody ev matched branch => + exact .letBody ((ihn _ _ _ _).mpr ev) (by rw [patterns _ _ hp]; exact matched) + ((ihb _ _ _ _ _).mpr branch) + | matchValue operand arms => + simp only [expression, except_bind_ok, except_pure_ok] at expanded + obtain ⟨qvalue, hv, others, ho, rfl⟩ := expanded + have ihv := sub depth types operand (by apply Prod.Lex.right; simp_wf; omega) hv + have ihn := subNormal depth types operand (by apply Prod.Lex.right; simp_wf; omega) hv + let R := fun e q => ∀ ls b t v a, OpenSource.EvalExit world calls types ls e b t v a ↔ OpenSource.EvalExit world calls [] ls q b t v a + have rel : List.Forall₂ (fun a b => + (∀ heap value, world.matchPattern types heap a.1 value = world.matchPattern [] heap b.1 value) ∧ + R a.2 b.2) arms others := by + have mapped := mapM_relation ho + have withMem := (List.forall₂_and_left arms others).mpr ⟨fun _ h => h, mapped⟩ + apply withMem.imp + intro a b h + rcases a with ⟨pat, body⟩ + simp only [except_bind_ok, except_pure_ok] at h + obtain ⟨ha, qpat, hp, qbody, hb, rfl⟩ := h + refine ⟨patterns _ _ hp, sub depth types body ?_ hb⟩ + apply Prod.Lex.right + have := List.sizeOf_lt_of_mem ha + simp only [Expr.matchValue.sizeOf_spec, Prod.mk.sizeOf_spec] at * + omega + constructor + · intro h; cases h with + | fromMatchValue ev => exact .fromMatchValue ((ihv _ _ _ _ _).mp ev) + | matchBody ev selected branch => + obtain ⟨other, selected', bodyRel⟩ := select_transfer rel selected + exact .matchBody ((ihn _ _ _ _).mp ev) selected' ((bodyRel _ _ _ _ _).mp branch) + · intro h; cases h with + | fromMatchValue ev => exact .fromMatchValue ((ihv _ _ _ _ _).mpr ev) + | matchBody ev selected branch => + have reverse : List.Forall₂ (fun a b => + (∀ heap value, world.matchPattern [] heap a.1 value = world.matchPattern types heap b.1 value) ∧ + R b.2 a.2) others arms := + rel.flip.imp (fun a b h => ⟨fun heap value => (h.1 heap value).symm, h.2⟩) + obtain ⟨other, selected', bodyRel⟩ := select_transfer (R := fun a b => R b a) reverse selected + exact .matchBody ((ihn _ _ _ _).mpr ev) selected' ((bodyRel _ _ _ _ _).mpr branch) +termination_by (depth, sizeOf expr) +decreasing_by all_goals exact smaller +end + +theorem expression_preparation_iff [Field F] [DecidableEq F] + (program : Program F) (world : World F) + (lookup : ∀ n t, world.constant n t = (elaborateConst program n t).mapError + (fun _ => EvalError.unboundVariable ("::" ++ n))) + (constDepth : world.constDepth = program.consts.length + 1) + (depth : Nat) (types : Types) (expr : Expr F) {prepared : Expr F} + (expanded : expression program depth types expr = .ok prepared) + (locals before result after) : + EvalExpr world types locals expr before result after ↔ + EvalExpr world [] locals prepared before result after := by + simpa only [OpenSource.closed_iff] using expression_preparation_open_iff + (calls := EvalFn world) program world lookup constDepth depth types expr expanded locals before result after + +end Aiur.Generic.SourceSemantics diff --git a/Aiur/Aiur/Generic/PreparationFunctionFacts.lean b/Aiur/Aiur/Generic/PreparationFunctionFacts.lean new file mode 100644 index 000000000..846522f8c --- /dev/null +++ b/Aiur/Aiur/Generic/PreparationFunctionFacts.lean @@ -0,0 +1,69 @@ +import Aiur.Generic.PreparationExpressionFacts +import Aiur.Generic.CoreRuntime +import Aiur.Generic.ControlLoweringFacts + +namespace Aiur.Generic + +theorem Preparation.function_ok {program : Program F} {key : Instance} {core : Aiur.Function F} + (compiled : Preparation.function program key = .ok core) : + ∃ fn types prepared body, program.findFunction? key.name = some fn ∧ + arguments fn.typeParams key.types = .ok types ∧ + Preparation.expression program (program.consts.length + 1) types fn.body = .ok prepared ∧ + ControlLower.function prepared (fn.params.map Prod.fst) = .ok body ∧ + body.lowerSafe [] ∧ + core = { + name := key.symbol + params := fn.params.map fun (name, type) => (name, (type.subst types).toCore) + result := (fn.result.subst types).toCore + body := body.lower [] } := by + cases found : program.findFunction? key.name with + | none => simp [Preparation.function, found] at compiled + | some fn => + simp only [Preparation.function, found, except_bind_ok] at compiled + obtain ⟨types, args, prepared, expanded, body, control, rest⟩ := compiled + split at rest + · simp at rest + · rename_i safe + obtain rfl := except_pure_ok.mp rest + exact ⟨fn, types, prepared, body, rfl, args, expanded, control, by simpa using safe, rfl⟩ + +/-- Successful compiler lookup identifies the original closure, its prepared +body, and the decidable lowering certificate. It cannot substitute a different +function or reinterpret a failed function lookup as a map. -/ +theorem Source.compilerFunction_spec [DecidableEq F] {s : Source F} + (compiled : s.compilerFunction? name = some core) : + ∃ source prepared body, s.program.sourceFunction? name = some source ∧ + Preparation.expression s.program (s.program.consts.length + 1) source.types source.body = .ok prepared ∧ + ControlLower.function prepared (source.params.map Prod.fst) = .ok body ∧ + body.lowerSafe [] ∧ core.params = source.params ∧ core.body = body.lower [] := by + cases decoded : Instance.ofSymbol name with + | error e => simp [Source.compilerFunction?, decoded, Except.toOption, bind, Except.bind] at compiled + | ok key => + have checked : Preparation.function s.program key = .ok core := by + cases run : Preparation.function s.program key <;> + simpa [Source.compilerFunction?, decoded, run, Except.toOption, bind, Except.bind] using compiled + obtain ⟨fn, types, prepared, body, found, args, expanded, control, safe, rfl⟩ := Preparation.function_ok checked + refine ⟨⟨types, fn.params.map (fun (n, t) => (n, (t.subst types).toCore)), fn.body⟩, + prepared, body, ?_, expanded, ?_, safe, rfl, rfl⟩ + · simp [Program.sourceFunction?, decoded, found, args, Except.toOption] + · simpa only [List.map_map, Function.comp_def] using control + +theorem SourceFunction.prepare_iff {fn : SourceFunction F} + {types : SourceSemantics.Types} {locals : Environment F Nat} {body : Expr F} + {args : List (SourceValue F)} {enums : String → Option Aiur.EnumDecl} : + fn.prepare enums args = .ok (types, locals, body) ↔ + fn.params.map Prod.snd = args.map Value.type ∧ (args.map (wellFormed enums)).all id = true ∧ + types = fn.types ∧ locals = (fn.params.map Prod.fst).zip args ∧ body = fn.body := by + unfold SourceFunction.prepare + split + · rename_i valid + simp only [Except.ok.injEq, Prod.mk.injEq] + constructor + · rintro ⟨rfl, rfl, rfl⟩; exact ⟨valid.1, valid.2, rfl, rfl, rfl⟩ + · rintro ⟨_, _, rfl, rfl, rfl⟩; exact ⟨rfl, rfl, rfl⟩ + · rename_i invalid + constructor + · intro h; cases h + · rintro ⟨typed, formed, _, _, _⟩; exact (invalid ⟨typed, formed⟩).elim + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/PreparationPatternFacts.lean b/Aiur/Aiur/Generic/PreparationPatternFacts.lean new file mode 100644 index 000000000..1a6a1fa80 --- /dev/null +++ b/Aiur/Aiur/Generic/PreparationPatternFacts.lean @@ -0,0 +1,170 @@ +import Aiur.Generic.Preparation +import Aiur.Generic.TypeFacts +import Aiur.Generic.RecordFacts +import Mathlib.Data.List.Forall2 + +namespace Aiur.Generic.Preparation +open SourceSemantics + +theorem mapM_relation {f : A → Except E B} {xs : List A} {ys : List B} + (mapped : xs.mapM f = .ok ys) : List.Forall₂ (fun x y => f x = .ok y) xs ys := by + induction xs generalizing ys with + | nil => simp at mapped; subst ys; exact .nil + | cons x xs ih => + simp only [List.mapM_cons, except_bind_ok, except_pure_ok] at mapped + obtain ⟨y, hy, rest, hr, rfl⟩ := mapped + exact .cons hy (ih hr) + +theorem mapM_forall {f : A → Except E B} {xs : List A} {ys : List B} {P : B → Prop} + (mapped : xs.mapM f = .ok ys) + (good : ∀ x ∈ xs, ∀ y, f x = .ok y → P y) : ∀ y ∈ ys, P y := by + induction xs generalizing ys with + | nil => simp at mapped; subst ys; simp + | cons x xs ih => + simp only [List.mapM_cons, except_bind_ok, except_pure_ok] at mapped + obtain ⟨y, hy, rest, hr, rfl⟩ := mapped + intro z hz + rcases List.mem_cons.mp hz with rfl | hz + · exact good x (by simp) _ hy + · exact ih hr (fun x hx => good x (by simp [hx])) z hz + +theorem matchList_congr [DecidableEq F] + {left : A → SourceValue F → Except EvalError (Option (Environment F Nat))} + {right : B → SourceValue F → Except EvalError (Option (Environment F Nat))} + {xs : List A} {ys : List B} + (related : List.Forall₂ (fun x y => ∀ v, left x v = right y v) xs ys) + (values : List (SourceValue F)) : + matchListWith left xs values = matchListWith right ys values := by + induction related generalizing values with + | nil => cases values <;> rfl + | cons h _ ih => cases values <;> simp only [matchListWith, h, ih] + +theorem matchList_attach [DecidableEq F] + (run : Pattern F → SourceValue F → Except EvalError (Option (Environment F Nat))) + (ps : List (Pattern F)) (values : List (SourceValue F)) : + matchListWith (fun p v => run p.val v) ps.attach values = matchListWith run ps values := by + apply matchList_congr + apply (List.forall₂_map_left_iff + (R := fun p q => ∀ v, run p v = run q v) + (f := fun p : { p // p ∈ ps } => p.val)).mp + simpa using (List.forall₂_same.mpr (fun p _ v => rfl) : + List.Forall₂ (fun p q => ∀ v, run p v = run q v) ps ps) + +/-- Instantiating type metadata and unfolding checked const references leaves +every pattern result unchanged, including failed matches and invalid loads. +The prepared pattern no longer depends on any declaration lookup or depth. -/ +theorem pattern_match [DecidableEq F] (program : Program F) + (constant : String → Ty → Except EvalError (Pattern F)) + (lookup : ∀ n t, constant n t = (elaborateConst program n t).mapError + (fun _ => EvalError.unboundVariable ("::" ++ n))) + (depth : Nat) (types : Types) (pat : Pattern F) {prepared : Pattern F} + (expanded : pattern program depth types pat = .ok prepared) + (other : String → Ty → Except EvalError (Pattern F)) (otherDepth : Nat) + (heap : Heap F) (value : SourceValue F) : + matchPatternWith constant depth types heap pat value = + matchPatternWith other otherDepth [] heap prepared value := by + have sub (d : Nat) (ts : Types) (p : Pattern F) + (smaller : Prod.Lex (· < ·) (· < ·) (d, sizeOf p) (depth, sizeOf pat)) {q : Pattern F} + (h : pattern program d ts p = .ok q) (v : SourceValue F) : + matchPatternWith constant d ts heap p v = matchPatternWith other otherDepth [] heap q v := + pattern_match program constant lookup d ts p h other otherDepth heap v + have children (ps : List (Pattern F)) (smaller : ∀ p ∈ ps, sizeOf p < sizeOf pat) + (qs : List (Pattern F)) (mapped : ps.mapM (pattern program depth types) = .ok qs) + (vs : List (SourceValue F)) : + matchListWith (fun p v => matchPatternWith constant depth types heap p.val v) ps.attach vs = + matchListWith (fun q v => matchPatternWith other otherDepth [] heap q.val v) qs.attach vs := by + rw [matchList_attach, matchList_attach] + apply matchList_congr + have rel := mapM_relation mapped + have withMem : List.Forall₂ (fun p q => p ∈ ps ∧ pattern program depth types p = .ok q) ps qs := + (List.forall₂_and_left _ _).mpr ⟨fun _ h => h, rel⟩ + apply withMem.imp + intro p q h v + exact sub depth types p (Prod.Lex.right _ (smaller p h.1)) h.2 v + cases pat with + | literal | wildcard | bind => + simp only [pattern, except_pure_ok] at expanded + subst prepared + simp only [matchPatternWith] + | global name annotation => + cases annotation with + | none => simp [pattern] at expanded + | some type => + cases depth with + | zero => simp [pattern] at expanded + | succ depth => + simp only [pattern, except_bind_ok] at expanded + obtain ⟨body, found, expanded⟩ := expanded + simp only [matchPatternWith, lookup, found, Except.mapError, + bind, Except.bind] + exact sub depth [] body (by exact Prod.Lex.left _ _ (by omega)) expanded value + | orElse left right names => + simp only [pattern, except_bind_ok, except_pure_ok] at expanded + obtain ⟨l, hl, r, hr, rfl⟩ := expanded + simp only [matchPatternWith, sub depth types left (by apply Prod.Lex.right; simp_wf; omega) hl, + sub depth types right (by apply Prod.Lex.right; simp_wf; omega) hr] + | load child => + simp only [pattern, except_bind_ok, except_pure_ok] at expanded + obtain ⟨q, hq, rfl⟩ := expanded + simp only [matchPatternWith] + cases loaded : loadValue heap value with + | error e => rfl + | ok v => + exact sub depth types child (by apply Prod.Lex.right; simp_wf <;> omega) hq v + | tuple ps | array ps => + simp only [pattern, except_bind_ok, except_pure_ok] at expanded + obtain ⟨qs, hqs, rfl⟩ := expanded + have lengths := (mapM_relation hqs).length_eq + cases value <;> simp only [matchPatternWith, lengths] + rename_i vs + split + · rfl + · exact children ps (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) qs hqs vs + | «repeat» child n => + simp only [pattern, except_bind_ok, except_pure_ok] at expanded + obtain ⟨q, hq, rfl⟩ := expanded + have single := sub depth types child (by apply Prod.Lex.right; simp_wf; omega) hq + cases value <;> simp only [matchPatternWith] + rename_i vs + split + · rfl + · apply matchList_congr + exact List.forall₂_same.mpr (fun _ _ v => single v) + | record head ps => + simp only [pattern, except_bind_ok, except_pure_ok] at expanded + obtain ⟨qs, hqs, rfl⟩ := expanded + have base := mapM_relation hqs + have withMem : List.Forall₂ (fun p q => p ∈ ps ∧ pattern program depth types p = .ok q) ps qs := + (List.forall₂_and_left _ _).mpr ⟨fun _ h => h, base⟩ + have rel : List.Forall₂ (fun p q => ∀ v, + matchPatternWith constant depth types heap p v = + matchPatternWith other otherDepth [] heap q v) ps qs := by + apply withMem.imp + intro p q h v + exact sub depth types p (Prod.Lex.right _ (by simp_wf; have := List.sizeOf_lt_of_mem h.1; omega)) h.2 v + have ordered := head.order_rel rel (a := Pattern.wildcard) (b := Pattern.wildcard) + (by intro v; simp only [matchPatternWith]) + have names : constructorName [] (head.subst types).type = constructorName types head.type := by + simp [RecordHead.subst, constructorName] + cases value <;> simp only [match_record, names, RecordHead.order_subst, ordered.length_eq] + split + · rfl + · split + · simp_all only [ite_true] + · simp_all only [ite_false] + exact matchList_congr ordered _ + | construct t ctor ps | constructAs params t ctor ps => + simp only [pattern, except_bind_ok, except_pure_ok] at expanded + obtain ⟨qs, hqs, rfl⟩ := expanded + have lengths := (mapM_relation hqs).length_eq + have names : constructorName [] (t.subst types) = constructorName types t := by + simp only [constructorName, Ty.subst_nil] + cases value <;> simp only [matchPatternWith, names, lengths] + rename_i name ctor' vs + split + · rfl + · exact children ps (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) qs hqs vs +termination_by (depth, sizeOf pat) +decreasing_by exact smaller + +end Aiur.Generic.Preparation diff --git a/Aiur/Aiur/Generic/RecordFacts.lean b/Aiur/Aiur/Generic/RecordFacts.lean new file mode 100644 index 000000000..6849e8c79 --- /dev/null +++ b/Aiur/Aiur/Generic/RecordFacts.lean @@ -0,0 +1,118 @@ +import Aiur.Generic.SourceSemantics +import Aiur.Generic.TypeFacts +import Mathlib.Data.List.Forall2 + +namespace Aiur.Generic + +@[simp] theorem RecordHead.positions_subst (h : RecordHead) (types n) : + (h.subst types).positions n = h.positions n := rfl + +@[simp] theorem RecordHead.order_subst (h : RecordHead) (types) (xs : List A) (fallback : A) : + (h.subst types).order xs fallback = h.order xs fallback := rfl + +@[simp] theorem RecordHead.order_length (h : RecordHead) (xs : List A) (fallback : A) : + (h.order xs fallback).length = (h.positions xs.length).length := by simp [RecordHead.order] + +theorem RecordHead.order_map (h : RecordHead) (xs : List A) (fallback : A) (f : A → B) : + h.order (xs.map f) (f fallback) = (h.order xs fallback).map f := by + simp only [RecordHead.order, List.length_map, List.map_map] + apply List.map_congr_left + intro slot _ + cases slot with + | none => rfl + | some i => simp [List.getElem?_map, Option.getD_map] + +theorem forall₂_getD {R : A → B → Prop} {xs : List A} {ys : List B} + (related : List.Forall₂ R xs ys) (fallback : R a b) (i : Nat) : + R (xs[i]?.getD a) (ys[i]?.getD b) := by + induction related generalizing i with + | nil => exact fallback + | cons h _ ih => cases i with + | zero => exact h + | succ i => exact ih i + +theorem RecordHead.order_rel (h : RecordHead) {R : A → B → Prop} {xs : List A} {ys : List B} + (related : List.Forall₂ R xs ys) (fallback : R a b) : + List.Forall₂ R (h.order xs a) (h.order ys b) := by + simp only [RecordHead.order, related.length_eq] + apply List.forall₂_map_left_iff.mpr + apply List.forall₂_map_right_iff.mpr + apply List.forall₂_same.mpr + intro slot _ + cases slot with + | none => exact fallback + | some i => exact forall₂_getD related fallback i + +theorem RecordHead.order_mem (h : RecordHead) {P : A → Prop} (xs : List A) (a : A) + (items : ∀ x ∈ xs, P x) (fallback : P a) : ∀ x ∈ h.order xs a, P x := by + intro x hx + obtain ⟨slot, _, rfl⟩ := List.mem_map.mp hx + cases slot with + | none => exact fallback + | some i => + cases found : xs[i]? with + | none => simpa [found] using fallback + | some x => simpa [found] using items x (List.mem_of_getElem? found) + +theorem RecordHead.order_attached (h : RecordHead) (xs : List A) (fallback : A) : + (h.order (xs.attach.map some) none).map + (fun p => (p.map Subtype.val).getD fallback) = h.order xs fallback := by + rw [← h.order_map] + simp + +theorem record_bindingNames (head : RecordHead) (ps : List (Pattern F)) : + (Pattern.record head ps).bindingNames = (head.order ps .wildcard).flatMap Pattern.bindingNames := by + have h := head.order_map ps (Pattern.wildcard : Pattern F) Pattern.bindingNames + simp only [Pattern.bindingNames] at h + simpa only [Pattern.bindingNames, List.flatMap] using congrArg List.flatten h + +namespace SourceSemantics + +theorem record_matchList_map [DecidableEq F] + {run : B → SourceValue F → Except EvalError (Option (Environment F Nat))} + (f : A → B) (xs : List A) (values : List (SourceValue F)) : + matchListWith run (xs.map f) values = matchListWith (fun x v => run (f x) v) xs values := by + induction xs generalizing values with + | nil => cases values <;> rfl + | cons x xs ih => cases values <;> simp only [List.map_cons, matchListWith, ih] + +theorem record_matchList_attach [DecidableEq F] (head : RecordHead) + (ps : List (Pattern F)) (values : List (SourceValue F)) : + matchListWith (fun child value => match child with + | some pat => matchPatternWith constant depth types heap pat.val value + | none => pure (some [])) (head.order (ps.attach.map some) none) values = + matchListWith (fun p v => matchPatternWith constant depth types heap p v) + (head.order ps .wildcard) values := by + rw [← head.order_attached ps (.wildcard : Pattern F), record_matchList_map] + congr 1 + funext child value + cases child <;> simp [matchPatternWith] + +/-- Named patterns visit declared fields in layout order, preserving all load errors. -/ +theorem match_record [DecidableEq F] (head : RecordHead) (ps : List (Pattern F)) (v : SourceValue F) : + matchPatternWith constant depth types heap (.record head ps) v = + match v with + | .construct n c vs => + if n != constructorName types head.type || c != structConstructor then .ok none + else if (head.order ps .wildcard).length != vs.length then .ok none + else matchListWith (fun p v => matchPatternWith constant depth types heap p v) + (head.order ps .wildcard) vs + | _ => .ok none := by + cases v <;> simp only [matchPatternWith, RecordHead.order_length, + List.length_map, List.length_attach, pure, Except.pure, bind, Except.bind] + split + · rfl + · split + · rfl + · exact record_matchList_attach head ps _ + +@[simp] theorem memberValue_subst [DecidableEq F] (types : Types) (field : FieldRef) (v : SourceValue F) : + memberValue [] (field.subst types) v = memberValue types field v := by + dsimp only [memberValue, FieldRef.subst] + have h : constructorName [] ((field.owner.map (Ty.subst types)).getD (.named "$invalid" [])) = + constructorName types (field.owner.getD (.named "$invalid" [])) := by + cases field.owner <;> simp [constructorName, Ty.subst_nil, Ty.subst] + rw [h] + +end SourceSemantics +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/Runtime.lean b/Aiur/Aiur/Generic/Runtime.lean new file mode 100644 index 000000000..51423badd --- /dev/null +++ b/Aiur/Aiur/Generic/Runtime.lean @@ -0,0 +1,160 @@ +import Aiur.Generic.Elaborate +import Aiur.Generic.SourceEvalFacts +import Aiur.Generic.PatternChecks + +namespace Aiur.Generic + +def wellFormed (enums : String → Option Aiur.EnumDecl) : Value F A → Bool + | .field _ | .ptr _ _ => true + | .tuple xs => (xs.map (wellFormed enums)).all id + | .construct n c xs => + match enums n >>= (fun d => d.constructors.find? (·.name == c)) with + | none => false + | some ctor => decide (xs.map Value.type = ctor.fields) && (xs.map (wellFormed enums)).all id +termination_by v => sizeOf v + +def hasType (enums : String → Option Aiur.EnumDecl) (t : Aiur.Ty) (v : Value F A) : Bool := + decide (v.type = t) && wellFormed enums v + +def constantOfExpr : Aiur.Expr α → Except String (Constant α) + | .literal x => pure (.field x) + | .tuple xs => return .tuple (← xs.mapM constantOfExpr) + | .construct n c xs => return .construct n c (← xs.mapM constantOfExpr) + | _ => throw "table rows must be constant literals, tuples, or constructors" +termination_by e => sizeOf e + +/-- Static array repeats copy a checked constant. No execution, allocation, or +hinting is performed while constructing precommitted table rows. -/ +def constantOfSource : Expr α → Except String (Constant α) + | .literal x => pure (.field x) + | .tuple xs | .array xs => return .tuple (← xs.mapM constantOfSource) + | .repeat x n => do + checkArrayLength n + return .tuple (List.replicate n (← constantOfSource x)) + | .record head xs => return .construct (StructLowering.nominalName [] head.type) structConstructor (head.order (← xs.mapM constantOfSource) (.tuple [])) + | .construct n ts c xs => + return .construct (Instance.symbol ⟨n, ts.getD []⟩) c (← xs.mapM constantOfSource) + | _ => throw "table rows must be constant literals, tuples, arrays, or constructors" +termination_by e => sizeOf e + +def staticProgram (p : Program α) : Except String (Aiur.Program α) := do + let tables ← p.tables.mapM fun t => do + let rows ← t.rows.mapM constantOfSource + return { name := t.name, rowType := t.rowType.toCore, rows : Aiur.Table α } + let maps := p.maps.map fun m => { + name := m.name, params := m.params.map fun (n, t) => (n, t.toCore) + result := m.result.toCore, input := m.input, output := m.output : Aiur.MapDecl } + let enums ← collectEnums p [] 1024 [] + ((tables.flatMap fun t => coreTypeNames t.rowType) ++ + (maps.flatMap fun m => (m.params.map Prod.snd ++ [m.result]).flatMap coreTypeNames)) + return { functions := [], enums, tables, maps } + +/-- Checked source plus its static tables. Generic functions remain templates; +there is no entrypoint choice or function-instance cache here. -/ +structure Source (F : Type) [DecidableEq F] where + program : Program F + tables : Aiur.Program F + tablesChecked : typecheck tables = .ok () + +def prepare [DecidableEq F] (p : Program F) : Except String (Source F) := do + let p ← elaborate p + for fn in p.functions do checkLoadPatterns p fn.name fn.body + let staticSource ← prepareTemplates { p with functions := [] } + let tables ← staticProgram staticSource + if checked : typecheck tables = .ok () then return ⟨p, tables, checked⟩ + else match typecheck tables with + | .error e => throw (toString e) + | .ok _ => throw "invalid static tables" + + +def Source.checkEntry [DecidableEq F] (s : Source F) (name : String) : Except String Unit := do + let some fn := s.program.findFunction? name | throw s!"unknown entrypoint '{name}'" + if fn.isInline then throw s!"inline function '{name}' cannot be an entrypoint" + if !fn.typeParams.isEmpty then throw s!"entrypoint '{name}' must be non-generic" + (fn.params.map Prod.snd).forM (checkPointerFree s.program s!"entrypoint '{name}'" 1024 []) + let fn : Aiur.Function F := { + name, params := fn.params.map fun (n, t) => (n, t.toCore) + result := fn.result.toCore, body := .tuple [] } + let enums ← collectEnums s.program [] 1024 [] ((fn.params.map Prod.snd).flatMap coreTypeNames) + (Aiur.checkEntry ({ functions := [fn], enums } : Aiur.Program F) name).mapError (fun e => reprStr e) + +/-- A closed function instance retains the source body and its type environment. +This is a runtime closure for a first-order function, not a function value in Aiur. -/ +structure SourceFunction (F : Type) where + types : SourceSemantics.Types + params : List (String × Aiur.Ty) + body : Expr F + +def Program.sourceFunction? (p : Program F) (name : String) : Option (SourceFunction F) := do + let key ← (Instance.ofSymbol name).toOption + let fn ← p.findFunction? key.name + let types ← (arguments fn.typeParams key.types).toOption + return { types, params := fn.params.map fun (n, t) => (n, (t.subst types).toCore), body := fn.body } + +def SourceFunction.prepare (enums : String → Option Aiur.EnumDecl) (fn : SourceFunction F) + (args : List (SourceValue F)) : Except EvalError (SourceSemantics.Types × Environment F Nat × Expr F) := + if fn.params.map Prod.snd = args.map Value.type ∧ (args.map (wellFormed enums)).all id = true then + .ok (fn.types, (fn.params.map Prod.fst).zip args, fn.body) + else .error (.malformedValue (.tuple (args.map Value.type))) + +def constantExpr : Constant F → Expr F + | .field x => .literal x + | .tuple xs => .tuple (xs.map constantExpr) + | .construct n c xs => .construct n (some []) c (xs.map constantExpr) + | .ptr _ a => Empty.elim a +termination_by v => sizeOf v + +/-- Ordinary calls resolve the original body without rewriting it. The finite +specialized runtime uses this same operation with a cached function lookup. -/ +def sourceWorld [DecidableEq F] (s : Source F) + (functions : String → Option (SourceFunction F)) : SourceSemantics.World F where + prepare name args := match functions name with + | some fn => fn.prepare s.program.enum? args + | none => return ([], [], constantExpr (← lookupMap s.tables name args)) + typed t v := hasType s.program.enum? t v + constant name t := (elaborateConst s.program name t).mapError + (fun _ => EvalError.unboundVariable ("::" ++ name)) + constDepth := s.program.consts.length + 1 + +def Source.world [DecidableEq F] (s : Source F) : SourceSemantics.World F := + sourceWorld s s.program.sourceFunction? + +abbrev Source.HintProvider [DecidableEq F] (s : Source F) := SourceSemantics.HintProvider s.world + +def Source.checkedHints [DecidableEq F] (s : Source F) + (dispatcher : HintDispatcher F) : s.HintProvider := fun channel key t => do + let v ← dispatcher.provide channel key + if typed : s.world.typed t v = true then return ⟨v, typed⟩ + else throw (.invalidValue t v.type) + +def Source.run [Field F] [DecidableEq F] (s : Source F) (name : String) + (args : List (SourceValue F)) (fuel : Nat := 1000) + (hints : s.HintProvider := SourceSemantics.unavailable) : Except String (SourceValue F × Heap F) := do + s.checkEntry name + let (types, locals, body) ← (s.world.prepare name args).mapError reprStr + (SourceSemantics.evalFunctionWith s.world hints types locals fuel body []).mapError reprStr + +def Source.EvalCall [Field F] [DecidableEq F] (s : Source F) (name : String) + (args : List (SourceValue F)) (result : SourceValue F) : Prop := + s.checkEntry name = .ok () ∧ ∃ heap, SourceSemantics.EvalFn s.world name args [] result heap + +/-- Successful execution implies the independent, fuel-free source relation. +The statement does not mention specialization or expression lowering. -/ +theorem Source.run_spec [Field F] [DecidableEq F] {s : Source F} + {hints : s.HintProvider} {name args fuel result heap} + (run : s.run name args fuel hints = .ok (result, heap)) : + s.checkEntry name = .ok () ∧ SourceSemantics.EvalFn s.world name args [] result heap := by + cases entry : s.checkEntry name with + | error e => simp [Source.run, entry, bind, Except.bind] at run + | ok u => + cases u + cases prepared : s.world.prepare name args with + | error e => simp [Source.run, entry, prepared, Except.mapError, bind, Except.bind] at run + | ok triple => + rcases triple with ⟨types, locals, body⟩ + have executed : SourceSemantics.evalFunctionWith s.world hints types locals fuel body [] = .ok (result, heap) := by + cases h : SourceSemantics.evalFunctionWith s.world hints types locals fuel body [] <;> + simpa [Source.run, entry, prepared, h, Except.mapError, bind, Except.bind] using run + exact ⟨rfl, SourceSemantics.evalFunction_spec prepared executed⟩ + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/Simulation.lean b/Aiur/Aiur/Generic/Simulation.lean new file mode 100644 index 000000000..1d97c4d6b --- /dev/null +++ b/Aiur/Aiur/Generic/Simulation.lean @@ -0,0 +1,161 @@ +import Aiur.Generic.Engine + +namespace Aiur.Generic.Engine + +def inScope (names : List String) (hintType : Aiur.Ty → Bool) : Aiur.Expr α → Bool + | .literal _ | .var _ => true + | .tuple xs | .construct _ _ xs => (xs.map (inScope names hintType)).all id + | .call n xs => names.contains n && (xs.map (inScope names hintType)).all id + | .project x _ | .store x | .load x | .neg x => inScope names hintType x + | .hint t x channel => hintType t && inScope names hintType x + | .letValue _ x b | .binary _ x b | .assertEq _ x b => inScope names hintType x && inScope names hintType b + | .matchValue x arms => inScope names hintType x && (arms.map fun a => inScope names hintType a.2).all id +termination_by e => sizeOf e +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +theorem selected_inScope [DecidableEq F] {input : SourceValue F} {arms : List (Aiur.Pattern F × Aiur.Expr F)} + (selected : selectArm input arms = some (bindings, body)) + (safe : ∀ a ∈ arms, inScope names hintType a.2 = true) : inScope names hintType body = true := by + induction arms with + | nil => simp [selectArm] at selected + | cons a rest ih => + rcases a with ⟨p, e⟩ + cases matched : p.bindings input with + | none => exact ih (by simpa [selectArm, matched] using selected) (fun a h => safe a (by simp [h])) + | some bs => + obtain ⟨rfl, rfl⟩ := (by simpa [selectArm, matched] using selected : bs = bindings ∧ e = body) + exact safe (p, e) (by simp) + +/-- The finite certificate concerns syntax and lookup, not evaluation or +termination. This simulation works for all finite evaluations and all hints. -/ +structure Agreement (left right : World F) (names : List String) (hintType : Aiur.Ty → Bool) : Prop where + prepare : ∀ n ∈ names, ∀ args locals body, + left.prepare n args = .ok (locals, body) ↔ right.prepare n args = .ok (locals, body) + hint : ∀ t, hintType t = true → ∀ v, left.typed t v = true ↔ right.typed t v = true + closed : ∀ n ∈ names, ∀ args locals body, + left.prepare n args = .ok (locals, body) → inScope names hintType body = true + +def Agreement.symm (a : Agreement left right names hintType) : Agreement right left names hintType where + prepare n hn args locals body := (a.prepare n hn args locals body).symm + hint t ht v := (a.hint t ht v).symm + closed n hn args locals body h := a.closed n hn args locals body ((a.prepare n hn args locals body).mpr h) + +variable {F : Type} {left right : World F} {names : List String} {hintType : Aiur.Ty → Bool} + +theorem EvalExpr.transfer [Field F] [DecidableEq F] + (a : Agreement left right names hintType) + (ev : EvalExpr left locals expr before result after) : + inScope names hintType expr = true → EvalExpr right locals expr before result after := by + induction ev using EvalExpr.rec + (motive_2 := fun ls es b vs h _ => (∀ e ∈ es, inScope names hintType e = true) → EvalArgs right ls es b vs h) + (motive_3 := fun n xs b v h _ => n ∈ names → EvalFn right n xs b v h) with + | literal => intro _; exact .literal + | var h => intro _; exact .var h + | tuple _ ih => intro h; exact .tuple (ih (by simpa [inScope] using h)) + | construct _ ih => intro h; exact .construct (ih (by simpa [inScope] using h)) + | project _ op ih => intro h; exact .project (ih (by simpa [inScope] using h)) op + | letValue _ matched _ ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true] at h + exact .letValue (ih1 h.1) matched (ih2 h.2) + | store _ ih => intro h; exact .store (ih (by simpa [inScope] using h)) + | load _ op ih => intro h; exact .load (ih (by simpa [inScope] using h)) op + | hint _ typed ih => + intro h + simp only [inScope, Bool.and_eq_true] at h + exact .hint (ih h.2) ((a.hint _ h.1 _).mp typed) + | neg _ op ih => intro h; exact .neg (ih (by simpa [inScope] using h)) op + | assertEq _ _ op ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true] at h + exact .assertEq (ih1 h.1) (ih2 h.2) op + | binary _ _ op ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true] at h + exact .binary (ih1 h.1) (ih2 h.2) op + | call _ _ ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true, List.contains_iff_mem, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .call (ih1 h.2) (ih2 h.1) + | matchValue _ selected _ ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .matchValue (ih1 h.1) selected (ih2 (selected_inScope selected h.2)) + | nil => exact .nil + | cons _ _ ih1 ih2 => + rename_i h + exact .cons (ih1 (h _ (by simp))) (ih2 (fun e he => h e (by simp [he]))) + | intro prepared _ ih => + rename_i hn + exact .intro ((a.prepare _ hn _ _ _).mp prepared) (ih (a.closed _ hn _ _ _ prepared)) + +theorem EvalFn.transfer [Field F] [DecidableEq F] + (a : Agreement left right names hintType) (hn : n ∈ names) + (ev : EvalFn left n args before result after) : EvalFn right n args before result after := by + cases ev with + | intro prepared body => + exact .intro ((a.prepare _ hn _ _ _).mp prepared) + (body.transfer a (a.closed _ hn _ _ _ prepared)) + +theorem evalFn_iff [Field F] [DecidableEq F] + (a : Agreement left right names hintType) (hn : n ∈ names) : + EvalFn left n args before result after ↔ EvalFn right n args before result after := + ⟨EvalFn.transfer a hn, EvalFn.transfer a.symm hn⟩ + +theorem EvalExpr.toCore [Field F] [DecidableEq F] {p : Aiur.Program F} + (ev : EvalExpr (.ofProgram p) locals expr before result after) : + Aiur.EvalExpr p locals expr before result after := by + induction ev using EvalExpr.rec + (motive_2 := fun ls es b vs h _ => Aiur.EvalArgs p ls es b vs h) + (motive_3 := fun n xs b v h _ => Aiur.EvalFn p n xs b v h) with + | literal => exact .literal + | var h => exact .var h + | tuple _ ih => exact .tuple ih + | construct _ ih => exact .construct ih + | project _ op ih => exact .project ih op + | letValue _ h _ ih1 ih2 => exact .letValue ih1 h ih2 + | store _ ih => exact .store ih + | load _ op ih => exact .load ih op + | hint _ typed ih => exact .hint ih typed + | neg _ op ih => exact .neg ih op + | assertEq _ _ op ih1 ih2 => exact .assertEq ih1 ih2 op + | binary _ _ op ih1 ih2 => exact .binary ih1 ih2 op + | call _ _ ih1 ih2 => exact .call ih1 ih2 + | matchValue _ h _ ih1 ih2 => exact .matchValue ih1 h ih2 + | nil => exact .nil + | cons _ _ ih1 ih2 => exact .cons ih1 ih2 + | intro h _ ih => exact .intro h ih + +theorem ofCore [Field F] [DecidableEq F] {p : Aiur.Program F} + (ev : Aiur.EvalExpr p locals expr before result after) : + EvalExpr (.ofProgram p) locals expr before result after := by + induction ev using Aiur.EvalExpr.rec + (motive_2 := fun ls es b vs h _ => EvalArgs (.ofProgram p) ls es b vs h) + (motive_3 := fun n xs b v h _ => EvalFn (.ofProgram p) n xs b v h) with + | literal => exact .literal + | var h => exact .var h + | tuple _ ih => exact .tuple ih + | construct _ ih => exact .construct ih + | project _ op ih => exact .project ih op + | letValue _ h _ ih1 ih2 => exact .letValue ih1 h ih2 + | store _ ih => exact .store ih + | load _ op ih => exact .load ih op + | hint _ typed ih => exact .hint ih typed + | neg _ op ih => exact .neg ih op + | assertEq _ _ op ih1 ih2 => exact .assertEq ih1 ih2 op + | binary _ _ op ih1 ih2 => exact .binary ih1 ih2 op + | call _ _ ih1 ih2 => exact .call ih1 ih2 + | matchValue _ h _ ih1 ih2 => exact .matchValue ih1 h ih2 + | nil => exact .nil + | cons _ _ ih1 ih2 => exact .cons ih1 ih2 + | intro h _ ih => exact .intro h ih + +theorem core_iff [Field F] [DecidableEq F] {p : Aiur.Program F} : + EvalFn (.ofProgram p) n args before result after ↔ Aiur.EvalFn p n args before result after := by + constructor + · rintro ⟨prepared, body⟩; exact .intro prepared body.toCore + · rintro ⟨prepared, body⟩; exact .intro prepared (ofCore body) + +end Aiur.Generic.Engine diff --git a/Aiur/Aiur/Generic/SliceFacts.lean b/Aiur/Aiur/Generic/SliceFacts.lean new file mode 100644 index 000000000..16ff25c92 --- /dev/null +++ b/Aiur/Aiur/Generic/SliceFacts.lean @@ -0,0 +1,63 @@ +import Aiur.Generic.SourceSemantics +import Aiur.Generic.ArrayFacts + +namespace Aiur.Generic.ArrayLowering + +private theorem range_projects (values : List (SourceValue F)) (length : Nat) (start : Nat) + (bound : start + length ≤ values.length) : + (List.range' start length).mapM (projectValue (.tuple values)) = + .ok ((values.drop start).take length) := by + induction length generalizing start with + | zero => simp + | succ length ih => + have index : start < values.length := by omega + have rest := ih (start + 1) (by omega) + rw [List.range'_succ, List.mapM_cons] + have head : projectValue (.tuple values) start = .ok values[start] := by + simp [projectValue, List.getElem?_eq_getElem index] + rw [head, rest, List.drop_eq_getElem_cons index, List.take_succ_cons] + rfl + +/-- Static projections select exactly the native array slice. No heap +operation is introduced, and the result holds for nested values and pointers. -/ +theorem slice_projects (values : List (SourceValue F)) (start stop : Nat) + (ordered : start ≤ stop) (bound : stop ≤ values.length) : + ((List.range (stop - start)).map (start + ·)).mapM (projectValue (.tuple values)) = + .ok ((values.drop start).take (stop - start)) := by + have indices : (List.range (stop - start)).map (start + ·) = List.range' start (stop - start) := by + simpa only [List.range_eq_range', Nat.add_zero] using List.map_add_range' (a := start) 0 (stop - start) 1 + rw [indices] + exact range_projects values (stop - start) start (by omega) + +/-- A successful native slice gives exactly the compiler's projection list. +This direction obtains shape and bounds from the native operation itself. -/ +theorem projects_of_source_slice {input result : SourceValue F} {start stop : Nat} + (sliced : SourceSemantics.sliceValue input start (some stop) = .ok result) : + ∃ values, + ((List.range (stop - start)).map (start + ·)).mapM (projectValue input) = .ok values ∧ + result = .tuple values := by + cases input <;> simp only [SourceSemantics.sliceValue, Option.getD_some] at sliced + all_goals first | contradiction | skip + rename_i values + split at sliced + · contradiction + · rename_i bounds + simp only [Bool.or_eq_true, decide_eq_true_eq, not_or] at bounds + have ordered : start ≤ stop := by omega + have bound : stop ≤ values.length := by omega + have same : result = .tuple ((values.drop start).take (stop - start)) := by + simpa only [pure, Except.pure, bind, Except.bind, Except.ok.injEq] using sliced.symm + exact ⟨_, slice_projects values start stop ordered bound, same⟩ + +/-- Under the checked operand shape and static bounds, the projection result +reflects back to native slicing, including the empty-slice case. -/ +theorem source_slice_of_projects {items values : List (SourceValue F)} {start stop : Nat} + (ordered : start ≤ stop) (bound : stop ≤ items.length) + (projected : ((List.range (stop - start)).map (start + ·)).mapM + (projectValue (.tuple items)) = .ok values) : + SourceSemantics.sliceValue (.tuple items) start (some stop) = .ok (.tuple values) := by + have same := Except.ok.inj ((slice_projects items start stop ordered bound).symm.trans projected) + rw [← same] + simp [SourceSemantics.sliceValue, Nat.not_lt.mpr ordered, Nat.not_lt.mpr bound] + +end Aiur.Generic.ArrayLowering diff --git a/Aiur/Aiur/Generic/SourceCallInduction.lean b/Aiur/Aiur/Generic/SourceCallInduction.lean new file mode 100644 index 000000000..275d25f68 --- /dev/null +++ b/Aiur/Aiur/Generic/SourceCallInduction.lean @@ -0,0 +1,280 @@ +import Aiur.Generic.OpenSource +import Aiur.Generic.SourceSimulation + +namespace Aiur.Generic.SourceSemantics +set_option linter.unusedSimpArgs false + +/-! Induction on finite source evaluations discharges recursive call premises. +Both ordinary fallthrough and an explicit function return close a call. -/ + +theorem EvalExpr.openCalls [Field F] [DecidableEq F] + {world : World F} {calls : CallRelation F} {names : List String} + (closed : ∀ n ∈ names, ∀ args ts ls e, world.prepare n args = .ok (ts, ls, e) → + inScope names (fun _ => true) ts e = true) + (step : ∀ n ∈ names, ∀ args ts ls e b v a, + world.prepare n args = .ok (ts, ls, e) → + (OpenSource.EvalExpr world calls ts ls e b v a ∨ + OpenSource.EvalExit world calls ts ls e b .function v a) → calls n args b v a) + (ev : EvalExpr world types locals expr before result after) : + inScope names (fun _ => true) types expr = true → OpenSource.EvalExpr world calls types locals expr before result after := by + induction ev using EvalExpr.rec + (motive_2 := fun ts ls es b vs h _ => (∀ e ∈ es, inScope names (fun _ => true) ts e = true) → OpenSource.EvalArgs world calls ts ls es b vs h) + (motive_3 := fun n xs b v h _ => n ∈ names → calls n xs b v h) + (motive_4 := fun ts ls e b target v h _ => inScope names (fun _ => true) ts e = true → OpenSource.EvalExit world calls ts ls e b target v h) + (motive_5 := fun ts ls es b target v h _ => (∀ e ∈ es, inScope names (fun _ => true) ts e = true) → OpenSource.EvalArgsExit world calls ts ls es b target v h) with + | block _ ih => intro h; exact .block (ih (by simpa only [inScope] using h)) + | blockExit _ ih => intro h; exact .blockExit (ih (by simpa only [inScope] using h)) + | literal => intro _; exact .literal + | var h => intro _; exact .var h + | global lookup interpreted _ ih => + intro _ + exact .global lookup interpreted + (ih (const_inScope _ interpreted)) + | tuple _ ih => intro h; exact .tuple (ih (by simpa [inScope] using h)) + | array _ ih => intro h; exact .array (ih (by simpa [inScope] using h)) + | «repeat» _ ih => intro h; exact .repeat (ih (by simpa [inScope] using h)) + | index _ op ih => intro h; exact .index (ih (by simpa [inScope] using h)) op + | slice _ op ih => intro h; exact .slice (ih (by simpa [inScope] using h)) op + | constructAs _ ih => intro h; exact .constructAs (ih (by simpa [inScope] using h)) + | builtin _ op ih => intro h; exact .builtin (ih (by simpa [inScope] using h)) op + | update _ op ih => intro h; exact .update (ih (by simpa [inScope] using h)) op + | record _ ih => intro h; exact .record (ih (by simpa [inScope] using h)) + | construct _ ih => intro h; exact .construct (ih (by simpa [inScope] using h)) + | project _ op ih => intro h; exact .project (ih (by simpa [inScope] using h)) op + | member _ op ih => intro h; exact .member (ih (by simpa [inScope] using h)) op + | letValue _ matched _ ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true] at h + exact .letValue (ih1 h.1) matched (ih2 h.2) + | store _ ih => intro h; exact .store (ih (by simpa [inScope] using h)) + | load _ op ih => intro h; exact .load (ih (by simpa [inScope] using h)) op + | hint _ typed ih => + intro h + simp only [inScope, Bool.and_eq_true] at h + exact .hint (ih h.2) typed + | neg _ op ih => intro h; exact .neg (ih (by simpa [inScope] using h)) op + | binary _ _ op ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true] at h + exact .binary (ih1 h.1) (ih2 h.2) op + | call _ _ ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true, List.contains_iff_mem, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .call (ih1 h.2) (ih2 h.1) + | matchValue _ selected _ ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .matchValue (ih1 h.1) selected (ih2 (selected_inScope selected h.2)) + | nil => exact .nil + | cons _ _ ih1 ih2 => + rename_i h + exact .cons (ih1 (h _ (by simp))) (ih2 (fun e he => h e (by simp [he]))) + | intro prepared _ ih => + rename_i hn + exact step _ hn _ _ _ _ _ _ _ prepared (.inl (ih (closed _ hn _ _ _ _ prepared))) + | returned prepared _ ih => + rename_i hn + exact step _ hn _ _ _ _ _ _ _ prepared (.inr (ih (closed _ hn _ _ _ _ prepared))) + | exit _ ih => rename_i h; exact .exit (ih (by simpa only [inScope] using h)) + | exitPayload _ ih => rename_i h; exact .exitPayload (ih (by simpa only [inScope] using h)) + | fromBlock different _ ih => rename_i h; exact .fromBlock different (ih (by simpa only [inScope] using h)) + | fromGlobal lookup interpreted _ ih => + rename_i _unused + exact .fromGlobal lookup interpreted (ih (const_inScope _ interpreted)) + | fromTuple _ ih => rename_i h; exact .fromTuple (ih (by simpa [inScope] using h)) + | fromArray _ ih => rename_i h; exact .fromArray (ih (by simpa [inScope] using h)) + | fromRepeat _ ih => rename_i h; exact .fromRepeat (ih (by simpa [inScope] using h)) + | fromIndex _ ih => rename_i h; exact .fromIndex (ih (by simpa [inScope] using h)) + | fromSlice _ ih => rename_i h; exact .fromSlice (ih (by simpa [inScope] using h)) + | fromConstructAs _ ih => rename_i h; exact .fromConstructAs (ih (by simpa [inScope] using h)) + | fromBuiltin _ ih => rename_i h; exact .fromBuiltin (ih (by simpa [inScope] using h)) + | fromUpdate _ ih => rename_i h; exact .fromUpdate (ih (by simpa [inScope] using h)) + | fromRecord _ ih => rename_i h; exact .fromRecord (ih (by simpa [inScope] using h)) + | fromConstruct _ ih => rename_i h; exact .fromConstruct (ih (by simpa [inScope] using h)) + | fromProject _ ih => rename_i h; exact .fromProject (ih (by simpa [inScope] using h)) + | fromMember _ ih => rename_i h; exact .fromMember (ih (by simpa [inScope] using h)) + | fromStore _ ih => rename_i h; exact .fromStore (ih (by simpa [inScope] using h)) + | fromLoad _ ih => rename_i h; exact .fromLoad (ih (by simpa [inScope] using h)) + | fromNeg _ ih => rename_i h; exact .fromNeg (ih (by simpa [inScope] using h)) + | fromLetValue _ ih => + rename_i h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .fromLetValue (ih h.1) + | fromHint _ ih => + rename_i h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .fromHint (ih h.2) + | binaryLeft _ ih => + rename_i h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .binaryLeft (ih h.1) + | fromCall _ ih => + rename_i h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .fromCall (ih h.2) + | fromMatchValue _ ih => + rename_i h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .fromMatchValue (ih h.1) + | letBody _ matched _ ih1 ih2 => + rename_i h + simp only [inScope, Bool.and_eq_true] at h + exact .letBody (ih1 h.1) matched (ih2 h.2) + | binaryRight _ _ ih1 ih2 => + rename_i h + simp only [inScope, Bool.and_eq_true] at h + exact .binaryRight (ih1 h.1) (ih2 h.2) + | matchBody _ selected _ ih1 ih2 => + rename_i h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .matchBody (ih1 h.1) selected (ih2 (selected_inScope selected h.2)) + | head _ ih => rename_i h; exact .head (ih (h _ (by simp))) + | tail _ _ ih1 ih2 => + rename_i h + exact .tail (ih1 (h _ (by simp))) (ih2 (fun e he => h e (by simp [he]))) + +theorem EvalExit.openCalls [Field F] [DecidableEq F] + {world : World F} {calls : CallRelation F} {names : List String} + (closed : ∀ n ∈ names, ∀ args ts ls e, world.prepare n args = .ok (ts, ls, e) → + inScope names (fun _ => true) ts e = true) + (step : ∀ n ∈ names, ∀ args ts ls e b v a, + world.prepare n args = .ok (ts, ls, e) → + (OpenSource.EvalExpr world calls ts ls e b v a ∨ + OpenSource.EvalExit world calls ts ls e b .function v a) → calls n args b v a) + (ev : EvalExit world types locals expr before target result after) : + inScope names (fun _ => true) types expr = true → OpenSource.EvalExit world calls types locals expr before target result after := by + induction ev using EvalExit.rec + (motive_1 := fun ts ls e b v h _ => inScope names (fun _ => true) ts e = true → OpenSource.EvalExpr world calls ts ls e b v h) + (motive_2 := fun ts ls es b vs h _ => (∀ e ∈ es, inScope names (fun _ => true) ts e = true) → OpenSource.EvalArgs world calls ts ls es b vs h) + (motive_3 := fun n xs b v h _ => n ∈ names → calls n xs b v h) + (motive_5 := fun ts ls es b target v h _ => (∀ e ∈ es, inScope names (fun _ => true) ts e = true) → OpenSource.EvalArgsExit world calls ts ls es b target v h) with + | block _ ih => rename_i h; exact .block (ih (by simpa only [inScope] using h)) + | blockExit _ ih => rename_i h; exact .blockExit (ih (by simpa only [inScope] using h)) + | literal => rename_i _unused; exact .literal + | var h => rename_i _unused; exact .var h + | global lookup interpreted _ ih => + rename_i _unused + exact .global lookup interpreted + (ih (const_inScope _ interpreted)) + | tuple _ ih => rename_i h; exact .tuple (ih (by simpa [inScope] using h)) + | array _ ih => rename_i h; exact .array (ih (by simpa [inScope] using h)) + | «repeat» _ ih => rename_i h; exact .repeat (ih (by simpa [inScope] using h)) + | index _ op ih => rename_i h; exact .index (ih (by simpa [inScope] using h)) op + | slice _ op ih => rename_i h; exact .slice (ih (by simpa [inScope] using h)) op + | constructAs _ ih => rename_i h; exact .constructAs (ih (by simpa [inScope] using h)) + | builtin _ op ih => rename_i h; exact .builtin (ih (by simpa [inScope] using h)) op + | update _ op ih => rename_i h; exact .update (ih (by simpa [inScope] using h)) op + | record _ ih => rename_i h; exact .record (ih (by simpa [inScope] using h)) + | construct _ ih => rename_i h; exact .construct (ih (by simpa [inScope] using h)) + | project _ op ih => rename_i h; exact .project (ih (by simpa [inScope] using h)) op + | member _ op ih => rename_i h; exact .member (ih (by simpa [inScope] using h)) op + | letValue _ matched _ ih1 ih2 => + rename_i h + simp only [inScope, Bool.and_eq_true] at h + exact .letValue (ih1 h.1) matched (ih2 h.2) + | store _ ih => rename_i h; exact .store (ih (by simpa [inScope] using h)) + | load _ op ih => rename_i h; exact .load (ih (by simpa [inScope] using h)) op + | hint _ typed ih => + rename_i h + simp only [inScope, Bool.and_eq_true] at h + exact .hint (ih h.2) typed + | neg _ op ih => rename_i h; exact .neg (ih (by simpa [inScope] using h)) op + | binary _ _ op ih1 ih2 => + rename_i h + simp only [inScope, Bool.and_eq_true] at h + exact .binary (ih1 h.1) (ih2 h.2) op + | call _ _ ih1 ih2 => + rename_i h + simp only [inScope, Bool.and_eq_true, List.contains_iff_mem, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .call (ih1 h.2) (ih2 h.1) + | matchValue _ selected _ ih1 ih2 => + rename_i h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .matchValue (ih1 h.1) selected (ih2 (selected_inScope selected h.2)) + | nil => exact .nil + | cons _ _ ih1 ih2 => + rename_i h + exact .cons (ih1 (h _ (by simp))) (ih2 (fun e he => h e (by simp [he]))) + | intro prepared _ ih => + rename_i hn + exact step _ hn _ _ _ _ _ _ _ prepared (.inl (ih (closed _ hn _ _ _ _ prepared))) + | returned prepared _ ih => + rename_i hn + exact step _ hn _ _ _ _ _ _ _ prepared (.inr (ih (closed _ hn _ _ _ _ prepared))) + | exit _ ih => intro h; exact .exit (ih (by simpa only [inScope] using h)) + | exitPayload _ ih => intro h; exact .exitPayload (ih (by simpa only [inScope] using h)) + | fromBlock different _ ih => intro h; exact .fromBlock different (ih (by simpa only [inScope] using h)) + | fromGlobal lookup interpreted _ ih => + intro _ + exact .fromGlobal lookup interpreted (ih (const_inScope _ interpreted)) + | fromTuple _ ih => intro h; exact .fromTuple (ih (by simpa [inScope] using h)) + | fromArray _ ih => intro h; exact .fromArray (ih (by simpa [inScope] using h)) + | fromRepeat _ ih => intro h; exact .fromRepeat (ih (by simpa [inScope] using h)) + | fromIndex _ ih => intro h; exact .fromIndex (ih (by simpa [inScope] using h)) + | fromSlice _ ih => intro h; exact .fromSlice (ih (by simpa [inScope] using h)) + | fromConstructAs _ ih => intro h; exact .fromConstructAs (ih (by simpa [inScope] using h)) + | fromBuiltin _ ih => intro h; exact .fromBuiltin (ih (by simpa [inScope] using h)) + | fromUpdate _ ih => intro h; exact .fromUpdate (ih (by simpa [inScope] using h)) + | fromRecord _ ih => intro h; exact .fromRecord (ih (by simpa [inScope] using h)) + | fromConstruct _ ih => intro h; exact .fromConstruct (ih (by simpa [inScope] using h)) + | fromProject _ ih => intro h; exact .fromProject (ih (by simpa [inScope] using h)) + | fromMember _ ih => intro h; exact .fromMember (ih (by simpa [inScope] using h)) + | fromStore _ ih => intro h; exact .fromStore (ih (by simpa [inScope] using h)) + | fromLoad _ ih => intro h; exact .fromLoad (ih (by simpa [inScope] using h)) + | fromNeg _ ih => intro h; exact .fromNeg (ih (by simpa [inScope] using h)) + | fromLetValue _ ih => + intro h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .fromLetValue (ih h.1) + | fromHint _ ih => + intro h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .fromHint (ih h.2) + | binaryLeft _ ih => + intro h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .binaryLeft (ih h.1) + | fromCall _ ih => + intro h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .fromCall (ih h.2) + | fromMatchValue _ ih => + intro h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .fromMatchValue (ih h.1) + | letBody _ matched _ ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true] at h + exact .letBody (ih1 h.1) matched (ih2 h.2) + | binaryRight _ _ ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true] at h + exact .binaryRight (ih1 h.1) (ih2 h.2) + | matchBody _ selected _ ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .matchBody (ih1 h.1) selected (ih2 (selected_inScope selected h.2)) + | head _ ih => rename_i h; exact .head (ih (h _ (by simp))) + | tail _ _ ih1 ih2 => + rename_i h + exact .tail (ih1 (h _ (by simp))) (ih2 (fun e he => h e (by simp [he]))) + +theorem EvalFn.openCalls [Field F] [DecidableEq F] + {world : World F} {calls : CallRelation F} {names : List String} + (closed : ∀ n ∈ names, ∀ args ts ls e, world.prepare n args = .ok (ts, ls, e) → + inScope names (fun _ => true) ts e = true) + (step : ∀ n ∈ names, ∀ args ts ls e b v a, + world.prepare n args = .ok (ts, ls, e) → + (OpenSource.EvalExpr world calls ts ls e b v a ∨ + OpenSource.EvalExit world calls ts ls e b .function v a) → calls n args b v a) + (ev : EvalFn world name args before result after) (member : name ∈ names) : + calls name args before result after := by + cases ev with + | intro prepared body => + exact step _ member _ _ _ _ _ _ _ prepared + (.inl (body.openCalls closed step (closed _ member _ _ _ _ prepared))) + | returned prepared body => + exact step _ member _ _ _ _ _ _ _ prepared + (.inr (body.openCalls closed step (closed _ member _ _ _ _ prepared))) + +end Aiur.Generic.SourceSemantics diff --git a/Aiur/Aiur/Generic/SourceEvalFacts.lean b/Aiur/Aiur/Generic/SourceEvalFacts.lean new file mode 100644 index 000000000..178a5e2df --- /dev/null +++ b/Aiur/Aiur/Generic/SourceEvalFacts.lean @@ -0,0 +1,16 @@ +import Aiur.Generic.ControlEvalSpec + +namespace Aiur.Generic.SourceSemantics + +/-- Every successful ordinary expression run has a native derivation. Use +`evalOutcome_spec` when observing an exit and `evalFunction_spec` at a function +boundary, where an early return also supplies a successful result. -/ +theorem evalExpr_spec [Field F] [DecidableEq F] + {world : World F} {types : Types} {hints : HintProvider world} + {locals : Environment F Nat} {fuel : Nat} {expr : Expr F} + {before after : Heap F} {result : SourceValue F} + (executed : evalExprWith world hints types locals fuel expr before = .ok (result, after)) : + EvalExpr world types locals expr before result after := + evalOutcome_spec (finishExpression_ok.mp executed) + +end Aiur.Generic.SourceSemantics diff --git a/Aiur/Aiur/Generic/SourceRules.lean b/Aiur/Aiur/Generic/SourceRules.lean new file mode 100644 index 000000000..4501face7 --- /dev/null +++ b/Aiur/Aiur/Generic/SourceRules.lean @@ -0,0 +1,38 @@ +import Aiur.Generic.SourceSemantics + +namespace Aiur.Generic.SourceSemantics + +variable [Field F] [DecidableEq F] {world : World F} + +/-- Repetition copies the result of one source evaluation, including length zero. -/ +theorem repeat_iff : + EvalExpr world types locals (.repeat operand length) before result after ↔ + ∃ value, EvalExpr world types locals operand before value after ∧ + result = .tuple (List.replicate length value) := by + constructor + · intro h + cases h with + | «repeat» value => exact ⟨_, value, rfl⟩ + · rintro ⟨value, evaluated, rfl⟩ + exact .repeat evaluated + +/-- A pointer pattern reads the pointer before matching the inner pattern. +This is a source-level law and does not refer to generated core syntax. -/ +theorem let_load_iff : + EvalExpr world types locals (.letValue (.load pat) operand body) before result after ↔ + EvalExpr world types locals (.letValue pat (.load operand) body) before result after := by + constructor + · intro h + cases h with + | letValue value matched body => + simp only [World.matchPattern, matchPatternWith, except_bind_ok] at matched + obtain ⟨input, loaded, matched⟩ := matched + exact .letValue (.load value loaded) matched body + · intro h + cases h with + | letValue value matched body => + cases value with + | load pointer loaded => + exact .letValue pointer (by simp only [World.matchPattern, matchPatternWith, except_bind_ok]; exact ⟨_, loaded, matched⟩) body + +end Aiur.Generic.SourceSemantics diff --git a/Aiur/Aiur/Generic/SourceSemantics.lean b/Aiur/Aiur/Generic/SourceSemantics.lean new file mode 100644 index 000000000..4139d0c54 --- /dev/null +++ b/Aiur/Aiur/Generic/SourceSemantics.lean @@ -0,0 +1,300 @@ +import Aiur.Generic.Builtin +import Aiur.Generic.Update +import Aiur.Generic.Consts +import Aiur.EvalCorrectness + +/-! Evaluation is defined on the checked source AST. Type arguments are carried +in an environment; bodies are neither specialized nor lowered before execution. +The existing structured values and allocation heap are shared with the core. -/ + +namespace Aiur.Generic.SourceSemantics + +abbrev Types := List (String × Ty) + +def instanceName (types : Types) (name : String) (args : Option (List Ty)) : String := + (Instance.mk name ((args.getD []).map (Ty.subst types))).symbol + +def constructorName (types : Types) (type : Ty) : String := + match (type.subst types).toCore with + | .enum name => name + | _ => "$invalid" + +structure World (F : Type) where + prepare : String → List (SourceValue F) → Except EvalError (Types × Environment F Nat × Expr F) + typed : Aiur.Ty → Constant F → Bool + /-- A single declaration lookup, with its use-site type information. -/ + constant : String → Ty → Except EvalError (Pattern F) := + fun name _ => .error (.unboundVariable ("::" ++ name)) + /-- The checked acyclic declaration graph bounds reference traversal. -/ + constDepth : Nat := 0 + +/-- Ordered, short-circuiting matching of a sequence. No later read is made +once an earlier pattern has failed. -/ +def matchListWith (matchOne : A → SourceValue F → Except EvalError (Option (Environment F Nat))) : + List A → List (SourceValue F) → Except EvalError (Option (Environment F Nat)) + | [], [] => pure (some []) + | p :: ps, value :: values => do + let some bindings ← matchOne p value | return none + let some rest ← matchListWith matchOne ps values | return none + return some (bindings ++ rest) + | _, _ => pure none + +/-- Pattern matching only reads the heap. A failed test returns `none`; a bad +load is an error, and cannot select a later arm. Bindings are installed only +after the whole pattern succeeds. -/ +def matchPatternWith [DecidableEq F] (constant : String → Ty → Except EvalError (Pattern F)) + (depth : Nat) (types : Types) (heap : Heap F) : + Pattern F → SourceValue F → Except EvalError (Option (Environment F Nat)) + | .literal x, value => pure ((Aiur.Pattern.literal x).bindings value) + | .wildcard, _ => pure (some []) + | .bind name, value => pure (some [(name, value)]) + | .global name annotation, value => do + let some type := annotation | throw (.unboundVariable ("::" ++ name)) + match depth with + | 0 => throw (.unboundVariable ("::" ++ name)) + | depth + 1 => + let body ← constant name (type.subst types) + matchPatternWith constant depth [] heap body value + | .orElse left right layout, value => do + let (selected, positions) ← match ← matchPatternWith constant depth types heap left value with + | some bindings => pure (some bindings, List.range layout.names.length) + | none => (matchPatternWith constant depth types heap right value).map (fun result => (result, layout.rightOrder)) + let some bindings := selected | return none + let some ordered := reorderBindings layout.names positions bindings | throw .patternMismatch + return some ordered + | .load pat, value => do matchPatternWith constant depth types heap pat (← loadValue heap value) + | .tuple ps, value | .array ps, value => do + let .tuple values := value | return none + if ps.length != values.length then return none + matchListWith (fun pat value => matchPatternWith constant depth types heap pat.val value) ps.attach values + | .repeat pat n, value => do + let .tuple values := value | return none + if values.length != n then return none + matchListWith (fun (_ : Unit) value => matchPatternWith constant depth types heap pat value) + (List.replicate n ()) values + | .record head ps, value => do + let .construct name ctor values := value | return none + if name != constructorName types head.type || ctor != structConstructor then return none + let children := head.order (ps.attach.map some) none + if children.length != values.length then return none + matchListWith (fun child value => match child with + | some pat => matchPatternWith constant depth types heap pat.val value + | none => pure (some [])) children values + | .construct t c ps, value | .constructAs _ t c ps, value => do + let .construct name ctor values := value | return none + if name != constructorName types t || ctor != c || ps.length != values.length then return none + matchListWith (fun pat value => matchPatternWith constant depth types heap pat.val value) ps.attach values +termination_by pat _ => (depth, sizeOf pat) +decreasing_by + all_goals simp_wf + all_goals first | omega | skip + all_goals try have := List.sizeOf_lt_of_mem pat.property + all_goals try simp_all only [Pattern.tuple.sizeOf_spec, Pattern.array.sizeOf_spec, + Pattern.construct.sizeOf_spec, Pattern.constructAs.sizeOf_spec, Pattern.record.sizeOf_spec] + all_goals omega + +def World.matchPattern [DecidableEq F] (world : World F) := + matchPatternWith world.constant world.constDepth + +/-- Matching without global declarations, useful for standalone patterns. -/ +def matchPattern [DecidableEq F] := + matchPatternWith (F := F) (fun name _ => .error (.unboundVariable ("::" ++ name))) 0 + +def selectArm [DecidableEq F] (world : World F) (types : Types) (heap : Heap F) (value : SourceValue F) : + List (Pattern F × Expr F) → Except EvalError (Option (Environment F Nat × Expr F)) + | [] => pure none + | (pat, body) :: arms => do + match ← world.matchPattern types heap pat value with + | some bindings => return some (bindings, body) + | none => selectArm world types heap value arms + +/-- Bounds are source naturals. Slicing makes a value and never allocates. -/ +def sliceValue (value : SourceValue F) (start : Nat) (stop : Option Nat) : Except EvalError (SourceValue F) := do + let .tuple values := value | throw .expectedTuple + let stop := stop.getD values.length + if start > stop || stop > values.length then throw (.projectionBounds stop values.length) + return .tuple ((values.drop start).take (stop - start)) + + +/-- Read one field of a checked nominal product; no address is observed. -/ +def memberValue (types : Types) (field : FieldRef) (value : SourceValue F) : Except EvalError (SourceValue F) := do + let name := constructorName types (field.owner.getD (.named "$invalid" [])) + let .construct actual ctor values := value | throw (.malformedValue (.enum name)) + if actual != name || ctor != structConstructor || values.length != field.arity then + throw (.malformedValue (.enum name)) + match values[field.index]? with + | some value => return value + | none => throw (.projectionBounds field.index field.arity) + +abbrev HintProvider (world : World F) := String → SourceValue F → (type : Aiur.Ty) → + Except HintError { value : Constant F // world.typed type value = true } + +def unavailable : HintProvider world := fun _ _ _ => .error .unavailable + + +mutual + inductive EvalExpr [Field F] [DecidableEq F] (world : World F) : + Types → Environment F Nat → Expr F → Heap F → SourceValue F → Heap F → Prop where + | block (body : EvalExpr world types locals expr before result after) : + EvalExpr world types locals (.control (.block label) expr) before result after + | blockExit (body : EvalExit world types locals expr before (.block label) result after) : + EvalExpr world types locals (.control (.block label) expr) before result after + | literal : EvalExpr world types locals (.literal value) heap (.field value) heap + | var (lookup : locals.find? (·.1 == name) = some (name, value)) : + EvalExpr world types locals (.var name) heap value heap + | global + (lookup : world.constant name (type.subst types) = .ok pattern) + (interpreted : Consts.toExpr pattern = .ok body) + (value : EvalExpr world [] [] body before result after) : + EvalExpr world types locals (.global name (some type)) before result after + | tuple (items : EvalArgs world types locals exprs before values after) : + EvalExpr world types locals (.tuple exprs) before (.tuple values) after + | array (items : EvalArgs world types locals exprs before values after) : + EvalExpr world types locals (.array exprs) before (.tuple values) after + | «repeat» (value : EvalExpr world types locals expr before input after) : + EvalExpr world types locals (.repeat expr length) before (.tuple (List.replicate length input)) after + | index (value : EvalExpr world types locals expr before input after) + (projected : projectValue input index = .ok result) : + EvalExpr world types locals (.index expr index) before result after + | slice (value : EvalExpr world types locals expr before input after) + (sliced : sliceValue input start stop = .ok result) : + EvalExpr world types locals (.slice expr start stop) before result after + | builtin (items : EvalArgs world types locals exprs before values after) + (applied : operation.apply values = .ok result) : + EvalExpr world types locals (.builtin operation exprs) before result after + | update (items : EvalArgs world types locals exprs before values after) + (updated : Update.value types paths values = .ok result) : + EvalExpr world types locals (.update paths exprs) before result after + | record (items : EvalArgs world types locals exprs before values after) : + EvalExpr world types locals (.record head exprs) before + (.construct (constructorName types head.type) structConstructor (head.order values (.tuple []))) after + | member (value : EvalExpr world types locals expr before input after) + (projected : memberValue types field input = .ok result) : + EvalExpr world types locals (.member expr field) before result after + | construct (items : EvalArgs world types locals exprs before values after) : + EvalExpr world types locals (.construct name args ctor exprs) before (.construct (instanceName types name args) ctor values) after + | constructAs (items : EvalArgs world types locals exprs before values after) : + EvalExpr world types locals (.constructAs params t ctor exprs) before (.construct (constructorName types t) ctor values) after + | project (value : EvalExpr world types locals expr before input after) + (projected : projectValue input index = .ok result) : + EvalExpr world types locals (.project expr index) before result after + | letValue (value : EvalExpr world types locals expr before input middle) + (matched : world.matchPattern types middle pattern input = .ok (some bindings)) + (body : EvalExpr world types (bindings ++ locals) rest middle result after) : + EvalExpr world types locals (.letValue pattern expr rest) before result after + | store (value : EvalExpr world types locals expr before input middle) : + EvalExpr world types locals (.store expr) before (.ptr input.type middle.length) (middle ++ [input]) + | load (pointer : EvalExpr world types locals expr before input after) + (loaded : loadValue after input = .ok result) : + EvalExpr world types locals (.load expr) before result after + | hint (key : EvalExpr world types locals expr before input after) + {value : Constant F} (typed : world.typed (t.subst types).toCore value = true) : + EvalExpr world types locals (.hint t expr channel) before value.toValue after + | neg (value : EvalExpr world types locals expr before input after) + (operation : evalNeg input = .ok result) : + EvalExpr world types locals (.neg expr) before result after + | binary (left : EvalExpr world types locals lhs before x middle) + (right : EvalExpr world types locals rhs middle y after) + (operation : evalBinOp op x y = .ok result) : + EvalExpr world types locals (.binary op lhs rhs) before result after + | call (arguments : EvalArgs world types locals args before values middle) + (callee : EvalFn world (instanceName types name typeArgs) values middle result after) : + EvalExpr world types locals (.call name typeArgs args) before result after + | matchValue (value : EvalExpr world types locals expr before input middle) + (selected : selectArm world types middle input arms = .ok (some (bindings, body))) + (branch : EvalExpr world types (bindings ++ locals) body middle result after) : + EvalExpr world types locals (.matchValue expr arms) before result after + + inductive EvalArgs [Field F] [DecidableEq F] (world : World F) : + Types → Environment F Nat → List (Expr F) → Heap F → List (SourceValue F) → Heap F → Prop where + | nil : EvalArgs world types locals [] heap [] heap + | cons (head : EvalExpr world types locals expr before value middle) + (tail : EvalArgs world types locals exprs middle values after) : + EvalArgs world types locals (expr :: exprs) before (value :: values) after + + inductive EvalFn [Field F] [DecidableEq F] (world : World F) : + String → List (SourceValue F) → Heap F → SourceValue F → Heap F → Prop where + | intro (prepared : world.prepare name args = .ok (types, locals, expr)) + (body : EvalExpr world types locals expr before result after) : + EvalFn world name args before result after + | returned (prepared : world.prepare name args = .ok (types, locals, expr)) + (body : EvalExit world types locals expr before .function result after) : + EvalFn world name args before result after + + /-- Abrupt evaluation preserves the heap prefix already executed. It carries + a lexical target and is caught only by that block or the current function. -/ + inductive EvalExit [Field F] [DecidableEq F] (world : World F) : + Types → Environment F Nat → Expr F → Heap F → ExitTarget → SourceValue F → Heap F → Prop where + | exit (value : EvalExpr world types locals expr before result after) : + EvalExit world types locals (.control (.exit target) expr) before target result after + | exitPayload (value : EvalExit world types locals expr before target result after) : + EvalExit world types locals (.control (.exit outer) expr) before target result after + | fromBlock (different : target ≠ .block label) + (body : EvalExit world types locals expr before target result after) : + EvalExit world types locals (.control (.block label) expr) before target result after + | fromGlobal (lookup : world.constant name (type.subst types) = .ok pattern) + (interpreted : Consts.toExpr pattern = .ok body) + (value : EvalExit world [] [] body before target result after) : + EvalExit world types locals (.global name (some type)) before target result after + | fromTuple (items : EvalArgsExit world types locals exprs before target result after) : + EvalExit world types locals (.tuple exprs) before target result after + | fromArray (items : EvalArgsExit world types locals exprs before target result after) : + EvalExit world types locals (.array exprs) before target result after + | fromRepeat (value : EvalExit world types locals expr before target result after) : + EvalExit world types locals (.repeat expr length) before target result after + | fromIndex (value : EvalExit world types locals expr before target result after) : + EvalExit world types locals (.index expr index) before target result after + | fromSlice (value : EvalExit world types locals expr before target result after) : + EvalExit world types locals (.slice expr start stop) before target result after + | fromBuiltin (items : EvalArgsExit world types locals exprs before target result after) : + EvalExit world types locals (.builtin operation exprs) before target result after + | fromUpdate (items : EvalArgsExit world types locals exprs before target result after) : + EvalExit world types locals (.update paths exprs) before target result after + | fromRecord (items : EvalArgsExit world types locals exprs before target result after) : + EvalExit world types locals (.record head exprs) before target result after + | fromMember (value : EvalExit world types locals expr before target result after) : + EvalExit world types locals (.member expr field) before target result after + | fromConstruct (items : EvalArgsExit world types locals exprs before target result after) : + EvalExit world types locals (.construct name args ctor exprs) before target result after + | fromConstructAs (items : EvalArgsExit world types locals exprs before target result after) : + EvalExit world types locals (.constructAs params t ctor exprs) before target result after + | fromProject (value : EvalExit world types locals expr before target result after) : + EvalExit world types locals (.project expr index) before target result after + | fromLetValue (value : EvalExit world types locals expr before target result after) : + EvalExit world types locals (.letValue pattern expr rest) before target result after + | letBody (value : EvalExpr world types locals expr before input middle) + (matched : world.matchPattern types middle pattern input = .ok (some bindings)) + (body : EvalExit world types (bindings ++ locals) rest middle target result after) : + EvalExit world types locals (.letValue pattern expr rest) before target result after + | fromStore (value : EvalExit world types locals expr before target result after) : + EvalExit world types locals (.store expr) before target result after + | fromLoad (value : EvalExit world types locals expr before target result after) : + EvalExit world types locals (.load expr) before target result after + | fromHint (value : EvalExit world types locals expr before target result after) : + EvalExit world types locals (.hint t expr channel) before target result after + | fromNeg (value : EvalExit world types locals expr before target result after) : + EvalExit world types locals (.neg expr) before target result after + | binaryLeft (value : EvalExit world types locals left before target result after) : + EvalExit world types locals (.binary op left right) before target result after + | binaryRight (left : EvalExpr world types locals lhs before input middle) + (right : EvalExit world types locals rhs middle target result after) : + EvalExit world types locals (.binary op lhs rhs) before target result after + | fromCall (arguments : EvalArgsExit world types locals args before target result after) : + EvalExit world types locals (.call name typeArgs args) before target result after + | fromMatchValue (value : EvalExit world types locals expr before target result after) : + EvalExit world types locals (.matchValue expr arms) before target result after + | matchBody (value : EvalExpr world types locals expr before input middle) + (selected : selectArm world types middle input arms = .ok (some (bindings, body))) + (branch : EvalExit world types (bindings ++ locals) body middle target result after) : + EvalExit world types locals (.matchValue expr arms) before target result after + + inductive EvalArgsExit [Field F] [DecidableEq F] (world : World F) : + Types → Environment F Nat → List (Expr F) → Heap F → ExitTarget → SourceValue F → Heap F → Prop where + | head (value : EvalExit world types locals expr before target result after) : + EvalArgsExit world types locals (expr :: rest) before target result after + | tail (head : EvalExpr world types locals expr before value middle) + (tail : EvalArgsExit world types locals rest middle target result after) : + EvalArgsExit world types locals (expr :: rest) before target result after +end + +end Aiur.Generic.SourceSemantics diff --git a/Aiur/Aiur/Generic/SourceSimulation.lean b/Aiur/Aiur/Generic/SourceSimulation.lean new file mode 100644 index 000000000..0916316c5 --- /dev/null +++ b/Aiur/Aiur/Generic/SourceSimulation.lean @@ -0,0 +1,374 @@ +import Aiur.Generic.SourceSemantics + +namespace Aiur.Generic.SourceSemantics +set_option linter.unusedSimpArgs false + +def inScope (names : List String) (hintType : Aiur.Ty → Bool) (types : Types) : Expr α → Bool + | .literal _ | .var _ => true + | .global _ _ => true + | .builtin _ xs | .update _ xs | .record _ xs | .tuple xs | .array xs | .construct _ _ _ xs | .constructAs _ _ _ xs => (xs.map (inScope names hintType types)).all id + | .call n ts xs => names.contains (instanceName types n ts) && (xs.map (inScope names hintType types)).all id + | .member x _ | .control _ x | .project x _ | .index x _ | .slice x _ _ | .repeat x _ | .store x | .load x | .neg x => inScope names hintType types x + | .hint t x channel => hintType (t.subst types).toCore && inScope names hintType types x + | .letValue _ x b | .binary _ x b => inScope names hintType types x && inScope names hintType types b + | .matchValue x arms => inScope names hintType types x && (arms.map fun a => inScope names hintType types a.2).all id +termination_by e => sizeOf e +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +private theorem mapM_forall {xs : List A} {ys : List B} {f : A → Except E B} {P : B → Prop} + (mapped : xs.mapM f = .ok ys) + (good : ∀ x ∈ xs, ∀ y, f x = .ok y → P y) : ∀ y ∈ ys, P y := by + induction xs generalizing ys with + | nil => simp at mapped; subst ys; simp + | cons x xs ih => + simp only [List.mapM_cons, except_bind_ok, except_pure_ok] at mapped + obtain ⟨y, hy, rest, hr, rfl⟩ := mapped + intro z hz + rcases List.mem_cons.mp hz with rfl | hz + · exact good x (by simp) _ hy + · exact ih hr (fun x hx => good x (by simp [hx])) z hz + +/-- Const bodies have no calls or hints. Following another const reference +also preserves this syntactic property. -/ +theorem const_inScope (pattern : Pattern F) {expr : Expr F} + (interpreted : Consts.toExpr pattern = .ok expr) : + inScope names hintType types expr = true := by + have sub (p : Pattern F) (hsize : sizeOf p < sizeOf pattern) {e : Expr F} + (h : Consts.toExpr p = .ok e) : inScope names hintType types e = true := + const_inScope p h + have children (ps : List (Pattern F)) (smaller : ∀ p ∈ ps, sizeOf p < sizeOf pattern) + (es : List (Expr F)) (mapped : ps.mapM Consts.toExpr = .ok es) : + ∀ e ∈ es, inScope names hintType types e = true := + mapM_forall mapped (fun p hp _ h => sub p (smaller p hp) h) + cases pattern with + | literal | global => + simp only [Consts.toExpr, except_pure_ok] at interpreted + subst expr + simp only [inScope] + | wildcard | bind | orElse => simp [Consts.toExpr] at interpreted + | load p | «repeat» p n => + simp only [Consts.toExpr, except_bind_ok, except_pure_ok] at interpreted + obtain ⟨e, he, rfl⟩ := interpreted + simpa only [inScope] using sub p (by simp_wf <;> omega) he + | record _ ps | tuple ps | array ps | constructAs _ _ _ ps => + simp only [Consts.toExpr, except_bind_ok, except_pure_ok] at interpreted + obtain ⟨es, mapped, rfl⟩ := interpreted + simp only [inScope, List.all_map, List.all_eq_true, Function.comp_def, id_eq] + exact children ps (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) es mapped + | construct t c ps => + cases t <;> simp only [Consts.toExpr] at interpreted + all_goals first | contradiction | skip + simp only [except_bind_ok, except_pure_ok] at interpreted + obtain ⟨es, mapped, rfl⟩ := interpreted + simp only [inScope, List.all_map, List.all_eq_true, Function.comp_def, id_eq] + exact children ps (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) es mapped +termination_by sizeOf pattern +decreasing_by + all_goals exact hsize + +theorem selected_inScope [DecidableEq F] {input : SourceValue F} {arms : List (Pattern F × Expr F)} + (selected : selectArm world types heap input arms = .ok (some (bindings, body))) + (safe : ∀ a ∈ arms, inScope names hintType types a.2 = true) : inScope names hintType types body = true := by + induction arms with + | nil => simp [selectArm] at selected + | cons a rest ih => + rcases a with ⟨p, e⟩ + cases matched : world.matchPattern types heap p input with + | error e => simp [selectArm, matched, bind, Except.bind] at selected + | ok bs => cases bs with + | none => exact ih (by simpa [selectArm, matched, bind, Except.bind, pure, Except.pure] using selected) (fun a h => safe a (by simp [h])) + | some bs => + obtain ⟨rfl, rfl⟩ := (by simpa [selectArm, matched, bind, Except.bind, pure, Except.pure] using selected : bs = bindings ∧ e = body) + exact safe (p, e) (by simp) + +/-- The finite certificate concerns syntax and lookup, not evaluation or +termination. This simulation works for all finite evaluations and all hints. -/ +structure Agreement (left right : World F) (names : List String) (hintType : Aiur.Ty → Bool) : Prop where + constants : left.constant = right.constant + constDepth : left.constDepth = right.constDepth + prepare : ∀ n ∈ names, ∀ args types locals body, + left.prepare n args = .ok (types, locals, body) ↔ right.prepare n args = .ok (types, locals, body) + hint : ∀ t, hintType t = true → ∀ v, left.typed t v = true ↔ right.typed t v = true + closed : ∀ n ∈ names, ∀ args types locals body, + left.prepare n args = .ok (types, locals, body) → inScope names hintType types body = true + +def Agreement.symm (a : Agreement left right names hintType) : Agreement right left names hintType where + constants := a.constants.symm + constDepth := a.constDepth.symm + prepare n hn args types locals body := (a.prepare n hn args types locals body).symm + hint t ht v := (a.hint t ht v).symm + closed n hn args types locals body h := a.closed n hn args types locals body ((a.prepare n hn args types locals body).mpr h) + +variable {F : Type} {left right : World F} {names : List String} {hintType : Aiur.Ty → Bool} + +theorem Agreement.patterns [DecidableEq F] (a : Agreement left right names hintType) : + left.matchPattern = right.matchPattern := by + simp only [World.matchPattern, a.constants, a.constDepth] + +theorem Agreement.select [DecidableEq F] (a : Agreement left right names hintType) : + selectArm left types heap input arms = selectArm right types heap input arms := by + induction arms with + | nil => rfl + | cons arm rest ih => simp only [selectArm, a.patterns, ih] + + + +theorem EvalExpr.transfer [Field F] [DecidableEq F] + (a : Agreement left right names hintType) + (ev : EvalExpr left types locals expr before result after) : + inScope names hintType types expr = true → EvalExpr right types locals expr before result after := by + induction ev using EvalExpr.rec + (motive_2 := fun ts ls es b vs h _ => (∀ e ∈ es, inScope names hintType ts e = true) → EvalArgs right ts ls es b vs h) + (motive_3 := fun n xs b v h _ => n ∈ names → EvalFn right n xs b v h) + (motive_4 := fun ts ls e b target v h _ => inScope names hintType ts e = true → EvalExit right ts ls e b target v h) + (motive_5 := fun ts ls es b target v h _ => (∀ e ∈ es, inScope names hintType ts e = true) → EvalArgsExit right ts ls es b target v h) with + | block _ ih => intro h; exact .block (ih (by simpa only [inScope] using h)) + | blockExit _ ih => intro h; exact .blockExit (ih (by simpa only [inScope] using h)) + | literal => intro _; exact .literal + | var h => intro _; exact .var h + | global lookup interpreted _ ih => + intro _ + exact .global (by simpa only [← a.constants] using lookup) interpreted + (ih (const_inScope _ interpreted)) + | tuple _ ih => intro h; exact .tuple (ih (by simpa [inScope] using h)) + | array _ ih => intro h; exact .array (ih (by simpa [inScope] using h)) + | «repeat» _ ih => intro h; exact .repeat (ih (by simpa [inScope] using h)) + | index _ op ih => intro h; exact .index (ih (by simpa [inScope] using h)) op + | slice _ op ih => intro h; exact .slice (ih (by simpa [inScope] using h)) op + | constructAs _ ih => intro h; exact .constructAs (ih (by simpa [inScope] using h)) + | builtin _ op ih => intro h; exact .builtin (ih (by simpa [inScope] using h)) op + | update _ op ih => intro h; exact .update (ih (by simpa [inScope] using h)) op + | record _ ih => intro h; exact .record (ih (by simpa [inScope] using h)) + | construct _ ih => intro h; exact .construct (ih (by simpa [inScope] using h)) + | project _ op ih => intro h; exact .project (ih (by simpa [inScope] using h)) op + | member _ op ih => intro h; exact .member (ih (by simpa [inScope] using h)) op + | letValue _ matched _ ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true] at h + exact .letValue (ih1 h.1) (by simpa only [← a.patterns] using matched) (ih2 h.2) + | store _ ih => intro h; exact .store (ih (by simpa [inScope] using h)) + | load _ op ih => intro h; exact .load (ih (by simpa [inScope] using h)) op + | hint _ typed ih => + intro h + simp only [inScope, Bool.and_eq_true] at h + exact .hint (ih h.2) ((a.hint _ h.1 _).mp typed) + | neg _ op ih => intro h; exact .neg (ih (by simpa [inScope] using h)) op + | binary _ _ op ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true] at h + exact .binary (ih1 h.1) (ih2 h.2) op + | call _ _ ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true, List.contains_iff_mem, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .call (ih1 h.2) (ih2 h.1) + | matchValue _ selected _ ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .matchValue (ih1 h.1) (by rw [← a.select]; exact selected) (ih2 (selected_inScope selected h.2)) + | nil => exact .nil + | cons _ _ ih1 ih2 => + rename_i h + exact .cons (ih1 (h _ (by simp))) (ih2 (fun e he => h e (by simp [he]))) + | intro prepared _ ih => + rename_i hn + exact .intro ((a.prepare _ hn _ _ _ _).mp prepared) (ih (a.closed _ hn _ _ _ _ prepared)) + | returned prepared _ ih => + rename_i hn + exact .returned ((a.prepare _ hn _ _ _ _).mp prepared) (ih (a.closed _ hn _ _ _ _ prepared)) + | exit _ ih => rename_i h; exact .exit (ih (by simpa only [inScope] using h)) + | exitPayload _ ih => rename_i h; exact .exitPayload (ih (by simpa only [inScope] using h)) + | fromBlock different _ ih => rename_i h; exact .fromBlock different (ih (by simpa only [inScope] using h)) + | fromGlobal lookup interpreted _ ih => + rename_i _unused + exact .fromGlobal (by simpa only [← a.constants] using lookup) interpreted (ih (const_inScope _ interpreted)) + | fromTuple _ ih => rename_i h; exact .fromTuple (ih (by simpa [inScope] using h)) + | fromArray _ ih => rename_i h; exact .fromArray (ih (by simpa [inScope] using h)) + | fromRepeat _ ih => rename_i h; exact .fromRepeat (ih (by simpa [inScope] using h)) + | fromIndex _ ih => rename_i h; exact .fromIndex (ih (by simpa [inScope] using h)) + | fromSlice _ ih => rename_i h; exact .fromSlice (ih (by simpa [inScope] using h)) + | fromConstructAs _ ih => rename_i h; exact .fromConstructAs (ih (by simpa [inScope] using h)) + | fromBuiltin _ ih => rename_i h; exact .fromBuiltin (ih (by simpa [inScope] using h)) + | fromUpdate _ ih => rename_i h; exact .fromUpdate (ih (by simpa [inScope] using h)) + | fromRecord _ ih => rename_i h; exact .fromRecord (ih (by simpa [inScope] using h)) + | fromConstruct _ ih => rename_i h; exact .fromConstruct (ih (by simpa [inScope] using h)) + | fromProject _ ih => rename_i h; exact .fromProject (ih (by simpa [inScope] using h)) + | fromMember _ ih => rename_i h; exact .fromMember (ih (by simpa [inScope] using h)) + | fromStore _ ih => rename_i h; exact .fromStore (ih (by simpa [inScope] using h)) + | fromLoad _ ih => rename_i h; exact .fromLoad (ih (by simpa [inScope] using h)) + | fromNeg _ ih => rename_i h; exact .fromNeg (ih (by simpa [inScope] using h)) + | fromLetValue _ ih => + rename_i h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .fromLetValue (ih h.1) + | fromHint _ ih => + rename_i h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .fromHint (ih h.2) + | binaryLeft _ ih => + rename_i h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .binaryLeft (ih h.1) + | fromCall _ ih => + rename_i h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .fromCall (ih h.2) + | fromMatchValue _ ih => + rename_i h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .fromMatchValue (ih h.1) + | letBody _ matched _ ih1 ih2 => + rename_i h + simp only [inScope, Bool.and_eq_true] at h + exact .letBody (ih1 h.1) (by simpa only [← a.patterns] using matched) (ih2 h.2) + | binaryRight _ _ ih1 ih2 => + rename_i h + simp only [inScope, Bool.and_eq_true] at h + exact .binaryRight (ih1 h.1) (ih2 h.2) + | matchBody _ selected _ ih1 ih2 => + rename_i h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .matchBody (ih1 h.1) (by rw [← a.select]; exact selected) (ih2 (selected_inScope selected h.2)) + | head _ ih => rename_i h; exact .head (ih (h _ (by simp))) + | tail _ _ ih1 ih2 => + rename_i h + exact .tail (ih1 (h _ (by simp))) (ih2 (fun e he => h e (by simp [he]))) + +theorem EvalExit.transfer [Field F] [DecidableEq F] + (a : Agreement left right names hintType) + (ev : EvalExit left types locals expr before target result after) : + inScope names hintType types expr = true → EvalExit right types locals expr before target result after := by + induction ev using EvalExit.rec + (motive_1 := fun ts ls e b v h _ => inScope names hintType ts e = true → EvalExpr right ts ls e b v h) + (motive_2 := fun ts ls es b vs h _ => (∀ e ∈ es, inScope names hintType ts e = true) → EvalArgs right ts ls es b vs h) + (motive_3 := fun n xs b v h _ => n ∈ names → EvalFn right n xs b v h) + (motive_5 := fun ts ls es b target v h _ => (∀ e ∈ es, inScope names hintType ts e = true) → EvalArgsExit right ts ls es b target v h) with + | block _ ih => rename_i h; exact .block (ih (by simpa only [inScope] using h)) + | blockExit _ ih => rename_i h; exact .blockExit (ih (by simpa only [inScope] using h)) + | literal => rename_i _unused; exact .literal + | var h => rename_i _unused; exact .var h + | global lookup interpreted _ ih => + rename_i _unused + exact .global (by simpa only [← a.constants] using lookup) interpreted + (ih (const_inScope _ interpreted)) + | tuple _ ih => rename_i h; exact .tuple (ih (by simpa [inScope] using h)) + | array _ ih => rename_i h; exact .array (ih (by simpa [inScope] using h)) + | «repeat» _ ih => rename_i h; exact .repeat (ih (by simpa [inScope] using h)) + | index _ op ih => rename_i h; exact .index (ih (by simpa [inScope] using h)) op + | slice _ op ih => rename_i h; exact .slice (ih (by simpa [inScope] using h)) op + | constructAs _ ih => rename_i h; exact .constructAs (ih (by simpa [inScope] using h)) + | builtin _ op ih => rename_i h; exact .builtin (ih (by simpa [inScope] using h)) op + | update _ op ih => rename_i h; exact .update (ih (by simpa [inScope] using h)) op + | record _ ih => rename_i h; exact .record (ih (by simpa [inScope] using h)) + | construct _ ih => rename_i h; exact .construct (ih (by simpa [inScope] using h)) + | project _ op ih => rename_i h; exact .project (ih (by simpa [inScope] using h)) op + | member _ op ih => rename_i h; exact .member (ih (by simpa [inScope] using h)) op + | letValue _ matched _ ih1 ih2 => + rename_i h + simp only [inScope, Bool.and_eq_true] at h + exact .letValue (ih1 h.1) (by simpa only [← a.patterns] using matched) (ih2 h.2) + | store _ ih => rename_i h; exact .store (ih (by simpa [inScope] using h)) + | load _ op ih => rename_i h; exact .load (ih (by simpa [inScope] using h)) op + | hint _ typed ih => + rename_i h + simp only [inScope, Bool.and_eq_true] at h + exact .hint (ih h.2) ((a.hint _ h.1 _).mp typed) + | neg _ op ih => rename_i h; exact .neg (ih (by simpa [inScope] using h)) op + | binary _ _ op ih1 ih2 => + rename_i h + simp only [inScope, Bool.and_eq_true] at h + exact .binary (ih1 h.1) (ih2 h.2) op + | call _ _ ih1 ih2 => + rename_i h + simp only [inScope, Bool.and_eq_true, List.contains_iff_mem, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .call (ih1 h.2) (ih2 h.1) + | matchValue _ selected _ ih1 ih2 => + rename_i h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .matchValue (ih1 h.1) (by rw [← a.select]; exact selected) (ih2 (selected_inScope selected h.2)) + | nil => exact .nil + | cons _ _ ih1 ih2 => + rename_i h + exact .cons (ih1 (h _ (by simp))) (ih2 (fun e he => h e (by simp [he]))) + | intro prepared _ ih => + rename_i hn + exact .intro ((a.prepare _ hn _ _ _ _).mp prepared) (ih (a.closed _ hn _ _ _ _ prepared)) + | returned prepared _ ih => + rename_i hn + exact .returned ((a.prepare _ hn _ _ _ _).mp prepared) (ih (a.closed _ hn _ _ _ _ prepared)) + | exit _ ih => intro h; exact .exit (ih (by simpa only [inScope] using h)) + | exitPayload _ ih => intro h; exact .exitPayload (ih (by simpa only [inScope] using h)) + | fromBlock different _ ih => intro h; exact .fromBlock different (ih (by simpa only [inScope] using h)) + | fromGlobal lookup interpreted _ ih => + intro _ + exact .fromGlobal (by simpa only [← a.constants] using lookup) interpreted (ih (const_inScope _ interpreted)) + | fromTuple _ ih => intro h; exact .fromTuple (ih (by simpa [inScope] using h)) + | fromArray _ ih => intro h; exact .fromArray (ih (by simpa [inScope] using h)) + | fromRepeat _ ih => intro h; exact .fromRepeat (ih (by simpa [inScope] using h)) + | fromIndex _ ih => intro h; exact .fromIndex (ih (by simpa [inScope] using h)) + | fromSlice _ ih => intro h; exact .fromSlice (ih (by simpa [inScope] using h)) + | fromConstructAs _ ih => intro h; exact .fromConstructAs (ih (by simpa [inScope] using h)) + | fromBuiltin _ ih => intro h; exact .fromBuiltin (ih (by simpa [inScope] using h)) + | fromUpdate _ ih => intro h; exact .fromUpdate (ih (by simpa [inScope] using h)) + | fromRecord _ ih => intro h; exact .fromRecord (ih (by simpa [inScope] using h)) + | fromConstruct _ ih => intro h; exact .fromConstruct (ih (by simpa [inScope] using h)) + | fromProject _ ih => intro h; exact .fromProject (ih (by simpa [inScope] using h)) + | fromMember _ ih => intro h; exact .fromMember (ih (by simpa [inScope] using h)) + | fromStore _ ih => intro h; exact .fromStore (ih (by simpa [inScope] using h)) + | fromLoad _ ih => intro h; exact .fromLoad (ih (by simpa [inScope] using h)) + | fromNeg _ ih => intro h; exact .fromNeg (ih (by simpa [inScope] using h)) + | fromLetValue _ ih => + intro h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .fromLetValue (ih h.1) + | fromHint _ ih => + intro h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .fromHint (ih h.2) + | binaryLeft _ ih => + intro h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .binaryLeft (ih h.1) + | fromCall _ ih => + intro h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .fromCall (ih h.2) + | fromMatchValue _ ih => + intro h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .fromMatchValue (ih h.1) + | letBody _ matched _ ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true] at h + exact .letBody (ih1 h.1) (by simpa only [← a.patterns] using matched) (ih2 h.2) + | binaryRight _ _ ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true] at h + exact .binaryRight (ih1 h.1) (ih2 h.2) + | matchBody _ selected _ ih1 ih2 => + intro h + simp only [inScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at h + exact .matchBody (ih1 h.1) (by rw [← a.select]; exact selected) (ih2 (selected_inScope selected h.2)) + | head _ ih => rename_i h; exact .head (ih (h _ (by simp))) + | tail _ _ ih1 ih2 => + rename_i h + exact .tail (ih1 (h _ (by simp))) (ih2 (fun e he => h e (by simp [he]))) + +theorem EvalFn.transfer [Field F] [DecidableEq F] + (a : Agreement left right names hintType) (hn : n ∈ names) + (ev : EvalFn left n args before result after) : EvalFn right n args before result after := by + cases ev with + | intro prepared body => + exact .intro ((a.prepare _ hn _ _ _ _).mp prepared) + (body.transfer a (a.closed _ hn _ _ _ _ prepared)) + | returned prepared body => + exact .returned ((a.prepare _ hn _ _ _ _).mp prepared) + (body.transfer a (a.closed _ hn _ _ _ _ prepared)) + +theorem evalFn_iff [Field F] [DecidableEq F] + (a : Agreement left right names hintType) (hn : n ∈ names) : + EvalFn left n args before result after ↔ EvalFn right n args before result after := + ⟨EvalFn.transfer a hn, EvalFn.transfer a.symm hn⟩ + +end Aiur.Generic.SourceSemantics diff --git a/Aiur/Aiur/Generic/Specialize.lean b/Aiur/Aiur/Generic/Specialize.lean new file mode 100644 index 000000000..72e2803c0 --- /dev/null +++ b/Aiur/Aiur/Generic/Specialize.lean @@ -0,0 +1,178 @@ +import Aiur.Generic.Preparation +import Aiur.Generic.Equality +import Aiur.Generic.ValueTyping +import Aiur.Generic.Simulation +import Aiur.Generic.SourceSimulation +import Aiur.Generic.LoweringTypes + +namespace Aiur.Generic + +def callableNames (p : Aiur.Program α) : List String := p.functions.map (·.name) ++ p.maps.map (·.name) + +/-- Every condition is a finite syntactic/type check. In particular this does +not ask a validator to decide semantic equivalence. -/ +def Valid [DecidableEq F] (s : Source F) (p : Aiur.Program F) (entries : List String) : Prop := + typecheck p = .ok () ∧ + p.tables = s.tables.tables ∧ p.maps = s.tables.maps ∧ + (∀ n ∈ callableNames p, s.compilerFunction? n = p.findFunction? n) ∧ + (∀ d ∈ p.enums, s.program.enum? d.name = some d) ∧ + closedEnums p.enums ∧ + (∀ fn ∈ p.functions, (∀ param ∈ fn.params, knownType p.enums param.2 = true) ∧ + Engine.inScope (callableNames p) (knownType p.enums) fn.body = true) ∧ + (∀ n ∈ entries, n ∈ callableNames p ∧ s.checkEntry n = .ok () ∧ Aiur.checkEntry p n = .ok ()) + +deriving instance DecidableEq for Aiur.Table + +instance [DecidableEq F] (s : Source F) (p : Aiur.Program F) (entries : List String) : + Decidable (Valid s p entries) := by unfold Valid; infer_instance + +/-- Every source call in every selected instance is in the finite cache. +This check sees source arrays and pointer patterns; it does not lower a body. -/ +def SourceClosed [DecidableEq F] (s : Source F) (p : Aiur.Program F) : Prop := + ∀ n ∈ callableNames p, ((s.program.sourceFunction? n).all fun fn => + SourceSemantics.inScope (callableNames p) (fun _ => true) fn.types fn.body) = true + +instance [DecidableEq F] (s : Source F) (p : Aiur.Program F) : Decidable (SourceClosed s p) := by + unfold SourceClosed + infer_instance + +/-- Source functions and maps must retain the same lookup priority. This is a +finite syntax check, including for manually constructed `Source` values. -/ +def LoweringReady [DecidableEq F] (s : Source F) (p : Aiur.Program F) : Prop := + ∀ n ∈ callableNames p, + (s.program.sourceFunction? n).isSome = (s.compilerFunction? n).isSome + +instance [DecidableEq F] (s : Source F) (p : Aiur.Program F) : Decidable (LoweringReady s p) := by + unfold LoweringReady; infer_instance + +def TypedLowering [DecidableEq F] (s : Source F) (p : Aiur.Program F) : Prop := + ∀ n ∈ callableNames p, ((s.program.sourceFunction? n).all fun fn => + match Preparation.expression s.program (s.program.consts.length + 1) fn.types fn.body with + | .error _ => false + | .ok prepared => match ControlLower.function prepared (fn.params.map Prod.fst) with + | .error _ => false + | .ok body => (body.checkLowerTypes p [] fn.params).isSome) = true + +instance [DecidableEq F] (s : Source F) (p : Aiur.Program F) : Decidable (TypedLowering s p) := by + unfold TypedLowering; infer_instance + +/-- The artifact retains its public entrypoint whitelist. Reachable helpers +are deliberately not made public merely by being present in `program`. -/ +structure Specialized [DecidableEq F] (s : Source F) (entries : List String) where + program : Aiur.Program F + valid : Valid s program entries + sourceClosed : SourceClosed s program + loweringReady : LoweringReady s program + typedLowering : TypedLowering s program + +structure Limits where + instances : Nat := 1024 + enumDepth : Nat := 1024 + deriving Repr + +private structure Collect (F : Type) where + functions : List (Aiur.Function F) := [] + remaining : Nat + +private def visit [DecidableEq F] (s : Source F) : Nat → List Instance → String → StateT (Collect F) (Except String) Unit + | 0, _, _ => throw "function dependency depth limit exceeded" + | fuel + 1, path, name => do + let key ← liftM (Instance.ofSymbol name) + if (s.program.findFunction? key.name).isSome then + if !key.types.all Ty.concrete then throw "cannot specialize an abstract type argument" + if let some ancestor := path.find? (·.name == key.name) then + if ancestor != key then throw s!"recursive call to '{key.name}' changes type arguments" + return + if (← get).functions.any (·.name == name) then return + let fn ← liftM (Preparation.function s.program key) + let state : Collect F ← get + if state.remaining == 0 then throw "function instance limit exceeded" + set ({ functions := state.functions ++ [fn], remaining := state.remaining - 1 } : Collect F) + let some original := s.program.sourceFunction? name | throw "source closure disappeared" + let dependencies := (sourceCalls original.types original.body).map Instance.symbol ++ coreCalls fn.body + for callee in dependencies.eraseDups do visit s fuel (key :: path) callee + else + if !key.types.isEmpty || !(s.program.maps.any (·.name == key.name)) then + throw s!"unknown function or map '{key.name}'" + +/-- Reachability is checked again after collection. Cache reuse on a different +DFS path must not hide a change of recursive type arguments. -/ +private def reachable (p : Aiur.Program F) : Nat → List String → List String → List String + | 0, seen, _ => seen + | fuel + 1, seen, pending => + let fresh := (pending.filter (fun n => !seen.contains n)).eraseDups + if fresh.isEmpty then seen + else reachable p fuel (seen ++ fresh) (fresh.flatMap fun n => + ((p.findFunction? n).map (fun fn => coreCalls fn.body)).getD []) + +private def checkRecursion (p : Aiur.Program F) : Except String Unit := do + for fn in p.functions do + let start ← Instance.ofSymbol fn.name + for name in reachable p (p.functions.length + 2) [] (coreCalls fn.body) do + let key ← Instance.ofSymbol name + if key.name == start.name && key != start then + throw s!"recursive path revisits '{key.name}' with different type arguments" + +def specialize [DecidableEq F] (s : Source F) (entries : List String) (limits : Limits := {}) : + Except String (Specialized s entries) := do + for name in entries do s.checkEntry name + let (_, collected) ← (entries.forM (visit s (s.program.functions.length + 2) [])).run + { remaining := limits.instances } + let names := collected.functions.flatMap fun fn => + ((fn.params.map Prod.snd ++ [fn.result]).flatMap coreTypeNames) ++ coreExprNames fn.body + let enums ← collectEnums s.program [] limits.enumDepth [] (names ++ s.tables.enums.map (·.name)) + let p := { s.tables with functions := collected.functions, enums } + checkRecursion p + -- Recheck after instantiation: enum layouts, pointer-free inputs, maps, and + -- ordinary typing all belong to the existing core checker. + (typecheck p).mapError toString + if valid : Valid s p entries then + if closed : SourceClosed s p then + if ready : LoweringReady s p then + if typed : TypedLowering s p then return ⟨p, valid, closed, ready, typed⟩ + else throw "specialization failed its source-scope typing check" + else throw "specialization changed a source function lookup" + else throw "specialization failed its source dependency check" + else throw "specialization failed its structural certificate check" + +def Specialized.checkEntry [DecidableEq F] {s : Source F} {entries : List String} + (q : Specialized s entries) (name : String) : Except String Unit := + if name ∈ entries then (Aiur.checkEntry q.program name).mapError reprStr + else .error s!"'{name}' is not a selected entrypoint" + +theorem Specialized.checkEntry_iff [DecidableEq F] {s : Source F} {entries : List String} + (q : Specialized s entries) : q.checkEntry name = .ok () ↔ name ∈ entries := by + by_cases selected : name ∈ entries + · have entry := (q.valid.2.2.2.2.2.2.2 name selected).2.2 + simp [Specialized.checkEntry, selected, entry, Except.mapError] + · simp [Specialized.checkEntry, selected] + +def Specialized.coreRun [Field F] [DecidableEq F] {s : Source F} {entries : List String} + (q : Specialized s entries) (name : String) (args : List (SourceValue F)) (fuel : Nat := 1000) + (hints : HintProvider F q.program.enums := HintProvider.unavailable) : Except String (SourceValue F × Heap F) := do + q.checkEntry name + (Aiur.run q.program name args fuel hints).mapError reprStr + +/-- A finite cache of source bodies paired with their concrete type environments. +Array operations and pointer patterns remain present in these bodies. -/ +def Specialized.instances [DecidableEq F] {s : Source F} {entries : List String} + (q : Specialized s entries) : List (String × Option (SourceFunction F)) := + (callableNames q.program).map fun n => (n, s.program.sourceFunction? n) + +def Specialized.world [DecidableEq F] {s : Source F} {entries : List String} + (q : Specialized s entries) : SourceSemantics.World F := + let cache := q.instances + sourceWorld s fun n => (cache.find? (·.1 == n)).bind Prod.snd + +def Specialized.run [Field F] [DecidableEq F] {s : Source F} {entries : List String} + (q : Specialized s entries) (name : String) (args : List (SourceValue F)) (fuel : Nat := 1000) + (hints : s.HintProvider := SourceSemantics.unavailable) : Except String (SourceValue F × Heap F) := do + q.checkEntry name + let (types, locals, body) ← (q.world.prepare name args).mapError reprStr + (SourceSemantics.evalFunctionWith q.world hints types locals fuel body []).mapError reprStr + +def Specialized.EvalCall [Field F] [DecidableEq F] {s : Source F} {entries : List String} + (q : Specialized s entries) (name : String) (args : List (SourceValue F)) (result : SourceValue F) : Prop := + q.checkEntry name = .ok () ∧ ∃ heap, SourceSemantics.EvalFn q.world name args [] result heap + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/StructFacts.lean b/Aiur/Aiur/Generic/StructFacts.lean new file mode 100644 index 000000000..ea3e626c4 --- /dev/null +++ b/Aiur/Aiur/Generic/StructFacts.lean @@ -0,0 +1,159 @@ +import Aiur.Generic.RecordFacts +import Aiur.Generic.OpenCore +import Aiur.Generic.ArrayFacts + +namespace Aiur.Generic.StructLowering +open SourceSemantics +variable [Field F] [DecidableEq F] {world : Engine.World F} {calls : CallRelation F} + +private theorem pureArgs {es : List (Aiur.Expr F)} {vs : List (SourceValue F)} + (rel : List.Forall₂ (fun e v => ∀ b w a, + OpenCore.EvalExpr world calls locals e b w a ↔ w = v ∧ a = b) es vs) : + OpenCore.EvalArgs world calls locals es before values after ↔ values = vs ∧ after = before := by + induction rel generalizing before values with + | nil => constructor <;> intro h + · cases h; exact ⟨rfl, rfl⟩ + · obtain ⟨rfl, rfl⟩ := h; exact .nil + | cons head _ ih => + constructor + · intro h; cases h with + | cons hv rest => + obtain ⟨rfl, rfl⟩ := (head _ _ _).mp hv + obtain ⟨rfl, rfl⟩ := ih.mp rest + exact ⟨rfl, rfl⟩ + · rintro ⟨rfl, rfl⟩ + exact .cons ((head _ _ _).mpr ⟨rfl, rfl⟩) (ih.mpr ⟨rfl, rfl⟩) + +private theorem recordProjects (head : RecordHead) (vs : List (SourceValue F)) : + OpenCore.EvalArgs world calls (("$record", .tuple vs) :: locals) + (head.order ((List.range vs.length).map fun i => .project (.var "$record") i) (.tuple [])) + before values after ↔ values = head.order vs (.tuple []) ∧ after = before := by + apply pureArgs + apply head.order_rel + · apply List.forall₂_of_length_eq_of_get (by simp) + intro i hi hj + simp only [List.get_eq_getElem, List.getElem_map, List.getElem_range] + intro b w a + constructor + · intro ev; cases ev with + | project ev op => + cases ev with + | var found => + simp only [List.find?_cons, beq_self_eq_true, Option.some.injEq, Prod.mk.injEq, true_and] at found + cases found + simpa [projectValue, List.getElem?_eq_getElem hj, pure, Except.pure] using op.symm + · rintro ⟨rfl, rfl⟩ + exact .project (input := .tuple vs) (.var (by simp)) (by simp [projectValue, List.getElem?_eq_getElem hj]) + · intro b w a + constructor + · intro ev; cases ev with + | tuple es => cases es; exact ⟨rfl, rfl⟩ + · rintro ⟨rfl, rfl⟩; exact .tuple .nil + +/-- Construction runs the written initializer sequence exactly once, then only rearranges values. -/ +theorem record_iff {items : List (Aiur.Expr F)} : + OpenCore.EvalExpr world calls locals (record types head items) before result after ↔ + ∃ values, OpenCore.EvalArgs world calls locals items before values after ∧ + result = .construct (constructorName types head.type) structConstructor (head.order values (.tuple [])) := by + have lengths {es : List (Aiur.Expr F)} {vs b a} + (ev : OpenCore.EvalArgs world calls locals es b vs a) : es.length = vs.length := by + induction es generalizing vs b with + | nil => cases ev; rfl + | cons e es ih => cases ev with + | cons _ rest => simp only [List.length_cons, ih rest] + constructor + · intro ev + cases ev with + | letValue operand matched body => + cases operand with + | tuple args => + simp only [Aiur.Pattern.bindings, Option.some.injEq] at matched + subst_vars + cases body with + | construct fields => + rw [lengths args] at fields + obtain ⟨rfl, rfl⟩ := (recordProjects head _).mp fields + exact ⟨_, args, rfl⟩ + · rintro ⟨values, args, rfl⟩ + apply OpenCore.EvalExpr.letValue (bindings := [("$record", .tuple values)]) (.tuple args) + (by simp [Aiur.Pattern.bindings]) + apply OpenCore.EvalExpr.construct + rw [lengths args] + exact (recordProjects head values).mpr ⟨rfl, rfl⟩ + +private theorem wildcard_bindings (n : Nat) (values : List (SourceValue F)) : + Aiur.Pattern.bindingsList (List.replicate n (.wildcard : Aiur.Pattern F)) values = + if values.length = n then some [] else none := by + induction n generalizing values with + | zero => cases values <;> simp [Aiur.Pattern.bindingsList] + | succ n ih => + cases values with + | nil => simp [Aiur.Pattern.bindingsList] + | cons v vs => + by_cases h : vs.length = n <;> + simp [List.replicate_succ, Aiur.Pattern.bindingsList, Aiur.Pattern.bindings, ih, h] + +private theorem fieldPatterns_bindings (count index : Nat) (bound : index < count) + (values : List (SourceValue F)) : + Aiur.Pattern.bindingsList (fieldPatterns count index) values = + if values.length = count then values[index]?.map (fun v => [("$member", v)]) else none := by + induction count generalizing index values with + | zero => omega + | succ n ih => + cases index with + | zero => + cases values with + | nil => simp [fieldPatterns, Aiur.Pattern.bindingsList] + | cons v vs => + simp only [fieldPatterns, Aiur.Pattern.bindingsList, Aiur.Pattern.bindings, wildcard_bindings] + by_cases h : vs.length = n <;> simp [h] + | succ i => + cases values with + | nil => simp [fieldPatterns, Aiur.Pattern.bindingsList] + | cons v vs => + simp only [fieldPatterns, Aiur.Pattern.bindingsList, Aiur.Pattern.bindings, ih i (by omega)] + by_cases h : vs.length = n <;> simp [h] + +private theorem field_bindings (field : FieldRef) (bound : field.index < field.arity) + (types : Types) (value : SourceValue F) (bindings : Environment F Nat) : + (fieldPattern (field.subst types)).bindings value = some bindings ↔ + ∃ result, memberValue types field value = .ok result ∧ bindings = [("$member", result)] := by + have name : nominalName [] ((field.owner.map (Ty.subst types)).getD (.named "$invalid" [])) = + constructorName types (field.owner.getD (.named "$invalid" [])) := by + cases field.owner <;> simp [nominalName, constructorName, Ty.subst_nil, Ty.subst] <;> rfl + cases value <;> simp only [fieldPattern, FieldRef.subst, Aiur.Pattern.bindings, + memberValue, name, fieldPatterns_bindings _ _ bound] + all_goals try simp [bind, Except.bind] + rename_i n c vs + by_cases hn : n = constructorName types (field.owner.getD (.named "$invalid" [])) + · subst n + by_cases hc : c = structConstructor + · subst c + by_cases hl : vs.length = field.arity + · have hi : field.index < vs.length := by omega + simp [hl, List.getElem?_eq_getElem hi, pure, Except.pure, eq_comm] + · simp [hl, pure, Except.pure, bind, Except.bind] + · simp [hc, Ne.symm hc, pure, Except.pure, bind, Except.bind] + · simp [hn, Ne.symm hn, pure, Except.pure, bind, Except.bind] + +/-- A named projection is exactly one operand evaluation followed by a nominal field read. -/ +theorem member_iff (bound : field.index < field.arity) : + OpenCore.EvalExpr world calls locals (member types operand field) before result after ↔ + ∃ value, OpenCore.EvalExpr world calls locals operand before value after ∧ + memberValue types field value = .ok result := by + constructor + · intro ev + cases ev with + | letValue operand matched body => + obtain ⟨value, op, rfl⟩ := (field_bindings field bound _ _ _).mp matched + cases body with + | var found => + simp only [List.cons_append, List.nil_append, List.find?_cons, beq_self_eq_true, + Option.some.injEq, Prod.mk.injEq, true_and] at found + cases found + exact ⟨_, operand, op⟩ + · rintro ⟨value, operand, op⟩ + exact .letValue (bindings := [("$member", result)]) operand + ((field_bindings field bound _ _ _).mpr ⟨result, op, rfl⟩) (.var (by simp)) + +end Aiur.Generic.StructLowering diff --git a/Aiur/Aiur/Generic/TraceEval.lean b/Aiur/Aiur/Generic/TraceEval.lean new file mode 100644 index 000000000..f191c2c0e --- /dev/null +++ b/Aiur/Aiur/Generic/TraceEval.lean @@ -0,0 +1,105 @@ +import Aiur.Generic.ControlEval + +namespace Aiur.Generic + +/-- Diagnostic values are observed, never fed back into Aiur computation. A +missing leave event identifies the active call stack when execution fails. -/ +inductive TraceEvent (F : Type) where + | message (text : String) (values : List (SourceValue F)) + | enter (function : String) (arguments : List (SourceValue F)) + | leave (function : String) (result : SourceValue F) + deriving Repr, BEq + +namespace Traced +open SourceSemantics + +/-- Trace state is below failure, so earlier messages survive a failed load, +assertion, hint, or fuel limit. Entries are accumulated in reverse order. -/ +abbrev Eval (F : Type) := StateT (Heap F) (ExceptT EvalError (StateM (List (TraceEvent F)))) +abbrev Flow (F : Type) := ExceptT (ExitTarget × SourceValue F) (Eval F) + +def emit (event : TraceEvent F) : Flow F Unit := + fun heap events => (.ok (.ok (), heap), event :: events) + +def error (err : EvalError) : Flow F A := ExceptT.mk (throw err) + +def catchExit (target : ExitTarget) (body : Flow F (SourceValue F)) : Flow F (SourceValue F) := ExceptT.mk do + return Outcome.catch target (← body.run) + +def finishFunction (body : Flow F (SourceValue F)) : Eval F (SourceValue F) := do + match ← (catchExit .function body).run with + | .ok value => return value + | .error (target, _) => throw (.unhandledExit (reprStr target)) + +def evalWithTrace [Field F] [DecidableEq F] (world : World F) (hints : SourceSemantics.HintProvider world) + (types : Types) (locals : Environment F Nat) : Nat → Expr F → Flow F (SourceValue F) + | 0, _ => error .outOfFuel + | fuel + 1, expr => do + match expr with + | .control (.block label) body => + catchExit (.block label) (evalWithTrace world hints types locals fuel body) + | .control (.exit target) value => + let value ← evalWithTrace world hints types locals fuel value + throw (target, value) + | .literal x => return .field x + | .var name => + let some (_, value) := locals.find? (·.1 == name) | error (.unboundVariable name) + return value + | .global name annotation => + let some type := annotation | error (.unboundVariable ("::" ++ name)) + let pattern ← liftM (world.constant name (type.subst types)) + let body ← liftM ((Consts.toExpr pattern).mapError (fun _ => EvalError.unboundVariable ("::" ++ name))) + evalWithTrace world hints [] [] fuel body + | .tuple items | .array items => return .tuple (← items.mapM (evalWithTrace world hints types locals fuel)) + | .repeat value n => return .tuple (List.replicate n (← evalWithTrace world hints types locals fuel value)) + | .index value i | .project value i => liftM (projectValue (← evalWithTrace world hints types locals fuel value) i) + | .slice value start stop => liftM (sliceValue (← evalWithTrace world hints types locals fuel value) start stop) + | .builtin op items => + let values ← items.mapM (evalWithTrace world hints types locals fuel) + if let .debug message := op then emit (.message message values) + liftM (op.apply values) + | .update paths items => + liftM (Update.value types paths (← items.mapM (evalWithTrace world hints types locals fuel))) + | .record head items => + let values ← items.mapM (evalWithTrace world hints types locals fuel) + return .construct (constructorName types head.type) structConstructor (head.order values (.tuple [])) + | .member value field => liftM (memberValue types field (← evalWithTrace world hints types locals fuel value)) + | .construct name args ctor items => + return .construct (instanceName types name args) ctor (← items.mapM (evalWithTrace world hints types locals fuel)) + | .constructAs _ t ctor items => + return .construct (constructorName types t) ctor (← items.mapM (evalWithTrace world hints types locals fuel)) + | .letValue pattern value body => + let value ← evalWithTrace world hints types locals fuel value + let some bindings ← liftM (world.matchPattern types (← get) pattern value) | error .patternMismatch + evalWithTrace world hints types (bindings ++ locals) fuel body + | .store value => + let value ← evalWithTrace world hints types locals fuel value + let heap ← get + set (heap ++ [value]) + return .ptr value.type heap.length + | .load pointer => + let pointer ← evalWithTrace world hints types locals fuel pointer + liftM (loadValue (← get) pointer) + | .hint t key channel => + let key ← evalWithTrace world hints types locals fuel key + let value ← liftM ((hints channel key (t.subst types).toCore).mapError EvalError.hint) + return value.val.toValue + | .neg value => liftM (evalNeg (← evalWithTrace world hints types locals fuel value)) + | .binary op left right => + liftM (evalBinOp op (← evalWithTrace world hints types locals fuel left) + (← evalWithTrace world hints types locals fuel right)) + | .call name args inputs => + let values ← inputs.mapM (evalWithTrace world hints types locals fuel) + let callee := instanceName types name args + emit (.enter callee values) + let (calleeTypes, bindings, body) ← liftM (world.prepare callee values) + let result ← liftM (finishFunction (evalWithTrace world hints calleeTypes bindings fuel body)) + emit (.leave callee result) + return result + | .matchValue scrutinee arms => + let value ← evalWithTrace world hints types locals fuel scrutinee + let some (bindings, body) ← liftM (SourceSemantics.selectArm world types (← get) value arms) | error .noMatchingArm + evalWithTrace world hints types (bindings ++ locals) fuel body + +end Traced +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/TraceFacts.lean b/Aiur/Aiur/Generic/TraceFacts.lean new file mode 100644 index 000000000..02e8fd0bd --- /dev/null +++ b/Aiur/Aiur/Generic/TraceFacts.lean @@ -0,0 +1,187 @@ +import Aiur.Generic.TraceEval +import Aiur.Generic.ControlEvalSpec + +namespace Aiur.Generic.Traced +open SourceSemantics + +def Agrees (traced : Eval F A) (plain : Evaluation F A) : Prop := + ∀ heap events, (traced heap events).1 = plain heap + +theorem agrees_pure (value : A) : Agrees (pure value : Eval F A) (pure value) := by + intro heap events; rfl + +theorem agrees_bind {first : Eval F A} {first' : Evaluation F A} + {next : A → Eval F B} {next' : A → Evaluation F B} + (head : Agrees first first') (tail : ∀ value, Agrees (next value) (next' value)) : + Agrees (first >>= next) (first' >>= next') := by + intro heap events + have h := head heap events + cases run : first heap events with + | mk outcome trace => + rw [run] at h + cases outcome with + | error err => + simp only [bind, StateT.bind, ExceptT.bind, ExceptT.bindCont, ExceptT.mk, + ExceptT.run, pure, StateT.pure, Except.pure, Except.bind, run, ← h] + | ok pair => + rcases pair with ⟨value, middle⟩ + simpa only [bind, StateT.bind, ExceptT.bind, ExceptT.bindCont, ExceptT.mk, + ExceptT.run, pure, StateT.pure, Except.pure, Except.bind, run, ← h] using tail value middle trace + +theorem agrees_lift (action : Except EvalError A) : + Agrees (liftM action : Eval F A) (liftM action) := by + intro heap events; cases action <;> rfl + +theorem agrees_get : Agrees (get : Eval F (Heap F)) get := by intro heap events; rfl +theorem agrees_set (heap : Heap F) : Agrees (set heap : Eval F Unit) (set heap) := by intro heap events; rfl +theorem agrees_throw (err : EvalError) : Agrees (throw err : Eval F A) (throw err) := by intro heap events; rfl + +abbrev FlowAgrees (traced : Flow F A) (plain : FlowEvaluation F A) := Agrees traced.run plain.run + +theorem flow_pure (value : A) : FlowAgrees (pure value : Flow F A) (pure value) := agrees_pure _ +theorem flow_throw (exit : ExitTarget × SourceValue F) : + FlowAgrees (throw exit : Flow F A) (throw exit) := agrees_pure _ + +theorem flow_bind {first : Flow F A} {first' : FlowEvaluation F A} + {next : A → Flow F B} {next' : A → FlowEvaluation F B} + (head : FlowAgrees first first') (tail : ∀ value, FlowAgrees (next value) (next' value)) : + FlowAgrees (first >>= next) (first' >>= next') := by + apply agrees_bind head + intro outcome + cases outcome with + | error exit => exact agrees_pure _ + | ok value => exact tail value + +theorem flow_lift_eval {action : Eval F A} {plain : Evaluation F A} (h : Agrees action plain) : + FlowAgrees (liftM action : Flow F A) (liftM plain) := + agrees_bind h (fun value => agrees_pure _) + +theorem flow_lift (action : Except EvalError A) : + FlowAgrees (liftM action : Flow F A) (liftM action) := + flow_lift_eval (agrees_lift action) + +theorem flow_error (err : EvalError) : FlowAgrees (error err : Flow F A) (flowError err) := agrees_throw _ +theorem flow_get : FlowAgrees (get : Flow F (Heap F)) get := flow_lift_eval agrees_get +theorem flow_set (heap : Heap F) : FlowAgrees (set heap : Flow F Unit) (set heap) := flow_lift_eval (agrees_set heap) +theorem flow_emit (event : TraceEvent F) : FlowAgrees (emit event) (pure ()) := by intro heap events; rfl + +theorem flow_catch {body : Flow F (SourceValue F)} {plain : FlowEvaluation F (SourceValue F)} + (h : FlowAgrees body plain) : FlowAgrees (catchExit target body) (SourceSemantics.catchExit target plain) := + agrees_bind h (fun value => agrees_pure _) + +theorem agrees_finish {body : Flow F (SourceValue F)} {plain : FlowEvaluation F (SourceValue F)} + (h : FlowAgrees body plain) : Agrees (finishFunction body) (SourceSemantics.finishFunction plain) := by + apply agrees_bind (flow_catch h) + intro outcome + cases outcome with + | ok value => exact agrees_pure _ + | error exit => exact agrees_throw _ + +theorem flow_mapM {traced : A → Flow F B} {plain : A → FlowEvaluation F B} + (same : ∀ value, FlowAgrees (traced value) (plain value)) (values : List A) : + FlowAgrees (values.mapM traced) (values.mapM plain) := by + induction values with + | nil => exact flow_pure _ + | cons value values ih => + simp only [List.mapM_cons] + exact flow_bind (same value) (fun v => flow_bind ih (fun vs => flow_pure _)) + +theorem emit_then {traced : Flow F A} {plain : FlowEvaluation F A} + (event : TraceEvent F) (h : FlowAgrees traced plain) : + FlowAgrees (emit event >>= fun _ => traced) plain := by + simpa only [pure_bind] using flow_bind (flow_emit event) (fun _ => h) + +/-- Instrumentation preserves the complete result, including errors and fuel +exhaustion, for every initial trace. It does not call a hint provider twice. -/ +theorem eval_agrees [Field F] [DecidableEq F] (world : World F) + (hints : SourceSemantics.HintProvider world) (types locals fuel expr) : + FlowAgrees (evalWithTrace world hints types locals fuel expr) + (evalOutcomeWith world hints types locals fuel expr) := by + induction fuel generalizing types locals expr with + | zero => exact flow_error _ + | succ fuel ih => + have args (types locals) (items : List (Expr F)) := + flow_mapM (fun expr => ih types locals expr) items + cases expr with + | control kind body => + cases kind with + | block label => exact flow_catch (ih _ _ _) + | exit target => exact flow_bind (ih _ _ _) (fun value => flow_throw _) + | literal value => exact flow_pure _ + | var name => + simp only [evalWithTrace, evalOutcomeWith] + cases locals.find? (·.1 == name) with + | none => exact flow_error _ + | some pair => exact flow_pure _ + | global name annotation => + simp only [evalWithTrace, evalOutcomeWith] + cases annotation with + | none => exact flow_error _ + | some type => + apply flow_bind (flow_lift _) + intro pattern + exact flow_bind (flow_lift _) (fun body => ih _ _ _) + | tuple items | array items => exact flow_bind (args _ _ _) (fun values => flow_pure _) + | «repeat» value n => exact flow_bind (ih _ _ _) (fun value => flow_pure _) + | index value i | project value i | slice value start stop | member value field | neg value => + exact flow_bind (ih _ _ _) (fun value => flow_lift _) + | builtin op items => + apply flow_bind (args _ _ _) + intro values + cases op with + | assertEq message => simpa only [pure_bind] using (flow_lift (Builtin.apply (.assertEq message) values)) + | ascribe t => simpa only [pure_bind] using (flow_lift (Builtin.apply (.ascribe t) values)) + | debug message => exact emit_then _ (flow_lift _) + | update paths items => exact flow_bind (args _ _ _) (fun values => flow_lift _) + | record head items | construct name typeArgs ctor items | constructAs params t ctor items => + exact flow_bind (args _ _ _) (fun values => flow_pure _) + | letValue pattern value body => + apply flow_bind (ih _ _ _) + intro value + apply flow_bind flow_get + intro heap + apply flow_bind (flow_lift _) + intro matched + cases matched with + | none => exact flow_error _ + | some bindings => exact ih _ _ _ + | store value => + apply flow_bind (ih _ _ _) + intro value + apply flow_bind flow_get + intro heap + exact flow_bind (flow_set _) (fun _ => flow_pure _) + | load value => + apply flow_bind (ih _ _ _) + intro value + exact flow_bind flow_get (fun heap => flow_lift _) + | hint type key channel => + apply flow_bind (ih _ _ _) + intro value + exact flow_bind (flow_lift _) (fun value => flow_pure _) + | binary op left right => + apply flow_bind (ih _ _ _) + intro left + exact flow_bind (ih _ _ _) (fun right => flow_lift _) + | call name typeArgs inputs => + apply flow_bind (args _ _ _) + intro values + apply emit_then + apply flow_bind (flow_lift _) + intro (calleeTypes, bindings, body) + have same := flow_lift_eval (agrees_finish (ih calleeTypes bindings body)) + have finished := flow_bind same (fun result => emit_then + (.leave (instanceName types name typeArgs) result) (flow_pure result)) + simpa only [bind_pure] using finished + | matchValue value arms => + apply flow_bind (ih _ _ _) + intro value + apply flow_bind flow_get + intro heap + apply flow_bind (flow_lift _) + intro matched + cases matched with + | none => exact flow_error _ + | some pair => exact ih _ _ _ + +end Aiur.Generic.Traced diff --git a/Aiur/Aiur/Generic/TypeFacts.lean b/Aiur/Aiur/Generic/TypeFacts.lean new file mode 100644 index 000000000..4a278dbb3 --- /dev/null +++ b/Aiur/Aiur/Generic/TypeFacts.lean @@ -0,0 +1,23 @@ +import Aiur.Generic.AST + +namespace Aiur.Generic + +@[simp] theorem Ty.subst_nil (type : Ty) : type.subst [] = type := by + have sub (t : Ty) (smaller : sizeOf t < sizeOf type) : t.subst [] = t := + Ty.subst_nil t + cases type with + | field | param => simp [Ty.subst] + | ptr t | array t n => simp only [Ty.subst, sub t (by simp_wf <;> omega)] + | tuple ts | named n ts => + have items : ts.map (Ty.subst []) = ts := by + calc + ts.map (Ty.subst []) = ts.map id := by + apply List.map_congr_left + intro t ht + exact sub t (by simp_wf; have := List.sizeOf_lt_of_mem ht; omega) + _ = ts := List.map_id ts + simp only [Ty.subst, items] +termination_by sizeOf type +decreasing_by exact smaller + +end Aiur.Generic diff --git a/Aiur/Aiur/Generic/Update.lean b/Aiur/Aiur/Generic/Update.lean new file mode 100644 index 000000000..f649cdca7 --- /dev/null +++ b/Aiur/Aiur/Generic/Update.lean @@ -0,0 +1,49 @@ +import Aiur.Generic.AST +import Aiur.Eval + +namespace Aiur.Generic.Update + +abbrev Types := List (String × Ty) + +def nominalName (types : Types) (type : Ty) : String := + match (type.subst types).toCore with | .enum name => name | _ => "$invalid" + +def pack (types : Types) (step : UpdateStep) (values : List (SourceValue F)) : SourceValue F := + match step.owner with + | none => .tuple values + | some type => .construct (nominalName types type) structConstructor values + +/-- Inspect a product value without following pointers. -/ +def unpack (types : Types) (step : UpdateStep) (value : SourceValue F) : Option (List (SourceValue F)) := + match step.owner, value with + | none, .tuple values => if values.length = step.width then some values else none + | some type, .construct name ctor values => + if name == nominalName types type && ctor == structConstructor && values.length == step.width then some values else none + | _, _ => none + +/-- Replace one statically selected descendant. All other components retain + their values, including opaque pointer identities. -/ +def replace (types : Types) : UpdatePath → SourceValue F → SourceValue F → Option (SourceValue F) + | [], _, replacement => some replacement + | step :: path, base, replacement => do + let values ← unpack types step base + let values ← values.zipIdx.mapM fun (value, index) => + if index == step.position then replace types path value replacement else some value + return pack types step values + +def apply (types : Types) : List UpdatePath → SourceValue F → List (SourceValue F) → Option (SourceValue F) + | [], base, [] => some base + | path :: paths, base, replacement :: rest => do + let base ← replace types path base replacement + apply types paths base rest + | _, _, _ => none + +/-- The operands have already been evaluated: base first, then every written + replacement. This operation performs no allocation and no heap access. -/ +def value (types : Types) (paths : List UpdatePath) : List (SourceValue F) → Except EvalError (SourceValue F) + | [] => .error .patternMismatch + | base :: replacements => match apply types paths base replacements with + | some result => .ok result + | none => .error .patternMismatch + +end Aiur.Generic.Update diff --git a/Aiur/Aiur/Generic/UpdateFacts.lean b/Aiur/Aiur/Generic/UpdateFacts.lean new file mode 100644 index 000000000..d4a5ba1f0 --- /dev/null +++ b/Aiur/Aiur/Generic/UpdateFacts.lean @@ -0,0 +1,308 @@ +import Aiur.Generic.StructFacts +import Aiur.Generic.UpdateSubstitution + +namespace Aiur.Generic.UpdateLowering +open SourceSemantics +variable [Field F] [DecidableEq F] {world : Engine.World F} {calls : CallRelation F} + +private theorem variable_iff (found : locals.find? (·.1 == name) = some (name, value)) : + OpenCore.EvalExpr world calls locals (.var name) before result after ↔ result = value ∧ after = before := by + constructor + · intro ev; cases ev with + | var lookup => rw [found] at lookup; cases lookup; exact ⟨rfl, rfl⟩ + · rintro ⟨rfl, rfl⟩; exact .var found + +private theorem let_bind : + OpenCore.EvalExpr world calls locals (.letValue (.bind name) input body) before result after ↔ + ∃ value middle, OpenCore.EvalExpr world calls locals input before value middle ∧ + OpenCore.EvalExpr world calls ((name, value) :: locals) body middle result after := by + constructor + · intro ev; cases ev with + | letValue operand matched rest => + simp only [Aiur.Pattern.bindings, Option.some.injEq] at matched + subst matched + exact ⟨_, _, operand, rest⟩ + · rintro ⟨value, middle, operand, body⟩ + exact .letValue (bindings := [(name, value)]) operand (by simp [Aiur.Pattern.bindings]) body + +private theorem wildcards (n : Nat) (values : List (SourceValue F)) : + Aiur.Pattern.bindingsList (List.replicate n (.wildcard : Aiur.Pattern F)) values = + if values.length = n then some [] else none := by + induction n generalizing values with + | zero => cases values <;> simp [Aiur.Pattern.bindingsList] + | succ n ih => + cases values with + | nil => simp [Aiur.Pattern.bindingsList] + | cons v vs => + by_cases h : vs.length = n <;> + simp [List.replicate_succ, Aiur.Pattern.bindingsList, Aiur.Pattern.bindings, ih, h] + +private theorem shape_bindings (types : Types) (step : UpdateStep) (input : SourceValue F) : + (shape types step).bindings input = (Update.unpack types step input).map (fun _ => []) := by + cases owner : step.owner <;> cases input <;> + simp [shape, Update.unpack, owner, Aiur.Pattern.bindings, wildcards, + Update.nominalName, StructLowering.nominalName] + all_goals split_ifs <;> simp_all [eq_comm] + all_goals exact absurd rfl (by assumption) + +private theorem unpack_spec (types : Types) (step : UpdateStep) (input : SourceValue F) (values : List (SourceValue F)) : + Update.unpack types step input = some values ↔ + input = Update.pack types step values ∧ values.length = step.width := by + cases owner : step.owner <;> cases input <;> + simp [Update.unpack, Update.pack, owner] + all_goals aesop + +private theorem product_iff : + OpenCore.EvalExpr world calls locals (product types step es) before result after ↔ + ∃ values, OpenCore.EvalArgs world calls locals es before values after ∧ result = Update.pack types step values := by + cases owner : step.owner <;> simp only [product, Update.pack, owner] + all_goals constructor + all_goals first + | (intro ev; cases ev; exact ⟨_, by assumption, rfl⟩) + | (rintro ⟨values, ev, rfl⟩; first | exact .tuple ev | exact .construct ev) + +private theorem component_iff + (found : locals.find? (·.1 == "$withBase") = some ("$withBase", input)) + (unpacked : Update.unpack types step input = some values) + (bound : index < step.width) : + OpenCore.EvalExpr world calls locals (component types step index) before result after ↔ + values[index]? = some result ∧ after = before := by + obtain ⟨rfl, length⟩ := (unpack_spec types step input values).mp unpacked + cases owner : step.owner with + | none => + simp only [component, owner] + constructor + · intro ev; cases ev with + | project ev op => + obtain ⟨rfl, rfl⟩ := (variable_iff found).mp ev + simpa [Update.pack, owner, projectValue, List.getElem?_eq_getElem (by omega : index < values.length)] using op + · rintro ⟨h, rfl⟩ + exact .project (.var found) (by simp [Update.pack, owner, projectValue, h]) + | some type => + simp only [component, owner] + rw [StructLowering.member_iff bound] + simp only [variable_iff found] + simp [memberValue, Update.pack, owner, constructorName, Update.nominalName, length, + List.getElem?_eq_getElem (by omega : index < values.length)] + cases ht : (type.subst types).toCore <;> simp [ht, and_comm] + +private theorem args_mapM {es : List (Aiur.Expr F)} {xs : List A} {run : A → Option (SourceValue F)} + (related : List.Forall₂ (fun e x => ∀ b v a, + OpenCore.EvalExpr world calls locals e b v a ↔ run x = some v ∧ a = b) es xs) : + OpenCore.EvalArgs world calls locals es before values after ↔ xs.mapM run = some values ∧ after = before := by + induction related generalizing before values with + | nil => constructor + · intro ev; cases ev; exact ⟨rfl, rfl⟩ + · rintro ⟨h, rfl⟩; cases h; exact .nil + | cons head _ ih => + constructor + · intro ev; cases ev with + | cons one rest => + obtain ⟨h, rfl⟩ := (head _ _ _).mp one + obtain ⟨hs, rfl⟩ := ih.mp rest + exact ⟨by simp [List.mapM_cons, h, hs], rfl⟩ + · rintro ⟨mapped, rfl⟩ + simp only [List.mapM_cons, bind, Option.bind_eq_some_iff, Option.pure_def, Option.some.injEq] at mapped + obtain ⟨v, hv, vs, hvs, same⟩ := mapped + cases same + exact .cons ((head _ _ _).mpr ⟨hv, rfl⟩) (ih.mpr ⟨hvs, rfl⟩) + +/-- A path rebuilds precisely the selected component, preserving the operand's +heap and the identity of every untouched pointer. -/ +theorem path_iff (target : UpdatePath) + (newFound : locals.find? (·.1 == "$withNew") = some ("$withNew", replacement)) : + OpenCore.EvalExpr world calls locals (path types target input) before result after ↔ + ∃ base, OpenCore.EvalExpr world calls locals input before base after ∧ + Update.replace types target base replacement = some result := by + induction target generalizing locals input before result after with + | nil => + simp only [path, Update.replace, Option.some.injEq] + constructor + · intro ev; cases ev with + | letValue operand matched body => + simp only [Aiur.Pattern.bindings, Option.some.injEq] at matched + subst matched + obtain ⟨rfl, rfl⟩ := (variable_iff newFound).mp body + exact ⟨_, operand, rfl⟩ + · rintro ⟨base, operand, rfl⟩ + exact .letValue (bindings := []) operand (by simp [Aiur.Pattern.bindings]) (.var newFound) + | cons step rest ih => + have fields (base : SourceValue F) (parts : List (SourceValue F)) + (unpacked : Update.unpack types step base = some parts) (b w a) : + OpenCore.EvalArgs world calls (("$withBase", base) :: locals) + ((List.range step.width).map fun i => + if i == step.position then path types rest (component types step i) else component types step i) b w a ↔ + (parts.zipIdx.mapM fun (v, i) => + if i == step.position then Update.replace types rest v replacement else some v) = some w ∧ a = b := by + apply args_mapM + apply List.forall₂_of_length_eq_of_get + · simp [(unpack_spec types step base parts).mp unpacked |>.2] + · intro i hi hv b w a + have length := ((unpack_spec types step base parts).mp unpacked).2 + have bound : i < step.width := by simpa using hi + have partBound : i < parts.length := by omega + simp only [List.get_eq_getElem, List.getElem_map, List.getElem_range, List.getElem_zipIdx, Nat.zero_add] + by_cases chosen : i == step.position + · simp only [chosen, ↓reduceIte] + rw [ih (locals := ("$withBase", base) :: locals) (by simpa using newFound)] + simp only [component_iff (locals := ("$withBase", base) :: locals) (input := base) (by simp) unpacked bound, + List.getElem?_eq_getElem partBound, Option.some.injEq] + constructor + · rintro ⟨v, ⟨rfl, rfl⟩, h⟩; exact ⟨h, rfl⟩ + · rintro ⟨h, rfl⟩; exact ⟨_, ⟨rfl, rfl⟩, h⟩ + · simpa [chosen, List.getElem?_eq_getElem partBound, eq_comm] using + (component_iff (world := world) (calls := calls) (before := b) (after := a) (result := w) + (by simp : (("$withBase", base) :: locals).find? (·.1 == "$withBase") = some ("$withBase", base)) unpacked bound) + rw [path, let_bind] + constructor + · rintro ⟨base, middle, operand, body⟩ + cases body with + | letValue inspected matched reconstructed => + obtain ⟨rfl, rfl⟩ := (variable_iff (value := base) (by simp)).mp inspected + rw [shape_bindings] at matched + obtain ⟨parts, unpacked, rfl⟩ := Option.map_eq_some_iff.mp matched + obtain ⟨values, ev, rfl⟩ := product_iff.mp reconstructed + obtain ⟨mapped, rfl⟩ := (fields _ parts unpacked _ _ _).mp ev + exact ⟨_, operand, by simp only [Update.replace, unpacked, bind, Option.bind_some, mapped, Option.pure_def]⟩ + · rintro ⟨base, operand, updated⟩ + simp only [Update.replace, bind, Option.bind_eq_some_iff, Option.pure_def, Option.some.injEq] at updated + obtain ⟨parts, unpacked, values, mapped, same⟩ := updated + subst result + refine ⟨base, after, operand, ?_⟩ + apply OpenCore.EvalExpr.letValue (input := base) (bindings := []) (.var (by simp)) + · rw [shape_bindings, unpacked]; rfl + · apply product_iff.mpr + exact ⟨values, (fields base parts unpacked _ _ _).mpr ⟨mapped, rfl⟩, rfl⟩ + +private theorem project_variable + (found : locals.find? (·.1 == name) = some (name, .tuple values)) : + OpenCore.EvalExpr world calls locals (.project (.var name) index) before result after ↔ + values[index]? = some result ∧ after = before := by + constructor + · intro ev; cases ev with + | project operand projected => + obtain ⟨rfl, rfl⟩ := (variable_iff found).mp operand + cases h : values[index]? <;> simp [projectValue, h] at projected + subst projected + exact ⟨rfl, rfl⟩ + · rintro ⟨h, rfl⟩ + exact .project (.var found) (by simp [projectValue, h]) + +private theorem sequence_iff (paths : List UpdatePath) + (inputFound : locals.find? (·.1 == "$withInputs") = some ("$withInputs", .tuple inputs)) + (currentFound : locals.find? (·.1 == "$withCurrent") = some ("$withCurrent", base)) + (length : (inputs.drop index).length = paths.length) : + OpenCore.EvalExpr world calls locals (sequence types paths index) before result after ↔ + Update.apply types paths base (inputs.drop index) = some result ∧ after = before := by + induction paths generalizing locals index base with + | nil => + have empty : inputs.drop index = [] := List.length_eq_zero_iff.mp length + simp only [sequence, variable_iff currentFound, empty, Update.apply, Option.some.injEq, eq_comm] + | cons target targets ih => + cases dropped : inputs.drop index with + | nil => simp [dropped] at length + | cons replacement replacements => + have atIndex : inputs[index]? = some replacement := by + have h := congrArg (fun xs => xs[0]?) dropped + simpa using h + have nextDrop : inputs.drop (index + 1) = replacements := by + rw [← List.drop_drop, dropped]; rfl + have nextLength : (inputs.drop (index + 1)).length = targets.length := by + simp [nextDrop, dropped] at length ⊢ + exact length + rw [sequence, let_bind] + constructor + · rintro ⟨newValue, middle, operand, body⟩ + obtain ⟨atNew, rfl⟩ := (project_variable inputFound).mp operand + have same : newValue = replacement := by rw [atIndex] at atNew; exact (Option.some.inj atNew).symm + subst newValue + obtain ⟨nextValue, finalHeap, changed, continued⟩ := let_bind.mp body + obtain ⟨oldValue, original, updated⟩ := (path_iff target (replacement := replacement) (by simp)).mp changed + obtain ⟨sameOld, rfl⟩ := (variable_iff (value := base) (by simpa using currentFound)).mp original + subst oldValue + have continuation := (ih (base := nextValue) (by simpa using inputFound) (by simp) nextLength).mp continued + rcases continuation with ⟨tail, rfl⟩ + exact ⟨by simpa [Update.apply, dropped, updated, nextDrop] using tail, rfl⟩ + · rintro ⟨updated, sameHeap⟩ + subst after + simp only [dropped, Update.apply, bind, Option.bind_eq_some_iff] at updated + obtain ⟨nextValue, changed, continued⟩ := updated + refine ⟨replacement, before, (project_variable inputFound).mpr ⟨atIndex, rfl⟩, ?_⟩ + apply let_bind.mpr + refine ⟨nextValue, before, ?_, ?_⟩ + · apply (path_iff target (replacement := replacement) (by simp)).mpr + exact ⟨base, .var (by simpa using currentFound), changed⟩ + · apply (ih (base := nextValue) (by simpa using inputFound) (by simp) nextLength).mpr + exact ⟨by simpa only [nextDrop] using continued, rfl⟩ + +private theorem apply_length {paths : List UpdatePath} {replacements : List (SourceValue F)} + (updated : Update.apply types paths base replacements = some result) : replacements.length = paths.length := by + induction paths generalizing base replacements with + | nil => cases replacements <;> simp_all [Update.apply] + | cons path paths ih => + cases replacements with + | nil => simp [Update.apply] at updated + | cons v vs => + simp only [Update.apply, bind, Option.bind_eq_some_iff] at updated + obtain ⟨value, _, updated⟩ := updated + simpa using ih updated + +/-- Functional updates and their late reconstruction have exactly the same +operand evaluations, results, and heap effects. No typing premise or semantic +assumption about the compiler is needed for this local equivalence. -/ +theorem expression_iff : + OpenCore.EvalExpr world calls locals (expression types paths operands) before result after ↔ + ∃ values, OpenCore.EvalArgs world calls locals operands before values after ∧ + Update.value types paths values = .ok result := by + rw [expression, let_bind] + constructor + · rintro ⟨input, middle, evaluated, body⟩ + cases evaluated with + | tuple args => + rename_i values + cases body with + | letValue inspected matched body => + have inspectedResult := (variable_iff (value := .tuple values) (by simp)).mp inspected + obtain ⟨sameValue, sameHeap⟩ := inspectedResult + subst_vars + simp only [Aiur.Pattern.bindings, wildcards] at matched + split at matched + · rename_i length + simp only [Option.some.injEq] at matched + subst matched + cases values with + | nil => simp at length + | cons base replacements => + obtain ⟨current, last, projected, continued⟩ := let_bind.mp body + obtain ⟨atCurrent, sameHeap⟩ := (project_variable (by simp : + (("$withInputs", .tuple (base :: replacements)) :: locals).find? (·.1 == "$withInputs") = + some ("$withInputs", .tuple (base :: replacements)))).mp projected + have same : current = base := by simpa using atCurrent.symm + subst current + subst last + have rel := (sequence_iff paths (inputs := base :: replacements) (base := base) (by simp) (by simp) + (by simpa using length)).mp continued + obtain ⟨updated, sameHeap⟩ := rel + subst after + exact ⟨_, args, by simp only [Update.value, List.drop_succ_cons, List.drop_zero] at updated ⊢; rw [updated]⟩ + · cases matched + · rintro ⟨values, args, updated⟩ + cases values with + | nil => simp [Update.value] at updated + | cons base replacements => + cases applied : Update.apply types paths base replacements with + | none => simp [Update.value, applied] at updated + | some output => + have same : output = result := by simpa [Update.value, applied] using updated + subst result + have length := apply_length applied + refine ⟨.tuple (base :: replacements), after, .tuple args, ?_⟩ + apply OpenCore.EvalExpr.letValue (input := .tuple (base :: replacements)) (bindings := []) (.var (by simp)) + · simp [Aiur.Pattern.bindings, wildcards, length] + · apply let_bind.mpr + refine ⟨base, after, ?_, ?_⟩ + · exact .project (input := .tuple (base :: replacements)) (.var (by simp)) (by simp [projectValue]) + · apply (sequence_iff paths (inputs := base :: replacements) (base := base) (by simp) (by simp) (by simpa using length)).mpr + exact ⟨by simpa using applied, rfl⟩ + +end Aiur.Generic.UpdateLowering diff --git a/Aiur/Aiur/Generic/UpdateSubstitution.lean b/Aiur/Aiur/Generic/UpdateSubstitution.lean new file mode 100644 index 000000000..f3deab8dd --- /dev/null +++ b/Aiur/Aiur/Generic/UpdateSubstitution.lean @@ -0,0 +1,42 @@ +import Aiur.Generic.Update +import Aiur.Generic.TypeFacts + +namespace Aiur.Generic.Update + +@[simp] theorem position_subst (step : UpdateStep) : (step.subst types).position = step.position := by + cases step <;> rfl +@[simp] theorem width_subst (step : UpdateStep) : (step.subst types).width = step.width := by + cases step <;> rfl +@[simp] theorem owner_subst (step : UpdateStep) : + (step.subst types).owner = step.owner.map (Ty.subst types) := by + cases step with + | member field => cases h : field.owner <;> simp [h, UpdateStep.subst, UpdateStep.owner, FieldRef.subst, Ty.subst] + | project | index => rfl + +@[simp] theorem pack_subst (step : UpdateStep) (values : List (SourceValue F)) : + pack [] (step.subst types) values = pack types step values := by + simp only [pack, owner_subst] + cases step.owner <;> simp [nominalName] + +@[simp] theorem unpack_subst (step : UpdateStep) (value : SourceValue F) : + unpack [] (step.subst types) value = unpack types step value := by + simp only [unpack, owner_subst, width_subst] + cases step.owner <;> cases value <;> simp [nominalName] + +@[simp] theorem replace_subst (path : UpdatePath) (base replacement : SourceValue F) : + replace [] (path.map (UpdateStep.subst types)) base replacement = replace types path base replacement := by + induction path generalizing base with + | nil => rfl + | cons step path ih => simp only [List.map_cons, replace, unpack_subst, position_subst, ih, pack_subst] + +@[simp] theorem apply_subst (paths : List UpdatePath) (base : SourceValue F) (replacements : List (SourceValue F)) : + apply [] (paths.map (List.map (UpdateStep.subst types))) base replacements = apply types paths base replacements := by + induction paths generalizing base replacements with + | nil => cases replacements <;> rfl + | cons path paths ih => cases replacements <;> simp only [List.map_cons, apply, replace_subst, ih] + +@[simp] theorem value_subst (paths : List UpdatePath) (values : List (SourceValue F)) : + value [] (paths.map (List.map (UpdateStep.subst types))) values = value types paths values := by + cases values <;> simp only [value, apply_subst] + +end Aiur.Generic.Update diff --git a/Aiur/Aiur/Generic/ValueTyping.lean b/Aiur/Aiur/Generic/ValueTyping.lean new file mode 100644 index 000000000..cc1d8d30a --- /dev/null +++ b/Aiur/Aiur/Generic/ValueTyping.lean @@ -0,0 +1,63 @@ +import Aiur.Generic.Runtime +import Aiur.ValueFormed + +namespace Aiur.Generic + +/-- The declarations needed to validate an actual value. Pointer targets are +opaque here; the typechecker separately validates their names and layouts. -/ +def knownType (decls : Declarations) : Aiur.Ty → Bool + | .field | .ptr _ => true + | .tuple ts => (ts.map (knownType decls)).all id + | .enum n => (decls.findEnum? n).isSome +termination_by t => sizeOf t + +def closedEnums (decls : Declarations) : Prop := + ∀ d ∈ decls, ∀ c ∈ d.constructors, ∀ t ∈ c.fields, knownType decls t = true + +instance (decls : Declarations) : Decidable (closedEnums decls) := + inferInstanceAs (Decidable (∀ d ∈ decls, ∀ c ∈ d.constructors, ∀ t ∈ c.fields, knownType decls t = true)) + +theorem formed_agrees {enums : String → Option Aiur.EnumDecl} {decls : Declarations} + (agree : ∀ n d, decls.findEnum? n = some d → enums n = some d) + (closed : closedEnums decls) (v : Value F A) (known : knownType decls v.type = true) : + wellFormed enums v = v.wellFormed decls := by + cases v with + | field | ptr => simp [wellFormed, Value.wellFormed] + | tuple xs => + simp only [Value.type, knownType, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at known + simp only [wellFormed, Value.wellFormed] + congr 1 + apply List.map_congr_left + intro v hv + exact formed_agrees agree closed v (known v hv) + | construct n c xs => + cases found : decls.findEnum? n with + | none => simp [Value.type, knownType, found] at known + | some d => + have resolved := agree n d found + simp only [wellFormed, Value.wellFormed, Declarations.findConstructor?, found, + resolved, bind, Option.bind] + cases ctor : d.constructors.find? (·.name == c) with + | none => rfl + | some definition => + by_cases types : xs.map Value.type = definition.fields + · simp only [types, decide_true, Bool.true_and] + congr 1 + apply List.map_congr_left + intro v hv + apply formed_agrees agree closed v + apply closed d (List.mem_of_find?_eq_some found) definition (List.mem_of_find?_eq_some ctor) + rw [← types] + exact List.mem_map.mpr ⟨v, hv, rfl⟩ + · simp [types] +termination_by sizeOf v + +theorem hasType_agrees {enums : String → Option Aiur.EnumDecl} {decls : Declarations} + (agree : ∀ n d, decls.findEnum? n = some d → enums n = some d) + (closed : closedEnums decls) (t : Aiur.Ty) (known : knownType decls t = true) (v : Value F A) : + hasType enums t v = v.hasType decls t := by + by_cases same : v.type = t + · simp [hasType, Value.hasType, same, formed_agrees agree closed v (by simpa [same] using known)] + · simp [hasType, Value.hasType, same] + +end Aiur.Generic diff --git a/Aiur/Aiur/HeapMono.lean b/Aiur/Aiur/HeapMono.lean new file mode 100644 index 000000000..be1cb6285 --- /dev/null +++ b/Aiur/Aiur/HeapMono.lean @@ -0,0 +1,454 @@ +import Aiur.Memory.Encoding +import Aiur.Memory.Representation +import Aiur.Generic.SourceSemantics + +/-! +# Heap Monotonicity for Concrete and Generic Source Semantics + +In `Aiur`, heap memory is append-only (`store` appends a single cell to the end +of `Heap F` and returns `.ptr input.type middle.length`). Consequently: +1. Every concrete (`Aiur.EvalExpr`, `Aiur.EvalArgs`, `Aiur.EvalFn`) and generic + (`Generic.SourceSemantics.EvalExpr`, `EvalArgs`, `EvalFn`, `EvalExit`, + `EvalArgsExit`) evaluation satisfies `Heap.Extends before after`. +2. Any representation predicate built from constants, conjunctions, + disjunctions, quantifiers, pointer dereferences (`h[addr]? = some v`), + and inductive heap data structures (linked lists, binary trees) is + monotone with respect to `Heap.Extends` (`HeapMono`). +-/ + +namespace Aiur + +variable {F : Type} + +/-! ### 1. `Heap.Extends` and Basic Properties -/ + +/-- `Heap.Extends h₁ h₂` holds when `h₂` is obtained by appending zero or more +newly allocated cells to `h₁`. -/ +def Heap.Extends (h₁ h₂ : Heap F) : Prop := + ∃ s : Heap F, h₂ = h₁ ++ s + +namespace Heap.Extends + +theorem iff_isPrefix {h₁ h₂ : Heap F} : + Heap.Extends h₁ h₂ ↔ h₁ <+: h₂ := by + constructor + · rintro ⟨s, rfl⟩ + exact ⟨s, rfl⟩ + · rintro ⟨s, rfl⟩ + exact ⟨s, rfl⟩ + +@[refl] +theorem refl (h : Heap F) : Heap.Extends h h := + ⟨[], (List.append_nil h).symm⟩ + +theorem trans {h₁ h₂ h₃ : Heap F} + (e₁₂ : Heap.Extends h₁ h₂) (e₂₃ : Heap.Extends h₂ h₃) : + Heap.Extends h₁ h₃ := by + rcases e₁₂ with ⟨s₁, rfl⟩ + rcases e₂₃ with ⟨s₂, rfl⟩ + exact ⟨s₁ ++ s₂, List.append_assoc h₁ s₁ s₂⟩ + +theorem append_right (h s : Heap F) : Heap.Extends h (h ++ s) := + ⟨s, rfl⟩ + +theorem snoc (h : Heap F) (v : SourceValue F) : Heap.Extends h (h ++ [v]) := + ⟨[v], rfl⟩ + +theorem nil (h : Heap F) : Heap.Extends [] h := + ⟨h, rfl⟩ + +theorem length_le {h₁ h₂ : Heap F} (ext : Heap.Extends h₁ h₂) : + h₁.length ≤ h₂.length := by + rcases ext with ⟨s, rfl⟩ + simp + +theorem getElem?_eq {h₁ h₂ : Heap F} {i : Nat} {v : SourceValue F} + (ext : Heap.Extends h₁ h₂) (found : h₁[i]? = some v) : + h₂[i]? = some v := + heap_get_of_prefix (iff_isPrefix.mp ext) found + +theorem loadValue_eq {h₁ h₂ : Heap F} {ptr v : SourceValue F} + (ext : Heap.Extends h₁ h₂) (loaded : loadValue h₁ ptr = .ok v) : + loadValue h₂ ptr = .ok v := by + cases ptr with + | field | tuple | construct => cases loaded + | ptr target addr => + cases found : h₁[addr]? with + | none => simp [loadValue, found] at loaded + | some stored => + have found₂ := ext.getElem?_eq found + simpa [loadValue, found, found₂] using loaded + +end Heap.Extends + +/-! ### 2. Concrete Evaluation Heap Monotonicity (`Aiur.Semantics`) -/ + +theorem EvalExpr.heap_extends [Field F] [DecidableEq F] {program : Program F} + {locals : Environment F Nat} {expr : Expr F} {before after : Heap F} {value : SourceValue F} + (evaluated : EvalExpr program locals expr before value after) : + Heap.Extends before after := + Heap.Extends.iff_isPrefix.mpr evaluated.grows + +theorem EvalArgs.heap_extends [Field F] [DecidableEq F] {program : Program F} + {locals : Environment F Nat} {exprs : List (Expr F)} {before after : Heap F} + {values : List (SourceValue F)} + (evaluated : EvalArgs program locals exprs before values after) : + Heap.Extends before after := + Heap.Extends.iff_isPrefix.mpr evaluated.grows + +theorem EvalFn.heap_extends [Field F] [DecidableEq F] {program : Program F} + {name : String} {args : List (SourceValue F)} {before after : Heap F} {value : SourceValue F} + (evaluated : EvalFn program name args before value after) : + Heap.Extends before after := + Heap.Extends.iff_isPrefix.mpr evaluated.grows + +/-! ### 3. Generic Source Evaluation Heap Monotonicity (`Aiur.Generic.SourceSemantics`) -/ + +namespace Generic.SourceSemantics + +variable [Field F] [DecidableEq F] {world : World F} + +theorem EvalExpr.heap_extends + {types : Types} {locals : Environment F Nat} {expr : Expr F} + {before after : Heap F} {result : SourceValue F} + (evaluated : EvalExpr world types locals expr before result after) : + Heap.Extends before after := by + induction evaluated using EvalExpr.rec + (motive_2 := fun _ _ _ before _ after _ => Heap.Extends before after) + (motive_3 := fun _ _ before _ after _ => Heap.Extends before after) + (motive_4 := fun _ _ _ before _ _ after _ => Heap.Extends before after) + (motive_5 := fun _ _ _ before _ _ after _ => Heap.Extends before after) with + | literal | var | nil => + exact Heap.Extends.refl _ + | block _ ih + | blockExit _ ih + | global _ _ _ ih + | tuple _ ih + | array _ ih + | «repeat» _ ih + | index _ _ ih + | slice _ _ ih + | builtin _ _ ih + | update _ _ ih + | record _ ih + | member _ _ ih + | construct _ ih + | constructAs _ ih + | project _ _ ih + | load _ _ ih + | hint _ _ ih + | neg _ _ ih + | intro _ _ ih + | returned _ _ ih + | exit _ ih + | exitPayload _ ih + | fromBlock _ _ ih + | fromGlobal _ _ _ ih + | fromTuple _ ih + | fromArray _ ih + | fromRepeat _ ih + | fromIndex _ ih + | fromSlice _ ih + | fromBuiltin _ ih + | fromUpdate _ ih + | fromRecord _ ih + | fromMember _ ih + | fromConstruct _ ih + | fromConstructAs _ ih + | fromProject _ ih + | fromLetValue _ ih + | fromStore _ ih + | fromLoad _ ih + | fromHint _ ih + | fromNeg _ ih + | binaryLeft _ ih + | fromCall _ ih + | fromMatchValue _ ih + | head _ ih => + exact ih + | letValue _ _ _ ih₁ ih₂ + | binary _ _ _ ih₁ ih₂ + | call _ _ ih₁ ih₂ + | matchValue _ _ _ ih₁ ih₂ + | cons _ _ ih₁ ih₂ + | letBody _ _ _ ih₁ ih₂ + | binaryRight _ _ ih₁ ih₂ + | matchBody _ _ _ ih₁ ih₂ + | tail _ _ ih₁ ih₂ => + exact ih₁.trans ih₂ + | store _ ih => + exact ih.trans (Heap.Extends.snoc _ _) + +theorem EvalArgs.heap_extends + {types : Types} {locals : Environment F Nat} {exprs : List (Expr F)} + {before after : Heap F} {values : List (SourceValue F)} + (evaluated : EvalArgs world types locals exprs before values after) : + Heap.Extends before after := + (EvalExpr.tuple evaluated).heap_extends + +theorem EvalExit.heap_extends + {types : Types} {locals : Environment F Nat} {expr : Expr F} + {before after : Heap F} {target : ExitTarget} {result : SourceValue F} + (evaluated : EvalExit world types locals expr before target result after) : + Heap.Extends before after := by + induction evaluated using EvalExit.rec + (motive_1 := fun _ _ _ before _ after _ => Heap.Extends before after) + (motive_2 := fun _ _ _ before _ after _ => Heap.Extends before after) + (motive_3 := fun _ _ before _ after _ => Heap.Extends before after) + (motive_5 := fun _ _ _ before _ _ after _ => Heap.Extends before after) with + | literal | var | nil => + exact Heap.Extends.refl _ + | block _ ih + | blockExit _ ih + | global _ _ _ ih + | tuple _ ih + | array _ ih + | «repeat» _ ih + | index _ _ ih + | slice _ _ ih + | builtin _ _ ih + | update _ _ ih + | record _ ih + | member _ _ ih + | construct _ ih + | constructAs _ ih + | project _ _ ih + | load _ _ ih + | hint _ _ ih + | neg _ _ ih + | intro _ _ ih + | returned _ _ ih + | exit _ ih + | exitPayload _ ih + | fromBlock _ _ ih + | fromGlobal _ _ _ ih + | fromTuple _ ih + | fromArray _ ih + | fromRepeat _ ih + | fromIndex _ ih + | fromSlice _ ih + | fromBuiltin _ ih + | fromUpdate _ ih + | fromRecord _ ih + | fromMember _ ih + | fromConstruct _ ih + | fromConstructAs _ ih + | fromProject _ ih + | fromLetValue _ ih + | fromStore _ ih + | fromLoad _ ih + | fromHint _ ih + | fromNeg _ ih + | binaryLeft _ ih + | fromCall _ ih + | fromMatchValue _ ih + | head _ ih => + exact ih + | letValue _ _ _ ih₁ ih₂ + | binary _ _ _ ih₁ ih₂ + | call _ _ ih₁ ih₂ + | matchValue _ _ _ ih₁ ih₂ + | cons _ _ ih₁ ih₂ + | letBody _ _ _ ih₁ ih₂ + | binaryRight _ _ ih₁ ih₂ + | matchBody _ _ _ ih₁ ih₂ + | tail _ _ ih₁ ih₂ => + exact ih₁.trans ih₂ + | store _ ih => + exact ih.trans (Heap.Extends.snoc _ _) + +theorem EvalFn.heap_extends + {name : String} {args : List (SourceValue F)} + {before after : Heap F} {result : SourceValue F} + (evaluated : EvalFn world name args before result after) : + Heap.Extends before after := by + cases evaluated with + | intro _ body => exact body.heap_extends + | returned _ body => exact body.heap_extends + +theorem EvalArgsExit.heap_extends + {types : Types} {locals : Environment F Nat} {exprs : List (Expr F)} + {before after : Heap F} {target : ExitTarget} {result : SourceValue F} + (evaluated : EvalArgsExit world types locals exprs before target result after) : + Heap.Extends before after := + (EvalExit.fromTuple evaluated).heap_extends + +abbrev EvalList := @EvalArgs +abbrev EvalFields := @EvalArgs +abbrev EvalPath := @EvalArgs + +theorem EvalList.heap_extends + {types : Types} {locals : Environment F Nat} {exprs : List (Expr F)} + {before after : Heap F} {values : List (SourceValue F)} + (evaluated : EvalList world types locals exprs before values after) : + Heap.Extends before after := + EvalArgs.heap_extends evaluated + +theorem EvalFields.heap_extends + {types : Types} {locals : Environment F Nat} {exprs : List (Expr F)} + {before after : Heap F} {values : List (SourceValue F)} + (evaluated : EvalFields world types locals exprs before values after) : + Heap.Extends before after := + EvalArgs.heap_extends evaluated + +theorem EvalPath.heap_extends + {types : Types} {locals : Environment F Nat} {exprs : List (Expr F)} + {before after : Heap F} {values : List (SourceValue F)} + (evaluated : EvalPath world types locals exprs before values after) : + Heap.Extends before after := + EvalArgs.heap_extends evaluated + +end Generic.SourceSemantics + +/-! ### 4. `HeapMono` Predicate Combinators and Inductive Heap Structures -/ + +/-- A heap-indexed predicate `P : Heap F → α → Prop` is monotone (`HeapMono P`) if +extending the heap preserves `P`. -/ +def HeapMono {α : Type*} (P : Heap F → α → Prop) : Prop := + ∀ ⦃h₁ h₂ : Heap F⦄ ⦃x : α⦄, Heap.Extends h₁ h₂ → P h₁ x → P h₂ x + +/-- A binary heap-indexed relation `R : Heap F → α → β → Prop` (such as a representation +relation between a mathematical value `x : α` and a `SourceValue F` `v : β`) is +monotone (`HeapMono₂ R`) if extending the heap preserves `R`. -/ +def HeapMono₂ {α β : Type*} (R : Heap F → α → β → Prop) : Prop := + ∀ ⦃h₁ h₂ : Heap F⦄ ⦃x : α⦄ ⦃y : β⦄, Heap.Extends h₁ h₂ → R h₁ x y → R h₂ x y + +namespace HeapMono + +variable {α β : Type*} + +theorem of_heapMono₂ {R : Heap F → α → β → Prop} (hR : HeapMono₂ R) (x : α) : + HeapMono (fun h y => R h x y) := + fun _ _ _ ext h => hR ext h + +theorem const (Q : α → Prop) : HeapMono (fun (_ : Heap F) x => Q x) := + fun _ _ _ _ h => h + +theorem and {P Q : Heap F → α → Prop} (hP : HeapMono P) (hQ : HeapMono Q) : + HeapMono (fun h x => P h x ∧ Q h x) := + fun _ _ _ ext ⟨hp, hq⟩ => ⟨hP ext hp, hQ ext hq⟩ + +theorem or {P Q : Heap F → α → Prop} (hP : HeapMono P) (hQ : HeapMono Q) : + HeapMono (fun h x => P h x ∨ Q h x) := by + intro h₁ h₂ x ext h + rcases h with hp | hq + · exact Or.inl (hP ext hp) + · exact Or.inr (hQ ext hq) + +theorem ex {P : β → Heap F → α → Prop} (hP : ∀ b, HeapMono (P b)) : + HeapMono (fun h x => ∃ b, P b h x) := by + intro h₁ h₂ x ext ⟨b, hb⟩ + exact ⟨b, hP b ext hb⟩ + +theorem all {P : β → Heap F → α → Prop} (hP : ∀ b, HeapMono (P b)) : + HeapMono (fun h x => ∀ b, P b h x) := + fun _ _ _ ext h b => hP b ext (h b) + +theorem comp {P : Heap F → β → Prop} (f : α → β) (hP : HeapMono P) : + HeapMono (fun h x => P h (f x)) := + fun _ _ _ ext h => hP ext h + +theorem forall₂ {R : Heap F → α → β → Prop} (hR : HeapMono₂ R) (xs : List α) : + HeapMono (fun h ys => List.Forall₂ (R h) xs ys) := by + intro h₁ h₂ ys ext h + exact h.imp (fun _ _ hab => hR ext hab) + +end HeapMono + +/-- Pointer dereference combinator: `ptr` is a pointer of type `ty` whose heap cell +satisfies `P`. -/ +def DerefTyped (ty : Ty) (P : Heap F → SourceValue F → Prop) + (h : Heap F) (ptr : SourceValue F) : Prop := + ∃ addr v, ptr = .ptr ty addr ∧ h[addr]? = some v ∧ P h v + +/-- Untyped pointer dereference combinator: `ptr` is a pointer (of some type `ty`) +whose heap cell satisfies `P`. -/ +def Deref (P : Heap F → SourceValue F → Prop) + (h : Heap F) (ptr : SourceValue F) : Prop := + ∃ ty addr v, ptr = .ptr ty addr ∧ h[addr]? = some v ∧ P h v + +theorem HeapMono.derefTyped {ty : Ty} {P : Heap F → SourceValue F → Prop} + (hP : HeapMono P) : HeapMono (DerefTyped ty P) := by + intro h₁ h₂ ptr ext ⟨addr, v, hptr, hget, hp⟩ + exact ⟨addr, v, hptr, ext.getElem?_eq hget, hP ext hp⟩ + +theorem HeapMono.deref {P : Heap F → SourceValue F → Prop} + (hP : HeapMono P) : HeapMono (Deref P) := by + intro h₁ h₂ ptr ext ⟨ty, addr, v, hptr, hget, hp⟩ + exact ⟨ty, addr, v, hptr, ext.getElem?_eq hget, hP ext hp⟩ + +theorem Represents.heapMono (rom : ROM F) (source : SourceValue F) : + HeapMono (fun h target => Represents rom h source target) := by + intro h₁ h₂ target ext hrep + exact hrep.mono (Heap.Extends.iff_isPrefix.mp ext) + +/-- Inductive heap-allocated linked list representation for any nominal node enum `enumName` +with constructors `nilCtor` (`Nil`) and `consCtor` (`Cons(head, tail)`). -/ +inductive RepLinkedList {α : Type*} (enumName nilCtor consCtor : String) + (R : Heap F → α → SourceValue F → Prop) (h : Heap F) : + List α → SourceValue F → Prop where + | nil {addr : Nat} + (cell : h[addr]? = some (.construct enumName nilCtor [])) : + RepLinkedList enumName nilCtor consCtor R h [] (.ptr (.enum enumName) addr) + | cons {x : α} {xs : List α} {addr : Nat} {headVal tailPtr : SourceValue F} + (cell : h[addr]? = some (.construct enumName consCtor [headVal, tailPtr])) + (headRep : R h x headVal) + (tailRep : RepLinkedList enumName nilCtor consCtor R h xs tailPtr) : + RepLinkedList enumName nilCtor consCtor R h (x :: xs) (.ptr (.enum enumName) addr) + +theorem RepLinkedList.mono {α : Type*} {enumName nilCtor consCtor : String} + {R : Heap F → α → SourceValue F → Prop} (hR : HeapMono₂ R) + {h₁ h₂ : Heap F} {xs : List α} {ptr : SourceValue F} + (ext : Heap.Extends h₁ h₂) + (rep : RepLinkedList enumName nilCtor consCtor R h₁ xs ptr) : + RepLinkedList enumName nilCtor consCtor R h₂ xs ptr := by + induction rep with + | nil cell => + exact .nil (ext.getElem?_eq cell) + | cons cell headRep _ ih => + exact .cons (ext.getElem?_eq cell) (hR ext headRep) ih + +theorem HeapMono.repLinkedList {α : Type*} (enumName nilCtor consCtor : String) + {R : Heap F → α → SourceValue F → Prop} (hR : HeapMono₂ R) (xs : List α) : + HeapMono (fun h ptr => RepLinkedList enumName nilCtor consCtor R h xs ptr) := + fun _ _ _ ext rep => rep.mono hR ext + +/-- Inductive binary tree for heap-allocated tree structures. -/ +inductive BinaryTree (α : Type*) where + | leaf : BinaryTree α + | branch (label : α) (left right : BinaryTree α) : BinaryTree α + deriving Repr, DecidableEq + +/-- Inductive heap-allocated binary tree representation for a nominal tree enum `enumName` +with constructors `leafCtor` and `branchCtor(label, left, right)`. -/ +inductive RepBinaryTree {α : Type*} (enumName leafCtor branchCtor : String) + (R : Heap F → α → SourceValue F → Prop) (h : Heap F) : + BinaryTree α → SourceValue F → Prop where + | leaf {addr : Nat} + (cell : h[addr]? = some (.construct enumName leafCtor [])) : + RepBinaryTree enumName leafCtor branchCtor R h .leaf (.ptr (.enum enumName) addr) + | branch {x : α} {l r : BinaryTree α} {addr : Nat} {val leftPtr rightPtr : SourceValue F} + (cell : h[addr]? = some (.construct enumName branchCtor [val, leftPtr, rightPtr])) + (labelRep : R h x val) + (leftRep : RepBinaryTree enumName leafCtor branchCtor R h l leftPtr) + (rightRep : RepBinaryTree enumName leafCtor branchCtor R h r rightPtr) : + RepBinaryTree enumName leafCtor branchCtor R h (.branch x l r) (.ptr (.enum enumName) addr) + +theorem RepBinaryTree.mono {α : Type*} {enumName leafCtor branchCtor : String} + {R : Heap F → α → SourceValue F → Prop} (hR : HeapMono₂ R) + {h₁ h₂ : Heap F} {t : BinaryTree α} {ptr : SourceValue F} + (ext : Heap.Extends h₁ h₂) + (rep : RepBinaryTree enumName leafCtor branchCtor R h₁ t ptr) : + RepBinaryTree enumName leafCtor branchCtor R h₂ t ptr := by + induction rep with + | leaf cell => + exact .leaf (ext.getElem?_eq cell) + | branch cell labelRep _ _ ihl ihr => + exact .branch (ext.getElem?_eq cell) (hR ext labelRep) ihl ihr + +theorem HeapMono.repBinaryTree {α : Type*} (enumName leafCtor branchCtor : String) + {R : Heap F → α → SourceValue F → Prop} (hR : HeapMono₂ R) (t : BinaryTree α) : + HeapMono (fun h ptr => RepBinaryTree enumName leafCtor branchCtor R h t ptr) := + fun _ _ _ ext rep => rep.mono hR ext + +end Aiur diff --git a/Aiur/Aiur/Hints.lean b/Aiur/Aiur/Hints.lean new file mode 100644 index 000000000..71bc765ad --- /dev/null +++ b/Aiur/Aiur/Hints.lean @@ -0,0 +1,43 @@ +import Aiur.Constant + +namespace Aiur + +inductive HintError where + | unavailable + | invalidValue (expected actual : Ty) + | message (text : String) + deriving Repr, BEq, DecidableEq + +/-- Host advice consumes and returns constants. Channels are static names; +neither the callback nor its algorithm is part of the program's semantics. -/ +abbrev HintFunction (F : Type) := Constant F → Except HintError (Constant F) +abbrev HintDispatcher (F : Type) := String → HintFunction F + +/-- The evaluator may encounter ill-typed syntax; never expose addresses to a +host callback even in that case. -/ +def HintDispatcher.provide (dispatcher : HintDispatcher F) (channel : String) + (key : SourceValue F) : Except HintError (Constant F) := do + let some key := key.toConstant? | throw (.message "hint key contains pointers") + dispatcher channel key + +/-- Successful hints carry their typing proof. Constants are values with no address leaves. -/ +abbrev HintProvider (F : Type) (decls : Declarations) := + String → SourceValue F → (type : Ty) → + Except HintError { value : Constant F // value.WellTyped decls type } + +namespace HintProvider + +/-- Existing callers need no provider unless execution actually reaches a hint. -/ +def unavailable : HintProvider F decls := fun _ _ _ => .error .unavailable + +/-- Adapt an untrusted value producer by checking the complete nominal value type. -/ +def checked (decls : Declarations) + (dispatcher : HintDispatcher F) : HintProvider F decls := + fun channel key type => do + let value ← dispatcher.provide channel key + if valid : value.hasType decls type = true then return ⟨value, valid⟩ + else throw (.invalidValue type value.type) + +end HintProvider + +end Aiur diff --git a/Aiur/Aiur/Inlining/Completeness.lean b/Aiur/Aiur/Inlining/Completeness.lean new file mode 100644 index 000000000..6c23cd18b --- /dev/null +++ b/Aiur/Aiur/Inlining/Completeness.lean @@ -0,0 +1,161 @@ +import Aiur.Inlining.Facts + +namespace Aiur.Inlining +open Generic + +variable [Field F] [DecidableEq F] {p q : Aiur.Program F} {names : List String} + +/-- Retained calls keep their calling convention, with a certified expanded +body. This also covers static map leaves. -/ +def ForwardCalls (p q : Aiur.Program F) (names : List String) : Prop := + ∀ n ∉ names, ∀ (args : List (SourceValue F)) ls body, prepareCall p n args = .ok (ls,body) → + ∃ tree : Tree F, tree.source = body ∧ tree.Safe p names ∧ + prepareCall q n args = .ok (ls,tree.target) + +theorem completeExpr (sameEnums : p.enums = q.enums) (forward : ForwardCalls p q names) + (ev : Engine.EvalExpr (.ofProgram p) locals expr before result after) : + ∀ tree : Tree F, tree.source = expr → tree.Safe p names → + Engine.EvalExpr (.ofProgram q) locals tree.target before result after := by + induction ev using Engine.EvalExpr.rec + (motive_2 := fun ls es b vs a _ => ∀ trees : List (Tree F), + trees.map Tree.source = es → (∀ t ∈ trees, t.Safe p names) → + Engine.EvalArgs (.ofProgram q) ls (trees.map Tree.target) b vs a) + (motive_3 := fun n xs b v a _ => ∀ (tree : Tree F) ls, + prepareCall p n xs = .ok (ls,tree.source) → tree.Safe p names → + Engine.EvalExpr (.ofProgram q) ls tree.target b v a) with + | literal => + intro tree same safe + cases tree <;> simp only [Tree.source, Aiur.Expr.literal.injEq, reduceCtorEq] at same + simp only [Tree.Safe] at safe + simp only [Tree.target] + subst_vars; exact .literal + | var found => + intro tree same safe + cases tree <;> simp only [Tree.source, Aiur.Expr.var.injEq, reduceCtorEq] at same + simp only [Tree.Safe] at safe + simp only [Tree.target] + subst_vars; exact .var found + | tuple _ ih => + intro tree same safe + cases tree <;> simp only [Tree.source, Aiur.Expr.tuple.injEq, reduceCtorEq] at same + simp only [Tree.Safe] at safe + simp only [Tree.target] + exact .tuple (ih _ same safe) + | construct _ ih => + intro tree same safe + cases tree <;> simp only [Tree.source, Aiur.Expr.construct.injEq, reduceCtorEq] at same + simp only [Tree.Safe] at safe + simp only [Tree.target] + rcases same with ⟨rfl,rfl,same⟩ + exact .construct (ih _ same safe) + | project _ op ih => + intro tree same safe + cases tree <;> simp only [Tree.source, Aiur.Expr.project.injEq, reduceCtorEq] at same + simp only [Tree.Safe] at safe + simp only [Tree.target] + rcases same with ⟨same,rfl⟩ + exact .project (ih _ same safe) op + | letValue _ matched _ ih1 ih2 => + intro tree same safe + cases tree <;> simp only [Tree.source, Aiur.Expr.letValue.injEq, reduceCtorEq] at same + simp only [Tree.Safe] at safe + simp only [Tree.target] + rcases same with ⟨rfl,first,last⟩ + exact .letValue (ih1 _ first safe.1) matched (ih2 _ last safe.2) + | store _ ih => + intro tree same safe + cases tree <;> simp only [Tree.source, Aiur.Expr.store.injEq, reduceCtorEq] at same + simp only [Tree.Safe] at safe + simp only [Tree.target] + exact .store (ih _ same safe) + | load _ op ih => + intro tree same safe + cases tree <;> simp only [Tree.source, Aiur.Expr.load.injEq, reduceCtorEq] at same + simp only [Tree.Safe] at safe + simp only [Tree.target] + exact .load (ih _ same safe) op + | hint _ typed ih => + intro tree same safe + cases tree <;> simp only [Tree.source, Aiur.Expr.hint.injEq, reduceCtorEq] at same + simp only [Tree.Safe] at safe + simp only [Tree.target] + rcases same with ⟨rfl,same,rfl⟩ + exact .hint (ih _ same safe) (by simpa only [Engine.World.ofProgram,sameEnums] using typed) + | neg _ op ih => + intro tree same safe + cases tree <;> simp only [Tree.source, Aiur.Expr.neg.injEq, reduceCtorEq] at same + simp only [Tree.Safe] at safe + simp only [Tree.target] + exact .neg (ih _ same safe) op + | binary _ _ op ih1 ih2 => + intro tree same safe + cases tree <;> simp only [Tree.source, Aiur.Expr.binary.injEq, reduceCtorEq] at same + simp only [Tree.Safe] at safe + simp only [Tree.target] + rcases same with ⟨rfl,first,last⟩ + exact .binary (ih1 _ first safe.1) (ih2 _ last safe.2) op + | assertEq _ _ op ih1 ih2 => + intro tree same safe + cases tree <;> simp only [Tree.source, Aiur.Expr.assertEq.injEq, reduceCtorEq] at same + simp only [Tree.Safe] at safe + simp only [Tree.target] + rcases same with ⟨rfl,first,last⟩ + exact .assertEq (ih1 _ first safe.1) (ih2 _ last safe.2) op + | @call ls es b values middle n v a arguments callee ih1 ih2 => + intro tree same safe + cases tree <;> simp only [Tree.source, Aiur.Expr.call.injEq, reduceCtorEq] at same <;> simp only [Tree.Safe] at safe <;> simp only [Tree.target] + · rcases same with ⟨rfl,args⟩ + cases callee with + | intro prepared body => + obtain ⟨out,source,valid,preparedOut⟩ := forward _ safe.1 _ _ _ prepared + exact .call (ih1 _ args safe.2) + (.intro preparedOut (ih2 out _ (by simpa only [source, Engine.World.ofProgram] using prepared) valid)) + · rename_i f children body + rcases same with ⟨rfl,args⟩ + obtain ⟨found,_,bodySource,scope,bodySafe,childrenSafe⟩ := safe + cases callee with + | intro prepared evaluated => + rcases prepareCall_spec prepared with ⟨g,looked,types,formed,rfl,rfl⟩ | ⟨value,absent,_⟩ + · have eq : g = f := Option.some.inj (looked.symm.trans found) + subst g + have bodyEv := ih2 body _ (by simpa only [bodySource, Engine.World.ofProgram] using prepared) bodySafe + have length : (f.params.map Prod.fst).length = values.length := by + simpa using congrArg List.length types + have binding := PatternLowering.bindingsList_binders (f.params.map Prod.fst) values length + have scope : hasScope (((f.params.map Prod.fst).zip values).map Prod.fst) body.target = true := by + rwa [List.map_fst_zip (by omega)] + apply Engine.EvalExpr.letValue (bindings := (f.params.map Prod.fst).zip values) (.tuple (ih1 _ args childrenSafe)) + · simpa only [Aiur.Pattern.bindings, List.map_map, Function.comp_def] using binding + · exact ((isolated_iff scope).mp (OpenCore.of_closed bodyEv)).close + · simp [found] at absent + | @matchValue ls e b input mid arms bs body v a scrutinee selected branch ih1 ih2 => + intro tree same safe + cases tree <;> simp only [Tree.source, Aiur.Expr.matchValue.injEq, reduceCtorEq] at same + simp only [Tree.Safe] at safe + simp only [Tree.target] + rename_i value armsOut + rcases same with ⟨valueSame,rfl⟩ + rw [select_map] at selected + obtain ⟨⟨bindings,chosen⟩,chosenEq,same⟩ := Option.map_eq_some_iff.mp selected + obtain ⟨rfl,rfl⟩ := Prod.mk.inj same + obtain ⟨pat,member,_⟩ := choose_member chosenEq + exact .matchValue (ih1 _ valueSame safe.1) + (by rw [select_map,chosenEq]; rfl) (ih2 chosen rfl (safe.2 (pat,chosen) member)) + | nil => + rename_i trees same safe + cases trees <;> simp_all only [List.map_nil, List.map_cons, reduceCtorEq] + exact .nil + | cons _ _ ih1 ih2 => + rename_i trees same safe + cases trees with + | nil => simp at same + | cons head tail => + obtain ⟨headEq,tailEq⟩ := List.cons.inj same + exact .cons (ih1 head headEq (safe _ (by simp))) + (ih2 tail tailEq (fun t ht => safe _ (by simp [ht]))) + | intro prepared _ ih => + rename_i tree ls preparedTree safe + obtain ⟨rfl,same⟩ := Prod.mk.inj (Except.ok.inj (prepared.symm.trans preparedTree)) + exact ih tree same.symm safe + +end Aiur.Inlining diff --git a/Aiur/Aiur/Inlining/Facts.lean b/Aiur/Aiur/Inlining/Facts.lean new file mode 100644 index 000000000..a415d3479 --- /dev/null +++ b/Aiur/Aiur/Inlining/Facts.lean @@ -0,0 +1,57 @@ +import Aiur.Inlining.Tree +import Aiur.Generic.PatternBindingsFacts +import Aiur.Semantics.CallTypes + +namespace Aiur.Inlining +open Generic + +def choose [DecidableEq F] (value : SourceValue F) : + List (Aiur.Pattern F × A) → Option (Environment F Nat × A) + | [] => none + | (pat,body) :: rest => match pat.bindings value with + | none => choose value rest + | some bs => some (bs,body) + +theorem select_map [DecidableEq F] (value : SourceValue F) (arms : List (Aiur.Pattern F × A)) + (f : A → Aiur.Expr F) : + selectArm value (arms.map fun a => (a.1,f a.2)) = (choose value arms).map (fun a => (a.1,f a.2)) := by + induction arms with + | nil => rfl + | cons a rest ih => + rcases a with ⟨pat,body⟩ + cases h : pat.bindings value <;> simp [selectArm,choose,h,ih] + +theorem choose_member [DecidableEq F] {arms : List (Aiur.Pattern F × A)} + (selected : choose input arms = some (bs,body)) : + ∃ pat, (pat,body) ∈ arms ∧ pat.bindings input = some bs := by + induction arms with + | nil => simp [choose] at selected + | cons arm rest ih => + rcases arm with ⟨pat,expr⟩ + cases matched : pat.bindings input with + | none => + obtain ⟨p,hp,hm⟩ := ih (by simpa [choose,matched] using selected) + exact ⟨p,by simp [hp],hm⟩ + | some bindings => + obtain ⟨rfl,rfl⟩ := (by simpa [choose,matched] using selected : bindings = bs ∧ expr = body) + exact ⟨pat,by simp,matched⟩ + +theorem Tree.checkTypes_infer {tree : Tree F} (checked : tree.checkTypes q locals = some type) : + inferType q "$inline" locals tree.target = .ok type := by + rw [Tree.checkTypes.eq_def] at checked + obtain ⟨t,typed,rest⟩ := Option.bind_eq_some_iff.mp checked + obtain ⟨_,_,same⟩ := Option.map_eq_some_iff.mp rest + cases same + exact except_toOption_some_iff.mp typed + +theorem Tree.typed [Field F] [DecidableEq F] {q : Aiur.Program F} {tree : Tree F} + (programChecked : typecheck q = .ok ()) + (closed : ∀ n args b v a, calls n args b v a → Aiur.EvalFn q n args b v a) + (ev : OpenCore.EvalExpr (.ofProgram q) calls locals tree.target before result after) + (memory : before.Good q.enums) (values : locals.Good q.enums) + (checked : tree.checkTypes q (environmentTypes locals) = some type) : + result.type = type ∧ result.Good q.enums ∧ after.Good q.enums := + (ev.toProgram closed).wellTyped programChecked memory values "$inline" type + (Tree.checkTypes_infer checked) + +end Aiur.Inlining diff --git a/Aiur/Aiur/Inlining/Program.lean b/Aiur/Aiur/Inlining/Program.lean new file mode 100644 index 000000000..fbc7974d6 --- /dev/null +++ b/Aiur/Aiur/Inlining/Program.lean @@ -0,0 +1,247 @@ +import Aiur.Inlining.Soundness +import Aiur.Generic.CoreCallInduction +import Aiur.Generic.Specialize +import Aiur.InputTypes +import Aiur.TableChecking + +namespace Aiur.Inlining +open Generic + +abbrev Bodies (F : Type) := List (String × Tree F) +def Bodies.body (bodies : Bodies F) (name : String) : Tree F := + ((bodies.find? (·.1 == name)).map Prod.snd).getD (.tuple []) +def Bodies.function (bodies : Bodies F) (f : Aiur.Function F) : Aiur.Function F := + { f with body := (bodies.body f.name).target } +def Bodies.program (bodies : Bodies F) (p : Aiur.Program F) (names : List String) : Aiur.Program F := + { p with functions := (p.functions.filter (fun f => !names.contains f.name)).map bodies.function } + +/-- The certificate contains only decidable checks of finite syntax. -/ +def Bodies.Valid [DecidableEq F] (b : Bodies F) (p : Aiur.Program F) (names entries : List String) : Prop := + let q := b.program p names + typecheck q = .ok () ∧ + (∀ f ∈ p.functions, + (b.body f.name).source = f.body ∧ (b.body f.name).Safe p names ∧ + (b.body f.name).checkTypes q f.params = some f.result ∧ + Engine.inScope (callableNames q) (knownType q.enums) (b.body f.name).target = true) ∧ + (∀ n ∈ entries, n ∉ names ∧ Aiur.checkEntry q n = .ok ()) + +instance [DecidableEq F] (b : Bodies F) (p : Aiur.Program F) (names entries : List String) : + Decidable (b.Valid p names entries) := by unfold Bodies.Valid; infer_instance + +structure Prepared [DecidableEq F] (p : Aiur.Program F) (names entries : List String) where + bodies : Bodies F + checked : typecheck p = .ok () + valid : bodies.Valid p names entries + +def Prepared.program [DecidableEq F] {p : Aiur.Program F} {names entries : List String} + (q : Prepared p names entries) : Aiur.Program F := q.bodies.program p names + +def prepare [DecidableEq F] (p : Aiur.Program F) (names entries : List String) : + Except String (Prepared p names entries) := do + if checked : typecheck p = .ok () then + for n in entries do + if names.contains n then throw s!"inline function '{n}' cannot be an entrypoint" + let bodies : Bodies F ← p.functions.mapM fun f => do + let tree ← expand p names (p.functions.length + 1) f.body + return (f.name,tree) + let q := bodies.program p names + (typecheck q).mapError toString + if valid : bodies.Valid p names entries then return ⟨bodies,checked,valid⟩ + else throw "inlining failed its structural certificate check" + else throw "inlining requires a typechecked program" + +@[simp] theorem Prepared.enums [DecidableEq F] {p : Aiur.Program F} (q : Prepared p names entries) : q.program.enums = p.enums := rfl + +theorem Bodies.findFunction (b : Bodies F) (p : Aiur.Program F) (names : List String) (n : String) : + (b.program p names).findFunction? n = + if n ∈ names then none else (p.findFunction? n).map b.function := by + simp only [Bodies.program,Aiur.Program.findFunction?,List.find?_map,List.find?_filter, + Function.comp_def,Bodies.function] + by_cases member : n ∈ names + · rw [if_pos member] + have absent : p.functions.find? (fun f => decide ((!names.contains f.name) = true ∧ (f.name == n) = true)) = none := by + apply List.find?_eq_none.mpr + intro f _ + by_cases named : f.name = n <;> simp [named,member] + rw [absent] + rfl + · rw [if_neg member] + have predicate : (fun f : Aiur.Function F => decide ((!names.contains f.name) = true ∧ (f.name == n) = true)) = + (fun f => f.name == n) := by + funext f + by_cases named : f.name = n <;> simp [named,member] + rw [predicate] + +theorem function_name {p : Aiur.Program F} (found : p.findFunction? n = some f) : f.name = n := by + simpa [Aiur.Program.findFunction?] using List.find?_some found + +def constantTree : Constant F → Tree F + | .field x => .literal x + | .ptr _ a => nomatch a + | .tuple xs => .tuple (xs.map constantTree) + | .construct n c xs => .construct n c (xs.map constantTree) +termination_by v => sizeOf v + +theorem constantTree_source (v : Constant F) : (constantTree v).source = v.toExpr := by + cases v with + | field => simp [constantTree,Tree.source,Constant.toExpr] + | ptr _ a => exact Empty.elim a + | tuple xs | construct n c xs => + simp only [constantTree,Tree.source,Constant.toExpr,List.map_map] + congr 1 + exact List.map_congr_left fun x hx => constantTree_source x +termination_by sizeOf v + +theorem constantTree_target (v : Constant F) : (constantTree v).target = v.toExpr := by + cases v with + | field => simp [constantTree,Tree.target,Constant.toExpr] + | ptr _ a => exact Empty.elim a + | tuple xs | construct n c xs => + simp only [constantTree,Tree.target,Constant.toExpr,List.map_map] + congr 1 + exact List.map_congr_left fun x hx => constantTree_target x +termination_by sizeOf v + +theorem constantTree_safe (v : Constant F) : (constantTree v).Safe p names := by + cases v with + | field => simp [constantTree,Tree.Safe] + | ptr _ a => exact Empty.elim a + | tuple xs | construct n c xs => + simp only [constantTree,Tree.Safe,List.mem_map,forall_exists_index,and_imp,forall_apply_eq_imp_iff₂] + intro x hx + exact constantTree_safe x +termination_by sizeOf v + +theorem constant_scope (v : Constant F) : Engine.inScope names hintType v.toExpr = true := by + cases v with + | field => simp [Constant.toExpr,Engine.inScope] + | ptr _ a => exact Empty.elim a + | tuple xs | construct n c xs => + simp only [Constant.toExpr,Engine.inScope,List.all_map,List.all_eq_true,Function.comp_def,id_eq] + intro x hx + exact constant_scope x +termination_by sizeOf v + +variable [Field F] [DecidableEq F] {p : Aiur.Program F} {names entries : List String} + +omit [Field F] in +@[simp] theorem Prepared.lookupMap (q : Prepared p names entries) (n : String) (args : List (SourceValue F)) : + lookupMap q.program n args = lookupMap p n args := rfl + +omit [Field F] in +theorem Prepared.forward (q : Prepared p names entries) : ForwardCalls p q.program names := by + intro n retained args ls body prepared + rcases prepareCall_spec prepared with ⟨f,found,types,formed,rfl,rfl⟩ | ⟨v,absent,looked,rfl,rfl⟩ + · have named := function_name found + have cert := q.valid.2.1 f (List.mem_of_find?_eq_some found) + refine ⟨q.bodies.body f.name,cert.1,cert.2.1,?_⟩ + have found' : q.program.findFunction? n = some (q.bodies.function f) := by + simp only [Prepared.program,Bodies.findFunction,if_neg retained,found,Option.map_some] + exact prepareCall_of_types found' types formed + · refine ⟨constantTree v,constantTree_source v,constantTree_safe v,?_⟩ + rw [constantTree_target] + exact prepareCall_map (by simp [Prepared.program,Bodies.findFunction,absent]) (by simpa using looked) + +theorem Prepared.complete (q : Prepared p names entries) (retained : name ∉ names) + (evaluated : Aiur.EvalFn p name args before result after) : + Aiur.EvalFn q.program name args before result after := by + cases Engine.core_iff.mpr evaluated with + | intro prepared body => + obtain ⟨tree,source,safe,prepared'⟩ := q.forward name retained _ _ _ prepared + exact .intro prepared' ((completeExpr (p := p) (q := q.program) rfl q.forward body tree source safe).toCore) + +omit [Field F] in +/-- Retained target functions have the original calling convention and the +certified expanded body. Static maps are unchanged. -/ +theorem Prepared.backward (q : Prepared p names entries) {args : List (SourceValue F)} + (prepared : prepareCall q.program n args = .ok (ls,expr)) : + (∃ f, p.findFunction? n = some f ∧ + f.params.map Prod.snd = args.map Value.type ∧ + (∀ arg ∈ args, arg.wellFormed p.enums = true) ∧ + ls = (f.params.map Prod.fst).zip args ∧ expr = (q.bodies.body f.name).target) ∨ + (∃ v : Constant F, prepareCall p n args = .ok ([],v.toExpr) ∧ ls = [] ∧ expr = v.toExpr) := by + rcases prepareCall_spec prepared with ⟨g,found,types,formed,rfl,rfl⟩ | ⟨v,absent,looked,rfl,rfl⟩ + · left + rw [Prepared.program,Bodies.findFunction] at found + split at found + · cases found + · obtain ⟨f,original,rfl⟩ := Option.map_eq_some_iff.mp found + exact ⟨f,original,types,formed,rfl,rfl⟩ + · right + have original : p.findFunction? n = none := by + obtain ⟨m,key,found,_⟩ := lookupMap_spec looked + have named : m.name = n := by simpa [Aiur.Program.findMap?] using List.find?_some found + rw [← named] + exact map_function_absent q.checked (List.mem_of_find?_eq_some found) + exact ⟨v,prepareCall_map original (by simpa using looked),rfl,rfl⟩ + +omit [Field F] in +theorem Prepared.closed (q : Prepared p names entries) : + ∀ n ∈ callableNames q.program, ∀ args ls e, + (Engine.World.ofProgram q.program).prepare n args = .ok (ls,e) → + Engine.inScope (callableNames q.program) (knownType q.program.enums) e = true := by + intro n _ args ls e prepared + rcases q.backward prepared with ⟨f,found,_,_,_,rfl⟩ | ⟨v,_,_,rfl⟩ + · exact (q.valid.2.1 f (List.mem_of_find?_eq_some found)).2.2.2 + · exact constant_scope v + +theorem Prepared.prepare_sound (q : Prepared p names entries) {calls : Generic.CallRelation F} + (closed : ∀ n args b v a, calls n args b v a → Aiur.EvalFn q.program n args b v a) + (reflect : ∀ n args b v a, calls n args b v a → b.Good q.program.enums → + (∀ arg ∈ args, arg.Good q.program.enums) → Aiur.EvalFn p n args b v a) + (prepared : prepareCall q.program name args = .ok (locals,expr)) + (evaluated : OpenCore.EvalExpr (.ofProgram q.program) calls locals expr before result after) + (heapGood : before.Good q.program.enums) (argsGood : ∀ arg ∈ args, arg.Good q.program.enums) : + Aiur.EvalFn p name args before result after := by + rcases q.backward prepared with ⟨f,found,types,formed,rfl,rfl⟩ | ⟨v,prep,rfl,rfl⟩ + · have cert := q.valid.2.1 f (List.mem_of_find?_eq_some found) + have localsGood : Environment.Good q.program.enums ((f.params.map Prod.fst).zip args) := + fun binding member => argsGood binding.2 (List.of_mem_zip member).2 + have body := soundExpr (p := p) (q := q.program) rfl q.valid.1 closed reflect (q.bodies.body f.name) _ _ _ _ cert.2.1 + (by rw [parameterTypes f.params args types]; exact cert.2.2.1) evaluated heapGood localsGood + rw [cert.1] at body + exact .intro (prepareCall_of_types found types formed) body.close.toCore + · obtain ⟨rfl,rfl⟩ := Aiur.EvalExpr.constant_result v (evaluated.toProgram closed) + exact .intro prep v.evaluates + +theorem Prepared.sound (q : Prepared p names entries) + (reachable : name ∈ callableNames q.program) + (evaluated : Aiur.EvalFn q.program name args before result after) + (heapGood : before.Good q.program.enums) (argsGood : ∀ arg ∈ args, arg.Good q.program.enums) : + Aiur.EvalFn p name args before result after := by + let calls : Generic.CallRelation F := fun n args b v a => + Aiur.EvalFn q.program n args b v a ∧ + (b.Good q.program.enums → (∀ arg ∈ args, arg.Good q.program.enums) → Aiur.EvalFn p n args b v a) + have lifted := Engine.core_iff.mpr evaluated + have conclusion : calls name args before result after := lifted.openCalls q.closed + (fun n _ args ls e b v a prepared body ev => + ⟨.intro prepared body.toCore, fun hg ag => q.prepare_sound + (fun _ _ _ _ _ h => h.1) (fun _ _ _ _ _ h => h.2) prepared ev hg ag⟩) reachable + exact conclusion.2 heapGood argsGood + +theorem Prepared.entry_sound (q : Prepared p names entries) (selected : name ∈ entries) + (evaluated : Aiur.EvalFn q.program name args [] result heap) : + Aiur.EvalFn p name args [] result heap := by + have entry := (q.valid.2.2 name selected).2 + have reachable : name ∈ callableNames q.program := by + obtain ⟨signature,found,_⟩ := (checkEntry_ok q.program name).mp entry + unfold Aiur.Program.findSignature? at found + cases fn : q.program.findFunction? name with + | some f => exact List.mem_append_left _ (List.mem_map.mpr + ⟨f,List.mem_of_find?_eq_some fn,function_name fn⟩) + | none => + simp only [fn] at found + obtain ⟨m,fm,_⟩ := Option.map_eq_some_iff.mp found + have named : m.name = name := by simpa [Aiur.Program.findMap?] using List.find?_some fm + exact List.mem_append_right _ (List.mem_map.mpr ⟨m,List.mem_of_find?_eq_some fm,named⟩) + exact q.sound reachable evaluated (by simp [Heap.Good]) (fun arg member => + ⟨(evaluated.publicArguments entry arg member).2, + Value.pointerNames_of_free (evaluated.public_pointerFree entry arg member)⟩) + +/-- Mandatory expansion preserves exactly the selected entry evaluations, +including allocations and nondeterministic choices. -/ +theorem Prepared.entry_iff (q : Prepared p names entries) (selected : name ∈ entries) : + Aiur.EvalFn p name args [] result heap ↔ Aiur.EvalFn q.program name args [] result heap := + ⟨q.complete (q.valid.2.2 name selected).1,q.entry_sound selected⟩ + +end Aiur.Inlining diff --git a/Aiur/Aiur/Inlining/Scope.lean b/Aiur/Aiur/Inlining/Scope.lean new file mode 100644 index 000000000..f1b402dc3 --- /dev/null +++ b/Aiur/Aiur/Inlining/Scope.lean @@ -0,0 +1,109 @@ +import Aiur.Generic.PatternStepFacts +import Aiur.Generic.EnvironmentFacts + +namespace Aiur.Inlining +open Generic Generic.Engine Generic.PatternLowering + +def hasScope (names : List String) : Aiur.Expr F → Bool + | .literal _ => true + | .var n => names.contains n + | .tuple xs | .construct _ _ xs | .call _ xs => (xs.map (hasScope names)).all id + | .project x _ | .store x | .load x | .hint _ x channel | .neg x => hasScope names x + | .binary _ x y | .assertEq _ x y => hasScope names x && hasScope names y + | .letValue p x b => hasScope names x && hasScope (patternNames p ++ names) b + | .matchValue x arms => hasScope names x && + (arms.map fun a => hasScope (patternNames a.1 ++ names) a.2).all id +termination_by e => sizeOf e +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +theorem agree_prepend (agree : EnvAgrees names (left : Environment F Nat) right) + (bs : Environment F Nat) : + EnvAgrees (bs.map Prod.fst ++ names) (bs ++ left) (bs ++ right) := by + intro n member + simp only [List.find?_append] + cases found : bs.find? (·.1 == n) with + | some b => rfl + | none => + have absent : n ∉ bs.map Prod.fst := by + intro h + obtain ⟨b,hb,same⟩ := List.mem_map.mp h + have := List.find?_eq_none.mp found b hb + simp [same] at this + exact agree n ((List.mem_append.mp member).resolve_left absent) + +theorem agree_extension (ls extra : Environment F Nat) : EnvAgrees (ls.map Prod.fst) ls (ls ++ extra) := by + have := agree_prepend (left := ([] : Environment F Nat)) (right := extra) + (names := []) (by simp [EnvAgrees]) ls + simpa using this + +theorem selected_hasScope [DecidableEq F] {input : SourceValue F} {arms : List (Aiur.Pattern F × Aiur.Expr F)} + (chosen : selectArm input arms = some (bs,body)) + (all : ∀ a ∈ arms, hasScope (patternNames a.1 ++ names) a.2 = true) : + hasScope (bs.map Prod.fst ++ names) body = true := by + induction arms with + | nil => simp [selectArm] at chosen + | cons a rest ih => + rcases a with ⟨pat,expr⟩ + cases matched : pat.bindings input with + | none => exact ih (by simpa [selectArm,matched] using chosen) (by intro a h; exact all a (by simp [h])) + | some found => + obtain ⟨rfl,rfl⟩ := (by simpa [selectArm,matched] using chosen : found = bs ∧ expr = body) + simpa [bindings_names matched] using all (pat,expr) (by simp) + +theorem changeLocals [Field F] [DecidableEq F] {world : Engine.World F} + (ev : OpenCore.EvalExpr world calls locals expr before result after) : + ∀ names other, hasScope names expr = true → EnvAgrees names locals other → + OpenCore.EvalExpr world calls other expr before result after := by + induction ev using OpenCore.EvalExpr.rec + (motive_2 := fun ls es b vs a _ => ∀ names other, + (∀ e ∈ es, hasScope names e = true) → EnvAgrees names ls other → + OpenCore.EvalArgs world calls other es b vs a) with + | literal => intros; exact .literal + | var found => + intro names other safe agree + exact .var (by rw [← agree _ (by simpa [hasScope] using safe)]; exact found) + | tuple _ ih => intro names other safe agree; exact .tuple (ih names other (by simpa [hasScope] using safe) agree) + | construct _ ih => intro names other safe agree; exact .construct (ih names other (by simpa [hasScope] using safe) agree) + | project _ op ih => intro names other safe agree; exact .project (ih names other (by simpa only [hasScope] using safe) agree) op + | store _ ih => intro names other safe agree; exact .store (ih names other (by simpa only [hasScope] using safe) agree) + | load _ op ih => intro names other safe agree; exact .load (ih names other (by simpa only [hasScope] using safe) agree) op + | hint _ op ih => intro names other safe agree; exact .hint (ih names other (by simpa only [hasScope] using safe) agree) op + | neg _ op ih => intro names other safe agree; exact .neg (ih names other (by simpa only [hasScope] using safe) agree) op + | binary _ _ op ih1 ih2 => + intro names other safe agree + simp only [hasScope, Bool.and_eq_true] at safe + have h := safe + exact .binary (ih1 names other h.1 agree) (ih2 names other h.2 agree) op + | assertEq _ _ op ih1 ih2 => + intro names other safe agree + simp only [hasScope, Bool.and_eq_true] at safe + have h := safe + exact .assertEq (ih1 names other h.1 agree) (ih2 names other h.2 agree) op + | letValue _ matched _ ih1 ih2 => + intro names other safe agree + simp only [hasScope, Bool.and_eq_true] at safe + have h := safe + exact .letValue (ih1 names other h.1 agree) matched + (ih2 _ _ h.2 (by rw [← bindings_names matched]; exact agree_prepend agree _)) + | call _ called ih => intro names other safe agree; exact .call (ih names other (by simpa [hasScope] using safe) agree) called + | matchValue _ selected _ ih1 ih2 => + intro names other safe agree + simp only [hasScope, Bool.and_eq_true, List.all_map, List.all_eq_true, Function.comp_def, id_eq] at safe + exact .matchValue (ih1 names other safe.1 agree) selected + (ih2 _ _ (selected_hasScope selected safe.2) (agree_prepend agree _)) + | nil => exact .nil + | cons _ _ ih1 ih2 => + rename_i names other safe agree + exact .cons (ih1 names other (safe _ (by simp)) agree) + (ih2 names other (by intro e h; exact safe e (by simp [h])) agree) + +theorem isolated_iff [Field F] [DecidableEq F] {world : Engine.World F} + (safe : hasScope (locals.map Prod.fst) expr = true) : + OpenCore.EvalExpr world calls locals expr b v a ↔ + OpenCore.EvalExpr world calls (locals ++ extra) expr b v a := + ⟨fun h => changeLocals h _ _ safe (agree_extension _ _), + fun h => changeLocals h _ _ safe (agree_extension _ _).symm⟩ + +end Aiur.Inlining diff --git a/Aiur/Aiur/Inlining/Soundness.lean b/Aiur/Aiur/Inlining/Soundness.lean new file mode 100644 index 000000000..6a9a19142 --- /dev/null +++ b/Aiur/Aiur/Inlining/Soundness.lean @@ -0,0 +1,240 @@ +import Aiur.Inlining.Completeness + +namespace Aiur.Inlining +open Generic + +/-- Reflect expansion using the static argument types. Calls are discharged by +induction on the finite target evaluation, so recursive functions need not be total. -/ +theorem soundExpr [Field F] [DecidableEq F] + {p q : Aiur.Program F} {names : List String} {calls : Generic.CallRelation F} + (sameEnums : p.enums = q.enums) (checkedProgram : typecheck q = .ok ()) + (closed : ∀ n args b v a, calls n args b v a → Aiur.EvalFn q n args b v a) + (reflect : ∀ n args b v a, calls n args b v a → b.Good q.enums → + (∀ arg ∈ args, arg.Good q.enums) → Aiur.EvalFn p n args b v a) + (tree : Tree F) (locals : Environment F Nat) + (before : Heap F) (result : SourceValue F) (after : Heap F) + (safe : tree.Safe p names) {type : Aiur.Ty} + (checked : tree.checkTypes q (environmentTypes locals) = some type) + (evaluated : OpenCore.EvalExpr (.ofProgram q) calls locals tree.target before result after) + (heapGood : before.Good q.enums) (localsGood : locals.Good q.enums) : + OpenCore.EvalExpr (.ofProgram p) (Engine.EvalFn (.ofProgram p)) locals tree.source before result after := by + have sub (child : Tree F) (smaller : sizeOf child < sizeOf tree) + (ls : Environment F Nat) (b : Heap F) (v : SourceValue F) (a : Heap F) + (safe : child.Safe p names) {t : Aiur.Ty} + (checked : child.checkTypes q (environmentTypes ls) = some t) + (ev : OpenCore.EvalExpr (.ofProgram q) calls ls child.target b v a) + (hg : b.Good q.enums) (lg : ls.Good q.enums) : + OpenCore.EvalExpr (.ofProgram p) (Engine.EvalFn (.ofProgram p)) ls child.source b v a := + soundExpr sameEnums checkedProgram closed reflect child ls b v a safe checked ev hg lg + have children (es : List (Tree F)) (smaller : ∀ e ∈ es, sizeOf e < sizeOf tree) + (safe : ∀ e ∈ es, e.Safe p names) {types : List Aiur.Ty} + (typed : es.mapM (Tree.checkTypes q (environmentTypes locals)) = some types) + {b : Heap F} {values : List (SourceValue F)} {a : Heap F} + (ev : OpenCore.EvalArgs (.ofProgram q) calls locals (es.map Tree.target) b values a) + (hg : b.Good q.enums) : + OpenCore.EvalArgs (.ofProgram p) (Engine.EvalFn (.ofProgram p)) locals (es.map Tree.source) b values a ∧ + values.map Value.type = types ∧ (∀ v ∈ values, v.Good q.enums) ∧ a.Good q.enums := by + induction es generalizing b values types with + | nil => + cases ev + have same : ([] : List Aiur.Ty) = types := Option.some.inj typed + subst types + exact ⟨.nil,rfl,by simp,hg⟩ + | cons e es ih => + cases ev with + | cons head tail => + simp only [List.mapM_cons, bind, Option.bind] at typed + obtain ⟨t, ht, rest⟩ := Option.bind_eq_some_iff.mp typed + obtain ⟨ts, hts, last⟩ := Option.bind_eq_some_iff.mp rest + cases Option.some.inj last + have info := Tree.typed checkedProgram closed head hg localsGood ht + obtain ⟨rest, shape, good, last⟩ := ih (fun x hx => smaller x (by simp [hx])) + (fun x hx => safe x (by simp [hx])) hts tail info.2.2 + exact ⟨.cons (sub e (smaller e (by simp)) locals _ _ _ (safe e (by simp)) ht head hg localsGood) rest, + by simp only [List.map_cons,info.1,shape], + by simpa only [List.mem_cons, forall_eq_or_imp] using And.intro info.2.1 good,last⟩ + have inferred := Tree.checkTypes_infer checked + rw [Tree.checkTypes.eq_def] at checked + simp only [inferred, Except.toOption, Bind.bind, Option.bind] at checked + obtain ⟨checkedUnit, checks, _⟩ := Option.map_eq_some_iff.mp checked + cases checkedUnit + cases tree with + | literal x => + simp only [Tree.Safe] at safe + simp only [Tree.source] + rw [Tree.target] at evaluated; cases evaluated; exact .literal + | var n => + simp only [Tree.Safe] at safe + simp only [Tree.source] + rw [Tree.target] at evaluated; cases evaluated with | var found => exact .var found + | tuple es => + simp only [Tree.Safe] at safe + simp only [Tree.source] + rw [Tree.target] at evaluated + cases evaluated with + | tuple items => + obtain ⟨_,mapped,_⟩ := Option.map_eq_some_iff.mp checks + exact .tuple ((children es (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) + safe mapped items heapGood).1) + | construct _ _ es => + simp only [Tree.Safe] at safe + simp only [Tree.source] + rw [Tree.target] at evaluated + cases evaluated with + | construct items => + obtain ⟨_,mapped,_⟩ := Option.map_eq_some_iff.mp checks + exact .construct ((children es (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) + safe mapped items heapGood).1) + | project child i => + simp only [Tree.Safe] at safe + simp only [Tree.source] + rw [Tree.target] at evaluated + obtain ⟨_,typed,_⟩ := Option.map_eq_some_iff.mp checks + cases evaluated with + | project ev operation => + exact .project (sub child (by simp_wf; try omega) locals _ _ _ safe typed ev heapGood localsGood) operation + | store child => + simp only [Tree.Safe] at safe + simp only [Tree.source] + rw [Tree.target] at evaluated + obtain ⟨_,typed,_⟩ := Option.map_eq_some_iff.mp checks + cases evaluated with + | store ev => + exact .store (sub child (by simp_wf; try omega) locals _ _ _ safe typed ev heapGood localsGood) + | load child => + simp only [Tree.Safe] at safe + simp only [Tree.source] + rw [Tree.target] at evaluated + obtain ⟨_,typed,_⟩ := Option.map_eq_some_iff.mp checks + cases evaluated with + | load ev operation => + exact .load (sub child (by simp_wf; try omega) locals _ _ _ safe typed ev heapGood localsGood) operation + | hint _ child channel => + simp only [Tree.Safe] at safe + simp only [Tree.source] + rw [Tree.target] at evaluated + obtain ⟨_,typed,_⟩ := Option.map_eq_some_iff.mp checks + cases evaluated with + | hint ev formed => + exact .hint (sub child (by simp_wf; try omega) locals _ _ _ safe typed ev heapGood localsGood) + (by simpa only [Engine.World.ofProgram,sameEnums] using formed) + | neg child => + simp only [Tree.Safe] at safe + simp only [Tree.source] + rw [Tree.target] at evaluated + obtain ⟨_,typed,_⟩ := Option.map_eq_some_iff.mp checks + cases evaluated with + | neg ev operation => + exact .neg (sub child (by simp_wf; try omega) locals _ _ _ safe typed ev heapGood localsGood) operation + | binary op left right => + simp only [Tree.Safe] at safe + simp only [Tree.source] + rw [Tree.target] at evaluated + cases evaluated with + | binary first second operation => + obtain ⟨_,leftType,rest⟩ := Option.bind_eq_some_iff.mp checks + obtain ⟨_,rightType,_⟩ := Option.bind_eq_some_iff.mp rest + have middleGood := (Tree.typed checkedProgram closed first heapGood localsGood leftType).2.2 + exact .binary (sub left (by simp_wf; omega) locals _ _ _ safe.1 leftType first heapGood localsGood) + (sub right (by simp_wf; omega) locals _ _ _ safe.2 rightType second middleGood localsGood) operation + | assertEq op left right => + simp only [Tree.Safe] at safe + simp only [Tree.source] + rw [Tree.target] at evaluated + cases evaluated with + | assertEq first second operation => + obtain ⟨_,leftType,rest⟩ := Option.bind_eq_some_iff.mp checks + obtain ⟨_,rightType,_⟩ := Option.bind_eq_some_iff.mp rest + have middleGood := (Tree.typed checkedProgram closed first heapGood localsGood leftType).2.2 + exact .assertEq (sub left (by simp_wf; omega) locals _ _ _ safe.1 leftType first heapGood localsGood) + (sub right (by simp_wf; omega) locals _ _ _ safe.2 rightType second middleGood localsGood) operation + | call name es => + simp only [Tree.Safe] at safe + simp only [Tree.source] + rw [Tree.target] at evaluated + cases evaluated with + | call argEval callee => + obtain ⟨_, mapped, _⟩ := Option.map_eq_some_iff.mp checks + obtain ⟨argsEval,_,argsGood,middleGood⟩ := children es + (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) safe.2 mapped argEval heapGood + exact .call argsEval (Engine.core_iff.mpr (reflect _ _ _ _ _ callee middleGood argsGood)) + | letValue pat value body => + simp only [Tree.Safe] at safe + simp only [Tree.source] + obtain ⟨inputType,valueType,rest⟩ := Option.bind_eq_some_iff.mp checks + obtain ⟨bindingTypes,patternType,rest⟩ := Option.bind_eq_some_iff.mp rest + obtain ⟨_,bodyType,_⟩ := Option.bind_eq_some_iff.mp rest + rw [Tree.target] at evaluated + cases evaluated with + | letValue valueEval matched bodyEval => + obtain ⟨shape,inputGood,middleGood⟩ := Tree.typed checkedProgram closed valueEval heapGood localsGood valueType + have bindingShape := patternTypes_bindings (caller := "$inline") + (by rw [shape]; exact checkPattern_types (except_toOption_some_iff.mp patternType)) inputGood.1 matched + exact .letValue (sub value (by simp_wf; omega) locals _ _ _ safe.1 valueType valueEval heapGood localsGood) matched + (sub body (by simp_wf; omega) _ _ _ _ safe.2 + (by simpa only [environmentTypes_append,bindingShape] using bodyType) bodyEval middleGood + (Environment.good_append.mpr ⟨Pattern.bindings_good inputGood matched,localsGood⟩)) + | matchValue value arms => + simp only [Tree.Safe] at safe + simp only [Tree.source] + obtain ⟨inputType,valueType,rest⟩ := Option.bind_eq_some_iff.mp checks + obtain ⟨_,armsTyped,_⟩ := Option.bind_eq_some_iff.mp rest + rw [Tree.target] at evaluated + cases evaluated with + | matchValue valueEval selected bodyEval => + rw [select_map] at selected + obtain ⟨⟨bs,branch⟩,chosen,same⟩ := Option.map_eq_some_iff.mp selected + obtain ⟨rfl,rfl⟩ := Prod.mk.inj same + obtain ⟨pat,member,matched⟩ := choose_member chosen + obtain ⟨_,branchTypes⟩ := option_mapM_hasResult armsTyped (pat,branch) member + obtain ⟨bindingTypes,patType,branchType⟩ := Option.bind_eq_some_iff.mp branchTypes + obtain ⟨shape,inputGood,middleGood⟩ := Tree.typed checkedProgram closed valueEval heapGood localsGood valueType + have bindingShape := patternTypes_bindings (caller := "$inline") + (by rw [shape]; exact checkPattern_types (except_toOption_some_iff.mp patType)) inputGood.1 matched + exact .matchValue (sub value (by simp_wf; omega) locals _ _ _ safe.1 valueType valueEval heapGood localsGood) + (by rw [select_map,chosen]; rfl) + (sub branch (by simp_wf; have h := List.sizeOf_lt_of_mem member; simp only [Prod.mk.sizeOf_spec] at h; omega) + _ _ _ _ (safe.2 _ member) (by simpa only [environmentTypes_append,bindingShape] using branchType) + bodyEval middleGood (Environment.good_append.mpr ⟨Pattern.bindings_good inputGood matched,localsGood⟩)) + | expand f es body => + simp only [Tree.Safe] at safe + simp only [Tree.source] + obtain ⟨types,argsTyped,rest⟩ := Option.bind_eq_some_iff.mp checks + split at rest + · cases rest + · rename_i sameTypes + have sameTypes : types = f.params.map Prod.snd := by simpa using sameTypes + obtain ⟨_,bodyTyped,_⟩ := Option.bind_eq_some_iff.mp rest + rw [Tree.target] at evaluated + cases evaluated with + | letValue argEval matched bodyEval => + cases argEval with + | tuple items => + rename_i values + obtain ⟨argsEval,shape,argsGood,middleGood⟩ := children es + (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) safe.2.2.2.2.2 argsTyped items heapGood + have typesEq := shape.trans sameTypes + have length : (f.params.map Prod.fst).length = values.length := by + simpa using (congrArg List.length typesEq).symm + have matched' := PatternLowering.bindingsList_binders _ _ length + simp only [List.map_map,Function.comp_def] at matched' + simp only [Aiur.Pattern.bindings] at matched + rw [matched'] at matched + cases Option.some.inj matched + have params := parameterTypes f.params _ typesEq.symm + have scope : hasScope (((f.params.map Prod.fst).zip values).map Prod.fst) body.target = true := by + rw [List.map_fst_zip (by omega)]; exact safe.2.2.2.1 + have isolated := (isolated_iff scope).mpr bodyEval + have localGood : Environment.Good q.enums ((f.params.map Prod.fst).zip values) := + fun binding member => argsGood binding.2 (List.of_mem_zip member).2 + have sourceBody := sub body (by simp_wf; omega) _ _ _ _ safe.2.2.2.2.1 + (by simpa only [params] using bodyTyped) isolated middleGood localGood + exact .call argsEval (.intro + (by + rw [safe.2.2.1] + exact prepareCall_of_types safe.1 typesEq.symm + (fun arg ha => by simpa only [sameEnums] using (argsGood arg ha).1)) sourceBody.close) +termination_by sizeOf tree +decreasing_by exact smaller + +end Aiur.Inlining diff --git a/Aiur/Aiur/Inlining/Tree.lean b/Aiur/Aiur/Inlining/Tree.lean new file mode 100644 index 000000000..86de41322 --- /dev/null +++ b/Aiur/Aiur/Inlining/Tree.lean @@ -0,0 +1,204 @@ +import Aiur.Inlining.Scope +import Aiur.Generic.Equality +import Aiur.Generic.LoweringTypeFacts + +namespace Aiur.Inlining +open Generic + +/-- A finite explanation of circuit-only expansion. Its two interpretations +are ordinary core expressions; no new source evaluation rule is introduced. -/ +inductive Tree (F : Type) where + | literal (value : F) + | var (name : String) + | tuple (items : List (Tree F)) + | construct (name ctor : String) (items : List (Tree F)) + | project (child : Tree F) (index : Nat) + | letValue (pattern : Aiur.Pattern F) (value body : Tree F) + | store (child : Tree F) + | load (child : Tree F) + | hint (type : Aiur.Ty) (key : Tree F) (channel : String := "") + | neg (child : Tree F) + | binary (op : BinOp) (left right : Tree F) + | assertEq (assertion : Assertion) (left right : Tree F) + | call (name : String) (args : List (Tree F)) + | expand (callee : Aiur.Function F) (args : List (Tree F)) (body : Tree F) + | matchValue (value : Tree F) (arms : List (Aiur.Pattern F × Tree F)) + +def Tree.source : Tree F → Aiur.Expr F + | .literal x => .literal x + | .var n => .var n + | .tuple xs => .tuple (xs.map Tree.source) + | .construct n c xs => .construct n c (xs.map Tree.source) + | .project x i => .project x.source i + | .letValue p x b => .letValue p x.source b.source + | .store x => .store x.source + | .load x => .load x.source + | .hint t x channel => .hint t x.source channel + | .neg x => .neg x.source + | .binary op x y => .binary op x.source y.source + | .assertEq op x y => .assertEq op x.source y.source + | .call n xs => .call n (xs.map Tree.source) + | .expand f xs _ => .call f.name (xs.map Tree.source) + | .matchValue x arms => .matchValue x.source (arms.map fun a => (a.1,a.2.source)) +termination_by t => sizeOf t +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +def Tree.target : Tree F → Aiur.Expr F + | .literal x => .literal x + | .var n => .var n + | .tuple xs => .tuple (xs.map Tree.target) + | .construct n c xs => .construct n c (xs.map Tree.target) + | .project x i => .project x.target i + | .letValue p x b => .letValue p x.target b.target + | .store x => .store x.target + | .load x => .load x.target + | .hint t x channel => .hint t x.target channel + | .neg x => .neg x.target + | .binary op x y => .binary op x.target y.target + | .assertEq op x y => .assertEq op x.target y.target + | .call n xs => .call n (xs.map Tree.target) + | .expand f xs b => .letValue (.tuple (f.params.map fun p => .bind p.1)) + (.tuple (xs.map Tree.target)) b.target + | .matchValue x arms => .matchValue x.target (arms.map fun a => (a.1,a.2.target)) +termination_by t => sizeOf t +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +/-- Purely syntactic expansion certificate. In particular, ordinary calls can +never name a mandatory-inline function. -/ +def Tree.Safe (p : Aiur.Program F) (inlineNames : List String) : Tree F → Prop + | .literal _ | .var _ => True + | .tuple xs | .construct _ _ xs => ∀ x ∈ xs, x.Safe p inlineNames + | .project x _ | .store x | .load x | .hint _ x channel | .neg x => x.Safe p inlineNames + | .binary _ x y | .assertEq _ x y | .letValue _ x y => x.Safe p inlineNames ∧ y.Safe p inlineNames + | .call n xs => n ∉ inlineNames ∧ ∀ x ∈ xs, x.Safe p inlineNames + | .expand f xs b => + p.findFunction? f.name = some f ∧ f.name ∈ inlineNames ∧ b.source = f.body ∧ + hasScope (f.params.map Prod.fst) b.target = true ∧ b.Safe p inlineNames ∧ + ∀ x ∈ xs, x.Safe p inlineNames + | .matchValue x arms => x.Safe p inlineNames ∧ ∀ a ∈ arms, a.2.Safe p inlineNames +termination_by t => sizeOf t +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +def Tree.safe [DecidableEq F] (p : Aiur.Program F) (names : List String) : Tree F → Bool + | .literal _ | .var _ => true + | .tuple xs | .construct _ _ xs => (xs.map (Tree.safe p names)).all id + | .project x _ | .store x | .load x | .hint _ x channel | .neg x => x.safe p names + | .binary _ x y | .assertEq _ x y | .letValue _ x y => x.safe p names && y.safe p names + | .call n xs => decide (n ∉ names) && (xs.map (Tree.safe p names)).all id + | .expand f xs b => decide (p.findFunction? f.name = some f) && decide (f.name ∈ names) && + decide (b.source = f.body) && hasScope (f.params.map Prod.fst) b.target && + b.safe p names && (xs.map (Tree.safe p names)).all id + | .matchValue x arms => x.safe p names && (arms.map fun a => a.2.safe p names).all id +termination_by t => sizeOf t +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +theorem Tree.safe_iff [DecidableEq F] (p : Aiur.Program F) (names : List String) (t : Tree F) : + t.safe p names = true ↔ t.Safe p names := by + have sub (x : Tree F) (smaller : sizeOf x < sizeOf t) : + x.safe p names = true ↔ x.Safe p names := Tree.safe_iff p names x + have items (xs : List (Tree F)) (small : ∀ x ∈ xs, sizeOf x < sizeOf t) : + (xs.map (Tree.safe p names)).all id = true ↔ ∀ x ∈ xs, x.Safe p names := by + simp only [List.all_map,List.all_eq_true,Function.comp_def,id_eq] + exact forall_congr' fun x => forall_congr' fun hx => sub x (small x hx) + cases t with + | literal | var => simp [Tree.safe,Tree.Safe] + | tuple xs | construct _ _ xs => + simp only [Tree.safe,Tree.Safe] + exact items xs (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega) + | project x _ | store x | load x | hint _ x channel | neg x => + simp only [Tree.safe,Tree.Safe] + exact sub x (by simp_wf; try omega) + | binary _ x y | assertEq _ x y | letValue _ x y => + simp only [Tree.safe,Tree.Safe,Bool.and_eq_true] + exact and_congr (sub x (by simp_wf; omega)) (sub y (by simp_wf; omega)) + | call n xs => + simp only [Tree.safe,Tree.Safe,Bool.and_eq_true,decide_eq_true_eq] + exact and_congr Iff.rfl (items xs (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega)) + | expand f xs b => + simp only [Tree.safe,Tree.Safe,Bool.and_eq_true,decide_eq_true_eq,and_assoc] + rw [sub b (by simp_wf; omega), items xs (by intros; simp_wf; have := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega)] + | matchValue x arms => + simp only [Tree.safe,Tree.Safe,Bool.and_eq_true] + apply and_congr (sub x (by simp_wf; omega)) + simp only [List.all_map,List.all_eq_true,Function.comp_def,id_eq] + exact forall_congr' fun a => forall_congr' fun ha => + sub a.2 (by simp_wf; have := List.sizeOf_lt_of_mem ha; cases a; simp_all only [Prod.mk.sizeOf_spec]; omega) +termination_by sizeOf t +decreasing_by exact smaller + +instance [DecidableEq F] (p : Aiur.Program F) (names : List String) (t : Tree F) : Decidable (t.Safe p names) := + decidable_of_iff (t.safe p names = true) (Tree.safe_iff p names t) + +/-- Record enough static types to reflect an erased call's parameter checks. +All tests concern finite syntax; no semantic property is decided here. -/ +def Tree.checkTypes (q : Aiur.Program F) (locals : List (String × Aiur.Ty)) (tree : Tree F) : Option Aiur.Ty := do + let type ← (inferType q "$inline" locals tree.target).toOption + let checks : Option Unit := match tree with + | .literal _ | .var _ => some () + | .tuple xs | .construct _ _ xs | .call _ xs => (xs.mapM (Tree.checkTypes q locals)).map fun _ => () + | .project x _ | .store x | .load x | .hint _ x channel | .neg x => (x.checkTypes q locals).map fun _ => () + | .binary _ x y | .assertEq _ x y => do + let _ ← x.checkTypes q locals + let _ ← y.checkTypes q locals + some () + | .letValue p x b => do + let type ← x.checkTypes q locals + let bs ← (checkPattern q.enums "$inline" p type).toOption + let _ ← b.checkTypes q (bs ++ locals) + some () + | .expand f xs b => do + let types ← xs.mapM (Tree.checkTypes q locals) + if types ≠ f.params.map Prod.snd then none else do + let _ ← b.checkTypes q f.params + some () + | .matchValue x arms => do + let type ← x.checkTypes q locals + let _ ← arms.mapM fun (a : Aiur.Pattern F × Tree F) => do + let bs ← (checkPattern q.enums "$inline" a.1 type).toOption + a.2.checkTypes q (bs ++ locals) + some () + checks.map (fun _ => type) +termination_by sizeOf tree +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +def expand (p : Aiur.Program F) (names : List String) (depth : Nat) (expr : Aiur.Expr F) : Except String (Tree F) := do + match expr with + | .literal x => return .literal x + | .var n => return .var n + | .tuple xs => return .tuple (← xs.mapM (expand p names depth)) + | .construct n c xs => return .construct n c (← xs.mapM (expand p names depth)) + | .project x i => return .project (← expand p names depth x) i + | .store x => return .store (← expand p names depth x) + | .load x => return .load (← expand p names depth x) + | .hint t x channel => return .hint t (← expand p names depth x) channel + | .neg x => return .neg (← expand p names depth x) + | .binary op x y => return .binary op (← expand p names depth x) (← expand p names depth y) + | .assertEq op x y => return .assertEq op (← expand p names depth x) (← expand p names depth y) + | .letValue pat x b => return .letValue pat (← expand p names depth x) (← expand p names depth b) + | .matchValue x arms => + let value ← expand p names depth x + let branches ← arms.mapM fun a => return (a.1, ← expand p names depth a.2) + return .matchValue value branches + | .call n xs => + let args ← xs.mapM (expand p names depth) + if !names.contains n then return .call n args + let some callee := p.findFunction? n | throw s!"unknown inline function '{n}'" + match depth with + | 0 => throw s!"inline cycle through '{n}'" + | depth + 1 => return .expand callee args (← expand p names depth callee.body) +termination_by (depth, sizeOf expr) +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; first | omega | cases ‹_ × _›; simp_all only [Prod.mk.sizeOf_spec]; omega + +end Aiur.Inlining diff --git a/Aiur/Aiur/InputTypes.lean b/Aiur/Aiur/InputTypes.lean new file mode 100644 index 000000000..7187c34ee --- /dev/null +++ b/Aiur/Aiur/InputTypes.lean @@ -0,0 +1,150 @@ +import Aiur.Tables +import Aiur.DeclarationFacts + +namespace Aiur + +/-- Type-wide pointer freedom implies value-level pointer freedom for every well-typed value. -/ +theorem Layout.Describes.pointerFree {decls : Declarations} {layout : Layout} {type : Ty} + (described : layout.Describes decls type) {value : Value F A} + (free : layout.pointerFree = true) (typed : value.hasType decls type = true) : + value.pointerFree = true := by + refine Layout.Describes.rec + (motive_1 := fun layout type _ => ∀ value : Value F A, + layout.pointerFree = true → value.hasType decls type = true → value.pointerFree = true) + (motive_2 := fun layouts types _ => ∀ values : List (Value F A), + (∀ layout ∈ layouts, layout.pointerFree = true) → + values.map Value.type = types → (∀ value ∈ values, value.wellFormed decls = true) → + ∀ value ∈ values, value.pointerFree = true) + (motive_3 := fun layouts ctors _ => ∀ name (values : List (Value F A)) ctor, + ctors.find? (·.name == name) = some ctor → + (∀ pair ∈ layouts, pair.2.pointerFree = true) → + values.map Value.type = ctor.fields → (∀ value ∈ values, value.wellFormed decls = true) → + ∀ value ∈ values, value.pointerFree = true) + ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ described value free typed + · intro value _ typed + cases value <;> simp_all [Value.hasType, Value.type, Value.pointerFree] + · intro target value free _; simp [Layout.pointerFree] at free + · intro layouts types related ih value free typed + cases value with + | field | ptr | construct => simp [Value.hasType, Value.type] at typed + | tuple values => + simp only [Value.hasType, Value.type, Ty.tuple.injEq, Bool.and_eq_true, + decide_eq_true_eq, Value.wellFormed, List.all_map, List.all_eq_true] at typed + simpa [Value.pointerFree] using ih values + (by simpa [Layout.pointerFree] using free) typed.1 typed.2 + · intro name definition constructors found related ih value free typed + cases value with + | field | ptr | tuple => simp [Value.hasType, Value.type] at typed + | construct name ctor values => + simp only [Value.hasType, Value.type, Ty.enum.injEq, Bool.and_eq_true, + decide_eq_true_eq] at typed + obtain ⟨rfl, formed⟩ := typed + simp only [Value.wellFormed, Declarations.findConstructor?, found] at formed + split at formed + · cases formed + · rename_i definition selected + simp only [Bool.and_eq_true, decide_eq_true_eq, List.all_map, + List.all_eq_true] at formed + simpa [Value.pointerFree] using ih ctor values definition selected + (by simpa [Layout.pointerFree] using free) formed.1 formed.2 + · intro values _ typed _ + have empty : values = [] := List.map_eq_nil_iff.mp typed + simp [empty] + · intro layout type layouts types head tail headIH tailIH values free typed formed + cases values with + | nil => simp at typed + | cons value values => + simp only [List.map_cons, List.cons.injEq] at typed + have h := headIH value (free layout (by simp)) + (by simp [Value.hasType, typed.1, formed value (by simp)]) + have t := tailIH values (fun l hl => free l (by simp [hl])) typed.2 + (fun v hv => formed v (by simp [hv])) + simpa using And.intro h t + · simp + · intro ctorName layout layouts ctors definition same head tail headIH tailIH name values ctor selected free + typed formed + subst ctorName + simp only [List.find?_cons] at selected + split at selected + · cases selected + have h := headIH (.tuple values) (free (definition.name, layout) (by simp)) + (by simpa [Value.hasType, Value.type, Value.wellFormed, typed] using formed) + simpa [Value.pointerFree] using h + · exact tailIH name values ctor selected (fun p hp => free p (by simp [hp])) typed formed + +theorem Value.pointerFree_of_type {decls : Declarations} {value : Value F A} + (free : value.type.pointerFree decls = true) (formed : value.wellFormed decls = true) : + value.pointerFree = true := by + unfold Ty.pointerFree at free + cases expanded : decls.layout value.type with + | error error => simp [expanded] at free + | ok layout => + exact (Declarations.layout_describes expanded).pointerFree + (by simpa [expanded] using free) (by simp [Value.hasType, formed]) + +theorem prepareCall_signature [DecidableEq F] {program : Program F} {name : String} + {args : List (Value F A)} {locals : Environment F A} {expr : Expr F} + (prepared : prepareCall program name args = .ok (locals, expr)) : + ∃ signature, program.findSignature? name = some signature ∧ + signature.params.map Prod.snd = args.map Value.type ∧ + ∀ value ∈ args, value.wellFormed program.enums = true := by + rcases prepareCall_spec prepared with function | table + · obtain ⟨fn, found, types, formed, _, _⟩ := function + exact ⟨_, Program.signature_of_function found, types, formed⟩ + · obtain ⟨_, absent, looked, _, _⟩ := table + obtain ⟨map, _, found, types, formed, _⟩ := lookupMap_spec looked + exact ⟨_, Program.signature_of_map absent found, types, formed⟩ + +theorem prepareCall_publicArguments [DecidableEq F] {program : Program F} {name : String} + {args : List (Value F A)} {locals : Environment F A} {expr : Expr F} + (entry : checkEntry program name = .ok ()) + (prepared : prepareCall program name args = .ok (locals, expr)) : + ∀ value ∈ args, value.type.pointerFree program.enums = true ∧ value.wellFormed program.enums = true := by + obtain ⟨signature, found, types, formed⟩ := prepareCall_signature prepared + obtain ⟨other, checked, free⟩ := (checkEntry_ok program name).mp entry + have same := Option.some.inj (found.symm.trans checked) + subst other + rw [types] at free + exact fun value member => ⟨free _ (List.mem_map.mpr ⟨value, member, rfl⟩), formed value member⟩ + +theorem prepareCall_entry [DecidableEq F] {program : Program F} {name : String} + {args : List (Value F A)} {locals : Environment F A} {expr : Expr F} + (prepared : prepareCall program name args = .ok (locals, expr)) + (free : ∀ value ∈ args, value.type.pointerFree program.enums = true) : + checkEntry program name = .ok () := by + obtain ⟨signature, found, types, _⟩ := prepareCall_signature prepared + apply (checkEntry_ok program name).mpr + refine ⟨signature, found, ?_⟩ + simpa [types] using free + +theorem EvalFn.publicArguments [Field F] [DecidableEq F] {program : Program F} {name : String} + {args : List (SourceValue F)} {before after : Heap F} {value : SourceValue F} + (evaluated : EvalFn program name args before value after) (entry : checkEntry program name = .ok ()) : + ∀ value ∈ args, value.type.pointerFree program.enums = true ∧ value.wellFormed program.enums = true := by + cases evaluated with + | intro prepared _ => exact prepareCall_publicArguments entry prepared + +theorem EvalFn.public_pointerFree [Field F] [DecidableEq F] {program : Program F} {name : String} + {args : List (SourceValue F)} {before after : Heap F} {value : SourceValue F} + (evaluated : EvalFn program name args before value after) (entry : checkEntry program name = .ok ()) : + ∀ value ∈ args, value.pointerFree = true := by + intro value member + have valid := evaluated.publicArguments entry value member + exact Value.pointerFree_of_type valid.1 valid.2 + +theorem ROMEvalCall.publicArguments [Field F] [DecidableEq F] {program : Program F} {name : String} + {args : List (Value F)} {value : Value F} {rom : ROM F} + (evaluated : ROMEvalCall rom program name args value) (entry : checkEntry program name = .ok ()) : + ∀ value ∈ args, value.type.pointerFree program.enums = true ∧ value.wellFormed program.enums = true := by + cases evaluated with + | intro prepared _ => exact prepareCall_publicArguments entry prepared + +theorem ROMEvalCall.entry_of_publicArguments [Field F] [DecidableEq F] + {program : Program F} {name : String} {args : List (Value F)} {value : Value F} {rom : ROM F} + (evaluated : ROMEvalCall rom program name args value) + (free : ∀ value ∈ args, value.type.pointerFree program.enums = true) : + checkEntry program name = .ok () := by + cases evaluated with + | intro prepared _ => exact prepareCall_entry prepared free + +end Aiur diff --git a/Aiur/Aiur/LayoutComposition.lean b/Aiur/Aiur/LayoutComposition.lean new file mode 100644 index 000000000..445001790 --- /dev/null +++ b/Aiur/Aiur/LayoutComposition.lean @@ -0,0 +1,56 @@ +import Aiur.EncodingTypes +import Aiur.LayoutUnique + +namespace Aiur + +theorem forIn_success {action : α → Except ε Unit} {items : List α} + (checked : ∀ item ∈ items, action item = .ok ()) : + (do for item in items do action item : Except ε Unit) = .ok () := by + induction items with + | nil => rfl + | cons item items ih => + simpa [List.forIn_cons, checked item (by simp), bind, Except.bind, pure, Except.pure] using + ih (fun x h => checked x (by simp [h])) + +theorem mapM_ok_of_forall₂ {action : α → Except ε β} {items : List α} {values : List β} + (related : List.Forall₂ (fun item value => action item = .ok value) items values) : + items.mapM action = .ok values := by + induction related with + | nil => rfl + | cons head tail ih => simp [List.mapM_cons, head, ih, bind, Except.bind, pure, Except.pure] + +theorem Declarations.layout_parts {decls : Declarations} {ty : Ty} {layout : Layout} + (expanded : decls.layout ty = .ok layout) : + ty.checkNames decls = .ok () ∧ decls.expand (decls.length + 1) ty = .ok layout := by + unfold Declarations.layout at expanded + obtain ⟨⟨⟩, names, inner⟩ := except_bind_ok.mp expanded + exact ⟨names, inner⟩ + +theorem Declarations.layout_field (decls : Declarations) : decls.layout .field = .ok .field := by + simp [Declarations.layout, Ty.checkNames, Declarations.expand, Ty.layoutWith, bind, Except.bind] + +theorem Declarations.layout_ptr {decls : Declarations} {target : Ty} + (names : target.checkNames decls = .ok ()) : decls.layout (.ptr target) = .ok (.ptr target) := by + simp [Declarations.layout, Ty.checkNames, names, Declarations.expand, Ty.layoutWith, bind, Except.bind] + +/-- Tuple composition preserves each component's independently computed inline layout. -/ +theorem Declarations.layout_tuple {decls : Declarations} {types : List Ty} {layouts : List Layout} + (related : List.Forall₂ (fun ty layout => decls.layout ty = .ok layout) types layouts) : + decls.layout (.tuple types) = .ok (.tuple layouts) := by + have names : ∀ ty ∈ types, ty.checkNames decls = .ok () := by + induction related with + | nil => simp + | cons head tail ih => simpa using And.intro (Declarations.layout_parts head).1 ih + have expanded : List.Forall₂ + (fun ty layout => decls.expand (decls.length + 1) ty = .ok layout) types layouts := + related.imp (fun _ _ h => (Declarations.layout_parts h).2) + have expansion := mapM_ok_of_forall₂ expanded + have checked : (Ty.tuple types).checkNames decls = .ok () := by + simpa only [Ty.checkNames] using forIn_success names + simp only [Declarations.expand] at expansion + simp only [Declarations.layout, checked, bind, Except.bind] + simp only [Declarations.expand, Ty.layoutWith] + rw [expansion] + rfl + +end Aiur diff --git a/Aiur/Aiur/LayoutShape.lean b/Aiur/Aiur/LayoutShape.lean new file mode 100644 index 000000000..b122be307 --- /dev/null +++ b/Aiur/Aiur/LayoutShape.lean @@ -0,0 +1,35 @@ +import Aiur.DeclarationFacts + +namespace Aiur + +/-- Every constructor payload is a tuple layout, recursively through inline enums. -/ +def Layout.TuplePayloads : Layout → Prop + | .field | .ptr _ => True + | .tuple layouts => ∀ layout ∈ layouts, layout.TuplePayloads + | .enum _ constructors => ∀ pair ∈ constructors, + (∃ layouts, pair.2 = .tuple layouts) ∧ pair.2.TuplePayloads +termination_by layout => sizeOf layout +decreasing_by + all_goals simp_wf + all_goals + have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + first | omega | cases ‹String × Layout›; simp_all only [Prod.mk.sizeOf_spec]; omega + +theorem Layout.Describes.tuple_shape {decls : Declarations} {layout : Layout} {types : List Ty} + (described : layout.Describes decls (.tuple types)) : ∃ layouts, layout = .tuple layouts := by + cases described with + | tuple => exact ⟨_, rfl⟩ + +theorem Layout.Describes.tuplePayloads {decls : Declarations} {layout : Layout} {ty : Ty} + (described : layout.Describes decls ty) : layout.TuplePayloads := by + induction described using Layout.Describes.rec + (motive_2 := fun layouts _ _ => ∀ layout ∈ layouts, layout.TuplePayloads) + (motive_3 := fun constructors _ _ => ∀ pair ∈ constructors, + (∃ layouts, pair.2 = .tuple layouts) ∧ pair.2.TuplePayloads) <;> + simp_all [Layout.TuplePayloads] + all_goals first + | assumption + | exact ⟨Layout.Describes.tuple_shape ‹Layout.Describes _ _ (.tuple _)›, by assumption⟩ + | aesop + +end Aiur diff --git a/Aiur/Aiur/LayoutUnique.lean b/Aiur/Aiur/LayoutUnique.lean new file mode 100644 index 000000000..76236baab --- /dev/null +++ b/Aiur/Aiur/LayoutUnique.lean @@ -0,0 +1,36 @@ +import Aiur.DeclarationFacts + +namespace Aiur + +/-- Successful finite unfoldings of the same nominal type have the same layout. -/ +theorem Layout.Describes.unique {decls : Declarations} {layout : Layout} {ty : Ty} + (described : layout.Describes decls ty) {other : Layout} + (also : other.Describes decls ty) : layout = other := by + have all : ∀ other, other.Describes decls ty → layout = other := by + refine Layout.Describes.rec + (motive_1 := fun layout ty _ => ∀ other, Layout.Describes decls other ty → layout = other) + (motive_2 := fun layouts types _ => ∀ others, LayoutsDescribe decls others types → layouts = others) + (motive_3 := fun layouts ctors _ => ∀ others, ConstructorsDescribe decls others ctors → layouts = others) + ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ described + · intro other related; cases related; rfl + · intro target other related; cases related; rfl + · intro layouts types related ih other also + cases also with + | tuple more => rw [ih _ more] + · intro name definition constructors found related ih other also + cases also with + | enum found' more => + have same := Option.some.inj (found.symm.trans found') + subst same + rw [ih _ more] + · intro others related; cases related; rfl + · intro layout type layouts types head tail h t others related + cases related with + | cons head' tail' => rw [h _ head', t _ tail'] + · intro others related; cases related; rfl + · intro name layout layouts ctors ctor same head tail h t others related + cases related with + | cons same' head' tail' => rw [same, same', h _ head', t _ tail'] + exact all other also + +end Aiur diff --git a/Aiur/Aiur/LayoutValidation.lean b/Aiur/Aiur/LayoutValidation.lean new file mode 100644 index 000000000..7cd70c69f --- /dev/null +++ b/Aiur/Aiur/LayoutValidation.lean @@ -0,0 +1,160 @@ +import Aiur.WireCanonical +import Mathlib.Algebra.BigOperators.Group.List.Basic + +namespace Aiur + +/-- The field values of the exact tag tests, in declaration order. -/ +def tagTests [Zero F] [One F] [NatCast F] [DecidableEq F] : Nat → F → Nat → List F + | 0, _, _ => [] + | count + 1, tag, start => (if tag = (start : F) then 1 else 0) :: tagTests count tag (start + 1) + +mutual + /-- Semantic conditions enforced by the enum validation gadget. -/ + def Layout.Admissible [Field F] [DecidableEq F] : Layout → List F → Prop + | .field, [_] | .ptr _, [_] => True + | .tuple layouts, words => Layout.AdmissibleList layouts words + | .enum _ constructors, words => + match Layout.enumParts constructors.length ((0 : Nat) : F) words with + | none => False + | some (tag, payload) => + payload.length = Layout.payloadWidth constructors ∧ + (tagTests constructors.length tag 0).sum = 1 ∧ + Layout.AdmissibleConstructors constructors tag payload 0 + | _, _ => False + termination_by layout _ => sizeOf layout + + def Layout.AdmissibleList [Field F] [DecidableEq F] : List Layout → List F → Prop + | [], [] => True + | layout :: layouts, words => + layout.Admissible (words.take layout.width) ∧ + Layout.AdmissibleList layouts (words.drop layout.width) + | [], _ :: _ => False + termination_by layouts _ => sizeOf layouts + + def Layout.AdmissibleConstructors [Field F] [DecidableEq F] : + List (String × Layout) → F → List F → Nat → Prop + | [], _, _, _ => True + | (_, layout) :: constructors, tag, payload, start => + (tag = (start : F) → layout.Admissible (payload.take layout.width) ∧ + ∀ word ∈ payload.drop layout.width, word = 0) ∧ + Layout.AdmissibleConstructors constructors tag payload (start + 1) + termination_by constructors _ _ _ => sizeOf constructors +end + +private theorem absent_tests [Field F] [DecidableEq F] {tag : F} {count start : Nat} + (absent : ∀ i, start ≤ i → i < start + count → tag ≠ (i : F)) : + tagTests count tag start = List.replicate count 0 := by + induction count generalizing start with + | zero => rfl + | succ count ih => + have different := absent start le_rfl (by omega) + simp only [tagTests, different, ↓reduceIte, List.replicate_succ] + rw [ih (fun i lo hi => absent i (by omega) (by omega))] + +private theorem absent_constructors [Field F] [DecidableEq F] + {constructors : List (String × Layout)} {tag : F} {payload : List F} {start : Nat} + (absent : ∀ i, start ≤ i → i < start + constructors.length → tag ≠ (i : F)) : + Layout.AdmissibleConstructors constructors tag payload start := by + induction constructors generalizing start with + | nil => simp [Layout.AdmissibleConstructors] + | cons pair rest ih => + rcases pair with ⟨name, layout⟩ + simp only [Layout.AdmissibleConstructors] + exact ⟨fun same => (absent start le_rfl (by simp) same).elim, + ih (fun i lo hi => absent i (by omega) (by simp only [List.length_cons]; omega))⟩ + +mutual + theorem Layout.decode_admissible [Field F] [DecidableEq F] {layout : Layout} + (safe : layout.TagSafe F) {words : List F} {value : Value F} + (decoded : layout.decode words = some value) : layout.Admissible words := by + cases layout with + | field => cases words with + | nil => simp [Layout.decode] at decoded + | cons word rest => cases rest with + | nil => simp [Layout.Admissible] + | cons => simp [Layout.decode] at decoded + | ptr target => cases words with + | nil => simp [Layout.decode] at decoded + | cons word rest => cases rest with + | nil => simp [Layout.Admissible] + | cons => simp [Layout.decode] at decoded + | tuple layouts => + simp only [Layout.decode] at decoded + obtain ⟨values, inner, _⟩ := Option.bind_eq_some_iff.mp decoded + simp only [Layout.Admissible] + exact Layout.decodeList_admissible (by simpa only [Layout.TagSafe] using safe) inner + | enum name constructors => + simp only [Layout.decode] at decoded + obtain ⟨⟨tag, payload⟩, parts, decoded⟩ := Option.bind_eq_some_iff.mp decoded + split at decoded + · rename_i width + obtain ⟨pair, inner, _⟩ := Option.bind_eq_some_iff.mp decoded + simp only [Layout.TagSafe] at safe + simp only [Layout.Admissible, parts] + exact ⟨width, Layout.decodeConstructor_admissible safe.1 safe.2 inner⟩ + · cases decoded + termination_by sizeOf layout + + theorem Layout.decodeList_admissible [Field F] [DecidableEq F] {layouts : List Layout} + (safe : ∀ layout ∈ layouts, layout.TagSafe F) {words : List F} {values : List (Value F)} + (decoded : Layout.decodeList layouts words = some values) : Layout.AdmissibleList layouts words := by + cases layouts with + | nil => cases words <;> simp_all [Layout.decodeList, Layout.AdmissibleList] + | cons layout layouts => + simp only [Layout.decodeList] at decoded + obtain ⟨value, headRun, rest⟩ := Option.bind_eq_some_iff.mp decoded + obtain ⟨values, tailRun, _⟩ := Option.bind_eq_some_iff.mp rest + simp only [Layout.AdmissibleList] + exact ⟨Layout.decode_admissible (safe _ (by simp)) headRun, + Layout.decodeList_admissible (fun l h => safe l (by simp [h])) tailRun⟩ + termination_by sizeOf layouts + + theorem Layout.decodeConstructor_admissible [Field F] [DecidableEq F] + {constructors : List (String × Layout)} {tag : F} {payload : List F} {start : Nat} + (tags : TagsDistinct F start constructors.length) + (safe : ∀ pair ∈ constructors, pair.2.TagSafe F) {value : String × List (Value F)} + (decoded : Layout.decodeConstructor constructors tag payload start = some value) : + (tagTests constructors.length tag start).sum = 1 ∧ + Layout.AdmissibleConstructors constructors tag payload start := by + cases constructors with + | nil => simp [Layout.decodeConstructor] at decoded + | cons pair rest => + rcases hpair : pair with ⟨name, layout⟩ + rw [hpair] at decoded tags safe + simp only [Layout.decodeConstructor] at decoded + split at decoded + · rename_i selected + obtain ⟨result, payloadRun, finished⟩ := Option.bind_eq_some_iff.mp decoded + cases result with + | field | ptr | construct => cases finished + | tuple args => + dsimp only at finished + split at finished + · rename_i zeroPadding + have absent : ∀ i, start + 1 ≤ i → i < start + 1 + rest.length → tag ≠ (i : F) := by + intro i lo hi same + have equal := tags start i (by omega) (by simp) (by omega) + (by simp only [List.length_cons]; omega) (selected.symm.trans same) + omega + simp only [Layout.AdmissibleConstructors] + refine ⟨?_, ?_⟩ + · simp only [List.length_cons, tagTests, selected, ↓reduceIte] + have tailZero := absent_tests absent + rw [selected] at tailZero + simp [tailZero] + · exact ⟨fun _ => ⟨Layout.decode_admissible (safe (name, layout) (by simp)) payloadRun, + by simpa using zeroPadding⟩, absent_constructors absent⟩ + · cases finished + · rename_i notSelected + obtain ⟨sum, acceptable⟩ := Layout.decodeConstructor_admissible tags.tail + (fun p h => safe p (by simp [h])) decoded + simp only [Layout.AdmissibleConstructors] + exact ⟨by simpa [tagTests, notSelected] using sum, + ⟨fun h => (notSelected h).elim, acceptable⟩⟩ + termination_by sizeOf constructors + decreasing_by + all_goals simp_all only [List.cons.sizeOf_spec, Prod.mk.sizeOf_spec] + all_goals omega +end + +end Aiur diff --git a/Aiur/Aiur/Library/Blake3.lean b/Aiur/Aiur/Library/Blake3.lean new file mode 100644 index 000000000..f6a3232d9 --- /dev/null +++ b/Aiur/Aiur/Library/Blake3.lean @@ -0,0 +1,472 @@ +import Aiur.Library.U32 +import Aiur.Library.U64 +import Aiur.Library.List +import Aiur.Library.Field +import Aiur.Library.Bytes + +/-! Shared Blake3 implementation, extracted from the audited IxVM port. +Inputs are finite lists of checked bytes. Ingress must establish finiteness for +untrusted memory; internally constructed lists preserve it. -/ +namespace Aiur.Library.Blake3 +open Aiur + +def dependencies : Modules.Program Nat := + U32.templates.append U64.declarations |>.append List.declarations |>.append Field.declarations + |>.append Bytes.declarations + +def declarations : Modules.Program Nat := aiur_library% dependencies r#" +module Blake3 { + type U8 = UInt8::U8; + type U32 = UInt32::U32; + type U64 = UInt64::U64; + type ByteStream = Bytes::Stream; + type Digest = [U32; 8]; + enum LayerNode { Push(Layer, Digest), Nil } + type Layer = &LayerNode; + enum MaybeDigest { None, Some(Digest) } + inline fn iv() -> [U32; 8] { + [ + UInt32::from_bytes([UInt8::BYTE_103, UInt8::BYTE_230, UInt8::BYTE_9, UInt8::BYTE_106]), + UInt32::from_bytes([UInt8::BYTE_133, UInt8::BYTE_174, UInt8::BYTE_103, UInt8::BYTE_187]), + UInt32::from_bytes([UInt8::BYTE_114, UInt8::BYTE_243, UInt8::BYTE_110, UInt8::BYTE_60]), + UInt32::from_bytes([UInt8::BYTE_58, UInt8::BYTE_245, UInt8::BYTE_79, UInt8::BYTE_165]), + UInt32::from_bytes([UInt8::BYTE_127, UInt8::BYTE_82, UInt8::BYTE_14, UInt8::BYTE_81]), + UInt32::from_bytes([UInt8::BYTE_140, UInt8::BYTE_104, UInt8::BYTE_5, UInt8::BYTE_155]), + UInt32::from_bytes([UInt8::BYTE_171, UInt8::BYTE_217, UInt8::BYTE_131, UInt8::BYTE_31]), + UInt32::from_bytes([UInt8::BYTE_25, UInt8::BYTE_205, UInt8::BYTE_224, UInt8::BYTE_91]) + ] + } + + inline fn hash(input: ByteStream) -> [U32; 8] { + let IV = iv(); + compress_layer(compress_chunks(input, &(Lists::Node::Nil), 0, 0, &([UInt8::BYTE_0; 8]), &(IV), &(LayerNode::Nil))) + } + + fn verify_bytes_against(bytes: ByteStream, expected: [U8; 32]) -> () { + let h = hash(bytes); + assert_eq!(address_to_fields( + digest_bytes(h)), + address_to_fields(expected), + "hash of the supplied bytes != the address they were fetched under"); + } + + fn bytes_to_addr(bytes: ByteStream) -> &[U8; 32] { + let h = hash(bytes); + &(digest_bytes(h)) + } + + fn next_layer(layer: Layer, digest: [U32; 8], root: Field) -> (MaybeDigest, Layer) { + match *(layer) { + LayerNode::Nil => { (MaybeDigest::Some(digest), layer) }, + LayerNode::Push(layer, other) => { + let (last, new_layer) = next_layer(layer, other, 0); + match last { + MaybeDigest::None => { (MaybeDigest::Some(digest), new_layer) }, + MaybeDigest::Some(last) => { + let PARENT = 4; + let ROOT = 8; + let IV = iv(); + let [x0, x1, x2, x3, x4, x5, x6, x7] = last; + let [x8, x9, x10, x11, x12, x13, x14, x15] = digest; + let blocks = [x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15]; + match *(new_layer) { + LayerNode::Nil => { + let flags = PARENT + ROOT * root; + let digest = compress_init(IV, blocks, [UInt8::BYTE_0; 8], 64, flags); + (MaybeDigest::None, &(LayerNode::Push(new_layer, digest))) }, + _ => { + let flags = PARENT; + let digest = compress_init(IV, blocks, [UInt8::BYTE_0; 8], 64, flags); + (MaybeDigest::None, &(LayerNode::Push(new_layer, digest))) }, + } }, + } }, + } + } + + fn compress_layer(layer: Layer) -> [U32; 8] { + let LayerNode::Push(rest, digest) = *(layer); + match *(rest) { + LayerNode::Nil => { digest }, + _ => { + let (last, new_merkle) = next_layer(rest, digest, 1); + match last { + MaybeDigest::None => { compress_layer(new_merkle) }, + MaybeDigest::Some(last) => { compress_layer(&(LayerNode::Push(new_merkle, last))) }, + } }, + } + } + + fn compress_chunks( + input: ByteStream, + byte_acc: ByteStream, + block_index: Field, + chunk_index: Field, + chunk_count: &U64, + block_digest: &[U32; 8], + layer: Layer + ) -> Layer { + match *(input) { + + Lists::Node::Nil => { + finish(byte_acc, block_index, chunk_index, chunk_count, block_digest, layer) }, + Lists::Node::Cons(head, input) => { + let byte_acc = &(Lists::Node::Cons(head, byte_acc)); + match block_index { + 63 => { compress_block(input, byte_acc, chunk_index, chunk_count, block_digest, layer) }, + _ => { compress_chunks(input, byte_acc, block_index + 1, chunk_index + 1, chunk_count, block_digest, layer) }, + } }, + } + } + + fn bytes_to_block(byte_acc: ByteStream) -> [U32; 16] { + let Lists::Node::Cons(b63, l) = *(byte_acc); + let Lists::Node::Cons(b62, l) = *(l); + let Lists::Node::Cons(b61, l) = *(l); + let Lists::Node::Cons(b60, l) = *(l); + let Lists::Node::Cons(b59, l) = *(l); + let Lists::Node::Cons(b58, l) = *(l); + let Lists::Node::Cons(b57, l) = *(l); + let Lists::Node::Cons(b56, l) = *(l); + let Lists::Node::Cons(b55, l) = *(l); + let Lists::Node::Cons(b54, l) = *(l); + let Lists::Node::Cons(b53, l) = *(l); + let Lists::Node::Cons(b52, l) = *(l); + let Lists::Node::Cons(b51, l) = *(l); + let Lists::Node::Cons(b50, l) = *(l); + let Lists::Node::Cons(b49, l) = *(l); + let Lists::Node::Cons(b48, l) = *(l); + let Lists::Node::Cons(b47, l) = *(l); + let Lists::Node::Cons(b46, l) = *(l); + let Lists::Node::Cons(b45, l) = *(l); + let Lists::Node::Cons(b44, l) = *(l); + let Lists::Node::Cons(b43, l) = *(l); + let Lists::Node::Cons(b42, l) = *(l); + let Lists::Node::Cons(b41, l) = *(l); + let Lists::Node::Cons(b40, l) = *(l); + let Lists::Node::Cons(b39, l) = *(l); + let Lists::Node::Cons(b38, l) = *(l); + let Lists::Node::Cons(b37, l) = *(l); + let Lists::Node::Cons(b36, l) = *(l); + let Lists::Node::Cons(b35, l) = *(l); + let Lists::Node::Cons(b34, l) = *(l); + let Lists::Node::Cons(b33, l) = *(l); + let Lists::Node::Cons(b32, l) = *(l); + let Lists::Node::Cons(b31, l) = *(l); + let Lists::Node::Cons(b30, l) = *(l); + let Lists::Node::Cons(b29, l) = *(l); + let Lists::Node::Cons(b28, l) = *(l); + let Lists::Node::Cons(b27, l) = *(l); + let Lists::Node::Cons(b26, l) = *(l); + let Lists::Node::Cons(b25, l) = *(l); + let Lists::Node::Cons(b24, l) = *(l); + let Lists::Node::Cons(b23, l) = *(l); + let Lists::Node::Cons(b22, l) = *(l); + let Lists::Node::Cons(b21, l) = *(l); + let Lists::Node::Cons(b20, l) = *(l); + let Lists::Node::Cons(b19, l) = *(l); + let Lists::Node::Cons(b18, l) = *(l); + let Lists::Node::Cons(b17, l) = *(l); + let Lists::Node::Cons(b16, l) = *(l); + let Lists::Node::Cons(b15, l) = *(l); + let Lists::Node::Cons(b14, l) = *(l); + let Lists::Node::Cons(b13, l) = *(l); + let Lists::Node::Cons(b12, l) = *(l); + let Lists::Node::Cons(b11, l) = *(l); + let Lists::Node::Cons(b10, l) = *(l); + let Lists::Node::Cons(b9, l) = *(l); + let Lists::Node::Cons(b8, l) = *(l); + let Lists::Node::Cons(b7, l) = *(l); + let Lists::Node::Cons(b6, l) = *(l); + let Lists::Node::Cons(b5, l) = *(l); + let Lists::Node::Cons(b4, l) = *(l); + let Lists::Node::Cons(b3, l) = *(l); + let Lists::Node::Cons(b2, l) = *(l); + let Lists::Node::Cons(b1, l) = *(l); + let Lists::Node::Cons(b0, _) = *(l); + [ + UInt32::from_bytes([b0, b1, b2, b3]), UInt32::from_bytes([b4, b5, b6, b7]), UInt32::from_bytes([b8, b9, b10, b11]), UInt32::from_bytes([b12, b13, b14, b15]), + UInt32::from_bytes([b16, b17, b18, b19]), UInt32::from_bytes([b20, b21, b22, b23]), UInt32::from_bytes([b24, b25, b26, b27]), UInt32::from_bytes([b28, b29, b30, b31]), + UInt32::from_bytes([b32, b33, b34, b35]), UInt32::from_bytes([b36, b37, b38, b39]), UInt32::from_bytes([b40, b41, b42, b43]), UInt32::from_bytes([b44, b45, b46, b47]), + UInt32::from_bytes([b48, b49, b50, b51]), UInt32::from_bytes([b52, b53, b54, b55]), UInt32::from_bytes([b56, b57, b58, b59]), UInt32::from_bytes([b60, b61, b62, b63]) + ] + } + + fn pad_block(acc: ByteStream, n: Field) -> ByteStream { + match n { + 0 => { acc }, + _ => { pad_block(&(Lists::Node::Cons(UInt8::BYTE_0, acc)), n - 1) }, + } + } + + fn finish( + byte_acc: ByteStream, + block_index: Field, + chunk_index: Field, + chunk_count: &U64, + block_digest: &[U32; 8], + layer: Layer + ) -> Layer { + let CHUNK_START = 1; + let CHUNK_END = 2; + let ROOT = 8; + match (block_index, chunk_index) { + (0, 0) => { + match *(chunk_count) { + [UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0] => { + let flags = ROOT + CHUNK_START + CHUNK_END; + &(LayerNode::Push(layer, compress_init(*(block_digest), [UInt32::ZERO; 16], *(chunk_count), 0, flags))) }, + _ => { layer }, + } }, + (0, _) => { &(LayerNode::Push(layer, *(block_digest))) }, + (_, _) => { + let flags = CHUNK_END + UInt64::is_zero(*(chunk_count)) * ROOT + Fields::is_zero(chunk_index - block_index) * CHUNK_START; + let block = bytes_to_block(pad_block(byte_acc, 64 - block_index)); + &(LayerNode::Push(layer, compress_init(*(block_digest), block, *(chunk_count), block_index, flags))) }, + } + } + + fn compress_block( + input: ByteStream, + byte_acc: ByteStream, + chunk_index: Field, + chunk_count: &U64, + block_digest: &[U32; 8], + layer: Layer + ) -> Layer { + let CHUNK_START = 1; + let CHUNK_END = 2; + let ROOT = 8; + let block = bytes_to_block(byte_acc); + match chunk_index { + 1023 => { + let flags = ROOT * Lists::is_empty(input) * UInt64::is_zero(*(chunk_count)) + CHUNK_END; + + let IV = iv(); + let layer = &(LayerNode::Push(layer, compress_init(*(block_digest), block, *(chunk_count), 64, flags))); + compress_chunks(input, &(Lists::Node::Nil), 0, 0, &(UInt64::wrapping_succ(*(chunk_count))), &(IV), layer) }, + _ => { + let chunk_end_flag = Lists::is_empty(input) * CHUNK_END; + let root_flag = Lists::is_empty(input) * UInt64::is_zero(*(chunk_count)) * ROOT; + let chunk_start_flag = Fields::is_zero(chunk_index - 63) * CHUNK_START; + let flags = chunk_end_flag + root_flag + chunk_start_flag; + let block_digest = compress_init(*(block_digest), block, *(chunk_count), 64, flags); + compress_chunks(input, &(Lists::Node::Nil), 0, chunk_index + 1, chunk_count, &(block_digest), layer) }, + } + } + + inline fn g_function( + a: U32, + b: U32, + c: U32, + d: U32, + x: U32, + y: U32 + ) -> [U32; 4] { + let a = UInt32::add3(a, b, x); + let d = UInt32::rotr16(UInt32::xor(d, a)); + let c = UInt32::add(c, d); + let b = UInt32::xor_rotr12(b, c); + let a = UInt32::add3(a, b, y); + let d = UInt32::rotr8(UInt32::xor(d, a)); + let c = UInt32::add(c, d); + let b = UInt32::xor_rotr7(b, c); + [a, b, c, d] + } + + inline fn compress_inner_j(state: [U32; 32]) -> [U32; 32] { + let [a, b, c, d] = g_function( + state[0], state[4], state[8], state[12], state[16], state[17] + ); + let state = (state with { [0] = a }); + let state = (state with { [4] = b }); + let state = (state with { [8] = c }); + let state = (state with { [12] = d }); + + let [a, b, c, d] = g_function( + state[1], state[5], state[9], state[13], state[18], state[19] + ); + let state = (state with { [1] = a }); + let state = (state with { [5] = b }); + let state = (state with { [9] = c }); + let state = (state with { [13] = d }); + + let [a, b, c, d] = g_function( + state[2], state[6], state[10], state[14], state[20], state[21] + ); + let state = (state with { [2] = a }); + let state = (state with { [6] = b }); + let state = (state with { [10] = c }); + let state = (state with { [14] = d }); + + let [a, b, c, d] = g_function( + state[3], state[7], state[11], state[15], state[22], state[23] + ); + let state = (state with { [3] = a }); + let state = (state with { [7] = b }); + let state = (state with { [11] = c }); + let state = (state with { [15] = d }); + + let [a, b, c, d] = g_function( + state[0], state[5], state[10], state[15], state[24], state[25] + ); + let state = (state with { [0] = a }); + let state = (state with { [5] = b }); + let state = (state with { [10] = c }); + let state = (state with { [15] = d }); + + let [a, b, c, d] = g_function( + state[1], state[6], state[11], state[12], state[26], state[27] + ); + let state = (state with { [1] = a }); + let state = (state with { [6] = b }); + let state = (state with { [11] = c }); + let state = (state with { [12] = d }); + + let [a, b, c, d] = g_function( + state[2], state[7], state[8], state[13], state[28], state[29] + ); + let state = (state with { [2] = a }); + let state = (state with { [7] = b }); + let state = (state with { [8] = c }); + let state = (state with { [13] = d }); + + let [a, b, c, d] = g_function( + state[3], state[4], state[9], state[14], state[30], state[31] + ); + let state = (state with { [3] = a }); + let state = (state with { [4] = b }); + let state = (state with { [9] = c }); + let state = (state with { [14] = d }); + + state + } + + inline fn compress_init( + chaining_value: [U32; 8], + block_words: [U32; 16], + counter: U64, + block_len: Field, + flags: Field + ) -> [U32; 8] { + let IV = iv(); + let IV0 = IV[0]; + let IV1 = IV[1]; + let IV2 = IV[2]; + let IV3 = IV[3]; + + let counter_low = UInt32::from_bytes(counter[0 .. 4]); + let counter_high = UInt32::from_bytes(counter[4 .. 8]); + + let block_len_u32 = UInt32::from_bytes([UInt8::from_field(block_len), UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0]); + let flags_u32 = UInt32::from_bytes([UInt8::from_field(flags), UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0]); + let state: [U32; 32] = [ + chaining_value[0], chaining_value[1], chaining_value[2], chaining_value[3], + chaining_value[4], chaining_value[5], chaining_value[6], chaining_value[7], + IV0, IV1, IV2, IV3, + counter_low, counter_high, block_len_u32, flags_u32, + block_words[0], block_words[1], block_words[2], block_words[3], + block_words[4], block_words[5], block_words[6], block_words[7], + block_words[8], block_words[9], block_words[10], block_words[11], + block_words[12], block_words[13], block_words[14], block_words[15] + ]; + + compress(0, state) + } + + fn compress( + stage: Field, + state: [U32; 32] + ) -> [U32; 8] { + match stage { + 7 => { + let output0 = UInt32::xor(state[0], state[8]); + let output1 = UInt32::xor(state[1], state[9]); + let output2 = UInt32::xor(state[2], state[10]); + let output3 = UInt32::xor(state[3], state[11]); + let output4 = UInt32::xor(state[4], state[12]); + let output5 = UInt32::xor(state[5], state[13]); + let output6 = UInt32::xor(state[6], state[14]); + let output7 = UInt32::xor(state[7], state[15]); + [output0, output1, output2, output3, output4, output5, output6, output7] }, + _ => { + let new_state = compress_inner_j(state); + + let new_state = (new_state with { [16] = state[18] }); + let new_state = (new_state with { [17] = state[22] }); + let new_state = (new_state with { [18] = state[19] }); + let new_state = (new_state with { [19] = state[26] }); + let new_state = (new_state with { [20] = state[23] }); + let new_state = (new_state with { [21] = state[16] }); + let new_state = (new_state with { [22] = state[20] }); + let new_state = (new_state with { [23] = state[29] }); + let new_state = (new_state with { [24] = state[17] }); + let new_state = (new_state with { [25] = state[27] }); + let new_state = (new_state with { [26] = state[28] }); + let new_state = (new_state with { [27] = state[21] }); + let new_state = (new_state with { [28] = state[25] }); + let new_state = (new_state with { [29] = state[30] }); + let new_state = (new_state with { [30] = state[31] }); + let new_state = (new_state with { [31] = state[24] }); + compress(stage + 1, new_state) }, + } + } + + inline fn digest_bytes(digest: [U32; 8]) -> [U8; 32] { + let b0 = UInt32::to_bytes(digest[0]); + let b1 = UInt32::to_bytes(digest[1]); + let b2 = UInt32::to_bytes(digest[2]); + let b3 = UInt32::to_bytes(digest[3]); + let b4 = UInt32::to_bytes(digest[4]); + let b5 = UInt32::to_bytes(digest[5]); + let b6 = UInt32::to_bytes(digest[6]); + let b7 = UInt32::to_bytes(digest[7]); + [b0[0], b0[1], b0[2], b0[3], b1[0], b1[1], b1[2], b1[3], + b2[0], b2[1], b2[2], b2[3], b3[0], b3[1], b3[2], b3[3], + b4[0], b4[1], b4[2], b4[3], b5[0], b5[1], b5[2], b5[3], + b6[0], b6[1], b6[2], b6[3], b7[0], b7[1], b7[2], b7[3]] +} + + inline fn address_to_fields(bytes: [U8; 32]) -> [Field; 32] { + [UInt8::to_field(bytes[0]), UInt8::to_field(bytes[1]), UInt8::to_field(bytes[2]), UInt8::to_field(bytes[3]), UInt8::to_field(bytes[4]), UInt8::to_field(bytes[5]), UInt8::to_field(bytes[6]), UInt8::to_field(bytes[7]), UInt8::to_field(bytes[8]), UInt8::to_field(bytes[9]), UInt8::to_field(bytes[10]), UInt8::to_field(bytes[11]), UInt8::to_field(bytes[12]), UInt8::to_field(bytes[13]), UInt8::to_field(bytes[14]), UInt8::to_field(bytes[15]), UInt8::to_field(bytes[16]), UInt8::to_field(bytes[17]), UInt8::to_field(bytes[18]), UInt8::to_field(bytes[19]), UInt8::to_field(bytes[20]), UInt8::to_field(bytes[21]), UInt8::to_field(bytes[22]), UInt8::to_field(bytes[23]), UInt8::to_field(bytes[24]), UInt8::to_field(bytes[25]), UInt8::to_field(bytes[26]), UInt8::to_field(bytes[27]), UInt8::to_field(bytes[28]), UInt8::to_field(bytes[29]), UInt8::to_field(bytes[30]), UInt8::to_field(bytes[31])] +} + + inline fn address_from_fields(raw: [Field; 32]) -> [U8; 32] { + let (b0, b1) = UInt8::from_fields(raw[0], raw[1]); + let (b2, b3) = UInt8::from_fields(raw[2], raw[3]); + let (b4, b5) = UInt8::from_fields(raw[4], raw[5]); + let (b6, b7) = UInt8::from_fields(raw[6], raw[7]); + let (b8, b9) = UInt8::from_fields(raw[8], raw[9]); + let (b10, b11) = UInt8::from_fields(raw[10], raw[11]); + let (b12, b13) = UInt8::from_fields(raw[12], raw[13]); + let (b14, b15) = UInt8::from_fields(raw[14], raw[15]); + let (b16, b17) = UInt8::from_fields(raw[16], raw[17]); + let (b18, b19) = UInt8::from_fields(raw[18], raw[19]); + let (b20, b21) = UInt8::from_fields(raw[20], raw[21]); + let (b22, b23) = UInt8::from_fields(raw[22], raw[23]); + let (b24, b25) = UInt8::from_fields(raw[24], raw[25]); + let (b26, b27) = UInt8::from_fields(raw[26], raw[27]); + let (b28, b29) = UInt8::from_fields(raw[28], raw[29]); + let (b30, b31) = UInt8::from_fields(raw[30], raw[31]); + [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31] +} + +inline fn pack_word(w: UInt32::U32) -> Field { + UInt32::compact_field(UInt32::compact(w)) + } + +inline fn pack_digest(h: [UInt32::U32; 8]) -> [Field; 8] { + [pack_word(h[0]), pack_word(h[1]), pack_word(h[2]), pack_word(h[3]), + pack_word(h[4]), pack_word(h[5]), pack_word(h[6]), pack_word(h[7])] + } +} +"# + +def templates : Modules.Program Nat := + dependencies.append declarations + +def source : Modules.Program Nat := + U32.source.append U64.declarations |>.append List.declarations |>.append Field.declarations + |>.append Bytes.declarations + |>.append declarations + +end Aiur.Library.Blake3 diff --git a/Aiur/Aiur/Library/Blake3/Correctness.lean b/Aiur/Aiur/Library/Blake3/Correctness.lean new file mode 100644 index 000000000..7f5a51a9a --- /dev/null +++ b/Aiur/Aiur/Library/Blake3/Correctness.lean @@ -0,0 +1,757 @@ +import Aiur.Library.Blake3 +import Aiur.Library.U32.Correctness +import Aiur.Library.U64.Correctness + +/-! Mathematical specification and correctness proofs for the `Blake3` library +(`Aiur.Library.Blake3`). + +This module establishes: +1. Total pure BLAKE3 specifications (`iv`, `schedules`, `rotateRight`, `mix`, `g`, + `round`, `permute`, `initialWords`, `compress`, `wordBytes`, `littleEndian`, + `bytesWord`, `blockWords`, `cvBytes`, `chunkLoop`, `chunkOutput`, + `parentOutput`, `subtree`, `digest`). +2. Byte-level and word-level correctness of `Blake3`'s core compression and hashing + primitives (`iv_spec`, `rotr8_spec`, `rotr16_spec`, `xor_rotr12_spec`, + `xor_rotr7_spec`, `g_spec`, `round_spec`, `permute_spec`, `counter_split_spec`, + `compress_spec`, `pad_block_spec`, `bytes_to_block_spec`, `chunk_single_root_spec`, + `next_layer_pair_spec`, `compress_layer_two_spec`, `compress_layer_step_spec`, + `digest_bytes_spec`, `cvBytes_inj`, `address_to_fields_inj`, and + `verify_bytes_against_iff`). +-/ +namespace Aiur.Library.Blake3 + +/-! ### 1. Pure Mathematical Specification of Unkeyed 32-Byte BLAKE3 -/ + +abbrev CV := Vector UInt32 8 +abbrev Block := Vector UInt32 16 +abbrev Digest := Vector UInt8 32 + +def iv : CV := #v[ + 0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, + 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19] + +def schedules : Vector (Vector (Fin 16) 16) 7 := #v[ + #v[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], + #v[2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8], + #v[3, 4, 10, 12, 13, 2, 7, 14, 6, 5, 9, 0, 11, 15, 8, 1], + #v[10, 7, 12, 9, 14, 3, 13, 15, 4, 0, 11, 2, 5, 8, 1, 6], + #v[12, 13, 9, 11, 15, 10, 14, 8, 7, 2, 5, 3, 0, 1, 6, 4], + #v[9, 14, 11, 5, 8, 12, 15, 1, 13, 3, 0, 10, 2, 6, 4, 7], + #v[11, 15, 5, 0, 1, 9, 8, 6, 14, 10, 2, 12, 3, 4, 7, 13]] + +def rotateRight (word count : UInt32) : UInt32 := + (word >>> count) ||| (word <<< (32 - count)) + +def mix (a b c d x y : UInt32) : Vector UInt32 4 := + let a := a + b + x + let d := rotateRight (d ^^^ a) 16 + let c := c + d + let b := rotateRight (b ^^^ c) 12 + let a := a + b + y + let d := rotateRight (d ^^^ a) 8 + let c := c + d + let b := rotateRight (b ^^^ c) 7 + #v[a, b, c, d] + +def g (state : Block) (a b c d : Fin 16) (x y : UInt32) : Block := + let words := mix state[a] state[b] state[c] state[d] x y + (((state.set a words[0]).set b words[1]).set c words[2]).set d words[3] + +def round (state message : Block) (schedule : Vector (Fin 16) 16) : Block := + let state := g state 0 4 8 12 message[schedule[0]] message[schedule[1]] + let state := g state 1 5 9 13 message[schedule[2]] message[schedule[3]] + let state := g state 2 6 10 14 message[schedule[4]] message[schedule[5]] + let state := g state 3 7 11 15 message[schedule[6]] message[schedule[7]] + let state := g state 0 5 10 15 message[schedule[8]] message[schedule[9]] + let state := g state 1 6 11 12 message[schedule[10]] message[schedule[11]] + let state := g state 2 7 8 13 message[schedule[12]] message[schedule[13]] + g state 3 4 9 14 message[schedule[14]] message[schedule[15]] + +def permute (m : Block) : Block := + #v[m[2], m[6], m[3], m[10], m[7], m[0], m[4], m[13], + m[1], m[11], m[12], m[5], m[9], m[14], m[15], m[8]] + +def initialWords (cv : CV) (counter : UInt64) (blockLen flags : UInt32) : Block := + #v[cv[0], cv[1], cv[2], cv[3], cv[4], cv[5], cv[6], cv[7], + iv[0], iv[1], iv[2], iv[3], counter.toUInt32, (counter >>> 32).toUInt32, blockLen, flags] + +def finalizeState (state : Block) : CV := + Vector.ofFn fun index => state[index.val] ^^^ state[index.val + 8] + +def compress (cv : CV) (message : Block) (counter : UInt64) (blockLen flags : UInt32) : CV := + finalizeState (schedules.foldl (fun state schedule => round state message schedule) + (initialWords cv counter blockLen flags)) + +def wordBytes (word : UInt32) : Vector UInt8 4 := + Vector.ofFn fun index => (word.toNat / 256^index.val).toUInt8 + +def littleEndian (bytes : List UInt8) : Nat := + bytes.foldr (fun byte rest => byte.toNat + 256 * rest) 0 + +def bytesWord (bytes : Vector UInt8 4) : UInt32 := + UInt32.ofNat (littleEndian bytes.toList) + +def blockWords (bytes : List UInt8) : Block := + let input := bytes.toArray + Vector.ofFn fun word => bytesWord (Vector.ofFn fun byte => input[word.val * 4 + byte.val]?.getD 0) + +def cvBytes (cv : CV) : Digest := + Vector.ofFn fun index => (wordBytes cv[index.val / 4])[index.val % 4] + +structure Output where + cv : CV + block : Block + blockLen : UInt32 + counter : UInt64 + flags : UInt32 + deriving DecidableEq, Repr + +def Output.chainingValue (output : Output) : CV := + compress output.cv output.block output.counter output.blockLen output.flags + +def Output.rootHash (output : Output) : Digest := + cvBytes (compress output.cv output.block 0 output.blockLen (output.flags ||| 8)) + +def chunkLoop (counter : UInt64) (cv : CV) (start : Bool) (input : List UInt8) : Output := + if _h : input.length ≤ 64 then + ⟨cv, blockWords input, input.length.toUInt32, counter, (if start then 1 else 0) ||| 2⟩ + else + let next := compress cv (blockWords (input.take 64)) counter 64 (if start then 1 else 0) + chunkLoop counter next false (input.drop 64) +termination_by input.length +decreasing_by simp only [List.length_drop]; omega + +def chunkOutput (counter : UInt64) (input : List UInt8) : Output := + chunkLoop counter iv true input + +def parentOutput (left right : CV) : Output := + ⟨iv, left ++ right, 64, 0, 4⟩ + +def leftLen (size : Nat) : Nat := 2 ^ (size - 1).log2 + +theorem leftLen_positive (size : Nat) : 0 < leftLen size := Nat.two_pow_pos _ + +theorem leftLen_lt {size : Nat} (large : 1024 < size) : leftLen size < size := by + have := Nat.log2_self_le (n := size - 1) (by omega) + unfold leftLen + omega + +def subtree (counter : Nat) (input : List UInt8) : Output := + if _h : input.length ≤ 1024 then chunkOutput counter.toUInt64 input + else + let split := leftLen input.length + let left := subtree counter (input.take split) + let right := subtree (counter + split / 1024) (input.drop split) + parentOutput left.chainingValue right.chainingValue +termination_by input.length +decreasing_by + · have := leftLen_lt (size := input.length) (by omega) + simp only [List.length_take]; omega + · have := leftLen_positive input.length + simp only [List.length_drop]; omega + +def digest (input : List UInt8) : Digest := (subtree 0 input).rootHash + +def NativeInput (input : List UInt8) : Prop := input.length < 2^64 + +/-! ### 2. Byte / Word Packing and `iv` Specification -/ + +def wordOfBytes (b0 b1 b2 b3 : UInt8) : UInt32 := + UInt32.ofNat (U32.pack b0.toNat b1.toNat b2.toNat b3.toNat) + +theorem wordOfBytes_toNat {b0 b1 b2 b3 : UInt8} : + (wordOfBytes b0 b1 b2 b3).toNat = U32.pack b0.toNat b1.toNat b2.toNat b3.toNat := by + unfold wordOfBytes + have hlt : U32.pack b0.toNat b1.toNat b2.toNat b3.toNat < U32.base := + U32.pack_lt b0.toNat_lt b1.toNat_lt b2.toNat_lt b3.toNat_lt + simpa [U32.base] using Nat.mod_eq_of_lt hlt + +theorem bytesWord_eq_wordOfBytes (b0 b1 b2 b3 : UInt8) : + bytesWord #v[b0, b1, b2, b3] = wordOfBytes b0 b1 b2 b3 := by + apply UInt32.ext + rw [wordOfBytes_toNat] + unfold bytesWord littleEndian U32.pack + have hlt : b0.toNat + 256 * b1.toNat + 65536 * b2.toNat + 16777216 * b3.toNat < 4294967296 := by + have := b0.toNat_lt; have := b1.toNat_lt; have := b2.toNat_lt; have := b3.toNat_lt + omega + have hfold : (#v[b0, b1, b2, b3]).toList.foldr (fun byte rest => byte.toNat + 256 * rest) 0 = + b0.toNat + 256 * b1.toNat + 65536 * b2.toNat + 16777216 * b3.toNat := by + simp [Vector.toList]; omega + rw [hfold] + simpa using Nat.mod_eq_of_lt hlt + +theorem wordBytes_wordOfBytes (b0 b1 b2 b3 : UInt8) : + wordBytes (wordOfBytes b0 b1 b2 b3) = #v[b0, b1, b2, b3] := by + ext i hi + have hpack := wordOfBytes_toNat (b0 := b0) (b1 := b1) (b2 := b2) (b3 := b3) + have hb0 := b0.toNat_lt; have hb1 := b1.toNat_lt; have hb2 := b2.toNat_lt; have hb3 := b3.toNat_lt + unfold wordBytes + simp only [Vector.getElem_ofFn] + rcases (by omega : i = 0 ∨ i = 1 ∨ i = 2 ∨ i = 3) with rfl | rfl | rfl | rfl + · simp [hpack, U32.pack] + · simp [UInt8.toNat_ofNat', hpack, U32.pack]; omega + · simp [UInt8.toNat_ofNat', hpack, U32.pack]; omega + · simp [UInt8.toNat_ofNat', hpack, U32.pack]; omega + +theorem wordOfBytes_wordBytes (w : UInt32) : + wordOfBytes (wordBytes w)[0] (wordBytes w)[1] (wordBytes w)[2] (wordBytes w)[3] = w := by + apply UInt32.ext + rw [wordOfBytes_toNat] + unfold wordBytes U32.pack + simp only [Vector.getElem_ofFn, UInt8.toNat_ofNat'] + have hw := w.toNat_lt + omega + +/-- `Blake3::iv()` in `Aiur.Library.Blake3` packs to the standard 8-word BLAKE3 `iv`. -/ +theorem iv_spec : + #v[wordOfBytes 103 230 9 106, + wordOfBytes 133 174 103 187, + wordOfBytes 114 243 110 60, + wordOfBytes 58 245 79 165, + wordOfBytes 127 82 14 81, + wordOfBytes 140 104 5 155, + wordOfBytes 171 217 131 31, + wordOfBytes 25 205 224 91] = iv := by + decide + +/-! ### 3. Rotations, XOR-Rotations, and `g` Specification -/ + +theorem rotateRight_toNat (w : UInt32) {r : Nat} (hrpos : 0 < r) (hr : r < 32) : + (rotateRight w (UInt32.ofNat r)).toNat = + w.toNat / 2^r + 2^(32 - r) * (w.toNat % 2^r) := by + unfold rotateRight + have hr_mod : (UInt32.ofNat r).toNat % 32 = r := by + simp [UInt32.toNat_ofNat'] + omega + have h32r_mod : (32 - UInt32.ofNat r).toNat % 32 = 32 - r := by + have h32r : (32 - UInt32.ofNat r).toNat = 32 - r := by + change (UInt32.ofNat 32 - UInt32.ofNat r).toNat = 32 - r + rw [UInt32.toNat_sub_of_le] + · simp [UInt32.toNat_ofNat']; omega + · show (UInt32.ofNat r).toNat ≤ (UInt32.ofNat 32).toNat + simp [UInt32.toNat_ofNat']; omega + rw [h32r] + exact Nat.mod_eq_of_lt (by omega) + have hshr : (w >>> UInt32.ofNat r).toNat = w.toNat / 2^r := by + rw [UInt32.toNat_shiftRight, hr_mod, Nat.shiftRight_eq_div_pow] + have hpow_split : 2^r * 2^(32 - r) = 4294967296 := by + rw [← Nat.pow_add, Nat.add_sub_of_le (by omega)] + have hshl : (w <<< (32 - UInt32.ofNat r)).toNat = 2^(32 - r) * (w.toNat % 2^r) := by + rw [UInt32.toNat_shiftLeft, h32r_mod, Nat.shiftLeft_eq] + have hw_decomp : w.toNat * 2^(32 - r) = + 2^(32 - r) * (w.toNat % 2^r) + 4294967296 * (w.toNat / 2^r) := by + have hmad := Nat.mod_add_div w.toNat (2^r) + calc w.toNat * 2^(32 - r) + _ = (w.toNat % 2^r + 2^r * (w.toNat / 2^r)) * 2^(32 - r) := by rw [hmad] + _ = 2^(32 - r) * (w.toNat % 2^r) + (2^r * 2^(32 - r)) * (w.toNat / 2^r) := by ring + _ = 2^(32 - r) * (w.toNat % 2^r) + 4294967296 * (w.toNat / 2^r) := by rw [hpow_split] + have hrem_lt : 2^(32 - r) * (w.toNat % 2^r) < 4294967296 := by + have : w.toNat % 2^r < 2^r := Nat.mod_lt _ (Nat.two_pow_pos r) + have := Nat.mul_lt_mul_of_pos_left this (Nat.two_pow_pos (32 - r)) + linarith [hpow_split] + change (w.toNat * 2^(32 - r)) % 4294967296 = 2^(32 - r) * (w.toNat % 2^r) + rw [hw_decomp, Nat.add_mul_mod_self_left, Nat.mod_eq_of_lt hrem_lt] + have hdiv_lt : w.toNat / 2^r < 2^(32 - r) := by + rw [Nat.div_lt_iff_lt_mul (Nat.two_pow_pos r)] + linarith [w.toNat_lt, hpow_split] + rw [UInt32.toNat_or, hshr, hshl] + change Nat.bitwise or (w.toNat / 2^r) (2^(32 - r) * (w.toNat % 2^r)) = _ + have hlor := U64.bitwise_add_mul_two_pow (f := or) rfl (32 - r) + hdiv_lt (Nat.two_pow_pos (32 - r)) 0 (w.toNat % 2^r) + have hlor0 : Nat.bitwise or (w.toNat / 2^r) 0 = w.toNat / 2^r := by + rw [U64.bitwise_zero_right rfl]; rfl + have hlor0y : Nat.bitwise or 0 (w.toNat % 2^r) = w.toNat % 2^r := by + rw [U64.bitwise_zero_left rfl]; rfl + simpa [hlor0, hlor0y] using hlor + +/-- `U32::rotr8([b0, b1, b2, b3]) = [b1, b2, b3, b0]` computes `rotateRight w 8`. -/ +theorem rotr8_spec (b0 b1 b2 b3 : UInt8) : + rotateRight (wordOfBytes b0 b1 b2 b3) 8 = wordOfBytes b1 b2 b3 b0 := by + apply UInt32.ext + change (rotateRight (wordOfBytes b0 b1 b2 b3) (UInt32.ofNat 8)).toNat = _ + rw [rotateRight_toNat (wordOfBytes b0 b1 b2 b3) (r := 8) (by omega) (by omega)] + simp only [wordOfBytes_toNat] + have := b0.toNat_lt; have := b1.toNat_lt; have := b2.toNat_lt; have := b3.toNat_lt + unfold U32.pack + omega + +/-- `U32::rotr16([b0, b1, b2, b3]) = [b2, b3, b0, b1]` computes `rotateRight w 16`. -/ +theorem rotr16_spec (b0 b1 b2 b3 : UInt8) : + rotateRight (wordOfBytes b0 b1 b2 b3) 16 = wordOfBytes b2 b3 b0 b1 := by + apply UInt32.ext + change (rotateRight (wordOfBytes b0 b1 b2 b3) (UInt32.ofNat 16)).toNat = _ + rw [rotateRight_toNat (wordOfBytes b0 b1 b2 b3) (r := 16) (by omega) (by omega)] + simp only [wordOfBytes_toNat] + have := b0.toNat_lt; have := b1.toNat_lt; have := b2.toNat_lt; have := b3.toNat_lt + unfold U32.pack + omega + +/-- `U32::xor([a0, a1, a2, a3], [b0, b1, b2, b3])` computes `w1 ^^^ w2`. -/ +theorem xor_spec (a0 a1 a2 a3 b0 b1 b2 b3 : UInt8) : + (wordOfBytes a0 a1 a2 a3) ^^^ (wordOfBytes b0 b1 b2 b3) = + wordOfBytes (a0 ^^^ b0) (a1 ^^^ b1) (a2 ^^^ b2) (a3 ^^^ b3) := by + apply UInt32.ext + rw [UInt32.toNat_xor] + simp only [wordOfBytes_toNat] + change Nat.xor (U32.pack a0.toNat a1.toNat a2.toNat a3.toNat) + (U32.pack b0.toNat b1.toNat b2.toNat b3.toNat) = + U32.pack (Nat.xor a0.toNat b0.toNat) (Nat.xor a1.toNat b1.toNat) + (Nat.xor a2.toNat b2.toNat) (Nat.xor a3.toNat b3.toNat) + have step : ∀ {x y : Nat}, x < 256 → y < 256 → ∀ u v : Nat, + Nat.xor (x + 256 * u) (y + 256 * v) = Nat.xor x y + 256 * Nat.xor u v := by + intro x y hx hy u v + exact U64.bitwise_add_mul_two_pow (f := bne) rfl 8 hx hy u v + have hrew : ∀ x0 x1 x2 x3 : Nat, + U32.pack x0 x1 x2 x3 = x0 + 256 * (x1 + 256 * (x2 + 256 * x3)) := by + intros; unfold U32.pack; ring + rw [hrew a0.toNat, hrew b0.toNat, hrew (Nat.xor a0.toNat b0.toNat)] + rw [step a0.toNat_lt b0.toNat_lt, step a1.toNat_lt b1.toNat_lt, step a2.toNat_lt b2.toNat_lt] + +theorem div_mod_eq {w d q r : Nat} (hd : 0 < d) (hw : w = r + d * q) (hr : r < d) : + w / d = q ∧ w % d = r := by + subst hw + exact ⟨by rw [Nat.add_mul_div_left _ _ hd, Nat.div_eq_of_lt hr, Nat.zero_add], + by rw [Nat.add_mul_mod_self_left, Nat.mod_eq_of_lt hr]⟩ + +/-- `U32::xor_rotr12` computes `rotateRight (a ^^^ b) 12` by combining `#u8_xor_rotr4` limbs. -/ +theorem xor_rotr12_spec (a0 a1 a2 a3 b0 b1 b2 b3 : UInt8) : + let x0 := (a0 ^^^ b0).toNat + let x1 := (a1 ^^^ b1).toNat + let x2 := (a2 ^^^ b2).toNat + let x3 := (a3 ^^^ b3).toNat + let r0 := UInt8.ofNat (x1 / 16 + (x2 % 16) * 16) + let r1 := UInt8.ofNat (x2 / 16 + (x3 % 16) * 16) + let r2 := UInt8.ofNat (x3 / 16 + (x0 % 16) * 16) + let r3 := UInt8.ofNat (x0 / 16 + (x1 % 16) * 16) + rotateRight (wordOfBytes a0 a1 a2 a3 ^^^ wordOfBytes b0 b1 b2 b3) 12 = + wordOfBytes r0 r1 r2 r3 := by + dsimp only + rw [xor_spec] + apply UInt32.ext + change (rotateRight (wordOfBytes (a0 ^^^ b0) (a1 ^^^ b1) (a2 ^^^ b2) (a3 ^^^ b3)) (UInt32.ofNat 12)).toNat = _ + rw [rotateRight_toNat (wordOfBytes (a0 ^^^ b0) (a1 ^^^ b1) (a2 ^^^ b2) (a3 ^^^ b3)) (r := 12) (by omega) (by omega)] + simp only [wordOfBytes_toNat, UInt8.toNat_ofNat'] + set x0 := (a0 ^^^ b0).toNat + set x1 := (a1 ^^^ b1).toNat + set x2 := (a2 ^^^ b2).toNat + set x3 := (a3 ^^^ b3).toNat + have hx0 : x0 < 256 := (a0 ^^^ b0).toNat_lt + have hx1 : x1 < 256 := (a1 ^^^ b1).toNat_lt + have hx2 : x2 < 256 := (a2 ^^^ b2).toNat_lt + have hx3 : x3 < 256 := (a3 ^^^ b3).toNat_lt + obtain ⟨hdiv, hmod⟩ := div_mod_eq (w := U32.pack x0 x1 x2 x3) (d := 2^12) + (q := x1 / 16 + 16 * x2 + 4096 * x3) (r := x0 + 256 * (x1 % 16)) + (by omega) (by unfold U32.pack; omega) (by omega) + rw [hdiv, hmod] + unfold U32.pack + rw [Nat.mod_eq_of_lt (by omega : x1 / 16 + x2 % 16 * 16 < 256), + Nat.mod_eq_of_lt (by omega : x2 / 16 + x3 % 16 * 16 < 256), + Nat.mod_eq_of_lt (by omega : x3 / 16 + x0 % 16 * 16 < 256), + Nat.mod_eq_of_lt (by omega : x0 / 16 + x1 % 16 * 16 < 256)] + have h0 : x0 % 16 + 16 * (x0 / 16) = x0 := Nat.mod_add_div x0 16 + have h2 : x2 % 16 + 16 * (x2 / 16) = x2 := Nat.mod_add_div x2 16 + have h3 : x3 % 16 + 16 * (x3 / 16) = x3 := Nat.mod_add_div x3 16 + change x1 / 16 + 16 * x2 + 4096 * x3 + 1048576 * (x0 + 256 * (x1 % 16)) = _ + omega + +/-- `U32::xor_rotr7` computes `rotateRight (a ^^^ b) 7` by combining `#u8_xor_rotr7` limbs. -/ +theorem xor_rotr7_spec (a0 a1 a2 a3 b0 b1 b2 b3 : UInt8) : + let x0 := (a0 ^^^ b0).toNat + let x1 := (a1 ^^^ b1).toNat + let x2 := (a2 ^^^ b2).toNat + let x3 := (a3 ^^^ b3).toNat + let r0 := UInt8.ofNat (x0 / 128 + (x1 % 128) * 2) + let r1 := UInt8.ofNat (x1 / 128 + (x2 % 128) * 2) + let r2 := UInt8.ofNat (x2 / 128 + (x3 % 128) * 2) + let r3 := UInt8.ofNat (x3 / 128 + (x0 % 128) * 2) + rotateRight (wordOfBytes a0 a1 a2 a3 ^^^ wordOfBytes b0 b1 b2 b3) 7 = + wordOfBytes r0 r1 r2 r3 := by + dsimp only + rw [xor_spec] + apply UInt32.ext + change (rotateRight (wordOfBytes (a0 ^^^ b0) (a1 ^^^ b1) (a2 ^^^ b2) (a3 ^^^ b3)) (UInt32.ofNat 7)).toNat = _ + rw [rotateRight_toNat (wordOfBytes (a0 ^^^ b0) (a1 ^^^ b1) (a2 ^^^ b2) (a3 ^^^ b3)) (r := 7) (by omega) (by omega)] + simp only [wordOfBytes_toNat, UInt8.toNat_ofNat'] + set x0 := (a0 ^^^ b0).toNat + set x1 := (a1 ^^^ b1).toNat + set x2 := (a2 ^^^ b2).toNat + set x3 := (a3 ^^^ b3).toNat + have hx0 : x0 < 256 := (a0 ^^^ b0).toNat_lt + have hx1 : x1 < 256 := (a1 ^^^ b1).toNat_lt + have hx2 : x2 < 256 := (a2 ^^^ b2).toNat_lt + have hx3 : x3 < 256 := (a3 ^^^ b3).toNat_lt + obtain ⟨hdiv, hmod⟩ := div_mod_eq (w := U32.pack x0 x1 x2 x3) (d := 2^7) + (q := x0 / 128 + 2 * x1 + 512 * x2 + 131072 * x3) (r := x0 % 128) + (by omega) (by unfold U32.pack; omega) (by omega) + rw [hdiv, hmod] + unfold U32.pack + rw [Nat.mod_eq_of_lt (by omega : x0 / 128 + x1 % 128 * 2 < 256), + Nat.mod_eq_of_lt (by omega : x1 / 128 + x2 % 128 * 2 < 256), + Nat.mod_eq_of_lt (by omega : x2 / 128 + x3 % 128 * 2 < 256), + Nat.mod_eq_of_lt (by omega : x3 / 128 + x0 % 128 * 2 < 256)] + have h1 : x1 % 128 + 128 * (x1 / 128) = x1 := Nat.mod_add_div x1 128 + have h2 : x2 % 128 + 128 * (x2 / 128) = x2 := Nat.mod_add_div x2 128 + have h3 : x3 % 128 + 128 * (x3 / 128) = x3 := Nat.mod_add_div x3 128 + change x0 / 128 + 2 * x1 + 512 * x2 + 131072 * x3 + 33554432 * (x0 % 128) = _ + omega + +/-- `Blake3::g_function` computes `mix a b c d mx my`. -/ +theorem g_function_spec (a b c d mx my : UInt32) : + let a1 := a + b + mx + let d1 := rotateRight (d ^^^ a1) 16 + let c1 := c + d1 + let b1 := rotateRight (b ^^^ c1) 12 + let a2 := a1 + b1 + my + let d2 := rotateRight (d1 ^^^ a2) 8 + let c2 := c1 + d2 + let b2 := rotateRight (b1 ^^^ c2) 7 + #v[a2, b2, c2, d2] = mix a b c d mx my := by + rfl + +/-- Helper for `compressInnerJ`, indexing the 4 column and 4 diagonal `g` +applications (`Blake3::g_function`) in `Blake3::compress_inner_j`. -/ +theorem g_spec (state : Block) (j : Fin 8) (mx my : UInt32) : + (match j.val with + | 0 => g state 0 4 8 12 mx my + | 1 => g state 1 5 9 13 mx my + | 2 => g state 2 6 10 14 mx my + | 3 => g state 3 7 11 15 mx my + | 4 => g state 0 5 10 15 mx my + | 5 => g state 1 6 11 12 mx my + | 6 => g state 2 7 8 13 mx my + | _ => g state 3 4 9 14 mx my) = + let cols : Vector (Fin 16 × Fin 16 × Fin 16 × Fin 16) 8 := + #v[(0, 4, 8, 12), (1, 5, 9, 13), (2, 6, 10, 14), (3, 7, 11, 15), + (0, 5, 10, 15), (1, 6, 11, 12), (2, 7, 8, 13), (3, 4, 9, 14)] + let (a, b, c, d) := cols[j] + g state a b c d mx my := by + fin_cases j <;> rfl + +/-! ### 4. `round`, `permute`, and `compress` Specifications -/ + +/-- `Blake3::compress_inner_j` in `Aiur.Library.Blake3` applies the 8 `g_function` +steps to the 16 state words `state[0..16]` and 16 message words `state[16..32]`, +computing `round state m schedules[0]`. -/ +def compressInnerJ (state m : Block) : Block := + let state := g state 0 4 8 12 m[0] m[1] + let state := g state 1 5 9 13 m[2] m[3] + let state := g state 2 6 10 14 m[4] m[5] + let state := g state 3 7 11 15 m[6] m[7] + let state := g state 0 5 10 15 m[8] m[9] + let state := g state 1 6 11 12 m[10] m[11] + let state := g state 2 7 8 13 m[12] m[13] + g state 3 4 9 14 m[14] m[15] + +theorem round_spec (state m : Block) : + compressInnerJ state m = round state m schedules[0] := by + rfl + +/-- Iterating `permute` `r` times on a message block `m` indexes `m` according to +`schedules[r]`. -/ +theorem permute_spec (m : Block) (r : Fin 7) (k : Fin 16) : + ((permute^[r.val]) m)[k.val] = m[(schedules[r])[k.val]] := by + fin_cases r <;> fin_cases k <;> rfl + +theorem round_permute_spec (state m : Block) (r : Fin 7) : + compressInnerJ state ((permute^[r.val]) m) = round state m schedules[r] := by + have h0 := permute_spec m r 0 + have h1 := permute_spec m r 1 + have h2 := permute_spec m r 2 + have h3 := permute_spec m r 3 + have h4 := permute_spec m r 4 + have h5 := permute_spec m r 5 + have h6 := permute_spec m r 6 + have h7 := permute_spec m r 7 + have h8 := permute_spec m r 8 + have h9 := permute_spec m r 9 + have h10 := permute_spec m r 10 + have h11 := permute_spec m r 11 + have h12 := permute_spec m r 12 + have h13 := permute_spec m r 13 + have h14 := permute_spec m r 14 + have h15 := permute_spec m r 15 + dsimp only [Fin.val_zero] at h0 + change ((permute^[r.val]) m)[1] = m[(schedules[r])[1]] at h1 + change ((permute^[r.val]) m)[2] = m[(schedules[r])[2]] at h2 + change ((permute^[r.val]) m)[3] = m[(schedules[r])[3]] at h3 + change ((permute^[r.val]) m)[4] = m[(schedules[r])[4]] at h4 + change ((permute^[r.val]) m)[5] = m[(schedules[r])[5]] at h5 + change ((permute^[r.val]) m)[6] = m[(schedules[r])[6]] at h6 + change ((permute^[r.val]) m)[7] = m[(schedules[r])[7]] at h7 + change ((permute^[r.val]) m)[8] = m[(schedules[r])[8]] at h8 + change ((permute^[r.val]) m)[9] = m[(schedules[r])[9]] at h9 + change ((permute^[r.val]) m)[10] = m[(schedules[r])[10]] at h10 + change ((permute^[r.val]) m)[11] = m[(schedules[r])[11]] at h11 + change ((permute^[r.val]) m)[12] = m[(schedules[r])[12]] at h12 + change ((permute^[r.val]) m)[13] = m[(schedules[r])[13]] at h13 + change ((permute^[r.val]) m)[14] = m[(schedules[r])[14]] at h14 + change ((permute^[r.val]) m)[15] = m[(schedules[r])[15]] at h15 + unfold compressInnerJ round + rw [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11, h12, h13, h14, h15] + +theorem schedules_foldl {α : Type} (f : α → Vector (Fin 16) 16 → α) (init : α) : + schedules.foldl f init = + f (f (f (f (f (f (f init schedules[0]) schedules[1]) schedules[2]) schedules[3]) + schedules[4]) schedules[5]) schedules[6] := by + unfold schedules + rfl + +/-- The 7-round loop `Blake3::compress_inner_i(state, m, 0)` in `Aiur.Library.Blake3` +equals folding `round` over all 7 `schedules`. -/ +def compressInnerI (state m : Block) : Block := + let s0 := compressInnerJ state m + let m1 := permute m + let s1 := compressInnerJ s0 m1 + let m2 := permute m1 + let s2 := compressInnerJ s1 m2 + let m3 := permute m2 + let s3 := compressInnerJ s2 m3 + let m4 := permute m3 + let s4 := compressInnerJ s3 m4 + let m5 := permute m4 + let s5 := compressInnerJ s4 m5 + let m6 := permute m5 + compressInnerJ s5 m6 + +theorem compress_inner_i_spec (state m : Block) : + compressInnerI state m = + schedules.foldl (fun s sched => round s m sched) state := by + have h0 : compressInnerJ state m = round state m schedules[0] := + round_permute_spec state m 0 + have h1 : compressInnerJ (round state m schedules[0]) (permute m) = + round (round state m schedules[0]) m schedules[1] := + round_permute_spec (round state m schedules[0]) m 1 + have h2 : compressInnerJ (round (round state m schedules[0]) m schedules[1]) (permute (permute m)) = + round (round (round state m schedules[0]) m schedules[1]) m schedules[2] := + round_permute_spec _ m 2 + have h3 : compressInnerJ (round (round (round state m schedules[0]) m schedules[1]) m schedules[2]) + (permute (permute (permute m))) = + round (round (round (round state m schedules[0]) m schedules[1]) m schedules[2]) m schedules[3] := + round_permute_spec _ m 3 + have h4 : compressInnerJ + (round (round (round (round state m schedules[0]) m schedules[1]) m schedules[2]) m schedules[3]) + (permute (permute (permute (permute m)))) = + round (round (round (round (round state m schedules[0]) m schedules[1]) m schedules[2]) m schedules[3]) m schedules[4] := + round_permute_spec _ m 4 + have h5 : compressInnerJ + (round (round (round (round (round state m schedules[0]) m schedules[1]) m schedules[2]) m schedules[3]) m schedules[4]) + (permute (permute (permute (permute (permute m))))) = + round (round (round (round (round (round state m schedules[0]) m schedules[1]) m schedules[2]) m schedules[3]) m schedules[4]) m schedules[5] := + round_permute_spec _ m 5 + have h6 : compressInnerJ + (round (round (round (round (round (round state m schedules[0]) m schedules[1]) m schedules[2]) m schedules[3]) m schedules[4]) m schedules[5]) + (permute (permute (permute (permute (permute (permute m)))))) = + round (round (round (round (round (round (round state m schedules[0]) m schedules[1]) m schedules[2]) m schedules[3]) m schedules[4]) m schedules[5]) m schedules[6] := + round_permute_spec _ m 6 + unfold compressInnerI + dsimp only + rw [schedules_foldl (fun s sched => round s m sched) state] + rw [h0, h1, h2, h3, h4, h5, h6] + +/-- Splitting a 64-bit `counter` represented as 8 bytes `(c0..c7)` into its lower 4 bytes +`(c0..c3)` and upper 4 bytes `(c4..c7)` matches `counter.toUInt32` and `(counter >>> 32).toUInt32` +in `initialWords`. -/ +theorem counter_split_spec (c0 c1 c2 c3 c4 c5 c6 c7 : UInt8) : + let counter : UInt64 := UInt64.ofNat (U64.pack c0.toNat c1.toNat c2.toNat c3.toNat c4.toNat c5.toNat c6.toNat c7.toNat) + counter.toUInt32 = wordOfBytes c0 c1 c2 c3 ∧ + (counter >>> 32).toUInt32 = wordOfBytes c4 c5 c6 c7 := by + dsimp only + have hc0 := c0.toNat_lt; have hc1 := c1.toNat_lt; have hc2 := c2.toNat_lt; have hc3 := c3.toNat_lt + have hc4 := c4.toNat_lt; have hc5 := c5.toNat_lt; have hc6 := c6.toNat_lt; have hc7 := c7.toNat_lt + have hpack_lt : U64.pack c0.toNat c1.toNat c2.toNat c3.toNat c4.toNat c5.toNat c6.toNat c7.toNat < U64.base := + U64.pack_lt hc0 hc1 hc2 hc3 hc4 hc5 hc6 hc7 + have hcounter_toNat : + (UInt64.ofNat (U64.pack c0.toNat c1.toNat c2.toNat c3.toNat c4.toNat c5.toNat c6.toNat c7.toNat)).toNat = + U64.pack c0.toNat c1.toNat c2.toNat c3.toNat c4.toNat c5.toNat c6.toNat c7.toNat := by + simpa [U64.base] using Nat.mod_eq_of_lt hpack_lt + constructor + · apply UInt32.ext + rw [UInt64.toNat_toUInt32, hcounter_toNat, wordOfBytes_toNat] + unfold U64.pack U32.pack + omega + · apply UInt32.ext + rw [UInt64.toNat_toUInt32, UInt64.toNat_shiftRight, hcounter_toNat, wordOfBytes_toNat] + have hshift : (32 : UInt64).toNat % 64 = 32 := by decide + rw [hshift, Nat.shiftRight_eq_div_pow] + unfold U64.pack U32.pack + omega + +/-- `Blake3::compress` in `Aiur.Library.Blake3` computes `compress cv message counter blockLen flags`. -/ +theorem compress_spec (cv : CV) (message : Block) (counter : UInt64) (blockLen flags : UInt32) : + finalizeState (compressInnerI (initialWords cv counter blockLen flags) message) = + compress cv message counter blockLen flags := + congrArg finalizeState (compress_inner_i_spec (initialWords cv counter blockLen flags) message) + +/-! ### 5. Block Padding, Chunk Compression, Merkle Tree Layer Reduction, and `hash` -/ + +/-- `Blake3::pad_block(rev_acc, block_index)` pads a reversed byte list `rev_acc` of length +`block_index ≤ 64` by prepending `64 - block_index` zero bytes, so reversing the result produces +`acc ++ List.replicate (64 - acc.length) 0`. -/ +def padBlock (revAcc : List UInt8) (blockIndex : Nat) : List UInt8 := + List.replicate (64 - blockIndex) (0 : UInt8) ++ revAcc + +theorem pad_block_spec (acc : List UInt8) : + (padBlock acc.reverse acc.length).reverse = + acc ++ List.replicate (64 - acc.length) 0 := by + unfold padBlock + simp [List.reverse_append] + +/-- Grouping a padded 64-byte block into 16 4-byte little-endian words (`Blake3::bytes_to_block`) +produces `blockWords acc` for any input block `acc` with `acc.length ≤ 64`. -/ +theorem bytes_to_block_spec (acc : List UInt8) (hlen : acc.length ≤ 64) : + blockWords (acc ++ List.replicate (64 - acc.length) 0) = blockWords acc := by + unfold blockWords + apply congrArg Vector.ofFn + funext w + apply congrArg bytesWord + apply congrArg Vector.ofFn + funext b + simp only [List.getElem?_toArray] + by_cases hlt : w.val * 4 + b.val < acc.length + · rw [List.getElem?_append_left hlt] + · have hge : acc.length ≤ w.val * 4 + b.val := by omega + rw [List.getElem?_append_right hge, List.getElem?_eq_none hge, Option.getD_none] + have hrep : w.val * 4 + b.val - acc.length < 64 - acc.length := by omega + simp [hrep] + +/-- `Blake3::compress_chunks` compresses a non-empty stream of bytes into the sequence of +1024-byte chunk chaining values (or a single root digest when `bytes.length ≤ 1024`). -/ +def chunkOption (counter : UInt64) (input : List UInt8) : Output := + chunkOutput counter (input.take 1024) + +theorem chunk_single_root_spec (input : List UInt8) (hlen : input.length ≤ 1024) : + (chunkOutput 0 input).rootHash = digest input := by + unfold digest subtree + simp [hlen] + +/-- `Blake3::next_layer` pairs adjacent chaining values `(left, right)` using `parentOutput` +and leaves a trailing odd chaining value unchanged. -/ +def nextLayer (cvs : List CV) : List CV := + match cvs with + | [] => [] + | [cv] => [cv] + | left :: right :: rest => (parentOutput left right).chainingValue :: nextLayer rest + +theorem next_layer_pair_spec (left right : CV) (rest : List CV) : + nextLayer (left :: right :: rest) = + compress iv (left ++ right) 0 64 4 :: nextLayer rest := by + rfl + +theorem next_layer_singleton_spec (cv : CV) : + nextLayer [cv] = [cv] := by + rfl + +theorem next_layer_length_lt {cvs : List CV} (h : 2 ≤ cvs.length) : + (nextLayer cvs).length < cvs.length := by + induction cvs using nextLayer.induct with + | case1 => simp at h + | case2 _ => simp at h + | case3 left right rest ih => + rcases rest with _ | ⟨c, _ | ⟨d, ds⟩⟩ + · simp [nextLayer] + · simp [nextLayer] + · have hih := ih (by simp) + simp only [nextLayer, List.length_cons] at hih ⊢ + omega + +/-- `Blake3::compress_layer` reduces a layer of `≥ 2` chaining values by repeatedly applying +`nextLayer` until a root pair `[left, right]` remains, then compresses that pair with +`PARENT | ROOT = 4 | 8 = 12`. -/ +def compressLayer (cvs : List CV) : CV := + match cvs with + | [] => iv + | [cv] => cv + | [left, right] => compress iv (left ++ right) 0 64 12 + | left :: right :: c :: rest => + compressLayer (nextLayer (left :: right :: c :: rest)) +termination_by cvs.length +decreasing_by + exact next_layer_length_lt (by simp) + +theorem compress_layer_two_spec (left right : CV) : + cvBytes (compressLayer [left, right]) = (parentOutput left right).rootHash := by + have h12 : ((4 : UInt32) ||| 8) = 12 := rfl + unfold parentOutput Output.rootHash + dsimp only + rw [h12, compressLayer] + +theorem compress_layer_step_spec (left right c : CV) (rest : List CV) : + compressLayer (left :: right :: c :: rest) = + compressLayer (nextLayer (left :: right :: c :: rest)) := by + conv_lhs => rw [compressLayer] + +/-! ### 6. `digest_bytes`, `bytes_to_addr`, `address_to_fields`, and `verify_bytes_against` -/ + +/-- `Blake3::digest_bytes` unpacks the 8 32-bit words of a chaining value into a 32-byte digest, +matching `cvBytes`. -/ +theorem digest_bytes_spec (cv : CV) (i : Fin 32) : + (cvBytes cv)[i] = (wordBytes cv[i.val / 4])[i.val % 4] := by + simp [cvBytes] + +theorem cvBytes_inj {cv1 cv2 : CV} (h : cvBytes cv1 = cvBytes cv2) : cv1 = cv2 := by + ext w hw + have h0 : (cvBytes cv1)[w * 4 + 0]'(by omega) = (cvBytes cv2)[w * 4 + 0]'(by omega) := by rw [h] + have h1 : (cvBytes cv1)[w * 4 + 1]'(by omega) = (cvBytes cv2)[w * 4 + 1]'(by omega) := by rw [h] + have h2 : (cvBytes cv1)[w * 4 + 2]'(by omega) = (cvBytes cv2)[w * 4 + 2]'(by omega) := by rw [h] + have h3 : (cvBytes cv1)[w * 4 + 3]'(by omega) = (cvBytes cv2)[w * 4 + 3]'(by omega) := by rw [h] + have hd0 : (w * 4 + 0) / 4 = w := by omega + have hd1 : (w * 4 + 1) / 4 = w := by omega + have hd2 : (w * 4 + 2) / 4 = w := by omega + have hd3 : (w * 4 + 3) / 4 = w := by omega + have hm0 : (w * 4 + 0) % 4 = 0 := by omega + have hm1 : (w * 4 + 1) % 4 = 1 := by omega + have hm2 : (w * 4 + 2) % 4 = 2 := by omega + have hm3 : (w * 4 + 3) % 4 = 3 := by omega + simp only [cvBytes, Vector.getElem_ofFn, hd0, hd1, hd2, hd3, hm0, hm1, hm2, hm3] at h0 h1 h2 h3 + have hw := congrArg UInt32.toNat (by + rw [← wordOfBytes_wordBytes cv1[w], ← wordOfBytes_wordBytes cv2[w], h0, h1, h2, h3] : + cv1[w] = cv2[w]) + exact hw + +/-- `Blake3::pack_digest(h: [UInt32::U32; 8]) -> [Field; 8]` converts each 32-bit +word of a chaining value into a field element via `UInt32::to_field`. -/ +def packDigest (F : Type) [Field F] (cv : CV) : Vector F 8 := + cv.map (fun w => (w.toNat : F)) + +/-- Under `U32.Compatible F`, `packDigest F` is injective on 8-word chaining values. -/ +theorem pack_digest_inj {F : Type} [Field F] (large : U32.Compatible F) : + Function.Injective (packDigest F) := by + intro a b h + ext i hi + have hi_eq := congrArg (fun v : Vector F 8 => v[i]) h + simp only [packDigest, Vector.getElem_map] at hi_eq + have ha_lt : a[i].toNat < 3 * U32.base := by + have := a[i].toNat_lt; unfold U32.base; omega + have hb_lt : b[i].toNat < 3 * U32.base := by + have := b[i].toNat_lt; unfold U32.base; omega + exact large ha_lt hb_lt hi_eq + +/-- `Blake3::address_to_fields(bytes: [U8; 32]) -> [Field; 32]` converts each byte +of a 32-byte digest into a field element via `UInt8::to_field`. -/ +def addressToFields (F : Type) [Field F] (addr : Digest) : Vector F 32 := + addr.map (fun b => (b.toNat : F)) + +/-- Under `U32.Compatible F`, `addressToFields F` is injective on 32-byte digests. -/ +theorem address_to_fields_inj {F : Type} [Field F] (large : U32.Compatible F) : + Function.Injective (addressToFields F) := by + intro a b h + ext i hi + have hi_eq := congrArg (fun v : Vector F 32 => v[i]) h + simp only [addressToFields, Vector.getElem_map] at hi_eq + have ha_lt : a[i].toNat < 3 * U32.base := by + have := a[i].toNat_lt; unfold U32.base; omega + have hb_lt : b[i].toNat < 3 * U32.base := by + have := b[i].toNat_lt; unfold U32.base; omega + exact large ha_lt hb_lt hi_eq + +/-- `Blake3::verify_bytes_against(bytes, expected)` asserts that the 32 field elements +`address_to_fields(digest_bytes(h))` equal `address_to_fields(expected)`. +Under `U32.Compatible F`, this field-array equality holds if and only if the BLAKE3 digest +of `bytes` equals `expectedAddr`. -/ +theorem verify_bytes_against_iff {F : Type} [Field F] (large : U32.Compatible F) + (bytes : List UInt8) (expectedAddr : Digest) : + addressToFields F (digest bytes) = addressToFields F expectedAddr ↔ + digest bytes = expectedAddr := + (address_to_fields_inj large).eq_iff + +end Aiur.Library.Blake3 diff --git a/Aiur/Aiur/Library/Blake3/Goldilocks.lean b/Aiur/Aiur/Library/Blake3/Goldilocks.lean new file mode 100644 index 000000000..c43200123 --- /dev/null +++ b/Aiur/Aiur/Library/Blake3/Goldilocks.lean @@ -0,0 +1,17 @@ +import Aiur.Library.Blake3 +import Aiur.Library.U32.Goldilocks + +namespace Aiur.Library.Blake3.Goldilocks +open Aiur + +theorem u64_compatible : U64.Compatible U32.Goldilocks.F := + U64.compatible_of_charP U32.Goldilocks.F U32.Goldilocks.modulus (by decide) + +def program : Modules.Program U32.Goldilocks.F := + U32.Goldilocks.program.append (U64.specialize U32.Goldilocks.F u64_compatible) + |>.append (List.declarations.toField U32.Goldilocks.F) + |>.append (Field.declarations.toField U32.Goldilocks.F) + |>.append (Bytes.declarations.toField U32.Goldilocks.F) + |>.append (Blake3.declarations.toField U32.Goldilocks.F) + +end Aiur.Library.Blake3.Goldilocks diff --git a/Aiur/Aiur/Library/Bytes.lean b/Aiur/Aiur/Library/Bytes.lean new file mode 100644 index 000000000..da6e9dce5 --- /dev/null +++ b/Aiur/Aiur/Library/Bytes.lean @@ -0,0 +1,92 @@ +import Aiur.Library.U8 +import Aiur.Library.List +import Aiur.Library.Frontend + +/-! Common byte streams and addresses. Address equality compares all 32 +checked bytes and does not assume a memory address or field-specific packing. -/ +namespace Aiur.Library.Bytes +open Aiur + +def dependencies : Modules.Program Nat := U8.templates.append List.declarations + +def declarations : Modules.Program Nat := aiur_library% dependencies r#" +module Bytes { + type Stream = Lists::List; + type Address = [UInt8::U8; 32]; + type AddressRef = &Address; +fn address_eq_tail(a: AddressRef, b: AddressRef) -> Field { + let [_, a1, a2, a3, a4, a5, a6, a7, + a8, a9, a10, a11, a12, a13, a14, a15, + a16, a17, a18, a19, a20, a21, a22, a23, + a24, a25, a26, a27, a28, a29, a30, a31] = (*(a)); + let [_, b1, b2, b3, b4, b5, b6, b7, + b8, b9, b10, b11, b12, b13, b14, b15, + b16, b17, b18, b19, b20, b21, b22, b23, + b24, b25, b26, b27, b28, b29, b30, b31] = (*(b)); + + let pa1 = ((((((UInt8::to_field(a7) * 256) + UInt8::to_field(a6)) * 256 + + UInt8::to_field(a5)) * 256 + UInt8::to_field(a4)) * 256 + + UInt8::to_field(a3)) * 256 + UInt8::to_field(a2)) * 256 + UInt8::to_field(a1); + let pb1 = ((((((UInt8::to_field(b7) * 256) + UInt8::to_field(b6)) * 256 + + UInt8::to_field(b5)) * 256 + UInt8::to_field(b4)) * 256 + + UInt8::to_field(b3)) * 256 + UInt8::to_field(b2)) * 256 + UInt8::to_field(b1); + match pa1 - pb1 { + 0 => { + let pa2 = ((((((UInt8::to_field(a14) * 256) + UInt8::to_field(a13)) * 256 + + UInt8::to_field(a12)) * 256 + UInt8::to_field(a11)) * 256 + + UInt8::to_field(a10)) * 256 + UInt8::to_field(a9)) * 256 + UInt8::to_field(a8); + let pb2 = ((((((UInt8::to_field(b14) * 256) + UInt8::to_field(b13)) * 256 + + UInt8::to_field(b12)) * 256 + UInt8::to_field(b11)) * 256 + + UInt8::to_field(b10)) * 256 + UInt8::to_field(b9)) * 256 + UInt8::to_field(b8); + match pa2 - pb2 { + 0 => { + let pa3 = ((((((UInt8::to_field(a21) * 256) + UInt8::to_field(a20)) * 256 + + UInt8::to_field(a19)) * 256 + UInt8::to_field(a18)) * 256 + + UInt8::to_field(a17)) * 256 + UInt8::to_field(a16)) * 256 + + UInt8::to_field(a15); + let pb3 = ((((((UInt8::to_field(b21) * 256) + UInt8::to_field(b20)) * 256 + + UInt8::to_field(b19)) * 256 + UInt8::to_field(b18)) * 256 + + UInt8::to_field(b17)) * 256 + UInt8::to_field(b16)) * 256 + + UInt8::to_field(b15); + match pa3 - pb3 { + 0 => { + let pa4 = ((((((UInt8::to_field(a28) * 256) + UInt8::to_field(a27)) * 256 + + UInt8::to_field(a26)) * 256 + UInt8::to_field(a25)) * 256 + + UInt8::to_field(a24)) * 256 + UInt8::to_field(a23)) * 256 + + UInt8::to_field(a22); + let pb4 = ((((((UInt8::to_field(b28) * 256) + UInt8::to_field(b27)) * 256 + + UInt8::to_field(b26)) * 256 + UInt8::to_field(b25)) * 256 + + UInt8::to_field(b24)) * 256 + UInt8::to_field(b23)) * 256 + + UInt8::to_field(b22); + match pa4 - pb4 { + 0 => { + let pa5 = ((UInt8::to_field(a31) * 256) + UInt8::to_field(a30)) * 256 + + UInt8::to_field(a29); + let pb5 = ((UInt8::to_field(b31) * 256) + UInt8::to_field(b30)) * 256 + + UInt8::to_field(b29); + match pa5 - pb5 { + 0 => { 1 } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } + } + +fn address_eq(a: AddressRef, b: AddressRef) -> Field { + let av = (*(a)); + let bv = (*(b)); + match UInt8::to_field(av[0]) - UInt8::to_field(bv[0]) { + 0 => { address_eq_tail(a, b) } , + _ => { 0 } , + } + } +} +"# + +end Aiur.Library.Bytes diff --git a/Aiur/Aiur/Library/Bytes/Correctness.lean b/Aiur/Aiur/Library/Bytes/Correctness.lean new file mode 100644 index 000000000..8450a88cf --- /dev/null +++ b/Aiur/Aiur/Library/Bytes/Correctness.lean @@ -0,0 +1,371 @@ +import Aiur.Library.Bytes +import Aiur.Library.List.Correctness + +/-! +# Mathematical and Heap Specifications of `Aiur.Library.Bytes` and Byte Streams + +This module establishes: +1. Canonical `SourceValue F` representation predicates `RepAddress` (`[UInt8::U8; 32]`), + `RepAddressRef` (`&[UInt8::U8; 32]`), and `RepByteStream` (`Lists::List`) + along with their `HeapMono` / `HeapMono₂` proofs. +2. Soundness and completeness of `Bytes::address_eq_tail` and `Bytes::address_eq` + under `[Field F] [DecidableEq F] (large : U64.Compatible F)`: + `addressEq F a b = if a = b then 1 else 0` (`1` iff `a = b`, `0` iff `a ≠ b`). +3. Mathematical and heap specifications of `read_byte_stream` and + `read_finite_byte_stream`: reading `len` bytes from an I/O stream starting at + `idx` produces a heap-extended `RepByteStream` of length `len` (with + `len < 2^32` enforced by `WordLists::depth_checked`). +-/ + +namespace Aiur.Library.Bytes + +open Aiur + +variable {F : Type} + +/-! ### 1. Representation Predicates (`RepAddress`, `RepAddressRef`, `RepByteStream`) and `HeapMono` -/ + +/-- A 32-byte address (`Bytes::Address = [UInt8::U8; 32]`). -/ +abbrev Address := Vector UInt8 32 + +/-- Canonical `SourceValue F` representation of `Bytes::Address = [UInt8::U8; 32]`. -/ +def RepAddress [NatCast F] (_h : Heap F) (addr : Address) (v : SourceValue F) : Prop := + v = .tuple (addr.toList.map fun b => .field (b.toNat : F)) + +theorem repAddress_heapMono₂ [NatCast F] : HeapMono₂ (RepAddress (F := F)) := + fun _ _ _ _ _ h => h + +theorem repAddress_heapMono [NatCast F] (addr : Address) : + HeapMono (fun h v => RepAddress (F := F) h addr v) := + HeapMono.of_heapMono₂ repAddress_heapMono₂ addr + +/-- Canonical `SourceValue F` representation of `Bytes::AddressRef = &Bytes::Address`. -/ +def RepAddressRef [NatCast F] (ty : Ty) (h : Heap F) (addr : Address) (ptr : SourceValue F) : Prop := + DerefTyped ty (fun h v => RepAddress h addr v) h ptr + +theorem repAddressRef_heapMono₂ [NatCast F] (ty : Ty) : + HeapMono₂ (RepAddressRef (F := F) ty) := + fun _ _ addr _ ext h => HeapMono.derefTyped (repAddress_heapMono addr) ext h + +theorem repAddressRef_heapMono [NatCast F] (ty : Ty) (addr : Address) : + HeapMono (fun h ptr => RepAddressRef (F := F) ty h addr ptr) := + HeapMono.derefTyped (repAddress_heapMono addr) + +/-- Canonical `SourceValue F` representation of `Bytes::Stream = Lists::List`. -/ +abbrev RepByteStream [NatCast F] (enumName : String) (h : Heap F) + (bytes : _root_.List UInt8) (ptr : SourceValue F) : Prop := + List.RepList enumName RepU8 h bytes ptr + +theorem repByteStream_heapMono₂ [NatCast F] (enumName : String) : + HeapMono₂ (RepByteStream (F := F) enumName) := + List.repList_heapMono₂ enumName repU8_heapMono₂ + +theorem repByteStream_heapMono [NatCast F] (enumName : String) (bytes : _root_.List UInt8) : + HeapMono (fun h ptr => RepByteStream (F := F) enumName h bytes ptr) := + List.repList_heapMono enumName repU8_heapMono₂ bytes + +private theorem list_map_u8_field_inj [Field F] (large : U32.Compatible F) + {xs ys : _root_.List UInt8} + (h : xs.map (fun b : UInt8 => (Value.field (b.toNat : F) : SourceValue F)) = + ys.map (fun b : UInt8 => (Value.field (b.toNat : F) : SourceValue F))) : + xs = ys := by + induction xs generalizing ys with + | nil => + cases ys <;> simp at h ⊢ + | cons x xs ih => + cases ys with + | nil => simp at h + | cons y ys => + simp only [_root_.List.map_cons, _root_.List.cons.injEq] at h + exact _root_.List.cons_eq_cons.mpr ⟨repU8_inj large (h := ([] : Heap F)) rfl h.1, ih h.2⟩ + +theorem repAddress_inj [Field F] (large : U32.Compatible F) {h : Heap F} + {a₁ a₂ : Address} {v : SourceValue F} + (h₁ : RepAddress h a₁ v) (h₂ : RepAddress h a₂ v) : a₁ = a₂ := by + have hTuple := Value.tuple.inj (h₁.symm.trans h₂) + exact Vector.toList_inj.mp (list_map_u8_field_inj large hTuple) + +theorem repAddressRef_inj [Field F] (large : U32.Compatible F) {ty : Ty} {h : Heap F} + {a₁ a₂ : Address} {ptr : SourceValue F} + (h₁ : RepAddressRef ty h a₁ ptr) (h₂ : RepAddressRef ty h a₂ ptr) : a₁ = a₂ := by + obtain ⟨addr₁, v₁, hptr₁, hcell₁, hrep₁⟩ := h₁ + obtain ⟨addr₂, v₂, hptr₂, hcell₂, hrep₂⟩ := h₂ + rw [hptr₁] at hptr₂ + injection hptr₂ with _ hAddr + subst hAddr + rw [hcell₁] at hcell₂ + injection hcell₂ with hVal + subst hVal + exact repAddress_inj large hrep₁ hrep₂ + +theorem repByteStream_inj [Field F] (large : U32.Compatible F) {enumName : String} {h : Heap F} + {bs₁ bs₂ : _root_.List UInt8} {ptr : SourceValue F} + (h₁ : RepByteStream enumName h bs₁ ptr) (h₂ : RepByteStream enumName h bs₂ ptr) : + bs₁ = bs₂ := + List.repList_inj (repU8_inj large) h₁ h₂ + +/-! ### 2. `Bytes::address_eq_tail` and `Bytes::address_eq` Correctness -/ + +/-- Packed 7-byte field limb `pa1` (`Bytes::address_eq_tail`, lines 27-29). -/ +def limb1 (F : Type) [Field F] (a : Address) : F := + ((((((a[7].toNat : F) * 256 + (a[6].toNat : F)) * 256 + + (a[5].toNat : F)) * 256 + (a[4].toNat : F)) * 256 + + (a[3].toNat : F)) * 256 + (a[2].toNat : F)) * 256 + (a[1].toNat : F) + +/-- Packed 7-byte field limb `pa2` (`Bytes::address_eq_tail`, lines 35-37). -/ +def limb2 (F : Type) [Field F] (a : Address) : F := + ((((((a[14].toNat : F) * 256 + (a[13].toNat : F)) * 256 + + (a[12].toNat : F)) * 256 + (a[11].toNat : F)) * 256 + + (a[10].toNat : F)) * 256 + (a[9].toNat : F)) * 256 + (a[8].toNat : F) + +/-- Packed 7-byte field limb `pa3` (`Bytes::address_eq_tail`, lines 43-46). -/ +def limb3 (F : Type) [Field F] (a : Address) : F := + ((((((a[21].toNat : F) * 256 + (a[20].toNat : F)) * 256 + + (a[19].toNat : F)) * 256 + (a[18].toNat : F)) * 256 + + (a[17].toNat : F)) * 256 + (a[16].toNat : F)) * 256 + (a[15].toNat : F) + +/-- Packed 7-byte field limb `pa4` (`Bytes::address_eq_tail`, lines 53-56). -/ +def limb4 (F : Type) [Field F] (a : Address) : F := + ((((((a[28].toNat : F) * 256 + (a[27].toNat : F)) * 256 + + (a[26].toNat : F)) * 256 + (a[25].toNat : F)) * 256 + + (a[24].toNat : F)) * 256 + (a[23].toNat : F)) * 256 + (a[22].toNat : F) + +/-- Packed 3-byte field limb `pa5` (`Bytes::address_eq_tail`, lines 63-64). -/ +def limb5 (F : Type) [Field F] (a : Address) : F := + ((a[31].toNat : F) * 256 + (a[30].toNat : F)) * 256 + (a[29].toNat : F) + +/-- Exact field-level mirror of `Bytes::address_eq_tail(a, b)`. -/ +def addressEqTail (F : Type) [Field F] [DecidableEq F] (a b : Address) : F := + if limb1 F a - limb1 F b = 0 then + if limb2 F a - limb2 F b = 0 then + if limb3 F a - limb3 F b = 0 then + if limb4 F a - limb4 F b = 0 then + if limb5 F a - limb5 F b = 0 then 1 else 0 + else 0 + else 0 + else 0 + else 0 + +/-- Exact field-level mirror of `Bytes::address_eq(a, b)`. -/ +def addressEq (F : Type) [Field F] [DecidableEq F] (a b : Address) : F := + if (a[0].toNat : F) - (b[0].toNat : F) = 0 then + addressEqTail F a b + else 0 + +private theorem limb_pack56_eq [Field F] (x0 x1 x2 x3 x4 x5 x6 : UInt8) : + ((((((x6.toNat : F) * 256 + (x5.toNat : F)) * 256 + + (x4.toNat : F)) * 256 + (x3.toNat : F)) * 256 + + (x2.toNat : F)) * 256 + (x1.toNat : F)) * 256 + (x0.toNat : F) = + ((U64.pack56 x0.toNat x1.toNat x2.toNat x3.toNat x4.toNat x5.toNat x6.toNat : Nat) : F) := by + unfold U64.pack56 + push_cast + ring + +private theorem limb7_sub_eq_zero_iff [Field F] (large : U64.Compatible F) + (a0 a1 a2 a3 a4 a5 a6 b0 b1 b2 b3 b4 b5 b6 : UInt8) : + (((((((a6.toNat : F) * 256 + (a5.toNat : F)) * 256 + + (a4.toNat : F)) * 256 + (a3.toNat : F)) * 256 + + (a2.toNat : F)) * 256 + (a1.toNat : F)) * 256 + (a0.toNat : F)) - + (((((((b6.toNat : F) * 256 + (b5.toNat : F)) * 256 + + (b4.toNat : F)) * 256 + (b3.toNat : F)) * 256 + + (b2.toNat : F)) * 256 + (b1.toNat : F)) * 256 + (b0.toNat : F)) = 0 ↔ + a0.toNat = b0.toNat ∧ a1.toNat = b1.toNat ∧ a2.toNat = b2.toNat ∧ + a3.toNat = b3.toNat ∧ a4.toNat = b4.toNat ∧ a5.toNat = b5.toNat ∧ + a6.toNat = b6.toNat := by + rw [limb_pack56_eq, limb_pack56_eq, sub_eq_zero] + constructor + · intro h + have hl := U64.natCast_inj large + (U64.pack56_lt a0.toNat_lt a1.toNat_lt a2.toNat_lt a3.toNat_lt a4.toNat_lt a5.toNat_lt a6.toNat_lt) + (U64.pack56_lt b0.toNat_lt b1.toNat_lt b2.toNat_lt b3.toNat_lt b4.toNat_lt b5.toNat_lt b6.toNat_lt) h + exact (U64.pack56_inj + a0.toNat_lt a1.toNat_lt a2.toNat_lt a3.toNat_lt a4.toNat_lt a5.toNat_lt a6.toNat_lt + b0.toNat_lt b1.toNat_lt b2.toNat_lt b3.toNat_lt b4.toNat_lt b5.toNat_lt b6.toNat_lt).mp hl + · rintro ⟨e0, e1, e2, e3, e4, e5, e6⟩ + rw [e0, e1, e2, e3, e4, e5, e6] + +private theorem limb3_sub_eq_zero_iff [Field F] (large : U64.Compatible F) + (a0 a1 a2 b0 b1 b2 : UInt8) : + (((a2.toNat : F) * 256 + (a1.toNat : F)) * 256 + (a0.toNat : F)) - + (((b2.toNat : F) * 256 + (b1.toNat : F)) * 256 + (b0.toNat : F)) = 0 ↔ + a0.toNat = b0.toNat ∧ a1.toNat = b1.toNat ∧ a2.toNat = b2.toNat := by + have ha : ((a2.toNat : F) * 256 + (a1.toNat : F)) * 256 + (a0.toNat : F) = + ((U32.pack a0.toNat a1.toNat a2.toNat 0 : Nat) : F) := by + unfold U32.pack; push_cast; ring + have hb : ((b2.toNat : F) * 256 + (b1.toNat : F)) * 256 + (b0.toNat : F) = + ((U32.pack b0.toNat b1.toNat b2.toNat 0 : Nat) : F) := by + unfold U32.pack; push_cast; ring + rw [ha, hb, sub_eq_zero] + constructor + · intro h + have ha0 := a0.toNat_lt; have ha1 := a1.toNat_lt; have ha2 := a2.toNat_lt + have hb0 := b0.toNat_lt; have hb1 := b1.toNat_lt; have hb2 := b2.toNat_lt + have hl := U64.natCast_inj large + (by unfold U32.pack U64.fieldBound; omega) + (by unfold U32.pack U64.fieldBound; omega) h + unfold U32.pack at hl + omega + · rintro ⟨e0, e1, e2⟩ + rw [e0, e1, e2] + +private theorem byte0_sub_eq_zero_iff [Field F] (large : U64.Compatible F) + (a0 b0 : UInt8) : + (a0.toNat : F) - (b0.toNat : F) = 0 ↔ a0.toNat = b0.toNat := by + rw [sub_eq_zero] + constructor + · intro h + exact U64.natCast_inj large + (by have := a0.toNat_lt; unfold U64.fieldBound; omega) + (by have := b0.toNat_lt; unfold U64.fieldBound; omega) h + · intro h + rw [h] + +/-- `Bytes::address_eq(a, b)` returns `1` if `a = b` and `0` if `a ≠ b`. -/ +theorem address_eq_spec [Field F] [DecidableEq F] (large : U64.Compatible F) + (a b : Address) : + addressEq F a b = if a = b then 1 else 0 := by + unfold addressEq addressEqTail + by_cases hab : a = b + · subst hab + simp + · simp only [hab, ↓reduceIte] + split_ifs with h0 h1 h2 h3 h4 h5 + · exfalso + apply hab + replace h0 := (byte0_sub_eq_zero_iff large _ _).mp h0 + replace h1 := (limb7_sub_eq_zero_iff large _ _ _ _ _ _ _ _ _ _ _ _ _ _).mp h1 + replace h2 := (limb7_sub_eq_zero_iff large _ _ _ _ _ _ _ _ _ _ _ _ _ _).mp h2 + replace h3 := (limb7_sub_eq_zero_iff large _ _ _ _ _ _ _ _ _ _ _ _ _ _).mp h3 + replace h4 := (limb7_sub_eq_zero_iff large _ _ _ _ _ _ _ _ _ _ _ _ _ _).mp h4 + replace h5 := (limb3_sub_eq_zero_iff large _ _ _ _ _ _).mp h5 + ext i hi + have : i = 0 ∨ i = 1 ∨ i = 2 ∨ i = 3 ∨ i = 4 ∨ i = 5 ∨ i = 6 ∨ i = 7 ∨ + i = 8 ∨ i = 9 ∨ i = 10 ∨ i = 11 ∨ i = 12 ∨ i = 13 ∨ i = 14 ∨ i = 15 ∨ + i = 16 ∨ i = 17 ∨ i = 18 ∨ i = 19 ∨ i = 20 ∨ i = 21 ∨ i = 22 ∨ i = 23 ∨ + i = 24 ∨ i = 25 ∨ i = 26 ∨ i = 27 ∨ i = 28 ∨ i = 29 ∨ i = 30 ∨ i = 31 := by omega + rcases this with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | + rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | + rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | + rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl + · exact h0 + · exact h1.1 + · exact h1.2.1 + · exact h1.2.2.1 + · exact h1.2.2.2.1 + · exact h1.2.2.2.2.1 + · exact h1.2.2.2.2.2.1 + · exact h1.2.2.2.2.2.2 + · exact h2.1 + · exact h2.2.1 + · exact h2.2.2.1 + · exact h2.2.2.2.1 + · exact h2.2.2.2.2.1 + · exact h2.2.2.2.2.2.1 + · exact h2.2.2.2.2.2.2 + · exact h3.1 + · exact h3.2.1 + · exact h3.2.2.1 + · exact h3.2.2.2.1 + · exact h3.2.2.2.2.1 + · exact h3.2.2.2.2.2.1 + · exact h3.2.2.2.2.2.2 + · exact h4.1 + · exact h4.2.1 + · exact h4.2.2.1 + · exact h4.2.2.2.1 + · exact h4.2.2.2.2.1 + · exact h4.2.2.2.2.2.1 + · exact h4.2.2.2.2.2.2 + · exact h5.1 + · exact h5.2.1 + · exact h5.2.2 + all_goals rfl + +theorem address_eq_one_iff [Field F] [DecidableEq F] (large : U64.Compatible F) + (a b : Address) : + addressEq F a b = 1 ↔ a = b := by + rw [address_eq_spec large] + by_cases h : a = b <;> simp [h] + +theorem address_eq_zero_iff [Field F] [DecidableEq F] (large : U64.Compatible F) + (a b : Address) : + addressEq F a b = 0 ↔ a ≠ b := by + rw [address_eq_spec large] + by_cases h : a = b <;> simp [h] + +/-! ### 3. `read_byte_stream` and `read_finite_byte_stream` Specifications -/ + +/-- Pure specification of `read_byte_stream(channel, idx, len)`: reads `len` +consecutive bytes starting at `idx` from the channel's byte stream `stream`. -/ +def readByteStream (stream : Nat → UInt8) (idx : Nat) : Nat → _root_.List UInt8 + | 0 => [] + | len + 1 => stream idx :: readByteStream stream (idx + 1) len + +theorem read_byte_stream_length (stream : Nat → UInt8) (idx len : Nat) : + (readByteStream stream idx len).length = len := by + induction len generalizing idx with + | zero => rfl + | succ len ih => simp [readByteStream, ih] + +theorem read_byte_stream_getElem (stream : Nat → UInt8) (idx len i : Nat) (hi : i < len) : + (readByteStream stream idx len)[i]'(by rw [read_byte_stream_length]; exact hi) = + stream (idx + i) := by + induction len generalizing idx i with + | zero => omega + | succ len ih => + cases i with + | zero => simp [readByteStream] + | succ i => + simp only [readByteStream, _root_.List.getElem_cons_succ] + rw [ih (idx + 1) i (by omega)] + congr 1 + omega + +/-- Allocate a `Bytes::Stream` (`Lists::List`) in `h : Heap F`. -/ +def allocByteStream [NatCast F] (enumName : String) (h : Heap F) + (bytes : _root_.List UInt8) : SourceValue F × Heap F := + List.allocValues enumName h (bytes.map fun b => .field (b.toNat : F)) + +theorem alloc_byte_stream_extends [NatCast F] (enumName : String) + (h : Heap F) (bytes : _root_.List UInt8) : + Heap.Extends h (allocByteStream (F := F) enumName h bytes).2 := + List.allocValues_extends enumName h _ + +theorem alloc_byte_stream_rep [NatCast F] (enumName : String) + (h : Heap F) (bytes : _root_.List UInt8) : + RepByteStream enumName (allocByteStream (F := F) enumName h bytes).2 + bytes (allocByteStream (F := F) enumName h bytes).1 := by + apply List.allocValues_rep enumName repU8_heapMono₂ h + rw [_root_.List.forall₂_map_right_iff] + exact _root_.List.forall₂_same.mpr (fun _ _ => rfl) + +/-- Specification of `read_byte_stream`: reading `len` bytes from `stream` at `idx` +and allocating the resulting `Lists::Node` chain extends the heap and produces a +valid `RepByteStream` of length `len`. -/ +theorem read_byte_stream_spec [NatCast F] (enumName : String) + (stream : Nat → UInt8) (idx len : Nat) (h : Heap F) : + let bytes := readByteStream stream idx len + let allocated := allocByteStream (F := F) enumName h bytes + Heap.Extends h allocated.2 ∧ + RepByteStream enumName allocated.2 bytes allocated.1 ∧ + bytes.length = len := + ⟨alloc_byte_stream_extends enumName h _, + alloc_byte_stream_rep enumName h _, + read_byte_stream_length stream idx len⟩ + +/-- Specification of `read_finite_byte_stream`: `read_byte_stream` followed by +`WordLists::depth_checked` succeeds iff `len < 2^32`, producing a heap-extended +`RepByteStream` of length `len < 2^32`. -/ +theorem read_finite_byte_stream_spec [NatCast F] (enumName : String) + (stream : Nat → UInt8) (idx len : Nat) (h : Heap F) : + let bytes := readByteStream stream idx len + let allocated := allocByteStream (F := F) enumName h bytes + (List.Word.depthChecked bytes = some len ↔ len < U32.base) ∧ + Heap.Extends h allocated.2 ∧ + RepByteStream enumName allocated.2 bytes allocated.1 ∧ + bytes.length = len := by + refine ⟨?_, read_byte_stream_spec enumName stream idx len h⟩ + rw [List.Word.depth_checked_some_iff, read_byte_stream_length] + simp + +end Aiur.Library.Bytes diff --git a/Aiur/Aiur/Library/Carry.lean b/Aiur/Aiur/Library/Carry.lean new file mode 100644 index 000000000..05f04ab3f --- /dev/null +++ b/Aiur/Aiur/Library/Carry.lean @@ -0,0 +1,60 @@ +import Aiur.AST +import Mathlib.Algebra.Field.Basic +import Mathlib.Data.Nat.Cast.Basic + +namespace Aiur.Library.Carry + +/-- The shared input domain and its low digit. Keeping one row generator +ensures the two precommitted traces use exactly the same ordering. -/ +def rows (base count : Nat) : List (Nat × Nat) := + (List.range count).map fun n => (n, n % base) + +/-- The original two-output relation, after conversion to the chosen field. -/ +def fullRows (F : Type) [NatCast F] (base count : Nat) : List (F × F × F) := + (List.range count).map fun (n : Nat) => + ((n : F), ((n % base : Nat) : F), ((n / base : Nat) : F)) + +/-- The slimmer relation used by the actual generated tables. -/ +def fieldRows (F : Type) [NatCast F] (base count : Nat) : List (F × F) := + (rows base count).map fun (n, byte) => ((n : F), (byte : F)) + +variable {F : Type} [Field F] + +/-- The omitted carry is determined by the input and low digit. No natural +division is performed by the circuit; it multiplies by the field inverse. -/ +theorem recover (base n : Nat) (nonzero : (base : F) ≠ 0) : + ((n : F) - ((n % base : Nat) : F)) / (base : F) = ((n / base : Nat) : F) := by + apply (div_eq_iff nonzero).2 + have equation := congrArg (fun n : Nat => (n : F)) (Nat.mod_add_div n base) + rw [Nat.cast_add, Nat.cast_mul] at equation + exact (sub_eq_iff_eq_add).2 (by simpa only [add_comm, mul_comm] using equation.symm) + +/-- Exact before/after lookup equivalence, including the input domain. The +statement remains true over any field in which the base is nonzero; table +input uniqueness is checked separately during ordinary program checking. -/ +theorem fullRows_iff (base count : Nat) (nonzero : (base : F) ≠ 0) (input byte carry : F) : + (input, byte, carry) ∈ fullRows F base count ↔ + (input, byte) ∈ fieldRows F base count ∧ carry = (input - byte) / (base : F) := by + simp only [fullRows, fieldRows, rows, List.map_map, List.mem_map] + constructor + · rintro ⟨n, member, equal⟩ + obtain ⟨rfl, tailEq⟩ := Prod.mk.inj equal + obtain ⟨rfl, rfl⟩ := Prod.mk.inj tailEq + exact ⟨⟨n, member, rfl⟩, (recover base n nonzero).symm⟩ + · rintro ⟨⟨n, member, equal⟩, rfl⟩ + obtain ⟨rfl, rfl⟩ := Prod.mk.inj equal + exact ⟨n, member, by dsimp only [Function.comp_apply]; rw [recover base n nonzero]⟩ + +/-- A map returning both coordinates is interchangeable with a byte-only map +followed by carry reconstruction. This uses the same `MapEntry` shape as the +static-map leaves of the circuit derivation model. -/ +theorem mapEntries_iff (base count : Nat) (nonzero : (base : F) ≠ 0) (input byte carry : F) : + (⟨[.field input], .tuple [.field byte, .field carry]⟩ : MapEntry F) ∈ + (fullRows F base count).map (fun (x, lo, hi) => ⟨[.field x], .tuple [.field lo, .field hi]⟩) ↔ + (⟨[.field input], .field byte⟩ : MapEntry F) ∈ + (fieldRows F base count).map (fun (x, lo) => ⟨[.field x], .field lo⟩) ∧ + carry = (input - byte) / (base : F) := by + simpa [List.mem_map, MapEntry.mk.injEq, Prod.exists, exists_and_left, and_assoc] using + fullRows_iff base count nonzero input byte carry + +end Aiur.Library.Carry diff --git a/Aiur/Aiur/Library/Field.lean b/Aiur/Aiur/Library/Field.lean new file mode 100644 index 000000000..ef8fe55a3 --- /dev/null +++ b/Aiur/Aiur/Library/Field.lean @@ -0,0 +1,11 @@ +import Aiur.Modules + +namespace Aiur.Library.Field +open Aiur + +def declarations : Modules.Program Nat := aiur% " +module Fields { + inline fn is_zero(x: Field) -> Field { match x { 0 => 1, _ => 0 } } +}" + +end Aiur.Library.Field diff --git a/Aiur/Aiur/Library/Field/Goldilocks.lean b/Aiur/Aiur/Library/Field/Goldilocks.lean new file mode 100644 index 000000000..8dece5161 --- /dev/null +++ b/Aiur/Aiur/Library/Field/Goldilocks.lean @@ -0,0 +1,93 @@ +import Aiur.Library.U8 +import Aiur.Library.Field +import Aiur.Library.Frontend +import Aiur.Library.U32.Goldilocks + +/-! Canonical Goldilocks encoding, inversion, and the quadratic extension +with nonresidue 7, shared with the recursive verifier. Advice consists only of +raw field values; ordinary constraints check inverses and byte encodings. +Unlike the bounded U32 implementation, these formulas select Goldilocks. -/ +namespace Aiur.Library.Field.Goldilocks +open Aiur + +def dependencies : Modules.Program Nat := U8.templates.append Library.Field.declarations + +def declarations : Modules.Program Nat := aiur_library% dependencies r#" +module Goldilocks { + type Goldilocks = Field; + + type ExtGoldilocks = [Field; 2]; + + inline fn gl_val(x: [UInt8::U8; 8]) -> Field { + UInt8::to_field(x[0]) + 256 * UInt8::to_field(x[1]) + 65536 * UInt8::to_field(x[2]) + + 16777216 * UInt8::to_field(x[3]) + 4294967296 * UInt8::to_field(x[4]) + + 1099511627776 * UInt8::to_field(x[5]) + 281474976710656 * UInt8::to_field(x[6]) + + 72057594037927936 * UInt8::to_field(x[7]) + } + + inline fn gl_lt_p(x: [UInt8::U8; 8]) -> Field { + let hi_max = Fields::is_zero( + UInt8::to_field(x[4]) + UInt8::to_field(x[5]) + UInt8::to_field(x[6]) + UInt8::to_field(x[7]) - 1020); + let lo_zero = Fields::is_zero( + UInt8::to_field(x[0]) + UInt8::to_field(x[1]) + UInt8::to_field(x[2]) + UInt8::to_field(x[3])); + 1 - (hi_max * (1 - lo_zero)) + } + + inline fn gl_to_bytes(v: Field) -> [UInt8::U8; 8] { + let b = hint::<[Field; 8]>("bytes_le", v); + let (c0, c1) = UInt8::from_fields(b[0], b[1]); + let (c2, c3) = UInt8::from_fields(b[2], b[3]); + let (c4, c5) = UInt8::from_fields(b[4], b[5]); + let (c6, c7) = UInt8::from_fields(b[6], b[7]); + let r = [c0, c1, c2, c3, c4, c5, c6, c7]; + assert_eq!(gl_val(r), v); + assert_eq!(gl_lt_p(r), 1); + r + } + + inline fn gl_inverse(x: Goldilocks::Goldilocks) -> Goldilocks::Goldilocks { + let iv = hint::("goldilocks.inverse", x); + let t = (x * iv) - 1; + assert_eq!(x * t, 0); + assert_eq!(iv * t, 0); + iv + } + + inline fn eg_add(a: ExtGoldilocks, b: ExtGoldilocks) -> ExtGoldilocks { + [a[0] + b[0], a[1] + b[1]] + } + + inline fn eg_sub(a: ExtGoldilocks, b: ExtGoldilocks) -> ExtGoldilocks { + [a[0] - b[0], a[1] - b[1]] + } + + inline fn eg_neg(a: ExtGoldilocks) -> ExtGoldilocks { + [0 - a[0], 0 - a[1]] + } + + inline fn eg_mul(a: ExtGoldilocks, b: ExtGoldilocks) -> ExtGoldilocks { + [(a[0] * b[0]) + (7 * (a[1] * b[1])), (a[0] * b[1]) + (a[1] * b[0])] + } + + inline fn eg_inverse(a: ExtGoldilocks) -> ExtGoldilocks { + let norm = (a[0] * a[0]) - (7 * (a[1] * a[1])); + let ninv = hint::("goldilocks.inverse", norm); + let t = (norm * ninv) - 1; + assert_eq!(norm * t, 0); + assert_eq!(ninv * t, 0); + [a[0] * ninv, (0 - a[1]) * ninv] + } + + inline fn eg_div(a: ExtGoldilocks, b: ExtGoldilocks) -> ExtGoldilocks { + eg_mul(a, eg_inverse(b)) + } + + inline fn eg_eq(a: ExtGoldilocks, b: ExtGoldilocks) -> Field { + Fields::is_zero(a[0] - b[0]) * Fields::is_zero(a[1] - b[1]) + } +} +"# + +def program : Modules.Program U32.Goldilocks.F := declarations.toField U32.Goldilocks.F + +end Aiur.Library.Field.Goldilocks diff --git a/Aiur/Aiur/Library/Frontend.lean b/Aiur/Aiur/Library/Frontend.lean new file mode 100644 index 000000000..993580d1c --- /dev/null +++ b/Aiur/Aiur/Library/Frontend.lean @@ -0,0 +1,15 @@ +import Aiur.Modules +import Lean.Elab.Eval + +open Lean Elab Term in +/-- Elaborate a library fragment against its declared dependencies, retaining +only the fragment. Linking clients can then share each dependency exactly once. -/ +elab "aiur_library% " dependencies:term:max source:str : term => do + let dependencies ← unsafe evalTerm (Aiur.Modules.Program Nat) + (mkApp (mkConst ``Aiur.Modules.Program) (mkConst ``Nat)) dependencies + let program ← match Aiur.Modules.Frontend.parse (← getEnv) source.getString with + | .ok program => pure program + | .error error => throwErrorAt source "{error}" + match Aiur.Modules.checkTemplates (dependencies.append program) with + | .error error => throwErrorAt source "{error}" + | .ok _ => return Lean.toExpr program diff --git a/Aiur/Aiur/Library/IxVMRep.lean b/Aiur/Aiur/Library/IxVMRep.lean new file mode 100644 index 000000000..628085a36 --- /dev/null +++ b/Aiur/Aiur/Library/IxVMRep.lean @@ -0,0 +1,1221 @@ +import Aiur.HeapMono +import Aiur.Library.U64.Correctness +import Aiur.Library.List.Correctness +import Aiur.Library.Bytes.Correctness +import Aiur.Library.RBTreeMap.Correctness +import Aiur.Library.Blake3.Correctness + +/-! +# `IxVM` Heap Representation Predicates, Monotonicity, Determinism, and Deserialization Lemmas + +This module provides the Phase 4 (`IxVM` correspondence) representation and +authentication foundation: +1. Determinism/injectivity (`det`) for primitive and container representation + predicates (`RepU8`, `RepU32`, `RepU64`, `RepAddress`, `RepAddressRef`, + `RepOption`, `RepLinkedList`, `RepList`, `RepBinaryTree`, `RepRBTreePtr`). +2. Mathematical ASTs and `SourceValue F` heap representation predicates for: + - `IxVMUniv` (`Zero | Succ | Max | IMax | Var`) & `RepIxVMUniv` + - `IxVMIExpr` (`Srt | Var | Ref | Rec | Prj | Str | Nat | App | Lam | All | Let | Share`) & `RepIxVMIExpr` + - `IxVMKUniv` (`Zero | Succ | Max | IMax | Param`) & `RepIxVMKUniv` + - `IxVMKExpr` (`BVar | Sort | Const | App | Lam | ForallE | LetE | LitNat | LitStr | Proj`) & `RepIxVMKExpr` + - `IxVMRoleEvidence`, `IxVMRoleTable`, `IxVMRoleCtx` & `RepRoleEvidence`, `RepRoleTable`, `RepRoleCtx` +3. `HeapMono` (`Heap.Extends h₁ h₂ → Rep* h₁ x v → Rep* h₂ x v`) and determinism / + injectivity (`Rep* h x₁ v → Rep* h x₂ v → x₁ = x₂`) for each `IxVM` predicate. +4. Ingress stream authentication (`ingress_verify_stream_sound`) and `TagN` + header / multi-byte `UInt64` decoding lemmas (`tag_header_split_unique`, + `tagn4_header_split_unique`, `tagn2_header_split_unique`, `u64OfLeBytes_*`, + and `tagn_tail_two_byte_spec`). +-/ + +namespace Aiur.Library.IxVMRep + +open Aiur +open Aiur.Library +open Aiur.Library.List +open Aiur.Library.Bytes +open Aiur.Library.RBTreeMap + +variable {F : Type} + +/-! ## 1. Determinism of Primitive and Container Representation Predicates -/ + +theorem nat_lt_256_inj [Field F] (large : U32.Compatible F) {a b : Nat} + (ha : a < 256) (hb : b < 256) (heq : (a : F) = (b : F)) : a = b := by + have ha' : a < 3 * U32.base := by unfold U32.base; omega + have hb' : b < 3 * U32.base := by unfold U32.base; omega + exact large ha' hb' heq + +private theorem limb_eq_of_tuple_eq [Field F] (large : U32.Compatible F) + {n w₁ w₂ : Nat} + (hTuple : (_root_.List.range n).map (fun i => (Value.field (((w₁ / 256 ^ i) % 256 : Nat) : F) : SourceValue F)) = + (_root_.List.range n).map (fun i => (Value.field (((w₂ / 256 ^ i) % 256 : Nat) : F) : SourceValue F))) + (i : Nat) (hi : i < n) : + (w₁ / 256 ^ i) % 256 = (w₂ / 256 ^ i) % 256 := by + have hElem := congrArg (fun xs : _root_.List (SourceValue F) => xs[i]?) hTuple + simp only [List.getElem?_map, List.getElem?_range hi, Option.map_some, + Option.some.injEq, Value.field.injEq] at hElem + exact nat_lt_256_inj large (Nat.mod_lt _ (by decide)) (Nat.mod_lt _ (by decide)) hElem + +private theorem nat_eq_of_byte_limbs : ∀ (n a b : Nat), + a < 256 ^ n → b < 256 ^ n → + (∀ i < n, (a / 256 ^ i) % 256 = (b / 256 ^ i) % 256) → a = b + | 0, a, b, ha, hb, _ => by omega + | n + 1, a, b, ha, hb, h => by + have h0 := h 0 (Nat.zero_lt_succ n) + simp only [Nat.pow_zero, Nat.div_one] at h0 + have hPowEq : 256 ^ (n + 1) = 256 ^ n * 256 := Nat.pow_succ 256 n + have hDiv : a / 256 = b / 256 := + nat_eq_of_byte_limbs n (a / 256) (b / 256) + (Nat.div_lt_of_lt_mul (by omega)) + (Nat.div_lt_of_lt_mul (by omega)) + (fun i hi => by + have hi' := h (i + 1) (Nat.succ_lt_succ hi) + have hPow : 256 ^ (i + 1) = 256 * 256 ^ i := by + rw [Nat.pow_succ, Nat.mul_comm] + rw [hPow, ← Nat.div_div_eq_div_mul, ← Nat.div_div_eq_div_mul] at hi' + exact hi') + have ha' := Nat.div_add_mod a 256 + have hb' := Nat.div_add_mod b 256 + omega + +theorem repU32_det [Field F] (large : U32.Compatible F) {h : Heap F} + {w₁ w₂ : UInt32} {v : SourceValue F} + (h₁ : RepU32 h w₁ v) (h₂ : RepU32 h w₂ v) : w₁ = w₂ := by + have hTuple := Value.tuple.inj (h₁.symm.trans h₂) + exact UInt32.ext (nat_eq_of_byte_limbs 4 w₁.toNat w₂.toNat w₁.toNat_lt w₂.toNat_lt + (fun i hi => limb_eq_of_tuple_eq large hTuple i hi)) + +theorem repU64_det [Field F] (large : U32.Compatible F) {h : Heap F} + {w₁ w₂ : UInt64} {v : SourceValue F} + (h₁ : RepU64 h w₁ v) (h₂ : RepU64 h w₂ v) : w₁ = w₂ := by + have hTuple := Value.tuple.inj (h₁.symm.trans h₂) + exact UInt64.ext (nat_eq_of_byte_limbs 8 w₁.toNat w₂.toNat w₁.toNat_lt w₂.toNat_lt + (fun i hi => limb_eq_of_tuple_eq large hTuple i hi)) + +private theorem list_map_u8_field_inj [Field F] (large : U32.Compatible F) + {xs ys : _root_.List UInt8} + (h : xs.map (fun b : UInt8 => (Value.field (b.toNat : F) : SourceValue F)) = + ys.map (fun b : UInt8 => (Value.field (b.toNat : F) : SourceValue F))) : + xs = ys := by + induction xs generalizing ys with + | nil => + cases ys <;> simp at h ⊢ + | cons x xs ih => + cases ys with + | nil => simp at h + | cons y ys => + simp only [List.map_cons, List.cons.injEq] at h + exact List.cons_eq_cons.mpr ⟨repU8_inj large (h := ([] : Heap F)) rfl h.1, ih h.2⟩ + +theorem repAddress_det [Field F] (large : U32.Compatible F) {h : Heap F} + {a₁ a₂ : Address} {v : SourceValue F} + (h₁ : RepAddress h a₁ v) (h₂ : RepAddress h a₂ v) : a₁ = a₂ := by + have hTuple := Value.tuple.inj (h₁.symm.trans h₂) + exact Vector.toList_inj.mp (list_map_u8_field_inj large hTuple) + +theorem repAddressRef_det [Field F] (large : U32.Compatible F) {ty : Ty} {h : Heap F} + {a₁ a₂ : Address} {ptr : SourceValue F} + (h₁ : RepAddressRef ty h a₁ ptr) (h₂ : RepAddressRef ty h a₂ ptr) : a₁ = a₂ := by + obtain ⟨addr₁, v₁, hptr₁, hcell₁, hrep₁⟩ := h₁ + obtain ⟨addr₂, v₂, hptr₂, hcell₂, hrep₂⟩ := h₂ + rw [hptr₁] at hptr₂ + injection hptr₂ with _ hAddr + subst hAddr + rw [hcell₁] at hcell₂ + injection hcell₂ with hVal + subst hVal + exact repAddress_det large hrep₁ hrep₂ + +theorem repOption_det {α : Type*} {enumName : String} + {R : Heap F → α → SourceValue F → Prop} {h : Heap F} + (hR : ∀ {x₁ x₂ v}, R h x₁ v → R h x₂ v → x₁ = x₂) + {o₁ o₂ : Option α} {v : SourceValue F} + (h₁ : RepOption enumName R h o₁ v) (h₂ : RepOption enumName R h o₂ v) : + o₁ = o₂ := by + revert h₂ + generalize hv : v = v' + intro h₂ + cases h₁ with + | none => + cases h₂ with + | none => rfl + | some _ => + injection hv with _ hCtor _ + exact absurd hCtor (by decide) + | some hv₁ => + cases h₂ with + | none => + injection hv with _ hCtor _ + exact absurd hCtor (by decide) + | some hv₂ => + injection hv with _ _ hArgs + injection hArgs with hVal _ + subst hVal + exact congrArg some (hR hv₁ hv₂) + +theorem repLinkedList_det {α : Type*} {enumName nilCtor consCtor : String} + (hNe : nilCtor ≠ consCtor) + {R : Heap F → α → SourceValue F → Prop} {h : Heap F} + (hR : ∀ {x₁ x₂ v}, R h x₁ v → R h x₂ v → x₁ = x₂) + {xs₁ xs₂ : _root_.List α} {ptr : SourceValue F} + (h₁ : RepLinkedList enumName nilCtor consCtor R h xs₁ ptr) + (h₂ : RepLinkedList enumName nilCtor consCtor R h xs₂ ptr) : + xs₁ = xs₂ := by + induction h₁ generalizing xs₂ with + | nil cell₁ => + cases h₂ with + | nil _ => rfl + | cons cell₂ _ _ => + rw [cell₁] at cell₂ + injection cell₂ with hVal + injection hVal with _ hCtor _ + exact absurd hCtor hNe + | cons cell₁ headRep₁ _ ih => + cases h₂ with + | nil cell₂ => + rw [cell₁] at cell₂ + injection cell₂ with hVal + injection hVal with _ hCtor _ + exact absurd hCtor.symm hNe + | cons cell₂ headRep₂ tailRep₂ => + rw [cell₁] at cell₂ + injection cell₂ with hVal + injection hVal with _ _ hArgs + injection hArgs with hHead hTail + injection hTail with hTailPtr _ + subst hHead hTailPtr + exact List.cons_eq_cons.mpr ⟨hR headRep₁ headRep₂, ih tailRep₂⟩ + +theorem repList_det {α : Type*} {enumName : String} + {R : Heap F → α → SourceValue F → Prop} {h : Heap F} + (hR : ∀ {x₁ x₂ v}, R h x₁ v → R h x₂ v → x₁ = x₂) + {xs₁ xs₂ : _root_.List α} {ptr : SourceValue F} + (h₁ : RepList enumName R h xs₁ ptr) + (h₂ : RepList enumName R h xs₂ ptr) : + xs₁ = xs₂ := + repLinkedList_det (by decide) hR h₁ h₂ + +theorem repBinaryTree_det {α : Type*} {enumName leafCtor branchCtor : String} + (hNe : leafCtor ≠ branchCtor) + {R : Heap F → α → SourceValue F → Prop} {h : Heap F} + (hR : ∀ {x₁ x₂ v}, R h x₁ v → R h x₂ v → x₁ = x₂) + {t₁ t₂ : BinaryTree α} {ptr : SourceValue F} + (h₁ : RepBinaryTree enumName leafCtor branchCtor R h t₁ ptr) + (h₂ : RepBinaryTree enumName leafCtor branchCtor R h t₂ ptr) : + t₁ = t₂ := by + induction h₁ generalizing t₂ with + | leaf cell₁ => + cases h₂ with + | leaf _ => rfl + | branch cell₂ _ _ _ => + rw [cell₁] at cell₂ + injection cell₂ with hVal + injection hVal with _ hCtor _ + exact absurd hCtor hNe + | branch cell₁ labelRep₁ _ _ ihl ihr => + cases h₂ with + | leaf cell₂ => + rw [cell₁] at cell₂ + injection cell₂ with hVal + injection hVal with _ hCtor _ + exact absurd hCtor.symm hNe + | branch cell₂ labelRep₂ leftRep₂ rightRep₂ => + rw [cell₁] at cell₂ + injection cell₂ with hVal + injection hVal with _ _ hArgs + injection hArgs with hLbl hRest₁ + injection hRest₁ with hLeft hRest₂ + injection hRest₂ with hRight _ + subst hLbl hLeft hRight + rw [hR labelRep₁ labelRep₂, ihl leftRep₂, ihr rightRep₂] + +theorem repRBTreePtr_det {K V : Type*} {enumName nilCtor nodeCtor : String} + (hNe : nilCtor ≠ nodeCtor) + {RLabel : Heap F → (Nat × K × V) → SourceValue F → Prop} {h : Heap F} + (hR : ∀ {x₁ x₂ v}, RLabel h x₁ v → RLabel h x₂ v → x₁ = x₂) + {t₁ t₂ : RBTree K V} {ptr : SourceValue F} + (h₁ : RepRBTreePtr enumName nilCtor nodeCtor RLabel h t₁ ptr) + (h₂ : RepRBTreePtr enumName nilCtor nodeCtor RLabel h t₂ ptr) : + t₁ = t₂ := by + have hBin := repBinaryTree_det hNe hR h₁ h₂ + have hOf := congrArg RBTree.ofBinaryTree hBin + rwa [RBTree.ofBinaryTree_toBinaryTree, RBTree.ofBinaryTree_toBinaryTree] at hOf + +/-! ## 2. `IxVMUniv` (`Ixon::Univ`) Representation, `HeapMono`, and Determinism -/ + +/-- Mathematical AST of `Ixon::Univ` universe levels. -/ +inductive IxVMUniv where + | zero : IxVMUniv + | succ (u : IxVMUniv) : IxVMUniv + | max (u v : IxVMUniv) : IxVMUniv + | imax (u v : IxVMUniv) : IxVMUniv + | var (idx : UInt64) : IxVMUniv + deriving Repr, DecidableEq + +/-- Heap representation predicate for `Ixon::Univ` values. -/ +inductive RepIxVMUniv [NatCast F] (h : Heap F) : IxVMUniv → SourceValue F → Prop where + | zero : + RepIxVMUniv h .zero (.construct "Ixon::Univ" "Zero" []) + | succ {u : IxVMUniv} {addr : Nat} {uVal : SourceValue F} + (cell : h[addr]? = some uVal) + (inner : RepIxVMUniv h u uVal) : + RepIxVMUniv h (.succ u) (.construct "Ixon::Univ" "Succ" [.ptr (.enum "Ixon::Univ") addr]) + | max {u v : IxVMUniv} {a₁ a₂ : Nat} {uVal vVal : SourceValue F} + (cell₁ : h[a₁]? = some uVal) + (cell₂ : h[a₂]? = some vVal) + (left : RepIxVMUniv h u uVal) + (right : RepIxVMUniv h v vVal) : + RepIxVMUniv h (.max u v) + (.construct "Ixon::Univ" "Max" + [.ptr (.enum "Ixon::Univ") a₁, .ptr (.enum "Ixon::Univ") a₂]) + | imax {u v : IxVMUniv} {a₁ a₂ : Nat} {uVal vVal : SourceValue F} + (cell₁ : h[a₁]? = some uVal) + (cell₂ : h[a₂]? = some vVal) + (left : RepIxVMUniv h u uVal) + (right : RepIxVMUniv h v vVal) : + RepIxVMUniv h (.imax u v) + (.construct "Ixon::Univ" "IMax" + [.ptr (.enum "Ixon::Univ") a₁, .ptr (.enum "Ixon::Univ") a₂]) + | var {idx : UInt64} {idxVal : SourceValue F} + (repIdx : RepU64 h idx idxVal) : + RepIxVMUniv h (.var idx) (.construct "Ixon::Univ" "Var" [idxVal]) + +theorem RepIxVMUniv.mono [NatCast F] {h₁ h₂ : Heap F} {u : IxVMUniv} {v : SourceValue F} + (ext : Heap.Extends h₁ h₂) (rep : RepIxVMUniv h₁ u v) : + RepIxVMUniv h₂ u v := by + induction rep with + | zero => exact .zero + | succ cell _ ih => exact .succ (ext.getElem?_eq cell) ih + | max cell₁ cell₂ _ _ ihl ihr => + exact .max (ext.getElem?_eq cell₁) (ext.getElem?_eq cell₂) ihl ihr + | imax cell₁ cell₂ _ _ ihl ihr => + exact .imax (ext.getElem?_eq cell₁) (ext.getElem?_eq cell₂) ihl ihr + | var repIdx => exact .var (repU64_heapMono₂ ext repIdx) + +theorem HeapMono.repIxVMUniv [NatCast F] (u : IxVMUniv) : + HeapMono (fun h v => RepIxVMUniv (F := F) h u v) := + fun _ _ _ ext rep => rep.mono ext + +theorem RepIxVMUniv.det [Field F] (large : U32.Compatible F) {h : Heap F} + {u₁ u₂ : IxVMUniv} {v : SourceValue F} + (h₁ : RepIxVMUniv h u₁ v) (h₂ : RepIxVMUniv h u₂ v) : u₁ = u₂ := by + induction h₁ generalizing u₂ with + | zero => + revert h₂; generalize hv : Value.construct "Ixon::Univ" "Zero" [] = v'; intro h₂ + cases h₂ <;> (try (injection hv with _ hCtor _; exact absurd hCtor (by decide))) + rfl + | succ cell₁ _ ih => + revert h₂; generalize hv : Value.construct "Ixon::Univ" "Succ" [Value.ptr (Ty.enum "Ixon::Univ") _] = v'; intro h₂ + cases h₂ <;> (try (injection hv with _ hCtor _; exact absurd hCtor (by decide))) + rename_i cell₂ inner₂ + injection hv with _ _ hArgs + injection hArgs with hPtr _ + injection hPtr with _ hAddr + subst hAddr + rw [cell₁] at cell₂ + injection cell₂ with hVal + subst hVal + exact congrArg IxVMUniv.succ (ih inner₂) + | max cell₁ cell₂ _ _ ihl ihr => + revert h₂ + generalize hv : Value.construct "Ixon::Univ" "Max" + [Value.ptr (Ty.enum "Ixon::Univ") _, Value.ptr (Ty.enum "Ixon::Univ") _] = v' + intro h₂ + cases h₂ <;> (try (injection hv with _ hCtor _; exact absurd hCtor (by decide))) + rename_i cell₁' cell₂' left₂ right₂ + injection hv with _ _ hArgs + injection hArgs with hPtr₁ hRest + injection hRest with hPtr₂ _ + injection hPtr₁ with _ hAddr₁ + injection hPtr₂ with _ hAddr₂ + subst hAddr₁ hAddr₂ + rw [cell₁] at cell₁' + rw [cell₂] at cell₂' + injection cell₁' with hVal₁ + injection cell₂' with hVal₂ + subst hVal₁ hVal₂ + rw [ihl left₂, ihr right₂] + | imax cell₁ cell₂ _ _ ihl ihr => + revert h₂ + generalize hv : Value.construct "Ixon::Univ" "IMax" + [Value.ptr (Ty.enum "Ixon::Univ") _, Value.ptr (Ty.enum "Ixon::Univ") _] = v' + intro h₂ + cases h₂ <;> (try (injection hv with _ hCtor _; exact absurd hCtor (by decide))) + rename_i cell₁' cell₂' left₂ right₂ + injection hv with _ _ hArgs + injection hArgs with hPtr₁ hRest + injection hRest with hPtr₂ _ + injection hPtr₁ with _ hAddr₁ + injection hPtr₂ with _ hAddr₂ + subst hAddr₁ hAddr₂ + rw [cell₁] at cell₁' + rw [cell₂] at cell₂' + injection cell₁' with hVal₁ + injection cell₂' with hVal₂ + subst hVal₁ hVal₂ + rw [ihl left₂, ihr right₂] + | var repIdx₁ => + revert h₂; generalize hv : Value.construct "Ixon::Univ" "Var" [_] = v'; intro h₂ + cases h₂ <;> (try (injection hv with _ hCtor _; exact absurd hCtor (by decide))) + rename_i repIdx₂ + injection hv with _ _ hArgs + injection hArgs with hVal _ + subst hVal + exact congrArg IxVMUniv.var (repU64_det large repIdx₁ repIdx₂) + +/-! ## 3. `IxVMIExpr` (`&Ixon::Expr`) Representation, `HeapMono`, and Determinism -/ + +/-- Mathematical AST of `Ixon::Expr` wire expressions. -/ +inductive IxVMIExpr (F : Type) where + | srt (idx : UInt64) : IxVMIExpr F + | var (idx : UInt64) : IxVMIExpr F + | ref (idx : UInt64) (univs : _root_.List UInt64) : IxVMIExpr F + | recur (idx : UInt64) (univs : _root_.List UInt64) : IxVMIExpr F + | prj (typeRefIdx fieldIdx : UInt64) (val : IxVMIExpr F) : IxVMIExpr F + | str (idx : UInt64) : IxVMIExpr F + | nat (idx : UInt64) : IxVMIExpr F + | app (func arg : IxVMIExpr F) : IxVMIExpr F + | lam (contract : SourceValue F) (ty body : IxVMIExpr F) : IxVMIExpr F + | all (binderContract valueContract : SourceValue F) (ty body : IxVMIExpr F) : IxVMIExpr F + | letE (contract : SourceValue F) (ty val body : IxVMIExpr F) : IxVMIExpr F + | share (idx : UInt64) : IxVMIExpr F + +/-- Heap representation predicate for `&Ixon::Expr` pointers. -/ +inductive RepIxVMIExpr [NatCast F] (u64ListEnum : String) (h : Heap F) : + IxVMIExpr F → SourceValue F → Prop where + | srt {addr : Nat} {idx : UInt64} {idxVal : SourceValue F} + (cell : h[addr]? = some (.construct "Ixon::Expr" "Srt" [idxVal])) + (repIdx : RepU64 h idx idxVal) : + RepIxVMIExpr u64ListEnum h (.srt idx) (.ptr (.enum "Ixon::Expr") addr) + | var {addr : Nat} {idx : UInt64} {idxVal : SourceValue F} + (cell : h[addr]? = some (.construct "Ixon::Expr" "Var" [idxVal])) + (repIdx : RepU64 h idx idxVal) : + RepIxVMIExpr u64ListEnum h (.var idx) (.ptr (.enum "Ixon::Expr") addr) + | ref {addr : Nat} {idx : UInt64} {univs : _root_.List UInt64} + {idxVal univsPtr : SourceValue F} + (cell : h[addr]? = some (.construct "Ixon::Expr" "Ref" [idxVal, univsPtr])) + (repIdx : RepU64 h idx idxVal) + (repUnivs : RepList u64ListEnum RepU64 h univs univsPtr) : + RepIxVMIExpr u64ListEnum h (.ref idx univs) (.ptr (.enum "Ixon::Expr") addr) + | recur {addr : Nat} {idx : UInt64} {univs : _root_.List UInt64} + {idxVal univsPtr : SourceValue F} + (cell : h[addr]? = some (.construct "Ixon::Expr" "Rec" [idxVal, univsPtr])) + (repIdx : RepU64 h idx idxVal) + (repUnivs : RepList u64ListEnum RepU64 h univs univsPtr) : + RepIxVMIExpr u64ListEnum h (.recur idx univs) (.ptr (.enum "Ixon::Expr") addr) + | prj {addr : Nat} {typeRefIdx fieldIdx : UInt64} {val : IxVMIExpr F} + {tVal fVal valPtr : SourceValue F} + (cell : h[addr]? = some (.construct "Ixon::Expr" "Prj" [tVal, fVal, valPtr])) + (repT : RepU64 h typeRefIdx tVal) + (repF : RepU64 h fieldIdx fVal) + (repVal : RepIxVMIExpr u64ListEnum h val valPtr) : + RepIxVMIExpr u64ListEnum h (.prj typeRefIdx fieldIdx val) (.ptr (.enum "Ixon::Expr") addr) + | str {addr : Nat} {idx : UInt64} {idxVal : SourceValue F} + (cell : h[addr]? = some (.construct "Ixon::Expr" "Str" [idxVal])) + (repIdx : RepU64 h idx idxVal) : + RepIxVMIExpr u64ListEnum h (.str idx) (.ptr (.enum "Ixon::Expr") addr) + | nat {addr : Nat} {idx : UInt64} {idxVal : SourceValue F} + (cell : h[addr]? = some (.construct "Ixon::Expr" "Nat" [idxVal])) + (repIdx : RepU64 h idx idxVal) : + RepIxVMIExpr u64ListEnum h (.nat idx) (.ptr (.enum "Ixon::Expr") addr) + | app {addr : Nat} {func arg : IxVMIExpr F} {fnPtr argPtr : SourceValue F} + (cell : h[addr]? = some (.construct "Ixon::Expr" "App" [fnPtr, argPtr])) + (repFn : RepIxVMIExpr u64ListEnum h func fnPtr) + (repArg : RepIxVMIExpr u64ListEnum h arg argPtr) : + RepIxVMIExpr u64ListEnum h (.app func arg) (.ptr (.enum "Ixon::Expr") addr) + | lam {addr : Nat} {contract : SourceValue F} {ty body : IxVMIExpr F} + {tyPtr bodyPtr : SourceValue F} + (cell : h[addr]? = some (.construct "Ixon::Expr" "Lam" [contract, tyPtr, bodyPtr])) + (repTy : RepIxVMIExpr u64ListEnum h ty tyPtr) + (repBody : RepIxVMIExpr u64ListEnum h body bodyPtr) : + RepIxVMIExpr u64ListEnum h (.lam contract ty body) (.ptr (.enum "Ixon::Expr") addr) + | all {addr : Nat} {bc vc : SourceValue F} {ty body : IxVMIExpr F} + {tyPtr bodyPtr : SourceValue F} + (cell : h[addr]? = some (.construct "Ixon::Expr" "All" [bc, vc, tyPtr, bodyPtr])) + (repTy : RepIxVMIExpr u64ListEnum h ty tyPtr) + (repBody : RepIxVMIExpr u64ListEnum h body bodyPtr) : + RepIxVMIExpr u64ListEnum h (.all bc vc ty body) (.ptr (.enum "Ixon::Expr") addr) + | letE {addr : Nat} {contract : SourceValue F} {ty val body : IxVMIExpr F} + {tyPtr valPtr bodyPtr : SourceValue F} + (cell : h[addr]? = some (.construct "Ixon::Expr" "Let" [contract, tyPtr, valPtr, bodyPtr])) + (repTy : RepIxVMIExpr u64ListEnum h ty tyPtr) + (repVal : RepIxVMIExpr u64ListEnum h val valPtr) + (repBody : RepIxVMIExpr u64ListEnum h body bodyPtr) : + RepIxVMIExpr u64ListEnum h (.letE contract ty val body) (.ptr (.enum "Ixon::Expr") addr) + | share {addr : Nat} {idx : UInt64} {idxVal : SourceValue F} + (cell : h[addr]? = some (.construct "Ixon::Expr" "Share" [idxVal])) + (repIdx : RepU64 h idx idxVal) : + RepIxVMIExpr u64ListEnum h (.share idx) (.ptr (.enum "Ixon::Expr") addr) + +theorem RepIxVMIExpr.mono [NatCast F] {u64ListEnum : String} {h₁ h₂ : Heap F} + {e : IxVMIExpr F} {ptr : SourceValue F} + (ext : Heap.Extends h₁ h₂) (rep : RepIxVMIExpr u64ListEnum h₁ e ptr) : + RepIxVMIExpr u64ListEnum h₂ e ptr := by + induction rep with + | srt cell repIdx => exact .srt (ext.getElem?_eq cell) repIdx + | var cell repIdx => exact .var (ext.getElem?_eq cell) repIdx + | ref cell repIdx repUnivs => + exact .ref (ext.getElem?_eq cell) repIdx (repList_heapMono₂ u64ListEnum repU64_heapMono₂ ext repUnivs) + | recur cell repIdx repUnivs => + exact .recur (ext.getElem?_eq cell) repIdx (repList_heapMono₂ u64ListEnum repU64_heapMono₂ ext repUnivs) + | prj cell repT repF _ ih => + exact .prj (ext.getElem?_eq cell) repT repF ih + | str cell repIdx => exact .str (ext.getElem?_eq cell) repIdx + | nat cell repIdx => exact .nat (ext.getElem?_eq cell) repIdx + | app cell _ _ ihFn ihArg => + exact .app (ext.getElem?_eq cell) ihFn ihArg + | lam cell _ _ ihTy ihBody => + exact .lam (ext.getElem?_eq cell) ihTy ihBody + | all cell _ _ ihTy ihBody => + exact .all (ext.getElem?_eq cell) ihTy ihBody + | letE cell _ _ _ ihTy ihVal ihBody => + exact .letE (ext.getElem?_eq cell) ihTy ihVal ihBody + | share cell repIdx => exact .share (ext.getElem?_eq cell) repIdx + +theorem HeapMono.repIxVMIExpr [NatCast F] (u64ListEnum : String) (e : IxVMIExpr F) : + HeapMono (fun h ptr => RepIxVMIExpr u64ListEnum h e ptr) := + fun _ _ _ ext rep => rep.mono ext + +theorem RepIxVMIExpr.det [Field F] (large : U32.Compatible F) {u64ListEnum : String} + {h : Heap F} {e₁ e₂ : IxVMIExpr F} {ptr : SourceValue F} + (h₁ : RepIxVMIExpr u64ListEnum h e₁ ptr) + (h₂ : RepIxVMIExpr u64ListEnum h e₂ ptr) : + e₁ = e₂ := by + induction h₁ generalizing e₂ with + | srt cell₁ repIdx₁ => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i repIdx₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs; injection hArgs with hV _ + subst hV + exact congrArg IxVMIExpr.srt (repU64_det large repIdx₁ repIdx₂) + | var cell₁ repIdx₁ => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i repIdx₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs; injection hArgs with hV _ + subst hV + exact congrArg IxVMIExpr.var (repU64_det large repIdx₁ repIdx₂) + | ref cell₁ repIdx₁ repUnivs₁ => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i repIdx₂ repUnivs₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs + injection hArgs with hV₁ hRest; injection hRest with hV₂ _ + subst hV₁ hV₂ + rw [repU64_det large repIdx₁ repIdx₂, + repList_det (repU64_det large) repUnivs₁ repUnivs₂] + | recur cell₁ repIdx₁ repUnivs₁ => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i repIdx₂ repUnivs₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs + injection hArgs with hV₁ hRest; injection hRest with hV₂ _ + subst hV₁ hV₂ + rw [repU64_det large repIdx₁ repIdx₂, + repList_det (repU64_det large) repUnivs₁ repUnivs₂] + | prj cell₁ repT₁ repF₁ _ ih => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i repT₂ repF₂ repVal₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs + injection hArgs with hV₁ hRest₁; injection hRest₁ with hV₂ hRest₂; injection hRest₂ with hV₃ _ + subst hV₁ hV₂ hV₃ + rw [repU64_det large repT₁ repT₂, repU64_det large repF₁ repF₂, ih repVal₂] + | str cell₁ repIdx₁ => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i repIdx₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs; injection hArgs with hV _ + subst hV + exact congrArg IxVMIExpr.str (repU64_det large repIdx₁ repIdx₂) + | nat cell₁ repIdx₁ => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i repIdx₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs; injection hArgs with hV _ + subst hV + exact congrArg IxVMIExpr.nat (repU64_det large repIdx₁ repIdx₂) + | app cell₁ _ _ ihFn ihArg => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i repFn₂ repArg₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs + injection hArgs with hV₁ hRest; injection hRest with hV₂ _ + subst hV₁ hV₂ + rw [ihFn repFn₂, ihArg repArg₂] + | lam cell₁ _ _ ihTy ihBody => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i repTy₂ repBody₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs + injection hArgs with hV₁ hRest₁; injection hRest₁ with hV₂ hRest₂; injection hRest₂ with hV₃ _ + subst hV₁ hV₂ hV₃ + rw [ihTy repTy₂, ihBody repBody₂] + | all cell₁ _ _ ihTy ihBody => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i repTy₂ repBody₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs + injection hArgs with hV₁ hRest₁; injection hRest₁ with hV₂ hRest₂ + injection hRest₂ with hV₃ hRest₃; injection hRest₃ with hV₄ _ + subst hV₁ hV₂ hV₃ hV₄ + rw [ihTy repTy₂, ihBody repBody₂] + | letE cell₁ _ _ _ ihTy ihVal ihBody => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i repTy₂ repVal₂ repBody₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs + injection hArgs with hV₁ hRest₁; injection hRest₁ with hV₂ hRest₂ + injection hRest₂ with hV₃ hRest₃; injection hRest₃ with hV₄ _ + subst hV₁ hV₂ hV₃ hV₄ + rw [ihTy repTy₂, ihVal repVal₂, ihBody repBody₂] + | share cell₁ repIdx₁ => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i repIdx₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs; injection hArgs with hV _ + subst hV + exact congrArg IxVMIExpr.share (repU64_det large repIdx₁ repIdx₂) + +/-! ## 4. `IxVMKUniv` (`KernelTypes::KLevel`) Representation, `HeapMono`, and Determinism -/ + +/-- Mathematical AST of `KernelTypes::KLevel` kernel universe levels. -/ +inductive IxVMKUniv (F : Type) where + | zero : IxVMKUniv F + | succ (u : IxVMKUniv F) : IxVMKUniv F + | max (u v : IxVMKUniv F) : IxVMKUniv F + | imax (u v : IxVMKUniv F) : IxVMKUniv F + | param (idx : F) : IxVMKUniv F + deriving Repr, DecidableEq + +/-- Heap representation predicate for `KernelTypes::KLevel = &KernelTypes::KLevelNode`. -/ +inductive RepIxVMKUniv (h : Heap F) : IxVMKUniv F → SourceValue F → Prop where + | zero {addr : Nat} + (cell : h[addr]? = some (.construct "KernelTypes::KLevelNode" "Zero" [])) : + RepIxVMKUniv h .zero (.ptr (.enum "KernelTypes::KLevelNode") addr) + | succ {addr : Nat} {u : IxVMKUniv F} {uPtr : SourceValue F} + (cell : h[addr]? = some (.construct "KernelTypes::KLevelNode" "Succ" [uPtr])) + (inner : RepIxVMKUniv h u uPtr) : + RepIxVMKUniv h (.succ u) (.ptr (.enum "KernelTypes::KLevelNode") addr) + | max {addr : Nat} {u v : IxVMKUniv F} {uPtr vPtr : SourceValue F} + (cell : h[addr]? = some (.construct "KernelTypes::KLevelNode" "Max" [uPtr, vPtr])) + (left : RepIxVMKUniv h u uPtr) + (right : RepIxVMKUniv h v vPtr) : + RepIxVMKUniv h (.max u v) (.ptr (.enum "KernelTypes::KLevelNode") addr) + | imax {addr : Nat} {u v : IxVMKUniv F} {uPtr vPtr : SourceValue F} + (cell : h[addr]? = some (.construct "KernelTypes::KLevelNode" "IMax" [uPtr, vPtr])) + (left : RepIxVMKUniv h u uPtr) + (right : RepIxVMKUniv h v vPtr) : + RepIxVMKUniv h (.imax u v) (.ptr (.enum "KernelTypes::KLevelNode") addr) + | param {addr : Nat} {idx : F} + (cell : h[addr]? = some (.construct "KernelTypes::KLevelNode" "Param" [.field idx])) : + RepIxVMKUniv h (.param idx) (.ptr (.enum "KernelTypes::KLevelNode") addr) + +theorem RepIxVMKUniv.mono {h₁ h₂ : Heap F} {u : IxVMKUniv F} {ptr : SourceValue F} + (ext : Heap.Extends h₁ h₂) (rep : RepIxVMKUniv h₁ u ptr) : + RepIxVMKUniv h₂ u ptr := by + induction rep with + | zero cell => exact .zero (ext.getElem?_eq cell) + | succ cell _ ih => exact .succ (ext.getElem?_eq cell) ih + | max cell _ _ ihl ihr => exact .max (ext.getElem?_eq cell) ihl ihr + | imax cell _ _ ihl ihr => exact .imax (ext.getElem?_eq cell) ihl ihr + | param cell => exact .param (ext.getElem?_eq cell) + +theorem repIxVMKUniv_heapMono₂ : HeapMono₂ (RepIxVMKUniv (F := F)) := + fun _ _ _ _ ext rep => rep.mono ext + +theorem HeapMono.repIxVMKUniv (u : IxVMKUniv F) : + HeapMono (fun h ptr => RepIxVMKUniv h u ptr) := + fun _ _ _ ext rep => rep.mono ext + +theorem RepIxVMKUniv.det {h : Heap F} {u₁ u₂ : IxVMKUniv F} {ptr : SourceValue F} + (h₁ : RepIxVMKUniv h u₁ ptr) (h₂ : RepIxVMKUniv h u₂ ptr) : u₁ = u₂ := by + induction h₁ generalizing u₂ with + | zero cell₁ => + cases h₂ <;> rw [cell₁] at * <;> (clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + | succ cell₁ _ ih => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i inner₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs; injection hArgs with hV _ + subst hV + exact congrArg IxVMKUniv.succ (ih inner₂) + | max cell₁ _ _ ihl ihr => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i left₂ right₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs + injection hArgs with hV₁ hRest; injection hRest with hV₂ _ + subst hV₁ hV₂ + rw [ihl left₂, ihr right₂] + | imax cell₁ _ _ ihl ihr => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i left₂ right₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs + injection hArgs with hV₁ hRest; injection hRest with hV₂ _ + subst hV₁ hV₂ + rw [ihl left₂, ihr right₂] + | param cell₁ => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs; injection hArgs with hV _ + injection hV with hField + subst hField + rfl + +/-! ## 5. `IxVMKExpr` (`KernelTypes::KExpr`) Representation, `HeapMono`, and Determinism -/ + +/-- Mathematical AST of `KernelTypes::KExpr` kernel expressions. -/ +inductive IxVMKExpr (F : Type) where + | bvar (idx : F) : IxVMKExpr F + | sort (lvl : IxVMKUniv F) : IxVMKExpr F + | const (name : Address) (lvls : _root_.List (IxVMKUniv F)) : IxVMKExpr F + | app (func arg : IxVMKExpr F) : IxVMKExpr F + | lam (ty body : IxVMKExpr F) : IxVMKExpr F + | forallE (ty body : IxVMKExpr F) : IxVMKExpr F + | letE (ty val body : IxVMKExpr F) : IxVMKExpr F + | litNat (limbs : _root_.List UInt64) : IxVMKExpr F + | litStr (bytes : _root_.List UInt8) : IxVMKExpr F + | proj (typeName : Address) (idx : F) (structExpr : IxVMKExpr F) : IxVMKExpr F + +/-- Heap representation predicate for `KernelTypes::KExpr = &KernelTypes::KExprNode`. -/ +inductive RepIxVMKExpr [NatCast F] (addrTy : Ty) (lvlListEnum limbListEnum byteListEnum : String) + (h : Heap F) : IxVMKExpr F → SourceValue F → Prop where + | bvar {addr : Nat} {idx : F} + (cell : h[addr]? = some (.construct "KernelTypes::KExprNode" "BVar" [.field idx])) : + RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h (.bvar idx) + (.ptr (.enum "KernelTypes::KExprNode") addr) + | sort {addr : Nat} {lvl : IxVMKUniv F} {lvlPtr : SourceValue F} + (cell : h[addr]? = some (.construct "KernelTypes::KExprNode" "Srt" [lvlPtr])) + (repLvl : RepIxVMKUniv h lvl lvlPtr) : + RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h (.sort lvl) + (.ptr (.enum "KernelTypes::KExprNode") addr) + | const {addr : Nat} {name : Address} {lvls : _root_.List (IxVMKUniv F)} + {namePtr lvlsPtr : SourceValue F} + (cell : h[addr]? = some (.construct "KernelTypes::KExprNode" "Const" [namePtr, lvlsPtr])) + (repName : RepAddressRef addrTy h name namePtr) + (repLvls : RepList lvlListEnum RepIxVMKUniv h lvls lvlsPtr) : + RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h (.const name lvls) + (.ptr (.enum "KernelTypes::KExprNode") addr) + | app {addr : Nat} {func arg : IxVMKExpr F} {fnPtr argPtr : SourceValue F} + (cell : h[addr]? = some (.construct "KernelTypes::KExprNode" "App" [fnPtr, argPtr])) + (repFn : RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h func fnPtr) + (repArg : RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h arg argPtr) : + RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h (.app func arg) + (.ptr (.enum "KernelTypes::KExprNode") addr) + | lam {addr : Nat} {ty body : IxVMKExpr F} {tyPtr bodyPtr : SourceValue F} + (cell : h[addr]? = some (.construct "KernelTypes::KExprNode" "Lam" [tyPtr, bodyPtr])) + (repTy : RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h ty tyPtr) + (repBody : RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h body bodyPtr) : + RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h (.lam ty body) + (.ptr (.enum "KernelTypes::KExprNode") addr) + | forallE {addr : Nat} {ty body : IxVMKExpr F} {tyPtr bodyPtr : SourceValue F} + (cell : h[addr]? = some (.construct "KernelTypes::KExprNode" "Forall" [tyPtr, bodyPtr])) + (repTy : RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h ty tyPtr) + (repBody : RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h body bodyPtr) : + RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h (.forallE ty body) + (.ptr (.enum "KernelTypes::KExprNode") addr) + | letE {addr : Nat} {ty val body : IxVMKExpr F} {tyPtr valPtr bodyPtr : SourceValue F} + (cell : h[addr]? = some (.construct "KernelTypes::KExprNode" "Let" [tyPtr, valPtr, bodyPtr])) + (repTy : RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h ty tyPtr) + (repVal : RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h val valPtr) + (repBody : RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h body bodyPtr) : + RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h (.letE ty val body) + (.ptr (.enum "KernelTypes::KExprNode") addr) + | litNat {addr : Nat} {limbs : _root_.List UInt64} {limbsPtr : SourceValue F} + (cell : h[addr]? = some (.construct "KernelTypes::KExprNode" "Lit" + [.construct "KernelTypes::KLiteral" "Nat" [limbsPtr]])) + (repLimbs : RepList limbListEnum RepU64 h limbs limbsPtr) : + RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h (.litNat limbs) + (.ptr (.enum "KernelTypes::KExprNode") addr) + | litStr {addr : Nat} {bytes : _root_.List UInt8} {bytesPtr : SourceValue F} + (cell : h[addr]? = some (.construct "KernelTypes::KExprNode" "Lit" + [.construct "KernelTypes::KLiteral" "Str" [bytesPtr]])) + (repBytes : RepByteStream byteListEnum h bytes bytesPtr) : + RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h (.litStr bytes) + (.ptr (.enum "KernelTypes::KExprNode") addr) + | proj {addr : Nat} {typeName : Address} {idx : F} {structExpr : IxVMKExpr F} + {namePtr structPtr : SourceValue F} + (cell : h[addr]? = some (.construct "KernelTypes::KExprNode" "Proj" + [namePtr, .field idx, structPtr])) + (repName : RepAddressRef addrTy h typeName namePtr) + (repStruct : RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h structExpr structPtr) : + RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h (.proj typeName idx structExpr) + (.ptr (.enum "KernelTypes::KExprNode") addr) + +theorem RepIxVMKExpr.mono [NatCast F] {addrTy : Ty} {lvlListEnum limbListEnum byteListEnum : String} + {h₁ h₂ : Heap F} {e : IxVMKExpr F} {ptr : SourceValue F} + (ext : Heap.Extends h₁ h₂) + (rep : RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h₁ e ptr) : + RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h₂ e ptr := by + induction rep with + | bvar cell => exact .bvar (ext.getElem?_eq cell) + | sort cell repLvl => exact .sort (ext.getElem?_eq cell) (repLvl.mono ext) + | const cell repName repLvls => + exact .const (ext.getElem?_eq cell) + (repAddressRef_heapMono₂ addrTy ext repName) + (repList_heapMono₂ lvlListEnum repIxVMKUniv_heapMono₂ ext repLvls) + | app cell _ _ ihFn ihArg => + exact .app (ext.getElem?_eq cell) ihFn ihArg + | lam cell _ _ ihTy ihBody => + exact .lam (ext.getElem?_eq cell) ihTy ihBody + | forallE cell _ _ ihTy ihBody => + exact .forallE (ext.getElem?_eq cell) ihTy ihBody + | letE cell _ _ _ ihTy ihVal ihBody => + exact .letE (ext.getElem?_eq cell) ihTy ihVal ihBody + | litNat cell repLimbs => + exact .litNat (ext.getElem?_eq cell) + (repList_heapMono₂ limbListEnum repU64_heapMono₂ ext repLimbs) + | litStr cell repBytes => + exact .litStr (ext.getElem?_eq cell) + (repByteStream_heapMono₂ byteListEnum ext repBytes) + | proj cell repName _ ihStruct => + exact .proj (ext.getElem?_eq cell) + (repAddressRef_heapMono₂ addrTy ext repName) ihStruct + +theorem HeapMono.repIxVMKExpr [NatCast F] (addrTy : Ty) (lvlListEnum limbListEnum byteListEnum : String) + (e : IxVMKExpr F) : + HeapMono (fun h ptr => RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h e ptr) := + fun _ _ _ ext rep => rep.mono ext + +theorem RepIxVMKExpr.det [Field F] (large : U32.Compatible F) + {addrTy : Ty} {lvlListEnum limbListEnum byteListEnum : String} + {h : Heap F} {e₁ e₂ : IxVMKExpr F} {ptr : SourceValue F} + (h₁ : RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h e₁ ptr) + (h₂ : RepIxVMKExpr addrTy lvlListEnum limbListEnum byteListEnum h e₂ ptr) : + e₁ = e₂ := by + induction h₁ generalizing e₂ with + | bvar cell₁ => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs; injection hArgs with hV _ + injection hV with hField + subst hField + rfl + | sort cell₁ repLvl₁ => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i repLvl₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs; injection hArgs with hV _ + subst hV + exact congrArg IxVMKExpr.sort (repLvl₁.det repLvl₂) + | const cell₁ repName₁ repLvls₁ => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i repName₂ repLvls₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs + injection hArgs with hV₁ hRest; injection hRest with hV₂ _ + subst hV₁ hV₂ + rw [repAddressRef_det large repName₁ repName₂, + repList_det RepIxVMKUniv.det repLvls₁ repLvls₂] + | app cell₁ _ _ ihFn ihArg => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i repFn₂ repArg₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs + injection hArgs with hV₁ hRest; injection hRest with hV₂ _ + subst hV₁ hV₂ + rw [ihFn repFn₂, ihArg repArg₂] + | lam cell₁ _ _ ihTy ihBody => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i repTy₂ repBody₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs + injection hArgs with hV₁ hRest; injection hRest with hV₂ _ + subst hV₁ hV₂ + rw [ihTy repTy₂, ihBody repBody₂] + | forallE cell₁ _ _ ihTy ihBody => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i repTy₂ repBody₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs + injection hArgs with hV₁ hRest; injection hRest with hV₂ _ + subst hV₁ hV₂ + rw [ihTy repTy₂, ihBody repBody₂] + | letE cell₁ _ _ _ ihTy ihVal ihBody => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i repTy₂ repVal₂ repBody₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs + injection hArgs with hV₁ hRest₁; injection hRest₁ with hV₂ hRest₂; injection hRest₂ with hV₃ _ + subst hV₁ hV₂ hV₃ + rw [ihTy repTy₂, ihVal repVal₂, ihBody repBody₂] + | litNat cell₁ repLimbs₁ => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + · rename_i repLimbs₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs; injection hArgs with hLit _ + injection hLit with _ _ hLitArgs; injection hLitArgs with hPtr _ + subst hPtr + exact congrArg IxVMKExpr.litNat (repList_det (repU64_det large) repLimbs₁ repLimbs₂) + · rename_i _ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs; injection hArgs with hLit _ + injection hLit with _ hLitCtor _ + exact absurd hLitCtor (by decide) + | litStr cell₁ repBytes₁ => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + · rename_i _ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs; injection hArgs with hLit _ + injection hLit with _ hLitCtor _ + exact absurd hLitCtor (by decide) + · rename_i repBytes₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs; injection hArgs with hLit _ + injection hLit with _ _ hLitArgs; injection hLitArgs with hPtr _ + subst hPtr + exact congrArg IxVMKExpr.litStr (repList_det (repU8_inj large) repBytes₁ repBytes₂) + | proj cell₁ repName₁ _ ihStruct => + cases h₂ <;> (rw [cell₁] at *; clear cell₁; try (injection ‹some _ = some _› with hC; injection hC with _ hCtor _; exact absurd hCtor (by decide))) + rename_i repName₂ repStruct₂ cell₂ + injection cell₂ with hC; injection hC with _ _ hArgs + injection hArgs with hV₁ hRest₁; injection hRest₁ with hV₂ hRest₂; injection hRest₂ with hV₃ _ + injection hV₂ with hField + subst hV₁ hField hV₃ + rw [repAddressRef_det large repName₁ repName₂, ihStruct repStruct₂] + +/-! ## 6. `IxVMRoleCtx` (`KernelRoles::RoleCtx`) Representation, `HeapMono`, and Determinism -/ + +/-- Mathematical AST of `KernelRoles::RoleEvidence`. -/ +inductive IxVMRoleEvidence where + | defeq : IxVMRoleEvidence + | proof (addr : Address) : IxVMRoleEvidence + +/-- Heap representation predicate for `KernelRoles::RoleEvidence`. -/ +inductive RepRoleEvidence [NatCast F] (addrTy : Ty) (h : Heap F) : + IxVMRoleEvidence → SourceValue F → Prop where + | defeq : + RepRoleEvidence addrTy h .defeq (.construct "KernelRoles::RoleEvidence" "Defeq" []) + | proof {addr : Address} {addrPtr : SourceValue F} + (repAddr : RepAddressRef addrTy h addr addrPtr) : + RepRoleEvidence addrTy h (.proof addr) + (.construct "KernelRoles::RoleEvidence" "Proof" [addrPtr]) + +theorem RepRoleEvidence.mono [NatCast F] {addrTy : Ty} {h₁ h₂ : Heap F} + {ev : IxVMRoleEvidence} {v : SourceValue F} + (ext : Heap.Extends h₁ h₂) (rep : RepRoleEvidence addrTy h₁ ev v) : + RepRoleEvidence addrTy h₂ ev v := by + cases rep with + | defeq => exact .defeq + | proof repAddr => exact .proof (repAddressRef_heapMono₂ addrTy ext repAddr) + +theorem repRoleEvidence_heapMono₂ [NatCast F] (addrTy : Ty) : + HeapMono₂ (RepRoleEvidence (F := F) addrTy) := + fun _ _ _ _ ext rep => rep.mono ext + +theorem RepRoleEvidence.det [Field F] (large : U32.Compatible F) {addrTy : Ty} {h : Heap F} + {ev₁ ev₂ : IxVMRoleEvidence} {v : SourceValue F} + (h₁ : RepRoleEvidence addrTy h ev₁ v) (h₂ : RepRoleEvidence addrTy h ev₂ v) : + ev₁ = ev₂ := by + revert h₂ + generalize hv : v = v' + intro h₂ + cases h₁ with + | defeq => + cases h₂ with + | defeq => rfl + | proof _ => + injection hv with _ hCtor _ + exact absurd hCtor (by decide) + | proof repAddr₁ => + cases h₂ with + | defeq => + injection hv with _ hCtor _ + exact absurd hCtor (by decide) + | proof repAddr₂ => + injection hv with _ _ hArgs + injection hArgs with hPtr _ + subst hPtr + exact congrArg IxVMRoleEvidence.proof (repAddressRef_det large repAddr₁ repAddr₂) + +/-- Mathematical model of `KernelRoles::RoleTableNode`. -/ +structure IxVMRoleTable (F : Type) where + binding : Address + byRole : RBTree F Address + byAddr : RBTree Address F + +@[ext] +theorem IxVMRoleTable.ext {t₁ t₂ : IxVMRoleTable F} + (hb : t₁.binding = t₂.binding) + (hr : t₁.byRole = t₂.byRole) + (ha : t₁.byAddr = t₂.byAddr) : t₁ = t₂ := by + cases t₁; cases t₂ + dsimp only at hb hr ha + rw [hb, hr, ha] + +/-- Mathematical model of `KernelRoles::RoleCtxNode`. -/ +inductive IxVMRoleCtx (F : Type) where + | mk (table : IxVMRoleTable F) (limit : F) : IxVMRoleCtx F + | assumed (table : IxVMRoleTable F) : IxVMRoleCtx F + +/-- Label representation for `RoleMap` (`(color, roleKey, addr)`). -/ +def RepRoleAddrLabel [NatCast F] (addrTy : Ty) (h : Heap F) + (lbl : Nat × F × Address) (v : SourceValue F) : Prop := + ∃ addrPtr, v = .tuple [.field (lbl.1 : F), .field lbl.2.1, addrPtr] ∧ + RepAddressRef addrTy h lbl.2.2 addrPtr + +theorem repRoleAddrLabel_heapMono₂ [NatCast F] (addrTy : Ty) : + HeapMono₂ (RepRoleAddrLabel (F := F) addrTy) := by + intro h₁ h₂ lbl v ext ⟨addrPtr, hv, hAddr⟩ + exact ⟨addrPtr, hv, repAddressRef_heapMono₂ addrTy ext hAddr⟩ + +theorem repRoleAddrLabel_det [Field F] (large : U32.Compatible F) {addrTy : Ty} {h : Heap F} + {l₁ l₂ : Nat × F × Address} {v : SourceValue F} + (hColor₁ : l₁.1 < 256) (hColor₂ : l₂.1 < 256) + (h₁ : RepRoleAddrLabel addrTy h l₁ v) (h₂ : RepRoleAddrLabel addrTy h l₂ v) : + l₁ = l₂ := by + obtain ⟨ptr₁, rfl, hAddr₁⟩ := h₁ + obtain ⟨ptr₂, hEq, hAddr₂⟩ := h₂ + injection hEq with hList + injection hList with hC hRest₁ + injection hRest₁ with hK hRest₂ + injection hRest₂ with hP _ + injection hC with hCField + injection hK with hKField + subst hP + rcases l₁ with ⟨c₁, k₁, a₁⟩ + rcases l₂ with ⟨c₂, k₂, a₂⟩ + have hc := nat_lt_256_inj large hColor₁ hColor₂ hCField + have ha := repAddressRef_det large hAddr₁ hAddr₂ + subst hc hKField ha + rfl + +/-- Heap representation predicate for `KernelRoles::RoleCtx`. -/ +inductive RepRoleCtx [NatCast F] (addrTy : Ty) (byRoleEnum byAddrEnum : String) + (RByRole : Heap F → (Nat × F × Address) → SourceValue F → Prop) + (RByAddr : Heap F → (Nat × Address × F) → SourceValue F → Prop) + (h : Heap F) : IxVMRoleCtx F → SourceValue F → Prop where + | mk {ctxAddr tblAddr : Nat} {tbl : IxVMRoleTable F} {limit : F} + {bindingPtr byRolePtr byAddrPtr evPtr : SourceValue F} + (ctxCell : h[ctxAddr]? = some (.construct "KernelRoles::RoleCtxNode" "Mk" + [.ptr (.enum "KernelRoles::RoleTableNode") tblAddr, .field limit])) + (tblCell : h[tblAddr]? = some (.construct "KernelRoles::RoleTableNode" "Mk" + [bindingPtr, byRolePtr, byAddrPtr, evPtr])) + (repBinding : RepAddressRef addrTy h tbl.binding bindingPtr) + (repByRole : RepRBTreePtr byRoleEnum "Nil" "Node" RByRole h tbl.byRole byRolePtr) + (repByAddr : RepRBTreePtr byAddrEnum "Nil" "Node" RByAddr h tbl.byAddr byAddrPtr) : + RepRoleCtx addrTy byRoleEnum byAddrEnum RByRole RByAddr h (.mk tbl limit) + (.ptr (.enum "KernelRoles::RoleCtxNode") ctxAddr) + | assumed {ctxAddr tblAddr : Nat} {tbl : IxVMRoleTable F} + {bindingPtr byRolePtr byAddrPtr evPtr : SourceValue F} + (ctxCell : h[ctxAddr]? = some (.construct "KernelRoles::RoleCtxNode" "Assumed" + [.ptr (.enum "KernelRoles::RoleTableNode") tblAddr])) + (tblCell : h[tblAddr]? = some (.construct "KernelRoles::RoleTableNode" "Mk" + [bindingPtr, byRolePtr, byAddrPtr, evPtr])) + (repBinding : RepAddressRef addrTy h tbl.binding bindingPtr) + (repByRole : RepRBTreePtr byRoleEnum "Nil" "Node" RByRole h tbl.byRole byRolePtr) + (repByAddr : RepRBTreePtr byAddrEnum "Nil" "Node" RByAddr h tbl.byAddr byAddrPtr) : + RepRoleCtx addrTy byRoleEnum byAddrEnum RByRole RByAddr h (.assumed tbl) + (.ptr (.enum "KernelRoles::RoleCtxNode") ctxAddr) + +theorem RepRoleCtx.mono [NatCast F] {addrTy : Ty} {byRoleEnum byAddrEnum : String} + {RByRole : Heap F → (Nat × F × Address) → SourceValue F → Prop} + {RByAddr : Heap F → (Nat × Address × F) → SourceValue F → Prop} + (hMonoRole : HeapMono₂ RByRole) (hMonoAddr : HeapMono₂ RByAddr) + {h₁ h₂ : Heap F} {rc : IxVMRoleCtx F} {ptr : SourceValue F} + (ext : Heap.Extends h₁ h₂) + (rep : RepRoleCtx addrTy byRoleEnum byAddrEnum RByRole RByAddr h₁ rc ptr) : + RepRoleCtx addrTy byRoleEnum byAddrEnum RByRole RByAddr h₂ rc ptr := by + cases rep with + | mk ctxCell tblCell repBinding repByRole repByAddr => + exact .mk (ext.getElem?_eq ctxCell) (ext.getElem?_eq tblCell) + (repAddressRef_heapMono₂ addrTy ext repBinding) + (RepRBTreePtr.mono hMonoRole ext repByRole) + (RepRBTreePtr.mono hMonoAddr ext repByAddr) + | assumed ctxCell tblCell repBinding repByRole repByAddr => + exact .assumed (ext.getElem?_eq ctxCell) (ext.getElem?_eq tblCell) + (repAddressRef_heapMono₂ addrTy ext repBinding) + (RepRBTreePtr.mono hMonoRole ext repByRole) + (RepRBTreePtr.mono hMonoAddr ext repByAddr) + +theorem HeapMono.repRoleCtx [NatCast F] (addrTy : Ty) (byRoleEnum byAddrEnum : String) + {RByRole : Heap F → (Nat × F × Address) → SourceValue F → Prop} + {RByAddr : Heap F → (Nat × Address × F) → SourceValue F → Prop} + (hMonoRole : HeapMono₂ RByRole) (hMonoAddr : HeapMono₂ RByAddr) + (rc : IxVMRoleCtx F) : + HeapMono (fun h ptr => RepRoleCtx addrTy byRoleEnum byAddrEnum RByRole RByAddr h rc ptr) := + fun _ _ _ ext rep => rep.mono hMonoRole hMonoAddr ext + +theorem RepRoleCtx.det [Field F] (large : U32.Compatible F) + {addrTy : Ty} {byRoleEnum byAddrEnum : String} + {RByRole : Heap F → (Nat × F × Address) → SourceValue F → Prop} + {RByAddr : Heap F → (Nat × Address × F) → SourceValue F → Prop} + {h : Heap F} + (hDetRole : ∀ {x₁ x₂ v}, RByRole h x₁ v → RByRole h x₂ v → x₁ = x₂) + (hDetAddr : ∀ {x₁ x₂ v}, RByAddr h x₁ v → RByAddr h x₂ v → x₁ = x₂) + {rc₁ rc₂ : IxVMRoleCtx F} {ptr : SourceValue F} + (h₁ : RepRoleCtx addrTy byRoleEnum byAddrEnum RByRole RByAddr h rc₁ ptr) + (h₂ : RepRoleCtx addrTy byRoleEnum byAddrEnum RByRole RByAddr h rc₂ ptr) : + rc₁ = rc₂ := by + cases h₁ with + | mk ctxCell₁ tblCell₁ repBinding₁ repByRole₁ repByAddr₁ => + cases h₂ with + | mk ctxCell₂ tblCell₂ repBinding₂ repByRole₂ repByAddr₂ => + rw [ctxCell₁] at ctxCell₂ + injection ctxCell₂ with hCtx + injection hCtx with _ _ hCtxArgs + injection hCtxArgs with hTblPtr hCtxRest + injection hCtxRest with hLim _ + injection hTblPtr with _ hTblAddr + injection hLim with hLimEq + subst hTblAddr hLimEq + rw [tblCell₁] at tblCell₂ + injection tblCell₂ with hTbl + injection hTbl with _ _ hTblArgs + injection hTblArgs with hB₁ hT₁ + injection hT₁ with hB₂ hT₂ + injection hT₂ with hB₃ _ + subst hB₁ hB₂ hB₃ + have hb := repAddressRef_det large repBinding₁ repBinding₂ + have hr := repRBTreePtr_det (by decide) hDetRole repByRole₁ repByRole₂ + have ha := repRBTreePtr_det (by decide) hDetAddr repByAddr₁ repByAddr₂ + rw [IxVMRoleTable.ext hb hr ha] + | assumed ctxCell₂ _ _ _ _ => + rw [ctxCell₁] at ctxCell₂ + injection ctxCell₂ with hCtx + injection hCtx with _ hCtor _ + exact absurd hCtor (by decide) + | assumed ctxCell₁ tblCell₁ repBinding₁ repByRole₁ repByAddr₁ => + cases h₂ with + | mk ctxCell₂ _ _ _ _ => + rw [ctxCell₁] at ctxCell₂ + injection ctxCell₂ with hCtx + injection hCtx with _ hCtor _ + exact absurd hCtor (by decide) + | assumed ctxCell₂ tblCell₂ repBinding₂ repByRole₂ repByAddr₂ => + rw [ctxCell₁] at ctxCell₂ + injection ctxCell₂ with hCtx + injection hCtx with _ _ hCtxArgs + injection hCtxArgs with hTblPtr _ + injection hTblPtr with _ hTblAddr + subst hTblAddr + rw [tblCell₁] at tblCell₂ + injection tblCell₂ with hTbl + injection hTbl with _ _ hTblArgs + injection hTblArgs with hB₁ hT₁ + injection hT₁ with hB₂ hT₂ + injection hT₂ with hB₃ _ + subst hB₁ hB₂ hB₃ + have hb := repAddressRef_det large repBinding₁ repBinding₂ + have hr := repRBTreePtr_det (by decide) hDetRole repByRole₁ repByRole₂ + have ha := repRBTreePtr_det (by decide) hDetAddr repByAddr₁ repByAddr₂ + rw [IxVMRoleTable.ext hb hr ha] + +/-! ## 7. Ingress Stream Authentication & `TagN` Field-Decoding Correctness -/ + +/-- Ingress stream verification soundness (`Ingress::load_verified_constant`, +`Ingress::load_verified_blob`, `KernelRoles::load_role_table`): reading a finite +byte stream at `(idx, len)` and passing `Blake3::verify_bytes_against` guarantees +a heap-extended `RepByteStream` of length `len < 2^32` whose pure BLAKE3 digest +equals `expectedAddr`. -/ +theorem ingress_verify_stream_sound [Field F] (large : U32.Compatible F) + (enumName : String) (stream : Nat → UInt8) (idx len : Nat) (h : Heap F) + (expectedAddr : Address) + (hDepth : Word.depthChecked (readByteStream stream idx len) = some len) + (hVerify : Blake3.addressToFields F (Blake3.digest (readByteStream stream idx len)) = + Blake3.addressToFields F expectedAddr) : + let bytes := readByteStream stream idx len + let allocated := allocByteStream enumName h bytes + h.Extends allocated.2 ∧ + RepByteStream enumName allocated.2 bytes allocated.1 ∧ + bytes.length = len ∧ + len < U32.base ∧ + Blake3.digest bytes = expectedAddr := by + obtain ⟨hDepthIff, hExt, hRep, hLen⟩ := read_finite_byte_stream_spec enumName stream idx len h + exact ⟨hExt, hRep, hLen, hDepthIff.mp hDepth, + (Blake3.verify_bytes_against_iff large (readByteStream stream idx len) expectedAddr).mp hVerify⟩ + +/-- Canonical `SourceValue F` representation of a decoded `Tag4` pair `(flag, value)` +(`(Field, UInt64::U64)` returned by `IxonDeserialize::get_tagn4`). -/ +def RepTag4 [NatCast F] (h : Heap F) (tag : UInt8 × UInt64) (v : SourceValue F) : Prop := + ∃ valTuple, v = .tuple [.field (tag.1.toNat : F), valTuple] ∧ + RepU64 h tag.2 valTuple + +theorem repTag4_heapMono₂ [NatCast F] : HeapMono₂ (RepTag4 (F := F)) := by + intro h₁ h₂ tag v ext ⟨valTuple, hv, hVal⟩ + exact ⟨valTuple, hv, repU64_heapMono₂ ext hVal⟩ + +theorem repTag4_inj [Field F] (large : U32.Compatible F) {h : Heap F} + {t₁ t₂ : UInt8 × UInt64} {v : SourceValue F} + (h₁ : RepTag4 h t₁ v) (h₂ : RepTag4 h t₂ v) : + t₁ = t₂ := by + obtain ⟨val₁, rfl, hVal₁⟩ := h₁ + obtain ⟨val₂, hEq, hVal₂⟩ := h₂ + injection hEq with hList + injection hList with hFlag hRest + injection hRest with hVal _ + subst hVal + rcases t₁ with ⟨f₁, w₁⟩ + rcases t₂ with ⟨f₂, w₂⟩ + have hf := repU8_inj large (h := ([] : Heap F)) rfl hFlag + have hw := repU64_det large hVal₁ hVal₂ + subst hf hw + rfl + +/-- Uniqueness of splitting a header byte into `flag * 32 + low5` with `low5 < 32`. -/ +theorem tag_header_split_unique {f₁ l₁ f₂ l₂ : Nat} + (hl₁ : l₁ < 32) (hl₂ : l₂ < 32) + (hEq : f₁ * 32 + l₁ = f₂ * 32 + l₂) : + f₁ = f₂ ∧ l₁ = l₂ := by + omega + +/-- Uniqueness of `get_tagn4` header decomposition `low3 + 8 * cont + 16 * flag` +(`low3 < 8`, `cont < 2`). -/ +theorem tagn4_header_split_unique {l₁ c₁ f₁ l₂ c₂ f₂ : Nat} + (hl₁ : l₁ < 8) (hc₁ : c₁ < 2) + (hl₂ : l₂ < 8) (hc₂ : c₂ < 2) + (hEq : l₁ + 8 * c₁ + 16 * f₁ = l₂ + 8 * c₂ + 16 * f₂) : + l₁ = l₂ ∧ c₁ = c₂ ∧ f₁ = f₂ := by + omega + +/-- Uniqueness of `get_tagn2` header decomposition `low5 + 32 * cont + 64 * flag` +(`low5 < 32`, `cont < 2`). -/ +theorem tagn2_header_split_unique {l₁ c₁ f₁ l₂ c₂ f₂ : Nat} + (hl₁ : l₁ < 32) (hc₁ : c₁ < 2) + (hl₂ : l₂ < 32) (hc₂ : c₂ < 2) + (hEq : l₁ + 32 * c₁ + 64 * f₁ = l₂ + 32 * c₂ + 64 * f₂) : + l₁ = l₂ ∧ c₁ = c₂ ∧ f₁ = f₂ := by + omega + +/-- Natural-number value of up to 8 little-endian bytes, zero-padding higher bytes +(matching `IxonDeserialize::get_u64_le`). -/ +def u64ValLeBytes (bytes : _root_.List UInt8) : Nat := + (bytes.getD 0 0).toNat + + 256 * (bytes.getD 1 0).toNat + + 65536 * (bytes.getD 2 0).toNat + + 16777216 * (bytes.getD 3 0).toNat + + 4294967296 * (bytes.getD 4 0).toNat + + 1099511627776 * (bytes.getD 5 0).toNat + + 281474976710656 * (bytes.getD 6 0).toNat + + 72057594037927936 * (bytes.getD 7 0).toNat + +/-- Construct a `UInt64` from up to 8 little-endian bytes, zero-padding higher bytes +(matching `IxonDeserialize::get_u64_le`). -/ +def u64OfLeBytes (bytes : _root_.List UInt8) : UInt64 := + UInt64.ofNat (u64ValLeBytes bytes) + +theorem u64ValLeBytes_lt (bytes : _root_.List UInt8) : + u64ValLeBytes bytes < 18446744073709551616 := by + have h0 : (bytes.getD 0 0).toNat < 256 := (bytes.getD 0 0).toNat_lt + have h1 : (bytes.getD 1 0).toNat < 256 := (bytes.getD 1 0).toNat_lt + have h2 : (bytes.getD 2 0).toNat < 256 := (bytes.getD 2 0).toNat_lt + have h3 : (bytes.getD 3 0).toNat < 256 := (bytes.getD 3 0).toNat_lt + have h4 : (bytes.getD 4 0).toNat < 256 := (bytes.getD 4 0).toNat_lt + have h5 : (bytes.getD 5 0).toNat < 256 := (bytes.getD 5 0).toNat_lt + have h6 : (bytes.getD 6 0).toNat < 256 := (bytes.getD 6 0).toNat_lt + have h7 : (bytes.getD 7 0).toNat < 256 := (bytes.getD 7 0).toNat_lt + unfold u64ValLeBytes + omega + +theorem toNat_u64OfLeBytes (bytes : _root_.List UInt8) : + (u64OfLeBytes bytes).toNat = u64ValLeBytes bytes := by + rw [u64OfLeBytes, UInt64.toNat_ofNat'] + exact Nat.mod_eq_of_lt (u64ValLeBytes_lt bytes) + +theorem u64OfLeBytes_nil : (u64OfLeBytes []).toNat = 0 := by + decide + +theorem u64OfLeBytes_singleton (b0 : UInt8) : + (u64OfLeBytes [b0]).toNat = b0.toNat := by + rw [toNat_u64OfLeBytes] + simp [u64ValLeBytes] + +theorem u64OfLeBytes_pair (b0 b1 : UInt8) : + (u64OfLeBytes [b0, b1]).toNat = b0.toNat + 256 * b1.toNat := by + rw [toNat_u64OfLeBytes] + simp [u64ValLeBytes] + +/-- Mathematical correctness of the 2-byte `get_tagn_tail` case (`q < h ≤ 64`): +adding `lo + 2 * h = v0 + 256 * carry` and placing `q + carry` in the second limb +reconstructs `lo + 2 * h + 256 * q`. -/ +theorem tagn_tail_two_byte_spec (lo v0 : UInt8) (q h carry : Nat) + (hq : q < h) (hh : h ≤ 64) (hCarry : carry < 2) + (hAdd : lo.toNat + 2 * h = v0.toNat + 256 * carry) : + (u64OfLeBytes [v0, UInt8.ofNat (q + carry)]).toNat = + lo.toNat + 2 * h + 256 * q := by + rw [u64OfLeBytes_pair] + have hqc : (UInt8.ofNat (q + carry)).toNat = q + carry := by + rw [UInt8.toNat_ofNat'] + exact Nat.mod_eq_of_lt (by omega) + rw [hqc] + omega + +end Aiur.Library.IxVMRep diff --git a/Aiur/Aiur/Library/List.lean b/Aiur/Aiur/Library/List.lean new file mode 100644 index 000000000..d15fb5db6 --- /dev/null +++ b/Aiur/Aiur/Library/List.lean @@ -0,0 +1,78 @@ +import Aiur.Modules + +namespace Aiur.Library.List +open Aiur + +def declarations : Modules.Program Nat := aiur% " +module Lists { + enum Node { Cons(T, List), Nil } + type List = &Node; + fn is_empty(list: List) -> Field { + match *list { Node::Nil => 1, Node::Cons(_, _) => 0 } + } + +fn length(list: List) -> Field { + match (*(list)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(_, rest) => { length(rest) + 1 } , + } + } + +fn concat(a: List, b: List) -> List { + match (*(a)) { + Lists::Node::Nil => { b } , + Lists::Node::Cons(v, rest) => { (&(Lists::Node::Cons(v, concat(rest, b)))) } , + } + } + +fn lookup(list: List, idx: Field) -> T { + let Lists::Node::Cons(v, _) = (*(drop(list, idx))); + v + } + +fn lookup_or_default(list: List, idx: Field, default: T) -> T { + match (*(drop(list, idx))) { + Lists::Node::Nil => { default } , + Lists::Node::Cons(v, _) => { v } , + } + } + +fn drop(list: List, n: Field) -> List { + match n { + 0 => { list } , + _ => { + let Lists::Node::Cons(_, rest) = (*(drop(list, n - 1))); + rest } , + } + } + +fn take(list: List, n: Field) -> List { + match n { + 0 => { (&(Lists::Node::Nil)) } , + _ => { + let Lists::Node::Cons(v, rest) = (*(list)); + (&(Lists::Node::Cons(v, take(rest, n - 1)))) } , + } + } + +fn snoc(list: List, v: T) -> List { + match (*(list)) { + Lists::Node::Nil => { (&(Lists::Node::Cons(v, (&(Lists::Node::Nil))))) } , + Lists::Node::Cons(head, rest) => { (&(Lists::Node::Cons(head, snoc(rest, v)))) } , + } + } + +fn reverse(list: List) -> List { + reverse_acc(list, (&(Lists::Node::Nil))) + } + +fn reverse_acc(list: List, acc: List) -> List { + match (*(list)) { + Lists::Node::Nil => { acc } , + Lists::Node::Cons(head, rest) => { + reverse_acc(rest, (&(Lists::Node::Cons(head, acc)))) } , + } + } +}" + +end Aiur.Library.List diff --git a/Aiur/Aiur/Library/List/Correctness.lean b/Aiur/Aiur/Library/List/Correctness.lean new file mode 100644 index 000000000..a9c33ecbc --- /dev/null +++ b/Aiur/Aiur/Library/List/Correctness.lean @@ -0,0 +1,403 @@ +import Aiur.HeapMono +import Aiur.Library.List +import Aiur.Library.List.Word +import Aiur.Library.Option +import Aiur.Library.U32.Correctness +import Aiur.Library.U64.Correctness + +/-! +# Canonical Source Representation Predicates and `Lists` / `WordLists` / `Options` Correctness + +This module establishes: +1. Canonical `SourceValue F` representation predicates `RepU8`, `RepU32`, `RepU64`, + `RepOption` (`Options::Option`), and `RepList` (`Lists::List`) along with + their `HeapMono` / `HeapMono₂` proofs. +2. Heap-allocation constructors (`allocNil`, `allocCons`, `allocList`) and their + heap-extension and representation soundness proofs. +3. Mathematical specifications for `Lists` (`is_empty`, `length`, `concat`, + `drop`, `take`, `lookup`, `lookup_or_default`, `snoc`, `reverse_acc`, `reverse`) + and `WordLists` (`checked_depth_succ`, `depth_checked`, `length_u64`, + `lookup_u64`). +-/ + +namespace Aiur.Library + +open Aiur + +variable {F : Type} + +/-! ### 1. Word Representation Predicates (`RepU8`, `RepU32`, `RepU64`) and `HeapMono` -/ + +/-- Canonical `SourceValue F` representation of a checked byte `UInt8::U8`. -/ +def RepU8 [NatCast F] (_h : Heap F) (b : UInt8) (v : SourceValue F) : Prop := + v = .field (b.toNat : F) + +theorem repU8_heapMono₂ [NatCast F] : HeapMono₂ (RepU8 (F := F)) := + fun _ _ _ _ _ h => h + +theorem repU8_heapMono [NatCast F] (b : UInt8) : + HeapMono (fun h v => RepU8 (F := F) h b v) := + HeapMono.of_heapMono₂ repU8_heapMono₂ b + +theorem repU8_inj [Field F] (large : U32.Compatible F) {h : Heap F} + {a b : UInt8} {v : SourceValue F} + (ha : RepU8 h a v) (hb : RepU8 h b v) : a = b := by + rw [RepU8] at ha hb + have heq : (a.toNat : F) = (b.toNat : F) := Value.field.inj (ha.symm.trans hb) + have ha_lt : a.toNat < 3 * U32.base := by + have := a.toNat_lt; unfold U32.base; omega + have hb_lt : b.toNat < 3 * U32.base := by + have := b.toNat_lt; unfold U32.base; omega + exact UInt8.ext (large ha_lt hb_lt heq) + +/-- Canonical `SourceValue F` representation of a 4-byte little-endian `UInt32::U32`. -/ +def RepU32 [NatCast F] (_h : Heap F) (w : UInt32) (v : SourceValue F) : Prop := + v = .tuple ((List.range 4).map fun i => .field (((w.toNat / 256 ^ i) % 256 : Nat) : F)) + +theorem repU32_heapMono₂ [NatCast F] : HeapMono₂ (RepU32 (F := F)) := + fun _ _ _ _ _ h => h + +theorem repU32_heapMono [NatCast F] (w : UInt32) : + HeapMono (fun h v => RepU32 (F := F) h w v) := + HeapMono.of_heapMono₂ repU32_heapMono₂ w + +/-- Canonical `SourceValue F` representation of an 8-byte little-endian `UInt64::U64`. -/ +def RepU64 [NatCast F] (_h : Heap F) (w : UInt64) (v : SourceValue F) : Prop := + v = .tuple ((List.range 8).map fun i => .field (((w.toNat / 256 ^ i) % 256 : Nat) : F)) + +theorem repU64_heapMono₂ [NatCast F] : HeapMono₂ (RepU64 (F := F)) := + fun _ _ _ _ _ h => h + +theorem repU64_heapMono [NatCast F] (w : UInt64) : + HeapMono (fun h v => RepU64 (F := F) h w v) := + HeapMono.of_heapMono₂ repU64_heapMono₂ w + +/-! ### 2. `RepOption` (`Options::Option`) and `HeapMono` -/ + +/-- Nominal enum symbol for `Options::Option` instantiated at `elemTy`. -/ +def optionEnumName (elemTy : Generic.Ty) : String := + (Generic.Instance.mk "Options::Option" [elemTy]).symbol + +/-- Canonical `SourceValue F` representation of `Options::Option` (`Some(x)` / `None`). -/ +inductive RepOption {α : Type*} (enumName : String) + (R : Heap F → α → SourceValue F → Prop) (h : Heap F) : + Option α → SourceValue F → Prop where + | none : RepOption enumName R h none (.construct enumName "None" []) + | some {x : α} {v : SourceValue F} (hv : R h x v) : + RepOption enumName R h (some x) (.construct enumName "Some" [v]) + +theorem RepOption.mono {α : Type*} {enumName : String} + {R : Heap F → α → SourceValue F → Prop} (hR : HeapMono₂ R) + {h₁ h₂ : Heap F} {opt : Option α} {v : SourceValue F} + (ext : Heap.Extends h₁ h₂) (rep : RepOption enumName R h₁ opt v) : + RepOption enumName R h₂ opt v := by + cases rep with + | none => exact .none + | some hv => exact .some (hR ext hv) + +theorem repOption_heapMono₂ {α : Type*} (enumName : String) + {R : Heap F → α → SourceValue F → Prop} (hR : HeapMono₂ R) : + HeapMono₂ (RepOption enumName R) := + fun _ _ _ _ ext rep => rep.mono hR ext + +theorem repOption_heapMono {α : Type*} (enumName : String) + {R : Heap F → α → SourceValue F → Prop} (hR : HeapMono₂ R) (opt : Option α) : + HeapMono (fun h v => RepOption enumName R h opt v) := + HeapMono.of_heapMono₂ (repOption_heapMono₂ enumName hR) opt + +/-! ### 3. `RepList` (`Lists::List`) and Heap Allocation -/ + +namespace List + +/-- Nominal enum symbol for `Lists::Node` instantiated at `elemTy`. -/ +def nodeEnumName (elemTy : Generic.Ty) : String := + (Generic.Instance.mk "Lists::Node" [elemTy]).symbol + +/-- Canonical `SourceValue F` representation of `Lists::List = &Lists::Node` +stored in `h : Heap F`. -/ +abbrev RepList {α : Type*} (enumName : String) + (R : Heap F → α → SourceValue F → Prop) (h : Heap F) + (xs : _root_.List α) (ptr : SourceValue F) : Prop := + RepLinkedList enumName "Nil" "Cons" R h xs ptr + +theorem repList_heapMono₂ {α : Type*} (enumName : String) + {R : Heap F → α → SourceValue F → Prop} (hR : HeapMono₂ R) : + HeapMono₂ (RepList enumName R) := + fun _ _ _ _ ext rep => rep.mono hR ext + +theorem repList_heapMono {α : Type*} (enumName : String) + {R : Heap F → α → SourceValue F → Prop} (hR : HeapMono₂ R) (xs : _root_.List α) : + HeapMono (fun h ptr => RepList enumName R h xs ptr) := + HeapMono.repLinkedList enumName "Nil" "Cons" hR xs + +theorem repList_inj {α : Type*} {enumName : String} + {R : Heap F → α → SourceValue F → Prop} {h : Heap F} + (hR : ∀ {x₁ x₂ v}, R h x₁ v → R h x₂ v → x₁ = x₂) + {xs₁ xs₂ : _root_.List α} {ptr : SourceValue F} + (h₁ : RepList enumName R h xs₁ ptr) + (h₂ : RepList enumName R h xs₂ ptr) : + xs₁ = xs₂ := by + induction h₁ generalizing xs₂ with + | nil cell₁ => + cases h₂ with + | nil _ => rfl + | cons cell₂ _ _ => + rw [cell₁] at cell₂ + injection cell₂ with hVal + injection hVal with _ hCtor _ + exact absurd hCtor (by decide) + | cons cell₁ headRep₁ _ ih => + cases h₂ with + | nil cell₂ => + rw [cell₁] at cell₂ + injection cell₂ with hVal + injection hVal with _ hCtor _ + exact absurd hCtor.symm (by decide) + | cons cell₂ headRep₂ tailRep₂ => + rw [cell₁] at cell₂ + injection cell₂ with hVal + injection hVal with _ _ hArgs + injection hArgs with hHead hTail + injection hTail with hTailPtr _ + subst hHead hTailPtr + exact _root_.List.cons_eq_cons.mpr ⟨hR headRep₁ headRep₂, ih tailRep₂⟩ + +/-- Allocate `&Lists::Node::Nil` at the end of `h : Heap F`. -/ +def allocNil (enumName : String) (h : Heap F) : SourceValue F × Heap F := + (.ptr (.enum enumName) h.length, h ++ [.construct enumName "Nil" []]) + +theorem allocNil_extends (enumName : String) (h : Heap F) : + Heap.Extends h (allocNil enumName h).2 := + Heap.Extends.snoc h _ + +theorem allocNil_rep {α : Type*} (enumName : String) + (R : Heap F → α → SourceValue F → Prop) (h : Heap F) : + RepList enumName R (allocNil enumName h).2 [] (allocNil enumName h).1 := by + exact .nil (by simp [allocNil]) + +/-- Allocate `&(Lists::Node::Cons(headVal, tailPtr))` at the end of `h : Heap F`. -/ +def allocCons (enumName : String) (headVal tailPtr : SourceValue F) (h : Heap F) : + SourceValue F × Heap F := + (.ptr (.enum enumName) h.length, h ++ [.construct enumName "Cons" [headVal, tailPtr]]) + +theorem allocCons_extends (enumName : String) (headVal tailPtr : SourceValue F) (h : Heap F) : + Heap.Extends h (allocCons enumName headVal tailPtr h).2 := + Heap.Extends.snoc h _ + +theorem allocCons_rep {α : Type*} (enumName : String) + {R : Heap F → α → SourceValue F → Prop} (hR : HeapMono₂ R) + {h : Heap F} {x : α} {xs : _root_.List α} {headVal tailPtr : SourceValue F} + (hx : R h x headVal) (hxs : RepList enumName R h xs tailPtr) : + RepList enumName R (allocCons enumName headVal tailPtr h).2 (x :: xs) + (allocCons enumName headVal tailPtr h).1 := by + have ext := allocCons_extends enumName headVal tailPtr h + exact .cons (by simp [allocCons]) (hR ext hx) (hxs.mono hR ext) + +/-- Allocate a full linked list of pre-encoded `SourceValue F` elements in `h : Heap F`. -/ +def allocValues (enumName : String) (h : Heap F) : + _root_.List (SourceValue F) → SourceValue F × Heap F + | [] => allocNil enumName h + | v :: vs => + let (tailPtr, h₁) := allocValues enumName h vs + allocCons enumName v tailPtr h₁ + +theorem allocValues_extends (enumName : String) (h : Heap F) + (vs : _root_.List (SourceValue F)) : + Heap.Extends h (allocValues enumName h vs).2 := by + induction vs generalizing h with + | nil => exact allocNil_extends enumName h + | cons v vs ih => + dsimp only [allocValues] + exact (ih h).trans (allocCons_extends enumName v (allocValues enumName h vs).1 _) + +theorem allocValues_rep {α : Type*} (enumName : String) + {R : Heap F → α → SourceValue F → Prop} (hR : HeapMono₂ R) + (h : Heap F) {xs : _root_.List α} {vs : _root_.List (SourceValue F)} + (hrel : _root_.List.Forall₂ (R h) xs vs) : + RepList enumName R (allocValues enumName h vs).2 xs (allocValues enumName h vs).1 := by + induction hrel with + | nil => + exact allocNil_rep enumName R h + | @cons x v xs vs hx _ ih => + dsimp only [allocValues] + have ext₁ := allocValues_extends enumName h vs + have hx₁ : R (allocValues enumName h vs).2 x v := hR ext₁ hx + exact allocCons_rep enumName hR hx₁ ih + +/-! ### 4. Specifications of `Lists` Operations -/ + +/-- `Lists::is_empty` returns `1` on `Nil` and `0` on `Cons`. -/ +def isEmpty [Zero F] [One F] (xs : _root_.List α) : F := + match xs with + | [] => 1 + | _ :: _ => 0 + +theorem is_empty_spec [Field F] (xs : _root_.List α) : + (isEmpty xs : F) = if xs.isEmpty then 1 else 0 := by + cases xs <;> rfl + +theorem is_empty_one_iff [Field F] (xs : _root_.List α) : + (isEmpty xs : F) = 1 ↔ xs = [] := by + cases xs <;> simp [isEmpty] + +theorem is_empty_zero_iff [Field F] (xs : _root_.List α) : + (isEmpty xs : F) = 0 ↔ xs ≠ [] := by + cases xs <;> simp [isEmpty] + +/-- `Lists::reverse_acc(list, acc)` computes `list.reverseAux acc = list.reverse ++ acc`. -/ +def reverseAcc (xs acc : _root_.List α) : _root_.List α := + match xs with + | [] => acc + | x :: rest => reverseAcc rest (x :: acc) + +theorem reverse_acc_spec (xs acc : _root_.List α) : + reverseAcc xs acc = xs.reverse ++ acc := by + induction xs generalizing acc with + | nil => simp [reverseAcc] + | cons x rest ih => + simp [reverseAcc, ih, _root_.List.reverse_cons, _root_.List.append_assoc] + +theorem reverse_spec (xs : _root_.List α) : + reverseAcc xs [] = xs.reverse := by + rw [reverse_acc_spec, _root_.List.append_nil] + +theorem snoc_spec (xs : _root_.List α) (v : α) : + xs ++ [v] = _root_.List.concat xs v := by + simp + +/-! ### 5. Specifications of `WordLists` (`depth_checked`, `length_u64`, `lookup_u64`) -/ + +namespace Word + +/-- `WordLists::checked_depth_succ(depth)` checks `UInt32::less_than_fields(depth, 4294967295) == 1` +and returns `depth + 1`. -/ +def checkedDepthSucc (depth : Nat) : Option Nat := + if depth < 4294967295 then some (depth + 1) else none + +/-- `WordLists::depth_checked(list)` recursively computes the list length while asserting +at each step that the depth is `< 2^32 - 1`, so the resulting length fits in `UInt32`. -/ +def depthChecked : _root_.List α → Option Nat + | [] => some 0 + | _ :: rest => do + let d ← depthChecked rest + checkedDepthSucc d + +theorem checked_depth_succ_sound [Field F] (large : U32.Compatible F) + {depth difference : Nat} (hdepth : depth < U32.base) (hdiff : difference < U32.base) + (hborrow : let borrow := ((difference : F) + (4294967295 : Nat) - (depth : F)) / (U32.base : F) + borrow * (borrow - 1) = 0) + (hlt : ((difference : F) + (4294967295 : Nat) - (depth : F)) / (U32.base : F) = 1) : + depth < 4294967295 ∧ depth + 1 < U32.base ∧ + (depth : F) + 1 = ((depth + 1 : Nat) : F) := by + have hcmp := U32.compare_fields_sound large (depth : F) ((4294967295 : Nat) : F) + hdepth (by unfold U32.base; omega) hdiff rfl rfl hborrow + rw [hlt] at hcmp + by_cases h : depth < 4294967295 + · refine ⟨h, by unfold U32.base; omega, by push_cast; rfl⟩ + · simp [h] at hcmp + +theorem depth_checked_iff (xs : _root_.List α) : + depthChecked xs = if xs.length < U32.base then some xs.length else none := by + induction xs with + | nil => + simp [depthChecked, U32.base] + | cons x rest ih => + simp only [depthChecked, ih, _root_.List.length_cons] + by_cases hrest : rest.length < U32.base + · simp only [hrest, ↓reduceIte, checkedDepthSucc] + by_cases hlt : rest.length < 4294967295 + · have hsucc : rest.length + 1 < U32.base := by unfold U32.base; omega + simp [hlt, hsucc] + · have hnsucc : ¬(rest.length + 1 < U32.base) := by unfold U32.base at *; omega + simp [hlt, hnsucc] + · have hnsucc : ¬(rest.length + 1 < U32.base) := by unfold U32.base at *; omega + simp [hrest, hnsucc] + +theorem depth_checked_some_iff (xs : _root_.List α) (n : Nat) : + depthChecked xs = some n ↔ n = xs.length ∧ xs.length < U32.base := by + rw [depth_checked_iff] + by_cases h : xs.length < U32.base + · simp [h, eq_comm] + · simp [h] + +/-- `WordLists::length_u64(list)` computes the 64-bit length by starting at `0 : UInt64` +on `Nil` and applying `UInt64::wrapping_succ` on each `Cons`. -/ +def lengthU64 : _root_.List α → UInt64 + | [] => 0 + | _ :: rest => lengthU64 rest + 1 + +theorem length_u64_spec (xs : _root_.List α) : + lengthU64 xs = UInt64.ofNat xs.length := by + induction xs with + | nil => rfl + | cons _ rest ih => + simp only [lengthU64, ih, _root_.List.length_cons, UInt64.ofNat_add] + rfl + +theorem length_u64_toNat_of_lt {xs : _root_.List α} (hlt : xs.length < U64.base) : + (lengthU64 xs).toNat = xs.length := by + rw [length_u64_spec, UInt64.toNat_ofNat'] + exact Nat.mod_eq_of_lt hlt + +theorem length_u64_of_depth_checked {xs : _root_.List α} {n : Nat} + (hchecked : depthChecked xs = some n) : + (lengthU64 xs).toNat = xs.length ∧ n = xs.length := by + obtain ⟨rfl, hlt32⟩ := (depth_checked_some_iff xs n).mp hchecked + have hlt64 : xs.length < U64.base := by + unfold U32.base U64.base at *; omega + exact ⟨length_u64_toNat_of_lt hlt64, rfl⟩ + +/-- `WordLists::lookup_u64(list, idx)` dereferences `Cons(v, rest)` and returns `v` +when `UInt64::is_zero(idx) == 1`, or recurses with `UInt64::saturating_pred(idx)` +when `UInt64::is_zero(idx) == 0`. -/ +def lookupU64 : _root_.List α → UInt64 → Option α + | [], _ => none + | v :: rest, idx => + if idx.toNat = 0 then + some v + else + lookupU64 rest (UInt64.ofNat (idx.toNat - 1)) + +theorem lookup_u64_spec (xs : _root_.List α) (idx : UInt64) : + lookupU64 xs idx = xs[idx.toNat]? := by + induction xs generalizing idx with + | nil => + simp [lookupU64] + | cons v rest ih => + simp only [lookupU64] + rcases eq_or_ne idx.toNat 0 with h0 | hne + · simp [h0] + · obtain ⟨k, hk⟩ : ∃ k, idx.toNat = k + 1 := ⟨idx.toNat - 1, by omega⟩ + have hlt := idx.toNat_lt + have hmod : k % 18446744073709551616 = k := by omega + simp [ih, hk, hmod] + +theorem lookup_u64_rep {α : Type*} (enumName : String) + (R : Heap F → α → SourceValue F → Prop) + {h : Heap F} {xs : _root_.List α} {ptr : SourceValue F} + (rep : RepList enumName R h xs ptr) (idx : UInt64) {x : α} + (hlookup : lookupU64 xs idx = some x) : + ∃ v : SourceValue F, R h x v := by + rw [lookup_u64_spec] at hlookup + revert idx + induction rep with + | nil => + intro idx hlookup + simp at hlookup + | @cons head tail addr headVal tailPtr _ headRep _ ih => + intro idx hlookup + rcases eq_or_ne idx.toNat 0 with h0 | hne + · rw [h0] at hlookup + simp only [_root_.List.getElem?_cons_zero, Option.some.injEq] at hlookup + subst hlookup + exact ⟨headVal, headRep⟩ + · obtain ⟨k, hk⟩ : ∃ k, idx.toNat = k + 1 := ⟨idx.toNat - 1, by omega⟩ + rw [hk, _root_.List.getElem?_cons_succ] at hlookup + have hlt := idx.toNat_lt + have hk_eq : (UInt64.ofNat k).toNat = k := by + rw [UInt64.toNat_ofNat']; omega + exact ih (UInt64.ofNat k) (by simpa [hk_eq] using hlookup) + +end Word +end List +end Aiur.Library diff --git a/Aiur/Aiur/Library/List/Word.lean b/Aiur/Aiur/Library/List/Word.lean new file mode 100644 index 000000000..1f010523d --- /dev/null +++ b/Aiur/Aiur/Library/List/Word.lean @@ -0,0 +1,48 @@ +import Aiur.Library.List +import Aiur.Library.U32 +import Aiur.Library.U64 + +/-! List operations whose sizes use checked words. Kept separate so the +polymorphic list library has no dependency on a field-specific word encoding. -/ +namespace Aiur.Library.List.Word +open Aiur + +def dependencies : Modules.Program Nat := + U32.templates.append U64.declarations |>.append List.declarations + +def declarations : Modules.Program Nat := aiur_library% dependencies r#" +module WordLists { +fn checked_depth_succ(depth: Field) -> Field { + assert_eq!(UInt32::less_than_fields(depth, 4294967295), 1, + "list depth exceeds u32"); + depth + 1 + } + +fn depth_checked(list: Lists::List) -> Field { + match (*(list)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(_, rest) => { + let depth = depth_checked(rest); + checked_depth_succ(depth) } , + } + } + +fn length_u64(list: Lists::List) -> UInt64::U64 { + match (*(list)) { + Lists::Node::Nil => { [UInt8::BYTE_0; 8] } , + Lists::Node::Cons(_, rest) => { UInt64::wrapping_succ(length_u64(rest)) } , + } + } + +fn lookup_u64(list: Lists::List, idx: UInt64::U64) -> T { + let Lists::Node::Cons(v, rest) = (*(list)); + let z = UInt64::is_zero(idx); + match z { + 1 => { v } , + 0 => { lookup_u64(rest, UInt64::saturating_pred(idx)) } , + } + } +} +"# + +end Aiur.Library.List.Word diff --git a/Aiur/Aiur/Library/Option.lean b/Aiur/Aiur/Library/Option.lean new file mode 100644 index 000000000..a2e309947 --- /dev/null +++ b/Aiur/Aiur/Library/Option.lean @@ -0,0 +1,12 @@ +import Aiur.Modules + +namespace Aiur.Library.Option +open Aiur + +/-- Constructor order matches the legacy library's wire representation. -/ +def declarations : Modules.Program Nat := aiur% " +module Options { + enum Option { Some(T), None } +}" + +end Aiur.Library.Option diff --git a/Aiur/Aiur/Library/RBTreeMap/Correctness.lean b/Aiur/Aiur/Library/RBTreeMap/Correctness.lean new file mode 100644 index 000000000..750575e70 --- /dev/null +++ b/Aiur/Aiur/Library/RBTreeMap/Correctness.lean @@ -0,0 +1,947 @@ +import Aiur.HeapMono +import Aiur.Library.Bytes.Correctness + +/-! +# Red-Black Tree (`RBTreeMap` / `RoleMap`) and Canonical Address Ordering Correctness + +This module formalizes the mathematical specification and correctness theorems for: +1. `canon_addr_cmp`: Lexicographic and 8-chunk big-endian `UInt32` comparison over + 32-byte `Address` values (`Vector UInt8 32`), establishing that `canonAddrCmp` + forms a `LawfulCmp` strict weak order (`irrefl`, `trans`, `asymm`, `trichotomous`, `eq_iff`). +2. `RBTree K V`: Red-black search trees over arbitrary ordered keys (`LawfulCmp cmp`), + bridged to `BinaryTree` and `RepBinaryTree` (`HeapMono`), with Okasaki-style + `balanceFix`, `balance`, `ins`, `rbtreeInsert`, and `rbtreeGet` / `rbtreeLookupOrDefault`. +3. Lookup and BST preservation theorems: `allKeys_balance`, `allKeys_ins`, + `rbtree_bst_balance`, `rbtree_bst_ins`, `rbtree_bst_insert`, `balance_lookup_eq`, + `ins_lookup_eq`, `rbtree_get_insert`, `rbtree_get_insert_self`, `rbtree_get_insert_ne`. +4. Static balanced tree construction (`buildBalancedTree` / `RoleMap` over `0..102` keys): + `toList_buildBalancedTree`, `bst_buildBalancedTree`, `rbtreeGet_eq_some_iff_mem_toList`, + `rbtreeGet_eq_none_iff_forall_ne`, `role_tree_get_eq_some_iff`, and `role_tree_get_eq_none_iff`. +-/ + +namespace Aiur.Library.RBTreeMap + +open Aiur.Library.Bytes + +/-! ## Strict Weak Order Comparison Class (`LawfulCmp`) -/ + +/-- A comparison function `cmp : K → K → Ordering` is lawful when `.eq` coincides +with equality, `.lt` is transitive, and `.gt` is the dual of `.lt`. -/ +structure LawfulCmp {K : Type*} (cmp : K → K → Ordering) : Prop where + eq_iff : ∀ x y, cmp x y = .eq ↔ x = y + lt_trans : ∀ {x y z}, cmp x y = .lt → cmp y z = .lt → cmp x z = .lt + gt_iff : ∀ x y, cmp x y = .gt ↔ cmp y x = .lt + +namespace LawfulCmp + +variable {K : Type*} {cmp : K → K → Ordering} + +theorem cmp_refl (h : LawfulCmp cmp) (x : K) : cmp x x = .eq := + (h.eq_iff x x).mpr rfl + +theorem lt_irrefl (h : LawfulCmp cmp) (x : K) : cmp x x ≠ .lt := by + rw [h.cmp_refl x]; decide + +theorem gt_irrefl (h : LawfulCmp cmp) (x : K) : cmp x x ≠ .gt := by + rw [h.cmp_refl x]; decide + +theorem lt_asymm (h : LawfulCmp cmp) {x y : K} (hxy : cmp x y = .lt) : cmp y x ≠ .lt := + fun hyx => h.lt_irrefl x (h.lt_trans hxy hyx) + +theorem lt_ne (h : LawfulCmp cmp) {x y : K} (hxy : cmp x y = .lt) : x ≠ y := by + rintro rfl + exact h.lt_irrefl x hxy + +theorem gt_of_lt (h : LawfulCmp cmp) {x y : K} (hxy : cmp x y = .lt) : cmp y x = .gt := + (h.gt_iff y x).mpr hxy + +theorem lt_of_gt (h : LawfulCmp cmp) {x y : K} (hxy : cmp x y = .gt) : cmp y x = .lt := + (h.gt_iff x y).mp hxy + +theorem trichotomous (h : LawfulCmp cmp) (x y : K) : + cmp x y = .lt ∨ x = y ∨ cmp y x = .lt := by + cases hxy : cmp x y with + | lt => exact Or.inl rfl + | eq => exact Or.inr (Or.inl ((h.eq_iff x y).mp hxy)) + | gt => exact Or.inr (Or.inr (h.lt_of_gt hxy)) + +end LawfulCmp + +/-- Standard `compare` on `Nat` satisfies `LawfulCmp`. -/ +theorem lawfulCmp_nat : LawfulCmp (compare : Nat → Nat → Ordering) where + eq_iff x y := by + simp only [compare, compareOfLessAndEq] + split_ifs <;> constructor <;> intro h <;> first | rfl | omega | cases h + lt_trans {x y z} hxy hyz := by + simp only [compare, compareOfLessAndEq] at hxy hyz ⊢ + split_ifs at hxy hyz ⊢ <;> first | rfl | omega + gt_iff x y := by + simp only [compare, compareOfLessAndEq] + split_ifs <;> constructor <;> intro h <;> first | rfl | omega + +/-! ## Lexicographic Comparison and `canon_addr_cmp` -/ + +/-- Lexicographic comparison on lists of natural numbers. -/ +def lexCmpNat : List Nat → List Nat → Ordering + | [], [] => .eq + | [], _ :: _ => .lt + | _ :: _, [] => .gt + | x :: xs, y :: ys => + match compare x y with + | .eq => lexCmpNat xs ys + | ord => ord + +/-- Lexicographic chaining combinator matching `canon_ord_then`. -/ +def canonOrdThen (a b : Ordering) : Ordering := + match a with + | .eq => b + | ord => ord + +/-- Field encoding of `Ordering` used in `KernelCanonicalCheck` (`0 = lt`, `1 = eq`, `2 = gt`). -/ +def canonOrdToNat : Ordering → Nat + | .lt => 0 + | .eq => 1 + | .gt => 2 + +@[simp] +theorem lexCmpNat_nil_nil : lexCmpNat [] [] = .eq := rfl + +@[simp] +theorem lexCmpNat_cons_cons (x y : Nat) (xs ys : List Nat) : + lexCmpNat (x :: xs) (y :: ys) = canonOrdThen (compare x y) (lexCmpNat xs ys) := rfl + +theorem canonOrdThen_assoc (a b c : Ordering) : + canonOrdThen (canonOrdThen a b) c = canonOrdThen a (canonOrdThen b c) := by + cases a <;> rfl + +theorem lexCmpNat_append {xs₁ ys₁ : List Nat} (hLen : xs₁.length = ys₁.length) + (xs₂ ys₂ : List Nat) : + lexCmpNat (xs₁ ++ xs₂) (ys₁ ++ ys₂) = + canonOrdThen (lexCmpNat xs₁ ys₁) (lexCmpNat xs₂ ys₂) := by + induction xs₁ generalizing ys₁ with + | nil => + cases ys₁ with + | nil => rfl + | cons _ _ => simp at hLen + | cons x xs₁ ih => + cases ys₁ with + | nil => simp at hLen + | cons y ys₁ => + simp only [List.length_cons, Nat.add_right_cancel_iff] at hLen + simp only [List.cons_append, lexCmpNat_cons_cons, ih hLen, canonOrdThen_assoc] + +theorem lawfulCmp_lexCmpNat : LawfulCmp lexCmpNat where + eq_iff xs ys := by + induction xs generalizing ys with + | nil => + cases ys <;> simp [lexCmpNat] + | cons x xs ih => + cases ys with + | nil => simp [lexCmpNat] + | cons y ys => + simp only [lexCmpNat] + cases hxy : compare x y with + | lt => + have hne : x ≠ y := lawfulCmp_nat.lt_ne hxy + simp [hne] + | eq => + have heq : x = y := (lawfulCmp_nat.eq_iff x y).mp hxy + subst heq + simp [ih ys] + | gt => + have hne : x ≠ y := Ne.symm (lawfulCmp_nat.lt_ne (lawfulCmp_nat.lt_of_gt hxy)) + simp [hne] + lt_trans {xs ys zs} hxy hyz := by + induction xs generalizing ys zs with + | nil => + cases ys with + | nil => simp [lexCmpNat] at hxy + | cons y ys => + cases zs with + | nil => simp [lexCmpNat] at hyz + | cons z zs => rfl + | cons x xs ih => + cases ys with + | nil => simp [lexCmpNat] at hxy + | cons y ys => + cases zs with + | nil => simp [lexCmpNat] at hyz + | cons z zs => + simp only [lexCmpNat] at hxy hyz ⊢ + cases h1 : compare x y <;> rw [h1] at hxy + · cases h2 : compare y z <;> rw [h2] at hyz + · rw [lawfulCmp_nat.lt_trans h1 h2] + · have hyz_eq : y = z := (lawfulCmp_nat.eq_iff y z).mp h2 + subst hyz_eq + rw [h1] + · nomatch hyz + · have hxy_eq : x = y := (lawfulCmp_nat.eq_iff x y).mp h1 + subst hxy_eq + cases h2 : compare x z + · rfl + · rw [h2] at hyz + exact ih hxy hyz + · rw [h2] at hyz + nomatch hyz + · nomatch hxy + gt_iff xs ys := by + induction xs generalizing ys with + | nil => + cases ys <;> simp [lexCmpNat] + | cons x xs ih => + cases ys with + | nil => simp [lexCmpNat] + | cons y ys => + simp only [lexCmpNat] + cases hxy : compare x y + · have hyx : compare y x = .gt := lawfulCmp_nat.gt_of_lt hxy + rw [hyx]; simp + · have heq : x = y := (lawfulCmp_nat.eq_iff x y).mp hxy + subst heq + rw [lawfulCmp_nat.cmp_refl x] + exact ih ys + · have hyx : compare y x = .lt := lawfulCmp_nat.lt_of_gt hxy + rw [hyx]; simp + +/-- Big-endian 4-byte chunk value matching `canon_addr_chunk` in `KernelCanonicalCheck`. -/ +def chunkVal (b0 b1 b2 b3 : UInt8) : Nat := + b0.toNat * 16777216 + b1.toNat * 65536 + b2.toNat * 256 + b3.toNat + +private theorem compare_step_256 (a b c d : Nat) (hb : b < 256) (hd : d < 256) : + compare (a * 256 + b) (c * 256 + d) = canonOrdThen (compare a c) (compare b d) := by + simp only [canonOrdThen, compare, compareOfLessAndEq] + split_ifs <;> first | rfl | (exfalso; omega) + +@[simp] +private theorem canonOrdThen_eq_right (a : Ordering) : canonOrdThen a .eq = a := by + cases a <;> rfl + +/-- Comparing two 4-byte big-endian chunks as natural numbers is identical to +comparing their 4 bytes lexicographically. -/ +theorem compare_chunkVal_eq_lexCmpNat (x0 x1 x2 x3 y0 y1 y2 y3 : UInt8) : + compare (chunkVal x0 x1 x2 x3) (chunkVal y0 y1 y2 y3) = + lexCmpNat [x0.toNat, x1.toNat, x2.toNat, x3.toNat] + [y0.toNat, y1.toNat, y2.toNat, y3.toNat] := by + have hL (b0 b1 b2 b3 : UInt8) : + chunkVal b0 b1 b2 b3 = ((b0.toNat * 256 + b1.toNat) * 256 + b2.toNat) * 256 + b3.toNat := by + unfold chunkVal; omega + rw [hL x0 x1 x2 x3, hL y0 y1 y2 y3] + rw [compare_step_256 _ _ _ _ x3.toNat_lt y3.toNat_lt] + rw [compare_step_256 _ _ _ _ x2.toNat_lt y2.toNat_lt] + rw [compare_step_256 _ _ _ _ x1.toNat_lt y1.toNat_lt] + simp only [lexCmpNat_cons_cons, lexCmpNat_nil_nil, canonOrdThen_eq_right, canonOrdThen_assoc] + +/-- Canonical comparison on 32-byte `Address` values. -/ +def canonAddrCmp (x y : Address) : Ordering := + lexCmpNat (x.toList.map UInt8.toNat) (y.toList.map UInt8.toNat) + +/-- Strict inequality on 32-byte `Address` values induced by `canonAddrCmp`. -/ +def canonAddrLt (x y : Address) : Prop := + canonAddrCmp x y = .lt + +private theorem list_map_u8_toNat_inj {xs ys : List UInt8} + (h : xs.map UInt8.toNat = ys.map UInt8.toNat) : xs = ys := by + induction xs generalizing ys with + | nil => + cases ys <;> simp at h ⊢ + | cons x xs ih => + cases ys with + | nil => simp at h + | cons y ys => + simp only [List.map_cons, List.cons.injEq] at h + exact List.cons_eq_cons.mpr ⟨UInt8.ext h.1, ih h.2⟩ + +/-- `canonAddrCmp` is a lawful strict weak order on 32-byte `Address` values. -/ +theorem lawfulCmp_canonAddrCmp : LawfulCmp canonAddrCmp where + eq_iff x y := by + unfold canonAddrCmp + rw [lawfulCmp_lexCmpNat.eq_iff] + constructor + · intro h + exact Vector.toList_inj.mp (list_map_u8_toNat_inj h) + · rintro rfl; rfl + lt_trans hxy hyz := lawfulCmp_lexCmpNat.lt_trans hxy hyz + gt_iff x y := lawfulCmp_lexCmpNat.gt_iff _ _ + +theorem canon_addr_cmp_refl (x : Address) : canonAddrCmp x x = .eq := + lawfulCmp_canonAddrCmp.cmp_refl x + +theorem canon_addr_cmp_eq_iff (x y : Address) : canonAddrCmp x y = .eq ↔ x = y := + lawfulCmp_canonAddrCmp.eq_iff x y + +theorem canon_addr_cmp_irrefl (x : Address) : ¬ canonAddrLt x x := + lawfulCmp_canonAddrCmp.lt_irrefl x + +theorem canon_addr_cmp_trans {x y z : Address} + (hxy : canonAddrLt x y) (hyz : canonAddrLt y z) : canonAddrLt x z := + lawfulCmp_canonAddrCmp.lt_trans hxy hyz + +theorem canon_addr_cmp_asymm {x y : Address} (hxy : canonAddrLt x y) : ¬ canonAddrLt y x := + lawfulCmp_canonAddrCmp.lt_asymm hxy + +theorem canon_addr_cmp_trichotomous (x y : Address) : + canonAddrLt x y ∨ x = y ∨ canonAddrLt y x := + lawfulCmp_canonAddrCmp.trichotomous x y + +theorem canon_addr_cmp_gt_iff (x y : Address) : + canonAddrCmp x y = .gt ↔ canonAddrLt y x := + lawfulCmp_canonAddrCmp.gt_iff x y + +/-! ## Red-Black Tree AST, `BinaryTree` Bridge, and `HeapMono` Representation -/ + +/-- Pure red-black search tree parameterized by key type `K` and value type `V`. -/ +inductive RBTree (K V : Type*) where + | nil : RBTree K V + | node (color : Nat) (key : K) (val : V) (left right : RBTree K V) : RBTree K V + deriving Repr, DecidableEq + +/-- Embedding of `RBTree K V` into `Aiur.BinaryTree (Nat × K × V)`. -/ +def RBTree.toBinaryTree {K V : Type*} : RBTree K V → BinaryTree (Nat × K × V) + | .nil => .leaf + | .node color key val left right => + .branch (color, key, val) left.toBinaryTree right.toBinaryTree + +/-- Inverse projection from `Aiur.BinaryTree (Nat × K × V)` to `RBTree K V`. -/ +def RBTree.ofBinaryTree {K V : Type*} : BinaryTree (Nat × K × V) → RBTree K V + | .leaf => .nil + | .branch (color, key, val) left right => + .node color key val (RBTree.ofBinaryTree left) (RBTree.ofBinaryTree right) + +@[simp] +theorem RBTree.ofBinaryTree_toBinaryTree {K V : Type*} (t : RBTree K V) : + RBTree.ofBinaryTree t.toBinaryTree = t := by + induction t with + | nil => rfl + | node color key val left right ihl ihr => + simp [RBTree.toBinaryTree, RBTree.ofBinaryTree, ihl, ihr] + +@[simp] +theorem RBTree.toBinaryTree_ofBinaryTree {K V : Type*} (t : BinaryTree (Nat × K × V)) : + (RBTree.ofBinaryTree t).toBinaryTree = t := by + induction t with + | leaf => rfl + | branch label left right ihl ihr => + rcases label with ⟨color, key, val⟩ + simp [RBTree.ofBinaryTree, RBTree.toBinaryTree, ihl, ihr] + +/-- Heap-allocated `RBTree K V` pointer representation, defined via `RepBinaryTree`. -/ +def RepRBTreePtr {F : Type} {K V : Type*} (enumName nilCtor nodeCtor : String) + (RLabel : Heap F → (Nat × K × V) → SourceValue F → Prop) + (h : Heap F) (t : RBTree K V) (ptr : SourceValue F) : Prop := + RepBinaryTree enumName nilCtor nodeCtor RLabel h t.toBinaryTree ptr + +theorem RepRBTreePtr.mono {F : Type} {K V : Type*} {enumName nilCtor nodeCtor : String} + {RLabel : Heap F → (Nat × K × V) → SourceValue F → Prop} (hR : HeapMono₂ RLabel) + {h₁ h₂ : Heap F} {t : RBTree K V} {ptr : SourceValue F} + (ext : Heap.Extends h₁ h₂) + (rep : RepRBTreePtr enumName nilCtor nodeCtor RLabel h₁ t ptr) : + RepRBTreePtr enumName nilCtor nodeCtor RLabel h₂ t ptr := + RepBinaryTree.mono hR ext rep + +theorem HeapMono.repRBTreePtr {F : Type} {K V : Type*} (enumName nilCtor nodeCtor : String) + {RLabel : Heap F → (Nat × K × V) → SourceValue F → Prop} (hR : HeapMono₂ RLabel) + (t : RBTree K V) : + HeapMono (fun h ptr => RepRBTreePtr enumName nilCtor nodeCtor RLabel h t ptr) := + HeapMono.repBinaryTree enumName nilCtor nodeCtor hR t.toBinaryTree + +/-! ## Red-Black Tree Operations (`rbtreeGet`, `balance`, `ins`, `rbtreeInsert`) -/ + +variable {K V : Type*} + +/-- Lookup key `k` in `RBTree K V` using `cmp`. -/ +def rbtreeGet (cmp : K → K → Ordering) (k : K) : RBTree K V → Option V + | .nil => none + | .node _ nk nv left right => + match cmp k nk with + | .lt => rbtreeGet cmp k left + | .eq => some nv + | .gt => rbtreeGet cmp k right + +/-- Lookup key `k` with fallback `default`, matching `rbtree_map_lookup_or_default` +and `role_map_lookup_or_default`. -/ +def rbtreeLookupOrDefault (cmp : K → K → Ordering) (k : K) (t : RBTree K V) (default : V) : V := + (rbtreeGet cmp k t).getD default + +/-- Red-black tree rotation helper matching `rbtree_map_balance_fix` in `RBTreeMap.aiur`. -/ +def balanceFix (k : K) (v : V) (left right : RBTree K V) : RBTree K V := + match left, right with + | .node 0 yk yv (.node 0 xk xv a b) c, d => + .node 0 yk yv (.node 1 xk xv a b) (.node 1 k v c d) + | .node 0 xk xv a (.node 0 yk yv b c), d => + .node 0 yk yv (.node 1 xk xv a b) (.node 1 k v c d) + | a, .node 0 zk zv (.node 0 yk yv b c) d => + .node 0 yk yv (.node 1 k v a b) (.node 1 zk zv c d) + | a, .node 0 yk yv b (.node 0 zk zv c d) => + .node 0 yk yv (.node 1 k v a b) (.node 1 zk zv c d) + | _, _ => + .node 1 k v left right + +/-- Red-black tree balance operation matching `rbtree_map_balance` in `RBTreeMap.aiur`. -/ +def balance (color : Nat) (k : K) (v : V) (left right : RBTree K V) : RBTree K V := + match color with + | 1 => balanceFix k v left right + | _ => .node color k v left right + +/-- Recursive red-black tree insertion helper matching `rbtree_map_ins` in `RBTreeMap.aiur`. -/ +def ins (cmp : K → K → Ordering) (k : K) (v : V) : RBTree K V → RBTree K V + | .nil => .node 0 k v .nil .nil + | .node color nk nv left right => + match cmp k nk with + | .lt => balance color nk nv (ins cmp k v left) right + | .eq => .node color k v left right + | .gt => balance color nk nv left (ins cmp k v right) + +/-- Top-level red-black tree insertion matching `rbtree_map_insert` in `RBTreeMap.aiur`. -/ +def rbtreeInsert (cmp : K → K → Ordering) (k : K) (v : V) (t : RBTree K V) : RBTree K V := + match ins cmp k v t with + | .nil => .nil + | .node _ nk nv left right => .node 1 nk nv left right + +/-- Disjunctive characterization of the 5 branches of `balanceFix`. -/ +theorem balanceFix_cases (k : K) (v : V) (left right : RBTree K V) : + (∃ yk yv xk xv a b c, + left = .node 0 yk yv (.node 0 xk xv a b) c ∧ + balanceFix k v left right = .node 0 yk yv (.node 1 xk xv a b) (.node 1 k v c right)) ∨ + (∃ xk xv a yk yv b c, + left = .node 0 xk xv a (.node 0 yk yv b c) ∧ + balanceFix k v left right = .node 0 yk yv (.node 1 xk xv a b) (.node 1 k v c right)) ∨ + (∃ zk zv yk yv b c d, + right = .node 0 zk zv (.node 0 yk yv b c) d ∧ + balanceFix k v left right = .node 0 yk yv (.node 1 k v left b) (.node 1 zk zv c d)) ∨ + (∃ yk yv b zk zv c d, + right = .node 0 yk yv b (.node 0 zk zv c d) ∧ + balanceFix k v left right = .node 0 yk yv (.node 1 k v left b) (.node 1 zk zv c d)) ∨ + balanceFix k v left right = .node 1 k v left right := by + unfold balanceFix + split + · exact Or.inl ⟨_, _, _, _, _, _, _, rfl, rfl⟩ + · exact Or.inr (Or.inl ⟨_, _, _, _, _, _, _, rfl, rfl⟩) + · exact Or.inr (Or.inr (Or.inl ⟨_, _, _, _, _, _, _, rfl, rfl⟩)) + · exact Or.inr (Or.inr (Or.inr (Or.inl ⟨_, _, _, _, _, _, _, rfl, rfl⟩))) + · exact Or.inr (Or.inr (Or.inr (Or.inr rfl))) + +/-! ## Key Predicates (`AllKeys`) and Binary Search Tree (`BST`) Invariant -/ + +/-- Predicate asserting that every key in the tree satisfies `P`. -/ +def AllKeys (P : K → Prop) : RBTree K V → Prop + | .nil => True + | .node _ k _ l r => P k ∧ AllKeys P l ∧ AllKeys P r + +theorem AllKeys.imp {P Q : K → Prop} (hPQ : ∀ x, P x → Q x) {t : RBTree K V} + (h : AllKeys P t) : AllKeys Q t := by + induction t with + | nil => trivial + | node _ k _ l r ihl ihr => + exact ⟨hPQ k h.1, ihl h.2.1, ihr h.2.2⟩ + +/-- Binary Search Tree invariant wrt `cmp`. -/ +def BST (cmp : K → K → Ordering) : RBTree K V → Prop + | .nil => True + | .node _ k _ l r => + AllKeys (fun x => cmp x k = .lt) l ∧ + AllKeys (fun x => cmp k x = .lt) r ∧ + BST cmp l ∧ + BST cmp r + +theorem allKeys_balanceFix (P : K → Prop) (k : K) (v : V) (left right : RBTree K V) : + AllKeys P (balanceFix k v left right) ↔ P k ∧ AllKeys P left ∧ AllKeys P right := by + rcases balanceFix_cases k v left right with + ⟨yk, yv, xk, xv, a, b, c, rfl, hEq⟩ | + ⟨xk, xv, a, yk, yv, b, c, rfl, hEq⟩ | + ⟨zk, zv, yk, yv, b, c, d, rfl, hEq⟩ | + ⟨yk, yv, b, zk, zv, c, d, rfl, hEq⟩ | + hEq + · rw [hEq]; simp only [AllKeys]; tauto + · rw [hEq]; simp only [AllKeys]; tauto + · rw [hEq]; simp only [AllKeys]; tauto + · rw [hEq]; simp only [AllKeys]; tauto + · rw [hEq]; rfl + +theorem allKeys_balance (P : K → Prop) (color : Nat) (k : K) (v : V) (left right : RBTree K V) : + AllKeys P (balance color k v left right) ↔ P k ∧ AllKeys P left ∧ AllKeys P right := by + unfold balance + split + · exact allKeys_balanceFix P k v left right + · rfl + +theorem allKeys_ins {cmp : K → K → Ordering} (hc : LawfulCmp cmp) + (P : K → Prop) (k : K) (v : V) (t : RBTree K V) : + AllKeys P (ins cmp k v t) ↔ P k ∧ AllKeys P t := by + induction t with + | nil => simp [ins, AllKeys] + | node color nk nv left right ihl ihr => + simp only [ins, AllKeys] + cases hcmp : cmp k nk + · rw [allKeys_balance, ihl]; tauto + · have heq : k = nk := (hc.eq_iff k nk).mp hcmp + subst heq + simp only [AllKeys] + tauto + · rw [allKeys_balance, ihr]; tauto + +/-- `balance` preserves the `BST` invariant whenever the children and root satisfy `BST`. -/ +theorem rbtree_bst_balance {cmp : K → K → Ordering} (hc : LawfulCmp cmp) + (color : Nat) (k : K) (v : V) (left right : RBTree K V) + (hLeftKeys : AllKeys (fun x => cmp x k = .lt) left) + (hRightKeys : AllKeys (fun x => cmp k x = .lt) right) + (hLeftBST : BST cmp left) + (hRightBST : BST cmp right) : + BST cmp (balance color k v left right) := by + unfold balance + split + · rcases balanceFix_cases k v left right with + ⟨yk, yv, xk, xv, a, b, c, rfl, hEq⟩ | + ⟨xk, xv, a, yk, yv, b, c, rfl, hEq⟩ | + ⟨zk, zv, yk, yv, b, c, d, rfl, hEq⟩ | + ⟨yk, yv, b, zk, zv, c, d, rfl, hEq⟩ | + hEq + · rw [hEq] + obtain ⟨hyk_k, ⟨hxk_k, ha_k, hb_k⟩, hc_k⟩ := hLeftKeys + obtain ⟨⟨hxk_yk, ha_yk, hb_yk⟩, hc_yk, ⟨ha_xk, hb_xk, ha_bst, hb_bst⟩, hc_bst⟩ := hLeftBST + refine ⟨⟨hxk_yk, ha_yk, hb_yk⟩, ⟨hyk_k, hc_yk, hRightKeys.imp (fun _ hx => hc.lt_trans hyk_k hx)⟩, + ⟨ha_xk, hb_xk, ha_bst, hb_bst⟩, ⟨hc_k, hRightKeys, hc_bst, hRightBST⟩⟩ + · rw [hEq] + obtain ⟨hxk_k, ha_k, hyk_k, hb_k, hc_k⟩ := hLeftKeys + obtain ⟨ha_xk, ⟨hyk_xk, hb_xk, hc_xk⟩, ha_bst, hb_yk, hc_yk, hb_bst, hc_bst⟩ := hLeftBST + refine ⟨⟨hyk_xk, ha_xk.imp (fun _ hx => hc.lt_trans hx hyk_xk), hb_yk⟩, + ⟨hyk_k, hc_yk, hRightKeys.imp (fun _ hx => hc.lt_trans hyk_k hx)⟩, + ⟨ha_xk, hb_xk, ha_bst, hb_bst⟩, ⟨hc_k, hRightKeys, hc_bst, hRightBST⟩⟩ + · rw [hEq] + obtain ⟨hk_zk, ⟨hk_yk, hk_b, hk_c⟩, hk_d⟩ := hRightKeys + obtain ⟨⟨hyk_zk, hb_zk, hc_zk⟩, hd_zk, ⟨hb_yk, hc_yk, hb_bst, hc_bst⟩, hd_bst⟩ := hRightBST + refine ⟨⟨hk_yk, hLeftKeys.imp (fun _ hx => hc.lt_trans hx hk_yk), hb_yk⟩, + ⟨hyk_zk, hc_yk, hd_zk.imp (fun _ hx => hc.lt_trans hyk_zk hx)⟩, + ⟨hLeftKeys, hk_b, hLeftBST, hb_bst⟩, ⟨hc_zk, hd_zk, hc_bst, hd_bst⟩⟩ + · rw [hEq] + obtain ⟨hk_yk, hk_b, hk_zk, hk_c, hk_d⟩ := hRightKeys + obtain ⟨hb_yk, ⟨hzk_yk, hc_yk, hd_yk⟩, hb_bst, hc_zk, hd_zk, hc_bst, hd_bst⟩ := hRightBST + refine ⟨⟨hk_yk, hLeftKeys.imp (fun _ hx => hc.lt_trans hx hk_yk), hb_yk⟩, + ⟨hzk_yk, hc_yk, hd_yk⟩, + ⟨hLeftKeys, hk_b, hLeftBST, hb_bst⟩, ⟨hc_zk, hd_zk, hc_bst, hd_bst⟩⟩ + · rw [hEq] + exact ⟨hLeftKeys, hRightKeys, hLeftBST, hRightBST⟩ + · exact ⟨hLeftKeys, hRightKeys, hLeftBST, hRightBST⟩ + +/-- `ins` preserves the `BST` invariant. -/ +theorem rbtree_bst_ins {cmp : K → K → Ordering} (hc : LawfulCmp cmp) + (k : K) (v : V) {t : RBTree K V} (ht : BST cmp t) : + BST cmp (ins cmp k v t) := by + induction t with + | nil => exact ⟨trivial, trivial, trivial, trivial⟩ + | node color nk nv left right ihl ihr => + obtain ⟨hL, hR, hBSTL, hBSTR⟩ := ht + simp only [ins] + cases hcmp : cmp k nk + · exact rbtree_bst_balance hc color nk nv (ins cmp k v left) right + ((allKeys_ins hc _ k v left).mpr ⟨hcmp, hL⟩) hR (ihl hBSTL) hBSTR + · have heq : k = nk := (hc.eq_iff k nk).mp hcmp + subst heq + exact ⟨hL, hR, hBSTL, hBSTR⟩ + · have hnk_k : cmp nk k = .lt := hc.lt_of_gt hcmp + exact rbtree_bst_balance hc color nk nv left (ins cmp k v right) + hL ((allKeys_ins hc _ k v right).mpr ⟨hnk_k, hR⟩) hBSTL (ihr hBSTR) + +/-- `rbtreeInsert` preserves the `BST` invariant. -/ +theorem rbtree_bst_insert {cmp : K → K → Ordering} (hc : LawfulCmp cmp) + (k : K) (v : V) {t : RBTree K V} (ht : BST cmp t) : + BST cmp (rbtreeInsert cmp k v t) := by + unfold rbtreeInsert + have hIns := rbtree_bst_ins hc k v ht + cases h : ins cmp k v t with + | nil => trivial + | node c nk nv l r => + rw [h] at hIns + exact hIns + +/-! ## Lookup Preservation Under `balance`, `ins`, and `rbtreeInsert` -/ + +private theorem lookup_rot_ll {cmp : K → K → Ordering} (hc : LawfulCmp cmp) + {yk k : K} {yv xv v : V} {xk : K} {a b c d : RBTree K V} {color : Nat} + (hyk_k : cmp yk k = .lt) (q : K) : + rbtreeGet cmp q (.node 0 yk yv (.node 1 xk xv a b) (.node 1 k v c d)) = + rbtreeGet cmp q (.node color k v (.node 0 yk yv (.node 0 xk xv a b) c) d) := by + simp only [rbtreeGet] + cases hqy : cmp q yk + · have hqk : cmp q k = .lt := hc.lt_trans hqy hyk_k + simp [hqk] + · have hq_eq : q = yk := (hc.eq_iff q yk).mp hqy + subst hq_eq + simp [hyk_k] + · cases hqk : cmp q k <;> simp + +private theorem lookup_rot_lr {cmp : K → K → Ordering} (hc : LawfulCmp cmp) + {xk yk k : K} {xv yv v : V} {a b c d : RBTree K V} {color : Nat} + (hxk_yk : cmp xk yk = .lt) (hyk_k : cmp yk k = .lt) (q : K) : + rbtreeGet cmp q (.node 0 yk yv (.node 1 xk xv a b) (.node 1 k v c d)) = + rbtreeGet cmp q (.node color k v (.node 0 xk xv a (.node 0 yk yv b c)) d) := by + simp only [rbtreeGet] + cases hqy : cmp q yk + · have hqk : cmp q k = .lt := hc.lt_trans hqy hyk_k + simp only [hqk] + · have hq_eq : q = yk := (hc.eq_iff q yk).mp hqy + subst hq_eq + have hyx : cmp q xk = .gt := hc.gt_of_lt hxk_yk + simp [hyk_k, hyx] + · have hqx : cmp q xk = .gt := hc.gt_of_lt (hc.lt_trans hxk_yk (hc.lt_of_gt hqy)) + cases hqk : cmp q k <;> simp [hqx] + +private theorem lookup_rot_rl {cmp : K → K → Ordering} (hc : LawfulCmp cmp) + {k yk zk : K} {v yv zv : V} {a b c d : RBTree K V} {color : Nat} + (hk_yk : cmp k yk = .lt) (hyk_zk : cmp yk zk = .lt) (q : K) : + rbtreeGet cmp q (.node 0 yk yv (.node 1 k v a b) (.node 1 zk zv c d)) = + rbtreeGet cmp q (.node color k v a (.node 0 zk zv (.node 0 yk yv b c) d)) := by + simp only [rbtreeGet] + cases hqy : cmp q yk + · have hqz : cmp q zk = .lt := hc.lt_trans hqy hyk_zk + cases hqk : cmp q k <;> simp [hqz] + · have hq_eq : q = yk := (hc.eq_iff q yk).mp hqy + subst hq_eq + have hyk_k : cmp q k = .gt := hc.gt_of_lt hk_yk + simp [hyk_k, hyk_zk] + · have hqk : cmp q k = .gt := hc.gt_of_lt (hc.lt_trans hk_yk (hc.lt_of_gt hqy)) + simp only [hqk] + +private theorem lookup_rot_rr {cmp : K → K → Ordering} (hc : LawfulCmp cmp) + {k yk zk : K} {v yv zv : V} {a b c d : RBTree K V} {color : Nat} + (hk_yk : cmp k yk = .lt) (q : K) : + rbtreeGet cmp q (.node 0 yk yv (.node 1 k v a b) (.node 1 zk zv c d)) = + rbtreeGet cmp q (.node color k v a (.node 0 yk yv b (.node 0 zk zv c d))) := by + simp only [rbtreeGet] + cases hqy : cmp q yk + · cases hqk : cmp q k <;> simp + · have hq_eq : q = yk := (hc.eq_iff q yk).mp hqy + subst hq_eq + have hyk_k : cmp q k = .gt := hc.gt_of_lt hk_yk + simp [hyk_k] + · have hqk : cmp q k = .gt := hc.gt_of_lt (hc.lt_trans hk_yk (hc.lt_of_gt hqy)) + simp [hqk] + +/-- `balance` preserves lookup results for all queries `q` on valid BST children. -/ +theorem balance_lookup_eq {cmp : K → K → Ordering} (hc : LawfulCmp cmp) + (color : Nat) (k : K) (v : V) (left right : RBTree K V) + (hLeftKeys : AllKeys (fun x => cmp x k = .lt) left) + (hRightKeys : AllKeys (fun x => cmp k x = .lt) right) + (hLeftBST : BST cmp left) + (hRightBST : BST cmp right) + (q : K) : + rbtreeGet cmp q (balance color k v left right) = + rbtreeGet cmp q (.node color k v left right) := by + unfold balance + split + · rcases balanceFix_cases k v left right with + ⟨yk, yv, xk, xv, a, b, c, rfl, hEq⟩ | + ⟨xk, xv, a, yk, yv, b, c, rfl, hEq⟩ | + ⟨zk, zv, yk, yv, b, c, d, rfl, hEq⟩ | + ⟨yk, yv, b, zk, zv, c, d, rfl, hEq⟩ | + hEq + · rw [hEq] + exact lookup_rot_ll hc hLeftKeys.1 q + · rw [hEq] + exact lookup_rot_lr hc hLeftBST.2.1.1 hLeftKeys.2.2.1 q + · rw [hEq] + exact lookup_rot_rl hc hRightKeys.2.1.1 hRightBST.1.1 q + · rw [hEq] + exact lookup_rot_rr hc hRightKeys.1 q + · rw [hEq] + · rfl + +/-- Lookup characterization after `ins`: returns `some v` for `q = k`, and +preserves `rbtreeGet cmp q t` for `q ≠ k`. -/ +theorem ins_lookup_eq [DecidableEq K] {cmp : K → K → Ordering} (hc : LawfulCmp cmp) + (k : K) (v : V) {t : RBTree K V} (ht : BST cmp t) (q : K) : + rbtreeGet cmp q (ins cmp k v t) = + if q = k then some v else rbtreeGet cmp q t := by + induction t with + | nil => + simp only [ins, rbtreeGet] + cases hqk : cmp q k + · have hne : q ≠ k := hc.lt_ne hqk + simp [hne] + · have heq : q = k := (hc.eq_iff q k).mp hqk + simp [heq] + · have hne : q ≠ k := Ne.symm (hc.lt_ne (hc.lt_of_gt hqk)) + simp [hne] + | node color nk nv left right ihl ihr => + obtain ⟨hL, hR, hBSTL, hBSTR⟩ := ht + simp only [ins] + cases hknk : cmp k nk + · rw [balance_lookup_eq hc color nk nv (ins cmp k v left) right + ((allKeys_ins hc _ k v left).mpr ⟨hknk, hL⟩) hR (rbtree_bst_ins hc k v hBSTL) hBSTR q] + simp only [rbtreeGet] + cases hqnk : cmp q nk + · exact ihl hBSTL + · have hq_nk : q = nk := (hc.eq_iff q nk).mp hqnk + subst hq_nk + have hne : q ≠ k := Ne.symm (hc.lt_ne hknk) + simp [hne] + · have hnk_q : cmp nk q = .lt := hc.lt_of_gt hqnk + have hne : q ≠ k := Ne.symm (hc.lt_ne (hc.lt_trans hknk hnk_q)) + simp [hne] + · have hk_nk : k = nk := (hc.eq_iff k nk).mp hknk + subst hk_nk + simp only [rbtreeGet] + cases hqk : cmp q k + · have hne : q ≠ k := hc.lt_ne hqk + simp [hne] + · have heq : q = k := (hc.eq_iff q k).mp hqk + simp [heq] + · have hne : q ≠ k := Ne.symm (hc.lt_ne (hc.lt_of_gt hqk)) + simp [hne] + · have hnk_k : cmp nk k = .lt := hc.lt_of_gt hknk + rw [balance_lookup_eq hc color nk nv left (ins cmp k v right) + hL ((allKeys_ins hc _ k v right).mpr ⟨hnk_k, hR⟩) hBSTL (rbtree_bst_ins hc k v hBSTR) q] + simp only [rbtreeGet] + cases hqnk : cmp q nk + · have hne : q ≠ k := hc.lt_ne (hc.lt_trans hqnk hnk_k) + simp [hne] + · have hq_nk : q = nk := (hc.eq_iff q nk).mp hqnk + subst hq_nk + have hne : q ≠ k := hc.lt_ne hnk_k + simp [hne] + · exact ihr hBSTR + +/-- Full lookup specification of `rbtreeInsert`. -/ +theorem rbtree_get_insert [DecidableEq K] {cmp : K → K → Ordering} (hc : LawfulCmp cmp) + (k : K) (v : V) {t : RBTree K V} (ht : BST cmp t) (q : K) : + rbtreeGet cmp q (rbtreeInsert cmp k v t) = + if q = k then some v else rbtreeGet cmp q t := by + unfold rbtreeInsert + have hEq := ins_lookup_eq hc k v ht q + cases h : ins cmp k v t with + | nil => + rw [h] at hEq + exact hEq + | node c nk nv l r => + rw [h] at hEq + exact hEq + +/-- Looking up the newly inserted key `k` returns `some v`. -/ +theorem rbtree_get_insert_self [DecidableEq K] {cmp : K → K → Ordering} (hc : LawfulCmp cmp) + (k : K) (v : V) {t : RBTree K V} (ht : BST cmp t) : + rbtreeGet cmp k (rbtreeInsert cmp k v t) = some v := by + rw [rbtree_get_insert hc k v ht k, ite_eq_left_iff] + intro hne + exact absurd rfl hne + +/-- Looking up any key `q ≠ k` after inserting `(k, v)` preserves the previous lookup result. -/ +theorem rbtree_get_insert_ne [DecidableEq K] {cmp : K → K → Ordering} (hc : LawfulCmp cmp) + (k : K) (v : V) {t : RBTree K V} (ht : BST cmp t) {q : K} (hne : q ≠ k) : + rbtreeGet cmp q (rbtreeInsert cmp k v t) = rbtreeGet cmp q t := by + rw [rbtree_get_insert hc k v ht q] + simp [hne] + +/-! ## In-Order Traversal (`toList`) and Static Balanced Tree (`RoleMap` / `buildBalancedTree`) -/ + +/-- In-order list of `(key, value)` pairs in `RBTree K V`. -/ +def RBTree.toList : RBTree K V → List (K × V) + | .nil => [] + | .node _ k v l r => l.toList ++ (k, v) :: r.toList + +theorem mem_toList_imp_allKeys {P : K → Prop} {t : RBTree K V} + (hAll : AllKeys P t) {p : K × V} (hp : p ∈ t.toList) : P p.1 := by + induction t with + | nil => simp [RBTree.toList] at hp + | node _ k v l r ihl ihr => + simp only [RBTree.toList, List.mem_append, List.mem_cons] at hp + rcases hp with hp | rfl | hp + · exact ihl hAll.2.1 hp + · exact hAll.1 + · exact ihr hAll.2.2 hp + +theorem allKeys_iff_forall_mem_toList (P : K → Prop) (t : RBTree K V) : + AllKeys P t ↔ ∀ p ∈ t.toList, P p.1 := by + induction t with + | nil => simp [AllKeys, RBTree.toList] + | node _ k v l r ihl ihr => + simp only [AllKeys, RBTree.toList, ihl, ihr, List.mem_append, List.mem_cons] + constructor + · rintro ⟨hk, hl, hr⟩ p (hp | rfl | hp) + · exact hl p hp + · exact hk + · exact hr p hp + · intro h + exact ⟨h (k, v) (Or.inr (Or.inl rfl)), + fun p hp => h p (Or.inl hp), + fun p hp => h p (Or.inr (Or.inr hp))⟩ + +/-- In a valid `BST`, `rbtreeGet cmp q t = some v` iff `(q, v) ∈ t.toList`. -/ +theorem rbtreeGet_eq_some_iff_mem_toList {cmp : K → K → Ordering} (hc : LawfulCmp cmp) + {t : RBTree K V} (ht : BST cmp t) (q : K) (v : V) : + rbtreeGet cmp q t = some v ↔ (q, v) ∈ t.toList := by + induction t with + | nil => simp [rbtreeGet, RBTree.toList] + | node _ nk nv l r ihl ihr => + obtain ⟨hL, hR, hBSTL, hBSTR⟩ := ht + simp only [rbtreeGet, RBTree.toList, List.mem_append, List.mem_cons] + cases hqnk : cmp q nk + · rw [ihl hBSTL] + constructor + · intro h; exact Or.inl h + · rintro (h | ⟨rfl, rfl⟩ | h) + · exact h + · exact absurd hqnk (hc.lt_irrefl q) + · have hnk_q : cmp nk q = .lt := mem_toList_imp_allKeys hR h + exact absurd (hc.lt_trans hqnk hnk_q) (hc.lt_irrefl q) + · have hq_nk : q = nk := (hc.eq_iff q nk).mp hqnk + subst hq_nk + simp only [Option.some.injEq] + constructor + · rintro rfl; exact Or.inr (Or.inl rfl) + · rintro (h | ⟨_, rfl⟩ | h) + · have hq_lt : cmp q q = .lt := mem_toList_imp_allKeys hL h + exact absurd hq_lt (hc.lt_irrefl q) + · rfl + · have hq_lt : cmp q q = .lt := mem_toList_imp_allKeys hR h + exact absurd hq_lt (hc.lt_irrefl q) + · have hnk_q : cmp nk q = .lt := hc.lt_of_gt hqnk + rw [ihr hBSTR] + constructor + · intro h; exact Or.inr (Or.inr h) + · rintro (h | ⟨rfl, rfl⟩ | h) + · have hq_nk : cmp q nk = .lt := mem_toList_imp_allKeys hL h + exact absurd (hc.lt_trans hnk_q hq_nk) (hc.lt_irrefl nk) + · exact absurd hnk_q (hc.lt_irrefl q) + · exact h + +/-- In a valid `BST`, `rbtreeGet cmp q t = none` iff no pair in `t.toList` has key `q`. -/ +theorem rbtreeGet_eq_none_iff_forall_ne {cmp : K → K → Ordering} (hc : LawfulCmp cmp) + {t : RBTree K V} (ht : BST cmp t) (q : K) : + rbtreeGet cmp q t = none ↔ ∀ p ∈ t.toList, p.1 ≠ q := by + constructor + · intro hNone ⟨k, v⟩ hp + rintro rfl + have hSome := (rbtreeGet_eq_some_iff_mem_toList hc ht k v).mpr hp + rw [hNone] at hSome + contradiction + · intro hAll + cases hGet : rbtreeGet cmp q t with + | none => rfl + | some v => + have hp := (rbtreeGet_eq_some_iff_mem_toList hc ht q v).mp hGet + exact absurd rfl (hAll (q, v) hp) + +/-- Fuel-bounded balanced binary search tree constructor from a slice of `(key, value)` bindings. -/ +def buildBalancedTreeAux : Nat → List (K × V) → RBTree K V + | 0, _ => .nil + | _ + 1, [] => .nil + | n + 1, head :: tail => + let half := (head :: tail).length / 2 + match (head :: tail).drop half with + | [] => .nil + | (k, v) :: rightEntries => + .node 1 k v + (buildBalancedTreeAux n ((head :: tail).take half)) + (buildBalancedTreeAux n rightEntries) + +/-- Balanced binary search tree constructor from a slice of `(key, value)` bindings, +matching `read_role_bindings` / `read_role_evidence` in `KernelRoles.aiur`. -/ +def buildBalancedTree (entries : List (K × V)) : RBTree K V := + buildBalancedTreeAux entries.length entries + +private theorem toList_buildBalancedTreeAux : + ∀ (n : Nat) (entries : List (K × V)), entries.length ≤ n → + (buildBalancedTreeAux n entries).toList = entries + | 0, entries, hLen => by + cases entries with + | nil => rfl + | cons _ _ => simp at hLen + | n + 1, [], _ => rfl + | n + 1, head :: tail, hLen => by + simp only [buildBalancedTreeAux] + have hDropNe : (head :: tail).drop ((head :: tail).length / 2) ≠ [] := by + intro hEmpty + have hL := congrArg List.length hEmpty + rw [List.length_drop] at hL + simp only [List.length_cons, List.length_nil] at hL + omega + split + · contradiction + · rename_i k v rightEntries hDrop + have hTakeLe : ((head :: tail).take ((head :: tail).length / 2)).length ≤ n := by + rw [List.length_take] + simp only [List.length_cons] at hLen ⊢ + omega + have hRightLe : rightEntries.length ≤ n := by + have hL := congrArg List.length hDrop + rw [List.length_drop, List.length_cons] at hL + simp only [List.length_cons] at hL hLen ⊢ + omega + simp only [RBTree.toList, toList_buildBalancedTreeAux n _ hTakeLe, + toList_buildBalancedTreeAux n _ hRightLe] + have hSplit := List.take_append_drop ((head :: tail).length / 2) (head :: tail) + rw [hDrop] at hSplit + exact hSplit + +/-- `buildBalancedTree` preserves the exact in-order sequence of `(key, value)` pairs. -/ +theorem toList_buildBalancedTree (entries : List (K × V)) : + (buildBalancedTree entries).toList = entries := + toList_buildBalancedTreeAux entries.length entries (Nat.le_refl _) + +private theorem bst_buildBalancedTreeAux {cmp : K → K → Ordering} : + ∀ (n : Nat) (entries : List (K × V)), entries.length ≤ n → + List.Pairwise (fun a b => cmp a.1 b.1 = .lt) entries → + BST cmp (buildBalancedTreeAux n entries) + | 0, entries, hLen, _ => by + cases entries with + | nil => trivial + | cons _ _ => simp at hLen + | n + 1, [], _, _ => trivial + | n + 1, head :: tail, hLen, hSorted => by + simp only [buildBalancedTreeAux] + split + · trivial + · rename_i k v rightEntries hDrop + have hTakeLe : ((head :: tail).take ((head :: tail).length / 2)).length ≤ n := by + rw [List.length_take] + simp only [List.length_cons] at hLen ⊢ + omega + have hRightLe : rightEntries.length ≤ n := by + have hL := congrArg List.length hDrop + rw [List.length_drop, List.length_cons] at hL + simp only [List.length_cons] at hL hLen ⊢ + omega + have hSplit : + (head :: tail).take ((head :: tail).length / 2) ++ (k, v) :: rightEntries = + head :: tail := by + have h := List.take_append_drop ((head :: tail).length / 2) (head :: tail) + rw [hDrop] at h + exact h + rw [← hSplit, List.pairwise_append, List.pairwise_cons] at hSorted + obtain ⟨hSortedTake, ⟨hMidRight, hSortedRight⟩, hCross⟩ := hSorted + refine ⟨?_, ?_, + bst_buildBalancedTreeAux n _ hTakeLe hSortedTake, + bst_buildBalancedTreeAux n _ hRightLe hSortedRight⟩ + · rw [allKeys_iff_forall_mem_toList, toList_buildBalancedTreeAux n _ hTakeLe] + intro p hp + exact hCross p hp (k, v) (List.mem_cons_self ..) + · rw [allKeys_iff_forall_mem_toList, toList_buildBalancedTreeAux n _ hRightLe] + intro p hp + exact hMidRight p hp + +/-- If `entries` is strictly sorted wrt `cmp`, `buildBalancedTree entries` is a valid `BST`. -/ +theorem bst_buildBalancedTree {cmp : K → K → Ordering} + {entries : List (K × V)} + (hSorted : List.Pairwise (fun a b => cmp a.1 b.1 = .lt) entries) : + BST cmp (buildBalancedTree entries) := + bst_buildBalancedTreeAux entries.length entries (Nat.le_refl _) hSorted + +/-- Lookup in `buildBalancedTree entries` (such as `RoleMap` over `0..102` role keys) +returns `some v` iff `(q, v) ∈ entries`. -/ +theorem role_tree_get_eq_some_iff {cmp : K → K → Ordering} (hc : LawfulCmp cmp) + {entries : List (K × V)} + (hSorted : List.Pairwise (fun a b => cmp a.1 b.1 = .lt) entries) + (q : K) (v : V) : + rbtreeGet cmp q (buildBalancedTree entries) = some v ↔ (q, v) ∈ entries := by + rw [rbtreeGet_eq_some_iff_mem_toList hc (bst_buildBalancedTree hSorted), + toList_buildBalancedTree] + +/-- Lookup in `buildBalancedTree entries` returns `none` iff `q` is not a key in `entries`. -/ +theorem role_tree_get_eq_none_iff {cmp : K → K → Ordering} (hc : LawfulCmp cmp) + {entries : List (K × V)} + (hSorted : List.Pairwise (fun a b => cmp a.1 b.1 = .lt) entries) + (q : K) : + rbtreeGet cmp q (buildBalancedTree entries) = none ↔ ∀ p ∈ entries, p.1 ≠ q := by + rw [rbtreeGet_eq_none_iff_forall_ne hc (bst_buildBalancedTree hSorted), + toList_buildBalancedTree] + +end Aiur.Library.RBTreeMap diff --git a/Aiur/Aiur/Library/U32.lean b/Aiur/Aiur/Library/U32.lean new file mode 100644 index 000000000..dfc73eaa2 --- /dev/null +++ b/Aiur/Aiur/Library/U32.lean @@ -0,0 +1,157 @@ +import Aiur.Library.U8 +import Aiur.Library.Frontend +import Aiur.Library.U32.Signature +import Mathlib.Algebra.CharP.Basic + +/-! Opaque byte and word arithmetic. The source has no privileged operations: +host advice supplies raw fields, and ordinary assertions/lookups check it. + +The compact representation and packed carry checks require an injective natural +cast below `3 * 2^32`. This includes characteristic zero and every prime field +of characteristic at least that bound; it does not assume Goldilocks. +-/ +namespace Aiur.Library.U32 +open Aiur + +def base : Nat := 4294967296 + +def Compatible (F : Type) [NatCast F] : Prop := + Set.InjOn (Nat.cast : Nat → F) (Set.Iio (3 * base)) + +theorem compatible_of_charP (F : Type) [AddGroupWithOne F] (p : Nat) [CharP F p] + (large : 3 * base ≤ p) : Compatible F := by + intro a ha b hb equal + exact CharP.natCast_injOn_Iio F p (lt_of_lt_of_le ha large) (lt_of_lt_of_le hb large) equal + +theorem compatible_of_charZero (F : Type) [AddMonoidWithOne F] [CharZero F] : + Compatible F := by + intro a _ b _ equal + exact Nat.cast_injective equal + +/-- The byte and word nominal types cannot be obtained through hints or entry arguments, +including through aliases and aggregates. Only checked constructors and typed +operations below create them. Typed conversions and word operations inline; +raw field comparison shares a memoized query across callers. -/ +private def implementation : Modules.Program Nat := aiur_library% (U8.templates.append signature) r#" +module UInt32: U32Signature { + type U8 = UInt8::U8; + opaque type U32 = [U8; 4]; + opaque type Compact = Field; + + const ZERO: U32 = [UInt8::BYTE_0; 4]; + const ONE: U32 = [UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0]; + const MAX: U32 = [UInt8::BYTE_255; 4]; + const COMPACT_ZERO: Compact = 0; + + inline fn from_bytes(bytes: [U8; 4]) -> U32 { bytes } + inline fn to_bytes(word: U32) -> [U8; 4] { word } + inline fn compact_field(word: Compact) -> Field { word } + inline fn compact(word: U32) -> Compact { + UInt8::to_field(word[0]) + 256*UInt8::to_field(word[1]) + + 65536*UInt8::to_field(word[2]) + 16777216*UInt8::to_field(word[3]) + } + inline fn from_fields(raw: [Field; 4]) -> U32 { + let (b0, b1) = UInt8::from_fields(raw[0], raw[1]); + let (b2, b3) = UInt8::from_fields(raw[2], raw[3]); + [b0, b1, b2, b3] + } + inline fn from_field(value: Field) -> U32 { + let raw = hint::<[Field; 4]>("u32.bytes", value); + let word = from_fields(raw); + constrain_eq!(compact(word), value, "u32 decomposition"); + word + } + inline fn compact_from_field(value: Field) -> Compact { from_field(value); value } + inline fn expand(word: Compact) -> U32 { from_field(word) } + + // Advice consumes bytes directly. Packing and the carry relation only + // feed constraints, so the Rust backend can discard that arithmetic. + inline fn add(a: U32, b: U32) -> U32 { + let raw = hint::<[Field; 4]>("u32.add", + ([UInt8::to_field(a[0]), UInt8::to_field(a[1]), UInt8::to_field(a[2]), UInt8::to_field(a[3])], + [UInt8::to_field(b[0]), UInt8::to_field(b[1]), UInt8::to_field(b[2]), UInt8::to_field(b[3])])); + let result = from_fields(raw); + let carry = (compact(a) + compact(b) - compact(result)) / 4294967296; + constrain_eq!(carry * (carry - 1), 0, "u32 add carry"); + result + } + inline fn add3(a: U32, b: U32, c: U32) -> U32 { + let raw = hint::<[Field; 4]>("u32.add3", + ([UInt8::to_field(a[0]), UInt8::to_field(a[1]), UInt8::to_field(a[2]), UInt8::to_field(a[3])], + [UInt8::to_field(b[0]), UInt8::to_field(b[1]), UInt8::to_field(b[2]), UInt8::to_field(b[3])], + [UInt8::to_field(c[0]), UInt8::to_field(c[1]), UInt8::to_field(c[2]), UInt8::to_field(c[3])])); + let result = from_fields(raw); + let carry = (compact(a) + compact(b) + compact(c) - compact(result)) / 4294967296; + constrain_eq!(carry * (carry - 1) * (carry - 2), 0, "u32 add3 carry"); + result + } + inline fn sub_borrow(a: Compact, b: Compact) -> (U32, Field) { + let raw = hint::<[Field; 4]>("u32.sub", (compact_field(a), compact_field(b))); + let result = from_fields(raw); + let borrow = (compact(result) + b - a) / 4294967296; + constrain_eq!(borrow * (borrow - 1), 0, "u32 subtraction borrow"); + (result, borrow) + } + inline fn sub(a: U32, b: U32) -> U32 { sub_borrow(compact(a), compact(b)).0 } + inline fn less_than(a: U32, b: U32) -> Field { compact_less_than(compact(a), compact(b)) } + inline fn compact_less_than(a: Compact, b: Compact) -> Field { + sub_borrow(a, b).1 + } + // Raw scalar compatibility boundary: both operands must be checked here. + // One hint supplies all three byte decompositions, including the wrapped + // difference. Reuse the byte-pair range table rather than adding a table. + fn less_than_fields(a: Field, b: Field) -> Field { + let raw = hint::<([Field; 4], [Field; 4], [Field; 4])>("u32.lt", (a, b)); + let left = from_fields(raw.0); + let difference = from_fields(raw.1); + let right = from_fields(raw.2); + constrain_eq!(a, compact(left), "u32 comparison left"); + constrain_eq!(b, compact(right), "u32 comparison right"); + let borrow = (compact(difference) + b - a) / 4294967296; + constrain_eq!(borrow * (borrow - 1), 0, "u32 comparison borrow"); + borrow + } + + inline fn xor(a: U32, b: U32) -> U32 { + [UInt8::xor(a[0], b[0]), UInt8::xor(a[1], b[1]), + UInt8::xor(a[2], b[2]), UInt8::xor(a[3], b[3])] + } + inline fn and(a: U32, b: U32) -> U32 { + [UInt8::and(a[0], b[0]), UInt8::and(a[1], b[1]), + UInt8::and(a[2], b[2]), UInt8::and(a[3], b[3])] + } + inline fn or(a: U32, b: U32) -> U32 { + [UInt8::or(a[0], b[0]), UInt8::or(a[1], b[1]), + UInt8::or(a[2], b[2]), UInt8::or(a[3], b[3])] + } + inline fn rotr8(a: U32) -> U32 { [a[1], a[2], a[3], a[0]] } + inline fn rotr16(a: U32) -> U32 { [a[2], a[3], a[0], a[1]] } + inline fn xor_rotr7(a: U32, b: U32) -> U32 { + let p0 = UInt8::xor_split7(a[0], b[0]); + let p1 = UInt8::xor_split7(a[1], b[1]); + let p2 = UInt8::xor_split7(a[2], b[2]); + let p3 = UInt8::xor_split7(a[3], b[3]); + [UInt8::join7(p0, p1), UInt8::join7(p1, p2), UInt8::join7(p2, p3), UInt8::join7(p3, p0)] + } + inline fn xor_rotr12(a: U32, b: U32) -> U32 { + let p0 = UInt8::xor_split4(a[0], b[0]); + let p1 = UInt8::xor_split4(a[1], b[1]); + let p2 = UInt8::xor_split4(a[2], b[2]); + let p3 = UInt8::xor_split4(a[3], b[3]); + [UInt8::join4(p1, p2), UInt8::join4(p2, p3), UInt8::join4(p3, p0), UInt8::join4(p0, p1)] + } +} +"# + +def declarations : Modules.Program Nat := signature.append implementation + +def templates : Modules.Program Nat := U8.templates.append declarations + +def source : Modules.Program Nat := U8.source.append declarations + +/-- Preferred field-specialization entrypoint: the caller establishes the +arithmetic precondition once, independently of the compiler's field genericity. -/ +def program (F : Type) [NatCast F] (_large : Compatible F) : Modules.Program F := + source.toField F + +end Aiur.Library.U32 diff --git a/Aiur/Aiur/Library/U32/Correctness.lean b/Aiur/Aiur/Library/U32/Correctness.lean new file mode 100644 index 000000000..bd711fd13 --- /dev/null +++ b/Aiur/Aiur/Library/U32/Correctness.lean @@ -0,0 +1,161 @@ +import Aiur.Library.U32 +import Aiur.Library.Carry +import Mathlib.Tactic.NormNum +import Mathlib.Tactic.Ring + +/-! Algebraic lemmas about the assertions in the ordinary Aiur word library. +These lemmas add no operation or trusted semantic rule. They establish what the +range checks and equations imply; the existing compiler correctness theorems +apply to the library's source just as they do to any other Aiur program. +-/ +namespace Aiur.Library.U32 + +def pack (a b c d : Nat) : Nat := a + 256*b + 65536*c + 16777216*d + +theorem pack_lt {a b c d : Nat} (ha : a < 256) (hb : b < 256) + (hc : c < 256) (hd : d < 256) : pack a b c d < base := by + unfold pack base + omega + +variable {F : Type} [Field F] + +theorem base_ne_zero (large : Compatible F) : (base : F) ≠ 0 := by + intro equal + have := large (x₁ := base) (x₂ := 0) (by norm_num [base]) (by norm_num [base]) + (by simpa using equal) + norm_num [base] at this + +theorem binary_carry (carry : F) : carry * (carry - 1) = 0 ↔ carry = 0 ∨ carry = 1 := by + simp [mul_eq_zero, sub_eq_zero] + +theorem ternary_carry (carry : F) : + carry * (carry - 1) * (carry - 2) = 0 ↔ carry = 0 ∨ carry = 1 ∨ carry = 2 := by + simp [mul_eq_zero, sub_eq_zero, or_assoc] + +/-- The packed carry relation has a unique, correct low word. This is the +integer-lifting step: a field equality is not enough without the field bound. -/ +theorem sum_sound (large : Compatible F) {sum result k : Nat} + (hs : sum < 3 * base) (hr : result < base) (hk : k < 3) + (equal : (sum : F) = (result : F) + (base : F) * (k : F)) : + result = sum % base := by + have bound : result + base * k < 3 * base := by unfold base at *; omega + have lifted : sum = result + base * k := large hs bound (by simpa using equal) + rw [lifted, Nat.add_mul_mod_self_left, Nat.mod_eq_of_lt hr] + +/-- The cubic used by `add3`, with the carry derived from the hinted result. -/ +theorem add3_check_iff (large : Compatible F) {sum result : Nat} + (hs : sum < 3 * base) (hr : result < base) : + let carry := ((sum : F) - (result : F)) / (base : F) + carry * (carry - 1) * (carry - 2) = 0 ↔ result = sum % base := by + dsimp + constructor + · intro valid + rcases (ternary_carry _).1 valid with h | h | h + · have h := (div_eq_iff (base_ne_zero large)).1 h + apply sum_sound large hs hr (k := 0) (by norm_num) + simpa [sub_eq_iff_eq_add, add_comm] using h + · have h := (div_eq_iff (base_ne_zero large)).1 h + apply sum_sound large hs hr (k := 1) (by norm_num) + simpa [sub_eq_iff_eq_add, add_comm] using h + · + have h := (div_eq_iff (base_ne_zero large)).1 h + apply sum_sound large hs hr (k := 2) (by norm_num) + linear_combination h + · intro equal + rw [equal, Carry.recover base sum (base_ne_zero large)] + have hk : sum / base < 3 := (Nat.div_lt_iff_lt_mul (by norm_num [base])).2 + (by simpa [mul_comm] using hs) + have small : ∀ n : Nat, n < 3 → n = 0 ∨ n = 1 ∨ n = 2 := by omega + have cases := small _ hk + rcases cases with h | h | h <;> simp [h] + +theorem add_check_iff (large : Compatible F) {sum result : Nat} + (hs : sum < 2 * base) (hr : result < base) : + let carry := ((sum : F) - (result : F)) / (base : F) + carry * (carry - 1) = 0 ↔ result = sum % base := by + dsimp + constructor + · intro valid + apply (add3_check_iff large (by omega) hr).1 + simp [valid] + · intro equal + rw [equal, Carry.recover base sum (base_ne_zero large)] + have hk : sum / base < 2 := (Nat.div_lt_iff_lt_mul (by norm_num [base])).2 + (by simpa [mul_comm] using hs) + have small : ∀ n : Nat, n < 2 → n = 0 ∨ n = 1 := by omega + rcases small _ hk with h | h <;> simp [h] + +/-- Packed operands already satisfy the word bound; range-checking the +result and constraining the derived carry suffice for wrapping addition. -/ +theorem add_words_check_iff (large : Compatible F) {a b result : Nat} + (ha : a < base) (hb : b < base) (hr : result < base) : + let carry := ((a : F) + (b : F) - (result : F)) / (base : F) + carry * (carry - 1) = 0 ↔ result = (a + b) % base := by + simpa only [Nat.cast_add] using + (add_check_iff large (sum := a + b) (by omega) hr) + +theorem add3_words_check_iff (large : Compatible F) {a b c result : Nat} + (ha : a < base) (hb : b < base) (hc : c < base) (hr : result < base) : + let carry := ((a : F) + (b : F) + (c : F) - (result : F)) / (base : F) + carry * (carry - 1) * (carry - 2) = 0 ↔ result = (a + b + c) % base := by + simpa only [Nat.cast_add] using + (add3_check_iff large (sum := a + b + c) (by omega) hr) + +/-- The reconstructed boolean borrow determines comparison and wrapping +subtraction simultaneously. The only range checks needed are the result bytes, +because both input compact words were already constructed through the API. -/ +theorem sub_sound (large : Compatible F) {a b result : Nat} + (ha : a < base) (hb : b < base) (hr : result < base) + (valid : let borrow := ((result : F) + (b : F) - (a : F)) / (base : F) + borrow * (borrow - 1) = 0) : + result = (a + base - b) % base ∧ + ((result : F) + (b : F) - (a : F)) / (base : F) = if a < b then 1 else 0 := by + dsimp at valid + rcases (binary_carry _).1 valid with h | h + · have equation := (div_eq_iff (base_ne_zero large)).1 h + have lifted : result + b = a := large (x₁ := result + b) (x₂ := a) + (by change result + b < 3 * base; omega) (by change a < 3 * base; omega) + (by push_cast; linear_combination equation) + have order : ¬a < b := by omega + constructor + · have : a + base - b = result + base := by omega + rw [this, Nat.add_mod_right, Nat.mod_eq_of_lt hr] + · simpa [order] using h + · have equation := (div_eq_iff (base_ne_zero large)).1 h + have lifted : result + b = a + base := large (x₁ := result + b) (x₂ := a + base) + (by change result + b < 3 * base; omega) (by change a + base < 3 * base; omega) + (by push_cast; linear_combination equation) + have order : a < b := by omega + constructor + · have : a + base - b = result := by omega + rw [this, Nat.mod_eq_of_lt hr] + · simpa [order] using h + +theorem joined_nibbles_lt {x y : Nat} (hx : x < 256) (_hy : y < 256) : + x / 16 + (y % 16) * 16 < 256 := by omega + +theorem joined_seven_bits_lt {x y : Nat} (hx : x < 256) (_hy : y < 256) : + x / 128 + (y % 128) * 2 < 256 := by omega + +/-- The three checked byte decompositions establish operand and difference +bounds (`pack_lt`). Recomposition ties the raw fields to those bounded words, +so the boolean borrow is exactly unsigned less-than, including at equality. -/ +theorem compare_fields_sound (large : Compatible F) (a b : F) + {leftWord rightWord difference : Nat} + (ha : leftWord < base) (hb : rightWord < base) (hd : difference < base) + (left : a = (leftWord : F)) (right : b = (rightWord : F)) + (valid : let borrow := ((difference : F) + b - a) / (base : F) + borrow * (borrow - 1) = 0) : + ((difference : F) + b - a) / (base : F) = + if leftWord < rightWord then 1 else 0 := by + subst a; subst b + exact (sub_sound large ha hb hd valid).2 + +#print axioms add_check_iff +#print axioms add3_check_iff +#print axioms sub_sound +#print axioms add_words_check_iff +#print axioms add3_words_check_iff +#print axioms compare_fields_sound + +end Aiur.Library.U32 diff --git a/Aiur/Aiur/Library/U32/Goldilocks.lean b/Aiur/Aiur/Library/U32/Goldilocks.lean new file mode 100644 index 000000000..de0cf75ff --- /dev/null +++ b/Aiur/Aiur/Library/U32/Goldilocks.lean @@ -0,0 +1,39 @@ +import Aiur.Library.U32 +import Mathlib.Algebra.Field.ZMod +import Mathlib.NumberTheory.LucasPrimality +import Mathlib.Tactic.ReduceModChar +import Mathlib.Tactic.NormNum.Prime + +/-! Explicit field selection for the IxVM word implementation. The host hints +and source assertions remain ordinary Aiur operations. Other fields can select +another implementation at this module boundary without changing the compiler. +The current implementation only needs the weaker `U32.Compatible` bound. -/ +namespace Aiur.Library.U32.Goldilocks + +abbrev modulus := 18446744069414584321 +abbrev F := ZMod modulus + +set_option maxRecDepth 10000 in +set_option maxHeartbeats 2000000 in +theorem modulus_prime : Nat.Prime modulus := by + apply lucas_primality modulus (7 : F) + · reduce_mod_char + · intro q hq hd + have factors : modulus - 1 = 2^32 * 3 * 5 * 17 * 257 * 65537 := by norm_num + rw [factors] at hd + simp only [hq.dvd_mul, or_assoc] at hd + rcases hd with hd | hd | hd | hd | hd | hd + all_goals + try replace hd := hq.dvd_of_dvd_pow hd + rw [Nat.prime_dvd_prime_iff_eq hq (by norm_num)] at hd + subst q + reduce_mod_char + decide + +instance : Fact (Nat.Prime modulus) := ⟨modulus_prime⟩ + +theorem compatible : U32.Compatible F := U32.compatible_of_charP F modulus (by decide) + +def program : Modules.Program F := U32.program F compatible + +end Aiur.Library.U32.Goldilocks diff --git a/Aiur/Aiur/Library/U32/Hints.lean b/Aiur/Aiur/Library/U32/Hints.lean new file mode 100644 index 000000000..e21442c90 --- /dev/null +++ b/Aiur/Aiur/Library/U32/Hints.lean @@ -0,0 +1,34 @@ +import Aiur.Hints +import Aiur.Library.U32 + +namespace Aiur.Library.U32 + +/-- An optional provider for the semantic evaluator. `toNat` is the embedding +host's canonical integer decoder. A bad decoder/answer cannot bypass any of the +library's assertions or table checks. These are raw constants, never opaque +values. Other channels can be supplied by the caller's fallback dispatcher. -/ +def hints {F : Type} [NatCast F] (toNat : F → Nat) + (fallback : HintDispatcher F := fun _ _ => .error .unavailable) : HintDispatcher F := + fun channel key => + let bytes (n : Nat) : Constant F := + .tuple ((List.range 4).map fun i => .field (((n / 256^i) % 256 : Nat) : F)) + let word (value : Constant F) : Option Nat := do + let .tuple [.field a, .field b, .field c, .field d] := value | none + some (toNat a + 256*toNat b + 65536*toNat c + 16777216*toNat d) + let sum (values : List (Constant F)) : Except HintError (Constant F) := do + let some words := values.mapM word | throw (.message "invalid u32 sum key") + return bytes words.sum + match channel, key with + | "u32.bytes", .field value => .ok (bytes (toNat value)) + | "u32.sub", .tuple [.field a, .field b] => + .ok (bytes (toNat a % base + base - toNat b % base)) + | "u32.add", .tuple [a, b] => sum [a, b] + | "u32.add3", .tuple [a, b, c] => sum [a, b, c] + | "u32.lt", .tuple [.field a, .field b] => + .ok (.tuple [bytes (toNat a), + bytes (toNat a % base + base - toNat b % base), bytes (toNat b)]) + | "u32.bytes", _ | "u32.sub", _ | "u32.add", _ | "u32.add3", _ + | "u32.lt", _ => .error (.message "invalid u32 hint key") + | _, _ => fallback channel key + +end Aiur.Library.U32 diff --git a/Aiur/Aiur/Library/U32/Signature.lean b/Aiur/Aiur/Library/U32/Signature.lean new file mode 100644 index 000000000..65662c458 --- /dev/null +++ b/Aiur/Aiur/Library/U32/Signature.lean @@ -0,0 +1,42 @@ +import Aiur.Library.U8 +import Aiur.Library.Frontend + +/-! Checked words and their compact representation. The byte boundary uses +the selected UInt8 implementation; arithmetic clients only need U32Signature. +Field-specific implementations must establish their own arithmetic bounds. -/ +namespace Aiur.Library.U32 +open Aiur + +def signature : Modules.Program Nat := aiur_library% U8.templates " +signature U32Signature { + opaque type U32; + opaque type Compact; + const ZERO: U32; + const ONE: U32; + const MAX: U32; + const COMPACT_ZERO: Compact; + fn from_bytes(bytes: [UInt8::U8; 4]) -> U32; + fn to_bytes(word: U32) -> [UInt8::U8; 4]; + fn from_fields(raw: [Field; 4]) -> U32; + fn from_field(value: Field) -> U32; + fn compact_field(word: Compact) -> Field; + fn compact(word: U32) -> Compact; + fn compact_from_field(value: Field) -> Compact; + fn expand(word: Compact) -> U32; + fn add(a: U32, b: U32) -> U32; + fn add3(a: U32, b: U32, c: U32) -> U32; + fn sub_borrow(a: Compact, b: Compact) -> (U32, Field); + fn sub(a: U32, b: U32) -> U32; + fn less_than(a: U32, b: U32) -> Field; + fn compact_less_than(a: Compact, b: Compact) -> Field; + fn less_than_fields(a: Field, b: Field) -> Field; + fn xor(a: U32, b: U32) -> U32; + fn and(a: U32, b: U32) -> U32; + fn or(a: U32, b: U32) -> U32; + fn rotr8(a: U32) -> U32; + fn rotr16(a: U32) -> U32; + fn xor_rotr7(a: U32, b: U32) -> U32; + fn xor_rotr12(a: U32, b: U32) -> U32; +}" + +end Aiur.Library.U32 diff --git a/Aiur/Aiur/Library/U64.lean b/Aiur/Aiur/Library/U64.lean new file mode 100644 index 000000000..9c7ec870f --- /dev/null +++ b/Aiur/Aiur/Library/U64.lean @@ -0,0 +1,225 @@ +import Aiur.Library.U8 +import Aiur.Library.Frontend +import Mathlib.Algebra.CharP.Basic + +/-! Eight checked little-endian bytes. The transparent word alias still contains +opaque bytes, so fields and hints cannot fabricate a word. Arithmetic lives here; +serializers may destructure existing bytes without rechecking them. +Multiplication columns and checked scalar conversion require a field with an +injective natural cast below 2^56. -/ +namespace Aiur.Library.U64 +open Aiur + +def Compatible (F : Type) [NatCast F] : Prop := + Set.InjOn (Nat.cast : Nat → F) (Set.Iio (2^56)) + +theorem compatible_of_charP (F : Type) [AddGroupWithOne F] (p : Nat) [CharP F p] + (large : 2^56 ≤ p) : Compatible F := by + intro a ha b hb equal + exact CharP.natCast_injOn_Iio F p (lt_of_lt_of_le ha large) (lt_of_lt_of_le hb large) equal + +def declarations : Modules.Program Nat := aiur_library% U8.templates r#" +module UInt64 { + type U8 = UInt8::U8; + type U64 = [U8; 8]; + const ZERO: U64 = [UInt8::BYTE_0; 8]; + const ONE: U64 = [UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, + UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0]; + const MAX: U64 = [UInt8::BYTE_255; 8]; + inline fn from_bytes(bytes: [U8; 8]) -> U64 { bytes } + inline fn to_bytes(word: U64) -> [U8; 8] { word } + inline fn from_fields(raw: [Field; 8]) -> U64 { + let (b0, b1) = UInt8::from_fields(raw[0], raw[1]); + let (b2, b3) = UInt8::from_fields(raw[2], raw[3]); + let (b4, b5) = UInt8::from_fields(raw[4], raw[5]); + let (b6, b7) = UInt8::from_fields(raw[6], raw[7]); + [b0, b1, b2, b3, b4, b5, b6, b7] + } + fn is_zero(x: U64) -> Field { + match x { + [UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0] => { 1 }, + _ => { 0 }, + } + } + + fn eq(a: U64, b: U64) -> Field { + let [a0, a1, a2, a3, a4, a5, a6, a7] = a; + let [b0, b1, b2, b3, b4, b5, b6, b7] = b; + match [UInt8::to_field(a0) - UInt8::to_field(b0), UInt8::to_field(a1) - UInt8::to_field(b1), + UInt8::to_field(a2) - UInt8::to_field(b2), UInt8::to_field(a3) - UInt8::to_field(b3), + UInt8::to_field(a4) - UInt8::to_field(b4), UInt8::to_field(a5) - UInt8::to_field(b5), + UInt8::to_field(a6) - UInt8::to_field(b6), UInt8::to_field(a7) - UInt8::to_field(b7)] { + [0, 0, 0, 0, 0, 0, 0, 0] => { 1 }, + _ => { 0 }, + } + } + + fn add(a: U64, b: U64) -> (U64, U8) { + let (s0, c1) = UInt8::split_sum(UInt8::to_field(a[0]) + UInt8::to_field(b[0])); + let (s1, c2) = UInt8::split_sum(UInt8::to_field(a[1]) + UInt8::to_field(b[1]) + UInt8::to_field(c1)); + let (s2, c3) = UInt8::split_sum(UInt8::to_field(a[2]) + UInt8::to_field(b[2]) + UInt8::to_field(c2)); + let (s3, c4) = UInt8::split_sum(UInt8::to_field(a[3]) + UInt8::to_field(b[3]) + UInt8::to_field(c3)); + let (s4, c5) = UInt8::split_sum(UInt8::to_field(a[4]) + UInt8::to_field(b[4]) + UInt8::to_field(c4)); + let (s5, c6) = UInt8::split_sum(UInt8::to_field(a[5]) + UInt8::to_field(b[5]) + UInt8::to_field(c5)); + let (s6, c7) = UInt8::split_sum(UInt8::to_field(a[6]) + UInt8::to_field(b[6]) + UInt8::to_field(c6)); + let (s7, c8) = UInt8::split_sum(UInt8::to_field(a[7]) + UInt8::to_field(b[7]) + UInt8::to_field(c7)); + ([s0, s1, s2, s3, s4, s5, s6, s7], c8) + } + + fn wrapping_succ(bytes: U64) -> U64 { + let [b0, b1, b2, b3, b4, b5, b6, b7] = bytes; + + match UInt8::to_field(b0) { + 255 => { match UInt8::to_field(b1) { + 255 => { match UInt8::to_field(b2) { + 255 => { match UInt8::to_field(b3) { + 255 => { match UInt8::to_field(b4) { + 255 => { match UInt8::to_field(b5) { + 255 => { match UInt8::to_field(b6) { + 255 => { match UInt8::to_field(b7) { + 255 => { [UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0] }, + _ => { [UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::from_field(UInt8::to_field(b7) + 1)] }, + } }, + _ => { [UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::from_field(UInt8::to_field(b6) + 1), b7] }, + } }, + _ => { [UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::from_field(UInt8::to_field(b5) + 1), b6, b7] }, + } }, + _ => { [UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::from_field(UInt8::to_field(b4) + 1), b5, b6, b7] }, + } }, + _ => { [UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::from_field(UInt8::to_field(b3) + 1), b4, b5, b6, b7] }, + } }, + _ => { [UInt8::BYTE_0, UInt8::BYTE_0, UInt8::from_field(UInt8::to_field(b2) + 1), b3, b4, b5, b6, b7] }, + } }, + _ => { [UInt8::BYTE_0, UInt8::from_field(UInt8::to_field(b1) + 1), b2, b3, b4, b5, b6, b7] }, + } }, + _ => { [UInt8::from_field(UInt8::to_field(b0) + 1), b1, b2, b3, b4, b5, b6, b7] }, + } + } + + fn saturating_pred(bytes: U64) -> U64 { + let [b0, b1, b2, b3, b4, b5, b6, b7] = bytes; + + match UInt8::to_field(b0) { + 0 => { match UInt8::to_field(b1) { + 0 => { match UInt8::to_field(b2) { + 0 => { match UInt8::to_field(b3) { + 0 => { match UInt8::to_field(b4) { + 0 => { match UInt8::to_field(b5) { + 0 => { match UInt8::to_field(b6) { + 0 => { match UInt8::to_field(b7) { + 0 => { [UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0] }, + _ => { [UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::from_field(UInt8::to_field(b7) - 1)] }, + } }, + _ => { [UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::from_field(UInt8::to_field(b6) - 1), b7] }, + } }, + _ => { [UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::from_field(UInt8::to_field(b5) - 1), b6, b7] }, + } }, + _ => { [UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::from_field(UInt8::to_field(b4) - 1), b5, b6, b7] }, + } }, + _ => { [UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::from_field(UInt8::to_field(b3) - 1), b4, b5, b6, b7] }, + } }, + _ => { [UInt8::BYTE_255, UInt8::BYTE_255, UInt8::from_field(UInt8::to_field(b2) - 1), b3, b4, b5, b6, b7] }, + } }, + _ => { [UInt8::BYTE_255, UInt8::from_field(UInt8::to_field(b1) - 1), b2, b3, b4, b5, b6, b7] }, + } }, + _ => { [UInt8::from_field(UInt8::to_field(b0) - 1), b1, b2, b3, b4, b5, b6, b7] }, + } + } + + fn to_field(x: [U8; 8]) -> Field { + let [b0, b1, b2, b3, b4, b5, b6, b7] = x; + assert_eq!(UInt8::to_field(b7), 0, + "u64 -> field: value exceeds 2^56 (top byte must be zero)"); + UInt8::to_field(b0) + 256 * UInt8::to_field(b1) + 65536 * UInt8::to_field(b2) + + 16777216 * UInt8::to_field(b3) + 4294967296 * UInt8::to_field(b4) + + 1099511627776 * UInt8::to_field(b5) + 281474976710656 * UInt8::to_field(b6) + } + + fn sub_with_borrow(a: U64, b: U64) -> (U64, Field) { + let (s0, c1) = UInt8::split_sum(UInt8::to_field(a[0]) + 256 - UInt8::to_field(b[0])); + let (s1, c2) = UInt8::split_sum(UInt8::to_field(a[1]) + 255 - UInt8::to_field(b[1]) + UInt8::to_field(c1)); + let (s2, c3) = UInt8::split_sum(UInt8::to_field(a[2]) + 255 - UInt8::to_field(b[2]) + UInt8::to_field(c2)); + let (s3, c4) = UInt8::split_sum(UInt8::to_field(a[3]) + 255 - UInt8::to_field(b[3]) + UInt8::to_field(c3)); + let (s4, c5) = UInt8::split_sum(UInt8::to_field(a[4]) + 255 - UInt8::to_field(b[4]) + UInt8::to_field(c4)); + let (s5, c6) = UInt8::split_sum(UInt8::to_field(a[5]) + 255 - UInt8::to_field(b[5]) + UInt8::to_field(c5)); + let (s6, c7) = UInt8::split_sum(UInt8::to_field(a[6]) + 255 - UInt8::to_field(b[6]) + UInt8::to_field(c6)); + let (s7, c8) = UInt8::split_sum(UInt8::to_field(a[7]) + 255 - UInt8::to_field(b[7]) + UInt8::to_field(c7)); + ([s0, s1, s2, s3, s4, s5, s6, s7], 1 - UInt8::to_field(c8)) + } + + fn mul(a: U64, b: U64) -> (U64, U64) { + let a0 = UInt8::to_field(a[0]) + 256 * UInt8::to_field(a[1]); + let b0 = UInt8::to_field(b[0]) + 256 * UInt8::to_field(b[1]); + let a1 = UInt8::to_field(a[2]) + 256 * UInt8::to_field(a[3]); + let b1 = UInt8::to_field(b[2]) + 256 * UInt8::to_field(b[3]); + let a2 = UInt8::to_field(a[4]) + 256 * UInt8::to_field(a[5]); + let b2 = UInt8::to_field(b[4]) + 256 * UInt8::to_field(b[5]); + let a3 = UInt8::to_field(a[6]) + 256 * UInt8::to_field(a[7]); + let b3 = UInt8::to_field(b[6]) + 256 * UInt8::to_field(b[7]); + let (r0, c0) = mul_column((a0 * b0)); + let (r1, c1) = mul_column((a0 * b1) + (a1 * b0) + UInt8::to_field(c0[0]) + 256 * UInt8::to_field(c0[1]) + 65536 * UInt8::to_field(c0[2])); + let (r2, c2) = mul_column((a0 * b2) + (a1 * b1) + (a2 * b0) + UInt8::to_field(c1[0]) + 256 * UInt8::to_field(c1[1]) + 65536 * UInt8::to_field(c1[2])); + let (r3, c3) = mul_column((a0 * b3) + (a1 * b2) + (a2 * b1) + (a3 * b0) + UInt8::to_field(c2[0]) + 256 * UInt8::to_field(c2[1]) + 65536 * UInt8::to_field(c2[2])); + let (r4, c4) = mul_column((a1 * b3) + (a2 * b2) + (a3 * b1) + UInt8::to_field(c3[0]) + 256 * UInt8::to_field(c3[1]) + 65536 * UInt8::to_field(c3[2])); + let (r5, c5) = mul_column((a2 * b3) + (a3 * b2) + UInt8::to_field(c4[0]) + 256 * UInt8::to_field(c4[1]) + 65536 * UInt8::to_field(c4[2])); + let (r6, c6) = mul_column((a3 * b3) + UInt8::to_field(c5[0]) + 256 * UInt8::to_field(c5[1]) + 65536 * UInt8::to_field(c5[2])); + assert_eq!(UInt8::to_field(c6[2]), 0, "mul: final carry exceeds one radix digit"); + ([r0[0], r0[1], r1[0], r1[1], r2[0], r2[1], r3[0], r3[1]], + [r4[0], r4[1], r5[0], r5[1], r6[0], r6[1], c6[0], c6[1]]) + } + + inline fn mul_column(x: Field) -> ([U8; 2], [U8; 3]) { + let bytes = hint::<[Field; 8]>("bytes_le", x); + let (r0, r1) = UInt8::from_fields(bytes[0], bytes[1]); + let (c0, c1) = UInt8::from_fields(bytes[2], bytes[3]); + let (c2, _) = UInt8::from_fields(bytes[4], 0); + constrain_eq!(x, UInt8::to_field(r0) + 256 * UInt8::to_field(r1) + + 65536 * (UInt8::to_field(c0) + 256 * UInt8::to_field(c1) + 65536 * UInt8::to_field(c2)), + "mul: column hint does not recompose"); + ([r0, r1], [c0, c1, c2]) + } + + fn and(a: U64, b: U64) -> U64 { + let [a0, a1, a2, a3, a4, a5, a6, a7] = a; + let [b0, b1, b2, b3, b4, b5, b6, b7] = b; + [UInt8::and(a0, b0), UInt8::and(a1, b1), UInt8::and(a2, b2), UInt8::and(a3, b3), + UInt8::and(a4, b4), UInt8::and(a5, b5), UInt8::and(a6, b6), UInt8::and(a7, b7)] + } + + fn or(a: U64, b: U64) -> U64 { + let [a0, a1, a2, a3, a4, a5, a6, a7] = a; + let [b0, b1, b2, b3, b4, b5, b6, b7] = b; + [UInt8::or(a0, b0), UInt8::or(a1, b1), UInt8::or(a2, b2), UInt8::or(a3, b3), + UInt8::or(a4, b4), UInt8::or(a5, b5), UInt8::or(a6, b6), UInt8::or(a7, b7)] + } + + fn xor(a: U64, b: U64) -> U64 { + let [a0, a1, a2, a3, a4, a5, a6, a7] = a; + let [b0, b1, b2, b3, b4, b5, b6, b7] = b; + [UInt8::xor(a0, b0), UInt8::xor(a1, b1), UInt8::xor(a2, b2), UInt8::xor(a3, b3), + UInt8::xor(a4, b4), UInt8::xor(a5, b5), UInt8::xor(a6, b6), UInt8::xor(a7, b7)] + } + + fn from_field(value: Field) -> U64 { + let [h0, h1, h2, h3, h4, h5, h6, h7] = hint::<[Field; 8]>("bytes_le", value); + let (b0, b1) = UInt8::from_fields(h0, h1); + let (b2, b3) = UInt8::from_fields(h2, h3); + let (b4, b5) = UInt8::from_fields(h4, h5); + let (b6, b7) = UInt8::from_fields(h6, h7); + let bytes = [b0, b1, b2, b3, b4, b5, b6, b7]; + + constrain_eq!(to_field(bytes), value, + "u64 bytes do not recompose to the field value"); + bytes + } +} +"# + +def templates : Modules.Program Nat := U8.templates.append declarations +def source : Modules.Program Nat := U8.source.append declarations + +/-- Link this specialization with the shared UInt8 module. -/ +def specialize (F : Type) [NatCast F] (_large : Compatible F) : Modules.Program F := + declarations.toField F + +end Aiur.Library.U64 diff --git a/Aiur/Aiur/Library/U64/Correctness.lean b/Aiur/Aiur/Library/U64/Correctness.lean new file mode 100644 index 000000000..aeed29b8d --- /dev/null +++ b/Aiur/Aiur/Library/U64/Correctness.lean @@ -0,0 +1,729 @@ +import Aiur.Library.U64 +import Aiur.Library.U32.Correctness +import Aiur.Library.U8Facts +import Aiur.Library.Carry +import Mathlib.Tactic.NormNum +import Mathlib.Tactic.Ring +import Mathlib.Tactic.Linarith + +/-! Algebraic and byte-packing correctness lemmas for the `UInt64` library (`Aiur.Library.U64`). +These lemmas establish soundness and completeness of all 12 `UInt64` operations +(`is_zero`, `eq`, `add`, `wrapping_succ`, `saturating_pred`, `to_field`, +`sub_with_borrow`, `mul`, `and`, `or`, `xor`, `from_field`) under `[Field F]` +and `U64.Compatible F`. +-/ +namespace Aiur.Library.U64 + +def base : Nat := 18446744073709551616 + +def fieldBound : Nat := 72057594037927936 + +theorem compatible_of_charZero (F : Type) [AddMonoidWithOne F] [CharZero F] : + Compatible F := by + intro _ _ _ _ equal + exact Nat.cast_injective equal + +theorem u32_compatible {F : Type} [NatCast F] (large : Compatible F) : + U32.Compatible F := by + intro a ha b hb equal + apply large + · change a < 2^56 + change a < 3 * U32.base at ha + unfold U32.base at ha + omega + · change b < 2^56 + change b < 3 * U32.base at hb + unfold U32.base at hb + omega + · exact equal + +def pack (b0 b1 b2 b3 b4 b5 b6 b7 : Nat) : Nat := + b0 + 256 * b1 + 65536 * b2 + 16777216 * b3 + + 4294967296 * b4 + 1099511627776 * b5 + + 281474976710656 * b6 + 72057594037927936 * b7 + +def pack56 (b0 b1 b2 b3 b4 b5 b6 : Nat) : Nat := + b0 + 256 * b1 + 65536 * b2 + 16777216 * b3 + + 4294967296 * b4 + 1099511627776 * b5 + + 281474976710656 * b6 + +def limb2 (r0 r1 : Nat) : Nat := + r0 + 256 * r1 + +def carry3 (c0 c1 c2 : Nat) : Nat := + c0 + 256 * c1 + 65536 * c2 + +theorem pack_eq_pack56_add (b0 b1 b2 b3 b4 b5 b6 b7 : Nat) : + pack b0 b1 b2 b3 b4 b5 b6 b7 = pack56 b0 b1 b2 b3 b4 b5 b6 + fieldBound * b7 := by + unfold pack pack56 fieldBound + ring + +theorem pack_lt {b0 b1 b2 b3 b4 b5 b6 b7 : Nat} + (h0 : b0 < 256) (h1 : b1 < 256) (h2 : b2 < 256) (h3 : b3 < 256) + (h4 : b4 < 256) (h5 : b5 < 256) (h6 : b6 < 256) (h7 : b7 < 256) : + pack b0 b1 b2 b3 b4 b5 b6 b7 < base := by + unfold pack base + omega + +theorem pack56_lt {b0 b1 b2 b3 b4 b5 b6 : Nat} + (h0 : b0 < 256) (h1 : b1 < 256) (h2 : b2 < 256) (h3 : b3 < 256) + (h4 : b4 < 256) (h5 : b5 < 256) (h6 : b6 < 256) : + pack56 b0 b1 b2 b3 b4 b5 b6 < fieldBound := by + unfold pack56 fieldBound + omega + +theorem limb2_lt {r0 r1 : Nat} (h0 : r0 < 256) (h1 : r1 < 256) : + limb2 r0 r1 < 65536 := by + unfold limb2 + omega + +theorem carry3_lt {c0 c1 c2 : Nat} (h0 : c0 < 256) (h1 : c1 < 256) (h2 : c2 < 256) : + carry3 c0 c1 c2 < 16777216 := by + unfold carry3 + omega + +theorem pack56_inj {a0 a1 a2 a3 a4 a5 a6 b0 b1 b2 b3 b4 b5 b6 : Nat} + (ha0 : a0 < 256) (ha1 : a1 < 256) (ha2 : a2 < 256) (ha3 : a3 < 256) + (ha4 : a4 < 256) (ha5 : a5 < 256) (_ha6 : a6 < 256) + (hb0 : b0 < 256) (hb1 : b1 < 256) (hb2 : b2 < 256) (hb3 : b3 < 256) + (hb4 : b4 < 256) (hb5 : b5 < 256) (_hb6 : b6 < 256) : + pack56 a0 a1 a2 a3 a4 a5 a6 = pack56 b0 b1 b2 b3 b4 b5 b6 ↔ + a0 = b0 ∧ a1 = b1 ∧ a2 = b2 ∧ a3 = b3 ∧ + a4 = b4 ∧ a5 = b5 ∧ a6 = b6 := by + constructor + · intro h + unfold pack56 at h + have h6 : a6 = b6 := by omega + subst h6 + have h5 : a5 = b5 := by omega + subst h5 + have h4 : a4 = b4 := by omega + subst h4 + have h3 : a3 = b3 := by omega + subst h3 + have h2 : a2 = b2 := by omega + subst h2 + have h1 : a1 = b1 := by omega + subst h1 + have h0 : a0 = b0 := by omega + exact ⟨h0, rfl, rfl, rfl, rfl, rfl, rfl⟩ + · rintro ⟨rfl, rfl, rfl, rfl, rfl, rfl, rfl⟩ + rfl + +theorem pack_inj {a0 a1 a2 a3 a4 a5 a6 a7 b0 b1 b2 b3 b4 b5 b6 b7 : Nat} + (ha0 : a0 < 256) (ha1 : a1 < 256) (ha2 : a2 < 256) (ha3 : a3 < 256) + (ha4 : a4 < 256) (ha5 : a5 < 256) (ha6 : a6 < 256) (_ha7 : a7 < 256) + (hb0 : b0 < 256) (hb1 : b1 < 256) (hb2 : b2 < 256) (hb3 : b3 < 256) + (hb4 : b4 < 256) (hb5 : b5 < 256) (hb6 : b6 < 256) (_hb7 : b7 < 256) : + pack a0 a1 a2 a3 a4 a5 a6 a7 = pack b0 b1 b2 b3 b4 b5 b6 b7 ↔ + a0 = b0 ∧ a1 = b1 ∧ a2 = b2 ∧ a3 = b3 ∧ + a4 = b4 ∧ a5 = b5 ∧ a6 = b6 ∧ a7 = b7 := by + constructor + · intro h + rw [pack_eq_pack56_add, pack_eq_pack56_add] at h + have h56a := pack56_lt ha0 ha1 ha2 ha3 ha4 ha5 ha6 + have h56b := pack56_lt hb0 hb1 hb2 hb3 hb4 hb5 hb6 + have h7 : a7 = b7 := by unfold fieldBound at *; omega + subst h7 + have h56 : pack56 a0 a1 a2 a3 a4 a5 a6 = pack56 b0 b1 b2 b3 b4 b5 b6 := by omega + obtain ⟨rfl, rfl, rfl, rfl, rfl, rfl, rfl⟩ := + (pack56_inj ha0 ha1 ha2 ha3 ha4 ha5 ha6 hb0 hb1 hb2 hb3 hb4 hb5 hb6).mp h56 + exact ⟨rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl⟩ + · rintro ⟨rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl⟩ + rfl + +variable {F : Type} [Field F] + +theorem natCast_inj (large : Compatible F) {a b : Nat} + (ha : a < fieldBound) (hb : b < fieldBound) (equal : (a : F) = (b : F)) : + a = b := + large (by simpa [fieldBound] using ha) (by simpa [fieldBound] using hb) equal + +theorem byte_cast_inj (large : Compatible F) {a b : Nat} + (ha : a < 256) (hb : b < 256) (equal : (a : F) = (b : F)) : + a = b := + natCast_inj large (by unfold fieldBound; omega) (by unfold fieldBound; omega) equal + +theorem byte_cast_eq_iff (large : Compatible F) {a b : Nat} + (ha : a < 256) (hb : b < 256) : + ((a : F) = (b : F)) ↔ a = b := + ⟨byte_cast_inj large ha hb, fun h => by subst h; rfl⟩ + +theorem byte_sub_eq_zero_iff (large : Compatible F) {a b : Nat} + (ha : a < 256) (hb : b < 256) : + ((a : F) - (b : F) = 0) ↔ a = b := by + rw [sub_eq_zero] + exact byte_cast_eq_iff large ha hb + +theorem two_ne_zero (large : Compatible F) : (2 : F) ≠ 0 := by + intro equal + have := natCast_inj large (a := 2) (b := 0) (by unfold fieldBound; omega) + (by unfold fieldBound; omega) (by simpa using equal) + omega + +theorem radix_ne_zero (large : Compatible F) : (256 : F) ≠ 0 := by + intro equal + have := natCast_inj large (a := 256) (b := 0) (by unfold fieldBound; omega) + (by unfold fieldBound; omega) (by simpa using equal) + omega + +theorem byte_eq_zero_iff (large : Compatible F) {a : Nat} (ha : a < 256) : + ((a : F) = 0) ↔ a = 0 := by + have hz : (0 : F) = ((0 : Nat) : F) := by simp + rw [hz] + exact byte_cast_eq_iff large ha (by omega) + +/-! ### 1. `is_zero` -/ + +theorem is_zero_sound (large : Compatible F) {b0 b1 b2 b3 b4 b5 b6 b7 : Nat} + (h0 : b0 < 256) (h1 : b1 < 256) (h2 : b2 < 256) (h3 : b3 < 256) + (h4 : b4 < 256) (h5 : b5 < 256) (h6 : b6 < 256) (h7 : b7 < 256) : + ((b0 : F) = 0 ∧ (b1 : F) = 0 ∧ (b2 : F) = 0 ∧ (b3 : F) = 0 ∧ + (b4 : F) = 0 ∧ (b5 : F) = 0 ∧ (b6 : F) = 0 ∧ (b7 : F) = 0) ↔ + pack b0 b1 b2 b3 b4 b5 b6 b7 = 0 := by + rw [byte_eq_zero_iff large h0, byte_eq_zero_iff large h1, + byte_eq_zero_iff large h2, byte_eq_zero_iff large h3, + byte_eq_zero_iff large h4, byte_eq_zero_iff large h5, + byte_eq_zero_iff large h6, byte_eq_zero_iff large h7] + unfold pack + omega + +/-! ### 2. `eq` -/ + +theorem eq_sound (large : Compatible F) + {a0 a1 a2 a3 a4 a5 a6 a7 b0 b1 b2 b3 b4 b5 b6 b7 : Nat} + (ha0 : a0 < 256) (ha1 : a1 < 256) (ha2 : a2 < 256) (ha3 : a3 < 256) + (ha4 : a4 < 256) (ha5 : a5 < 256) (ha6 : a6 < 256) (ha7 : a7 < 256) + (hb0 : b0 < 256) (hb1 : b1 < 256) (hb2 : b2 < 256) (hb3 : b3 < 256) + (hb4 : b4 < 256) (hb5 : b5 < 256) (hb6 : b6 < 256) (hb7 : b7 < 256) : + ((a0 : F) - (b0 : F) = 0 ∧ (a1 : F) - (b1 : F) = 0 ∧ + (a2 : F) - (b2 : F) = 0 ∧ (a3 : F) - (b3 : F) = 0 ∧ + (a4 : F) - (b4 : F) = 0 ∧ (a5 : F) - (b5 : F) = 0 ∧ + (a6 : F) - (b6 : F) = 0 ∧ (a7 : F) - (b7 : F) = 0) ↔ + pack a0 a1 a2 a3 a4 a5 a6 a7 = pack b0 b1 b2 b3 b4 b5 b6 b7 := by + rw [byte_sub_eq_zero_iff large ha0 hb0, + byte_sub_eq_zero_iff large ha1 hb1, + byte_sub_eq_zero_iff large ha2 hb2, + byte_sub_eq_zero_iff large ha3 hb3, + byte_sub_eq_zero_iff large ha4 hb4, + byte_sub_eq_zero_iff large ha5 hb5, + byte_sub_eq_zero_iff large ha6 hb6, + byte_sub_eq_zero_iff large ha7 hb7] + exact (pack_inj ha0 ha1 ha2 ha3 ha4 ha5 ha6 ha7 hb0 hb1 hb2 hb3 hb4 hb5 hb6 hb7).symm + +/-! ### 3. `add` -/ + +theorem split_sum_recover (large : Compatible F) (sum : Nat) : + let byte := sum % 256 + (((sum : F) - ((byte : Nat) : F)) / (256 : F)) = (((sum / 256 : Nat) : F)) := + Carry.recover 256 sum (radix_ne_zero large) + +theorem split_sum_step {sum s c : Nat} + (hs : s = sum % 256) (hc : c = sum / 256) : + sum = s + 256 * c ∧ s < 256 := by + subst hs; subst hc + exact ⟨(Nat.mod_add_div sum 256).symm, Nat.mod_lt sum (by omega)⟩ + +theorem add_sound + {a0 a1 a2 a3 a4 a5 a6 a7 b0 b1 b2 b3 b4 b5 b6 b7 : Nat} + {s0 s1 s2 s3 s4 s5 s6 s7 c1 c2 c3 c4 c5 c6 c7 c8 : Nat} + (ha0 : a0 < 256) (ha1 : a1 < 256) (ha2 : a2 < 256) (ha3 : a3 < 256) + (ha4 : a4 < 256) (ha5 : a5 < 256) (ha6 : a6 < 256) (ha7 : a7 < 256) + (hb0 : b0 < 256) (hb1 : b1 < 256) (hb2 : b2 < 256) (hb3 : b3 < 256) + (hb4 : b4 < 256) (hb5 : b5 < 256) (hb6 : b6 < 256) (hb7 : b7 < 256) + (hs0 : s0 < 256) (hs1 : s1 < 256) (hs2 : s2 < 256) (hs3 : s3 < 256) + (hs4 : s4 < 256) (hs5 : s5 < 256) (hs6 : s6 < 256) (hs7 : s7 < 256) + (h0 : a0 + b0 = s0 + 256 * c1) + (h1 : a1 + b1 + c1 = s1 + 256 * c2) + (h2 : a2 + b2 + c2 = s2 + 256 * c3) + (h3 : a3 + b3 + c3 = s3 + 256 * c4) + (h4 : a4 + b4 + c4 = s4 + 256 * c5) + (h5 : a5 + b5 + c5 = s5 + 256 * c6) + (h6 : a6 + b6 + c6 = s6 + 256 * c7) + (h7 : a7 + b7 + c7 = s7 + 256 * c8) : + pack s0 s1 s2 s3 s4 s5 s6 s7 = + (pack a0 a1 a2 a3 a4 a5 a6 a7 + pack b0 b1 b2 b3 b4 b5 b6 b7) % base ∧ + c8 = (pack a0 a1 a2 a3 a4 a5 a6 a7 + pack b0 b1 b2 b3 b4 b5 b6 b7) / base ∧ + c8 < 2 := by + have hpack : pack a0 a1 a2 a3 a4 a5 a6 a7 + pack b0 b1 b2 b3 b4 b5 b6 b7 = + pack s0 s1 s2 s3 s4 s5 s6 s7 + base * c8 := by + unfold pack base + omega + have hs_lt : pack s0 s1 s2 s3 s4 s5 s6 s7 < base := + pack_lt hs0 hs1 hs2 hs3 hs4 hs5 hs6 hs7 + have ha_lt : pack a0 a1 a2 a3 a4 a5 a6 a7 < base := + pack_lt ha0 ha1 ha2 ha3 ha4 ha5 ha6 ha7 + have hb_lt : pack b0 b1 b2 b3 b4 b5 b6 b7 < base := + pack_lt hb0 hb1 hb2 hb3 hb4 hb5 hb6 hb7 + have hc8_lt : c8 < 2 := by omega + refine ⟨?_, ?_, hc8_lt⟩ + · rw [hpack, Nat.add_mul_mod_self_left, Nat.mod_eq_of_lt hs_lt] + · rw [hpack, Nat.add_mul_div_left _ _ (by unfold base; omega), + Nat.div_eq_of_lt hs_lt, Nat.zero_add] + +/-! ### 4. `wrapping_succ` -/ + +def wrappingSuccBytes (b0 b1 b2 b3 b4 b5 b6 b7 : Nat) : + Nat × Nat × Nat × Nat × Nat × Nat × Nat × Nat := + if b0 = 255 then + if b1 = 255 then + if b2 = 255 then + if b3 = 255 then + if b4 = 255 then + if b5 = 255 then + if b6 = 255 then + if b7 = 255 then (0, 0, 0, 0, 0, 0, 0, 0) + else (0, 0, 0, 0, 0, 0, 0, b7 + 1) + else (0, 0, 0, 0, 0, 0, b6 + 1, b7) + else (0, 0, 0, 0, 0, b5 + 1, b6, b7) + else (0, 0, 0, 0, b4 + 1, b5, b6, b7) + else (0, 0, 0, b3 + 1, b4, b5, b6, b7) + else (0, 0, b2 + 1, b3, b4, b5, b6, b7) + else (0, b1 + 1, b2, b3, b4, b5, b6, b7) + else (b0 + 1, b1, b2, b3, b4, b5, b6, b7) + +theorem wrapping_succ_sound {b0 b1 b2 b3 b4 b5 b6 b7 : Nat} + (h0 : b0 < 256) (h1 : b1 < 256) (h2 : b2 < 256) (h3 : b3 < 256) + (h4 : b4 < 256) (h5 : b5 < 256) (h6 : b6 < 256) (h7 : b7 < 256) : + let (r0, r1, r2, r3, r4, r5, r6, r7) := wrappingSuccBytes b0 b1 b2 b3 b4 b5 b6 b7 + r0 < 256 ∧ r1 < 256 ∧ r2 < 256 ∧ r3 < 256 ∧ + r4 < 256 ∧ r5 < 256 ∧ r6 < 256 ∧ r7 < 256 ∧ + pack r0 r1 r2 r3 r4 r5 r6 r7 = (pack b0 b1 b2 b3 b4 b5 b6 b7 + 1) % base := by + unfold wrappingSuccBytes + split_ifs with hb0 hb1 hb2 hb3 hb4 hb5 hb6 hb7 + · subst_vars; decide + all_goals + subst_vars + dsimp only + refine ⟨by omega, by omega, by omega, by omega, by omega, by omega, by omega, by omega, ?_⟩ + rw [Nat.mod_eq_of_lt (by unfold pack base; omega)] + unfold pack + omega + +theorem wrapping_succ_bytes_sound {b0 b1 b2 b3 b4 b5 b6 b7 : Nat} + (h0 : b0 < 256) (h1 : b1 < 256) (h2 : b2 < 256) (h3 : b3 < 256) + (h4 : b4 < 256) (h5 : b5 < 256) (h6 : b6 < 256) (h7 : b7 < 256) : + let (r0, r1, r2, r3, r4, r5, r6, r7) := wrappingSuccBytes b0 b1 b2 b3 b4 b5 b6 b7 + r0 < 256 ∧ r1 < 256 ∧ r2 < 256 ∧ r3 < 256 ∧ + r4 < 256 ∧ r5 < 256 ∧ r6 < 256 ∧ r7 < 256 ∧ + pack r0 r1 r2 r3 r4 r5 r6 r7 = (pack b0 b1 b2 b3 b4 b5 b6 b7 + 1) % base := + wrapping_succ_sound h0 h1 h2 h3 h4 h5 h6 h7 + +/-! ### 5. `saturating_pred` -/ + +def saturatingPredBytes (b0 b1 b2 b3 b4 b5 b6 b7 : Nat) : + Nat × Nat × Nat × Nat × Nat × Nat × Nat × Nat := + if b0 = 0 then + if b1 = 0 then + if b2 = 0 then + if b3 = 0 then + if b4 = 0 then + if b5 = 0 then + if b6 = 0 then + if b7 = 0 then (0, 0, 0, 0, 0, 0, 0, 0) + else (255, 255, 255, 255, 255, 255, 255, b7 - 1) + else (255, 255, 255, 255, 255, 255, b6 - 1, b7) + else (255, 255, 255, 255, 255, b5 - 1, b6, b7) + else (255, 255, 255, 255, b4 - 1, b5, b6, b7) + else (255, 255, 255, b3 - 1, b4, b5, b6, b7) + else (255, 255, b2 - 1, b3, b4, b5, b6, b7) + else (255, b1 - 1, b2, b3, b4, b5, b6, b7) + else (b0 - 1, b1, b2, b3, b4, b5, b6, b7) + +theorem saturating_pred_sound {b0 b1 b2 b3 b4 b5 b6 b7 : Nat} + (h0 : b0 < 256) (h1 : b1 < 256) (h2 : b2 < 256) (h3 : b3 < 256) + (h4 : b4 < 256) (h5 : b5 < 256) (h6 : b6 < 256) (h7 : b7 < 256) : + let (r0, r1, r2, r3, r4, r5, r6, r7) := saturatingPredBytes b0 b1 b2 b3 b4 b5 b6 b7 + r0 < 256 ∧ r1 < 256 ∧ r2 < 256 ∧ r3 < 256 ∧ + r4 < 256 ∧ r5 < 256 ∧ r6 < 256 ∧ r7 < 256 ∧ + pack r0 r1 r2 r3 r4 r5 r6 r7 = pack b0 b1 b2 b3 b4 b5 b6 b7 - 1 := by + unfold saturatingPredBytes + split_ifs <;> + (subst_vars; dsimp only; + refine ⟨by omega, by omega, by omega, by omega, by omega, by omega, by omega, by omega, ?_⟩; + unfold pack; omega) + +/-! ### 6. `to_field` -/ + +theorem top_byte_zero_iff (large : Compatible F) {b0 b1 b2 b3 b4 b5 b6 b7 : Nat} + (h0 : b0 < 256) (h1 : b1 < 256) (h2 : b2 < 256) (h3 : b3 < 256) + (h4 : b4 < 256) (h5 : b5 < 256) (h6 : b6 < 256) (h7 : b7 < 256) : + (b7 : F) = 0 ↔ pack b0 b1 b2 b3 b4 b5 b6 b7 < fieldBound := by + rw [byte_eq_zero_iff large h7, pack_eq_pack56_add] + have h56 := pack56_lt h0 h1 h2 h3 h4 h5 h6 + unfold fieldBound at * + omega + +theorem to_field_sound (large : Compatible F) {b0 b1 b2 b3 b4 b5 b6 b7 : Nat} + (h0 : b0 < 256) (h1 : b1 < 256) (h2 : b2 < 256) (h3 : b3 < 256) + (h4 : b4 < 256) (h5 : b5 < 256) (h6 : b6 < 256) (h7 : b7 < 256) + (topZero : (b7 : F) = 0) : + pack b0 b1 b2 b3 b4 b5 b6 b7 < fieldBound ∧ + (b0 : F) + 256 * (b1 : F) + 65536 * (b2 : F) + 16777216 * (b3 : F) + + 4294967296 * (b4 : F) + 1099511627776 * (b5 : F) + 281474976710656 * (b6 : F) = + ((pack b0 b1 b2 b3 b4 b5 b6 b7 : Nat) : F) := by + have hb7 : b7 = 0 := byte_cast_inj large h7 (by omega) (by simpa using topZero) + refine ⟨(top_byte_zero_iff large h0 h1 h2 h3 h4 h5 h6 h7).mp topZero, ?_⟩ + subst hb7 + unfold pack + push_cast + ring + +/-! ### 7. `sub_with_borrow` -/ + +theorem sub_with_borrow_sound + {a0 a1 a2 a3 a4 a5 a6 a7 b0 b1 b2 b3 b4 b5 b6 b7 : Nat} + {s0 s1 s2 s3 s4 s5 s6 s7 c1 c2 c3 c4 c5 c6 c7 c8 : Nat} + (ha0 : a0 < 256) (ha1 : a1 < 256) (ha2 : a2 < 256) (ha3 : a3 < 256) + (ha4 : a4 < 256) (ha5 : a5 < 256) (ha6 : a6 < 256) (ha7 : a7 < 256) + (hb0 : b0 < 256) (hb1 : b1 < 256) (hb2 : b2 < 256) (hb3 : b3 < 256) + (hb4 : b4 < 256) (hb5 : b5 < 256) (hb6 : b6 < 256) (hb7 : b7 < 256) + (hs0 : s0 < 256) (hs1 : s1 < 256) (hs2 : s2 < 256) (hs3 : s3 < 256) + (hs4 : s4 < 256) (hs5 : s5 < 256) (hs6 : s6 < 256) (hs7 : s7 < 256) + (h0 : a0 + 256 - b0 = s0 + 256 * c1) + (h1 : a1 + 255 - b1 + c1 = s1 + 256 * c2) + (h2 : a2 + 255 - b2 + c2 = s2 + 256 * c3) + (h3 : a3 + 255 - b3 + c3 = s3 + 256 * c4) + (h4 : a4 + 255 - b4 + c4 = s4 + 256 * c5) + (h5 : a5 + 255 - b5 + c5 = s5 + 256 * c6) + (h6 : a6 + 255 - b6 + c6 = s6 + 256 * c7) + (h7 : a7 + 255 - b7 + c7 = s7 + 256 * c8) : + pack s0 s1 s2 s3 s4 s5 s6 s7 = + (pack a0 a1 a2 a3 a4 a5 a6 a7 + base - pack b0 b1 b2 b3 b4 b5 b6 b7) % base ∧ + (1 : F) - (c8 : F) = + if pack a0 a1 a2 a3 a4 a5 a6 a7 < pack b0 b1 b2 b3 b4 b5 b6 b7 then 1 else 0 := by + have hs_lt : pack s0 s1 s2 s3 s4 s5 s6 s7 < base := + pack_lt hs0 hs1 hs2 hs3 hs4 hs5 hs6 hs7 + have ha_lt : pack a0 a1 a2 a3 a4 a5 a6 a7 < base := + pack_lt ha0 ha1 ha2 ha3 ha4 ha5 ha6 ha7 + have hb_lt : pack b0 b1 b2 b3 b4 b5 b6 b7 < base := + pack_lt hb0 hb1 hb2 hb3 hb4 hb5 hb6 hb7 + have h0' : a0 + 256 = b0 + s0 + 256 * c1 := by omega + have h1' : a1 + 255 + c1 = b1 + s1 + 256 * c2 := by omega + have h2' : a2 + 255 + c2 = b2 + s2 + 256 * c3 := by omega + have h3' : a3 + 255 + c3 = b3 + s3 + 256 * c4 := by omega + have h4' : a4 + 255 + c4 = b4 + s4 + 256 * c5 := by omega + have h5' : a5 + 255 + c5 = b5 + s5 + 256 * c6 := by omega + have h6' : a6 + 255 + c6 = b6 + s6 + 256 * c7 := by omega + have h7' : a7 + 255 + c7 = b7 + s7 + 256 * c8 := by omega + have hadd : pack a0 a1 a2 a3 a4 a5 a6 a7 + base = + pack b0 b1 b2 b3 b4 b5 b6 b7 + (pack s0 s1 s2 s3 s4 s5 s6 s7 + base * c8) := by + unfold pack base + omega + have hsum : pack a0 a1 a2 a3 a4 a5 a6 a7 + base - pack b0 b1 b2 b3 b4 b5 b6 b7 = + pack s0 s1 s2 s3 s4 s5 s6 s7 + base * c8 := by + omega + have hc8_lt : c8 < 2 := by + have : base * c8 < base * 2 := by unfold base at *; omega + exact Nat.lt_of_mul_lt_mul_left this + constructor + · rw [hsum, Nat.add_mul_mod_self_left, Nat.mod_eq_of_lt hs_lt] + · split_ifs with hlt + · have hc8 : c8 = 0 := by + rcases (by omega : c8 = 0 ∨ c8 = 1) with rfl | rfl + · rfl + · omega + simp [hc8] + · have hc8 : c8 = 1 := by + rcases (by omega : c8 = 0 ∨ c8 = 1) with rfl | rfl + · omega + · rfl + simp [hc8] + +/-! ### 8. `mul` and `mul_column` -/ + +theorem mul_column_sound (large : Compatible F) {val r0 r1 c0 c1 c2 : Nat} + (hval : val < fieldBound) + (hr0 : r0 < 256) (hr1 : r1 < 256) + (hc0 : c0 < 256) (hc1 : c1 < 256) (hc2 : c2 < 256) + (equal : (val : F) = (r0 : F) + 256 * (r1 : F) + + 65536 * ((c0 : F) + 256 * (c1 : F) + 65536 * (c2 : F))) : + val = limb2 r0 r1 + 65536 * carry3 c0 c1 c2 ∧ + limb2 r0 r1 = val % 65536 ∧ + carry3 c0 c1 c2 = val / 65536 := by + have hbound : limb2 r0 r1 + 65536 * carry3 c0 c1 c2 < fieldBound := by + unfold limb2 carry3 fieldBound + omega + have hlifted : val = limb2 r0 r1 + 65536 * carry3 c0 c1 c2 := by + apply natCast_inj large hval hbound + unfold limb2 carry3 + push_cast + linear_combination equal + have hlimb : limb2 r0 r1 < 65536 := limb2_lt hr0 hr1 + refine ⟨hlifted, ?_, ?_⟩ + · rw [hlifted, Nat.add_mul_mod_self_left, Nat.mod_eq_of_lt hlimb] + · rw [hlifted, Nat.add_mul_div_left _ _ (by omega), Nat.div_eq_of_lt hlimb, Nat.zero_add] + +theorem mul_sound + {a0 a1 a2 a3 a4 a5 a6 a7 b0 b1 b2 b3 b4 b5 b6 b7 : Nat} + {r00 r01 r10 r11 r20 r21 r30 r31 r40 r41 r50 r51 r60 r61 : Nat} + {c00 c01 c02 c10 c11 c12 c20 c21 c22 c30 c31 c32 c40 c41 c42 c50 c51 c52 c60 c61 c62 : Nat} + (hr00 : r00 < 256) (hr01 : r01 < 256) (hr10 : r10 < 256) (hr11 : r11 < 256) + (hr20 : r20 < 256) (hr21 : r21 < 256) (hr30 : r30 < 256) (hr31 : r31 < 256) + (hr40 : r40 < 256) (hr41 : r41 < 256) (hr50 : r50 < 256) (hr51 : r51 < 256) + (hr60 : r60 < 256) (hr61 : r61 < 256) (hc60 : c60 < 256) (hc61 : c61 < 256) + (col0 : limb2 a0 a1 * limb2 b0 b1 = limb2 r00 r01 + 65536 * carry3 c00 c01 c02) + (col1 : limb2 a0 a1 * limb2 b2 b3 + limb2 a2 a3 * limb2 b0 b1 + carry3 c00 c01 c02 = + limb2 r10 r11 + 65536 * carry3 c10 c11 c12) + (col2 : limb2 a0 a1 * limb2 b4 b5 + limb2 a2 a3 * limb2 b2 b3 + limb2 a4 a5 * limb2 b0 b1 + + carry3 c10 c11 c12 = limb2 r20 r21 + 65536 * carry3 c20 c21 c22) + (col3 : limb2 a0 a1 * limb2 b6 b7 + limb2 a2 a3 * limb2 b4 b5 + limb2 a4 a5 * limb2 b2 b3 + + limb2 a6 a7 * limb2 b0 b1 + carry3 c20 c21 c22 = + limb2 r30 r31 + 65536 * carry3 c30 c31 c32) + (col4 : limb2 a2 a3 * limb2 b6 b7 + limb2 a4 a5 * limb2 b4 b5 + limb2 a6 a7 * limb2 b2 b3 + + carry3 c30 c31 c32 = limb2 r40 r41 + 65536 * carry3 c40 c41 c42) + (col5 : limb2 a4 a5 * limb2 b6 b7 + limb2 a6 a7 * limb2 b4 b5 + carry3 c40 c41 c42 = + limb2 r50 r51 + 65536 * carry3 c50 c51 c52) + (col6 : limb2 a6 a7 * limb2 b6 b7 + carry3 c50 c51 c52 = + limb2 r60 r61 + 65536 * carry3 c60 c61 c62) + (hc62 : c62 = 0) : + let a := pack a0 a1 a2 a3 a4 a5 a6 a7 + let b := pack b0 b1 b2 b3 b4 b5 b6 b7 + let lo := pack r00 r01 r10 r11 r20 r21 r30 r31 + let hi := pack r40 r41 r50 r51 r60 r61 c60 c61 + a * b = lo + base * hi ∧ + lo = (a * b) % base ∧ + hi = (a * b) / base ∧ + hi < base := by + dsimp only + have hlo_lt : pack r00 r01 r10 r11 r20 r21 r30 r31 < base := + pack_lt hr00 hr01 hr10 hr11 hr20 hr21 hr30 hr31 + have hhi_lt : pack r40 r41 r50 r51 r60 r61 c60 c61 < base := + pack_lt hr40 hr41 hr50 hr51 hr60 hr61 hc60 hc61 + have hprod : pack a0 a1 a2 a3 a4 a5 a6 a7 * pack b0 b1 b2 b3 b4 b5 b6 b7 = + pack r00 r01 r10 r11 r20 r21 r30 r31 + + base * pack r40 r41 r50 r51 r60 r61 c60 c61 := by + subst hc62 + have h0' : (limb2 a0 a1 : Int) * limb2 b0 b1 = limb2 r00 r01 + 65536 * carry3 c00 c01 c02 := by exact_mod_cast col0 + have h1' : (limb2 a0 a1 : Int) * limb2 b2 b3 + limb2 a2 a3 * limb2 b0 b1 + carry3 c00 c01 c02 = + limb2 r10 r11 + 65536 * carry3 c10 c11 c12 := by exact_mod_cast col1 + have h2' : (limb2 a0 a1 : Int) * limb2 b4 b5 + limb2 a2 a3 * limb2 b2 b3 + limb2 a4 a5 * limb2 b0 b1 + + carry3 c10 c11 c12 = limb2 r20 r21 + 65536 * carry3 c20 c21 c22 := by exact_mod_cast col2 + have h3' : (limb2 a0 a1 : Int) * limb2 b6 b7 + limb2 a2 a3 * limb2 b4 b5 + limb2 a4 a5 * limb2 b2 b3 + + limb2 a6 a7 * limb2 b0 b1 + carry3 c20 c21 c22 = + limb2 r30 r31 + 65536 * carry3 c30 c31 c32 := by exact_mod_cast col3 + have h4' : (limb2 a2 a3 : Int) * limb2 b6 b7 + limb2 a4 a5 * limb2 b4 b5 + limb2 a6 a7 * limb2 b2 b3 + + carry3 c30 c31 c32 = limb2 r40 r41 + 65536 * carry3 c40 c41 c42 := by exact_mod_cast col4 + have h5' : (limb2 a4 a5 : Int) * limb2 b6 b7 + limb2 a6 a7 * limb2 b4 b5 + carry3 c40 c41 c42 = + limb2 r50 r51 + 65536 * carry3 c50 c51 c52 := by exact_mod_cast col5 + have h6' : (limb2 a6 a7 : Int) * limb2 b6 b7 + carry3 c50 c51 c52 = + limb2 r60 r61 + 65536 * carry3 c60 c61 0 := by exact_mod_cast col6 + have hint : (pack a0 a1 a2 a3 a4 a5 a6 a7 : Int) * pack b0 b1 b2 b3 b4 b5 b6 b7 = + pack r00 r01 r10 r11 r20 r21 r30 r31 + + base * pack r40 r41 r50 r51 r60 r61 c60 c61 := by + unfold pack limb2 carry3 base at * + push_cast at * + linear_combination + h0' + 65536 * h1' + 4294967296 * h2' + 281474976710656 * h3' + + 18446744073709551616 * h4' + 1208925819614629174706176 * h5' + + 79228162514264337593543950336 * h6' + exact_mod_cast hint + refine ⟨hprod, ?_, ?_, hhi_lt⟩ + · rw [hprod, Nat.add_mul_mod_self_left, Nat.mod_eq_of_lt hlo_lt] + · rw [hprod, Nat.add_mul_div_left _ _ (by unfold base; omega), + Nat.div_eq_of_lt hlo_lt, Nat.zero_add] + +/-! ### 9, 10, 11. `and`, `or`, `xor` -/ + +theorem bitwise_zero_left {f : Bool → Bool → Bool} (_hff : f false false = false) (y : Nat) : + Nat.bitwise f 0 y = if f false true then y else 0 := by + rw [Nat.bitwise] + simp + +theorem bitwise_zero_right {f : Bool → Bool → Bool} (_hff : f false false = false) (x : Nat) : + Nat.bitwise f x 0 = if f true false then x else 0 := by + rcases eq_or_ne x 0 with rfl | hx + · rw [Nat.bitwise]; simp + · rw [Nat.bitwise]; simp [hx] + +theorem bitwise_zero_zero {f : Bool → Bool → Bool} (_hff : f false false = false) : + Nat.bitwise f 0 0 = 0 := by + rw [Nat.bitwise]; simp + +theorem bitwise_bit {f : Bool → Bool → Bool} (hff : f false false = false) + {a b : Nat} (ha : a < 2) (hb : b < 2) : + Nat.bitwise f a b = if f (decide (a = 1)) (decide (b = 1)) then 1 else 0 := by + rcases (by omega : a = 0 ∨ a = 1) with rfl | rfl <;> + rcases (by omega : b = 0 ∨ b = 1) with rfl | rfl + · simp [bitwise_zero_zero hff, hff] + · simp [bitwise_zero_left hff] + · simp [bitwise_zero_right hff] + · rw [Nat.bitwise]; dsimp only; simp [bitwise_zero_zero hff] + +theorem bitwise_add_mul_two {f : Bool → Bool → Bool} (hff : f false false = false) + {a b : Nat} (ha : a < 2) (hb : b < 2) (x y : Nat) : + Nat.bitwise f (a + 2 * x) (b + 2 * y) = Nat.bitwise f a b + 2 * Nat.bitwise f x y := by + rw [bitwise_bit hff ha hb] + rcases eq_or_ne (a + 2 * x) 0 with hax | hax + · have ha0 : a = 0 := by omega + have hx0 : x = 0 := by omega + subst ha0; subst hx0 + rw [hax, bitwise_zero_left hff, bitwise_zero_left hff] + rcases (by omega : b = 0 ∨ b = 1) with rfl | rfl + · simp [hff] + · simp; split_ifs <;> omega + · rcases eq_or_ne (b + 2 * y) 0 with hby | hby + · have hb0 : b = 0 := by omega + have hy0 : y = 0 := by omega + subst hb0; subst hy0 + rw [hby, bitwise_zero_right hff, bitwise_zero_right hff] + rcases (by omega : a = 0 ∨ a = 1) with rfl | rfl + · simp [hff] + · simp; split_ifs <;> omega + · conv_lhs => rw [Nat.bitwise] + dsimp only + have hdivx : (a + 2 * x) / 2 = x := by omega + have hdivy : (b + 2 * y) / 2 = y := by omega + have hmodx : ((a + 2 * x) % 2 = 1) ↔ (a = 1) := by omega + have hmody : ((b + 2 * y) % 2 = 1) ↔ (b = 1) := by omega + have hdecx : decide ((a + 2 * x) % 2 = 1) = decide (a = 1) := decide_eq_decide.mpr hmodx + have hdecy : decide ((b + 2 * y) % 2 = 1) = decide (b = 1) := decide_eq_decide.mpr hmody + simp only [hax, hby, ↓reduceIte, hdivx, hdivy, hdecx, hdecy] + split_ifs <;> omega + +theorem bitwise_add_mul_two_pow {f : Bool → Bool → Bool} (hff : f false false = false) + (k : Nat) : ∀ {a b : Nat}, a < 2^k → b < 2^k → ∀ (x y : Nat), + Nat.bitwise f (a + 2^k * x) (b + 2^k * y) = Nat.bitwise f a b + 2^k * Nat.bitwise f x y := by + induction k with + | zero => + intro a b ha hb x y + have ha0 : a = 0 := by omega + have hb0 : b = 0 := by omega + subst ha0; subst hb0 + simp [bitwise_zero_zero hff] + | succ k ih => + intro a b ha hb x y + have hmad_a : a % 2 + 2 * (a / 2) = a := Nat.mod_add_div a 2 + have hmad_b : b % 2 + 2 * (b / 2) = b := Nat.mod_add_div b 2 + have ha' : a % 2 + 2 * (a / 2 + 2^k * x) = a + 2^(k + 1) * x := by + calc a % 2 + 2 * (a / 2 + 2^k * x) + _ = (a % 2 + 2 * (a / 2)) + 2^k * 2 * x := by ring + _ = a + 2^(k + 1) * x := by rw [hmad_a, Nat.pow_succ] + have hb' : b % 2 + 2 * (b / 2 + 2^k * y) = b + 2^(k + 1) * y := by + calc b % 2 + 2 * (b / 2 + 2^k * y) + _ = (b % 2 + 2 * (b / 2)) + 2^k * 2 * y := by ring + _ = b + 2^(k + 1) * y := by rw [hmad_b, Nat.pow_succ] + have ha_div : a / 2 < 2^k := by + rw [Nat.div_lt_iff_lt_mul (by omega)]; rw [Nat.pow_succ] at ha; omega + have hb_div : b / 2 < 2^k := by + rw [Nat.div_lt_iff_lt_mul (by omega)]; rw [Nat.pow_succ] at hb; omega + have h1 := bitwise_add_mul_two hff (a := a % 2) (b := b % 2) (by omega) (by omega) + (a / 2 + 2^k * x) (b / 2 + 2^k * y) + have h2 := ih ha_div hb_div x y + have h3 := bitwise_add_mul_two hff (a := a % 2) (b := b % 2) (by omega) (by omega) (a / 2) (b / 2) + rw [hmad_a, hmad_b] at h3 + rw [← ha', ← hb', h1, h2, h3, Nat.pow_succ] + ring + +theorem bitwise_lt_two_pow {f : Bool → Bool → Bool} (hff : f false false = false) : + ∀ (k : Nat) {a b : Nat}, a < 2^k → b < 2^k → Nat.bitwise f a b < 2^k := by + intro k a b ha hb + induction k generalizing a b with + | zero => + have ha0 : a = 0 := by omega + have hb0 : b = 0 := by omega + subst ha0; subst hb0; simp [bitwise_zero_zero hff] + | succ k ih => + have ha_div : a / 2 < 2^k := by + rw [Nat.div_lt_iff_lt_mul (by omega)]; rw [Nat.pow_succ] at ha; omega + have hb_div : b / 2 < 2^k := by + rw [Nat.div_lt_iff_lt_mul (by omega)]; rw [Nat.pow_succ] at hb; omega + have h3 := bitwise_add_mul_two hff (a := a % 2) (b := b % 2) (by omega) (by omega) (a / 2) (b / 2) + rw [Nat.mod_add_div, Nat.mod_add_div] at h3 + have hrec := ih ha_div hb_div + have hmod : Nat.bitwise f (a % 2) (b % 2) < 2 := by + rw [bitwise_bit hff (by omega) (by omega)] + split_ifs <;> omega + rw [h3, Nat.pow_succ] + omega + +theorem bitwise_pack {f : Bool → Bool → Bool} (hff : f false false = false) + {a0 a1 a2 a3 a4 a5 a6 a7 b0 b1 b2 b3 b4 b5 b6 b7 : Nat} + (ha0 : a0 < 256) (ha1 : a1 < 256) (ha2 : a2 < 256) (ha3 : a3 < 256) + (ha4 : a4 < 256) (ha5 : a5 < 256) (ha6 : a6 < 256) (_ha7 : a7 < 256) + (hb0 : b0 < 256) (hb1 : b1 < 256) (hb2 : b2 < 256) (hb3 : b3 < 256) + (hb4 : b4 < 256) (hb5 : b5 < 256) (hb6 : b6 < 256) (_hb7 : b7 < 256) : + pack (Nat.bitwise f a0 b0) (Nat.bitwise f a1 b1) (Nat.bitwise f a2 b2) (Nat.bitwise f a3 b3) + (Nat.bitwise f a4 b4) (Nat.bitwise f a5 b5) (Nat.bitwise f a6 b6) (Nat.bitwise f a7 b7) = + Nat.bitwise f (pack a0 a1 a2 a3 a4 a5 a6 a7) (pack b0 b1 b2 b3 b4 b5 b6 b7) := by + have step : ∀ {x y : Nat}, x < 256 → y < 256 → ∀ u v : Nat, + Nat.bitwise f (x + 256 * u) (y + 256 * v) = Nat.bitwise f x y + 256 * Nat.bitwise f u v := by + intro x y hx hy u v + simpa using bitwise_add_mul_two_pow hff 8 (by simpa using hx) (by simpa using hy) u v + have hrew : ∀ x0 x1 x2 x3 x4 x5 x6 x7 : Nat, + pack x0 x1 x2 x3 x4 x5 x6 x7 = + x0 + 256 * (x1 + 256 * (x2 + 256 * (x3 + 256 * (x4 + 256 * (x5 + 256 * (x6 + 256 * x7)))))) := by + intros; unfold pack; ring + rw [hrew a0, hrew b0, hrew (Nat.bitwise f a0 b0)] + rw [step ha0 hb0, step ha1 hb1, step ha2 hb2, step ha3 hb3, + step ha4 hb4, step ha5 hb5, step ha6 hb6] + +theorem and_sound (large : Compatible F) + {a0 a1 a2 a3 a4 a5 a6 a7 b0 b1 b2 b3 b4 b5 b6 b7 : Nat} + (ha0 : a0 < 256) (ha1 : a1 < 256) (ha2 : a2 < 256) (ha3 : a3 < 256) + (ha4 : a4 < 256) (ha5 : a5 < 256) (ha6 : a6 < 256) (ha7 : a7 < 256) + (hb0 : b0 < 256) (hb1 : b1 < 256) (hb2 : b2 < 256) (hb3 : b3 < 256) + (hb4 : b4 < 256) (hb5 : b5 < 256) (hb6 : b6 < 256) (hb7 : b7 < 256) : + ((a0 : F) + (b0 : F) - ((Nat.xor a0 b0 : Nat) : F)) / 2 = ((Nat.land a0 b0 : Nat) : F) ∧ + pack (Nat.land a0 b0) (Nat.land a1 b1) (Nat.land a2 b2) (Nat.land a3 b3) + (Nat.land a4 b4) (Nat.land a5 b5) (Nat.land a6 b6) (Nat.land a7 b7) = + Nat.land (pack a0 a1 a2 a3 a4 a5 a6 a7) (pack b0 b1 b2 b3 b4 b5 b6 b7) := by + constructor + · have h := U8.and_field (two_ne_zero large) (BitVec.ofNat 8 a0) (BitVec.ofNat 8 b0) + simpa [BitVec.toNat_ofNat, Nat.mod_eq_of_lt ha0, Nat.mod_eq_of_lt hb0] using h + · exact bitwise_pack rfl ha0 ha1 ha2 ha3 ha4 ha5 ha6 ha7 hb0 hb1 hb2 hb3 hb4 hb5 hb6 hb7 + +theorem or_sound (large : Compatible F) + {a0 a1 a2 a3 a4 a5 a6 a7 b0 b1 b2 b3 b4 b5 b6 b7 : Nat} + (ha0 : a0 < 256) (ha1 : a1 < 256) (ha2 : a2 < 256) (ha3 : a3 < 256) + (ha4 : a4 < 256) (ha5 : a5 < 256) (ha6 : a6 < 256) (ha7 : a7 < 256) + (hb0 : b0 < 256) (hb1 : b1 < 256) (hb2 : b2 < 256) (hb3 : b3 < 256) + (hb4 : b4 < 256) (hb5 : b5 < 256) (hb6 : b6 < 256) (hb7 : b7 < 256) : + ((a0 : F) + (b0 : F) + ((Nat.xor a0 b0 : Nat) : F)) / 2 = ((Nat.lor a0 b0 : Nat) : F) ∧ + pack (Nat.lor a0 b0) (Nat.lor a1 b1) (Nat.lor a2 b2) (Nat.lor a3 b3) + (Nat.lor a4 b4) (Nat.lor a5 b5) (Nat.lor a6 b6) (Nat.lor a7 b7) = + Nat.lor (pack a0 a1 a2 a3 a4 a5 a6 a7) (pack b0 b1 b2 b3 b4 b5 b6 b7) := by + constructor + · have h := U8.or_field (two_ne_zero large) (BitVec.ofNat 8 a0) (BitVec.ofNat 8 b0) + simpa [BitVec.toNat_ofNat, Nat.mod_eq_of_lt ha0, Nat.mod_eq_of_lt hb0] using h + · exact bitwise_pack rfl ha0 ha1 ha2 ha3 ha4 ha5 ha6 ha7 hb0 hb1 hb2 hb3 hb4 hb5 hb6 hb7 + +theorem xor_sound + {a0 a1 a2 a3 a4 a5 a6 a7 b0 b1 b2 b3 b4 b5 b6 b7 : Nat} + (ha0 : a0 < 256) (ha1 : a1 < 256) (ha2 : a2 < 256) (ha3 : a3 < 256) + (ha4 : a4 < 256) (ha5 : a5 < 256) (ha6 : a6 < 256) (ha7 : a7 < 256) + (hb0 : b0 < 256) (hb1 : b1 < 256) (hb2 : b2 < 256) (hb3 : b3 < 256) + (hb4 : b4 < 256) (hb5 : b5 < 256) (hb6 : b6 < 256) (hb7 : b7 < 256) : + pack (Nat.xor a0 b0) (Nat.xor a1 b1) (Nat.xor a2 b2) (Nat.xor a3 b3) + (Nat.xor a4 b4) (Nat.xor a5 b5) (Nat.xor a6 b6) (Nat.xor a7 b7) = + Nat.xor (pack a0 a1 a2 a3 a4 a5 a6 a7) (pack b0 b1 b2 b3 b4 b5 b6 b7) := + bitwise_pack rfl ha0 ha1 ha2 ha3 ha4 ha5 ha6 ha7 hb0 hb1 hb2 hb3 hb4 hb5 hb6 hb7 + +/-! ### 12. `from_field` -/ + +theorem from_field_sound (large : Compatible F) {value : F} + {b0 b1 b2 b3 b4 b5 b6 b7 : Nat} + (h0 : b0 < 256) (h1 : b1 < 256) (h2 : b2 < 256) (h3 : b3 < 256) + (h4 : b4 < 256) (h5 : b5 < 256) (h6 : b6 < 256) (h7 : b7 < 256) + (topZero : (b7 : F) = 0) + (recomposed : (b0 : F) + 256 * (b1 : F) + 65536 * (b2 : F) + 16777216 * (b3 : F) + + 4294967296 * (b4 : F) + 1099511627776 * (b5 : F) + 281474976710656 * (b6 : F) = value) : + b7 = 0 ∧ + pack b0 b1 b2 b3 b4 b5 b6 b7 < fieldBound ∧ + ((pack b0 b1 b2 b3 b4 b5 b6 b7 : Nat) : F) = value := by + have hb7 : b7 = 0 := byte_cast_inj large h7 (by omega) (by simpa using topZero) + obtain ⟨hlt, hcast⟩ := to_field_sound large h0 h1 h2 h3 h4 h5 h6 h7 topZero + exact ⟨hb7, hlt, hcast.symm.trans recomposed⟩ + +theorem from_field_unique (large : Compatible F) {n : Nat} (hn : n < fieldBound) + {b0 b1 b2 b3 b4 b5 b6 b7 : Nat} + (h0 : b0 < 256) (h1 : b1 < 256) (h2 : b2 < 256) (h3 : b3 < 256) + (h4 : b4 < 256) (h5 : b5 < 256) (h6 : b6 < 256) (h7 : b7 < 256) + (topZero : (b7 : F) = 0) + (recomposed : (b0 : F) + 256 * (b1 : F) + 65536 * (b2 : F) + 16777216 * (b3 : F) + + 4294967296 * (b4 : F) + 1099511627776 * (b5 : F) + 281474976710656 * (b6 : F) = (n : F)) : + pack b0 b1 b2 b3 b4 b5 b6 b7 = n := by + obtain ⟨_, hlt, hcast⟩ := from_field_sound large h0 h1 h2 h3 h4 h5 h6 h7 topZero recomposed + exact natCast_inj large hlt hn hcast + +end Aiur.Library.U64 diff --git a/Aiur/Aiur/Library/U64/Goldilocks.lean b/Aiur/Aiur/Library/U64/Goldilocks.lean new file mode 100644 index 000000000..a9af610f8 --- /dev/null +++ b/Aiur/Aiur/Library/U64/Goldilocks.lean @@ -0,0 +1,20 @@ +import Aiur.Library.U64 +import Aiur.Library.U32.Goldilocks + +/-! Explicit Goldilocks field specialization for the 64-bit word library. +The Goldilocks prime `2^64 - 2^32 + 1` exceeds `2^56`, so natural casts below +`2^56` are injective and `U64.Compatible U32.Goldilocks.F` holds. -/ +namespace Aiur.Library.U64.Goldilocks +open Aiur + +abbrev modulus := U32.Goldilocks.modulus +abbrev F := U32.Goldilocks.F + +theorem compatible : U64.Compatible F := + U64.compatible_of_charP F modulus (by decide) + +def declarations : Modules.Program F := U64.specialize F compatible + +def program : Modules.Program F := U64.source.toField F + +end Aiur.Library.U64.Goldilocks diff --git a/Aiur/Aiur/Library/U64/Hints.lean b/Aiur/Aiur/Library/U64/Hints.lean new file mode 100644 index 000000000..5b531c67f --- /dev/null +++ b/Aiur/Aiur/Library/U64/Hints.lean @@ -0,0 +1,16 @@ +import Aiur.Hints +import Aiur.Library.U64 + +namespace Aiur.Library.U64 + +/-- Optional semantic provider. The library checks the returned raw fields; +this dispatcher cannot construct opaque bytes. -/ +def hints {F : Type} [NatCast F] (toNat : F → Nat) + (fallback : HintDispatcher F := fun _ _ => .error .unavailable) : HintDispatcher F := + fun channel key => match channel, key with + | "bytes_le", .field value => + .ok (.tuple ((List.range 8).map fun i => .field (((toNat value / 256^i) % 256 : Nat) : F))) + | "bytes_le", _ => .error (.message "invalid byte decomposition key") + | _, _ => fallback channel key + +end Aiur.Library.U64 diff --git a/Aiur/Aiur/Library/U8.lean b/Aiur/Aiur/Library/U8.lean new file mode 100644 index 000000000..01636a6d7 --- /dev/null +++ b/Aiur/Aiur/Library/U8.lean @@ -0,0 +1,131 @@ +import Aiur.Modules +import Aiur.Library.Carry +import Aiur.Library.U8.Signature + +/-! Checked byte operations shared by word arithmetic and Blake3. +Raw operations accept fields and check their domain through the same tables +that establish their opaque results. They never reinterpret unchecked fields. +-/ +namespace Aiur.Library.U8 +open Aiur + +def declarations : Modules.Program Nat := aiur% r#" +module UInt8 { + opaque type U8 = Field; + // Only the split tables construct these parts. Joining parts from different + // bytes is safe: their bit positions are disjoint. Keeping them opaque lets + // other modules recombine them without another range lookup. + opaque type Parts4 = (Field, Field); + opaque type Parts7 = (Field, Field); + + table byte_inputs: (Field,) {} + table byte_values: U8 {} + table byte_bits: [Field; 8] {} + table pair_inputs: (Field, Field) {} + table pair_units: () {} + table pair_xors: U8 {} + table pair_adds: (U8, U8) {} + table pair_subs: (U8, U8) {} + table pair_muls: (U8, U8) {} + table pair_xor_parts4: Parts4 {} + table pair_xor_parts7: Parts7 {} + table sum_inputs: (Field,) {} + table sum_bytes: U8 {} + + map from_field(x: Field) -> U8 = byte_inputs => byte_values; + map raw_bit_decomposition(x: Field) -> [Field; 8] = byte_inputs => byte_bits; + map range_pair(a: Field, b: Field) -> () = pair_inputs => pair_units; + map raw_xor(a: Field, b: Field) -> U8 = pair_inputs => pair_xors; + map raw_add(a: Field, b: Field) -> (U8, U8) = pair_inputs => pair_adds; + map raw_sub(a: Field, b: Field) -> (U8, U8) = pair_inputs => pair_subs; + map raw_mul(a: Field, b: Field) -> (U8, U8) = pair_inputs => pair_muls; + map raw_xor_split4(a: Field, b: Field) -> Parts4 = pair_inputs => pair_xor_parts4; + map raw_xor_split7(a: Field, b: Field) -> Parts7 = pair_inputs => pair_xor_parts7; + map raw_sum_byte(sum: Field) -> U8 = sum_inputs => sum_bytes; + + // XOR/subtraction check both raw inputs. These identities reuse their + // fixed-table multiplicities, as in legacy's byte primitives. Division + // by two requires odd characteristic (as does a faithful byte embedding). + inline fn raw_and(a: Field, b: Field) -> U8 { + let x = raw_xor(a, b); + (a + b - x) / 2 + } + inline fn raw_or(a: Field, b: Field) -> U8 { + let x = raw_xor(a, b); + (a + b + x) / 2 + } + inline fn raw_lt(a: Field, b: Field) -> Field { + let (_, borrow) = raw_sub(a, b); + borrow + } + + inline fn to_field(byte: U8) -> Field { byte } + inline fn from_fields(a: Field, b: Field) -> (U8, U8) { range_pair(a, b); (a, b) } + inline fn bit_decomposition(x: U8) -> [Field; 8] { raw_bit_decomposition(x) } + inline fn xor(a: U8, b: U8) -> U8 { raw_xor(a, b) } + inline fn and(a: U8, b: U8) -> U8 { raw_and(a, b) } + inline fn or(a: U8, b: U8) -> U8 { raw_or(a, b) } + inline fn less_than(a: U8, b: U8) -> Field { raw_lt(a, b) } + inline fn add(a: U8, b: U8) -> (U8, U8) { raw_add(a, b) } + inline fn sub(a: U8, b: U8) -> (U8, U8) { raw_sub(a, b) } + inline fn mul(a: U8, b: U8) -> (U8, U8) { raw_mul(a, b) } + inline fn xor_split4(a: U8, b: U8) -> Parts4 { raw_xor_split4(a, b) } + inline fn xor_split7(a: U8, b: U8) -> Parts7 { raw_xor_split7(a, b) } + inline fn join4(high: Parts4, low: Parts4) -> U8 { high.0 + low.1 } + inline fn join7(high: Parts7, low: Parts7) -> U8 { high.0 + low.1 } + + // Domain 0..767 covers adding three bytes and an incoming carry. The table + // supplies the low byte; carry recovery is the ordinary proved field identity. + inline fn split_sum(sum: Field) -> (U8, U8) { + let byte = raw_sum_byte(sum); + (byte, (sum - byte) / 256) + } +} +"# + +private def byteTy : Generic.Ty := .named "U8" [] +private def literal (n : Nat) : Generic.Expr Nat := .literal n +private def pair (a b : Nat) : Generic.Expr Nat := .tuple [literal a, literal b] + +/-- Complete tables, independent of the workload and accelerator implementation. -/ +def tables : List (Generic.Table Nat) := Id.run do + let byte := byteTy + let two := Generic.Ty.tuple [byte, byte] + let inputs := (List.range 256).flatMap fun a => (List.range 256).map fun b => (a,b) + let sums := Carry.rows 256 768 + return [ + ⟨"byte_inputs", .tuple [.field], (List.range 256).map fun x => .tuple [literal x]⟩, + ⟨"byte_values", byte, (List.range 256).map literal⟩, + ⟨"byte_bits", .array .field 8, (List.range 256).map fun x => + .array ((List.range 8).map fun i => literal ((x / 2^i) % 2))⟩, + ⟨"pair_inputs", .tuple [.field, .field], inputs.map fun (a,b) => pair a b⟩, + ⟨"pair_units", .tuple [], inputs.map fun _ => .tuple []⟩, + ⟨"pair_xors", byte, inputs.map fun (a,b) => literal (Nat.xor a b)⟩, + ⟨"pair_adds", two, inputs.map fun (a,b) => pair ((a+b)%256) ((a+b)/256)⟩, + ⟨"pair_subs", two, inputs.map fun (a,b) => pair ((a+256-b)%256) (if a < b then 1 else 0)⟩, + ⟨"pair_muls", two, inputs.map fun (a,b) => pair ((a*b)%256) ((a*b)/256)⟩, + ⟨"pair_xor_parts4", .named "Parts4" [], inputs.map fun (a,b) => + let x := Nat.xor a b; pair (x/16) ((x%16)*16)⟩, + ⟨"pair_xor_parts7", .named "Parts7" [], inputs.map fun (a,b) => + let x := Nat.xor a b; pair (x/128) ((x%128)*2)⟩, + ⟨"sum_inputs", .tuple [.field], sums.map fun (n, _) => .tuple [literal n]⟩, + ⟨"sum_bytes", byte, sums.map fun (_, byte) => literal byte⟩] + +def templates : Modules.Program Nat := + { declarations with signatures := signature.signatures + modules := declarations.modules.map fun m => + { m with signature := some "U8Signature", body := match m.body with + | .definitions d => .definitions { d with + program.consts := d.program.consts ++ (List.range 256).map fun n => + ⟨s!"BYTE_{n}", .literal n⟩ + constTypes := d.constTypes ++ (List.range 256).map fun n => + (s!"BYTE_{n}", byteTy) } + | body => body } } + +def source : Modules.Program Nat := + { templates with modules := templates.modules.map fun m => + {m with body := match m.body with + | .definitions d => .definitions {d with program.tables := tables} + | body => body} } + +end Aiur.Library.U8 diff --git a/Aiur/Aiur/Library/U8/Signature.lean b/Aiur/Aiur/Library/U8/Signature.lean new file mode 100644 index 000000000..7b6108589 --- /dev/null +++ b/Aiur/Aiur/Library/U8/Signature.lean @@ -0,0 +1,50 @@ +import Aiur.Modules + +/-! The checked byte interface. Callers cannot manufacture bytes or split +parts from fields, including through hints. Maps and ordinary functions have +the same interface; table storage and host accelerators are implementation +details. The 256 typed literals are added below without exposing a cast. -/ +namespace Aiur.Library.U8 +open Aiur + +private def interface : Modules.Program Nat := aiur% " +signature U8Signature { + opaque type U8; + opaque type Parts4; + opaque type Parts7; + fn from_field(x: Field) -> U8; + fn from_fields(a: Field, b: Field) -> (U8, U8); + fn to_field(byte: U8) -> Field; + fn raw_bit_decomposition(x: Field) -> [Field; 8]; + fn range_pair(a: Field, b: Field) -> (); + fn raw_xor(a: Field, b: Field) -> U8; + fn raw_and(a: Field, b: Field) -> U8; + fn raw_or(a: Field, b: Field) -> U8; + fn raw_lt(a: Field, b: Field) -> Field; + fn raw_add(a: Field, b: Field) -> (U8, U8); + fn raw_sub(a: Field, b: Field) -> (U8, U8); + fn raw_mul(a: Field, b: Field) -> (U8, U8); + fn raw_xor_split4(a: Field, b: Field) -> Parts4; + fn raw_xor_split7(a: Field, b: Field) -> Parts7; + fn raw_sum_byte(sum: Field) -> U8; + fn bit_decomposition(x: U8) -> [Field; 8]; + fn xor(a: U8, b: U8) -> U8; + fn and(a: U8, b: U8) -> U8; + fn or(a: U8, b: U8) -> U8; + fn less_than(a: U8, b: U8) -> Field; + fn add(a: U8, b: U8) -> (U8, U8); + fn sub(a: U8, b: U8) -> (U8, U8); + fn mul(a: U8, b: U8) -> (U8, U8); + fn xor_split4(a: U8, b: U8) -> Parts4; + fn xor_split7(a: U8, b: U8) -> Parts7; + fn join4(high: Parts4, low: Parts4) -> U8; + fn join7(high: Parts7, low: Parts7) -> U8; + fn split_sum(sum: Field) -> (U8, U8); +}" + +def signature : Modules.Program Nat := + { interface with signatures := interface.signatures.map fun s => + { s with consts := (List.range 256).map fun n => + (s!"BYTE_{n}", .named "U8" []) } } + +end Aiur.Library.U8 diff --git a/Aiur/Aiur/Library/U8Facts.lean b/Aiur/Aiur/Library/U8Facts.lean new file mode 100644 index 000000000..eac022607 --- /dev/null +++ b/Aiur/Aiur/Library/U8Facts.lean @@ -0,0 +1,123 @@ +import Mathlib.Tactic + +/-! Arithmetic identities used by the ordinary Aiur byte library to reuse +XOR's fixed lookup for AND/OR. Proved by binary recursion on `Nat.bitwise`, +then lifted to any field in which two is nonzero. -/ +namespace Aiur.Library.U8 + +theorem nat_xor_and_sum (n m : Nat) : + n + m = Nat.xor n m + 2 * Nat.land n m := by + induction n using Nat.strongRecOn generalizing m with + | ind n ih => + rcases eq_or_ne n 0 with rfl | hn + · simp + rcases eq_or_ne m 0 with rfl | hm + · simp + have hrec := ih (n / 2) (Nat.div_lt_self (by omega) (by omega)) (m / 2) + unfold Nat.xor Nat.land at hrec ⊢ + rw [Nat.bitwise, Nat.bitwise] + dsimp only + simp only [hn, hm, ↓reduceIte] + rcases (by omega : n % 2 = 0 ∨ n % 2 = 1) with hn2 | hn2 <;> + rcases (by omega : m % 2 = 0 ∨ m % 2 = 1) with hm2 | hm2 + · have h1 : decide (n % 2 = 1) = false := by simp [hn2] + have h2 : decide (m % 2 = 1) = false := by simp [hm2] + simp [h1, h2]; omega + · have h1 : decide (n % 2 = 1) = false := by simp [hn2] + have h2 : decide (m % 2 = 1) = true := by simp [hm2] + simp [h1, h2]; omega + · have h1 : decide (n % 2 = 1) = true := by simp [hn2] + have h2 : decide (m % 2 = 1) = false := by simp [hm2] + simp [h1, h2]; omega + · have h1 : decide (n % 2 = 1) = true := by simp [hn2] + have h2 : decide (m % 2 = 1) = true := by simp [hm2] + simp [h1, h2]; omega + +theorem nat_xor_or_sum (n m : Nat) : + 2 * Nat.lor n m = n + m + Nat.xor n m := by + induction n using Nat.strongRecOn generalizing m with + | ind n ih => + rcases eq_or_ne n 0 with rfl | hn + · simp; omega + rcases eq_or_ne m 0 with rfl | hm + · simp; omega + have hrec := ih (n / 2) (Nat.div_lt_self (by omega) (by omega)) (m / 2) + unfold Nat.lor Nat.xor at hrec ⊢ + rw [Nat.bitwise, Nat.bitwise] + dsimp only + simp only [hn, hm, ↓reduceIte] + rcases (by omega : n % 2 = 0 ∨ n % 2 = 1) with hn2 | hn2 <;> + rcases (by omega : m % 2 = 0 ∨ m % 2 = 1) with hm2 | hm2 + · have h1 : decide (n % 2 = 1) = false := by simp [hn2] + have h2 : decide (m % 2 = 1) = false := by simp [hm2] + simp [h1, h2]; omega + · have h1 : decide (n % 2 = 1) = false := by simp [hn2] + have h2 : decide (m % 2 = 1) = true := by simp [hm2] + simp [h1, h2]; omega + · have h1 : decide (n % 2 = 1) = true := by simp [hn2] + have h2 : decide (m % 2 = 1) = false := by simp [hm2] + simp [h1, h2]; omega + · have h1 : decide (n % 2 = 1) = true := by simp [hn2] + have h2 : decide (m % 2 = 1) = true := by simp [hm2] + simp [h1, h2]; omega + +theorem xor_and_sum (a b : BitVec 8) : + a.toNat + b.toNat = (a ^^^ b).toNat + 2 * (a &&& b).toNat := by + rw [BitVec.toNat_xor, BitVec.toNat_and] + exact nat_xor_and_sum a.toNat b.toNat + +theorem xor_or_sum (a b : BitVec 8) : + 2 * (a ||| b).toNat = a.toNat + b.toNat + (a ^^^ b).toNat := by + rw [BitVec.toNat_or, BitVec.toNat_xor] + exact nat_xor_or_sum a.toNat b.toNat + +theorem and_field {F : Type*} [Field F] (two : (2 : F) ≠ 0) (a b : BitVec 8) : + ((a.toNat : F) + b.toNat - (a ^^^ b).toNat) / 2 = ((a &&& b).toNat : F) := by + have h := congrArg (fun n : Nat => (n : F)) (xor_and_sum a b) + push_cast at h + apply (div_eq_iff two).mpr + linear_combination h + +theorem or_field {F : Type*} [Field F] (two : (2 : F) ≠ 0) (a b : BitVec 8) : + ((a.toNat : F) + b.toNat + (a ^^^ b).toNat) / 2 = ((a ||| b).toNat : F) := by + have h := congrArg (fun n : Nat => (n : F)) (xor_or_sum a b) + push_cast at h + apply (div_eq_iff two).mpr + linear_combination -h + +end Aiur.Library.U8 + +namespace Aiur.Library.U8Facts + +theorem xor_lt_256 {a b : Nat} (ha : a < 256) (hb : b < 256) : + Nat.xor a b < 256 := by + have h : Nat.xor a b = (BitVec.ofNat 8 a ^^^ BitVec.ofNat 8 b).toNat := by + simp [BitVec.toNat_xor, BitVec.toNat_ofNat, Nat.mod_eq_of_lt ha, Nat.mod_eq_of_lt hb] + rw [h] + exact (BitVec.ofNat 8 a ^^^ BitVec.ofNat 8 b).isLt + +theorem xor_and_identity (a b : Nat) : + a + b = Nat.xor a b + 2 * Nat.land a b := + U8.nat_xor_and_sum a b + +theorem xor_or_identity (a b : Nat) : + 2 * Nat.lor a b = a + b + Nat.xor a b := + U8.nat_xor_or_sum a b + +theorem land_128_div {a : Nat} (ha : a < 256) : + Nat.land a 128 / 128 = a / 128 := by + apply Nat.eq_of_testBit_eq + intro i + have h1 : (128 : Nat) = 2 ^ 7 := rfl + have hland : Nat.land a (2 ^ 7) = a &&& 2 ^ 7 := rfl + rw [h1, hland, ← Nat.shiftRight_eq_div_pow, ← Nat.shiftRight_eq_div_pow, + Nat.testBit_shiftRight, Nat.testBit_shiftRight, Nat.testBit_and] + rcases i with _ | i + · have : Nat.testBit 128 7 = true := rfl + simp [this] + · have hlt : a < 2 ^ (7 + (i + 1)) := by + calc a < 2 ^ 8 := ha + _ ≤ 2 ^ (7 + (i + 1)) := Nat.pow_le_pow_right (by omega) (by omega) + simp [Nat.testBit_lt_two_pow hlt] + +end Aiur.Library.U8Facts diff --git a/Aiur/Aiur/MemoCompleteness.lean b/Aiur/Aiur/MemoCompleteness.lean new file mode 100644 index 000000000..701a9bc74 --- /dev/null +++ b/Aiur/Aiur/MemoCompleteness.lean @@ -0,0 +1,19 @@ +import Aiur.Completeness +import Aiur.Circuit.MemoDerivation + +namespace Aiur + +variable {F : Type} {rom : WireROM F} + +/-- Successful ROM evaluation admits a finite memoized graph of its canonical encodings. -/ +theorem memo_complete [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {name : String} {args : List (Value F)} {result : Value F} + (evaluated : ROMEvalCall (rom.decode program.enums) program name args result) : + ∃ wires output, DecodesValues program.enums wires args ∧ output.decode program.enums = some result ∧ + Circuit.MemoAccepts system rom name wires output := by + obtain ⟨wires, output, arguments, decoded, tree⟩ := evaluation_complete compiled evaluated + exact ⟨wires, output, arguments, decoded, tree.memo⟩ + +end Aiur diff --git a/Aiur/Aiur/MemoSoundness.lean b/Aiur/Aiur/MemoSoundness.lean new file mode 100644 index 000000000..46ad7a933 --- /dev/null +++ b/Aiur/Aiur/MemoSoundness.lean @@ -0,0 +1,17 @@ +import Aiur.Correctness +import Aiur.Circuit.MemoAcyclic + +namespace Aiur + +variable {F : Type} {rom : WireROM F} + +/-- An acyclic memoized graph has the same decoded semantics as a closed derivation tree. -/ +theorem memo_acyclic_sound [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) {message : Circuit.Message F} + (graph : Circuit.MemoDerivation system rom message) (acyclic : graph.Acyclic) : + message.Evaluates program rom := by + obtain ⟨tree⟩ := graph.derives_of_acyclic acyclic + exact derivation_sound compiled tree + +end Aiur diff --git a/Aiur/Aiur/Memory.lean b/Aiur/Aiur/Memory.lean new file mode 100644 index 000000000..f85f7045a --- /dev/null +++ b/Aiur/Aiur/Memory.lean @@ -0,0 +1,26 @@ +import Aiur.AST + +namespace Aiur + +/-- A runtime store appends a value; locations are indices, never source field values. -/ +abbrev Heap (F : Type) := List (SourceValue F) + +/-- The prover supplies one finite heterogeneous table for the whole circuit proof. -/ +structure ROM (F : Type) where + entries : List (F × Value F) := [] + deriving Repr, BEq + +def ROM.lookup [DecidableEq F] (rom : ROM F) (type : Ty) (address : F) : Option (Value F) := + (rom.entries.find? (fun entry => decide (entry.1 = address ∧ entry.2.type = type))).map Prod.snd + +/-- An address determines one value at each nominal type. Opaque pointers of +different types may reuse an address; identical repeated entries are harmless. -/ +def ROM.Valid (rom : ROM F) : Prop := + ∀ a ∈ rom.entries, ∀ b ∈ rom.entries, + a.1 = b.1 → a.2.type = b.2.type → a.2 = b.2 + +instance [DecidableEq F] (rom : ROM F) : Decidable rom.Valid := + inferInstanceAs (Decidable (∀ a ∈ rom.entries, ∀ b ∈ rom.entries, + a.1 = b.1 → a.2.type = b.2.type → a.2 = b.2)) + +end Aiur diff --git a/Aiur/Aiur/Memory/Completeness.lean b/Aiur/Aiur/Memory/Completeness.lean new file mode 100644 index 000000000..265e1d3d5 --- /dev/null +++ b/Aiur/Aiur/Memory/Completeness.lean @@ -0,0 +1,121 @@ +import Aiur.Memory.Encoding +import Aiur.Memory.Representation +import Mathlib.Data.Fintype.EquivFin + +namespace Aiur + +variable {F : Type} {rom : ROM F} {encode : Nat → F} + +theorem HeapCells.of_prefix {before after : Heap F} (cells : HeapCells rom encode after) + (grows : before <+: after) : HeapCells rom encode before := + fun i value found => cells i value (heap_get_of_prefix grows found) + +/-- A source execution can be interpreted against any table containing its encoded heap. -/ +theorem EvalExpr.toROM [Field F] [DecidableEq F] {program : Program F} + {locals : Environment F Nat} {expr : Expr F} {before after : Heap F} {value : SourceValue F} + (evaluated : EvalExpr program locals expr before value after) : + HeapCells rom encode after → + ROMEvalExpr rom program (encodeEnv encode locals) expr (value.mapAddress encode) := by + induction evaluated using EvalExpr.rec + (motive_2 := fun locals exprs before values after _ => HeapCells rom encode after → + ROMEvalArgs rom program (encodeEnv encode locals) exprs (values.map (Value.mapAddress encode))) + (motive_3 := fun name args before value after _ => HeapCells rom encode after → + ROMEvalCall rom program name (args.map (Value.mapAddress encode)) (value.mapAddress encode)) with + | literal => intro _; simpa only [Value.mapAddress] using ROMEvalExpr.literal + | var found => + intro _ + apply ROMEvalExpr.var + simp [encodeEnv, List.find?_map, Function.comp_def, found] + | tuple _ ih => + intro cells + simpa only [Value.mapAddress] using ROMEvalExpr.tuple (ih cells) + | construct _ ih => + intro cells + simpa only [Value.mapAddress] using ROMEvalExpr.construct (ih cells) + | project _ projected ih => + intro cells + refine .project (ih cells) ?_ + rw [projectValue_mapAddress, projected] + rfl + | letValue _ matched body valueIH bodyIH => + intro cells + have mapped := congrArg (Option.map (encodeEnv encode)) matched + rw [← Pattern.bindings_mapAddress] at mapped + simp only [Option.map_some] at mapped + refine .letValue (valueIH (cells.of_prefix body.grows)) mapped ?_ + simpa only [encodeEnv_append] using bodyIH cells + | @store locals expr before input middle value ih => + intro cells + have grow : middle <+: middle ++ [input] := ⟨[input], rfl⟩ + have cell := cells middle.length input (by simp) + simpa only [Value.mapAddress, Value.type_mapAddress] using + ROMEvalExpr.store (ih (cells.of_prefix grow)) cell + | @load locals expr before input after result pointer loaded ih => + intro cells + cases input with + | field | tuple | construct => cases loaded + | ptr target address => + cases found : after[address]? with + | none => simp [loadValue, found] at loaded + | some stored => + by_cases typed : stored.type = target + · simp [loadValue, found, typed, pure, Except.pure, bind, Except.bind] at loaded + subst result + exact .load (by simpa only [Value.mapAddress] using ih cells) + (cells address stored found) (by simpa only [Value.type_mapAddress] using typed) + · simp [loadValue, found, typed] at loaded + | neg _ operation ih => + intro cells + refine .neg (ih cells) ?_ + rw [evalNeg_mapAddress, operation]; rfl + | hint _ typed ih => + intro cells + simpa only [Constant.toValue_mapAddress] using ROMEvalExpr.hint (ih cells) typed + | assertEq _ right operation leftIH rightIH => + intro cells + refine .assertEq (leftIH (cells.of_prefix right.grows)) (rightIH cells) ?_ + exact evalAssertEq_mapAddress operation encode + | binary _ right operation leftIH rightIH => + intro cells + refine .binary (leftIH (cells.of_prefix right.grows)) (rightIH cells) ?_ + rw [evalBinOp_mapAddress, operation]; rfl + | call _ callee argsIH callIH => + intro cells + exact .call (argsIH (cells.of_prefix callee.grows)) (callIH cells) + | matchValue _ selected branch valueIH bodyIH => + intro cells + have mapped := congrArg (Option.map (fun (locals, expr) => (encodeEnv encode locals, expr))) selected + rw [← selectArm_mapAddress] at mapped + simp only [Option.map_some] at mapped + refine .matchValue (valueIH (cells.of_prefix branch.grows)) mapped ?_ + simpa only [encodeEnv_append] using bodyIH cells + | nil => exact .nil + | cons _ tail headIH tailIH => + rename_i cells + exact .cons (headIH (cells.of_prefix tail.grows)) (tailIH cells) + | intro prepared _ bodyIH => + rename_i cells + exact .intro (prepareCall_mapAddress prepared encode) (bodyIH cells) + +theorem EvalFn.toROM [Field F] [DecidableEq F] {program : Program F} + {name : String} {args : List (SourceValue F)} {before after : Heap F} {value : SourceValue F} + (evaluated : EvalFn program name args before value after) (cells : HeapCells rom encode after) : + ROMEvalCall rom program name (args.map (Value.mapAddress encode)) (value.mapAddress encode) := by + cases evaluated with + | intro prepared body => exact .intro (prepareCall_mapAddress prepared encode) (body.toROM cells) + +/-- A finite field has enough address space whenever the allocation count fits its cardinality. -/ +theorem heap_address_embedding [Field F] [Fintype F] (heap : Heap F) + (capacity : heap.length ≤ Fintype.card F) : + ∃ encode : Nat → F, + ∀ i j, i < heap.length → j < heap.length → encode i = encode j → i = j := by + classical + have capacity' : Fintype.card (Fin heap.length) ≤ Fintype.card F := by simpa using capacity + obtain ⟨embedding⟩ := Function.Embedding.nonempty_of_card_le capacity' + let encode : Nat → F := fun i => if h : i < heap.length then embedding ⟨i, h⟩ else 0 + refine ⟨encode, ?_⟩ + intro i j hi hj same + have equal : (⟨i, hi⟩ : Fin heap.length) = ⟨j, hj⟩ := embedding.injective (by simpa [encode, hi, hj] using same) + exact congrArg Fin.val equal + +end Aiur diff --git a/Aiur/Aiur/Memory/Encoding.lean b/Aiur/Aiur/Memory/Encoding.lean new file mode 100644 index 000000000..c24da7c73 --- /dev/null +++ b/Aiur/Aiur/Memory/Encoding.lean @@ -0,0 +1,165 @@ +import Aiur.Semantics +import Aiur.Tables +import Mathlib.Data.List.FinRange + +namespace Aiur + +theorem Value.mapAddress_free (value : Value F A) (free : value.pointerFree = true) + (left right : A → B) : value.mapAddress left = value.mapAddress right := by + cases value with + | field => simp [Value.mapAddress] + | ptr => simp [Value.pointerFree, Value.type, Ty.pointerFree] at free + | tuple items | construct _ _ items => + simp only [Value.mapAddress, Value.tuple.injEq, Value.construct.injEq, true_and] + have itemsFree : ∀ item ∈ items, item.pointerFree = true := by + simpa [Value.pointerFree, Value.type, Ty.pointerFree] using free + exact List.map_congr_left (fun item member => Value.mapAddress_free item (itemsFree item member) left right) +termination_by sizeOf value + +def encodeEnv (encode : A → B) (locals : Environment F A) : Environment F B := + locals.map (fun (name, value) => (name, value.mapAddress encode)) + +@[simp] theorem encodeEnv_append (encode : A → B) (left right : Environment F A) : + encodeEnv encode (left ++ right) = encodeEnv encode left ++ encodeEnv encode right := List.map_append + +mutual + theorem Pattern.bindings_mapAddress [DecidableEq F] (pattern : Pattern F) (value : Value F A) + (encode : A → B) : + pattern.bindings (value.mapAddress encode) = (pattern.bindings value).map (encodeEnv encode) := by + cases pattern with + | wildcard => simp [Pattern.bindings, encodeEnv] + | bind => simp [Pattern.bindings, encodeEnv] + | literal => + cases value with + | tuple | ptr | construct => simp [Value.mapAddress, Pattern.bindings] + | field => simp only [Value.mapAddress, Pattern.bindings]; split <;> rfl + | tuple patterns => + cases value with + | field | ptr | construct => simp [Value.mapAddress, Pattern.bindings] + | tuple values => + simpa only [Value.mapAddress, Pattern.bindings] using + Pattern.bindingsList_mapAddress patterns values encode + | construct name ctor patterns => + cases value with + | field | ptr | tuple => simp [Value.mapAddress, Pattern.bindings] + | construct actual actualCtor values => + simp only [Value.mapAddress, Pattern.bindings] + split + · exact Pattern.bindingsList_mapAddress patterns values encode + · rfl + termination_by sizeOf pattern + + theorem Pattern.bindingsList_mapAddress [DecidableEq F] (patterns : List (Pattern F)) + (values : List (Value F A)) (encode : A → B) : + Pattern.bindingsList patterns (values.map (Value.mapAddress encode)) = + (Pattern.bindingsList patterns values).map (encodeEnv encode) := by + cases patterns with + | nil => cases values <;> simp [Pattern.bindingsList, encodeEnv] + | cons pattern patterns => + cases values with + | nil => simp [Pattern.bindingsList] + | cons value values => + simp only [List.map_cons, Pattern.bindingsList, + Pattern.bindings_mapAddress pattern value encode, Pattern.bindingsList_mapAddress patterns values encode] + cases pattern.bindings value <;> cases Pattern.bindingsList patterns values <;> + simp [encodeEnv_append] + termination_by sizeOf patterns +end + +theorem selectArm_mapAddress [DecidableEq F] (value : Value F A) + (arms : List (Pattern F × Expr F)) (encode : A → B) : + selectArm (value.mapAddress encode) arms = + (selectArm value arms).map (fun (locals, expr) => (encodeEnv encode locals, expr)) := by + induction arms with + | nil => rfl + | cons arm arms ih => + rcases arm with ⟨pattern, body⟩ + simp only [selectArm, Pattern.bindings_mapAddress] + cases pattern.bindings value <;> simp [ih] + +theorem projectValue_mapAddress (value : Value F A) (index : Nat) (encode : A → B) : + projectValue (value.mapAddress encode) index = (projectValue value index).map (Value.mapAddress encode) := by + cases value with + | field | ptr | construct => simp [Value.mapAddress, projectValue, Except.map] + | tuple items => + cases found : items[index]? <;> simp [Value.mapAddress, projectValue, List.getElem?_map, found, Except.map, + pure, Except.pure] + +theorem evalNeg_mapAddress [Field F] (value : Value F A) (encode : A → B) : + evalNeg (value.mapAddress encode) = (evalNeg value).map (Value.mapAddress encode) := by + cases value <;> simp [Value.mapAddress, evalNeg, Except.map] + +theorem evalBinOp_mapAddress [Field F] [DecidableEq F] + (op : BinOp) (left right : Value F A) (encode : A → B) : + evalBinOp op (left.mapAddress encode) (right.mapAddress encode) = + (evalBinOp op left right).map (Value.mapAddress encode) := by + cases left <;> cases right <;> simp [Value.mapAddress, evalBinOp, Except.map] + cases op <;> simp [Value.mapAddress] + split <;> simp [Value.mapAddress] + +theorem prepareCall_mapAddress [DecidableEq F] {program : Program F} {name : String} {args : List (Value F A)} + {locals : Environment F A} {body : Expr F} + (prepared : prepareCall program name args = .ok (locals, body)) (encode : A → B) : + prepareCall program name (args.map (Value.mapAddress encode)) = .ok (encodeEnv encode locals, body) := by + rcases prepareCall_spec prepared with function | table + · obtain ⟨fn, found, types, formed, rfl, rfl⟩ := function + have shape : fn.params.map Prod.snd = (args.map (Value.mapAddress encode)).map Value.type := by + simpa only [List.map_map, Function.comp_def, Value.type_mapAddress] using types + have prepared := prepareCall_of_types found shape (by + intro value member + obtain ⟨source, sourceMember, rfl⟩ := List.mem_map.mp member + simpa using formed source sourceMember) + have localsMap : encodeEnv encode ((fn.params.map Prod.fst).zip args) = + (fn.params.map Prod.fst).zip (args.map (Value.mapAddress encode)) := by + simp only [encodeEnv, List.zip_map_right] + exact List.map_congr_left (fun pair _ => by cases pair; rfl) + simpa only [localsMap] using prepared + · obtain ⟨value, absent, looked, rfl, rfl⟩ := table + simpa only [encodeEnv, List.map_nil] using + prepareCall_map absent ((lookupMap_mapAddress program name args encode).trans looked) + +theorem EvalExpr.grows [Field F] [DecidableEq F] {program : Program F} + {locals : Environment F Nat} {expr : Expr F} {before after : Heap F} {value : SourceValue F} + (evaluated : EvalExpr program locals expr before value after) : before <+: after := by + induction evaluated using EvalExpr.rec + (motive_2 := fun _ _ before _ after _ => before <+: after) + (motive_3 := fun _ _ before _ after _ => before <+: after) with + | literal | var | nil => exact List.prefix_refl _ + | tuple _ ih | construct _ ih | project _ _ ih | neg _ _ ih | load _ _ ih | hint _ _ ih | intro _ _ ih => exact ih + | letValue _ _ _ a b | binary _ _ _ a b | assertEq _ _ _ a b | call _ _ a b | matchValue _ _ _ a b | cons _ _ a b => exact a.trans b + | store _ ih => exact ih.trans ⟨_, rfl⟩ + +theorem EvalFn.grows [Field F] [DecidableEq F] {program : Program F} + {name : String} {args : List (SourceValue F)} {before after : Heap F} {value : SourceValue F} + (evaluated : EvalFn program name args before value after) : before <+: after := by + cases evaluated with + | intro _ body => exact body.grows + +theorem EvalArgs.grows [Field F] [DecidableEq F] {program : Program F} + {locals : Environment F Nat} {exprs : List (Expr F)} {before after : Heap F} {values : List (SourceValue F)} + (evaluated : EvalArgs program locals exprs before values after) : before <+: after := by + exact (EvalExpr.tuple evaluated).grows + +/-- Encode all allocated cells into one heterogeneous finite ROM. -/ +def ROM.ofHeap (heap : Heap F) (encode : Nat → F) : ROM F := + ⟨List.ofFn (fun i : Fin heap.length => (encode i, heap[i].mapAddress encode))⟩ + +def HeapCells (rom : ROM F) (encode : Nat → F) (heap : Heap F) : Prop := + ∀ i value, heap[i]? = some value → (encode i, value.mapAddress encode) ∈ rom.entries + +theorem ROM.ofHeap_cells (heap : Heap F) (encode : Nat → F) : HeapCells (ROM.ofHeap heap encode) encode heap := by + intro i value found + obtain ⟨bound, same⟩ := List.getElem?_eq_some_iff.mp found + exact List.mem_ofFn.mpr ⟨⟨i, bound⟩, by simp [same]⟩ + +theorem ROM.ofHeap_valid (heap : Heap F) (encode : Nat → F) + (injective : ∀ i j, i < heap.length → j < heap.length → encode i = encode j → i = j) : + (ROM.ofHeap heap encode).Valid := by + intro a ha b hb address _ + obtain ⟨i, rfl⟩ := List.mem_ofFn.mp ha + obtain ⟨j, rfl⟩ := List.mem_ofFn.mp hb + have same : i = j := Fin.ext (injective i j i.isLt j.isLt address) + subst j + rfl + +end Aiur diff --git a/Aiur/Aiur/Memory/Operations.lean b/Aiur/Aiur/Memory/Operations.lean new file mode 100644 index 000000000..38c35d0f4 --- /dev/null +++ b/Aiur/Aiur/Memory/Operations.lean @@ -0,0 +1,207 @@ +import Aiur.Tables +import Aiur.Memory.Representation + +namespace Aiur + +variable {F : Type} {rom : ROM F} {heap : Heap F} + +namespace RepresentsArgs + +theorem types {sources : List (SourceValue F)} {targets : List (Value F)} + (related : RepresentsArgs rom heap sources targets) : + sources.map Value.type = targets.map Value.type := by + induction related with + | nil => rfl + | cons head _ ih => simp only [List.map_cons, head.type, ih] + +theorem zip (names : List String) {sources : List (SourceValue F)} {targets : List (Value F)} + (related : RepresentsArgs rom heap sources targets) : + RepresentsEnv rom heap (names.zip sources) (names.zip targets) := by + induction related generalizing names with + | nil => simp + | cons head _ ih => + cases names with + | nil => exact .nil + | cons name names => exact .cons ⟨rfl, head⟩ (ih names) + +theorem get {sources : List (SourceValue F)} {targets : List (Value F)} + (related : RepresentsArgs rom heap sources targets) {i : Nat} {target : Value F} + (found : targets[i]? = some target) : + ∃ source, sources[i]? = some source ∧ Represents rom heap source target := by + induction related generalizing i with + | nil => simp at found + | cons head _ ih => + cases i with + | zero => simp only [List.getElem?_cons_zero, Option.some.injEq] at found; subst target; exact ⟨_, rfl, head⟩ + | succ i => exact ih found + +end RepresentsArgs + +theorem RepresentsEnv.lookup {sources : Environment F Nat} {targets : Environment F} + (related : RepresentsEnv rom heap sources targets) {name : String} {target : Value F} + (found : targets.find? (·.1 == name) = some (name, target)) : + ∃ source, sources.find? (·.1 == name) = some (name, source) ∧ Represents rom heap source target := by + induction related with + | nil => simp at found + | @cons a b _ _ head tail ih => + simp only [List.find?_cons] at found ⊢ + rw [head.1] + split at found + · rename_i selected + cases found + exact ⟨a.2, by cases a; simp_all, head.2⟩ + · rename_i rejected + simpa only [rejected, ↓reduceIte] using ih found + +mutual + theorem Pattern.represents [DecidableEq F] (pattern : Pattern F) + {source : SourceValue F} {target : Value F} (related : Represents rom heap source target) : + Option.Rel (RepresentsEnv rom heap) (pattern.bindings source) (pattern.bindings target) := by + cases pattern with + | wildcard => simpa only [Pattern.bindings] using Option.Rel.some (List.Forall₂.nil) + | bind name => + simpa only [Pattern.bindings] using Option.Rel.some (List.Forall₂.cons ⟨rfl, related⟩ .nil) + | literal literal => + cases related with + | field => simp only [Pattern.bindings]; split + · exact .some .nil + · exact .none + | tuple | ptr | construct => simp only [Pattern.bindings]; exact .none + | tuple patterns => + cases related with + | field | ptr | construct => simp only [Pattern.bindings]; exact .none + | tuple items => simpa only [Pattern.bindings] using Pattern.representsList patterns items + | construct name ctor patterns => + cases related with + | field | ptr | tuple => simp only [Pattern.bindings]; exact .none + | construct items => + simp only [Pattern.bindings] + split + · exact Pattern.representsList patterns items + · exact .none + termination_by sizeOf pattern + + theorem Pattern.representsList [DecidableEq F] (patterns : List (Pattern F)) + {sources : List (SourceValue F)} {targets : List (Value F)} + (related : RepresentsArgs rom heap sources targets) : + Option.Rel (RepresentsEnv rom heap) (Pattern.bindingsList patterns sources) + (Pattern.bindingsList patterns targets) := by + cases patterns with + | nil => cases related <;> simp only [Pattern.bindingsList]; exact .some .nil; exact .none + | cons pattern patterns => + cases related with + | nil => simp only [Pattern.bindingsList]; exact .none + | cons head tail => + have heads := pattern.represents head + have tails := Pattern.representsList patterns tail + simp only [Pattern.bindingsList] + generalize hs : pattern.bindings _ = sourceHead at heads ⊢ + generalize ht : pattern.bindings _ = targetHead at heads ⊢ + generalize hss : Pattern.bindingsList patterns _ = sourceTail at tails ⊢ + generalize htt : Pattern.bindingsList patterns _ = targetTail at tails ⊢ + cases heads <;> cases tails + all_goals first | exact .some (List.rel_append ‹_› ‹_›) | exact .none + termination_by sizeOf patterns +end + +theorem selectArm_represents [DecidableEq F] {source : SourceValue F} {target : Value F} + (related : Represents rom heap source target) (arms : List (Pattern F × Expr F)) : + Option.Rel (fun a b => RepresentsEnv rom heap a.1 b.1 ∧ a.2 = b.2) + (selectArm source arms) (selectArm target arms) := by + induction arms with + | nil => exact .none + | cons arm arms ih => + rcases arm with ⟨pattern, body⟩ + have matched := pattern.represents related + simp only [selectArm] + generalize hs : pattern.bindings source = sourceMatch at matched ⊢ + generalize ht : pattern.bindings target = targetMatch at matched ⊢ + cases matched with + | none => exact ih + | some bindings => exact .some ⟨bindings, rfl⟩ + +theorem Represents.project {source : SourceValue F} {target result : Value F} {index : Nat} + (related : Represents rom heap source target) (projected : projectValue target index = .ok result) : + ∃ value, projectValue source index = .ok value ∧ Represents rom heap value result := by + cases related with + | field | ptr | construct => cases projected + | @tuple sources targets items => + cases found : targets[index]? with + | none => simp [projectValue, found] at projected + | some target => + simp [projectValue, found, pure, Except.pure] at projected + subst result + obtain ⟨value, source, relation⟩ := RepresentsArgs.get items found + exact ⟨value, by simp [projectValue, source, pure, Except.pure], relation⟩ + +theorem Represents.neg [Field F] {source : SourceValue F} {target result : Value F} + (related : Represents rom heap source target) (operation : evalNeg target = .ok result) : + ∃ value, evalNeg source = .ok value ∧ Represents rom heap value result := by + cases related with + | field => cases operation; exact ⟨_, rfl, .field⟩ + | tuple | ptr | construct => cases operation + +theorem Represents.assertEq [DecidableEq F] + {left right : SourceValue F} {x y result : Value F} + (first : Represents rom heap left x) (second : Represents rom heap right y) + (operation : evalAssertEq message x y = .ok result) : + ∃ value, evalAssertEq message left right = .ok value ∧ Represents rom heap value result := by + obtain ⟨free, rfl, rfl⟩ := evalAssertEq_ok.mp operation + have lhs := first.pointerFree_eq free + have rhs := second.pointerFree_eq free + refine ⟨.tuple [], evalAssertEq_ok.mpr ⟨?_, lhs.trans rhs.symm, rfl⟩, .tuple .nil⟩ + rw [lhs, Value.pointerFree_mapAddress] + exact free + +theorem Represents.binary [Field F] [DecidableEq F] + {left right : SourceValue F} {x y result : Value F} {op : BinOp} + (l : Represents rom heap left x) (r : Represents rom heap right y) + (operation : evalBinOp op x y = .ok result) : + ∃ value, evalBinOp op left right = .ok value ∧ Represents rom heap value result := by + cases l with + | tuple | ptr | construct => cases operation + | field => + cases r with + | tuple | ptr | construct => cases operation + | field => + cases op with + | add | sub | mul => cases operation; exact ⟨_, rfl, .field⟩ + | div => + simp only [evalBinOp] at operation + split at operation + · cases operation + · rename_i nonzero + cases operation + exact ⟨_, by simp [evalBinOp, nonzero], .field⟩ + +theorem prepareCall_represents [DecidableEq F] {program : Program F} {name : String} + {sources : List (SourceValue F)} {targets : List (Value F)} + (related : RepresentsArgs rom heap sources targets) {locals : Environment F} {body : Expr F} + (prepared : prepareCall program name targets = .ok (locals, body)) : + ∃ sourceLocals, prepareCall program name sources = .ok (sourceLocals, body) ∧ + RepresentsEnv rom heap sourceLocals locals := by + rcases prepareCall_spec prepared with function | table + · obtain ⟨fn, found, types, formed, rfl, rfl⟩ := function + refine ⟨_, prepareCall_of_types found (types.trans related.types.symm) ?_, related.zip _⟩ + clear types prepared found + induction related with + | nil => simp + | cons head tail ih => + intro source member + rcases List.mem_cons.mp member with rfl | member + · rw [head.wellFormed program.enums] + exact formed _ (by simp) + · exact ih (fun v h => formed v (by simp [h])) source member + · obtain ⟨constant, absent, looked, rfl, rfl⟩ := table + obtain ⟨_, key, _, _, _, extracted, _, _⟩ := lookupMap_spec looked + have free : (Value.tuple targets).pointerFree = true := by + rw [← Value.toConstant_spec extracted] + exact Constant.toValue_pointerFree key + have same := (Represents.tuple related).pointerFree_eq free + have same : sources = targets.map (Value.mapAddress (fun _ => 0)) := by + simpa only [Value.mapAddress, Value.tuple.injEq] using same + refine ⟨[], prepareCall_map absent ?_, .nil⟩ + rw [same, lookupMap_mapAddress] + exact looked + +end Aiur diff --git a/Aiur/Aiur/Memory/Partition.lean b/Aiur/Aiur/Memory/Partition.lean new file mode 100644 index 000000000..b7ff355ce --- /dev/null +++ b/Aiur/Aiur/Memory/Partition.lean @@ -0,0 +1,96 @@ +import Aiur.Wire +import Mathlib.Data.List.FinRange + +namespace Aiur + +/-- Physical ROM words have no nominal tag. The payload length is its chip's +static width; addresses are local to that width. Only active rows occur here. +The STARK's lookup balance and field-capacity bounds remain adapter obligations. -/ +structure WidthROM (F : Type) where + entries : List (F × List F) + +namespace WidthROM + +/-- The same width and address must always supply the same words. -/ +def Valid (rom : WidthROM F) : Prop := + ∀ a ∈ rom.entries, ∀ b ∈ rom.entries, + a.1 = b.1 → a.2.length = b.2.length → a.2 = b.2 + +/-- Independently generated ROMs compose when their address ranges are +disjoint within each width. Distributed execution uses this boundary; it +does not require globally distinct addresses across different widths. -/ +theorem append_valid {left right : WidthROM F} (hl : left.Valid) (hr : right.Valid) + (separate : ∀ a ∈ left.entries, ∀ b ∈ right.entries, + a.2.length = b.2.length → a.1 ≠ b.1) : + (WidthROM.mk (left.entries ++ right.entries)).Valid := by + intro a ha b hb address size + simp only [List.mem_append] at ha hb + rcases ha with ha | ha <;> rcases hb with hb | hb + · exact hl a ha b hb address size + · exact (separate a ha b hb size address).elim + · exact (separate b hb a ha size.symm address.symm).elim + · exact hr a ha b hb address size + +/-- Expand raw words into their static typed views for the existing compiler +model. This is a proof construction, not witness data or runtime validation. +Unused views may have invalid tags; the provenance theorem needs only the view +originating from the corresponding well-typed store. -/ +def toWireROM (rom : WidthROM F) (decls : Declarations) (types : List Ty) : WireROM F := + ⟨rom.entries.flatMap fun (address, words) => + (types.filter fun type => (decls.layout type).toOption.map Layout.width == some words.length).map + (fun type => (address, ⟨type, words⟩))⟩ + +theorem mem_toWireROM {rom : WidthROM F} {decls : Declarations} {types : List Ty} + {address : F} {wire : WireValue F} : + (address, wire) ∈ (rom.toWireROM decls types).entries ↔ + (address, wire.words) ∈ rom.entries ∧ wire.type ∈ types ∧ + (decls.layout wire.type).toOption.map Layout.width = some wire.words.length := by + rcases wire with ⟨type, words⟩ + simp only [toWireROM, List.mem_flatMap, List.mem_map, List.mem_filter, + beq_iff_eq, Prod.exists, Prod.mk.injEq, WireValue.mk.injEq] + constructor + · rintro ⟨a, w, member, t, ⟨typed, size⟩, rfl, rfl, rfl⟩ + exact ⟨member, typed, size⟩ + · rintro ⟨member, typed, size⟩ + exact ⟨address, words, member, type, ⟨typed, size⟩, rfl, rfl, rfl⟩ + +/-- Width-local functionality suffices for the type-directed ROM model. No +address directory, global uniqueness, or nominal tag column is assumed. -/ +theorem toWireROM_valid {rom : WidthROM F} (valid : rom.Valid) + (decls : Declarations) (types : List Ty) : (rom.toWireROM decls types).Valid := by + rintro ⟨a, left⟩ ha ⟨b, right⟩ hb address typed + obtain ⟨lm, _, ls⟩ := mem_toWireROM.mp ha + obtain ⟨rm, _, rs⟩ := mem_toWireROM.mp hb + have size : left.words.length = right.words.length := by + rw [typed, rs] at ls + exact (Option.some.inj ls).symm + have words : left.words = right.words := valid _ lm _ rm address size + cases left; cases right + simp_all + +/-- Reference construction: each width enumerates its own addresses. -/ +def ofBuckets (widths : List Nat) (rows : Nat → List (List F)) (encode : Nat → F) : WidthROM F := + ⟨widths.flatMap fun width => + List.ofFn (fun i : Fin (rows width).length => (encode i, (rows width)[i]))⟩ + +/-- The injection bound is per bucket; numeric addresses can be reused freely +in other widths. The AIR enforces this with its local consecutive-address rows. -/ +theorem ofBuckets_valid (widths : List Nat) (rows : Nat → List (List F)) (encode : Nat → F) + (sized : ∀ w ∈ widths, ∀ words ∈ rows w, words.length = w) + (distinct : ∀ w ∈ widths, ∀ i j, i < (rows w).length → j < (rows w).length → + encode i = encode j → i = j) : (ofBuckets widths rows encode).Valid := by + intro a ha b hb address size + obtain ⟨w, wm, hm⟩ := List.mem_flatMap.mp ha + obtain ⟨i, rfl⟩ := List.mem_ofFn.mp hm + obtain ⟨v, vm, hn⟩ := List.mem_flatMap.mp hb + obtain ⟨j, rfl⟩ := List.mem_ofFn.mp hn + have sameWidth : w = v := + (sized w wm _ (List.getElem_mem i.isLt)).symm.trans + (size.trans (sized v vm _ (List.getElem_mem j.isLt))) + subst v + have same : i = j := Fin.ext (distinct w wm i j i.isLt j.isLt address) + subst j + rfl + +end WidthROM +end Aiur diff --git a/Aiur/Aiur/Memory/Representation.lean b/Aiur/Aiur/Memory/Representation.lean new file mode 100644 index 000000000..459b48c9c --- /dev/null +++ b/Aiur/Aiur/Memory/Representation.lean @@ -0,0 +1,121 @@ +import Aiur.Semantics +import Aiur.ROMSemantics +import Aiur.Semantics.CallTypes +import Mathlib.Data.List.Nodup + +namespace Aiur + +/-- A source location and a field address correspond through the values they contain. + Distinct allocations may correspond to the same ROM address. -/ +inductive Represents (rom : ROM F) (heap : Heap F) : SourceValue F → Value F → Prop where + | field : Represents rom heap (.field value) (.field value) + | tuple (items : List.Forall₂ (Represents rom heap) sources targets) : + Represents rom heap (.tuple sources) (.tuple targets) + | construct (items : List.Forall₂ (Represents rom heap) sources targets) : + Represents rom heap (.construct name ctor sources) (.construct name ctor targets) + | ptr (source : heap[location]? = some stored) + (cell : (address, encoded) ∈ rom.entries) + (contents : Represents rom heap stored encoded) : + Represents rom heap (.ptr stored.type location) (.ptr encoded.type address) + +variable {F : Type} {rom : ROM F} {heap larger : Heap F} + +/-- Extending immutable memory preserves every earlier cell. -/ +theorem heap_get_of_prefix (grows : heap <+: larger) {i : Nat} {v : SourceValue F} + (found : heap[i]? = some v) : larger[i]? = some v := by + obtain ⟨rest, rfl⟩ := grows + rw [List.getElem?_append_left ((List.getElem?_eq_some_iff.mp found).1)] + exact found + +theorem Represents.type {source : SourceValue F} {target : Value F} + (related : Represents rom heap source target) : source.type = target.type := by + induction related using Represents.rec + (motive_2 := fun sources targets _ => sources.map Value.type = targets.map Value.type) with + | field | construct => simp [Value.type] + | tuple _ ih => simp only [Value.type, ih] + | ptr _ _ _ ih => simp only [Value.type, ih] + | nil => rfl + | cons _ _ h t => simp only [List.map_cons, h, t] + +theorem Represents.wellFormed (decls : Declarations) {source : SourceValue F} {target : Value F} + (related : Represents rom heap source target) : + source.wellFormed decls = target.wellFormed decls := by + induction related using Represents.rec + (motive_2 := fun sources targets _ => + sources.map Value.type = targets.map Value.type ∧ + sources.map (Value.wellFormed decls) = targets.map (Value.wellFormed decls)) with + | field => simp [Value.wellFormed] + | tuple _ ih => simp [Value.wellFormed, ih.2] + | construct _ ih => simp [Value.wellFormed, ih.1, ih.2] + | ptr _ _ related ih => simp [Value.wellFormed, related.type] + | nil => exact ⟨rfl, rfl⟩ + | cons head _ h t => exact ⟨by simp [head.type, t.1], by simp [h, t.2]⟩ + +theorem Represents.mono {source : SourceValue F} {target : Value F} + (related : Represents rom heap source target) (grows : heap <+: larger) : + Represents rom larger source target := by + induction related using Represents.rec + (motive_2 := fun sources targets _ => List.Forall₂ (Represents rom larger) sources targets) with + | field => exact .field + | tuple _ ih => exact .tuple ih + | construct _ ih => exact .construct ih + | ptr source cell _ ih => exact .ptr (heap_get_of_prefix grows source) cell ih + | nil => exact .nil + | cons _ _ h t => exact .cons h t + +abbrev RepresentsArgs (rom : ROM F) (heap : Heap F) := List.Forall₂ (Represents rom heap) +abbrev RepresentsEnv (rom : ROM F) (heap : Heap F) := + List.Forall₂ (fun (s : String × SourceValue F) (t : String × Value F) => + s.1 = t.1 ∧ Represents rom heap s.2 t.2) + +theorem RepresentsArgs.mono {sources : List (SourceValue F)} {targets : List (Value F)} + (related : RepresentsArgs rom heap sources targets) (grows : heap <+: larger) : + RepresentsArgs rom larger sources targets := related.imp (fun _ _ h => h.mono grows) + +theorem RepresentsEnv.mono {sources : Environment F Nat} {targets : Environment F} + (related : RepresentsEnv rom heap sources targets) (grows : heap <+: larger) : + RepresentsEnv rom larger sources targets := related.imp (fun _ _ h => ⟨h.1, h.2.mono grows⟩) + +theorem ROM.functional (valid : rom.Valid) {address : F} {left right : Value F} + (a : (address, left) ∈ rom.entries) (b : (address, right) ∈ rom.entries) + (typed : left.type = right.type) : left = right := + valid _ a _ b rfl typed + +/-- The pointer-free public interface can be represented in every ROM and heap. -/ +theorem Represents.of_pointerFree (source : SourceValue F) (free : source.pointerFree = true) + (encode : Nat → F) : Represents rom heap source (source.mapAddress encode) := by + cases source with + | field => simpa only [Value.mapAddress] using Represents.field + | ptr => simp [Value.pointerFree, Value.type, Ty.pointerFree] at free + | tuple items | construct _ _ items => + simp only [Value.mapAddress] + first | apply Represents.tuple | apply Represents.construct + have freeItems : ∀ item ∈ items, item.pointerFree = true := by + simpa [Value.pointerFree, Value.type, Ty.pointerFree] using free + apply List.forall₂_map_right_iff.mpr + exact List.forall₂_same.mpr (fun item member => of_pointerFree item (freeItems item member) encode) +termination_by sizeOf source + + +/-- A pointer-free result is equal as data, without any address correspondence. -/ +theorem Represents.pointerFree_eq {source : SourceValue F} {target : Value F} + (related : Represents rom heap source target) : target.pointerFree = true → + source = target.mapAddress (fun _ => 0) := by + induction related using Represents.rec + (motive_2 := fun sources targets _ => + (∀ value ∈ targets, value.pointerFree = true) → + sources = targets.map (Value.mapAddress (fun _ => 0))) with + | field => intro _; simp [Value.mapAddress] + | tuple _ ih | construct _ ih => + intro free + simp only [Value.mapAddress, Value.tuple.injEq, Value.construct.injEq, true_and] + apply ih + simpa [Value.pointerFree, Value.type, Ty.pointerFree] using free + | ptr => simp [Value.pointerFree, Value.type, Ty.pointerFree] + | nil => rfl + | cons _ _ h t => + rename_i free + simp only [List.map_cons] + exact congrArg₂ List.cons (h (free _ (by simp))) (t (fun v mem => free v (by simp [mem]))) + +end Aiur diff --git a/Aiur/Aiur/Memory/Soundness.lean b/Aiur/Aiur/Memory/Soundness.lean new file mode 100644 index 000000000..b2ba777be --- /dev/null +++ b/Aiur/Aiur/Memory/Soundness.lean @@ -0,0 +1,134 @@ +import Aiur.Memory.Operations +import Aiur.Memory.Encoding + +namespace Aiur + +variable {F : Type} {rom : ROM F} + +private theorem option_related_some {R : α → β → Prop} {source : Option α} {target : β} + (related : Option.Rel R source (some target)) : ∃ value, source = some value ∧ R value target := by + cases related with + | some relation => exact ⟨_, rfl, relation⟩ + +/-- A finite evaluation against a functional ROM can be realized by fresh source allocations. + The proof preserves values through cell contents, without equating the two address spaces. -/ +theorem ROMEvalExpr.realize [Field F] [DecidableEq F] (valid : rom.Valid) + {program : Program F} {locals : Environment F} {expr : Expr F} {target : Value F} + (evaluated : ROMEvalExpr rom program locals expr target) : + ∀ heap sourceLocals, RepresentsEnv rom heap sourceLocals locals → + ∃ source after, EvalExpr program sourceLocals expr heap source after ∧ heap <+: after ∧ + Represents rom after source target := by + induction evaluated using ROMEvalExpr.rec + (motive_2 := fun locals exprs targets _ => ∀ heap sourceLocals, + RepresentsEnv rom heap sourceLocals locals → + ∃ sources after, EvalArgs program sourceLocals exprs heap sources after ∧ heap <+: after ∧ + RepresentsArgs rom after sources targets) + (motive_3 := fun name targets result _ => ∀ heap sources, + RepresentsArgs rom heap sources targets → + ∃ source after, EvalFn program name sources heap source after ∧ heap <+: after ∧ + Represents rom after source result) with + | literal => intro heap locals _; exact ⟨_, heap, .literal, List.prefix_refl _, .field⟩ + | var found => + intro heap locals related + obtain ⟨source, lookup, related⟩ := related.lookup found + exact ⟨source, heap, .var lookup, List.prefix_refl _, related⟩ + | tuple _ ih => + intro heap locals related + obtain ⟨sources, after, evaluated, grows, results⟩ := ih heap locals related + exact ⟨.tuple sources, after, .tuple evaluated, grows, .tuple results⟩ + | construct _ ih => + intro heap locals related + obtain ⟨sources, after, evaluated, grows, results⟩ := ih heap locals related + exact ⟨_, after, .construct evaluated, grows, .construct results⟩ + | project _ projected ih => + intro heap locals related + obtain ⟨source, after, evaluated, grows, result⟩ := ih heap locals related + obtain ⟨value, projected, result⟩ := result.project projected + exact ⟨value, after, .project evaluated projected, grows, result⟩ + | letValue _ matched _ valueIH bodyIH => + intro heap locals related + obtain ⟨source, middle, valueEval, first, input⟩ := valueIH heap locals related + obtain ⟨bindings, matchSource, bindingRep⟩ := option_related_some + (by rw [← matched]; exact Pattern.represents _ input) + obtain ⟨result, after, bodyEval, second, output⟩ := + bodyIH middle (bindings ++ locals) (List.rel_append bindingRep (related.mono first)) + exact ⟨result, after, .letValue valueEval matchSource bodyEval, first.trans second, output⟩ + | store _ cell ih => + intro heap locals related + obtain ⟨source, middle, evaluated, grows, result⟩ := ih heap locals related + have appends : middle <+: middle ++ [source] := ⟨[source], rfl⟩ + exact ⟨.ptr source.type middle.length, middle ++ [source], .store evaluated, + grows.trans appends, .ptr (by simp) cell (result.mono appends)⟩ + | load _ cell shape ih => + intro heap locals related + obtain ⟨pointer, after, evaluated, grows, pointerRep⟩ := ih heap locals related + cases pointerRep with + | ptr source stored content => + have same := ROM.functional valid stored cell shape.symm + subst_vars + exact ⟨_, after, .load evaluated (by simp [loadValue, source, pure, Except.pure, bind, Except.bind]), grows, content⟩ + | neg _ operation ih => + intro heap locals related + obtain ⟨source, after, evaluated, grows, result⟩ := ih heap locals related + obtain ⟨value, operation, result⟩ := result.neg operation + exact ⟨value, after, .neg evaluated operation, grows, result⟩ + | @hint locals expr input type channel _ constant typed ih => + intro heap sourceLocals related + obtain ⟨key, after, keyEval, grows, _⟩ := ih heap sourceLocals related + refine ⟨constant.toValue, after, .hint keyEval typed, grows, ?_⟩ + simpa only [Constant.toValue_mapAddress] using + (Represents.of_pointerFree (rom := rom) (heap := after) constant.toValue + (Constant.toValue_pointerFree constant) (fun _ => (0 : F))) + | assertEq _ _ operation leftIH rightIH => + intro heap locals related + obtain ⟨left, middle, leftEval, first, leftRep⟩ := leftIH heap locals related + obtain ⟨right, after, rightEval, second, rightRep⟩ := rightIH middle locals (related.mono first) + obtain ⟨value, operation, result⟩ := (leftRep.mono second).assertEq rightRep operation + exact ⟨value, after, .assertEq leftEval rightEval operation, first.trans second, result⟩ + | binary _ _ operation leftIH rightIH => + intro heap locals related + obtain ⟨left, middle, leftEval, first, leftRep⟩ := leftIH heap locals related + obtain ⟨right, after, rightEval, second, rightRep⟩ := rightIH middle locals (related.mono first) + obtain ⟨value, operation, result⟩ := (leftRep.mono second).binary rightRep operation + exact ⟨value, after, .binary leftEval rightEval operation, first.trans second, result⟩ + | call _ _ argsIH callIH => + intro heap locals related + obtain ⟨args, middle, argsEval, first, argsRep⟩ := argsIH heap locals related + obtain ⟨value, after, callEval, second, result⟩ := callIH middle args argsRep + exact ⟨value, after, .call argsEval callEval, first.trans second, result⟩ + | matchValue _ selected _ valueIH bodyIH => + intro heap locals related + obtain ⟨source, middle, valueEval, first, input⟩ := valueIH heap locals related + obtain ⟨⟨bindings, body⟩, selectedSource, bindingRep, same⟩ := option_related_some + (by rw [← selected]; exact selectArm_represents input _) + dsimp at same + subst body + obtain ⟨result, after, bodyEval, second, output⟩ := + bodyIH middle (bindings ++ locals) (List.rel_append bindingRep (related.mono first)) + exact ⟨result, after, .matchValue valueEval selectedSource bodyEval, first.trans second, output⟩ + | nil => rename_i heap locals related; exact ⟨[], heap, .nil, List.prefix_refl _, .nil⟩ + | cons _ _ headIH tailIH => + rename_i heap locals related + obtain ⟨head, middle, headEval, first, headRep⟩ := headIH heap locals related + obtain ⟨tail, after, tailEval, second, tailRep⟩ := tailIH middle locals (related.mono first) + exact ⟨head :: tail, after, .cons headEval tailEval, first.trans second, + .cons (headRep.mono second) tailRep⟩ + | intro prepared _ bodyIH => + rename_i heap sources related + obtain ⟨locals, preparedSource, environment⟩ := prepareCall_represents related prepared + obtain ⟨value, after, evaluated, grows, result⟩ := bodyIH heap locals environment + exact ⟨value, after, .intro preparedSource evaluated, grows, result⟩ + +theorem ROMEvalCall.realize [Field F] [DecidableEq F] (valid : rom.Valid) + {program : Program F} {name : String} {args : List (Value F)} {result : Value F} + (evaluated : ROMEvalCall rom program name args result) + {heap : Heap F} {sources : List (SourceValue F)} (related : RepresentsArgs rom heap sources args) : + ∃ source after, EvalFn program name sources heap source after ∧ heap <+: after ∧ + Represents rom after source result := by + cases evaluated with + | intro prepared body => + obtain ⟨locals, prepareSource, environment⟩ := prepareCall_represents related prepared + obtain ⟨source, after, evaluated, grows, output⟩ := body.realize valid heap locals environment + exact ⟨source, after, .intro prepareSource evaluated, grows, output⟩ + +end Aiur diff --git a/Aiur/Aiur/Memory/Typing.lean b/Aiur/Aiur/Memory/Typing.lean new file mode 100644 index 000000000..19a81242f --- /dev/null +++ b/Aiur/Aiur/Memory/Typing.lean @@ -0,0 +1,290 @@ +import Aiur.Memory.ValueNames +import Aiur.TypecheckFacts + +namespace Aiur + +theorem parameterTypes (params : List (String × Ty)) (args : List (Value F A)) + (types : params.map Prod.snd = args.map Value.type) : + environmentTypes ((params.map Prod.fst).zip args) = params := by + induction params generalizing args with + | nil => cases args <;> simp_all [environmentTypes] + | cons param params ih => + cases args with + | nil => simp at types + | cons arg args => + simp only [List.map_cons, List.cons.injEq] at types + simp only [List.map_cons, List.zip_cons_cons, environmentTypes, List.map_cons] + rw [← types.1] + exact congrArg (param :: ·) (ih args types.2) + +/-- Checked source execution preserves constructor payloads, pointer annotations, and every stored cell. -/ +theorem EvalExpr.wellTyped [Field F] [DecidableEq F] {program : Program F} + (checkedProgram : typecheck program = .ok ()) + {locals : Environment F Nat} {expr : Expr F} {result : SourceValue F} {before after : Heap F} + (evaluated : EvalExpr program locals expr before result after) : + before.Good program.enums → locals.Good program.enums → ∀ caller type, + inferType program caller (environmentTypes locals) expr = .ok type → + result.type = type ∧ result.Good program.enums ∧ after.Good program.enums := by + induction evaluated using EvalExpr.rec + (motive_2 := fun locals exprs before values after _ => before.Good program.enums → + locals.Good program.enums → ∀ caller types, + inferTypes program caller (environmentTypes locals) exprs = .ok types → + values.map Value.type = types ∧ (∀ value ∈ values, value.Good program.enums) ∧ after.Good program.enums) + (motive_3 := fun name args before value after _ => before.Good program.enums → + (∀ arg ∈ args, arg.PointerNames program.enums) → ∀ fn, program.findSignature? name = some fn → + value.type = fn.result ∧ value.Good program.enums ∧ after.Good program.enums) with + | literal => + intro memory formed caller type checked + exact ⟨by simpa [inferType, Value.type, pure, Except.pure] using checked, by simp, memory⟩ + | var lookup => + intro memory formed caller type checked + refine ⟨?_, formed _ (List.mem_of_find?_eq_some lookup), memory⟩ + simpa [inferType, environmentTypes, List.find?_map, Function.comp_def, lookup, + pure, Except.pure] using checked + | hint _ typed ih => + intro memory formed caller type checked + simp only [inferType] at checked + obtain ⟨keyType, keyRun, checked⟩ := except_bind_ok.mp checked + have heapGood := (ih memory formed caller keyType keyRun).2.2 + obtain ⟨_, _, checked⟩ := except_bind_ok.mp checked + obtain ⟨rfl, _⟩ := checkHintType_ok checked + have typed := (by simpa [Value.WellTyped, Value.hasType] using typed) + exact ⟨by simpa using typed.1, + ⟨by simpa using typed.2, Value.pointerNames_of_free (Constant.toValue_pointerFree _)⟩, heapGood⟩ + | tuple _ ih => + intro memory formed caller type checked + simp only [inferType] at checked + obtain ⟨types, itemsRun, finished⟩ := except_bind_ok.mp checked + obtain rfl := except_pure_ok.mp finished + obtain ⟨shape, valuesGood, heapGood⟩ := ih memory formed caller types itemsRun + exact ⟨by simp [Value.type, shape], (Value.good_tuple _ _).mpr valuesGood, heapGood⟩ + | @construct locals exprs before values after name ctor _ ih => + intro memory formed caller type checked + cases found : program.enums.findConstructor? name ctor with + | none => simp [inferType, found] at checked + | some definition => + simp only [inferType, found] at checked + split at checked + · cases checked + · rename_i arity + simp only [pure_bind] at checked + obtain ⟨types, argsRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨finished, typesRun, rest⟩ := except_bind_ok.mp rest + cases finished + obtain rfl := except_pure_ok.mp rest + obtain ⟨shape, valuesGood, heapGood⟩ := ih memory formed caller types argsRun + have length : definition.fields.length = types.length := by + have len := inferTypes_length argsRun + have arity : exprs.length = definition.fields.length := by simpa using arity + omega + have combined := congrArg (fun r : Except CheckError PUnit => r >>= fun _ => + (pure () : Except CheckError Unit)) typesRun + have typesEq := requireTypes_ok (caller := caller) length + (by simpa only [bind, Except.bind, pure, Except.pure] using combined) + refine ⟨by simp [Value.type], ⟨?_, ?_⟩, heapGood⟩ + · exact (Value.wellFormed_construct _ _ _ _).mpr + ⟨definition, found, shape.trans typesEq.symm, fun v h => (valuesGood v h).1⟩ + · exact (Value.pointerNames_construct _ _ _ _).mpr (fun v h => (valuesGood v h).2) + | @project locals expr before input after index result _ projected ih => + intro memory formed caller type checked + simp only [inferType] at checked + obtain ⟨inputType, inputRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨inputShape, inputGood, heapGood⟩ := ih memory formed caller inputType inputRun + cases input with + | field | ptr | construct => cases projected + | tuple values => + simp only [Value.type] at inputShape + subst inputType + cases found : (values.map Value.type)[index]? with + | none => simp [found] at rest + | some itemType => + simp only [found, except_pure_ok] at rest + subst type + cases source : values[index]? with + | none => simp [projectValue, source] at projected + | some value => + simp [projectValue, source, pure, Except.pure] at projected + subst result + refine ⟨?_, (Value.good_tuple _ _).mp inputGood _ (List.mem_of_getElem? source), heapGood⟩ + simpa [List.getElem?_map, source] using found + | letValue _ matched _ valueIH bodyIH => + intro memory formed caller type checked + simp only [inferType] at checked + obtain ⟨valueType, valueRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨bindingTypes, patternRun, rest⟩ := except_bind_ok.mp rest + obtain ⟨shape, inputGood, heapGood⟩ := valueIH memory formed caller valueType valueRun + have bindings := patternTypes_bindings (caller := caller) + (by rw [shape]; exact checkPattern_types patternRun) inputGood.1 matched + exact bodyIH heapGood (Environment.good_append.mpr + ⟨Pattern.bindings_good inputGood matched, formed⟩) caller type + (by simpa only [environmentTypes_append, bindings] using rest) + | store _ ih => + intro memory formed caller type checked + simp only [inferType] at checked + obtain ⟨inputType, inputRun, rest⟩ := except_bind_ok.mp checked + obtain rfl := except_pure_ok.mp rest + obtain ⟨shape, inputGood, heapGood⟩ := ih memory formed caller inputType inputRun + refine ⟨by simp [Value.type, shape], ⟨by simp, ?_⟩, ?_⟩ + · simpa only [Value.PointerNames] using Value.type_names inputGood.1 inputGood.2 + · simpa only [Heap.Good, List.mem_append, List.mem_singleton, or_imp, forall_and, + forall_eq] using And.intro heapGood inputGood + | @load locals expr before input after result _ loaded ih => + intro memory formed caller type checked + simp only [inferType] at checked + obtain ⟨inputType, inputRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨pointerShape, _, heapGood⟩ := ih memory formed caller inputType inputRun + cases input with + | field | tuple | construct => cases loaded + | ptr target address => + simp only [Value.type] at pointerShape + subst inputType + obtain rfl := except_pure_ok.mp rest + cases found : after[address]? with + | none => simp [loadValue, found] at loaded + | some stored => + by_cases typed : stored.type = target + · simp [loadValue, found, typed, bind, Except.bind, pure, Except.pure] at loaded + subst result + exact ⟨typed, heapGood _ (List.mem_of_getElem? found), heapGood⟩ + · simp [loadValue, found, typed] at loaded + | @neg locals expr before input after result _ operation ih => + intro memory formed caller type checked + simp only [inferType] at checked + obtain ⟨inputType, inputRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨finished, _, rest⟩ := except_bind_ok.mp rest + obtain rfl := except_pure_ok.mp rest + have heapGood := (ih memory formed caller inputType inputRun).2.2 + cases input with + | field x => cases operation; exact ⟨by simp [Value.type], by simp, heapGood⟩ + | tuple | ptr | construct => cases operation + | @assertEq locals lhs before x middle rhs y after op result _ _ operation leftIH rightIH => + intro memory formed caller type checked + simp only [inferType] at checked + obtain ⟨leftType, leftRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨rightType, rightRun, rest⟩ := except_bind_ok.mp rest + obtain ⟨finished, _, rest⟩ := except_bind_ok.mp rest + have resultUnit := (evalAssertEq_ok.mp operation).2.2 + subst result + split at rest + · simp [bind, Except.bind] at rest + · have same : type = .tuple [] := by simpa [bind, Except.bind, pure, Except.pure] using rest.symm + subst type + have heapGood := (rightIH (leftIH memory formed caller leftType leftRun).2.2 formed caller rightType rightRun).2.2 + exact ⟨by simp [Value.type], by simp, heapGood⟩ + | @binary locals lhs before x middle rhs y after op result _ _ operation leftIH rightIH => + intro memory formed caller type checked + simp only [inferType] at checked + obtain ⟨leftType, leftRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨finished, _, rest⟩ := except_bind_ok.mp rest + obtain ⟨rightType, rightRun, rest⟩ := except_bind_ok.mp rest + obtain ⟨finished, _, rest⟩ := except_bind_ok.mp rest + obtain rfl := except_pure_ok.mp rest + have heapGood := (rightIH (leftIH memory formed caller leftType leftRun).2.2 formed caller rightType rightRun).2.2 + cases x with + | tuple | ptr | construct => cases operation + | field x => + cases y with + | tuple | ptr | construct => cases operation + | field y => + cases op <;> simp only [evalBinOp] at operation + all_goals first + | (split at operation <;> cases operation; exact ⟨by simp [Value.type], by simp, heapGood⟩) + | (cases operation; exact ⟨by simp [Value.type], by simp, heapGood⟩) + | @call locals args before values middle name result after _ _ argsIH callIH => + intro memory formed caller type checked + cases found : program.findSignature? name with + | none => simp [inferType, found] at checked + | some fn => + simp only [inferType, found] at checked + split at checked + · cases checked + · simp only [pure_bind] at checked + obtain ⟨types, argsRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨finished, _, rest⟩ := except_bind_ok.mp rest + obtain rfl := except_pure_ok.mp rest + obtain ⟨_, valuesGood, heapGood⟩ := argsIH memory formed caller types argsRun + exact callIH heapGood (fun v h => (valuesGood v h).2) fn found + | @matchValue locals expr before input middle arms bindings body result after _ selected _ valueIH bodyIH => + intro memory formed caller type checked + simp only [inferType] at checked + obtain ⟨inputType, inputRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨shape, inputGood, heapGood⟩ := valueIH memory formed caller inputType inputRun + cases arms with + | nil => simp [selectArm] at selected + | cons arm arms => + rcases arm with ⟨pattern, branch⟩ + obtain ⟨bindingTypes, patternRun, rest⟩ := except_bind_ok.mp rest + obtain ⟨branchType, branchRun, rest⟩ := except_bind_ok.mp rest + obtain ⟨finished, armsRun, rest⟩ := except_bind_ok.mp rest + cases finished + obtain rfl := except_pure_ok.mp rest + have allChecked : checkArms program caller (environmentTypes locals) input.type branchType + ((pattern, branch) :: arms) = .ok () := by + rw [shape] + simp [checkArms, patternRun, branchRun, requireType, armsRun, bind, Except.bind] + exact bodyIH heapGood (Environment.good_append.mpr + ⟨selectArm_good inputGood selected, formed⟩) caller branchType (by + simpa only [environmentTypes_append] using checkArms_selected allChecked inputGood.1 selected) + | nil => + rename_i memory formed caller types checked + simp only [inferTypes, except_pure_ok] at checked + subst types + exact ⟨rfl, by simp, memory⟩ + | cons _ _ headIH tailIH => + rename_i memory formed caller types checked + simp only [inferTypes] at checked + obtain ⟨headType, headRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨tailTypes, tailRun, rest⟩ := except_bind_ok.mp rest + obtain rfl := except_pure_ok.mp rest + obtain ⟨headType, headGood, middleGood⟩ := headIH memory formed caller headType headRun + obtain ⟨tailTypes, tailGood, heapGood⟩ := tailIH middleGood formed caller tailTypes tailRun + exact ⟨by simp [headType, tailTypes], by simpa [headGood] using tailGood, heapGood⟩ + | intro prepared evaluated bodyIH => + rename_i memory names signature found + rcases prepareCall_spec prepared with function | table + · obtain ⟨fn, sourceFound, types, formed, rfl, rfl⟩ := function + have same := Option.some.inj (found.symm.trans (Program.signature_of_function sourceFound)) + subst signature + refine bodyIH memory ?_ fn.name fn.result ?_ + · intro binding member + have argMember := (List.of_mem_zip member).2 + exact ⟨formed _ argMember, names _ argMember⟩ + · rw [parameterTypes _ _ types] + exact typecheck_function checkedProgram (List.mem_of_find?_eq_some sourceFound) + · obtain ⟨constant, absent, looked, rfl, rfl⟩ := table + obtain ⟨map, key, mapFound, _, _, _, _, typed⟩ := lookupMap_spec looked + have same := Option.some.inj (found.symm.trans (Program.signature_of_map absent mapFound)) + subst signature + obtain ⟨rfl, rfl⟩ := EvalExpr.constant_result constant evaluated + have typed : constant.type = map.result ∧ constant.wellFormed program.enums = true := by + simpa [Value.hasType] using typed + exact ⟨by simpa using typed.1, ⟨by simpa using typed.2, + Value.pointerNames_of_free (Constant.toValue_pointerFree constant)⟩, memory⟩ + +theorem EvalFn.heap_good [Field F] [DecidableEq F] {program : Program F} + (checked : typecheck program = .ok ()) {name : String} {args : List (SourceValue F)} + {before after : Heap F} {result : SourceValue F} + (evaluated : EvalFn program name args before result after) (memory : before.Good program.enums) + (names : ∀ arg ∈ args, arg.PointerNames program.enums) : + result.Good program.enums ∧ after.Good program.enums := by + cases evaluated with + | intro prepared body => + rcases prepareCall_spec prepared with function | table + · obtain ⟨fn, found, types, formed, rfl, rfl⟩ := function + have localsGood : Environment.Good program.enums ((fn.params.map Prod.fst).zip args) := by + intro binding member + have argMember := (List.of_mem_zip member).2 + exact ⟨formed _ argMember, names _ argMember⟩ + exact (body.wellTyped checked memory localsGood fn.name fn.result (by + rw [parameterTypes _ _ types] + exact typecheck_function checked (List.mem_of_find?_eq_some found))).2 + · obtain ⟨constant, _, looked, rfl, rfl⟩ := table + obtain ⟨rfl, rfl⟩ := EvalExpr.constant_result constant body + obtain ⟨_, _, _, _, _, _, _, typed⟩ := lookupMap_spec looked + have formed : constant.wellFormed program.enums = true := by + simp only [Value.hasType, Bool.and_eq_true] at typed + exact typed.2 + exact ⟨⟨by simpa using formed, + Value.pointerNames_of_free (Constant.toValue_pointerFree constant)⟩, memory⟩ + +end Aiur diff --git a/Aiur/Aiur/Memory/ValueNames.lean b/Aiur/Aiur/Memory/ValueNames.lean new file mode 100644 index 000000000..1b2dbd436 --- /dev/null +++ b/Aiur/Aiur/Memory/ValueNames.lean @@ -0,0 +1,152 @@ +import Aiur.LayoutComposition +import Aiur.Memory.Encoding + +namespace Aiur + +/-- Every pointer annotation in a value names declared types, including nested payloads. -/ +def Value.PointerNames (decls : Declarations) : Value F A → Prop + | .field _ => True + | .ptr target _ => target.checkNames decls = .ok () + | .tuple values | .construct _ _ values => ∀ value ∈ values, value.PointerNames decls +termination_by value => sizeOf value + +@[simp] theorem Value.pointerNames_field (decls : Declarations) (x : F) : + (@Value.field F A x).PointerNames decls := by simp [PointerNames] + +@[simp] theorem Value.pointerNames_tuple (decls : Declarations) (values : List (Value F A)) : + (.tuple values : Value F A).PointerNames decls ↔ ∀ value ∈ values, value.PointerNames decls := by + rw [PointerNames] + +@[simp] theorem Value.pointerNames_construct (decls : Declarations) (name ctor : String) (values : List (Value F A)) : + (.construct name ctor values : Value F A).PointerNames decls ↔ ∀ value ∈ values, value.PointerNames decls := by + rw [PointerNames] + +theorem Value.pointerNames_of_free {decls : Declarations} {value : Value F A} + (free : value.pointerFree = true) : value.PointerNames decls := by + cases value with + | field => simp [PointerNames] + | ptr => simp [pointerFree] at free + | tuple values | construct name ctor values => + simp only [PointerNames] + simp only [pointerFree, List.all_map, List.all_eq_true] at free + intro value member + exact value.pointerNames_of_free (free value member) +termination_by sizeOf value + +theorem Value.type_names {decls : Declarations} {value : Value F A} + (formed : value.wellFormed decls = true) (names : value.PointerNames decls) : + value.type.checkNames decls = .ok () := by + cases value with + | field => simp [Value.type, Ty.checkNames] + | ptr => simpa only [PointerNames, Value.type, Ty.checkNames] using names + | tuple values => + simp only [Value.type, Ty.checkNames] + apply forIn_success + intro type member + obtain ⟨value, valueMember, rfl⟩ := List.mem_map.mp member + exact Value.type_names ((Value.wellFormed_tuple _ _).mp formed value valueMember) + ((Value.pointerNames_tuple _ _).mp names value valueMember) + | construct name ctor values => + obtain ⟨definition, found, _, _⟩ := (Value.wellFormed_construct _ _ _ _).mp formed + cases enumFound : decls.findEnum? name with + | none => simp [Declarations.findConstructor?, enumFound] at found + | some declaration => simp [Value.type, Ty.checkNames, enumFound] +termination_by sizeOf value + +def Value.Good (decls : Declarations) (value : Value F A) : Prop := + value.wellFormed decls = true ∧ value.PointerNames decls + +def Environment.Good (decls : Declarations) (locals : Environment F A) : Prop := + ∀ binding ∈ locals, binding.2.Good decls + +def Heap.Good (decls : Declarations) (heap : Heap F) : Prop := + ∀ value ∈ heap, value.Good decls + +theorem Environment.Good.formed {decls : Declarations} {locals : Environment F A} + (good : locals.Good decls) : locals.WellFormed decls := fun binding member => (good binding member).1 + +@[simp] theorem Environment.good_append {decls : Declarations} {left right : Environment F A} : + (left ++ right).Good decls ↔ left.Good decls ∧ right.Good decls := by + simp [Good, or_imp, forall_and] + +@[simp] theorem Value.good_field (decls : Declarations) (x : F) : (@Value.field F A x).Good decls := ⟨by simp, by simp⟩ + +@[simp] theorem Value.good_tuple (decls : Declarations) (values : List (Value F A)) : + (.tuple values : Value F A).Good decls ↔ ∀ value ∈ values, value.Good decls := by + simp [Good, forall_and] + +mutual + theorem Pattern.bindings_pointerNames [DecidableEq F] {decls : Declarations} + {pattern : Pattern F} {value : Value F A} {locals : Environment F A} + (names : value.PointerNames decls) (matched : pattern.bindings value = some locals) : + ∀ binding ∈ locals, binding.2.PointerNames decls := by + cases pattern with + | wildcard => simp only [Pattern.bindings, Option.some.injEq] at matched; subst locals; simp + | bind name => simp only [Pattern.bindings, Option.some.injEq] at matched; subst locals; simpa using names + | literal literal => + cases value with + | tuple | ptr | construct => simp [Pattern.bindings] at matched + | field x => + simp only [Pattern.bindings] at matched + split at matched + · cases matched; simp + · cases matched + | tuple patterns => + cases value with + | field | ptr | construct => simp [Pattern.bindings] at matched + | tuple values => + simp only [Pattern.bindings] at matched + exact Pattern.bindingsList_pointerNames (by simpa only [Value.PointerNames] using names) matched + | construct name ctor patterns => + cases value with + | field | tuple | ptr => simp [Pattern.bindings] at matched + | construct actual constructor values => + simp only [Pattern.bindings] at matched + split at matched + · exact Pattern.bindingsList_pointerNames (by simpa only [Value.PointerNames] using names) matched + · cases matched + termination_by sizeOf pattern + + theorem Pattern.bindingsList_pointerNames [DecidableEq F] {decls : Declarations} + {patterns : List (Pattern F)} {values : List (Value F A)} {locals : Environment F A} + (names : ∀ value ∈ values, value.PointerNames decls) + (matched : Pattern.bindingsList patterns values = some locals) : + ∀ binding ∈ locals, binding.2.PointerNames decls := by + cases patterns with + | nil => cases values <;> simp_all [Pattern.bindingsList] + | cons pattern patterns => + cases values with + | nil => simp [Pattern.bindingsList] at matched + | cons value values => + simp only [Pattern.bindingsList] at matched + obtain ⟨head, headRun, rest⟩ := Option.bind_eq_some_iff.mp matched + obtain ⟨tail, tailRun, finished⟩ := Option.bind_eq_some_iff.mp rest + simp only [Option.pure_def, Option.some.injEq] at finished + subst locals + have h := Pattern.bindings_pointerNames (names _ (by simp)) headRun + have t := Pattern.bindingsList_pointerNames (fun v hv => names v (by simp [hv])) tailRun + simpa only [List.mem_append, or_imp, forall_and] using And.intro h t + termination_by sizeOf patterns +end + +theorem Pattern.bindings_good [DecidableEq F] {decls : Declarations} + {pattern : Pattern F} {value : Value F A} {locals : Environment F A} + (good : value.Good decls) (matched : pattern.bindings value = some locals) : locals.Good decls := + fun binding member => ⟨Pattern.bindings_wellFormed good.1 matched binding member, + Pattern.bindings_pointerNames good.2 matched binding member⟩ + +theorem selectArm_good [DecidableEq F] {decls : Declarations} + {value : Value F A} {arms : List (Pattern F × Expr F)} {locals : Environment F A} {body : Expr F} + (good : value.Good decls) (selected : selectArm value arms = some (locals, body)) : locals.Good decls := by + induction arms with + | nil => simp [selectArm] at selected + | cons arm arms ih => + rcases arm with ⟨pattern, branch⟩ + cases matched : pattern.bindings value with + | none => exact ih (by simpa [selectArm, matched] using selected) + | some bindings => + simp [selectArm, matched] at selected + rcases selected with ⟨rfl, rfl⟩ + exact Pattern.bindings_good good matched + +end Aiur diff --git a/Aiur/Aiur/Memory/WidthCorrectness.lean b/Aiur/Aiur/Memory/WidthCorrectness.lean new file mode 100644 index 000000000..b8e3ef759 --- /dev/null +++ b/Aiur/Aiur/Memory/WidthCorrectness.lean @@ -0,0 +1,37 @@ +import Aiur.Memory.Partition +import Aiur.Optimized.Equivalence + +namespace Aiur.WidthROM + +variable {F : Type} [Field F] [DecidableEq F] + {program : Program F} {entries : List String} {config : Optimized.Config} + {artifact : Optimized.Artifact F} + +/-- The optimized compiler's entry soundness applies to untyped width-local +memory through static typed views. In particular, result canonicality follows +from the existing store-provenance induction without a tag in the ROM trace. +As with the compiler theorem, this assumes a finite derivation; the STARK +lookup argument itself is outside the Lean model. -/ +theorem compiler_entry_sound + (compiled : Optimized.compile program entries config = .ok artifact) + {rom : WidthROM F} (valid : rom.Valid) (types : List Ty) + {root : Circuit.Message F} (entry : root.channel ∈ entries) + (free : root.PublicArguments program.enums) + (derived : Circuit.Derives artifact.system (rom.toWireROM program.enums types) root) : + root.Evaluates program (rom.toWireROM program.enums types) := + Optimized.compiler_entry_sound compiled entry (rom.toWireROM_valid valid program.enums types) free derived + +/-- Erasing the physical ROM's types preserves the equivalence between the +reference compiler and all optimized layout passes, for finite entry proofs. -/ +theorem reference_derives_iff + {reference : Circuit.System F} (original : Circuit.compile program = .ok reference) + (compiled : Optimized.compile program entries config = .ok artifact) + {rom : WidthROM F} (valid : rom.Valid) (types : List Ty) + {root : Circuit.Message F} (entry : root.channel ∈ entries) + (free : root.PublicArguments program.enums) : + Circuit.Derives reference (rom.toWireROM program.enums types) root ↔ + Circuit.Derives artifact.system (rom.toWireROM program.enums types) root := + Optimized.reference_derives_iff original compiled entry + (rom.toWireROM_valid valid program.enums types) free + +end Aiur.WidthROM diff --git a/Aiur/Aiur/Memory/WireEncoding.lean b/Aiur/Aiur/Memory/WireEncoding.lean new file mode 100644 index 000000000..3a535420c --- /dev/null +++ b/Aiur/Aiur/Memory/WireEncoding.lean @@ -0,0 +1,81 @@ +import Aiur.Memory.Typing +import Aiur.DeclarationTotal +import Aiur.WireMemory + +namespace Aiur + +@[simp] theorem Value.pointerNames_mapAddress (decls : Declarations) (encode : A → B) (value : Value F A) : + (value.mapAddress encode).PointerNames decls ↔ value.PointerNames decls := by + cases value with + | field | ptr => simp only [Value.mapAddress, Value.PointerNames] + | tuple values | construct name ctor values => + simp only [Value.mapAddress, Value.PointerNames, List.forall_mem_map] + exact forall_congr' (fun v => imp_congr_right (fun _ => Value.pointerNames_mapAddress decls encode v)) +termination_by sizeOf value + +@[simp] theorem Value.good_mapAddress (decls : Declarations) (encode : A → B) (value : Value F A) : + (value.mapAddress encode).Good decls ↔ value.Good decls := by simp [Value.Good] + +/-- Well-formed source values have an encoding; field size is needed only to decode tags uniquely. -/ +theorem Value.encode_total [NatCast F] [Zero F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) {value : Value F} (good : value.Good decls) : + ∃ wire, value.encode decls = some wire := by + obtain ⟨layout, expanded⟩ := Declarations.layout_total checked (Value.type_names good.1 good.2) + obtain ⟨words, encoded⟩ := (Declarations.layout_describes expanded).encode_total rfl good.1 + exact ⟨⟨value.type, words⟩, by simp [Value.encode, good.1, expanded, Except.toOption, encoded]⟩ + +/-- Encode the values in a semantic table, keeping its addresses. -/ +def ROM.encode [NatCast F] [Zero F] (decls : Declarations) (rom : ROM F) : WireROM F := + ⟨rom.entries.filterMap (fun cell => (cell.2.encode decls).map (fun wire => (cell.1, wire)))⟩ + +theorem ROM.encode_addresses [NatCast F] [Zero F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) {rom : ROM F} + (good : ∀ cell ∈ rom.entries, cell.2.Good decls) : + ((rom.encode decls).entries.map Prod.fst) = rom.entries.map Prod.fst := by + rcases rom with ⟨entries⟩ + change ((entries.filterMap _).map Prod.fst) = entries.map Prod.fst + induction entries with + | nil => rfl + | cons cell entries ih => + obtain ⟨wire, encoded⟩ := Value.encode_total checked (good cell (by simp)) + simp only [List.filterMap_cons, encoded, Option.map_some, List.map_cons] + exact congrArg (cell.1 :: ·) (ih (fun c h => good c (by simp [h]))) + +theorem ROM.encode_valid [NatCast F] [Zero F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) {rom : ROM F} + (good : ∀ cell ∈ rom.entries, cell.2.Good decls) (valid : rom.Valid) : + (rom.encode decls).Valid := by + intro a ha b hb address types + obtain ⟨⟨la, lv⟩, lm, le⟩ := List.mem_filterMap.mp ha + obtain ⟨⟨ra, rv⟩, rm, re⟩ := List.mem_filterMap.mp hb + obtain ⟨lw, ld, rfl⟩ := Option.map_eq_some_iff.mp le + obtain ⟨rw, rd, rfl⟩ := Option.map_eq_some_iff.mp re + have typed : lv.type = rv.type := + (Value.encode_spec ld).2.1.symm.trans (types.trans (Value.encode_spec rd).2.1) + have same : lv = rv := valid _ lm _ rm address typed + rw [same, rd] at ld + exact (Option.some.inj ld).symm + +/-- The canonical table encoding decodes to exactly the same heterogeneous ROM. -/ +theorem ROM.decode_encode [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) (tags : decls.tagsValid F = true) {rom : ROM F} + (good : ∀ cell ∈ rom.entries, cell.2.Good decls) : (rom.encode decls).decode decls = rom := by + rcases rom with ⟨entries⟩ + apply congrArg ROM.mk + change (entries.filterMap _).filterMap _ = entries + induction entries with + | nil => rfl + | cons cell entries ih => + obtain ⟨wire, encoded⟩ := Value.encode_total checked (good cell (by simp)) + have decoded := Value.decode_encode encoded (fun _ => Declarations.layout_tagSafe tags) + simp only [List.filterMap_cons, encoded, Option.map_some, decoded] + exact congrArg (cell :: ·) (ih (fun c h => good c (by simp [h]))) + +theorem ROM.ofHeap_good {decls : Declarations} {heap : Heap F} + (good : heap.Good decls) (encode : Nat → F) : + ∀ cell ∈ (ROM.ofHeap heap encode).entries, cell.2.Good decls := by + intro cell member + obtain ⟨index, rfl⟩ := List.mem_ofFn.mp member + simpa using good heap[index] (List.getElem_mem _) + +end Aiur diff --git a/Aiur/Aiur/Memory/WireProvenance.lean b/Aiur/Aiur/Memory/WireProvenance.lean new file mode 100644 index 000000000..9e61ad007 --- /dev/null +++ b/Aiur/Aiur/Memory/WireProvenance.lean @@ -0,0 +1,322 @@ +import Aiur.WireMemory +import Aiur.Memory.Representation +import Aiur.Semantics.WithCalls + +namespace Aiur + +/-- Pointers have finite provenance through cells whose contents have the same +property. The rest of the ROM may contain malformed or unreachable cells. -/ +inductive ROM.Provenance (rom : ROM F) : Value F → Prop where + | field : rom.Provenance (.field value) + | tuple (items : ∀ value ∈ values, rom.Provenance value) : + rom.Provenance (.tuple values) + | construct (items : ∀ value ∈ values, rom.Provenance value) : + rom.Provenance (.construct name ctor values) + | ptr (cell : (address, stored) ∈ rom.entries) (contents : rom.Provenance stored) : + rom.Provenance (.ptr stored.type address) + +/-- A raw ROM cannot assign two encodings to one typed address. -/ +theorem WireROM.functional {rom : WireROM F} (valid : rom.Valid) + {address : F} {left right : WireValue F} + (first : (address, left) ∈ rom.entries) (second : (address, right) ∈ rom.entries) + (typed : left.type = right.type) : left = right := + valid _ first _ second rfl typed + +variable {F : Type} {rom : ROM F} + +theorem ROM.Provenance.of_pointerFree (value : Value F) + (free : value.pointerFree = true) : rom.Provenance value := by + cases value with + | field => exact .field + | ptr => simp [Value.pointerFree] at free + | tuple values | construct name ctor values => + have items : ∀ value ∈ values, value.pointerFree = true := by + simpa [Value.pointerFree] using free + first | apply ROM.Provenance.tuple | apply ROM.Provenance.construct + exact fun value member => .of_pointerFree value (items value member) +termination_by sizeOf value + +@[simp] theorem ROM.Provenance.tuple_iff {values : List (Value F)} : + rom.Provenance (.tuple values) ↔ ∀ value ∈ values, rom.Provenance value := by + constructor + · intro trusted; cases trusted; assumption + · exact .tuple + +@[simp] theorem ROM.Provenance.construct_iff {name ctor : String} {values : List (Value F)} : + rom.Provenance (.construct name ctor values) ↔ ∀ value ∈ values, rom.Provenance value := by + constructor + · intro trusted; cases trusted; assumption + · exact .construct + +theorem ROM.Provenance.load {target : Ty} {address : F} {value : Value F} + (trusted : rom.Provenance (.ptr target address)) (valid : rom.Valid) + (cell : (address, value) ∈ rom.entries) (typed : value.type = target) : rom.Provenance value := by + cases trusted with + | ptr stored contents => + have same := ROM.functional valid stored cell typed.symm + simpa only [same] using contents + +/-- Once an address has store provenance, a raw load's existing ROM lookup +already guarantees that its payload decodes. No independent enum validation is +required at the load. -/ +theorem WireROM.load_of_provenance [NatCast F] [Zero F] [DecidableEq F] + {decls : Declarations} {wireRom : WireROM F} (valid : wireRom.Valid) + {target : Ty} {address : F} {wire : WireValue F} + (trusted : (wireRom.decode decls).Provenance (.ptr target address)) + (cell : (address, wire) ∈ wireRom.entries) (typed : wire.type = target) : + ∃ value, wire.decode decls = some value ∧ value.type = target ∧ + (wireRom.decode decls).Provenance value := by + cases trusted with + | ptr storedCell contents => + obtain ⟨encoded, original, decoded⟩ := WireROM.mem_decode.mp storedCell + have same := WireROM.functional valid original cell ((WireValue.decode_spec decoded).1.symm.trans typed.symm) + exact ⟨_, same ▸ decoded, rfl, contents⟩ + +/-- Provenance is required only for the values available to the expression. -/ +def Environment.Provenance (rom : ROM F) (locals : Environment F) : Prop := + ∀ binding ∈ locals, rom.Provenance binding.2 + +@[simp] theorem Environment.provenance_append {left right : Environment F} : + (left ++ right).Provenance rom ↔ left.Provenance rom ∧ right.Provenance rom := by + simp [Provenance, or_imp, forall_and] + +theorem Environment.Provenance.lookup {locals : Environment F} {name : String} {value : Value F} + (trusted : locals.Provenance rom) + (found : locals.find? (·.1 == name) = some (name, value)) : rom.Provenance value := + trusted _ (List.mem_of_find?_eq_some found) + +theorem ROM.Provenance.project {input result : Value F} {index : Nat} + (trusted : rom.Provenance input) (projected : projectValue input index = .ok result) : + rom.Provenance result := by + cases trusted with + | field | ptr | construct => cases projected + | tuple items => + simp only [projectValue] at projected + split at projected + · cases projected + exact items _ (List.mem_of_getElem? ‹_›) + · cases projected + +mutual + theorem Pattern.bindings_provenance [DecidableEq F] + {pattern : Pattern F} {value : Value F} {locals : Environment F} + (trusted : rom.Provenance value) (matched : pattern.bindings value = some locals) : + locals.Provenance rom := by + cases pattern with + | wildcard => + simp only [Pattern.bindings, Option.some.injEq] at matched + subst locals + simp [Environment.Provenance] + | bind name => + simp only [Pattern.bindings, Option.some.injEq] at matched + subst locals + simpa [Environment.Provenance] using trusted + | literal literal => + cases value with + | tuple | ptr | construct => simp [Pattern.bindings] at matched + | field x => + simp only [Pattern.bindings] at matched + split at matched + · cases matched; simp [Environment.Provenance] + · cases matched + | tuple patterns => + cases value with + | field | ptr | construct => simp [Pattern.bindings] at matched + | tuple values => + simp only [Pattern.bindings] at matched + exact Pattern.bindingsList_provenance (ROM.Provenance.tuple_iff.mp trusted) matched + | construct name ctor patterns => + cases value with + | field | tuple | ptr => simp [Pattern.bindings] at matched + | construct actual constructor values => + simp only [Pattern.bindings] at matched + split at matched + · exact Pattern.bindingsList_provenance (ROM.Provenance.construct_iff.mp trusted) matched + · cases matched + termination_by sizeOf pattern + + theorem Pattern.bindingsList_provenance [DecidableEq F] + {patterns : List (Pattern F)} {values : List (Value F)} {locals : Environment F} + (trusted : ∀ value ∈ values, rom.Provenance value) + (matched : Pattern.bindingsList patterns values = some locals) : locals.Provenance rom := by + cases patterns with + | nil => cases values <;> simp_all [Pattern.bindingsList, Environment.Provenance] + | cons pattern patterns => + cases values with + | nil => simp [Pattern.bindingsList] at matched + | cons value values => + simp only [Pattern.bindingsList] at matched + obtain ⟨head, headRun, rest⟩ := Option.bind_eq_some_iff.mp matched + obtain ⟨tail, tailRun, finished⟩ := Option.bind_eq_some_iff.mp rest + simp only [Option.pure_def, Option.some.injEq] at finished + subst locals + exact Environment.provenance_append.mpr + ⟨Pattern.bindings_provenance (trusted _ (by simp)) headRun, + Pattern.bindingsList_provenance (fun v h => trusted v (by simp [h])) tailRun⟩ + termination_by sizeOf patterns +end + +theorem selectArm_provenance [DecidableEq F] + {value : Value F} {arms : List (Pattern F × Expr F)} {locals : Environment F} {body : Expr F} + (trusted : rom.Provenance value) (selected : selectArm value arms = some (locals, body)) : + locals.Provenance rom := by + induction arms with + | nil => simp [selectArm] at selected + | cons arm arms ih => + rcases arm with ⟨pattern, branch⟩ + cases matched : pattern.bindings value with + | none => exact ih (by simpa [selectArm, matched] using selected) + | some bindings => + simp [selectArm, matched] at selected + rcases selected with ⟨rfl, rfl⟩ + exact Pattern.bindings_provenance trusted matched + +theorem ROM.Provenance.neg [Field F] {input result : Value F} + (operation : evalNeg input = .ok result) : rom.Provenance result := by + cases input with + | field => cases operation; exact .field + | tuple | construct | ptr => cases operation + +theorem ROM.Provenance.binary [Field F] [DecidableEq F] + {left right result : Value F} {op : BinOp} + (operation : evalBinOp op left right = .ok result) : rom.Provenance result := by + cases left with + | tuple | construct | ptr => cases operation + | field => + cases right with + | tuple | construct | ptr => cases operation + | field => + cases op with + | add | sub | mul => cases operation; exact .field + | div => + simp only [evalBinOp] at operation + split at operation + · cases operation + · cases operation; exact .field + +theorem ROM.Provenance.assertEq [DecidableEq F] + {left right result : Value F} {message : Assertion} + (operation : evalAssertEq message left right = .ok result) : rom.Provenance result := by + obtain ⟨_, _, rfl⟩ := evalAssertEq_ok.mp operation + exact .tuple (by simp) + +/-- Evaluation propagates pointer provenance. Calls need only preserve it when +their arguments have provenance; the theorem imposes no condition on unrelated +rows or calls with fabricated pointer arguments. -/ +theorem ROMEvalExprWith.provenance [Field F] [DecidableEq F] + {decls : Declarations} {calls : CallRelation F} + {locals : Environment F} {expr : Expr F} {result : Value F} + (evaluated : ROMEvalExprWith decls rom calls locals expr result) + (valid : rom.Valid) + (callProvenance : ∀ name args result, calls name args result → + (∀ value ∈ args, rom.Provenance value) → rom.Provenance result) + (trusted : locals.Provenance rom) : rom.Provenance result := by + revert trusted + induction evaluated using ROMEvalExprWith.rec + (motive_2 := fun locals _ values _ => + locals.Provenance rom → ∀ value ∈ values, rom.Provenance value) with + | literal => intro _; exact .field + | var found => intro env; exact env.lookup found + | tuple _ ih => intro env; exact .tuple (ih env) + | construct _ ih => intro env; exact .construct (ih env) + | project _ projected ih => intro env; exact (ih env).project projected + | letValue _ matched _ valueIH bodyIH => + intro env + exact bodyIH (Environment.provenance_append.mpr + ⟨Pattern.bindings_provenance (valueIH env) matched, env⟩) + | store _ cell ih => intro env; exact .ptr cell (ih env) + | load _ cell typed ih => intro env; exact (ih env).load valid cell typed + | @hint locals expr input type channel _ constant typed ih => + intro _ + exact .of_pointerFree _ (Constant.toValue_pointerFree constant) + | neg _ operation _ => intro _; exact .neg operation + | assertEq _ _ operation _ _ => intro _; exact .assertEq operation + | binary _ _ operation _ _ => intro _; exact .binary operation + | call _ callee ih => intro env; exact callProvenance _ _ _ callee (ih env) + | matchValue _ selected _ valueIH bodyIH => + intro env + exact bodyIH (Environment.provenance_append.mpr + ⟨selectArm_provenance (valueIH env) selected, env⟩) + | nil => simp_all + | cons _ _ headIH tailIH => + rename_i env value member + rcases List.mem_cons.mp member with rfl | member + · exact headIH env + · exact tailIH env value member + +theorem ROMEvalArgsWith.provenance [Field F] [DecidableEq F] + {decls : Declarations} {calls : CallRelation F} + {locals : Environment F} {exprs : List (Expr F)} {values : List (Value F)} + (evaluated : ROMEvalArgsWith decls rom calls locals exprs values) + (valid : rom.Valid) + (callProvenance : ∀ name args result, calls name args result → + (∀ value ∈ args, rom.Provenance value) → rom.Provenance result) + (trusted : locals.Provenance rom) : ∀ value ∈ values, rom.Provenance value := + ROM.Provenance.tuple_iff.mp + ((ROMEvalExprWith.tuple evaluated).provenance valid callProvenance trusted) + +theorem prepareCall_provenance [DecidableEq F] + {program : Program F} {name : String} {args : List (Value F)} + {locals : Environment F} {expr : Expr F} + (prepared : prepareCall program name args = .ok (locals, expr)) + (trusted : ∀ value ∈ args, rom.Provenance value) : locals.Provenance rom := by + rcases prepareCall_spec prepared with function | table + · obtain ⟨fn, _, _, _, rfl, _⟩ := function + exact fun binding member => trusted binding.2 (List.of_mem_zip member).2 + · obtain ⟨constant, _, _, rfl, _⟩ := table + simp [Environment.Provenance] + +/-- Actual function evaluation also preserves provenance, including through +mutual recursion. Finiteness comes from its derivation, not a totality premise. -/ +theorem ROMEvalExpr.provenance [Field F] [DecidableEq F] + {program : Program F} {locals : Environment F} {expr : Expr F} {result : Value F} + (evaluated : ROMEvalExpr rom program locals expr result) + (valid : rom.Valid) (trusted : locals.Provenance rom) : rom.Provenance result := by + revert trusted + induction evaluated using ROMEvalExpr.rec + (motive_2 := fun locals _ values _ => + locals.Provenance rom → ∀ value ∈ values, rom.Provenance value) + (motive_3 := fun _ args result _ => + (∀ value ∈ args, rom.Provenance value) → rom.Provenance result) with + | literal => intro _; exact .field + | var found => intro env; exact env.lookup found + | tuple _ ih => intro env; exact .tuple (ih env) + | construct _ ih => intro env; exact .construct (ih env) + | project _ projected ih => intro env; exact (ih env).project projected + | letValue _ matched _ valueIH bodyIH => + intro env + exact bodyIH (Environment.provenance_append.mpr + ⟨Pattern.bindings_provenance (valueIH env) matched, env⟩) + | store _ cell ih => intro env; exact .ptr cell (ih env) + | load _ cell typed ih => intro env; exact (ih env).load valid cell typed + | @hint locals expr input type channel _ constant typed ih => + intro _ + exact .of_pointerFree _ (Constant.toValue_pointerFree constant) + | neg _ operation _ => intro _; exact .neg operation + | assertEq _ _ operation _ _ => intro _; exact .assertEq operation + | binary _ _ operation _ _ => intro _; exact .binary operation + | call _ _ argsIH calleeIH => intro env; exact calleeIH (argsIH env) + | matchValue _ selected _ valueIH bodyIH => + intro env + exact bodyIH (Environment.provenance_append.mpr + ⟨selectArm_provenance (valueIH env) selected, env⟩) + | nil => simp_all + | cons _ _ headIH tailIH => + rename_i env value member + rcases List.mem_cons.mp member with rfl | member + · exact headIH env + · exact tailIH env value member + | intro prepared _ bodyIH => + rename_i argsTrusted + exact bodyIH (prepareCall_provenance prepared argsTrusted) + +theorem ROMEvalCall.provenance [Field F] [DecidableEq F] + {program : Program F} {name : String} {args : List (Value F)} {result : Value F} + (evaluated : ROMEvalCall rom program name args result) + (valid : rom.Valid) (trusted : ∀ value ∈ args, rom.Provenance value) : + rom.Provenance result := by + cases evaluated with + | intro prepared body => + exact body.provenance valid (prepareCall_provenance prepared trusted) + +end Aiur diff --git a/Aiur/Aiur/MemoryCorrectness.lean b/Aiur/Aiur/MemoryCorrectness.lean new file mode 100644 index 000000000..d8e80da27 --- /dev/null +++ b/Aiur/Aiur/MemoryCorrectness.lean @@ -0,0 +1,193 @@ +import Aiur.Memory.Soundness +import Aiur.Memory.Completeness +import Aiur.Memory.WireEncoding +import Aiur.Completeness +import Aiur.MemoSoundness +import Aiur.Circuit.Entry +import Aiur.EvalCorrectness +import Aiur.InputTypes + +namespace Aiur + +/-- Canonical entry values: the address map is immaterial because arguments contain no pointers. -/ +def entryValues [Zero F] (args : List (SourceValue F)) : List (Value F) := + args.map (Value.mapAddress (fun _ => 0)) + +theorem entryValues_eq [Zero F] {args : List (SourceValue F)} + (free : ∀ value ∈ args, value.pointerFree = true) (encode : Nat → F) : + args.map (Value.mapAddress encode) = entryValues args := + List.map_congr_left (fun value member => value.mapAddress_free (free value member) _ _) + +/-- Public acceptance of the canonical flat encodings of semantic entry values. -/ +def Circuit.EncodedEntryDerives [Field F] [DecidableEq F] (system : Circuit.System F) + (name : String) (args : List (Value F)) (result : Value F) : Prop := + ∃ wires output, DecodesValues system.enums wires args ∧ output.decode system.enums = some result ∧ + Circuit.EntryDerives system ⟨name, wires, output⟩ + +/-- The same public claim with a finite memoized graph. Cycles remain permitted. -/ +def Circuit.EncodedMemoEntryDerives [Field F] [DecidableEq F] (system : Circuit.System F) + (name : String) (args : List (Value F)) (result : Value F) : Prop := + ∃ wires output, DecodesValues system.enums wires args ∧ output.decode system.enums = some result ∧ + Circuit.MemoEntryDerives system ⟨name, wires, output⟩ + +theorem Circuit.EncodedEntryDerives.memo [Field F] [DecidableEq F] + {system : Circuit.System F} {name : String} {args : List (Value F)} {result : Value F} + (accepted : Circuit.EncodedEntryDerives system name args result) : + Circuit.EncodedMemoEntryDerives system name args result := by + obtain ⟨wires, output, arguments, decoded, tree⟩ := accepted + exact ⟨wires, output, arguments, decoded, tree.memo⟩ + +private theorem public_arguments [Field F] [DecidableEq F] {decls : Declarations} + {wires : List (WireValue F)} {values : List (Value F)} + (arguments : DecodesValues decls wires values) + (free : ∀ value ∈ values, value.type.pointerFree decls = true) : + ∀ wire ∈ wires, wire.type.pointerFree decls = true := by + induction arguments with + | nil => simp + | @cons wire value wires values head tail ih => + have headFree := free value (by simp) + rw [(WireValue.decode_spec head).1] at headFree + simpa using And.intro headFree (ih (fun v h => free v (by simp [h]))) + +private theorem decoded_public_arguments [Field F] [DecidableEq F] {decls : Declarations} + {wires : List (WireValue F)} {values : List (Value F)} + (arguments : DecodesValues decls wires values) + (free : ∀ wire ∈ wires, wire.type.pointerFree decls = true) : + ∀ value ∈ values, value.type.pointerFree decls = true := by + induction arguments with + | nil => simp + | @cons wire value wires values head tail ih => + have spec := WireValue.decode_spec head + have valid : value.type.pointerFree decls = true := by + rw [spec.1]; exact free wire (by simp) + simpa only [List.mem_cons, forall_eq_or_imp] using + And.intro valid (ih (fun w h => free w (by simp [h]))) + +/-- Completeness uses an injection only on allocated locations; enums need no extra execution premise. -/ +theorem compiler_heap_complete [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {name : String} {args : List (SourceValue F)} {value : SourceValue F} {heap : Heap F} + (entry : checkEntry program name = .ok ()) (evaluated : EvalFn program name args [] value heap) + (encode : Nat → F) + (distinct : ∀ i j, i < heap.length → j < heap.length → encode i = encode j → i = j) : + Circuit.EncodedEntryDerives system name (entryValues args) (value.mapAddress encode) := by + have stages := Circuit.compile_stages compiled + have declarations := typecheck_declarations stages.1 + have free := evaluated.public_pointerFree entry + have heapGood := (evaluated.heap_good stages.1 (by simp [Heap.Good]) + (fun arg member => Value.pointerNames_of_free (free arg member))).2 + let table := ROM.ofHeap heap encode + have good := ROM.ofHeap_good heapGood encode + have decodeTable := ROM.decode_encode declarations stages.2.1 good + have body := evaluated.toROM (ROM.ofHeap_cells heap encode) + have encodedBody : ROMEvalCall ((table.encode program.enums).decode program.enums) program name + (args.map (Value.mapAddress encode)) (value.mapAddress encode) := by + rw [decodeTable]; exact body + obtain ⟨wires, output, arguments, decoded, derives⟩ := evaluation_complete compiled encodedBody + rw [entryValues_eq free encode] at arguments + have argsFree : ∀ arg ∈ entryValues args, arg.type.pointerFree program.enums = true := by + intro arg member + obtain ⟨source, sourceMember, rfl⟩ := List.mem_map.mp member + simpa using (evaluated.publicArguments entry source sourceMember).1 + have tableValid := ROM.encode_valid declarations good (ROM.ofHeap_valid heap encode distinct) + refine ⟨wires, output, ?_, ?_, ?_⟩ + · simpa only [stages.2.2.2.1] using arguments + · simpa only [stages.2.2.2.1] using decoded + · refine ⟨?_, ?_, table.encode program.enums, tableValid, derives⟩ + · exact ⟨by simpa only [stages.2.2.2.1] using arguments.each, + by simpa only [stages.2.2.2.1] using + (show ∃ value, output.decode program.enums = some value from ⟨_, decoded⟩)⟩ + · simpa only [stages.2.2.2.1, Circuit.Message.PublicArguments] using public_arguments arguments argsFree + +/-- Allocation capacity and tag injectivity are separate: compilation already checks the latter. -/ +theorem compiler_heap_complete_finite [Field F] [DecidableEq F] [Fintype F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {name : String} {args : List (SourceValue F)} {value : SourceValue F} {heap : Heap F} + (entry : checkEntry program name = .ok ()) (evaluated : EvalFn program name args [] value heap) + (capacity : heap.length ≤ Fintype.card F) : + ∃ encode : Nat → F, Circuit.EncodedEntryDerives system name (entryValues args) (value.mapAddress encode) := by + obtain ⟨encode, distinct⟩ := heap_address_embedding heap capacity + exact ⟨encode, compiler_heap_complete compiled entry evaluated encode distinct⟩ + +/-- A successful executable run supplies a witness when its allocations fit the field. -/ +theorem compiler_run_complete [Field F] [DecidableEq F] [Fintype F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {name : String} {args : List (SourceValue F)} {fuel : Nat} + {value : SourceValue F} {heap : Heap F} {hints : HintProvider F program.enums} + (executed : run program name args fuel hints = .ok (value, heap)) (capacity : heap.length ≤ Fintype.card F) : + ∃ encode : Nat → F, Circuit.EncodedEntryDerives system name (entryValues args) (value.mapAddress encode) := by + obtain ⟨_, entry, locals, expr, prepared, body⟩ := run_eq_ok_iff.mp executed + exact compiler_heap_complete_finite compiled entry (.intro prepared (evalExpr_spec body)) capacity + +/-- Memoized completeness reuses the same tree witness and allocation bound. -/ +theorem memo_run_complete [Field F] [DecidableEq F] [Fintype F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {name : String} {args : List (SourceValue F)} {fuel : Nat} + {value : SourceValue F} {heap : Heap F} {hints : HintProvider F program.enums} + (executed : run program name args fuel hints = .ok (value, heap)) (capacity : heap.length ≤ Fintype.card F) : + ∃ encode : Nat → F, Circuit.EncodedMemoEntryDerives system name (entryValues args) (value.mapAddress encode) := by + obtain ⟨encode, tree⟩ := compiler_run_complete compiled executed capacity + exact ⟨encode, tree.memo⟩ + +/-- Soundness realizes decoded circuit values by fresh source allocations, allowing address sharing. -/ +theorem compiler_heap_sound [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) {rom : WireROM F} (valid : rom.Valid) + {name : String} {args : List (SourceValue F)} {result : Value F} + (entry : checkEntry program name = .ok ()) + {wires : List (WireValue F)} {output : WireValue F} + (derived : Circuit.CircuitEvaluates system rom name wires output) + (arguments : DecodesValues program.enums wires (entryValues args)) + (decoded : output.decode program.enums = some result) : + ∃ source heap, EvalFn program name args [] source heap ∧ + Represents (rom.decode program.enums) heap source result := by + have evaluated := compiler_sound compiled derived arguments decoded + have free : ∀ value ∈ args, value.pointerFree = true := by + intro value member + have valid := evaluated.publicArguments entry (value.mapAddress (fun _ => 0)) + (List.mem_map.mpr ⟨value, member, rfl⟩) + exact Value.pointerFree_of_type (by simpa using valid.1) (by simpa using valid.2) + have relatedArgs : RepresentsArgs (rom.decode program.enums) [] args (entryValues args) := by + apply List.forall₂_map_right_iff.mpr + exact List.forall₂_same.mpr (fun value member => + Represents.of_pointerFree value (free value member) _) + obtain ⟨source, heap, evaluated, _, related⟩ := evaluated.realize (WireROM.decode_valid valid) relatedArgs + exact ⟨source, heap, evaluated, related⟩ + +/-- Pointer-free decoded results agree exactly with source evaluation. -/ +theorem compiler_entry_sound [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {name : String} {args : List (SourceValue F)} {result : Value F} + (accepted : Circuit.EncodedEntryDerives system name (entryValues args) result) + (free : result.pointerFree = true) : + EvalCall program name args (result.mapAddress (fun _ => 0)) := by + obtain ⟨wires, output, arguments, decoded, _, argumentsFree, rom, valid, derived⟩ := accepted + have enums := (Circuit.compile_stages compiled).2.2.2.1 + rw [enums] at arguments decoded argumentsFree + have sourceFree := decoded_public_arguments arguments argumentsFree + have entry : checkEntry program name = .ok () := + (compiler_sound compiled derived arguments decoded).entry_of_publicArguments sourceFree + obtain ⟨source, heap, evaluated, related⟩ := compiler_heap_sound compiled valid entry derived arguments decoded + rw [related.pointerFree_eq free] at evaluated + exact ⟨entry, heap, evaluated⟩ + +/-- Acyclic memoized call graphs have heap soundness without a totality hypothesis. -/ +theorem memo_acyclic_heap_sound [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) {rom : WireROM F} (valid : rom.Valid) + {name : String} {args : List (SourceValue F)} {result : Value F} + (entry : checkEntry program name = .ok ()) + {wires : List (WireValue F)} {output : WireValue F} + (graph : Circuit.MemoDerivation system rom ⟨name, wires, output⟩) (acyclic : graph.Acyclic) + (arguments : DecodesValues program.enums wires (entryValues args)) + (decoded : output.decode program.enums = some result) : + ∃ source heap, EvalFn program name args [] source heap ∧ + Represents (rom.decode program.enums) heap source result := + compiler_heap_sound compiled valid entry (graph.derives_of_acyclic acyclic) arguments decoded + +end Aiur diff --git a/Aiur/Aiur/Modules.lean b/Aiur/Aiur/Modules.lean new file mode 100644 index 000000000..3f2021792 --- /dev/null +++ b/Aiur/Aiur/Modules.lean @@ -0,0 +1,3 @@ +import Aiur.Modules.Frontend +import Aiur.Modules.Correctness +import Aiur.Optimized.Program diff --git a/Aiur/Aiur/Modules/AST.lean b/Aiur/Aiur/Modules/AST.lean new file mode 100644 index 000000000..4d0fe8816 --- /dev/null +++ b/Aiur/Aiur/Modules/AST.lean @@ -0,0 +1,93 @@ +import Aiur.Generic.AST + +/-! Static modules. Files, imports and entrypoint declarations are deliberately +absent. Module bodies reuse the native generic expression language. -/ +namespace Aiur.Modules +open Generic + +inductive Ref where + | mk (name : String) (args : List Ref) + deriving Repr, BEq, Inhabited, Lean.ToExpr + +def Ref.name : Ref → String | .mk name _ => name +def Ref.args : Ref → List Ref | .mk _ args => args +def Ref.symbol : Ref → String + | .mk name [] => name + | .mk name args => name ++ "::<" ++ String.intercalate "," (args.map Ref.symbol) ++ ">" +termination_by r => sizeOf r + +structure TypeMember where + name : String + typeParams : List String := [] + definition : Option Generic.Ty := none + /-- Withhold input/hint permission; the implementation may still be transparent. -/ + isOpaque : Bool := false + deriving Repr, BEq, Inhabited, Lean.ToExpr + +structure Callable where + name : String + typeParams : List String := [] + params : List (String × Generic.Ty) + result : Generic.Ty + deriving Repr, BEq, Inhabited, Lean.ToExpr + +structure Signature where + name : String + types : List TypeMember := [] + consts : List (String × Generic.Ty) := [] + /-- Functions and maps have the same callable interface. -/ + functions : List Callable := [] + tables : List (String × Generic.Ty) := [] + deriving Repr, BEq, Inhabited, Lean.ToExpr + +structure Definitions (α : Type) where + program : Generic.Program α + constTypes : List (String × Generic.Ty) := [] + /-- Destructuring parameter patterns, before checking their irrefutability. -/ + parameterPatterns : List (String × List (Generic.Pattern α)) := [] + /-- Declaration-level opacity, retained independently of alias normalization. -/ + opaqueTypes : List String := [] + deriving Repr, BEq, Inhabited, Lean.ToExpr + +inductive Body (α : Type) where + | definitions (value : Definitions α) + | alias (target : Ref) + deriving Repr, BEq, Inhabited, Lean.ToExpr + +structure Module (α : Type) where + name : String + parameters : List (String × String) := [] + signature : Option String := none + body : Body α + deriving Repr, BEq, Inhabited, Lean.ToExpr + +structure Program (α : Type) where + signatures : List Signature := [] + modules : List (Module α) := [] + deriving Repr, BEq, Inhabited, Lean.ToExpr + +def Program.findModule? (p : Program α) (name : String) := p.modules.find? (·.name == name) +def Program.findSignature? (p : Program α) (name : String) := p.signatures.find? (·.name == name) + +/-- Compose declaration fragments before checking. Duplicate definitions are +errors; this operation never reopens or merges the contents of a module. -/ +def Program.append (p q : Program α) : Program α := + ⟨p.signatures ++ q.signatures, p.modules ++ q.modules⟩ + +def Definitions.map (f : α → β) (d : Definitions α) : Definitions β := { + program := d.program.map f + constTypes := d.constTypes + parameterPatterns := d.parameterPatterns.map fun (n, ps) => (n, ps.map (Generic.Pattern.map f)) + opaqueTypes := d.opaqueTypes } + +def Program.map (f : α → β) (p : Program α) : Program β := { + signatures := p.signatures + modules := p.modules.map fun m => { + name := m.name, parameters := m.parameters, signature := m.signature + body := match m.body with + | .definitions d => .definitions (d.map f) + | .alias target => .alias target } } + +def Program.toField (p : Program Nat) (F : Type) [NatCast F] := p.map (Nat.cast : Nat → F) + +end Aiur.Modules diff --git a/Aiur/Aiur/Modules/Check.lean b/Aiur/Aiur/Modules/Check.lean new file mode 100644 index 000000000..e19a3f935 --- /dev/null +++ b/Aiur/Aiur/Modules/Check.lean @@ -0,0 +1,290 @@ +import Aiur.Modules.Opacity + +namespace Aiur.Modules + +def stub (f : Callable) : Generic.Function α := { + name := f.name, typeParams := f.typeParams, params := f.params, result := f.result + body := .call f.name (some (f.typeParams.map Generic.Ty.param)) (f.params.map fun p => .var p.1) } + +/-- Ordinary abstract members promise input admissibility. Opaque members +withhold it. Private constructors occur only in the checking environment. -/ +def interfaceProgram (s : Signature) (aliasTarget : Option String := none) : Generic.Program α := { + functions := s.functions.map stub + enums := s.types.filterMap fun t => + if t.definition.isSome || aliasTarget.isSome then none + else some ⟨t.name, t.typeParams, [⟨"@abstract", + if t.isOpaque then [.ptr .field] else t.typeParams.map .param⟩]⟩ + aliases := s.types.filterMap fun t => + match t.definition with + | some type => some ⟨t.name, t.typeParams, type⟩ + | none => aliasTarget.map fun target => + ⟨t.name, t.typeParams, .named (rename target ((splitPath t.name).getLast!)) (t.typeParams.map .param)⟩ + tables := s.tables.map fun (n,t) => ⟨n,t,[]⟩ } + +def headers (p : Generic.Program α) : Generic.Program α := { + p with + functions := p.functions.map (fun f => stub ⟨f.name,f.typeParams,f.params,f.result⟩) ++ + p.maps.map (fun f => stub ⟨f.name,[],f.params,f.result⟩) + maps := [], consts := [], tables := p.tables.map fun t => {t with rows := []} } + +def publicView (p : Program α) (w : World α) : + Nat → Item α → List (String × Generic.Ty) → Except String (Generic.Program α × List (String × Generic.Ty)) + | 0, _, _ => throw "interface alias depth exceeded" + | fuel + 1, item, constants => do + if let some sig := item.decl.signature then + let some signature := p.findSignature? sig | throw s!"unknown signature '{sig}'" + let (signature, _) ← (qualifySignature p item signature).run w + return (interfaceProgram signature (item.target.map Ref.symbol), signature.consts) + else if let some target := item.target then + let some targetItem := w.find? target | throw "missing alias interface" + let (base, consts) ← publicView p w fuel targetItem constants + let renamed := fun n => rename item.key.symbol ((splitPath n).getLast!) + let types := base.nominals.map (fun t => (t.name,t.typeParams)) ++ base.aliases.map (fun t => (t.name,t.typeParams)) + let aliases := types.map fun (n,ps) => Generic.AliasDecl.mk (renamed n) ps (.named n (ps.map .param)) + let functions := base.functions.map fun f => stub ⟨renamed f.name, f.typeParams, f.params, f.result⟩ + let tables := base.tables.map fun t => {t with name := renamed t.name} + let templates := base.consts.map fun c => Generic.ConstDecl.mk (renamed c.name) (.global c.name) + return ({ functions, aliases, tables, consts := templates }, consts.map fun (n,t) => (renamed n,t)) + else + let raw := item.qualified.getD {functions := []} + -- An inferred interface exposes const templates as well as their + -- inferred types. Context-dependent constructors remain polymorphic; + -- references into sealed modules still use those modules' interfaces. + return (sealTypes {headers raw with consts := raw.consts} item.declaredOpaqueTypes, + constants.filter fun (n,_) => raw.consts.any (·.name == n)) + +def rawModuleView (p : Program α) (w : World α) (owner : Ref) + (constants : List (String × Generic.Ty)) : Except String (Generic.Program α × List (String × Generic.Ty)) := do + let mut result : Generic.Program α := { functions := [] } + let mut external := [] + for item in w.items do + if item.key == owner && item.target.isNone then + result := append result (item.qualified.getD {functions := []}) + else + let (view, consts) ← publicView p w 128 item constants + result := append result view + external := external ++ consts + return (result, external) + +def normalizeView (result : Generic.Program α) (external : List (String × Generic.Ty)) : + Except String (Generic.Program α × List (String × Generic.Ty)) := do + let aliases ← Generic.Aliases.resolveDeclarations result + let expanded ← Generic.Aliases.expandProgram aliases result + let externalTypes ← external.mapM fun (n,t) => return (n, ← Generic.Aliases.expandType aliases t) + return ({expanded with aliases},externalTypes) + +def moduleView (p : Program α) (w : World α) (owner : Ref) + (constants : List (String × Generic.Ty)) : Except String (Generic.Program α × List (String × Generic.Ty)) := do + let (raw, external) ← rawModuleView p w owner constants + normalizeView raw external + +def normalized (view : Generic.Program α) (t : Generic.Ty) := do + Generic.Aliases.expandType (← Generic.Aliases.resolveDeclarations view) t + +def inferConstants (p : Program α) (w : World α) : Except String (List (String × Generic.Ty)) := do + let mut constants := [] + let mut failure := "cannot infer exported constant types" + let total := (w.items.map fun i => (i.qualified.getD {functions := []}).consts.length).sum + for _ in List.range (total + 1) do + let mut next := constants + for item in w.items do + if item.target.isSome || item.key.name.startsWith "@" then continue + match moduleView p w item.key constants with + | .error e => failure := e + | .ok (view, external) => + for c in (item.qualified.getD {functions := []}).consts do + let checked : Except String Generic.Ty := do + let some body := view.consts.find? (·.name == c.name) | throw "missing constant" + let annotation ← (item.constTypes.lookup c.name).mapM (normalized view) + Generic.inferInterfaceConst view body.value annotation external false + match checked with + | .ok type => if type.concrete then + let exposed := (item.constTypes.lookup c.name).getD type + next := (c.name,exposed) :: next.filter (·.1 != c.name) + | .error e => failure := s!"in const '{c.name}': {e}" + if next == constants then break + constants := next + for item in w.items do + if item.target.isSome || item.key.name.startsWith "@" then continue + let (view, external) ← moduleView p w item.key constants + for c in (item.qualified.getD {functions := []}).consts do + if (constants.lookup c.name).isNone then + let some body := view.consts.find? (·.name == c.name) | throw failure + let annotation ← (item.constTypes.lookup c.name).mapM (normalized view) + let _ ← (Generic.inferInterfaceConst view body.value annotation external false).mapError + (fun e => s!"in const '{c.name}': {e}") + return constants + +def checkContract (p : Program α) (w : World α) (constants : List (String × Generic.Ty)) + (item : Item α) (signature : String) (throughInterface : Bool) : Except String Unit := do + let some sig := p.findSignature? signature | throw s!"unknown signature '{signature}'" + let (required, _) ← (qualifySignature p item sig).run w + let owner := if throughInterface || item.target.isSome then Ref.mk "" [] else item.key + let (raw, external) ← rawModuleView p w owner constants + -- Conformance must preserve opaque identity in every exposed signature. + let (view, external) ← normalizeView (sealTypes raw item.declaredOpaqueTypes) external + let available ← if throughInterface || item.target.isSome then (publicView p w 128 item constants).map Prod.fst + else pure (item.qualified.getD {functions := []}) + for t in required.types do + let arity := (available.nominals.find? (·.name == t.name)).map (·.typeParams.length) |>.orElse fun _ => + (available.aliases.find? (·.name == t.name)).map (·.typeParams.length) + if arity != some t.typeParams.length then throw s!"missing or incompatible type '{t.name}' required by '{signature}'" + unless t.isOpaque do + checkNonOpaque raw (opaqueNames p w owner) + s!"non-opaque signature member '{t.name}'" (.named t.name (t.typeParams.map .param)) t.typeParams + if let some expected := t.definition then + let actual ← normalized view (.named t.name (t.typeParams.map .param)) + let expected ← normalized view expected + if actual != expected then throw s!"manifest type mismatch for '{t.name}' in signature '{signature}'" + for f in required.functions do + let arity := (available.functions.find? (·.name == f.name)).map (·.typeParams.length) |>.orElse fun _ => + (available.maps.find? (·.name == f.name)).map (fun _ => 0) + if arity != some f.typeParams.length then throw s!"missing or incompatible callable '{f.name}' required by '{signature}'" + let params ← f.params.mapM fun (n,t) => return (n, ← normalized view t) + let result ← normalized view f.result + let _ ← Generic.elaborateExpr view f.typeParams params + (.call f.name (some (f.typeParams.map .param)) (params.map fun p => .var p.1)) result false external + for (name,type) in required.consts do + let types := if throughInterface || item.target.isSome then external else constants + let actual ← match types.lookup name with + | some type => pure type + | none => do + let some body := view.consts.find? (·.name == name) | throw s!"missing const '{name}' required by '{signature}'" + Generic.inferInterfaceConst view body.value (some (← normalized view type)) external + if (← normalized view actual) != (← normalized view type) then throw s!"const type mismatch for '{name}' in signature '{signature}'" + for (name,type) in required.tables do + let some table := available.tables.find? (·.name == name) | throw s!"missing table '{name}' required by '{signature}'" + if (← normalized view table.rowType) != (← normalized view type) then throw s!"table type mismatch for '{name}'" + +def checkWorld (p : Program α) (w : World α) : Except String Unit := do + -- Sealing must not hide alias cycles spanning several modules. Check the + -- complete declaration graph as well as each client's restricted view. + let mut declarations : Generic.Program α := {functions := []} + for item in w.items do + let definition ← if item.target.isNone then pure (item.qualified.getD {functions := []}) + else (publicView p w 128 item []).map Prod.fst + declarations := append declarations definition + let _ ← Generic.Aliases.resolveDeclarations declarations + let constants ← inferConstants p w + let mut dependencies : List (Generic.Function α) := [] + for item in w.items do + let (raw, _) ← rawModuleView p w item.key constants + let (view, external) ← moduleView p w item.key constants + -- Validate declarations, including interfaces and unused generic data types. + let _ ← Generic.elaborate ({ view with functions := [], consts := [], tables := [], maps := [] } : Generic.Program α) + if !item.key.name.startsWith "@" then + if let some sig := item.decl.signature then + (checkContract p w constants item sig false).mapError (fun e => s!"module '{item.key.symbol}' does not satisfy '{sig}': {e}") + if let some target := item.target then + let (exposed,_) ← publicView p w 128 item constants + dependencies := dependencies ++ exposed.functions.map fun fn => + {fn with + -- Aliases are transparent edges, including for inline-cycle checks. + isInline := true + body := .call (rename target.symbol ((splitPath fn.name).getLast!)) + (some (fn.typeParams.map .param)) (fn.params.map fun p => .var p.1)} + continue + let own := item.qualified.getD {functions := []} + let mut checked := [] + for fn in own.functions do + for type in hintTypes fn.body do + checkNonOpaque raw (opaqueNames p w item.key) s!"hint in '{fn.name}'" type + let some fn := view.findFunction? fn.name | throw "missing function in module view" + Generic.checkParams fn.typeParams + if let some n := findDuplicate (fn.params.map Prod.fst) [] then throw s!"duplicate parameter '{n}'" + (fn.params.map Prod.snd ++ [fn.result]).forM (Generic.checkType view fn.typeParams) + let body ← (Generic.elaborateExpr view fn.typeParams fn.params fn.body fn.result true external).mapError + (fun e => s!"in module '{item.key.symbol}', function '{fn.name}': {e}") + checked := checked ++ [{fn with body}] + dependencies := dependencies ++ checked + Generic.checkGenericCycles {view with functions := checked ++ view.functions.filter (fun f => !own.functions.any (·.name == f.name))} + for table in own.tables do + let some table := view.tables.find? (·.name == table.name) | throw "missing table" + Generic.checkPointerFree view s!"table '{table.name}'" 1024 [] table.rowType + for row in table.rows do + let _ ← Generic.elaborateExpr view [] [] row table.rowType false external + for m in own.maps do + let some m := view.maps.find? (·.name == m.name) | throw "missing map" + (m.params.map Prod.snd ++ [m.result]).forM (Generic.checkPointerFree view s!"map '{m.name}'" 1024 []) + let some input := view.tables.find? (·.name == m.input) | throw s!"unknown input table '{m.input}'" + let some output := view.tables.find? (·.name == m.output) | throw s!"unknown output table '{m.output}'" + if input.rowType != .tuple (m.params.map Prod.snd) || output.rowType != m.result then + throw s!"table type mismatch for map '{m.name}'" + for (_,patterns) in item.parameterPatterns do + let aliases ← Generic.Aliases.resolveDeclarations view + for pat in patterns do + let pat ← Generic.Aliases.expandPattern aliases pat + -- Constants are always refutable; other patterns use exposed shapes. + if !pat.irrefutable view.nominals then throw "parameter patterns must be irrefutable" + -- Interface-only body checking must not hide a growing generic recursion + -- path that crosses module boundaries, including aliases and unused functors. + Generic.checkGenericCycles {functions := dependencies} + Generic.checkInlineCycles {functions := dependencies} + for (key,sig) in w.requirements do + let some item := w.find? key | throw "missing module argument" + (checkContract p w constants item sig true).mapError (fun e => s!"module argument '{key.symbol}' does not satisfy '{sig}': {e}") + +def abstractModule (name : String) (sig : Signature) : Module α := { + name, signature := some sig.name + body := .definitions ⟨interfaceProgram sig, [], [], (sig.types.filter (·.isOpaque)).map (·.name)⟩ } + +/-- Independent abstract arguments preserve each module parameter's permissions, +even when two parameters are later instantiated with the same concrete module. -/ +def templateContext (p : Program α) : Except String (Program α × List Ref) := do + let signatureModules := p.signatures.map fun s => abstractModule ("@signature:" ++ s.name) s + let mut extra := signatureModules + let mut seeds := [] + for m in p.modules do + if m.parameters.isEmpty then continue + let mut args := [] + for (n,sig) in m.parameters do + let some signature := p.findSignature? sig | throw s!"unknown signature '{sig}'" + let name := "@parameter:" ++ m.name ++ ":" ++ n + extra := extra ++ [abstractModule name signature] + args := args ++ [.mk name []] + seeds := seeds ++ [.mk m.name args] + return ({p with modules := p.modules ++ extra}, seeds) + +/-- Entry selection uses the externally supplied interface before alias +normalization. Internal functions may continue to accept opaque values. -/ +def checkEntryInputs (p : Program α) (w : World α) (external : String) : Except String Unit := do + let ((target, member), w) ← (locate p (.mk "" []) [] external).run w + let constants ← inferConstants p w + let (view, _) ← rawModuleView p w (.mk "" []) constants + let name := rename target.symbol member + let some fn := view.findFunction? name | throw s!"unknown entry function '{external}'" + for (_, type) in fn.params do + checkNonOpaque view (opaqueNames p w (.mk "" [])) s!"entry '{external}'" type + let some item := w.find? target | throw "missing entry module" + let some implementation := w.find? item.canonical | throw "missing entry implementation" + unless implementation.decl.parameters.isEmpty do + let (abstract, seeds) ← templateContext p + let (world, _) ← collect abstract [] seeds + let key := Ref.mk implementation.decl.name (implementation.decl.parameters.map fun (n, _) => + .mk ("@parameter:" ++ implementation.decl.name ++ ":" ++ n) []) + let (view, _) ← rawModuleView abstract world key [] + let some fn := view.findFunction? (rename key.symbol member) | + throw "missing abstract entry implementation" + for (_, type) in fn.params do + checkNonOpaque view (opaqueNames abstract world key) + s!"entry '{external}' under its module signature" type + +/-- Check every template once with abstract module arguments. No concrete +application can make an invalid unused template acceptable. -/ +def checkTemplates (p : Program α) : Except String Unit := do + validate p + let (abstract, seeds) ← templateContext p + let (world,_) ← collect abstract [] seeds + checkWorld abstract world + -- Validate the permission promised by manifest members in the signature + -- itself; a particular transparent implementation must not justify it. + for sig in p.signatures do + let owner := Ref.mk ("@signature:" ++ sig.name) [] + let (view, _) ← rawModuleView abstract world owner [] + for type in sig.types do + unless type.isOpaque do + checkNonOpaque view (opaqueNames abstract world owner) + s!"non-opaque signature member '{sig.name}::{type.name}'" + (.named (rename owner.symbol type.name) (type.typeParams.map .param)) type.typeParams + +end Aiur.Modules diff --git a/Aiur/Aiur/Modules/Correctness.lean b/Aiur/Aiur/Modules/Correctness.lean new file mode 100644 index 000000000..13994792a --- /dev/null +++ b/Aiur/Aiur/Modules/Correctness.lean @@ -0,0 +1,160 @@ +import Aiur.Modules.Link +import Aiur.Generic.NativeCircuit + +namespace Aiur.Modules +variable {F : Type} [Field F] [DecidableEq F] {program : Program F} + +def Prepared.EvalFn (p : Prepared program) (name : String) (args : List (SourceValue F)) + (value : SourceValue F) (heap : Heap F) : Prop := + ∃ entry, p.find? name = some entry ∧ + Generic.SourceSemantics.EvalFn p.environment.source.world entry.resolved.name args [] value heap + +theorem Prepared.run_heap_spec {p : Prepared program} {hints : p.environment.source.HintProvider} + (executed : p.run name args fuel hints = .ok (value,heap)) : p.EvalFn name args value heap := by + cases selected : p.find? name with + | none => simp [Prepared.run,selected] at executed + | some entry => + simp only [Prepared.run,selected] at executed + exact ⟨entry,selected,(Generic.Source.run_spec executed).2⟩ + +omit [Field F] in +theorem Prepared.entry_mem {p : Prepared program} + {entry : Selection program p.environment.assembly.instances} + (selected : p.find? name = some entry) : entry.resolved.name ∈ p.entries := by + have present := List.mem_of_find?_eq_some selected + exact List.mem_map.mpr ⟨entry,present,rfl⟩ + +structure Compiled (p : Prepared program) where + specialized : Generic.Specialized p.environment.source p.entries + circuit : Generic.Compiled specialized + +def Prepared.compile (p : Prepared program) : Except String (Compiled p) := do + let specialized ← Generic.specialize p.environment.source p.entries + return ⟨specialized, ← specialized.compile⟩ + +def Compiled.check {p : Prepared program} (c : Compiled p) (rom : WireROM F) + (name : String) (args : List (WireValue F)) (result : WireValue F) + (rows : List (Circuit.Row F)) : Except String Unit := do + let some entry := p.find? name | throw s!"unselected entrypoint '{name}'" + c.circuit.check rom ⟨entry.resolved.name,args,result⟩ rows + +def Compiled.checkMemo {p : Prepared program} (c : Compiled p) (rom : WireROM F) + (name : String) (args : List (WireValue F)) (result : WireValue F) + (rows : List (Circuit.WeightedRow F)) : Except String Unit := do + let some entry := p.find? name | throw s!"unselected entrypoint '{name}'" + c.circuit.checkMemo rom ⟨entry.resolved.name,args,result⟩ rows + +/-- Completeness from the module-denoted native environment to integer rows. +Module aliases only rename the external entrypoint; they introduce no wrapper. -/ +theorem Compiled.check_complete [Fintype F] {p : Prepared program} (c : Compiled p) + (wellFormed : c.circuit.system.WellFormed) + (evaluated : p.EvalFn name args value heap) (capacity : heap.length ≤ Fintype.card F) : + ∃ (encode : Nat → F), ∃ wires output rom rows, + DecodesValues c.circuit.system.enums wires (entryValues args) ∧ + output.decode c.circuit.system.enums = some (value.mapAddress encode) ∧ + c.check rom name wires output rows = .ok () := by + obtain ⟨entry,selected,evaluated⟩ := evaluated + obtain ⟨encode,wires,output,rom,rows,arguments,decoded,checked⟩ := + c.circuit.checker_heap_complete (Prepared.entry_mem selected) wellFormed evaluated capacity + refine ⟨encode,wires,output,rom,rows,arguments,decoded,?_⟩ + simp only [Compiled.check,selected] + exact c.circuit.check_iff.mpr ⟨Prepared.entry_mem selected,checked⟩ + +theorem Compiled.checkMemo_complete [Fintype F] {p : Prepared program} (c : Compiled p) + (wellFormed : c.circuit.system.WellFormed) + (evaluated : p.EvalFn name args value heap) (capacity : heap.length ≤ Fintype.card F) : + ∃ (encode : Nat → F), ∃ wires output rom rows, + DecodesValues c.circuit.system.enums wires (entryValues args) ∧ + output.decode c.circuit.system.enums = some (value.mapAddress encode) ∧ + c.checkMemo rom name wires output rows = .ok () := by + obtain ⟨entry,selected,evaluated⟩ := evaluated + obtain ⟨encode,wires,output,rom,rows,arguments,decoded,checked⟩ := + c.circuit.checkerMemo_heap_complete (Prepared.entry_mem selected) wellFormed evaluated capacity + refine ⟨encode,wires,output,rom,rows,arguments,decoded,?_⟩ + simp only [Compiled.checkMemo,selected] + exact c.circuit.checkMemo_iff.mpr ⟨Prepared.entry_mem selected,checked⟩ + +theorem Compiled.run_complete [Fintype F] {p : Prepared program} (c : Compiled p) + (wellFormed : c.circuit.system.WellFormed) {hints : p.environment.source.HintProvider} + (executed : p.run name args fuel hints = .ok (value,heap)) (capacity : heap.length ≤ Fintype.card F) : + ∃ (encode : Nat → F), ∃ wires output rom rows, + DecodesValues c.circuit.system.enums wires (entryValues args) ∧ + output.decode c.circuit.system.enums = some (value.mapAddress encode) ∧ + c.check rom name wires output rows = .ok () := + c.check_complete wellFormed (Prepared.run_heap_spec executed) capacity + +theorem Compiled.runMemo_complete [Fintype F] {p : Prepared program} (c : Compiled p) + (wellFormed : c.circuit.system.WellFormed) {hints : p.environment.source.HintProvider} + (executed : p.run name args fuel hints = .ok (value,heap)) (capacity : heap.length ≤ Fintype.card F) : + ∃ (encode : Nat → F), ∃ wires output rom rows, + DecodesValues c.circuit.system.enums wires (entryValues args) ∧ + output.decode c.circuit.system.enums = some (value.mapAddress encode) ∧ + c.checkMemo rom name wires output rows = .ok () := + c.checkMemo_complete wellFormed (Prepared.run_heap_spec executed) capacity + +theorem Compiled.check_sound {p : Prepared program} (c : Compiled p) + {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} + {wires : List (WireValue F)} {output : WireValue F} {rows : List (Circuit.Row F)} + (checked : c.check rom name wires output rows = .ok ()) + (arguments : DecodesValues c.specialized.program.enums wires (entryValues args)) + (decoded : output.decode c.specialized.program.enums = some result) : + ∃ value heap, p.EvalCall name args value ∧ + Represents (rom.decode c.specialized.program.enums) heap value result := by + cases selected : p.find? name with + | none => simp [Compiled.check,selected] at checked + | some entry => + simp only [Compiled.check,selected] at checked + obtain ⟨value,heap,evaluated,related⟩ := c.circuit.check_sound checked arguments decoded + exact ⟨value,heap,⟨entry,selected,evaluated⟩,related⟩ + +/-- The weighted checker permits cyclic justification. Its soundness remains +conditional on acyclicity of the extracted support graph, never on totality. -/ +theorem Compiled.checkerMemo_acyclic_sound {p : Prepared program} (c : Compiled p) + {entry : Selection program p.environment.assembly.instances} + (selected : p.find? name = some entry) + {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} + {wires : List (WireValue F)} {output : WireValue F} {rows : List (Circuit.WeightedRow F)} + (checked : c.circuit.system.checkMemo rom ⟨entry.resolved.name,wires,output⟩ rows = .ok ()) + (acyclic : (Classical.choice (c.circuit.system.checkMemo_sound checked)).Acyclic) + (arguments : DecodesValues c.specialized.program.enums wires (entryValues args)) + (decoded : output.decode c.specialized.program.enums = some result) : + ∃ value heap, p.EvalCall name args value ∧ + Represents (rom.decode c.specialized.program.enums) heap value result := by + obtain ⟨value,heap,evaluated,related⟩ := + c.circuit.checkerMemo_acyclic_heap_sound (Prepared.entry_mem selected) + checked acyclic arguments decoded + have checkedEntry := (c.specialized.valid.2.2.2.2.2.2.2 _ (Prepared.entry_mem selected)).2.1 + exact ⟨value,heap,⟨entry,selected,checkedEntry,heap,evaluated⟩,related⟩ + +theorem Compiled.checkMemo_rows {p : Prepared program} (c : Compiled p) + {entry : Selection program p.environment.assembly.instances} + (selected : p.find? name = some entry) + (checked : c.checkMemo rom name wires output rows = .ok ()) : + c.circuit.system.checkMemo rom ⟨entry.resolved.name,wires,output⟩ rows = .ok () := by + simp only [Compiled.checkMemo,selected] at checked + exact (c.circuit.checkMemo_iff.mp checked).2 + +theorem Compiled.checkMemo_acyclic_sound {p : Prepared program} (c : Compiled p) + {entry : Selection program p.environment.assembly.instances} + (selected : p.find? name = some entry) + {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} + {wires : List (WireValue F)} {output : WireValue F} {rows : List (Circuit.WeightedRow F)} + (checked : c.checkMemo rom name wires output rows = .ok ()) + (acyclic : (Classical.choice (c.circuit.system.checkMemo_sound (c.checkMemo_rows selected checked))).Acyclic) + (arguments : DecodesValues c.specialized.program.enums wires (entryValues args)) + (decoded : output.decode c.specialized.program.enums = some result) : + ∃ value heap, p.EvalCall name args value ∧ + Represents (rom.decode c.specialized.program.enums) heap value result := + c.checkerMemo_acyclic_sound selected (c.checkMemo_rows selected checked) acyclic arguments decoded + +omit [Field F] in +/-- Every source name exposed by a compiled root has a declarative module +resolution, with its target included in the assembled environment. -/ +theorem Prepared.selected_denotes {p : Prepared program} + {entry : Selection program p.environment.assembly.instances} + (_selected : p.find? name = some entry) : + NameDenotes program (.mk "" []) [] entry.external entry.resolved.target entry.resolved.name ∧ + p.environment.assembly.instances.contains entry.resolved.target = true := + ⟨entry.resolved.denotes,entry.resolved.closed⟩ + +end Aiur.Modules diff --git a/Aiur/Aiur/Modules/Elaborate.lean b/Aiur/Aiur/Modules/Elaborate.lean new file mode 100644 index 000000000..ea39888d7 --- /dev/null +++ b/Aiur/Aiur/Modules/Elaborate.lean @@ -0,0 +1,198 @@ +import Aiur.Modules.Rewrite + +namespace Aiur.Modules + +def memberNames (p : Generic.Program α) : List String := + p.functions.map (·.name) ++ p.nominals.map (·.name) ++ p.aliases.map (·.name) ++ + p.consts.map (·.name) ++ p.tables.map (·.name) ++ p.maps.map (·.name) + +def Signature.names (s : Signature) := + s.types.map (·.name) ++ s.consts.map Prod.fst ++ s.functions.map (·.name) ++ s.tables.map Prod.fst + +def Signature.exposes (s : Signature) (access : Access) (name : String) : Bool := + match access with + | .type => s.types.any (·.name == name) + | .constructor => (s.types.find? (·.name == name)).any (·.definition.isSome) + | .constant => s.consts.any (·.1 == name) + | .callable => s.functions.any (·.name == name) + | .table => s.tables.any (·.1 == name) + +def hasMember (p : Generic.Program α) (access : Access) (name : String) : Bool := + match access with + | .type | .constructor => (p.nominals.map (·.name) ++ p.aliases.map (·.name)).contains name + | .constant => p.consts.any (·.name == name) + | .callable => p.functions.any (·.name == name) || p.maps.any (·.name == name) + | .table => p.tables.any (·.name == name) + +def simpleIdentifier (name : String) : Bool := + !name.isEmpty && name.toList.all (fun c => c.isAlphanum || c == '_') && + !(name.toList.head!.isDigit) && name != "Field" + +def validate (p : Program α) : Except String Unit := do + let names := p.modules.map (·.name) ++ p.signatures.map (·.name) + if let some n := findDuplicate names [] then throw s!"duplicate module/signature '{n}'" + for n in names do + unless simpleIdentifier n do throw s!"invalid module/signature name '{n}'" + for s in p.signatures do + if let some n := findDuplicate s.names [] then throw s!"duplicate signature member '{n}'" + for n in s.names do unless simpleIdentifier n do throw s!"invalid signature member '{n}'" + for t in s.types do + if t.isOpaque && t.definition.isSome then + throw s!"opaque signature member '{s.name}::{t.name}' cannot expose a representation" + for m in p.modules do + if let some n := findDuplicate (m.parameters.map Prod.fst) [] then throw s!"duplicate module parameter '{n}'" + for (n, sig) in m.parameters do + unless simpleIdentifier n do throw s!"invalid module parameter '{n}'" + if names.contains n then throw s!"module parameter '{n}' shadows a global module/signature" + if (p.findSignature? sig).isNone then throw s!"unknown signature '{sig}'" + if let some sig := m.signature then + if (p.findSignature? sig).isNone then throw s!"unknown signature '{sig}'" + if let .definitions d := m.body then + if let some n := findDuplicate (memberNames d.program) [] then throw s!"duplicate member '{m.name}::{n}'" + for n in memberNames d.program do + unless simpleIdentifier n do throw s!"invalid module member '{n}'" + if let some n := findDuplicate d.opaqueTypes [] then throw s!"duplicate opaque declaration '{n}'" + for n in d.opaqueTypes do + unless hasMember d.program .type n do throw s!"unknown opaque type '{m.name}::{n}'" + +structure Item (α : Type) where + key : Ref + canonical : Ref + decl : Module α + bindings : Bindings + target : Option Ref := none + qualified : Option (Generic.Program α) := none + constTypes : List (String × Generic.Ty) := [] + parameterPatterns : List (String × List (Generic.Pattern α)) := [] + deriving Inhabited + +structure World (α : Type) where + items : List (Item α) := [] + requirements : List (Ref × String) := [] + deriving Inhabited + +abbrev Build (α : Type) := StateT (World α) (Except String) + +def World.find? (w : World α) (key : Ref) := w.items.find? (·.key == key) + +/-- Preserve an alias's interface for checking, but normalize argument identity +before memoizing an application. Contract obligations remember the supplied view. -/ +def ensure (p : Program α) : Nat → Bindings → Ref → Build α Ref + | 0, _, _ => throw "module expansion depth exceeded (possible cyclic alias)" + | fuel + 1, bindings, ref => do + if ref.args.isEmpty then + if let some bound := bindings.lookup ref.name then return bound + else if (bindings.lookup ref.name).isSome then throw "module parameters cannot be applied" + let some decl := p.findModule? ref.name | throw s!"unknown module '{ref.name}'" + if decl.parameters.length != ref.args.length then + throw s!"module '{ref.name}' expects {decl.parameters.length} arguments" + let actual ← ref.args.mapM (ensure p fuel bindings) + for ((_, signature), argument) in decl.parameters.zip actual do + modify fun w => { w with requirements := (argument, signature) :: w.requirements } + let canonicalArgs ← actual.mapM fun arg => do return (← liftM (resolve p [] 128 arg)).value + let key := Ref.mk ref.name canonicalArgs + if ((← get).find? key).isSome then return key + if (← get).items.length >= 512 then throw "module instance limit exceeded (512)" + let canonical := (← liftM (resolve p [] 128 key)).value + let bound := (decl.parameters.map Prod.fst).zip canonicalArgs + let target ← match decl.body with + | .definitions _ => pure none + | .alias target => some <$> ensure p fuel bound target + modify fun w => { w with items := w.items ++ [⟨key, canonical, decl, bound, target, none, [], []⟩] } + return key + +def getItem (key : Ref) : Build α (Item α) := do + let some item := (← get).find? key | throw s!"missing module instance '{key.symbol}'" + return item + +/-- Access is checked against the supplied alias/interface before following it. +Inside a module its implementation members remain available. -/ +def accessible (p : Program α) : Nat → Ref → Ref → Access → String → Build α Unit + | 0, _, _, _, _ => throw "module alias depth exceeded" + | fuel + 1, owner, target, access, name => do + let item ← getItem target + if owner != target then + if let some sig := item.decl.signature then + let some signature := p.findSignature? sig | throw s!"unknown signature '{sig}'" + unless signature.exposes access name do throw s!"'{target.symbol}::{name}' is not exposed by signature '{sig}'" + return + match item.decl.body with + | .definitions d => + unless hasMember d.program access name do throw s!"unknown {repr access} '{target.symbol}::{name}'" + if owner != target && access == .constructor && d.opaqueTypes.contains name then + throw s!"cannot access the representation of opaque type '{target.symbol}::{name}'" + | .alias _ => + let some next := item.target | throw "missing alias target" + accessible p fuel owner next access name + +def locate (p : Program α) (owner : Ref) (bindings : Bindings) (path : String) : Build α (Ref × String) := do + match splitPath path with + | [name] => return (owner, name) + | [head, name] => + let ref ← liftM (parseRef 128 head) + if (p.findModule? ref.name).isNone && (bindings.lookup ref.name).isNone then + throw s!"unknown module '{ref.name}'" + return (← ensure p 128 bindings ref, name) + | _ => throw s!"expected a module-qualified member, got '{path}'" + +def qualify (p : Program α) (owner : Ref) (bindings : Bindings) (access : Access) (path : String) : Build α String := do + let (target, name) ← locate p owner bindings path + accessible p 128 owner target access name + return rename target.symbol name + +def qualifySignature (p : Program α) (item : Item α) (sig : Signature) : Build α Signature := do + let q := qualify p item.key item.bindings + -- Signature-local names are requirements, and need not occur in a malformed + -- implementation. Their existence is checked by conformance, separately. + let tyName := fun path => + match splitPath path with + | [name] => pure (rename item.key.symbol name) + | _ => q .type path + let types ← sig.types.mapM fun t => do + return { t with name := rename item.key.symbol t.name, definition := ← t.definition.mapM (retype tyName) } + let consts ← sig.consts.mapM fun (n,t) => return (rename item.key.symbol n, ← retype tyName t) + let tables ← sig.tables.mapM fun (n,t) => return (rename item.key.symbol n, ← retype tyName t) + let functions ← sig.functions.mapM fun f => do + return { f with + name := rename item.key.symbol f.name + params := ← f.params.mapM fun (n,t) => return (n, ← retype tyName t) + result := ← retype tyName f.result } + return { sig with types, consts, tables, functions } + +def finish (p : Program α) : Nat → Build α Unit + | 0 => throw "module dependency expansion limit exceeded" + | fuel + 1 => do + let some item := (← get).items.find? (fun i => i.qualified.isNone) | return + -- Mark before walking dependencies: cross-module function recursion is legal. + modify fun w => { w with items := w.items.map fun i => + if i.key == item.key then { i with qualified := some { functions := [] } } else i } + if let .definitions d := item.decl.body then + let q := qualify p item.key item.bindings + let qualified ← rewrite item.key.symbol q d.program + let constTypes ← d.constTypes.mapM fun (n,t) => return (rename item.key.symbol n, ← retype (q .type) t) + let parameterPatterns ← d.parameterPatterns.mapM fun (n,ps) => do + return (rename item.key.symbol n, ← ps.mapM (repattern q)) + modify fun w => { w with items := w.items.map fun i => + if i.key == item.key then { i with qualified := some qualified, constTypes, parameterPatterns } else i } + if let some sig := item.decl.signature then + let some signature := p.findSignature? sig | throw s!"unknown signature '{sig}'" + let _ ← qualifySignature p item signature + finish p fuel + +def collect (p : Program α) (entries : List String) (seeds : List Ref := []) : Except String (World α × List (String × String)) := do + let (selected, world) ← (do + for seed in seeds do let _ ← ensure p 128 [] seed; pure () + for m in p.modules do + if m.parameters.isEmpty then let _ ← ensure p 128 [] (.mk m.name []); pure () + if let some name := findDuplicate entries [] then throw s!"duplicate entrypoint '{name}'" + let selected ← entries.mapM fun path => do + let [head, name] := splitPath path | throw "entrypoints must be module-qualified" + let target ← ensure p 128 [] (← liftM (parseRef 128 head)) + accessible p 128 (.mk "" []) target .callable name + let item ← getItem target + return (path, rename item.canonical.symbol name) + finish p 1024 + return selected : Build α (List (String × String))).run {} + return (world, selected) + +end Aiur.Modules diff --git a/Aiur/Aiur/Modules/Frontend.lean b/Aiur/Aiur/Modules/Frontend.lean new file mode 100644 index 000000000..64db72750 --- /dev/null +++ b/Aiur/Aiur/Modules/Frontend.lean @@ -0,0 +1,277 @@ +import Aiur.Modules.Check +import Aiur.Generic.Frontend + +namespace Aiur.Modules.Frontend +open Lean Elab Term +open Aiur.Frontend +open Aiur.Generic.Frontend + +declare_syntax_cat aiur_module_ref (behavior := symbol) +declare_syntax_cat aiur_qualified (behavior := symbol) +declare_syntax_cat aiur_global_name (behavior := symbol) +declare_syntax_cat aiur_signature_member (behavior := symbol) +declare_syntax_cat aiur_module_parameter (behavior := symbol) +declare_syntax_cat aiur_root_decl (behavior := symbol) +declare_syntax_cat aiur_modules (behavior := symbol) +declare_syntax_cat aiur_module_member (behavior := symbol) + +syntax (name := refName) ident : aiur_module_ref +syntax (name := refApply) ident "::<" sepBy1(aiur_module_ref, ",", ",", allowTrailingSep) ">" : aiur_module_ref +syntax (name := qualified) aiur_module_ref "::" sepBy1(ident, "::") : aiur_qualified +syntax (name := rootedQualified) "::" aiur_module_ref "::" sepBy1(ident, "::") : aiur_qualified +syntax (name := globalName) ident : aiur_global_name +syntax (name := qualifiedName) aiur_qualified : aiur_global_name +syntax (name := qualifiedType) aiur_qualified : aiur_type +syntax (name := qualifiedAppliedType) aiur_qualified "<" sepBy1(aiur_type, ",", ",", allowTrailingSep) ">" : aiur_type +syntax (name := qualifiedValue) aiur_qualified : aiur_expr +syntax (name := qualifiedCall) aiur_qualified "(" sepBy(aiur_expr, ",", ",", allowTrailingSep) ")" : aiur_expr +syntax (name := qualifiedGenericCall) aiur_qualified "::<" sepBy1(aiur_type, ",", ",", allowTrailingSep) ">" + "(" sepBy(aiur_expr, ",", ",", allowTrailingSep) ")" : aiur_expr +syntax (name := qualifiedGenericConstructor) aiur_qualified "::<" sepBy1(aiur_type, ",", ",", allowTrailingSep) ">" "::" ident : aiur_expr +syntax (name := qualifiedGenericConstructorArgs) aiur_qualified "::<" sepBy1(aiur_type, ",", ",", allowTrailingSep) ">" "::" ident + "(" sepBy(aiur_expr, ",", ",", allowTrailingSep) ")" : aiur_expr +syntax (name := qualifiedRecord) atomic(aiur_qualified "{" sepBy(aiur_record_value, ",", ",", allowTrailingSep) "}") : aiur_expr +syntax (name := qualifiedGenericRecord) atomic(aiur_qualified "::<" sepBy1(aiur_type, ",", ",", allowTrailingSep) ">" + "{" sepBy(aiur_record_value, ",", ",", allowTrailingSep) "}") : aiur_expr +syntax (name := qualifiedPattern) aiur_qualified : aiur_pattern +syntax (name := qualifiedPatternArgs) aiur_qualified "(" sepBy(aiur_pattern, ",", ",", allowTrailingSep) ")" : aiur_pattern +syntax (name := qualifiedGenericPattern) aiur_qualified "::<" sepBy1(aiur_type, ",", ",", allowTrailingSep) ">" "::" ident : aiur_pattern +syntax (name := qualifiedGenericPatternArgs) aiur_qualified "::<" sepBy1(aiur_type, ",", ",", allowTrailingSep) ">" "::" ident + "(" sepBy(aiur_pattern, ",", ",", allowTrailingSep) ")" : aiur_pattern +syntax (name := qualifiedRecordPattern) aiur_qualified "{" aiur_record_patterns "}" : aiur_pattern +syntax (name := qualifiedGenericRecordPattern) aiur_qualified "::<" sepBy1(aiur_type, ",", ",", allowTrailingSep) ">" + "{" aiur_record_patterns "}" : aiur_pattern +syntax (name := rootedCall) "::" ident "(" sepBy(aiur_expr, ",", ",", allowTrailingSep) ")" : aiur_expr +syntax (name := rootedGenericCall) "::" ident "::<" sepBy1(aiur_type, ",", ",", allowTrailingSep) ">" + "(" sepBy(aiur_expr, ",", ",", allowTrailingSep) ")" : aiur_expr +syntax (name := rootedType) "::" ident : aiur_type +syntax (name := typedConst) &"const" ident ":" aiur_type "=" aiur_expr ";" : aiur_const +syntax (name := qualifiedMap) &"map" ident "(" sepBy(aiur_param, ",", ",", allowTrailingSep) ")" + "->" aiur_type "=" aiur_global_name "=>" aiur_global_name ";" : aiur_map + +syntax (name := sigAbstract) &"type" ident ";" : aiur_signature_member +syntax (name := sigGenericAbstract) &"type" ident "<" sepBy1(ident, ",", ",", allowTrailingSep) ">" ";" : aiur_signature_member +syntax (name := sigOpaqueAbstract) &"opaque" &"type" ident ";" : aiur_signature_member +syntax (name := sigGenericOpaqueAbstract) &"opaque" &"type" ident "<" sepBy1(ident, ",", ",", allowTrailingSep) ">" ";" : aiur_signature_member +syntax (name := sigAlias) aiur_alias : aiur_signature_member +syntax (name := sigConst) &"const" ident ":" aiur_type ";" : aiur_signature_member +syntax (name := sigTable) &"table" ident ":" aiur_type ";" : aiur_signature_member +syntax (name := sigFunction) "fn" ident "(" sepBy(aiur_param, ",", ",", allowTrailingSep) ")" "->" aiur_type ";" : aiur_signature_member +syntax (name := sigGenericFunction) "fn" ident "<" sepBy1(ident, ",", ",", allowTrailingSep) ">" + "(" sepBy(aiur_param, ",", ",", allowTrailingSep) ")" "->" aiur_type ";" : aiur_signature_member +syntax (name := moduleParameter) ident ":" ident : aiur_module_parameter +syntax (name := signatureDecl) &"signature" ident "{" aiur_signature_member* "}" : aiur_root_decl +syntax (name := ordinaryMember) aiur_decl : aiur_module_member +syntax (name := opaqueAliasMember) &"opaque" aiur_alias : aiur_module_member +syntax (name := opaqueStructMember) &"opaque" aiur_struct : aiur_module_member +syntax (name := opaqueEnumMember) &"opaque" aiur_enum : aiur_module_member +syntax (name := moduleDecl) &"module" ident + ("<" sepBy1(aiur_module_parameter, ",", ",", allowTrailingSep) ">")? (":" ident)? + "{" aiur_module_member* "}" : aiur_root_decl +syntax (name := moduleAlias) &"module" ident + ("<" sepBy1(aiur_module_parameter, ",", ",", allowTrailingSep) ">")? (":" ident)? + "=" aiur_module_ref ";" : aiur_root_decl +syntax (name := modules) aiur_root_decl* : aiur_modules + +partial def readRef (s : Syntax) : Except String Ref := do + if s.getKind == ``refApply then + return .mk (← readName s[0]) (← s[2].getSepArgs.toList.mapM readRef) + else return .mk (← readName s[0]) [] + +private def pathParts (s : Syntax) : Except String (List String) := do + let offset := if s.getKind == ``rootedQualified then 1 else 0 + let head ← readRef s[offset] + return head.symbol :: (← s[2 + offset].getSepArgs.toList.mapM readName) + +private def node (kind : Name) (args : Array Syntax) := Syntax.node .none kind args +private def atom (text : String) := Syntax.atom .none text +private def identifier (text : String) : Syntax := mkIdent (Name.mkSimple text) + +/-- Normalize only qualified identifier syntax, then reuse the native expression +reader. No expression is lowered or evaluated by module parsing. -/ +partial def normalize (moduleNames localTypes : List String) (s : Syntax) : Except String Syntax := do + let k := s.getKind + if k == `choice then + -- Prefer the modular parse of a qualified identifier when both grammars fit. + let candidates := s.getArgs.toList + let localConstructor := candidates.find? fun c => + [``genericConstructor, ``genericConstructorArgs, ``genericConstructorPattern, + ``genericConstructorPatternArgs].contains c.getKind && + localTypes.contains (c[0].getId.toString) && + !(moduleNames.contains (c[0].getId.toString)) + if let some chosen := localConstructor then return ← normalize moduleNames localTypes chosen + let chosen := candidates.find? fun c => [``qualifiedValue, ``qualifiedCall, ``qualifiedPattern, + ``qualifiedPatternArgs, ``qualifiedGenericCall, ``qualifiedType].contains c.getKind + if let some chosen := chosen then return ← normalize moduleNames localTypes chosen + return node k (← s.getArgs.mapM (normalize moduleNames localTypes)) + let s ← match s with + | .node info kind args => do pure (Syntax.node info kind (← args.mapM (normalize moduleNames localTypes))) + | s => pure s + if k == ``rootedCall || k == ``rootedGenericCall then + return node (if k == ``rootedCall then ``call else ``genericCall) + (#[identifier ("::" ++ (← readName s[1]))] ++ (s.getArgs.toList.drop 2).toArray) + if k == ``rootedType then return node ``namedType #[identifier (← readName s[1])] + if k == ``qualifiedType || k == ``qualifiedAppliedType then + let name := String.intercalate "::" (← pathParts s[0]) + if k == ``qualifiedType then return node ``namedType #[identifier name] + return node ``appliedType #[identifier name, s[1], s[2], s[3]] + if [``qualifiedRecord, ``qualifiedGenericRecord, ``qualifiedRecordPattern, ``qualifiedGenericRecordPattern, + ``qualifiedGenericConstructor, ``qualifiedGenericConstructorArgs, ``qualifiedGenericPattern, ``qualifiedGenericPatternArgs, + ``qualifiedGenericCall].contains k then + let name := String.intercalate "::" (← pathParts s[0]) + let kind := if k == ``qualifiedRecord then ``recordExpr + else if k == ``qualifiedGenericRecord then ``genericRecordExpr + else if k == ``qualifiedRecordPattern then ``recordPattern + else if k == ``qualifiedGenericRecordPattern then ``genericRecordPattern + else if k == ``qualifiedGenericConstructor then ``genericConstructor + else if k == ``qualifiedGenericConstructorArgs then ``genericConstructorArgs + else if k == ``qualifiedGenericPattern then ``genericConstructorPattern + else if k == ``qualifiedGenericPatternArgs then ``genericConstructorPatternArgs + else ``genericCall + return node kind (s.getArgs.set! 0 (identifier name)) + if [``qualifiedValue, ``qualifiedCall, ``qualifiedPattern, ``qualifiedPatternArgs].contains k then + let parts ← pathParts s[0] + let first := (← parseRef 128 parts.head!).name + -- An unknown qualifier may be supplied by a separately parsed fragment. + -- Only types declared in this module can start local constructor paths. + let isModule := moduleNames.contains first || !localTypes.contains first + let constructor := parts.length > (if isModule then 2 else 1) + let inPattern := k == ``qualifiedPattern || k == ``qualifiedPatternArgs + let hasArgs := k == ``qualifiedCall || k == ``qualifiedPatternArgs + if constructor then + let name := String.intercalate "::" (parts.dropLast) + let ctor := parts.getLast! + let kind := if inPattern then (if hasArgs then ``constructorPatternArgs else ``constructorPattern) + else (if hasArgs then ``constructorCall else ``constructorExpr) + let args := #[identifier name, atom "::", identifier ctor] + return node kind (if hasArgs then args ++ #[s[1],s[2],s[3]] else args) + let name := String.intercalate "::" parts + if inPattern && hasArgs then throw "a const pattern does not take arguments" + if hasArgs then return node ``call #[identifier name,s[1],s[2],s[3]] + return node (if inPattern then ``globalPattern else ``globalExpr) #[atom "::",identifier name] + if [``constructorExpr, ``constructorCall, ``constructorPattern, ``constructorPatternArgs].contains k then + let head ← readName s[0] + if moduleNames.contains head || !localTypes.contains head then + let full := head ++ "::" ++ (← readName s[2]) + if k == ``constructorCall then return node ``call #[identifier full,s[3],s[4],s[5]] + if k == ``constructorPatternArgs then throw "a const pattern does not take arguments" + return node (if k == ``constructorPattern then ``globalPattern else ``globalExpr) #[atom "::",identifier full] + if k == ``qualifiedMap then + let nameOf := fun x => do + if x.getKind == ``globalName then readName x[0] + else return String.intercalate "::" (← pathParts x[0]) + return node ``mapDefinition ((s.getArgs.set! 8 (identifier (← nameOf s[8]))).set! 10 (identifier (← nameOf s[10]))) + return s + +def readDefinitions (ds : List Syntax) : Except String (Definitions Nat) := do + let enums ← (ds.filter (·.getKind == ``enumDecl)).mapM (fun d => lowerEnum d[0]) + let structs ← (ds.filter (·.getKind == ``structDecl)).mapM (fun d => lowerStruct d[0]) + let aliases ← (ds.filter (·.getKind == ``aliasDecl)).mapM (fun d => lowerAlias d[0]) + let constEntries ← (ds.filter (·.getKind == ``constDecl)).mapM fun d => do + let s := d[0] + let typed := s.getKind == ``typedConst + let annotation ← if typed then some <$> type [] s[3] else pure none + let decl : Generic.ConstDecl Nat := { name := ← readName s[1], value := ← Generic.Consts.ofExpr (← expr [] s[if typed then 5 else 3]) } + return (decl,annotation) + let consts := constEntries.map Prod.fst + let constTypes := constEntries.filterMap fun (d,t) => t.map (d.name, ·) + let functions ← (ds.filter (·.getKind == ``functionDecl)).mapM (fun d => lowerFunction [] [] [] d[0] false) + let parameterPatterns ← (ds.filter (·.getKind == ``functionDecl)).mapM fun d => do + let s := if d[0].getKind == `choice then d[0][0] else d[0] + let s := if s.getKind == ``inlineFunction then nativeChoice s[1] else s + let generic := s.getKind == ``genericFunction + let params ← if generic then s[3].getSepArgs.toList.mapM readName else pure [] + return (← readName s[1], ← s[if generic then 6 else 3].getSepArgs.toList.mapM fun p => pattern params p[0]) + let tables ← (ds.filter (·.getKind == ``tableDecl)).mapM fun d => do + let s := d[0] + return { name := ← readName s[1], rowType := ← type [] s[3], rows := ← s[5].getSepArgs.toList.mapM (expr []) : Generic.Table Nat } + let maps ← (ds.filter (·.getKind == ``mapDecl)).mapM fun d => do + let s := nativeChoice d[0] + let params ← s[3].getSepArgs.toList.mapM fun p => do + let .bind n ← pattern [] p[0] | throw "map parameters must be named bindings" + return (n, ← type [] p[2]) + return { name := ← readName s[1], params, result := ← type [] s[6], input := ← readName s[8], output := ← readName s[10] : Generic.MapDecl } + return ⟨{functions,enums,structs,aliases,consts,tables,maps}, constTypes, parameterPatterns, []⟩ + +def readSignature (s : Syntax) : Except String Signature := do + let mut result : Signature := {name := ← readName s[1]} + for m in s[3].getArgs do + let k := m.getKind + if [``sigAbstract, ``sigGenericAbstract, ``sigOpaqueAbstract, ``sigGenericOpaqueAbstract].contains k then + let isOpaque := k == ``sigOpaqueAbstract || k == ``sigGenericOpaqueAbstract + let offset := if isOpaque then 1 else 0 + let generic := k == ``sigGenericAbstract || k == ``sigGenericOpaqueAbstract + let params ← if generic then m[3 + offset].getSepArgs.toList.mapM readName else pure [] + result := {result with types := result.types ++ [⟨← readName m[1 + offset],params,none,isOpaque⟩]} + else if k == ``sigAlias then + let d ← lowerAlias m[0] + result := {result with types := result.types ++ [⟨d.name,d.typeParams,some d.target,false⟩]} + else if k == ``sigConst then + result := {result with consts := result.consts ++ [(← readName m[1], ← type [] m[3])]} + else if k == ``sigTable then + result := {result with tables := result.tables ++ [(← readName m[1], ← type [] m[3])]} + else + let generic := k == ``sigGenericFunction + let ps ← if generic then m[3].getSepArgs.toList.mapM readName else pure [] + let offset := if generic then 3 else 0 + let params ← m[3+offset].getSepArgs.toList.mapM fun param => do + let .bind name ← pattern ps param[0] | throw "signature parameters must be named bindings" + return (name, ← type ps param[2]) + result := {result with functions := result.functions ++ + [⟨← readName m[1],ps,params,← type ps m[6+offset]⟩]} + return result + +/-- A module-only root; source files and imports are not part of this frontend. -/ +private partial def checkIdentifiers (s : Syntax) : Except String Unit := do + if s.isIdent then + let n ← readName s + unless simpleIdentifier n || n == "Field" do throw s!"invalid source identifier '{n}'" + else s.getArgs.forM checkIdentifiers + +def parse (env : Lean.Environment) (source : String) : Except String (Program Nat) := do + let s ← Parser.runParserCategory env `aiur_modules (← prepareSource source) "" + checkIdentifiers s + let ds := s[0].getArgs.toList + let names ← (ds.filter (·.getKind != ``signatureDecl)).mapM fun d => readName d[1] + let mut result : Program Nat := {} + for s in ds do + if s.getKind == ``signatureDecl then + result := {result with signatures := result.signatures ++ [← readSignature (← normalize names [] s)]} + else + let parameters ← if s[2].getArgs.isEmpty then pure [] else + s[2][1].getSepArgs.toList.mapM fun p => return (← readName p[0], ← readName p[2]) + let signature ← if s[3].getArgs.isEmpty then pure none else some <$> readName s[3][1] + let body ← if s.getKind == ``moduleAlias then Body.alias <$> readRef s[5] else do + let members := s[5].getArgs.toList.map nativeChoice + let opaqueTypes ← (members.filter (·.getKind != ``ordinaryMember)).mapM + (fun m => readName (nativeChoice m[1])[1]) + let ds := members.map fun m => + if m.getKind == ``ordinaryMember then m[0] + else node (if m.getKind == ``opaqueAliasMember then ``aliasDecl + else if m.getKind == ``opaqueStructMember then ``structDecl else ``enumDecl) #[m[1]] + let localTypes ← (ds.filter fun d => [``enumDecl, ``structDecl, ``aliasDecl].contains d.getKind).mapM + (fun d => readName (nativeChoice d[0])[1]) + let ds ← ds.mapM (normalize (names ++ parameters.map Prod.fst) localTypes) + pure (Body.definitions { (← readDefinitions ds) with opaqueTypes }) + result := {result with modules := result.modules ++ [⟨← readName s[1],parameters,signature,body⟩]} + return result + +def ofString (env : Lean.Environment) (source : String) : Except String (Program Nat) := do + let p ← parse env source + checkTemplates p + return p + +@[term_elab Aiur.Frontend.aiurTerm] +def elabModules : TermElab := fun stx expected => do + let some expected := expected | throwUnsupportedSyntax + unless (← Meta.whnf expected).isAppOf ``Program do throwUnsupportedSyntax + match ofString (← getEnv) (stx[1].isStrLit?.getD "") with + | .error e => throwErrorAt stx[1] "{e}" + | .ok p => return Lean.toExpr p + +elab "aiur_modules% " source:str : term => do + match ofString (← getEnv) source.getString with + | .error e => throwErrorAt source "{e}" + | .ok p => return Lean.toExpr p + +end Aiur.Modules.Frontend diff --git a/Aiur/Aiur/Modules/Link.lean b/Aiur/Aiur/Modules/Link.lean new file mode 100644 index 000000000..49d7fea12 --- /dev/null +++ b/Aiur/Aiur/Modules/Link.lean @@ -0,0 +1,208 @@ +import Aiur.Modules.Check +import Aiur.Generic.Runtime + +namespace Aiur.Modules + +/-- Declarative global-name resolution. Local binders are handled separately by +the capture-avoiding structural rebinding in `reexpr`. -/ +inductive NameDenotes (p : Program α) (owner : Ref) (bindings : Bindings) : String → Ref → String → Prop where + | local (spelling : splitPath path = [member]) : + NameDenotes p owner bindings path owner (rename owner.symbol member) + | qualified (spelling : splitPath path = [ref.symbol, member]) + (resolved : Denotes p bindings ref target) : + NameDenotes p owner bindings path target (rename target.symbol member) + +structure ResolvedName (p : Program α) (owner : Ref) (bindings : Bindings) + (instances : List Ref) (path : String) where + target : Ref + name : String + denotes : NameDenotes p owner bindings path target name + closed : instances.contains target = true + +def resolveName (p : Program α) (owner : Ref) (bindings : Bindings) (instances : List Ref) + (path : String) : Except String (ResolvedName p owner bindings instances path) := do + match spelling : splitPath path with + | [member] => + if closed : instances.contains owner = true then + return ⟨owner, rename owner.symbol member, .local spelling, closed⟩ + else throw "local module is absent from the declaration environment" + | [head, member] => + let ref ← parseRef 128 head + if canonical : ref.symbol = head then + let target ← resolve p bindings 128 ref + if closed : instances.contains target.value = true then + return ⟨target.value, rename target.value.symbol member, + .qualified (by simpa [canonical] using spelling) target.valid, closed⟩ + else throw s!"unlinked dependency '{target.value.symbol}'" + else throw "module paths must use canonical identifier syntax" + | _ => throw s!"expected a module-qualified member, got '{path}'" + +/-- A certified substitution for global identifiers, independent of the module +collector's cache and traversal order. -/ +structure Relocation (p : Program α) (owner : Ref) (bindings : Bindings) (instances : List Ref) where + lookup : Access → String → Except String String + valid : ∀ access path name, lookup access path = .ok name → + ∃ target, NameDenotes p owner bindings path target name ∧ instances.contains target = true + +def relocation (p : Program α) (owner : Ref) (bindings : Bindings) (instances : List Ref) : + Relocation p owner bindings instances where + lookup := fun _ path => (resolveName p owner bindings instances path).map (·.name) + valid := by + intro access path name success + cases h : resolveName p owner bindings instances path with + | error e => simp [h, Except.map] at success + | ok result => + simp only [h, Except.map, Except.ok.injEq] at success + subst name + exact ⟨result.target, result.denotes, result.closed⟩ + +/-- One environment fragment is exactly an original module body under a +certified name substitution. This specification mentions neither `collect` +nor `checkTemplates`, and contains no interface placeholder bodies. -/ +structure Fragment (p : Program α) (instances : List Ref) where + key : Ref + decl : Module α + definitions : Definitions α + found : p.findModule? key.name = some decl + body : decl.body = .definitions definitions + arity : decl.parameters.length = key.args.length + names : Relocation p key ((decl.parameters.map Prod.fst).zip key.args) instances + program : Generic.Program α + relocated : rewrite key.symbol names.lookup definitions.program = .ok program + +def linkFragment (p : Program α) (instances : List Ref) (key : Ref) : + Except String { fragment : Fragment p instances // fragment.key = key } := do + match found : p.findModule? key.name with + | none => throw s!"unknown module '{key.name}'" + | some decl => + match body : decl.body with + | .alias _ => throw "aliases must resolve to definitions before linking" + | .definitions definitions => + if arity : decl.parameters.length = key.args.length then + let names := relocation p key ((decl.parameters.map Prod.fst).zip key.args) instances + match h : rewrite key.symbol names.lookup definitions.program with + | .error e => throw e + | .ok program => return ⟨⟨key,decl,definitions,found,body,arity,names,program,h⟩,rfl⟩ + else throw "unbound module parameters during linking" + +structure Fragments (p : Program α) (instances keys : List Ref) where + values : List (Fragment p instances) + covers : values.map (·.key) = keys + +def linkFragments (p : Program α) (instances : List Ref) : + (keys : List Ref) → Except String (Fragments p instances keys) + | [] => return ⟨[],rfl⟩ + | key :: keys => do + let head ← linkFragment p instances key + let tail ← linkFragments p instances keys + return ⟨head.val :: tail.values, by simp [head.property, tail.covers]⟩ + +def combine {p : Program α} {instances : List Ref} (fragments : List (Fragment p instances)) : Generic.Program α := + fragments.foldl (fun program fragment => append program fragment.program) {functions := []} + +/-- Static semantics of a linked declaration environment. Every definition +comes from a source module, rebinding is valid, and all module dependencies are +present. Extra unreachable instances are harmless and may remain. -/ +structure Assembly (p : Program α) where + instances : List Ref + fragments : Fragments p instances instances + program : Generic.Program α + assembled : combine fragments.values = program + +def assemble (p : Program α) (world : World α) : Except String (Assembly p) := do + let instances := (world.items.filter (·.target.isNone)).map (·.key) + let fragments ← linkFragments p instances instances + return ⟨instances,fragments,combine fragments.values,rfl⟩ + +/-- Expose the useful source-to-environment fact without referring to a +particular elaboration implementation. -/ +theorem Assembly.fragment_origin (a : Assembly p) (f : Fragment p a.instances) + (_present : f ∈ a.fragments.values) : + p.findModule? f.key.name = some f.decl ∧ + f.decl.body = .definitions f.definitions ∧ + rewrite f.key.symbol f.names.lookup f.definitions.program = .ok f.program := + ⟨f.found,f.body,f.relocated⟩ + +theorem combine_functions {p : Program α} {instances : List Ref} + (fragments : List (Fragment p instances)) : + (combine fragments).functions = fragments.flatMap (·.program.functions) := by + have aux : ∀ initial : Generic.Program α, + (fragments.foldl (fun program fragment => append program fragment.program) initial).functions = + initial.functions ++ fragments.flatMap (·.program.functions) := by + induction fragments with + | nil => intro initial; simp + | cons head tail ih => + intro initial + rw [List.foldl_cons, ih] + simp [append, List.append_assoc] + simpa [combine] using aux {functions := []} + +/-- Linking cannot invent a function: each member of the resulting environment +belongs to a certified rebinding of an original module body. -/ +theorem Assembly.function_origin (a : Assembly p) (present : f ∈ a.program.functions) : + ∃ fragment ∈ a.fragments.values, + f ∈ fragment.program.functions ∧ + p.findModule? fragment.key.name = some fragment.decl ∧ + fragment.decl.body = .definitions fragment.definitions := by + rw [← a.assembled, combine_functions] at present + obtain ⟨fragment, member, present⟩ := List.mem_flatMap.mp present + exact ⟨fragment,member,present,fragment.found,fragment.body⟩ + +structure Selection (p : Program α) (instances : List Ref) where + external : String + resolved : ResolvedName p (.mk "" []) [] instances external + +/-- The semantic context is an independently specified assembly plus the +existing checked native source. Module syntax adds no expression-evaluation rules. -/ +structure Environment (p : Program F) [DecidableEq F] where + assembly : Assembly p + source : Generic.Source F + checked : Generic.prepare assembly.program = .ok source + +structure Prepared (p : Program F) [DecidableEq F] where + environment : Environment p + selections : List (Selection p environment.assembly.instances) + +def prepare [DecidableEq F] (p : Program F) (entries : List String) : Except String (Prepared p) := do + checkTemplates p + let (world,_) ← collect p entries + checkWorld p world + entries.forM (checkEntryInputs p world) + let assembly ← assemble p world + match checked : Generic.prepare assembly.program with + | .error e => throw e + | .ok source => + let selections ← entries.mapM fun external => do + let resolved ← resolveName p (.mk "" []) [] assembly.instances external + source.checkEntry resolved.name + return {external,resolved : Selection p assembly.instances} + return ⟨⟨assembly,source,checked⟩, selections⟩ + +def Prepared.entries [DecidableEq F] (p : Prepared (program : Program F)) : List String := + p.selections.map (·.resolved.name) + +def Prepared.find? [DecidableEq F] (p : Prepared (program : Program F)) (name : String) := + p.selections.find? (·.external == name) + +def Prepared.run [Field F] [DecidableEq F] (p : Prepared (program : Program F)) (name : String) + (args : List (SourceValue F)) (fuel : Nat := 1000) + (hints : p.environment.source.HintProvider := Generic.SourceSemantics.unavailable) : + Except String (SourceValue F × Heap F) := do + let some entry := p.find? name | throw s!"unselected entrypoint '{name}'" + p.environment.source.run entry.resolved.name args fuel hints + +def Prepared.EvalCall [Field F] [DecidableEq F] (p : Prepared (program : Program F)) + (name : String) (args : List (SourceValue F)) (value : SourceValue F) : Prop := + ∃ entry, p.find? name = some entry ∧ p.environment.source.EvalCall entry.resolved.name args value + +theorem Prepared.run_spec [Field F] [DecidableEq F] {p : Prepared (program : Program F)} + {hints : p.environment.source.HintProvider} + (executed : p.run name args fuel hints = .ok (value, heap)) : p.EvalCall name args value := by + cases selected : p.find? name with + | none => simp [Prepared.run,selected] at executed + | some entry => + simp only [Prepared.run,selected] at executed + obtain ⟨checked,evaluated⟩ := Generic.Source.run_spec executed + exact ⟨entry,selected,checked,heap,evaluated⟩ + +end Aiur.Modules diff --git a/Aiur/Aiur/Modules/Opacity.lean b/Aiur/Aiur/Modules/Opacity.lean new file mode 100644 index 000000000..fa8ad3ec8 --- /dev/null +++ b/Aiur/Aiur/Modules/Opacity.lean @@ -0,0 +1,105 @@ +import Aiur.Modules.Elaborate + +/-! Opacity is static module information. These checks run on retained type +names, before representation aliases are normalized. They do not rewrite code. -/ +namespace Aiur.Modules + +def Item.declaredOpaqueTypes (item : Item α) : List String := + match item.decl.body with + | .definitions d => d.opaqueTypes.map (rename item.key.symbol) + | .alias _ => [] + +/-- Input permissions come from the view supplied to a client. The defining +module may inspect its representation, but its own opaque declarations still +cannot be supplied as entry arguments or hint results. -/ +def opaqueNames (p : Program α) (w : World α) (owner : Ref) : List String := + w.items.flatMap fun item => + item.declaredOpaqueTypes ++ + if item.key == owner then [] else + ((item.decl.signature.bind p.findSignature?).toList.flatMap fun s => + (s.types.filter (·.isOpaque)).map fun t => rename item.key.symbol t.name) + +/-- Recursive input admissibility. Abstract signature parameters may promise +admissibility; pointers are intrinsically opaque. Empty arrays still inspect +their element type, and all enum variants are inspected. -/ +def nonOpaque (p : Generic.Program α) (opaqueTypes parameters : List String) : + Nat → Generic.Ty → Bool + | 0, _ => false + | fuel + 1, type => match type with + | .field => true + | .ptr _ => false + | .param name => parameters.contains name + | .tuple types => types.all (nonOpaque p opaqueTypes parameters fuel) + | .array type _ => nonOpaque p opaqueTypes parameters fuel type + | .named name args => + if opaqueTypes.contains name then false else + match p.aliases.find? (·.name == name) with + | some d => d.typeParams.length == args.length && + nonOpaque p opaqueTypes parameters fuel (d.target.subst (d.typeParams.zip args)) + | none => match p.findEnum? name with + | none => false + | some d => d.typeParams.length == args.length && + d.constructors.all fun c => c.fields.all fun t => + nonOpaque p opaqueTypes parameters fuel (t.subst (d.typeParams.zip args)) + +def checkNonOpaque (p : Generic.Program α) (opaqueTypes : List String) + (context : String) (type : Generic.Ty) (parameters : List String := []) : Except String Unit := + if nonOpaque p opaqueTypes parameters 1024 type then .ok () + else .error s!"{context} requires a recursively non-opaque type (pointers are opaque): {repr type}" + +@[simp] theorem nonOpaque_pointer : + nonOpaque p opaqueTypes parameters fuel (.ptr type) = false := by + cases fuel <;> rfl + +theorem nonOpaque_declared (present : opaqueTypes.contains name = true) : + nonOpaque p opaqueTypes parameters fuel (.named name args) = false := by + cases fuel <;> simp only [nonOpaque, present, ite_true] + +@[simp] theorem nonOpaque_array : + nonOpaque p opaqueTypes parameters (fuel + 1) (.array type length) = + nonOpaque p opaqueTypes parameters fuel type := rfl + +/-- Input permissions are independent of the field and of numeric literals. -/ +theorem nonOpaque_map (f : α → β) (p : Generic.Program α) (opaqueTypes parameters) + (fuel : Nat) (type : Generic.Ty) : + nonOpaque (p.map f) opaqueTypes parameters fuel type = + nonOpaque p opaqueTypes parameters fuel type := by + induction fuel generalizing type with + | zero => rfl + | succ fuel ih => + have aliases : (p.map f).aliases = p.aliases := rfl + have enums : (p.map f).findEnum? = p.findEnum? := rfl + have same : nonOpaque (p.map f) opaqueTypes parameters fuel = + nonOpaque p opaqueTypes parameters fuel := funext ih + cases type <;> simp only [nonOpaque, aliases, enums, same] + +/-- A client's nominal placeholder is private to checking and never enters +the source evaluation environment or a circuit layout. -/ +def sealTypes (p : Generic.Program α) (names : List String) : Generic.Program α := + let declarations := p.nominals.map (fun d => (d.name, d.typeParams)) ++ + p.aliases.map (fun d => (d.name, d.typeParams)) + { p with + aliases := p.aliases.filter (fun d => !names.contains d.name) + structs := p.structs.filter (fun d => !names.contains d.name) + enums := p.enums.filter (fun d => !names.contains d.name) ++ + (declarations.filter (fun d => names.contains d.1)).map fun (name, params) => + ⟨name, params, [⟨"@opaque", [.ptr .field]⟩]⟩ } + +/-- Collect every explicitly requested witness type, including inactive code +and hint keys. The source expression itself is left untouched. -/ +def hintTypes : Generic.Expr α → List Generic.Ty + | .literal _ | .var _ | .global _ _ => [] + | .tuple xs | .array xs | .construct _ _ _ xs | .constructAs _ _ _ xs | + .record _ xs | .builtin _ xs | .update _ xs | .call _ _ xs => xs.flatMap hintTypes + | .control _ x | .repeat x _ | .index x _ | .slice x _ _ | .member x _ | + .project x _ | .store x | .load x | .neg x => hintTypes x + | .hint t key channel => t :: hintTypes key + | .binary _ x y | .letValue _ x y => hintTypes x ++ hintTypes y + | .matchValue x arms => hintTypes x ++ arms.flatMap (fun arm => hintTypes arm.2) +termination_by e => sizeOf e +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; try omega + all_goals cases ‹Generic.Pattern α × Generic.Expr α›; simp_all only [Prod.mk.sizeOf_spec]; omega + +end Aiur.Modules diff --git a/Aiur/Aiur/Modules/Resolution.lean b/Aiur/Aiur/Modules/Resolution.lean new file mode 100644 index 000000000..ca24a3b07 --- /dev/null +++ b/Aiur/Aiur/Modules/Resolution.lean @@ -0,0 +1,127 @@ +import Aiur.Modules.AST +import Mathlib.Data.List.Forall2 + +namespace Aiur.Modules + +abbrev Bindings := List (String × Ref) + +/- The static meaning of application and aliases. This relation has no fuel, +cache or elaborator in its definition. Canonical instances always name a body, +and aliases introduce no new identity. -/ +mutual +inductive Denotes (p : Program α) : Bindings → Ref → Ref → Prop where + | parameter (found : bindings.lookup name = some value) : + Denotes p bindings (.mk name []) value + | definitions (found : p.findModule? name = some decl) + (body : decl.body = .definitions definitions) + (arguments : DenotesMany p bindings args actual) + (arity : decl.parameters.length = actual.length) : + Denotes p bindings (.mk name args) (.mk name actual) + | alias (found : p.findModule? name = some decl) + (body : decl.body = .alias target) + (arguments : DenotesMany p bindings args actual) + (arity : decl.parameters.length = actual.length) + (applied : Denotes p ((decl.parameters.map Prod.fst).zip actual) target result) : + Denotes p bindings (.mk name args) result + +inductive DenotesMany (p : Program α) : Bindings → List Ref → List Ref → Prop where + | nil : DenotesMany p bindings [] [] + | cons : Denotes p bindings a b → DenotesMany p bindings as bs → + DenotesMany p bindings (a :: as) (b :: bs) +end + +structure Resolution (p : Program α) (bindings : Bindings) (ref : Ref) where + value : Ref + valid : Denotes p bindings ref value + +structure Resolutions (p : Program α) (bindings : Bindings) (refs : List Ref) where + values : List Ref + valid : DenotesMany p bindings refs values + +mutual + /-- Bounded implementation of declarative resolution. Bounds only reject + programs; every successful result carries its independent derivation. -/ + def resolve (p : Program α) (bindings : Bindings) : + (fuel : Nat) → (ref : Ref) → Except String (Resolution p bindings ref) + | 0, _ => .error "module expansion depth exceeded (possible cyclic alias)" + | fuel + 1, .mk name args => do + if h : args = [] then + match found : bindings.lookup name with + | some value => return ⟨value, by subst args; exact .parameter found⟩ + | none => pure () + else if (bindings.lookup name).isSome then + throw s!"module parameter '{name}' cannot be applied" + match found : p.findModule? name with + | none => throw s!"unknown module '{name}'" + | some decl => + let actual ← resolveMany p bindings fuel args + if arity : decl.parameters.length = actual.values.length then + match body : decl.body with + | .definitions definitions => + return ⟨.mk name actual.values, .definitions found body actual.valid arity⟩ + | .alias target => + let result ← resolve p ((decl.parameters.map Prod.fst).zip actual.values) fuel target + return ⟨result.value, .alias found body actual.valid arity result.valid⟩ + else throw s!"module '{name}' expects {decl.parameters.length} arguments" + termination_by fuel _ => (fuel, 0) + + def resolveMany (p : Program α) (bindings : Bindings) (fuel : Nat) : + (refs : List Ref) → Except String (Resolutions p bindings refs) + | [] => return ⟨[], .nil⟩ + | ref :: refs => do + let head ← resolve p bindings fuel ref + let tail ← resolveMany p bindings fuel refs + return ⟨head.value :: tail.values, .cons head.valid tail.valid⟩ + termination_by refs => (fuel, refs.length + 1) +end + +/-- Rootless paths in expressions retain their spelling until module resolution. +Splitting respects nested applications such as `F::>::f`. -/ +def splitPath (path : String) : List String := Id.run do + let chars := path.toList + let mut depth := 0 + let mut current := [] + let mut parts := [] + let mut i := 0 + while i < chars.length do + let c := chars[i]! + if c == ':' && chars[i + 1]? == some ':' && depth == 0 && chars[i + 2]? != some '<' then + if !current.isEmpty then parts := parts ++ [String.ofList current] + current := [] + i := i + 2 + else + if c == '<' then depth := depth + 1 + if c == '>' then depth := depth - 1 + current := current ++ [c] + i := i + 1 + if !current.isEmpty then parts := parts ++ [String.ofList current] + return parts + +private def splitArgs (chars : List Char) : List String := Id.run do + let mut depth := 0 + let mut current := [] + let mut parts := [] + for c in chars do + if c == ',' && depth == 0 then + parts := parts ++ [String.ofList current] + current := [] + else + if c == '<' then depth := depth + 1 + if c == '>' then depth := depth - 1 + current := current ++ [c] + return parts ++ [String.ofList current] + +def parseRef : Nat → String → Except String Ref + | 0, _ => .error "module path depth exceeded" + | fuel + 1, text => do + let text := text.trimAscii.toString + let parts := text.splitOn "::<" + let name := parts.head! + if name.isEmpty then throw "empty module name" + if parts.length == 1 then return .mk name [] + if !text.endsWith ">" then throw "unterminated module application" + let args := ((text.drop (name.length + 3)).toString.dropEnd 1).toString + let refs ← (splitArgs args.toList).mapM (parseRef fuel) + return .mk name refs + +end Aiur.Modules diff --git a/Aiur/Aiur/Modules/Rewrite.lean b/Aiur/Aiur/Modules/Rewrite.lean new file mode 100644 index 000000000..62f9dc9de --- /dev/null +++ b/Aiur/Aiur/Modules/Rewrite.lean @@ -0,0 +1,152 @@ +import Aiur.Modules.Resolution +import Aiur.Generic.Elaborate + +namespace Aiur.Modules + +inductive Access where + | type | constructor | constant | callable | table + deriving Repr, BEq, DecidableEq, Inhabited + +/-- Rebinding changes global names, never evaluation structure or local binders. +The callback is also used for visibility checks and dependency discovery. -/ +def retype [Monad m] [LawfulMonad m] (name : String → m String) : Generic.Ty → m Generic.Ty + | .field => pure .field + | .param p => pure (.param p) + | .ptr t => return .ptr (← retype name t) + | .array t n => return .array (← retype name t) n + | .tuple ts => return .tuple (← ts.attach.mapM (fun t => retype name t.val)) + | .named n ts => return .named (← name n) (← ts.attach.mapM (fun t => retype name t.val)) +termination_by t => sizeOf t +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem t.property; omega + +/-- Constructibility concerns the outer type. An abstract type is still a +valid type argument to an exposed tuple/record/enum constructor. -/ +def reConstructorType [Monad m] [LawfulMonad m] (name : Access → String → m String) : Generic.Ty → m Generic.Ty + | .named n ts => return .named (← name .constructor n) (← ts.mapM (retype (name .type))) + | t => retype (name .type) t + +def rehead [Monad m] [LawfulMonad m] (name : Access → String → m String) (h : Generic.RecordHead) := do + let t ← reConstructorType name h.type + return { h with type := t } + +def repattern [Monad m] [LawfulMonad m] (name : Access → String → m String) : Generic.Pattern α → m (Generic.Pattern α) + | .literal x => pure (.literal x) + | .wildcard => pure .wildcard + | .bind n => pure (.bind n) + | .global n t => return .global (← name .constant n) (← t.mapM (retype (name .type))) + | .load p => return .load (← repattern name p) + | .orElse p q bs => return .orElse (← repattern name p) (← repattern name q) bs + | .tuple ps => return .tuple (← ps.attach.mapM (fun p => repattern name p.val)) + | .array ps => return .array (← ps.attach.mapM (fun p => repattern name p.val)) + | .repeat p n => return .repeat (← repattern name p) n + | .record h ps => return .record (← rehead name h) (← ps.attach.mapM (fun p => repattern name p.val)) + | .construct t c ps => return .construct (← reConstructorType name t) c (← ps.attach.mapM (fun p => repattern name p.val)) + | .constructAs params t c ps => + return .constructAs params (← reConstructorType name t) c (← ps.attach.mapM (fun p => repattern name p.val)) +termination_by p => sizeOf p +decreasing_by + all_goals simp_wf + all_goals first | omega | have h := List.sizeOf_lt_of_mem p.property; omega + +def refield [Monad m] [LawfulMonad m] (name : Access → String → m String) (f : Generic.FieldRef) := do + return { f with owner := ← f.owner.mapM (retype (name .type)) } + +def restep [Monad m] [LawfulMonad m] (name : Access → String → m String) : Generic.UpdateStep → m Generic.UpdateStep + | .member f => return .member (← refield name f) + | .index i n => pure (.index i n) + | .project i n => pure (.project i n) + +def reexpr [Monad m] [LawfulMonad m] [MonadExceptOf String m] (name : Access → String → m String) + (locals : List String) : Generic.Expr α → m (Generic.Expr α) + | .literal x => pure (.literal x) + | .var n => if locals.contains n then pure (.var n) else return .global (← name .constant n) + | .global n t => return .global (← name .constant n) (← t.mapM (retype (name .type))) + | .tuple xs => return .tuple (← xs.attach.mapM (fun x => reexpr name locals x.val)) + | .array xs => return .array (← xs.attach.mapM (fun x => reexpr name locals x.val)) + | .repeat x n => return .repeat (← reexpr name locals x) n + | .index x n => return .index (← reexpr name locals x) n + | .slice x a b => return .slice (← reexpr name locals x) a b + | .construct n ts c xs => + return .construct (← name .constructor n) + (← ts.mapM (List.mapM (retype (name .type)))) c (← xs.attach.mapM (fun x => reexpr name locals x.val)) + | .constructAs ps t c xs => + return .constructAs ps (← reConstructorType name t) c + (← xs.attach.mapM (fun x => reexpr name locals x.val)) + | .record h xs => return .record (← rehead name h) (← xs.attach.mapM (fun x => reexpr name locals x.val)) + | .member x f => return .member (← reexpr name locals x) (← refield name f) + | .update ps xs => return .update (← ps.mapM (List.mapM (restep name))) (← xs.attach.mapM (fun x => reexpr name locals x.val)) + | .builtin op xs => return .builtin (← op.mapTypesM (retype (name .type))) (← xs.attach.mapM (fun x => reexpr name locals x.val)) + | .project x n => return .project (← reexpr name locals x) n + | .letValue p x b => + return .letValue (← repattern name p) (← reexpr name locals x) + (← reexpr name (p.bindingNames ++ locals) b) + | .store x => return .store (← reexpr name locals x) + | .load x => return .load (← reexpr name locals x) + | .hint t x channel => return .hint (← retype (name .type) t) (← reexpr name locals x) channel + | .neg x => return .neg (← reexpr name locals x) + | .binary op x y => return .binary op (← reexpr name locals x) (← reexpr name locals y) + | .call n ts xs => do + if locals.contains n then throw s!"local '{n}' is not callable; qualify the global function" + return .call (← name .callable n) (← ts.mapM (List.mapM (retype (name .type)))) + (← xs.attach.mapM (fun x => reexpr name locals x.val)) + | .matchValue x arms => + return .matchValue (← reexpr name locals x) + (← arms.attach.mapM fun arm => return (← repattern name arm.val.1, ← reexpr name (arm.val.1.bindingNames ++ locals) arm.val.2)) + | .control c x => return .control c (← reexpr name locals x) +termination_by e => sizeOf e +decreasing_by + all_goals simp_wf + all_goals + first + | omega + | have h := List.sizeOf_lt_of_mem x.property; omega + | have h := List.sizeOf_lt_of_mem arm.property + rcases arm with ⟨⟨p,b⟩,mem⟩ + simp_all only [Prod.mk.sizeOf_spec] + omega + +def rename (owner name : String) := owner ++ "::" ++ name + +def rewrite [Monad m] [LawfulMonad m] [MonadExceptOf String m] (owner : String) + (name : Access → String → m String) (p : Generic.Program α) : m (Generic.Program α) := do + let functions ← p.functions.mapM fun f => do + return { f with + name := rename owner f.name + params := ← f.params.mapM fun (n,t) => return (n, ← retype (name .type) t) + result := ← retype (name .type) f.result + body := ← reexpr name (f.params.map Prod.fst) f.body } + let enums ← p.enums.mapM fun d => do + return { d with + name := rename owner d.name + constructors := ← d.constructors.mapM fun c => do + return { c with fields := ← c.fields.mapM (retype (name .type)) } } + let structs ← p.structs.mapM fun d => do + return { d with + name := rename owner d.name + fields := ← d.fields.mapM fun (n,t) => return (n, ← retype (name .type) t) } + let aliases ← p.aliases.mapM fun d => do + return { d with + name := rename owner d.name, target := ← retype (name .type) d.target } + let consts ← p.consts.mapM fun d => do + return { d with + name := rename owner d.name, value := ← repattern name d.value } + let tables ← p.tables.mapM fun d => do + return { d with + name := rename owner d.name, rowType := ← retype (name .type) d.rowType + rows := ← d.rows.mapM (reexpr name []) } + let maps ← p.maps.mapM fun d => do + return { d with + name := rename owner d.name + params := ← d.params.mapM fun (n,t) => return (n, ← retype (name .type) t) + result := ← retype (name .type) d.result + input := ← name .table d.input, output := ← name .table d.output } + return { functions, enums, structs, aliases, consts, tables, maps } + +def append (p q : Generic.Program α) : Generic.Program α := { + functions := p.functions ++ q.functions, enums := p.enums ++ q.enums + structs := p.structs ++ q.structs, aliases := p.aliases ++ q.aliases + consts := p.consts ++ q.consts, tables := p.tables ++ q.tables, maps := p.maps ++ q.maps } + +end Aiur.Modules diff --git a/Aiur/Aiur/Optimized.lean b/Aiur/Aiur/Optimized.lean new file mode 100644 index 000000000..ee4b97c7a --- /dev/null +++ b/Aiur/Aiur/Optimized.lean @@ -0,0 +1,11 @@ +import Aiur.Optimized.Basic +import Aiur.Optimized.Compile +import Aiur.Optimized.Layout +import Aiur.Optimized.Dedup +import Aiur.Optimized.Program +import Aiur.Optimized.Correctness +import Aiur.Optimized.NativeCorrectness +import Aiur.Optimized.Physical +import Aiur.Optimized.Activation +import Aiur.Optimized.Grouping.Plan +import Aiur.Optimized.EndToEnd diff --git a/Aiur/Aiur/Optimized/Activation.lean b/Aiur/Aiur/Optimized/Activation.lean new file mode 100644 index 000000000..a8b68d309 --- /dev/null +++ b/Aiur/Aiur/Optimized/Activation.lean @@ -0,0 +1,184 @@ +import Aiur.Optimized.PhysicalSemantics +import Mathlib.Data.List.Dedup + +/-! +An activation pass for the final physical circuit. It preserves every active +row and makes the all-zero row silent padding, without multiplying every +constraint by another selector. This is separate from the source compiler: +its existing local-rule correctness theorem composes with `active_rule_iff`. +-/ + +namespace Aiur.Optimized.Activation + +open Circuit +variable {F : Type} [Field F] [DecidableEq F] + +/-- Replace the constant term by that constant times the row selector. -/ +def polynomial (selector : Nat) (p : Polynomial F) : Polynomial F := + Polynomial.simplify (.sub p (.mul (.const (p.denote fun _ => 0)) (.sub (.const 1) (.var selector)))) + +@[simp] theorem polynomial_active (selector : Nat) (p : Polynomial F) + (a : Nat → F) (active : a selector = 1) : + (polynomial selector p).denote a = p.denote a := by + simp [polynomial, Polynomial.denote_simplify, Scalar.Circuit.ArithExpr.denote, active] + +@[simp] theorem polynomial_zero (selector : Nat) (p : Polynomial F) : + (polynomial selector p).denote (fun _ => 0) = 0 := by + simp [polynomial, Polynomial.denote_simplify, Scalar.Circuit.ArithExpr.denote] + +def boolean (selector : Nat) : Polynomial F := + .mul (.var selector) (.sub (.var selector) (.const 1)) + +def silent (selector : Nat) (enable : Polynomial F) : Polynomial F := + Polynomial.simplify (.mul (.sub (.const 1) (.var selector)) enable) + +def send (selector : Nat) (s : Send F) : Send F := + { s with enable := polynomial selector s.enable } + +def memory (selector : Nat) (m : MemoryLookup F) : MemoryLookup F := + { m with enable := polynomial selector m.enable } + +/-- Explicit silence constraints cover arbitrary chips, including nonzero +inactive assignments. Repeated enables share a single such constraint. -/ +def guards (chip : Chip F) : List (Polynomial F) := + ((chip.sends.map fun s => (send chip.numVars s).enable) ++ + (chip.memory.map fun m => (memory chip.numVars m).enable)).dedup + +def compile (chip : Chip F) : Chip F := + { chip with + numVars := chip.numVars + 1 + constraints := boolean chip.numVars :: + chip.constraints.map (polynomial chip.numVars) ++ + (guards chip).map (silent chip.numVars) + sends := chip.sends.map (send chip.numVars) + memory := chip.memory.map (memory chip.numVars) } + +theorem selector_boolean (chip : Chip F) (a : Nat → F) + (valid : (compile chip).ValidAssignment rom a) : + a chip.numVars = 0 ∨ a chip.numVars = 1 := by + have h := valid.1 (boolean chip.numVars) (by simp [compile]) + simpa [boolean, Scalar.Circuit.ArithExpr.denote, mul_eq_zero, sub_eq_zero] using h + +theorem guard_inactive (chip : Chip F) (a : Nat → F) + (valid : (compile chip).ValidAssignment rom a) (inactive : a chip.numVars = 0) + (g : Polynomial F) (member : g ∈ guards chip) : g.denote a = 0 := by + have h := valid.1 (silent chip.numVars g) + (List.mem_cons_of_mem _ (List.mem_append_right _ (List.mem_map.mpr ⟨g, member, rfl⟩))) + simpa [silent, Polynomial.denote_simplify, Scalar.Circuit.ArithExpr.denote, inactive] using h + +theorem requirements_inactive (chip : Chip F) (a : Nat → F) + (valid : (compile chip).ValidAssignment rom a) (inactive : a chip.numVars = 0) : + (compile chip).requirements a = [] := by + simp only [Chip.requirements, compile, List.filterMap_map] + apply List.filterMap_eq_nil_iff.mpr + intro s member + have h := guard_inactive chip a valid inactive (send chip.numVars s).enable (by + apply List.mem_dedup.mpr + exact List.mem_append_left _ (List.mem_map.mpr ⟨s, member, rfl⟩)) + simp [h] + +theorem memory_inactive (chip : Chip F) (a : Nat → F) + (valid : (compile chip).ValidAssignment rom a) (inactive : a chip.numVars = 0) + (m : MemoryLookup F) (member : m ∈ (compile chip).memory) : m.enable.denote a = 0 := by + obtain ⟨source, sourceMember, rfl⟩ := List.mem_map.mp member + exact guard_inactive chip a valid inactive _ (by + apply List.mem_dedup.mpr + exact List.mem_append_right _ (List.mem_map.mpr ⟨source, sourceMember, rfl⟩)) + +theorem valid_active_iff (chip : Chip F) (a : Nat → F) (active : a chip.numVars = 1) : + (compile chip).ValidAssignment rom a ↔ chip.ValidAssignment rom a := by + have constraint (p : Polynomial F) : + (polynomial chip.numVars p).denote a = p.denote a := polynomial_active _ _ _ active + have silence (p : Polynomial F) : (silent chip.numVars p).denote a = 0 := by + simp [silent, Polynomial.denote_simplify, Scalar.Circuit.ArithExpr.denote, active] + constructor + · intro valid + refine ⟨fun p member => ?_, fun m member => ?_⟩ + · have h := valid.1 (polynomial chip.numVars p) + (List.mem_cons_of_mem _ (List.mem_append_left _ (List.mem_map.mpr ⟨p, member, rfl⟩))) + simpa only [constraint] using h + · have h := valid.2 (memory chip.numVars m) (List.mem_map.mpr ⟨m, member, rfl⟩) + simpa only [memory, MemoryLookup.Valid, constraint] using h + · intro valid + refine ⟨?_, ?_⟩ + · intro p member + rcases List.mem_cons.mp member with rfl | member + · simp [boolean, Scalar.Circuit.ArithExpr.denote, active] + · rcases List.mem_append.mp member with member | member + · obtain ⟨p, sourceMember, rfl⟩ := List.mem_map.mp member + simpa only [constraint] using valid.1 p sourceMember + · obtain ⟨p, _, rfl⟩ := List.mem_map.mp member + exact silence p + · intro m member + obtain ⟨m, sourceMember, rfl⟩ := List.mem_map.mp member + simpa only [memory, MemoryLookup.Valid, constraint] using valid.2 m sourceMember + +theorem requirements_active (chip : Chip F) (a : Nat → F) (active : a chip.numVars = 1) : + (compile chip).requirements a = chip.requirements a := by + simp [Chip.requirements, compile, List.filterMap_map, send, Send.message, active] + +theorem conclusion_eq (chip : Chip F) (a : Nat → F) : + (compile chip).conclusion a = chip.conclusion a := rfl + +/-- Zero padding needs no source values, hints, ROM membership, or calls. -/ +theorem zero_valid (chip : Chip F) (rom : WireROM F) : + (compile chip).ValidAssignment rom (fun _ => 0) := by + refine ⟨?_, ?_⟩ + · intro p member + rcases List.mem_cons.mp member with rfl | member + · simp [boolean, Scalar.Circuit.ArithExpr.denote] + · rcases List.mem_append.mp member with member | member + · obtain ⟨p, _, rfl⟩ := List.mem_map.mp member + exact polynomial_zero _ _ + · obtain ⟨g, guardMember, rfl⟩ := List.mem_map.mp member + have zero : g.denote (fun _ => 0) = 0 := by + simp only [guards, List.mem_dedup, List.mem_append, List.mem_map] at guardMember + rcases guardMember with member | member + · obtain ⟨s, _, same⟩ := member + rw [← same] + exact polynomial_zero _ _ + · obtain ⟨m, _, same⟩ := member + rw [← same] + exact polynomial_zero _ _ + simp [silent, Polynomial.denote_simplify, Scalar.Circuit.ArithExpr.denote, zero] + · intro m member + obtain ⟨m, _, rfl⟩ := List.mem_map.mp member + simp [memory, MemoryLookup.Valid] + +theorem zero_requirements (chip : Chip F) (rom : WireROM F) : + (compile chip).requirements (fun _ => 0) = [] := + requirements_inactive chip _ (zero_valid chip rom) rfl + +/-- The active part of the transformed chip has exactly the original local +rule. No source evaluation or compiler theorem is weakened by padding. -/ +theorem active_rule_iff (chip : Chip F) (formed : chip.wellFormed = true) + (paddedFormed : (compile chip).wellFormed = true) (rom : WireROM F) + (root : Message F) (premises : List (Message F)) : + (∃ row : Row F, row.chip = chip.name ∧ (compile chip).ValidRow rom row ∧ + row.assignment chip.numVars = 1 ∧ (compile chip).receive row = root ∧ + (compile chip).premises row = premises) ↔ chip.LocalRule rom root premises := by + constructor + · rintro ⟨row, _, valid, active, rootEq, callsEq⟩ + have sourceValid := (valid_active_iff chip row.assignment active).mp valid.2.2 + have finite := chip.finiteAssignment formed row.assignment rom + refine ⟨Row.ofAssignment chip.name chip.numVars row.assignment, rfl, + ⟨formed, Row.ofAssignment_length _ _ _, finite.1.mp sourceValid⟩, ?_, ?_⟩ + · exact finite.2.1.symm.trans rootEq + · exact finite.2.2.symm.trans ((requirements_active chip row.assignment active).symm.trans callsEq) + · rintro ⟨row, _, valid, rootEq, callsEq⟩ + let a := Function.update row.assignment chip.numVars 1 + have active : a chip.numVars = 1 := by simp [a] + have same := chip.agree (a := row.assignment) (b := a) (fun id member => by + have bound := chip.wellFormed_variables formed id member + simp [a, Function.update_of_ne (Nat.ne_of_lt bound)]) rom + have targetValid := (valid_active_iff chip a active).mpr (same.1.mp valid.2.2) + have finite := (compile chip).finiteAssignment paddedFormed a rom + refine ⟨Row.ofAssignment chip.name (chip.numVars + 1) a, rfl, + ⟨paddedFormed, Row.ofAssignment_length _ _ _, finite.1.mp targetValid⟩, ?_, ?_, ?_⟩ + · rw [Row.ofAssignment_agree _ _ _ _ (Nat.lt_succ_self _)] + exact active + · exact finite.2.1.symm.trans (same.2.1.symm.trans rootEq) + · exact finite.2.2.symm.trans ((requirements_active chip a active).trans + (same.2.2.symm.trans callsEq)) + +end Aiur.Optimized.Activation diff --git a/Aiur/Aiur/Optimized/AffineEquation.lean b/Aiur/Aiur/Optimized/AffineEquation.lean new file mode 100644 index 000000000..e1327c8f5 --- /dev/null +++ b/Aiur/Aiur/Optimized/AffineEquation.lean @@ -0,0 +1,115 @@ +import Aiur.Optimized.PolynomialFacts +import Mathlib.Tactic.Ring + +namespace Aiur.Optimized.Polynomial + +variable {F : Type} [Field F] [DecidableEq F] + +/-- Split an affine expression into the coefficient of one variable and the +remainder. Products are accepted only when one operand simplifies to a constant. -/ +def isolate (id : Witness) : Polynomial F → Option (F × Polynomial F) + | .const value => some (0, .const value) + | .var other => if other = id then some (1, .const 0) else some (0, .var other) + | .add left right => do + let (a, p) ← isolate id left + let (b, q) ← isolate id right + return (a + b, .add p q) + | .sub left right => do + let (a, p) ← isolate id left + let (b, q) ← isolate id right + return (a - b, .sub p q) + | .mul left right => + match simplify left, simplify right with + | .const c, _ => (isolate id right).map fun (a, p) => (c * a, .mul (.const c) p) + | _, .const c => (isolate id left).map fun (a, p) => (a * c, .mul p (.const c)) + | _, _ => none + +/-- Structural failure to isolate is independent of the selected variable. +Only the resulting coefficient and remainder depend on that variable. -/ +theorem isolate_isSome_eq (expr : Polynomial F) (left right : Witness) : + (expr.isolate left).isSome = (expr.isolate right).isSome := by + induction expr with + | const value => rfl + | var other => simp [isolate]; split <;> split <;> rfl + | add a b ihA ihB | sub a b ihA ihB => + cases ha : isolate left a <;> cases hb : isolate left b <;> + cases hc : isolate right a <;> cases hd : isolate right b <;> + simp_all [isolate] + | mul a b ihA ihB => + simp only [isolate] + split <;> simp_all + +theorem isolate_denote {id : Witness} {expr : Polynomial F} {coefficient : F} + {rest : Polynomial F} (found : expr.isolate id = some (coefficient, rest)) + (assignment : Witness → F) : + expr.denote assignment = coefficient * assignment id + rest.denote assignment := by + induction expr generalizing coefficient rest with + | const c => cases found; simp [Scalar.Circuit.ArithExpr.denote] + | var other => + simp only [isolate] at found + split at found <;> cases found <;> simp_all [Scalar.Circuit.ArithExpr.denote] + | add left right ihLeft ihRight | sub left right ihLeft ihRight => + simp only [isolate] at found + cases leftFound : isolate id left with + | none => simp [leftFound] at found + | some l => + cases rightFound : isolate id right with + | none => simp [leftFound, rightFound] at found + | some r => + simp [leftFound, rightFound] at found + obtain ⟨rfl, rfl⟩ := found + simp only [Scalar.Circuit.ArithExpr.denote, ihLeft leftFound, ihRight rightFound] + ring + | mul left right ihLeft ihRight => + simp only [isolate] at found + split at found + · rename_i c leftEq + cases rightFound : isolate id right with + | none => simp [rightFound] at found + | some r => + simp [rightFound] at found + obtain ⟨rfl, rfl⟩ := found + have constant := denote_simplify left assignment + rw [leftEq] at constant + simp only [Circuit.ArithExpr.denote, Scalar.Circuit.ArithExpr.denote] at constant ihLeft ihRight ⊢ + rw [← constant, ihRight rightFound] + ring + · rename_i c rightEq _ + cases leftFound : isolate id left with + | none => simp [leftFound] at found + | some l => + simp [leftFound] at found + obtain ⟨rfl, rfl⟩ := found + have constant := denote_simplify right assignment + rw [rightEq] at constant + simp only [Circuit.ArithExpr.denote, Scalar.Circuit.ArithExpr.denote] at constant ihLeft ihRight ⊢ + rw [← constant, ihLeft leftFound] + ring + · contradiction + +/-- Solve only nonzero coefficients in the actual field. -/ +def solution? (expr : Polynomial F) (id : Witness) : Option (Polynomial F) := do + let (coefficient, rest) ← expr.isolate id + if coefficient = 0 then none + else some (simplify (.mul (.const (-coefficient⁻¹)) rest)) + +theorem solution?_sound {expr value : Polynomial F} {id : Witness} + (found : expr.solution? id = some value) (assignment : Witness → F) + (zero : expr.denote assignment = 0) : assignment id = value.denote assignment := by + unfold solution? at found + cases splitEq : expr.isolate id with + | none => simp [splitEq] at found + | some pair => + rcases pair with ⟨coefficient, rest⟩ + simp only [splitEq, bind, Option.bind] at found + split at found + · contradiction + · rename_i nonzero + cases found + rw [isolate_denote splitEq assignment] at zero + simp only [denote_simplify, Scalar.Circuit.ArithExpr.denote] + have equation := congrArg (fun x => coefficient⁻¹ * x) zero + simp only [mul_add, ← mul_assoc, inv_mul_cancel₀ nonzero, one_mul, mul_zero] at equation + exact (eq_neg_of_add_eq_zero_left equation).trans (by ring) + +end Aiur.Optimized.Polynomial diff --git a/Aiur/Aiur/Optimized/AliasCertificate.lean b/Aiur/Aiur/Optimized/AliasCertificate.lean new file mode 100644 index 000000000..aa3830333 --- /dev/null +++ b/Aiur/Aiur/Optimized/AliasCertificate.lean @@ -0,0 +1,159 @@ +import Aiur.Optimized.DegreeCertificate + +namespace Aiur.Optimized + +variable {F : Type} [Field F] [DecidableEq F] + +theorem ScopedChip.substitute_activation (chip : ScopedChip F) (replace : Witness → Polynomial F) + (assignment : Witness → F) (scope : ScopeId) : + ((chip.substitute replace).activation scope).denote assignment = + (chip.activation scope).denote (fun id => (replace id).denote assignment) := by + cases found : chip.scopes[scope]? <;> + simp [ScopedChip.substitute, ScopedChip.activation, found, Polynomial.denote_simplify, + Polynomial.denote_subst, Scalar.Circuit.ArithExpr.denote] + +theorem ScopedChip.substitute_validAssignment (chip : ScopedChip F) (replace : Witness → Polynomial F) + (rom : WireROM F) (assignment : Witness → F) : + (chip.substitute replace).ValidAssignment rom assignment ↔ + chip.ValidAssignment rom (fun id => (replace id).denote assignment) := by + unfold ScopedChip.ValidAssignment + change (∀ equation ∈ (chip.equations.map _).toList, _) ∧ + (∀ cell ∈ (chip.cells.map _).toList, _) ↔ _ + simp only [Array.toList_map, List.forall_mem_map, ScopedChip.substitute_activation, + Polynomial.denote_simplify, Polynomial.denote_subst, WireValue.map_map, Function.comp_def] + +def ScopedChip.fixedInterface (chip : ScopedChip F) (replace : Witness → Polynomial F) : Prop := + ∀ id ∈ chip.inputs.flatMap WireValue.words ++ chip.output.words ++ + chip.calls.toList.flatMap (fun call => call.result.words), replace id = .var id + +instance (chip : ScopedChip F) (replace : Witness → Polynomial F) : + Decidable (chip.fixedInterface replace) := by unfold ScopedChip.fixedInterface; infer_instance + +theorem ScopedChip.substitute_conclusion (chip : ScopedChip F) (replace : Witness → Polynomial F) + (fixed : chip.fixedInterface replace) (assignment : Witness → F) : + (chip.substitute replace).conclusion assignment = + chip.conclusion (fun id => (replace id).denote assignment) := by + have fixedInput (value : WireValue Witness) (member : value ∈ chip.inputs) : + value.map assignment = value.map (fun id => (replace id).denote assignment) := by + apply WireValue.map_congr + intro id present + rw [fixed id (List.mem_append_left _ (List.mem_append_left _ + (List.mem_flatMap.mpr ⟨value, member, present⟩)))] + rfl + have fixedOutput : chip.output.map assignment = chip.output.map (fun id => (replace id).denote assignment) := by + apply WireValue.map_congr + intro id present + rw [fixed id (by simp only [List.mem_append]; exact Or.inl (Or.inr present))] + rfl + simp only [ScopedChip.conclusion, ScopedChip.substitute] + rw [List.map_congr_left fixedInput, fixedOutput] + +theorem ScopedChip.substitute_premises (chip : ScopedChip F) (replace : Witness → Polynomial F) + (fixed : chip.fixedInterface replace) (assignment : Witness → F) : + (chip.substitute replace).premises assignment = + chip.premises (fun id => (replace id).denote assignment) := by + unfold ScopedChip.premises + change (chip.calls.map _).toList.filterMap _ = _ + simp only [Array.toList_map, List.filterMap_map] + apply List.filterMap_congr + intro call member + simp only [Function.comp_def, ScopedChip.substitute_activation] + split + · congr 1 + have fixedResult : call.result.map assignment = + call.result.map (fun id => (replace id).denote assignment) := by + apply WireValue.map_congr + intro id present + rw [fixed id (List.mem_append_right _ (List.mem_flatMap.mpr ⟨call, member, present⟩))] + rfl + simp only [Call.message, List.map_map, WireValue.map_map, Function.comp_def, + Polynomial.denote_simplify, Polynomial.denote_subst, fixedResult] + · rfl + +namespace Alias + +def Certificate (chip : ScopedChip F) (values : Array (Polynomial F)) : Prop := + values.size = chip.roles.size ∧ chip.fixedInterface (Degree.replacement values) ∧ + ∀ id ∈ List.range chip.roles.size, + Degree.replacement values id = .var id ∨ + match chip.aliases[id]?.getD none with + | none => False + | some expression => + (∀ other ∈ expression.vars, id < other ∧ other < chip.roles.size) ∧ + Polynomial.Identical (expression.subst (Degree.replacement values)) (Degree.replacement values id) ∧ + ∃ equation ∈ chip.equations.toList, + Polynomial.Identical (chip.activation equation.scope) (.const 1) ∧ + Polynomial.Identical equation.polynomial (.sub expression (.var id)) + +instance (chip : ScopedChip F) (values : Array (Polynomial F)) : Decidable (Certificate chip values) := by + unfold Certificate + refine @instDecidableAnd _ _ inferInstance ?_ + refine @instDecidableAnd _ _ inferInstance ?_ + refine @List.decidableBAll _ _ ?_ _ + intro id + refine @instDecidableOr _ _ inferInstance ?_ + split <;> infer_instance + +namespace Certificate + +variable {chip : ScopedChip F} {values : Array (Polynomial F)} + +/-- Every eliminated selector is determined by an equation in the input chip. +Forward references decrease the remaining suffix length, ruling out cycles. -/ +theorem assignment (checked : Certificate chip values) {rom : WireROM F} {a : Witness → F} + (valid : chip.ValidAssignment rom a) : (fun id => (Degree.replacement values id).denote a) = a := by + have prove (fuel : Nat) : ∀ id, chip.roles.size - id < fuel → + a id = (Degree.replacement values id).denote a := by + induction fuel with + | zero => intro id bound; omega + | succ fuel ih => + intro id bound + by_cases bounded : id < chip.roles.size + · rcases checked.2.2 id (List.mem_range.mpr bounded) with unchanged | defined + · rw [unchanged]; rfl + · cases found : chip.aliases[id]?.getD none with + | none => simp only [found] at defined + | some expression => + rw [found] at defined + obtain ⟨earlier, expanded, equation, member, global, definition⟩ := defined + have equation := valid.1 equation member + rw [global.denote, definition.denote] at equation + change 1 * (expression.denote a - a id) = 0 at equation + have equality : a id = expression.denote a := (sub_eq_zero.mp (by simpa using equation)).symm + have expand : expression.denote a = (expression.subst (Degree.replacement values)).denote a := by + rw [Polynomial.denote_subst] + apply Polynomial.denote_congr + intro other member + have order := earlier other member + exact ih other (by omega) + exact equality.trans (expand.trans (expanded.denote a)) + · have sized := checked.1 + have absent : values[id]? = none := Array.getElem?_eq_none (by omega) + simp [Degree.replacement, absent, Scalar.Circuit.ArithExpr.denote] + funext id + exact (prove (chip.roles.size + 1) id (by omega)).symm + +theorem equivalent (checked : Certificate chip values) : + chip.Equivalent (chip.substitute (Degree.replacement values)) := by + constructor + · intro rom a valid + refine ⟨a, ?_, ?_, ?_⟩ + · rw [ScopedChip.substitute_validAssignment, checked.assignment valid] + exact valid + · rw [chip.substitute_conclusion _ checked.2.1, checked.assignment valid] + · rw [chip.substitute_premises _ checked.2.1, checked.assignment valid] + · intro rom a valid + exact ⟨_, (chip.substitute_validAssignment _ _ _).mp valid, + (chip.substitute_conclusion _ checked.2.1 a).symm, + (chip.substitute_premises _ checked.2.1 a).symm⟩ + +end Certificate + +def checkedResolve (chip : ScopedChip F) : Except String (Degree.Checked chip) := do + let values ← resolveAliasValues chip + if checked : Certificate chip values then + return ⟨chip.substitute (Degree.replacement values), checked.equivalent, rfl, rfl, rfl⟩ + else throw s!"invalid selector-elimination certificate in {chip.name}" + +end Alias +end Aiur.Optimized diff --git a/Aiur/Aiur/Optimized/AllocationCertificate.lean b/Aiur/Aiur/Optimized/AllocationCertificate.lean new file mode 100644 index 000000000..dde8489e5 --- /dev/null +++ b/Aiur/Aiur/Optimized/AllocationCertificate.lean @@ -0,0 +1,195 @@ +import Aiur.Optimized.ControlCertificate +import Aiur.Optimized.LayoutWitness +import Aiur.Optimized.Index + +namespace Aiur.Optimized.Allocation + +variable {F : Type} [Field F] [DecidableEq F] + +abbrev Site := Witness × Option ScopeId + +def sites (scope : Option ScopeId) (ids : List Witness) : List Site := ids.map (·, scope) + +/-- Interfaces and guard variables are live unconditionally; payload variables +are live only in their scope. Repeated occurrences are intentional. -/ +def occurrences (chip : ScopedChip F) : List Site := + sites none (chip.inputs.flatMap WireValue.words ++ chip.output.words) ++ + chip.scopes.toList.flatMap (fun scope => sites none scope.activation.vars) ++ + chip.equations.toList.flatMap (fun equation => sites (some equation.scope) equation.polynomial.vars) ++ + chip.calls.toList.flatMap (fun call => sites (some call.scope) + (call.args.flatMap (fun value => value.words.flatMap Polynomial.vars) ++ call.result.words)) ++ + chip.cells.toList.flatMap (fun cell => sites (some cell.scope) + (cell.address.vars ++ cell.value.words.flatMap Polynomial.vars)) + +def Live (chip : ScopedChip F) (assignment : Witness → F) : Option ScopeId → Prop + | none => True + | some scope => (chip.activation scope).denote assignment ≠ 0 + +theorem relevant_site {chip : ScopedChip F} {assignment : Witness → F} {id : Witness} + (relevant : chip.Relevant assignment id) : + ∃ scope, (id, scope) ∈ occurrences chip ∧ Live chip assignment scope := by + cases relevant with + | input member present => + refine ⟨none, ?_, trivial⟩ + simp only [occurrences, sites, List.mem_append, List.mem_flatMap, List.mem_map, Prod.mk.injEq] + aesop + | output present => + refine ⟨none, ?_, trivial⟩ + simp only [occurrences, sites, List.mem_append, List.mem_flatMap, List.mem_map, Prod.mk.injEq] + aesop + | activation present => + rename_i scope + cases found : chip.scopes[scope]? with + | none => simp [ScopedChip.activation, found, Polynomial.vars] at present + | some value => + simp only [ScopedChip.activation, found, Option.map_some, Option.getD_some] at present + have member : value ∈ chip.scopes.toList := by simpa using Array.mem_of_getElem? found + refine ⟨none, ?_, trivial⟩ + simp only [occurrences, sites, List.mem_append, List.mem_flatMap, List.mem_map, Prod.mk.injEq] + aesop + | equation member active present => + rename_i equation + refine ⟨some equation.scope, ?_, active⟩ + simp only [occurrences, sites, List.mem_append, List.mem_flatMap, List.mem_map, Prod.mk.injEq] + aesop + | callArgument member active valueMember polynomialMember used => + rename_i call value polynomial + refine ⟨some call.scope, ?_, ?_⟩ + · simp only [occurrences, sites, List.mem_append, List.mem_flatMap, List.mem_map, Prod.mk.injEq] + aesop + · change _ ≠ 0 + rw [active] + exact one_ne_zero + | callResult member active present => + rename_i call + refine ⟨some call.scope, ?_, ?_⟩ + · simp only [occurrences, sites, List.mem_append, List.mem_flatMap, List.mem_map, Prod.mk.injEq] + aesop + · change _ ≠ 0 + rw [active] + exact one_ne_zero + | address member active present => + rename_i cell + refine ⟨some cell.scope, ?_, ?_⟩ + · simp only [occurrences, sites, List.mem_append, List.mem_flatMap, List.mem_map, Prod.mk.injEq] + aesop + · change _ ≠ 0 + rw [active] + exact one_ne_zero + | payload member active polynomialMember used => + rename_i cell polynomial + refine ⟨some cell.scope, ?_, ?_⟩ + · simp only [occurrences, sites, List.mem_append, List.mem_flatMap, List.mem_map, Prod.mk.injEq] + aesop + · change _ ≠ 0 + rw [active] + exact one_ne_zero + +def Owned (chip : ScopedChip F) (site : Site) : Prop := + match chip.roles[site.1]? with + | none => False + | some (.auxiliary owner) => + match site.2, chip.scopes[owner]? with + | some scope, some declared => + match chip.scopes[scope]? with + | some current => declared.path.isPrefixOf current.path = true + | none => False + | _, _ => False + | some _ => True + +instance (chip : ScopedChip F) (site : Site) : Decidable (Owned chip site) := by + unfold Owned + split <;> (try infer_instance) + split <;> (try infer_instance) + split <;> infer_instance + +def usedIds (chip : ScopedChip F) : List Witness := ((occurrences chip).map Prod.fst).eraseDups + +def Certificate (chip : ScopedChip F) (layout : ColumnLayout) : Prop := + Control.Certificate chip ∧ + (∀ site ∈ occurrences chip, layout.column site.1 < layout.occupants.size ∧ Owned chip site) ∧ + ∀ i ∈ usedIds chip, ∀ j ∈ usedIds chip, + layout.column i = layout.column j → i = j ∨ chip.canShare i j = true + +omit [Field F] [DecidableEq F] in +/-- Only witnesses mapped to the same physical column can interfere. The +indexed predicate checks exactly the original all-pairs condition. -/ +theorem sharing_iff_indexed (chip : ScopedChip F) (layout : ColumnLayout) + (ids : List Witness) : + (∀ i ∈ ids, ∀ j ∈ ids, + layout.column i = layout.column j → i = j ∨ chip.canShare i j = true) ↔ + (∀ i ∈ ids, ∀ j ∈ (Index.build layout.column ids).getD (layout.column i) [], + i = j ∨ chip.canShare i j = true) := by + simp only [Index.getD_build, List.mem_filter, beq_iff_eq] + constructor + · intro checked i hi j hj + exact checked i hi j hj.1 hj.2.symm + · intro checked i hi j hj same + exact checked i hi j ⟨hj, same.symm⟩ + +instance (chip : ScopedChip F) (layout : ColumnLayout) : Decidable (Certificate chip layout) := + let sites := occurrences chip + let ids := usedIds chip + let buckets := Index.build layout.column ids + decidable_of_iff + (Control.Certificate chip ∧ + (∀ site ∈ sites, layout.column site.1 < layout.occupants.size ∧ Owned chip site) ∧ + ∀ i ∈ ids, ∀ j ∈ buckets.getD (layout.column i) [], i = j ∨ chip.canShare i j = true) + (by unfold Certificate; rw [sharing_iff_indexed]) + +namespace Certificate + +variable {chip : ScopedChip F} {layout : ColumnLayout} + {rom : WireROM F} {assignment : Witness → F} + +theorem bounded (checked : Certificate chip layout) {id : Witness} (relevant : chip.Relevant assignment id) : + layout.column id < layout.occupants.size := by + obtain ⟨scope, member, _⟩ := relevant_site relevant + exact (checked.2.1 _ member).1 + +theorem activePath (checked : Certificate chip layout) (valid : chip.ValidAssignment rom assignment) + {id owner : Witness} {scope : Scope F} (relevant : chip.Relevant assignment id) + (role : chip.roles[id]? = some (.auxiliary owner)) (found : chip.scopes[owner]? = some scope) : + Control.ActivePath chip assignment scope.path := by + obtain ⟨site, member, active⟩ := relevant_site relevant + have owned := (checked.2.1 _ member).2 + unfold Owned at owned + simp only [role] at owned + cases site with + | none => contradiction + | some useScope => + simp only [found] at owned + cases useFound : chip.scopes[useScope]? with + | none => simp [useFound] at owned + | some current => + simp only [useFound] at owned + have activePath := checked.1.activePath valid useFound active + exact fun tag member => activePath tag ((List.isPrefixOf_iff_prefix.mp owned).subset member) + +theorem compatible (checked : Certificate chip layout) (valid : chip.ValidAssignment rom assignment) + {i j : Witness} (left : chip.Relevant assignment i) (right : chip.Relevant assignment j) + (column : layout.column i = layout.column j) : assignment i = assignment j := by + have present {id : Witness} (relevant : chip.Relevant assignment id) : id ∈ usedIds chip := by + obtain ⟨site, member, _⟩ := relevant_site relevant + simp only [usedIds, List.mem_eraseDups] + exact List.mem_map.mpr ⟨(id, site), member, rfl⟩ + rcases checked.2.2 i (present left) j (present right) column with same | shares + · rw [same] + · unfold ScopedChip.canShare at shares + split at shares <;> (try contradiction) + rename_i a b leftRole rightRole + split at shares <;> (try contradiction) + rename_i leftScope rightScope leftFound rightFound + exact False.elim (checked.1.paths_exclusive valid shares + (checked.activePath valid left leftRole leftFound) (checked.activePath valid right rightRole rightFound)) + +theorem complete (checked : Certificate chip layout) (rom : WireROM F) (assignment : Witness → F) + (formed : (emitChip chip layout).wellFormed = true) (valid : chip.ValidAssignment rom assignment) : + ∃ row : Circuit.Row F, row.chip = chip.name ∧ (emitChip chip layout).ValidRow rom row ∧ + (emitChip chip layout).receive row = chip.conclusion assignment ∧ + (emitChip chip layout).premises row = chip.premises assignment := + emitChip_complete chip layout rom assignment formed valid (fun _ => checked.bounded) + (fun _ _ => checked.compatible valid) + +end Certificate +end Aiur.Optimized.Allocation diff --git a/Aiur/Aiur/Optimized/ArmWitness.lean b/Aiur/Aiur/Optimized/ArmWitness.lean new file mode 100644 index 000000000..269bd58f9 --- /dev/null +++ b/Aiur/Aiur/Optimized/ArmWitness.lean @@ -0,0 +1,186 @@ +import Aiur.Optimized.WitnessContext +import Aiur.Optimized.InactiveWitness +import Aiur.Optimized.FailureWitness +import Aiur.Optimized.PatternIrrefutable + +namespace Aiur.Optimized.Compiler + +variable {F : Type} [Field F] [DecidableEq F] +open Circuit.Compiler (Bounded LocalsBounded localsEnvironment localsEnvironment_append localsBounded_append) +set_option maxHeartbeats 3000000 +set_option maxRecDepth 8192 + +/-- The selected source arm receives the only enabled scope. Other arms can +be witnessed without evaluation, while previous-pattern failures enforce order. -/ +theorem lowerArms_complete {program : Program F} (checked : checkDeclarations program.enums = .ok ()) + (tags : program.enums.tagsValid F = true) + {calls : Circuit.CallRelation F} {sourceCalls : Aiur.CallRelation F} {function : String} + {locals : Locals F} {scrutinee : Symbolic F} {result : WireValue Witness} + {scopes : List ScopeId} {arms : List (Pattern F × Expr F)} {previous : List (List (Polynomial F))} + (bodyCompletes : ∀ arm ∈ arms, ExprComplete program sourceCalls calls function arm.2) + {before after : State F} + (compiled : lowerArms program function locals scrutinee result scopes arms previous before = .ok ((), after)) + {rom : WireROM F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (scopeLayout : before.Scoped) + (valid : before.Valid rom calls initial) (scopesValid : ∀ scope ∈ scopes, scope < before.scopes.size) + (localsBound : LocalsBounded before.roles.size locals) (scrutineeBound : Bounded before.roles.size scrutinee) + (resultBound : Bounded (F := F) before.roles.size (result.map Polynomial.var)) + (previousBound : ∀ conditions ∈ previous, ∀ condition ∈ conditions, condition.inBounds before.roles.size = true) + {environment : Environment F} + (decoded : DecodesEnvironment program.enums (localsEnvironment locals initial) environment) + {input value : Value F} + (inputDecode : (scrutinee.map (Circuit.ArithExpr.denote initial)).decode program.enums = some input) + (resultDecode : (result.map initial).decode program.enums = some value) + {bindings : Environment F} {body : Expr F} + (selected : selectArm input arms = some (bindings, body)) + (evaluated : ROMEvalExprWith program.enums (rom.decode program.enums) sourceCalls + (bindings ++ environment) body value) + (selectors : ∀ i : Fin scopes.length, (before.activation scopes[i]).denote initial = + if i.val = armIndex input arms then 1 else 0) + (previousFailed : ∀ conditions ∈ previous, ¬AllZero conditions initial) : + ∃ assignment, Extension rom calls before after initial assignment := by + induction arms generalizing scopes previous before initial with + | nil => simp [selectArm] at selected + | cons arm arms ih => + rcases arm with ⟨pat, headBody⟩ + cases scopes with + | nil => simp [lowerArms] at compiled + | cons scope scopes => + simp only [lowerArms] at compiled + obtain ⟨⟨conditions, patternBindings⟩, patternState, patternRun, guardsBind⟩ := bind_ok.mp compiled + obtain ⟨stateEq, conditionsBound, bindingsBound⟩ := pattern_bounded patternRun scrutineeBound + subst patternState + obtain ⟨⟨⟩, s₁, equationsRun, failuresBind⟩ := bind_ok.mp guardsBind + obtain ⟨⟨⟩, s₂, failuresRun, bodyBind⟩ := bind_ok.mp failuresBind + obtain ⟨bodyWire, s₃, bodyRun, tailRun⟩ := bind_ok.mp bodyBind + have scopeValid := scopesValid scope (by simp) + have equationsRun' : (do for condition in conditions do equation scope condition : Build F Unit) + before = .ok ((), s₁) := bind_ok.mpr ⟨(), s₁, equationsRun, rfl⟩ + have failuresRun' : (do for earlier in previous do failure scope earlier : Build F Unit) + s₁ = .ok ((), s₂) := bind_ok.mpr ⟨(), s₂, failuresRun, rfl⟩ + have equationStructure := equations_grow equationsRun' + have equationScoped := equations_scoped equationsRun' scopeLayout scopeValid + have scopeValid₁ := equationStructure.scopeValid scopeValid + obtain ⟨failureStructure, failureScoped⟩ := forIn_scoped failuresRun equationScoped scopeValid₁ + (fun _ _ {_ _} run stateShape bound => failure_scoped run stateShape bound) + have beforeBody := equationStructure.trans failureStructure + have scopeValid₂ := beforeBody.scopeValid scopeValid + obtain ⟨bodyStructure, bodyScoped⟩ := lower_scoped bodyRun failureScoped scopeValid₂ + have throughHead := beforeBody.trans bodyStructure + have patternMeaning := (pattern_correct checked tags patternRun).2 initial input inputDecode + have combinedBound : LocalsBounded before.roles.size (patternBindings ++ locals) := + localsBounded_append.mpr ⟨bindingsBound, localsBound⟩ + have headSelector := selectors ⟨0, by simp⟩ + cases matched : pat.bindings input with + | some matchedBindings => + have selection : matchedBindings = bindings ∧ headBody = body := by + simpa [selectArm, matched] using selected + obtain ⟨bindingsEq, bodyEq⟩ := selection + subst bindings + subst body + have active : (before.activation scope).denote initial = 1 := by + simpa [armIndex, matched] using headSelector + rcases patternMeaning with ⟨sourceBindings, sourceMatched, zero, bindingsDecode⟩ | ⟨absent, _⟩ + · have bindingsEq : sourceBindings = matchedBindings := + Option.some.inj (sourceMatched.symm.trans matched) + subst sourceBindings + have equationExt := equations_complete equationsRun' layout valid + (scopeLayout.activation_bound scope) conditionsBound (Or.inr zero) + obtain ⟨a, failureExt⟩ := failures_complete failuresRun' equationExt.layout equationScoped + equationExt.validAssignment scopeValid₁ + (fun earlier member condition inside => equationExt.bound (previousBound earlier member condition inside)) + (Or.inr previousFailed) + have prefixExt := equationExt.trans failureExt + have active₂ := (Extension.activation prefixExt beforeBody scopeLayout scopeValid).trans active + have envDecode : DecodesEnvironment program.enums + (localsEnvironment (patternBindings ++ locals) initial) (matchedBindings ++ environment) := by + simpa only [localsEnvironment_append] using bindingsDecode.append decoded + obtain ⟨b, bodyExt, _, _⟩ := bodyCompletes (pat, headBody) (by simp) bodyRun + prefixExt.layout failureScoped (Extension.validAssignment prefixExt) scopeValid₂ + (combinedBound.mono prefixExt.increase) + (fun candidate equal => by cases equal; exact resultBound.mono prefixExt.increase) + active₂ (prefixExt.environment combinedBound envDecode) + (fun candidate equal => by + cases equal + rw [prefixExt.variables resultBound] + exact resultDecode) evaluated + have full := prefixExt.trans bodyExt + split at tailRun + · obtain ⟨_, stateEq⟩ := pure_ok.mp tailRun + subst after + exact ⟨b, full⟩ + · obtain ⟨c, tailExt⟩ := lowerArms_inactive tailRun full.layout bodyScoped (Extension.validAssignment full) + (fun child member => throughHead.scopeValid (scopesValid child (by simp [member]))) + (localsBound.mono full.increase) (scrutineeBound.mono full.increase) (resultBound.mono full.increase) + (by + intro earlier member condition inside + rcases List.mem_append.mp member with old | last + · exact full.bound (previousBound earlier old condition inside) + · obtain rfl := List.mem_singleton.mp last + exact full.bound (conditionsBound condition inside)) + (by + intro child member + rw [Extension.activation full throughHead scopeLayout (scopesValid child (by simp [member]))] + obtain ⟨i, bound, rfl⟩ := List.mem_iff_getElem.mp member + have old := selectors ⟨i + 1, by simp; omega⟩ + simpa [armIndex, matched] using old) + exact ⟨c, full.trans tailExt⟩ + · rw [matched] at absent + cases absent + | none => + have inactive : (before.activation scope).denote initial = 0 := by + simpa [armIndex, matched] using headSelector + have conditionFailed : ¬AllZero conditions initial := by + rcases patternMeaning with ⟨_, present, _, _⟩ | ⟨_, failed⟩ + · rw [matched] at present + cases present + · exact failed + let start : InactiveContext rom calls scope before initial := + ⟨layout, scopeLayout, valid, scopeValid, inactive⟩ + obtain ⟨equationExt, equationContext⟩ := start.equations equationsRun' conditionsBound + obtain ⟨a, failureExt, failureContext⟩ := equationContext.failures failuresRun + (fun earlier member condition inside => equationExt.bound (previousBound earlier member condition inside)) + have prefixExt := equationExt.trans failureExt + obtain ⟨b, bodyExt, _⟩ := lower_inactive bodyRun failureContext.layout failureContext.scopeLayout + failureContext.valid failureContext.scopeValid (combinedBound.mono prefixExt.increase) + (fun candidate equal => by cases equal; exact resultBound.mono prefixExt.increase) failureContext.inactive + have full := prefixExt.trans bodyExt + split at tailRun + · rename_i irrefutable + obtain ⟨_, present⟩ := pattern_matches checked tags patternRun irrefutable inputDecode + rw [matched] at present + cases present + · have tailSelected : selectArm input arms = some (bindings, body) := by + simpa only [selectArm, matched] using selected + obtain ⟨c, tailExt⟩ := ih (fun arm member => bodyCompletes arm (by simp [member])) tailRun + full.layout bodyScoped (Extension.validAssignment full) + (fun child member => throughHead.scopeValid (scopesValid child (by simp [member]))) + (localsBound.mono full.increase) (scrutineeBound.mono full.increase) (resultBound.mono full.increase) + (by + intro earlier member condition inside + rcases List.mem_append.mp member with old | last + · exact full.bound (previousBound earlier old condition inside) + · obtain rfl := List.mem_singleton.mp last + exact full.bound (conditionsBound condition inside)) + (full.environment localsBound decoded) (full.decoded_value scrutineeBound inputDecode) + (by rw [full.variables resultBound]; exact resultDecode) tailSelected + (by + intro i + rw [Extension.activation full throughHead scopeLayout (scopesValid scopes[i] (by simp))] + have old := selectors ⟨i.val + 1, by simpa using Nat.succ_lt_succ i.isLt⟩ + simpa [armIndex, matched] using old) + (by + intro earlier member zero + rcases List.mem_append.mp member with old | last + · apply previousFailed earlier old + intro condition inside + rw [← full.polynomial (previousBound earlier old condition inside)] + exact zero condition inside + · obtain rfl := List.mem_singleton.mp last + apply conditionFailed + intro condition inside + rw [← full.polynomial (conditionsBound condition inside)] + exact zero condition inside) + exact ⟨c, full.trans tailExt⟩ + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/Basic.lean b/Aiur/Aiur/Optimized/Basic.lean new file mode 100644 index 000000000..0bc566ff8 --- /dev/null +++ b/Aiur/Aiur/Optimized/Basic.lean @@ -0,0 +1,141 @@ +import Aiur.Circuit.Compile +import Aiur.Circuit.Stats + +deriving instance DecidableEq for Aiur.Scalar.Circuit.ArithExpr + +namespace Aiur.Optimized + +abbrev Polynomial := Circuit.ArithExpr +abbrev ScopeId := Nat +abbrev Witness := Nat + +structure Config where + maxDegree : Nat := 3 + shareAuxiliaries : Bool := true + eliminateSelectors : Bool := true + propagateScopes : Bool := true + simplifyConstraints : Bool := true + propagateValues : Bool := true + mergeLookups : Bool := true + deduplicate : Bool := true + deriving Repr, BEq + +/-- A path records selected arms of independent choices, not execution times. -/ +abbrev Path := List (Nat × Nat) + +def Path.exclusive (left right : Path) : Bool := + left.any fun (choice, arm) => right.any fun (other, branch) => + choice == other && arm != branch + +inductive Role where + | input + | output + | selector + | auxiliary (scope : ScopeId) + deriving Repr, BEq, DecidableEq + +structure Scope (F : Type) where + activation : Polynomial F + path : Path + deriving Repr, BEq, DecidableEq + +structure Equation (F : Type) where + scope : ScopeId + polynomial : Polynomial F + deriving Repr, BEq, DecidableEq + +structure Call (F : Type) where + scope : ScopeId + channel : String + args : List (WireValue (Polynomial F)) + result : WireValue Witness + deriving Repr, BEq, DecidableEq + +structure Cell (F : Type) where + scope : ScopeId + address : Polynomial F + value : WireValue (Polynomial F) + deriving Repr, BEq, DecidableEq + +/-- The coverage and exclusion equations for a choice are checked separately; +this record describes their intended parent/child relationship. -/ +structure Choice where + parent : ScopeId + children : List ScopeId + deriving Repr, BEq, DecidableEq + +/-- Logical witnesses have roles and scopes; selector aliases need no column. -/ +structure ScopedChip (F : Type) where + name : String + inputs : List (WireValue Witness) + output : WireValue Witness + roles : Array Role + aliases : Array (Option (Polynomial F)) + scopes : Array (Scope F) + equations : Array (Equation F) + calls : Array (Call F) + cells : Array (Cell F) + choices : Array Choice := #[] + deriving Repr, BEq + +structure ColumnLayout where + /-- `none` identifies a witness eliminated by an affine definition. -/ + columnOf : Array (Option Circuit.Var) + /-- All logical witnesses that share each physical column. -/ + occupants : Array (List Witness) + deriving Repr, BEq + +structure LaidOutChip (F : Type) where + logical : ScopedChip F + /-- Allocation before final copy/constant propagation and column compaction. -/ + layout : ColumnLayout + /-- Final physical chip, after value propagation when enabled. -/ + chip : Circuit.Chip F + deriving Repr, BEq + +namespace Polynomial + +export Aiur.Scalar.Circuit.ArithExpr (const var add sub mul) + +abbrev degree (expr : Polynomial F) : Nat := Circuit.ArithExpr.degree expr + +def subst (replacement : Witness → Polynomial F) : Polynomial F → Polynomial F + | .const value => .const value + | .var id => replacement id + | .add a b => .add (subst replacement a) (subst replacement b) + | .sub a b => .sub (subst replacement a) (subst replacement b) + | .mul a b => .mul (subst replacement a) (subst replacement b) + +def vars : Polynomial F → List Witness + | .const _ => [] + | .var id => [id] + | .add a b | .sub a b | .mul a b => vars a ++ vars b + +/-- These simplifications concern total polynomials, never source operations. -/ +def simplify [Field F] [DecidableEq F] : Polynomial F → Polynomial F + | .const value => .const value + | .var id => .var id + | .add a b => + match simplify a, simplify b with + | .const a, .const b => .const (a + b) + | .const a, b => if a = 0 then b else .add (.const a) b + | a, .const b => if b = 0 then a else .add a (.const b) + | a, b => .add a b + | .sub a b => + let a := simplify a + let b := simplify b + if a == b then .const 0 else + match a, b with + | .const a, .const b => .const (a - b) + | a, .const b => if b = 0 then a else .sub a (.const b) + | a, b => .sub a b + | .mul a b => + match simplify a, simplify b with + | .const a, .const b => .const (a * b) + | .const a, b => if a = 0 then .const 0 else if a = 1 then b else .mul (.const a) b + | a, .const b => if b = 0 then .const 0 else if b = 1 then a else .mul a (.const b) + | a, b => .mul a b + +end Polynomial + +end Aiur.Optimized diff --git a/Aiur/Aiur/Optimized/BranchFacts.lean b/Aiur/Aiur/Optimized/BranchFacts.lean new file mode 100644 index 000000000..30887fd5a --- /dev/null +++ b/Aiur/Aiur/Optimized/BranchFacts.lean @@ -0,0 +1,112 @@ +import Aiur.Optimized.PolynomialFacts +import Mathlib.Algebra.BigOperators.Field + +namespace Aiur.Optimized + +variable {F : Type} [Field F] + +/-- The value of the failure certificate emitted for a conjunction. -/ +def combination : List F → List F → F + | d :: ds, u :: us => d * u + combination ds us + | _, _ => 0 + +theorem combination_zero_left {differences : List F} + (zero : ∀ d ∈ differences, d = 0) (coefficients : List F) : combination differences coefficients = 0 := by + induction differences generalizing coefficients with + | nil => rfl + | cons d ds ih => + cases coefficients <;> simp_all [combination] + +theorem combination_zero_right (differences : List F) : + combination differences (List.replicate differences.length 0) = 0 := by + induction differences <;> simp_all [List.replicate_succ, combination] + +/-- A failed conjunction is witnessed by one inverse coefficient. This proof +does not assume a finite field or any bound on the number of conditions. -/ +theorem failure_certificate_iff (differences : List F) : + (∃ coefficients, coefficients.length = differences.length ∧ combination differences coefficients = 1) ↔ + ¬ (∀ d ∈ differences, d = 0) := by + classical + constructor + · rintro ⟨coefficients, _, equation⟩ allZero + rw [combination_zero_left allZero] at equation + exact zero_ne_one equation + · intro fails + induction differences with + | nil => simp at fails + | cons d ds ih => + by_cases zero : d = 0 + · obtain ⟨coefficients, length, equation⟩ := ih (by simpa [zero] using fails) + exact ⟨0 :: coefficients, by simp [length], by simp [combination, zero, equation]⟩ + · exact ⟨d⁻¹ :: List.replicate ds.length 0, by simp, + by simp [combination, zero, combination_zero_right]⟩ + +theorem guarded_failure_iff (enable : F) (differences : List F) : + (∃ coefficients, coefficients.length = differences.length ∧ + enable * (combination differences coefficients - 1) = 0) ↔ + (enable = 0 ∨ ¬ (∀ d ∈ differences, d = 0)) := by + classical + constructor + · rintro ⟨coefficients, length, equation⟩ + rcases mul_eq_zero.mp equation with inactive | failed + · exact Or.inl inactive + · exact Or.inr ((failure_certificate_iff differences).mp + ⟨coefficients, length, sub_eq_zero.mp failed⟩) + · rintro (inactive | failed) + · exact ⟨List.replicate differences.length 0, by simp, by simp [inactive]⟩ + · obtain ⟨coefficients, length, equation⟩ := (failure_certificate_iff differences).mpr failed + exact ⟨coefficients, length, by simp [equation]⟩ + +theorem selector_boolean (value : F) : value * (value - 1) = 0 ↔ value = 0 ∨ value = 1 := by + simp only [mul_eq_zero, sub_eq_zero] + +variable {I : Type} [Fintype I] + +theorem exclusive_sum (selectors : I → F) + (exclusive : ∀ i j, i ≠ j → selectors i * selectors j = 0) {i : I} + (active : selectors i ≠ 0) : ∑ j, selectors j = selectors i := by + classical + apply Finset.sum_eq_single i + · intro j _ different + exact (mul_eq_zero.mp (exclusive i j different.symm)).resolve_left active + · simp + +/-- Exclusive Boolean children have a Boolean sum in every characteristic. +Their sum can therefore define the parent's activation. -/ +theorem selector_sum_boolean (selectors : I → F) + (boolean : ∀ i, selectors i * (selectors i - 1) = 0) + (exclusive : ∀ i j, i ≠ j → selectors i * selectors j = 0) : + (∑ i, selectors i) * ((∑ i, selectors i) - 1) = 0 := by + classical + by_cases zero : ∀ i, selectors i = 0 + · simp [zero] + · obtain ⟨i, active⟩ := not_forall.mp zero + rw [exclusive_sum selectors exclusive active] + exact boolean i + +/-- Coverage selects exactly one child when the parent is active. Repeated +branches cannot wrap a finite field's characteristic because of exclusion. -/ +theorem selector_exactly_one (selectors : I → F) + (boolean : ∀ i, selectors i * (selectors i - 1) = 0) + (exclusive : ∀ i j, i ≠ j → selectors i * selectors j = 0) + (coverage : ∑ i, selectors i = 1) : ∃! i, selectors i = 1 := by + classical + have nonzero : ∃ i, selectors i ≠ 0 := by + by_contra! absent + simp [absent] at coverage + obtain ⟨i, active⟩ := nonzero + have one : selectors i = 1 := ((selector_boolean _).mp (boolean i)).resolve_left active + refine ⟨i, one, ?_⟩ + intro j selected + by_contra different + have zero := exclusive i j (Ne.symm different) + simp [one, selected] at zero + +theorem selector_inactive (selectors : I → F) + (exclusive : ∀ i j, i ≠ j → selectors i * selectors j = 0) + (coverage : ∑ i, selectors i = 0) : ∀ i, selectors i = 0 := by + intro i + by_contra active + exact active ((exclusive_sum selectors exclusive active).symm.trans coverage) + +end Aiur.Optimized diff --git a/Aiur/Aiur/Optimized/BranchOutputs.lean b/Aiur/Aiur/Optimized/BranchOutputs.lean new file mode 100644 index 000000000..6bca9deec --- /dev/null +++ b/Aiur/Aiur/Optimized/BranchOutputs.lean @@ -0,0 +1,155 @@ +import Aiur.Optimized.LookupGuards +import Aiur.Optimized.Propagation + +namespace Aiur.Optimized.LookupMerging + +variable {F : Type} [Field F] [DecidableEq F] + +/-- A guarded output definition. Its expression already includes the guard. -/ +structure OutputDefinition (ctx : Context F) (id scope : Witness) where + expr : Polynomial F + sound : ∀ a, ctx.Valid a → + (ctx.guard scope).denote a * a (ctx.layout.column id) = expr.denote a + +def outputLeaf (ctx : Context F) (id scope : Witness) (eq : Equation F) + (member : eq ∈ ctx.logical.equations.toList) (owner : eq.scope = scope) + (value : Polynomial F) (solved : eq.polynomial.solution? id = some value) : OutputDefinition ctx id scope where + expr := Polynomial.simplify (.mul (ctx.guard scope) (ctx.layout.expression value)) + sound a valid := by + have zero := (ctx.logicalValid valid).1 eq member + rw [owner] at zero + simp only [Context.guard, ColumnLayout.expression_denote, Polynomial.denote_simplify, + Scalar.Circuit.ArithExpr.denote] + rcases mul_eq_zero.mp zero with inactive | equation + · simp [inactive] + · exact congrArg (fun x => (ctx.logical.activation scope).denote (a ∘ ctx.layout.column) * x) + (Polynomial.solution?_sound solved (a ∘ ctx.layout.column) equation) + +structure OutputSum (ctx : Context F) (id : Witness) (scopes : List ScopeId) where + expr : Polynomial F + sound : ∀ a, ctx.Valid a → + (scopes.map (fun scope => (ctx.guard scope).denote a)).sum * a (ctx.layout.column id) = expr.denote a + +def outputSum (ctx : Context F) (id : Witness) + (resolve : (scope : ScopeId) → Option (OutputDefinition ctx id scope)) : + (scopes : List ScopeId) → Option (OutputSum ctx id scopes) + | [] => some ⟨.const 0, by intros; simp [Scalar.Circuit.ArithExpr.denote]⟩ + | scope :: scopes => do + let head ← resolve scope + let tail ← outputSum ctx id resolve scopes + return ⟨.add head.expr tail.expr, by + intro a valid + simp only [List.map_cons, List.sum_cons, add_mul, Scalar.Circuit.ArithExpr.denote] + rw [head.sound a valid, tail.sound a valid]⟩ + +theorem Context.coverage (ctx : Context F) (choice : Choice) + (member : choice ∈ ctx.logical.choices.toList) {a : Witness → F} (valid : ctx.Valid a) : + (choice.children.map (fun scope => (ctx.guard scope).denote a)).sum = + (ctx.guard choice.parent).denote a := by + have zero := ctx.control.zero (ctx.logicalValid valid) (ctx.control.2.1 choice member).1 + have fold (scopes : List ScopeId) (start : Polynomial F) : + (scopes.foldl (fun sum child => Polynomial.add sum (ctx.logical.activation child)) start).denote + (a ∘ ctx.layout.column) = start.denote (a ∘ ctx.layout.column) + + (scopes.map (fun scope => (ctx.guard scope).denote a)).sum := by + induction scopes generalizing start with + | nil => simp + | cons scope scopes ih => simp [ih, Context.guard, Scalar.Circuit.ArithExpr.denote, add_assoc] + simpa only [Scalar.Circuit.ArithExpr.denote, Control.Choice.total, fold, + zero_add, sub_eq_zero, Context.guard, ColumnLayout.expression_denote] using zero + +/-- Search actual guarded equalities and checked coverage trees. Failure to +find a complete cover retains the existing output witness. -/ +def outputDefinition (ctx : Context F) (id : Witness) : Nat → + (scope : ScopeId) → Option (OutputDefinition ctx id scope) + | 0, _ => none + | fuel + 1, scope => do + for eq in ctx.logical.equations.toList.attach do + if owner : eq.val.scope = scope then + match solved : eq.val.polynomial.solution? id with + | none => pure () + | some value => + if value.degree ≤ 1 then + return outputLeaf ctx id scope eq.val eq.property owner value solved + for choice in ctx.logical.choices.toList.attach do + if parent : choice.val.parent = scope then + if let some parts := outputSum ctx id (outputDefinition ctx id fuel) choice.val.children then + return ⟨parts.expr, by + intro a valid + rw [← parent, ← ctx.coverage choice.val choice.property valid] + exact parts.sound a valid⟩ + none + +structure OutputFact (chip : Circuit.Chip F) where + id : Witness + value : Polynomial F + unpinned : id ∉ Propagation.fixed chip + sound : ∀ a, Circuit.Satisfies chip.constraints a → a id = value.denote a + +def outputFacts (ctx : Context F) (chip : Circuit.Chip F) + (equations : chip.constraints = (emitChip ctx.logical ctx.layout).constraints) : List (OutputFact chip) := Id.run do + let mut facts := [] + let outputs := ctx.logical.output.words.map ctx.layout.column + for id in ctx.logical.output.words do + let column := ctx.layout.column id + if unpinned : column ∉ Propagation.fixed chip then + if let some definition := outputDefinition ctx id ctx.logical.scopes.size 0 then + let value := definition.expr.simplify + if value.degree ≤ 2 && !value.vars.any (outputs.contains ·) then + facts := facts ++ [⟨column, value, unpinned, by + intro a valid + have ctxValid : ctx.Valid a := by simpa only [Context.Valid, ← equations] using valid + have defined := definition.sound a ctxValid + have root : (ctx.guard 0).denote a = 1 := by + simpa only [Context.guard, ColumnLayout.expression_denote, Scalar.Circuit.ArithExpr.denote] + using ctx.control.1.denote (a ∘ ctx.layout.column) + simpa only [root, one_mul, value, Polynomial.denote_simplify] using defined⟩] + return facts + +def outputReplacement {chip : Circuit.Chip F} (facts : List (OutputFact chip)) (id : Witness) : Polynomial F := + match facts.find? (fun fact => fact.id == id) with + | some fact => fact.value + | none => .var id + +omit [DecidableEq F] in +theorem outputReplacement_fixed {chip : Circuit.Chip F} (facts : List (OutputFact chip)) + {id : Witness} (member : id ∈ Propagation.fixed chip) : outputReplacement facts id = .var id := by + unfold outputReplacement + cases found : facts.find? _ with + | none => rfl + | some fact => + have same : fact.id = id := by simpa only [beq_iff_eq] using (List.find?_some found) + exact False.elim (fact.unpinned (same.symm ▸ member)) + +omit [DecidableEq F] in +theorem outputReplacement_denote {chip : Circuit.Chip F} (facts : List (OutputFact chip)) + {a : Witness → F} (valid : Circuit.Satisfies chip.constraints a) (id : Witness) : + (outputReplacement facts id).denote a = a id := by + unfold outputReplacement + cases found : facts.find? _ with + | none => rfl + | some fact => + have same : fact.id = id := by simpa only [beq_iff_eq] using (List.find?_some found) + exact (fact.sound a valid).symm.trans (congrArg a same) + +def replaceOutputs (chip : Circuit.Chip F) (facts : List (OutputFact chip)) : Propagation.Checked chip where + chip := Propagation.rewrite chip id (outputReplacement facts) + equivalent := by + have fixed : ∀ i ∈ Propagation.fixed chip, outputReplacement facts i = .var i := + fun _ member => outputReplacement_fixed facts member + constructor + · intro rom a valid + have same : (fun i => (outputReplacement facts i).denote a) = a := + funext (outputReplacement_denote facts valid.1) + refine ⟨a, ?_, ?_, ?_⟩ + · rw [Propagation.rewrite_valid, same]; exact valid + · rw [(Propagation.rewrite_claims chip id _ fixed a).1, same] + · rw [(Propagation.rewrite_claims chip id _ fixed a).2, same] + · intro rom a valid + exact ⟨_, (Propagation.rewrite_valid chip id _ rom a).mp valid, + (Propagation.rewrite_claims chip id _ fixed a).1.symm, + (Propagation.rewrite_claims chip id _ fixed a).2.symm⟩ + name_eq := rfl + inputTypes := by simp [Propagation.rewrite, List.map_map, Function.comp_def] + outputType := rfl + +end Aiur.Optimized.LookupMerging diff --git a/Aiur/Aiur/Optimized/BuildFacts.lean b/Aiur/Aiur/Optimized/BuildFacts.lean new file mode 100644 index 000000000..f45ff0c22 --- /dev/null +++ b/Aiur/Aiur/Optimized/BuildFacts.lean @@ -0,0 +1,70 @@ +import Aiur.Optimized.Compile +import Aiur.Circuit.PatternEncoding + +namespace Aiur.Optimized.Compiler + +variable {F : Type} + +theorem bind_ok {first : Build F α} {next : α → Build F β} + {before after : State F} {result : β} : + (first >>= next) before = .ok (result, after) ↔ + ∃ value middle, first before = .ok (value, middle) ∧ next value middle = .ok (result, after) := by + cases run : first before with + | error error => simp [StateT.bind, bind, Except.bind, run] + | ok output => + rcases output with ⟨value, middle⟩ + simp [StateT.bind, bind, Except.bind, run] + +@[simp] theorem pure_ok {value result : α} {before after : State F} : + (pure value : Build F α) before = .ok (result, after) ↔ value = result ∧ before = after := by + simp [pure, StateT.pure, Except.pure] + +@[simp] theorem lift_ok (value : α) (state : State F) : + (liftM (.ok value : Except String α) : Build F α) state = .ok (value, state) := rfl + +@[simp] theorem lift_error (error : String) (state : State F) : + (liftM (.error error : Except String α) : Build F α) state = .error error := rfl + +@[simp] theorem throw_apply (error : String) (state : State F) : + (throw error : Build F α) state = .error error := rfl + +theorem getLayout_eq {decls : Declarations} {type : Ty} {layout : Layout} {before after : State F} + (compiled : getLayout decls type before = .ok (layout, after)) : + decls.layout type = .ok layout ∧ before = after := by + cases expanded : decls.layout type with + | error error => simp [getLayout, expanded, Except.mapError] at compiled + | ok result => + simp only [getLayout, expanded, Except.mapError, lift_ok, Except.ok.injEq, Prod.mk.injEq] at compiled + rcases compiled with ⟨rfl, rfl⟩ + exact ⟨rfl, rfl⟩ + +/-- Both compilers use the same static slicing operation. This bridge reuses +the existing canonical tuple/enum decoding lemmas. -/ +theorem splitValues_reference {decls : Declarations} {types : List Ty} {words : List α} + {values : List (WireValue α)} {before after : State F} + (compiled : splitValues decls types words before = .ok (values, after)) : + after = before ∧ ∀ state : Circuit.Compiler.BuildState F, + Circuit.Compiler.splitValues decls types words state = .ok (values, state) := by + induction types generalizing words values before with + | nil => cases words with + | nil => + obtain ⟨rfl, rfl⟩ := pure_ok.mp compiled + exact ⟨rfl, fun _ => rfl⟩ + | cons => simp [splitValues] at compiled + | cons type types ih => + simp only [splitValues] at compiled + obtain ⟨layout, middle, expanded, rest⟩ := bind_ok.mp compiled + obtain ⟨expansion, rfl⟩ := getLayout_eq expanded + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · rename_i width + obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨rfl, tailReference⟩ := ih tailRun + refine ⟨rfl, fun state => ?_⟩ + simp [Circuit.Compiler.splitValues, Circuit.Compiler.getLayout, expansion, Except.mapError, + StateT.bind, bind, Except.bind, width, StateT.pure, pure, Except.pure, tailReference] + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/CheckedLayout.lean b/Aiur/Aiur/Optimized/CheckedLayout.lean new file mode 100644 index 000000000..9380563ac --- /dev/null +++ b/Aiur/Aiur/Optimized/CheckedLayout.lean @@ -0,0 +1,107 @@ +import Aiur.Optimized.AllocationCertificate +import Aiur.Optimized.Propagation +import Aiur.Optimized.ScopedPropagation +import Aiur.Optimized.ConstraintElimination +import Aiur.Optimized.LookupMerging + +namespace Aiur.Optimized + +variable {F : Type} [Field F] [DecidableEq F] + +def ScopedChip.Realizes (source : ScopedChip F) (physical : Circuit.Chip F) : Prop := + ∀ rom conclusion premises, source.Rule rom conclusion premises ↔ physical.LocalRule rom conclusion premises + +theorem realizes_emit {source logical : ScopedChip F} {layout : ColumnLayout} + (same : source.Equivalent logical) (allocation : Allocation.Certificate logical layout) + (formed : (emitChip logical layout).wellFormed = true) : source.Realizes (emitChip logical layout) := by + intro rom conclusion premises + rw [same.rule_iff] + constructor + · rintro ⟨a, valid, root, calls⟩ + obtain ⟨row, name, valid, root', calls'⟩ := allocation.complete rom a formed valid + exact ⟨row, name, valid, root'.trans root, calls'.trans calls⟩ + · rintro ⟨row, _, valid, root, calls⟩ + exact ⟨_, ((emitChip_validRow logical layout rom row).mp valid).2.2, + (emitChip_receive logical layout row).symm.trans root, + (emitChip_premises logical layout row).symm.trans calls⟩ + +structure CheckedLayout (source : ScopedChip F) extends LaidOutChip F where + equivalent : source.Realizes chip + name_eq : chip.name = source.name + inputTypes : chip.inputs.map WireValue.type = source.inputs.map WireValue.type + outputType : chip.output.type = source.output.type + +def checkedLayOut (config : Config) (chip : ScopedChip F) : Except String (CheckedLayout chip) := do + let aliases ← Alias.checkedResolve chip + let propagated ← if config.propagateScopes then ScopedPropagation.run aliases.chip + else pure (ScopedPropagation.identity aliases.chip) + let simplified := if config.simplifyConstraints then ConstraintElimination.run propagated.chip + else ScopedPropagation.identity propagated.chip + let degree ← Degree.checkedBound config simplified.chip + let logical := degree.chip + unless logical.wellScoped do throw s!"auxiliary escaped its activation scope in {chip.name}" + let layout := allocateColumns config logical + let physical := emitChip logical layout + if allocation : Allocation.Certificate logical layout then + if formed : physical.wellFormed = true then + let lookups := LookupMerging.run config logical layout + let propagatedValues ← if config.propagateValues then Propagation.run lookups.chip + else pure (Propagation.Checked.identity lookups.chip) + let values : Propagation.Checked physical := { + chip := propagatedValues.chip + equivalent := lookups.equivalent.trans propagatedValues.equivalent + name_eq := propagatedValues.name_eq.trans lookups.name_eq + inputTypes := propagatedValues.inputTypes.trans lookups.inputTypes + outputType := propagatedValues.outputType.trans lookups.outputType } + let lookupCap := if config.mergeLookups && !logical.choices.isEmpty then 2 else 1 + if finalFormed : values.chip.wellFormed = true then + if values.chip.stats.maxConstraintDegree > config.maxDegree || values.chip.stats.maxLookupDegree > lookupCap || + values.chip.maxLookupGuardDegree > 1 then + throw s!"degree reduction failed in {chip.name}" + return { + logical, layout, chip := values.chip + equivalent := fun rom root premises => + (realizes_emit (aliases.equivalent.trans + (propagated.equivalent.trans (simplified.equivalent.trans degree.equivalent))) + allocation formed rom root premises).trans + (values.equivalent.localRule formed finalFormed rom root premises) + name_eq := values.name_eq.trans + (degree.name_eq.trans (simplified.name_eq.trans (propagated.name_eq.trans aliases.name_eq))) + inputTypes := values.inputTypes.trans (by + simp [physical, emitChip, logical, degree.inputs_eq, simplified.inputs_eq, propagated.inputs_eq, aliases.inputs_eq, + List.map_map, Function.comp_def]) + outputType := values.outputType.trans (by + simp [physical, emitChip, logical, degree.output_eq, simplified.output_eq, propagated.output_eq, aliases.output_eq]) } + else throw s!"invalid propagated layout in {chip.name}" + else throw s!"invalid optimized layout in {chip.name}" + else throw s!"invalid column-allocation certificate in {chip.name}" + +def layOut (config : Config) (chip : ScopedChip F) : Except String (LaidOutChip F) := + (checkedLayOut config chip).map CheckedLayout.toLaidOutChip + +/-- The actual layout pipeline preserves the entire local rule: selector +elimination, scoped propagation, degree reduction, sharing, emission, quadratic lookup merging, branch outputs, value propagation, +and compaction. -/ +theorem layOut_correct {config : Config} {source : ScopedChip F} {result : LaidOutChip F} + (compiled : layOut config source = .ok result) : source.Realizes result.chip := by + unfold layOut at compiled + cases found : checkedLayOut config source with + | error error => simp [found, Except.map] at compiled + | ok checked => + have same : checked.toLaidOutChip = result := by simpa [found, Except.map] using compiled + cases same + exact checked.equivalent + +theorem layOut_interface {config : Config} {source : ScopedChip F} {result : LaidOutChip F} + (compiled : layOut config source = .ok result) : + result.chip.name = source.name ∧ result.chip.inputs.map WireValue.type = source.inputs.map WireValue.type ∧ + result.chip.output.type = source.output.type := by + unfold layOut at compiled + cases found : checkedLayOut config source with + | error error => simp [found, Except.map] at compiled + | ok checked => + have same : checked.toLaidOutChip = result := by simpa [found, Except.map] using compiled + cases same + exact ⟨checked.name_eq, checked.inputTypes, checked.outputType⟩ + +end Aiur.Optimized diff --git a/Aiur/Aiur/Optimized/ChoiceFacts.lean b/Aiur/Aiur/Optimized/ChoiceFacts.lean new file mode 100644 index 000000000..26d9e95b8 --- /dev/null +++ b/Aiur/Aiur/Optimized/ChoiceFacts.lean @@ -0,0 +1,207 @@ +import Aiur.Optimized.ReferenceState +import Aiur.Optimized.BranchFacts +import Mathlib.Algebra.BigOperators.Fin + +namespace Aiur.Optimized.Compiler + +variable {F : Type} [Field F] [DecidableEq F] + +/-- Every scoped obligation refers to an existing scope, and every activation +uses only allocated logical witnesses. This includes unused scopes. -/ +structure State.Scoped (state : State F) : Prop where + equations : ∀ equation ∈ state.equations.toList, equation.scope < state.scopes.size + calls : ∀ call ∈ state.calls.toList, call.scope < state.scopes.size + cells : ∀ cell ∈ state.cells.toList, cell.scope < state.scopes.size + activations : ∀ scope ∈ state.scopes.toList, scope.activation.inBounds state.roles.size = true + +theorem choice_eq {parent count : Nat} {children : List ScopeId} {before after : State F} + (compiled : choice parent count before = .ok (children, after)) : + ∃ enclosing, before.scopes[parent]? = some enclosing ∧ + children = choiceChildren before count ∧ after = choiceState before parent enclosing count := by + simp only [choice] at compiled + obtain ⟨enclosing, middle, scopeRun, remaining⟩ := bind_ok.mp compiled + obtain ⟨found, stateEq⟩ := getScope_eq scopeRun + subst middle + change Except.ok (choiceChildren before count, choiceState before parent enclosing count) = + Except.ok (children, after) at remaining + obtain ⟨childEq, afterEq⟩ := Prod.mk.inj (Except.ok.inj remaining) + exact ⟨enclosing, found, childEq.symm, afterEq.symm⟩ + +@[simp] theorem choiceChildren_length (before : State F) (count : Nat) : + (choiceChildren before count).length = count := by simp [choiceChildren] + +@[simp] theorem choiceChildren_getElem (before : State F) (count : Nat) (i : Nat) + (bound : i < (choiceChildren before count).length) : + (choiceChildren before count)[i] = before.scopes.size + i := by + simp [choiceChildren] + +@[simp] theorem choiceState_roles_size (before : State F) (parent : ScopeId) + (enclosing : Scope F) (count : Nat) : + (choiceState before parent enclosing count).roles.size = before.roles.size + count := by + simp [choiceState] + +@[simp] theorem choiceState_scopes_size (before : State F) (parent : ScopeId) + (enclosing : Scope F) (count : Nat) : + (choiceState before parent enclosing count).scopes.size = before.scopes.size + count := by + simp [choiceState] + +theorem choiceState_scope {before : State F} {parent count : Nat} {enclosing : Scope F} + {id : ScopeId} {value : Scope F} (found : before.scopes[id]? = some value) : + (choiceState before parent enclosing count).scopes[id]? = some value := by + have bounded := (Array.getElem?_eq_some_iff.mp found).1 + simpa [choiceState, Array.getElem?_append, bounded] using found + +theorem choiceState_activation {before : State F} {parent count : Nat} {enclosing : Scope F} + {id : ScopeId} (bounded : id < before.scopes.size) : + (choiceState before parent enclosing count).activation id = before.activation id := by + simp [State.activation, choiceState, Array.getElem?_append, bounded] + +theorem choiceState_child {before : State F} {parent count : Nat} {enclosing : Scope F} + {i : Nat} (bounded : i < count) : + (choiceState before parent enclosing count).activation (before.scopes.size + i) = + .var (before.roles.size + i) := by + simp [State.activation, choiceState, Array.getElem?_append, Nat.not_lt.mpr (Nat.le_add_right _ _), + Nat.add_sub_cancel_left, List.getElem?_map, List.getElem?_range bounded] + +theorem choiceState_extends (before : State F) (parent : ScopeId) (enclosing : Scope F) (count : Nat) : + before.Extends (choiceState before parent enclosing count) := by + refine ⟨fun _ _ => choiceState_scope, ?_, ?_, ?_⟩ + · intro equation member + simp [choiceState, member] + · exact fun _ => id + · exact fun _ => id + +theorem choice_extends {parent count : Nat} {children : List ScopeId} {before after : State F} + (compiled : choice parent count before = .ok (children, after)) : before.Extends after := by + obtain ⟨enclosing, _, _, rfl⟩ := choice_eq compiled + exact choiceState_extends before parent enclosing count + +theorem choice_length {parent count : Nat} {children : List ScopeId} {before after : State F} + (compiled : choice parent count before = .ok (children, after)) : children.length = count := by + obtain ⟨_, _, rfl, _⟩ := choice_eq compiled + simp + +theorem State.Extends.activation_eq {before after : State F} (extension : before.Extends after) + {scope : ScopeId} (bounded : scope < before.scopes.size) : + after.activation scope = before.activation scope := by + cases found : before.scopes[scope]? with + | none => exact False.elim (Nat.not_le_of_gt bounded (Array.getElem?_eq_none_iff.mp found)) + | some value => simp only [State.activation, found, extension.scopes scope value found] + +theorem choice_child_bound {parent count : Nat} {children : List ScopeId} {before after : State F} + (compiled : choice parent count before = .ok (children, after)) : + ∀ child ∈ children, child < after.scopes.size := by + obtain ⟨enclosing, _, rfl, rfl⟩ := choice_eq compiled + intro child member + obtain ⟨i, bounded, rfl⟩ := List.mem_map.mp member + simpa using Nat.add_lt_add_left (List.mem_range.mp bounded) before.scopes.size + +/-- The semantic output of a choice. Parent activation need not be Boolean for +this local result; the actual equations imply it whenever the choice is valid. -/ +structure ChoiceSound (before after : State F) (parent : ScopeId) + (children : List ScopeId) (assignment : Witness → F) : Prop where + boolean : ∀ i : Fin children.length, + (after.activation children[i]).denote assignment = 0 ∨ + (after.activation children[i]).denote assignment = 1 + exclusive : ∀ i j : Fin children.length, i ≠ j → + (after.activation children[i]).denote assignment * (after.activation children[j]).denote assignment = 0 + coverage : ∑ i : Fin children.length, (after.activation children[i]).denote assignment = + (before.activation parent).denote assignment + +theorem choice_total_denote (before : State F) (count : Nat) (assignment : Witness → F) : + ((choiceSelectors before count).foldl Polynomial.add (.const 0)).denote assignment = + ∑ i : Fin count, assignment (before.roles.size + i) := by + change Scalar.Circuit.ArithExpr.denote assignment _ = _ + rw [Scalar.Circuit.ArithExpr.denote_foldl_add] + simp only [Scalar.Circuit.ArithExpr.denote, zero_add, choiceSelectors, List.map_map] + rw [← List.ofFn_getElem_eq_map] + simp only [List.length_range, List.getElem_range, Circuit.ArithExpr.denote, + Scalar.Circuit.ArithExpr.denote] + exact Fin.sum_ofFn _ + +theorem choice_sound {parent count : Nat} {children : List ScopeId} {before after : State F} + (compiled : choice parent count before = .ok (children, after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {assignment : Witness → F} + (valid : after.Valid rom calls assignment) + (root : (before.activation 0).denote assignment = 1) : + before.Valid rom calls assignment ∧ ChoiceSound before after parent children assignment := by + have oldValid := valid.of_extends (choice_extends compiled) + obtain ⟨enclosing, found, rfl, rfl⟩ := choice_eq compiled + let after := choiceState before parent enclosing count + have rootBound : 0 < before.scopes.size := by + by_contra absent + have empty : before.scopes[0]? = none := Array.getElem?_eq_none_iff.mpr (by omega) + simp [State.activation, empty, Scalar.Circuit.ArithExpr.denote] at root + have global : (after.activation 0).denote assignment = 1 := by + rw [choiceState_activation rootBound] + exact root + have imposed (polynomial : Polynomial F) + (member : (⟨0, polynomial⟩ : Equation F) ∈ choiceEquations before enclosing count) : + polynomial.denote assignment = 0 := by + have satisfied := valid.1 ⟨0, polynomial⟩ (by simp [choiceState, member]) + change (after.activation 0).denote assignment * polynomial.denote assignment = 0 at satisfied + simpa [global] using satisfied + have bool (i : Nat) (bounded : i < count) : + assignment (before.roles.size + i) * (assignment (before.roles.size + i) - 1) = 0 := by + apply imposed (.mul (.var (before.roles.size + i)) (.sub (.var (before.roles.size + i)) (.const 1))) + apply List.mem_append_left + apply List.mem_flatMap.mpr + exact ⟨i, List.mem_range.mpr bounded, by simp⟩ + have pair (i j : Nat) (iBound : i < count) (less : j < i) : + assignment (before.roles.size + i) * assignment (before.roles.size + j) = 0 := by + apply imposed (.mul (.var (before.roles.size + i)) (.var (before.roles.size + j))) + apply List.mem_append_left + apply List.mem_flatMap.mpr + exact ⟨i, List.mem_range.mpr iBound, by simp [less]⟩ + have cover := imposed (.sub ((choiceSelectors before count).foldl Polynomial.add (.const 0)) + enclosing.activation) (by simp [choiceEquations]) + change ((choiceSelectors before count).foldl Polynomial.add (.const 0)).denote assignment - + enclosing.activation.denote assignment = 0 at cover + rw [choice_total_denote] at cover + refine ⟨oldValid, ⟨?_, ?_, ?_⟩⟩ + · intro i + simpa only [Fin.getElem_fin, choiceChildren_getElem, choiceState_child (by simpa using i.isLt), + Circuit.ArithExpr.denote, Scalar.Circuit.ArithExpr.denote] using (selector_boolean _).mp (bool i (by simpa using i.isLt)) + · intro i j different + simp only [Fin.getElem_fin, choiceChildren_getElem, choiceState_child (by simpa using i.isLt), + choiceState_child (by simpa using j.isLt), Circuit.ArithExpr.denote, Scalar.Circuit.ArithExpr.denote] + have distinct : i.val ≠ j.val := fun same => different (Fin.ext same) + rcases lt_or_gt_of_ne distinct with less | greater + · rw [mul_comm] + exact pair j i (by simpa using j.isLt) less + · exact pair i j (by simpa using i.isLt) greater + · have pointwise (i : Fin (choiceChildren before count).length) : + (choiceState before parent enclosing count).activation (before.scopes.size + i) = + .var (before.roles.size + i) := choiceState_child (by simpa using i.isLt) + simp only [Fin.getElem_fin, choiceChildren_getElem] + simp_rw [pointwise] + simp only [Circuit.ArithExpr.denote, Scalar.Circuit.ArithExpr.denote] + rw [Fin.sum_univ_eq_sum_range (fun i => assignment (before.roles.size + i)) (choiceChildren before count).length] + rw [Fin.sum_univ_eq_sum_range (fun i => assignment (before.roles.size + i)) count] at cover + simpa [State.activation, found, Circuit.ArithExpr.denote] using sub_eq_zero.mp cover + +theorem ChoiceSound.active {before after : State F} {parent : ScopeId} {children : List ScopeId} + {assignment : Witness → F} (sound : ChoiceSound before after parent children assignment) + (active : (before.activation parent).denote assignment = 1) : + ∃! i : Fin children.length, (after.activation children[i]).denote assignment = 1 := by + apply selector_exactly_one _ _ sound.exclusive (sound.coverage.trans active) + intro i + exact (selector_boolean _).mpr (sound.boolean i) + +theorem ChoiceSound.inactive {before after : State F} {parent : ScopeId} {children : List ScopeId} + {assignment : Witness → F} (sound : ChoiceSound before after parent children assignment) + (inactive : (before.activation parent).denote assignment = 0) : + ∀ i : Fin children.length, (after.activation children[i]).denote assignment = 0 := + selector_inactive _ sound.exclusive (sound.coverage.trans inactive) + +theorem choice_active {parent count : Nat} {children : List ScopeId} {before after : State F} + (compiled : choice parent count before = .ok (children, after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {assignment : Witness → F} + (valid : after.Valid rom calls assignment) + (root : (before.activation 0).denote assignment = 1) + (active : (before.activation parent).denote assignment = 1) : + ∃ branch ∈ children, (after.activation branch).denote assignment = 1 := by + obtain ⟨i, selected, _⟩ := (choice_sound compiled valid root).2.active active + exact ⟨children[i], List.getElem_mem i.isLt, selected⟩ + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/ChoiceWitness.lean b/Aiur/Aiur/Optimized/ChoiceWitness.lean new file mode 100644 index 000000000..ae8cc5947 --- /dev/null +++ b/Aiur/Aiur/Optimized/ChoiceWitness.lean @@ -0,0 +1,239 @@ +import Aiur.Optimized.ChoiceFacts +import Aiur.Scalar.Circuit.WitnessBasic + +namespace Aiur.Optimized.Compiler + +variable {F : Type} [Field F] [DecidableEq F] + +theorem State.Scoped.activation_bound {state : State F} (scopeLayout : state.Scoped) (id : ScopeId) : + (state.activation id).inBounds state.roles.size = true := by + cases found : state.scopes[id]? with + | none => simp [State.activation, found, Circuit.ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] + | some scope => + simpa [State.activation, found] using scopeLayout.activations scope + (by simpa using Array.mem_of_getElem? found) + +theorem State.Scoped.fresh {state : State F} (scopeLayout : state.Scoped) (role : Role) : + ({ state with roles := state.roles.push role, aliases := state.aliases.push none } : State F).Scoped := by + refine ⟨scopeLayout.equations, scopeLayout.calls, scopeLayout.cells, ?_⟩ + intro scope member + exact Scalar.Circuit.ArithExpr.inBounds_mono (by simp) (scopeLayout.activations scope member) + +theorem State.Scoped.equation {state : State F} (scopeLayout : state.Scoped) {scope : ScopeId} + (bounded : scope < state.scopes.size) (polynomial : Polynomial F) : + ({ state with equations := state.equations.push ⟨scope, polynomial⟩ } : State F).Scoped := by + refine ⟨?_, scopeLayout.calls, scopeLayout.cells, scopeLayout.activations⟩ + intro equation member + simp only [Array.toList_push, List.mem_append, List.mem_singleton] at member + rcases member with member | rfl + · exact scopeLayout.equations equation member + · exact bounded + +private theorem choiceEquation_scope {before : State F} {enclosing : Scope F} {count : Nat} + {equation : Equation F} (member : equation ∈ choiceEquations before enclosing count) : + equation.scope = 0 := by + simp only [choiceEquations, List.mem_append, List.mem_flatMap, List.mem_cons, + List.mem_map, List.mem_singleton, List.not_mem_nil, or_false] at member + rcases member with ⟨i, _, equal | ⟨j, _, equal⟩⟩ | equal <;> subst equation <;> rfl + +theorem choice_scoped {parent count : Nat} {children : List ScopeId} {before after : State F} + (compiled : choice parent count before = .ok (children, after)) + (scopeLayout : before.Scoped) : after.Scoped := by + obtain ⟨enclosing, found, _, rfl⟩ := choice_eq compiled + have rootBound : 0 < before.scopes.size := by + have := (Array.getElem?_eq_some_iff.mp found).1 + omega + have grow : before.roles.size ≤ before.roles.size + count := Nat.le_add_right _ _ + refine ⟨?_, ?_, ?_, ?_⟩ + · intro equation member + simp only [choiceState, Array.toList_append, List.toList_toArray, List.mem_append] at member + rcases member with old | new + · exact lt_of_lt_of_le (scopeLayout.equations equation old) (by simp) + · rw [choiceEquation_scope new] + simpa using lt_of_lt_of_le rootBound (Nat.le_add_right before.scopes.size count) + · intro call member + exact lt_of_lt_of_le (scopeLayout.calls call member) (by simp) + · intro cell member + exact lt_of_lt_of_le (scopeLayout.cells cell member) (by simp) + · intro scope member + simp only [choiceState, Array.toList_append, List.toList_toArray, List.mem_append, + List.mem_map, List.mem_range] at member + rcases member with old | ⟨i, bounded, rfl⟩ + · exact Scalar.Circuit.ArithExpr.inBounds_mono (by simpa using grow) (scopeLayout.activations scope old) + · simpa [Circuit.ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + (Nat.add_lt_add_left bounded before.roles.size) + +private theorem choiceEquation_bounded {before : State F} {enclosing : Scope F} {count : Nat} + (enclosingBound : enclosing.activation.inBounds before.roles.size = true) + {equation : Equation F} (member : equation ∈ choiceEquations before enclosing count) : + equation.polynomial.inBounds (before.roles.size + count) = true := by + have selector (i : Nat) (bounded : i < count) : + (Polynomial.var (F := F) (before.roles.size + i)).inBounds (before.roles.size + count) = true := by + simpa [Circuit.ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + Nat.add_lt_add_left bounded before.roles.size + have total : ((choiceSelectors before count).foldl Polynomial.add (.const 0)).inBounds + (before.roles.size + count) = true := by + apply Scalar.Circuit.Compiler.foldl_add_inBounds rfl + intro p member + obtain ⟨i, bounded, rfl⟩ := List.mem_map.mp member + exact selector i (List.mem_range.mp bounded) + simp only [choiceEquations, List.mem_append, List.mem_flatMap, List.mem_cons, + List.mem_map, List.mem_singleton, List.mem_range, List.not_mem_nil, or_false] at member + rcases member with ⟨i, bounded, equal | ⟨j, less, equal⟩⟩ | equal + · subst equation + simpa [Circuit.ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using selector i bounded + · subst equation + simpa [Circuit.ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + And.intro (selector i bounded) (selector j (less.trans bounded)) + · subst equation + simpa [Circuit.ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + And.intro total (Scalar.Circuit.ArithExpr.inBounds_mono (Nat.le_add_right _ _) enclosingBound) + +private theorem choiceState_wellformed {before : State F} {parent count : Nat} {enclosing : Scope F} + (found : before.scopes[parent]? = some enclosing) (scopeLayout : before.Scoped) + (layout : before.toReference.WellFormed) : + (choiceState before parent enclosing count).toReference.WellFormed := by + let after := choiceState before parent enclosing count + have rootBound : 0 < before.scopes.size := by + have := (Array.getElem?_eq_some_iff.mp found).1 + omega + have increase : before.roles.size ≤ after.roles.size := by simp [after] + have enclosingBound : enclosing.activation.inBounds before.roles.size = true := + scopeLayout.activations enclosing (by simpa using Array.mem_of_getElem? found) + refine ⟨?_, ?_, ?_⟩ + · intro polynomial member + simp only [State.toReference, Array.toList_map, List.mem_map] at member + obtain ⟨equation, member, rfl⟩ := member + change (Polynomial.mul (after.activation equation.scope) equation.polynomial).inBounds after.roles.size = true + simp only [choiceState, Array.toList_append, List.toList_toArray, List.mem_append] at member + rcases member with old | new + · rw [choiceState_activation (scopeLayout.equations equation old)] + apply Scalar.Circuit.ArithExpr.inBounds_mono increase + exact layout.constraints _ (by + simp only [State.toReference, Array.toList_map, List.mem_map] + exact ⟨equation, old, rfl⟩) + · rw [choiceEquation_scope new, choiceState_activation rootBound] + simpa only [after, choiceState_roles_size, Circuit.ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds, Bool.and_eq_true] using + And.intro (Scalar.Circuit.ArithExpr.inBounds_mono increase (scopeLayout.activation_bound 0)) + (choiceEquation_bounded enclosingBound new) + · intro send member + simp only [State.toReference, Array.toList_map, List.mem_map] at member + obtain ⟨call, member, rfl⟩ := member + change (Circuit.Send.mk call.channel call.args call.result (after.activation call.scope)).inBounds after.roles.size = true + rw [choiceState_activation (scopeLayout.calls call member)] + apply Circuit.Compiler.Send_bounds_mono increase + exact layout.sends _ (by + simp only [State.toReference, Array.toList_map, List.mem_map] + exact ⟨call, member, rfl⟩) + · intro lookup member + simp only [State.toReference, Array.toList_map, List.mem_map] at member + obtain ⟨cell, member, rfl⟩ := member + change (Circuit.MemoryLookup.mk cell.address cell.value (after.activation cell.scope)).inBounds after.roles.size = true + rw [choiceState_activation (scopeLayout.cells cell member)] + apply Circuit.Compiler.MemoryLookup_bounds_mono increase + exact layout.memory _ (by + simp only [State.toReference, Array.toList_map, List.mem_map] + exact ⟨cell, member, rfl⟩) + +private theorem choiceState_valid {before : State F} {parent count : Nat} {enclosing : Scope F} + (scopeLayout : before.Scoped) {rom : WireROM F} {calls : Circuit.CallRelation F} + {assignment : Witness → F} (valid : before.Valid rom calls assignment) + (zero : ∀ equation ∈ choiceEquations before enclosing count, + equation.polynomial.denote assignment = 0) : + (choiceState before parent enclosing count).Valid rom calls assignment := by + refine ⟨?_, ?_, ?_⟩ + · intro equation member + simp only [choiceState, Array.toList_append, List.toList_toArray, List.mem_append] at member + rcases member with old | new + · rw [choiceState_activation (scopeLayout.equations equation old)] + exact valid.1 equation old + · rw [zero equation new, mul_zero] + · intro call member active + rw [choiceState_activation (scopeLayout.calls call member)] at active + exact valid.2.1 call member active + · intro cell member active + rw [choiceState_activation (scopeLayout.cells cell member)] at active + exact valid.2.2 cell member active + +/-- A choice witness selects one arm, or no arm when its parent is inactive. -/ +def choiceSelected {count : Nat} (selected : Option (Fin count)) (i : Nat) : F := + if selected.map Fin.val = some i then 1 else 0 + +private theorem choiceSelected_boolean {count : Nat} (selected : Option (Fin count)) (i : Nat) : + choiceSelected (F := F) selected i * (choiceSelected selected i - 1) = 0 := by + unfold choiceSelected + split <;> simp + +private theorem choiceSelected_exclusive {count : Nat} (selected : Option (Fin count)) + (i j : Nat) (different : i ≠ j) : + choiceSelected (F := F) selected i * choiceSelected selected j = 0 := by + by_cases left : selected.map Fin.val = some i + · have right : selected.map Fin.val ≠ some j := fun equal => different (Option.some.inj (left.symm.trans equal)) + simp [choiceSelected, left, different] + · simp [choiceSelected, left] + +private theorem choiceSelected_sum {count : Nat} (selected : Option (Fin count)) : + ∑ i : Fin count, choiceSelected (F := F) selected i = if selected.isSome then 1 else 0 := by + cases selected with + | none => simp [choiceSelected] + | some selected => + have pointwise (i : Fin count) : choiceSelected (F := F) (some selected) i = + if selected = i then 1 else 0 := by simp [choiceSelected, Fin.ext_iff] + simp_rw [pointwise] + simp + +/-- Construct all selector witnesses, keeping every existing witness fixed. +The optional arm is absent exactly when the parent activation is zero. -/ +theorem choice_complete {parent count : Nat} {children : List ScopeId} {before after : State F} + (compiled : choice parent count before = .ok (children, after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (scopeLayout : before.Scoped) + (valid : before.Valid rom calls initial) (selected : Option (Fin count)) + (parentValue : (before.activation parent).denote initial = if selected.isSome then 1 else 0) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + ∀ i : Fin children.length, + (after.activation children[i]).denote assignment = choiceSelected selected i := by + obtain ⟨enclosing, found, rfl, rfl⟩ := choice_eq compiled + let assignment : Witness → F := fun id => + if id < before.roles.size then initial id else choiceSelected selected (id - before.roles.size) + have agree : ∀ id < before.roles.size, assignment id = initial id := by + intro id bounded + simp [assignment, bounded] + have witness (i : Nat) : assignment (before.roles.size + i) = choiceSelected selected i := by + simp [assignment, Nat.not_lt.mpr (Nat.le_add_right _ _)] + have enclosingBound := scopeLayout.activations enclosing (by simpa using Array.mem_of_getElem? found) + have parentValue' : enclosing.activation.denote assignment = if selected.isSome then 1 else 0 := by + change Scalar.Circuit.ArithExpr.denote assignment enclosing.activation = _ + rw [Scalar.Circuit.ArithExpr.denote_eq_of_agree agree enclosingBound] + simpa [State.activation, found, Circuit.ArithExpr.denote] using parentValue + have oldValid : before.Valid rom calls assignment := by + apply (before.valid_iff_reference rom calls assignment).mpr + exact ((before.valid_iff_reference rom calls initial).mp valid).of_agree layout agree + have zero : ∀ equation ∈ choiceEquations before enclosing count, + equation.polynomial.denote assignment = 0 := by + intro equation member + simp only [choiceEquations, List.mem_append, List.mem_flatMap, List.mem_cons, + List.mem_map, List.mem_singleton, List.mem_range, List.not_mem_nil, or_false] at member + rcases member with ⟨i, bounded, equal | ⟨j, less, equal⟩⟩ | equal + · subst equation + simpa only [Circuit.ArithExpr.denote, Scalar.Circuit.ArithExpr.denote, witness] using + choiceSelected_boolean (F := F) selected i + · subst equation + simpa only [Circuit.ArithExpr.denote, Scalar.Circuit.ArithExpr.denote, witness] using + choiceSelected_exclusive (F := F) selected i j (Nat.ne_of_gt less) + · subst equation + change ((choiceSelectors before count).foldl Polynomial.add (.const 0)).denote assignment - + enclosing.activation.denote assignment = 0 + rw [choice_total_denote, parentValue'] + simp_rw [witness] + rw [choiceSelected_sum, sub_self] + have finalValid := choiceState_valid (parent := parent) scopeLayout oldValid zero + refine ⟨assignment, ⟨?_, agree, choiceState_wellformed found scopeLayout layout, + ((choiceState before parent enclosing count).valid_iff_reference rom calls assignment).mp finalValid⟩, ?_⟩ + · change before.roles.size ≤ (choiceState before parent enclosing count).roles.size + simp + · intro i + simp only [Fin.getElem_fin, choiceChildren_getElem, choiceState_child (by simpa using i.isLt), + Circuit.ArithExpr.denote, Scalar.Circuit.ArithExpr.denote, witness] + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/Compile.lean b/Aiur/Aiur/Optimized/Compile.lean new file mode 100644 index 000000000..3b35860ae --- /dev/null +++ b/Aiur/Aiur/Optimized/Compile.lean @@ -0,0 +1,355 @@ +import Aiur.Optimized.ConstantDivision + +namespace Aiur.Optimized +namespace Compiler + +abbrev Symbolic (F : Type) := WireValue (Polynomial F) +abbrev Locals (F : Type) := List (String × Symbolic F) + +structure State (F : Type) where + roles : Array Role := #[] + aliases : Array (Option (Polynomial F)) := #[] + scopes : Array (Scope F) := #[] + nextChoice : Nat := 0 + equations : Array (Equation F) := #[] + calls : Array (Call F) := #[] + cells : Array (Cell F) := #[] + choices : Array Choice := #[] + config : Config := {} + +abbrev Build (F : Type) := StateT (State F) (Except String) + +def fresh (role : Role) : Build F Witness := do + let state ← get + set { state with roles := state.roles.push role, aliases := state.aliases.push none } + return state.roles.size + +def equation (scope : ScopeId) (polynomial : Polynomial F) : Build F Unit := + modify fun state => { state with equations := state.equations.push ⟨scope, polynomial⟩ } + +def getScope (scope : ScopeId) : Build F (Scope F) := do + let some value := (← get).scopes[scope]? | throw "invalid activation scope" + return value + +def getLayout (decls : Declarations) (type : Ty) : Build F Layout := + liftM ((decls.layout type).mapError reprStr) + +def freshValue (decls : Declarations) (role : Role) (type : Ty) : Build F (WireValue Witness) := do + let layout ← getLayout decls type + return ⟨type, ← (List.range layout.width).mapM fun _ => fresh role⟩ + +def splitValues (decls : Declarations) : List Ty → List α → Build F (List (WireValue α)) + | [], [] => pure [] + | type :: types, words => do + let layout ← getLayout decls type + if words.length < layout.width then throw "invalid flat value shape" + return ⟨type, words.take layout.width⟩ :: + (← splitValues decls types (words.drop layout.width)) + | [], _ :: _ => throw "invalid flat value shape" + +/-- Logical selector variables allocated by a choice, in arm order. -/ +def choiceSelectors (before : State F) (count : Nat) : List (Polynomial F) := + (List.range count).map fun arm => .var (before.roles.size + arm) + +def choiceChildren (before : State F) (count : Nat) : List ScopeId := + (List.range count).map fun arm => before.scopes.size + arm + +/-- Booleanity and pairwise exclusion are emitted before the coverage equation, +with the same ordering as the incremental selector allocator. -/ +def choiceEquations [Field F] (before : State F) (enclosing : Scope F) (count : Nat) : + List (Equation F) := + (List.range count).flatMap (fun arm => + let selector : Polynomial F := .var (before.roles.size + arm) + ⟨0, .mul selector (.sub selector (.const 1))⟩ :: + (List.range arm).map fun previous => + ⟨0, .mul selector (.var (before.roles.size + previous))⟩) ++ + [⟨0, .sub ((choiceSelectors before count).foldl Polynomial.add (.const 0)) enclosing.activation⟩] + +/-- Resolve only the optional parent alias; control equations remain present. -/ +def choiceAliases [Field F] (before : State F) (enclosing : Scope F) (count : Nat) : + Array (Option (Polynomial F)) := + let aliases := before.aliases ++ (List.replicate count none).toArray + let roles := before.roles ++ (List.replicate count Role.selector).toArray + if before.config.eliminateSelectors && count > 0 then + if let .var id := enclosing.activation then + if roles[id]? == some .selector && (aliases[id]?.getD none).isNone then + aliases.set! id (some ((choiceSelectors before count).foldl Polynomial.add (.const 0))) + else aliases + else aliases + else aliases + +/-- The fresh block of selectors and scopes can be allocated in bulk because +all indices are determined by the original state and the number of arms. -/ +def choiceState [Field F] (before : State F) (parent : ScopeId) (enclosing : Scope F) + (count : Nat) : State F := + { before with + roles := before.roles ++ (List.replicate count Role.selector).toArray + aliases := choiceAliases before enclosing count + scopes := before.scopes ++ ((List.range count).map fun arm => + ⟨.var (before.roles.size + arm), enclosing.path ++ [(before.nextChoice, arm)]⟩).toArray + nextChoice := before.nextChoice + 1 + equations := before.equations ++ (choiceEquations before enclosing count).toArray + choices := before.choices.push ⟨parent, choiceChildren before count⟩ } + +/-- All control equations are global. Branch payload equations use the new scopes. -/ +def choice [Field F] (parent : ScopeId) (count : Nat) : Build F (List ScopeId) := do + let enclosing ← getScope parent + let before ← get + set (choiceState before parent enclosing count) + return choiceChildren before count + +mutual + def validate [Field F] (scope : ScopeId) : Layout → List (Polynomial F) → Build F Unit + | .field, [_] | .ptr _, [_] => pure () + | .tuple layouts, words => validateList scope layouts words + | .enum _ constructors, words => do + let some (tag, payload) := Layout.enumParts constructors.length (.const 0) words + | throw "invalid enum shape" + if payload.length != Layout.payloadWidth constructors then throw "invalid enum width" + let branches ← choice scope constructors.length + validateConstructors constructors branches tag payload 0 + | _, _ => throw "invalid value shape" + termination_by layout _ => sizeOf layout + + def validateList [Field F] (scope : ScopeId) : List Layout → List (Polynomial F) → Build F Unit + | [], [] => pure () + | layout :: layouts, words => do + if words.length < layout.width then throw "invalid tuple width" + validate scope layout (words.take layout.width) + validateList scope layouts (words.drop layout.width) + | [], _ :: _ => throw "invalid tuple width" + termination_by layouts _ => sizeOf layouts + + def validateConstructors [Field F] : List (String × Layout) → List ScopeId → + Polynomial F → List (Polynomial F) → Nat → Build F Unit + | [], [], _, _, _ => pure () + | (_, layout) :: rest, branch :: branches, tag, payload, index => do + equation branch (.sub tag (.const (index : F))) + validate branch layout (payload.take layout.width) + for word in payload.drop layout.width do equation branch word + validateConstructors rest branches tag payload (index + 1) + | _, _, _, _, _ => throw "constructor scope mismatch" + termination_by constructors _ _ _ _ => sizeOf constructors +end + +def validateValue [Field F] (decls : Declarations) (scope : ScopeId) (value : Symbolic F) : Build F Unit := do + validate scope (← getLayout decls value.type) value.words + +def validateParameters [Field F] (decls : Declarations) (enabled : Bool) + (inputs : List (WireValue Witness)) : Build F Unit := do + if enabled then + for value in inputs do validateValue decls 0 (value.map Polynomial.var) + +mutual + /-- Core patterns are conjunctions of scalar equalities. Source pattern loads + have already been translated to ordinary core expressions by preparation. -/ + def pattern [Field F] (decls : Declarations) (pat : Pattern F) (value : Symbolic F) : + Build F (List (Polynomial F) × Locals F) := do + match pat with + | .wildcard => return ([], []) + | .bind name => return ([], [(name, value)]) + | .literal literal => + let ⟨.field, [word]⟩ := value | throw "non-field literal pattern" + return ([.sub word (.const literal)], []) + | .tuple patterns => + let .tuple types := value.type | throw "non-tuple pattern" + patternList decls patterns (← splitValues decls types value.words) + | .construct name ctor patterns => + if value.type ≠ .enum name then throw "constructor pattern type mismatch" + let some definition := decls.findEnum? name | throw "unknown enum" + let index := definition.constructors.findIdx (·.name == ctor) + let some constructor := definition.constructors[index]? | throw "unknown constructor" + let some (tag, payload) := Layout.enumParts definition.constructors.length (.const 0) value.words + | throw "invalid constructor shape" + let layout ← getLayout decls (.tuple constructor.fields) + let values ← splitValues decls constructor.fields (payload.take layout.width) + let (conditions, bindings) ← patternList decls patterns values + return (.sub tag (.const (index : F)) :: conditions, bindings) + termination_by sizeOf pat + + def patternList [Field F] (decls : Declarations) (patterns : List (Pattern F)) + (values : List (Symbolic F)) : Build F (List (Polynomial F) × Locals F) := do + match patterns, values with + | [], [] => return ([], []) + | pat :: patterns, value :: values => + let (head, bindings) ← pattern decls pat value + let (tail, rest) ← patternList decls patterns values + return (head ++ tail, bindings ++ rest) + | _, _ => throw "pattern arity mismatch" + termination_by sizeOf patterns +end + +/-- A conjunction fails exactly when its differences generate one in the field. +The coefficients are branch-owned witnesses; no global equality indicators. -/ +def failure [Field F] (scope : ScopeId) (conditions : List (Polynomial F)) : Build F Unit := do + let terms ← conditions.mapM fun difference => do + return Polynomial.mul difference (.var (← fresh (.auxiliary scope))) + equation scope (.sub (terms.foldl Polynomial.add (.const 0)) (.const 1)) + +def equalValue (scope : ScopeId) (left right : Symbolic F) : Build F Unit := do + if left.type ≠ right.type ∨ left.words.length ≠ right.words.length then + throw "value equality shape mismatch" + for (a, b) in left.words.zip right.words do equation scope (.sub a b) + +def asField : Symbolic F → Build F (Polynomial F) + | ⟨.field, [word]⟩ => pure word + | _ => throw "expected a field" + +def destination (decls : Declarations) (scope : ScopeId) (type : Ty) + (target : Option (WireValue Witness)) : Build F (WireValue Witness) := do + if let some target := target then + if target.type ≠ type then throw "destination type mismatch" + return target + freshValue decls (.auxiliary scope) type + +def retainArms (decls : Declarations) : List (Pattern F × Expr F) → List (Pattern F × Expr F) + | [] => [] + | arm :: rest => arm :: if arm.1.irrefutable decls then [] else retainArms decls rest + +mutual + def lower [Field F] [DecidableEq F] (program : Program F) (function : String) + (locals : Locals F) (scope : ScopeId) (expr : Expr F) + (target : Option (WireValue Witness) := none) : Build F (Symbolic F) := do + let step : Build F (Symbolic F) := do + match expr with + | .literal value => pure (WireValue.field (.const value)) + | .var name => do + let some (_, value) := locals.find? (·.1 == name) | throw s!"unbound variable {name}" + pure value + | .tuple items => do + pure (.tuple (← lowerArgs program function locals scope items)) + | .construct name ctor args => do + let some definition := program.enums.findEnum? name | throw "unknown enum" + let index := definition.constructors.findIdx (·.name == ctor) + let some constructor := definition.constructors[index]? | throw "unknown constructor" + let values ← lowerArgs program function locals scope args + if values.map WireValue.type ≠ constructor.fields then throw "constructor argument types" + let layout ← getLayout program.enums (.enum name) + let payload := values.flatMap WireValue.words + let tagWidth := Layout.tagWidth definition.constructors.length + if payload.length + tagWidth > layout.width then throw "constructor payload width" + pure ⟨.enum name, Layout.enumWords definition.constructors.length (.const (index : F)) + (payload ++ List.replicate (layout.width - tagWidth - payload.length) (.const 0))⟩ + | .project operand index => do + let value ← lower program function locals scope operand + let .tuple types := value.type | throw "non-tuple projection" + let items ← splitValues program.enums types value.words + let some result := items[index]? | throw "projection out of bounds" + pure result + | .letValue pat value body => do + let value ← lower program function locals scope value + let (conditions, bindings) ← pattern program.enums pat value + for condition in conditions do equation scope condition + lower program function (bindings ++ locals) scope body target + | .store operand => do + let value ← lower program function locals scope operand + let result ← destination program.enums scope (.ptr value.type) target + let [address] := result.words | throw "pointer width" + -- The operand's soundness already supplies a canonical encoding. + -- Storing it preserves the provenance used to justify later loads. + modify fun state => { state with cells := state.cells.push ⟨scope, .var address, value⟩ } + pure (result.map Polynomial.var) + | .load operand => do + let pointer ← lower program function locals scope operand + let ⟨.ptr type, [address]⟩ := pointer | throw "non-pointer load" + let result ← destination program.enums scope type target + let value := result.map Polynomial.var + -- Finite entry derivations supply validity through store provenance + -- and ROM address uniqueness; reads require only the cell lookup. + modify fun state => { state with cells := state.cells.push ⟨scope, address, value⟩ } + pure value + | .neg operand => do + pure (.field (.sub (.const 0) (← asField (← lower program function locals scope operand)))) + | .hint type key channel => do + let _ ← lower program function locals scope key + if !type.pointerFree program.enums then throw "hint result contains pointers" + let result ← destination program.enums scope type target + validateValue program.enums scope (result.map Polynomial.var) + pure (result.map Polynomial.var) + | .assertEq _ left right => do + let left ← lower program function locals scope left + let right ← lower program function locals scope right + if !left.type.pointerFree program.enums then throw "assertion contains pointers" + equalValue scope left right + pure (.tuple []) + | .binary op left right => do + let left ← asField (← lower program function locals scope left) + let right ← asField (← lower program function locals scope right) + match op with + | .add => pure (.field (.add left right)) + | .sub => pure (.field (.sub left right)) + | .mul => pure (.field (.mul left right)) + | .div => + match right.constantInverse? with + | some inverse => pure (.field (.mul left (.const inverse))) + | none => do + let inverse ← fresh (.auxiliary scope) + equation scope (.sub (.mul right (.var inverse)) (.const 1)) + pure (.field (.mul left (.var inverse))) + | .call name args => do + let some callee := program.findSignature? name | throw s!"unknown function {name}" + let args ← lowerArgs program function locals scope args + if args.map WireValue.type ≠ callee.params.map Prod.snd then throw "call argument types" + let result ← destination program.enums scope callee.result target + -- Canonical arguments follow from expression soundness; the callee's + -- induction hypothesis supplies a canonical result. + modify fun state => { state with calls := state.calls.push ⟨scope, name, args, result⟩ } + pure (result.map Polynomial.var) + | .matchValue scrutinee arms => do + let _ ← liftM ((Circuit.Compiler.checkPatterns program.enums function arms []).mapError reprStr) + let type ← liftM ((inferType program function + (locals.map fun (name, value) => (name, value.type)) expr).mapError reprStr) + let scrutinee ← lower program function locals scope scrutinee + let result ← destination program.enums scope type target + let retained := retainArms program.enums arms + let branches ← choice scope retained.length + lowerArms program function locals scrutinee result branches arms [] + pure (result.map Polynomial.var) + let value ← step + if let some result := target then + equalValue scope (result.map Polynomial.var) value + return result.map Polynomial.var + return value + termination_by sizeOf expr + + def lowerArgs [Field F] [DecidableEq F] (program : Program F) (function : String) + (locals : Locals F) (scope : ScopeId) (args : List (Expr F)) : Build F (List (Symbolic F)) := do + match args with + | [] => return [] + | arg :: rest => return (← lower program function locals scope arg) :: + (← lowerArgs program function locals scope rest) + termination_by sizeOf args + + def lowerArms [Field F] [DecidableEq F] (program : Program F) (function : String) + (locals : Locals F) (scrutinee : Symbolic F) (result : WireValue Witness) + (scopes : List ScopeId) (arms : List (Pattern F × Expr F)) + (previous : List (List (Polynomial F))) : Build F Unit := do + match scopes, arms with + | [], [] => pure () + | scope :: scopes, (pat, body) :: rest => do + let (conditions, bindings) ← pattern program.enums pat scrutinee + for condition in conditions do equation scope condition + for earlier in previous do failure scope earlier + let _ ← lower program function (bindings ++ locals) scope body (some result) + if pat.irrefutable program.enums then pure () + else lowerArms program function locals scrutinee result scopes rest (previous ++ [conditions]) + | _, _ => throw "branch scope mismatch" + termination_by sizeOf arms +end + +def function [Field F] [DecidableEq F] (program : Program F) (config : Config) + (fn : Function F) (validateInputs : Bool := true) : Except String (ScopedChip F) := do + let build : Build F (List (WireValue Witness) × WireValue Witness) := do + let inputs ← (fn.params.map Prod.snd).mapM (freshValue program.enums .input) + let output ← freshValue program.enums .output fn.result + -- Only entry arguments and fresh hints cross the canonical-value boundary. + validateParameters program.enums validateInputs inputs + let locals := (fn.params.map Prod.fst).zip (inputs.map (WireValue.map Polynomial.var)) + let _ ← lower program fn.name locals 0 fn.body (some output) + return (inputs, output) + let ((inputs, output), state) ← build.run { config, scopes := #[⟨.const 1, []⟩] } + return ⟨fn.name, inputs, output, state.roles, state.aliases, state.scopes, + state.equations, state.calls, state.cells, state.choices⟩ + +end Compiler +end Aiur.Optimized diff --git a/Aiur/Aiur/Optimized/CompileFacts.lean b/Aiur/Aiur/Optimized/CompileFacts.lean new file mode 100644 index 000000000..ab8ec69b1 --- /dev/null +++ b/Aiur/Aiur/Optimized/CompileFacts.lean @@ -0,0 +1,174 @@ +import Aiur.Optimized.ReferenceState + +namespace Aiur.Optimized.Compiler + +variable {F : Type} [Field F] [DecidableEq F] + +theorem fresh_extends {role : Role} {id : Witness} {before after : State F} + (compiled : fresh role before = .ok (id, after)) : before.Extends after := by + obtain ⟨_, rfl⟩ := fresh_eq compiled + exact ⟨fun _ _ h => h, fun _ h => h, fun _ h => h, fun _ h => h⟩ + +theorem freshList_preserves {α : Type} {items : List α} {role : Role} + {ids : List Witness} {before after : State F} + (compiled : (items.mapM (fun _ => fresh role)) before = .ok (ids, after)) : + after.scopes = before.scopes ∧ after.equations = before.equations ∧ + after.calls = before.calls ∧ after.cells = before.cells := by + induction items generalizing before ids with + | nil => + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [List.mapM_nil] using compiled) + exact ⟨rfl, rfl, rfl, rfl⟩ + | cons item items ih => + simp only [List.mapM_cons] at compiled + obtain ⟨id, middle, headRun, tailBind⟩ := bind_ok.mp compiled + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp tailBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨_, stateEq⟩ := fresh_eq headRun + subst middle + simpa only using ih tailRun + +theorem freshValue_preserves {decls : Declarations} {role : Role} {type : Ty} + {value : WireValue Witness} {before after : State F} + (compiled : freshValue decls role type before = .ok (value, after)) : + after.scopes = before.scopes ∧ after.equations = before.equations ∧ + after.calls = before.calls ∧ after.cells = before.cells := by + simp only [freshValue] at compiled + obtain ⟨layout, middle, expanded, tailBind⟩ := bind_ok.mp compiled + obtain ⟨_, stateEq⟩ := getLayout_eq expanded + subst middle + obtain ⟨words, last, wordsRun, finished⟩ := bind_ok.mp tailBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + exact freshList_preserves wordsRun + +theorem freshValue_extends {decls : Declarations} {role : Role} {type : Ty} + {value : WireValue Witness} {before after : State F} + (compiled : freshValue decls role type before = .ok (value, after)) : + before.Extends after := by + obtain ⟨scopes, equations, calls, cells⟩ := freshValue_preserves compiled + exact ⟨by simpa only [scopes] using (State.Extends.refl before).scopes, + by simp [equations], by simp [calls], by simp [cells]⟩ + +theorem freshValue_type {decls : Declarations} {role : Role} {type : Ty} + {value : WireValue Witness} {before after : State F} + (compiled : freshValue decls role type before = .ok (value, after)) : value.type = type := + (Circuit.Compiler.freshValue_spec (freshValue_reference compiled)).2.2.1 + +theorem freshValues_preserves {decls : Declarations} {role : Role} {types : List Ty} + {values : List (WireValue Witness)} {before after : State F} + (compiled : (types.mapM (freshValue decls role)) before = .ok (values, after)) : + after.scopes = before.scopes ∧ after.equations = before.equations ∧ + after.calls = before.calls ∧ after.cells = before.cells := by + induction types generalizing before values with + | nil => + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [List.mapM_nil] using compiled) + exact ⟨rfl, rfl, rfl, rfl⟩ + | cons type types ih => + simp only [List.mapM_cons] at compiled + obtain ⟨value, middle, headRun, restBind⟩ := bind_ok.mp compiled + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp restBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨hs, he, hc, hm⟩ := freshValue_preserves headRun + obtain ⟨ts, te, tc, tm⟩ := ih tailRun + exact ⟨ts.trans hs, te.trans he, tc.trans hc, tm.trans hm⟩ + +theorem destination_spec {decls : Declarations} {scope : ScopeId} {type : Ty} + {target : Option (WireValue Witness)} {value : WireValue Witness} {before after : State F} + (compiled : destination decls scope type target before = .ok (value, after)) : + before.Extends after ∧ after.scopes = before.scopes ∧ value.type = type := by + cases target with + | none => + exact ⟨freshValue_extends compiled, (freshValue_preserves compiled).1, freshValue_type compiled⟩ + | some target => + simp only [destination] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · rename_i same + obtain ⟨⟨⟩, middle, emptyRun, finished⟩ := bind_ok.mp compiled + obtain ⟨_, stateEq⟩ := pure_ok.mp emptyRun + subst middle + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + exact ⟨.refl _, rfl, Classical.not_not.mp same⟩ + +theorem lower_target {program : Program F} {function : String} {locals : Locals F} + {scope : ScopeId} {expr : Expr F} {target : WireValue Witness} {output : Symbolic F} + {before after : State F} + (compiled : lower program function locals scope expr (some target) before = .ok (output, after)) : + output = target.map Polynomial.var := by + unfold lower at compiled + obtain ⟨value, middle, _, restBind⟩ := bind_ok.mp compiled + obtain ⟨_, last, _, finished⟩ := bind_ok.mp restBind + exact (pure_ok.mp finished).1.symm + +theorem destination_extends {decls : Declarations} {scope : ScopeId} {type : Ty} + {target : Option (WireValue Witness)} {value : WireValue Witness} {before after : State F} + (compiled : destination decls scope type target before = .ok (value, after)) : + before.Extends after := (destination_spec compiled).1 + +theorem destination_valid {decls : Declarations} {scope : ScopeId} {type : Ty} + {target : Option (WireValue Witness)} {value : WireValue Witness} {before after : State F} + (compiled : destination decls scope type target before = .ok (value, after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {assignment : Witness → F} + (valid : after.Valid rom calls assignment) : before.Valid rom calls assignment := + valid.of_extends (destination_extends compiled) + +theorem asField_eq {value : Symbolic F} {polynomial : Polynomial F} {before after : State F} + (compiled : asField value before = .ok (polynomial, after)) : + value = .field polynomial ∧ before = after := by + cases value with + | mk type words => + cases type <;> cases words <;> simp [asField] at compiled + rename_i word rest + cases rest <;> simp [asField] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨rfl, rfl⟩ + +private theorem except_bind_ok {first : Except ε α} {next : α → Except ε β} {result : β} : + (first >>= next) = .ok result ↔ ∃ value, first = .ok value ∧ next value = .ok result := by + cases first <;> simp [bind, Except.bind] + +theorem function_stages {program : Program F} {config : Config} {fn : Function F} {chip : ScopedChip F} + {validateInputs : Bool} (compiled : function program config fn validateInputs = .ok chip) : + ∃ (inputs : List (WireValue Witness)) (output : WireValue Witness) + (s₁ s₂ s₃ : State F) (body : Symbolic F) (s₄ : State F), + ((fn.params.map Prod.snd).mapM (freshValue program.enums .input)) + ({config, scopes := #[⟨.const 1, []⟩]} : State F) = .ok (inputs, s₁) ∧ + freshValue program.enums .output fn.result s₁ = .ok (output, s₂) ∧ + validateParameters program.enums validateInputs inputs s₂ = .ok ((), s₃) ∧ + lower program fn.name ((fn.params.map Prod.fst).zip (inputs.map (WireValue.map Polynomial.var))) + 0 fn.body (some output) s₃ = .ok (body, s₄) ∧ + chip = ⟨fn.name, inputs, output, s₄.roles, s₄.aliases, s₄.scopes, + s₄.equations, s₄.calls, s₄.cells, s₄.choices⟩ := by + unfold function at compiled + obtain ⟨⟨⟨inputs, output⟩, state⟩, run, finished⟩ := except_bind_ok.mp compiled + simp only [pure, Except.pure, Except.ok.injEq] at finished + subst chip + obtain ⟨inputs, s₁, inputsRun, rest₁⟩ := bind_ok.mp run + obtain ⟨output, s₂, outputRun, rest₂⟩ := bind_ok.mp rest₁ + obtain ⟨⟨⟩, s₃, inputsValid, rest₃⟩ := bind_ok.mp rest₂ + obtain ⟨body, s₄, bodyRun, rest₄⟩ := bind_ok.mp rest₃ + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp rest₄ + exact ⟨inputs, output, s₁, s₂, s₃, body, s₄, + inputsRun, outputRun, inputsValid, bodyRun, rfl⟩ + +theorem freshValues_types {decls : Declarations} {role : Role} {types : List Ty} + {values : List (WireValue Witness)} {before after : State F} + (compiled : (types.mapM (freshValue decls role)) before = .ok (values, after)) : + values.map WireValue.type = types := by + induction types generalizing before values with + | nil => + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [List.mapM_nil] using compiled) + rfl + | cons type types ih => + simp only [List.mapM_cons] at compiled + obtain ⟨value, middle, headRun, restBind⟩ := bind_ok.mp compiled + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp restBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + simp only [List.map_cons, freshValue_type headRun, ih tailRun] + +theorem function_interface {program : Program F} {config : Config} {fn : Function F} {chip : ScopedChip F} + {validateInputs : Bool} (compiled : function program config fn validateInputs = .ok chip) : + chip.name = fn.name ∧ chip.inputs.map WireValue.type = fn.params.map Prod.snd ∧ chip.output.type = fn.result := by + obtain ⟨_, _, _, _, _, _, _, inputsRun, outputRun, _, _, rfl⟩ := function_stages compiled + exact ⟨rfl, freshValues_types inputsRun, freshValue_type outputRun⟩ + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/ConstantDivision.lean b/Aiur/Aiur/Optimized/ConstantDivision.lean new file mode 100644 index 000000000..22254da16 --- /dev/null +++ b/Aiur/Aiur/Optimized/ConstantDivision.lean @@ -0,0 +1,30 @@ +import Aiur.Optimized.PolynomialFacts + +namespace Aiur.Optimized.Polynomial + +variable {F : Type} [Field F] [DecidableEq F] + +/-- Invert only a nonzero constant in the chosen field. The caller has already +lowered both operands, so their calls and memory effects remain present. -/ +def constantInverse? (denominator : Polynomial F) : Option F := + match denominator.simplify with + | .const value => if value = 0 then none else some value⁻¹ + | _ => none + +theorem constantInverse?_sound {denominator : Polynomial F} {inverse : F} + (found : denominator.constantInverse? = some inverse) (assignment : Witness → F) : + denominator.denote assignment ≠ 0 ∧ inverse = (denominator.denote assignment)⁻¹ := by + unfold constantInverse? at found + cases simplified : denominator.simplify <;> simp only [simplified] at found + all_goals try contradiction + split at found + · contradiction + · rename_i nonzero + cases found + have equal := denote_simplify denominator assignment + rw [simplified] at equal + change _ = denominator.denote assignment at equal + rw [← equal] + exact ⟨nonzero, rfl⟩ + +end Aiur.Optimized.Polynomial diff --git a/Aiur/Aiur/Optimized/ConstraintElimination.lean b/Aiur/Aiur/Optimized/ConstraintElimination.lean new file mode 100644 index 000000000..80adc3623 --- /dev/null +++ b/Aiur/Aiur/Optimized/ConstraintElimination.lean @@ -0,0 +1,308 @@ +import Aiur.Optimized.AllocationCertificate +import Aiur.Optimized.ScopedPropagation +import Mathlib.Tactic.Ring + +/-! Remove constraints that only define a private auxiliary. Scoped propagation +first substitutes the equalities of the selected arm. A failed earlier pattern +then often has a nonzero constant coefficient on one of its private witnesses. +Solving for that witness makes the entire equation existentially redundant. +No pattern splitting or change to the control tree is involved. -/ + +namespace Aiur.Optimized.ConstraintElimination + +variable {F : Type} [Field F] [DecidableEq F] + +/-- Isolate a variable with a constant coefficient, allowing arbitrary products +in the remainder. Unlike affine propagation, the remainder need not be affine. -/ +def isolate (id : Witness) : Polynomial F → Option (F × Polynomial F) + | .const c => some (0, .const c) + | .var other => if other = id then some (1, .const 0) else some (0, .var other) + | .add left right => do + let (a, p) ← isolate id left + let (b, q) ← isolate id right + return (a + b, .add p q) + | .sub left right => do + let (a, p) ← isolate id left + let (b, q) ← isolate id right + return (a - b, .sub p q) + | .mul left right => do + let (a, p) ← isolate id left + let (b, q) ← isolate id right + if a = 0 then + if b = 0 then return (0, .mul p q) + else match p.simplify with + | .const c => return (c * b, .mul p q) + | _ => none + else if b = 0 then + match q.simplify with + | .const c => return (a * c, .mul p q) + | _ => none + else none + +theorem isolate_denote {id : Witness} {expr : Polynomial F} {coefficient : F} + {rest : Polynomial F} (found : isolate id expr = some (coefficient, rest)) + (assignment : Witness → F) : + expr.denote assignment = coefficient * assignment id + rest.denote assignment := by + induction expr generalizing coefficient rest with + | const c => cases found; simp [Scalar.Circuit.ArithExpr.denote] + | var other => + simp only [isolate] at found + split at found <;> cases found <;> simp_all [Scalar.Circuit.ArithExpr.denote] + | add left right ihLeft ihRight | sub left right ihLeft ihRight => + simp only [isolate] at found + cases hl : isolate id left with + | none => simp [hl] at found + | some l => + cases hr : isolate id right with + | none => simp [hr] at found + | some r => + simp [hl, hr] at found + obtain ⟨rfl, rfl⟩ := found + simp only [Scalar.Circuit.ArithExpr.denote, ihLeft hl, ihRight hr] + ring + | mul left right ihLeft ihRight => + simp only [isolate] at found + cases hl : isolate id left with + | none => simp [hl] at found + | some l => + cases hr : isolate id right with + | none => simp [hr] at found + | some r => + rcases l with ⟨a, p⟩ + rcases r with ⟨b, q⟩ + simp only [hl, hr, bind, Option.bind] at found + split at found + · rename_i ha + split at found + · rename_i hb + cases found + simp [Scalar.Circuit.ArithExpr.denote, ihLeft hl, ihRight hr, ha, hb] + · split at found <;> try contradiction + rename_i c hp + cases found + have constant := Polynomial.denote_simplify p assignment + rw [hp] at constant + simp only [Scalar.Circuit.ArithExpr.denote, ihLeft hl, ihRight hr, ha] + change c = Scalar.Circuit.ArithExpr.denote assignment p at constant + simp only [Circuit.ArithExpr.denote] at * + rw [← constant] + ring + · split at found + · rename_i hb + split at found <;> try contradiction + rename_i c hq + cases found + have constant := Polynomial.denote_simplify q assignment + rw [hq] at constant + simp only [Scalar.Circuit.ArithExpr.denote, ihLeft hl, ihRight hr, hb] + change c = Scalar.Circuit.ArithExpr.denote assignment q at constant + simp only [Circuit.ArithExpr.denote] at * + rw [← constant] + ring + · contradiction + +def erase (chip : ScopedChip F) (equation : Equation F) : ScopedChip F := + { chip with equations := chip.equations.filter fun other => decide (other ≠ equation) } + +def usedVariables (chip : ScopedChip F) : List Witness := + (Allocation.occurrences chip).map Prod.fst + +theorem relevant_mem {chip : ScopedChip F} {assignment : Witness → F} {id : Witness} + (relevant : chip.Relevant assignment id) : id ∈ usedVariables chip := by + obtain ⟨scope, member, _⟩ := Allocation.relevant_site relevant + exact List.mem_map.mpr ⟨(id, scope), member, rfl⟩ + +structure Proposal (F : Type) where + equation : Equation F + id : Witness + coefficient : F + rest : Polynomial F + +/-- Privacy is checked against every remaining equation, activation, interface, +call and memory lookup. No witness that affects an observable claim can escape. -/ +def Proposal.Certificate (chip : ScopedChip F) (p : Proposal F) : Prop := + chip.roles[p.id]? = some (.auxiliary p.equation.scope) ∧ + p.id ∉ usedVariables (erase chip p.equation) ∧ + p.id ∉ p.rest.vars ∧ + isolate p.id p.equation.polynomial = some (p.coefficient, p.rest) ∧ + p.coefficient ≠ 0 + +instance (chip : ScopedChip F) (p : Proposal F) : Decidable (p.Certificate chip) := by + unfold Proposal.Certificate + infer_instance + +theorem Proposal.equivalent {chip : ScopedChip F} {p : Proposal F} + (checked : p.Certificate chip) : chip.Equivalent (erase chip p.equation) := by + constructor + · intro rom a valid + refine ⟨a, ⟨?_, valid.2⟩, rfl, rfl⟩ + intro eq member + have present : eq ∈ chip.equations.toList ∧ eq ≠ p.equation := by + simpa [erase] using member + exact valid.1 eq present.1 + · intro rom a valid + let target := erase chip p.equation + let b := Function.update a p.id (-p.rest.denote a / p.coefficient) + have agree : ∀ id, target.Relevant a id → a id = b id := by + intro id relevant + have different : id ≠ p.id := by + rintro rfl + exact checked.2.1 (relevant_mem relevant) + simp [b, Function.update_of_ne different] + have kept : target.ValidAssignment rom b := target.validAssignment_agree agree valid + have rest : p.rest.denote b = p.rest.denote a := by + apply Polynomial.denote_congr + intro id member + have different : id ≠ p.id := by rintro rfl; exact checked.2.2.1 member + simp [b, Function.update_of_ne different] + have zero : p.equation.polynomial.denote b = 0 := by + rw [isolate_denote checked.2.2.2.1, rest] + simp [b, div_eq_mul_inv, mul_comm, checked.2.2.2.2] + refine ⟨b, ⟨?_, kept.2⟩, (target.conclusion_agree agree).symm, + (target.premises_agree agree).symm⟩ + intro eq member + by_cases same : eq = p.equation + · subst eq + rw [zero, mul_zero] + · apply kept.1 eq + simpa [target, erase] using And.intro member same + +/-- Candidate search is untrusted. Occurrence counts only avoid proposing +variables that the certificate would reject. Count once per equation. -/ +def proposals (chip : ScopedChip F) : List (Proposal F) := Id.run do + let protectedIds := (usedVariables { chip with equations := #[] }).foldl + (fun set id => set.insert id) (∅ : Std.HashSet Witness) + let mut counts : Std.HashMap Witness Nat := ∅ + for eq in chip.equations do + for id in eq.polynomial.vars.eraseDups do + counts := counts.insert id (counts.getD id 0 + 1) + let mut result := [] + for eq in chip.equations do + for id in eq.polynomial.vars.eraseDups do + if counts.getD id 0 != 1 then continue + if protectedIds.contains id then continue + if chip.roles[id]? != some (.auxiliary eq.scope) then continue + if let some (coefficient, rest) := isolate id eq.polynomial then + if coefficient != 0 then + result := ⟨eq, id, coefficient, rest⟩ :: result + break + return result.reverse + +def applyProposals (source : ScopedChip F) : List (Proposal F) → + Degree.Checked source → Degree.Checked source + | [], current => current + | p :: ps, current => + if checked : p.Certificate current.chip then + applyProposals source ps { + chip := erase current.chip p.equation + equivalent := current.equivalent.trans (p.equivalent checked) + name_eq := current.name_eq + inputs_eq := current.inputs_eq + output_eq := current.output_eq } + else applyProposals source ps current + +def replacement (id : Witness) (value : Polynomial F) (other : Witness) : Polynomial F := + if other = id then value else .var other + +structure Reuse (F : Type) where + equation : Equation F + id : Witness + value : Polynomial F + retained : Equation F + +/-- A repeated residual check may reuse a witness from an equation in exactly +the same scope. In particular, neither an inactive sibling nor the equation +being erased can justify the replacement. -/ +def Reuse.Certificate (chip : ScopedChip F) (p : Reuse F) : Prop := + chip.roles[p.id]? = some (.auxiliary p.equation.scope) ∧ + p.id ∉ usedVariables (erase chip p.equation) ∧ + p.id ∉ p.value.vars ∧ + p.retained ∈ (erase chip p.equation).equations.toList ∧ + p.equation.scope = p.retained.scope ∧ + Polynomial.Identical (p.equation.polynomial.subst (replacement p.id p.value)) + p.retained.polynomial + +instance (chip : ScopedChip F) (p : Reuse F) : Decidable (p.Certificate chip) := by + letI : BEq (Equation F) := instBEqOfDecidableEq + unfold Reuse.Certificate + infer_instance + +theorem Reuse.equivalent {chip : ScopedChip F} {p : Reuse F} + (checked : p.Certificate chip) : chip.Equivalent (erase chip p.equation) := by + constructor + · intro rom a valid + refine ⟨a, ⟨?_, valid.2⟩, rfl, rfl⟩ + intro eq member + have present : eq ∈ chip.equations.toList ∧ eq ≠ p.equation := by + simpa [erase] using member + exact valid.1 eq present.1 + · intro rom a valid + let target := erase chip p.equation + let b := Function.update a p.id (p.value.denote a) + have agree : ∀ id, target.Relevant a id → a id = b id := by + intro id relevant + have different : id ≠ p.id := by + rintro rfl + exact checked.2.1 (relevant_mem relevant) + simp [b, Function.update_of_ne different] + have kept : target.ValidAssignment rom b := target.validAssignment_agree agree valid + have rewritten : p.equation.polynomial.denote b = p.retained.polynomial.denote a := by + rw [← (Polynomial.alias_extension p.value p.equation.polynomial p.id checked.2.2.1 a).2] + exact checked.2.2.2.2.2.denote a + refine ⟨b, ⟨?_, kept.2⟩, (target.conclusion_agree agree).symm, + (target.premises_agree agree).symm⟩ + intro eq member + by_cases same : eq = p.equation + · subst eq + have activation := target.activation_agree agree p.equation.scope + change (chip.activation p.equation.scope).denote a = + (chip.activation p.equation.scope).denote b at activation + rw [← activation, rewritten, checked.2.2.2.2.1] + exact valid.1 p.retained checked.2.2.2.1 + · apply kept.1 eq + simpa [target, erase] using And.intro member same + +/-- Recognize identical residual equations modulo one private auxiliary name. +Templates only guide search: the certificate checks the actual substitution. -/ +def reuseProposals (chip : ScopedChip F) : List (Reuse F) := Id.run do + let protectedIds := (usedVariables { chip with equations := #[] }).foldl + (fun set id => set.insert id) (∅ : Std.HashSet Witness) + let mut counts : Std.HashMap Witness Nat := ∅ + for eq in chip.equations do + for id in eq.polynomial.vars.eraseDups do + counts := counts.insert id (counts.getD id 0 + 1) + let mut templates : Std.HashMap Nat (List (Polynomial F × Equation F × Witness)) := ∅ + let mut result := [] + for eq in chip.equations do + for id in eq.polynomial.vars.eraseDups do + if counts.getD id 0 != 1 || protectedIds.contains id then continue + if chip.roles[id]? != some (.auxiliary eq.scope) then continue + let template := (eq.polynomial.subst (replacement id (.var chip.roles.size))).normalForm + let key := EquationIndex.key (eq.scope, template) + let bucket := templates.getD key [] + if let some (_, retained, witness) := bucket.find? fun (other, retained, _) => + retained.scope == eq.scope && other == template then + result := ⟨eq, id, .var witness, retained⟩ :: result + else + templates := templates.insert key ((template, eq, id) :: bucket) + break + return result.reverse + +def applyReuse (source : ScopedChip F) : List (Reuse F) → + Degree.Checked source → Degree.Checked source + | [], current => current + | p :: ps, current => + if checked : p.Certificate current.chip then + applyReuse source ps { + chip := erase current.chip p.equation + equivalent := current.equivalent.trans (p.equivalent checked) + name_eq := current.name_eq + inputs_eq := current.inputs_eq + output_eq := current.output_eq } + else applyReuse source ps current + +def run (chip : ScopedChip F) : Degree.Checked chip := + let privateEquations := applyProposals chip (proposals chip) (ScopedPropagation.identity chip) + applyReuse chip (reuseProposals privateEquations.chip) privateEquations + +end Aiur.Optimized.ConstraintElimination diff --git a/Aiur/Aiur/Optimized/ControlCertificate.lean b/Aiur/Aiur/Optimized/ControlCertificate.lean new file mode 100644 index 000000000..dd0a569ae --- /dev/null +++ b/Aiur/Aiur/Optimized/ControlCertificate.lean @@ -0,0 +1,204 @@ +import Aiur.Optimized.AliasCertificate +import Aiur.Optimized.BranchFacts +import Aiur.Optimized.EquationIndex +import Mathlib.Algebra.BigOperators.Fin + +namespace Aiur.Optimized.Control + +variable {F : Type} [Field F] [DecidableEq F] + +/-- A polynomial is zero either by simplification or by an actual global +equation. The choice metadata by itself imposes no semantic restrictions. -/ +def ZeroEquation (chip : ScopedChip F) (polynomial : Polynomial F) : Prop := + Polynomial.Identical polynomial (.const 0) ∨ + ∃ equation ∈ chip.equations.toList, equation.scope = 0 ∧ + Polynomial.Identical equation.polynomial polynomial + +instance (chip : ScopedChip F) (polynomial : Polynomial F) : Decidable (ZeroEquation chip polynomial) := by + unfold ZeroEquation + infer_instance + +def Choice.total (chip : ScopedChip F) (choice : Aiur.Optimized.Choice) : Polynomial F := + choice.children.foldl (fun sum child => .add sum (chip.activation child)) (.const 0) + +def Choice.Checked (chip : ScopedChip F) (choice : Aiur.Optimized.Choice) : Prop := + ZeroEquation chip (.sub (Choice.total chip choice) (chip.activation choice.parent)) ∧ + ∀ i j : Fin choice.children.length, j < i → + ZeroEquation chip (.mul (chip.activation choice.children[i]) (chip.activation choice.children[j])) + +instance (chip : ScopedChip F) (choice : Aiur.Optimized.Choice) : Decidable (Choice.Checked chip choice) := by + unfold Choice.Checked + infer_instance + +def ParentChecked (chip : ScopedChip F) (id : ScopeId) : Prop := + match chip.scopes[id]? with + | none => False + | some scope => + match scope.path.getLast? with + | none => True + | some (choiceId, arm) => + match chip.choices[choiceId]? with + | none => False + | some choice => + match chip.scopes[choice.parent]? with + | none => False + | some parent => choice.children[arm]? = some id ∧ choice.parent < id ∧ + scope.path = parent.path ++ [(choiceId, arm)] + +instance (chip : ScopedChip F) (id : ScopeId) : Decidable (ParentChecked chip id) := by + unfold ParentChecked + split <;> (try infer_instance) + split <;> (try infer_instance) + split <;> (try infer_instance) + split <;> infer_instance + +def Certificate (chip : ScopedChip F) : Prop := + Polynomial.Identical (chip.activation 0) (.const 1) ∧ + (∀ choice ∈ chip.choices.toList, Choice.Checked chip choice) ∧ + ∀ id ∈ List.range chip.scopes.size, ParentChecked chip id + +open EquationIndex (expressionKey) + +def globalNormalForms (chip : ScopedChip F) : List (Polynomial F) := + (chip.equations.toList.filter (fun eq => eq.scope == 0)).map + (fun eq => eq.polynomial.normalForm) + +theorem zeroEquation_iff_indexed (chip : ScopedChip F) (polynomial : Polynomial F) : + ZeroEquation chip polynomial ↔ + polynomial.normalForm = (.const 0 : Polynomial F) ∨ + polynomial.normalForm ∈ + (Index.build expressionKey (globalNormalForms chip)).getD + (expressionKey polynomial.normalForm) [] := by + rw [Index.mem_build] + simp only [ZeroEquation, Polynomial.Identical, globalNormalForms, + Polynomial.normalForm, Polynomial.simplify, List.mem_map, List.mem_filter, beq_iff_eq] + aesop + +set_option synthInstance.maxSize 4096 in +/-- Normalize the actual global equations once, then use indexed membership +to check coverage and exclusion. The proposition being decided is unchanged. -/ +instance (chip : ScopedChip F) : Decidable (Certificate chip) := by + letI : BEq (Polynomial F) := instBEqOfDecidableEq + let index := Index.build expressionKey (globalNormalForms chip) + letI (polynomial : Polynomial F) : Decidable (ZeroEquation chip polynomial) := + decidable_of_iff + (polynomial.normalForm = (.const 0 : Polynomial F) ∨ + polynomial.normalForm ∈ index.getD (expressionKey polynomial.normalForm) []) + (zeroEquation_iff_indexed chip polynomial).symm + unfold Certificate Choice.Checked + infer_instance + +def ActivePath (chip : ScopedChip F) (assignment : Witness → F) (path : Path) : Prop := + ∀ tag ∈ path, ∃ choice, chip.choices[tag.1]? = some choice ∧ + ∃ child, choice.children[tag.2]? = some child ∧ (chip.activation child).denote assignment ≠ 0 + +namespace Certificate + +variable {chip : ScopedChip F} {rom : WireROM F} {assignment : Witness → F} + +theorem zero (checked : Certificate chip) (valid : chip.ValidAssignment rom assignment) + {polynomial : Polynomial F} (equation : ZeroEquation chip polynomial) : polynomial.denote assignment = 0 := by + rcases equation with zero | ⟨equation, member, scope, same⟩ + · exact zero.denote assignment + · have satisfied := valid.1 equation member + rw [scope, checked.1.denote, same.denote] at satisfied + simpa only [Scalar.Circuit.ArithExpr.denote, one_mul] using satisfied + +theorem exclusive (checked : Certificate chip) (valid : chip.ValidAssignment rom assignment) + {choice : Aiur.Optimized.Choice} (member : choice ∈ chip.choices.toList) + (i j : Fin choice.children.length) (different : i ≠ j) : + (chip.activation choice.children[i]).denote assignment * + (chip.activation choice.children[j]).denote assignment = 0 := by + rcases lt_or_gt_of_ne different with less | greater + · simpa only [Scalar.Circuit.ArithExpr.denote, mul_comm] using + checked.zero valid ((checked.2.1 choice member).2 j i less) + · exact checked.zero valid ((checked.2.1 choice member).2 i j greater) + +private theorem total_denote (choice : Aiur.Optimized.Choice) : + (Choice.total chip choice).denote assignment = + ∑ i : Fin choice.children.length, (chip.activation choice.children[i]).denote assignment := by + have fold (children : List ScopeId) (start : Polynomial F) : + (children.foldl (fun sum child => Polynomial.add sum (chip.activation child)) start).denote assignment = + start.denote assignment + (children.map (fun child => (chip.activation child).denote assignment)).sum := by + induction children generalizing start with + | nil => simp + | cons child children ih => simp [ih, Scalar.Circuit.ArithExpr.denote, add_assoc] + unfold Choice.total + change Scalar.Circuit.ArithExpr.denote assignment _ = _ + rw [fold] + simp only [Scalar.Circuit.ArithExpr.denote, zero_add] + rw [← List.ofFn_getElem_eq_map] + exact Fin.sum_ofFn _ + +theorem parent_active (checked : Certificate chip) (valid : chip.ValidAssignment rom assignment) + {choice : Aiur.Optimized.Choice} (member : choice ∈ chip.choices.toList) + (i : Fin choice.children.length) (active : (chip.activation choice.children[i]).denote assignment ≠ 0) : + (chip.activation choice.parent).denote assignment ≠ 0 := by + have coverage := checked.zero valid (checked.2.1 choice member).1 + change (Choice.total chip choice).denote assignment - (chip.activation choice.parent).denote assignment = 0 at coverage + have sum := sub_eq_zero.mp coverage + rw [total_denote] at sum + rw [← sum, exclusive_sum _ (checked.exclusive valid member) active] + exact active + +/-- Active descendants force every branch on their recorded path to be active. +This follows from checked coverage/exclusion equations, not from path labels. -/ +theorem activePath (checked : Certificate chip) (valid : chip.ValidAssignment rom assignment) + {id : ScopeId} {scope : Scope F} (found : chip.scopes[id]? = some scope) + (active : (chip.activation id).denote assignment ≠ 0) : ActivePath chip assignment scope.path := by + have prove (id : ScopeId) : ∀ scope, chip.scopes[id]? = some scope → + (chip.activation id).denote assignment ≠ 0 → ActivePath chip assignment scope.path := by + induction id using Nat.strong_induction_on with + | h id ih => + intro scope found active + have step := checked.2.2 id (List.mem_range.mpr (Array.getElem?_eq_some_iff.mp found).1) + unfold ParentChecked at step + simp only [found] at step + cases last : scope.path.getLast? with + | none => simp [ActivePath, List.getLast?_eq_none_iff.mp last] + | some tag => + simp only [last] at step + cases choiceFound : chip.choices[tag.1]? with + | none => simp [choiceFound] at step + | some choice => + simp only [choiceFound] at step + cases parentFound : chip.scopes[choice.parent]? with + | none => simp [parentFound] at step + | some parent => + simp only [parentFound] at step + obtain ⟨child, earlier, path⟩ := step + obtain ⟨bounded, childEq⟩ := List.getElem?_eq_some_iff.mp child + have parentActive := checked.parent_active valid + (by simpa using Array.mem_of_getElem? choiceFound) ⟨tag.2, bounded⟩ (by simpa [childEq] using active) + have ancestor := ih choice.parent earlier parent parentFound parentActive + intro item member + rw [path] at member + rcases List.mem_append.mp member with previous | lastItem + · exact ancestor item previous + · have same := List.mem_singleton.mp lastItem + subst item + exact ⟨choice, choiceFound, id, child, active⟩ + exact prove id scope found active + +theorem paths_exclusive (checked : Certificate chip) (valid : chip.ValidAssignment rom assignment) + {left right : Path} (different : left.exclusive right = true) + (leftActive : ActivePath chip assignment left) (rightActive : ActivePath chip assignment right) : False := by + obtain ⟨⟨choiceId, arm⟩, leftMem, rest⟩ := List.any_eq_true.mp different + obtain ⟨⟨other, branch⟩, rightMem, condition⟩ := List.any_eq_true.mp rest + obtain ⟨same, distinct⟩ := Bool.and_eq_true_iff.mp condition + have same : choiceId = other := beq_iff_eq.mp same + have distinct : arm ≠ branch := by simpa using distinct + subst other + obtain ⟨choice, found, a, aFound, aActive⟩ := leftActive _ leftMem + obtain ⟨otherChoice, otherFound, b, bFound, bActive⟩ := rightActive _ rightMem + have equal : choice = otherChoice := Option.some.inj (found.symm.trans otherFound) + subst otherChoice + obtain ⟨aBound, aEq⟩ := List.getElem?_eq_some_iff.mp aFound + obtain ⟨bBound, bEq⟩ := List.getElem?_eq_some_iff.mp bFound + have zero := checked.exclusive valid (by simpa using Array.mem_of_getElem? found) + ⟨arm, aBound⟩ ⟨branch, bBound⟩ (by simpa using distinct) + simp only [Fin.getElem_fin, aEq, bEq] at zero + exact (mul_ne_zero aActive bActive) zero + +end Certificate +end Aiur.Optimized.Control diff --git a/Aiur/Aiur/Optimized/Correctness.lean b/Aiur/Aiur/Optimized/Correctness.lean new file mode 100644 index 000000000..8f8de0bc1 --- /dev/null +++ b/Aiur/Aiur/Optimized/Correctness.lean @@ -0,0 +1,46 @@ +import Aiur.Optimized.Program +import Aiur.Optimized.LayoutWitness +import Aiur.Optimized.BranchFacts +import Aiur.Optimized.PrimitiveCorrectness +import Aiur.Optimized.ReferenceState + +namespace Aiur.Optimized + +variable {F : Type} [Field F] [DecidableEq F] + +/-- The implemented deduplication pass preserves each public entry claim. +This theorem concerns the optimized system before and after deduplication; +`Equivalence.lean` composes it with the earlier passes and reference compiler. -/ +theorem Artifact.dedup_derives_iff (compiled : Artifact F) {rom : WireROM F} {root : Circuit.Message F} + (entry : root.channel ∈ compiled.entries) : + Circuit.Derives compiled.unmerged rom root ↔ Circuit.Derives compiled.system rom root := by + simpa only [compiled.deduplication.entry_fixed entry] using + compiled.deduplication.derives_iff (rom := rom) (root := root) + +theorem Artifact.dedup_memoDerives_iff (compiled : Artifact F) {rom : WireROM F} {root : Circuit.Message F} + (entry : root.channel ∈ compiled.entries) : + Circuit.MemoDerives compiled.unmerged rom root ↔ Circuit.MemoDerives compiled.system rom root := by + simpa only [compiled.deduplication.entry_fixed entry] using + compiled.deduplication.memoDerives_iff (rom := rom) (root := root) + +theorem Artifact.dedup_acyclic_iff (compiled : Artifact F) {rom : WireROM F} {root : Circuit.Message F} + (entry : root.channel ∈ compiled.entries) : + (∃ graph : Circuit.MemoDerivation compiled.unmerged rom root, graph.Acyclic) ↔ + (∃ graph : Circuit.MemoDerivation compiled.system rom root, graph.Acyclic) := by + have translated := compiled.deduplication.acyclic_iff (rom := rom) (root := root) + rw [compiled.deduplication.entry_fixed entry] at translated + exact translated + +theorem Artifact.dedup_check_iff (compiled : Artifact F) {rom : WireROM F} {root : Circuit.Message F} + (entry : root.channel ∈ compiled.entries) : + (∃ rows, compiled.unmerged.check rom root rows = .ok ()) ↔ + (∃ rows, compiled.system.check rom root rows = .ok ()) := + compiled.deduplication.check_entry_iff entry + +theorem Artifact.dedup_checkMemo_iff (compiled : Artifact F) {rom : WireROM F} {root : Circuit.Message F} + (entry : root.channel ∈ compiled.entries) : + (∃ rows, compiled.unmerged.checkMemo rom root rows = .ok ()) ↔ + (∃ rows, compiled.system.checkMemo rom root rows = .ok ()) := + compiled.deduplication.checkMemo_entry_iff entry + +end Aiur.Optimized diff --git a/Aiur/Aiur/Optimized/Dedup.lean b/Aiur/Aiur/Optimized/Dedup.lean new file mode 100644 index 000000000..8f90aa5da --- /dev/null +++ b/Aiur/Aiur/Optimized/Dedup.lean @@ -0,0 +1,90 @@ +import Aiur.Optimized.DedupCertificate + +namespace Aiur.Optimized +namespace Dedup + +structure Result (F : Type) where + system : Circuit.System F + representatives : List (String × String) + classes : Array Nat + deriving Repr, BEq + +/-- The partitioning heuristic produces data; certification gives the semantic +guarantee, including recursive rules and fixed public entrypoints. -/ +structure CheckedResult [Field F] [DecidableEq F] (source : Circuit.System F) (entries : List String) + extends Result F where + certificate : Certificate source system representatives entries + +def certify [Field F] [DecidableEq F] (source : Circuit.System F) (entries : List String) + (result : Result F) : Except String (CheckedResult source entries) := + if valid : Certificate source result.system result.representatives entries then + .ok { toResult := result, certificate := valid } + else .error "chip deduplication certificate failed" + +/-- Call slots keep their order, payloads, results, and enables. Only the +destination names of function calls are replaced by candidate class indices. -/ +def signature (system : Circuit.System F) (classes : Array Nat) + (chip : Circuit.Chip F) : Circuit.Chip F := + { chip with + name := "" + sends := chip.sends.map fun send => + let index := system.chips.findIdx (·.name == send.channel) + let destination := if index < system.chips.length then + "function:" ++ toString (classes[index]?.getD index) + else "map:" ++ send.channel + { send with channel := destination } + } + +def refine [DecidableEq F] (system : Circuit.System F) (entries : List String) + (classes : Array Nat) : Array Nat := Id.run do + let chips := system.chips.toArray + let signatures := chips.map (signature system classes) + let mut result := #[] + for i in List.range chips.size do + let previous := (List.range i).find? fun j => + classes[i]? == classes[j]? && signatures[i]? == signatures[j]? && + !(entries.contains (chips[i]?.map Circuit.Chip.name |>.getD "")) && + !(entries.contains (chips[j]?.map Circuit.Chip.name |>.getD "")) + result := result.push (match previous with + | none => i + | some j => result[j]?.getD j) + return result + +/-- Finite partition refinement compares regular unfoldings, including mutual +recursion. Each strict iteration splits at least one candidate class. -/ +def partition [DecidableEq F] (system : Circuit.System F) (entries : List String) : + Nat → Array Nat → Except String (Array Nat) + | 0, _ => .error "chip partition refinement failed to stabilize" + | fuel + 1, classes => + let next := refine system entries classes + if next == classes then .ok classes else partition system entries fuel next + +def identity (system : Circuit.System F) : Result F := + ⟨system, system.chips.map (fun chip => (chip.name, chip.name)), + (List.range system.chips.length).toArray⟩ + +def compute [DecidableEq F] (system : Circuit.System F) (entries : List String) : Except String (Result F) := do + let count := system.chips.length + let classes ← partition system entries (count + 1) (Array.replicate count 0) + unless classes.size == count && refine system entries classes == classes do + throw "invalid chip partition" + let mut representatives := [] + for (chip, index) in system.chips.zipIdx do + let some representative := classes[index]? | throw "missing representative" + let some target := system.chips[representative]? | throw "invalid representative" + unless classes[representative]? == some representative do throw "non-idempotent representative" + if entries.contains chip.name && chip.name != target.name then throw "entrypoint was merged" + representatives := representatives ++ [(chip.name, target.name)] + let rename := fun name => ((representatives.find? (·.1 == name)).map Prod.snd).getD name + let chips := system.chips.zipIdx.filterMap fun (chip, index) => + if classes[index]? == some index then + some { chip with sends := chip.sends.map fun send => { send with channel := rename send.channel } } + else none + return ⟨{ system with chips }, representatives, classes⟩ + +def run [Field F] [DecidableEq F] (system : Circuit.System F) (entries : List String) : + Except String (CheckedResult system entries) := do + certify system entries (← compute system entries) + +end Dedup +end Aiur.Optimized diff --git a/Aiur/Aiur/Optimized/DedupCertificate.lean b/Aiur/Aiur/Optimized/DedupCertificate.lean new file mode 100644 index 000000000..cc767888a --- /dev/null +++ b/Aiur/Aiur/Optimized/DedupCertificate.lean @@ -0,0 +1,302 @@ +import Aiur.Optimized.Basic +import Aiur.Circuit.RuleTranslation + +deriving instance DecidableEq for Aiur.Circuit.Send +deriving instance DecidableEq for Aiur.Circuit.MemoryLookup +deriving instance DecidableEq for Aiur.Circuit.Chip + +namespace Aiur.Circuit + +def Chip.rename (rename : String → String) (chip : Chip F) : Chip F := + { chip with + name := rename chip.name + sends := chip.sends.map fun send => { send with channel := rename send.channel } } + +variable {F : Type} [Field F] [DecidableEq F] + +omit [Field F] [DecidableEq F] in +@[simp] theorem Chip.rename_wellFormed (rename : String → String) (chip : Chip F) : + (chip.rename rename).wellFormed = chip.wellFormed := by + simp [Chip.rename, Chip.wellFormed, List.all_map, Function.comp_def] + rfl + +omit [DecidableEq F] in +@[simp] theorem Chip.rename_validRow (rename : String → String) (chip : Chip F) + (rom : WireROM F) (row : Row F) : + (chip.rename rename).ValidRow rom row ↔ chip.ValidRow rom row := by + unfold Chip.ValidRow + rw [Chip.rename_wellFormed] + rfl + +omit [DecidableEq F] in +@[simp] theorem Chip.rename_receive (rename : String → String) (chip : Chip F) (row : Row F) : + (chip.rename rename).receive row = (chip.receive row).rename rename := rfl + +@[simp] theorem Chip.rename_premises (rename : String → String) (chip : Chip F) (row : Row F) : + (chip.rename rename).premises row = (chip.premises row).map (Message.rename rename) := by + simp only [Chip.rename, Chip.premises, List.filterMap_map, List.map_filterMap, Function.comp_def] + congr 1 + funext send + split <;> rfl + +omit [DecidableEq F] in +@[simp] theorem Chip.validRow_relabel (chip : Chip F) (rom : WireROM F) (row : Row F) (name : String) : + chip.ValidRow rom { row with chip := name } ↔ chip.ValidRow rom row := Iff.rfl + +omit [DecidableEq F] in +@[simp] theorem Chip.receive_relabel (chip : Chip F) (row : Row F) (name : String) : + chip.receive { row with chip := name } = chip.receive row := rfl + +@[simp] theorem Chip.premises_relabel (chip : Chip F) (row : Row F) (name : String) : + chip.premises { row with chip := name } = chip.premises row := rfl + +omit [Field F] [DecidableEq F] in +theorem System.findChip_name {system : System F} {name : String} {chip : Chip F} + (found : system.findChip? name = some chip) : chip.name = name := by + have h := List.find?_some (p := fun c : Chip F => c.name == name) found + exact beq_iff_eq.mp h + +end Aiur.Circuit + +namespace Aiur.Optimized.Dedup + +open Circuit +variable {F : Type} [Field F] [DecidableEq F] + +def rename (representatives : List (String × String)) (name : String) : String := + ((representatives.find? (·.1 == name)).map Prod.snd).getD name + +/-- A finite, decidable certificate, checked after partition refinement. +No claim about refinement heuristics is trusted by the semantic proof. -/ +def Certificate (source target : Circuit.System F) (representatives : List (String × String)) + (entries : List String) : Prop := + (∀ pair ∈ representatives, (source.findChip? pair.1).isSome = true ∧ + (source.findChip? pair.2).isSome = true) ∧ + (∀ chip ∈ source.chips, target.findChip? (rename representatives chip.name) = + some (chip.rename (rename representatives))) ∧ + (∀ chip ∈ target.chips, (source.findChip? chip.name).isSome = true) ∧ + target.mapClaims = source.mapClaims ∧ + (∀ claim ∈ source.mapClaims, source.findChip? claim.channel = none) ∧ + target.enums = source.enums ∧ + checkChips [] source.chips = .ok () ∧ checkChips [] target.chips = .ok () ∧ + (∀ entry ∈ entries, rename representatives entry = entry) + +private theorem isEqv_decide_iff [DecidableEq α] (left right : List α) : + left.isEqv right (fun a b => decide (a = b)) = true ↔ left = right := by + induction left generalizing right with + | nil => cases right <;> simp [List.isEqv] + | cons a left ih => cases right <;> simp [List.isEqv, ih] + +/-- A full byte table supplies hundreds of thousands of map claims. Use the +tail-recursive comparison for that list, with exactly the same equality test. -/ +instance (source target : Circuit.System F) (representatives : List (String × String)) (entries : List String) : + Decidable (Certificate source target representatives entries) := by + letI : Decidable (target.mapClaims = source.mapClaims) := + decidable_of_iff (target.mapClaims.isEqv source.mapClaims (fun a b => decide (a = b)) = true) + (isEqv_decide_iff _ _) + unfold Certificate + infer_instance + +theorem rename_eq_self {pairs : List (String × String)} {name : String} + (absent : ∀ pair ∈ pairs, pair.1 ≠ name) : rename pairs name = name := by + have h : pairs.find? (·.1 == name) = none := List.find?_eq_none.mpr (by simpa using absent) + simp [rename, h] + +theorem rename_preimage {pairs : List (String × String)} {name result : String} + (same : rename pairs name = result) : name ∈ pairs.map Prod.fst ++ [result] := by + by_cases h : name ∈ pairs.map Prod.fst + · simp [h] + · have unchanged : rename pairs name = name := rename_eq_self (by + intro pair member equal + exact h (List.mem_map.mpr ⟨pair, member, equal⟩)) + simp [← same, unchanged] + +omit [Field F] [DecidableEq F] in +theorem finite_fibers (pairs : List (String × String)) (message : Message F) : + Finite {claim : Message F // claim.rename (rename pairs) = message} := by + let candidates := (pairs.map Prod.fst ++ [message.channel]).map fun name => + ({ message with channel := name } : Message F) + have bounded : {claim : Message F | claim.rename (rename pairs) = message} ⊆ {claim | claim ∈ candidates} := by + intro claim same + have name := congrArg Message.channel same + have args := congrArg Message.args same + have result := congrArg Message.result same + apply List.mem_map.mpr + refine ⟨claim.channel, rename_preimage name, ?_⟩ + cases claim + cases message + simp_all [Message.rename] + exact (candidates.finite_toSet.subset bounded).to_subtype + +namespace Certificate + +variable {source target : Circuit.System F} {pairs : List (String × String)} {entries : List String} + +omit [DecidableEq F] in +theorem outside (checked : Certificate source target pairs entries) {name : String} + (absent : source.findChip? name = none) : rename pairs name = name := + rename_eq_self (by + intro pair member equal + have present := (checked.1 pair member).1 + simp [equal, absent] at present) + +omit [DecidableEq F] in +theorem lookup (checked : Certificate source target pairs entries) (name : String) : + target.findChip? (rename pairs name) = (source.findChip? name).map (Chip.rename (rename pairs)) := by + cases found : source.findChip? name with + | some chip => + have shape := checked.2.1 chip (List.mem_of_find?_eq_some found) + simpa [source.findChip_name found] using shape + | none => + rw [checked.outside found] + cases selected : target.findChip? name with + | none => rfl + | some chip => + have present := checked.2.2.1 chip (List.mem_of_find?_eq_some selected) + simp [target.findChip_name selected, found] at present + +omit [DecidableEq F] in +theorem static_fixed (checked : Certificate source target pairs entries) {claim : Message F} + (member : source.MapClaim claim) : claim.rename (rename pairs) = claim := by + have unchanged := checked.outside (checked.2.2.2.2.1 claim member) + cases claim + simp_all [Message.rename] + +omit [DecidableEq F] in +theorem static_iff (checked : Certificate source target pairs entries) (claim : Message F) : + target.MapClaim (claim.rename (rename pairs)) ↔ source.MapClaim claim := by + have static := checked.2.2.2.1 + constructor + · intro member + have old : source.MapClaim (claim.rename (rename pairs)) := by + simpa only [System.MapClaim, static] using member + have absent := checked.2.2.2.2.1 _ old + have original : source.findChip? claim.channel = none := by + cases found : source.findChip? claim.channel with + | none => rfl + | some chip => + have selected := checked.lookup claim.channel + simp only [found, Option.map_some] at selected + have present := checked.2.2.1 _ (List.mem_of_find?_eq_some selected) + simp only [Chip.rename] at present + rw [System.findChip_name found] at present + change source.findChip? (rename pairs claim.channel) = none at absent + simp [absent] at present + have fixed : claim.rename (rename pairs) = claim := by + cases claim + simp_all [Message.rename, checked.outside original] + simpa only [fixed] using old + · intro member + simpa only [System.MapClaim, static, checked.static_fixed member] using member + +theorem ruleTranslation (checked : Certificate source target pairs entries) : + source.RuleTranslation target (rename pairs) where + forward rom rule := by + cases rule with + | node chip row found valid => + let newRow : Row F := { row with chip := rename pairs row.chip } + have selected : target.findChip? newRow.chip = some (chip.rename (rename pairs)) := by + simp [newRow, checked.lookup, found] + refine ⟨.node (chip.rename (rename pairs)) newRow selected ?_, ?_, ?_⟩ + · simpa [newRow] using valid + · simp [RuleInstance.conclusion, newRow] + · simp [RuleInstance.premises, newRow] + | table claim member => + exact ⟨.table (claim.rename (rename pairs)) ((checked.static_iff claim).mpr member), rfl, rfl⟩ + backward rom rule claim same := by + cases rule with + | node chip row found valid => + have names : rename pairs claim.channel = chip.name := congrArg Message.channel same + have selected : target.findChip? (rename pairs claim.channel) = some chip := by + simpa [names, target.findChip_name found] using found + rw [checked.lookup] at selected + cases original : source.findChip? claim.channel with + | none => simp [original] at selected + | some old => + have shape : old.rename (rename pairs) = chip := by simpa [original] using selected + subst chip + let oldRow : Row F := { row with chip := claim.channel } + refine ⟨.node old oldRow original ?_, ?_, ?_⟩ + · simpa [oldRow] using valid + · have args := congrArg Message.args same + have result := congrArg Message.result same + have name := source.findChip_name original + change old.receive oldRow = claim + cases claim with + | mk channel inputs output => + change old.name = channel at name + change inputs = (old.receive oldRow).args at args + change output = (old.receive oldRow).result at result + simp only [Chip.receive, name, args, result] + · simp [RuleInstance.premises, oldRow] + | table message member => + have old : source.MapClaim claim := (checked.static_iff claim).mp (by simpa [same, RuleInstance.conclusion] using member) + exact ⟨.table claim old, rfl, rfl⟩ + +theorem context (checked : Certificate source target pairs entries) (rom : WireROM F) (root : Message F) : + target.checkContext rom (root.rename (rename pairs)) = source.checkContext rom root := by + obtain ⟨_, _, _, _, _, enums, sourceChips, targetChips, _⟩ := checked + simp only [System.checkContext, Message.rename, enums, sourceChips, targetChips] + +theorem derives_iff (checked : Certificate source target pairs entries) {rom : WireROM F} {root : Message F} : + Derives source rom root ↔ Derives target rom (root.rename (rename pairs)) := + checked.ruleTranslation.derives_iff + +theorem memoDerives_iff (checked : Certificate source target pairs entries) {rom : WireROM F} {root : Message F} : + MemoDerives source rom root ↔ MemoDerives target rom (root.rename (rename pairs)) := + checked.ruleTranslation.memoDerives_iff (finite_fibers pairs) + +theorem acyclic_iff (checked : Certificate source target pairs entries) {rom : WireROM F} {root : Message F} : + (∃ graph : MemoDerivation source rom root, graph.Acyclic) ↔ + (∃ graph : MemoDerivation target rom (root.rename (rename pairs)), graph.Acyclic) := + checked.ruleTranslation.acyclic_iff (finite_fibers pairs) + +/-- Deduplication preserves existential accepted traces, including malformed +contexts (which both sides reject). No assumptions about recursion are needed. -/ +theorem check_iff (checked : Certificate source target pairs entries) {rom : WireROM F} {root : Message F} : + (∃ rows, source.check rom root rows = .ok ()) ↔ + (∃ rows, target.check rom (root.rename (rename pairs)) rows = .ok ()) := by + constructor + · rintro ⟨rows, accepted⟩ + have context := (System.check_iff.mp accepted).1 + exact (target.check_derives_iff (by rwa [checked.context])).mpr + (checked.derives_iff.mp (source.check_sound accepted)) + · rintro ⟨rows, accepted⟩ + have context := (System.check_iff.mp accepted).1 + rw [checked.context] at context + exact (source.check_derives_iff context).mpr + (checked.derives_iff.mpr (target.check_sound accepted)) + +theorem checkMemo_iff (checked : Certificate source target pairs entries) {rom : WireROM F} {root : Message F} : + (∃ rows, source.checkMemo rom root rows = .ok ()) ↔ + (∃ rows, target.checkMemo rom (root.rename (rename pairs)) rows = .ok ()) := by + constructor + · rintro ⟨rows, accepted⟩ + have context := (System.checkMemo_iff.mp accepted).1 + exact (target.checkMemo_derives_iff (by rwa [checked.context])).mpr + (checked.memoDerives_iff.mp (source.checkMemo_sound accepted)) + · rintro ⟨rows, accepted⟩ + have context := (System.checkMemo_iff.mp accepted).1 + rw [checked.context] at context + exact (source.checkMemo_derives_iff context).mpr + (checked.memoDerives_iff.mpr (target.checkMemo_sound accepted)) + +omit [DecidableEq F] in +theorem entry_fixed (checked : Certificate source target pairs entries) {root : Message F} + (entry : root.channel ∈ entries) : root.rename (rename pairs) = root := by + have fixed := checked.2.2.2.2.2.2.2.2 root.channel entry + cases root + simp_all [Message.rename] + +theorem check_entry_iff (checked : Certificate source target pairs entries) {rom : WireROM F} {root : Message F} + (entry : root.channel ∈ entries) : + (∃ rows, source.check rom root rows = .ok ()) ↔ (∃ rows, target.check rom root rows = .ok ()) := by + simpa only [checked.entry_fixed entry] using checked.check_iff (rom := rom) (root := root) + +theorem checkMemo_entry_iff (checked : Certificate source target pairs entries) {rom : WireROM F} {root : Message F} + (entry : root.channel ∈ entries) : + (∃ rows, source.checkMemo rom root rows = .ok ()) ↔ (∃ rows, target.checkMemo rom root rows = .ok ()) := by + simpa only [checked.entry_fixed entry] using checked.checkMemo_iff (rom := rom) (root := root) + +end Certificate +end Aiur.Optimized.Dedup diff --git a/Aiur/Aiur/Optimized/DegreeCertificate.lean b/Aiur/Aiur/Optimized/DegreeCertificate.lean new file mode 100644 index 000000000..4e4a79ced --- /dev/null +++ b/Aiur/Aiur/Optimized/DegreeCertificate.lean @@ -0,0 +1,399 @@ +import Aiur.Optimized.ScopedSemantics +import Aiur.Optimized.PolynomialIdentity +import Aiur.Optimized.EquationIndex + +namespace Aiur.Optimized.Degree + +variable {F : Type} [Field F] [DecidableEq F] + +abbrev Definition (F : Type) := ScopeId × Polynomial F × Witness + +def replacement (values : Array (Polynomial F)) (id : Witness) : Polynomial F := + values[id]?.getD (.var id) + +def expand (width : Nat) (definitions : List (Definition F)) : Array (Polynomial F) := Id.run do + let mut values := (List.range width).toArray.map Polynomial.var + for (_, expression, id) in definitions.reverse do + values := values.set! id (expression.subst (replacement values)).simplify + return values + +def Supported (base : Nat) (definitions : List (Definition F)) (scope : ScopeId) (polynomial : Polynomial F) : Prop := + ∀ id ∈ polynomial.vars, id < base ∨ ∃ definition ∈ definitions, definition.2.2 = id ∧ definition.1 = scope + +instance (base : Nat) (definitions : List (Definition F)) (scope : ScopeId) (polynomial : Polynomial F) : + Decidable (Supported base definitions scope polynomial) := by unfold Supported; infer_instance + +abbrev NormalCall (F : Type) := + ScopeId × String × List (WireValue (Polynomial F)) × WireValue Witness +abbrev NormalCell (F : Type) := ScopeId × Polynomial F × WireValue (Polynomial F) + +def normalCall (replace : Witness → Polynomial F) (call : Call F) : NormalCall F := + (call.scope, call.channel, call.args.map (WireValue.map (fun p => (p.subst replace).normalForm)), call.result) + +def normalCell (replace : Witness → Polynomial F) (cell : Cell F) : NormalCell F := + (cell.scope, (cell.address.subst replace).normalForm, + cell.value.map (fun p => (p.subst replace).normalForm)) + +def NormalCall.message (call : NormalCall F) (assignment : Witness → F) : Circuit.Message F := + ⟨call.2.1, call.2.2.1.map (WireValue.map (Circuit.ArithExpr.denote assignment)), + call.2.2.2.map assignment⟩ + +def NormalCell.entry (cell : NormalCell F) (assignment : Witness → F) : F × WireValue F := + (cell.2.1.denote assignment, cell.2.2.map (Circuit.ArithExpr.denote assignment)) + +@[simp] theorem normalCall_id (call : Call F) (assignment : Witness → F) : + (normalCall Polynomial.var call).message assignment = call.message assignment := by + simp [normalCall, NormalCall.message, Call.message, List.map_map, WireValue.map_map, + Function.comp_def, Polynomial.eval_normalForm, Polynomial.denote_subst, + Scalar.Circuit.ArithExpr.denote] + +@[simp] theorem normalCell_id (cell : Cell F) (assignment : Witness → F) : + (normalCell Polynomial.var cell).entry assignment = + (cell.address.denote assignment, cell.value.map (Circuit.ArithExpr.denote assignment)) := by + simp [normalCell, NormalCell.entry, WireValue.map_map, Function.comp_def, + Polynomial.eval_normalForm, Polynomial.denote_subst, Scalar.Circuit.ArithExpr.denote] + +private theorem filterMap_of_map_eq {α β γ δ : Type} {xs : List α} {ys : List β} + {f : α → γ} {g : β → γ} {left : α → Option δ} {right : β → Option δ} + (same : xs.map f = ys.map g) + (pointwise : ∀ x ∈ xs, ∀ y ∈ ys, f x = g y → left x = right y) : + xs.filterMap left = ys.filterMap right := by + induction xs generalizing ys with + | nil => cases ys <;> simp_all + | cons x xs ih => + cases ys with + | nil => simp at same + | cons y ys => + obtain ⟨head, tail⟩ := List.cons.inj same + have rest := ih tail (fun a ha b hb => pointwise a (by simp [ha]) b (by simp [hb])) + simp only [List.filterMap_cons, pointwise x (by simp) y (by simp) head, rest] + +/-- The finite certificate records total-expression definitions and checks the +two scoped equation systems after eliminating precisely those fresh columns. -/ +def Certificate (source target : ScopedChip F) (definitions : List (Definition F)) + (values : Array (Polynomial F)) : Prop := + let replace := replacement values + let base := source.roles.size + target.name = source.name ∧ target.inputs = source.inputs ∧ target.output = source.output ∧ + target.scopes = source.scopes ∧ + (∀ id ∈ List.range base, replace id = .var id) ∧ + (∀ id ∈ source.inputs.flatMap WireValue.words ++ source.output.words, id < base) ∧ + (∀ scope ∈ source.scopes.toList, ∀ id ∈ scope.activation.vars, id < base) ∧ + (∀ definition ∈ definitions, + Supported base definitions definition.1 definition.2.1 ∧ + (∀ id ∈ definition.2.1.vars, id < definition.2.2) ∧ + Polynomial.Identical (definition.2.1.subst replace) (replace definition.2.2) ∧ + ∃ equation ∈ target.equations.toList, equation.scope = definition.1 ∧ + Polynomial.Identical equation.polynomial (.sub (.var definition.2.2) definition.2.1)) ∧ + (∀ equation ∈ source.equations.toList, + Polynomial.Identical equation.polynomial (.const 0) ∨ + ∃ translated ∈ target.equations.toList, translated.scope = equation.scope ∧ + Supported base definitions translated.scope translated.polynomial ∧ + Polynomial.Identical (translated.polynomial.subst replace) equation.polynomial) ∧ + (∀ equation ∈ target.equations.toList, + Polynomial.Identical (equation.polynomial.subst replace) (.const 0) ∨ + ∃ original ∈ source.equations.toList, original.scope = equation.scope ∧ + Polynomial.Identical (equation.polynomial.subst replace) original.polynomial) ∧ + target.calls.toList.map (normalCall replace) = source.calls.toList.map (normalCall Polynomial.var) ∧ + (∀ call ∈ target.calls.toList, + (∀ polynomial ∈ call.args.flatMap WireValue.words, Supported base definitions call.scope polynomial) ∧ + (∀ id ∈ call.result.words, id < base)) ∧ + target.cells.toList.map (normalCell replace) = source.cells.toList.map (normalCell Polynomial.var) ∧ + (∀ cell ∈ target.cells.toList, Supported base definitions cell.scope cell.address ∧ + ∀ polynomial ∈ cell.value.words, Supported base definitions cell.scope polynomial) + +set_option synthInstance.maxSize 4096 in +instance (source target : ScopedChip F) (definitions : List (Definition F)) (values : Array (Polynomial F)) : + Decidable (Certificate source target definitions values) := by + letI : BEq (ScopeId × Polynomial F) := instBEqOfDecidableEq + let replace := replacement values + let targetRaw := EquationIndex.build target.equations.toList id + let sourceRaw := EquationIndex.build source.equations.toList id + let supported := target.equations.toList.filter fun eq => + decide (Supported source.roles.size definitions eq.scope eq.polynomial) + let targetExpanded := EquationIndex.build supported (Polynomial.subst replace) + letI (scope : ScopeId) (polynomial : Polynomial F) : Decidable + (∃ equation ∈ target.equations.toList, equation.scope = scope ∧ + Polynomial.Identical equation.polynomial polynomial) := + decidable_of_iff + ((scope, polynomial.normalForm) ∈ + targetRaw.getD (EquationIndex.key (scope, polynomial.normalForm)) []) + (EquationIndex.member_build target.equations.toList id scope polynomial) + letI (scope : ScopeId) (polynomial : Polynomial F) : Decidable + (∃ equation ∈ source.equations.toList, equation.scope = scope ∧ + Polynomial.Identical polynomial equation.polynomial) := + decidable_of_iff + ((scope, polynomial.normalForm) ∈ + sourceRaw.getD (EquationIndex.key (scope, polynomial.normalForm)) []) + (by + rw [EquationIndex.member_build] + simp only [id_eq, Polynomial.Identical] + exact exists_congr fun eq => and_congr_right fun _ => and_congr_right fun _ => eq_comm) + letI (scope : ScopeId) (polynomial : Polynomial F) : Decidable + (∃ equation ∈ target.equations.toList, equation.scope = scope ∧ + Supported source.roles.size definitions equation.scope equation.polynomial ∧ + Polynomial.Identical (equation.polynomial.subst replace) polynomial) := + decidable_of_iff + ((scope, polynomial.normalForm) ∈ + targetExpanded.getD (EquationIndex.key (scope, polynomial.normalForm)) []) + (by + rw [EquationIndex.member_build] + simp only [supported, List.mem_filter, decide_eq_true_eq] + aesop) + unfold Certificate + dsimp only + infer_instance + +namespace Certificate + +variable {source target : ScopedChip F} {definitions : List (Definition F)} {values : Array (Polynomial F)} + +theorem scopes (checked : Certificate source target definitions values) (scope : ScopeId) : + target.activation scope = source.activation scope := by + simp only [ScopedChip.activation, checked.2.2.2.1] + +theorem original (checked : Certificate source target definitions values) {id : Witness} + (bounded : id < source.roles.size) : replacement values id = .var id := + checked.2.2.2.2.1 id (List.mem_range.mpr bounded) + +theorem activation_bounded (checked : Certificate source target definitions values) (scope : ScopeId) : + ∀ id ∈ (source.activation scope).vars, id < source.roles.size := by + cases found : source.scopes[scope]? with + | none => simp [ScopedChip.activation, found, Polynomial.vars] + | some value => + simpa only [ScopedChip.activation, found, Option.map_some, Option.getD_some] using + checked.2.2.2.2.2.2.1 value (by simpa using Array.mem_of_getElem? found) + +theorem activation_extend (checked : Certificate source target definitions values) + (assignment : Witness → F) (scope : ScopeId) : + (target.activation scope).denote (fun id => (replacement values id).denote assignment) = + (source.activation scope).denote assignment := by + rw [checked.scopes] + apply Polynomial.denote_congr + intro id member + rw [checked.original (checked.activation_bounded scope id member)] + rfl + +/-- Active defining equations identify each fresh column with its expansion. +The strict ordering check prevents a definition from justifying itself. -/ +theorem definition_sound (checked : Certificate source target definitions values) + {rom : WireROM F} {assignment : Witness → F} (valid : target.ValidAssignment rom assignment) + {definition : Definition F} (member : definition ∈ definitions) + (active : (source.activation definition.1).denote assignment ≠ 0) : + assignment definition.2.2 = (replacement values definition.2.2).denote assignment := by + have prove (id : Witness) : ∀ definition ∈ definitions, definition.2.2 = id → + (source.activation definition.1).denote assignment ≠ 0 → + assignment id = (replacement values id).denote assignment := by + induction id using Nat.strong_induction_on with + | h id ih => + intro definition member same active + obtain ⟨support, earlier, expansion, equation, present, owner, polynomial⟩ := + checked.2.2.2.2.2.2.2.1 definition member + have zero := valid.1 equation present + rw [checked.scopes, owner, polynomial.denote] at zero + change (source.activation definition.1).denote assignment * + (assignment definition.2.2 - definition.2.1.denote assignment) = 0 at zero + have equal := sub_eq_zero.mp ((mul_eq_zero.mp zero).resolve_left active) + have substitute : definition.2.1.denote assignment = + (definition.2.1.subst (replacement values)).denote assignment := by + rw [Polynomial.denote_subst] + apply Polynomial.denote_congr + intro other used + rcases support other used with old | ⟨previous, previousMem, index, scope⟩ + · rw [checked.original old]; rfl + · exact ih other (same ▸ earlier other used) previous previousMem index (scope ▸ active) + exact same ▸ (equal.trans (substitute.trans (expansion.denote assignment))) + exact prove definition.2.2 definition member rfl active + +theorem expression_sound (checked : Certificate source target definitions values) + {rom : WireROM F} {assignment : Witness → F} (valid : target.ValidAssignment rom assignment) + {scope : ScopeId} {polynomial : Polynomial F} + (support : Supported source.roles.size definitions scope polynomial) + (active : (source.activation scope).denote assignment ≠ 0) : + polynomial.denote assignment = (polynomial.subst (replacement values)).denote assignment := by + rw [Polynomial.denote_subst] + apply Polynomial.denote_congr + intro id member + rcases support id member with old | ⟨definition, present, index, owner⟩ + · rw [checked.original old]; rfl + · simpa only [index] using checked.definition_sound valid present (owner ▸ active) + +theorem conclusion_extend (checked : Certificate source target definitions values) + (assignment : Witness → F) : + target.conclusion (fun id => (replacement values id).denote assignment) = source.conclusion assignment := by + have bound := checked.2.2.2.2.2.1 + have inputs : source.inputs.map (WireValue.map (fun id => (replacement values id).denote assignment)) = + source.inputs.map (WireValue.map assignment) := by + apply List.map_congr_left + intro value member + apply WireValue.map_congr + intro id present + rw [checked.original (bound id (List.mem_append_left _ (List.mem_flatMap.mpr ⟨value, member, present⟩)))] + rfl + have output : source.output.map (fun id => (replacement values id).denote assignment) = + source.output.map assignment := by + apply WireValue.map_congr + intro id present + rw [checked.original (bound id (List.mem_append_right _ present))] + rfl + simp only [ScopedChip.conclusion, checked.1, checked.2.1, checked.2.2.1, inputs, output] + +theorem conclusion_project (checked : Certificate source target definitions values) + (assignment : Witness → F) : target.conclusion assignment = source.conclusion assignment := by + simp only [ScopedChip.conclusion, checked.1, checked.2.1, checked.2.2.1] + +theorem call_extend (checked : Certificate source target definitions values) + (assignment : Witness → F) {call : Call F} (member : call ∈ target.calls.toList) : + (normalCall (replacement values) call).message assignment = + call.message (fun id => (replacement values id).denote assignment) := by + have result : call.result.map assignment = + call.result.map (fun id => (replacement values id).denote assignment) := by + apply WireValue.map_congr + intro id present + rw [checked.original ((checked.2.2.2.2.2.2.2.2.2.2.2.1 call member).2 id present)] + rfl + simpa only [normalCall, NormalCall.message, Call.message, List.map_map, WireValue.map_map, + Function.comp_def, Polynomial.eval_normalForm, Polynomial.denote_subst] using + congrArg (fun result => Circuit.Message.mk call.channel + (call.args.map (WireValue.map (Circuit.ArithExpr.denote + (fun id => (replacement values id).denote assignment)))) result) result + +theorem call_project (checked : Certificate source target definitions values) + {rom : WireROM F} {assignment : Witness → F} (valid : target.ValidAssignment rom assignment) + {call : Call F} (member : call ∈ target.calls.toList) + (active : (source.activation call.scope).denote assignment = 1) : + (normalCall (replacement values) call).message assignment = call.message assignment := by + have args : call.args.map (WireValue.map (fun p => (p.subst (replacement values)).denote assignment)) = + call.args.map (WireValue.map (Circuit.ArithExpr.denote assignment)) := by + apply List.map_congr_left + intro value present + apply WireValue.map_congr + intro polynomial used + exact (checked.expression_sound valid + ((checked.2.2.2.2.2.2.2.2.2.2.2.1 call member).1 polynomial + (List.mem_flatMap.mpr ⟨value, present, used⟩)) (by rw [active]; exact one_ne_zero)).symm + simpa only [normalCall, NormalCall.message, Call.message, List.map_map, WireValue.map_map, + Function.comp_def, Polynomial.eval_normalForm] using + congrArg (fun args => Circuit.Message.mk call.channel args (call.result.map assignment)) args + +theorem premises_extend (checked : Certificate source target definitions values) + (assignment : Witness → F) : + target.premises (fun id => (replacement values id).denote assignment) = source.premises assignment := by + apply filterMap_of_map_eq checked.2.2.2.2.2.2.2.2.2.2.1 + intro call member original _ same + have scope : call.scope = original.scope := congrArg Prod.fst same + have message := congrArg (fun c => NormalCall.message c assignment) same + rw [checked.call_extend assignment member, normalCall_id] at message + simp only [checked.activation_extend, scope, message] + +theorem premises_project (checked : Certificate source target definitions values) + {rom : WireROM F} {assignment : Witness → F} (valid : target.ValidAssignment rom assignment) : + target.premises assignment = source.premises assignment := by + apply filterMap_of_map_eq checked.2.2.2.2.2.2.2.2.2.2.1 + intro call member original _ same + have scope : call.scope = original.scope := congrArg Prod.fst same + by_cases active : (source.activation call.scope).denote assignment = 1 + · have message := congrArg (fun c => NormalCall.message c assignment) same + rw [checked.call_project valid member active, normalCall_id] at message + simp only [checked.scopes, ← scope, active, ↓reduceIte, message] + · simp only [checked.scopes, ← scope, active, ↓reduceIte] + +theorem cell_extend (cell : Cell F) (assignment : Witness → F) : + (normalCell (replacement values) cell).entry assignment = + (cell.address.denote (fun id => (replacement values id).denote assignment), + cell.value.map (Circuit.ArithExpr.denote (fun id => (replacement values id).denote assignment))) := by + simp [normalCell, NormalCell.entry, WireValue.map_map, Function.comp_def, + Polynomial.eval_normalForm, Polynomial.denote_subst] + +theorem cell_project (checked : Certificate source target definitions values) + {rom : WireROM F} {assignment : Witness → F} (valid : target.ValidAssignment rom assignment) + {cell : Cell F} (member : cell ∈ target.cells.toList) + (active : (source.activation cell.scope).denote assignment = 1) : + (normalCell (replacement values) cell).entry assignment = + (cell.address.denote assignment, cell.value.map (Circuit.ArithExpr.denote assignment)) := by + obtain ⟨address, payload⟩ := checked.2.2.2.2.2.2.2.2.2.2.2.2.2 cell member + have nonzero : (source.activation cell.scope).denote assignment ≠ 0 := by rw [active]; exact one_ne_zero + simp only [normalCell, NormalCell.entry, WireValue.map_map, Function.comp_def, + Polynomial.eval_normalForm] + rw [← checked.expression_sound valid address nonzero] + congr 1 + exact WireValue.map_congr _ (fun p hp => (checked.expression_sound valid (payload p hp) nonzero).symm) + +theorem valid_extend (checked : Certificate source target definitions values) + {rom : WireROM F} {assignment : Witness → F} (valid : source.ValidAssignment rom assignment) : + target.ValidAssignment rom (fun id => (replacement values id).denote assignment) := by + constructor + · intro equation member + rw [checked.activation_extend, ← Polynomial.denote_subst] + rcases checked.2.2.2.2.2.2.2.2.2.1 equation member with zero | ⟨original, present, scope, same⟩ + · rw [zero.denote]; simp [Scalar.Circuit.ArithExpr.denote] + · rw [same.denote, ← scope] + exact valid.1 original present + · intro cell member active + rw [checked.activation_extend] at active + have cells := checked.2.2.2.2.2.2.2.2.2.2.2.2.1 + have present : normalCell (replacement values) cell ∈ + target.cells.toList.map (normalCell (replacement values)) := List.mem_map.mpr ⟨cell, member, rfl⟩ + rw [cells] at present + obtain ⟨original, present, same⟩ := List.mem_map.mp present + have scope : original.scope = cell.scope := congrArg Prod.fst same + have entry := congrArg (fun c => NormalCell.entry c assignment) same + rw [normalCell_id, cell_extend] at entry + rw [← entry] + exact valid.2 original present (scope ▸ active) + +theorem valid_project (checked : Certificate source target definitions values) + {rom : WireROM F} {assignment : Witness → F} (valid : target.ValidAssignment rom assignment) : + source.ValidAssignment rom assignment := by + constructor + · intro equation member + rcases checked.2.2.2.2.2.2.2.2.1 equation member with zero | ⟨translated, present, scope, support, same⟩ + · rw [zero.denote]; simp [Scalar.Circuit.ArithExpr.denote] + · by_cases inactive : (source.activation equation.scope).denote assignment = 0 + · simp [inactive] + · have eq := valid.1 translated present + rw [checked.scopes, checked.expression_sound valid support (scope ▸ inactive), same.denote, scope] at eq + exact eq + · intro cell member active + have cells := checked.2.2.2.2.2.2.2.2.2.2.2.2.1 + have present : normalCell Polynomial.var cell ∈ + source.cells.toList.map (normalCell Polynomial.var) := List.mem_map.mpr ⟨cell, member, rfl⟩ + rw [← cells] at present + obtain ⟨translated, present, same⟩ := List.mem_map.mp present + have scope : translated.scope = cell.scope := congrArg Prod.fst same + have entry := congrArg (fun c => NormalCell.entry c assignment) same + rw [checked.cell_project valid present (scope ▸ active), normalCell_id] at entry + rw [← entry] + exact valid.2 translated present (by rw [checked.scopes, scope]; exact active) + +/-- A checked degree-reduction certificate gives both witness directions, +including the ordered list of call premises and all ROM obligations. -/ +theorem equivalent (checked : Certificate source target definitions values) : source.Equivalent target := by + constructor + · intro rom assignment valid + exact ⟨_, checked.valid_extend valid, checked.conclusion_extend assignment, checked.premises_extend assignment⟩ + · intro rom assignment valid + exact ⟨_, checked.valid_project valid, (checked.conclusion_project assignment).symm, + (checked.premises_project valid).symm⟩ + +end Certificate + +structure Checked (source : ScopedChip F) where + chip : ScopedChip F + equivalent : source.Equivalent chip + name_eq : chip.name = source.name + inputs_eq : chip.inputs = source.inputs + output_eq : chip.output = source.output + +/-- Check the actual optimizer output; no correctness claim about its search +or cache heuristics is trusted by the certificate theorem. -/ +def certify (source : ScopedChip F) (state : State F) : Except String (Checked source) := do + let values := expand state.chip.roles.size state.cache + if checked : Certificate source state.chip state.cache values then + return ⟨state.chip, checked.equivalent, checked.1, checked.2.1, checked.2.2.1⟩ + else throw s!"invalid degree-reduction certificate in {source.name}" + +def checkedBound (config : Config) (source : ScopedChip F) : Except String (Checked source) := do + certify source (← boundState config source) + +end Aiur.Optimized.Degree diff --git a/Aiur/Aiur/Optimized/EndToEnd.lean b/Aiur/Aiur/Optimized/EndToEnd.lean new file mode 100644 index 000000000..75ac4e207 --- /dev/null +++ b/Aiur/Aiur/Optimized/EndToEnd.lean @@ -0,0 +1,282 @@ +import Aiur.Optimized.Grouping.Plan +import Aiur.Optimized.Activation + +/-! +Unified end-to-end compiler soundness from activated and grouped physical circuits +all the way back to the independent modular source evaluation predicate +`Modules.Prepared.EvalFn`. +-/ + +namespace Aiur + +variable {F : Type} [Field F] [DecidableEq F] + +/-- Conditional soundness for weighted memoized rows at the core `Program F` level. -/ +theorem checkerMemo_acyclic_heap_sound {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {rom : WireROM F} {name : String} {args : List (SourceValue F)} {result : Value F} + {wires : List (WireValue F)} {output : WireValue F} {rows : List (Circuit.WeightedRow F)} + (checked : system.checkMemo rom ⟨name, wires, output⟩ rows = .ok ()) + (acyclic : (Classical.choice (system.checkMemo_sound checked)).Acyclic) + (entry : checkEntry program name = .ok ()) + (arguments : DecodesValues program.enums wires (entryValues args)) + (decoded : output.decode program.enums = some result) : + ∃ source heap, EvalFn program name args [] source heap ∧ + Represents (rom.decode program.enums) heap source result := + memo_acyclic_heap_sound compiled + (Circuit.System.checkContext_iff.mp (Circuit.System.checkMemo_iff.mp checked).1).2.2.1 + entry (Classical.choice (system.checkMemo_sound checked)) acyclic arguments decoded + +end Aiur + +namespace Aiur.Optimized.Activation + +open Circuit +variable {F : Type} [Field F] [DecidableEq F] + +/-- An active row of the activation-padded chip `compile chip` satisfies the +padded chip's constraints and memory lookups with selector `1`. -/ +def ActiveRule (chip : Chip F) (rom : WireROM F) + (root : Message F) (premises : List (Message F)) : Prop := + ∃ row : Row F, row.chip = chip.name ∧ (compile chip).ValidRow rom row ∧ + row.assignment chip.numVars = 1 ∧ (compile chip).receive row = root ∧ + (compile chip).premises row = premises + +/-- Active rows of `Activation.compile chip` have the exact same local rule as +`chip` itself. -/ +theorem activeRule_iff (chip : Chip F) (formed : chip.wellFormed = true) + (paddedFormed : (compile chip).wellFormed = true) (rom : WireROM F) + (root : Message F) (premises : List (Message F)) : + ActiveRule chip rom root premises ↔ chip.LocalRule rom root premises := + active_rule_iff chip formed paddedFormed rom root premises + +end Aiur.Optimized.Activation + +namespace Aiur.Optimized.Grouping + +open Circuit +variable {F : Type} [Field F] [DecidableEq F] +variable {source : Circuit.System F} {id : String → Except String Nat} + +/-- Every ungrouped single chip in the plan is well-formed both before and after +row-activation compilation. -/ +def Plan.WellFormedActivation (plan : Plan source id) : Prop := + ∀ c ∈ plan.singles, c.wellFormed = true ∧ (Activation.compile c).wellFormed = true + +instance (plan : Plan source id) : Decidable plan.WellFormedActivation := by + unfold Plan.WellFormedActivation + infer_instance + +/-- Local rule of a grouped physical plan after applying `Activation.compile` to +every ungrouped single chip (grouped chips already include activation in +`Layout.RowRule`). -/ +def Plan.ActivatedLocalRule (plan : Plan source id) (rom : WireROM F) + (root : Message F) (premises : List (Message F)) : Prop := + (∃ c ∈ plan.singles, Activation.ActiveRule c rom root premises) ∨ + ∃ p ∈ plan.groups, p.checked.layout.RowRule rom root premises + +theorem Plan.activatedLocalRule_iff (plan : Plan source id) + (activated : plan.WellFormedActivation) (rom : WireROM F) + (root : Message F) (premises : List (Message F)) : + plan.ActivatedLocalRule rom root premises ↔ plan.LocalRule rom root premises := by + constructor + · rintro (⟨c, hc, rule⟩ | ⟨p, hp, rule⟩) + · have wf := activated c hc + exact Or.inl ⟨c, hc, (Activation.activeRule_iff c wf.1 wf.2 rom root premises).mp rule⟩ + · exact Or.inr ⟨p, hp, rule⟩ + · rintro (⟨c, hc, rule⟩ | ⟨p, hp, rule⟩) + · have wf := activated c hc + exact Or.inl ⟨c, hc, (Activation.activeRule_iff c wf.1 wf.2 rom root premises).mpr rule⟩ + · exact Or.inr ⟨p, hp, rule⟩ + +/-- Finite derivation tree over the activated grouped physical system. -/ +inductive Plan.ActivatedDerives (plan : Plan source id) (rom : WireROM F) : Message F → Prop + | node {root premises} (rule : plan.ActivatedLocalRule rom root premises) + (children : ∀ message ∈ premises, plan.ActivatedDerives rom message) : + plan.ActivatedDerives rom root + | table {message} (member : source.MapClaim message) : plan.ActivatedDerives rom message + +theorem Plan.activatedDerives_sound_plan (plan : Plan source id) + (activated : plan.WellFormedActivation) {rom : WireROM F} {root : Message F} + (derived : plan.ActivatedDerives rom root) : plan.Derives rom root := by + induction derived with + | node rule _ ih => + exact .node ((plan.activatedLocalRule_iff activated _ _ _).mp rule) ih + | table member => exact .table member + +theorem Plan.activatedDerives_complete_plan (plan : Plan source id) + (activated : plan.WellFormedActivation) {rom : WireROM F} {root : Message F} + (derived : plan.Derives rom root) : plan.ActivatedDerives rom root := by + induction derived with + | node rule _ ih => + exact .node ((plan.activatedLocalRule_iff activated _ _ _).mpr rule) ih + | table member => exact .table member + +theorem Plan.activatedDerives_iff (plan : Plan source id) + (activated : plan.WellFormedActivation) {rom : WireROM F} {root : Message F} : + plan.ActivatedDerives rom root ↔ plan.Derives rom root := + ⟨plan.activatedDerives_sound_plan activated, plan.activatedDerives_complete_plan activated⟩ + +theorem Plan.activatedDerives_sound (plan : Plan source id) + (activated : plan.WellFormedActivation) {rom : WireROM F} {root : Message F} + (derived : plan.ActivatedDerives rom root) : Circuit.Derives source rom root := + plan.derives_sound (plan.activatedDerives_sound_plan activated derived) + +end Aiur.Optimized.Grouping + +namespace Aiur.Optimized.Physical + +open Circuit +variable {F : Type} [Field F] [DecidableEq F] +variable {id : String → Except String Nat} + +theorem Prepared.grouped_activated_native_heap_sound {source : Generic.Source F} {entries : List String} + {specialized : Generic.Specialized source entries} (compiled : GenericArtifact specialized) + (prepared : Prepared compiled.artifact) (plan : Grouping.Plan prepared.system id) + (activated : plan.WellFormedActivation) + {name : String} (entry : name ∈ entries) {rom : WidthROM F} (valid : rom.Valid) + {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F} + (signed : Erasure.Signed compiled.system ⟨name, wires, output⟩) + (derived : plan.ActivatedDerives (Erasure.rawROM rom) (Erasure.message compiled.system ⟨name, wires, output⟩)) + (arguments : DecodesValues specialized.program.enums wires (entryValues args)) + (decoded : output.decode specialized.program.enums = some result) : + ∃ value heap, Generic.SourceSemantics.EvalFn source.world name args [] value heap ∧ + Represents ((Erasure.typedROM compiled.system rom).decode specialized.program.enums) heap value result := + prepared.grouped_native_heap_sound compiled plan entry valid signed + (plan.activatedDerives_sound_plan activated derived) arguments decoded + +end Aiur.Optimized.Physical + +namespace Aiur.Optimized + +open Circuit +variable {F : Type} [Field F] [DecidableEq F] +variable {id : String → Except String Nat} + +theorem ModulesArtifact.physical_heap_sound {program : Modules.Program F} + {prepared : Modules.Prepared program} (compiled : ModulesArtifact prepared) + (physical : Physical.Prepared compiled.circuit.artifact) + {external : String} {entry : Modules.Selection program prepared.environment.assembly.instances} + (selected : prepared.find? external = some entry) + {rom : WidthROM F} (valid : rom.Valid) + {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F} + (signed : Erasure.Signed compiled.circuit.system ⟨entry.resolved.name, wires, output⟩) + (derived : Derives physical.system (Erasure.rawROM rom) + (Erasure.message compiled.circuit.system ⟨entry.resolved.name, wires, output⟩)) + (arguments : DecodesValues compiled.specialized.program.enums wires (entryValues args)) + (decoded : output.decode compiled.specialized.program.enums = some result) : + ∃ value heap, prepared.EvalFn external args value heap ∧ + Represents ((Erasure.typedROM compiled.circuit.system rom).decode compiled.specialized.program.enums) + heap value result := by + obtain ⟨value, heap, evaluated, related⟩ := + physical.native_heap_sound compiled.circuit (Modules.Prepared.entry_mem selected) + valid signed derived arguments decoded + exact ⟨value, heap, ⟨entry, selected, evaluated⟩, related⟩ + +theorem ModulesArtifact.grouped_heap_sound {program : Modules.Program F} + {prepared : Modules.Prepared program} (compiled : ModulesArtifact prepared) + (physical : Physical.Prepared compiled.circuit.artifact) + (plan : Grouping.Plan physical.system id) + {external : String} {entry : Modules.Selection program prepared.environment.assembly.instances} + (selected : prepared.find? external = some entry) + {rom : WidthROM F} (valid : rom.Valid) + {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F} + (signed : Erasure.Signed compiled.circuit.system ⟨entry.resolved.name, wires, output⟩) + (derived : plan.Derives (Erasure.rawROM rom) + (Erasure.message compiled.circuit.system ⟨entry.resolved.name, wires, output⟩)) + (arguments : DecodesValues compiled.specialized.program.enums wires (entryValues args)) + (decoded : output.decode compiled.specialized.program.enums = some result) : + ∃ value heap, prepared.EvalFn external args value heap ∧ + Represents ((Erasure.typedROM compiled.circuit.system rom).decode compiled.specialized.program.enums) + heap value result := + compiled.physical_heap_sound physical selected valid signed (plan.derives_sound derived) arguments decoded + +theorem ModulesArtifact.grouped_activated_heap_sound {program : Modules.Program F} + {prepared : Modules.Prepared program} (compiled : ModulesArtifact prepared) + (physical : Physical.Prepared compiled.circuit.artifact) + (plan : Grouping.Plan physical.system id) + (activated : plan.WellFormedActivation) + {external : String} {entry : Modules.Selection program prepared.environment.assembly.instances} + (selected : prepared.find? external = some entry) + {rom : WidthROM F} (valid : rom.Valid) + {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F} + (signed : Erasure.Signed compiled.circuit.system ⟨entry.resolved.name, wires, output⟩) + (derived : plan.ActivatedDerives (Erasure.rawROM rom) + (Erasure.message compiled.circuit.system ⟨entry.resolved.name, wires, output⟩)) + (arguments : DecodesValues compiled.specialized.program.enums wires (entryValues args)) + (decoded : output.decode compiled.specialized.program.enums = some result) : + ∃ value heap, prepared.EvalFn external args value heap ∧ + Represents ((Erasure.typedROM compiled.circuit.system rom).decode compiled.specialized.program.enums) + heap value result := + compiled.grouped_heap_sound physical plan selected valid signed + (plan.activatedDerives_sound_plan activated derived) arguments decoded + +end Aiur.Optimized + +namespace Aiur.Modules + +open Circuit Optimized +variable {F : Type} [Field F] [DecidableEq F] +variable {id : String → Except String Nat} + +/-- End-to-end soundness from a physical type-erased circuit derivation to +`Modules.Prepared.EvalFn`. -/ +theorem Prepared.physical_heap_sound {program : Modules.Program F} + (prepared : Modules.Prepared program) (compiled : ModulesArtifact prepared) + (physical : Physical.Prepared compiled.circuit.artifact) + {external : String} {entry : Modules.Selection program prepared.environment.assembly.instances} + (selected : prepared.find? external = some entry) + {rom : WidthROM F} (valid : rom.Valid) + {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F} + (signed : Erasure.Signed compiled.circuit.system ⟨entry.resolved.name, wires, output⟩) + (derived : Derives physical.system (Erasure.rawROM rom) + (Erasure.message compiled.circuit.system ⟨entry.resolved.name, wires, output⟩)) + (arguments : DecodesValues compiled.specialized.program.enums wires (entryValues args)) + (decoded : output.decode compiled.specialized.program.enums = some result) : + ∃ value heap, prepared.EvalFn external args value heap ∧ + Represents ((Erasure.typedROM compiled.circuit.system rom).decode compiled.specialized.program.enums) + heap value result := + compiled.physical_heap_sound physical selected valid signed derived arguments decoded + +/-- End-to-end soundness from a grouped physical circuit derivation to +`Modules.Prepared.EvalFn`. -/ +theorem Prepared.grouped_heap_sound {program : Modules.Program F} + (prepared : Modules.Prepared program) (compiled : ModulesArtifact prepared) + (physical : Physical.Prepared compiled.circuit.artifact) + (plan : Grouping.Plan physical.system id) + {external : String} {entry : Modules.Selection program prepared.environment.assembly.instances} + (selected : prepared.find? external = some entry) + {rom : WidthROM F} (valid : rom.Valid) + {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F} + (signed : Erasure.Signed compiled.circuit.system ⟨entry.resolved.name, wires, output⟩) + (derived : plan.Derives (Erasure.rawROM rom) + (Erasure.message compiled.circuit.system ⟨entry.resolved.name, wires, output⟩)) + (arguments : DecodesValues compiled.specialized.program.enums wires (entryValues args)) + (decoded : output.decode compiled.specialized.program.enums = some result) : + ∃ value heap, prepared.EvalFn external args value heap ∧ + Represents ((Erasure.typedROM compiled.circuit.system rom).decode compiled.specialized.program.enums) + heap value result := + compiled.grouped_heap_sound physical plan selected valid signed derived arguments decoded + +/-- End-to-end soundness from an activated grouped physical circuit derivation to +`Modules.Prepared.EvalFn`. -/ +theorem Prepared.grouped_activated_heap_sound {program : Modules.Program F} + (prepared : Modules.Prepared program) (compiled : ModulesArtifact prepared) + (physical : Physical.Prepared compiled.circuit.artifact) + (plan : Grouping.Plan physical.system id) + (activated : plan.WellFormedActivation) + {external : String} {entry : Modules.Selection program prepared.environment.assembly.instances} + (selected : prepared.find? external = some entry) + {rom : WidthROM F} (valid : rom.Valid) + {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F} + (signed : Erasure.Signed compiled.circuit.system ⟨entry.resolved.name, wires, output⟩) + (derived : plan.ActivatedDerives (Erasure.rawROM rom) + (Erasure.message compiled.circuit.system ⟨entry.resolved.name, wires, output⟩)) + (arguments : DecodesValues compiled.specialized.program.enums wires (entryValues args)) + (decoded : output.decode compiled.specialized.program.enums = some result) : + ∃ value heap, prepared.EvalFn external args value heap ∧ + Represents ((Erasure.typedROM compiled.circuit.system rom).decode compiled.specialized.program.enums) + heap value result := + compiled.grouped_activated_heap_sound physical plan activated selected valid signed derived arguments decoded + +end Aiur.Modules diff --git a/Aiur/Aiur/Optimized/EquationIndex.lean b/Aiur/Aiur/Optimized/EquationIndex.lean new file mode 100644 index 000000000..de424c6e2 --- /dev/null +++ b/Aiur/Aiur/Optimized/EquationIndex.lean @@ -0,0 +1,33 @@ +import Aiur.Optimized.PolynomialIdentity +import Aiur.Optimized.Index + +namespace Aiur.Optimized.EquationIndex + +/-- A field-independent discriminator. Collisions only enlarge a bucket; +membership always compares the complete normalized equation. -/ +def expressionKey : Polynomial F → Nat + | .const _ => 0 + | .var id => id + 1 + | .add a b | .sub a b | .mul a b => + let left := expressionKey a + if left == 0 then expressionKey b else left + +def key (equation : ScopeId × Polynomial F) : Nat := + (hash (equation.1, expressionKey equation.2)).toNat + +variable {F : Type} [Field F] [DecidableEq F] + +/-- Normalize translated equations once, retaining their activation scopes. -/ +def build (equations : List (Equation F)) (translate : Polynomial F → Polynomial F) : + Std.HashMap Nat (List (ScopeId × Polynomial F)) := + Index.build key (equations.map fun eq => (eq.scope, (translate eq.polynomial).normalForm)) + +theorem member_build (equations : List (Equation F)) (translate : Polynomial F → Polynomial F) + (scope : ScopeId) (polynomial : Polynomial F) : + (scope, polynomial.normalForm) ∈ + (build equations translate).getD (key (scope, polynomial.normalForm)) [] ↔ + ∃ equation ∈ equations, equation.scope = scope ∧ + Polynomial.Identical (translate equation.polynomial) polynomial := by + simp [build, Index.mem_build, Polynomial.Identical] + +end Aiur.Optimized.EquationIndex diff --git a/Aiur/Aiur/Optimized/Equivalence.lean b/Aiur/Aiur/Optimized/Equivalence.lean new file mode 100644 index 000000000..4440377b5 --- /dev/null +++ b/Aiur/Aiur/Optimized/Equivalence.lean @@ -0,0 +1,160 @@ +import Aiur.Optimized.SemanticModel +import Aiur.Optimized.Correctness +import Aiur.Circuit.MemoTree + +namespace Aiur.Optimized + +variable {F : Type} [Field F] [DecidableEq F] + {program : Program F} {entries : List String} {config : Config} {artifact : Artifact F} + +/-- Removing internal validation preserves every reference derivation, even for +internal pointer arguments and before requiring a functional ROM. -/ +theorem reference_derives {reference : Circuit.System F} + (original : Circuit.compile program = .ok reference) + (compiled : compile program entries config = .ok artifact) + {rom : WireROM F} {root : Circuit.Message F} (entry : root.channel ∈ entries) + (derived : Circuit.Derives reference rom root) : Circuit.Derives artifact.system rom root := + (artifact.dedup_derives_iff (by simpa only [(compile_stages compiled).2.2.1] using entry)).mp + (((Circuit.compile_semanticModel original).supportRefinesProvenance + (compile_semanticModel compiled)).derives derived) + +/-- Entry validation starts the canonical-value/provenance induction. The +result's canonical encoding is proved here, with no decoded-return premise. -/ +theorem compiler_entry_sound (compiled : compile program entries config = .ok artifact) + {rom : WireROM F} {root : Circuit.Message F} (entry : root.channel ∈ entries) + (valid : rom.Valid) (free : root.PublicArguments program.enums) + (derived : Circuit.Derives artifact.system rom root) : root.Evaluates program rom := by + obtain ⟨tree⟩ := (artifact.dedup_derives_iff + (by simpa only [(compile_stages compiled).2.2.1] using entry)).mpr derived + obtain ⟨rule, _, same⟩ := tree.root_instance + have canonical := compile_entry_arguments compiled rule (by simpa only [same] using entry) + rw [same] at canonical + exact (compile_semanticModel compiled).derivation_evaluates valid free canonical tree + +/-- Finite entry derivations recover every omitted internal validation. +The statement covers all layout passes and recursive chip deduplication. -/ +theorem reference_derives_iff {reference : Circuit.System F} + (original : Circuit.compile program = .ok reference) + (compiled : compile program entries config = .ok artifact) + {rom : WireROM F} {root : Circuit.Message F} (entry : root.channel ∈ entries) + (valid : rom.Valid) (free : root.PublicArguments program.enums) : + Circuit.Derives reference rom root ↔ Circuit.Derives artifact.system rom root := by + refine ⟨reference_derives original compiled entry, ?_⟩ + intro derived + obtain ⟨args, result, arguments, decoded, evaluated⟩ := + compiler_entry_sound compiled entry valid free derived + exact (Circuit.compile_semanticModel original).complete_encoded evaluated arguments decoded + +/-- Cyclic memoized completeness is preserved. Soundness in the reverse + direction requires an acyclic graph. -/ +theorem reference_memoDerives {reference : Circuit.System F} + (original : Circuit.compile program = .ok reference) + (compiled : compile program entries config = .ok artifact) + {rom : WireROM F} {root : Circuit.Message F} (entry : root.channel ∈ entries) + (derived : Circuit.MemoDerives reference rom root) : Circuit.MemoDerives artifact.system rom root := + (artifact.dedup_memoDerives_iff (by simpa only [(compile_stages compiled).2.2.1] using entry)).mp + (((Circuit.compile_semanticModel original).supportRefinesProvenance + (compile_semanticModel compiled)).memoDerives derived) + +theorem reference_acyclic_iff {reference : Circuit.System F} + (original : Circuit.compile program = .ok reference) + (compiled : compile program entries config = .ok artifact) + {rom : WireROM F} {root : Circuit.Message F} (entry : root.channel ∈ entries) + (valid : rom.Valid) (free : root.PublicArguments program.enums) : + (∃ graph : Circuit.MemoDerivation reference rom root, graph.Acyclic) ↔ + (∃ graph : Circuit.MemoDerivation artifact.system rom root, graph.Acyclic) := by + rw [← Circuit.derives_iff_acyclic_memo, ← Circuit.derives_iff_acyclic_memo] + exact reference_derives_iff original compiled entry valid free + +private theorem reference_context_iff {reference : Circuit.System F} + (original : Circuit.compile program = .ok reference) + (compiled : compile program entries config = .ok artifact) + (rom : WireROM F) (root : Circuit.Message F) : + reference.checkContext rom root = .ok () ↔ artifact.system.checkContext rom root = .ok () := by + simp only [Circuit.System.checkContext_iff, Circuit.compile_wellFormed original, artifact.wellFormed, and_true, + (Circuit.compile_stages original).2.2.2.1, compile_enums compiled] + +/-- The integer checker already enforces the public input and functional-ROM +conditions needed by provenance soundness. Its generic tree bridge is unchanged. -/ +theorem reference_check_iff {reference : Circuit.System F} + (original : Circuit.compile program = .ok reference) + (compiled : compile program entries config = .ok artifact) + {rom : WireROM F} {root : Circuit.Message F} (entry : root.channel ∈ entries) : + (∃ rows, reference.check rom root rows = .ok ()) ↔ + (∃ rows, artifact.system.check rom root rows = .ok ()) := by + constructor + · rintro ⟨rows, accepted⟩ + have context := (reference_context_iff original compiled rom root).mp + (Circuit.System.check_iff.mp accepted).1 + exact (artifact.system.check_derives_iff context).mpr + (reference_derives original compiled entry (reference.check_sound accepted)) + · rintro ⟨rows, accepted⟩ + have context := (reference_context_iff original compiled rom root).mpr + (Circuit.System.check_iff.mp accepted).1 + have facts := Circuit.System.checkContext_iff.mp (Circuit.System.check_iff.mp accepted).1 + have free : root.PublicArguments program.enums := by + simpa only [compile_enums compiled] using facts.2.1 + exact (reference.check_derives_iff context).mpr + ((reference_derives_iff original compiled entry facts.2.2.1 free).mpr + (artifact.system.check_sound accepted)) + +/-- Every accepted reference LogUp witness remains accepted after deleting +load checks. No acyclicity restriction is needed for this direction. -/ +theorem reference_checkMemo_complete {reference : Circuit.System F} + (original : Circuit.compile program = .ok reference) + (compiled : compile program entries config = .ok artifact) + {rom : WireROM F} {root : Circuit.Message F} (entry : root.channel ∈ entries) + (accepted : ∃ rows, reference.checkMemo rom root rows = .ok ()) : + ∃ rows, artifact.system.checkMemo rom root rows = .ok () := by + obtain ⟨rows, accepted⟩ := accepted + have context := (reference_context_iff original compiled rom root).mp + (Circuit.System.checkMemo_iff.mp accepted).1 + exact (artifact.system.checkMemo_derives_iff context).mpr + (reference_memoDerives original compiled entry (reference.checkMemo_sound accepted)) + +/-- Memoized checker equivalence holds for claims admitting acyclic support. +Arbitrary cyclic proofs retain the intended possibility of self-justification. -/ +theorem reference_checkMemo_acyclic_iff {reference : Circuit.System F} + (original : Circuit.compile program = .ok reference) + (compiled : compile program entries config = .ok artifact) + {rom : WireROM F} {root : Circuit.Message F} (entry : root.channel ∈ entries) : + ((∃ rows, reference.checkMemo rom root rows = .ok ()) ∧ + ∃ graph : Circuit.MemoDerivation reference rom root, graph.Acyclic) ↔ + ((∃ rows, artifact.system.checkMemo rom root rows = .ok ()) ∧ + ∃ graph : Circuit.MemoDerivation artifact.system rom root, graph.Acyclic) := by + constructor + · rintro ⟨⟨rows, accepted⟩, graph, acyclic⟩ + have context := (reference_context_iff original compiled rom root).mp + (Circuit.System.checkMemo_iff.mp accepted).1 + have facts := Circuit.System.checkContext_iff.mp context + have free : root.PublicArguments program.enums := by + simpa only [compile_enums compiled] using facts.2.1 + exact ⟨reference_checkMemo_complete original compiled entry ⟨rows, accepted⟩, + (reference_acyclic_iff original compiled entry facts.2.2.1 free).mp ⟨graph, acyclic⟩⟩ + · rintro ⟨⟨rows, accepted⟩, graph, acyclic⟩ + have context := (reference_context_iff original compiled rom root).mpr + (Circuit.System.checkMemo_iff.mp accepted).1 + have facts := Circuit.System.checkContext_iff.mp (Circuit.System.checkMemo_iff.mp accepted).1 + have free : root.PublicArguments program.enums := by + simpa only [compile_enums compiled] using facts.2.1 + have tree := (reference_derives_iff original compiled entry facts.2.2.1 free).mpr + (graph.derives_of_acyclic acyclic) + exact ⟨(reference.checkMemo_derives_iff context).mpr tree.memo, tree.acyclic⟩ + +/-- Source ROM evaluation and the optimized entry circuit agree on inputs +with provenance. Pointer-free inputs satisfy this precondition automatically. -/ +theorem compiler_correct (compiled : compile program entries config = .ok artifact) + {rom : WireROM F} (valid : rom.Valid) {name : String} (entry : name ∈ entries) + {args : List (Value F)} {result : Value F} + (trusted : ∀ value ∈ args, (rom.decode program.enums).Provenance value) : + ROMEvalCall (rom.decode program.enums) program name args result ↔ + Circuit.EncodedEvaluates program.enums artifact.system rom name args result := by + rw [(compile_semanticModel compiled).evaluates_iff valid trusted] + unfold Circuit.EncodedEvaluates + constructor <;> rintro ⟨wires, output, arguments, decoded, derived⟩ + · exact ⟨wires, output, arguments, decoded, + (artifact.dedup_derives_iff (by simpa only [(compile_stages compiled).2.2.1] using entry)).mp derived⟩ + · exact ⟨wires, output, arguments, decoded, + (artifact.dedup_derives_iff (by simpa only [(compile_stages compiled).2.2.1] using entry)).mpr derived⟩ + +end Aiur.Optimized diff --git a/Aiur/Aiur/Optimized/ExpressionCorrectness.lean b/Aiur/Aiur/Optimized/ExpressionCorrectness.lean new file mode 100644 index 000000000..368bfcd8b --- /dev/null +++ b/Aiur/Aiur/Optimized/ExpressionCorrectness.lean @@ -0,0 +1,715 @@ +import Aiur.Optimized.ValidationCorrectness +import Aiur.Optimized.CompileFacts +import Aiur.Circuit.ExpressionCorrectness +import Aiur.Memory.WireProvenance + +namespace Aiur.Optimized.Compiler + +open Circuit.Compiler (ExpressionMeaning localsEnvironment localsEnvironment_append) + +variable {F : Type} [Field F] [DecidableEq F] +/-- Call premises are needed only for arguments whose pointers originate in +stores. This is the invariant supplied by finite entrypoint derivations. -/ +def CallsSound (decls : Declarations) (rom : WireROM F) + (calls : Circuit.CallRelation F) (sourceCalls : Aiur.CallRelation F) : Prop := + ∀ name args result, calls name args result → ∀ values, + DecodesValues decls args values → + (∀ v ∈ values, (rom.decode decls).Provenance v) → + ∃ value, result.decode decls = some value ∧ sourceCalls name values value + +set_option maxHeartbeats 4000000 +set_option maxRecDepth 8192 + +theorem lift_eq_ok {computation : Except String α} {value : α} {before after : State F} + (compiled : (liftM computation : Build F α) before = .ok (value, after)) : + computation = .ok value ∧ before = after := by + cases computation with + | error error => simp [lift_error] at compiled + | ok result => + simp only [lift_ok, Except.ok.injEq, Prod.mk.injEq] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨rfl, rfl⟩ + +theorem equalValue_extends {scope : ScopeId} {left right : Symbolic F} {before after : State F} + (compiled : equalValue scope left right before = .ok ((), after)) : before.Extends after := by + simp only [equalValue] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp compiled + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst middle + apply equations_extends (conditions := (left.words.zip right.words).map (fun (a, b) => Polynomial.sub a b)) + simpa only [List.forIn_map] using rest + +private theorem failure_terms_extends {scope : ScopeId} {conditions terms : List (Polynomial F)} + {before after : State F} + (compiled : (conditions.mapM fun difference => do + return Polynomial.mul difference (.var (← fresh (.auxiliary scope))) : Build F (List (Polynomial F))) + before = .ok (terms, after)) : before.Extends after := by + induction conditions generalizing terms before with + | nil => + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [List.mapM_nil] using compiled) + exact .refl _ + | cons difference conditions ih => + simp only [List.mapM_cons] at compiled + obtain ⟨term, s₁, headRun, tailBind⟩ := bind_ok.mp compiled + obtain ⟨tail, s₂, tailRun, finished⟩ := bind_ok.mp tailBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨id, s₃, freshRun, finished⟩ := bind_ok.mp headRun + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + exact (fresh_extends freshRun).trans (ih tailRun) + +theorem failure_extends {scope : ScopeId} {conditions : List (Polynomial F)} {before after : State F} + (compiled : failure scope conditions before = .ok ((), after)) : before.Extends after := by + simp only [failure] at compiled + obtain ⟨terms, middle, termsRun, equationRun⟩ := bind_ok.mp compiled + exact (failure_terms_extends termsRun).trans (equation_extends equationRun) + +theorem failures_sound {scope : ScopeId} {previous : List (List (Polynomial F))} {before after : State F} + (compiled : (do for earlier in previous do failure scope earlier : Build F Unit) + before = .ok ((), after)) : + before.Extends after ∧ ∀ {rom : WireROM F} {calls : Circuit.CallRelation F} {assignment : Witness → F}, + after.Valid rom calls assignment → before.Valid rom calls assignment ∧ + ((before.activation scope).denote assignment = 1 → ∀ earlier ∈ previous, ¬AllZero earlier assignment) := by + induction previous generalizing before with + | nil => + have same : before = after := by + simpa [List.forIn_nil, pure, StateT.pure, StateT.bind, bind, Except.bind, Except.pure] using compiled + subst after + exact ⟨.refl _, fun valid => ⟨valid, by simp⟩⟩ + | cons earlier previous ih => + simp only [List.forIn_cons, bind_assoc, pure_bind] at compiled + obtain ⟨⟨⟩, middle, headRun, tailRun⟩ := bind_ok.mp compiled + have extension := failure_extends headRun + obtain ⟨tailExtension, tailMeaning⟩ := ih tailRun + refine ⟨extension.trans tailExtension, fun valid => ?_⟩ + obtain ⟨middleValid, tail⟩ := tailMeaning valid + obtain ⟨beforeValid, head⟩ := failure_sound headRun middleValid + exact ⟨beforeValid, fun active => by + simpa using And.intro (head active) (tail (extension.active active))⟩ + +theorem finish_sound {scope : ScopeId} {target : Option (WireValue Witness)} {value output : Symbolic F} + {before after : State F} + (compiled : (do + if let some result := target then + equalValue scope (result.map Polynomial.var) value + return result.map Polynomial.var + return value : Build F (Symbolic F)) before = .ok (output, after)) : + before.Extends after ∧ ∀ {rom : WireROM F} {calls : Circuit.CallRelation F} {assignment : Witness → F}, + after.Valid rom calls assignment → before.Valid rom calls assignment ∧ + ((before.activation scope).denote assignment = 1 → + output.map (Circuit.ArithExpr.denote assignment) = value.map (Circuit.ArithExpr.denote assignment)) := by + cases target with + | none => + obtain ⟨rfl, rfl⟩ := pure_ok.mp compiled + exact ⟨.refl _, fun valid => ⟨valid, fun _ => rfl⟩⟩ + | some result => + obtain ⟨⟨⟩, middle, equated, finished⟩ := bind_ok.mp compiled + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + exact ⟨equalValue_extends equated, fun valid => equalValue_sound equated valid⟩ + +theorem cell_sound {cell : Cell F} {before after : State F} + (compiled : (modify (fun state => {state with cells := state.cells.push cell}) : Build F Unit) + before = .ok ((), after)) : + before.Extends after ∧ ∀ {rom : WireROM F} {calls : Circuit.CallRelation F} {assignment : Witness → F}, + after.Valid rom calls assignment → before.Valid rom calls assignment ∧ + ((before.activation cell.scope).denote assignment = 1 → + (cell.address.denote assignment, cell.value.map (Circuit.ArithExpr.denote assignment)) ∈ rom.entries) := by + change Except.ok ((), {before with cells := before.cells.push cell}) = Except.ok ((), after) at compiled + have stateEq := congrArg Prod.snd (Except.ok.inj compiled) + dsimp only at stateEq + subst after + have extension : before.Extends {before with cells := before.cells.push cell} := + ⟨fun _ _ => id, fun _ => id, fun _ => id, by simp⟩ + exact ⟨extension, fun valid => ⟨valid.of_extends extension, valid.2.2 cell (by simp)⟩⟩ + +theorem call_sound {call : Call F} {before after : State F} + (compiled : (modify (fun state => {state with calls := state.calls.push call}) : Build F Unit) + before = .ok ((), after)) : + before.Extends after ∧ ∀ {rom : WireROM F} {calls : Circuit.CallRelation F} {assignment : Witness → F}, + after.Valid rom calls assignment → before.Valid rom calls assignment ∧ + ((before.activation call.scope).denote assignment = 1 → + calls call.channel (call.message assignment).args (call.message assignment).result) := by + change Except.ok ((), {before with calls := before.calls.push call}) = Except.ok ((), after) at compiled + have stateEq := congrArg Prod.snd (Except.ok.inj compiled) + dsimp only at stateEq + subst after + have extension : before.Extends {before with calls := before.calls.push call} := + ⟨fun _ _ => id, fun _ => id, by simp, fun _ => id⟩ + exact ⟨extension, fun valid => ⟨valid.of_extends extension, valid.2.1 call (by simp)⟩⟩ + +mutual + theorem lower_sound {program : Program F} (checked : checkDeclarations program.enums = .ok ()) + (tags : program.enums.tagsValid F = true) + {calls : Circuit.CallRelation F} {sourceCalls : Aiur.CallRelation F} + {rom : WireROM F} (romValid : rom.Valid) + (callSound : CallsSound program.enums rom calls sourceCalls) + (callProvenance : ∀ name args result, sourceCalls name args result → + (∀ v ∈ args, (rom.decode program.enums).Provenance v) → + (rom.decode program.enums).Provenance result) + {function : String} {locals : Locals F} {scope : ScopeId} {expr : Expr F} + {target : Option (WireValue Witness)} {output : Symbolic F} {before after : State F} + (compiled : lower program function locals scope expr target before = .ok (output, after)) : + before.Extends after ∧ ∀ (assignment : Witness → F), + (before.activation 0).denote assignment = 1 → after.Valid rom calls assignment → + before.Valid rom calls assignment ∧ ((before.activation scope).denote assignment = 1 → ∀ environment, + DecodesEnvironment program.enums (localsEnvironment locals assignment) environment → + environment.Provenance (rom.decode program.enums) → + ExpressionMeaning program.enums rom sourceCalls environment expr + (output.map (Circuit.ArithExpr.denote assignment))) := by + rw [lower.eq_def] at compiled + obtain ⟨value, middle, valueRun, finishRun⟩ := bind_ok.mp compiled + obtain ⟨finishExtension, finishMeaning⟩ := finish_sound finishRun + have body : before.Extends middle ∧ ∀ (assignment : Witness → F), + (before.activation 0).denote assignment = 1 → middle.Valid rom calls assignment → + before.Valid rom calls assignment ∧ ((before.activation scope).denote assignment = 1 → ∀ environment, + DecodesEnvironment program.enums (localsEnvironment locals assignment) environment → + environment.Provenance (rom.decode program.enums) → + ExpressionMeaning program.enums rom sourceCalls environment expr + (value.map (Circuit.ArithExpr.denote assignment))) := by + cases expr with + | literal literal => + obtain ⟨rfl, rfl⟩ := pure_ok.mp valueRun + exact ⟨.refl _, fun _ _ valid => ⟨valid, fun _ _ _ _ => + ⟨.field literal, by simp [Scalar.Circuit.ArithExpr.denote], .literal⟩⟩⟩ + | var name => + cases found : locals.find? (·.1 == name) with + | none => simp [found] at valueRun + | some binding => + rcases binding with ⟨bindingName, wire⟩ + have same : bindingName = name := by simpa using List.find?_some found + subst bindingName + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [found] using valueRun) + refine ⟨.refl _, fun assignment _ valid => ⟨valid, fun _ environment decoded _ => ?_⟩⟩ + obtain ⟨value, lookup, valueDecode⟩ := decoded.find name + (wire := (name, wire.map (Circuit.ArithExpr.denote assignment))) + (by simp [localsEnvironment, List.find?_map, Function.comp_def, found]) + exact ⟨value, valueDecode, .var lookup⟩ + | tuple items => + obtain ⟨wires, last, argsRun, finished⟩ := bind_ok.mp valueRun + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨extension, meaning⟩ := lowerArgs_sound checked tags romValid callSound callProvenance argsRun + refine ⟨extension, fun assignment root valid => ?_⟩ + obtain ⟨previous, evaluated⟩ := meaning assignment root valid + refine ⟨previous, fun active environment decoded trusted => ?_⟩ + obtain ⟨values, decodedValues, evaluations⟩ := evaluated active environment decoded trusted + exact ⟨.tuple values, by + simpa only [WireValue.map_tuple] using WireValue.decode_tuple checked tags decodedValues, + .tuple evaluations⟩ + | construct name ctor args => + cases found : program.enums.findEnum? name with + | none => simp [found] at valueRun + | some definition => + cases atIndex : definition.constructors[definition.constructors.findIdx (·.name == ctor)]? with + | none => simp [found, atIndex] at valueRun + | some constructor => + simp only [found, atIndex] at valueRun + obtain ⟨wires, s₁, argsRun, rest⟩ := bind_ok.mp valueRun + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · rename_i types + obtain ⟨⟨⟩, unchangedState, unchanged, layoutBind⟩ := bind_ok.mp rest + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst unchangedState + obtain ⟨layout, layoutState, layoutRun, shapeBind⟩ := bind_ok.mp layoutBind + obtain ⟨expansion, stateEq⟩ := getLayout_eq layoutRun + subst layoutState + split at shapeBind + · simp [StateT.bind, bind, Except.bind] at shapeBind + · obtain ⟨⟨⟩, unchangedState, unchanged, finished⟩ := bind_ok.mp shapeBind + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst unchangedState + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨extension, meaning⟩ := lowerArgs_sound checked tags romValid callSound callProvenance argsRun + refine ⟨extension, fun assignment root valid => ?_⟩ + obtain ⟨previous, evaluated⟩ := meaning assignment root valid + refine ⟨previous, fun active environment decoded trusted => ?_⟩ + obtain ⟨values, argsDecode, argsEval⟩ := evaluated active environment decoded trusted + have ctorName : constructor.name = ctor := by + simpa using List.findIdx_of_getElem?_eq_some atIndex + refine ⟨.construct name ctor values, ?_, .construct argsEval⟩ + have constructed := WireValue.decode_construct checked tags found atIndex argsDecode + (by simpa [Function.comp_def, WireValue.map] using (not_ne_iff.mp types)) expansion + simpa [ctorName, WireValue.map, List.map_flatMap, List.flatMap_map, + List.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using constructed + | project operand index => + obtain ⟨input, s₁, inputRun, rest⟩ := bind_ok.mp valueRun + rcases input with ⟨type, words⟩ + cases type with + | field | ptr | enum => simp at rest + | tuple types => + dsimp only at rest + obtain ⟨wires, s₂, splitRun, resultBind⟩ := bind_ok.mp rest + obtain ⟨stateEq, reference⟩ := splitValues_reference splitRun + subst s₂ + cases projected : wires[index]? with + | none => simp [projected] at resultBind + | some result => + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [projected] using resultBind) + obtain ⟨extension, meaning⟩ := lower_sound checked tags romValid callSound callProvenance inputRun + refine ⟨extension, fun assignment root valid => ?_⟩ + obtain ⟨previous, evaluated⟩ := meaning assignment root valid + refine ⟨previous, fun active environment decoded trusted => ?_⟩ + obtain ⟨value, inputDecode, inputEval⟩ := evaluated active environment decoded trusted + obtain ⟨values, rfl, decodedValues⟩ := Circuit.Compiler.splitValues_decode checked (reference {}) inputDecode + obtain ⟨value, valueAt, valueDecode⟩ := decodedValues.getElem (index := index) + (wire := result.map (Circuit.ArithExpr.denote assignment)) + (by simp [List.getElem?_map, projected]) + exact ⟨value, valueDecode, .project inputEval (by simp [projectValue, valueAt, pure, Except.pure])⟩ + | letValue pat operand body => + obtain ⟨input, s₁, inputRun, patternBind⟩ := bind_ok.mp valueRun + obtain ⟨⟨conditions, bindings⟩, s₂, patternRun, guardBind⟩ := bind_ok.mp patternBind + obtain ⟨stateEq, matched⟩ := pattern_correct checked tags patternRun + subst s₂ + obtain ⟨⟨⟩, s₃, guardRun, bodyRun⟩ := bind_ok.mp guardBind + have guardRun' : (do for condition in conditions do equation scope condition : Build F Unit) + s₁ = .ok ((), s₃) := bind_ok.mpr ⟨(), s₃, guardRun, rfl⟩ + obtain ⟨inputExtension, inputMeaning⟩ := lower_sound checked tags romValid callSound callProvenance inputRun + have guardExtension := equations_extends guardRun' + obtain ⟨bodyExtension, bodyMeaning⟩ := lower_sound checked tags romValid callSound callProvenance bodyRun + have beforeBody := inputExtension.trans guardExtension + refine ⟨beforeBody.trans bodyExtension, fun assignment root valid => ?_⟩ + obtain ⟨s₃valid, bodyEval⟩ := bodyMeaning assignment (beforeBody.active root) valid + obtain ⟨s₁valid, equations⟩ := equations_sound guardRun' s₃valid + obtain ⟨previous, inputEval⟩ := inputMeaning assignment root s₁valid + refine ⟨previous, fun active environment decoded trusted => ?_⟩ + obtain ⟨inputValue, inputDecode, inputEval⟩ := inputEval active environment decoded trusted + have zeros : AllZero conditions assignment := fun condition member => by + simpa only [inputExtension.active active, one_mul] using equations condition member + rcases matched assignment inputValue inputDecode with + ⟨values, matched, _, decodedBindings⟩ | ⟨_, failed⟩ + · obtain ⟨value, resultDecode, evaluated⟩ := bodyEval (beforeBody.active active) (values ++ environment) + (by simpa only [localsEnvironment_append] using decodedBindings.append decoded) + (by + intro binding member + rcases List.mem_append.mp member with member | member + · exact Pattern.bindings_provenance + (inputEval.provenance (WireROM.decode_valid romValid) callProvenance trusted) matched binding member + · exact trusted binding member) + exact ⟨value, resultDecode, .letValue inputEval matched evaluated⟩ + · exact (failed zeros).elim + | store operand => + obtain ⟨input, s₁, inputRun, destBind⟩ := bind_ok.mp valueRun + obtain ⟨result, s₂, destRun, shapeBind⟩ := bind_ok.mp destBind + have resultType := (destination_spec destRun).2.2 + rcases result with ⟨resultType', resultWords⟩ + dsimp only at resultType + subst resultType' + cases resultWords with + | nil => simp at shapeBind + | cons address words => + cases words with + | cons => simp at shapeBind + | nil => + dsimp only at shapeBind + obtain ⟨⟨⟩, s₃, cellRun, finished⟩ := bind_ok.mp shapeBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨inputExtension, inputMeaning⟩ := lower_sound checked tags romValid callSound callProvenance inputRun + have beforeCell := inputExtension.trans (destination_extends destRun) + obtain ⟨cellExtension, cellMeaning⟩ := cell_sound cellRun + refine ⟨beforeCell.trans cellExtension, fun assignment root valid => ?_⟩ + obtain ⟨s₂valid, cell⟩ := cellMeaning valid + obtain ⟨previous, evaluated⟩ := inputMeaning assignment root (destination_valid destRun s₂valid) + refine ⟨previous, fun active environment decoded trusted => ?_⟩ + obtain ⟨value, valueDecode, valueEval⟩ := evaluated active environment decoded trusted + obtain ⟨type, _, layout, expansion, _⟩ := WireValue.decode_spec valueDecode + have names := (Declarations.layout_parts expansion).1 + refine ⟨.ptr value.type (assignment address), ?_, .store valueEval ?_⟩ + · simpa only [WireValue.map_ptr, Scalar.Circuit.ArithExpr.denote, type, WireValue.map, WireValue.ptr, List.map_cons, List.map_nil] using + WireValue.decode_ptr names (assignment address) + · exact WireROM.mem_decode.mpr ⟨_, cell (beforeCell.active active), valueDecode⟩ + | load operand => + obtain ⟨input, s₁, inputRun, shapeBind⟩ := bind_ok.mp valueRun + rcases input with ⟨type, words⟩ + cases type with + | field | tuple | enum => simp at shapeBind + | ptr pointerType => + cases words with + | nil => simp at shapeBind + | cons address words => + cases words with + | cons => simp at shapeBind + | nil => + dsimp only at shapeBind + obtain ⟨result, s₂, destRun, cellBind⟩ := bind_ok.mp shapeBind + obtain ⟨⟨⟩, s₃, cellRun, finished⟩ := bind_ok.mp cellBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨inputExtension, inputMeaning⟩ := + lower_sound checked tags romValid callSound callProvenance inputRun + have beforeCell := inputExtension.trans (destination_extends destRun) + obtain ⟨cellExtension, cellMeaning⟩ := cell_sound cellRun + refine ⟨beforeCell.trans cellExtension, fun assignment root valid => ?_⟩ + obtain ⟨s₂valid, cell⟩ := cellMeaning valid + obtain ⟨previous, evaluated⟩ := inputMeaning assignment root (destination_valid destRun s₂valid) + refine ⟨previous, fun active environment decoded trusted => ?_⟩ + obtain ⟨value, valueDecode, valueEval⟩ := evaluated active environment decoded trusted + have same := WireValue.ptr_decoded_eq valueDecode + subst value + have pointerTrusted := valueEval.provenance (WireROM.decode_valid romValid) callProvenance trusted + obtain ⟨value, resultDecode, resultType, _⟩ := + WireROM.load_of_provenance romValid pointerTrusted (cell (beforeCell.active active)) + (by simpa only [WireValue.map] using (destination_spec destRun).2.2) + exact ⟨value, resultDecode, .load valueEval + (WireROM.mem_decode.mpr ⟨_, cell (beforeCell.active active), resultDecode⟩) resultType⟩ + | neg operand => + obtain ⟨input, s₁, inputRun, rest⟩ := bind_ok.mp valueRun + obtain ⟨polynomial, s₂, fieldRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_eq fieldRun + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨extension, meaning⟩ := lower_sound checked tags romValid callSound callProvenance inputRun + refine ⟨extension, fun assignment root valid => ?_⟩ + obtain ⟨previous, evaluated⟩ := meaning assignment root valid + refine ⟨previous, fun active environment decoded trusted => ?_⟩ + obtain ⟨value, valueDecode, valueEval⟩ := evaluated active environment decoded trusted + simp only [WireValue.map_field, WireValue.decode_field, Option.some.injEq] at valueDecode + subst value + exact ⟨.field (0 - polynomial.denote assignment), by simp [Scalar.Circuit.ArithExpr.denote], + .neg valueEval (by simp [evalNeg])⟩ + | hint type key channel => + obtain ⟨input, s₁, keyRun, rest⟩ := bind_ok.mp valueRun + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · rename_i free + have free : type.pointerFree program.enums = true := by simpa using free + obtain ⟨⟨⟩, unchangedState, unchanged, destBind⟩ := bind_ok.mp rest + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst unchangedState + obtain ⟨result, s₂, destRun, validationBind⟩ := bind_ok.mp destBind + obtain ⟨⟨⟩, s₃, validationRun, finished⟩ := bind_ok.mp validationBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨keyExtension, keyMeaning⟩ := lower_sound checked tags romValid callSound callProvenance keyRun + have destExtension := destination_extends destRun + obtain ⟨validationExtension, validationMeaning⟩ := validateValue_sound checked tags validationRun + have beforeValidation := keyExtension.trans destExtension + refine ⟨beforeValidation.trans validationExtension, fun assignment root valid => ?_⟩ + obtain ⟨s₂valid, resultDecoded⟩ := validationMeaning rom calls assignment (beforeValidation.active root) valid + obtain ⟨previous, keyEval⟩ := keyMeaning assignment root (destination_valid destRun s₂valid) + refine ⟨previous, fun active environment decoded trusted => ?_⟩ + obtain ⟨keyValue, _, keyEval⟩ := keyEval active environment decoded trusted + obtain ⟨value, resultDecode⟩ := resultDecoded (beforeValidation.active active) + have spec := WireValue.decode_spec resultDecode + have shape : value.type = type := spec.1.trans (destination_spec destRun).2.2 + have valueFree := Value.pointerFree_of_type (shape ▸ free) spec.2.1 + obtain ⟨constant, same⟩ := value.exists_constant valueFree + subst value + exact ⟨_, resultDecode, .hint keyEval (by + simpa [Value.WellTyped, Value.hasType] using And.intro shape spec.2.1)⟩ + | assertEq message left right => + obtain ⟨leftWire, s₁, leftRun, rest⟩ := bind_ok.mp valueRun + obtain ⟨rightWire, s₂, rightRun, rest⟩ := bind_ok.mp rest + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · rename_i free + obtain ⟨⟨⟩, unchangedState, unchanged, eqBind⟩ := bind_ok.mp rest + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst unchangedState + obtain ⟨⟨⟩, last, equated, finished⟩ := bind_ok.mp eqBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨leftExtension, leftMeaning⟩ := lower_sound checked tags romValid callSound callProvenance leftRun + obtain ⟨rightExtension, rightMeaning⟩ := lower_sound checked tags romValid callSound callProvenance rightRun + have beforeEq := leftExtension.trans rightExtension + refine ⟨beforeEq.trans (equalValue_extends equated), fun assignment root valid => ?_⟩ + obtain ⟨valid₂, equal⟩ := equalValue_sound equated valid + obtain ⟨valid₁, rightEval⟩ := rightMeaning assignment (leftExtension.active root) valid₂ + obtain ⟨previous, leftEval⟩ := leftMeaning assignment root valid₁ + refine ⟨previous, fun active environment decoded trusted => ?_⟩ + obtain ⟨x, xDecode, xEval⟩ := leftEval active environment decoded trusted + obtain ⟨y, yDecode, yEval⟩ := rightEval (leftExtension.active active) environment decoded trusted + have same : x = y := Option.some.inj (xDecode.symm.trans ((equal (beforeEq.active active)) ▸ yDecode)) + have data := WireValue.decode_spec xDecode + have pointerFree : x.pointerFree = true := Value.pointerFree_of_type + (by simpa [data.1, WireValue.type_map] using free) data.2.1 + exact ⟨.tuple [], by simpa only [WireValue.map_tuple, List.map_nil] using + WireValue.decode_tuple checked tags (.nil : DecodesValues program.enums [] []), + .assertEq xEval yEval (evalAssertEq_ok.mpr ⟨pointerFree, same, rfl⟩)⟩ + | binary op left right => + obtain ⟨leftWire, s₁, leftRun, leftBind⟩ := bind_ok.mp valueRun + obtain ⟨leftPoly, s₂, leftField, rightBind⟩ := bind_ok.mp leftBind + obtain ⟨rfl, rfl⟩ := asField_eq leftField + obtain ⟨rightWire, s₃, rightRun, rightFieldBind⟩ := bind_ok.mp rightBind + obtain ⟨rightPoly, s₄, rightField, rest⟩ := bind_ok.mp rightFieldBind + obtain ⟨rfl, rfl⟩ := asField_eq rightField + obtain ⟨leftExtension, leftMeaning⟩ := lower_sound checked tags romValid callSound callProvenance leftRun + obtain ⟨rightExtension, rightMeaning⟩ := lower_sound checked tags romValid callSound callProvenance rightRun + have beforeOperation := leftExtension.trans rightExtension + cases op with + | add | sub | mul => + obtain ⟨rfl, rfl⟩ := pure_ok.mp rest + refine ⟨beforeOperation, fun assignment root valid => ?_⟩ + obtain ⟨s₁valid, rightEval⟩ := rightMeaning assignment (leftExtension.active root) valid + obtain ⟨previous, leftEval⟩ := leftMeaning assignment root s₁valid + refine ⟨previous, fun active environment decoded trusted => ?_⟩ + obtain ⟨x, xDecode, xEval⟩ := leftEval active environment decoded trusted + obtain ⟨y, yDecode, yEval⟩ := rightEval (leftExtension.active active) environment decoded trusted + simp only [WireValue.map_field, WireValue.decode_field, Option.some.injEq] at xDecode yDecode + subst x; subst y + exact ⟨_, WireValue.decode_field _ _, .binary xEval yEval (by + simp [evalBinOp, Scalar.Circuit.ArithExpr.denote])⟩ + | div => + cases folded : rightPoly.constantInverse? with + | some inverse => + simp only [folded] at rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp rest + refine ⟨beforeOperation, fun assignment root valid => ?_⟩ + obtain ⟨s₁valid, rightEval⟩ := rightMeaning assignment (leftExtension.active root) valid + obtain ⟨previous, leftEval⟩ := leftMeaning assignment root s₁valid + refine ⟨previous, fun active environment decoded trusted => ?_⟩ + obtain ⟨x, xDecode, xEval⟩ := leftEval active environment decoded trusted + obtain ⟨y, yDecode, yEval⟩ := rightEval (leftExtension.active active) environment decoded trusted + simp only [WireValue.map_field, WireValue.decode_field, Option.some.injEq] at xDecode yDecode + subst x; subst y + have known := Polynomial.constantInverse?_sound folded assignment + exact ⟨_, WireValue.decode_field _ _, .binary xEval yEval (by + simp [evalBinOp, Scalar.Circuit.ArithExpr.denote, known.1, known.2, div_eq_mul_inv])⟩ + | none => + simp only [folded] at rest + obtain ⟨inverse, s₅, inverseRun, inverseBind⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₆, equationRun, finished⟩ := bind_ok.mp inverseBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + have beforeEquation := beforeOperation.trans (fresh_extends inverseRun) + refine ⟨beforeEquation.trans (equation_extends equationRun), fun assignment root valid => ?_⟩ + obtain ⟨s₅valid, equation⟩ := equation_valid equationRun valid + have s₃valid := fresh_valid inverseRun s₅valid + obtain ⟨s₁valid, rightEval⟩ := rightMeaning assignment (leftExtension.active root) s₃valid + obtain ⟨previous, leftEval⟩ := leftMeaning assignment root s₁valid + refine ⟨previous, fun active environment decoded trusted => ?_⟩ + obtain ⟨x, xDecode, xEval⟩ := leftEval active environment decoded trusted + obtain ⟨y, yDecode, yEval⟩ := rightEval (leftExtension.active active) environment decoded trusted + simp only [WireValue.map_field, WireValue.decode_field, Option.some.injEq] at xDecode yDecode + subst x; subst y + change (s₅.activation scope).denote assignment * + (rightPoly.denote assignment * assignment inverse - 1) = 0 at equation + rw [beforeEquation.active active, one_mul] at equation + exact ⟨_, WireValue.decode_field _ _, .binary xEval yEval (by + simp [evalBinOp, Scalar.Circuit.ArithExpr.denote, Scalar.Circuit.inverse_nonzero equation, + Scalar.Circuit.inverse_eq equation, div_eq_mul_inv])⟩ + | call name args => + cases found : program.findSignature? name with + | none => simp [found] at valueRun + | some callee => + simp only [found] at valueRun + obtain ⟨arguments, s₁, argsRun, guardBind⟩ := bind_ok.mp valueRun + split at guardBind + · simp [StateT.bind, bind, Except.bind] at guardBind + · obtain ⟨⟨⟩, unchangedState, unchanged, destBind⟩ := bind_ok.mp guardBind + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst unchangedState + obtain ⟨result, s₂, destRun, callBind⟩ := bind_ok.mp destBind + obtain ⟨⟨⟩, s₃, callRun, finished⟩ := bind_ok.mp callBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨argsExtension, argsMeaning⟩ := lowerArgs_sound checked tags romValid callSound callProvenance argsRun + have beforeCall := argsExtension.trans (destination_extends destRun) + obtain ⟨callExtension, callMeaning⟩ := call_sound callRun + refine ⟨beforeCall.trans callExtension, fun assignment root valid => ?_⟩ + obtain ⟨s₂valid, callValid⟩ := callMeaning valid + obtain ⟨previous, argsEval⟩ := argsMeaning assignment root (destination_valid destRun s₂valid) + refine ⟨previous, fun active environment decoded trusted => ?_⟩ + obtain ⟨values, argsDecode, argsEval⟩ := argsEval active environment decoded trusted + obtain ⟨value, resultDecode, calleeEval⟩ := + callSound name _ _ (callValid (beforeCall.active active)) values argsDecode + (argsEval.provenance (WireROM.decode_valid romValid) callProvenance trusted) + exact ⟨value, by simpa only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote, Call.message] using resultDecode, .call argsEval calleeEval⟩ + | matchValue scrutinee arms => + obtain ⟨⟨⟩, checkState, checkRun, typeBind⟩ := bind_ok.mp valueRun + obtain ⟨_, stateEq⟩ := lift_eq_ok checkRun + subst checkState + obtain ⟨type, typeState, typeRun, scrutineeBind⟩ := bind_ok.mp typeBind + obtain ⟨_, stateEq⟩ := lift_eq_ok typeRun + subst typeState + obtain ⟨input, s₁, scrutineeRun, destBind⟩ := bind_ok.mp scrutineeBind + obtain ⟨result, s₂, destRun, choiceBind⟩ := bind_ok.mp destBind + obtain ⟨branches, s₄, choiceRun, armsBind⟩ := bind_ok.mp choiceBind + obtain ⟨⟨⟩, s₅, armsRun, finished⟩ := bind_ok.mp armsBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨inputExtension, inputMeaning⟩ := lower_sound checked tags romValid callSound callProvenance scrutineeRun + have beforeChoice := inputExtension.trans (destination_extends destRun) + have choiceExtension := choice_extends choiceRun + have beforeArms := beforeChoice.trans choiceExtension + obtain ⟨armsExtension, armsMeaning⟩ := lowerArms_sound checked tags romValid callSound callProvenance + (choice_length choiceRun) armsRun + refine ⟨beforeArms.trans armsExtension, fun assignment root valid => ?_⟩ + obtain ⟨s₄valid, armsEval⟩ := armsMeaning assignment (beforeArms.active root) valid + have s₂valid := s₄valid.of_extends choiceExtension + obtain ⟨previous, inputEval⟩ := inputMeaning assignment root (destination_valid destRun s₂valid) + refine ⟨previous, fun active environment decoded trusted => ?_⟩ + obtain ⟨inputValue, inputDecode, evaluated⟩ := inputEval active environment decoded trusted + obtain ⟨branch, member, enabled⟩ := choice_active choiceRun s₄valid (beforeChoice.active root) + (beforeChoice.active active) + obtain ⟨_, bindings, body, selected, value, valueDecode, bodyEval⟩ := + armsEval environment decoded trusted inputValue inputDecode + (evaluated.provenance (WireROM.decode_valid romValid) callProvenance trusted) branch member enabled + exact ⟨value, by simpa only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote, Call.message] using valueDecode, + .matchValue evaluated selected bodyEval⟩ + refine ⟨body.1.trans finishExtension, fun assignment root valid => ?_⟩ + obtain ⟨middleValid, equal⟩ := finishMeaning valid + obtain ⟨beforeValid, evaluated⟩ := body.2 assignment root middleValid + refine ⟨beforeValid, fun active environment decoded trusted => ?_⟩ + rw [equal (body.1.active active)] + exact evaluated active environment decoded trusted + termination_by sizeOf expr + + theorem lowerArgs_sound {program : Program F} (checked : checkDeclarations program.enums = .ok ()) + (tags : program.enums.tagsValid F = true) + {calls : Circuit.CallRelation F} {sourceCalls : Aiur.CallRelation F} + {rom : WireROM F} (romValid : rom.Valid) + (callSound : CallsSound program.enums rom calls sourceCalls) + (callProvenance : ∀ name args result, sourceCalls name args result → + (∀ v ∈ args, (rom.decode program.enums).Provenance v) → + (rom.decode program.enums).Provenance result) + {function : String} {locals : Locals F} {scope : ScopeId} {args : List (Expr F)} + {outputs : List (Symbolic F)} {before after : State F} + (compiled : lowerArgs program function locals scope args before = .ok (outputs, after)) : + before.Extends after ∧ ∀ (assignment : Witness → F), + (before.activation 0).denote assignment = 1 → after.Valid rom calls assignment → + before.Valid rom calls assignment ∧ ((before.activation scope).denote assignment = 1 → ∀ environment, + DecodesEnvironment program.enums (localsEnvironment locals assignment) environment → + environment.Provenance (rom.decode program.enums) → ∃ values, + DecodesValues program.enums (outputs.map (WireValue.map (Circuit.ArithExpr.denote assignment))) values ∧ + ROMEvalArgsWith program.enums (rom.decode program.enums) sourceCalls environment args values) := by + cases args with + | nil => + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [lowerArgs] using compiled) + exact ⟨.refl _, fun _ _ valid => ⟨valid, fun _ _ _ _ => ⟨[], .nil, .nil⟩⟩⟩ + | cons arg args => + simp only [lowerArgs] at compiled + obtain ⟨head, middle, headRun, rest⟩ := bind_ok.mp compiled + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨headExtension, headMeaning⟩ := lower_sound checked tags romValid callSound callProvenance headRun + obtain ⟨tailExtension, tailMeaning⟩ := lowerArgs_sound checked tags romValid callSound callProvenance tailRun + refine ⟨headExtension.trans tailExtension, fun assignment root valid => ?_⟩ + obtain ⟨middleValid, tailEval⟩ := tailMeaning assignment (headExtension.active root) valid + obtain ⟨previous, headEval⟩ := headMeaning assignment root middleValid + refine ⟨previous, fun active environment decoded trusted => ?_⟩ + obtain ⟨head, headDecode, headEval⟩ := headEval active environment decoded trusted + obtain ⟨tail, tailDecode, tailEval⟩ := tailEval (headExtension.active active) environment decoded trusted + exact ⟨head :: tail, .cons headDecode tailDecode, .cons headEval tailEval⟩ + termination_by sizeOf args + + theorem lowerArms_sound {program : Program F} (checked : checkDeclarations program.enums = .ok ()) + (tags : program.enums.tagsValid F = true) + {calls : Circuit.CallRelation F} {sourceCalls : Aiur.CallRelation F} + {rom : WireROM F} (romValid : rom.Valid) + (callSound : CallsSound program.enums rom calls sourceCalls) + (callProvenance : ∀ name args result, sourceCalls name args result → + (∀ v ∈ args, (rom.decode program.enums).Provenance v) → + (rom.decode program.enums).Provenance result) + {function : String} {locals : Locals F} {scrutinee : Symbolic F} {result : WireValue Witness} + {scopes : List ScopeId} {arms : List (Pattern F × Expr F)} {previous : List (List (Polynomial F))} + (length : scopes.length = (retainArms program.enums arms).length) {before after : State F} + (compiled : lowerArms program function locals scrutinee result scopes arms previous before = .ok ((), after)) : + before.Extends after ∧ ∀ (assignment : Witness → F), + (before.activation 0).denote assignment = 1 → after.Valid rom calls assignment → + before.Valid rom calls assignment ∧ ∀ environment, + DecodesEnvironment program.enums (localsEnvironment locals assignment) environment → + environment.Provenance (rom.decode program.enums) → ∀ input, + (scrutinee.map (Circuit.ArithExpr.denote assignment)).decode program.enums = some input → + (rom.decode program.enums).Provenance input → + ∀ scope ∈ scopes, (before.activation scope).denote assignment = 1 → + (∀ earlier ∈ previous, ¬AllZero earlier assignment) ∧ ∃ bindings body, + selectArm input arms = some (bindings, body) ∧ + ExpressionMeaning program.enums rom sourceCalls (bindings ++ environment) body + (result.map assignment) := by + cases arms with + | nil => + cases scopes with + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp (by simpa only [lowerArms] using compiled) + exact ⟨.refl _, fun _ _ valid => ⟨valid, by simp⟩⟩ + | cons => simp [lowerArms] at compiled + | cons arm arms => + rcases hArm : arm with ⟨pat, body⟩ + rw [hArm] at compiled length + cases scopes with + | nil => simp [lowerArms] at compiled + | cons scope scopes => + simp only [lowerArms] at compiled + obtain ⟨⟨conditions, bindings⟩, patternState, patternRun, guardBind⟩ := bind_ok.mp compiled + obtain ⟨stateEq, patternMeaning⟩ := pattern_correct checked tags patternRun + subst patternState + obtain ⟨⟨⟩, s₁, guardRun, failuresBind⟩ := bind_ok.mp guardBind + obtain ⟨⟨⟩, s₂, failuresRun, bodyBind⟩ := bind_ok.mp failuresBind + obtain ⟨bodyWire, s₃, bodyRun, rest⟩ := bind_ok.mp bodyBind + have guardRun' : (do for condition in conditions do equation scope condition : Build F Unit) + before = .ok ((), s₁) := bind_ok.mpr ⟨(), s₁, guardRun, rfl⟩ + have failuresRun' : (do for earlier in previous do failure scope earlier : Build F Unit) + s₁ = .ok ((), s₂) := bind_ok.mpr ⟨(), s₂, failuresRun, rfl⟩ + have guardExtension := equations_extends guardRun' + obtain ⟨failuresExtension, failuresMeaning⟩ := failures_sound failuresRun' + have beforeBody := guardExtension.trans failuresExtension + obtain ⟨bodyExtension, bodyMeaning⟩ := lower_sound checked tags romValid callSound callProvenance bodyRun + have headExtension := beforeBody.trans bodyExtension + have headFacts (assignment : Witness → F) + (root : (before.activation 0).denote assignment = 1) + (valid : s₃.Valid rom calls assignment) : + before.Valid rom calls assignment ∧ ∀ environment, + DecodesEnvironment program.enums (localsEnvironment locals assignment) environment → + environment.Provenance (rom.decode program.enums) → ∀ input, + (scrutinee.map (Circuit.ArithExpr.denote assignment)).decode program.enums = some input → + (rom.decode program.enums).Provenance input → + (before.activation scope).denote assignment = 1 → + (∀ earlier ∈ previous, ¬AllZero earlier assignment) ∧ ∃ values, + pat.bindings input = some values ∧ + ExpressionMeaning program.enums rom sourceCalls (values ++ environment) body + (result.map assignment) := by + obtain ⟨s₂valid, evaluated⟩ := bodyMeaning assignment (beforeBody.active root) valid + obtain ⟨s₁valid, failed⟩ := failuresMeaning s₂valid + obtain ⟨beforeValid, equations⟩ := equations_sound guardRun' s₁valid + refine ⟨beforeValid, fun environment decoded trusted input inputDecoded inputTrusted active => ?_⟩ + have allZero : AllZero conditions assignment := fun condition member => by + simpa only [active, one_mul] using equations condition member + refine ⟨failed (guardExtension.active active), ?_⟩ + rcases patternMeaning assignment input inputDecoded with + ⟨values, matched, _, bindingsDecoded⟩ | ⟨_, unmatched⟩ + · refine ⟨values, matched, ?_⟩ + have resultMeaning := evaluated (beforeBody.active active) (values ++ environment) + (by simpa only [localsEnvironment_append] using bindingsDecoded.append decoded) + (by + intro binding member + rcases List.mem_append.mp member with member | member + · exact Pattern.bindings_provenance inputTrusted matched binding member + · exact trusted binding member) + simpa only [lower_target bodyRun, WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using resultMeaning + · exact (unmatched allZero).elim + split at rest + · rename_i irrefutable + obtain ⟨_, rfl⟩ := pure_ok.mp rest + have empty : scopes = [] := by + have zero : scopes.length = 0 := by simpa [retainArms, irrefutable] using length + exact List.length_eq_zero_iff.mp zero + subst scopes + refine ⟨headExtension, fun assignment root valid => ?_⟩ + obtain ⟨beforeValid, selected⟩ := headFacts assignment root valid + refine ⟨beforeValid, fun environment decoded trusted input inputDecoded inputTrusted selectedScope member active => ?_⟩ + obtain rfl := List.mem_singleton.mp member + obtain ⟨failed, values, matched, evaluated⟩ := selected environment decoded trusted input inputDecoded inputTrusted active + exact ⟨failed, values, body, by simp [selectArm, matched], evaluated⟩ + · rename_i refutable + simp only [pure_bind] at rest + have tailLength : scopes.length = (retainArms program.enums arms).length := by + simpa [retainArms, refutable] using length + obtain ⟨tailExtension, tailMeaning⟩ := lowerArms_sound checked tags romValid callSound callProvenance tailLength rest + refine ⟨headExtension.trans tailExtension, fun assignment root valid => ?_⟩ + obtain ⟨s₃valid, tails⟩ := tailMeaning assignment (headExtension.active root) valid + obtain ⟨beforeValid, head⟩ := headFacts assignment root s₃valid + refine ⟨beforeValid, fun environment decoded trusted input inputDecoded inputTrusted selected member active => ?_⟩ + rcases List.mem_cons.mp member with rfl | member + · obtain ⟨failed, values, matched, evaluated⟩ := head environment decoded trusted input inputDecoded inputTrusted active + exact ⟨failed, values, body, by simp [selectArm, matched], evaluated⟩ + · obtain ⟨failed, values, selectedBody, matched, evaluated⟩ := + tails environment decoded trusted input inputDecoded inputTrusted selected member (headExtension.active active) + have conditionFailed : ¬AllZero conditions assignment := failed conditions (by simp) + have noMatch : pat.bindings input = none := by + rcases patternMeaning assignment input inputDecoded with + ⟨_, _, conditionsZero, _⟩ | ⟨noMatch, _⟩ + · exact (conditionFailed conditionsZero).elim + · exact noMatch + exact ⟨fun earlier member => failed earlier (List.mem_append_left _ member), + values, selectedBody, by simpa [selectArm, noMatch] using matched, evaluated⟩ + termination_by sizeOf arms + decreasing_by + all_goals simp_all only [Prod.mk.sizeOf_spec, List.cons.sizeOf_spec] + all_goals omega +end + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/ExpressionWitness.lean b/Aiur/Aiur/Optimized/ExpressionWitness.lean new file mode 100644 index 000000000..513a28eb0 --- /dev/null +++ b/Aiur/Aiur/Optimized/ExpressionWitness.lean @@ -0,0 +1,612 @@ +import Aiur.Optimized.ValidationWitness +import Aiur.Optimized.FailureWitness +import Aiur.Optimized.PatternIrrefutable +import Aiur.Optimized.ParameterWitness +import Aiur.Optimized.WitnessContext +import Aiur.Optimized.ArmWitness +import Aiur.Optimized.ExpressionCorrectness +import Aiur.Circuit.ExpressionWitness + +namespace Aiur.Optimized.Compiler + +variable {F : Type} [Field F] [DecidableEq F] +open Circuit.Compiler (Bounded LocalsBounded CallsComplete localsEnvironment localsEnvironment_append) + +set_option maxHeartbeats 5000000 +set_option maxRecDepth 10000 + +mutual + /-- Source evaluation supplies witnesses for the actual scoped compiler, + including a caller-supplied destination for branch results. -/ + theorem lower_complete {program : Program F} (checked : checkDeclarations program.enums = .ok ()) + (tags : program.enums.tagsValid F = true) + {calls : Circuit.CallRelation F} {sourceCalls : Aiur.CallRelation F} + (typed : CallsTyped program sourceCalls) (callComplete : CallsComplete program.enums sourceCalls calls) + {function : String} {locals : Locals F} {scope : ScopeId} {expr : Expr F} + {target : Option (WireValue Witness)} {output : Symbolic F} {before after : State F} + (compiled : lower program function locals scope expr target before = .ok (output, after)) + {rom : WireROM F} {initial : Witness → F} + (stateLayout : before.toReference.WellFormed) (scopeLayout : before.Scoped) + (valid : before.Valid rom calls initial) (scopeValid : scope < before.scopes.size) + (localsBound : LocalsBounded before.roles.size locals) + (targetBound : TargetBound (F := F) before.roles.size target) + (active : (before.activation scope).denote initial = 1) {environment : Environment F} + (decoded : DecodesEnvironment program.enums (localsEnvironment locals initial) environment) + {value : Value F} (targetDecode : TargetDecodes program.enums target initial value) + (evaluated : ROMEvalExprWith program.enums (rom.decode program.enums) sourceCalls environment expr value) : + ∃ assignment, Extension rom calls before after initial assignment ∧ Bounded after.roles.size output ∧ + (output.map (Circuit.ArithExpr.denote assignment)).decode program.enums = some value := by + have allStructure := (lower_scoped compiled scopeLayout scopeValid).1 + rw [lower.eq_def] at compiled + obtain ⟨wire, middle, valueRun, finishRun⟩ := bind_ok.mp compiled + have sameScopes := finish_scopes finishRun + have scopeEq : middle.activation scope = before.activation scope := by + rw [← allStructure.activation_eq scopeValid] + simp only [State.activation, sameScopes] + have body : ∃ assignment, Extension rom calls before middle initial assignment ∧ Bounded middle.roles.size wire ∧ + (wire.map (Circuit.ArithExpr.denote assignment)).decode program.enums = some value := by + cases exprEq : expr with + | literal literal => + rw [exprEq] at evaluated valueRun + cases evaluated + obtain ⟨rfl, rfl⟩ := pure_ok.mp valueRun + exact ⟨initial, .refl stateLayout ((before.valid_iff_reference rom calls initial).mp valid), + Circuit.Compiler.bounded_field.mpr rfl, WireValue.decode_field _ _⟩ + | var name => + rw [exprEq] at evaluated valueRun + cases evaluated with + | var lookup => + cases found : locals.find? (·.1 == name) with + | none => simp [found] at valueRun + | some binding => + rcases binding with ⟨bindingName, result⟩ + have same : bindingName = name := by simpa using List.find?_some found + subst bindingName + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [found] using valueRun) + obtain ⟨actual, actualFound, valueDecode⟩ := decoded.find name + (wire := (name, result.map (Circuit.ArithExpr.denote initial))) + (by simp [localsEnvironment, List.find?_map, Function.comp_def, found]) + have equal := (Prod.mk.inj (Option.some.inj (actualFound.symm.trans lookup))).2 + exact ⟨initial, .refl stateLayout ((before.valid_iff_reference rom calls initial).mp valid), + localsBound _ (List.mem_of_find?_eq_some found), equal ▸ valueDecode⟩ + | tuple items => + rw [exprEq] at evaluated valueRun + cases evaluated with + | tuple itemsEval => + obtain ⟨wires, last, argsRun, finished⟩ := bind_ok.mp valueRun + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, ext, bounds, valuesDecode⟩ := lowerArgs_complete checked tags typed callComplete argsRun + stateLayout scopeLayout valid scopeValid localsBound active decoded itemsEval + exact ⟨a, ext, Circuit.Compiler.bounded_tuple.mpr bounds, by + simpa only [WireValue.map_tuple] using WireValue.decode_tuple checked tags valuesDecode⟩ + | construct name ctor args => + rw [exprEq] at evaluated valueRun + cases evaluated with + | construct argsEval => + cases found : program.enums.findEnum? name with + | none => simp [found] at valueRun + | some definition => + cases atIndex : definition.constructors[definition.constructors.findIdx (·.name == ctor)]? with + | none => simp [found, atIndex] at valueRun + | some constructor => + simp only [found, atIndex] at valueRun + obtain ⟨wires, s₁, argsRun, rest⟩ := bind_ok.mp valueRun + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · rename_i types + obtain ⟨⟨⟩, unchangedState, unchanged, layoutBind⟩ := bind_ok.mp rest + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst unchangedState + obtain ⟨typeLayout, layoutState, layoutRun, shapeBind⟩ := bind_ok.mp layoutBind + obtain ⟨expansion, stateEq⟩ := getLayout_eq layoutRun + subst layoutState + split at shapeBind + · simp [StateT.bind, bind, Except.bind] at shapeBind + · obtain ⟨⟨⟩, unchangedState, unchanged, finished⟩ := bind_ok.mp shapeBind + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst unchangedState + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, ext, valuesBound, argsDecode⟩ := lowerArgs_complete checked tags typed callComplete + argsRun stateLayout scopeLayout valid scopeValid localsBound active decoded argsEval + refine ⟨a, ext, ?_, ?_⟩ + · unfold Bounded + refine Layout.enumWords_all _ _ _ ?_ ?_ + · rfl + · intro polynomial member + simp only [List.mem_append] at member + rcases member with member | member + · obtain ⟨item, member, leaf⟩ := List.mem_flatMap.mp member + exact valuesBound item member polynomial leaf + · have zero : polynomial = .const 0 := List.eq_of_mem_replicate member + subst polynomial; rfl + · have ctorName : constructor.name = ctor := by + simpa using List.findIdx_of_getElem?_eq_some atIndex + have constructed := WireValue.decode_construct checked tags found atIndex argsDecode + (by simpa [Function.comp_def, WireValue.map] using not_ne_iff.mp types) expansion + simpa [ctorName, WireValue.map, List.map_flatMap, List.flatMap_map, + List.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using constructed + | project operand index => + rw [exprEq] at evaluated valueRun + cases evaluated with + | project inputEval projected => + obtain ⟨input, s₁, inputRun, rest⟩ := bind_ok.mp valueRun + rcases input with ⟨type, words⟩ + cases type with + | field | ptr | enum => simp at rest + | tuple types => + dsimp only at rest + obtain ⟨items, last, splitRun, tailBind⟩ := bind_ok.mp rest + obtain ⟨stateEq, reference⟩ := splitValues_reference splitRun + subst last + cases found : items[index]? with + | none => simp [found] at tailBind + | some result => + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [found] using tailBind) + obtain ⟨a, ext, bounds, inputDecode⟩ := lower_complete checked tags typed callComplete inputRun + stateLayout scopeLayout valid scopeValid localsBound (by simp [TargetBound]) active decoded + (by simp [TargetDecodes]) inputEval + obtain ⟨values, rfl, valuesDecode⟩ := Circuit.Compiler.splitValues_decode checked (reference {}) inputDecode + obtain ⟨actual, atValue, valueDecode⟩ := valuesDecode.getElem (index := index) + (wire := result.map (Circuit.ArithExpr.denote a)) (by simp [List.getElem?_map, found]) + have same : actual = value := by simpa [projectValue, atValue, pure, Except.pure] using projected + exact ⟨a, ext, splitValues_bounded splitRun bounds result (List.mem_of_getElem? found), same ▸ valueDecode⟩ + | letValue pat operand body => + rw [exprEq] at evaluated valueRun + cases evaluated with + | letValue inputEval matched bodyEval => + obtain ⟨input, s₁, inputRun, rest⟩ := bind_ok.mp valueRun + obtain ⟨⟨conditions, bindings⟩, s₂, patternRun, restBind⟩ := bind_ok.mp rest + obtain ⟨⟨⟩, s₃, conditionsRun, bodyRun⟩ := bind_ok.mp restBind + obtain ⟨a, inputExt, inputBound, inputDecode⟩ := lower_complete checked tags typed callComplete inputRun + stateLayout scopeLayout valid scopeValid localsBound (by simp [TargetBound]) active decoded + (by simp [TargetDecodes]) inputEval + obtain ⟨inputStructure, inputScoped⟩ := lower_scoped inputRun scopeLayout scopeValid + obtain ⟨stateEq, conditionBound, bindingsBound⟩ := pattern_bounded patternRun inputBound + subst s₂ + have meaning := (pattern_correct checked tags patternRun).2 a _ inputDecode + obtain ⟨bindingDecode, conditionZero⟩ : + DecodesEnvironment program.enums (localsEnvironment bindings a) _ ∧ AllZero conditions a := by + rcases meaning with ⟨environment, actual, zeros, bindingsDecode⟩ | ⟨absent, _⟩ + · have same := Option.some.inj (actual.symm.trans matched) + exact ⟨same ▸ bindingsDecode, zeros⟩ + · rw [matched] at absent; cases absent + have conditionsRun' : (do for c in conditions do equation scope c : Build F Unit) + s₁ = .ok ((), s₃) := bind_ok.mpr ⟨PUnit.unit, s₃, conditionsRun, rfl⟩ + have equationsExt := equations_complete conditionsRun' inputExt.layout inputExt.validAssignment + (inputScoped.activation_bound scope) conditionBound (Or.inr conditionZero) + have equationsScoped := equations_scoped conditionsRun' inputScoped (inputStructure.scopeValid scopeValid) + have equationsScopes := equations_scopes conditionsRun' + have untilBody := inputExt.trans equationsExt + have currentActive : (s₃.activation scope).denote a = 1 := by + simpa only [State.activation, equationsScopes] using + (inputExt.activation inputStructure scopeLayout scopeValid).trans active + have currentScope : scope < s₃.scopes.size := by + rw [equationsScopes]; exact inputStructure.scopeValid scopeValid + obtain ⟨b, bodyExt, bodyBound, resultDecode⟩ := lower_complete checked tags typed callComplete bodyRun + equationsExt.layout equationsScoped equationsExt.validAssignment currentScope + (Circuit.Compiler.localsBounded_append.mpr + ⟨bindingsBound.mono equationsExt.increase, localsBound.mono untilBody.increase⟩) + (targetBound.mono untilBody.increase) currentActive + (by simpa only [localsEnvironment_append] using bindingDecode.append (untilBody.environment localsBound decoded)) + (Extension.targetDecode untilBody targetBound targetDecode) bodyEval + exact ⟨b, untilBody.trans bodyExt, bodyBound, resultDecode⟩ + | store operand => + rw [exprEq] at evaluated valueRun + cases evaluated with + | @store _ _ stored address operandEval cell => + obtain ⟨input, s₁, inputRun, destBind⟩ := bind_ok.mp valueRun + obtain ⟨result, s₂, destRun, shapeBind⟩ := bind_ok.mp destBind + have resultType := (destination_spec destRun).2.2 + rcases result with ⟨resultType', resultWords⟩ + dsimp only at resultType + subst resultType' + cases resultWords with + | nil => simp at shapeBind + | cons addressVar words => cases words with + | cons => simp at shapeBind + | nil => + dsimp only at shapeBind + obtain ⟨⟨⟩, s₃, cellRun, finished⟩ := bind_ok.mp shapeBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, inputExt, inputBound, inputDecode⟩ := lower_complete checked tags typed callComplete inputRun + stateLayout scopeLayout valid scopeValid localsBound (by simp [TargetBound]) active decoded + (by simp [TargetDecodes]) operandEval + obtain ⟨inputStructure, inputScoped⟩ := lower_scoped inputRun scopeLayout scopeValid + obtain ⟨b, destExt, resultBound, resultDecode⟩ := destination_decoded_complete checked tags destRun + inputExt.layout inputExt.validAssignment (.ptr stored.type address) + (by simp only [Value.type]; exact congrArg Ty.ptr (WireValue.decode_spec inputDecode).1) + (by simp) (targetBound.mono inputExt.increase) + (Extension.targetDecode inputExt targetBound targetDecode) + have destScoped := destination_scoped destRun inputScoped + have initialExt := inputExt.trans destExt + have resultDecodeB : ((WireValue.mk (.ptr input.type) [addressVar]).map Polynomial.var |>.map + (Circuit.ArithExpr.denote b)).decode program.enums = some (.ptr stored.type address) := by + simpa only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using resultDecode + have addressEq : b addressVar = address := + (Value.ptr.inj (WireValue.ptr_decoded_eq resultDecode)).2.symm + have ab : (Polynomial.var addressVar : Polynomial F).inBounds s₂.roles.size = true := + resultBound _ (by simp) + have inputDecodeB := destExt.decoded_value inputBound inputDecode + have cellExt := cell_complete cellRun destExt.layout destExt.validAssignment + (destScoped.activation_bound scope) ab + (inputBound.mono destExt.increase) (by + intro _ + obtain ⟨wireValue, rawCell, storedDecode⟩ := WireROM.mem_decode.mp cell + have same := WireValue.decode_injective checked inputDecodeB storedDecode + change (b addressVar, input.map (Circuit.ArithExpr.denote b)) ∈ rom.entries + rw [addressEq, same] + exact rawCell) + exact ⟨b, initialExt.trans cellExt, resultBound.mono cellExt.increase, resultDecodeB⟩ + | load operand => + rw [exprEq] at evaluated valueRun + cases evaluated with + | load pointerEval cell sourceType => + obtain ⟨input, s₁, inputRun, shapeBind⟩ := bind_ok.mp valueRun + rcases input with ⟨type, words⟩ + cases type with + | field | tuple | enum => simp at shapeBind + | ptr pointerType => + cases words with + | nil => simp at shapeBind + | cons address words => cases words with + | cons => simp at shapeBind + | nil => + dsimp only at shapeBind + obtain ⟨result, s₂, destRun, cellBind⟩ := bind_ok.mp shapeBind + obtain ⟨⟨⟩, s₃, cellRun, finished⟩ := bind_ok.mp cellBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, inputExt, inputBound, pointerDecode⟩ := lower_complete checked tags typed callComplete inputRun + stateLayout scopeLayout valid scopeValid localsBound (by simp [TargetBound]) active decoded + (by simp [TargetDecodes]) pointerEval + obtain ⟨inputStructure, inputScoped⟩ := lower_scoped inputRun scopeLayout scopeValid + have pointerEq := WireValue.ptr_decoded_eq pointerDecode + rcases Value.ptr.inj pointerEq with ⟨rfl, addressEq⟩ + rw [addressEq] at cell + obtain ⟨wireValue, rawCell, valueDecode⟩ := WireROM.mem_decode.mp cell + obtain ⟨b, destExt, resultBound, resultDecode⟩ := destination_decoded_complete checked tags destRun + inputExt.layout inputExt.validAssignment value sourceType (WireValue.decode_spec valueDecode).2.1 + (targetBound.mono inputExt.increase) (Extension.targetDecode inputExt targetBound targetDecode) + have resultDecodeB : ((result.map Polynomial.var).map (Circuit.ArithExpr.denote b)).decode + program.enums = some value := by simpa only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using resultDecode + have destScoped := destination_scoped destRun inputScoped + have initialExt := inputExt.trans destExt + have ab := inputBound address (by simp) + have cellExt := cell_complete cellRun destExt.layout destExt.validAssignment + (destScoped.activation_bound scope) (destExt.bound ab) resultBound (by + intro _ + have same := WireValue.decode_injective checked resultDecodeB valueDecode + change (address.denote b, (result.map Polynomial.var).map (Circuit.ArithExpr.denote b)) ∈ rom.entries + rw [same, destExt.polynomial ab] + exact rawCell) + exact ⟨b, initialExt.trans cellExt, resultBound.mono cellExt.increase, resultDecodeB⟩ + | hint type key channel => + rw [exprEq] at evaluated valueRun + cases evaluated with + | hint keyEval valueTyped => + rename_i constant + obtain ⟨input, s₁, keyRun, rest⟩ := bind_ok.mp valueRun + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · obtain ⟨⟨⟩, unchangedState, unchanged, destBind⟩ := bind_ok.mp rest + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst unchangedState + obtain ⟨result, s₂, destRun, validationBind⟩ := bind_ok.mp destBind + obtain ⟨⟨⟩, s₃, validationRun, finished⟩ := bind_ok.mp validationBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, keyExt, _, _⟩ := lower_complete checked tags typed callComplete keyRun + stateLayout scopeLayout valid scopeValid localsBound (by simp [TargetBound]) active decoded + (by simp [TargetDecodes]) keyEval + obtain ⟨keyStructure, keyScoped⟩ := lower_scoped keyRun scopeLayout scopeValid + have valueTyped : constant.type = type ∧ constant.wellFormed program.enums = true := by + simpa [Value.WellTyped, Value.hasType] using valueTyped + obtain ⟨b, destExt, resultBound, resultDecode⟩ := destination_decoded_complete checked tags destRun + keyExt.layout keyExt.validAssignment constant.toValue (by simpa using valueTyped.1) + (by simpa using valueTyped.2) (targetBound.mono keyExt.increase) + (Extension.targetDecode keyExt targetBound targetDecode) + have destScoped := destination_scoped destRun keyScoped + have beforeValidation := keyStructure.trans (destination_extends destRun) + have initialExt := keyExt.trans destExt + have resultDecodeB : ((result.map Polynomial.var).map (Circuit.ArithExpr.denote b)).decode + program.enums = some constant.toValue := by simpa only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using resultDecode + obtain ⟨c, validationExt⟩ := validateValue_complete tags validationRun destExt.layout destScoped + destExt.validAssignment (beforeValidation.scopeValid scopeValid) resultBound + (Or.inr ⟨(Extension.activation initialExt beforeValidation scopeLayout scopeValid).trans active, + constant.toValue, resultDecodeB⟩) + exact ⟨c, initialExt.trans validationExt, resultBound.mono validationExt.increase, + validationExt.decoded_value resultBound resultDecodeB⟩ + | neg operand => + rw [exprEq] at evaluated valueRun + cases evaluated with + | neg inputEval operation => + obtain ⟨input, s₁, inputRun, rest⟩ := bind_ok.mp valueRun + obtain ⟨polynomial, s₂, fieldRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_eq fieldRun + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, ext, bounded, inputDecode⟩ := lower_complete checked tags typed callComplete inputRun + stateLayout scopeLayout valid scopeValid localsBound (by simp [TargetBound]) active decoded + (by simp [TargetDecodes]) inputEval + simp only [WireValue.map_field, WireValue.decode_field, Option.some.injEq] at inputDecode + rw [← inputDecode] at operation + exact ⟨a, ext, by simpa [Scalar.Circuit.ArithExpr.inBounds, State.toReference] using bounded, + by simpa [evalNeg, Scalar.Circuit.ArithExpr.denote] using operation⟩ + | assertEq message left right => + rw [exprEq] at evaluated valueRun + cases evaluated with + | assertEq leftEval rightEval operation => + obtain ⟨_, same, rfl⟩ := evalAssertEq_ok.mp operation + obtain ⟨leftWire, s₁, leftRun, rest⟩ := bind_ok.mp valueRun + obtain ⟨rightWire, s₂, rightRun, restBind⟩ := bind_ok.mp rest + split at restBind + · simp [StateT.bind, bind, Except.bind] at restBind + · obtain ⟨⟨⟩, unchangedState, unchanged, restBind⟩ := bind_ok.mp restBind + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst unchangedState + obtain ⟨⟨⟩, last, equated, finished⟩ := bind_ok.mp restBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, leftExt, leftBound, leftDecode⟩ := lower_complete checked tags typed callComplete leftRun + stateLayout scopeLayout valid scopeValid localsBound (by simp [TargetBound]) active decoded + (by simp [TargetDecodes]) leftEval + obtain ⟨leftStructure, leftScoped⟩ := lower_scoped leftRun scopeLayout scopeValid + obtain ⟨b, rightExt, rightBound, rightDecode⟩ := lower_complete checked tags typed callComplete rightRun + leftExt.layout leftScoped leftExt.validAssignment (leftStructure.scopeValid scopeValid) + (localsBound.mono leftExt.increase) (by simp [TargetBound]) + ((leftExt.activation leftStructure scopeLayout scopeValid).trans active) + (leftExt.environment localsBound decoded) (by simp [TargetDecodes]) rightEval + obtain ⟨_, rightScoped⟩ := lower_scoped rightRun leftScoped (leftStructure.scopeValid scopeValid) + have leftDecodeB := rightExt.decoded_value leftBound leftDecode + rw [same] at leftDecodeB + have equal := WireValue.decode_injective checked leftDecodeB rightDecode + have finalExt := equalValue_complete equated rightExt.layout rightExt.validAssignment + (rightScoped.activation_bound scope) (leftBound.mono rightExt.increase) rightBound (Or.inr equal) + exact ⟨b, (leftExt.trans rightExt).trans finalExt, Circuit.Compiler.bounded_tuple.mpr (by simp), by + simpa only [WireValue.map_tuple, List.map_nil] using + WireValue.decode_tuple checked tags (.nil : DecodesValues program.enums [] [])⟩ + | binary op left right => + rw [exprEq] at evaluated valueRun + cases evaluated with + | binary leftEval rightEval operation => + obtain ⟨leftWire, s₁, leftRun, rest⟩ := bind_ok.mp valueRun + obtain ⟨leftPoly, s₂, leftField, restBind⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_eq leftField + obtain ⟨rightWire, s₃, rightRun, rest⟩ := bind_ok.mp restBind + obtain ⟨rightPoly, s₄, rightField, restBind⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_eq rightField + obtain ⟨a, leftExt, leftBound, leftDecode⟩ := lower_complete checked tags typed callComplete leftRun + stateLayout scopeLayout valid scopeValid localsBound (by simp [TargetBound]) active decoded + (by simp [TargetDecodes]) leftEval + obtain ⟨leftStructure, leftScoped⟩ := lower_scoped leftRun scopeLayout scopeValid + obtain ⟨b, rightExt, rightBound, rightDecode⟩ := lower_complete checked tags typed callComplete rightRun + leftExt.layout leftScoped leftExt.validAssignment (leftStructure.scopeValid scopeValid) + (localsBound.mono leftExt.increase) (by simp [TargetBound]) + ((leftExt.activation leftStructure scopeLayout scopeValid).trans active) + (leftExt.environment localsBound decoded) (by simp [TargetDecodes]) rightEval + obtain ⟨_, rightScoped⟩ := lower_scoped rightRun leftScoped (leftStructure.scopeValid scopeValid) + have chainExt := leftExt.trans rightExt + have lb := Circuit.Compiler.bounded_field.mp (leftBound.mono rightExt.increase) + have rb := Circuit.Compiler.bounded_field.mp rightBound + have leftDecodeB := rightExt.decoded_value leftBound leftDecode + simp only [WireValue.map_field, WireValue.decode_field, Option.some.injEq] at leftDecodeB rightDecode + rw [← leftDecodeB, ← rightDecode] at operation + cases op with + | add | sub | mul => + obtain ⟨rfl, rfl⟩ := pure_ok.mp restBind + exact ⟨b, chainExt, by simpa [Scalar.Circuit.ArithExpr.inBounds, State.toReference] using And.intro lb rb, + by simpa [evalBinOp, Scalar.Circuit.ArithExpr.denote] using operation⟩ + | div => + have nonzero : rightPoly.denote b ≠ 0 := by + intro zero + simp [evalBinOp, zero] at operation + have quotient : Value.field (leftPoly.denote b / rightPoly.denote b) = value := by + simpa [evalBinOp, nonzero] using operation + cases folded : rightPoly.constantInverse? with + | some inverse => + simp only [folded] at restBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp restBind + refine ⟨b, chainExt, ?_, ?_⟩ + · simpa [Scalar.Circuit.ArithExpr.inBounds, State.toReference] using lb + · simp only [WireValue.map_field, WireValue.decode_field, Option.some.injEq] + change Value.field (leftPoly.denote b * inverse) = value + rw [(Polynomial.constantInverse?_sound folded b).2, ← div_eq_mul_inv] + exact quotient + | none => + simp only [folded] at restBind + obtain ⟨inverse, s₅, freshRun, rest⟩ := bind_ok.mp restBind + obtain ⟨⟨⟩, s₆, inverseRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨c, freshExt, inverseBound, inverseEq⟩ := fresh_complete freshRun rightExt.layout + rightExt.validAssignment (rightPoly.denote b)⁻¹ + have freshScoped := fresh_scoped freshRun rightScoped + have ib : (Polynomial.var inverse : Polynomial F).inBounds s₅.roles.size = true := by + simpa [Scalar.Circuit.ArithExpr.inBounds, State.toReference] using inverseBound + have inverseExt := equation_complete inverseRun freshExt.layout freshExt.validAssignment (by + simpa only [Scalar.Circuit.ArithExpr.inBounds, Bool.and_eq_true, and_true, State.toReference] using + And.intro (freshScoped.activation_bound scope) (And.intro (freshExt.bound rb) ib)) (by + change (s₅.activation scope).denote c * (rightPoly.denote c * c inverse - 1) = 0 + rw [freshExt.polynomial rb, inverseEq] + simp [nonzero]) + refine ⟨c, (chainExt.trans freshExt).trans inverseExt, ?_, ?_⟩ + · simpa [Scalar.Circuit.ArithExpr.inBounds, State.toReference] using + And.intro ((freshExt.trans inverseExt).bound lb) (inverseExt.bound ib) + · simp only [WireValue.map_field, WireValue.decode_field, Option.some.injEq] + change Value.field (leftPoly.denote c * c inverse) = value + rw [freshExt.polynomial lb, inverseEq, ← div_eq_mul_inv] + exact quotient + | call name args => + rw [exprEq] at evaluated valueRun + cases evaluated with + | call argsEval calleeEval => + cases found : program.findSignature? name with + | none => simp [found] at valueRun + | some callee => + simp only [found] at valueRun + obtain ⟨arguments, s₁, argsRun, rest⟩ := bind_ok.mp valueRun + split at rest + · simp [StateT.bind, bind, Except.bind] at rest + · obtain ⟨⟨⟩, unchangedState, unchanged, destBind⟩ := bind_ok.mp rest + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst unchangedState + obtain ⟨result, s₂, destRun, callBind⟩ := bind_ok.mp destBind + obtain ⟨⟨⟩, s₅, callRun, finished⟩ := bind_ok.mp callBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, argsExt, argsBound, argsDecode⟩ := lowerArgs_complete checked tags typed callComplete argsRun + stateLayout scopeLayout valid scopeValid localsBound active decoded argsEval + obtain ⟨argsStructure, argsScoped⟩ := lowerArgs_scoped argsRun scopeLayout scopeValid + have resultType := typed _ _ _ calleeEval callee found + obtain ⟨b, destExt, resultBound, resultDecode⟩ := destination_decoded_complete checked tags destRun + argsExt.layout argsExt.validAssignment value resultType.1 resultType.2 + (targetBound.mono argsExt.increase) (Extension.targetDecode argsExt targetBound targetDecode) + have resultDecodeB : ((result.map Polynomial.var).map (Circuit.ArithExpr.denote b)).decode program.enums = + some value := by simpa only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using resultDecode + have destScoped := destination_scoped destRun argsScoped + have initialExt := argsExt.trans destExt + have callExt := call_complete callRun destExt.layout destExt.validAssignment + (destScoped.activation_bound scope) + (fun arg member => (argsBound arg member).mono destExt.increase) + resultBound (by + intro _ + exact callComplete name _ value calleeEval _ _ + (destExt.decoded_values argsBound argsDecode) resultDecode) + exact ⟨b, initialExt.trans callExt, resultBound.mono callExt.increase, resultDecodeB⟩ + | matchValue scrutinee arms => + rw [exprEq] at evaluated valueRun + have allEval := evaluated + cases evaluated with + | matchValue inputEval selected branchEval => + obtain ⟨⟨⟩, checkState, checkRun, typeBind⟩ := bind_ok.mp valueRun + obtain ⟨_, stateEq⟩ := lift_eq_ok checkRun + subst checkState + obtain ⟨type, typeState, typeRun, inputBind⟩ := bind_ok.mp typeBind + obtain ⟨inferred, stateEq⟩ := lift_eq_ok typeRun + subst typeState + have typeChecked : inferType program function (environmentTypes environment) + (.matchValue scrutinee arms) = .ok type := by + rw [Circuit.Compiler.decoded_environment_types decoded] + cases h : inferType program function (locals.map fun (name, value) => (name, value.type)) + (.matchValue scrutinee arms) <;> simp_all [Except.mapError] + have resultType := allEval.wellTyped typed (WireROM.decode_wellFormed program.enums rom) + decoded.wellFormed function type typeChecked + obtain ⟨input, s₁, inputRun, destBind⟩ := bind_ok.mp inputBind + obtain ⟨result, s₂, destRun, choiceBind⟩ := bind_ok.mp destBind + obtain ⟨branches, s₄, choiceRun, armsBind⟩ := bind_ok.mp choiceBind + obtain ⟨⟨⟩, s₅, armsRun, finished⟩ := bind_ok.mp armsBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, inputExt, inputBound, inputDecode⟩ := lower_complete checked tags typed callComplete inputRun + stateLayout scopeLayout valid scopeValid localsBound (by simp [TargetBound]) active decoded + (by simp [TargetDecodes]) inputEval + obtain ⟨inputStructure, inputScoped⟩ := lower_scoped inputRun scopeLayout scopeValid + obtain ⟨b, destExt, resultBound, resultDecode⟩ := destination_decoded_complete checked tags destRun + inputExt.layout inputExt.validAssignment value resultType.1 resultType.2 + (targetBound.mono inputExt.increase) (Extension.targetDecode inputExt targetBound targetDecode) + have resultDecodeB : ((result.map Polynomial.var).map (Circuit.ArithExpr.denote b)).decode program.enums = + some value := by simpa only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using resultDecode + have destScoped := destination_scoped destRun inputScoped + have beforeChoice := inputStructure.trans (destination_extends destRun) + have untilChoice := inputExt.trans destExt + have inputDecodeC := destExt.decoded_value inputBound inputDecode + have indexBound := lowerArms_index_lt checked tags armsRun inputDecodeC selected + let chosen : Fin (retainArms program.enums arms).length := ⟨_, by + rw [← choice_length choiceRun] + exact indexBound⟩ + obtain ⟨d, choiceExt, choices⟩ := choice_complete choiceRun destExt.layout destScoped + destExt.validAssignment (some chosen) (by + simpa using (Extension.activation untilChoice beforeChoice scopeLayout scopeValid).trans active) + have untilArms := untilChoice.trans choiceExt + have bodyCompletes : ∀ arm ∈ arms, ExprComplete program sourceCalls calls function arm.2 := by + intro arm member + have smaller : sizeOf arm.2 < sizeOf (Expr.matchValue scrutinee arms) := by + have bound := List.sizeOf_lt_of_mem member + cases arm + simp_all only [Prod.mk.sizeOf_spec, Expr.matchValue.sizeOf_spec] + omega + intro branchLocals branchScope branchTarget branchOutput first last branchRun branchROM branchInitial + branchLayout branchScoped branchValid branchScopeValid branchLocalsBound branchTargetBound + branchActive branchEnvironment branchEnvironmentDecode branchValue branchTargetDecode branchEval + exact lower_complete checked tags typed callComplete branchRun branchLayout branchScoped branchValid + branchScopeValid branchLocalsBound branchTargetBound branchActive branchEnvironmentDecode + branchTargetDecode branchEval + obtain ⟨e, armsExt⟩ := lowerArms_complete checked tags bodyCompletes armsRun choiceExt.layout + (choice_scoped choiceRun destScoped) choiceExt.validAssignment (choice_child_bound choiceRun) + (localsBound.mono untilArms.increase) + (inputBound.mono (destExt.trans choiceExt).increase) + (resultBound.mono choiceExt.increase) (by simp) + (untilArms.environment localsBound decoded) + ((destExt.trans choiceExt).decoded_value inputBound inputDecode) + (by simpa only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using + choiceExt.decoded_value resultBound resultDecodeB) + selected branchEval (by + intro i + simpa only [choiceSelected, Option.map_some, Option.some.injEq, chosen, eq_comm] using choices i) + (by simp) + exact ⟨e, untilArms.trans armsExt, resultBound.mono (choiceExt.trans armsExt).increase, + (choiceExt.trans armsExt).decoded_value resultBound resultDecodeB⟩ + obtain ⟨assignment, ext, bounded, decodedWire⟩ := body + cases target with + | none => + obtain ⟨rfl, rfl⟩ := pure_ok.mp finishRun + exact ⟨assignment, ext, bounded, decodedWire⟩ + | some candidate => + obtain ⟨⟨⟩, last, equalRun, finished⟩ := bind_ok.mp finishRun + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + have candidateBound := (targetBound candidate rfl).mono ext.increase + have candidateDecoded := Extension.targetDecode ext targetBound targetDecode candidate rfl + have canonical : ((candidate.map Polynomial.var).map (Circuit.ArithExpr.denote assignment)).decode program.enums = some value := by + simpa only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using candidateDecoded + have equality := WireValue.decode_injective checked canonical decodedWire + have finishExt := equalValue_complete equalRun ext.layout ext.validAssignment + (by rw [scopeEq]; exact ext.bound (scopeLayout.activation_bound scope)) + candidateBound bounded (Or.inr equality) + exact ⟨assignment, ext.trans finishExt, candidateBound.mono finishExt.increase, canonical⟩ + termination_by sizeOf expr + decreasing_by + all_goals subst expr + all_goals simp_wf + all_goals try simp only [Expr.matchValue.sizeOf_spec] at smaller + all_goals omega + + theorem lowerArgs_complete {program : Program F} (checked : checkDeclarations program.enums = .ok ()) + (tags : program.enums.tagsValid F = true) + {calls : Circuit.CallRelation F} {sourceCalls : Aiur.CallRelation F} + (typed : CallsTyped program sourceCalls) (callComplete : CallsComplete program.enums sourceCalls calls) + {function : String} {locals : Locals F} {scope : ScopeId} {args : List (Expr F)} + {outputs : List (Symbolic F)} {before after : State F} + (compiled : lowerArgs program function locals scope args before = .ok (outputs, after)) + {rom : WireROM F} {initial : Witness → F} + (stateLayout : before.toReference.WellFormed) (scopeLayout : before.Scoped) + (valid : before.Valid rom calls initial) (scopeValid : scope < before.scopes.size) + (localsBound : LocalsBounded before.roles.size locals) + (active : (before.activation scope).denote initial = 1) {environment : Environment F} + (decoded : DecodesEnvironment program.enums (localsEnvironment locals initial) environment) + {values : List (Value F)} + (evaluated : ROMEvalArgsWith program.enums (rom.decode program.enums) sourceCalls environment args values) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + (∀ output ∈ outputs, Bounded after.roles.size output) ∧ + DecodesValues program.enums (outputs.map (WireValue.map (Circuit.ArithExpr.denote assignment))) values := by + cases args with + | nil => + cases evaluated + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [lowerArgs] using compiled) + exact ⟨initial, .refl stateLayout ((before.valid_iff_reference rom calls initial).mp valid), by simp, .nil⟩ + | cons arg args => + cases evaluated with + | cons headEval tailEval => + simp only [lowerArgs] at compiled + obtain ⟨head, middle, headRun, rest⟩ := bind_ok.mp compiled + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, headExt, headBound, headDecode⟩ := lower_complete checked tags typed callComplete headRun + stateLayout scopeLayout valid scopeValid localsBound (by simp [TargetBound]) active decoded + (by simp [TargetDecodes]) headEval + obtain ⟨headStructure, headScoped⟩ := lower_scoped headRun scopeLayout scopeValid + obtain ⟨b, tailExt, tailBound, tailDecode⟩ := lowerArgs_complete checked tags typed callComplete tailRun + headExt.layout headScoped headExt.validAssignment (headStructure.scopeValid scopeValid) + (localsBound.mono headExt.increase) ((headExt.activation headStructure scopeLayout scopeValid).trans active) + (headExt.environment localsBound decoded) tailEval + refine ⟨b, headExt.trans tailExt, ?_, .cons (tailExt.decoded_value headBound headDecode) tailDecode⟩ + intro output member + rcases List.mem_cons.mp member with rfl | member + · exact headBound.mono tailExt.increase + · exact tailBound output member + termination_by sizeOf args +end + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/FailureWitness.lean b/Aiur/Aiur/Optimized/FailureWitness.lean new file mode 100644 index 000000000..3a00b076c --- /dev/null +++ b/Aiur/Aiur/Optimized/FailureWitness.lean @@ -0,0 +1,45 @@ +import Aiur.Optimized.ScopedInvariant + +namespace Aiur.Optimized.Compiler + +variable {F : Type} [Field F] [DecidableEq F] +set_option maxHeartbeats 1500000 +set_option maxRecDepth 4096 + +theorem failures_complete {scope : ScopeId} {previous : List (List (Polynomial F))} {before after : State F} + (compiled : (do for earlier in previous do failure scope earlier : Build F Unit) + before = .ok ((), after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (scopeLayout : before.Scoped) + (valid : before.Valid rom calls initial) (scopeValid : scope < before.scopes.size) + (bounded : ∀ earlier ∈ previous, ∀ condition ∈ earlier, condition.inBounds before.roles.size = true) + (failed : (before.activation scope).denote initial = 0 ∨ + ∀ earlier ∈ previous, ¬AllZero earlier initial) : + ∃ assignment, Extension rom calls before after initial assignment := by + induction previous generalizing before initial with + | nil => + have same : before = after := by + simpa [List.forIn_nil, pure, StateT.pure, StateT.bind, bind, Except.bind, Except.pure] using compiled + subst after + exact ⟨initial, .refl layout ((before.valid_iff_reference rom calls initial).mp valid)⟩ + | cons earlier previous ih => + simp only [List.forIn_cons, bind_assoc, pure_bind] at compiled + obtain ⟨⟨⟩, middle, headRun, tailRun⟩ := bind_ok.mp compiled + obtain ⟨a, headExt⟩ := failure_complete headRun layout valid (scopeLayout.activation_bound scope) + (bounded earlier (by simp)) (failed.imp_right (fun failures => failures earlier (by simp))) + obtain ⟨headStructure, headScoped⟩ := failure_scoped headRun scopeLayout scopeValid + obtain ⟨b, tailExt⟩ := ih tailRun headExt.layout headScoped headExt.validAssignment + (headStructure.scopeValid scopeValid) + (fun earlier member p leaf => headExt.bound (bounded earlier (by simp [member]) p leaf)) (by + rw [headExt.activation headStructure scopeLayout scopeValid] + rcases failed with inactive | failures + · exact Or.inl inactive + · right + intro earlier member zero + apply failures earlier (by simp [member]) + intro p leaf + rw [← headExt.polynomial (bounded earlier (by simp [member]) p leaf)] + exact zero p leaf) + exact ⟨b, headExt.trans tailExt⟩ + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/Grouping.lean b/Aiur/Aiur/Optimized/Grouping.lean new file mode 100644 index 000000000..07141cff2 --- /dev/null +++ b/Aiur/Aiur/Optimized/Grouping.lean @@ -0,0 +1,201 @@ +import Aiur.Optimized.Activation + +/-! Function grouping preserves logical call identities. Members share data +columns, while columns needed to silence cubic constraints and lookup enables +are private. A quadratic constraint may acquire a member selector; a cubic +constraint is retained only after checking that private zeroes silence it. +The construction does not assume a field characteristic or a group-size bound. +-/ +namespace Aiur.Optimized.Grouping + +open Circuit +variable {F : Type} [Field F] [DecidableEq F] + +def erase (privateCols : List Nat) (p : Polynomial F) : Polynomial F := + (p.subst fun v => if privateCols.contains v then .const 0 else .var v).simplify + +def silent (privateCols : List Nat) (p : Polynomial F) : Bool := + erase privateCols p == .const 0 + +theorem silent_zero {privateCols : List Nat} {p : Polynomial F} + (checked : silent privateCols p = true) (a : Nat → F) + (zero : ∀ v ∈ privateCols, a v = 0) : p.denote a = 0 := by + have equal : erase privateCols p = .const 0 := Polynomial.beq_eq _ _ |>.mp checked + have h := congrArg (fun p : Polynomial F => p.denote a) equal + simp only [erase, Polynomial.denote_simplify, Polynomial.denote_subst] at h + have same : (fun v => (if privateCols.contains v then Polynomial.const 0 else .var v).denote a) = a := by + funext v + by_cases member : v ∈ privateCols + · simp [member, Scalar.Circuit.ArithExpr.denote, zero v member] + · simp [member, Scalar.Circuit.ArithExpr.denote] + simpa only [same, Scalar.Circuit.ArithExpr.denote] using h + +def gate (selector : Nat) (privateCols : List Nat) (p : Polynomial F) : Polynomial F := + if silent privateCols p then p else .mul (.var selector) p + +@[simp] theorem gate_active (selector : Nat) (privateCols : List Nat) (p : Polynomial F) + (a : Nat → F) (active : a selector = 1) : + (gate selector privateCols p).denote a = p.denote a := by + unfold gate + split <;> simp [Scalar.Circuit.ArithExpr.denote, active] + +theorem gate_inactive (selector : Nat) (privateCols : List Nat) (p : Polynomial F) + (a : Nat → F) (inactive : a selector = 0) + (zero : ∀ v ∈ privateCols, a v = 0) : + (gate selector privateCols p).denote a = 0 := by + unfold gate + split + · exact silent_zero ‹_› a zero + · simp [Scalar.Circuit.ArithExpr.denote, inactive] + +def privateZero (selector column : Nat) : Polynomial F := + .mul (.sub (.const 1) (.var selector)) (.var column) + +def member (source : Chip F) (selector : Nat) (privateCols : List Nat) : Chip F := + { source with constraints := source.constraints.map (gate selector privateCols) ++ + privateCols.map (privateZero selector) } + +theorem member_active (source : Chip F) (selector : Nat) (privateCols : List Nat) + (a : Nat → F) (active : a selector = 1) : + (member source selector privateCols).ValidAssignment rom a ↔ source.ValidAssignment rom a := by + constructor + · intro h + refine ⟨?_, h.2⟩ + intro p hp + have h := h.1 _ (List.mem_append_left _ (List.mem_map.mpr ⟨p, hp, rfl⟩)) + simpa only [gate_active _ _ _ _ active] using h + · intro h + refine ⟨?_, h.2⟩ + intro p hp + rcases List.mem_append.mp hp with hp | hp + · obtain ⟨q, hq, rfl⟩ := List.mem_map.mp hp + simpa only [gate_active _ _ _ _ active] using h.1 q hq + · obtain ⟨v, _, rfl⟩ := List.mem_map.mp hp + simp [privateZero, Scalar.Circuit.ArithExpr.denote, active] + +theorem member_private_zero (source : Chip F) (selector : Nat) (privateCols : List Nat) + (a : Nat → F) (valid : (member source selector privateCols).ValidAssignment rom a) + (inactive : a selector = 0) (v : Nat) (present : v ∈ privateCols) : a v = 0 := by + have h := valid.1 (privateZero selector v) + (List.mem_append_right _ (List.mem_map.mpr ⟨v, present, rfl⟩)) + simpa [privateZero, Scalar.Circuit.ArithExpr.denote, inactive] using h + +theorem member_inactive (source : Chip F) (selector : Nat) (privateCols : List Nat) + (quiet : ∀ m ∈ source.memory, silent privateCols m.enable = true) + (a : Nat → F) (inactive : a selector = 0) (zero : ∀ v ∈ privateCols, a v = 0) : + (member source selector privateCols).ValidAssignment rom a := by + refine ⟨?_, ?_⟩ + · intro p present + rcases List.mem_append.mp present with present | present + · obtain ⟨p, _, rfl⟩ := List.mem_map.mp present + exact gate_inactive _ _ _ _ inactive zero + · obtain ⟨v, hv, rfl⟩ := List.mem_map.mp present + simp [privateZero, Scalar.Circuit.ArithExpr.denote, zero v hv] + · intro m present + have h := silent_zero (quiet m present) a zero + simp [MemoryLookup.Valid, h] + +theorem requirements_inactive (source : Chip F) (privateCols : List Nat) + (quiet : ∀ s ∈ source.sends, silent privateCols s.enable = true) + (a : Nat → F) (zero : ∀ v ∈ privateCols, a v = 0) : source.requirements a = [] := by + apply List.filterMap_eq_nil_iff.mpr + intro s present + simp [silent_zero (quiet s present) a zero] + +/-- The selected member recovers the original finite-row local rule. This is +the same interface used by Physical.Prepared's source-correctness theorem; +grouping changes neither the conclusion nor its constrained call premises. -/ +theorem selected_member_sound (source : Chip F) (formed : source.wellFormed = true) + (privateCols : List Nat) (a : Nat → F) + (valid : (member (Activation.compile source) source.numVars privateCols).ValidAssignment rom a) + (active : a source.numVars = 1) : + source.LocalRule rom (source.conclusion a) ((Activation.compile source).requirements a) := by + have activated := (member_active _ _ _ _ active).mp valid + have original := (Activation.valid_active_iff source a active).mp activated + have finite := source.finiteAssignment formed a rom + refine ⟨Row.ofAssignment source.name source.numVars a, rfl, + ⟨formed, Row.ofAssignment_length _ _ _, finite.1.mp original⟩, finite.2.1.symm, ?_⟩ + exact finite.2.2.symm.trans (Activation.requirements_active source a active).symm + +theorem selected_member_complete (source : Chip F) (privateCols : List Nat) + (a : Nat → F) (valid : source.ValidAssignment rom a) (active : a source.numVars = 1) : + (member (Activation.compile source) source.numVars privateCols).ValidAssignment rom a := + (member_active _ _ _ _ active).mpr ((Activation.valid_active_iff source a active).mpr valid) + +omit [DecidableEq F] in +/-- A shared message argument of degree two can be materialized in one private +column without increasing the maximum constraint degree. -/ +theorem private_value_iff (s value witness : F) (boolean : s = 0 ∨ s = 1) : + (s * (witness - value) = 0 ∧ (1 - s) * witness = 0) ↔ witness = s * value := by + rcases boolean with rfl | rfl <;> simp [sub_eq_zero] + +/-- Prefix exclusion is linear in the group size and sound in every field, +including characteristic two. No unchecked cast of the group size is used. -/ +def Exclusive : List F → Prop + | [] => True + | s :: ss => (s = 0 ∨ s = 1) ∧ s * ss.sum = 0 ∧ Exclusive ss + +omit [DecidableEq F] in +theorem exclusive_sum {ss : List F} (valid : Exclusive ss) : ss.sum = 0 ∨ ss.sum = 1 := by + induction ss with + | nil => simp + | cons s ss ih => + rcases valid with ⟨hs, cross, tail⟩ + rcases hs with rfl | rfl + · simpa using ih tail + · have sum : ss.sum = 0 := by simpa using cross + simp [sum] + +omit [DecidableEq F] in +theorem exclusive_zero {ss : List F} (valid : Exclusive ss) (zero : ss.sum = 0) : + ∀ s ∈ ss, s = 0 := by + induction ss with + | nil => simp + | cons s ss ih => + rcases valid with ⟨hs, cross, tail⟩ + rcases hs with rfl | rfl + · have sum : ss.sum = 0 := by simpa using zero + intro v hv + rcases List.mem_cons.mp hv with rfl | hv + · rfl + · exact ih tail sum v hv + · have sum : ss.sum = 0 := by simpa using cross + simp [sum] at zero + +omit [DecidableEq F] in +theorem exclusive_unique {ss : List F} (valid : Exclusive ss) : + ss = ss.map (fun _ => (0 : F)) ∨ ∃ left right, + ss = left ++ 1 :: right ∧ (∀ s ∈ left, s = 0) ∧ (∀ s ∈ right, s = 0) := by + induction ss with + | nil => simp + | cons s ss ih => + rcases valid with ⟨hs, cross, tail⟩ + rcases hs with rfl | rfl + · rcases ih tail with zero | ⟨left, right, same, hl, hr⟩ + · exact Or.inl (by simpa using congrArg (List.cons 0) zero) + · refine Or.inr ⟨0 :: left, right, by simp [same], ?_, hr⟩ + intro v hv + rcases List.mem_cons.mp hv with rfl | hv + · rfl + · exact hl v hv + · have sum : ss.sum = 0 := by simpa using cross + exact Or.inr ⟨[], ss, rfl, by simp, exclusive_zero tail sum⟩ + +omit [DecidableEq F] in +/-- Superposing a lookup slot preserves exactly the active member's argument +(and multiplicity). Applies independently to every padded argument position; +the channel and callable/ROM-width identity are positions in that same slot. -/ +theorem superpose_selected (left right : List F) (selected : F) + (before : ∀ x ∈ left, x = 0) (after : ∀ x ∈ right, x = 0) : + (left ++ selected :: right).sum = selected := by + have hl : left.sum = 0 := List.sum_eq_zero before + have hr : right.sum = 0 := List.sum_eq_zero after + simp [hl, hr] + +omit [DecidableEq F] in +/-- If the complete row is padding, the provider multiplicity must vanish. -/ +theorem inactive_count (s count : F) (inactive : s = 0) + (guard : (1 - s) * count = 0) : count = 0 := by + simpa [inactive] using guard + +end Aiur.Optimized.Grouping diff --git a/Aiur/Aiur/Optimized/Grouping/Certificate.lean b/Aiur/Aiur/Optimized/Grouping/Certificate.lean new file mode 100644 index 000000000..d6b4c9252 --- /dev/null +++ b/Aiur/Aiur/Optimized/Grouping/Certificate.lean @@ -0,0 +1,202 @@ +import Aiur.Optimized.Grouping.Payload + +namespace Aiur.Optimized.Grouping +open Circuit +variable {F : Type} [Field F] [DecidableEq F] + +deriving instance DecidableEq for Lookup +deriving instance DecidableEq for Member + +def Member.project (m : Member F) (v : Nat) : Polynomial F := .var (m.columns[v]?.getD 0) + +def Implied (constraints : List (Polynomial F)) (p : Polynomial F) : Prop := + p.Identical (.const 0) ∨ ∃ q ∈ constraints, p.Identical q + +instance (constraints : List (Polynomial F)) (p : Polynomial F) : Decidable (Implied constraints p) := by + unfold Implied + infer_instance + +theorem Implied.sound {cs : List (Polynomial F)} {p : Polynomial F} (h : Implied cs p) + (a : Nat → F) (valid : Satisfies cs a) : p.denote a = 0 := by + rcases h with h | ⟨q, hq, same⟩ + · exact h.denote a + · exact (same.denote a).trans (valid q hq) + +/-- A cheap structural filter; coefficients are deliberately ignored so this +does not require a hashing interface on the field. Collisions still undergo +the full polynomial comparison and have no bearing on correctness. -/ +def equationKey : Polynomial F → UInt64 + | .const _ => 1 + | .var v => v.toUInt64 * 1099511628211 + 3 + | .add a b => ((equationKey a * 1099511628211) ^^^ equationKey b) + 5 + | .sub a b => ((equationKey a * 1099511628211) ^^^ equationKey b) + 7 + | .mul a b => ((equationKey a * 1099511628211) ^^^ equationKey b) + 11 + +/-- Normalize and fingerprint source equations once per member. The key only +filters comparisons; the proposition remains full polynomial equality. -/ +def allImpliedDecidable (cs ps : List (Polynomial F)) (replacement : Nat → Polynomial F) : + Decidable (∀ p ∈ ps, Implied cs (p.subst replacement)) := by + let normalized := cs.map fun q => (equationKey q.normalForm, q.normalForm) + let wanted := ps.map fun p => + let n := (p.subst replacement).normalForm + (equationKey n, n) + apply decidable_of_iff (∀ p ∈ wanted, + p.2 = Polynomial.normalForm (.const (0 : F)) ∨ + ∃ q ∈ normalized, p.1 = q.1 ∧ p.2 = q.2) + simp only [wanted, List.forall_mem_map] + simp [normalized, Implied, Polynomial.Identical, eq_comm] + constructor + · intro h p hp + rcases h p hp with h | ⟨q, hq, _, same⟩ + · exact Or.inl h + · exact Or.inr ⟨q, hq, same⟩ + · intro h p hp + rcases h p hp with h | ⟨q, hq, same⟩ + · exact Or.inl h + · exact Or.inr ⟨q, hq, congrArg equationKey same, same⟩ + +/-- Finite checks over actual output expressions and actual constraints. +All conditions are decidable polynomial/structural comparisons. -/ +structure Certificate (sources : List (Chip F)) (g : Layout F) : Prop where + sources_eq : g.members.map Member.origin = sources + shapes : ∀ m ∈ g.members, m.Shape + names : ∀ m ∈ g.members, m.name = m.origin.name + formed : ∀ m ∈ g.members, m.origin.wellFormed = true + unique : ∀ m ∈ g.members, ∀ n ∈ g.members, m.selector = n.selector → m = n + project_payload : ∀ m ∈ g.members, + ((g.view m).subst (g.back (some m.selector))).Identical ((ofChip m.origin).subst m.project) + extend_payload : ∀ m ∈ g.members, + ((g.view m).subst m.embedding).Identical (ofChip m.origin) + extend_constraints : ∀ m ∈ g.members, ∀ p ∈ g.constraints, + Implied m.origin.constraints (p.subst m.embedding) + extend_selectors : ∀ m ∈ g.members, ∀ n ∈ g.members, + (m.embedding n.selector).Identical (.const (selected (some m.selector) n)) + extend_activation : ∀ m ∈ g.members, + (g.activation.subst m.embedding).Identical (.const 1) + zero_constraints : Satisfies g.constraints (fun _ => 0) + +instance (sources : List (Chip F)) (g : Layout F) : Decidable (Certificate sources g) := by + letI (m : Member F) : Decidable (∀ p ∈ g.constraints, + Implied m.origin.constraints (p.subst m.embedding)) := + allImpliedDecidable m.origin.constraints g.constraints m.embedding + letI : Decidable (Satisfies g.constraints (fun _ => (0 : F))) := by + unfold Satisfies Scalar.Circuit.Satisfies + infer_instance + apply decidable_of_iff ((g.members.map Member.origin = sources) ∧ + (∀ m ∈ g.members, m.Shape) ∧ + (∀ m ∈ g.members, m.name = m.origin.name) ∧ + (∀ m ∈ g.members, m.origin.wellFormed = true) ∧ + (∀ m ∈ g.members, ∀ n ∈ g.members, m.selector = n.selector → m = n) ∧ + (∀ m ∈ g.members, + ((g.view m).subst (g.back (some m.selector))).Identical ((ofChip m.origin).subst m.project)) ∧ + (∀ m ∈ g.members, + ((g.view m).subst m.embedding).Identical (ofChip m.origin)) ∧ + (∀ m ∈ g.members, ∀ p ∈ g.constraints, + Implied m.origin.constraints (p.subst m.embedding)) ∧ + (∀ m ∈ g.members, ∀ n ∈ g.members, + (m.embedding n.selector).Identical (.const (selected (some m.selector) n))) ∧ + (∀ m ∈ g.members, + (g.activation.subst m.embedding).Identical (.const 1)) ∧ + (Satisfies g.constraints (fun _ => 0))) + constructor + · rintro ⟨h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10⟩ + exact ⟨h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10⟩ + · intro h + exact ⟨h.sources_eq, h.shapes, h.names, h.formed, h.unique, h.project_payload, h.extend_payload, h.extend_constraints, h.extend_selectors, h.extend_activation, h.zero_constraints⟩ + +namespace Certificate +variable {sources : List (Chip F)} {g : Layout F} + +theorem payload_project (checked : Certificate sources g) (m : Member F) (hm : m ∈ g.members) + (a : Nat → F) (valid : Satisfies g.constraints a) + (selectors : ∀ n ∈ g.members, a n.selector = selected (some m.selector) n) : + (g.view m).denote a = (ofChip m.origin).denote (fun v => a (m.columns[v]?.getD 0)) := by + have same := (checked.project_payload m hm).denote a + have back := g.back_sound checked.shapes a valid (some m.selector) selectors + simpa only [Payload.denote_subst, back, Member.project, Scalar.Circuit.ArithExpr.denote] using same + +theorem payload_extend (checked : Certificate sources g) (m : Member F) (hm : m ∈ g.members) + (a : Nat → F) : + (g.view m).denote (fun v => (m.embedding v).denote a) = (ofChip m.origin).denote a := by + simpa only [Payload.denote_subst] using (checked.extend_payload m hm).denote a + +theorem project_valid (checked : Certificate sources g) (m : Member F) (hm : m ∈ g.members) + (a : Nat → F) (valid : g.ValidRow rom a) (active : a m.selector = 1) : + m.origin.ValidAssignment rom (fun v => a (m.columns[v]?.getD 0)) ∧ + (g.view m).denote a = (ofChip m.origin).denote (fun v => a (m.columns[v]?.getD 0)) := by + obtain ⟨n, hn, _, selectors⟩ := g.select checked.shapes a valid.1 valid.2.1 + have sameSelector : n.selector = m.selector := by + have h := selectors m hm + by_contra hne + simp [selected, hne, active] at h + have same := checked.unique n hn m hm sameSelector + subst n + have payload := checked.payload_project m hm a valid.1 selectors + have memory := valid.2.2 m hm active + rw [payload, ofChip_memory] at memory + let b := fun v : Nat => a (m.columns[v]?.getD 0) + have on : b m.sourceSelector = 1 := by simpa [b, ← (checked.shapes m hm).1] using active + have activatedMemory : ∀ lookup ∈ m.source.memory, lookup.Valid rom b := by + intro lookup present + obtain ⟨original, ho, rfl⟩ := List.mem_map.mp present + have originalValid := memory original ho + have on' : b m.origin.numVars = 1 := on + simpa only [Activation.memory, MemoryLookup.Valid, + Activation.polynomial_active m.origin.numVars original.enable b on', b] using originalValid + have original := (Activation.valid_active_iff m.origin b on).mp + (g.selected_member_sound m hm a valid.1 on activatedMemory) + exact ⟨original, payload⟩ + +theorem extend_valid (checked : Certificate sources g) (m : Member F) (hm : m ∈ g.members) + (a : Nat → F) (valid : m.origin.ValidAssignment rom a) : + g.ValidRow rom (fun v => (m.embedding v).denote a) := by + refine ⟨?_, ?_, ?_⟩ + · intro p hp + have h := (checked.extend_constraints m hm p hp).sound a valid.1 + simpa only [Polynomial.denote_subst] using h + · simpa only [Polynomial.denote_subst, Scalar.Circuit.ArithExpr.denote] using + (checked.extend_activation m hm).denote a + · intro n hn on + have sel := (checked.extend_selectors m hm n hn).denote a + have sameSelector : m.selector = n.selector := by + by_contra different + simp [selected, different, Scalar.Circuit.ArithExpr.denote, on] at sel + have same := checked.unique m hm n hn sameSelector + subst n + rw [checked.payload_extend m hm a, ofChip_memory] + exact valid.2 + +/-- The complete emitted row rule is equivalent to the disjunction of the +original source row rules. Selection and source-memory validity are derived, +not premises supplied to this theorem. -/ +theorem localRule_iff (checked : Certificate sources g) (rom : WireROM F) + (root : Message F) (premises : List (Message F)) : + g.LocalRule rom root premises ↔ ∃ c ∈ sources, c.LocalRule rom root premises := by + constructor + · rintro ⟨a, m, hm, valid, active, rootEq, callsEq⟩ + have h := checked.project_valid m hm a valid active + have finite := m.origin.finiteAssignment (checked.formed m hm) + (fun v => a (m.columns[v]?.getD 0)) rom + refine ⟨m.origin, ?_, Row.ofAssignment m.origin.name m.origin.numVars + (fun v => a (m.columns[v]?.getD 0)), rfl, + ⟨checked.formed m hm, Row.ofAssignment_length _ _ _, finite.1.mp h.1⟩, ?_, ?_⟩ + · rw [← checked.sources_eq] + exact List.mem_map.mpr ⟨m, hm, rfl⟩ + · rw [h.2, ofChip_root] at rootEq + exact finite.2.1.symm.trans rootEq + · rw [h.2, ofChip_requirements] at callsEq + exact finite.2.2.symm.trans callsEq + · rintro ⟨c, hc, row, _, valid, rootEq, callsEq⟩ + rw [← checked.sources_eq] at hc + obtain ⟨m, hm, rfl⟩ := List.mem_map.mp hc + refine ⟨fun v => (m.embedding v).denote row.assignment, m, hm, + checked.extend_valid m hm row.assignment valid.2.2, ?_, ?_, ?_⟩ + · simpa [selected, Scalar.Circuit.ArithExpr.denote] using + (checked.extend_selectors m hm m hm).denote row.assignment + · rw [checked.payload_extend m hm row.assignment, ofChip_root] + exact rootEq + · rw [checked.payload_extend m hm row.assignment, ofChip_requirements] + exact callsEq + +end Certificate +end Aiur.Optimized.Grouping diff --git a/Aiur/Aiur/Optimized/Grouping/Compile.lean b/Aiur/Aiur/Optimized/Grouping/Compile.lean new file mode 100644 index 000000000..8161002aa --- /dev/null +++ b/Aiur/Aiur/Optimized/Grouping/Compile.lean @@ -0,0 +1,143 @@ +import Aiur.Optimized.Grouping.Packets + +namespace Aiur.Optimized.Grouping +open Circuit + +variable {F : Type} [Field F] [DecidableEq F] + +/-- Zero-coefficient terms are discarded. The remaining supports deliberately +ignore cancellation: this heuristic only chooses columns; `silent` checks it. -/ +private def supports : Polynomial F → List (List Nat) + | .const x => if x = 0 then [] else [[]] + | .var v => [[v]] + | .add a b | .sub a b => supports a ++ supports b + | .mul a b => (supports a).flatMap fun x => (supports b).map fun y => (x ++ y).dedup + +/-- Select the smallest-degree form while keeping the original expression +order. In particular `(1 - branch) * x` can become `(member - branch) * x` +when `branch` is private, avoiding a cubic lookup and its lifted column. +The row and packet certificates check the resulting expressions. -/ +def selectArgument (selector : Nat) (privateCols : List Nat) (p : Polynomial F) : Polynomial F := + let direct := (gate selector privateCols p).simplify + let better := fun a b : Polynomial F => if a.degree < b.degree then a else b + if direct.degree ≤ 1 || silent privateCols p then direct else match p with + | .add a b => better (Polynomial.simplify (.add (selectArgument selector privateCols a) + (selectArgument selector privateCols b))) direct + | .sub a b => better (Polynomial.simplify (.sub (selectArgument selector privateCols a) + (selectArgument selector privateCols b))) direct + | .mul a b => + let left := Polynomial.simplify (.mul (selectArgument selector privateCols a) b) + let right := Polynomial.simplify (.mul a (selectArgument selector privateCols b)) + better left (better right direct) + | _ => direct + +def privateColumns (source : Chip F) (selector : Nat) + (lookupArgs : List (Polynomial F) := []) : Except String (List Nat) := do + let quiet := source.sends.map (·.enable) ++ source.memory.map (·.enable) + let required := source.constraints.filter (·.degree > 2) ++ quiet + let mut columns := [selector] + let mut terms := (required.flatMap supports).filter fun xs => !xs.contains selector + for _ in List.range source.numVars do + if terms.isEmpty then break + let candidates := terms.flatten.dedup + let best := candidates.foldl (fun (best : Nat × Nat) v => + let score := terms.countP (·.contains v) + if score > best.2 then (v, score) else best) (selector, 0) + if best.2 == 0 then break + columns := best.1 :: columns + terms := terms.filter fun xs => !xs.contains best.1 + -- Cancellation can leave an empty support. A conservative fallback is still + -- cheap for such uncommon chips, and the result is checked independently. + for p in required do + unless silent columns p do columns := (columns ++ Polynomial.vars p).dedup + -- One additional private factor can silence many quadratic arguments. + -- Keep only steps that remove at least one distinct materialization: the + -- private-plus-lifted width cannot increase, and the shared width can shrink. + let mut pending := (lookupArgs.filter fun p => (selectArgument selector columns p).degree > 2).dedup + for _ in List.range source.numVars do + let candidates := (pending.flatMap Polynomial.vars).dedup.filter fun v => !columns.contains v + let best := candidates.foldl (fun (best : Nat × Nat) v => + let score := pending.countP fun p => (selectArgument selector (v :: columns) p).degree ≤ 2 + if score > best.2 then (v, score) else best) (selector, 0) + if best.2 == 0 then break + let next := best.1 :: columns + let remaining := pending.filter fun p => (selectArgument selector next p).degree > 2 + if remaining.length ≥ pending.length then break + columns := next + pending := remaining + unless required.all (silent columns) do throw s!"cannot silence group member {source.name}" + unless columns.all (· < source.numVars) do throw "group private column out of bounds" + return columns.mergeSort (· ≤ ·) + +/-- Members retain their call identities, even when several typed functions +already share one physical chip. Activate each source before choosing columns. -/ +def candidate (name : String) (id : String → Except String Nat) + (sources : List (Chip F)) (optimizeLookups : Bool := true) : Except String (Layout F) := do + unless sources.length ≥ 2 do throw "a function group needs at least two members" + let selected ← sources.mapM fun origin => do + let chip := Activation.compile origin + let (provided, required) ← messages id chip + let args := if optimizeLookups then provided ++ required.flatMap (·.args) else [] + return (origin, ← privateColumns chip origin.numVars args) + let shared := selected.foldl (fun n (origin, privateCols) => + max n (origin.numVars + 1 - privateCols.length)) 0 + let mut next := shared + let mut members : List (Member F) := [] + let mut receive : List (Polynomial F) := [] + let mut sends : List (Lookup F) := [] + for (origin, privateCols) in selected do + let chip := Activation.compile origin + let selector := origin.numVars + let sharedCols := (List.range chip.numVars).filter fun v => !privateCols.contains v + let columns := (List.range chip.numVars).map fun v => + if privateCols.contains v then next + privateCols.idxOf v else sharedCols.idxOf v + next := next + privateCols.length + let columns := columns.toArray + let root := columns[selector]?.getD 0 + let rename := rename columns + let (provided, required) ← messages id chip + let mut writes : List (Nat × Polynomial F) := [] + let mut transformed : List (List (Polynomial F)) := [] + for args in provided :: required.map (·.args) do + let mut out := [] + for p in args do + unless p.degree ≤ 2 do throw s!"lookup degree exceeds two in {chip.name}" + let selected := if optimizeLookups then selectArgument selector privateCols p + else (gate selector privateCols p).simplify + let value ← if selected.degree ≤ 2 then + pure (rename selected).simplify + else do + let p := rename p + if let some (column, _) := writes.find? (fun (_, value) => value == p) then + pure (.var column) + else + let column := next + next := next + 1 + writes := writes ++ [(column, p)] + pure (.var column) + out := out ++ [value] + transformed := transformed ++ [out] + receive := plusArgs receive (transformed.headD []) + let required := required.zip (transformed.drop 1) |>.map fun (lookup, args) => + Lookup.mk (rename lookup.enable) args + sends := (List.range (max sends.length required.length)).map fun i => + let a := sends[i]?.getD ⟨.const 0, []⟩ + let b := required[i]?.getD ⟨.const 0, []⟩ + ⟨plus a.enable b.enable, plusArgs a.args b.args⟩ + members := members ++ [⟨chip.name, columns, root, writes, origin, privateCols⟩] + let layout := Layout.mk name next members receive sends + unless layout.constraints.all (fun p => p.degree ≤ 3 && p.inBounds next) do + throw s!"group {name} exceeds degree or column budget" + unless (receive ++ sends.flatMap (·.args)).all (fun p => p.degree ≤ 2 && p.inBounds next) && + sends.all (fun s => s.enable.degree ≤ 2 && s.enable.inBounds next) do + throw s!"group {name} has invalid lookup expressions" + return layout + +/-- The compiler returns a proof-bearing result; uncertified layouts cannot +reach the exporter. Column selection remains an untrusted heuristic. -/ +def compile (name : String) (id : String → Except String Nat) (sources : List (Chip F)) + (optimizeLookups : Bool := true) : + Except String (Checked sources id) := do + certify sources id (← candidate name id sources optimizeLookups) + +end Aiur.Optimized.Grouping diff --git a/Aiur/Aiur/Optimized/Grouping/Finite.lean b/Aiur/Aiur/Optimized/Grouping/Finite.lean new file mode 100644 index 000000000..3d34f00be --- /dev/null +++ b/Aiur/Aiur/Optimized/Grouping/Finite.lean @@ -0,0 +1,74 @@ +import Aiur.Optimized.Grouping.Payload + +namespace Aiur.Optimized.Grouping +open Circuit +variable {F : Type} [Field F] [DecidableEq F] + +def restrict (width v : Nat) : Polynomial F := + if v < width then .var v else .const 0 + +omit [DecidableEq F] in +@[simp] theorem restrict_denote (width v : Nat) (a : Nat → F) (name : String) : + (restrict width v).denote a = (Row.ofAssignment name width a).assignment v := by + by_cases inside : v < width + · simp [restrict, inside, Scalar.Circuit.ArithExpr.denote, + Row.ofAssignment_agree _ _ _ _ inside] + · simp [restrict, inside, Scalar.Circuit.ArithExpr.denote, Row.assignment, + Scalar.Circuit.Row.assignment, Row.ofAssignment] + +/-- Truncating the assignment to the actual exported row width must preserve +every equation and decoded payload. This prevents completeness from relying +on an infinite assignment with values outside the allocated columns. -/ +def Layout.FiniteCertificate (g : Layout F) : Prop := + (∀ p ∈ g.constraints, (p.subst (restrict g.width)).Identical p) ∧ + (g.activation.subst (restrict g.width)).Identical g.activation ∧ + ∀ m ∈ g.members, m.selector < g.width ∧ + ((g.view m).subst (restrict g.width)).Identical (g.view m) + +instance (g : Layout F) : Decidable g.FiniteCertificate := by + unfold Layout.FiniteCertificate + infer_instance + +theorem Layout.finiteAssignment (g : Layout F) (checked : g.FiniteCertificate) + (a : Nat → F) (valid : g.ValidRow rom a) : + let row := Row.ofAssignment g.name g.width a + g.ValidRow rom row.assignment ∧ + ∀ m ∈ g.members, (g.view m).denote row.assignment = (g.view m).denote a := by + have payload (m : Member F) (hm : m ∈ g.members) : + (g.view m).denote (Row.ofAssignment g.name g.width a).assignment = (g.view m).denote a := by + simpa only [Payload.denote_subst, restrict_denote g.width _ a g.name] using + (checked.2.2 m hm).2.denote a + refine ⟨⟨?_, ?_, ?_⟩, payload⟩ + · intro p hp + have same := (checked.1 p hp).denote a + simpa only [Polynomial.denote_subst, restrict_denote g.width _ a g.name, valid.1 p hp] using same + · have same := checked.2.1.denote a + simpa only [Polynomial.denote_subst, restrict_denote g.width _ a g.name, valid.2.1] using same + · intro m hm on + rw [payload m hm] + apply valid.2.2 m hm + simpa only [Row.ofAssignment_agree _ _ _ _ (checked.2.2 m hm).1] using on + +/-- The physical rule uses a finite row with exactly the exported width. -/ +def Layout.RowRule (g : Layout F) (rom : WireROM F) (root : Message F) + (premises : List (Message F)) : Prop := + ∃ (row : Row F) (m : Member F), row.chip = g.name ∧ row.values.length = g.width ∧ m ∈ g.members ∧ + g.ValidRow rom row.assignment ∧ row.assignment m.selector = 1 ∧ + ((g.view m).denote row.assignment).root = root ∧ + ((g.view m).denote row.assignment).requirements = premises + +theorem Layout.rowRule_iff (g : Layout F) (checked : g.FiniteCertificate) + (rom : WireROM F) (root : Message F) (premises : List (Message F)) : + g.RowRule rom root premises ↔ g.LocalRule rom root premises := by + constructor + · rintro ⟨row, m, _, _, hm, valid, active, rootEq, callsEq⟩ + exact ⟨row.assignment, m, hm, valid, active, rootEq, callsEq⟩ + · rintro ⟨a, m, hm, valid, active, rootEq, callsEq⟩ + have finite := g.finiteAssignment checked a valid + refine ⟨Row.ofAssignment g.name g.width a, m, rfl, Row.ofAssignment_length _ _ _, + hm, finite.1, ?_, ?_, ?_⟩ + · simpa only [Row.ofAssignment_agree _ _ _ _ (checked.2.2 m hm).1] using active + · simpa only [finite.2 m hm] using rootEq + · simpa only [finite.2 m hm] using callsEq + +end Aiur.Optimized.Grouping diff --git a/Aiur/Aiur/Optimized/Grouping/Layout.lean b/Aiur/Aiur/Optimized/Grouping/Layout.lean new file mode 100644 index 000000000..6e2cccce7 --- /dev/null +++ b/Aiur/Aiur/Optimized/Grouping/Layout.lean @@ -0,0 +1,113 @@ +import Aiur.Optimized.Grouping +import Aiur.Optimized.PolynomialIdentity + +namespace Aiur.Optimized.Grouping +open Circuit +variable {F : Type} [Field F] [DecidableEq F] + +structure Lookup (F : Type) where + enable : Polynomial F + args : List (Polynomial F) + +structure Member (F : Type) where + name : String + columns : Array Nat + selector : Nat + /-- Private message arguments of degree two, populated after the source row. -/ + writes : List (Nat × Polynomial F) := [] + origin : Chip F + privateCols : List Nat + +def Member.source (m : Member F) : Chip F := Activation.compile m.origin +def Member.sourceSelector (m : Member F) : Nat := m.origin.numVars + +structure Layout (F : Type) where + name : String + width : Nat + members : List (Member F) + receive : List (Polynomial F) + sends : List (Lookup F) + +def rename (columns : Array Nat) (p : Polynomial F) : Polynomial F := + p.subst (fun v => .var (columns[v]?.getD 0)) + +omit [DecidableEq F] in +@[simp] theorem rename_denote (columns : Array Nat) (p : Polynomial F) (a : Nat → F) : + (rename columns p).denote a = p.denote (fun v => a (columns[v]?.getD 0)) := by + simp [rename, Polynomial.denote_subst, Scalar.Circuit.ArithExpr.denote] + +def plus (a b : Polynomial F) : Polynomial F := Polynomial.simplify (.add a b) +def sum (ps : List (Polynomial F)) : Polynomial F := ps.foldl plus (.const 0) + +def Member.constraints (m : Member F) : List (Polynomial F) := + (member m.source m.sourceSelector m.privateCols).constraints.map (rename m.columns) ++ + m.writes.flatMap fun (column, value) => + [.mul (.var m.selector) (.sub (.var column) value), privateZero m.selector column] + +def exclusions : List (Polynomial F) → List (Polynomial F) + | [] => [] + | s :: ss => .mul s (sum ss) :: exclusions ss + +def Layout.activation (g : Layout F) : Polynomial F := + sum (g.members.map fun m => .var m.selector) + +def Layout.rawConstraints (g : Layout F) : List (Polynomial F) := + g.members.flatMap Member.constraints ++ exclusions (g.members.map fun m => .var m.selector) + +def Layout.constraints (g : Layout F) : List (Polynomial F) := + (g.rawConstraints.map Polynomial.simplify).filter (· != .const 0) + +/-- Projection from the actual emitted constraints, not a parallel circuit +model. Renaming shares data columns, but the selected member satisfies exactly +the original constraint list. Memory membership is recovered from its selected +lookup messages, just as for an ungrouped physical chip. -/ +theorem Layout.member_constraints (g : Layout F) (m : Member F) (present : m ∈ g.members) + (a : Nat → F) (valid : Satisfies g.constraints a) : + Satisfies (member m.source m.sourceSelector m.privateCols).constraints + (fun v => a (m.columns[v]?.getD 0)) := by + intro p hp + have included : rename m.columns p ∈ g.members.flatMap Member.constraints := by + apply List.mem_flatMap.mpr + refine ⟨m, present, List.mem_append_left _ ?_⟩ + exact List.mem_map.mpr ⟨p, hp, rfl⟩ + by_cases zero : (rename m.columns p).simplify = .const 0 + · have h := congrArg (fun p : Polynomial F => p.denote a) zero + simpa only [Polynomial.denote_simplify, rename_denote, Scalar.Circuit.ArithExpr.denote] using h + · have h := valid ((rename m.columns p).simplify) (by + unfold Layout.constraints Layout.rawConstraints + apply List.mem_filter.mpr + constructor + · exact List.mem_map.mpr ⟨_, List.mem_append_left _ included, rfl⟩ + · change (!((rename m.columns p).simplify == .const 0)) = true + cases h : ((rename m.columns p).simplify == .const 0) with + | false => rfl + | true => exact (zero ((Polynomial.beq_eq _ _).mp h)).elim) + simpa only [Polynomial.denote_simplify, rename_denote] using h + +theorem Layout.selected_member_sound (g : Layout F) (m : Member F) (present : m ∈ g.members) + (a : Nat → F) (valid : Satisfies g.constraints a) + (active : a (m.columns[m.sourceSelector]?.getD 0) = 1) + (memory : ∀ lookup ∈ m.source.memory, + lookup.Valid rom (fun v => a (m.columns[v]?.getD 0))) : + m.source.ValidAssignment rom (fun v => a (m.columns[v]?.getD 0)) := by + exact (member_active m.source m.sourceSelector m.privateCols + (fun v => a (m.columns[v]?.getD 0)) active).mp ⟨g.member_constraints m present a valid, memory⟩ +def plusArgs (xs ys : List (Polynomial F)) : List (Polynomial F) := + (List.range (max xs.length ys.length)).map fun i => + plus (xs[i]?.getD (.const 0)) (ys[i]?.getD (.const 0)) + +def messages (id : String → Except String Nat) (source : Chip F) : + Except String (List (Polynomial F) × List (Lookup F)) := do + let call ← id source.name + let receive := [.const 1, .const call] ++ + (source.inputs.flatMap WireValue.words).map .var ++ source.output.words + let sends ← source.sends.mapM fun s => do + let callee ← id s.channel + return Lookup.mk s.enable ([.const 1, .const callee] ++ + s.args.flatMap WireValue.words ++ s.result.words.map .var) + let memory := source.memory.map fun m => + Lookup.mk m.enable ([.const 2, .const m.value.words.length, m.address] ++ m.value.words) + return (receive, sends ++ memory) + + +end Aiur.Optimized.Grouping diff --git a/Aiur/Aiur/Optimized/Grouping/Packets.lean b/Aiur/Aiur/Optimized/Grouping/Packets.lean new file mode 100644 index 000000000..c2e5b73df --- /dev/null +++ b/Aiur/Aiur/Optimized/Grouping/Packets.lean @@ -0,0 +1,179 @@ +import Aiur.Optimized.Grouping.Certificate +import Aiur.Optimized.Grouping.Finite + +namespace Aiur.Optimized.Grouping +open Circuit +variable {F : Type} [Field F] [DecidableEq F] + +def word (ps : List (Polynomial F)) (i : Nat) : Polynomial F := ps[i]?.getD (.const 0) + +def VectorCheck (p q : List (Polynomial F)) (left right : Nat → Polynomial F) : Prop := + ∀ i ∈ List.range (max p.length q.length), + ((word p i).subst left).Identical ((word q i).subst right) + +instance (p q : List (Polynomial F)) (left right : Nat → Polynomial F) : + Decidable (VectorCheck p q left right) := by unfold VectorCheck; infer_instance + +theorem VectorCheck.sound {p q : List (Polynomial F)} {left right : Nat → Polynomial F} + (checked : VectorCheck p q left right) (a : Nat → F) (i : Nat) : + (word p i).denote (fun v => (left v).denote a) = + (word q i).denote (fun v => (right v).denote a) := by + by_cases bound : i < max p.length q.length + · simpa only [Polynomial.denote_subst] using + (checked i (List.mem_range.mpr bound)).denote a + · have hp : p.length ≤ i := by omega + have hq : q.length ≤ i := by omega + simp [word, List.getElem?_eq_none hp, List.getElem?_eq_none hq, + Scalar.Circuit.ArithExpr.denote] + +def lookupAt (ls : List (Lookup F)) (i : Nat) : Lookup F := ls[i]?.getD ⟨.const 0, []⟩ + +/-- Compare every encoded channel/width tag, enabled message, argument word, +and zero-padded tail. The logical payload check alone would omit these. -/ +def PacketCheck (g : Layout F) (left : Nat → Polynomial F) + (provided : List (Polynomial F)) (required : List (Lookup F)) + (right : Nat → Polynomial F) : Prop := + VectorCheck g.receive provided left right ∧ + ∀ i ∈ List.range (max g.sends.length required.length), + ((g.slot i).enable.subst left).Identical ((lookupAt required i).enable.subst right) ∧ + VectorCheck (g.slot i).args (lookupAt required i).args left right + +instance (g : Layout F) (left : Nat → Polynomial F) (provided : List (Polynomial F)) + (required : List (Lookup F)) (right : Nat → Polynomial F) : + Decidable (PacketCheck g left provided required right) := by unfold PacketCheck; infer_instance + +def Member.PacketCertificate (id : String → Except String Nat) (g : Layout F) (m : Member F) : Prop := + match messages id m.origin with + | .error _ => False + | .ok (provided, required) => + PacketCheck g (g.back (some m.selector)) provided required m.project ∧ + PacketCheck g (fun v => (restrict g.width v).subst m.embedding) + provided required (fun v => .var v) + +instance (id : String → Except String Nat) (g : Layout F) (m : Member F) : + Decidable (m.PacketCertificate id g) := by unfold Member.PacketCertificate; split <;> infer_instance + +/-- Values seen by the lookup protocol, extended with zeros in absent slots. -/ +def SamePackets (g : Layout F) (a : Nat → F) (provided : List (Polynomial F)) + (required : List (Lookup F)) (b : Nat → F) : Prop := + (∀ i, (word g.receive i).denote a = (word provided i).denote b) ∧ + ∀ i, (g.slot i).enable.denote a = (lookupAt required i).enable.denote b ∧ + ∀ j, (word (g.slot i).args j).denote a = (word (lookupAt required i).args j).denote b + +theorem PacketCheck.sound {g : Layout F} {left right : Nat → Polynomial F} + {provided : List (Polynomial F)} {required : List (Lookup F)} + (checked : PacketCheck g left provided required right) (a : Nat → F) : + SamePackets g (fun v => (left v).denote a) provided required (fun v => (right v).denote a) := by + refine ⟨fun i => checked.1.sound a i, ?_⟩ + intro i + by_cases bound : i < max g.sends.length required.length + · have h := checked.2 i (List.mem_range.mpr bound) + refine ⟨?_, fun j => h.2.sound a j⟩ + simpa only [Polynomial.denote_subst] using h.1.denote a + · have hg : g.sends.length ≤ i := by omega + have hr : required.length ≤ i := by omega + simp [Layout.slot, lookupAt, List.getElem?_eq_none hg, List.getElem?_eq_none hr, + word, Scalar.Circuit.ArithExpr.denote] + +structure Checked (sources : List (Chip F)) (id : String → Except String Nat) where + layout : Layout F + certificate : Certificate sources layout + finite : layout.FiniteCertificate + packets : ∀ m ∈ layout.members, m.PacketCertificate id layout + padding : PacketCheck layout (layout.back none) [] [] (fun v => .var v) + +/-- Failure rejects the candidate; the heuristic cannot export an uncertified +layout. All proposition decisions below are finite structural checks. -/ +def certify (sources : List (Chip F)) (id : String → Except String Nat) (g : Layout F) : + Except String (Checked sources id) := do + if hf : g.FiniteCertificate then + if h : Certificate sources g then + if hp : ∀ m ∈ g.members, m.PacketCertificate id g then + if hz : PacketCheck g (g.back none) [] [] (fun v => .var v) then + return ⟨g, h, hf, hp, hz⟩ + else throw s!"group {g.name}: padding packet certificate failed" + else throw s!"group {g.name}: encoded packet certificate failed" + else throw s!"group {g.name}: row equivalence certificate failed" + else throw s!"group {g.name}: finite row certificate failed" + +variable {sources : List (Chip F)} {id : String → Except String Nat} + +theorem Checked.localRule_iff (checked : Checked sources id) (rom : WireROM F) + (root : Message F) (premises : List (Message F)) : + checked.layout.RowRule rom root premises ↔ ∃ c ∈ sources, c.LocalRule rom root premises := + (checked.layout.rowRule_iff checked.finite rom root premises).trans + (checked.certificate.localRule_iff rom root premises) + +theorem Checked.packet_sound (checked : Checked sources id) (m : Member F) + (hm : m ∈ checked.layout.members) (a : Nat → F) + (valid : checked.layout.ValidRow rom a) (active : a m.selector = 1) : + ∃ provided required, messages id m.origin = .ok (provided, required) ∧ + SamePackets checked.layout a provided required (fun v => a (m.columns[v]?.getD 0)) := by + obtain ⟨n, hn, _, selectors⟩ := checked.layout.select checked.certificate.shapes a valid.1 valid.2.1 + have sameSelector : n.selector = m.selector := by + have h := selectors m hm + by_contra hne + simp [selected, hne, active] at h + have same := checked.certificate.unique n hn m hm sameSelector + subst n + have back := checked.layout.back_sound checked.certificate.shapes a valid.1 (some m.selector) selectors + have hc := checked.packets m hm + unfold Member.PacketCertificate at hc + cases result : messages id m.origin with + | error error => simp [result] at hc + | ok pair => + obtain ⟨provided, required⟩ := pair + simp only [result] at hc + refine ⟨provided, required, rfl, ?_⟩ + simpa only [back, Member.project, Scalar.Circuit.ArithExpr.denote] using hc.1.sound a + +/-- Every valid source assignment has a finite grouped row with exactly the +same raw lookup messages, including tags, enables, and zero-padded tails. -/ +theorem Checked.packet_complete (checked : Checked sources id) (m : Member F) + (hm : m ∈ checked.layout.members) (a : Nat → F) + (valid : m.origin.ValidAssignment rom a) : + ∃ (row : Row F) (provided : List (Polynomial F)) (required : List (Lookup F)), + row.chip = checked.layout.name ∧ row.values.length = checked.layout.width ∧ + checked.layout.ValidRow rom row.assignment ∧ row.assignment m.selector = 1 ∧ + messages id m.origin = .ok (provided, required) ∧ + SamePackets checked.layout row.assignment provided required a := by + let b := fun v => (m.embedding v).denote a + let row := Row.ofAssignment checked.layout.name checked.layout.width b + have finite := checked.layout.finiteAssignment checked.finite b + (checked.certificate.extend_valid m hm a valid) + have hc := checked.packets m hm + unfold Member.PacketCertificate at hc + cases result : messages id m.origin with + | error error => simp [result] at hc + | ok pair => + obtain ⟨provided, required⟩ := pair + simp only [result] at hc + refine ⟨row, provided, required, rfl, Row.ofAssignment_length _ _ _, finite.1, ?_, rfl, ?_⟩ + · rw [Row.ofAssignment_agree _ _ _ _ (checked.finite.2.2 m hm).1] + simpa [b, selected, Scalar.Circuit.ArithExpr.denote] using + (checked.certificate.extend_selectors m hm m hm).denote a + · have values : (fun v => ((restrict checked.layout.width v).subst m.embedding).denote a) = + row.assignment := by + funext v + rw [Polynomial.denote_subst] + exact restrict_denote _ _ b _ + simpa only [values, Scalar.Circuit.ArithExpr.denote] using hc.2.sound a + +theorem Checked.padding_sound (checked : Checked sources id) (a : Nat → F) + (valid : Satisfies checked.layout.constraints a) (off : checked.layout.activation.denote a = 0) : + SamePackets checked.layout a [] [] (fun _ => 0) := by + have selectors := checked.layout.off checked.certificate.shapes a valid off + have back := checked.layout.back_sound checked.certificate.shapes a valid none selectors + have h := checked.padding.sound a + simpa [SamePackets, back, word, lookupAt, Scalar.Circuit.ArithExpr.denote] using h + +theorem Checked.zero_padding (checked : Checked sources id) : + Satisfies checked.layout.constraints (fun _ => 0) ∧ + checked.layout.activation.denote (fun _ => 0) = 0 ∧ + SamePackets checked.layout (fun _ => 0) [] [] (fun _ => 0) := by + have valid := checked.certificate.zero_constraints + have off : checked.layout.activation.denote (fun _ => 0) = 0 := by + simp [Layout.activation, sum_denote, Function.comp_def, Scalar.Circuit.ArithExpr.denote] + exact ⟨valid, off, checked.padding_sound _ valid off⟩ + +end Aiur.Optimized.Grouping diff --git a/Aiur/Aiur/Optimized/Grouping/Payload.lean b/Aiur/Aiur/Optimized/Grouping/Payload.lean new file mode 100644 index 000000000..fdbe52488 --- /dev/null +++ b/Aiur/Aiur/Optimized/Grouping/Payload.lean @@ -0,0 +1,114 @@ +import Aiur.Optimized.Grouping.Substitution +import Aiur.Circuit.Erasure + +namespace Aiur.Optimized.Grouping +open Circuit +variable {F : Type} [Field F] [DecidableEq F] + +/-- Logical schemas accompany the actual scalar message expressions. The +numeric channel/width tags are checked separately, including unused slots. -/ +structure Payload (α : Type) where + root : Message α + calls : List (α × Message α) + cells : List (α × α × WireValue α) + deriving DecidableEq + +def mapMessage (f : α → β) (m : Message α) : Message β := + ⟨m.channel, m.args.map (WireValue.map f), m.result.map f⟩ + +@[simp] theorem mapMessage_map (f : α → β) (g : β → γ) (m : Message α) : + mapMessage g (mapMessage f m) = mapMessage (g ∘ f) m := by + simp [mapMessage, WireValue.map_map, List.map_map, Function.comp_def] + +def Payload.map (f : α → β) (p : Payload α) : Payload β := + ⟨mapMessage f p.root, p.calls.map (fun (e, m) => (f e, mapMessage f m)), + p.cells.map (fun (e, address, value) => (f e, f address, value.map f))⟩ + +@[simp] theorem Payload.map_map (f : α → β) (g : β → γ) (p : Payload α) : + (p.map f).map g = p.map (g ∘ f) := by + cases p + simp [Payload.map, List.map_map, Function.comp_def, WireValue.map_map] + +def Payload.denote (p : Payload (Polynomial F)) (a : Nat → F) : Payload F := + p.map (fun p => p.denote a) + +def Payload.subst (p : Payload (Polynomial F)) (r : Nat → Polynomial F) : Payload (Polynomial F) := + p.map (Polynomial.subst r) + +omit [DecidableEq F] in +@[simp] theorem Payload.denote_subst (p : Payload (Polynomial F)) (r : Nat → Polynomial F) + (a : Nat → F) : (p.subst r).denote a = p.denote (fun v => (r v).denote a) := by + simp [Payload.denote, Payload.subst, Function.comp_def] + +def Payload.Identical (p q : Payload (Polynomial F)) : Prop := + p.map Polynomial.simplify = q.map Polynomial.simplify + +instance (p q : Payload (Polynomial F)) : Decidable (p.Identical q) := by + unfold Payload.Identical + infer_instance + +theorem Payload.Identical.denote {p q : Payload (Polynomial F)} (h : p.Identical q) (a : Nat → F) : + p.denote a = q.denote a := by + have h := congrArg (fun p : Payload (Polynomial F) => p.denote a) h + simpa [Payload.denote, Function.comp_def] using h + +def Payload.MemoryValid (p : Payload F) (rom : WireROM F) : Prop := + ∀ cell ∈ p.cells, cell.1 = 1 → (cell.2.1, cell.2.2) ∈ rom.entries + +def Payload.requirements (p : Payload F) : List (Message F) := + p.calls.filterMap fun (e, m) => if e = 1 then some m else none + +def ofChip (c : Chip F) : Payload (Polynomial F) := + ⟨⟨c.name, c.inputs.map (WireValue.map .var), c.output⟩, + c.sends.map (fun s => (s.enable, ⟨s.channel, s.args, s.result.map .var⟩)), + c.memory.map (fun m => (m.enable, m.address, m.value))⟩ + +omit [DecidableEq F] in +theorem ofChip_root (c : Chip F) (a : Nat → F) : + ((ofChip c).denote a).root = c.conclusion a := by + simp [ofChip, Payload.denote, Payload.map, mapMessage, Chip.conclusion, + WireValue.map_map, List.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] + +theorem ofChip_requirements (c : Chip F) (a : Nat → F) : + ((ofChip c).denote a).requirements = c.requirements a := by + simp [ofChip, Payload.denote, Payload.map, Payload.requirements, Chip.requirements, + List.filterMap_map, Function.comp_def, Send.message, mapMessage, WireValue.map_map, + Scalar.Circuit.ArithExpr.denote] + +omit [DecidableEq F] in +theorem ofChip_memory (c : Chip F) (a : Nat → F) (rom : WireROM F) : + ((ofChip c).denote a).MemoryValid rom ↔ ∀ m ∈ c.memory, m.Valid rom a := by + simp [ofChip, Payload.denote, Payload.map, Payload.MemoryValid, MemoryLookup.Valid] + +/-- Decode with the static source signature, but read every word from the +emitted shared lookup. Extra padding and numeric tags are covered by Packets. -/ +def decodeMessage (shape : Message α) (words : List β) : Message β := + ⟨shape.channel, Erasure.readWords (shape.args.map Erasure.shape) (words.drop 2), + ⟨shape.result.type, (words.drop (2 + (shape.args.flatMap WireValue.words).length)).take shape.result.words.length⟩⟩ + +def Layout.slot (g : Layout F) (i : Nat) : Lookup F := + g.sends[i]?.getD ⟨.const 0, []⟩ + +def Layout.view (g : Layout F) (m : Member F) : Payload (Polynomial F) := + let source := ofChip m.origin + ⟨decodeMessage source.root g.receive, + source.calls.zipIdx.map fun ((_, call), i) => + let slot := g.slot i + (slot.enable, decodeMessage call slot.args), + source.cells.zipIdx.map fun ((_, _, value), i) => + let slot := g.slot (source.calls.length + i) + (slot.enable, slot.args[2]?.getD (.const 0), + ⟨value.type, (slot.args.drop 3).take value.words.length⟩)⟩ + +/-- This predicate checks memory using the words in the emitted shared +messages. Source-memory membership is a consequence of the certificate. -/ +def Layout.ValidRow (g : Layout F) (rom : WireROM F) (a : Nat → F) : Prop := + Satisfies g.constraints a ∧ g.activation.denote a = 1 ∧ + ∀ m ∈ g.members, a m.selector = 1 → ((g.view m).denote a).MemoryValid rom + +def Layout.LocalRule (g : Layout F) (rom : WireROM F) (root : Message F) + (premises : List (Message F)) : Prop := + ∃ a m, m ∈ g.members ∧ g.ValidRow rom a ∧ a m.selector = 1 ∧ + ((g.view m).denote a).root = root ∧ ((g.view m).denote a).requirements = premises + +end Aiur.Optimized.Grouping diff --git a/Aiur/Aiur/Optimized/Grouping/Plan.lean b/Aiur/Aiur/Optimized/Grouping/Plan.lean new file mode 100644 index 000000000..f636a3f0d --- /dev/null +++ b/Aiur/Aiur/Optimized/Grouping/Plan.lean @@ -0,0 +1,127 @@ +import Aiur.Optimized.Grouping.Compile +import Aiur.Optimized.Physical + +namespace Aiur.Optimized.Grouping +open Circuit +variable {F : Type} [Field F] [DecidableEq F] +variable {id : String → Except String Nat} + +structure Packed (F : Type) [Field F] [DecidableEq F] (id : String → Except String Nat) where + sources : List (Chip F) + checked : Checked sources id + +/-- The exporter certifies the entire partition, including chips that retain +their original physical layout. No source member may be dropped or replaced. -/ +def PlanCertificate (source : Circuit.System F) (singles : List (Chip F)) + (groups : List (Packed F id)) : Prop := + (∀ c ∈ singles, source.findChip? c.name = some c) ∧ + (∀ p ∈ groups, ∀ c ∈ p.sources, source.findChip? c.name = some c) ∧ + (∀ c ∈ source.chips, c ∈ singles ∨ ∃ p ∈ groups, c ∈ p.sources) + +instance (source : Circuit.System F) (singles : List (Chip F)) + (groups : List (Packed F id)) : Decidable (PlanCertificate source singles groups) := by + letI (c : Chip F) (cs : List (Chip F)) : Decidable (c ∈ cs) := + decidable_of_iff (∃ d ∈ cs, d = c) (by simp) + unfold PlanCertificate + infer_instance + +structure Plan (source : Circuit.System F) (id : String → Except String Nat) where + singles : List (Chip F) + groups : List (Packed F id) + certificate : PlanCertificate source singles groups + +def preparePlan (source : Circuit.System F) (id : String → Except String Nat) + (groups : List (Packed F id)) : Except String (Plan source id) := do + let names := groups.flatMap fun p => p.sources.map Chip.name + let singles := source.chips.filter fun c => !names.contains c.name + if h : PlanCertificate source singles groups then return ⟨singles, groups, h⟩ + else throw "grouping partition does not preserve the physical source circuits" + +variable {source : Circuit.System F} + +def Plan.LocalRule (plan : Plan source id) (rom : WireROM F) + (root : Message F) (premises : List (Message F)) : Prop := + (∃ c ∈ plan.singles, c.LocalRule rom root premises) ∨ + ∃ p ∈ plan.groups, p.checked.layout.RowRule rom root premises + +theorem Plan.localRule_iff (plan : Plan source id) (rom : WireROM F) + (root : Message F) (premises : List (Message F)) : + plan.LocalRule rom root premises ↔ + ∃ c, source.findChip? c.name = some c ∧ c.LocalRule rom root premises := by + constructor + · rintro (⟨c, hc, rule⟩ | ⟨p, hp, rule⟩) + · exact ⟨c, plan.certificate.1 c hc, rule⟩ + · obtain ⟨c, hc, rule⟩ := (p.checked.localRule_iff rom root premises).mp rule + exact ⟨c, plan.certificate.2.1 p hp c hc, rule⟩ + · rintro ⟨c, hc, rule⟩ + rcases plan.certificate.2.2 c (List.mem_of_find?_eq_some hc) with single | ⟨p, hp, grouped⟩ + · exact Or.inl ⟨c, single, rule⟩ + · exact Or.inr ⟨p, hp, (p.checked.localRule_iff rom root premises).mpr ⟨c, grouped, rule⟩⟩ + +/-- The same finite-derivation contract used by the compiler. Each group rule +reads its actual emitted equations and shared call/memory message words. -/ +inductive Plan.Derives (plan : Plan source id) (rom : WireROM F) : Message F → Prop + | node {root premises} (rule : plan.LocalRule rom root premises) + (children : ∀ message ∈ premises, plan.Derives rom message) : plan.Derives rom root + | table {message} (member : source.MapClaim message) : plan.Derives rom message + +theorem Plan.derives_sound (plan : Plan source id) {rom : WireROM F} {root : Message F} + (derived : plan.Derives rom root) : Circuit.Derives source rom root := by + induction derived with + | node rule _ ih => + obtain ⟨c, hc, row, chipEq, valid, rootEq, premisesEq⟩ := + (plan.localRule_iff _ _ _).mp rule + have found : source.findChip? row.chip = some c := by simpa [chipEq] using hc + obtain ⟨children⟩ := (derivations_nonempty_iff (messages := c.premises row)).mpr + (by simpa only [premisesEq] using ih) + rw [← rootEq] + exact ⟨.node c row found valid children⟩ + | table member => exact ⟨.table member⟩ + +theorem Plan.derives_complete (plan : Plan source id) {rom : WireROM F} {root : Message F} + (derived : Circuit.Derives source rom root) : plan.Derives rom root := by + obtain ⟨tree⟩ := derived + induction tree using Derivation.rec + (motive_2 := fun messages _ => ∀ message ∈ messages, plan.Derives rom message) with + | node c row found valid children ih => + apply Plan.Derives.node _ ih + apply (plan.localRule_iff _ _ _).mpr + have name := System.findChip_name found + exact ⟨c, by simpa [name] using found, row, name.symm, valid, rfl, rfl⟩ + | table member => exact .table member + | nil => simp_all + | cons _ _ head tail => + rename_i message member + rcases List.mem_cons.mp member with rfl | member + · exact head + · exact tail message member + +theorem Plan.derives_iff (plan : Plan source id) {rom : WireROM F} {root : Message F} : + plan.Derives rom root ↔ Circuit.Derives source rom root := + ⟨plan.derives_sound, plan.derives_complete⟩ + +end Aiur.Optimized.Grouping + +namespace Aiur.Optimized.Physical +open Circuit +variable {F : Type} [Field F] [DecidableEq F] +variable {id : String → Except String Nat} + +/-- Grouping composes all the way to independent source evaluation. There are +no selected-member or source-memory side conditions: those are recovered from +the certified grouped row rule. The existing ROM and public-schema hypotheses +are exactly the hypotheses of `Prepared.native_heap_sound`. -/ +theorem Prepared.grouped_native_heap_sound {source : Generic.Source F} {entries : List String} + {specialized : Generic.Specialized source entries} (compiled : GenericArtifact specialized) + (prepared : Prepared compiled.artifact) (plan : Grouping.Plan prepared.system id) + {name : String} (entry : name ∈ entries) {rom : WidthROM F} (valid : rom.Valid) + {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F} + (signed : Erasure.Signed compiled.system ⟨name, wires, output⟩) + (derived : plan.Derives (Erasure.rawROM rom) (Erasure.message compiled.system ⟨name, wires, output⟩)) + (arguments : DecodesValues specialized.program.enums wires (entryValues args)) + (decoded : output.decode specialized.program.enums = some result) : + ∃ value heap, Generic.SourceSemantics.EvalFn source.world name args [] value heap ∧ + Represents ((Erasure.typedROM compiled.system rom).decode specialized.program.enums) heap value result := + prepared.native_heap_sound compiled entry valid signed (plan.derives_sound derived) arguments decoded + +end Aiur.Optimized.Physical diff --git a/Aiur/Aiur/Optimized/Grouping/Selection.lean b/Aiur/Aiur/Optimized/Grouping/Selection.lean new file mode 100644 index 000000000..1e951e963 --- /dev/null +++ b/Aiur/Aiur/Optimized/Grouping/Selection.lean @@ -0,0 +1,144 @@ +import Aiur.Optimized.Grouping.Layout + +namespace Aiur.Optimized.Grouping +open Circuit +variable {F : Type} [Field F] [DecidableEq F] + +theorem sum_denote (ps : List (Polynomial F)) (a : Nat → F) : + (sum ps).denote a = (ps.map (fun p => p.denote a)).sum := by + have fold (ps : List (Polynomial F)) (p : Polynomial F) : + (ps.foldl plus p).denote a = p.denote a + (ps.map (fun p => p.denote a)).sum := by + induction ps generalizing p with + | nil => simp + | cons q qs ih => simp [ih, plus, Polynomial.denote_simplify, Scalar.Circuit.ArithExpr.denote, add_assoc] + simpa [sum, Scalar.Circuit.ArithExpr.denote] using fold ps (.const 0) + +theorem Layout.constraints_iff (g : Layout F) (a : Nat → F) : + Satisfies g.constraints a ↔ Satisfies g.rawConstraints a := by + constructor + · intro valid p hp + by_cases zero : (Polynomial.simplify p) = .const 0 + · have h := congrArg (fun q : Polynomial F => q.denote a) zero + simpa only [Polynomial.denote_simplify, Scalar.Circuit.ArithExpr.denote] using h + · have present : (Polynomial.simplify p) ∈ g.constraints := by + apply List.mem_filter.mpr + refine ⟨List.mem_map.mpr ⟨p, hp, rfl⟩, ?_⟩ + change (!((Polynomial.simplify p) == .const 0)) = true + cases h : ((Polynomial.simplify p) == .const 0) with + | false => rfl + | true => exact (zero ((Polynomial.beq_eq _ _).mp h)).elim + simpa only [Polynomial.denote_simplify] using valid _ present + · intro valid p hp + obtain ⟨hp, _⟩ := List.mem_filter.mp hp + obtain ⟨q, hq, rfl⟩ := List.mem_map.mp hp + simpa only [Polynomial.denote_simplify] using valid q hq + +theorem Layout.member_satisfies (g : Layout F) (m : Member F) (present : m ∈ g.members) + (a : Nat → F) (valid : Satisfies g.constraints a) : Satisfies m.constraints a := by + intro p hp + exact (g.constraints_iff a).mp valid p + (List.mem_append_left _ (List.mem_flatMap.mpr ⟨m, present, hp⟩)) + +def Member.Shape (m : Member F) : Prop := + m.selector = m.columns[m.sourceSelector]?.getD 0 ∧ m.sourceSelector ∈ m.privateCols + +instance (m : Member F) : Decidable m.Shape := by unfold Member.Shape; infer_instance + +theorem Layout.private_zero (g : Layout F) (m : Member F) (present : m ∈ g.members) + (shape : m.Shape) (a : Nat → F) (valid : Satisfies g.constraints a) + (off : a m.selector = 0) (v : Nat) (hv : v ∈ m.privateCols) : + a (m.columns[v]?.getD 0) = 0 := by + have h := g.member_constraints m present a valid (privateZero m.sourceSelector v) + (List.mem_append_right _ (List.mem_map.mpr ⟨v, hv, rfl⟩)) + simpa [privateZero, Scalar.Circuit.ArithExpr.denote, ← shape.1, off] using h + +theorem Layout.selector_boolean (g : Layout F) (m : Member F) (present : m ∈ g.members) + (shape : m.Shape) (a : Nat → F) (valid : Satisfies g.constraints a) : + a m.selector = 0 ∨ a m.selector = 1 := by + have h := g.member_constraints m present a valid (privateZero m.sourceSelector m.sourceSelector) + (List.mem_append_right _ (List.mem_map.mpr ⟨m.sourceSelector, shape.2, rfl⟩)) + have h : (1 - a m.selector) * a m.selector = 0 := by + simpa [privateZero, Scalar.Circuit.ArithExpr.denote, ← shape.1] using h + rcases mul_eq_zero.mp h with h | h + · exact Or.inr (sub_eq_zero.mp h).symm + · exact Or.inl h + +theorem exclusions_sound (ps : List (Polynomial F)) (a : Nat → F) + (booleans : ∀ p ∈ ps, p.denote a = 0 ∨ p.denote a = 1) + (valid : Satisfies (exclusions ps) a) : Exclusive (ps.map (fun p => p.denote a)) := by + induction ps with + | nil => trivial + | cons p ps ih => + refine ⟨booleans p (by simp), ?_, ih (fun q hq => booleans q (by simp [hq])) ?_⟩ + · simpa [exclusions, Scalar.Circuit.ArithExpr.denote, sum_denote] using valid _ (List.mem_cons_self ..) + · intro q hq + exact valid q (List.mem_cons_of_mem _ hq) + +theorem Layout.exclusive (g : Layout F) (shapes : ∀ m ∈ g.members, m.Shape) + (a : Nat → F) (valid : Satisfies g.constraints a) : + Exclusive (g.members.map (fun m => a m.selector)) := by + have h := exclusions_sound (g.members.map (fun m => Polynomial.var m.selector)) a + (by + intro p hp + obtain ⟨m, hm, rfl⟩ := List.mem_map.mp hp + exact g.selector_boolean m hm (shapes m hm) a valid) + (by + intro p hp + exact (g.constraints_iff a).mp valid p (List.mem_append_right _ hp)) + simpa [Function.comp_def, Scalar.Circuit.ArithExpr.denote] using h + +def selected (mode : Option Nat) (m : Member F) : F := + if mode = some m.selector then 1 else 0 + +omit [DecidableEq F] in +theorem select_member (ms : List (Member F)) (a : Nat → F) + (valid : Exclusive (ms.map (fun m => a m.selector))) : + (∀ m ∈ ms, a m.selector = 0) ∨ + ∃ m ∈ ms, a m.selector = 1 ∧ ∀ n ∈ ms, a n.selector = selected (some m.selector) n := by + induction ms with + | nil => exact Or.inl (by simp) + | cons m ms ih => + rcases valid with ⟨boolean, cross, tail⟩ + rcases boolean with off | on + · rcases ih tail with all | ⟨n, hn, active, values⟩ + · exact Or.inl (by simpa using And.intro off all) + · refine Or.inr ⟨n, by simp [hn], active, ?_⟩ + intro q hq + rcases List.mem_cons.mp hq with same | hq + · subst q + have different : n.selector ≠ m.selector := by intro h; simp_all + simp [selected, different, off] + · exact values q hq + · have zero : (ms.map (fun m => a m.selector)).sum = 0 := by simpa [on] using cross + have all := exclusive_zero tail zero + refine Or.inr ⟨m, by simp, on, ?_⟩ + intro n hn + rcases List.mem_cons.mp hn with rfl | hn + · simp [selected, on] + · have off := all _ (List.mem_map.mpr ⟨n, hn, rfl⟩) + have different : m.selector ≠ n.selector := by intro h; simp_all + simp [selected, different, off] + +theorem Layout.select (g : Layout F) (shapes : ∀ m ∈ g.members, m.Shape) + (a : Nat → F) (valid : Satisfies g.constraints a) (active : g.activation.denote a = 1) : + ∃ m ∈ g.members, a m.selector = 1 ∧ ∀ n ∈ g.members, a n.selector = selected (some m.selector) n := by + rcases select_member g.members a (g.exclusive shapes a valid) with off | on + · have zero : g.activation.denote a = 0 := by + rw [Layout.activation, sum_denote] + apply List.sum_eq_zero + intro x hx + obtain ⟨p, hp, rfl⟩ := List.mem_map.mp hx + obtain ⟨m, hm, rfl⟩ := List.mem_map.mp hp + exact off m hm + exact (zero_ne_one (zero.symm.trans active)).elim + · exact on + +theorem Layout.off (g : Layout F) (shapes : ∀ m ∈ g.members, m.Shape) + (a : Nat → F) (valid : Satisfies g.constraints a) (inactive : g.activation.denote a = 0) : + ∀ m ∈ g.members, a m.selector = selected none m := by + have zero : (g.members.map (fun m => a m.selector)).sum = 0 := by + simpa [Layout.activation, sum_denote, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using inactive + intro m hm + exact exclusive_zero (g.exclusive shapes a valid) zero _ (List.mem_map.mpr ⟨m, hm, rfl⟩) + +end Aiur.Optimized.Grouping diff --git a/Aiur/Aiur/Optimized/Grouping/Snapshot.lean b/Aiur/Aiur/Optimized/Grouping/Snapshot.lean new file mode 100644 index 000000000..f479c62eb --- /dev/null +++ b/Aiur/Aiur/Optimized/Grouping/Snapshot.lean @@ -0,0 +1,34 @@ +import Aiur.Optimized.Physical +import Lean + +/-! Offline compiler inputs for repeatable grouping experiments. The snapshot +contains the original physical chips, not a reconstruction from grouped rows. +Candidate groups still pass the ordinary grouping certificate before export. -/ +namespace Aiur +open Lean + +deriving instance ToJson, FromJson for Ty +deriving instance ToJson, FromJson for WireValue +deriving instance ToJson, FromJson for Scalar.Circuit.ArithExpr +deriving instance ToJson, FromJson for Circuit.Send +deriving instance ToJson, FromJson for Circuit.MemoryLookup +deriving instance ToJson, FromJson for Circuit.Chip + +namespace Optimized.Grouping + +structure Snapshot (F : Type) where + chips : List (Circuit.Chip F) + callables : List String + entries : List String + representatives : List (String × String) + groups : List (String × List String) + deriving ToJson, FromJson + +def Snapshot.capture [Field F] [DecidableEq F] (artifact : Artifact F) + (physical : Physical.Prepared artifact) (callables : List String) + (groups : List (String × List String)) : Snapshot F := + ⟨physical.system.chips, callables, artifact.entries, + callables.map (fun name => (name, physical.representative name)), groups⟩ + +end Optimized.Grouping +end Aiur diff --git a/Aiur/Aiur/Optimized/Grouping/Substitution.lean b/Aiur/Aiur/Optimized/Grouping/Substitution.lean new file mode 100644 index 000000000..98466563e --- /dev/null +++ b/Aiur/Aiur/Optimized/Grouping/Substitution.lean @@ -0,0 +1,108 @@ +import Aiur.Optimized.Grouping.Selection + +namespace Aiur.Optimized.Grouping +open Circuit +variable {F : Type} [Field F] [DecidableEq F] + +def replacement (bindings : List (Nat × Polynomial F)) (v : Nat) : Polynomial F := + ((bindings.find? (fun b => b.1 == v)).map Prod.snd).getD (.var v) + +omit [DecidableEq F] in +theorem replacement_sound (bindings : List (Nat × Polynomial F)) (a : Nat → F) + (sound : ∀ b ∈ bindings, b.2.denote a = a b.1) (v : Nat) : + (replacement bindings v).denote a = a v := by + cases found : bindings.find? (fun b => b.1 == v) with + | none => simp [replacement, found, Scalar.Circuit.ArithExpr.denote] + | some b => + have index_eq : b.1 = v := beq_iff_eq.mp (List.find?_some (p := fun b : Nat × Polynomial F => b.1 == v) found) + simpa [replacement, found, index_eq] using sound b (List.mem_of_find?_eq_some found) + +def Layout.baseBindings (g : Layout F) (mode : Option Nat) : List (Nat × Polynomial F) := + g.members.flatMap fun m => + (m.selector, .const (selected mode m)) :: + if mode = some m.selector then [] else + m.privateCols.map fun v => (m.columns[v]?.getD 0, .const 0) + +def Layout.base (g : Layout F) (mode : Option Nat) := replacement (g.baseBindings mode) + +theorem Layout.base_sound (g : Layout F) (shapes : ∀ m ∈ g.members, m.Shape) + (a : Nat → F) (valid : Satisfies g.constraints a) (mode : Option Nat) + (selectors : ∀ m ∈ g.members, a m.selector = selected mode m) (v : Nat) : + (g.base mode v).denote a = a v := by + apply replacement_sound + intro b hb + obtain ⟨m, hm, hb⟩ := List.mem_flatMap.mp hb + rcases List.mem_cons.mp hb with rfl | hb + · exact (selectors m hm).symm + · split at hb + · simp at hb + · rename_i different + obtain ⟨v, hv, rfl⟩ := List.mem_map.mp hb + have off : a m.selector = 0 := by simpa [selected, different] using selectors m hm + exact (g.private_zero m hm (shapes m hm) a valid off v hv).symm + +def Layout.backBindings (g : Layout F) (mode : Option Nat) : List (Nat × Polynomial F) := + let base := g.base mode + g.members.flatMap fun m => m.writes.map fun (column, value) => + (column, if mode = some m.selector then value.subst base else .const 0) + +def Layout.back (g : Layout F) (mode : Option Nat) : Nat → Polynomial F := + replacement (g.backBindings mode ++ g.baseBindings mode) + +theorem Layout.write_equations (g : Layout F) (m : Member F) (hm : m ∈ g.members) + (a : Nat → F) (valid : Satisfies g.constraints a) (w : Nat × Polynomial F) (hw : w ∈ m.writes) : + a m.selector * (a w.1 - w.2.denote a) = 0 ∧ (1 - a m.selector) * a w.1 = 0 := by + have h := g.member_satisfies m hm a valid + constructor + · exact h (.mul (.var m.selector) (.sub (.var w.1) w.2)) + (List.mem_append_right _ (List.mem_flatMap.mpr ⟨w, hw, by simp⟩)) + · exact h (privateZero m.selector w.1) + (List.mem_append_right _ (List.mem_flatMap.mpr ⟨w, hw, by simp⟩)) + +theorem Layout.back_sound (g : Layout F) (shapes : ∀ m ∈ g.members, m.Shape) + (a : Nat → F) (valid : Satisfies g.constraints a) (mode : Option Nat) + (selectors : ∀ m ∈ g.members, a m.selector = selected mode m) (v : Nat) : + (g.back mode v).denote a = a v := by + have base := g.base_sound shapes a valid mode selectors + apply replacement_sound + intro b hb + rcases List.mem_append.mp hb with hb | hb + · obtain ⟨m, hm, hb⟩ := List.mem_flatMap.mp hb + obtain ⟨w, hw, rfl⟩ := List.mem_map.mp hb + have eqs := g.write_equations m hm a valid w hw + have sel := selectors m hm + by_cases on : mode = some m.selector + · have on' : a m.selector = 1 := by simpa [selected, on] using sel + have equal : w.2.denote a = a w.1 := (sub_eq_zero.mp (by simpa [on'] using eqs.1)).symm + change (if mode = some m.selector then w.2.subst (g.base mode) else .const 0).denote a = a w.1 + rw [ite_eq_left on, Polynomial.denote_subst] + simpa only [base] using equal + · have off : a m.selector = 0 := by simpa [selected, on] using sel + simpa [on, Scalar.Circuit.ArithExpr.denote, off] using eqs.2.symm + · obtain ⟨m, hm, hb⟩ := List.mem_flatMap.mp hb + rcases List.mem_cons.mp hb with rfl | hb + · exact (selectors m hm).symm + · split at hb + · simp at hb + · rename_i different + obtain ⟨v, hv, rfl⟩ := List.mem_map.mp hb + have off : a m.selector = 0 := by simpa [selected, different] using selectors m hm + exact (g.private_zero m hm (shapes m hm) a valid off v hv).symm + +/-- A concrete extension of a source row: source columns, activation, then +private lifted arguments. The certificate checks this proposed extension; +no property of the placement heuristic is assumed. -/ +def Member.embeddingBase (m : Member F) : Nat → Polynomial F := + replacement (((List.range m.origin.numVars).map fun v => (m.columns[v]?.getD 0, .var v)) ++ + [(m.selector, .const 1)]) + +def Member.embedding (m : Member F) : Nat → Polynomial F := + let columns := m.columns.toList + let original := m.embeddingBase + let base := fun column => if columns.contains column then original column else .const 0 + let writes := m.writes.map fun (column, value) => (column, value.subst base) + fun v => match writes.find? (fun w => w.1 == v) with + | some w => w.2 + | none => base v + +end Aiur.Optimized.Grouping diff --git a/Aiur/Aiur/Optimized/InactiveBasics.lean b/Aiur/Aiur/Optimized/InactiveBasics.lean new file mode 100644 index 000000000..481dbdd12 --- /dev/null +++ b/Aiur/Aiur/Optimized/InactiveBasics.lean @@ -0,0 +1,193 @@ +import Aiur.Optimized.ValidationWitness + +namespace Aiur.Optimized.Compiler + +variable {F : Type} [Field F] [DecidableEq F] + +/-- Construction context for a disabled source expression. Unconditional +selector equations are still witnessed; ordinary payload obligations vanish. -/ +structure InactiveContext (rom : WireROM F) (calls : Circuit.CallRelation F) + (scope : ScopeId) (state : State F) (assignment : Witness → F) : Prop where + layout : state.toReference.WellFormed + scopeLayout : state.Scoped + valid : state.Valid rom calls assignment + scopeValid : scope < state.scopes.size + inactive : (state.activation scope).denote assignment = 0 + +namespace InactiveContext + +variable {rom : WireROM F} {calls : Circuit.CallRelation F} {scope : ScopeId} + {before after : State F} {initial assignment : Witness → F} + +theorem advance (context : InactiveContext rom calls scope before initial) + (structurePreserved : before.Extends after ∧ after.Scoped) + (extension : Extension rom calls before after initial assignment) : + InactiveContext rom calls scope after assignment := + ⟨extension.layout, structurePreserved.2, extension.validAssignment, + structurePreserved.1.scopeValid context.scopeValid, + (extension.activation structurePreserved.1 context.scopeLayout context.scopeValid).trans context.inactive⟩ + +theorem refl (context : InactiveContext rom calls scope before initial) : + Extension rom calls before before initial initial := + .refl context.layout ((before.valid_iff_reference rom calls initial).mp context.valid) + +theorem afterLower (context : InactiveContext rom calls scope before initial) + {program : Program F} {function : String} {locals : Locals F} {expr : Expr F} + {target : Option (WireValue Witness)} {value : Symbolic F} + (compiled : lower program function locals scope expr target before = .ok (value, after)) + (extension : Extension rom calls before after initial assignment) : + InactiveContext rom calls scope after assignment := + context.advance (lower_scoped compiled context.scopeLayout context.scopeValid) extension + +theorem afterArgs (context : InactiveContext rom calls scope before initial) + {program : Program F} {function : String} {locals : Locals F} {args : List (Expr F)} + {values : List (Symbolic F)} + (compiled : lowerArgs program function locals scope args before = .ok (values, after)) + (extension : Extension rom calls before after initial assignment) : + InactiveContext rom calls scope after assignment := + context.advance (lowerArgs_scoped compiled context.scopeLayout context.scopeValid) extension + +theorem destination (context : InactiveContext rom calls scope before initial) + {decls : Declarations} {type : Ty} {target : Option (WireValue Witness)} {vars : WireValue Witness} + (compiled : destination decls scope type target before = .ok (vars, after)) + (targetBound : ∀ candidate, target = some candidate → + Circuit.Compiler.Bounded (F := F) before.roles.size (candidate.map Polynomial.var)) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + InactiveContext rom calls scope after assignment ∧ + Circuit.Compiler.Bounded (F := F) after.roles.size (vars.map Polynomial.var) := by + obtain ⟨a, extension, bounded⟩ := destination_inactive compiled context.layout context.valid targetBound + exact ⟨a, extension, context.advance + ⟨destination_extends compiled, destination_scoped compiled context.scopeLayout⟩ extension, bounded⟩ + +theorem validate (context : InactiveContext rom calls scope before initial) + {decls : Declarations} {value : Symbolic F} + (compiled : validateValue decls scope value before = .ok ((), after)) + (bounded : Circuit.Compiler.Bounded before.roles.size value) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + InactiveContext rom calls scope after assignment := by + obtain ⟨a, extension⟩ := validateValue_inactive compiled context.layout context.scopeLayout + context.valid context.scopeValid bounded context.inactive + exact ⟨a, extension, context.advance + (validateValue_scoped compiled context.scopeLayout context.scopeValid) extension⟩ + +theorem equations (context : InactiveContext rom calls scope before initial) + {conditions : List (Polynomial F)} + (compiled : (do for condition in conditions do equation scope condition : Build F Unit) + before = .ok ((), after)) + (bounded : ∀ condition ∈ conditions, condition.inBounds before.roles.size = true) : + Extension rom calls before after initial initial ∧ InactiveContext rom calls scope after initial := by + have extension := equations_complete compiled context.layout context.valid + (context.scopeLayout.activation_bound scope) bounded (Or.inl context.inactive) + exact ⟨extension, context.advance + ⟨equations_grow compiled, equations_scoped compiled context.scopeLayout context.scopeValid⟩ extension⟩ + +theorem equal (context : InactiveContext rom calls scope before initial) + {left right : Symbolic F} (compiled : equalValue scope left right before = .ok ((), after)) + (leftBound : Circuit.Compiler.Bounded before.roles.size left) + (rightBound : Circuit.Compiler.Bounded before.roles.size right) : + Extension rom calls before after initial initial ∧ InactiveContext rom calls scope after initial := by + have extension := equalValue_complete compiled context.layout context.valid + (context.scopeLayout.activation_bound scope) leftBound rightBound (Or.inl context.inactive) + exact ⟨extension, context.advance (equalValue_structural compiled context.scopeLayout context.scopeValid) extension⟩ + +theorem equation (context : InactiveContext rom calls scope before initial) + {polynomial : Polynomial F} (compiled : equation scope polynomial before = .ok ((), after)) + (bounded : polynomial.inBounds before.roles.size = true) : + Extension rom calls before after initial initial ∧ InactiveContext rom calls scope after initial := by + have extension := equation_complete compiled context.layout context.valid (by + simp only [Scalar.Circuit.ArithExpr.inBounds, Bool.and_eq_true] + exact ⟨context.scopeLayout.activation_bound scope, bounded⟩) (by simp [context.inactive]) + exact ⟨extension, context.advance + ⟨equation_grow compiled, equation_scoped compiled context.scopeLayout context.scopeValid⟩ extension⟩ + +theorem fresh (context : InactiveContext rom calls scope before initial) {role : Role} {id : Witness} + (compiled : fresh role before = .ok (id, after)) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + InactiveContext rom calls scope after assignment ∧ id < after.roles.size := by + obtain ⟨a, extension, bounded, _⟩ := fresh_complete compiled context.layout context.valid (0 : F) + exact ⟨a, extension, context.advance ⟨fresh_extends compiled, fresh_scoped compiled context.scopeLayout⟩ extension, + bounded⟩ + +theorem cell (context : InactiveContext rom calls scope before initial) {address : Polynomial F} {value : Symbolic F} + (compiled : (modify (fun state => {state with cells := state.cells.push ⟨scope, address, value⟩}) : Build F Unit) + before = .ok ((), after)) + (addressBound : address.inBounds before.roles.size = true) + (valueBound : Circuit.Compiler.Bounded before.roles.size value) : + Extension rom calls before after initial initial ∧ InactiveContext rom calls scope after initial := by + have extension := cell_complete compiled context.layout context.valid + (context.scopeLayout.activation_bound scope) addressBound valueBound (by + intro active + have impossible : (0 : F) = 1 := context.inactive.symm.trans active + exact False.elim (zero_ne_one impossible)) + change Except.ok ((), {before with cells := before.cells.push ⟨scope, address, value⟩}) = .ok ((), after) at compiled + have stateEq := (Prod.mk.inj (Except.ok.inj compiled)).2 + subst after + exact ⟨extension, context.advance (pushCell_scoped context.scopeLayout ⟨scope, address, value⟩ context.scopeValid) extension⟩ + +theorem call (context : InactiveContext rom calls scope before initial) + {name : String} {args : List (Symbolic F)} {result : WireValue Witness} + (compiled : (modify (fun state => {state with calls := state.calls.push ⟨scope, name, args, result⟩}) : Build F Unit) + before = .ok ((), after)) + (argsBound : ∀ arg ∈ args, Circuit.Compiler.Bounded before.roles.size arg) + (resultBound : Circuit.Compiler.Bounded (F := F) before.roles.size (result.map Polynomial.var)) : + Extension rom calls before after initial initial ∧ InactiveContext rom calls scope after initial := by + have extension := call_complete compiled context.layout context.valid + (context.scopeLayout.activation_bound scope) argsBound resultBound (by + intro active + have impossible : (0 : F) = 1 := context.inactive.symm.trans active + exact False.elim (zero_ne_one impossible)) + change Except.ok ((), {before with calls := before.calls.push ⟨scope, name, args, result⟩}) = .ok ((), after) at compiled + have stateEq := (Prod.mk.inj (Except.ok.inj compiled)).2 + subst after + exact ⟨extension, context.advance (pushCall_scoped context.scopeLayout ⟨scope, name, args, result⟩ context.scopeValid) extension⟩ + +theorem validateMany (context : InactiveContext rom calls scope before initial) + {decls : Declarations} {values : List (Symbolic F)} + (compiled : (forIn values PUnit.unit (fun value _ => do + validateValue decls scope value + pure (ForInStep.yield PUnit.unit)) : Build F PUnit) before = .ok (PUnit.unit, after)) + (bounded : ∀ value ∈ values, Circuit.Compiler.Bounded before.roles.size value) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + InactiveContext rom calls scope after assignment := by + have wrapped : (do for value in values do validateValue decls scope value : Build F Unit) + before = .ok ((), after) := bind_ok.mpr ⟨PUnit.unit, after, compiled, rfl⟩ + obtain ⟨a, extension⟩ := validateValues_inactive wrapped context.layout context.scopeLayout context.valid + context.scopeValid bounded context.inactive + have structural := forIn_scoped compiled context.scopeLayout context.scopeValid + (fun _ _ {_ _} run layout bound => validateValue_scoped run layout bound) + exact ⟨a, extension, context.advance structural extension⟩ + +theorem failure (context : InactiveContext rom calls scope before initial) {conditions : List (Polynomial F)} + (compiled : failure scope conditions before = .ok ((), after)) + (bounded : ∀ condition ∈ conditions, condition.inBounds before.roles.size = true) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + InactiveContext rom calls scope after assignment := by + obtain ⟨a, extension⟩ := failure_complete compiled context.layout context.valid + (context.scopeLayout.activation_bound scope) bounded (Or.inl context.inactive) + exact ⟨a, extension, context.advance (failure_scoped compiled context.scopeLayout context.scopeValid) extension⟩ + +theorem failures (context : InactiveContext rom calls scope before initial) {previous : List (List (Polynomial F))} + (compiled : (forIn previous PUnit.unit (fun conditions _ => do + Compiler.failure scope conditions + pure (ForInStep.yield PUnit.unit)) : Build F PUnit) before = .ok (PUnit.unit, after)) + (bounded : ∀ conditions ∈ previous, ∀ condition ∈ conditions, condition.inBounds before.roles.size = true) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + InactiveContext rom calls scope after assignment := by + induction previous generalizing before initial with + | nil => + obtain ⟨_, stateEq⟩ := pure_ok.mp (by simpa only [List.forIn_nil] using compiled) + subst after + exact ⟨initial, context.refl, context⟩ + | cons conditions rest ih => + simp only [List.forIn_cons] at compiled + obtain ⟨step, middle, stepRun, tailRun⟩ := bind_ok.mp compiled + obtain ⟨⟨⟩, last, headRun, headFinish⟩ := bind_ok.mp stepRun + obtain ⟨rfl, stateEq⟩ := pure_ok.mp headFinish + subst middle + obtain ⟨a, headExt, headContext⟩ := context.failure headRun (bounded conditions (by simp)) + obtain ⟨b, tailExt, tailContext⟩ := ih headContext tailRun + (fun conditions member condition inside => headExt.bound (bounded conditions (by simp [member]) condition inside)) + exact ⟨b, headExt.trans tailExt, tailContext⟩ + +end InactiveContext +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/InactiveWitness.lean b/Aiur/Aiur/Optimized/InactiveWitness.lean new file mode 100644 index 000000000..2c9690953 --- /dev/null +++ b/Aiur/Aiur/Optimized/InactiveWitness.lean @@ -0,0 +1,436 @@ +import Aiur.Optimized.InactiveBasics + +namespace Aiur.Optimized.Compiler + +variable {F : Type} [Field F] [DecidableEq F] +set_option maxHeartbeats 3000000 +set_option maxRecDepth 8192 + +mutual + /-- Every disabled expression admits all fresh witnesses, including the +unconditional Boolean/coverage equations introduced by nested choices. -/ + theorem lower_inactive {program : Program F} {function : String} {locals : Locals F} + {scope : ScopeId} {expr : Expr F} {target : Option (WireValue Witness)} {output : Symbolic F} + {before after : State F} + (compiled : lower program function locals scope expr target before = .ok (output, after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (scopeLayout : before.Scoped) + (valid : before.Valid rom calls initial) (scopeValid : scope < before.scopes.size) + (localsBound : Circuit.Compiler.LocalsBounded before.roles.size locals) + (targetBound : ∀ candidate, target = some candidate → + Circuit.Compiler.Bounded (F := F) before.roles.size (candidate.map Polynomial.var)) + (inactive : (before.activation scope).denote initial = 0) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + Circuit.Compiler.Bounded after.roles.size output := by + let start : InactiveContext rom calls scope before initial := ⟨layout, scopeLayout, valid, scopeValid, inactive⟩ + rw [lower.eq_def] at compiled + obtain ⟨value, middle, stepRun, finished⟩ := bind_ok.mp compiled + have step : ∃ assignment, Extension rom calls before middle initial assignment ∧ + InactiveContext rom calls scope middle assignment ∧ Circuit.Compiler.Bounded middle.roles.size value := by + cases expr with + | literal literal => + obtain ⟨rfl, stateEq⟩ := pure_ok.mp stepRun + subst middle + exact ⟨initial, start.refl, start, Circuit.Compiler.bounded_field.mpr rfl⟩ + | var name => + cases found : locals.find? (·.1 == name) with + | none => simp [found] at stepRun + | some binding => + rcases binding with ⟨key, wire⟩ + simp only [found] at stepRun + obtain ⟨rfl, stateEq⟩ := pure_ok.mp stepRun + subst middle + exact ⟨initial, start.refl, start, localsBound _ (List.mem_of_find?_eq_some found)⟩ + | tuple items => + obtain ⟨values, s₁, argsRun, pureRun⟩ := bind_ok.mp stepRun + obtain ⟨rfl, stateEq⟩ := pure_ok.mp pureRun + subst middle + obtain ⟨a, extension, bounded⟩ := lowerArgs_inactive argsRun layout scopeLayout valid scopeValid localsBound inactive + exact ⟨a, extension, start.afterArgs argsRun extension, Circuit.Compiler.bounded_tuple.mpr bounded⟩ + | construct name ctor args => + cases found : program.enums.findEnum? name with + | none => simp [found] at stepRun + | some definition => + simp only [found] at stepRun + cases atIndex : definition.constructors[definition.constructors.findIdx (·.name == ctor)]? with + | none => simp [atIndex] at stepRun + | some constructor => + simp only [atIndex] at stepRun + obtain ⟨values, s₁, argsRun, checkBind⟩ := bind_ok.mp stepRun + split at checkBind + · simp [StateT.bind, bind, Except.bind] at checkBind + · obtain ⟨⟨⟩, s₂, unchanged, layoutBind⟩ := bind_ok.mp checkBind + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst s₂ + obtain ⟨typeLayout, s₃, layoutRun, widthBind⟩ := bind_ok.mp layoutBind + obtain ⟨_, stateEq⟩ := getLayout_eq layoutRun + subst s₃ + split at widthBind + · simp [StateT.bind, bind, Except.bind] at widthBind + · obtain ⟨⟨⟩, s₄, unchanged, pureRun⟩ := bind_ok.mp widthBind + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst s₄ + obtain ⟨rfl, stateEq⟩ := pure_ok.mp pureRun + subst middle + obtain ⟨a, extension, bounded⟩ := lowerArgs_inactive argsRun layout scopeLayout valid scopeValid localsBound inactive + refine ⟨a, extension, start.afterArgs argsRun extension, ?_⟩ + unfold Circuit.Compiler.Bounded + refine Layout.enumWords_all _ _ _ ?_ ?_ + · rfl + · intro polynomial member + simp only [List.mem_append] at member + rcases member with member | member + · obtain ⟨wire, member, leaf⟩ := List.mem_flatMap.mp member + exact bounded wire member polynomial leaf + · have same : polynomial = .const 0 := List.eq_of_mem_replicate member + subst polynomial + rfl + | project operand index => + obtain ⟨wire, s₁, operandRun, projectBind⟩ := bind_ok.mp stepRun + cases typeEq : wire.type with + | field | ptr | enum => simp [typeEq] at projectBind + | tuple types => + simp only [typeEq] at projectBind + obtain ⟨items, s₂, splitRun, resultRun⟩ := bind_ok.mp projectBind + obtain ⟨stateEq, _⟩ := splitValues_reference splitRun + subst s₂ + cases found : items[index]? with + | none => simp [found] at resultRun + | some result => + simp only [found] at resultRun + obtain ⟨rfl, stateEq⟩ := pure_ok.mp resultRun + subst middle + obtain ⟨a, extension, bounded⟩ := lower_inactive operandRun layout scopeLayout valid scopeValid localsBound + (by simp) inactive + exact ⟨a, extension, start.afterLower operandRun extension, + splitValues_bounded splitRun bounded result (List.mem_of_getElem? found)⟩ + | letValue pat operand body => + obtain ⟨wire, s₁, operandRun, patternBind⟩ := bind_ok.mp stepRun + obtain ⟨⟨conditions, bindings⟩, s₂, patternRun, equationsBind⟩ := bind_ok.mp patternBind + obtain ⟨⟨⟩, s₃, equationRun, bodyRun⟩ := bind_ok.mp equationsBind + have stateEq := pattern_unchanged patternRun + subst s₂ + have equationRun' : (do for condition in conditions do equation scope condition : Build F Unit) + s₁ = .ok ((), s₃) := bind_ok.mpr ⟨PUnit.unit, s₃, equationRun, rfl⟩ + obtain ⟨a, e₁, wireBound⟩ := lower_inactive operandRun layout scopeLayout valid scopeValid localsBound (by simp) inactive + have c₁ := start.afterLower operandRun e₁ + obtain ⟨_, conditionsBound, bindingsBound⟩ := pattern_bounded patternRun wireBound + obtain ⟨e₂, c₂⟩ := c₁.equations equationRun' conditionsBound + have chain := e₁.trans e₂ + obtain ⟨b, e₃, bodyBound⟩ := lower_inactive bodyRun c₂.layout c₂.scopeLayout c₂.valid c₂.scopeValid + (Circuit.Compiler.localsBounded_append.mpr ⟨bindingsBound.mono e₂.increase, localsBound.mono chain.increase⟩) + (fun candidate equal => (targetBound candidate equal).mono chain.increase) c₂.inactive + exact ⟨b, chain.trans e₃, c₂.afterLower bodyRun e₃, bodyBound⟩ + | store operand => + obtain ⟨wire, s₁, operandRun, destinationBind⟩ := bind_ok.mp stepRun + obtain ⟨result, s₂, destinationRun, pointerBind⟩ := bind_ok.mp destinationBind + cases wordsEq : result.words with + | nil => simp [wordsEq] at pointerBind + | cons address rest => + cases rest with + | cons => simp [wordsEq] at pointerBind + | nil => + simp only [wordsEq] at pointerBind + obtain ⟨⟨⟩, s₃, storeRun, pureRun⟩ := bind_ok.mp pointerBind + obtain ⟨rfl, stateEq⟩ := pure_ok.mp pureRun + subst middle + obtain ⟨a, e₁, wireBound⟩ := lower_inactive operandRun layout scopeLayout valid scopeValid localsBound (by simp) inactive + have c₁ := start.afterLower operandRun e₁ + obtain ⟨b, e₂, c₂, resultBound⟩ := c₁.destination destinationRun + (fun candidate equal => (targetBound candidate equal).mono e₁.increase) + have addressBound := resultBound (.var address) (by simp [WireValue.words_map, wordsEq]) + obtain ⟨e₃, c₃⟩ := c₂.cell storeRun addressBound (wireBound.mono e₂.increase) + exact ⟨b, (e₁.trans e₂).trans e₃, c₃, resultBound.mono e₃.increase⟩ + | load operand => + obtain ⟨pointer, s₁, operandRun, pointerBind⟩ := bind_ok.mp stepRun + rcases pointer with ⟨type, words⟩ + cases type with + | field | tuple | enum => simp at pointerBind + | ptr type => + cases words with + | nil => simp at pointerBind + | cons address rest => + cases rest with + | cons => simp at pointerBind + | nil => + dsimp only at pointerBind + obtain ⟨result, s₂, destinationRun, loadBind⟩ := bind_ok.mp pointerBind + obtain ⟨⟨⟩, s₃, loadRun, pureRun⟩ := bind_ok.mp loadBind + obtain ⟨rfl, stateEq⟩ := pure_ok.mp pureRun + subst middle + obtain ⟨a, e₁, pointerBound⟩ := lower_inactive operandRun layout scopeLayout valid scopeValid localsBound (by simp) inactive + have c₁ := start.afterLower operandRun e₁ + obtain ⟨b, e₂, c₂, resultBound⟩ := c₁.destination destinationRun + (fun candidate equal => (targetBound candidate equal).mono e₁.increase) + have addressBound := pointerBound address (by simp) + obtain ⟨e₃, c₃⟩ := c₂.cell loadRun (e₂.bound addressBound) resultBound + exact ⟨b, (e₁.trans e₂).trans e₃, c₃, resultBound.mono e₃.increase⟩ + | neg operand => + obtain ⟨wire, s₁, operandRun, fieldBind⟩ := bind_ok.mp stepRun + obtain ⟨polynomial, s₂, fieldRun, pureRun⟩ := bind_ok.mp fieldBind + obtain ⟨shape, stateEq⟩ := asField_eq fieldRun + subst s₂ + obtain ⟨rfl, stateEq⟩ := pure_ok.mp pureRun + subst middle + obtain ⟨a, extension, bounded⟩ := lower_inactive operandRun layout scopeLayout valid scopeValid localsBound (by simp) inactive + have scalarBound : polynomial.inBounds s₁.roles.size = true := by + simpa only [shape, Circuit.Compiler.bounded_field] using bounded + exact ⟨a, extension, start.afterLower operandRun extension, + Circuit.Compiler.bounded_field.mpr (by simp [Scalar.Circuit.ArithExpr.inBounds, scalarBound])⟩ + | hint type key channel => + obtain ⟨keyWire, s₁, keyRun, pointerCheck⟩ := bind_ok.mp stepRun + split at pointerCheck + · simp [StateT.bind, bind, Except.bind] at pointerCheck + · obtain ⟨⟨⟩, s₂, unchanged, destinationBind⟩ := bind_ok.mp pointerCheck + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst s₂ + obtain ⟨result, s₃, destinationRun, validationBind⟩ := bind_ok.mp destinationBind + obtain ⟨⟨⟩, s₄, validationRun, pureRun⟩ := bind_ok.mp validationBind + obtain ⟨rfl, stateEq⟩ := pure_ok.mp pureRun + subst middle + obtain ⟨a, e₁, _⟩ := lower_inactive keyRun layout scopeLayout valid scopeValid localsBound (by simp) inactive + have c₁ := start.afterLower keyRun e₁ + obtain ⟨b, e₂, c₂, resultBound⟩ := c₁.destination destinationRun + (fun candidate equal => (targetBound candidate equal).mono e₁.increase) + obtain ⟨c, e₃, c₃⟩ := c₂.validate validationRun resultBound + exact ⟨c, (e₁.trans e₂).trans e₃, c₃, resultBound.mono e₃.increase⟩ + | assertEq message left right => + obtain ⟨leftWire, s₁, leftRun, rightBind⟩ := bind_ok.mp stepRun + obtain ⟨rightWire, s₂, rightRun, pointerCheck⟩ := bind_ok.mp rightBind + split at pointerCheck + · simp [StateT.bind, bind, Except.bind] at pointerCheck + · obtain ⟨⟨⟩, s₃, unchanged, equalityBind⟩ := bind_ok.mp pointerCheck + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst s₃ + obtain ⟨⟨⟩, s₄, equalityRun, pureRun⟩ := bind_ok.mp equalityBind + obtain ⟨rfl, stateEq⟩ := pure_ok.mp pureRun + subst middle + obtain ⟨a, e₁, leftBound⟩ := lower_inactive leftRun layout scopeLayout valid scopeValid localsBound (by simp) inactive + have c₁ := start.afterLower leftRun e₁ + obtain ⟨b, e₂, rightBound⟩ := lower_inactive rightRun c₁.layout c₁.scopeLayout c₁.valid c₁.scopeValid + (localsBound.mono e₁.increase) (by simp) c₁.inactive + have c₂ := c₁.afterLower rightRun e₂ + obtain ⟨e₃, c₃⟩ := c₂.equal equalityRun (leftBound.mono e₂.increase) rightBound + exact ⟨b, (e₁.trans e₂).trans e₃, c₃, Circuit.Compiler.bounded_tuple.mpr (by simp)⟩ + | binary op left right => + obtain ⟨leftWire, s₁, leftRun, leftFieldBind⟩ := bind_ok.mp stepRun + obtain ⟨leftWord, s₂, leftFieldRun, rightBind⟩ := bind_ok.mp leftFieldBind + obtain ⟨leftShape, stateEq⟩ := asField_eq leftFieldRun + subst s₂ + obtain ⟨rightWire, s₃, rightRun, rightFieldBind⟩ := bind_ok.mp rightBind + obtain ⟨rightWord, s₄, rightFieldRun, operatorRun⟩ := bind_ok.mp rightFieldBind + obtain ⟨rightShape, stateEq⟩ := asField_eq rightFieldRun + subst s₄ + obtain ⟨a, e₁, leftBound⟩ := lower_inactive leftRun layout scopeLayout valid scopeValid localsBound (by simp) inactive + have c₁ := start.afterLower leftRun e₁ + obtain ⟨b, e₂, rightBound⟩ := lower_inactive rightRun c₁.layout c₁.scopeLayout c₁.valid c₁.scopeValid + (localsBound.mono e₁.increase) (by simp) c₁.inactive + have c₂ := c₁.afterLower rightRun e₂ + have leftWordBound : leftWord.inBounds s₃.roles.size = true := by + simpa only [leftShape, Circuit.Compiler.bounded_field, State.toReference] using leftBound.mono e₂.increase + have rightWordBound : rightWord.inBounds s₃.roles.size = true := by + simpa only [rightShape, Circuit.Compiler.bounded_field] using rightBound + cases op with + | add | sub | mul => + obtain ⟨rfl, stateEq⟩ := pure_ok.mp operatorRun + subst middle + refine ⟨b, e₁.trans e₂, c₂, Circuit.Compiler.bounded_field.mpr ?_⟩ + simp [Scalar.Circuit.ArithExpr.inBounds, leftWordBound, rightWordBound] + | div => + cases folded : rightWord.constantInverse? with + | some inverse => + simp only [folded] at operatorRun + obtain ⟨rfl, stateEq⟩ := pure_ok.mp operatorRun + subst middle + refine ⟨b, e₁.trans e₂, c₂, Circuit.Compiler.bounded_field.mpr ?_⟩ + simpa [Scalar.Circuit.ArithExpr.inBounds] using leftWordBound + | none => + simp only [folded] at operatorRun + obtain ⟨inverse, s₅, inverseRun, equationBind⟩ := bind_ok.mp operatorRun + obtain ⟨⟨⟩, s₆, equationRun, pureRun⟩ := bind_ok.mp equationBind + obtain ⟨rfl, stateEq⟩ := pure_ok.mp pureRun + subst middle + obtain ⟨c, e₃, c₃, inverseBound⟩ := c₂.fresh inverseRun + have inversePolyBound : (Polynomial.var inverse : Polynomial F).inBounds s₅.roles.size = true := by + simpa [Scalar.Circuit.ArithExpr.inBounds] using inverseBound + obtain ⟨e₄, c₄⟩ := c₃.equation equationRun (by + simp only [Scalar.Circuit.ArithExpr.inBounds, Bool.and_eq_true, and_true] + exact ⟨e₃.bound rightWordBound, inversePolyBound⟩) + refine ⟨c, ((e₁.trans e₂).trans e₃).trans e₄, c₄, Circuit.Compiler.bounded_field.mpr ?_⟩ + simpa only [Scalar.Circuit.ArithExpr.inBounds, Bool.and_eq_true, State.toReference] using + And.intro ((e₃.trans e₄).bound leftWordBound) (e₄.bound inversePolyBound) + | call name args => + cases found : program.findSignature? name with + | none => simp [found] at stepRun + | some callee => + simp only [found] at stepRun + obtain ⟨argValues, s₁, argsRun, checkBind⟩ := bind_ok.mp stepRun + split at checkBind + · simp [StateT.bind, bind, Except.bind] at checkBind + · obtain ⟨⟨⟩, s₂, unchanged, destinationBind⟩ := bind_ok.mp checkBind + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst s₂ + obtain ⟨result, s₃, destinationRun, callBind⟩ := bind_ok.mp destinationBind + obtain ⟨⟨⟩, s₆, callRun, pureRun⟩ := bind_ok.mp callBind + obtain ⟨rfl, stateEq⟩ := pure_ok.mp pureRun + subst middle + obtain ⟨a, e₁, argsBound⟩ := lowerArgs_inactive argsRun layout scopeLayout valid scopeValid localsBound inactive + have c₁ := start.afterArgs argsRun e₁ + obtain ⟨b, e₂, c₂, resultBound⟩ := c₁.destination destinationRun + (fun candidate equal => (targetBound candidate equal).mono e₁.increase) + obtain ⟨e₃, c₃⟩ := c₂.call callRun + (fun arg member => (argsBound arg member).mono e₂.increase) resultBound + exact ⟨b, (e₁.trans e₂).trans e₃, c₃, resultBound.mono e₃.increase⟩ + | matchValue scrutinee arms => + obtain ⟨checked, s₁, checkRun, typeBind⟩ := bind_ok.mp stepRun + have stateEq := lift_unchanged checkRun + subst s₁ + obtain ⟨type, s₂, typeRun, scrutineeBind⟩ := bind_ok.mp typeBind + have stateEq := lift_unchanged typeRun + subst s₂ + obtain ⟨scrutineeWire, s₃, scrutineeRun, destinationBind⟩ := bind_ok.mp scrutineeBind + obtain ⟨result, s₄, destinationRun, choiceBind⟩ := bind_ok.mp destinationBind + obtain ⟨branches, s₆, choiceRun, armsBind⟩ := bind_ok.mp choiceBind + obtain ⟨⟨⟩, s₇, armsRun, pureRun⟩ := bind_ok.mp armsBind + obtain ⟨rfl, stateEq⟩ := pure_ok.mp pureRun + subst middle + obtain ⟨a, e₁, scrutineeBound⟩ := lower_inactive scrutineeRun layout scopeLayout valid scopeValid localsBound (by simp) inactive + have c₁ := start.afterLower scrutineeRun e₁ + obtain ⟨b, e₂, c₂, resultBound⟩ := c₁.destination destinationRun + (fun candidate equal => (targetBound candidate equal).mono e₁.increase) + obtain ⟨d, e₄, selected⟩ := choice_complete choiceRun c₂.layout c₂.scopeLayout c₂.valid none (by simpa using c₂.inactive) + have c₄ := c₂.advance ⟨choice_extends choiceRun, choice_scoped choiceRun c₂.scopeLayout⟩ e₄ + have branchesInactive : ∀ branch ∈ branches, (s₆.activation branch).denote d = 0 := by + intro branch member + obtain ⟨i, bounded, equal⟩ := List.getElem_of_mem member + simpa [choiceSelected, equal] using selected ⟨i, bounded⟩ + have chain := (e₁.trans e₂).trans e₄ + obtain ⟨e, e₅⟩ := lowerArms_inactive armsRun c₄.layout c₄.scopeLayout c₄.valid + (choice_child_bound choiceRun) (localsBound.mono chain.increase) + (scrutineeBound.mono (e₂.trans e₄).increase) + (resultBound.mono e₄.increase) (by simp) branchesInactive + have c₅ := c₄.advance (lowerArms_scoped armsRun c₄.scopeLayout (choice_child_bound choiceRun)) e₅ + exact ⟨e, chain.trans e₅, c₅, resultBound.mono (e₄.trans e₅).increase⟩ + obtain ⟨a, extension, context, bounded⟩ := step + cases target with + | none => + obtain ⟨rfl, stateEq⟩ := pure_ok.mp finished + subst after + exact ⟨a, extension, bounded⟩ + | some target => + obtain ⟨⟨⟩, last, equalRun, pureRun⟩ := bind_ok.mp finished + obtain ⟨rfl, stateEq⟩ := pure_ok.mp pureRun + subst after + obtain ⟨equalExt, _⟩ := context.equal equalRun ((targetBound target rfl).mono extension.increase) bounded + exact ⟨a, extension.trans equalExt, (targetBound target rfl).mono (extension.trans equalExt).increase⟩ + termination_by sizeOf expr + + theorem lowerArgs_inactive {program : Program F} {function : String} {locals : Locals F} + {scope : ScopeId} {args : List (Expr F)} {output : List (Symbolic F)} {before after : State F} + (compiled : lowerArgs program function locals scope args before = .ok (output, after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (scopeLayout : before.Scoped) + (valid : before.Valid rom calls initial) (scopeValid : scope < before.scopes.size) + (localsBound : Circuit.Compiler.LocalsBounded before.roles.size locals) + (inactive : (before.activation scope).denote initial = 0) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + ∀ value ∈ output, Circuit.Compiler.Bounded after.roles.size value := by + cases args with + | nil => + obtain ⟨rfl, stateEq⟩ := pure_ok.mp (by simpa only [lowerArgs] using compiled) + subst after + exact ⟨initial, .refl layout ((before.valid_iff_reference rom calls initial).mp valid), by simp⟩ + | cons arg rest => + simp only [lowerArgs] at compiled + obtain ⟨head, s₁, headRun, tailBind⟩ := bind_ok.mp compiled + obtain ⟨tail, s₂, tailRun, pureRun⟩ := bind_ok.mp tailBind + obtain ⟨rfl, stateEq⟩ := pure_ok.mp pureRun + subst after + obtain ⟨a, e₁, headBound⟩ := lower_inactive headRun layout scopeLayout valid scopeValid localsBound (by simp) inactive + have start : InactiveContext rom calls scope before initial := ⟨layout, scopeLayout, valid, scopeValid, inactive⟩ + have context := start.afterLower headRun e₁ + obtain ⟨b, e₂, tailBound⟩ := lowerArgs_inactive tailRun context.layout context.scopeLayout context.valid + context.scopeValid (localsBound.mono e₁.increase) context.inactive + refine ⟨b, e₁.trans e₂, ?_⟩ + intro value member + rcases List.mem_cons.mp member with rfl | member + · exact headBound.mono e₂.increase + · exact tailBound value member + termination_by sizeOf args + + theorem lowerArms_inactive {program : Program F} {function : String} {locals : Locals F} + {scrutinee : Symbolic F} {result : WireValue Witness} {branches : List ScopeId} + {arms : List (Pattern F × Expr F)} {previous : List (List (Polynomial F))} {before after : State F} + (compiled : lowerArms program function locals scrutinee result branches arms previous before = .ok ((), after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (scopeLayout : before.Scoped) + (valid : before.Valid rom calls initial) (branchesValid : ∀ branch ∈ branches, branch < before.scopes.size) + (localsBound : Circuit.Compiler.LocalsBounded before.roles.size locals) + (scrutineeBound : Circuit.Compiler.Bounded before.roles.size scrutinee) + (resultBound : Circuit.Compiler.Bounded (F := F) before.roles.size (result.map Polynomial.var)) + (previousBound : ∀ conditions ∈ previous, ∀ condition ∈ conditions, condition.inBounds before.roles.size = true) + (inactive : ∀ branch ∈ branches, (before.activation branch).denote initial = 0) : + ∃ assignment, Extension rom calls before after initial assignment := by + cases branches with + | nil => + cases arms with + | nil => + obtain ⟨_, stateEq⟩ := pure_ok.mp (by simpa only [lowerArms] using compiled) + subst after + exact ⟨initial, .refl layout ((before.valid_iff_reference rom calls initial).mp valid)⟩ + | cons => simp [lowerArms] at compiled + | cons branch branches => + cases arms with + | nil => simp [lowerArms] at compiled + | cons arm rest => + cases armEq : arm with + | mk pat body => + simp only [armEq, lowerArms] at compiled + obtain ⟨⟨conditions, bindings⟩, s₁, patternRun, equationsBind⟩ := bind_ok.mp compiled + have stateEq := pattern_unchanged patternRun + subst s₁ + obtain ⟨⟨⟩, s₂, equationsRun, failuresBind⟩ := bind_ok.mp equationsBind + obtain ⟨⟨⟩, s₃, failuresRun, bodyBind⟩ := bind_ok.mp failuresBind + obtain ⟨value, s₄, bodyRun, tailRun⟩ := bind_ok.mp bodyBind + let start : InactiveContext rom calls branch before initial := + ⟨layout, scopeLayout, valid, branchesValid branch (by simp), inactive branch (by simp)⟩ + obtain ⟨_, conditionsBound, bindingsBound⟩ := pattern_bounded patternRun scrutineeBound + have equationsRun' : (do for condition in conditions do equation branch condition : Build F Unit) + before = .ok ((), s₂) := bind_ok.mpr ⟨PUnit.unit, s₂, equationsRun, rfl⟩ + obtain ⟨e₁, c₁⟩ := start.equations equationsRun' conditionsBound + obtain ⟨a, e₂, c₂⟩ := c₁.failures failuresRun + (fun conditions member condition inside => e₁.bound (previousBound conditions member condition inside)) + have chain := e₁.trans e₂ + obtain ⟨b, e₃, _⟩ := lower_inactive bodyRun c₂.layout c₂.scopeLayout c₂.valid c₂.scopeValid + (Circuit.Compiler.localsBounded_append.mpr + ⟨bindingsBound.mono chain.increase, localsBound.mono chain.increase⟩) + (fun candidate equal => by cases equal; exact resultBound.mono chain.increase) c₂.inactive + have c₃ := c₂.afterLower bodyRun e₃ + have full := chain.trans e₃ + split at tailRun + · obtain ⟨_, stateEq⟩ := pure_ok.mp tailRun + subst after + exact ⟨b, full⟩ + · have failureStructure := forIn_scoped failuresRun c₁.scopeLayout c₁.scopeValid + (fun _ _ {_ _} run stateShape bound => failure_scoped run stateShape bound) + have structurePreserved := ((equations_grow equationsRun').trans failureStructure.1).trans + (lower_scoped bodyRun c₂.scopeLayout c₂.scopeValid).1 + obtain ⟨c, tailExt⟩ := lowerArms_inactive tailRun c₃.layout c₃.scopeLayout c₃.valid + (fun child member => structurePreserved.scopeValid (branchesValid child (by simp [member]))) + (localsBound.mono full.increase) (scrutineeBound.mono full.increase) (resultBound.mono full.increase) + (by + intro earlier member condition inside + rcases List.mem_append.mp member with old | last + · exact full.bound (previousBound earlier old condition inside) + · obtain rfl := List.mem_singleton.mp last + exact full.bound (conditionsBound condition inside)) + (by + intro child member + rw [Extension.activation full structurePreserved scopeLayout (branchesValid child (by simp [member]))] + exact inactive child (by simp [member])) + exact ⟨c, full.trans tailExt⟩ + termination_by sizeOf arms + decreasing_by all_goals simp_all only [List.cons.sizeOf_spec, Prod.mk.sizeOf_spec]; omega +end + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/Index.lean b/Aiur/Aiur/Optimized/Index.lean new file mode 100644 index 000000000..eb398fa2a --- /dev/null +++ b/Aiur/Aiur/Optimized/Index.lean @@ -0,0 +1,27 @@ +import Std.Data.HashMap.Lemmas + +namespace Aiur.Optimized.Index + +/-- Preserve source order within each natural-number key. Keys describe +compiler metadata, so indexing requires no hashing or ordering on the field. -/ +def build (key : α → Nat) (items : List α) : Std.HashMap Nat (List α) := + items.foldr (fun item buckets => + buckets.insert (key item) (item :: buckets.getD (key item) [])) {} + +/-- An index lookup returns exactly the corresponding subsequence. -/ +theorem getD_build (key : α → Nat) (items : List α) (id : Nat) : + (build key items).getD id [] = items.filter (fun item => key item == id) := by + induction items with + | nil => simp [build] + | cons item items ih => + simp only [build] at ih + simp only [build, List.foldr_cons, Std.HashMap.getD_insert] + by_cases same : key item = id + · simp [same, ih] + · simp [same, ih] + +@[simp] theorem mem_build (key : α → Nat) (items : List α) (item : α) : + item ∈ (build key items).getD (key item) [] ↔ item ∈ items := by + simp [getD_build] + +end Aiur.Optimized.Index diff --git a/Aiur/Aiur/Optimized/Layout.lean b/Aiur/Aiur/Optimized/Layout.lean new file mode 100644 index 000000000..89a944a28 --- /dev/null +++ b/Aiur/Aiur/Optimized/Layout.lean @@ -0,0 +1,202 @@ +import Aiur.Optimized.Basic + +namespace Aiur.Optimized + +/-- Resolve forward selector definitions once, keeping every activation affine. -/ +def resolveAliasValues [Field F] [DecidableEq F] (chip : ScopedChip F) : Except String (Array (Polynomial F)) := do + let mut resolved : Array (Polynomial F) := (List.range chip.roles.size).toArray.map Polynomial.var + for id in (List.range chip.roles.size).reverse do + if let some expr := chip.aliases[id]?.getD none then + unless expr.vars.all (fun v => id < v && v < chip.roles.size) do + throw "selector definitions must refer to later witnesses" + let value := (expr.subst fun v => resolved[v]?.getD (.var v)).simplify + if value.degree > 1 then throw "non-affine selector definition" + resolved := resolved.set! id value + return resolved + +def ScopedChip.substitute [Field F] [DecidableEq F] + (replacement : Witness → Polynomial F) (chip : ScopedChip F) : ScopedChip F := + let replace := fun (expr : Polynomial F) => (expr.subst replacement).simplify + { chip with + scopes := chip.scopes.map fun scope => { scope with activation := replace scope.activation } + equations := chip.equations.map fun eq => { eq with polynomial := replace eq.polynomial } + calls := chip.calls.map fun call => { call with args := call.args.map (WireValue.map replace) } + cells := chip.cells.map fun cell => + { cell with address := replace cell.address, value := cell.value.map replace } + } + +def resolveAliases [Field F] [DecidableEq F] (chip : ScopedChip F) : Except String (ScopedChip F) := do + let resolved ← resolveAliasValues chip + return chip.substitute fun v => resolved[v]?.getD (.var v) + +namespace Degree + +structure State (F : Type) where + chip : ScopedChip F + cache : List (ScopeId × Polynomial F × Witness) := [] + +abbrev Build (F : Type) := StateT (State F) (Except String) + +def emit [Field F] [DecidableEq F] (scope : ScopeId) (expr : Polynomial F) : Build F Unit := do + let expr := expr.simplify + if expr == .const 0 then return + modify fun state => { state with chip.equations := state.chip.equations.push ⟨scope, expr⟩ } + +/-- Reuse only definitions of total expressions in the very same scope. -/ +def materialize [Field F] [DecidableEq F] (scope : ScopeId) (expr : Polynomial F) : Build F (Polynomial F) := do + if let some (_, _, id) := (← get).cache.find? (fun (owner, value, _) => owner == scope && value == expr) then + return .var id + let state ← get + let id := state.chip.roles.size + set { state with + chip.roles := state.chip.roles.push (.auxiliary scope) + chip.aliases := state.chip.aliases.push none + cache := (scope, expr, id) :: state.cache } + emit scope (.sub (.var id) expr) + return .var id + +/-- With budget one, name a quadratic product. With a larger budget, name +oversized operands. Added definitions fit the enclosing scope's degree budget. -/ +def reduce [Field F] [DecidableEq F] (scope : ScopeId) (budget : Nat) : + Polynomial F → Build F (Polynomial F) + | .const value => pure (.const value) + | .var id => pure (.var id) + | .add left right => do + return Polynomial.simplify (.add (← reduce scope budget left) (← reduce scope budget right)) + | .sub left right => do + return Polynomial.simplify (.sub (← reduce scope budget left) (← reduce scope budget right)) + | .mul left right => do + let mut left ← reduce scope budget left + let mut right ← reduce scope budget right + let product := Polynomial.simplify (.mul left right) + if product.degree ≤ budget then return product + if budget == 1 then return ← materialize scope product + if left.degree ≥ right.degree then + left ← materialize scope left + if left.degree + right.degree > budget then right ← materialize scope right + else + right ← materialize scope right + if left.degree + right.degree > budget then left ← materialize scope left + return .mul left right + +def boundState [Field F] [DecidableEq F] (config : Config) (chip : ScopedChip F) : Except String (State F) := do + if config.maxDegree < 3 then throw "the optimized compiler requires a degree cap of at least three" + for scope in chip.scopes do + if scope.activation.degree > 1 then throw "non-affine activation" + let build : Build F Unit := do + for eq in chip.equations do + let some scope := chip.scopes[eq.scope]? | throw "invalid equation scope" + let expr ← reduce eq.scope (config.maxDegree - scope.activation.degree) eq.polynomial + emit eq.scope expr + let calls ← chip.calls.mapM fun call => do + let args ← call.args.mapM fun arg => do + return { arg with words := ← arg.words.mapM (reduce call.scope 1) } + return { call with args } + let cells ← chip.cells.mapM fun cell => do + let address ← reduce cell.scope 1 cell.address + let words ← cell.value.words.mapM (reduce cell.scope 1) + return { cell with address, value := { cell.value with words } } + modify fun state => { state with chip.calls := calls, chip.cells := cells } + let (_, state) ← build.run { chip := { chip with equations := #[] } } + return state + +def bound [Field F] [DecidableEq F] (config : Config) (chip : ScopedChip F) : Except String (ScopedChip F) := + (boundState config chip).map (·.chip) + +end Degree + +def ScopedChip.owns (chip : ScopedChip F) (scope : ScopeId) (expr : Polynomial F) : Bool := + expr.vars.all fun id => + match chip.roles[id]?, chip.scopes[scope]? with + | some (.auxiliary owner), some current => + match chip.scopes[owner]? with + | some declared => declared.path.isPrefixOf current.path + | none => false + | some _, some _ => true + | _, _ => false + +/-- Catch accidental escapes from branch storage before allocating shared columns. -/ +def ScopedChip.wellScoped (chip : ScopedChip F) : Bool := + chip.scopes.all (fun scope => scope.activation.vars.all fun id => chip.roles[id]? == some .selector) && + chip.equations.all (fun eq => chip.owns eq.scope eq.polynomial) && + chip.calls.all (fun call => + (call.args.flatMap WireValue.words).all (chip.owns call.scope) && + call.result.words.all (fun id => chip.owns call.scope (.var id))) && + chip.cells.all (fun cell => chip.owns cell.scope cell.address && + cell.value.words.all (chip.owns cell.scope)) + +def ScopedChip.canShare (chip : ScopedChip F) (left right : Witness) : Bool := + match chip.roles[left]?, chip.roles[right]? with + | some (.auxiliary a), some (.auxiliary b) => + match chip.scopes[a]?, chip.scopes[b]? with + | some a, some b => a.path.exclusive b.path + | _, _ => false + | _, _ => false + +def allocateColumns (config : Config) (chip : ScopedChip F) : ColumnLayout := Id.run do + let mut layout : ColumnLayout := ⟨Array.replicate chip.roles.size none, #[]⟩ + -- Removing an equation can leave its private witnesses in the logical ID + -- space. Do not let those dead witnesses consume or interfere with columns. + -- The allocation certificate below the search still checks every live use. + let used := chip.inputs.flatMap WireValue.words ++ chip.output.words ++ + chip.scopes.toList.flatMap (fun scope => scope.activation.vars) ++ + chip.equations.toList.flatMap (fun eq => eq.polynomial.vars) ++ + chip.calls.toList.flatMap (fun call => + call.args.flatMap (fun value => value.words.flatMap Polynomial.vars) ++ call.result.words) ++ + chip.cells.toList.flatMap (fun cell => cell.address.vars ++ cell.value.words.flatMap Polynomial.vars) + let live := used.foldl (fun set id => set.insert id) (∅ : Std.HashSet Witness) + -- Interfaces and actual selector witnesses never enter the sharing pool. + for id in List.range chip.roles.size do + if (chip.aliases[id]?.getD none).isNone then + match chip.roles[id]? with + | some (.auxiliary _) => pure () + | some _ => + layout := { + columnOf := layout.columnOf.set! id (some layout.occupants.size) + occupants := layout.occupants.push [id] } + | none => pure () + for id in List.range chip.roles.size do + if let some (.auxiliary _) := chip.roles[id]? then + if !live.contains id then continue + let candidate := if config.shareAuxiliaries then + layout.occupants.toList.findIdx (fun occupants => occupants.all (chip.canShare id)) + else layout.occupants.size + if candidate < layout.occupants.size then + layout := { + columnOf := layout.columnOf.set! id (some candidate) + occupants := layout.occupants.modify candidate (id :: ·) } + else + layout := { + columnOf := layout.columnOf.set! id (some layout.occupants.size) + occupants := layout.occupants.push [id] } + return layout + +def ColumnLayout.column (layout : ColumnLayout) (id : Witness) : Circuit.Var := + (layout.columnOf[id]?.getD none).getD layout.occupants.size + +def ColumnLayout.expression [Field F] [DecidableEq F] (layout : ColumnLayout) (value : Polynomial F) : Polynomial F := + (value.subst (Polynomial.var ∘ layout.column)).simplify + +def ScopedChip.activation [Zero F] (chip : ScopedChip F) (scope : ScopeId) : Polynomial F := + ((chip.scopes[scope]?).map Scope.activation).getD (.const 0) + +def emitChip [Field F] [DecidableEq F] (chip : ScopedChip F) (layout : ColumnLayout) : Circuit.Chip F := Id.run do + let column := layout.column + let expr := layout.expression + let enable := fun scope => expr (chip.activation scope) + let constraints := chip.equations.toList.filterMap fun eq => + let polynomial := Polynomial.simplify (.mul (enable eq.scope) (expr eq.polynomial)) + if polynomial == .const 0 then none else some polynomial + return { + name := chip.name + inputs := chip.inputs.map (WireValue.map column) + output := chip.output.map (Polynomial.var ∘ column) + numVars := layout.occupants.size + constraints + sends := chip.calls.toList.map fun call => + ⟨call.channel, call.args.map (WireValue.map expr), call.result.map column, enable call.scope⟩ + memory := chip.cells.toList.map fun cell => + ⟨expr cell.address, cell.value.map expr, enable cell.scope⟩ + } + +end Aiur.Optimized diff --git a/Aiur/Aiur/Optimized/LayoutWitness.lean b/Aiur/Aiur/Optimized/LayoutWitness.lean new file mode 100644 index 000000000..269125ae3 --- /dev/null +++ b/Aiur/Aiur/Optimized/LayoutWitness.lean @@ -0,0 +1,132 @@ +import Aiur.Optimized.ScopedSemantics + +namespace Aiur.Optimized + +variable {F : Type} [Field F] [DecidableEq F] + +/-- Logical variables whose values matter in this assignment. Inactive +payloads are deliberately absent; all activation expressions remain relevant. -/ +inductive ScopedChip.Relevant (chip : ScopedChip F) (assignment : Witness → F) : Witness → Prop + | input {value id} : value ∈ chip.inputs → id ∈ value.words → chip.Relevant assignment id + | output {id} : id ∈ chip.output.words → chip.Relevant assignment id + | activation {scope id} : id ∈ (chip.activation scope).vars → chip.Relevant assignment id + | equation {equation id} : equation ∈ chip.equations.toList → + (chip.activation equation.scope).denote assignment ≠ 0 → id ∈ equation.polynomial.vars → + chip.Relevant assignment id + | callArgument {call value polynomial id} : call ∈ chip.calls.toList → + (chip.activation call.scope).denote assignment = 1 → value ∈ call.args → polynomial ∈ value.words → + id ∈ polynomial.vars → chip.Relevant assignment id + | callResult {call id} : call ∈ chip.calls.toList → + (chip.activation call.scope).denote assignment = 1 → id ∈ call.result.words → chip.Relevant assignment id + | address {cell id} : cell ∈ chip.cells.toList → (chip.activation cell.scope).denote assignment = 1 → + id ∈ cell.address.vars → chip.Relevant assignment id + | payload {cell polynomial id} : cell ∈ chip.cells.toList → (chip.activation cell.scope).denote assignment = 1 → + polynomial ∈ cell.value.words → id ∈ polynomial.vars → chip.Relevant assignment id + +private theorem wire_map_congr {α β : Type} (value : WireValue α) {left right : α → β} + (agree : ∀ word ∈ value.words, left word = right word) : value.map left = value.map right := by + cases value + simp only [WireValue.map, WireValue.mk.injEq, true_and] + exact List.map_congr_left agree + +namespace ScopedChip + +variable {chip : ScopedChip F} {a b : Witness → F} + +omit [DecidableEq F] in +theorem activation_agree (agree : ∀ id, chip.Relevant a id → a id = b id) (scope : ScopeId) : + (chip.activation scope).denote a = (chip.activation scope).denote b := + Polynomial.denote_congr _ (fun _ member => agree _ (.activation member)) + +omit [DecidableEq F] in +theorem conclusion_agree (agree : ∀ id, chip.Relevant a id → a id = b id) : + chip.conclusion a = chip.conclusion b := by + have inputs : chip.inputs.map (WireValue.map a) = chip.inputs.map (WireValue.map b) := by + apply List.map_congr_left + intro value member + exact wire_map_congr value (fun id present => agree id (.input member present)) + have output := wire_map_congr chip.output (fun id present => agree id (.output present)) + simp only [conclusion, inputs, output] + +omit [DecidableEq F] in +theorem call_agree (agree : ∀ id, chip.Relevant a id → a id = b id) {call : Call F} + (member : call ∈ chip.calls.toList) (active : (chip.activation call.scope).denote a = 1) : + call.message a = call.message b := by + have args : call.args.map (WireValue.map (Circuit.ArithExpr.denote a)) = + call.args.map (WireValue.map (Circuit.ArithExpr.denote b)) := by + apply List.map_congr_left + intro value present + apply wire_map_congr + intro polynomial found + exact Polynomial.denote_congr _ (fun id used => agree id (.callArgument member active present found used)) + have result := wire_map_congr call.result (fun id present => agree id (.callResult member active present)) + simp only [Call.message, args, result] + +theorem premises_agree (agree : ∀ id, chip.Relevant a id → a id = b id) : + chip.premises a = chip.premises b := by + apply List.filterMap_congr + intro call member + by_cases active : (chip.activation call.scope).denote a = 1 + · simp only [← activation_agree agree, active, ↓reduceIte, call_agree agree member active] + · simp only [← activation_agree agree, active, ↓reduceIte] + +theorem validAssignment_agree (agree : ∀ id, chip.Relevant a id → a id = b id) + {rom : WireROM F} (valid : chip.ValidAssignment rom a) : chip.ValidAssignment rom b := by + constructor + · intro equation member + rw [← activation_agree agree] + by_cases inactive : (chip.activation equation.scope).denote a = 0 + · simp [inactive] + · have equal := Polynomial.denote_congr equation.polynomial + (fun id used => agree id (.equation member inactive used)) + rw [← equal] + exact valid.1 equation member + · intro cell member active + rw [← activation_agree agree] at active + have address := Polynomial.denote_congr cell.address + (fun id used => agree id (.address member active used)) + have payload : cell.value.map (Circuit.ArithExpr.denote a) = cell.value.map (Circuit.ArithExpr.denote b) := by + apply wire_map_congr + intro polynomial present + exact Polynomial.denote_congr polynomial + (fun id used => agree id (.payload member active present used)) + rw [← address, ← payload] + exact valid.2 cell member active + +end ScopedChip + +/-- Existentially pack a logical witness into shared physical columns. Only +simultaneously relevant values must agree when their columns coincide. -/ +theorem emitChip_complete (chip : ScopedChip F) (layout : ColumnLayout) (rom : WireROM F) + (assignment : Witness → F) (formed : (emitChip chip layout).wellFormed = true) + (valid : chip.ValidAssignment rom assignment) + (bounded : ∀ id, chip.Relevant assignment id → layout.column id < layout.occupants.size) + (compatible : ∀ i j, chip.Relevant assignment i → chip.Relevant assignment j → + layout.column i = layout.column j → assignment i = assignment j) : + ∃ row : Circuit.Row F, row.chip = chip.name ∧ (emitChip chip layout).ValidRow rom row ∧ + (emitChip chip layout).receive row = chip.conclusion assignment ∧ + (emitChip chip layout).premises row = chip.premises assignment := by + classical + let physical : Circuit.Var → F := fun column => + if present : ∃ id, chip.Relevant assignment id ∧ layout.column id = column then + assignment (Classical.choose present) + else 0 + have pack (id : Witness) (relevant : chip.Relevant assignment id) : physical (layout.column id) = assignment id := by + have present : ∃ other, chip.Relevant assignment other ∧ layout.column other = layout.column id := + ⟨id, relevant, rfl⟩ + simp only [physical, dif_pos present] + exact compatible _ id (Classical.choose_spec present).1 relevant (Classical.choose_spec present).2 + let row := Circuit.Row.ofAssignment chip.name layout.occupants.size physical + have agree (id : Witness) (relevant : chip.Relevant assignment id) : + assignment id = (row.assignment ∘ layout.column) id := by + rw [Function.comp_apply, Circuit.Row.ofAssignment_agree _ _ _ _ (bounded id relevant)] + exact (pack id relevant).symm + refine ⟨row, rfl, ?_, ?_, ?_⟩ + · apply (emitChip_validRow chip layout rom row).mpr + exact ⟨formed, Circuit.Row.ofAssignment_length _ _ _, chip.validAssignment_agree agree valid⟩ + · rw [emitChip_receive] + exact (chip.conclusion_agree agree).symm + · rw [emitChip_premises] + exact (chip.premises_agree agree).symm + +end Aiur.Optimized diff --git a/Aiur/Aiur/Optimized/LinearNormalization.lean b/Aiur/Aiur/Optimized/LinearNormalization.lean new file mode 100644 index 000000000..472a6946f --- /dev/null +++ b/Aiur/Aiur/Optimized/LinearNormalization.lean @@ -0,0 +1,218 @@ +import Aiur.Optimized.PolynomialFacts +import Mathlib.Tactic.Ring +import Mathlib.Tactic.LinearCombination + +namespace Aiur.Optimized.LinearNormalization + +variable {F : Type} [Field F] [DecidableEq F] + +/-- Sparse affine coefficients. Combining equal variables prevents substitutions +from repeatedly expanding different expressions for the same linear value. -/ +abbrev Terms (F : Type) := List (Witness × F) + +def Terms.denote (terms : Terms F) (assignment : Witness → F) : F := + (terms.map (fun (id, coefficient) => coefficient * assignment id)).sum + +/-- Merge sorted sparse coefficients. Singleton leaves and scaling preserve +the order, so normalization never needs repeated linear insertion searches. -/ +def Terms.add : Terms F → Terms F → Terms F + | [], right => right + | left, [] => left + | (leftId, leftValue) :: left, (rightId, rightValue) :: right => + if leftId = rightId then + if leftValue + rightValue = 0 then Terms.add left right + else (leftId, leftValue + rightValue) :: Terms.add left right + else if leftId < rightId then + (leftId, leftValue) :: Terms.add left ((rightId, rightValue) :: right) + else (rightId, rightValue) :: Terms.add ((leftId, leftValue) :: left) right + termination_by left right => left.length + right.length + +theorem Terms.denote_add (left right : Terms F) (assignment : Witness → F) : + (left.add right).denote assignment = left.denote assignment + right.denote assignment := by + match left, right with + | [], right => simp [Terms.add, Terms.denote] + | left, [] => cases left <;> simp [Terms.add, Terms.denote] + | (leftId, leftValue) :: left, (rightId, rightValue) :: right => + by_cases same : leftId = rightId + · subst rightId + by_cases zero : leftValue + rightValue = 0 + · simp only [Terms.add, if_pos zero, ↓reduceIte] + rw [Terms.denote_add left right] + have zeroMul := congrArg (fun x => x * assignment leftId) zero + simp only [add_mul, zero_mul] at zeroMul + simp only [Terms.denote, List.map_cons, List.sum_cons] + linear_combination -zeroMul + · simp only [Terms.add, if_neg zero, ↓reduceIte, Terms.denote, List.map_cons, List.sum_cons] + have ih := Terms.denote_add left right assignment + simp only [Terms.denote] at ih + rw [ih] + ring + · by_cases before : leftId < rightId + · simp only [Terms.add, if_neg same, if_pos before, Terms.denote, List.map_cons, List.sum_cons] + have ih := Terms.denote_add left ((rightId, rightValue) :: right) assignment + simp only [Terms.denote, List.map_cons, List.sum_cons] at ih + rw [ih] + ring + · simp only [Terms.add, if_neg same, if_neg before, Terms.denote, List.map_cons, List.sum_cons] + have ih := Terms.denote_add ((leftId, leftValue) :: left) right assignment + simp only [Terms.denote, List.map_cons, List.sum_cons] at ih + rw [ih] + ring + termination_by left.length + right.length + +def Terms.scale (coefficient : F) (terms : Terms F) : Terms F := + if coefficient = 0 then [] else terms.map fun (id, value) => (id, coefficient * value) + +theorem Terms.denote_scale (coefficient : F) (terms : Terms F) (assignment : Witness → F) : + (terms.scale coefficient).denote assignment = coefficient * terms.denote assignment := by + by_cases zero : coefficient = 0 + · simp [Terms.scale, Terms.denote, zero] + · simp only [Terms.scale, if_neg zero] + induction terms with + | nil => simp [Terms.denote] + | cons head rest ih => + rcases head with ⟨id, value⟩ + simp only [List.map_cons, Terms.denote, List.sum_cons] at ih ⊢ + rw [ih] + ring + +structure Affine (F : Type) where + constant : F + terms : Terms F + +def Affine.denote (form : Affine F) (assignment : Witness → F) : F := + form.terms.denote assignment + form.constant + +def Affine.add (left right : Affine F) : Affine F := + ⟨left.constant + right.constant, left.terms.add right.terms⟩ + +def Affine.scale (coefficient : F) (form : Affine F) : Affine F := + ⟨coefficient * form.constant, form.terms.scale coefficient⟩ + +@[simp] theorem Affine.denote_add (left right : Affine F) (assignment : Witness → F) : + (left.add right).denote assignment = left.denote assignment + right.denote assignment := by + simp only [Affine.add, Affine.denote, Terms.denote_add] + ring + +@[simp] theorem Affine.denote_scale (coefficient : F) (form : Affine F) (assignment : Witness → F) : + (form.scale coefficient).denote assignment = coefficient * form.denote assignment := by + simp only [Affine.scale, Affine.denote, Terms.denote_scale] + ring + +def Terms.expression : Terms F → Polynomial F + | [] => .const 0 + | (id, coefficient) :: rest => + .add (.mul (.const coefficient) (.var id)) (Terms.expression rest) + +omit [DecidableEq F] in +theorem Terms.expression_denote (terms : Terms F) (assignment : Witness → F) : + terms.expression.denote assignment = terms.denote assignment := by + induction terms with + | nil => simp [Terms.expression, Terms.denote, Scalar.Circuit.ArithExpr.denote] + | cons head rest ih => + rcases head with ⟨id, coefficient⟩ + simpa [Terms.expression, Terms.denote, Scalar.Circuit.ArithExpr.denote] using + congrArg (coefficient * assignment id + ·) ih + +def Affine.expression (form : Affine F) : Polynomial F := + Polynomial.simplify (.add form.terms.expression (.const form.constant)) + +@[simp] theorem Affine.expression_denote (form : Affine F) (assignment : Witness → F) : + form.expression.denote assignment = form.denote assignment := by + simp [Affine.expression, Affine.denote, Terms.expression_denote, Scalar.Circuit.ArithExpr.denote] + +inductive Result (F : Type) where + | affine (form : Affine F) + | nonlinear (expression : Polynomial F) + +def Result.expression : Result F → Polynomial F + | .affine form => form.expression + | .nonlinear expression => expression + +def Result.denote (result : Result F) (assignment : Witness → F) : F := + result.expression.denote assignment + +def Result.add (left right : Result F) : Result F := + match left, right with + | .affine left, .affine right => .affine (left.add right) + | left, right => .nonlinear (.add left.expression right.expression) + +def Result.sub (left right : Result F) : Result F := + match left, right with + | .affine left, .affine right => .affine (left.add (right.scale (-1))) + | left, right => .nonlinear (.sub left.expression right.expression) + +def Result.mul (left right : Result F) : Result F := + match left, right with + | .affine left, .affine right => + if left.terms.isEmpty then .affine (right.scale left.constant) + else if right.terms.isEmpty then .affine (left.scale right.constant) + else .nonlinear (.mul left.expression right.expression) + | left, right => .nonlinear (.mul left.expression right.expression) + +@[simp] theorem Result.denote_add (left right : Result F) (assignment : Witness → F) : + (left.add right).denote assignment = left.denote assignment + right.denote assignment := by + cases left <;> cases right <;> + simp [Result.add, Result.denote, Result.expression, Scalar.Circuit.ArithExpr.denote] + +@[simp] theorem Result.denote_sub (left right : Result F) (assignment : Witness → F) : + (left.sub right).denote assignment = left.denote assignment - right.denote assignment := by + cases left <;> cases right <;> + simp [Result.sub, Result.denote, Result.expression, Scalar.Circuit.ArithExpr.denote, sub_eq_add_neg] + +@[simp] theorem Result.denote_mul (left right : Result F) (assignment : Witness → F) : + (left.mul right).denote assignment = left.denote assignment * right.denote assignment := by + cases left with + | nonlinear left => cases right <;> rfl + | affine left => + cases right with + | nonlinear right => rfl + | affine right => + simp only [Result.mul] + split + · rename_i empty + have empty : left.terms = [] := List.isEmpty_iff.mp empty + simp only [Result.denote, Result.expression, Affine.expression_denote, Affine.denote_scale] + simp [Affine.denote, Terms.denote, empty] + · split + · rename_i empty + have empty : right.terms = [] := List.isEmpty_iff.mp empty + simp only [Result.denote, Result.expression, Affine.expression_denote, Affine.denote_scale] + simp [Affine.denote, Terms.denote, empty, mul_comm] + · rfl + +/-- Normalize maximal affine subexpressions without expanding nonlinear products. -/ +def normalize : Polynomial F → Result F + | .const value => .affine ⟨value, []⟩ + | .var id => .affine ⟨0, [(id, 1)]⟩ + | .add left right => (normalize left).add (normalize right) + | .sub left right => (normalize left).sub (normalize right) + | .mul left right => (normalize left).mul (normalize right) + +theorem normalize_denote (expression : Polynomial F) (assignment : Witness → F) : + (normalize expression).denote assignment = expression.denote assignment := by + induction expression with + | const value => simp [normalize, Result.denote, Result.expression, Affine.denote, + Terms.denote, Scalar.Circuit.ArithExpr.denote] + | var id => simp [normalize, Result.denote, Result.expression, Affine.denote, + Terms.denote, Scalar.Circuit.ArithExpr.denote] + | add left right ihLeft ihRight => + simpa [normalize, Scalar.Circuit.ArithExpr.denote] using congrArg₂ (· + ·) ihLeft ihRight + | sub left right ihLeft ihRight => + simpa [normalize, Scalar.Circuit.ArithExpr.denote] using congrArg₂ (· - ·) ihLeft ihRight + | mul left right ihLeft ihRight => + simpa [normalize, Scalar.Circuit.ArithExpr.denote] using congrArg₂ (· * ·) ihLeft ihRight + +end Aiur.Optimized.LinearNormalization + +namespace Aiur.Optimized.Polynomial +variable {F : Type} [Field F] [DecidableEq F] + +def normalizeLinear (expression : Polynomial F) : Polynomial F := + (LinearNormalization.normalize expression).expression + +@[simp] theorem denote_normalizeLinear (expression : Polynomial F) (assignment : Witness → F) : + expression.normalizeLinear.denote assignment = expression.denote assignment := + LinearNormalization.normalize_denote expression assignment + +end Aiur.Optimized.Polynomial diff --git a/Aiur/Aiur/Optimized/LocalCorrectness.lean b/Aiur/Aiur/Optimized/LocalCorrectness.lean new file mode 100644 index 000000000..345fbd213 --- /dev/null +++ b/Aiur/Aiur/Optimized/LocalCorrectness.lean @@ -0,0 +1,129 @@ +import Aiur.Optimized.ExpressionCorrectness +import Aiur.Circuit.LocalCorrectness +import Aiur.Optimized.ParameterWitness + +namespace Aiur.Optimized + +variable {F : Type} [Field F] [DecidableEq F] + +theorem ScopedChip.premises_forall (chip : ScopedChip F) (assignment : Witness → F) + (property : Circuit.Message F → Prop) : + (∀ message ∈ chip.premises assignment, property message) ↔ + ∀ call ∈ chip.calls.toList, (chip.activation call.scope).denote assignment = 1 → + property (call.message assignment) := by + constructor + · intro valid call member enabled + exact valid (call.message assignment) (List.mem_filterMap.mpr ⟨call, member, by simp [enabled]⟩) + · intro valid message member + obtain ⟨call, callMember, selected⟩ := List.mem_filterMap.mp member + split at selected + · rename_i enabled + cases selected + exact valid call callMember enabled + · cases selected + +namespace Compiler + +open Circuit.Compiler (parameter_environment) + +/-- Internal rows preserve canonicality from their arguments. The call premise +produces a decoded result; callers never assume the result is canonical. -/ +theorem function_sound {program : Program F} (checked : checkDeclarations program.enums = .ok ()) + (tags : program.enums.tagsValid F = true) {config : Config} {fn : Function F} {chip : ScopedChip F} + {validateInputs : Bool} (compiled : function program config fn validateInputs = .ok chip) + {rom : WireROM F} {sourceCalls : Aiur.CallRelation F} {assignment : Witness → F} + (romValid : rom.Valid) + (valid : chip.ValidAssignment rom assignment) + (premises : ∀ message ∈ chip.premises assignment, ∀ args, + DecodesValues program.enums message.args args → + (∀ v ∈ args, (rom.decode program.enums).Provenance v) → + ∃ result, message.result.decode program.enums = some result ∧ sourceCalls message.channel args result) + (callProvenance : ∀ name args result, sourceCalls name args result → + (∀ v ∈ args, (rom.decode program.enums).Provenance v) → + (rom.decode program.enums).Provenance result) + {args : List (Value F)} + (arguments : DecodesValues program.enums (chip.conclusion assignment).args args) + (trusted : ∀ v ∈ args, (rom.decode program.enums).Provenance v) : + ∃ result, (chip.conclusion assignment).result.decode program.enums = some result ∧ + ROMEvalExprWith program.enums (rom.decode program.enums) sourceCalls + ((fn.params.map Prod.fst).zip args) fn.body result ∧ + (rom.decode program.enums).Provenance result := by + let calls : Circuit.CallRelation F := fun name args result => ⟨name, args, result⟩ ∈ chip.premises assignment + have callSound : CallsSound program.enums rom calls sourceCalls := fun name args result member => + premises ⟨name, args, result⟩ member + obtain ⟨inputs, output, s₁, s₂, s₃, body, s₄, + inputsRun, outputRun, inputValidation, bodyRun, chipEq⟩ := function_stages compiled + have stateValid : s₄.Valid rom calls assignment := by + refine ⟨?_, ?_, ?_⟩ + · simpa only [chipEq, ScopedChip.ValidAssignment, ScopedChip.activation, State.activation] using valid.1 + · have activeCalls := (ScopedChip.premises_forall chip assignment + (fun message => calls message.channel message.args message.result)).mp (fun _ h => h) + simpa only [chipEq, ScopedChip.activation, State.activation, Call.message] using activeCalls + · simpa only [chipEq, ScopedChip.ValidAssignment, ScopedChip.activation, State.activation] using valid.2 + have s₁root : (s₁.activation 0).denote assignment = 1 := by + simp only [State.activation, (freshValues_preserves inputsRun).1] + rfl + have s₂root := (freshValue_extends outputRun).active s₁root + have inputExtension : s₂.Extends s₃ := by + cases validateInputs with + | false => + obtain ⟨_, rfl⟩ := pure_ok.mp inputValidation + exact .refl _ + | true => + have run : (do for wire in inputs.map (WireValue.map Polynomial.var) do + validateValue program.enums 0 wire : Build F Unit) s₂ = .ok ((), s₃) := by + simpa only [validateParameters, Bool.true_eq, ↓reduceIte, List.forIn_map] using inputValidation + exact (validateValues_sound checked tags run).1 + have s₃root := inputExtension.active s₂root + obtain ⟨_, bodyMeaning⟩ := lower_sound checked tags romValid callSound callProvenance bodyRun + have environmentTrusted : Environment.Provenance (rom.decode program.enums) ((fn.params.map Prod.fst).zip args) := by + intro binding member + exact trusted binding.2 (List.of_mem_zip member).2 + have decoded : DecodesValues program.enums (inputs.map (WireValue.map assignment)) args := by + simpa only [chipEq, ScopedChip.conclusion] using arguments + obtain ⟨result, resultDecode, evaluated⟩ := (bodyMeaning assignment s₃root stateValid).2 s₃root + ((fn.params.map Prod.fst).zip args) + (by simpa only [parameter_environment] using decoded.environment (fn.params.map Prod.fst)) environmentTrusted + refine ⟨result, ?_, evaluated, evaluated.provenance (WireROM.decode_valid romValid) callProvenance environmentTrusted⟩ + simpa only [chipEq, ScopedChip.conclusion, lower_target bodyRun, WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using resultDecode + +/-- Entry arguments are checked independently of whether the body uses them. +This is the base case of the canonical-value invariant. -/ +theorem function_arguments_sound {program : Program F} (checked : checkDeclarations program.enums = .ok ()) + (tags : program.enums.tagsValid F = true) {config : Config} {fn : Function F} {chip : ScopedChip F} + (compiled : function program config fn true = .ok chip) + {rom : WireROM F} {assignment : Witness → F} (valid : chip.ValidAssignment rom assignment) : + ∃ args, DecodesValues program.enums (chip.conclusion assignment).args args := by + obtain ⟨inputs, output, s₁, s₂, s₃, body, s₄, + inputsRun, outputRun, inputValidation, bodyRun, chipEq⟩ := function_stages compiled + let initialState : State F := {config, scopes := #[⟨.const 1, []⟩]} + have initialScoped : initialState.Scoped := by + exact ⟨by simp [initialState], by simp [initialState], by simp [initialState], + by simp [initialState, Scalar.Circuit.ArithExpr.inBounds]⟩ + have s₂scoped := freshValue_scoped outputRun (freshValues_scoped inputsRun initialScoped) + have s₂scopes : s₂.scopes = initialState.scopes := + (freshValue_preserves outputRun).1.trans (freshValues_preserves inputsRun).1 + have s₂bound : 0 < s₂.scopes.size := by simp [s₂scopes, initialState] + have run : (do for wire in inputs.map (WireValue.map Polynomial.var) do + validateValue program.enums 0 wire : Build F Unit) s₂ = .ok ((), s₃) := by + simpa only [validateParameters, Bool.true_eq, ↓reduceIte, List.forIn_map] using inputValidation + obtain ⟨inputExtension, s₃scoped⟩ := validateValues_scoped run s₂scoped s₂bound + have bodyExtension := (lower_scoped bodyRun s₃scoped (inputExtension.scopeValid s₂bound)).1 + let calls : Circuit.CallRelation F := fun _ _ _ => True + have stateValid : s₄.Valid rom calls assignment := by + refine ⟨?_, by simp [calls], ?_⟩ + · simpa only [chipEq, ScopedChip.ValidAssignment, ScopedChip.activation, State.activation] using valid.1 + · simpa only [chipEq, ScopedChip.ValidAssignment, ScopedChip.activation, State.activation] using valid.2 + have root : (s₂.activation 0).denote assignment = 1 := by + simp [State.activation, s₂scopes, initialState, Scalar.Circuit.ArithExpr.denote] + have decoded := ((validateValues_sound checked tags run).2 rom calls assignment root + (stateValid.of_extends bodyExtension)).2 root + apply DecodesValues.exists_of_each + intro wire member + simp only [chipEq, ScopedChip.conclusion] at member + obtain ⟨input, inputMember, rfl⟩ := List.mem_map.mp member + simpa only [WireValue.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using decoded (input.map Polynomial.var) + (List.mem_map.mpr ⟨input, inputMember, rfl⟩) + +end Compiler +end Aiur.Optimized diff --git a/Aiur/Aiur/Optimized/LocalWitness.lean b/Aiur/Aiur/Optimized/LocalWitness.lean new file mode 100644 index 000000000..cd6a1f5ec --- /dev/null +++ b/Aiur/Aiur/Optimized/LocalWitness.lean @@ -0,0 +1,114 @@ +import Aiur.Optimized.ParameterWitness +import Aiur.Optimized.ValidationWitness +import Aiur.Optimized.LocalCorrectness +import Aiur.Optimized.ExpressionWitness + +namespace Aiur.Optimized.Compiler + +variable {F : Type} [Field F] [DecidableEq F] +open Circuit.Compiler (Bounded LocalsBounded CallsComplete parameter_types parameter_wellFormed + parameter_bounded parameter_environment) + +set_option maxHeartbeats 2000000 +set_option maxRecDepth 4096 + +/-- Finite source body evaluation supplies an assignment for the actual scoped +function compiler, with the same decoded interface and active call claims. -/ +theorem function_complete {program : Program F} (declarations : checkDeclarations program.enums = .ok ()) + (tags : program.enums.tagsValid F = true) {config : Config} {fn : Function F} {chip : ScopedChip F} + {validateInputs : Bool} (compiled : function program config fn validateInputs = .ok chip) + {rom : WireROM F} {calls : Circuit.CallRelation F} {sourceCalls : Aiur.CallRelation F} + (typed : CallsTyped program sourceCalls) (callComplete : CallsComplete program.enums sourceCalls calls) + (checked : inferType program fn.name fn.params fn.body = .ok fn.result) + {args : List (Value F)} {value : Value F} + (types : fn.params.map Prod.snd = args.map Value.type) + (formed : ∀ arg ∈ args, arg.wellFormed program.enums = true) + (evaluated : ROMEvalExprWith program.enums (rom.decode program.enums) sourceCalls + ((fn.params.map Prod.fst).zip args) fn.body value) : + ∃ assignment, chip.ValidAssignment rom assignment ∧ + DecodesValues program.enums (chip.conclusion assignment).args args ∧ + (chip.conclusion assignment).result.decode program.enums = some value ∧ + ∀ message ∈ chip.premises assignment, calls message.channel message.args message.result := by + have resultType := evaluated.wellTyped typed (WireROM.decode_wellFormed program.enums rom) + (parameter_wellFormed formed) fn.name fn.result (by rw [parameter_types fn.params args types]; exact checked) + obtain ⟨inputs, output, s₁, s₂, s₃, body, s₅, + inputsRun, outputRun, inputsValidation, bodyRun, chipEq⟩ := function_stages compiled + let initialState : State F := {config, scopes := #[⟨.const 1, []⟩]} + have emptyLayout : initialState.toReference.WellFormed := by + exact ⟨by simp [initialState, State.toReference], by simp [initialState, State.toReference], + by simp [initialState, State.toReference]⟩ + have emptyValid : initialState.Valid rom calls (fun _ => 0) := by + exact ⟨by simp [initialState], by simp [initialState], by simp [initialState]⟩ + have emptyScoped : initialState.Scoped := by + exact ⟨by simp [initialState], by simp [initialState], by simp [initialState], + by simp [initialState, Scalar.Circuit.ArithExpr.inBounds]⟩ + obtain ⟨a, e₁, inputsBound, inputsDecode⟩ := freshValues_decoded_complete declarations tags inputsRun + emptyLayout emptyValid args types.symm formed + have inputSymbolicBound : ∀ wire ∈ inputs.map (WireValue.map Polynomial.var), Bounded (F := F) s₁.roles.size wire := by + simpa only [List.forall_mem_map] using inputsBound + have inputsDecodeA : DecodesValues program.enums + ((inputs.map (WireValue.map Polynomial.var)).map (WireValue.map (Circuit.ArithExpr.denote a))) args := by + simpa only [List.map_map, Function.comp_def, WireValue.map_map, Circuit.ArithExpr.denote, Scalar.Circuit.ArithExpr.denote] using inputsDecode + have s₁scoped := freshValues_scoped inputsRun emptyScoped + obtain ⟨b, e₂, outputBound, outputDecode⟩ := freshValue_decoded_complete declarations tags outputRun + e₁.layout e₁.validAssignment value resultType.1 resultType.2 + have s₂scoped := freshValue_scoped outputRun s₁scoped + have s₂scopes : s₂.scopes = initialState.scopes := + (freshValue_preserves outputRun).1.trans (freshValues_preserves inputsRun).1 + have s₂root : (s₂.activation 0).denote b = 1 := by + simp [State.activation, s₂scopes, initialState, Scalar.Circuit.ArithExpr.denote] + have s₂valid : 0 < s₂.scopes.size := by simp [s₂scopes, initialState] + have outputDecodeB : ((output.map Polynomial.var).map (Circuit.ArithExpr.denote b)).decode program.enums = some value := by + simpa only [WireValue.map_map, Function.comp_def, Circuit.ArithExpr.denote, Scalar.Circuit.ArithExpr.denote] using outputDecode + obtain ⟨c, e₃, inputStructure, s₃scoped⟩ : ∃ c, Extension rom calls s₂ s₃ b c ∧ + s₂.Extends s₃ ∧ s₃.Scoped := by + cases validateInputs with + | false => + obtain ⟨_, rfl⟩ := pure_ok.mp inputsValidation + exact ⟨b, .refl e₂.layout e₂.valid, .refl _, s₂scoped⟩ + | true => + have run : (do for wire in inputs.map (WireValue.map Polynomial.var) do + validateValue program.enums 0 wire : Build F Unit) s₂ = .ok ((), s₃) := by + simpa only [validateParameters, Bool.true_eq, ↓reduceIte, List.forIn_map] using inputsValidation + obtain ⟨c, e₃⟩ := validateValues_complete tags run e₂.layout s₂scoped e₂.validAssignment s₂valid + (fun wire member => (inputSymbolicBound wire member).mono e₂.increase) + (Or.inr ⟨s₂root, fun wire member => (e₂.decoded_values inputSymbolicBound inputsDecodeA).each + (wire.map (Circuit.ArithExpr.denote b)) (List.mem_map.mpr ⟨wire, member, rfl⟩)⟩) + obtain ⟨extension, nextScoped⟩ := validateValues_scoped run s₂scoped s₂valid + exact ⟨c, e₃, extension, nextScoped⟩ + have s₃root := (e₃.activation inputStructure s₂scoped s₂valid).trans s₂root + have s₃valid := inputStructure.scopeValid s₂valid + have throughInterface := e₂.trans e₃ + have argsDecodeC : DecodesValues program.enums (inputs.map (WireValue.map c)) args := by + simpa only [List.map_map, Function.comp_def, WireValue.map_map, Circuit.ArithExpr.denote, Scalar.Circuit.ArithExpr.denote] using + throughInterface.decoded_values inputSymbolicBound inputsDecodeA + have bodyWitness : ∃ e, Extension rom calls s₃ s₅ c e ∧ Bounded s₅.roles.size body ∧ + (body.map (Circuit.ArithExpr.denote e)).decode program.enums = some value := by + apply lower_complete declarations tags typed callComplete bodyRun e₃.layout s₃scoped + e₃.validAssignment s₃valid + (parameter_bounded (fun input member => (inputsBound input member).mono throughInterface.increase)) + · intro candidate same + have candidateEq : candidate = output := (Option.some.inj same).symm + subst candidate + exact outputBound.mono e₃.increase + · exact s₃root + · simpa only [parameter_environment] using argsDecodeC.environment (fn.params.map Prod.fst) + · intro candidate same + have candidateEq : candidate = output := (Option.some.inj same).symm + subst candidate + simpa only [WireValue.map_map, Function.comp_def, Circuit.ArithExpr.denote, Scalar.Circuit.ArithExpr.denote] using e₃.decoded_value outputBound outputDecodeB + · exact evaluated + obtain ⟨e, e₅, _, _⟩ := bodyWitness + have finalValid := e₅.validAssignment + refine ⟨e, ?_, ?_, ?_, ?_⟩ + · simpa only [chipEq, ScopedChip.ValidAssignment, ScopedChip.activation, State.activation] using + And.intro finalValid.1 finalValid.2.2 + · simpa only [chipEq, ScopedChip.conclusion, List.map_map, Function.comp_def, WireValue.map_map, + Circuit.ArithExpr.denote, Scalar.Circuit.ArithExpr.denote] using + (throughInterface.trans e₅).decoded_values inputSymbolicBound inputsDecodeA + · simpa only [chipEq, ScopedChip.conclusion, WireValue.map_map, Function.comp_def, Circuit.ArithExpr.denote, Scalar.Circuit.ArithExpr.denote] using + (e₃.trans e₅).decoded_value outputBound outputDecodeB + · apply (ScopedChip.premises_forall chip e (fun message => calls message.channel message.args message.result)).mpr + simpa only [chipEq, ScopedChip.activation, State.activation, Call.message] using finalValid.2.1 + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/LookupCalls.lean b/Aiur/Aiur/Optimized/LookupCalls.lean new file mode 100644 index 000000000..f94ce3135 --- /dev/null +++ b/Aiur/Aiur/Optimized/LookupCalls.lean @@ -0,0 +1,132 @@ +import Aiur.Optimized.LookupPayloads + +namespace Aiur.Optimized.LookupMerging + +variable {F : Type} [Field F] [DecidableEq F] + +structure CallSlot (ctx : Context F) where + channel : String + result : WireValue Witness + payload : Payload ctx + +def CallSlot.emit {ctx : Context F} (call : CallSlot ctx) : Circuit.Send F := + ⟨call.channel, call.payload.wires, call.result, call.payload.guard.expr⟩ + +def CallSlot.claims {ctx : Context F} (call : CallSlot ctx) (a : Witness → F) : List (Circuit.Message F) := + if call.payload.guard.expr.denote a = 1 then [call.emit.message a] else [] + +def CallSlot.Compatible {ctx : Context F} (left right : CallSlot ctx) : Prop := + left.channel = right.channel ∧ left.result = right.result ∧ + left.payload.wires.map wireShape = right.payload.wires.map wireShape + +instance {ctx : Context F} (left right : CallSlot ctx) : Decidable (left.Compatible right) := by + unfold CallSlot.Compatible + infer_instance + +def CallSlot.join {ctx : Context F} (left right : CallSlot ctx) + (different : left.payload.guard.exclusive right.payload.guard = true) : CallSlot ctx := + ⟨left.channel, left.result, left.payload.join right.payload different⟩ + +theorem CallSlot.join_claims {ctx : Context F} {left right : CallSlot ctx} + (different : left.payload.guard.exclusive right.payload.guard = true) + (shape : left.Compatible right) {a : Witness → F} (valid : ctx.Valid a) : + (left.join right different).claims a = left.claims a ++ right.claims a := by + have leftMessage (active : left.payload.guard.expr.denote a = 1) : + (left.join right different).emit.message a = left.emit.message a := by + have same := Payload.join_left different shape.2.2 valid active + exact congrArg (fun args => Circuit.Message.mk left.channel args (left.result.map a)) same + have rightMessage (active : right.payload.guard.expr.denote a = 1) : + (left.join right different).emit.message a = right.emit.message a := by + have same := Payload.join_right different shape.2.2 valid active + simpa only [CallSlot.emit, CallSlot.join, Circuit.Send.message, denoteWires, shape.1, shape.2.1] using + congrArg (fun args => Circuit.Message.mk left.channel args (left.result.map a)) same + rcases left.payload.guard.boolean a valid with l | l + · rcases right.payload.guard.boolean a valid with r | r + · simp [CallSlot.claims, CallSlot.join, Payload.join, Guard.join, Scalar.Circuit.ArithExpr.denote, l, r] + · rw [CallSlot.claims, if_pos (by simpa [CallSlot.join, Payload.join, Guard.join, + Scalar.Circuit.ArithExpr.denote, l] using r), rightMessage r] + simp [CallSlot.claims, l, r] + · have r := Guard.exclusive_sound different valid (by rw [l]; exact one_ne_zero) + rw [CallSlot.claims, if_pos (by simp [CallSlot.join, Payload.join, Guard.join, + Scalar.Circuit.ArithExpr.denote, l, r]), leftMessage l] + simp [CallSlot.claims, l, r] + +def callClaims {ctx : Context F} (a : Witness → F) (calls : List (CallSlot ctx)) : List (Circuit.Message F) := + calls.flatMap (fun call => call.claims a) + +theorem callClaims_inactive {ctx : Context F} {right : CallSlot ctx} {gap : List (CallSlot ctx)} + (different : gap.all (fun call => right.payload.guard.exclusive call.payload.guard) = true) + {a : Witness → F} (valid : ctx.Valid a) (active : right.payload.guard.expr.denote a = 1) : + callClaims a gap = [] := by + apply List.flatMap_eq_nil_iff.mpr + intro call member + have zero := Guard.exclusive_sound (List.all_eq_true.mp different call member) valid + (by rw [active]; exact one_ne_zero) + simp [CallSlot.claims, zero] + +/-- Moving the right slot across a gap preserves premise order only when its +activation excludes every slot in that gap. Simultaneous calls retain their +separate occurrences, even when their messages happen to agree. -/ +theorem CallSlot.join_across {ctx : Context F} {left right : CallSlot ctx} {gap : List (CallSlot ctx)} + (different : left.payload.guard.exclusive right.payload.guard = true) + (shape : left.Compatible right) + (crossing : gap.all (fun call => right.payload.guard.exclusive call.payload.guard) = true) + {a : Witness → F} (valid : ctx.Valid a) : + (left.join right different).claims a ++ callClaims a gap = + left.claims a ++ callClaims a gap ++ right.claims a := by + rw [CallSlot.join_claims different shape valid] + by_cases active : right.payload.guard.expr.denote a = 1 + · rw [callClaims_inactive crossing valid active]; simp + · simp [CallSlot.claims, active] + +def insertCall {ctx : Context F} (right : CallSlot ctx) : List (CallSlot ctx) → List (CallSlot ctx) + | [] => [right] + | left :: rest => + if left.Compatible right then + if different : left.payload.guard.exclusive right.payload.guard = true then + if rest.all (fun call => right.payload.guard.exclusive call.payload.guard) then + left.join right different :: rest + else left :: insertCall right rest + else left :: insertCall right rest + else left :: insertCall right rest + +theorem insertCall_claims {ctx : Context F} (right : CallSlot ctx) (calls : List (CallSlot ctx)) + {a : Witness → F} (valid : ctx.Valid a) : + callClaims a (insertCall right calls) = callClaims a calls ++ right.claims a := by + induction calls with + | nil => simp [insertCall, callClaims] + | cons left rest ih => + unfold insertCall + split + · split + · split + · exact CallSlot.join_across (by assumption) (by assumption) (by assumption) valid + · simpa only [callClaims, List.flatMap_cons, List.append_assoc] using congrArg (left.claims a ++ ·) ih + · simpa only [callClaims, List.flatMap_cons, List.append_assoc] using congrArg (left.claims a ++ ·) ih + · simpa only [callClaims, List.flatMap_cons, List.append_assoc] using congrArg (left.claims a ++ ·) ih + +def mergeCalls {ctx : Context F} (calls : List (CallSlot ctx)) : List (CallSlot ctx) := + calls.foldl (fun acc call => insertCall call acc) [] + +theorem mergeCalls_claims {ctx : Context F} (calls : List (CallSlot ctx)) + {a : Witness → F} (valid : ctx.Valid a) : callClaims a (mergeCalls calls) = callClaims a calls := by + have fold (rest acc : List (CallSlot ctx)) : + callClaims a (rest.foldl (fun acc call => insertCall call acc) acc) = callClaims a acc ++ callClaims a rest := by + induction rest generalizing acc with + | nil => simp [callClaims] + | cons call rest ih => + rw [List.foldl_cons, ih, insertCall_claims call acc valid] + simp only [callClaims, List.flatMap_cons, List.append_assoc] + simpa only [mergeCalls, callClaims, List.flatMap_nil, List.nil_append] using fold calls [] + +theorem emitCalls_claims {ctx : Context F} (calls : List (CallSlot ctx)) (a : Witness → F) : + (calls.map CallSlot.emit).filterMap (fun send => + if send.enable.denote a = 1 then some (send.message a) else none) = callClaims a calls := by + induction calls with + | nil => rfl + | cons call rest ih => + simp only [List.map_cons, List.filterMap_cons, callClaims, List.flatMap_cons, CallSlot.claims] + by_cases active : call.payload.guard.expr.denote a = 1 <;> + simp_all [CallSlot.emit, callClaims, CallSlot.claims] + +end Aiur.Optimized.LookupMerging diff --git a/Aiur/Aiur/Optimized/LookupGuards.lean b/Aiur/Aiur/Optimized/LookupGuards.lean new file mode 100644 index 000000000..c5ba19f2f --- /dev/null +++ b/Aiur/Aiur/Optimized/LookupGuards.lean @@ -0,0 +1,123 @@ +import Aiur.Optimized.ControlCertificate +import Aiur.Optimized.PhysicalSemantics + +namespace Aiur.Optimized.LookupMerging + +variable {F : Type} [Field F] [DecidableEq F] + +/-- The constraints of the emitted chip remain anchors while lookup slots are +merged. Scope labels only authorize sharing after their control equations have +been checked. -/ +structure Context (F : Type) [Field F] [DecidableEq F] where + logical : ScopedChip F + layout : ColumnLayout + control : Control.Certificate logical + boolean : ∀ scope ∈ List.range logical.scopes.size, + Control.ZeroEquation logical + (.mul (logical.activation scope) (.sub (logical.activation scope) (.const 1))) + +def Context.Valid (ctx : Context F) (a : Witness → F) : Prop := + Circuit.Satisfies (emitChip ctx.logical ctx.layout).constraints a + +def Context.guard (ctx : Context F) (scope : ScopeId) : Polynomial F := + ctx.layout.expression (ctx.logical.activation scope) + +theorem Context.logicalValid (ctx : Context F) {a : Witness → F} (valid : ctx.Valid a) : + ctx.logical.ValidAssignment (⟨ctx.logical.cells.toList.map fun cell => + (cell.address.denote (a ∘ ctx.layout.column), + cell.value.map (Circuit.ArithExpr.denote (a ∘ ctx.layout.column)))⟩ : WireROM F) + (a ∘ ctx.layout.column) := by + refine ⟨(emitChip_constraints _ _ _).mp valid, ?_⟩ + intro cell member _ + exact List.mem_map.mpr ⟨cell, member, rfl⟩ + +theorem Context.guard_boolean (ctx : Context F) {a : Witness → F} (valid : ctx.Valid a) + {scope : ScopeId} (bound : scope < ctx.logical.scopes.size) : + (ctx.guard scope).denote a = 0 ∨ (ctx.guard scope).denote a = 1 := by + have zero := ctx.control.zero (ctx.logicalValid valid) + (ctx.boolean scope (List.mem_range.mpr bound)) + simpa only [Context.guard, ColumnLayout.expression_denote, Scalar.Circuit.ArithExpr.denote, + mul_eq_zero, sub_eq_zero] using zero + +def Context.exclusive (ctx : Context F) (left right : ScopeId) : Bool := + match ctx.logical.scopes[left]?, ctx.logical.scopes[right]? with + | some left, some right => left.path.exclusive right.path + | _, _ => false + +theorem Context.exclusive_sound (ctx : Context F) {a : Witness → F} (valid : ctx.Valid a) + {left right : ScopeId} (different : ctx.exclusive left right = true) + (active : (ctx.guard left).denote a ≠ 0) : (ctx.guard right).denote a = 0 := by + unfold Context.exclusive at different + cases l : ctx.logical.scopes[left]? with + | none => simp [l] at different + | some ls => + cases r : ctx.logical.scopes[right]? with + | none => simp [r] at different + | some rs => + simp only [l, r] at different + by_contra other + apply ctx.control.paths_exclusive (ctx.logicalValid valid) different + · apply ctx.control.activePath (ctx.logicalValid valid) l + simpa only [Context.guard, ColumnLayout.expression_denote] using active + · apply ctx.control.activePath (ctx.logicalValid valid) r + simpa only [Context.guard, ColumnLayout.expression_denote] using other + +structure Guard (ctx : Context F) where + expr : Polynomial F + scopes : List ScopeId + boolean : ∀ a, ctx.Valid a → expr.denote a = 0 ∨ expr.denote a = 1 + origin : ∀ a, ctx.Valid a → expr.denote a ≠ 0 → + ∃ scope ∈ scopes, (ctx.guard scope).denote a ≠ 0 + +def Guard.ofScope (ctx : Context F) (scope : ScopeId) (bound : scope < ctx.logical.scopes.size) : Guard ctx := + ⟨ctx.guard scope, [scope], fun _ h => ctx.guard_boolean h bound, + fun _ _ active => ⟨scope, by simp, active⟩⟩ + +def Guard.exclusive {ctx : Context F} (left right : Guard ctx) : Bool := + left.scopes.all fun l => right.scopes.all (ctx.exclusive l) + +theorem Guard.exclusive_sound {ctx : Context F} {left right : Guard ctx} + (different : left.exclusive right = true) {a : Witness → F} (valid : ctx.Valid a) + (active : left.expr.denote a ≠ 0) : right.expr.denote a = 0 := by + by_contra other + obtain ⟨l, lm, la⟩ := left.origin a valid active + obtain ⟨r, rm, ra⟩ := right.origin a valid other + exact ra (ctx.exclusive_sound valid + (List.all_eq_true.mp (List.all_eq_true.mp different l lm) r rm) la) + +def Guard.join {ctx : Context F} (left right : Guard ctx) + (different : left.exclusive right = true) : Guard ctx where + expr := .add left.expr right.expr + scopes := left.scopes ++ right.scopes + boolean a valid := by + rcases left.boolean a valid with l | l + · simpa only [Scalar.Circuit.ArithExpr.denote, l, zero_add] using right.boolean a valid + · have r := Guard.exclusive_sound different valid (by rw [l]; exact one_ne_zero) + simp [Scalar.Circuit.ArithExpr.denote, l, r] + origin a valid active := by + by_cases l : left.expr.denote a = 0 + · have r : right.expr.denote a ≠ 0 := by simpa [Scalar.Circuit.ArithExpr.denote, l] using active + obtain ⟨scope, member, enabled⟩ := right.origin a valid r + exact ⟨scope, List.mem_append_right _ member, enabled⟩ + · obtain ⟨scope, member, enabled⟩ := left.origin a valid l + exact ⟨scope, List.mem_append_left _ member, enabled⟩ + +/-- A zero guard contributes no payload. When exactly one guard is one, the +quadratic sum is exactly that branch's value, including in small fields. -/ +def mix (leftGuard rightGuard left right : Polynomial F) : Polynomial F := + Polynomial.simplify (.add (.mul leftGuard left) (.mul rightGuard right)) + +theorem mix_left {g h x y : Polynomial F} {a : Witness → F} + (left : g.denote a = 1) (right : h.denote a = 0) : + (mix g h x y).denote a = x.denote a := by + simp [mix, Scalar.Circuit.ArithExpr.denote, left, right] + +theorem mix_right {g h x y : Polynomial F} {a : Witness → F} + (left : g.denote a = 0) (right : h.denote a = 1) : + (mix g h x y).denote a = y.denote a := by + simp [mix, Scalar.Circuit.ArithExpr.denote, left, right] + +def wireShape (wire : WireValue α) : Ty × Nat := (wire.type, wire.words.length) + + +end Aiur.Optimized.LookupMerging diff --git a/Aiur/Aiur/Optimized/LookupMemory.lean b/Aiur/Aiur/Optimized/LookupMemory.lean new file mode 100644 index 000000000..320f466a8 --- /dev/null +++ b/Aiur/Aiur/Optimized/LookupMemory.lean @@ -0,0 +1,104 @@ +import Aiur.Optimized.LookupPayloads + +namespace Aiur.Optimized.LookupMerging + +variable {F : Type} [Field F] [DecidableEq F] + +/-- Pack the address as a separate field wire. The stored value keeps its full +nominal type and width, so unrelated ROM layouts cannot accidentally merge. -/ +def memoryWords (address : Polynomial F) (value : WireValue (Polynomial F)) : List (WireValue (Polynomial F)) := + [WireValue.field address, value] + +def unpackMemory (zero : α) (wires : List (WireValue α)) : α × WireValue α := + match wires with + | address :: value :: _ => (address.words.headD zero, value) + | _ => (zero, ⟨.tuple [], []⟩) + +omit [DecidableEq F] in +theorem unpackMemory_denote (wires : List (WireValue (Polynomial F))) (a : Witness → F) : + unpackMemory (0 : F) (denoteWires a wires) = + ((unpackMemory (.const 0) wires).1.denote a, + (unpackMemory (.const 0) wires).2.map (Circuit.ArithExpr.denote a)) := by + cases wires with + | nil => rfl + | cons address rest => + cases rest with + | nil => rfl + | cons value rest => + rcases address with ⟨type, words⟩ + cases words <;> rfl + +def Payload.emitMemory {ctx : Context F} (p : Payload ctx) : Circuit.MemoryLookup F := + let (address, value) := unpackMemory (.const 0) p.wires + ⟨address, value, p.guard.expr⟩ + +theorem Payload.emitMemory_valid {ctx : Context F} (p : Payload ctx) (rom : WireROM F) (a : Witness → F) : + p.emitMemory.Valid rom a ↔ + (p.guard.expr.denote a = 1 → unpackMemory (0 : F) (denoteWires a p.wires) ∈ rom.entries) := by + rw [unpackMemory_denote] + rfl + +theorem Payload.join_memory {ctx : Context F} {left right : Payload ctx} + (different : left.guard.exclusive right.guard = true) + (shape : left.wires.map wireShape = right.wires.map wireShape) + {a : Witness → F} (valid : ctx.Valid a) (rom : WireROM F) : + (left.join right different).emitMemory.Valid rom a ↔ + left.emitMemory.Valid rom a ∧ right.emitMemory.Valid rom a := by + rw [Payload.emitMemory_valid, Payload.emitMemory_valid, Payload.emitMemory_valid] + rcases left.guard.boolean a valid with l | l + · rcases right.guard.boolean a valid with r | r + · simp [Payload.join, Guard.join, Scalar.Circuit.ArithExpr.denote, l, r] + · rw [Payload.join_right different shape valid r] + simp [Payload.join, Guard.join, Scalar.Circuit.ArithExpr.denote, l, r] + · have r := Guard.exclusive_sound different valid (by rw [l]; exact one_ne_zero) + rw [Payload.join_left different shape valid l] + simp [Payload.join, Guard.join, Scalar.Circuit.ArithExpr.denote, l, r] + +def memoryValid {ctx : Context F} (rom : WireROM F) (a : Witness → F) (slots : List (Payload ctx)) : Prop := + ∀ slot ∈ slots, slot.emitMemory.Valid rom a + +@[simp] theorem memoryValid_cons {ctx : Context F} (rom : WireROM F) (a : Witness → F) + (slot : Payload ctx) (slots : List (Payload ctx)) : + memoryValid rom a (slot :: slots) ↔ slot.emitMemory.Valid rom a ∧ memoryValid rom a slots := by + simp only [memoryValid, List.forall_mem_cons] + +def insertMemory {ctx : Context F} (right : Payload ctx) : List (Payload ctx) → List (Payload ctx) + | [] => [right] + | left :: rest => + if left.wires.map wireShape = right.wires.map wireShape then + if different : left.guard.exclusive right.guard = true then + left.join right different :: rest + else left :: insertMemory right rest + else left :: insertMemory right rest + +theorem insertMemory_valid {ctx : Context F} (right : Payload ctx) (slots : List (Payload ctx)) + {a : Witness → F} (valid : ctx.Valid a) (rom : WireROM F) : + memoryValid rom a (insertMemory right slots) ↔ memoryValid rom a slots ∧ right.emitMemory.Valid rom a := by + induction slots with + | nil => simp [insertMemory, memoryValid] + | cons left rest ih => + unfold insertMemory + split + · split + · rw [memoryValid_cons, memoryValid_cons, Payload.join_memory (by assumption) (by assumption) valid] + tauto + · rw [memoryValid_cons, memoryValid_cons, ih]; tauto + · rw [memoryValid_cons, memoryValid_cons, ih]; tauto + +def mergeMemory {ctx : Context F} (slots : List (Payload ctx)) : List (Payload ctx) := + slots.foldl (fun acc slot => insertMemory slot acc) [] + +theorem mergeMemory_valid {ctx : Context F} (slots : List (Payload ctx)) + {a : Witness → F} (valid : ctx.Valid a) (rom : WireROM F) : + memoryValid rom a (mergeMemory slots) ↔ memoryValid rom a slots := by + have fold (rest acc : List (Payload ctx)) : + memoryValid rom a (rest.foldl (fun acc slot => insertMemory slot acc) acc) ↔ + memoryValid rom a acc ∧ memoryValid rom a rest := by + induction rest generalizing acc with + | nil => simp [memoryValid] + | cons slot rest ih => + rw [List.foldl_cons, ih, insertMemory_valid slot acc valid, memoryValid_cons] + tauto + simpa only [mergeMemory, memoryValid, List.not_mem_nil, false_implies, implies_true, true_and] using fold slots [] + +end Aiur.Optimized.LookupMerging diff --git a/Aiur/Aiur/Optimized/LookupMerging.lean b/Aiur/Aiur/Optimized/LookupMerging.lean new file mode 100644 index 000000000..acd14f45a --- /dev/null +++ b/Aiur/Aiur/Optimized/LookupMerging.lean @@ -0,0 +1,109 @@ +import Aiur.Optimized.LookupCalls +import Aiur.Optimized.LookupMemory +import Aiur.Optimized.BranchOutputs + +namespace Aiur.Optimized.LookupMerging + +variable {F : Type} [Field F] [DecidableEq F] + +def Context.CallsBounded (ctx : Context F) : Prop := + ∀ call ∈ ctx.logical.calls.toList, call.scope < ctx.logical.scopes.size + +def Context.CellsBounded (ctx : Context F) : Prop := + ∀ cell ∈ ctx.logical.cells.toList, cell.scope < ctx.logical.scopes.size + +instance (ctx : Context F) : Decidable ctx.CallsBounded := by unfold Context.CallsBounded; infer_instance +instance (ctx : Context F) : Decidable ctx.CellsBounded := by unfold Context.CellsBounded; infer_instance + +def Context.calls (ctx : Context F) (bounded : ctx.CallsBounded) : List (CallSlot ctx) := + ctx.logical.calls.toList.attach.map fun call => + ⟨call.val.channel, call.val.result.map ctx.layout.column, + .single (.ofScope ctx call.val.scope (bounded call.val call.property)) + (call.val.args.map (WireValue.map ctx.layout.expression))⟩ + +def Context.cells (ctx : Context F) (bounded : ctx.CellsBounded) : List (Payload ctx) := + ctx.logical.cells.toList.attach.map fun cell => + .single (.ofScope ctx cell.val.scope (bounded cell.val cell.property)) + (memoryWords (ctx.layout.expression cell.val.address) (cell.val.value.map ctx.layout.expression)) + +theorem Context.calls_emit (ctx : Context F) (bounded : ctx.CallsBounded) : + (ctx.calls bounded).map CallSlot.emit = (emitChip ctx.logical ctx.layout).sends := by + simp [Context.calls, CallSlot.emit, Payload.single, Guard.ofScope, Context.guard, + emitChip, List.map_map, Function.comp_def] + +theorem Context.cells_emit (ctx : Context F) (bounded : ctx.CellsBounded) : + (ctx.cells bounded).map Payload.emitMemory = (emitChip ctx.logical ctx.layout).memory := by + simp [Context.cells, Payload.emitMemory, Payload.single, Guard.ofScope, Context.guard, + memoryWords, unpackMemory, WireValue.field, WireValue.map, + emitChip, List.map_map, Function.comp_def] + +def mergedChip (ctx : Context F) (calls : ctx.CallsBounded) (cells : ctx.CellsBounded) : Circuit.Chip F := + { emitChip ctx.logical ctx.layout with + sends := (mergeCalls (ctx.calls calls)).map CallSlot.emit + memory := (mergeMemory (ctx.cells cells)).map Payload.emitMemory } + +theorem mergedChip_valid (ctx : Context F) (calls : ctx.CallsBounded) (cells : ctx.CellsBounded) + (rom : WireROM F) (a : Witness → F) : + (mergedChip ctx calls cells).ValidAssignment rom a ↔ + (emitChip ctx.logical ctx.layout).ValidAssignment rom a := by + unfold Circuit.Chip.ValidAssignment + apply and_congr_right + intro valid + change ctx.Valid a at valid + simp only [mergedChip, List.forall_mem_map] + change memoryValid rom a (mergeMemory (ctx.cells cells)) ↔ _ + rw [mergeMemory_valid _ valid] + rw [← ctx.cells_emit cells] + simp only [memoryValid, List.forall_mem_map] + +theorem mergedChip_claims (ctx : Context F) (calls : ctx.CallsBounded) (cells : ctx.CellsBounded) + {a : Witness → F} (valid : ctx.Valid a) : + (mergedChip ctx calls cells).requirements a = (emitChip ctx.logical ctx.layout).requirements a := by + unfold Circuit.Chip.requirements + change (List.map CallSlot.emit (mergeCalls (ctx.calls calls))).filterMap _ = _ + rw [emitCalls_claims, mergeCalls_claims _ valid] + rw [← ctx.calls_emit calls, emitCalls_claims] + +def merge (ctx : Context F) (calls : ctx.CallsBounded) (cells : ctx.CellsBounded) : + Propagation.Checked (emitChip ctx.logical ctx.layout) where + chip := mergedChip ctx calls cells + equivalent := by + constructor + · intro rom a valid + exact ⟨a, (mergedChip_valid ctx calls cells rom a).mpr valid, rfl, + mergedChip_claims ctx calls cells valid.1⟩ + · intro rom a valid + have original := (mergedChip_valid ctx calls cells rom a).mp valid + exact ⟨a, original, rfl, (mergedChip_claims ctx calls cells original.1).symm⟩ + name_eq := rfl + inputTypes := rfl + outputType := rfl + +/-- Rejecting an optimization certificate leaves the already certified emitted +chip alone. In particular branchless chips retain affine lookup payloads. -/ +def run (config : Config) (logical : ScopedChip F) (layout : ColumnLayout) : + Propagation.Checked (emitChip logical layout) := + let original := emitChip logical layout + if !config.mergeLookups || logical.choices.isEmpty then .identity original else + if control : Control.Certificate logical then + if boolean : ∀ scope ∈ List.range logical.scopes.size, + Control.ZeroEquation logical (.mul (logical.activation scope) (.sub (logical.activation scope) (.const 1))) then + let ctx : Context F := ⟨logical, layout, control, boolean⟩ + if calls : ctx.CallsBounded then + if cells : ctx.CellsBounded then + let merged := merge ctx calls cells + let outputs := replaceOutputs merged.chip (outputFacts ctx merged.chip rfl) + if outputs.chip.stats.maxConstraintDegree ≤ config.maxDegree && outputs.chip.stats.maxLookupDegree ≤ 2 && outputs.chip.maxLookupGuardDegree ≤ 1 then + { chip := outputs.chip + equivalent := merged.equivalent.trans outputs.equivalent + name_eq := outputs.name_eq.trans merged.name_eq + inputTypes := outputs.inputTypes.trans merged.inputTypes + outputType := outputs.outputType.trans merged.outputType } + else if merged.chip.stats.maxLookupDegree ≤ 2 then merged + else .identity original + else .identity original + else .identity original + else .identity original + else .identity original + +end Aiur.Optimized.LookupMerging diff --git a/Aiur/Aiur/Optimized/LookupPayloads.lean b/Aiur/Aiur/Optimized/LookupPayloads.lean new file mode 100644 index 000000000..202da2990 --- /dev/null +++ b/Aiur/Aiur/Optimized/LookupPayloads.lean @@ -0,0 +1,199 @@ +import Aiur.Optimized.LookupGuards + +namespace Aiur.Optimized.LookupMerging + +variable {F : Type} [Field F] [DecidableEq F] + +def wireZip (f : Polynomial F → Polynomial F → Polynomial F) + (left right : WireValue (Polynomial F)) : WireValue (Polynomial F) := + ⟨left.type, List.zipWith f left.words right.words⟩ + +def wiresZip (f : Polynomial F → Polynomial F → Polynomial F) + (left right : List (WireValue (Polynomial F))) : List (WireValue (Polynomial F)) := + List.zipWith (wireZip f) left right + +def denoteWires (a : Witness → F) (wires : List (WireValue (Polynomial F))) : List (WireValue F) := + wires.map (WireValue.map (Circuit.ArithExpr.denote a)) + +def ZeroWires (a : Witness → F) (wires : List (WireValue (Polynomial F))) : Prop := + ∀ wire ∈ wires, ∀ p ∈ wire.words, p.denote a = 0 + +omit [DecidableEq F] in +theorem wireZip_left {f : Polynomial F → Polynomial F → Polynomial F} + {left right : WireValue (Polynomial F)} (shape : wireShape left = wireShape right) + {a : Witness → F} (same : ∀ x ∈ left.words, ∀ y ∈ right.words, + (f x y).denote a = x.denote a) : + (wireZip f left right).map (Circuit.ArithExpr.denote a) = left.map (Circuit.ArithExpr.denote a) := by + rcases left with ⟨lt, ls⟩; rcases right with ⟨rt, rs⟩ + have length : ls.length = rs.length := congrArg Prod.snd shape + clear shape + simp only [wireZip, WireValue.map] + congr 1 + induction ls generalizing rs with + | nil => simp + | cons x xs ih => + cases rs with + | nil => simp at length + | cons y ys => + change (f x y).denote a :: _ = x.denote a :: _ + rw [same x (by simp) y (by simp)] + exact congrArg (List.cons _) (ih ys + (fun x hx y hy => same x (by simp [hx]) y (by simp [hy])) (by simpa using length)) + +omit [DecidableEq F] in +theorem wireZip_right {f : Polynomial F → Polynomial F → Polynomial F} + {left right : WireValue (Polynomial F)} (shape : wireShape left = wireShape right) + {a : Witness → F} (same : ∀ x ∈ left.words, ∀ y ∈ right.words, + (f x y).denote a = y.denote a) : + (wireZip f left right).map (Circuit.ArithExpr.denote a) = right.map (Circuit.ArithExpr.denote a) := by + rcases left with ⟨lt, ls⟩; rcases right with ⟨rt, rs⟩ + obtain ⟨rfl, length⟩ := Prod.mk.inj shape + clear shape + change ls.length = rs.length at length + simp only [wireZip, WireValue.map] + congr 1 + induction ls generalizing rs with + | nil => cases rs <;> simp_all + | cons x xs ih => + cases rs with + | nil => simp at length + | cons y ys => + change (f x y).denote a :: _ = y.denote a :: _ + rw [same x (by simp) y (by simp)] + exact congrArg (List.cons _) (ih ys + (fun x hx y hy => same x (by simp [hx]) y (by simp [hy])) (by simpa using length)) + +theorem wiresZip_left {f : Polynomial F → Polynomial F → Polynomial F} + {left right : List (WireValue (Polynomial F))} (shape : left.map wireShape = right.map wireShape) + {a : Witness → F} (same : ∀ l ∈ left, ∀ r ∈ right, ∀ x ∈ l.words, ∀ y ∈ r.words, + (f x y).denote a = x.denote a) : + denoteWires a (wiresZip f left right) = denoteWires a left := by + induction left generalizing right with + | nil => simp [wiresZip, denoteWires] + | cons l ls ih => + cases right with + | nil => simp at shape + | cons r rs => + simp only [List.map_cons, List.cons.injEq] at shape + change _ :: _ = _ :: _ + rw [wireZip_left shape.1 (same l (by simp) r (by simp))] + exact congrArg (List.cons _) (ih shape.2 + (fun l hl r hr => same l (by simp [hl]) r (by simp [hr]))) + +theorem wiresZip_right {f : Polynomial F → Polynomial F → Polynomial F} + {left right : List (WireValue (Polynomial F))} (shape : left.map wireShape = right.map wireShape) + {a : Witness → F} (same : ∀ l ∈ left, ∀ r ∈ right, ∀ x ∈ l.words, ∀ y ∈ r.words, + (f x y).denote a = y.denote a) : + denoteWires a (wiresZip f left right) = denoteWires a right := by + induction left generalizing right with + | nil => cases right <;> simp_all [wiresZip, denoteWires] + | cons l ls ih => + cases right with + | nil => simp at shape + | cons r rs => + simp only [List.map_cons, List.cons.injEq] at shape + change _ :: _ = _ :: _ + rw [wireZip_right shape.1 (same l (by simp) r (by simp))] + exact congrArg (List.cons _) (ih shape.2 + (fun l hl r hr => same l (by simp [hl]) r (by simp [hr]))) + +private theorem zipWith_member {α β γ : Type} {f : α → β → γ} {xs : List α} {ys : List β} {z : γ} + (member : z ∈ List.zipWith f xs ys) : ∃ x ∈ xs, ∃ y ∈ ys, f x y = z := by + induction xs generalizing ys with + | nil => simp at member + | cons x xs ih => + cases ys with + | nil => simp at member + | cons y ys => + simp only [List.zipWith_cons_cons, List.mem_cons] at member + rcases member with rfl | member + · exact ⟨x, by simp, y, by simp, rfl⟩ + · obtain ⟨a, ha, b, hb, rfl⟩ := ih member + exact ⟨a, by simp [ha], b, by simp [hb], rfl⟩ + +omit [DecidableEq F] in +theorem wiresZip_zero {f : Polynomial F → Polynomial F → Polynomial F} + {left right : List (WireValue (Polynomial F))} {a : Witness → F} + (zero : ∀ l ∈ left, ∀ r ∈ right, ∀ x ∈ l.words, ∀ y ∈ r.words, (f x y).denote a = 0) : + ZeroWires a (wiresZip f left right) := by + intro wire member p occurs + obtain ⟨l, hl, r, hr, rfl⟩ := zipWith_member member + obtain ⟨x, hx, y, hy, rfl⟩ := zipWith_member occurs + exact zero l hl r hr x hx y hy + +/-- A merged payload is already weighted. Further merges add weighted payloads +rather than multiplying them by another selector; its degree stays quadratic. -/ +structure Payload (ctx : Context F) where + guard : Guard ctx + wires : List (WireValue (Polynomial F)) + weighted : Bool + zero : ∀ a, ctx.Valid a → guard.expr.denote a = 0 → weighted = true → ZeroWires a wires + +def Payload.single {ctx : Context F} (guard : Guard ctx) (wires : List (WireValue (Polynomial F))) : Payload ctx := + ⟨guard, wires, false, by simp⟩ + +def Payload.factor {ctx : Context F} (payload : Payload ctx) : Polynomial F := + if payload.weighted then .const 1 else payload.guard.expr + +theorem Payload.factor_active {ctx : Context F} (p : Payload ctx) {a : Witness → F} + (active : p.guard.expr.denote a = 1) : p.factor.denote a = 1 := by + simp only [Payload.factor] + split <;> simp [Scalar.Circuit.ArithExpr.denote, active] + +theorem Payload.factor_inactive {ctx : Context F} (p : Payload ctx) {a : Witness → F} + (valid : ctx.Valid a) (inactive : p.guard.expr.denote a = 0) + {wire : WireValue (Polynomial F)} (member : wire ∈ p.wires) {x : Polynomial F} (occurs : x ∈ wire.words) : + p.factor.denote a * x.denote a = 0 := by + unfold Payload.factor + split + · simp [Scalar.Circuit.ArithExpr.denote, p.zero a valid inactive (by assumption) wire member x occurs] + · simp [inactive] + +def Payload.join {ctx : Context F} (left right : Payload ctx) + (different : left.guard.exclusive right.guard = true) : Payload ctx where + guard := left.guard.join right.guard different + wires := wiresZip (mix left.factor right.factor) left.wires right.wires + weighted := true + zero a valid inactive _ := by + have l : left.guard.expr.denote a = 0 := by + rcases left.guard.boolean a valid with zero | one + · exact zero + · have r := Guard.exclusive_sound different valid (by rw [one]; exact one_ne_zero) + simp [Guard.join, Scalar.Circuit.ArithExpr.denote, one, r] at inactive + have r : right.guard.expr.denote a = 0 := by + simpa [Guard.join, Scalar.Circuit.ArithExpr.denote, l] using inactive + apply wiresZip_zero + intro lw lm rw rm x hx y hy + simp only [mix, Polynomial.denote_simplify, Scalar.Circuit.ArithExpr.denote] + rw [left.factor_inactive valid l lm hx, right.factor_inactive valid r rm hy, add_zero] + +theorem Payload.join_left {ctx : Context F} {left right : Payload ctx} + (different : left.guard.exclusive right.guard = true) + (shape : left.wires.map wireShape = right.wires.map wireShape) + {a : Witness → F} (valid : ctx.Valid a) (active : left.guard.expr.denote a = 1) : + denoteWires a (left.join right different).wires = denoteWires a left.wires := by + have inactive := Guard.exclusive_sound different valid (by rw [active]; exact one_ne_zero) + apply wiresZip_left shape + intro lw lm rw rm x hx y hy + change (Polynomial.simplify _).denote a = _ + rw [Polynomial.denote_simplify] + change left.factor.denote a * x.denote a + right.factor.denote a * y.denote a = _ + rw [left.factor_active active, one_mul, right.factor_inactive valid inactive rm hy, add_zero] + +theorem Payload.join_right {ctx : Context F} {left right : Payload ctx} + (different : left.guard.exclusive right.guard = true) + (shape : left.wires.map wireShape = right.wires.map wireShape) + {a : Witness → F} (valid : ctx.Valid a) (active : right.guard.expr.denote a = 1) : + denoteWires a (left.join right different).wires = denoteWires a right.wires := by + have inactive : left.guard.expr.denote a = 0 := by + by_contra other + have := Guard.exclusive_sound different valid other + simp [active] at this + apply wiresZip_right shape + intro lw lm rw rm x hx y hy + change (Polynomial.simplify _).denote a = _ + rw [Polynomial.denote_simplify] + change left.factor.denote a * x.denote a + right.factor.denote a * y.denote a = _ + rw [left.factor_inactive valid inactive lm hx, right.factor_active active, one_mul, zero_add] + +end Aiur.Optimized.LookupMerging diff --git a/Aiur/Aiur/Optimized/MapFacts.lean b/Aiur/Aiur/Optimized/MapFacts.lean new file mode 100644 index 000000000..8440e49f5 --- /dev/null +++ b/Aiur/Aiur/Optimized/MapFacts.lean @@ -0,0 +1,77 @@ +import Aiur.Optimized.ProgramFacts +import Aiur.Circuit.MapFacts + +namespace Aiur.Optimized + +open Circuit + +variable {F : Type} + +set_option linter.unusedSimpArgs false + +theorem compile_mapClaims [Field F] [DecidableEq F] + {program : Program F} {entries : List String} {config : Config} {artifact : Artifact F} + (compiled : compile program entries config = .ok artifact) + (message : Message F) : + artifact.unmerged.MapClaim message ↔ ∃ map ∈ program.maps, ∃ entry ∈ program.mapEntries map, + encodeMapEntry program.enums map.name entry = some message := by + rw [(compile_stages compiled).2.2.2.2.2] + simp only [System.MapClaim, System.mapClaims, List.mem_flatMap, List.mem_filterMap] + rfl + +/-- A static leaf gives exactly the source lookup, including its canonical encodings. -/ +theorem compile_map_spec [Field F] [DecidableEq F] + {program : Program F} {entries : List String} {config : Config} {artifact : Artifact F} + (compiled : compile program entries config = .ok artifact) + {message : Message F} (member : artifact.unmerged.MapClaim message) : + ∃ args constant, DecodesValues program.enums message.args args ∧ + message.result.decode program.enums = some constant.toValue ∧ + program.findFunction? message.channel = none ∧ + lookupMap program message.channel args = .ok constant := by + obtain ⟨map, mapMember, entry, entryMember, encoded⟩ := (compile_mapClaims compiled message).mp member + have stages := compile_stages compiled + obtain ⟨name, arguments, result⟩ := encodeMapEntry_spec stages.2.1 encoded + exact ⟨entry.args.map Constant.toValue, entry.result, arguments, result, + by rw [name]; exact map_function_absent stages.1 mapMember, + by rw [name]; exact lookupMap_of_entry stages.1 mapMember entryMember⟩ + +/-- Lookup succeeds only at one of the fixed, aligned rows of the compiled traces. -/ +theorem compile_map_lookup [Field F] [DecidableEq F] + {program : Program F} {entries : List String} {config : Config} {artifact : Artifact F} + (compiled : compile program entries config = .ok artifact) + {name : String} {args : List (Value F)} {constant : Constant F} + (looked : lookupMap program name args = .ok constant) : + ∃ wires output, DecodesValues program.enums wires args ∧ + output.decode program.enums = some constant.toValue ∧ + artifact.unmerged.MapClaim ⟨name, wires, output⟩ := by + obtain ⟨map, key, found, _, formed, extracted, row, outputTyped⟩ := lookupMap_spec looked + have mapped : map.name = name := by simpa using List.find?_some found + have reconstructed := Value.toConstant_spec extracted + cases key with + | field x => simp [Constant.toValue, Value.mapAddress] at reconstructed + | construct e c xs => simp [Constant.toValue, Value.mapAddress] at reconstructed + | ptr _ address => exact Empty.elim address + | tuple constants => + have same : constants.map (Constant.toValue (Address := F)) = args := by + simpa only [show (Constant.toValue : Constant F → Value F F) = Value.mapAddress Empty.elim from rfl, Constant.toValue, Value.mapAddress, Value.tuple.injEq] using reconstructed + let entry : MapEntry F := ⟨constants, constant⟩ + have argsGood : ∀ c ∈ constants, c.wellFormed program.enums = true := by + intro c member + have good := formed (Constant.toValue c) (by rw [← same]; exact List.mem_map.mpr ⟨c, member, rfl⟩) + simpa using good + have resultGood : constant.wellFormed program.enums = true := by + simp only [Value.hasType, Bool.and_eq_true] at outputTyped + exact outputTyped.2 + have stages := compile_stages compiled + obtain ⟨message, encoded⟩ := encodeMapEntry_total (name := name) + (typecheck_declarations stages.1) entry argsGood resultGood + obtain ⟨messageName, arguments, result⟩ := encodeMapEntry_spec stages.2.1 encoded + have claim : artifact.unmerged.MapClaim message := (compile_mapClaims compiled message).mpr + ⟨map, List.mem_of_find?_eq_some found, entry, mapEntry_mem_iff.mpr row, + by simpa only [mapped] using encoded⟩ + refine ⟨message.args, message.result, ?_, result, ?_⟩ + · simpa only [entry, same] using arguments + · cases message + simpa only [Message.mk.injEq] using (messageName ▸ claim) + +end Aiur.Optimized diff --git a/Aiur/Aiur/Optimized/NativeCorrectness.lean b/Aiur/Aiur/Optimized/NativeCorrectness.lean new file mode 100644 index 000000000..dc51699a0 --- /dev/null +++ b/Aiur/Aiur/Optimized/NativeCorrectness.lean @@ -0,0 +1,223 @@ +import Aiur.Optimized.Equivalence + +namespace Aiur.Optimized + +variable {F : Type} [Field F] [DecidableEq F] + {source : Generic.Source F} {entries : List String} + +theorem GenericArtifact.native_entry_iff {prepared : Generic.Specialized source entries} + (compiled : GenericArtifact prepared) {name : String} (selected : name ∈ entries) : + Generic.SourceSemantics.EvalFn source.world name args [] value heap ↔ + Aiur.EvalFn compiled.inlined.program name args [] value heap := + (prepared.native_entry_iff selected).trans (compiled.inlined.entry_iff selected) + +/-- Completeness begins at the independent predicate on the original source. +Specialization, mandatory inlining, scoped compilation, physical layout, and +deduplication are all included. -/ +theorem GenericArtifact.heap_complete {prepared : Generic.Specialized source entries} + (compiled : GenericArtifact prepared) {name : String} (selected : name ∈ entries) + {args : List (SourceValue F)} {value : SourceValue F} {heap : Heap F} + (evaluated : Generic.SourceSemantics.EvalFn source.world name args [] value heap) + (encode : Nat → F) (distinct : ∀ i j, i < heap.length → j < heap.length → encode i = encode j → i = j) : + Circuit.EncodedEntryDerives compiled.system name (entryValues args) (value.mapAddress encode) := by + have stages := compile_stages compiled.compiled + have model := compile_semanticModel compiled.compiled + have originalEnums : compiled.artifact.unmerged.enums = compiled.inlined.program.enums := by + rw [stages.2.2.2.2.2] + obtain ⟨wires, output, arguments, decoded, formed, free, rom, valid, derived⟩ := + model.heap_complete stages.1 stages.2.1 originalEnums (compiled.inlined.valid.2.2 name selected).2 + ((compiled.native_entry_iff selected).mp evaluated) encode distinct + have sameEnums : compiled.system.enums = compiled.artifact.unmerged.enums := + compiled.artifact.deduplication.2.2.2.2.2.1 + refine ⟨wires, output, ?_, ?_, ?_, ?_, rom, valid, ?_⟩ + · simpa only [sameEnums] using arguments + · simpa only [sameEnums] using decoded + · simpa only [sameEnums] using formed + · simpa only [sameEnums] using free + · exact (compiled.artifact.dedup_derives_iff (by simpa only [stages.2.2.1] using selected)).mp derived + +theorem GenericArtifact.heap_sound {prepared : Generic.Specialized source entries} + (compiled : GenericArtifact prepared) {name : String} (selected : name ∈ entries) + {rom : WireROM F} (valid : rom.Valid) + {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F} + (derived : Circuit.CircuitEvaluates compiled.system rom name wires output) + (arguments : DecodesValues prepared.program.enums wires (entryValues args)) + (decoded : output.decode prepared.program.enums = some result) : + ∃ value heap, Generic.SourceSemantics.EvalFn source.world name args [] value heap ∧ + Represents (rom.decode prepared.program.enums) heap value result := by + have stages := compile_stages compiled.compiled + have original := (compiled.artifact.dedup_derives_iff (by simpa only [stages.2.2.1] using selected)).mpr derived + obtain ⟨value, heap, evaluated, related⟩ := + (compile_semanticModel compiled.compiled).heap_sound valid (compiled.inlined.valid.2.2 name selected).2 + original arguments decoded + exact ⟨value, heap, (compiled.native_entry_iff selected).mpr evaluated, related⟩ + +theorem GenericArtifact.checker_heap_complete [Fintype F] {prepared : Generic.Specialized source entries} + (compiled : GenericArtifact prepared) {name : String} (selected : name ∈ entries) + {args : List (SourceValue F)} {value : SourceValue F} {heap : Heap F} + (evaluated : Generic.SourceSemantics.EvalFn source.world name args [] value heap) + (capacity : heap.length ≤ Fintype.card F) : + ∃ (encode : Nat → F), ∃ wires output rom rows, + DecodesValues compiled.system.enums wires (entryValues args) ∧ + output.decode compiled.system.enums = some (value.mapAddress encode) ∧ + compiled.system.check rom ⟨name, wires, output⟩ rows = .ok () := by + obtain ⟨encode, distinct⟩ := heap_address_embedding heap capacity + obtain ⟨wires, output, arguments, decoded, derived⟩ := compiled.heap_complete selected evaluated encode distinct + obtain ⟨rom, rows, checked⟩ := (compiled.system.check_entry_iff compiled.artifact.wellFormed).mpr derived + exact ⟨encode, wires, output, rom, rows, arguments, decoded, checked⟩ + +theorem GenericArtifact.checkerMemo_heap_complete [Fintype F] {prepared : Generic.Specialized source entries} + (compiled : GenericArtifact prepared) {name : String} (selected : name ∈ entries) + {args : List (SourceValue F)} {value : SourceValue F} {heap : Heap F} + (evaluated : Generic.SourceSemantics.EvalFn source.world name args [] value heap) + (capacity : heap.length ≤ Fintype.card F) : + ∃ (encode : Nat → F), ∃ wires output rom rows, + DecodesValues compiled.system.enums wires (entryValues args) ∧ + output.decode compiled.system.enums = some (value.mapAddress encode) ∧ + compiled.system.checkMemo rom ⟨name, wires, output⟩ rows = .ok () := by + obtain ⟨encode, distinct⟩ := heap_address_embedding heap capacity + obtain ⟨wires, output, arguments, decoded, derived⟩ := + (compiled.heap_complete selected evaluated encode distinct).memo + obtain ⟨rom, rows, checked⟩ := (compiled.system.checkMemo_entry_iff compiled.artifact.wellFormed).mpr derived + exact ⟨encode, wires, output, rom, rows, arguments, decoded, checked⟩ + +theorem GenericArtifact.checker_heap_sound {prepared : Generic.Specialized source entries} + (compiled : GenericArtifact prepared) {name : String} (selected : name ∈ entries) + {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} + {wires : List (WireValue F)} {output : WireValue F} {rows : List (Circuit.Row F)} + (checked : compiled.system.check rom ⟨name, wires, output⟩ rows = .ok ()) + (arguments : DecodesValues prepared.program.enums wires (entryValues args)) + (decoded : output.decode prepared.program.enums = some result) : + ∃ value heap, Generic.SourceSemantics.EvalFn source.world name args [] value heap ∧ + Represents (rom.decode prepared.program.enums) heap value result := + compiled.heap_sound selected + (Circuit.System.checkContext_iff.mp (Circuit.System.check_iff.mp checked).1).2.2.1 + (compiled.system.check_sound checked) arguments decoded + +theorem GenericArtifact.checkerMemo_acyclic_heap_sound {prepared : Generic.Specialized source entries} + (compiled : GenericArtifact prepared) {name : String} (selected : name ∈ entries) + {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} + {wires : List (WireValue F)} {output : WireValue F} {rows : List (Circuit.WeightedRow F)} + (checked : compiled.system.checkMemo rom ⟨name, wires, output⟩ rows = .ok ()) + (acyclic : (Classical.choice (compiled.system.checkMemo_sound checked)).Acyclic) + (arguments : DecodesValues prepared.program.enums wires (entryValues args)) + (decoded : output.decode prepared.program.enums = some result) : + ∃ value heap, Generic.SourceSemantics.EvalFn source.world name args [] value heap ∧ + Represents (rom.decode prepared.program.enums) heap value result := + compiled.heap_sound selected + (Circuit.System.checkContext_iff.mp (Circuit.System.checkMemo_iff.mp checked).1).2.2.1 + ((Classical.choice (compiled.system.checkMemo_sound checked)).derives_of_acyclic acyclic) arguments decoded + +theorem GenericArtifact.check_sound {prepared : Generic.Specialized source entries} + (compiled : GenericArtifact prepared) {name : String} + {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} + {wires : List (WireValue F)} {output : WireValue F} {rows : List (Circuit.Row F)} + (checked : compiled.artifact.check rom ⟨name, wires, output⟩ rows = .ok ()) + (arguments : DecodesValues prepared.program.enums wires (entryValues args)) + (decoded : output.decode prepared.program.enums = some result) : + ∃ value heap, source.EvalCall name args value ∧ + Represents (rom.decode prepared.program.enums) heap value result := by + obtain ⟨selected, checked⟩ := Artifact.check_iff.mp checked + have selected : name ∈ entries := by simpa only [(compile_stages compiled.compiled).2.2.1] using selected + obtain ⟨value, heap, evaluated, related⟩ := compiled.checker_heap_sound selected checked arguments decoded + exact ⟨value, heap, ⟨(prepared.valid.2.2.2.2.2.2.2 name selected).2.1, heap, evaluated⟩, related⟩ + +/-- The public module API connects the original source predicate to the final +integer checker. No reference-compiler run is required. -/ +theorem ModulesArtifact.check_complete [Fintype F] {program : Modules.Program F} + {prepared : Modules.Prepared program} (compiled : ModulesArtifact prepared) + (evaluated : prepared.EvalFn name args value heap) (capacity : heap.length ≤ Fintype.card F) : + ∃ (encode : Nat → F), ∃ wires output rom rows, + DecodesValues compiled.circuit.system.enums wires (entryValues args) ∧ + output.decode compiled.circuit.system.enums = some (value.mapAddress encode) ∧ + compiled.check rom name wires output rows = .ok () := by + obtain ⟨entry, selected, evaluated⟩ := evaluated + obtain ⟨encode, wires, output, rom, rows, arguments, decoded, checked⟩ := + compiled.circuit.checker_heap_complete (Modules.Prepared.entry_mem selected) evaluated capacity + refine ⟨encode, wires, output, rom, rows, arguments, decoded, ?_⟩ + simp only [ModulesArtifact.check, selected] + exact Artifact.check_iff.mpr ⟨by + simpa only [(compile_stages compiled.circuit.compiled).2.2.1] using Modules.Prepared.entry_mem selected, checked⟩ + +theorem ModulesArtifact.checkMemo_complete [Fintype F] {program : Modules.Program F} + {prepared : Modules.Prepared program} (compiled : ModulesArtifact prepared) + (evaluated : prepared.EvalFn name args value heap) (capacity : heap.length ≤ Fintype.card F) : + ∃ (encode : Nat → F), ∃ wires output rom rows, + DecodesValues compiled.circuit.system.enums wires (entryValues args) ∧ + output.decode compiled.circuit.system.enums = some (value.mapAddress encode) ∧ + compiled.checkMemo rom name wires output rows = .ok () := by + obtain ⟨entry, selected, evaluated⟩ := evaluated + obtain ⟨encode, wires, output, rom, rows, arguments, decoded, checked⟩ := + compiled.circuit.checkerMemo_heap_complete (Modules.Prepared.entry_mem selected) evaluated capacity + refine ⟨encode, wires, output, rom, rows, arguments, decoded, ?_⟩ + simp only [ModulesArtifact.checkMemo, selected] + exact Artifact.checkMemo_iff.mpr ⟨by + simpa only [(compile_stages compiled.circuit.compiled).2.2.1] using Modules.Prepared.entry_mem selected, checked⟩ + +theorem ModulesArtifact.run_complete [Fintype F] {program : Modules.Program F} + {prepared : Modules.Prepared program} (compiled : ModulesArtifact prepared) + {hints : prepared.environment.source.HintProvider} + (executed : prepared.run name args fuel hints = .ok (value, heap)) (capacity : heap.length ≤ Fintype.card F) : + ∃ (encode : Nat → F), ∃ wires output rom rows, + DecodesValues compiled.circuit.system.enums wires (entryValues args) ∧ + output.decode compiled.circuit.system.enums = some (value.mapAddress encode) ∧ + compiled.check rom name wires output rows = .ok () := + compiled.check_complete (Modules.Prepared.run_heap_spec executed) capacity + +theorem ModulesArtifact.runMemo_complete [Fintype F] {program : Modules.Program F} + {prepared : Modules.Prepared program} (compiled : ModulesArtifact prepared) + {hints : prepared.environment.source.HintProvider} + (executed : prepared.run name args fuel hints = .ok (value, heap)) (capacity : heap.length ≤ Fintype.card F) : + ∃ (encode : Nat → F), ∃ wires output rom rows, + DecodesValues compiled.circuit.system.enums wires (entryValues args) ∧ + output.decode compiled.circuit.system.enums = some (value.mapAddress encode) ∧ + compiled.checkMemo rom name wires output rows = .ok () := + compiled.checkMemo_complete (Modules.Prepared.run_heap_spec executed) capacity + +theorem ModulesArtifact.check_sound {program : Modules.Program F} {prepared : Modules.Prepared program} + (compiled : ModulesArtifact prepared) + {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} + {wires : List (WireValue F)} {output : WireValue F} {rows : List (Circuit.Row F)} + (checked : compiled.check rom name wires output rows = .ok ()) + (arguments : DecodesValues compiled.specialized.program.enums wires (entryValues args)) + (decoded : output.decode compiled.specialized.program.enums = some result) : + ∃ value heap, prepared.EvalCall name args value ∧ + Represents (rom.decode compiled.specialized.program.enums) heap value result := by + cases selected : prepared.find? name with + | none => simp [ModulesArtifact.check, selected] at checked + | some entry => + simp only [ModulesArtifact.check, selected] at checked + obtain ⟨value, heap, evaluated, related⟩ := compiled.circuit.check_sound checked arguments decoded + exact ⟨value, heap, ⟨entry, selected, evaluated⟩, related⟩ + +theorem ModulesArtifact.checkMemo_rows {program : Modules.Program F} {prepared : Modules.Prepared program} + (compiled : ModulesArtifact prepared) {entry : Modules.Selection program prepared.environment.assembly.instances} + (selected : prepared.find? name = some entry) + (checked : compiled.checkMemo rom name wires output rows = .ok ()) : + compiled.circuit.system.checkMemo rom ⟨entry.resolved.name, wires, output⟩ rows = .ok () := by + simp only [ModulesArtifact.checkMemo, selected] at checked + exact (Artifact.checkMemo_iff.mp checked).2 + +/-- Memoized soundness uses acyclicity of the support graph chosen through +`checkMemo_sound`. It does not assume that the source functions are total. -/ +theorem ModulesArtifact.checkMemo_acyclic_sound {program : Modules.Program F} + {prepared : Modules.Prepared program} (compiled : ModulesArtifact prepared) + {entry : Modules.Selection program prepared.environment.assembly.instances} + (selected : prepared.find? name = some entry) + {rom : WireROM F} {args : List (SourceValue F)} {result : Value F} + {wires : List (WireValue F)} {output : WireValue F} {rows : List (Circuit.WeightedRow F)} + (checked : compiled.checkMemo rom name wires output rows = .ok ()) + (acyclic : (Classical.choice (compiled.circuit.system.checkMemo_sound + (compiled.checkMemo_rows selected checked))).Acyclic) + (arguments : DecodesValues compiled.specialized.program.enums wires (entryValues args)) + (decoded : output.decode compiled.specialized.program.enums = some result) : + ∃ value heap, prepared.EvalCall name args value ∧ + Represents (rom.decode compiled.specialized.program.enums) heap value result := by + obtain ⟨value, heap, evaluated, related⟩ := + compiled.circuit.checkerMemo_acyclic_heap_sound (Modules.Prepared.entry_mem selected) + (compiled.checkMemo_rows selected checked) acyclic arguments decoded + have checkedEntry := + (compiled.specialized.valid.2.2.2.2.2.2.2 _ (Modules.Prepared.entry_mem selected)).2.1 + exact ⟨value, heap, ⟨entry, selected, checkedEntry, heap, evaluated⟩, related⟩ + +end Aiur.Optimized diff --git a/Aiur/Aiur/Optimized/ParameterWitness.lean b/Aiur/Aiur/Optimized/ParameterWitness.lean new file mode 100644 index 000000000..70db6d7b2 --- /dev/null +++ b/Aiur/Aiur/Optimized/ParameterWitness.lean @@ -0,0 +1,66 @@ +import Aiur.Optimized.PrimitiveWitness +import Aiur.Optimized.ScopedInvariant +import Aiur.Circuit.ParameterWitness + +namespace Aiur.Optimized.Compiler + +variable {F : Type} [Field F] [DecidableEq F] + +theorem freshValues_decoded_complete {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) (tags : decls.tagsValid F = true) + {role : Role} {types : List Ty} {vars : List (WireValue Witness)} {before after : State F} + (compiled : (types.mapM (freshValue decls role)) before = .ok (vars, after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (valid : before.Valid rom calls initial) + (values : List (Value F)) (shape : values.map Value.type = types) + (formed : ∀ value ∈ values, value.wellFormed decls = true) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + (∀ wire ∈ vars, Circuit.Compiler.Bounded (F := F) after.roles.size (wire.map Polynomial.var)) ∧ + DecodesValues decls (vars.map (WireValue.map assignment)) values := by + induction values generalizing vars types before initial with + | nil => + subst types + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [List.map_nil, List.mapM_nil, List.reverse_nil] using compiled) + exact ⟨initial, .refl layout ((before.valid_iff_reference rom calls initial).mp valid), by simp, .nil⟩ + | cons value values ih => + subst types + simp only [List.map_cons, List.mapM_cons] at compiled + obtain ⟨head, middle, headRun, tailBind⟩ := bind_ok.mp compiled + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp tailBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, headExt, headBound, headDecode⟩ := freshValue_decoded_complete checked tags headRun + layout valid value rfl (formed _ (by simp)) + obtain ⟨b, tailExt, tailBound, tailDecode⟩ := ih tailRun headExt.layout headExt.validAssignment rfl + (fun v h => formed v (by simp [h])) + refine ⟨b, headExt.trans tailExt, ?_, .cons ?_ tailDecode⟩ + · simpa [State.toReference] using And.intro (headBound.mono tailExt.increase) tailBound + · rw [tailExt.variables headBound] + exact headDecode + +theorem freshValues_scoped {decls : Declarations} {role : Role} {types : List Ty} + {vars : List (WireValue Witness)} {before after : State F} + (compiled : (types.mapM (freshValue decls role)) before = .ok (vars, after)) + (scopeLayout : before.Scoped) : after.Scoped := by + induction types generalizing vars before with + | nil => + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [List.map_nil, List.mapM_nil, List.reverse_nil] using compiled) + exact scopeLayout + | cons type types ih => + simp only [List.mapM_cons] at compiled + obtain ⟨head, middle, headRun, tailBind⟩ := bind_ok.mp compiled + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp tailBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + exact ih tailRun (freshValue_scoped headRun scopeLayout) + +theorem validateValues_scoped {decls : Declarations} {scope : ScopeId} {wires : List (Symbolic F)} + {before after : State F} + (compiled : (do for wire in wires do validateValue decls scope wire : Build F Unit) + before = .ok ((), after)) + (scopeLayout : before.Scoped) (scopeValid : scope < before.scopes.size) : + before.Extends after ∧ after.Scoped := by + obtain ⟨⟨⟩, middle, loopRun, finished⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp finished + exact forIn_scoped loopRun scopeLayout scopeValid + (fun _ _ {_ _} run layout bound => validateValue_scoped run layout bound) + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/PatternCorrectness.lean b/Aiur/Aiur/Optimized/PatternCorrectness.lean new file mode 100644 index 000000000..95cb0e899 --- /dev/null +++ b/Aiur/Aiur/Optimized/PatternCorrectness.lean @@ -0,0 +1,195 @@ +import Aiur.Optimized.BuildFacts +import Aiur.Optimized.BranchFacts + +namespace Aiur.Optimized.Compiler + +open Circuit.Compiler (localsEnvironment localsEnvironment_append) + +variable {F : Type} [Field F] [DecidableEq F] +set_option maxHeartbeats 2000000 +set_option maxRecDepth 4096 + +def AllZero (conditions : List (Polynomial F)) (assignment : Witness → F) : Prop := + ∀ condition ∈ conditions, condition.denote assignment = 0 + +@[simp] theorem allZero_append (left right : List (Polynomial F)) (assignment : Witness → F) : + AllZero (left ++ right) assignment ↔ AllZero left assignment ∧ AllZero right assignment := by + simp only [AllZero, List.forall_mem_append] + +/-- Conditions are a conjunction, so a failed constructor tag suffices without +interpreting a payload using the wrong constructor's layout. -/ +def PatternMeaning (decls : Declarations) (matched : Option (Environment F)) + (conditions : List (Polynomial F)) (bindings : Locals F) (assignment : Witness → F) : Prop := + (∃ environment, matched = some environment ∧ AllZero conditions assignment ∧ + DecodesEnvironment decls (localsEnvironment bindings assignment) environment) ∨ + (matched = none ∧ ¬ AllZero conditions assignment) + +mutual + theorem pattern_correct {decls : Declarations} (checked : checkDeclarations decls = .ok ()) + (tags : decls.tagsValid F = true) {pat : Pattern F} {wire : Symbolic F} + {conditions : List (Polynomial F)} {bindings : Locals F} {before after : State F} + (compiled : pattern decls pat wire before = .ok ((conditions, bindings), after)) : + after = before ∧ ∀ assignment value, + (wire.map (Circuit.ArithExpr.denote assignment)).decode decls = some value → + PatternMeaning decls (pat.bindings value) conditions bindings assignment := by + cases pat with + | wildcard => + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp (by simpa only [pattern] using compiled) + exact ⟨rfl, fun _ _ _ => Or.inl ⟨[], by simp [Pattern.bindings], by simp [AllZero], .nil⟩⟩ + | bind name => + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp (by simpa only [pattern] using compiled) + exact ⟨rfl, fun _ value decoded => Or.inl + ⟨[(name, value)], by simp [Pattern.bindings], by simp [AllZero], .cons ⟨rfl, decoded⟩ .nil⟩⟩ + | literal literal => + rcases wire with ⟨type, words⟩ + cases type with + | tuple | ptr | enum => simp [pattern] at compiled + | field => + cases words with + | nil => simp [pattern] at compiled + | cons word rest => cases rest with + | cons => simp [pattern] at compiled + | nil => + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp (by simpa only [pattern] using compiled) + refine ⟨rfl, fun assignment value decoded => ?_⟩ + have same : Value.field (word.denote assignment) = value := by + change (WireValue.field (word.denote assignment)).decode decls = some value at decoded + simpa only [WireValue.decode_field, Option.some.injEq] using decoded + subst value + by_cases matched : literal = word.denote assignment + · exact Or.inl ⟨[], by simp [Pattern.bindings, matched], + by simp [AllZero, Scalar.Circuit.ArithExpr.denote, ← matched], .nil⟩ + · refine Or.inr ⟨by simp [Pattern.bindings, matched], ?_⟩ + intro allZero + exact matched (sub_eq_zero.mp (allZero _ (List.mem_singleton_self _))).symm + | tuple patterns => + rcases wire with ⟨type, words⟩ + cases type with + | field | ptr | enum => simp [pattern] at compiled + | tuple types => + simp only [pattern] at compiled + obtain ⟨wires, middle, splitRun, patternRun⟩ := bind_ok.mp compiled + obtain ⟨rfl, reference⟩ := splitValues_reference splitRun + obtain ⟨unchanged, meaning⟩ := patternList_correct checked tags patternRun + refine ⟨unchanged, fun assignment value decoded => ?_⟩ + obtain ⟨values, rfl, valuesDecoded⟩ := Circuit.Compiler.splitValues_decode checked (reference {}) decoded + simpa only [Pattern.bindings] using meaning assignment values valuesDecoded + | construct name ctor patterns => + simp only [pattern] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · rename_i typeEq + have typeEq : wire.type = .enum name := by simpa using typeEq + obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + cases found : decls.findEnum? name with + | none => simp [found] at rest + | some definition => + simp only [found] at rest + cases atIndex : definition.constructors[definition.constructors.findIdx (·.name == ctor)]? with + | none => simp [atIndex] at rest + | some constructor => + simp only [atIndex] at rest + have ctorName : constructor.name = ctor := by + simpa using List.findIdx_of_getElem?_eq_some atIndex + rcases wire with ⟨type, words⟩ + dsimp only at typeEq + subst type + cases parts : Layout.enumParts definition.constructors.length (.const 0) words with + | none => simp [parts] at rest + | some pair => + rcases pair with ⟨tag, payload⟩ + simp only [parts] at rest + obtain ⟨layout, s₁, layoutRun, afterLayout⟩ := bind_ok.mp rest + obtain ⟨expansion, stateEq⟩ := getLayout_eq layoutRun + subst s₁ + obtain ⟨values, s₂, splitRun, afterSplit⟩ := bind_ok.mp afterLayout + obtain ⟨stateEq, reference⟩ := splitValues_reference splitRun + subst s₂ + obtain ⟨⟨payloadConditions, payloadBindings⟩, s₃, payloadRun, finished⟩ := bind_ok.mp afterSplit + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp finished + obtain ⟨unchanged, payloadMeaning⟩ := patternList_correct checked tags payloadRun + refine ⟨unchanged, fun assignment value decoded => ?_⟩ + obtain ⟨actual, args, rfl, tagMatch, payloadDecoded⟩ := + Circuit.Compiler.enum_payload_decoded checked tags found atIndex expansion parts (reference {}) decoded + rw [ctorName] at tagMatch payloadDecoded + by_cases same : actual = ctor + · have selected := tagMatch.mpr same + have meaning := payloadMeaning assignment args (payloadDecoded same) + subst actual + simpa [PatternMeaning, Pattern.bindings, AllZero, selected, + Scalar.Circuit.ArithExpr.denote] using meaning + · refine Or.inr ⟨by simp [Pattern.bindings, Ne.symm same], ?_⟩ + intro allZero + have tagZero := allZero _ (List.mem_cons_self ..) + change tag.denote assignment - _ = 0 at tagZero + exact same (tagMatch.mp (sub_eq_zero.mp tagZero)) + termination_by sizeOf pat + + theorem patternList_correct {decls : Declarations} (checked : checkDeclarations decls = .ok ()) + (tags : decls.tagsValid F = true) {patterns : List (Pattern F)} {wires : List (Symbolic F)} + {conditions : List (Polynomial F)} {bindings : Locals F} {before after : State F} + (compiled : patternList decls patterns wires before = .ok ((conditions, bindings), after)) : + after = before ∧ ∀ assignment values, + DecodesValues decls (wires.map (WireValue.map (Circuit.ArithExpr.denote assignment))) values → + PatternMeaning decls (Pattern.bindingsList patterns values) conditions bindings assignment := by + cases patterns with + | nil => + cases wires with + | nil => + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp (by simpa only [patternList] using compiled) + refine ⟨rfl, fun _ values decoded => ?_⟩ + cases decoded + exact Or.inl ⟨[], by simp [Pattern.bindingsList], by simp [AllZero], .nil⟩ + | cons => simp [patternList] at compiled + | cons pat patterns => + cases wires with + | nil => simp [patternList] at compiled + | cons wire wires => + simp only [patternList] at compiled + obtain ⟨⟨head, headBindings⟩, middle, headRun, rest⟩ := bind_ok.mp compiled + obtain ⟨⟨tail, tailBindings⟩, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp finished + obtain ⟨rfl, headMeaning⟩ := pattern_correct checked tags headRun + obtain ⟨rfl, tailMeaning⟩ := patternList_correct checked tags tailRun + refine ⟨rfl, fun assignment values decoded => ?_⟩ + cases decoded with + | cons headDecoded tailDecoded => + rcases headMeaning assignment _ headDecoded with + ⟨headValues, headMatch, headZero, headBindingsDecode⟩ | ⟨headMatch, headNonzero⟩ <;> + rcases tailMeaning assignment _ tailDecoded with + ⟨tailValues, tailMatch, tailZero, tailBindingsDecode⟩ | ⟨tailMatch, tailNonzero⟩ + · exact Or.inl ⟨headValues ++ tailValues, by simp [Pattern.bindingsList, headMatch, tailMatch], + (allZero_append _ _ _).mpr ⟨headZero, tailZero⟩, + by simpa only [localsEnvironment_append] using headBindingsDecode.append tailBindingsDecode⟩ + · exact Or.inr ⟨by simp [Pattern.bindingsList, headMatch, tailMatch], + fun allZero => tailNonzero ((allZero_append _ _ _).mp allZero).2⟩ + · exact Or.inr ⟨by simp [Pattern.bindingsList, headMatch], + fun allZero => headNonzero ((allZero_append _ _ _).mp allZero).1⟩ + · exact Or.inr ⟨by simp [Pattern.bindingsList, headMatch], + fun allZero => headNonzero ((allZero_append _ _ _).mp allZero).1⟩ + termination_by sizeOf patterns +end + +/-- Exact rejection of an earlier pattern by the optimized linear failure +certificate, including nested tuples and enum patterns. -/ +theorem pattern_failure_iff {decls : Declarations} (checked : checkDeclarations decls = .ok ()) + (tags : decls.tagsValid F = true) {pat : Pattern F} {wire : Symbolic F} + {conditions : List (Polynomial F)} {bindings : Locals F} {before after : State F} + (compiled : pattern decls pat wire before = .ok ((conditions, bindings), after)) + {assignment : Witness → F} {value : Value F} + (decoded : (wire.map (Circuit.ArithExpr.denote assignment)).decode decls = some value) : + (∃ coefficients, coefficients.length = conditions.length ∧ + combination (conditions.map (Circuit.ArithExpr.denote assignment)) coefficients = 1) ↔ + pat.bindings value = none := by + have algebra := failure_certificate_iff (conditions.map (Circuit.ArithExpr.denote assignment)) + simp only [List.length_map, List.forall_mem_map] at algebra + rw [algebra] + rcases (pattern_correct checked tags compiled).2 assignment value decoded with + ⟨environment, matched, allZero, _⟩ | ⟨matched, nonzero⟩ + · simp only [matched, Option.some_ne_none, iff_false] + exact not_not_intro allZero + · simp only [matched, iff_true] + exact nonzero + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/PatternIrrefutable.lean b/Aiur/Aiur/Optimized/PatternIrrefutable.lean new file mode 100644 index 000000000..a0b5442cd --- /dev/null +++ b/Aiur/Aiur/Optimized/PatternIrrefutable.lean @@ -0,0 +1,175 @@ +import Aiur.Optimized.PatternCorrectness + +namespace Aiur.Optimized.Compiler + +set_option maxHeartbeats 1600000 +set_option maxRecDepth 4096 + +mutual + /-- An irrefutable pattern lowered for a canonical input always collects bindings. -/ + theorem pattern_matches [Field F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) (tags : decls.tagsValid F = true) + {pattern : Pattern F} {wire : Symbolic F} {test : List (Polynomial F)} {bindings : Locals F} + {before after : State F} + (compiled : Compiler.pattern decls pattern wire before = .ok ((test, bindings), after)) + (irrefutable : pattern.irrefutable decls = true) {assignment : Witness → F} {value : Value F} + (decoded : (wire.map (Circuit.ArithExpr.denote assignment)).decode decls = some value) : + ∃ values, pattern.bindings value = some values := by + cases pattern with + | wildcard => exact ⟨[], by simp [Pattern.bindings]⟩ + | bind name => exact ⟨[(name, value)], by simp [Pattern.bindings]⟩ + | literal => simp [Pattern.irrefutable] at irrefutable + | tuple patterns => + rcases wire with ⟨type, words⟩ + cases type with + | field | ptr | enum => simp [Compiler.pattern] at compiled + | tuple types => + simp only [Compiler.pattern] at compiled + obtain ⟨wires, middle, splitRun, patternRun⟩ := bind_ok.mp compiled + obtain ⟨_, splitReference⟩ := splitValues_reference splitRun + obtain ⟨values, rfl, valuesDecoded⟩ := Circuit.Compiler.splitValues_decode checked (splitReference {}) decoded + simpa only [Pattern.bindings] using patternList_matches checked tags patternRun + (by simpa [Pattern.irrefutable] using irrefutable) valuesDecoded + | construct name ctor patterns => + simp only [Compiler.pattern] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · rename_i typeEq + have typeEq : wire.type = .enum name := by simpa using typeEq + obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + cases found : decls.findEnum? name with + | none => simp [found] at rest + | some definition => + simp only [found] at rest + cases atIndex : definition.constructors[definition.constructors.findIdx (·.name == ctor)]? with + | none => simp [atIndex] at rest + | some constructor => + simp only [atIndex] at rest + have ctorName : constructor.name = ctor := by simpa using List.findIdx_of_getElem?_eq_some atIndex + have only : definition.constructors = [constructor] ∧ + (∀ p ∈ patterns, p.irrefutable decls = true) := by + rcases definition with ⟨defName, ctors⟩ + cases ctors with + | nil => simp [Pattern.irrefutable, found] at irrefutable + | cons first others => + cases others with + | cons => simp [Pattern.irrefutable, found] at irrefutable + | nil => + simp only [Pattern.irrefutable, found, Bool.and_eq_true, beq_iff_eq, + List.all_eq_true, List.mem_map, forall_exists_index, and_imp] at irrefutable + have same : first = constructor := by + simpa [List.findIdx_cons, irrefutable.1] using atIndex + subst first + exact ⟨rfl, by simpa using irrefutable.2⟩ + rcases wire with ⟨type, words⟩ + dsimp only at typeEq + subst type + cases parts : Layout.enumParts definition.constructors.length (.const 0) words with + | none => simp [parts] at rest + | some pair => + rcases pair with ⟨tag, payload⟩ + simp only [parts] at rest + obtain ⟨layout, s₁, layoutRun, rest⟩ := bind_ok.mp rest + obtain ⟨expansion, rfl⟩ := getLayout_eq layoutRun + obtain ⟨values, s₂, splitRun, rest⟩ := bind_ok.mp rest + obtain ⟨_, splitReference⟩ := splitValues_reference splitRun + obtain ⟨⟨payloadTest, payloadBindings⟩, s₄, payloadRun, finished⟩ := bind_ok.mp rest + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp finished + obtain ⟨actual, args, rfl, _, payloadDecoded⟩ := + Circuit.Compiler.enum_payload_decoded checked tags found atIndex expansion parts (splitReference {}) decoded + have formed := (WireValue.decode_spec decoded).2.1 + have same : actual = ctor := by + by_contra different + simp [Value.wellFormed, Declarations.findConstructor?, found, only.1, + ctorName, Ne.symm different] at formed + obtain ⟨values, matched⟩ := patternList_matches checked tags payloadRun only.2 + (payloadDecoded (same.trans ctorName.symm)) + exact ⟨values, by simpa [Pattern.bindings, same] using matched⟩ + termination_by sizeOf pattern + + theorem patternList_matches [Field F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) (tags : decls.tagsValid F = true) + {patterns : List (Pattern F)} {wires : List (Symbolic F)} + {test : List (Polynomial F)} {bindings : Locals F} {before after : State F} + (compiled : patternList decls patterns wires before = .ok ((test, bindings), after)) + (irrefutable : ∀ pattern ∈ patterns, pattern.irrefutable decls = true) + {assignment : Witness → F} {values : List (Value F)} + (decoded : DecodesValues decls (wires.map (WireValue.map (Circuit.ArithExpr.denote assignment))) values) : + ∃ bindings, Pattern.bindingsList patterns values = some bindings := by + cases patterns with + | nil => + cases wires with + | cons => simp [patternList] at compiled + | nil => cases decoded; exact ⟨[], by simp [Pattern.bindingsList]⟩ + | cons pattern patterns => + cases wires with + | nil => simp [patternList] at compiled + | cons wire wires => + simp only [patternList] at compiled + obtain ⟨⟨head, headBindings⟩, middle, headRun, rest⟩ := bind_ok.mp compiled + obtain ⟨⟨tail, tailBindings⟩, last, tailRun, finished⟩ := bind_ok.mp rest + cases decoded with + | cons headDecode tailDecode => + obtain ⟨head, matchedHead⟩ := pattern_matches checked tags headRun (irrefutable _ (by simp)) headDecode + obtain ⟨tail, matchedTail⟩ := patternList_matches checked tags tailRun + (fun p h => irrefutable p (by simp [h])) tailDecode + exact ⟨head ++ tail, by simp [Pattern.bindingsList, matchedHead, matchedTail]⟩ + termination_by sizeOf patterns +end + +/-- First successful source pattern, counted in source order. The value on a +list with no matching arm is irrelevant to successful compilation witnesses. -/ +def armIndex [DecidableEq F] (input : Value F) : List (Pattern F × Expr F) → Nat + | [] => 0 + | (pat, _) :: rest => if (pat.bindings input).isSome then 0 else armIndex input rest + 1 + +@[simp] theorem armIndex_cons_some [DecidableEq F] {input : Value F} {pat : Pattern F} + {body : Expr F} {rest : List (Pattern F × Expr F)} {bindings : Environment F} + (matched : pat.bindings input = some bindings) : armIndex input ((pat, body) :: rest) = 0 := by + simp [armIndex, matched] + +@[simp] theorem armIndex_cons_none [DecidableEq F] {input : Value F} {pat : Pattern F} + {body : Expr F} {rest : List (Pattern F × Expr F)} + (unmatched : pat.bindings input = none) : + armIndex input ((pat, body) :: rest) = armIndex input rest + 1 := by + simp [armIndex, unmatched] + +/-- A successful source match selects one of the scopes actually emitted by +the compiler. Truncation after an irrefutable arm cannot hide this selection. -/ +theorem lowerArms_index_lt [Field F] [DecidableEq F] {program : Program F} + (checked : checkDeclarations program.enums = .ok ()) (tags : program.enums.tagsValid F = true) + {function : String} {locals : Locals F} {scrutinee : Symbolic F} {result : WireValue Witness} + {scopes : List ScopeId} {arms : List (Pattern F × Expr F)} {previous : List (List (Polynomial F))} + {before after : State F} + (compiled : lowerArms program function locals scrutinee result scopes arms previous before = .ok ((), after)) + {assignment : Witness → F} {input : Value F} + (decoded : (scrutinee.map (Circuit.ArithExpr.denote assignment)).decode program.enums = some input) + {bindings : Environment F} {body : Expr F} + (selected : selectArm input arms = some (bindings, body)) : armIndex input arms < scopes.length := by + induction arms generalizing scopes previous before with + | nil => simp [selectArm] at selected + | cons arm arms ih => + rcases arm with ⟨pat, headBody⟩ + cases scopes with + | nil => simp [lowerArms] at compiled + | cons scope scopes => + simp only [lowerArms] at compiled + obtain ⟨⟨conditions, patternBindings⟩, s₁, patternRun, guardsBind⟩ := bind_ok.mp compiled + obtain ⟨⟨⟩, s₂, _, failuresBind⟩ := bind_ok.mp guardsBind + obtain ⟨⟨⟩, s₃, _, bodyBind⟩ := bind_ok.mp failuresBind + obtain ⟨_, s₄, _, rest⟩ := bind_ok.mp bodyBind + cases matched : pat.bindings input with + | some matchedBindings => simp [armIndex, matched] + | none => + split at rest + · rename_i irrefutable + obtain ⟨_, matchSome⟩ := pattern_matches checked tags patternRun irrefutable decoded + rw [matched] at matchSome + cases matchSome + · have tailSelected : selectArm input arms = some (bindings, body) := by + simpa only [selectArm, matched] using selected + have bound := ih rest tailSelected + simpa [armIndex, matched] using Nat.succ_lt_succ bound + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/PatternWitness.lean b/Aiur/Aiur/Optimized/PatternWitness.lean new file mode 100644 index 000000000..5f99981c0 --- /dev/null +++ b/Aiur/Aiur/Optimized/PatternWitness.lean @@ -0,0 +1,126 @@ +import Aiur.Optimized.PrimitiveWitness +import Aiur.Optimized.PatternCorrectness + +namespace Aiur.Optimized.Compiler + +variable {F : Type} [Field F] [DecidableEq F] +open Circuit.Compiler (Bounded LocalsBounded) + +set_option maxHeartbeats 2000000 +set_option maxRecDepth 4096 + +theorem splitValues_bounded {decls : Declarations} {types : List Ty} {words : List (Polynomial F)} + {values : List (Symbolic F)} {before after : State F} + (compiled : splitValues decls types words before = .ok (values, after)) {bound : Nat} + (bounded : ∀ word ∈ words, word.inBounds bound = true) : + ∀ value ∈ values, Bounded bound value := + Circuit.Compiler.splitValues_bounded ((splitValues_reference compiled).2 {}) bounded + +mutual + /-- Optimized patterns are static polynomial views and allocate no witnesses. -/ + theorem pattern_bounded {decls : Declarations} {pat : Pattern F} {wire : Symbolic F} + {conditions : List (Polynomial F)} {bindings : Locals F} {before after : State F} + (compiled : pattern decls pat wire before = .ok ((conditions, bindings), after)) + {bound : Nat} (bounded : Bounded bound wire) : + after = before ∧ (∀ condition ∈ conditions, condition.inBounds bound = true) ∧ + LocalsBounded bound bindings := by + cases pat with + | wildcard => + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp (by simpa only [pattern] using compiled) + exact ⟨rfl, by simp, by simp [LocalsBounded]⟩ + | bind name => + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp (by simpa only [pattern] using compiled) + exact ⟨rfl, by simp, by simpa [LocalsBounded] using bounded⟩ + | literal literal => + rcases wire with ⟨type, words⟩ + cases type with + | tuple | ptr | enum => simp [pattern] at compiled + | field => + cases words with + | nil => simp [pattern] at compiled + | cons word rest => cases rest with + | cons => simp [pattern] at compiled + | nil => + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp (by simpa only [pattern] using compiled) + exact ⟨rfl, by simpa [Scalar.Circuit.ArithExpr.inBounds] using bounded word (by simp), + by simp [LocalsBounded]⟩ + | tuple patterns => + rcases wire with ⟨type, words⟩ + cases type with + | field | ptr | enum => simp [pattern] at compiled + | tuple types => + simp only [pattern] at compiled + obtain ⟨wires, middle, splitRun, patternRun⟩ := bind_ok.mp compiled + obtain ⟨rfl, _⟩ := splitValues_reference splitRun + exact patternList_bounded patternRun (splitValues_bounded splitRun bounded) + | construct name ctor patterns => + simp only [pattern] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + cases found : decls.findEnum? name with + | none => simp [found] at rest + | some definition => + simp only [found] at rest + cases atIndex : definition.constructors[definition.constructors.findIdx (·.name == ctor)]? with + | none => simp [atIndex] at rest + | some constructor => + simp only [atIndex] at rest + rcases wire with ⟨type, words⟩ + cases parts : Layout.enumParts definition.constructors.length (.const 0) words with + | none => simp [parts] at rest + | some pair => + rcases pair with ⟨tag, payload⟩ + simp only [parts] at rest + obtain ⟨headBound, tailBound⟩ := Layout.enumParts_all parts (by rfl) bounded + obtain ⟨layout, afterLayout, layoutRun, afterLayoutBind⟩ := bind_ok.mp rest + obtain ⟨_, stateEq⟩ := getLayout_eq layoutRun + subst afterLayout + obtain ⟨values, afterSplit, splitRun, afterSplitBind⟩ := bind_ok.mp afterLayoutBind + obtain ⟨stateEq, _⟩ := splitValues_reference splitRun + subst afterSplit + obtain ⟨⟨payloadConditions, payloadBindings⟩, afterPatterns, payloadRun, finished⟩ := + bind_ok.mp afterSplitBind + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp finished + obtain ⟨unchanged, payloadBound, bindingsBound⟩ := patternList_bounded payloadRun + (splitValues_bounded splitRun + (fun p member => tailBound p (List.mem_of_mem_take member))) + refine ⟨unchanged, ?_, bindingsBound⟩ + intro p member + rcases List.mem_cons.mp member with rfl | member + · simpa [Scalar.Circuit.ArithExpr.inBounds] using headBound + · exact payloadBound p member + termination_by sizeOf pat + + theorem patternList_bounded {decls : Declarations} {patterns : List (Pattern F)} + {values : List (Symbolic F)} {conditions : List (Polynomial F)} {bindings : Locals F} + {before after : State F} + (compiled : patternList decls patterns values before = .ok ((conditions, bindings), after)) + {bound : Nat} (bounded : ∀ value ∈ values, Bounded bound value) : + after = before ∧ (∀ condition ∈ conditions, condition.inBounds bound = true) ∧ + LocalsBounded bound bindings := by + cases patterns with + | nil => + cases values with + | nil => + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp (by simpa only [patternList] using compiled) + exact ⟨rfl, by simp, by simp [LocalsBounded]⟩ + | cons => simp [patternList] at compiled + | cons pat patterns => + cases values with + | nil => simp [patternList] at compiled + | cons value values => + simp only [patternList] at compiled + obtain ⟨⟨head, headBindings⟩, middle, headRun, rest⟩ := bind_ok.mp compiled + obtain ⟨⟨tail, tailBindings⟩, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp finished + obtain ⟨rfl, headBound, headLocals⟩ := pattern_bounded headRun (bounded value (by simp)) + obtain ⟨rfl, tailBound, tailLocals⟩ := patternList_bounded tailRun + (fun value member => bounded value (by simp [member])) + exact ⟨rfl, by simpa only [List.forall_mem_append] using And.intro headBound tailBound, + Circuit.Compiler.localsBounded_append.mpr ⟨headLocals, tailLocals⟩⟩ + termination_by sizeOf patterns +end + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/Physical.lean b/Aiur/Aiur/Optimized/Physical.lean new file mode 100644 index 000000000..e6f601634 --- /dev/null +++ b/Aiur/Aiur/Optimized/Physical.lean @@ -0,0 +1,120 @@ +import Aiur.Circuit.Erasure +import Aiur.Optimized.NativeCorrectness + +namespace Aiur.Optimized.Physical + +open Circuit +variable {F : Type} [Field F] [DecidableEq F] + +/-- Erase static interfaces, then reuse the certified recursive partitioning +pass. The original typed artifact remains the source-level proof interface. -/ +structure Prepared (artifact : Artifact F) where + compatible : Erasure.Compatible artifact.system + merged : Dedup.CheckedResult (Erasure.system artifact.system) artifact.entries + +def prepare (artifact : Artifact F) : Except String (Prepared artifact) := do + if compatible : Erasure.Compatible artifact.system then + let source := Erasure.system artifact.system + let merged ← if artifact.config.deduplicate then Dedup.run source artifact.entries + else Dedup.certify source artifact.entries (Dedup.identity source) + return ⟨compatible, merged⟩ + else throw "physical circuit interfaces failed their type-erasure certificate" + +def Prepared.system {artifact : Artifact F} (prepared : Prepared artifact) : Circuit.System F := + prepared.merged.system + +def Prepared.representative {artifact : Artifact F} (prepared : Prepared artifact) (name : String) : String := + Dedup.rename prepared.merged.representatives (Dedup.rename artifact.representatives name) + +/-- Fixed tables retain their existing channels and typed proof interface. -/ +theorem table_separated (artifact : Artifact F) (claim : Message F) + (member : artifact.system.MapClaim claim) : artifact.system.findChip? claim.channel = none := by + have oldMember : artifact.unmerged.MapClaim claim := by + simpa only [System.MapClaim, artifact.deduplication.2.2.2.1] using member + have absent := artifact.deduplication.2.2.2.2.1 claim oldMember + have found := artifact.deduplication.lookup claim.channel + simpa only [artifact.deduplication.outside absent, absent, Option.map_none] using found + +theorem Prepared.derives_iff {artifact : Artifact F} (prepared : Prepared artifact) + {rom : WidthROM F} {root : Message F} (entry : root.channel ∈ artifact.entries) + (signed : Erasure.Signed artifact.system root) : + Derives artifact.system (Erasure.typedROM artifact.system rom) root ↔ + Derives prepared.system (Erasure.rawROM rom) (Erasure.message artifact.system root) := by + rw [Erasure.derives_iff artifact.system prepared.compatible (table_separated artifact) signed] + have fixed := prepared.merged.certificate.entry_fixed + (root := Erasure.message artifact.system root) (by simpa using entry) + simpa only [fixed, Prepared.system] using prepared.merged.certificate.derives_iff + (rom := Erasure.rawROM rom) (root := Erasure.message artifact.system root) + +theorem Prepared.acyclic_iff {artifact : Artifact F} (prepared : Prepared artifact) + {rom : WidthROM F} {root : Message F} (entry : root.channel ∈ artifact.entries) + (signed : Erasure.Signed artifact.system root) : + (∃ graph : MemoDerivation artifact.system (Erasure.typedROM artifact.system rom) root, graph.Acyclic) ↔ + (∃ graph : MemoDerivation prepared.system (Erasure.rawROM rom) (Erasure.message artifact.system root), + graph.Acyclic) := by + rw [← derives_iff_acyclic_memo, ← derives_iff_acyclic_memo] + exact prepared.derives_iff entry signed + +/-- Source soundness includes type-erased merging. Canonicality is still +established by entry/hint constraints and the existing provenance induction. +`signed` specifies the public claim's static interface, without checking values. -/ +theorem Prepared.entry_sound {program : Program F} {entries : List String} {config : Config} + {artifact : Artifact F} (compiled : compile program entries config = .ok artifact) + (prepared : Prepared artifact) {rom : WidthROM F} (valid : rom.Valid) + {root : Message F} (entry : root.channel ∈ entries) + (signed : Erasure.Signed artifact.system root) (free : root.PublicArguments program.enums) + (derived : Derives prepared.system (Erasure.rawROM rom) (Erasure.message artifact.system root)) : + root.Evaluates program (Erasure.typedROM artifact.system rom) := by + apply compiler_entry_sound compiled entry + (rom.toWireROM_valid valid _ _) free + exact (prepared.derives_iff (by simpa only [(compile_stages compiled).2.2.1] using entry) signed).mpr derived + +theorem Prepared.memo_entry_sound {program : Program F} {entries : List String} {config : Config} + {artifact : Artifact F} (compiled : compile program entries config = .ok artifact) + (prepared : Prepared artifact) {rom : WidthROM F} (valid : rom.Valid) + {root : Message F} (entry : root.channel ∈ entries) + (signed : Erasure.Signed artifact.system root) (free : root.PublicArguments program.enums) + (graph : MemoDerivation prepared.system (Erasure.rawROM rom) (Erasure.message artifact.system root)) + (acyclic : graph.Acyclic) : root.Evaluates program (Erasure.typedROM artifact.system rom) := + prepared.entry_sound compiled valid entry signed free (graph.derives_of_acyclic acyclic) + +/-- The reference compiler and the physical merged circuits accept the same +finite entry derivations over the corresponding views of width-local ROM. -/ +theorem Prepared.reference_derives_iff {program : Program F} {entries : List String} {config : Config} + {artifact : Artifact F} {reference : Circuit.System F} + (original : Circuit.compile program = .ok reference) + (compiled : compile program entries config = .ok artifact) (prepared : Prepared artifact) + {rom : WidthROM F} (valid : rom.Valid) {root : Message F} (entry : root.channel ∈ entries) + (signed : Erasure.Signed artifact.system root) (free : root.PublicArguments program.enums) : + Derives reference (Erasure.typedROM artifact.system rom) root ↔ + Derives prepared.system (Erasure.rawROM rom) (Erasure.message artifact.system root) := + (Optimized.reference_derives_iff original compiled entry (rom.toWireROM_valid valid _ _) free).trans + (prepared.derives_iff (by simpa only [(compile_stages compiled).2.2.1] using entry) signed) + +/-- Compose physical merging with specialization, inlining, compilation, and +heap realization, reaching the independent source evaluation predicate. -/ +theorem Prepared.native_heap_sound {source : Generic.Source F} {entries : List String} + {specialized : Generic.Specialized source entries} (compiled : GenericArtifact specialized) + (prepared : Prepared compiled.artifact) {name : String} (entry : name ∈ entries) + {rom : WidthROM F} (valid : rom.Valid) + {args : List (SourceValue F)} {result : Value F} {wires : List (WireValue F)} {output : WireValue F} + (signed : Erasure.Signed compiled.system ⟨name, wires, output⟩) + (derived : Derives prepared.system (Erasure.rawROM rom) + (Erasure.message compiled.system ⟨name, wires, output⟩)) + (arguments : DecodesValues specialized.program.enums wires (entryValues args)) + (decoded : output.decode specialized.program.enums = some result) : + ∃ value heap, Generic.SourceSemantics.EvalFn source.world name args [] value heap ∧ + Represents ((Erasure.typedROM compiled.system rom).decode specialized.program.enums) heap value result := + compiled.heap_sound entry (rom.toWireROM_valid valid _ _) + ((prepared.derives_iff (by simpa only [(compile_stages compiled.compiled).2.2.1] using entry) signed).mpr derived) + arguments decoded + +def Prepared.checkMemo {artifact : Artifact F} (prepared : Prepared artifact) + (rom : WidthROM F) (root : Message F) (rows : List (WeightedRow F)) : Except String Unit := do + unless artifact.entries.contains root.channel do throw s!"unselected entrypoint {root.channel}" + -- The schema is public/static. Canonical enum checks remain in the circuit. + let some original := artifact.system.findChip? root.channel | throw "missing entrypoint circuit" + unless Erasure.messageShape root == Erasure.signature original do throw "wrong entrypoint signature" + (prepared.system.checkMemo (Erasure.rawROM rom) (Erasure.message artifact.system root) rows).mapError reprStr + +end Aiur.Optimized.Physical diff --git a/Aiur/Aiur/Optimized/PhysicalSemantics.lean b/Aiur/Aiur/Optimized/PhysicalSemantics.lean new file mode 100644 index 000000000..2fceb4715 --- /dev/null +++ b/Aiur/Aiur/Optimized/PhysicalSemantics.lean @@ -0,0 +1,187 @@ +import Aiur.Optimized.PolynomialFacts +import Aiur.Circuit.RowWitness + +namespace Aiur.Circuit + +open Aiur.Optimized (Polynomial) + +variable {F : Type} [Field F] [DecidableEq F] + +/-- A physical local rule, retaining the exact ordered list of call slots. -/ +def Chip.LocalRule (chip : Chip F) (rom : WireROM F) + (conclusion : Message F) (premises : List (Message F)) : Prop := + ∃ row, row.chip = chip.name ∧ chip.ValidRow rom row ∧ + chip.receive row = conclusion ∧ chip.premises row = premises + +def Chip.ValidAssignment (chip : Chip F) (rom : WireROM F) (a : Var → F) : Prop := + Satisfies chip.constraints a ∧ ∀ lookup ∈ chip.memory, lookup.Valid rom a + +def Chip.conclusion (chip : Chip F) (a : Var → F) : Message F := + ⟨chip.name, chip.inputs.map (WireValue.map a), chip.output.map (ArithExpr.denote a)⟩ + +def Chip.requirements (chip : Chip F) (a : Var → F) : List (Message F) := + chip.sends.filterMap fun send => + if send.enable.denote a = 1 then some (send.message a) else none + +def Chip.Refines (source target : Chip F) : Prop := + ∀ rom a, source.ValidAssignment rom a → ∃ b, + target.ValidAssignment rom b ∧ target.conclusion b = source.conclusion a ∧ + target.requirements b = source.requirements a + +def Chip.Equivalent (source target : Chip F) : Prop := + source.Refines target ∧ target.Refines source + +theorem Chip.Equivalent.refl (chip : Chip F) : chip.Equivalent chip := + ⟨fun _ a valid => ⟨a, valid, rfl, rfl⟩, fun _ a valid => ⟨a, valid, rfl, rfl⟩⟩ + +theorem Chip.Refines.trans {first second third : Chip F} + (left : first.Refines second) (right : second.Refines third) : first.Refines third := by + intro rom a valid + obtain ⟨b, valid, root, calls⟩ := left rom a valid + obtain ⟨c, valid, root', calls'⟩ := right rom b valid + exact ⟨c, valid, root'.trans root, calls'.trans calls⟩ + +theorem Chip.Equivalent.trans {first second third : Chip F} + (left : first.Equivalent second) (right : second.Equivalent third) : first.Equivalent third := + ⟨left.1.trans right.1, right.2.trans left.2⟩ + +/-- Include guards, interfaces, and inactive lookup slots when finding unused columns. -/ +def Chip.expressions (chip : Chip F) : List (ArithExpr F) := + (chip.inputs.flatMap WireValue.words).map .var ++ chip.output.words ++ chip.constraints ++ + chip.sends.flatMap (fun send => send.enable :: + send.args.flatMap WireValue.words ++ send.result.words.map .var) ++ + chip.memory.flatMap (fun lookup => lookup.enable :: lookup.address :: lookup.value.words) + +def Chip.variables (chip : Chip F) : List Var := chip.expressions.flatMap Polynomial.vars + +theorem Chip.agree {chip : Chip F} {a b : Var → F} + (agree : ∀ id ∈ chip.variables, a id = b id) (rom : WireROM F) : + (chip.ValidAssignment rom a ↔ chip.ValidAssignment rom b) ∧ + chip.conclusion a = chip.conclusion b ∧ chip.requirements a = chip.requirements b := by + have expr (p : ArithExpr F) (member : p ∈ chip.expressions) : p.denote a = p.denote b := + Polynomial.denote_congr p (fun id present => agree id (List.mem_flatMap.mpr ⟨p, member, present⟩)) + have inputs (wire : WireValue Var) (member : wire ∈ chip.inputs) : wire.map a = wire.map b := by + apply WireValue.map_congr + intro id present + exact expr (.var id) (by + simp only [Chip.expressions, List.mem_append] + exact Or.inl (Or.inl (Or.inl (Or.inl + (List.mem_map.mpr ⟨id, List.mem_flatMap.mpr ⟨wire, member, present⟩, rfl⟩))))) + have output : chip.output.map (ArithExpr.denote a) = chip.output.map (ArithExpr.denote b) := by + apply WireValue.map_congr + intro p present + exact expr p (by simp [Chip.expressions, present]) + have constraints : Satisfies chip.constraints a ↔ Satisfies chip.constraints b := by + unfold Satisfies Scalar.Circuit.Satisfies + apply forall_congr' + intro p + apply forall_congr' + intro member + exact congrArg (· = 0) (expr p (by simp [Chip.expressions, member])) |>.to_iff + have sends (send : Send F) (member : send ∈ chip.sends) : + send.enable.denote a = send.enable.denote b ∧ send.message a = send.message b := by + have present (p : ArithExpr F) + (h : p ∈ send.enable :: send.args.flatMap WireValue.words ++ send.result.words.map .var) : + p ∈ chip.expressions := by + simp only [Chip.expressions, List.mem_append] + exact Or.inl (Or.inr (List.mem_flatMap.mpr ⟨send, member, h⟩)) + refine ⟨expr _ (present _ (by simp)), ?_⟩ + have args : send.args.map (WireValue.map (ArithExpr.denote a)) = + send.args.map (WireValue.map (ArithExpr.denote b)) := by + apply List.map_congr_left + intro wire mem + apply WireValue.map_congr + intro p h + exact expr p (present p (List.mem_append_left _ + (List.mem_cons_of_mem _ (List.mem_flatMap.mpr ⟨wire, mem, h⟩)))) + have result : send.result.map a = send.result.map b := by + apply WireValue.map_congr + intro id mem + exact expr (.var id) (present _ (by simp [mem])) + simp only [Send.message, args, result] + have memory (lookup : MemoryLookup F) (member : lookup ∈ chip.memory) : + lookup.Valid rom a ↔ lookup.Valid rom b := by + have present (p : ArithExpr F) (h : p ∈ lookup.enable :: lookup.address :: lookup.value.words) : + p ∈ chip.expressions := by + simp only [Chip.expressions, List.mem_append] + exact Or.inr (List.mem_flatMap.mpr ⟨lookup, member, h⟩) + have value : lookup.value.map (ArithExpr.denote a) = lookup.value.map (ArithExpr.denote b) := + WireValue.map_congr _ (fun p h => expr p (present p (by simp [h]))) + simp only [MemoryLookup.Valid, expr lookup.enable (present _ (by simp)), + expr lookup.address (present _ (by simp)), value] + refine ⟨and_congr constraints (forall_congr' fun lookup => forall_congr' (memory lookup)), ?_, ?_⟩ + · simp only [Chip.conclusion, List.map_congr_left inputs, output] + · apply List.filterMap_congr + intro send member + simp only [(sends send member).1, (sends send member).2] + +omit [Field F] [DecidableEq F] in +theorem Chip.wellFormed_variables {chip : Chip F} (formed : chip.wellFormed = true) : + ∀ id ∈ chip.variables, id < chip.numVars := by + have bounded (p : ArithExpr F) (h : p.inBounds chip.numVars = true) : + ∀ id ∈ Polynomial.vars p, id < chip.numVars := by + induction p with + | const value => simp [Polynomial.vars] + | var id => simpa [Polynomial.vars, ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using h + | add a b ha hb | sub a b ha hb | mul a b ha hb => + simp only [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds, Bool.and_eq_true] at h + intro id member + rcases List.mem_append.mp member with member | member + · exact ha h.1 id member + · exact hb h.2 id member + simp only [Chip.wellFormed, Bool.and_eq_true, List.all_eq_true, decide_eq_true_eq] at formed + obtain ⟨⟨⟨⟨inputs, output⟩, constraints⟩, sends⟩, memory⟩ := formed + intro id member + obtain ⟨p, member, occurs⟩ := List.mem_flatMap.mp member + apply bounded p ?_ id occurs + simp only [Chip.expressions, List.mem_append] at member + rcases member with (((member | member) | member) | member) | member + · obtain ⟨v, present, equal⟩ := List.mem_map.mp member + cases equal + exact decide_eq_true (inputs v present) + · exact output p member + · exact constraints p member + · obtain ⟨send, member, present⟩ := List.mem_flatMap.mp member + have h := sends send member + simp only [Send.inBounds, Bool.and_eq_true, List.all_eq_true, decide_eq_true_eq] at h + simp only [List.mem_cons, List.mem_append] at present + rcases present with (rfl | present) | present + · exact h.1.2 + · exact h.2 p present + · obtain ⟨v, leaf, equal⟩ := List.mem_map.mp present + cases equal + exact decide_eq_true (h.1.1 v leaf) + · obtain ⟨lookup, member, present⟩ := List.mem_flatMap.mp member + have h := memory lookup member + simp only [MemoryLookup.inBounds, Bool.and_eq_true, List.all_eq_true] at h + simp only [List.mem_cons] at present + rcases present with rfl | rfl | present + · exact h.1.2 + · exact h.1.1 + · exact h.2 p present + +theorem Chip.finiteAssignment {chip : Chip F} (formed : chip.wellFormed = true) + (a : Var → F) (rom : WireROM F) : + let row := Row.ofAssignment chip.name chip.numVars a + (chip.ValidAssignment rom a ↔ chip.ValidAssignment rom row.assignment) ∧ + chip.conclusion a = chip.receive row ∧ chip.requirements a = chip.premises row := by + apply chip.agree + intro id member + exact (Row.ofAssignment_agree _ _ _ id (chip.wellFormed_variables formed id member)).symm + +theorem Chip.Equivalent.localRule {source target : Chip F} (same : source.Equivalent target) + (sourceFormed : source.wellFormed = true) (targetFormed : target.wellFormed = true) + (rom : WireROM F) (root : Message F) (premises : List (Message F)) : + source.LocalRule rom root premises ↔ target.LocalRule rom root premises := by + have forward {source target : Chip F} (refines : source.Refines target) + (formed : target.wellFormed = true) : + source.LocalRule rom root premises → target.LocalRule rom root premises := by + rintro ⟨row, _, valid, rootEq, callsEq⟩ + obtain ⟨a, valid, root', calls'⟩ := refines rom row.assignment valid.2.2 + have finite := target.finiteAssignment formed a rom + exact ⟨Row.ofAssignment target.name target.numVars a, rfl, + ⟨formed, Row.ofAssignment_length _ _ _, finite.1.mp valid⟩, + finite.2.1.symm.trans (root'.trans rootEq), finite.2.2.symm.trans (calls'.trans callsEq)⟩ + exact ⟨forward same.1 targetFormed, forward same.2 sourceFormed⟩ + +end Aiur.Circuit diff --git a/Aiur/Aiur/Optimized/PolynomialFacts.lean b/Aiur/Aiur/Optimized/PolynomialFacts.lean new file mode 100644 index 000000000..bb1670787 --- /dev/null +++ b/Aiur/Aiur/Optimized/PolynomialFacts.lean @@ -0,0 +1,123 @@ +import Aiur.Optimized.Basic + +namespace Aiur.Optimized.Polynomial + +variable {F : Type} + +theorem beq_eq [BEq F] [LawfulBEq F] (left right : Polynomial F) : + (left == right) = true ↔ left = right := by + induction left generalizing right <;> cases right <;> + simp_all [BEq.beq, Scalar.Circuit.instBEqArithExpr.beq] + +variable [Field F] [DecidableEq F] + +omit [DecidableEq F] in +@[simp] theorem denote_subst (expr : Polynomial F) (replacement : Witness → Polynomial F) + (assignment : Witness → F) : + (expr.subst replacement).denote assignment = + expr.denote (fun id => (replacement id).denote assignment) := by + induction expr <;> simp_all [subst, Scalar.Circuit.ArithExpr.denote] + +omit [DecidableEq F] in +theorem denote_congr (expr : Polynomial F) {left right : Witness → F} + (agree : ∀ id ∈ expr.vars, left id = right id) : expr.denote left = expr.denote right := by + induction expr <;> simp_all [vars, Scalar.Circuit.ArithExpr.denote] + +@[simp] theorem denote_simplify (expr : Polynomial F) (assignment : Witness → F) : + expr.simplify.denote assignment = expr.denote assignment := by + change Scalar.Circuit.ArithExpr.denote assignment expr.simplify = + Scalar.Circuit.ArithExpr.denote assignment expr + induction expr with + | const value => rfl + | var id => rfl + | add a b ha hb => + simp only [simplify, Scalar.Circuit.ArithExpr.denote] + rw [← ha, ← hb] + cases simplify a <;> cases simplify b <;> + simp [Scalar.Circuit.ArithExpr.denote] <;> split <;> + simp_all [Scalar.Circuit.ArithExpr.denote] + | sub a b ha hb => + simp only [simplify, Scalar.Circuit.ArithExpr.denote] + rw [← ha, ← hb] + split + · rename_i same + have same := (beq_eq _ _).mp same + simp [Scalar.Circuit.ArithExpr.denote, same] + · cases simplify a <;> cases simplify b <;> + simp [Scalar.Circuit.ArithExpr.denote] <;> split <;> + simp_all [Scalar.Circuit.ArithExpr.denote] + | mul a b ha hb => + simp only [simplify, Scalar.Circuit.ArithExpr.denote] + rw [← ha, ← hb] + cases simplify a <;> cases simplify b <;> + simp [Scalar.Circuit.ArithExpr.denote] <;> split <;> + (try simp_all [Scalar.Circuit.ArithExpr.denote]) <;> split <;> + simp_all [Scalar.Circuit.ArithExpr.denote] + +omit [DecidableEq F] in +/-- Naming a total polynomial is an existential conservative extension. The +guard permits an arbitrary witness in an inactive scope. -/ +theorem materialize_iff (enable value : F) (property : F → Prop) : + (∃ witness, enable * (witness - value) = 0 ∧ (enable ≠ 0 → property witness)) ↔ + (enable ≠ 0 → property value) := by + constructor + · rintro ⟨witness, equation, required⟩ active + have equal : witness = value := sub_eq_zero.mp ((mul_eq_zero.mp equation).resolve_left active) + simpa only [equal] using required active + · intro required + exact ⟨value, by simp, required⟩ + +omit [DecidableEq F] in +/-- Inverse witnesses stay guarded: no obligation is imposed by an inactive +division, even if its denominator is zero. -/ +theorem inverse_iff (enable denominator : F) : + (∃ inverse, enable * (denominator * inverse - 1) = 0) ↔ + (enable = 0 ∨ denominator ≠ 0) := by + constructor + · rintro ⟨inverse, valid⟩ + rcases mul_eq_zero.mp valid with inactive | equation + · exact Or.inl inactive + · right + intro zero + simp [zero] at equation + · rintro (inactive | nonzero) + · exact ⟨0, by simp [inactive]⟩ + · exact ⟨denominator⁻¹, by simp [nonzero]⟩ + +omit [DecidableEq F] in +/-- A nonrecursive selector definition has an extension for every assignment +to the remaining columns. Substitution evaluates in precisely that extension. -/ +theorem alias_extension (definition expr : Polynomial F) (id : Witness) + (nonrecursive : id ∉ definition.vars) (assignment : Witness → F) : + let extended := Function.update assignment id (definition.denote assignment) + extended id = definition.denote extended ∧ + (expr.subst (fun other => if other = id then definition else .var other)).denote assignment = + expr.denote extended := by + dsimp only + have unchanged : definition.denote assignment = + definition.denote (Function.update assignment id (definition.denote assignment)) := by + apply denote_congr + intro other member + have different : other ≠ id := by rintro rfl; exact nonrecursive member + simp [Function.update_of_ne different] + constructor + · simpa only [Function.update_self] using unchanged + · rw [denote_subst] + congr 1 + funext other + by_cases same : other = id <;> + simp [same, Function.update, Scalar.Circuit.ArithExpr.denote] + +omit [DecidableEq F] in +/-- Projection needs the defining equation. Dropping an unconstrained selector +and substituting an arbitrary expression would not justify this equality. -/ +theorem alias_projection (definition expr : Polynomial F) (id : Witness) (assignment : Witness → F) + (defined : assignment id = definition.denote assignment) : + (expr.subst (fun other => if other = id then definition else .var other)).denote assignment = + expr.denote assignment := by + rw [denote_subst] + apply denote_congr + intro other _ + by_cases same : other = id <;> simp [same, defined, Scalar.Circuit.ArithExpr.denote] + +end Aiur.Optimized.Polynomial diff --git a/Aiur/Aiur/Optimized/PolynomialIdentity.lean b/Aiur/Aiur/Optimized/PolynomialIdentity.lean new file mode 100644 index 000000000..83badd40d --- /dev/null +++ b/Aiur/Aiur/Optimized/PolynomialIdentity.lean @@ -0,0 +1,24 @@ +import Aiur.Optimized.PolynomialFacts + +namespace Aiur.Optimized.Polynomial + +variable {F : Type} [Field F] [DecidableEq F] + +/-- A deliberately conservative, executable polynomial identity check. The +optimizer preserves expression order, so ring expansion is unnecessary. -/ +def normalForm (expr : Polynomial F) : Polynomial F := expr.simplify + +@[simp] theorem eval_normalForm (expr : Polynomial F) (assignment : Witness → F) : + expr.normalForm.denote assignment = expr.denote assignment := denote_simplify expr assignment + +def Identical (left right : Polynomial F) : Prop := left.normalForm = right.normalForm + +instance (left right : Polynomial F) : Decidable (Identical left right) := by + unfold Identical + infer_instance + +theorem Identical.denote {left right : Polynomial F} (same : Identical left right) + (assignment : Witness → F) : left.denote assignment = right.denote assignment := by + simpa only [eval_normalForm] using congrArg (Circuit.ArithExpr.denote assignment) same + +end Aiur.Optimized.Polynomial diff --git a/Aiur/Aiur/Optimized/PrimitiveCorrectness.lean b/Aiur/Aiur/Optimized/PrimitiveCorrectness.lean new file mode 100644 index 000000000..ab3144c4e --- /dev/null +++ b/Aiur/Aiur/Optimized/PrimitiveCorrectness.lean @@ -0,0 +1,121 @@ +import Aiur.Optimized.StateSemantics +import Aiur.Optimized.PatternCorrectness + +namespace Aiur.Optimized.Compiler + +variable {F : Type} [Field F] [DecidableEq F] +set_option maxRecDepth 4096 +set_option maxHeartbeats 1000000 + +theorem equations_sound {scope : ScopeId} {conditions : List (Polynomial F)} {before after : State F} + (compiled : (do for condition in conditions do equation scope condition : Build F Unit) before = .ok ((), after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {assignment : Witness → F} + (valid : after.Valid rom calls assignment) : before.Valid rom calls assignment ∧ + ∀ condition ∈ conditions, (before.activation scope).denote assignment * condition.denote assignment = 0 := by + induction conditions generalizing before with + | nil => + have same : before = after := by + simpa [List.forIn_nil, pure, StateT.pure, StateT.bind, bind, Except.bind, Except.pure] using compiled + exact ⟨same ▸ valid, by simp⟩ + | cons condition conditions ih => + simp [List.forIn_cons, equation, modify, modifyGet, MonadStateOf.modifyGet, StateT.modifyGet, + StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at compiled + obtain ⟨previous, tail⟩ := ih compiled + obtain ⟨previousValid, head⟩ := equation_valid (scope := scope) (polynomial := condition) rfl previous + exact ⟨previousValid, fun polynomial member => by + rcases List.mem_cons.mp member with rfl | member + · exact head + · exact tail polynomial member⟩ + +theorem equalValue_sound {scope : ScopeId} {left right : Symbolic F} {before after : State F} + (compiled : equalValue scope left right before = .ok ((), after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {assignment : Witness → F} + (valid : after.Valid rom calls assignment) : before.Valid rom calls assignment ∧ + ((before.activation scope).denote assignment = 1 → + left.map (Circuit.ArithExpr.denote assignment) = right.map (Circuit.ArithExpr.denote assignment)) := by + simp only [equalValue] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · rename_i shaped + obtain ⟨types, widths⟩ := not_or.mp shaped + have types := not_ne_iff.mp types + have widths := not_ne_iff.mp widths + obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + have equations : (do + for polynomial in (left.words.zip right.words).map (fun (a, b) => Polynomial.sub a b) do + equation scope polynomial : Build F Unit) before = .ok ((), after) := by + simpa only [List.forIn_map] using rest + obtain ⟨previous, equal⟩ := equations_sound equations valid + refine ⟨previous, fun active => ?_⟩ + have words : left.words.map (Circuit.ArithExpr.denote assignment) = + right.words.map (Circuit.ArithExpr.denote assignment) := by + apply List.ext_getElem + · simp [widths] + · intro i leftBound rightBound + have leftIn : i < left.words.length := by simpa using leftBound + have rightIn : i < right.words.length := by simpa using rightBound + have member : (left.words[i], right.words[i]) ∈ left.words.zip right.words := + List.mem_iff_getElem.mpr ⟨i, by simp [leftIn, rightIn], List.getElem_zip⟩ + have equation := equal _ (List.mem_map.mpr ⟨_, member, rfl⟩) + simpa only [active, Scalar.Circuit.ArithExpr.denote, one_mul, sub_eq_zero, List.getElem_map] using equation + cases left; cases right + simp_all [WireValue.map] + +private theorem failure_terms_sound {scope : ScopeId} {conditions terms : List (Polynomial F)} + {before after : State F} + (compiled : (conditions.mapM fun difference => do + return Polynomial.mul difference (.var (← fresh (.auxiliary scope))) : Build F (List (Polynomial F))) + before = .ok (terms, after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {assignment : Witness → F} + (valid : after.Valid rom calls assignment) : before.Valid rom calls assignment ∧ + after.scopes = before.scopes ∧ (AllZero conditions assignment → AllZero terms assignment) := by + induction conditions generalizing terms before with + | nil => + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [List.mapM_nil] using compiled) + exact ⟨valid, rfl, fun _ => by simp [AllZero]⟩ + | cons difference conditions ih => + simp only [List.mapM_cons] at compiled + obtain ⟨term, s₁, headRun, tailBind⟩ := bind_ok.mp compiled + obtain ⟨tail, s₂, tailRun, finished⟩ := bind_ok.mp tailBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨middleValid, tailScopes, tailZero⟩ := ih tailRun + obtain ⟨id, s₃, freshRun, finished⟩ := bind_ok.mp headRun + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + have scopes : s₃.scopes = before.scopes := by + simpa only using congrArg (fun state : State F => state.scopes) (fresh_eq freshRun).2 + refine ⟨fresh_valid freshRun middleValid, tailScopes.trans scopes, fun zero term member => ?_⟩ + rcases List.mem_cons.mp member with rfl | member + · change difference.denote assignment * assignment id = 0 + rw [zero _ (List.mem_cons_self ..), zero_mul] + · exact tailZero (fun p hp => zero p (List.mem_cons_of_mem _ hp)) term member + +private theorem fold_add_zero {conditions : List (Polynomial F)} {assignment : Witness → F} + (zero : AllZero conditions assignment) (start : Polynomial F) : + (conditions.foldl Polynomial.add start).denote assignment = start.denote assignment := by + induction conditions generalizing start with + | nil => rfl + | cons condition conditions ih => + rw [List.foldl_cons, ih (fun p hp => zero p (List.mem_cons_of_mem _ hp))] + change start.denote assignment + condition.denote assignment = start.denote assignment + rw [zero _ (List.mem_cons_self ..), add_zero] + +/-- An active failure block cannot accept a matching earlier pattern. This +theorem refers to the actual emitted equation and allocated coefficients. -/ +theorem failure_sound {scope : ScopeId} {conditions : List (Polynomial F)} {before after : State F} + (compiled : failure scope conditions before = .ok ((), after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {assignment : Witness → F} + (valid : after.Valid rom calls assignment) : before.Valid rom calls assignment ∧ + ((before.activation scope).denote assignment = 1 → ¬ AllZero conditions assignment) := by + simp only [failure] at compiled + obtain ⟨terms, middle, termsRun, equationRun⟩ := bind_ok.mp compiled + obtain ⟨middleValid, equation⟩ := equation_valid equationRun valid + obtain ⟨beforeValid, scopes, termsZero⟩ := failure_terms_sound termsRun middleValid + refine ⟨beforeValid, fun active zero => ?_⟩ + have activation : middle.activation scope = before.activation scope := by simp only [State.activation, scopes] + rw [activation, active] at equation + change 1 * ((terms.foldl Polynomial.add (.const 0)).denote assignment - 1) = 0 at equation + rw [fold_add_zero (termsZero zero)] at equation + exact one_ne_zero (by simpa only [Scalar.Circuit.ArithExpr.denote, zero_sub, one_mul, neg_eq_zero] using equation) + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/PrimitiveWitness.lean b/Aiur/Aiur/Optimized/PrimitiveWitness.lean new file mode 100644 index 000000000..dae58ab74 --- /dev/null +++ b/Aiur/Aiur/Optimized/PrimitiveWitness.lean @@ -0,0 +1,329 @@ +import Aiur.Optimized.ReferenceState +import Aiur.Optimized.BranchFacts +import Aiur.Circuit.EncodingWitness + +namespace Aiur.Optimized.Compiler + +variable {F : Type} [Field F] [DecidableEq F] + +set_option maxHeartbeats 1000000 +set_option maxRecDepth 4096 + +theorem equations_scopes {scope : ScopeId} {conditions : List (Polynomial F)} {before after : State F} + (compiled : (do for condition in conditions do equation scope condition : Build F Unit) + before = .ok ((), after)) : after.scopes = before.scopes := by + induction conditions generalizing before with + | nil => + have same : before = after := by + simpa [List.forIn_nil, pure, StateT.pure, StateT.bind, bind, Except.bind, Except.pure] using compiled + exact congrArg State.scopes same.symm + | cons condition conditions ih => + simp [List.forIn_cons, equation, modify, modifyGet, MonadStateOf.modifyGet, StateT.modifyGet, + StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at compiled + exact ih (before := {before with equations := before.equations.push ⟨scope, condition⟩}) compiled + +theorem equations_complete {scope : ScopeId} {conditions : List (Polynomial F)} {before after : State F} + (compiled : (do for condition in conditions do equation scope condition : Build F Unit) + before = .ok ((), after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {assignment : Witness → F} + (layout : before.toReference.WellFormed) (valid : before.Valid rom calls assignment) + (scopeBound : (before.activation scope).inBounds before.roles.size = true) + (bounded : ∀ condition ∈ conditions, condition.inBounds before.roles.size = true) + (zero : (before.activation scope).denote assignment = 0 ∨ + ∀ condition ∈ conditions, condition.denote assignment = 0) : + Extension rom calls before after assignment assignment := by + induction conditions generalizing before with + | nil => + have same : before = after := by + simpa [List.forIn_nil, pure, StateT.pure, StateT.bind, bind, Except.bind, Except.pure] using compiled + subst after + exact .refl layout ((before.valid_iff_reference rom calls assignment).mp valid) + | cons condition conditions ih => + simp [List.forIn_cons, equation, modify, modifyGet, MonadStateOf.modifyGet, StateT.modifyGet, + StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at compiled + have step := equation_complete (scope := scope) (polynomial := condition) (before := before) rfl + layout valid (by simp [Scalar.Circuit.ArithExpr.inBounds, scopeBound, bounded condition (by simp)]) (by + rcases zero with inactive | zeros + · simp [inactive] + · simp [zeros condition (by simp)]) + exact step.trans (ih (before := {before with equations := before.equations.push ⟨scope, condition⟩}) + compiled step.layout step.validAssignment scopeBound + (fun p member => bounded p (by simp [member])) + (zero.imp_right (fun zeros p member => zeros p (by simp [member])))) + +theorem equalValue_complete {scope : ScopeId} {left right : Symbolic F} {before after : State F} + (compiled : equalValue scope left right before = .ok ((), after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {assignment : Witness → F} + (layout : before.toReference.WellFormed) (valid : before.Valid rom calls assignment) + (scopeBound : (before.activation scope).inBounds before.roles.size = true) + (leftBound : Circuit.Compiler.Bounded before.roles.size left) + (rightBound : Circuit.Compiler.Bounded before.roles.size right) + (equal : (before.activation scope).denote assignment = 0 ∨ + left.map (Circuit.ArithExpr.denote assignment) = right.map (Circuit.ArithExpr.denote assignment)) : + Extension rom calls before after assignment assignment := by + simp only [equalValue] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + have equations : (do + for polynomial in (left.words.zip right.words).map (fun (a, b) => Polynomial.sub a b) do + equation scope polynomial : Build F Unit) before = .ok ((), after) := by + simpa only [List.forIn_map] using rest + apply equations_complete equations layout valid scopeBound + · intro polynomial member + obtain ⟨⟨a, b⟩, pairMember, rfl⟩ := List.mem_map.mp member + have members := List.of_mem_zip pairMember + simp [Scalar.Circuit.ArithExpr.inBounds, leftBound _ members.1, rightBound _ members.2] + · rcases equal with inactive | equal + · exact Or.inl inactive + · right + intro polynomial member + obtain ⟨⟨a, b⟩, pairMember, rfl⟩ := List.mem_map.mp member + have wordsEq := congrArg WireValue.words equal + have mapped : (a.denote assignment, b.denote assignment) ∈ + (left.words.map (Circuit.ArithExpr.denote assignment)).zip + (right.words.map (Circuit.ArithExpr.denote assignment)) := by + rw [List.zip_map] + exact List.mem_map.mpr ⟨(a, b), pairMember, rfl⟩ + change left.words.map (Circuit.ArithExpr.denote assignment) = + right.words.map (Circuit.ArithExpr.denote assignment) at wordsEq + rw [wordsEq, List.zip_eq_zipWith, List.zipWith_self] at mapped + obtain ⟨word, _, pairEq⟩ := List.mem_map.mp mapped + have pair := Prod.mk.inj pairEq + change a.denote assignment - b.denote assignment = 0 + exact sub_eq_zero.mpr (pair.1.symm.trans pair.2) + +theorem freshValue_decoded_complete {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) (tags : decls.tagsValid F = true) + {role : Role} {type : Ty} {vars : WireValue Witness} {before after : State F} + (compiled : freshValue decls role type before = .ok (vars, after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (valid : before.Valid rom calls initial) + (value : Value F) (shape : value.type = type) (formed : value.wellFormed decls = true) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + Circuit.Compiler.Bounded (F := F) after.roles.size (vars.map Polynomial.var) ∧ + (vars.map assignment).decode decls = some value := + Circuit.Compiler.freshValue_decoded_complete checked tags (freshValue_reference compiled) layout + ((before.valid_iff_reference rom calls initial).mp valid) value shape formed + +theorem freshValue_zero_complete {decls : Declarations} {role : Role} {type : Ty} + {vars : WireValue Witness} {before after : State F} + (compiled : freshValue decls role type before = .ok (vars, after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (valid : before.Valid rom calls initial) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + Circuit.Compiler.Bounded (F := F) after.roles.size (vars.map Polynomial.var) := + Circuit.Compiler.freshValue_zero_complete (freshValue_reference compiled) layout + ((before.valid_iff_reference rom calls initial).mp valid) + +theorem destination_complete {decls : Declarations} {scope : ScopeId} {type : Ty} + {target : Option (WireValue Witness)} {vars : WireValue Witness} {before after : State F} + (compiled : destination decls scope type target before = .ok (vars, after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (valid : before.Valid rom calls initial) + (value : WireValue F) (shape : value.type = type) (sized : value.Sized decls) + (targetBound : ∀ candidate, target = some candidate → + Circuit.Compiler.Bounded (F := F) before.roles.size (candidate.map Polynomial.var)) + (targetValue : ∀ candidate, target = some candidate → candidate.map initial = value) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + Circuit.Compiler.Bounded (F := F) after.roles.size (vars.map Polynomial.var) ∧ vars.map assignment = value := by + cases target with + | none => + exact freshValue_complete (by simpa [destination] using compiled) layout valid value shape sized + | some candidate => + simp only [destination] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · obtain ⟨⟨⟩, middle, unchanged, finished⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + exact ⟨initial, .refl layout ((before.valid_iff_reference rom calls initial).mp valid), + targetBound _ rfl, targetValue _ rfl⟩ + +theorem destination_inactive {decls : Declarations} {scope : ScopeId} {type : Ty} + {target : Option (WireValue Witness)} {vars : WireValue Witness} {before after : State F} + (compiled : destination decls scope type target before = .ok (vars, after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (valid : before.Valid rom calls initial) + (targetBound : ∀ candidate, target = some candidate → + Circuit.Compiler.Bounded (F := F) before.roles.size (candidate.map Polynomial.var)) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + Circuit.Compiler.Bounded (F := F) after.roles.size (vars.map Polynomial.var) := by + cases target with + | none => + exact freshValue_zero_complete (by simpa [destination] using compiled) layout valid + | some candidate => + simp only [destination] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · obtain ⟨⟨⟩, middle, unchanged, finished⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + exact ⟨initial, .refl layout ((before.valid_iff_reference rom calls initial).mp valid), targetBound _ rfl⟩ + +theorem destination_decoded_complete {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) (tags : decls.tagsValid F = true) + {scope : ScopeId} {type : Ty} {target : Option (WireValue Witness)} + {vars : WireValue Witness} {before after : State F} + (compiled : destination decls scope type target before = .ok (vars, after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (valid : before.Valid rom calls initial) + (value : Value F) (shape : value.type = type) (formed : value.wellFormed decls = true) + (targetBound : ∀ candidate, target = some candidate → + Circuit.Compiler.Bounded (F := F) before.roles.size (candidate.map Polynomial.var)) + (targetDecode : ∀ candidate, target = some candidate → (candidate.map initial).decode decls = some value) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + Circuit.Compiler.Bounded (F := F) after.roles.size (vars.map Polynomial.var) ∧ + (vars.map assignment).decode decls = some value := by + cases target with + | none => + exact freshValue_decoded_complete checked tags (by simpa [destination] using compiled) + layout valid value shape formed + | some candidate => + simp only [destination] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · obtain ⟨⟨⟩, middle, unchanged, finished⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + exact ⟨initial, .refl layout ((before.valid_iff_reference rom calls initial).mp valid), + targetBound _ rfl, targetDecode _ rfl⟩ + +private theorem failure_terms_complete {scope : ScopeId} {conditions terms : List (Polynomial F)} + {before after : State F} + (compiled : (conditions.mapM fun difference => do + return Polynomial.mul difference (.var (← fresh (.auxiliary scope))) : Build F (List (Polynomial F))) + before = .ok (terms, after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (valid : before.Valid rom calls initial) + (bounded : ∀ condition ∈ conditions, condition.inBounds before.roles.size = true) + (coefficients : List F) (sized : coefficients.length = conditions.length) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + after.scopes = before.scopes ∧ + (∀ term ∈ terms, term.inBounds after.roles.size = true) ∧ + terms.map (Circuit.ArithExpr.denote assignment) = + List.zipWith (· * ·) (conditions.map (Circuit.ArithExpr.denote initial)) coefficients := by + induction conditions generalizing terms before initial coefficients with + | nil => + cases coefficients with + | cons => simp at sized + | nil => + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [List.mapM_nil] using compiled) + exact ⟨initial, .refl layout ((before.valid_iff_reference rom calls initial).mp valid), + rfl, by simp, rfl⟩ + | cons difference conditions ih => + cases coefficients with + | nil => simp at sized + | cons coefficient coefficients => + simp only [List.mapM_cons] at compiled + obtain ⟨term, middle, headRun, restBind⟩ := bind_ok.mp compiled + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp restBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨id, afterFresh, freshRun, headFinished⟩ := bind_ok.mp headRun + obtain ⟨rfl, rfl⟩ := pure_ok.mp headFinished + obtain ⟨a, freshExt, idBound, assigned⟩ := fresh_complete freshRun layout valid coefficient + have scopes : afterFresh.scopes = before.scopes := by + simpa only using congrArg (fun state : State F => state.scopes) (fresh_eq freshRun).2 + obtain ⟨b, tailExt, tailScopes, tailBound, tailValues⟩ := ih tailRun freshExt.layout + freshExt.validAssignment (fun p member => freshExt.bound (bounded p (by simp [member]))) + coefficients (by simpa using sized) + have differenceBound := bounded difference (by simp) + have varBound : (Polynomial.var id : Polynomial F).inBounds afterFresh.roles.size = true := by + simpa [Scalar.Circuit.ArithExpr.inBounds] using idBound + refine ⟨b, freshExt.trans tailExt, tailScopes.trans scopes, ?_, ?_⟩ + · intro p member + rcases List.mem_cons.mp member with rfl | member + · simpa [Scalar.Circuit.ArithExpr.inBounds, State.toReference] using + And.intro ((freshExt.trans tailExt).bound differenceBound) (tailExt.bound varBound) + · exact tailBound p member + · have tailInputs : conditions.map (Circuit.ArithExpr.denote a) = + conditions.map (Circuit.ArithExpr.denote initial) := + List.map_congr_left (fun p member => freshExt.polynomial (bounded p (by simp [member]))) + have varValue : b id = coefficient := (tailExt.agree id idBound).trans assigned + simp only [List.map_cons, List.zipWith_cons_cons, Scalar.Circuit.ArithExpr.denote, + (freshExt.trans tailExt).polynomial differenceBound, varValue, tailValues, tailInputs] + +private theorem sum_zipWith_eq_combination (left right : List F) : + (List.zipWith (· * ·) left right).sum = combination left right := by + induction left generalizing right with + | nil => simp [combination] + | cons head tail ih => + cases right <;> simp [combination, ih] + +/-- A failed earlier pattern has a finite list of inverse coefficients. The +construction allocates exactly the witnesses used by the executable compiler. -/ +theorem failure_complete {scope : ScopeId} {conditions : List (Polynomial F)} {before after : State F} + (compiled : failure scope conditions before = .ok ((), after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (valid : before.Valid rom calls initial) + (scopeBound : (before.activation scope).inBounds before.roles.size = true) + (bounded : ∀ condition ∈ conditions, condition.inBounds before.roles.size = true) + (failed : (before.activation scope).denote initial = 0 ∨ + ¬ ∀ condition ∈ conditions, condition.denote initial = 0) : + ∃ assignment, Extension rom calls before after initial assignment := by + simp only [failure] at compiled + obtain ⟨terms, middle, termsRun, equationRun⟩ := bind_ok.mp compiled + have failure : (before.activation scope).denote initial = 0 ∨ + ¬ ∀ value ∈ conditions.map (Circuit.ArithExpr.denote initial), value = 0 := by + simpa only [List.forall_mem_map] using failed + obtain ⟨coefficients, sized, certificate⟩ := + (guarded_failure_iff ((before.activation scope).denote initial) + (conditions.map (Circuit.ArithExpr.denote initial))).mpr failure + obtain ⟨a, ext, scopes, termsBound, termsValue⟩ := failure_terms_complete termsRun layout valid + bounded coefficients (by simpa using sized) + have activation : middle.activation scope = before.activation scope := by simp [State.activation, scopes] + have sumBound : (terms.foldl Polynomial.add (.const (0 : F))).inBounds middle.roles.size = true := + Scalar.Circuit.Compiler.foldl_add_inBounds rfl termsBound + have finalExt := equation_complete equationRun ext.layout ext.validAssignment (by + simp only [Scalar.Circuit.ArithExpr.inBounds, Bool.and_eq_true, and_true] + exact ⟨activation ▸ ext.bound scopeBound, sumBound⟩) (by + rw [activation, ext.polynomial scopeBound] + change (before.activation scope).denote initial * + ((terms.foldl Polynomial.add (.const (0 : F))).denote a - 1) = 0 + rw [Scalar.Circuit.ArithExpr.denote_foldl_add, termsValue] + simpa only [Scalar.Circuit.ArithExpr.denote, zero_add, sum_zipWith_eq_combination] using certificate) + exact ⟨a, ext.trans finalExt⟩ + +theorem cell_complete {cell : Cell F} {before after : State F} + (compiled : (modify (fun state => {state with cells := state.cells.push cell}) : Build F Unit) + before = .ok ((), after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {assignment : Witness → F} + (layout : before.toReference.WellFormed) (valid : before.Valid rom calls assignment) + (scopeBound : (before.activation cell.scope).inBounds before.roles.size = true) + (addressBound : cell.address.inBounds before.roles.size = true) + (valueBound : Circuit.Compiler.Bounded before.roles.size cell.value) + (member : (before.activation cell.scope).denote assignment = 1 → + (cell.address.denote assignment, cell.value.map (Circuit.ArithExpr.denote assignment)) ∈ rom.entries) : + Extension rom calls before after assignment assignment := by + change Except.ok ((), {before with cells := before.cells.push cell}) = Except.ok ((), after) at compiled + have stateEq := congrArg Prod.snd (Except.ok.inj compiled) + dsimp only at stateEq + subst after + apply Circuit.Compiler.requireCell_complete (enable := before.activation cell.scope) + (address := cell.address) (value := cell.value) _ layout + ((before.valid_iff_reference rom calls assignment).mp valid) scopeBound addressBound valueBound member + simp [Circuit.Compiler.requireCell_apply, State.toReference, State.activation] + +theorem call_complete {call : Call F} {before after : State F} + (compiled : (modify (fun state => {state with calls := state.calls.push call}) : Build F Unit) + before = .ok ((), after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {assignment : Witness → F} + (layout : before.toReference.WellFormed) (valid : before.Valid rom calls assignment) + (scopeBound : (before.activation call.scope).inBounds before.roles.size = true) + (argsBound : ∀ arg ∈ call.args, Circuit.Compiler.Bounded before.roles.size arg) + (resultBound : Circuit.Compiler.Bounded (F := F) before.roles.size (call.result.map Polynomial.var)) + (member : (before.activation call.scope).denote assignment = 1 → + calls call.channel (call.message assignment).args (call.message assignment).result) : + Extension rom calls before after assignment assignment := by + change Except.ok ((), {before with calls := before.calls.push call}) = Except.ok ((), after) at compiled + have stateEq := congrArg Prod.snd (Except.ok.inj compiled) + dsimp only at stateEq + subst after + have reference := Circuit.Compiler.send_complete layout + ((before.valid_iff_reference rom calls assignment).mp valid) + ⟨call.channel, call.args, call.result, before.activation call.scope⟩ + (Circuit.Compiler.send_bounded argsBound resultBound scopeBound) member + simpa only [Extension, State.toReference, State.activation, Array.map_push] using reference + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/Program.lean b/Aiur/Aiur/Optimized/Program.lean new file mode 100644 index 000000000..57f63a345 --- /dev/null +++ b/Aiur/Aiur/Optimized/Program.lean @@ -0,0 +1,111 @@ +import Aiur.Optimized.Compile +import Aiur.Optimized.CheckedLayout +import Aiur.Optimized.Dedup +import Aiur.Modules.Correctness + +namespace Aiur.Optimized + +/-- Alternative compiler artifact with certified layout, degree bounds, and +deduplication. `Equivalence` and `NativeCorrectness` connect successful compilation +to both integer checkers and the original source evaluation predicate. -/ +structure Artifact (F : Type) [Field F] [DecidableEq F] where + config : Config + entries : List String + layouts : List (LaidOutChip F) + system : Circuit.System F + representatives : List (String × String) + unmerged : Circuit.System F + deduplication : Dedup.Certificate unmerged system representatives entries + degreeBound : ∀ chip ∈ system.chips, + chip.stats.maxConstraintDegree ≤ config.maxDegree ∧ chip.stats.maxLookupDegree ≤ 2 ∧ chip.maxLookupGuardDegree ≤ 1 + +def compile [Field F] [DecidableEq F] (program : Program F) (entries : List String) + (config : Config := {}) : Except String (Artifact F) := do + if config.maxDegree < 3 then throw "the optimized compiler requires a degree cap of at least three" + let _ ← (typecheck program).mapError reprStr + for entry in entries do + if (program.findFunction? entry).isNone then throw s!"unknown entrypoint {entry}" + let _ ← (checkEntry program entry).mapError reprStr + for declaration in program.enums do + let _ ← (Circuit.checkEnumTags F declaration).mapError reprStr + let layouts ← program.functions.mapM fun fn => do + layOut config (← Compiler.function program config fn (entries.contains fn.name)) + let initial : Circuit.System F := ⟨layouts.map (·.chip), program.enums, program.tables, program.maps⟩ + let deduplicate : Except String (Dedup.CheckedResult initial entries) := if config.deduplicate then Dedup.run initial entries + else Dedup.certify initial entries (Dedup.identity initial) + let result ← deduplicate + let _ ← (Circuit.checkChips [] result.system.chips).mapError reprStr + if h : result.system.chips.all (fun chip => decide + (chip.stats.maxConstraintDegree ≤ config.maxDegree ∧ chip.stats.maxLookupDegree ≤ 2 ∧ chip.maxLookupGuardDegree ≤ 1)) = true then + return { + config, entries, layouts, system := result.system, representatives := result.representatives + unmerged := initial + deduplication := result.certificate + degreeBound := by + intro chip member + exact of_decide_eq_true (List.all_eq_true.mp h chip member) + } + else throw "optimized degree bound failed" + +def Artifact.check [Field F] [DecidableEq F] (compiled : Artifact F) (rom : WireROM F) + (root : Circuit.Message F) (rows : List (Circuit.Row F)) : Except String Unit := do + unless compiled.entries.contains root.channel do throw s!"unselected entrypoint {root.channel}" + (compiled.system.check rom root rows).mapError reprStr + +def Artifact.checkMemo [Field F] [DecidableEq F] (compiled : Artifact F) (rom : WireROM F) + (root : Circuit.Message F) (rows : List (Circuit.WeightedRow F)) : Except String Unit := do + unless compiled.entries.contains root.channel do throw s!"unselected entrypoint {root.channel}" + (compiled.system.checkMemo rom root rows).mapError reprStr + +variable {F : Type} [Field F] [DecidableEq F] + {source : Generic.Source F} {entries : List String} + +structure GenericArtifact (prepared : Generic.Specialized source entries) where + inlined : Inlining.Prepared prepared.program prepared.inlineNames entries + artifact : Artifact F + config : Config + compiled : compile inlined.program entries config = .ok artifact + +def GenericArtifact.system {prepared : Generic.Specialized source entries} + (compiled : GenericArtifact prepared) : Circuit.System F := compiled.artifact.system + +structure ModulesArtifact (prepared : Modules.Prepared (program : Modules.Program F)) where + specialized : Generic.Specialized prepared.environment.source prepared.entries + circuit : GenericArtifact specialized + +def ModulesArtifact.check {program : Modules.Program F} {prepared : Modules.Prepared program} + (compiled : ModulesArtifact prepared) (rom : WireROM F) (name : String) + (args : List (WireValue F)) (result : WireValue F) (rows : List (Circuit.Row F)) : Except String Unit := do + let some entry := prepared.find? name | throw s!"unselected entrypoint '{name}'" + compiled.circuit.artifact.check rom ⟨entry.resolved.name, args, result⟩ rows + +def ModulesArtifact.checkMemo {program : Modules.Program F} {prepared : Modules.Prepared program} + (compiled : ModulesArtifact prepared) (rom : WireROM F) (name : String) + (args : List (WireValue F)) (result : WireValue F) (rows : List (Circuit.WeightedRow F)) : Except String Unit := do + let some entry := prepared.find? name | throw s!"unselected entrypoint '{name}'" + compiled.circuit.artifact.checkMemo rom ⟨entry.resolved.name, args, result⟩ rows + +end Aiur.Optimized + +namespace Aiur.Generic + +def Specialized.compileOptimized {F : Type} [Field F] [DecidableEq F] + {source : Source F} {entries : List String} + (prepared : Specialized source entries) (config : Optimized.Config := {}) : + Except String (Optimized.GenericArtifact prepared) := do + let inlined ← Inlining.prepare prepared.program prepared.inlineNames entries + match compiled : Optimized.compile inlined.program entries config with + | .error error => throw error + | .ok artifact => return ⟨inlined, artifact, config, compiled⟩ + +end Aiur.Generic + +namespace Aiur.Modules + +def Prepared.compileOptimized {F : Type} [Field F] [DecidableEq F] {program : Program F} + (prepared : Prepared program) (config : Optimized.Config := {}) : + Except String (Optimized.ModulesArtifact prepared) := do + let specialized ← Generic.specialize prepared.environment.source prepared.entries + return ⟨specialized, ← specialized.compileOptimized config⟩ + +end Aiur.Modules diff --git a/Aiur/Aiur/Optimized/ProgramFacts.lean b/Aiur/Aiur/Optimized/ProgramFacts.lean new file mode 100644 index 000000000..ab9d93635 --- /dev/null +++ b/Aiur/Aiur/Optimized/ProgramFacts.lean @@ -0,0 +1,167 @@ +import Aiur.Optimized.Program +import Aiur.Optimized.CompileFacts + +namespace Aiur.Optimized + +variable {F : Type} [Field F] [DecidableEq F] + +theorem compile_stages {program : Program F} {entries : List String} {config : Config} {artifact : Artifact F} + (compiled : compile program entries config = .ok artifact) : + typecheck program = .ok () ∧ program.enums.tagsValid F = true ∧ + artifact.entries = entries ∧ artifact.config = config ∧ + program.functions.mapM (fun function => do layOut config (← Compiler.function program config function (entries.contains function.name))) = + .ok artifact.layouts ∧ + artifact.unmerged = ⟨artifact.layouts.map (·.chip), program.enums, program.tables, program.maps⟩ := by + unfold compile at compiled + dsimp only at compiled + split at compiled + · simp [bind, Except.bind] at compiled + · simp only [pure_bind] at compiled + obtain ⟨⟨⟩, checked, rest₁⟩ := except_bind_ok.mp compiled + have checked : typecheck program = .ok () := by + cases found : typecheck program with + | error error => simp [found, Except.mapError] at checked + | ok unit => cases unit; rfl + obtain ⟨⟨⟩, _, rest₂⟩ := except_bind_ok.mp rest₁ + obtain ⟨⟨⟩, tags, rest₃⟩ := except_bind_ok.mp rest₂ + obtain ⟨layouts, mapped, rest₄⟩ := except_bind_ok.mp rest₃ + obtain ⟨result, deduplicated, rest₅⟩ := except_bind_ok.mp rest₄ + obtain ⟨⟨⟩, formed, finished⟩ := except_bind_ok.mp rest₅ + split at finished + · obtain rfl := except_pure_ok.mp finished + refine ⟨checked, ?_, rfl, rfl, mapped, rfl⟩ + apply (Declarations.tagsValid_spec program.enums).mpr + have each := forIn_ok (items := program.enums) + (action := fun declaration => (Circuit.checkEnumTags F declaration).mapError reprStr) (by + have combined := congrArg (fun result : Except String PUnit => result >>= fun _ => + (pure () : Except String Unit)) tags + simpa only [bind, Except.bind, pure, Except.pure] using combined) + intro declaration member + have accepted := each declaration member + cases found : Circuit.checkEnumTags F declaration with + | error error => simp [found, Except.mapError] at accepted + | ok unit => + unfold Circuit.checkEnumTags at found + split at found + · assumption + · cases found + · cases finished + +theorem Artifact.unmerged_wellFormed (artifact : Artifact F) : artifact.unmerged.WellFormed := by + have accepted := artifact.deduplication.2.2.2.2.2.2.1 + have checked := Circuit.checkChips_iff.mp accepted + exact ⟨checked.1, checked.2.1⟩ + +theorem Artifact.wellFormed (artifact : Artifact F) : artifact.system.WellFormed := by + have accepted := artifact.deduplication.2.2.2.2.2.2.2.1 + have checked := Circuit.checkChips_iff.mp accepted + exact ⟨checked.1, checked.2.1⟩ + +theorem compile_enums {program : Program F} {entries : List String} {config : Config} {artifact : Artifact F} + (compiled : compile program entries config = .ok artifact) : artifact.system.enums = program.enums := by + have unmerged := (compile_stages compiled).2.2.2.2.2 + exact artifact.deduplication.2.2.2.2.2.1.trans (by rw [unmerged]) + +private theorem forall₂_of_mapM_ok {f : α → Except ε β} {xs : List α} {ys : List β} + (mapped : xs.mapM f = .ok ys) : List.Forall₂ (fun x y => f x = .ok y) xs ys := by + induction xs generalizing ys with + | nil => simp only [List.mapM_nil] at mapped; cases mapped; exact .nil + | cons x xs ih => + cases hx : f x with + | error error => simp [hx] at mapped; cases mapped + | ok y => + cases hxs : xs.mapM f with + | error error => simp [hx, hxs] at mapped; cases mapped + | ok rest => + simp [hx, hxs] at mapped + cases mapped + exact .cons hx (ih hxs) + +def FunctionLowered (program : Program F) (config : Config) (entries : List String) (function : Function F) (chip : Circuit.Chip F) : Prop := + ∃ logical layout, Compiler.function program config function (entries.contains function.name) = .ok logical ∧ + layOut config logical = .ok layout ∧ layout.chip = chip + +theorem FunctionLowered.interface {program : Program F} {config : Config} {entries : List String} {function : Function F} + {chip : Circuit.Chip F} (compiled : FunctionLowered program config entries function chip) : + chip.name = function.name ∧ chip.inputs.map WireValue.type = function.params.map Prod.snd ∧ + chip.output.type = function.result := by + obtain ⟨logical, layout, lowered, laidOut, rfl⟩ := compiled + have source := Compiler.function_interface lowered + have physical := layOut_interface laidOut + exact ⟨physical.1.trans source.1, physical.2.1.trans source.2.1, physical.2.2.trans source.2.2⟩ + +theorem compile_functions {program : Program F} {entries : List String} {config : Config} {artifact : Artifact F} + (compiled : compile program entries config = .ok artifact) : + List.Forall₂ (FunctionLowered program config entries) program.functions artifact.unmerged.chips := by + have stages := compile_stages compiled + have mapped := forall₂_of_mapM_ok stages.2.2.2.2.1 + rw [stages.2.2.2.2.2] + apply List.forall₂_map_right_iff.mpr + apply mapped.imp + intro function layout run + obtain ⟨logical, lowered, laidOut⟩ := except_bind_ok.mp run + exact ⟨logical, layout, lowered, laidOut, rfl⟩ + +private theorem lookup_functions {program : Program F} {config : Config} {entries : List String} + {functions : List (Function F)} {chips : List (Circuit.Chip F)} + (compiled : List.Forall₂ (FunctionLowered program config entries) functions chips) (name : String) : + Option.Rel (FunctionLowered program config entries) + (functions.find? (·.name == name)) (chips.find? (·.name == name)) := by + induction compiled with + | nil => exact .none + | cons head _ ih => + have names := head.interface.1 + simp only [List.find?_cons, names] + split + · exact .some head + · exact ih + +theorem compile_find_function {program : Program F} {entries : List String} {config : Config} {artifact : Artifact F} + (compiled : compile program entries config = .ok artifact) + {name : String} {function : Function F} (found : program.findFunction? name = some function) : + ∃ chip, artifact.unmerged.findChip? name = some chip ∧ FunctionLowered program config entries function chip := by + have related := lookup_functions (compile_functions compiled) name + change Option.Rel _ (program.findFunction? name) (artifact.unmerged.findChip? name) at related + rw [found] at related + cases target : artifact.unmerged.findChip? name with + | none => rw [target] at related; cases related + | some chip => + rw [target] at related + cases related with + | some lowered => exact ⟨chip, rfl, lowered⟩ + +theorem compile_find_chip {program : Program F} {entries : List String} {config : Config} {artifact : Artifact F} + (compiled : compile program entries config = .ok artifact) + {name : String} {chip : Circuit.Chip F} (found : artifact.unmerged.findChip? name = some chip) : + ∃ function, program.findFunction? name = some function ∧ FunctionLowered program config entries function chip := by + have related := lookup_functions (compile_functions compiled) name + change Option.Rel _ (program.findFunction? name) (artifact.unmerged.findChip? name) at related + rw [found] at related + cases source : program.findFunction? name with + | none => rw [source] at related; cases related + | some function => + rw [source] at related + cases related with + | some lowered => exact ⟨function, rfl, lowered⟩ + +theorem Artifact.check_iff {artifact : Artifact F} {rom : WireROM F} {root : Circuit.Message F} + {rows : List (Circuit.Row F)} : + artifact.check rom root rows = .ok () ↔ root.channel ∈ artifact.entries ∧ + artifact.system.check rom root rows = .ok () := by + unfold Artifact.check + by_cases selected : root.channel ∈ artifact.entries + · simp only [List.contains_iff_mem, selected, ↓reduceIte, pure_bind, true_and] + cases checked : artifact.system.check rom root rows <;> simp [Except.mapError, checked] + · simp [List.contains_iff_mem, selected, bind, Except.bind] + +theorem Artifact.checkMemo_iff {artifact : Artifact F} {rom : WireROM F} {root : Circuit.Message F} + {rows : List (Circuit.WeightedRow F)} : + artifact.checkMemo rom root rows = .ok () ↔ root.channel ∈ artifact.entries ∧ + artifact.system.checkMemo rom root rows = .ok () := by + unfold Artifact.checkMemo + by_cases selected : root.channel ∈ artifact.entries + · simp only [List.contains_iff_mem, selected, ↓reduceIte, pure_bind, true_and] + cases checked : artifact.system.checkMemo rom root rows <;> simp [Except.mapError, checked] + · simp [List.contains_iff_mem, selected, bind, Except.bind] + +end Aiur.Optimized diff --git a/Aiur/Aiur/Optimized/Propagation.lean b/Aiur/Aiur/Optimized/Propagation.lean new file mode 100644 index 000000000..ca9d6df2d --- /dev/null +++ b/Aiur/Aiur/Optimized/Propagation.lean @@ -0,0 +1,257 @@ +import Aiur.Optimized.PhysicalSemantics +import Aiur.Optimized.PolynomialIdentity +import Aiur.Optimized.AffineEquation +import Aiur.Optimized.LinearNormalization + +namespace Aiur.Optimized.Propagation + +variable {F : Type} [Field F] [DecidableEq F] + +/-- Inputs and unknown call results remain witnesses. Provided outputs and ROM +payloads may instead contain expressions. -/ +def fixed (chip : Circuit.Chip F) : List Witness := + chip.inputs.flatMap WireValue.words ++ chip.sends.flatMap (fun send => send.result.words) + +def rewrite (chip : Circuit.Chip F) (column : Witness → Witness) + (replace : Witness → Polynomial F) : Circuit.Chip F := + -- Substitution may duplicate affine expressions exponentially. Collect their + -- coefficients before the next elimination, including under nonlinear nodes. + let expr := fun p : Polynomial F => (p.subst replace).simplify.normalizeLinear.simplify + { chip with + inputs := chip.inputs.map (WireValue.map column) + output := chip.output.map expr + constraints := chip.constraints.filterMap fun p => + let p := expr p + if p == .const 0 then none else some p + sends := chip.sends.map fun send => { send with + args := send.args.map (WireValue.map expr) + result := send.result.map column + enable := expr send.enable } + memory := chip.memory.map fun lookup => { lookup with + address := expr lookup.address, value := lookup.value.map expr, enable := expr lookup.enable } } + +theorem rewrite_valid (chip : Circuit.Chip F) (column : Witness → Witness) + (replace : Witness → Polynomial F) (rom : WireROM F) (a : Witness → F) : + (rewrite chip column replace).ValidAssignment rom a ↔ + chip.ValidAssignment rom (fun id => (replace id).denote a) := by + have constraints : Circuit.Satisfies (rewrite chip column replace).constraints a ↔ + Circuit.Satisfies chip.constraints (fun id => (replace id).denote a) := by + constructor + · intro valid p member + let result := (Polynomial.subst replace p).simplify.normalizeLinear.simplify + have equal : result.denote a = p.denote (fun id => (replace id).denote a) := by + simp [result] + by_cases zero : (result == .const 0) = true + · rw [← equal, (Polynomial.beq_eq _ _).mp zero] + rfl + · have found : result ∈ (rewrite chip column replace).constraints := + List.mem_filterMap.mpr ⟨p, member, by simp [zero, result]⟩ + exact equal ▸ valid result found + · intro valid p member + obtain ⟨old, oldMember, emitted⟩ := List.mem_filterMap.mp member + dsimp only at emitted + split at emitted + · contradiction + · cases emitted + simpa only [Polynomial.denote_normalizeLinear, Polynomial.denote_simplify, + Polynomial.denote_subst] using valid old oldMember + unfold Circuit.Chip.ValidAssignment + rw [constraints] + simp only [rewrite, List.forall_mem_map, Circuit.MemoryLookup.Valid, + Polynomial.denote_normalizeLinear, Polynomial.denote_simplify, Polynomial.denote_subst, + WireValue.map_map, Function.comp_def] + +theorem rewrite_claims (chip : Circuit.Chip F) (column : Witness → Witness) + (replace : Witness → Polynomial F) + (fixed : ∀ id ∈ fixed chip, replace id = .var (column id)) (a : Witness → F) : + (rewrite chip column replace).conclusion a = chip.conclusion (fun id => (replace id).denote a) ∧ + (rewrite chip column replace).requirements a = chip.requirements (fun id => (replace id).denote a) := by + have input (wire : WireValue Witness) (member : wire ∈ chip.inputs) : + wire.map (a ∘ column) = wire.map (fun id => (replace id).denote a) := by + apply WireValue.map_congr + intro id present + rw [fixed id (List.mem_append_left _ (List.mem_flatMap.mpr ⟨wire, member, present⟩))] + rfl + constructor + · simp only [rewrite, Circuit.Chip.conclusion, List.map_map, WireValue.map_map, + Function.comp_def, Polynomial.denote_normalizeLinear, Polynomial.denote_simplify, Polynomial.denote_subst] + congr 1 + exact List.map_congr_left input + · simp only [rewrite, Circuit.Chip.requirements, List.filterMap_map] + apply List.filterMap_congr + intro send member + simp only [Function.comp_def, Polynomial.denote_normalizeLinear, Polynomial.denote_simplify, Polynomial.denote_subst] + split + · congr 1 + have result : send.result.map (a ∘ column) = send.result.map (fun id => (replace id).denote a) := by + apply WireValue.map_congr + intro id present + rw [fixed id (List.mem_append_right _ (List.mem_flatMap.mpr ⟨send, member, present⟩))] + rfl + simp only [Circuit.Send.message, List.map_map, WireValue.map_map, Function.comp_def, + Polynomial.denote_normalizeLinear, Polynomial.denote_simplify, Polynomial.denote_subst] + exact congrArg (Circuit.Message.mk send.channel _) result + · rfl + +structure Candidate (F : Type) where + id : Witness + value : Polynomial F + +/-- Only actual unconditional equations authorize substitution. In particular, +a guarded equality is not a definition of its value outside the branch. -/ +def Candidate.Certificate (chip : Circuit.Chip F) (candidate : Candidate F) : Prop := + candidate.id ∉ fixed chip ∧ candidate.id ∉ candidate.value.vars ∧ candidate.value.degree ≤ 1 ∧ + ∃ equation ∈ chip.constraints, + Polynomial.Identical equation (.sub (.var candidate.id) candidate.value) ∨ + Polynomial.Identical equation (.sub candidate.value (.var candidate.id)) ∨ + Polynomial.solution? equation candidate.id = some candidate.value + +instance (chip : Circuit.Chip F) (candidate : Candidate F) : Decidable (candidate.Certificate chip) := by + unfold Candidate.Certificate + infer_instance + +def Candidate.replace (candidate : Candidate F) (id : Witness) : Polynomial F := + if id = candidate.id then candidate.value else .var id + +theorem Candidate.equivalent {chip : Circuit.Chip F} {candidate : Candidate F} + (checked : candidate.Certificate chip) : + chip.Equivalent (rewrite chip (fun i => i) candidate.replace) := by + have fixed : ∀ i ∈ fixed chip, candidate.replace i = .var i := by + intro i member + have different : i ≠ candidate.id := by rintro rfl; exact checked.1 member + simp [Candidate.replace, different] + constructor + · intro rom a valid + obtain ⟨polynomial, member, justified⟩ := checked.2.2.2 + have equation : Circuit.ArithExpr.denote a polynomial = 0 := valid.1 polynomial member + have equal : a candidate.id = candidate.value.denote a := by + rcases justified with same | same | solved + · rw [same.denote] at equation + exact sub_eq_zero.mp equation + · rw [same.denote] at equation + exact (sub_eq_zero.mp equation).symm + · exact Polynomial.solution?_sound solved a equation + have unchanged : (fun i => (candidate.replace i).denote a) = a := by + funext i + by_cases h : i = candidate.id <;> simp [Candidate.replace, h, equal, Scalar.Circuit.ArithExpr.denote] + refine ⟨a, ?_, ?_, ?_⟩ + · rw [rewrite_valid, unchanged]; exact valid + · rw [(rewrite_claims chip (fun i => i) candidate.replace fixed a).1, unchanged] + · rw [(rewrite_claims chip (fun i => i) candidate.replace fixed a).2, unchanged] + · intro rom a valid + exact ⟨_, (rewrite_valid chip (fun i => i) candidate.replace rom a).mp valid, + (rewrite_claims chip (fun i => i) candidate.replace fixed a).1.symm, + (rewrite_claims chip (fun i => i) candidate.replace fixed a).2.symm⟩ + +/-- Retain the equation found by the untrusted search so validation does not +repeat an existential search through the entire constraint list. -/ +structure Proposal (F : Type) where + candidate : Candidate F + equationIndex : Nat + +def proposal? (chip : Circuit.Chip F) : Option (Proposal F) := Id.run do + let fixedIds := (fixed chip).foldl (fun set id => set.insert id) (∅ : Std.HashSet Witness) + let allowed := fun id value => + if !fixedIds.contains id && !(Polynomial.vars value).contains id && value.degree ≤ 1 + then some (Candidate.mk id value) else none + for (equation, index) in chip.constraints.zipIdx do + let found := match equation with + | .sub (.var id) value => (allowed id value).orElse fun _ => + match value with | .var other => allowed other (.var id) | _ => none + | .sub value (.var id) => allowed id value + | .var id => allowed id (.const 0) + | _ => none + if let some candidate := found then return some ⟨candidate, index⟩ + for id in (Polynomial.vars equation).eraseDups do + if fixedIds.contains id then continue + -- Failure here is structural, not a zero coefficient for this variable: + -- `isolate_isSome_eq` shows that trying other variables cannot help. + let some (coefficient, rest) := Polynomial.isolate id equation | break + if coefficient ≠ 0 then + let value := Polynomial.simplify (.mul (.const (-coefficient⁻¹)) rest) + if let some candidate := allowed id value then return some ⟨candidate, index⟩ + return none + +def candidate? (chip : Circuit.Chip F) : Option (Candidate F) := + (proposal? chip).map (·.candidate) + +/-- The index is only advice: bounds, the actual equation, fixed columns, +occurrence and degree are checked before recovering the original certificate. -/ +def Proposal.check (proposal : Proposal F) (chip : Circuit.Chip F) : + Option {candidate : Candidate F // candidate.Certificate chip} := + let candidate := proposal.candidate + match selected : chip.constraints[proposal.equationIndex]? with + | none => none + | some equation => + if checked : candidate.id ∉ fixed chip ∧ candidate.id ∉ candidate.value.vars ∧ + candidate.value.degree ≤ 1 ∧ + (Polynomial.Identical equation (.sub (.var candidate.id) candidate.value) ∨ + Polynomial.Identical equation (.sub candidate.value (.var candidate.id)) ∨ + Polynomial.solution? equation candidate.id = some candidate.value) then + some ⟨candidate, checked.1, checked.2.1, checked.2.2.1, + equation, List.mem_of_getElem? selected, checked.2.2.2⟩ + else none + +structure Checked (source : Circuit.Chip F) where + chip : Circuit.Chip F + equivalent : source.Equivalent chip + name_eq : chip.name = source.name + inputTypes : chip.inputs.map WireValue.type = source.inputs.map WireValue.type + outputType : chip.output.type = source.output.type + +def Checked.identity (chip : Circuit.Chip F) : Checked chip := + ⟨chip, .refl chip, rfl, rfl, rfl⟩ + +/-- The fuel is an optimization budget, not an evaluation bound. Exhausting it +retains a proved equivalent chip; each successful step removes a variable. -/ +def propagate (source : Circuit.Chip F) : Nat → (current : Checked source) → Checked source + | 0, current => current + | fuel + 1, current => + match (proposal? current.chip).bind (fun proposal => proposal.check current.chip) with + | none => current + | some ⟨candidate, checked⟩ => + propagate source fuel { + chip := rewrite current.chip id candidate.replace + equivalent := current.equivalent.trans (Candidate.equivalent checked) + name_eq := current.name_eq + inputTypes := by simpa [rewrite, List.map_map, Function.comp_def] using current.inputTypes + outputType := current.outputType } + +def compact (chip : Circuit.Chip F) (columns : List Witness) : Circuit.Chip F := + { rewrite chip columns.idxOf (fun id => .var (columns.idxOf id)) with numVars := columns.length } + +theorem compact_equivalent (chip : Circuit.Chip F) (columns : List Witness) + (inverse : ∀ id ∈ chip.variables, columns[columns.idxOf id]? = some id) : + chip.Equivalent (compact chip columns) := by + let replace : Witness → Polynomial F := fun id => Polynomial.var (columns.idxOf id) + have claims := rewrite_claims chip columns.idxOf replace (fun _ _ => rfl) + constructor + · intro rom a valid + let b : Witness → F := fun column => a (columns[column]?.getD 0) + have agree : ∀ id ∈ chip.variables, (replace id).denote b = a id := by + intro id member + simp [replace, Scalar.Circuit.ArithExpr.denote, b, inverse id member] + have same := chip.agree agree rom + refine ⟨b, (rewrite_valid chip columns.idxOf replace rom b).mpr (same.1.mpr valid), ?_, ?_⟩ + · exact (claims b).1.trans same.2.1 + · exact (claims b).2.trans same.2.2 + · intro rom a valid + exact ⟨_, (rewrite_valid chip columns.idxOf replace rom a).mp valid, + (claims a).1.symm, (claims a).2.symm⟩ + +/-- Renumber surviving columns densely after propagation, including columns +made irrelevant by constant-folded equations. -/ +def run (source : Circuit.Chip F) : Except String (Checked source) := do + let current := propagate source source.numVars (.identity source) + let used := current.chip.variables + let columns := (List.range current.chip.numVars).filter (used.contains ·) + if inverse : ∀ id ∈ current.chip.variables, columns[columns.idxOf id]? = some id then + return { + chip := compact current.chip columns + equivalent := current.equivalent.trans (compact_equivalent _ _ inverse) + name_eq := current.name_eq + inputTypes := by simpa [compact, rewrite, List.map_map, Function.comp_def] using current.inputTypes + outputType := current.outputType } + else throw s!"invalid column compaction in {source.name}" + +end Aiur.Optimized.Propagation diff --git a/Aiur/Aiur/Optimized/ReferenceState.lean b/Aiur/Aiur/Optimized/ReferenceState.lean new file mode 100644 index 000000000..e2ff443b5 --- /dev/null +++ b/Aiur/Aiur/Optimized/ReferenceState.lean @@ -0,0 +1,120 @@ +import Aiur.Optimized.StateSemantics +import Aiur.Circuit.ValueWitness + +namespace Aiur.Optimized.Compiler + +variable {F : Type} [Field F] [DecidableEq F] + +/-- Forget allocation roles, while retaining logical witness indices and all +guarded obligations. This reuses the reference compiler's witness extension +lemmas; it does not assume the two expression compilers are equivalent. -/ +def State.toReference (state : State F) : Circuit.Compiler.BuildState F where + nextVar := state.roles.size + constraints := state.equations.map fun equation => .mul (state.activation equation.scope) equation.polynomial + sends := state.calls.map fun call => ⟨call.channel, call.args, call.result, state.activation call.scope⟩ + memory := state.cells.map fun cell => ⟨cell.address, cell.value, state.activation cell.scope⟩ + +theorem State.valid_iff_reference (state : State F) (rom : WireROM F) (calls : Circuit.CallRelation F) + (assignment : Witness → F) : state.Valid rom calls assignment ↔ state.toReference.Valid rom calls assignment := by + have equations : Circuit.Satisfies state.toReference.constraints.toList assignment ↔ + ∀ equation ∈ state.equations.toList, + (state.activation equation.scope).denote assignment * equation.polynomial.denote assignment = 0 := by + simp only [State.toReference, Circuit.Satisfies, Scalar.Circuit.Satisfies, Array.toList_map, List.forall_mem_map, + Scalar.Circuit.ArithExpr.denote] + constructor + · rintro ⟨localEquations, localCalls, localCells⟩ + refine ⟨equations.mpr localEquations, ?_, ?_⟩ + · simpa only [State.toReference, Array.toList_map, List.forall_mem_map, Call.message] using localCalls + · simpa only [State.toReference, Array.toList_map, List.forall_mem_map, Circuit.MemoryLookup.Valid] using localCells + · intro valid + refine ⟨equations.mp valid.constraints, ?_, ?_⟩ + · simpa only [State.toReference, Array.toList_map, List.forall_mem_map, Call.message] using valid.calls + · simpa only [State.toReference, Array.toList_map, List.forall_mem_map, Circuit.MemoryLookup.Valid] using valid.memory + +theorem fresh_reference {role : Role} {id : Witness} {before after : State F} + (compiled : fresh role before = .ok (id, after)) : + Circuit.Compiler.fresh before.toReference = .ok (id, after.toReference) := by + obtain ⟨rfl, rfl⟩ := fresh_eq compiled + simp only [Circuit.Compiler.fresh_apply, State.toReference, State.activation, Array.size_push] + +theorem equation_reference {scope : ScopeId} {polynomial : Polynomial F} {before after : State F} + (compiled : equation scope polynomial before = .ok ((), after)) : + Circuit.Compiler.constrain (.mul (before.activation scope) polynomial) before.toReference = + .ok ((), after.toReference) := by + obtain rfl := equation_eq compiled + simp only [Circuit.Compiler.constrain_apply, State.toReference, State.activation, Array.map_push] + +theorem freshList_reference {α : Type} {items : List α} {role : Role} {ids : List Witness} + {before after : State F} + (compiled : (items.mapM (fun _ => fresh role)) before = .ok (ids, after)) : + Circuit.Compiler.freshWords items.length before.toReference = .ok (ids, after.toReference) := by + induction items generalizing ids before with + | nil => + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [List.mapM_nil] using compiled) + simp [Circuit.Compiler.freshWords_apply] + | cons item items ih => + simp only [List.mapM_cons] at compiled + obtain ⟨id, middle, headRun, tailBind⟩ := bind_ok.mp compiled + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp tailBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨rfl, rfl⟩ := fresh_eq headRun + have reference := ih tailRun + simp only [Circuit.Compiler.freshWords_apply, Except.ok.injEq, Prod.mk.injEq] at reference ⊢ + obtain ⟨rfl, stateEq⟩ := reference + rw [← stateEq] + simp [State.toReference, State.activation, List.range'_succ, Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] + +theorem freshValue_reference {decls : Declarations} {role : Role} {type : Ty} {value : WireValue Witness} + {before after : State F} + (compiled : freshValue decls role type before = .ok (value, after)) : + Circuit.Compiler.freshValue decls type before.toReference = .ok (value, after.toReference) := by + simp only [freshValue] at compiled + obtain ⟨layout, middle, expanded, rest⟩ := bind_ok.mp compiled + obtain ⟨expansion, stateEq⟩ := getLayout_eq expanded + subst middle + obtain ⟨words, last, wordsRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + have reference := freshList_reference wordsRun + simp only [List.length_range] at reference + simpa [Circuit.Compiler.freshValue, Circuit.Compiler.getLayout, expansion, Except.mapError, + StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] using reference + +abbrev Extension (rom : WireROM F) (calls : Circuit.CallRelation F) (before after : State F) + (initial assignment : Witness → F) : Prop := + Circuit.Compiler.Extension rom calls before.toReference after.toReference initial assignment + +theorem Extension.validAssignment {rom : WireROM F} {calls : Circuit.CallRelation F} {before after : State F} + {initial assignment : Witness → F} (extension : Extension rom calls before after initial assignment) : + after.Valid rom calls assignment := + (after.valid_iff_reference rom calls assignment).mpr (Circuit.Compiler.Extension.valid extension) + +theorem fresh_complete {role : Role} {id : Witness} {before after : State F} + (compiled : fresh role before = .ok (id, after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (valid : before.Valid rom calls initial) (value : F) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + id < after.roles.size ∧ assignment id = value := + Circuit.Compiler.fresh_complete (fresh_reference compiled) layout + ((before.valid_iff_reference rom calls initial).mp valid) value + +theorem equation_complete {scope : ScopeId} {polynomial : Polynomial F} {before after : State F} + (compiled : equation scope polynomial before = .ok ((), after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {assignment : Witness → F} + (layout : before.toReference.WellFormed) (valid : before.Valid rom calls assignment) + (bounded : (Polynomial.mul (before.activation scope) polynomial).inBounds before.roles.size = true) + (zero : (before.activation scope).denote assignment * polynomial.denote assignment = 0) : + Extension rom calls before after assignment assignment := + Circuit.Compiler.constrain_complete (equation_reference compiled) layout + ((before.valid_iff_reference rom calls assignment).mp valid) bounded zero + +theorem freshValue_complete {decls : Declarations} {role : Role} {type : Ty} {vars : WireValue Witness} + {before after : State F} (compiled : freshValue decls role type before = .ok (vars, after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (valid : before.Valid rom calls initial) + (value : WireValue F) (shape : value.type = type) (sized : value.Sized decls) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + Circuit.Compiler.Bounded (F := F) after.roles.size (vars.map Polynomial.var) ∧ vars.map assignment = value := + Circuit.Compiler.freshValue_complete (freshValue_reference compiled) layout + ((before.valid_iff_reference rom calls initial).mp valid) value shape sized + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/ScopedInvariant.lean b/Aiur/Aiur/Optimized/ScopedInvariant.lean new file mode 100644 index 000000000..1c12f56c8 --- /dev/null +++ b/Aiur/Aiur/Optimized/ScopedInvariant.lean @@ -0,0 +1,617 @@ +import Aiur.Optimized.ScopedWitness + +namespace Aiur.Optimized.Compiler + +variable {F : Type} [Field F] [DecidableEq F] +set_option maxHeartbeats 2000000 +set_option maxRecDepth 4096 + +theorem equation_grow {scope : ScopeId} {polynomial : Polynomial F} {before after : State F} + (compiled : equation scope polynomial before = .ok ((), after)) : before.Extends after := by + obtain rfl := equation_eq compiled + exact ⟨fun _ _ => id, by simp, fun _ => id, fun _ => id⟩ + +theorem equations_grow {scope : ScopeId} {conditions : List (Polynomial F)} {before after : State F} + (compiled : (do for condition in conditions do equation scope condition : Build F Unit) + before = .ok ((), after)) : before.Extends after := by + induction conditions generalizing before with + | nil => + have same : before = after := by + simpa [List.forIn_nil, pure, StateT.pure, StateT.bind, bind, Except.bind, Except.pure] using compiled + subst after + exact .refl before + | cons condition conditions ih => + simp [List.forIn_cons, equation, modify, modifyGet, MonadStateOf.modifyGet, StateT.modifyGet, + StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at compiled + exact (equation_grow (scope := scope) (polynomial := condition) rfl).trans (ih compiled) + +mutual + theorem validate_scoped {layout : Layout} {scope : ScopeId} {words : List (Polynomial F)} + {before after : State F} (compiled : validate scope layout words before = .ok ((), after)) + (scopeLayout : before.Scoped) (scopeValid : scope < before.scopes.size) : + before.Extends after ∧ after.Scoped := by + cases layout with + | field => + cases words with + | nil => simp [validate] at compiled + | cons word rest => + cases rest with + | cons => simp [validate] at compiled + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp (by simpa only [validate] using compiled) + exact ⟨.refl _, scopeLayout⟩ + | ptr target => + cases words with + | nil => simp [validate] at compiled + | cons word rest => + cases rest with + | cons => simp [validate] at compiled + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp (by simpa only [validate] using compiled) + exact ⟨.refl _, scopeLayout⟩ + | tuple layouts => exact validateList_scoped (by simpa only [validate] using compiled) scopeLayout scopeValid + | enum name constructors => + simp only [validate] at compiled + cases parts : Layout.enumParts constructors.length (.const 0) words with + | none => simp [parts] at compiled + | some pair => + rcases pair with ⟨tag, payload⟩ + simp only [parts] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · obtain ⟨⟨⟩, unchangedState, unchanged, choiceBind⟩ := bind_ok.mp compiled + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst unchangedState + obtain ⟨branches, middle, choiceRun, ctorRun⟩ := bind_ok.mp choiceBind + obtain ⟨ctorExtension, finalLayout⟩ := validateConstructors_scoped ctorRun + (choice_scoped choiceRun scopeLayout) (choice_child_bound choiceRun) + exact ⟨(choice_extends choiceRun).trans ctorExtension, finalLayout⟩ + termination_by sizeOf layout + + theorem validateList_scoped {layouts : List Layout} {scope : ScopeId} {words : List (Polynomial F)} + {before after : State F} (compiled : validateList scope layouts words before = .ok ((), after)) + (scopeLayout : before.Scoped) (scopeValid : scope < before.scopes.size) : + before.Extends after ∧ after.Scoped := by + cases layouts with + | nil => + cases words with + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp (by simpa only [validateList] using compiled) + exact ⟨.refl _, scopeLayout⟩ + | cons => simp [validateList] at compiled + | cons layout layouts => + simp only [validateList] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · obtain ⟨⟨⟩, unchangedState, unchanged, validationBind⟩ := bind_ok.mp compiled + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst unchangedState + obtain ⟨⟨⟩, middle, headRun, tailRun⟩ := bind_ok.mp validationBind + obtain ⟨headExtension, middleLayout⟩ := validate_scoped headRun scopeLayout scopeValid + obtain ⟨tailExtension, finalLayout⟩ := validateList_scoped tailRun middleLayout + (headExtension.scopeValid scopeValid) + exact ⟨headExtension.trans tailExtension, finalLayout⟩ + termination_by sizeOf layouts + + theorem validateConstructors_scoped {constructors : List (String × Layout)} {branches : List ScopeId} + {tag : Polynomial F} {payload : List (Polynomial F)} {index : Nat} {before after : State F} + (compiled : validateConstructors constructors branches tag payload index before = .ok ((), after)) + (scopeLayout : before.Scoped) (branchesValid : ∀ branch ∈ branches, branch < before.scopes.size) : + before.Extends after ∧ after.Scoped := by + cases constructors with + | nil => + cases branches with + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp (by simpa only [validateConstructors] using compiled) + exact ⟨.refl _, scopeLayout⟩ + | cons => simp [validateConstructors] at compiled + | cons ctor rest => + cases hctor : ctor with + | mk ctorName ctorLayout => + cases branches with + | nil => simp [validateConstructors] at compiled + | cons branch branches => + simp only [hctor, validateConstructors] at compiled + obtain ⟨⟨⟩, s₁, tagRun, payloadBind⟩ := bind_ok.mp compiled + obtain ⟨⟨⟩, s₂, payloadRun, paddingBind⟩ := bind_ok.mp payloadBind + obtain ⟨⟨⟩, s₃, paddingRun, tailRun⟩ := bind_ok.mp paddingBind + have tagExtension := equation_grow tagRun + have branchValid := branchesValid branch (by simp) + obtain ⟨payloadExtension, payloadLayout⟩ := validate_scoped payloadRun + (equation_scoped tagRun scopeLayout branchValid) (tagExtension.scopeValid branchValid) + have paddingRun' : (do for word in payload.drop ctorLayout.width do equation branch word : Build F Unit) + s₂ = .ok ((), s₃) := bind_ok.mpr ⟨PUnit.unit, s₃, paddingRun, rfl⟩ + have paddingExtension := equations_grow paddingRun' + have prefixExtension := (tagExtension.trans payloadExtension).trans paddingExtension + have paddingLayout := equations_scoped paddingRun' payloadLayout + (payloadExtension.scopeValid (tagExtension.scopeValid branchValid)) + obtain ⟨tailExtension, finalLayout⟩ := validateConstructors_scoped tailRun paddingLayout + (fun child member => prefixExtension.scopeValid (branchesValid child (by simp [member]))) + exact ⟨prefixExtension.trans tailExtension, finalLayout⟩ + termination_by sizeOf constructors + decreasing_by all_goals simp_all only [List.cons.sizeOf_spec, Prod.mk.sizeOf_spec]; omega +end + +theorem validateValue_scoped {decls : Declarations} {scope : ScopeId} {value : Symbolic F} + {before after : State F} (compiled : validateValue decls scope value before = .ok ((), after)) + (scopeLayout : before.Scoped) (scopeValid : scope < before.scopes.size) : + before.Extends after ∧ after.Scoped := by + simp only [validateValue] at compiled + obtain ⟨layout, middle, layoutRun, validationRun⟩ := bind_ok.mp compiled + obtain ⟨_, stateEq⟩ := getLayout_eq layoutRun + subst middle + exact validate_scoped validationRun scopeLayout scopeValid + +private theorem polynomial_has_bound (polynomial : Polynomial F) : + ∃ bound, polynomial.inBounds bound = true := by + induction polynomial with + | const value => exact ⟨0, rfl⟩ + | var id => exact ⟨id + 1, by simp [Circuit.ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds]⟩ + | add a b ha hb | sub a b ha hb | mul a b ha hb => + obtain ⟨left, leftBound⟩ := ha + obtain ⟨right, rightBound⟩ := hb + refine ⟨max left right, ?_⟩ + simpa only [Circuit.ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds, Bool.and_eq_true] using + And.intro (Scalar.Circuit.ArithExpr.inBounds_mono (Nat.le_max_left _ _) leftBound) + (Scalar.Circuit.ArithExpr.inBounds_mono (Nat.le_max_right _ _) rightBound) + +private theorem words_have_bound (words : List (Polynomial F)) : + ∃ bound, ∀ polynomial ∈ words, polynomial.inBounds bound = true := by + induction words with + | nil => exact ⟨0, by simp⟩ + | cons polynomial rest ih => + obtain ⟨left, leftBound⟩ := polynomial_has_bound polynomial + obtain ⟨right, rightBound⟩ := ih + refine ⟨max left right, ?_⟩ + intro p member + rcases List.mem_cons.mp member with rfl | member + · exact Scalar.Circuit.ArithExpr.inBounds_mono (Nat.le_max_left _ _) leftBound + · exact Scalar.Circuit.ArithExpr.inBounds_mono (Nat.le_max_right _ _) (rightBound p member) + +theorem pattern_unchanged {decls : Declarations} {pat : Pattern F} {value : Symbolic F} + {conditions : List (Polynomial F)} {bindings : Locals F} {before after : State F} + (compiled : pattern decls pat value before = .ok ((conditions, bindings), after)) : after = before := by + obtain ⟨bound, bounded⟩ := words_have_bound value.words + exact (pattern_bounded compiled (bound := bound) bounded).1 + +private theorem failure_terms_scoped {scope : ScopeId} {conditions terms : List (Polynomial F)} + {before after : State F} + (compiled : (conditions.mapM fun difference => do + return Polynomial.mul difference (.var (← fresh (.auxiliary scope)))) before = .ok (terms, after)) + (scopeLayout : before.Scoped) : before.Extends after ∧ after.Scoped := by + induction conditions generalizing terms before with + | nil => + obtain ⟨rfl, rfl⟩ := pure_ok.mp (by simpa only [List.mapM_nil] using compiled) + exact ⟨.refl _, scopeLayout⟩ + | cons condition conditions ih => + simp only [List.mapM_cons] at compiled + obtain ⟨term, s₁, headRun, tailBind⟩ := bind_ok.mp compiled + obtain ⟨tail, s₂, tailRun, finished⟩ := bind_ok.mp tailBind + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨id, middle, freshRun, headFinish⟩ := bind_ok.mp headRun + obtain ⟨_, stateEq⟩ := pure_ok.mp headFinish + subst s₁ + obtain ⟨tailExtension, finalLayout⟩ := ih tailRun (fresh_scoped freshRun scopeLayout) + exact ⟨(fresh_extends freshRun).trans tailExtension, finalLayout⟩ + +theorem failure_scoped {scope : ScopeId} {conditions : List (Polynomial F)} {before after : State F} + (compiled : failure scope conditions before = .ok ((), after)) + (scopeLayout : before.Scoped) (scopeValid : scope < before.scopes.size) : + before.Extends after ∧ after.Scoped := by + simp only [failure] at compiled + obtain ⟨terms, middle, termsRun, equationRun⟩ := bind_ok.mp compiled + obtain ⟨termsExtension, middleLayout⟩ := failure_terms_scoped termsRun scopeLayout + exact ⟨termsExtension.trans (equation_grow equationRun), + equation_scoped equationRun middleLayout (termsExtension.scopeValid scopeValid)⟩ + +theorem forIn_scoped {α : Type} {items : List α} {action : α → Build F Unit} + {scope : ScopeId} {before after : State F} + (compiled : (forIn items PUnit.unit (fun item _ => do + action item + pure (ForInStep.yield PUnit.unit)) : Build F PUnit) before = .ok (PUnit.unit, after)) + (scopeLayout : before.Scoped) (scopeValid : scope < before.scopes.size) + (each : ∀ item ∈ items, ∀ {first last : State F}, action item first = .ok ((), last) → + first.Scoped → scope < first.scopes.size → first.Extends last ∧ last.Scoped) : + before.Extends after ∧ after.Scoped := by + induction items generalizing before with + | nil => + obtain ⟨_, stateEq⟩ := pure_ok.mp (by simpa only [List.forIn_nil] using compiled) + subst after + exact ⟨.refl _, scopeLayout⟩ + | cons item rest ih => + simp only [List.forIn_cons] at compiled + obtain ⟨step, middle, stepRun, restRun⟩ := bind_ok.mp compiled + obtain ⟨⟨⟩, s₁, actionRun, stepFinish⟩ := bind_ok.mp stepRun + obtain ⟨rfl, stateEq⟩ := pure_ok.mp stepFinish + subst middle + obtain ⟨headExtension, middleLayout⟩ := each item (by simp) actionRun scopeLayout scopeValid + obtain ⟨tailExtension, finalLayout⟩ := ih restRun middleLayout + (headExtension.scopeValid scopeValid) (fun item member => each item (by simp [member])) + exact ⟨headExtension.trans tailExtension, finalLayout⟩ + +theorem equalValue_structural {scope : ScopeId} {left right : Symbolic F} {before after : State F} + (compiled : equalValue scope left right before = .ok ((), after)) + (scopeLayout : before.Scoped) (scopeValid : scope < before.scopes.size) : + before.Extends after ∧ after.Scoped := by + refine ⟨?_, equalValue_scoped compiled scopeLayout scopeValid⟩ + simp only [equalValue] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp compiled + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst middle + apply equations_grow (conditions := (left.words.zip right.words).map fun (a, b) => Polynomial.sub a b) + simpa only [List.forIn_map] using rest + +theorem lift_unchanged {α : Type} {computation : Except String α} {value : α} {before after : State F} + (compiled : (liftM computation : Build F α) before = .ok (value, after)) : before = after := by + cases computation with + | error message => cases compiled + | ok output => exact (Prod.mk.inj (Except.ok.inj compiled)).2 + +theorem pushCell_scoped {state : State F} (scopeLayout : state.Scoped) (cell : Cell F) + (scopeValid : cell.scope < state.scopes.size) : + state.Extends {state with cells := state.cells.push cell} ∧ + ({state with cells := state.cells.push cell} : State F).Scoped := by + refine ⟨⟨fun _ _ => id, fun _ => id, fun _ => id, by simp⟩, + ⟨scopeLayout.equations, scopeLayout.calls, ?_, scopeLayout.activations⟩⟩ + intro next member + simp only [Array.toList_push, List.mem_append, List.mem_singleton] at member + rcases member with old | rfl + · exact scopeLayout.cells next old + · exact scopeValid + +theorem pushCall_scoped {state : State F} (scopeLayout : state.Scoped) (call : Call F) + (scopeValid : call.scope < state.scopes.size) : + state.Extends {state with calls := state.calls.push call} ∧ + ({state with calls := state.calls.push call} : State F).Scoped := by + refine ⟨⟨fun _ _ => id, fun _ => id, by simp, fun _ => id⟩, + ⟨scopeLayout.equations, ?_, scopeLayout.cells, scopeLayout.activations⟩⟩ + intro next member + simp only [Array.toList_push, List.mem_append, List.mem_singleton] at member + rcases member with old | rfl + · exact scopeLayout.calls next old + · exact scopeValid + +mutual + theorem lower_scoped {program : Program F} {function : String} {locals : Locals F} + {scope : ScopeId} {expr : Expr F} {target : Option (WireValue Witness)} {output : Symbolic F} + {before after : State F} + (compiled : lower program function locals scope expr target before = .ok (output, after)) + (scopeLayout : before.Scoped) (scopeValid : scope < before.scopes.size) : + before.Extends after ∧ after.Scoped := by + rw [lower.eq_def] at compiled + obtain ⟨value, middle, stepRun, finished⟩ := bind_ok.mp compiled + have step : before.Extends middle ∧ middle.Scoped := by + cases expr with + | literal literal => + obtain ⟨_, stateEq⟩ := pure_ok.mp stepRun + subst middle + exact ⟨.refl _, scopeLayout⟩ + | var name => + cases found : locals.find? (·.1 == name) with + | none => simp [found] at stepRun + | some binding => + rcases binding with ⟨key, wire⟩ + simp only [found] at stepRun + obtain ⟨_, stateEq⟩ := pure_ok.mp stepRun + subst middle + exact ⟨.refl _, scopeLayout⟩ + | tuple items => + obtain ⟨values, s₁, argsRun, pureRun⟩ := bind_ok.mp stepRun + obtain ⟨_, stateEq⟩ := pure_ok.mp pureRun + subst middle + exact lowerArgs_scoped argsRun scopeLayout scopeValid + | construct name ctor args => + cases found : program.enums.findEnum? name with + | none => simp [found] at stepRun + | some definition => + simp only [found] at stepRun + cases atIndex : definition.constructors[definition.constructors.findIdx (·.name == ctor)]? with + | none => simp [atIndex] at stepRun + | some constructor => + simp only [atIndex] at stepRun + obtain ⟨values, s₁, argsRun, checkBind⟩ := bind_ok.mp stepRun + obtain ⟨argExtension, argLayout⟩ := lowerArgs_scoped argsRun scopeLayout scopeValid + split at checkBind + · simp [StateT.bind, bind, Except.bind] at checkBind + · obtain ⟨⟨⟩, s₂, unchanged, layoutBind⟩ := bind_ok.mp checkBind + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst s₂ + obtain ⟨layout, s₃, layoutRun, widthBind⟩ := bind_ok.mp layoutBind + obtain ⟨_, stateEq⟩ := getLayout_eq layoutRun + subst s₃ + split at widthBind + · simp [StateT.bind, bind, Except.bind] at widthBind + · obtain ⟨⟨⟩, s₄, unchanged, pureRun⟩ := bind_ok.mp widthBind + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst s₄ + obtain ⟨_, stateEq⟩ := pure_ok.mp pureRun + subst middle + exact ⟨argExtension, argLayout⟩ + | project operand index => + obtain ⟨wire, s₁, operandRun, projectBind⟩ := bind_ok.mp stepRun + obtain ⟨operandExtension, operandLayout⟩ := lower_scoped operandRun scopeLayout scopeValid + cases typeEq : wire.type with + | field | ptr | enum => simp [typeEq] at projectBind + | tuple types => + simp only [typeEq] at projectBind + obtain ⟨items, s₂, splitRun, resultRun⟩ := bind_ok.mp projectBind + obtain ⟨stateEq, _⟩ := splitValues_reference splitRun + subst s₂ + cases found : items[index]? with + | none => simp [found] at resultRun + | some result => + simp only [found] at resultRun + obtain ⟨_, stateEq⟩ := pure_ok.mp resultRun + subst middle + exact ⟨operandExtension, operandLayout⟩ + | letValue pat operand body => + obtain ⟨wire, s₁, operandRun, patternBind⟩ := bind_ok.mp stepRun + obtain ⟨⟨conditions, bindings⟩, s₂, patternRun, equationsBind⟩ := bind_ok.mp patternBind + obtain ⟨⟨⟩, s₃, equationRun, bodyRun⟩ := bind_ok.mp equationsBind + have stateEq := pattern_unchanged patternRun + subst s₂ + have equationRun' : (do for condition in conditions do equation scope condition : Build F Unit) + s₁ = .ok ((), s₃) := bind_ok.mpr ⟨PUnit.unit, s₃, equationRun, rfl⟩ + obtain ⟨operandExtension, operandLayout⟩ := lower_scoped operandRun scopeLayout scopeValid + have equationExtension := equations_grow equationRun' + have prefixExtension := operandExtension.trans equationExtension + have equationLayout := equations_scoped equationRun' operandLayout (operandExtension.scopeValid scopeValid) + obtain ⟨bodyExtension, finalLayout⟩ := lower_scoped bodyRun equationLayout + (prefixExtension.scopeValid scopeValid) + exact ⟨prefixExtension.trans bodyExtension, finalLayout⟩ + | store operand => + obtain ⟨wire, s₁, operandRun, destinationBind⟩ := bind_ok.mp stepRun + obtain ⟨result, s₂, destinationRun, pointerBind⟩ := bind_ok.mp destinationBind + obtain ⟨operandExtension, operandLayout⟩ := lower_scoped operandRun scopeLayout scopeValid + have destinationExtension := destination_extends destinationRun + have prefixExtension := operandExtension.trans destinationExtension + have destinationLayout := destination_scoped destinationRun operandLayout + cases wordsEq : result.words with + | nil => simp [wordsEq] at pointerBind + | cons address rest => + cases rest with + | cons => simp [wordsEq] at pointerBind + | nil => + simp only [wordsEq] at pointerBind + obtain ⟨⟨⟩, s₃, storeRun, pureRun⟩ := bind_ok.mp pointerBind + obtain ⟨_, stateEq⟩ := pure_ok.mp pureRun + subst middle + change Except.ok ((), {s₂ with cells := s₂.cells.push ⟨scope, .var address, wire⟩}) = .ok ((), s₃) at storeRun + have stateEq := (Prod.mk.inj (Except.ok.inj storeRun)).2 + subst s₃ + obtain ⟨cellExtension, finalLayout⟩ := pushCell_scoped destinationLayout + ⟨scope, .var address, wire⟩ (prefixExtension.scopeValid scopeValid) + exact ⟨prefixExtension.trans cellExtension, finalLayout⟩ + | load operand => + obtain ⟨pointer, s₁, operandRun, pointerBind⟩ := bind_ok.mp stepRun + obtain ⟨operandExtension, operandLayout⟩ := lower_scoped operandRun scopeLayout scopeValid + rcases pointer with ⟨type, words⟩ + cases type with + | field | tuple | enum => simp at pointerBind + | ptr type => + cases words with + | nil => simp at pointerBind + | cons address rest => + cases rest with + | cons => simp at pointerBind + | nil => + dsimp only at pointerBind + obtain ⟨result, s₂, destinationRun, loadBind⟩ := bind_ok.mp pointerBind + obtain ⟨⟨⟩, s₃, loadRun, pureRun⟩ := bind_ok.mp loadBind + obtain ⟨_, stateEq⟩ := pure_ok.mp pureRun + subst middle + have prefixExtension := operandExtension.trans (destination_extends destinationRun) + change Except.ok ((), {s₂ with cells := s₂.cells.push ⟨scope, address, result.map Polynomial.var⟩}) = + .ok ((), s₃) at loadRun + have stateEq := (Prod.mk.inj (Except.ok.inj loadRun)).2 + subst s₃ + obtain ⟨cellExtension, finalLayout⟩ := pushCell_scoped + (destination_scoped destinationRun operandLayout) + ⟨scope, address, result.map Polynomial.var⟩ (prefixExtension.scopeValid scopeValid) + exact ⟨prefixExtension.trans cellExtension, finalLayout⟩ + | neg operand => + obtain ⟨wire, s₁, operandRun, fieldBind⟩ := bind_ok.mp stepRun + obtain ⟨polynomial, s₂, fieldRun, pureRun⟩ := bind_ok.mp fieldBind + obtain ⟨_, stateEq⟩ := asField_eq fieldRun + subst s₂ + obtain ⟨_, stateEq⟩ := pure_ok.mp pureRun + subst middle + exact lower_scoped operandRun scopeLayout scopeValid + | hint type key channel => + obtain ⟨keyWire, s₁, keyRun, pointerCheck⟩ := bind_ok.mp stepRun + split at pointerCheck + · simp [StateT.bind, bind, Except.bind] at pointerCheck + · obtain ⟨⟨⟩, s₂, unchanged, destinationBind⟩ := bind_ok.mp pointerCheck + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst s₂ + obtain ⟨result, s₃, destinationRun, validationBind⟩ := bind_ok.mp destinationBind + obtain ⟨⟨⟩, s₄, validationRun, pureRun⟩ := bind_ok.mp validationBind + obtain ⟨_, stateEq⟩ := pure_ok.mp pureRun + subst middle + obtain ⟨keyExtension, keyLayout⟩ := lower_scoped keyRun scopeLayout scopeValid + have prefixExtension := keyExtension.trans (destination_extends destinationRun) + obtain ⟨validationExtension, finalLayout⟩ := validateValue_scoped validationRun + (destination_scoped destinationRun keyLayout) (prefixExtension.scopeValid scopeValid) + exact ⟨prefixExtension.trans validationExtension, finalLayout⟩ + | assertEq message left right => + obtain ⟨leftWire, s₁, leftRun, rightBind⟩ := bind_ok.mp stepRun + obtain ⟨rightWire, s₂, rightRun, pointerCheck⟩ := bind_ok.mp rightBind + split at pointerCheck + · simp [StateT.bind, bind, Except.bind] at pointerCheck + · obtain ⟨⟨⟩, s₃, unchanged, equalityBind⟩ := bind_ok.mp pointerCheck + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst s₃ + obtain ⟨⟨⟩, s₄, equalityRun, pureRun⟩ := bind_ok.mp equalityBind + obtain ⟨_, stateEq⟩ := pure_ok.mp pureRun + subst middle + obtain ⟨leftExtension, leftLayout⟩ := lower_scoped leftRun scopeLayout scopeValid + obtain ⟨rightExtension, rightLayout⟩ := lower_scoped rightRun leftLayout + (leftExtension.scopeValid scopeValid) + have prefixExtension := leftExtension.trans rightExtension + obtain ⟨equalityExtension, finalLayout⟩ := equalValue_structural equalityRun rightLayout + (prefixExtension.scopeValid scopeValid) + exact ⟨prefixExtension.trans equalityExtension, finalLayout⟩ + | binary op left right => + obtain ⟨leftWire, s₁, leftRun, leftFieldBind⟩ := bind_ok.mp stepRun + obtain ⟨leftWord, s₂, leftFieldRun, rightBind⟩ := bind_ok.mp leftFieldBind + obtain ⟨_, stateEq⟩ := asField_eq leftFieldRun + subst s₂ + obtain ⟨rightWire, s₃, rightRun, rightFieldBind⟩ := bind_ok.mp rightBind + obtain ⟨rightWord, s₄, rightFieldRun, operatorRun⟩ := bind_ok.mp rightFieldBind + obtain ⟨_, stateEq⟩ := asField_eq rightFieldRun + subst s₄ + obtain ⟨leftExtension, leftLayout⟩ := lower_scoped leftRun scopeLayout scopeValid + obtain ⟨rightExtension, rightLayout⟩ := lower_scoped rightRun leftLayout + (leftExtension.scopeValid scopeValid) + have prefixExtension := leftExtension.trans rightExtension + cases op with + | add | sub | mul => + obtain ⟨_, stateEq⟩ := pure_ok.mp operatorRun + subst middle + exact ⟨prefixExtension, rightLayout⟩ + | div => + cases folded : rightWord.constantInverse? with + | some inverse => + simp only [folded] at operatorRun + obtain ⟨_, stateEq⟩ := pure_ok.mp operatorRun + subst middle + exact ⟨prefixExtension, rightLayout⟩ + | none => + simp only [folded] at operatorRun + obtain ⟨inverse, s₅, inverseRun, equationBind⟩ := bind_ok.mp operatorRun + obtain ⟨⟨⟩, s₆, equationRun, pureRun⟩ := bind_ok.mp equationBind + obtain ⟨_, stateEq⟩ := pure_ok.mp pureRun + subst middle + have inverseExtension := prefixExtension.trans (fresh_extends inverseRun) + exact ⟨inverseExtension.trans (equation_grow equationRun), + equation_scoped equationRun (fresh_scoped inverseRun rightLayout) + (inverseExtension.scopeValid scopeValid)⟩ + | call name args => + cases found : program.findSignature? name with + | none => simp [found] at stepRun + | some callee => + simp only [found] at stepRun + obtain ⟨argValues, s₁, argsRun, checkBind⟩ := bind_ok.mp stepRun + split at checkBind + · simp [StateT.bind, bind, Except.bind] at checkBind + · obtain ⟨⟨⟩, s₂, unchanged, destinationBind⟩ := bind_ok.mp checkBind + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst s₂ + obtain ⟨result, s₃, destinationRun, callBind⟩ := bind_ok.mp destinationBind + obtain ⟨⟨⟩, s₆, callRun, pureRun⟩ := bind_ok.mp callBind + obtain ⟨_, stateEq⟩ := pure_ok.mp pureRun + subst middle + obtain ⟨argsExtension, argsLayout⟩ := lowerArgs_scoped argsRun scopeLayout scopeValid + have destinationExtension := argsExtension.trans (destination_extends destinationRun) + change Except.ok ((), {s₃ with calls := s₃.calls.push ⟨scope, name, argValues, result⟩}) = .ok ((), s₆) at callRun + have stateEq := (Prod.mk.inj (Except.ok.inj callRun)).2 + subst s₆ + obtain ⟨callExtension, finalLayout⟩ := pushCall_scoped (destination_scoped destinationRun argsLayout) + ⟨scope, name, argValues, result⟩ (destinationExtension.scopeValid scopeValid) + exact ⟨destinationExtension.trans callExtension, finalLayout⟩ + | matchValue scrutinee arms => + obtain ⟨checked, s₁, checkRun, typeBind⟩ := bind_ok.mp stepRun + have stateEq := lift_unchanged checkRun + subst s₁ + obtain ⟨type, s₂, typeRun, scrutineeBind⟩ := bind_ok.mp typeBind + have stateEq := lift_unchanged typeRun + subst s₂ + obtain ⟨scrutineeWire, s₃, scrutineeRun, destinationBind⟩ := bind_ok.mp scrutineeBind + obtain ⟨result, s₄, destinationRun, choiceBind⟩ := bind_ok.mp destinationBind + obtain ⟨branches, s₆, choiceRun, armsBind⟩ := bind_ok.mp choiceBind + obtain ⟨⟨⟩, s₇, armsRun, pureRun⟩ := bind_ok.mp armsBind + obtain ⟨_, stateEq⟩ := pure_ok.mp pureRun + subst middle + obtain ⟨scrutineeExtension, scrutineeLayout⟩ := lower_scoped scrutineeRun scopeLayout scopeValid + have prefixExtension := scrutineeExtension.trans (destination_extends destinationRun) + have choicesExtension := prefixExtension.trans (choice_extends choiceRun) + obtain ⟨armsExtension, finalLayout⟩ := lowerArms_scoped armsRun + (choice_scoped choiceRun (destination_scoped destinationRun scrutineeLayout)) (choice_child_bound choiceRun) + exact ⟨choicesExtension.trans armsExtension, finalLayout⟩ + cases target with + | none => + obtain ⟨_, stateEq⟩ := pure_ok.mp finished + subst after + exact step + | some target => + obtain ⟨⟨⟩, last, equalRun, pureRun⟩ := bind_ok.mp finished + obtain ⟨_, stateEq⟩ := pure_ok.mp pureRun + subst after + obtain ⟨equalExtension, finalLayout⟩ := equalValue_structural equalRun step.2 (step.1.scopeValid scopeValid) + exact ⟨step.1.trans equalExtension, finalLayout⟩ + termination_by sizeOf expr + + theorem lowerArgs_scoped {program : Program F} {function : String} {locals : Locals F} + {scope : ScopeId} {args : List (Expr F)} {output : List (Symbolic F)} {before after : State F} + (compiled : lowerArgs program function locals scope args before = .ok (output, after)) + (scopeLayout : before.Scoped) (scopeValid : scope < before.scopes.size) : + before.Extends after ∧ after.Scoped := by + cases args with + | nil => + obtain ⟨_, stateEq⟩ := pure_ok.mp (by simpa only [lowerArgs] using compiled) + subst after + exact ⟨.refl _, scopeLayout⟩ + | cons arg rest => + simp only [lowerArgs] at compiled + obtain ⟨head, s₁, headRun, tailBind⟩ := bind_ok.mp compiled + obtain ⟨tail, s₂, tailRun, pureRun⟩ := bind_ok.mp tailBind + obtain ⟨_, stateEq⟩ := pure_ok.mp pureRun + subst after + obtain ⟨headExtension, headLayout⟩ := lower_scoped headRun scopeLayout scopeValid + obtain ⟨tailExtension, finalLayout⟩ := lowerArgs_scoped tailRun headLayout (headExtension.scopeValid scopeValid) + exact ⟨headExtension.trans tailExtension, finalLayout⟩ + termination_by sizeOf args + + theorem lowerArms_scoped {program : Program F} {function : String} {locals : Locals F} + {scrutinee : Symbolic F} {result : WireValue Witness} {branches : List ScopeId} + {arms : List (Pattern F × Expr F)} {previous : List (List (Polynomial F))} {before after : State F} + (compiled : lowerArms program function locals scrutinee result branches arms previous before = .ok ((), after)) + (scopeLayout : before.Scoped) (branchesValid : ∀ branch ∈ branches, branch < before.scopes.size) : + before.Extends after ∧ after.Scoped := by + cases branches with + | nil => + cases arms with + | nil => + obtain ⟨_, stateEq⟩ := pure_ok.mp (by simpa only [lowerArms] using compiled) + subst after + exact ⟨.refl _, scopeLayout⟩ + | cons => simp [lowerArms] at compiled + | cons branch branches => + cases arms with + | nil => simp [lowerArms] at compiled + | cons arm rest => + cases armEq : arm with + | mk pat body => + simp only [armEq, lowerArms] at compiled + obtain ⟨⟨conditions, bindings⟩, s₁, patternRun, equationsBind⟩ := bind_ok.mp compiled + have stateEq := pattern_unchanged patternRun + subst s₁ + obtain ⟨⟨⟩, s₂, equationsRun, failuresBind⟩ := bind_ok.mp equationsBind + obtain ⟨⟨⟩, s₃, failuresRun, bodyBind⟩ := bind_ok.mp failuresBind + obtain ⟨value, s₄, bodyRun, tailRun⟩ := bind_ok.mp bodyBind + have branchValid := branchesValid branch (by simp) + have equationsRun' : (do for condition in conditions do equation branch condition : Build F Unit) + before = .ok ((), s₂) := bind_ok.mpr ⟨PUnit.unit, s₂, equationsRun, rfl⟩ + have equationExtension := equations_grow equationsRun' + have equationLayout := equations_scoped equationsRun' scopeLayout branchValid + obtain ⟨failuresExtension, failuresLayout⟩ := forIn_scoped failuresRun equationLayout + (equationExtension.scopeValid branchValid) + (fun earlier _ {_ _} run layout bound => failure_scoped run layout bound) + have prefixExtension := equationExtension.trans failuresExtension + obtain ⟨bodyExtension, bodyLayout⟩ := lower_scoped bodyRun failuresLayout + (prefixExtension.scopeValid branchValid) + have armsExtension := prefixExtension.trans bodyExtension + split at tailRun + · obtain ⟨_, stateEq⟩ := pure_ok.mp tailRun + subst after + exact ⟨armsExtension, bodyLayout⟩ + · obtain ⟨tailExtension, finalLayout⟩ := lowerArms_scoped tailRun bodyLayout + (fun child member => armsExtension.scopeValid (branchesValid child (by simp [member]))) + exact ⟨armsExtension.trans tailExtension, finalLayout⟩ + termination_by sizeOf arms + decreasing_by all_goals simp_all only [List.cons.sizeOf_spec, Prod.mk.sizeOf_spec]; omega +end + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/ScopedPropagation.lean b/Aiur/Aiur/Optimized/ScopedPropagation.lean new file mode 100644 index 000000000..602fe1fc9 --- /dev/null +++ b/Aiur/Aiur/Optimized/ScopedPropagation.lean @@ -0,0 +1,231 @@ +import Aiur.Optimized.ControlCertificate +import Aiur.Optimized.AffineEquation + +namespace Aiur.Optimized.ScopedPropagation + +variable {F : Type} [Field F] [DecidableEq F] + +/-- Choose a simple affine equality. Search is untrusted: `fact?` checks the +actual equation before constructing a usable fact. -/ +def definition? (p : Polynomial F) : Option (Witness × Polynomial F) := Id.run do + for id in p.vars.eraseDups do + -- Structural failure is independent of the variable (`isolate_isSome_eq`). + -- Do not simplify the same nonlinear equation again for every variable. + let some (coefficient, rest) := p.isolate id | return none + if coefficient ≠ 0 then + let value := Polynomial.simplify (.mul (.const (-coefficient⁻¹)) rest) + if !value.vars.contains id && value.degree ≤ 1 then return some (id, value) + return none + +/-- A scope can use its own facts, root facts, and facts from a branch on its +path. The path is trusted only after checking the actual control equations. -/ +def available (chip : ScopedChip F) (owner current : ScopeId) : Bool := + owner == 0 || owner == current || + match chip.scopes[current]? with + | none => false + | some scope => scope.path.any fun tag => + ((chip.choices[tag.1]?).bind fun choice => choice.children[tag.2]?) == some owner + +/-- Control equations and the equalities used as facts remain unchanged. -/ +def keep (chip : ScopedChip F) (eq : Equation F) : Bool := + eq.scope == 0 || match definition? eq.polynomial with + | none => false + | some (id, _) => !chip.equations.any fun earlier => + earlier.scope < eq.scope && available chip earlier.scope eq.scope && + (definition? earlier.polynomial).any (fun other => other.1 == id) + +/-- Solve each equation once before checking which scope owns its definition. -/ +def definitions (chip : ScopedChip F) : Array (Equation F × Option (Witness × Polynomial F)) := + chip.equations.map fun eq => (eq, definition? eq.polynomial) + +@[noinline] def keepPrepared (chip : ScopedChip F) + (known : Array (Equation F × Option (Witness × Polynomial F))) (eq : Equation F) : Bool := + eq.scope == 0 || match definition? eq.polynomial with + | none => false + | some (id, _) => !known.any fun (earlier, definition) => + earlier.scope < eq.scope && available chip earlier.scope eq.scope && + definition.any (fun other => other.1 == id) + +@[simp] theorem keepPrepared_eq (chip : ScopedChip F) (eq : Equation F) : + keepPrepared chip (definitions chip) eq = keep chip eq := by + simp [keepPrepared, definitions, keep, Array.any_map, Function.comp_def] + +def anchors (chip : ScopedChip F) : ScopedChip F := + let known := definitions chip + { chip with equations := chip.equations.filter (keepPrepared chip known), cells := #[] } + +structure Fact (basis : ScopedChip F) where + scope : ScopeId + id : Witness + value : Polynomial F + sound : ∀ rom a, basis.ValidAssignment rom a → + (basis.activation scope).denote a ≠ 0 → a id = value.denote a + +def fact? (basis : ScopedChip F) (eq : Equation F) (member : eq ∈ basis.equations.toList) : + Option (Fact basis) := do + let (id, value) ← definition? eq.polynomial + if checked : eq.polynomial.solution? id = some value then + return ⟨eq.scope, id, value, fun _ a valid active => + Polynomial.solution?_sound checked a ((mul_eq_zero.mp (valid.1 eq member)).resolve_left active)⟩ + else none + +def facts (basis : ScopedChip F) : List (Fact basis) := + basis.equations.toList.attach.filterMap fun eq => fact? basis eq.val eq.property + +theorem available_active {chip : ScopedChip F} (checked : Control.Certificate chip) + {rom : WireROM F} {a : Witness → F} (valid : chip.ValidAssignment rom a) + {owner current : ScopeId} (found : available chip owner current = true) + (active : (chip.activation current).denote a ≠ 0) : (chip.activation owner).denote a ≠ 0 := by + simp only [available, Bool.or_eq_true, beq_iff_eq] at found + rcases found with (root | same) | inherited + · subst owner + rw [checked.1.denote] + exact one_ne_zero + · simpa [same] using active + · cases scopeFound : chip.scopes[current]? with + | none => simp [scopeFound] at inherited + | some scope => + simp only [scopeFound] at inherited + obtain ⟨tag, member, selected⟩ := List.any_eq_true.mp inherited + have selected := beq_iff_eq.mp selected + obtain ⟨choice, choiceFound, child, childFound, childActive⟩ := + checked.activePath valid scopeFound active tag member + simp only [choiceFound, Option.bind_some, childFound, Option.some.injEq] at selected + simpa [selected] using childActive + +def replacement {basis : ScopedChip F} (known : List (Fact basis)) (scope : ScopeId) + (id : Witness) : Polynomial F := + match known.find? (fun fact => fact.id == id && available basis fact.scope scope) with + | none => .var id + | some fact => fact.value + +theorem replacement_denote {basis : ScopedChip F} (checked : Control.Certificate basis) + (known : List (Fact basis)) {rom : WireROM F} {a : Witness → F} + (valid : basis.ValidAssignment rom a) {scope : ScopeId} + (active : (basis.activation scope).denote a ≠ 0) (id : Witness) : + (replacement known scope id).denote a = a id := by + unfold replacement + cases found : known.find? _ with + | none => rfl + | some fact => + have selected := List.find?_some found + obtain ⟨same, available⟩ := Bool.and_eq_true_iff.mp selected + have same : fact.id = id := beq_iff_eq.mp same + exact same ▸ (fact.sound rom a valid (available_active checked valid available active)).symm + +def expression {basis : ScopedChip F} (known : List (Fact basis)) (scope : ScopeId) + (p : Polynomial F) : Polynomial F := (p.subst (replacement known scope)).simplify + +theorem expression_denote {basis : ScopedChip F} (checked : Control.Certificate basis) + (known : List (Fact basis)) {rom : WireROM F} {a : Witness → F} + (valid : basis.ValidAssignment rom a) {scope : ScopeId} + (active : (basis.activation scope).denote a ≠ 0) (p : Polynomial F) : + (expression known scope p).denote a = p.denote a := by + simp only [expression, Polynomial.denote_simplify, Polynomial.denote_subst] + exact Polynomial.denote_congr p (fun id _ => replacement_denote checked known valid active id) + +def transform (chip : ScopedChip F) : ScopedChip F := + let known := definitions chip + let expr := expression (facts (anchors chip)) + { chip with + equations := chip.equations.map fun eq => + { eq with polynomial := if keepPrepared chip known eq then eq.polynomial else expr eq.scope eq.polynomial } + calls := chip.calls.map fun call => + { call with args := call.args.map (WireValue.map (expr call.scope)) } + cells := chip.cells.map fun cell => + { cell with address := expr cell.scope cell.address, value := cell.value.map (expr cell.scope) } } + +@[simp] theorem anchors_activation (chip : ScopedChip F) (scope : ScopeId) : + (anchors chip).activation scope = chip.activation scope := rfl + +@[simp] theorem transform_activation (chip : ScopedChip F) (scope : ScopeId) : + (transform chip).activation scope = chip.activation scope := rfl + +theorem anchors_of_source {chip : ScopedChip F} {rom : WireROM F} {a : Witness → F} + (valid : chip.ValidAssignment rom a) : (anchors chip).ValidAssignment rom a := by + refine ⟨?_, by simp [anchors]⟩ + intro eq member + have member : eq ∈ chip.equations.toList ∧ keep chip eq = true := by + simpa only [anchors, Array.toList_filter, List.mem_filter, keepPrepared_eq] using member + exact valid.1 eq member.1 + +theorem anchors_of_target {chip : ScopedChip F} {rom : WireROM F} {a : Witness → F} + (valid : (transform chip).ValidAssignment rom a) : (anchors chip).ValidAssignment rom a := by + refine ⟨?_, by simp [anchors]⟩ + intro eq member + have member : eq ∈ chip.equations.toList ∧ keep chip eq = true := by + simpa only [anchors, Array.toList_filter, List.mem_filter, keepPrepared_eq] using member + have present : eq ∈ (transform chip).equations.toList := by + simp only [transform, Array.toList_map, List.mem_map, keepPrepared_eq] + exact ⟨eq, member.1, by simp [member.2]⟩ + exact valid.1 eq present + +theorem valid_iff {chip : ScopedChip F} (checked : Control.Certificate (anchors chip)) + {rom : WireROM F} {a : Witness → F} (valid : (anchors chip).ValidAssignment rom a) : + (transform chip).ValidAssignment rom a ↔ chip.ValidAssignment rom a := by + have expr {scope : ScopeId} (active : (chip.activation scope).denote a ≠ 0) (p : Polynomial F) := + expression_denote checked (facts (anchors chip)) valid active p + unfold ScopedChip.ValidAssignment + simp only [transform, Array.toList_map, List.forall_mem_map, keepPrepared_eq] + apply and_congr + · apply forall_congr' + intro eq + apply forall_congr' + intro member + change (chip.activation eq.scope).denote a * + (if keep chip eq then eq.polynomial else + expression (facts (anchors chip)) eq.scope eq.polynomial).denote a = 0 ↔ _ + by_cases active : (chip.activation eq.scope).denote a = 0 + · simp [active] + · split + · rfl + · rw [expr active] + · apply forall_congr' + intro cell + apply forall_congr' + intro member + apply imp_congr_right + intro active + change (chip.activation cell.scope).denote a = 1 at active + have nonzero : (chip.activation cell.scope).denote a ≠ 0 := by rw [active]; exact one_ne_zero + simp only [WireValue.map_map, Function.comp_def, expr nonzero] + +theorem premises_eq {chip : ScopedChip F} (checked : Control.Certificate (anchors chip)) + {rom : WireROM F} {a : Witness → F} (valid : (anchors chip).ValidAssignment rom a) : + (transform chip).premises a = chip.premises a := by + simp only [ScopedChip.premises, transform, Array.toList_map, List.filterMap_map] + apply List.filterMap_congr + intro call member + change (if (chip.activation call.scope).denote a = 1 then _ else _) = _ + split + · rename_i active + have nonzero : (chip.activation call.scope).denote a ≠ 0 := by rw [active]; exact one_ne_zero + have args : call.args.map (WireValue.map (fun p => + (expression (facts (anchors chip)) call.scope p).denote a)) = + call.args.map (WireValue.map (Circuit.ArithExpr.denote a)) := by + apply List.map_congr_left + intro wire _ + exact WireValue.map_congr wire (fun p _ => expression_denote checked _ valid nonzero p) + simp only [Call.message, List.map_map, WireValue.map_map, Function.comp_def, args] + · rfl + +theorem equivalent (chip : ScopedChip F) (checked : Control.Certificate (anchors chip)) : + chip.Equivalent (transform chip) := by + constructor + · intro rom a valid + have basis := anchors_of_source valid + exact ⟨a, (valid_iff checked basis).mpr valid, rfl, premises_eq checked basis⟩ + · intro rom a valid + have basis := anchors_of_target valid + exact ⟨a, (valid_iff checked basis).mp valid, rfl, (premises_eq checked basis).symm⟩ + +def identity (chip : ScopedChip F) : Degree.Checked chip := + ⟨chip, ⟨fun _ a valid => ⟨a, valid, rfl, rfl⟩, + fun _ a valid => ⟨a, valid, rfl, rfl⟩⟩, rfl, rfl, rfl⟩ + +def run (chip : ScopedChip F) : Except String (Degree.Checked chip) := do + if checked : Control.Certificate (anchors chip) then + return ⟨transform chip, equivalent chip checked, rfl, rfl, rfl⟩ + else throw s!"invalid scoped-propagation control certificate in {chip.name}" + +end Aiur.Optimized.ScopedPropagation diff --git a/Aiur/Aiur/Optimized/ScopedSemantics.lean b/Aiur/Aiur/Optimized/ScopedSemantics.lean new file mode 100644 index 000000000..08cd0b25e --- /dev/null +++ b/Aiur/Aiur/Optimized/ScopedSemantics.lean @@ -0,0 +1,138 @@ +import Aiur.Optimized.Layout +import Aiur.Optimized.PolynomialFacts +import Aiur.Circuit.RowWitness + +namespace Aiur.Optimized + +variable {F : Type} [Field F] [DecidableEq F] + +def Call.message (call : Call F) (assignment : Witness → F) : Circuit.Message F := + ⟨call.channel, call.args.map (WireValue.map (Circuit.ArithExpr.denote assignment)), call.result.map assignment⟩ + +/-- Equations and ROM membership have no evaluation order. Calls are exposed +as premises rather than interpreted recursively at this boundary. -/ +def ScopedChip.ValidAssignment (chip : ScopedChip F) (rom : WireROM F) (assignment : Witness → F) : Prop := + (∀ equation ∈ chip.equations.toList, + (chip.activation equation.scope).denote assignment * equation.polynomial.denote assignment = 0) ∧ + (∀ cell ∈ chip.cells.toList, (chip.activation cell.scope).denote assignment = 1 → + (cell.address.denote assignment, cell.value.map (Circuit.ArithExpr.denote assignment)) ∈ rom.entries) + +def ScopedChip.conclusion (chip : ScopedChip F) (assignment : Witness → F) : Circuit.Message F := + ⟨chip.name, chip.inputs.map (WireValue.map assignment), chip.output.map assignment⟩ + +def ScopedChip.premises (chip : ScopedChip F) (assignment : Witness → F) : List (Circuit.Message F) := + chip.calls.toList.filterMap fun call => + if (chip.activation call.scope).denote assignment = 1 then some (call.message assignment) else none + +/-- Witness transport preserves every call occurrence and the same ROM. -/ +def ScopedChip.Refines (source target : ScopedChip F) : Prop := + ∀ rom assignment, source.ValidAssignment rom assignment → + ∃ translated, target.ValidAssignment rom translated ∧ + target.conclusion translated = source.conclusion assignment ∧ + target.premises translated = source.premises assignment + +def ScopedChip.Equivalent (source target : ScopedChip F) : Prop := + source.Refines target ∧ target.Refines source + +def ScopedChip.Rule (chip : ScopedChip F) (rom : WireROM F) + (conclusion : Circuit.Message F) (premises : List (Circuit.Message F)) : Prop := + ∃ assignment, chip.ValidAssignment rom assignment ∧ + chip.conclusion assignment = conclusion ∧ chip.premises assignment = premises + +theorem ScopedChip.Equivalent.rule_iff {source target : ScopedChip F} (same : source.Equivalent target) + (rom : WireROM F) (conclusion : Circuit.Message F) (premises : List (Circuit.Message F)) : + source.Rule rom conclusion premises ↔ target.Rule rom conclusion premises := by + constructor + · rintro ⟨a, valid, root, calls⟩ + obtain ⟨b, valid, root', calls'⟩ := same.1 rom a valid + exact ⟨b, valid, root'.trans root, calls'.trans calls⟩ + · rintro ⟨a, valid, root, calls⟩ + obtain ⟨b, valid, root', calls'⟩ := same.2 rom a valid + exact ⟨b, valid, root'.trans root, calls'.trans calls⟩ + +theorem ScopedChip.Refines.trans {first second third : ScopedChip F} + (left : first.Refines second) (right : second.Refines third) : first.Refines third := by + intro rom assignment valid + obtain ⟨middle, valid, conclusion, premises⟩ := left rom assignment valid + obtain ⟨last, valid, conclusion', premises'⟩ := right rom middle valid + exact ⟨last, valid, conclusion'.trans conclusion, premises'.trans premises⟩ + +theorem ScopedChip.Equivalent.trans {first second third : ScopedChip F} + (left : first.Equivalent second) (right : second.Equivalent third) : first.Equivalent third := + ⟨left.1.trans right.1, right.2.trans left.2⟩ + +@[simp] theorem ColumnLayout.expression_denote (layout : ColumnLayout) (expr : Polynomial F) + (assignment : Circuit.Var → F) : + (layout.expression expr).denote assignment = expr.denote (assignment ∘ layout.column) := by + simp [ColumnLayout.expression, Polynomial.denote_simplify, Polynomial.denote_subst, + Function.comp_def, Scalar.Circuit.ArithExpr.denote] + +private theorem discard_zero {α : Type} (xs : List α) (polynomial : α → Polynomial F) + (assignment : Witness → F) : + Circuit.Satisfies (xs.filterMap fun x => if polynomial x == .const 0 then none else some (polynomial x)) assignment ↔ + ∀ x ∈ xs, (polynomial x).denote assignment = 0 := by + constructor + · intro valid x member + by_cases zero : (polynomial x == .const 0) = true + · rw [(Polynomial.beq_eq _ _).mp zero] + rfl + · exact valid _ (List.mem_filterMap.mpr ⟨x, member, by simp [zero]⟩) + · intro valid p member + obtain ⟨x, inputMember, emitted⟩ := List.mem_filterMap.mp member + split at emitted + · contradiction + · cases emitted + exact valid x inputMember + +theorem emitChip_constraints (chip : ScopedChip F) (layout : ColumnLayout) (assignment : Witness → F) : + Circuit.Satisfies (emitChip chip layout).constraints assignment ↔ + ∀ equation ∈ chip.equations.toList, + (chip.activation equation.scope).denote (assignment ∘ layout.column) * + equation.polynomial.denote (assignment ∘ layout.column) = 0 := by + change Circuit.Satisfies (chip.equations.toList.filterMap _) assignment ↔ _ + rw [discard_zero] + simp only [Polynomial.denote_simplify, Circuit.ArithExpr.denote, + Scalar.Circuit.ArithExpr.denote] + change (∀ equation ∈ chip.equations.toList, + (layout.expression (chip.activation equation.scope)).denote assignment * + (layout.expression equation.polynomial).denote assignment = 0) ↔ _ + simp only [ColumnLayout.expression_denote] + +theorem emitChip_memory (chip : ScopedChip F) (layout : ColumnLayout) (rom : WireROM F) + (assignment : Witness → F) : + (∀ lookup ∈ (emitChip chip layout).memory, lookup.Valid rom assignment) ↔ + ∀ cell ∈ chip.cells.toList, + (chip.activation cell.scope).denote (assignment ∘ layout.column) = 1 → + (cell.address.denote (assignment ∘ layout.column), + cell.value.map (Circuit.ArithExpr.denote (assignment ∘ layout.column))) ∈ rom.entries := by + simp only [emitChip, Id.run, pure, Circuit.MemoryLookup.Valid, List.forall_mem_map] + simp only [ColumnLayout.expression_denote, WireValue.map_map, Function.comp_def] + +/-- Emission is exactly substitution of physical columns for logical witnesses, +even for layouts which share columns. This direction needs no ownership claim. -/ +theorem emitChip_validRow (chip : ScopedChip F) (layout : ColumnLayout) (rom : WireROM F) (row : Circuit.Row F) : + (emitChip chip layout).ValidRow rom row ↔ + (emitChip chip layout).wellFormed = true ∧ row.values.length = layout.occupants.size ∧ + chip.ValidAssignment rom (row.assignment ∘ layout.column) := by + unfold Circuit.Chip.ValidRow ScopedChip.ValidAssignment + rw [emitChip_constraints, emitChip_memory] + rfl + +theorem emitChip_receive (chip : ScopedChip F) (layout : ColumnLayout) (row : Circuit.Row F) : + (emitChip chip layout).receive row = chip.conclusion (row.assignment ∘ layout.column) := by + simp [emitChip, Circuit.Chip.receive, ScopedChip.conclusion, WireValue.map_map, List.map_map, + Function.comp_def, Scalar.Circuit.ArithExpr.denote] + +theorem emitChip_premises (chip : ScopedChip F) (layout : ColumnLayout) (row : Circuit.Row F) : + (emitChip chip layout).premises row = chip.premises (row.assignment ∘ layout.column) := by + simp only [emitChip, Id.run, pure, Circuit.Chip.premises, ScopedChip.premises, List.filterMap_map] + congr 1 + funext call + simp only [Function.comp_def, ColumnLayout.expression_denote] + split + · congr 1 + simp [Circuit.Send.message, Call.message, WireValue.map_map, List.map_map, + ColumnLayout.expression_denote, Function.comp_def] + · rfl + +end Aiur.Optimized diff --git a/Aiur/Aiur/Optimized/ScopedWitness.lean b/Aiur/Aiur/Optimized/ScopedWitness.lean new file mode 100644 index 000000000..f4ff4d367 --- /dev/null +++ b/Aiur/Aiur/Optimized/ScopedWitness.lean @@ -0,0 +1,129 @@ +import Aiur.Optimized.ChoiceWitness +import Aiur.Optimized.CompileFacts +import Aiur.Optimized.PatternWitness + +namespace Aiur.Optimized.Compiler + +variable {F : Type} [Field F] [DecidableEq F] +set_option maxHeartbeats 1000000 +set_option maxRecDepth 4096 + +theorem fresh_scoped {role : Role} {id : Witness} {before after : State F} + (compiled : fresh role before = .ok (id, after)) (scopeLayout : before.Scoped) : after.Scoped := by + obtain ⟨_, rfl⟩ := fresh_eq compiled + exact scopeLayout.fresh role + +theorem freshValue_scoped {decls : Declarations} {role : Role} {type : Ty} + {value : WireValue Witness} {before after : State F} + (compiled : freshValue decls role type before = .ok (value, after)) + (scopeLayout : before.Scoped) : after.Scoped := by + obtain ⟨scopes, equations, calls, cells⟩ := freshValue_preserves compiled + have grow : before.roles.size ≤ after.roles.size := by + obtain ⟨layout, _, _, stateEq⟩ := Circuit.Compiler.freshValue_eq (freshValue_reference compiled) + have sizeEq := congrArg Circuit.Compiler.BuildState.nextVar stateEq + change after.roles.size = before.roles.size + layout.width at sizeEq + omega + refine ⟨?_, ?_, ?_, ?_⟩ + · simpa [scopes, equations] using scopeLayout.equations + · simpa [scopes, calls] using scopeLayout.calls + · simpa [scopes, cells] using scopeLayout.cells + · intro scope member + rw [scopes] at member + exact Scalar.Circuit.ArithExpr.inBounds_mono grow (scopeLayout.activations scope member) + +theorem destination_scoped {decls : Declarations} {scope : ScopeId} {type : Ty} + {target : Option (WireValue Witness)} {value : WireValue Witness} {before after : State F} + (compiled : destination decls scope type target before = .ok (value, after)) + (scopeLayout : before.Scoped) : after.Scoped := by + cases target with + | none => exact freshValue_scoped compiled scopeLayout + | some target => + simp only [destination] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · obtain ⟨⟨⟩, middle, emptyRun, finished⟩ := bind_ok.mp compiled + obtain ⟨_, stateEq⟩ := pure_ok.mp emptyRun + subst middle + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + exact scopeLayout + +theorem equation_scoped {scope : ScopeId} {polynomial : Polynomial F} {before after : State F} + (compiled : equation scope polynomial before = .ok ((), after)) + (scopeLayout : before.Scoped) (scopeValid : scope < before.scopes.size) : after.Scoped := by + obtain rfl := equation_eq compiled + exact scopeLayout.equation scopeValid polynomial + +theorem equations_scoped {scope : ScopeId} {conditions : List (Polynomial F)} {before after : State F} + (compiled : (do for condition in conditions do equation scope condition : Build F Unit) + before = .ok ((), after)) + (scopeLayout : before.Scoped) (scopeValid : scope < before.scopes.size) : after.Scoped := by + induction conditions generalizing before with + | nil => + have same : before = after := by + simpa [List.forIn_nil, pure, StateT.pure, StateT.bind, bind, Except.bind, Except.pure] using compiled + exact same ▸ scopeLayout + | cons condition conditions ih => + simp [List.forIn_cons, equation, modify, modifyGet, MonadStateOf.modifyGet, StateT.modifyGet, + StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at compiled + exact ih (before := {before with equations := before.equations.push ⟨scope, condition⟩}) + compiled (scopeLayout.equation scopeValid condition) scopeValid + +theorem equalValue_scoped {scope : ScopeId} {left right : Symbolic F} {before after : State F} + (compiled : equalValue scope left right before = .ok ((), after)) + (scopeLayout : before.Scoped) (scopeValid : scope < before.scopes.size) : after.Scoped := by + simp only [equalValue] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + have equations : (do + for polynomial in (left.words.zip right.words).map (fun (a, b) => Polynomial.sub a b) do + equation scope polynomial : Build F Unit) before = .ok ((), after) := by + simpa only [List.forIn_map] using rest + exact equations_scoped equations scopeLayout scopeValid + +theorem equalValue_scopes {scope : ScopeId} {left right : Symbolic F} {before after : State F} + (compiled : equalValue scope left right before = .ok ((), after)) : after.scopes = before.scopes := by + simp only [equalValue] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + have equations : (do + for polynomial in (left.words.zip right.words).map (fun (a, b) => Polynomial.sub a b) do + equation scope polynomial : Build F Unit) before = .ok ((), after) := by + simpa only [List.forIn_map] using rest + exact equations_scopes equations + +theorem finish_scopes {scope : ScopeId} {target : Option (WireValue Witness)} {value output : Symbolic F} + {before after : State F} + (compiled : (do + if let some result := target then + equalValue scope (result.map Polynomial.var) value + return result.map Polynomial.var + return value : Build F (Symbolic F)) before = .ok (output, after)) : + after.scopes = before.scopes := by + cases target with + | none => + obtain ⟨rfl, rfl⟩ := pure_ok.mp compiled + rfl + | some result => + obtain ⟨⟨⟩, middle, equalRun, finished⟩ := bind_ok.mp compiled + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + exact equalValue_scopes equalRun + +theorem State.Extends.scopeValid {before after : State F} (extension : before.Extends after) + {scope : ScopeId} (scopeValid : scope < before.scopes.size) : scope < after.scopes.size := by + have found : before.scopes[scope]? = some before.scopes[scope] := by simp [scopeValid] + exact (Array.getElem?_eq_some_iff.mp (extension.scopes _ _ found)).1 + +theorem Extension.activation {rom : WireROM F} {calls : Circuit.CallRelation F} + {before after : State F} {initial assignment : Witness → F} + (extension : Extension rom calls before after initial assignment) + (structural : before.Extends after) (scopeLayout : before.Scoped) + {scope : ScopeId} (scopeValid : scope < before.scopes.size) : + (after.activation scope).denote assignment = (before.activation scope).denote initial := by + rw [structural.activation_eq scopeValid] + exact extension.polynomial (scopeLayout.activation_bound scope) + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/SemanticModel.lean b/Aiur/Aiur/Optimized/SemanticModel.lean new file mode 100644 index 000000000..ce05f6d8e --- /dev/null +++ b/Aiur/Aiur/Optimized/SemanticModel.lean @@ -0,0 +1,142 @@ +import Aiur.Optimized.LocalCorrectness +import Aiur.Optimized.LocalWitness +import Aiur.Optimized.MapFacts +import Aiur.Circuit.ProvenanceModel + +namespace Aiur.Optimized + +variable {F : Type} [Field F] [DecidableEq F] + +/-- Internal expressions preserve canonicality and store provenance. Only entry +arguments and fresh hints require validation. Physical layout preserves this +conditional local semantics. -/ +theorem compile_semanticModel {program : Program F} {entries : List String} {config : Config} {artifact : Artifact F} + (compiled : compile program entries config = .ok artifact) : artifact.unmerged.ProvenanceModel program := by + have stages := compile_stages compiled + have declarations := typecheck_declarations stages.1 + refine ⟨declarations, ?_, ?_, ?_, ?_⟩ + · intro rom rule signature found + cases rule with + | node chip row lookup valid => + obtain ⟨function, functionFound, lowered⟩ := compile_find_chip compiled lookup + have names : chip.name = row.chip := by simpa using List.find?_some lookup + have sourceSignature : program.findSignature? chip.name = some ⟨function.params, function.result⟩ := by + rw [names] + exact Program.signature_of_function functionFound + change program.findSignature? chip.name = some signature at found + obtain rfl := Option.some.inj (found.symm.trans sourceSignature) + simpa only [Circuit.RuleInstance.conclusion, Circuit.Chip.receive, List.map_map, + Function.comp_def, WireValue.type_map] using lowered.interface.2.1 + | table message member => + obtain ⟨args, constant, arguments, decoded, absent, looked⟩ := compile_map_spec compiled member + obtain ⟨map, _, mapFound, types, _, _, _, _⟩ := lookupMap_spec looked + have signatureFound := Program.signature_of_map absent mapFound + obtain rfl := Option.some.inj (found.symm.trans signatureFound) + exact arguments.types.symm.trans types.symm + · intro rom rule signature found + cases rule with + | node chip row lookup valid => + obtain ⟨function, functionFound, lowered⟩ := compile_find_chip compiled lookup + have names : chip.name = row.chip := by simpa using List.find?_some lookup + have sourceSignature : program.findSignature? chip.name = some ⟨function.params, function.result⟩ := by + rw [names] + exact Program.signature_of_function functionFound + change program.findSignature? chip.name = some signature at found + obtain rfl := Option.some.inj (found.symm.trans sourceSignature) + exact lowered.interface.2.2 + | table message member => + obtain ⟨args, constant, arguments, decoded, absent, looked⟩ := compile_map_spec compiled member + obtain ⟨map, _, mapFound, _, _, _, _, typed⟩ := lookupMap_spec looked + have signatureFound := Program.signature_of_map absent mapFound + obtain rfl := Option.some.inj (found.symm.trans signatureFound) + have resultType := (WireValue.decode_spec decoded).1 + simp only [Value.hasType, Bool.and_eq_true, decide_eq_true_eq] at typed + exact resultType.symm.trans (by simpa using typed.1) + · intro rom romValid rule calls premises callProvenance args arguments trusted + cases rule with + | node chip row lookup valid => + obtain ⟨function, found, lowered⟩ := compile_find_chip compiled lookup + have interface := lowered.interface + obtain ⟨logical, layout, lowered, laidOut, rfl⟩ := lowered + obtain ⟨assignment, logicalValid, conclusion, requires⟩ := + (layOut_correct laidOut rom (layout.chip.receive row) (layout.chip.premises row)).mpr + ⟨{row with chip := layout.chip.name}, rfl, valid, rfl, rfl⟩ + have logicalArguments : DecodesValues program.enums (logical.conclusion assignment).args args := by + simpa only [conclusion, Circuit.RuleInstance.conclusion] using arguments + obtain ⟨result, decoded, evaluated, resultTrusted⟩ := + Compiler.function_sound declarations stages.2.1 lowered romValid logicalValid (sourceCalls := calls) (by + intro premise member values argumentDecode trusted + exact premises premise (by simpa only [requires, Circuit.RuleInstance.premises] using member) values argumentDecode trusted) + callProvenance logicalArguments trusted + rw [conclusion] at decoded + refine ⟨result, decoded, ⟨_, _, ?_, evaluated⟩, resultTrusted⟩ + have types : function.params.map Prod.snd = args.map Value.type := by + rw [arguments.types] + simpa only [Circuit.RuleInstance.conclusion, Circuit.Chip.receive, List.map_map, Function.comp_def, WireValue.type_map] + using interface.2.1.symm + apply prepareCall_of_types (fn := function) ?_ types arguments.wellFormed + change program.findFunction? layout.chip.name = some function + rw [interface.1, Circuit.findFunction_name found] + exact found + | table message member => + obtain ⟨mapArgs, constant, mapArguments, decoded, absent, looked⟩ := compile_map_spec compiled member + have same := arguments.unique mapArguments + subst mapArgs + exact ⟨constant.toValue, decoded, + ⟨_, _, prepareCall_map absent looked, (ROMEvalExprWith.constant_iff constant).mpr rfl⟩, + .of_pointerFree constant.toValue (Constant.toValue_pointerFree constant)⟩ + · intro rom calls sourceCalls typed callComplete name args result step + obtain ⟨locals, body, prepared, evaluated⟩ := step + rcases prepareCall_spec prepared with function | table + · obtain ⟨function, found, types, formed, rfl, rfl⟩ := function + obtain ⟨chip, lookup, lowered⟩ := compile_find_function compiled found + have interface := lowered.interface + obtain ⟨logical, layout, lowered, laidOut, rfl⟩ := lowered + have checked := typecheck_function stages.1 (List.mem_of_find?_eq_some found) + obtain ⟨assignment, logicalValid, arguments, decoded, premises⟩ := + Compiler.function_complete declarations stages.2.1 lowered typed callComplete checked types formed evaluated + obtain ⟨row, rowName, valid, conclusion, requires⟩ := + (layOut_correct laidOut rom (logical.conclusion assignment) (logical.premises assignment)).mp + ⟨assignment, logicalValid, rfl, rfl⟩ + have functionName := Circuit.findFunction_name found + have rowLookup : artifact.unmerged.findChip? row.chip = some layout.chip := by + rw [rowName, interface.1, functionName] + exact lookup + refine ⟨.node layout.chip row rowLookup valid, interface.1.trans functionName, ?_, ?_, ?_⟩ + · simpa only [Circuit.RuleInstance.conclusion, conclusion] using arguments + · simpa only [Circuit.RuleInstance.conclusion, conclusion] using decoded + · simpa only [Circuit.RuleInstance.premises, requires] using premises + · obtain ⟨constant, _, looked, rfl, rfl⟩ := table + obtain rfl := (ROMEvalExprWith.constant_iff constant).mp evaluated + obtain ⟨wires, output, arguments, decoded, member⟩ := compile_map_lookup compiled looked + exact ⟨.table ⟨name, wires, output⟩ member, rfl, arguments, decoded, + by simp [Circuit.RuleInstance.premises]⟩ + +/-- Selected entry chips validate every argument, including unused ones. +Internal chips rely on the caller's canonical-value invariant instead. -/ +theorem compile_entry_arguments {program : Program F} {entries : List String} {config : Config} + {artifact : Artifact F} (compiled : compile program entries config = .ok artifact) + {rom : WireROM F} (rule : Circuit.RuleInstance artifact.unmerged rom) + (entry : rule.conclusion.channel ∈ entries) : + ∃ args, DecodesValues program.enums rule.conclusion.args args := by + cases rule with + | node chip row lookup valid => + obtain ⟨function, _, lowered⟩ := compile_find_chip compiled lookup + have interface := lowered.interface + obtain ⟨logical, layout, lowered, laidOut, rfl⟩ := lowered + have selected : entries.contains function.name = true := by + apply List.contains_iff_mem.mpr + simpa only [Circuit.RuleInstance.conclusion, Circuit.Chip.receive, interface.1] using entry + rw [selected] at lowered + obtain ⟨assignment, logicalValid, conclusion, _⟩ := + (layOut_correct laidOut rom (layout.chip.receive row) (layout.chip.premises row)).mpr + ⟨{row with chip := layout.chip.name}, rfl, valid, rfl, rfl⟩ + have stages := compile_stages compiled + obtain ⟨args, decoded⟩ := Compiler.function_arguments_sound + (typecheck_declarations stages.1) stages.2.1 lowered logicalValid + exact ⟨args, by simpa only [conclusion, Circuit.RuleInstance.conclusion] using decoded⟩ + | table message member => + obtain ⟨args, _, arguments, _⟩ := compile_map_spec compiled member + exact ⟨args, arguments⟩ + +end Aiur.Optimized diff --git a/Aiur/Aiur/Optimized/StateSemantics.lean b/Aiur/Aiur/Optimized/StateSemantics.lean new file mode 100644 index 000000000..f0970a999 --- /dev/null +++ b/Aiur/Aiur/Optimized/StateSemantics.lean @@ -0,0 +1,105 @@ +import Aiur.Optimized.BuildFacts +import Aiur.Optimized.ScopedSemantics + +namespace Aiur.Optimized.Compiler + +variable {F : Type} [Field F] [DecidableEq F] + +def State.activation (state : State F) (scope : ScopeId) : Polynomial F := + ((state.scopes[scope]?).map Scope.activation).getD (.const 0) + +/-- Local soundness interprets calls through an arbitrary relation, so the +same lemma can later be used for trees and for memoized graphs. -/ +def State.Valid (state : State F) (rom : WireROM F) (calls : Circuit.CallRelation F) + (assignment : Witness → F) : Prop := + (∀ equation ∈ state.equations.toList, + (state.activation equation.scope).denote assignment * equation.polynomial.denote assignment = 0) ∧ + (∀ call ∈ state.calls.toList, (state.activation call.scope).denote assignment = 1 → + calls call.channel (call.message assignment).args (call.message assignment).result) ∧ + (∀ cell ∈ state.cells.toList, (state.activation cell.scope).denote assignment = 1 → + (cell.address.denote assignment, cell.value.map (Circuit.ArithExpr.denote assignment)) ∈ rom.entries) + +structure State.Extends (before after : State F) : Prop where + scopes : ∀ (id : ScopeId) (scope : Scope F), before.scopes[id]? = some scope → after.scopes[id]? = some scope + equations : before.equations.toList ⊆ after.equations.toList + calls : before.calls.toList ⊆ after.calls.toList + cells : before.cells.toList ⊆ after.cells.toList + +theorem State.Extends.refl (state : State F) : state.Extends state := + ⟨fun _ _ => id, fun _ => id, fun _ => id, fun _ => id⟩ + +theorem State.Extends.trans {first second third : State F} (left : first.Extends second) + (right : second.Extends third) : first.Extends third := + ⟨fun i value found => right.scopes i value (left.scopes i value found), + fun _ member => right.equations (left.equations member), + fun _ member => right.calls (left.calls member), fun _ member => right.cells (left.cells member)⟩ + +theorem State.Extends.activation {before after : State F} (extension : before.Extends after) + {scope : ScopeId} {assignment : Witness → F} (active : (before.activation scope).denote assignment ≠ 0) : + after.activation scope = before.activation scope := by + cases found : before.scopes[scope]? with + | none => simp [State.activation, found, Scalar.Circuit.ArithExpr.denote] at active + | some value => simp only [State.activation, found, extension.scopes scope value found] + +theorem State.Valid.of_extends {before after : State F} (extension : before.Extends after) + {rom : WireROM F} {calls : Circuit.CallRelation F} {assignment : Witness → F} + (valid : after.Valid rom calls assignment) : before.Valid rom calls assignment := by + refine ⟨?_, ?_, ?_⟩ + · intro equation member + by_cases inactive : (before.activation equation.scope).denote assignment = 0 + · simp [inactive] + · rw [← extension.activation inactive] + exact valid.1 equation (extension.equations member) + · intro call member active + have nonzero : (before.activation call.scope).denote assignment ≠ 0 := by rw [active]; exact one_ne_zero + exact valid.2.1 call (extension.calls member) (by rw [extension.activation nonzero]; exact active) + · intro cell member active + have nonzero : (before.activation cell.scope).denote assignment ≠ 0 := by rw [active]; exact one_ne_zero + exact valid.2.2 cell (extension.cells member) (by rw [extension.activation nonzero]; exact active) + +theorem getScope_eq {scope : ScopeId} {value : Scope F} {before after : State F} + (compiled : getScope scope before = .ok (value, after)) : + before.scopes[scope]? = some value ∧ after = before := by + simp only [getScope] at compiled + obtain ⟨state, middle, getRun, rest⟩ := bind_ok.mp compiled + change Except.ok (before, before) = Except.ok (state, middle) at getRun + obtain ⟨rfl, rfl⟩ := Prod.mk.inj (Except.ok.inj getRun) + cases found : before.scopes[scope]? with + | none => simp [found] at rest + | some result => + simp [found] at rest + obtain ⟨rfl, rfl⟩ := rest + exact ⟨rfl, rfl⟩ + +theorem fresh_eq {role : Role} {id : Witness} {before after : State F} + (compiled : fresh role before = .ok (id, after)) : + id = before.roles.size ∧ after = {before with roles := before.roles.push role, aliases := before.aliases.push none} := by + change Except.ok (before.roles.size, {before with roles := before.roles.push role, aliases := before.aliases.push none}) = + Except.ok (id, after) at compiled + exact ⟨congrArg Prod.fst (Except.ok.inj compiled).symm, congrArg Prod.snd (Except.ok.inj compiled).symm⟩ + +theorem fresh_valid {role : Role} {id : Witness} {before after : State F} + (compiled : fresh role before = .ok (id, after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {assignment : Witness → F} + (valid : after.Valid rom calls assignment) : before.Valid rom calls assignment := by + obtain ⟨_, rfl⟩ := fresh_eq compiled + exact valid + +theorem equation_eq {scope : ScopeId} {polynomial : Polynomial F} {before after : State F} + (compiled : equation scope polynomial before = .ok ((), after)) : + after = {before with equations := before.equations.push ⟨scope, polynomial⟩} := by + change Except.ok ((), {before with equations := before.equations.push ⟨scope, polynomial⟩}) = + Except.ok ((), after) at compiled + exact congrArg Prod.snd (Except.ok.inj compiled).symm + +theorem equation_valid {scope : ScopeId} {polynomial : Polynomial F} {before after : State F} + (compiled : equation scope polynomial before = .ok ((), after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {assignment : Witness → F} + (valid : after.Valid rom calls assignment) : before.Valid rom calls assignment ∧ + (before.activation scope).denote assignment * polynomial.denote assignment = 0 := by + obtain rfl := equation_eq compiled + refine ⟨⟨?_, valid.2⟩, valid.1 ⟨scope, polynomial⟩ (by simp)⟩ + intro prior member + exact valid.1 prior (by simp [member]) + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/ValidationCorrectness.lean b/Aiur/Aiur/Optimized/ValidationCorrectness.lean new file mode 100644 index 000000000..efc361ea9 --- /dev/null +++ b/Aiur/Aiur/Optimized/ValidationCorrectness.lean @@ -0,0 +1,267 @@ +import Aiur.Optimized.PrimitiveCorrectness +import Aiur.Optimized.ChoiceFacts +import Aiur.LayoutShape +import Aiur.EncodingTypes + +namespace Aiur.Optimized.Compiler + +variable {F : Type} [Field F] [DecidableEq F] +set_option maxHeartbeats 2000000 +set_option maxRecDepth 4096 + +theorem State.Extends.active {before after : State F} (extension : before.Extends after) + {scope : ScopeId} {assignment : Witness → F} + (active : (before.activation scope).denote assignment = 1) : + (after.activation scope).denote assignment = 1 := by + rw [extension.activation (by rw [active]; exact one_ne_zero)] + exact active + +theorem equation_extends {scope : ScopeId} {polynomial : Polynomial F} {before after : State F} + (compiled : equation scope polynomial before = .ok ((), after)) : before.Extends after := by + obtain rfl := equation_eq compiled + exact ⟨fun _ _ => id, by simp, fun _ => id, fun _ => id⟩ + +theorem equations_extends {scope : ScopeId} {conditions : List (Polynomial F)} {before after : State F} + (compiled : (do for condition in conditions do equation scope condition : Build F Unit) + before = .ok ((), after)) : before.Extends after := by + induction conditions generalizing before with + | nil => + have same : before = after := by + simpa [List.forIn_nil, pure, StateT.pure, StateT.bind, bind, Except.bind, Except.pure] using compiled + subst after + exact .refl before + | cons condition conditions ih => + simp [List.forIn_cons, equation, modify, modifyGet, MonadStateOf.modifyGet, StateT.modifyGet, + StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at compiled + exact (equation_extends (scope := scope) (polynomial := condition) rfl).trans (ih compiled) + +mutual + theorem validate_sound {layout : Layout} (proper : layout.TuplePayloads) + (safe : layout.TagSafe F) {scope : ScopeId} {words : List (Polynomial F)} + {before after : State F} (compiled : validate scope layout words before = .ok ((), after)) : + before.Extends after ∧ ∀ (rom : WireROM F) (calls : Circuit.CallRelation F) (assignment : Witness → F), + (before.activation 0).denote assignment = 1 → after.Valid rom calls assignment → + before.Valid rom calls assignment ∧ ((before.activation scope).denote assignment = 1 → + ∃ value, layout.decode (words.map (Circuit.ArithExpr.denote assignment)) = some value) := by + cases layout with + | field => + cases words with + | nil => simp [validate] at compiled + | cons word rest => + cases rest with + | cons => simp [validate] at compiled + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp (by simpa only [validate] using compiled) + exact ⟨.refl _, fun _ _ assignment _ valid => ⟨valid, fun _ => + ⟨.field (word.denote assignment), by simp [Layout.decode]⟩⟩⟩ + | ptr target => + cases words with + | nil => simp [validate] at compiled + | cons word rest => + cases rest with + | cons => simp [validate] at compiled + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp (by simpa only [validate] using compiled) + exact ⟨.refl _, fun _ _ assignment _ valid => ⟨valid, fun _ => + ⟨.ptr target (word.denote assignment), by simp [Layout.decode]⟩⟩⟩ + | tuple layouts => + simp only [validate] at compiled + obtain ⟨extension, meaning⟩ := validateList_sound + (by simpa only [Layout.TuplePayloads] using proper) + (by simpa only [Layout.TagSafe] using safe) compiled + exact ⟨extension, fun rom calls assignment root valid => by + obtain ⟨previous, decoded⟩ := meaning rom calls assignment root valid + exact ⟨previous, fun active => by + obtain ⟨values, decoded⟩ := decoded active + exact ⟨.tuple values, by simp [Layout.decode, decoded]⟩⟩⟩ + | enum name constructors => + simp only [validate] at compiled + cases parts : Layout.enumParts constructors.length (.const 0) words with + | none => simp [parts] at compiled + | some pair => + rcases pair with ⟨tag, payload⟩ + simp only [parts] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · rename_i width + have width : payload.length = Layout.payloadWidth constructors := by simpa using width + obtain ⟨⟨⟩, unchangedState, unchanged, choiceBind⟩ := bind_ok.mp compiled + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst unchangedState + obtain ⟨branches, middle, choiceRun, ctorRun⟩ := bind_ok.mp choiceBind + have choiceExtension := choice_extends choiceRun + simp only [Layout.TagSafe] at safe + obtain ⟨ctorExtension, meaning⟩ := validateConstructors_sound + (by simpa only [Layout.TuplePayloads] using proper) safe.1 safe.2 ctorRun + refine ⟨choiceExtension.trans ctorExtension, fun rom calls assignment root valid => ?_⟩ + obtain ⟨middleValid, decoded⟩ := meaning rom calls assignment (choiceExtension.active root) valid + refine ⟨middleValid.of_extends choiceExtension, fun active => ?_⟩ + obtain ⟨branch, member, enabled⟩ := choice_active choiceRun middleValid root active + obtain ⟨_, _, _, _, ⟨ctor, args⟩, decoded⟩ := decoded branch member enabled + exact ⟨.construct name ctor args, by simp [Layout.decode, Circuit.Compiler.enumParts_denote parts assignment, width, decoded]⟩ + termination_by sizeOf layout + + theorem validateList_sound {layouts : List Layout} + (proper : ∀ layout ∈ layouts, layout.TuplePayloads) + (safe : ∀ layout ∈ layouts, layout.TagSafe F) + {scope : ScopeId} {words : List (Polynomial F)} {before after : State F} + (compiled : validateList scope layouts words before = .ok ((), after)) : + before.Extends after ∧ ∀ (rom : WireROM F) (calls : Circuit.CallRelation F) (assignment : Witness → F), + (before.activation 0).denote assignment = 1 → after.Valid rom calls assignment → + before.Valid rom calls assignment ∧ ((before.activation scope).denote assignment = 1 → + ∃ values, Layout.decodeList layouts (words.map (Circuit.ArithExpr.denote assignment)) = some values) := by + cases layouts with + | nil => + cases words with + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp (by simpa only [validateList] using compiled) + exact ⟨.refl _, fun _ _ _ _ valid => ⟨valid, fun _ => ⟨[], by simp [Layout.decodeList]⟩⟩⟩ + | cons => simp [validateList] at compiled + | cons layout layouts => + simp only [validateList] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · obtain ⟨⟨⟩, unchangedState, unchanged, validationBind⟩ := bind_ok.mp compiled + obtain ⟨_, stateEq⟩ := pure_ok.mp unchanged + subst unchangedState + obtain ⟨⟨⟩, middle, headRun, tailRun⟩ := bind_ok.mp validationBind + obtain ⟨headExtension, headMeaning⟩ := validate_sound + (proper _ (by simp)) (safe _ (by simp)) headRun + obtain ⟨tailExtension, tailMeaning⟩ := validateList_sound + (fun l h => proper l (by simp [h])) (fun l h => safe l (by simp [h])) tailRun + refine ⟨headExtension.trans tailExtension, fun rom calls assignment root valid => ?_⟩ + obtain ⟨middleValid, tails⟩ := tailMeaning rom calls assignment (headExtension.active root) valid + obtain ⟨previous, heads⟩ := headMeaning rom calls assignment root middleValid + refine ⟨previous, fun active => ?_⟩ + obtain ⟨head, headDecode⟩ := heads active + obtain ⟨tail, tailDecode⟩ := tails (headExtension.active active) + exact ⟨head :: tail, by simp [Layout.decodeList, ← List.map_take, ← List.map_drop, headDecode, tailDecode]⟩ + termination_by sizeOf layouts + + theorem validateConstructors_sound {constructors : List (String × Layout)} + (proper : ∀ pair ∈ constructors, (∃ layouts, pair.2 = .tuple layouts) ∧ pair.2.TuplePayloads) + {index : Nat} (tags : TagsDistinct F index constructors.length) + (safe : ∀ pair ∈ constructors, pair.2.TagSafe F) + {branches : List ScopeId} {tag : Polynomial F} {payload : List (Polynomial F)} + {before after : State F} + (compiled : validateConstructors constructors branches tag payload index before = .ok ((), after)) : + before.Extends after ∧ ∀ (rom : WireROM F) (calls : Circuit.CallRelation F) (assignment : Witness → F), + (before.activation 0).denote assignment = 1 → after.Valid rom calls assignment → + before.Valid rom calls assignment ∧ (∀ branch ∈ branches, + (before.activation branch).denote assignment = 1 → + ∃ actual, index ≤ actual ∧ actual < index + constructors.length ∧ + tag.denote assignment = (actual : F) ∧ + ∃ value, Layout.decodeConstructor constructors (tag.denote assignment) + (payload.map (Circuit.ArithExpr.denote assignment)) index = some value) := by + cases constructors with + | nil => + cases branches with + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp (by simpa only [validateConstructors] using compiled) + exact ⟨.refl _, fun _ _ _ _ valid => ⟨valid, by simp⟩⟩ + | cons => simp [validateConstructors] at compiled + | cons pair constructors => + rcases hpair : pair with ⟨name, layout⟩ + rw [hpair] at compiled tags proper safe + cases branches with + | nil => simp [validateConstructors] at compiled + | cons branch branches => + simp only [validateConstructors] at compiled + obtain ⟨⟨⟩, s₁, tagRun, validationBind⟩ := bind_ok.mp compiled + obtain ⟨⟨⟩, s₂, payloadRun, paddingBind⟩ := bind_ok.mp validationBind + obtain ⟨⟨⟩, s₃, paddingRun, tailRun⟩ := bind_ok.mp paddingBind + have tagExtension := equation_extends tagRun + obtain ⟨⟨layouts, tupleEq⟩, layoutProper⟩ := proper (name, layout) (by simp) + obtain ⟨payloadExtension, payloadMeaning⟩ := validate_sound + layoutProper (safe _ (by simp)) payloadRun + have paddingRun' : (do for word in payload.drop layout.width do equation branch word : Build F Unit) + s₂ = .ok ((), s₃) := bind_ok.mpr ⟨(), s₃, paddingRun, rfl⟩ + have paddingExtension := equations_extends paddingRun' + obtain ⟨tailExtension, tailMeaning⟩ := validateConstructors_sound + (fun p h => proper p (by simp [h])) tags.tail (fun p h => safe p (by simp [h])) tailRun + have beforePadding := tagExtension.trans payloadExtension + have beforeTail := beforePadding.trans paddingExtension + refine ⟨beforeTail.trans tailExtension, fun rom calls assignment root valid => ?_⟩ + obtain ⟨s₃valid, tails⟩ := tailMeaning rom calls assignment (beforeTail.active root) valid + obtain ⟨s₂valid, padding⟩ := equations_sound paddingRun' s₃valid + obtain ⟨s₁valid, payloads⟩ := payloadMeaning rom calls assignment (tagExtension.active root) s₂valid + obtain ⟨previous, tagEquation⟩ := equation_valid tagRun s₁valid + refine ⟨previous, fun selected member active => ?_⟩ + rcases List.mem_cons.mp member with rfl | member + · have tagEqual : tag.denote assignment = (index : F) := by + simpa only [active, Scalar.Circuit.ArithExpr.denote, one_mul, sub_eq_zero] using tagEquation + obtain ⟨value, decoded⟩ := payloads (tagExtension.active active) + have type := Layout.decode_type decoded + rw [tupleEq, Layout.type] at type + cases value with + | field | ptr | construct => simp [Value.type] at type + | tuple values => + have zeros : ((payload.map (Circuit.ArithExpr.denote assignment)).drop layout.width).all + (fun x => decide (x = 0)) = true := by + have zero : ∀ word ∈ payload.drop layout.width, word.denote assignment = 0 := by + intro word member + simpa only [beforePadding.active active, one_mul] using padding word member + simpa [← List.map_drop] using zero + exact ⟨index, le_rfl, by simp, tagEqual, (name, values), by + simp [Layout.decodeConstructor, tagEqual, ← List.map_take, decoded, zeros]⟩ + · obtain ⟨actual, lo, hi, tagEqual, value, decoded⟩ := tails selected member (beforeTail.active active) + have different : tag.denote assignment ≠ (index : F) := by + intro same + have equal := tags actual index (by omega) (by simp only [List.length_cons]; omega) + le_rfl (by simp) (tagEqual.symm.trans same) + omega + exact ⟨actual, by omega, by simp only [List.length_cons]; omega, tagEqual, + value, by simp [Layout.decodeConstructor, different, decoded]⟩ + termination_by sizeOf constructors + decreasing_by + all_goals simp_all only [List.cons.sizeOf_spec, Prod.mk.sizeOf_spec] + all_goals omega +end + +/-- An active validated interface decodes to a canonical typed source value. -/ +theorem validateValue_sound {decls : Declarations} (checked : checkDeclarations decls = .ok ()) + (tags : decls.tagsValid F = true) {scope : ScopeId} {wire : Symbolic F} {before after : State F} + (compiled : validateValue decls scope wire before = .ok ((), after)) : + before.Extends after ∧ ∀ (rom : WireROM F) (calls : Circuit.CallRelation F) (assignment : Witness → F), + (before.activation 0).denote assignment = 1 → after.Valid rom calls assignment → + before.Valid rom calls assignment ∧ ((before.activation scope).denote assignment = 1 → + ∃ value, (wire.map (Circuit.ArithExpr.denote assignment)).decode decls = some value) := by + simp only [validateValue] at compiled + obtain ⟨layout, middle, expanded, run⟩ := bind_ok.mp compiled + obtain ⟨expansion, stateEq⟩ := getLayout_eq expanded + subst middle + obtain ⟨extension, meaning⟩ := validate_sound (Declarations.layout_describes expansion).tuplePayloads + (Declarations.layout_tagSafe tags expansion) run + refine ⟨extension, fun rom calls assignment root valid => ?_⟩ + obtain ⟨previous, decoded⟩ := meaning rom calls assignment root valid + refine ⟨previous, fun active => ?_⟩ + obtain ⟨value, decoded⟩ := decoded active + exact ⟨value, WireValue.decode_of_layout (wire := wire.map (Circuit.ArithExpr.denote assignment)) + checked expansion decoded⟩ + +theorem validateValues_sound {decls : Declarations} (checked : checkDeclarations decls = .ok ()) + (tags : decls.tagsValid F = true) {scope : ScopeId} {wires : List (Symbolic F)} {before after : State F} + (compiled : (do for wire in wires do validateValue decls scope wire : Build F Unit) + before = .ok ((), after)) : + before.Extends after ∧ ∀ (rom : WireROM F) (calls : Circuit.CallRelation F) (assignment : Witness → F), + (before.activation 0).denote assignment = 1 → after.Valid rom calls assignment → + before.Valid rom calls assignment ∧ ((before.activation scope).denote assignment = 1 → + ∀ wire ∈ wires, ∃ value, (wire.map (Circuit.ArithExpr.denote assignment)).decode decls = some value) := by + induction wires generalizing before with + | nil => + have same : before = after := by + simpa [List.forIn_nil, pure, StateT.pure, StateT.bind, bind, Except.bind, Except.pure] using compiled + subst after + exact ⟨.refl _, fun _ _ _ _ valid => ⟨valid, by simp⟩⟩ + | cons wire wires ih => + simp only [List.forIn_cons, bind_assoc, pure_bind] at compiled + obtain ⟨⟨⟩, middle, headRun, tailRun⟩ := bind_ok.mp compiled + obtain ⟨headExtension, headMeaning⟩ := validateValue_sound checked tags headRun + obtain ⟨tailExtension, tailMeaning⟩ := ih tailRun + refine ⟨headExtension.trans tailExtension, fun rom calls assignment root valid => ?_⟩ + obtain ⟨middleValid, tail⟩ := tailMeaning rom calls assignment (headExtension.active root) valid + obtain ⟨previous, head⟩ := headMeaning rom calls assignment root middleValid + exact ⟨previous, fun active => by + simpa using And.intro (head active) (tail (headExtension.active active))⟩ + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/ValidationWitness.lean b/Aiur/Aiur/Optimized/ValidationWitness.lean new file mode 100644 index 000000000..6c72f6d1c --- /dev/null +++ b/Aiur/Aiur/Optimized/ValidationWitness.lean @@ -0,0 +1,446 @@ +import Aiur.Optimized.ScopedWitness +import Aiur.Optimized.ValidationCorrectness +import Aiur.Optimized.ScopedInvariant +import Aiur.LayoutValidation + +namespace Aiur.Optimized.Compiler + +variable {F : Type} [Field F] [DecidableEq F] +set_option maxHeartbeats 2500000 +set_option maxRecDepth 4096 + +private theorem tagTests_has_tag {count index : Nat} {tag : F} + (selected : (tagTests count tag index).sum = 1) : + ∃ i : Fin count, tag = ((index + i.val : Nat) : F) := by + induction count generalizing index with + | zero => simp [tagTests] at selected + | succ count ih => + by_cases equal : tag = (index : F) + · exact ⟨⟨0, by omega⟩, by simpa using equal⟩ + · have tail : (tagTests count tag (index + 1)).sum = 1 := by + simpa [tagTests, equal] using selected + obtain ⟨i, tagEq⟩ := ih tail + exact ⟨⟨i.val + 1, by omega⟩, by simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using tagEq⟩ + +private def ConstructorInputs (activation : ScopeId → F) (tag : F) (payload : List F) : + List (String × Layout) → List ScopeId → Nat → Prop + | [], [], _ => True + | (_, type) :: constructors, branch :: branches, index => + (activation branch = 0 ∨ activation branch = 1 ∧ tag = (index : F) ∧ + type.Admissible (payload.take type.width) ∧ ∀ word ∈ payload.drop type.width, word = 0) ∧ + ConstructorInputs activation tag payload constructors branches (index + 1) + | _, _, _ => False + +private theorem constructorInputs_congr {left right : ScopeId → F} {tag : F} {payload : List F} + {constructors : List (String × Layout)} {branches : List ScopeId} {index : Nat} + (same : ∀ branch ∈ branches, left branch = right branch) + (inputs : ConstructorInputs left tag payload constructors branches index) : + ConstructorInputs right tag payload constructors branches index := by + induction constructors generalizing branches index with + | nil => cases branches <;> simpa [ConstructorInputs] using inputs + | cons constructor constructors ih => + cases branches with + | nil => exact inputs + | cons branch branches => + obtain ⟨head, tail⟩ := inputs + exact ⟨by simpa only [same branch (by simp)] using head, + ih (fun b member => same b (by simp [member])) tail⟩ + +private theorem constructorInputs_of_admissible + {activation : ScopeId → F} {tag : F} {payload : List F} + {constructors : List (String × Layout)} {branches : List ScopeId} {index : Nat} + (sizeEq : branches.length = constructors.length) + (choices : ∀ (j : Nat) (bound : j < branches.length), + activation branches[j] = 0 ∨ activation branches[j] = 1 ∧ tag = ((index + j : Nat) : F)) + (admissible : Layout.AdmissibleConstructors constructors tag payload index) : + ConstructorInputs activation tag payload constructors branches index := by + induction constructors generalizing branches index with + | nil => + cases branches with + | nil => trivial + | cons => simp at sizeEq + | cons constructor constructors ih => + rcases constructor with ⟨name, type⟩ + cases branches with + | nil => simp at sizeEq + | cons branch branches => + simp only [Layout.AdmissibleConstructors] at admissible + refine ⟨?_, ih (by simpa using sizeEq) ?_ admissible.2⟩ + · rcases choices 0 (by simp) with inactive | ⟨active, tagEq⟩ + · exact Or.inl inactive + · have tagEq : tag = (index : F) := by simpa using tagEq + exact Or.inr ⟨active, tagEq, admissible.1 tagEq⟩ + · intro j bound + convert choices (j + 1) (by simp; omega) using 1 <;> + simp [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] <;> rfl + +private theorem constructorInputs_inactive + {activation : ScopeId → F} {tag : F} {payload : List F} + {constructors : List (String × Layout)} {branches : List ScopeId} {index : Nat} + (sizeEq : branches.length = constructors.length) + (inactive : ∀ branch ∈ branches, activation branch = 0) : + ConstructorInputs activation tag payload constructors branches index := by + induction constructors generalizing branches index with + | nil => + cases branches with + | nil => trivial + | cons => simp at sizeEq + | cons constructor constructors ih => + cases branches with + | nil => simp at sizeEq + | cons branch branches => + exact ⟨Or.inl (inactive branch (by simp)), + ih (by simpa using sizeEq) (fun b member => inactive b (by simp [member]))⟩ + +private theorem validation_choice_complete + {scope : ScopeId} {constructors : List (String × Layout)} {branches : List ScopeId} + {tag : Polynomial F} {payload : List (Polynomial F)} {before after : State F} + (compiled : choice scope constructors.length before = .ok (branches, after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (scopeLayout : before.Scoped) + (valid : before.Valid rom calls initial) + (tagBound : tag.inBounds before.roles.size = true) + (payloadBound : ∀ word ∈ payload, word.inBounds before.roles.size = true) + (acceptable : (before.activation scope).denote initial = 0 ∨ + (before.activation scope).denote initial = 1 ∧ + (tagTests constructors.length (tag.denote initial) 0).sum = 1 ∧ + Layout.AdmissibleConstructors constructors (tag.denote initial) + (payload.map (Circuit.ArithExpr.denote initial)) 0) : + ∃ assignment, Extension rom calls before after initial assignment ∧ + ConstructorInputs (fun branch => (after.activation branch).denote assignment) + (tag.denote assignment) (payload.map (Circuit.ArithExpr.denote assignment)) constructors branches 0 := by + have length := choice_length compiled + rcases acceptable with inactive | ⟨active, tagSum, admissible⟩ + · obtain ⟨a, ext, childValues⟩ := choice_complete compiled layout scopeLayout valid none + (by simpa using inactive) + refine ⟨a, ext, constructorInputs_inactive length ?_⟩ + intro branch member + obtain ⟨i, bound, rfl⟩ := List.mem_iff_getElem.mp member + simpa [choiceSelected] using childValues ⟨i, bound⟩ + · obtain ⟨selected, tagEq⟩ := tagTests_has_tag tagSum + obtain ⟨a, ext, childValues⟩ := choice_complete compiled layout scopeLayout valid (some selected) + (by simpa using active) + refine ⟨a, ext, ?_⟩ + rw [ext.polynomial tagBound, ext.words payloadBound] + apply constructorInputs_of_admissible length _ admissible + intro j bound + have child := childValues ⟨j, bound⟩ + by_cases selectedHere : selected.val = j + · right + refine ⟨?_, ?_⟩ + · simpa [choiceSelected, selectedHere] using child + · simpa [selectedHere] using tagEq + · left + simpa [choiceSelected, selectedHere] using child + +mutual + /-- Canonical words admit validation witnesses. Disabled values need no + canonical shape beyond the shape already accepted by compilation. -/ + theorem validate_complete {type : Layout} {scope : ScopeId} + {words : List (Polynomial F)} {before after : State F} + (compiled : validate scope type words before = .ok ((), after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (scopeLayout : before.Scoped) + (valid : before.Valid rom calls initial) (scopeValid : scope < before.scopes.size) + (bounded : ∀ word ∈ words, word.inBounds before.roles.size = true) + (admissible : (before.activation scope).denote initial = 0 ∨ + (before.activation scope).denote initial = 1 ∧ + type.Admissible (words.map (Circuit.ArithExpr.denote initial))) : + ∃ assignment, Extension rom calls before after initial assignment := by + cases type with + | field => + cases words with + | nil => simp [validate] at compiled + | cons word rest => cases rest with + | cons => simp [validate] at compiled + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp (by simpa only [validate] using compiled) + exact ⟨initial, .refl layout ((before.valid_iff_reference rom calls initial).mp valid)⟩ + | ptr target => + cases words with + | nil => simp [validate] at compiled + | cons word rest => cases rest with + | cons => simp [validate] at compiled + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp (by simpa only [validate] using compiled) + exact ⟨initial, .refl layout ((before.valid_iff_reference rom calls initial).mp valid)⟩ + | tuple layouts => + exact validateList_complete (by simpa only [validate] using compiled) layout scopeLayout valid + scopeValid bounded (by simpa only [Layout.Admissible] using admissible) + | enum name constructors => + simp only [validate] at compiled + cases parts : Layout.enumParts constructors.length (.const 0) words with + | none => simp [parts] at compiled + | some pair => + rcases pair with ⟨tag, payload⟩ + simp only [parts] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨branches, middle, choiceRun, constructorsRun⟩ := bind_ok.mp rest + obtain ⟨tagBound, payloadBound⟩ := Layout.enumParts_all parts (by rfl) bounded + have acceptable : (before.activation scope).denote initial = 0 ∨ + (before.activation scope).denote initial = 1 ∧ + (tagTests constructors.length (tag.denote initial) 0).sum = 1 ∧ + Layout.AdmissibleConstructors constructors (tag.denote initial) + (payload.map (Circuit.ArithExpr.denote initial)) 0 := by + rcases admissible with inactive | ⟨active, good⟩ + · exact Or.inl inactive + · simp only [Layout.Admissible, Nat.cast_zero, Circuit.Compiler.enumParts_denote parts initial] at good + exact Or.inr ⟨active, good.2⟩ + obtain ⟨a, choiceExt, selected⟩ := validation_choice_complete choiceRun layout scopeLayout valid + tagBound payloadBound acceptable + obtain ⟨b, constructorsExt⟩ := validateConstructors_complete constructorsRun choiceExt.layout + (choice_scoped choiceRun scopeLayout) choiceExt.validAssignment + (choice_child_bound choiceRun) (choiceExt.bound tagBound) + (fun p member => choiceExt.bound (payloadBound p member)) selected + exact ⟨b, choiceExt.trans constructorsExt⟩ + termination_by sizeOf type + + theorem validateList_complete {types : List Layout} {scope : ScopeId} + {words : List (Polynomial F)} {before after : State F} + (compiled : validateList scope types words before = .ok ((), after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (scopeLayout : before.Scoped) + (valid : before.Valid rom calls initial) (scopeValid : scope < before.scopes.size) + (bounded : ∀ word ∈ words, word.inBounds before.roles.size = true) + (admissible : (before.activation scope).denote initial = 0 ∨ + (before.activation scope).denote initial = 1 ∧ + Layout.AdmissibleList types (words.map (Circuit.ArithExpr.denote initial))) : + ∃ assignment, Extension rom calls before after initial assignment := by + cases types with + | nil => cases words with + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp (by simpa only [validateList] using compiled) + exact ⟨initial, .refl layout ((before.valid_iff_reference rom calls initial).mp valid)⟩ + | cons => simp [validateList] at compiled + | cons type types => + simp only [validateList] at compiled + split at compiled + · simp [StateT.bind, bind, Except.bind] at compiled + · obtain ⟨⟨⟩, middle, unchanged, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := pure_ok.mp unchanged + obtain ⟨⟨⟩, middle, headRun, tailRun⟩ := bind_ok.mp rest + have headBound : ∀ p ∈ words.take type.width, p.inBounds before.roles.size = true := + fun p member => bounded p (List.mem_of_mem_take member) + have tailBound : ∀ p ∈ words.drop type.width, p.inBounds before.roles.size = true := + fun p member => bounded p (List.mem_of_mem_drop member) + have headAdmissible : (before.activation scope).denote initial = 0 ∨ + (before.activation scope).denote initial = 1 ∧ + type.Admissible ((words.take type.width).map (Circuit.ArithExpr.denote initial)) := by + rcases admissible with inactive | ⟨active, good⟩ + · exact Or.inl inactive + · simp only [Layout.AdmissibleList] at good + exact Or.inr ⟨active, by simpa only [List.map_take] using good.1⟩ + obtain ⟨a, headExt⟩ := validate_complete headRun layout scopeLayout valid scopeValid headBound headAdmissible + obtain ⟨headStructure, headScoped⟩ := validate_scoped headRun scopeLayout scopeValid + have tailAdmissible : (middle.activation scope).denote a = 0 ∨ + (middle.activation scope).denote a = 1 ∧ + Layout.AdmissibleList types ((words.drop type.width).map (Circuit.ArithExpr.denote a)) := by + rw [headExt.activation headStructure scopeLayout scopeValid, headExt.words tailBound] + rcases admissible with inactive | ⟨active, good⟩ + · exact Or.inl inactive + · simp only [Layout.AdmissibleList] at good + exact Or.inr ⟨active, by simpa only [List.map_drop] using good.2⟩ + obtain ⟨b, tailExt⟩ := validateList_complete tailRun headExt.layout headScoped headExt.validAssignment + (headStructure.scopeValid scopeValid) (fun p member => headExt.bound (tailBound p member)) tailAdmissible + exact ⟨b, headExt.trans tailExt⟩ + termination_by sizeOf types + + private theorem validateConstructors_complete + {constructors : List (String × Layout)} {branches : List ScopeId} {tag : Polynomial F} + {payload : List (Polynomial F)} {index : Nat} {before after : State F} + (compiled : validateConstructors constructors branches tag payload index before = .ok ((), after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (scopeLayout : before.Scoped) + (valid : before.Valid rom calls initial) + (branchesValid : ∀ branch ∈ branches, branch < before.scopes.size) + (tagBound : tag.inBounds before.roles.size = true) + (bounded : ∀ word ∈ payload, word.inBounds before.roles.size = true) + (inputs : ConstructorInputs (fun branch => (before.activation branch).denote initial) + (tag.denote initial) (payload.map (Circuit.ArithExpr.denote initial)) constructors branches index) : + ∃ assignment, Extension rom calls before after initial assignment := by + cases constructors with + | nil => cases branches with + | nil => + obtain ⟨_, rfl⟩ := pure_ok.mp (by simpa only [validateConstructors] using compiled) + exact ⟨initial, .refl layout ((before.valid_iff_reference rom calls initial).mp valid)⟩ + | cons => simp [validateConstructors] at compiled + | cons pair constructors => + rcases hpair : pair with ⟨name, type⟩ + rw [hpair] at compiled inputs + cases branches with + | nil => simp [validateConstructors] at compiled + | cons branch branches => + simp only [validateConstructors] at compiled + obtain ⟨⟨⟩, afterTag, tagRun, afterTagBind⟩ := bind_ok.mp compiled + obtain ⟨⟨⟩, afterValue, valueRun, afterValueBind⟩ := bind_ok.mp afterTagBind + obtain ⟨⟨⟩, afterPadding, paddingRun, tailRun⟩ := bind_ok.mp afterValueBind + obtain ⟨head, tail⟩ := inputs + have branchValid := branchesValid branch (by simp) + have tagExt := equation_complete tagRun layout valid (by + simp [Scalar.Circuit.ArithExpr.inBounds, scopeLayout.activation_bound branch, tagBound]) (by + rcases head with inactive | ⟨active, tagEq, _⟩ + · simp [inactive] + · simp [Scalar.Circuit.ArithExpr.denote, tagEq]) + have tagState := equation_eq tagRun + subst afterTag + have tagScoped := scopeLayout.equation branchValid (.sub tag (.const (index : F))) + have valueBound : ∀ p ∈ payload.take type.width, p.inBounds before.roles.size = true := + fun p member => bounded p (List.mem_of_mem_take member) + have paddingBound : ∀ p ∈ payload.drop type.width, p.inBounds before.roles.size = true := + fun p member => bounded p (List.mem_of_mem_drop member) + have valueAdmissible : (before.activation branch).denote initial = 0 ∨ + (before.activation branch).denote initial = 1 ∧ + type.Admissible ((payload.take type.width).map (Circuit.ArithExpr.denote initial)) := by + rcases head with inactive | ⟨active, _, good, _⟩ + · exact Or.inl inactive + · exact Or.inr ⟨active, by simpa only [List.map_take] using good⟩ + obtain ⟨a, valueExt⟩ := validate_complete valueRun tagExt.layout tagScoped tagExt.validAssignment + branchValid valueBound valueAdmissible + obtain ⟨valueStructure, valueScoped⟩ := validate_scoped valueRun tagScoped branchValid + have untilValue := tagExt.trans valueExt + have activation := valueExt.activation valueStructure tagScoped branchValid + have paddingZero : (afterValue.activation branch).denote a = 0 ∨ + ∀ p ∈ payload.drop type.width, p.denote a = 0 := by + rw [activation] + rcases head with inactive | ⟨_, _, _, zeros⟩ + · exact Or.inl inactive + · right + intro p member + rw [untilValue.polynomial (paddingBound p member)] + apply zeros + rw [← List.map_drop] + exact List.mem_map.mpr ⟨p, member, rfl⟩ + have paddingRun' : (do for p in payload.drop type.width do equation branch p : Build F Unit) + afterValue = .ok ((), afterPadding) := bind_ok.mpr ⟨PUnit.unit, afterPadding, paddingRun, rfl⟩ + have paddingExt := equations_complete paddingRun' valueExt.layout valueExt.validAssignment + (valueScoped.activation_bound branch) (fun p member => untilValue.bound (paddingBound p member)) paddingZero + have paddingScoped := equations_scoped paddingRun' valueScoped (valueStructure.scopeValid branchValid) + have paddingScopes := equations_scopes paddingRun' + have throughPadding := untilValue.trans paddingExt + have tailValid : ∀ b ∈ branches, b < afterPadding.scopes.size := by + intro b member + rw [paddingScopes] + exact valueStructure.scopeValid (branchesValid b (by simp [member])) + have tailInputs : ConstructorInputs (fun b => (afterPadding.activation b).denote a) + (tag.denote a) (payload.map (Circuit.ArithExpr.denote a)) constructors branches (index + 1) := by + rw [throughPadding.polynomial tagBound, throughPadding.words bounded] + apply constructorInputs_congr _ tail + intro b member + have bValid := branchesValid b (by simp [member]) + have same := valueExt.activation valueStructure tagScoped bValid + simpa only [State.activation, paddingScopes] using same.symm + obtain ⟨b, tailExt⟩ := validateConstructors_complete tailRun throughPadding.layout paddingScoped + (Extension.validAssignment throughPadding) tailValid (throughPadding.bound tagBound) + (fun p member => throughPadding.bound (bounded p member)) tailInputs + exact ⟨b, throughPadding.trans tailExt⟩ + termination_by sizeOf constructors + decreasing_by + all_goals simp_all only [List.cons.sizeOf_spec, Prod.mk.sizeOf_spec] + all_goals omega +end + +theorem validateValue_complete {decls : Declarations} (tags : decls.tagsValid F = true) + {scope : ScopeId} {wire : Symbolic F} {before after : State F} + (compiled : validateValue decls scope wire before = .ok ((), after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (scopeLayout : before.Scoped) + (valid : before.Valid rom calls initial) (scopeValid : scope < before.scopes.size) + (bounded : Circuit.Compiler.Bounded before.roles.size wire) + (decodable : (before.activation scope).denote initial = 0 ∨ + (before.activation scope).denote initial = 1 ∧ + ∃ value, (wire.map (Circuit.ArithExpr.denote initial)).decode decls = some value) : + ∃ assignment, Extension rom calls before after initial assignment := by + simp only [validateValue] at compiled + obtain ⟨type, middle, expanded, run⟩ := bind_ok.mp compiled + obtain ⟨expansion, stateEq⟩ := getLayout_eq expanded + subst middle + apply validate_complete run layout scopeLayout valid scopeValid bounded + rcases decodable with inactive | ⟨active, value, decoded⟩ + · exact Or.inl inactive + · obtain ⟨_, _, other, found, decoded⟩ := WireValue.decode_spec decoded + simp only [WireValue.type_map, expansion, Except.ok.injEq] at found + subst other + exact Or.inr ⟨active, Layout.decode_admissible (Declarations.layout_tagSafe tags expansion) decoded⟩ + +theorem validateValue_inactive {decls : Declarations} + {scope : ScopeId} {wire : Symbolic F} {before after : State F} + (compiled : validateValue decls scope wire before = .ok ((), after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (scopeLayout : before.Scoped) + (valid : before.Valid rom calls initial) (scopeValid : scope < before.scopes.size) + (bounded : Circuit.Compiler.Bounded before.roles.size wire) + (inactive : (before.activation scope).denote initial = 0) : + ∃ assignment, Extension rom calls before after initial assignment := by + simp only [validateValue] at compiled + obtain ⟨type, middle, expanded, run⟩ := bind_ok.mp compiled + obtain ⟨_, stateEq⟩ := getLayout_eq expanded + subst middle + exact validate_complete run layout scopeLayout valid scopeValid bounded (Or.inl inactive) + +theorem validateValues_complete {decls : Declarations} (tags : decls.tagsValid F = true) + {scope : ScopeId} {wires : List (Symbolic F)} {before after : State F} + (compiled : (do for wire in wires do validateValue decls scope wire : Build F Unit) + before = .ok ((), after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (scopeLayout : before.Scoped) + (valid : before.Valid rom calls initial) (scopeValid : scope < before.scopes.size) + (bounded : ∀ wire ∈ wires, Circuit.Compiler.Bounded before.roles.size wire) + (decodable : (before.activation scope).denote initial = 0 ∨ + (before.activation scope).denote initial = 1 ∧ + ∀ wire ∈ wires, ∃ value, (wire.map (Circuit.ArithExpr.denote initial)).decode decls = some value) : + ∃ assignment, Extension rom calls before after initial assignment := by + induction wires generalizing before initial with + | nil => + have same : before = after := by + simpa [List.forIn_nil, pure, StateT.pure, StateT.bind, bind, Except.bind, Except.pure] using compiled + subst after + exact ⟨initial, .refl layout ((before.valid_iff_reference rom calls initial).mp valid)⟩ + | cons wire wires ih => + simp only [List.forIn_cons, bind_assoc, pure_bind] at compiled + obtain ⟨⟨⟩, middle, headRun, tailRun⟩ := bind_ok.mp compiled + obtain ⟨a, headExt⟩ := validateValue_complete tags headRun layout scopeLayout valid scopeValid + (bounded wire (by simp)) (decodable.imp_right (fun h => ⟨h.1, h.2 wire (by simp)⟩)) + obtain ⟨headStructure, headScoped⟩ := validateValue_scoped headRun scopeLayout scopeValid + obtain ⟨b, tailExt⟩ := ih tailRun headExt.layout headScoped headExt.validAssignment + (headStructure.scopeValid scopeValid) (fun w member => (bounded w (by simp [member])).mono headExt.increase) (by + rw [headExt.activation headStructure scopeLayout scopeValid] + rcases decodable with inactive | ⟨active, good⟩ + · exact Or.inl inactive + · right + refine ⟨active, ?_⟩ + intro w member + rw [headExt.value (bounded w (by simp [member]))] + exact good w (by simp [member])) + exact ⟨b, headExt.trans tailExt⟩ + +theorem validateValues_inactive {decls : Declarations} + {scope : ScopeId} {wires : List (Symbolic F)} {before after : State F} + (compiled : (do for wire in wires do validateValue decls scope wire : Build F Unit) + before = .ok ((), after)) + {rom : WireROM F} {calls : Circuit.CallRelation F} {initial : Witness → F} + (layout : before.toReference.WellFormed) (scopeLayout : before.Scoped) + (valid : before.Valid rom calls initial) (scopeValid : scope < before.scopes.size) + (bounded : ∀ wire ∈ wires, Circuit.Compiler.Bounded before.roles.size wire) + (inactive : (before.activation scope).denote initial = 0) : + ∃ assignment, Extension rom calls before after initial assignment := by + induction wires generalizing before initial with + | nil => + have same : before = after := by + simpa [List.forIn_nil, pure, StateT.pure, StateT.bind, bind, Except.bind, Except.pure] using compiled + subst after + exact ⟨initial, .refl layout ((before.valid_iff_reference rom calls initial).mp valid)⟩ + | cons wire wires ih => + simp only [List.forIn_cons, bind_assoc, pure_bind] at compiled + obtain ⟨⟨⟩, middle, headRun, tailRun⟩ := bind_ok.mp compiled + obtain ⟨a, headExt⟩ := validateValue_inactive headRun layout scopeLayout valid scopeValid + (bounded wire (by simp)) inactive + obtain ⟨headStructure, headScoped⟩ := validateValue_scoped headRun scopeLayout scopeValid + obtain ⟨b, tailExt⟩ := ih tailRun headExt.layout headScoped headExt.validAssignment + (headStructure.scopeValid scopeValid) (fun w member => (bounded w (by simp [member])).mono headExt.increase) + ((headExt.activation headStructure scopeLayout scopeValid).trans inactive) + exact ⟨b, headExt.trans tailExt⟩ + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/Optimized/WitnessContext.lean b/Aiur/Aiur/Optimized/WitnessContext.lean new file mode 100644 index 000000000..1162fdeb2 --- /dev/null +++ b/Aiur/Aiur/Optimized/WitnessContext.lean @@ -0,0 +1,46 @@ +import Aiur.Optimized.ValidationWitness +import Aiur.Circuit.ExpressionWitness + +namespace Aiur.Optimized.Compiler + +variable {F : Type} [Field F] [DecidableEq F] +open Circuit.Compiler (Bounded LocalsBounded localsEnvironment) + +def TargetBound (bound : Nat) (target : Option (WireValue Witness)) : Prop := + ∀ candidate, target = some candidate → Bounded (F := F) bound (candidate.map Polynomial.var) + +def TargetDecodes (decls : Declarations) (target : Option (WireValue Witness)) + (assignment : Witness → F) (value : Value F) : Prop := + ∀ candidate, target = some candidate → (candidate.map assignment).decode decls = some value + +theorem TargetBound.mono {target : Option (WireValue Witness)} {before after : Nat} + (bounded : TargetBound (F := F) before target) (grow : before ≤ after) : TargetBound (F := F) after target := + fun candidate found => (bounded candidate found).mono grow + +theorem Extension.targetDecode {rom : WireROM F} {calls : Circuit.CallRelation F} + {before after : State F} {initial assignment : Witness → F} + (extension : Extension rom calls before after initial assignment) + {decls : Declarations} {target : Option (WireValue Witness)} {value : Value F} + (bounded : TargetBound (F := F) before.roles.size target) + (decoded : TargetDecodes decls target initial value) : TargetDecodes decls target assignment value := by + intro candidate found + rw [extension.variables (bounded candidate found)] + exact decoded candidate found + +/-- The induction hypothesis consumed by the branch witness construction. -/ +def ExprComplete (program : Program F) (sourceCalls : Aiur.CallRelation F) + (calls : Circuit.CallRelation F) (function : String) (expr : Expr F) : Prop := + ∀ {locals : Locals F} {scope : ScopeId} {target : Option (WireValue Witness)} + {output : Symbolic F} {before after : State F}, + lower program function locals scope expr target before = .ok (output, after) → + ∀ {rom : WireROM F} {initial : Witness → F}, + before.toReference.WellFormed → before.Scoped → before.Valid rom calls initial → scope < before.scopes.size → + LocalsBounded before.roles.size locals → TargetBound (F := F) before.roles.size target → + (before.activation scope).denote initial = 1 → ∀ {environment : Environment F}, + DecodesEnvironment program.enums (localsEnvironment locals initial) environment → ∀ {value : Value F}, + TargetDecodes program.enums target initial value → + ROMEvalExprWith program.enums (rom.decode program.enums) sourceCalls environment expr value → + ∃ assignment, Extension rom calls before after initial assignment ∧ Bounded after.roles.size output ∧ + (output.map (Circuit.ArithExpr.denote assignment)).decode program.enums = some value + +end Aiur.Optimized.Compiler diff --git a/Aiur/Aiur/PatternTyping.lean b/Aiur/Aiur/PatternTyping.lean new file mode 100644 index 000000000..0091e4784 --- /dev/null +++ b/Aiur/Aiur/PatternTyping.lean @@ -0,0 +1,143 @@ +import Aiur.ValueFormed + +namespace Aiur + +variable {F : Type} + +def environmentTypes (locals : Environment F A) : List (String × Ty) := + locals.map fun binding => (binding.1, binding.2.type) + +@[simp] theorem environmentTypes_append (left right : Environment F A) : + environmentTypes (left ++ right) = environmentTypes left ++ environmentTypes right := List.map_append + +theorem requireType_ok {caller : String} {expected actual : Ty} + (checked : requireType caller expected actual = .ok ()) : expected = actual := by + simpa [requireType] using checked + +theorem checkPattern_types {decls : Declarations} {caller : String} {pattern : Pattern F} {type : Ty} + {bindings : List (String × Ty)} (checked : checkPattern decls caller pattern type = .ok bindings) : + patternTypes decls caller pattern type = .ok bindings := by + unfold checkPattern at checked + obtain ⟨types, typed, rest⟩ := except_bind_ok.mp checked + split at rest + · cases rest + · simp only [pure_bind, except_pure_ok] at rest + subst bindings + exact typed + +mutual + /-- Matching collects exactly the binding types computed by the typechecker. -/ + theorem patternTypes_bindings [DecidableEq F] {decls : Declarations} {caller : String} {pattern : Pattern F} + {value : Value F A} {types : List (String × Ty)} {bindings : Environment F A} + (checked : patternTypes decls caller pattern value.type = .ok types) + (formed : value.wellFormed decls = true) + (matched : pattern.bindings value = some bindings) : environmentTypes bindings = types := by + cases pattern with + | wildcard => + simp only [patternTypes, except_pure_ok] at checked + simp only [Pattern.bindings, Option.some.injEq] at matched + subst types; subst bindings; rfl + | bind name => + simp only [patternTypes, except_pure_ok] at checked + simp only [Pattern.bindings, Option.some.injEq] at matched + subst types; subst bindings; rfl + | literal literal => + cases value with + | tuple values | ptr | construct => simp [Pattern.bindings] at matched + | field value => + simp [patternTypes, Value.type, requireType, bind, Except.bind, pure, Except.pure] at checked + subst types + simp only [Pattern.bindings] at matched + split at matched + · cases matched; rfl + · cases matched + | tuple patterns => + cases value with + | field | ptr | construct => simp [Pattern.bindings] at matched + | tuple values => + simp only [Pattern.bindings] at matched + simp only [patternTypes, Value.type] at checked + split at checked + · cases checked + · simp only [pure_bind] at checked + exact patternTypesList_bindings checked ((Value.wellFormed_tuple _ _).mp formed) matched + | construct name ctor patterns => + cases value with + | field | ptr | tuple => simp [Pattern.bindings] at matched + | construct actual actualCtor values => + simp only [Pattern.bindings] at matched + split at matched + · rename_i same + rcases same with ⟨rfl, rfl⟩ + obtain ⟨definition, found, shapes, valuesFormed⟩ := + (Value.wellFormed_construct _ _ _ _).mp formed + simp only [patternTypes, Value.type, requireType, ↓reduceIte, pure_bind, found] at checked + split at checked + · cases checked + · rw [← shapes] at checked + exact patternTypesList_bindings checked valuesFormed matched + · cases matched + termination_by sizeOf pattern + + theorem patternTypesList_bindings [DecidableEq F] {decls : Declarations} {caller : String} + {patterns : List (Pattern F)} {values : List (Value F A)} + {types : List (String × Ty)} {bindings : Environment F A} + (checked : patternTypesList decls caller patterns (values.map Value.type) = .ok types) + (formed : ∀ value ∈ values, value.wellFormed decls = true) + (matched : Pattern.bindingsList patterns values = some bindings) : environmentTypes bindings = types := by + cases patterns with + | nil => + cases values with + | nil => + simp only [patternTypesList, List.map_nil, except_pure_ok] at checked + simp only [Pattern.bindingsList, Option.some.injEq] at matched + subst types; subst bindings; rfl + | cons => simp [Pattern.bindingsList] at matched + | cons pattern patterns => + cases values with + | nil => simp [Pattern.bindingsList] at matched + | cons value values => + simp only [patternTypesList, List.map_cons] at checked + obtain ⟨headTypes, headRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨tailTypes, tailRun, finished⟩ := except_bind_ok.mp rest + obtain rfl := except_pure_ok.mp finished + cases headMatch : pattern.bindings value with + | none => simp [Pattern.bindingsList, headMatch] at matched + | some headBindings => + cases tailMatch : Pattern.bindingsList patterns values with + | none => simp [Pattern.bindingsList, headMatch, tailMatch] at matched + | some tailBindings => + simp [Pattern.bindingsList, headMatch, tailMatch] at matched + subst bindings + rw [environmentTypes_append, patternTypes_bindings headRun (formed _ (by simp)) headMatch, + patternTypesList_bindings tailRun (fun v h => formed v (by simp [h])) tailMatch] + termination_by sizeOf patterns +end + +theorem checkArms_selected [DecidableEq F] {program : Program F} {caller : String} + {locals : List (String × Ty)} {value : Value F A} {type : Ty} + {arms : List (Pattern F × Expr F)} {bindings : Environment F A} {body : Expr F} + (checked : checkArms program caller locals value.type type arms = .ok ()) + (formed : value.wellFormed program.enums = true) + (selected : selectArm value arms = some (bindings, body)) : + inferType program caller (environmentTypes bindings ++ locals) body = .ok type := by + induction arms with + | nil => simp [selectArm] at selected + | cons arm arms ih => + rcases arm with ⟨pattern, branch⟩ + simp only [checkArms] at checked + obtain ⟨types, patternRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨branchType, branchRun, rest⟩ := except_bind_ok.mp rest + obtain ⟨finished, sameRun, tailRun⟩ := except_bind_ok.mp rest + cases finished + have same := requireType_ok sameRun + subst branchType + cases matched : pattern.bindings value with + | none => exact ih tailRun (by simpa only [selectArm, matched] using selected) + | some actual => + simp only [selectArm, matched, Option.some.injEq, Prod.mk.injEq] at selected + obtain ⟨rfl, rfl⟩ := selected + rw [patternTypes_bindings (checkPattern_types patternRun) formed matched] + exact branchRun + +end Aiur diff --git a/Aiur/Aiur/ROMSemantics.lean b/Aiur/Aiur/ROMSemantics.lean new file mode 100644 index 000000000..de655387f --- /dev/null +++ b/Aiur/Aiur/ROMSemantics.lean @@ -0,0 +1,61 @@ +import Aiur.Runtime + +namespace Aiur + +mutual + /-- Finite successful evaluation, with structured results and no fuel parameter. -/ + inductive ROMEvalExpr [Field F] [DecidableEq F] (rom : ROM F) (program : Program F) : + Environment F → Expr F → Value F → Prop where + | literal : ROMEvalExpr rom program locals (.literal value) (.field value) + | var (lookup : locals.find? (·.1 == name) = some (name, value)) : + ROMEvalExpr rom program locals (.var name) value + | tuple (items : ROMEvalArgs rom program locals exprs values) : + ROMEvalExpr rom program locals (.tuple exprs) (.tuple values) + | construct (items : ROMEvalArgs rom program locals exprs values) : + ROMEvalExpr rom program locals (.construct name ctor exprs) (.construct name ctor values) + | project (value : ROMEvalExpr rom program locals expr input) + (projected : projectValue input index = .ok result) : + ROMEvalExpr rom program locals (.project expr index) result + | letValue (value : ROMEvalExpr rom program locals expr input) + (matched : pattern.bindings input = some bindings) + (body : ROMEvalExpr rom program (bindings ++ locals) rest result) : + ROMEvalExpr rom program locals (.letValue pattern expr rest) result + | store (value : ROMEvalExpr rom program locals expr input) + (cell : (address, input) ∈ rom.entries) : + ROMEvalExpr rom program locals (.store expr) (.ptr input.type address) + | load (pointer : ROMEvalExpr rom program locals expr (.ptr target address)) + (cell : (address, result) ∈ rom.entries) (typed : result.type = target) : + ROMEvalExpr rom program locals (.load expr) result + | hint (key : ROMEvalExpr rom program locals expr input) + {value : Constant F} (typed : value.WellTyped program.enums type) : + ROMEvalExpr rom program locals (.hint type expr channel) value.toValue + | neg (value : ROMEvalExpr rom program locals expr input) (operation : evalNeg input = .ok result) : + ROMEvalExpr rom program locals (.neg expr) result + | assertEq (left : ROMEvalExpr rom program locals lhs x) (right : ROMEvalExpr rom program locals rhs y) + (operation : evalAssertEq op x y = .ok result) : + ROMEvalExpr rom program locals (.assertEq op lhs rhs) result + | binary (left : ROMEvalExpr rom program locals lhs x) (right : ROMEvalExpr rom program locals rhs y) + (operation : evalBinOp op x y = .ok result) : + ROMEvalExpr rom program locals (.binary op lhs rhs) result + | call (arguments : ROMEvalArgs rom program locals args values) + (callee : ROMEvalCall rom program name values result) : + ROMEvalExpr rom program locals (.call name args) result + | matchValue (value : ROMEvalExpr rom program locals expr input) + (selected : selectArm input arms = some (bindings, body)) + (branch : ROMEvalExpr rom program (bindings ++ locals) body result) : + ROMEvalExpr rom program locals (.matchValue expr arms) result + + inductive ROMEvalArgs [Field F] [DecidableEq F] (rom : ROM F) (program : Program F) : + Environment F → List (Expr F) → List (Value F) → Prop where + | nil : ROMEvalArgs rom program locals [] [] + | cons (head : ROMEvalExpr rom program locals expr value) + (tail : ROMEvalArgs rom program locals exprs values) : + ROMEvalArgs rom program locals (expr :: exprs) (value :: values) + + inductive ROMEvalCall [Field F] [DecidableEq F] (rom : ROM F) (program : Program F) : + String → List (Value F) → Value F → Prop where + | intro (prepared : prepareCall program name args = .ok (locals, expr)) + (body : ROMEvalExpr rom program locals expr result) : ROMEvalCall rom program name args result +end + +end Aiur diff --git a/Aiur/Aiur/Runtime.lean b/Aiur/Aiur/Runtime.lean new file mode 100644 index 000000000..f414b5b1e --- /dev/null +++ b/Aiur/Aiur/Runtime.lean @@ -0,0 +1,185 @@ +import Aiur.Typecheck +import Aiur.Constant +import Aiur.Memory +import Aiur.Hints +import Mathlib.Algebra.Field.Defs + +namespace Aiur + +abbrev Environment (F : Type) (Address : Type := F) := List (String × Value F Address) + +inductive EvalError where + | invalidProgram (error : CheckError) + | unknownFunction (name : String) + | arityMismatch (function : String) (expected actual : Nat) + | argumentTypeMismatch (function : String) (expected actual : Ty) + | unboundVariable (name : String) + | unhandledExit (target : String) + | expectedField + | expectedTuple + | expectedPointer + | malformedValue (type : Ty) + | danglingPointer (address : Nat) + | memoryTypeMismatch (expected actual : Ty) + | pointerEntryArgument (index : Nat) + | projectionBounds (index size : Nat) + | patternMismatch + | divisionByZero + | noMatchingArm + | outOfFuel + | missingMapInput (name : String) + | invalidMap (name : String) + | hint (error : HintError) + | assertionFailed (message : Option String) + | pointerEquality + deriving Repr, BEq, DecidableEq + +/-- Structural equality never follows a pointer or observes its address. The +checker excludes pointers from the entire operand type before execution. -/ +def evalAssertEq [DecidableEq F] [DecidableEq A] (assertion : Assertion) + (left right : Value F A) : Except EvalError (Value F A) := + if left.pointerFree && right.pointerFree then + if left = right then .ok (.tuple []) else .error (.assertionFailed assertion.message) + else .error .pointerEquality + +/-- Disabling the Rust check does not weaken equality in the semantic model. -/ +theorem evalAssertEq_runtimeCheck [DecidableEq F] [DecidableEq A] + (assertion : Assertion) (runtimeCheck : Bool) (left right : Value F A) : + evalAssertEq { assertion with runtimeCheck } left right = + evalAssertEq assertion left right := rfl + +theorem evalAssertEq_ok [DecidableEq F] [DecidableEq A] {left right result : Value F A} : + evalAssertEq message left right = .ok result ↔ + left.pointerFree = true ∧ left = right ∧ result = .tuple [] := by + by_cases free : left.pointerFree = true + · by_cases same : left = right + · subst right; simp [evalAssertEq, free, eq_comm] + · by_cases other : right.pointerFree = true <;> simp [evalAssertEq, free, same, other] + · simp [evalAssertEq, free] + +@[simp] theorem Value.pointerFree_mapAddress (encode : A → B) (value : Value F A) : + (value.mapAddress encode).pointerFree = value.pointerFree := by + cases value with + | field | ptr => simp only [Value.mapAddress, Value.pointerFree] + | tuple values | construct name ctor values => + simp only [Value.mapAddress, Value.pointerFree, List.map_map, Function.comp_def] + apply congrArg (fun values : List Bool => values.all id) + exact List.map_congr_left (fun v _ => Value.pointerFree_mapAddress encode v) +termination_by sizeOf value + +theorem evalAssertEq_mapAddress [DecidableEq F] [DecidableEq A] [DecidableEq B] + {left right result : Value F A} (operation : evalAssertEq message left right = .ok result) + (encode : A → B) : + evalAssertEq message (left.mapAddress encode) (right.mapAddress encode) = .ok (result.mapAddress encode) := by + obtain ⟨free, rfl, rfl⟩ := evalAssertEq_ok.mp operation + exact evalAssertEq_ok.mpr ⟨by simpa using free, rfl, by simp [Value.mapAddress]⟩ + + +mutual + /-- Match the whole value and collect bindings in left-to-right order. -/ + def Pattern.bindings [DecidableEq F] : Pattern F → Value F Address → Option (Environment F Address) + | .literal x, .field y => if x = y then some [] else none + | .wildcard, _ => some [] + | .bind name, value => some [(name, value)] + | .tuple patterns, .tuple values => Pattern.bindingsList patterns values + | .construct name ctor patterns, .construct other ctor' values => + if name = other ∧ ctor = ctor' then Pattern.bindingsList patterns values else none + | _, _ => none + termination_by pattern _ => sizeOf pattern + + def Pattern.bindingsList [DecidableEq F] : List (Pattern F) → List (Value F Address) → + Option (Environment F Address) + | [], [] => some [] + | pattern :: patterns, value :: values => do + return (← pattern.bindings value) ++ (← Pattern.bindingsList patterns values) + | _, _ => none + termination_by patterns _ => sizeOf patterns +end + +def selectArm [DecidableEq F] (value : Value F Address) : + List (Pattern F × Expr F) → Option (Environment F Address × Expr F) + | [] => none + | (pattern, body) :: rest => + match pattern.bindings value with + | some bindings => some (bindings, body) + | none => selectArm value rest + +def evalNeg [Field F] : Value F Address → Except EvalError (Value F Address) + | .field x => .ok (.field (-x)) + | .tuple _ | .ptr _ _ | .construct _ _ _ => .error .expectedField + +def evalBinOp [Field F] [DecidableEq F] (op : BinOp) : + Value F Address → Value F Address → Except EvalError (Value F Address) + | .field x, .field y => + match op with + | .add => .ok (.field (x + y)) + | .sub => .ok (.field (x - y)) + | .mul => .ok (.field (x * y)) + | .div => if y = 0 then .error .divisionByZero else .ok (.field (x / y)) + | _, _ => .error .expectedField + +def projectValue (value : Value F Address) (index : Nat) : Except EvalError (Value F Address) := do + let .tuple items := value | throw .expectedTuple + let some result := items[index]? | throw (.projectionBounds index items.length) + return result + +/-- Table lookup returns a pointer-free constant; missing inputs are errors. -/ +def lookupMap [DecidableEq F] (program : Program F) (name : String) + (args : List (Value F Address)) : Except EvalError (Constant F) := do + let some map := program.findMap? name | throw (.unknownFunction name) + if map.params.length != args.length then + throw (.arityMismatch name map.params.length args.length) + for (param, arg) in map.params.zip args do + if param.2 ≠ arg.type then throw (.argumentTypeMismatch name param.2 arg.type) + if !arg.wellFormed program.enums then throw (.malformedValue arg.type) + let some key := (Value.tuple args).toConstant? | throw (.missingMapInput name) + let some (_, result) := (program.mapRows map).find? (fun row => decide (row.1 = key)) + | throw (.missingMapInput name) + if !result.hasType program.enums map.result then throw (.invalidMap name) + return result + +/-- Resolve a function body or a statically selected map result through the same call interface. -/ +def prepareCall [DecidableEq F] (program : Program F) (name : String) (args : List (Value F Address)) : + Except EvalError (Environment F Address × Expr F) := do + let some fn := program.findFunction? name + | return ([], (← lookupMap program name args).toExpr) + if fn.params.length != args.length then + throw (.arityMismatch name fn.params.length args.length) + for (param, arg) in fn.params.zip args do + if param.2 ≠ arg.type then throw (.argumentTypeMismatch name param.2 arg.type) + if !arg.wellFormed program.enums then throw (.malformedValue arg.type) + return ((fn.params.map Prod.fst).zip args, fn.body) + +/-- Loads check their declared cell type; source pointers remain opaque to the language. -/ +def loadValue (heap : Heap F) : SourceValue F → Except EvalError (SourceValue F) + | .ptr target address => do + let some value := heap[address]? | throw (.danglingPointer address) + if value.type ≠ target then throw (.memoryTypeMismatch target value.type) + return value + | _ => throw .expectedPointer + +/-- This check depends only on the declared input types, not on supplied values. -/ +def checkEntryTypes (decls : Declarations) (index : Nat) : List Ty → Except EvalError Unit + | [] => .ok () + | type :: rest => + if type.pointerFree decls then checkEntryTypes decls (index + 1) rest + else .error (.pointerEntryArgument index) + +/-- Select a callable as a public entry without inspecting any argument values. -/ +def checkEntry (program : Program F) (name : String) : Except EvalError Unit := do + let some signature := program.findSignature? name | throw (.unknownFunction name) + checkEntryTypes program.enums 0 (signature.params.map Prod.snd) + +theorem checkEntryTypes_ok (decls : Declarations) (types : List Ty) (index : Nat) : + checkEntryTypes decls index types = .ok () ↔ ∀ type ∈ types, type.pointerFree decls = true := by + induction types generalizing index with + | nil => simp [checkEntryTypes] + | cons type rest ih => + cases free : type.pointerFree decls <;> simp [checkEntryTypes, free, ih] + +theorem checkEntry_ok (program : Program F) (name : String) : + checkEntry program name = .ok () ↔ ∃ signature, program.findSignature? name = some signature ∧ + ∀ type ∈ signature.params.map Prod.snd, type.pointerFree program.enums = true := by + cases found : program.findSignature? name <;> simp [checkEntry, found, checkEntryTypes_ok] + +end Aiur diff --git a/Aiur/Aiur/Scalar.lean b/Aiur/Aiur/Scalar.lean new file mode 100644 index 000000000..8f8cfc0b0 --- /dev/null +++ b/Aiur/Aiur/Scalar.lean @@ -0,0 +1,10 @@ +import Aiur.Scalar.AST +import Aiur.Scalar.Typecheck +import Aiur.Scalar.Eval +import Aiur.Scalar.Semantics +import Aiur.Scalar.Circuit +import Aiur.Scalar.Correctness +import Aiur.Scalar.MemoCompleteness +import Aiur.Scalar.MemoSoundness +import Aiur.Scalar.EvalCorrectness +import Aiur.Scalar.Frontend diff --git a/Aiur/Aiur/Scalar/AST.lean b/Aiur/Aiur/Scalar/AST.lean new file mode 100644 index 000000000..6a92d0a4f --- /dev/null +++ b/Aiur/Aiur/Scalar/AST.lean @@ -0,0 +1,79 @@ +import Std + +namespace Aiur.Scalar + +/-- The source language currently has one type, independently of literal storage. -/ +inductive Ty where + | field + deriving Repr, BEq, DecidableEq + +inductive BinOp where + | add | sub | mul | div + deriving Repr, BEq, DecidableEq + +/-- `α` is `Nat` in the frontend and the chosen field after specialization. -/ +inductive Pattern (α : Type) where + | literal (value : α) + | wildcard + deriving Repr, BEq + +inductive Expr (α : Type) where + | literal (value : α) + | var (name : String) + | neg (value : Expr α) + | binary (op : BinOp) (left right : Expr α) + | call (function : String) (args : List (Expr α)) + | matchValue (scrutinee : Expr α) (arms : List (Pattern α × Expr α)) + deriving Repr, BEq + +structure Function (α : Type) where + name : String + params : List String + body : Expr α + deriving Repr, BEq + +/-- All definitions share one namespace, allowing forward and mutually recursive calls. -/ +structure Program (α : Type) where + functions : List (Function α) + deriving Repr, BEq + +def Program.findFunction? (program : Program α) (name : String) : Option (Function α) := + program.functions.find? (·.name == name) + +def Pattern.map (f : α → β) : Pattern α → Pattern β + | .literal value => .literal (f value) + | .wildcard => .wildcard + +/-- Map literal values in both expressions and patterns, preserving program structure. -/ +def Expr.map (f : α → β) : Expr α → Expr β + | .literal value => .literal (f value) + | .var name => .var name + | .neg value => .neg (value.map f) + | .binary op left right => .binary op (left.map f) (right.map f) + | .call name args => .call name (args.map (Expr.map f)) + | .matchValue scrutinee arms => + .matchValue (scrutinee.map f) (arms.map fun arm => (arm.1.map f, arm.2.map f)) +termination_by expr => sizeOf expr +decreasing_by + all_goals simp_wf + all_goals + first + | omega + | have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + first + | omega + | cases arm + simp_all only [Prod.mk.sizeOf_spec] + omega + +def Function.map (f : α → β) (function : Function α) : Function β := + { name := function.name, params := function.params, body := function.body.map f } + +def Program.map (f : α → β) (program : Program α) : Program β := + { functions := program.functions.map (Function.map f) } + +/-- Specialize a frontend program by casting its natural literals into a field. -/ +def Program.toField (F : Type) [NatCast F] (program : Program Nat) : Program F := + program.map (fun n => (Nat.cast n : F)) + +end Aiur.Scalar diff --git a/Aiur/Aiur/Scalar/Circuit.lean b/Aiur/Aiur/Scalar/Circuit.lean new file mode 100644 index 000000000..d3d30ecf2 --- /dev/null +++ b/Aiur/Aiur/Scalar/Circuit.lean @@ -0,0 +1,5 @@ +import Aiur.Scalar.Circuit.Basic +import Aiur.Scalar.Circuit.Compile +import Aiur.Scalar.Circuit.Derivation +import Aiur.Scalar.Circuit.MemoDerivation +import Aiur.Scalar.Circuit.MemoAcyclic diff --git a/Aiur/Aiur/Scalar/Circuit/Basic.lean b/Aiur/Aiur/Scalar/Circuit/Basic.lean new file mode 100644 index 000000000..24e88d39c --- /dev/null +++ b/Aiur/Aiur/Scalar/Circuit/Basic.lean @@ -0,0 +1,175 @@ +import Aiur.Scalar.AST +import Mathlib.Algebra.Field.Basic + +namespace Aiur.Scalar.Circuit + +abbrev Var := Nat +abbrev Channel := String + +/-- A polynomial expression. Division and function calls are deliberately absent. -/ +inductive ArithExpr (F : Type) where + | const (value : F) + | var (id : Var) + | add (left right : ArithExpr F) + | sub (left right : ArithExpr F) + | mul (left right : ArithExpr F) + deriving Repr, BEq + +/-- The value of a polynomial under an assignment, not an execution instruction. -/ +def ArithExpr.denote [Field F] (assignment : Var → F) : ArithExpr F → F + | .const value => value + | .var id => assignment id + | .add left right => left.denote assignment + right.denote assignment + | .sub left right => left.denote assignment - right.denote assignment + | .mul left right => left.denote assignment * right.denote assignment + +def ArithExpr.inBounds (numVars : Nat) : ArithExpr F → Bool + | .const _ => true + | .var id => id < numVars + | .add left right | .sub left right | .mul left right => + left.inBounds numVars && right.inBounds numVars + +/-- Every local constraint is exactly a polynomial required to be zero. -/ +abbrev Constraint := ArithExpr + +def Satisfies [Field F] (constraints : List (Constraint F)) (assignment : Var → F) : Prop := + ∀ polynomial ∈ constraints, polynomial.denote assignment = 0 + +/-- Constraint order has no semantic significance. -/ +theorem satisfies_perm [Field F] {left right : List (Constraint F)} + (h : left.Perm right) (assignment : Var → F) : + Satisfies left assignment ↔ Satisfies right assignment := by + constructor + · intro valid polynomial member + exact valid polynomial (h.mem_iff.mpr member) + · intro valid polynomial member + exact valid polynomial (h.mem_iff.mp member) + +/-- A call requests a tuple of arguments together with its claimed return value. -/ +structure Message (F : Type) where + channel : Channel + args : List F + result : F + deriving Repr, BEq, DecidableEq + +/-- An enabled call contributes one message; its result is always a local variable. -/ +structure Send (F : Type) where + channel : Channel + args : List (ArithExpr F) + result : Var + enable : ArithExpr F + deriving Repr, BEq + +def Send.message [Field F] (send : Send F) (assignment : Var → F) : Message F := + ⟨send.channel, send.args.map (ArithExpr.denote assignment), assignment send.result⟩ + +def Send.inBounds (numVars : Nat) (send : Send F) : Bool := + send.result < numVars && send.enable.inBounds numVars && + send.args.all (ArithExpr.inBounds numVars) + +/-- +One chip per function. Inputs occupy variables `0 .. arity - 1`. +The lists of equations and sends impose no execution order. +-/ +structure Chip (F : Type) where + name : String + arity : Nat + numVars : Nat + output : Var + constraints : List (Constraint F) + sends : List (Send F) + deriving Repr, BEq + +def Chip.wellFormed (chip : Chip F) : Bool := + chip.arity ≤ chip.output && chip.output < chip.numVars && + chip.constraints.all (ArithExpr.inBounds chip.numVars) && + chip.sends.all (Send.inBounds chip.numVars) + +/-- A proposed simultaneous assignment for one invocation of a chip. -/ +structure Row (F : Type) where + chip : String + values : List F + deriving Repr, BEq + +def Row.assignment [Zero F] (row : Row F) (id : Var) : F := + row.values[id]?.getD 0 + +structure System (F : Type) where + chips : List (Chip F) + deriving Repr, BEq + +def System.findChip? (system : System F) (name : String) : Option (Chip F) := + system.chips.find? (·.name == name) + +inductive WitnessError where + | duplicateChip (name : String) + | unknownChip (name : String) + | invalidLayout (name : String) + | wrongRowSize (name : String) (expected actual : Nat) + | constraintNotZero (name : String) (index : Nat) + | unbalancedMessages + deriving Repr, BEq, DecidableEq + +/-- Validate a proposed assignment and obtain its receive and enabled sends. -/ +def Chip.checkRow [Field F] [DecidableEq F] (chip : Chip F) (row : Row F) : + Except WitnessError (Message F × List (Message F)) := do + if !chip.wellFormed then throw (.invalidLayout chip.name) + if row.values.length != chip.numVars then + throw (.wrongRowSize chip.name chip.numVars row.values.length) + for (polynomial, index) in chip.constraints.zipIdx do + if polynomial.denote row.assignment ≠ 0 then throw (.constraintNotZero chip.name index) + let mut sent := [] + for send in chip.sends do + let enabled := send.enable.denote row.assignment + if enabled = 1 then sent := sent ++ [send.message row.assignment] + let received := Message.mk chip.name (row.values.take chip.arity) (row.assignment chip.output) + return (received, sent) + +/-- +Check exact channel balance, including multiplicities, with one external request. +Rows are an unordered witness collection; no call stack or execution order is assumed. +-/ +def System.check [Field F] [DecidableEq F] (system : System F) + (entry : Message F) (rows : List (Row F)) : Except WitnessError Unit := do + let mut seen := [] + for chip in system.chips do + if chip.name ∈ seen then throw (.duplicateChip chip.name) + seen := chip.name :: seen + if !chip.wellFormed then throw (.invalidLayout chip.name) + let mut received := [] + let mut sent := [entry] + for row in rows do + let some chip := system.findChip? row.chip | throw (.unknownChip row.chip) + let (input, output) ← chip.checkRow row + received := input :: received + sent := output ++ sent + if sent.Perm received then pure () else throw .unbalancedMessages + +/-- The executable witness check defines acceptance of the abstract channel model. -/ +def System.Accepts [Field F] [DecidableEq F] (system : System F) + (entry : Message F) (rows : List (Row F)) : Prop := + system.check entry rows = .ok () + +/-- A selected inverse equation rules out a zero denominator. -/ +theorem inverse_nonzero [Field F] {denominator inverse : F} + (h : denominator * inverse - 1 = 0) : denominator ≠ 0 := by + intro zero + simp [zero] at h + +theorem inverse_eq [Field F] {denominator inverse : F} + (h : denominator * inverse - 1 = 0) : inverse = denominator⁻¹ := by + have product : denominator * inverse = 1 := sub_eq_zero.mp h + have nonzero := inverse_nonzero h + calc + inverse = (denominator⁻¹ * denominator) * inverse := by + rw [inv_mul_cancel₀ nonzero, one_mul] + _ = denominator⁻¹ * (denominator * inverse) := mul_assoc _ _ _ + _ = denominator⁻¹ := by rw [product, mul_one] + +theorem selector_boolean [Field F] {selector : F} + (h : selector * (selector - 1) = 0) : selector = 0 ∨ selector = 1 := by + rcases mul_eq_zero.mp h with zero | one + · exact Or.inl zero + · exact Or.inr (sub_eq_zero.mp one) + +end Aiur.Scalar.Circuit diff --git a/Aiur/Aiur/Scalar/Circuit/Compile.lean b/Aiur/Aiur/Scalar/Circuit/Compile.lean new file mode 100644 index 000000000..7e1e8b613 --- /dev/null +++ b/Aiur/Aiur/Scalar/Circuit/Compile.lean @@ -0,0 +1,179 @@ +import Aiur.Scalar.Circuit.Basic +import Aiur.Scalar.Typecheck + +namespace Aiur.Scalar.Circuit + +inductive CompileError where + | invalidProgram (error : CheckError) + | duplicatePattern (function : String) + deriving Repr, BEq, DecidableEq + +instance : ToString CompileError where + toString + | .invalidProgram error => toString error + | .duplicatePattern name => s!"duplicate field pattern in function '{name}'" + +-- The lowering implementation is exposed here for compiler correctness proofs. +namespace Compiler + +structure BuildState (F : Type) where + nextVar : Nat + constraints : Array (Constraint F) := #[] + sends : Array (Send F) := #[] + +abbrev Build (F : Type) := StateT (BuildState F) (Except CompileError) + +def fresh : Build F Var := do + let state ← get + set { state with nextVar := state.nextVar + 1 } + return state.nextVar + +def constrain (polynomial : ArithExpr F) : Build F Unit := + modify fun state => { state with constraints := state.constraints.push polynomial } + +def guarded (enable polynomial : ArithExpr F) : Build F Unit := + constrain (.mul enable polynomial) + +def boolean [Field F] (selector : ArithExpr F) : Build F Unit := + constrain (.mul selector (.sub selector (.const 1))) + +/-- Stop at the wildcard: any later arms are unreachable and are not lowered. -/ +def literalPatterns : List (Pattern F × Expr F) → List F + | [] => [] + | (.literal value, _) :: rest => value :: literalPatterns rest + | (.wildcard, _) :: _ => [] + +def checkPatterns [DecidableEq F] (function : String) : + List (Pattern F × Expr F) → List F → Except CompileError Unit + | [], _ => pure () + | (.wildcard, _) :: _, _ => pure () + | (.literal value, _) :: rest, seen => do + if value ∈ seen then throw (.duplicatePattern function) + checkPatterns function rest (value :: seen) + +/-- One product equation for each pair of distinct selector occurrences. -/ +def exclusionConstraints : List (ArithExpr F) → List (Constraint F) + | [] => [] + | selector :: rest => rest.map (ArithExpr.mul selector) ++ exclusionConstraints rest + +def selectionConstraints [Field F] (parent : ArithExpr F) + (selectors : List (ArithExpr F)) : List (Constraint F) := + selectors.map (fun selector => .mul selector (.sub selector (.const 1))) ++ + exclusionConstraints selectors ++ + [.sub (selectors.foldl ArithExpr.add (.const 0)) parent] + +/-- Boolean selectors, pairwise exclusion, and exactly one when the parent is active. -/ +def selectOne [Field F] (parent : ArithExpr F) (selectors : List (ArithExpr F)) : + Build F Unit := + modify fun state => { state with + constraints := state.constraints ++ (selectionConstraints parent selectors).toArray } + +/-- A selected default excludes each explicit literal using a fresh inverse witness. -/ +def excludeLiterals [Field F] (selector scrutinee : ArithExpr F) : List F → Build F Unit + | [] => pure () + | value :: rest => do + let inverse ← fresh + guarded selector + (.sub (.mul (.sub scrutinee (.const value)) (.var inverse)) (.const 1)) + excludeLiterals selector scrutinee rest + +mutual + def lowerExpr [Field F] [DecidableEq F] (function : String) + (locals : List (String × Var)) (enable : ArithExpr F) (expr : Expr F) : + Build F (ArithExpr F) := do + match expr with + | .literal value => return .const value + | .var name => + let some (_, id) := locals.find? (·.1 == name) + | throw (.invalidProgram (.unboundVariable function name)) + return .var id + | .neg value => return .sub (.const 0) (← lowerExpr function locals enable value) + | .binary op left right => + let left ← lowerExpr function locals enable left + let right ← lowerExpr function locals enable right + match op with + | .add => return .add left right + | .sub => return .sub left right + | .mul => return .mul left right + | .div => + let inverse ← fresh + guarded enable (.sub (.mul right (.var inverse)) (.const 1)) + return .mul left (.var inverse) + | .call name args => + let args ← lowerArgs function locals enable args + let result ← fresh + boolean enable + modify fun state => { state with + sends := state.sends.push ⟨name, args, result, enable⟩ } + return .var result + | .matchValue scrutinee arms => + checkPatterns function arms [] + let scrutinee ← lowerExpr function locals enable scrutinee + let result ← fresh + let selectors ← lowerArms function locals scrutinee result (literalPatterns arms) arms + selectOne enable selectors + return .var result + termination_by sizeOf expr + + def lowerArgs [Field F] [DecidableEq F] (function : String) + (locals : List (String × Var)) (enable : ArithExpr F) (args : List (Expr F)) : + Build F (List (ArithExpr F)) := do + match args with + | [] => pure [] + | arg :: rest => + let arg ← lowerExpr function locals enable arg + let rest ← lowerArgs function locals enable rest + return arg :: rest + termination_by sizeOf args + + def lowerArms [Field F] [DecidableEq F] (function : String) + (locals : List (String × Var)) (scrutinee : ArithExpr F) (result : Var) + (literals : List F) (arms : List (Pattern F × Expr F)) : + Build F (List (ArithExpr F)) := do + match arms with + | [] => pure [] + | (pattern, body) :: rest => + let selector := ArithExpr.var (← fresh) + match pattern with + | .literal value => guarded selector (.sub scrutinee (.const value)) + | .wildcard => + excludeLiterals selector scrutinee literals + let body ← lowerExpr function locals selector body + guarded selector (.sub (.var result) body) + match pattern with + | .wildcard => return [selector] + | .literal _ => + let rest ← lowerArms function locals scrutinee result literals rest + return selector :: rest + termination_by sizeOf arms +end + +def lowerFunction [Field F] [DecidableEq F] (defn : Function F) : + Except CompileError (Chip F) := do + let arity := defn.params.length + let output := arity + let (body, state) ← + (lowerExpr defn.name (defn.params.zip (List.range arity)) (.const 1) defn.body).run + { nextVar := arity + 1 } + return { + name := defn.name + arity + output + numVars := state.nextVar + constraints := (state.constraints.push (.sub (.var output) body)).toList + sends := state.sends.toList + } + +end Compiler + +/-- +Compile a field-specialized program to one chip per function. Calls remain channel sends, +so recursive definitions are never unfolded. Matching is validated in the chosen field. +-/ +def compile [Field F] [DecidableEq F] (program : Program F) : Except CompileError (System F) := do + match typecheck program with + | .error error => throw (.invalidProgram error) + | .ok () => pure () + return ⟨← program.functions.mapM Compiler.lowerFunction⟩ + +end Aiur.Scalar.Circuit diff --git a/Aiur/Aiur/Scalar/Circuit/CompileFacts.lean b/Aiur/Aiur/Scalar/Circuit/CompileFacts.lean new file mode 100644 index 000000000..29929c7b4 --- /dev/null +++ b/Aiur/Aiur/Scalar/Circuit/CompileFacts.lean @@ -0,0 +1,273 @@ +import Aiur.Scalar.Circuit.Compile +import Aiur.Scalar.Circuit.Selectors + +namespace Aiur.Scalar.Circuit + +/-- Fresh variables never invalidate the bounds of an earlier expression. -/ +theorem ArithExpr.inBounds_mono {expr : ArithExpr F} {before after : Nat} + (increase : before ≤ after) (bound : expr.inBounds before = true) : + expr.inBounds after = true := by + induction expr with + | const => rfl + | var id => + simp only [ArithExpr.inBounds, decide_eq_true_eq] at bound ⊢ + exact lt_of_lt_of_le bound increase + | add _ _ leftIH rightIH | sub _ _ leftIH rightIH | mul _ _ leftIH rightIH => + simp only [ArithExpr.inBounds, Bool.and_eq_true] at bound ⊢ + exact ⟨leftIH bound.1, rightIH bound.2⟩ + +theorem Send.inBounds_mono {send : Send F} {before after : Nat} + (increase : before ≤ after) (bound : send.inBounds before = true) : + send.inBounds after = true := by + simp only [Send.inBounds, Bool.and_eq_true, decide_eq_true_eq, List.all_eq_true] at bound ⊢ + exact ⟨⟨lt_of_lt_of_le bound.1.1 increase, ArithExpr.inBounds_mono increase bound.1.2⟩, + fun expr member => ArithExpr.inBounds_mono increase (bound.2 expr member)⟩ + +@[simp] theorem Compiler.lift_ok (value : α) (state : Compiler.BuildState F) : + (liftM (.ok value : Except CompileError α) : Compiler.Build F α) state = .ok (value, state) := rfl + +@[simp] theorem Compiler.lift_error (error : CompileError) (state : Compiler.BuildState F) : + (liftM (.error error : Except CompileError α) : Compiler.Build F α) state = .error error := rfl + +/-- Extending a fresh-variable assignment preserves every earlier polynomial. -/ +theorem ArithExpr.denote_eq_of_agree [Field F] {left right : Var → F} {bound : Nat} + (agree : ∀ id < bound, left id = right id) {expr : ArithExpr F} + (inBounds : expr.inBounds bound = true) : expr.denote left = expr.denote right := by + induction expr with + | const => rfl + | var id => exact agree id (by simpa [ArithExpr.inBounds] using inBounds) + | add _ _ leftIH rightIH => + simp only [ArithExpr.inBounds, Bool.and_eq_true] at inBounds + simp only [ArithExpr.denote, leftIH inBounds.1, rightIH inBounds.2] + | sub _ _ leftIH rightIH => + simp only [ArithExpr.inBounds, Bool.and_eq_true] at inBounds + simp only [ArithExpr.denote, leftIH inBounds.1, rightIH inBounds.2] + | mul _ _ leftIH rightIH => + simp only [ArithExpr.inBounds, Bool.and_eq_true] at inBounds + simp only [ArithExpr.denote, leftIH inBounds.1, rightIH inBounds.2] + +theorem Compiler.fresh_run (state : Compiler.BuildState F) : + Compiler.fresh.run state = .ok (state.nextVar, { state with nextVar := state.nextVar + 1 }) := rfl + +@[simp] theorem Compiler.fresh_apply (state : Compiler.BuildState F) : + Compiler.fresh state = .ok (state.nextVar, { state with nextVar := state.nextVar + 1 }) := rfl + +theorem Compiler.constrain_run (state : Compiler.BuildState F) (polynomial : ArithExpr F) : + (Compiler.constrain polynomial).run state = + .ok ((), { state with constraints := state.constraints.push polynomial }) := rfl + +@[simp] theorem Compiler.constrain_apply (polynomial : ArithExpr F) (state : Compiler.BuildState F) : + Compiler.constrain polynomial state = + .ok ((), { state with constraints := state.constraints.push polynomial }) := rfl + +@[simp] theorem Compiler.guarded_apply (enable polynomial : ArithExpr F) (state : Compiler.BuildState F) : + Compiler.guarded enable polynomial state = + .ok ((), { state with constraints := state.constraints.push (.mul enable polynomial) }) := rfl + +theorem satisfies_append [Field F] (left right : List (Constraint F)) (assignment : Var → F) : + Satisfies (left ++ right) assignment ↔ + Satisfies left assignment ∧ Satisfies right assignment := by + simp [Satisfies, or_imp, forall_and] + +theorem Compiler.exclusionConstraints_satisfies [Field F] + (selectors : List (ArithExpr F)) (assignment : Var → F) : + Satisfies (Compiler.exclusionConstraints selectors) assignment ↔ + (selectors.map (ArithExpr.denote assignment)).Pairwise (fun left right => left * right = 0) := by + induction selectors with + | nil => simp [Compiler.exclusionConstraints, Satisfies] + | cons selector rest ih => + rw [Compiler.exclusionConstraints, satisfies_append, ih] + simp [Satisfies, ArithExpr.denote] + +theorem ArithExpr.denote_foldl_add [Field F] (selectors : List (ArithExpr F)) + (initial : ArithExpr F) (assignment : Var → F) : + (selectors.foldl ArithExpr.add initial).denote assignment = + initial.denote assignment + (selectors.map (ArithExpr.denote assignment)).sum := by + induction selectors generalizing initial with + | nil => simp + | cons head tail ih => + simp only [List.foldl_cons, ih, List.map_cons, List.sum_cons, ArithExpr.denote] + exact add_assoc _ _ _ + +/-- The actual emitted equations are exactly the abstract selector conditions. -/ +theorem Compiler.selectionConstraints_satisfies [Field F] + (parent : ArithExpr F) (selectors : List (ArithExpr F)) (assignment : Var → F) : + Satisfies (Compiler.selectionConstraints parent selectors) assignment ↔ + SelectorsValid (parent.denote assignment) (selectors.map (ArithExpr.denote assignment)) := by + simp only [Compiler.selectionConstraints, satisfies_append, + Compiler.exclusionConstraints_satisfies] + have booleans : Satisfies + (selectors.map (fun selector => .mul selector (.sub selector (.const 1)))) assignment ↔ + ∀ value ∈ selectors.map (ArithExpr.denote assignment), value * (value - 1) = 0 := by + simp [Satisfies, ArithExpr.denote] + rw [booleans] + have sumEquation : Satisfies + [.sub (selectors.foldl ArithExpr.add (.const 0)) parent] assignment ↔ + (selectors.map (ArithExpr.denote assignment)).sum = parent.denote assignment := by + simp [Satisfies, ArithExpr.denote, ArithExpr.denote_foldl_add, sub_eq_zero] + rw [sumEquation] + exact ⟨fun ⟨⟨boolean, exclusive⟩, sum⟩ => ⟨boolean, exclusive, sum⟩, + fun valid => ⟨⟨valid.boolean, valid.exclusive⟩, valid.sum⟩⟩ + +theorem Compiler.selectOne_run [Field F] (parent : ArithExpr F) + (selectors : List (ArithExpr F)) (state : Compiler.BuildState F) : + (Compiler.selectOne parent selectors).run state = + .ok ((), { state with + constraints := state.constraints ++ (Compiler.selectionConstraints parent selectors).toArray }) := rfl + +@[simp] theorem Compiler.selectOne_apply [Field F] (parent : ArithExpr F) + (selectors : List (ArithExpr F)) (state : Compiler.BuildState F) : + Compiler.selectOne parent selectors state = + .ok ((), { state with + constraints := state.constraints ++ (Compiler.selectionConstraints parent selectors).toArray }) := rfl + +/-- The compiler's input-variable environment agrees with the source parameter bindings. -/ +theorem parameter_environment [Zero F] (params : List String) (row : Row F) + (enough : params.length ≤ row.values.length) : + (params.zip (List.range params.length)).map (fun binding => (binding.1, row.assignment binding.2)) = + params.zip (row.values.take params.length) := by + apply List.ext_getElem + · simp [Nat.min_eq_left enough] + · intro index leftBound rightBound + have bound : index < params.length := by simpa using leftBound + simp [Row.assignment, Nat.lt_of_lt_of_le bound enough] + +theorem Row.assignment_of_prefix [Zero F] {before after : Row F} + (extension : before.values.IsPrefix after.values) {id : Nat} (bound : id < before.values.length) : + after.assignment id = before.assignment id := by + have afterBound : id < after.values.length := lt_of_lt_of_le bound extension.length_le + simp [Row.assignment, bound, afterBound, extension.getElem bound] + +/-- Checking patterns gives distinct retained literals and excludes previously seen ones. -/ +theorem Compiler.checkPatterns_spec [DecidableEq F] (function : String) + (arms : List (Pattern F × Expr F)) (seen : List F) : + Compiler.checkPatterns function arms seen = .ok () ↔ + (Compiler.literalPatterns arms).Nodup ∧ + ∀ value ∈ Compiler.literalPatterns arms, value ∉ seen := by + induction arms generalizing seen with + | nil => simp [Compiler.checkPatterns, Compiler.literalPatterns, pure, Except.pure] + | cons arm rest ih => + rcases arm with ⟨pattern, body⟩ + cases pattern with + | wildcard => simp [Compiler.checkPatterns, Compiler.literalPatterns, pure, Except.pure] + | literal value => + by_cases member : value ∈ seen + · simp [Compiler.checkPatterns, Compiler.literalPatterns, member, List.nodup_cons, + bind, Except.bind] + · have reduction : Compiler.checkPatterns function ((.literal value, body) :: rest) seen = + Compiler.checkPatterns function rest (value :: seen) := by + simp [Compiler.checkPatterns, member, bind, pure, Except.bind, Except.pure] + rw [reduction, ih] + simp only [Compiler.literalPatterns, List.nodup_cons] + constructor + · rintro ⟨distinct, fresh⟩ + refine ⟨⟨?_, distinct⟩, ?_⟩ + · intro repeated + exact fresh value repeated (by simp) + · intro next present + rcases List.mem_cons.mp present with same | present + · subst next; exact member + · intro old + exact fresh next present (by simp [old]) + · rintro ⟨⟨notRepeated, distinct⟩, fresh⟩ + refine ⟨distinct, ?_⟩ + intro next present old + rcases List.mem_cons.mp old with same | old + · subst next; exact notRepeated present + · exact fresh next (by simp [present]) old + +theorem Compiler.lowerFunction_interface [Field F] [DecidableEq F] + {defn : Function F} {chip : Chip F} (compiled : Compiler.lowerFunction defn = .ok chip) : + chip.name = defn.name ∧ chip.arity = defn.params.length ∧ chip.output = defn.params.length := by + unfold Compiler.lowerFunction at compiled + cases lowered : + (Compiler.lowerExpr defn.name (defn.params.zip (List.range defn.params.length)) + (.const 1) defn.body).run { nextVar := defn.params.length + 1 } with + | error error => simp [lowered] at compiled + | ok result => + rcases result with ⟨body, state⟩ + simp [lowered] at compiled + cases compiled + exact ⟨rfl, rfl, rfl⟩ + +private theorem forall₂_of_mapM_ok {f : α → Except ε β} {xs : List α} {ys : List β} + (mapped : xs.mapM f = .ok ys) : List.Forall₂ (fun x y => f x = .ok y) xs ys := by + induction xs generalizing ys with + | nil => simp only [List.mapM_nil] at mapped; cases mapped; exact .nil + | cons x xs ih => + cases hx : f x with + | error error => simp [hx] at mapped; cases mapped + | ok y => + cases hxs : xs.mapM f with + | error error => simp [hx, hxs] at mapped; cases mapped + | ok rest => + simp [hx, hxs] at mapped + cases mapped + exact .cons hx (ih hxs) + +/-- The output list contains precisely the chip compiled from each source function. -/ +theorem compile_functions [Field F] [DecidableEq F] {program : Program F} {system : System F} + (compiled : compile program = .ok system) : + List.Forall₂ (fun defn chip => Compiler.lowerFunction defn = .ok chip) + program.functions system.chips := by + unfold compile at compiled + cases checked : typecheck program with + | error error => simp [checked] at compiled; cases compiled + | ok checkedUnit => + cases checkedUnit + cases mapped : program.functions.mapM Compiler.lowerFunction with + | error error => simp [checked, mapped] at compiled + | ok chips => + simp [checked, mapped] at compiled + subst system + exact forall₂_of_mapM_ok mapped + +private theorem lookup_functions [Field F] [DecidableEq F] + {defns : List (Function F)} {chips : List (Chip F)} + (compiled : List.Forall₂ (fun defn chip => Compiler.lowerFunction defn = .ok chip) defns chips) + (name : String) : + Option.Rel (fun defn chip => Compiler.lowerFunction defn = .ok chip) + (defns.find? (·.name == name)) (chips.find? (·.name == name)) := by + induction compiled with + | nil => exact .none + | cons head _ ih => + have names := (Compiler.lowerFunction_interface head).1 + simp only [List.find?_cons, names] + split + · exact .some head + · exact ih + +theorem compile_find_function [Field F] [DecidableEq F] + {program : Program F} {system : System F} (compiled : compile program = .ok system) + {name : String} {defn : Function F} (found : program.findFunction? name = some defn) : + ∃ chip, system.findChip? name = some chip ∧ Compiler.lowerFunction defn = .ok chip := by + have related := lookup_functions (compile_functions compiled) name + change Option.Rel _ (program.findFunction? name) (system.findChip? name) at related + rw [found] at related + cases target : system.findChip? name with + | none => rw [target] at related; cases related + | some chip => + rw [target] at related + cases related with + | some lowered => exact ⟨chip, rfl, lowered⟩ + +theorem compile_find_chip [Field F] [DecidableEq F] + {program : Program F} {system : System F} (compiled : compile program = .ok system) + {name : String} {chip : Chip F} (found : system.findChip? name = some chip) : + ∃ defn, program.findFunction? name = some defn ∧ Compiler.lowerFunction defn = .ok chip := by + have related := lookup_functions (compile_functions compiled) name + change Option.Rel _ (program.findFunction? name) (system.findChip? name) at related + rw [found] at related + cases source : program.findFunction? name with + | none => rw [source] at related; cases related + | some defn => + rw [source] at related + cases related with + | some lowered => exact ⟨defn, rfl, lowered⟩ + +theorem findFunction_name {program : Program F} {name : String} {defn : Function F} + (found : program.findFunction? name = some defn) : defn.name = name := by + have := List.find?_some found + simpa using this + +end Aiur.Scalar.Circuit diff --git a/Aiur/Aiur/Scalar/Circuit/Degree.lean b/Aiur/Aiur/Scalar/Circuit/Degree.lean new file mode 100644 index 000000000..6f2b292ae --- /dev/null +++ b/Aiur/Aiur/Scalar/Circuit/Degree.lean @@ -0,0 +1,13 @@ +import Aiur.Scalar.Circuit.Basic + +namespace Aiur.Scalar.Circuit + +/-- A structural upper bound on polynomial degree. Constants, including zero, +have degree zero; cancellation and multiplication by zero are not simplified. -/ +def ArithExpr.degree : ArithExpr F → Nat + | .const _ => 0 + | .var _ => 1 + | .add left right | .sub left right => max left.degree right.degree + | .mul left right => left.degree + right.degree + +end Aiur.Scalar.Circuit diff --git a/Aiur/Aiur/Scalar/Circuit/Derivation.lean b/Aiur/Aiur/Scalar/Circuit/Derivation.lean new file mode 100644 index 000000000..037389c8f --- /dev/null +++ b/Aiur/Aiur/Scalar/Circuit/Derivation.lean @@ -0,0 +1,125 @@ +import Aiur.Scalar.Circuit.Basic + +namespace Aiur.Scalar.Circuit + +/-- Local validity is a collection of simultaneous equations and layout conditions. -/ +def Chip.ValidRow [Field F] (chip : Chip F) (row : Row F) : Prop := + chip.wellFormed = true ∧ row.values.length = chip.numVars ∧ + Satisfies chip.constraints row.assignment + +/-- The conclusion of a chip rule instantiated by a row. -/ +def Chip.receive [Field F] (chip : Chip F) (row : Row F) : Message F := + ⟨chip.name, row.values.take chip.arity, row.assignment chip.output⟩ + +theorem Chip.ValidRow.receive_arity [Field F] {chip : Chip F} {row : Row F} + (valid : chip.ValidRow row) : (chip.receive row).args.length = chip.arity := by + obtain ⟨layout, size, _⟩ := valid + have bounds : chip.arity ≤ chip.numVars := by + simp [Chip.wellFormed] at layout + exact le_trans layout.1.1.1 (Nat.le_of_lt layout.1.1.2) + simp [Chip.receive, size, Nat.min_eq_left bounds] + +/-- Keep one premise per enabled send occurrence, including repeated messages. -/ +def Chip.premises [Field F] [DecidableEq F] (chip : Chip F) (row : Row F) : List (Message F) := + chip.sends.filterMap fun send => + if send.enable.denote row.assignment = 1 then some (send.message row.assignment) else none + +theorem Chip.premises_forall [Field F] [DecidableEq F] (chip : Chip F) (row : Row F) + (property : Message F → Prop) : + (∀ message ∈ chip.premises row, property message) ↔ + ∀ send ∈ chip.sends, send.enable.denote row.assignment = 1 → property (send.message row.assignment) := by + constructor + · intro valid send member enabled + apply valid (send.message row.assignment) + apply List.mem_filterMap.mpr + exact ⟨send, member, by simp [enabled]⟩ + · intro valid message member + obtain ⟨send, sendMember, selected⟩ := List.mem_filterMap.mp member + split at selected + · rename_i enabled + cases selected + exact valid send sendMember enabled + · cases selected + +mutual + /-- + A closed, finite derivation of a message. Local validity is a side condition; + all enabled calls must be discharged by child derivations. There is no assumption rule. + -/ + inductive Derivation [Field F] [DecidableEq F] (system : System F) : Message F → Type where + | node (chip : Chip F) (row : Row F) + (lookup : system.findChip? row.chip = some chip) + (valid : chip.ValidRow row) + (children : Derivations system (chip.premises row)) : + Derivation system (chip.receive row) + + /-- A finite list of proofs indexed by its list of premise occurrences. -/ + inductive Derivations [Field F] [DecidableEq F] (system : System F) : List (Message F) → Type where + | nil : Derivations system [] + | cons (head : Derivation system message) (tail : Derivations system messages) : + Derivations system (message :: messages) +end + +/-- Derivability asserts the existence of a closed derivation tree. -/ +def Derives [Field F] [DecidableEq F] (system : System F) (message : Message F) : Prop := + Nonempty (Derivation system message) + +/-- The circuit relation for one function's arguments and claimed result. -/ +def CircuitEvaluates [Field F] [DecidableEq F] (system : System F) + (function : String) (args : List F) (result : F) : Prop := + Derives system ⟨function, args, result⟩ + +/-- Assemble a forest from proofs of every premise, retaining repeated occurrences. -/ +theorem derivations_nonempty_iff [Field F] [DecidableEq F] {system : System F} + {messages : List (Message F)} : + Nonempty (Derivations system messages) ↔ ∀ message ∈ messages, Derives system message := by + induction messages with + | nil => + constructor + · intros; contradiction + · intro _; exact ⟨.nil⟩ + | cons message messages ih => + constructor + · rintro ⟨children⟩ + cases children with + | cons head tail => + intro next member + rcases List.mem_cons.mp member with same | member + · subst next; exact ⟨head⟩ + · exact ih.mp ⟨tail⟩ next member + · intro premises + obtain ⟨head⟩ := premises message (by simp) + obtain ⟨tail⟩ := ih.mpr (fun next member => premises next (by simp [member])) + exact ⟨.cons head tail⟩ + +mutual + /-- Flatten a tree to rows, retaining separate occurrences of identical calls. -/ + def Derivation.rows [Field F] [DecidableEq F] {system : System F} {message : Message F} : + Derivation system message → List (Row F) + | .node _ row _ _ children => row :: children.rows + + def Derivations.rows [Field F] [DecidableEq F] {system : System F} {messages : List (Message F)} : + Derivations system messages → List (Row F) + | .nil => [] + | .cons head tail => head.rows ++ tail.rows +end + +theorem Derivation.rows_ne_nil [Field F] [DecidableEq F] {system : System F} + {message : Message F} (derivation : Derivation system message) : derivation.rows ≠ [] := by + cases derivation + simp [Derivation.rows] + +/-- If every valid rule requires a call, no finite closed derivation can start. -/ +theorem not_derives_of_no_leaves [Field F] [DecidableEq F] {system : System F} + (requiresCall : ∀ chip row, system.findChip? row.chip = some chip → + chip.ValidRow row → chip.premises row ≠ []) (message : Message F) : + ¬ Derives system message := by + rintro ⟨derivation⟩ + induction derivation using Derivation.rec + (motive_2 := fun messages _ => messages ≠ [] → False) with + | node chip row lookup valid _ childrenIH => + exact childrenIH (requiresCall chip row lookup valid) + | nil => exact absurd rfl ‹([] : List (Message F)) ≠ []› + | cons _ _ headIH _ => exact headIH + +end Aiur.Scalar.Circuit diff --git a/Aiur/Aiur/Scalar/Circuit/ExpressionCorrectness.lean b/Aiur/Aiur/Scalar/Circuit/ExpressionCorrectness.lean new file mode 100644 index 000000000..f0ef83377 --- /dev/null +++ b/Aiur/Aiur/Scalar/Circuit/ExpressionCorrectness.lean @@ -0,0 +1,360 @@ +import Aiur.Scalar.Semantics.WithCalls +import Aiur.Scalar.Circuit.CompileFacts + +namespace Aiur.Scalar.Circuit.Compiler + +def localsEnvironment (locals : List (String × Var)) (assignment : Var → F) : Environment F := + locals.map fun binding => (binding.1, assignment binding.2) + +/-- Every existing equation and active call is justified under one simultaneous assignment. -/ +structure BuildState.Valid [Field F] (state : BuildState F) (calls : CallRelation F) + (assignment : Var → F) : Prop where + constraints : Satisfies state.constraints.toList assignment + calls : ∀ send ∈ state.sends.toList, send.enable.denote assignment = 1 → + calls send.channel (send.args.map (ArithExpr.denote assignment)) (assignment send.result) + +structure BuildState.WellFormed (state : BuildState F) : Prop where + constraints : ∀ polynomial ∈ state.constraints.toList, polynomial.inBounds state.nextVar = true + sends : ∀ send ∈ state.sends.toList, send.inBounds state.nextVar = true + +theorem BuildState.Valid.of_subset [Field F] {before after : BuildState F} + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid calls assignment) + (constraints : ∀ polynomial ∈ before.constraints.toList, polynomial ∈ after.constraints.toList) + (sends : ∀ send ∈ before.sends.toList, send ∈ after.sends.toList) : + before.Valid calls assignment := + ⟨fun polynomial member => valid.constraints polynomial (constraints polynomial member), + fun send member => valid.calls send (sends send member)⟩ + +/-- The default branch's inverse witnesses force every explicit equality to fail. -/ +theorem excludeLiterals_sound [Field F] {selector scrutinee : ArithExpr F} {literals : List F} + {before after : BuildState F} + (compiled : (excludeLiterals selector scrutinee literals).run before = .ok ((), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid calls assignment) : + before.Valid calls assignment ∧ + (selector.denote assignment = 1 → ∀ literal ∈ literals, scrutinee.denote assignment ≠ literal) := by + cases literals with + | nil => + simp [excludeLiterals, StateT.run, StateT.pure, pure, Except.pure] at compiled + subst after + exact ⟨valid, by simp⟩ + | cons value rest => + cases restRun : excludeLiterals selector scrutinee rest { + before with nextVar := before.nextVar + 1 + constraints := before.constraints.push + (.mul selector (.sub (.mul (.sub scrutinee (.const value)) + (.var before.nextVar)) (.const 1))) } with + | error error => + simp [excludeLiterals, StateT.run, StateT.bind, bind, Except.bind, restRun] at compiled + | ok output => + rcases output with ⟨finished, state⟩ + cases finished + simp [excludeLiterals, StateT.run, StateT.bind, bind, Except.bind, restRun] at compiled + subst after + obtain ⟨middleValid, restExcluded⟩ := excludeLiterals_sound restRun valid + refine ⟨middleValid.of_subset (fun equation member => by simp [member]) + (fun _ member => member), ?_⟩ + intro active literal member + rcases List.mem_cons.mp member with same | member + · subst literal + have equation := middleValid.constraints + (.mul selector (.sub (.mul (.sub scrutinee (.const value)) + (.var before.nextVar)) (.const 1))) (by simp) + apply default_excludes_literal + simpa [ArithExpr.denote, active] using equation + · exact restExcluded active literal member +termination_by literals.length + +mutual + /-- The first conclusion transports validity backwards; the second handles active expressions. -/ + theorem lowerExpr_sound [Field F] [DecidableEq F] + {function : String} {locals : List (String × Var)} {enable : ArithExpr F} {expr : Expr F} + {before after : BuildState F} {polynomial : ArithExpr F} + (compiled : (lowerExpr function locals enable expr).run before = .ok (polynomial, after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid calls assignment) : + before.Valid calls assignment ∧ + (enable.denote assignment = 1 → + EvalExprWith calls (localsEnvironment locals assignment) expr (polynomial.denote assignment)) := by + cases expr with + | literal value => + simp [lowerExpr, StateT.run, StateT.pure, pure, Except.pure] at compiled + rcases compiled with ⟨rfl, rfl⟩ + exact ⟨valid, fun _ => .literal⟩ + | var name => + cases found : locals.find? (·.1 == name) with + | none => + simp [lowerExpr, found, StateT.run] at compiled + cases compiled + | some binding => + rcases binding with ⟨bindingName, id⟩ + have same : bindingName = name := by simpa using List.find?_some found + subst bindingName + simp [lowerExpr, found, StateT.run, StateT.pure, pure, Except.pure] at compiled + rcases compiled with ⟨rfl, rfl⟩ + refine ⟨valid, fun _ => .var ?_⟩ + simp [localsEnvironment, List.find?_map, Function.comp_def, found, ArithExpr.denote] + | neg expr => + cases lowered : lowerExpr function locals enable expr before with + | error error => + simp [lowerExpr, StateT.run, StateT.bind, bind, Except.bind, lowered] at compiled + | ok output => + rcases output with ⟨inner, state⟩ + simp [lowerExpr, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, lowered] at compiled + rcases compiled with ⟨rfl, rfl⟩ + obtain ⟨beforeValid, evaluated⟩ := lowerExpr_sound lowered valid + refine ⟨beforeValid, fun active => ?_⟩ + simpa [ArithExpr.denote] using EvalExprWith.neg (evaluated active) + | binary op left right => + cases leftRun : lowerExpr function locals enable left before with + | error error => + simp [lowerExpr, StateT.run, StateT.bind, bind, Except.bind, leftRun] at compiled + | ok output => + rcases output with ⟨leftPolynomial, middle⟩ + cases rightRun : lowerExpr function locals enable right middle with + | error error => + simp [lowerExpr, StateT.run, StateT.bind, bind, Except.bind, leftRun, rightRun] at compiled + | ok output => + rcases output with ⟨rightPolynomial, state⟩ + cases op with + | add | sub | mul => + simp [lowerExpr, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, leftRun, rightRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + obtain ⟨middleValid, rightEval⟩ := lowerExpr_sound rightRun valid + obtain ⟨beforeValid, leftEval⟩ := lowerExpr_sound leftRun middleValid + refine ⟨beforeValid, fun active => ?_⟩ + first + | exact .add (leftEval active) (rightEval active) + | exact .sub (leftEval active) (rightEval active) + | exact .mul (leftEval active) (rightEval active) + | div => + simp [lowerExpr, fresh, guarded, constrain, StateT.run, StateT.bind, + StateT.pure, bind, pure, Except.bind, Except.pure, leftRun, rightRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + have stateValid : state.Valid calls assignment := + valid.of_subset (fun equation member => by simp [member]) (fun _ member => member) + obtain ⟨middleValid, rightEval⟩ := lowerExpr_sound rightRun stateValid + obtain ⟨beforeValid, leftEval⟩ := lowerExpr_sound leftRun middleValid + refine ⟨beforeValid, fun active => ?_⟩ + have equation := valid.constraints + (.mul enable (.sub (.mul rightPolynomial (.var state.nextVar)) (.const 1))) (by simp) + have inverseEquation : rightPolynomial.denote assignment * assignment state.nextVar - 1 = 0 := by + simpa [ArithExpr.denote, active] using equation + have evaluated := EvalExprWith.div (leftEval active) (rightEval active) + (inverse_nonzero inverseEquation) + simpa [ArithExpr.denote, inverse_eq inverseEquation, div_eq_mul_inv] using evaluated + | call name args => + cases argsRun : lowerArgs function locals enable args before with + | error error => + simp [lowerExpr, StateT.run, StateT.bind, bind, Except.bind, argsRun] at compiled + | ok output => + rcases output with ⟨arguments, state⟩ + simp [lowerExpr, fresh, boolean, constrain, StateT.run, StateT.bind, + StateT.pure, bind, pure, Except.bind, Except.pure, argsRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + have stateValid : state.Valid calls assignment := + valid.of_subset (fun equation member => by simp [member]) (fun send member => by simp [member]) + obtain ⟨beforeValid, argumentsEval⟩ := lowerArgs_sound argsRun stateValid + refine ⟨beforeValid, fun active => .call (argumentsEval active) ?_⟩ + exact valid.calls ⟨name, arguments, state.nextVar, enable⟩ (by simp) active + | matchValue scrutinee arms => + cases checked : checkPatterns function arms [] with + | error error => + simp [lowerExpr, checked, StateT.run, StateT.bind, bind, Except.bind] at compiled + | ok checkedUnit => + cases checkedUnit + cases scrutineeRun : lowerExpr function locals enable scrutinee before with + | error error => + simp [lowerExpr, checked, StateT.run, StateT.bind, bind, Except.bind, + scrutineeRun] at compiled + | ok output => + rcases output with ⟨scrutineePolynomial, middle⟩ + cases armsRun : lowerArms function locals scrutineePolynomial middle.nextVar + (literalPatterns arms) arms { middle with nextVar := middle.nextVar + 1 } with + | error error => + simp [lowerExpr, checked, StateT.run, StateT.bind, bind, Except.bind, + scrutineeRun, armsRun] at compiled + | ok output => + rcases output with ⟨selectors, state⟩ + simp [lowerExpr, checked, StateT.run, StateT.bind, + StateT.pure, bind, pure, Except.bind, Except.pure, scrutineeRun, armsRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + have stateValid : state.Valid calls assignment := + valid.of_subset (fun equation member => by simp [member]) (fun _ member => member) + obtain ⟨middleValid, armsEval⟩ := lowerArms_sound checked + (fun _ member => member) armsRun stateValid + obtain ⟨beforeValid, scrutineeEval⟩ := lowerExpr_sound scrutineeRun + ⟨middleValid.constraints, middleValid.calls⟩ + refine ⟨beforeValid, fun active => ?_⟩ + have equations : Satisfies (selectionConstraints enable selectors) assignment := + fun equation member => valid.constraints equation (by simp [member]) + have selection : SelectorsValid (1 : F) (selectors.map (ArithExpr.denote assignment)) := by + simpa [active] using (selectionConstraints_satisfies enable selectors assignment).mp equations + obtain ⟨head, tail, shape, _, _⟩ := selection.active + have oneMember : (1 : F) ∈ selectors.map (ArithExpr.denote assignment) := by + rw [shape] + simp + obtain ⟨selector, member, selected⟩ := List.mem_map.mp oneMember + obtain ⟨body, arm, _, bodyEval⟩ := armsEval ⟨selector, member, selected⟩ + exact .matchValue (scrutineeEval active) arm bodyEval + termination_by sizeOf expr + + theorem lowerArgs_sound [Field F] [DecidableEq F] + {function : String} {locals : List (String × Var)} {enable : ArithExpr F} {args : List (Expr F)} + {before after : BuildState F} {polynomials : List (ArithExpr F)} + (compiled : (lowerArgs function locals enable args).run before = .ok (polynomials, after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid calls assignment) : + before.Valid calls assignment ∧ + (enable.denote assignment = 1 → EvalArgsWith calls (localsEnvironment locals assignment) + args (polynomials.map (ArithExpr.denote assignment))) := by + cases args with + | nil => + simp [lowerArgs, StateT.run, StateT.pure, pure, Except.pure] at compiled + rcases compiled with ⟨rfl, rfl⟩ + exact ⟨valid, fun _ => .nil⟩ + | cons head tail => + cases headRun : lowerExpr function locals enable head before with + | error error => + simp [lowerArgs, StateT.run, StateT.bind, bind, Except.bind, headRun] at compiled + | ok output => + rcases output with ⟨headPolynomial, middle⟩ + cases tailRun : lowerArgs function locals enable tail middle with + | error error => + simp [lowerArgs, StateT.run, StateT.bind, bind, Except.bind, headRun, tailRun] at compiled + | ok output => + rcases output with ⟨tailPolynomials, finalState⟩ + simp [lowerArgs, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, headRun, tailRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + obtain ⟨middleValid, tailEval⟩ := lowerArgs_sound tailRun valid + obtain ⟨beforeValid, headEval⟩ := lowerExpr_sound headRun middleValid + exact ⟨beforeValid, fun active => .cons (headEval active) (tailEval active)⟩ + termination_by sizeOf args + + /-- + A selected arm evaluates the match result variable. + The extra alternative distinguishes a matching literal from a default that excludes + every explicit pattern; this is needed when skipping earlier arms in the induction. + -/ + theorem lowerArms_sound [Field F] [DecidableEq F] + {function : String} {locals : List (String × Var)} {scrutinee : ArithExpr F} {result : Var} + {literals : List F} {arms : List (Pattern F × Expr F)} + (checked : checkPatterns function arms [] = .ok ()) + (covers : ∀ literal ∈ literalPatterns arms, literal ∈ literals) + {before after : BuildState F} {selectors : List (ArithExpr F)} + (compiled : (lowerArms function locals scrutinee result literals arms).run before = .ok (selectors, after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid calls assignment) : + before.Valid calls assignment ∧ + ((∃ selector ∈ selectors, selector.denote assignment = 1) → + ∃ body, SelectArm (scrutinee.denote assignment) arms body ∧ + (scrutinee.denote assignment ∈ literalPatterns arms ∨ + ∀ literal ∈ literals, scrutinee.denote assignment ≠ literal) ∧ + EvalExprWith calls (localsEnvironment locals assignment) body (assignment result)) := by + cases arms with + | nil => + simp [lowerArms, StateT.run, StateT.pure, pure, Except.pure] at compiled + rcases compiled with ⟨rfl, rfl⟩ + exact ⟨valid, by simp⟩ + | cons arm rest => + cases armEq : arm + rename_i pattern body + simp only [armEq] at checked covers compiled ⊢ + cases pattern with + | literal value => + have distinct := ((checkPatterns_spec function ((.literal value, body) :: rest) []).mp checked).1 + have tailDistinct : value ∉ literalPatterns rest ∧ (literalPatterns rest).Nodup := by + simpa [literalPatterns] using distinct + have checkedRest : checkPatterns function rest [] = .ok () := + (checkPatterns_spec function rest []).mpr ⟨tailDistinct.2, by simp⟩ + have coversRest : ∀ literal ∈ literalPatterns rest, literal ∈ literals := + fun literal member => covers literal (by simp [literalPatterns, member]) + cases bodyRun : lowerExpr function locals (.var before.nextVar) body { + before with nextVar := before.nextVar + 1 + constraints := before.constraints.push + (.mul (.var before.nextVar) (.sub scrutinee (.const value))) } with + | error error => + simp [lowerArms, StateT.run, StateT.bind, bind, Except.bind, bodyRun] at compiled + | ok output => + rcases output with ⟨bodyPolynomial, middle⟩ + cases restRun : lowerArms function locals scrutinee result literals rest { + middle with + constraints := middle.constraints.push + (.mul (.var before.nextVar) (.sub (.var result) bodyPolynomial)) } with + | error error => + simp [lowerArms, StateT.run, StateT.bind, bind, Except.bind, bodyRun, restRun] at compiled + | ok output => + rcases output with ⟨restSelectors, state⟩ + simp [lowerArms, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, bodyRun, restRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + obtain ⟨resultValid, restEval⟩ := lowerArms_sound checkedRest coversRest restRun valid + have middleValid : middle.Valid calls assignment := + resultValid.of_subset (fun equation member => by simp [member]) (fun _ member => member) + obtain ⟨patternValid, bodyEval⟩ := lowerExpr_sound bodyRun middleValid + refine ⟨patternValid.of_subset (fun equation member => by simp [member]) + (fun _ member => member), ?_⟩ + intro selection + by_cases active : assignment before.nextVar = 1 + · have patternEquation := patternValid.constraints + (.mul (.var before.nextVar) (.sub scrutinee (.const value))) (by simp) + have equal : scrutinee.denote assignment = value := sub_eq_zero.mp + (by simpa [ArithExpr.denote, active] using patternEquation) + have resultEquation := resultValid.constraints + (.mul (.var before.nextVar) (.sub (.var result) bodyPolynomial)) (by simp) + have output : assignment result = bodyPolynomial.denote assignment := sub_eq_zero.mp + (by simpa [ArithExpr.denote, active] using resultEquation) + refine ⟨body, ?_, Or.inl (by simp [literalPatterns, equal]), ?_⟩ + · rw [equal]; exact .literal + · rw [output]; exact bodyEval active + · have tailSelected : ∃ selector ∈ restSelectors, selector.denote assignment = 1 := by + obtain ⟨selector, member, enabled⟩ := selection + rcases List.mem_cons.mp member with same | member + · subst selector; exact (active enabled).elim + · exact ⟨selector, member, enabled⟩ + obtain ⟨selectedBody, selected, reason, evaluated⟩ := restEval tailSelected + have different : value ≠ scrutinee.denote assignment := by + intro equal + rcases reason with member | excluded + · rw [← equal] at member + exact tailDistinct.1 member + · exact excluded value (covers value (by simp [literalPatterns])) equal.symm + refine ⟨selectedBody, .skip different selected, ?_, evaluated⟩ + rcases reason with member | excluded + · exact Or.inl (by simp [literalPatterns, member]) + · exact Or.inr excluded + | wildcard => + cases excludedRun : excludeLiterals (.var before.nextVar) scrutinee literals + { before with nextVar := before.nextVar + 1 } with + | error error => + simp [lowerArms, StateT.run, StateT.bind, bind, Except.bind, excludedRun] at compiled + | ok output => + rcases output with ⟨finished, middle⟩ + cases finished + cases bodyRun : lowerExpr function locals (.var before.nextVar) body middle with + | error error => + simp [lowerArms, StateT.run, StateT.bind, bind, Except.bind, excludedRun, bodyRun] at compiled + | ok output => + rcases output with ⟨bodyPolynomial, state⟩ + simp [lowerArms, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, excludedRun, bodyRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + have stateValid : state.Valid calls assignment := + valid.of_subset (fun equation member => by simp [member]) (fun _ member => member) + obtain ⟨middleValid, bodyEval⟩ := lowerExpr_sound bodyRun stateValid + obtain ⟨beforeValid, excluded⟩ := excludeLiterals_sound excludedRun middleValid + refine ⟨⟨beforeValid.constraints, beforeValid.calls⟩, ?_⟩ + rintro ⟨selector, member, active⟩ + have same := List.mem_singleton.mp member + subst selector + change assignment before.nextVar = 1 at active + have resultEquation := valid.constraints + (.mul (.var before.nextVar) (.sub (.var result) bodyPolynomial)) (by simp) + have output : assignment result = bodyPolynomial.denote assignment := sub_eq_zero.mp + (by simpa [ArithExpr.denote, active] using resultEquation) + refine ⟨body, .wildcard, Or.inr (excluded active), ?_⟩ + rw [output] + exact bodyEval active + termination_by sizeOf arms +end + +end Aiur.Scalar.Circuit.Compiler diff --git a/Aiur/Aiur/Scalar/Circuit/InactiveCorrectness.lean b/Aiur/Aiur/Scalar/Circuit/InactiveCorrectness.lean new file mode 100644 index 000000000..805b8ff3b --- /dev/null +++ b/Aiur/Aiur/Scalar/Circuit/InactiveCorrectness.lean @@ -0,0 +1,410 @@ +import Aiur.Scalar.Circuit.WitnessBasic + +namespace Aiur.Scalar.Circuit.Compiler + +/-- Default inverse equations need no nonzero differences when the selector is zero. -/ +theorem excludeLiterals_inactive [Field F] {selector scrutinee : ArithExpr F} {literals : List F} + {before after : BuildState F} + (compiled : (excludeLiterals selector scrutinee literals).run before = .ok ((), after)) + (layout : before.WellFormed) + (selectorBound : selector.inBounds before.nextVar = true) + (scrutineeBound : scrutinee.inBounds before.nextVar = true) + {assignment : Var → F} (inactive : selector.denote assignment = 0) : + InactiveExtension before after assignment ∧ after.WellFormed := by + cases literals with + | nil => + simp [excludeLiterals, StateT.run, StateT.pure, pure, Except.pure] at compiled + subst after + exact ⟨.refl _ _, layout⟩ + | cons value rest => + let equation : ArithExpr F := + .mul selector (.sub (.mul (.sub scrutinee (.const value)) (.var before.nextVar)) (.const 1)) + let next : BuildState F := { + before with nextVar := before.nextVar + 1 + constraints := before.constraints.push equation } + cases restRun : excludeLiterals selector scrutinee rest next with + | error error => + simp [excludeLiterals, StateT.run, StateT.bind, bind, Except.bind, next, equation, + restRun] at compiled + | ok output => + rcases output with ⟨finished, state⟩ + cases finished + simp [excludeLiterals, StateT.run, StateT.bind, bind, Except.bind, next, equation, + restRun] at compiled + subst after + have equationBound : equation.inBounds (before.nextVar + 1) = true := by + simp [equation, ArithExpr.inBounds, ArithExpr.inBounds_mono (Nat.le_succ _) selectorBound, + ArithExpr.inBounds_mono (Nat.le_succ _) scrutineeBound] + have nextLayout : next.WellFormed := layout.fresh.constrain equationBound + obtain ⟨extension, finalLayout⟩ := excludeLiterals_inactive restRun nextLayout + (ArithExpr.inBounds_mono (Nat.le_succ _) selectorBound) + (ArithExpr.inBounds_mono (Nat.le_succ _) scrutineeBound) inactive + have first : InactiveExtension before next assignment := + (InactiveExtension.fresh before assignment).trans + (InactiveExtension.constrain _ (by simp [equation, ArithExpr.denote, inactive])) + exact ⟨first.trans extension, finalLayout⟩ +termination_by literals.length + +mutual + /-- With a zero enable, setting every fresh variable to zero satisfies the emitted code. -/ + theorem lowerExpr_inactive [Field F] [DecidableEq F] + {function : String} {locals : List (String × Var)} {enable : ArithExpr F} {expr : Expr F} + {before after : BuildState F} {polynomial : ArithExpr F} + (compiled : (lowerExpr function locals enable expr).run before = .ok (polynomial, after)) + (layout : before.WellFormed) + (localsBound : ∀ binding ∈ locals, binding.2 < before.nextVar) + (enableBound : enable.inBounds before.nextVar = true) + {assignment : Var → F} (inactive : enable.denote assignment = 0) + (zeros : ∀ id, before.nextVar ≤ id → assignment id = 0) : + InactiveExtension before after assignment ∧ after.WellFormed ∧ + polynomial.inBounds after.nextVar = true := by + cases expr with + | literal value => + simp [lowerExpr, StateT.run, StateT.pure, pure, Except.pure] at compiled + rcases compiled with ⟨rfl, rfl⟩ + exact ⟨.refl _ _, layout, rfl⟩ + | var name => + cases found : locals.find? (·.1 == name) with + | none => + simp [lowerExpr, found, StateT.run] at compiled + cases compiled + | some binding => + rcases binding with ⟨bindingName, id⟩ + simp [lowerExpr, found, StateT.run, StateT.pure, pure, Except.pure] at compiled + rcases compiled with ⟨rfl, rfl⟩ + refine ⟨.refl _ _, layout, ?_⟩ + simpa [ArithExpr.inBounds] using + localsBound (bindingName, id) (List.mem_of_find?_eq_some found) + | neg expr => + cases lowered : lowerExpr function locals enable expr before with + | error error => + simp [lowerExpr, StateT.run, StateT.bind, bind, Except.bind, lowered] at compiled + | ok output => + rcases output with ⟨inner, state⟩ + simp [lowerExpr, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, lowered] at compiled + rcases compiled with ⟨rfl, rfl⟩ + obtain ⟨extension, finalLayout, bounded⟩ := + lowerExpr_inactive lowered layout localsBound enableBound inactive zeros + exact ⟨extension, finalLayout, by simpa [ArithExpr.inBounds] using bounded⟩ + | binary op left right => + cases leftRun : lowerExpr function locals enable left before with + | error error => + simp [lowerExpr, StateT.run, StateT.bind, bind, Except.bind, leftRun] at compiled + | ok output => + rcases output with ⟨leftPolynomial, middle⟩ + cases rightRun : lowerExpr function locals enable right middle with + | error error => + simp [lowerExpr, StateT.run, StateT.bind, bind, Except.bind, leftRun, rightRun] at compiled + | ok output => + rcases output with ⟨rightPolynomial, state⟩ + obtain ⟨leftExtension, middleLayout, leftBound⟩ := + lowerExpr_inactive leftRun layout localsBound enableBound inactive zeros + obtain ⟨rightExtension, stateLayout, rightBound⟩ := lowerExpr_inactive rightRun middleLayout + (fun binding member => lt_of_lt_of_le (localsBound binding member) leftExtension.increase) + (ArithExpr.inBounds_mono leftExtension.increase enableBound) inactive + (fun id bound => zeros id (le_trans leftExtension.increase bound)) + have extension := leftExtension.trans rightExtension + have leftFinal := ArithExpr.inBounds_mono rightExtension.increase leftBound + cases op with + | add | sub | mul => + simp [lowerExpr, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, leftRun, rightRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + exact ⟨extension, stateLayout, by simp [ArithExpr.inBounds, leftFinal, rightBound]⟩ + | div => + simp [lowerExpr, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, leftRun, rightRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + have enableFinal := ArithExpr.inBounds_mono + (le_trans extension.increase (Nat.le_succ _)) enableBound + refine ⟨extension.trans ((InactiveExtension.fresh state assignment).trans + (InactiveExtension.constrain _ (by simp [ArithExpr.denote, inactive]))), + stateLayout.fresh.constrain ?_, ?_⟩ + · simp [ArithExpr.inBounds, enableFinal, + ArithExpr.inBounds_mono (Nat.le_succ _) rightBound] + · simp [ArithExpr.inBounds, ArithExpr.inBounds_mono (Nat.le_succ _) leftFinal] + | call name args => + cases argsRun : lowerArgs function locals enable args before with + | error error => + simp [lowerExpr, StateT.run, StateT.bind, bind, Except.bind, argsRun] at compiled + | ok output => + rcases output with ⟨arguments, state⟩ + simp [lowerExpr, boolean, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, argsRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + obtain ⟨extension, stateLayout, argsBound⟩ := + lowerArgs_inactive argsRun layout localsBound enableBound inactive zeros + have enableFinal := ArithExpr.inBounds_mono + (le_trans extension.increase (Nat.le_succ _)) enableBound + have booleanBound : (ArithExpr.mul enable (.sub enable (.const 1))).inBounds + (state.nextVar + 1) = true := by simp [ArithExpr.inBounds, enableFinal] + have withBoolean := stateLayout.fresh.constrain booleanBound + refine ⟨extension.trans ((InactiveExtension.fresh state assignment).trans + ((InactiveExtension.constrain _ (by simp [ArithExpr.denote, inactive])).trans + (InactiveExtension.send _ inactive))), withBoolean.send ?_, ?_⟩ + · simp only [Send.inBounds, Bool.and_eq_true, decide_eq_true_eq, List.all_eq_true] + exact ⟨⟨Nat.lt_succ_self _, enableFinal⟩, + fun arg member => ArithExpr.inBounds_mono (Nat.le_succ _) (argsBound arg member)⟩ + · simp [ArithExpr.inBounds] + | matchValue scrutinee arms => + cases checked : checkPatterns function arms [] with + | error error => + simp [lowerExpr, checked, StateT.run, StateT.bind, bind, Except.bind] at compiled + | ok checkedUnit => + cases checkedUnit + cases scrutineeRun : lowerExpr function locals enable scrutinee before with + | error error => + simp [lowerExpr, checked, StateT.run, StateT.bind, bind, Except.bind, + scrutineeRun] at compiled + | ok output => + rcases output with ⟨scrutineePolynomial, middle⟩ + cases armsRun : lowerArms function locals scrutineePolynomial middle.nextVar + (literalPatterns arms) arms { middle with nextVar := middle.nextVar + 1 } with + | error error => + simp [lowerExpr, checked, StateT.run, StateT.bind, bind, Except.bind, + scrutineeRun, armsRun] at compiled + | ok output => + rcases output with ⟨selectors, state⟩ + simp [lowerExpr, checked, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, scrutineeRun, armsRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + obtain ⟨scrutineeExtension, middleLayout, scrutineeBound⟩ := + lowerExpr_inactive scrutineeRun layout localsBound enableBound inactive zeros + have first := scrutineeExtension.trans (InactiveExtension.fresh middle assignment) + obtain ⟨armsExtension, stateLayout, selectorsBound, selectorsZero⟩ := + lowerArms_inactive armsRun middleLayout.fresh + (fun binding member => lt_of_lt_of_le (localsBound binding member) first.increase) + (ArithExpr.inBounds_mono (Nat.le_succ _) scrutineeBound) (Nat.lt_succ_self _) + (fun id bound => zeros id (le_trans first.increase bound)) + have extension := first.trans armsExtension + have enableFinal := ArithExpr.inBounds_mono extension.increase enableBound + refine ⟨extension.trans (InactiveExtension.constrainMany _ + (selectionConstraints_zero inactive selectorsZero)), + stateLayout.constrainMany (selectionConstraints_inBounds enableFinal selectorsBound), ?_⟩ + simp only [ArithExpr.inBounds, decide_eq_true_eq] + exact lt_of_lt_of_le (Nat.lt_succ_self _) armsExtension.increase + termination_by sizeOf expr + + theorem lowerArgs_inactive [Field F] [DecidableEq F] + {function : String} {locals : List (String × Var)} {enable : ArithExpr F} {args : List (Expr F)} + {before after : BuildState F} {polynomials : List (ArithExpr F)} + (compiled : (lowerArgs function locals enable args).run before = .ok (polynomials, after)) + (layout : before.WellFormed) + (localsBound : ∀ binding ∈ locals, binding.2 < before.nextVar) + (enableBound : enable.inBounds before.nextVar = true) + {assignment : Var → F} (inactive : enable.denote assignment = 0) + (zeros : ∀ id, before.nextVar ≤ id → assignment id = 0) : + InactiveExtension before after assignment ∧ after.WellFormed ∧ + ∀ polynomial ∈ polynomials, polynomial.inBounds after.nextVar = true := by + cases args with + | nil => + simp [lowerArgs, StateT.run, StateT.pure, pure, Except.pure] at compiled + rcases compiled with ⟨rfl, rfl⟩ + exact ⟨.refl _ _, layout, by simp⟩ + | cons head tail => + cases headRun : lowerExpr function locals enable head before with + | error error => + simp [lowerArgs, StateT.run, StateT.bind, bind, Except.bind, headRun] at compiled + | ok output => + rcases output with ⟨headPolynomial, middle⟩ + cases tailRun : lowerArgs function locals enable tail middle with + | error error => + simp [lowerArgs, StateT.run, StateT.bind, bind, Except.bind, headRun, tailRun] at compiled + | ok output => + rcases output with ⟨tailPolynomials, state⟩ + simp [lowerArgs, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, headRun, tailRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + obtain ⟨headExtension, middleLayout, headBound⟩ := + lowerExpr_inactive headRun layout localsBound enableBound inactive zeros + obtain ⟨tailExtension, stateLayout, tailBounds⟩ := lowerArgs_inactive tailRun middleLayout + (fun binding member => lt_of_lt_of_le (localsBound binding member) headExtension.increase) + (ArithExpr.inBounds_mono headExtension.increase enableBound) inactive + (fun id bound => zeros id (le_trans headExtension.increase bound)) + refine ⟨headExtension.trans tailExtension, stateLayout, ?_⟩ + intro polynomial member + rcases List.mem_cons.mp member with rfl | member + · exact ArithExpr.inBounds_mono tailExtension.increase headBound + · exact tailBounds polynomial member + termination_by sizeOf args + + /-- All arms can be disabled simultaneously, including their nested matches and calls. -/ + theorem lowerArms_inactive [Field F] [DecidableEq F] + {function : String} {locals : List (String × Var)} {scrutinee : ArithExpr F} {result : Var} + {literals : List F} {arms : List (Pattern F × Expr F)} + {before after : BuildState F} {selectors : List (ArithExpr F)} + (compiled : (lowerArms function locals scrutinee result literals arms).run before = .ok (selectors, after)) + (layout : before.WellFormed) + (localsBound : ∀ binding ∈ locals, binding.2 < before.nextVar) + (scrutineeBound : scrutinee.inBounds before.nextVar = true) + (resultBound : result < before.nextVar) + {assignment : Var → F} (zeros : ∀ id, before.nextVar ≤ id → assignment id = 0) : + InactiveExtension before after assignment ∧ after.WellFormed ∧ + (∀ selector ∈ selectors, selector.inBounds after.nextVar = true) ∧ + (∀ selector ∈ selectors, selector.denote assignment = 0) := by + cases arms with + | nil => + simp [lowerArms, StateT.run, StateT.pure, pure, Except.pure] at compiled + rcases compiled with ⟨rfl, rfl⟩ + exact ⟨.refl _ _, layout, by simp, by simp⟩ + | cons arm rest => + cases armEq : arm + rename_i pattern body + simp only [armEq] at compiled ⊢ + have selectorZero : assignment before.nextVar = 0 := zeros _ (Nat.le_refl _) + cases pattern with + | literal value => + let patternEquation : ArithExpr F := + .mul (.var before.nextVar) (.sub scrutinee (.const value)) + let start : BuildState F := { + before with nextVar := before.nextVar + 1 + constraints := before.constraints.push patternEquation } + have first : InactiveExtension before start assignment := + (InactiveExtension.fresh before assignment).trans + (InactiveExtension.constrain _ (by simp [patternEquation, ArithExpr.denote, selectorZero])) + have startLayout : start.WellFormed := layout.fresh.constrain (by + simp [patternEquation, ArithExpr.inBounds, + ArithExpr.inBounds_mono (Nat.le_succ _) scrutineeBound]) + cases bodyRun : lowerExpr function locals (.var before.nextVar) body start with + | error error => + simp [lowerArms, StateT.run, StateT.bind, bind, Except.bind, start, + patternEquation, bodyRun] at compiled + | ok output => + rcases output with ⟨bodyPolynomial, middle⟩ + obtain ⟨bodyExtension, middleLayout, bodyBound⟩ := lowerExpr_inactive bodyRun startLayout + (fun binding member => lt_of_lt_of_le (localsBound binding member) first.increase) + (by simp [start, ArithExpr.inBounds]) selectorZero + (fun id bound => zeros id (le_trans first.increase bound)) + have extension := first.trans bodyExtension + have selectorBound : before.nextVar < middle.nextVar := + lt_of_lt_of_le (Nat.lt_succ_self _) bodyExtension.increase + let resultEquation : ArithExpr F := + .mul (.var before.nextVar) (.sub (.var result) bodyPolynomial) + let next : BuildState F := { middle with constraints := middle.constraints.push resultEquation } + have nextLayout : next.WellFormed := middleLayout.constrain (by + simp [resultEquation, ArithExpr.inBounds, selectorBound, bodyBound, + lt_of_lt_of_le resultBound extension.increase]) + have nextExtension : InactiveExtension before next assignment := extension.trans + (InactiveExtension.constrain _ (by simp [resultEquation, ArithExpr.denote, selectorZero])) + cases restRun : lowerArms function locals scrutinee result literals rest next with + | error error => + simp [lowerArms, StateT.run, StateT.bind, bind, Except.bind, start, + patternEquation, next, resultEquation, bodyRun, restRun] at compiled + | ok output => + rcases output with ⟨restSelectors, state⟩ + simp [lowerArms, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, start, patternEquation, next, resultEquation, + bodyRun, restRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + obtain ⟨restExtension, finalLayout, restBound, restZero⟩ := + lowerArms_inactive restRun nextLayout + (fun binding member => lt_of_lt_of_le (localsBound binding member) nextExtension.increase) + (ArithExpr.inBounds_mono nextExtension.increase scrutineeBound) + (lt_of_lt_of_le resultBound nextExtension.increase) + (fun id bound => zeros id (le_trans nextExtension.increase bound)) + refine ⟨nextExtension.trans restExtension, finalLayout, ?_, ?_⟩ + · intro selector member + rcases List.mem_cons.mp member with rfl | member + · simp only [ArithExpr.inBounds, decide_eq_true_eq] + exact lt_of_lt_of_le selectorBound restExtension.increase + · exact restBound selector member + · intro selector member + rcases List.mem_cons.mp member with rfl | member + · exact selectorZero + · exact restZero selector member + | wildcard => + cases excludedRun : excludeLiterals (.var before.nextVar) scrutinee literals + { before with nextVar := before.nextVar + 1 } with + | error error => + simp [lowerArms, StateT.run, StateT.bind, bind, Except.bind, excludedRun] at compiled + | ok output => + rcases output with ⟨finished, middle⟩ + cases finished + obtain ⟨excludedExtension, middleLayout⟩ := excludeLiterals_inactive excludedRun layout.fresh + (by simp [ArithExpr.inBounds]) (ArithExpr.inBounds_mono (Nat.le_succ _) scrutineeBound) + selectorZero + have first := (InactiveExtension.fresh before assignment).trans excludedExtension + have selectorBound : before.nextVar < middle.nextVar := + lt_of_lt_of_le (Nat.lt_succ_self _) excludedExtension.increase + cases bodyRun : lowerExpr function locals (.var before.nextVar) body middle with + | error error => + simp [lowerArms, StateT.run, StateT.bind, bind, Except.bind, excludedRun, bodyRun] at compiled + | ok output => + rcases output with ⟨bodyPolynomial, state⟩ + simp [lowerArms, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, excludedRun, bodyRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + obtain ⟨bodyExtension, stateLayout, bodyBound⟩ := lowerExpr_inactive bodyRun middleLayout + (fun binding member => lt_of_lt_of_le (localsBound binding member) first.increase) + (by simpa [ArithExpr.inBounds] using selectorBound) selectorZero + (fun id bound => zeros id (le_trans first.increase bound)) + have extension := first.trans bodyExtension + have selectorFinal := lt_of_lt_of_le selectorBound bodyExtension.increase + refine ⟨extension.trans (InactiveExtension.constrain _ + (by simp [ArithExpr.denote, selectorZero])), stateLayout.constrain ?_, ?_, ?_⟩ + · simp [ArithExpr.inBounds, bodyBound, selectorFinal, + lt_of_lt_of_le resultBound extension.increase] + · simpa [ArithExpr.inBounds] using selectorFinal + · simpa [ArithExpr.denote] using selectorZero + termination_by sizeOf arms +end + +/-- A finite witness for inactive code, with no assumption that the expression evaluates. -/ +theorem lowerExpr_inactive_complete [Field F] [DecidableEq F] + {function : String} {locals : List (String × Var)} {enable : ArithExpr F} {expr : Expr F} + {before after : BuildState F} {polynomial : ArithExpr F} + (compiled : (lowerExpr function locals enable expr).run before = .ok (polynomial, after)) + (layout : before.WellFormed) + (localsBound : ∀ binding ∈ locals, binding.2 < before.nextVar) + (enableBound : enable.inBounds before.nextVar = true) + {calls : CallRelation F} {initial : List F} (size : initial.length = before.nextVar) + (valid : before.Valid calls (Row.assignment ⟨function, initial⟩)) + (inactive : enable.denote (Row.assignment ⟨function, initial⟩) = 0) : + ∃ values, initial.IsPrefix values ∧ values.length = after.nextVar ∧ + after.WellFormed ∧ polynomial.inBounds after.nextVar = true ∧ + after.Valid calls (Row.assignment ⟨function, values⟩) ∧ + InactiveExtension before after (Row.assignment ⟨function, values⟩) := by + obtain ⟨extension, finalLayout, bounded⟩ := lowerExpr_inactive compiled layout localsBound enableBound + inactive (fun id bound => by + simp [Row.assignment, List.getElem?_eq_none (show initial.length ≤ id by omega)]) + refine ⟨initial ++ List.replicate (after.nextVar - before.nextVar) 0, + List.prefix_append _ _, ?_, finalLayout, bounded, ?_, ?_⟩ + · simp only [List.length_append, List.length_replicate, size] + exact Nat.add_sub_of_le extension.increase + · rw [assignment_append_zeros] + exact extension.valid valid + · rw [assignment_append_zeros] + exact extension + +/-- A finite witness disabling an entire arm list while preserving the match result. -/ +theorem lowerArms_inactive_complete [Field F] [DecidableEq F] + {function : String} {locals : List (String × Var)} {scrutinee : ArithExpr F} {result : Var} + {literals : List F} {arms : List (Pattern F × Expr F)} + {before after : BuildState F} {selectors : List (ArithExpr F)} + (compiled : (lowerArms function locals scrutinee result literals arms).run before = .ok (selectors, after)) + (layout : before.WellFormed) + (localsBound : ∀ binding ∈ locals, binding.2 < before.nextVar) + (scrutineeBound : scrutinee.inBounds before.nextVar = true) (resultBound : result < before.nextVar) + {calls : CallRelation F} {initial : List F} (size : initial.length = before.nextVar) + (valid : before.Valid calls (Row.assignment ⟨function, initial⟩)) : + ∃ values, initial.IsPrefix values ∧ values.length = after.nextVar ∧ after.WellFormed ∧ + (∀ selector ∈ selectors, selector.inBounds after.nextVar = true) ∧ + after.Valid calls (Row.assignment ⟨function, values⟩) ∧ + (∀ selector ∈ selectors, selector.denote (Row.assignment ⟨function, values⟩) = 0) ∧ + InactiveExtension before after (Row.assignment ⟨function, values⟩) := by + obtain ⟨extension, finalLayout, bounded, zeros⟩ := lowerArms_inactive compiled layout localsBound + scrutineeBound resultBound (assignment := Row.assignment ⟨function, initial⟩) + (fun id bound => by simp [Row.assignment, List.getElem?_eq_none (show initial.length ≤ id by omega)]) + refine ⟨initial ++ List.replicate (after.nextVar - before.nextVar) 0, + List.prefix_append _ _, ?_, finalLayout, bounded, ?_, ?_, ?_⟩ + · simp only [List.length_append, List.length_replicate, size] + exact Nat.add_sub_of_le extension.increase + · rw [assignment_append_zeros] + exact extension.valid valid + · rw [assignment_append_zeros] + exact zeros + · rw [assignment_append_zeros] + exact extension + +end Aiur.Scalar.Circuit.Compiler diff --git a/Aiur/Aiur/Scalar/Circuit/LocalCorrectness.lean b/Aiur/Aiur/Scalar/Circuit/LocalCorrectness.lean new file mode 100644 index 000000000..f6db3f0aa --- /dev/null +++ b/Aiur/Aiur/Scalar/Circuit/LocalCorrectness.lean @@ -0,0 +1,111 @@ +import Aiur.Scalar.Semantics.WithCalls +import Aiur.Scalar.Circuit.CompileFacts +import Aiur.Scalar.Circuit.Derivation +import Aiur.Scalar.Circuit.ExpressionCorrectness +import Aiur.Scalar.Circuit.WitnessCorrectness + +namespace Aiur.Scalar.Circuit.Compiler + +/-- +Satisfying a compiled body recovers its +source evaluation, provided every enabled call is justified by `calls`. +This lemma does not assume anything about recursive function evaluation. +-/ +theorem lowerFunction_sound [Field F] [DecidableEq F] + {defn : Function F} {chip : Chip F} (compiled : lowerFunction defn = .ok chip) + {calls : CallRelation F} {row : Row F} (valid : chip.ValidRow row) + (premises : ∀ message ∈ chip.premises row, + calls message.channel message.args message.result) : + EvalExprWith calls (defn.params.zip (chip.receive row).args) defn.body + (chip.receive row).result := by + cases lowered : + (lowerExpr defn.name (defn.params.zip (List.range defn.params.length)) + (.const 1) defn.body).run { nextVar := defn.params.length + 1 } with + | error error => simp [lowerFunction, lowered] at compiled + | ok output => + rcases output with ⟨polynomial, state⟩ + simp [lowerFunction, lowered] at compiled + subst chip + have callsValid := (Chip.premises_forall _ row + (fun message => calls message.channel message.args message.result)).mp premises + have stateValid : state.Valid calls row.assignment := { + constraints := fun equation member => + valid.2.2 equation (by simp [member]) + calls := callsValid + } + have body := (lowerExpr_sound lowered stateValid).2 rfl + have outputEquation := valid.2.2 (.sub (.var defn.params.length) polynomial) (by simp) + have result : row.assignment defn.params.length = polynomial.denote row.assignment := by + exact sub_eq_zero.mp outputEquation + have enough : defn.params.length ≤ row.values.length := by + have arity := valid.receive_arity + simp only [Chip.receive, List.length_take] at arity + omega + simpa only [localsEnvironment, parameter_environment defn.params row enough, + Chip.receive, result] using body + +/-- +Construct a simultaneous assignment for +one compiled body. Inactive branches must be satisfiable without evaluating them. +-/ +theorem lowerFunction_complete [Field F] [DecidableEq F] + {defn : Function F} {chip : Chip F} (compiled : lowerFunction defn = .ok chip) + {calls : CallRelation F} {args : List F} {result : F} + (arity : defn.params.length = args.length) + (body : EvalExprWith calls (defn.params.zip args) defn.body result) : + ∃ row, row.chip = defn.name ∧ chip.ValidRow row ∧ + chip.receive row = ⟨defn.name, args, result⟩ ∧ + ∀ message ∈ chip.premises row, calls message.channel message.args message.result := by + cases lowered : + (lowerExpr defn.name (defn.params.zip (List.range defn.params.length)) + (.const 1) defn.body).run { nextVar := defn.params.length + 1 } with + | error error => simp [lowerFunction, lowered] at compiled + | ok output => + rcases output with ⟨polynomial, state⟩ + simp [lowerFunction, lowered] at compiled + subst chip + let initial : Row F := ⟨defn.name, args ++ [result]⟩ + have environment : localsEnvironment + (defn.params.zip (List.range defn.params.length)) initial.assignment = defn.params.zip args := by + simpa [localsEnvironment, initial, arity] using + parameter_environment defn.params initial (by simp [initial, arity]) + have sourceBody : EvalExprWith calls + (localsEnvironment (defn.params.zip (List.range defn.params.length)) initial.assignment) + defn.body result := by rw [environment]; exact body + have localsBound : ∀ binding ∈ defn.params.zip (List.range defn.params.length), + binding.2 < defn.params.length + 1 := by + intro binding member + have bound := List.mem_range.mp (List.of_mem_zip member).2 + omega + obtain ⟨values, extension, size, layout, polynomialBound, stateValid, resultValue⟩ := + lowerExpr_complete lowered + ⟨by simp, by simp⟩ localsBound rfl (initial := initial.values) + (by simp [initial, arity]) ⟨by simp [Satisfies], by simp⟩ rfl sourceBody + let row : Row F := ⟨defn.name, values⟩ + change polynomial.denote row.assignment = result at resultValue + have outputBound : defn.params.length < state.nextVar := by + have bound := extension.length_le + simp only [initial, List.length_append, List.length_singleton, ← arity] at bound + omega + have outputValue : row.assignment defn.params.length = result := by + rw [Row.assignment_of_prefix (before := initial) (after := row) extension + (by simp [initial, arity])] + simp [initial, Row.assignment, arity] + have inputs : values.take defn.params.length = args := by + obtain ⟨extra, shape⟩ := extension + rw [← shape] + simp [initial, List.append_assoc, arity] + refine ⟨row, rfl, ⟨?_, size, ?_⟩, ?_, ?_⟩ + · simp [Chip.wellFormed, outputBound, layout.constraints, layout.sends, + ArithExpr.inBounds, polynomialBound] + · intro equation member + simp only [List.mem_append, List.mem_singleton] at member + rcases member with member | same + · exact stateValid.constraints equation member + · subst equation + simp only [ArithExpr.denote, outputValue, resultValue, sub_self] + · simp only [Chip.receive, row, inputs, outputValue] + · exact (Chip.premises_forall _ row + (fun message => calls message.channel message.args message.result)).mpr stateValid.calls + +end Aiur.Scalar.Circuit.Compiler diff --git a/Aiur/Aiur/Scalar/Circuit/MatchWitness.lean b/Aiur/Aiur/Scalar/Circuit/MatchWitness.lean new file mode 100644 index 000000000..18abc8e59 --- /dev/null +++ b/Aiur/Aiur/Scalar/Circuit/MatchWitness.lean @@ -0,0 +1,67 @@ +import Aiur.Scalar.Circuit.InactiveCorrectness + +namespace Aiur.Scalar.Circuit.Compiler + +/-- A selected default admits inverse witnesses for every excluded literal. -/ +theorem excludeLiterals_complete [Field F] {function : String} + {selector scrutinee : ArithExpr F} {literals : List F} {before after : BuildState F} + (compiled : (excludeLiterals selector scrutinee literals).run before = .ok ((), after)) + (layout : before.WellFormed) + (selectorBound : selector.inBounds before.nextVar = true) + (scrutineeBound : scrutinee.inBounds before.nextVar = true) + {calls : CallRelation F} {initial : List F} (size : initial.length = before.nextVar) + (valid : before.Valid calls (Row.assignment ⟨function, initial⟩)) + (active : selector.denote (Row.assignment ⟨function, initial⟩) = 1) + (excluded : ∀ literal ∈ literals, scrutinee.denote (Row.assignment ⟨function, initial⟩) ≠ literal) : + ∃ values, initial.IsPrefix values ∧ values.length = after.nextVar ∧ + after.WellFormed ∧ after.Valid calls (Row.assignment ⟨function, values⟩) := by + cases literals with + | nil => + simp [excludeLiterals, StateT.run, StateT.pure, pure, Except.pure] at compiled + subst after + exact ⟨initial, ⟨[], by simp⟩, size, layout, valid⟩ + | cons value rest => + let equation : ArithExpr F := + .mul selector (.sub (.mul (.sub scrutinee (.const value)) (.var before.nextVar)) (.const 1)) + let next : BuildState F := { + before with nextVar := before.nextVar + 1 + constraints := before.constraints.push equation } + cases restRun : excludeLiterals selector scrutinee rest next with + | error error => + simp [excludeLiterals, StateT.run, StateT.bind, bind, Except.bind, next, equation, + restRun] at compiled + | ok output => + rcases output with ⟨finished, state⟩ + cases finished + simp [excludeLiterals, StateT.run, StateT.bind, bind, Except.bind, next, equation, + restRun] at compiled + subst after + let inverse := (scrutinee.denote (Row.assignment ⟨function, initial⟩) - value)⁻¹ + let padded := initial ++ [inverse] + have extension : initial.IsPrefix padded := List.prefix_append _ _ + have inverseValue : Row.assignment ⟨function, padded⟩ before.nextVar = inverse := by + rw [← size] + exact assignment_append_value _ _ _ + have selectorValue := denote_of_prefix (function := function) extension size selectorBound + have scrutineeValue := denote_of_prefix (function := function) extension size scrutineeBound + have oldValid := valid.of_prefix layout size extension + have freshValid : { before with nextVar := before.nextVar + 1 }.Valid calls + (Row.assignment ⟨function, padded⟩) := ⟨oldValid.constraints, oldValid.calls⟩ + have nextValid : next.Valid calls (Row.assignment ⟨function, padded⟩) := + freshValid.constrain (by + simp [equation, ArithExpr.denote, selectorValue, active, scrutineeValue, inverseValue, + inverse, sub_ne_zero.mpr (excluded value (by simp))]) + have nextLayout : next.WellFormed := layout.fresh.constrain (by + simp [equation, ArithExpr.inBounds, ArithExpr.inBounds_mono (Nat.le_succ _) selectorBound, + ArithExpr.inBounds_mono (Nat.le_succ _) scrutineeBound]) + obtain ⟨values, finalExtension, finalSize, finalLayout, finalValid⟩ := + excludeLiterals_complete restRun nextLayout + (ArithExpr.inBounds_mono (Nat.le_succ _) selectorBound) + (ArithExpr.inBounds_mono (Nat.le_succ _) scrutineeBound) + (by simp [padded, next, size]) nextValid + (selectorValue.trans active) + (fun literal member => by rw [scrutineeValue]; exact excluded literal (by simp [member])) + exact ⟨values, extension.trans finalExtension, finalSize, finalLayout, finalValid⟩ +termination_by literals.length + +end Aiur.Scalar.Circuit.Compiler diff --git a/Aiur/Aiur/Scalar/Circuit/MemoAcyclic.lean b/Aiur/Aiur/Scalar/Circuit/MemoAcyclic.lean new file mode 100644 index 000000000..46368d081 --- /dev/null +++ b/Aiur/Aiur/Scalar/Circuit/MemoAcyclic.lean @@ -0,0 +1,47 @@ +import Aiur.Scalar.Circuit.MemoDerivation +import Mathlib.Data.Fintype.Card +import Mathlib.Data.Fintype.Fin +import Mathlib.Logic.Relation +import Mathlib.Order.WellFounded + +namespace Aiur.Scalar.Circuit.MemoDerivation + +variable [Field F] [DecidableEq F] {system : System F} {message : Message F} + +/-- An enabled premise of `parent` is supplied by `child`, oriented for induction. -/ +def Dependency (graph : MemoDerivation system message) (child parent : Fin graph.size) : Prop := + ∃ j : Fin (graph.node parent).premises.length, graph.target parent j = child + +/-- No node lies on a nonempty directed path back to itself. Sharing is allowed. -/ +def Acyclic (graph : MemoDerivation system message) : Prop := + ∀ i, ¬ Relation.TransGen graph.Dependency i i + +/-- On the finite node set, the absence of directed cycles permits dependency induction. -/ +theorem Acyclic.wellFounded {graph : MemoDerivation system message} + (acyclic : graph.Acyclic) : WellFounded graph.Dependency := by + letI : Std.Irrefl (Relation.TransGen graph.Dependency) := ⟨acyclic⟩ + exact (Finite.wellFounded_of_trans_of_irrefl (Relation.TransGen graph.Dependency)).mono + (fun _ _ edge => .single edge) + +/-- Unfold the dependencies of any node into a finite, closed derivation tree. -/ +theorem node_derives_of_acyclic (graph : MemoDerivation system message) + (acyclic : graph.Acyclic) (i : Fin graph.size) : + Derives system (graph.node i).conclusion := by + induction i using acyclic.wellFounded.induction with + | h i ih => + have premises : ∀ premise ∈ (graph.node i).premises, Derives system premise := by + intro premise member + obtain ⟨j, bounded, same⟩ := List.mem_iff_getElem.mp member + have child := ih (graph.target i ⟨j, bounded⟩) ⟨⟨j, bounded⟩, rfl⟩ + rwa [(graph.target_claim i ⟨j, bounded⟩).trans same] at child + obtain ⟨children⟩ := derivations_nonempty_iff.mpr premises + exact ⟨.node (graph.node i).chip (graph.node i).row + (graph.node i).lookup (graph.node i).valid children⟩ + +/-- An acyclic memoized graph supplies an ordinary derivation of its root claim. -/ +theorem derives_of_acyclic (graph : MemoDerivation system message) + (acyclic : graph.Acyclic) : Derives system message := by + rw [← graph.root_claim] + exact graph.node_derives_of_acyclic acyclic graph.root + +end Aiur.Scalar.Circuit.MemoDerivation diff --git a/Aiur/Aiur/Scalar/Circuit/MemoDerivation.lean b/Aiur/Aiur/Scalar/Circuit/MemoDerivation.lean new file mode 100644 index 000000000..b9bb4f594 --- /dev/null +++ b/Aiur/Aiur/Scalar/Circuit/MemoDerivation.lean @@ -0,0 +1,149 @@ +import Aiur.Scalar.Circuit.Derivation + +namespace Aiur.Scalar.Circuit + +/-- One locally checked rule instance, without proofs of its call premises. -/ +structure RuleInstance [Field F] (system : System F) where + chip : Chip F + row : Row F + lookup : system.findChip? row.chip = some chip + valid : chip.ValidRow row + +def RuleInstance.conclusion [Field F] {system : System F} + (rule : RuleInstance system) : Message F := rule.chip.receive rule.row + +def RuleInstance.premises [Field F] [DecidableEq F] {system : System F} + (rule : RuleInstance system) : List (Message F) := rule.chip.premises rule.row + +/-- +A finite graph of locally valid rules. Every enabled call has an explicit target +with the required conclusion. References may be shared or cyclic, including self-references. +There is no ordering, rank, multiplicity, or source-termination condition. +-/ +structure MemoDerivation [Field F] [DecidableEq F] (system : System F) + (message : Message F) where + size : Nat + node : Fin size → RuleInstance system + root : Fin size + root_claim : (node root).conclusion = message + target : (i : Fin size) → Fin (node i).premises.length → Fin size + target_claim : ∀ i j, (node (target i j)).conclusion = (node i).premises[j] + +/-- Memoized acceptance asserts the existence of a finite, possibly cyclic graph. -/ +def MemoDerives [Field F] [DecidableEq F] (system : System F) (message : Message F) : Prop := + Nonempty (MemoDerivation system message) + +def MemoAccepts [Field F] [DecidableEq F] (system : System F) + (function : String) (args : List F) (result : F) : Prop := + MemoDerives system ⟨function, args, result⟩ + +/-- The claims represented anywhere in a graph, including its root. -/ +def MemoDerivation.Claims [Field F] [DecidableEq F] {system : System F} {message : Message F} + (graph : MemoDerivation system message) (claim : Message F) : Prop := + ∃ i, (graph.node i).conclusion = claim + +theorem MemoDerivation.root_mem [Field F] [DecidableEq F] + {system : System F} {message : Message F} (graph : MemoDerivation system message) : + graph.Claims message := ⟨graph.root, graph.root_claim⟩ + +theorem MemoDerivation.premise_mem [Field F] [DecidableEq F] + {system : System F} {message : Message F} (graph : MemoDerivation system message) + (i : Fin graph.size) {premise : Message F} (member : premise ∈ (graph.node i).premises) : + graph.Claims premise := by + obtain ⟨j, bounded, same⟩ := List.mem_iff_getElem.mp member + exact ⟨graph.target i ⟨j, bounded⟩, (graph.target_claim i ⟨j, bounded⟩).trans same⟩ + +/-- Build explicit references from a finite table closed under call premises. -/ +noncomputable def MemoDerivation.ofClosed [Field F] [DecidableEq F] + {system : System F} {message : Message F} (rules : List (RuleInstance system)) + (root : ∃ rule ∈ rules, rule.conclusion = message) + (closed : ∀ rule ∈ rules, ∀ premise ∈ rule.premises, + ∃ provider ∈ rules, provider.conclusion = premise) : MemoDerivation system message := by + have locate {claim : Message F} (present : ∃ rule ∈ rules, rule.conclusion = claim) : + ∃ i : Fin rules.length, rules[i].conclusion = claim := by + obtain ⟨rule, member, conclusion⟩ := present + obtain ⟨i, bounded, same⟩ := List.mem_iff_getElem.mp member + exact ⟨⟨i, bounded⟩, by simpa [same] using conclusion⟩ + let rootIndex := Classical.choose (locate root) + have targets (i : Fin rules.length) (j : Fin rules[i].premises.length) : + ∃ target : Fin rules.length, rules[target].conclusion = rules[i].premises[j] := + locate (closed rules[i] (List.getElem_mem _) _ (List.getElem_mem _)) + exact { + size := rules.length + node := fun i => rules[i] + root := rootIndex + root_claim := Classical.choose_spec (locate root) + target := fun i j => Classical.choose (targets i j) + target_claim := fun i j => Classical.choose_spec (targets i j) + } + +mutual + /-- Keep each tree occurrence as a locally valid graph node. -/ + def Derivation.instances [Field F] [DecidableEq F] {system : System F} {message : Message F} : + Derivation system message → List (RuleInstance system) + | .node chip row lookup valid children => ⟨chip, row, lookup, valid⟩ :: children.instances + + def Derivations.instances [Field F] [DecidableEq F] {system : System F} {messages : List (Message F)} : + Derivations system messages → List (RuleInstance system) + | .nil => [] + | .cons head tail => head.instances ++ tail.instances +end + +theorem Derivation.root_instance [Field F] [DecidableEq F] + {system : System F} {message : Message F} (tree : Derivation system message) : + ∃ rule ∈ tree.instances, rule.conclusion = message := by + cases tree with + | node chip row lookup valid children => exact ⟨⟨chip, row, lookup, valid⟩, by simp [instances], rfl⟩ + +theorem Derivations.root_instances [Field F] [DecidableEq F] + {system : System F} {messages : List (Message F)} (trees : Derivations system messages) : + ∀ message ∈ messages, ∃ rule ∈ trees.instances, rule.conclusion = message := by + cases trees with + | nil => simp + | cons head tail => + intro message member + rcases List.mem_cons.mp member with rfl | member + · obtain ⟨rule, present, conclusion⟩ := head.root_instance + exact ⟨rule, by simp [instances, present], conclusion⟩ + · obtain ⟨rule, present, conclusion⟩ := tail.root_instances message member + exact ⟨rule, by simp [instances, present], conclusion⟩ +termination_by structural trees + +theorem Derivation.instances_closed [Field F] [DecidableEq F] + {system : System F} {message : Message F} (tree : Derivation system message) : + ∀ rule ∈ tree.instances, ∀ premise ∈ rule.premises, + ∃ provider ∈ tree.instances, provider.conclusion = premise := by + induction tree using Derivation.rec + (motive_2 := fun messages (trees : Derivations system messages) => + ∀ (rule : RuleInstance system), rule ∈ trees.instances → ∀ premise ∈ rule.premises, + ∃ provider ∈ trees.instances, provider.conclusion = premise) with + | node chip row lookup valid children ih => + intro rule member premise required + simp only [instances, List.mem_cons] at member + rcases member with rfl | member + · obtain ⟨provider, present, conclusion⟩ := children.root_instances premise required + exact ⟨provider, by simp [instances, present], conclusion⟩ + · obtain ⟨provider, present, conclusion⟩ := ih rule member premise required + exact ⟨provider, by simp [instances, present], conclusion⟩ + | nil => rename_i rule member premise required; simp [Derivations.instances] at member + | cons head tail headIH tailIH => + rename_i rule member premise required + simp only [Derivations.instances, List.mem_append] at member + rcases member with member | member + · obtain ⟨provider, present, conclusion⟩ := headIH rule member premise required + exact ⟨provider, by simp [Derivations.instances, present], conclusion⟩ + · obtain ⟨provider, present, conclusion⟩ := tailIH rule member premise required + exact ⟨provider, by simp [Derivations.instances, present], conclusion⟩ + +/-- Every ordinary derivation supplies a memoized graph; cycles are not required. -/ +noncomputable def Derivation.toMemo [Field F] [DecidableEq F] + {system : System F} {message : Message F} (tree : Derivation system message) : + MemoDerivation system message := + .ofClosed tree.instances tree.root_instance tree.instances_closed + +theorem Derives.memo [Field F] [DecidableEq F] {system : System F} {message : Message F} + (derives : Derives system message) : MemoDerives system message := by + obtain ⟨tree⟩ := derives + exact ⟨tree.toMemo⟩ + +end Aiur.Scalar.Circuit diff --git a/Aiur/Aiur/Scalar/Circuit/Selectors.lean b/Aiur/Aiur/Scalar/Circuit/Selectors.lean new file mode 100644 index 000000000..766c8b82f --- /dev/null +++ b/Aiur/Aiur/Scalar/Circuit/Selectors.lean @@ -0,0 +1,106 @@ +import Aiur.Scalar.Circuit.Basic +import Mathlib.Algebra.BigOperators.Group.List.Basic + +namespace Aiur.Scalar.Circuit + +/-- Values satisfying the Boolean, pairwise exclusion, and sum selector equations. -/ +structure SelectorsValid [Field F] (parent : F) (selectors : List F) : Prop where + boolean : ∀ selector ∈ selectors, selector * (selector - 1) = 0 + exclusive : selectors.Pairwise (fun left right => left * right = 0) + sum : selectors.sum = parent + +/-- Adding a disabled branch preserves all selector equations. -/ +theorem SelectorsValid.zero_cons [Field F] {parent : F} {selectors : List F} + (valid : SelectorsValid parent selectors) : SelectorsValid parent (0 :: selectors) := by + refine ⟨?_, List.pairwise_cons.mpr ⟨by simp, valid.exclusive⟩, by simpa using valid.sum⟩ + intro selector member + rcases List.mem_cons.mp member with rfl | member + · simp + · exact valid.boolean selector member + +/-- All-zero selectors supply a witness for an inactive match. -/ +theorem SelectorsValid.zeros [Field F] {selectors : List F} + (zeros : ∀ selector ∈ selectors, selector = 0) : SelectorsValid (0 : F) selectors := by + induction selectors with + | nil => exact ⟨by simp, by simp, rfl⟩ + | cons head tail ih => + have headZero := zeros head (by simp) + subst head + exact (ih (fun selector member => zeros selector (by simp [member]))).zero_cons + +/-- A chosen branch and zeroes elsewhere supply a witness for an active match. -/ +theorem SelectorsValid.single [Field F] {before after : List F} + (beforeZero : ∀ selector ∈ before, selector = 0) + (afterZero : ∀ selector ∈ after, selector = 0) : + SelectorsValid (1 : F) (before ++ 1 :: after) := by + induction before with + | nil => + have tail := SelectorsValid.zeros afterZero + refine ⟨?_, List.pairwise_cons.mpr ⟨by simpa using afterZero, tail.exclusive⟩, ?_⟩ + · intro selector member + rcases List.mem_cons.mp member with rfl | member + · simp + · exact tail.boolean selector member + · simp [tail.sum] + | cons head tail ih => + have headZero := beforeZero head (by simp) + subst head + exact (ih (fun selector member => beforeZero selector (by simp [member]))).zero_cons + +/-- An inactive match forces every selector to zero, in any field characteristic. -/ +theorem SelectorsValid.inactive [Field F] {selectors : List F} + (valid : SelectorsValid (0 : F) selectors) : ∀ selector ∈ selectors, selector = 0 := by + induction selectors with + | nil => simp + | cons head tail ih => + obtain ⟨pairs, exclusive⟩ := List.pairwise_cons.mp valid.exclusive + rcases selector_boolean (valid.boolean head (by simp)) with zero | one + · subst head + have tailValid : SelectorsValid (0 : F) tail := { + boolean := fun value member => valid.boolean value (by simp [member]) + exclusive + sum := by simpa using valid.sum + } + intro value member + rcases List.mem_cons.mp member with zero | member + · exact zero + · exact ih tailValid value member + · subst head + have zeros : ∀ value ∈ tail, value = 0 := by simpa using pairs + have tailSum : tail.sum = 0 := List.sum_eq_zero zeros + have impossible := valid.sum + simp [tailSum] at impossible + +/-- An active match has exactly one selected occurrence; all other selectors are zero. -/ +theorem SelectorsValid.active [Field F] {selectors : List F} + (valid : SelectorsValid (1 : F) selectors) : + ∃ before after, selectors = before ++ 1 :: after ∧ + (∀ selector ∈ before, selector = 0) ∧ (∀ selector ∈ after, selector = 0) := by + induction selectors with + | nil => simpa using valid.sum + | cons head tail ih => + obtain ⟨pairs, exclusive⟩ := List.pairwise_cons.mp valid.exclusive + rcases selector_boolean (valid.boolean head (by simp)) with zero | one + · subst head + have tailValid : SelectorsValid (1 : F) tail := { + boolean := fun value member => valid.boolean value (by simp [member]) + exclusive + sum := by simpa using valid.sum + } + obtain ⟨before, after, shape, beforeZero, afterZero⟩ := ih tailValid + refine ⟨0 :: before, after, by simp [shape], ?_, afterZero⟩ + intro selector member + rcases List.mem_cons.mp member with zero | member + · exact zero + · exact beforeZero selector member + · subst head + exact ⟨[], tail, rfl, by simp, by simpa using pairs⟩ + +/-- A selected default branch excludes every literal guarded by an inverse equation. -/ +theorem default_excludes_literal [Field F] {value pattern inverse : F} + (equation : (value - pattern) * inverse - 1 = 0) : value ≠ pattern := by + intro same + have nonzero := inverse_nonzero equation + exact nonzero (sub_eq_zero.mpr same) + +end Aiur.Scalar.Circuit diff --git a/Aiur/Aiur/Scalar/Circuit/WitnessBasic.lean b/Aiur/Aiur/Scalar/Circuit/WitnessBasic.lean new file mode 100644 index 000000000..6f4a11fa0 --- /dev/null +++ b/Aiur/Aiur/Scalar/Circuit/WitnessBasic.lean @@ -0,0 +1,248 @@ +import Aiur.Scalar.Circuit.ExpressionCorrectness + +namespace Aiur.Scalar.Circuit.Compiler + +/-- New equations vanish and every new send is disabled under this assignment. -/ +structure InactiveExtension [Field F] (before after : BuildState F) + (assignment : Var → F) : Prop where + increase : before.nextVar ≤ after.nextVar + equations : ∃ added, after.constraints.toList = before.constraints.toList ++ added ∧ + Satisfies added assignment + sends : ∃ added, after.sends.toList = before.sends.toList ++ added ∧ + ∀ send ∈ added, send.enable.denote assignment = 0 + +theorem InactiveExtension.refl [Field F] (state : BuildState F) (assignment : Var → F) : + InactiveExtension state state assignment := + ⟨Nat.le_refl _, ⟨[], by simp, by simp [Satisfies]⟩, ⟨[], by simp, by simp⟩⟩ + +theorem InactiveExtension.trans [Field F] {first middle last : BuildState F} + {assignment : Var → F} (left : InactiveExtension first middle assignment) + (right : InactiveExtension middle last assignment) : InactiveExtension first last assignment := by + obtain ⟨leftEquations, leftShape, leftZero⟩ := left.equations + obtain ⟨rightEquations, rightShape, rightZero⟩ := right.equations + obtain ⟨leftSends, leftSendShape, leftDisabled⟩ := left.sends + obtain ⟨rightSends, rightSendShape, rightDisabled⟩ := right.sends + refine ⟨le_trans left.increase right.increase, + ⟨leftEquations ++ rightEquations, by simp [rightShape, leftShape, List.append_assoc], + (satisfies_append _ _ _).mpr ⟨leftZero, rightZero⟩⟩, + ⟨leftSends ++ rightSends, by simp [rightSendShape, leftSendShape, List.append_assoc], ?_⟩⟩ + intro send member + rcases List.mem_append.mp member with member | member + · exact leftDisabled send member + · exact rightDisabled send member + +/-- Inactive code preserves all earlier equations and call justifications. -/ +theorem InactiveExtension.valid [Field F] {before after : BuildState F} + {assignment : Var → F} (extension : InactiveExtension before after assignment) + {calls : CallRelation F} (valid : before.Valid calls assignment) : + after.Valid calls assignment := by + obtain ⟨equations, shape, zero⟩ := extension.equations + obtain ⟨sends, sendShape, disabled⟩ := extension.sends + constructor + · rw [shape] + exact (satisfies_append _ _ _).mpr ⟨valid.constraints, zero⟩ + · intro send member active + rw [sendShape] at member + rcases List.mem_append.mp member with member | member + · exact valid.calls send member active + · have := disabled send member + simp [this] at active + +theorem InactiveExtension.fresh [Field F] (state : BuildState F) (assignment : Var → F) : + InactiveExtension state { state with nextVar := state.nextVar + 1 } assignment := + ⟨Nat.le_succ _, ⟨[], by simp, by simp [Satisfies]⟩, ⟨[], by simp, by simp⟩⟩ + +theorem InactiveExtension.constrain [Field F] (state : BuildState F) + {assignment : Var → F} {polynomial : ArithExpr F} + (zero : polynomial.denote assignment = 0) : + InactiveExtension state { state with constraints := state.constraints.push polynomial } assignment := + ⟨Nat.le_refl _, ⟨[polynomial], by simp, by simpa [Satisfies] using zero⟩, + ⟨[], by simp, by simp⟩⟩ + +theorem InactiveExtension.send [Field F] (state : BuildState F) + {assignment : Var → F} {send : Send F} (disabled : send.enable.denote assignment = 0) : + InactiveExtension state { state with sends := state.sends.push send } assignment := + ⟨Nat.le_refl _, ⟨[], by simp, by simp [Satisfies]⟩, + ⟨[send], by simp, by simpa using disabled⟩⟩ + +theorem InactiveExtension.constrainMany [Field F] (state : BuildState F) + {assignment : Var → F} {polynomials : List (ArithExpr F)} + (zero : Satisfies polynomials assignment) : + InactiveExtension state + { state with constraints := state.constraints ++ polynomials.toArray } assignment := + ⟨Nat.le_refl _, ⟨polynomials, by simp, zero⟩, ⟨[], by simp, by simp⟩⟩ + +theorem denote_of_prefix [Field F] {function : String} {initial values : List F} + (extension : initial.IsPrefix values) {bound : Nat} (size : initial.length = bound) + {polynomial : ArithExpr F} (bounded : polynomial.inBounds bound = true) : + polynomial.denote (Row.assignment ⟨function, values⟩) = + polynomial.denote (Row.assignment ⟨function, initial⟩) := + ArithExpr.denote_eq_of_agree + (fun _ bound => Row.assignment_of_prefix extension (by simpa [size] using bound)) bounded + +theorem value_of_prefix [Zero F] {function : String} {initial values : List F} + (extension : initial.IsPrefix values) {bound : Nat} (size : initial.length = bound) + {id : Var} (bounded : id < bound) : + Row.assignment ⟨function, values⟩ id = Row.assignment ⟨function, initial⟩ id := + Row.assignment_of_prefix extension (by simpa [size] using bounded) + +theorem denotes_of_prefix [Field F] {function : String} {initial values : List F} + (extension : initial.IsPrefix values) {bound : Nat} (size : initial.length = bound) + {polynomials : List (ArithExpr F)} + (bounded : ∀ polynomial ∈ polynomials, polynomial.inBounds bound = true) : + polynomials.map (ArithExpr.denote (Row.assignment ⟨function, values⟩)) = + polynomials.map (ArithExpr.denote (Row.assignment ⟨function, initial⟩)) := by + apply List.map_congr_left + exact fun polynomial member => denote_of_prefix extension size (bounded polynomial member) + +theorem assignment_append_value [Zero F] (function : String) (initial : List F) (value : F) : + Row.assignment ⟨function, initial ++ [value]⟩ initial.length = value := by + simp [Row.assignment] + +theorem localsEnvironment_of_prefix [Zero F] {function : String} {initial values : List F} + (extension : initial.IsPrefix values) {bound : Nat} (size : initial.length = bound) + {locals : List (String × Var)} (bounded : ∀ binding ∈ locals, binding.2 < bound) : + localsEnvironment locals (Row.assignment ⟨function, values⟩) = + localsEnvironment locals (Row.assignment ⟨function, initial⟩) := by + apply List.map_congr_left + intro binding member + rw [Row.assignment_of_prefix (before := ⟨function, initial⟩) extension + (by simpa [size] using bounded binding member)] + +theorem BuildState.WellFormed.fresh {state : BuildState F} (layout : state.WellFormed) : + { state with nextVar := state.nextVar + 1 }.WellFormed := + ⟨fun equation member => ArithExpr.inBounds_mono (Nat.le_succ _) (layout.constraints equation member), + fun send member => Send.inBounds_mono (Nat.le_succ _) (layout.sends send member)⟩ + +theorem BuildState.WellFormed.constrain {state : BuildState F} (layout : state.WellFormed) + {polynomial : ArithExpr F} (bound : polynomial.inBounds state.nextVar = true) : + { state with constraints := state.constraints.push polynomial }.WellFormed := by + refine ⟨?_, layout.sends⟩ + intro equation member + simp only [Array.toList_push, List.mem_append, List.mem_singleton] at member + rcases member with member | rfl + · exact layout.constraints equation member + · exact bound + +theorem BuildState.WellFormed.constrainMany {state : BuildState F} (layout : state.WellFormed) + {polynomials : List (ArithExpr F)} + (bound : ∀ polynomial ∈ polynomials, polynomial.inBounds state.nextVar = true) : + { state with constraints := state.constraints ++ polynomials.toArray }.WellFormed := by + refine ⟨?_, layout.sends⟩ + intro polynomial member + simp only [Array.toList_append, List.mem_append] at member + rcases member with member | member + · exact layout.constraints polynomial member + · exact bound polynomial member + +theorem BuildState.WellFormed.send {state : BuildState F} (layout : state.WellFormed) + {send : Send F} (bound : send.inBounds state.nextVar = true) : + { state with sends := state.sends.push send }.WellFormed := by + refine ⟨layout.constraints, ?_⟩ + intro next member + simp only [Array.toList_push, List.mem_append, List.mem_singleton] at member + rcases member with member | rfl + · exact layout.sends next member + · exact bound + +theorem BuildState.Valid.constrain [Field F] {state : BuildState F} {calls : CallRelation F} + {assignment : Var → F} (valid : state.Valid calls assignment) {polynomial : ArithExpr F} + (zero : polynomial.denote assignment = 0) : + { state with constraints := state.constraints.push polynomial }.Valid calls assignment := by + refine ⟨?_, valid.calls⟩ + intro equation member + simp only [Array.toList_push, List.mem_append, List.mem_singleton] at member + rcases member with member | rfl + · exact valid.constraints equation member + · exact zero + +theorem BuildState.Valid.constrainMany [Field F] {state : BuildState F} {calls : CallRelation F} + {assignment : Var → F} (valid : state.Valid calls assignment) {polynomials : List (ArithExpr F)} + (zero : Satisfies polynomials assignment) : + { state with constraints := state.constraints ++ polynomials.toArray }.Valid calls assignment := by + refine ⟨?_, valid.calls⟩ + simpa using (satisfies_append _ _ _).mpr ⟨valid.constraints, zero⟩ + +theorem BuildState.Valid.of_prefix [Field F] {function : String} {initial values : List F} + {state : BuildState F} {calls : CallRelation F} + (valid : state.Valid calls (Row.assignment ⟨function, initial⟩)) + (layout : state.WellFormed) (size : initial.length = state.nextVar) + (extension : initial.IsPrefix values) : + state.Valid calls (Row.assignment ⟨function, values⟩) := by + constructor + · intro equation member + rw [denote_of_prefix extension size (layout.constraints equation member)] + exact valid.constraints equation member + · intro send member active + have bounds := layout.sends send member + simp only [Send.inBounds, Bool.and_eq_true, decide_eq_true_eq, List.all_eq_true] at bounds + have enable := denote_of_prefix (function := function) extension size bounds.1.2 + rw [enable] at active + have args : send.args.map (ArithExpr.denote (Row.assignment ⟨function, values⟩)) = + send.args.map (ArithExpr.denote (Row.assignment ⟨function, initial⟩)) := by + apply List.map_congr_left + exact fun arg member => denote_of_prefix extension size (bounds.2 arg member) + rw [args, Row.assignment_of_prefix (before := ⟨function, initial⟩) extension + (by simpa [size] using bounds.1.1)] + exact valid.calls send member active + +theorem foldl_add_inBounds {selectors : List (ArithExpr F)} {initial : ArithExpr F} {bound : Nat} + (initialBound : initial.inBounds bound = true) + (bounded : ∀ selector ∈ selectors, selector.inBounds bound = true) : + (selectors.foldl ArithExpr.add initial).inBounds bound = true := by + induction selectors generalizing initial with + | nil => exact initialBound + | cons head tail ih => + apply ih + · simp [ArithExpr.inBounds, initialBound, bounded head (by simp)] + · exact fun selector member => bounded selector (by simp [member]) + +theorem exclusionConstraints_inBounds {selectors : List (ArithExpr F)} {bound : Nat} + (bounded : ∀ selector ∈ selectors, selector.inBounds bound = true) : + ∀ equation ∈ exclusionConstraints selectors, equation.inBounds bound = true := by + induction selectors with + | nil => simp [exclusionConstraints] + | cons head tail ih => + intro equation member + simp only [exclusionConstraints, List.mem_append, List.mem_map] at member + rcases member with ⟨selector, member, rfl⟩ | member + · simp [ArithExpr.inBounds, bounded head (by simp), bounded selector (by simp [member])] + · exact ih (fun selector member => bounded selector (by simp [member])) equation member + +theorem selectionConstraints_inBounds [Field F] {parent : ArithExpr F} + {selectors : List (ArithExpr F)} {bound : Nat} (parentBound : parent.inBounds bound = true) + (bounded : ∀ selector ∈ selectors, selector.inBounds bound = true) : + ∀ equation ∈ selectionConstraints parent selectors, equation.inBounds bound = true := by + intro equation member + simp only [selectionConstraints, List.mem_append, List.mem_map, List.mem_singleton] at member + rcases member with (⟨selector, member, rfl⟩ | member) | rfl + · simp [ArithExpr.inBounds, bounded selector member] + · exact exclusionConstraints_inBounds bounded equation member + · simp [ArithExpr.inBounds, parentBound, + foldl_add_inBounds (initial := .const (0 : F)) rfl bounded] + +theorem selectionConstraints_zero [Field F] {parent : ArithExpr F} + {selectors : List (ArithExpr F)} {assignment : Var → F} + (inactive : parent.denote assignment = 0) + (zeros : ∀ selector ∈ selectors, selector.denote assignment = 0) : + Satisfies (selectionConstraints parent selectors) assignment := by + apply (selectionConstraints_satisfies _ _ _).mpr + rw [inactive] + apply SelectorsValid.zeros + intro value present + obtain ⟨selector, selectorMember, same⟩ := List.mem_map.mp present + rw [← same] + exact zeros selector selectorMember + +/-- Appending zeroes leaves the total assignment unchanged, including out-of-bounds values. -/ +theorem assignment_append_zeros [Zero F] (function : String) (initial : List F) (count : Nat) : + Row.assignment ⟨function, initial ++ List.replicate count 0⟩ = + Row.assignment ⟨function, initial⟩ := by + funext id + by_cases bound : id < initial.length + · simp [Row.assignment, List.getElem?_append_left bound] + · simp [Row.assignment, List.getElem?_append_right (Nat.le_of_not_gt bound), + List.getElem?_eq_none (Nat.le_of_not_gt bound), List.getElem?_replicate] + split <;> rfl + +end Aiur.Scalar.Circuit.Compiler diff --git a/Aiur/Aiur/Scalar/Circuit/WitnessCorrectness.lean b/Aiur/Aiur/Scalar/Circuit/WitnessCorrectness.lean new file mode 100644 index 000000000..7120c67c8 --- /dev/null +++ b/Aiur/Aiur/Scalar/Circuit/WitnessCorrectness.lean @@ -0,0 +1,583 @@ +import Aiur.Scalar.Circuit.MatchWitness + +namespace Aiur.Scalar.Circuit.Compiler + +set_option maxHeartbeats 800000 in +set_option maxRecDepth 2048 in +mutual + /-- + Expression completeness under an active enable. New variables extend the initial + assignment, preserving its values and all earlier constraints and call premises. + This includes providing witnesses for every inactive branch of a compiled match. + -/ + theorem lowerExpr_complete [Field F] [DecidableEq F] + {function : String} {locals : List (String × Var)} {enable : ArithExpr F} {expr : Expr F} + {before after : BuildState F} {polynomial : ArithExpr F} + (compiled : (lowerExpr function locals enable expr).run before = .ok (polynomial, after)) + (layout : before.WellFormed) + (localsBound : ∀ binding ∈ locals, binding.2 < before.nextVar) + (enableBound : enable.inBounds before.nextVar = true) + {calls : CallRelation F} {initial : List F} (size : initial.length = before.nextVar) + (valid : before.Valid calls (Row.assignment ⟨function, initial⟩)) + (active : enable.denote (Row.assignment ⟨function, initial⟩) = 1) + {result : F} + (body : EvalExprWith calls + (localsEnvironment locals (Row.assignment ⟨function, initial⟩)) expr result) : + ∃ values, initial.IsPrefix values ∧ values.length = after.nextVar ∧ + after.WellFormed ∧ polynomial.inBounds after.nextVar = true ∧ + after.Valid calls (Row.assignment ⟨function, values⟩) ∧ + polynomial.denote (Row.assignment ⟨function, values⟩) = result := by + cases expr with + | literal value => + simp [lowerExpr, StateT.run, StateT.pure, pure, Except.pure] at compiled + rcases compiled with ⟨rfl, rfl⟩ + cases body + exact ⟨initial, ⟨[], by simp⟩, size, layout, rfl, valid, rfl⟩ + | var name => + cases found : locals.find? (·.1 == name) with + | none => + simp [lowerExpr, found, StateT.run] at compiled + cases compiled + | some binding => + rcases binding with ⟨bindingName, id⟩ + have same : bindingName = name := by simpa using List.find?_some found + subst bindingName + simp [lowerExpr, found, StateT.run, StateT.pure, pure, Except.pure] at compiled + rcases compiled with ⟨rfl, rfl⟩ + refine ⟨initial, ⟨[], by simp⟩, size, layout, ?_, valid, ?_⟩ + · simpa [ArithExpr.inBounds] using localsBound (name, id) (List.mem_of_find?_eq_some found) + · cases body with + | var lookup => + simpa [localsEnvironment, List.find?_map, Function.comp_def, found, + ArithExpr.denote] using lookup + | neg expr => + cases lowered : lowerExpr function locals enable expr before with + | error error => + simp [lowerExpr, StateT.run, StateT.bind, bind, Except.bind, lowered] at compiled + | ok output => + rcases output with ⟨inner, state⟩ + simp [lowerExpr, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, lowered] at compiled + rcases compiled with ⟨rfl, rfl⟩ + cases body with + | neg operand => + obtain ⟨values, extension, finalSize, finalLayout, innerBound, finalValid, value⟩ := + lowerExpr_complete lowered layout localsBound enableBound size valid active operand + refine ⟨values, extension, finalSize, finalLayout, ?_, finalValid, ?_⟩ + · simpa [ArithExpr.inBounds] using innerBound + · simp [ArithExpr.denote, value] + | binary op left right => + cases leftRun : lowerExpr function locals enable left before with + | error error => + simp [lowerExpr, StateT.run, StateT.bind, bind, Except.bind, leftRun] at compiled + | ok output => + rcases output with ⟨leftPolynomial, middle⟩ + cases rightRun : lowerExpr function locals enable right middle with + | error error => + simp [lowerExpr, StateT.run, StateT.bind, bind, Except.bind, leftRun, rightRun] at compiled + | ok output => + rcases output with ⟨rightPolynomial, state⟩ + have operands {x y : F} + (leftEval : EvalExprWith calls + (localsEnvironment locals (Row.assignment ⟨function, initial⟩)) left x) + (rightEval : EvalExprWith calls + (localsEnvironment locals (Row.assignment ⟨function, initial⟩)) right y) : + ∃ values, initial.IsPrefix values ∧ values.length = state.nextVar ∧ + state.WellFormed ∧ leftPolynomial.inBounds state.nextVar = true ∧ + rightPolynomial.inBounds state.nextVar = true ∧ + state.Valid calls (Row.assignment ⟨function, values⟩) ∧ + leftPolynomial.denote (Row.assignment ⟨function, values⟩) = x ∧ + rightPolynomial.denote (Row.assignment ⟨function, values⟩) = y := by + obtain ⟨firstValues, firstExtension, firstSize, firstLayout, leftBound, firstValid, leftValue⟩ := + lowerExpr_complete leftRun layout localsBound enableBound size valid active leftEval + have increase : before.nextVar ≤ middle.nextVar := by + rw [← size, ← firstSize] + exact firstExtension.length_le + obtain ⟨values, extension, finalSize, finalLayout, rightBound, finalValid, rightValue⟩ := + lowerExpr_complete rightRun firstLayout + (fun binding member => lt_of_lt_of_le (localsBound binding member) increase) + (ArithExpr.inBounds_mono increase enableBound) firstSize firstValid + (by rw [denote_of_prefix firstExtension size enableBound]; exact active) + (by rw [localsEnvironment_of_prefix firstExtension size localsBound]; exact rightEval) + have nextIncrease : middle.nextVar ≤ state.nextVar := by + rw [← firstSize, ← finalSize] + exact extension.length_le + refine ⟨values, firstExtension.trans extension, finalSize, finalLayout, + ArithExpr.inBounds_mono nextIncrease leftBound, rightBound, finalValid, ?_, rightValue⟩ + rw [denote_of_prefix extension firstSize leftBound] + exact leftValue + cases body with + | add leftEval rightEval | sub leftEval rightEval | mul leftEval rightEval => + simp [lowerExpr, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, leftRun, rightRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + obtain ⟨values, extension, finalSize, finalLayout, leftBound, rightBound, + finalValid, leftValue, rightValue⟩ := operands leftEval rightEval + refine ⟨values, extension, finalSize, finalLayout, ?_, finalValid, ?_⟩ + · simp [ArithExpr.inBounds, leftBound, rightBound] + · simp [ArithExpr.denote, leftValue, rightValue] + | div leftEval rightEval nonzero => + rename_i x y + simp [lowerExpr, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, leftRun, rightRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + obtain ⟨values, extension, finalSize, finalLayout, leftBound, rightBound, + finalValid, leftValue, rightValue⟩ := operands leftEval rightEval + let finished := values ++ [y⁻¹] + have extended : values.IsPrefix finished := List.prefix_append _ _ + have inverse : Row.assignment ⟨function, finished⟩ state.nextVar = y⁻¹ := by + simp [Row.assignment, finished, ← finalSize] + have increase : before.nextVar ≤ state.nextVar := by + rw [← size, ← finalSize] + exact extension.length_le + have finalEnable := ArithExpr.inBounds_mono increase enableBound + have activeFinal : enable.denote (Row.assignment ⟨function, finished⟩) = 1 := by + rw [denote_of_prefix (extension.trans extended) size enableBound] + exact active + have leftFinal : leftPolynomial.denote (Row.assignment ⟨function, finished⟩) = x := by + rw [denote_of_prefix extended finalSize leftBound] + exact leftValue + have rightFinal : rightPolynomial.denote (Row.assignment ⟨function, finished⟩) = y := by + rw [denote_of_prefix extended finalSize rightBound] + exact rightValue + have equationBound : + (ArithExpr.mul enable (.sub (.mul rightPolynomial (.var state.nextVar)) (.const 1))).inBounds + (state.nextVar + 1) = true := by + simp [ArithExpr.inBounds, ArithExpr.inBounds_mono (Nat.le_succ _) finalEnable, + ArithExpr.inBounds_mono (Nat.le_succ _) rightBound] + have oldValid := finalValid.of_prefix finalLayout finalSize extended + have freshValid : { state with nextVar := state.nextVar + 1 }.Valid calls + (Row.assignment ⟨function, finished⟩) := ⟨oldValid.constraints, oldValid.calls⟩ + refine ⟨finished, extension.trans extended, by simp [finished, finalSize], + finalLayout.fresh.constrain equationBound, ?_, freshValid.constrain ?_, ?_⟩ + · simp [ArithExpr.inBounds, ArithExpr.inBounds_mono (Nat.le_succ _) leftBound] + · simp [ArithExpr.denote, activeFinal, rightFinal, inverse, nonzero] + · simp [ArithExpr.denote, leftFinal, inverse, div_eq_mul_inv] + | call name args => + cases argsRun : lowerArgs function locals enable args before with + | error error => + simp [lowerExpr, StateT.run, StateT.bind, bind, Except.bind, argsRun] at compiled + | ok output => + rcases output with ⟨arguments, state⟩ + simp [lowerExpr, boolean, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, argsRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + cases body with + | call argsEval callee => + obtain ⟨values, extension, finalSize, finalLayout, argsBound, finalValid, argsValue⟩ := + lowerArgs_complete argsRun layout localsBound enableBound size valid active argsEval + let finished := values ++ [result] + have extended : values.IsPrefix finished := List.prefix_append _ _ + have output : Row.assignment ⟨function, finished⟩ state.nextVar = result := by + simp [Row.assignment, finished, ← finalSize] + have increase : before.nextVar ≤ state.nextVar := by + rw [← size, ← finalSize] + exact extension.length_le + have finalEnable := ArithExpr.inBounds_mono (Nat.le_succ _) + (ArithExpr.inBounds_mono increase enableBound) + have activeFinal : enable.denote (Row.assignment ⟨function, finished⟩) = 1 := by + rw [denote_of_prefix (extension.trans extended) size enableBound] + exact active + have argumentsUnchanged : arguments.map (ArithExpr.denote (Row.assignment ⟨function, finished⟩)) = + arguments.map (ArithExpr.denote (Row.assignment ⟨function, values⟩)) := by + apply List.map_congr_left + exact fun argument member => denote_of_prefix extended finalSize (argsBound argument member) + have booleanBound : (ArithExpr.mul enable (.sub enable (.const 1))).inBounds + (state.nextVar + 1) = true := by simp [ArithExpr.inBounds, finalEnable] + have sendBound : (⟨name, arguments, state.nextVar, enable⟩ : Send F).inBounds + (state.nextVar + 1) = true := by + simp only [Send.inBounds, Bool.and_eq_true, decide_eq_true_eq, List.all_eq_true] + exact ⟨⟨Nat.lt_succ_self _, finalEnable⟩, + fun argument member => ArithExpr.inBounds_mono (Nat.le_succ _) (argsBound argument member)⟩ + have oldValid := finalValid.of_prefix finalLayout finalSize extended + have freshValid : { state with nextVar := state.nextVar + 1 }.Valid calls + (Row.assignment ⟨function, finished⟩) := ⟨oldValid.constraints, oldValid.calls⟩ + have booleanZero : (ArithExpr.mul enable (.sub enable (.const 1))).denote + (Row.assignment ⟨function, finished⟩) = 0 := by simp [ArithExpr.denote, activeFinal] + have withBoolean := finalLayout.fresh.constrain booleanBound + have withBooleanValid := freshValid.constrain booleanZero + refine ⟨finished, extension.trans extended, by simp [finished, finalSize], + ⟨withBoolean.constraints, ?_⟩, by simp [ArithExpr.inBounds], + ⟨withBooleanValid.constraints, ?_⟩, output⟩ + · intro send member + simp only [Array.toList_push, List.mem_append, List.mem_singleton] at member + rcases member with member | rfl + · exact withBoolean.sends send member + · exact sendBound + · intro send member enabled + simp only [Array.toList_push, List.mem_append, List.mem_singleton] at member + rcases member with member | rfl + · exact withBooleanValid.calls send member enabled + · change calls name _ _ + rw [argumentsUnchanged, argsValue, output] + exact callee + | matchValue scrutinee arms => + cases checked : checkPatterns function arms [] with + | error error => + simp [lowerExpr, checked, StateT.run, StateT.bind, bind, Except.bind] at compiled + | ok checkedUnit => + cases checkedUnit + cases scrutineeRun : lowerExpr function locals enable scrutinee before with + | error error => + simp [lowerExpr, checked, StateT.run, StateT.bind, bind, Except.bind, + scrutineeRun] at compiled + | ok output => + rcases output with ⟨scrutineePolynomial, middle⟩ + cases armsRun : lowerArms function locals scrutineePolynomial middle.nextVar + (literalPatterns arms) arms { middle with nextVar := middle.nextVar + 1 } with + | error error => + simp [lowerExpr, checked, StateT.run, StateT.bind, bind, Except.bind, + scrutineeRun, armsRun] at compiled + | ok output => + rcases output with ⟨selectors, state⟩ + simp [lowerExpr, checked, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, scrutineeRun, armsRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + cases body with + | matchValue scrutineeEval selected branch => + obtain ⟨middleValues, firstExtension, middleSize, middleLayout, scrutineeBound, + middleValid, scrutineeValue⟩ := + lowerExpr_complete scrutineeRun layout localsBound enableBound size valid active scrutineeEval + let padded := middleValues ++ [result] + have extended : middleValues.IsPrefix padded := List.prefix_append _ _ + have first := firstExtension.trans extended + have paddedSize : padded.length = middle.nextVar + 1 := by simp [padded, middleSize] + have increase : before.nextVar ≤ middle.nextVar + 1 := by + rw [← size, ← paddedSize] + exact first.length_le + have oldValid := middleValid.of_prefix middleLayout middleSize extended + have freshValid : { middle with nextVar := middle.nextVar + 1 }.Valid calls + (Row.assignment ⟨function, padded⟩) := ⟨oldValid.constraints, oldValid.calls⟩ + obtain ⟨values, extension, finalSize, finalLayout, selectorsBound, finalValid, selectorsValid⟩ := + lowerArms_complete (output := result) armsRun middleLayout.fresh + (fun binding member => lt_of_lt_of_le (localsBound binding member) increase) + (ArithExpr.inBounds_mono (Nat.le_succ _) scrutineeBound) (Nat.lt_succ_self _) + paddedSize freshValid + ((denote_of_prefix extended middleSize scrutineeBound).trans scrutineeValue) + (by rw [← middleSize]; exact assignment_append_value _ _ _) selected + (fun _ member => Or.inl member) + (by rw [localsEnvironment_of_prefix first size localsBound]; exact branch) + have total := first.trans extension + have finalIncrease : before.nextVar ≤ state.nextVar := by + rw [← size, ← finalSize] + exact total.length_le + have finalEnable := ArithExpr.inBounds_mono finalIncrease enableBound + have selectedEquations : Satisfies (selectionConstraints enable selectors) + (Row.assignment ⟨function, values⟩) := by + apply (selectionConstraints_satisfies _ _ _).mpr + rw [denote_of_prefix total size enableBound, active] + exact selectorsValid + have outputBound : middle.nextVar < state.nextVar := by + have length := extension.length_le + rw [paddedSize, finalSize] at length + omega + refine ⟨values, total, finalSize, + finalLayout.constrainMany (selectionConstraints_inBounds finalEnable selectorsBound), + by simpa [ArithExpr.inBounds] using outputBound, + finalValid.constrainMany selectedEquations, ?_⟩ + change Row.assignment ⟨function, values⟩ middle.nextVar = result + rw [value_of_prefix extension paddedSize (Nat.lt_succ_self _), ← middleSize] + exact assignment_append_value _ _ _ + termination_by sizeOf expr + + theorem lowerArgs_complete [Field F] [DecidableEq F] + {function : String} {locals : List (String × Var)} {enable : ArithExpr F} {args : List (Expr F)} + {before after : BuildState F} {polynomials : List (ArithExpr F)} + (compiled : (lowerArgs function locals enable args).run before = .ok (polynomials, after)) + (layout : before.WellFormed) + (localsBound : ∀ binding ∈ locals, binding.2 < before.nextVar) + (enableBound : enable.inBounds before.nextVar = true) + {calls : CallRelation F} {initial : List F} (size : initial.length = before.nextVar) + (valid : before.Valid calls (Row.assignment ⟨function, initial⟩)) + (active : enable.denote (Row.assignment ⟨function, initial⟩) = 1) + {results : List F} + (body : EvalArgsWith calls + (localsEnvironment locals (Row.assignment ⟨function, initial⟩)) args results) : + ∃ values, initial.IsPrefix values ∧ values.length = after.nextVar ∧ + after.WellFormed ∧ (∀ polynomial ∈ polynomials, polynomial.inBounds after.nextVar = true) ∧ + after.Valid calls (Row.assignment ⟨function, values⟩) ∧ + polynomials.map (ArithExpr.denote (Row.assignment ⟨function, values⟩)) = results := by + cases args with + | nil => + simp [lowerArgs, StateT.run, StateT.pure, pure, Except.pure] at compiled + rcases compiled with ⟨rfl, rfl⟩ + cases body + exact ⟨initial, ⟨[], by simp⟩, size, layout, by simp, valid, rfl⟩ + | cons head tail => + cases headRun : lowerExpr function locals enable head before with + | error error => + simp [lowerArgs, StateT.run, StateT.bind, bind, Except.bind, headRun] at compiled + | ok output => + rcases output with ⟨headPolynomial, middle⟩ + cases tailRun : lowerArgs function locals enable tail middle with + | error error => + simp [lowerArgs, StateT.run, StateT.bind, bind, Except.bind, headRun, tailRun] at compiled + | ok output => + rcases output with ⟨tailPolynomials, state⟩ + simp [lowerArgs, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, headRun, tailRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + cases body with + | cons headEval tailEval => + obtain ⟨firstValues, firstExtension, firstSize, firstLayout, headBound, firstValid, headValue⟩ := + lowerExpr_complete headRun layout localsBound enableBound size valid active headEval + have increase : before.nextVar ≤ middle.nextVar := by + rw [← size, ← firstSize] + exact firstExtension.length_le + obtain ⟨values, extension, finalSize, finalLayout, tailBounds, finalValid, tailValue⟩ := + lowerArgs_complete tailRun firstLayout + (fun binding member => lt_of_lt_of_le (localsBound binding member) increase) + (ArithExpr.inBounds_mono increase enableBound) firstSize firstValid + (by rw [denote_of_prefix firstExtension size enableBound]; exact active) + (by rw [localsEnvironment_of_prefix firstExtension size localsBound]; exact tailEval) + have nextIncrease : middle.nextVar ≤ state.nextVar := by + rw [← firstSize, ← finalSize] + exact extension.length_le + refine ⟨values, firstExtension.trans extension, finalSize, finalLayout, ?_, finalValid, ?_⟩ + · intro polynomial member + rcases List.mem_cons.mp member with rfl | member + · exact ArithExpr.inBounds_mono nextIncrease headBound + · exact tailBounds polynomial member + · simp only [List.map_cons, tailValue] + rw [denote_of_prefix extension firstSize headBound, headValue] + termination_by sizeOf args + + /-- Construct the selected arm and disable every other retained arm. -/ + theorem lowerArms_complete [Field F] [DecidableEq F] + {function : String} {locals : List (String × Var)} {scrutinee : ArithExpr F} {result : Var} + {literals : List F} {arms : List (Pattern F × Expr F)} + {before after : BuildState F} {selectors : List (ArithExpr F)} + (compiled : (lowerArms function locals scrutinee result literals arms).run before = .ok (selectors, after)) + (layout : before.WellFormed) + (localsBound : ∀ binding ∈ locals, binding.2 < before.nextVar) + (scrutineeBound : scrutinee.inBounds before.nextVar = true) (resultBound : result < before.nextVar) + {calls : CallRelation F} {initial : List F} (size : initial.length = before.nextVar) + (valid : before.Valid calls (Row.assignment ⟨function, initial⟩)) + {value output : F} (scrutineeValue : scrutinee.denote (Row.assignment ⟨function, initial⟩) = value) + (outputValue : Row.assignment ⟨function, initial⟩ result = output) + {selectedBody : Expr F} (selected : SelectArm value arms selectedBody) + (priorExcluded : ∀ literal ∈ literals, literal ∈ literalPatterns arms ∨ value ≠ literal) + (body : EvalExprWith calls (localsEnvironment locals (Row.assignment ⟨function, initial⟩)) selectedBody output) : + ∃ values, initial.IsPrefix values ∧ values.length = after.nextVar ∧ after.WellFormed ∧ + (∀ selector ∈ selectors, selector.inBounds after.nextVar = true) ∧ + after.Valid calls (Row.assignment ⟨function, values⟩) ∧ + SelectorsValid (1 : F) (selectors.map (ArithExpr.denote (Row.assignment ⟨function, values⟩))) := by + cases arms with + | nil => cases selected + | cons arm rest => + cases armEq : arm + rename_i pattern armBody + simp only [armEq] at compiled selected priorExcluded + cases pattern with + | literal literal => + let patternEquation : ArithExpr F := + .mul (.var before.nextVar) (.sub scrutinee (.const literal)) + let start : BuildState F := { + before with nextVar := before.nextVar + 1 + constraints := before.constraints.push patternEquation } + have startLayout : start.WellFormed := layout.fresh.constrain (by + simp [patternEquation, ArithExpr.inBounds, + ArithExpr.inBounds_mono (Nat.le_succ _) scrutineeBound]) + have startLocals : ∀ binding ∈ locals, binding.2 < start.nextVar := + fun binding member => lt_of_lt_of_le (localsBound binding member) (Nat.le_succ _) + cases bodyRun : lowerExpr function locals (.var before.nextVar) armBody start with + | error error => + simp [lowerArms, StateT.run, StateT.bind, bind, Except.bind, start, + patternEquation, bodyRun] at compiled + | ok lowered => + rcases lowered with ⟨bodyPolynomial, middle⟩ + let resultEquation : ArithExpr F := + .mul (.var before.nextVar) (.sub (.var result) bodyPolynomial) + let next : BuildState F := { middle with constraints := middle.constraints.push resultEquation } + cases restRun : lowerArms function locals scrutinee result literals rest next with + | error error => + simp [lowerArms, StateT.run, StateT.bind, bind, Except.bind, start, + patternEquation, next, resultEquation, bodyRun, restRun] at compiled + | ok lowered => + rcases lowered with ⟨restSelectors, state⟩ + simp [lowerArms, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, start, patternEquation, next, resultEquation, + bodyRun, restRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + cases selected with + | literal => + let padded := initial ++ [1] + have extended : initial.IsPrefix padded := List.prefix_append _ _ + have paddedSize : padded.length = start.nextVar := by simp [padded, start, size] + have selectorValue : Row.assignment ⟨function, padded⟩ before.nextVar = (1 : F) := by + rw [← size] + exact assignment_append_value _ _ _ + have scrutineePadded := + (denote_of_prefix (function := function) extended size scrutineeBound).trans scrutineeValue + have oldValid := valid.of_prefix layout size extended + have freshValid : { before with nextVar := before.nextVar + 1 }.Valid calls + (Row.assignment ⟨function, padded⟩) := ⟨oldValid.constraints, oldValid.calls⟩ + have startValid : start.Valid calls (Row.assignment ⟨function, padded⟩) := + freshValid.constrain (by simp [patternEquation, ArithExpr.denote, scrutineePadded]) + obtain ⟨bodyValues, bodyExtension, middleSize, middleLayout, bodyBound, middleValid, bodyValue⟩ := + lowerExpr_complete bodyRun startLayout startLocals + (by simp [start, ArithExpr.inBounds]) paddedSize startValid selectorValue + (by rw [localsEnvironment_of_prefix extended size localsBound]; exact body) + have first := extended.trans bodyExtension + have selectorBound : before.nextVar < middle.nextVar := by + have length := bodyExtension.length_le + simp only [paddedSize, start, middleSize] at length + omega + have increase : before.nextVar ≤ middle.nextVar := Nat.le_of_lt selectorBound + have outputMiddle := (value_of_prefix (function := function) first size resultBound).trans outputValue + have nextLayout : next.WellFormed := middleLayout.constrain (by + simp [resultEquation, ArithExpr.inBounds, selectorBound, bodyBound, + lt_of_lt_of_le resultBound increase]) + have nextValid : next.Valid calls (Row.assignment ⟨function, bodyValues⟩) := + middleValid.constrain (by simp [resultEquation, ArithExpr.denote, outputMiddle, bodyValue]) + obtain ⟨values, extension, finalSize, finalLayout, restBound, finalValid, restZero, _⟩ := + lowerArms_inactive_complete restRun nextLayout + (fun binding member => lt_of_lt_of_le (localsBound binding member) increase) + (ArithExpr.inBounds_mono increase scrutineeBound) + (lt_of_lt_of_le resultBound increase) middleSize nextValid + have nextIncrease : middle.nextVar ≤ state.nextVar := by + rw [← middleSize, ← finalSize] + exact extension.length_le + have selectorFinal := (value_of_prefix (function := function) + (bodyExtension.trans extension) paddedSize (Nat.lt_succ_self _)).trans selectorValue + refine ⟨values, first.trans extension, finalSize, finalLayout, ?_, finalValid, ?_⟩ + · intro selector member + rcases List.mem_cons.mp member with rfl | member + · simpa [ArithExpr.inBounds] using lt_of_lt_of_le selectorBound nextIncrease + · exact restBound selector member + · simp only [List.map_cons, ArithExpr.denote, selectorFinal] + apply SelectorsValid.single (before := []) (by simp) + intro value present + obtain ⟨selector, selectorMember, same⟩ := List.mem_map.mp present + rw [← same] + exact restZero selector selectorMember + | skip different selectedRest => + let padded := initial ++ [0] + have extended : initial.IsPrefix padded := List.prefix_append _ _ + have paddedSize : padded.length = start.nextVar := by simp [padded, start, size] + have selectorValue : Row.assignment ⟨function, padded⟩ before.nextVar = (0 : F) := by + rw [← size] + exact assignment_append_value _ _ _ + have oldValid := valid.of_prefix layout size extended + have freshValid : { before with nextVar := before.nextVar + 1 }.Valid calls + (Row.assignment ⟨function, padded⟩) := ⟨oldValid.constraints, oldValid.calls⟩ + have startValid : start.Valid calls (Row.assignment ⟨function, padded⟩) := + freshValid.constrain (by simp [patternEquation, ArithExpr.denote, selectorValue]) + obtain ⟨bodyValues, bodyExtension, middleSize, middleLayout, bodyBound, middleValid, _⟩ := + lowerExpr_inactive_complete bodyRun startLayout startLocals + (by simp [start, ArithExpr.inBounds]) paddedSize startValid selectorValue + have first := extended.trans bodyExtension + have selectorBound : before.nextVar < middle.nextVar := by + have length := bodyExtension.length_le + simp only [paddedSize, start, middleSize] at length + omega + have increase : before.nextVar ≤ middle.nextVar := Nat.le_of_lt selectorBound + have selectorMiddle := + (value_of_prefix (function := function) bodyExtension paddedSize (Nat.lt_succ_self _)).trans selectorValue + have nextLayout : next.WellFormed := middleLayout.constrain (by + simp [resultEquation, ArithExpr.inBounds, selectorBound, bodyBound, + lt_of_lt_of_le resultBound increase]) + have nextValid : next.Valid calls (Row.assignment ⟨function, bodyValues⟩) := + middleValid.constrain (by simp [resultEquation, ArithExpr.denote, selectorMiddle]) + have restExcluded : ∀ nextLiteral ∈ literals, + nextLiteral ∈ literalPatterns rest ∨ value ≠ nextLiteral := by + intro nextLiteral member + rcases priorExcluded nextLiteral member with retained | excluded + · simp only [literalPatterns, List.mem_cons] at retained + rcases retained with rfl | retained + · exact Or.inr different.symm + · exact Or.inl retained + · exact Or.inr excluded + obtain ⟨values, extension, finalSize, finalLayout, restBound, finalValid, restValid⟩ := + lowerArms_complete (output := output) restRun nextLayout + (fun binding member => lt_of_lt_of_le (localsBound binding member) increase) + (ArithExpr.inBounds_mono increase scrutineeBound) + (lt_of_lt_of_le resultBound increase) middleSize nextValid + ((denote_of_prefix first size scrutineeBound).trans scrutineeValue) + ((value_of_prefix first size resultBound).trans outputValue) + selectedRest restExcluded + (by rw [localsEnvironment_of_prefix first size localsBound]; exact body) + have nextIncrease : middle.nextVar ≤ state.nextVar := by + rw [← middleSize, ← finalSize] + exact extension.length_le + have selectorFinal := (value_of_prefix (function := function) + (bodyExtension.trans extension) paddedSize (Nat.lt_succ_self _)).trans selectorValue + refine ⟨values, first.trans extension, finalSize, finalLayout, ?_, finalValid, ?_⟩ + · intro selector member + rcases List.mem_cons.mp member with rfl | member + · simpa [ArithExpr.inBounds] using lt_of_lt_of_le selectorBound nextIncrease + · exact restBound selector member + · simpa only [List.map_cons, ArithExpr.denote, selectorFinal] using restValid.zero_cons + | wildcard => + cases selected + cases excludedRun : excludeLiterals (.var before.nextVar) scrutinee literals + { before with nextVar := before.nextVar + 1 } with + | error error => + simp [lowerArms, StateT.run, StateT.bind, bind, Except.bind, excludedRun] at compiled + | ok lowered => + rcases lowered with ⟨finished, middle⟩ + cases finished + cases bodyRun : lowerExpr function locals (.var before.nextVar) selectedBody middle with + | error error => + simp [lowerArms, StateT.run, StateT.bind, bind, Except.bind, excludedRun, bodyRun] at compiled + | ok lowered => + rcases lowered with ⟨bodyPolynomial, state⟩ + simp [lowerArms, StateT.run, StateT.bind, StateT.pure, bind, pure, + Except.bind, Except.pure, excludedRun, bodyRun] at compiled + rcases compiled with ⟨rfl, rfl⟩ + let padded := initial ++ [1] + have extended : initial.IsPrefix padded := List.prefix_append _ _ + have paddedSize : padded.length = before.nextVar + 1 := by simp [padded, size] + have selectorValue : Row.assignment ⟨function, padded⟩ before.nextVar = (1 : F) := by + rw [← size] + exact assignment_append_value _ _ _ + have scrutineePadded := + (denote_of_prefix (function := function) extended size scrutineeBound).trans scrutineeValue + have oldValid := valid.of_prefix layout size extended + have freshValid : { before with nextVar := before.nextVar + 1 }.Valid calls + (Row.assignment ⟨function, padded⟩) := ⟨oldValid.constraints, oldValid.calls⟩ + have excluded : ∀ literal ∈ literals, + scrutinee.denote (Row.assignment ⟨function, padded⟩) ≠ literal := by + intro literal member + rw [scrutineePadded] + rcases priorExcluded literal member with impossible | different + · simp [literalPatterns] at impossible + · exact different + obtain ⟨middleValues, middleExtension, middleSize, middleLayout, middleValid⟩ := + excludeLiterals_complete excludedRun layout.fresh + (by simp [ArithExpr.inBounds]) + (ArithExpr.inBounds_mono (Nat.le_succ _) scrutineeBound) + paddedSize freshValid selectorValue excluded + have first := extended.trans middleExtension + have selectorBound : before.nextVar < middle.nextVar := by + have length := middleExtension.length_le + rw [paddedSize, middleSize] at length + omega + have increase : before.nextVar ≤ middle.nextVar := Nat.le_of_lt selectorBound + have selectorMiddle := (value_of_prefix (function := function) + middleExtension paddedSize (Nat.lt_succ_self _)).trans selectorValue + obtain ⟨values, extension, finalSize, finalLayout, bodyBound, finalValid, bodyValue⟩ := + lowerExpr_complete bodyRun middleLayout + (fun binding member => lt_of_lt_of_le (localsBound binding member) increase) + (by simpa [ArithExpr.inBounds] using selectorBound) middleSize middleValid selectorMiddle + (by rw [localsEnvironment_of_prefix first size localsBound]; exact body) + have total := first.trans extension + have nextIncrease : middle.nextVar ≤ state.nextVar := by + rw [← middleSize, ← finalSize] + exact extension.length_le + have selectorFinal := (value_of_prefix (function := function) + (middleExtension.trans extension) paddedSize (Nat.lt_succ_self _)).trans selectorValue + have outputFinal := (value_of_prefix (function := function) total size resultBound).trans outputValue + refine ⟨values, total, finalSize, finalLayout.constrain ?_, ?_, finalValid.constrain ?_, ?_⟩ + · simp [ArithExpr.inBounds, bodyBound, lt_of_lt_of_le selectorBound nextIncrease, + lt_of_lt_of_le resultBound (le_trans increase nextIncrease)] + · simpa [ArithExpr.inBounds] using lt_of_lt_of_le selectorBound nextIncrease + · simp [ArithExpr.denote, outputFinal, bodyValue] + · simpa [ArithExpr.denote, selectorFinal] using + (SelectorsValid.single (before := []) (after := []) (by simp) (by simp) : + SelectorsValid (1 : F) [1]) + termination_by sizeOf arms + +end + +end Aiur.Scalar.Circuit.Compiler diff --git a/Aiur/Aiur/Scalar/Correctness.lean b/Aiur/Aiur/Scalar/Correctness.lean new file mode 100644 index 000000000..90e9f72fe --- /dev/null +++ b/Aiur/Aiur/Scalar/Correctness.lean @@ -0,0 +1,119 @@ +import Aiur.Scalar.Semantics +import Aiur.Scalar.Circuit.Compile +import Aiur.Scalar.Circuit.Derivation +import Aiur.Scalar.Circuit.LocalCorrectness + +namespace Aiur.Scalar + +/-- Every successful source evaluation has a closed derivation in the chip system. -/ +def CompilationComplete [Field F] [DecidableEq F] (program : Program F) + (system : Circuit.System F) : Prop := + ∀ name args result, EvalCall program name args result → + Circuit.CircuitEvaluates system name args result + +/-- Every closed chip derivation corresponds to a successful source evaluation. -/ +def CompilationSound [Field F] [DecidableEq F] (program : Program F) + (system : Circuit.System F) : Prop := + ∀ name args result, Circuit.CircuitEvaluates system name args result → + EvalCall program name args result + +/-- The target equivalence, independent of any fuel bound or flat witness representation. -/ +def CompilationCorrect [Field F] [DecidableEq F] (program : Program F) + (system : Circuit.System F) : Prop := + ∀ name args result, EvalCall program name args result ↔ + Circuit.CircuitEvaluates system name args result + +theorem compilationCorrect_iff [Field F] [DecidableEq F] + (program : Program F) (system : Circuit.System F) : + CompilationCorrect program system ↔ + CompilationComplete program system ∧ CompilationSound program system := by + constructor + · intro correct + exact ⟨fun name args result => (correct name args result).mp, + fun name args result => (correct name args result).mpr⟩ + · rintro ⟨complete, sound⟩ name args result + exact ⟨complete name args result, sound name args result⟩ + +/-- The compiler's correctness specification, with both directions quantified over all calls. -/ +def CompilerCorrect (F : Type) [Field F] [DecidableEq F] : Prop := + ∀ (program : Program F) (system : Circuit.System F), + Circuit.compile program = .ok system → CompilationCorrect program system + +/-- Induction over a closed circuit tree reduces soundness to one compiled body. -/ +theorem derivation_sound [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) {message : Circuit.Message F} + (derivation : Circuit.Derivation system message) : + EvalCall program message.channel message.args message.result := by + induction derivation using Circuit.Derivation.rec + (motive_2 := fun messages _ => + ∀ message ∈ messages, EvalCall program message.channel message.args message.result) with + | node chip row lookup valid _ childrenIH => + obtain ⟨defn, found, lowered⟩ := Circuit.compile_find_chip compiled lookup + have interface := Circuit.Compiler.lowerFunction_interface lowered + have name := Circuit.findFunction_name found + have body := Circuit.Compiler.lowerFunction_sound lowered valid childrenIH + apply EvalCall.intro (defn := defn) + · change program.findFunction? chip.name = some defn + rw [interface.1, name] + exact found + · rw [← interface.2.1] + exact valid.receive_arity.symm + · exact body.toEvalExpr + | nil => simp_all + | cons _ _ headIH tailIH => + rename_i message member + rcases List.mem_cons.mp member with same | member + · subst message; exact headIH + · exact tailIH message member + +/-- Every closed derivation of a successfully compiled program has a source evaluation. -/ +theorem compiler_sound [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) : CompilationSound program system := by + rintro name args result ⟨derivation⟩ + exact derivation_sound compiled derivation + +/-- Induction over source evaluation reduces completeness to one compiled body. -/ +theorem evaluation_complete [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {name : String} {args : List F} {result : F} (evaluates : EvalCall program name args result) : + Circuit.CircuitEvaluates system name args result := by + induction evaluates using EvalCall.rec + (motive_1 := fun locals expr value _ => + EvalExprWith (Circuit.CircuitEvaluates system) locals expr value) + (motive_2 := fun locals exprs values _ => + EvalArgsWith (Circuit.CircuitEvaluates system) locals exprs values) with + | literal => exact .literal + | var lookup => exact .var lookup + | neg _ ih => exact .neg ih + | add _ _ leftIH rightIH => exact .add leftIH rightIH + | sub _ _ leftIH rightIH => exact .sub leftIH rightIH + | mul _ _ leftIH rightIH => exact .mul leftIH rightIH + | div _ _ nonzero leftIH rightIH => exact .div leftIH rightIH nonzero + | call _ _ argumentsIH calleeIH => exact .call argumentsIH calleeIH + | matchValue _ selected _ scrutineeIH branchIH => exact .matchValue scrutineeIH selected branchIH + | nil => exact .nil + | cons _ _ headIH tailIH => exact .cons headIH tailIH + | intro lookup arity _ bodyIH => + obtain ⟨chip, found, lowered⟩ := Circuit.compile_find_function compiled lookup + obtain ⟨row, rowName, valid, receive, premises⟩ := + Circuit.Compiler.lowerFunction_complete lowered arity bodyIH + have name := Circuit.findFunction_name lookup + have rowLookup : system.findChip? row.chip = some chip := by + rw [rowName, name] + exact found + obtain ⟨children⟩ := Circuit.derivations_nonempty_iff.mpr premises + have tree := Circuit.Derivation.node chip row rowLookup valid children + rw [receive, name] at tree + exact ⟨tree⟩ + +/-- Successful compilation preserves and reflects evaluation as finite closed chip derivations. -/ +theorem compiler_correct [Field F] [DecidableEq F] : CompilerCorrect F := by + intro program system compiled name args result + constructor + · exact evaluation_complete compiled + · exact compiler_sound compiled name args result + +end Aiur.Scalar diff --git a/Aiur/Aiur/Scalar/Eval.lean b/Aiur/Aiur/Scalar/Eval.lean new file mode 100644 index 000000000..906cfcb9e --- /dev/null +++ b/Aiur/Aiur/Scalar/Eval.lean @@ -0,0 +1,81 @@ +import Aiur.Scalar.Typecheck +import Mathlib.Algebra.Field.Defs + +namespace Aiur.Scalar + +inductive EvalError where + | invalidProgram (error : CheckError) + | unknownFunction (name : String) + | arityMismatch (function : String) (expected actual : Nat) + | unboundVariable (name : String) + | divisionByZero + | noMatchingArm + | outOfFuel + deriving Repr, BEq, DecidableEq + +instance : ToString EvalError where + toString + | .invalidProgram error => toString error + | .unknownFunction name => s!"unknown function '{name}'" + | .arityMismatch fn expected actual => + s!"function '{fn}' received {actual} arguments; expected {expected}" + | .unboundVariable name => s!"unbound variable '{name}'" + | .divisionByZero => "division by zero" + | .noMatchingArm => "no matching arm" + | .outOfFuel => "evaluation ran out of fuel" + +def Pattern.matches [DecidableEq F] : Pattern F → F → Bool + | .literal value, input => decide (value = input) + | .wildcard, _ => true + +/-- Arithmetic execution, exposed for the evaluator/semantics correspondence proof. -/ +def evalBinOp [Field F] [DecidableEq F] (op : BinOp) (left right : F) : + Except EvalError F := + match op with + | .add => .ok (left + right) + | .sub => .ok (left - right) + | .mul => .ok (left * right) + | .div => if right = 0 then .error .divisionByZero else .ok (left / right) + +/-- +A total reference evaluator. Fuel bounds expression nesting and recursive call depth; +each child receives the parent's remaining fuel. It is not a global step counter. +-/ +def evalExpr [Field F] [DecidableEq F] (program : Program F) + (locals : List (String × F)) : Nat → Expr F → Except EvalError F + | 0, _ => .error .outOfFuel + | fuel + 1, expr => do + match expr with + | .literal value => pure value + | .var name => + let some (_, value) := locals.find? (·.1 == name) | throw (.unboundVariable name) + pure value + | .neg value => return -(← evalExpr program locals fuel value) + | .binary op left right => + let left ← evalExpr program locals fuel left + let right ← evalExpr program locals fuel right + evalBinOp op left right + | .call name args => + let some fn := program.findFunction? name | throw (.unknownFunction name) + if fn.params.length != args.length then + throw (.arityMismatch name fn.params.length args.length) + let values ← args.mapM (evalExpr program locals fuel) + evalExpr program (fn.params.zip values) fuel fn.body + | .matchValue scrutinee arms => + let value ← evalExpr program locals fuel scrutinee + let some (_, body) := arms.find? (fun (pat, _) => pat.matches value) + | throw .noMatchingArm + evalExpr program locals fuel body + +/-- Evaluate an entry function with field arguments, checking the whole program first. -/ +def eval [Field F] [DecidableEq F] (program : Program F) (function : String) + (args : List F) (fuel : Nat := 1000) : Except EvalError F := do + match typecheck program with + | .error error => throw (.invalidProgram error) + | .ok () => pure () + let some fn := program.findFunction? function | throw (.unknownFunction function) + if fn.params.length != args.length then + throw (.arityMismatch function fn.params.length args.length) + evalExpr program (fn.params.zip args) fuel fn.body + +end Aiur.Scalar diff --git a/Aiur/Aiur/Scalar/EvalCorrectness.lean b/Aiur/Aiur/Scalar/EvalCorrectness.lean new file mode 100644 index 000000000..e6d131e4a --- /dev/null +++ b/Aiur/Aiur/Scalar/EvalCorrectness.lean @@ -0,0 +1,284 @@ +import Aiur.Scalar.Eval +import Aiur.Scalar.Semantics + +namespace Aiur.Scalar + +theorem SelectArm.find_eq [DecidableEq F] {value : F} {arms : List (Pattern F × Expr F)} + {body : Expr F} (selected : SelectArm value arms body) : + ∃ pattern, arms.find? (fun (pat, _) => pat.matches value) = some (pattern, body) := by + induction selected with + | literal => exact ⟨.literal value, by simp [List.find?, Pattern.matches]⟩ + | wildcard => exact ⟨.wildcard, by simp [List.find?, Pattern.matches]⟩ + | skip different _ ih => + obtain ⟨pattern, found⟩ := ih + exact ⟨pattern, by simpa [List.find?, Pattern.matches, different] using found⟩ + +theorem SelectArm.of_find [DecidableEq F] {value : F} {arms : List (Pattern F × Expr F)} + {pattern : Pattern F} {body : Expr F} + (found : arms.find? (fun (pat, _) => pat.matches value) = some (pattern, body)) : + SelectArm value arms body := by + induction arms with + | nil => simp at found + | cons arm rest ih => + rcases arm with ⟨headPattern, headBody⟩ + cases headPattern with + | wildcard => + simp [List.find?, Pattern.matches] at found + rcases found with ⟨rfl, rfl⟩ + exact .wildcard + | literal literal => + by_cases same : literal = value + · subst literal + simp [List.find?, Pattern.matches] at found + rcases found with ⟨rfl, rfl⟩ + exact .literal + · exact .skip same (ih (by simpa [List.find?, Pattern.matches, same] using found)) + +private theorem evalArgs_of_mapM [Field F] [DecidableEq F] {program : Program F} + {locals : Environment F} {fuel : Nat} + (sound : ∀ expr result, evalExpr program locals fuel expr = .ok result → + EvalExpr program locals expr result) + {args : List (Expr F)} {values : List F} + (executed : args.mapM (evalExpr program locals fuel) = .ok values) : + EvalArgs program locals args values := by + induction args generalizing values with + | nil => + simp [pure, Except.pure] at executed + subst values + exact .nil + | cons head tail ih => + cases headRun : evalExpr program locals fuel head with + | error error => simp [List.mapM_cons, headRun, bind, Except.bind] at executed + | ok value => + cases tailRun : tail.mapM (evalExpr program locals fuel) with + | error error => simp [List.mapM_cons, headRun, tailRun, bind, Except.bind] at executed + | ok results => + simp [List.mapM_cons, headRun, tailRun, bind, pure, Except.bind, Except.pure] at executed + subst values + exact .cons (sound head value headRun) (ih tailRun) + +/-- Every successful executable expression evaluation has a fuel-free derivation. -/ +theorem evalExpr_spec [Field F] [DecidableEq F] {program : Program F} + {locals : Environment F} {fuel : Nat} {expr : Expr F} {result : F} + (executed : evalExpr program locals fuel expr = .ok result) : + EvalExpr program locals expr result := by + induction fuel generalizing locals expr result with + | zero => simp [evalExpr] at executed + | succ fuel ih => + cases expr with + | literal value => + simp [evalExpr, pure, Except.pure] at executed + subst result + exact .literal + | var name => + cases found : locals.find? (·.1 == name) with + | none => simp [evalExpr, found, throw] at executed + | some binding => + rcases binding with ⟨key, value⟩ + have same : key = name := by simpa using List.find?_some found + subst key + simp [evalExpr, found, pure, Except.pure] at executed + subst result + exact .var found + | neg expr => + cases innerRun : evalExpr program locals fuel expr with + | error error => simp [evalExpr, innerRun, bind, Except.bind] at executed + | ok value => + simp [evalExpr, innerRun, bind, pure, Except.bind, Except.pure] at executed + subst result + exact .neg (ih innerRun) + | binary op left right => + cases leftRun : evalExpr program locals fuel left with + | error error => simp [evalExpr, leftRun, bind, Except.bind] at executed + | ok leftValue => + cases rightRun : evalExpr program locals fuel right with + | error error => simp [evalExpr, leftRun, rightRun, bind, Except.bind] at executed + | ok rightValue => + have operation : evalBinOp op leftValue rightValue = .ok result := by + simpa [evalExpr, leftRun, rightRun, bind, Except.bind] using executed + cases op with + | add => + simp [evalBinOp] at operation + subst result + exact .add (ih leftRun) (ih rightRun) + | sub => + simp [evalBinOp] at operation + subst result + exact .sub (ih leftRun) (ih rightRun) + | mul => + simp [evalBinOp] at operation + subst result + exact .mul (ih leftRun) (ih rightRun) + | div => + by_cases zero : rightValue = 0 + · simp [evalBinOp, zero] at operation + · simp [evalBinOp, zero] at operation + subst result + exact .div (ih leftRun) (ih rightRun) zero + | call name args => + cases found : program.findFunction? name with + | none => simp [evalExpr, found, throw] at executed + | some defn => + by_cases arity : defn.params.length = args.length + · cases argsRun : args.mapM (evalExpr program locals fuel) with + | error error => + simp [evalExpr, found, arity, argsRun, bind, pure, Except.bind, Except.pure] at executed + | ok values => + have arguments := evalArgs_of_mapM (fun _ _ run => ih run) argsRun + have bodyRun : evalExpr program (defn.params.zip values) fuel defn.body = .ok result := by + simpa [evalExpr, found, arity, argsRun, bind, pure, Except.bind, Except.pure] using executed + exact .call arguments (.intro found (arity.trans arguments.length_eq) (ih bodyRun)) + · simp [evalExpr, found, arity, bind, Except.bind] at executed + | matchValue scrutinee arms => + cases scrutineeRun : evalExpr program locals fuel scrutinee with + | error error => simp [evalExpr, scrutineeRun, bind, Except.bind] at executed + | ok value => + cases found : arms.find? (fun (pat, _) => pat.matches value) with + | none => simp [evalExpr, scrutineeRun, found, bind, Except.bind, throw] at executed + | some arm => + rcases arm with ⟨pattern, body⟩ + have bodyRun : evalExpr program locals fuel body = .ok result := by + simpa [evalExpr, scrutineeRun, found, bind, Except.bind] using executed + exact .matchValue (ih scrutineeRun) (.of_find found) (ih bodyRun) + +/-- The public evaluator checks the program, resolves the entry, and executes its body. -/ +theorem eval_eq_ok_iff [Field F] [DecidableEq F] {program : Program F} + {name : String} {args : List F} {fuel : Nat} {result : F} : + eval program name args fuel = .ok result ↔ + typecheck program = .ok () ∧ ∃ defn, program.findFunction? name = some defn ∧ + defn.params.length = args.length ∧ + evalExpr program (defn.params.zip args) fuel defn.body = .ok result := by + cases checked : typecheck program with + | error error => simp [eval, checked, bind, Except.bind] + | ok checkedUnit => + cases checkedUnit + cases found : program.findFunction? name with + | none => simp [eval, checked, found, bind, pure, Except.bind, Except.pure, throw] + | some defn => + by_cases arity : defn.params.length = args.length <;> + simp [eval, checked, found, arity, bind, pure, Except.bind, Except.pure] + +/-- `eval = .ok result` implies the evaluation predicate, for every fuel bound. -/ +theorem eval_spec [Field F] [DecidableEq F] {program : Program F} + {name : String} {args : List F} {fuel : Nat} {result : F} + (executed : eval program name args fuel = .ok result) : EvalCall program name args result := by + obtain ⟨_, defn, found, arity, body⟩ := eval_eq_ok_iff.mp executed + exact .intro found arity (evalExpr_spec body) + +/-- A finite expression derivation executes successfully at every sufficiently large fuel bound. -/ +theorem EvalExpr.eventually_runs [Field F] [DecidableEq F] {program : Program F} + {locals : Environment F} {expr : Expr F} {result : F} + (evaluates : EvalExpr program locals expr result) : + ∃ minimum, ∀ fuel, minimum ≤ fuel → evalExpr program locals fuel expr = .ok result := by + induction evaluates using EvalExpr.rec + (motive_2 := fun locals exprs values _ => + ∃ minimum, ∀ fuel, minimum ≤ fuel → exprs.mapM (evalExpr program locals fuel) = .ok values) + (motive_3 := fun name args result _ => + ∃ minimum, ∀ fuel, minimum ≤ fuel → + ∃ defn, program.findFunction? name = some defn ∧ defn.params.length = args.length ∧ + evalExpr program (defn.params.zip args) fuel defn.body = .ok result) with + | literal => + refine ⟨1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => simp [evalExpr, pure, Except.pure] + | var lookup => + refine ⟨1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => simp [evalExpr, lookup, pure, Except.pure] + | neg _ ih => + obtain ⟨minimum, runs⟩ := ih + refine ⟨minimum + 1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => + simp [evalExpr, runs fuel (by omega), bind, pure, Except.bind, Except.pure] + | add _ _ leftIH rightIH | sub _ _ leftIH rightIH | mul _ _ leftIH rightIH => + obtain ⟨leftMinimum, leftRuns⟩ := leftIH + obtain ⟨rightMinimum, rightRuns⟩ := rightIH + refine ⟨max leftMinimum rightMinimum + 1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => + simp [evalExpr, leftRuns fuel (by omega), rightRuns fuel (by omega), + evalBinOp, bind, Except.bind] + | div _ _ nonzero leftIH rightIH => + obtain ⟨leftMinimum, leftRuns⟩ := leftIH + obtain ⟨rightMinimum, rightRuns⟩ := rightIH + refine ⟨max leftMinimum rightMinimum + 1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => + simp [evalExpr, leftRuns fuel (by omega), rightRuns fuel (by omega), + evalBinOp, nonzero, bind, Except.bind] + | call arguments _ argumentsIH calleeIH => + obtain ⟨argsMinimum, argsRuns⟩ := argumentsIH + obtain ⟨callMinimum, callRuns⟩ := calleeIH + refine ⟨max argsMinimum callMinimum + 1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => + obtain ⟨defn, lookup, arity, bodyRun⟩ := callRuns fuel (by omega) + have syntaxArity := arity.trans arguments.length_eq.symm + simpa [evalExpr, lookup, syntaxArity, argsRuns fuel (by omega), + bind, pure, Except.bind, Except.pure] using bodyRun + | matchValue _ selected _ scrutineeIH branchIH => + obtain ⟨scrutineeMinimum, scrutineeRuns⟩ := scrutineeIH + obtain ⟨branchMinimum, branchRuns⟩ := branchIH + obtain ⟨pattern, found⟩ := selected.find_eq + refine ⟨max scrutineeMinimum branchMinimum + 1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => + simpa [evalExpr, scrutineeRuns fuel (by omega), found, bind, Except.bind] + using branchRuns fuel (by omega) + | nil => exact ⟨0, fun _ _ => rfl⟩ + | cons _ _ headIH tailIH => + obtain ⟨headMinimum, headRuns⟩ := headIH + obtain ⟨tailMinimum, tailRuns⟩ := tailIH + refine ⟨max headMinimum tailMinimum, ?_⟩ + intro fuel enough + simp [List.mapM_cons, headRuns fuel (by omega), tailRuns fuel (by omega), + bind, pure, Except.bind, Except.pure] + | intro lookup arity _ bodyIH => + obtain ⟨minimum, bodyRuns⟩ := bodyIH + exact ⟨minimum, fun fuel enough => ⟨_, lookup, arity, bodyRuns fuel enough⟩⟩ + +/-- The program check is the only extra condition imposed by the public evaluator. -/ +theorem EvalCall.eventually_eval [Field F] [DecidableEq F] {program : Program F} + (checked : typecheck program = .ok ()) {name : String} {args : List F} {result : F} + (evaluates : EvalCall program name args result) : + ∃ minimum, ∀ fuel, minimum ≤ fuel → eval program name args fuel = .ok result := by + cases evaluates with + | intro lookup arity body => + obtain ⟨minimum, runs⟩ := body.eventually_runs + exact ⟨minimum, fun fuel enough => eval_eq_ok_iff.mpr ⟨checked, _, lookup, arity, runs fuel enough⟩⟩ + +/-- Every successful source call in a checked program can be run with enough fuel. -/ +theorem eval_complete [Field F] [DecidableEq F] {program : Program F} + (checked : typecheck program = .ok ()) {name : String} {args : List F} {result : F} + (evaluates : EvalCall program name args result) : + ∃ fuel, eval program name args fuel = .ok result := by + obtain ⟨minimum, runs⟩ := evaluates.eventually_eval checked + exact ⟨minimum, runs minimum (Nat.le_refl _)⟩ + +/-- Exact correspondence for the checked public evaluator, quantifying over sufficient fuel. -/ +theorem exists_eval_iff [Field F] [DecidableEq F] {program : Program F} + {name : String} {args : List F} {result : F} : + (∃ fuel, eval program name args fuel = .ok result) ↔ + typecheck program = .ok () ∧ EvalCall program name args result := by + constructor + · rintro ⟨fuel, executed⟩ + exact ⟨(eval_eq_ok_iff.mp executed).1, eval_spec executed⟩ + · rintro ⟨checked, evaluated⟩ + exact eval_complete checked evaluated + +end Aiur.Scalar diff --git a/Aiur/Aiur/Scalar/Frontend.lean b/Aiur/Aiur/Scalar/Frontend.lean new file mode 100644 index 000000000..c0fd7bb2e --- /dev/null +++ b/Aiur/Aiur/Scalar/Frontend.lean @@ -0,0 +1,182 @@ +import Aiur.Scalar.Typecheck +import Lean + +namespace Aiur.Scalar.Frontend + +open Lean Elab Term + +declare_syntax_cat scalar_aiur_expr +declare_syntax_cat scalar_aiur_pattern +declare_syntax_cat scalar_aiur_arm +declare_syntax_cat scalar_aiur_param +declare_syntax_cat scalar_aiur_function +declare_syntax_cat scalar_aiur_program + +syntax (name := literal) num : scalar_aiur_expr +syntax (name := variableExpr) ident : scalar_aiur_expr +syntax (name := parens) "(" scalar_aiur_expr ")" : scalar_aiur_expr +syntax (name := block) "{" scalar_aiur_expr "}" : scalar_aiur_expr +syntax (name := call) ident "(" sepBy(scalar_aiur_expr, ",", ",", allowTrailingSep) ")" : scalar_aiur_expr +syntax:75 (name := neg) "-" scalar_aiur_expr:75 : scalar_aiur_expr +syntax:70 (name := mul) scalar_aiur_expr:70 "*" scalar_aiur_expr:71 : scalar_aiur_expr +syntax:70 (name := div) scalar_aiur_expr:70 "/" scalar_aiur_expr:71 : scalar_aiur_expr +syntax:65 (name := add) scalar_aiur_expr:65 "+" scalar_aiur_expr:66 : scalar_aiur_expr +syntax:65 (name := sub) scalar_aiur_expr:65 "-" scalar_aiur_expr:66 : scalar_aiur_expr +syntax (name := literalPattern) num : scalar_aiur_pattern +syntax (name := wildcardPattern) "_" : scalar_aiur_pattern +syntax (name := arm) scalar_aiur_pattern "=>" scalar_aiur_expr : scalar_aiur_arm +syntax (name := matchValue) "match" scalar_aiur_expr "{" + sepBy1(scalar_aiur_arm, ",", ",", allowTrailingSep) "}" : scalar_aiur_expr +syntax (name := param) ident (":" ident)? : scalar_aiur_param +syntax (name := function) "fn" ident "(" sepBy(scalar_aiur_param, ",", ",", allowTrailingSep) ")" + ("->" ident)? "{" scalar_aiur_expr "}" : scalar_aiur_function +syntax (name := program) scalar_aiur_function* : scalar_aiur_program + +private def readName (stx : Syntax) : Except String String := + match stx.getId with + | .str .anonymous name => .ok name + | _ => .error "expected a simple function or parameter name" + +private def lowerPattern (stx : Syntax) : Except String (Pattern Nat) := do + if stx.getKind == ``literalPattern then + let some value := stx[0].isNatLit? | throw "expected a natural-number pattern" + return .literal value + else if stx.getKind == ``wildcardPattern then + return .wildcard + else + throw "expected a natural-number pattern or '_'" + +/-- Lower Lean's syntax tree for the embedded language; no field is chosen here. -/ +private partial def lowerExpr (stx : Syntax) : Except String (Aiur.Scalar.Expr Nat) := do + let kind := stx.getKind + if kind == ``literal then + let some value := stx[0].isNatLit? | throw "expected a natural-number literal" + return .literal value + else if kind == ``variableExpr then + return .var (← readName stx[0]) + else if kind == ``parens || kind == ``block then + lowerExpr stx[1] + else if kind == ``neg then + return .neg (← lowerExpr stx[1]) + else if kind == ``add || kind == ``sub || kind == ``mul || kind == ``div then + let op := if kind == ``add then BinOp.add else if kind == ``sub then .sub + else if kind == ``mul then .mul else .div + return .binary op (← lowerExpr stx[0]) (← lowerExpr stx[2]) + else if kind == ``call then + return .call (← readName stx[0]) (← stx[2].getSepArgs.toList.mapM lowerExpr) + else if kind == ``matchValue then + let scrutinee ← lowerExpr stx[1] + let arms ← stx[3].getSepArgs.toList.mapM fun arm => do + return (← lowerPattern arm[0], ← lowerExpr arm[2]) + return .matchValue scrutinee arms + else + throw s!"unsupported expression syntax: {kind}" + +private def checkAnnotation (stx : Syntax) : Except String Unit := do + if !stx.getArgs.isEmpty then + if stx[1].getId != `Field then throw "expected type 'Field'" + +private def lowerFunction (stx : Syntax) : Except String (Aiur.Scalar.Function Nat) := do + checkAnnotation stx[5] + return { + name := ← readName stx[1] + params := ← stx[3].getSepArgs.toList.mapM (fun param => do + checkAnnotation param[1] + readName param[0]) + body := ← lowerExpr stx[7] + } + +/-- Mask Rust comments before invoking Lean's parser, preserving lines and token boundaries. -/ +private def maskComments : List Char → Nat → Bool → Except String (List Char) + | [], depth, _ => + if depth == 0 then .ok [] else .error "unterminated block comment" + | '/' :: '/' :: rest, 0, false => do + return ' ' :: ' ' :: (← maskComments rest 0 true) + | '/' :: '*' :: rest, depth, false => do + return ' ' :: ' ' :: (← maskComments rest (depth + 1) false) + | '*' :: '/' :: rest, depth + 1, false => do + return ' ' :: ' ' :: (← maskComments rest depth false) + | char :: rest, depth, inLine => do + let masked := if (inLine || depth > 0) && char != '\n' && char != '\r' then ' ' else char + return masked :: (← maskComments rest depth (inLine && char != '\n')) + +/-- Keep adjacent arithmetic operators from being interpreted as Lean comments. -/ +private def normalizeWhitespace : List Char → List Char + | [] => [] + | char :: rest => + let normalized := if char == '\t' || char == '\r' then ' ' else char + if (char == '-' || char == '/') && rest.head? == some '-' then + normalized :: ' ' :: normalizeWhitespace rest + else + normalized :: normalizeWhitespace rest + +/-- Parse and typecheck a string using the syntax categories registered in Lean. -/ +def ofString (env : Environment) (source : String) : Except String (Program Nat) := do + let source := String.ofList (normalizeWhitespace (← maskComments source.toList 0 false)) + let stx ← Parser.runParserCategory env `scalar_aiur_program source "" + let program := { functions := ← stx[0].getArgs.toList.mapM lowerFunction } + match typecheck program with + | .error error => throw (toString error) + | .ok () => pure program + +private def quoteList (type : Lean.Expr) (values : List Lean.Expr) : Lean.Expr := + values.foldr (fun value tail => mkApp3 (mkConst ``List.cons [0]) type value tail) + (mkApp (mkConst ``List.nil [0]) type) + +private def natType : Lean.Expr := mkConst ``Nat +private def exprType : Lean.Expr := mkApp (mkConst ``Aiur.Scalar.Expr) natType +private def patternType : Lean.Expr := mkApp (mkConst ``Pattern) natType + +private def quoteOp : BinOp → Lean.Expr + | .add => mkConst ``BinOp.add + | .sub => mkConst ``BinOp.sub + | .mul => mkConst ``BinOp.mul + | .div => mkConst ``BinOp.div + +private def quotePattern : Pattern Nat → Lean.Expr + | .literal value => mkApp2 (mkConst ``Pattern.literal) natType (toExpr value) + | .wildcard => mkApp (mkConst ``Pattern.wildcard) natType + +private def quoteExpr : Aiur.Scalar.Expr Nat → Lean.Expr + | .literal value => mkApp2 (mkConst ``Aiur.Scalar.Expr.literal) natType (toExpr value) + | .var name => mkApp2 (mkConst ``Aiur.Scalar.Expr.var) natType (toExpr name) + | .neg value => mkApp2 (mkConst ``Aiur.Scalar.Expr.neg) natType (quoteExpr value) + | .binary op left right => + mkApp4 (mkConst ``Aiur.Scalar.Expr.binary) natType (quoteOp op) (quoteExpr left) (quoteExpr right) + | .call name args => + mkApp3 (mkConst ``Aiur.Scalar.Expr.call) natType (toExpr name) + (quoteList exprType (args.map quoteExpr)) + | .matchValue scrutinee arms => + let armType := mkApp2 (mkConst ``Prod [0, 0]) patternType exprType + let arms := arms.map fun arm => + mkApp4 (mkConst ``Prod.mk [0, 0]) patternType exprType + (quotePattern arm.1) (quoteExpr arm.2) + mkApp3 (mkConst ``Aiur.Scalar.Expr.matchValue) natType (quoteExpr scrutinee) (quoteList armType arms) +termination_by expr => sizeOf expr +decreasing_by + all_goals simp_wf + all_goals + first + | omega + | have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + first + | omega + | cases arm + simp_all only [Prod.mk.sizeOf_spec] + omega + +private def quoteFunction (defn : Aiur.Scalar.Function Nat) : Lean.Expr := + mkApp4 (mkConst ``Aiur.Scalar.Function.mk) natType (toExpr defn.name) (toExpr defn.params) + (quoteExpr defn.body) + +private def quoteProgram (program : Program Nat) : Lean.Expr := + mkApp2 (mkConst ``Program.mk) natType + (quoteList (mkApp (mkConst ``Aiur.Scalar.Function) natType) (program.functions.map quoteFunction)) + +/-- Elaborate a Rust-like source string directly to a checked `Program Nat`. -/ +elab "scalar_aiur% " source:str : term => do + match ofString (← getEnv) source.getString with + | .error error => throwErrorAt source "{error}" + | .ok program => return quoteProgram program + +end Aiur.Scalar.Frontend diff --git a/Aiur/Aiur/Scalar/MemoCompleteness.lean b/Aiur/Aiur/Scalar/MemoCompleteness.lean new file mode 100644 index 000000000..f86287247 --- /dev/null +++ b/Aiur/Aiur/Scalar/MemoCompleteness.lean @@ -0,0 +1,24 @@ +import Aiur.Scalar.Correctness +import Aiur.Scalar.Circuit.MemoDerivation +import Aiur.Scalar.EvalCorrectness + +namespace Aiur.Scalar + +/-- Every successful source evaluation admits a finite memoized circuit graph. -/ +theorem memo_complete [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {name : String} {args : List F} {result : F} (evaluates : EvalCall program name args result) : + Circuit.MemoAccepts system name args result := + (evaluation_complete compiled evaluates).memo + +/-- A successful executable run supplies a memoized graph for its result. -/ +theorem memo_eval_complete [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {name : String} {args : List F} {fuel : Nat} {result : F} + (executed : eval program name args fuel = .ok result) : + Circuit.MemoAccepts system name args result := + memo_complete compiled (eval_spec executed) + +end Aiur.Scalar diff --git a/Aiur/Aiur/Scalar/MemoSoundness.lean b/Aiur/Aiur/Scalar/MemoSoundness.lean new file mode 100644 index 000000000..5b95658c4 --- /dev/null +++ b/Aiur/Aiur/Scalar/MemoSoundness.lean @@ -0,0 +1,15 @@ +import Aiur.Scalar.Correctness +import Aiur.Scalar.Circuit.MemoAcyclic + +namespace Aiur.Scalar + +/-- Every acyclic graph for a compiled system has a finite source evaluation. -/ +theorem memo_acyclic_sound [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) {message : Circuit.Message F} + (graph : Circuit.MemoDerivation system message) (acyclic : graph.Acyclic) : + EvalCall program message.channel message.args message.result := by + obtain ⟨tree⟩ := graph.derives_of_acyclic acyclic + exact derivation_sound compiled tree + +end Aiur.Scalar diff --git a/Aiur/Aiur/Scalar/Semantics.lean b/Aiur/Aiur/Scalar/Semantics.lean new file mode 100644 index 000000000..1e0e2c4b8 --- /dev/null +++ b/Aiur/Aiur/Scalar/Semantics.lean @@ -0,0 +1,144 @@ +import Aiur.Scalar.AST +import Mathlib.Algebra.Field.Defs + +namespace Aiur.Scalar + +abbrev Environment (F : Type) := List (String × F) + +/-- Select the first matching arm. There is no rule for skipping a wildcard. -/ +inductive SelectArm (value : F) : List (Pattern F × Expr F) → Expr F → Prop where + | literal : SelectArm value ((.literal value, body) :: rest) body + | wildcard : SelectArm value ((.wildcard, body) :: rest) body + | skip (different : pattern ≠ value) (next : SelectArm value rest body) : + SelectArm value ((.literal pattern, other) :: rest) body + +theorem SelectArm.deterministic {value : F} {arms : List (Pattern F × Expr F)} + {left right : Expr F} (first : SelectArm value arms left) + (second : SelectArm value arms right) : left = right := by + induction first with + | literal => cases second <;> simp_all + | wildcard => cases second <;> rfl + | skip different _ ih => + cases second with + | literal => exact (different rfl).elim + | skip _ next => exact ih next + +mutual + /-- Successful expression evaluation, with finite derivations and no fuel. -/ + inductive EvalExpr [Field F] (program : Program F) : Environment F → Expr F → F → Prop where + | literal : EvalExpr program locals (.literal value) value + | var (lookup : locals.find? (·.1 == name) = some (name, value)) : + EvalExpr program locals (.var name) value + | neg (operand : EvalExpr program locals expr value) : + EvalExpr program locals (.neg expr) (-value) + | add (left : EvalExpr program locals lhs x) (right : EvalExpr program locals rhs y) : + EvalExpr program locals (.binary .add lhs rhs) (x + y) + | sub (left : EvalExpr program locals lhs x) (right : EvalExpr program locals rhs y) : + EvalExpr program locals (.binary .sub lhs rhs) (x - y) + | mul (left : EvalExpr program locals lhs x) (right : EvalExpr program locals rhs y) : + EvalExpr program locals (.binary .mul lhs rhs) (x * y) + | div (left : EvalExpr program locals lhs x) (right : EvalExpr program locals rhs y) + (nonzero : y ≠ 0) : + EvalExpr program locals (.binary .div lhs rhs) (x / y) + | call (arguments : EvalArgs program locals args values) + (callee : EvalCall program name values result) : + EvalExpr program locals (.call name args) result + | matchValue (scrutinee : EvalExpr program locals expr value) + (selected : SelectArm value arms body) (branch : EvalExpr program locals body result) : + EvalExpr program locals (.matchValue expr arms) result + + /-- Each argument is evaluated in the caller's environment, preserving its position. -/ + inductive EvalArgs [Field F] (program : Program F) : + Environment F → List (Expr F) → List F → Prop where + | nil : EvalArgs program locals [] [] + | cons (head : EvalExpr program locals expr value) + (tail : EvalArgs program locals exprs values) : + EvalArgs program locals (expr :: exprs) (value :: values) + + /-- A function call binds exactly its parameters and evaluates its body. -/ + inductive EvalCall [Field F] (program : Program F) : String → List F → F → Prop where + | intro (lookup : program.findFunction? name = some defn) + (arity : defn.params.length = args.length) + (body : EvalExpr program (defn.params.zip args) defn.body result) : + EvalCall program name args result +end + +theorem EvalArgs.length_eq [Field F] {program : Program F} + {locals : Environment F} {exprs : List (Expr F)} {values : List F} + (evaluates : EvalArgs program locals exprs values) : exprs.length = values.length := by + induction evaluates using EvalArgs.rec + (motive_1 := fun _ _ _ _ => True) (motive_3 := fun _ _ _ _ => True) <;> simp_all + +/-- Unknown functions and calls with the wrong arity cannot have derivations. -/ +theorem EvalCall.function_exists [Field F] {program : Program F} {name : String} + {args : List F} {result : F} (evaluates : EvalCall program name args result) : + ∃ defn, program.findFunction? name = some defn ∧ defn.params.length = args.length := by + cases evaluates with + | intro lookup arity _ => exact ⟨_, lookup, arity⟩ + +/-- A finite source evaluation determines its result uniquely. -/ +theorem EvalExpr.deterministic [Field F] {program : Program F} + {locals : Environment F} {expr : Expr F} {left right : F} + (first : EvalExpr program locals expr left) (second : EvalExpr program locals expr right) : + left = right := by + induction first using EvalExpr.rec + (motive_2 := fun locals exprs values _ => + ∀ other, EvalArgs program locals exprs other → values = other) + (motive_3 := fun name args value _ => + ∀ other, EvalCall program name args other → value = other) generalizing right with + | literal => cases second; rfl + | var lookup => cases second; simp_all + | neg _ ih => + cases second with + | neg operand => rw [ih operand] + | add _ _ leftIH rightIH => + cases second with + | add left right => rw [leftIH left, rightIH right] + | sub _ _ leftIH rightIH => + cases second with + | sub left right => rw [leftIH left, rightIH right] + | mul _ _ leftIH rightIH => + cases second with + | mul left right => rw [leftIH left, rightIH right] + | div _ _ _ leftIH rightIH => + cases second with + | div left right _ => rw [leftIH left, rightIH right] + | call _ _ argumentsIH calleeIH => + cases second with + | call arguments callee => + cases argumentsIH _ arguments + exact calleeIH _ callee + | matchValue _ selected _ scrutineeIH branchIH => + cases second with + | matchValue scrutinee otherSelected branch => + cases scrutineeIH scrutinee + cases selected.deterministic otherSelected + exact branchIH branch + | nil => rename_i other evaluated; cases evaluated; rfl + | cons _ _ headIH tailIH => + rename_i other evaluated + cases evaluated with + | cons head tail => + cases headIH head + cases tailIH _ tail + rfl + | intro lookup _ _ bodyIH => + rename_i other evaluated + cases evaluated with + | intro otherLookup _ body => + have same := Option.some.inj (lookup.symm.trans otherLookup) + cases same + exact bodyIH body + +theorem EvalCall.deterministic [Field F] {program : Program F} {name : String} + {args : List F} {left right : F} (first : EvalCall program name args left) + (second : EvalCall program name args right) : left = right := by + cases first with + | intro lookup _ body => + cases second with + | intro otherLookup _ otherBody => + have same := Option.some.inj (lookup.symm.trans otherLookup) + cases same + exact body.deterministic otherBody + +end Aiur.Scalar diff --git a/Aiur/Aiur/Scalar/Semantics/WithCalls.lean b/Aiur/Aiur/Scalar/Semantics/WithCalls.lean new file mode 100644 index 000000000..6214d309d --- /dev/null +++ b/Aiur/Aiur/Scalar/Semantics/WithCalls.lean @@ -0,0 +1,84 @@ +import Aiur.Scalar.Semantics + +namespace Aiur.Scalar + +/-- Interpret a call by a supplied relation while evaluating the surrounding body. -/ +abbrev CallRelation (F : Type) := String → List F → F → Prop + +mutual + /-- One function body's semantics, with calls supplied as premises. -/ + inductive EvalExprWith [Field F] (calls : CallRelation F) : + Environment F → Expr F → F → Prop where + | literal : EvalExprWith calls locals (.literal value) value + | var (lookup : locals.find? (·.1 == name) = some (name, value)) : + EvalExprWith calls locals (.var name) value + | neg (operand : EvalExprWith calls locals expr value) : + EvalExprWith calls locals (.neg expr) (-value) + | add (left : EvalExprWith calls locals lhs x) (right : EvalExprWith calls locals rhs y) : + EvalExprWith calls locals (.binary .add lhs rhs) (x + y) + | sub (left : EvalExprWith calls locals lhs x) (right : EvalExprWith calls locals rhs y) : + EvalExprWith calls locals (.binary .sub lhs rhs) (x - y) + | mul (left : EvalExprWith calls locals lhs x) (right : EvalExprWith calls locals rhs y) : + EvalExprWith calls locals (.binary .mul lhs rhs) (x * y) + | div (left : EvalExprWith calls locals lhs x) (right : EvalExprWith calls locals rhs y) + (nonzero : y ≠ 0) : + EvalExprWith calls locals (.binary .div lhs rhs) (x / y) + | call (arguments : EvalArgsWith calls locals args values) (callee : calls name values result) : + EvalExprWith calls locals (.call name args) result + | matchValue (scrutinee : EvalExprWith calls locals expr value) + (selected : SelectArm value arms body) (branch : EvalExprWith calls locals body result) : + EvalExprWith calls locals (.matchValue expr arms) result + + inductive EvalArgsWith [Field F] (calls : CallRelation F) : + Environment F → List (Expr F) → List F → Prop where + | nil : EvalArgsWith calls locals [] [] + | cons (head : EvalExprWith calls locals expr value) + (tail : EvalArgsWith calls locals exprs values) : + EvalArgsWith calls locals (expr :: exprs) (value :: values) +end + +/-- Supplying actual source call proofs recovers the original expression relation. -/ +theorem EvalExprWith.toEvalExpr [Field F] {program : Program F} + {locals : Environment F} {expr : Expr F} {result : F} + (evaluates : EvalExprWith (EvalCall program) locals expr result) : + EvalExpr program locals expr result := by + induction evaluates using EvalExprWith.rec + (motive_2 := fun locals exprs values _ => EvalArgs program locals exprs values) with + | literal => exact .literal + | var lookup => exact .var lookup + | neg _ ih => exact .neg ih + | add _ _ leftIH rightIH => exact .add leftIH rightIH + | sub _ _ leftIH rightIH => exact .sub leftIH rightIH + | mul _ _ leftIH rightIH => exact .mul leftIH rightIH + | div _ _ nonzero leftIH rightIH => exact .div leftIH rightIH nonzero + | call _ callee argumentsIH => exact .call argumentsIH callee + | matchValue _ selected _ scrutineeIH branchIH => exact .matchValue scrutineeIH selected branchIH + | nil => exact .nil + | cons _ _ headIH tailIH => exact .cons headIH tailIH + +theorem EvalExpr.toEvalExprWith [Field F] {program : Program F} + {locals : Environment F} {expr : Expr F} {result : F} + (evaluates : EvalExpr program locals expr result) : + EvalExprWith (EvalCall program) locals expr result := by + induction evaluates using EvalExpr.rec + (motive_2 := fun locals exprs values _ => EvalArgsWith (EvalCall program) locals exprs values) + (motive_3 := fun _ _ _ _ => True) with + | literal => exact .literal + | var lookup => exact .var lookup + | neg _ ih => exact .neg ih + | add _ _ leftIH rightIH => exact .add leftIH rightIH + | sub _ _ leftIH rightIH => exact .sub leftIH rightIH + | mul _ _ leftIH rightIH => exact .mul leftIH rightIH + | div _ _ nonzero leftIH rightIH => exact .div leftIH rightIH nonzero + | call _ callee argumentsIH _ => exact .call argumentsIH callee + | matchValue _ selected _ scrutineeIH branchIH => exact .matchValue scrutineeIH selected branchIH + | nil => exact .nil + | cons _ _ headIH tailIH => exact .cons headIH tailIH + | intro => trivial + +theorem evalExprWith_iff_evalExpr [Field F] {program : Program F} + {locals : Environment F} {expr : Expr F} {result : F} : + EvalExprWith (EvalCall program) locals expr result ↔ EvalExpr program locals expr result := + ⟨EvalExprWith.toEvalExpr, EvalExpr.toEvalExprWith⟩ + +end Aiur.Scalar diff --git a/Aiur/Aiur/Scalar/Typecheck.lean b/Aiur/Aiur/Scalar/Typecheck.lean new file mode 100644 index 000000000..eba5ebd22 --- /dev/null +++ b/Aiur/Aiur/Scalar/Typecheck.lean @@ -0,0 +1,82 @@ +import Aiur.Scalar.AST + +namespace Aiur.Scalar + +inductive CheckError where + | duplicateFunction (name : String) + | duplicateParameter (function name : String) + | unboundVariable (function name : String) + | unknownFunction (caller callee : String) + | arityMismatch (caller callee : String) (expected actual : Nat) + | emptyMatch (function : String) + deriving Repr, BEq, DecidableEq + +instance : ToString CheckError where + toString + | .duplicateFunction name => s!"duplicate function '{name}'" + | .duplicateParameter fn name => s!"duplicate parameter '{name}' in function '{fn}'" + | .unboundVariable fn name => s!"unbound variable '{name}' in function '{fn}'" + | .unknownFunction caller callee => s!"unknown function '{callee}' in function '{caller}'" + | .arityMismatch caller callee expected actual => + s!"function '{caller}' calls '{callee}' with {actual} arguments; expected {expected}" + | .emptyMatch fn => s!"empty match in function '{fn}'" + +private def findDuplicate : List String → List String → Option String + | [], _ => none + | name :: rest, seen => + if name ∈ seen then some name else findDuplicate rest (name :: seen) + +mutual + /-- With only field values, inference checks variable scope and function signatures. -/ + def inferType (program : Program α) (caller : String) (locals : List String) + (expr : Expr α) : Except CheckError Ty := do + match expr with + | .literal _ => pure .field + | .var name => + if name ∈ locals then pure .field else throw (.unboundVariable caller name) + | .neg value => inferType program caller locals value + | .binary _ left right => + let _ ← inferType program caller locals left + inferType program caller locals right + | .call name args => + let some fn := program.findFunction? name | throw (.unknownFunction caller name) + if fn.params.length != args.length then + throw (.arityMismatch caller name fn.params.length args.length) + checkArgs program caller locals args + pure .field + | .matchValue scrutinee arms => + let _ ← inferType program caller locals scrutinee + if arms.isEmpty then throw (.emptyMatch caller) + checkArms program caller locals arms + pure .field + termination_by sizeOf expr + + private def checkArgs (program : Program α) (caller : String) (locals : List String) + (args : List (Expr α)) : Except CheckError Unit := do + match args with + | [] => pure () + | arg :: rest => + let _ ← inferType program caller locals arg + checkArgs program caller locals rest + termination_by sizeOf args + + private def checkArms (program : Program α) (caller : String) (locals : List String) + (arms : List (Pattern α × Expr α)) : Except CheckError Unit := do + match arms with + | [] => pure () + | (_, body) :: rest => + let _ ← inferType program caller locals body + checkArms program caller locals rest + termination_by sizeOf arms +end + +/-- Check every body against the complete signature table, without choosing a field. -/ +def typecheck (program : Program α) : Except CheckError Unit := do + if let some name := findDuplicate (program.functions.map (·.name)) [] then + throw (.duplicateFunction name) + for fn in program.functions do + if let some name := findDuplicate fn.params [] then + throw (.duplicateParameter fn.name name) + let _ ← inferType program fn.name fn.params fn.body + +end Aiur.Scalar diff --git a/Aiur/Aiur/Semantics.lean b/Aiur/Aiur/Semantics.lean new file mode 100644 index 000000000..cef32d68d --- /dev/null +++ b/Aiur/Aiur/Semantics.lean @@ -0,0 +1,70 @@ +import Aiur.Eval + +namespace Aiur + +mutual + /-- Finite source evaluation threads a fresh-allocation heap, with no fuel. -/ + inductive EvalExpr [Field F] [DecidableEq F] (program : Program F) : + Environment F Nat → Expr F → Heap F → SourceValue F → Heap F → Prop where + | literal : EvalExpr program locals (.literal value) heap (.field value) heap + | var (lookup : locals.find? (·.1 == name) = some (name, value)) : + EvalExpr program locals (.var name) heap value heap + | tuple (items : EvalArgs program locals exprs before values after) : + EvalExpr program locals (.tuple exprs) before (.tuple values) after + | construct (items : EvalArgs program locals exprs before values after) : + EvalExpr program locals (.construct name ctor exprs) before (.construct name ctor values) after + | project (value : EvalExpr program locals expr before input after) + (projected : projectValue input index = .ok result) : + EvalExpr program locals (.project expr index) before result after + | letValue (value : EvalExpr program locals expr before input middle) + (matched : pattern.bindings input = some bindings) + (body : EvalExpr program (bindings ++ locals) rest middle result after) : + EvalExpr program locals (.letValue pattern expr rest) before result after + | store (value : EvalExpr program locals expr before input middle) : + EvalExpr program locals (.store expr) before (.ptr input.type middle.length) (middle ++ [input]) + | load (pointer : EvalExpr program locals expr before input after) + (loaded : loadValue after input = .ok result) : + EvalExpr program locals (.load expr) before result after + | hint (key : EvalExpr program locals expr before input after) + {value : Constant F} (typed : value.WellTyped program.enums type) : + EvalExpr program locals (.hint type expr channel) before value.toValue after + | neg (value : EvalExpr program locals expr before input after) + (operation : evalNeg input = .ok result) : + EvalExpr program locals (.neg expr) before result after + | assertEq (left : EvalExpr program locals lhs before x middle) + (right : EvalExpr program locals rhs middle y after) + (operation : evalAssertEq op x y = .ok result) : + EvalExpr program locals (.assertEq op lhs rhs) before result after + | binary (left : EvalExpr program locals lhs before x middle) + (right : EvalExpr program locals rhs middle y after) + (operation : evalBinOp op x y = .ok result) : + EvalExpr program locals (.binary op lhs rhs) before result after + | call (arguments : EvalArgs program locals args before values middle) + (callee : EvalFn program name values middle result after) : + EvalExpr program locals (.call name args) before result after + | matchValue (value : EvalExpr program locals expr before input middle) + (selected : selectArm input arms = some (bindings, body)) + (branch : EvalExpr program (bindings ++ locals) body middle result after) : + EvalExpr program locals (.matchValue expr arms) before result after + + inductive EvalArgs [Field F] [DecidableEq F] (program : Program F) : + Environment F Nat → List (Expr F) → Heap F → List (SourceValue F) → Heap F → Prop where + | nil : EvalArgs program locals [] heap [] heap + | cons (head : EvalExpr program locals expr before value middle) + (tail : EvalArgs program locals exprs middle values after) : + EvalArgs program locals (expr :: exprs) before (value :: values) after + + /-- Internal calls share the caller's heap and may receive pointers. -/ + inductive EvalFn [Field F] [DecidableEq F] (program : Program F) : + String → List (SourceValue F) → Heap F → SourceValue F → Heap F → Prop where + | intro (prepared : prepareCall program name args = .ok (locals, expr)) + (body : EvalExpr program locals expr before result after) : + EvalFn program name args before result after +end + +/-- Public entry calls start with an empty heap and well-formed arguments of pointer-free types. -/ +def EvalCall [Field F] [DecidableEq F] (program : Program F) + (name : String) (args : List (SourceValue F)) (result : SourceValue F) : Prop := + checkEntry program name = .ok () ∧ ∃ heap, EvalFn program name args [] result heap + +end Aiur diff --git a/Aiur/Aiur/Semantics/CallFacts.lean b/Aiur/Aiur/Semantics/CallFacts.lean new file mode 100644 index 000000000..b2c271f48 --- /dev/null +++ b/Aiur/Aiur/Semantics/CallFacts.lean @@ -0,0 +1,43 @@ +import Aiur.Semantics.WithCalls +import Aiur.ValueFacts +import Aiur.ExceptFacts + +namespace Aiur + +variable {F : Type} {rom : ROM F} + +theorem checked_arguments (decls : Declarations) (name : String) (params : List (String × Ty)) + (args : List (Value F A)) (types : params.map Prod.snd = args.map Value.type) + (formed : ∀ arg ∈ args, arg.wellFormed decls = true) : + (do + for (param, arg) in params.zip args do + if param.2 ≠ arg.type then throw (.argumentTypeMismatch name param.2 arg.type) + if !arg.wellFormed decls then throw (.malformedValue arg.type) + pure () : Except EvalError Unit) = .ok () := by + induction params generalizing args with + | nil => cases args <;> simp_all [pure, Except.pure, bind, Except.bind] + | cons param params ih => + cases args with + | nil => simp at types + | cons arg args => + simp only [List.map_cons, List.cons.injEq] at types + simp only [List.zip_cons_cons, List.forIn_cons] + simp [types.1, formed arg (by simp), bind, Except.bind, pure, Except.pure] at ih ⊢ + exact ih args types.2 (fun v h => formed v (by simp [h])) + +/-- Structural argument types are exactly the shape check performed at a source call. -/ +theorem prepareCall_of_types [DecidableEq F] {program : Program F} {name : String} {fn : Function F} + {args : List (Value F A)} (found : program.findFunction? name = some fn) + (types : fn.params.map Prod.snd = args.map Value.type) + (formed : ∀ arg ∈ args, arg.wellFormed program.enums = true) : + prepareCall program name args = .ok ((fn.params.map Prod.fst).zip args, fn.body) := by + have arity : fn.params.length = args.length := by + simpa using congrArg List.length types + simp only [prepareCall, found, arity, bne_self_eq_false, Bool.false_eq_true, ↓reduceIte] + have checked := checked_arguments program.enums name fn.params args types formed + have combined := congrArg (fun result => result >>= fun _ => + (Except.ok ((fn.params.map Prod.fst).zip args, fn.body) : Except EvalError _)) checked + simp only [bind_assoc, pure_bind] at combined + simpa only [bind, Except.bind, pure, Except.pure] using combined + +end Aiur diff --git a/Aiur/Aiur/Semantics/CallTypes.lean b/Aiur/Aiur/Semantics/CallTypes.lean new file mode 100644 index 000000000..ddb5bc27b --- /dev/null +++ b/Aiur/Aiur/Semantics/CallTypes.lean @@ -0,0 +1,62 @@ +import Aiur.Semantics.CallFacts +import Aiur.ExceptFacts + +namespace Aiur + +variable {F : Type} {rom : ROM F} + +theorem checked_arguments_types (decls : Declarations) (name : String) (params : List (String × Ty)) + (args : List (Value F A)) (arity : params.length = args.length) + (checked : (forIn (params.zip args) PUnit.unit (fun pair _ => + if pair.1.2 ≠ pair.2.type then Except.error (.argumentTypeMismatch name pair.1.2 pair.2.type) + else if !pair.2.wellFormed decls then Except.error (.malformedValue pair.2.type) + else Except.ok (ForInStep.yield PUnit.unit)) + : Except EvalError PUnit) = .ok PUnit.unit) : + params.map Prod.snd = args.map Value.type ∧ (∀ arg ∈ args, arg.wellFormed decls = true) := by + induction params generalizing args with + | nil => + cases args <;> simp_all + | cons param params ih => + cases args with + | nil => simp at arity + | cons arg args => + have restArity : params.length = args.length := by simpa using arity + by_cases same : param.2 = arg.type + · cases formed : arg.wellFormed decls with + | false => simp [List.zip_cons_cons, List.forIn_cons, same, formed, bind, Except.bind] at checked + | true => + simp [List.zip_cons_cons, List.forIn_cons, same, formed, bind, Except.bind] at checked + obtain ⟨types, forms⟩ := ih args restArity (by simpa using checked) + exact ⟨by simp [same, types], by simpa [formed] using forms⟩ + · simp [List.zip_cons_cons, List.forIn_cons, same, bind, Except.bind] at checked + +/-- A prepared call selects a typed function body or a successfully looked-up constant. -/ +theorem prepareCall_spec [DecidableEq F] {program : Program F} {name : String} {args : List (Value F A)} + {locals : Environment F A} {body : Expr F} + (prepared : prepareCall program name args = .ok (locals, body)) : + (∃ fn, program.findFunction? name = some fn ∧ fn.params.map Prod.snd = args.map Value.type ∧ + (∀ arg ∈ args, arg.wellFormed program.enums = true) ∧ + locals = (fn.params.map Prod.fst).zip args ∧ body = fn.body) ∨ + (∃ value, program.findFunction? name = none ∧ lookupMap program name args = .ok value ∧ + locals = [] ∧ body = value.toExpr) := by + cases found : program.findFunction? name with + | none => + right + simp only [prepareCall, found] at prepared + obtain ⟨value, lookup, finished⟩ := except_bind_ok.mp prepared + obtain ⟨rfl, rfl⟩ := Prod.mk.inj (except_pure_ok.mp finished) + exact ⟨value, rfl, lookup, rfl, rfl⟩ + | some fn => + left + by_cases arity : fn.params.length = args.length + · simp only [prepareCall, found, arity, bne_self_eq_false, Bool.false_eq_true, ↓reduceIte, + pure_bind] at prepared + obtain ⟨done, checked, finished⟩ := except_bind_ok.mp prepared + cases done + obtain ⟨rfl, rfl⟩ := Prod.mk.inj (except_pure_ok.mp finished) + have spec := checked_arguments_types program.enums name fn.params args arity (by + simpa [bind, Except.bind, pure, Except.pure] using checked) + exact ⟨fn, rfl, spec.1, spec.2, rfl, rfl⟩ + · simp [prepareCall, found, arity, bind, Except.bind] at prepared + +end Aiur diff --git a/Aiur/Aiur/Semantics/NoHints.lean b/Aiur/Aiur/Semantics/NoHints.lean new file mode 100644 index 000000000..77415617c --- /dev/null +++ b/Aiur/Aiur/Semantics/NoHints.lean @@ -0,0 +1,37 @@ +import Aiur.Semantics.CallTypes + +namespace Aiur + +@[simp] theorem Constant.toExpr_noHints (value : Constant F) : value.toExpr.noHints = true := by + cases value with + | field => simp [Constant.toExpr, Expr.noHints] + | ptr _ address => exact Empty.elim address + | tuple values | construct _ _ values => + simp only [Constant.toExpr, Expr.noHints, List.map_map, List.all_map, List.all_eq_true] + exact fun value _ => Constant.toExpr_noHints value +termination_by sizeOf value + +theorem prepareCall_noHints [DecidableEq F] {program : Program F} + (safe : program.noHints = true) {name : String} {args : List (Value F A)} + {locals : Environment F A} {body : Expr F} + (prepared : prepareCall program name args = .ok (locals, body)) : body.noHints = true := by + rcases prepareCall_spec prepared with function | table + · obtain ⟨function, found, _, _, _, rfl⟩ := function + exact (by simpa [Program.noHints] using safe : ∀ f ∈ program.functions, f.body.noHints = true) + function (List.mem_of_find?_eq_some found) + · obtain ⟨value, _, _, _, rfl⟩ := table + exact value.toExpr_noHints + +theorem selectArm_noHints [DecidableEq F] {value : Value F A} + {arms : List (Pattern F × Expr F)} {bindings : Environment F A} {body : Expr F} + (safe : ∀ arm ∈ arms, arm.2.noHints = true) + (selected : selectArm value arms = some (bindings, body)) : body.noHints = true := by + induction arms with + | nil => cases selected + | cons arm arms ih => + simp only [selectArm] at selected + split at selected + · cases selected; exact safe arm (by simp) + · exact ih (fun a h => safe a (by simp [h])) selected + +end Aiur diff --git a/Aiur/Aiur/Semantics/WithCalls.lean b/Aiur/Aiur/Semantics/WithCalls.lean new file mode 100644 index 000000000..97563417e --- /dev/null +++ b/Aiur/Aiur/Semantics/WithCalls.lean @@ -0,0 +1,107 @@ +import Aiur.ROMSemantics + +namespace Aiur + +variable {F : Type} {rom : ROM F} + +/-- Interpret each function call by a supplied premise relation. -/ +abbrev CallRelation (F : Type) := String → List (Value F) → Value F → Prop + +mutual + inductive ROMEvalExprWith [Field F] [DecidableEq F] (decls : Declarations) (rom : ROM F) (calls : CallRelation F) : + Environment F → Expr F → Value F → Prop where + | literal : ROMEvalExprWith decls rom calls locals (.literal value) (.field value) + | var (lookup : locals.find? (·.1 == name) = some (name, value)) : + ROMEvalExprWith decls rom calls locals (.var name) value + | tuple (items : ROMEvalArgsWith decls rom calls locals exprs values) : + ROMEvalExprWith decls rom calls locals (.tuple exprs) (.tuple values) + | construct (items : ROMEvalArgsWith decls rom calls locals exprs values) : + ROMEvalExprWith decls rom calls locals (.construct name ctor exprs) (.construct name ctor values) + | project (value : ROMEvalExprWith decls rom calls locals expr input) + (projected : projectValue input index = .ok result) : + ROMEvalExprWith decls rom calls locals (.project expr index) result + | letValue (value : ROMEvalExprWith decls rom calls locals expr input) + (matched : pattern.bindings input = some bindings) + (body : ROMEvalExprWith decls rom calls (bindings ++ locals) rest result) : + ROMEvalExprWith decls rom calls locals (.letValue pattern expr rest) result + | store (value : ROMEvalExprWith decls rom calls locals expr input) + (cell : (address, input) ∈ rom.entries) : + ROMEvalExprWith decls rom calls locals (.store expr) (.ptr input.type address) + | load (pointer : ROMEvalExprWith decls rom calls locals expr (.ptr target address)) + (cell : (address, result) ∈ rom.entries) (typed : result.type = target) : + ROMEvalExprWith decls rom calls locals (.load expr) result + | hint (key : ROMEvalExprWith decls rom calls locals expr input) + {value : Constant F} (typed : value.WellTyped decls type) : + ROMEvalExprWith decls rom calls locals (.hint type expr channel) value.toValue + | neg (value : ROMEvalExprWith decls rom calls locals expr input) (operation : evalNeg input = .ok result) : + ROMEvalExprWith decls rom calls locals (.neg expr) result + | assertEq (left : ROMEvalExprWith decls rom calls locals lhs x) (right : ROMEvalExprWith decls rom calls locals rhs y) + (operation : evalAssertEq op x y = .ok result) : + ROMEvalExprWith decls rom calls locals (.assertEq op lhs rhs) result + | binary (left : ROMEvalExprWith decls rom calls locals lhs x) (right : ROMEvalExprWith decls rom calls locals rhs y) + (operation : evalBinOp op x y = .ok result) : + ROMEvalExprWith decls rom calls locals (.binary op lhs rhs) result + | call (arguments : ROMEvalArgsWith decls rom calls locals args values) (callee : calls name values result) : + ROMEvalExprWith decls rom calls locals (.call name args) result + | matchValue (value : ROMEvalExprWith decls rom calls locals expr input) + (selected : selectArm input arms = some (bindings, body)) + (branch : ROMEvalExprWith decls rom calls (bindings ++ locals) body result) : + ROMEvalExprWith decls rom calls locals (.matchValue expr arms) result + + inductive ROMEvalArgsWith [Field F] [DecidableEq F] (decls : Declarations) (rom : ROM F) (calls : CallRelation F) : + Environment F → List (Expr F) → List (Value F) → Prop where + | nil : ROMEvalArgsWith decls rom calls locals [] [] + | cons (head : ROMEvalExprWith decls rom calls locals expr value) + (tail : ROMEvalArgsWith decls rom calls locals exprs values) : + ROMEvalArgsWith decls rom calls locals (expr :: exprs) (value :: values) +end + +theorem ROMEvalExprWith.toEvalExpr [Field F] [DecidableEq F] {program : Program F} + {locals : Environment F} {expr : Expr F} {result : Value F} + (evaluates : ROMEvalExprWith program.enums rom (ROMEvalCall rom program) locals expr result) : + ROMEvalExpr rom program locals expr result := by + induction evaluates using ROMEvalExprWith.rec + (motive_2 := fun locals exprs values _ => ROMEvalArgs rom program locals exprs values) with + | literal => exact .literal + | var lookup => exact .var lookup + | tuple _ ih => exact .tuple ih + | construct _ ih => exact .construct ih + | project _ projected ih => exact .project ih projected + | letValue _ matched _ valueIH bodyIH => exact .letValue valueIH matched bodyIH + | store _ cell ih => exact .store ih cell + | load _ cell typed ih => exact .load ih cell typed + | hint _ typed ih => exact .hint ih typed + | neg _ operation ih => exact .neg ih operation + | assertEq _ _ operation leftIH rightIH => exact .assertEq leftIH rightIH operation + | binary _ _ operation leftIH rightIH => exact .binary leftIH rightIH operation + | call _ callee ih => exact .call ih callee + | matchValue _ selected _ valueIH bodyIH => exact .matchValue valueIH selected bodyIH + | nil => exact .nil + | cons _ _ headIH tailIH => exact .cons headIH tailIH + +theorem ROMEvalExpr.toEvalExprWith [Field F] [DecidableEq F] {program : Program F} + {locals : Environment F} {expr : Expr F} {result : Value F} + (evaluates : ROMEvalExpr rom program locals expr result) : + ROMEvalExprWith program.enums rom (ROMEvalCall rom program) locals expr result := by + induction evaluates using ROMEvalExpr.rec + (motive_2 := fun locals exprs values _ => ROMEvalArgsWith program.enums rom (ROMEvalCall rom program) locals exprs values) + (motive_3 := fun _ _ _ _ => True) with + | literal => exact .literal + | var lookup => exact .var lookup + | tuple _ ih => exact .tuple ih + | construct _ ih => exact .construct ih + | project _ projected ih => exact .project ih projected + | letValue _ matched _ valueIH bodyIH => exact .letValue valueIH matched bodyIH + | store _ cell ih => exact .store ih cell + | load _ cell typed ih => exact .load ih cell typed + | hint _ typed ih => exact .hint ih typed + | neg _ operation ih => exact .neg ih operation + | assertEq _ _ operation leftIH rightIH => exact .assertEq leftIH rightIH operation + | binary _ _ operation leftIH rightIH => exact .binary leftIH rightIH operation + | call _ callee ih _ => exact .call ih callee + | matchValue _ selected _ valueIH bodyIH => exact .matchValue valueIH selected bodyIH + | nil => exact .nil + | cons _ _ headIH tailIH => exact .cons headIH tailIH + | intro => trivial + +end Aiur diff --git a/Aiur/Aiur/SourceBundle.lean b/Aiur/Aiur/SourceBundle.lean new file mode 100644 index 000000000..b6bd4c535 --- /dev/null +++ b/Aiur/Aiur/SourceBundle.lean @@ -0,0 +1,27 @@ +module +public import Init.System.IO + +public section + +/-! Filesystem composition for applications. Imports are deliberately outside +the Aiur AST: the existing frontend receives ordinary module declarations. +The same contents are used by compilation and the application's cache key. -/ +namespace Aiur.SourceBundle + +/-- Read an ordered `.sources` manifest. Paths are relative to the manifest; +blank lines and `#` comments are ignored. -/ +def read (manifest : System.FilePath) : IO String := do + let directory := manifest.parent.getD "." + let mut result := "" + let mut seen : List String := [] + for raw in (← IO.FS.readFile manifest).splitOn "\n" do + let line := raw.trimAscii.toString + if line.isEmpty || line.startsWith "#" then continue + if seen.contains line then + throw (IO.userError s!"duplicate source '{line}' in {manifest}") + seen := line :: seen + result := result ++ s!"// Source: {line}\n" ++ (← IO.FS.readFile (directory / line)) ++ "\n" + if seen.isEmpty then throw (IO.userError s!"empty source bundle {manifest}") + return result + +end Aiur.SourceBundle diff --git a/Aiur/Aiur/StepLemmas.lean b/Aiur/Aiur/StepLemmas.lean new file mode 100644 index 000000000..ab7700f58 --- /dev/null +++ b/Aiur/Aiur/StepLemmas.lean @@ -0,0 +1,539 @@ +import Aiur.Semantics +import Aiur.Semantics.CallFacts +import Aiur.Semantics.CallTypes +import Aiur.Tables +import Aiur.Generic.SourceSemantics +import Aiur.Modules.Correctness + +/-! +# Composable Step & Inversion Lemmas for Aiur Source Semantics + +This module provides `iff` inversion and introduction lemmas for concrete +`Aiur.EvalExpr` / `Aiur.EvalArgs` / `Aiur.EvalFn`, generic +`Aiur.Generic.SourceSemantics.EvalExpr` / `EvalArgs` / `EvalFn`, and +`Aiur.Modules.Prepared.EvalFn`, together with the Hint-Invariance +(non-deterministic witness soundness) Hoare combinator. +-/ + +namespace Aiur + +variable {F : Type} [Field F] [DecidableEq F] + +/-! ## Concrete `Aiur.EvalExpr`, `Aiur.EvalArgs`, and `Aiur.EvalFn` Step Lemmas -/ + +theorem evalExpr_literal_iff {program : Program F} {locals : Environment F Nat} + {value : F} {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr program locals (.literal value) before result after ↔ + result = .field value ∧ after = before := by + constructor + · intro h; cases h; exact ⟨rfl, rfl⟩ + · rintro ⟨rfl, rfl⟩; exact .literal + +theorem evalExpr_var_iff {program : Program F} {locals : Environment F Nat} + {name : String} {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr program locals (.var name) before result after ↔ + locals.find? (·.1 == name) = some (name, result) ∧ after = before := by + constructor + · intro h; cases h with | var lookup => exact ⟨lookup, rfl⟩ + · rintro ⟨lookup, rfl⟩; exact .var lookup + +theorem evalExpr_tuple_iff {program : Program F} {locals : Environment F Nat} + {exprs : List (Expr F)} {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr program locals (.tuple exprs) before result after ↔ + ∃ values, EvalArgs program locals exprs before values after ∧ result = .tuple values := by + constructor + · intro h; cases h with | tuple items => exact ⟨_, items, rfl⟩ + · rintro ⟨values, items, rfl⟩; exact .tuple items + +theorem evalExpr_construct_iff {program : Program F} {locals : Environment F Nat} + {name : String} {ctor : String} {exprs : List (Expr F)} + {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr program locals (.construct name ctor exprs) before result after ↔ + ∃ values, EvalArgs program locals exprs before values after ∧ + result = .construct name ctor values := by + constructor + · intro h; cases h with | construct items => exact ⟨_, items, rfl⟩ + · rintro ⟨values, items, rfl⟩; exact .construct items + +theorem evalExpr_project_iff {program : Program F} {locals : Environment F Nat} + {expr : Expr F} {index : Nat} {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr program locals (.project expr index) before result after ↔ + ∃ input, EvalExpr program locals expr before input after ∧ + projectValue input index = .ok result := by + constructor + · intro h; cases h with | project value projected => exact ⟨_, value, projected⟩ + · rintro ⟨input, value, projected⟩; exact .project value projected + +theorem evalExpr_letValue_iff {program : Program F} {locals : Environment F Nat} + {pattern : Pattern F} {expr rest : Expr F} + {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr program locals (.letValue pattern expr rest) before result after ↔ + ∃ input middle bindings, + EvalExpr program locals expr before input middle ∧ + pattern.bindings input = some bindings ∧ + EvalExpr program (bindings ++ locals) rest middle result after := by + constructor + · intro h; cases h with | letValue value matched body => exact ⟨_, _, _, value, matched, body⟩ + · rintro ⟨input, middle, bindings, value, matched, body⟩ + exact .letValue value matched body + +theorem evalExpr_store_iff {program : Program F} {locals : Environment F Nat} + {expr : Expr F} {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr program locals (.store expr) before result after ↔ + ∃ input middle, + EvalExpr program locals expr before input middle ∧ + result = .ptr input.type middle.length ∧ + after = middle ++ [input] := by + constructor + · intro h; cases h with | store value => exact ⟨_, _, value, rfl, rfl⟩ + · rintro ⟨input, middle, value, rfl, rfl⟩; exact .store value + +theorem evalExpr_load_iff {program : Program F} {locals : Environment F Nat} + {expr : Expr F} {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr program locals (.load expr) before result after ↔ + ∃ input, EvalExpr program locals expr before input after ∧ + loadValue after input = .ok result := by + constructor + · intro h; cases h with | load pointer loaded => exact ⟨_, pointer, loaded⟩ + · rintro ⟨input, pointer, loaded⟩; exact .load pointer loaded + +theorem evalExpr_hint_iff {program : Program F} {locals : Environment F Nat} + {type : Ty} {expr : Expr F} {channel : String} + {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr program locals (.hint type expr channel) before result after ↔ + ∃ (input : SourceValue F) (value : Constant F), + EvalExpr program locals expr before input after ∧ + value.WellTyped program.enums type ∧ + result = value.toValue := by + constructor + · intro h + cases h + rename_i input value typed key + exact ⟨input, value, key, typed, rfl⟩ + · rintro ⟨input, value, key, typed, rfl⟩ + exact .hint key typed + +theorem evalExpr_neg_iff {program : Program F} {locals : Environment F Nat} + {expr : Expr F} {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr program locals (.neg expr) before result after ↔ + ∃ input, EvalExpr program locals expr before input after ∧ + evalNeg input = .ok result := by + constructor + · intro h; cases h with | neg value operation => exact ⟨_, value, operation⟩ + · rintro ⟨input, value, operation⟩; exact .neg value operation + +theorem evalExpr_assertEq_iff {program : Program F} {locals : Environment F Nat} + {op : Assertion} {lhs rhs : Expr F} + {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr program locals (.assertEq op lhs rhs) before result after ↔ + ∃ x middle y, + EvalExpr program locals lhs before x middle ∧ + EvalExpr program locals rhs middle y after ∧ + evalAssertEq op x y = .ok result := by + constructor + · intro h; cases h with | assertEq left right operation => exact ⟨_, _, _, left, right, operation⟩ + · rintro ⟨x, middle, y, left, right, operation⟩; exact .assertEq left right operation + +theorem evalExpr_binary_iff {program : Program F} {locals : Environment F Nat} + {op : BinOp} {lhs rhs : Expr F} + {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr program locals (.binary op lhs rhs) before result after ↔ + ∃ x middle y, + EvalExpr program locals lhs before x middle ∧ + EvalExpr program locals rhs middle y after ∧ + evalBinOp op x y = .ok result := by + constructor + · intro h; cases h with | binary left right operation => exact ⟨_, _, _, left, right, operation⟩ + · rintro ⟨x, middle, y, left, right, operation⟩; exact .binary left right operation + +theorem evalExpr_call_iff {program : Program F} {locals : Environment F Nat} + {name : String} {args : List (Expr F)} + {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr program locals (.call name args) before result after ↔ + ∃ values middle, + EvalArgs program locals args before values middle ∧ + EvalFn program name values middle result after := by + constructor + · intro h; cases h with | call arguments callee => exact ⟨_, _, arguments, callee⟩ + · rintro ⟨values, middle, arguments, callee⟩; exact .call arguments callee + +theorem evalFn_iff {program : Program F} {name : String} {args : List (SourceValue F)} + {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalFn program name args before result after ↔ + ∃ locals expr, + prepareCall program name args = .ok (locals, expr) ∧ + EvalExpr program locals expr before result after := by + constructor + · intro h; cases h with | intro prepared body => exact ⟨_, _, prepared, body⟩ + · rintro ⟨locals, expr, prepared, body⟩; exact .intro prepared body + +theorem evalExpr_call_function_iff {program : Program F} {locals : Environment F Nat} + {name : String} {fn : Function F} {args : List (Expr F)} + {before : Heap F} {result : SourceValue F} {after : Heap F} + (found : program.findFunction? name = some fn) : + EvalExpr program locals (.call name args) before result after ↔ + ∃ values middle, + EvalArgs program locals args before values middle ∧ + fn.params.map Prod.snd = values.map Value.type ∧ + (∀ arg ∈ values, arg.wellFormed program.enums = true) ∧ + EvalExpr program ((fn.params.map Prod.fst).zip values) fn.body middle result after := by + rw [evalExpr_call_iff] + constructor + · rintro ⟨values, middle, arguments, callee⟩ + rw [evalFn_iff] at callee + obtain ⟨callLocals, expr, prepared, body⟩ := callee + rcases prepareCall_spec prepared with ⟨fn', found', types, formed, rfl, rfl⟩ | ⟨_, absent, _⟩ + · rw [found] at found' + cases found' + exact ⟨values, middle, arguments, types, formed, body⟩ + · rw [found] at absent + contradiction + · rintro ⟨values, middle, arguments, types, formed, body⟩ + exact ⟨values, middle, arguments, .intro (prepareCall_of_types found types formed) body⟩ + +theorem evalExpr_call_table_iff {program : Program F} {locals : Environment F Nat} + {name : String} {args : List (Expr F)} + {before : Heap F} {result : SourceValue F} {after : Heap F} + (absent : program.findFunction? name = none) : + EvalExpr program locals (.call name args) before result after ↔ + ∃ (values : List (SourceValue F)) (value : Constant F), + EvalArgs program locals args before values after ∧ + lookupMap program name values = .ok value ∧ + result = value.toValue := by + rw [evalExpr_call_iff] + constructor + · rintro ⟨values, middle, arguments, callee⟩ + rw [evalFn_iff] at callee + obtain ⟨callLocals, expr, prepared, body⟩ := callee + rcases prepareCall_spec prepared with ⟨fn', found', _⟩ | ⟨value, _, looked, rfl, rfl⟩ + · rw [absent] at found' + contradiction + · obtain ⟨rfl, rfl⟩ := EvalExpr.constant_result value body + exact ⟨values, value, arguments, looked, rfl⟩ + · rintro ⟨values, value, arguments, looked, rfl⟩ + exact ⟨values, after, arguments, .intro (prepareCall_map absent looked) (Constant.evaluates value)⟩ + +theorem evalExpr_matchValue_iff {program : Program F} {locals : Environment F Nat} + {expr : Expr F} {arms : List (Pattern F × Expr F)} + {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr program locals (.matchValue expr arms) before result after ↔ + ∃ input middle bindings body, + EvalExpr program locals expr before input middle ∧ + selectArm input arms = some (bindings, body) ∧ + EvalExpr program (bindings ++ locals) body middle result after := by + constructor + · intro h; cases h with | matchValue value selected branch => exact ⟨_, _, _, _, value, selected, branch⟩ + · rintro ⟨input, middle, bindings, body, value, selected, branch⟩ + exact .matchValue value selected branch + +theorem evalArgs_nil_iff {program : Program F} {locals : Environment F Nat} + {before : Heap F} {values : List (SourceValue F)} {after : Heap F} : + EvalArgs program locals [] before values after ↔ + values = [] ∧ after = before := by + constructor + · intro h; cases h; exact ⟨rfl, rfl⟩ + · rintro ⟨rfl, rfl⟩; exact .nil + +theorem evalArgs_cons_iff {program : Program F} {locals : Environment F Nat} + {expr : Expr F} {exprs : List (Expr F)} + {before : Heap F} {results : List (SourceValue F)} {after : Heap F} : + EvalArgs program locals (expr :: exprs) before results after ↔ + ∃ value middle values, + EvalExpr program locals expr before value middle ∧ + EvalArgs program locals exprs middle values after ∧ + results = value :: values := by + constructor + · intro h; cases h with | cons head tail => exact ⟨_, _, _, head, tail, rfl⟩ + · rintro ⟨value, middle, values, head, tail, rfl⟩; exact .cons head tail + +/-! ## Concrete Hint-Invariance (Non-Deterministic Soundness) Combinators -/ + +/-- If a `let pattern = hint ...; rest` expression evaluates and every well-typed +hint witness `c` that matches `pattern` and satisfies the continuation `rest` +establishes `P c result after`, then some well-typed witness `c` satisfies `P`. -/ +theorem evalExpr_let_hint_invariance {program : Program F} {locals : Environment F Nat} + {pattern : Pattern F} {type : Ty} {keyExpr : Expr F} {channel : String} {rest : Expr F} + {before : Heap F} {result : SourceValue F} {after : Heap F} + {P : Constant F → SourceValue F → Heap F → Prop} + (eval : EvalExpr program locals (.letValue pattern (.hint type keyExpr channel) rest) before result after) + (hPost : ∀ (c : Constant F) (middle : Heap F) (bindings : Environment F Nat), + c.WellTyped program.enums type → + pattern.bindings c.toValue = some bindings → + EvalExpr program (bindings ++ locals) rest middle result after → + P c result after) : + ∃ c : Constant F, c.WellTyped program.enums type ∧ P c result after := by + rw [evalExpr_letValue_iff] at eval + obtain ⟨input, middle, bindings, hHint, matched, body⟩ := eval + rw [evalExpr_hint_iff] at hHint + obtain ⟨_, c, _, typed, rfl⟩ := hHint + exact ⟨c, typed, hPost c middle bindings typed matched body⟩ + +/-- Function-level Hint-Invariance combinator for concrete `EvalFn`. -/ +theorem evalFn_hint_invariance {program : Program F} {name : String} {fn : Function F} + {args : List (SourceValue F)} {before : Heap F} {result : SourceValue F} {after : Heap F} + {pattern : Pattern F} {type : Ty} {keyExpr : Expr F} {channel : String} {rest : Expr F} + {P : Constant F → SourceValue F → Heap F → Prop} + (found : program.findFunction? name = some fn) + (hBody : fn.body = .letValue pattern (.hint type keyExpr channel) rest) + (eval : EvalFn program name args before result after) + (hPost : ∀ (c : Constant F) (middle : Heap F) (bindings : Environment F Nat), + c.WellTyped program.enums type → + pattern.bindings c.toValue = some bindings → + EvalExpr program (bindings ++ (fn.params.map Prod.fst).zip args) rest middle result after → + P c result after) : + ∃ c : Constant F, c.WellTyped program.enums type ∧ P c result after := by + rw [evalFn_iff] at eval + obtain ⟨locals, expr, prepared, body⟩ := eval + rcases prepareCall_spec prepared with ⟨fn', found', _, _, rfl, rfl⟩ | ⟨_, absent, _⟩ + · rw [found] at found' + cases found' + rw [hBody] at body + exact evalExpr_let_hint_invariance body hPost + · rw [found] at absent + contradiction + +namespace Generic.SourceSemantics + +/-! ## Generic `SourceSemantics` Step Lemmas -/ + +theorem evalExpr_literal_iff {world : World F} {types : Types} {locals : Environment F Nat} + {value : F} {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr world types locals (.literal value) before result after ↔ + result = .field value ∧ after = before := by + constructor + · intro h; cases h; exact ⟨rfl, rfl⟩ + · rintro ⟨rfl, rfl⟩; exact .literal + +theorem evalExpr_var_iff {world : World F} {types : Types} {locals : Environment F Nat} + {name : String} {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr world types locals (.var name) before result after ↔ + locals.find? (·.1 == name) = some (name, result) ∧ after = before := by + constructor + · intro h; cases h with | var lookup => exact ⟨lookup, rfl⟩ + · rintro ⟨lookup, rfl⟩; exact .var lookup + +theorem evalExpr_tuple_iff {world : World F} {types : Types} {locals : Environment F Nat} + {exprs : List (Expr F)} {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr world types locals (.tuple exprs) before result after ↔ + ∃ values, EvalArgs world types locals exprs before values after ∧ result = .tuple values := by + constructor + · intro h; cases h with | tuple items => exact ⟨_, items, rfl⟩ + · rintro ⟨values, items, rfl⟩; exact .tuple items + +theorem evalExpr_array_iff {world : World F} {types : Types} {locals : Environment F Nat} + {exprs : List (Expr F)} {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr world types locals (.array exprs) before result after ↔ + ∃ values, EvalArgs world types locals exprs before values after ∧ result = .tuple values := by + constructor + · intro h; cases h with | array items => exact ⟨_, items, rfl⟩ + · rintro ⟨values, items, rfl⟩; exact .array items + +theorem evalExpr_let_iff {world : World F} {types : Types} {locals : Environment F Nat} + {pattern : Pattern F} {expr rest : Expr F} + {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr world types locals (.letValue pattern expr rest) before result after ↔ + ∃ input middle bindings, + EvalExpr world types locals expr before input middle ∧ + world.matchPattern types middle pattern input = .ok (some bindings) ∧ + EvalExpr world types (bindings ++ locals) rest middle result after := by + constructor + · intro h; cases h with | letValue value matched body => exact ⟨_, _, _, value, matched, body⟩ + · rintro ⟨input, middle, bindings, value, matched, body⟩ + exact .letValue value matched body + +theorem evalExpr_store_iff {world : World F} {types : Types} {locals : Environment F Nat} + {expr : Expr F} {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr world types locals (.store expr) before result after ↔ + ∃ input middle, + EvalExpr world types locals expr before input middle ∧ + result = .ptr input.type middle.length ∧ + after = middle ++ [input] := by + constructor + · intro h; cases h with | store value => exact ⟨_, _, value, rfl, rfl⟩ + · rintro ⟨input, middle, value, rfl, rfl⟩; exact .store value + +theorem evalExpr_load_iff {world : World F} {types : Types} {locals : Environment F Nat} + {expr : Expr F} {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr world types locals (.load expr) before result after ↔ + ∃ input, EvalExpr world types locals expr before input after ∧ + loadValue after input = .ok result := by + constructor + · intro h; cases h with | load pointer loaded => exact ⟨_, pointer, loaded⟩ + · rintro ⟨input, pointer, loaded⟩; exact .load pointer loaded + +theorem evalExpr_hint_iff {world : World F} {types : Types} {locals : Environment F Nat} + {t : Ty} {expr : Expr F} {channel : String} + {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr world types locals (.hint t expr channel) before result after ↔ + ∃ (input : SourceValue F) (value : Constant F), + EvalExpr world types locals expr before input after ∧ + world.typed (t.subst types).toCore value = true ∧ + result = value.toValue := by + constructor + · intro h + cases h + rename_i input value typed key + exact ⟨input, value, key, typed, rfl⟩ + · rintro ⟨input, value, key, typed, rfl⟩ + exact .hint key typed + +theorem evalExpr_builtin_iff {world : World F} {types : Types} {locals : Environment F Nat} + {operation : Builtin} {exprs : List (Expr F)} + {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr world types locals (.builtin operation exprs) before result after ↔ + ∃ values, + EvalArgs world types locals exprs before values after ∧ + operation.apply values = .ok result := by + constructor + · intro h; cases h with | builtin items applied => exact ⟨_, items, applied⟩ + · rintro ⟨values, items, applied⟩; exact .builtin items applied + +theorem evalArgs_nil_iff {world : World F} {types : Types} {locals : Environment F Nat} + {before : Heap F} {values : List (SourceValue F)} {after : Heap F} : + EvalArgs world types locals [] before values after ↔ + values = [] ∧ after = before := by + constructor + · intro h; cases h; exact ⟨rfl, rfl⟩ + · rintro ⟨rfl, rfl⟩; exact .nil + +theorem evalArgs_cons_iff {world : World F} {types : Types} {locals : Environment F Nat} + {expr : Expr F} {exprs : List (Expr F)} + {before : Heap F} {results : List (SourceValue F)} {after : Heap F} : + EvalArgs world types locals (expr :: exprs) before results after ↔ + ∃ value middle values, + EvalExpr world types locals expr before value middle ∧ + EvalArgs world types locals exprs middle values after ∧ + results = value :: values := by + constructor + · intro h; cases h with | cons head tail => exact ⟨_, _, _, head, tail, rfl⟩ + · rintro ⟨value, middle, values, head, tail, rfl⟩; exact .cons head tail + +theorem evalExpr_assertEq_iff {world : World F} {types : Types} {locals : Environment F Nat} + {assertion : Assertion} {lhs rhs : Expr F} + {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr world types locals (.builtin (.assertEq assertion) [lhs, rhs]) before result after ↔ + ∃ x middle y, + EvalExpr world types locals lhs before x middle ∧ + EvalExpr world types locals rhs middle y after ∧ + evalAssertEq assertion x y = .ok result := by + rw [evalExpr_builtin_iff] + constructor + · rintro ⟨values, items, applied⟩ + rw [evalArgs_cons_iff] at items + obtain ⟨x, middle, rest1, hLhs, items1, rfl⟩ := items + rw [evalArgs_cons_iff] at items1 + obtain ⟨y, middle2, rest2, hRhs, items2, rfl⟩ := items1 + rw [evalArgs_nil_iff] at items2 + obtain ⟨rfl, rfl⟩ := items2 + exact ⟨x, middle, y, hLhs, hRhs, applied⟩ + · rintro ⟨x, middle, y, hLhs, hRhs, applied⟩ + exact ⟨[x, y], .cons hLhs (.cons hRhs .nil), applied⟩ + +theorem evalExpr_binary_iff {world : World F} {types : Types} {locals : Environment F Nat} + {op : BinOp} {lhs rhs : Expr F} + {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr world types locals (.binary op lhs rhs) before result after ↔ + ∃ x middle y, + EvalExpr world types locals lhs before x middle ∧ + EvalExpr world types locals rhs middle y after ∧ + evalBinOp op x y = .ok result := by + constructor + · intro h; cases h with | binary left right operation => exact ⟨_, _, _, left, right, operation⟩ + · rintro ⟨x, middle, y, left, right, operation⟩; exact .binary left right operation + +theorem evalExpr_neg_iff {world : World F} {types : Types} {locals : Environment F Nat} + {expr : Expr F} {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr world types locals (.neg expr) before result after ↔ + ∃ input, EvalExpr world types locals expr before input after ∧ + evalNeg input = .ok result := by + constructor + · intro h; cases h with | neg value operation => exact ⟨_, value, operation⟩ + · rintro ⟨input, value, operation⟩; exact .neg value operation + +theorem evalExpr_block_iff {world : World F} {types : Types} {locals : Environment F Nat} + {label : String} {expr : Expr F} + {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr world types locals (.control (.block label) expr) before result after ↔ + EvalExpr world types locals expr before result after ∨ + EvalExit world types locals expr before (.block label) result after := by + constructor + · intro h + cases h with + | block body => exact Or.inl body + | blockExit body => exact Or.inr body + · rintro (body | body) + · exact .block body + · exact .blockExit body + +theorem evalExpr_call_iff {world : World F} {types : Types} {locals : Environment F Nat} + {name : String} {typeArgs : Option (List Ty)} {args : List (Expr F)} + {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr world types locals (.call name typeArgs args) before result after ↔ + ∃ values middle, + EvalArgs world types locals args before values middle ∧ + EvalFn world (instanceName types name typeArgs) values middle result after := by + constructor + · intro h; cases h with | call arguments callee => exact ⟨_, _, arguments, callee⟩ + · rintro ⟨values, middle, arguments, callee⟩; exact .call arguments callee + +theorem evalExpr_matchValue_iff {world : World F} {types : Types} {locals : Environment F Nat} + {expr : Expr F} {arms : List (Pattern F × Expr F)} + {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalExpr world types locals (.matchValue expr arms) before result after ↔ + ∃ input middle bindings body, + EvalExpr world types locals expr before input middle ∧ + selectArm world types middle input arms = .ok (some (bindings, body)) ∧ + EvalExpr world types (bindings ++ locals) body middle result after := by + constructor + · intro h; cases h with | matchValue value selected branch => exact ⟨_, _, _, _, value, selected, branch⟩ + · rintro ⟨input, middle, bindings, body, value, selected, branch⟩ + exact .matchValue value selected branch + +theorem evalFn_step_iff {world : World F} {name : String} {args : List (SourceValue F)} + {before : Heap F} {result : SourceValue F} {after : Heap F} : + EvalFn world name args before result after ↔ + ∃ types locals expr, + world.prepare name args = .ok (types, locals, expr) ∧ + (EvalExpr world types locals expr before result after ∨ + EvalExit world types locals expr before .function result after) := by + constructor + · intro h + cases h with + | intro prepared body => exact ⟨_, _, _, prepared, Or.inl body⟩ + | returned prepared body => exact ⟨_, _, _, prepared, Or.inr body⟩ + · rintro ⟨types, locals, expr, prepared, body | body⟩ + · exact .intro prepared body + · exact .returned prepared body + +/-- Generic `SourceSemantics` Hint-Invariance combinator. -/ +theorem evalExpr_let_hint_invariance {world : World F} {types : Types} {locals : Environment F Nat} + {pattern : Pattern F} {t : Ty} {keyExpr : Expr F} {channel : String} {rest : Expr F} + {before : Heap F} {result : SourceValue F} {after : Heap F} + {P : Constant F → SourceValue F → Heap F → Prop} + (eval : EvalExpr world types locals (.letValue pattern (.hint t keyExpr channel) rest) before result after) + (hPost : ∀ (c : Constant F) (middle : Heap F) (bindings : Environment F Nat), + world.typed (t.subst types).toCore c = true → + world.matchPattern types middle pattern c.toValue = .ok (some bindings) → + EvalExpr world types (bindings ++ locals) rest middle result after → + P c result after) : + ∃ c : Constant F, world.typed (t.subst types).toCore c = true ∧ P c result after := by + rw [evalExpr_let_iff] at eval + obtain ⟨input, middle, bindings, hHint, matched, body⟩ := eval + rw [evalExpr_hint_iff] at hHint + obtain ⟨_, c, _, typed, rfl⟩ := hHint + exact ⟨c, typed, hPost c middle bindings typed matched body⟩ + +end Generic.SourceSemantics + +namespace Modules + +theorem Prepared.evalFn_iff {program : Program F} {p : Prepared program} + {name : String} {args : List (SourceValue F)} {value : SourceValue F} {heap : Heap F} : + p.EvalFn name args value heap ↔ + ∃ entry, p.find? name = some entry ∧ + Generic.SourceSemantics.EvalFn p.environment.source.world entry.resolved.name args [] value heap := + Iff.rfl + +end Modules + +end Aiur diff --git a/Aiur/Aiur/TableChecking.lean b/Aiur/Aiur/TableChecking.lean new file mode 100644 index 000000000..b647d229c --- /dev/null +++ b/Aiur/Aiur/TableChecking.lean @@ -0,0 +1,233 @@ +import Aiur.Tables + +namespace Aiur + +variable {F : Type} + +set_option linter.unusedSimpArgs false + +private theorem duplicate_none {names seen : List String} + (checked : findDuplicate names seen = none) : names.Nodup ∧ ∀ name ∈ names, name ∉ seen := by + induction names generalizing seen with + | nil => simp + | cons name names ih => + simp only [findDuplicate] at checked + split at checked + · cases checked + · rename_i fresh + obtain ⟨distinct, separate⟩ := ih checked + refine ⟨List.nodup_cons.mpr ⟨?_, distinct⟩, ?_⟩ + · intro member + exact separate name member (by simp) + · intro value member + rcases List.mem_cons.mp member with rfl | member + · exact fresh + · intro old + exact separate value member (by simp [old]) + +theorem typecheck_tables [DecidableEq F] {program : Program F} + (checked : typecheck program = .ok ()) : + (program.functions.map (·.name) ++ program.maps.map (·.name)).Nodup ∧ + checkTables program = .ok () := by + unfold typecheck at checked + obtain ⟨_, _, rest⟩ := except_bind_ok.mp checked + cases repeated : findDuplicate (program.functions.map (·.name) ++ program.maps.map (·.name)) [] with + | some name => simp [repeated, bind, Except.bind] at rest + | none => + simp only [repeated, pure_bind] at rest + obtain ⟨done, tables, _⟩ := except_bind_ok.mp rest + cases done + exact ⟨(duplicate_none repeated).1, tables⟩ + +theorem typecheck_table [DecidableEq F] {program : Program F} + (checked : typecheck program = .ok ()) {table : Table F} (member : table ∈ program.tables) : + checkTable program table = .ok () := by + have checked := (typecheck_tables checked).2 + unfold checkTables at checked + split at checked + · cases checked + · simp only [pure_bind] at checked + obtain ⟨done, tables, _⟩ := except_bind_ok.mp checked + cases done + have combined := congrArg (fun r : Except CheckError PUnit => + r >>= fun _ => (pure () : Except CheckError Unit)) tables + exact forIn_ok (by simpa [bind, Except.bind, pure, Except.pure] using combined) table member + +theorem typecheck_map [DecidableEq F] {program : Program F} + (checked : typecheck program = .ok ()) {map : MapDecl} (member : map ∈ program.maps) : + checkMap program map = .ok () := by + have checked := (typecheck_tables checked).2 + unfold checkTables at checked + split at checked + · cases checked + · simp only [pure_bind] at checked + obtain ⟨done, _, rest⟩ := except_bind_ok.mp checked + cases done + exact forIn_ok rest map member + +theorem requirePointerFree_ok {decls : Declarations} {context : String} {type : Ty} + (checked : requirePointerFree decls context type = .ok ()) : type.pointerFree decls = true := by + cases free : type.pointerFree decls <;> simp_all [requirePointerFree] + +theorem table_pointerFree {program : Program F} {table : Table F} + (checked : checkTable program table = .ok ()) : table.rowType.pointerFree program.enums = true := by + unfold checkTable at checked + obtain ⟨_, _, rest⟩ := except_bind_ok.mp checked + obtain ⟨done, free, _⟩ := except_bind_ok.mp rest + cases done + exact requirePointerFree_ok free + +theorem map_pointerFree [DecidableEq F] {program : Program F} {map : MapDecl} + (checked : checkMap program map = .ok ()) : + (Ty.tuple (map.params.map Prod.snd)).pointerFree program.enums = true ∧ + map.result.pointerFree program.enums = true := by + unfold checkMap at checked + obtain ⟨_, _, rest⟩ := except_bind_ok.mp checked + obtain ⟨_, _, rest⟩ := except_bind_ok.mp rest + obtain ⟨done, input, rest⟩ := except_bind_ok.mp rest + cases done + obtain ⟨done, output, _⟩ := except_bind_ok.mp rest + cases done + exact ⟨requirePointerFree_ok input, requirePointerFree_ok output⟩ + +theorem table_row_typed {program : Program F} {table : Table F} + (checked : checkTable program table = .ok ()) {value : Constant F} (member : value ∈ table.rows) : + value.type = table.rowType ∧ value.wellFormed program.enums = true := by + unfold checkTable at checked + obtain ⟨_, _, rest⟩ := except_bind_ok.mp checked + obtain ⟨_, _, rows⟩ := except_bind_ok.mp rest + obtain ⟨index, bounded, same⟩ := List.mem_iff_getElem.mp member + have accepted := forIn_ok rows (value, index) (by + have mem := List.getElem_mem (l := table.rows.zipIdx) (n := index) (by simpa using bounded) + simpa [List.getElem_zipIdx, same] using mem) + by_cases typed : value.type = table.rowType + · by_cases formed : value.wellFormed program.enums = true + · exact ⟨typed, formed⟩ + · simp [checkTableRow, typed, formed, bind, Except.bind, pure, Except.pure] at accepted + · simp [checkTableRow, typed, bind, Except.bind] at accepted + +theorem checkMap_spec [DecidableEq F] {program : Program F} {map : MapDecl} + (checked : checkMap program map = .ok ()) : + ∃ inputs outputs, program.findTable? map.input = some inputs ∧ + program.findTable? map.output = some outputs ∧ + inputs.rowType = .tuple (map.params.map Prod.snd) ∧ outputs.rowType = map.result ∧ + inputs.rows.length = outputs.rows.length ∧ inputs.rows.Nodup := by + unfold checkMap at checked + obtain ⟨_, _, rest⟩ := except_bind_ok.mp checked + obtain ⟨_, _, rest⟩ := except_bind_ok.mp rest + obtain ⟨_, _, rest⟩ := except_bind_ok.mp rest + obtain ⟨_, _, rest⟩ := except_bind_ok.mp rest + cases duplicate : findDuplicate (map.params.map Prod.fst) [] with + | some name => simp [duplicate, bind, Except.bind] at rest + | none => + simp only [duplicate, pure_bind] at rest + cases hi : program.findTable? map.input with + | none => simp [hi] at rest + | some inputs => + cases ho : program.findTable? map.output with + | none => simp [hi, ho] at rest + | some outputs => + simp only [hi, ho] at rest + obtain ⟨done, inputType, rest⟩ := except_bind_ok.mp rest + obtain ⟨done, outputType, rest⟩ := except_bind_ok.mp rest + cases done + by_cases sameLength : inputs.rows.length = outputs.rows.length + · by_cases unique : inputs.rows.Nodup + · exact ⟨inputs, outputs, rfl, rfl, (requireType_ok inputType).symm, + (requireType_ok outputType).symm, sameLength, unique⟩ + · simp [sameLength, unique, bind, Except.bind] at rest + · simp [sameLength, bind, Except.bind] at rest + +theorem map_function_absent [DecidableEq F] {program : Program F} + (checked : typecheck program = .ok ()) {map : MapDecl} (member : map ∈ program.maps) : + program.findFunction? map.name = none := by + have disjoint := (List.nodup_append.mp (typecheck_tables checked).1).2.2 + apply List.find?_eq_none.mpr + intro fn present + have different : fn.name ≠ map.name := fun same => + disjoint fn.name (List.mem_map.mpr ⟨fn, present, rfl⟩) map.name + (List.mem_map.mpr ⟨map, member, rfl⟩) same + simpa using different + +theorem find_of_unique_key [DecidableEq β] (key : α → β) {rows : List α} {row : α} + (unique : (rows.map key).Nodup) (member : row ∈ rows) : + rows.find? (fun candidate => decide (key candidate = key row)) = some row := by + induction rows with + | nil => cases member + | cons head tail ih => + have distinct := List.nodup_cons.mp unique + rcases List.mem_cons.mp member with rfl | member + · simp [List.find?_cons] + · have different : key head ≠ key row := by + intro same + exact distinct.1 (List.mem_map.mpr ⟨row, member, same.symm⟩) + simp [List.find?_cons, different, ih distinct.2 member] + +theorem map_found_of_mem [DecidableEq F] {program : Program F} + (checked : typecheck program = .ok ()) {map : MapDecl} (member : map ∈ program.maps) : + program.findMap? map.name = some map := by + have unique := (List.nodup_append.mp (typecheck_tables checked).1).2.1 + have found := find_of_unique_key MapDecl.name unique member + simpa only [Program.findMap?, beq_eq_decide] using found + +theorem mapRows_unique [DecidableEq F] {program : Program F} + (checked : typecheck program = .ok ()) {map : MapDecl} (member : map ∈ program.maps) : + ((program.mapRows map).map Prod.fst).Nodup := by + obtain ⟨inputs, outputs, hi, ho, _, _, sameLength, unique⟩ := + checkMap_spec (typecheck_map checked member) + simpa only [Program.mapRows, hi, ho, List.map_fst_zip (Nat.le_of_eq sameLength)] using unique + +theorem mapRows_typed [DecidableEq F] {program : Program F} + (checked : typecheck program = .ok ()) {map : MapDecl} (member : map ∈ program.maps) + {key value : Constant F} (row : (key, value) ∈ program.mapRows map) : + key.type = .tuple (map.params.map Prod.snd) ∧ key.wellFormed program.enums = true ∧ + value.hasType program.enums map.result = true := by + obtain ⟨inputs, outputs, hi, ho, inputType, outputType, _, _⟩ := + checkMap_spec (typecheck_map checked member) + simp only [Program.mapRows, hi, ho] at row + have a := table_row_typed (typecheck_table checked (List.mem_of_find?_eq_some hi)) (List.of_mem_zip row).1 + have b := table_row_typed (typecheck_table checked (List.mem_of_find?_eq_some ho)) (List.of_mem_zip row).2 + exact ⟨a.1.trans inputType, a.2, by simp [Value.hasType, b.1, b.2, outputType]⟩ + +theorem mapEntry_mem_iff {program : Program F} {map : MapDecl} {entry : MapEntry F} : + entry ∈ program.mapEntries map ↔ (.tuple entry.args, entry.result) ∈ program.mapRows map := by + simp only [Program.mapEntries, List.mem_filterMap] + constructor + · rintro ⟨⟨key, value⟩, member, same⟩ + cases key with + | field | construct => cases same + | ptr _ address => exact Empty.elim address + | tuple args => cases same; exact member + · intro member + exact ⟨(.tuple entry.args, entry.result), member, by cases entry; rfl⟩ + +/-- On checked tables, membership and executable lookup coincide. -/ +theorem lookupMap_of_entry [DecidableEq F] {program : Program F} + (checked : typecheck program = .ok ()) {map : MapDecl} (member : map ∈ program.maps) + {entry : MapEntry F} (row : entry ∈ program.mapEntries map) : + lookupMap program map.name (entry.args.map (Constant.toValue (Address := A))) = .ok entry.result := by + have row := mapEntry_mem_iff.mp row + obtain ⟨inputType, inputFormed, outputTyped⟩ := mapRows_typed checked member row + have types : map.params.map Prod.snd = (entry.args.map (Constant.toValue (Address := A))).map Value.type := by + simp only [Value.type, Ty.tuple.injEq] at inputType + simpa only [List.map_map, Function.comp_def, Constant.toValue_type] using inputType.symm + have arity : map.params.length = entry.args.length := by + have := congrArg List.length types + simpa using this + have formed : ∀ arg ∈ entry.args.map (Constant.toValue (Address := A)), arg.wellFormed program.enums = true := by + simpa [Value.wellFormed] using inputFormed + have arguments := checked_arguments program.enums map.name map.params _ types formed + have found := find_of_unique_key Prod.fst (mapRows_unique checked member) row + have key : (Value.tuple (entry.args.map (Constant.toValue (Address := A)))).toConstant? = + some (.tuple entry.args) := by + simpa only [Constant.toValue, Value.mapAddress, show (Constant.toValue (Address := A) : Constant F → Value F A) = Value.mapAddress Empty.elim from rfl] using + (Constant.toConstant_toValue (A := A) (.tuple entry.args)) + simp only [lookupMap, map_found_of_mem checked member, List.length_map, arity, + bne_self_eq_false, Bool.false_eq_true, ↓reduceIte, pure_bind] + have combined := congrArg (fun r : Except EvalError Unit => r >>= fun _ => + (pure entry.result : Except EvalError (Constant F))) arguments + simp only [bind_assoc, pure_bind] at combined + simpa only [key, found, outputTyped, Bool.not_true, Bool.false_eq_true, ↓reduceIte, + pure_bind, bind_assoc, bind, Except.bind, pure, Except.pure] using combined + +end Aiur diff --git a/Aiur/Aiur/TableUniqueness.lean b/Aiur/Aiur/TableUniqueness.lean new file mode 100644 index 000000000..a2f30921f --- /dev/null +++ b/Aiur/Aiur/TableUniqueness.lean @@ -0,0 +1,59 @@ +import Aiur.AST + +namespace Aiur + +/-- Check duplicates in groups with the same key. The key need not be injective: +full row equality is still checked within each group. This needs only decidable +equality, even when the field has no order or hash function. -/ +def nodupByKey [DecidableEq α] [DecidableEq β] (key : α → β) : List α → Bool + | [] => true + | row :: rows => + let groups := rows.partition (fun value => decide (key value = key row)) + decide (row :: groups.1).Nodup && nodupByKey key groups.2 +termination_by rows => rows.length +decreasing_by + simp only [List.partition_eq_filter_filter] + exact Nat.lt_succ_of_le (List.length_filter_le _ _) + +theorem nodupByKey_eq [DecidableEq α] [DecidableEq β] (key : α → β) (rows : List α) : + nodupByKey key rows = decide rows.Nodup := by + cases rows with + | nil => simp [nodupByKey] + | cons row rows => + let p := fun value => decide (key value = key row) + have separate : ∀ a ∈ row :: rows.filter p, ∀ b ∈ rows.filter (fun x => !p x), a ≠ b := by + intro a ha b hb same + subst b + have no : key a ≠ key row := by simpa [p] using (List.mem_filter.mp hb).2 + rcases List.mem_cons.mp ha with rfl | ha + · exact no rfl + · exact no (by simpa [p] using (List.mem_filter.mp ha).2) + have perm := (List.filter_append_perm p rows).cons row + have equiv : (row :: rows).Nodup ↔ + (row :: rows.filter p).Nodup ∧ (rows.filter (fun x => !p x)).Nodup := by + rw [← perm.nodup_iff] + rw [← List.cons_append, List.nodup_append] + exact ⟨fun h => ⟨h.1, h.2.1⟩, fun h => ⟨h.1, h.2, separate⟩⟩ + simp only [nodupByKey, List.partition_eq_filter_filter] + rw [nodupByKey_eq key] + simp only [equiv, Bool.decide_and] + rfl +termination_by rows.length +decreasing_by exact Nat.lt_succ_of_le (List.length_filter_le _ _) + +/-- The first argument partitions Cartesian-product input tables into small +groups. It is only an optimization key; every complete row is compared. -/ +def tableRowKey : Constant α → Constant α + | .tuple (first :: _) => first + | value => value + +def tableRowsNodup [DecidableEq α] (rows : List (Constant α)) : Bool := + match rows with + | .tuple [_] :: _ => decide rows.Nodup + | _ => nodupByKey tableRowKey rows + +@[simp] theorem tableRowsNodup_eq [DecidableEq α] (rows : List (Constant α)) : + tableRowsNodup rows = decide rows.Nodup := + by unfold tableRowsNodup; split <;> simp [nodupByKey_eq] + +end Aiur diff --git a/Aiur/Aiur/Tables.lean b/Aiur/Aiur/Tables.lean new file mode 100644 index 000000000..f49a3dbe0 --- /dev/null +++ b/Aiur/Aiur/Tables.lean @@ -0,0 +1,215 @@ +import Aiur.TypecheckFacts +import Aiur.Semantics.CallTypes +import Aiur.Semantics +import Aiur.EvalCorrectness + +namespace Aiur + +set_option linter.unusedSimpArgs false + +variable {F : Type} + +theorem Program.signature_of_function {program : Program F} {name : String} {fn : Function F} + (found : program.findFunction? name = some fn) : + program.findSignature? name = some ⟨fn.params, fn.result⟩ := by + simp [Program.findSignature?, found] + +theorem Program.signature_of_map {program : Program F} {name : String} {map : MapDecl} + (absent : program.findFunction? name = none) (found : program.findMap? name = some map) : + program.findSignature? name = some ⟨map.params, map.result⟩ := by + simp [Program.findSignature?, absent, found] + +/-- Expose the typed, aligned static row selected by a successful lookup. -/ +theorem lookupMap_spec [DecidableEq F] {program : Program F} {name : String} + {args : List (Value F A)} {value : Constant F} + (looked : lookupMap program name args = .ok value) : + ∃ map key, program.findMap? name = some map ∧ + map.params.map Prod.snd = args.map Value.type ∧ + (∀ arg ∈ args, arg.wellFormed program.enums = true) ∧ + (Value.tuple args).toConstant? = some key ∧ + (key, value) ∈ program.mapRows map ∧ value.hasType program.enums map.result = true := by + cases found : program.findMap? name with + | none => simp [lookupMap, found] at looked + | some map => + by_cases arity : map.params.length = args.length + · simp only [lookupMap, found, arity, bne_self_eq_false, Bool.false_eq_true, ↓reduceIte, + pure_bind] at looked + obtain ⟨done, arguments, rest⟩ := except_bind_ok.mp looked + cases done + have checked := checked_arguments_types program.enums name map.params args arity (by + simpa [bind, Except.bind, pure, Except.pure] using arguments) + cases extracted : (Value.tuple args).toConstant? with + | none => simp [extracted] at rest + | some key => + simp only [extracted] at rest + cases row : (program.mapRows map).find? (fun row => decide (row.1 = key)) with + | none => simp [row] at rest + | some pair => + obtain ⟨input, output⟩ := pair + have same : input = key := by simpa using List.find?_some row + subst input + simp only [row] at rest + split at rest + · cases rest + · rename_i valid + have valid : output.hasType program.enums map.result = true := by simpa using valid + obtain rfl := except_pure_ok.mp rest + exact ⟨map, key, rfl, checked.1, checked.2, rfl, + List.mem_of_find?_eq_some row, valid⟩ + · simp [lookupMap, found, arity, bind, Except.bind] at looked + +theorem prepareCall_map [DecidableEq F] {program : Program F} {name : String} + {args : List (Value F A)} {value : Constant F} + (absent : program.findFunction? name = none) + (looked : lookupMap program name args = .ok value) : + prepareCall program name args = .ok ([], value.toExpr) := by + simp [prepareCall, absent, looked, bind, Except.bind, pure, Except.pure] + +theorem lookupMap_mapAddress [DecidableEq F] (program : Program F) (name : String) + (args : List (Value F A)) (encode : A → B) : + lookupMap program name (args.map (Value.mapAddress encode)) = lookupMap program name args := by + have same : (Value.tuple (args.map (Value.mapAddress encode))).toConstant? = + (Value.tuple args).toConstant? := by + simpa only [Value.mapAddress] using Value.toConstant_mapAddress (.tuple args) encode + unfold lookupMap + cases program.findMap? name with + | none => rfl + | some map => + simp only [List.length_map, List.zip_map_right, List.forIn_map, Prod.map_fst, + Prod.map_snd, id_eq, Value.type_mapAddress, Value.wellFormed_mapAddress, same] + +theorem ROMEvalArgsWith.map_iff [Field F] [DecidableEq F] {decls : Declarations} + {rom : ROM F} {calls : CallRelation F} {locals : Environment F} + (items : List α) (expression : α → Expr F) (value : α → Value F) + (each : ∀ item ∈ items, ∀ result, + ROMEvalExprWith decls rom calls locals (expression item) result ↔ result = value item) + {results : List (Value F)} : + ROMEvalArgsWith decls rom calls locals (items.map expression) results ↔ results = items.map value := by + induction items generalizing results with + | nil => + constructor + · intro evaluated; cases evaluated; rfl + · rintro rfl; exact .nil + | cons item items ih => + simp only [List.map_cons] + constructor + · intro evaluated + cases evaluated with + | cons head tail => + have h := (each item (by simp) _).mp head + have t := (ih (fun v mem => each v (by simp [mem]))).mp tail + simp [h, t] + · rintro rfl + exact .cons ((each item (by simp) _).mpr rfl) + ((ih (fun v mem => each v (by simp [mem]))).mpr rfl) + +/-- Returning a constant is independent of the ROM and every call relation. -/ +theorem ROMEvalExprWith.constant_iff [Field F] [DecidableEq F] {decls : Declarations} + {rom : ROM F} {calls : CallRelation F} {locals : Environment F} + (constant : Constant F) {result : Value F} : + ROMEvalExprWith decls rom calls locals constant.toExpr result ↔ result = constant.toValue := by + cases constant with + | field x => + simp only [Constant.toExpr, Constant.toValue, Value.mapAddress] + constructor + · intro evaluated; cases evaluated; rfl + · rintro rfl; exact .literal + | ptr _ address => exact Empty.elim address + | tuple items => + have arguments (results : List (Value F)) := ROMEvalArgsWith.map_iff + (decls := decls) (rom := rom) (calls := calls) (locals := locals) (results := results) + items Constant.toExpr Constant.toValue + (fun item _ _ => ROMEvalExprWith.constant_iff (decls := decls) item) + simp only [Constant.toExpr, Constant.toValue, Value.mapAddress] + constructor + · intro evaluated + cases evaluated with + | tuple evaluated => rw [arguments _] at evaluated; subst evaluated; rfl + · rintro rfl + exact .tuple ((arguments _).mpr rfl) + | construct name ctor items => + have arguments (results : List (Value F)) := ROMEvalArgsWith.map_iff + (decls := decls) (rom := rom) (calls := calls) (locals := locals) (results := results) + items Constant.toExpr Constant.toValue + (fun item _ _ => ROMEvalExprWith.constant_iff (decls := decls) item) + simp only [Constant.toExpr, Constant.toValue, Value.mapAddress] + constructor + · intro evaluated + cases evaluated with + | construct evaluated => rw [arguments _] at evaluated; subst evaluated; rfl + · rintro rfl + exact .construct ((arguments _).mpr rfl) +termination_by sizeOf constant + +theorem EvalArgs.constants [Field F] [DecidableEq F] {program : Program F} + {locals : Environment F Nat} {heap : Heap F} + (items : List α) (expression : α → Expr F) (value : α → SourceValue F) + (each : ∀ item ∈ items, EvalExpr program locals (expression item) heap (value item) heap) : + EvalArgs program locals (items.map expression) heap (items.map value) heap := by + induction items with + | nil => exact .nil + | cons item items ih => exact .cons (each item (by simp)) (ih (fun v h => each v (by simp [h]))) + +/-- Static results do not allocate or inspect memory. -/ +theorem Constant.evaluates [Field F] [DecidableEq F] {program : Program F} + {locals : Environment F Nat} {heap : Heap F} (constant : Constant F) : + EvalExpr program locals constant.toExpr heap constant.toValue heap := by + cases constant with + | field => simpa [Constant.toExpr, Constant.toValue, Value.mapAddress] using + (@EvalExpr.literal F _ _ program locals _ heap) + | ptr _ address => exact Empty.elim address + | tuple items => + simp only [Constant.toExpr, Constant.toValue, Value.mapAddress] + exact .tuple (EvalArgs.constants items Constant.toExpr Constant.toValue + (fun item _ => Constant.evaluates item)) + | construct name ctor items => + simp only [Constant.toExpr, Constant.toValue, Value.mapAddress] + exact .construct (EvalArgs.constants items Constant.toExpr Constant.toValue + (fun item _ => Constant.evaluates item)) +termination_by sizeOf constant + +theorem EvalArgs.constants_result [Field F] [DecidableEq F] {program : Program F} + {locals : Environment F Nat} (items : List α) (expression : α → Expr F) + (value : α → SourceValue F) + (each : ∀ item ∈ items, ∀ before result after, + EvalExpr program locals (expression item) before result after → result = value item ∧ after = before) + {before after : Heap F} {results : List (SourceValue F)} + (evaluated : EvalArgs program locals (items.map expression) before results after) : + results = items.map value ∧ after = before := by + induction items generalizing before results with + | nil => cases evaluated; exact ⟨rfl, rfl⟩ + | cons item items ih => + cases evaluated with + | cons head tail => + obtain ⟨rfl, rfl⟩ := each item (by simp) _ _ _ head + obtain ⟨rfl, rfl⟩ := ih (fun x h => each x (by simp [h])) tail + exact ⟨rfl, rfl⟩ + +/-- Constant results remain unique even when other functions contain hints. -/ +theorem EvalExpr.constant_result [Field F] [DecidableEq F] {program : Program F} + {locals : Environment F Nat} (constant : Constant F) {before after : Heap F} + {result : SourceValue F} (evaluated : EvalExpr program locals constant.toExpr before result after) : + result = constant.toValue ∧ after = before := by + cases constant with + | field x => + simp only [Constant.toExpr] at evaluated + cases evaluated + simp [Constant.toValue, Value.mapAddress] + | ptr _ address => exact Empty.elim address + | tuple items => + simp only [Constant.toExpr] at evaluated + cases evaluated with + | tuple arguments => + obtain ⟨rfl, rfl⟩ := EvalArgs.constants_result items Constant.toExpr Constant.toValue + (fun item _ _ _ _ h => EvalExpr.constant_result item h) arguments + simp [Constant.toValue, Value.mapAddress] + | construct name ctor items => + simp only [Constant.toExpr] at evaluated + cases evaluated with + | construct arguments => + obtain ⟨rfl, rfl⟩ := EvalArgs.constants_result items Constant.toExpr Constant.toValue + (fun item _ _ _ _ h => EvalExpr.constant_result item h) arguments + simp [Constant.toValue, Value.mapAddress] +termination_by sizeOf constant + +end Aiur diff --git a/Aiur/Aiur/Trace.lean b/Aiur/Aiur/Trace.lean new file mode 100644 index 000000000..1b2f57f1b --- /dev/null +++ b/Aiur/Aiur/Trace.lean @@ -0,0 +1,3 @@ +import Aiur.Trace.Export +import Aiur.Trace.FFI +import Aiur.Memory.WidthCorrectness diff --git a/Aiur/Aiur/Trace/Compile.lean b/Aiur/Aiur/Trace/Compile.lean new file mode 100644 index 000000000..6a2a567fa --- /dev/null +++ b/Aiur/Aiur/Trace/Compile.lean @@ -0,0 +1,303 @@ +import Aiur.Optimized.Program +import Aiur.Execution.Encode + +/-! Untrusted, executable witness advice. This module does not change the +certified compiler. Its companion lowering must reproduce the source chip +exactly, and its placement must reproduce the certified final chip exactly. -/ +namespace Aiur.Trace +open Optimized + +inductive Operation (F : Type) where + | assign (dest : List Witness) (values : List (Polynomial F)) + | inverse (dest : Witness) (value : Polynomial F) + | choose (dest : List Witness) (tests : List (List (Polynomial F))) + | failure (dest : List Witness) (differences : List (Polynomial F)) + | call (name : String) (args : List (Polynomial F)) (dest : List Witness) + | store (type : Ty) (values : List (Polynomial F)) (dest : Witness) + | load (type : Ty) (address : Polynomial F) (dest : List Witness) + | hint (site : Nat) (type keyType : Ty) (key : List (Polynomial F)) (dest : List Witness) (channel : String := "") + +structure Step (F : Type) where + scope : ScopeId + operation : Operation F + +namespace Compiler +abbrev Symbolic := Optimized.Compiler.Symbolic +abbrev Locals := Optimized.Compiler.Locals + +structure State (F : Type) where + core : Optimized.Compiler.State F + steps : Array (Step F) := #[] + nextHint : Nat := 0 + +abbrev Build (F : Type) := StateT (State F) (Except String) + +def core (action : Optimized.Compiler.Build F α) : Build F α := do + let state ← get + let (value, next) ← liftM (action.run state.core) + set { state with core := next } + return value + +def emit (scope : ScopeId) (operation : Operation F) : Build F Unit := + modify fun state => { state with steps := state.steps.push ⟨scope, operation⟩ } + +def capture (action : Build F α) : Build F (α × Array (Step F)) := do + let previous := (← get).steps + modify fun state => { state with steps := #[] } + let result ← action + let steps := (← get).steps + modify fun state => { state with steps := previous } + return (result, steps) + +def append (steps : Array (Step F)) : Build F Unit := + modify fun state => { state with steps := state.steps ++ steps } + +def fresh (role : Role) : Build F Witness := core (Optimized.Compiler.fresh role) +def equation (scope : ScopeId) (p : Polynomial F) : Build F Unit := + core (Optimized.Compiler.equation scope p) +def getLayout (decls : Declarations) (type : Ty) : Build F Layout := + core (Optimized.Compiler.getLayout decls type) +def freshValue (decls : Declarations) (role : Role) (type : Ty) : Build F (WireValue Witness) := + core (Optimized.Compiler.freshValue decls role type) +def splitValues (decls : Declarations) (types : List Ty) (words : List α) : + Build F (List (WireValue α)) := core (Optimized.Compiler.splitValues decls types words) +def pattern [Field F] (decls : Declarations) (pat : Pattern F) (value : Symbolic F) : + Build F (List (Polynomial F) × Locals F) := core (Optimized.Compiler.pattern decls pat value) +def equalValue (scope : ScopeId) (left right : Symbolic F) : Build F Unit := + core (Optimized.Compiler.equalValue scope left right) +def asField (value : Symbolic F) : Build F (Polynomial F) := core (Optimized.Compiler.asField value) +def destination (decls : Declarations) (scope : ScopeId) (type : Ty) + (target : Option (WireValue Witness)) : Build F (WireValue Witness) := + core (Optimized.Compiler.destination decls scope type target) + +def choice [Field F] (scope : ScopeId) (tests : List (List (Polynomial F))) : Build F (List ScopeId) := do + let first := (← get).core.roles.size + let children ← core (Optimized.Compiler.choice scope tests.length) + emit scope (.choose ((List.range tests.length).map (first + ·)) tests) + return children + +mutual + def validate [Field F] (scope : ScopeId) : Layout → List (Polynomial F) → Build F Unit + | .field, [_] | .ptr _, [_] => pure () + | .tuple layouts, words => validateList scope layouts words + | .enum _ constructors, words => do + let some (tag, payload) := Layout.enumParts constructors.length (.const 0) words + | throw "invalid enum shape" + if payload.length != Layout.payloadWidth constructors then throw "invalid enum width" + let branches ← choice scope ((List.range constructors.length).map fun i => [.sub tag (.const (i : F))]) + validateConstructors constructors branches tag payload 0 + | _, _ => throw "invalid value shape" + termination_by layout _ => sizeOf layout + + def validateList [Field F] (scope : ScopeId) : List Layout → List (Polynomial F) → Build F Unit + | [], [] => pure () + | layout :: layouts, words => do + if words.length < layout.width then throw "invalid tuple width" + validate scope layout (words.take layout.width) + validateList scope layouts (words.drop layout.width) + | [], _ :: _ => throw "invalid tuple width" + termination_by layouts _ => sizeOf layouts + + def validateConstructors [Field F] : List (String × Layout) → List ScopeId → + Polynomial F → List (Polynomial F) → Nat → Build F Unit + | [], [], _, _, _ => pure () + | (_, layout) :: rest, branch :: branches, tag, payload, index => do + equation branch (.sub tag (.const (index : F))) + validate branch layout (payload.take layout.width) + for word in payload.drop layout.width do equation branch word + validateConstructors rest branches tag payload (index + 1) + | _, _, _, _, _ => throw "constructor scope mismatch" + termination_by constructors _ _ _ _ => sizeOf constructors +end + +def validateValue [Field F] (decls : Declarations) (scope : ScopeId) (value : Symbolic F) : Build F Unit := do + validate scope (← getLayout decls value.type) value.words + +def failure [Field F] (scope : ScopeId) (conditions : List (Polynomial F)) : Build F Unit := do + let first := (← get).core.roles.size + core (Optimized.Compiler.failure scope conditions) + emit scope (.failure ((List.range conditions.length).map (first + ·)) conditions) + +/-- Execution lowers even unreachable arms. Count their hint sites so that a +later live site's ordinal still binds to the exact execution instruction PC. -/ +def hintCount : Expr F → Nat + | .literal _ | .var _ => 0 + | .tuple xs | .construct _ _ xs | .call _ xs => (xs.map hintCount).sum + | .project x _ | .load x | .store x | .neg x => hintCount x + | .hint _ key channel => hintCount key + 1 + | .binary _ a b | .assertEq _ a b | .letValue _ a b => hintCount a + hintCount b + | .matchValue x arms => hintCount x + (arms.map fun arm => hintCount arm.2).sum +termination_by expr => sizeOf expr +decreasing_by + all_goals simp_wf + all_goals + first + | omega + | have h := List.sizeOf_lt_of_mem ‹_ ∈ _›; omega + | have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + cases arm + simp_all only [Prod.mk.sizeOf_spec] + omega + +mutual + def lower [Field F] [DecidableEq F] (program : Program F) (function : String) + (locals : Locals F) (scope : ScopeId) (expr : Expr F) + (target : Option (WireValue Witness) := none) : Build F (Symbolic F) := do + let step : Build F (Symbolic F) := do + match expr with + | .literal value => pure (WireValue.field (.const value)) + | .var name => do + let some (_, value) := locals.find? (·.1 == name) | throw s!"unbound variable {name}" + pure value + | .tuple items => do + pure (.tuple (← lowerArgs program function locals scope items)) + | .construct name ctor args => do + let some definition := program.enums.findEnum? name | throw "unknown enum" + let index := definition.constructors.findIdx (·.name == ctor) + let some constructor := definition.constructors[index]? | throw "unknown constructor" + let values ← lowerArgs program function locals scope args + if values.map WireValue.type ≠ constructor.fields then throw "constructor argument types" + let layout ← getLayout program.enums (.enum name) + let payload := values.flatMap WireValue.words + let tagWidth := Layout.tagWidth definition.constructors.length + if payload.length + tagWidth > layout.width then throw "constructor payload width" + pure ⟨.enum name, Layout.enumWords definition.constructors.length (.const (index : F)) + (payload ++ List.replicate (layout.width - tagWidth - payload.length) (.const 0))⟩ + | .project operand index => do + let value ← lower program function locals scope operand + let .tuple types := value.type | throw "non-tuple projection" + let items ← splitValues program.enums types value.words + let some result := items[index]? | throw "projection out of bounds" + pure result + | .letValue pat value body => do + let value ← lower program function locals scope value + let (conditions, bindings) ← pattern program.enums pat value + for condition in conditions do equation scope condition + lower program function (bindings ++ locals) scope body target + | .store operand => do + let value ← lower program function locals scope operand + let result ← destination program.enums scope (.ptr value.type) target + let [address] := result.words | throw "pointer width" + emit scope (.store value.type value.words address) + -- Match the proved compiler: the operand already establishes validity. + core <| modify fun state => { state with cells := state.cells.push ⟨scope, .var address, value⟩ } + pure (result.map Polynomial.var) + | .load operand => do + let pointer ← lower program function locals scope operand + let ⟨.ptr type, [address]⟩ := pointer | throw "non-pointer load" + let result ← destination program.enums scope type target + let value := result.map Polynomial.var + emit scope (.load type address result.words) + -- Finite entry derivations supply validity through store provenance + -- and ROM address uniqueness; reads require only the cell lookup. + core <| modify fun state => { state with cells := state.cells.push ⟨scope, address, value⟩ } + pure value + | .neg operand => do + pure (.field (.sub (.const 0) (← asField (← lower program function locals scope operand)))) + | .hint type key channel => do + let key ← lower program function locals scope key + let site := (← get).nextHint + modify fun state => { state with nextHint := site + 1 } + if !type.pointerFree program.enums then throw "hint result contains pointers" + let result ← destination program.enums scope type target + emit scope (.hint site type key.type key.words result.words channel) + validateValue program.enums scope (result.map Polynomial.var) + pure (result.map Polynomial.var) + | .assertEq _ left right => do + let left ← lower program function locals scope left + let right ← lower program function locals scope right + if !left.type.pointerFree program.enums then throw "assertion contains pointers" + equalValue scope left right + pure (.tuple []) + | .binary op left right => do + let left ← asField (← lower program function locals scope left) + let right ← asField (← lower program function locals scope right) + match op with + | .add => pure (.field (.add left right)) + | .sub => pure (.field (.sub left right)) + | .mul => pure (.field (.mul left right)) + | .div => + match right.constantInverse? with + | some inverse => pure (.field (.mul left (.const inverse))) + | none => do + let inverse ← fresh (.auxiliary scope) + emit scope (.inverse inverse right) + equation scope (.sub (.mul right (.var inverse)) (.const 1)) + pure (.field (.mul left (.var inverse))) + | .call name args => do + let some callee := program.findSignature? name | throw s!"unknown function {name}" + let args ← lowerArgs program function locals scope args + if args.map WireValue.type ≠ callee.params.map Prod.snd then throw "call argument types" + let result ← destination program.enums scope callee.result target + emit scope (.call name (args.flatMap WireValue.words) result.words) + core <| modify fun state => { state with calls := state.calls.push ⟨scope, name, args, result⟩ } + pure (result.map Polynomial.var) + | .matchValue scrutinee arms => do + let _ ← liftM ((Circuit.Compiler.checkPatterns program.enums function arms []).mapError reprStr) + let type ← liftM ((inferType program function + (locals.map fun (name, value) => (name, value.type)) expr).mapError reprStr) + let scrutinee ← lower program function locals scope scrutinee + let result ← destination program.enums scope type target + let retained := Optimized.Compiler.retainArms program.enums arms + let tests ← retained.mapM fun (pat, _) => return (← pattern program.enums pat scrutinee).1 + let branches ← choice scope tests + lowerArms program function locals scrutinee result branches arms [] + pure (result.map Polynomial.var) + let value ← step + if let some result := target then + emit scope (.assign result.words value.words) + equalValue scope (result.map Polynomial.var) value + return result.map Polynomial.var + return value + termination_by sizeOf expr + + def lowerArgs [Field F] [DecidableEq F] (program : Program F) (function : String) + (locals : Locals F) (scope : ScopeId) (args : List (Expr F)) : Build F (List (Symbolic F)) := do + match args with + | [] => return [] + | arg :: rest => return (← lower program function locals scope arg) :: + (← lowerArgs program function locals scope rest) + termination_by sizeOf args + + def lowerArms [Field F] [DecidableEq F] (program : Program F) (function : String) + (locals : Locals F) (scrutinee : Symbolic F) (result : WireValue Witness) + (scopes : List ScopeId) (arms : List (Pattern F × Expr F)) + (previous : List (List (Polynomial F))) : Build F Unit := do + match scopes, arms with + | [], [] => pure () + | scope :: scopes, (pat, body) :: rest => do + let (conditions, bindings) ← pattern program.enums pat scrutinee + for condition in conditions do equation scope condition + for earlier in previous do failure scope earlier + let _ ← lower program function (bindings ++ locals) scope body (some result) + if pat.irrefutable program.enums then + modify fun state => { state with nextHint := state.nextHint + (rest.map fun (_, body) => hintCount body).sum } + else lowerArms program function locals scrutinee result scopes rest (previous ++ [conditions]) + | _, _ => throw "branch scope mismatch" + termination_by sizeOf arms +end + +structure Result (F : Type) where + chip : ScopedChip F + steps : Array (Step F) + hints : Nat + +def function [Field F] [DecidableEq F] (program : Program F) (config : Config) + (fn : Function F) (validateInputs : Bool := true) : Except String (Result F) := do + let build : Build F (List (WireValue Witness) × WireValue Witness) := do + let inputs ← (fn.params.map Prod.snd).mapM (freshValue program.enums .input) + let output ← freshValue program.enums .output fn.result + if validateInputs then + for value in inputs do validateValue program.enums 0 (value.map Polynomial.var) + let locals := (fn.params.map Prod.fst).zip (inputs.map (WireValue.map Polynomial.var)) + let _ ← lower program fn.name locals 0 fn.body (some output) + return (inputs, output) + let ((inputs, output), state) ← build.run { core := { config, scopes := #[⟨.const 1, []⟩] } } + let c := state.core + let chip := ScopedChip.mk fn.name inputs output c.roles c.aliases c.scopes c.equations c.calls c.cells c.choices + let original ← Optimized.Compiler.function program config fn validateInputs + unless chip == original do throw s!"trace lowering differs from certified lowering in {fn.name}" + return ⟨chip, state.steps, state.nextHint⟩ + +end Compiler +end Aiur.Trace diff --git a/Aiur/Aiur/Trace/Export.lean b/Aiur/Aiur/Trace/Export.lean new file mode 100644 index 000000000..e566670a0 --- /dev/null +++ b/Aiur/Aiur/Trace/Export.lean @@ -0,0 +1,141 @@ +import Aiur.Trace.Compile +import Aiur.Optimized.Activation +import Aiur.Optimized.Physical +import Aiur.Optimized.Grouping.Plan + +namespace Aiur.Trace +open Optimized Lean + +private def obj (fields : List (String × Json)) := Json.mkObj fields +private def js {α : Type} [ToJson α] (value : α) : Json := Lean.toJson value + +def polynomialJson (encode : F → Nat) : Polynomial F → Json + | .const x => obj [("const", js (encode x))] + | .var x => obj [("var", js x)] + | .add a b => obj [("add", js [polynomialJson encode a, polynomialJson encode b])] + | .sub a b => obj [("sub", js [polynomialJson encode a, polynomialJson encode b])] + | .mul a b => obj [("mul", js [polynomialJson encode a, polynomialJson encode b])] + +def operationJson (encode : F → Nat) (hintPCs : List Nat) : Operation F → Except String Json + | .assign dest values => return obj [("op", js "assign"), ("dest", js dest), + ("values", js (values.map (polynomialJson encode)))] + | .inverse dest value => return obj [("op", js "inverse"), ("dest", js dest), + ("value", polynomialJson encode value)] + | .choose dest tests => return obj [("op", js "choose"), ("dest", js dest), + ("tests", js (tests.map (fun xs => js (xs.map (polynomialJson encode)))))] + | .failure dest differences => return obj [("op", js "failure"), ("dest", js dest), + ("differences", js (differences.map (polynomialJson encode)))] + | .call name args dest => return obj [("op", js "call"), ("name", js name), ("dest", js dest), + ("args", js (args.map (polynomialJson encode)))] + | .store type values dest => return obj [("op", js "store"), ("type", Execution.typeJson type), + ("values", js (values.map (polynomialJson encode))), ("dest", js dest)] + | .load type address dest => return obj [("op", js "load"), ("type", Execution.typeJson type), + ("address", polynomialJson encode address), ("dest", js dest)] + | .hint site type keyType key dest channel => do + let some pc := hintPCs[site]? | throw "missing execution hint site" + return obj [("op", js "hint"), ("channel", js channel), ("instruction", js pc), ("type", Execution.typeJson type), + ("key_type", Execution.typeJson keyType), ("key", js (key.map (polynomialJson encode))), ("dest", js dest)] + +def chipJson [Field F] [DecidableEq F] (encode : F → Nat) (source : Circuit.Chip F) : Except String Json := do + let chip := Activation.compile source + unless chip.wellFormed do throw s!"invalid activated circuit {source.name}" + unless chip.stats.maxConstraintDegree ≤ max 2 source.stats.maxConstraintDegree && + chip.maxLookupGuardDegree ≤ max 1 source.maxLookupGuardDegree do + throw s!"activation increased the degree budget in {source.name}" + let poly := polynomialJson encode + return obj [("name", js chip.name), ("width", js chip.numVars), + ("activation", js source.numVars), + ("inputs", js (chip.inputs.flatMap WireValue.words)), ("output", js (chip.output.words.map poly)), + ("constraints", js (chip.constraints.map poly)), + ("sends", js (chip.sends.map fun send => obj [("channel", js send.channel), + ("args", js ((send.args.flatMap WireValue.words).map poly)), ("result", js send.result.words), + ("enable", poly send.enable)])), + ("memory", js (chip.memory.map fun cell => obj [("type", Execution.typeJson cell.value.type), + ("address", poly cell.address), ("values", js (cell.value.words.map poly)), ("enable", poly cell.enable)]))] + +/-- Replay the actual layout functions to retain their otherwise discarded +definitions and compaction columns. Equality checks fail closed if either +compiler evolves without updating its companion metadata. -/ +def functionJson [Field F] [DecidableEq F] (encode : F → Nat) (program : Program F) + (config : Config) (fn : Function F) (layout : LaidOutChip F) (representative : String) + (bytecode : Execution.Function F) (validateInputs : Bool := true) : Except String Json := do + let source ← Compiler.function program config fn validateInputs + let aliases ← resolveAliases source.chip + let propagatedScopes := if config.propagateScopes then ScopedPropagation.transform aliases else aliases + let simplified := if config.simplifyConstraints then (ConstraintElimination.run propagatedScopes).chip + else propagatedScopes + let degree ← Degree.boundState config simplified + unless degree.chip == layout.logical do throw s!"trace logical layout mismatch in {fn.name}" + let merged := (LookupMerging.run config degree.chip layout.layout).chip + let columns ← if config.propagateValues then do + let propagated := Propagation.propagate merged merged.numVars (.identity merged) + let used := propagated.chip.variables + let columns := (List.range propagated.chip.numVars).filter (used.contains ·) + unless Propagation.compact propagated.chip columns == layout.chip do + throw s!"trace final compaction mismatch in {fn.name}" + pure columns + else do + unless merged == layout.chip do throw s!"trace final layout mismatch in {fn.name}" + pure (List.range merged.numVars) + let hintPCs := bytecode.code.toList.zipIdx.filterMap fun (op, pc) => + match op with | .hint .. => some pc | _ => none + unless source.hints == hintPCs.length do throw s!"trace hint occurrence mismatch in {fn.name}" + let steps := source.steps ++ (degree.cache.reverse.map fun (scope, value, dest) => + Step.mk scope (.assign [dest] [value])).toArray + let steps ← steps.mapM fun step => do + return obj [("guard", polynomialJson encode (source.chip.activation step.scope)), + ("action", ← operationJson encode hintPCs step.operation)] + let writes := columns.zipIdx.flatMap fun (old, column) => + (layout.layout.occupants[old]?.getD []).map fun id => + let guard := match degree.chip.roles[id]? with + | some (.auxiliary scope) => source.chip.activation scope + | _ => .const 1 + obj [("column", js column), ("source", js id), ("guard", polynomialJson encode guard)] + return obj [("name", js fn.name), ("chip", js representative), + ("witnesses", js degree.chip.roles.size), ("inputs", js (source.chip.inputs.flatMap WireValue.words)), + ("output", js source.chip.output.words), ("steps", js steps), ("writes", js writes)] + +def groupJson [Field F] [DecidableEq F] (encode : F → Nat) (group : Grouping.Layout F) : Json := + let poly := polynomialJson encode + obj [("name", js group.name), ("width", js group.width), + ("activation", poly group.activation), ("constraints", js (group.constraints.map poly)), + ("receive", js (group.receive.map poly)), + ("sends", js (group.sends.map fun s => obj [("enable", poly s.enable), ("args", js (s.args.map poly))])), + ("members", js (group.members.map fun m => obj [("name", js m.name), ("columns", js m.columns), + ("selector", js m.selector), ("writes", js (m.writes.map fun (column, value) => + obj [("column", js column), ("value", poly value)]))]))] + +def exportPreparedJson [Field F] [DecidableEq F] (modulus : Nat) (encode : F → Nat) + (program : Program F) (artifact : Optimized.Artifact F) (physical : Physical.Prepared artifact) + (bytecode : Execution.Bytecode F) (groups : List (String × List String) := []) : Except String Json := do + unless program.functions.length == artifact.layouts.length && program.functions.length == bytecode.functions.length do + throw "trace program/function count mismatch" + let functions ← ((program.functions.zip artifact.layouts).zip bytecode.functions).mapM fun ((fn, layout), code) => do + unless fn.name == code.name do throw "trace bytecode function order mismatch" + let representative := physical.representative fn.name + functionJson encode program artifact.config fn layout representative code (artifact.entries.contains fn.name) + let callableNames := bytecode.functions.map (·.name) ++ bytecode.maps.map (·.name) + let id := fun name => if callableNames.contains name then pure (callableNames.idxOf name) + else throw s!"unknown grouped callable {name}" + let mut used : List String := [] + let mut packed : List (Grouping.Packed F id) := [] + for (name, names) in groups do + let names := (names.map physical.representative).dedup + let chips := physical.system.chips.filter fun c => + names.contains c.name && !used.contains c.name && !artifact.entries.contains c.name + if chips.length < 2 then continue + let group ← Grouping.compile name id chips + used := used ++ chips.map (·.name) + packed := packed ++ [⟨chips, group⟩] + let plan ← Grouping.preparePlan physical.system id packed + let layouts := plan.groups.map fun p => groupJson encode p.checked.layout + return obj [("version", js (2 : Nat)), ("modulus", js modulus), + ("functions", js functions), ("chips", js (← physical.system.chips.mapM (chipJson encode))), + ("groups", js layouts)] + +def exportJson [Field F] [DecidableEq F] (modulus : Nat) (encode : F → Nat) + (program : Program F) (artifact : Optimized.Artifact F) (bytecode : Execution.Bytecode F) + (groups : List (String × List String) := []) : Except String Json := do + exportPreparedJson modulus encode program artifact (← Physical.prepare artifact) bytecode groups + +end Aiur.Trace diff --git a/Aiur/Aiur/Trace/FFI.lean b/Aiur/Aiur/Trace/FFI.lean new file mode 100644 index 000000000..f6884cf7e --- /dev/null +++ b/Aiur/Aiur/Trace/FFI.lean @@ -0,0 +1,113 @@ +import Aiur.Trace.Export +import Aiur.Execution.FFI + +namespace Aiur.Trace +open Lean + +structure Matrix where + chip : String + width : Nat + height : Nat + unpadded_height : Nat + values : Array Nat + multiplicities : Array Nat + deriving FromJson + +structure Matrices where + matrices : Array Matrix + deriving FromJson + +structure Result where + execution : Execution.Result + trace : Matrices + +@[extern "aiur_lean_execute"] +private opaque executeJson (request : @& String) : IO String + +/-- Execute and populate using the companion plan. This path additionally runs +the Rust diagnostic checker; callers can then use the original Lean checker. -/ +def run (exported : Execution.Export (ZMod p)) [NeZero p] (plan : Json) + (entry : String) (args : Array Nat) (hints : Array (Execution.HintEntry (ZMod p)) := #[]) + (pad : Bool := true) : IO (Except String Result) := do + let request := do + let program ← exported.toJson p ZMod.val + let hints ← exported.prepareHints hints + pure <| Json.mkObj [("program", program), ("trace", plan), ("entry", toJson entry), + ("flat_args", toJson args), ("hints", Execution.hintsJson ZMod.val hints), ("pad_trace", toJson pad), + ("compare_reference", toJson true)] + match request with + | .error e => return .error e + | .ok request => + let response ← executeJson request.compress + return do + let response ← Json.parse response + if let .ok error := response.getObjValAs? String "error" then throw error + let result ← response.getObjVal? "ok" + return ⟨← fromJson? result, ← fromJson? (← result.getObjVal? "trace")⟩ + +private def readType (fuel : Nat) (value : Json) : Except String Ty := do + match fuel with + | 0 => throw "type nesting too deep" + | fuel + 1 => + match ← value.getObjValAs? String "kind" with + | "field" => pure .field + | "ptr" => return .ptr (← readType fuel (← value.getObjVal? "target")) + | "enum" => return .enum (← value.getObjValAs? String "name") + | "tuple" => return .tuple (← (← value.getObjValAs? (List Json) "items").mapM (readType fuel)) + | _ => throw "invalid wire type" + +/-- Physical rows, including the activation column and silent padding. -/ +def Result.paddedRows (result : Result) (p : Nat) [NeZero p] : Except String (List (Circuit.WeightedRow (ZMod p))) := do + let rows ← result.trace.matrices.toList.mapM fun matrix => do + unless matrix.values.size == matrix.height * matrix.width && matrix.multiplicities.size == matrix.height && + matrix.unpadded_height ≤ matrix.height && matrix.values.all (· < p) do throw "malformed trace matrix" + return (List.range matrix.height).map fun i => + Circuit.WeightedRow.mk ⟨matrix.chip, (List.range matrix.width).map fun column => + ((matrix.values[i * matrix.width + column]?.getD 0 : Nat) : ZMod p)⟩ + (Int.ofNat (matrix.multiplicities[i]?.getD 0)) + return rows.flatten + +/-- Project active rows to the certified physical circuit. Inactive rows must +provide nothing. `Activation.active_rule_iff` proves the local-rule bridge; +the Lean checker still checks the complete projected trace. -/ +def Result.rows (result : Result) (p : Nat) [NeZero p] : Except String (List (Circuit.WeightedRow (ZMod p))) := do + let rows ← result.trace.matrices.toList.mapM fun matrix => do + unless matrix.width > 0 && matrix.values.size == matrix.height * matrix.width && + matrix.multiplicities.size == matrix.height && matrix.unpadded_height ≤ matrix.height && + matrix.values.all (· < p) do throw "malformed activated trace matrix" + let rows ← (List.range matrix.height).mapM fun i => do + let active := matrix.values[i * matrix.width + matrix.width - 1]?.getD 0 + let count := matrix.multiplicities[i]?.getD 0 + if active == 0 then + unless count == 0 do throw "inactive row provides a claim" + return [] + unless active == 1 do throw "non-boolean row activation" + return [Circuit.WeightedRow.mk ⟨matrix.chip, (List.range (matrix.width - 1)).map fun column => + ((matrix.values[i * matrix.width + column]?.getD 0 : Nat) : ZMod p)⟩ (Int.ofNat count)] + return rows.flatten + return rows.flatten + +def Result.rom (result : Result) (p : Nat) [NeZero p] : Except String (WireROM (ZMod p)) := do + let types ← result.execution.memory_types.toList.mapM fun (type, width) => do + return (← readType 1024 type, width) + let entries ← result.execution.memory.toList.mapM fun entry => do + unless entry.address < p do throw "ROM address exceeds field capacity" + let words ← entry.cell.getObjValAs? (List Nat) "value" + unless words.all (· < p) do throw "noncanonical ROM value" + -- Type IDs are proof-level views, not physical memory columns. Include + -- every declared view of the width; unused invalid encodings are harmless. + return (types.filter (fun (_, width) => width == words.length)).map fun (type, _) => + ((entry.address : ZMod p), WireValue.mk type (words.map Nat.cast)) + return ⟨entries.flatten⟩ + +/-- The physical deduplication proof uses these untyped cells directly; typed +views are reconstructed only in its source-level soundness theorem. -/ +def Result.widthROM (result : Result) (p : Nat) [NeZero p] : Except String (WidthROM (ZMod p)) := do + let entries ← result.execution.memory.toList.mapM fun entry => do + unless entry.address < p do throw "ROM address exceeds field capacity" + let words ← entry.cell.getObjValAs? (List Nat) "value" + unless words.all (· < p) do throw "noncanonical ROM value" + return ((entry.address : ZMod p), words.map Nat.cast) + return ⟨entries⟩ + +end Aiur.Trace diff --git a/Aiur/Aiur/Tuple.lean b/Aiur/Aiur/Tuple.lean new file mode 100644 index 000000000..86f5d4654 --- /dev/null +++ b/Aiur/Aiur/Tuple.lean @@ -0,0 +1,11 @@ +import Aiur.Tuple.AST +import Aiur.Tuple.Typecheck +import Aiur.Tuple.Eval +import Aiur.Tuple.Semantics +import Aiur.Tuple.EvalCorrectness +import Aiur.Tuple.Circuit +import Aiur.Tuple.Correctness +import Aiur.Tuple.Completeness +import Aiur.Tuple.MemoCompleteness +import Aiur.Tuple.MemoSoundness +import Aiur.Tuple.Frontend diff --git a/Aiur/Aiur/Tuple/AST.lean b/Aiur/Aiur/Tuple/AST.lean new file mode 100644 index 000000000..ba0e12b38 --- /dev/null +++ b/Aiur/Aiur/Tuple/AST.lean @@ -0,0 +1,214 @@ +import Std + +namespace Aiur.Tuple + +/-- Tuple shape is part of the type, including empty and singleton tuples. -/ +inductive Ty where + | field + | tuple (items : List Ty) + deriving Repr, BEq + +mutual + def Ty.decEq : (left right : Ty) → Decidable (left = right) + | .field, .field => .isTrue rfl + | .tuple xs, .tuple ys => + match Ty.listDecEq xs ys with + | .isTrue h => .isTrue (congrArg Ty.tuple h) + | .isFalse h => .isFalse (fun eq => h (Ty.tuple.inj eq)) + | .field, .tuple _ => .isFalse (by intro h; cases h) + | .tuple _, .field => .isFalse (by intro h; cases h) + termination_by left _ => sizeOf left + + def Ty.listDecEq : (left right : List (Ty)) → Decidable (left = right) + | [], [] => .isTrue rfl + | [], _ :: _ => .isFalse (by intro h; cases h) + | _ :: _, [] => .isFalse (by intro h; cases h) + | x :: xs, y :: ys => match Ty.decEq x y, Ty.listDecEq xs ys with + | .isTrue h, .isTrue hs => .isTrue (by cases h; cases hs; rfl) + | .isFalse h, _ => .isFalse (fun eq => h (List.cons.inj eq).1) + | _, .isFalse h => .isFalse (fun eq => h (List.cons.inj eq).2) + termination_by left _ => sizeOf left +end + +instance : DecidableEq (Ty) := Ty.decEq + +inductive BinOp where + | add | sub | mul | div + deriving Repr, BEq, DecidableEq + +/-- A structured value whose leaves are field elements (or symbolic field expressions). -/ +inductive Value (α : Type) where + | field (value : α) + | tuple (items : List (Value α)) + deriving Repr, BEq + +mutual + def Value.decEq [DecidableEq α] : (left right : Value α) → Decidable (left = right) + | .field x, .field y => + if h : x = y then .isTrue (by cases h; rfl) + else .isFalse (fun eq => h (Value.field.inj eq)) + | .tuple xs, .tuple ys => + match Value.listDecEq xs ys with + | .isTrue h => .isTrue (congrArg Value.tuple h) + | .isFalse h => .isFalse (fun eq => h (Value.tuple.inj eq)) + | .field _, .tuple _ => .isFalse (by intro h; cases h) + | .tuple _, .field _ => .isFalse (by intro h; cases h) + termination_by left _ => sizeOf left + + def Value.listDecEq [DecidableEq α] : (left right : List (Value α)) → Decidable (left = right) + | [], [] => .isTrue rfl + | [], _ :: _ => .isFalse (by intro h; cases h) + | _ :: _, [] => .isFalse (by intro h; cases h) + | x :: xs, y :: ys => match Value.decEq x y, Value.listDecEq xs ys with + | .isTrue h, .isTrue hs => .isTrue (by cases h; cases hs; rfl) + | .isFalse h, _ => .isFalse (fun eq => h (List.cons.inj eq).1) + | _, .isFalse h => .isFalse (fun eq => h (List.cons.inj eq).2) + termination_by left _ => sizeOf left +end + +instance [DecidableEq α] : DecidableEq (Value α) := Value.decEq + +def Value.map (f : α → β) : Value α → Value β + | .field x => .field (f x) + | .tuple items => .tuple (items.map (Value.map f)) +termination_by value => sizeOf value + +def Value.type : Value α → Ty + | .field _ => .field + | .tuple items => .tuple (items.map Value.type) +termination_by value => sizeOf value + +def Value.flatten : Value α → List α + | .field x => [x] + | .tuple items => items.flatMap Value.flatten +termination_by value => sizeOf value + +instance [OfNat α n] : OfNat (Value α) n := ⟨.field (OfNat.ofNat n)⟩ + +/-- Patterns can test leaves, discard subtrees, or bind entire subtrees. -/ +inductive Pattern (α : Type) where + | literal (value : α) + | wildcard + | bind (name : String) + | tuple (items : List (Pattern α)) + deriving Repr, BEq + +mutual + def Pattern.decEq [DecidableEq α] : (left right : Pattern α) → Decidable (left = right) + | .literal x, .literal y => + if h : x = y then .isTrue (by cases h; rfl) + else .isFalse (fun eq => h (Pattern.literal.inj eq)) + | .wildcard, .wildcard => .isTrue rfl + | .bind x, .bind y => + if h : x = y then .isTrue (by cases h; rfl) + else .isFalse (fun eq => h (Pattern.bind.inj eq)) + | .tuple xs, .tuple ys => + match Pattern.listDecEq xs ys with + | .isTrue h => .isTrue (congrArg Pattern.tuple h) + | .isFalse h => .isFalse (fun eq => h (Pattern.tuple.inj eq)) + | .literal _, .wildcard => .isFalse (by intro h; cases h) + | .literal _, .bind _ => .isFalse (by intro h; cases h) + | .literal _, .tuple _ => .isFalse (by intro h; cases h) + | .wildcard, .literal _ => .isFalse (by intro h; cases h) + | .wildcard, .bind _ => .isFalse (by intro h; cases h) + | .wildcard, .tuple _ => .isFalse (by intro h; cases h) + | .bind _, .literal _ => .isFalse (by intro h; cases h) + | .bind _, .wildcard => .isFalse (by intro h; cases h) + | .bind _, .tuple _ => .isFalse (by intro h; cases h) + | .tuple _, .literal _ => .isFalse (by intro h; cases h) + | .tuple _, .wildcard => .isFalse (by intro h; cases h) + | .tuple _, .bind _ => .isFalse (by intro h; cases h) + termination_by left _ => sizeOf left + + def Pattern.listDecEq [DecidableEq α] : (left right : List (Pattern α)) → Decidable (left = right) + | [], [] => .isTrue rfl + | [], _ :: _ => .isFalse (by intro h; cases h) + | _ :: _, [] => .isFalse (by intro h; cases h) + | x :: xs, y :: ys => match Pattern.decEq x y, Pattern.listDecEq xs ys with + | .isTrue h, .isTrue hs => .isTrue (by cases h; cases hs; rfl) + | .isFalse h, _ => .isFalse (fun eq => h (List.cons.inj eq).1) + | _, .isFalse h => .isFalse (fun eq => h (List.cons.inj eq).2) + termination_by left _ => sizeOf left +end + +instance [DecidableEq α] : DecidableEq (Pattern α) := Pattern.decEq + +inductive Expr (α : Type) where + | literal (value : α) + | var (name : String) + | tuple (items : List (Expr α)) + | project (value : Expr α) (index : Nat) + | letValue (pattern : Pattern α) (value body : Expr α) + | neg (value : Expr α) + | binary (op : BinOp) (left right : Expr α) + | call (function : String) (args : List (Expr α)) + | matchValue (scrutinee : Expr α) (arms : List (Pattern α × Expr α)) + deriving Repr, BEq + +structure Function (α : Type) where + name : String + params : List (String × Ty) + result : Ty + body : Expr α + deriving Repr, BEq + +structure Program (α : Type) where + functions : List (Function α) + deriving Repr, BEq + +def Program.findFunction? (program : Program α) (name : String) : Option (Function α) := + program.functions.find? (·.name == name) + +def Pattern.map (f : α → β) : Pattern α → Pattern β + | .literal x => .literal (f x) + | .wildcard => .wildcard + | .bind name => .bind name + | .tuple items => .tuple (items.map (Pattern.map f)) +termination_by pattern => sizeOf pattern + +/-- Bindings and wildcards accept every value of their checked type. -/ +def Pattern.irrefutable : Pattern α → Bool + | .literal _ => false + | .wildcard | .bind _ => true + | .tuple items => (items.map Pattern.irrefutable).all id +termination_by pattern => sizeOf pattern + +/-- Ignore binder names when checking duplicate matching conditions. -/ +def Pattern.condition : Pattern α → Pattern α + | .bind _ => .wildcard + | .tuple items => .tuple (items.map Pattern.condition) + | pattern => pattern +termination_by pattern => sizeOf pattern + +def Expr.map (f : α → β) : Expr α → Expr β + | .literal value => .literal (f value) + | .var name => .var name + | .tuple items => .tuple (items.map (Expr.map f)) + | .project value index => .project (value.map f) index + | .letValue pattern value body => .letValue (pattern.map f) (value.map f) (body.map f) + | .neg value => .neg (value.map f) + | .binary op left right => .binary op (left.map f) (right.map f) + | .call name args => .call name (args.map (Expr.map f)) + | .matchValue scrutinee arms => + .matchValue (scrutinee.map f) (arms.map fun arm => (arm.1.map f, arm.2.map f)) +termination_by expr => sizeOf expr +decreasing_by + all_goals simp_wf + all_goals + first + | omega + | have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + first + | omega + | cases arm; simp_all only [Prod.mk.sizeOf_spec]; omega + +def Function.map (f : α → β) (function : Function α) : Function β := + { function with body := function.body.map f } + +def Program.map (f : α → β) (program : Program α) : Program β := + { functions := program.functions.map (Function.map f) } + +def Program.toField (F : Type) [NatCast F] (program : Program Nat) : Program F := + program.map (fun n => (Nat.cast n : F)) + +end Aiur.Tuple diff --git a/Aiur/Aiur/Tuple/Circuit.lean b/Aiur/Aiur/Tuple/Circuit.lean new file mode 100644 index 000000000..cb5e660b5 --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit.lean @@ -0,0 +1,6 @@ +import Aiur.Tuple.Circuit.Basic +import Aiur.Tuple.Circuit.Compile +import Aiur.Tuple.Circuit.PatternFacts +import Aiur.Tuple.Circuit.Derivation +import Aiur.Tuple.Circuit.MemoDerivation +import Aiur.Tuple.Circuit.MemoAcyclic diff --git a/Aiur/Aiur/Tuple/Circuit/Basic.lean b/Aiur/Aiur/Tuple/Circuit/Basic.lean new file mode 100644 index 000000000..7662090de --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit/Basic.lean @@ -0,0 +1,110 @@ +import Aiur.Tuple.AST +import Aiur.Scalar.Circuit.Basic + +namespace Aiur.Tuple.Circuit + +abbrev Var := Scalar.Circuit.Var +abbrev ArithExpr := Scalar.Circuit.ArithExpr +abbrev Constraint := Scalar.Circuit.Constraint +abbrev Satisfies [Field F] (constraints : List (Constraint F)) (assignment : Var → F) := + Scalar.Circuit.Satisfies constraints assignment +abbrev Row := Scalar.Circuit.Row + +namespace ArithExpr +export Aiur.Scalar.Circuit.ArithExpr (const var add sub mul) +abbrev denote [Field F] (assignment : Var → F) (expr : ArithExpr F) : F := + Scalar.Circuit.ArithExpr.denote assignment expr +abbrev inBounds (numVars : Nat) (expr : ArithExpr F) : Bool := + Scalar.Circuit.ArithExpr.inBounds numVars expr +end ArithExpr + +namespace Row +abbrev assignment [Zero F] (row : Row F) (id : Var) : F := + Scalar.Circuit.Row.assignment row id +end Row + +/-- Tuple shape and every leaf are part of a call's claim. -/ +structure Message (F : Type) where + channel : String + args : List (Value F) + result : Value F + deriving Repr, BEq, DecidableEq + +structure Send (F : Type) where + channel : String + args : List (Value (ArithExpr F)) + result : Value Var + enable : ArithExpr F + deriving Repr, BEq + +def Send.message [Field F] (send : Send F) (assignment : Var → F) : Message F := + ⟨send.channel, send.args.map (Value.map (ArithExpr.denote assignment)), send.result.map assignment⟩ + +def Send.inBounds (numVars : Nat) (send : Send F) : Bool := + send.result.flatten.all (· < numVars) && send.enable.inBounds numVars && + (send.args.flatMap Value.flatten).all (ArithExpr.inBounds numVars) + +/-- Structure lives in the interface; rows and equations contain only field elements. -/ +structure Chip (F : Type) where + name : String + inputs : List (Value Var) + output : Value Var + numVars : Nat + constraints : List (Constraint F) + sends : List (Send F) + deriving Repr, BEq + +def Chip.wellFormed (chip : Chip F) : Bool := + (chip.inputs.flatMap Value.flatten ++ chip.output.flatten).all (· < chip.numVars) && + chip.constraints.all (ArithExpr.inBounds chip.numVars) && + chip.sends.all (Send.inBounds chip.numVars) + +def Chip.ValidRow [Field F] (chip : Chip F) (row : Row F) : Prop := + chip.wellFormed = true ∧ row.values.length = chip.numVars ∧ + Satisfies chip.constraints row.assignment + +def Chip.receive [Field F] (chip : Chip F) (row : Row F) : Message F := + ⟨chip.name, chip.inputs.map (Value.map row.assignment), chip.output.map row.assignment⟩ + +def Chip.premises [Field F] [DecidableEq F] (chip : Chip F) (row : Row F) : List (Message F) := + chip.sends.filterMap fun send => + if send.enable.denote row.assignment = 1 then some (send.message row.assignment) else none + +structure System (F : Type) where + chips : List (Chip F) + deriving Repr, BEq + +def System.findChip? (system : System F) (name : String) : Option (Chip F) := + system.chips.find? (·.name == name) + +abbrev WitnessError := Scalar.Circuit.WitnessError + +def Chip.checkRow [Field F] [DecidableEq F] (chip : Chip F) (row : Row F) : + Except WitnessError (Message F × List (Message F)) := do + if !chip.wellFormed then throw (.invalidLayout chip.name) + if row.values.length != chip.numVars then + throw (.wrongRowSize chip.name chip.numVars row.values.length) + for (polynomial, index) in chip.constraints.zipIdx do + if polynomial.denote row.assignment ≠ 0 then throw (.constraintNotZero chip.name index) + return (chip.receive row, chip.premises row) + +def System.check [Field F] [DecidableEq F] (system : System F) + (entry : Message F) (rows : List (Row F)) : Except WitnessError Unit := do + let mut seen := [] + for chip in system.chips do + if chip.name ∈ seen then throw (.duplicateChip chip.name) + seen := chip.name :: seen + if !chip.wellFormed then throw (.invalidLayout chip.name) + let mut received := [] + let mut sent := [entry] + for row in rows do + let some chip := system.findChip? row.chip | throw (.unknownChip row.chip) + let (input, output) ← chip.checkRow row + received := input :: received + sent := output ++ sent + if sent.Perm received then pure () else throw .unbalancedMessages + +def System.Accepts [Field F] [DecidableEq F] (system : System F) + (entry : Message F) (rows : List (Row F)) : Prop := system.check entry rows = .ok () + +end Aiur.Tuple.Circuit diff --git a/Aiur/Aiur/Tuple/Circuit/BuildFacts.lean b/Aiur/Aiur/Tuple/Circuit/BuildFacts.lean new file mode 100644 index 000000000..c24ae06b1 --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit/BuildFacts.lean @@ -0,0 +1,161 @@ +import Aiur.Tuple.Circuit.Compile +import Aiur.Tuple.Semantics.WithCalls +import Aiur.Tuple.ValueFacts +import Aiur.Scalar.Circuit.CompileFacts + +namespace Aiur.Tuple.Circuit.Compiler + +def localsEnvironment [Field F] (locals : Locals F) (assignment : Var → F) : Environment F := + locals.map fun binding => (binding.1, binding.2.map (ArithExpr.denote assignment)) + +@[simp] theorem localsEnvironment_append [Field F] (left right : Locals F) (assignment : Var → F) : + localsEnvironment (left ++ right) assignment = + localsEnvironment left assignment ++ localsEnvironment right assignment := List.map_append + +/-- Validity of all equations and enabled calls in a simultaneous assignment. -/ +structure BuildState.Valid [Field F] (state : BuildState F) (calls : CallRelation F) + (assignment : Var → F) : Prop where + constraints : Satisfies state.constraints.toList assignment + calls : ∀ send ∈ state.sends.toList, send.enable.denote assignment = 1 → + calls send.channel (send.args.map (Value.map (ArithExpr.denote assignment))) + (send.result.map assignment) + +theorem BuildState.Valid.of_subset [Field F] {before after : BuildState F} + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid calls assignment) + (constraints : ∀ polynomial ∈ before.constraints.toList, polynomial ∈ after.constraints.toList) + (sends : ∀ send ∈ before.sends.toList, send ∈ after.sends.toList) : + before.Valid calls assignment := + ⟨fun polynomial member => valid.constraints polynomial (constraints polynomial member), + fun send member => valid.calls send (sends send member)⟩ + +theorem bind_ok {first : Build F α} {next : α → Build F β} + {before after : BuildState F} {result : β} : + (first >>= next) before = .ok (result, after) ↔ + ∃ value middle, first before = .ok (value, middle) ∧ next value middle = .ok (result, after) := by + cases run : first before with + | error error => simp [StateT.bind, bind, Except.bind, run] + | ok output => + rcases output with ⟨value, middle⟩ + simp [StateT.bind, bind, Except.bind, run] + +@[simp] theorem pure_ok {value result : α} {before after : BuildState F} : + (pure value : Build F α) before = .ok (result, after) ↔ value = result ∧ before = after := by + simp [pure, StateT.pure, Except.pure] + +@[simp] theorem lift_ok (value : α) (state : BuildState F) : + (liftM (.ok value : Except CompileError α) : Build F α) state = .ok (value, state) := rfl + +@[simp] theorem lift_error (error : CompileError) (state : BuildState F) : + (liftM (.error error : Except CompileError α) : Build F α) state = .error error := rfl + +@[simp] theorem throw_apply (error : CompileError) (state : BuildState F) : + (throw error : Build F α) state = .error error := rfl + +theorem lift_eq_ok {computation : Except CompileError α} {value : α} + {before after : BuildState F} + (compiled : (liftM computation : Build F α) before = .ok (value, after)) : + computation = .ok value ∧ before = after := by + cases computation with + | error error => simp [lift_error] at compiled + | ok result => + simp only [lift_ok, Except.ok.injEq, Prod.mk.injEq] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨rfl, rfl⟩ + +@[simp] theorem fresh_apply (state : BuildState F) : + fresh state = .ok (state.nextVar, { state with nextVar := state.nextVar + 1 }) := rfl + +@[simp] theorem constrain_apply (polynomial : ArithExpr F) (state : BuildState F) : + constrain polynomial state = + .ok ((), { state with constraints := state.constraints.push polynomial }) := rfl + +@[simp] theorem guarded_apply (enable polynomial : ArithExpr F) (state : BuildState F) : + guarded enable polynomial state = + .ok ((), { state with constraints := state.constraints.push (.mul enable polynomial) }) := rfl + +@[simp] theorem boolean_apply [Field F] (selector : ArithExpr F) (state : BuildState F) : + boolean selector state = .ok ((), { state with + constraints := state.constraints.push (.mul selector (.sub selector (.const 1))) }) := rfl + +theorem constrain_valid [Field F] {before after : BuildState F} {polynomial : ArithExpr F} + (compiled : constrain polynomial before = .ok ((), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid calls assignment) : + before.Valid calls assignment ∧ polynomial.denote assignment = 0 := by + simp only [constrain_apply, Except.ok.injEq, Prod.mk.injEq, true_and] at compiled + subst after + exact ⟨valid.of_subset (fun _ member => by simp [member]) (fun _ member => member), + valid.constraints polynomial (by simp)⟩ + +theorem fresh_valid [Field F] {before after : BuildState F} {id : Var} + (compiled : fresh before = .ok (id, after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid calls assignment) : + before.Valid calls assignment := by + simp only [fresh_apply, Except.ok.injEq, Prod.mk.injEq] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨valid.constraints, valid.calls⟩ + +theorem boolean_valid [Field F] {before after : BuildState F} {selector : ArithExpr F} + (compiled : boolean selector before = .ok ((), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid calls assignment) : + before.Valid calls assignment ∧ + (selector.denote assignment = 0 ∨ selector.denote assignment = 1) := by + obtain ⟨beforeValid, equation⟩ := constrain_valid compiled valid + exact ⟨beforeValid, Scalar.Circuit.selector_boolean equation⟩ + +theorem asField_ok {value : Symbolic F} {polynomial : ArithExpr F} + {before after : BuildState F} (compiled : asField value before = .ok (polynomial, after)) : + value = .field polynomial ∧ before = after := by + cases value with + | field value => + simp only [asField, pure_ok] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨rfl, rfl⟩ + | tuple values => simp [asField] at compiled + +mutual + theorem freshValue_spec {type : Ty} {value : Value Var} {before after : BuildState F} + (compiled : freshValue type before = .ok (value, after)) : + after.constraints = before.constraints ∧ after.sends = before.sends ∧ value.type = type := by + cases type with + | field => + simp [freshValue, StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at compiled + rcases compiled with ⟨rfl, rfl⟩ + exact ⟨rfl, rfl, by simp [Value.type]⟩ + | tuple types => + simp only [freshValue] at compiled + obtain ⟨values, middle, run, finished⟩ := bind_ok.mp compiled + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨constraints, sends, shape⟩ := freshValues_spec run + exact ⟨constraints, sends, by simp [Value.type, shape]⟩ + termination_by sizeOf type + + theorem freshValues_spec {types : List Ty} {values : List (Value Var)} + {before after : BuildState F} + (compiled : freshValues types before = .ok (values, after)) : + after.constraints = before.constraints ∧ after.sends = before.sends ∧ + values.map Value.type = types := by + cases types with + | nil => + simp only [freshValues, pure_ok] at compiled + rcases compiled with ⟨rfl, rfl⟩ + exact ⟨rfl, rfl, rfl⟩ + | cons type types => + simp only [freshValues] at compiled + obtain ⟨value, middle, head, rest⟩ := bind_ok.mp compiled + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨hc, hs, ht⟩ := freshValue_spec head + obtain ⟨tc, ts, tt⟩ := freshValues_spec tailRun + exact ⟨tc.trans hc, ts.trans hs, by simp [ht, tt]⟩ + termination_by sizeOf types +end + +theorem freshValue_valid [Field F] {type : Ty} {value : Value Var} + {before after : BuildState F} (compiled : freshValue type before = .ok (value, after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid calls assignment) : + before.Valid calls assignment := by + obtain ⟨constraints, sends, _⟩ := freshValue_spec compiled + exact valid.of_subset (fun _ member => by rwa [constraints]) + (fun _ member => by rwa [sends]) + +end Aiur.Tuple.Circuit.Compiler diff --git a/Aiur/Aiur/Tuple/Circuit/Compile.lean b/Aiur/Aiur/Tuple/Circuit/Compile.lean new file mode 100644 index 000000000..2f824eebb --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit/Compile.lean @@ -0,0 +1,225 @@ +import Aiur.Tuple.Circuit.Basic +import Aiur.Tuple.Typecheck + +namespace Aiur.Tuple.Circuit + +inductive CompileError where + | invalidProgram (error : CheckError) + | duplicatePattern (function : String) + | invalidShape + deriving Repr, BEq, DecidableEq + +namespace Compiler + +structure BuildState (F : Type) where + nextVar : Nat := 0 + constraints : Array (Constraint F) := #[] + sends : Array (Send F) := #[] + +abbrev Build (F : Type) := StateT (BuildState F) (Except CompileError) +abbrev Symbolic (F : Type) := Value (ArithExpr F) +abbrev Locals (F : Type) := List (String × Symbolic F) + +def fresh : Build F Var := do + let state ← get + set { state with nextVar := state.nextVar + 1 } + return state.nextVar + +def constrain (polynomial : ArithExpr F) : Build F Unit := + modify fun state => { state with constraints := state.constraints.push polynomial } + +def guarded (enable polynomial : ArithExpr F) : Build F Unit := constrain (.mul enable polynomial) + +def boolean [Field F] (selector : ArithExpr F) : Build F Unit := + constrain (.mul selector (.sub selector (.const 1))) + +mutual + def freshValue (type : Ty) : Build F (Value Var) := do + match type with + | .field => return .field (← fresh) + | .tuple types => return .tuple (← freshValues types) + termination_by sizeOf type + + def freshValues (types : List Ty) : Build F (List (Value Var)) := do + match types with + | [] => return [] + | type :: rest => return (← freshValue type) :: (← freshValues rest) + termination_by sizeOf types +end + +def checkPatterns [DecidableEq F] (function : String) : + List (Pattern F × Expr F) → List (Pattern F) → Except CompileError Unit + | [], _ => pure () + | (pattern, _) :: rest, seen => do + if seen.any (fun other => decide (pattern.condition = other)) then + throw (.duplicatePattern function) + if pattern.irrefutable then return () + checkPatterns function rest (pattern.condition :: seen) + +/-- A zero test is exact in every field; its inverse is a witness, never division in a constraint. -/ +def equalIndicator [Field F] (difference : ArithExpr F) : Build F (ArithExpr F) := do + let equal := ArithExpr.var (← fresh) + let inverse := ArithExpr.var (← fresh) + boolean equal + constrain (.mul difference equal) + constrain (.sub (.mul difference inverse) (.sub (.const 1) equal)) + return equal + +mutual + /-- A pattern's indicator and bindings, including nested conjunctions of leaf tests. -/ + def lowerPattern [Field F] (pattern : Pattern F) (value : Symbolic F) : + Build F (ArithExpr F × Locals F) := do + match pattern, value with + | .wildcard, _ => return (.const 1, []) + | .bind name, value => return (.const 1, [(name, value)]) + | .literal literal, .field value => + return (← equalIndicator (.sub value (.const literal)), []) + | .tuple patterns, .tuple values => lowerPatterns patterns values + | _, _ => throw .invalidShape + termination_by sizeOf pattern + + def lowerPatterns [Field F] (patterns : List (Pattern F)) (values : List (Symbolic F)) : + Build F (ArithExpr F × Locals F) := do + match patterns, values with + | [], [] => return (.const 1, []) + | pattern :: patterns, value :: values => + let (test, bindings) ← lowerPattern pattern value + let (tests, rest) ← lowerPatterns patterns values + return (.mul test tests, bindings ++ rest) + | _, _ => throw .invalidShape + termination_by sizeOf patterns +end + +mutual + def constrainValue (enable : ArithExpr F) (left right : Symbolic F) : Build F Unit := do + match left, right with + | .field left, .field right => guarded enable (.sub left right) + | .tuple left, .tuple right => constrainValues enable left right + | _, _ => throw .invalidShape + termination_by sizeOf left + + def constrainValues (enable : ArithExpr F) (left right : List (Symbolic F)) : Build F Unit := do + match left, right with + | [], [] => return () + | left :: ls, right :: rs => + constrainValue enable left right + constrainValues enable ls rs + | _, _ => throw .invalidShape + termination_by sizeOf left +end + +def asField : Symbolic F → Build F (ArithExpr F) + | .field value => pure value + | .tuple _ => throw .invalidShape + +def excludePairs (selectors : List (ArithExpr F)) : Build F Unit := do + match selectors with + | [] => return () + | selector :: rest => + for other in rest do constrain (.mul selector other) + excludePairs rest + +mutual + def lowerExpr [Field F] [DecidableEq F] (program : Program F) (function : String) + (locals : Locals F) (enable : ArithExpr F) (expr : Expr F) : Build F (Symbolic F) := do + match expr with + | .literal value => return .field (.const value) + | .var name => + let some (_, value) := locals.find? (·.1 == name) + | throw (.invalidProgram (.unboundVariable function name)) + return value + | .tuple items => return .tuple (← lowerArgs program function locals enable items) + | .project value index => + let .tuple items ← lowerExpr program function locals enable value | throw .invalidShape + let some value := items[index]? | throw .invalidShape + return value + | .letValue pattern value body => + let value ← lowerExpr program function locals enable value + let (test, bindings) ← lowerPattern pattern value + guarded enable (.sub test (.const 1)) + lowerExpr program function (bindings ++ locals) enable body + | .neg value => + return .field (.sub (.const 0) (← asField (← lowerExpr program function locals enable value))) + | .binary op left right => + let left ← asField (← lowerExpr program function locals enable left) + let right ← asField (← lowerExpr program function locals enable right) + match op with + | .add => return .field (.add left right) + | .sub => return .field (.sub left right) + | .mul => return .field (.mul left right) + | .div => + let inverse ← fresh + guarded enable (.sub (.mul right (.var inverse)) (.const 1)) + return .field (.mul left (.var inverse)) + | .call name args => + let some callee := program.findFunction? name + | throw (.invalidProgram (.unknownFunction function name)) + let args ← lowerArgs program function locals enable args + let result ← freshValue callee.result + boolean enable + modify fun state => { state with sends := state.sends.push ⟨name, args, result, enable⟩ } + return result.map ArithExpr.var + | .matchValue scrutinee arms => + liftM (checkPatterns function arms []) + let type ← liftM ((inferType program function + (locals.map fun (name, value) => (name, value.type)) expr).mapError CompileError.invalidProgram) + let scrutinee ← lowerExpr program function locals enable scrutinee + let result ← freshValue type + let selectors ← lowerArms program function locals scrutinee + (result.map ArithExpr.var) enable arms + excludePairs selectors + constrain (.sub (selectors.foldl ArithExpr.add (.const 0)) enable) + return result.map ArithExpr.var + termination_by sizeOf expr + + def lowerArgs [Field F] [DecidableEq F] (program : Program F) (function : String) + (locals : Locals F) (enable : ArithExpr F) (args : List (Expr F)) : + Build F (List (Symbolic F)) := do + match args with + | [] => return [] + | arg :: rest => + return (← lowerExpr program function locals enable arg) :: + (← lowerArgs program function locals enable rest) + termination_by sizeOf args + + def lowerArms [Field F] [DecidableEq F] (program : Program F) (function : String) + (locals : Locals F) (scrutinee result : Symbolic F) (remaining : ArithExpr F) + (arms : List (Pattern F × Expr F)) : Build F (List (ArithExpr F)) := do + match arms with + | [] => return [] + | (pattern, body) :: rest => + let (test, bindings) ← lowerPattern pattern scrutinee + let selector := ArithExpr.var (← fresh) + boolean selector + constrain (.sub selector (.mul remaining test)) + let body ← lowerExpr program function (bindings ++ locals) selector body + constrainValue selector result body + if pattern.irrefutable then return [selector] + let rest ← lowerArms program function locals scrutinee result + (.mul remaining (.sub (.const 1) test)) rest + return selector :: rest + termination_by sizeOf arms +end + +def lowerFunction [Field F] [DecidableEq F] (program : Program F) (fn : Function F) : + Except CompileError (Chip F) := do + let build : Build F (List (Value Var) × Value Var) := do + let inputs ← freshValues (fn.params.map Prod.snd) + let output ← freshValue fn.result + let locals := (fn.params.map Prod.fst).zip (inputs.map (Value.map ArithExpr.var)) + let body ← lowerExpr program fn.name locals (.const 1) fn.body + constrainValue (.const 1) (output.map ArithExpr.var) body + return (inputs, output) + let ((inputs, output), state) ← build.run {} + return ⟨fn.name, inputs, output, state.nextVar, state.constraints.toList, state.sends.toList⟩ + +end Compiler + +/-- One chip per function, with one fresh variable for each field leaf of a call result. -/ +def compile [Field F] [DecidableEq F] (program : Program F) : Except CompileError (System F) := do + match typecheck program with + | .error error => throw (.invalidProgram error) + | .ok () => pure () + return ⟨← program.functions.mapM (Compiler.lowerFunction program)⟩ + +end Aiur.Tuple.Circuit diff --git a/Aiur/Aiur/Tuple/Circuit/CompileFacts.lean b/Aiur/Aiur/Tuple/Circuit/CompileFacts.lean new file mode 100644 index 000000000..7d6b95964 --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit/CompileFacts.lean @@ -0,0 +1,120 @@ +import Aiur.Tuple.Circuit.BuildFacts + +namespace Aiur.Tuple.Circuit + +private theorem except_bind_ok {first : Except ε α} {next : α → Except ε β} {result : β} : + (first >>= next) = .ok result ↔ ∃ value, first = .ok value ∧ next value = .ok result := by + cases first <;> simp [bind, Except.bind] + +/-- Expose the actual stages of compiling a function, without changing the compiler. -/ +theorem Compiler.lowerFunction_stages [Field F] [DecidableEq F] + {program : Program F} {fn : Function F} {chip : Chip F} + (compiled : Compiler.lowerFunction program fn = .ok chip) : + ∃ inputs output s₁ s₂ body s₃ s₄, + Compiler.freshValues (fn.params.map Prod.snd) {} = .ok (inputs, s₁) ∧ + Compiler.freshValue fn.result s₁ = .ok (output, s₂) ∧ + Compiler.lowerExpr program fn.name + ((fn.params.map Prod.fst).zip (inputs.map (Value.map ArithExpr.var))) + (.const 1) fn.body s₂ = .ok (body, s₃) ∧ + Compiler.constrainValue (.const 1) (output.map ArithExpr.var) body s₃ = .ok ((), s₄) ∧ + chip = ⟨fn.name, inputs, output, s₄.nextVar, s₄.constraints.toList, s₄.sends.toList⟩ := by + unfold Compiler.lowerFunction at compiled + obtain ⟨⟨⟨inputs, output⟩, state⟩, run, finished⟩ := except_bind_ok.mp compiled + simp only [pure, Except.pure, Except.ok.injEq] at finished + subst chip + obtain ⟨inputs, s₁, inputsRun, rest⟩ := Compiler.bind_ok.mp run + obtain ⟨output, s₂, outputRun, rest⟩ := Compiler.bind_ok.mp rest + obtain ⟨body, s₃, bodyRun, rest⟩ := Compiler.bind_ok.mp rest + obtain ⟨finished, s₄, constraintRun, rest⟩ := Compiler.bind_ok.mp rest + cases finished + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := Compiler.pure_ok.mp rest + exact ⟨inputs, output, s₁, s₂, body, s₃, s₄, inputsRun, outputRun, bodyRun, constraintRun, rfl⟩ + +theorem Compiler.lowerFunction_interface [Field F] [DecidableEq F] + {program : Program F} {fn : Function F} {chip : Chip F} + (compiled : Compiler.lowerFunction program fn = .ok chip) : + chip.name = fn.name ∧ chip.inputs.map Value.type = fn.params.map Prod.snd ∧ + chip.output.type = fn.result := by + obtain ⟨_, _, _, _, _, _, _, inputsRun, outputRun, _, _, rfl⟩ := lowerFunction_stages compiled + exact ⟨rfl, (freshValues_spec inputsRun).2.2, (freshValue_spec outputRun).2.2⟩ + +private theorem forall₂_of_mapM_ok {f : α → Except ε β} {xs : List α} {ys : List β} + (mapped : xs.mapM f = .ok ys) : List.Forall₂ (fun x y => f x = .ok y) xs ys := by + induction xs generalizing ys with + | nil => simp only [List.mapM_nil] at mapped; cases mapped; exact .nil + | cons x xs ih => + cases hx : f x with + | error error => simp [hx] at mapped; cases mapped + | ok y => + cases hxs : xs.mapM f with + | error error => simp [hx, hxs] at mapped; cases mapped + | ok rest => + simp [hx, hxs] at mapped + cases mapped + exact .cons hx (ih hxs) + +theorem compile_functions [Field F] [DecidableEq F] {program : Program F} {system : System F} + (compiled : compile program = .ok system) : + List.Forall₂ (fun fn chip => Compiler.lowerFunction program fn = .ok chip) + program.functions system.chips := by + unfold compile at compiled + cases checked : typecheck program with + | error error => simp [checked] at compiled; cases compiled + | ok checkedUnit => + cases checkedUnit + cases mapped : program.functions.mapM (Compiler.lowerFunction program) with + | error error => simp [checked, mapped] at compiled + | ok chips => + simp [checked, mapped] at compiled + subst system + exact forall₂_of_mapM_ok mapped + +private theorem lookup_functions [Field F] [DecidableEq F] {program : Program F} + {fns : List (Function F)} {chips : List (Chip F)} + (compiled : List.Forall₂ (fun fn chip => Compiler.lowerFunction program fn = .ok chip) fns chips) + (name : String) : + Option.Rel (fun fn chip => Compiler.lowerFunction program fn = .ok chip) + (fns.find? (·.name == name)) (chips.find? (·.name == name)) := by + induction compiled with + | nil => exact .none + | cons head _ ih => + have names := (Compiler.lowerFunction_interface head).1 + simp only [List.find?_cons, names] + split + · exact .some head + · exact ih + +theorem compile_find_function [Field F] [DecidableEq F] + {program : Program F} {system : System F} (compiled : compile program = .ok system) + {name : String} {fn : Function F} (found : program.findFunction? name = some fn) : + ∃ chip, system.findChip? name = some chip ∧ Compiler.lowerFunction program fn = .ok chip := by + have related := lookup_functions (compile_functions compiled) name + change Option.Rel _ (program.findFunction? name) (system.findChip? name) at related + rw [found] at related + cases target : system.findChip? name with + | none => rw [target] at related; cases related + | some chip => + rw [target] at related + cases related with + | some lowered => exact ⟨chip, rfl, lowered⟩ + +theorem compile_find_chip [Field F] [DecidableEq F] + {program : Program F} {system : System F} (compiled : compile program = .ok system) + {name : String} {chip : Chip F} (found : system.findChip? name = some chip) : + ∃ fn, program.findFunction? name = some fn ∧ Compiler.lowerFunction program fn = .ok chip := by + have related := lookup_functions (compile_functions compiled) name + change Option.Rel _ (program.findFunction? name) (system.findChip? name) at related + rw [found] at related + cases source : program.findFunction? name with + | none => rw [source] at related; cases related + | some fn => + rw [source] at related + cases related with + | some lowered => exact ⟨fn, rfl, lowered⟩ + +theorem findFunction_name {program : Program F} {name : String} {fn : Function F} + (found : program.findFunction? name = some fn) : fn.name = name := by + have := List.find?_some found + simpa using this + +end Aiur.Tuple.Circuit diff --git a/Aiur/Aiur/Tuple/Circuit/Derivation.lean b/Aiur/Aiur/Tuple/Circuit/Derivation.lean new file mode 100644 index 000000000..de4be40ae --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit/Derivation.lean @@ -0,0 +1,86 @@ +import Aiur.Tuple.Circuit.Basic + +namespace Aiur.Tuple.Circuit + +mutual + /-- + A closed, finite derivation of a message. Local validity is a side condition; + all enabled calls must be discharged by child derivations. There is no assumption rule. + -/ + inductive Derivation [Field F] [DecidableEq F] (system : System F) : Message F → Type where + | node (chip : Chip F) (row : Row F) + (lookup : system.findChip? row.chip = some chip) + (valid : chip.ValidRow row) + (children : Derivations system (chip.premises row)) : + Derivation system (chip.receive row) + + /-- A finite list of proofs indexed by its list of premise occurrences. -/ + inductive Derivations [Field F] [DecidableEq F] (system : System F) : List (Message F) → Type where + | nil : Derivations system [] + | cons (head : Derivation system message) (tail : Derivations system messages) : + Derivations system (message :: messages) +end + +/-- Derivability asserts the existence of a closed derivation tree. -/ +def Derives [Field F] [DecidableEq F] (system : System F) (message : Message F) : Prop := + Nonempty (Derivation system message) + +/-- The circuit relation for one function's arguments and claimed result. -/ +def CircuitEvaluates [Field F] [DecidableEq F] (system : System F) + (function : String) (args : List (Value F)) (result : Value F) : Prop := + Derives system ⟨function, args, result⟩ + +/-- Assemble a forest from proofs of every premise, retaining repeated occurrences. -/ +theorem derivations_nonempty_iff [Field F] [DecidableEq F] {system : System F} + {messages : List (Message F)} : + Nonempty (Derivations system messages) ↔ ∀ message ∈ messages, Derives system message := by + induction messages with + | nil => + constructor + · intros; contradiction + · intro _; exact ⟨.nil⟩ + | cons message messages ih => + constructor + · rintro ⟨children⟩ + cases children with + | cons head tail => + intro next member + rcases List.mem_cons.mp member with same | member + · subst next; exact ⟨head⟩ + · exact ih.mp ⟨tail⟩ next member + · intro premises + obtain ⟨head⟩ := premises message (by simp) + obtain ⟨tail⟩ := ih.mpr (fun next member => premises next (by simp [member])) + exact ⟨.cons head tail⟩ + +mutual + /-- Flatten a tree to rows, retaining separate occurrences of identical calls. -/ + def Derivation.rows [Field F] [DecidableEq F] {system : System F} {message : Message F} : + Derivation system message → List (Row F) + | .node _ row _ _ children => row :: children.rows + + def Derivations.rows [Field F] [DecidableEq F] {system : System F} {messages : List (Message F)} : + Derivations system messages → List (Row F) + | .nil => [] + | .cons head tail => head.rows ++ tail.rows +end + +theorem Derivation.rows_ne_nil [Field F] [DecidableEq F] {system : System F} + {message : Message F} (derivation : Derivation system message) : derivation.rows ≠ [] := by + cases derivation + simp [Derivation.rows] + +/-- If every valid rule requires a call, no finite closed derivation can start. -/ +theorem not_derives_of_no_leaves [Field F] [DecidableEq F] {system : System F} + (requiresCall : ∀ chip row, system.findChip? row.chip = some chip → + chip.ValidRow row → chip.premises row ≠ []) (message : Message F) : + ¬ Derives system message := by + rintro ⟨derivation⟩ + induction derivation using Derivation.rec + (motive_2 := fun messages _ => messages ≠ [] → False) with + | node chip row lookup valid _ childrenIH => + exact childrenIH (requiresCall chip row lookup valid) + | nil => exact absurd rfl ‹([] : List (Message F)) ≠ []› + | cons _ _ headIH _ => exact headIH + +end Aiur.Tuple.Circuit diff --git a/Aiur/Aiur/Tuple/Circuit/ExpressionCorrectness.lean b/Aiur/Aiur/Tuple/Circuit/ExpressionCorrectness.lean new file mode 100644 index 000000000..07a6e39d6 --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit/ExpressionCorrectness.lean @@ -0,0 +1,287 @@ +import Aiur.Tuple.Circuit.PatternCorrectness +import Aiur.Tuple.Circuit.ValueCorrectness + +namespace Aiur.Tuple.Circuit.Compiler + +set_option maxHeartbeats 800000 + +mutual + /-- A satisfying assignment recovers evaluation whenever this expression is enabled. -/ + theorem lowerExpr_sound [Field F] [DecidableEq F] + {program : Program F} {function : String} {locals : Locals F} + {enable : ArithExpr F} {expr : Expr F} {output : Symbolic F} + {before after : BuildState F} + (compiled : lowerExpr program function locals enable expr before = .ok (output, after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid calls assignment) : + before.Valid calls assignment ∧ (enable.denote assignment = 1 → + EvalExprWith calls (localsEnvironment locals assignment) expr + (output.map (ArithExpr.denote assignment))) := by + cases expr with + | literal value => + simp only [lowerExpr, pure_ok] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨valid, fun _ => by simpa only [Value.map, Scalar.Circuit.ArithExpr.denote] using EvalExprWith.literal⟩ + | var name => + cases found : locals.find? (·.1 == name) with + | none => simp [lowerExpr, found] at compiled + | some binding => + obtain ⟨bindingName, value⟩ := binding + have same : bindingName = name := by simpa using List.find?_some found + subst bindingName + simp only [lowerExpr, found, pure_ok] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨valid, fun _ => .var (by + simp [localsEnvironment, List.find?_map, Function.comp_def, found])⟩ + | tuple items => + simp only [lowerExpr] at compiled + obtain ⟨values, middle, itemsRun, finished⟩ := bind_ok.mp compiled + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨beforeValid, evaluated⟩ := lowerArgs_sound itemsRun valid + exact ⟨beforeValid, fun active => by + simpa only [Value.map] using EvalExprWith.tuple (evaluated active)⟩ + | project value index => + simp only [lowerExpr] at compiled + obtain ⟨input, middle, valueRun, rest⟩ := bind_ok.mp compiled + cases input with + | field => simp at rest + | tuple items => + cases projected : items[index]? with + | none => simp [projected] at rest + | some result => + simp only [projected, pure_ok] at rest + obtain ⟨rfl, rfl⟩ := rest + obtain ⟨beforeValid, evaluated⟩ := lowerExpr_sound valueRun valid + refine ⟨beforeValid, fun active => .project (evaluated active) ?_⟩ + simp [Value.map, projectValue, List.getElem?_map, projected, pure, Except.pure] + | letValue pattern value body => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, valueRun, rest⟩ := bind_ok.mp compiled + obtain ⟨⟨test, bindings⟩, s₂, patternRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₃, guardRun, bodyRun⟩ := bind_ok.mp rest + cases finished + obtain ⟨s₃Valid, bodyEval⟩ := lowerExpr_sound bodyRun valid + obtain ⟨s₂Valid, equation⟩ := constrain_valid guardRun s₃Valid + obtain ⟨s₁Valid, matched⟩ := lowerPattern_sound patternRun s₂Valid + obtain ⟨beforeValid, valueEval⟩ := lowerExpr_sound valueRun s₁Valid + refine ⟨beforeValid, fun active => ?_⟩ + change enable.denote assignment * (test.denote assignment - 1) = 0 at equation + have testOne : test.denote assignment = 1 := by + simpa [active, sub_eq_zero] using equation + rcases matched with ⟨matched, _⟩ | ⟨_, testZero⟩ + · exact .letValue (valueEval active) matched (by + simpa only [localsEnvironment_append] using bodyEval active) + · exact (zero_ne_one (testZero.symm.trans testOne)).elim + | neg value => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, valueRun, rest⟩ := bind_ok.mp compiled + obtain ⟨polynomial, s₂, fieldRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_ok fieldRun + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨beforeValid, evaluated⟩ := lowerExpr_sound valueRun valid + exact ⟨beforeValid, fun active => .neg (evaluated active) (by + simp [Value.map, evalNeg, ArithExpr.denote, Scalar.Circuit.ArithExpr.denote])⟩ + | binary op left right => + simp only [lowerExpr] at compiled + obtain ⟨leftValue, s₁, leftRun, rest⟩ := bind_ok.mp compiled + obtain ⟨leftPoly, s₂, leftField, rest⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_ok leftField + obtain ⟨rightValue, s₃, rightRun, rest⟩ := bind_ok.mp rest + obtain ⟨rightPoly, s₄, rightField, rest⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_ok rightField + cases op with + | add | sub | mul => + obtain ⟨rfl, rfl⟩ := pure_ok.mp rest + obtain ⟨s₁Valid, rightEval⟩ := lowerExpr_sound rightRun valid + obtain ⟨beforeValid, leftEval⟩ := lowerExpr_sound leftRun s₁Valid + exact ⟨beforeValid, fun active => .binary (leftEval active) (rightEval active) (by + simp [Value.map, evalBinOp, ArithExpr.denote, Scalar.Circuit.ArithExpr.denote])⟩ + | div => + obtain ⟨inverse, s₅, freshRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₆, inverseRun, finishedRun⟩ := bind_ok.mp rest + cases finished + obtain ⟨rfl, rfl⟩ := pure_ok.mp finishedRun + obtain ⟨s₅Valid, equation⟩ := constrain_valid inverseRun valid + have s₃Valid := fresh_valid freshRun s₅Valid + obtain ⟨s₁Valid, rightEval⟩ := lowerExpr_sound rightRun s₃Valid + obtain ⟨beforeValid, leftEval⟩ := lowerExpr_sound leftRun s₁Valid + refine ⟨beforeValid, fun active => .binary (leftEval active) (rightEval active) ?_⟩ + change enable.denote assignment * (rightPoly.denote assignment * assignment inverse - 1) = 0 + at equation + rw [active, one_mul] at equation + simp [Value.map, evalBinOp, ArithExpr.denote, Scalar.Circuit.ArithExpr.denote, + Scalar.Circuit.inverse_nonzero equation, Scalar.Circuit.inverse_eq equation, div_eq_mul_inv] + | call name args => + cases found : program.findFunction? name with + | none => simp [lowerExpr, found] at compiled + | some callee => + simp only [lowerExpr, found] at compiled + obtain ⟨arguments, s₁, argsRun, rest⟩ := bind_ok.mp compiled + obtain ⟨result, s₂, resultRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₃, booleanRun, rest⟩ := bind_ok.mp rest + cases finished + simp [StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at rest + obtain ⟨rfl, rfl⟩ := rest + have s₃Valid : s₃.Valid calls assignment := + valid.of_subset (fun _ member => member) (fun _ member => by simp [member]) + have s₂Valid := (boolean_valid booleanRun s₃Valid).1 + have s₁Valid := freshValue_valid resultRun s₂Valid + obtain ⟨beforeValid, argsEval⟩ := lowerArgs_sound argsRun s₁Valid + refine ⟨beforeValid, fun active => .call (argsEval active) ?_⟩ + simpa only [Value.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using + valid.calls ⟨name, arguments, result, enable⟩ (by simp) active + | matchValue scrutinee arms => + simp only [lowerExpr] at compiled + obtain ⟨checked, s₁, checkRun, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := lift_eq_ok checkRun + obtain ⟨type, s₂, typeRun, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := lift_eq_ok typeRun + obtain ⟨input, s₃, scrutineeRun, rest⟩ := bind_ok.mp rest + obtain ⟨result, s₄, resultRun, rest⟩ := bind_ok.mp rest + obtain ⟨selectors, s₅, armsRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₆, exclusionRun, rest⟩ := bind_ok.mp rest + cases finished + obtain ⟨finished, s₇, sumRun, finishedRun⟩ := bind_ok.mp rest + cases finished + obtain ⟨rfl, rfl⟩ := pure_ok.mp finishedRun + obtain ⟨s₆Valid, sumEquation⟩ := constrain_valid sumRun valid + have s₅Valid := excludePairs_valid exclusionRun s₆Valid + obtain ⟨s₄Valid, armsEval⟩ := lowerArms_sound armsRun s₅Valid + have s₃Valid := freshValue_valid resultRun s₄Valid + obtain ⟨beforeValid, scrutineeEval⟩ := lowerExpr_sound scrutineeRun s₃Valid + refine ⟨beforeValid, fun active => ?_⟩ + have sum : (selectors.map (ArithExpr.denote assignment)).sum = 1 := by + have equation := sub_eq_zero.mp sumEquation + simpa [ArithExpr.denote, Scalar.Circuit.ArithExpr.denote, + Scalar.Circuit.ArithExpr.denote_foldl_add, active] using equation + have nonzero : ∃ selector ∈ selectors, selector.denote assignment ≠ 0 := by + by_contra absent + push Not at absent + have zero : (selectors.map (ArithExpr.denote assignment)).sum = 0 := + List.sum_eq_zero (by simpa using absent) + exact zero_ne_one (zero.symm.trans sum) + obtain ⟨selector, member, activeSelector⟩ := nonzero + obtain ⟨_, bindings, body, selected, evaluated⟩ := armsEval selector member activeSelector + exact .matchValue (scrutineeEval active) selected evaluated + termination_by sizeOf expr + + theorem lowerArgs_sound [Field F] [DecidableEq F] + {program : Program F} {function : String} {locals : Locals F} {enable : ArithExpr F} + {args : List (Expr F)} {outputs : List (Symbolic F)} {before after : BuildState F} + (compiled : lowerArgs program function locals enable args before = .ok (outputs, after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid calls assignment) : + before.Valid calls assignment ∧ (enable.denote assignment = 1 → + EvalArgsWith calls (localsEnvironment locals assignment) args + (outputs.map (Value.map (ArithExpr.denote assignment)))) := by + cases args with + | nil => + simp only [lowerArgs, pure_ok] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨valid, fun _ => .nil⟩ + | cons arg args => + simp only [lowerArgs] at compiled + obtain ⟨head, middle, headRun, rest⟩ := bind_ok.mp compiled + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨middleValid, tailEval⟩ := lowerArgs_sound tailRun valid + obtain ⟨beforeValid, headEval⟩ := lowerExpr_sound headRun middleValid + exact ⟨beforeValid, fun active => .cons (headEval active) (tailEval active)⟩ + termination_by sizeOf args + + /-- Any selected occurrence is exactly the first matching source arm. -/ + theorem lowerArms_sound [Field F] [DecidableEq F] + {program : Program F} {function : String} {locals : Locals F} + {scrutinee result : Symbolic F} {remaining : ArithExpr F} + {arms : List (Pattern F × Expr F)} {selectors : List (ArithExpr F)} + {before after : BuildState F} + (compiled : lowerArms program function locals scrutinee result remaining arms before = + .ok (selectors, after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid calls assignment) : + before.Valid calls assignment ∧ + ∀ selector ∈ selectors, selector.denote assignment ≠ 0 → + remaining.denote assignment ≠ 0 ∧ + ∃ bindings body, + selectArm (scrutinee.map (ArithExpr.denote assignment)) arms = some (bindings, body) ∧ + EvalExprWith calls (bindings ++ localsEnvironment locals assignment) body + (result.map (ArithExpr.denote assignment)) := by + cases arms with + | nil => + simp only [lowerArms, pure_ok] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨valid, by simp⟩ + | cons arm arms => + rcases hArm : arm with ⟨pattern, body⟩ + simp only [hArm, lowerArms] at compiled + obtain ⟨⟨test, bindings⟩, s₁, patternRun, rest⟩ := bind_ok.mp compiled + obtain ⟨selector, s₂, freshRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₃, booleanRun, rest⟩ := bind_ok.mp rest + cases finished + obtain ⟨finished, s₄, equationRun, rest⟩ := bind_ok.mp rest + cases finished + obtain ⟨bodyValue, s₅, bodyRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₆, valueRun, rest⟩ := bind_ok.mp rest + cases finished + have headFacts (endValid : s₆.Valid calls assignment) : + before.Valid calls assignment ∧ + PatternTest (pattern.bindings (scrutinee.map (ArithExpr.denote assignment))) + (test.denote assignment) (localsEnvironment bindings assignment) ∧ + assignment selector = remaining.denote assignment * test.denote assignment ∧ + (assignment selector = 0 ∨ assignment selector = 1) ∧ + (assignment selector = 1 → EvalExprWith calls + (localsEnvironment bindings assignment ++ localsEnvironment locals assignment) body + (result.map (ArithExpr.denote assignment))) := by + obtain ⟨s₅Valid, resultEq⟩ := constrainValue_sound valueRun endValid + obtain ⟨s₄Valid, bodyEval⟩ := lowerExpr_sound bodyRun s₅Valid + obtain ⟨s₃Valid, equation⟩ := constrain_valid equationRun s₄Valid + obtain ⟨s₂Valid, boolean⟩ := boolean_valid booleanRun s₃Valid + have s₁Valid := fresh_valid freshRun s₂Valid + obtain ⟨beforeValid, matched⟩ := lowerPattern_sound patternRun s₁Valid + refine ⟨beforeValid, matched, sub_eq_zero.mp equation, boolean, fun active => ?_⟩ + rw [resultEq active] + simpa only [localsEnvironment_append] using bodyEval active + have headSelected (endValid : s₆.Valid calls assignment) (active : assignment selector ≠ 0) : + remaining.denote assignment ≠ 0 ∧ + ∃ matched body', selectArm (scrutinee.map (ArithExpr.denote assignment)) + ((pattern, body) :: arms) = some (matched, body') ∧ + EvalExprWith calls (matched ++ localsEnvironment locals assignment) body' + (result.map (ArithExpr.denote assignment)) := by + obtain ⟨_, matched, equation, boolean, evaluated⟩ := headFacts endValid + have one := boolean.resolve_left active + have remainingNonzero : remaining.denote assignment ≠ 0 := by + intro zero + exact active (by simp [zero] at equation; exact equation) + refine ⟨remainingNonzero, localsEnvironment bindings assignment, body, ?_, evaluated one⟩ + rcases matched with ⟨matched, _⟩ | ⟨_, zero⟩ + · simp [selectArm, matched] + · exact (active (by simpa [zero] using equation)).elim + split at rest + · obtain ⟨rfl, rfl⟩ := pure_ok.mp rest + refine ⟨(headFacts valid).1, ?_⟩ + intro chosen member active + obtain rfl := List.mem_singleton.mp member + exact headSelected valid active + · simp only [pure_bind] at rest + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨s₆Valid, tailEval⟩ := lowerArms_sound tailRun valid + obtain ⟨beforeValid, matched, _, _, _⟩ := headFacts s₆Valid + refine ⟨beforeValid, ?_⟩ + intro chosen member active + rcases List.mem_cons.mp member with same | member + · subst chosen + exact headSelected s₆Valid active + · obtain ⟨remainingNonzero, selectedBindings, selectedBody, selected, evaluated⟩ := + tailEval chosen member active + change remaining.denote assignment * (1 - test.denote assignment) ≠ 0 + at remainingNonzero + have nonzero := (mul_ne_zero_iff.mp remainingNonzero).1 + refine ⟨nonzero, selectedBindings, selectedBody, ?_, evaluated⟩ + rcases matched with ⟨_, one⟩ | ⟨unmatched, _⟩ + · exact (remainingNonzero (by simp [one])).elim + · simpa only [selectArm, unmatched] using selected + termination_by sizeOf arms + decreasing_by + all_goals simp_all only [Prod.mk.sizeOf_spec, List.cons.sizeOf_spec] + all_goals omega +end + +end Aiur.Tuple.Circuit.Compiler diff --git a/Aiur/Aiur/Tuple/Circuit/ExpressionWitness.lean b/Aiur/Aiur/Tuple/Circuit/ExpressionWitness.lean new file mode 100644 index 000000000..7b2587b1e --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit/ExpressionWitness.lean @@ -0,0 +1,413 @@ +import Aiur.Tuple.Circuit.InactiveWitness +import Aiur.Tuple.TypecheckFacts + +namespace Aiur.Tuple.Circuit.Compiler + +set_option maxHeartbeats 2400000 +set_option maxRecDepth 10000 + +@[simp] theorem localsEnvironment_types [Field F] (locals : Locals F) (assignment : Var → F) : + environmentTypes (localsEnvironment locals assignment) = locals.map (fun binding => (binding.1, binding.2.type)) := by + simp [environmentTypes, localsEnvironment, List.map_map, Value.type_map] + +mutual + /-- Source evaluation supplies witnesses for the actual tuple compiler. -/ + theorem lowerExpr_complete [Field F] [DecidableEq F] + {program : Program F} {function : String} {locals : Locals F} + {enable : ArithExpr F} {expr : Expr F} {output : Symbolic F} {before after : BuildState F} + (compiled : lowerExpr program function locals enable expr before = .ok (output, after)) + {calls : CallRelation F} (typed : CallsTyped program calls) {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid calls initial) + (localsBound : LocalsBounded before.nextVar locals) + (enableBound : enable.inBounds before.nextVar = true) (active : enable.denote initial = 1) + {value : Value F} (evaluated : EvalExprWith calls (localsEnvironment locals initial) expr value) : + ∃ assignment, Extension calls before after initial assignment ∧ Bounded after.nextVar output ∧ + output.map (ArithExpr.denote assignment) = value := by + cases expr with + | literal literal => + cases evaluated + simp only [lowerExpr, pure_ok] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨initial, .refl layout valid, bounded_field.mpr rfl, by simp [Value.map, ArithExpr.denote, Scalar.Circuit.ArithExpr.denote]⟩ + | var name => + cases evaluated with + | var lookup => + cases found : locals.find? (·.1 == name) with + | none => simp [lowerExpr, found] at compiled + | some binding => + obtain ⟨bindingName, result⟩ := binding + simp only [lowerExpr, found, pure_ok] at compiled + obtain ⟨rfl, rfl⟩ := compiled + refine ⟨initial, .refl layout valid, localsBound _ (List.mem_of_find?_eq_some found), ?_⟩ + simpa [localsEnvironment, List.find?_map, Function.comp_def, found] using + congrArg (Option.map Prod.snd) lookup + | tuple items => + cases evaluated with + | tuple itemsEval => + simp only [lowerExpr] at compiled + obtain ⟨values, middle, itemsRun, finished⟩ := bind_ok.mp compiled + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, extension, bounded, valuesEq⟩ := + lowerArgs_complete itemsRun typed layout valid localsBound enableBound active itemsEval + exact ⟨a, extension, bounded_tuple.mpr bounded, by simp only [Value.map, valuesEq]⟩ + | project expr index => + cases evaluated with + | project inputEval projected => + simp only [lowerExpr] at compiled + obtain ⟨input, middle, inputRun, rest⟩ := bind_ok.mp compiled + cases input with + | field => simp at rest + | tuple items => + cases found : items[index]? with + | none => simp [found] at rest + | some result => + simp only [found, pure_ok] at rest + obtain ⟨rfl, rfl⟩ := rest + obtain ⟨a, extension, bounded, inputEq⟩ := + lowerExpr_complete inputRun typed layout valid localsBound enableBound active inputEval + refine ⟨a, extension, bounded_tuple.mp bounded result (List.mem_of_getElem? found), ?_⟩ + rw [← inputEq] at projected + simpa [Value.map, projectValue, List.getElem?_map, found, pure, Except.pure] using projected + | letValue pattern expr body => + cases evaluated with + | letValue inputEval matched bodyEval => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, inputRun, rest⟩ := bind_ok.mp compiled + obtain ⟨⟨test, bindings⟩, s₂, patternRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₃, guardRun, bodyRun⟩ := bind_ok.mp rest + cases finished + obtain ⟨a, e₁, inputBound, inputEq⟩ := + lowerExpr_complete inputRun typed layout valid localsBound enableBound active inputEval + obtain ⟨b, e₂, testBound, bindingsBound⟩ := lowerPattern_complete patternRun e₁.layout e₁.valid inputBound + have chainExt := e₁.trans e₂ + have patternTest := (lowerPattern_sound patternRun e₂.valid).2 + rw [e₂.value inputBound, inputEq, matched] at patternTest + obtain ⟨bindingsEq, testOne⟩ : _ ∧ test.denote b = 1 := by + rcases patternTest with ⟨same, one⟩ | ⟨impossible, _⟩ + · exact ⟨Option.some.inj same, one⟩ + · cases impossible + have e₃ := guarded_complete guardRun e₂.layout e₂.valid (chainExt.bound enableBound) + (by simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using testBound) + (Or.inr (by change test.denote b - 1 = 0; simp [testOne])) + obtain ⟨c, e₄, bodyBound, bodyEq⟩ := lowerExpr_complete bodyRun typed e₃.layout e₃.valid + (localsBounded_append.mpr ⟨bindingsBound.mono e₃.increase, localsBound.mono (chainExt.trans e₃).increase⟩) + ((chainExt.trans e₃).bound enableBound) (((chainExt.trans e₃).polynomial enableBound).trans active) + (by rw [localsEnvironment_append, ← bindingsEq, chainExt.locals localsBound]; exact bodyEval) + exact ⟨c, (chainExt.trans e₃).trans e₄, bodyBound, bodyEq⟩ + | neg expr => + cases evaluated with + | neg inputEval operation => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, inputRun, rest⟩ := bind_ok.mp compiled + obtain ⟨polynomial, s₂, fieldRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_ok fieldRun + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, extension, bounded, inputEq⟩ := + lowerExpr_complete inputRun typed layout valid localsBound enableBound active inputEval + refine ⟨a, extension, by simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using bounded, ?_⟩ + rw [← inputEq] at operation + simpa [Value.map, evalNeg, ArithExpr.denote, Scalar.Circuit.ArithExpr.denote] using operation + | binary op left right => + cases evaluated with + | binary leftEval rightEval operation => + simp only [lowerExpr] at compiled + obtain ⟨leftValue, s₁, leftRun, rest⟩ := bind_ok.mp compiled + obtain ⟨leftPoly, s₂, leftField, rest⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_ok leftField + obtain ⟨rightValue, s₃, rightRun, rest⟩ := bind_ok.mp rest + obtain ⟨rightPoly, s₄, rightField, rest⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_ok rightField + obtain ⟨a, e₁, leftBound, leftEq⟩ := + lowerExpr_complete leftRun typed layout valid localsBound enableBound active leftEval + obtain ⟨b, e₂, rightBound, rightEq⟩ := lowerExpr_complete rightRun typed e₁.layout e₁.valid + (localsBound.mono e₁.increase) (e₁.bound enableBound) ((e₁.polynomial enableBound).trans active) + (by rw [e₁.locals localsBound]; exact rightEval) + have chainExt := e₁.trans e₂ + have lb := bounded_field.mp (leftBound.mono e₂.increase) + have rb := bounded_field.mp rightBound + have leftEqB := (e₂.value leftBound).trans leftEq + rw [← leftEqB, ← rightEq] at operation + cases op with + | add | sub | mul => + obtain ⟨rfl, rfl⟩ := pure_ok.mp rest + exact ⟨b, chainExt, by + simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using And.intro lb rb, + by simpa [Value.map, evalBinOp, ArithExpr.denote, Scalar.Circuit.ArithExpr.denote] using operation⟩ + | div => + have nonzero : rightPoly.denote b ≠ 0 := by + intro zero + simp [Value.map, evalBinOp, zero] at operation + have quotient : Value.field (leftPoly.denote b / rightPoly.denote b) = value := by + simpa [Value.map, evalBinOp, nonzero] using operation + obtain ⟨inverse, s₅, freshRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₆, inverseRun, finishedRun⟩ := bind_ok.mp rest + cases finished + obtain ⟨rfl, rfl⟩ := pure_ok.mp finishedRun + obtain ⟨c, e₃, invBound, invEq⟩ := fresh_complete freshRun e₂.layout e₂.valid (rightPoly.denote b)⁻¹ + have ib : (ArithExpr.var inverse : ArithExpr F).inBounds s₅.nextVar = true := by + simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using invBound + have e₄ := guarded_complete inverseRun e₃.layout e₃.valid ((chainExt.trans e₃).bound enableBound) + (by simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using And.intro (e₃.bound rb) ib) + (Or.inr (by + change rightPoly.denote c * c inverse - 1 = 0 + rw [e₃.polynomial rb, invEq] + simp [nonzero])) + refine ⟨c, (chainExt.trans e₃).trans e₄, ?_, ?_⟩ + · simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + And.intro ((e₃.trans e₄).bound lb) (e₄.bound ib) + · simp only [Value.map] + change Value.field (leftPoly.denote c * c inverse) = value + rw [e₃.polynomial lb, invEq, ← div_eq_mul_inv] + exact quotient + | call name args => + cases evaluated with + | call argsEval calleeEval => + cases found : program.findFunction? name with + | none => simp [lowerExpr, found] at compiled + | some callee => + simp only [lowerExpr, found] at compiled + obtain ⟨arguments, s₁, argsRun, rest⟩ := bind_ok.mp compiled + obtain ⟨result, s₂, resultRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₃, booleanRun, rest⟩ := bind_ok.mp rest + cases finished + simp [StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at rest + obtain ⟨rfl, rfl⟩ := rest + obtain ⟨a, e₁, argsBound, argsEq⟩ := + lowerArgs_complete argsRun typed layout valid localsBound enableBound active argsEval + obtain ⟨b, e₂, resultBound, resultEq⟩ := freshValue_complete resultRun e₁.layout e₁.valid + value (typed _ _ _ calleeEval callee found) + have chainExt := e₁.trans e₂ + have e₃ := boolean_complete booleanRun e₂.layout e₂.valid (chainExt.bound enableBound) + (Or.inr ((chainExt.polynomial enableBound).trans active)) + have e₄ := send_complete e₃.layout e₃.valid ⟨name, arguments, result, enable⟩ + (send_bounded (fun value h => (argsBound value h).mono (e₂.trans e₃).increase) + (resultBound.mono e₃.increase) ((chainExt.trans e₃).bound enableBound)) (by + intro _ + simp only [e₂.values argsBound, argsEq, resultEq] + exact calleeEval) + exact ⟨b, (chainExt.trans e₃).trans e₄, resultBound.mono (e₃.trans e₄).increase, + by simpa only [Value.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using resultEq⟩ + | matchValue scrutinee arms => + have allEval := evaluated + cases evaluated with + | matchValue inputEval selected branchEval => + simp only [lowerExpr] at compiled + obtain ⟨checked, s₁, checkRun, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := lift_eq_ok checkRun + obtain ⟨type, s₂, typeRun, rest⟩ := bind_ok.mp rest + obtain ⟨inferred, rfl⟩ := lift_eq_ok typeRun + have shape : value.type = type := by + apply allEval.type typed function type + rw [localsEnvironment_types] + cases h : inferType program function (locals.map fun (name, value) => (name, value.type)) + (.matchValue scrutinee arms) <;> simp_all [Except.mapError] + obtain ⟨input, s₃, inputRun, rest⟩ := bind_ok.mp rest + obtain ⟨result, s₄, resultRun, rest⟩ := bind_ok.mp rest + obtain ⟨selectors, s₅, armsRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₆, exclusionRun, rest⟩ := bind_ok.mp rest + cases finished + obtain ⟨finished, s₇, sumRun, finishedRun⟩ := bind_ok.mp rest + cases finished + obtain ⟨rfl, rfl⟩ := pure_ok.mp finishedRun + obtain ⟨a, e₁, inputBound, inputEq⟩ := + lowerExpr_complete inputRun typed layout valid localsBound enableBound active inputEval + obtain ⟨b, e₂, resultBound, resultEq⟩ := freshValue_complete resultRun e₁.layout e₁.valid value shape + have chainExt := e₁.trans e₂ + obtain ⟨c, e₃, selectorsBound, selection⟩ := lowerArms_complete armsRun typed e₂.layout e₂.valid + (localsBound.mono chainExt.increase) (inputBound.mono e₂.increase) resultBound + (chainExt.bound enableBound) ((chainExt.polynomial enableBound).trans active) + (by rw [e₂.value inputBound, inputEq]; exact selected) + (by + rw [chainExt.locals localsBound, Value.map_map] + change EvalExprWith calls _ _ (result.map b) + rw [resultEq] + exact branchEval) + have e₄ := excludePairs_complete exclusionRun e₃.layout e₃.valid selectorsBound selection.exclusive + have e₅ := sum_complete sumRun e₄.layout e₄.valid + (fun p h => e₄.bound (selectorsBound p h)) (((chainExt.trans e₃).trans e₄).bound enableBound) + (by rw [((chainExt.trans e₃).trans e₄).polynomial enableBound, active]; exact selection.sum) + exact ⟨c, ((chainExt.trans e₃).trans e₄).trans e₅, + resultBound.mono ((e₃.trans e₄).trans e₅).increase, + by simpa only [Value.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using (e₃.variables resultBound).trans resultEq⟩ + termination_by sizeOf expr + + theorem lowerArgs_complete [Field F] [DecidableEq F] + {program : Program F} {function : String} {locals : Locals F} {enable : ArithExpr F} + {args : List (Expr F)} {outputs : List (Symbolic F)} {before after : BuildState F} + (compiled : lowerArgs program function locals enable args before = .ok (outputs, after)) + {calls : CallRelation F} (typed : CallsTyped program calls) {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid calls initial) + (localsBound : LocalsBounded before.nextVar locals) + (enableBound : enable.inBounds before.nextVar = true) (active : enable.denote initial = 1) + {values : List (Value F)} (evaluated : EvalArgsWith calls (localsEnvironment locals initial) args values) : + ∃ assignment, Extension calls before after initial assignment ∧ + (∀ value ∈ outputs, Bounded after.nextVar value) ∧ + outputs.map (Value.map (ArithExpr.denote assignment)) = values := by + cases args with + | nil => + cases evaluated + simp only [lowerArgs, pure_ok] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨initial, .refl layout valid, by simp, rfl⟩ + | cons arg args => + cases evaluated with + | cons headEval tailEval => + simp only [lowerArgs] at compiled + obtain ⟨head, middle, headRun, rest⟩ := bind_ok.mp compiled + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, e₁, headBound, headEq⟩ := + lowerExpr_complete headRun typed layout valid localsBound enableBound active headEval + obtain ⟨b, e₂, tailBound, tailEq⟩ := lowerArgs_complete tailRun typed e₁.layout e₁.valid + (localsBound.mono e₁.increase) (e₁.bound enableBound) ((e₁.polynomial enableBound).trans active) + (by rw [e₁.locals localsBound]; exact tailEval) + refine ⟨b, e₁.trans e₂, ?_, ?_⟩ + · intro value member + rcases List.mem_cons.mp member with rfl | member + · exact headBound.mono e₂.increase + · exact tailBound value member + · simp only [List.map_cons, e₂.value headBound, headEq, tailEq] + termination_by sizeOf args + + theorem lowerArms_complete [Field F] [DecidableEq F] + {program : Program F} {function : String} {locals : Locals F} + {scrutinee result : Symbolic F} {remaining : ArithExpr F} + {arms : List (Pattern F × Expr F)} {selectors : List (ArithExpr F)} {before after : BuildState F} + (compiled : lowerArms program function locals scrutinee result remaining arms before = .ok (selectors, after)) + {calls : CallRelation F} (typed : CallsTyped program calls) {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid calls initial) + (localsBound : LocalsBounded before.nextVar locals) + (inputBound : Bounded before.nextVar scrutinee) (resultBound : Bounded before.nextVar result) + (remainingBound : remaining.inBounds before.nextVar = true) (active : remaining.denote initial = 1) + {matched : Environment F} {body : Expr F} + (selected : selectArm (scrutinee.map (ArithExpr.denote initial)) arms = some (matched, body)) + (evaluated : EvalExprWith calls (matched ++ localsEnvironment locals initial) body + (result.map (ArithExpr.denote initial))) : + ∃ assignment, Extension calls before after initial assignment ∧ + (∀ selector ∈ selectors, selector.inBounds after.nextVar = true) ∧ + Scalar.Circuit.SelectorsValid (1 : F) (selectors.map (ArithExpr.denote assignment)) := by + cases arms with + | nil => simp [selectArm] at selected + | cons arm arms => + rcases hArm : arm with ⟨pattern, branch⟩ + simp only [hArm, lowerArms] at compiled + obtain ⟨⟨test, bindings⟩, s₁, patternRun, rest⟩ := bind_ok.mp compiled + obtain ⟨selector, s₂, freshRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₃, booleanRun, rest⟩ := bind_ok.mp rest + cases finished + obtain ⟨finished, s₄, equationRun, rest⟩ := bind_ok.mp rest + cases finished + obtain ⟨bodyValue, s₅, bodyRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₆, valueRun, armsRest⟩ := bind_ok.mp rest + cases finished + obtain ⟨a, e₁, testBound, bindingsBound⟩ := lowerPattern_complete patternRun layout valid inputBound + have patternTest := (lowerPattern_sound patternRun e₁.valid).2 + rw [e₁.value inputBound] at patternTest + have testBool : test.denote a = 0 ∨ test.denote a = 1 := by + rcases patternTest with ⟨_, one⟩ | ⟨_, zero⟩ + · exact Or.inr one + · exact Or.inl zero + obtain ⟨b, e₂, idBound, selEq⟩ := fresh_complete freshRun e₁.layout e₁.valid (test.denote a) + have selectorBound : (ArithExpr.var selector : ArithExpr F).inBounds s₂.nextVar = true := by + simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using idBound + have e₃ := boolean_complete booleanRun e₂.layout e₂.valid selectorBound (by + change b selector = 0 ∨ b selector = 1; rw [selEq]; exact testBool) + have chainExt := (e₁.trans e₂).trans e₃ + have e₄ := constrain_complete equationRun e₃.layout e₃.valid + (by simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + And.intro (e₃.bound selectorBound) (And.intro (chainExt.bound remainingBound) ((e₂.trans e₃).bound testBound))) + (by change b selector - remaining.denote b * test.denote b = 0 + rw [selEq, chainExt.polynomial remainingBound, active, e₂.polynomial testBound]; simp) + have localsBound' : LocalsBounded s₄.nextVar (bindings ++ locals) := + localsBounded_append.mpr ⟨bindingsBound.mono ((e₂.trans e₃).trans e₄).increase, + localsBound.mono (chainExt.trans e₄).increase⟩ + rcases patternTest with ⟨matchedHead, testOne⟩ | ⟨unmatchedHead, testZero⟩ + · have selectedHead : matched = localsEnvironment bindings a ∧ body = branch := by + simpa only [hArm, selectArm, matchedHead, Option.some.injEq, Prod.mk.injEq] using selected.symm + obtain ⟨rfl, rfl⟩ := selectedHead + have selOne : (ArithExpr.var selector : ArithExpr F).denote b = 1 := selEq.trans testOne + obtain ⟨c, e₅, bodyBound, bodyEq⟩ := lowerExpr_complete bodyRun typed e₄.layout e₄.valid localsBound' + ((e₃.trans e₄).bound selectorBound) selOne (by + rw [localsEnvironment_append, e₂.locals bindingsBound, (chainExt.trans e₄).locals localsBound] + exact evaluated) + have headExt := (chainExt.trans e₄).trans e₅ + have selOneC := (((e₃.trans e₄).trans e₅).polynomial selectorBound).trans selOne + have e₆ := constrainValue_complete valueRun e₅.layout e₅.valid + (((e₃.trans e₄).trans e₅).bound selectorBound) (resultBound.mono headExt.increase) bodyBound + (Or.inr ((headExt.value resultBound).trans bodyEq.symm)) + have total := headExt.trans e₆ + have finalBound := (((e₃.trans e₄).trans e₅).trans e₆).bound selectorBound + split at armsRest + · obtain ⟨rfl, rfl⟩ := pure_ok.mp armsRest + refine ⟨c, total, by simpa using finalBound, ?_⟩ + simpa only [List.map_cons, List.map_nil, selOneC, List.nil_append] using + (Scalar.Circuit.SelectorsValid.single (before := []) (after := []) (by simp) (by simp) : + Scalar.Circuit.SelectorsValid (1 : F) [1]) + · simp only [pure_bind] at armsRest + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp armsRest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + have testFinal := ((((e₂.trans e₃).trans e₄).trans e₅).trans e₆).bound testBound + have nextBound : (ArithExpr.mul remaining (.sub (.const 1) test)).inBounds s₆.nextVar = true := by + simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + And.intro (total.bound remainingBound) testFinal + have nextZero : (ArithExpr.mul remaining (.sub (.const 1) test)).denote c = 0 := by + change remaining.denote c * (1 - test.denote c) = 0 + rw [((((e₂.trans e₃).trans e₄).trans e₅).trans e₆).polynomial testBound, testOne] + simp + obtain ⟨d, tailExt, tailBound, tailZero⟩ := lowerArms_inactive tailRun total.layout total.valid + (localsBound.mono total.increase) (inputBound.mono total.increase) (resultBound.mono total.increase) + nextBound nextZero + refine ⟨d, total.trans tailExt, ?_, ?_⟩ + · intro p member + rcases List.mem_cons.mp member with rfl | member + · exact tailExt.bound finalBound + · exact tailBound p member + · have one := (tailExt.polynomial finalBound).trans selOneC + simp only [List.map_cons, one] + exact Scalar.Circuit.SelectorsValid.single (before := []) (by simp) + (by simpa only [List.forall_mem_map] using tailZero) + · have selectedTail : selectArm (scrutinee.map (ArithExpr.denote initial)) arms = some (matched, body) := by + simpa only [hArm, selectArm, unmatchedHead] using selected + have selZero : (ArithExpr.var selector : ArithExpr F).denote b = 0 := selEq.trans testZero + obtain ⟨c, e₅, bodyBound⟩ := lowerExpr_inactive bodyRun e₄.layout e₄.valid localsBound' + ((e₃.trans e₄).bound selectorBound) selZero + have headExt := (chainExt.trans e₄).trans e₅ + have selZeroC := (((e₃.trans e₄).trans e₅).polynomial selectorBound).trans selZero + have e₆ := constrainValue_complete valueRun e₅.layout e₅.valid + (((e₃.trans e₄).trans e₅).bound selectorBound) (resultBound.mono headExt.increase) bodyBound (Or.inl selZeroC) + have total := headExt.trans e₆ + have finalBound := (((e₃.trans e₄).trans e₅).trans e₆).bound selectorBound + split at armsRest + · rename_i irrefutable + have one := lowerPattern_irrefutable patternRun irrefutable a + exact (zero_ne_one (testZero.symm.trans one)).elim + · simp only [pure_bind] at armsRest + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp armsRest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + have testFinal := ((((e₂.trans e₃).trans e₄).trans e₅).trans e₆).bound testBound + have nextBound : (ArithExpr.mul remaining (.sub (.const 1) test)).inBounds s₆.nextVar = true := by + simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + And.intro (total.bound remainingBound) testFinal + have nextOne : (ArithExpr.mul remaining (.sub (.const 1) test)).denote c = 1 := by + change remaining.denote c * (1 - test.denote c) = 1 + rw [total.polynomial remainingBound, active, + ((((e₂.trans e₃).trans e₄).trans e₅).trans e₆).polynomial testBound, testZero] + simp + obtain ⟨d, tailExt, tailBound, selection⟩ := lowerArms_complete tailRun typed total.layout total.valid + (localsBound.mono total.increase) (inputBound.mono total.increase) (resultBound.mono total.increase) + nextBound nextOne (by rw [total.value inputBound]; exact selectedTail) + (by rw [total.locals localsBound, total.value resultBound]; exact evaluated) + refine ⟨d, total.trans tailExt, ?_, ?_⟩ + · intro p member + rcases List.mem_cons.mp member with rfl | member + · exact tailExt.bound finalBound + · exact tailBound p member + · have zero := (tailExt.polynomial finalBound).trans selZeroC + simpa only [List.map_cons, zero] using selection.zero_cons + termination_by sizeOf arms + decreasing_by + all_goals simp only [*, Prod.mk.sizeOf_spec, List.cons.sizeOf_spec] + all_goals omega +end + +end Aiur.Tuple.Circuit.Compiler diff --git a/Aiur/Aiur/Tuple/Circuit/InactiveWitness.lean b/Aiur/Aiur/Tuple/Circuit/InactiveWitness.lean new file mode 100644 index 000000000..222f0bc9b --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit/InactiveWitness.lean @@ -0,0 +1,277 @@ +import Aiur.Tuple.Circuit.SelectorWitness + +namespace Aiur.Tuple.Circuit.Compiler + +set_option maxHeartbeats 1600000 + +mutual + /-- Disabled expressions still admit all unconditional pattern-test witnesses. -/ + theorem lowerExpr_inactive [Field F] [DecidableEq F] + {program : Program F} {function : String} {locals : Locals F} + {enable : ArithExpr F} {expr : Expr F} {output : Symbolic F} {before after : BuildState F} + (compiled : lowerExpr program function locals enable expr before = .ok (output, after)) + {calls : CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid calls initial) + (localsBound : LocalsBounded before.nextVar locals) + (enableBound : enable.inBounds before.nextVar = true) (inactive : enable.denote initial = 0) : + ∃ assignment, Extension calls before after initial assignment ∧ Bounded after.nextVar output := by + cases expr with + | literal value => + simp only [lowerExpr, pure_ok] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨initial, .refl layout valid, bounded_field.mpr rfl⟩ + | var name => + cases found : locals.find? (·.1 == name) with + | none => simp [lowerExpr, found] at compiled + | some binding => + obtain ⟨bindingName, value⟩ := binding + simp only [lowerExpr, found, pure_ok] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨initial, .refl layout valid, localsBound _ (List.mem_of_find?_eq_some found)⟩ + | tuple items => + simp only [lowerExpr] at compiled + obtain ⟨values, middle, itemsRun, finished⟩ := bind_ok.mp compiled + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨assignment, extension, bounded⟩ := + lowerArgs_inactive itemsRun layout valid localsBound enableBound inactive + exact ⟨assignment, extension, bounded_tuple.mpr bounded⟩ + | project value index => + simp only [lowerExpr] at compiled + obtain ⟨input, middle, valueRun, rest⟩ := bind_ok.mp compiled + cases input with + | field => simp at rest + | tuple items => + cases projected : items[index]? with + | none => simp [projected] at rest + | some result => + simp only [projected, pure_ok] at rest + obtain ⟨rfl, rfl⟩ := rest + obtain ⟨assignment, extension, bounded⟩ := + lowerExpr_inactive valueRun layout valid localsBound enableBound inactive + exact ⟨assignment, extension, + bounded_tuple.mp bounded result (List.mem_of_getElem? projected)⟩ + | letValue pattern value body => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, valueRun, rest⟩ := bind_ok.mp compiled + obtain ⟨⟨test, bindings⟩, s₂, patternRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₃, guardRun, bodyRun⟩ := bind_ok.mp rest + cases finished + obtain ⟨a, e₁, inputBound⟩ := lowerExpr_inactive valueRun layout valid localsBound enableBound inactive + obtain ⟨b, e₂, testBound, bindingsBound⟩ := lowerPattern_complete patternRun e₁.layout e₁.valid inputBound + have chainExt := e₁.trans e₂ + have e₃ := guarded_complete guardRun e₂.layout e₂.valid (chainExt.bound enableBound) + (by simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using testBound) + (Or.inl ((chainExt.polynomial enableBound).trans inactive)) + obtain ⟨c, e₄, bodyBound⟩ := lowerExpr_inactive bodyRun e₃.layout e₃.valid + (localsBounded_append.mpr ⟨bindingsBound.mono e₃.increase, localsBound.mono (chainExt.trans e₃).increase⟩) + ((chainExt.trans e₃).bound enableBound) (((chainExt.trans e₃).polynomial enableBound).trans inactive) + exact ⟨c, (chainExt.trans e₃).trans e₄, bodyBound⟩ + | neg value => + simp only [lowerExpr] at compiled + obtain ⟨input, s₁, valueRun, rest⟩ := bind_ok.mp compiled + obtain ⟨polynomial, s₂, fieldRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_ok fieldRun + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, extension, bounded⟩ := lowerExpr_inactive valueRun layout valid localsBound enableBound inactive + exact ⟨a, extension, by simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using bounded⟩ + | binary op left right => + simp only [lowerExpr] at compiled + obtain ⟨leftValue, s₁, leftRun, rest⟩ := bind_ok.mp compiled + obtain ⟨leftPoly, s₂, leftField, rest⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_ok leftField + obtain ⟨rightValue, s₃, rightRun, rest⟩ := bind_ok.mp rest + obtain ⟨rightPoly, s₄, rightField, rest⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := asField_ok rightField + obtain ⟨a, e₁, leftBound⟩ := lowerExpr_inactive leftRun layout valid localsBound enableBound inactive + obtain ⟨b, e₂, rightBound⟩ := lowerExpr_inactive rightRun e₁.layout e₁.valid + (localsBound.mono e₁.increase) (e₁.bound enableBound) ((e₁.polynomial enableBound).trans inactive) + have chainExt := e₁.trans e₂ + have lb := bounded_field.mp (leftBound.mono e₂.increase) + have rb := bounded_field.mp rightBound + cases op with + | add | sub | mul => + obtain ⟨rfl, rfl⟩ := pure_ok.mp rest + exact ⟨b, chainExt, by simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using And.intro lb rb⟩ + | div => + obtain ⟨inverse, s₅, freshRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₆, inverseRun, finishedRun⟩ := bind_ok.mp rest + cases finished + obtain ⟨rfl, rfl⟩ := pure_ok.mp finishedRun + obtain ⟨c, e₃, invBound, _⟩ := fresh_complete freshRun e₂.layout e₂.valid 0 + have ib : (ArithExpr.var inverse : ArithExpr F).inBounds s₅.nextVar = true := by + simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using invBound + have e₄ := guarded_complete inverseRun e₃.layout e₃.valid ((chainExt.trans e₃).bound enableBound) + (by simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using And.intro (e₃.bound rb) ib) + (Or.inl (((chainExt.trans e₃).polynomial enableBound).trans inactive)) + exact ⟨c, (chainExt.trans e₃).trans e₄, by + simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + And.intro ((e₃.trans e₄).bound lb) (e₄.bound ib)⟩ + | call name args => + cases found : program.findFunction? name with + | none => simp [lowerExpr, found] at compiled + | some callee => + simp only [lowerExpr, found] at compiled + obtain ⟨arguments, s₁, argsRun, rest⟩ := bind_ok.mp compiled + obtain ⟨result, s₂, resultRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₃, booleanRun, rest⟩ := bind_ok.mp rest + cases finished + simp [StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at rest + obtain ⟨rfl, rfl⟩ := rest + obtain ⟨a, e₁, argsBound⟩ := lowerArgs_inactive argsRun layout valid localsBound enableBound inactive + obtain ⟨b, e₂, resultBound, _⟩ := freshValue_complete resultRun e₁.layout e₁.valid + (zeroValue callee.result) (zeroValue_type _) + have chainExt := e₁.trans e₂ + have e₃ := boolean_complete booleanRun e₂.layout e₂.valid (chainExt.bound enableBound) + (Or.inl ((chainExt.polynomial enableBound).trans inactive)) + have e₄ := send_complete e₃.layout e₃.valid ⟨name, arguments, result, enable⟩ + (send_bounded (fun value h => (argsBound value h).mono (e₂.trans e₃).increase) + (resultBound.mono e₃.increase) ((chainExt.trans e₃).bound enableBound)) (by + intro active + have zero := ((chainExt.trans e₃).polynomial enableBound).trans inactive + exact (zero_ne_one (zero.symm.trans active)).elim) + exact ⟨b, (chainExt.trans e₃).trans e₄, resultBound.mono (e₃.trans e₄).increase⟩ + | matchValue scrutinee arms => + simp only [lowerExpr] at compiled + obtain ⟨checked, s₁, checkRun, rest⟩ := bind_ok.mp compiled + obtain ⟨_, rfl⟩ := lift_eq_ok checkRun + obtain ⟨type, s₂, typeRun, rest⟩ := bind_ok.mp rest + obtain ⟨_, rfl⟩ := lift_eq_ok typeRun + obtain ⟨input, s₃, scrutineeRun, rest⟩ := bind_ok.mp rest + obtain ⟨result, s₄, resultRun, rest⟩ := bind_ok.mp rest + obtain ⟨selectors, s₅, armsRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₆, exclusionRun, rest⟩ := bind_ok.mp rest + cases finished + obtain ⟨finished, s₇, sumRun, finishedRun⟩ := bind_ok.mp rest + cases finished + obtain ⟨rfl, rfl⟩ := pure_ok.mp finishedRun + obtain ⟨a, e₁, inputBound⟩ := lowerExpr_inactive scrutineeRun layout valid localsBound enableBound inactive + obtain ⟨b, e₂, resultBound, _⟩ := freshValue_complete resultRun e₁.layout e₁.valid + (zeroValue type) (zeroValue_type _) + have chainExt := e₁.trans e₂ + obtain ⟨c, e₃, selectorsBound, selectorsZero⟩ := lowerArms_inactive armsRun e₂.layout e₂.valid + (localsBound.mono chainExt.increase) (inputBound.mono e₂.increase) resultBound + (chainExt.bound enableBound) ((chainExt.polynomial enableBound).trans inactive) + have selection := Scalar.Circuit.SelectorsValid.zeros + (selectors := selectors.map (ArithExpr.denote c)) (by + simpa only [List.forall_mem_map] using selectorsZero) + have e₄ := excludePairs_complete exclusionRun e₃.layout e₃.valid selectorsBound selection.exclusive + have e₅ := sum_complete sumRun e₄.layout e₄.valid + (fun p h => e₄.bound (selectorsBound p h)) (((chainExt.trans e₃).trans e₄).bound enableBound) + (by rw [((chainExt.trans e₃).trans e₄).polynomial enableBound, inactive]; exact selection.sum) + exact ⟨c, ((chainExt.trans e₃).trans e₄).trans e₅, resultBound.mono ((e₃.trans e₄).trans e₅).increase⟩ + termination_by sizeOf expr + + theorem lowerArgs_inactive [Field F] [DecidableEq F] + {program : Program F} {function : String} {locals : Locals F} {enable : ArithExpr F} + {args : List (Expr F)} {outputs : List (Symbolic F)} {before after : BuildState F} + (compiled : lowerArgs program function locals enable args before = .ok (outputs, after)) + {calls : CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid calls initial) + (localsBound : LocalsBounded before.nextVar locals) + (enableBound : enable.inBounds before.nextVar = true) (inactive : enable.denote initial = 0) : + ∃ assignment, Extension calls before after initial assignment ∧ + ∀ value ∈ outputs, Bounded after.nextVar value := by + cases args with + | nil => + simp only [lowerArgs, pure_ok] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨initial, .refl layout valid, by simp⟩ + | cons arg args => + simp only [lowerArgs] at compiled + obtain ⟨head, middle, headRun, rest⟩ := bind_ok.mp compiled + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, e₁, headBound⟩ := lowerExpr_inactive headRun layout valid localsBound enableBound inactive + obtain ⟨b, e₂, tailBound⟩ := lowerArgs_inactive tailRun e₁.layout e₁.valid + (localsBound.mono e₁.increase) (e₁.bound enableBound) ((e₁.polynomial enableBound).trans inactive) + refine ⟨b, e₁.trans e₂, ?_⟩ + intro value member + rcases List.mem_cons.mp member with rfl | member + · exact headBound.mono e₂.increase + · exact tailBound value member + termination_by sizeOf args + + theorem lowerArms_inactive [Field F] [DecidableEq F] + {program : Program F} {function : String} {locals : Locals F} + {scrutinee result : Symbolic F} {remaining : ArithExpr F} + {arms : List (Pattern F × Expr F)} {selectors : List (ArithExpr F)} {before after : BuildState F} + (compiled : lowerArms program function locals scrutinee result remaining arms before = .ok (selectors, after)) + {calls : CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid calls initial) + (localsBound : LocalsBounded before.nextVar locals) + (inputBound : Bounded before.nextVar scrutinee) (resultBound : Bounded before.nextVar result) + (remainingBound : remaining.inBounds before.nextVar = true) (inactive : remaining.denote initial = 0) : + ∃ assignment, Extension calls before after initial assignment ∧ + (∀ selector ∈ selectors, selector.inBounds after.nextVar = true) ∧ + (∀ selector ∈ selectors, selector.denote assignment = 0) := by + cases arms with + | nil => + simp only [lowerArms, pure_ok] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨initial, .refl layout valid, by simp, by simp⟩ + | cons arm arms => + rcases hArm : arm with ⟨pattern, body⟩ + simp only [hArm, lowerArms] at compiled + obtain ⟨⟨test, bindings⟩, s₁, patternRun, rest⟩ := bind_ok.mp compiled + obtain ⟨selector, s₂, freshRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₃, booleanRun, rest⟩ := bind_ok.mp rest + cases finished + obtain ⟨finished, s₄, equationRun, rest⟩ := bind_ok.mp rest + cases finished + obtain ⟨bodyValue, s₅, bodyRun, rest⟩ := bind_ok.mp rest + obtain ⟨finished, s₆, valueRun, rest⟩ := bind_ok.mp rest + cases finished + obtain ⟨a, e₁, testBound, bindingsBound⟩ := lowerPattern_complete patternRun layout valid inputBound + obtain ⟨b, e₂, idBound, selZero⟩ := fresh_complete freshRun e₁.layout e₁.valid 0 + have selectorBound : (ArithExpr.var selector : ArithExpr F).inBounds s₂.nextVar = true := by + simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using idBound + have e₃ := boolean_complete booleanRun e₂.layout e₂.valid selectorBound (Or.inl selZero) + have chainExt := (e₁.trans e₂).trans e₃ + have e₄ := constrain_complete equationRun e₃.layout e₃.valid + (by simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + And.intro (e₃.bound selectorBound) (And.intro (chainExt.bound remainingBound) ((e₂.trans e₃).bound testBound))) + (by change b selector - remaining.denote b * test.denote b = 0 + rw [selZero, chainExt.polynomial remainingBound, inactive]; simp) + obtain ⟨c, e₅, bodyBound⟩ := lowerExpr_inactive bodyRun e₄.layout e₄.valid + (localsBounded_append.mpr ⟨bindingsBound.mono ((e₂.trans e₃).trans e₄).increase, + localsBound.mono (chainExt.trans e₄).increase⟩) + ((e₃.trans e₄).bound selectorBound) + (by simpa only [ArithExpr.denote, Scalar.Circuit.ArithExpr.denote] using selZero) + have selZeroC : (ArithExpr.var selector : ArithExpr F).denote c = 0 := + ((e₃.trans e₄).trans e₅).polynomial selectorBound |>.trans selZero + have headExt := (chainExt.trans e₄).trans e₅ + have e₆ := constrainValue_complete valueRun e₅.layout e₅.valid + (((e₃.trans e₄).trans e₅).bound selectorBound) (resultBound.mono headExt.increase) bodyBound (Or.inl selZeroC) + have total := headExt.trans e₆ + have finalBound := (((e₃.trans e₄).trans e₅).trans e₆).bound selectorBound + split at rest + · obtain ⟨rfl, rfl⟩ := pure_ok.mp rest + exact ⟨c, total, by simpa using finalBound, by simpa using selZeroC⟩ + · simp only [pure_bind] at rest + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + have nextBound : (ArithExpr.mul remaining (.sub (.const 1) test)).inBounds s₆.nextVar = true := by + simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + And.intro (total.bound remainingBound) (((((e₂.trans e₃).trans e₄).trans e₅).trans e₆).bound testBound) + have nextZero : (ArithExpr.mul remaining (.sub (.const 1) test)).denote c = 0 := by + change remaining.denote c * (1 - test.denote c) = 0 + rw [total.polynomial remainingBound, inactive, zero_mul] + obtain ⟨d, tailExt, tailBound, tailZero⟩ := lowerArms_inactive tailRun total.layout total.valid + (localsBound.mono total.increase) (inputBound.mono total.increase) (resultBound.mono total.increase) + nextBound nextZero + refine ⟨d, total.trans tailExt, ?_, ?_⟩ + · intro p member + rcases List.mem_cons.mp member with rfl | member + · exact tailExt.bound finalBound + · exact tailBound p member + · intro p member + rcases List.mem_cons.mp member with rfl | member + · exact (tailExt.polynomial finalBound).trans selZeroC + · exact tailZero p member + termination_by sizeOf arms + decreasing_by + all_goals simp only [*, Prod.mk.sizeOf_spec, List.cons.sizeOf_spec] + all_goals omega +end + +end Aiur.Tuple.Circuit.Compiler diff --git a/Aiur/Aiur/Tuple/Circuit/LocalCorrectness.lean b/Aiur/Aiur/Tuple/Circuit/LocalCorrectness.lean new file mode 100644 index 000000000..4a4d0ffa1 --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit/LocalCorrectness.lean @@ -0,0 +1,63 @@ +import Aiur.Tuple.Circuit.ExpressionCorrectness +import Aiur.Tuple.Circuit.CompileFacts + +namespace Aiur.Tuple.Circuit + +theorem Chip.premises_forall [Field F] [DecidableEq F] (chip : Chip F) (row : Row F) + (property : Message F → Prop) : + (∀ message ∈ chip.premises row, property message) ↔ + ∀ send ∈ chip.sends, send.enable.denote row.assignment = 1 → + property (send.message row.assignment) := by + constructor + · intro valid send member enabled + apply valid (send.message row.assignment) + apply List.mem_filterMap.mpr + exact ⟨send, member, by simp [enabled]⟩ + · intro valid message member + obtain ⟨send, sendMember, selected⟩ := List.mem_filterMap.mp member + split at selected + · rename_i enabled + cases selected + exact valid send sendMember enabled + · cases selected + +namespace Compiler + +theorem parameter_environment [Field F] (names : List String) (inputs : List (Value Var)) + (assignment : Var → F) : + localsEnvironment (names.zip (inputs.map (Value.map ArithExpr.var))) assignment = + names.zip (inputs.map (Value.map assignment)) := by + induction names generalizing inputs with + | nil => simp [localsEnvironment] + | cons name names ih => + cases inputs with + | nil => simp [localsEnvironment] + | cons input inputs => + simp only [List.map_cons, List.zip_cons_cons] + change (name, _) :: localsEnvironment _ assignment = _ + rw [ih] + simp only [Value.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] + +/-- One compiled chip recovers its source body using its enabled messages as call premises. -/ +theorem lowerFunction_sound [Field F] [DecidableEq F] + {program : Program F} {fn : Function F} {chip : Chip F} + (compiled : lowerFunction program fn = .ok chip) + {calls : CallRelation F} {row : Row F} (valid : chip.ValidRow row) + (premises : ∀ message ∈ chip.premises row, + calls message.channel message.args message.result) : + EvalExprWith calls ((fn.params.map Prod.fst).zip (chip.receive row).args) fn.body + (chip.receive row).result := by + obtain ⟨inputs, output, s₁, s₂, body, s₃, s₄, _, _, bodyRun, outputRun, rfl⟩ := + lowerFunction_stages compiled + have stateValid : s₄.Valid calls row.assignment := ⟨valid.2.2, + (Chip.premises_forall _ row (fun message => + calls message.channel message.args message.result)).mp premises⟩ + obtain ⟨s₃Valid, resultEq⟩ := constrainValue_sound outputRun stateValid + have evaluated := (lowerExpr_sound bodyRun s₃Valid).2 rfl + have result := resultEq rfl + simp only [Value.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] at result + change output.map row.assignment = body.map (ArithExpr.denote row.assignment) at result + simpa only [parameter_environment, Chip.receive, result] using evaluated + +end Compiler +end Aiur.Tuple.Circuit diff --git a/Aiur/Aiur/Tuple/Circuit/LocalWitness.lean b/Aiur/Aiur/Tuple/Circuit/LocalWitness.lean new file mode 100644 index 000000000..a3cd6d681 --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit/LocalWitness.lean @@ -0,0 +1,79 @@ +import Aiur.Tuple.Circuit.ExpressionWitness +import Aiur.Tuple.Circuit.LocalCorrectness +import Aiur.Tuple.Circuit.RowWitness + +namespace Aiur.Tuple.Circuit.Compiler + +private theorem parameter_types (params : List (String × Ty)) (args : List (Value F)) + (types : params.map Prod.snd = args.map Value.type) : + environmentTypes ((params.map Prod.fst).zip args) = params := by + induction params generalizing args with + | nil => cases args <;> simp_all [environmentTypes] + | cons param params ih => + cases args with + | nil => simp at types + | cons arg args => + simp only [List.map_cons, List.cons.injEq] at types + simp only [List.map_cons, List.zip_cons_cons, environmentTypes, List.map_cons] + rw [← types.1] + exact congrArg (param :: ·) (ih args types.2) + +private theorem parameter_bounded {names : List String} {inputs : List (Value Var)} {bound : Nat} + (bounded : ∀ input ∈ inputs, Bounded (F := F) bound (input.map ArithExpr.var)) : + LocalsBounded (F := F) bound (names.zip (inputs.map (Value.map ArithExpr.var))) := by + intro binding member + obtain ⟨_, inside⟩ := List.of_mem_zip member + obtain ⟨input, member, same⟩ := List.mem_map.mp inside + rw [← same] + exact bounded input member + +/-- A finite source body evaluation yields a finite chip row, with exactly its enabled premises. -/ +theorem lowerFunction_complete [Field F] [DecidableEq F] + {program : Program F} {fn : Function F} {chip : Chip F} + (compiled : lowerFunction program fn = .ok chip) + {calls : CallRelation F} (typed : CallsTyped program calls) + (checked : inferType program fn.name fn.params fn.body = .ok fn.result) + {args : List (Value F)} {value : Value F} + (types : fn.params.map Prod.snd = args.map Value.type) + (evaluated : EvalExprWith calls ((fn.params.map Prod.fst).zip args) fn.body value) : + ∃ row, row.chip = fn.name ∧ chip.ValidRow row ∧ chip.receive row = ⟨fn.name, args, value⟩ ∧ + ∀ message ∈ chip.premises row, calls message.channel message.args message.result := by + have resultType : value.type = fn.result := + evaluated.type typed fn.name fn.result (by rw [parameter_types fn.params args types]; exact checked) + obtain ⟨inputs, output, s₁, s₂, body, s₃, s₄, inputsRun, outputRun, bodyRun, constraintRun, rfl⟩ := + lowerFunction_stages compiled + have emptyLayout : ({} : BuildState F).WellFormed := ⟨by simp, by simp⟩ + have emptyValid : ({} : BuildState F).Valid calls (fun _ => 0) := ⟨by simp [Satisfies, Scalar.Circuit.Satisfies], by simp⟩ + obtain ⟨a, e₁, inputsBound, inputsEq⟩ := freshValues_complete inputsRun emptyLayout emptyValid args types.symm + obtain ⟨b, e₂, outputBound, outputEq⟩ := freshValue_complete outputRun e₁.layout e₁.valid value resultType + have inputsEqB : inputs.map (Value.map b) = args := by + rw [← inputsEq] + exact List.map_congr_left (fun input member => e₂.variables (inputsBound input member)) + obtain ⟨c, e₃, bodyBound, bodyEq⟩ := lowerExpr_complete bodyRun typed e₂.layout e₂.valid + (parameter_bounded (fun input member => (inputsBound input member).mono e₂.increase)) rfl rfl + (by rw [parameter_environment, inputsEqB]; exact evaluated) + have resultEq : (output.map ArithExpr.var).map (ArithExpr.denote c) = value := by + simpa only [Value.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using (e₃.variables outputBound).trans outputEq + have e₄ := constrainValue_complete constraintRun e₃.layout e₃.valid rfl + (outputBound.mono e₃.increase) bodyBound (Or.inr (resultEq.trans bodyEq.symm)) + let row := Row.ofAssignment fn.name s₄.nextVar c + have finiteExt := BuildState.finite_witness e₄.layout e₄.valid fn.name + have inputFinal : ∀ input ∈ inputs, Bounded (F := F) s₄.nextVar (input.map ArithExpr.var) := + fun input member => (inputsBound input member).mono ((e₂.trans e₃).trans e₄).increase + have outputFinal := outputBound.mono (e₃.trans e₄).increase + have rowValid : (Chip.mk fn.name inputs output s₄.nextVar s₄.constraints.toList s₄.sends.toList).ValidRow row := + ⟨chip_wellFormed e₄.layout inputFinal outputFinal, Row.ofAssignment_length _ _ _, finiteExt.valid.constraints⟩ + refine ⟨row, rfl, rowValid, ?_, ?_⟩ + · change Message.mk fn.name (inputs.map (Value.map row.assignment)) (output.map row.assignment) = _ + have ins : inputs.map (Value.map row.assignment) = args := by + rw [← inputsEq] + apply List.map_congr_left + intro input member + exact (((e₂.trans e₃).trans e₄).trans finiteExt).variables (inputsBound input member) + have out : output.map row.assignment = value := + (((e₃.trans e₄).trans finiteExt).variables outputBound).trans outputEq + rw [ins, out] + · exact (Chip.premises_forall _ row (fun message => + calls message.channel message.args message.result)).mpr finiteExt.valid.calls + +end Aiur.Tuple.Circuit.Compiler diff --git a/Aiur/Aiur/Tuple/Circuit/MemoAcyclic.lean b/Aiur/Aiur/Tuple/Circuit/MemoAcyclic.lean new file mode 100644 index 000000000..869b0fc6e --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit/MemoAcyclic.lean @@ -0,0 +1,47 @@ +import Aiur.Tuple.Circuit.MemoDerivation +import Mathlib.Data.Fintype.Card +import Mathlib.Data.Fintype.Fin +import Mathlib.Logic.Relation +import Mathlib.Order.WellFounded + +namespace Aiur.Tuple.Circuit.MemoDerivation + +variable [Field F] [DecidableEq F] {system : System F} {message : Message F} + +/-- An enabled premise of `parent` is supplied by `child`, oriented for induction. -/ +def Dependency (graph : MemoDerivation system message) (child parent : Fin graph.size) : Prop := + ∃ j : Fin (graph.node parent).premises.length, graph.target parent j = child + +/-- No node lies on a nonempty directed path back to itself. Sharing is allowed. -/ +def Acyclic (graph : MemoDerivation system message) : Prop := + ∀ i, ¬ Relation.TransGen graph.Dependency i i + +/-- On the finite node set, the absence of directed cycles permits dependency induction. -/ +theorem Acyclic.wellFounded {graph : MemoDerivation system message} + (acyclic : graph.Acyclic) : WellFounded graph.Dependency := by + letI : Std.Irrefl (Relation.TransGen graph.Dependency) := ⟨acyclic⟩ + exact (Finite.wellFounded_of_trans_of_irrefl (Relation.TransGen graph.Dependency)).mono + (fun _ _ edge => .single edge) + +/-- Unfold the dependencies of any node into a finite, closed derivation tree. -/ +theorem node_derives_of_acyclic (graph : MemoDerivation system message) + (acyclic : graph.Acyclic) (i : Fin graph.size) : + Derives system (graph.node i).conclusion := by + induction i using acyclic.wellFounded.induction with + | h i ih => + have premises : ∀ premise ∈ (graph.node i).premises, Derives system premise := by + intro premise member + obtain ⟨j, bounded, same⟩ := List.mem_iff_getElem.mp member + have child := ih (graph.target i ⟨j, bounded⟩) ⟨⟨j, bounded⟩, rfl⟩ + rwa [(graph.target_claim i ⟨j, bounded⟩).trans same] at child + obtain ⟨children⟩ := derivations_nonempty_iff.mpr premises + exact ⟨.node (graph.node i).chip (graph.node i).row + (graph.node i).lookup (graph.node i).valid children⟩ + +/-- An acyclic memoized graph supplies an ordinary derivation of its root claim. -/ +theorem derives_of_acyclic (graph : MemoDerivation system message) + (acyclic : graph.Acyclic) : Derives system message := by + rw [← graph.root_claim] + exact graph.node_derives_of_acyclic acyclic graph.root + +end Aiur.Tuple.Circuit.MemoDerivation diff --git a/Aiur/Aiur/Tuple/Circuit/MemoDerivation.lean b/Aiur/Aiur/Tuple/Circuit/MemoDerivation.lean new file mode 100644 index 000000000..1d538bbf7 --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit/MemoDerivation.lean @@ -0,0 +1,149 @@ +import Aiur.Tuple.Circuit.Derivation + +namespace Aiur.Tuple.Circuit + +/-- One locally checked rule instance, without proofs of its call premises. -/ +structure RuleInstance [Field F] (system : System F) where + chip : Chip F + row : Row F + lookup : system.findChip? row.chip = some chip + valid : chip.ValidRow row + +def RuleInstance.conclusion [Field F] {system : System F} + (rule : RuleInstance system) : Message F := rule.chip.receive rule.row + +def RuleInstance.premises [Field F] [DecidableEq F] {system : System F} + (rule : RuleInstance system) : List (Message F) := rule.chip.premises rule.row + +/-- +A finite graph of locally valid rules. Every enabled call has an explicit target +with the required conclusion. References may be shared or cyclic, including self-references. +There is no ordering, rank, multiplicity, or source-termination condition. +-/ +structure MemoDerivation [Field F] [DecidableEq F] (system : System F) + (message : Message F) where + size : Nat + node : Fin size → RuleInstance system + root : Fin size + root_claim : (node root).conclusion = message + target : (i : Fin size) → Fin (node i).premises.length → Fin size + target_claim : ∀ i j, (node (target i j)).conclusion = (node i).premises[j] + +/-- Memoized acceptance asserts the existence of a finite, possibly cyclic graph. -/ +def MemoDerives [Field F] [DecidableEq F] (system : System F) (message : Message F) : Prop := + Nonempty (MemoDerivation system message) + +def MemoAccepts [Field F] [DecidableEq F] (system : System F) + (function : String) (args : List (Value F)) (result : Value F) : Prop := + MemoDerives system ⟨function, args, result⟩ + +/-- The claims represented anywhere in a graph, including its root. -/ +def MemoDerivation.Claims [Field F] [DecidableEq F] {system : System F} {message : Message F} + (graph : MemoDerivation system message) (claim : Message F) : Prop := + ∃ i, (graph.node i).conclusion = claim + +theorem MemoDerivation.root_mem [Field F] [DecidableEq F] + {system : System F} {message : Message F} (graph : MemoDerivation system message) : + graph.Claims message := ⟨graph.root, graph.root_claim⟩ + +theorem MemoDerivation.premise_mem [Field F] [DecidableEq F] + {system : System F} {message : Message F} (graph : MemoDerivation system message) + (i : Fin graph.size) {premise : Message F} (member : premise ∈ (graph.node i).premises) : + graph.Claims premise := by + obtain ⟨j, bounded, same⟩ := List.mem_iff_getElem.mp member + exact ⟨graph.target i ⟨j, bounded⟩, (graph.target_claim i ⟨j, bounded⟩).trans same⟩ + +/-- Build explicit references from a finite table closed under call premises. -/ +noncomputable def MemoDerivation.ofClosed [Field F] [DecidableEq F] + {system : System F} {message : Message F} (rules : List (RuleInstance system)) + (root : ∃ rule ∈ rules, rule.conclusion = message) + (closed : ∀ rule ∈ rules, ∀ premise ∈ rule.premises, + ∃ provider ∈ rules, provider.conclusion = premise) : MemoDerivation system message := by + have locate {claim : Message F} (present : ∃ rule ∈ rules, rule.conclusion = claim) : + ∃ i : Fin rules.length, rules[i].conclusion = claim := by + obtain ⟨rule, member, conclusion⟩ := present + obtain ⟨i, bounded, same⟩ := List.mem_iff_getElem.mp member + exact ⟨⟨i, bounded⟩, by simpa [same] using conclusion⟩ + let rootIndex := Classical.choose (locate root) + have targets (i : Fin rules.length) (j : Fin rules[i].premises.length) : + ∃ target : Fin rules.length, rules[target].conclusion = rules[i].premises[j] := + locate (closed rules[i] (List.getElem_mem _) _ (List.getElem_mem _)) + exact { + size := rules.length + node := fun i => rules[i] + root := rootIndex + root_claim := Classical.choose_spec (locate root) + target := fun i j => Classical.choose (targets i j) + target_claim := fun i j => Classical.choose_spec (targets i j) + } + +mutual + /-- Keep each tree occurrence as a locally valid graph node. -/ + def Derivation.instances [Field F] [DecidableEq F] {system : System F} {message : Message F} : + Derivation system message → List (RuleInstance system) + | .node chip row lookup valid children => ⟨chip, row, lookup, valid⟩ :: children.instances + + def Derivations.instances [Field F] [DecidableEq F] {system : System F} {messages : List (Message F)} : + Derivations system messages → List (RuleInstance system) + | .nil => [] + | .cons head tail => head.instances ++ tail.instances +end + +theorem Derivation.root_instance [Field F] [DecidableEq F] + {system : System F} {message : Message F} (tree : Derivation system message) : + ∃ rule ∈ tree.instances, rule.conclusion = message := by + cases tree with + | node chip row lookup valid children => exact ⟨⟨chip, row, lookup, valid⟩, by simp [instances], rfl⟩ + +theorem Derivations.root_instances [Field F] [DecidableEq F] + {system : System F} {messages : List (Message F)} (trees : Derivations system messages) : + ∀ message ∈ messages, ∃ rule ∈ trees.instances, rule.conclusion = message := by + cases trees with + | nil => simp + | cons head tail => + intro message member + rcases List.mem_cons.mp member with rfl | member + · obtain ⟨rule, present, conclusion⟩ := head.root_instance + exact ⟨rule, by simp [instances, present], conclusion⟩ + · obtain ⟨rule, present, conclusion⟩ := tail.root_instances message member + exact ⟨rule, by simp [instances, present], conclusion⟩ +termination_by structural trees + +theorem Derivation.instances_closed [Field F] [DecidableEq F] + {system : System F} {message : Message F} (tree : Derivation system message) : + ∀ rule ∈ tree.instances, ∀ premise ∈ rule.premises, + ∃ provider ∈ tree.instances, provider.conclusion = premise := by + induction tree using Derivation.rec + (motive_2 := fun messages (trees : Derivations system messages) => + ∀ (rule : RuleInstance system), rule ∈ trees.instances → ∀ premise ∈ rule.premises, + ∃ provider ∈ trees.instances, provider.conclusion = premise) with + | node chip row lookup valid children ih => + intro rule member premise required + simp only [instances, List.mem_cons] at member + rcases member with rfl | member + · obtain ⟨provider, present, conclusion⟩ := children.root_instances premise required + exact ⟨provider, by simp [instances, present], conclusion⟩ + · obtain ⟨provider, present, conclusion⟩ := ih rule member premise required + exact ⟨provider, by simp [instances, present], conclusion⟩ + | nil => rename_i rule member premise required; simp [Derivations.instances] at member + | cons head tail headIH tailIH => + rename_i rule member premise required + simp only [Derivations.instances, List.mem_append] at member + rcases member with member | member + · obtain ⟨provider, present, conclusion⟩ := headIH rule member premise required + exact ⟨provider, by simp [Derivations.instances, present], conclusion⟩ + · obtain ⟨provider, present, conclusion⟩ := tailIH rule member premise required + exact ⟨provider, by simp [Derivations.instances, present], conclusion⟩ + +/-- Every ordinary derivation supplies a memoized graph; cycles are not required. -/ +noncomputable def Derivation.toMemo [Field F] [DecidableEq F] + {system : System F} {message : Message F} (tree : Derivation system message) : + MemoDerivation system message := + .ofClosed tree.instances tree.root_instance tree.instances_closed + +theorem Derives.memo [Field F] [DecidableEq F] {system : System F} {message : Message F} + (derives : Derives system message) : MemoDerives system message := by + obtain ⟨tree⟩ := derives + exact ⟨tree.toMemo⟩ + +end Aiur.Tuple.Circuit diff --git a/Aiur/Aiur/Tuple/Circuit/PatternCorrectness.lean b/Aiur/Aiur/Tuple/Circuit/PatternCorrectness.lean new file mode 100644 index 000000000..968688fe1 --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit/PatternCorrectness.lean @@ -0,0 +1,102 @@ +import Aiur.Tuple.Circuit.BuildFacts +import Aiur.Tuple.Circuit.PatternFacts + +namespace Aiur.Tuple.Circuit.Compiler + +theorem equalIndicator_sound [Field F] [DecidableEq F] + {difference test : ArithExpr F} {before after : BuildState F} + (compiled : equalIndicator difference before = .ok (test, after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid calls assignment) : + before.Valid calls assignment ∧ + test.denote assignment = if difference.denote assignment = 0 then 1 else 0 := by + simp [equalIndicator, StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at compiled + obtain ⟨rfl, rfl⟩ := compiled + refine ⟨valid.of_subset (fun _ member => by simp [member]) (fun _ member => member), ?_⟩ + apply equality_indicator_sound + · exact valid.constraints (.mul difference (.var before.nextVar)) (by simp) + · exact valid.constraints + (.sub (.mul difference (.var (before.nextVar + 1))) + (.sub (.const 1) (.var before.nextVar))) (by simp) + +/-- A test records both exact matching and the environment collected by the pattern. -/ +def PatternTest [Field F] (matched : Option (Environment F)) (test : F) + (bindings : Environment F) : Prop := + (matched = some bindings ∧ test = 1) ∨ (matched = none ∧ test = 0) + +mutual + /-- The actual recursive lowering computes the whole pattern's exact indicator and bindings. -/ + theorem lowerPattern_sound [Field F] [DecidableEq F] + {pattern : Pattern F} {value : Symbolic F} {test : ArithExpr F} {bindings : Locals F} + {before after : BuildState F} + (compiled : lowerPattern pattern value before = .ok ((test, bindings), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid calls assignment) : + before.Valid calls assignment ∧ PatternTest + (pattern.bindings (value.map (ArithExpr.denote assignment))) + (test.denote assignment) (localsEnvironment bindings assignment) := by + cases pattern with + | wildcard => + simp only [lowerPattern, pure_ok, Prod.mk.injEq] at compiled + rcases compiled with ⟨⟨rfl, rfl⟩, rfl⟩ + exact ⟨valid, Or.inl ⟨by simp [Pattern.bindings, localsEnvironment], rfl⟩⟩ + | bind name => + simp only [lowerPattern, pure_ok, Prod.mk.injEq] at compiled + rcases compiled with ⟨⟨rfl, rfl⟩, rfl⟩ + exact ⟨valid, Or.inl ⟨by simp [Pattern.bindings, localsEnvironment], rfl⟩⟩ + | literal literal => + cases value with + | tuple values => simp [lowerPattern] at compiled + | field value => + simp only [lowerPattern] at compiled + obtain ⟨test, middle, tested, finished⟩ := bind_ok.mp compiled + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp finished + obtain ⟨valid, exactTest⟩ := equalIndicator_sound tested valid + refine ⟨valid, ?_⟩ + by_cases same : literal = value.denote assignment + · exact Or.inl ⟨by simp [Value.map, Pattern.bindings, same, localsEnvironment], + by simpa [ArithExpr.denote, Scalar.Circuit.ArithExpr.denote, same] using exactTest⟩ + · exact Or.inr ⟨by simp [Value.map, Pattern.bindings, same], + by simpa [ArithExpr.denote, Scalar.Circuit.ArithExpr.denote, + sub_eq_zero, Ne.symm same] using exactTest⟩ + | tuple patterns => + cases value with + | field value => simp [lowerPattern] at compiled + | tuple values => + simp only [lowerPattern] at compiled + simpa only [Value.map, Pattern.bindings] using lowerPatterns_sound compiled valid + termination_by sizeOf pattern + + theorem lowerPatterns_sound [Field F] [DecidableEq F] + {patterns : List (Pattern F)} {values : List (Symbolic F)} + {test : ArithExpr F} {bindings : Locals F} {before after : BuildState F} + (compiled : lowerPatterns patterns values before = .ok ((test, bindings), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid calls assignment) : + before.Valid calls assignment ∧ PatternTest + (Pattern.bindingsList patterns (values.map (Value.map (ArithExpr.denote assignment)))) + (test.denote assignment) (localsEnvironment bindings assignment) := by + cases patterns with + | nil => + cases values with + | nil => + simp only [lowerPatterns, pure_ok, Prod.mk.injEq] at compiled + rcases compiled with ⟨⟨rfl, rfl⟩, rfl⟩ + exact ⟨valid, Or.inl ⟨by simp [Pattern.bindingsList, localsEnvironment], rfl⟩⟩ + | cons => simp [lowerPatterns] at compiled + | cons pattern patterns => + cases values with + | nil => simp [lowerPatterns] at compiled + | cons value values => + simp only [lowerPatterns] at compiled + obtain ⟨⟨head, headBindings⟩, middle, headRun, rest⟩ := bind_ok.mp compiled + obtain ⟨⟨tail, tailBindings⟩, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp finished + obtain ⟨middleValid, tailTest⟩ := lowerPatterns_sound tailRun valid + obtain ⟨beforeValid, headTest⟩ := lowerPattern_sound headRun middleValid + refine ⟨beforeValid, ?_⟩ + rcases headTest with ⟨headMatch, headOne⟩ | ⟨headMatch, headZero⟩ <;> + rcases tailTest with ⟨tailMatch, tailOne⟩ | ⟨tailMatch, tailZero⟩ <;> + simp [PatternTest, Pattern.bindingsList, ArithExpr.denote, + Scalar.Circuit.ArithExpr.denote, localsEnvironment_append, *] + termination_by sizeOf patterns +end + +end Aiur.Tuple.Circuit.Compiler diff --git a/Aiur/Aiur/Tuple/Circuit/PatternFacts.lean b/Aiur/Aiur/Tuple/Circuit/PatternFacts.lean new file mode 100644 index 000000000..7b35435b7 --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit/PatternFacts.lean @@ -0,0 +1,22 @@ +import Aiur.Tuple.Circuit.Basic + +namespace Aiur.Tuple.Circuit + +/-- The equality-test equations determine the indicator in every field. -/ +theorem equality_indicator_sound [Field F] [DecidableEq F] {difference equal inverse : F} + (zero : difference * equal = 0) + (inverseEquation : difference * inverse - (1 - equal) = 0) : + equal = if difference = 0 then 1 else 0 := by + by_cases same : difference = 0 + · simp only [same, zero_mul, zero_sub, neg_eq_zero] at inverseEquation + simpa [same] using (sub_eq_zero.mp inverseEquation).symm + · simpa [same] using (mul_eq_zero.mp zero).resolve_left same + +/-- Every field difference has witnesses for the emitted equality-test equations. -/ +theorem equality_indicator_complete [Field F] [DecidableEq F] (difference : F) : + let equal : F := if difference = 0 then 1 else 0 + equal * (equal - 1) = 0 ∧ difference * equal = 0 ∧ + difference * difference⁻¹ - (1 - equal) = 0 := by + by_cases same : difference = 0 <;> simp [same] + +end Aiur.Tuple.Circuit diff --git a/Aiur/Aiur/Tuple/Circuit/PatternWitness.lean b/Aiur/Aiur/Tuple/Circuit/PatternWitness.lean new file mode 100644 index 000000000..cf45589fd --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit/PatternWitness.lean @@ -0,0 +1,179 @@ +import Aiur.Tuple.Circuit.ValueWitness + +namespace Aiur.Tuple.Circuit.Compiler + +theorem equalIndicator_complete [Field F] [DecidableEq F] + {difference test : ArithExpr F} {before after : BuildState F} + (compiled : equalIndicator difference before = .ok (test, after)) + {calls : CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid calls initial) + (bounded : difference.inBounds before.nextVar = true) : + ∃ assignment, Extension calls before after initial assignment ∧ + test.inBounds after.nextVar = true := by + simp [equalIndicator, StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at compiled + obtain ⟨rfl, rfl⟩ := compiled + let equal : F := if difference.denote initial = 0 then 1 else 0 + let assignment := Function.update (Function.update initial before.nextVar equal) + (before.nextVar + 1) (difference.denote initial)⁻¹ + have agree : ∀ id < before.nextVar, assignment id = initial id := by + intro id bound + simp [assignment, Function.update_of_ne (by omega : id ≠ before.nextVar + 1), + Function.update_of_ne (by omega : id ≠ before.nextVar)] + have dEq : difference.denote assignment = difference.denote initial := + Scalar.Circuit.ArithExpr.denote_eq_of_agree agree bounded + have eEq : assignment before.nextVar = equal := by simp [assignment] + have uEq : assignment (before.nextVar + 1) = (difference.denote initial)⁻¹ := by simp [assignment] + have equations := equality_indicator_complete (difference.denote initial) + have grown := layout.grow (by omega : before.nextVar ≤ before.nextVar + 1 + 1) + have db := Scalar.Circuit.ArithExpr.inBounds_mono + (by omega : before.nextVar ≤ before.nextVar + 1 + 1) bounded + have lo : before.nextVar < before.nextVar + 1 + 1 := by omega + have hi : before.nextVar + 1 < before.nextVar + 1 + 1 := by omega + have firstBound : (ArithExpr.mul (.var before.nextVar) + (.sub (.var before.nextVar) (.const (1 : F)))).inBounds (before.nextVar + 1 + 1) = true := by + simp [Scalar.Circuit.ArithExpr.inBounds, lo] + have secondBound : (ArithExpr.mul difference (.var before.nextVar)).inBounds + (before.nextVar + 1 + 1) = true := by + simp [Scalar.Circuit.ArithExpr.inBounds, lo, db] + have thirdBound : (ArithExpr.sub (.mul difference (.var (before.nextVar + 1))) + (.sub (.const 1) (.var before.nextVar))).inBounds (before.nextVar + 1 + 1) = true := by + simp [Scalar.Circuit.ArithExpr.inBounds, lo, hi, db] + have grownValid : ({ before with nextVar := before.nextVar + 1 + 1 } : BuildState F).Valid calls assignment := + ⟨(valid.of_agree layout agree).constraints, (valid.of_agree layout agree).calls⟩ + have firstZero : (ArithExpr.mul (.var before.nextVar) + (.sub (.var before.nextVar) (.const (1 : F)))).denote assignment = 0 := by + simpa only [ArithExpr.denote, Scalar.Circuit.ArithExpr.denote, eEq, equal] using equations.1 + have secondZero : (ArithExpr.mul difference (.var before.nextVar)).denote assignment = 0 := by + change difference.denote assignment * assignment before.nextVar = 0 + simpa only [dEq, eEq, equal] using equations.2.1 + have thirdZero : (ArithExpr.sub (.mul difference (.var (before.nextVar + 1))) + (.sub (.const 1) (.var before.nextVar))).denote assignment = 0 := by + change difference.denote assignment * assignment (before.nextVar + 1) - (1 - assignment before.nextVar) = 0 + simpa only [dEq, uEq, eEq, equal] using equations.2.2 + exact ⟨assignment, ⟨by dsimp; omega, agree, + ((grown.constrain firstBound).constrain secondBound).constrain thirdBound, + ((grownValid.constrain firstZero).constrain secondZero).constrain thirdZero⟩, + by simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using lo⟩ + +mutual + theorem lowerPattern_complete [Field F] [DecidableEq F] + {pattern : Pattern F} {value : Symbolic F} {test : ArithExpr F} {bindings : Locals F} + {before after : BuildState F} + (compiled : lowerPattern pattern value before = .ok ((test, bindings), after)) + {calls : CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid calls initial) + (bounded : Bounded before.nextVar value) : + ∃ assignment, Extension calls before after initial assignment ∧ + test.inBounds after.nextVar = true ∧ LocalsBounded after.nextVar bindings := by + cases pattern with + | wildcard => + simp only [lowerPattern, pure_ok, Prod.mk.injEq] at compiled + rcases compiled with ⟨⟨rfl, rfl⟩, rfl⟩ + exact ⟨initial, .refl layout valid, rfl, by simp [LocalsBounded]⟩ + | bind name => + simp only [lowerPattern, pure_ok, Prod.mk.injEq] at compiled + rcases compiled with ⟨⟨rfl, rfl⟩, rfl⟩ + exact ⟨initial, .refl layout valid, rfl, by simpa [LocalsBounded] using bounded⟩ + | literal literal => + cases value with + | tuple values => simp [lowerPattern] at compiled + | field value => + simp only [lowerPattern] at compiled + obtain ⟨test, middle, tested, finished⟩ := bind_ok.mp compiled + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp finished + obtain ⟨assignment, extension, bound⟩ := equalIndicator_complete tested layout valid + (by simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using bounded_field.mp bounded) + exact ⟨assignment, extension, bound, by simp [LocalsBounded]⟩ + | tuple patterns => + cases value with + | field value => simp [lowerPattern] at compiled + | tuple values => + simp only [lowerPattern] at compiled + exact lowerPatterns_complete compiled layout valid (bounded_tuple.mp bounded) + termination_by sizeOf pattern + + theorem lowerPatterns_complete [Field F] [DecidableEq F] + {patterns : List (Pattern F)} {values : List (Symbolic F)} + {test : ArithExpr F} {bindings : Locals F} {before after : BuildState F} + (compiled : lowerPatterns patterns values before = .ok ((test, bindings), after)) + {calls : CallRelation F} {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid calls initial) + (bounded : ∀ value ∈ values, Bounded before.nextVar value) : + ∃ assignment, Extension calls before after initial assignment ∧ + test.inBounds after.nextVar = true ∧ LocalsBounded after.nextVar bindings := by + cases patterns with + | nil => + cases values with + | nil => + simp only [lowerPatterns, pure_ok, Prod.mk.injEq] at compiled + rcases compiled with ⟨⟨rfl, rfl⟩, rfl⟩ + exact ⟨initial, .refl layout valid, rfl, by simp [LocalsBounded]⟩ + | cons => simp [lowerPatterns] at compiled + | cons pattern patterns => + cases values with + | nil => simp [lowerPatterns] at compiled + | cons value values => + simp only [lowerPatterns] at compiled + obtain ⟨⟨head, headBindings⟩, middle, headRun, rest⟩ := bind_ok.mp compiled + obtain ⟨⟨tail, tailBindings⟩, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp finished + obtain ⟨a, headExt, headBound, headLocals⟩ := + lowerPattern_complete headRun layout valid (bounded value (by simp)) + obtain ⟨b, tailExt, tailBound, tailLocals⟩ := lowerPatterns_complete tailRun + headExt.layout headExt.valid + (fun value member => (bounded value (by simp [member])).mono headExt.increase) + exact ⟨b, headExt.trans tailExt, by + simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + And.intro (Scalar.Circuit.ArithExpr.inBounds_mono tailExt.increase headBound) tailBound, + localsBounded_append.mpr ⟨headLocals.mono tailExt.increase, tailLocals⟩⟩ + termination_by sizeOf patterns +end + +mutual + theorem lowerPattern_irrefutable [Field F] {pattern : Pattern F} {value : Symbolic F} + {test : ArithExpr F} {bindings : Locals F} {before after : BuildState F} + (compiled : lowerPattern pattern value before = .ok ((test, bindings), after)) + (irrefutable : pattern.irrefutable = true) (assignment : Var → F) : test.denote assignment = 1 := by + cases pattern with + | wildcard | bind => + simp only [lowerPattern, pure_ok, Prod.mk.injEq] at compiled + rcases compiled with ⟨⟨rfl, rfl⟩, rfl⟩ + rfl + | literal => simp [Pattern.irrefutable] at irrefutable + | tuple patterns => + cases value with + | field => simp [lowerPattern] at compiled + | tuple values => + simp only [lowerPattern] at compiled + exact lowerPatterns_irrefutable compiled (by simpa [Pattern.irrefutable] using irrefutable) assignment + termination_by sizeOf pattern + + theorem lowerPatterns_irrefutable [Field F] {patterns : List (Pattern F)} {values : List (Symbolic F)} + {test : ArithExpr F} {bindings : Locals F} {before after : BuildState F} + (compiled : lowerPatterns patterns values before = .ok ((test, bindings), after)) + (irrefutable : ∀ pattern ∈ patterns, pattern.irrefutable = true) (assignment : Var → F) : + test.denote assignment = 1 := by + cases patterns with + | nil => + cases values with + | nil => + simp only [lowerPatterns, pure_ok, Prod.mk.injEq] at compiled + rcases compiled with ⟨⟨rfl, rfl⟩, rfl⟩ + rfl + | cons => simp [lowerPatterns] at compiled + | cons pattern patterns => + cases values with + | nil => simp [lowerPatterns] at compiled + | cons value values => + simp only [lowerPatterns] at compiled + obtain ⟨⟨head, headBindings⟩, middle, headRun, rest⟩ := bind_ok.mp compiled + obtain ⟨⟨tail, tailBindings⟩, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨⟨rfl, rfl⟩, rfl⟩ := pure_ok.mp finished + have headOne := lowerPattern_irrefutable headRun (irrefutable pattern (by simp)) assignment + have tailOne := lowerPatterns_irrefutable tailRun (fun p h => irrefutable p (by simp [h])) assignment + change head.denote assignment * tail.denote assignment = 1 + rw [headOne, tailOne, one_mul] + termination_by sizeOf patterns +end + +end Aiur.Tuple.Circuit.Compiler diff --git a/Aiur/Aiur/Tuple/Circuit/RowWitness.lean b/Aiur/Aiur/Tuple/Circuit/RowWitness.lean new file mode 100644 index 000000000..8fb0a7c7b --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit/RowWitness.lean @@ -0,0 +1,45 @@ +import Aiur.Tuple.Circuit.WitnessBasic +import Mathlib.Data.List.OfFn + +namespace Aiur.Tuple.Circuit + +/-- Store the allocated prefix of a witness assignment as a finite row. -/ +def Row.ofAssignment (name : String) (bound : Nat) (assignment : Var → F) : Row F := + ⟨name, List.ofFn (fun id : Fin bound => assignment id)⟩ + +@[simp] theorem Row.ofAssignment_length (name : String) (bound : Nat) (assignment : Var → F) : + (Row.ofAssignment name bound assignment).values.length = bound := by simp [Row.ofAssignment] + +theorem Row.ofAssignment_agree [Zero F] (name : String) (bound : Nat) (assignment : Var → F) + (id : Var) (inside : id < bound) : + (Row.ofAssignment name bound assignment).assignment id = assignment id := by + simp [Row.assignment, Scalar.Circuit.Row.assignment, Row.ofAssignment, inside] + +namespace Compiler + +@[simp] theorem bounded_vars {bound : Nat} {value : Value Var} : + Bounded (F := F) bound (value.map ArithExpr.var) ↔ ∀ id ∈ value.flatten, id < bound := by + simp [Bounded, Value.flatten_map, ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] + +theorem BuildState.finite_witness [Field F] {calls : CallRelation F} {state : BuildState F} + {assignment : Var → F} (layout : state.WellFormed) (valid : state.Valid calls assignment) + (name : String) : + Extension calls state state assignment (Row.ofAssignment name state.nextVar assignment).assignment := + ⟨le_rfl, Row.ofAssignment_agree _ _ _, layout, + valid.of_agree layout (Row.ofAssignment_agree _ _ _)⟩ + +theorem chip_wellFormed {name : String} {inputs : List (Value Var)} {output : Value Var} {state : BuildState F} + (layout : state.WellFormed) + (inputsBound : ∀ input ∈ inputs, Bounded (F := F) state.nextVar (input.map ArithExpr.var)) + (outputBound : Bounded (F := F) state.nextVar (output.map ArithExpr.var)) : + (Chip.mk name inputs output state.nextVar state.constraints.toList state.sends.toList).wellFormed = true := by + simp only [Chip.wellFormed, Bool.and_eq_true, List.all_eq_true, decide_eq_true_eq] + refine ⟨⟨?_, layout.constraints⟩, layout.sends⟩ + intro id member + rcases List.mem_append.mp member with member | member + · obtain ⟨input, member, leaf⟩ := List.mem_flatMap.mp member + exact bounded_vars.mp (inputsBound input member) id leaf + · exact bounded_vars.mp outputBound id member + +end Compiler +end Aiur.Tuple.Circuit diff --git a/Aiur/Aiur/Tuple/Circuit/SelectorWitness.lean b/Aiur/Aiur/Tuple/Circuit/SelectorWitness.lean new file mode 100644 index 000000000..932647c22 --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit/SelectorWitness.lean @@ -0,0 +1,71 @@ +import Aiur.Tuple.Circuit.PatternWitness +import Aiur.Scalar.Circuit.WitnessBasic + +namespace Aiur.Tuple.Circuit.Compiler + +private theorem excludeHead_complete [Field F] {calls : CallRelation F} + (selector : ArithExpr F) (rest : List (ArithExpr F)) {before after : BuildState F} + (compiled : (forIn rest PUnit.unit (fun other _ => do + constrain (.mul selector other) + pure (ForInStep.yield PUnit.unit)) : Build F PUnit) before = .ok (PUnit.unit, after)) {assignment : Var → F} + (layout : before.WellFormed) (valid : before.Valid calls assignment) + (headBound : selector.inBounds before.nextVar = true) + (tailBound : ∀ other ∈ rest, other.inBounds before.nextVar = true) + (zero : ∀ other ∈ rest, selector.denote assignment * other.denote assignment = 0) : + Extension calls before after assignment assignment := by + induction rest generalizing before with + | nil => + have same : before = after := by + simpa [List.forIn_nil, pure, StateT.pure, Except.pure] using compiled + subst after + exact .refl layout valid + | cons other rest ih => + simp only [List.forIn_cons] at compiled + simp [StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at compiled + have hb : (ArithExpr.mul selector other).inBounds before.nextVar = true := by + simp [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] at headBound ⊢ + exact ⟨headBound, tailBound other (by simp)⟩ + have extension := ih compiled (layout.constrain hb) + (valid.constrain (zero other (by simp))) headBound + (fun p h => tailBound p (by simp [h])) (fun p h => zero p (by simp [h])) + exact ⟨extension.increase, extension.agree, extension.layout, extension.valid⟩ + +theorem excludePairs_complete [Field F] {calls : CallRelation F} + {selectors : List (ArithExpr F)} {before after : BuildState F} + (compiled : excludePairs selectors before = .ok ((), after)) {assignment : Var → F} + (layout : before.WellFormed) (valid : before.Valid calls assignment) + (bounded : ∀ selector ∈ selectors, selector.inBounds before.nextVar = true) + (exclusive : (selectors.map (ArithExpr.denote assignment)).Pairwise (fun x y => x * y = 0)) : + Extension calls before after assignment assignment := by + induction selectors generalizing before with + | nil => + simp only [excludePairs, pure_ok, true_and] at compiled + subst after + exact .refl layout valid + | cons selector rest ih => + simp only [excludePairs] at compiled + obtain ⟨finished, middle, pairs, restRun⟩ := bind_ok.mp compiled + cases finished + simp only [List.map_cons, List.pairwise_cons, List.forall_mem_map] at exclusive + have headExt := excludeHead_complete selector rest pairs layout valid + (bounded selector (by simp)) (fun p h => bounded p (by simp [h])) exclusive.1 + have tailExt := ih restRun headExt.layout headExt.valid + (fun p h => headExt.bound (bounded p (by simp [h]))) exclusive.2 + exact headExt.trans tailExt + +theorem sum_complete [Field F] {calls : CallRelation F} + {selectors : List (ArithExpr F)} {enable : ArithExpr F} {before after : BuildState F} + (compiled : constrain (.sub (selectors.foldl ArithExpr.add (.const 0)) enable) before = .ok ((), after)) + {assignment : Var → F} (layout : before.WellFormed) (valid : before.Valid calls assignment) + (bounded : ∀ selector ∈ selectors, selector.inBounds before.nextVar = true) + (enableBound : enable.inBounds before.nextVar = true) + (sum : (selectors.map (ArithExpr.denote assignment)).sum = enable.denote assignment) : + Extension calls before after assignment assignment := by + apply constrain_complete compiled layout valid + · simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + And.intro (Scalar.Circuit.Compiler.foldl_add_inBounds (initial := .const (0 : F)) rfl bounded) enableBound + · simp only [ArithExpr.denote, Scalar.Circuit.ArithExpr.denote, + Scalar.Circuit.ArithExpr.denote_foldl_add, zero_add, sub_eq_zero] + exact sum + +end Aiur.Tuple.Circuit.Compiler diff --git a/Aiur/Aiur/Tuple/Circuit/ValueCorrectness.lean b/Aiur/Aiur/Tuple/Circuit/ValueCorrectness.lean new file mode 100644 index 000000000..de07529b7 --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit/ValueCorrectness.lean @@ -0,0 +1,91 @@ +import Aiur.Tuple.Circuit.BuildFacts + +namespace Aiur.Tuple.Circuit.Compiler + +mutual + /-- Guarded leaf equalities imply equality of the complete structured values. -/ + theorem constrainValue_sound [Field F] {enable : ArithExpr F} {left right : Symbolic F} + {before after : BuildState F} + (compiled : constrainValue enable left right before = .ok ((), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid calls assignment) : + before.Valid calls assignment ∧ (enable.denote assignment = 1 → + left.map (ArithExpr.denote assignment) = right.map (ArithExpr.denote assignment)) := by + cases left with + | field left => + cases right with + | tuple => simp [constrainValue] at compiled + | field right => + simp only [constrainValue, guarded] at compiled + obtain ⟨beforeValid, equation⟩ := constrain_valid compiled valid + refine ⟨beforeValid, fun active => ?_⟩ + change enable.denote assignment * (left.denote assignment - right.denote assignment) = 0 + at equation + simp only [active, one_mul, sub_eq_zero] at equation + simp [Value.map, equation] + | tuple left => + cases right with + | field => simp [constrainValue] at compiled + | tuple right => + simp only [constrainValue] at compiled + obtain ⟨beforeValid, equal⟩ := constrainValues_sound compiled valid + exact ⟨beforeValid, fun active => by simp only [Value.map, equal active]⟩ + termination_by sizeOf left + + theorem constrainValues_sound [Field F] {enable : ArithExpr F} + {left right : List (Symbolic F)} {before after : BuildState F} + (compiled : constrainValues enable left right before = .ok ((), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid calls assignment) : + before.Valid calls assignment ∧ (enable.denote assignment = 1 → + left.map (Value.map (ArithExpr.denote assignment)) = + right.map (Value.map (ArithExpr.denote assignment))) := by + cases left with + | nil => + cases right with + | nil => + simp only [constrainValues, pure_ok, true_and] at compiled + subst after + exact ⟨valid, fun _ => rfl⟩ + | cons => simp [constrainValues] at compiled + | cons left ls => + cases right with + | nil => simp [constrainValues] at compiled + | cons right rs => + simp only [constrainValues] at compiled + obtain ⟨finished, middle, headRun, tailRun⟩ := bind_ok.mp compiled + cases finished + obtain ⟨middleValid, tailEq⟩ := constrainValues_sound tailRun valid + obtain ⟨beforeValid, headEq⟩ := constrainValue_sound headRun middleValid + exact ⟨beforeValid, fun active => by simp [headEq active, tailEq active]⟩ + termination_by sizeOf left +end + +/-- Exclusion equations only add constraints, so earlier validity can be recovered. -/ +theorem excludePairs_valid [Field F] {selectors : List (ArithExpr F)} + {before after : BuildState F} + (compiled : excludePairs selectors before = .ok ((), after)) + {calls : CallRelation F} {assignment : Var → F} (valid : after.Valid calls assignment) : + before.Valid calls assignment := by + induction selectors generalizing before with + | nil => + simp only [excludePairs, pure_ok, true_and] at compiled + subst after + exact valid + | cons selector rest ih => + simp only [excludePairs] at compiled + obtain ⟨finished, middle, pairs, restRun⟩ := bind_ok.mp compiled + cases finished + have middleValid := ih restRun + clear ih restRun compiled valid + induction rest generalizing before with + | nil => + simpa [List.forIn_nil, pure, StateT.pure, Except.pure] using + (show before.Valid calls assignment from by + have same : before = middle := by simpa [List.forIn_nil, pure, StateT.pure, Except.pure] using pairs + simpa [same] using middleValid) + | cons other rest ih => + simp only [List.forIn_cons] at pairs + simp [StateT.bind, bind, Except.bind, StateT.pure, pure, Except.pure] at pairs + have previous := ih pairs + exact previous.of_subset (fun _ member => by simp [member]) (fun _ member => member) + +end Aiur.Tuple.Circuit.Compiler diff --git a/Aiur/Aiur/Tuple/Circuit/ValueWitness.lean b/Aiur/Aiur/Tuple/Circuit/ValueWitness.lean new file mode 100644 index 000000000..b655ab76b --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit/ValueWitness.lean @@ -0,0 +1,180 @@ +import Aiur.Tuple.Circuit.WitnessBasic + +namespace Aiur.Tuple.Circuit.Compiler + +set_option maxHeartbeats 1000000 + +def zeroValue [Zero F] : Ty → Value F + | .field => .field 0 + | .tuple types => .tuple (types.map zeroValue) +termination_by type => sizeOf type + +@[simp] theorem zeroValue_type [Zero F] (type : Ty) : (zeroValue (F := F) type).type = type := by + cases type with + | field => simp [zeroValue, Value.type] + | tuple types => + simp only [zeroValue, Value.type, List.map_map, Ty.tuple.injEq] + conv_rhs => rw [← List.map_id types] + apply List.map_congr_left + intro type member + exact zeroValue_type type +termination_by sizeOf type +decreasing_by + simp_wf + have := List.sizeOf_lt_of_mem ‹_ ∈ _› + omega + +mutual + /-- Every value of the declared shape can be assigned to its fresh field leaves. -/ + theorem freshValue_complete [Field F] {calls : CallRelation F} {before after : BuildState F} + {type : Ty} {vars : Value Var} + (compiled : freshValue type before = .ok (vars, after)) {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid calls initial) + (value : Value F) (shape : value.type = type) : + ∃ assignment, Extension calls before after initial assignment ∧ + Bounded (F := F) after.nextVar (vars.map ArithExpr.var) ∧ vars.map assignment = value := by + cases type with + | field => + cases value with + | tuple => simp [Value.type] at shape + | field value => + simp only [freshValue] at compiled + obtain ⟨id, middle, allocated, finished⟩ := bind_ok.mp compiled + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨assignment, extension, bound, assigned⟩ := fresh_complete allocated layout valid value + exact ⟨assignment, extension, by + simpa [Value.map, ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using bound, + by simp [Value.map, assigned]⟩ + | tuple types => + cases value with + | field => simp [Value.type] at shape + | tuple values => + simp only [Value.type, Ty.tuple.injEq] at shape + simp only [freshValue] at compiled + obtain ⟨vars, middle, allocated, finished⟩ := bind_ok.mp compiled + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨assignment, extension, bound, assigned⟩ := + freshValues_complete allocated layout valid values shape + exact ⟨assignment, extension, by simpa [Value.map] using bound, + by simp only [Value.map, assigned]⟩ + termination_by sizeOf type + decreasing_by all_goals simp_all only [Ty.tuple.sizeOf_spec]; all_goals omega + + theorem freshValues_complete [Field F] {calls : CallRelation F} {before after : BuildState F} + {types : List Ty} {vars : List (Value Var)} + (compiled : freshValues types before = .ok (vars, after)) {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid calls initial) + (values : List (Value F)) (shape : values.map Value.type = types) : + ∃ assignment, Extension calls before after initial assignment ∧ + (∀ value ∈ vars, Bounded (F := F) after.nextVar (value.map ArithExpr.var)) ∧ + vars.map (Value.map assignment) = values := by + cases types with + | nil => + cases values with + | cons => simp at shape + | nil => + simp only [freshValues, pure_ok] at compiled + obtain ⟨rfl, rfl⟩ := compiled + exact ⟨initial, .refl layout valid, by simp, rfl⟩ + | cons type types => + cases values with + | nil => simp at shape + | cons value values => + simp only [List.map_cons, List.cons.injEq] at shape + simp only [freshValues] at compiled + obtain ⟨head, middle, headRun, rest⟩ := bind_ok.mp compiled + obtain ⟨tail, last, tailRun, finished⟩ := bind_ok.mp rest + obtain ⟨rfl, rfl⟩ := pure_ok.mp finished + obtain ⟨a, headExt, headBound, headValue⟩ := freshValue_complete headRun layout valid value shape.1 + obtain ⟨b, tailExt, tailBound, tailValue⟩ := + freshValues_complete tailRun headExt.layout headExt.valid values shape.2 + refine ⟨b, headExt.trans tailExt, ?_, ?_⟩ + · intro tree member + rcases List.mem_cons.mp member with rfl | member + · exact headBound.mono tailExt.increase + · exact tailBound tree member + · simp only [List.map_cons, tailExt.variables headBound, headValue, tailValue] + termination_by sizeOf types + decreasing_by all_goals simp_all only [List.cons.sizeOf_spec]; all_goals omega +end + +mutual + theorem constrainValue_complete [Field F] {calls : CallRelation F} + {enable : ArithExpr F} {left right : Symbolic F} {before after : BuildState F} + (compiled : constrainValue enable left right before = .ok ((), after)) {assignment : Var → F} + (layout : before.WellFormed) (valid : before.Valid calls assignment) + (enableBound : enable.inBounds before.nextVar = true) + (leftBound : Bounded before.nextVar left) (rightBound : Bounded before.nextVar right) + (equal : enable.denote assignment = 0 ∨ + left.map (ArithExpr.denote assignment) = right.map (ArithExpr.denote assignment)) : + Extension calls before after assignment assignment := by + cases left with + | field left => + cases right with + | tuple => simp [constrainValue] at compiled + | field right => + simp only [constrainValue, guarded] at compiled + apply constrain_complete compiled layout valid + · simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using + And.intro enableBound (And.intro (bounded_field.mp leftBound) (bounded_field.mp rightBound)) + · change enable.denote assignment * (left.denote assignment - right.denote assignment) = 0 + rcases equal with disabled | equal + · simp [disabled] + · simp only [Value.map, Value.field.injEq] at equal + simp [equal] + | tuple left => + cases right with + | field => simp [constrainValue] at compiled + | tuple right => + simp only [constrainValue] at compiled + apply constrainValues_complete compiled layout valid enableBound + (bounded_tuple.mp leftBound) (bounded_tuple.mp rightBound) + simpa only [Value.map, Value.tuple.injEq] using equal + termination_by sizeOf left + + theorem constrainValues_complete [Field F] {calls : CallRelation F} + {enable : ArithExpr F} {left right : List (Symbolic F)} {before after : BuildState F} + (compiled : constrainValues enable left right before = .ok ((), after)) {assignment : Var → F} + (layout : before.WellFormed) (valid : before.Valid calls assignment) + (enableBound : enable.inBounds before.nextVar = true) + (leftBound : ∀ value ∈ left, Bounded before.nextVar value) + (rightBound : ∀ value ∈ right, Bounded before.nextVar value) + (equal : enable.denote assignment = 0 ∨ + left.map (Value.map (ArithExpr.denote assignment)) = right.map (Value.map (ArithExpr.denote assignment))) : + Extension calls before after assignment assignment := by + cases left with + | nil => + cases right with + | nil => + simp only [constrainValues, pure_ok, true_and] at compiled + subst after + exact .refl layout valid + | cons => simp [constrainValues] at compiled + | cons left ls => + cases right with + | nil => simp [constrainValues] at compiled + | cons right rs => + simp only [constrainValues] at compiled + obtain ⟨finished, middle, headRun, tailRun⟩ := bind_ok.mp compiled + cases finished + have headEq : enable.denote assignment = 0 ∨ + left.map (ArithExpr.denote assignment) = right.map (ArithExpr.denote assignment) := by + rcases equal with disabled | equal + · exact Or.inl disabled + · exact Or.inr (List.cons.inj equal).1 + have tailEq : enable.denote assignment = 0 ∨ + ls.map (Value.map (ArithExpr.denote assignment)) = rs.map (Value.map (ArithExpr.denote assignment)) := by + rcases equal with disabled | equal + · exact Or.inl disabled + · exact Or.inr (List.cons.inj equal).2 + have headExt := constrainValue_complete headRun layout valid enableBound + (leftBound left (by simp)) (rightBound right (by simp)) headEq + have tailExt := constrainValues_complete tailRun headExt.layout headExt.valid + (Scalar.Circuit.ArithExpr.inBounds_mono headExt.increase enableBound) + (fun value member => (leftBound value (by simp [member])).mono headExt.increase) + (fun value member => (rightBound value (by simp [member])).mono headExt.increase) tailEq + exact headExt.trans tailExt + termination_by sizeOf left +end + +end Aiur.Tuple.Circuit.Compiler diff --git a/Aiur/Aiur/Tuple/Circuit/WitnessBasic.lean b/Aiur/Aiur/Tuple/Circuit/WitnessBasic.lean new file mode 100644 index 000000000..dd99c8790 --- /dev/null +++ b/Aiur/Aiur/Tuple/Circuit/WitnessBasic.lean @@ -0,0 +1,234 @@ +import Aiur.Tuple.Circuit.PatternCorrectness + +namespace Aiur.Tuple.Circuit.Compiler + +/-- All leaves of a symbolic tuple refer only to allocated variables. -/ +def Bounded (bound : Nat) (value : Symbolic F) : Prop := + ∀ polynomial ∈ value.flatten, polynomial.inBounds bound = true + +@[simp] theorem bounded_field {bound : Nat} {polynomial : ArithExpr F} : + Bounded bound (.field polynomial) ↔ polynomial.inBounds bound = true := by + simp [Bounded, Value.flatten] + +@[simp] theorem bounded_tuple {bound : Nat} {values : List (Symbolic F)} : + Bounded bound (.tuple values) ↔ ∀ value ∈ values, Bounded bound value := by + simp only [Bounded, Value.flatten, List.mem_flatMap, forall_exists_index, and_imp] + constructor + · intro h value member p leaf + exact h p value member leaf + · intro h p value member leaf + exact h value member p leaf + +theorem Bounded.mono {before after : Nat} (increase : before ≤ after) + {value : Symbolic F} (bounded : Bounded before value) : Bounded after value := + fun p member => Scalar.Circuit.ArithExpr.inBounds_mono increase (bounded p member) + +def LocalsBounded (bound : Nat) (locals : Locals F) : Prop := + ∀ binding ∈ locals, Bounded bound binding.2 + +theorem LocalsBounded.mono {before after : Nat} (increase : before ≤ after) + {locals : Locals F} (bounded : LocalsBounded before locals) : LocalsBounded after locals := + fun binding member => (bounded binding member).mono increase + +@[simp] theorem localsBounded_append {bound : Nat} {left right : Locals F} : + LocalsBounded bound (left ++ right) ↔ LocalsBounded bound left ∧ LocalsBounded bound right := by + simp [LocalsBounded, or_imp, forall_and] + +structure BuildState.WellFormed (state : BuildState F) : Prop where + constraints : ∀ polynomial ∈ state.constraints.toList, polynomial.inBounds state.nextVar = true + sends : ∀ send ∈ state.sends.toList, send.inBounds state.nextVar = true + +theorem Send_bounds_mono {send : Send F} {before after : Nat} (increase : before ≤ after) + (bounded : send.inBounds before = true) : send.inBounds after = true := by + simp only [Send.inBounds, Bool.and_eq_true, List.all_eq_true, decide_eq_true_eq] at bounded ⊢ + exact ⟨⟨fun id member => lt_of_lt_of_le (bounded.1.1 id member) increase, + Scalar.Circuit.ArithExpr.inBounds_mono increase bounded.1.2⟩, + fun polynomial member => Scalar.Circuit.ArithExpr.inBounds_mono increase (bounded.2 polynomial member)⟩ + +theorem BuildState.WellFormed.grow {state : BuildState F} (layout : state.WellFormed) + {bound : Nat} (increase : state.nextVar ≤ bound) : + { state with nextVar := bound }.WellFormed := + ⟨fun p member => Scalar.Circuit.ArithExpr.inBounds_mono increase (layout.constraints p member), + fun send member => Send_bounds_mono increase (layout.sends send member)⟩ + +theorem BuildState.WellFormed.constrain {state : BuildState F} (layout : state.WellFormed) + {polynomial : ArithExpr F} (bounded : polynomial.inBounds state.nextVar = true) : + { state with constraints := state.constraints.push polynomial }.WellFormed := by + refine ⟨?_, layout.sends⟩ + intro p member + simp only [Array.toList_push, List.mem_append, List.mem_singleton] at member + rcases member with member | rfl + · exact layout.constraints p member + · exact bounded + +theorem BuildState.Valid.constrain [Field F] {state : BuildState F} {calls : CallRelation F} + {assignment : Var → F} (valid : state.Valid calls assignment) {polynomial : ArithExpr F} + (zero : polynomial.denote assignment = 0) : + { state with constraints := state.constraints.push polynomial }.Valid calls assignment := by + refine ⟨?_, valid.calls⟩ + intro p member + simp only [Array.toList_push, List.mem_append, List.mem_singleton] at member + rcases member with member | rfl + · exact valid.constraints p member + · exact zero + +theorem BuildState.Valid.of_agree [Field F] {state : BuildState F} {calls : CallRelation F} + {before after : Var → F} (valid : state.Valid calls before) (layout : state.WellFormed) + (agree : ∀ id < state.nextVar, after id = before id) : state.Valid calls after := by + constructor + · intro p member + rw [Scalar.Circuit.ArithExpr.denote_eq_of_agree agree (layout.constraints p member)] + exact valid.constraints p member + · intro send member active + have bounded := layout.sends send member + simp only [Send.inBounds, Bool.and_eq_true, List.all_eq_true, decide_eq_true_eq] at bounded + have enabled : send.enable.denote after = send.enable.denote before := + Scalar.Circuit.ArithExpr.denote_eq_of_agree agree bounded.1.2 + have result : send.result.map after = send.result.map before := + Value.map_congr _ (fun id inside => agree id (bounded.1.1 id inside)) + have args : send.args.map (Value.map (ArithExpr.denote after)) = + send.args.map (Value.map (ArithExpr.denote before)) := by + apply List.map_congr_left + intro value inside + apply Value.map_congr + intro p leaf + exact Scalar.Circuit.ArithExpr.denote_eq_of_agree agree + (bounded.2 p (List.mem_flatMap.mpr ⟨value, inside, leaf⟩)) + rw [args, result] + exact valid.calls send member (enabled.symm.trans active) + +/-- A witness extends the allocation frontier and preserves every old variable. -/ +structure Extension [Field F] (calls : CallRelation F) (before after : BuildState F) + (initial assignment : Var → F) : Prop where + increase : before.nextVar ≤ after.nextVar + agree : ∀ id < before.nextVar, assignment id = initial id + layout : after.WellFormed + valid : after.Valid calls assignment + +theorem Extension.refl [Field F] {calls : CallRelation F} {state : BuildState F} + {assignment : Var → F} (layout : state.WellFormed) (valid : state.Valid calls assignment) : + Extension calls state state assignment assignment := ⟨le_rfl, by intros; rfl, layout, valid⟩ + +theorem Extension.trans [Field F] {calls : CallRelation F} {s₁ s₂ s₃ : BuildState F} + {a₁ a₂ a₃ : Var → F} (left : Extension calls s₁ s₂ a₁ a₂) + (right : Extension calls s₂ s₃ a₂ a₃) : Extension calls s₁ s₃ a₁ a₃ := + ⟨left.increase.trans right.increase, + fun id bound => (right.agree id (lt_of_lt_of_le bound left.increase)).trans (left.agree id bound), + right.layout, right.valid⟩ + +theorem Extension.polynomial [Field F] {calls : CallRelation F} {before after : BuildState F} + {a b : Var → F} (extension : Extension calls before after a b) {p : ArithExpr F} + (bounded : p.inBounds before.nextVar = true) : p.denote b = p.denote a := + Scalar.Circuit.ArithExpr.denote_eq_of_agree extension.agree bounded + +theorem Extension.value [Field F] {calls : CallRelation F} {before after : BuildState F} + {a b : Var → F} (extension : Extension calls before after a b) {value : Symbolic F} + (bounded : Bounded before.nextVar value) : + value.map (ArithExpr.denote b) = value.map (ArithExpr.denote a) := + Value.map_congr _ (fun p member => extension.polynomial (bounded p member)) + +theorem Extension.locals [Field F] {calls : CallRelation F} {before after : BuildState F} + {a b : Var → F} (extension : Extension calls before after a b) {locals : Locals F} + (bounded : LocalsBounded before.nextVar locals) : localsEnvironment locals b = localsEnvironment locals a := by + apply List.map_congr_left + intro binding member + simp only [extension.value (bounded binding member)] + +theorem Extension.variables [Field F] {calls : CallRelation F} {before after : BuildState F} + {a b : Var → F} (extension : Extension calls before after a b) {value : Value Var} + (bounded : Bounded (F := F) before.nextVar (value.map ArithExpr.var)) : value.map b = value.map a := by + simpa only [Value.map_map, Function.comp_def, Scalar.Circuit.ArithExpr.denote] using extension.value bounded + +theorem fresh_complete [Field F] {calls : CallRelation F} {before after : BuildState F} {id : Var} + (compiled : fresh before = .ok (id, after)) {initial : Var → F} + (layout : before.WellFormed) (valid : before.Valid calls initial) (value : F) : + ∃ assignment, Extension calls before after initial assignment ∧ + id < after.nextVar ∧ assignment id = value := by + simp only [fresh_apply, Except.ok.injEq, Prod.mk.injEq] at compiled + obtain ⟨rfl, rfl⟩ := compiled + let assignment := Function.update initial before.nextVar value + have agree : ∀ id < before.nextVar, assignment id = initial id := by + intro id bounded + exact Function.update_of_ne (Nat.ne_of_lt bounded) _ _ + have oldValid := valid.of_agree layout agree + exact ⟨assignment, ⟨Nat.le_succ _, agree, layout.grow (Nat.le_succ _), + ⟨oldValid.constraints, oldValid.calls⟩⟩, Nat.lt_succ_self _, by simp [assignment]⟩ + +theorem constrain_complete [Field F] {calls : CallRelation F} {before after : BuildState F} + {p : ArithExpr F} (compiled : constrain p before = .ok ((), after)) {assignment : Var → F} + (layout : before.WellFormed) (valid : before.Valid calls assignment) + (bounded : p.inBounds before.nextVar = true) (zero : p.denote assignment = 0) : + Extension calls before after assignment assignment := by + simp only [constrain_apply, Except.ok.injEq, Prod.mk.injEq, true_and] at compiled + subst after + exact ⟨le_rfl, by intros; rfl, layout.constrain bounded, valid.constrain zero⟩ + +theorem boolean_complete [Field F] {calls : CallRelation F} {before after : BuildState F} + {p : ArithExpr F} (compiled : boolean p before = .ok ((), after)) {assignment : Var → F} + (layout : before.WellFormed) (valid : before.Valid calls assignment) + (bounded : p.inBounds before.nextVar = true) (value : p.denote assignment = 0 ∨ p.denote assignment = 1) : + Extension calls before after assignment assignment := by + apply constrain_complete compiled layout valid + · simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using bounded + · rcases value with zero | one <;> + simp [ArithExpr.denote, Scalar.Circuit.ArithExpr.denote, *] + +theorem Extension.bound [Field F] {calls : CallRelation F} {before after : BuildState F} + {a b : Var → F} (extension : Extension calls before after a b) {p : ArithExpr F} + (bounded : p.inBounds before.nextVar = true) : p.inBounds after.nextVar = true := + Scalar.Circuit.ArithExpr.inBounds_mono extension.increase bounded + +theorem Extension.values [Field F] {calls : CallRelation F} {before after : BuildState F} + {a b : Var → F} (extension : Extension calls before after a b) {values : List (Symbolic F)} + (bounded : ∀ value ∈ values, Bounded before.nextVar value) : + values.map (Value.map (ArithExpr.denote b)) = values.map (Value.map (ArithExpr.denote a)) := + List.map_congr_left (fun value member => extension.value (bounded value member)) + +theorem send_complete [Field F] {calls : CallRelation F} {before : BuildState F} + {assignment : Var → F} (layout : before.WellFormed) (valid : before.Valid calls assignment) + (send : Send F) (bounded : send.inBounds before.nextVar = true) + (called : send.enable.denote assignment = 1 → + calls send.channel (send.args.map (Value.map (ArithExpr.denote assignment))) (send.result.map assignment)) : + Extension calls before { before with sends := before.sends.push send } assignment assignment := by + refine ⟨le_rfl, by intros; rfl, ⟨layout.constraints, ?_⟩, ⟨valid.constraints, ?_⟩⟩ + · intro next member + simp only [Array.toList_push, List.mem_append, List.mem_singleton] at member + rcases member with member | rfl + · exact layout.sends next member + · exact bounded + · intro next member active + simp only [Array.toList_push, List.mem_append, List.mem_singleton] at member + rcases member with member | rfl + · exact valid.calls next member active + · exact called active + +theorem send_bounded {name : String} {args : List (Symbolic F)} {result : Value Var} + {enable : ArithExpr F} {bound : Nat} + (argsBound : ∀ value ∈ args, Bounded bound value) + (resultBound : Bounded (F := F) bound (result.map ArithExpr.var)) + (enableBound : enable.inBounds bound = true) : + (⟨name, args, result, enable⟩ : Send F).inBounds bound = true := by + simp only [Send.inBounds, Bool.and_eq_true, List.all_eq_true, decide_eq_true_eq] + refine ⟨⟨?_, enableBound⟩, ?_⟩ + · intro id member + have := resultBound (.var id) (by simpa only [Value.flatten_map, List.mem_map] using + (show ∃ x ∈ result.flatten, ArithExpr.var x = .var id from ⟨id, member, rfl⟩)) + simpa only [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds, decide_eq_true_eq] using this + · intro p member + obtain ⟨value, member, leaf⟩ := List.mem_flatMap.mp member + exact argsBound value member p leaf + +theorem guarded_complete [Field F] {calls : CallRelation F} {before after : BuildState F} + {enable polynomial : ArithExpr F} + (compiled : guarded enable polynomial before = .ok ((), after)) {assignment : Var → F} + (layout : before.WellFormed) (valid : before.Valid calls assignment) + (enableBound : enable.inBounds before.nextVar = true) + (polyBound : polynomial.inBounds before.nextVar = true) + (zero : enable.denote assignment = 0 ∨ polynomial.denote assignment = 0) : + Extension calls before after assignment assignment := by + apply constrain_complete compiled layout valid + · simpa [ArithExpr.inBounds, Scalar.Circuit.ArithExpr.inBounds] using And.intro enableBound polyBound + · change enable.denote assignment * polynomial.denote assignment = 0 + exact mul_eq_zero.mpr zero + +end Aiur.Tuple.Circuit.Compiler diff --git a/Aiur/Aiur/Tuple/Completeness.lean b/Aiur/Aiur/Tuple/Completeness.lean new file mode 100644 index 000000000..7f53f900e --- /dev/null +++ b/Aiur/Aiur/Tuple/Completeness.lean @@ -0,0 +1,71 @@ +import Aiur.Tuple.Correctness +import Aiur.Tuple.Circuit.LocalWitness +import Aiur.Tuple.Semantics.CallTypes + +namespace Aiur.Tuple + +private theorem compiled_typechecked [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} (compiled : Circuit.compile program = .ok system) : + typecheck program = .ok () := by + cases checked : typecheck program with + | error error => simp [Circuit.compile, checked] at compiled; cases compiled + | ok finished => cases finished; rfl + +/-- Compiled call premises carry the function's declared structural result type. -/ +theorem circuit_calls_typed [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} (compiled : Circuit.compile program = .ok system) : + CallsTyped program (Circuit.CircuitEvaluates system) := by + intro name args result derives fn found + obtain ⟨tree⟩ := derives + cases tree with + | node chip row lookup valid children => + obtain ⟨source, sourceFound, lowered⟩ := Circuit.compile_find_chip compiled lookup + have names : chip.name = row.chip := by simpa using List.find?_some lookup + change program.findFunction? chip.name = some fn at found + rw [names] at found + have same : fn = source := Option.some.inj (found.symm.trans sourceFound) + subst fn + simpa only [Circuit.Chip.receive, Value.type_map] using (Circuit.Compiler.lowerFunction_interface lowered).2.2 + +/-- Every finite source evaluation produces a closed derivation of the compiled tuple chips. -/ +theorem evaluation_complete [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {name : String} {args : List (Value F)} {result : Value F} (evaluated : EvalCall program name args result) : + Circuit.CircuitEvaluates system name args result := by + induction evaluated using EvalCall.rec + (motive_1 := fun locals expr value _ => EvalExprWith (Circuit.CircuitEvaluates system) locals expr value) + (motive_2 := fun locals exprs values _ => EvalArgsWith (Circuit.CircuitEvaluates system) locals exprs values) with + | literal => exact .literal + | var lookup => exact .var lookup + | tuple _ ih => exact .tuple ih + | project _ projected ih => exact .project ih projected + | letValue _ matched _ inputIH bodyIH => exact .letValue inputIH matched bodyIH + | neg _ operation ih => exact .neg ih operation + | binary _ _ operation leftIH rightIH => exact .binary leftIH rightIH operation + | call _ _ argsIH calleeIH => exact .call argsIH calleeIH + | matchValue _ selected _ inputIH bodyIH => exact .matchValue inputIH selected bodyIH + | nil => exact .nil + | cons _ _ headIH tailIH => exact .cons headIH tailIH + | intro prepared _ bodyIH => + obtain ⟨fn, lookup, types, rfl, rfl⟩ := prepareCall_spec prepared + obtain ⟨chip, found, lowered⟩ := Circuit.compile_find_function compiled lookup + have checked := typecheck_function (compiled_typechecked compiled) (List.mem_of_find?_eq_some lookup) + obtain ⟨row, rowName, valid, receive, premises⟩ := Circuit.Compiler.lowerFunction_complete + lowered (circuit_calls_typed compiled) checked types bodyIH + have name := Circuit.findFunction_name lookup + have rowLookup : system.findChip? row.chip = some chip := by rw [rowName, name]; exact found + obtain ⟨children⟩ := Circuit.derivations_nonempty_iff.mpr premises + have tree := Circuit.Derivation.node chip row rowLookup valid children + rw [receive, name] at tree + exact ⟨tree⟩ + +/-- Successful compilation preserves and reflects evaluation, including arbitrary nested tuples. -/ +theorem compiler_correct [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {name : String} {args : List (Value F)} {result : Value F} : + EvalCall program name args result ↔ Circuit.CircuitEvaluates system name args result := + ⟨evaluation_complete compiled, compiler_sound compiled⟩ + +end Aiur.Tuple diff --git a/Aiur/Aiur/Tuple/Correctness.lean b/Aiur/Aiur/Tuple/Correctness.lean new file mode 100644 index 000000000..1e2844713 --- /dev/null +++ b/Aiur/Aiur/Tuple/Correctness.lean @@ -0,0 +1,44 @@ +import Aiur.Tuple.Circuit.LocalCorrectness +import Aiur.Tuple.Circuit.Derivation +import Aiur.Tuple.Semantics.CallFacts + +namespace Aiur.Tuple + +/-- Every closed derivation of a compiled tuple program has a finite source evaluation. -/ +theorem derivation_sound [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) {message : Circuit.Message F} + (derivation : Circuit.Derivation system message) : + EvalCall program message.channel message.args message.result := by + induction derivation using Circuit.Derivation.rec + (motive_2 := fun messages _ => + ∀ message ∈ messages, EvalCall program message.channel message.args message.result) with + | node chip row lookup valid _ childrenIH => + obtain ⟨fn, found, lowered⟩ := Circuit.compile_find_chip compiled lookup + have interface := Circuit.Compiler.lowerFunction_interface lowered + have body := Circuit.Compiler.lowerFunction_sound lowered valid childrenIH + have types : fn.params.map Prod.snd = (chip.receive row).args.map Value.type := by + simpa only [Circuit.Chip.receive, List.map_map, Function.comp_def, Value.type_map] + using interface.2.1.symm + apply EvalCall.intro (prepareCall_of_types (fn := fn) ?_ types) body.toEvalExpr + change program.findFunction? chip.name = some fn + rw [interface.1, Circuit.findFunction_name found] + exact found + | nil => simp_all + | cons _ _ headIH tailIH => + rename_i message member + rcases List.mem_cons.mp member with same | member + · subst message; exact headIH + · exact tailIH message member + +/-- Soundness for the current compiler, including nested tuples and ordered patterns. -/ +theorem compiler_sound [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {name : String} {args : List (Value F)} {result : Value F} + (derives : Circuit.CircuitEvaluates system name args result) : + EvalCall program name args result := by + obtain ⟨tree⟩ := derives + exact derivation_sound compiled tree + +end Aiur.Tuple diff --git a/Aiur/Aiur/Tuple/Eval.lean b/Aiur/Aiur/Tuple/Eval.lean new file mode 100644 index 000000000..266741778 --- /dev/null +++ b/Aiur/Aiur/Tuple/Eval.lean @@ -0,0 +1,116 @@ +import Aiur.Tuple.Typecheck +import Mathlib.Algebra.Field.Defs + +namespace Aiur.Tuple + +abbrev Environment (F : Type) := List (String × Value F) + +inductive EvalError where + | invalidProgram (error : CheckError) + | unknownFunction (name : String) + | arityMismatch (function : String) (expected actual : Nat) + | argumentTypeMismatch (function : String) (expected actual : Ty) + | unboundVariable (name : String) + | expectedField + | expectedTuple + | projectionBounds (index size : Nat) + | patternMismatch + | divisionByZero + | noMatchingArm + | outOfFuel + deriving Repr, BEq, DecidableEq + +mutual + /-- Match the whole value and collect bindings in left-to-right order. -/ + def Pattern.bindings [DecidableEq F] : Pattern F → Value F → Option (Environment F) + | .literal x, .field y => if x = y then some [] else none + | .wildcard, _ => some [] + | .bind name, value => some [(name, value)] + | .tuple patterns, .tuple values => Pattern.bindingsList patterns values + | _, _ => none + termination_by pattern _ => sizeOf pattern + + def Pattern.bindingsList [DecidableEq F] : List (Pattern F) → List (Value F) → + Option (Environment F) + | [], [] => some [] + | pattern :: patterns, value :: values => do + return (← pattern.bindings value) ++ (← Pattern.bindingsList patterns values) + | _, _ => none + termination_by patterns _ => sizeOf patterns +end + +def selectArm [DecidableEq F] (value : Value F) : + List (Pattern F × Expr F) → Option (Environment F × Expr F) + | [] => none + | (pattern, body) :: rest => + match pattern.bindings value with + | some bindings => some (bindings, body) + | none => selectArm value rest + +def evalNeg [Field F] : Value F → Except EvalError (Value F) + | .field x => .ok (.field (-x)) + | .tuple _ => .error .expectedField + +def evalBinOp [Field F] [DecidableEq F] (op : BinOp) : + Value F → Value F → Except EvalError (Value F) + | .field x, .field y => + match op with + | .add => .ok (.field (x + y)) + | .sub => .ok (.field (x - y)) + | .mul => .ok (.field (x * y)) + | .div => if y = 0 then .error .divisionByZero else .ok (.field (x / y)) + | _, _ => .error .expectedField + +def projectValue (value : Value F) (index : Nat) : Except EvalError (Value F) := do + let .tuple items := value | throw .expectedTuple + let some result := items[index]? | throw (.projectionBounds index items.length) + return result + +/-- Resolve a call and check the complete shapes of its arguments. -/ +def prepareCall (program : Program F) (name : String) (args : List (Value F)) : + Except EvalError (Environment F × Expr F) := do + let some fn := program.findFunction? name | throw (.unknownFunction name) + if fn.params.length != args.length then + throw (.arityMismatch name fn.params.length args.length) + for (param, arg) in fn.params.zip args do + if param.2 ≠ arg.type then throw (.argumentTypeMismatch name param.2 arg.type) + return ((fn.params.map Prod.fst).zip args, fn.body) + +/-- Eager tuples and call arguments; only the first selected match body runs. -/ +def evalExpr [Field F] [DecidableEq F] (program : Program F) + (locals : Environment F) : Nat → Expr F → Except EvalError (Value F) + | 0, _ => .error .outOfFuel + | fuel + 1, expr => do + match expr with + | .literal value => return .field value + | .var name => + let some (_, value) := locals.find? (·.1 == name) | throw (.unboundVariable name) + return value + | .tuple items => return .tuple (← items.mapM (evalExpr program locals fuel)) + | .project value index => projectValue (← evalExpr program locals fuel value) index + | .letValue pattern value body => + let value ← evalExpr program locals fuel value + let some bindings := pattern.bindings value | throw .patternMismatch + evalExpr program (bindings ++ locals) fuel body + | .neg value => evalNeg (← evalExpr program locals fuel value) + | .binary op left right => + evalBinOp op (← evalExpr program locals fuel left) (← evalExpr program locals fuel right) + | .call name args => + let values ← args.mapM (evalExpr program locals fuel) + let (bindings, body) ← prepareCall program name values + evalExpr program bindings fuel body + | .matchValue scrutinee arms => + let value ← evalExpr program locals fuel scrutinee + let some (bindings, body) := selectArm value arms | throw .noMatchingArm + evalExpr program (bindings ++ locals) fuel body + +/-- Entry arguments and results retain their complete tuple structure. -/ +def eval [Field F] [DecidableEq F] (program : Program F) (name : String) + (args : List (Value F)) (fuel : Nat := 1000) : Except EvalError (Value F) := do + match typecheck program with + | .error error => throw (.invalidProgram error) + | .ok () => pure () + let (bindings, body) ← prepareCall program name args + evalExpr program bindings fuel body + +end Aiur.Tuple diff --git a/Aiur/Aiur/Tuple/EvalCorrectness.lean b/Aiur/Aiur/Tuple/EvalCorrectness.lean new file mode 100644 index 000000000..732dc189f --- /dev/null +++ b/Aiur/Aiur/Tuple/EvalCorrectness.lean @@ -0,0 +1,260 @@ +import Aiur.Tuple.Semantics + +namespace Aiur.Tuple + +private theorem evalArgs_of_mapM [Field F] [DecidableEq F] {program : Program F} + {locals : Environment F} {fuel : Nat} + (sound : ∀ expr result, evalExpr program locals fuel expr = .ok result → + EvalExpr program locals expr result) + {args : List (Expr F)} {values : List (Value F)} + (executed : args.mapM (evalExpr program locals fuel) = .ok values) : + EvalArgs program locals args values := by + induction args generalizing values with + | nil => + simp [pure, Except.pure] at executed + subst values + exact .nil + | cons head tail ih => + cases headRun : evalExpr program locals fuel head with + | error error => simp [List.mapM_cons, headRun, bind, Except.bind] at executed + | ok value => + cases tailRun : tail.mapM (evalExpr program locals fuel) with + | error error => simp [List.mapM_cons, headRun, tailRun, bind, Except.bind] at executed + | ok results => + simp [List.mapM_cons, headRun, tailRun, bind, pure, Except.bind, Except.pure] at executed + subst values + exact .cons (sound head value headRun) (ih tailRun) + +/-- Every successful executable run has a finite fuel-free evaluation proof. -/ +theorem evalExpr_spec [Field F] [DecidableEq F] {program : Program F} + {locals : Environment F} {fuel : Nat} {expr : Expr F} {result : Value F} + (executed : evalExpr program locals fuel expr = .ok result) : + EvalExpr program locals expr result := by + induction fuel generalizing locals expr result with + | zero => simp [evalExpr] at executed + | succ fuel ih => + cases expr with + | literal value => + simp [evalExpr, pure, Except.pure] at executed + subst result + exact .literal + | var name => + cases found : locals.find? (·.1 == name) with + | none => simp [evalExpr, found, throw] at executed + | some binding => + rcases binding with ⟨key, value⟩ + have same : key = name := by simpa using List.find?_some found + subst key + simp [evalExpr, found, pure, Except.pure] at executed + subst result + exact .var found + | tuple items => + cases run : items.mapM (evalExpr program locals fuel) with + | error error => simp [evalExpr, run, bind, Except.bind] at executed + | ok values => + simp [evalExpr, run, bind, pure, Except.bind, Except.pure] at executed + subst result + exact .tuple (evalArgs_of_mapM (fun _ _ run => ih run) run) + | project value index => + cases run : evalExpr program locals fuel value with + | error error => simp [evalExpr, run, bind, Except.bind] at executed + | ok input => + exact .project (ih run) (by simpa [evalExpr, run, bind, Except.bind] using executed) + | neg value => + cases run : evalExpr program locals fuel value with + | error error => simp [evalExpr, run, bind, Except.bind] at executed + | ok input => + exact .neg (ih run) (by simpa [evalExpr, run, bind, Except.bind] using executed) + | binary op left right => + cases leftRun : evalExpr program locals fuel left with + | error error => simp [evalExpr, leftRun, bind, Except.bind] at executed + | ok leftValue => + cases rightRun : evalExpr program locals fuel right with + | error error => simp [evalExpr, leftRun, rightRun, bind, Except.bind] at executed + | ok rightValue => + exact .binary (ih leftRun) (ih rightRun) + (by simpa [evalExpr, leftRun, rightRun, bind, Except.bind] using executed) + | letValue pattern value body => + cases run : evalExpr program locals fuel value with + | error error => simp [evalExpr, run, bind, Except.bind] at executed + | ok input => + cases matched : pattern.bindings input with + | none => simp [evalExpr, run, matched, bind, Except.bind, throw] at executed + | some bindings => + exact .letValue (ih run) matched + (ih (by simpa [evalExpr, run, matched, bind, Except.bind] using executed)) + | call name args => + cases argsRun : args.mapM (evalExpr program locals fuel) with + | error error => simp [evalExpr, argsRun, bind, Except.bind] at executed + | ok values => + cases prepared : prepareCall program name values with + | error error => simp [evalExpr, argsRun, prepared, bind, Except.bind] at executed + | ok binding => + rcases binding with ⟨calleeLocals, body⟩ + exact .call (evalArgs_of_mapM (fun _ _ run => ih run) argsRun) + (.intro prepared + (ih (by simpa [evalExpr, argsRun, prepared, bind, Except.bind] using executed))) + | matchValue scrutinee arms => + cases run : evalExpr program locals fuel scrutinee with + | error error => simp [evalExpr, run, bind, Except.bind] at executed + | ok input => + cases selected : selectArm input arms with + | none => simp [evalExpr, run, selected, bind, Except.bind, throw] at executed + | some binding => + rcases binding with ⟨bindings, body⟩ + exact .matchValue (ih run) selected + (ih (by simpa [evalExpr, run, selected, bind, Except.bind] using executed)) + +theorem eval_eq_ok_iff [Field F] [DecidableEq F] {program : Program F} + {name : String} {args : List (Value F)} {fuel : Nat} {result : Value F} : + eval program name args fuel = .ok result ↔ + typecheck program = .ok () ∧ ∃ locals expr, + prepareCall program name args = .ok (locals, expr) ∧ + evalExpr program locals fuel expr = .ok result := by + cases checked : typecheck program with + | error error => simp [eval, checked, bind, Except.bind] + | ok checkedUnit => + cases checkedUnit + cases prepared : prepareCall program name args with + | error error => simp [eval, checked, prepared, bind, pure, Except.bind, Except.pure] + | ok binding => + rcases binding with ⟨locals, expr⟩ + simp only [eval, checked, prepared, bind, pure, Except.bind, Except.pure, + Except.ok.injEq, Prod.mk.injEq, true_and] + constructor + · intro run; exact ⟨locals, expr, ⟨rfl, rfl⟩, run⟩ + · rintro ⟨_, _, ⟨rfl, rfl⟩, run⟩; exact run + +theorem eval_spec [Field F] [DecidableEq F] {program : Program F} + {name : String} {args : List (Value F)} {fuel : Nat} {result : Value F} + (executed : eval program name args fuel = .ok result) : EvalCall program name args result := by + obtain ⟨_, locals, expr, prepared, body⟩ := eval_eq_ok_iff.mp executed + exact .intro prepared (evalExpr_spec body) + +/-- Every finite evaluation runs with all sufficiently large fuel bounds. -/ +theorem EvalExpr.eventually_runs [Field F] [DecidableEq F] {program : Program F} + {locals : Environment F} {expr : Expr F} {result : Value F} + (evaluates : EvalExpr program locals expr result) : + ∃ minimum, ∀ fuel, minimum ≤ fuel → evalExpr program locals fuel expr = .ok result := by + induction evaluates using EvalExpr.rec + (motive_2 := fun locals exprs values _ => + ∃ minimum, ∀ fuel, minimum ≤ fuel → exprs.mapM (evalExpr program locals fuel) = .ok values) + (motive_3 := fun name args result _ => + ∃ minimum, ∀ fuel, minimum ≤ fuel → ∃ locals expr, + prepareCall program name args = .ok (locals, expr) ∧ + evalExpr program locals fuel expr = .ok result) with + | literal => + refine ⟨1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => rfl + | var lookup => + refine ⟨1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => simp [evalExpr, lookup, pure, Except.pure] + | tuple _ ih => + obtain ⟨minimum, runs⟩ := ih + refine ⟨minimum + 1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => simp [evalExpr, runs fuel (by omega), bind, pure, Except.bind, Except.pure] + | project _ projected ih | neg _ projected ih => + obtain ⟨minimum, runs⟩ := ih + refine ⟨minimum + 1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => simp [evalExpr, runs fuel (by omega), projected, bind, Except.bind] + | binary _ _ operation leftIH rightIH => + obtain ⟨leftMinimum, leftRuns⟩ := leftIH + obtain ⟨rightMinimum, rightRuns⟩ := rightIH + refine ⟨max leftMinimum rightMinimum + 1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => + simp [evalExpr, leftRuns fuel (by omega), rightRuns fuel (by omega), + operation, bind, Except.bind] + | letValue _ matched _ valueIH bodyIH | matchValue _ matched _ valueIH bodyIH => + obtain ⟨valueMinimum, valueRuns⟩ := valueIH + obtain ⟨bodyMinimum, bodyRuns⟩ := bodyIH + refine ⟨max valueMinimum bodyMinimum + 1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => + simpa [evalExpr, valueRuns fuel (by omega), matched, bind, Except.bind] + using bodyRuns fuel (by omega) + | call _ _ argsIH callIH => + obtain ⟨argsMinimum, argsRuns⟩ := argsIH + obtain ⟨callMinimum, callRuns⟩ := callIH + refine ⟨max argsMinimum callMinimum + 1, ?_⟩ + intro fuel enough + cases fuel with + | zero => omega + | succ fuel => + obtain ⟨locals, expr, prepared, bodyRun⟩ := callRuns fuel (by omega) + simpa [evalExpr, argsRuns fuel (by omega), prepared, bind, Except.bind] using bodyRun + | nil => exact ⟨0, fun _ _ => rfl⟩ + | cons _ _ headIH tailIH => + obtain ⟨headMinimum, headRuns⟩ := headIH + obtain ⟨tailMinimum, tailRuns⟩ := tailIH + refine ⟨max headMinimum tailMinimum, ?_⟩ + intro fuel enough + simp [List.mapM_cons, headRuns fuel (by omega), tailRuns fuel (by omega), + bind, pure, Except.bind, Except.pure] + | intro prepared _ bodyIH => + obtain ⟨minimum, runs⟩ := bodyIH + exact ⟨minimum, fun fuel enough => ⟨_, _, prepared, runs fuel enough⟩⟩ + +theorem EvalCall.eventually_eval [Field F] [DecidableEq F] {program : Program F} + (checked : typecheck program = .ok ()) {name : String} + {args : List (Value F)} {result : Value F} (evaluates : EvalCall program name args result) : + ∃ minimum, ∀ fuel, minimum ≤ fuel → eval program name args fuel = .ok result := by + cases evaluates with + | intro prepared body => + obtain ⟨minimum, runs⟩ := body.eventually_runs + exact ⟨minimum, fun fuel enough => eval_eq_ok_iff.mpr ⟨checked, _, _, prepared, runs fuel enough⟩⟩ + +theorem eval_complete [Field F] [DecidableEq F] {program : Program F} + (checked : typecheck program = .ok ()) {name : String} + {args : List (Value F)} {result : Value F} (evaluates : EvalCall program name args result) : + ∃ fuel, eval program name args fuel = .ok result := by + obtain ⟨minimum, runs⟩ := evaluates.eventually_eval checked + exact ⟨minimum, runs minimum (Nat.le_refl _)⟩ + +theorem exists_eval_iff [Field F] [DecidableEq F] {program : Program F} + {name : String} {args : List (Value F)} {result : Value F} : + (∃ fuel, eval program name args fuel = .ok result) ↔ + typecheck program = .ok () ∧ EvalCall program name args result := by + constructor + · rintro ⟨fuel, executed⟩ + exact ⟨(eval_eq_ok_iff.mp executed).1, eval_spec executed⟩ + · rintro ⟨checked, evaluated⟩ + exact eval_complete checked evaluated + +theorem EvalExpr.deterministic [Field F] [DecidableEq F] {program : Program F} + {locals : Environment F} {expr : Expr F} {left right : Value F} + (first : EvalExpr program locals expr left) (second : EvalExpr program locals expr right) : + left = right := by + obtain ⟨a, leftRuns⟩ := first.eventually_runs + obtain ⟨b, rightRuns⟩ := second.eventually_runs + exact Except.ok.inj ((leftRuns (max a b) (Nat.le_max_left _ _)).symm.trans + (rightRuns (max a b) (Nat.le_max_right _ _))) + +theorem EvalCall.deterministic [Field F] [DecidableEq F] {program : Program F} + {name : String} {args : List (Value F)} {left right : Value F} + (first : EvalCall program name args left) (second : EvalCall program name args right) : + left = right := by + cases first with + | intro prepared body => + cases second with + | intro otherPrepared otherBody => + cases Except.ok.inj (prepared.symm.trans otherPrepared) + exact body.deterministic otherBody + +end Aiur.Tuple diff --git a/Aiur/Aiur/Tuple/Frontend.lean b/Aiur/Aiur/Tuple/Frontend.lean new file mode 100644 index 000000000..88412da6a --- /dev/null +++ b/Aiur/Aiur/Tuple/Frontend.lean @@ -0,0 +1,243 @@ +import Aiur.Tuple.Typecheck +import Lean + +namespace Aiur.Tuple.Frontend + +open Lean Elab Term + +declare_syntax_cat tuple_aiur_type +declare_syntax_cat tuple_aiur_expr +declare_syntax_cat tuple_aiur_pattern +declare_syntax_cat tuple_aiur_arm +declare_syntax_cat tuple_aiur_param +declare_syntax_cat tuple_aiur_function +declare_syntax_cat tuple_aiur_program + +syntax (name := namedType) ident : tuple_aiur_type +syntax (name := unitType) "(" ")" : tuple_aiur_type +syntax (name := typeParens) "(" tuple_aiur_type ")" : tuple_aiur_type +syntax (name := tupleType) "(" tuple_aiur_type "," sepBy(tuple_aiur_type, ",", ",", allowTrailingSep) ")" : tuple_aiur_type +syntax (name := unitExpr) "(" ")" : tuple_aiur_expr +syntax (name := tupleExpr) "(" tuple_aiur_expr "," sepBy(tuple_aiur_expr, ",", ",", allowTrailingSep) ")" : tuple_aiur_expr +syntax:80 (name := project) tuple_aiur_expr:80 "." num : tuple_aiur_expr +syntax (name := letValue) "let" tuple_aiur_pattern "=" tuple_aiur_expr ";" tuple_aiur_expr : tuple_aiur_expr +syntax (name := literal) num : tuple_aiur_expr +syntax (name := variableExpr) ident : tuple_aiur_expr +syntax (name := parens) "(" tuple_aiur_expr ")" : tuple_aiur_expr +syntax (name := block) "{" tuple_aiur_expr "}" : tuple_aiur_expr +syntax (name := call) ident "(" sepBy(tuple_aiur_expr, ",", ",", allowTrailingSep) ")" : tuple_aiur_expr +syntax:75 (name := neg) "-" tuple_aiur_expr:75 : tuple_aiur_expr +syntax:70 (name := mul) tuple_aiur_expr:70 "*" tuple_aiur_expr:71 : tuple_aiur_expr +syntax:70 (name := div) tuple_aiur_expr:70 "/" tuple_aiur_expr:71 : tuple_aiur_expr +syntax:65 (name := add) tuple_aiur_expr:65 "+" tuple_aiur_expr:66 : tuple_aiur_expr +syntax:65 (name := sub) tuple_aiur_expr:65 "-" tuple_aiur_expr:66 : tuple_aiur_expr +syntax (name := literalPattern) num : tuple_aiur_pattern +syntax (name := wildcardPattern) "_" : tuple_aiur_pattern +syntax (name := bindPattern) ident : tuple_aiur_pattern +syntax (name := unitPattern) "(" ")" : tuple_aiur_pattern +syntax (name := patternParens) "(" tuple_aiur_pattern ")" : tuple_aiur_pattern +syntax (name := tuplePattern) "(" tuple_aiur_pattern "," sepBy(tuple_aiur_pattern, ",", ",", allowTrailingSep) ")" : tuple_aiur_pattern +syntax (name := arm) tuple_aiur_pattern "=>" tuple_aiur_expr : tuple_aiur_arm +syntax (name := matchValue) "match" tuple_aiur_expr "{" + sepBy1(tuple_aiur_arm, ",", ",", allowTrailingSep) "}" : tuple_aiur_expr +syntax (name := param) tuple_aiur_pattern ":" tuple_aiur_type : tuple_aiur_param +syntax (name := function) "fn" ident "(" sepBy(tuple_aiur_param, ",", ",", allowTrailingSep) ")" + "->" tuple_aiur_type "{" tuple_aiur_expr "}" : tuple_aiur_function +syntax (name := program) tuple_aiur_function* : tuple_aiur_program + +private def readName (stx : Syntax) : Except String String := + match stx.getId with + | .str .anonymous name => .ok name + | _ => .error "expected a simple function or parameter name" + +private partial def lowerType (stx : Syntax) : Except String Ty := do + if stx.getKind == ``namedType then + if stx[0].getId == `Field then return .field + else throw "expected 'Field' or a tuple type" + else if stx.getKind == ``unitType then return .tuple [] + else if stx.getKind == ``typeParens then lowerType stx[1] + else if stx.getKind == ``tupleType then + return .tuple ((← lowerType stx[1]) :: (← stx[3].getSepArgs.toList.mapM lowerType)) + else throw "expected 'Field' or a tuple type" + +private partial def lowerPattern (stx : Syntax) : Except String (Pattern Nat) := do + if stx.getKind == ``literalPattern then + let some value := stx[0].isNatLit? | throw "expected a natural-number pattern" + return .literal value + else if stx.getKind == ``wildcardPattern then return .wildcard + else if stx.getKind == ``bindPattern then return .bind (← readName stx[0]) + else if stx.getKind == ``unitPattern then return .tuple [] + else if stx.getKind == ``patternParens then lowerPattern stx[1] + else if stx.getKind == ``tuplePattern then + return .tuple ((← lowerPattern stx[1]) :: (← stx[3].getSepArgs.toList.mapM lowerPattern)) + else throw "expected a literal, wildcard, binding, or tuple pattern" + +/-- Lower Lean's syntax tree for the embedded language; no field is chosen here. -/ +private partial def lowerExpr (stx : Syntax) : Except String (Aiur.Tuple.Expr Nat) := do + let kind := stx.getKind + if kind == ``literal then + let some value := stx[0].isNatLit? | throw "expected a natural-number literal" + return .literal value + else if kind == ``unitExpr then return .tuple [] + else if kind == ``tupleExpr then + return .tuple ((← lowerExpr stx[1]) :: (← stx[3].getSepArgs.toList.mapM lowerExpr)) + else if kind == ``project then + let some index := stx[2].isNatLit? | throw "expected a tuple index" + return .project (← lowerExpr stx[0]) index + else if kind == ``letValue then + return .letValue (← lowerPattern stx[1]) (← lowerExpr stx[3]) (← lowerExpr stx[5]) + else if kind == ``variableExpr then + return .var (← readName stx[0]) + else if kind == ``parens || kind == ``block then + lowerExpr stx[1] + else if kind == ``neg then + return .neg (← lowerExpr stx[1]) + else if kind == ``add || kind == ``sub || kind == ``mul || kind == ``div then + let op := if kind == ``add then BinOp.add else if kind == ``sub then .sub + else if kind == ``mul then .mul else .div + return .binary op (← lowerExpr stx[0]) (← lowerExpr stx[2]) + else if kind == ``call then + return .call (← readName stx[0]) (← stx[2].getSepArgs.toList.mapM lowerExpr) + else if kind == ``matchValue then + let scrutinee ← lowerExpr stx[1] + let arms ← stx[3].getSepArgs.toList.mapM fun arm => do + return (← lowerPattern arm[0], ← lowerExpr arm[2]) + return .matchValue scrutinee arms + else + throw s!"unsupported expression syntax: {kind}" + +private def lowerFunction (stx : Syntax) : Except String (Aiur.Tuple.Function Nat) := do + let name ← readName stx[1] + let mut params := [] + let mut destructuring := [] + let mut names := [] + for (param, index) in stx[3].getSepArgs.toList.zipIdx do + let pattern ← lowerPattern param[0] + let type ← lowerType param[2] + if !pattern.irrefutable then throw s!"parameter patterns must be irrefutable in function '{name}'" + let bindings ← (checkPattern name pattern type).mapError toString + names := names ++ bindings.map Prod.fst + match pattern with + | .bind key => params := params ++ [(key, type)] + | _ => + let key := s!"$arg{index}" + params := params ++ [(key, type)] + destructuring := destructuring ++ [(pattern, key)] + if let some duplicate := findDuplicate names [] then + throw s!"duplicate parameter '{duplicate}' in function '{name}'" + let body ← lowerExpr stx[8] + return { + name, params + result := ← lowerType stx[6] + body := destructuring.foldr (fun (pattern, key) body => .letValue pattern (.var key) body) body + } + +/-- Mask Rust comments before invoking Lean's parser, preserving lines and token boundaries. -/ +private def maskComments : List Char → Nat → Bool → Except String (List Char) + | [], depth, _ => + if depth == 0 then .ok [] else .error "unterminated block comment" + | '/' :: '/' :: rest, 0, false => do + return ' ' :: ' ' :: (← maskComments rest 0 true) + | '/' :: '*' :: rest, depth, false => do + return ' ' :: ' ' :: (← maskComments rest (depth + 1) false) + | '*' :: '/' :: rest, depth + 1, false => do + return ' ' :: ' ' :: (← maskComments rest depth false) + | char :: rest, depth, inLine => do + let masked := if (inLine || depth > 0) && char != '\n' && char != '\r' then ' ' else char + return masked :: (← maskComments rest depth (inLine && char != '\n')) + +/-- Keep adjacent arithmetic operators from being interpreted as Lean comments. -/ +private def normalizeWhitespace : List Char → List Char + | [] => [] + | char :: rest => + let normalized := if char == '\t' || char == '\r' then ' ' else char + -- Keep chained tuple indices such as `p.1.0` from becoming a decimal token. + if char == '.' then ' ' :: '.' :: ' ' :: normalizeWhitespace rest + else if (char == '-' || char == '/') && rest.head? == some '-' then + normalized :: ' ' :: normalizeWhitespace rest + else + normalized :: normalizeWhitespace rest + +/-- Parse and typecheck a string using the syntax categories registered in Lean. -/ +def ofString (env : Environment) (source : String) : Except String (Program Nat) := do + let source := String.ofList (normalizeWhitespace (← maskComments source.toList 0 false)) + let stx ← Parser.runParserCategory env `tuple_aiur_program source "" + let program := { functions := ← stx[0].getArgs.toList.mapM lowerFunction } + match typecheck program with + | .error error => throw (toString error) + | .ok () => pure program + +private def quoteList (type : Lean.Expr) (values : List Lean.Expr) : Lean.Expr := + values.foldr (fun value tail => mkApp3 (mkConst ``List.cons [0]) type value tail) + (mkApp (mkConst ``List.nil [0]) type) + +private def natType : Lean.Expr := mkConst ``Nat +private def exprType : Lean.Expr := mkApp (mkConst ``Aiur.Tuple.Expr) natType +private def patternType : Lean.Expr := mkApp (mkConst ``Pattern) natType + +private def quoteOp : BinOp → Lean.Expr + | .add => mkConst ``BinOp.add + | .sub => mkConst ``BinOp.sub + | .mul => mkConst ``BinOp.mul + | .div => mkConst ``BinOp.div + +private def quoteTy : Ty → Lean.Expr + | .field => mkConst ``Ty.field + | .tuple items => mkApp (mkConst ``Ty.tuple) (quoteList (mkConst ``Ty) (items.map quoteTy)) + +private def quotePattern : Pattern Nat → Lean.Expr + | .literal value => mkApp2 (mkConst ``Pattern.literal) natType (toExpr value) + | .wildcard => mkApp (mkConst ``Pattern.wildcard) natType + | .bind name => mkApp2 (mkConst ``Pattern.bind) natType (toExpr name) + | .tuple items => mkApp2 (mkConst ``Pattern.tuple) natType (quoteList patternType (items.map quotePattern)) + +private def quoteExpr : Aiur.Tuple.Expr Nat → Lean.Expr + | .literal value => mkApp2 (mkConst ``Aiur.Tuple.Expr.literal) natType (toExpr value) + | .var name => mkApp2 (mkConst ``Aiur.Tuple.Expr.var) natType (toExpr name) + | .tuple items => mkApp2 (mkConst ``Aiur.Tuple.Expr.tuple) natType (quoteList exprType (items.map quoteExpr)) + | .project value index => mkApp3 (mkConst ``Aiur.Tuple.Expr.project) natType (quoteExpr value) (toExpr index) + | .letValue pattern value body => + mkApp4 (mkConst ``Aiur.Tuple.Expr.letValue) natType (quotePattern pattern) (quoteExpr value) (quoteExpr body) + | .neg value => mkApp2 (mkConst ``Aiur.Tuple.Expr.neg) natType (quoteExpr value) + | .binary op left right => + mkApp4 (mkConst ``Aiur.Tuple.Expr.binary) natType (quoteOp op) (quoteExpr left) (quoteExpr right) + | .call name args => + mkApp3 (mkConst ``Aiur.Tuple.Expr.call) natType (toExpr name) + (quoteList exprType (args.map quoteExpr)) + | .matchValue scrutinee arms => + let armType := mkApp2 (mkConst ``Prod [0, 0]) patternType exprType + let arms := arms.map fun arm => + mkApp4 (mkConst ``Prod.mk [0, 0]) patternType exprType + (quotePattern arm.1) (quoteExpr arm.2) + mkApp3 (mkConst ``Aiur.Tuple.Expr.matchValue) natType (quoteExpr scrutinee) (quoteList armType arms) +termination_by expr => sizeOf expr +decreasing_by + all_goals simp_wf + all_goals + first + | omega + | have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + first + | omega + | cases arm + simp_all only [Prod.mk.sizeOf_spec] + omega + +private def quoteFunction (defn : Aiur.Tuple.Function Nat) : Lean.Expr := + let paramType := mkApp2 (mkConst ``Prod [0, 0]) (mkConst ``String) (mkConst ``Ty) + let params := defn.params.map fun (name, type) => + mkApp4 (mkConst ``Prod.mk [0, 0]) (mkConst ``String) (mkConst ``Ty) (toExpr name) (quoteTy type) + mkApp5 (mkConst ``Aiur.Tuple.Function.mk) natType (toExpr defn.name) (quoteList paramType params) + (quoteTy defn.result) (quoteExpr defn.body) + +private def quoteProgram (program : Program Nat) : Lean.Expr := + mkApp2 (mkConst ``Program.mk) natType + (quoteList (mkApp (mkConst ``Aiur.Tuple.Function) natType) (program.functions.map quoteFunction)) + +/-- Elaborate a Rust-like source string directly to a checked `Program Nat`. -/ +elab "tuple_aiur% " source:str : term => do + match ofString (← getEnv) source.getString with + | .error error => throwErrorAt source "{error}" + | .ok program => return quoteProgram program + +end Aiur.Tuple.Frontend diff --git a/Aiur/Aiur/Tuple/MemoCompleteness.lean b/Aiur/Aiur/Tuple/MemoCompleteness.lean new file mode 100644 index 000000000..a029d5dc6 --- /dev/null +++ b/Aiur/Aiur/Tuple/MemoCompleteness.lean @@ -0,0 +1,24 @@ +import Aiur.Tuple.Completeness +import Aiur.Tuple.Circuit.MemoDerivation +import Aiur.Tuple.EvalCorrectness + +namespace Aiur.Tuple + +/-- Successful source evaluation admits a finite memoized graph, with sharing allowed. -/ +theorem memo_complete [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {name : String} {args : List (Value F)} {result : Value F} (evaluated : EvalCall program name args result) : + Circuit.MemoAccepts system name args result := + (evaluation_complete compiled evaluated).memo + +/-- Every successful executable run supplies a memoized graph for its result. -/ +theorem memo_eval_complete [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) + {name : String} {args : List (Value F)} {fuel : Nat} {result : Value F} + (executed : eval program name args fuel = .ok result) : + Circuit.MemoAccepts system name args result := + memo_complete compiled (eval_spec executed) + +end Aiur.Tuple diff --git a/Aiur/Aiur/Tuple/MemoSoundness.lean b/Aiur/Aiur/Tuple/MemoSoundness.lean new file mode 100644 index 000000000..f56ed8370 --- /dev/null +++ b/Aiur/Aiur/Tuple/MemoSoundness.lean @@ -0,0 +1,15 @@ +import Aiur.Tuple.Correctness +import Aiur.Tuple.Circuit.MemoAcyclic + +namespace Aiur.Tuple + +/-- An acyclic memoized graph for the tuple compiler recovers source evaluation. -/ +theorem memo_acyclic_sound [Field F] [DecidableEq F] + {program : Program F} {system : Circuit.System F} + (compiled : Circuit.compile program = .ok system) {message : Circuit.Message F} + (graph : Circuit.MemoDerivation system message) (acyclic : graph.Acyclic) : + EvalCall program message.channel message.args message.result := by + obtain ⟨tree⟩ := graph.derives_of_acyclic acyclic + exact derivation_sound compiled tree + +end Aiur.Tuple diff --git a/Aiur/Aiur/Tuple/Semantics.lean b/Aiur/Aiur/Tuple/Semantics.lean new file mode 100644 index 000000000..9de2a4849 --- /dev/null +++ b/Aiur/Aiur/Tuple/Semantics.lean @@ -0,0 +1,47 @@ +import Aiur.Tuple.Eval + +namespace Aiur.Tuple + +mutual + /-- Finite successful evaluation, with structured results and no fuel parameter. -/ + inductive EvalExpr [Field F] [DecidableEq F] (program : Program F) : + Environment F → Expr F → Value F → Prop where + | literal : EvalExpr program locals (.literal value) (.field value) + | var (lookup : locals.find? (·.1 == name) = some (name, value)) : + EvalExpr program locals (.var name) value + | tuple (items : EvalArgs program locals exprs values) : + EvalExpr program locals (.tuple exprs) (.tuple values) + | project (value : EvalExpr program locals expr input) + (projected : projectValue input index = .ok result) : + EvalExpr program locals (.project expr index) result + | letValue (value : EvalExpr program locals expr input) + (matched : pattern.bindings input = some bindings) + (body : EvalExpr program (bindings ++ locals) rest result) : + EvalExpr program locals (.letValue pattern expr rest) result + | neg (value : EvalExpr program locals expr input) (operation : evalNeg input = .ok result) : + EvalExpr program locals (.neg expr) result + | binary (left : EvalExpr program locals lhs x) (right : EvalExpr program locals rhs y) + (operation : evalBinOp op x y = .ok result) : + EvalExpr program locals (.binary op lhs rhs) result + | call (arguments : EvalArgs program locals args values) + (callee : EvalCall program name values result) : + EvalExpr program locals (.call name args) result + | matchValue (value : EvalExpr program locals expr input) + (selected : selectArm input arms = some (bindings, body)) + (branch : EvalExpr program (bindings ++ locals) body result) : + EvalExpr program locals (.matchValue expr arms) result + + inductive EvalArgs [Field F] [DecidableEq F] (program : Program F) : + Environment F → List (Expr F) → List (Value F) → Prop where + | nil : EvalArgs program locals [] [] + | cons (head : EvalExpr program locals expr value) + (tail : EvalArgs program locals exprs values) : + EvalArgs program locals (expr :: exprs) (value :: values) + + inductive EvalCall [Field F] [DecidableEq F] (program : Program F) : + String → List (Value F) → Value F → Prop where + | intro (prepared : prepareCall program name args = .ok (locals, expr)) + (body : EvalExpr program locals expr result) : EvalCall program name args result +end + +end Aiur.Tuple diff --git a/Aiur/Aiur/Tuple/Semantics/CallFacts.lean b/Aiur/Aiur/Tuple/Semantics/CallFacts.lean new file mode 100644 index 000000000..7cc437367 --- /dev/null +++ b/Aiur/Aiur/Tuple/Semantics/CallFacts.lean @@ -0,0 +1,37 @@ +import Aiur.Tuple.Semantics.WithCalls +import Aiur.Tuple.ValueFacts + +namespace Aiur.Tuple + +private theorem checked_arguments (name : String) (params : List (String × Ty)) + (args : List (Value F)) (types : params.map Prod.snd = args.map Value.type) : + (do + for (param, arg) in params.zip args do + if param.2 ≠ arg.type then throw (.argumentTypeMismatch name param.2 arg.type) + pure () : Except EvalError Unit) = .ok () := by + induction params generalizing args with + | nil => cases args <;> simp_all [pure, Except.pure, bind, Except.bind] + | cons param params ih => + cases args with + | nil => simp at types + | cons arg args => + simp only [List.map_cons, List.cons.injEq] at types + simp only [List.zip_cons_cons, List.forIn_cons] + simp [types.1, bind, Except.bind, pure, Except.pure] at ih ⊢ + exact ih args types.2 + +/-- Structural argument types are exactly the shape check performed at a source call. -/ +theorem prepareCall_of_types {program : Program F} {name : String} {fn : Function F} + {args : List (Value F)} (found : program.findFunction? name = some fn) + (types : fn.params.map Prod.snd = args.map Value.type) : + prepareCall program name args = .ok ((fn.params.map Prod.fst).zip args, fn.body) := by + have arity : fn.params.length = args.length := by + simpa using congrArg List.length types + simp only [prepareCall, found, arity, bne_self_eq_false, Bool.false_eq_true, ↓reduceIte] + have checked := checked_arguments name fn.params args types + have combined := congrArg (fun result => result >>= fun _ => + (Except.ok ((fn.params.map Prod.fst).zip args, fn.body) : Except EvalError _)) checked + simp only [bind_assoc, pure_bind] at combined + simpa only [bind, Except.bind, pure, Except.pure] using combined + +end Aiur.Tuple diff --git a/Aiur/Aiur/Tuple/Semantics/CallTypes.lean b/Aiur/Aiur/Tuple/Semantics/CallTypes.lean new file mode 100644 index 000000000..d2e153f84 --- /dev/null +++ b/Aiur/Aiur/Tuple/Semantics/CallTypes.lean @@ -0,0 +1,45 @@ +import Aiur.Tuple.Semantics.CallFacts +import Aiur.Tuple.TypecheckFacts + +namespace Aiur.Tuple + +private theorem checked_arguments_types (name : String) (params : List (String × Ty)) + (args : List (Value F)) (arity : params.length = args.length) + (checked : (forIn (params.zip args) PUnit.unit (fun pair _ => + if pair.1.2 = pair.2.type then Except.ok (ForInStep.yield PUnit.unit) + else Except.error (.argumentTypeMismatch name pair.1.2 pair.2.type)) + : Except EvalError PUnit) = .ok PUnit.unit) : + params.map Prod.snd = args.map Value.type := by + induction params generalizing args with + | nil => + cases args <;> simp_all + | cons param params ih => + cases args with + | nil => simp at arity + | cons arg args => + have restArity : params.length = args.length := by simpa using arity + by_cases same : param.2 = arg.type + · simp [List.zip_cons_cons, List.forIn_cons, same, bind, Except.bind] at checked + simp [same, ih args restArity checked] + · simp [List.zip_cons_cons, List.forIn_cons, same, bind, Except.bind] at checked + +/-- Successful entry preparation supplies the declared argument shapes and exact body environment. -/ +theorem prepareCall_spec {program : Program F} {name : String} {args : List (Value F)} + {locals : Environment F} {body : Expr F} + (prepared : prepareCall program name args = .ok (locals, body)) : + ∃ fn, program.findFunction? name = some fn ∧ fn.params.map Prod.snd = args.map Value.type ∧ + locals = (fn.params.map Prod.fst).zip args ∧ body = fn.body := by + cases found : program.findFunction? name with + | none => simp [prepareCall, found] at prepared + | some fn => + by_cases arity : fn.params.length = args.length + · simp only [prepareCall, found, arity, bne_self_eq_false, Bool.false_eq_true, ↓reduceIte, + pure_bind] at prepared + obtain ⟨done, checked, finished⟩ := except_bind_ok.mp prepared + cases done + obtain ⟨rfl, rfl⟩ := Prod.mk.inj (except_pure_ok.mp finished) + exact ⟨fn, rfl, checked_arguments_types name fn.params args arity (by + simpa [bind, Except.bind, pure, Except.pure] using checked), rfl, rfl⟩ + · simp [prepareCall, found, arity, bind, Except.bind] at prepared + +end Aiur.Tuple diff --git a/Aiur/Aiur/Tuple/Semantics/WithCalls.lean b/Aiur/Aiur/Tuple/Semantics/WithCalls.lean new file mode 100644 index 000000000..70105c951 --- /dev/null +++ b/Aiur/Aiur/Tuple/Semantics/WithCalls.lean @@ -0,0 +1,81 @@ +import Aiur.Tuple.Semantics + +namespace Aiur.Tuple + +/-- Interpret each function call by a supplied premise relation. -/ +abbrev CallRelation (F : Type) := String → List (Value F) → Value F → Prop + +mutual + inductive EvalExprWith [Field F] [DecidableEq F] (calls : CallRelation F) : + Environment F → Expr F → Value F → Prop where + | literal : EvalExprWith calls locals (.literal value) (.field value) + | var (lookup : locals.find? (·.1 == name) = some (name, value)) : + EvalExprWith calls locals (.var name) value + | tuple (items : EvalArgsWith calls locals exprs values) : + EvalExprWith calls locals (.tuple exprs) (.tuple values) + | project (value : EvalExprWith calls locals expr input) + (projected : projectValue input index = .ok result) : + EvalExprWith calls locals (.project expr index) result + | letValue (value : EvalExprWith calls locals expr input) + (matched : pattern.bindings input = some bindings) + (body : EvalExprWith calls (bindings ++ locals) rest result) : + EvalExprWith calls locals (.letValue pattern expr rest) result + | neg (value : EvalExprWith calls locals expr input) (operation : evalNeg input = .ok result) : + EvalExprWith calls locals (.neg expr) result + | binary (left : EvalExprWith calls locals lhs x) (right : EvalExprWith calls locals rhs y) + (operation : evalBinOp op x y = .ok result) : + EvalExprWith calls locals (.binary op lhs rhs) result + | call (arguments : EvalArgsWith calls locals args values) (callee : calls name values result) : + EvalExprWith calls locals (.call name args) result + | matchValue (value : EvalExprWith calls locals expr input) + (selected : selectArm input arms = some (bindings, body)) + (branch : EvalExprWith calls (bindings ++ locals) body result) : + EvalExprWith calls locals (.matchValue expr arms) result + + inductive EvalArgsWith [Field F] [DecidableEq F] (calls : CallRelation F) : + Environment F → List (Expr F) → List (Value F) → Prop where + | nil : EvalArgsWith calls locals [] [] + | cons (head : EvalExprWith calls locals expr value) + (tail : EvalArgsWith calls locals exprs values) : + EvalArgsWith calls locals (expr :: exprs) (value :: values) +end + +theorem EvalExprWith.toEvalExpr [Field F] [DecidableEq F] {program : Program F} + {locals : Environment F} {expr : Expr F} {result : Value F} + (evaluates : EvalExprWith (EvalCall program) locals expr result) : + EvalExpr program locals expr result := by + induction evaluates using EvalExprWith.rec + (motive_2 := fun locals exprs values _ => EvalArgs program locals exprs values) with + | literal => exact .literal + | var lookup => exact .var lookup + | tuple _ ih => exact .tuple ih + | project _ projected ih => exact .project ih projected + | letValue _ matched _ valueIH bodyIH => exact .letValue valueIH matched bodyIH + | neg _ operation ih => exact .neg ih operation + | binary _ _ operation leftIH rightIH => exact .binary leftIH rightIH operation + | call _ callee ih => exact .call ih callee + | matchValue _ selected _ valueIH bodyIH => exact .matchValue valueIH selected bodyIH + | nil => exact .nil + | cons _ _ headIH tailIH => exact .cons headIH tailIH + +theorem EvalExpr.toEvalExprWith [Field F] [DecidableEq F] {program : Program F} + {locals : Environment F} {expr : Expr F} {result : Value F} + (evaluates : EvalExpr program locals expr result) : + EvalExprWith (EvalCall program) locals expr result := by + induction evaluates using EvalExpr.rec + (motive_2 := fun locals exprs values _ => EvalArgsWith (EvalCall program) locals exprs values) + (motive_3 := fun _ _ _ _ => True) with + | literal => exact .literal + | var lookup => exact .var lookup + | tuple _ ih => exact .tuple ih + | project _ projected ih => exact .project ih projected + | letValue _ matched _ valueIH bodyIH => exact .letValue valueIH matched bodyIH + | neg _ operation ih => exact .neg ih operation + | binary _ _ operation leftIH rightIH => exact .binary leftIH rightIH operation + | call _ callee ih _ => exact .call ih callee + | matchValue _ selected _ valueIH bodyIH => exact .matchValue valueIH selected bodyIH + | nil => exact .nil + | cons _ _ headIH tailIH => exact .cons headIH tailIH + | intro => trivial + +end Aiur.Tuple diff --git a/Aiur/Aiur/Tuple/Typecheck.lean b/Aiur/Aiur/Tuple/Typecheck.lean new file mode 100644 index 000000000..6dea11b69 --- /dev/null +++ b/Aiur/Aiur/Tuple/Typecheck.lean @@ -0,0 +1,149 @@ +import Aiur.Tuple.AST + +namespace Aiur.Tuple + +inductive CheckError where + | duplicateFunction (name : String) + | duplicateParameter (function name : String) + | duplicateBinding (function name : String) + | unboundVariable (function name : String) + | unknownFunction (caller callee : String) + | arityMismatch (caller callee : String) (expected actual : Nat) + | typeMismatch (function : String) (expected actual : Ty) + | expectedTuple (function : String) + | tupleArity (function : String) (expected actual : Nat) + | projectionBounds (function : String) (index size : Nat) + | refutableBinding (function : String) + | emptyMatch (function : String) + deriving Repr, BEq, DecidableEq + +instance : ToString CheckError where + toString + | .duplicateFunction name => s!"duplicate function '{name}'" + | .duplicateParameter fn name => s!"duplicate parameter '{name}' in function '{fn}'" + | .duplicateBinding fn name => s!"duplicate pattern binding '{name}' in function '{fn}'" + | .unboundVariable fn name => s!"unbound variable '{name}' in function '{fn}'" + | .unknownFunction caller callee => s!"unknown function '{callee}' in function '{caller}'" + | .arityMismatch caller callee expected actual => + s!"function '{caller}' calls '{callee}' with {actual} arguments; expected {expected}" + | .typeMismatch fn expected actual => + s!"type mismatch in function '{fn}': expected {repr expected}, got {repr actual}" + | .expectedTuple fn => s!"expected a tuple in function '{fn}'" + | .tupleArity fn expected actual => + s!"tuple pattern in function '{fn}' has {actual} components; expected {expected}" + | .projectionBounds fn index size => + s!"tuple projection .{index} is out of bounds for size {size} in function '{fn}'" + | .refutableBinding fn => s!"let and parameter patterns must be irrefutable in function '{fn}'" + | .emptyMatch fn => s!"empty match in function '{fn}'" + +def findDuplicate : List String → List String → Option String + | [], _ => none + | name :: rest, seen => + if name ∈ seen then some name else findDuplicate rest (name :: seen) + +def requireType (caller : String) (expected actual : Ty) : Except CheckError Unit := + if expected = actual then .ok () else .error (.typeMismatch caller expected actual) + +mutual + def patternTypes (caller : String) (pattern : Pattern α) (type : Ty) : + Except CheckError (List (String × Ty)) := do + match pattern with + | .wildcard => return [] + | .bind name => return [(name, type)] + | .literal _ => requireType caller .field type; return [] + | .tuple patterns => + let .tuple types := type | throw (.expectedTuple caller) + if patterns.length != types.length then + throw (.tupleArity caller types.length patterns.length) + patternTypesList caller patterns types + termination_by sizeOf pattern + + def patternTypesList (caller : String) (patterns : List (Pattern α)) (types : List Ty) : + Except CheckError (List (String × Ty)) := do + match patterns, types with + | [], [] => return [] + | pattern :: patterns, type :: types => + return (← patternTypes caller pattern type) ++ (← patternTypesList caller patterns types) + | _, _ => throw (.tupleArity caller types.length patterns.length) + termination_by sizeOf patterns +end + +def checkPattern (caller : String) (pattern : Pattern α) (type : Ty) : + Except CheckError (List (String × Ty)) := do + let bindings ← patternTypes caller pattern type + if let some name := findDuplicate (bindings.map Prod.fst) [] then + throw (.duplicateBinding caller name) + return bindings + +mutual + def inferType (program : Program α) (caller : String) (locals : List (String × Ty)) + (expr : Expr α) : Except CheckError Ty := do + match expr with + | .literal _ => return .field + | .var name => + let some (_, type) := locals.find? (·.1 == name) | throw (.unboundVariable caller name) + return type + | .tuple items => return .tuple (← inferTypes program caller locals items) + | .project value index => + let .tuple types ← inferType program caller locals value | throw (.expectedTuple caller) + let some type := types[index]? | throw (.projectionBounds caller index types.length) + return type + | .letValue pattern value body => + let type ← inferType program caller locals value + let bindings ← checkPattern caller pattern type + if !pattern.irrefutable then throw (.refutableBinding caller) + inferType program caller (bindings ++ locals) body + | .neg value => + requireType caller .field (← inferType program caller locals value) + return .field + | .binary _ left right => + requireType caller .field (← inferType program caller locals left) + requireType caller .field (← inferType program caller locals right) + return .field + | .call name args => + let some fn := program.findFunction? name | throw (.unknownFunction caller name) + if fn.params.length != args.length then + throw (.arityMismatch caller name fn.params.length args.length) + let types ← inferTypes program caller locals args + for (expected, actual) in (fn.params.map Prod.snd).zip types do + requireType caller expected actual + return fn.result + | .matchValue scrutinee arms => + let type ← inferType program caller locals scrutinee + match arms with + | [] => throw (.emptyMatch caller) + | (pattern, body) :: rest => + let bindings ← checkPattern caller pattern type + let result ← inferType program caller (bindings ++ locals) body + checkArms program caller locals type result rest + return result + termination_by sizeOf expr + + def inferTypes (program : Program α) (caller : String) (locals : List (String × Ty)) + (exprs : List (Expr α)) : Except CheckError (List Ty) := do + match exprs with + | [] => return [] + | expr :: rest => + return (← inferType program caller locals expr) :: (← inferTypes program caller locals rest) + termination_by sizeOf exprs + + def checkArms (program : Program α) (caller : String) (locals : List (String × Ty)) + (scrutinee result : Ty) (arms : List (Pattern α × Expr α)) : Except CheckError Unit := do + match arms with + | [] => return () + | (pattern, body) :: rest => + let bindings ← checkPattern caller pattern scrutinee + requireType caller result (← inferType program caller (bindings ++ locals) body) + checkArms program caller locals scrutinee result rest + termination_by sizeOf arms +end + +def typecheck (program : Program α) : Except CheckError Unit := do + if let some name := findDuplicate (program.functions.map (·.name)) [] then + throw (.duplicateFunction name) + for fn in program.functions do + if let some name := findDuplicate (fn.params.map Prod.fst) [] then + throw (.duplicateParameter fn.name name) + requireType fn.name fn.result (← inferType program fn.name fn.params fn.body) + +end Aiur.Tuple diff --git a/Aiur/Aiur/Tuple/TypecheckFacts.lean b/Aiur/Aiur/Tuple/TypecheckFacts.lean new file mode 100644 index 000000000..2d9b2095f --- /dev/null +++ b/Aiur/Aiur/Tuple/TypecheckFacts.lean @@ -0,0 +1,316 @@ +import Aiur.Tuple.Semantics.WithCalls +import Aiur.Tuple.ValueFacts +import Mathlib.Data.List.Basic + +namespace Aiur.Tuple + +theorem except_bind_ok {first : Except ε α} {next : α → Except ε β} {result : β} : + (first >>= next) = .ok result ↔ ∃ value, first = .ok value ∧ next value = .ok result := by + cases first <;> simp [bind, Except.bind] + +theorem forIn_ok {action : α → Except ε Unit} {items : List α} + (checked : (do for item in items do action item : Except ε Unit) = .ok ()) : + ∀ item ∈ items, action item = .ok () := by + induction items with + | nil => simp + | cons item items ih => + cases first : action item with + | error error => simp [List.forIn_cons, first, bind, Except.bind] at checked + | ok finished => + cases finished + simp only [List.forIn_cons, first, bind, Except.bind, pure, Except.pure] at checked + intro value member + rcases List.mem_cons.mp member with rfl | member + · exact first + · exact ih checked value member + +@[simp] theorem except_pure_ok {value result : α} : + (pure value : Except ε α) = .ok result ↔ value = result := by simp [pure, Except.pure] + +@[simp] theorem except_throw_eq (error : ε) : (throw error : Except ε α) = .error error := rfl + +def environmentTypes (locals : Environment F) : List (String × Ty) := + locals.map fun binding => (binding.1, binding.2.type) + +@[simp] theorem environmentTypes_append (left right : Environment F) : + environmentTypes (left ++ right) = environmentTypes left ++ environmentTypes right := List.map_append + +theorem requireType_ok {caller : String} {expected actual : Ty} + (checked : requireType caller expected actual = .ok ()) : expected = actual := by + simpa [requireType] using checked + +theorem checkPattern_types {caller : String} {pattern : Pattern F} {type : Ty} + {bindings : List (String × Ty)} (checked : checkPattern caller pattern type = .ok bindings) : + patternTypes caller pattern type = .ok bindings := by + unfold checkPattern at checked + obtain ⟨types, typed, rest⟩ := except_bind_ok.mp checked + split at rest + · cases rest + · simp only [pure_bind, except_pure_ok] at rest + subst bindings + exact typed + +mutual + /-- Matching collects exactly the binding types computed by the typechecker. -/ + theorem patternTypes_bindings [DecidableEq F] {caller : String} {pattern : Pattern F} + {value : Value F} {types : List (String × Ty)} {bindings : Environment F} + (checked : patternTypes caller pattern value.type = .ok types) + (matched : pattern.bindings value = some bindings) : environmentTypes bindings = types := by + cases pattern with + | wildcard => + simp only [patternTypes, except_pure_ok] at checked + simp only [Pattern.bindings, Option.some.injEq] at matched + subst types; subst bindings; rfl + | bind name => + simp only [patternTypes, except_pure_ok] at checked + simp only [Pattern.bindings, Option.some.injEq] at matched + subst types; subst bindings; rfl + | literal literal => + cases value with + | tuple values => simp [Pattern.bindings] at matched + | field value => + simp [patternTypes, Value.type, requireType, bind, Except.bind, pure, Except.pure] at checked + subst types + simp only [Pattern.bindings] at matched + split at matched + · cases matched; rfl + · cases matched + | tuple patterns => + cases value with + | field => simp [Pattern.bindings] at matched + | tuple values => + simp only [Pattern.bindings] at matched + simp only [patternTypes, Value.type] at checked + split at checked + · cases checked + · simp only [pure_bind] at checked + exact patternTypesList_bindings checked matched + termination_by sizeOf pattern + + theorem patternTypesList_bindings [DecidableEq F] {caller : String} + {patterns : List (Pattern F)} {values : List (Value F)} + {types : List (String × Ty)} {bindings : Environment F} + (checked : patternTypesList caller patterns (values.map Value.type) = .ok types) + (matched : Pattern.bindingsList patterns values = some bindings) : environmentTypes bindings = types := by + cases patterns with + | nil => + cases values with + | nil => + simp only [patternTypesList, List.map_nil, except_pure_ok] at checked + simp only [Pattern.bindingsList, Option.some.injEq] at matched + subst types; subst bindings; rfl + | cons => simp [Pattern.bindingsList] at matched + | cons pattern patterns => + cases values with + | nil => simp [Pattern.bindingsList] at matched + | cons value values => + simp only [patternTypesList, List.map_cons] at checked + obtain ⟨headTypes, headRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨tailTypes, tailRun, finished⟩ := except_bind_ok.mp rest + obtain rfl := except_pure_ok.mp finished + cases headMatch : pattern.bindings value with + | none => simp [Pattern.bindingsList, headMatch] at matched + | some headBindings => + cases tailMatch : Pattern.bindingsList patterns values with + | none => simp [Pattern.bindingsList, headMatch, tailMatch] at matched + | some tailBindings => + simp [Pattern.bindingsList, headMatch, tailMatch] at matched + subst bindings + rw [environmentTypes_append, patternTypes_bindings headRun headMatch, + patternTypesList_bindings tailRun tailMatch] + termination_by sizeOf patterns +end + +theorem checkArms_selected [DecidableEq F] {program : Program F} {caller : String} + {locals : List (String × Ty)} {value : Value F} {type : Ty} + {arms : List (Pattern F × Expr F)} {bindings : Environment F} {body : Expr F} + (checked : checkArms program caller locals value.type type arms = .ok ()) + (selected : selectArm value arms = some (bindings, body)) : + inferType program caller (environmentTypes bindings ++ locals) body = .ok type := by + induction arms with + | nil => simp [selectArm] at selected + | cons arm arms ih => + rcases arm with ⟨pattern, branch⟩ + simp only [checkArms] at checked + obtain ⟨types, patternRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨branchType, branchRun, rest⟩ := except_bind_ok.mp rest + obtain ⟨finished, sameRun, tailRun⟩ := except_bind_ok.mp rest + cases finished + have same := requireType_ok sameRun + subst branchType + cases matched : pattern.bindings value with + | none => exact ih tailRun (by simpa only [selectArm, matched] using selected) + | some actual => + simp only [selectArm, matched, Option.some.injEq, Prod.mk.injEq] at selected + obtain ⟨rfl, rfl⟩ := selected + rw [patternTypes_bindings (checkPattern_types patternRun) matched] + exact branchRun + +/-- A call premise has the result shape of the function it names. -/ +def CallsTyped (program : Program F) (calls : CallRelation F) : Prop := + ∀ name args result, calls name args result → + ∀ fn, program.findFunction? name = some fn → result.type = fn.result + +private theorem checked_functions (program : Program F) (fns : List (Function F)) + (checked : (do + for fn in fns do + if let some name := findDuplicate (fn.params.map Prod.fst) [] then + throw (.duplicateParameter fn.name name) + requireType fn.name fn.result (← inferType program fn.name fn.params fn.body) + : Except CheckError Unit) = .ok ()) : + ∀ fn ∈ fns, inferType program fn.name fn.params fn.body = .ok fn.result := by + induction fns with + | nil => simp + | cons fn fns ih => + cases duplicate : findDuplicate (fn.params.map Prod.fst) [] with + | some name => simp [List.forIn_cons, duplicate, bind, Except.bind] at checked + | none => + cases inferred : inferType program fn.name fn.params fn.body with + | error error => simp [List.forIn_cons, duplicate, inferred, bind, Except.bind, pure, Except.pure] at checked + | ok type => + by_cases same : fn.result = type + · subst type + simp only [List.forIn_cons, duplicate, inferred, requireType, ↓reduceIte, + bind, Except.bind, pure, Except.pure] at checked + intro next member + rcases List.mem_cons.mp member with rfl | member + · exact inferred + · exact ih checked next member + · simp [List.forIn_cons, duplicate, inferred, requireType, same, + bind, Except.bind, pure, Except.pure] at checked + +theorem typecheck_function {program : Program F} (checked : typecheck program = .ok ()) + {fn : Function F} (member : fn ∈ program.functions) : + inferType program fn.name fn.params fn.body = .ok fn.result := by + unfold typecheck at checked + split at checked + · cases checked + · simp only [pure_bind] at checked + exact checked_functions program program.functions checked fn member + +/-- Successful evaluation preserves inferred tuple shape when call premises have their declared shapes. -/ +theorem EvalExprWith.type [Field F] [DecidableEq F] {program : Program F} {calls : CallRelation F} + (typed : CallsTyped program calls) {locals : Environment F} {expr : Expr F} {result : Value F} + (evaluated : EvalExprWith calls locals expr result) : + ∀ caller type, inferType program caller (environmentTypes locals) expr = .ok type → result.type = type := by + induction evaluated using EvalExprWith.rec + (motive_2 := fun locals exprs values _ => ∀ caller types, + inferTypes program caller (environmentTypes locals) exprs = .ok types → values.map Value.type = types) with + | literal => + intro caller type checked + simpa [inferType, Value.type, pure, Except.pure] using checked + | var lookup => + intro caller type checked + simpa [inferType, environmentTypes, List.find?_map, Function.comp_def, lookup, + pure, Except.pure] using checked + | tuple _ ih => + intro caller type checked + simp only [inferType] at checked + obtain ⟨types, itemsRun, finished⟩ := except_bind_ok.mp checked + obtain rfl := except_pure_ok.mp finished + simp [Value.type, ih caller types itemsRun] + | @project locals expr input index result _ projected ih => + intro caller type checked + simp only [inferType] at checked + obtain ⟨inputType, inputRun, rest⟩ := except_bind_ok.mp checked + have inputShape := ih caller inputType inputRun + cases input with + | field => cases projected + | tuple values => + simp only [Value.type] at inputShape + subst inputType + cases found : (values.map Value.type)[index]? with + | none => simp [found] at rest + | some itemType => + simp only [found, except_pure_ok] at rest + subst type + cases source : values[index]? with + | none => simp [projectValue, source] at projected + | some value => + simp [projectValue, source, pure, Except.pure] at projected + subst result + simpa [List.getElem?_map, source] using found + | letValue _ matched _ valueIH bodyIH => + intro caller type checked + simp only [inferType] at checked + obtain ⟨valueType, valueRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨bindingTypes, patternRun, rest⟩ := except_bind_ok.mp rest + split at rest + · cases rest + · simp only [pure_bind] at rest + have shape := valueIH caller valueType valueRun + have bindings := patternTypes_bindings (caller := caller) + (by rw [shape]; exact checkPattern_types patternRun) matched + exact bodyIH caller type (by simpa only [environmentTypes_append, bindings] using rest) + | @neg locals expr input result _ operation ih => + intro caller type checked + simp only [inferType] at checked + obtain ⟨inputType, _, rest⟩ := except_bind_ok.mp checked + obtain ⟨finished, _, rest⟩ := except_bind_ok.mp rest + obtain rfl := except_pure_ok.mp rest + cases input with + | field x => cases operation; simp [Value.type] + | tuple => cases operation + | @binary locals lhs x rhs y op result _ _ operation leftIH rightIH => + intro caller type checked + simp only [inferType] at checked + obtain ⟨leftType, _, rest⟩ := except_bind_ok.mp checked + obtain ⟨finished, _, rest⟩ := except_bind_ok.mp rest + obtain ⟨rightType, _, rest⟩ := except_bind_ok.mp rest + obtain ⟨finished, _, rest⟩ := except_bind_ok.mp rest + obtain rfl := except_pure_ok.mp rest + cases x with + | tuple => cases operation + | field x => + cases y with + | tuple => cases operation + | field y => + cases op <;> simp only [evalBinOp] at operation + all_goals first + | (split at operation <;> cases operation; simp [Value.type]) + | (cases operation; simp [Value.type]) + | @call locals args values name result _ callee ih => + intro caller type checked + cases found : program.findFunction? name with + | none => simp [inferType, found] at checked + | some fn => + simp only [inferType, found] at checked + split at checked + · cases checked + · simp only [pure_bind] at checked + obtain ⟨types, _, rest⟩ := except_bind_ok.mp checked + obtain ⟨finished, _, rest⟩ := except_bind_ok.mp rest + obtain rfl := except_pure_ok.mp rest + exact typed name values result callee fn found + | @matchValue locals expr input arms bindings body result _ selected _ valueIH bodyIH => + intro caller type checked + simp only [inferType] at checked + obtain ⟨inputType, inputRun, rest⟩ := except_bind_ok.mp checked + have shape := valueIH caller inputType inputRun + cases arms with + | nil => simp [selectArm] at selected + | cons arm arms => + rcases arm with ⟨pattern, branch⟩ + obtain ⟨bindingTypes, patternRun, rest⟩ := except_bind_ok.mp rest + obtain ⟨branchType, branchRun, rest⟩ := except_bind_ok.mp rest + obtain ⟨finished, armsRun, rest⟩ := except_bind_ok.mp rest + cases finished + obtain rfl := except_pure_ok.mp rest + have allChecked : checkArms program caller (environmentTypes locals) input.type branchType + ((pattern, branch) :: arms) = .ok () := by + rw [shape] + simp [checkArms, patternRun, branchRun, requireType, armsRun, bind, Except.bind] + exact bodyIH caller branchType (by + simpa only [environmentTypes_append] using checkArms_selected allChecked selected) + | nil => + rename_i caller types checked + simpa [inferTypes, pure, Except.pure] using checked + | cons _ _ headIH tailIH => + rename_i caller types checked + simp only [inferTypes] at checked + obtain ⟨headType, headRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨tailTypes, tailRun, rest⟩ := except_bind_ok.mp rest + obtain rfl := except_pure_ok.mp rest + simp [headIH caller headType headRun, tailIH caller tailTypes tailRun] + +end Aiur.Tuple diff --git a/Aiur/Aiur/Tuple/ValueFacts.lean b/Aiur/Aiur/Tuple/ValueFacts.lean new file mode 100644 index 000000000..41bd3fa6e --- /dev/null +++ b/Aiur/Aiur/Tuple/ValueFacts.lean @@ -0,0 +1,68 @@ +import Aiur.Tuple.AST +import Mathlib.Data.List.Basic + +namespace Aiur.Tuple.Value + +theorem map_congr (value : Value α) {f g : α → β} + (agree : ∀ x ∈ value.flatten, f x = g x) : value.map f = value.map g := by + cases value with + | field x => simp only [Value.map, agree x (by simp [Value.flatten])] + | tuple items => + simp only [Value.map, Value.tuple.injEq] + apply List.map_congr_left + intro value member + apply map_congr value + intro x inside + exact agree x (by simpa only [Value.flatten, List.mem_flatMap] using ⟨value, member, inside⟩) +termination_by sizeOf value +decreasing_by + simp_all only [Value.tuple.sizeOf_spec] + have := List.sizeOf_lt_of_mem ‹_ ∈ _› + omega + +@[simp] theorem flatten_map (f : α → β) (value : Value α) : + (value.map f).flatten = value.flatten.map f := by + cases value with + | field => simp [Value.map, Value.flatten] + | tuple items => + simp only [Value.map, Value.flatten, List.flatMap_map, List.map_flatMap] + apply List.flatMap_congr + intro value member + exact flatten_map f value +termination_by sizeOf value +decreasing_by + simp_wf + have := List.sizeOf_lt_of_mem ‹_ ∈ _› + omega + +@[simp] theorem map_map (f : α → β) (g : β → γ) (value : Value α) : + (value.map f).map g = value.map (g ∘ f) := by + cases value with + | field => simp [Value.map] + | tuple items => + simp only [Value.map, List.map_map, Value.tuple.injEq] + apply List.map_congr_left + intro value member + exact map_map f g value +termination_by sizeOf value +decreasing_by + simp_wf + have := List.sizeOf_lt_of_mem ‹_ ∈ _› + omega + +@[simp] theorem type_map (f : α → β) (value : Value α) : + (value.map f).type = value.type := by + cases value with + | field => simp [Value.map, Value.type] + | tuple items => + simp only [Value.map, Value.type, List.map_map, Ty.tuple.injEq] + apply List.map_congr_left + intro value member + exact type_map f value +termination_by sizeOf value +decreasing_by + simp_wf + have := List.sizeOf_lt_of_mem ‹_ ∈ _› + omega + +end Aiur.Tuple.Value diff --git a/Aiur/Aiur/Typecheck.lean b/Aiur/Aiur/Typecheck.lean new file mode 100644 index 000000000..fbb495652 --- /dev/null +++ b/Aiur/Aiur/Typecheck.lean @@ -0,0 +1,251 @@ +import Aiur.Declarations +import Aiur.TableUniqueness + +namespace Aiur + +inductive CheckError where + | invalidDeclarations (error : DeclError) + | pointerType (context : String) (type : Ty) + | unknownConstructor (enumName constructor : String) + | constructorArity (enumName constructor : String) (expected actual : Nat) + | duplicateFunction (name : String) + | duplicateParameter (function name : String) + | duplicateBinding (function name : String) + | unboundVariable (function name : String) + | unknownFunction (caller callee : String) + | arityMismatch (caller callee : String) (expected actual : Nat) + | typeMismatch (function : String) (expected actual : Ty) + | expectedPointer (function : String) + | expectedTuple (function : String) + | tupleArity (function : String) (expected actual : Nat) + | projectionBounds (function : String) (index size : Nat) + | emptyMatch (function : String) + | duplicateTable (name : String) + | unknownTable (map table : String) + | malformedTableRow (table : String) (index : Nat) + | tableRowType (table : String) (index : Nat) (expected actual : Ty) + | tableLength (map : String) (inputs outputs : Nat) + | duplicateInput (map table : String) + deriving Repr, BEq, DecidableEq + +instance : ToString CheckError where + toString + | .invalidDeclarations error => toString error + | .pointerType context type => s!"{context} requires a pointer-free type; got {repr type}" + | .unknownConstructor name ctor => s!"unknown constructor '{name}::{ctor}'" + | .constructorArity name ctor expected actual => + s!"constructor '{name}::{ctor}' has {actual} arguments; expected {expected}" + | .duplicateFunction name => s!"duplicate function '{name}'" + | .duplicateParameter fn name => s!"duplicate parameter '{name}' in function '{fn}'" + | .duplicateBinding fn name => s!"duplicate pattern binding '{name}' in function '{fn}'" + | .unboundVariable fn name => s!"unbound variable '{name}' in function '{fn}'" + | .unknownFunction caller callee => s!"unknown function '{callee}' in function '{caller}'" + | .arityMismatch caller callee expected actual => + s!"function '{caller}' calls '{callee}' with {actual} arguments; expected {expected}" + | .typeMismatch fn expected actual => + s!"type mismatch in function '{fn}': expected {repr expected}, got {repr actual}" + | .expectedPointer fn => s!"expected a pointer in function '{fn}'" + | .expectedTuple fn => s!"expected a tuple in function '{fn}'" + | .tupleArity fn expected actual => + s!"tuple pattern in function '{fn}' has {actual} components; expected {expected}" + | .projectionBounds fn index size => + s!"tuple projection .{index} is out of bounds for size {size} in function '{fn}'" + | .emptyMatch fn => s!"empty match in function '{fn}'" + | .duplicateTable name => s!"duplicate table '{name}'" + | .unknownTable map table => s!"map '{map}' refers to unknown table '{table}'" + | .malformedTableRow table index => s!"malformed value in table '{table}', row {index}" + | .tableRowType table index expected actual => + s!"table '{table}', row {index}: expected {repr expected}, got {repr actual}" + | .tableLength map inputs outputs => + s!"map '{map}' has {inputs} input rows and {outputs} output rows" + | .duplicateInput map table => s!"map '{map}' uses repeated input rows in table '{table}'" + +def findDuplicate : List String → List String → Option String + | [], _ => none + | name :: rest, seen => + if name ∈ seen then some name else findDuplicate rest (name :: seen) + +def requireType (caller : String) (expected actual : Ty) : Except CheckError Unit := + if expected = actual then .ok () else .error (.typeMismatch caller expected actual) + +/-- Check the declared type even when no value or table row is supplied. -/ +def requirePointerFree (decls : Declarations) (context : String) (type : Ty) : Except CheckError Unit := + if type.pointerFree decls then .ok () else .error (.pointerType context type) + +def checkHintType (decls : Declarations) (caller : String) (type : Ty) : Except CheckError Ty := do + (type.checkNames decls).mapError CheckError.invalidDeclarations + requirePointerFree decls s!"hint in '{caller}'" type + return type + +mutual + def patternTypes (decls : Declarations) (caller : String) (pattern : Pattern α) (type : Ty) : + Except CheckError (List (String × Ty)) := do + match pattern with + | .wildcard => return [] + | .bind name => return [(name, type)] + | .literal _ => requireType caller .field type; return [] + | .tuple patterns => + let .tuple types := type | throw (.expectedTuple caller) + if patterns.length != types.length then + throw (.tupleArity caller types.length patterns.length) + patternTypesList decls caller patterns types + | .construct name ctor patterns => + requireType caller (.enum name) type + let some definition := decls.findConstructor? name ctor + | throw (.unknownConstructor name ctor) + if patterns.length != definition.fields.length then + throw (.constructorArity name ctor definition.fields.length patterns.length) + patternTypesList decls caller patterns definition.fields + termination_by sizeOf pattern + + def patternTypesList (decls : Declarations) (caller : String) (patterns : List (Pattern α)) (types : List Ty) : + Except CheckError (List (String × Ty)) := do + match patterns, types with + | [], [] => return [] + | pattern :: patterns, type :: types => + return (← patternTypes decls caller pattern type) ++ (← patternTypesList decls caller patterns types) + | _, _ => throw (.tupleArity caller types.length patterns.length) + termination_by sizeOf patterns +end + +def checkPattern (decls : Declarations) (caller : String) (pattern : Pattern α) (type : Ty) : + Except CheckError (List (String × Ty)) := do + let bindings ← patternTypes decls caller pattern type + if let some name := findDuplicate (bindings.map Prod.fst) [] then + throw (.duplicateBinding caller name) + return bindings + +mutual + def inferType (program : Program α) (caller : String) (locals : List (String × Ty)) + (expr : Expr α) : Except CheckError Ty := do + match expr with + | .literal _ => return .field + | .var name => + let some (_, type) := locals.find? (·.1 == name) | throw (.unboundVariable caller name) + return type + | .tuple items => return .tuple (← inferTypes program caller locals items) + | .construct name ctor args => + let some definition := program.enums.findConstructor? name ctor + | throw (.unknownConstructor name ctor) + if args.length != definition.fields.length then + throw (.constructorArity name ctor definition.fields.length args.length) + let types ← inferTypes program caller locals args + for (expected, actual) in definition.fields.zip types do + requireType caller expected actual + return .enum name + | .project value index => + let .tuple types ← inferType program caller locals value | throw (.expectedTuple caller) + let some type := types[index]? | throw (.projectionBounds caller index types.length) + return type + | .letValue pattern value body => + let type ← inferType program caller locals value + let bindings ← checkPattern program.enums caller pattern type + inferType program caller (bindings ++ locals) body + | .store value => return .ptr (← inferType program caller locals value) + | .load pointer => + let .ptr target ← inferType program caller locals pointer | throw (.expectedPointer caller) + return target + | .hint type key channel => + let keyType ← inferType program caller locals key + requirePointerFree program.enums s!"hint key in '{caller}'" keyType + checkHintType program.enums caller type + | .neg value => + requireType caller .field (← inferType program caller locals value) + return .field + | .assertEq _ left right => + let type ← inferType program caller locals left + requireType caller type (← inferType program caller locals right) + if !type.pointerFree program.enums then throw (.pointerType "assert_eq!" type) + return .tuple [] + | .binary _ left right => + requireType caller .field (← inferType program caller locals left) + requireType caller .field (← inferType program caller locals right) + return .field + | .call name args => + let some fn := program.findSignature? name | throw (.unknownFunction caller name) + if fn.params.length != args.length then + throw (.arityMismatch caller name fn.params.length args.length) + let types ← inferTypes program caller locals args + for (expected, actual) in (fn.params.map Prod.snd).zip types do + requireType caller expected actual + return fn.result + | .matchValue scrutinee arms => + let type ← inferType program caller locals scrutinee + match arms with + | [] => throw (.emptyMatch caller) + | (pattern, body) :: rest => + let bindings ← checkPattern program.enums caller pattern type + let result ← inferType program caller (bindings ++ locals) body + checkArms program caller locals type result rest + return result + termination_by sizeOf expr + + def inferTypes (program : Program α) (caller : String) (locals : List (String × Ty)) + (exprs : List (Expr α)) : Except CheckError (List Ty) := do + match exprs with + | [] => return [] + | expr :: rest => + return (← inferType program caller locals expr) :: (← inferTypes program caller locals rest) + termination_by sizeOf exprs + + def checkArms (program : Program α) (caller : String) (locals : List (String × Ty)) + (scrutinee result : Ty) (arms : List (Pattern α × Expr α)) : Except CheckError Unit := do + match arms with + | [] => return () + | (pattern, body) :: rest => + let bindings ← checkPattern program.enums caller pattern scrutinee + requireType caller result (← inferType program caller (bindings ++ locals) body) + checkArms program caller locals scrutinee result rest + termination_by sizeOf arms +end + +def checkFunction (program : Program α) (fn : Function α) : Except CheckError Unit := do + for (_, type) in fn.params do + (type.checkNames program.enums).mapError CheckError.invalidDeclarations + (fn.result.checkNames program.enums).mapError CheckError.invalidDeclarations + if let some name := findDuplicate (fn.params.map Prod.fst) [] then + throw (.duplicateParameter fn.name name) + requireType fn.name fn.result (← inferType program fn.name fn.params fn.body) + +def checkTableRow (program : Program α) (table : Table α) + (entry : Constant α × Nat) : Except CheckError Unit := do + let (row, index) := entry + if row.type ≠ table.rowType then + throw (.tableRowType table.name index table.rowType row.type) + if !row.wellFormed program.enums then throw (.malformedTableRow table.name index) + +def checkTable (program : Program α) (table : Table α) : Except CheckError Unit := do + (table.rowType.checkNames program.enums).mapError CheckError.invalidDeclarations + requirePointerFree program.enums s!"table '{table.name}'" table.rowType + for entry in table.rows.zipIdx do checkTableRow program table entry + +def checkMap [DecidableEq α] (program : Program α) (map : MapDecl) : Except CheckError Unit := do + for (_, type) in map.params do + (type.checkNames program.enums).mapError CheckError.invalidDeclarations + (map.result.checkNames program.enums).mapError CheckError.invalidDeclarations + requirePointerFree program.enums s!"map '{map.name}' inputs" (.tuple (map.params.map Prod.snd)) + requirePointerFree program.enums s!"map '{map.name}' result" map.result + if let some name := findDuplicate (map.params.map Prod.fst) [] then + throw (.duplicateParameter map.name name) + let some inputs := program.findTable? map.input | throw (.unknownTable map.name map.input) + let some outputs := program.findTable? map.output | throw (.unknownTable map.name map.output) + requireType map.name (.tuple (map.params.map Prod.snd)) inputs.rowType + requireType map.name map.result outputs.rowType + if inputs.rows.length != outputs.rows.length then + throw (.tableLength map.name inputs.rows.length outputs.rows.length) + if !tableRowsNodup inputs.rows then throw (.duplicateInput map.name map.input) + +def checkTables [DecidableEq α] (program : Program α) : Except CheckError Unit := do + if let some name := findDuplicate (program.tables.map (·.name)) [] then + throw (.duplicateTable name) + for table in program.tables do checkTable program table + for map in program.maps do checkMap program map + +def typecheck [DecidableEq α] (program : Program α) : Except CheckError Unit := do + (checkDeclarations program.enums).mapError CheckError.invalidDeclarations + if let some name := findDuplicate (program.functions.map (·.name) ++ program.maps.map (·.name)) [] then + throw (.duplicateFunction name) + checkTables program + for fn in program.functions do checkFunction program fn + +end Aiur diff --git a/Aiur/Aiur/TypecheckFacts.lean b/Aiur/Aiur/TypecheckFacts.lean new file mode 100644 index 000000000..9b5ee0951 --- /dev/null +++ b/Aiur/Aiur/TypecheckFacts.lean @@ -0,0 +1,285 @@ +import Aiur.PatternTyping +import Aiur.Semantics.WithCalls +import Aiur.ValueFacts +import Aiur.ExceptFacts +import Mathlib.Data.List.Forall2 + +namespace Aiur + +theorem checkHintType_ok {decls : Declarations} {caller : String} {type result : Ty} + (checked : checkHintType decls caller type = .ok result) : + result = type ∧ type.pointerFree decls = true := by + cases names : type.checkNames decls with + | error error => simp [checkHintType, names, Except.mapError, bind, Except.bind] at checked + | ok done => + cases done + cases free : type.pointerFree decls <;> + simp_all [checkHintType, names, requirePointerFree, Except.mapError, bind, Except.bind, + pure, Except.pure] + +variable {F : Type} {rom : ROM F} + +/-- A call premise has the result shape of the function or map it names. -/ +def CallsTyped (program : Program F) (calls : CallRelation F) : Prop := + ∀ name args result, calls name args result → + ∀ fn, program.findSignature? name = some fn → result.type = fn.result ∧ result.wellFormed program.enums = true + +theorem typecheck_declarations [DecidableEq F] {program : Program F} (checked : typecheck program = .ok ()) : + checkDeclarations program.enums = .ok () := by + unfold typecheck at checked + obtain ⟨done, declarations, _⟩ := except_bind_ok.mp checked + cases run : checkDeclarations program.enums with + | error error => simp [run, Except.mapError] at declarations + | ok unit => cases unit; rfl + +theorem typecheck_function [DecidableEq F] {program : Program F} (checked : typecheck program = .ok ()) + {fn : Function F} (member : fn ∈ program.functions) : + inferType program fn.name fn.params fn.body = .ok fn.result := by + unfold typecheck at checked + obtain ⟨done, _, rest⟩ := except_bind_ok.mp checked + split at rest + · cases rest + · simp only [pure_bind] at rest + obtain ⟨_, _, rest⟩ := except_bind_ok.mp rest + have body := forIn_ok rest fn member + unfold checkFunction at body + obtain ⟨_, _, body⟩ := except_bind_ok.mp body + obtain ⟨_, _, body⟩ := except_bind_ok.mp body + split at body + · cases body + · simp only [pure_bind] at body + obtain ⟨type, inferred, same⟩ := except_bind_ok.mp body + rw [← requireType_ok same] at inferred + exact inferred + +theorem inferTypes_length {program : Program F} {caller : String} {locals : List (String × Ty)} + {exprs : List (Expr F)} {types : List Ty} + (checked : inferTypes program caller locals exprs = .ok types) : types.length = exprs.length := by + induction exprs generalizing types with + | nil => simp only [inferTypes, except_pure_ok] at checked; subst types; rfl + | cons expr exprs ih => + simp only [inferTypes] at checked + obtain ⟨type, _, rest⟩ := except_bind_ok.mp checked + obtain ⟨types, tail, finished⟩ := except_bind_ok.mp rest + obtain rfl := except_pure_ok.mp finished + simp [ih tail] + +theorem requireTypes_ok {caller : String} {expected actual : List Ty} + (length : expected.length = actual.length) + (checked : (do for (e, a) in expected.zip actual do requireType caller e a : Except CheckError Unit) = .ok ()) : + expected = actual := by + have all := forIn_ok checked + have related : List.Forall₂ Eq expected actual := List.forall₂_iff_zip.mpr + ⟨length, fun h => requireType_ok (all _ h)⟩ + simpa only [List.forall₂_eq_eq_eq] using related + +/-- Typed ROM cells supply well-formed constructor data to loads. -/ +def ROM.WellFormed (decls : Declarations) (rom : ROM F) : Prop := + ∀ entry ∈ rom.entries, entry.2.wellFormed decls = true + +/-- Evaluation preserves declared types and constructor payload invariants. -/ +theorem ROMEvalExprWith.wellTyped [Field F] [DecidableEq F] {program : Program F} {calls : CallRelation F} + (typed : CallsTyped program calls) (memory : rom.WellFormed program.enums) + {locals : Environment F} {expr : Expr F} {result : Value F} + (evaluated : ROMEvalExprWith program.enums rom calls locals expr result) : + locals.WellFormed program.enums → ∀ caller type, + inferType program caller (environmentTypes locals) expr = .ok type → + result.type = type ∧ result.wellFormed program.enums = true := by + induction evaluated using ROMEvalExprWith.rec + (motive_2 := fun locals exprs values _ => locals.WellFormed program.enums → ∀ caller types, + inferTypes program caller (environmentTypes locals) exprs = .ok types → + values.map Value.type = types ∧ ∀ value ∈ values, value.wellFormed program.enums = true) with + | literal => + intro formed caller type checked + refine ⟨?_, by simp⟩ + simpa [inferType, Value.type, pure, Except.pure] using checked + | var lookup => + intro formed caller type checked + refine ⟨?_, formed _ (List.mem_of_find?_eq_some lookup)⟩ + simpa [inferType, environmentTypes, List.find?_map, Function.comp_def, lookup, + pure, Except.pure] using checked + | hint _ typed _ => + intro formed caller type checked + simp only [inferType] at checked + obtain ⟨_, _, checked⟩ := except_bind_ok.mp checked + obtain ⟨_, _, checked⟩ := except_bind_ok.mp checked + obtain ⟨rfl, _⟩ := checkHintType_ok checked + simpa [Value.WellTyped, Value.hasType, Constant.toValue] using typed + | tuple _ ih => + intro formed caller type checked + simp only [inferType] at checked + obtain ⟨types, itemsRun, finished⟩ := except_bind_ok.mp checked + obtain rfl := except_pure_ok.mp finished + obtain ⟨shape, valuesFormed⟩ := ih formed caller types itemsRun + exact ⟨by simp [Value.type, shape], (Value.wellFormed_tuple _ _).mpr valuesFormed⟩ + | @construct locals exprs values name ctor _ ih => + intro formed caller type checked + cases found : program.enums.findConstructor? name ctor with + | none => simp [inferType, found] at checked + | some definition => + simp only [inferType, found] at checked + split at checked + · cases checked + · rename_i arity + simp only [pure_bind] at checked + obtain ⟨types, argsRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨finished, typesRun, rest⟩ := except_bind_ok.mp rest + cases finished + obtain rfl := except_pure_ok.mp rest + obtain ⟨shape, valuesFormed⟩ := ih formed caller types argsRun + have length : definition.fields.length = types.length := by + have len := inferTypes_length argsRun + have arity : exprs.length = definition.fields.length := by simpa using arity + omega + have combined := congrArg (fun r : Except CheckError PUnit => r >>= fun _ => + (pure () : Except CheckError Unit)) typesRun + have typesEq := requireTypes_ok (caller := caller) length + (by simpa only [bind, Except.bind, pure, Except.pure] using combined) + refine ⟨by simp [Value.type], (Value.wellFormed_construct _ _ _ _).mpr ?_⟩ + exact ⟨definition, found, shape.trans typesEq.symm, valuesFormed⟩ + | @project locals expr input index result _ projected ih => + intro formed caller type checked + simp only [inferType] at checked + obtain ⟨inputType, inputRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨inputShape, inputFormed⟩ := ih formed caller inputType inputRun + cases input with + | field | ptr | construct => cases projected + | tuple values => + simp only [Value.type] at inputShape + subst inputType + cases found : (values.map Value.type)[index]? with + | none => simp [found] at rest + | some itemType => + simp only [found, except_pure_ok] at rest + subst type + cases source : values[index]? with + | none => simp [projectValue, source] at projected + | some value => + simp [projectValue, source, pure, Except.pure] at projected + subst result + refine ⟨?_, (Value.wellFormed_tuple _ _).mp inputFormed _ (List.mem_of_getElem? source)⟩ + simpa [List.getElem?_map, source] using found + | letValue _ matched _ valueIH bodyIH => + intro formed caller type checked + simp only [inferType] at checked + obtain ⟨valueType, valueRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨bindingTypes, patternRun, rest⟩ := except_bind_ok.mp rest + obtain ⟨shape, inputFormed⟩ := valueIH formed caller valueType valueRun + have bindings := patternTypes_bindings (caller := caller) + (by rw [shape]; exact checkPattern_types patternRun) inputFormed matched + exact bodyIH (Environment.wellFormed_append.mpr + ⟨Pattern.bindings_wellFormed inputFormed matched, formed⟩) caller type + (by simpa only [environmentTypes_append, bindings] using rest) + | store _ _ ih => + intro formed caller type checked + simp only [inferType] at checked + obtain ⟨inputType, inputRun, rest⟩ := except_bind_ok.mp checked + obtain rfl := except_pure_ok.mp rest + exact ⟨by simp [Value.type, (ih formed caller inputType inputRun).1], by simp⟩ + | @load locals expr target address result _ cell shape ih => + intro formed caller type checked + simp only [inferType] at checked + obtain ⟨inputType, inputRun, rest⟩ := except_bind_ok.mp checked + have pointerShape := (ih formed caller inputType inputRun).1 + simp only [Value.type] at pointerShape + subst inputType + obtain rfl := except_pure_ok.mp rest + exact ⟨shape, memory _ cell⟩ + | @neg locals expr input result _ operation ih => + intro formed caller type checked + simp only [inferType] at checked + obtain ⟨inputType, _, rest⟩ := except_bind_ok.mp checked + obtain ⟨finished, _, rest⟩ := except_bind_ok.mp rest + obtain rfl := except_pure_ok.mp rest + cases input with + | field x => cases operation; simp [Value.type] + | tuple | ptr | construct => cases operation + | @assertEq locals lhs x rhs y op result _ _ operation leftIH rightIH => + intro formed caller type checked + simp only [inferType] at checked + obtain ⟨leftType, leftRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨rightType, rightRun, rest⟩ := except_bind_ok.mp rest + obtain ⟨finished, _, rest⟩ := except_bind_ok.mp rest + have resultUnit := (evalAssertEq_ok.mp operation).2.2 + subst result + split at rest + · simp [bind, Except.bind] at rest + · have same : type = .tuple [] := by simpa [bind, Except.bind, pure, Except.pure] using rest.symm + subst type + simp [Value.type] + | @binary locals lhs x rhs y op result _ _ operation leftIH rightIH => + intro formed caller type checked + simp only [inferType] at checked + obtain ⟨leftType, _, rest⟩ := except_bind_ok.mp checked + obtain ⟨finished, _, rest⟩ := except_bind_ok.mp rest + obtain ⟨rightType, _, rest⟩ := except_bind_ok.mp rest + obtain ⟨finished, _, rest⟩ := except_bind_ok.mp rest + obtain rfl := except_pure_ok.mp rest + cases x with + | tuple | ptr | construct => cases operation + | field x => + cases y with + | tuple | ptr | construct => cases operation + | field y => + cases op <;> simp only [evalBinOp] at operation + all_goals first + | (split at operation <;> cases operation; simp [Value.type]) + | (cases operation; simp [Value.type]) + | @call locals args values name result _ callee ih => + intro formed caller type checked + cases found : program.findSignature? name with + | none => simp [inferType, found] at checked + | some fn => + simp only [inferType, found] at checked + split at checked + · cases checked + · simp only [pure_bind] at checked + obtain ⟨types, _, rest⟩ := except_bind_ok.mp checked + obtain ⟨finished, _, rest⟩ := except_bind_ok.mp rest + obtain rfl := except_pure_ok.mp rest + exact typed name values result callee fn found + | @matchValue locals expr input arms bindings body result _ selected _ valueIH bodyIH => + intro formed caller type checked + simp only [inferType] at checked + obtain ⟨inputType, inputRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨shape, inputFormed⟩ := valueIH formed caller inputType inputRun + cases arms with + | nil => simp [selectArm] at selected + | cons arm arms => + rcases arm with ⟨pattern, branch⟩ + obtain ⟨bindingTypes, patternRun, rest⟩ := except_bind_ok.mp rest + obtain ⟨branchType, branchRun, rest⟩ := except_bind_ok.mp rest + obtain ⟨finished, armsRun, rest⟩ := except_bind_ok.mp rest + cases finished + obtain rfl := except_pure_ok.mp rest + have allChecked : checkArms program caller (environmentTypes locals) input.type branchType + ((pattern, branch) :: arms) = .ok () := by + rw [shape] + simp [checkArms, patternRun, branchRun, requireType, armsRun, bind, Except.bind] + exact bodyIH (Environment.wellFormed_append.mpr + ⟨selectArm_wellFormed inputFormed selected, formed⟩) caller branchType (by + simpa only [environmentTypes_append] using checkArms_selected allChecked inputFormed selected) + | nil => + rename_i formed caller types checked + simp only [inferTypes, except_pure_ok] at checked + subst types + exact ⟨rfl, by simp⟩ + | cons _ _ headIH tailIH => + rename_i formed caller types checked + simp only [inferTypes] at checked + obtain ⟨headType, headRun, rest⟩ := except_bind_ok.mp checked + obtain ⟨tailTypes, tailRun, rest⟩ := except_bind_ok.mp rest + obtain rfl := except_pure_ok.mp rest + obtain ⟨headType, headFormed⟩ := headIH formed caller headType headRun + obtain ⟨tailTypes, tailFormed⟩ := tailIH formed caller tailTypes tailRun + exact ⟨by simp [headType, tailTypes], by simpa [headFormed] using tailFormed⟩ + +theorem ROMEvalExprWith.type [Field F] [DecidableEq F] {program : Program F} {calls : CallRelation F} + (typed : CallsTyped program calls) (memory : rom.WellFormed program.enums) + {locals : Environment F} {expr : Expr F} {result : Value F} + (evaluated : ROMEvalExprWith program.enums rom calls locals expr result) + (formed : locals.WellFormed program.enums) (caller : String) (type : Ty) + (checked : inferType program caller (environmentTypes locals) expr = .ok type) : result.type = type := + (evaluated.wellTyped typed memory formed caller type checked).1 + +end Aiur diff --git a/Aiur/Aiur/ValueFacts.lean b/Aiur/Aiur/ValueFacts.lean new file mode 100644 index 000000000..d55cd427f --- /dev/null +++ b/Aiur/Aiur/ValueFacts.lean @@ -0,0 +1,81 @@ +import Aiur.AST +import Mathlib.Data.List.Basic + +namespace Aiur.Value + +theorem map_congr (value : Value α) {f g : α → β} + (agree : ∀ x ∈ value.flatten, f x = g x) : value.map f = value.map g := by + cases value with + | field x => simp only [Value.map, agree x (by simp [Value.flatten])] + | ptr target x => simp only [Value.map, agree x (by simp [Value.flatten])] + | tuple items | construct _ _ items => + simp only [Value.map, Value.tuple.injEq, Value.construct.injEq, true_and] + apply List.map_congr_left + intro value member + apply map_congr value + intro x inside + exact agree x (by simpa only [Value.flatten, List.mem_flatMap] using ⟨value, member, inside⟩) +termination_by sizeOf value +decreasing_by + all_goals + simp_wf + have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + simp_all only [Value.tuple.sizeOf_spec, Value.construct.sizeOf_spec] + omega + +@[simp] theorem flatten_map (f : α → β) (value : Value α) : + (value.map f).flatten = value.flatten.map f := by + cases value with + | field => simp [Value.map, Value.flatten] + | ptr => simp [Value.map, Value.flatten] + | tuple items | construct _ _ items => + simp only [Value.map, Value.flatten, List.flatMap_map, List.map_flatMap] + apply List.flatMap_congr + intro value member + exact flatten_map f value +termination_by sizeOf value +decreasing_by + all_goals + simp_wf + have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + simp_all only [Value.tuple.sizeOf_spec, Value.construct.sizeOf_spec] + omega + +@[simp] theorem map_map (f : α → β) (g : β → γ) (value : Value α) : + (value.map f).map g = value.map (g ∘ f) := by + cases value with + | field => simp [Value.map] + | ptr => simp [Value.map] + | tuple items | construct _ _ items => + simp only [Value.map, List.map_map, Value.tuple.injEq, Value.construct.injEq, true_and] + apply List.map_congr_left + intro value member + exact map_map f g value +termination_by sizeOf value +decreasing_by + all_goals + simp_wf + have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + simp_all only [Value.tuple.sizeOf_spec, Value.construct.sizeOf_spec] + omega + +@[simp] theorem type_map (f : α → β) (value : Value α) : + (value.map f).type = value.type := by + cases value with + | field => simp [Value.map, Value.type] + | ptr => simp [Value.map, Value.type] + | construct => simp [Value.map, Value.type] + | tuple items => + simp only [Value.map, Value.type, List.map_map, Ty.tuple.injEq] + apply List.map_congr_left + intro value member + exact type_map f value +termination_by sizeOf value +decreasing_by + all_goals + simp_wf + have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + simp_all only [Value.tuple.sizeOf_spec, Value.construct.sizeOf_spec] + omega + +end Aiur.Value diff --git a/Aiur/Aiur/ValueFormed.lean b/Aiur/Aiur/ValueFormed.lean new file mode 100644 index 000000000..6bc54cb41 --- /dev/null +++ b/Aiur/Aiur/ValueFormed.lean @@ -0,0 +1,102 @@ +import Aiur.Runtime +import Aiur.ExceptFacts + +namespace Aiur + +@[simp] theorem Value.wellFormed_field (decls : Declarations) (x : F) : + (@Value.field F A x).wellFormed decls = true := by simp [wellFormed] + +@[simp] theorem Value.wellFormed_ptr (decls : Declarations) (target : Ty) (x : A) : + (@Value.ptr F A target x).wellFormed decls = true := by simp [wellFormed] + +@[simp] theorem Value.wellFormed_tuple (decls : Declarations) (values : List (Value F A)) : + (.tuple values : Value F A).wellFormed decls = true ↔ ∀ value ∈ values, value.wellFormed decls = true := by + simp [wellFormed] + +theorem Value.wellFormed_construct (decls : Declarations) (name ctor : String) (values : List (Value F A)) : + (.construct name ctor values : Value F A).wellFormed decls = true ↔ + ∃ definition, decls.findConstructor? name ctor = some definition ∧ + values.map Value.type = definition.fields ∧ ∀ value ∈ values, value.wellFormed decls = true := by + cases found : decls.findConstructor? name ctor <;> simp [wellFormed, found] + +/-- Environments contain values with valid constructor payloads. -/ +def Environment.WellFormed (decls : Declarations) (locals : Environment F A) : Prop := + ∀ binding ∈ locals, binding.2.wellFormed decls = true + +@[simp] theorem Environment.wellFormed_append {decls : Declarations} {left right : Environment F A} : + (left ++ right).WellFormed decls ↔ left.WellFormed decls ∧ right.WellFormed decls := by + simp [WellFormed, or_imp, forall_and] + +mutual + theorem Pattern.bindings_wellFormed [DecidableEq F] {decls : Declarations} + {pattern : Pattern F} {value : Value F A} {locals : Environment F A} + (formed : value.wellFormed decls = true) (matched : pattern.bindings value = some locals) : + locals.WellFormed decls := by + cases pattern with + | wildcard => simp only [Pattern.bindings, Option.some.injEq] at matched; subst locals; simp [Environment.WellFormed] + | bind name => + simp only [Pattern.bindings, Option.some.injEq] at matched + subst locals + simpa [Environment.WellFormed] using formed + | literal literal => + cases value with + | tuple | ptr | construct => simp [Pattern.bindings] at matched + | field x => + simp only [Pattern.bindings] at matched + split at matched + · cases matched; simp [Environment.WellFormed] + · cases matched + | tuple patterns => + cases value with + | field | ptr | construct => simp [Pattern.bindings] at matched + | tuple values => + simp only [Pattern.bindings] at matched + exact Pattern.bindingsList_wellFormed ((Value.wellFormed_tuple _ _).mp formed) matched + | construct name ctor patterns => + cases value with + | field | tuple | ptr => simp [Pattern.bindings] at matched + | construct actual constructor values => + obtain ⟨definition, _, _, valuesFormed⟩ := (Value.wellFormed_construct _ _ _ _).mp formed + simp only [Pattern.bindings] at matched + split at matched + · exact Pattern.bindingsList_wellFormed valuesFormed matched + · cases matched + termination_by sizeOf pattern + + theorem Pattern.bindingsList_wellFormed [DecidableEq F] {decls : Declarations} + {patterns : List (Pattern F)} {values : List (Value F A)} {locals : Environment F A} + (formed : ∀ value ∈ values, value.wellFormed decls = true) + (matched : Pattern.bindingsList patterns values = some locals) : locals.WellFormed decls := by + cases patterns with + | nil => cases values <;> simp_all [Pattern.bindingsList, Environment.WellFormed] + | cons pattern patterns => + cases values with + | nil => simp [Pattern.bindingsList] at matched + | cons value values => + simp only [Pattern.bindingsList] at matched + obtain ⟨head, headRun, rest⟩ := Option.bind_eq_some_iff.mp matched + obtain ⟨tail, tailRun, finished⟩ := Option.bind_eq_some_iff.mp rest + simp only [Option.pure_def, Option.some.injEq] at finished + subst locals + exact Environment.wellFormed_append.mpr + ⟨Pattern.bindings_wellFormed (formed _ (by simp)) headRun, + Pattern.bindingsList_wellFormed (fun v h => formed v (by simp [h])) tailRun⟩ + termination_by sizeOf patterns +end + +theorem selectArm_wellFormed [DecidableEq F] {decls : Declarations} + {value : Value F A} {arms : List (Pattern F × Expr F)} {locals : Environment F A} {body : Expr F} + (formed : value.wellFormed decls = true) (selected : selectArm value arms = some (locals, body)) : + locals.WellFormed decls := by + induction arms with + | nil => simp [selectArm] at selected + | cons arm arms ih => + rcases arm with ⟨pattern, branch⟩ + cases matched : pattern.bindings value with + | none => exact ih (by simpa [selectArm, matched] using selected) + | some bindings => + simp [selectArm, matched] at selected + rcases selected with ⟨rfl, rfl⟩ + exact Pattern.bindings_wellFormed formed matched + +end Aiur diff --git a/Aiur/Aiur/Wire.lean b/Aiur/Aiur/Wire.lean new file mode 100644 index 000000000..61ccd9227 --- /dev/null +++ b/Aiur/Aiur/Wire.lean @@ -0,0 +1,136 @@ +import Aiur.Declarations +import Mathlib.Algebra.Field.Basic + +namespace Aiur + +/-- Circuit values carry static types and a fixed number of field columns. -/ +structure WireValue (α : Type) where + type : Ty + words : List α + deriving Repr, BEq, DecidableEq + +def WireValue.field (value : α) : WireValue α := ⟨.field, [value]⟩ +def WireValue.ptr (target : Ty) (address : α) : WireValue α := ⟨.ptr target, [address]⟩ +def WireValue.tuple (values : List (WireValue α)) : WireValue α := + ⟨.tuple (values.map WireValue.type), values.flatMap WireValue.words⟩ + +instance [OfNat α n] : OfNat (WireValue α) n := ⟨.field (OfNat.ofNat n)⟩ + +def WireValue.map (f : α → β) (value : WireValue α) : WireValue β := + ⟨value.type, value.words.map f⟩ + +/-- Correct column count, without requiring a valid tag or canonical payload. -/ +def WireValue.Sized (decls : Declarations) (value : WireValue α) : Prop := + ∃ layout, decls.layout value.type = .ok layout ∧ value.words.length = layout.width + +namespace Layout + +def payloadWidth (constructors : List (String × Layout)) : Nat := + (constructors.map (fun c => c.2.width)).foldr max 0 + +mutual + /-- Only multiple-constructor enums store a tag. Unused payload words are zero. -/ + def encode [NatCast F] [Zero F] : Layout → Value F → Option (List F) + | .field, .field value => some [value] + | .ptr target, .ptr actual address => if target = actual then some [address] else none + | .tuple layouts, .tuple values => encodeList layouts values + | .enum name constructors, .construct actual ctor args => do + if name ≠ actual then none else do + let (index, payload) ← encodeConstructor constructors ctor args 0 + return enumWords constructors.length (index : F) + (payload ++ List.replicate (payloadWidth constructors - payload.length) 0) + | _, _ => none + termination_by layout _ => sizeOf layout + + def encodeList [NatCast F] [Zero F] : List Layout → List (Value F) → Option (List F) + | [], [] => some [] + | layout :: layouts, value :: values => do + return (← encode layout value) ++ (← encodeList layouts values) + | _, _ => none + termination_by layouts _ => sizeOf layouts + + def encodeConstructor [NatCast F] [Zero F] : List (String × Layout) → String → + List (Value F) → Nat → Option (Nat × List F) + | [], _, _, _ => none + | (name, layout) :: rest, ctor, args, index => + if name = ctor then do return (index, ← encode layout (.tuple args)) + else encodeConstructor rest ctor args (index + 1) + termination_by layouts _ _ _ => sizeOf layouts +end + +mutual + /-- Decoding validates the active tag and all canonical padding; it never follows pointers. -/ + def decode [NatCast F] [Zero F] [DecidableEq F] : Layout → List F → Option (Value F) + | .field, [value] => some (.field value) + | .ptr target, [address] => some (.ptr target address) + | .tuple layouts, words => return .tuple (← decodeList layouts words) + | .enum name constructors, words => do + let (tag, payload) ← enumParts constructors.length ((0 : Nat) : F) words + if payload.length = payloadWidth constructors then do + let (ctor, args) ← decodeConstructor constructors tag payload 0 + return .construct name ctor args + else none + | _, _ => none + termination_by layout _ => sizeOf layout + + def decodeList [NatCast F] [Zero F] [DecidableEq F] : List Layout → List F → Option (List (Value F)) + | [], [] => some [] + | layout :: layouts, words => do + return (← decode layout (words.take layout.width)) :: + (← decodeList layouts (words.drop layout.width)) + | [], _ :: _ => none + termination_by layouts _ => sizeOf layouts + + def decodeConstructor [NatCast F] [Zero F] [DecidableEq F] : List (String × Layout) → + F → List F → Nat → Option (String × List (Value F)) + | [], _, _, _ => none + | (name, layout) :: rest, tag, payload, index => + if tag = (index : F) then do + let .tuple args ← decode layout (payload.take layout.width) | none + if (payload.drop layout.width).all (fun x => decide (x = 0)) then + return (name, args) + else none + else decodeConstructor rest tag payload (index + 1) + termination_by layouts _ _ _ => sizeOf layouts +end + +end Layout + +/-- Entry decoding is type-directed, including nominal enum identity. -/ +def WireValue.decode [NatCast F] [Zero F] [DecidableEq F] (decls : Declarations) + (value : WireValue F) : Option (Value F) := do + let layout ← (decls.layout value.type).toOption + let decoded ← layout.decode value.words + if decoded.hasType decls value.type then some decoded else none + +def Value.encode [NatCast F] [Zero F] (decls : Declarations) (value : Value F) : + Option (WireValue F) := do + if !value.wellFormed decls then none else do + let layout ← (decls.layout value.type).toOption + return ⟨value.type, ← layout.encode value⟩ + +/-- Natural-number constructor tags must remain distinct in the actual field. -/ +def Declarations.tagsValid (F : Type) [NatCast F] [DecidableEq F] (decls : Declarations) : Bool := + decls.all fun decl => decide ((List.range decl.constructors.length).map (fun i : Nat => (i : F))).Nodup + +theorem Declarations.tagsValid_spec [NatCast F] [DecidableEq F] (decls : Declarations) : + decls.tagsValid F = true ↔ + ∀ decl ∈ decls, ((List.range decl.constructors.length).map (fun i : Nat => (i : F))).Nodup := by + simp [tagsValid, List.all_eq_true] + +/-- The prover chooses raw typed cells. Invalid unused encodings impose no extra requirement. -/ +structure WireROM (F : Type) where + entries : List (F × WireValue F) := [] + deriving Repr, BEq + +/-- Functionality is type-directed. Physical width tables need no nominal tag: +their words can have several static typed views at the same address. -/ +def WireROM.Valid (rom : WireROM F) : Prop := + ∀ a ∈ rom.entries, ∀ b ∈ rom.entries, + a.1 = b.1 → a.2.type = b.2.type → a.2 = b.2 + +instance WireROM.instDecidableValid [DecidableEq F] (rom : WireROM F) : Decidable rom.Valid := + inferInstanceAs (Decidable (∀ a ∈ rom.entries, ∀ b ∈ rom.entries, + a.1 = b.1 → a.2.type = b.2.type → a.2 = b.2)) + +end Aiur diff --git a/Aiur/Aiur/WireBoundary.lean b/Aiur/Aiur/WireBoundary.lean new file mode 100644 index 000000000..dc71be6c1 --- /dev/null +++ b/Aiur/Aiur/WireBoundary.lean @@ -0,0 +1,64 @@ +import Aiur.WireCanonical +import Aiur.ValueFormed + +namespace Aiur + +theorem WireValue.decode_spec [NatCast F] [Zero F] [DecidableEq F] + {decls : Declarations} {wire : WireValue F} {value : Value F} + (decoded : wire.decode decls = some value) : + value.type = wire.type ∧ value.wellFormed decls = true ∧ ∃ layout, + decls.layout wire.type = .ok layout ∧ layout.decode wire.words = some value := by + unfold WireValue.decode at decoded + cases expanded : decls.layout wire.type with + | error error => simp [expanded, Except.toOption] at decoded + | ok layout => + simp only [expanded, Except.toOption, bind, Option.bind] at decoded + obtain ⟨result, run, finished⟩ := Option.bind_eq_some_iff.mp decoded + split at finished + · rename_i formed + cases finished + simp only [Value.hasType, Bool.and_eq_true, decide_eq_true_eq] at formed + exact ⟨formed.1, formed.2, layout, rfl, run⟩ + · cases finished + +theorem Value.encode_spec [NatCast F] [Zero F] {decls : Declarations} + {value : Value F} {wire : WireValue F} (encoded : value.encode decls = some wire) : + value.wellFormed decls = true ∧ wire.type = value.type ∧ ∃ layout, + decls.layout value.type = .ok layout ∧ layout.encode value = some wire.words := by + unfold Value.encode at encoded + split at encoded + · cases encoded + · rename_i formed + have formed : value.wellFormed decls = true := by simpa using formed + cases expanded : decls.layout value.type with + | error error => simp [expanded, Except.toOption] at encoded + | ok layout => + simp only [expanded, Except.toOption, bind, Option.bind] at encoded + obtain ⟨words, run, finished⟩ := Option.bind_eq_some_iff.mp encoded + cases finished + exact ⟨formed, rfl, layout, rfl, run⟩ + +theorem Value.encode_sized [NatCast F] [Zero F] {decls : Declarations} + {value : Value F} {wire : WireValue F} (encoded : value.encode decls = some wire) : + wire.Sized decls := by + obtain ⟨_, type, layout, expanded, run⟩ := Value.encode_spec encoded + exact ⟨layout, by rwa [type], Layout.encode_length run⟩ + +theorem Value.decode_encode [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + {value : Value F} {wire : WireValue F} (encoded : value.encode decls = some wire) + (safe : ∀ layout, decls.layout value.type = .ok layout → layout.TagSafe F) : + wire.decode decls = some value := by + obtain ⟨formed, type, layout, expanded, run⟩ := Value.encode_spec encoded + have decoded := Layout.decode_encode (safe layout expanded) run + simp [WireValue.decode, type, expanded, Except.toOption, decoded, Value.hasType, formed] + +theorem WireValue.encode_decode [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + {wire : WireValue F} {value : Value F} (decoded : wire.decode decls = some value) + (unique : ∀ layout, decls.layout wire.type = .ok layout → layout.NamesUnique) : + value.encode decls = some wire := by + obtain ⟨type, formed, layout, expanded, run⟩ := WireValue.decode_spec decoded + have encoded := Layout.encode_decode (unique layout expanded) run + cases wire + simp [Value.encode, formed, type, expanded, Except.toOption, encoded] + +end Aiur diff --git a/Aiur/Aiur/WireCanonical.lean b/Aiur/Aiur/WireCanonical.lean new file mode 100644 index 000000000..3fc95e09a --- /dev/null +++ b/Aiur/Aiur/WireCanonical.lean @@ -0,0 +1,145 @@ +import Aiur.WireRoundtrip + +namespace Aiur + +set_option maxHeartbeats 1000000 + +def Layout.NamesUnique : Layout → Prop + | .field | .ptr _ => True + | .tuple layouts => ∀ layout ∈ layouts, layout.NamesUnique + | .enum _ constructors => (constructors.map Prod.fst).Nodup ∧ + ∀ pair ∈ constructors, pair.2.NamesUnique +termination_by layout => sizeOf layout +decreasing_by + all_goals simp_wf + all_goals + have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + first | omega | cases ‹String × Layout›; simp_all only [Prod.mk.sizeOf_spec]; omega + +namespace Layout + +private theorem all_zero [Zero F] [DecidableEq F] {words : List F} + (zero : words.all (fun x => decide (x = 0)) = true) : words = List.replicate words.length 0 := by + induction words with + | nil => rfl + | cons x xs ih => + simp only [List.all_cons, Bool.and_eq_true, decide_eq_true_eq] at zero + rw [zero.1, List.length_cons, List.replicate_succ] + exact congrArg (fun xs => 0 :: xs) (ih zero.2) + +mutual + /-- Decoding accepts precisely canonical encodings, with no nonzero unused columns. -/ + theorem encode_decode [NatCast F] [Zero F] [DecidableEq F] {layout : Layout} + (unique : layout.NamesUnique) {value : Value F} {words : List F} + (decoded : layout.decode words = some value) : layout.encode value = some words := by + cases layout with + | field => + cases words with + | nil => simp [decode] at decoded + | cons x xs => + cases xs with + | cons => simp [decode] at decoded + | nil => simp only [decode, Option.some.injEq] at decoded; subst value; simp [encode] + | ptr target => + cases words with + | nil => simp [decode] at decoded + | cons x xs => + cases xs with + | cons => simp [decode] at decoded + | nil => simp only [decode, Option.some.injEq] at decoded; subst value; simp [encode] + | tuple layouts => + simp only [decode] at decoded + obtain ⟨values, run, finished⟩ := Option.bind_eq_some_iff.mp decoded + simp only [Option.pure_def, Option.some.injEq] at finished + subst value + simpa only [encode] using encodeList_decode (by simpa only [NamesUnique] using unique) run + | enum name constructors => + simp only [decode] at decoded + obtain ⟨⟨tag, payload⟩, parts, decoded⟩ := Option.bind_eq_some_iff.mp decoded + split at decoded + · rename_i length + obtain ⟨⟨ctor, args⟩, run, finished⟩ := Option.bind_eq_some_iff.mp decoded + simp only [Option.pure_def, Option.some.injEq] at finished + subst value + simp only [NamesUnique] at unique + obtain ⟨_, index, encodedWords, encoded, tagEq, paddingEq⟩ := + encodeConstructor_decode unique.1 unique.2 run + simp only [encode, ne_eq, not_true_eq_false, ↓reduceIte, encoded, Option.bind_some] + dsimp only [bind, Option.bind] + rw [← length, ← paddingEq, ← tagEq, enumParts_words parts] + rfl + · cases decoded + termination_by sizeOf layout + + theorem encodeList_decode [NatCast F] [Zero F] [DecidableEq F] {layouts : List Layout} + (unique : ∀ layout ∈ layouts, layout.NamesUnique) + {values : List (Value F)} {words : List F} + (decoded : decodeList layouts words = some values) : encodeList layouts values = some words := by + cases layouts with + | nil => cases words <;> simp_all [decodeList, encodeList] + | cons layout layouts => + simp only [decodeList] at decoded + obtain ⟨value, headRun, rest⟩ := Option.bind_eq_some_iff.mp decoded + obtain ⟨values, tailRun, finished⟩ := Option.bind_eq_some_iff.mp rest + simp only [Option.pure_def, Option.some.injEq] at finished + subst_vars + simp only [encodeList, encode_decode (unique _ (by simp)) headRun, Option.bind_some, + encodeList_decode (fun l h => unique l (by simp [h])) tailRun] + simp + termination_by sizeOf layouts + + theorem encodeConstructor_decode [NatCast F] [Zero F] [DecidableEq F] + {constructors : List (String × Layout)} {ctor : String} {args : List (Value F)} + {start : Nat} {tag : F} {payload : List F} + (names : (constructors.map Prod.fst).Nodup) + (unique : ∀ pair ∈ constructors, pair.2.NamesUnique) + (decoded : decodeConstructor constructors tag payload start = some (ctor, args)) : + ctor ∈ constructors.map Prod.fst ∧ ∃ index words, + encodeConstructor constructors ctor args start = some (index, words) ∧ + tag = (index : F) ∧ + payload = words ++ List.replicate (payload.length - words.length) 0 := by + cases constructors with + | nil => simp [decodeConstructor] at decoded + | cons pair rest => + rcases hpair : pair with ⟨name, layout⟩ + rw [hpair] at decoded names unique + simp only [List.map_cons, List.nodup_cons] at names + simp only [decodeConstructor] at decoded + split at decoded + · rename_i selected + obtain ⟨value, run, finished⟩ := Option.bind_eq_some_iff.mp decoded + cases value with + | field | ptr | construct => simp only [] at finished; cases finished + | tuple values => + dsimp only at finished + split at finished + · rename_i zero + simp only [Option.pure_def, Option.some.injEq, Prod.mk.injEq] at finished + rcases finished with ⟨rfl, rfl⟩ + have encoded := encode_decode (unique (name, layout) (by simp)) run + have width := encode_length encoded + refine ⟨by simp, start, payload.take layout.width, ?_, selected, ?_⟩ + · simp [encodeConstructor, encoded] + · have padding := all_zero zero + rw [List.length_drop] at padding + rw [width, ← padding] + exact (List.take_append_drop _ _).symm + · cases finished + · obtain ⟨member, index, words, encoded, tagEq, paddingEq⟩ := + encodeConstructor_decode names.2 (fun p h => unique p (by simp [h])) decoded + have different : name ≠ ctor := by intro same; subst name; exact names.1 member + refine ⟨by simp [member], index, words, ?_, tagEq, paddingEq⟩ + simpa only [encodeConstructor, different, ↓reduceIte] using encoded + termination_by sizeOf constructors + decreasing_by + all_goals simp_all only [List.cons.sizeOf_spec, Prod.mk.sizeOf_spec] + all_goals omega +end + +theorem decode_length [NatCast F] [Zero F] [DecidableEq F] {layout : Layout} + (unique : layout.NamesUnique) {words : List F} {value : Value F} + (decoded : layout.decode words = some value) : words.length = layout.width := + encode_length (encode_decode unique decoded) + +end Layout +end Aiur diff --git a/Aiur/Aiur/WireCodec.lean b/Aiur/Aiur/WireCodec.lean new file mode 100644 index 000000000..af48e6e4d --- /dev/null +++ b/Aiur/Aiur/WireCodec.lean @@ -0,0 +1,138 @@ +import Aiur.Wire +import Aiur.DeclarationFacts + +namespace Aiur.Layout + +@[simp] theorem payloadWidth_nil : payloadWidth [] = 0 := rfl +@[simp] theorem payloadWidth_cons (name : String) (layout : Layout) (rest : List (String × Layout)) : + payloadWidth ((name, layout) :: rest) = max layout.width (payloadWidth rest) := rfl + +mutual + theorem encode_length [NatCast F] [Zero F] {layout : Layout} {value : Value F} {words : List F} + (encoded : layout.encode value = some words) : words.length = layout.width := by + cases layout with + | field => + cases value <;> simp [encode] at encoded + case field value => subst words; simp [Layout.width] + | ptr target => + cases value <;> simp [encode] at encoded + case ptr actual address => + obtain ⟨rfl, rfl⟩ := encoded + simp [Layout.width] + | tuple layouts => + cases value <;> simp [encode] at encoded + case tuple values => simpa only [Layout.width] using encodeList_length encoded + | enum name constructors => + cases value <;> simp only [encode] at encoded + case field => cases encoded + case tuple => cases encoded + case ptr => cases encoded + case construct actual ctor args => + split at encoded + · cases encoded + · obtain ⟨⟨index, payload⟩, chosen, finished⟩ := Option.bind_eq_some_iff.mp encoded + have bound := encodeConstructor_length chosen + simp only [Option.pure_def, Option.some.injEq] at finished + subst words + simp only [enumWords_length, List.length_append, List.length_replicate, Layout.width] + change tagWidth constructors.length + + (payload.length + (payloadWidth constructors - payload.length)) = + tagWidth constructors.length + payloadWidth constructors + omega + termination_by sizeOf layout + + theorem encodeList_length [NatCast F] [Zero F] {layouts : List Layout} + {values : List (Value F)} {words : List F} + (encoded : encodeList layouts values = some words) : + words.length = (layouts.map Layout.width).sum := by + cases layouts with + | nil => cases values <;> simp_all [encodeList] + | cons layout layouts => + cases values with + | nil => simp [encodeList, encodeConstructor] at encoded + | cons value values => + simp only [encodeList] at encoded + obtain ⟨head, headRun, rest⟩ := Option.bind_eq_some_iff.mp encoded + obtain ⟨tail, tailRun, finished⟩ := Option.bind_eq_some_iff.mp rest + simp only [Option.pure_def, Option.some.injEq] at finished + subst words + simp [encode_length headRun, encodeList_length tailRun] + termination_by sizeOf layouts + + theorem encodeConstructor_length [NatCast F] [Zero F] {constructors : List (String × Layout)} + {ctor : String} {args : List (Value F)} {start index : Nat} {words : List F} + (encoded : encodeConstructor constructors ctor args start = some (index, words)) : + words.length ≤ payloadWidth constructors := by + cases constructors with + | nil => simp [encodeList, encodeConstructor] at encoded + | cons entry constructors => + rcases hentry : entry with ⟨name, layout⟩ + rw [hentry] at encoded + simp only [encodeConstructor] at encoded + split at encoded + · obtain ⟨payload, run, finished⟩ := Option.bind_eq_some_iff.mp encoded + simp only [Option.pure_def, Option.some.injEq, Prod.mk.injEq] at finished + rcases finished with ⟨rfl, rfl⟩ + rw [encode_length run, payloadWidth_cons] + exact Nat.le_max_left _ _ + · exact (encodeConstructor_length encoded).trans (Nat.le_max_right _ _) + termination_by sizeOf constructors + decreasing_by + all_goals simp_all only [Layout.enum.sizeOf_spec, Layout.tuple.sizeOf_spec, + List.cons.sizeOf_spec, Prod.mk.sizeOf_spec] + all_goals omega +end + +mutual + theorem decode_type [NatCast F] [Zero F] [DecidableEq F] {layout : Layout} + {words : List F} {value : Value F} (decoded : layout.decode words = some value) : + value.type = layout.type := by + cases layout with + | field => + cases words with + | nil => simp [decode] at decoded + | cons x xs => + cases xs with + | cons => simp [decode] at decoded + | nil => simp only [decode, Option.some.injEq] at decoded; subst value; simp [Value.type, Layout.type] + | ptr target => + cases words with + | nil => simp [decode] at decoded + | cons x xs => + cases xs with + | cons => simp [decode] at decoded + | nil => simp only [decode, Option.some.injEq] at decoded; subst value; simp [Value.type, Layout.type] + | tuple layouts => + simp only [decode] at decoded + obtain ⟨values, run, finished⟩ := Option.bind_eq_some_iff.mp decoded + simp only [Option.pure_def, Option.some.injEq] at finished + subst value + simp only [Value.type, Layout.type, Ty.tuple.injEq] + exact decodeList_types run + | enum name constructors => + simp only [decode] at decoded + obtain ⟨⟨tag, payload⟩, _, decoded⟩ := Option.bind_eq_some_iff.mp decoded + split at decoded + · obtain ⟨⟨ctor, args⟩, _, finished⟩ := Option.bind_eq_some_iff.mp decoded + cases finished + simp [Value.type, Layout.type] + · cases decoded + termination_by sizeOf layout + + theorem decodeList_types [NatCast F] [Zero F] [DecidableEq F] {layouts : List Layout} + {words : List F} {values : List (Value F)} + (decoded : decodeList layouts words = some values) : + values.map Value.type = layouts.map Layout.type := by + cases layouts with + | nil => cases words <;> simp_all [decodeList] + | cons layout layouts => + simp only [decodeList] at decoded + obtain ⟨head, headRun, rest⟩ := Option.bind_eq_some_iff.mp decoded + obtain ⟨tail, tailRun, finished⟩ := Option.bind_eq_some_iff.mp rest + simp only [Option.pure_def, Option.some.injEq] at finished + subst values + simp [decode_type headRun, decodeList_types tailRun] + termination_by sizeOf layouts +end + +end Aiur.Layout diff --git a/Aiur/Aiur/WireComposition.lean b/Aiur/Aiur/WireComposition.lean new file mode 100644 index 000000000..5c300820b --- /dev/null +++ b/Aiur/Aiur/WireComposition.lean @@ -0,0 +1,104 @@ +import Aiur.WireRelation +import Aiur.LayoutComposition +import Aiur.ConstructorFacts + +namespace Aiur + +/-- Canonical component encodings assemble to a canonical tuple payload. -/ +theorem DecodesValues.encodeList [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) {wires : List (WireValue F)} {values : List (Value F)} + (decoded : DecodesValues decls wires values) : + ∃ layouts, List.Forall₂ (fun ty layout => decls.layout ty = .ok layout) + (wires.map WireValue.type) layouts ∧ + Layout.encodeList layouts values = some (wires.flatMap WireValue.words) := by + induction decoded with + | nil => exact ⟨[], .nil, by simp [Layout.encodeList]⟩ + | @cons wire value wires values head tail ih => + obtain ⟨_, _, layout, expanded, rawDecode⟩ := WireValue.decode_spec head + obtain ⟨layouts, expansions, encoded⟩ := ih + refine ⟨layout :: layouts, .cons expanded expansions, ?_⟩ + have first := Layout.encode_decode (Declarations.layout_namesUnique checked expanded) rawDecode + simp [Layout.encodeList, first, encoded] + +theorem WireValue.decode_tuple [Field F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) (tags : decls.tagsValid F = true) + {wires : List (WireValue F)} {values : List (Value F)} (decoded : DecodesValues decls wires values) : + (WireValue.tuple wires).decode decls = some (.tuple values) := by + obtain ⟨layouts, expansions, encoded⟩ := decoded.encodeList checked + have expanded := Declarations.layout_tuple expansions + apply WireValue.decode_of_layout checked expanded + apply Layout.decode_encode (Declarations.layout_tagSafe tags expanded) + simpa only [Layout.encode, WireValue.tuple] using encoded + +theorem WireValue.decode_ptr [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + {target : Ty} (names : target.checkNames decls = .ok ()) (address : F) : + (WireValue.ptr target address).decode decls = some (.ptr target address) := by + have expanded := Declarations.layout_ptr names + simp [WireValue.decode, WireValue.ptr, expanded, Except.toOption, Layout.decode, + Value.hasType, Value.type, Value.wellFormed] + +theorem Layout.encodeConstructor_at [NatCast F] [Zero F] + {constructors : List (String × Layout)} (names : (constructors.map Prod.fst).Nodup) + {index start : Nat} {ctor : String} {layout : Layout} + (found : constructors[index]? = some (ctor, layout)) + {args : List (Value F)} {payload : List F} (encoded : layout.encode (.tuple args) = some payload) : + Layout.encodeConstructor constructors ctor args start = some (start + index, payload) := by + induction constructors generalizing index start with + | nil => simp at found + | cons pair rest ih => + rcases pair with ⟨name, head⟩ + simp only [List.map_cons, List.nodup_cons] at names + cases index with + | zero => + simp only [List.getElem?_cons_zero, Option.some.injEq, Prod.mk.injEq] at found + rcases found with ⟨rfl, rfl⟩ + simp [Layout.encodeConstructor, encoded] + | succ index => + simp only [List.getElem?_cons_succ] at found + have different : name ≠ ctor := by + intro same + exact names.1 (List.mem_map.mpr ⟨(ctor, layout), List.mem_of_getElem? found, same.symm⟩) + simpa [Layout.encodeConstructor, different, Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using + ih names.2 found (start := start + 1) + +/-- Constructor assembly uses its declared tag and zeroes every unused payload column. -/ +theorem WireValue.decode_construct [Field F] [DecidableEq F] {decls : Declarations} + (checked : checkDeclarations decls = .ok ()) (tags : decls.tagsValid F = true) + {name : String} {definition : EnumDecl} (found : decls.findEnum? name = some definition) + {index : Nat} {ctor : ConstructorDecl} (atIndex : definition.constructors[index]? = some ctor) + {wires : List (WireValue F)} {values : List (Value F)} (decoded : DecodesValues decls wires values) + (types : wires.map WireValue.type = ctor.fields) + {layout : Layout} (expanded : decls.layout (.enum name) = .ok layout) : + (WireValue.mk (.enum name) (Layout.enumWords definition.constructors.length (index : F) + (wires.flatMap WireValue.words ++ + List.replicate (layout.width - Layout.tagWidth definition.constructors.length - + (wires.flatMap WireValue.words).length) 0))).decode decls = + some (.construct name ctor.name values) := by + have description := Declarations.layout_describes expanded + cases description with + | @enum _ other constructors otherFound related => + have same := Option.some.inj (found.symm.trans otherFound) + subst other + obtain ⟨chosen, chosenAt, chosenDescription⟩ := related.at atIndex + obtain ⟨layouts, expansions, encoded⟩ := decoded.encodeList checked + have payloadExpanded := Declarations.layout_tuple expansions + rw [types] at payloadExpanded + have sameLayout := chosenDescription.unique (Declarations.layout_describes payloadExpanded) + subst chosen + have unique := Declarations.layout_namesUnique checked expanded + simp only [Layout.NamesUnique] at unique + have chosenEncoded := Layout.encodeConstructor_at unique.1 chosenAt + (by simpa only [Layout.encode, WireValue.tuple] using encoded) (start := 0) + apply WireValue.decode_of_layout checked expanded + apply Layout.decode_encode (Declarations.layout_tagSafe tags expanded) + simp [Layout.encode, chosenEncoded, Layout.width, Layout.payloadWidth, related.length] + +theorem WireValue.ptr_decoded_eq [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + {target : Ty} {address : F} {value : Value F} + (decoded : (WireValue.ptr target address).decode decls = some value) : value = .ptr target address := by + obtain ⟨_, _, layout, expanded, rawDecode⟩ := WireValue.decode_spec decoded + have described := Declarations.layout_describes expanded + cases described + simpa only [WireValue.ptr, Layout.decode, Option.some.injEq] using rawDecode.symm + +end Aiur diff --git a/Aiur/Aiur/WireFacts.lean b/Aiur/Aiur/WireFacts.lean new file mode 100644 index 000000000..84c287e5a --- /dev/null +++ b/Aiur/Aiur/WireFacts.lean @@ -0,0 +1,30 @@ +import Aiur.Wire + +namespace Aiur.WireValue + +@[simp] theorem type_map (f : α → β) (value : WireValue α) : + (value.map f).type = value.type := rfl + +@[simp] theorem words_map (f : α → β) (value : WireValue α) : + (value.map f).words = value.words.map f := rfl + +@[simp] theorem map_map (f : α → β) (g : β → γ) (value : WireValue α) : + (value.map f).map g = value.map (g ∘ f) := by + cases value + simp [map, List.map_map] + +theorem map_congr (value : WireValue α) {f g : α → β} + (agree : ∀ x ∈ value.words, f x = g x) : value.map f = value.map g := by + exact congrArg (WireValue.mk value.type) (List.map_congr_left agree) + +@[simp] theorem map_field (f : α → β) (value : α) : + (field value).map f = field (f value) := rfl + +@[simp] theorem map_ptr (f : α → β) (target : Ty) (address : α) : + (ptr target address).map f = ptr target (f address) := rfl + +@[simp] theorem map_tuple (f : α → β) (values : List (WireValue α)) : + (tuple values).map f = tuple (values.map (map f)) := by + simp [map, tuple, List.map_map, List.map_flatMap, List.flatMap_map] + +end Aiur.WireValue diff --git a/Aiur/Aiur/WireMemory.lean b/Aiur/Aiur/WireMemory.lean new file mode 100644 index 000000000..fb51951ee --- /dev/null +++ b/Aiur/Aiur/WireMemory.lean @@ -0,0 +1,42 @@ +import Aiur.WireBoundary +import Aiur.TypecheckFacts + +namespace Aiur + +/-- Decode the prover's table once for the whole derivation. Unused malformed cells are omitted. -/ +def WireROM.decode [NatCast F] [Zero F] [DecidableEq F] (decls : Declarations) + (rom : WireROM F) : ROM F := + ⟨rom.entries.filterMap (fun cell => (cell.2.decode decls).map (fun value => (cell.1, value)))⟩ + +theorem WireROM.mem_decode [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + {rom : WireROM F} {address : F} {value : Value F} : + (address, value) ∈ (rom.decode decls).entries ↔ ∃ wire, + (address, wire) ∈ rom.entries ∧ wire.decode decls = some value := by + simp only [WireROM.decode, List.mem_filterMap] + constructor + · rintro ⟨⟨location, wire⟩, member, decoded⟩ + obtain ⟨result, run, same⟩ := Option.map_eq_some_iff.mp decoded + obtain ⟨rfl, rfl⟩ := Prod.mk.inj same + exact ⟨wire, member, run⟩ + · rintro ⟨wire, member, decoded⟩ + exact ⟨(address, wire), member, by simp [decoded]⟩ + +theorem WireROM.decode_wellFormed [NatCast F] [Zero F] [DecidableEq F] + (decls : Declarations) (rom : WireROM F) : (rom.decode decls).WellFormed decls := by + rintro ⟨address, value⟩ member + obtain ⟨wire, _, decoded⟩ := WireROM.mem_decode.mp member + exact (WireValue.decode_spec decoded).2.1 + +theorem WireROM.decode_valid [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + {rom : WireROM F} (valid : rom.Valid) : (rom.decode decls).Valid := by + intro a ha b hb address types + obtain ⟨left, leftMem, leftDecode⟩ := WireROM.mem_decode.mp ha + obtain ⟨right, rightMem, rightDecode⟩ := WireROM.mem_decode.mp hb + have typed : left.type = right.type := + (WireValue.decode_spec leftDecode).1.symm.trans + (types.trans (WireValue.decode_spec rightDecode).1) + have same : left = right := valid _ leftMem _ rightMem address typed + rw [same, rightDecode] at leftDecode + exact (Option.some.inj leftDecode).symm + +end Aiur diff --git a/Aiur/Aiur/WireRelation.lean b/Aiur/Aiur/WireRelation.lean new file mode 100644 index 000000000..8befee1c4 --- /dev/null +++ b/Aiur/Aiur/WireRelation.lean @@ -0,0 +1,125 @@ +import Aiur.EncodingTypes +import Aiur.WireFacts + +namespace Aiur + +@[simp] theorem WireValue.decode_field [NatCast F] [Zero F] [DecidableEq F] + (decls : Declarations) (value : F) : (WireValue.field value).decode decls = some (.field value) := by + simp [WireValue.decode, WireValue.field, Declarations.layout, Ty.checkNames, + Declarations.expand, Ty.layoutWith, Except.toOption, Layout.decode, Value.hasType, + Value.type, Value.wellFormed, bind, Except.bind, Option.bind] + +/-- A list of flat encodings and the corresponding nominal source values. -/ +def DecodesValues [NatCast F] [Zero F] [DecidableEq F] (decls : Declarations) + (wires : List (WireValue F)) (values : List (Value F)) : Prop := + List.Forall₂ (fun wire value => wire.decode decls = some value) wires values + +namespace DecodesValues + +theorem types [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + {wires : List (WireValue F)} {values : List (Value F)} (decoded : DecodesValues decls wires values) : + values.map Value.type = wires.map WireValue.type := by + induction decoded with + | nil => rfl + | cons head tail ih => simp [(WireValue.decode_spec head).1, ih] + +theorem wellFormed [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + {wires : List (WireValue F)} {values : List (Value F)} (decoded : DecodesValues decls wires values) : + ∀ value ∈ values, value.wellFormed decls = true := by + induction decoded with + | nil => simp + | cons head tail ih => simpa using And.intro (WireValue.decode_spec head).2.1 ih + +theorem unique [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + {wires : List (WireValue F)} {values other : List (Value F)} + (decoded : DecodesValues decls wires values) (also : DecodesValues decls wires other) : values = other := by + induction decoded generalizing other with + | nil => cases also; rfl + | cons head tail ih => + cases also with + | cons head' tail' => simp [Option.some.inj (head.symm.trans head'), ih tail'] + +theorem exists_of_each [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + {wires : List (WireValue F)} (decoded : ∀ wire ∈ wires, ∃ value, wire.decode decls = some value) : + ∃ values, DecodesValues decls wires values := by + induction wires with + | nil => exact ⟨[], .nil⟩ + | cons wire wires ih => + obtain ⟨value, head⟩ := decoded wire (by simp) + obtain ⟨values, tail⟩ := ih (fun w h => decoded w (by simp [h])) + exact ⟨value :: values, .cons head tail⟩ + +theorem getElem [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + {wires : List (WireValue F)} {values : List (Value F)} (decoded : DecodesValues decls wires values) + {index : Nat} {wire : WireValue F} (found : wires[index]? = some wire) : + ∃ value, values[index]? = some value ∧ wire.decode decls = some value := by + induction decoded generalizing index with + | nil => simp at found + | cons head tail ih => + cases index with + | zero => + simp only [List.getElem?_cons_zero, Option.some.injEq] at found + subst wire + exact ⟨_, rfl, head⟩ + | succ index => exact ih (by simpa using found) + +end DecodesValues + +/-- Environments preserve binding order and names while decoding their values. -/ +def DecodesEnvironment [NatCast F] [Zero F] [DecidableEq F] (decls : Declarations) + (wires : List (String × WireValue F)) (values : Environment F) : Prop := + List.Forall₂ (fun wire value => wire.1 = value.1 ∧ wire.2.decode decls = some value.2) wires values + +namespace DecodesEnvironment + +theorem append [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + {left right : List (String × WireValue F)} {first second : Environment F} + (head : DecodesEnvironment decls left first) (tail : DecodesEnvironment decls right second) : + DecodesEnvironment decls (left ++ right) (first ++ second) := by + induction head with + | nil => exact tail + | cons h hs ih => exact .cons h ih + +theorem wellFormed [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + {wires : List (String × WireValue F)} {values : Environment F} + (decoded : DecodesEnvironment decls wires values) : values.WellFormed decls := by + induction decoded with + | nil => simp [Environment.WellFormed] + | cons head tail ih => + simp only [Environment.WellFormed, List.mem_cons, forall_eq_or_imp] at ih ⊢ + exact ⟨(WireValue.decode_spec head.2).2.1, ih⟩ + +theorem find [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + {wires : List (String × WireValue F)} {values : Environment F} + (decoded : DecodesEnvironment decls wires values) (name : String) + {wire : String × WireValue F} (found : wires.find? (·.1 == name) = some wire) : + ∃ value, values.find? (·.1 == name) = some (wire.1, value) ∧ wire.2.decode decls = some value := by + induction decoded with + | nil => simp at found + | @cons x y xs ys head tail ih => + by_cases same : x.1 = name + · have sameWire : x = wire := by simpa [List.find?_cons, same] using found + subst wire + refine ⟨y.2, ?_, head.2⟩ + have yName : y.1 = name := head.1.symm.trans same + simp only [List.find?_cons, yName, beq_self_eq_true, ↓reduceIte] + exact congrArg some (Prod.ext head.1.symm rfl) + · have tailFound : xs.find? (·.1 == name) = some wire := by + simpa [List.find?_cons, same] using found + obtain ⟨value, result, decoded⟩ := ih tailFound + refine ⟨value, ?_, decoded⟩ + simpa [List.find?_cons, ← head.1, same] using result + +end DecodesEnvironment + +theorem DecodesValues.environment [NatCast F] [Zero F] [DecidableEq F] {decls : Declarations} + {wires : List (WireValue F)} {values : List (Value F)} (decoded : DecodesValues decls wires values) + (names : List String) : DecodesEnvironment decls (names.zip wires) (names.zip values) := by + induction decoded generalizing names with + | nil => simp [DecodesEnvironment] + | cons head tail ih => + cases names with + | nil => exact .nil + | cons name names => exact .cons ⟨rfl, head⟩ (ih names) + +end Aiur diff --git a/Aiur/Aiur/WireRoundtrip.lean b/Aiur/Aiur/WireRoundtrip.lean new file mode 100644 index 000000000..be6f6c87d --- /dev/null +++ b/Aiur/Aiur/WireRoundtrip.lean @@ -0,0 +1,156 @@ +import Aiur.WireCodec + +namespace Aiur + +set_option maxHeartbeats 1000000 + +/-- Distinct tags in a segment of the constructor numbering. -/ +def TagsDistinct (F : Type) [NatCast F] (start count : Nat) : Prop := + ∀ i j, start ≤ i → i < start + count → start ≤ j → j < start + count → + (i : F) = (j : F) → i = j + +theorem TagsDistinct.tail [NatCast F] {start count : Nat} + (safe : TagsDistinct F start (count + 1)) : TagsDistinct F (start + 1) count := by + intro i j il ih jl jh same + exact safe i j (by omega) (by omega) (by omega) (by omega) same + +/-- Every nested enum's tags remain distinct in the selected field. -/ +def Layout.TagSafe (F : Type) [NatCast F] : Layout → Prop + | .field | .ptr _ => True + | .tuple layouts => ∀ layout ∈ layouts, layout.TagSafe F + | .enum _ constructors => TagsDistinct F 0 constructors.length ∧ + ∀ pair ∈ constructors, pair.2.TagSafe F +termination_by layout => sizeOf layout +decreasing_by + all_goals simp_wf + all_goals + have h := List.sizeOf_lt_of_mem ‹_ ∈ _› + first | omega | cases ‹String × Layout›; simp_all only [Prod.mk.sizeOf_spec]; omega + +namespace Layout + +theorem encodeConstructor_index [NatCast F] [Zero F] {constructors : List (String × Layout)} + {ctor : String} {args : List (Value F)} {start index : Nat} {words : List F} + (encoded : encodeConstructor constructors ctor args start = some (index, words)) : + start ≤ index ∧ index < start + constructors.length := by + induction constructors generalizing start with + | nil => simp [encodeConstructor] at encoded + | cons pair rest ih => + rcases pair with ⟨name, layout⟩ + simp only [encodeConstructor] at encoded + split at encoded + · obtain ⟨payload, _, finished⟩ := Option.bind_eq_some_iff.mp encoded + simp only [Option.pure_def, Option.some.injEq, Prod.mk.injEq] at finished + rcases finished with ⟨rfl, rfl⟩ + simp + · have bounds := ih encoded + simp only [List.length_cons] + omega + +mutual + /-- Encoding followed by decoding recovers exactly the original nominal value. -/ + theorem decode_encode [NatCast F] [Zero F] [DecidableEq F] {layout : Layout} + (safe : layout.TagSafe F) {value : Value F} {words : List F} + (encoded : layout.encode value = some words) : layout.decode words = some value := by + cases layout with + | field => + cases value <;> simp [encode] at encoded + case field value => subst words; simp [decode] + | ptr target => + cases value <;> simp [encode] at encoded + case ptr actual address => + obtain ⟨rfl, rfl⟩ := encoded + simp [decode] + | tuple layouts => + cases value <;> simp [encode] at encoded + case tuple values => + simp [decode, decodeList_encode (by simpa only [TagSafe] using safe) encoded] + | enum name constructors => + cases value <;> simp only [encode] at encoded + case field => cases encoded + case ptr => cases encoded + case tuple => cases encoded + case construct actual ctor args => + split at encoded + · cases encoded + · rename_i same + have same : name = actual := by simpa using same + subst actual + obtain ⟨⟨index, payload⟩, chosen, finished⟩ := Option.bind_eq_some_iff.mp encoded + simp only [Option.pure_def, Option.some.injEq] at finished + subst words + have width := encodeConstructor_length chosen + have length : (payload ++ List.replicate (payloadWidth constructors - payload.length) (0 : F)).length = + payloadWidth constructors := by simp only [List.length_append, List.length_replicate]; omega + have implicit : constructors.length = 1 → (index : F) = ((0 : Nat) : F) := by + intro singleton + have bound := encodeConstructor_index chosen + have same : index = 0 := by omega + rw [same] + simp only [TagSafe] at safe + simp only [decode, enumParts_enumWords _ implicit, bind, Option.bind, length, ↓reduceIte] + rw [decodeConstructor_encode safe.1 safe.2 chosen] + rfl + termination_by sizeOf layout + + theorem decodeList_encode [NatCast F] [Zero F] [DecidableEq F] {layouts : List Layout} + (safe : ∀ layout ∈ layouts, layout.TagSafe F) {values : List (Value F)} {words : List F} + (encoded : encodeList layouts values = some words) : decodeList layouts words = some values := by + cases layouts with + | nil => cases values <;> simp_all [encodeList, decodeList] + | cons layout layouts => + cases values with + | nil => simp [encodeList] at encoded + | cons value values => + simp only [encodeList] at encoded + obtain ⟨head, headRun, rest⟩ := Option.bind_eq_some_iff.mp encoded + obtain ⟨tail, tailRun, finished⟩ := Option.bind_eq_some_iff.mp rest + simp only [Option.pure_def, Option.some.injEq] at finished + subst words + have width := encode_length headRun + simp only [decodeList, ← width, List.take_left, List.drop_left] + rw [decode_encode (safe _ (by simp)) headRun, + decodeList_encode (fun l h => safe l (by simp [h])) tailRun] + rfl + termination_by sizeOf layouts + + theorem decodeConstructor_encode [NatCast F] [Zero F] [DecidableEq F] + {constructors : List (String × Layout)} {ctor : String} {args : List (Value F)} + {start index : Nat} {payload : List F} + (tags : TagsDistinct F start constructors.length) + (safe : ∀ pair ∈ constructors, pair.2.TagSafe F) + (encoded : encodeConstructor constructors ctor args start = some (index, payload)) + (padding : Nat) : + decodeConstructor constructors (index : F) (payload ++ List.replicate padding 0) start = some (ctor, args) := by + cases constructors with + | nil => simp [encodeConstructor] at encoded + | cons pair rest => + rcases hpair : pair with ⟨name, layout⟩ + rw [hpair] at encoded safe tags + simp only [encodeConstructor] at encoded + split at encoded + · rename_i same + subst name + obtain ⟨words, headRun, finished⟩ := Option.bind_eq_some_iff.mp encoded + simp only [Option.pure_def, Option.some.injEq, Prod.mk.injEq] at finished + rcases finished with ⟨rfl, rfl⟩ + have width := encode_length headRun + simp only [decodeConstructor, ↓reduceIte, ← width, List.take_left, List.drop_left] + rw [decode_encode (safe (ctor, layout) (by simp)) headRun] + simp + · have bounds := encodeConstructor_index encoded + have different : (index : F) ≠ (start : F) := by + intro same + have equal := tags index start (by omega) (by simp only [List.length_cons]; omega) (by omega) + (by simp) same + omega + simp only [decodeConstructor, different, ↓reduceIte] + exact decodeConstructor_encode tags.tail (fun p h => safe p (by simp [h])) encoded padding + termination_by sizeOf constructors + decreasing_by + all_goals simp_all only [List.cons.sizeOf_spec, Prod.mk.sizeOf_spec] + all_goals omega +end + +end Layout +end Aiur diff --git a/Aiur/AiurTests.lean b/Aiur/AiurTests.lean new file mode 100644 index 000000000..eabf32aa4 --- /dev/null +++ b/Aiur/AiurTests.lean @@ -0,0 +1,233 @@ +import Aiur.Scalar +import AiurTests.Circuit +import AiurTests.Semantics +import AiurTests.Memo +import AiurTests.TupleRuntime +import AiurTests.Enums +import AiurTests.EnumEncoding +import AiurTests.Tagless +import AiurTests.EnumProofs +import AiurTests.Pointers +import AiurTests.WidthROM +import AiurTests.Tuples +import AiurTests.Tables +import AiurTests.RefutableLets +import AiurTests.InputTypes +import AiurTests.Hints +import AiurTests.Accumulators +import AiurTests.Generics +import AiurTests.Aliases +import AiurTests.PointerPatterns +import AiurTests.Consts +import AiurTests.Arrays +import AiurTests.SourceEvaluation +import AiurTests.Control +import AiurTests.Structs +import AiurTests.Updates +import AiurTests.Diagnostics +import AiurTests.Assertions +import AiurTests.OrPatterns +import AiurTests.Modules +import AiurTests.Opacity +import AiurTests.Execution +import AiurTests.Trace +import AiurTests.Inlining +import AiurTests.CircuitStats +import AiurTests.Optimized +import AiurTests.Propagation +import AiurTests.CompilerIndex +import AiurTests.Carry +import AiurTests.Blake3 +import AiurTests.U8 +import AiurTests.U64 +import AiurTests.U32 +import AiurTests.LibraryInterfaces +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +open Aiur.Scalar + +namespace AiurTests + +def identity : Program Nat := scalar_aiur% "fn identity(x) { x }" + +/-- Elaboration produces ordinary AST constructors, reducible by the kernel. -/ +example : identity = ⟨[⟨"identity", ["x"], .var "x"⟩]⟩ := rfl +example : typecheck identity = .ok () := by decide +kernel +example : eval (identity.toField Rat) "identity" [42] = .ok 42 := by decide +kernel + +def sample : Program Nat := scalar_aiur% " +// The same definitions will be evaluated in two fields. +fn arithmetic(x: Field, y: Field) -> Field { (x + y) * (x - y) / y } +fn negation(x) { -x * 2 + 1 } +fn adjacent(x) { x--1 + x/-2 } +fn tabs(x) {\t x\t/\t2\r\n} +fn precedence() { 2 + 3 * 4 - 8 / 2 } +fn left_assoc() { 12 / 3 / 2 - 2 - 1 } +fn sum3(x, y, z,) { x + y + z } +fn forward(x) { sum3(x, 2, 3,) } +fn even(n) { + match n { + 0 => 1, + _ => odd(n - 1), + } +} +fn odd(n) { + match n { + 0 => 0, + _ => even(n - 1), + } +} +fn divide(x, y) { x / y } +fn lazy_match(x) { match x { 0 => 9, _ => 1 / 0 } } +fn ordered(x) { match x { 7 => 10, 0 => 20, _ => 30 } } +fn wildcard_first(x) { match x { _ => 11, 0 => 22 } } +fn partial_match(x) { match x { 1 => 4 } } +fn nested(x, y) { match x { 0 => { match y { 1 => 2, _ => 3 } }, _ => 4 } } +fn forever(x) { forever(x) } +fn eager() { sum3(1 / 0, 2, 3) } +fn large() { 123456789012345678901234567890 } +fn literal() { /* outer /* nested */ comment */ 8 } // trailing comment +" + +def rationals : Program Rat := sample.toField Rat + +instance : Fact (Nat.Prime 7) := ⟨by decide⟩ +def modSeven : Program (ZMod 7) := sample.toField (ZMod 7) + +def rationalTests : List (String × Except EvalError Rat × Except EvalError Rat) := [ + ("arithmetic", eval rationals "arithmetic" [5, 2], .ok (21 / 2)), + ("unary minus", eval rationals "negation" [3], .ok (-5)), + ("adjacent operators", eval rationals "adjacent" [6], .ok 4), + ("tabs and CRLF", eval rationals "tabs" [6], .ok 3), + ("operator precedence", eval rationals "precedence" [], .ok 10), + ("left associativity", eval rationals "left_assoc" [], .ok (-1)), + ("many arguments", eval rationals "sum3" [4, 5, 6], .ok 15), + ("forward call", eval rationals "forward" [4], .ok 9), + ("mutual recursion, even", eval rationals "even" [10], .ok 1), + ("mutual recursion, odd", eval rationals "even" [9], .ok 0), + ("mutual recursion, other entry", eval rationals "odd" [9], .ok 1), + ("division by zero", eval rationals "divide" [1, 0], .error .divisionByZero), + ("unselected arm is lazy", eval rationals "lazy_match" [0], .ok 9), + ("selected arm can fail", eval rationals "lazy_match" [1], .error .divisionByZero), + ("pattern before specialization", eval rationals "ordered" [0], .ok 20), + ("first matching arm", eval rationals "wildcard_first" [0], .ok 11), + ("missing arm", eval rationals "partial_match" [0], .error .noMatchingArm), + ("nested matches", eval rationals "nested" [0, 1], .ok 2), + ("recursion limit", eval rationals "forever" [1] 20, .error .outOfFuel), + ("zero fuel", eval rationals "literal" [] 0, .error .outOfFuel), + ("single literal fuel", eval rationals "literal" [] 1, .ok 8), + ("eager call arguments", eval rationals "eager" [], .error .divisionByZero), + ("entry lookup", eval rationals "missing" [], .error (.unknownFunction "missing")), + ("entry arity", eval rationals "sum3" [1], .error (.arityMismatch "sum3" 3 1)), + ("large natural", eval rationals "large" [], .ok 123456789012345678901234567890) +] + +def finiteFieldTests : List (String × Except EvalError (ZMod 7) × Except EvalError (ZMod 7)) := [ + ("literal reduction", eval modSeven "literal" [], .ok 1), + ("field division", eval modSeven "divide" [1, 2], .ok 4), + ("field negation", eval modSeven "negation" [3], .ok 2), + ("patterns specialized too", eval modSeven "ordered" [0], .ok 3), + ("zero after reduction", eval modSeven "divide" [1, 7], .error .divisionByZero) +] + +def invalidPrograms : List (Program Nat × CheckError) := [ + (⟨[⟨"f", [], .literal 0⟩, ⟨"f", [], .literal 1⟩]⟩, .duplicateFunction "f"), + (⟨[⟨"f", ["x", "x"], .var "x"⟩]⟩, .duplicateParameter "f" "x"), + (⟨[⟨"f", [], .var "x"⟩]⟩, .unboundVariable "f" "x"), + (⟨[⟨"f", [], .call "g" []⟩]⟩, .unknownFunction "f" "g"), + (⟨[⟨"f", ["x"], .call "f" []⟩]⟩, .arityMismatch "f" "f" 1 0), + (⟨[⟨"f", [], .matchValue (.literal 0) []⟩]⟩, .emptyMatch "f"), + (⟨[⟨"f", [], .matchValue (.literal 0) + [(.wildcard, .literal 1), (.literal 0, .var "unreachable")]⟩]⟩, + .unboundVariable "f" "unreachable") +] + +-- The string elaborator runs the checker rather than merely constructing syntax. +/-- error: function 'f' calls 'f' with 0 arguments; expected 1 -/ +#guard_msgs in +#check (scalar_aiur% "fn f(x) { f() }" : Program Nat) + +/-- error: duplicate function 'f' -/ +#guard_msgs in +#check (scalar_aiur% "fn f() { 0 } fn f() { 1 }" : Program Nat) + +/-- error: unbound variable 'y' in function 'f' -/ +#guard_msgs in +#check (scalar_aiur% "fn f(x) { y }" : Program Nat) + +-- These exercise parser failures without coupling tests to parser error formatting. +run_cmd do + let env ← Lean.getEnv + for source in [ + "fn f() { 1 } trailing", + "fn f() { match 0 { } }", + "fn f() { match 0 { x => 1 } }", + "fn f(x: Nat) { x }", + "fn f() -> Nat { 0 }", + "fn f() { (1, 2) }", + "fn f() { 1 + }", + "fn f() { 1 /* comment */ 2 }", + "fn f() { 1 } /* unterminated", + "fn f() { 1 } -- not a Rust comment" + ] do + match Frontend.ofString env source with + | .error _ => pure () + | .ok _ => throwError "unexpectedly accepted invalid source: {source}" + +private def checkEqual [DecidableEq α] [Repr α] (label : String) (actual expected : α) : IO Unit := do + unless actual = expected do + throw (IO.userError s!"{label}: expected {repr expected}, got {repr actual}") + +def run : IO Unit := do + for (label, actual, expected) in rationalTests do + checkEqual label actual expected + for (label, actual, expected) in finiteFieldTests do + checkEqual label actual expected + for (program, error) in invalidPrograms do + checkEqual "checker error" (typecheck program) (.error error) + checkEqual "checked evaluation" (eval (program.toField Rat) "f" []) + (.error (.invalidProgram error)) + IO.println s!"Passed {rationalTests.length + finiteFieldTests.length + 2 * invalidPrograms.length} runtime checks." + +end AiurTests + +def main : IO Unit := do + AiurTests.run + AiurCircuitTests.run + AiurTupleTests.run + AiurPointerTests.run + AiurTupleRuntimeTests.run + AiurEnumTests.run + AiurEnumEncodingTests.run + AiurTaglessTests.run + AiurTableTests.run + AiurRefutableLetTests.run + AiurInputTypeTests.run + AiurHintTests.run + AiurAccumulatorTests.run + AiurGenericTests.run + AiurAliasTests.run + AiurPointerPatternTests.run + AiurConstTests.run + AiurArrayTests.run + AiurControlTests.run + AiurStructTests.run + AiurUpdateTests.run + AiurDiagnosticTests.run + AiurAssertionTests.run + AiurOrPatternTests.run + AiurModuleTests.run + AiurOpacityTests.run + AiurExecutionTests.run + AiurTraceTests.run + AiurTraceTests.runSmallField + AiurInlineTests.run + AiurCircuitStatsTests.run + AiurPropagationTests.run + AiurCompilerIndexTests.run + AiurCarryTests.run + AiurU8Tests.run + AiurU64Tests.run + AiurU32Tests.run + AiurOptimizedTests.run diff --git a/Aiur/AiurTests/Accumulators.lean b/Aiur/AiurTests/Accumulators.lean new file mode 100644 index 000000000..f144f548f --- /dev/null +++ b/Aiur/AiurTests/Accumulators.lean @@ -0,0 +1,117 @@ +import Aiur +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +open Aiur Aiur.Circuit + +namespace AiurAccumulatorTests + +set_option maxRecDepth 10000 +set_option maxHeartbeats 2000000 + +def source : Program Nat := aiur% " +table keys: () { (), } +table values: Field { 7, } +map known() -> Field = keys => values; +fn leaf() -> Field { 7 } +fn twice() -> Field { leaf() + leaf() } +fn loop() -> Field { loop() } +fn tables() -> Field { known() + known() } +fn memory(x: Field) -> Field { *&x } +" + +def system (F : Type) [Field F] [DecidableEq F] : System F := + (compile (source.toField F)).toOption.getD { chips := [] } + +def leaf : Row Rat := ⟨"leaf", [7]⟩ +def twice : Row Rat := ⟨"twice", [14, 7, 7]⟩ +def loop : Row Rat := ⟨"loop", [99, 99]⟩ +def root : Message Rat := ⟨"twice", [], 14⟩ +def loopClaim : Message Rat := ⟨"loop", [], 99⟩ + +private def unit (claim : Message Rat) (rows : List (Row Rat)) := + (system Rat).check ⟨[]⟩ claim rows + +private def memo (claim : Message Rat) (rows : List (WeightedRow Rat)) := + (system Rat).checkMemo ⟨[]⟩ claim rows + +def checks : List (String × Except WitnessError Unit × Except WitnessError Unit) := [ + ("unit requires duplicate rows", unit root [twice, leaf, leaf], .ok ()), + ("unit cannot reuse one provide", unit root [twice, leaf], .error .unbalancedMessages), + ("row order is irrelevant", unit root [leaf, twice, leaf], .ok ()), + ("memo shares one leaf", memo root [⟨twice, 1⟩, ⟨leaf, 2⟩], .ok ()), + ("memo row order is irrelevant", memo root [⟨leaf, 2⟩, ⟨twice, 1⟩], .ok ()), + ("provide multiplicity must balance", memo root [⟨twice, 1⟩, ⟨leaf, 1⟩], .error .unbalancedMessages), + ("requires are not multiplied", memo root [⟨twice, 2⟩, ⟨leaf, 4⟩], .error .unbalancedMessages), + ("zero provide still requires premises", memo root [⟨twice, 1⟩, ⟨leaf, 2⟩, ⟨loop, 0⟩], + .error .unbalancedMessages), + ("signed provides cancel exactly", memo root [⟨twice, 1⟩, ⟨leaf, 3⟩, ⟨leaf, -1⟩], .ok ()), + ("negative provide alone cannot prove root", memo ⟨"leaf", [], 7⟩ [⟨leaf, -1⟩], + .error .unbalancedMessages), + ("unit cycle cannot justify root", unit loopClaim [loop], .error .unbalancedMessages), + ("memo cycle can justify root", memo loopClaim [⟨loop, 2⟩], .ok ()), + ("unused balanced cycle is allowed", unit root [twice, leaf, loop, leaf], .ok ()), + ("zero weight cannot bypass constraints", memo root + [⟨twice, 1⟩, ⟨leaf, 2⟩, ⟨⟨"leaf", [8]⟩, 0⟩], .error (.constraintNotZero "leaf" 0)), + ("zero weight cannot bypass row width", memo root + [⟨twice, 1⟩, ⟨leaf, 2⟩, ⟨⟨"leaf", []⟩, 0⟩], .error (.wrongRowSize "leaf" 1 0)), + ("unknown weighted row", memo root [⟨⟨"absent", []⟩, 0⟩], .error (.unknownChip "absent")), + ("unit static root", unit ⟨"known", [], 7⟩ [], .ok ()), + ("memo static root", memo ⟨"known", [], 7⟩ [], .ok ()), + ("false static claim", memo ⟨"known", [], 8⟩ [], .error .unbalancedMessages), + ("unit static leaves are reusable", unit ⟨"tables", [], 14⟩ [⟨"tables", [14, 7, 7]⟩], .ok ()), + ("memo static leaves are reusable", memo ⟨"tables", [], 14⟩ [⟨⟨"tables", [14, 7, 7]⟩, 1⟩], .ok ()), + ("memo ROM membership", (system Rat).checkMemo ⟨[(99, 7)]⟩ ⟨"memory", [7], 7⟩ + [⟨⟨"memory", [7, 7, 99, 7]⟩, 1⟩], .ok ()), + ("memo missing ROM cell", memo ⟨"memory", [7], 7⟩ [⟨⟨"memory", [7, 7, 99, 7]⟩, 1⟩], + .error (.missingCell "memory" 0)), + ("memo rejects nonfunctional ROM", (system Rat).checkMemo ⟨[(99, 7), (99, 8)]⟩ + ⟨"memory", [7], 7⟩ [⟨⟨"memory", [7, 7, 99, 7]⟩, 1⟩], .error .invalidROM), + ("memo rejects pointer arguments", memo ⟨"memory", [.ptr .field 99], 7⟩ [], + .error .pointerEntryArgument), + ("memo rejects malformed root", memo ⟨"leaf", [], ⟨.field, []⟩⟩ [], .error .malformedEntry) +] + +-- Balance remains exact even when two requirements would vanish in the circuit field. +instance : Fact (Nat.Prime 2) := ⟨by decide⟩ + +example : (system (ZMod 2)).check ⟨[]⟩ ⟨"twice", [], 0⟩ [⟨"twice", [0, 1, 1]⟩] = + .error .unbalancedMessages := by decide +kernel +example : (system (ZMod 2)).checkMemo ⟨[]⟩ ⟨"twice", [], 0⟩ [⟨⟨"twice", [0, 1, 1]⟩, 1⟩] = + .error .unbalancedMessages := by decide +kernel +example : (system (ZMod 2)).checkMemo ⟨[]⟩ ⟨"twice", [], 0⟩ + [⟨⟨"twice", [0, 1, 1]⟩, 1⟩, ⟨⟨"leaf", [1]⟩, 2⟩] = .ok () := by decide +kernel + +theorem tree : Derives (system Rat) ⟨[]⟩ root := + System.check_sound (by decide +kernel : unit root [twice, leaf, leaf] = .ok ()) + +theorem cyclic : MemoDerives (system Rat) ⟨[]⟩ loopClaim := + System.checkMemo_sound (by decide +kernel : memo loopClaim [⟨loop, 2⟩] = .ok ()) + +example : ∃ rows, (system Rat).check ⟨[]⟩ root rows = .ok () := + (System.check_derives_iff (by decide +kernel)).mpr tree + +example : ∃ rows, (system Rat).checkMemo ⟨[]⟩ loopClaim rows = .ok () := + (System.checkMemo_derives_iff (by decide +kernel)).mpr cyclic + +-- Theorems are checked by Lean's kernel; classical choice is permitted, admissions are not. +/-- info: 'Aiur.Circuit.System.check_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Circuit.System.check_sound +/-- info: 'Aiur.Circuit.Derivation.check_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Circuit.Derivation.check_complete +/-- info: 'Aiur.Circuit.System.checkMemo_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Circuit.System.checkMemo_sound +/-- info: 'Aiur.Circuit.MemoDerivation.check_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Circuit.MemoDerivation.check_complete + +def run : IO Unit := do + for (label, actual, expected) in checks do + unless actual = expected do + throw (IO.userError s!"{label}: expected {repr expected}, got {repr actual}") + IO.println s!"Passed {checks.length} integer accumulator checks." + +end AiurAccumulatorTests diff --git a/Aiur/AiurTests/Aliases.lean b/Aiur/AiurTests/Aliases.lean new file mode 100644 index 000000000..d5e994ba1 --- /dev/null +++ b/Aiur/AiurTests/Aliases.lean @@ -0,0 +1,213 @@ +import Aiur.Generic +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +namespace AiurAliasTests +open Aiur +instance : Fact (Nat.Prime 101) := ⟨by decide⟩ +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 + +def source : Generic.Program Nat := aiur% " +type Coordinates = Pair; +type Pair = (T, T); +type Scalar = Field; +type Id = T; +type Maybe = Option; +type Fixed = Maybe; +type Wrapped = Box>; +type Swapped = Either; +type Link = &List; +type Concrete = Scalar; +enum Option { None, Some(T) } +enum Box { New(T) } +enum Either { Left(A), Right(B) } +enum List { Nil, Cons(T, Link) } + +fn identity(x: T) -> T { x } +fn pair(x: T) -> Pair { (x, x) } +fn unwrap(x: Maybe, fallback: T) -> T { + match x { Maybe::Some(v) => v, Maybe::None => fallback } +} +fn unbox(Wrapped::New((a, b)): Wrapped) -> T { a } +fn main(x: Id>) -> Scalar { + let coordinates = pair(x); + unwrap(Maybe::Some(identity::(coordinates.0)), identity::(0)) +} +fn explicit(x: Field) -> Field { unwrap(Maybe::::Some(x), 0) } +fn fixed(x: Scalar) -> Fixed { Fixed::Some(x) } +fn none() -> Fixed { Fixed::None } +fn nested(x: Scalar) -> Scalar { unbox(Wrapped::New(pair(x))) } +fn swapped(x: Scalar) -> Swapped<(Scalar, Scalar), Scalar> { Swapped::Left(x) } +fn read(x: Scalar) -> Scalar { + let list = List::Cons(x, &List::::Nil); + let List::Cons(v, tail) = list; + let List::Nil = *tail; + v +} +fn hinted(x: T) -> Scalar { hint::>(x) } +fn hint_entry(x: Scalar) -> Scalar { hinted(x) } +fn literal() -> Scalar { 108 } +fn singleton(x: (Scalar,)) -> (Scalar,) { x } +" + +-- Type metadata is normalized, while alias declarations and code remain. +#guard source.aliases.length == 10 +#guard (source.findFunction? "main").map (·.params) == some [("x", .field)] +#guard (source.findFunction? "literal").map (·.body) == some (.literal 108) +#guard (source.findFunction? "singleton").map (·.result) == some (.tuple [.field]) + +def runSource (name : String) (args : List (SourceValue Rat)) := do + let s ← Generic.prepare (source.toField Rat) + s.run name args + +def runSpecialized (name : String) (args : List (SourceValue Rat)) := do + let s ← Generic.prepare (source.toField Rat) + let q ← Generic.specialize s [name] + q.run name args + +#guard runSource "main" [.field 17] == .ok (.field 17, []) +#guard runSpecialized "main" [.field 17] == .ok (.field 17, []) +#guard runSpecialized "explicit" [.field 19] == .ok (.field 19, []) +#guard runSpecialized "nested" [.field 23] == .ok (.field 23, []) +#guard runSpecialized "swapped" [.field 31] == runSource "swapped" [.field 31] +#guard runSpecialized "fixed" [.field 31] == runSource "fixed" [.field 31] +#guard runSpecialized "none" [] == runSource "none" [] +#guard (runSpecialized "read" [.field 29]).map Prod.fst == .ok (.field 29) +#guard runSource "read" [.field 29] == runSpecialized "read" [.field 29] + +-- Aliases do not make new specialization keys or nominal enum identities. +#guard (do + let s ← Generic.prepare (source.toField Rat) + let q ← Generic.specialize s ["main", "explicit", "fixed", "none"] + return (q.program.functions.filter fun (decl : Aiur.Function Rat) => + (Generic.Instance.ofSymbol decl.name).toOption.any (fun (key : Generic.Instance) => key.name == "identity")).length) == .ok 1 +#guard (do + let s ← Generic.prepare (source.toField Rat) + let q ← Generic.specialize s ["main", "explicit", "fixed", "none"] + return q.program.enums.length) == .ok 1 + +def mapped : Generic.Program Nat := aiur% " +type Item = Box; +type Key = (Item,); +enum Box { New(T) } +table keys: Key { (Item::New(1),), (Item::New(2),) } +table outputs: Item { Item::New(3), Item::New(4) } +map lookup(x: Item) -> Item = keys => outputs; +fn main(x: Field) -> Field { let Item::New(y) = lookup(Item::New(x)); y } +" + +#guard (do + let s ← Generic.prepare (mapped.toField Rat) + let q ← Generic.specialize s ["main"] + q.run "main" [.field 2]) == .ok (.field 4, []) +#guard (do + let s ← Generic.prepare (source.toField Rat) + s.run "hint_entry" [.field 2] 100 (s.checkedHints (fun _ _ => .ok (.field 41)))) == + .ok (.field 41, []) +#guard (do + let s ← Generic.prepare (source.toField (ZMod 101)) + s.run "literal" []) == .ok (.field 7, []) +#guard (do + let s ← Generic.prepare (source.toField (ZMod 101)) + let q ← Generic.specialize s ["main", "read", "nested", "swapped", "hint_entry"] + return (← q.compile).system.chips.length).toOption.isSome +#guard (do + let s ← Generic.prepare (mapped.toField (ZMod 101)) + let q ← Generic.specialize s ["main"] + return (← q.compile).system.maps.length) == .ok 1 + +-- The shared preparation API also expands hand-built, field-valued ASTs. +def handBuilt : Generic.Program Nat := { + aliases := [{ name := "Scalar", target := .field }] + functions := [{ + name := "main" + params := [("x", .named "Scalar" [])] + result := .named "Scalar" [] + body := .var "x" + }] +} +#guard (do + let s ← Generic.prepare (handBuilt.toField Rat) + s.run "main" [.field 13]) == .ok (.field 13, []) + +run_cmd do + let bad := [ + "type A = A;", + "type A = &A;", + "type A = A<(T, T)>;", + "type A = B; type B = (Field, A);", + "type A = E; enum E { New(T) }", + "type Ignore = Field; type A = Ignore;", + "type A = Missing;", + "type A = U;", + "type A = T;", + "type Field = ();", + "type A = Field;", + "type T = Field; fn f(x: T) -> Field { x }", + "type A = Field; type A = ();", + "type A = Field; enum A { New }", + "type P = (T, T); fn f(x: P) -> Field { 0 }", + "type S = Field; fn f(x: S) -> Field { x }", + "type Ignore = Field; fn f(x: Ignore) -> Field { x }", + "type Ignore = Field; fn f() -> Field { hint::>(()) }", + "type S = Field; fn f() -> S { S::Some(1) }", + "enum O { Some(T) } type A = O; fn f() -> A { A::::Some(1) }", + "enum O { Some(T) } type Fixed = O; fn f(x: O<(Field, Field)>) -> Field { let Fixed::Some(y) = x; 0 }", + "enum O { Some(T) } type Fixed = O; fn f() -> O<(Field, Field)> { Fixed::Some((1, 2)) }", + "type A = Field; fn f(x: (A,)) -> A { x }", + "enum E { A } enum F { A } type X = E; fn f(x: X) -> F { x }", + "type P = &Field; fn f() -> P { hint::/.{proof,vk,claims}.bin` — if all three exist - the prove is skipped and blobs are loaded instead - --reprove force a fresh prove even when blobs exist - --skip-deps subject-only check (`verify_const`) instead of the - full-closure `verify_claim` default - --queries N FRI numQueries (default 100; the pipeline's - `recursiveFriParameters` in Benchmarks/Typecheck.lean - runs 50 with no query PoW, while this tool grinds 20 - PoW bits — pass --queries 50 when a replay should - mirror the pipeline's query count); must match between - prove and replay! - --mode M how to run the recursive verifier over the saved proof: - native codegen'd Rust verifier (default; the - production path bench-typecheck uses) - bytecode generic Rust Aiur bytecode interpreter - interp Lean debug interpreter — call-stack trace + - pretty-printed values on failure (slow) - --depth N interp: pointer-deref depth in the pp (default 2) - --stack N interp: max call-stack frames shown (default 40) -``` --/ - -open Lean (Name) - -def argNat (args : List String) (flag : String) (dflt : Nat) : Nat := - match args.dropWhile (· != flag) with - | _ :: v :: _ => v.toNat?.getD dflt - | _ => dflt - -def argStr (args : List String) (flag : String) : Option String := - match args.dropWhile (· != flag) with - | _ :: v :: _ => some v - | _ => none - -def commitParams : Aiur.CommitmentParameters := { logBlowup := 2, capHeight := 0 } - -def friParams (numQueries : Nat) : Aiur.FriParameters := - { logFinalPolyLen := 0, maxLogArity := 1, numQueries, - commitProofOfWorkBits := 0, queryProofOfWorkBits := 20 } - -def secs (t0 t1 : Nat) : Float := (Float.ofNat (t1 - t0)) / 1e9 - -/-- Prove `constName`'s typecheck and return `(proofBytes, vkBytes, claimBytes)`. -/ -def proveConst (ixePath constName : String) (skipDeps : Bool) - (fri : Aiur.FriParameters) : IO (Option (ByteArray × ByteArray × ByteArray)) := do - -- `--skip-deps` uses the subject-only `verify_const`, which the - -- production toplevel no longer carries. - let .ok toplevel := (if skipDeps then IxVM.ixVMFull else IxVM.ixVM) - | IO.eprintln "IxVM toplevel merge failed"; return none - let .ok compiled := toplevel.compileWithGroups IxVM.functionGroups - | IO.eprintln "IxVM compile failed"; return none - let entrypoint := if skipDeps then `verify_const else `verify_claim - let some funIdx := compiled.getFuncIdx entrypoint - | IO.eprintln s!"{entrypoint} entrypoint missing"; return none - let aiurSystem := Aiur.AiurSystem.build compiled.bytecode commitParams fri - let ixonEnv ← match Ixon.deEnvAnon (← IO.FS.readBinFile ixePath) with - | .error e => IO.eprintln s!"deserialize {ixePath} failed: {e}"; return none - | .ok env => pure env - let some addr := Ix.Cli.NameResolve.resolveIxeAddr ixonEnv constName - | IO.eprintln s!"{constName} not found in {ixePath}"; return none - IO.println s!"proving {constName} ({if skipDeps then "subject-only" else "full closure"}, \ - numQueries={fri.numQueries}) …" - (← IO.getStdout).flush - let t0 ← IO.monoNanosNow - let (claim, proof) ← - if skipDeps then do - let witness ← match IxVM.ClaimHarness.buildVerifyConst ixonEnv addr with - | .error e => IO.eprintln s!"verify_const witness: {e}"; return none - | .ok w => pure w - match aiurSystem.proveIxVM funIdx witness.input witness.inputIOBuffer with - | .error e => IO.eprintln s!"proveIxVM failed: {e}"; return none - | .ok (claim, proof, _) => pure (claim, proof) - else do - let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with - | .error e => IO.eprintln s!"EnvHandle.fromIxe: {e}"; return none - | .ok h => pure h - match aiurSystem.proveAddrWithEnv funIdx envHandle addr.hash with - | .error e => IO.eprintln s!"proveAddrWithEnv failed: {e}"; return none - | .ok (claimBytes, proof, _) => - -- `verify_claim`'s public input is the packed blake3 digest of the - -- serialized `Ix.Claim` (same recipe as `ix verify` / bench-typecheck: - -- 8 G elements of 4 LE bytes each, `ClaimHarness.packedDigestKey`). - let digest := Address.blake3 claimBytes - pure (Aiur.buildClaim funIdx (IxVM.ClaimHarness.packedDigestKey digest) #[], proof) - let t1 ← IO.monoNanosNow - IO.println s!"inner prove: {secs t0 t1} s, proof {proof.toBytes.size} bytes" - -- Sanity: the inner proof must verify out-of-circuit before we chase the - -- recursive verifier. - match aiurSystem.verify claim proof with - | .ok () => IO.println "inner proof verifies out-of-circuit: ok" - | .error e => IO.eprintln s!"⚠ inner proof FAILS out-of-circuit verify: {e}" - -- Verify the proof before serializing the transport consumed in-circuit. - match aiurSystem.proofToAdviceBytes claim proof with - | .error e => IO.eprintln s!"advice re-encoding failed: {e}"; return none - | .ok adviceBytes => - return some (adviceBytes, aiurSystem.vkBytes, MultiStark.serializeClaims #[claim]) - -def main (args : List String) : IO UInt32 := do - let ixePath := (argStr args "--ixe").getD "init.ixe" - let some constName := argStr args "--const" - | IO.eprintln "usage: bench-recursion-debug --const [--ixe ] \ - [--dir ] [--mode native|bytecode|interp] [--skip-deps] [--reprove]" - return 1 - let dir := (argStr args "--dir").getD "recursion-debug" - let mode := (argStr args "--mode").getD "native" - let skipDeps := args.contains "--skip-deps" - let fri := friParams (argNat args "--queries" 100) - if fri.numQueries == 0 then - IO.eprintln "error: --queries must be positive" - return 1 - let depth := argNat args "--depth" 2 - let stackLimit := argNat args "--stack" 40 - IO.FS.createDirAll dir - let tag := if skipDeps then s!"{constName}.skipdeps" else constName - let tag := s!"{tag}.q{fri.numQueries}" - let proofPath : System.FilePath := s!"{dir}/{tag}.proof.bin" - let vkPath : System.FilePath := s!"{dir}/{tag}.vk.bin" - let claimsPath : System.FilePath := s!"{dir}/{tag}.claims.bin" - let allSaved := (← proofPath.pathExists) && (← vkPath.pathExists) - && (← claimsPath.pathExists) - let (proofBytes, vkBytes, claimBytes) ← - if allSaved && !args.contains "--reprove" then do - IO.println s!"loading saved blobs {dir}/{tag}.*.bin" - pure (← IO.FS.readBinFile proofPath, ← IO.FS.readBinFile vkPath, - ← IO.FS.readBinFile claimsPath) - else do - let some blobs ← proveConst ixePath constName skipDeps fri | return 1 - let (p, v, c) := blobs - IO.FS.writeBinFile proofPath p - IO.FS.writeBinFile vkPath v - IO.FS.writeBinFile claimsPath c - IO.println s!"saved blobs to {dir}/{tag}.*.bin" - pure (p, v, c) - IO.println s!"proof {proofBytes.size} bytes, vk {vkBytes.size} bytes, \ - claims {claimBytes.size} bytes" - - -- ── the recursive verifier over the saved blobs ─────────────────────────── - let .ok vTop := MultiStark.multiStark - | IO.eprintln "multi-stark verifier toplevel merge failed"; return 1 - -- `--list-funcs`: dump the compiled verifier's funIdx → name table (for - -- decoding fun_idx stacks printed by the Rust bytecode interpreter). - if args.contains "--list-funcs" then - let .ok vCompiled := vTop.compileWithGroups MultiStark.verifierFunctionGroups - | IO.eprintln "multi-stark verifier compile failed"; return 1 - let entries := vCompiled.nameMap.toArray.qsort (·.2 < ·.2) - for (g, i) in entries do - IO.println s!"{i} {g}" - return 0 - let pubInput := MultiStark.verifierPubInput vkBytes claimBytes - if mode == "interp" then - -- Lean debug interpreter: call-stack + pretty-printed values on failure. - let decls ← match vTop.mkDecls with - | .error e => IO.eprintln s!"mkDecls failed: {e}"; return 1 - | .ok d => pure d - let gName := Aiur.Global.mk `verify_multi_stark_proof - let inputTypes ← match decls.getByKey gName with - | some (.function f) => pure (f.inputs.map (·.2)) - | _ => IO.eprintln "verify_multi_stark_proof not in decls"; return 1 - let inputs := Aiur.unflattenInputs decls pubInput inputTypes - let toGs := fun (b : ByteArray) => b.data.map Aiur.G.ofUInt8 - let io := (((default : Aiur.IOBuffer).extend 0 #[Aiur.G.ofNat 0] (toGs proofBytes)).extend - 1 #[Aiur.G.ofNat 0] (toGs vkBytes)).extend - 2 #[Aiur.G.ofNat 0] (toGs claimBytes) - IO.println "running verify_multi_stark_proof under the Lean debug interpreter …" - (← IO.getStdout).flush - let t0 ← IO.monoNanosNow - match Aiur.runFunction decls gName inputs io with - | (.error e, s) => - let t1 ← IO.monoNanosNow - IO.eprintln s!"REJECTED after {secs t0 t1} s:\n{e.ppDeref s.store depth stackLimit}" - return 1 - | (.ok v, s) => - let t1 ← IO.monoNanosNow - IO.println s!"ACCEPTED in {secs t0 t1} s: {Aiur.Value.ppDeref s.store depth v}" - return 0 - else - let .ok vCompiled := vTop.compileWithGroups MultiStark.verifierFunctionGroups - | IO.eprintln "multi-stark verifier compile failed"; return 1 - let some vIdx := vCompiled.getFuncIdx `verify_multi_stark_proof - | IO.eprintln "verify_multi_stark_proof entrypoint missing"; return 1 - let useBytecode := mode == "bytecode" - IO.println s!"executing verify_multi_stark_proof \ - ({if useBytecode then "Rust bytecode interpreter" else "codegen'd native"}) …" - (← IO.getStdout).flush - let t0 ← IO.monoNanosNow - match vCompiled.bytecode.executeMultiStark vIdx pubInput proofBytes vkBytes - claimBytes useBytecode with - | .error e => - let t1 ← IO.monoNanosNow - IO.eprintln s!"REJECTED after {secs t0 t1} s: {e}" - return 1 - | .ok (out, qc) => - let t1 ← IO.monoNanosNow - let vShapes := Aiur.circuitShapes vCompiled.bytecode commitParams fri - let stats := Aiur.computeStats vCompiled qc vShapes - (logBlowup := commitParams.logBlowup) - IO.println s!"ACCEPTED in {secs t0 t1} s, output {out}, \ - fft-cost {stats.totalFftCost}" - return 0 diff --git a/Benchmarks/Sha256.lean b/Benchmarks/Sha256.lean deleted file mode 100644 index 849bf6758..000000000 --- a/Benchmarks/Sha256.lean +++ /dev/null @@ -1,54 +0,0 @@ -import Ix.Aiur.Library.Core -import Ix.Aiur.Library.ByteStream -import Ix.IxVM.Sha256 -import Ix.Aiur.Protocol -import Ix.Aiur.Compiler -import Ix.Benchmark.Bench - -open BgroupM - -abbrev dataSizes := #[64, 128, 256, 512, 1024, 2048] -abbrev numHashesPerProof := #[1, 2, 4, 8, 16, 32] - -def commitmentParameters : Aiur.CommitmentParameters := { - logBlowup := 2 - capHeight := 0 -} - -def friParameters : Aiur.FriParameters := { - logFinalPolyLen := 0 - maxLogArity := 1 - numQueries := 100 - commitProofOfWorkBits := 0 - queryProofOfWorkBits := 20 -} - -def mergedToplevel : Except Aiur.Global Aiur.Source.Toplevel := do - let tl ← Aiur.Library.core.merge Aiur.Library.byteStream - tl.merge IxVM.sha256 - -def sha256Bench : IO $ Array BenchReport := do - let .ok toplevel := mergedToplevel - | throw (IO.userError "Merging failed") - let .ok compiled := toplevel.compile - | throw (IO.userError "Compilation failed") - let some funIdx := compiled.getFuncIdx `sha256_bench - | throw (IO.userError "Aiur function not found") - let aiurSystem := Aiur.AiurSystem.build compiled.bytecode commitmentParameters friParameters - bgroup "prove sha256" { oneShot := true, avgThroughput := true, report := true } do - for dataSize in dataSizes do - for numHashes in numHashesPerProof do - let ioBuffer := Array.range numHashes |>.foldl - (init := default) - fun ioBuffer idx => - let data := Array.range dataSize |>.map - -- Add `idx` so every preimage is different and avoids memoization. - fun i => Aiur.G.ofUInt8 (i + idx).toUInt8 - ioBuffer.extend 0 #[.ofNat idx] data - throughput (.ElementsAndBytes numHashes.toUInt64 (dataSize * numHashes).toUInt64 "hashes") - bench s!"dataSize={dataSize} numHashes={numHashes}" - (aiurSystem.prove funIdx #[Aiur.G.ofNat numHashes]) ioBuffer - -def main : IO Unit := do - let _ ← sha256Bench - return diff --git a/Benchmarks/Typecheck.lean b/Benchmarks/Typecheck.lean deleted file mode 100644 index 319f9aea2..000000000 --- a/Benchmarks/Typecheck.lean +++ /dev/null @@ -1,1002 +0,0 @@ -import Cli -import Ix.IxVM -import Ix.IxVM.Toplevel -import Ix.IxVM.ClaimHarness -import Ix.Aiur.Protocol -import Ix.Aiur.Compiler -import Ix.Aiur.Statistics -import MultiStark -import Ix.Aggr -import Ix.TracingTexray -import Ix.Benchmark.Bench -import Ix.Benchmark.Results -import Ix.Cli.ConstsFile -import Ix.Cli.NameResolve - -/-! -# Aiur typecheck benchmark - -Out-of-circuit **execution** and in-circuit **proving** benchmark for the IxVM -kernel's `verify_claim` entrypoint, run over constants from a serialized -`Ixon.Env` (`.ixe`). Reading the env from a `.ixe` keeps this on Ix's critical -path (same load `ix check --ixe` uses) and avoids importing Lean modules at -runtime. Useful standalone (per-constant timeline + RAM breakdown via -tracing-texray) and as a machine source (benchmark results JSON). - -``` -lake exe bench-typecheck --ixe --consts [--consts-file

] [flags] - - --ixe serialized `Ixon.Env`, e.g. from `ix compile Foo.lean` - (writes `foo.ixe`). Required. - --consts comma-separated fully-qualified constant names to - benchmark (e.g. `Nat.add_comm,String.append`). Same - flag/shape as `ix check --consts`. - --consts-file additionally read names from a file: one per line, blank - lines and `#` comments ignored. Unions with --consts. - - Names (from any source) resolve against the env's named map via - `String.toName` plus a `toString` fallback (mirrors `ix check --ixe`), so - numeric / private components round-trip (`Foo.0.Bar`, `_private.M.0.foo`). - Pass at least one name via --consts or --consts-file. - - --skip-deps check only each target itself (verify_const, trusting its - deps) instead of its whole transitive closure (verify_claim, - the default). Reserved - for targets too expensive to full-closure-check. - --json write results JSON to (per constant, plus one pair row - with --join). Off by default: normal CLI usage prints only - the human-readable summary. - --texray enable the tracing-texray timeline + RAM breakdown. With - --json , per-phase span timings are also written to - .spans (JSON Lines) for the CI drill-down. Off by default. - --execute-only run only Phase 1 (constants / fft-cost / execute-time) and skip - proving — the fast `execute`-mode signal. - --recursive after each constant's prove, run the in-circuit multi-stark - verifier (`verify_multi_stark_proof`) over the fresh proof: - execute it (`fri-verifier-execute-time`, `fri-verifier-fft-cost` — the - recursion-cost proxy), then prove that execution end-to-end - (`fri-verifier-prove-time`, `fri-verifier-peak-rss`, - `fri-verifier-proof-size`, `fri-verifier-verify-time`), and close the - row with the pipeline ledger — `total-time` (each stage's - prove, summed; a prove already contains its own witness - execution, so the standalone execute times are NOT added, - and later pipeline stages will fold in as they land) and - `pipeline-peak-rss` (the maximum over - every phase window — the run's true RAM ceiling, which no - single windowed peak reports). The whole system, inner prove included, - switches to the recursion-tuned parameters - (`recursiveFriParameters`), so recursive rows are NOT - comparable to a plain prove run's. This is the mode CI's - `aiur` benchmark runs (`ix bench run --backend aiur`): the - full proof pipeline, per constant, over the shared - benchmark constants (Ix.BenchConstants). With --texray, both - proves stream the same `stark/...` span names, so the summed - `phase-stark-*` fields cover the pair. Conflicts with - --execute-only. - --join with --recursive and exactly two constants, benchmark the - converged ix_aggr direct flat pair (shape 2) over the two - singleton-CheckEnv IxVM proofs. Emits one `left + right` JSON row - carrying join-execute-time, join-fft-cost, join-prove-time, - join-peak-rss, join-proof-size, and join-verify-time. This is - an explicit W0/Section-13 diagnostic, not part of the default - per-constant CI run. -``` - -By default, the harness STARK-checks `Ix.Claim.check addr none` for each -constant (the full transitive typecheck). `--join` instead uses a singleton -`CheckEnv` shard claim for each of its two children. Work proceeds in up to -four phases: - -1. **Execute** (every constant): run the bytecode out-of-circuit. Cheap and - deterministic, so we always record `constants` (the number of constants the - kernel actually typechecked: `check_const`'s unique query count — NOT the - shipped byte scope, which also carries primitive bytes the kernel may - never touch), `fft-cost` (Σ width·height·log2(height) over circuits — the - proving-cost proxy), and `execute-time`. -2. **Prove** (cheap→expensive by measured fft-cost): the end-to-end STARK prove, - recording `prove-time`, the serialized `proof-size` (bytes), and - `verify-time` (verifying the fresh proof) — prover changes can trade speed - against proof size or verification cost, so all three are tracked. With - texray on, each prove emits a per-span timeline (`aiur/execute`, - `aiur/witness`, `stark/...`) with RAM Δ/peak to stderr. -3. **Recursive** (`--recursive` only, right after each constant's prove): feed - the fresh proof + vk + claims to `verify_multi_stark_proof`, execute it, - then prove the verifier execution — the end-to-end recursion cost. -4. **Join** (`--recursive --join`, exactly two constants): use each requested - constant as a one-owned-constant `CheckEnv` shard, then execute/prove/verify - the converged `ix_aggr` direct flat pair (shape 2) over those IxVM proofs. - The pair gets a dedicated JSON row because the join is one shared operation, - not a cost attributable to either child independently. - -When `--json` is set the file is rewritten after every prove, so an external -`timeout` still leaves a complete file of the results collected so far (cheapest -first). A name absent from the env or whose execution errors is skipped with a -warning, so a single bad name never fails the run. The harness imposes no time -limit; bound a run with an external `timeout` if needed. - -The JSON is a flat shape. An `--execute-only` row carries the plain -Phase-1 fields (`{ "": { "constants": …, "fft-cost": …, -"execute-time": …, "throughput": …, "peak-rss": … } }`); a `--recursive` -pipeline row stage-qualifies every stage measure (`"ixvm-execute-time"`, -`"ixvm-fft-cost"`, `"ixvm-prove-time"`, `"ixvm-throughput"`, -`"ixvm-peak-rss"`, `"ixvm-proof-size"`, `"ixvm-verify-time"`, the -same seven as `"fri-verifier-…"`, and further stage prefixes when the -KZG stages land), plus the pipeline ledger `"total-time"`, `"pipeline-throughput"`, -`"pipeline-peak-rss"` once the pipeline completes. Each stage's peak-rss -and throughput are scoped to that stage's own prove window. Any -bencher-specific reshaping is the caller's job (see -`.github/workflows/bench-main.yml`). - -With `--join`, the same object also contains one `"left + right"` row. It has -`status`, the sum of the two child `constants`, and the six `join-*` measures; -it intentionally has no per-child or pipeline ledger fields. --/ - -open Lean (Json Name) - -def commitmentParameters : Aiur.CommitmentParameters := { - logBlowup := 2 - capHeight := 0 -} - -def friParameters : Aiur.FriParameters := { - logFinalPolyLen := 0 - maxLogArity := 1 - numQueries := 100 - commitProofOfWorkBits := 0 - queryProofOfWorkBits := 0 -} - -/-- Recursion-tuned commitment parameters for `--recursive`. -/ -def recursiveCommitmentParameters : Aiur.CommitmentParameters := { - logBlowup := 2 - capHeight := 0 -} - -/-- Recursion FRI parameters for `--recursive` — the CI `aiur` pipeline - benchmark's parameters, applied to the stage-1 and stage-2 proofs - alike. The query count IS the soundness level, so a real (secure) - recursive proof needs a full query count, not a toy handful — but the - in-circuit verifier's work (and the outer prove's footprint) scales - with it, and at the heavy end of the selection the outer prove runs - close enough to the CI host's RAM ceiling that a constant can cross - it. That is the intended trade: prefer the soundness and let a - constant that does not fit land as an OOM row, documenting the gap - between secure recursion and what fits today. - `--recursive` runs the WHOLE system, inner prove included, under - these, so its rows are not comparable to a plain `prove` run's. -/ -def recursiveFriParameters : Aiur.FriParameters := { - logFinalPolyLen := 0 - maxLogArity := 1 - numQueries := 50 - commitProofOfWorkBits := 0 - queryProofOfWorkBits := 0 -} - - - -/-- Per-constant measurements. `proveSec` is `none` when the constant was - executed but not (yet) proven. -/ -structure Result where - name : String - constants : Nat - fftCost : Float - executeSec : Float - /-- The kernel REJECTED the constant (Phase-1 check error). The JSON entry - is `{"status": "rejected"}` (see `Ix.Benchmark.Results`) — a rejected - constant is a correctness signal, not a benchmark datum — Phase 2 - skips it, and the run exits with the reserved rejection code. -/ - failed : Bool := false - proveSec : Option Float := none - /-- Serialized proof size in bytes (`Aiur.Proof.toBytes`). Tracked because - prover changes can trade speed against proof size. -/ - proofSize : Option Nat := none - /-- Wall time of `AiurSystem.verify` over the fresh proof — the other side - of the same trade-off. `none` if verification failed (reported loudly). -/ - verifySec : Option Float := none - /-- The trace shards the fresh proof holds: one unless the prove was - budgeted (`--trace-shards`) and the record did not fit one shard. -/ - traceShards : Option Nat := none - /-- The constant's prove-phase RSS high-water in bytes (tracing-texray - tree sampler; the window resets per prove). -/ - peakRss : Option Nat := none - /-- The constant's own Phase-1 (execute) RSS high-water mark — the sampler - window resets per constant. Emitted as `peak-rss` in execute-only - mode; a prove row's `peak-rss` is the prover's window instead (the - prover would dwarf an execute peak, so the modes never share a row — - or a testbed). -/ - executePeakRss : Option Nat := none - /-- Wall time of executing the in-circuit multi-stark verifier over this - constant's fresh proof (`--recursive` only). -/ - recursiveExecuteSec : Option Float := none - /-- That execution's own in-circuit FFT cost — the deterministic proxy for - what proving the verifier costs. Drifts ~±15% run-to-run: the parallel - prover emits byte-different valid proofs, so the verifier authenticates - different Merkle paths (pin with `RAYON_NUM_THREADS=1`). -/ - recursiveFftCost : Option Float := none - /-- Wall time of PROVING the verifier execution — the end-to-end recursion - cost. -/ - recursiveProveSec : Option Float := none - /-- The outer (recursion) prove's RSS high-water (windowed like `peakRss`; - the outer prove dwarfs the verifier execution, so one field serves). -/ - recursivePeakRss : Option Nat := none - /-- Serialized outer proof size in bytes. -/ - recursiveProofSize : Option Nat := none - /-- Wall time of `AiurSystem.verify` over the outer proof; `none` if that - verification failed (reported loudly). -/ - recursiveVerifySec : Option Float := none - deriving Inhabited - -/-- The successfully verified IxVM artifact retained for the optional binary - join phase. `innerClaimsBytes` is the serialized singleton list containing - the IxVM proof's Aiur claim; `checkEnvClaimBytes` is the nested Ix claim - preimage that the converged join opens below it. -/ -structure JoinArtifact where - label : String - constants : Nat - statement : Aggr.CheckEnvTrees - innerClaimsBytes : ByteArray - checkEnvClaimBytes : ByteArray - outerClaim : Array Aiur.G - proof : Aiur.Proof - -/-- Measurements for the one pair-wide `ix_aggr` shape-2 operation. Kept separate - from `Result`: copying these fields onto both child rows would count the - same join twice, while attaching them to one child would make the result - order-dependent. -/ -structure JoinResult where - name : String - constants : Nat - fftCost : Float - executeSec : Float - proveSec : Float - peakRss : Nat - proofSize : Nat - verifySec : Option Float - failed : Bool := false - -/-- A `Json` number with at most `d` decimal places, rendered decimally. - `Float`'s own `ToJson` prints the full binary representation - (`0.02602000000000000146…`), so build the `JsonNumber` (mantissa · - 10⁻ᵈ) directly from the rounded value instead. -/ -def jsonRound (d : Nat) (f : Float) : Json := - let scale := (10.0 : Float) ^ d.toFloat - let scaled := f * scale - let m : Int := - if scaled < 0 then -Int.ofNat (-scaled).round.toUInt64.toNat - else Int.ofNat scaled.round.toUInt64.toNat - Json.num ⟨m, d⟩ - -def JoinResult.toJsonEntry (r : JoinResult) : String × Json := - if r.failed then - (r.name, Json.mkObj [("status", Json.str "rejected")]) - else - let fields : List (String × Json) := - [ ("status", Json.str "ok") - , ("constants", Lean.toJson r.constants) - , ("join-fft-cost", jsonRound 0 r.fftCost) - , ("join-execute-time", jsonRound 6 r.executeSec) - , ("join-prove-time", jsonRound 6 r.proveSec) - , ("join-peak-rss", Lean.toJson r.peakRss) - , ("join-proof-size", Lean.toJson r.proofSize) ] - let fields := match r.verifySec with - | some seconds => fields ++ [("join-verify-time", jsonRound 6 seconds)] - | none => fields - (r.name, Json.mkObj fields) - -/-- Flat results object: `name → { constants, … }`. No bencher-specific - shaping. - - Measure names are MODE-SCOPED: an execute-only run's row carries the - plain Phase-1 fields (`fft-cost`, `execute-time`, `throughput`, - `peak-rss`); a pipeline run stage-qualifies every stage measure - (`ixvm-…`, `fri-verifier-…`), each stage's peak and constants/sec scoped - to its own prove window. The two modes store on separate bencher - testbeds (aiur-execute-* / aiur-*). -/ -def Result.toJsonEntry (executeOnly : Bool) (r : Result) : String × Json := - if r.failed then - (r.name, Json.mkObj [("status", Json.str "rejected")]) else - let base : List (String × Json) := - [ ("status", Json.str "ok") - , ("constants", Lean.toJson r.constants) ] - if executeOnly then - let fields := base ++ - [ ("fft-cost", jsonRound 0 r.fftCost) - , ("execute-time", jsonRound 6 r.executeSec) ] - let fields := if r.executeSec > 0 then - fields ++ [ ("throughput", jsonRound 2 (r.constants.toFloat / r.executeSec)) ] - else fields - let fields := match r.executePeakRss with - | some n => fields ++ [ ("peak-rss", Lean.toJson n) ] - | none => fields - (r.name, Json.mkObj fields) - else - let fields := base ++ - [ ("ixvm-fft-cost", jsonRound 0 r.fftCost) - , ("ixvm-execute-time", jsonRound 6 r.executeSec) ] - -- ixvm-prove-time, the proving throughput, and the prove-phase - -- peak are present only once proven. - let fields := match r.proveSec with - | some p => fields ++ [ ("ixvm-prove-time", jsonRound 6 p) - , ("ixvm-throughput", - jsonRound 2 (r.constants.toFloat / p)) ] - | none => fields - let fields := match r.peakRss with - | some n => fields ++ [ ("ixvm-peak-rss", Lean.toJson n) ] - | none => fields - let fields := match r.proofSize with - | some n => fields ++ [ ("ixvm-proof-size", Lean.toJson n) ] - | none => fields - let fields := match r.verifySec with - | some v => fields ++ [ ("ixvm-verify-time", jsonRound 6 v) ] - | none => fields - let fields := match r.traceShards with - | some n => fields ++ [ ("ixvm-trace-shards", Lean.toJson n) ] - | none => fields - -- The stage-2 metrics, in measurement order; the execute-side pair - -- lands before the outer prove runs, so an OOM'd outer prove still - -- leaves them on disk. - let fields := match r.recursiveExecuteSec, r.recursiveFftCost with - | some s, some c => fields ++ [ ("fri-verifier-execute-time", jsonRound 6 s) - , ("fri-verifier-fft-cost", jsonRound 0 c) ] - | _, _ => fields - let fields := match r.recursiveProveSec with - | some s => fields ++ [ ("fri-verifier-prove-time", jsonRound 6 s) - , ("fri-verifier-throughput", - jsonRound 2 (r.constants.toFloat / s)) ] - | none => fields - let fields := match r.recursivePeakRss with - | some n => fields ++ [ ("fri-verifier-peak-rss", Lean.toJson n) ] - | none => fields - let fields := match r.recursiveProofSize with - | some n => fields ++ [ ("fri-verifier-proof-size", Lean.toJson n) ] - | none => fields - let fields := match r.recursiveVerifySec with - | some v => fields ++ [ ("fri-verifier-verify-time", jsonRound 6 v) ] - | none => fields - -- The pipeline ledger, once the whole pipeline has run. - -- `total-time` is each stage's prove, summed. A stage's prove is - -- the WHOLE cost of producing that stage's proof: `prove_ixvm` runs - -- the executor itself (the `aiur/execute_ixvm` span) before - -- generating the witness, so the `ixvm-execute-time` beside it is - -- a SECOND, standalone run — instrumentation for `constants` and - -- `ixvm-fft-cost`, not a step of proving. Adding the two would - -- count the execution twice. Verification is likewise excluded: a - -- consumer cost, not a production one. - -- `pipeline-throughput` is `constants` over `total-time` — the - -- end-to-end checking rate, per-stage throughputs being scoped to - -- their own prove. - -- `pipeline-peak-rss` is the whole run's RAM high-water: the - -- per-phase windows reset, so no single `peak-rss` answers "how much - -- RAM does this pipeline need" — their maximum does. Emitted - -- only with every component present, so it doubles as the row's - -- completion marker (the orchestrator's teardown-kill `doneKey`). - let fields := match r.proveSec, r.recursiveExecuteSec, r.recursiveProveSec with - | some p, some _, some rp => - let peaks := [r.executePeakRss, r.peakRss, r.recursivePeakRss].reduceOption - fields ++ [ ("total-time", jsonRound 6 (p + rp)) - , ("pipeline-throughput", - jsonRound 2 (r.constants.toFloat / (p + rp))) ] - ++ (match peaks.max? with - | some n => [("pipeline-peak-rss", Lean.toJson n)] - | none => []) - | _, _, _ => fields - (r.name, Json.mkObj fields) - -/-- Time a thunk, returning its value and the elapsed seconds. The result is - forced by `blackBoxIO` so a pure computation isn't optimized away. -/ -def timed (f : Unit → α) : IO (α × Float) := do - let t0 ← IO.monoNanosNow - let a ← blackBoxIO f () - let t1 ← IO.monoNanosNow - return (a, (t1 - t0).toFloat / 1e9) - -def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do - let some ixeArg := p.flag? "ixe" - | IO.eprintln "error: --ixe is required"; return 1 - let ixePath := ixeArg.as! String - -- `--consts` comma-list ∪ `--consts-file`, shared grammar + dedup - -- (Ix.Cli.ConstsFile — same parser as `ix check-lean`). Raw strings: - -- resolution against the env happens later (so the `toString` fallback can - -- see the displayed form the user wrote). - let nameArgs ← Ix.Cli.ConstsFile.gather p - if nameArgs.isEmpty then - IO.eprintln "error: provide at least one constant via --consts and/or --consts-file " - return 1 - let jsonOut : Option String := (p.flag? "json").map (·.as! String) - let queryCount? := (p.flag? "queries").map (·.as! Nat) - if queryCount? == some 0 then - IO.eprintln "error: --queries must be positive" - return Ix.Benchmark.Results.exitUsage - -- skip-deps: check just the target (`verify_const`, trusting its deps) - -- instead of re-checking the whole transitive closure (`verify_claim`). - let skipDeps := p.hasFlag "skip-deps" - -- Execute-only: run just Phase 1 (constants / fft-cost / execute-time) and - -- skip the Phase 2 prove loop. - let executeOnly := p.hasFlag "execute-only" - -- Recursive: after each constant's prove, execute AND prove the in-circuit - -- multi-stark verifier over the fresh proof (Phase 3). - let recursive := p.hasFlag "recursive" - -- Join: retain two verified IxVM proofs, then benchmark one production - -- direct flat join over their singleton-CheckEnv statements. - let join := p.hasFlag "join" - if recursive && executeOnly then - IO.eprintln "error: --recursive measures the prove path; drop --execute-only" - return Ix.Benchmark.Results.exitUsage - if join && !recursive then - IO.eprintln "error: --join requires --recursive" - return Ix.Benchmark.Results.exitUsage - if join && skipDeps then - IO.eprintln "error: --join requires singleton CheckEnv shards; drop --skip-deps" - return Ix.Benchmark.Results.exitUsage - -- Off by default; CI passes --texray explicitly. - let useTexray ← TracingTexray.enabled (p.hasFlag "texray") - let useInterp := p.hasFlag "interp" - if join && useInterp then - IO.eprintln "error: --join requires the native singleton-shard prover; drop --interp" - return Ix.Benchmark.Results.exitUsage - -- Trace shards: each constant's singleton CheckEnv shard proven as a - -- batch of trace shards within a RAM budget, the `ix prove --trace-shards - -- --max-ram` path. `BENCH_TRACE_SHARDS=` is the `!benchmark` - -- spelling; a binary without the flag ignores the variable, so a base - -- checkout that predates it keeps proving whole. - let traceShardsEnv ← IO.getEnv "BENCH_TRACE_SHARDS" - let traceShards := p.hasFlag "trace-shards" || traceShardsEnv.isSome - let maxRamGib := match (p.flag? "max-ram").map (·.as! Nat) with - | some gib => gib - | none => (traceShardsEnv.bind String.toNat?).getD 0 - let maxRamBytes := maxRamGib * 1024 * 1024 * 1024 - if traceShards && (skipDeps || useInterp || executeOnly) then - IO.eprintln "error: --trace-shards proves singleton CheckEnv shards natively; \ - drop --skip-deps, --interp and --execute-only" - return Ix.Benchmark.Results.exitUsage - -- Start the process-tree RSS sampler so each Result's peak-rss reflects the - -- true high-water mark. With --texray, install the streaming subscriber up - -- front: every phase span — aiur/execute_ixvm in Phase 1 included — - -- renders its duration and RAM Δ/peak through the one shared channel - -- instead of per-benchmark arithmetic. With --json too, the per-span sink - -- also lands the timings at `.spans` as JSON Lines for the CI - -- comparison. - TracingTexray.startSampler - if useTexray then TracingTexray.init {} - match useTexray, jsonOut with - | true, some path => TracingTexray.jsonSink s!"{path}.spans" - | _, _ => pure () - - -- Compile the IxVM kernel once; build the prover system once. - -- `--skip-deps` proves the subject-only `verify_const`, a debug - -- entrypoint absent from the production toplevel, so it needs the full - -- one — and is thereby measuring a DIFFERENT verifying key than a - -- claim run, which is the honest reading of those numbers. - let .ok toplevel := (if skipDeps then IxVM.ixVMFull else IxVM.ixVM) - | throw (IO.userError "Merging IxVM kernel failed") - let .ok compiled := toplevel.compileWithGroups IxVM.functionGroups - | throw (IO.userError "Compilation of IxVM kernel failed") - let entrypoint := if skipDeps then `verify_const else `verify_claim - let some funIdx := compiled.getFuncIdx entrypoint - | throw (IO.userError s!"{entrypoint} entrypoint missing") - -- `check_const`'s unique query count is the `constants` metric below; - -- resolve it up front so a kernel rename fails the run, not the metric. - let some checkConstIdx := compiled.getFuncIdx `check_const - | throw (IO.userError "check_const missing from compiled kernel") - -- Recursive mode runs the WHOLE system — the inner prove included — under - -- the recursion-tuned parameters, so the verifier's query loop stays - -- tractable (cost scales with numQueries). - let (commitParams, friParams) := - if recursive then (recursiveCommitmentParameters, recursiveFriParameters) - else (commitmentParameters, friParameters) - -- `--queries N` overrides the selected parameter set's FRI query count - -- (inner and outer proof alike in --recursive mode, which builds both - -- systems from `friParams`). - let friParams := match queryCount? with - | some n => { friParams with numQueries := n } - | none => friParams - let aiurSystem := Aiur.AiurSystem.build compiled.bytecode commitParams friParams - -- The recursive-verifier context, compiled and built ONCE: the verifier - -- toplevel is constant-independent, and its prover system (same recursion - -- parameters) is reused for every constant's outer prove. - let vCtx : Option (Aiur.CompiledToplevel × Aiur.Bytecode.FunIdx × Aiur.AiurSystem) ← - if !recursive then pure none else do - let .ok vTop := MultiStark.multiStark - | throw (IO.userError "Merging multi-stark verifier failed") - let .ok vCompiled := vTop.compileWithGroups MultiStark.verifierFunctionGroups - | throw (IO.userError "Compilation of multi-stark verifier failed") - let some vIdx := vCompiled.getFuncIdx `verify_multi_stark_proof - | throw (IO.userError "verify_multi_stark_proof entrypoint missing") - pure (some (vCompiled, vIdx, - Aiur.AiurSystem.build vCompiled.bytecode commitParams friParams)) - -- The opt-in pair metric uses the converged production aggregator while the - -- generic recursive phase above remains the standalone Multi-STARK verifier - -- benchmark. Compile the second system only when `--join` requests it. - let aggrCtx : Option - (Aiur.CompiledToplevel × Aiur.Bytecode.FunIdx × Aiur.AiurSystem) ← - if !join then pure none else do - let .ok aggrTop := Aggr.ixAggr - | throw (IO.userError "Merging ix_aggr failed") - let .ok aggrCompiled := aggrTop.compileWithGroups Aggr.functionGroups - | throw (IO.userError "Compilation of ix_aggr failed") - let some aggrIdx := aggrCompiled.getFuncIdx `ix_aggr - | throw (IO.userError "ix_aggr entrypoint missing") - pure (some (aggrCompiled, aggrIdx, - Aiur.AiurSystem.build aggrCompiled.bytecode commitParams friParams)) - - -- Load the serialized env lazily (the `ix check --ixe` path, #445): byte-window - -- constants over the backing buffer, so only the checked closure is ever - -- materialized — no whole-env (100+GB on mathlib) load just to check a few. - let ixonEnv ← match Ixon.deEnvAnon (← IO.FS.readBinFile ixePath) with - | .error e => IO.eprintln s!"deserialize {ixePath} failed: {e}"; return 1 - | .ok env => pure env - IO.println s!"Loaded {ixePath}: {ixonEnv.namedCount} named, {ixonEnv.constCount} consts" - let mut targets : Array (String × Address) := #[] - for arg in nameArgs do - match Ix.Cli.NameResolve.resolveIxeAddr ixonEnv arg with - | some addr => targets := targets.push (arg, addr) - | none => IO.eprintln s!"warning: {arg} not found in {ixePath}; skipping" - if targets.isEmpty then - IO.eprintln "no requested constants were found in the env" - return 1 - if join && targets.size != 2 then - IO.eprintln s!"error: --join requires exactly two resolved constants; got {targets.size}" - return Ix.Benchmark.Results.exitUsage - - -- Build the env once into a Rust-owned `EnvHandle` and share it - -- across both Phase 1 and Phase 2 loops. Per-target FFI calls - -- reuse the parsed env — no per-call mmap / lazy-index rebuild. - let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with - | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1 - | .ok h => pure h - - let singletonOwnedBlob (addr : Address) : ByteArray := addr.hash - - -- Phase 1: execute every constant (cheap, deterministic structural metrics). - -- For full-closure check claims, use `checkAddrWithEnv` against the - -- shared `envHandle`. For `--skip-deps` (`buildVerifyConst`), the - -- witness is a small subject-only blob — keep Lean witness + - -- `executeIxVM`. - IO.println "── Phase 1: execute (witness generation) ──" - -- Shapes off the already-built system (cheap: reads the compiled - -- circuits), hoisted out of the per-constant loop. - let shapes := aiurSystem.circuitShapes - let mut execed : Array (Result × Address) := #[] - let mut execIdx := 0 - for (label, addr) in targets do - execIdx := execIdx + 1 - try - -- Announce BEFORE the execute (flushed): a kill mid-execute must - -- leave the in-flight constant's name in the log. - IO.println s!" [{execIdx}/{targets.size}] executing {label} …" - (← IO.getStdout).flush - -- Windowed high-water: reset per constant so each row's - -- execute peak is its own, not the loop's running maximum. - TracingTexray.resetPeakTreeRss - let (res, execSec) ← timed fun _ => - if skipDeps then - (IxVM.ClaimHarness.buildVerifyConst ixonEnv addr).bind fun witness => - if useInterp then - compiled.bytecode.execute funIdx witness.input witness.inputIOBuffer - else - compiled.bytecode.executeIxVM funIdx witness.input witness.inputIOBuffer - else if join then - compiled.bytecode.shardCheckWithEnv funIdx envHandle - (singletonOwnedBlob addr) useInterp (assumeBinding := true) - else - compiled.bytecode.checkAddrWithEnv funIdx envHandle addr.hash useInterp - (assumeBinding := true) - let execPeak ← TracingTexray.peakTreeRssBytes - match res with - | .error e => - IO.eprintln s!" ❌ {label} FAILED TO TYPECHECK: {e}" - execed := execed.push - ({ name := label, constants := 0, fftCost := 0, executeSec := 0, - failed := true }, addr) - | .ok (_, _, queryCounts) => - let stats := Aiur.computeStats compiled queryCounts shapes - (logBlowup := commitParams.logBlowup) - -- Constants CHECKED, not shipped: `check_const` is memoized per - -- (ci, addr), so its unique query count is exactly the number of - -- constants the kernel typechecked. The shipped byte scope - -- (`closureFrom`) is a superset (primitive bytes seeded for - -- reduction), so counting it would inflate throughput. - let some qc := queryCounts[checkConstIdx]? - | throw (IO.userError s!"queryCounts has no entry for check_const \ - (idx {checkConstIdx}, {queryCounts.size} entries)") - let constants := qc.uniqueRows - -- Throughput via the shared benchmark framework; duration/RAM per - -- phase stream from texray's `aiur/execute_ixvm` span line. - let thrpt := (Throughput.Elements constants.toUInt64 "consts").formatRate - (execSec * 1e9) - IO.println s!" {label}: constants={constants} fft-cost={stats.totalFftCost} \ - execute={execSec}s thrpt={thrpt}" - execed := execed.push - ({ name := label, constants, fftCost := stats.totalFftCost, - executeSec := execSec, executePeakRss := some execPeak }, addr) - catch e => - -- Record the failure rather than dropping the constant. A silent - -- drop left `execed.any (·.failed)` clear, so a thrown constant — - -- including the `check_const`-missing throw above — yielded an - -- exit-0 run with one fewer row and no other trace. - IO.eprintln s!" execute {label} threw: {e}" - execed := execed.push - ({ name := label, constants := 0, fftCost := 0, executeSec := 0, - failed := true }, addr) - - -- Persist rows when `--json` was given, MERGING into the file (the shared - -- results-row contract): rows land after each result, so a kill leaves the - -- completed ones, and per-constant processes can share one file with the - -- orchestrator and each other. - let writeJson (results : Array Result) : IO Unit := - match jsonOut with - | some path => - results.forM fun r => - let (name, row) := Result.toJsonEntry executeOnly r - Ix.Benchmark.Results.writeEntry path name row - | none => pure () - let writeJoinJson (result : JoinResult) : IO Unit := - match jsonOut with - | some path => - let (name, row) := result.toJsonEntry - Ix.Benchmark.Results.writeEntry path name row - | none => pure () - let writeRejectedJoin (name : String) : IO Unit := - match jsonOut with - | some path => Ix.Benchmark.Results.writeEntry path name <| - Json.mkObj [("status", Json.str "rejected")] - | none => pure () - - -- `--execute-only`: stop after Phase 1; the results JSON (if requested) is - -- already complete with the execute metrics. - if executeOnly then - writeJson (execed.map (·.1)) - match jsonOut with - | some path => IO.println s!"wrote {execed.size} execute-only benchmarks to {path}" - | none => IO.println s!"executed {execed.size} constants (--execute-only); pass --json to emit results" - return if execed.any (·.1.failed) then Ix.Benchmark.Results.exitRejected else 0 - - -- Phase 2: prove cheap→expensive. Refine each entry with its prove-time as - -- it lands (texray was installed before Phase 1, so the prove spans render - -- the same way the execute ones did). - IO.println "── Phase 2: prove ──" - let mut ordered := execed.qsort (·.1.fftCost < ·.1.fftCost) - writeJson (ordered.map (·.1)) - let mut spent : Float := 0.0 - let mut joinArtifacts : Array JoinArtifact := #[] - for i in [:ordered.size] do - let (r, addr) := ordered[i]! - if r.failed then continue - try - -- Announce BEFORE the prove (flushed): when a watchdog kill or OOM - -- lands mid-prove, the log must already say which constant died. - IO.println s!" [{i + 1}/{ordered.size}] proving {r.name} (fft-cost={r.fftCost}) …" - (← IO.getStdout).flush - -- Windowed high-water: each prove's peak is its own window, not - -- the run's cumulative maximum (mirrors the Phase-1 resets). - TracingTexray.resetPeakTreeRss - let (proveRes, proveSec) ← timed fun _ => - if skipDeps then - (IxVM.ClaimHarness.buildVerifyConst ixonEnv addr).bind fun witness => - let proveRes := - if useInterp then - aiurSystem.prove funIdx witness.input witness.inputIOBuffer - else - aiurSystem.proveIxVM funIdx witness.input witness.inputIOBuffer - proveRes.map fun (claim, proof, ioBuf) => - (claim, proof, ioBuf, (none : Option ByteArray)) - else if join || traceShards then - match aiurSystem.shardProveWithEnv funIdx envHandle - (singletonOwnedBlob addr) maxRamBytes false traceShards - (assumeBinding := true) with - | .error e => .error e - | .ok result => match result.proof with - | none => - if traceShards then - .error s!"no trace-shard count fits the budget \ - (whole-execution peak {result.peakBytes} bytes)" - else - .error s!"projected prover peak {result.peakBytes} bytes exceeds \ - the budget; suggested {result.suggestedParts} parts" - | some proof => - let digest := Address.blake3 result.claimBytes - let claim := - Aiur.buildClaim funIdx (IxVM.ClaimHarness.packedDigestKey digest) #[] - -- Shard proving no longer returns its whole ingested IO scope; - -- this benchmark never reads it after the proof is produced. - .ok (claim, proof, default, some result.claimBytes) - else - match aiurSystem.proveAddrWithEnv funIdx envHandle addr.hash useInterp - (assumeBinding := true) with - | .error e => .error e - | .ok (claimBytes, proof, ioBuf) => - -- The envHandle path returns the SERIALIZED `Ix.Claim`; rebuild - -- the Array-G claim `verify` takes — `verify_claim`'s input is - -- the 32-G blake3 digest of those bytes (same recipe as - -- `ix verify`). - let digest := Address.blake3 claimBytes - let claim := - Aiur.buildClaim funIdx (IxVM.ClaimHarness.packedDigestKey digest) #[] - .ok (claim, proof, ioBuf, none) - match (proveRes : Except String - (Array Aiur.G × Aiur.Proof × Aiur.IOBuffer × Option ByteArray)) with - | .error e => IO.eprintln s!" prove {r.name} failed: {e}"; continue - | .ok (claim, proof, _ioBuf, checkEnvClaimBytes?) => - spent := spent + proveSec - let peak ← TracingTexray.peakTreeRssBytes - let proofBytes := Aiur.Proof.toBytes proof - let (verifyRes, verifySec) ← timed fun _ => - aiurSystem.verify claim proof - -- A proof that does not verify is a correctness alarm, not a slow - -- row: mark the entry FAILED so `status` says so and the run - -- exits non-zero. Leaving `failed` clear emitted `"status":"ok"` - -- with prove-time and proof-size present, the only signal being - -- an absent `verify-time` key — invisible to anything keying on - -- status. - let mut r := r - let verifySec? ← match verifyRes with - | .ok () => pure (some verifySec) - | .error e => - IO.eprintln s!" verify {r.name} FAILED: {e}" - r := { r with failed := true } - pure none - let shards := Aiur.Proof.shardCount proof - IO.println s!" {r.name}: prove={proveSec}s verify={verifySec}s \ - proof={proofBytes.size} bytes, {shards} trace shard(s) (cumulative {spent}s)" - ordered := ordered.set! i - ({ r with proveSec := some proveSec, peakRss := some peak - , proofSize := some proofBytes.size, verifySec := verifySec? - , traceShards := some shards }, addr) - writeJson (ordered.map (·.1)) - -- Phase 3 (--recursive): the in-circuit verifier over the fresh - -- proof — execute it (fri-verifier-execute-time / fri-verifier-fft-cost), then prove - -- that execution (fri-verifier-prove-time / fri-verifier-peak-rss / - -- fri-verifier-proof-size / fri-verifier-verify-time). A reject on the execute - -- is a correctness alarm, reported loudly with the recursive fields - -- left absent — never a benchmark datum. - if let some (vCompiled, vIdx, vSystem) := vCtx then - IO.println s!" [{i + 1}/{ordered.size}] recursively verifying {r.name} …" - (← IO.getStdout).flush - let innerClaimsBytes := MultiStark.serializeClaims #[claim] - let vkBytes := aiurSystem.vkBytes - let pubInput := MultiStark.verifierPubInput vkBytes innerClaimsBytes - -- Verify and serialize the proof transport consumed in-circuit. - -- `proofBytes` remains the raw proof used for reported proof size. - let adviceBytes ← match aiurSystem.proofToAdviceBytes claim proof with - | .ok bytes => pure bytes - | .error e => - IO.eprintln s!" ❌ advice re-encoding for {r.name} FAILED: {e}" - continue - -- Native path: the advice buffer is built in Rust from the raw - -- byte blobs and execution routes through the codegen'd verifier. - let (rvRes, rvSec) ← timed fun _ => - vCompiled.bytecode.executeMultiStark vIdx pubInput adviceBytes - vkBytes innerClaimsBytes useInterp - match rvRes with - | .error e => - IO.eprintln s!" ❌ recursive verifier REJECTED {r.name}'s proof: {e}" - | .ok (_, qc) => - let rvStats := Aiur.computeStats vCompiled qc vSystem.circuitShapes - (logBlowup := commitParams.logBlowup) - IO.println s!" {r.name}: recursive={rvSec}s \ - fri-verifier-fft-cost={rvStats.totalFftCost}" - -- The per-circuit breakdown names where the verifier's cost - -- lives (deserialization vs blake3 vs FRI); texray-gated like - -- the other detailed diagnostics. - if useTexray then Aiur.printStats rvStats - let (row, _) := ordered[i]! - ordered := ordered.set! i - ({ row with recursiveExecuteSec := some rvSec - , recursiveFftCost := some rvStats.totalFftCost }, addr) - -- Flush the execute-side pair before the outer prove: an OOM - -- there keeps them, and the announce (flushed) names the - -- constant that died. - writeJson (ordered.map (·.1)) - IO.println s!" [{i + 1}/{ordered.size}] proving the verifier over {r.name} …" - (← IO.getStdout).flush - TracingTexray.resetPeakTreeRss - let (rvProveRes, rvProveSec) ← timed fun _ => - vSystem.proveMultiStark vIdx pubInput adviceBytes vkBytes - innerClaimsBytes useInterp - let (rvClaim, rvProof) ← match rvProveRes with - | .ok result => pure result - | .error e => - IO.eprintln s!" outer prove {r.name} failed: {e}" - continue - let rvPeak ← TracingTexray.peakTreeRssBytes - let rvProofBytes := Aiur.Proof.toBytes rvProof - let (rvVerifyRes, rvVerifySec) ← timed fun _ => - vSystem.verify rvClaim rvProof - let rvVerifySec? ← match rvVerifyRes with - | .ok () => pure (some rvVerifySec) - | .error e => - IO.eprintln s!" outer verify {r.name} FAILED: {e}" - pure none - IO.println s!" {r.name}: fri-verifier-prove={rvProveSec}s \ - fri-verifier-verify={rvVerifySec}s outer proof={rvProofBytes.size} bytes" - let (row, _) := ordered[i]! - ordered := ordered.set! i - ({ row with recursiveProveSec := some rvProveSec - , recursivePeakRss := some rvPeak - , recursiveProofSize := some rvProofBytes.size - , recursiveVerifySec := rvVerifySec? }, addr) - writeJson (ordered.map (·.1)) - if join && !r.failed then - match rvVerifyRes, checkEnvClaimBytes? with - | .ok (), some checkEnvClaimBytes => - let (expectedClaim, trees) ← IO.ofExcept <| - IxVM.ClaimHarness.shardCheckEnvClaimTrees ixonEnv #[addr] - (assumeBinding := true) - if Ix.Claim.ser expectedClaim != checkEnvClaimBytes then - throw <| IO.userError s!"join benchmark: native shard claim for \ - {r.name} differs from host reconstruction" - let statement ← IO.ofExcept <| - Aggr.CheckEnvTrees.ofClaim expectedClaim trees - joinArtifacts := joinArtifacts.push { - label := r.name - constants := r.constants - statement - innerClaimsBytes - checkEnvClaimBytes - outerClaim := claim - proof := proof - } - | .error _, _ => pure () - | .ok (), none => - throw <| IO.userError s!"join benchmark: missing CheckEnv claim \ - preimage for {r.name}" - catch e => - IO.eprintln s!" prove {r.name} threw: {e}" - - -- Phase 4 (--recursive --join): one pair-wide converged direct join. The two - -- child rows retain their ordinary IxVM/recursive-verifier measurements; - -- the shared ix_aggr shape-2 proof lands under its own stable `left + right` - -- row so it is neither duplicated nor assigned arbitrarily to one child. - let mut joinRejected := false - if join then - IO.println "── Phase 4: ix_aggr direct flat pair (shape 2) ──" - let leftLabel := targets[0]!.1 - let rightLabel := targets[1]!.1 - let pairName := s!"{leftLabel} + {rightLabel}" - let some left := joinArtifacts.find? fun artifact => artifact.label == leftLabel | do - IO.eprintln s!"join benchmark: no verified IxVM proof for {leftLabel}" - return 1 - let some right := joinArtifacts.find? fun artifact => artifact.label == rightLabel | do - IO.eprintln s!"join benchmark: no verified IxVM proof for {rightLabel}" - return 1 - let some (aggrCompiled, aggrIdx, aggrSystem) := aggrCtx | do - IO.eprintln "join benchmark: ix_aggr context was not built" - return 1 - let ixvmVk := aiurSystem.vkBytes - let aggrVk := aggrSystem.vkBytes - let allowed := Aggr.allowedBlob ixvmVk funIdx aggrVk aggrIdx - let leftStatement : Aggr.CheckEnvTrees := { - ctx := left.statement.ctx - subjects := left.statement.subjects - assumptions := left.statement.assumptions - } - let rightStatement : Aggr.CheckEnvTrees := { - ctx := right.statement.ctx - subjects := right.statement.subjects - assumptions := right.statement.assumptions - } - let outputStatement := leftStatement.join rightStatement - let outputClaimBytes := Ix.Claim.ser outputStatement.claim - let pubInput := Aggr.pubInput allowed outputClaimBytes - let preimagesBlob := Aggr.preimagesBlob - #[left.checkEnvClaimBytes, right.checkEnvClaimBytes] - let treesBlob := Aggr.treesBlob <| - Aggr.CheckEnvTrees.adviceTrees leftStatement rightStatement outputStatement - let pathsBlob := Aggr.pathsBlob #[] - let leftProofAdvice ← match aiurSystem.proofToAdviceBytes - left.outerClaim left.proof with - | .error e => - IO.eprintln s!"join benchmark: left proof advice encoding failed: {e}" - return 1 - | .ok bytes => pure bytes - let rightProofAdvice ← match aiurSystem.proofToAdviceBytes - right.outerClaim right.proof with - | .error e => - IO.eprintln s!"join benchmark: right proof advice encoding failed: {e}" - return 1 - | .ok bytes => pure bytes - let shape := Aggr.shapeCode (.ixvm, some .ixvm) - IO.println s!" executing join {pairName} …" - (← IO.getStdout).flush - let (joinExecuteResult, joinExecuteSec) ← timed fun _ => - aggrCompiled.bytecode.executeIxAggr aggrIdx pubInput shape - leftProofAdvice rightProofAdvice ixvmVk aggrVk - left.innerClaimsBytes right.innerClaimsBytes outputClaimBytes allowed - preimagesBlob treesBlob pathsBlob - let joinFftCost ← match joinExecuteResult with - | .error e => - IO.eprintln s!" ❌ ix_aggr direct join REJECTED {pairName}: {e}" - writeRejectedJoin pairName - joinRejected := true - pure none - | .ok (_, queryCounts) => - let stats := Aiur.computeStats aggrCompiled queryCounts aggrSystem.circuitShapes - (logBlowup := commitParams.logBlowup) - IO.println s!" {pairName}: join-execute={joinExecuteSec}s \ - join-fft-cost={stats.totalFftCost}" - if useTexray then Aiur.printStats stats - pure (some stats.totalFftCost) - if let some joinFftCost := joinFftCost then - -- Persist the cheap phase before proving, so a watchdog kill still - -- reports the join's execution time and FFT cost. - if let some path := jsonOut then - Ix.Benchmark.Results.writeEntry path pairName <| Json.mkObj - [("status", Json.str "ok"), - ("constants", Lean.toJson (left.constants + right.constants)), - ("join-execute-time", jsonRound 6 joinExecuteSec), - ("join-fft-cost", jsonRound 0 joinFftCost)] - IO.println s!" proving join {pairName} …" - (← IO.getStdout).flush - TracingTexray.resetPeakTreeRss - let (joinProveResult, joinProveSec) ← timed fun _ => - aggrSystem.proveIxAggr aggrIdx pubInput shape - leftProofAdvice rightProofAdvice ixvmVk aggrVk - left.innerClaimsBytes right.innerClaimsBytes outputClaimBytes allowed - preimagesBlob treesBlob pathsBlob - match joinProveResult with - | .error e => - IO.eprintln s!" prove join {pairName} failed: {e}" - return 1 - | .ok (joinClaim, joinProof) => - let expectedClaim := Aiur.buildClaim aggrIdx pubInput #[] - if joinClaim != expectedClaim then - IO.eprintln s!" join {pairName} returned an unexpected outer claim" - return 1 - let joinPeak ← TracingTexray.peakTreeRssBytes - let joinProofBytes := joinProof.toBytes - let (joinVerifyResult, joinVerifySec) ← timed fun _ => - aggrSystem.verify joinClaim joinProof - let joinVerifySec? ← match joinVerifyResult with - | .ok () => pure (some joinVerifySec) - | .error e => - IO.eprintln s!" join verify {pairName} FAILED: {e}" - joinRejected := true - pure none - let joinResult : JoinResult := { - name := pairName - constants := left.constants + right.constants - fftCost := joinFftCost - executeSec := joinExecuteSec - proveSec := joinProveSec - peakRss := joinPeak - proofSize := joinProofBytes.size - verifySec := joinVerifySec? - failed := joinVerifySec?.isNone - } - writeJoinJson joinResult - IO.println s!" {pairName}: join-prove={joinProveSec}s \ - join-verify={joinVerifySec}s proof={joinProofBytes.size} bytes" - - match jsonOut with - | some path => - let rowCount := ordered.size + (if join && !joinRejected then 1 else 0) - IO.println s!"wrote {rowCount} benchmarks to {path} ({spent}s proving)" - | none => IO.println s!"proved {ordered.size} constants ({spent}s); pass --json to emit results" - return if ordered.any (·.1.failed) || joinRejected then - Ix.Benchmark.Results.exitRejected - else 0 - -def typecheckCmd : Cli.Cmd := `[Cli| - typecheck VIA runTypecheckCmd; - "Benchmark IxVM-kernel execution + proving of `Ix.Claim.check` over `.ixe` constants" - - FLAGS: - "ixe" : String; "Path to a serialized `Ixon.Env` (e.g. produced by `ix compile`). Required." - "consts" : String; "Comma-separated fully-qualified constant names to benchmark (e.g. `Nat.add_comm,String.append`). Same flag/shape as `ix check --consts`." - "consts-file" : String; "Additionally read constant names from a file (one per line; `#` comments and blank lines ignored). Unions with --consts." - "json" : String; "Write results JSON to this path (per constant, plus one pair row with --join). Off by default; normal CLI usage prints only the human-readable summary." - "skip-deps"; "Check only each target itself (verify_const, trusting its deps) instead of re-checking its whole transitive closure (verify_claim)." - "execute-only"; "Execute only (Phase 1: constants / fft-cost / execute-time) and skip proving. The fast per-PR `execute`-mode signal." - "recursive"; "After each prove, execute and then prove the in-circuit multi-stark verifier over the fresh proof (the fri-verifier-* metrics; see the module docstring). Uses recursion-tuned FRI parameters. Conflicts with --execute-only." - "join"; "With --recursive and exactly two resolved constants, prove each as a singleton CheckEnv shard, then execute/prove/verify one direct flat aggregate join (ix_aggr shape 2). Emits a dedicated `left + right` row with join-* metrics. Conflicts with --skip-deps, --execute-only, and --interp." - "trace-shards"; "Prove each constant as a singleton CheckEnv shard planned to a batch of trace shards within --max-ram (the `ix prove --trace-shards` path); `BENCH_TRACE_SHARDS=` sets both from the environment. Every proven row reports `ixvm-trace-shards`, the shard count of its proof." - "max-ram" : Nat; "With --trace-shards: the per-constant prover RAM budget in GiB (default 0: 85% of MemAvailable)." - "interp"; "Route execution through the generic Aiur bytecode interpreter instead of the codegen'd IxVM kernel - no `lake exe ix codegen` + cargo rebuild needed after `Ix/IxVM/*.lean` edits. Applies to Phase 1, the prove's witness generation, and both --recursive steps. Slower; execute-time rows are not comparable to codegen-mode runs (fft-cost is)." - "queries" : Nat; "Override the positive FRI query count of the selected parameter set (default 100, or 50 with --recursive; applies to inner and outer proof alike)." - texray; "Enable the tracing-texray timeline + RAM breakdown (per-prove spans on stderr). Combined with --json, per-phase span timings are additionally written to `.spans` as JSON Lines for the CI drill-down. Off by default." - -] - -def main (args : List String) : IO UInt32 := - typecheckCmd.validate args diff --git a/Cargo.lock b/Cargo.lock index 9ff3172d0..2b62a3ce2 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -62,21 +62,15 @@ dependencies = [ name = "aiur" version = "0.1.0" dependencies = [ - "bincode", "blake3", - "hashbrown 0.15.5", - "indexmap", - "libc", + "hashbrown 0.17.0", "multi-stark", - "num-bigint 0.4.6", - "p3-blake3", - "p3-commit", - "p3-symmetric", "rayon", + "record-pool", "rustc-hash", + "serde", "serde_json", - "tracing", - "tracing-texray", + "stark-key", ] [[package]] @@ -100,15 +94,6 @@ version = "1.0.103" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2a4385e2e34eb35d6b3efe798b9eb88096925d87726c0798709bf56d9ed84af3" -[[package]] -name = "ar_archive_writer" -version = "0.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4087686b4b0a3427190bae57a1d9a478dbb2d40c5dc1bd6e2b6d797913bdd348" -dependencies = [ - "object", -] - [[package]] name = "ark-bn254" version = "0.5.0" @@ -238,12 +223,6 @@ dependencies = [ "rayon", ] -[[package]] -name = "arrayref" -version = "0.3.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb" - [[package]] name = "arrayvec" version = "0.7.6" @@ -390,11 +369,10 @@ checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3" [[package]] name = "blake3" -version = "1.8.5" +version = "1.8.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0aa83c34e62843d924f905e0f5c866eb1dd6545fc4d719e803d9ba6030371fce" +checksum = "6d9e454fc11f76977dc803893aff6304ed33d6a26efae8696573bea74baa27ae" dependencies = [ - "arrayref", "arrayvec", "cc", "cfg-if", @@ -1347,7 +1325,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" dependencies = [ "allocator-api2", - "equivalent", "foldhash 0.1.5", ] @@ -1367,6 +1344,11 @@ name = "hashbrown" version = "0.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51" +dependencies = [ + "allocator-api2", + "equivalent", + "foldhash 0.2.0", +] [[package]] name = "heapless" @@ -1990,7 +1972,6 @@ dependencies = [ "ix-common", "ix-proof-compression", "ixon", - "ixvm-codegen", "lean-ffi", "memmap2", "mimalloc", @@ -2001,6 +1982,8 @@ dependencies = [ "serde", "serde_json", "sha2 0.10.9", + "stark-key", + "stark-verifier", "tiny-keccak", "tokio", "tracing", @@ -2038,12 +2021,32 @@ dependencies = [ "serde_json", "sha2 0.10.9", "sppark", + "stark-key", "tiny-keccak", "tracing", "tracing-subscriber", "tracing-texray", ] +[[package]] +name = "ix-prover" +version = "0.1.0" +dependencies = [ + "aiur", + "blake3", + "ixvm", + "multi-stark", + "rayon", + "record-pool", + "rustc-hash", + "serde", + "serde_json", + "stark-verifier", + "tracing", + "tracing-subscriber", + "tracing-texray", +] + [[package]] name = "ixon" version = "0.1.0" @@ -2062,16 +2065,14 @@ dependencies = [ ] [[package]] -name = "ixvm-codegen" +name = "ixvm" version = "0.1.0" dependencies = [ "aiur", - "ix-common", - "ixon", + "blake3", "multi-stark", - "rayon", - "rustc-hash", - "stacker", + "serde", + "serde_json", ] [[package]] @@ -2697,15 +2698,6 @@ dependencies = [ "objc2-security", ] -[[package]] -name = "object" -version = "0.37.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe" -dependencies = [ - "memchr", -] - [[package]] name = "once_cell" version = "1.21.4" @@ -3237,16 +3229,6 @@ dependencies = [ "unicode-ident", ] -[[package]] -name = "psm" -version = "0.1.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "645dbe486e346d9b5de3ef16ede18c26e6c70ad97418f4874b8b1889d6e761ea" -dependencies = [ - "ar_archive_writer", - "cc", -] - [[package]] name = "quick-xml" version = "0.39.4" @@ -3446,6 +3428,10 @@ dependencies = [ "crossbeam-utils", ] +[[package]] +name = "record-pool" +version = "0.1.0" + [[package]] name = "redox_syscall" version = "0.5.18" @@ -3902,16 +3888,25 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" [[package]] -name = "stacker" -version = "0.1.24" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "640c8cdd92b6b12f5bcb1803ca3bbf5ab96e5e6b6b96b9ab77dabe9e880b3190" +name = "stark-key" +version = "0.1.0" dependencies = [ - "cc", - "cfg-if", + "bincode", + "multi-stark", +] + +[[package]] +name = "stark-verifier" +version = "0.1.0" +dependencies = [ + "aiur", + "blake3", + "ixvm", "libc", - "psm", - "windows-sys 0.61.2", + "multi-stark", + "serde", + "serde_json", + "stark-key", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 5d62a1651..5e8fe6f40 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,10 +1,26 @@ [workspace] members = [ + "crates/ix-prover", + "crates/record-pool", "crates/aiur", + "crates/stark-key", + "crates/stark-verifier", + "crates/ixvm", + "crates/common", + "crates/proof-compression", + "crates/ffi", + "crates/ixon", +] +default-members = [ + "crates/ix-prover", + "crates/record-pool", + "crates/aiur", + "crates/stark-key", + "crates/stark-verifier", + "crates/ixvm", "crates/common", "crates/proof-compression", "crates/ffi", - "crates/ixvm-codegen", "crates/ixon", ] resolver = "2" @@ -26,8 +42,9 @@ license = "MIT OR Apache-2.0" [workspace.dependencies] # Internal crates +record-pool = { path = "crates/record-pool" } aiur = { path = "crates/aiur" } -ixvm-codegen = { path = "crates/ixvm-codegen" } +stark-key = { path = "crates/stark-key" } ix-common = { path = "crates/common" } ixon = { path = "crates/ixon" } @@ -51,7 +68,7 @@ quickcheck = "1.0.3" quickcheck_macros = "1.0.0" rayon = "1" rustc-hash = "2" -serde_json = "1" +serde_json = { version = "1", features = ["unbounded_depth"] } sha2 = "0.10" tiny-keccak = { version = "2", features = ["keccak"] } tracing = "0.1" diff --git a/Ix.lean b/Ix.lean index c2ce7029c..729c1a3cc 100644 --- a/Ix.lean +++ b/Ix.lean @@ -22,7 +22,10 @@ public import Ix.AssumptionTree public import Ix.Commit public import Ix.Watchdog public import Ix.Benchmark.Bench -public import Ix.Aiur +public import Ix.Aiur.Protocol +public import Ix.IxVM.ClaimHarness +public import Ix.IxVM.RoleSpecGen +public import Ix.MultiStark.Wire public import Ix.TracingTexray /-! This module serves as the root of the `Ix` library. diff --git a/Ix/Aggr.lean b/Ix/Aggr.lean index 41dcd7b11..d3daaffae 100644 --- a/Ix/Aggr.lean +++ b/Ix/Aggr.lean @@ -1,46 +1,7 @@ module -public import Ix.Aggr.FFI -public import Ix.Aggr.Circuit -public import Ix.Aggr.FunctionGroups public import Ix.Aggr.Host public import Ix.Aggr.Protocol -public import MultiStark - -/-! -# The `ixAggr` toplevel - -`ixAggr` is the recursive aggregation system for IxVM proofs. It reuses the -Ix-agnostic Multi-STARK verifier modules (`MultiStark/…`, unmodified) and -adds the heterogeneous `ix_aggr` entrypoint from `Ix/Aggr/Circuit.lean` — one -circuit that wraps or joins any mix of IxVM and `ix_aggr` child proofs, with -the shape chosen by advice. There is no separate lift stage: an IxVM proof -enters the recursion system through a wrap or directly as a join child. - -Host wire contracts live in `Ix/Aggr/Protocol.lean`; statement folds live in -`Ix/Aggr/Host.lean`. --/ - -public section - -namespace Aggr - -/-- The full aggregation toplevel: every Multi-STARK verifier module (via -`MultiStark.verifierBase`, unmodified) plus the `ix_aggr` circuit — -unpruned. Only tests should build on this; production uses `ixAggr`. -/ -def ixAggrFull : Except Aiur.Global Aiur.Source.Toplevel := do - let t ← MultiStark.verifierBase - t.merge circuit - -/-- The production aggregation toplevel: `ixAggrFull` pruned to `ix_aggr`'s -call closure. Every compiled function is a committed circuit whose openings -pad every proof of the system's execution, so functions only reachable from -unrelated entries (`verify_multi_stark_proof`, kernel-oriented helpers of the -shared modules, test/bench entries) cost real proof bytes if kept. -/ -def ixAggr : Except Aiur.Global Aiur.Source.Toplevel := do - let t ← ixAggrFull - pure (t.prune [`ix_aggr]) - - -end Aggr - -end +public import Ix.Aggr.Parameters +public import Ix.Aggr.Reference +public import Ix.Aggr.Verification +public import Ix.Aggr.CatalogPlan diff --git a/Ix/Aggr/Backend.lean b/Ix/Aggr/Backend.lean deleted file mode 100644 index 81b8a461c..000000000 --- a/Ix/Aggr/Backend.lean +++ /dev/null @@ -1,75 +0,0 @@ -module -public import Ix.Aggr -public import Ix.Aiur.Compiler -public import Ix.IxVM -public import Ix.IxVM.Toplevel - -/-! Compilation and system construction shared by aggregation commands. -/ - -public section -namespace Aggr - -private def compileToplevel (label : String) - (source : Except Aiur.Global Aiur.Source.Toplevel) - (groups : Array (String × Array String)) : - IO (Except String Aiur.CompiledToplevel) := do - match source with - | .error e => return Except.error s!"{label} toplevel merge failed: {e}" - | .ok top => match top.compileWithGroups groups with - | .error e => return Except.error s!"{label} compilation failed: {e}" - | .ok compiled => return Except.ok compiled - -structure CompiledBackend where - compiled : Aiur.CompiledToplevel - system : Aiur.AiurSystem - vk : ByteArray - -/-- Compile a Lean-authored Aiur program, then perform the Rust-side system -construction and verifying-key serialization in the same worker. Keeping this -pipeline together lets the independent IxVM and recursion backends build in -parallel instead of serializing their Rust setup on the controller thread. -/ -def compileBackend (label : String) - (source : Unit → Except Aiur.Global Aiur.Source.Toplevel) - (groups : Array (String × Array String)) - (commitment : Aiur.CommitmentParameters) (fri : Aiur.FriParameters) : - IO (Except String CompiledBackend) := do - let source ← IO.lazyPure source - let compiled ← match ← compileToplevel label source groups with - | .error e => return .error e - | .ok compiled => pure compiled - let system := Aiur.AiurSystem.build compiled.bytecode commitment fri - let vk := system.vkBytes - return .ok { compiled, system, vk } - - -structure VerificationBackend where - system : Aiur.AiurSystem - aggrIdx : Aiur.Bytecode.FunIdx - allowed : ByteArray - ixvmVk : ByteArray - -/-- Build the two deterministic systems whose identities are committed by an -aggregate root: the IxVM vk and the single-entrypoint recursion vk. -/ -def buildVerificationBackend - (recursionParameters : Aggr.RecursionParameters) : - IO (Except String VerificationBackend) := do - let ixvm ← match ← compileBackend "IxVM" (fun _ => IxVM.ixVM) - IxVM.functionGroups Aiur.defaultCommitmentParameters Aiur.defaultFriParameters with - | .error e => return .error e - | .ok backend => pure backend - let aggr ← match ← compileBackend "recursion" (fun _ => Aggr.ixAggr) - Aggr.functionGroups recursionParameters.commitment recursionParameters.fri with - | .error e => return .error e - | .ok backend => pure backend - let verifyIdx := ixvm.compiled.getFuncIdx `verify_claim |>.get! - let aggrIdx := aggr.compiled.getFuncIdx `ix_aggr |>.get! - let allowed := Aggr.allowedBlob ixvm.vk verifyIdx aggr.vk aggrIdx - return .ok { - system := aggr.system - aggrIdx - allowed - ixvmVk := ixvm.vk - } - -end Aggr -end diff --git a/Ix/Aggr/Circuit.lean b/Ix/Aggr/Circuit.lean deleted file mode 100644 index faf75d795..000000000 --- a/Ix/Aggr/Circuit.lean +++ /dev/null @@ -1,1475 +0,0 @@ -module -public import Ix.Aiur.Meta -public import Ix.Aiur.Library.Blake3 -public import MultiStark.Verifier - -/-! -# Heterogeneous recursive aggregation circuit - -One entrypoint, `ix_aggr`, subsumes wrapping and joining. A non-deterministic -shape hint (IO channel 6) selects one of seventeen verified forms: - -| shape | children | statement fold | -|-------|---------------------------|-----------------------------------------| -| 0 | one IxVM proof | pass-through (wrap) | -| 1 | one `ix_aggr` proof | pass-through (wrap) | -| 2 | IxVM, IxVM | union / difference | -| 3 | IxVM, `ix_aggr` | union / difference | -| 4 | `ix_aggr`, IxVM | union / difference | -| 5 | `ix_aggr`, `ix_aggr` | union / difference | -| 6 | IxVM, IxVM | structural root / path discharge | -| 7 | IxVM, `ix_aggr` | structural root / path discharge | -| 8 | `ix_aggr`, IxVM | structural root / path discharge | -| 9 | `ix_aggr`, `ix_aggr` | structural root / path discharge | -| 10 | shards `[lo, hi)` of an IxVM batch | range leaf: residual sum | -| 11 | `ix_aggr`, `ix_aggr` (ranges) | range join: adjacent ranges added | -| 12 | one `ix_aggr` range proof | range root: whole batch, IxVM claim | -| 13 | IxVM, IxVM `Binding` | binding discharge: validator 4 → 3 | -| 14 | `ix_aggr`, IxVM `Binding` | binding discharge: validator 4 → 3 | -| 15 | `ix_aggr`, `ix_aggr` | cross-binding structural pair: one literal class, validator 5 | -| 16 | `ix_aggr`, `ix_aggr` | catalog join: union of member statements | - -Shapes 15 and 16 join claims made under different role bindings, as libraries -compiled from different Lean toolchains are. Shape 15 is the structural pair -for two `CheckEnv` claims whose bindings have the same literal class -(`Ix.ClaimContext.literalClass`): each child validates its binding (validator -3) or already names a class (validator 5), and the output names the class -(validator 5), so further folds of that class and discharge across its -bindings are the existing shapes. Shape 16 forms a `Catalog` claim, the -conjunction of unconditional `CheckEnv` claims under any contexts: a `CheckEnv` -child contributes its own claim digest, a `Catalog` child its members, and the -output's members are their union. Both take `ix_aggr` children only. - -Shapes 10–12 are the range-sum recursion (see the section of that name in -the circuit): together they verify one large IxVM batch across several -recursion proofs, and the root's statement is exactly the wrap's (shape 0), -so ranges compose with every pair shape unchanged. - -The hint is advice, not trust: every shape verifies its children against the -verifying key demanded by that shape (digest-bound to the allowed blob) and -then demands that shape's exact claim layout, so a wrong hint fails either the -proof verification or a digest/shape assertion. - -The public statement is uniform across all shapes: - -`blake3(allowed_blob) ‖ blake3(output claim bytes)`, - -where the output claim is a `CheckEnv` claim, or a `Catalog` claim for shape -16 (and for a wrap of one), - -packed four bytes per Goldilocks element. The 80-byte allowed blob is - -`blake3(ixvm vk) ‖ verify_claim idx (u64 LE) ‖ blake3(self vk) ‖ ix_aggr idx -(u64 LE)` - -and is carried unchanged by every node of an aggregation tree: a parent -asserts its `ix_aggr` children bind the *same* allowed digest, which pins both -verifying keys and both entrypoint indices transitively. The indices must be -explicit because the Source DSL cannot materialize its compiler-assigned -function index inside a circuit. - -Child claims normalize to one `CheckEnv` statement each: - -* IxVM child — 10-word `verify_claim` claim `[0, verify_idx, digest(8)]`, - where the digest packs `blake3` of the serialized `CheckEnv` claim. -* `ix_aggr` child — 18-word claim `[0, aggr_idx, allowed(8), digest(8)]`. - -Wrap shapes bind the output digest to the child's `CheckEnv` digest directly -and open nothing. Flat pair shapes open both `CheckEnv` preimages (channel 4), -re-root the canonical subject/assumption trees (channel 5), and prove - -`subjects = subjects_L ∪ subjects_R` - -`assumptions = (assumptions_L ∪ assumptions_R) ∖ subjects`. - -Structural pair shapes instead bind -`subjects = nodeHash(subjects_L.root, subjects_R.root)` and account for every -input assumption by either carrying it into the canonical output assumptions -or discharging it with a strict Merkle inclusion path on channel 6. - -All address-list operations use bytewise address comparison. Pointer identity -is never used as set equality: Aiur memory constrains pointers to be unique, -not stored values to be globally deduplicated. - -## IO channels - -| channel | key | payload | -|---------|----------------------|------------------------------------------| -| 0 | `[0]` / `[1]` | child proof bytes; a range leaf carries the batch preamble at `[0]` and the range's proofs at `[1]`, a range root the preamble at `[1]` | -| 1 | `[kind]` | vk bytes (0 = IxVM, 1 = self) | -| 2 | `[0]` / `[1]`, `[2]` | child claims; output claim or range statement bytes | -| 3 | `[0]` | 80-byte allowed blob | -| 4 | packed digest | `CheckEnv` and `Catalog` claim, range statement and role binding section preimages | -| 5 | raw 32-byte root | serialized canonical `AssumptionTree`s | -| 6 | `[0]` / address | shape byte (0–16) / structural path choice | --/ - -public section - -namespace Aggr - -def circuit := ⟦ - enum AggrNextAssumption { - Done, - More(Addr, G, List‹Addr›, List‹Addr›) - } - - /- ## Small strict byte readers - - The aggregator only decodes fixed-width digests, u64 function indices, and - single-byte tags. Keeping these readers local avoids pulling the full IxVM - Ixon decoder (and all of its kernel-only types) into the recursion system. - -/ - - fn aggr_read_byte(stream: ByteStream) -> (U8, ByteStream) { - let ListNode.Cons(byte, rest) = load(stream); - (byte, rest) - } - - fn aggr_read_address(stream: ByteStream) -> (Addr, ByteStream) { - let ListNode.Cons(b0, s) = load(stream); - let ListNode.Cons(b1, s) = load(s); - let ListNode.Cons(b2, s) = load(s); - let ListNode.Cons(b3, s) = load(s); - let ListNode.Cons(b4, s) = load(s); - let ListNode.Cons(b5, s) = load(s); - let ListNode.Cons(b6, s) = load(s); - let ListNode.Cons(b7, s) = load(s); - let ListNode.Cons(b8, s) = load(s); - let ListNode.Cons(b9, s) = load(s); - let ListNode.Cons(b10, s) = load(s); - let ListNode.Cons(b11, s) = load(s); - let ListNode.Cons(b12, s) = load(s); - let ListNode.Cons(b13, s) = load(s); - let ListNode.Cons(b14, s) = load(s); - let ListNode.Cons(b15, s) = load(s); - let ListNode.Cons(b16, s) = load(s); - let ListNode.Cons(b17, s) = load(s); - let ListNode.Cons(b18, s) = load(s); - let ListNode.Cons(b19, s) = load(s); - let ListNode.Cons(b20, s) = load(s); - let ListNode.Cons(b21, s) = load(s); - let ListNode.Cons(b22, s) = load(s); - let ListNode.Cons(b23, s) = load(s); - let ListNode.Cons(b24, s) = load(s); - let ListNode.Cons(b25, s) = load(s); - let ListNode.Cons(b26, s) = load(s); - let ListNode.Cons(b27, s) = load(s); - let ListNode.Cons(b28, s) = load(s); - let ListNode.Cons(b29, s) = load(s); - let ListNode.Cons(b30, s) = load(s); - let ListNode.Cons(b31, s) = load(s); - (store([b0, b1, b2, b3, b4, b5, b6, b7, - b8, b9, b10, b11, b12, b13, b14, b15, - b16, b17, b18, b19, b20, b21, b22, b23, - b24, b25, b26, b27, b28, b29, b30, b31]), s) - } - - fn aggr_put_address(addr: Addr, rest: ByteStream) -> ByteStream { - let a = load(addr); - let s31 = store(ListNode.Cons(a[31], rest)); - let s30 = store(ListNode.Cons(a[30], s31)); - let s29 = store(ListNode.Cons(a[29], s30)); - let s28 = store(ListNode.Cons(a[28], s29)); - let s27 = store(ListNode.Cons(a[27], s28)); - let s26 = store(ListNode.Cons(a[26], s27)); - let s25 = store(ListNode.Cons(a[25], s26)); - let s24 = store(ListNode.Cons(a[24], s25)); - let s23 = store(ListNode.Cons(a[23], s24)); - let s22 = store(ListNode.Cons(a[22], s23)); - let s21 = store(ListNode.Cons(a[21], s22)); - let s20 = store(ListNode.Cons(a[20], s21)); - let s19 = store(ListNode.Cons(a[19], s20)); - let s18 = store(ListNode.Cons(a[18], s19)); - let s17 = store(ListNode.Cons(a[17], s18)); - let s16 = store(ListNode.Cons(a[16], s17)); - let s15 = store(ListNode.Cons(a[15], s16)); - let s14 = store(ListNode.Cons(a[14], s15)); - let s13 = store(ListNode.Cons(a[13], s14)); - let s12 = store(ListNode.Cons(a[12], s13)); - let s11 = store(ListNode.Cons(a[11], s12)); - let s10 = store(ListNode.Cons(a[10], s11)); - let s9 = store(ListNode.Cons(a[9], s10)); - let s8 = store(ListNode.Cons(a[8], s9)); - let s7 = store(ListNode.Cons(a[7], s8)); - let s6 = store(ListNode.Cons(a[6], s7)); - let s5 = store(ListNode.Cons(a[5], s6)); - let s4 = store(ListNode.Cons(a[4], s5)); - let s3 = store(ListNode.Cons(a[3], s4)); - let s2 = store(ListNode.Cons(a[2], s3)); - let s1 = store(ListNode.Cons(a[1], s2)); - store(ListNode.Cons(a[0], s1)) - } - - fn aggr_pack_address(addr: Addr) -> [G; 8] { - let a = load(addr); - [@b3_pack_w([a[0], a[1], a[2], a[3]]), - @b3_pack_w([a[4], a[5], a[6], a[7]]), - @b3_pack_w([a[8], a[9], a[10], a[11]]), - @b3_pack_w([a[12], a[13], a[14], a[15]]), - @b3_pack_w([a[16], a[17], a[18], a[19]]), - @b3_pack_w([a[20], a[21], a[22], a[23]]), - @b3_pack_w([a[24], a[25], a[26], a[27]]), - @b3_pack_w([a[28], a[29], a[30], a[31]])] - } - - -- `Ix.Merkle.nodeHash`: Blake3 of `0x01 ‖ left ‖ right`. - fn aggr_node_hash(left: Addr, right: Addr) -> Addr { - let tail = aggr_put_address(left, - aggr_put_address(right, store(ListNode.Nil))); - bytes_to_addr(store(ListNode.Cons(1u8, tail))) - } - - -- `Ix.Merkle.leafHash`: Blake3 of `0x00 ‖ address`. - fn aggr_leaf_hash(addr: Addr) -> Addr { - let tail = aggr_put_address(addr, store(ListNode.Nil)); - bytes_to_addr(store(ListNode.Cons(0u8, tail))) - } - - fn aggr_pack_be4(a: U8, b: U8, c: U8, d: U8) -> G { - ((to_field(a) * 256 + to_field(b)) * 256 + to_field(c)) * 256 - + to_field(d) - } - - -- Byte-lexicographic address order: 0 = less, 1 = equal, 2 = greater. - -- Four-byte big-endian words stay below 2^32, so native field equality and - -- `u32_less_than` are exact. - fn aggr_address_order(a: Addr, b: Addr) -> G { - let av = load(a); - let bv = load(b); - let aw0 = @aggr_pack_be4(av[0], av[1], av[2], av[3]); - let bw0 = @aggr_pack_be4(bv[0], bv[1], bv[2], bv[3]); - match aw0 - bw0 { - 0 => - let aw1 = @aggr_pack_be4(av[4], av[5], av[6], av[7]); - let bw1 = @aggr_pack_be4(bv[4], bv[5], bv[6], bv[7]); - match aw1 - bw1 { - 0 => - let aw2 = @aggr_pack_be4(av[8], av[9], av[10], av[11]); - let bw2 = @aggr_pack_be4(bv[8], bv[9], bv[10], bv[11]); - match aw2 - bw2 { - 0 => - let aw3 = @aggr_pack_be4(av[12], av[13], av[14], av[15]); - let bw3 = @aggr_pack_be4(bv[12], bv[13], bv[14], bv[15]); - match aw3 - bw3 { - 0 => - let aw4 = @aggr_pack_be4(av[16], av[17], av[18], av[19]); - let bw4 = @aggr_pack_be4(bv[16], bv[17], bv[18], bv[19]); - match aw4 - bw4 { - 0 => - let aw5 = @aggr_pack_be4(av[20], av[21], av[22], av[23]); - let bw5 = @aggr_pack_be4(bv[20], bv[21], bv[22], bv[23]); - match aw5 - bw5 { - 0 => - let aw6 = @aggr_pack_be4(av[24], av[25], av[26], av[27]); - let bw6 = @aggr_pack_be4(bv[24], bv[25], bv[26], bv[27]); - match aw6 - bw6 { - 0 => - let aw7 = @aggr_pack_be4(av[28], av[29], av[30], av[31]); - let bw7 = @aggr_pack_be4(bv[28], bv[29], bv[30], bv[31]); - match aw7 - bw7 { - 0 => 1, - _ => match u32_less_than(aw7, bw7) { 1 => 0, _ => 2, }, - }, - _ => match u32_less_than(aw6, bw6) { 1 => 0, _ => 2, }, - }, - _ => match u32_less_than(aw5, bw5) { 1 => 0, _ => 2, }, - }, - _ => match u32_less_than(aw4, bw4) { 1 => 0, _ => 2, }, - }, - _ => match u32_less_than(aw3, bw3) { 1 => 0, _ => 2, }, - }, - _ => match u32_less_than(aw2, bw2) { 1 => 0, _ => 2, }, - }, - _ => match u32_less_than(aw1, bw1) { 1 => 0, _ => 2, }, - }, - _ => match u32_less_than(aw0, bw0) { 1 => 0, _ => 2, }, - } - } - - fn aggr_assert_strict_sorted(leaves: List‹Addr›) { - match load(leaves) { - ListNode.Nil => (), - ListNode.Cons(a, rest) => - match load(rest) { - ListNode.Nil => (), - ListNode.Cons(b, _) => - assert_eq!(aggr_address_order(a, b), 0, - "aggr: tree leaves are not strictly sorted"); - aggr_assert_strict_sorted(rest), - }, - } - } - - -- Parse an `AssumptionTree` body into its in-order real leaves. Padding is - -- omitted. The serialized shape is advice; canonical-root recomputation - -- below binds the resulting sorted leaf set to the requested root. - fn aggr_parse_tree_body(stream: ByteStream) -> (List‹Addr›, ByteStream) { - let (tag, rest) = aggr_read_byte(stream); - match tag { - 0 => - let (addr, stop) = aggr_read_address(rest); - (store(ListNode.Cons(addr, store(ListNode.Nil))), stop), - 1 => (store(ListNode.Nil), rest), - 2 => - let (left, s2) = aggr_parse_tree_body(rest); - let (right, stop) = aggr_parse_tree_body(s2); - (list_concat(left, right), stop), - } - } - - fn aggr_leaf_hashes(leaves: List‹Addr›) -> List‹Addr› { - match load(leaves) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(addr, rest) => - store(ListNode.Cons(aggr_leaf_hash(addr), aggr_leaf_hashes(rest))), - } - } - - -- One canonical Merkle reduction level. An odd last node is paired with - -- the zero-address padding sentinel. - fn aggr_pair_hashes(nodes: List‹Addr›) -> List‹Addr› { - match load(nodes) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(left, rest) => - match load(rest) { - ListNode.Nil => - let zero = store([0u8; 32]); - store(ListNode.Cons(aggr_node_hash(left, zero), store(ListNode.Nil))), - ListNode.Cons(right, tail) => - store(ListNode.Cons(aggr_node_hash(left, right), aggr_pair_hashes(tail))), - }, - } - } - - fn aggr_reduce_hashes(nodes: List‹Addr›) -> Addr { - let ListNode.Cons(root, rest) = load(nodes); - match load(rest) { - ListNode.Nil => root, - _ => aggr_reduce_hashes(aggr_pair_hashes(nodes)), - } - } - - fn aggr_canonical_root(leaves: List‹Addr›) -> Addr { - aggr_reduce_hashes(aggr_leaf_hashes(leaves)) - } - - fn aggr_load_canonical_tree(root: Addr) -> List‹Addr› { - let raw = load(root); - let (idx, len) = io_get_info(5, raw); - let bytes = read_checked_byte_stream(5, idx, len); - let (tag, body) = aggr_read_byte(bytes); - assert_eq!(tag, 0xE2u8, "aggr: tree has the wrong Ixon tag"); - let (leaves, stop) = aggr_parse_tree_body(body); - assert_eq!(load(stop), ListNode.Nil, - "aggr: trailing bytes after AssumptionTree"); - assert_eq!(list_is_empty(leaves), 0, - "aggr: a present tree must contain at least one leaf"); - -- Strictly increasing address keys cannot form a cycle. This establishes - -- finite leaves independently of the advised parser's return; recomputing - -- the root from that list then binds the set used by every fold below. - -- The serialized tree shape itself is only advice, not the statement. - aggr_assert_strict_sorted(leaves); - let expected = aggr_canonical_root(leaves); - assert_eq!(address_eq(expected, root), 1, - "aggr: tree leaves do not reproduce the canonical root"); - leaves - } - - fn aggr_load_optional_tree(root: Option‹Addr›) -> List‹Addr› { - match root { - Option.None => store(ListNode.Nil), - Option.Some(addr) => aggr_load_canonical_tree(addr), - } - } - - fn aggr_assert_same_list(left: List‹Addr›, right: List‹Addr›) { - match (load(left), load(right)) { - (ListNode.Nil, ListNode.Nil) => (), - (ListNode.Cons(a, ar), ListNode.Cons(b, br)) => - assert_eq!(address_eq(a, b), 1, "aggr: set element mismatch"); - aggr_assert_same_list(ar, br), - } - } - - -- Assert `output` is the sorted, deduplicated union of two sorted unique - -- inputs. The merge is linear in the number of leaves. - fn aggr_assert_union(left: List‹Addr›, right: List‹Addr›, - output: List‹Addr›) { - match (load(left), load(right)) { - (ListNode.Nil, _) => aggr_assert_same_list(right, output), - (_, ListNode.Nil) => aggr_assert_same_list(left, output), - (ListNode.Cons(a, ar), ListNode.Cons(b, br)) => - let ListNode.Cons(o, or) = load(output); - match aggr_address_order(a, b) { - 0 => - assert_eq!(address_eq(a, o), 1, "aggr: subject union mismatch"); - aggr_assert_union(ar, right, or), - 1 => - assert_eq!(address_eq(a, o), 1, "aggr: subject union mismatch"); - aggr_assert_union(ar, br, or), - _ => - assert_eq!(address_eq(b, o), 1, "aggr: subject union mismatch"); - aggr_assert_union(left, br, or), - }, - } - } - - -- Assert `output` is the sorted, disjoint union of two sorted unique inputs. - -- Used for flat pair subject sets (`aggr_pair`), where child subject sets - -- must partition the joined subjects without overlap. - fn aggr_assert_disjoint_union(left: List‹Addr›, right: List‹Addr›, - output: List‹Addr›) { - match (load(left), load(right)) { - (ListNode.Nil, _) => aggr_assert_same_list(right, output), - (_, ListNode.Nil) => aggr_assert_same_list(left, output), - (ListNode.Cons(a, ar), ListNode.Cons(b, br)) => - let ListNode.Cons(o, or) = load(output); - match aggr_address_order(a, b) { - 0 => - assert_eq!(address_eq(a, o), 1, "aggr: subject union mismatch"); - aggr_assert_disjoint_union(ar, right, or), - 1 => - assert_eq!(0, 1, "aggr: child subject sets overlap"); - (), - _ => - assert_eq!(address_eq(b, o), 1, "aggr: subject union mismatch"); - aggr_assert_disjoint_union(left, br, or), - }, - } - } - - -- Assert two sorted address lists are disjoint. Used in `aggr_pair` to - -- enforce `subjects_i ∩ assumptions_i = ∅` per child so a child's subjects - -- can never discharge its own assumptions. - fn aggr_assert_disjoint(left: List‹Addr›, right: List‹Addr›) { - match (load(left), load(right)) { - (ListNode.Nil, _) => (), - (_, ListNode.Nil) => (), - (ListNode.Cons(a, ar), ListNode.Cons(b, br)) => - match aggr_address_order(a, b) { - 0 => aggr_assert_disjoint(ar, right), - 1 => - assert_eq!(0, 1, "aggr: subject set overlaps assumption set"); - (), - _ => aggr_assert_disjoint(left, br), - }, - } - } - - -- Select the next unique value from the union of two sorted assumption - -- lists, tagging its origin (`0 = left only`, `1 = both`, `2 = right only`) - -- and returning the unconsumed tails. - fn aggr_next_assumption(left: List‹Addr›, right: List‹Addr›) - -> AggrNextAssumption { - match (load(left), load(right)) { - (ListNode.Nil, ListNode.Nil) => AggrNextAssumption.Done, - (ListNode.Cons(a, ar), ListNode.Nil) => - AggrNextAssumption.More(a, 0, ar, right), - (ListNode.Nil, ListNode.Cons(b, br)) => - AggrNextAssumption.More(b, 2, left, br), - (ListNode.Cons(a, ar), ListNode.Cons(b, br)) => - match aggr_address_order(a, b) { - 0 => AggrNextAssumption.More(a, 0, ar, right), - 1 => AggrNextAssumption.More(a, 1, ar, br), - _ => AggrNextAssumption.More(b, 2, left, br), - }, - } - } - - -- Find `target` in a sorted subject list, discarding subject values below it - -- and returning the suffix useful for the next (strictly larger) target. - fn aggr_seek_subject(target: Addr, subjects: List‹Addr›) - -> (G, List‹Addr›) { - match load(subjects) { - ListNode.Nil => (0, subjects), - ListNode.Cons(subject, rest) => - match aggr_address_order(subject, target) { - 0 => aggr_seek_subject(target, rest), - 1 => (1, rest), - _ => (0, subjects), - }, - } - } - - -- Assert `output = (left ∪ right) ∖ subjects`, all lists sorted and - -- duplicate-free. Subject scan state is threaded so the check is linear. - fn aggr_assert_difference(left: List‹Addr›, right: List‹Addr›, - subjects: List‹Addr›, output: List‹Addr›) { - match aggr_next_assumption(left, right) { - AggrNextAssumption.Done => - assert_eq!(load(output), ListNode.Nil, - "aggr: output has an extra assumption"); - (), - AggrNextAssumption.More(candidate, _source, left_rest, right_rest) => - let (discharged, subject_rest) = aggr_seek_subject(candidate, subjects); - match discharged { - 1 => aggr_assert_difference(left_rest, right_rest, subject_rest, output), - _ => - let ListNode.Cons(actual, output_rest) = load(output); - assert_eq!(address_eq(candidate, actual), 1, - "aggr: outstanding assumption mismatch"); - aggr_assert_difference(left_rest, right_rest, subject_rest, output_rest), - }, - } - } - - /- ## Structural assumption discharge - - Structural pairs do not open their subject trees. Channel 6 carries one - choice for every unique input-assumption candidate, keyed by the raw - candidate address. A carried candidate must occur next in the canonical - output-assumption list; a discharged candidate must supply a valid cross-child - Merkle path into the opposite child's subject root (`right_root` for a - left-only assumption, `left_root` for a right-only assumption) and step into - the one-hash structural output root. An assumption shared by both children - cannot be discharged and must be carried. - -/ - - fn aggr_fold_path(hash: Addr, remaining: G, stream: ByteStream) - -> (Addr, ByteStream) { - match remaining { - 0 => (hash, stream), - _ => - let (side, s1) = aggr_read_byte(stream); - assert_eq!(u8_less_than(side, 2u8), 1, - "aggr structural: path side must be 0 or 1"); - let (sibling, s2) = aggr_read_address(s1); - let parent = match side { - 0 => aggr_node_hash(sibling, hash), - _ => aggr_node_hash(hash, sibling), - }; - aggr_fold_path(parent, remaining - 1, s2), - } - } - - -- Return 1 when `candidate` is discharged by a cross-child path into the - -- opposite child's subject root (`right_root` for a left-only assumption, - -- `left_root` for a right-only assumption), or 0 when it is explicitly - -- carried. An assumption present in both children (`source == 1`) cannot be - -- discharged at this join and must be carried. The payload is strict: - -- carried: 0 - -- discharged: 1 || count:u8 || (side:u8 || sibling:32)* - fn aggr_discharge_choice(candidate: Addr, source: G, - left_root: Addr, right_root: Addr) -> G { - let (idx, len) = io_get_info(6, load(candidate)); - let bytes = read_checked_byte_stream(6, idx, len); - let (choice, rest) = aggr_read_byte(bytes); - assert_eq!(u8_less_than(choice, 2u8), 1, - "aggr structural: discharge choice must be 0 or 1"); - match choice { - 0 => - assert_eq!(load(rest), ListNode.Nil, - "aggr structural: carried choice has trailing bytes"); - 0, - _ => - let (count, path) = aggr_read_byte(rest); - assert_eq!(u8_less_than(0u8, count), 1, - "aggr structural: Merkle path must have at least 1 step"); - assert_eq!(u8_less_than(count, 65u8), 1, - "aggr structural: Merkle path exceeds 64 steps"); - let (child_actual, last_step) = aggr_fold_path(aggr_leaf_hash(candidate), - to_field(count) - 1, path); - let (last_side, s1) = aggr_read_byte(last_step); - let (last_sibling, stop) = aggr_read_address(s1); - assert_eq!(load(stop), ListNode.Nil, - "aggr structural: trailing bytes after Merkle path"); - match source { - 0 => - assert_eq!(last_side, 0u8, - "aggr structural: left assumption must be discharged by right child"); - assert_eq!(address_eq(last_sibling, left_root), 1, - "aggr structural: final step sibling is not left subject root"); - assert_eq!(address_eq(child_actual, right_root), 1, - "aggr structural: assumption path does not reach right subject root"); - 1, - 2 => - assert_eq!(last_side, 1u8, - "aggr structural: right assumption must be discharged by left child"); - assert_eq!(address_eq(last_sibling, right_root), 1, - "aggr structural: final step sibling is not right subject root"); - assert_eq!(address_eq(child_actual, left_root), 1, - "aggr structural: assumption path does not reach left subject root"); - 1, - _ => - assert_eq!(0, 1, - "aggr structural: shared assumption cannot be discharged"); - 0, - }, - } - } - - -- Every unique candidate from `left ∪ right` is either discharged by a - -- cross-child membership path or consumed from the strictly-sorted output list. - fn aggr_assert_structural_difference(left: List‹Addr›, right: List‹Addr›, - left_root: Addr, right_root: Addr, output: List‹Addr›) { - match aggr_next_assumption(left, right) { - AggrNextAssumption.Done => - assert_eq!(load(output), ListNode.Nil, - "aggr structural: output has an extra assumption"); - (), - AggrNextAssumption.More(candidate, source, left_rest, right_rest) => - match aggr_discharge_choice(candidate, source, left_root, right_root) { - 1 => aggr_assert_structural_difference(left_rest, right_rest, - left_root, right_root, output), - _ => - let ListNode.Cons(actual, output_rest) = load(output); - assert_eq!(address_eq(candidate, actual), 1, - "aggr structural: outstanding assumption mismatch"); - aggr_assert_structural_difference(left_rest, right_rest, - left_root, right_root, output_rest), - }, - } - } - - fn aggr_get_opt_address(stream: ByteStream) -> (Option‹Addr›, ByteStream) { - let (tag, rest) = aggr_read_byte(stream); - match tag { - 0 => (Option.None, rest), - 1 => - let (addr, stop) = aggr_read_address(rest); - (Option.Some(addr), stop), - } - } - - -- Strictly decode one complete `Claim::CheckEnv` byte string: its context - -- (specification digest, binding hash, axioms, validator), root and - -- assumptions. The fixed sequence and final Nil check rule out cycles in - -- preimages and output claims without a separate depth traversal. - fn aggr_parse_check_env(bytes: ByteStream) - -> ((Addr, Addr, Option‹Addr›, G), Addr, Option‹Addr›) { - -- TagN4(0xE, 5) is the one byte 0xE5; object format 4 is Ixon v4; - -- validator 3 is erased-lean-v2, whose claims carry a context, 4 - -- erased-lean-v2-assumed, whose claims assume their binding meets the - -- specifications, and 5 erased-lean-v2-class, whose context names a - -- literal class instead of a binding. - let (tag, s) = aggr_read_byte(bytes); - assert_eq!(tag, 0xE5u8, "aggr: claim is not CheckEnv"); - let (format, s) = aggr_read_byte(s); - assert_eq!(format, 4u8, "aggr: unsupported object format"); - let (validator_byte, s) = aggr_read_byte(s); - let validator = to_field(validator_byte); - assert_eq!((validator - 3) * (validator - 4) * (validator - 5), 0, - "aggr: wrong validator identity"); - let (spec, s) = aggr_read_address(s); - let (binding, s) = aggr_read_address(s); - let (axioms, s) = aggr_get_opt_address(s); - let (root, s2) = aggr_read_address(s); - let (assumptions, stop) = aggr_get_opt_address(s2); - assert_eq!(load(stop), ListNode.Nil, - "aggr: trailing bytes after CheckEnv claim"); - ((spec, binding, axioms, validator), root, assumptions) - } - - -- Strictly decode one complete `Claim::Binding` byte string: its - -- specification digest and binding hash. - fn aggr_parse_binding(bytes: ByteStream) -> (Addr, Addr) { - -- TagN4(0xE, 10) is the two bytes `E8 02`; validator 3. - let (tag0, s) = aggr_read_byte(bytes); - assert_eq!(tag0, 0xE8u8, "aggr: claim is not Binding"); - let (tag1, s) = aggr_read_byte(s); - assert_eq!(tag1, 0x02u8, "aggr: claim is not Binding"); - let (format, s) = aggr_read_byte(s); - assert_eq!(format, 4u8, "aggr: unsupported object format"); - let (validator, s) = aggr_read_byte(s); - assert_eq!(validator, 3u8, "aggr: wrong validator identity"); - let (spec, s) = aggr_read_address(s); - let (binding, stop) = aggr_read_address(s); - assert_eq!(load(stop), ListNode.Nil, - "aggr: trailing bytes after Binding claim"); - (spec, binding) - } - - -- Strictly decode one complete `Claim::Catalog` byte string: its members - -- root, the canonical tree of the member claims' digests. - fn aggr_parse_catalog(bytes: ByteStream) -> Addr { - -- TagN4(0xE, 8) is the two bytes `E8 00`; validator 3. - let (tag0, s) = aggr_read_byte(bytes); - assert_eq!(tag0, 0xE8u8, "aggr: claim is not Catalog"); - let (tag1, s) = aggr_read_byte(s); - assert_eq!(tag1, 0x00u8, "aggr: claim is not Catalog"); - let (format, s) = aggr_read_byte(s); - assert_eq!(format, 4u8, "aggr: unsupported object format"); - let (validator, s) = aggr_read_byte(s); - assert_eq!(validator, 3u8, "aggr: wrong validator identity"); - let (members, stop) = aggr_read_address(s); - assert_eq!(load(stop), ListNode.Nil, - "aggr: trailing bytes after Catalog claim"); - members - } - - fn aggr_opt_address_eq(a: Option‹Addr›, b: Option‹Addr›) -> G { - match a { - Option.None => - match b { - Option.None => 1, - Option.Some(_) => 0, - }, - Option.Some(x) => - match b { - Option.None => 0, - Option.Some(y) => address_eq(x, y), - }, - } - } - - -- A fold states its children's typing under one context: both children - -- and the output must carry the same specification digest, binding hash, - -- axioms and validator, so a fold never mixes claims that assume their - -- binding with claims that validate it. - fn aggr_assert_same_context(a: (Addr, Addr, Option‹Addr›, G), - b: (Addr, Addr, Option‹Addr›, G)) { - let (spec_a, binding_a, axioms_a, validator_a) = a; - let (spec_b, binding_b, axioms_b, validator_b) = b; - assert_eq!(address_eq(spec_a, spec_b), 1, - "aggr: claims differ in specification digest"); - assert_eq!(address_eq(binding_a, binding_b), 1, - "aggr: claims differ in binding hash"); - assert_eq!(aggr_opt_address_eq(axioms_a, axioms_b), 1, - "aggr: claims differ in axioms"); - assert_eq!(validator_a, validator_b, - "aggr: claims differ in whether they assume their binding"); - () - } - - /- ## Digest-bound advice and claim decoding -/ - - fn aggr_load_preimage(digest: [G; 8]) -> ByteStream { - let (idx, len) = io_get_info(4, digest); - let bytes = read_checked_byte_stream(4, idx, len); - assert_eq!(@b3_pack(@blake3(bytes)), digest, - "aggr: claim preimage digest mismatch"); - bytes - } - - fn aggr_claim_field(claim: List‹U64›, index: G) -> G { - @gl_val(list_lookup(claim, index)) - } - - fn aggr_claim_digest(claim: List‹U64›, start: G) -> [G; 8] { - [aggr_claim_field(claim, start), - aggr_claim_field(claim, start + 1), - aggr_claim_field(claim, start + 2), - aggr_claim_field(claim, start + 3), - aggr_claim_field(claim, start + 4), - aggr_claim_field(claim, start + 5), - aggr_claim_field(claim, start + 6), - aggr_claim_field(claim, start + 7)] - } - - fn aggr_assert_digest(actual: [G; 8], expected: [G; 8]) { - assert_eq!(actual[0], expected[0]); - assert_eq!(actual[1], expected[1]); - assert_eq!(actual[2], expected[2]); - assert_eq!(actual[3], expected[3]); - assert_eq!(actual[4], expected[4]); - assert_eq!(actual[5], expected[5]); - assert_eq!(actual[6], expected[6]); - assert_eq!(actual[7], expected[7]); - () - } - - fn aggr_only_claim(claims: List‹List‹U64››) -> List‹U64› { - let ListNode.Cons(claim, rest) = load(claims); - assert_eq!(load(rest), ListNode.Nil, - "aggr: child proof must expose exactly one claim"); - claim - } - - /- ## Heterogeneous child verification - - Child kind 0 verifies against the IxVM system, kind 1 against this circuit's - own system. Which system a proof MUST verify against is fixed by the kind: - the vk bytes on channel 1 are digest-checked against the corresponding half - of the allowed blob before deserialization, so a hinted kind that does not - match the child proof fails verification. - -/ - - fn aggr_load_sys(kind: G, ixvm_vk_digest: [G; 8], self_vk_digest: [G; 8]) - -> Sys { - -- The checked reader proves the key bytes finite and below 256, so the - -- digest pins every field read_system parses from them; read_system - -- also checks expression-graph acyclicity. - let (sidx, slen) = io_get_info(1, [kind]); - let sbytes = read_checked_byte_stream(1, sidx, slen); - let digest = @b3_pack(@blake3(sbytes)); - match kind { - 0 => - aggr_assert_digest(digest, ixvm_vk_digest), - _ => - aggr_assert_digest(digest, self_vk_digest), - }; - let (sys, srest) = @read_system(sbytes); - assert_eq!(load(srest), ListNode.Nil); - sys - } - - -- Verify one child (a batch of trace shards) against `sys`. The batch's - -- headers carry the child claims and the batch transcript binds them, so - -- they need no standalone public digest; the channel-2 copy is checked - -- equal to them. read_claims uses constrained countdowns; the final Nil - -- check rules out cyclic cbytes before they can enter the transcript. - fn aggr_verify_child(sys: Sys, key: G) -> List‹List‹U64›› { - let (idx, len) = io_get_info(0, [key]); - let (cidx, clen) = io_get_info(2, [key]); - let cbytes = read_checked_byte_stream(2, cidx, clen); - let (claims, crest) = @read_claims(cbytes); - assert_eq!(load(crest), ListNode.Nil); - assert_eq!(@verify_batch_at(sys, idx, len, claims), 1); - claims - } - - -- Verify the child at `key` as the hinted `kind` and return the packed - -- digest of its `CheckEnv` claim bytes. - -- - -- * kind 0 (IxVM): the 10-word `verify_claim` claim carries the `CheckEnv` - -- digest as its public input. - -- * kind 1 (self): the 18-word `ix_aggr` claim must bind THIS aggregation - -- identity (`allowed_digest`), pinning both vks and both entrypoint - -- indices transitively; its output digest is the child's `CheckEnv`. - fn aggr_child_check_env_digest(kind: G, key: G, - ixvm_vk_digest: [G; 8], self_vk_digest: [G; 8], - verify_idx: G, aggr_idx: G, allowed_digest: [G; 8]) -> [G; 8] { - let sys = aggr_load_sys(kind, ixvm_vk_digest, self_vk_digest); - let claim = aggr_only_claim(aggr_verify_child(sys, key)); - assert_eq!(aggr_claim_field(claim, 0), 0, - "aggr: child has the wrong claim channel"); - match kind { - 0 => - assert_eq!(list_length(claim), 10, - "aggr: IxVM child must expose a 10-word verify_claim claim"); - assert_eq!(aggr_claim_field(claim, 1), verify_idx, - "aggr: IxVM child has the wrong entrypoint"); - aggr_claim_digest(claim, 2), - _ => - assert_eq!(list_length(claim), 18, - "aggr: recursive child must expose an 18-word ix_aggr claim"); - assert_eq!(aggr_claim_field(claim, 1), aggr_idx, - "aggr: recursive child has the wrong entrypoint"); - aggr_assert_digest(aggr_claim_digest(claim, 2), allowed_digest); - aggr_claim_digest(claim, 10), - } - } - - /- ## Shapes -/ - - -- Wrap: one child, output statement identical to the child's. Digest - -- equality is byte equality (Blake3), so nothing needs to be opened. - fn aggr_wrap(kind: G, ixvm_vk_digest: [G; 8], self_vk_digest: [G; 8], - verify_idx: G, aggr_idx: G, allowed_digest: [G; 8], - out_claim_digest: [G; 8]) { - let child = aggr_child_check_env_digest(kind, 0, - ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); - aggr_assert_digest(child, out_claim_digest) - } - - -- Pair: two children, canonical set-discharge fold. - fn aggr_pair(left_kind: G, right_kind: G, - ixvm_vk_digest: [G; 8], self_vk_digest: [G; 8], - verify_idx: G, aggr_idx: G, allowed_digest: [G; 8], - out_claim_digest: [G; 8]) { - let left_digest = aggr_child_check_env_digest(left_kind, 0, - ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); - let right_digest = aggr_child_check_env_digest(right_kind, 1, - ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); - let (left_ctx, left_root, left_asm) = - aggr_parse_check_env(aggr_load_preimage(left_digest)); - let (right_ctx, right_root, right_asm) = - aggr_parse_check_env(aggr_load_preimage(right_digest)); - - -- Bind and decode this fold's output claim. - let (oidx, olen) = io_get_info(2, [2]); - let output_bytes = read_checked_byte_stream(2, oidx, olen); - assert_eq!(@b3_pack(@blake3(output_bytes)), out_claim_digest, - "aggr: output claim digest mismatch"); - let (output_ctx, output_root, output_asm) = aggr_parse_check_env(output_bytes); - aggr_assert_same_context(left_ctx, right_ctx); - aggr_assert_same_context(left_ctx, output_ctx); - - let left_subjects = aggr_load_canonical_tree(left_root); - let right_subjects = aggr_load_canonical_tree(right_root); - let left_assumptions = aggr_load_optional_tree(left_asm); - let right_assumptions = aggr_load_optional_tree(right_asm); - let output_subjects = aggr_load_canonical_tree(output_root); - let output_assumptions = aggr_load_optional_tree(output_asm); - - aggr_assert_disjoint(left_subjects, left_assumptions); - aggr_assert_disjoint(right_subjects, right_assumptions); - aggr_assert_disjoint_union(left_subjects, right_subjects, output_subjects); - aggr_assert_difference(left_assumptions, right_assumptions, - output_subjects, output_assumptions); - () - } - - -- Structural pair: verify the same heterogeneous child forms, commit to - -- subjects with one free-form node hash, and discharge assumptions through - -- channel-6 Merkle paths. Only canonical assumption trees are opened. - fn aggr_pair_structural(left_kind: G, right_kind: G, - ixvm_vk_digest: [G; 8], self_vk_digest: [G; 8], - verify_idx: G, aggr_idx: G, allowed_digest: [G; 8], - out_claim_digest: [G; 8]) { - let left_digest = aggr_child_check_env_digest(left_kind, 0, - ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); - let right_digest = aggr_child_check_env_digest(right_kind, 1, - ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); - let (left_ctx, left_root, left_asm) = - aggr_parse_check_env(aggr_load_preimage(left_digest)); - let (right_ctx, right_root, right_asm) = - aggr_parse_check_env(aggr_load_preimage(right_digest)); - - let (oidx, olen) = io_get_info(2, [2]); - let output_bytes = read_checked_byte_stream(2, oidx, olen); - assert_eq!(@b3_pack(@blake3(output_bytes)), out_claim_digest, - "aggr structural: output claim digest mismatch"); - let (output_ctx, output_root, output_asm) = aggr_parse_check_env(output_bytes); - aggr_assert_same_context(left_ctx, right_ctx); - aggr_assert_same_context(left_ctx, output_ctx); - - assert_eq!(address_eq(left_root, right_root), 0, - "aggr structural: child subject roots must be distinct"); - let expected_root = aggr_node_hash(left_root, right_root); - assert_eq!(address_eq(output_root, expected_root), 1, - "aggr structural: output subject root is not nodeHash(left, right)"); - - let left_assumptions = aggr_load_optional_tree(left_asm); - let right_assumptions = aggr_load_optional_tree(right_asm); - let output_assumptions = aggr_load_optional_tree(output_asm); - aggr_assert_structural_difference(left_assumptions, right_assumptions, - left_root, right_root, output_assumptions); - () - } - - -- Binding discharge: a `CheckEnv` child that assumes its binding (key 0, - -- of the hinted kind) and an IxVM proof of the `Binding` claim for its - -- specification digest and binding hash (key 1). The output is the - -- child's claim validating its binding: the same bytes with validator 3. - -- Folds keep the validator, so an aggregate discharges once, at the top. - fn aggr_discharge_binding(kind: G, - ixvm_vk_digest: [G; 8], self_vk_digest: [G; 8], - verify_idx: G, aggr_idx: G, allowed_digest: [G; 8], - out_claim_digest: [G; 8]) { - let child_digest = aggr_child_check_env_digest(kind, 0, - ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); - let binding_digest = aggr_child_check_env_digest(0, 1, - ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); - let (child_ctx, child_root, child_asm) = - aggr_parse_check_env(aggr_load_preimage(child_digest)); - let (spec, binding, axioms, validator) = child_ctx; - assert_eq!(validator, 4, - "aggr discharge: the claim does not assume its binding"); - let (bound_spec, bound_binding) = - aggr_parse_binding(aggr_load_preimage(binding_digest)); - assert_eq!(address_eq(spec, bound_spec), 1, - "aggr discharge: the binding claim is for another specification digest"); - assert_eq!(address_eq(binding, bound_binding), 1, - "aggr discharge: the binding claim is for another binding"); - - let (oidx, olen) = io_get_info(2, [2]); - let output_bytes = read_checked_byte_stream(2, oidx, olen); - assert_eq!(@b3_pack(@blake3(output_bytes)), out_claim_digest, - "aggr discharge: output claim digest mismatch"); - let (output_ctx, output_root, output_asm) = aggr_parse_check_env(output_bytes); - aggr_assert_same_context((spec, binding, axioms, 3), output_ctx); - assert_eq!(address_eq(child_root, output_root), 1, - "aggr discharge: output subject root differs from the child's"); - assert_eq!(aggr_opt_address_eq(child_asm, output_asm), 1, - "aggr discharge: output assumptions differ from the child's"); - () - } - - /- ## Claims under different role bindings - - A role binding's literal class (`Ix.ClaimContext.literalClassOf`) is the - BLAKE3 of `E8 04` followed by the addresses it binds to the twelve roles the - checker uses without a reference to them, in role order: `Nat`, `Nat.zero`, - `Nat.succ`, `List`, `List.nil`, `List.cons`, `String`, `String.ofList`, - `Char`, `Char.ofNat`, `propext` and `Classical.choice`, at role indices 0, - 1, 2, 29, 30, 31, 37, 38, 39, 40, 56 and 57. A claim that validates its - binding (validator 3) names the binding hash; its class is read from the - binding section (channel 4, keyed by the binding hash, so its BLAKE3 is - checked), which must bind all 103 roles, one entry per role in order. - -/ - - -- 1 for the role indices of the literal class. - fn aggr_is_class_role(i: G) -> G { - match i { - 0 => 1, - 1 => 1, - 2 => 1, - 29 => 1, - 30 => 1, - 31 => 1, - 37 => 1, - 38 => 1, - 39 => 1, - 40 => 1, - 56 => 1, - 57 => 1, - _ => 0, - } - } - - -- The class roles' addresses from the bound entries `i` to 102 of a - -- complete binding section, each entry its role index then its address. - fn aggr_class_walk(stream: ByteStream, i: G, remaining: G) -> List‹Addr› { - match remaining { - 0 => store(ListNode.Nil), - _ => - let (role, s) = aggr_read_byte(stream); - assert_eq!(to_field(role), i, - "aggr cross-binding: the binding does not bind every role in order"); - let (addr, s2) = aggr_read_address(s); - let rest = aggr_class_walk(s2, i + 1, remaining - 1); - match aggr_is_class_role(i) { - 1 => store(ListNode.Cons(addr, rest)), - _ => rest, - }, - } - } - - fn aggr_put_addresses(addrs: List‹Addr›, tail: ByteStream) -> ByteStream { - match load(addrs) { - ListNode.Nil => tail, - ListNode.Cons(a, rest) => aggr_put_address(a, aggr_put_addresses(rest, tail)), - } - } - - -- The literal class of the binding section with hash `binding`. - fn aggr_binding_class(binding: Addr) -> Addr { - let bytes = aggr_load_preimage(aggr_pack_address(binding)); - let (tag0, s) = aggr_read_byte(bytes); - assert_eq!(tag0, 0xE8u8, "aggr cross-binding: not a role binding section"); - let (tag1, s) = aggr_read_byte(s); - assert_eq!(tag1, 0x03u8, "aggr cross-binding: not a role binding section"); - let (_version, s) = aggr_read_byte(s); - let (count, s) = aggr_read_byte(s); - assert_eq!(count, 103u8, - "aggr cross-binding: the binding does not bind every role"); - let addrs = aggr_class_walk(s, 0, 103); - let body = aggr_put_addresses(addrs, store(ListNode.Nil)); - bytes_to_addr(store(ListNode.Cons(0xE8u8, store(ListNode.Cons(0x04u8, body))))) - } - - -- The literal class of a `CheckEnv` claim's context: read from its - -- binding (validator 3) or named by it (validator 5). A claim that - -- assumes its binding (validator 4) is refused: discharge it first. - fn aggr_context_class(ctx: (Addr, Addr, Option‹Addr›, G)) -> Addr { - let (_spec, binding, _axioms, validator) = ctx; - assert_eq!((validator - 3) * (validator - 5), 0, - "aggr cross-binding: the claim assumes its binding"); - match validator { - 5 => binding, - _ => aggr_binding_class(binding), - } - } - - -- Cross-binding structural pair: two `ix_aggr` children whose bindings - -- have one literal class. The output names the class (validator 5), with - -- the children's specification digest and axioms, subjects - -- `nodeHash(left, right)` and the structural difference of the - -- assumptions, as in `aggr_pair_structural`. - fn aggr_cross_binding(ixvm_vk_digest: [G; 8], self_vk_digest: [G; 8], - verify_idx: G, aggr_idx: G, allowed_digest: [G; 8], - out_claim_digest: [G; 8]) { - let left_digest = aggr_child_check_env_digest(1, 0, - ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); - let right_digest = aggr_child_check_env_digest(1, 1, - ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); - let (left_ctx, left_root, left_asm) = - aggr_parse_check_env(aggr_load_preimage(left_digest)); - let (right_ctx, right_root, right_asm) = - aggr_parse_check_env(aggr_load_preimage(right_digest)); - let left_class = aggr_context_class(left_ctx); - let right_class = aggr_context_class(right_ctx); - assert_eq!(address_eq(left_class, right_class), 1, - "aggr cross-binding: the bindings' literal classes differ"); - let (left_spec, _lb, left_axioms, _lv) = left_ctx; - let (right_spec, _rb, right_axioms, _rv) = right_ctx; - - let (oidx, olen) = io_get_info(2, [2]); - let output_bytes = read_checked_byte_stream(2, oidx, olen); - assert_eq!(@b3_pack(@blake3(output_bytes)), out_claim_digest, - "aggr cross-binding: output claim digest mismatch"); - let (output_ctx, output_root, output_asm) = aggr_parse_check_env(output_bytes); - aggr_assert_same_context((left_spec, left_class, left_axioms, 5), output_ctx); - aggr_assert_same_context((right_spec, right_class, right_axioms, 5), output_ctx); - - assert_eq!(address_eq(left_root, right_root), 0, - "aggr cross-binding: child subject roots must be distinct"); - let expected_root = aggr_node_hash(left_root, right_root); - assert_eq!(address_eq(output_root, expected_root), 1, - "aggr cross-binding: output subject root is not nodeHash(left, right)"); - let left_assumptions = aggr_load_optional_tree(left_asm); - let right_assumptions = aggr_load_optional_tree(right_asm); - let output_assumptions = aggr_load_optional_tree(output_asm); - aggr_assert_structural_difference(left_assumptions, right_assumptions, - left_root, right_root, output_assumptions); - () - } - - -- The member statements a catalog join's child contributes, sorted: an - -- unconditional `CheckEnv` claim that validates its binding or names a - -- literal class contributes its own digest, a `Catalog` claim the leaves of - -- its members tree. - fn aggr_catalog_part(digest: [G; 8]) -> List‹Addr› { - let bytes = aggr_load_preimage(digest); - let (tag, _rest) = aggr_read_byte(bytes); - match tag { - 229 => - let (ctx, _root, asm) = aggr_parse_check_env(bytes); - let (_spec, _binding, _axioms, validator) = ctx; - assert_eq!((validator - 3) * (validator - 5), 0, - "aggr catalog: a member claim assumes its binding"); - assert_eq!(aggr_opt_address_eq(asm, Option.None), 1, - "aggr catalog: a member claim has assumptions"); - store(ListNode.Cons(bytes_to_addr(bytes), store(ListNode.Nil))), - _ => aggr_load_canonical_tree(aggr_parse_catalog(bytes)), - } - } - - -- Catalog join: two `ix_aggr` children, each a member claim or a catalog; - -- the output `Catalog` claim's members are the union of theirs. - fn aggr_catalog_join(ixvm_vk_digest: [G; 8], self_vk_digest: [G; 8], - verify_idx: G, aggr_idx: G, allowed_digest: [G; 8], - out_claim_digest: [G; 8]) { - let left_digest = aggr_child_check_env_digest(1, 0, - ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); - let right_digest = aggr_child_check_env_digest(1, 1, - ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); - let left = aggr_catalog_part(left_digest); - let right = aggr_catalog_part(right_digest); - - let (oidx, olen) = io_get_info(2, [2]); - let output_bytes = read_checked_byte_stream(2, oidx, olen); - assert_eq!(@b3_pack(@blake3(output_bytes)), out_claim_digest, - "aggr catalog: output claim digest mismatch"); - let output = aggr_load_canonical_tree(aggr_parse_catalog(output_bytes)); - aggr_assert_union(left, right, output); - () - } - - /- ## Range-sum recursion over one IxVM batch - - A batch of K trace shards balances when the shards' residuals plus the - preamble messages' contribution sum to zero under the batch challenges. - The whole-batch check is `verify_batch`; the range shapes split it so no - single recursion proof has to verify every shard of a large batch: - - * a **range leaf** (shape 10) verifies shards `[lo, hi)` and states their - residual sum; - * a **range join** (shape 11) adds two adjacent ranges of the same batch; - * a **range root** (shape 12) checks that one range covers `[0, K)`, adds - the messages' contribution, demands zero, and re-emits the batch's one - IxVM claim exactly as a wrap (shape 0) of that batch would. - - Every range node binds the batch by `D = blake3(preamble bytes)`, the - bincode of the headers and messages. Leaves and the root parse the - preamble from the hashed byte stream itself — never through the - unconstrained offset readers — so the headers that fix the challenges are - the ones `D` names. The range statement is - - `0x52 ‖ D(32) ‖ lo(u64 LE) ‖ hi(u64 LE) ‖ r0(u64 LE) ‖ r1(u64 LE)` - - and travels as a node's output digest, opened on channel 4 like a - `CheckEnv` preimage; its tag keeps it from ever parsing as one. - -/ - - fn aggr_parse_range(bytes: ByteStream) -> (Addr, U64, U64, Ext) { - let (tag, s) = aggr_read_byte(bytes); - assert_eq!(tag, 0x52u8, "aggr range: statement has the wrong tag"); - let (d, s2) = aggr_read_address(s); - let (lo, s3) = @read_u64(s2); - let (hi, s4) = @read_u64(s3); - let (r0, s5) = @read_u64(s4); - let (r1, stop) = @read_u64(s5); - assert_eq!(load(stop), ListNode.Nil, - "aggr range: trailing bytes after the statement"); - (d, lo, hi, [@gl_val(r0), @gl_val(r1)]) - } - - -- Stream readers for the batch preamble, `Vec` then - -- `Vec` in bincode's fixed-int little-endian encoding. - fn aggr_read_digest(s: ByteStream) -> (DigestP, ByteStream) { - let (a, s1) = @read_u64(s); - let (b, s2) = @read_u64(s1); - let (c, s3) = @read_u64(s2); - let (d, s4) = @read_u64(s3); - (store([a, b, c, d]), s4) - } - fn aggr_read_cap_n(s: ByteStream, n: G) -> (MerkleCap, ByteStream) { - match n { - 0 => (store(ListNode.Nil), s), - _ => - let (x, s1) = aggr_read_digest(s); - let (rest, s2) = aggr_read_cap_n(s1, n - 1); - (store(ListNode.Cons(x, rest)), s2), - } - } - fn aggr_read_bits_n(s: ByteStream, n: G) -> (List‹G›, ByteStream) { - match n { - 0 => (store(ListNode.Nil), s), - _ => - let (b, s1) = aggr_read_byte(s); - let (rest, s2) = aggr_read_bits_n(s1, n - 1); - (store(ListNode.Cons(to_field(b), rest)), s2), - } - } - fn aggr_read_bytes_n(s: ByteStream, n: G) -> (List‹U8›, ByteStream) { - match n { - 0 => (store(ListNode.Nil), s), - _ => - let (b, s1) = aggr_read_byte(s); - let (rest, s2) = aggr_read_bytes_n(s1, n - 1); - (store(ListNode.Cons(b, rest)), s2), - } - } - fn aggr_read_header(s: ByteStream) -> (ShardHeader, ByteStream) { - let (na, s1) = @read_count(s); - let (active, s2) = aggr_read_bits_n(s1, na); - let (nc, s3) = @read_count(s2); - let (cap, s4) = aggr_read_cap_n(s3, nc); - let (nl, s5) = @read_count(s4); - let (lds, s6) = aggr_read_bytes_n(s5, nl); - let (claims, s7) = @read_claims(s6); - (ShardHeader.Mk(active, cap, lds, claims), s7) - } - fn aggr_read_headers_n(s: ByteStream, n: G) -> (List‹ShardHeader›, ByteStream) { - match n { - 0 => (store(ListNode.Nil), s), - _ => - let (h, s1) = aggr_read_header(s); - let (rest, s2) = aggr_read_headers_n(s1, n - 1); - (store(ListNode.Cons(h, rest)), s2), - } - } - fn aggr_read_message(s: ByteStream) -> (BatchMessage, ByteStream) { - let (args, s1) = @read_one_claim(s); - let (mult, s2) = @read_u64(s1); - (BatchMessage.Mk(args, mult), s2) - } - fn aggr_read_messages_n(s: ByteStream, n: G) -> (List‹BatchMessage›, ByteStream) { - match n { - 0 => (store(ListNode.Nil), s), - _ => - let (m, s1) = aggr_read_message(s); - let (rest, s2) = aggr_read_messages_n(s1, n - 1); - (store(ListNode.Cons(m, rest)), s2), - } - } - - -- The preamble on channel 0 at `key`, bound to the batch digest `d` and - -- parsed from the hashed stream. - fn aggr_load_preamble(key: G, d: Addr) -> (List‹ShardHeader›, List‹BatchMessage›) { - let (idx, len) = io_get_info(0, [key]); - let bytes = read_checked_byte_stream(0, idx, len); - assert_eq!(address_eq(bytes_to_addr(bytes), d), 1, - "aggr range: preamble does not hash to the statement's batch digest"); - let (nh, s1) = @read_count(bytes); - let (headers, s2) = aggr_read_headers_n(s1, nh); - let (nm, s3) = @read_count(s2); - let (messages, stop) = aggr_read_messages_n(s3, nm); - assert_eq!(load(stop), ListNode.Nil, - "aggr range: trailing bytes after the preamble"); - (headers, messages) - } - - -- The batch challenges from the IxVM system and the preamble. - fn aggr_batch_challenges(sys: Sys, headers: List‹ShardHeader›, - messages: List‹BatchMessage›) -> (Ext, Ext, ByteStream) { - let Sys.Mk(_params, tlimbs, _circuits, commit, _prep_indices) = sys; - let prep_cap = @opt_commit_cap(commit); - batch_fiat_shamir(tlimbs, prep_cap, headers, messages) - } - - -- Verify `n` consecutive shards from header list `headers` and channel-0 - -- offset `i`, the first being shard `shard`, accumulating residuals. - -- Returns the sum and the offset after the last proof. - fn aggr_verify_range(sys: Sys, headers: List‹ShardHeader›, i: G, shard: G, - n: G, input: ByteStream, lch: Ext, fch: Ext, acc: Ext) -> (Ext, G) { - match n { - 0 => (acc, i), - _ => - let ListNode.Cons(h, hrest) = load(headers); - let (p, j) = read_proof(i); - let r = verify_shard(sys, h, shard, p, input, lch, fch); - aggr_verify_range(sys, hrest, j, shard + 1, n - 1, input, lch, fch, - @eg_add(acc, r)), - } - } - - -- The output statement of a range node: channel 2 key 2, digest-bound. - fn aggr_output_range(out_claim_digest: [G; 8]) -> (Addr, U64, U64, Ext) { - let (oidx, olen) = io_get_info(2, [2]); - let output_bytes = read_checked_byte_stream(2, oidx, olen); - assert_eq!(@b3_pack(@blake3(output_bytes)), out_claim_digest, - "aggr range: output statement digest mismatch"); - aggr_parse_range(output_bytes) - } - - -- A verified self child at `key` whose output is a range statement. - fn aggr_child_range(key: G, ixvm_vk_digest: [G; 8], self_vk_digest: [G; 8], - verify_idx: G, aggr_idx: G, allowed_digest: [G; 8]) - -> (Addr, U64, U64, Ext) { - let digest = aggr_child_check_env_digest(1, key, - ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); - aggr_parse_range(aggr_load_preimage(digest)) - } - - -- Range leaf: the preamble on channel 0 key 0, the proofs of shards - -- `[lo, hi)` as a length-prefixed vector on channel 0 key 1. - fn aggr_range_leaf(ixvm_vk_digest: [G; 8], self_vk_digest: [G; 8], - out_claim_digest: [G; 8]) { - let sys = aggr_load_sys(0, ixvm_vk_digest, self_vk_digest); - let (d, lo_limb, hi_limb, r) = aggr_output_range(out_claim_digest); - let (headers, messages) = aggr_load_preamble(0, d); - let (lch, fch, input) = aggr_batch_challenges(sys, headers, messages); - assert_eq!(bytes8_le(lo_limb, hi_limb), 1, - "aggr range: the range ends before it starts"); - let lo = flatten_u64(lo_limb); - let n = flatten_u64(hi_limb) - lo; - let (pidx, plen) = io_get_info(0, [1]); - let (count, j) = read_count_at(pidx); - assert_eq!(count, n, "aggr range: proof count differs from the range"); - let (total, stop) = aggr_verify_range(sys, list_drop(headers, lo), j, lo, - n, input, lch, fch, [0, 0]); - assert_eq!(stop, pidx + plen, "aggr range: trailing bytes after the proofs"); - assert_eq!(@eg_eq(total, r), 1, - "aggr range: residual sum differs from the statement"); - () - } - - -- Range join: two self children over adjacent ranges of one batch. - fn aggr_range_join(ixvm_vk_digest: [G; 8], self_vk_digest: [G; 8], - verify_idx: G, aggr_idx: G, allowed_digest: [G; 8], - out_claim_digest: [G; 8]) { - let (ld, llo, lhi, lr) = aggr_child_range(0, - ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); - let (rd, rlo, rhi, rr) = aggr_child_range(1, - ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); - let (d, lo, hi, r) = aggr_output_range(out_claim_digest); - assert_eq!(address_eq(ld, rd), 1, - "aggr range: children verify different batches"); - assert_eq!(address_eq(d, ld), 1, - "aggr range: output names a different batch than the children"); - assert_eq!(flatten_u64(lhi), flatten_u64(rlo), - "aggr range: children are not adjacent"); - assert_eq!(flatten_u64(lo), flatten_u64(llo), - "aggr range: output starts elsewhere than the left child"); - assert_eq!(flatten_u64(hi), flatten_u64(rhi), - "aggr range: output ends elsewhere than the right child"); - assert_eq!(@eg_eq(@eg_add(lr, rr), r), 1, - "aggr range: output residual is not the children's sum"); - () - } - - -- Range root: one self child covering `[0, K)` on channel 0 key 0, the - -- preamble on channel 0 key 1. Emits the batch's IxVM claim digest. - fn aggr_range_root(ixvm_vk_digest: [G; 8], self_vk_digest: [G; 8], - verify_idx: G, aggr_idx: G, allowed_digest: [G; 8], - out_claim_digest: [G; 8]) { - let (d, lo, hi, r) = aggr_child_range(0, - ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); - let sys = aggr_load_sys(0, ixvm_vk_digest, self_vk_digest); - let (headers, messages) = aggr_load_preamble(1, d); - let k = list_length(headers); - assert_eq!(assert_shard_count_ok(k), 1); - assert_eq!(flatten_u64(lo), 0, - "aggr range: root range does not start at shard 0"); - assert_eq!(flatten_u64(hi), k, - "aggr range: root range does not end at the last shard"); - assert_eq!(assert_closure_pairs(messages, 0, 0), 1); - let (lch, fch, _input) = aggr_batch_challenges(sys, headers, messages); - let total = messages_acc(r, messages, lch, fch); - assert_eq!(@ext_is_zero(total), 1, "aggr range: the batch does not balance"); - let claim = aggr_only_claim(batch_claims(headers)); - assert_eq!(list_length(claim), 10, - "aggr range: batch must carry a 10-word verify_claim claim"); - assert_eq!(aggr_claim_field(claim, 0), 0, - "aggr range: batch claim has the wrong channel"); - assert_eq!(aggr_claim_field(claim, 1), verify_idx, - "aggr range: batch claim has the wrong entrypoint"); - aggr_assert_digest(aggr_claim_digest(claim, 2), out_claim_digest) - } - - /- ## Entrypoint -/ - - -- Public input is `blake3(allowed_blob) ‖ blake3(output_claim_bytes)`, - -- packed four bytes per Goldilocks element. - pub fn ix_aggr(allowed_digest: [G; 8], out_claim_digest: [G; 8]) { - -- Allowed blob: - -- ixvm_vk_digest(32) ‖ verify_idx(u64 LE) ‖ - -- self_vk_digest(32) ‖ aggr_idx(u64 LE). - let (aidx, alen) = io_get_info(3, [0]); - assert_eq!(alen, 80, - "aggr: allowed blob must be exactly 80 bytes"); - let allowed_bytes = read_checked_byte_stream(3, aidx, alen); - assert_eq!(@b3_pack(@blake3(allowed_bytes)), allowed_digest, - "aggr: allowed blob digest mismatch"); - let (ixvm_digest_addr, as1) = aggr_read_address(allowed_bytes); - let (verify_idx_limb, as2) = @read_u64(as1); - let (self_digest_addr, as3) = aggr_read_address(as2); - let (aggr_idx_limb, astop) = @read_u64(as3); - assert_eq!(load(astop), ListNode.Nil, - "aggr: allowed blob must be exactly 80 bytes"); - let ixvm_vk_digest = aggr_pack_address(ixvm_digest_addr); - let self_vk_digest = aggr_pack_address(self_digest_addr); - let verify_idx = flatten_u64(verify_idx_limb); - let aggr_idx = flatten_u64(aggr_idx_limb); - - -- Shape hint: exactly one advice byte. - -- 0 = wrap IxVM 1 = wrap self - -- 2–5 = flat pairs: 2 + 2·left + right - -- 6–9 = structural pairs: 6 + 2·left + right - -- 10 = range leaf 11 = range join 12 = range root - -- 13 = binding discharge of an IxVM child - -- 14 = binding discharge of a self child - -- 15 = cross-binding structural pair (self children) - -- 16 = catalog join (self children) - let (hidx, hlen) = io_get_info(6, [0]); - assert_eq!(hlen, 1, "aggr: shape hint must be exactly one byte"); - let hint = read_checked_byte_stream(6, hidx, hlen); - let (shape, hstop) = aggr_read_byte(hint); - assert_eq!(load(hstop), ListNode.Nil, - "aggr: trailing bytes after shape hint"); - match shape { - 0 => aggr_wrap(0, ixvm_vk_digest, self_vk_digest, - verify_idx, aggr_idx, allowed_digest, out_claim_digest), - 1 => aggr_wrap(1, ixvm_vk_digest, self_vk_digest, - verify_idx, aggr_idx, allowed_digest, out_claim_digest), - 2 => aggr_pair(0, 0, ixvm_vk_digest, self_vk_digest, - verify_idx, aggr_idx, allowed_digest, out_claim_digest), - 3 => aggr_pair(0, 1, ixvm_vk_digest, self_vk_digest, - verify_idx, aggr_idx, allowed_digest, out_claim_digest), - 4 => aggr_pair(1, 0, ixvm_vk_digest, self_vk_digest, - verify_idx, aggr_idx, allowed_digest, out_claim_digest), - 5 => aggr_pair(1, 1, ixvm_vk_digest, self_vk_digest, - verify_idx, aggr_idx, allowed_digest, out_claim_digest), - 6 => aggr_pair_structural(0, 0, ixvm_vk_digest, self_vk_digest, - verify_idx, aggr_idx, allowed_digest, out_claim_digest), - 7 => aggr_pair_structural(0, 1, ixvm_vk_digest, self_vk_digest, - verify_idx, aggr_idx, allowed_digest, out_claim_digest), - 8 => aggr_pair_structural(1, 0, ixvm_vk_digest, self_vk_digest, - verify_idx, aggr_idx, allowed_digest, out_claim_digest), - 9 => aggr_pair_structural(1, 1, ixvm_vk_digest, self_vk_digest, - verify_idx, aggr_idx, allowed_digest, out_claim_digest), - 10 => aggr_range_leaf(ixvm_vk_digest, self_vk_digest, out_claim_digest), - 11 => aggr_range_join(ixvm_vk_digest, self_vk_digest, - verify_idx, aggr_idx, allowed_digest, out_claim_digest), - 12 => aggr_range_root(ixvm_vk_digest, self_vk_digest, - verify_idx, aggr_idx, allowed_digest, out_claim_digest), - 13 => aggr_discharge_binding(0, ixvm_vk_digest, self_vk_digest, - verify_idx, aggr_idx, allowed_digest, out_claim_digest), - 14 => aggr_discharge_binding(1, ixvm_vk_digest, self_vk_digest, - verify_idx, aggr_idx, allowed_digest, out_claim_digest), - 15 => aggr_cross_binding(ixvm_vk_digest, self_vk_digest, - verify_idx, aggr_idx, allowed_digest, out_claim_digest), - 16 => aggr_catalog_join(ixvm_vk_digest, self_vk_digest, - verify_idx, aggr_idx, allowed_digest, out_claim_digest), - } - } -⟧ - -end Aggr - -end - diff --git a/Ix/Aggr/FFI.lean b/Ix/Aggr/FFI.lean deleted file mode 100644 index 23a835291..000000000 --- a/Ix/Aggr/FFI.lean +++ /dev/null @@ -1,152 +0,0 @@ -module -public import Ix.Aiur.Protocol - -/-! Native aggregation execution, proving, and manifest binding. -Extern symbols and record layout are shared with `crates/ffi/src/aiur/aggregate/ffi.rs`. -/ - -public section -namespace Aiur - -/-- Manifest-bound aggregate root reconstructed and audited by the native -Stage 2 controller. `claimBytes` is the exact root `Ix.Claim` wire encoding; -`constantCount` is the number of environment constants proven to occur once. -/ -structure AggregateExpected where - claimBytes : ByteArray - constantCount : Nat - deriving Nonempty - - -namespace Bytecode.Toplevel - -/-- Native execution of the `ix_aggr` aggregation entrypoint. Serialized child -proof transport (from `AiurSystem.proofToAdviceBytes`), claims, and the fixed -vk/output/allowed blobs are passed without -per-byte Lean field boxing; `preimagesBlob`, `treesBlob`, and `pathsBlob` use the compact -count/key/length framing produced by `Aggr.preimagesBlob` and -`Aggr.treesBlob` / `Aggr.pathsBlob`. Rust expands them directly into IO -channels 0–6 (the shape hint and structural paths share channel 6 with -disjoint key shapes). Wrap shapes pass empty right-child/path blobs — -the circuit never reads them. As with `executeMultiStark`, `useBytecode` -selects the generic interpreter over the generated production aggregator, -and the codegen'd path is only valid when `toplevel` is the production -`Aggr.ixAggr` bytecode. -/ -@[extern "rs_aiur_ix_aggr_execute"] -opaque executeIxAggr (toplevel : @& Bytecode.Toplevel) - (funIdx : @& Bytecode.FunIdx) (pubInput : @& Array G) (shape : @& Nat) - (leftProofAdviceBytes rightProofAdviceBytes ixvmVkBytes selfVkBytes : @& ByteArray) - (leftClaimsBytes rightClaimsBytes outputClaimBytes allowedBytes : @& ByteArray) - (preimagesBlob treesBlob pathsBlob : @& ByteArray) (useBytecode : Bool := false) : - Except String (Array G × Array QueryCount) - - -end Bytecode.Toplevel -namespace AiurSystem - -/-- Prove one `ix_aggr` execution — any shape — over raw child proof/claim -advice. Both proof blobs must come from `AiurSystem.proofToAdviceBytes`; -the compact preimage/tree/path blobs are produced by `Aggr.preimagesBlob`, -`Aggr.treesBlob`, and `Aggr.pathsBlob`; wrap and flat shapes pass empty -right-child blobs. Malformed framing is returned as an error; as with -`prove`/`proveMultiStark`, callers must supply an accepting execution -witness. Only valid when `system` was built from the production -`Aggr.ixAggr` bytecode (unless `useBytecode` is set). The final native IO -buffer is intentionally not marshalled back to Lean. -/ -@[extern "rs_aiur_ix_aggr_prove"] -opaque proveIxAggr (system : @& AiurSystem) - (funIdx : @& Bytecode.FunIdx) (pubInput : @& Array G) (shape : @& Nat) - (leftProofAdviceBytes rightProofAdviceBytes ixvmVkBytes selfVkBytes : @& ByteArray) - (leftClaimsBytes rightClaimsBytes outputClaimBytes allowedBytes : @& ByteArray) - (preimagesBlob treesBlob pathsBlob : @& ByteArray) (useBytecode : Bool := false) : - Except String (Array G × Proof) - -/-- `proveIxAggr` with the generated executor, planned as trace shards whose -projected host peak fits `maxBytes`: a driver that proves single aggregation -steps holds each one to its RAM budget this way, as the Stage 2 controller -holds its slots. An execution no shard count fits is an error. -/ -@[extern "rs_aiur_ix_aggr_prove_within"] -opaque proveIxAggrWithin (system : @& AiurSystem) - (funIdx : @& Bytecode.FunIdx) (pubInput : @& Array G) (shape : @& Nat) - (leftProofAdviceBytes rightProofAdviceBytes ixvmVkBytes selfVkBytes : @& ByteArray) - (leftClaimsBytes rightClaimsBytes outputClaimBytes allowedBytes : @& ByteArray) - (preimagesBlob treesBlob pathsBlob : @& ByteArray) (maxBytes : @& Nat) : - Except String (Array G × Proof) - -/-- Run the production aggregate-first Stage 2 pipeline natively after Lean -has compiled the IxVM and `ix_aggr` systems. Rust owns all data-dependent -orchestration: manifest/environment binding, shard-claim reconstruction, -statement folding, cache validation, dependency scheduling, recursive advice, -proving, and persistence. `proofHexes` is one store address per line; -`cacheFriBytes` is the stable 40-byte recursion-FRI cache identity. -`reproveSlotCode` is zero for a full run and `slot + 1` for a targeted replay; -the latter loads and verifies only the target's immediate cached children. -When `writeOutputs` is false, proofs are hashed but neither the store nor cache -is changed. Returns the root or replayed proof address. With `verifyOnly`, the -run stops after the proof import — every shard claim reconstructed natively, -every supplied proof bound to its shard by claim digest and verified in -parallel, exactly one per shard — returning the empty string (the composed -verdict of `ix verify --ixes`). `subtreeCode` is zero for a full run and -`slot + 1` to prove only the plan subtree rooted at that slot from the -proofs of the leaves under it, returning that slot's proof address; the -root-only steps (root validation, wrapping) are skipped, and the run fails -unless that proof was persisted and cached. A nonempty `bindingProof` names -an `Ixon.Proof` of the environment binding's `binding` claim: every shard -claim then assumes its binding, and the root discharges that condition once, -after any wrap; the discharged root claim is the one a run that validates -its binding states. -/ -@[extern "rs_aiur_stage2_aggregate"] -opaque aggregateStage2 (ixvmSystem aggrSystem : @& AiurSystem) - (envHandle : @& EnvHandle) (manifestPath proofHexes : @& String) - (verifyIdx aggrIdx jobs ramBudgetBytes structuralAbove reproveSlotCode : @& Nat) - (directJoins planOnly : Bool) (cacheFriBytes : @& ByteArray) - (useCache writeOutputs traceShards : Bool) (rangeWidth : @& Nat) - (wrapRoot : Bool) (execAhead : @& Nat) (verifyOnly : Bool) - (subtreeCode : @& Nat) (bindingProof : @& String := "") (fresh : Bool := false) : - Except String String - -/-- Reconstruct and audit the manifest-relative aggregate root entirely in -Rust, using the same ownership, frontier, pruning, and statement-fold code as -`aggregateStage2`. This is the native orchestration path for `ix verify` and -does not construct shard statements or schedule Lean tasks. -/ -@[extern "rs_aiur_aggregate_expected"] -opaque aggregateExpected (envHandle : @& EnvHandle) - (manifestPath : @& String) (structuralAbove : @& Nat) : - Except String AggregateExpected - - - -/-- The Stage 2 plan cut for `ix prove --ixe --ixes`: 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 --ixe --ixes`: 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; -`gpus` the GPU count (0 uses every visible GPU). -Oversized environment claims are bisected and checkpointed; completed -proofs are reused. A nonempty `outManifest` receives the final partition. -A nonempty `bindingProof` names an `Ixon.Proof` of the environment binding's -`binding` claim: every claim of the run then assumes its binding, and the -root discharges that condition once. `fresh` bypasses earlier proof indexes -and refinement checkpoints while publishing newly verified results to the -usual cache locations. Returns the verified root address; progress is -printed on stderr. -/ -@[extern "rs_aiur_prove_multi_gpu"] -opaque proveMultiGpu (ixvmSystem aggrSystem : @& AiurSystem) - (envHandle : @& EnvHandle) (manifestPath : @& String) - (verifyIdx aggrIdx gpus maxRamBytes execJobs structuralAbove : @& Nat) - (cacheFriBytes : @& ByteArray) (outManifest : @& String) - (bindingProof : @& String := "") (fresh : Bool := false) : Except String String - -end AiurSystem -end Aiur -end diff --git a/Ix/Aggr/FunctionGroups.lean b/Ix/Aggr/FunctionGroups.lean deleted file mode 100644 index 68bff1781..000000000 --- a/Ix/Aggr/FunctionGroups.lean +++ /dev/null @@ -1,270 +0,0 @@ -module - -/-! -Function-grouping data for the production aggregation toplevel -(`Aggr.ixAggr`), applied wherever it is compiled for proving or verifying -(see `CompiledToplevel.groupFunctions`). Empty = no grouping: every -constrained function keeps its singleton circuit. Fill from measured -workload statistics; a stale grouping stays sound (grouping never affects -semantics), only less efficient. --/ - -public section - -namespace Aggr - --- Cost-aware groups over the ix_aggr join and standalone-verifier profiles. --- Aggregation metadata readers and wrappers use the existing claim/tree and --- wrapper circuits. This keeps the frequently used opening, frontier and --- proof-vector loops narrow; compare actual shapes and execution counts with --- Scripts/Performance/FunctionGrouping.lean. -def functionGroups : Array (String × Array String) := #[ - ("aggr_group_00", #[ - "memo_u32_less_than", - "u64_is_zero", - "relaxed_u64_succ", - "flatten_u64", - "read_sys_lookups_n", - "frontier_merge", - "frontier_split", - "frontier_sort", - "frontier_leaves", - "rows_at_round", - "limbs_onto", - "from_ext_basis" - ]), - ("aggr_group_01", #[ - "address_eq_tail", - "address_eq", - "aggr_address_order", - "aggr_load_canonical_tree", - "aggr_assert_same_list", - "aggr_assert_union", - "aggr_parse_check_env", - "aggr_load_preimage", - "aggr_claim_digest", - "aggr_assert_digest", - "aggr_only_claim", - "aggr_child_check_env_digest" - ]), - ("aggr_group_02", #[ - "read_u8", - "read_digest_vec_at", - "read_vk_u32_limb", - "read_field", - "lookup_groups_count", - "assert_blowup_zero", - "ext_exp_pow2", - "reconstruct_ext_row", - "assert_bits", - "select_active_circuits", - "select_active_prep", - "list_length.SysCircuit" - ]), - ("aggr_group_03", #[ - "read_u64", - "blake3_next_layer", - "blake3_compress_layer", - "read_vk_u64", - "mmcs_verify_multi", - "pcs_check_witness", - "open_prep_batch", - "query_loop", - "verify_commit_multi", - "ch_sample_field", - "ch_sample_ext", - "snoc_b8", - "logup_steps_fold" - ]), - ("aggr_group_04", #[ - "read_count", - "read_opened_round", - "read_batch_opening_vec_n", - "read_commit_phase_step_vec_n", - "read_preprocessed", - "bytes_to_addr", - "mmcs_compress", - "pcs_betas", - "verify_query", - "cap_onto", - "ch_sample_bits", - "fingerprint_vals", - "read_claim_vals_n", - "list_length.Bucket", - "list_concat.U8_8" - ]), - ("aggr_group_05", #[ - "read_count_at", - "list_drop.SysNode" - ]), - ("aggr_group_06", #[ - "read_active_n", - "read_u64_vec_vec_vec_n", - "read_opened_round_n", - "b3_w4_onto", - "frontier_fold", - "circ_has_height", - "heights_all", - "heights_prep", - "batch_views_at", - "step_views_at", - "drop_index_bits", - "take_bits" - ]), - ("aggr_group_07", #[ - "read_u64_vec", - "list_length.Ptr.U8_8_4" - ]), - ("aggr_group_08", #[ - "read_ext_vec", - "read_ext_vec_vec", - "read_ext_vec_vec_n", - "pad_block", - "read_vk_u16_limb", - "has_height", - "bits_to_num", - "exp_by_bits", - "points_onto", - "round_onto", - "log_degrees_onto", - "list_concat.Ptr.U8_32" - ]), - ("aggr_group_09", #[ - "read_ext_vec_n", - "pair_mul" - ]), - ("aggr_group_10", #[ - "read_digest_vec_at_n", - "read_merkle_cap_vec_n", - "read_opt_idx_n", - "leaf_hash_at", - "fri_fold2", - "obs_log_arities", - "build_buckets", - "rollin", - "sample_query_indices", - "query_views", - "snoc_cap", - "two_adic_gen", - "pow2", - "quotient_eval", - "list_length.CommitPhaseMultiStep" - ]), - ("aggr_group_11", #[ - "read_u64_vec_vec_n", - "read_node_ids_n" - ]), - ("aggr_group_12", #[ - "bytes_to_block", - "blake3_finish", - "blake3_compress_block", - "read_sys_circuits_n", - "ch_sample8", - "ood_loop", - "aggr_read_address", - "aggr_put_address", - "aggr_parse_range", - "aggr_read_digest" - ]), - ("aggr_group_13", #[ - "read_vk_cap_n", - "read_opt_commit", - "prep_count", - "heights_max", - "verify_one_query", - "verify_input_multi", - "quotient_degree_of", - "claims_acc", - "read_claims_n", - "aggr_pack_address", - "list_length.FrontierNode" - ]), - ("aggr_group_14", #[ - "compress_ordered", - "ood_fold", - "list_is_empty.Ptr.U8_32" - ]), - ("aggr_group_15", #[ - "select_rows_le", - "frontier_level", - "accs_onto" - ]), - ("aggr_group_16", #[ - "inject_maybe", - "rev_onto", - "list_lookup.G_2", - "list_drop.G_2" - ]), - ("aggr_group_17", #[ - "open_2pt_mat", - "open_batch_2pt", - "open_quotient", - "open_prep", - "fold_roots", - "logup_fingerprint" - ]), - ("aggr_group_18", #[ - "aggr_node_hash", - "aggr_leaf_hash", - "aggr_assert_strict_sorted", - "aggr_parse_tree_body", - "aggr_leaf_hashes", - "aggr_pair_hashes", - "aggr_reduce_hashes", - "aggr_canonical_root", - "aggr_load_optional_tree", - "aggr_next_assumption", - "aggr_seek_subject", - "aggr_assert_difference", - "aggr_get_opt_address", - "aggr_claim_field", - "list_lookup.U8_8", - "list_drop.U8_8", - "aggr_class_walk", - "aggr_put_addresses", - "aggr_read_cap_n", - "aggr_read_bits_n", - "aggr_read_headers_n" - ]), - ("aggr_group_19", #[ - "aggr_fold_path", - "aggr_discharge_choice", - "aggr_assert_structural_difference", - "aggr_load_sys", - "aggr_verify_child", - "aggr_wrap", - "aggr_pair", - "aggr_pair_structural", - "aggr_discharge_binding", - "aggr_cross_binding", - "aggr_catalog_join", - "aggr_range_leaf", - "aggr_range_join", - "aggr_range_root", - "aggr_output_range", - "aggr_child_range", - "aggr_opt_address_eq", - "aggr_context_class", - "aggr_read_header", - "aggr_verify_range", - "aggr_load_preamble", - "aggr_binding_class", - "aggr_parse_binding", - "aggr_parse_catalog", - "aggr_assert_same_context", - "aggr_catalog_part", - "aggr_read_message", - "aggr_read_messages_n", - "aggr_batch_challenges", - "aggr_is_class_role" - ]), - ("aggr_group_20", #[ - "list_lookup.BatchOpening", - "list_length.CommitPhaseProofStep", - "list_drop.G" - ]) -] - -end Aggr - -end diff --git a/Ix/Aggr/Parameters.lean b/Ix/Aggr/Parameters.lean index a72684008..ac68d7b8e 100644 --- a/Ix/Aggr/Parameters.lean +++ b/Ix/Aggr/Parameters.lean @@ -1,28 +1,15 @@ module -public import MultiStark.Wire +public import Ix.MultiStark.Wire public section namespace Aggr -/-! ## Recursion proof parameters - -IxVM proofs and aggregate recursion proofs deliberately have separate host -configuration, even while both configurations retain today's canonical values. -Keeping the recursion pair here gives aggregation and aggregate verification a -single construction path; a later policy change cannot silently update only one -side. --/ - -/-- Commitment and FRI parameters for aggregation proofs. These parameters are -already bound by `AiurSystem.vkBytes`; this structure is host configuration, not -an additional circuit public input. -/ +/-- Commitment and FRI parameters for aggregation proofs. -/ structure RecursionParameters where commitment : Aiur.CommitmentParameters fri : Aiur.FriParameters -/-- Compatibility default for aggregate recursion proofs. Policy changes (for -example, reducing the query count) must be explicit updates to this value and -must not change the canonical IxVM proof parameters. -/ +/-- Compatibility default for aggregate recursion proofs. -/ def defaultRecursionParameters : RecursionParameters := { commitment := Aiur.defaultCommitmentParameters fri := Aiur.defaultFriParameters @@ -30,28 +17,18 @@ def defaultRecursionParameters : RecursionParameters := { /-- Stable 40-byte serialization used as the `fri_params_ser` component of the aggregate cache key: five `u64` little-endian fields in verifying-key -order. Commitment parameters need no separate cache-key component because a -change to them changes the recursion-vk digest that the key also contains. -/ +order. -/ def RecursionParameters.cacheFriBytes (parameters : RecursionParameters) : ByteArray := let fri := parameters.fri ⟨MultiStark.u64le fri.logFinalPolyLen ++ MultiStark.u64le fri.maxLogArity ++ MultiStark.u64le fri.numQueries ++ MultiStark.u64le fri.commitProofOfWorkBits ++ MultiStark.u64le fri.queryProofOfWorkBits⟩ -/-- Build a recursion proving/verifying system through the shared aggregate -parameter path. Both `AggregateCmd` and `VerifyCmd` use this helper. -/ -def buildRecursionSystem (bytecode : Aiur.Bytecode.Toplevel) - (parameters : RecursionParameters) : Aiur.AiurSystem := - Aiur.AiurSystem.build bytecode parameters.commitment parameters.fri - - def defaultStructuralAbove : Nat := 4096 def aggregateGiB : Nat := 1024 * 1024 * 1024 -/-- Linux `MemTotal` parser kept separate so the 92% default has a pure seam. -The fallback only affects non-Linux hosts; admit-when-alone still guarantees -progress without pretending the fallback is a calibrated capacity. -/ +/-- Linux `MemTotal` parser kept separate so the 92% default has a pure seam. -/ def aggregateMemTotalBytes (contents : String) : Option Nat := (contents.splitOn "\n").findSome? fun line => if line.startsWith "MemTotal:" then diff --git a/Ix/Aggr/Protocol.lean b/Ix/Aggr/Protocol.lean index 2905b7d65..7d9a58ac4 100644 --- a/Ix/Aggr/Protocol.lean +++ b/Ix/Aggr/Protocol.lean @@ -13,13 +13,7 @@ namespace Aggr /-- The digest-bound 80-byte identity blob: `blake3(ixvm vk) ‖ verify_claim index as u64-LE ‖ blake3(self vk) ‖ -ix_aggr index as u64-LE`. - -The verifying keys stay outside the public input. Their digests and both -entrypoint indices form the stable identity that every node of an aggregation -tree pins transitively — the blob is identical at every node regardless of -shape. The indices must be explicit because the Source DSL cannot materialize -its compiler-assigned function index inside a circuit. -/ +ix_aggr index as u64-LE`. -/ def allowedBlob (ixvmVkBytes : ByteArray) (verifyClaimIdx : Nat) (selfVkBytes : ByteArray) (aggrIdx : Nat) : ByteArray := let ixvmDigest := (Address.blake3 ixvmVkBytes).hash.data @@ -56,27 +50,13 @@ structural form. -/ def structuralShapeCode (left right : ChildKind) : Nat := 6 + 2 * left.code + right.code -/-! ## Range-sum recursion - -Shapes `10`–`12` verify one IxVM batch across several recursion proofs: a -leaf verifies shards `[lo, hi)`, a join adds two adjacent ranges, and the -root checks that one range covers the whole batch, balances it against the -preamble messages, and emits the batch's `CheckEnv` digest exactly as a wrap -would. Their statements are `rangeStatement` bytes, opened on channel 4 like -`CheckEnv` preimages. -/ +/-! ## Range-sum recursion -/ def rangeLeafShape : Nat := 10 def rangeJoinShape : Nat := 11 def rangeRootShape : Nat := 12 -/-! ## Binding discharge - -Shapes `13`–`14` take a `CheckEnv` child that assumes its binding (an IxVM -child for `13`, an `ix_aggr` child for `14`, at key 0) and an IxVM proof of -the `binding` claim for its specification digest and binding hash (key 1), -and state the child's claim validating its binding: the same bytes with -validator 3. Folds keep the validator, so an aggregate discharges once, at -the top. -/ +/-! ## Binding discharge -/ /-- The binding-discharge shape for a child of kind `kind`. -/ def dischargeShapeCode (kind : ChildKind) : Nat := 13 + kind.code @@ -96,32 +76,17 @@ def rangeStatementTag : UInt8 := 0x52 /-- A range node's output statement: -`0x52 ‖ blake3(preamble)(32) ‖ lo(u64 LE) ‖ hi(u64 LE) ‖ residual(16)`, - -where `preamble` is the batch's serialized headers and messages and -`residual` is the range's residual sum as two little-endian `u64` limbs (a -canonical extension-field element). -/ +`0x52 ‖ blake3(preamble)(32) ‖ lo(u64 LE) ‖ hi(u64 LE) ‖ residual(16)`. -/ def rangeStatement (preamble : ByteArray) (lo hi : Nat) (residual : ByteArray) : ByteArray := ⟨#[rangeStatementTag] ++ (Address.blake3 preamble).hash.data ++ MultiStark.u64le lo ++ MultiStark.u64le hi ++ residual.data⟩ -/-! ## Native-FFI advice framing +/-! ## Advice framing -/ -`executeIxAggr` / `proveIxAggr` take the digest-addressed advice as compact -byte blobs and expand them into IO channels natively. The circuit still -re-hashes/re-roots every payload; these host-side keys only make the advice -addressable — they are not trusted bindings. -/ - -/-- Four little-endian bytes of `n`, used only by the compact native-FFI -framing below. Advice blobs are bounded by the `ByteArray`/Rust address -space in practice and therefore never approach the `u32` limit. -/ private def u32le (n : Nat) : Array UInt8 := (Array.range 4).map (fun i => UInt8.ofNat ((n >>> (8 * i)) % 256)) -/-- Encode content-addressed byte blobs for the native FFI as - -`count:u32-LE ‖ (key:32 ‖ length:u32-LE ‖ payload)*`. -/ private def keyedBlobs (entries : Array (ByteArray × ByteArray)) : ByteArray := Id.run do assert! entries.size < 4294967296 @@ -132,23 +97,18 @@ private def keyedBlobs out := out ++ key.data ++ u32le payload.size ++ payload.data return ⟨out⟩ -/-- Pack `CheckEnv` claim preimages for the native FFI. Each key is computed -as Blake3(payload), matching IO channel 4's packed-digest lookup. -/ +/-- Pack `CheckEnv` claim preimages. Each key is computed as Blake3(payload), +matching IO channel 4's packed-digest lookup. -/ def preimagesBlob (preimages : Array ByteArray) : ByteArray := keyedBlobs <| preimages.map fun bytes => ((Address.blake3 bytes).hash, bytes) -/-- Pack serialized canonical trees for the native FFI. Channel 5 keys use -the raw 32-byte tree root. The in-circuit loader independently checks strict -leaf order and recomputes the canonical root. -/ +/-- Pack serialized canonical trees. Channel 5 keys use the raw 32-byte tree root. -/ def treesBlob (trees : Array Ix.AssumptionTree) : ByteArray := keyedBlobs <| trees.map fun tree => (tree.root.hash, Ix.AssumptionTree.ser tree) -/-- Encode one structural-discharge choice. A missing path means "carry" and -encodes as `0`; a present path encodes as -`1 ‖ count:u8 ‖ (side:u8 ‖ sibling:32)*`. The side byte is zero when the -sibling is on the left and one when it is on the right. -/ +/-- Encode one structural-discharge choice. -/ def pathPayload (path? : Option Ix.Merkle.MerklePath) : ByteArray := Id.run do match path? with | none => return ⟨#[0]⟩ @@ -167,31 +127,22 @@ def pathsBlob keyedBlobs <| paths.map fun (candidate, path?) => (candidate.hash, pathPayload path?) -/-! ## Interpreter-side advice assembly - -These helpers place advice on the IO channels exactly as the circuit reads -them, for the pure-Lean `Bytecode.Toplevel.execute` path. The native -execute/prove FFI will consume byte blobs with the same channel layout. -/ +/-! ## Advice assembly -/ /-- One byte per Goldilocks element, the layout `read_checked_byte_stream` expects. -/ def byteGs (bytes : ByteArray) : Array Aiur.G := bytes.data.map .ofUInt8 -/-- Channel 4: a `CheckEnv` claim preimage, keyed by its packed digest. The -circuit re-hashes the payload against the key, so host keys are addressing, -not trusted bindings. -/ +/-- Channel 4: a `CheckEnv` claim preimage, keyed by its packed digest. -/ def extendPreimage (io : Aiur.IOBuffer) (bytes : ByteArray) : Aiur.IOBuffer := io.extend 4 (MultiStark.digestGs bytes) (byteGs bytes) -/-- Channel 5: one serialized canonical tree, keyed by its raw 32-byte root. -The circuit independently checks strict leaf order and recomputes the -canonical root. -/ +/-- Channel 5: one serialized canonical tree, keyed by its raw 32-byte root. -/ def extendTree (io : Aiur.IOBuffer) (tree : Ix.AssumptionTree) : Aiur.IOBuffer := io.extend 5 (byteGs tree.root.hash) (byteGs (Ix.AssumptionTree.ser tree)) /-- Channel 6: one structural carried/discharged choice keyed by the raw -candidate address. The 32-element address key cannot collide with the shape's -one-element `[0]` key. -/ +candidate address. -/ def extendPath (io : Aiur.IOBuffer) (candidate : Address) (path? : Option Ix.Merkle.MerklePath) : Aiur.IOBuffer := io.extend 6 (byteGs candidate.hash) (byteGs (pathPayload path?)) @@ -214,22 +165,16 @@ def extendVk (io : Aiur.IOBuffer) (kind : ChildKind) (vkBytes : ByteArray) : Aiur.IOBuffer := io.extend 1 #[.ofNat kind.code] (byteGs vkBytes) -/-- Channel 2 key 2: the output claim bytes of a pair fold. Wrap shapes bind -the output digest against the child claim directly and read no output bytes. -/ +/-- Channel 2 key 2: the output claim bytes of a pair fold. -/ def extendOutputClaim (io : Aiur.IOBuffer) (bytes : ByteArray) : Aiur.IOBuffer := io.extend 2 #[.ofNat 2] (byteGs bytes) /-- Bump when aggregate cache identity changes beyond the recursion verifying -key. Version 2 uses uniform `ix_aggr` outer claims. Encoded as `u64` -little-endian in every cache key. -/ +key. Version 2 uses uniform `ix_aggr` outer claims. -/ def aggregateCacheVersion : Nat := 2 /-- `blake3(version ‖ recursion_vk_digest ‖ fri_params_ser ‖ outer_claim_bytes)`. - -`serializeClaims #[outerClaim]` is the canonical, length-delimited outer-claim -encoding. The expected outer claim commits to the single entrypoint, allowed -blob, and output statement at every persisted node. -/ def aggregateCacheKey (recursionVk : ByteArray) (recursionParameters : Aggr.RecursionParameters) @@ -240,7 +185,7 @@ def aggregateCacheKey (recursionVk : ByteArray) recursionParameters.cacheFriBytes.data ++ outerClaimBytes.data⟩ /-- The public claim is uniform across wrap, flat, and structural witnesses. -/ -def aggregateOuterClaim (allowed : ByteArray) (aggrIdx : Aiur.Bytecode.FunIdx) +def aggregateOuterClaim (allowed : ByteArray) (aggrIdx : Nat) (claim : Ix.Claim) : Array Aiur.G := Aiur.buildClaim aggrIdx (Aggr.pubInput allowed (Ix.Claim.ser claim)) #[] diff --git a/Ix/Aggr/Reference.lean b/Ix/Aggr/Reference.lean index eeb42ee5f..072852f8f 100644 --- a/Ix/Aggr/Reference.lean +++ b/Ix/Aggr/Reference.lean @@ -3,10 +3,7 @@ public import Ix.Aggr.Host public import Ix.Aggr.Protocol public import Ix.Shard.Environment -/-! Pure reference model for native aggregation plans and statements. - -Used by differential tests and the policy benchmark; execution, caching, and -scheduling are owned by the native controller. -/ +/-! Pure reference model for native aggregation plans and statements. -/ public section namespace Aggr.Reference @@ -31,39 +28,23 @@ structure ScheduledFold where op : Ix.Shard.AggregationTree.FoldOp subjectCount : Nat structural : Bool - /-- Result kind of this slot. Only direct-policy leaves are `.ixvm`. -/ kind : Aggr.ChildKind := .aggr - /-- `ix_aggr` shape proven by this slot. Direct-policy raw leaves have no - shape because they are verified and forwarded without a recursion proof. -/ shape? : Option Nat := none deriving BEq, Repr - /-- Reference copy of the native controller's conservative wrap reserve. -/ def aggregateWrapRamBytes : Nat := 195 * aggregateGiB -/-- Structural joins are dominated by the same two recursive-proof checks as -lifts. Keep the conservative lift reserve until the real E2E calibration. -/ def aggregateStructuralJoinRamBytes : Nat := aggregateWrapRamBytes -/-- Native verification and serialization of a raw shard proof in direct mode -is charged to its consuming pair. -/ def aggregateRawShardRamBytes : Nat := 4 * aggregateGiB -/-- Measured upper envelope for an `IxVM + IxVM` pair (shapes 2/6). -/ def aggregateDirectJoinRamBytes : Nat := 390 * aggregateGiB -/-- Measured upper envelope for a mixed recursive/IxVM pair (shapes 3/4/7/8). -/ def aggregateMixedJoinRamBytes : Nat := 340 * aggregateGiB -/-- Flat joins add canonical subject-tree work to the recursive-proof base. -One MiB per subject is a deliberately conservative placeholder: at Init's -~52k-subject root it adds ~51 GiB. The -default structural threshold caps this term near 4 GiB in production. -/ def aggregateFlatJoinRamPerSubjectBytes : Nat := 1024 * 1024 -/-- Reference per-shape RAM weight. Shape 5 retains the flat subject-count -reserve; shape 9 is the O(1)-subject structural arm. -/ def aggregateShapeRamBytes (shape subjectCount : Nat) : Nat := match shape with | 0 | 1 => aggregateWrapRamBytes @@ -74,7 +55,6 @@ def aggregateShapeRamBytes (shape subjectCount : Nat) : Nat := | 9 => aggregateStructuralJoinRamBytes | _ => aggregateDirectJoinRamBytes -/-- Reference per-slot RAM weight, also used by the policy benchmark. -/ def aggregateSlotRamBytes (item : ScheduledFold) : Nat := match item.shape? with | some shape => aggregateShapeRamBytes shape item.subjectCount @@ -88,16 +68,13 @@ def aggregateSlotRamBytes (item : ScheduledFold) : Nat := def aggregateSlotRamWeights (plan : Array ScheduledFold) : Array Nat := plan.map aggregateSlotRamBytes -/-- Resolve subject counts and the structural threshold once, before proving. -Because parent counts only grow, `count > structuralAbove` makes the mode -monotone: a flat join is never scheduled above a structural child. -/ + +/-- Resolve subject counts and the structural threshold once, before proving. -/ def schedulePlan (plan : Array Ix.Shard.AggregationTree.FoldOp) (shardCounts : Array Nat) (structuralAbove : Nat) (directJoins : Bool := false) : Except String (Array ScheduledFold) := do let mut scheduled : Array ScheduledFold := #[] - -- A singleton must still produce an `ix_aggr` wrapper. Larger direct plans - -- keep leaves raw so their first pair can select shapes 2–4/6–8. let rawLeaves := directJoins && plan.size > 1 for op in plan do match op with @@ -127,14 +104,11 @@ def schedulePlan (plan : Array Ix.Shard.AggregationTree.FoldOp) } pure scheduled -/-! ## Converged single-entrypoint slot derivation -/ - /-- Derive every converged slot statement, uniform outer claim, kind, and -cache key before proving. Wrap-first leaves use shape 0; direct-policy leaves -remain raw IxVM claims and are deliberately not cache-consumed. -/ +cache key before proving. -/ def buildAggrSlotSpecs (plan : Array ScheduledFold) (prepared : Array PreparedShard) (aggrVk allowed : ByteArray) - (verifyIdx aggrIdx : Aiur.Bytecode.FunIdx) + (verifyIdx aggrIdx : Nat) (recursionParameters : Aggr.RecursionParameters) : Except String (Array AggregateSlotSpec) := do let mut specs : Array AggregateSlotSpec := #[] @@ -196,43 +170,41 @@ def buildAggrSlotSpecs (plan : Array ScheduledFold) } pure specs -private def prepareOwnedShard (env : Ixon.Env) (owned : Array Address) : +private def prepareOwnedShard (env : Ixon.Env) (owned : Array Address) + (assumeBinding : Bool := false) : Except String PreparedShard := do - let (claim, trees) ← IxVM.ClaimHarness.shardCheckEnvClaimTrees env owned + let (claim, trees) ← IxVM.ClaimHarness.shardCheckEnvClaimTrees env owned assumeBinding let statement ← Aggr.CheckEnvTrees.ofClaim claim trees pure { claim, statement } /-- Reconstruct every shard statement after partitioning environment ownership -in one pass. Calling `ownedConstsForBlocks` once per shard rescans the complete -environment for every leaf, which made Mathlib aggregate startup take more -than twenty minutes before the proof store was touched. -/ +in one pass. -/ def prepareShards (env : Ixon.Env) (shards : Array (Array Address)) - (shardIds : Array Nat := #[]) : Except String (Array PreparedShard) := do + (shardIds : Array Nat := #[]) (assumeBinding : Bool := false) : + Except String (Array PreparedShard) := do let ownedAll := Ix.Shard.ownedConstsPer env shards if ownedAll.size != shards.size then throw s!"internal: prepared ownership for {ownedAll.size} shards, expected {shards.size}" let mut prepared : Array PreparedShard := #[] for (owned, shard) in ownedAll.mapIdx fun shard owned => (owned, shard) do let originalShard := (shardIds[shard]?).getD shard - let item ← match prepareOwnedShard env owned with + let item ← match prepareOwnedShard env owned assumeBinding with | .error e => throw s!"prepare shard {originalShard}: {e}" | .ok item => pure item prepared := prepared.push item pure prepared - -private def shardStatement (env : Ixon.Env) (owned : Array Address) : +private def shardStatement (env : Ixon.Env) (owned : Array Address) + (assumeBinding : Bool := false) : Except String Aggr.CheckEnvTrees := do - let (claim, trees) ← IxVM.ClaimHarness.shardCheckEnvClaimTrees env owned + let (claim, trees) ← IxVM.ClaimHarness.shardCheckEnvClaimTrees env owned assumeBinding Aggr.CheckEnvTrees.ofClaim claim trees /-- Reproduce the flat/structural statement fold from a coverage-validated -manifest. Zero-constant leaves are pruned exactly as in `ix aggregate`; no proof -data is needed. Ownership is assigned for every retained shard in one -environment pass; verification must not reintroduce the old shard-by-shard -full-environment scan. -/ +manifest. -/ def expectedFromManifest (env : Ixon.Env) - (view : Ix.Shard.IxesManifestView) (structuralAbove : Nat) : + (view : Ix.Shard.IxesManifestView) (structuralAbove : Nat) + (assumeBinding : Bool := false) : Except String Aggr.CheckEnvTrees := do let (view, counts) ← view.pruneEmpty env let owned := Ix.Shard.ownedConstsPer env view.shards @@ -244,7 +216,7 @@ def expectedFromManifest (env : Ixon.Env) | .leaf shard => let some shardOwned := owned[shard]? | throw s!"aggregate plan references missing shard {shard}" - slots := slots.push (← shardStatement env shardOwned) + slots := slots.push (← shardStatement env shardOwned assumeBinding) | .join left right => let some leftStatement := slots[left]? | throw s!"aggregate plan references missing left slot {left}" diff --git a/Ix/Aiur.lean b/Ix/Aiur.lean deleted file mode 100644 index 67949f1ef..000000000 --- a/Ix/Aiur.lean +++ /dev/null @@ -1,24 +0,0 @@ -module - -public import Ix.Aiur.Goldilocks -public import Ix.Aiur.Meta -public import Ix.Aiur.Stages.Source -public import Ix.Aiur.Stages.Typed -public import Ix.Aiur.Stages.Simple -public import Ix.Aiur.Stages.Concrete -public import Ix.Aiur.Stages.Bytecode -public import Ix.Aiur.Semantics.Flatten -public import Ix.Aiur.Semantics.BytecodeFfi -public import Ix.Aiur.Semantics.SourceEval -public import Ix.Aiur.Semantics.BytecodeEval -public import Ix.Aiur.Protocol -public import Ix.Aiur.Interpret -public import Ix.Aiur.Compiler.Check -public import Ix.Aiur.Compiler.Match -public import Ix.Aiur.Compiler.Simple -public import Ix.Aiur.Compiler.Concretize -public import Ix.Aiur.Compiler.Layout -public import Ix.Aiur.Compiler.Lower -public import Ix.Aiur.Compiler.Dedup -public import Ix.Aiur.Compiler -public import Ix.Aiur.Statistics diff --git a/Ix/Aiur/Codegen/Rust.lean b/Ix/Aiur/Codegen/Rust.lean deleted file mode 100644 index a10adfe05..000000000 --- a/Ix/Aiur/Codegen/Rust.lean +++ /dev/null @@ -1,270 +0,0 @@ -/- The Rust syntax subset used by Aiur code generation. - -This is a syntax tree, not a Rust type checker. Names and paths are trusted -identifiers supplied by the generator; user-provided text is a string literal. -Executable code has no raw-text escape hatch. Rendering belongs here, not in -bytecode emission. Blocks distinguish statements from a value-producing tail. --/ -module -public import Std - -public section -namespace Aiur.Codegen - -inductive RustSize where - | value (n : Nat) - | named (name : String) - deriving Inhabited, BEq - -inductive RustType where - | named (name : String) - | app (name : String) (args : Array RustType) - | array (elem : RustType) (size : RustSize) - | slice (elem : RustType) - | ref (mutable : Bool) (ty : RustType) - | ptr (mutable : Bool) (ty : RustType) - | tuple (elems : Array RustType) - deriving Inhabited, BEq - -inductive RustBinOp where - | add | sub | mul | eq | ne | lt | ge | and | or | bitAnd | bitOr | shl | shr - deriving Inhabited, BEq - -inductive MatchPat where - | binding (name : String) - | litU64 (n : Nat) - | wildcard - | tuple (elems : Array MatchPat) - | array (elems : Array MatchPat) - | constructor (path : Array String) (args : Array MatchPat) - deriving Inhabited, BEq - -mutual -inductive RustExpr where - | var (name : String) - | nat (n : Nat) - | bool (b : Bool) - | string (value : String) - | path (segments : Array String) - | call (callee : RustExpr) (args : Array RustExpr) - | methodCall (receiver : RustExpr) (name : String) (args : Array RustExpr) - | constGeneric (callee : RustExpr) (args : Array RustExpr) - | index (arr idx : RustExpr) - | field (e : RustExpr) (name : String) - | binop (op : RustBinOp) (a b : RustExpr) - | deref (e : RustExpr) - | ref (e : RustExpr) - | not (e : RustExpr) - | cast (e : RustExpr) (ty : RustType) - | tryExpr (e : RustExpr) - | range (start stop : Option RustExpr) - | macroCall (name : String) (args : Array RustExpr) - | arrayLit (elems : Array RustExpr) - | arrayRepeat (elem : RustExpr) (size : RustSize) - | tuple (elems : Array RustExpr) - | structLit (path : Array String) (fields : Array (String × RustExpr)) - | block (body : RustBlock) - | unsafeBlock (body : RustBlock) - | labeledBlock (label : String) (body : RustBlock) - | ifExpr (cond : RustExpr) (thenBody elseBody : RustBlock) - | matchExpr (scrut : RustExpr) (arms : Array MatchArm) - | closure (params : Array MatchPat) (body : RustExpr) - deriving Inhabited - -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) - (elseStmts : Option (Array RustStmt)) - | matchStmt (scrut : RustExpr) (arms : Array MatchArm) - | block (stmts : Array RustStmt) - | forStmt (pat : MatchPat) (iter : RustExpr) (body : Array RustStmt) - | breakWith (label : String) (e : RustExpr) - deriving Inhabited - -structure RustBlock where - stmts : Array RustStmt := #[] - tail : Option RustExpr := none - deriving Inhabited - -structure MatchArm where - pat : MatchPat - guard : Option RustExpr := none - body : RustBlock - deriving Inhabited -end - -inductive RustVisibility where - | internal | crate - deriving Inhabited, BEq - -structure RustFunction where - name : String - visibility : RustVisibility := .internal - constParams : Array (String × RustType) := #[] - params : Array (String × RustType) - returnTy : RustType - body : RustBlock - deriving Inhabited - -inductive RustItem where - | constUsize (name : String) (value : Nat) - | function (fn : RustFunction) - deriving Inhabited - -/-! ## Rendering -/ - -private def commaSep (xs : Array String) : String := ", ".intercalate xs.toList -private def tupleText (xs : Array String) : String := - "(" ++ commaSep xs ++ (if xs.size == 1 then "," else "") ++ ")" - -def RustSize.toStr : RustSize → String - | .value n => toString n - | .named n => n - -partial def RustType.toStr : RustType → String - | .named n => n - | .app n args => n ++ "<" ++ commaSep (args.map RustType.toStr) ++ ">" - | .array t n => "[" ++ t.toStr ++ "; " ++ n.toStr ++ "]" - | .slice t => "[" ++ t.toStr ++ "]" - | .ref isMut t => "&" ++ (if isMut then "mut " else "") ++ t.toStr - | .ptr isMut t => (if isMut then "*mut " else "*const ") ++ t.toStr - | .tuple ts => tupleText (ts.map RustType.toStr) - -def RustBinOp.toStr : RustBinOp → String - | .add => "+" | .sub => "-" | .mul => "*" - | .eq => "==" | .ne => "!=" | .lt => "<" | .ge => ">=" - | .and => "&&" | .or => "||" | .bitAnd => "&" | .bitOr => "|" - | .shl => "<<" | .shr => ">>" - -partial def MatchPat.toStr : MatchPat → String - | .binding n => n - | .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) ++ ")" - -/-- Escape literal contents once, independently of format-string escaping. -/ -private def stringLiteral (s : String) : String := - "\"" ++ String.ofList (s.toList.flatMap fun c => - match c with - | '\\' => ['\\', '\\'] | '"' => ['\\', '"'] - | '\n' => ['\\', 'n'] | '\r' => ['\\', 'r'] | '\t' => ['\\', 't'] - | '\x00' => ['\\', '0'] - | c => [c]) ++ "\"" - -mutual -partial def RustExpr.toStr : RustExpr → String - | .var n => n - | .nat n => toString n - | .bool b => if b then "true" else "false" - | .string s => stringLiteral s - | .path p => "::".intercalate p.toList - | .call f xs => - -- Calling a function-valued field is distinct from method dispatch. - let callee := match f with - | .field .. => "(" ++ f.toStr ++ ")" - | _ => f.postfixBase - callee ++ "(" ++ commaSep (xs.map (·.toStrBare)) ++ ")" - | .methodCall e n xs => e.postfixBase ++ "." ++ n ++ - "(" ++ commaSep (xs.map (·.toStrBare)) ++ ")" - | .constGeneric f xs => f.postfixBase ++ "::<" ++ commaSep (xs.map (·.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. - | .deref e => "(*" ++ e.toStr ++ ")" - | .ref e => "(&" ++ e.toStr ++ ")" - | .not e => "(!" ++ e.toStr ++ ")" - | .cast e t => "(" ++ e.toStr ++ " as " ++ t.toStr ++ ")" - | .tryExpr e => e.postfixBase ++ "?" - | .range a b => (a.map (·.toStr) |>.getD "") ++ ".." ++ - (b.map (·.toStr) |>.getD "") - | .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.toStrBare) ++ " }" - | .block b => b.toStr - | .unsafeBlock b => "unsafe " ++ b.toStr - | .labeledBlock label b => "'" ++ label ++ ": " ++ b.toStr - | .ifExpr c t e => "if " ++ c.toStr ++ " " ++ t.toStr ++ " else " ++ e.toStr - | .matchExpr e arms => renderMatch e arms - | .closure ps e => "|" ++ commaSep (ps.map MatchPat.toStr) ++ "| " ++ e.toStr - -/-- A closure or control-flow expression must be grouped before a postfix - operation; otherwise, for example, a call can attach to the closure body. -/ -partial def RustExpr.postfixBase (e : RustExpr) : String := - match e with - | .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.toStrBare |>.getD "") ++ " }" - -partial def renderMatch (scrut : RustExpr) (arms : Array MatchArm) : String := - "match " ++ scrut.toStr ++ " { " ++ - commaSep (arms.map fun arm => - arm.pat.toStr ++ - (arm.guard.map (fun g => " if " ++ g.toStr) |>.getD "") ++ - " => " ++ arm.body.toStr) ++ (if arms.isEmpty then "" else ",") ++ " }" - -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.toStrBare ++ ";" - | .letPattern p ty e => "let " ++ p.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 "") - | .matchStmt e arms => renderMatch e arms - | .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.toStrBare ++ ";" - -partial def stmtsToStr (ss : Array RustStmt) : String := - " ".intercalate (ss.toList.map RustStmt.toStr) -end - -def RustItem.toStr : RustItem → String - | .constUsize n v => s!"const {n}: usize = {v};\n" - | .function f => - 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 ",") ++ - ") " ++ returns ++ f.body.toStr ++ "\n" - -end Aiur.Codegen -end diff --git a/Ix/Aiur/Compiler.lean b/Ix/Aiur/Compiler.lean deleted file mode 100644 index 5eb558e18..000000000 --- a/Ix/Aiur/Compiler.lean +++ /dev/null @@ -1,289 +0,0 @@ -module -public import Ix.Aiur.Compiler.Lower -public import Ix.Aiur.Compiler.Dedup -public import Ix.Aiur.Compiler.Concretize -public import Ix.Aiur.Compiler.Simple - -/-! -Aiur compiler pipeline: type-check, simplify, concretize, lower, deduplicate. - -The pipeline in `Aiur` uses staged IRs: -``` -Source.Toplevel - └─ checkAndSimplify (Check + Simple) - ↓ -Typed.Decls - └─ concretize (Concretize) - ↓ -Concrete.Decls - └─ toBytecode (Lower + Layout) - ↓ -Bytecode.Toplevel - ├─ deduplicate (Dedup) - └─ needsCircuit (this file) - ↓ -CompiledToplevel -``` --/ - -public section -@[expose] section - -namespace Aiur - -structure CompiledToplevel where - mk :: - source : Source.Toplevel - bytecode : Bytecode.Toplevel - nameMap : Std.HashMap Global Bytecode.FunIdx - -@[inline] -def CompiledToplevel.getFuncIdx (ct : CompiledToplevel) (name : Lean.Name) : - Option Bytecode.FunIdx := - ct.nameMap[Global.mk name]? - -/-- Regroup the circuit partition: each `(name, members)` in `groups` becomes -ONE circuit proving all the listed functions (branching on the member; see -`Bytecode.Circuit`), positioned where its first member's singleton circuit -was; every other constrained function keeps its singleton circuit. Grouping -is a circuit-level choice — the function "library", its bytecode, execution, -and the query record are untouched, and callers still target function -indices on the function channel. - -Grouping is favorable for RARELY-CALLED functions of similar shape: the -merged circuit sums the members' selector columns but takes the max of their -auxiliary columns, so each (rare) row pays the group's selector count, while -the system sheds one circuit (vk entry, commitment matrix, verifier work) -per absorbed member. - -Errors if a name is unknown, unconstrained (it has no circuit to group), an -entry function, listed twice, or if a group is empty. -/ -def CompiledToplevel.groupFunctions (ct : CompiledToplevel) - (groups : Array (String × Array String)) : - Except String CompiledToplevel := do - let t := ct.bytecode - -- Function names as printed (`toString` of the `Global`), the exact - -- inverse of what statistics reports — so measured groupings can be fed - -- back verbatim. - let byName : Std.HashMap String Bytecode.FunIdx := - ct.nameMap.fold (init := {}) fun acc g i => acc.insert (toString g) i - -- Resolve and validate the groups into member-index arrays. - let mut grouped : Std.HashMap Bytecode.FunIdx Nat := {} - let mut resolved : Array (String × Array Bytecode.FunIdx) := #[] - for (gname, names) in groups do - if names.isEmpty then - throw s!"group {gname} is empty" - let mut members := #[] - for name in names do - let some i := byName[name]? - | throw s!"group {gname}: unknown function {name}" - let f := t.functions[i]! - unless f.constrained do - throw s!"group {gname}: {name} is unconstrained (it has no circuit)" - if f.entry then - throw s!"group {gname}: {name} is an entry function" - if grouped.contains i then - throw s!"group {gname}: {name} is already grouped" - grouped := grouped.insert i resolved.size - members := members.push i - resolved := resolved.push (gname, members) - -- Rebuild the partition in first-occurrence order over the existing - -- (singleton-ordered) circuits. - let mut circuits : Array Bytecode.Circuit := #[] - let mut placed : Array Bool := .replicate resolved.size false - for c in t.circuits do - let members := c.members - if h : members.size = 1 then - let i := members[0] - match grouped[i]? with - | none => circuits := circuits.push c - | some g => - unless placed[g]! do - placed := placed.set! g true - let (gname, ms) := resolved[g]! - let layout := ms.foldl (init := t.functions[ms[0]!]!.layout) - fun acc m => if m == ms[0]! then acc - else acc.merge t.functions[m]!.layout - circuits := circuits.push { name := gname, members := ms, layout } - else - throw "groupFunctions: partition already grouped; group from a freshly compiled toplevel" - pure { ct with bytecode := { t with circuits } } - -/-- Termination helper for the `Block`/`Ctrl` traversal below. -/ -private theorem Bytecode.Block.sizeOf_ctrl_lt'' (b : Bytecode.Block) : - sizeOf b.ctrl < sizeOf b := by - rcases b with ⟨ops, ctrl⟩ - show sizeOf ctrl < 1 + sizeOf ops + sizeOf ctrl - omega - -mutual -/-- Collect all callee `FunIdx` values from constrained `Op.call` nodes in a -block tree. Unconstrained calls are skipped because cascading into unconstrained -mode removes the need for the callee's own circuit. -/ -def Bytecode.Ctrl.collectConstrainedCallees (c : Bytecode.Ctrl) : - Array Bytecode.FunIdx := match c with - | .match _ cases default? => - let branchCallees := cases.attach.foldl (init := #[]) fun acc ⟨(_, block), _⟩ => - acc ++ block.collectConstrainedCallees - match default? with - | some block => branchCallees ++ block.collectConstrainedCallees - | none => branchCallees - | .matchContinue _ cases default? _ _ _ continuation => - let branchCallees := cases.attach.foldl (init := #[]) fun acc ⟨(_, block), _⟩ => - acc ++ block.collectConstrainedCallees - let withDefault := match default? with - | some block => branchCallees ++ block.collectConstrainedCallees - | none => branchCallees - withDefault ++ continuation.collectConstrainedCallees - | .return _ _ | .yield _ _ => #[] -termination_by (sizeOf c, 0) -decreasing_by - all_goals first - | decreasing_tactic - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - | grind - -def Bytecode.Block.collectConstrainedCallees (b : Bytecode.Block) : - Array Bytecode.FunIdx := - let opCallees := b.ops.foldl (init := #[]) fun acc op => - match op with - | .call idx _ _ false => acc.push idx - | _ => acc - opCallees ++ b.ctrl.collectConstrainedCallees -termination_by (sizeOf b, 1) -decreasing_by - all_goals first - | decreasing_tactic - | (apply Prod.Lex.left; exact Bytecode.Block.sizeOf_ctrl_lt'' _) -end - -/-- The default circuit partition: one singleton circuit per constrained -function, in function-index order, named by `nameOf`. -/ -def Bytecode.Toplevel.singletonCircuits (t : Bytecode.Toplevel) - (nameOf : Bytecode.FunIdx → String) : Array Bytecode.Circuit := Id.run do - let mut circuits : Array Bytecode.Circuit := #[] - for h : i in [:t.functions.size] do - let f := t.functions[i] - if f.constrained then - circuits := circuits.push - { name := nameOf i, members := #[i], layout := f.layout } - pure circuits - -/-- Compute which functions need a circuit. A function needs a circuit iff it is -reachable from an entry point through a chain of constrained call edges. -/ -def Bytecode.Toplevel.needsCircuit (t : Bytecode.Toplevel) : Array Bool := Id.run do - let n := t.functions.size - let mut needs := Array.replicate n false - let mut stack : Array Bytecode.FunIdx := #[] - for i in [:n] do - if t.functions[i]!.entry then - needs := needs.set! i true - stack := stack.push i - while h : 0 < stack.size do - let fi := stack.back - stack := stack.pop - let callees := t.functions[fi]!.body.collectConstrainedCallees - for callee in callees do - if !needs[callee]! then - needs := needs.set! callee true - stack := stack.push callee - needs - -/-- Full compilation pipeline. -/ -def Source.Toplevel.compile (t : Source.Toplevel) : Except String CompiledToplevel := do - let t ← t.inlineCalls - let typedDecls ← t.checkAndSimplify.mapError toString - let concDecls ← typedDecls.concretize.mapError toString - let (bytecodeRaw, preNameMap) ← concDecls.toBytecode - let (bytecodeDedup, remap) := bytecodeRaw.deduplicate - let needs := bytecodeDedup.needsCircuit - let bytecode : Bytecode.Toplevel := { bytecodeDedup with - functions := bytecodeDedup.functions.mapIdx fun i f => - { f with constrained := needs[i]! } } - let nameMap := preNameMap.fold (init := (∅ : Std.HashMap Global Bytecode.FunIdx)) - fun acc name idx => acc.insert name (remap idx) - -- Singleton circuits are labeled with (one of) the function's source names. - let reverseMap := nameMap.fold (init := (∅ : Std.HashMap Bytecode.FunIdx String)) - fun acc global idx => if acc.contains idx then acc else acc.insert idx (toString global) - let bytecode := { bytecode with - circuits := bytecode.singletonCircuits fun i => reverseMap[i]?.getD s!"" } - pure (CompiledToplevel.mk t bytecode nameMap) - -/-- Name of the environment variable that switches function grouping OFF -process-wide: when it is set to anything but `0` or the empty string, -`compileWithGroups` ignores its grouping and compiles the singleton -partition. For testing and measurement only - the prover and the verifier -must see the same setting, since grouping changes the verifying key. -/ -def noFunctionGroupsEnvVar : String := "IX_NO_FUNCTION_GROUPS" - -unsafe def functionGroupsDisabledUnsafe (_ : Unit) : Bool := - match unsafeBaseIO (IO.getEnv noFunctionGroupsEnvVar) with - | some v => v != "0" && v != "" - | none => false - -@[implemented_by functionGroupsDisabledUnsafe] -opaque functionGroupsDisabledImpl (_ : Unit) : Bool := false - -/-- Whether `IX_NO_FUNCTION_GROUPS` disables function grouping in this -process (see `noFunctionGroupsEnvVar`). -/ -def functionGroupsDisabled : Bool := functionGroupsDisabledImpl () - -/-- `compile`, then apply a function grouping (see -`CompiledToplevel.groupFunctions`) - unless `IX_NO_FUNCTION_GROUPS` is set -(see `noFunctionGroupsEnvVar`), in which case the grouping is ignored and -every constrained function keeps its singleton circuit. -/ -def Source.Toplevel.compileWithGroups (t : Source.Toplevel) - (groups : Array (String × Array String)) : Except String CompiledToplevel := do - let compiled ← t.compile - if functionGroupsDisabled then pure compiled else compiled.groupFunctions groups - -/-- Progress helper: given success of the three `Except`-returning stages, -`compile` as a whole returns `.ok` (the remaining stages — `deduplicate`, -`needsCircuit`, the field-setter `mapIdx`, the name-map `fold`, and the -terminating `pure` — are all total). -/ -theorem Source.Toplevel.compile_ok_of_stages - {t inlined : Source.Toplevel} {typedDecls concDecls bytecodeRaw preNameMap} - (hinline : t.inlineCalls = .ok inlined) - (hts : inlined.checkAndSimplify = .ok typedDecls) - (hconc : typedDecls.concretize = .ok concDecls) - (hbc : concDecls.toBytecode = .ok (bytecodeRaw, preNameMap)) : - ∃ ct, t.compile = .ok ct := by - simp only [Source.Toplevel.compile, hinline, hts, hconc, hbc, Except.mapError, - bind, Except.bind, pure, Except.pure] - exact ⟨_, rfl⟩ - -/-- Inverse of `compile_ok_of_stages`: unpack a successful `compile` into -stage witnesses. Used by `compile_preservation` to thread stage-local -lemmas through the composition. -/ -theorem Source.Toplevel.compile_stages_of_ok - {t : Source.Toplevel} {ct : CompiledToplevel} - (_hct : t.compile = .ok ct) : - ∃ inlined typedDecls concDecls bytecodeRaw preNameMap, - t.inlineCalls = .ok inlined ∧ - inlined.checkAndSimplify = .ok typedDecls ∧ - typedDecls.concretize = .ok concDecls ∧ - concDecls.toBytecode = .ok (bytecodeRaw, preNameMap) := by - -- Case on each stage result; `mapError` on `.ok` is definitionally `.ok`. - cases hinline : t.inlineCalls with - | error e => simp [Source.Toplevel.compile, hinline, bind, Except.bind] at _hct - | ok inlined => - cases hts : inlined.checkAndSimplify with - | error e => simp [Source.Toplevel.compile, hinline, hts, bind, Except.bind, Except.mapError] at _hct - | ok typedDecls => - cases hconc : typedDecls.concretize with - | error e => - simp [Source.Toplevel.compile, hinline, hts, hconc, bind, Except.bind, Except.mapError] at _hct - | ok concDecls => - cases hbc : concDecls.toBytecode with - | error e => - simp [Source.Toplevel.compile, hinline, hts, hconc, hbc, bind, Except.bind, Except.mapError] at _hct - | ok bc => - obtain ⟨bytecodeRaw, preNameMap⟩ := bc - exact ⟨inlined, typedDecls, concDecls, bytecodeRaw, preNameMap, rfl, hts, hconc, hbc⟩ - --- Compile post-conditions moved to `Proofs/StructCompatible.lean`. - -end Aiur - -end -- @[expose] section -end diff --git a/Ix/Aiur/Compiler/Check.lean b/Ix/Aiur/Compiler/Check.lean deleted file mode 100644 index ca0739f89..000000000 --- a/Ix/Aiur/Compiler/Check.lean +++ /dev/null @@ -1,1116 +0,0 @@ -module -public import Ix.Aiur.Stages.Typed -public import Std.Data.HashSet -public import Std.Data.HashMap - -/-! -Type checker: `Source.Toplevel` → `Typed.Decls`. - -The output `Typed.Term` has the flattened `.tuple` / `.array` constructors. -`Match.lean` consumes `Typed.Term` directly, which eliminates the double -`checkFunction` pass. - -Totality requires an `Ix.Array.Induction` helper library. --/ - -public section -@[expose] section - -namespace Aiur - -inductive CheckError - | duplicatedDefinition : Global → CheckError - | unboundGlobal : Global → CheckError - | unboundLocal : Local → CheckError - | notAConstructor : Global → CheckError - | notAValue : Global → CheckError - | notAFunction : Global → CheckError - | cannotApply : Global → CheckError - | notADataType : Global → CheckError - | wrongNumTypeArgs : Global → Nat → Nat → CheckError - | duplicatedTypeParam : Global → String → CheckError - | typeMismatch : Typ → Typ → CheckError - | illegalReturn : CheckError - | wrongNumArgs : Global → Nat → Nat → CheckError - | notATuple : Typ → CheckError - | notAnArray : Typ → CheckError - | emptyArray : CheckError - | indexOoB : Nat → CheckError - | negativeRange : Nat → Nat → CheckError - | rangeOoB : Nat → Nat → CheckError - | incompatiblePattern : Pattern → Typ → CheckError - | differentBindings : List (Local × Typ) → List (Local × Typ) → CheckError - | emptyMatch - | branchMismatch : Typ → Typ → CheckError - | notAPointer : Typ → CheckError - | duplicatedBind : Pattern → CheckError - | typeAliasCycle : Global → CheckError - | unconstrainedConstructor : Global → CheckError - | infiniteType : Nat → Typ → CheckError - | unresolvedMVar : Nat → CheckError - | u8LitOutOfRange : Nat → CheckError - | unconstrainedBigUintDivModType : Typ → CheckError - | entryHasPointer : Global → CheckError - deriving Repr - -instance : ToString CheckError where - toString e := repr e |>.pretty - -open Source - -/-- Apply a type-parameter substitution to a type. -/ -def Typ.instantiate (subst : Global → Option Typ) : Typ → Typ - | .unit => .unit - | .field => .field - | .u8 => .u8 - | .tuple ts => .tuple (ts.attach.map (fun ⟨t, _⟩ => Typ.instantiate subst t)) - | .array t n => .array (Typ.instantiate subst t) n - | .pointer t => .pointer (Typ.instantiate subst t) - | .ref g => (subst g).getD (.ref g) - | .app g args => .app g (args.attach.map (fun ⟨t, _⟩ => Typ.instantiate subst t)) - | .function ins out => - .function (ins.attach.map (fun ⟨t, _⟩ => Typ.instantiate subst t)) (Typ.instantiate subst out) - | .mvar n => .mvar n -termination_by t => sizeOf t - -def mkParamSubst (params : List String) (args : Array Typ) : Global → Option Typ := - let m : Std.HashMap Global Typ := (params.zip args.toList).foldl - (fun m (p, t) => m.insert (Global.init p) t) {} - fun g => m[g]? - -/-- Bounded alias-expansion. The `bound` caps how many times we can re-enter -via a `.app`/`.ref` alias expansion; the outer interface uses -`toplevelAliases.size + 1`, which the monotonic growth of `visited` (capped -at `toplevelAliases.size`) guarantees is never exhausted on well-formed -inputs. -/ -def expandTypeMBound : Nat → Std.HashSet Global → Array TypeAlias → - Typ → StateT (Std.HashMap Global Typ) (Except CheckError) Typ - | _, _, _, .unit => pure .unit - | _, _, _, .field => pure .field - | _, _, _, .u8 => pure .u8 - | bound, visited, tops, .pointer t => do - pure $ .pointer (← expandTypeMBound bound visited tops t) - | bound, visited, tops, .function inputs output => do - let inputs' ← inputs.attach.mapM fun ⟨t, _⟩ => - expandTypeMBound bound visited tops t - let output' ← expandTypeMBound bound visited tops output - pure $ .function inputs' output' - | bound, visited, tops, .tuple ts => do - let ts' ← ts.attach.mapM fun ⟨t, _⟩ => - expandTypeMBound bound visited tops t - pure $ .tuple ts' - | bound, visited, tops, .array t n => do - let t' ← expandTypeMBound bound visited tops t - pure $ .array t' n - | bound, visited, tops, .app g args => do - let args' ← args.attach.mapM fun ⟨t, _⟩ => - expandTypeMBound bound visited tops t - if let some alias := tops.find? (·.name == g) then - if visited.contains g then - throw $ .typeAliasCycle g - if alias.params.length != args'.size then - throw $ .wrongNumTypeArgs g alias.params.length args'.size - let subst := mkParamSubst alias.params args' - let instantiated := Typ.instantiate subst alias.expansion - match bound with - | 0 => pure $ .app g args' -- bound exhausted; fall back - | bound+1 => - expandTypeMBound bound (visited.insert g) tops instantiated - else - pure $ .app g args' - | bound, visited, tops, .ref g => do - let aliasMap ← get - if let some expanded := aliasMap[g]? then - return expanded - if let some (alias : TypeAlias) := tops.find? (·.name == g) then - if visited.contains g then - throw $ .typeAliasCycle g - if !alias.params.isEmpty then - throw $ .wrongNumTypeArgs g alias.params.length 0 - match bound with - | 0 => pure $ .ref g -- bound exhausted; fall back - | bound+1 => - let expanded ← expandTypeMBound bound (visited.insert g) - tops alias.expansion - set (aliasMap.insert g expanded) - return expanded - else - pure $ .ref g - | _, _, _, .mvar n => pure $ .mvar n -termination_by bound _ _ t => (bound, sizeOf t) -decreasing_by - all_goals first - | decreasing_tactic - | (apply Prod.Lex.left; omega) - | (apply Prod.Lex.right - first - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; simp +arith; omega) - | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; simp +arith; omega) - | (simp +arith; omega) - | grind) - -/-- Outer interface. Uses `toplevelAliases.size + 1` as the bound. -/ -def expandTypeM (visited : Std.HashSet Global) (toplevelAliases : Array TypeAlias) - (t : Typ) : StateT (Std.HashMap Global Typ) (Except CheckError) Typ := - expandTypeMBound (toplevelAliases.size + 1) visited toplevelAliases t - -/-- Constructs a map of declarations from a toplevel, expanding all type aliases. -/ -def Source.Toplevel.mkDecls (toplevel : Source.Toplevel) : Except CheckError Source.Decls := do - let mut allNames : Std.HashSet Global := {} - for alias in toplevel.typeAliases do - if allNames.contains alias.name then - throw $ .duplicatedDefinition alias.name - allNames := allNames.insert alias.name - - let initAliasMap := {} - let (_, finalAliasMap) ← (toplevel.typeAliases.mapM fun (alias : TypeAlias) => do - let expanded ← expandTypeM {} toplevel.typeAliases alias.expansion - modify fun (aliasMap : Std.HashMap Global Typ) => aliasMap.insert alias.name expanded - ).run initAliasMap - - let expandTyp (typ : Typ) : Except CheckError Typ := - (expandTypeM {} toplevel.typeAliases typ).run' finalAliasMap - - let mut decls : Decls := default - for function in toplevel.functions do - if allNames.contains function.name then - throw $ .duplicatedDefinition function.name - allNames := allNames.insert function.name - let inputs' ← function.inputs.mapM fun (loc, typ) => do - let typ' ← expandTyp typ - pure (loc, typ') - let output' ← expandTyp function.output - let function' : Source.Function ← - match hEntry : function.entry with - | true => - if hSig : sigPointerFree inputs' output' = true then - pure { function with inputs := inputs', output := output', entryPointerFree := Or.inl hSig } - else - throw $ .entryHasPointer function.name - | false => - pure { function with inputs := inputs', output := output', entryPointerFree := Or.inr hEntry } - decls := decls.insert function.name (.function function') - - for dataType in toplevel.dataTypes do - if allNames.contains dataType.name then - throw $ .duplicatedDefinition dataType.name - allNames := allNames.insert dataType.name - let mut constructors : List Constructor := [] - for ctor in dataType.constructors do - let argTypes' ← ctor.argTypes.mapM expandTyp - constructors := constructors.concat { ctor with argTypes := argTypes' } - let dataType' := { dataType with constructors } - decls := decls.insert dataType.name (.dataType dataType') - for ctor in constructors do - let ctorName := dataType.name.pushNamespace ctor.nameHead - if allNames.contains ctorName then - throw $ .duplicatedDefinition ctorName - allNames := allNames.insert ctorName - decls := decls.insert ctorName (.constructor dataType' ctor) - - pure decls - -/-! ## Inference monad and unification -/ - -structure CheckContext where - decls : Decls - varTypes : Std.HashMap Local Typ - returnType : Typ - typeParams : List String - -structure CheckState where - nextMVar : Nat := 0 - mvarSubst : Std.HashMap Nat Typ := {} - -abbrev CheckM := ReaderT CheckContext (StateT CheckState (Except CheckError)) - -def freshMVar : CheckM Typ := do - let idx := (← get).nextMVar - modify fun s => { s with nextMVar := s.nextMVar + 1 } - pure $ .mvar idx - -/-! ## mvar-chain helpers - -`walkTyp` follows the mvar substitution chain until it hits a non-mvar or an -unbound mvar. With the occurs check maintained by `bindMVar`, the chain is -acyclic in practice; the `visited` set makes the function total regardless, -and the `bound` parameter caps the Nat-termination measure. - -Outer interface `walkTyp` uses `CheckState.nextMVar + 1` as the bound — -every mvar id is `< nextMVar`, and the visited set ensures no id is visited -twice, so the chain length is at most `nextMVar`. -/ - -/-- Bounded walk; see `walkTyp` for the outer interface. -/ -def walkTypBound : Nat → Std.HashSet Nat → Typ → CheckM Typ - | bound, visited, .mvar id => do - if visited.contains id then pure (.mvar id) - else match bound with - | 0 => pure (.mvar id) - | bound+1 => - match (← get).mvarSubst[id]? with - | some t => walkTypBound bound (visited.insert id) t - | none => pure (.mvar id) - | _, _, t => pure t -termination_by bound _ _ => bound - -/-- Outer interface. The bound is `nextMVar + 1`, which cannot be exhausted -because the visited set grows by one on each step and is capped at `nextMVar`. -Returns the original type if the chain bound runs out (defensive). -/ -def walkTyp (t : Typ) : CheckM Typ := do - let s ← get - walkTypBound (s.nextMVar + 1) {} t - -/-- Bounded occurs check. Follows both mvar chains and the structural -recursion through `Typ`. -/ -def occursInBound : Nat → Nat → Std.HashSet Nat → Typ → CheckM Bool - | id, bound, visited, .mvar id' => do - if id == id' then pure true - else if visited.contains id' then pure false - else match bound with - | 0 => pure false - | bound+1 => - match (← get).mvarSubst[id']? with - | some t => occursInBound id bound (visited.insert id') t - | none => pure false - | id, bound, visited, .tuple ts => - ts.attach.anyM fun ⟨t, _⟩ => occursInBound id bound visited t - | id, bound, visited, .array t _ => occursInBound id bound visited t - | id, bound, visited, .pointer t => occursInBound id bound visited t - | id, bound, visited, .function ins out => do - if ← ins.attach.anyM fun ⟨t, _⟩ => occursInBound id bound visited t then - pure true - else occursInBound id bound visited out - | id, bound, visited, .app _ args => - args.attach.anyM fun ⟨t, _⟩ => occursInBound id bound visited t - | _, _, _, _ => pure false -termination_by _ bound _ t => (bound, sizeOf t) -decreasing_by - all_goals first - | decreasing_tactic - | (apply Prod.Lex.left; omega) - | (apply Prod.Lex.right - first - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; simp +arith; omega) - | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; simp +arith; omega) - | (simp +arith; omega) - | grind) - -/-- Outer interface for the occurs check. -/ -def occursIn (id : Nat) (t : Typ) : CheckM Bool := do - let s ← get - occursInBound id (s.nextMVar + 1) {} t - -def bindMVar (id : Nat) (t : Typ) : CheckM Unit := do - if ← occursIn id t then throw $ .infiniteType id t - modify fun s => { s with mvarSubst := s.mvarSubst.insert id t } - -/-- Bounded unification. The `bound` caps the structural recursion depth after -each `walkTyp` call — each recursive step consumes one unit of `bound`. On -well-formed inputs, `sizeOf t1 + sizeOf t2 + nextMVar + 1` is always enough, -which is what the outer `unifyTyp` uses. - -When `bound` runs out we return `false` (defensive) rather than diverging. -/ -def unifyTypBound : Nat → Typ → Typ → CheckM Bool - | 0, _, _ => pure false - | bound+1, t1, t2 => do - let t1 ← walkTyp t1 - let t2 ← walkTyp t2 - match t1, t2 with - | .mvar a, .mvar b => - if a == b then pure true else do bindMVar a (.mvar b); pure true - | .mvar a, _ => do bindMVar a t2; pure true - | _, .mvar b => do bindMVar b t1; pure true - | .unit, .unit | .field, .field | .u8, .u8 => pure true - | .tuple ts1, .tuple ts2 => - if ts1.size != ts2.size then pure false else - ts1.zip ts2 |>.allM fun (x, y) => unifyTypBound bound x y - | .array t1' n1, .array t2' n2 => - if n1 != n2 then pure false else unifyTypBound bound t1' t2' - | .pointer t1', .pointer t2' => unifyTypBound bound t1' t2' - | .ref g1, .ref g2 => pure (g1 == g2) - | .function ins1 out1, .function ins2 out2 => do - if ins1.length != ins2.length then pure false else - let inOk ← ins1.zip ins2 |>.allM fun (x, y) => unifyTypBound bound x y - if !inOk then pure false else unifyTypBound bound out1 out2 - | .app g1 a1, .app g2 a2 => - if g1 != g2 || a1.size != a2.size then pure false else - a1.zip a2 |>.allM fun (x, y) => unifyTypBound bound x y - | _, _ => pure false -termination_by bound _ _ => bound - -/-- Computable structural "node count" on `Typ`. Used as a finite, runtime- -available proxy for `sizeOf` in `unifyTyp`'s bound. -/ -def Typ.nodeCount : Typ → Nat - | .unit => 1 - | .field => 1 - | .u8 => 1 - | .mvar _ => 1 - | .ref _ => 1 - | .pointer t => 1 + Typ.nodeCount t - | .array t _ => 1 + Typ.nodeCount t - | .tuple ts => 1 + ts.attach.foldl (init := 0) fun acc ⟨t, _⟩ => acc + Typ.nodeCount t - | .function ins out => - 1 + Typ.nodeCount out + ins.foldl (fun acc t => acc + Typ.nodeCount t) 0 - | .app _ args => 1 + args.attach.foldl (init := 0) fun acc ⟨t, _⟩ => acc + Typ.nodeCount t -termination_by t => sizeOf t -decreasing_by - all_goals first - | decreasing_tactic - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - | grind - -/-- Outer interface. Uses `nextMVar + Typ.nodeCount t1 + Typ.nodeCount t2 + 1` -as a bound, which is guaranteed large enough for any well-formed pair of -types under any valid mvar substitution. -/ -def unifyTyp (t1 t2 : Typ) : CheckM Bool := do - let s ← get - unifyTypBound (s.nextMVar + t1.nodeCount + t2.nodeCount + 1) t1 t2 - -/-- Bounded zonk. Follows mvar chains via the `bound`/`visited` pattern, and -structurally recurses through `Typ`. -/ -def zonkTypBound : Nat → Std.HashSet Nat → Typ → CheckM Typ - | bound, visited, .mvar id => do - if visited.contains id then pure (.mvar id) - else match bound with - | 0 => pure (.mvar id) - | bound+1 => - match (← get).mvarSubst[id]? with - | some t => zonkTypBound bound (visited.insert id) t - | none => pure (.mvar id) - | bound, visited, .tuple ts => do - pure $ .tuple (← ts.attach.mapM fun ⟨t, _⟩ => zonkTypBound bound visited t) - | bound, visited, .array t n => do - pure $ .array (← zonkTypBound bound visited t) n - | bound, visited, .pointer t => do - pure $ .pointer (← zonkTypBound bound visited t) - | bound, visited, .function ins out => do - pure $ .function (← ins.attach.mapM fun ⟨t, _⟩ => zonkTypBound bound visited t) - (← zonkTypBound bound visited out) - | bound, visited, .app g args => do - pure $ .app g (← args.attach.mapM fun ⟨t, _⟩ => zonkTypBound bound visited t) - | _, _, t => pure t -termination_by bound _ t => (bound, sizeOf t) -decreasing_by - all_goals first - | decreasing_tactic - | (apply Prod.Lex.left; omega) - | (apply Prod.Lex.right - first - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; simp +arith; omega) - | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; simp +arith; omega) - | (simp +arith; omega) - | grind) - -/-- Outer interface. Uses `nextMVar + 1` as a safe bound on the mvar chain -length. -/ -def zonkTyp (t : Typ) : CheckM Typ := do - let s ← get - zonkTypBound (s.nextMVar + 1) {} t - -/-- Fixed signature of `unconstrainedBigUintDivMod`: the inputs are lists -of U64 limbs — a pointer to a list datatype instantiated at `[U8; 8]` -(e.g. `KLimbs = List‹U64›`) — and each result is the SAME list datatype -instantiated at `[G; 8]`. The result limbs are UNCONSTRAINED prover -advice, so they must not type as range-checked bytes; consumers rebuild -`u8` limbs via `u8_range_check` (see `glimbs_to_klimbs` in the IxVM -kernel). The list's constructor shape is not verified here; the runtime -BigUint::div_rem faults on a malformed chain. Takes the ZONKED input -type. -/ -def bigUintDivModResultTyp : Typ → CheckM Typ - | .pointer (.app g #[.array .u8 8]) => - pure (.pointer (.app g #[.array .field 8])) - | τ => throw $ .unconstrainedBigUintDivModType τ - -def instantiateParams (params : List String) : CheckM (Array Typ × (Global → Option Typ)) := do - let mvars ← (params.toArray.mapM fun _ => freshMVar) - pure (mvars, mkParamSubst params mvars) - -/-! ## Type inference — produces Typed.Term -/ - -def refLookup (global : Global) : CheckM (Typ × Array Typ) := do - let ctx ← read - match ctx.decls.getByKey global with - | some (.function function) => - if function.params.isEmpty then - pure (.function (function.inputs.map Prod.snd) function.output, #[]) - else - let (mvars, subst) ← instantiateParams function.params - let inputs := function.inputs.map (Typ.instantiate subst ∘ Prod.snd) - let output := Typ.instantiate subst function.output - pure (.function inputs output, mvars) - | some (.constructor dataType constructor) => - let args := constructor.argTypes - unless args.isEmpty do (throw $ .wrongNumArgs global args.length 0) - if dataType.params.isEmpty then - pure (.ref dataType.name, #[]) - else - let (mvars, _) ← instantiateParams dataType.params - pure (.app dataType.name mvars, mvars) - | some _ => throw $ .notAValue global - | none => throw $ .unboundGlobal global - -def bindIdents (bindings : List (Local × Typ)) (ctx : CheckContext) : CheckContext := - { ctx with varTypes := ctx.varTypes.insertMany bindings } - -/-- Convenience: wrap an `Aiur.Typ`-typed `Term` constructor for the unop family. -/ -abbrev TypedUnop := Typ → Bool → Typed.Term → Typed.Term -abbrev TypedBinop := Typ → Bool → Typed.Term → Typed.Term → Typed.Term - -/-! ## Pattern checker - -`checkPatternAux` / `checkPattern` are total and live outside the inferTerm -mutual block — they never call into it, only the other direction. -/ - -mutual - -/-- Pattern-recursive worker for `checkPattern`. Recursion is delegated to -`checkPatternsArr` / `checkPatternsList` / `checkPatternsArrUniform` so the -termination of each arm is visible structurally: the helpers recurse on -sub-`Array`/`List` of the matched constructor. -/ -def checkPatternAux (pat : Pattern) (typ : Typ) : CheckM (List (Local × Typ)) := do - let typ ← walkTyp typ - match pat with - | .var var => pure [(var, typ)] - | .wildcard => pure [] - | .field _ => - -- A numeric-literal pattern matches both `field` and `u8` scrutinees: a - -- `u8` is a field element, so comparing it against a byte constant is sound. - match typ with - | .field | .u8 => pure [] - | _ => throw $ .incompatiblePattern pat typ - | .tuple pats => - match typ with - | .tuple typs => do - unless pats.size == typs.size do throw $ .incompatiblePattern pat typ - checkPatternsArr pats typs - | _ => throw $ .incompatiblePattern pat typ - | .array pats => - match typ with - | .array innerTyp n => do - unless pats.size == n do throw $ .incompatiblePattern pat typ - checkPatternsArrUniform pats innerTyp - | _ => throw $ .incompatiblePattern pat typ - | .ref refName pats => - match typ with - | tFn@(.function ..) => - if pats.isEmpty then do - let ctx ← read - let some (.function function) := ctx.decls.getByKey refName - | throw $ .incompatiblePattern pat typ - let typ' := .function (function.inputs.map Prod.snd) function.output - unless ← unifyTyp tFn typ' do throw $ .typeMismatch tFn typ' - pure [] - else throw $ .incompatiblePattern pat typ - | .ref dataTypeRef => do - let ctx ← read - let some (.dataType dataType) := ctx.decls.getByKey dataTypeRef - | throw $ .unboundGlobal dataTypeRef - let some (.constructor dataType' constr) := ctx.decls.getByKey refName - | throw $ .notAConstructor refName - unless dataType == dataType' do throw $ .incompatiblePattern pat typ - let typs := constr.argTypes - unless pats.length == typs.length do throw $ .wrongNumArgs refName pats.length typs.length - checkPatternsList pats typs - | .app dataTypeRef args => do - let ctx ← read - let some (.dataType dataType) := ctx.decls.getByKey dataTypeRef - | throw $ .unboundGlobal dataTypeRef - let some (.constructor dataType' constr) := ctx.decls.getByKey refName - | throw $ .notAConstructor refName - unless dataType == dataType' do throw $ .incompatiblePattern pat typ - let subst := mkParamSubst dataType.params args - let typs := constr.argTypes.map (Typ.instantiate subst) - unless pats.length == typs.length do throw $ .wrongNumArgs refName pats.length typs.length - checkPatternsList pats typs - | _ => throw $ .incompatiblePattern pat typ - | .or p1 p2 => do - let bind ← checkPatternAux p1 typ - let bind' ← checkPatternAux p2 typ - if bind != bind' then throw $ .differentBindings bind bind' else pure bind - | .pointer p => - match typ with - | .pointer innerTyp => checkPatternAux p innerTyp - | _ => throw $ .incompatiblePattern pat typ -termination_by (sizeOf pat, 0) - -/-- Pair-up `pats` and `typs` (both `Array`) and run `checkPatternAux` on each, -concatenating bindings. The per-element recursion decreases on `sizeOf pats`. -/ -def checkPatternsArr (pats : Array Pattern) (typs : Array Typ) : - CheckM (List (Local × Typ)) := - pats.attach.zip typs |>.foldlM (init := []) fun acc (⟨pat, hmem⟩, typ) => do - have : sizeOf pat < sizeOf pats := Array.sizeOf_lt_of_mem hmem - let sub ← checkPatternAux pat typ - pure (acc.append sub) -termination_by (sizeOf pats, 1) -decreasing_by all_goals first | decreasing_tactic | omega - -/-- Like `checkPatternsArr`, but every pattern is matched against the same -element type `innerTyp` (used for `.array` patterns). -/ -def checkPatternsArrUniform (pats : Array Pattern) (innerTyp : Typ) : - CheckM (List (Local × Typ)) := - pats.attach.foldlM (init := []) fun acc ⟨pat, hmem⟩ => do - have : sizeOf pat < sizeOf pats := Array.sizeOf_lt_of_mem hmem - let sub ← checkPatternAux pat innerTyp - pure (acc.append sub) -termination_by (sizeOf pats, 1) -decreasing_by all_goals first | decreasing_tactic | omega - -/-- List version of `checkPatternsArr`. -/ -def checkPatternsList (pats : List Pattern) (typs : List Typ) : - CheckM (List (Local × Typ)) := - pats.attach.zip typs |>.foldlM (init := []) fun acc (⟨pat, hmem⟩, typ) => do - have : sizeOf pat < sizeOf pats := List.sizeOf_lt_of_mem hmem - let sub ← checkPatternAux pat typ - pure (acc.append sub) -termination_by (sizeOf pats, 1) -decreasing_by all_goals first | decreasing_tactic | omega - -end - -def checkPattern (pat : Pattern) (typ : Typ) : CheckM (List (Local × Typ)) := do - let binds ← checkPatternAux pat typ - let locals := binds.map Prod.fst - unless (locals == locals.eraseDups) do throw $ .duplicatedBind pat - pure binds - -/-! ## Type inference - -All the old helper functions (`inferAssertEq`, `inferLet`, `inferProj`, -`inferApplication` and its chain, etc.) have been inlined into `inferTerm`'s -big match. The only surviving mutual-block members are: -- `inferTerm` — the dispatcher, recurses structurally on sub-`Term`s. -- `checkNoEscape` / `inferNoEscape` — wrap `inferTerm` on the same `Term`. -- `checkArgsAndInputs` — one-level helper for `.app`; recurses via - `checkNoEscape` on each arg, which is a `∈` subterm of the caller. -- `checkMatchBranch` — one-level helper for `.match`; recurses via - `inferTerm` on the branch body, a subterm of the `branchData` pair. - -Lex measure `(sizeOf input, prio)`: -- `inferTerm` at prio 0 (callees go "upward" via `Lex.right`) -- the rest at prio 1 -This works because every `inferTerm → X` call decreases `sizeOf` strictly -(sub-`Term` of `t`), and every `X → inferTerm` call either stays same -size with priority decrease (`checkNoEscape`, `inferNoEscape`) or decreases -size strictly (`checkMatchBranch`, `checkArgsAndInputs` via member args). -/ - -mutual - -def inferTerm (t : Term) : CheckM Typed.Term := match t with - | .unit => pure (.unit .unit false) - | .var x => do - let ctx ← read - match (ctx.varTypes[x]?, x) with - | (some t, _) => pure (.var t false x) - | (none, Local.str localName) => - let (typ, _) ← refLookup (Global.init localName) - pure (.var typ false x) - | (none, _) => throw $ .unboundLocal x - | .ref x => do - let (typ, tArgs) ← refLookup x - pure (.ref typ false x tArgs) - | .ret term => do - let ctx ← read - let term' ← checkNoEscape term ctx.returnType - pure (Typed.Term.ret ctx.returnType true term') - | .field g => pure (.field .field false g) - | .tuple ts => do - let typedTerms ← ts.attach.mapM fun ⟨t, _⟩ => inferNoEscape t - let typs := typedTerms.map (·.typ) - pure (Typed.Term.tuple (.tuple typs) false typedTerms) - | .array ts => do - if h : ts.size > 0 then - let first ← inferNoEscape ts[0] - -- Check every element against first.typ (re-checks ts[0] trivially). - let typedTerms ← ts.attach.mapM fun ⟨t, _⟩ => checkNoEscape t first.typ - pure (Typed.Term.array (.array first.typ ts.size) false typedTerms) - else throw .emptyArray - | .let pat expr body => do - let expr' ← inferNoEscape expr - let bindings ← checkPattern pat expr'.typ - let body' ← withReader (bindIdents bindings) (inferTerm body) - pure (Typed.Term.let body'.typ body'.escapes pat expr' body') - | .match term branches => do - let term' ← inferNoEscape term - let init := ([], none) - let (branches', typOpt) ← branches.attach.foldrM (init := init) - (fun ⟨branchData, _⟩ acc => checkMatchBranch term'.typ branchData acc) - match typOpt with - | some (typ, escapes) => pure (Typed.Term.match typ escapes term' branches') - | none => throw .emptyMatch - | .app func args mode => do - -- `.inlined` is eliminated by `Toplevel.inlineCalls` before checking; - -- reaching it here means the pass was skipped. Downstream stages carry - -- only the unconstrained flag. - let u : Bool ← match mode with - | .normal => pure false - | .unconstrained => pure true - | .inlined => throw (.cannotApply func) - let ctx ← read - -- Local function lookup (only for unqualified names); returns - -- `some (.ok …)` on hit, `some (.error …)` on wrong-type local, `none` to - -- fall through to global lookup. - let localLookup : Option (Except CheckError (Typ × List Typ)) := - match func.toName with - | .str .anonymous s => - match ctx.varTypes[Local.str s]? with - | some (.function ins out) => some (.ok (out, ins)) - | some _ => some (.error (.notAFunction func)) - | none => none - | _ => none - match localLookup with - | some (.error e) => throw e - | some (.ok (output, inputs)) => - let args' ← checkArgsAndInputs func args inputs - pure (Typed.Term.app output false func #[] args' u) - | none => - match ctx.decls.getByKey func with - | some (.function function) => - if function.params.isEmpty then - let args' ← checkArgsAndInputs func args (function.inputs.map Prod.snd) - pure (Typed.Term.app function.output false func #[] args' u) - else - let (mvars, subst) ← instantiateParams function.params - let inputTypes := function.inputs.map (Typ.instantiate subst ∘ Prod.snd) - let output := Typ.instantiate subst function.output - let args' ← checkArgsAndInputs func args inputTypes - pure (Typed.Term.app output false func mvars args' u) - | some (.constructor dataType constr) => - if u then throw $ .unconstrainedConstructor func - if dataType.params.isEmpty then - let args' ← checkArgsAndInputs func args constr.argTypes - pure (Typed.Term.app (.ref dataType.name) false func #[] args' u) - else - let (mvars, subst) ← instantiateParams dataType.params - let argTypes := constr.argTypes.map (Typ.instantiate subst) - let args' ← checkArgsAndInputs func args argTypes - pure (Typed.Term.app (.app dataType.name mvars) false func mvars args' u) - | _ => throw $ .cannotApply func - | .ann typ term => checkNoEscape term typ - | .proj tup i => do - let tup' ← inferNoEscape tup - match ← walkTyp tup'.typ with - | .tuple typs => - if h : i < typs.size then - pure (Typed.Term.proj typs[i] false tup' i) - else throw $ .indexOoB i - | typ' => throw $ .notATuple typ' - | .get arr i => do - let arr' ← inferNoEscape arr - match ← walkTyp arr'.typ with - | .array typ n => - if i ≥ n then throw $ .indexOoB i - else pure (Typed.Term.get typ false arr' i) - | typ' => throw $ .notAnArray typ' - | .slice arr i j => - if j < i then throw $ .negativeRange i j else do - let arr' ← inferNoEscape arr - match ← walkTyp arr'.typ with - | .array typ n => - if j ≤ n then - pure (Typed.Term.slice (.array typ (j - i)) false arr' i j) - else throw $ .rangeOoB i j - | typ' => throw $ .notAnArray typ' - | .set arr i val => do - let arr' ← inferNoEscape arr - match ← walkTyp arr'.typ with - | .array typ n => - if i ≥ n then throw $ .indexOoB i - else - let val' ← checkNoEscape val typ - pure (Typed.Term.set (.array typ n) false arr' i val') - | typ' => throw $ .notAnArray typ' - | .store term => do - let term' ← inferNoEscape term - pure (Typed.Term.store (.pointer term'.typ) false term') - | .load term => do - let term' ← inferNoEscape term - match ← walkTyp term'.typ with - | .pointer innerTyp => pure (Typed.Term.load innerTyp false term') - | typ' => throw $ .notAPointer typ' - | .ptrVal term => do - let term' ← inferNoEscape term - match ← walkTyp term'.typ with - | .pointer _ => pure (Typed.Term.ptrVal .field false term') - | typ' => throw $ .notAPointer typ' - | .eqZero a => do - let a' ← checkNoEscape a .field - pure (Typed.Term.eqZero .field false a') - | .add a b => do - let a' ← checkNoEscape a .field - let b' ← checkNoEscape b .field - pure (Typed.Term.add .field false a' b') - | .sub a b => do - let a' ← checkNoEscape a .field - let b' ← checkNoEscape b .field - pure (Typed.Term.sub .field false a' b') - | .mul a b => do - let a' ← checkNoEscape a .field - let b' ← checkNoEscape b .field - pure (Typed.Term.mul .field false a' b') - | .u8ShiftLeft a => do - let a' ← checkNoEscape a .u8 - pure (Typed.Term.u8ShiftLeft .u8 false a') - | .u8ShiftRight a => do - let a' ← checkNoEscape a .u8 - pure (Typed.Term.u8ShiftRight .u8 false a') - | .u8BitDecomposition a => do - -- Bits are 0/1 values, kept as plain `field`. - let a' ← checkNoEscape a .u8 - pure (Typed.Term.u8BitDecomposition (.array .field 8) false a') - | .u8Xor a b => do - let a' ← checkNoEscape a .u8 - let b' ← checkNoEscape b .u8 - pure (Typed.Term.u8Xor .u8 false a' b') - | .u8And a b => do - let a' ← checkNoEscape a .u8 - let b' ← checkNoEscape b .u8 - pure (Typed.Term.u8And .u8 false a' b') - | .u8Or a b => do - let a' ← checkNoEscape a .u8 - let b' ← checkNoEscape b .u8 - pure (Typed.Term.u8Or .u8 false a' b') - | .u8Add a b => do - -- Low byte and the 0/1 carry are both `u8` (the carry is provably in range: - -- the add lookup forces the inputs to be bytes, so `carry ∈ {0, 1}`). - let a' ← checkNoEscape a .u8 - let b' ← checkNoEscape b .u8 - pure (Typed.Term.u8Add (.tuple #[.u8, .u8]) false a' b') - | .u8Mul a b => do - -- Both low and high bytes are `u8`. - let a' ← checkNoEscape a .u8 - let b' ← checkNoEscape b .u8 - pure (Typed.Term.u8Mul (.tuple #[.u8, .u8]) false a' b') - | .u8XorSplit7 a b => do - let a' ← checkNoEscape a .u8 - let b' ← checkNoEscape b .u8 - pure (Typed.Term.u8XorSplit7 (.tuple #[.u8, .u8]) false a' b') - | .u8XorSplit4 a b => do - let a' ← checkNoEscape a .u8 - let b' ← checkNoEscape b .u8 - pure (Typed.Term.u8XorSplit4 (.tuple #[.u8, .u8]) false a' b') - | .u8Sub a b => do - -- Low byte and the 0/1 borrow are both `u8` (same range argument as add). - let a' ← checkNoEscape a .u8 - let b' ← checkNoEscape b .u8 - pure (Typed.Term.u8Sub (.tuple #[.u8, .u8]) false a' b') - | .u8LessThan a b => do - -- Result is a 0/1 flag (`field`). - let a' ← checkNoEscape a .u8 - let b' ← checkNoEscape b .u8 - pure (Typed.Term.u8LessThan .field false a' b') - | .u32LessThan a b => do - let a' ← checkNoEscape a .field - let b' ← checkNoEscape b .field - pure (Typed.Term.u32LessThan .field false a' b') - | .unconstrainedU32Add a b => do - let word : Typ := .array .u8 4 - let a' ← checkNoEscape a word - let b' ← checkNoEscape b word - pure (Typed.Term.unconstrainedU32Add (.tuple #[.array .field 4, .field]) false a' b') - | .unconstrainedU32Add3 a b c => do - let word : Typ := .array .u8 4 - let a' ← checkNoEscape a word - let b' ← checkNoEscape b word - let c' ← checkNoEscape c word - pure (Typed.Term.unconstrainedU32Add3 (.tuple #[.array .field 4, .field]) false a' b' c') - | .u32ToField a => do - let a' ← checkNoEscape a (.array .u8 4) - pure (Typed.Term.u32ToField .field false a') - | .u8Lit n => do - if n ≥ 256 then throw (.u8LitOutOfRange n) - pure (Typed.Term.field .u8 false (G.ofNat n)) - | .u8RangeCheck a b => do - let a' ← checkNoEscape a .field - let b' ← checkNoEscape b .field - pure (Typed.Term.u8RangeCheck (.tuple #[.u8, .u8]) false a' b') - | .unconstrainedBigUintDivMod a b => do - -- See `bigUintDivModResultTyp` for the op's fixed signature. - let a' ← inferNoEscape a - let b' ← checkNoEscape b a'.typ - let τ ← bigUintDivModResultTyp (← zonkTyp a'.typ) - pure (Typed.Term.unconstrainedBigUintDivMod (.tuple #[τ, τ]) false a' b') - | .unconstrainedGToBytes a => do - -- The bytes are UNCONSTRAINED advice, so they come back as raw - -- `field`s — they must not type as range-checked bytes. Consumers - -- mint `u8`s from the `u8_range_check` outputs (see `gl_to_bytes` - -- and `idx_to_u64`). - let a' ← checkNoEscape a .field - pure (Typed.Term.unconstrainedGToBytes (.array .field 8) false a') - | .unconstrainedGInverse a => do - let a' ← checkNoEscape a .field - pure (Typed.Term.unconstrainedGInverse .field false a') - | .toField a => do - let a' ← checkNoEscape a .u8 - pure (Typed.Term.toField .field false a') - | .u8FromFieldUnsafe a => do - let a' ← checkNoEscape a .field - pure (Typed.Term.u8FromFieldUnsafe .u8 false a') - | .ioGetInfo channel key => do - let channel' ← checkNoEscape channel .field - let key' ← inferNoEscape key - match ← walkTyp key'.typ with - | .array .. => - pure (Typed.Term.ioGetInfo (.tuple #[.field, .field]) false channel' key') - | typ' => throw $ .notAnArray typ' - | .ioSetInfo channel key idx len ret => do - let channel' ← checkNoEscape channel .field - let key' ← inferNoEscape key - match ← walkTyp key'.typ with - | .array keyEltTyp _ => - unless ← unifyTyp keyEltTyp .field do throw $ .typeMismatch .field keyEltTyp - let idx' ← checkNoEscape idx .field - let len' ← checkNoEscape len .field - let ret' ← inferTerm ret - pure (Typed.Term.ioSetInfo ret'.typ ret'.escapes channel' key' idx' len' ret') - | typ' => throw $ .notAnArray typ' - | .ioRead channel idx len => do - if len = 0 then throw .emptyArray - let channel' ← checkNoEscape channel .field - let idx' ← checkNoEscape idx .field - pure (Typed.Term.ioRead (.array .field len) false channel' idx' len) - | .ioWrite channel data ret => do - let channel' ← checkNoEscape channel .field - let data' ← inferNoEscape data - match ← walkTyp data'.typ with - | .array dataEltTyp _ => - unless ← unifyTyp dataEltTyp .field do throw $ .typeMismatch .field dataEltTyp - let ret' ← inferTerm ret - pure (Typed.Term.ioWrite ret'.typ ret'.escapes channel' data' ret') - | typ' => throw $ .notAnArray typ' - | .assertEq a b msg ret => do - let a' ← inferNoEscape a - let b' ← checkNoEscape b a'.typ - let ret' ← inferTerm ret - pure (Typed.Term.assertEq ret'.typ ret'.escapes a' b' msg ret') - | .debug label term ret => do - let term' ← match term with - | none => pure none - | some sub => do pure (some (← inferTerm sub)) - let ret' ← inferTerm ret - pure (Typed.Term.debug ret'.typ ret'.escapes label term' ret') -termination_by (sizeOf t, 0) -decreasing_by - all_goals first - | decreasing_tactic - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - | (cases term <;> simp_all +arith) - | grind - -def checkNoEscape (term : Term) (typ : Typ) : CheckM Typed.Term := do - let typedTerm ← inferTerm term - if typedTerm.escapes then throw .illegalReturn - unless ← unifyTyp typ typedTerm.typ do throw $ .typeMismatch typ typedTerm.typ - pure typedTerm -termination_by (sizeOf term, 1) - -def inferNoEscape (term : Term) : CheckM Typed.Term := do - let typedTerm ← inferTerm term - if typedTerm.escapes then throw .illegalReturn - pure typedTerm -termination_by (sizeOf term, 1) - -/-- Arg/input checker extracted from the `.app` arm. Recurses into -`checkNoEscape` once per arg; each `arg ∈ args` so `sizeOf arg < sizeOf args`. -Sharing `args` with the caller is fine because `sizeOf args < sizeOf (.app ...)` -at the inferTerm call site. -/ -def checkArgsAndInputs (func : Global) (args : List Term) (inputs : List Typ) : - CheckM (List Typed.Term) := do - let lenArgs := args.length - let lenInputs := inputs.length - unless lenArgs == lenInputs do throw $ .wrongNumArgs func lenArgs lenInputs - args.attach.zip inputs |>.mapM (fun (⟨arg, _⟩, input) => checkNoEscape arg input) -termination_by (sizeOf args, 1) -decreasing_by - all_goals first - | decreasing_tactic - | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - | grind - -/-- Branch checker for one match arm. Recurses into `inferTerm` on the branch -body, which is `branchData.snd` — a sub-sizeOf of `branchData`. -/ -def checkMatchBranch - (patTyp : Typ) (branchData : Pattern × Term) - (acc : List (Pattern × Typed.Term) × Option (Typ × Bool)) : - CheckM (List (Pattern × Typed.Term) × Option (Typ × Bool)) := do - let (pat, branch) := branchData - let (typedBranches, currentTypOpt) := acc - let bindings ← checkPattern pat patTyp - withReader (bindIdents bindings) (match currentTypOpt with - | none => do - let typedBranch ← inferTerm branch - pure (typedBranches.cons (pat, typedBranch), some (typedBranch.typ, typedBranch.escapes)) - | some (matchTyp, matchEscapes) => do - let typedBranch ← inferTerm branch - let typedBranches := typedBranches.cons (pat, typedBranch) - if typedBranch.escapes then - pure (typedBranches, currentTypOpt) - else if matchEscapes then - pure (typedBranches, some (typedBranch.typ, false)) - else - unless ← unifyTyp matchTyp typedBranch.typ do - throw $ .branchMismatch matchTyp typedBranch.typ - pure (typedBranches, currentTypOpt)) -termination_by (sizeOf branchData, 1) - -end - -/-! ## Zonking — applies the mvar substitution through every typed sub-term. -/ - -def zonkTypedTerm (t : Typed.Term) : CheckM Typed.Term := match t with - | .unit τ e => do pure (.unit (← zonkTyp τ) e) - | .var τ e l => do pure (.var (← zonkTyp τ) e l) - | .ref τ e g tArgs => do pure (.ref (← zonkTyp τ) e g (← tArgs.mapM zonkTyp)) - | .field τ e g => do pure (.field (← zonkTyp τ) e g) - | .tuple τ e ts => do - pure (.tuple (← zonkTyp τ) e (← ts.attach.mapM fun ⟨t, _⟩ => zonkTypedTerm t)) - | .array τ e ts => do - pure (.array (← zonkTyp τ) e (← ts.attach.mapM fun ⟨t, _⟩ => zonkTypedTerm t)) - | .ret τ e sub => do pure (.ret (← zonkTyp τ) e (← zonkTypedTerm sub)) - | .let τ e pat v b => do - pure (.let (← zonkTyp τ) e pat (← zonkTypedTerm v) (← zonkTypedTerm b)) - | .match τ e scrut bs => do - let scrut' ← zonkTypedTerm scrut - let bs' ← bs.attach.mapM fun ⟨(p, b), _⟩ => do return (p, ← zonkTypedTerm b) - pure (.match (← zonkTyp τ) e scrut' bs') - | .app τ e g tArgs args u => do - pure (.app (← zonkTyp τ) e g (← tArgs.mapM zonkTyp) - (← args.attach.mapM fun ⟨a, _⟩ => zonkTypedTerm a) u) - | .add τ e a b => do pure (.add (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b)) - | .sub τ e a b => do pure (.sub (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b)) - | .mul τ e a b => do pure (.mul (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b)) - | .eqZero τ e a => do pure (.eqZero (← zonkTyp τ) e (← zonkTypedTerm a)) - | .proj τ e a n => do pure (.proj (← zonkTyp τ) e (← zonkTypedTerm a) n) - | .get τ e a n => do pure (.get (← zonkTyp τ) e (← zonkTypedTerm a) n) - | .slice τ e a i j => do pure (.slice (← zonkTyp τ) e (← zonkTypedTerm a) i j) - | .set τ e a n v => do - pure (.set (← zonkTyp τ) e (← zonkTypedTerm a) n (← zonkTypedTerm v)) - | .store τ e a => do pure (.store (← zonkTyp τ) e (← zonkTypedTerm a)) - | .load τ e a => do pure (.load (← zonkTyp τ) e (← zonkTypedTerm a)) - | .ptrVal τ e a => do pure (.ptrVal (← zonkTyp τ) e (← zonkTypedTerm a)) - | .assertEq τ e a b msg r => do - pure (.assertEq (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b) - msg (← zonkTypedTerm r)) - | .ioGetInfo τ e c k => do - pure (.ioGetInfo (← zonkTyp τ) e (← zonkTypedTerm c) (← zonkTypedTerm k)) - | .ioSetInfo τ e c k i l r => do - pure (.ioSetInfo (← zonkTyp τ) e (← zonkTypedTerm c) (← zonkTypedTerm k) - (← zonkTypedTerm i) (← zonkTypedTerm l) (← zonkTypedTerm r)) - | .ioRead τ e c i n => do - pure (.ioRead (← zonkTyp τ) e (← zonkTypedTerm c) (← zonkTypedTerm i) n) - | .ioWrite τ e c d r => do - pure (.ioWrite (← zonkTyp τ) e (← zonkTypedTerm c) (← zonkTypedTerm d) (← zonkTypedTerm r)) - | .u8BitDecomposition τ e a => do - pure (.u8BitDecomposition (← zonkTyp τ) e (← zonkTypedTerm a)) - | .u8ShiftLeft τ e a => do pure (.u8ShiftLeft (← zonkTyp τ) e (← zonkTypedTerm a)) - | .u8ShiftRight τ e a => do pure (.u8ShiftRight (← zonkTyp τ) e (← zonkTypedTerm a)) - | .u8Xor τ e a b => do pure (.u8Xor (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b)) - | .u8Add τ e a b => do pure (.u8Add (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b)) - | .u8Mul τ e a b => do pure (.u8Mul (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b)) - | .u8XorSplit7 τ e a b => do pure (.u8XorSplit7 (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b)) - | .u8XorSplit4 τ e a b => do pure (.u8XorSplit4 (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b)) - | .u8Sub τ e a b => do pure (.u8Sub (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b)) - | .u8And τ e a b => do pure (.u8And (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b)) - | .u8Or τ e a b => do pure (.u8Or (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b)) - | .u8LessThan τ e a b => do - pure (.u8LessThan (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b)) - | .u32LessThan τ e a b => do - pure (.u32LessThan (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b)) - | .u8RangeCheck τ e a b => do - pure (.u8RangeCheck (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b)) - | .unconstrainedBigUintDivMod τ e a b => do - pure (.unconstrainedBigUintDivMod (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b)) - | .unconstrainedGToBytes τ e a => do - pure (.unconstrainedGToBytes (← zonkTyp τ) e (← zonkTypedTerm a)) - | .unconstrainedGInverse τ e a => do - pure (.unconstrainedGInverse (← zonkTyp τ) e (← zonkTypedTerm a)) - | .unconstrainedU32Add τ e a b => do - pure (.unconstrainedU32Add (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b)) - | .unconstrainedU32Add3 τ e a b c => do - pure (.unconstrainedU32Add3 (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b) - (← zonkTypedTerm c)) - | .u32ToField τ e a => do - pure (.u32ToField (← zonkTyp τ) e (← zonkTypedTerm a)) - | .toField τ e a => do pure (.toField (← zonkTyp τ) e (← zonkTypedTerm a)) - | .u8FromFieldUnsafe τ e a => do - pure (.u8FromFieldUnsafe (← zonkTyp τ) e (← zonkTypedTerm a)) - | .debug τ e label t r => do - let t' ← match t with - | none => pure none - | some sub => do pure (some (← zonkTypedTerm sub)) - pure (.debug (← zonkTyp τ) e label t' (← zonkTypedTerm r)) -termination_by sizeOf t -decreasing_by - all_goals first - | decreasing_tactic - | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - | grind - -def getFunctionContext (function : Function) (decls : Decls) : CheckContext := - { decls - varTypes := .ofList function.inputs - returnType := function.output - typeParams := function.params } - -def wellFormedDecls (decls : Decls) : Except CheckError Unit := do - let mut visited := default - for (_, decl) in decls.pairs do - match EStateM.run (wellFormedDecl decl) visited with - | .error e _ => throw e - | .ok () visited' => visited := visited' -where - checkUniqueParams (name : Global) (params : List String) : - EStateM CheckError (Std.HashSet Global) Unit := - let rec go : List String → Std.HashSet String → EStateM CheckError (Std.HashSet Global) Unit - | [], _ => pure () - | p :: ps, seen => - if seen.contains p then throw $ .duplicatedTypeParam name p - else go ps (seen.insert p) - go params {} - wellFormedDecl : Declaration → EStateM CheckError (Std.HashSet Global) Unit - | .dataType dataType => do - let map ← get - if !map.contains dataType.name then - set $ map.insert dataType.name - checkUniqueParams dataType.name dataType.params - dataType.constructors.flatMap (·.argTypes) |>.forM (wellFormedType dataType.params) - | .function function => do - checkUniqueParams function.name function.params - wellFormedType function.params function.output - function.inputs.forM fun (_, typ) => wellFormedType function.params typ - | .constructor .. => pure () - wellFormedType (params : List String) : Typ → EStateM CheckError (Std.HashSet Global) Unit - | .tuple typs => - typs.attach.forM (fun ⟨t, _⟩ => wellFormedType params t) - | .pointer pointerTyp => wellFormedType params pointerTyp - | .array t _ => wellFormedType params t - | .ref ref => - if params.any (· == ref.toName.toString) then pure () - else match decls.getByKey ref with - | some (.dataType dt) => - unless dt.params.isEmpty do throw $ .wrongNumTypeArgs ref 0 dt.params.length - | some _ => throw $ .notADataType ref - | none => throw $ .unboundGlobal ref - | .app g args => match decls.getByKey g with - | some (.dataType dt) => do - unless args.size == dt.params.length do - throw $ .wrongNumTypeArgs g args.size dt.params.length - args.attach.forM (fun ⟨t, _⟩ => wellFormedType params t) - | some _ => throw $ .notADataType g - | none => throw $ .unboundGlobal g - | _ => pure () - termination_by t => sizeOf t - -/-- Check a function (infer + zonk). -/ -def checkFunction (function : Function) : CheckM Typed.Function := do - let body ← inferTerm function.body - unless body.escapes do - unless ← unifyTyp body.typ function.output do - throw $ .typeMismatch body.typ function.output - let body ← zonkTypedTerm body - pure ⟨function.name, function.params, function.inputs, function.output, body, function.entry⟩ - -end Aiur - -end -- @[expose] section -end diff --git a/Ix/Aiur/Compiler/Concretize.lean b/Ix/Aiur/Compiler/Concretize.lean deleted file mode 100644 index 9ff782f1e..000000000 --- a/Ix/Aiur/Compiler/Concretize.lean +++ /dev/null @@ -1,1116 +0,0 @@ -module -public import Ix.Lib -public import Ix.Aiur.Compiler.Simple -public import Ix.Aiur.Stages.Concrete - -/-! -Monomorphization: `Typed.Decls` (after simplify) → `Concrete.Decls`. - -The static check rejecting polymorphic recursion is enforced by bounding the -worklist: every new (template, type-args) pair must be -structurally simpler than the pair that triggered it, where "simpler" is -measured on the DAG of type-argument references. A violation throws -`.polymorphicRecursion`. --/ - -public section -@[expose] section - -namespace Aiur - -open Source - -/-- Errors surfacing during monomorphization. Separate enum from `CheckError`. -/ -inductive ConcretizeError - | unresolvedMVar : Nat → ConcretizeError - | templateNotFound : Global → ConcretizeError - | wrongNumArgs : Global → Nat → Nat → ConcretizeError - | polymorphicRecursion : Global → Array Typ → ConcretizeError - | fuelExhausted : ConcretizeError - /-- Pattern shape not supported by the direct `Source → Concrete` path. - Nested patterns (like `.tuple [.ref _ [...], ...]`), `.or`, and `.pointer` - currently require running the match compiler; today only single-level - patterns where every sub-pattern is `.var` or `.wildcard` are translated - directly. -/ - | unsupportedPattern : ConcretizeError - /-- A `.match` whose scrutinee isn't already a `.var` needs a fresh local - to bind it, which requires state threading not yet wired here. -/ - | unsupportedMatchScrutinee : ConcretizeError - deriving Repr - -instance : ToString ConcretizeError where - toString e := repr e |>.pretty - -/-! ## Type flattening to `Concrete.Typ` -/ - - -/-- Convert a `Typ` (from the source IR) into a `Concrete.Typ` using a mono map -that knows the concrete name for each `(template, args)` pair. -/ -def typToConcrete (mono : Std.HashMap (Global × Array Typ) Global) : - Typ → Except ConcretizeError Concrete.Typ - | .unit => pure .unit - | .field => pure .field - -- `u8` is erased here: same representation as `field`, distinction no longer - -- needed past type-checking. - | .u8 => pure .field - | .tuple ts => do - pure (.tuple (← ts.attach.mapM fun ⟨t, _⟩ => typToConcrete mono t)) - | .array t n => do pure (.array (← typToConcrete mono t) n) - | .pointer t => do pure (.pointer (← typToConcrete mono t)) - | .function ins out => do - let ins' ← ins.attach.mapM fun ⟨t, _⟩ => typToConcrete mono t - let out' ← typToConcrete mono out - pure (.function ins' out') - | .ref g => pure (.ref g) - | .app g args => do - match mono[(g, args)]? with - | some concName => pure (.ref concName) - | none => pure (.ref g) - | .mvar n => .error (.unresolvedMVar n) -termination_by t => sizeOf t - --- `List.mapM_except_ok` moved to `Proofs/ConcretizeProgress.lean`. - - --- `Typed.Term.MvarFree`, `Pattern.Simple`, `Typed.Term.ConcretizeReady` --- moved to `Proofs/ConcretizeProgress.lean`. - - -/-! ## Name mangling. -/ - -def Typ.toFlatName : Typ → String - | .field => "G" - | .u8 => "U8" - | .unit => "Unit" - | Typ.ref g => g.toName.toString (escape := false) - | .pointer t => "Ptr_" ++ t.toFlatName - | .tuple ts => "Tup_" ++ "_".intercalate - (ts.attach.map fun ⟨t, _⟩ => Typ.toFlatName t).toList - | .array t n => t.toFlatName ++ "_" ++ toString n - | .function .. => "Fn" - | .app name args => - name.toName.toString (escape := false) ++ "_" ++ - "_".intercalate (args.attach.map fun ⟨t, _⟩ => Typ.toFlatName t).toList - | .mvar id => s!"?{id}" -termination_by t => sizeOf t -decreasing_by all_goals first | decreasing_tactic | grind - -def Typ.appendNameLimbs (g : Global) : Typ → Global - | .field => g.pushNamespace "G" - | .u8 => g.pushNamespace "U8" - | .unit => g.pushNamespace "Unit" - | Typ.ref g' => - let rec pushAll (g : Global) : Lean.Name → Global - | .str parent s => (pushAll g parent).pushNamespace s - | _ => g - pushAll g g'.toName - | .pointer t => Typ.appendNameLimbs (g.pushNamespace "Ptr") t - | .tuple ts => - ts.attach.foldl (init := g.pushNamespace "Tup") - (fun acc ⟨t, _⟩ => Typ.appendNameLimbs acc t) - | .array t n => g.pushNamespace (toFlatName t ++ "_" ++ toString n) - | .function .. => g.pushNamespace "Fn" - | .app name args => - args.attach.foldl (init := Typ.appendNameLimbs g (.ref name)) - (fun acc ⟨t, _⟩ => Typ.appendNameLimbs acc t) - | .mvar id => g.pushNamespace s!"?{id}" -termination_by t => sizeOf t -decreasing_by - all_goals first - | decreasing_tactic - | (-- For .app→.ref cross-call: need sizeOf (.ref name) < sizeOf (.app name args). - -- sizeOf (.ref name) = 1 + sizeOf name, sizeOf (.app name args) = - -- 1 + sizeOf name + sizeOf args, so we need sizeOf args > 0. - have := Array.two_le_sizeOf ‹Array Typ›; grind) - -def concretizeName (templateName : Global) (args : Array Typ) : Global := - args.foldl Typ.appendNameLimbs templateName - -/-! ## Source → Concrete pattern translation — direct, non-nested subset only. - -A full match compiler lives in `Compiler/Match.lean` (produces `Simple.Term` -decision trees). The Aiur pipeline doesn't yet wire that through, so here we -handle only the patterns that map 1:1 to `Concrete.Pattern`: -- `.wildcard` / `.var x` at top level → `Concrete.Pattern.wildcard` (a - top-level `.var x` additionally requires binding `x` to the scrutinee, - which the caller handles by prepending a `.letVar`) -- `.field g` → `Concrete.Pattern.field g` -- `.ref g [var_1, ..., var_n]` → `Concrete.Pattern.ref g #[var_1, ..., var_n]` -- `.tuple [var_1, ..., var_n]` → `Concrete.Pattern.tuple #[var_1, ..., var_n]` -- `.array [var_1, ..., var_n]` → `Concrete.Pattern.array #[var_1, ..., var_n]` - -Everything else throws `.unsupportedPattern`. -/ - -/-- Base tag for wildcard `.idx` locals introduced when translating a -sub-pattern. Chosen large enough to avoid colliding with any `.idx` used -elsewhere in the pipeline (`Simple.tmpVar = .idx 0`, the match compiler -allocates `.idx id` with `id` starting at 0 too — so we reserve a -dedicated high range here). -/ -def concretizeWildcardBase : Nat := 1 <<< 20 - -/-- Extract a list of `Local`s from a list of sub-patterns, demanding each is -`.var x` or `.wildcard`. Wildcards are turned into a fresh-named local of -the form `.idx (concretizeWildcardBase + offset)` — this doesn't collide -with user names (which are `.str _`) or with the other reserved `.idx` -slots used elsewhere. -/ -def subPatternsToLocals (pats : List Pattern) : - Except ConcretizeError (Array Local) := do - let (locals, _) ← pats.foldlM (init := (#[], concretizeWildcardBase)) - fun (acc, tag) p => do - match p with - | .var x => pure (acc.push x, tag) - | .wildcard => pure (acc.push (.idx tag), tag + 1) - | _ => throw .unsupportedPattern - pure locals - -def subPatternsToLocalsArr (pats : Array Pattern) : - Except ConcretizeError (Array Local) := - subPatternsToLocals pats.toList - -/-- Expand a match-branch pattern into one or more `Concrete.Pattern` cases. - -Each arm dispatches on a single-level constructor shape over `.var`/`.wildcard` -sub-patterns. Top-level `.var x` produces a wildcard case that rebinds the -scrutinee to `x` via a `.letVar` at the top of the body. `.or` flattens -recursively by concatenating both expansions. Any shape outside this subset -throws `.unsupportedPattern`. -/ -def expandPattern (scrutTyp : Concrete.Typ) (scrutLocal : Local) : - Pattern → Concrete.Term → - Except ConcretizeError (Array (Concrete.Pattern × Concrete.Term)) - | .wildcard, cb => pure #[(.wildcard, cb)] - | .var x, cb => pure #[(.wildcard, - .letVar cb.typ cb.escapes x (.var scrutTyp false scrutLocal) cb)] - | .field g, cb => pure #[(.field g, cb)] - | .ref g pats, cb => do - let locals ← subPatternsToLocals pats - pure #[(.ref g locals, cb)] - | .tuple pats, cb => do - let locals ← subPatternsToLocalsArr pats - pure #[(.tuple locals, cb)] - | .array pats, cb => do - let locals ← subPatternsToLocalsArr pats - pure #[(.array locals, cb)] - | .or p1 p2, cb => do - pure ((← expandPattern scrutTyp scrutLocal p1 cb) - ++ (← expandPattern scrutTyp scrutLocal p2 cb)) - | _, _ => throw .unsupportedPattern - -/-- Irrefutable tuple destructuring: given a scrutinee term whose type is a -tuple, a list of sub-patterns (one per field), the element types, and a -body `cb`, produce the nested `.letVar`/`.letWild` + `.proj` sequence. Used -by the single-arm tuple pattern special case of `termToConcrete`'s `.match`. -/ -def destructureTuple (scrutTerm : Concrete.Term) (pats : Array Pattern) - (ts : Array Concrete.Typ) (cb : Concrete.Term) : Concrete.Term := Id.run do - let mut acc := cb - for i in [:pats.size] do - let j := pats.size - 1 - i - let p := pats[j]?.getD .wildcard - let eltTyp := ts[j]?.getD .unit - let projTerm : Concrete.Term := .proj eltTyp false scrutTerm j - acc := match p with - | .var x => .letVar acc.typ acc.escapes x projTerm acc - | _ => .letWild acc.typ acc.escapes projTerm acc - acc - -/-- Irrefutable array destructuring: analogous to `destructureTuple` but over -a homogeneous array scrutinee, using `.get` for each element. -/ -def destructureArray (scrutTerm : Concrete.Term) (pats : Array Pattern) - (eltTyp : Concrete.Typ) (cb : Concrete.Term) : Concrete.Term := Id.run do - let mut acc := cb - for i in [:pats.size] do - let j := pats.size - 1 - i - let p := pats[j]?.getD .wildcard - let getTerm : Concrete.Term := .get eltTyp false scrutTerm j - acc := match p with - | .var x => .letVar acc.typ acc.escapes x getTerm acc - | _ => .letWild acc.typ acc.escapes getTerm acc - acc - -/-! ## The main pass - -`termToConcrete` walks a `Typed.Term` and produces a `Concrete.Term`. The only -failure modes are `.mvar` types (ruled out by the checker's zonking step) and -pattern shapes that haven't been flattened by `simplify`'s decision-tree -rewrite (`.pointer` sub-patterns in `.ref`, and non-`.var` scrutinees). -/ - -def termToConcrete - (mono : Std.HashMap (Global × Array Typ) Global) : - Typed.Term → Except ConcretizeError Concrete.Term - | .unit τ e => do pure (.unit (← typToConcrete mono τ) e) - | .var τ e x => do pure (.var (← typToConcrete mono τ) e x) - | .ref τ e g _tArgs => do pure (.ref (← typToConcrete mono τ) e g) - | .field τ e g => do pure (.field (← typToConcrete mono τ) e g) - | .tuple τ e ts => do - pure (.tuple (← typToConcrete mono τ) e (← ts.mapM (termToConcrete mono))) - | .array τ e ts => do - pure (.array (← typToConcrete mono τ) e (← ts.mapM (termToConcrete mono))) - | .ret τ e r => do pure (.ret (← typToConcrete mono τ) e (← termToConcrete mono r)) - | .let τ e pat v b => do - -- After simplify, patterns are `.var x` or `.wildcard`. Preserve the - -- variable binding when present; fall back to wildcard otherwise. - let τ' ← typToConcrete mono τ - let v' ← termToConcrete mono v - let b' ← termToConcrete mono b - match pat with - | .var x => pure (.letVar τ' e x v' b') - | _ => pure (.letWild τ' e v' b') - | .match τ e scrut bs => do - -- Handle the direct subset: scrutinee is already a `.var` and every - -- branch pattern is a single-level constructor over `.var`/`.wildcard` - -- sub-patterns. Tuple/array patterns at the top level are - -- *irrefutable* — when the match has exactly one such case, we - -- destructure via `.letVar`/`.letWild` + `.proj`/`.get` instead of - -- emitting a `Concrete.Term.match` (which `Lower` doesn't support - -- for tuple/array patterns). - let τ' ← typToConcrete mono τ - let scrut' ← termToConcrete mono scrut - match scrut' with - | .var scrutTyp _ scrutLocal => do - let scrutTerm : Concrete.Term := .var scrutTyp false scrutLocal - -- Single-arm tuple pattern destructuring (irrefutable). - if let [(Pattern.tuple pats, body)] := bs then - if let .tuple ts := scrutTyp then - let cb ← termToConcrete mono body - return destructureTuple scrutTerm pats ts cb - -- Single-arm array pattern destructuring (irrefutable, homogeneous). - if let [(Pattern.array pats, body)] := bs then - if let .array eltTyp _ := scrutTyp then - let cb ← termToConcrete mono body - return destructureArray scrutTerm pats eltTyp cb - -- General match path: every branch's pattern expands to one or - -- more single-level `Concrete` cases that `Lower` can dispatch. - let cases ← bs.toArray.attach.foldlM (init := #[]) - fun acc ⟨(p, b), _⟩ => do - let cb ← termToConcrete mono b - pure (acc ++ (← expandPattern scrutTyp scrutLocal p cb)) - pure (.match τ' e scrutLocal cases none) - | _ => throw .unsupportedMatchScrutinee - | .app τ e g _tArgs args u => do - pure (.app (← typToConcrete mono τ) e g (← args.mapM (termToConcrete mono)) u) - | .add τ e a b => do - pure (.add (← typToConcrete mono τ) e - (← termToConcrete mono a) (← termToConcrete mono b)) - | .sub τ e a b => do - pure (.sub (← typToConcrete mono τ) e - (← termToConcrete mono a) (← termToConcrete mono b)) - | .mul τ e a b => do - pure (.mul (← typToConcrete mono τ) e - (← termToConcrete mono a) (← termToConcrete mono b)) - | .eqZero τ e a => do pure (.eqZero (← typToConcrete mono τ) e (← termToConcrete mono a)) - | .proj τ e a n => do pure (.proj (← typToConcrete mono τ) e (← termToConcrete mono a) n) - | .get τ e a n => do pure (.get (← typToConcrete mono τ) e (← termToConcrete mono a) n) - | .slice τ e a i j => do pure (.slice (← typToConcrete mono τ) e (← termToConcrete mono a) i j) - | .set τ e a n v => do - pure (.set (← typToConcrete mono τ) e - (← termToConcrete mono a) n (← termToConcrete mono v)) - | .store τ e a => do pure (.store (← typToConcrete mono τ) e (← termToConcrete mono a)) - | .load τ e a => do pure (.load (← typToConcrete mono τ) e (← termToConcrete mono a)) - | .ptrVal τ e a => do pure (.ptrVal (← typToConcrete mono τ) e (← termToConcrete mono a)) - | .assertEq τ e a b msg r => do - pure (.assertEq (← typToConcrete mono τ) e - (← termToConcrete mono a) (← termToConcrete mono b) - msg (← termToConcrete mono r)) - | .ioGetInfo τ e c k => do - pure (.ioGetInfo (← typToConcrete mono τ) e - (← termToConcrete mono c) (← termToConcrete mono k)) - | .ioSetInfo τ e c k i l r => do - pure (.ioSetInfo (← typToConcrete mono τ) e - (← termToConcrete mono c) (← termToConcrete mono k) - (← termToConcrete mono i) - (← termToConcrete mono l) (← termToConcrete mono r)) - | .ioRead τ e c i n => do - pure (.ioRead (← typToConcrete mono τ) e - (← termToConcrete mono c) (← termToConcrete mono i) n) - | .ioWrite τ e c d r => do - pure (.ioWrite (← typToConcrete mono τ) e - (← termToConcrete mono c) (← termToConcrete mono d) - (← termToConcrete mono r)) - | .u8BitDecomposition τ e a => do - pure (.u8BitDecomposition (← typToConcrete mono τ) e (← termToConcrete mono a)) - | .u8ShiftLeft τ e a => do - pure (.u8ShiftLeft (← typToConcrete mono τ) e (← termToConcrete mono a)) - | .u8ShiftRight τ e a => do - pure (.u8ShiftRight (← typToConcrete mono τ) e (← termToConcrete mono a)) - | .u8Xor τ e a b => do - pure (.u8Xor (← typToConcrete mono τ) e - (← termToConcrete mono a) (← termToConcrete mono b)) - | .u8Add τ e a b => do - pure (.u8Add (← typToConcrete mono τ) e - (← termToConcrete mono a) (← termToConcrete mono b)) - | .u8Mul τ e a b => do - pure (.u8Mul (← typToConcrete mono τ) e - (← termToConcrete mono a) (← termToConcrete mono b)) - | .u8XorSplit7 τ e a b => do - pure (.u8XorSplit7 (← typToConcrete mono τ) e - (← termToConcrete mono a) (← termToConcrete mono b)) - | .u8XorSplit4 τ e a b => do - pure (.u8XorSplit4 (← typToConcrete mono τ) e - (← termToConcrete mono a) (← termToConcrete mono b)) - | .u8Sub τ e a b => do - pure (.u8Sub (← typToConcrete mono τ) e - (← termToConcrete mono a) (← termToConcrete mono b)) - | .u8And τ e a b => do - pure (.u8And (← typToConcrete mono τ) e - (← termToConcrete mono a) (← termToConcrete mono b)) - | .u8Or τ e a b => do - pure (.u8Or (← typToConcrete mono τ) e - (← termToConcrete mono a) (← termToConcrete mono b)) - | .u8LessThan τ e a b => do - pure (.u8LessThan (← typToConcrete mono τ) e - (← termToConcrete mono a) (← termToConcrete mono b)) - | .u32LessThan τ e a b => do - pure (.u32LessThan (← typToConcrete mono τ) e - (← termToConcrete mono a) (← termToConcrete mono b)) - | .unconstrainedU32Add τ e a b => do - pure (.unconstrainedU32Add (← typToConcrete mono τ) e - (← termToConcrete mono a) (← termToConcrete mono b)) - | .unconstrainedU32Add3 τ e a b c => do - pure (.unconstrainedU32Add3 (← typToConcrete mono τ) e - (← termToConcrete mono a) (← termToConcrete mono b) (← termToConcrete mono c)) - | .u32ToField τ e a => do - pure (.u32ToField (← typToConcrete mono τ) e (← termToConcrete mono a)) - | .u8RangeCheck τ e a b => do - pure (.u8RangeCheck (← typToConcrete mono τ) e - (← termToConcrete mono a) (← termToConcrete mono b)) - | .unconstrainedBigUintDivMod τ e a b => do - pure (.unconstrainedBigUintDivMod (← typToConcrete mono τ) e - (← termToConcrete mono a) (← termToConcrete mono b)) - | .unconstrainedGToBytes τ e a => do - pure (.unconstrainedGToBytes (← typToConcrete mono τ) e (← termToConcrete mono a)) - | .unconstrainedGInverse τ e a => do - pure (.unconstrainedGInverse (← typToConcrete mono τ) e (← termToConcrete mono a)) - -- `toField` / `u8FromFieldUnsafe` are erased coercions: `u8` and `field` - -- share a representation, so we drop the wrapper and keep the inner term. - | .toField _ _ a | .u8FromFieldUnsafe _ _ a => termToConcrete mono a - | .debug τ e l t r => do - -- Inline the Option.mapM case-split so termination sees the sub-Term. - let t' ← match t with - | none => pure none - | some sub => do pure (some (← termToConcrete mono sub)) - pure (.debug (← typToConcrete mono τ) e l t' (← termToConcrete mono r)) -termination_by t => sizeOf t -decreasing_by - all_goals first - | decreasing_tactic - | (have : ∀ {α} [SizeOf α] (a : α), sizeOf a < sizeOf (some a) := by - intros; show _ < 1 + _; omega - grind) - | (-- Branch bodies in `.match`: `(p, b) ∈ bs.toArray` ⇒ `sizeOf b < sizeOf bs` - have hmem : _ ∈ _ := ‹_ ∈ _› - have := Array.sizeOf_lt_of_mem hmem - grind) - -/-! ## Progress lemmas moved to `Proofs/ConcretizeProgress.lean`. -/ - - -/-! ## Monomorphization — worklist + rewriting (port of `Ix/Aiur/Compiler/Concretize.lean`) -/ - -abbrev MonoMap := Std.HashMap (Global × Array Typ) Global - -/-- Apply a type-parameter substitution + mono-map rewrite to a `Typ`. -An `.app g args` whose `(g, args)` is in `mono` is replaced by `.ref (mono[(g, args)]!)`; -otherwise the `.app` persists with args recursively rewritten. -/ -def rewriteTyp (subst : Global → Option Typ) (mono : MonoMap) : Typ → Typ - | .ref g => (subst g).getD (.ref g) - | .app g args => - match mono[(g, args)]? with - | some concName => .ref concName - | none => .app g (args.attach.map fun ⟨t, _⟩ => rewriteTyp subst mono t) - | .tuple ts => .tuple (ts.attach.map fun ⟨t, _⟩ => rewriteTyp subst mono t) - | .array t n => .array (rewriteTyp subst mono t) n - | .pointer t => .pointer (rewriteTyp subst mono t) - | .function ins out => - .function (ins.attach.map fun ⟨t, _⟩ => rewriteTyp subst mono t) - (rewriteTyp subst mono out) - | t => t -termination_by t => sizeOf t -decreasing_by - all_goals first - | decreasing_tactic - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - -/-- Rewrite a reference to a function or a constructor's global name, using the -type-args from the site that referenced it. Returns the monomorphic name when -available, otherwise the original global. -/ -def rewriteGlobal (decls : Typed.Decls) (mono : MonoMap) - (g : Global) (tArgs : Array Typ) : Global := - if tArgs.isEmpty then g - else match decls.getByKey g with - | some (.function _) => - match mono[(g, tArgs)]? with - | some concName => concName - | none => g - | some (.constructor dt _) => - match g.popNamespace with - | some (ctorName, _) => - match mono[(dt.name, tArgs)]? with - | some concDTName => concDTName.pushNamespace ctorName - | none => g - | none => g - | _ => g - -/-- Rewrite constructor names in patterns, using the expected (unrewritten) -scrutinee type to determine which monomorphic instance to use. -/ -def rewritePattern (decls : Typed.Decls) (mono : MonoMap) - (expectedTyp : Typ) : Pattern → Pattern - | .ref g pats => - let tArgs : Array Typ := match expectedTyp with - | .app _ args => args - | _ => #[] - let g' := rewriteGlobal decls mono g tArgs - -- Post-simplify, sub-patterns of a `.ref` are all `.var` / `.wildcard` - -- (the match compiler flattens nested patterns into a chain of switches). - -- Inner `rewritePattern` calls are therefore no-ops; passing `.unit` as the - -- expected type is sound because the no-op arms never consult `expectedTyp`. - let pats' := pats.attach.map fun ⟨p, _⟩ => rewritePattern decls mono .unit p - .ref g' pats' - | .tuple pats => - -- Sub-patterns of a tuple pattern are flattened to simple vars by simplify; - -- same justification as above for passing `.unit`. - .tuple (pats.attach.map fun ⟨p, _⟩ => rewritePattern decls mono .unit p) - | .array pats => - let innerTyp : Typ := match expectedTyp with - | .array t _ => t - | _ => .unit - .array (pats.attach.map fun ⟨p, _⟩ => rewritePattern decls mono innerTyp p) - | .or a b => - .or (rewritePattern decls mono expectedTyp a) (rewritePattern decls mono expectedTyp b) - | .pointer p => - match expectedTyp with - | .pointer inner => .pointer (rewritePattern decls mono inner p) - | _ => .pointer p - | p => p -termination_by p => sizeOf p -decreasing_by - all_goals first - | decreasing_tactic - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - -/-- Rewrite a `Typed.Term`: rewrites type annotations, function/constructor -names via `.app`/`.ref`, and branch patterns (via `rewritePattern`). -/ -def rewriteTypedTerm (decls : Typed.Decls) - (subst : Global → Option Typ) (mono : MonoMap) : Typed.Term → Typed.Term - | .unit τ e => .unit (rewriteTyp subst mono τ) e - | .var τ e x => .var (rewriteTyp subst mono τ) e x - | .ref τ e g tArgs => - let g' := rewriteGlobal decls mono g tArgs - .ref (rewriteTyp subst mono τ) e g' (tArgs.map (rewriteTyp subst mono)) - | .field τ e v => .field (rewriteTyp subst mono τ) e v - | .tuple τ e ts => - .tuple (rewriteTyp subst mono τ) e - (ts.attach.map fun ⟨t, _⟩ => rewriteTypedTerm decls subst mono t) - | .array τ e ts => - .array (rewriteTyp subst mono τ) e - (ts.attach.map fun ⟨t, _⟩ => rewriteTypedTerm decls subst mono t) - | .ret τ e r => - .ret (rewriteTyp subst mono τ) e (rewriteTypedTerm decls subst mono r) - | .let τ e p v b => - let vTyp := v.typ - .let (rewriteTyp subst mono τ) e - (rewritePattern decls mono vTyp p) - (rewriteTypedTerm decls subst mono v) - (rewriteTypedTerm decls subst mono b) - | .match τ e scrut bs => - let scrutTyp := scrut.typ - .match (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono scrut) - (bs.attach.map fun ⟨(p, b), _⟩ => - (rewritePattern decls mono scrutTyp p, - rewriteTypedTerm decls subst mono b)) - | .app τ e g tArgs args u => - let g' := rewriteGlobal decls mono g tArgs - .app (rewriteTyp subst mono τ) e g' #[] - (args.attach.map fun ⟨a, _⟩ => rewriteTypedTerm decls subst mono a) u - | .add τ e a b => .add (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b) - | .sub τ e a b => .sub (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b) - | .mul τ e a b => .mul (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b) - | .eqZero τ e a => .eqZero (rewriteTyp subst mono τ) e (rewriteTypedTerm decls subst mono a) - | .proj τ e a n => .proj (rewriteTyp subst mono τ) e (rewriteTypedTerm decls subst mono a) n - | .get τ e a n => .get (rewriteTyp subst mono τ) e (rewriteTypedTerm decls subst mono a) n - | .slice τ e a i j => .slice (rewriteTyp subst mono τ) e (rewriteTypedTerm decls subst mono a) i j - | .set τ e a n v => - .set (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) n - (rewriteTypedTerm decls subst mono v) - | .store τ e a => .store (rewriteTyp subst mono τ) e (rewriteTypedTerm decls subst mono a) - | .load τ e a => .load (rewriteTyp subst mono τ) e (rewriteTypedTerm decls subst mono a) - | .ptrVal τ e a => .ptrVal (rewriteTyp subst mono τ) e (rewriteTypedTerm decls subst mono a) - | .assertEq τ e a b msg r => - .assertEq (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b) - msg (rewriteTypedTerm decls subst mono r) - | .ioGetInfo τ e c k => - .ioGetInfo (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono c) (rewriteTypedTerm decls subst mono k) - | .ioSetInfo τ e c k i l r => - .ioSetInfo (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono c) (rewriteTypedTerm decls subst mono k) - (rewriteTypedTerm decls subst mono i) - (rewriteTypedTerm decls subst mono l) (rewriteTypedTerm decls subst mono r) - | .ioRead τ e c i n => - .ioRead (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono c) (rewriteTypedTerm decls subst mono i) n - | .ioWrite τ e c d r => - .ioWrite (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono c) (rewriteTypedTerm decls subst mono d) - (rewriteTypedTerm decls subst mono r) - | .u8BitDecomposition τ e a => - .u8BitDecomposition (rewriteTyp subst mono τ) e (rewriteTypedTerm decls subst mono a) - | .u8ShiftLeft τ e a => - .u8ShiftLeft (rewriteTyp subst mono τ) e (rewriteTypedTerm decls subst mono a) - | .u8ShiftRight τ e a => - .u8ShiftRight (rewriteTyp subst mono τ) e (rewriteTypedTerm decls subst mono a) - | .u8Xor τ e a b => .u8Xor (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b) - | .u8Add τ e a b => .u8Add (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b) - | .u8Mul τ e a b => .u8Mul (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b) - | .u8XorSplit7 τ e a b => .u8XorSplit7 (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b) - | .u8XorSplit4 τ e a b => .u8XorSplit4 (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b) - | .u8Sub τ e a b => .u8Sub (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b) - | .u8And τ e a b => .u8And (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b) - | .u8Or τ e a b => .u8Or (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b) - | .u8LessThan τ e a b => .u8LessThan (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b) - | .u32LessThan τ e a b => .u32LessThan (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b) - | .unconstrainedU32Add τ e a b => .unconstrainedU32Add (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b) - | .unconstrainedU32Add3 τ e a b c => .unconstrainedU32Add3 (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b) - (rewriteTypedTerm decls subst mono c) - | .u32ToField τ e a => .u32ToField (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) - | .u8RangeCheck τ e a b => .u8RangeCheck (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b) - | .unconstrainedBigUintDivMod τ e a b => .unconstrainedBigUintDivMod (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b) - | .unconstrainedGToBytes τ e a => .unconstrainedGToBytes (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) - | .unconstrainedGInverse τ e a => .unconstrainedGInverse (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) - | .toField τ e a => .toField (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) - | .u8FromFieldUnsafe τ e a => .u8FromFieldUnsafe (rewriteTyp subst mono τ) e - (rewriteTypedTerm decls subst mono a) - | .debug τ e l t r => - let t' := match t with - | none => none - | some sub => some (rewriteTypedTerm decls subst mono sub) - .debug (rewriteTyp subst mono τ) e l t' (rewriteTypedTerm decls subst mono r) -termination_by t => sizeOf t -decreasing_by - all_goals first - | decreasing_tactic - | (have : ∀ {α} [SizeOf α] (a : α), sizeOf a < sizeOf (some a) := by - intros; show _ < 1 + _; omega - grind) - | (have hmem : _ ∈ _ := ‹_ ∈ _› - have := List.sizeOf_lt_of_mem hmem - grind) - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - - -/-- Collect every `(Global, Array Typ)` instantiation reachable from a type. -/ -def collectInTyp (seen : Std.HashSet (Global × Array Typ)) : - Typ → Std.HashSet (Global × Array Typ) - | .app g args => - let seen := args.attach.foldl (fun s ⟨t, _⟩ => collectInTyp s t) seen - seen.insert (g, args) - | .tuple ts => ts.attach.foldl (fun s ⟨t, _⟩ => collectInTyp s t) seen - | .array t _ => collectInTyp seen t - | .pointer t => collectInTyp seen t - | .function ins out => - let seen := ins.attach.foldl (fun s ⟨t, _⟩ => collectInTyp s t) seen - collectInTyp seen out - | _ => seen -termination_by t => sizeOf t -decreasing_by - all_goals first - | decreasing_tactic - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - -/-- Collect `(Global, Array Typ)` instantiations reachable from types embedded -in a `Typed.Term`. -/ -def collectInTypedTerm (seen : Std.HashSet (Global × Array Typ)) : - Typed.Term → Std.HashSet (Global × Array Typ) - | .unit τ _ => collectInTyp seen τ - | .var τ _ _ => collectInTyp seen τ - | .ref τ _ _ tArgs => - let seen := collectInTyp seen τ - tArgs.foldl collectInTyp seen - | .field τ _ _ => collectInTyp seen τ - | .tuple τ _ ts => - let seen := collectInTyp seen τ - ts.attach.foldl (fun s ⟨t, _⟩ => collectInTypedTerm s t) seen - | .array τ _ ts => - let seen := collectInTyp seen τ - ts.attach.foldl (fun s ⟨t, _⟩ => collectInTypedTerm s t) seen - | .ret τ _ r => collectInTypedTerm (collectInTyp seen τ) r - | .let τ _ _ v b => - let seen := collectInTyp seen τ - collectInTypedTerm (collectInTypedTerm seen v) b - | .match τ _ scrut bs => - let seen := collectInTyp seen τ - let seen := collectInTypedTerm seen scrut - bs.attach.foldl (fun s ⟨(_, b), _⟩ => collectInTypedTerm s b) seen - | .app τ _ _ tArgs args _ => - let seen := collectInTyp seen τ - let seen := tArgs.foldl collectInTyp seen - args.attach.foldl (fun s ⟨a, _⟩ => collectInTypedTerm s a) seen - | .add τ _ a b | .sub τ _ a b | .mul τ _ a b - | .u8Xor τ _ a b | .u8Add τ _ a b | .u8Mul τ _ a b | .u8Sub τ _ a b - | .u8XorSplit7 τ _ a b | .u8XorSplit4 τ _ a b | .u8RangeCheck τ _ a b - | .unconstrainedBigUintDivMod τ _ a b - | .u8And τ _ a b | .u8Or τ _ a b - | .u8LessThan τ _ a b | .u32LessThan τ _ a b | .unconstrainedU32Add τ _ a b => - collectInTypedTerm (collectInTypedTerm (collectInTyp seen τ) a) b - | .unconstrainedU32Add3 τ _ a b c => - collectInTypedTerm (collectInTypedTerm (collectInTypedTerm (collectInTyp seen τ) a) b) c - | .eqZero τ _ a | .store τ _ a | .load τ _ a | .ptrVal τ _ a | .toField τ _ a - | .u8FromFieldUnsafe τ _ a - | .unconstrainedGToBytes τ _ a | .unconstrainedGInverse τ _ a - | .u32ToField τ _ a - | .u8BitDecomposition τ _ a | .u8ShiftLeft τ _ a | .u8ShiftRight τ _ a => - collectInTypedTerm (collectInTyp seen τ) a - | .ioGetInfo τ _ c k => - collectInTypedTerm (collectInTypedTerm (collectInTyp seen τ) c) k - | .proj τ _ a _ | .get τ _ a _ | .slice τ _ a _ _ => - collectInTypedTerm (collectInTyp seen τ) a - | .set τ _ a _ v => collectInTypedTerm (collectInTypedTerm (collectInTyp seen τ) a) v - | .assertEq τ _ a b _ r => - collectInTypedTerm - (collectInTypedTerm (collectInTypedTerm (collectInTyp seen τ) a) b) r - | .ioSetInfo τ _ c k i l r => - collectInTypedTerm - (collectInTypedTerm - (collectInTypedTerm - (collectInTypedTerm (collectInTypedTerm (collectInTyp seen τ) c) k) i) l) r - | .ioRead τ _ c i _ => - collectInTypedTerm (collectInTypedTerm (collectInTyp seen τ) c) i - | .ioWrite τ _ c d r => - collectInTypedTerm - (collectInTypedTerm (collectInTypedTerm (collectInTyp seen τ) c) d) r - | .debug τ _ _ t r => - let seen := collectInTyp seen τ - let seen := match t with | some t => collectInTypedTerm seen t | none => seen - collectInTypedTerm seen r -termination_by t => sizeOf t -decreasing_by - all_goals first - | decreasing_tactic - | (have : ∀ {α} [SizeOf α] (a : α), sizeOf a < sizeOf (some a) := by - intros; show _ < 1 + _; omega - grind) - | (have hmem : _ ∈ _ := ‹_ ∈ _› - have := List.sizeOf_lt_of_mem hmem - grind) - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - -/-- Collect call instantiations from `.app`/`.ref` `tArgs` in a `Typed.Term`, -resolving them against the declaration kind (function vs. constructor). -/ -def collectCalls (decls : Typed.Decls) - (seen : Std.HashSet (Global × Array Typ)) : - Typed.Term → Std.HashSet (Global × Array Typ) - | .app _ _ g tArgs args _ => - let seen := args.attach.foldl (fun s ⟨a, _⟩ => collectCalls decls s a) seen - if tArgs.isEmpty then seen - else match decls.getByKey g with - | some (.function _) => seen.insert (g, tArgs) - | some (.constructor dt _) => seen.insert (dt.name, tArgs) - | _ => seen - | .ref _ _ g tArgs => - if tArgs.isEmpty then seen - else match decls.getByKey g with - | some (.function _) => seen.insert (g, tArgs) - | some (.constructor dt _) => seen.insert (dt.name, tArgs) - | _ => seen - | .unit _ _ | .var _ _ _ | .field _ _ _ => seen - | .tuple _ _ ts | .array _ _ ts => - ts.attach.foldl (fun s ⟨t, _⟩ => collectCalls decls s t) seen - | .ret _ _ r => collectCalls decls seen r - | .let _ _ _ v b => collectCalls decls (collectCalls decls seen v) b - | .match _ _ scrut bs => - let seen := collectCalls decls seen scrut - bs.attach.foldl (fun s ⟨(_, b), _⟩ => collectCalls decls s b) seen - | .add _ _ a b | .sub _ _ a b | .mul _ _ a b - | .u8Xor _ _ a b | .u8Add _ _ a b | .u8Mul _ _ a b | .u8Sub _ _ a b - | .u8XorSplit7 _ _ a b | .u8XorSplit4 _ _ a b | .u8RangeCheck _ _ a b - | .unconstrainedBigUintDivMod _ _ a b - | .u8And _ _ a b | .u8Or _ _ a b - | .u8LessThan _ _ a b | .u32LessThan _ _ a b | .unconstrainedU32Add _ _ a b => - collectCalls decls (collectCalls decls seen a) b - | .unconstrainedU32Add3 _ _ a b c => - collectCalls decls (collectCalls decls (collectCalls decls seen a) b) c - | .eqZero _ _ a | .store _ _ a | .load _ _ a | .ptrVal _ _ a | .toField _ _ a - | .u8FromFieldUnsafe _ _ a - | .unconstrainedGToBytes _ _ a | .unconstrainedGInverse _ _ a - | .u32ToField _ _ a - | .u8BitDecomposition _ _ a | .u8ShiftLeft _ _ a | .u8ShiftRight _ _ a => - collectCalls decls seen a - | .ioGetInfo _ _ c k => - collectCalls decls (collectCalls decls seen c) k - | .proj _ _ a _ | .get _ _ a _ | .slice _ _ a _ _ => collectCalls decls seen a - | .set _ _ a _ v => collectCalls decls (collectCalls decls seen a) v - | .assertEq _ _ a b _ r => - collectCalls decls (collectCalls decls (collectCalls decls seen a) b) r - | .ioSetInfo _ _ c k i l r => - collectCalls decls - (collectCalls decls - (collectCalls decls - (collectCalls decls (collectCalls decls seen c) k) i) l) r - | .ioRead _ _ c i _ => collectCalls decls (collectCalls decls seen c) i - | .ioWrite _ _ c d r => - collectCalls decls (collectCalls decls (collectCalls decls seen c) d) r - | .debug _ _ _ t r => - let seen := match t with | some t => collectCalls decls seen t | none => seen - collectCalls decls seen r -termination_by t => sizeOf t -decreasing_by - all_goals first - | decreasing_tactic - | (have : ∀ {α} [SizeOf α] (a : α), sizeOf a < sizeOf (some a) := by - intros; show _ < 1 + _; omega - grind) - | (have hmem : _ ∈ _ := ‹_ ∈ _› - have := List.sizeOf_lt_of_mem hmem - grind) - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - -/-- Substitute type parameters throughout a `Typed.Term`, leaving function and -constructor names unchanged (name rewriting is done later by `rewriteTypedTerm`). -/ -def substInTypedTerm (subst : Global → Option Typ) : Typed.Term → Typed.Term - | .unit τ e => .unit (Typ.instantiate subst τ) e - | .var τ e x => .var (Typ.instantiate subst τ) e x - | .ref τ e g tArgs => - .ref (Typ.instantiate subst τ) e g (tArgs.map (Typ.instantiate subst)) - | .field τ e v => .field (Typ.instantiate subst τ) e v - | .tuple τ e ts => - .tuple (Typ.instantiate subst τ) e - (ts.attach.map fun ⟨t, _⟩ => substInTypedTerm subst t) - | .array τ e ts => - .array (Typ.instantiate subst τ) e - (ts.attach.map fun ⟨t, _⟩ => substInTypedTerm subst t) - | .ret τ e r => .ret (Typ.instantiate subst τ) e (substInTypedTerm subst r) - | .let τ e p v b => - .let (Typ.instantiate subst τ) e p (substInTypedTerm subst v) (substInTypedTerm subst b) - | .match τ e scrut bs => - .match (Typ.instantiate subst τ) e (substInTypedTerm subst scrut) - (bs.attach.map fun ⟨(p, b), _⟩ => (p, substInTypedTerm subst b)) - | .app τ e g tArgs args u => - .app (Typ.instantiate subst τ) e g (tArgs.map (Typ.instantiate subst)) - (args.attach.map fun ⟨a, _⟩ => substInTypedTerm subst a) u - | .add τ e a b => .add (Typ.instantiate subst τ) e - (substInTypedTerm subst a) (substInTypedTerm subst b) - | .sub τ e a b => .sub (Typ.instantiate subst τ) e - (substInTypedTerm subst a) (substInTypedTerm subst b) - | .mul τ e a b => .mul (Typ.instantiate subst τ) e - (substInTypedTerm subst a) (substInTypedTerm subst b) - | .eqZero τ e a => .eqZero (Typ.instantiate subst τ) e (substInTypedTerm subst a) - | .proj τ e a n => .proj (Typ.instantiate subst τ) e (substInTypedTerm subst a) n - | .get τ e a n => .get (Typ.instantiate subst τ) e (substInTypedTerm subst a) n - | .slice τ e a i j => .slice (Typ.instantiate subst τ) e (substInTypedTerm subst a) i j - | .set τ e a n v => - .set (Typ.instantiate subst τ) e (substInTypedTerm subst a) n (substInTypedTerm subst v) - | .store τ e a => .store (Typ.instantiate subst τ) e (substInTypedTerm subst a) - | .load τ e a => .load (Typ.instantiate subst τ) e (substInTypedTerm subst a) - | .ptrVal τ e a => .ptrVal (Typ.instantiate subst τ) e (substInTypedTerm subst a) - | .assertEq τ e a b msg r => - .assertEq (Typ.instantiate subst τ) e (substInTypedTerm subst a) - (substInTypedTerm subst b) msg (substInTypedTerm subst r) - | .ioGetInfo τ e c k => - .ioGetInfo (Typ.instantiate subst τ) e - (substInTypedTerm subst c) (substInTypedTerm subst k) - | .ioSetInfo τ e c k i l r => - .ioSetInfo (Typ.instantiate subst τ) e - (substInTypedTerm subst c) (substInTypedTerm subst k) - (substInTypedTerm subst i) - (substInTypedTerm subst l) (substInTypedTerm subst r) - | .ioRead τ e c i n => - .ioRead (Typ.instantiate subst τ) e - (substInTypedTerm subst c) (substInTypedTerm subst i) n - | .ioWrite τ e c d r => .ioWrite (Typ.instantiate subst τ) e - (substInTypedTerm subst c) (substInTypedTerm subst d) (substInTypedTerm subst r) - | .u8BitDecomposition τ e a => - .u8BitDecomposition (Typ.instantiate subst τ) e (substInTypedTerm subst a) - | .u8ShiftLeft τ e a => - .u8ShiftLeft (Typ.instantiate subst τ) e (substInTypedTerm subst a) - | .u8ShiftRight τ e a => - .u8ShiftRight (Typ.instantiate subst τ) e (substInTypedTerm subst a) - | .u8Xor τ e a b => .u8Xor (Typ.instantiate subst τ) e - (substInTypedTerm subst a) (substInTypedTerm subst b) - | .u8Add τ e a b => .u8Add (Typ.instantiate subst τ) e - (substInTypedTerm subst a) (substInTypedTerm subst b) - | .u8Mul τ e a b => .u8Mul (Typ.instantiate subst τ) e - (substInTypedTerm subst a) (substInTypedTerm subst b) - | .u8XorSplit7 τ e a b => .u8XorSplit7 (Typ.instantiate subst τ) e - (substInTypedTerm subst a) (substInTypedTerm subst b) - | .u8XorSplit4 τ e a b => .u8XorSplit4 (Typ.instantiate subst τ) e - (substInTypedTerm subst a) (substInTypedTerm subst b) - | .u8Sub τ e a b => .u8Sub (Typ.instantiate subst τ) e - (substInTypedTerm subst a) (substInTypedTerm subst b) - | .u8And τ e a b => .u8And (Typ.instantiate subst τ) e - (substInTypedTerm subst a) (substInTypedTerm subst b) - | .u8Or τ e a b => .u8Or (Typ.instantiate subst τ) e - (substInTypedTerm subst a) (substInTypedTerm subst b) - | .u8LessThan τ e a b => .u8LessThan (Typ.instantiate subst τ) e - (substInTypedTerm subst a) (substInTypedTerm subst b) - | .u32LessThan τ e a b => .u32LessThan (Typ.instantiate subst τ) e - (substInTypedTerm subst a) (substInTypedTerm subst b) - | .unconstrainedU32Add τ e a b => .unconstrainedU32Add (Typ.instantiate subst τ) e - (substInTypedTerm subst a) (substInTypedTerm subst b) - | .unconstrainedU32Add3 τ e a b c => .unconstrainedU32Add3 (Typ.instantiate subst τ) e - (substInTypedTerm subst a) (substInTypedTerm subst b) (substInTypedTerm subst c) - | .u32ToField τ e a => .u32ToField (Typ.instantiate subst τ) e (substInTypedTerm subst a) - | .u8RangeCheck τ e a b => .u8RangeCheck (Typ.instantiate subst τ) e - (substInTypedTerm subst a) (substInTypedTerm subst b) - | .unconstrainedBigUintDivMod τ e a b => .unconstrainedBigUintDivMod (Typ.instantiate subst τ) e - (substInTypedTerm subst a) (substInTypedTerm subst b) - | .unconstrainedGToBytes τ e a => - .unconstrainedGToBytes (Typ.instantiate subst τ) e (substInTypedTerm subst a) - | .unconstrainedGInverse τ e a => - .unconstrainedGInverse (Typ.instantiate subst τ) e (substInTypedTerm subst a) - | .toField τ e a => .toField (Typ.instantiate subst τ) e (substInTypedTerm subst a) - | .u8FromFieldUnsafe τ e a => - .u8FromFieldUnsafe (Typ.instantiate subst τ) e (substInTypedTerm subst a) - | .debug τ e l t r => - let t' := match t with - | none => none - | some sub => some (substInTypedTerm subst sub) - .debug (Typ.instantiate subst τ) e l t' (substInTypedTerm subst r) -termination_by t => sizeOf t -decreasing_by - all_goals first - | decreasing_tactic - | (have : ∀ {α} [SizeOf α] (a : α), sizeOf a < sizeOf (some a) := by - intros; show _ < 1 + _; omega - grind) - | (-- List branch bodies in `.match`: `(p, b) ∈ bs` ⇒ `sizeOf b < sizeOf bs`. - have hmem : _ ∈ _ := ‹_ ∈ _› - have := List.sizeOf_lt_of_mem hmem - grind) - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - -/-! ### Pure-fold decomposition of `Typed.Decls.concretize`. - -Four pure functions: - * `concretizeSeed` — Step 1, collect initial worklist from monomorphic decls. - * `concretizeDrain` — Step 2, fuel-bounded worklist specialization. - * `concretizeBuild` — Step 3, rewrite monomorphic decls using mono-map. - * `step4Lower` — Step 4, lower to `Concrete.Decls` (defined in ConcretizeSound). - -Composed without `let mut` / `while` / `for`. Each step exposes its equation -for downstream proofs. -/ - -/-- Step 2 state: pending worklist + seen set + accumulated mono map + arrays -of newly-specialized functions and datatypes. -/ -structure DrainState where - pending : Std.HashSet (Global × Array Typ) - seen : Std.HashSet (Global × Array Typ) - mono : Std.HashMap (Global × Array Typ) Global - newFunctions : Array Typed.Function - newDataTypes : Array DataType - -/-- Step 1: seed the worklist from every monomorphic decl in `decls`. -/ -def concretizeSeed (decls : Typed.Decls) : Std.HashSet (Global × Array Typ) := - decls.pairs.foldl - (fun pending p => - match p.snd with - | .function f => - if f.params.isEmpty then - let p1 := collectInTyp pending f.output - let p2 := f.inputs.foldl (fun s (_, t) => collectInTyp s t) p1 - let p3 := collectInTypedTerm p2 f.body - collectCalls decls p3 f.body - else pending - | .dataType dt => - if dt.params.isEmpty then - dt.constructors.foldl - (fun s c => c.argTypes.foldl collectInTyp s) pending - else pending - | _ => pending) - {} - -/-- Process one `(name, args)` entry in the worklist: insert into `seen` + `mono`, -specialize its template, push new pending entries from substituted body. -/ -def concretizeDrainEntry (decls : Typed.Decls) (state : DrainState) - (entry : Global × Array Typ) : Except ConcretizeError DrainState := do - let (name, args) := entry - if state.seen.contains (name, args) then pure state - else - let concName := concretizeName name args - let seen' := state.seen.insert (name, args) - let mono' := state.mono.insert (name, args) concName - match decls.getByKey name with - | some (.function f) => - if f.params.length != args.size then - throw (.wrongNumArgs name f.params.length args.size) - let subst := mkParamSubst f.params args - let newInputs := f.inputs.map fun (l, t) => (l, Typ.instantiate subst t) - let newOutput := Typ.instantiate subst f.output - let newBody := substInTypedTerm subst f.body - let p1 := collectInTyp state.pending newOutput - let p2 := newInputs.foldl (fun s (_, t) => collectInTyp s t) p1 - let p3 := collectInTypedTerm p2 newBody - let pending' := collectCalls decls p3 newBody - let newFn : Typed.Function := - { name := concName, params := [], inputs := newInputs, - output := newOutput, body := newBody, entry := false } - pure { pending := pending', seen := seen', mono := mono', - newFunctions := state.newFunctions.push newFn, - newDataTypes := state.newDataTypes } - | some (.dataType dt) => - if dt.params.length != args.size then - throw (.wrongNumArgs name dt.params.length args.size) - let subst := mkParamSubst dt.params args - let newCtors := dt.constructors.map fun c => - { c with argTypes := c.argTypes.map (Typ.instantiate subst) } - let pending' := newCtors.foldl - (fun s c => c.argTypes.foldl collectInTyp s) state.pending - let newDt : DataType := - { name := concName, params := [], constructors := newCtors } - pure { pending := pending', seen := seen', mono := mono', - newFunctions := state.newFunctions, - newDataTypes := state.newDataTypes.push newDt } - | _ => throw (.templateNotFound name) - -/-- One worklist iteration: drain all current `pending` into `seen` + mono. -New entries discovered during draining are added to the next-iteration -`pending`. Starts each iteration with `pending = {}`. -/ -def concretizeDrainIter (decls : Typed.Decls) (state : DrainState) : - Except ConcretizeError DrainState := - let batch := state.pending - let state0 : DrainState := { state with pending := {} } - batch.toArray.foldlM (concretizeDrainEntry decls) state0 - -/-- Step 2: fuel-bounded worklist drain. Fuel bounds total iterations; each -iteration fully drains current `pending` and may add new entries for the next. -`fuelExhausted` thrown if fuel hits 0 with non-empty pending. - -For fully-monomorphic programs, 1 iteration suffices — `pending` empties -after the first drain since no polymorphic templates exist. -/ -def concretizeDrain (decls : Typed.Decls) : - Nat → DrainState → Except ConcretizeError DrainState - | 0, state => - if state.pending.isEmpty then pure state - else throw .fuelExhausted - | fuel+1, state => - if state.pending.isEmpty then pure state - else do - let state' ← concretizeDrainIter decls state - concretizeDrain decls fuel state' - -/-- Step 3: build the rewritten monomorphic `Typed.Decls`. All `.app` types -with a mono-map entry are rewritten to `.ref`. -/ -def concretizeBuild (decls : Typed.Decls) (mono : MonoMap) - (newFunctions : Array Typed.Function) (newDataTypes : Array DataType) : - Typed.Decls := - let emptySubst : Global → Option Typ := fun _ => none - let fromSource : Typed.Decls := decls.pairs.foldl - (fun acc p => - let (key, d) := p - match d with - | .function f => - if f.params.isEmpty then - let newInputs := f.inputs.map fun (l, t) => (l, rewriteTyp emptySubst mono t) - let newOutput := rewriteTyp emptySubst mono f.output - let newBody := rewriteTypedTerm decls emptySubst mono f.body - acc.insert key (.function - { f with inputs := newInputs, output := newOutput, body := newBody }) - else acc - | .dataType dt => - if dt.params.isEmpty then - let newCtors := dt.constructors.map fun c => - { c with argTypes := c.argTypes.map (rewriteTyp emptySubst mono) } - acc.insert key (.dataType { dt with constructors := newCtors }) - else acc - | .constructor dt c => - if dt.params.isEmpty then - let newArgTypes := c.argTypes.map (rewriteTyp emptySubst mono) - let newCtor : Constructor := { c with argTypes := newArgTypes } - let rewrittenCtors := dt.constructors.map fun c' => - { c' with argTypes := c'.argTypes.map (rewriteTyp emptySubst mono) } - let newDt : DataType := { dt with constructors := rewrittenCtors } - acc.insert key (.constructor newDt newCtor) - else acc) - default - let withNewDts : Typed.Decls := newDataTypes.foldl - (fun acc dt => - let rewrittenCtors := dt.constructors.map fun c => - { c with argTypes := c.argTypes.map (rewriteTyp emptySubst mono) } - let newDt : DataType := { dt with constructors := rewrittenCtors } - let acc' := acc.insert dt.name (.dataType newDt) - rewrittenCtors.foldl - (fun acc'' c => - let cName := dt.name.pushNamespace c.nameHead - acc''.insert cName (.constructor newDt c)) - acc') - fromSource - newFunctions.foldl - (fun acc f => - let newInputs := f.inputs.map fun (l, t) => (l, rewriteTyp emptySubst mono t) - let newOutput := rewriteTyp emptySubst mono f.output - let newBody := rewriteTypedTerm decls emptySubst mono f.body - let newF : Typed.Function := - { f with inputs := newInputs, output := newOutput, body := newBody } - acc.insert f.name (.function newF)) - withNewDts - -/-- Fuel bound for Step 2: worst-case iterations of the worklist loop. Each -iteration adds at least one new `seen` entry (else `pending = ∅` exits). Total -entries ≤ number of distinct `(name, args)` pairs reachable from `decls` — -bounded by `decls.size * (upper-bound on nesting depth of type-argument -substitution)`. For fully-monomorphic programs, 1 suffices. Pick a generous -bound: `decls.size + 1`. Caller can raise if polymorphism hits the ceiling. -/ -def concretizeDrainFuel (decls : Typed.Decls) : Nat := decls.size + 1 - -/-- Specialise every polymorphic template reachable from concrete decls into a -concrete monomorphic copy, then lower the whole table to `Concrete.Decls`. -/ -def Typed.Decls.concretize (decls : Typed.Decls) : - Except ConcretizeError Concrete.Decls := do - let pending := concretizeSeed decls - let initState : DrainState := - { pending, seen := {}, mono := {}, newFunctions := #[], newDataTypes := #[] } - let drained ← concretizeDrain decls (concretizeDrainFuel decls) initState - let monoDecls := concretizeBuild decls drained.mono - drained.newFunctions drained.newDataTypes - let emptyMono : Std.HashMap (Global × Array Typ) Global := {} - monoDecls.foldlM (init := default) fun acc (name, d) => do match d with - | .function f => - let inputs ← f.inputs.mapM fun (l, t) => do - let t' ← typToConcrete emptyMono t - pure (l, t') - let output ← typToConcrete emptyMono f.output - let body ← termToConcrete emptyMono f.body - let concF : Concrete.Function := - { name := f.name, inputs, output, body, entry := f.entry } - pure (acc.insert name (.function concF)) - | .dataType dt => - let ctors ← dt.constructors.mapM fun c => do - let argTypes ← c.argTypes.mapM (typToConcrete emptyMono) - pure ({ nameHead := c.nameHead, argTypes } : Concrete.Constructor) - let concDt : Concrete.DataType := { name := dt.name, constructors := ctors } - pure (acc.insert name (.dataType concDt)) - | .constructor dt c => - let ctors ← dt.constructors.mapM fun c' => do - let argTypes ← c'.argTypes.mapM (typToConcrete emptyMono) - pure ({ nameHead := c'.nameHead, argTypes } : Concrete.Constructor) - let concDt : Concrete.DataType := { name := dt.name, constructors := ctors } - let argTypes ← c.argTypes.mapM (typToConcrete emptyMono) - let concC : Concrete.Constructor := { nameHead := c.nameHead, argTypes } - pure (acc.insert name (.constructor concDt concC)) - -end Aiur - -end -- @[expose] section -end diff --git a/Ix/Aiur/Compiler/Dedup.lean b/Ix/Aiur/Compiler/Dedup.lean deleted file mode 100644 index 8a9d70bfa..000000000 --- a/Ix/Aiur/Compiler/Dedup.lean +++ /dev/null @@ -1,227 +0,0 @@ -module -public import Ix.Aiur.Stages.Bytecode -public import Std.Data.HashMap - -/-! -Bytecode function deduplication via partition refinement (bisimulation). - -Functions with identical structure that differ only in call target indices are -merged — this handles mutual recursion and cycles. --/ - -public section -@[expose] section - -namespace Aiur - -namespace Bytecode - -def skeletonOp : Op → Op - | .call _ args size u => .call 0 args size u - | op => op - -/-- Termination helpers for the Block/Ctrl mutual traversals below. -/ -private theorem Block.sizeOf_ctrl_lt (b : Block) : sizeOf b.ctrl < sizeOf b := by - rcases b with ⟨ops, ctrl⟩ - show sizeOf ctrl < 1 + sizeOf ops + sizeOf ctrl - omega - -mutual - def skeletonCtrl : Ctrl → Ctrl - | .match v branches def_ => - .match v (branches.attach.map fun ⟨(g, b), _⟩ => (g, skeletonBlock b)) - (match def_ with | none => none | some b => some (skeletonBlock b)) - | .return s vs => .return s vs - | .yield s vs => .yield s vs - | .matchContinue v branches def_ outputSize sharedAux sharedLookups cont => - .matchContinue v (branches.attach.map fun ⟨(g, b), _⟩ => (g, skeletonBlock b)) - (match def_ with | none => none | some b => some (skeletonBlock b)) - outputSize sharedAux sharedLookups (skeletonBlock cont) - termination_by c => (sizeOf c, 0) - decreasing_by - all_goals first - | decreasing_tactic - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - - def skeletonBlock (block : Block) : Block := - { block with - ops := block.ops.map skeletonOp - ctrl := skeletonCtrl block.ctrl } - termination_by (sizeOf block, 1) - decreasing_by - all_goals first - | decreasing_tactic - | (apply Prod.Lex.left; exact Block.sizeOf_ctrl_lt _) -end - -def collectCalleesOp : Op → Array FunIdx - | .call idx _ _ _ => #[idx] - | _ => #[] - -private theorem Block.sizeOf_ctrl_lt' (b : Block) : sizeOf b.ctrl < sizeOf b := by - rcases b with ⟨ops, ctrl⟩ - show sizeOf ctrl < 1 + sizeOf ops + sizeOf ctrl - omega - -mutual - def collectCalleesCtrl (c : Ctrl) : Array FunIdx := match c with - | .match _ branches def_ => - let branchCallees := branches.attach.foldl (init := #[]) fun acc ⟨(_, b), _⟩ => - acc ++ collectCalleesBlock b - match def_ with - | none => branchCallees - | some b => branchCallees ++ collectCalleesBlock b - | .return .. => #[] - | .yield .. => #[] - | .matchContinue _ branches def_ _ _ _ cont => - let branchCallees := branches.attach.foldl (init := #[]) fun acc ⟨(_, b), _⟩ => - acc ++ collectCalleesBlock b - let withDefault := match def_ with - | none => branchCallees - | some b => branchCallees ++ collectCalleesBlock b - withDefault ++ collectCalleesBlock cont - termination_by (sizeOf c, 0) - decreasing_by - all_goals first - | decreasing_tactic - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - | grind - - def collectCalleesBlock (block : Block) : Array FunIdx := - let opCallees := block.ops.foldl (init := #[]) fun acc op => - acc ++ collectCalleesOp op - opCallees ++ collectCalleesCtrl block.ctrl - termination_by (sizeOf block, 1) - decreasing_by - all_goals first - | decreasing_tactic - | (apply Prod.Lex.left; exact Block.sizeOf_ctrl_lt' _) -end - -def rewriteOp (f : FunIdx → FunIdx) : Op → Op - | .call idx args size u => .call (f idx) args size u - | op => op - -mutual - def rewriteCtrl (f : FunIdx → FunIdx) (c : Ctrl) : Ctrl := match c with - | .match v branches def_ => - .match v (branches.attach.map fun ⟨(g, b), _⟩ => (g, rewriteBlock f b)) - (match def_ with | none => none | some b => some (rewriteBlock f b)) - | .return s vs => .return s vs - | .yield s vs => .yield s vs - | .matchContinue v branches def_ outputSize sharedAux sharedLookups cont => - .matchContinue v (branches.attach.map fun ⟨(g, b), _⟩ => (g, rewriteBlock f b)) - (match def_ with | none => none | some b => some (rewriteBlock f b)) - outputSize sharedAux sharedLookups (rewriteBlock f cont) - termination_by (sizeOf c, 0) - decreasing_by - all_goals first - | decreasing_tactic - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - - def rewriteBlock (f : FunIdx → FunIdx) (block : Block) : Block := - { block with - ops := block.ops.map (rewriteOp f) - ctrl := rewriteCtrl f block.ctrl } - termination_by (sizeOf block, 1) - decreasing_by - all_goals first - | decreasing_tactic - | (apply Prod.Lex.left; exact Block.sizeOf_ctrl_lt _) -end - -def assignClasses [BEq α] [Hashable α] (values : Array α) : Array Nat × Nat := - let (classes, _, nextId) := values.foldl (init := (#[], (∅ : Std.HashMap α Nat), 0)) - fun (classes, map, nextId) v => - match map[v]? with - | some id => (classes.push id, map, nextId) - | none => (classes.push nextId, map.insert v nextId, nextId + 1) - (classes, nextId) - -/-- Bounded refinement step. The `bound` caps iterations — `classes.size + 1` -is always enough since the number of distinct equivalence classes can only -increase (or stay the same) per step, and is bounded above by `classes.size`. -/ -def partitionRefineBound : Nat → Array Nat → Array (Array FunIdx) → Array Nat - | 0, classes, _ => classes - | bound+1, classes, callees => - let signatures := classes.mapIdx fun i cls => - (cls, callees[i]!.map (classes[·]!)) - let (newClasses, _) := assignClasses signatures - if newClasses == classes then classes - else partitionRefineBound bound newClasses callees -termination_by bound _ _ => bound - -/-- Outer interface. Uses `classes.size + 1` as the bound. -/ -def partitionRefine (classes : Array Nat) (callees : Array (Array FunIdx)) : Array Nat := - partitionRefineBound (classes.size + 1) classes callees - -/-! ### Pure-fold decomposition of `Toplevel.deduplicate`. - -Three pure step functions, composed without `Id.run do`. Each step exposes a -clean equation lemma for downstream proofs. -/ - -/-- Step 1: canonical-class flags from `classes`. Position `i` is canonical -iff `classes[i]` equals the number of canonical flags seen so far. -/ -def deduplicate_canonical (classes : Array Nat) : Array Bool × Nat := - classes.foldl - (fun (acc : Array Bool × Nat) cls => - let (flags, top_cls) := acc - if cls == top_cls then (flags.push True, top_cls + 1) - else (flags.push False, top_cls)) - (#[], 0) - -/-- Step 2: `remap` function. In-domain: `classes[i]`. Out-of-domain: identity -(semantically irrelevant — evaluator guards `funIdx < functions.size` before -calling — but makes out-of-range agreement provable without a separate -domain invariant). -/ -def deduplicate_remap (classes : Array Nat) : FunIdx → FunIdx := - fun i => if h : i < classes.size then classes[i] else i - -/-- Per-class `entry` aggregation: OR all `.entry` fields across class members. -Total — uses `Array.zip` (truncates to `min classes.size functions.size`). -/ -def deduplicate_class_entry (functions : Array Function) (classes : Array Nat) - (cls : Nat) : Bool := - (classes.zip functions).foldl - (fun acc p => if p.fst == cls then acc || p.snd.entry else acc) - false - -/-- Step 3: build `newFunctions` by filter-mapping canonical indices. Total — -uses `Array.zip` to pair `classes × canonical × functions` (truncates to min -size; all three have size `n` after refinement). -/ -def deduplicate_newFunctions (functions : Array Function) (classes : Array Nat) - (canonical : Array Bool) (remapFn : FunIdx → FunIdx) : Array Function := - ((classes.zip canonical).zip functions).foldl - (fun acc p => - let ((cls, can), f) := p - if can then - let entry := deduplicate_class_entry functions classes cls - let body := rewriteBlock remapFn f.body - acc.push { body, layout := f.layout, entry, constrained := false } - else acc) - #[] - -/-- Deduplicate bytecode functions via partition refinement. -Returns the deduplicated toplevel and a mapping from old index to new index. -/ -def Toplevel.deduplicate (t : Toplevel) : Toplevel × (FunIdx → FunIdx) := - let functions := t.functions - let n := functions.size - if n == 0 then (t, id) - else - -- Skeleton key includes full `FunctionLayout`: same-class functions share - -- every layout field, so dedup's per-class `layout := f.layout` - -- (canonical rep's) matches every class member's layout. - let skeletons := functions.map fun f => (skeletonBlock f.body, f.layout) - let (initClasses, _) := assignClasses skeletons - let callees := functions.map fun f => collectCalleesBlock f.body - let classes := partitionRefine initClasses callees - let (canonical, _top_cls) := deduplicate_canonical classes - let remapFn := deduplicate_remap classes - let newFunctions := deduplicate_newFunctions functions classes canonical remapFn - ({ t with functions := newFunctions }, remapFn) - -end Bytecode - -end Aiur - -end -- @[expose] section -end diff --git a/Ix/Aiur/Compiler/Layout.lean b/Ix/Aiur/Compiler/Layout.lean deleted file mode 100644 index 59ba7789d..000000000 --- a/Ix/Aiur/Compiler/Layout.lean +++ /dev/null @@ -1,311 +0,0 @@ -module -public import Ix.Aiur.Stages.Concrete -public import Ix.Aiur.Stages.Bytecode -public import Std.Data.TreeSet - -/-! -Circuit layout computation for Aiur bytecode. - -Consumes `Concrete.Term`, so `typSize` has no `.mvar` or parametric `.app` arms -to reject — the failure modes `Ix/Aiur/Compiler/Layout.lean` has (at `:41, :93` -per the `unreachable!` audit) cannot happen. - -The `gadget` arm of the previous `Layout` is dropped. --/ - -public section -@[expose] section - -namespace Aiur - -namespace Concrete - -/-! ## Flat size computation — total via `visited` set + depth bound. - -Mirrors the pattern used in `Ix/Aiur/Semantics/Flatten.lean` to keep the -three mutual functions total: every `DataType.size` call inserts a fresh -name into `visited`, and we carry a `bound` parameter that upper-bounds -the remaining recursion depth. The outer interfaces use `decls.size + 1` -as bound — the monotonic visited set makes this bound unreachable on -well-formed inputs. -/ - -mutual - -/-- See `Typ.size` for the outer interface. -/ -def Typ.sizeBound (decls : Decls) : Nat → Std.HashSet Global → Typ → - Except String Nat - | 0, _, _ => pure 0 - | _+1, _, .unit => pure 0 - | _+1, _, .field => pure 1 - | _+1, _, .pointer _ => pure 1 - | _+1, _, .function _ _ => pure 1 - | bound+1, visited, .tuple ts => - ts.attach.foldlM (init := 0) fun acc ⟨t, _⟩ => do - let s ← Typ.sizeBound decls bound visited t - pure (acc + s) - | bound+1, visited, .array t n => do - let s ← Typ.sizeBound decls bound visited t - pure (n * s) - | bound+1, visited, .ref g => match decls.getByKey g with - | some (.dataType dt) => DataType.sizeBound decls bound visited dt - | _ => throw s!"Datatype not found: `{g}`" - -/-- See `Constructor.size` for the outer interface. -/ -def Constructor.sizeBound (decls : Decls) (bound : Nat) (visited : Std.HashSet Global) - (c : Constructor) : Except String Nat := - c.argTypes.foldlM (init := 0) fun acc t => do - let s ← Typ.sizeBound decls bound visited t - pure (acc + s) - -/-- See `DataType.size` for the outer interface. -/ -def DataType.sizeBound (decls : Decls) : Nat → Std.HashSet Global → DataType → - Except String Nat - | 0, _, _ => pure 1 - | bound+1, visited, dt => - if visited.contains dt.name then - throw s!"Cycle detected at datatype `{dt.name}`" - else do - let visited := visited.insert dt.name - let ctorSizes ← dt.constructors.mapM - (Concrete.Constructor.sizeBound decls bound visited) - let maxFields := ctorSizes.foldl max 0 - -- Single-variant enums need no tag slot: the layout matches a plain - -- tuple of the sole constructor's fields. - if dt.constructors.length == 1 then pure maxFields - else pure (maxFields + 1) -end - -/-- Outer interface: the recursion bound is `decls.size + 1`, which the -monotonic growth of `visited` (capped at `decls.size`) guarantees cannot -be exhausted on well-formed inputs. -/ -def Typ.size (decls : Decls) (visited : Std.HashSet Global := {}) (t : Typ) : - Except String Nat := - Typ.sizeBound decls (decls.size + 1) visited t - -def Constructor.size (decls : Decls) (visited : Std.HashSet Global := {}) - (c : Constructor) : Except String Nat := - Constructor.sizeBound decls (decls.size + 1) visited c - -def DataType.size (dt : DataType) (decls : Decls) - (visited : Std.HashSet Global := {}) : Except String Nat := - DataType.sizeBound decls (decls.size + 1) visited dt - -namespace Bytecode - -structure SharedData where - auxiliaries : Nat - lookups : Nat - -def SharedData.maximals (a b : SharedData) : SharedData := { - auxiliaries := a.auxiliaries.max b.auxiliaries - lookups := a.lookups.max b.lookups -} - -abbrev MemSizes := Std.TreeSet Nat - -structure LayoutMState where - functionLayout : Aiur.Bytecode.FunctionLayout - memSizes : MemSizes - degrees : Array Nat - -@[inline] def LayoutMState.new (inputSize : Nat) : LayoutMState := - ⟨{ inputSize, selectors := 0, auxiliaries := 1, lookups := 0 }, .empty, Array.replicate inputSize 1⟩ - -abbrev LayoutM := StateM LayoutMState - -@[inline] def bumpSelectors (n : Nat := 1) : LayoutM Unit := - modify fun stt => { stt with - functionLayout := { stt.functionLayout with selectors := stt.functionLayout.selectors + n } } - -@[inline] def bumpLookups (n : Nat := 1) : LayoutM Unit := - modify fun stt => { stt with - functionLayout := { stt.functionLayout with lookups := stt.functionLayout.lookups + n } } - -@[inline] def bumpAuxiliaries (n : Nat := 1) : LayoutM Unit := - modify fun stt => { stt with - functionLayout := { stt.functionLayout with auxiliaries := stt.functionLayout.auxiliaries + n } } - -@[inline] def addMemSize (size : Nat) : LayoutM Unit := - modify fun stt => { stt with memSizes := stt.memSizes.insert size } - -@[inline] def pushDegree (degree : Nat) : LayoutM Unit := - modify fun stt => { stt with degrees := stt.degrees.push degree } - -@[inline] def pushDegrees (degrees : Array Nat) : LayoutM Unit := - modify fun stt => { stt with degrees := stt.degrees ++ degrees } - -@[inline] def getDegrees : LayoutM $ Array Nat := - get >>= (pure ·.degrees) - -@[inline] def getDegree (v : Aiur.Bytecode.ValIdx) : LayoutM Nat := - get >>= fun stt => pure (stt.degrees[v]?.getD 0) - -@[inline] def setDegrees (degrees : Array Nat) : LayoutM Unit := - modify fun stt => { stt with degrees } - -def getSharedData : LayoutM SharedData := - get >>= fun stt => - pure { - auxiliaries := stt.functionLayout.auxiliaries - lookups := stt.functionLayout.lookups - } - -def setSharedData (sharedData : SharedData) : LayoutM Unit := - modify fun stt => { stt with functionLayout := { stt.functionLayout with - auxiliaries := sharedData.auxiliaries - lookups := sharedData.lookups } } - -def opLayout : Bytecode.Op → LayoutM Unit - | .const _ => pushDegree 0 - | .add a b | .sub a b => do - let aDegree ← getDegree a - let bDegree ← getDegree b - pushDegree (aDegree.max bDegree) - | .mul a b => do - let aDegree ← getDegree a - let bDegree ← getDegree b - let degree := aDegree + bDegree - if degree < 2 then pushDegree degree - else do pushDegree 1; bumpAuxiliaries - | .eqZero a => do - let degree ← getDegree a - if degree = 0 then pushDegree 0 - else do pushDegree 1; bumpAuxiliaries 2 - | .call _ _ outputSize unconstrained => do - pushDegrees $ .replicate outputSize 1 - bumpAuxiliaries outputSize - if !unconstrained then bumpLookups - | .store values => do - pushDegree 1; bumpAuxiliaries; bumpLookups; addMemSize values.size - | .load size _ => do - pushDegrees $ .replicate size 1 - bumpAuxiliaries size; bumpLookups; addMemSize size - | .assertEq .. => pure () - | .ioGetInfo _ _ => do pushDegrees #[1, 1]; bumpAuxiliaries 2 - | .ioSetInfo .. => pure () - | .ioRead _ _ len => do pushDegrees $ .replicate len 1; bumpAuxiliaries len - | .ioWrite .. => pure () - | .u8BitDecomposition _ => do pushDegrees $ .replicate 8 1; bumpAuxiliaries 8; bumpLookups - | .u8ShiftLeft _ | .u8ShiftRight _ | .u8Xor .. | .u8And .. | .u8Or .. => do - pushDegree 1; bumpAuxiliaries; bumpLookups - | .u8Add a b | .u8Sub a b => do - -- Low byte `z` is the only auxiliary; the carry/borrow is a compound - -- expression of degree `max(deg a, deg b, 1)` (add: `(a+b-z)/256`, - -- sub: `(z+b-a)/256`). - let aDegree ← getDegree a - let bDegree ← getDegree b - pushDegree 1 - pushDegree ((aDegree.max bDegree).max 1) - bumpAuxiliaries; bumpLookups - | .u8Mul .. => do pushDegrees #[1, 1]; bumpAuxiliaries 2; bumpLookups - | .u8XorSplit7 .. | .u8XorSplit4 .. => do pushDegrees #[1, 1]; bumpAuxiliaries 2; bumpLookups - | .u8LessThan .. => do pushDegree 1; bumpAuxiliaries; bumpLookups - | .u32LessThan .. => do pushDegree 1; bumpAuxiliaries 6; bumpLookups 6 - | .unconstrainedU32Add a b => do - let degrees ← (a ++ b).mapM getDegree - pushDegrees $ .replicate 4 1 - pushDegree (degrees.foldl Nat.max 1) - bumpAuxiliaries 4 - | .unconstrainedU32Add3 a b c => do - let degrees ← (a ++ b ++ c).mapM getDegree - pushDegrees $ .replicate 4 1 - pushDegree (degrees.foldl Nat.max 1) - bumpAuxiliaries 4 - | .u32ToField a => do - let degrees ← a.mapM getDegree - pushDegree (degrees.foldl Nat.max 0) - -- Pure range-check lookup: no output columns/degrees, just one lookup. - | .u8RangeCheck .. => bumpLookups - -- Unconstrained hint: two fresh auxiliary witness columns (q_ptr, r_ptr). - -- No constraint relation, no lookup. Mirrors `IORead` (aux only) — the Rust - -- `constraints.rs` pushes exactly 2 auxiliaries and emits no relation. - | .unconstrainedBigUintDivMod .. => do pushDegrees #[1, 1]; bumpAuxiliaries 2 - -- Unconstrained hints: fresh auxiliary witness columns only, no relation, - -- no lookup — same shape as `IORead`. The caller pins the values. - | .unconstrainedGToBytes _ => do pushDegrees $ .replicate 8 1; bumpAuxiliaries 8 - | .unconstrainedGInverse _ => do pushDegree 1; bumpAuxiliaries - | .debug .. => pure () - -/-- Termination helper for blockLayout's Block/Ctrl traversal. -/ -private theorem Bytecode.Block.sizeOf_ctrl_lt_layout (b : Bytecode.Block) : - sizeOf b.ctrl < sizeOf b := by - rcases b with ⟨ops, ctrl⟩ - show sizeOf ctrl < 1 + sizeOf ops + sizeOf ctrl - omega - -mutual - -def ctrlLayout (c : Bytecode.Ctrl) : LayoutM Unit := match c with - | .match _ branches defaultBranch => do - let initSharedData ← getSharedData - let degrees ← getDegrees - -- Fold over branches, tracking the running maximum shared data. - let maximalSharedData ← branches.attach.foldlM (init := initSharedData) - fun currMax ⟨(_, block), _⟩ => do - setSharedData initSharedData - blockLayout block - let blockSharedData ← getSharedData - setDegrees degrees - pure (currMax.maximals blockSharedData) - -- Apply default branch if present. - let finalMax ← match defaultBranch with - | none => pure maximalSharedData - | some defaultBlock => do - setSharedData initSharedData - bumpAuxiliaries branches.size - blockLayout defaultBlock - let defaultBlockSharedData ← getSharedData - setDegrees degrees - pure (maximalSharedData.maximals defaultBlockSharedData) - setSharedData finalMax - | .return .. => bumpSelectors - | .yield .. => bumpSelectors - | .matchContinue _ branches defaultBranch outputSize _sharedAux _sharedLookups continuation => do - let initSharedData ← getSharedData - let degrees ← getDegrees - let maximalSharedData ← branches.attach.foldlM (init := initSharedData) - fun currMax ⟨(_, block), _⟩ => do - setSharedData initSharedData - blockLayout block - let blockSharedData ← getSharedData - setDegrees degrees - pure (currMax.maximals blockSharedData) - let finalMax ← match defaultBranch with - | none => pure maximalSharedData - | some defaultBlock => do - setSharedData initSharedData - bumpAuxiliaries branches.size - blockLayout defaultBlock - let defaultBlockSharedData ← getSharedData - setDegrees degrees - pure (maximalSharedData.maximals defaultBlockSharedData) - setSharedData finalMax - bumpAuxiliaries outputSize - pushDegrees (.replicate outputSize 1) - blockLayout continuation -termination_by (sizeOf c, 0) -decreasing_by - all_goals first - | decreasing_tactic - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - | grind - -def blockLayout (block : Bytecode.Block) : LayoutM Unit := do - block.ops.forM opLayout - ctrlLayout block.ctrl -termination_by (sizeOf block, 1) -decreasing_by - all_goals first - | decreasing_tactic - | (apply Prod.Lex.left; exact Bytecode.Block.sizeOf_ctrl_lt_layout _) - -end - -end Bytecode - -end Concrete - -end Aiur - -end -- @[expose] section -end diff --git a/Ix/Aiur/Compiler/Lower.lean b/Ix/Aiur/Compiler/Lower.lean deleted file mode 100644 index cbc807182..000000000 --- a/Ix/Aiur/Compiler/Lower.lean +++ /dev/null @@ -1,663 +0,0 @@ -module -public import Std.Data.HashMap -public import Ix.Aiur.Stages.Concrete -public import Ix.Aiur.Compiler.Layout - -/-! -Bytecode lowering: `Concrete.Decls` → `Bytecode.Toplevel`. - -Consumes `Concrete.Term` (no mvars, no parametric apps), so `typSize` has no -failure modes — the `Impossible case` / `unreachable!` sites in -`Ix/Aiur/Compiler/Lower.lean` cannot be reached. The `gadget` arm has been -dropped. - -Non-tail match in let-RHS positions is compiled to `Bytecode.Ctrl.matchContinue` -via `findNonTailMatch` + `compileMatchContinue`. --/ - -public section -@[expose] section - -namespace Aiur - -structure FunctionLayout where - index : Nat - inputSize : Nat - outputSize : Nat - offsets : Array Nat - deriving Inhabited - -structure ConstructorLayout where - index : Nat - size : Nat - offsets : Array Nat - -- True when the parent datatype has a single constructor: no tag slot, so - -- construction omits the tag const and matches need no discrimination. - tagless : Bool - deriving Inhabited - -inductive Layout - | dataType : (size : Nat) → Layout - | function : FunctionLayout → Layout - | constructor : ConstructorLayout → Layout - deriving Inhabited - -abbrev LayoutMap := Std.HashMap Global Layout - -open Concrete in -def Concrete.Decls.layoutMap (decls : Decls) : Except String LayoutMap := do - let pass := fun (layoutMap, funcIdx) (_, v) => do match v with - | .dataType dataType => do - let dataTypeSize ← dataType.size decls - let layoutMap := layoutMap.insert dataType.name (.dataType dataTypeSize) - let tagless := dataType.constructors.length == 1 - let pass := fun (acc, index) constructor => do - let offsets ← constructor.argTypes.foldlM (init := #[0]) fun offsets typ => do - let typSyze ← typ.size decls - pure $ offsets.push ((offsets[offsets.size - 1]?.getD 0) + typSyze) - let decl := .constructor { size := dataTypeSize, offsets, index, tagless } - let name := dataType.name.pushNamespace constructor.nameHead - pure (acc.insert name decl, index + 1) - let (layoutMap, _) ← dataType.constructors.foldlM pass (layoutMap, 0) - pure (layoutMap, funcIdx) - | .function function => do - let inputSize ← function.inputs.foldlM (init := 0) fun acc (_, typ) => do - let typSize ← typ.size decls - pure $ acc + typSize - let outputSize ← function.output.size decls - let offsets ← function.inputs.foldlM (init := #[0]) fun offsets (_, typ) => do - let typSyze ← typ.size decls - pure $ offsets.push ((offsets[offsets.size - 1]?.getD 0) + typSyze) - let layoutMap := layoutMap.insert function.name $ - .function { index := funcIdx, inputSize, outputSize, offsets } - pure (layoutMap, funcIdx + 1) - | .constructor .. => pure (layoutMap, funcIdx) - let (layoutMap, _) ← decls.foldlM pass ({}, 0) - pure layoutMap - -open Concrete in -def typSize (layoutMap : LayoutMap) : Concrete.Typ → Except String Nat -| .unit => pure 0 -| .field .. => pure 1 -| .pointer .. => pure 1 -| .function .. => pure 1 -| .tuple ts => ts.foldlM (init := 0) fun acc t => do - let tSize ← typSize layoutMap t - pure $ acc + tSize -| .array typ n => do - let size ← typSize layoutMap typ - pure $ n * size -| .ref g => match layoutMap[g]? with - | some (.dataType size) => pure size - /- The other arms are ruled out by the `Concrete.Decls.layoutMap` invariant: - every `.ref` in a well-typed concrete program points at a datatype layout. -/ - | _ => throw s!"Layout missing for `{g}`" - -structure CompilerState where - valIdx : Bytecode.ValIdx - ops : Array Bytecode.Op - selIdx : Bytecode.SelIdx - degrees : Array Nat - /-- Values computed in the current straight-line block only. Branches restore - this with the rest of the state; block boundaries discard it. -/ - available : Std.HashMap Bytecode.Op (Array Bytecode.ValIdx) := {} - deriving Inhabited - -abbrev CompileM := EStateM String CompilerState - -def pushOpDegree (degrees : Array Nat) (op : Bytecode.Op) (size : Nat) : Array Nat := - if size > 1 then - (Array.replicate size 1).foldl (init := degrees) (·.push ·) - else match op with - | .const _ => degrees.push 0 - | .add a b | .sub a b => - degrees.push ((degrees[a]?.getD 0).max (degrees[b]?.getD 0)) - | .mul a b => - let d := (degrees[a]?.getD 0) + (degrees[b]?.getD 0) - degrees.push (if d < 2 then d else 1) - | .eqZero a => degrees.push (if (degrees[a]?.getD 0) == 0 then 0 else 1) - | _ => degrees.push 1 - -/-- Only reuse deterministic field operations and immutable, content-addressed -memory. In particular, calls may perform IO, and unconstrained hints must not -be treated as constrained equalities. Keep their occurrences independent. -/ -def reusableOp : Bytecode.Op → Bool - | .const _ | .add .. | .sub .. | .mul .. | .eqZero _ | .store _ | .load .. => true - | _ => false - -def pushOp (op : Bytecode.Op) (size : Nat := 1) : CompileM (Array Bytecode.ValIdx) := - modifyGet (fun s => Id.run do - if reusableOp op then - if let some values := s.available[op]? then - return (values, s) - let valIdx := s.valIdx - let values := Array.range' valIdx size - let mut available := s.available - if reusableOp op then - available := available.insert op values - -- The retained store already proves this pointer's contents. Forward a - -- subsequent load without introducing another memory lookup or columns. - if let .store fields := op then - available := available.insert (.load fields.size valIdx) fields - return (values, { s with - valIdx := valIdx + size, - ops := s.ops.push op, - degrees := pushOpDegree s.degrees op size, - available })) - -def extractOps : CompileM (Array Bytecode.Op) := - modifyGet fun s => (s.ops, {s with ops := #[], available := {}}) - -open Concrete in -mutual - -/-- Lower a `Concrete.Term` to a flat array of `ValIdx`s, appending ops to the -state as needed. Tail-position constructors (`.ret`, `.match`) are handled by -`TypedTerm.compile` at the block level, so this function is for straight-line -code. -/ -def toIndex - (layoutMap : LayoutMap) - (bindings : Std.HashMap Local (Array Bytecode.ValIdx)) - (term : Term) : CompileM (Array Bytecode.ValIdx) := - match term with - | .unit _ _ => pure #[] - | .ret .. => throw "ret in value position (should not happen after typechecking)" - | .match .. => throw "Non-tail match in arbitrary position (not supported)" - | .letLoad _ _ dst dstTyp src bod => do - let size ← match typSize layoutMap dstTyp with - | .error e => throw e - | .ok n => pure n - let ptrIdxs := bindings[src]?.getD #[0] - let loaded ← pushOp (.load size ptrIdxs[0]!) size - toIndex layoutMap (bindings.insert dst loaded) bod - | .var _ _ name => pure (bindings[name]?.getD #[]) - | .ref _ _ name => match layoutMap[name]? with - | some (.function layout) => do - pushOp (.const (.ofNat layout.index)) - | some (.constructor layout) => do - let size := layout.size - -- Tagless single-variant: no tag slot. A nullary ctor is then a width-0 - -- (unit-like) value; with fields it pads up to `size` from empty. - if layout.tagless then - if size == 0 then pure #[] - else - let padding := (← pushOp (.const (.ofNat 0)))[0]! - pure $ Array.replicate size padding - else - let paddingOp := Bytecode.Op.const (.ofNat layout.index) - let index ← pushOp paddingOp - if index.size < size then - let padding := (← pushOp paddingOp)[0]! - pure $ index ++ Array.replicate (size - index.size) padding - else - pure index - | _ => throw s!"ref: layout missing for `{name}`" - | .field _ _ g => pushOp (Bytecode.Op.const g) - | .tuple _ _ terms | .array _ _ terms => - terms.foldlM (init := #[]) fun acc arg => do - pure $ acc ++ (← toIndex layoutMap bindings arg) - | .letVar _ _ var val bod => do - let val ← toIndex layoutMap bindings val - toIndex layoutMap (bindings.insert var val) bod - | .letWild _ _ val bod => do - let _ ← toIndex layoutMap bindings val - toIndex layoutMap bindings bod - | .add _ _ a b => do - let a ← expectIdx layoutMap bindings a; let b ← expectIdx layoutMap bindings b - pushOp (.add a b) - | .sub _ _ a b => do - let a ← expectIdx layoutMap bindings a; let b ← expectIdx layoutMap bindings b - pushOp (.sub a b) - | .mul _ _ a b => do - let a ← expectIdx layoutMap bindings a; let b ← expectIdx layoutMap bindings b - pushOp (.mul a b) - | .eqZero _ _ a => do - let a ← expectIdx layoutMap bindings a - pushOp (.eqZero a) - | .app _ _ name args unconstrained => match layoutMap[name]? with - | some (.function layout) => do - let args ← buildArgs layoutMap bindings args - pushOp (.call layout.index args layout.outputSize unconstrained) layout.outputSize - | some (.constructor layout) => do - let size := layout.size - -- Tagless single-variant: omit the tag const; args fill the layout from - -- offset 0, exactly like a tuple. - let index ← - if layout.tagless then pure #[] - else pushOp (.const (.ofNat layout.index)) - let index ← buildArgs layoutMap bindings args index - if index.size < size then - let padding := (← pushOp (.const (.ofNat 0)))[0]! - pure $ index ++ Array.replicate (size - index.size) padding - else - pure index - | _ => throw s!"app: layout missing for `{name}`" - | .proj _ _ arg i => do - let typs ← match arg.typ with - | .tuple typs => pure typs - | _ => throw "proj on non-tuple" - let offset ← (typs.extract 0 i).foldlM (init := 0) fun acc typ => do - let typLen ← match typSize layoutMap typ with - | .error e => throw e - | .ok len => pure len - pure $ typLen + acc - let arg ← toIndex layoutMap bindings arg - let iLen ← match typSize layoutMap (typs[i]?.getD .unit) with - | .error e => throw e - | .ok len => pure len - pure $ arg.extract offset (offset + iLen) - | .get _ _ arr i => do - let eltTyp ← match arr.typ with - | .array typ _ => pure typ - | _ => throw "get on non-array" - let eltSize ← match typSize layoutMap eltTyp with - | .error e => throw e - | .ok len => pure len - let offset := i * eltSize - let arr ← toIndex layoutMap bindings arr - pure $ arr.extract offset (offset + eltSize) - | .slice _ _ arr i j => do - let eltTyp ← match arr.typ with - | .array typ _ => pure typ - | _ => throw "slice on non-array" - let eltSize ← match typSize layoutMap eltTyp with - | .error e => throw e - | .ok len => pure len - let arr ← toIndex layoutMap bindings arr - pure $ arr.extract (i * eltSize) (j * eltSize) - | .set _ _ arr i val => do - let eltTyp ← match arr.typ with - | .array typ _ => pure typ - | _ => throw "set on non-array" - let eltSize ← match typSize layoutMap eltTyp with - | .error e => throw e - | .ok len => pure len - let arr ← toIndex layoutMap bindings arr - let left := arr.extract 0 (i * eltSize) - let val ← toIndex layoutMap bindings val - let right := arr.extract ((i + 1) * eltSize) - pure $ left ++ val ++ right - | .store _ _ arg => do - let args ← toIndex layoutMap bindings arg - pushOp (.store args) - | .load _ _ ptr => do - let size ← match ptr.typ with - | .pointer typ => match typSize layoutMap typ with - | .error e => throw e - | .ok len => pure len - | _ => throw "load on non-pointer" - let ptr ← expectIdx layoutMap bindings ptr - pushOp (.load size ptr) size - | .ptrVal _ _ ptr => toIndex layoutMap bindings ptr - | .assertEq _ _ a b msg ret => do - let a ← toIndex layoutMap bindings a - let b ← toIndex layoutMap bindings b - modify fun stt => { stt with ops := stt.ops.push (.assertEq a b msg) } - toIndex layoutMap bindings ret - | .ioGetInfo _ _ channel key => do - let channel ← expectIdx layoutMap bindings channel - let key ← toIndex layoutMap bindings key - pushOp (.ioGetInfo channel key) 2 - | .ioSetInfo _ _ channel key idx len ret => do - let channel ← expectIdx layoutMap bindings channel - let key ← toIndex layoutMap bindings key - let idx ← expectIdx layoutMap bindings idx - let len ← expectIdx layoutMap bindings len - modify fun stt => { stt with ops := stt.ops.push (.ioSetInfo channel key idx len) } - toIndex layoutMap bindings ret - | .ioRead _ _ channel idx len => do - let channel ← expectIdx layoutMap bindings channel - let idx ← expectIdx layoutMap bindings idx - pushOp (.ioRead channel idx len) len - | .ioWrite _ _ channel data ret => do - let channel ← expectIdx layoutMap bindings channel - let data ← toIndex layoutMap bindings data - modify fun stt => { stt with ops := stt.ops.push (.ioWrite channel data) } - toIndex layoutMap bindings ret - | .u8BitDecomposition _ _ byte => do - let byte ← expectIdx layoutMap bindings byte - pushOp (.u8BitDecomposition byte) 8 - | .u8ShiftLeft _ _ byte => do let byte ← expectIdx layoutMap bindings byte; pushOp (.u8ShiftLeft byte) - | .u8ShiftRight _ _ byte => do let byte ← expectIdx layoutMap bindings byte; pushOp (.u8ShiftRight byte) - | .u8Xor _ _ i j => do - let i ← expectIdx layoutMap bindings i; let j ← expectIdx layoutMap bindings j - pushOp (.u8Xor i j) - | .u8Add _ _ i j => do - let i ← expectIdx layoutMap bindings i; let j ← expectIdx layoutMap bindings j - pushOp (.u8Add i j) 2 - | .u8Mul _ _ i j => do - let i ← expectIdx layoutMap bindings i; let j ← expectIdx layoutMap bindings j - pushOp (.u8Mul i j) 2 - | .u8XorSplit7 _ _ i j => do - let i ← expectIdx layoutMap bindings i; let j ← expectIdx layoutMap bindings j - pushOp (.u8XorSplit7 i j) 2 - | .u8XorSplit4 _ _ i j => do - let i ← expectIdx layoutMap bindings i; let j ← expectIdx layoutMap bindings j - pushOp (.u8XorSplit4 i j) 2 - | .u8Sub _ _ i j => do - let i ← expectIdx layoutMap bindings i; let j ← expectIdx layoutMap bindings j - pushOp (.u8Sub i j) 2 - | .u8And _ _ i j => do let i ← expectIdx layoutMap bindings i; let j ← expectIdx layoutMap bindings j; pushOp (.u8And i j) - | .u8Or _ _ i j => do let i ← expectIdx layoutMap bindings i; let j ← expectIdx layoutMap bindings j; pushOp (.u8Or i j) - | .u8LessThan _ _ i j => do let i ← expectIdx layoutMap bindings i; let j ← expectIdx layoutMap bindings j; pushOp (.u8LessThan i j) - | .u32LessThan _ _ i j => do let i ← expectIdx layoutMap bindings i; let j ← expectIdx layoutMap bindings j; pushOp (.u32LessThan i j) - | .unconstrainedU32Add _ _ a b => do - let a ← toIndex layoutMap bindings a - let b ← toIndex layoutMap bindings b - pushOp (.unconstrainedU32Add a b) 5 - | .unconstrainedU32Add3 _ _ a b c => do - let a ← toIndex layoutMap bindings a - let b ← toIndex layoutMap bindings b - let c ← toIndex layoutMap bindings c - pushOp (.unconstrainedU32Add3 a b c) 5 - | .u32ToField _ _ a => do - let a ← toIndex layoutMap bindings a - pushOp (.u32ToField a) - | .u8RangeCheck _ _ i j => do - -- Side-effecting lookup; the two `u8` outputs alias the inputs, so no new - -- value slots are allocated (cf. `.assertEq`). - let i ← expectIdx layoutMap bindings i - let j ← expectIdx layoutMap bindings j - modify fun stt => { stt with ops := stt.ops.push (.u8RangeCheck i j) } - pure #[i, j] - | .unconstrainedBigUintDivMod _ _ a b => do - -- Unconstrained hint: runtime computes q,r via BigUint::div_rem and writes - -- two fresh pointers (q_ptr, r_ptr) into the witness columns. No constraint - -- relation is emitted; caller verifies `q*b + r == a` and `r < b` separately. - let a ← expectIdx layoutMap bindings a - let b ← expectIdx layoutMap bindings b - pushOp (.unconstrainedBigUintDivMod a b) 2 - | .unconstrainedGToBytes _ _ a => do - let a ← expectIdx layoutMap bindings a - pushOp (.unconstrainedGToBytes a) 8 - | .unconstrainedGInverse _ _ a => do - let a ← expectIdx layoutMap bindings a - pushOp (.unconstrainedGInverse a) - | .debug _ _ label term ret => do - let term ← match term with - | none => pure none - | some sub => do pure (some (← toIndex layoutMap bindings sub)) - modify fun stt => { stt with ops := stt.ops.push (.debug label term) } - toIndex layoutMap bindings ret -termination_by (sizeOf term, 0) -decreasing_by - all_goals first - | decreasing_tactic - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - -/-- Lower a list of args, appending each lowered ValIdx to `init`. -/ -def buildArgs - (layoutMap : LayoutMap) - (bindings : Std.HashMap Local (Array Bytecode.ValIdx)) - (args : List Term) (init : Array Bytecode.ValIdx := #[]) : - CompileM (Array Bytecode.ValIdx) := - args.attach.foldlM (init := init) fun acc ⟨arg, _⟩ => do - pure (acc.append (← toIndex layoutMap bindings arg)) -termination_by (sizeOf args, 1) - -/-- Lower a term, asserting it produces exactly one ValIdx. -/ -def expectIdx - (layoutMap : LayoutMap) - (bindings : Std.HashMap Local (Array Bytecode.ValIdx)) - (term : Term) : CompileM Bytecode.ValIdx := do - let idxs ← toIndex layoutMap bindings term - if h : idxs.size = 1 then - have : 0 < idxs.size := by simp only [h, Nat.lt_add_one] - pure idxs[0] - else throw "Term is not of size 1" -termination_by (sizeOf term, 1) - -end - -/-- Compute the max aux/lookup usage across match-continue branches (for layout -pre-reservation). Uses `Bytecode.blockLayout` with the current degree array. -/ -def Concrete.computeSharedLayout - (matchCases : Array (G × Bytecode.Block)) - (defaultBlock : Option Bytecode.Block) : CompileM (Nat × Nat) := do - let degrees := (← get).degrees - let initLS : Bytecode.LayoutMState := - ⟨{ inputSize := 0, selectors := 0, auxiliaries := 0, lookups := 0 }, - .empty, degrees⟩ - let (sharedAux, sharedLookups) := matchCases.foldl (init := (0, 0)) - fun (maxA, maxL) (_, block) => - let (_, ls) := Bytecode.blockLayout block |>.run initLS - (maxA.max ls.functionLayout.auxiliaries, maxL.max ls.functionLayout.lookups) - pure $ match defaultBlock with - | some block => - let (_, ls) := Bytecode.blockLayout block |>.run initLS - (sharedAux.max (ls.functionLayout.auxiliaries + matchCases.size), - sharedLookups.max ls.functionLayout.lookups) - | none => (sharedAux, sharedLookups) - -mutual - -/-- Lower a `Concrete.Term` body to a `Bytecode.Block`. -/ -def Concrete.Term.compile - (term : Concrete.Term) (returnTyp : Concrete.Typ) (layoutMap : LayoutMap) - (bindings : Std.HashMap Local (Array Bytecode.ValIdx)) - (yieldCtrl : Bool := false) : CompileM Bytecode.Block := - match term with - -- Non-tail match: `let var = match scrut {...}; body` → `matchContinue` ctrl. - | .letVar _ _ var (.match matchTyp valEscapes scrut cases defaultOpt) bod => do - if valEscapes then - -- All branches escape; match is effectively tail, body is dead. - (Concrete.Term.match matchTyp valEscapes scrut cases defaultOpt).compile - returnTyp layoutMap bindings yieldCtrl - else - let idxs := bindings[scrut]?.getD #[0] - let ops ← extractOps - let (matchCases, defaultBlock) ← cases.foldlM (init := (#[], .none)) - (Concrete.addCase layoutMap bindings returnTyp idxs (yieldCtrl := true)) - let defaultBlock ← match defaultOpt with - | some t => do - let blk ← t.compile returnTyp layoutMap bindings (yieldCtrl := true) - pure (some blk) - | none => pure defaultBlock - let outputSize ← match typSize layoutMap matchTyp with - | .error e => throw e - | .ok n => pure n - let (sharedAux, sharedLookups) ← Concrete.computeSharedLayout matchCases defaultBlock - let mergedStart := (← get).valIdx - modify fun s => { s with - valIdx := s.valIdx + outputSize, - degrees := (Array.replicate outputSize 1).foldl (init := s.degrees) (·.push ·) } - let mergedIdxs := Array.range' mergedStart outputSize - let continuation ← bod.compile returnTyp layoutMap - (bindings.insert var mergedIdxs) yieldCtrl - let ctrl : Bytecode.Ctrl := - .matchContinue idxs[0]! matchCases defaultBlock outputSize - sharedAux sharedLookups continuation - pure ({ ops, ctrl } : Bytecode.Block) - | .letWild _ _ (.match matchTyp valEscapes scrut cases defaultOpt) bod => do - if valEscapes then - (Concrete.Term.match matchTyp valEscapes scrut cases defaultOpt).compile - returnTyp layoutMap bindings yieldCtrl - else - let idxs := bindings[scrut]?.getD #[0] - let ops ← extractOps - let (matchCases, defaultBlock) ← cases.foldlM (init := (#[], .none)) - (Concrete.addCase layoutMap bindings returnTyp idxs (yieldCtrl := true)) - let defaultBlock ← match defaultOpt with - | some t => do - let blk ← t.compile returnTyp layoutMap bindings (yieldCtrl := true) - pure (some blk) - | none => pure defaultBlock - let outputSize ← match typSize layoutMap matchTyp with - | .error e => throw e - | .ok n => pure n - let (sharedAux, sharedLookups) ← Concrete.computeSharedLayout matchCases defaultBlock - modify fun s => { s with - valIdx := s.valIdx + outputSize, - degrees := (Array.replicate outputSize 1).foldl (init := s.degrees) (·.push ·) } - let continuation ← bod.compile returnTyp layoutMap bindings yieldCtrl - let ctrl : Bytecode.Ctrl := - .matchContinue idxs[0]! matchCases defaultBlock outputSize - sharedAux sharedLookups continuation - pure ({ ops, ctrl } : Bytecode.Block) - | .letVar _ _ var val bod => do - let val ← toIndex layoutMap bindings val - bod.compile returnTyp layoutMap (bindings.insert var val) yieldCtrl - | .letWild _ _ val bod => do - let _ ← toIndex layoutMap bindings val - bod.compile returnTyp layoutMap bindings yieldCtrl - | .letLoad _ _ dst dstTyp src bod => do - let size ← match typSize layoutMap dstTyp with - | .error e => throw e - | .ok n => pure n - let ptrIdxs := bindings[src]?.getD #[0] - let loaded ← pushOp (.load size ptrIdxs[0]!) size - bod.compile returnTyp layoutMap (bindings.insert dst loaded) yieldCtrl - | .debug _ _ label term ret => do - let term ← term.mapM (toIndex layoutMap bindings) - modify fun stt => { stt with ops := stt.ops.push (.debug label term) } - ret.compile returnTyp layoutMap bindings yieldCtrl - | .assertEq _ _ a b msg ret => do - let a ← toIndex layoutMap bindings a - let b ← toIndex layoutMap bindings b - modify fun stt => { stt with ops := stt.ops.push (.assertEq a b msg) } - ret.compile returnTyp layoutMap bindings yieldCtrl - | .ioSetInfo _ _ channel key idx len ret => do - let channel ← toIndex layoutMap bindings channel - let key ← toIndex layoutMap bindings key - let idx ← toIndex layoutMap bindings idx - let len ← toIndex layoutMap bindings len - modify fun stt => { stt with ops := stt.ops.push (.ioSetInfo channel[0]! key idx[0]! len[0]!) } - ret.compile returnTyp layoutMap bindings yieldCtrl - | .ioWrite _ _ channel data ret => do - let channel ← toIndex layoutMap bindings channel - let data ← toIndex layoutMap bindings data - modify fun stt => { stt with ops := stt.ops.push (.ioWrite channel[0]! data) } - ret.compile returnTyp layoutMap bindings yieldCtrl - | .match _ _ scrut cases defaultOpt => do - let idxs := bindings[scrut]?.getD #[0] - let ops ← extractOps - let (bcCases, defaultBlock) ← cases.foldlM (init := (#[], .none)) - (Concrete.addCase layoutMap bindings returnTyp idxs yieldCtrl) - let defaultBlock ← match defaultOpt with - | some t => do - let blk ← t.compile returnTyp layoutMap bindings yieldCtrl - pure (some blk) - | none => pure defaultBlock - let ctrl : Bytecode.Ctrl := .match idxs[0]! bcCases defaultBlock - pure ({ ops, ctrl } : Bytecode.Block) - | .ret _ _ term => do - let idxs ← toIndex layoutMap bindings term - let state ← get - let state := { state with selIdx := state.selIdx + 1, available := {} } - set state - let ops := state.ops - let id := state.selIdx - pure ({ ops, ctrl := .return (id - 1) idxs } : Bytecode.Block) - | _ => do - let idxs ← toIndex layoutMap bindings term - let state ← get - let state := { state with selIdx := state.selIdx + 1, available := {} } - set state - let ops := state.ops - let id := state.selIdx - let ctrl : Bytecode.Ctrl := - if yieldCtrl && !term.escapes then .yield (id - 1) idxs else .return (id - 1) idxs - pure ({ ops, ctrl } : Bytecode.Block) -termination_by (sizeOf term, 0) -decreasing_by - all_goals first - | decreasing_tactic - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - | grind - -def Concrete.addCase - (layoutMap : LayoutMap) - (bindings : Std.HashMap Local (Array Bytecode.ValIdx)) - (returnTyp : Concrete.Typ) - (idxs : Array Bytecode.ValIdx) - (yieldCtrl : Bool := false) : - (Array (G × Bytecode.Block) × Option Bytecode.Block) → - (Concrete.Pattern × Concrete.Term) → - CompileM (Array (G × Bytecode.Block) × Option Bytecode.Block) := - fun (cases, defaultBlock) (pat, term) => - match pat with - | .field g => do - let initState ← get - let term ← term.compile returnTyp layoutMap bindings yieldCtrl - set { initState with selIdx := (← get).selIdx } - pure (cases.push (g, term), defaultBlock) - | .ref global pats => do - let (index, offsets, tagless) ← match layoutMap[global]? with - | some (.function layout) => pure (layout.index, layout.offsets, false) - | some (.constructor layout) => pure (layout.index, layout.offsets, layout.tagless) - | _ => throw s!"addCase: layout missing for `{global}`" - -- Bind each sub-pattern `Local` to the corresponding slice of `idxs`. - -- A tagged layout reserves `idxs[0]` for the tag, so argument `i` occupies - -- `idxs[1 + offsets[i] .. 1 + offsets[i+1]]`. A tagless (single-variant) - -- layout has no tag slot, so the base is `0` — a tuple-identical layout. - let base := if tagless then 0 else 1 - let ptrBindings : Std.HashMap Local (Array Bytecode.ValIdx) := - (Array.range pats.size).foldl (init := bindings) fun acc i => - let startOff := base + (offsets[i]?.getD 0) - let endOff := base + (offsets[i+1]?.getD (offsets[i]?.getD 0)) - let slice := idxs.extract startOff endOff - let patLocal := pats[i]?.getD (.idx 0) - acc.insert patLocal slice - let initState ← get - let term ← term.compile returnTyp layoutMap ptrBindings yieldCtrl - set { initState with selIdx := (← get).selIdx } - -- Single-variant: emit the arm as the unconditional default. With no other - -- cases the `.match`/`.matchContinue` always falls through to it, so no tag - -- discrimination occurs (`idxs[0]` is a field, never a tag). - if tagless then pure (cases, .some term) - else pure (cases.push (.ofNat index, term), defaultBlock) - | .wildcard => do - let initState ← get - let term ← term.compile returnTyp layoutMap bindings yieldCtrl - set { initState with selIdx := (← get).selIdx } - pure (cases, .some term) - | _ => throw "addCase: unsupported pattern in concrete lower" -termination_by _ pair => (sizeOf pair.snd, 1) -decreasing_by all_goals first | decreasing_tactic | grind - -end - -/-- Lower a full concrete function to bytecode. -/ -def Concrete.Function.compile (layoutMap : LayoutMap) (f : Concrete.Function) : - Except String (Bytecode.Block × Bytecode.LayoutMState) := do - let (_inputSize, _outputSize) ← match layoutMap[f.name]? with - | some (.function layout) => pure (layout.inputSize, layout.outputSize) - | _ => throw s!"`{f.name}` should be a function" - let (valIdx, bindings) ← f.inputs.foldlM (init := (0, default)) - fun (valIdx, bindings) (arg, typ) => do - let len ← match typSize layoutMap typ with - | .error e => throw e - | .ok len => pure len - let indices := Array.range' valIdx len - pure (valIdx + len, bindings.insert arg indices) - let state := { valIdx, selIdx := 0, ops := #[], degrees := Array.replicate valIdx 1 } - match f.body.compile f.output layoutMap bindings |>.run state with - | .error e _ => throw e - | .ok body _ => - let (_, layoutMState) := Bytecode.blockLayout body |>.run (.new valIdx) - let layoutMState := { layoutMState with functionLayout := - { layoutMState.functionLayout with - lookups := layoutMState.functionLayout.lookups + 1 } } - pure (body, layoutMState) - -def Concrete.Decls.toBytecode (decls : Concrete.Decls) : - Except String (Bytecode.Toplevel × Std.HashMap Global Bytecode.FunIdx) := do - let layout ← decls.layoutMap - let initMemSizes : Bytecode.MemSizes := .empty - let (functions, memSizes, nameMap) ← decls.foldlM (init := (#[], initMemSizes, {})) - fun acc@(functions, memSizes, nameMap) (_, decl) => match decl with - | .function function => do - let (body, layoutMState) ← match function.compile layout with - | .error e => throw s!"[{function.name}] {e}" - | .ok r => pure r - let nameMap := nameMap.insert function.name functions.size - let function := ⟨body, layoutMState.functionLayout, function.entry, false⟩ - let memSizes := layoutMState.memSizes.foldl (·.insert ·) memSizes - pure (functions.push function, memSizes, nameMap) - | _ => pure acc - pure (⟨functions, memSizes.toArray, #[]⟩, nameMap) - -end Aiur - -end -- @[expose] section -end diff --git a/Ix/Aiur/Compiler/Match.lean b/Ix/Aiur/Compiler/Match.lean deleted file mode 100644 index 90d05ca83..000000000 --- a/Ix/Aiur/Compiler/Match.lean +++ /dev/null @@ -1,534 +0,0 @@ -module -public import Ix.Aiur.Compiler.Check -public import Ix.Aiur.Stages.Simple -public import Ix.SmallMap - -/-! -Match compiler: `Typed.Term` → `Simple.Term`. - -Consumes `Typed.Term` and produces `Simple.Term` directly. The double -`checkFunction` pass goes away because we no longer round-trip through -untyped `Term`. - -Decision-tree style with Maranget's heuristics: -- `.or` subpatterns → duplicated rows via DNF-product. -- Nested subpatterns → bare `Local` with guard rows for the children. -- `.pointer` subpatterns → `.letLoad` to materialise the dereferenced value, then - match on that value. -- Non-exhaustive matches: the diagnostics flag `missing` is set; downstream - (`Simple.lean`) converts this into `CheckError.nonExhaustiveMatch`. - -`Simple.Term`'s `.match` admits matches in `letVar`-RHS positions -only; this is exactly what `findNonTailMatch` detects in `Lower`. --/ - -public section - -namespace Aiur - -namespace MatchCompiler - -open Typed - -abbrev TermId := Nat -/-- A term plus a unique id — used so we can share a value across multiple -guards without re-evaluating. -/ -abbrev UniqTerm := TermId × Term - -/-- The patterns that `Simple.Pattern` admits directly, plus a `pointer` form -that the match compiler lowers to a `letLoad`. -/ -inductive SPattern - | field : G → SPattern - | ref : Global → Array Local → SPattern - | tuple : Array Local → SPattern - | array : Array Local → SPattern - /-- `pointer v t` binds `v` to the dereferenced value; `t` is the element type - (the `inner` of the pointer type), needed so `Simple.TermInner.letLoad` - can be produced with its required type annotation. -/ - | pointer : Local → Typ → SPattern - deriving BEq, Hashable, Inhabited - -structure Clause where - pat : SPattern - guards : Array (Pattern × UniqTerm) - body : UniqTerm - deriving Inhabited - -structure ExtTerm where - renames : Array (Local × Term) - value : Term - deriving Inhabited - -structure Row where - clauses : Array Clause - body : ExtTerm - uniqId : TermId - deriving Inhabited - -structure Diagnostics where - missing : Bool - reachable : List Term - deriving Inhabited - -structure Compiler where - uniqId : TermId - decls : Source.Decls - diagnostics : Diagnostics - -abbrev CompilerM := StateM Compiler - -def setId (id : TermId) : CompilerM Unit := - modify fun stt => { stt with uniqId := id } - -def newId : CompilerM TermId := do - let varId ← Compiler.uniqId <$> get - modify fun stt => { stt with uniqId := stt.uniqId + 1 } - pure varId - -/-- Look up the constructor's argument types in `decls`, with template -parameters substituted according to the scrutinee's concrete type arguments. -Returns an empty array if the global isn't a constructor. - -For a templated constructor like `TList.TCons : G → &TList‹A› → TList‹A›`, -calling this with `scrutTyp = .app TList [.field]` returns -`[.field, .pointer (.app TList [.field])]` — A has been substituted with G. -Without this substitution, fresh vars introduced by the match compiler would -carry stale `.ref A` annotations that downstream passes can't resolve. -/ -private def constructorArgTypes (decls : Source.Decls) (g : Global) - (scrutTyp : Typ) : Array Typ := - match decls.getByKey g with - | some (.constructor dt ctor) => - let subst : Global → Option Typ := - match scrutTyp with - | .app _ args => mkParamSubst dt.params args - | _ => fun _ => none - (ctor.argTypes.map (Typ.instantiate subst)).toArray - | _ => #[] - -/-- Convert a source-language `Pattern` into a guarded `SPattern` clause set via -DNF-product rewriting. Does not enter nested patterns — those become guard rows. - -Each fresh per-arg `Local` is bound at the *correct* type — pulled from the -parent constructor/tuple/array — so downstream passes (e.g. `.pointer` arms -of `decisionToTyped`) can read the right type off the bound `.var` term. -/ -def dnfProd (branches: List $ Pattern × UniqTerm) (body : ExtTerm) : CompilerM (Array Row) := do - let initId ← Compiler.uniqId <$> get - let stt ← get - let decls := stt.decls - let rec aux := fun renames clauses branches body => match branches with - | [] => do - let id ← Compiler.uniqId <$> get - let row := ⟨clauses, { body with renames := body.renames ++ renames }, id⟩ - setId initId - pure #[row] - | (.or patL patR, term) :: rest => do - let rowsL ← aux renames clauses ((patL, term) :: rest) body - let rowsR ← aux renames clauses ((patR, term) :: rest) body - pure $ rowsL ++ rowsR - | (.wildcard, _) :: rest => aux renames clauses rest body - | (.var var, (_, term)) :: rest => aux (renames.push (var, term)) clauses rest body - | (.field g, term) :: rest => aux renames (clauses.push ⟨.field g, #[], term⟩) rest body - | (.tuple args, term) :: rest => do - let argTypes := match term.snd.typ with - | .tuple ts => ts - | _ => Array.replicate args.size .unit - let (vars, guards) ← flattenArgs args argTypes - let clause := ⟨.tuple vars, guards, term⟩ - aux renames (clauses.push clause) rest body - | (.array args, term) :: rest => do - let eltTyp := match term.snd.typ with - | .array t _ => t - | _ => .unit - let argTypes := Array.replicate args.size eltTyp - let (vars, guards) ← flattenArgs args argTypes - let clause := ⟨.array vars, guards, term⟩ - aux renames (clauses.push clause) rest body - | (.ref global args, term) :: rest => do - let argTypes := constructorArgTypes decls global term.snd.typ - let (vars, guards) ← flattenArgs args.toArray argTypes - let clause := ⟨.ref global vars, guards, term⟩ - aux renames (clauses.push clause) rest body - | (.pointer arg, term) :: rest => do - let id ← newId - let var := .idx id - let innerTyp := match term.snd.typ with - | .pointer t => t - | _ => .unit - let guards := #[(arg, (id, (Typed.Term.var innerTyp false var : Term)))] - let clause := ⟨.pointer var innerTyp, guards, term⟩ - aux renames (clauses.push clause) rest body - aux Array.empty Array.empty branches body -where - flattenArgs (args : Array Pattern) (argTypes : Array Typ) := do - let varIds ← args.mapM fun _ => newId - let guards := args.zip varIds |>.mapIdx fun i (arg, id) => - let typ := argTypes[i]?.getD .unit - (arg, (id, (Typed.Term.var typ false (.idx id) : Term))) - pure (varIds.map .idx, guards) - -inductive Decision - | success : ExtTerm → Decision - | failure - /-- `switch scrutVar scrutTyp cases fallback` — `scrutTyp` is the type of - `scrutVar` at the point of the switch. Preserving it is necessary so - `decisionToTyped` can emit each nested `.match` with the correct scrutinee - type annotation; downstream `Concretize.rewritePattern` consults that type - to pick the right monomorphic constructor name (e.g. `List.Nil` → - `List.G.Nil` when the scrutinee is `List`). -/ - | switch : Local → Typ → List (SPattern × Decision) → Decision → Decision - | letLoad : (dst : Local) → (dstTyp : Typ) → (src : Local) → Decision → Decision - | let : Local → Term → Decision → Decision - deriving Inhabited - -def modifyDiagnostics (f : Diagnostics → Diagnostics) : CompilerM Unit := - modify fun stt => { stt with diagnostics := f stt.diagnostics } - -def patTypeLength (decls : Source.Decls) : SPattern → Nat - | .field _ => gSize.toNat - | .tuple _ => 1 - | .array _ => 1 - | .ref global _ => typeLookup global |>.constructors.length - | .pointer _ _ => 1 -where - typeLookup (global : Global) := - match global.popNamespace with - | some (_, enum) => match decls.getByKey enum with - | some (.dataType typ) => typ - | _ => ⟨⟨.anonymous⟩, [], []⟩ - | none => ⟨⟨.anonymous⟩, [], []⟩ - -def extractSPatterns (rows : Array Row) (term : UniqTerm) : SmallMap SPattern (Array Row) := - rows.foldl (init := default) processRow -where - processRow map row := row.clauses.foldl (init := map) processClause - processClause map clause := - if term.fst == clause.body.fst then map.insert clause.pat #[] else map - -def removeFirstInstance (find : α → Bool) (vec : Array α) : Option (α × Array α) := - match h : vec.findIdx? find with - | none => none - | some i => - let filtered := vec.extract 0 i ++ vec.extract (i + 1) vec.size - have := Array.findIdx?_eq_some_iff_findIdx_eq.mp h |>.left - some (vec[i], filtered) - -def rowRemoveClause (row : Row) (term : UniqTerm) : Option (Clause × Row) := - let id := term.fst - match removeFirstInstance (·.body.fst == id) row.clauses with - | some (deletedClause, restClauses) => some (deletedClause, { row with clauses := restClauses }) - | none => none - -def switch (cases : List (SPattern × Decision)) (fallback : Decision) : UniqTerm → Decision - | (_, .var typ _ var) => .switch var typ cases fallback - | (id, term) => let var := .idx id; .let var term (.switch var term.typ cases fallback) - -/-! Maranget's decision-tree algorithm terminates on well-formed inputs via -a measure on row-matrices, but reducing that measure to a Lean `Nat` is -delicate. We use a fuel bound threaded through the mutual block; the outer -`compileRows` entry picks a generous bound computed from the row matrix. - -When fuel runs out we return `.failure` (surfaced as nonExhaustive downstream), -which would be a bug for well-formed inputs — the bound is chosen to be -unreachable on any practical Aiur program. -/ - -/-- Row dispatcher used by `compileSwitchBound`. Pulled out as a top-level -function (rather than a `where`) to avoid an implicit mutual cycle. -/ -private def processRow (term : UniqTerm) : SmallMap SPattern (Array Row) × Array Row → - Row → CompilerM (SmallMap SPattern (Array Row) × Array Row) := - fun (rowMap, fallbackRows) row => - match rowRemoveClause row term with - | some (clause, row') => do - setId row.uniqId - let newRows ← dnfProd clause.guards.toList row'.body - let newRows := newRows.map (fun r => { r with clauses := r.clauses ++ row'.clauses }) - let updatedMap := rowMap.update clause.pat (· ++ newRows) - pure (updatedMap, fallbackRows) - | none => pure (rowMap.map (·.push row), fallbackRows.push row) - -mutual - -def compileSwitchBound : Nat → Array Row → UniqTerm → CompilerM Decision - | 0, _, _ => pure .failure - | bound+1, rows, term => do - let stt ← get - let numCases := patTypeLength stt.decls rows[0]!.clauses[0]!.pat - let spatMap := extractSPatterns rows term - let size := spatMap.size - if size == numCases then - let (rowMap, _) ← rows.foldlM (init := (spatMap, #[])) (processRow term) - let cases ← rowMap.toList.mapM fun (pat, rows) => - Prod.mk pat <$> compileRowsBound bound rows - setId stt.uniqId - pure $ switch cases .failure term - else - let (rowMap, fallbackRows) ← rows.foldlM (init := (spatMap, #[])) (processRow term) - let cases ← rowMap.toList.mapM fun (pat, rows) => - Prod.mk pat <$> compileRowsBound bound rows - let fallback ← compileRowsBound bound fallbackRows - setId stt.uniqId - pure $ switch cases fallback term -termination_by bound _ _ => (bound, 0) - -def compileRowsBound : Nat → Array Row → CompilerM Decision - | 0, _ => do - modifyDiagnostics fun d => { d with missing := true } - pure .failure - | bound+1, rows => - match rows[0]? with - | some row => match row.clauses[0]? with - | some clause => compileSwitchBound bound rows clause.body - | none => do - modifyDiagnostics fun d => { d with reachable := row.body.value :: d.reachable } - pure $ .success row.body - | none => do - modifyDiagnostics fun d => { d with missing := true } - pure .failure -termination_by bound _ => (bound, 1) - -end - -/-- Estimated bound on the compile-matrix recursion depth. Conservative: -twice the sum of (rows × max-clauses-per-row), plus 1024 slack. -/ -private def rowBound (rows : Array Row) : Nat := - let maxClauses := rows.foldl (init := 0) fun acc row => max acc row.clauses.size - rows.size * (1 + maxClauses) * 2 + 1024 - -def compileSwitch (rows : Array Row) (term : UniqTerm) : CompilerM Decision := - compileSwitchBound (rowBound rows) rows term - -def compileRows (rows : Array Row) : CompilerM Decision := - compileRowsBound (rowBound rows) rows - -def compile (term : Term) (rules : List (Pattern × Term)) : CompilerM (Decision × Diagnostics) := do - let id ← newId - -- All patterns must refer to the SAME evaluated scrutinee. In particular, - -- a variable fallback must not bind the original expression again after - -- `switch` has already evaluated it to choose the branch. - let scrut := match term with - | .var .. => term - | _ => .var term.typ false (.idx id) - let rows ← rules.foldlM (init := #[]) fun acc rule => do - let (pat, bod) := rule - let newRows ← dnfProd [(pat, (id, scrut))] ⟨#[], bod⟩ - pure $ acc ++ newRows - let tree ← compileRows rows - let tree := match term with - | .var .. => tree - | _ => .let (.idx id) term tree - let diagnostics ← Compiler.diagnostics <$> get - pure (tree, diagnostics) - -def runWithNewCompiler (decls : Source.Decls) (f : CompilerM α) : α := - StateT.run' f ⟨0, decls, ⟨false, []⟩⟩ - -def runMatchCompiler (decls : Source.Decls) (term : Term) (rules : List (Pattern × Term)) : - Decision × Diagnostics := - runWithNewCompiler decls (compile term rules) - -/-! ## Decision tree → Simple.Term - -The decision tree is lowered into `Simple.Term` directly, preserving types from -the input `Typed.Term`s. `pointer`-guard rows become `.letLoad` nodes. - -Non-exhaustive matches produce `none` on the `Decision.failure` branch; the caller -(`Compiler/Simple.lean`) surfaces this as `CheckError.nonExhaustiveMatch`. --/ - -def sPatternToSimple : SPattern → Option Simple.Pattern - | .field g => some (.field g) - | .ref global vars => some (.ref global vars) - | .tuple vars => some (.tuple vars) - | .array vars => some (.array vars) - /- pointer patterns are converted into a `.letLoad` before emission -/ - | .pointer _ _ => none - -/-- Translate a typed term to a simple term, traversing the new plain-inductive -shape: pattern-match on each `Typed.Term` constructor and rebuild as the -matching `Simple.Term` constructor. Pulled out of the `decisionToSimple` -mutual block since it doesn't recurse on `Decision`. -/ -def typedToSimple : Term → Simple.Term - | .unit τ e => .unit τ e - | .var τ e l => .var τ e l - | .ref τ e g tArgs => .ref τ e g tArgs - | .field τ e g => .field τ e g - | .tuple τ e ts => .tuple τ e (ts.attach.map fun ⟨t, _⟩ => typedToSimple t) - | .array τ e ts => .array τ e (ts.attach.map fun ⟨t, _⟩ => typedToSimple t) - | .ret τ e sub => .ret τ e (typedToSimple sub) - | .let τ e _pat v b => - -- Post-simplify, non-trivial `let`s were rewritten. Treat any survivor as - -- a wildcard let. - .letWild τ e (typedToSimple v) (typedToSimple b) - | .match τ e _scrut _bs => - -- Post-simplify, matches are re-compiled by `runMatchCompiler`. A raw - -- `match` here means it didn't pass through `simplifyTerm`; default to unit. - .unit τ e - | .app τ e g tArgs args u => - .app τ e g tArgs (args.attach.map fun ⟨t, _⟩ => typedToSimple t) u - | .add τ e a b => .add τ e (typedToSimple a) (typedToSimple b) - | .sub τ e a b => .sub τ e (typedToSimple a) (typedToSimple b) - | .mul τ e a b => .mul τ e (typedToSimple a) (typedToSimple b) - | .eqZero τ e a => .eqZero τ e (typedToSimple a) - | .proj τ e a n => .proj τ e (typedToSimple a) n - | .get τ e a n => .get τ e (typedToSimple a) n - | .slice τ e a i j => .slice τ e (typedToSimple a) i j - | .set τ e a n v => .set τ e (typedToSimple a) n (typedToSimple v) - | .store τ e a => .store τ e (typedToSimple a) - | .load τ e a => .load τ e (typedToSimple a) - | .ptrVal τ e a => .ptrVal τ e (typedToSimple a) - | .assertEq τ e a b msg r => - .assertEq τ e (typedToSimple a) (typedToSimple b) msg (typedToSimple r) - | .ioGetInfo τ e c k => .ioGetInfo τ e (typedToSimple c) (typedToSimple k) - | .ioSetInfo τ e c k i l r => - .ioSetInfo τ e (typedToSimple c) (typedToSimple k) (typedToSimple i) - (typedToSimple l) (typedToSimple r) - | .ioRead τ e c i n => .ioRead τ e (typedToSimple c) (typedToSimple i) n - | .ioWrite τ e c d r => .ioWrite τ e (typedToSimple c) (typedToSimple d) (typedToSimple r) - | .u8BitDecomposition τ e a => .u8BitDecomposition τ e (typedToSimple a) - | .u8ShiftLeft τ e a => .u8ShiftLeft τ e (typedToSimple a) - | .u8ShiftRight τ e a => .u8ShiftRight τ e (typedToSimple a) - | .u8Xor τ e a b => .u8Xor τ e (typedToSimple a) (typedToSimple b) - | .u8Add τ e a b => .u8Add τ e (typedToSimple a) (typedToSimple b) - | .u8Mul τ e a b => .u8Mul τ e (typedToSimple a) (typedToSimple b) - | .u8XorSplit7 τ e a b => .u8XorSplit7 τ e (typedToSimple a) (typedToSimple b) - | .u8XorSplit4 τ e a b => .u8XorSplit4 τ e (typedToSimple a) (typedToSimple b) - | .u8Sub τ e a b => .u8Sub τ e (typedToSimple a) (typedToSimple b) - | .u8And τ e a b => .u8And τ e (typedToSimple a) (typedToSimple b) - | .u8Or τ e a b => .u8Or τ e (typedToSimple a) (typedToSimple b) - | .u8LessThan τ e a b => .u8LessThan τ e (typedToSimple a) (typedToSimple b) - | .u32LessThan τ e a b => .u32LessThan τ e (typedToSimple a) (typedToSimple b) - | .unconstrainedU32Add τ e a b => .unconstrainedU32Add τ e (typedToSimple a) (typedToSimple b) - | .unconstrainedU32Add3 τ e a b c => .unconstrainedU32Add3 τ e (typedToSimple a) (typedToSimple b) (typedToSimple c) - | .u32ToField τ e a => .u32ToField τ e (typedToSimple a) - | .u8RangeCheck τ e a b => .u8RangeCheck τ e (typedToSimple a) (typedToSimple b) - | .unconstrainedBigUintDivMod τ e a b => .unconstrainedBigUintDivMod τ e (typedToSimple a) (typedToSimple b) - | .unconstrainedGToBytes τ e a => .unconstrainedGToBytes τ e (typedToSimple a) - | .unconstrainedGInverse τ e a => .unconstrainedGInverse τ e (typedToSimple a) - | .toField τ e a => .toField τ e (typedToSimple a) - | .u8FromFieldUnsafe τ e a => .u8FromFieldUnsafe τ e (typedToSimple a) - | .debug τ e l t r => - let t' := match t with | none => none | some sub => some (typedToSimple sub) - .debug τ e l t' (typedToSimple r) -termination_by t => sizeOf t -decreasing_by all_goals first | decreasing_tactic | grind - -def decisionToSimple (retTyp : Typ) : Decision → Option Simple.Term - | .failure => none - | .success ⟨renames, value⟩ => - let base := typedToSimple value - some (renames.foldr (init := base) fun (x, term) acc => - let rhs := typedToSimple term - Simple.Term.letVar acc.typ acc.escapes x rhs acc) - | .switch ptr _ [(.pointer val innerTyp, body)] _ => - match decisionToSimple retTyp body with - | none => none - | some body' => - some (Simple.Term.letLoad body'.typ body'.escapes val innerTyp ptr body') - | .switch var _ branches dflt => do - -- `.failure → none` is exactly what `decisionToSimple retTyp .failure` - -- returns, so we can skip the outer case-split on `dflt`. - let defaultOpt : Option Simple.Term := decisionToSimple retTyp dflt - let cases ← branches.attach.foldlM (init := #[]) fun acc ⟨(spat, tree), _⟩ => do - match sPatternToSimple spat with - | none => none - | some sPat => - let body ← decisionToSimple retTyp tree - pure (acc.push (sPat, body)) - some (Simple.Term.match retTyp false var cases defaultOpt) - | .letLoad dst dstTyp src body => - match decisionToSimple retTyp body with - | none => none - | some body' => - some (Simple.Term.letLoad body'.typ body'.escapes dst dstTyp src body') - | .let var term body => - match decisionToSimple retTyp body with - | none => none - | some body' => - let rhs := typedToSimple term - some (Simple.Term.letVar body'.typ body'.escapes var rhs body') -termination_by d => sizeOf d -decreasing_by - all_goals first - | decreasing_tactic - | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - | grind - -/-! ## Decision → Typed.Term - -`decisionToTyped` is the direct analogue of `decisionToSimple` that stays in -`Typed.Term` form so the downstream `Concretize` pass can consume it. Every -output `.match` has a single-level pattern shape (`.field`, `.ref _ vars`, -`.tuple vars`, `.array vars`, or top-level `.var` / `.wildcard`), so the -simplified matches land in the subset that `Concretize.termToConcrete` -already handles natively. - -`.pointer` in the source is modelled here as `.let x = load ptr in ...` -plus a matching `.switch` on the loaded value. -/ - -/-- Convert a decision-tree `SPattern` back to a `Source.Pattern`, where -each sub-`Local` becomes a top-level `.var` binding. Returns `none` for -`.pointer` (handled one level up by emitting a `let load` before the match). -/ -def sPatternToTypedPattern : SPattern → Option Pattern - | .field g => some (.field g) - | .ref g vars => some (.ref g (vars.toList.map (.var))) - | .tuple vars => some (.tuple (vars.map (.var))) - | .array vars => some (.array (vars.map (.var))) - | .pointer _ _ => none - -/-- Convert a decision tree to a `Typed.Term`. `retTyp` is the match's return -type; `scrutTyp` is the *outermost* scrutinee's type — used for the `.var` -node we emit at the top-level `.match` so downstream passes see the correct -type. Sub-`.switch` nodes (introduced by nested patterns) inherit their -scrutinee type from the parent's pattern arg, but those types aren't -needed by the `Concretize`/`Lower` path (which only inspects the top -scrut), so we re-use `scrutTyp` recursively as a placeholder. -/ -def decisionToTyped (retTyp : Typ) (scrutTyp : Typ) : Decision → Option Term - | .failure => none - | .success ⟨renames, value⟩ => - -- Apply renames as a chain of `.let`s with simple `.var` patterns. - some (renames.foldr (init := value) fun (x, term) acc => - Term.let acc.typ acc.escapes (.var x) term acc) - | .switch ptr _ [(.pointer val innerTyp, body)] _ => - -- Single pointer-pattern case: `let val = load ptr in body`. - match decisionToTyped retTyp innerTyp body with - | none => none - | some body' => - let loadTerm : Term := .load innerTyp false (.var (.pointer innerTyp) false ptr) - some (.let body'.typ body'.escapes (.var val) loadTerm body') - | .switch var switchTyp branches dflt => do - let defaultOpt : Option Term := decisionToTyped retTyp switchTyp dflt - let cases ← branches.attach.foldlM (init := #[]) fun acc ⟨(spat, tree), _⟩ => do - match sPatternToTypedPattern spat with - | none => none - | some pat => - let body ← decisionToTyped retTyp switchTyp tree - pure (acc.push (pat, body)) - -- `Typed.Term.match` expects `List (Pattern × Term)`; add a wildcard - -- default case at the end so coverage is explicit. - let casesList : List (Pattern × Term) := cases.toList - let casesList := match defaultOpt with - | some d => casesList ++ [(.wildcard, d)] - | none => casesList - some (.match retTyp false (.var switchTyp false var) casesList) - | .letLoad dst dstTyp src body => - match decisionToTyped retTyp scrutTyp body with - | none => none - | some body' => - let loadTerm : Term := .load dstTyp false (.var (.pointer dstTyp) false src) - some (.let body'.typ body'.escapes (.var dst) loadTerm body') - | .let var term body => - match decisionToTyped retTyp scrutTyp body with - | none => none - | some body' => - some (.let body'.typ body'.escapes (.var var) term body') -termination_by d => sizeOf d -decreasing_by - all_goals first - | decreasing_tactic - | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - | grind - -end MatchCompiler - -end Aiur - -end diff --git a/Ix/Aiur/Compiler/Simple.lean b/Ix/Aiur/Compiler/Simple.lean deleted file mode 100644 index 09d9c910a..000000000 --- a/Ix/Aiur/Compiler/Simple.lean +++ /dev/null @@ -1,204 +0,0 @@ -module -public import Ix.Aiur.Compiler.Match - -/-! -`simplifyTerm`: `Typed.Term` → `Simple.Term`. - -Consumes `Typed.Term` directly (no more double `checkFunction`). Walks the -typed tree, invoking the decision-tree match compiler on every `match`, and -transforms `let` nodes into either `.letVar`, `.letWild`, or a rebuilt `match` -(when the pattern is non-trivial). - -Non-exhaustive matches are accepted at compile time. -A `.failure` leaf in the decision tree is materialized as a match case with -no default, which becomes `Bytecode.Ctrl.match … none`. Evaluators surface -the unreached case at runtime via their own `.nonExhaustiveMatch` error. --/ - -public section -@[expose] section - -namespace Aiur - -open Typed - -/-- Temporary variable used when hoisting a complex-pattern `let` into a `match`. -Only valid when it doesn't shadow any other binding. Public so proofs in other -modules can cite the definition (e.g., via unfolding). -/ -abbrev tmpVar : Local := .idx 0 - -/-- Build `let pat = v in b`, but first float any leading `let`s out of `v`: -`let pat = (let w = e in rest) in b` ⤳ `let w = e in let pat = rest in b`. - -The match compiler hoists a non-variable `match` scrutinee into a `let` -(`MatchCompiler.compile`), so `let x = match foo(bar) {..}` simplifies to -`let x = (let w = foo(bar) in match w {..})`. That buries the `match` one -`let` deep, where `Lower`'s non-tail-match detector (which only fires when a -`match` is the *immediate* `letVar`/`letWild` RHS) can't see it. Floating the -hoisted `let`s outward restores the invariant: the `match` becomes the direct -RHS again. The source-normalization entry point freshens all source binders -before this pass, and the match compiler introduces its own locals. Callers -that invoke this helper directly must likewise ensure the floated binders do -not occur free in `b`; it is not a capture-avoiding transformation on arbitrary -unfreshened `Typed.Term`s. -/ -def mkLetFloating (τ : Typ) (e : Bool) (pat : Pattern) (v b : Term) : Term := - match v with - | .let τ' e' pat' v' rest => .let τ' e' pat' v' (mkLetFloating τ e pat rest b) - | _ => .let τ e pat v b -termination_by sizeOf v -decreasing_by decreasing_tactic - -/-- `simplifyTypedTerm` walks a typed term, producing a term of the same shape -whose `match`es have been pre-compiled down to the decision-tree form, and whose -`let`s bind only simple locals or wildcards. It operates in the `CheckError` -monad so it can surface non-exhaustiveness. - -The traversal stays in `Typed.Term`; the final `Typed → Simple` mapping is done -in `MatchCompiler.typedToSimple` after this pass. -/ -def simplifyTypedTerm (decls : Source.Decls) : Term → Except CheckError Term - | .let τ e (.var x) v b => do - let v' ← simplifyTypedTerm decls v - let b' ← simplifyTypedTerm decls b - pure (mkLetFloating τ e (.var x) v' b') - | .let τ e .wildcard v b => do - let v' ← simplifyTypedTerm decls v - let b' ← simplifyTypedTerm decls b - pure (mkLetFloating τ e .wildcard v' b') - | .let τ e pat v b => do - let v' ← simplifyTypedTerm decls v - let b' ← simplifyTypedTerm decls b - let tmp : Term := .var v'.typ false tmpVar - let (tree, _diag) := MatchCompiler.runMatchCompiler decls tmp [(pat, b')] - let body : Term := - match MatchCompiler.decisionToTyped b'.typ tmp.typ tree with - | some rewrite => rewrite - | none => .match b'.typ b'.escapes tmp [(pat, b')] - pure (mkLetFloating τ e (.var tmpVar) v' body) - | .match τ e scrut branches => do - let scrut' ← simplifyTypedTerm decls scrut - let branches' ← branches.attach.mapM fun pb => - (simplifyTypedTerm decls pb.1.2).map (Prod.mk pb.1.1) - let (tree, _diag) := MatchCompiler.runMatchCompiler decls scrut' branches' - match MatchCompiler.decisionToTyped τ scrut'.typ tree with - | some rewrite => pure rewrite - | none => - match scrut' with - | .var .. => pure (.match τ e scrut' branches') - | _ => - let tmp : Term := .var scrut'.typ false tmpVar - let inner : Term := .match τ e tmp branches' - pure (.let τ e (.var tmpVar) scrut' inner) - | .ret τ e r => do - let r' ← simplifyTypedTerm decls r - pure (.ret τ e r') - | .app τ e g tArgs args u => do - let args' ← args.attach.mapM fun ⟨a, _⟩ => simplifyTypedTerm decls a - pure (.app τ e g tArgs args' u) - | .tuple τ e ts => do - let ts' ← ts.attach.mapM fun ⟨t, _⟩ => simplifyTypedTerm decls t - pure (.tuple τ e ts') - | .array τ e ts => do - let ts' ← ts.attach.mapM fun ⟨t, _⟩ => simplifyTypedTerm decls t - pure (.array τ e ts') - | .debug τ e l t r => do - let t' ← match t with - | none => pure none - | some sub => do pure (some (← simplifyTypedTerm decls sub)) - let r' ← simplifyTypedTerm decls r - pure (.debug τ e l t' r') - | .assertEq τ e a b msg r => do - let a' ← simplifyTypedTerm decls a - let b' ← simplifyTypedTerm decls b - let r' ← simplifyTypedTerm decls r - pure (.assertEq τ e a' b' msg r') - | .ioSetInfo τ e c k i l r => do - let c' ← simplifyTypedTerm decls c - let k' ← simplifyTypedTerm decls k - let i' ← simplifyTypedTerm decls i - let l' ← simplifyTypedTerm decls l - let r' ← simplifyTypedTerm decls r - pure (.ioSetInfo τ e c' k' i' l' r') - | .ioWrite τ e c d r => do - let c' ← simplifyTypedTerm decls c - let d' ← simplifyTypedTerm decls d - let r' ← simplifyTypedTerm decls r - pure (.ioWrite τ e c' d' r') - | .u8LessThan τ e a b => do - let a' ← simplifyTypedTerm decls a - let b' ← simplifyTypedTerm decls b - pure (.u8LessThan τ e a' b') - | .u8XorSplit7 τ e a b => do pure (.u8XorSplit7 τ e (← simplifyTypedTerm decls a) (← simplifyTypedTerm decls b)) - | .u8XorSplit4 τ e a b => do pure (.u8XorSplit4 τ e (← simplifyTypedTerm decls a) (← simplifyTypedTerm decls b)) - | .u32LessThan τ e a b => do - let a' ← simplifyTypedTerm decls a - let b' ← simplifyTypedTerm decls b - pure (.u32LessThan τ e a' b') - | .u8RangeCheck τ e a b => do - let a' ← simplifyTypedTerm decls a - let b' ← simplifyTypedTerm decls b - pure (.u8RangeCheck τ e a' b') - | .unconstrainedBigUintDivMod τ e a b => do - let a' ← simplifyTypedTerm decls a - let b' ← simplifyTypedTerm decls b - pure (.unconstrainedBigUintDivMod τ e a' b') - | .unconstrainedGToBytes τ e a => do - let a' ← simplifyTypedTerm decls a - pure (.unconstrainedGToBytes τ e a') - | .unconstrainedU32Add τ e a b => do - pure (.unconstrainedU32Add τ e (← simplifyTypedTerm decls a) (← simplifyTypedTerm decls b)) - | .unconstrainedU32Add3 τ e a b c => do - pure (.unconstrainedU32Add3 τ e (← simplifyTypedTerm decls a) (← simplifyTypedTerm decls b) - (← simplifyTypedTerm decls c)) - | .u32ToField τ e a => do - pure (.u32ToField τ e (← simplifyTypedTerm decls a)) - | .unconstrainedGInverse τ e a => do - let a' ← simplifyTypedTerm decls a - pure (.unconstrainedGInverse τ e a') - | .toField τ e a => do - let a' ← simplifyTypedTerm decls a - pure (.toField τ e a') - | .u8FromFieldUnsafe τ e a => do - let a' ← simplifyTypedTerm decls a - pure (.u8FromFieldUnsafe τ e a') - | t => pure t -termination_by t => sizeOf t -decreasing_by - all_goals first - | decreasing_tactic - | (have : sizeOf (_, _) < sizeOf _ := List.sizeOf_lt_of_mem ‹_ ∈ _› - grind) - | (have hmem := Subtype.property ‹_› - have := List.sizeOf_lt_of_mem hmem - grind) - -/-- Run `simplifyTypedTerm` on every function in a decls map. -/ -def simplifyDecls (decls : Source.Decls) (typedDecls : Typed.Decls) : - Except CheckError Typed.Decls := do - typedDecls.foldlM (init := default) fun acc (name, d) => match d with - | .function f => do - let body' ← simplifyTypedTerm decls f.body - pure (acc.insert name (.function { f with body := body' })) - | .dataType dt => pure (acc.insert name (.dataType dt)) - | .constructor dt c => pure (acc.insert name (.constructor dt c)) - -/-- Typecheck and simplify an already-normalized `Source.Toplevel`: -`mkDecls`, `wellFormedDecls`, typecheck, simplify. The public `compile` pipeline -runs `inlineCalls` first, including caller/callee hygiene. Direct callers of -this stage must likewise eliminate inline calls and ensure fresh source -binders before simplification widens any let scopes. -/ -def Source.Toplevel.checkAndSimplify (toplevel : Source.Toplevel) : - Except CheckError Typed.Decls := do - let decls ← toplevel.mkDecls - wellFormedDecls decls - let typedDecls ← decls.foldlM (init := default) fun acc (name, decl) => match decl with - | .constructor d c => pure $ acc.insert name (.constructor d c : Typed.Declaration) - | .dataType d => pure $ acc.insert name (.dataType d : Typed.Declaration) - | .function f => do - let f ← ((checkFunction f) (getFunctionContext f decls)).run' {} - pure $ acc.insert name (.function f : Typed.Declaration) - simplifyDecls decls typedDecls - -end Aiur - -end -- @[expose] section -end diff --git a/Ix/Aiur/Goldilocks.lean b/Ix/Aiur/Goldilocks.lean index b9745f737..8b468e7a0 100644 --- a/Ix/Aiur/Goldilocks.lean +++ b/Ix/Aiur/Goldilocks.lean @@ -51,10 +51,6 @@ def G.isU8 (x : G) : Prop := x.n < 256 /-- Range predicate for u32 operations. -/ def G.isU32 (x : G) : Prop := x.n < 2 ^ 32 --- Semantic models for unsigned integer operations. --- These mirror the Aiur circuit gadgets, which force range constraints --- on their inputs and compute the corresponding bitwise/arithmetic result. - def G.u8And (a b : G) : G := G.ofNat (a.n &&& b.n) def G.u8Or (a b : G) : G := G.ofNat (a.n ||| b.n) def G.u8Xor (a b : G) : G := G.ofNat (a.n ^^^ b.n) @@ -81,16 +77,12 @@ def G.u8BitDecomposition (a : G) : Fin 8 → G := def G.u32LessThan (a b : G) : G := if a.n < b.n then 1 else 0 -/-- The 8 little-endian bytes of the canonical `u64` value. Semantic model of -the `unconstrained_g_to_bytes` hint. -/ +/-- The 8 little-endian bytes of the canonical `u64` value. -/ def G.toLeBytes (a : G) : Fin 8 → G := fun i => G.ofUInt8 (a.val >>> (8 * i.val).toUInt64).toUInt8 /-- Canonical little-endian u64 limbs of a natural number, each limb as its -8 LE bytes (as field elements). Semantic model of the limb lists the -`unconstrained_big_uint_div_mod` runtime builds (`biguint_to_klimbs_u64` in -`crates/aiur/src/execute.rs`): zero is the empty list, no trailing zero -limbs. -/ +8 LE bytes (as field elements). -/ def natToLimbsLE (n : Nat) : List (Array G) := if h : n = 0 then [] else @@ -101,8 +93,7 @@ termination_by n decreasing_by exact Nat.div_lt_self (Nat.pos_of_ne_zero h) (by decide : (1 : Nat) < 2^64) -/-- Value of one 8-LE-byte limb. Inverse direction of `natToLimbsLE`'s -per-limb encoding; bytes are assumed already validated `< 256`. -/ +/-- Value of one 8-LE-byte limb. -/ def limbBytesVal (bytes : Array G) : Nat := (bytes.toList.zipIdx.map fun (b, i) => b.val.toNat <<< (8 * i)).foldl (· + ·) 0 @@ -110,8 +101,7 @@ def limbBytesVal (bytes : Array G) : Nat := def limbsVal (limbs : List (Array G)) : Nat := limbs.foldr (fun limb acc => limbBytesVal limb + acc <<< 64) 0 -/-- Exponentiation by squaring. Fuel-structural (64 bits covers any `n < 2⁶⁴` -exponent, in particular `p − 2`). -/ +/-- Exponentiation by squaring. -/ def G.pow (x : G) (n : Nat) : G := go n 64 where go (n fuel : Nat) : G := match fuel with | 0 => 1 @@ -122,8 +112,7 @@ def G.pow (x : G) (n : Nat) : G := go n 64 where let sq := h * h if n % 2 == 0 then sq else sq * x -/-- Fermat inverse `x^(p−2)`, with `0 ↦ 0`. Semantic model of the -`unconstrained_g_inverse` hint. -/ +/-- Fermat inverse `x^(p−2)`, with `0 ↦ 0`. -/ def G.inverse (x : G) : G := G.pow x (gSize.toNat - 2) theorem G.one_ne_zero : ¬(1 : G) = (0 : G) := by decide diff --git a/Ix/Aiur/Interpret.lean b/Ix/Aiur/Interpret.lean deleted file mode 100644 index efac94a80..000000000 --- a/Ix/Aiur/Interpret.lean +++ /dev/null @@ -1,592 +0,0 @@ -module -public import Ix.Aiur.Stages.Source -public import Ix.Aiur.Semantics.Flatten -public import Ix.Aiur.Protocol - -/-! -Debug interpreter — fast interactive execution with `callCache` and call-stack -traces. Still `partial` by design: loops on non-terminating programs. - -The proof-bearing reference semantics live under `Ix/Aiur/Semantics/`: -`SourceEval.lean`, `TypedEval.lean`, `ConcreteEval.lean`, `BytecodeEval.lean`. --/ - -public section - -namespace Aiur - -open Source - -abbrev Bindings := List (Local × Value) -abbrev Store := IndexMap (Array Value) Unit - --- --------------------------------------------------------------------------- --- Pretty printing --- --------------------------------------------------------------------------- - -private def hexDigit (d : Nat) : Char := - if d < 10 then Char.ofNat ('0'.toNat + d) - else Char.ofNat ('a'.toNat + d - 10) - -private partial def natToHexGo (n : Nat) (acc : String) : String := - if n == 0 then acc - else natToHexGo (n / 16) (String.singleton (hexDigit (n % 16)) ++ acc) - -private def natToHex (n : Nat) : String := - if n == 0 then "0" else natToHexGo n "" - -partial def Value.pp : Value → String - | .unit => "()" - | .field g => toString g.val.toNat - | .tuple vs => "(" ++ String.intercalate ", " (vs.toList.map Value.pp) ++ ")" - | .array vs => "[" ++ String.intercalate ", " (vs.toList.map Value.pp) ++ "]" - | .ctor g args => - let name := g.toName.toString - if args.isEmpty then name - else name ++ "(" ++ String.intercalate ", " (args.toList.map Value.pp) ++ ")" - | .fn g => "fn(" ++ g.toName.toString ++ ")" - | .pointer _ n => "&0x" ++ natToHex n - -instance : ToString Value := ⟨Value.pp⟩ - -/-- Pretty-print a `Value` while auto-dereferencing pointers up to `depth` -levels. Used by the `dbg!` interpreter helper so users see structured -content like `App(Const(3, []), BVar(0))` instead of opaque `&0x123`. -/ -partial def Value.ppDeref (store : Store) (depth : Nat) : Value → String - | .unit => "()" - | .field g => toString g.val.toNat - | .tuple vs => "(" ++ String.intercalate ", " (vs.toList.map (Value.ppDeref store depth)) ++ ")" - | .array vs => "[" ++ String.intercalate ", " (vs.toList.map (Value.ppDeref store depth)) ++ "]" - | .ctor g args => - let name := g.toName.toString - if args.isEmpty then name - else name ++ "(" ++ String.intercalate ", " (args.toList.map (Value.ppDeref store depth)) ++ ")" - | .fn g => "fn(" ++ g.toName.toString ++ ")" - | .pointer _ n => - if depth == 0 then "..." - else - match store.getByIdx n with - | some (vs, _) => - -- Stored value is `Array Value`; for tagged enums it's - -- typically `[ctor]` or `[tag, fields...]`. Recurse on each. - match vs.toList with - | [v] => Value.ppDeref store (depth - 1) v - | _ => "[" ++ String.intercalate ", " (vs.toList.map (Value.ppDeref store (depth - 1))) ++ "]" - | none => "&0x" ++ natToHex n ++ "(unbound)" - --- --------------------------------------------------------------------------- --- Pattern matching --- --------------------------------------------------------------------------- - -mutual - -private def matchPattern (store : Store) : - Pattern → Value → Option Bindings - | .wildcard, _ => some [] - | .var l, v => some [(l, v)] - | .field g, .field g' => if g == g' then some [] else none - | .tuple pats, .tuple vs => matchPatsArr store pats vs - | .array pats, .array vs => matchPatsArr store pats vs - | .ref g pats, .ctor g' vs => - if g != g' then none else matchPatsList store pats vs.toList - | .or p1 p2, v => - matchPattern store p1 v <|> matchPattern store p2 v - | .pointer p, .pointer _ n => - match store.getByIdx n with - | some (vs, _) => vs[0]?.bind (matchPattern store p ·) - | none => none - | _, _ => none - -private def matchPatsList (store : Store) : - List Pattern → List Value → Option Bindings - | [], [] => some [] - | p :: ps, v :: vs => do - let b1 ← matchPattern store p v - let b2 ← matchPatsList store ps vs - return b1 ++ b2 - | _, _ => none - -private def matchPatsArr (store : Store) - (pats : Array Pattern) (vs : Array Value) : Option Bindings := - matchPatsList store pats.toList vs.toList - -end - --- --------------------------------------------------------------------------- --- Interrupt --- --------------------------------------------------------------------------- - -inductive Interrupt where - | error : String → List (Global × List Value) → Interrupt - | ret : Value → Interrupt - -instance : ToString Interrupt where - toString - | .ret v => s!"unexpected return: {v}" - | .error msg [] => msg - | .error msg stack => - let frames := stack.map fun (g, args) => - let argStr := String.intercalate ", " (args.map toString) - s!" in {g}({argStr})" - msg ++ "\nCall stack:\n" ++ String.intercalate "\n" frames - -/-- Pretty-print an `Interrupt`, auto-dereferencing pointer values up to -`depth` pointer-follows, and showing at most `stackLimit` call-stack frames -(starting from the innermost). -/ -def Interrupt.ppDeref (store : Store) (depth : Nat) (stackLimit : Nat) : - Interrupt → String - | .ret v => s!"unexpected return: {Value.ppDeref store depth v}" - | .error msg [] => msg - | .error msg stack => - let total := stack.length - let shown := stack.take stackLimit - let rule := String.ofList (List.replicate 80 '─') - let frames := shown.zipIdx.map fun ((g, args), i) => - let argStr := String.intercalate ", " (args.map (Value.ppDeref store depth)) - let header := s!"─── #{i} " ++ g.toName.toString ++ " " - let pad := String.ofList (List.replicate (max 1 (80 - header.length)) '─') - header ++ pad ++ s!"\n {g}({argStr})" - let trailer := if total > stackLimit - then s!"\n... ({total - stackLimit} more frame(s) elided)" - else "" - msg ++ s!"\nCall stack ({total} frames, #0 = innermost):\n" - ++ String.intercalate "\n" frames - ++ trailer - ++ "\n" ++ rule - --- --------------------------------------------------------------------------- --- Interpreter monad --- --------------------------------------------------------------------------- - -structure InterpState where - store : Store := default - ioBuffer : IOBuffer - callCache : Std.HashMap (Global × List Value) Value := {} - -abbrev InterpM := ExceptT Interrupt (StateM InterpState) - -private def throwErr (msg : String) : InterpM α := - throw (.error msg []) - -private def getStore : InterpM Store := return (← get).store -private def getIOBuffer : InterpM IOBuffer := return (← get).ioBuffer -private def modifyIOBuffer (f : IOBuffer → IOBuffer) : InterpM Unit := - modify fun s => { s with ioBuffer := f s.ioBuffer } - -private def expectField : Value → InterpM G - | .field g => pure g - | v => throwErr s!"expected field value, got {v}" - -private def expectFieldArray : Value → InterpM (Array G) - | .array vs => vs.mapM expectField - | v => throwErr s!"expected array of field values, got {v}" - -private def lookupVar (bindings : Bindings) (l : Local) : InterpM Value := - match bindings.find? (·.1 == l) with - | some (_, v) => pure v - | none => throwErr s!"Unbound variable: {repr l}" - -private def tryLocalLookup (g : Global) (bindings : Bindings) : Option Value := - match g.toName with - | .str .anonymous name => bindings.find? (·.1 == Local.str name) |>.map (·.2) - | _ => none - --- --------------------------------------------------------------------------- --- Main interpreter --- --------------------------------------------------------------------------- - -private def callSite (g : Global) (args : List Value) (m : InterpM Value) : InterpM Value := - tryCatch m fun i => match i with - | .ret v => pure v - | .error msg stack => throw (.error msg ((g, args) :: stack)) - -/-! ### `List` limb chains (`unconstrainedBigUintDivMod`) - -Value-level mirror of `read_klimbs_u64` / `build_klimbs_u64` in -`crates/aiur/src/execute.rs`; see `Ix/Aiur/Semantics/SourceEval.lean` for -the reference-evaluator twin. Constructor 0 = Cons(limb, rest), -constructor 1 = Nil; limb bytes little-endian, limbs head-first. -/ - -/-- Store a value content-deduped, returning its pointer (the `.store` -semantics, callable from the divmod chain builder). -/ -private def storeValueI (v : Value) : InterpM Value := do - let store ← getStore - if let some idx := store.getIdxOf #[v] then - return .pointer 0 idx - let idx := store.size - modify fun s => { s with store := s.store.insert #[v] () } - return .pointer 0 idx - -/-- Walk a limb-chain pointer, returning the node datatype and the limbs -head-first. `steps` bounds the walk so a malformed cycle terminates. -/ -private def readLimbChainI (decls : Decls) : - Nat → Value → InterpM (DataType × List (Array G)) - | 0, _ => throwErr "unconstrainedBigUintDivMod: cyclic limb list" - | steps+1, ptrVal => do - match ptrVal with - | .pointer _ n => - let store ← getStore - match store.getByIdx n with - | none => throwErr s!"unconstrainedBigUintDivMod: invalid pointer {n}" - | some (vs, _) => - match (vs[0]? : Option Value) with - | some (.ctor g args) => - match decls.getByKey g with - | some (.constructor dt ctor) => - let tag := dt.constructors.findIdx? (· == ctor) |>.getD 0 - if tag == 1 then pure (dt, []) - else if tag == 0 then - match args with - | #[.array byteVals, rest] => - let bytes ← byteVals.mapM fun bv => - match bv with - | .field b => - if b.val < 256 then pure b - else throwErr - "unconstrainedBigUintDivMod: limb byte out of range" - | _ => throwErr - "unconstrainedBigUintDivMod: limb byte not a field" - if bytes.size == 8 then do - let (_, restLimbs) ← readLimbChainI decls steps rest - pure (dt, bytes :: restLimbs) - else throwErr "unconstrainedBigUintDivMod: limb is not [U8; 8]" - | _ => throwErr "unconstrainedBigUintDivMod: malformed Cons node" - else - throwErr "unconstrainedBigUintDivMod: unexpected constructor tag" - | _ => throwErr s!"unconstrainedBigUintDivMod: unbound ctor {g}" - | _ => throwErr "unconstrainedBigUintDivMod: node is not a constructor" - | _ => throwErr "unconstrainedBigUintDivMod: input is not a pointer" - -/-- Build a limb chain from head-first `limbs` (Nil first, limbs in -reverse — same allocation order as the Rust builder). -/ -private def buildLimbChainI (consG nilG : Global) : - List (Array G) → InterpM Value - | [] => storeValueI (.ctor nilG #[]) - | limb :: rest => do - let restPtr ← buildLimbChainI consG nilG rest - storeValueI (.ctor consG #[.array (limb.map .field), restPtr]) - -mutual - -private partial def applyGlobal (decls : Decls) (g : Global) (args : List Value) : - InterpM Value := - callSite g args do - match decls.getByKey g with - | some (.function f) => - if args.length != f.inputs.length then - throwErr s!"arity mismatch calling '{f.name}': \ - expected {f.inputs.length}, got {args.length}" - if let some v := (← get).callCache[(g, args)]? then - return v - let v ← interp decls (f.inputs.map (·.1) |>.zip args) f.body - modify fun s => { s with callCache := s.callCache.insert (g, args) v } - return v - | some (.constructor _ _) => return .ctor g args.toArray - | none => throwErr s!"apply: '{g}' is not known" - | some (.dataType _) => throwErr s!"apply: '{g}' is a type, not callable" - -private partial def applyLocal (decls : Decls) (v : Value) (args : List Value) : - InterpM Value := - match v with - | .fn g => applyGlobal decls g args - | _ => throwErr s!"apply: expected a function pointer, got {v}" - -partial def interp (decls : Decls) (bindings : Bindings) : Term → InterpM Value - | .unit => return .unit - | .var l => lookupVar bindings l - | .ref g => - match decls.getByKey g with - | some (.function _) => return .fn g - | some (.constructor _ ctor) => - if ctor.argTypes.isEmpty then return .ctor g #[] - else throwErr s!"ref: constructor '{g}' requires {ctor.argTypes.length} argument(s)" - | some (.dataType _) => throwErr s!"ref: '{g}' is a type, not a value" - | none => throwErr s!"ref: '{g}' is not known" - | .field g => return .field g - | .tuple ts => return .tuple (← ts.mapM (interp decls bindings)) - | .array ts => return .array (← ts.mapM (interp decls bindings)) - | .ret t => do let v ← interp decls bindings t; throw (.ret v) - | .ann _ t => interp decls bindings t - | .let p t1 t2 => do - let v ← interp decls bindings t1 - let store ← getStore - match matchPattern store p v with - | some bs => interp decls (bs ++ bindings) t2 - | none => throwErr "let: pattern match failed" - | .match t cases => do - let v ← interp decls bindings t - let store ← getStore - match cases.findSome? fun (p, body) => - matchPattern store p v |>.map (·, body) with - | some (bs, body) => interp decls (bs ++ bindings) body - | none => throwErr "match: non-exhaustive patterns" - | .app g args _ => do - let vs ← args.mapM (interp decls bindings) - match tryLocalLookup g bindings with - | some v => applyLocal decls v vs - | none => applyGlobal decls g vs - | .add t1 t2 => do - match (← interp decls bindings t1), (← interp decls bindings t2) with - | .field a, .field b => return .field (a + b) - | _, _ => throwErr "add: expected field values" - | .sub t1 t2 => do - match (← interp decls bindings t1), (← interp decls bindings t2) with - | .field a, .field b => return .field (a - b) - | _, _ => throwErr "sub: expected field values" - | .mul t1 t2 => do - match (← interp decls bindings t1), (← interp decls bindings t2) with - | .field a, .field b => return .field (a * b) - | _, _ => throwErr "mul: expected field values" - | .eqZero t => do - match ← interp decls bindings t with - | .field g => return .field (if g.val == 0 then 1 else 0) - | _ => throwErr "eqZero: expected field value" - | .proj t n => do - match ← interp decls bindings t with - | .tuple vs => - if h : n < vs.size then return vs[n] - else throwErr s!"proj: index {n} out of bounds (size {vs.size})" - | _ => throwErr "proj: expected tuple" - | .get t n => do - match ← interp decls bindings t with - | .array vs => - if h : n < vs.size then return vs[n] - else throwErr s!"get: index {n} out of bounds (size {vs.size})" - | _ => throwErr "get: expected array" - | .slice t i j => do - match ← interp decls bindings t with - | .array vs => return .array (vs.extract i j) - | _ => throwErr "slice: expected array" - | .set t n vTerm => do - let val ← interp decls bindings vTerm - match ← interp decls bindings t with - | .array vs => - if n < vs.size then return .array (vs.set! n val) - else throwErr s!"set: index {n} out of bounds (size {vs.size})" - | _ => throwErr "set: expected array" - | .store t => do - let v ← interp decls bindings t - let store ← getStore - if let some idx := store.getIdxOf #[v] then - return .pointer 0 idx - let idx := store.size - modify fun s => { s with store := s.store.insert #[v] () } - return .pointer 0 idx - | .load t => do - match ← interp decls bindings t with - | .pointer _ n => - let store ← getStore - match store.getByIdx n with - | some (vs, _) => return vs[0]! - | none => throwErr s!"load: invalid pointer {n}" - | _ => throwErr "load: expected pointer" - | .ptrVal t => do - match ← interp decls bindings t with - | .pointer _ n => return .field (G.ofNat n) - | _ => throwErr "ptrVal: expected pointer" - | .assertEq t1 t2 msg ret => do - let v1 ← interp decls bindings t1 - let v2 ← interp decls bindings t2 - if v1 != v2 then - match msg with - | some m => throwErr s!"assertEq: {v1} ≠ {v2} ({m})" - | none => throwErr s!"assertEq: {v1} ≠ {v2}" - interp decls bindings ret - | .u8BitDecomposition t => do - match ← interp decls bindings t with - | .field g => - let byte := g.val.toUInt8 - return .array (Array.ofFn fun (i : Fin 8) => - .field (G.ofUInt8 ((byte >>> i.val.toUInt8) &&& 1))) - | _ => throwErr "u8BitDecomposition: expected field value" - | .u8ShiftLeft t => do - match ← interp decls bindings t with - | .field g => return .field (G.ofUInt8 (g.val.toUInt8 <<< 1)) - | _ => throwErr "u8ShiftLeft: expected field value" - | .u8ShiftRight t => do - match ← interp decls bindings t with - | .field g => return .field (G.ofUInt8 (g.val.toUInt8 >>> 1)) - | _ => throwErr "u8ShiftRight: expected field value" - | .u8Xor t1 t2 => do - match (← interp decls bindings t1), (← interp decls bindings t2) with - | .field a, .field b => return .field (G.ofUInt8 (a.val.toUInt8 ^^^ b.val.toUInt8)) - | _, _ => throwErr "u8Xor: expected field values" - | .u8Add t1 t2 => do - match (← interp decls bindings t1), (← interp decls bindings t2) with - | .field a, .field b => - let x := a.val.toUInt8.toNat + b.val.toUInt8.toNat - let sum : Value := .field (G.ofUInt8 x.toUInt8) - let overflow : Value := .field (if x >= 256 then 1 else 0) - return .tuple #[sum, overflow] - | _, _ => throwErr "u8Add: expected field values" - | .u8Mul t1 t2 => do - match (← interp decls bindings t1), (← interp decls bindings t2) with - | .field a, .field b => - let x := a.val.toUInt8.toNat * b.val.toUInt8.toNat - let lo : Value := .field (G.ofUInt8 x.toUInt8) - let hi : Value := .field (G.ofUInt8 (x / 256).toUInt8) - return .tuple #[lo, hi] - | _, _ => throwErr "u8Mul: expected field values" - | .u8XorSplit7 t1 t2 => do - match (← interp decls bindings t1), (← interp decls bindings t2) with - | .field a, .field b => - let x := a.val.toUInt8 ^^^ b.val.toUInt8 - return .tuple #[.field (G.ofUInt8 (x >>> 7)), .field (G.ofUInt8 (x <<< 1))] - | _, _ => throwErr "u8XorSplit7: expected field values" - | .u8XorSplit4 t1 t2 => do - match (← interp decls bindings t1), (← interp decls bindings t2) with - | .field a, .field b => - let x := a.val.toUInt8 ^^^ b.val.toUInt8 - return .tuple #[.field (G.ofUInt8 (x >>> 4)), .field (G.ofUInt8 (x <<< 4))] - | _, _ => throwErr "u8XorSplit4: expected field values" - | .u8Sub t1 t2 => do - match (← interp decls bindings t1), (← interp decls bindings t2) with - | .field a, .field b => - let i := a.val.toUInt8 - let j := b.val.toUInt8 - return .tuple #[.field (G.ofUInt8 (i - j)), .field (if j > i then 1 else 0)] - | _, _ => throwErr "u8Sub: expected field values" - | .u8And t1 t2 => do - match (← interp decls bindings t1), (← interp decls bindings t2) with - | .field a, .field b => return .field (G.ofUInt8 (a.val.toUInt8 &&& b.val.toUInt8)) - | _, _ => throwErr "u8And: expected field values" - | .u8Or t1 t2 => do - match (← interp decls bindings t1), (← interp decls bindings t2) with - | .field a, .field b => return .field (G.ofUInt8 (a.val.toUInt8 ||| b.val.toUInt8)) - | _, _ => throwErr "u8Or: expected field values" - | .u8LessThan t1 t2 => do - match (← interp decls bindings t1), (← interp decls bindings t2) with - | .field a, .field b => return .field (if a.val.toUInt8 < b.val.toUInt8 then 1 else 0) - | _, _ => throwErr "u8LessThan: expected field values" - | .u32LessThan t1 t2 => do - match (← interp decls bindings t1), (← interp decls bindings t2) with - | .field a, .field b => - return .field (if a.val.toUInt32 < b.val.toUInt32 then 1 else 0) - | _, _ => throwErr "u32LessThan: expected field values" - | .unconstrainedU32Add t1 t2 => do - match (← interp decls bindings t1), (← interp decls bindings t2) with - | .array a, .array b => - let pack (xs : Array Value) := xs.toList.zipIdx.foldl - (fun n (v, i) => match v with | .field g => n + g.val.toNat * 256 ^ i | _ => n) 0 - let sum := pack a + pack b - return .tuple #[.array (#[0, 1, 2, 3].map fun i => .field (.ofNat ((sum / 256 ^ i) % 256))), - .field (.ofNat (sum / 0x100000000))] - | _, _ => throwErr "unconstrainedU32Add: expected byte arrays" - | .unconstrainedU32Add3 t1 t2 t3 => do - match (← interp decls bindings t1), (← interp decls bindings t2), - (← interp decls bindings t3) with - | .array a, .array b, .array c => - let pack (xs : Array Value) := xs.toList.zipIdx.foldl - (fun n (v, i) => match v with | .field g => n + g.val.toNat * 256 ^ i | _ => n) 0 - let sum := pack a + pack b + pack c - return .tuple #[.array (#[0, 1, 2, 3].map fun i => .field (.ofNat ((sum / 256 ^ i) % 256))), - .field (.ofNat (sum / 0x100000000))] - | _, _, _ => throwErr "unconstrainedU32Add3: expected byte arrays" - | .u32ToField t => do - match ← interp decls bindings t with - | .array a => return .field (.ofNat (a.toList.zipIdx.foldl - (fun n (v, i) => match v with | .field g => n + g.val.toNat * 256 ^ i | _ => n) 0)) - | _ => throwErr "u32ToField: expected byte array" - | .u8RangeCheck t1 t2 => do - match (← interp decls bindings t1), (← interp decls bindings t2) with - | .field a, .field b => - if a.val < 256 && b.val < 256 then return .tuple #[.field a, .field b] - else throwErr "u8RangeCheck: value out of range [0, 256)" - | _, _ => throwErr "u8RangeCheck: expected field values" - | .unconstrainedBigUintDivMod t1 t2 => do - let aPtr ← interp decls bindings t1 - let bPtr ← interp decls bindings t2 - let bound := (← getStore).size + 1 - let (dt, aLimbs) ← readLimbChainI decls bound aPtr - let (_, bLimbs) ← readLimbChainI decls bound bPtr - match dt.constructors[0]?, dt.constructors[1]? with - | some cons, some nil => - let consG := dt.name.pushNamespace cons.nameHead - let nilG := dt.name.pushNamespace nil.nameHead - let aVal := limbsVal aLimbs - let bVal := limbsVal bLimbs - -- `Nat` division matches the runtime's `b = 0 → (0, a)` convention. - let qPtr ← buildLimbChainI consG nilG (natToLimbsLE (aVal / bVal)) - let rPtr ← buildLimbChainI consG nilG (natToLimbsLE (aVal % bVal)) - return .tuple #[qPtr, rPtr] - | _, _ => - throwErr "unconstrainedBigUintDivMod: datatype has fewer than two constructors" - | .unconstrainedGToBytes t => do - match ← interp decls bindings t with - | .field g => return .array (Array.ofFn fun i => .field (g.toLeBytes i)) - | _ => throwErr "unconstrainedGToBytes: expected field value" - | .unconstrainedGInverse t => do - match ← interp decls bindings t with - | .field g => return .field g.inverse - | _ => throwErr "unconstrainedGInverse: expected field value" - -- `toField` / `u8FromFieldUnsafe` are erased coercions: value unchanged. - | .toField t | .u8FromFieldUnsafe t => interp decls bindings t - | .u8Lit n => return .field (G.ofNat n) - | .debug label optT cont => do - match optT with - | none => dbg_trace s!"{label}" - | some t => - let v ← interp decls bindings t - let store ← getStore - dbg_trace s!"{label}: {Value.ppDeref store 16 v}" - interp decls bindings cont - | .ioGetInfo channel key => do - let channelG ← expectField (← interp decls bindings channel) - let keyGs ← expectFieldArray (← interp decls bindings key) - let io ← getIOBuffer - match io.map[(channelG, keyGs)]? with - | some info => - return .tuple #[.field (.ofNat info.idx), .field (.ofNat info.len)] - | none => throwErr s!"ioGetInfo: key not found" - | .ioSetInfo channel key idx len ret => do - let channelG ← expectField (← interp decls bindings channel) - let keyGs ← expectFieldArray (← interp decls bindings key) - let idxVal ← expectField (← interp decls bindings idx) - let lenVal ← expectField (← interp decls bindings len) - let io ← getIOBuffer - if io.map.contains (channelG, keyGs) then - throwErr s!"ioSetInfo: key already set" - let info : IOKeyInfo := ⟨idxVal.val.toNat, lenVal.val.toNat⟩ - modifyIOBuffer fun io => { io with map := io.map.insert (channelG, keyGs) info } - interp decls bindings ret - | .ioRead channel idx len => do - let channelG ← expectField (← interp decls bindings channel) - let idxVal ← expectField (← interp decls bindings idx) - let io ← getIOBuffer - let arena := io.data.getD channelG #[] - let start := idxVal.val.toNat - if start + len > arena.size then - throwErr s!"ioRead: out-of-bounds read at {start} for length {len} \ - (channel {channelG.val}, arena size {arena.size})" - return .array (arena.extract start (start + len) |>.map .field) - | .ioWrite channel data ret => do - let channelG ← expectField (← interp decls bindings channel) - let dataGs ← expectFieldArray (← interp decls bindings data) - modifyIOBuffer fun io => - let arena := io.data.getD channelG #[] - { io with data := io.data.insert channelG (arena ++ dataGs) } - interp decls bindings ret - -end - -def runFunction (decls : Decls) (funcName : Global) (inputs : List Value) - (ioBuffer : IOBuffer := default) : - Except Interrupt Value × InterpState := - let init : InterpState := { ioBuffer } - match decls.getByKey funcName with - | some (.function f) => - if inputs.length != f.inputs.length then - (.error (.error s!"runFunction: arity mismatch for {funcName}: \ - expected {f.inputs.length}, got {inputs.length}" []), init) - else - let bindings := f.inputs.map (·.1) |>.zip inputs - -- `callSite` also catches a top-level early `return` from the entry - -- function itself, which otherwise escapes as a `.ret` interrupt. - StateT.run (ExceptT.run (callSite funcName inputs - (interp decls bindings f.body))) init - | _ => - (.error (.error s!"Function not found: {funcName}" []), init) - -end Aiur - -end diff --git a/Ix/Aiur/Library/Blake3.lean b/Ix/Aiur/Library/Blake3.lean deleted file mode 100644 index a0cf1bf9b..000000000 --- a/Ix/Aiur/Library/Blake3.lean +++ /dev/null @@ -1,561 +0,0 @@ -module -public import Ix.Aiur.Meta - -public section - -namespace Aiur.Library - -def blake3 := ⟦ - /- # Test entrypoints -/ - - pub fn blake3_test() -> [[U8; 4]; 8] { - let (idx, len) = io_get_info(0, [0]); - let byte_stream = read_checked_byte_stream(0, idx, len); - @blake3(byte_stream) - } - - /- # Benchmark entrypoints -/ - - pub fn blake3_bench(num_hashes: G) -> G { - let num_hashes_pred = num_hashes - 1; - let key = [num_hashes_pred]; - let (idx, len) = io_get_info(0, key); - let byte_stream = read_checked_byte_stream(0, idx, len); - @blake3(byte_stream); - match num_hashes_pred { - 0 => 0, - _ => blake3_bench(num_hashes_pred), - } - } - - /- # Implementation -/ - - enum LayerNode { - Push(Layer, [[U8; 4]; 8]), - Nil - } - - type Layer = &LayerNode - - enum MaybeDigest { - None, - Some([[U8; 4]; 8]) - } - - -- Blake3 output words packed 4 LE bytes -> 1 field element (injective: - -- 2^32 < p, unlike full 8-byte limbs). Pure wiring when @-inlined; the - -- packed form is the public-input digest representation shared by the - -- kernel's `verify_claim` and the recursive verifier's entrypoint. - fn b3_pack_w(w: [U8; 4]) -> G { - to_field(w[0]) + 256 * to_field(w[1]) + 65536 * to_field(w[2]) - + 16777216 * to_field(w[3]) - } - fn b3_pack(h: [[U8; 4]; 8]) -> [G; 8] { - [@b3_pack_w(h[0]), @b3_pack_w(h[1]), @b3_pack_w(h[2]), @b3_pack_w(h[3]), - @b3_pack_w(h[4]), @b3_pack_w(h[5]), @b3_pack_w(h[6]), @b3_pack_w(h[7])] - } - - -- `input` must be a finite list of bytes: built by constrained terminating - -- code from checked bytes, or admitted through read_checked_byte_stream. - -- Hash equality alone establishes neither for an arbitrary hinted - -- pointer: cyclic lookups can forge a traversal's return, and message - -- bytes enter the compression only as packed 32-bit words, which elements - -- that are not bytes can match while holding other values. Keep the - -- checks at ingress, not on every hash of an internally constructed - -- buffer. - fn blake3(input: ByteStream) -> [[U8; 4]; 8] { - let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]]; - blake3_compress_layer(blake3_compress_chunks(input, store(ListNode.Nil), 0, 0, store([0u8; 8]), store(IV), store(LayerNode.Nil))) - } - - -- Hash `bytes` and assert the digest equals `expected`. Used by every - -- IOBuffer-load path that verifies the pre-image of a content-addressed - -- pointer matches the bytes the prover supplied. - fn verify_bytes_against(bytes: ByteStream, expected: [U8; 32]) { - let h = @blake3(bytes); - assert_eq!( - [h[0][0], h[0][1], h[0][2], h[0][3], - h[1][0], h[1][1], h[1][2], h[1][3], - h[2][0], h[2][1], h[2][2], h[2][3], - h[3][0], h[3][1], h[3][2], h[3][3], - h[4][0], h[4][1], h[4][2], h[4][3], - h[5][0], h[5][1], h[5][2], h[5][3], - h[6][0], h[6][1], h[6][2], h[6][3], - h[7][0], h[7][1], h[7][2], h[7][3]], - expected, - "blake3 of the supplied bytes != the address they were fetched under"); - } - - -- Hash `bytes` and intern the digest into the Store. Returned pointer is - -- the canonical content-addressed `Addr` shape (`&[U8;32]`). Used by every - -- site that synthesises an address from raw bytes (e.g. `expr_addr`, - -- `leaf_hash`, `node_hash`, `cprj_content_addr`). - fn bytes_to_addr(bytes: ByteStream) -> &[U8; 32] { - let h = @blake3(bytes); - store([h[0][0], h[0][1], h[0][2], h[0][3], - h[1][0], h[1][1], h[1][2], h[1][3], - h[2][0], h[2][1], h[2][2], h[2][3], - h[3][0], h[3][1], h[3][2], h[3][3], - h[4][0], h[4][1], h[4][2], h[4][3], - h[5][0], h[5][1], h[5][2], h[5][3], - h[6][0], h[6][1], h[6][2], h[6][3], - h[7][0], h[7][1], h[7][2], h[7][3]]) - } - - fn blake3_next_layer(layer: Layer, digest: [[U8; 4]; 8], root: G) -> (MaybeDigest, Layer) { - match load(layer) { - LayerNode.Nil => (MaybeDigest.Some(digest), layer), - LayerNode.Push(layer, other) => - let (last, new_layer) = blake3_next_layer(layer, other, 0); - match last { - MaybeDigest.None => (MaybeDigest.Some(digest), new_layer), - MaybeDigest.Some(last) => - let PARENT = 4; - let ROOT = 8; - let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]]; - let [x0, x1, x2, x3, x4, x5, x6, x7] = last; - let [x8, x9, x10, x11, x12, x13, x14, x15] = digest; - let blocks = [x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15]; - match load(new_layer) { - LayerNode.Nil => - let flags = PARENT + ROOT * root; - let digest = @blake3_compress_init(IV, blocks, [0u8; 8], 64, flags); - (MaybeDigest.None, store(LayerNode.Push(new_layer, digest))), - _ => - let flags = PARENT; - let digest = @blake3_compress_init(IV, blocks, [0u8; 8], 64, flags); - (MaybeDigest.None, store(LayerNode.Push(new_layer, digest))), - }, - }, - } - } - - fn blake3_compress_layer(layer: Layer) -> [[U8; 4]; 8] { - let LayerNode.Push(rest, digest) = load(layer); - match load(rest) { - LayerNode.Nil => digest, - _ => - let (last, new_merkle) = blake3_next_layer(rest, digest, 1); - match last { - MaybeDigest.None => blake3_compress_layer(new_merkle), - MaybeDigest.Some(last) => blake3_compress_layer(store(LayerNode.Push(new_merkle, last))), - }, - } - } - - -- Hot chunk loop. The 64-byte block buffer is NOT threaded here as a - -- `[[U8; 4]; 16]` value — that cost 64 columns of `inputSize` plus a +64-aux - -- `assign_block_value` call on every row. Instead bytes accumulate into a - -- reverse-ordered linked list (`byte_acc`). Four byte steps share one hot - -- row. The inline continuations repeat the Nil/Cons and block_index == 63 - -- checks at EACH byte, including unaligned entry states. Block compression - -- and finalization are called at exactly the original boundaries. - fn blake3_compress_chunks( - input: ByteStream, - byte_acc: ByteStream, - block_index: G, - chunk_index: G, - chunk_count: &U64, - block_digest: &[[U8; 4]; 8], - layer: Layer - ) -> Layer { - match load(input) { - -- Input exhausted: hand off to the cold finalize circuit. - ListNode.Nil => - blake3_finish(byte_acc, block_index, chunk_index, chunk_count, block_digest, layer), - ListNode.Cons(head, input) => - let byte_acc = store(ListNode.Cons(head, byte_acc)); - match block_index { - 63 => blake3_compress_block(input, byte_acc, chunk_index, chunk_count, block_digest, layer), - _ => @blake3_compress_chunks_step2(input, byte_acc, block_index + 1, chunk_index + 1, chunk_count, block_digest, layer), - }, - } - } - -- These helpers are always inlined: only the fourth step recurses through - -- the ordinary seven-input hot circuit. No helper adds a circuit. - fn blake3_compress_chunks_step2( - input: ByteStream, - byte_acc: ByteStream, - block_index: G, - chunk_index: G, - chunk_count: &U64, - block_digest: &[[U8; 4]; 8], - layer: Layer - ) -> Layer { - match load(input) { - -- Input exhausted: hand off to the cold finalize circuit. - ListNode.Nil => - blake3_finish(byte_acc, block_index, chunk_index, chunk_count, block_digest, layer), - ListNode.Cons(head, input) => - let byte_acc = store(ListNode.Cons(head, byte_acc)); - match block_index { - 63 => blake3_compress_block(input, byte_acc, chunk_index, chunk_count, block_digest, layer), - _ => @blake3_compress_chunks_step3(input, byte_acc, block_index + 1, chunk_index + 1, chunk_count, block_digest, layer), - }, - } - } - fn blake3_compress_chunks_step3( - input: ByteStream, - byte_acc: ByteStream, - block_index: G, - chunk_index: G, - chunk_count: &U64, - block_digest: &[[U8; 4]; 8], - layer: Layer - ) -> Layer { - match load(input) { - -- Input exhausted: hand off to the cold finalize circuit. - ListNode.Nil => - blake3_finish(byte_acc, block_index, chunk_index, chunk_count, block_digest, layer), - ListNode.Cons(head, input) => - let byte_acc = store(ListNode.Cons(head, byte_acc)); - match block_index { - 63 => blake3_compress_block(input, byte_acc, chunk_index, chunk_count, block_digest, layer), - _ => @blake3_compress_chunks_step4(input, byte_acc, block_index + 1, chunk_index + 1, chunk_count, block_digest, layer), - }, - } - } - fn blake3_compress_chunks_step4( - input: ByteStream, - byte_acc: ByteStream, - block_index: G, - chunk_index: G, - chunk_count: &U64, - block_digest: &[[U8; 4]; 8], - layer: Layer - ) -> Layer { - match load(input) { - -- Input exhausted: hand off to the cold finalize circuit. - ListNode.Nil => - blake3_finish(byte_acc, block_index, chunk_index, chunk_count, block_digest, layer), - ListNode.Cons(head, input) => - let byte_acc = store(ListNode.Cons(head, byte_acc)); - match block_index { - 63 => blake3_compress_block(input, byte_acc, chunk_index, chunk_count, block_digest, layer), - _ => blake3_compress_chunks(input, byte_acc, block_index + 1, chunk_index + 1, chunk_count, block_digest, layer), - }, - } - } - - -- Materializes a 64-byte accumulator list into a `[[U8; 4]; 16]` block. The - -- list is reverse-ordered (head = most recently appended byte = position 63). - -- 64 unrolled `load`s, one circuit row per call — keeps the 64-wide buffer - -- out of the hot loop and out of `inputSize`. - fn bytes_to_block(byte_acc: ByteStream) -> [[U8; 4]; 16] { - let ListNode.Cons(b63, l) = load(byte_acc); - let ListNode.Cons(b62, l) = load(l); - let ListNode.Cons(b61, l) = load(l); - let ListNode.Cons(b60, l) = load(l); - let ListNode.Cons(b59, l) = load(l); - let ListNode.Cons(b58, l) = load(l); - let ListNode.Cons(b57, l) = load(l); - let ListNode.Cons(b56, l) = load(l); - let ListNode.Cons(b55, l) = load(l); - let ListNode.Cons(b54, l) = load(l); - let ListNode.Cons(b53, l) = load(l); - let ListNode.Cons(b52, l) = load(l); - let ListNode.Cons(b51, l) = load(l); - let ListNode.Cons(b50, l) = load(l); - let ListNode.Cons(b49, l) = load(l); - let ListNode.Cons(b48, l) = load(l); - let ListNode.Cons(b47, l) = load(l); - let ListNode.Cons(b46, l) = load(l); - let ListNode.Cons(b45, l) = load(l); - let ListNode.Cons(b44, l) = load(l); - let ListNode.Cons(b43, l) = load(l); - let ListNode.Cons(b42, l) = load(l); - let ListNode.Cons(b41, l) = load(l); - let ListNode.Cons(b40, l) = load(l); - let ListNode.Cons(b39, l) = load(l); - let ListNode.Cons(b38, l) = load(l); - let ListNode.Cons(b37, l) = load(l); - let ListNode.Cons(b36, l) = load(l); - let ListNode.Cons(b35, l) = load(l); - let ListNode.Cons(b34, l) = load(l); - let ListNode.Cons(b33, l) = load(l); - let ListNode.Cons(b32, l) = load(l); - let ListNode.Cons(b31, l) = load(l); - let ListNode.Cons(b30, l) = load(l); - let ListNode.Cons(b29, l) = load(l); - let ListNode.Cons(b28, l) = load(l); - let ListNode.Cons(b27, l) = load(l); - let ListNode.Cons(b26, l) = load(l); - let ListNode.Cons(b25, l) = load(l); - let ListNode.Cons(b24, l) = load(l); - let ListNode.Cons(b23, l) = load(l); - let ListNode.Cons(b22, l) = load(l); - let ListNode.Cons(b21, l) = load(l); - let ListNode.Cons(b20, l) = load(l); - let ListNode.Cons(b19, l) = load(l); - let ListNode.Cons(b18, l) = load(l); - let ListNode.Cons(b17, l) = load(l); - let ListNode.Cons(b16, l) = load(l); - let ListNode.Cons(b15, l) = load(l); - let ListNode.Cons(b14, l) = load(l); - let ListNode.Cons(b13, l) = load(l); - let ListNode.Cons(b12, l) = load(l); - let ListNode.Cons(b11, l) = load(l); - let ListNode.Cons(b10, l) = load(l); - let ListNode.Cons(b9, l) = load(l); - let ListNode.Cons(b8, l) = load(l); - let ListNode.Cons(b7, l) = load(l); - let ListNode.Cons(b6, l) = load(l); - let ListNode.Cons(b5, l) = load(l); - let ListNode.Cons(b4, l) = load(l); - let ListNode.Cons(b3, l) = load(l); - let ListNode.Cons(b2, l) = load(l); - let ListNode.Cons(b1, l) = load(l); - let ListNode.Cons(b0, _) = load(l); - [ - [b0, b1, b2, b3], [b4, b5, b6, b7], [b8, b9, b10, b11], [b12, b13, b14, b15], - [b16, b17, b18, b19], [b20, b21, b22, b23], [b24, b25, b26, b27], [b28, b29, b30, b31], - [b32, b33, b34, b35], [b36, b37, b38, b39], [b40, b41, b42, b43], [b44, b45, b46, b47], - [b48, b49, b50, b51], [b52, b53, b54, b55], [b56, b57, b58, b59], [b60, b61, b62, b63] - ] - } - - -- Prepends `n` zero bytes to a partial block accumulator so it can be fed to - -- `bytes_to_block`. Cold: only the trailing partial block of a hash uses it. - fn pad_block(acc: ByteStream, n: G) -> ByteStream { - match n { - 0 => acc, - _ => pad_block(store(ListNode.Cons(0u8, acc)), n - 1), - } - } - - -- Cold finalize circuit for `blake3_compress_chunks`: input is exhausted, so - -- emit the trailing layer node. Quarantines the `blake3_compress` call and - -- the partial-block materialization out of the hot chunk loop. - fn blake3_finish( - byte_acc: ByteStream, - block_index: G, - chunk_index: G, - chunk_count: &U64, - block_digest: &[[U8; 4]; 8], - layer: Layer - ) -> Layer { - let CHUNK_START = 1; - let CHUNK_END = 2; - let ROOT = 8; - match (block_index, chunk_index) { - (0, 0) => - match load(chunk_count) { - [0, 0, 0, 0, 0, 0, 0, 0] => - let flags = ROOT + CHUNK_START + CHUNK_END; - store(LayerNode.Push(layer, @blake3_compress_init(load(block_digest), [[0u8; 4]; 16], load(chunk_count), 0, flags))), - _ => layer, - }, - (0, _) => store(LayerNode.Push(layer, load(block_digest))), - (_, _) => - let flags = CHUNK_END + u64_is_zero(load(chunk_count)) * ROOT + eq_zero(chunk_index - block_index) * CHUNK_START; - let block = bytes_to_block(pad_block(byte_acc, 64 - block_index)); - store(LayerNode.Push(layer, @blake3_compress_init(load(block_digest), block, load(chunk_count), block_index, flags))), - } - } - - -- Cold continuation of `blake3_compress_chunks`: runs once per filled 64-byte - -- block. Materializes the byte accumulator, runs `blake3_compress`, pushes the - -- digest, and resets the accumulator for the next block. - fn blake3_compress_block( - input: ByteStream, - byte_acc: ByteStream, - chunk_index: G, - chunk_count: &U64, - block_digest: &[[U8; 4]; 8], - layer: Layer - ) -> Layer { - let CHUNK_START = 1; - let CHUNK_END = 2; - let ROOT = 8; - let block = bytes_to_block(byte_acc); - match chunk_index { - 1023 => - let flags = ROOT * list_is_empty(input) * u64_is_zero(load(chunk_count)) + CHUNK_END; - let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]]; - let layer = store(LayerNode.Push(layer, @blake3_compress_init(load(block_digest), block, load(chunk_count), 64, flags))); - blake3_compress_chunks(input, store(ListNode.Nil), 0, 0, store(relaxed_u64_succ(load(chunk_count))), store(IV), layer), - _ => - let chunk_end_flag = list_is_empty(input) * CHUNK_END; - let root_flag = list_is_empty(input) * u64_is_zero(load(chunk_count)) * ROOT; - let chunk_start_flag = eq_zero(chunk_index - 63) * CHUNK_START; - let flags = chunk_end_flag + root_flag + chunk_start_flag; - let block_digest = @blake3_compress_init(load(block_digest), block, load(chunk_count), 64, flags); - blake3_compress_chunks(input, store(ListNode.Nil), 0, chunk_index + 1, chunk_count, store(block_digest), layer), - } - } - - fn blake3_g_function( - a: [U8; 4], - b: [U8; 4], - c: [U8; 4], - d: [U8; 4], - x: [U8; 4], - y: [U8; 4] - ) -> [[U8; 4]; 4] { - let a = @u32_add3(a, b, x); - let d = @u32_rotr16(@u32_xor(d, a)); - let c = @u32_add(c, d); - let b = @u32_xor_rotr12(b, c); - let a = @u32_add3(a, b, y); - let d = @u32_rotr8(@u32_xor(d, a)); - let c = @u32_add(c, d); - let b = @u32_xor_rotr7(b, c); - [a, b, c, d] - } - - fn blake3_compress_inner_j(state: [[U8; 4]; 32]) -> [[U8; 4]; 32] { - -- Round 0 - let [a, b, c, d] = @blake3_g_function( - state[0], state[4], state[8], state[12], state[16], state[17] - ); - let state = set(state, 0, a); - let state = set(state, 4, b); - let state = set(state, 8, c); - let state = set(state, 12, d); - - -- Round 1 - let [a, b, c, d] = @blake3_g_function( - state[1], state[5], state[9], state[13], state[18], state[19] - ); - let state = set(state, 1, a); - let state = set(state, 5, b); - let state = set(state, 9, c); - let state = set(state, 13, d); - - -- Round 2 - let [a, b, c, d] = @blake3_g_function( - state[2], state[6], state[10], state[14], state[20], state[21] - ); - let state = set(state, 2, a); - let state = set(state, 6, b); - let state = set(state, 10, c); - let state = set(state, 14, d); - - -- Round 3 - let [a, b, c, d] = @blake3_g_function( - state[3], state[7], state[11], state[15], state[22], state[23] - ); - let state = set(state, 3, a); - let state = set(state, 7, b); - let state = set(state, 11, c); - let state = set(state, 15, d); - - -- Round 4 - let [a, b, c, d] = @blake3_g_function( - state[0], state[5], state[10], state[15], state[24], state[25] - ); - let state = set(state, 0, a); - let state = set(state, 5, b); - let state = set(state, 10, c); - let state = set(state, 15, d); - - -- Round 5 - let [a, b, c, d] = @blake3_g_function( - state[1], state[6], state[11], state[12], state[26], state[27] - ); - let state = set(state, 1, a); - let state = set(state, 6, b); - let state = set(state, 11, c); - let state = set(state, 12, d); - - -- Round 6 - let [a, b, c, d] = @blake3_g_function( - state[2], state[7], state[8], state[13], state[28], state[29] - ); - let state = set(state, 2, a); - let state = set(state, 7, b); - let state = set(state, 8, c); - let state = set(state, 13, d); - - -- Round 7 - let [a, b, c, d] = @blake3_g_function( - state[3], state[4], state[9], state[14], state[30], state[31] - ); - let state = set(state, 3, a); - let state = set(state, 4, b); - let state = set(state, 9, c); - let state = set(state, 14, d); - - state - } - - -- TODO: - -- `block_words` could be two arguments of type [[U8; 4]; 8] - fn blake3_compress_init( - chaining_value: [[U8; 4]; 8], - block_words: [[U8; 4]; 16], - counter: U64, - block_len: G, - flags: G - ) -> [[U8; 4]; 8] { - let IV0 = [103u8, 230u8, 9u8, 106u8]; - let IV1 = [133u8, 174u8, 103u8, 187u8]; - let IV2 = [114u8, 243u8, 110u8, 60u8]; - let IV3 = [ 58u8, 245u8, 79u8, 165u8]; - - let counter_low = counter[0 .. 4]; - let counter_high = counter[4 .. 8]; - - -- `block_len` and `flags` are small (< 256); pack as the low byte. - let block_len_u32 = [u8_from_field_unsafe(block_len), 0u8, 0u8, 0u8]; - let flags_u32 = [u8_from_field_unsafe(flags), 0u8, 0u8, 0u8]; - let state: [[U8; 4]; 32] = [ - chaining_value[0], chaining_value[1], chaining_value[2], chaining_value[3], - chaining_value[4], chaining_value[5], chaining_value[6], chaining_value[7], - IV0, IV1, IV2, IV3, - counter_low, counter_high, block_len_u32, flags_u32, - block_words[0], block_words[1], block_words[2], block_words[3], - block_words[4], block_words[5], block_words[6], block_words[7], - block_words[8], block_words[9], block_words[10], block_words[11], - block_words[12], block_words[13], block_words[14], block_words[15] - ]; - - blake3_compress(0, state) - } - - -- One row per stage: stages 0..6 run one round each and recurse with - -- `stage + 1`; stage 7 folds the working halves into the digest. - fn blake3_compress( - stage: G, - state: [[U8; 4]; 32] - ) -> [[U8; 4]; 8] { - match stage { - 7 => - let output0 = @u32_xor(state[0], state[8]); - let output1 = @u32_xor(state[1], state[9]); - let output2 = @u32_xor(state[2], state[10]); - let output3 = @u32_xor(state[3], state[11]); - let output4 = @u32_xor(state[4], state[12]); - let output5 = @u32_xor(state[5], state[13]); - let output6 = @u32_xor(state[6], state[14]); - let output7 = @u32_xor(state[7], state[15]); - [output0, output1, output2, output3, output4, output5, output6, output7], - _ => - let new_state = @blake3_compress_inner_j(state); - -- Apply the message schedule permutation for the next round. The final - -- round also executes this permutation, but only state[0..15] is consumed - -- afterward, so that last permutation is unobservable. - let new_state = set(new_state, 16, state[18]); - let new_state = set(new_state, 17, state[22]); - let new_state = set(new_state, 18, state[19]); - let new_state = set(new_state, 19, state[26]); - let new_state = set(new_state, 20, state[23]); - let new_state = set(new_state, 21, state[16]); - let new_state = set(new_state, 22, state[20]); - let new_state = set(new_state, 23, state[29]); - let new_state = set(new_state, 24, state[17]); - let new_state = set(new_state, 25, state[27]); - let new_state = set(new_state, 26, state[28]); - let new_state = set(new_state, 27, state[21]); - let new_state = set(new_state, 28, state[25]); - let new_state = set(new_state, 29, state[30]); - let new_state = set(new_state, 30, state[31]); - let new_state = set(new_state, 31, state[24]); - blake3_compress(stage + 1, new_state), - } - } -⟧ - -end Aiur.Library - -end diff --git a/Ix/Aiur/Library/ByteStream.lean b/Ix/Aiur/Library/ByteStream.lean deleted file mode 100644 index 8596cc1e3..000000000 --- a/Ix/Aiur/Library/ByteStream.lean +++ /dev/null @@ -1,349 +0,0 @@ -module -public import Ix.Aiur.Meta - -public section - -namespace Aiur.Library - -def byteStream := ⟦ - type ByteStream = List‹U8› - - type U64 = [U8; 8] - - -- Materialize `len` IO cells of `channel` from `idx` as a byte list. The - -- result is ADVICE: an IO read is a free column and - -- `u8_from_field_unsafe` mints a `U8` holding any field element, so the - -- "bytes" may be any field elements and the list may even be cyclic. - -- Call it unconstrained (`#`) and only for an advisory value whose every - -- possible content is safe (e.g. IxVM channel-3 reducibility hints). - fn read_byte_stream_unchecked(channel: G, idx: G, len: G) -> ByteStream { - match len { - 0 => store(ListNode.Nil), - _ => - let tail = read_byte_stream_unchecked(channel, idx + 1, len - 1); - let [byte] = io_read(channel, idx, 1); - store(ListNode.Cons(u8_from_field_unsafe(byte), tail)), - } - } - - -- Read the byte stream at (`channel`, `idx`, `len`) and prove in a single - -- constrained pass, before anything hashes or parses it, that it is finite - -- and that every element is a byte (< 256). Every byte stream a circuit - -- reads from IO comes through here. Two elements per row share one - -- `u8_range_check` lookup, so the read costs one lookup and one row per two - -- bytes; an odd last element is paired with itself. - -- - -- `len` is the termination rank. The recursive arm runs only for `len` other - -- than 0 and 1, that is for `len >= 2` as an integer in [0, p), so `len - 2` - -- never wraps and the rank strictly decreases along every chain of rows. - -- No chain can return to a row, so every chain ends at a base arm that - -- returns a finite list. - -- - -- Hashing alone does not bind unchecked elements. BLAKE3 absorbs message - -- bytes only as packed 32-bit words, `b0 + 2^8 b1 + 2^16 b2 + 2^24 b3`, so - -- elements that are not bytes can keep every word's packed value while a - -- parser reads different fields out of them (`02 00 01 00` read as - -- `03 00 00 00`, with the difference moved into the word's first - -- element). Once every element is below 256 the packing is injective, so - -- the parsed fields are the hashed bytes. - -- - -- Must be called CONSTRAINED: under `#` the checks prove nothing. - fn read_checked_byte_stream(channel: G, idx: G, len: G) -> ByteStream { - match len { - 0 => store(ListNode.Nil), - 1 => - let [raw] = io_read(channel, idx, 1); - let (b, _) = u8_range_check(raw, raw); - store(ListNode.Cons(b, store(ListNode.Nil))), - _ => - let [raw0, raw1] = io_read(channel, idx, 2); - let (b0, b1) = u8_range_check(raw0, raw1); - let tail = read_checked_byte_stream(channel, idx + 2, len - 2); - store(ListNode.Cons(b0, store(ListNode.Cons(b1, tail)))), - } - } - - fn u64_is_zero(x: U64) -> G { - match x { - [0, 0, 0, 0, 0, 0, 0, 0] => 1, - _ => 0, - } - } - - -- Wrapping little-endian u32 addition. The four result bytes are advice and - -- are range-checked here. The carry is the virtual expression - -- `(a + b - result) / 2^32`; constraining it to be boolean uniquely pins the - -- wrapping result, so a separate packed-sum equality would be redundant. - fn u32_add(a: [U8; 4], b: [U8; 4]) -> [U8; 4] { - let (raw, carry) = unconstrained_u32_add(a, b); - let (z0, z1) = u8_range_check(raw[0], raw[1]); - let (z2, z3) = u8_range_check(raw[2], raw[3]); - - assert_eq!(carry * carry, carry, "u32_add: carry is not boolean"); - - [z0, z1, z2, z3] - } - - -- Wrapping sum of three little-endian u32s. The output costs two paired - -- range-check lookups. The virtual carry is - -- `(a + b + c - result) / 2^32`; constraining it to {0, 1, 2} uniquely pins - -- the result, so no separate packed-sum equality is needed. - fn u32_add3(a: [U8; 4], b: [U8; 4], c: [U8; 4]) -> [U8; 4] { - let (raw, carry) = unconstrained_u32_add3(a, b, c); - let (z0, z1) = u8_range_check(raw[0], raw[1]); - let (z2, z3) = u8_range_check(raw[2], raw[3]); - - assert_eq!(carry * (carry - 1) * (carry - 2), 0, - "u32_add3: carry is not in {0, 1, 2}"); - - [z0, z1, z2, z3] - } - - fn u32_xor(a: [U8; 4], b: [U8; 4]) -> [U8; 4] { - let c0 = u8_xor(a[0], b[0]); - let c1 = u8_xor(a[1], b[1]); - let c2 = u8_xor(a[2], b[2]); - let c3 = u8_xor(a[3], b[3]); - [c0, c1, c2, c3] - } - - fn u32_and(a: [U8; 4], b: [U8; 4]) -> [U8; 4] { - let c0 = u8_and(a[0], b[0]); - let c1 = u8_and(a[1], b[1]); - let c2 = u8_and(a[2], b[2]); - let c3 = u8_and(a[3], b[3]); - [c0, c1, c2, c3] - } - - -- Right-rotations of a little-endian word. rotr16 / rotr8 are pure byte - -- moves (free); rotr12 / rotr7 are a byte move composed with the chained - -- 4-/7-bit gadget (two lookups + two free field adds each). - fn u32_rotr16(w: [U8; 4]) -> [U8; 4] { - let [w0, w1, w2, w3] = w; - [w2, w3, w0, w1] - } - - fn u32_rotr8(w: [U8; 4]) -> [U8; 4] { - let [w0, w1, w2, w3] = w; - [w1, w2, w3, w0] - } - - fn u32_xor_rotr7(a: [U8; 4], b: [U8; 4]) -> [U8; 4] { - let (h0, l0) = u8_xor_split7(a[0], b[0]); - let (h1, l1) = u8_xor_split7(a[1], b[1]); - let (h2, l2) = u8_xor_split7(a[2], b[2]); - let (h3, l3) = u8_xor_split7(a[3], b[3]); - [u8_from_field_unsafe(to_field(h0) + to_field(l1)), - u8_from_field_unsafe(to_field(h1) + to_field(l2)), - u8_from_field_unsafe(to_field(h2) + to_field(l3)), - u8_from_field_unsafe(to_field(h3) + to_field(l0))] - } - - fn u32_xor_rotr12(a: [U8; 4], b: [U8; 4]) -> [U8; 4] { - let (h0, l0) = u8_xor_split4(a[0], b[0]); - let (h1, l1) = u8_xor_split4(a[1], b[1]); - let (h2, l2) = u8_xor_split4(a[2], b[2]); - let (h3, l3) = u8_xor_split4(a[3], b[3]); - [u8_from_field_unsafe(to_field(h1) + to_field(l2)), - u8_from_field_unsafe(to_field(h2) + to_field(l3)), - u8_from_field_unsafe(to_field(h3) + to_field(l0)), - u8_from_field_unsafe(to_field(h0) + to_field(l1))] - } - - -- Byte-by-byte `u64` equality - fn u64_eq(a: U64, b: U64) -> G { - let [a0, a1, a2, a3, a4, a5, a6, a7] = a; - let [b0, b1, b2, b3, b4, b5, b6, b7] = b; - match [to_field(a0) - to_field(b0), to_field(a1) - to_field(b1), - to_field(a2) - to_field(b2), to_field(a3) - to_field(b3), - to_field(a4) - to_field(b4), to_field(a5) - to_field(b5), - to_field(a6) - to_field(b6), to_field(a7) - to_field(b7)] { - [0, 0, 0, 0, 0, 0, 0, 0] => 1, - _ => 0, - } - } - - -- `u64` addition with carry propagation (little-endian bytes). - -- Returns the sum together with the final carry-out. - fn u64_add(a: U64, b: U64) -> (U64, U8) { - let [a0, a1, a2, a3, a4, a5, a6, a7] = a; - let [b0, b1, b2, b3, b4, b5, b6, b7] = b; - let (s0, c1) = u8_add(a0, b0); - let (t1, o1) = u8_add(a1, b1); - let (s1, c1a) = u8_add(t1, c1); - let c2 = u8_from_field_unsafe(to_field(o1) + to_field(c1a)); - let (t2, o2) = u8_add(a2, b2); - let (s2, c2a) = u8_add(t2, c2); - let c3 = u8_from_field_unsafe(to_field(o2) + to_field(c2a)); - let (t3, o3) = u8_add(a3, b3); - let (s3, c3a) = u8_add(t3, c3); - let c4 = u8_from_field_unsafe(to_field(o3) + to_field(c3a)); - let (t4, o4) = u8_add(a4, b4); - let (s4, c4a) = u8_add(t4, c4); - let c5 = u8_from_field_unsafe(to_field(o4) + to_field(c4a)); - let (t5, o5) = u8_add(a5, b5); - let (s5, c5a) = u8_add(t5, c5); - let c6 = u8_from_field_unsafe(to_field(o5) + to_field(c5a)); - let (t6, o6) = u8_add(a6, b6); - let (s6, c6a) = u8_add(t6, c6); - let c7 = u8_from_field_unsafe(to_field(o6) + to_field(c6a)); - let (t7, o7) = u8_add(a7, b7); - let (s7, c7a) = u8_add(t7, c7); - let final_carry = u8_from_field_unsafe(to_field(o7) + to_field(c7a)); - ([s0, s1, s2, s3, s4, s5, s6, s7], final_carry) - } - - -- `u64` subtraction via repeated decrement (correct for small b) - fn u64_sub(a: U64, b: U64) -> U64 { - match u64_is_zero(b) { - 1 => a, - 0 => u64_sub(relaxed_u64_pred(a), relaxed_u64_pred(b)), - } - } - - fn g_or(a: G, b: G) -> G { - match (a, b) { - (0, 0) => 0, - _ => 1, - } - } - - -- Computes the successor of an `u64` assumed to be properly represented in - -- little-endian bytes. If that's not the case, this implementation has UB. - fn relaxed_u64_succ(bytes: U64) -> U64 { - let [b0, b1, b2, b3, b4, b5, b6, b7] = bytes; - -- Incrementing a byte known to be `< 255` cannot overflow, so add as a - -- cheap `G` and reinterpret (no `u8_add` lookup). - match b0 { - 255 => match b1 { - 255 => match b2 { - 255 => match b3 { - 255 => match b4 { - 255 => match b5 { - 255 => match b6 { - 255 => match b7 { - 255 => [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], - _ => [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, u8_from_field_unsafe(to_field(b7) + 1)], - }, - _ => [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, u8_from_field_unsafe(to_field(b6) + 1), b7], - }, - _ => [0u8, 0u8, 0u8, 0u8, 0u8, u8_from_field_unsafe(to_field(b5) + 1), b6, b7], - }, - _ => [0u8, 0u8, 0u8, 0u8, u8_from_field_unsafe(to_field(b4) + 1), b5, b6, b7], - }, - _ => [0u8, 0u8, 0u8, u8_from_field_unsafe(to_field(b3) + 1), b4, b5, b6, b7], - }, - _ => [0u8, 0u8, u8_from_field_unsafe(to_field(b2) + 1), b3, b4, b5, b6, b7], - }, - _ => [0u8, u8_from_field_unsafe(to_field(b1) + 1), b2, b3, b4, b5, b6, b7], - }, - _ => [u8_from_field_unsafe(to_field(b0) + 1), b1, b2, b3, b4, b5, b6, b7], - } - } - - fn relaxed_u64_be_add_2_bytes(u64: U64, bs: [U8; 2]) -> U64 { - -- Byte 0, no initial carry - let (sum0, carry1) = u8_add(u64[7], bs[1]); - - -- Byte 1 - let (sum1, overflow1) = u8_add(u64[6], bs[0]); - let (sum1_with_carry, carry1a) = u8_add(sum1, carry1); - let carry2 = u8_from_field_unsafe(to_field(overflow1) + to_field(carry1a)); - - -- Other bytes - let (sum2, carry3) = u8_add(u64[5], carry2); - let (sum3, carry4) = u8_add(u64[4], carry3); - let (sum4, carry5) = u8_add(u64[3], carry4); - let (sum5, carry6) = u8_add(u64[2], carry5); - let (sum6, carry7) = u8_add(u64[1], carry6); - let (sum7, _carry8) = u8_add(u64[0], carry7); - - [sum7, sum6, sum5, sum4, sum3, sum2, sum1, sum0] - } - - fn u32_be_add(a: [U8; 4], b: [U8; 4]) -> [U8; 4] { - -- Byte 0, no initial carry - let (sum0, carry1) = u8_add(a[3], b[3]); - - -- Byte 1 - let (sum1, overflow1) = u8_add(a[2], b[2]); - let (sum1_with_carry, carry1a) = u8_add(sum1, carry1); - let carry2 = u8_from_field_unsafe(to_field(overflow1) + to_field(carry1a)); - - -- Byte 2 - let (sum2, overflow2) = u8_add(a[1], b[1]); - let (sum2_with_carry, carry2a) = u8_add(sum2, carry2); - let carry3 = u8_from_field_unsafe(to_field(overflow2) + to_field(carry2a)); - - -- Byte 3 - let (sum3, _x) = u8_add(a[0], b[0]); - let (sum3_with_carry, _x) = u8_add(sum3, carry3); - - [sum3_with_carry, sum2_with_carry, sum1_with_carry, sum0] - } - - -- Computes the predecessor of an `u64` assumed to be properly represented in - -- little-endian bytes. If that's not the case, this implementation has UB. - fn relaxed_u64_pred(bytes: U64) -> U64 { - let [b0, b1, b2, b3, b4, b5, b6, b7] = bytes; - -- Decrementing a byte known to be `> 0` cannot underflow, so subtract as a - -- cheap `G` and reinterpret (no `u8_sub` lookup). - match b0 { - 0 => match b1 { - 0 => match b2 { - 0 => match b3 { - 0 => match b4 { - 0 => match b5 { - 0 => match b6 { - 0 => match b7 { - 0 => [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], - _ => [255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, u8_from_field_unsafe(to_field(b7) - 1)], - }, - _ => [255u8, 255u8, 255u8, 255u8, 255u8, 255u8, u8_from_field_unsafe(to_field(b6) - 1), b7], - }, - _ => [255u8, 255u8, 255u8, 255u8, 255u8, u8_from_field_unsafe(to_field(b5) - 1), b6, b7], - }, - _ => [255u8, 255u8, 255u8, 255u8, u8_from_field_unsafe(to_field(b4) - 1), b5, b6, b7], - }, - _ => [255u8, 255u8, 255u8, u8_from_field_unsafe(to_field(b3) - 1), b4, b5, b6, b7], - }, - _ => [255u8, 255u8, u8_from_field_unsafe(to_field(b2) - 1), b3, b4, b5, b6, b7], - }, - _ => [255u8, u8_from_field_unsafe(to_field(b1) - 1), b2, b3, b4, b5, b6, b7], - }, - _ => [u8_from_field_unsafe(to_field(b0) - 1), b1, b2, b3, b4, b5, b6, b7], - } - } - - -- Flatten a [U8; 8] (U64 little-endian bytes) into a single G via - -- b0 + 256 * b1 + ... + 256^6 * b6. The most significant byte (b7) must be zero; - -- this is enforced by assert_eq!, limiting the range to 7 bytes (< 2^56). - -- - -- INJECTIVITY IS CONDITIONAL ON THE CALLER. `[U8; 8]` is nominal typing, - -- not a constraint — `u8_from_field_unsafe` mints a `U8` holding any - -- field element — so this function alone does NOT pin a unique input - -- for a given output. With unchecked bytes the sum is satisfiable many - -- ways (`b1 = k`, `b0 = x - 256k`). Only when every byte is - -- range-checked does `b7 = 0` bound the value by 2^56 - 1, which is - -- below Goldilocks `p`, so the sum cannot wrap and the decomposition is - -- unique. - -- - -- Callers relying on that uniqueness must therefore supply - -- range-checked bytes, and must not lose the `b7 = 0` assert: widening - -- this to a full u64 would silently break them, since 8-byte strings - -- are not injective into the field (a value and value + p collide). - -- `Ingress.idx_to_u64` is one such caller — it pins a projection index - -- whose bytes are hashed into a member's content address. - fn flatten_u64(x: [U8; 8]) -> G { - let [b0, b1, b2, b3, b4, b5, b6, b7] = x; - assert_eq!(to_field(b7), 0, - "u64 -> field: value exceeds 2^56 (top byte must be zero)"); - to_field(b0) + 0x100 * to_field(b1) + 0x10000 * to_field(b2) - + 0x1000000 * to_field(b3) + 0x100000000 * to_field(b4) - + 0x10000000000 * to_field(b5) + 0x1000000000000 * to_field(b6) - } -⟧ - -end Aiur.Library - -end diff --git a/Ix/Aiur/Library/Core.lean b/Ix/Aiur/Library/Core.lean deleted file mode 100644 index 0e1405de3..000000000 --- a/Ix/Aiur/Library/Core.lean +++ /dev/null @@ -1,258 +0,0 @@ -module -public import Ix.Aiur.Meta - -public section - -namespace Aiur.Library - -def core := ⟦ - enum ListNode‹T› { - Cons(T, List‹T›), - Nil - } - - type List‹T› = &ListNode‹T› - - enum Option‹T› { - Some(T), - None - } - - -- Memoized u32 comparison for hot structural and frontier walks. Aiur - -- memoizes function calls automatically, so keeping the decomposition in - -- this shared helper avoids charging the wide intrinsic layout repeatedly; - -- recurring `(a, b)` pairs share one constrained helper row. This belongs - -- in Core because both the IxVM substitution circuits and the recursive - -- multi-STARK verifier rely on the same optimization. - fn memo_u32_less_than(a: G, b: G) -> G { - u32_less_than(a, b) - } - - -- Interned 32-element address (blake3 content hash). - -- - -- DIFFERENT POINTER VALUES DO NOT IMPLY DIFFERENT DATA. The Aiur - -- executor content-dedups `store`, so in an honest trace equal content - -- yields one canonical pointer — but that is an executor convention, - -- not a constraint. The memory AIR (`crates/aiur/src/memory.rs`) - -- enforces only that `is_real` is boolean, that real rows form a - -- prefix, and that `ptr + 1 = ptr_next`. Pointers are unique; VALUES - -- ARE NOT. `Op::Store` witnesses its pointer as a free auxiliary column - -- and merely requires `(channel, size, ptr, values)` to be present in - -- the memory table, so a prover may commit two rows holding identical - -- content and direct a store to either. - -- - -- Consequently, comparing addresses is `address_eq` — NEVER a pointer - -- subtraction. A raw `ptr_val` comparison is admissible in exactly two - -- places, and both must say so at the site: - -- 1. as a fast path with a COMPLETE fallback that decides correctly - -- when the pointers differ (`level_struct_eq`, `ind_is_solo`, - -- `canon_cmp_kexpr_ctx`, the `k_is_def_eq` entry shortcut), or - -- 2. inside `assert_eq!`, where only the positive answer is acted on - -- and a spurious mismatch costs completeness, never soundness. - type Addr = &[U8; 32] - - -- Cold path of `address_eq`: byte 0 already matched, compare the other - -- 31. A separate function on purpose — Aiur charges a function's full - -- width on every one of its rows, so a nested match inside `address_eq` - -- would save nothing; the split has to be a function boundary, and this - -- circuit's height is only the rare byte-0-match rows. - fn address_eq_tail(a: Addr, b: Addr) -> G { - let [_, a1, a2, a3, a4, a5, a6, a7, - a8, a9, a10, a11, a12, a13, a14, a15, - a16, a17, a18, a19, a20, a21, a22, a23, - a24, a25, a26, a27, a28, a29, a30, a31] = load(a); - let [_, b1, b2, b3, b4, b5, b6, b7, - b8, b9, b10, b11, b12, b13, b14, b15, - b16, b17, b18, b19, b20, b21, b22, b23, - b24, b25, b26, b27, b28, b29, b30, b31] = load(b); - -- Pack 7 bytes per field element, base 256, then compare packed - -- limbs: 31 matched variables become 5. On bytes below 256, base-256 - -- packing is INJECTIVE and the comparison decides byte equality - -- exactly — unlike a weighted sum with smaller coefficients, where - -- distinct byte strings collide and unequal addresses would compare - -- equal. Seven is the largest safe group: `256^7 - 1 = 2^56-1` fits - -- Goldilocks, while eight bytes would reach `2^64-1 > p` and wrap the - -- packing back into collisions. - -- - -- `U8` is nominal typing, not a range: `u8_from_field_unsafe` gives - -- any field element that type. Elements that are not bytes can agree - -- on every packed limb while the addresses they stand for differ, so - -- both addresses must hold checked bytes: IO bytes admitted by - -- `read_checked_byte_stream`, hash outputs (whose bytes the hash - -- gadget range-checks), byte-lookup results, or literals. - -- Compared one limb at a time, each packed inside the branch that - -- needs it: a mismatch in an early group returns without ever packing - -- the later ones. Width is set by the widest path, so this costs the - -- same as comparing all five at once and executes strictly less. - let pa1 = ((((((to_field(a7) * 256) + to_field(a6)) * 256 + - to_field(a5)) * 256 + to_field(a4)) * 256 + - to_field(a3)) * 256 + to_field(a2)) * 256 + to_field(a1); - let pb1 = ((((((to_field(b7) * 256) + to_field(b6)) * 256 + - to_field(b5)) * 256 + to_field(b4)) * 256 + - to_field(b3)) * 256 + to_field(b2)) * 256 + to_field(b1); - match pa1 - pb1 { - 0 => - let pa2 = ((((((to_field(a14) * 256) + to_field(a13)) * 256 + - to_field(a12)) * 256 + to_field(a11)) * 256 + - to_field(a10)) * 256 + to_field(a9)) * 256 + to_field(a8); - let pb2 = ((((((to_field(b14) * 256) + to_field(b13)) * 256 + - to_field(b12)) * 256 + to_field(b11)) * 256 + - to_field(b10)) * 256 + to_field(b9)) * 256 + to_field(b8); - match pa2 - pb2 { - 0 => - let pa3 = ((((((to_field(a21) * 256) + to_field(a20)) * 256 + - to_field(a19)) * 256 + to_field(a18)) * 256 + - to_field(a17)) * 256 + to_field(a16)) * 256 + - to_field(a15); - let pb3 = ((((((to_field(b21) * 256) + to_field(b20)) * 256 + - to_field(b19)) * 256 + to_field(b18)) * 256 + - to_field(b17)) * 256 + to_field(b16)) * 256 + - to_field(b15); - match pa3 - pb3 { - 0 => - let pa4 = ((((((to_field(a28) * 256) + to_field(a27)) * 256 + - to_field(a26)) * 256 + to_field(a25)) * 256 + - to_field(a24)) * 256 + to_field(a23)) * 256 + - to_field(a22); - let pb4 = ((((((to_field(b28) * 256) + to_field(b27)) * 256 + - to_field(b26)) * 256 + to_field(b25)) * 256 + - to_field(b24)) * 256 + to_field(b23)) * 256 + - to_field(b22); - match pa4 - pb4 { - 0 => - let pa5 = ((to_field(a31) * 256) + to_field(a30)) * 256 + - to_field(a29); - let pb5 = ((to_field(b31) * 256) + to_field(b30)) * 256 + - to_field(b29); - match pa5 - pb5 { - 0 => 1, - _ => 0, - }, - _ => 0, - }, - _ => 0, - }, - _ => 0, - }, - _ => 0, - } - } - - -- Content equality over all 32 bytes. Sound in BOTH directions, and - -- therefore the only comparison that may decide anything about two - -- addresses. - -- - -- Byte-0 prefilter: one differing byte proves inequality, and nearly - -- every comparison — the primitive-dispatch gauntlet in whnf above all - -- — mismatches at byte 0, so hot rows reject at narrow width and only - -- byte-0 matches pay the wide tail. Result is identical to a flat - -- 32-byte compare. - fn address_eq(a: Addr, b: Addr) -> G { - let av = load(a); - let bv = load(b); - match to_field(av[0]) - to_field(bv[0]) { - 0 => address_eq_tail(a, b), - _ => 0, - } - } - - fn list_length‹T›(list: List‹T›) -> G { - match load(list) { - ListNode.Nil => 0, - ListNode.Cons(_, rest) => list_length(rest) + 1, - } - } - - -- Scalar u32 successor with overflow forbidden. Reuse the shared comparison - -- so its range checks are memoized across all callers. - fn checked_depth_succ(depth: G) -> G { - assert_eq!(memo_u32_less_than(depth, 0xFFFFFFFF), 1, - "list depth exceeds u32"); - depth + 1 - } - - fn list_length_u64‹T›(list: List‹T›) -> U64 { - match load(list) { - ListNode.Nil => [0u8; 8], - ListNode.Cons(_, rest) => relaxed_u64_succ(list_length_u64(rest)), - } - } - - fn list_concat‹T›(a: List‹T›, b: List‹T›) -> List‹T› { - match load(a) { - ListNode.Nil => b, - ListNode.Cons(v, rest) => store(ListNode.Cons(v, list_concat(rest, b))), - } - } - - fn list_is_empty‹T›(list: List‹T›) -> G { - match load(list) { - ListNode.Nil => 1, - ListNode.Cons(_, _) => 0, - } - } - - fn list_lookup‹T›(list: List‹T›, idx: G) -> T { - let ListNode.Cons(v, _) = load(list_drop(list, idx)); - v - } - - fn list_lookup_or_default‹T›(list: List‹T›, idx: G, default: T) -> T { - match load(list_drop(list, idx)) { - ListNode.Nil => default, - ListNode.Cons(v, _) => v, - } - } - - fn list_lookup_u64‹T›(list: List‹T›, idx: U64) -> T { - let ListNode.Cons(v, rest) = load(list); - let z = u64_is_zero(idx); - match z { - 1 => v, - 0 => list_lookup_u64(rest, relaxed_u64_pred(idx)), - } - } - - fn list_drop‹T›(list: List‹T›, n: G) -> List‹T› { - match n { - 0 => list, - _ => - let ListNode.Cons(_, rest) = load(list_drop(list, n - 1)); - rest, - } - } - - fn list_take‹T›(list: List‹T›, n: G) -> List‹T› { - match n { - 0 => store(ListNode.Nil), - _ => - let ListNode.Cons(v, rest) = load(list); - store(ListNode.Cons(v, list_take(rest, n - 1))), - } - } - - fn list_snoc‹T›(list: List‹T›, v: T) -> List‹T› { - match load(list) { - ListNode.Nil => store(ListNode.Cons(v, store(ListNode.Nil))), - ListNode.Cons(head, rest) => store(ListNode.Cons(head, list_snoc(rest, v))), - } - } - - -- O(N) reverse via accumulator. Used by hot-path builders that - -- accumulate via cons (O(1)) then reverse once instead of O(N²) snoc. - fn list_reverse‹T›(list: List‹T›) -> List‹T› { - list_reverse_acc(list, store(ListNode.Nil)) - } - - fn list_reverse_acc‹T›(list: List‹T›, acc: List‹T›) -> List‹T› { - match load(list) { - ListNode.Nil => acc, - ListNode.Cons(head, rest) => - list_reverse_acc(rest, store(ListNode.Cons(head, acc))), - } - } -⟧ - -end Aiur.Library - -end diff --git a/Ix/Aiur/Meta.lean b/Ix/Aiur/Meta.lean deleted file mode 100644 index d0e7cea5a..000000000 --- a/Ix/Aiur/Meta.lean +++ /dev/null @@ -1,846 +0,0 @@ -module -public import Lean.Elab -public import Lean.Elab.Term.TermElabM -public import Ix.Aiur.Stages.Source - -/-! -Surface DSL for `Aiur.Source.Toplevel` — direct port of `Ix/Aiur/Meta.lean` -with the `.data`-wrapped tuple/array/field constructors inlined to match -`Aiur.Source.Term`'s flat shape. - -Usage: -``` -def myProgram : Source.Toplevel := ⟦ - pub fn add(a: G, b: G) -> G { - a + b - } -⟧ -``` --/ - -public meta section - -namespace Aiur - -open Lean Elab Meta Source - -abbrev ElabStxCat name := TSyntax name → TermElabM Expr - -declare_syntax_cat aiur_typ -syntax "G" : aiur_typ -syntax "U8" : aiur_typ -syntax "(" aiur_typ (", " aiur_typ)* ")" : aiur_typ -syntax "[" aiur_typ "; " num "]" : aiur_typ -syntax "&" aiur_typ : aiur_typ -syntax ("." noWs)? ident : aiur_typ -syntax ("." noWs)? ident "‹" aiur_typ (", " aiur_typ)* "›" : aiur_typ -syntax "fn" "(" ")" " -> " aiur_typ : aiur_typ -syntax "fn" "(" aiur_typ (", " aiur_typ)* ")" " -> " aiur_typ : aiur_typ - -declare_syntax_cat aiur_pattern -syntax ("." noWs)? ident : aiur_pattern -syntax "_" : aiur_pattern -syntax ident "(" aiur_pattern (", " aiur_pattern)* ")" : aiur_pattern -syntax num : aiur_pattern -syntax:max num "u8" : aiur_pattern -syntax "(" aiur_pattern (", " aiur_pattern)* ")" : aiur_pattern -syntax "[" aiur_pattern (", " aiur_pattern)* "]" : aiur_pattern -syntax aiur_pattern "|" aiur_pattern : aiur_pattern -syntax "&" aiur_pattern : aiur_pattern -syntax ident "‹" aiur_typ (", " aiur_typ)* "›" "." noWs ident - "(" aiur_pattern (", " aiur_pattern)* ")" : aiur_pattern -syntax ident "‹" aiur_typ (", " aiur_typ)* "›" "." noWs ident : aiur_pattern - -def elabListCore (head : α) (tail : Array α) (elabFn : α → TermElabM Expr) - (listEltType : Expr) (isArray := false) : TermElabM Expr := do - let mut elaborated := Array.mkEmpty (tail.size + 1) - elaborated := elaborated.push $ ← elabFn head - for elt in tail do - elaborated := elaborated.push $ ← elabFn elt - if isArray - then mkArrayLit listEltType elaborated.toList - else mkListLit listEltType elaborated.toList - -def elabList (head : α) (tail : Array α) (elabFn : α → TermElabM Expr) - (listEltTypeName : Name) (isArray := false) : TermElabM Expr := - elabListCore head tail elabFn (mkConst listEltTypeName) isArray - -def elabEmptyList (listEltTypeName : Name) : TermElabM Expr := - mkListLit (mkConst listEltTypeName) [] - -def elabG (n : TSyntax `num) : TermElabM Expr := - mkAppM ``G.ofNat #[mkNatLit n.getNat] - -partial def elabTyp : ElabStxCat `aiur_typ - | `(aiur_typ| G) => pure $ mkConst ``Typ.field - | `(aiur_typ| U8) => pure $ mkConst ``Typ.u8 - | `(aiur_typ| ($t:aiur_typ $[, $ts:aiur_typ]*)) => do - mkAppM ``Typ.tuple #[← elabList t ts elabTyp ``Typ true] - | `(aiur_typ| [$t:aiur_typ; $n:num]) => do - mkAppM ``Typ.array #[← elabTyp t, mkNatLit n.getNat] - | `(aiur_typ| &$t:aiur_typ) => do - mkAppM ``Typ.pointer #[← elabTyp t] - | `(aiur_typ| $[.]?$i:ident) => do - let g ← mkAppM ``Global.mk #[toExpr i.getId] - mkAppM ``Typ.ref #[g] - | `(aiur_typ| fn() -> $t:aiur_typ) => do - mkAppM ``Typ.function #[← elabEmptyList ``Typ, ← elabTyp t] - | `(aiur_typ| fn($t$[, $ts:aiur_typ]*) -> $t':aiur_typ) => do - mkAppM ``Typ.function #[← elabList t ts elabTyp ``Typ, ← elabTyp t'] - | `(aiur_typ| $[.]?$i:ident‹$t:aiur_typ $[, $ts:aiur_typ]*›) => do - let g ← mkAppM ``Global.mk #[toExpr i.getId] - mkAppM ``Typ.app #[g, ← elabList t ts elabTyp ``Typ true] - | stx => throw $ .error stx "Invalid syntax for type" - -partial def elabPattern : ElabStxCat `aiur_pattern - | `(aiur_pattern| $v:ident($p:aiur_pattern $[, $ps:aiur_pattern]*)) => do - let g ← mkAppM ``Global.mk #[toExpr v.getId] - mkAppM ``Pattern.ref #[g, ← elabList p ps elabPattern ``Pattern] - | `(aiur_pattern| .$i:ident) => do - let g ← mkAppM ``Global.mk #[toExpr i.getId] - mkAppM ``Pattern.ref #[g, ← elabEmptyList ``Pattern] - | `(aiur_pattern| $i:ident) => match i.getId with - | .str .anonymous name => do - mkAppM ``Pattern.var #[← mkAppM ``Local.str #[toExpr name]] - | name@(.str _ _) => do - let g ← mkAppM ``Global.mk #[toExpr name] - mkAppM ``Pattern.ref #[g, ← elabEmptyList ``Pattern] - | _ => throw $ .error i "Illegal pattern name" - | `(aiur_pattern| _) => pure $ mkConst ``Pattern.wildcard - | `(aiur_pattern| $n:num) => do mkAppM ``Pattern.field #[← elabG n] - -- `Nu8` byte-literal pattern: same `Pattern.field` value, kept for clarity - -- when matching a `U8` scrutinee. - | `(aiur_pattern| $n:num u8) => do mkAppM ``Pattern.field #[← elabG n] - | `(aiur_pattern| ($p:aiur_pattern $[, $ps:aiur_pattern]*)) => do - mkAppM ``Pattern.tuple #[← elabList p ps elabPattern ``Pattern true] - | `(aiur_pattern| [$p:aiur_pattern $[, $ps:aiur_pattern]*]) => do - mkAppM ``Pattern.array #[← elabList p ps elabPattern ``Pattern true] - | `(aiur_pattern| $p₁:aiur_pattern | $p₂:aiur_pattern) => do - mkAppM ``Pattern.or #[← elabPattern p₁, ← elabPattern p₂] - | `(aiur_pattern| &$p:aiur_pattern) => do - mkAppM ``Pattern.pointer #[← elabPattern p] - | `(aiur_pattern| $tmpl:ident‹$_:aiur_typ $[, $_:aiur_typ]*›.$ctor:ident - ($p:aiur_pattern $[, $ps:aiur_pattern]*)) => do - let name := tmpl.getId ++ ctor.getId - let g ← mkAppM ``Global.mk #[toExpr name] - mkAppM ``Pattern.ref #[g, ← elabList p ps elabPattern ``Pattern] - | `(aiur_pattern| $tmpl:ident‹$_:aiur_typ $[, $_:aiur_typ]*›.$ctor:ident) => do - let name := tmpl.getId ++ ctor.getId - let g ← mkAppM ``Global.mk #[toExpr name] - mkAppM ``Pattern.ref #[g, ← elabEmptyList ``Pattern] - | stx => throw $ .error stx "Invalid syntax for pattern" - -declare_syntax_cat aiur_trm -syntax ("." noWs)? ident : aiur_trm -syntax num : aiur_trm -syntax "(" ")" : aiur_trm -syntax "(" aiur_trm (", " aiur_trm)* ")" : aiur_trm --- Array elements and `return` operands parse at prec 1: it keeps the --- statement-sequencing rule (prec 0, below `let`) out of expression --- positions and keeps `[t; n]` replicate vs `[t]` list unambiguous. -syntax "[" aiur_trm:1 (", " aiur_trm:1)* "]" : aiur_trm -syntax "[" aiur_trm:1 "; " num "]" : aiur_trm -syntax "return " aiur_trm:1 : aiur_trm --- `let` right-hand sides parse at prec 1 so the statement-sequencing rule --- (prec 0, below) can't swallow the `let`'s own `;` and continuation. -syntax "let " aiur_pattern (":" aiur_typ)? " = " aiur_trm:1 "; " aiur_trm : aiur_trm -syntax "let " aiur_pattern (":" aiur_typ)? " = " aiur_trm:1 ";" : aiur_trm -syntax "let " aiur_pattern (":" aiur_typ)? " = " aiur_trm:1 : aiur_trm --- Statement sequencing: `t; rest` discards `t`'s value (elaborates to --- `let _ = t; rest`); trailing `t;` closes the block with `()`. Lets --- unit-returning calls sit in statement position without `let _ =`. -syntax:0 aiur_trm "; " (aiur_trm)? : aiur_trm -syntax "match " aiur_trm " { " - (aiur_pattern " => " aiur_trm ", ")+ " }" : aiur_trm -syntax ("." noWs)? ident "(" ")" : aiur_trm -syntax ("." noWs)? ident "(" aiur_trm (", " aiur_trm)* ")" : aiur_trm -syntax "#" noWs ("." noWs)? ident "(" ")" : aiur_trm -syntax "#" noWs ("." noWs)? ident "(" aiur_trm (", " aiur_trm)* ")" : aiur_trm --- Inlined call: `@fn(args)` splices `fn`'s body into the caller at compile --- time (no separate circuit). Callee must not be inline-recursive. -syntax "@" noWs ("." noWs)? ident "(" ")" : aiur_trm -syntax "@" noWs ("." noWs)? ident "(" aiur_trm (", " aiur_trm)* ")" : aiur_trm -syntax ident "‹" aiur_typ (", " aiur_typ)* "›" "(" ")" : aiur_trm -syntax ident "‹" aiur_typ (", " aiur_typ)* "›" "(" aiur_trm - (", " aiur_trm)* ")" : aiur_trm -syntax "#" noWs ident "‹" aiur_typ (", " aiur_typ)* "›" "(" ")" : aiur_trm -syntax "#" noWs ident "‹" aiur_typ (", " aiur_typ)* "›" "(" aiur_trm - (", " aiur_trm)* ")" : aiur_trm -syntax ident "‹" aiur_typ (", " aiur_typ)* "›" "." noWs ident "(" ")" : aiur_trm -syntax ident "‹" aiur_typ (", " aiur_typ)* "›" "." noWs ident - "(" aiur_trm (", " aiur_trm)* ")" : aiur_trm --- Standard left-associative binary operators (`+`/`-` at prec 50, `*` at --- prec 60). Right operands have min-prec ≥ 51 so the statement-sequencing --- rule (prec 0) cannot swallow `; rest` from inside the right --- operand. -syntax:50 aiur_trm:50 " + " aiur_trm:51 : aiur_trm -syntax:50 aiur_trm:50 " - " aiur_trm:51 : aiur_trm -syntax:60 aiur_trm:60 " * " aiur_trm:61 : aiur_trm -syntax "eq_zero" "(" aiur_trm ")" : aiur_trm -syntax "proj" "(" aiur_trm ", " num ")" : aiur_trm -syntax aiur_trm "[" num "]" : aiur_trm -syntax aiur_trm "[" num ".." num "]" : aiur_trm -syntax "set" "(" aiur_trm ", " num ", " aiur_trm ")" : aiur_trm -syntax "store" "(" aiur_trm ")" : aiur_trm -syntax "load" "(" aiur_trm ")" : aiur_trm -syntax "ptr_val" "(" aiur_trm ")" : aiur_trm -syntax "assert_eq!" "(" aiur_trm ", " aiur_trm (", " str)? ")" ";" (aiur_trm)? : aiur_trm -syntax aiur_trm ": " aiur_typ : aiur_trm -syntax "io_get_info" "(" aiur_trm ", " aiur_trm ")" : aiur_trm -syntax "io_set_info" "(" aiur_trm ", " aiur_trm ", " aiur_trm ", " aiur_trm ")" ";" - (aiur_trm)? : aiur_trm -syntax "io_read" "(" aiur_trm ", " aiur_trm ", " num ")" : aiur_trm -syntax "io_write" "(" aiur_trm ", " aiur_trm ")" ";" (aiur_trm)? : aiur_trm -syntax "u8_bit_decomposition" "(" aiur_trm ")" : aiur_trm -syntax "u8_shift_left" "(" aiur_trm ")" : aiur_trm -syntax "u8_shift_right" "(" aiur_trm ")" : aiur_trm -syntax "u8_xor" "(" aiur_trm ", " aiur_trm ")" : aiur_trm -syntax "u8_add" "(" aiur_trm ", " aiur_trm ")" : aiur_trm -syntax "u8_mul" "(" aiur_trm ", " aiur_trm ")" : aiur_trm -syntax "u8_xor_split7" "(" aiur_trm ", " aiur_trm ")" : aiur_trm -syntax "u8_xor_split4" "(" aiur_trm ", " aiur_trm ")" : aiur_trm -syntax "u8_sub" "(" aiur_trm ", " aiur_trm ")" : aiur_trm -syntax "u8_and" "(" aiur_trm ", " aiur_trm ")" : aiur_trm -syntax "u8_or" "(" aiur_trm ", " aiur_trm ")" : aiur_trm -syntax "u8_less_than" "(" aiur_trm ", " aiur_trm ")" : aiur_trm -syntax "u32_less_than" "(" aiur_trm ", " aiur_trm ")" : aiur_trm -syntax "unconstrained_u32_add" "(" aiur_trm ", " aiur_trm ")" : aiur_trm -syntax "unconstrained_u32_add3" "(" aiur_trm ", " aiur_trm ", " aiur_trm ")" : aiur_trm -syntax "u32_to_field" "(" aiur_trm ")" : aiur_trm -syntax "u8_range_check" "(" aiur_trm ", " aiur_trm ")" : aiur_trm -syntax "unconstrained_big_uint_div_mod" "(" aiur_trm ", " aiur_trm ")" : aiur_trm -syntax "unconstrained_g_to_bytes" "(" aiur_trm ")" : aiur_trm -syntax "unconstrained_g_inverse" "(" aiur_trm ")" : aiur_trm -syntax "to_field" "(" aiur_trm ")" : aiur_trm -syntax "u8_from_field_unsafe" "(" aiur_trm ")" : aiur_trm -syntax:max num "u8" : aiur_trm -syntax "dbg!" "(" str (", " aiur_trm)? ")" ";" (aiur_trm)? : aiur_trm - -syntax aiur_trm "[" "@" noWs ident "]" : aiur_trm -syntax "set" "(" aiur_trm ", " "@" noWs ident ", " aiur_trm ")" : aiur_trm -syntax "fold" "(" num ".." num ", " aiur_trm ", " "|" aiur_pattern ", " "@" noWs ident "|" aiur_trm ")" : aiur_trm - -partial def elabTrm : ElabStxCat `aiur_trm - | `(aiur_trm| .$i:ident) => do - mkAppM ``Source.Term.ref #[← mkAppM ``Global.mk #[toExpr i.getId]] - | `(aiur_trm| $i:ident) => match i.getId with - | .str .anonymous name => do - mkAppM ``Source.Term.var #[← mkAppM ``Local.str #[toExpr name]] - | name@(.str _ _) => do - mkAppM ``Source.Term.ref #[← mkAppM ``Global.mk #[toExpr name]] - | _ => throw $ .error i "Illegal name" - | `(aiur_trm| $n:num) => do - -- Aiur.Source.Term has `.field` directly (no `.data` wrapper). - mkAppM ``Source.Term.field #[← elabG n] - | `(aiur_trm| ()) => pure $ mkConst ``Source.Term.unit - | `(aiur_trm| ($t:aiur_trm $[, $ts:aiur_trm]*)) => do - if ts.isEmpty then elabTrm t - else - mkAppM ``Source.Term.tuple #[← elabList t ts elabTrm ``Source.Term true] - | `(aiur_trm| [$t:aiur_trm $[, $ts:aiur_trm]*]) => do - mkAppM ``Source.Term.array #[← elabList t ts elabTrm ``Source.Term true] - | `(aiur_trm| [$t:aiur_trm; $n:num]) => do - let ts ← mkArrayLit (mkConst ``Source.Term) (.replicate n.getNat (← elabTrm t)) - mkAppM ``Source.Term.array #[ts] - | `(aiur_trm| return $t:aiur_trm) => do - mkAppM ``Source.Term.ret #[← elabTrm t] - | `(aiur_trm| let $p:aiur_pattern $[: $ty:aiur_typ]? = $t:aiur_trm; $t':aiur_trm) => - match ty with - | none => do mkAppM ``Source.Term.let #[← elabPattern p, ← elabTrm t, ← elabTrm t'] - | some ty => do - let t ← mkAppM ``Source.Term.ann #[← elabTyp ty, ← elabTrm t] - mkAppM ``Source.Term.let #[← elabPattern p, t, ← elabTrm t'] - | `(aiur_trm| let $p:aiur_pattern $[: $ty:aiur_typ]? = $t:aiur_trm;) => - match ty with - | none => do mkAppM ``Source.Term.let #[← elabPattern p, ← elabTrm t, mkConst ``Source.Term.unit] - | some ty => do - let t ← mkAppM ``Source.Term.ann #[← elabTyp ty, ← elabTrm t] - mkAppM ``Source.Term.let #[← elabPattern p, t, mkConst ``Source.Term.unit] - | `(aiur_trm| let $p:aiur_pattern $[: $ty:aiur_typ]? = $t:aiur_trm) => - match ty with - | none => do mkAppM ``Source.Term.let #[← elabPattern p, ← elabTrm t, mkConst ``Source.Term.unit] - | some ty => do - let t ← mkAppM ``Source.Term.ann #[← elabTyp ty, ← elabTrm t] - mkAppM ``Source.Term.let #[← elabPattern p, t, mkConst ``Source.Term.unit] - | `(aiur_trm| $t:aiur_trm; $[$t':aiur_trm]?) => do - mkAppM ``Source.Term.let - #[mkConst ``Pattern.wildcard, ← elabTrm t, ← elabRet t'] - | `(aiur_trm| match $t:aiur_trm {$[$ps:aiur_pattern => $ts:aiur_trm,]*}) => do - let mut prods := Array.mkEmpty (ps.size + 1) - for (p, t) in ps.zip ts do - prods := prods.push $ ← mkAppM ``Prod.mk #[← elabPattern p, ← elabTrm t] - let prodType ← mkAppM ``Prod #[mkConst ``Pattern, mkConst ``Source.Term] - mkAppM ``Source.Term.match #[← elabTrm t, ← mkListLit prodType prods.toList] - | `(aiur_trm| $[.]?$f:ident ()) => do - match f.getId with - | .str .anonymous _ => pure () - | _ => logWarningAt f "empty parentheses are not needed; use the name without parentheses" - let g ← mkAppM ``Global.mk #[toExpr f.getId] - mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, mkConst ``Source.CallMode.normal] - | `(aiur_trm| $[.]?$f:ident ($a:aiur_trm $[, $as:aiur_trm]*)) => do - let g ← mkAppM ``Global.mk #[toExpr f.getId] - mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, mkConst ``Source.CallMode.normal] - | `(aiur_trm| #$[.]?$f:ident()) => do - let g ← mkAppM ``Global.mk #[toExpr f.getId] - mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, mkConst ``Source.CallMode.unconstrained] - | `(aiur_trm| #$[.]?$f:ident($a:aiur_trm $[, $as:aiur_trm]*)) => do - let g ← mkAppM ``Global.mk #[toExpr f.getId] - mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, mkConst ``Source.CallMode.unconstrained] - | `(aiur_trm| @$[.]?$f:ident()) => do - let g ← mkAppM ``Global.mk #[toExpr f.getId] - mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, mkConst ``Source.CallMode.inlined] - | `(aiur_trm| @$[.]?$f:ident($a:aiur_trm $[, $as:aiur_trm]*)) => do - let g ← mkAppM ``Global.mk #[toExpr f.getId] - mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, mkConst ``Source.CallMode.inlined] - | `(aiur_trm| $a:aiur_trm + $b:aiur_trm) => do - mkAppM ``Source.Term.add #[← elabTrm a, ← elabTrm b] - | `(aiur_trm| $a:aiur_trm - $b:aiur_trm) => do - mkAppM ``Source.Term.sub #[← elabTrm a, ← elabTrm b] - | `(aiur_trm| $a:aiur_trm * $b:aiur_trm) => do - mkAppM ``Source.Term.mul #[← elabTrm a, ← elabTrm b] - | `(aiur_trm| eq_zero($a:aiur_trm)) => do - mkAppM ``Source.Term.eqZero #[← elabTrm a] - | `(aiur_trm| proj($a:aiur_trm, $i:num)) => do - mkAppM ``Source.Term.proj #[← elabTrm a, toExpr i.getNat] - | `(aiur_trm| $t:aiur_trm[$i:num]) => do - mkAppM ``Source.Term.get #[← elabTrm t, toExpr i.getNat] - | `(aiur_trm| $t:aiur_trm[$i:num .. $j:num]) => do - mkAppM ``Source.Term.slice #[← elabTrm t, toExpr i.getNat, toExpr j.getNat] - | `(aiur_trm| set($a:aiur_trm, $i:num, $v:aiur_trm)) => do - mkAppM ``Source.Term.set #[← elabTrm a, toExpr i.getNat, ← elabTrm v] - | `(aiur_trm| store($a:aiur_trm)) => do - mkAppM ``Source.Term.store #[← elabTrm a] - | `(aiur_trm| load($a:aiur_trm)) => do - mkAppM ``Source.Term.load #[← elabTrm a] - | `(aiur_trm| ptr_val($a:aiur_trm)) => do - mkAppM ``Source.Term.ptrVal #[← elabTrm a] - | `(aiur_trm| assert_eq!($a:aiur_trm, $b:aiur_trm $[, $msg:str]?); $[$ret:aiur_trm]?) => do - let msgExpr ← match msg with - | some m => mkAppM ``Option.some #[mkStrLit m.getString] - | none => mkAppOptM ``Option.none #[Lean.mkConst ``String] - mkAppM ``Source.Term.assertEq #[← elabTrm a, ← elabTrm b, msgExpr, ← elabRet ret] - | `(aiur_trm| $v:aiur_trm : $t:aiur_typ) => do - mkAppM ``Source.Term.ann #[← elabTyp t, ← elabTrm v] - | `(aiur_trm| io_get_info($ch:aiur_trm, $key:aiur_trm)) => do - mkAppM ``Source.Term.ioGetInfo #[← elabTrm ch, ← elabTrm key] - | `(aiur_trm| io_set_info($ch:aiur_trm, $key:aiur_trm, $idx:aiur_trm, $len:aiur_trm); $[$ret:aiur_trm]?) => do - mkAppM ``Source.Term.ioSetInfo - #[← elabTrm ch, ← elabTrm key, ← elabTrm idx, ← elabTrm len, ← elabRet ret] - | `(aiur_trm| io_read($ch:aiur_trm, $idx:aiur_trm, $len:num)) => do - mkAppM ``Source.Term.ioRead #[← elabTrm ch, ← elabTrm idx, mkNatLit len.getNat] - | `(aiur_trm| io_write($ch:aiur_trm, $data:aiur_trm); $[$ret:aiur_trm]?) => do - mkAppM ``Source.Term.ioWrite #[← elabTrm ch, ← elabTrm data, ← elabRet ret] - | `(aiur_trm| u8_bit_decomposition($byte:aiur_trm)) => do - mkAppM ``Source.Term.u8BitDecomposition #[← elabTrm byte] - | `(aiur_trm| u8_shift_left($byte:aiur_trm)) => do - mkAppM ``Source.Term.u8ShiftLeft #[← elabTrm byte] - | `(aiur_trm| u8_shift_right($byte:aiur_trm)) => do - mkAppM ``Source.Term.u8ShiftRight #[← elabTrm byte] - | `(aiur_trm| u8_xor($i:aiur_trm, $j:aiur_trm)) => do - mkAppM ``Source.Term.u8Xor #[← elabTrm i, ← elabTrm j] - | `(aiur_trm| u8_add($i:aiur_trm, $j:aiur_trm)) => do - mkAppM ``Source.Term.u8Add #[← elabTrm i, ← elabTrm j] - | `(aiur_trm| u8_mul($i:aiur_trm, $j:aiur_trm)) => do - mkAppM ``Source.Term.u8Mul #[← elabTrm i, ← elabTrm j] - | `(aiur_trm| u8_xor_split7($i:aiur_trm, $j:aiur_trm)) => do - mkAppM ``Source.Term.u8XorSplit7 #[← elabTrm i, ← elabTrm j] - | `(aiur_trm| u8_xor_split4($i:aiur_trm, $j:aiur_trm)) => do - mkAppM ``Source.Term.u8XorSplit4 #[← elabTrm i, ← elabTrm j] - | `(aiur_trm| u8_sub($i:aiur_trm, $j:aiur_trm)) => do - mkAppM ``Source.Term.u8Sub #[← elabTrm i, ← elabTrm j] - | `(aiur_trm| u8_and($i:aiur_trm, $j:aiur_trm)) => do - mkAppM ``Source.Term.u8And #[← elabTrm i, ← elabTrm j] - | `(aiur_trm| u8_or($i:aiur_trm, $j:aiur_trm)) => do - mkAppM ``Source.Term.u8Or #[← elabTrm i, ← elabTrm j] - | `(aiur_trm| u8_less_than($i:aiur_trm, $j:aiur_trm)) => do - mkAppM ``Source.Term.u8LessThan #[← elabTrm i, ← elabTrm j] - | `(aiur_trm| u32_less_than($i:aiur_trm, $j:aiur_trm)) => do - mkAppM ``Source.Term.u32LessThan #[← elabTrm i, ← elabTrm j] - | `(aiur_trm| unconstrained_u32_add($i:aiur_trm, $j:aiur_trm)) => do - mkAppM ``Source.Term.unconstrainedU32Add #[← elabTrm i, ← elabTrm j] - | `(aiur_trm| unconstrained_u32_add3($i:aiur_trm, $j:aiur_trm, $k:aiur_trm)) => do - mkAppM ``Source.Term.unconstrainedU32Add3 #[← elabTrm i, ← elabTrm j, ← elabTrm k] - | `(aiur_trm| u32_to_field($a:aiur_trm)) => do - mkAppM ``Source.Term.u32ToField #[← elabTrm a] - | `(aiur_trm| u8_range_check($i:aiur_trm, $j:aiur_trm)) => do - mkAppM ``Source.Term.u8RangeCheck #[← elabTrm i, ← elabTrm j] - | `(aiur_trm| unconstrained_big_uint_div_mod($a:aiur_trm, $b:aiur_trm)) => do - mkAppM ``Source.Term.unconstrainedBigUintDivMod #[← elabTrm a, ← elabTrm b] - | `(aiur_trm| unconstrained_g_to_bytes($a:aiur_trm)) => do - mkAppM ``Source.Term.unconstrainedGToBytes #[← elabTrm a] - | `(aiur_trm| unconstrained_g_inverse($a:aiur_trm)) => do - mkAppM ``Source.Term.unconstrainedGInverse #[← elabTrm a] - | `(aiur_trm| to_field($a:aiur_trm)) => do - mkAppM ``Source.Term.toField #[← elabTrm a] - | `(aiur_trm| u8_from_field_unsafe($a:aiur_trm)) => do - mkAppM ``Source.Term.u8FromFieldUnsafe #[← elabTrm a] - | `(aiur_trm| $n:num u8) => do - mkAppM ``Source.Term.u8Lit #[mkNatLit n.getNat] - | `(aiur_trm| dbg!($label:str $[, $t:aiur_trm]?); $[$ret:aiur_trm]?) => do - let t ← match t with - | none => mkAppOptM ``Option.none #[some (mkConst ``Source.Term)] - | some t => mkAppM ``Option.some #[← elabTrm t] - mkAppM ``Source.Term.debug #[mkStrLit label.getString, t, ← elabRet ret] - -- Template function calls: explicit type args are dropped (inferred) - | `(aiur_trm| $f:ident‹$_:aiur_typ $[, $_:aiur_typ]*›()) => do - let g ← mkAppM ``Global.mk #[toExpr f.getId] - mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, mkConst ``Source.CallMode.normal] - | `(aiur_trm| $f:ident‹$_:aiur_typ $[, $_:aiur_typ]*› - ($a:aiur_trm $[, $as:aiur_trm]*)) => do - let g ← mkAppM ``Global.mk #[toExpr f.getId] - mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, mkConst ``Source.CallMode.normal] - | `(aiur_trm| #$f:ident‹$_:aiur_typ $[, $_:aiur_typ]*›()) => do - let g ← mkAppM ``Global.mk #[toExpr f.getId] - mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, mkConst ``Source.CallMode.unconstrained] - | `(aiur_trm| #$f:ident‹$_:aiur_typ $[, $_:aiur_typ]*› - ($a:aiur_trm $[, $as:aiur_trm]*)) => do - let g ← mkAppM ``Global.mk #[toExpr f.getId] - mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, mkConst ``Source.CallMode.unconstrained] - -- Template constructor calls - | `(aiur_trm| $tmpl:ident‹$_:aiur_typ $[, $_:aiur_typ]*›.$ctor:ident()) => do - logWarningAt ctor "empty parentheses are not needed; use the name without parentheses" - let name := tmpl.getId ++ ctor.getId - let g ← mkAppM ``Global.mk #[toExpr name] - mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, mkConst ``Source.CallMode.normal] - | `(aiur_trm| $tmpl:ident‹$_:aiur_typ $[, $_:aiur_typ]*›.$ctor:ident - ($a:aiur_trm $[, $as:aiur_trm]*)) => do - let name := tmpl.getId ++ ctor.getId - let g ← mkAppM ``Global.mk #[toExpr name] - mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, mkConst ``Source.CallMode.normal] - | `(aiur_trm| fold($i .. $j, $init, |$acc, @$v| $body)) => do - let i := i.getNat - let j := j.getNat - let range := if i ≤ j then List.range' i (j - i) - else (List.range' j (i - j)).reverse - let mut res := init - for n in range do - let body' ← replaceToken v.getId n body - res ← `(aiur_trm| let $acc = $res; $body') - elabTrm res - | `(aiur_trm| $_[@$var]) => throw $ .error var "Unbound macro variable" - | `(aiur_trm| set($_, @$var, $_)) => throw $ .error var "Unbound macro variable" - | stx => throw $ .error stx "Invalid syntax for term" -where - elabRet : Option (TSyntax `aiur_trm) → TermElabM Expr - | none => pure $ mkConst ``Source.Term.unit - | some ret => elabTrm ret - replaceToken (old : Name) (new : Nat) : TSyntax `aiur_trm → TermElabM (TSyntax `aiur_trm) - | `(aiur_trm| $arr[@$var]) => do - let arr ← replaceToken old new arr - if var.getId = old then - let new := Syntax.mkNatLit new - `(aiur_trm| $arr[$new]) - else `(aiur_trm| $arr[@$var]) - | `(aiur_trm| set($arr, @$var, $v)) => do - let arr ← replaceToken old new arr - let v ← replaceToken old new v - if var.getId = old then - let new := Syntax.mkNatLit new - `(aiur_trm| set($arr, $new, $v)) - else `(aiur_trm| set($arr, @$var, $v)) - | `(aiur_trm| ($t $[, $ts]*)) => do - let t ← replaceToken old new t - let ts ← ts.mapM $ replaceToken old new - `(aiur_trm| ($t $[, $ts]*)) - | `(aiur_trm| [$t $[, $ts]*]) => do - let t ← replaceToken old new t - let ts ← ts.mapM $ replaceToken old new - `(aiur_trm| [$t $[, $ts]*]) - | `(aiur_trm| [$t; $n]) => do - let t ← replaceToken old new t - `(aiur_trm| [$t; $n]) - | `(aiur_trm| return $t:aiur_trm) => do - let t ← replaceToken old new t - `(aiur_trm| return $t) - | `(aiur_trm| let $p:aiur_pattern $[: $ty]? = $t:aiur_trm; $t':aiur_trm) => do - let t ← replaceToken old new t - let t' ← replaceToken old new t' - `(aiur_trm| let $p $[: $ty]? = $t; $t') - | `(aiur_trm| let $p:aiur_pattern $[: $ty]? = $t:aiur_trm;) => do - let t ← replaceToken old new t - `(aiur_trm| let $p $[: $ty]? = $t;) - | `(aiur_trm| let $p:aiur_pattern $[: $ty]? = $t:aiur_trm) => do - let t ← replaceToken old new t - `(aiur_trm| let $p $[: $ty]? = $t) - | `(aiur_trm| match $t:aiur_trm {$[$ps:aiur_pattern => $ts:aiur_trm,]*}) => do - let t ← replaceToken old new t - let ts ← ts.mapM $ replaceToken old new - `(aiur_trm| match $t {$[$ps:aiur_pattern => $ts:aiur_trm,]*}) - | `(aiur_trm| $[.%$dot]?$f:ident ($a:aiur_trm $[, $as:aiur_trm]*)) => do - let a ← replaceToken old new a - let as ← as.mapM $ replaceToken old new - if dot.isSome then `(aiur_trm| .$f:ident ($a $[, $as]*)) - else `(aiur_trm| $f:ident ($a $[, $as]*)) - | `(aiur_trm| #$[.%$dot]?$f:ident($a:aiur_trm $[, $as:aiur_trm]*)) => do - let a ← replaceToken old new a - let as ← as.mapM $ replaceToken old new - if dot.isSome then `(aiur_trm| #.$f:ident($a $[, $as]*)) - else `(aiur_trm| #$f:ident($a $[, $as]*)) - | `(aiur_trm| $a + $b) => do - let a ← replaceToken old new a - let b ← replaceToken old new b - `(aiur_trm| $a + $b) - | `(aiur_trm| $a - $b) => do - let a ← replaceToken old new a - let b ← replaceToken old new b - `(aiur_trm| $a - $b) - | `(aiur_trm| $a * $b) => do - let a ← replaceToken old new a - let b ← replaceToken old new b - `(aiur_trm| $a * $b) - | `(aiur_trm| eq_zero($a:aiur_trm)) => do - let a ← replaceToken old new a - `(aiur_trm| eq_zero($a)) - | `(aiur_trm| proj($a:aiur_trm, $i:num)) => do - let a ← replaceToken old new a - `(aiur_trm| proj($a, $i)) - | `(aiur_trm| $t:aiur_trm[$i:num]) => do - let t ← replaceToken old new t - `(aiur_trm| $t[$i]) - | `(aiur_trm| $t:aiur_trm[$i:num..$j:num]) => do - let t ← replaceToken old new t - `(aiur_trm| $t[$i..$j]) - | `(aiur_trm| set($a:aiur_trm, $i:num, $v:aiur_trm)) => do - let a ← replaceToken old new a - let v ← replaceToken old new v - `(aiur_trm| set($a, $i, $v)) - | `(aiur_trm| store($a:aiur_trm)) => do - let a ← replaceToken old new a - `(aiur_trm| store($a)) - | `(aiur_trm| load($a:aiur_trm)) => do - let a ← replaceToken old new a - `(aiur_trm| load($a)) - | `(aiur_trm| ptr_val($a:aiur_trm)) => do - let a ← replaceToken old new a - `(aiur_trm| ptr_val($a)) - | `(aiur_trm| assert_eq!($a:aiur_trm, $b:aiur_trm $[, $msg:str]?); $[$ret:aiur_trm]?) => do - let a ← replaceToken old new a - let b ← replaceToken old new b - let ret' ← ret.mapM $ replaceToken old new - `(aiur_trm| assert_eq!($a, $b $[, $msg]?); $[$ret']?) - | `(aiur_trm| $v:aiur_trm : $t:aiur_typ) => do - let v ← replaceToken old new v - `(aiur_trm| $v : $t) - | `(aiur_trm| io_get_info($ch:aiur_trm, $key:aiur_trm)) => do - let ch ← replaceToken old new ch - let key ← replaceToken old new key - `(aiur_trm| io_get_info($ch, $key)) - | `(aiur_trm| io_set_info($ch:aiur_trm, $key:aiur_trm, $idx:aiur_trm, $len:aiur_trm); $[$ret:aiur_trm]?) => do - let ch ← replaceToken old new ch - let key ← replaceToken old new key - let idx ← replaceToken old new idx - let len ← replaceToken old new len - let ret' ← ret.mapM $ replaceToken old new - `(aiur_trm| io_set_info($ch, $key, $idx, $len); $[$ret']?) - | `(aiur_trm| io_read($ch:aiur_trm, $idx:aiur_trm, $len:num)) => do - let ch ← replaceToken old new ch - let idx ← replaceToken old new idx - `(aiur_trm| io_read($ch, $idx, $len)) - | `(aiur_trm| io_write($ch:aiur_trm, $data:aiur_trm); $[$ret:aiur_trm]?) => do - let ch ← replaceToken old new ch - let data ← replaceToken old new data - let ret' ← ret.mapM $ replaceToken old new - `(aiur_trm| io_write($ch, $data); $[$ret']?) - | `(aiur_trm| u8_bit_decomposition($byte:aiur_trm)) => do - let byte ← replaceToken old new byte - `(aiur_trm| u8_bit_decomposition($byte)) - | `(aiur_trm| u8_shift_left($byte:aiur_trm)) => do - let byte ← replaceToken old new byte - `(aiur_trm| u8_shift_left($byte)) - | `(aiur_trm| u8_shift_right($byte:aiur_trm)) => do - let byte ← replaceToken old new byte - `(aiur_trm| u8_shift_right($byte)) - | `(aiur_trm| u8_xor($i:aiur_trm, $j:aiur_trm)) => do - let i ← replaceToken old new i - let j ← replaceToken old new j - `(aiur_trm| u8_xor($i, $j)) - | `(aiur_trm| u8_add($i:aiur_trm, $j:aiur_trm)) => do - let i ← replaceToken old new i - let j ← replaceToken old new j - `(aiur_trm| u8_add($i, $j)) - | `(aiur_trm| u8_mul($i:aiur_trm, $j:aiur_trm)) => do - let i ← replaceToken old new i - let j ← replaceToken old new j - `(aiur_trm| u8_mul($i, $j)) - | `(aiur_trm| u8_xor_split7($i:aiur_trm, $j:aiur_trm)) => do - let i ← replaceToken old new i - let j ← replaceToken old new j - `(aiur_trm| u8_xor_split7($i, $j)) - | `(aiur_trm| u8_xor_split4($i:aiur_trm, $j:aiur_trm)) => do - let i ← replaceToken old new i - let j ← replaceToken old new j - `(aiur_trm| u8_xor_split4($i, $j)) - | `(aiur_trm| u8_sub($i:aiur_trm, $j:aiur_trm)) => do - let i ← replaceToken old new i - let j ← replaceToken old new j - `(aiur_trm| u8_sub($i, $j)) - | `(aiur_trm| u8_and($i:aiur_trm, $j:aiur_trm)) => do - let i ← replaceToken old new i - let j ← replaceToken old new j - `(aiur_trm| u8_and($i, $j)) - | `(aiur_trm| u8_or($i:aiur_trm, $j:aiur_trm)) => do - let i ← replaceToken old new i - let j ← replaceToken old new j - `(aiur_trm| u8_or($i, $j)) - | `(aiur_trm| u8_less_than($i:aiur_trm, $j:aiur_trm)) => do - let i ← replaceToken old new i - let j ← replaceToken old new j - `(aiur_trm| u8_less_than($i, $j)) - | `(aiur_trm| u32_less_than($i:aiur_trm, $j:aiur_trm)) => do - let i ← replaceToken old new i - let j ← replaceToken old new j - `(aiur_trm| u32_less_than($i, $j)) - | `(aiur_trm| unconstrained_u32_add($i:aiur_trm, $j:aiur_trm)) => do - let i ← replaceToken old new i - let j ← replaceToken old new j - `(aiur_trm| unconstrained_u32_add($i, $j)) - | `(aiur_trm| unconstrained_u32_add3($i:aiur_trm, $j:aiur_trm, $k:aiur_trm)) => do - let i ← replaceToken old new i - let j ← replaceToken old new j - let k ← replaceToken old new k - `(aiur_trm| unconstrained_u32_add3($i, $j, $k)) - | `(aiur_trm| u32_to_field($a:aiur_trm)) => do - let a ← replaceToken old new a - `(aiur_trm| u32_to_field($a)) - | `(aiur_trm| u8_range_check($i:aiur_trm, $j:aiur_trm)) => do - let i ← replaceToken old new i - let j ← replaceToken old new j - `(aiur_trm| u8_range_check($i, $j)) - | `(aiur_trm| unconstrained_big_uint_div_mod($a:aiur_trm, $b:aiur_trm)) => do - let a ← replaceToken old new a - let b ← replaceToken old new b - `(aiur_trm| unconstrained_big_uint_div_mod($a, $b)) - | `(aiur_trm| unconstrained_g_to_bytes($a:aiur_trm)) => do - let a ← replaceToken old new a - `(aiur_trm| unconstrained_g_to_bytes($a)) - | `(aiur_trm| unconstrained_g_inverse($a:aiur_trm)) => do - let a ← replaceToken old new a - `(aiur_trm| unconstrained_g_inverse($a)) - | `(aiur_trm| to_field($a:aiur_trm)) => do - let a ← replaceToken old new a - `(aiur_trm| to_field($a)) - | `(aiur_trm| u8_from_field_unsafe($a:aiur_trm)) => do - let a ← replaceToken old new a - `(aiur_trm| u8_from_field_unsafe($a)) - | `(aiur_trm| dbg!($label:str $[, $t:aiur_trm]?); $[$ret:aiur_trm]?) => do - let t' ← t.mapM $ replaceToken old new - let ret' ← ret.mapM $ replaceToken old new - `(aiur_trm| dbg!($label $[, $t']?); $[$ret']?) - | `(aiur_trm| fold($i .. $j, $init, |$acc, @$v| $body)) => do - let init ← replaceToken old new init - -- Don't conflict with shadowing tokens. - let body ← if v.getId = old then pure body - else replaceToken old new body - `(aiur_trm| fold($i .. $j, $init, |$acc, @$v| $body)) - | `(aiur_trm| $t:aiur_trm; $[$t':aiur_trm]?) => do - let t ← replaceToken old new t - let t' ← t'.mapM $ replaceToken old new - `(aiur_trm| $t; $[$t']?) - | stx => pure stx - -declare_syntax_cat aiur_constructor -syntax ident : aiur_constructor -syntax ident "(" aiur_typ (", " aiur_typ)* ")" : aiur_constructor - -def elabConstructor : ElabStxCat `aiur_constructor - | `(aiur_constructor| $i:ident) => match i.getId with - | .str .anonymous name => do - mkAppM ``Constructor.mk #[toExpr name, ← elabEmptyList ``Typ] - | _ => throw $ .error i "Illegal constructor name" - | `(aiur_constructor| $i:ident($t:aiur_typ$[, $ts:aiur_typ]*)) => match i.getId with - | .str .anonymous name => do - mkAppM ``Constructor.mk #[toExpr name, ← elabList t ts elabTyp ``Typ] - | _ => throw $ .error i "Illegal constructor name" - | stx => throw $ .error stx "Invalid syntax for constructor" - -def elabTypeParams (head : TSyntax `ident) (tail : Array (TSyntax `ident)) : - TermElabM (Array String × Expr) := do - let mut params := #[] - for p in #[head] ++ tail do - match p.getId with - | .str .anonymous name => params := params.push name - | _ => throw $ .error p "Illegal type parameter name" - let expr ← mkListLit (mkConst ``String) (params.map toExpr).toList - pure (params, expr) - -declare_syntax_cat aiur_data_type -syntax "enum " ident : aiur_data_type -syntax "enum " ident "{" aiur_constructor - (", " aiur_constructor)* "}" : aiur_data_type -syntax "enum " ident "‹" ident (", " ident)* "›" : aiur_data_type -syntax "enum " ident "‹" ident (", " ident)* "›" "{" - aiur_constructor (", " aiur_constructor)* "}" : aiur_data_type - -def elabDataType : ElabStxCat `aiur_data_type - | `(aiur_data_type| enum $n:ident) => do - let g ← mkAppM ``Global.mk #[toExpr n.getId] - mkAppM ``DataType.mk #[g, ← elabEmptyList ``String, ← elabEmptyList ``Constructor] - | `(aiur_data_type| enum $n:ident - {$c:aiur_constructor $[, $cs:aiur_constructor]*}) => do - let g ← mkAppM ``Global.mk #[toExpr n.getId] - mkAppM ``DataType.mk - #[g, ← elabEmptyList ``String, - ← elabList c cs elabConstructor ``Constructor] - | `(aiur_data_type| enum $n:ident‹$p:ident $[, $ps:ident]*›) => do - let g ← mkAppM ``Global.mk #[toExpr n.getId] - let (_, paramsExpr) ← elabTypeParams p ps - mkAppM ``DataType.mk #[g, paramsExpr, ← elabEmptyList ``Constructor] - | `(aiur_data_type| enum $n:ident‹$p:ident $[, $ps:ident]*› - {$c:aiur_constructor $[, $cs:aiur_constructor]*}) => do - let g ← mkAppM ``Global.mk #[toExpr n.getId] - let (_, paramsExpr) ← elabTypeParams p ps - mkAppM ``DataType.mk - #[g, paramsExpr, ← elabList c cs elabConstructor ``Constructor] - | stx => throw $ .error stx "Invalid syntax for data type" - -declare_syntax_cat aiur_type_alias -syntax "type " ident " = " aiur_typ : aiur_type_alias -syntax "type " ident "‹" ident (", " ident)* "›" " = " aiur_typ : aiur_type_alias - -def elabTypeAlias : ElabStxCat `aiur_type_alias - | `(aiur_type_alias| type $n:ident = $t:aiur_typ) => do - let g ← mkAppM ``Global.mk #[toExpr n.getId] - mkAppM ``TypeAlias.mk #[g, ← elabEmptyList ``String, ← elabTyp t] - | `(aiur_type_alias| type $n:ident‹$p:ident $[, $ps:ident]*› = $t:aiur_typ) => do - let g ← mkAppM ``Global.mk #[toExpr n.getId] - let (_, paramsExpr) ← elabTypeParams p ps - mkAppM ``TypeAlias.mk #[g, paramsExpr, ← elabTyp t] - | stx => throw $ .error stx "Invalid syntax for type alias" - -declare_syntax_cat aiur_bind -syntax ident ": " aiur_typ : aiur_bind - -def elabBind : ElabStxCat `aiur_bind - | `(aiur_bind| $i:ident: $t:aiur_typ) => match i.getId with - | .str .anonymous name => do - mkAppM ``Prod.mk #[← mkAppM ``Local.str #[toExpr name], ← elabTyp t] - | _ => throw $ .error i "Illegal variable name" - | stx => throw $ .error stx "Invalid syntax for binding" - -declare_syntax_cat aiur_function -syntax ("pub ")? "fn " ident "(" ")" (" -> " aiur_typ)? "{" aiur_trm "}" : aiur_function -syntax ("pub ")? "fn " ident "(" aiur_bind (", " aiur_bind)* ")" - (" -> " aiur_typ)? "{" aiur_trm "}" : aiur_function -syntax "fn " ident "‹" ident (", " ident)* "›" "(" ")" - (" -> " aiur_typ)? "{" aiur_trm "}" : aiur_function -syntax "fn " ident "‹" ident (", " ident)* "›" - "(" aiur_bind (", " aiur_bind)* ")" - (" -> " aiur_typ)? "{" aiur_trm "}" : aiur_function - -def elabFunction : ElabStxCat `aiur_function - | `(aiur_function| $[pub%$e]? fn $i:ident() $[-> $ty:aiur_typ]? {$t:aiur_trm}) => do - let g ← mkAppM ``Global.mk #[toExpr i.getId] - let bindType ← mkAppM ``Prod #[mkConst ``Local, mkConst ``Typ] - let inputs ← mkListLit bindType [] - let output ← elabRetTyp ty - let body ← elabTrm t - mkMonoFun e g inputs output body - | `(aiur_function| $[pub%$e]? fn $i:ident($b:aiur_bind $[, $bs:aiur_bind]*) - $[-> $ty:aiur_typ]? {$t:aiur_trm}) => do - let g ← mkAppM ``Global.mk #[toExpr i.getId] - let bindType ← mkAppM ``Prod #[mkConst ``Local, mkConst ``Typ] - let inputs ← elabListCore b bs elabBind bindType - let output ← elabRetTyp ty - let body ← elabTrm t - mkMonoFun e g inputs output body - | `(aiur_function| fn $i:ident‹$p:ident $[, $ps:ident]*›() - $[-> $ty:aiur_typ]? {$t:aiur_trm}) => do - let g ← mkAppM ``Global.mk #[toExpr i.getId] - let (_, paramsExpr) ← elabTypeParams p ps - let bindType ← mkAppM ``Prod #[mkConst ``Local, mkConst ``Typ] - mkAppM ``Source.Function.poly - #[g, paramsExpr, ← mkListLit bindType [], - ← elabRetTyp ty, ← elabTrm t] - | `(aiur_function| fn $i:ident‹$p:ident $[, $ps:ident]*› - ($b:aiur_bind $[, $bs:aiur_bind]*) - $[-> $ty:aiur_typ]? {$t:aiur_trm}) => do - let g ← mkAppM ``Global.mk #[toExpr i.getId] - let (_, paramsExpr) ← elabTypeParams p ps - let bindType ← mkAppM ``Prod #[mkConst ``Local, mkConst ``Typ] - mkAppM ``Source.Function.poly - #[g, paramsExpr, - ← elabListCore b bs elabBind bindType, - ← elabRetTyp ty, ← elabTrm t] - | stx => throw $ .error stx "Invalid syntax for function" -where - elabRetTyp : Option (TSyntax `aiur_typ) → TermElabM Expr - | none => pure $ mkConst ``Typ.unit - | some typ => elabTyp typ - /-- Build a monomorphic `Source.Function`. If `pubKw?` is `some _` - (public/entry function), require a `sigPointerFree` proof: signatures - with `.pointer` types are rejected with a Meta-level error. -/ - mkMonoFun (pubKw? : Option Syntax) (name inputs output body : Expr) : - TermElabM Expr := do - match pubKw? with - | none => - mkAppM ``Source.Function.monoNonEntry #[name, inputs, output, body] - | some kw => - let sigExpr ← mkAppM ``Source.sigPointerFree #[inputs, output] - let propExpr ← mkAppM ``Eq #[sigExpr, mkConst ``Bool.true] - let proof ← - try - Lean.Meta.mkDecideProof propExpr - catch _ => - throw $ .error kw - "Public (entry) function signatures cannot contain pointer types" - mkAppM ``Source.Function.monoEntry #[name, inputs, output, body, proof] - -declare_syntax_cat aiur_declaration -syntax aiur_function : aiur_declaration -syntax aiur_data_type : aiur_declaration -syntax aiur_type_alias : aiur_declaration - -def accElabDeclarations (declarations : (Array Expr × Array Expr × Array Expr)) - (stx : TSyntax `aiur_declaration) : - TermElabM (Array Expr × Array Expr × Array Expr) := - let (dataTypes, typeAliases, functions) := declarations - match stx with - | `(aiur_declaration| $f:aiur_function) => do - pure (dataTypes, typeAliases, functions.push $ ← elabFunction f) - | `(aiur_declaration| $d:aiur_data_type) => do - pure (dataTypes.push $ ← elabDataType d, typeAliases, functions) - | `(aiur_declaration| $ta:aiur_type_alias) => do - pure (dataTypes, typeAliases.push $ ← elabTypeAlias ta, functions) - | stx => throw $ .error stx "Invalid syntax for declaration" - -declare_syntax_cat aiur_toplevel -syntax aiur_declaration* : aiur_toplevel - -def elabToplevel : ElabStxCat `aiur_toplevel - | `(aiur_toplevel| $[$ds:aiur_declaration]*) => do - let (dataTypes, typeAliases, functions) ← - ds.foldlM (init := default) accElabDeclarations - mkAppM ``Source.Toplevel.mk #[ - ← mkArrayLit (mkConst ``DataType) dataTypes.toList, - ← mkArrayLit (mkConst ``TypeAlias) typeAliases.toList, - ← mkArrayLit (mkConst ``Source.Function) functions.toList, - ] - | stx => throw $ .error stx "Invalid syntax for toplevel" - -elab "⟦" t:aiur_toplevel "⟧" : term => elabToplevel t - --- Verify left-associativity and relative precedence of `+`, `-`, `*`, and `;`. -run_cmd do - match ← `(aiur_trm| a - b - c) with - | `(aiur_trm| $lhs:aiur_trm - $_) => - unless (match lhs with | `(aiur_trm| $_ - $_) => true | _ => false) do - throwError "expected `a - b - c` to parse as `(a - b) - c`" - | _ => throwError "expected outer `-` in `a - b - c`" - match ← `(aiur_trm| a * b * c) with - | `(aiur_trm| $lhs:aiur_trm * $_) => - unless (match lhs with | `(aiur_trm| $_ * $_) => true | _ => false) do - throwError "expected `a * b * c` to parse as `(a * b) * c`" - | _ => throwError "expected outer `*` in `a * b * c`" - match ← `(aiur_trm| a - b + c * d; e) with - | `(aiur_trm| $expr:aiur_trm; $_) => - match expr with - | `(aiur_trm| $sub:aiur_trm + $mul:aiur_trm) => - unless (match sub with | `(aiur_trm| $_ - $_) => true | _ => false) && - (match mul with | `(aiur_trm| $_ * $_) => true | _ => false) do - throwError "expected `a - b + c * d` to parse as `(a - b) + (c * d)`" - | _ => throwError "expected outer `+` in `a - b + c * d`" - | _ => throwError "expected outer `;` in `a - b + c * d; e`" - -end Aiur - -end diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index ca685ff75..32e88a44c 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -1,50 +1,90 @@ module +public import Std.Data.HashMap +public import Ix.Aiur.Goldilocks public import Ix.Address -public import Ix.Aiur.Semantics.BytecodeFfi /-! -AiurSystem, Proof, FRI params, and `buildClaim` — the "prove & verify" FFI surface. - -Bytecode execution lives in `Ix/Aiur/Semantics/BytecodeFfi.lean`. -Domain-specific verifier and aggregation entrypoints live in -`MultiStark/FFI.lean` and `Ix/Aggr/FFI.lean`. +Pure Lean protocol types (`IOBuffer`, `QueryCount`, `CommitmentParameters`, +`FriParameters`, `ShardRetention`, `buildClaim`) and Rust-backed environment / +manifest FFI (`EnvHandle`, `shardManifestRefine`, +`detectedRamBudgetBytes`). -/ public section namespace Aiur -private opaque PoofNonempty : NonemptyType -def Proof : Type := PoofNonempty.type -instance : Nonempty Proof := PoofNonempty.property +structure IOKeyInfo where + idx : Nat + len : Nat + deriving DecidableEq + +instance : BEq IOKeyInfo where + beq a b := a.idx == b.idx && a.len == b.len + +instance : LawfulBEq IOKeyInfo where + eq_of_beq {a b} h := by + simp [BEq.beq, Bool.and_eq_true] at h + cases a; cases b; simp_all + rfl {a} := by simp [BEq.beq] + +structure IOBuffer where + /-- Per-channel data arenas. `idx` slots into `data[channel]`. -/ + data : Std.HashMap G (Array G) + /-- Channel-keyed info map. Same `key` on different channels resolves + to distinct `IOKeyInfo`. -/ + map : Std.HashMap (G × Array G) IOKeyInfo + deriving Inhabited + +/-- Append `data` to the `channel` arena and register `key → (idx, len)` +on the same channel. -/ +def IOBuffer.extend (ioBuffer : IOBuffer) (channel : G) (key data : Array G) : + IOBuffer := + let arena := ioBuffer.data.getD channel #[] + let idx := arena.size + let len := data.size + { ioBuffer with + data := ioBuffer.data.insert channel (arena ++ data) + map := ioBuffer.map.insert (channel, key) { idx, len } } + +/-- Rebuild an `IOBuffer` from the flat arrays produced by the Rust FFI. -/ +def IOBuffer.ofArrays (data : Array (G × Array G)) + (map : Array ((G × Array G) × IOKeyInfo)) : IOBuffer := + ⟨data.foldl (fun acc (k, v) => acc.insert k v) ∅, + map.foldl (fun acc (k, v) => acc.insert k v) ∅⟩ + +instance : BEq IOBuffer where + beq x y := + @BEq.beq _ Std.HashMap.instBEq x.data y.data && + @BEq.beq _ Std.HashMap.instBEq x.map y.map + +/-- Per-circuit query counts for one circuit. -/ +structure QueryCount where + uniqueRows : Nat + totalHits : Nat + deriving Inhabited + +private opaque EnvHandleNonempty : NonemptyType +def EnvHandle : Type := EnvHandleNonempty.type +instance : Nonempty EnvHandle := EnvHandleNonempty.property -namespace Proof +namespace EnvHandle -@[extern "rs_aiur_proof_to_bytes"] -opaque toBytes : @& Proof → ByteArray +@[extern "rs_aiur_env_handle_from_ixe"] +private opaque fromIxe' : @& ByteArray → Except String EnvHandle -@[extern "rs_aiur_proof_of_bytes"] -opaque ofBytes : @& ByteArray → Proof +/-- Load an `EnvHandle` from a `.ixe` file path (UTF-8 ByteArray). -/ +def fromIxe (path : String) : Except String EnvHandle := + fromIxe' path.toUTF8 -/-- The trace shards this batch holds: one for an unbudgeted prove, more -when a budget split the execution's rows. -/ -@[extern "rs_aiur_proof_shard_count"] -opaque shardCount : @& Proof → Nat +@[extern "rs_aiur_env_handle_from_bytes"] +private opaque fromBytes' : @& ByteArray → Except String EnvHandle -/-- Decode an untrusted serialized proof without aborting the process. Store -and network boundaries must use this variant; `ofBytes` remains for callers -whose bytes were produced in-process or already validated. -/ -@[extern "rs_aiur_proof_of_bytes_checked"] -opaque ofBytesChecked : @& ByteArray → Except String Proof +/-- Build an `EnvHandle` from a serialized env blob. -/ +def fromBytes (bytes : ByteArray) : Except String EnvHandle := + fromBytes' bytes -/-- The advice of a range-sum recursion node over shards `[lo, hi)` of this -batch: the serialized preamble (headers and messages, the prefix of the -batch's own encoding), the range's proofs as one length-prefixed vector, and -the range's residual sum as two little-endian `u64` limbs. -/ -@[extern "rs_aiur_proof_range_advice"] -opaque rangeAdvice : @& Proof → @& Nat → @& Nat → - Except String (ByteArray × ByteArray × ByteArray) -end Proof +end EnvHandle structure CommitmentParameters where logBlowup : Nat @@ -57,9 +97,6 @@ structure FriParameters where commitProofOfWorkBits : Nat queryProofOfWorkBits : Nat -/-- Canonical Aiur parameters, shared by `ix prove`, `ix verify`, and the -`ix check` statistics. Until these become flags / commit to the proof -header, every flow MUST use the same values or proofs won't verify. -/ def defaultCommitmentParameters : CommitmentParameters := { logBlowup := 2, capHeight := 0 } @@ -71,12 +108,6 @@ def defaultFriParameters : FriParameters := { queryProofOfWorkBits := 20 } -/-- Shape of one compiled circuit, built directly by Rust -(`LeanAiurCircuitShape` in `crates/ffi/src/lean.rs`; field order must -match). Heights of function and memory circuits are execution-dependent -and are not part of the shape; `preprocessedHeight` doubles as the fixed -trace height of the byte-gadget circuits (256 and 65536), whose witness -builders always emit the full table. -/ structure CircuitShape where mainWidth : Nat stage2Width : Nat @@ -85,140 +116,7 @@ structure CircuitShape where preprocessedHeight : Nat deriving Inhabited -private opaque AiurSystemNonempty : NonemptyType -def AiurSystem : Type := AiurSystemNonempty.type -instance : Nonempty AiurSystem := AiurSystemNonempty.property - -/-- Result of a prove FFI call, built directly by Rust -(`LeanAiurProveResult` in `crates/ffi/src/lean.rs`). `ioData`/`ioMap` -are the flattened `IOBuffer`; see `IOBuffer.ofArrays`. -/ -structure ProveResult where - claim : Array G - proof : Proof - ioData : Array (G × Array G) - ioMap : Array ((G × Array G) × IOKeyInfo) - deriving Nonempty - -/-- Result of a with-env prove FFI call, built directly by Rust -(`LeanAiurProveEnvResult` in `crates/ffi/src/lean.rs`). `claimBytes` -is the claim's wire serialization (`ixon::Claim::put`). -/ -structure ProveEnvResult where - claimBytes : ByteArray - proof : Proof - ioData : Array (G × Array G) - ioMap : Array ((G × Array G) × IOKeyInfo) - deriving Nonempty - -namespace AiurSystem - -@[extern "rs_aiur_system_build"] -opaque build : @&Bytecode.Toplevel → @&CommitmentParameters → @&FriParameters → AiurSystem - -/-- Serialize the verifying key (`System`) to bytes. -/ -@[extern "rs_aiur_system_vk_bytes"] -opaque vkBytes : @& AiurSystem → ByteArray - -/-- Per-circuit shapes in canonical system order: constrained functions -(ascending index), memories, `Bytes1`, `Bytes2`. -/ -@[extern "rs_aiur_system_circuit_shapes"] -opaque circuitShapes : @& AiurSystem → Array CircuitShape - -@[extern "rs_aiur_system_prove"] -private opaque prove' : @& AiurSystem → - @& Bytecode.FunIdx → @& Array G → - (ioData : @& Array (G × Array G)) → - (ioMap : @& Array ((G × Array G) × IOKeyInfo)) → - Except String ProveResult - -/-- Executes the bytecode function `funIdx` with the given `args` and `ioBuffer`, -then generates a proof of the computation. Returns the claim -(`#[functionChannel, funIdx] ++ args ++ output`), the `Proof`, and the -updated `IOBuffer`. -/ -def prove (system : @& AiurSystem) - (funIdx : @& Bytecode.FunIdx) (args : @& Array G) (ioBuffer : IOBuffer) : - Except String (Array G × Proof × IOBuffer) := - (prove' system funIdx args ioBuffer.data.toArray ioBuffer.map.toArray).map - fun r => (r.claim, r.proof, .ofArrays r.ioData r.ioMap) - -@[extern "rs_aiur_system_prove_ixvm"] -private opaque proveIxVM' : @& AiurSystem → - @& Bytecode.FunIdx → @& Array G → - (ioData : @& Array (G × Array G)) → - (ioMap : @& Array ((G × Array G) × IOKeyInfo)) → - @& Nat → Bool → - Except String ProveResult - -/-- IxVM-native prove: same shape as `prove`, but routes execution - through the codegen'd Rust kernel (`execute_generated`) instead - of the bytecode interpreter. The resulting `Proof` is - verification-compatible with one from `prove`. Only valid when - `system.toplevel` is the IxVM kernel's bytecode. - - With `traceShards`, the execution is gated against `maxRamBytes` - (`0`: detect 85% of `MemAvailable`) and an over-budget record is - proven as a batch of trace shards within that budget. -/ -def proveIxVM (system : @& AiurSystem) - (funIdx : @& Bytecode.FunIdx) (args : @& Array G) (ioBuffer : IOBuffer) - (maxRamBytes : Nat := 0) (traceShards : Bool := false) : - Except String (Array G × Proof × IOBuffer) := - (proveIxVM' system funIdx args ioBuffer.data.toArray ioBuffer.map.toArray - maxRamBytes traceShards).map - fun r => (r.claim, r.proof, .ofArrays r.ioData r.ioMap) - -@[extern "rs_aiur_system_prove_addr_with_env"] -private opaque proveAddrWithEnv' : @& AiurSystem → - @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool → Bool → - Except String ProveEnvResult - -/-- Per-claim prove against a Rust-owned `EnvHandle`. Returns - `(claimBytes, proof, ioBuffer)` — Rust serializes the - reconstructed `Ix.Claim` via `ixon::Claim::put` so Lean can - deserialize directly without re-running the closure walk. - `useBytecode` routes the witness-generating execution through the - generic Aiur bytecode interpreter instead of the codegen'd IxVM - kernel (same toggle as `checkAddrWithEnv`). -/ -def proveAddrWithEnv (system : @& AiurSystem) - (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) (addrBytes : ByteArray) - (useBytecode : Bool := false) (assumeBinding : Bool := false) : - Except String (ByteArray × Proof × IOBuffer) := - (proveAddrWithEnv' system funIdx envHandle addrBytes useBytecode assumeBinding).map - fun r => (r.claimBytes, r.proof, .ofArrays r.ioData r.ioMap) - -/-- Result of a per-shard prove: the claim's wire bytes, the proof, the - projected prover RAM peak of the record that produced it - (`AiurSystem::peak_prove_bytes`), and the part count the peak model - projects will fit the budget - (`AiurSystem::suggested_split_parts`). - - `proof` is `none` exactly when the peak exceeded the budget — a - RESULT rather than an error, since the caller's answer is to cut - the shard into `suggestedParts` parts and prove those. The count is - computed Rust-side because only there does the executed record - still exist to read per-circuit heights from; it is optimistic - (parts re-execute dependencies shared across the cut), so each part - must still be gated on its own record. `suggestedParts` is 1 - whenever the prove ran. The claim bytes are filled either way (the - claim is known before proving starts). - - The final IO buffer is not returned — it is the shard's whole - ingested byte scope and no caller reads it. -/ -structure ShardProveResult where - claimBytes : ByteArray - proof : Option Proof - peakBytes : Nat - suggestedParts : Nat - /-- `proveEnvDistributed` with `execOnly`: each worker's measured record - bytes, 8-byte LE per worker in manifest order; empty otherwise. -/ - workerBytes : ByteArray - -@[extern "rs_aiur_system_shard_prove_with_env"] -private opaque shardProveWithEnv' : @& AiurSystem → - @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → @& Nat → Bool → Bool → - @& Nat → Bool → Except String ShardProveResult - -/-- What a trace-shard batch keeps of each shard between its two rounds. - `auto` lets the prover's RAM model choose: retain when the whole - retained batch fits the budget, regenerate otherwise. -/ +/-- What a trace-shard batch keeps of each shard between its two rounds. -/ inductive ShardRetention where | auto | retain @@ -236,165 +134,6 @@ def ShardRetention.code : ShardRetention → Nat | .retain => 1 | .regenerate => 2 -/-- Per-shard prove against a Rust-owned `EnvHandle`: ONE execution, - whose record is proven from directly. - - `maxRamBytes` is a per-shard prover-RAM budget checked against that - record's projected peak before the witness phase begins; `0` means - detect (85% of `MemAvailable`, the policy the check batch's RAM gate - uses), and an unreadable `/proc/meminfo` disables the check rather - than guessing. Over budget, the record is dropped and `proof` is - `none` — learning that here costs one execution instead of an OOM - part-way through an FFT. The peak comes back either way, so a prove - run yields the same split/merge signal a check run does. - - `execOnly` stops after execution + measurement (`proof` is `none` - either way; `suggestedParts` is 1 exactly when the peak fits): the - split loop runs on executions alone, never starting a STARK. - - `traceShards` proves an over-budget record as a batch of trace - shards, each within the budget, instead of splitting it into parts; - `peakBytes` is then the heaviest shard's projection. Only when no - shard count fits does the result fall back to `suggestedParts`. - `retention` fixes what the batch keeps between its rounds, or lets - the RAM model choose. `assumeBinding` proves the claim assuming the - environment's binding meets the specifications (validator 4), for an - aggregate that discharges it once with a binding proof. -/ -def shardProveWithEnv (system : @& AiurSystem) - (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) - (ownedBlob : ByteArray) (maxRamBytes : Nat := 0) - (execOnly : Bool := false) (traceShards : Bool := false) - (retention : ShardRetention := .auto) (assumeBinding : Bool := false) : - Except String ShardProveResult := - shardProveWithEnv' system funIdx envHandle ownedBlob maxRamBytes execOnly - traceShards retention.code assumeBinding - -@[extern "rs_aiur_system_prove_env_distributed"] -private opaque proveEnvDistributed' : @& AiurSystem → - @& Bytecode.FunIdx → @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → - @& Nat → Bool → Bool → @& Nat → @& Nat → @& ByteArray → - Except String ShardProveResult - -/-- The whole environment as ONE claim, `CheckEnv(root, none)`, proven from - one worker record per element of `owners` (trace-sharding design - §13.3). Worker 0 runs `verify_claim` (`verifyIdx`) and defers every - `check_owned` (`checkOwnedIdx`) call for a constant it does not own; - every other worker runs `check_owned` over its chunk (the constants it - owns), in its own pointer namespace. The workers execute in parallel; - the records - are proven as one batch, each planned to `maxCells` committed cells - (`0`: one shard per record). `planOnly` stops after the static caller - graph and the commit order, reporting every worker's owned constants, - byte scope and callers and the largest group of mutually calling - workers (how many records the first round holds at once), without - executing; `execOnly` stops after execution and the absorption of the - deferred calls, reporting every record's size. Both leave `proof` - `none`. `peakBytes` is not measured (`0`). - - Records are proven in an order that lets a worker commit as soon as - every worker that calls into it has executed, at most `execJobs` - workers executing at once (`0`: all). Executions run ahead of the - prover as far as `maxRamBytes` (`0`: detect) leaves room for their - records beside the prover's working set, and a record stays resident - for its second round while that room lasts, so a worker executes twice - only when memory forces it. `measured` gives each worker's record - bytes as an earlier `execOnly` run measured them (the manifest's - measured-peaks section); without them nothing runs ahead until this - run has measured a record. -/ -def proveEnvDistributed (system : @& AiurSystem) - (verifyIdx checkOwnedIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) - (owners : Array (Array Address)) (maxCells : Nat := 0) - (planOnly : Bool := false) (execOnly : Bool := false) (execJobs : Nat := 0) - (maxRamBytes : Nat := 0) (measured : Array Nat := #[]) : - Except String ShardProveResult := - let u32le (n : Nat) : ByteArray := - ⟨#[(n &&& 0xFF).toUInt8, ((n >>> 8) &&& 0xFF).toUInt8, - ((n >>> 16) &&& 0xFF).toUInt8, ((n >>> 24) &&& 0xFF).toUInt8]⟩ - let header : ByteArray := - owners.foldl (fun (acc : ByteArray) (o : Array Address) => acc ++ u32le o.size) - (u32le owners.size) - let blob : ByteArray := - owners.foldl (fun (acc : ByteArray) (o : Array Address) => - o.foldl (fun (acc : ByteArray) (a : Address) => acc ++ a.hash) acc) header - let u64le (n : Nat) : ByteArray := - ⟨(Array.range 8).map fun i => ((n >>> (8 * i)) &&& 0xFF).toUInt8⟩ - let measuredBlob : ByteArray := measured.foldl - (fun (acc : ByteArray) (n : Nat) => acc ++ u64le n) ByteArray.empty - proveEnvDistributed' system verifyIdx checkOwnedIdx envHandle blob maxCells - planOnly execOnly execJobs maxRamBytes measuredBlob - -/-- One shard claim proven by `shardProveAheadWithEnv`: the claim's wire - bytes, the persisted proof wrapper's store address (hex) and the - heaviest trace shard's projected peak. -/ -structure ShardProvenAhead where - claimBytes : ByteArray - proofAddr : String - peakBytes : Nat - -@[extern "rs_aiur_system_shard_prove_ahead_with_env"] -private opaque shardProveAheadWithEnv' : @& AiurSystem → - @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → @& ByteArray → @& Nat → - @& Nat → @& Nat → @& String → @& String → - Bool → - Except String (Array ShardProvenAhead) - -/-- Several shard claims proven in order, each from one execution planned - as trace shards within `maxRamBytes`, with the executions running - ahead of the prover on threads — `execJobs` at once (`0`: one per - core), so peak host memory is the prover's budget plus the records in - flight. Every proof and its claim are written to the store under - `storeDir` and, unless `indexDir` is empty, recorded in the shard-proof - index as soon as they exist, so a killed run keeps what it finished. - `labels` are the shards' manifest indices, for the lines printed. Each claim - assumes the environment's binding meets the specifications (validator 4) - when `assumeBinding`, and validates it otherwise. -/ -def shardProveAheadWithEnv (system : @& AiurSystem) - (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) - (owners : Array (Array Address)) (labels : Array Nat) (maxRamBytes : Nat) - (retention : ShardRetention) (execJobs : Nat) (storeDir indexDir : String) - (assumeBinding : Bool := false) : - Except String (Array ShardProvenAhead) := - let u32le (n : Nat) : ByteArray := - ⟨#[(n &&& 0xFF).toUInt8, ((n >>> 8) &&& 0xFF).toUInt8, - ((n >>> 16) &&& 0xFF).toUInt8, ((n >>> 24) &&& 0xFF).toUInt8]⟩ - let header : ByteArray := - owners.foldl (fun (acc : ByteArray) (o : Array Address) => acc ++ u32le o.size) - (u32le owners.size) - let blob : ByteArray := - owners.foldl (fun (acc : ByteArray) (o : Array Address) => - o.foldl (fun (acc : ByteArray) (a : Address) => acc ++ a.hash) acc) header - let labelsBlob : ByteArray := - labels.foldl (fun (acc : ByteArray) (n : Nat) => acc ++ u32le n) ByteArray.empty - shardProveAheadWithEnv' system funIdx envHandle blob labelsBlob maxRamBytes - retention.code execJobs storeDir indexDir assumeBinding - -@[extern "rs_aiur_system_verify"] -opaque verify : @& AiurSystem → - @& Array G → @& Proof → Except String Unit - -/-- Verify and serialize a proof in the transport consumed by the in-circuit -recursive verifier. -/ -@[extern "rs_aiur_proof_to_advice_bytes"] -opaque proofToAdviceBytes : @& AiurSystem → - @& Array G → @& Proof → Except String ByteArray - -end AiurSystem - -/-- Refine an existing `.ixes` manifest (`sourcePath`) by cutting some of - its leaves into parts and write the result to `outPath` - (`ShardManifest::refine`, `crates/ixon/src/shard.rs`). Every other - leaf keeps its block list, record, id and place in the aggregation - tree; a refined leaf's place becomes a balanced subtree over its - parts, part 0 keeps the leaf's id and later parts take fresh ids after - the last existing one. - - `refinementsBlob`: `count(u32)`, then per refined leaf `id(u32) ‖ - nparts(u32)` and per part `nblocks(u32) ‖ 32·nblocks ‖ peak(u64)`. - `measuredBlob`: empty, or one `u64` analytic prover peak per SOURCE - shard in id order; a nonzero value overrides the peak carried forward - for an unsplit leaf. The new partition is validated as an exact, - disjoint cover of the env's blocks. Returns the parts' new ids: - `count(u32)`, then per refinement `n(u32) ‖ n × id(u32)`. -/ @[extern "rs_shard_manifest_refine"] opaque shardManifestRefine : @& EnvHandle → @& String → @& ByteArray → @& ByteArray → @& String → IO ByteArray @@ -402,76 +141,12 @@ opaque shardManifestRefine : @& EnvHandle → @& String → @[extern "rs_aiur_detected_ram_budget"] private opaque detectedRamBudgetFFI : IO UInt64 -/-- The prover/execution RAM budget the Rust side detects on this machine: - 85 % of `MemAvailable` (`ixon::shard::RAM_USABLE_FRAC`) — the policy - the check batch's RAM gate and `ix prove --max-ram 0` use. `0` when - `/proc/meminfo` is unreadable; callers that need a budget fail closed - on it instead of running ungated. -/ def detectedRamBudgetBytes : IO Nat := do pure (← detectedRamBudgetFFI).toNat -namespace Bytecode.Toplevel - -/-- One shard's result from `shardCheckBatchWithEnv`. -/ -structure ShardResult where - error : String - peakBytes : Nat - /-- 1 when `peakBytes` fits the batch's `maxRamBytes` (or no budget - was given); otherwise the part count the peak model projects will - fit (`AiurSystem::suggested_split_parts`, measured on the record - in-task). -/ - suggestedParts : Nat - deriving Inhabited +abbrev functionChannel : G := .ofNat 1 -@[extern "rs_aiur_toplevel_shard_check_batch"] -private opaque shardCheckBatchWithEnv' : @& Bytecode.Toplevel → - @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool → @& Nat → - @& CommitmentParameters → @& FriParameters → @& Nat → - Except String (Array ShardResult) - -/-- Check EVERY shard of a partition in one call: rayon over the shard - list with true work-stealing (no chunk barriers), each shard - through the exact single-shard machinery over its own private - record and witness io. `shardsBlob` encodes, per shard, a 4-byte LE - owned-constant count followed by that many 32-byte addresses. - Returns one `ShardResult` per shard in shard order: empty error = - clean, and `peakBytes` is the analytic prover RAM peak - ([`AiurSystem::peak_prove_bytes`] Rust-side) of the shard's executed - record — the split/merge input (0 on failure). - `jobs = 0` uses rayon's default pool width (all cores): peak RSS - is bounded by the Rust-side RAM gate (a byte-weighted admission - semaphore over estimated per-shard execution RSS vs available - system RAM), not by thread count — pass `jobs` only to narrow - CPU use. - - `maxRamBytes > 0` is a per-shard prover-RAM budget: each result's - `suggestedParts` is 1 when its peak fits and the model's projected - part count otherwise, so a caller can cut over-budget shards and - re-batch the parts — the wave loop that audits a partition's split - behavior on executions alone. -/ -def shardCheckBatchWithEnv (toplevel : @& Bytecode.Toplevel) - (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) - (shardsBlob : ByteArray) (useBytecode : Bool := false) (jobs : Nat := 0) - (commitmentParameters : CommitmentParameters := defaultCommitmentParameters) - (friParameters : FriParameters := defaultFriParameters) - (maxRamBytes : Nat := 0) - : Except String (Array ShardResult) := - shardCheckBatchWithEnv' toplevel funIdx envHandle shardsBlob useBytecode - jobs commitmentParameters friParameters maxRamBytes - -end Bytecode.Toplevel - -/-- One-shot variant of `AiurSystem.circuitShapes` for flows that never -build an `AiurSystem` (the `ix check` statistics): Rust builds the system, -extracts the shapes, and drops it. -/ -@[extern "rs_aiur_circuit_shapes"] -opaque circuitShapes : - @& Bytecode.Toplevel → @& CommitmentParameters → @& FriParameters → - Array CircuitShape - -abbrev functionChannel : G := .ofNat 0 - -def buildClaim (funIdx : Bytecode.FunIdx) (input output : Array G) := +def buildClaim (funIdx : Nat) (input output : Array G) : Array G := #[functionChannel, .ofNat funIdx] ++ input ++ output end Aiur diff --git a/Ix/Aiur/Semantics/BytecodeEval.lean b/Ix/Aiur/Semantics/BytecodeEval.lean deleted file mode 100644 index 7656bcec9..000000000 --- a/Ix/Aiur/Semantics/BytecodeEval.lean +++ /dev/null @@ -1,510 +0,0 @@ -module -public import Ix.Aiur.Stages.Bytecode -public import Ix.Aiur.Semantics.BytecodeFfi -public import Ix.IndexMap - -/-! -Lean-native bytecode reference evaluator. - -Mirrors `src/aiur/execute.rs` in big-step form: -- No `QueryRecord` (trace-side bookkeeping). -- No call cache. -- No `unconstrained` branching (both branches of every `if unconstrained` produce - the same value; they differ only in whether a query is logged). -- No stack machine — direct big-step. -- Call-only fuel decrement at `Op.call`. -- Errors return, never panic. - -Per-width memory buckets mirror Rust's `QueryRecord.memory_queries` -(`execute.rs:36-40`). Each `Op.store values` uses `values.size` as the width key. --/ - -public section -@[expose] section - -namespace Aiur - -namespace Bytecode.Eval - -/-- Width-bucketed memory, matching Rust's `QueryRecord.memory_queries`. -Outer key is the width; each bucket is an ordered map from flat-width arrays of -field elements to unit (the index within the bucket is its insertion order). -/ -abbrev MemoryBuckets := IndexMap Nat (IndexMap (Array G) Unit) - -structure EvalState where - map : Array G := #[] - memory : MemoryBuckets := default - ioBuffer : IOBuffer - deriving Inhabited - -/-- Opaque `Repr` so `BytecodeError` (whose `earlyReturn` sentinel carries -the state) can keep its derived instance; the state itself is not printable. -/ -instance : Repr EvalState := ⟨fun _ _ => .text ""⟩ - -/-- Tagged errors — small enum, no messages, for proof statements. - -The `earlyReturn` case is NOT an error: it is the escape channel for -`Ctrl.return`, which exits the enclosing FUNCTION — unwinding past any -pending `matchContinue` continuations — while `Ctrl.yield` feeds the -nearest continuation. It rides the `Except` error track so every -intermediate frame propagates it for free, and is unwrapped back into a -normal result at the function boundary (`evalOp .call` and -`runFunction`) — mirroring the Rust executor's continuation-stack -truncation on `Ctrl::Return`. -/ -inductive BytecodeError - | outOfFuel - | invalidValIdx (v : ValIdx) - | invalidFunIdx (f : FunIdx) - | arityMismatch (f : FunIdx) - | assertFailed - | invalidPointer (w i : Nat) - | ioKeyAlreadySet - | ioKeyNotFound - | ioReadOoB - | callOutputSizeMismatch - | unreachableAfterLayout - | u8RangeCheckFailed - | unconstrainedBigUintDivModFailed - | earlyReturn (outs : Array G) (st : EvalState) - deriving Repr, Inhabited - -/-! ## ValIdx access -/ - -def readIdx (st : EvalState) (v : ValIdx) : Except BytecodeError G := - match st.map[v]? with - | some g => .ok g - | none => .error (.invalidValIdx v) - -def readIdxs (st : EvalState) (vs : Array ValIdx) : Except BytecodeError (Array G) := - vs.foldlM (init := #[]) fun acc v => do - let g ← readIdx st v - pure (acc.push g) - -/-! ## Memory ops -/ - -/-- Insert/retrieve at a specific width bucket; returns the insertion index. -/ -def memStore (st : EvalState) (vals : Array G) : EvalState × Nat := - let width := vals.size - let bucket := st.memory.getByKey width |>.getD default - if let some idx := bucket.getIdxOf vals then - (st, idx) - else - let idx := bucket.size - let newBucket := bucket.insert vals () - let newMem := st.memory.insert width newBucket - ({ st with memory := newMem }, idx) - -/-- Load from the width-`size` bucket at index `ptr`. -/ -def memLoad (st : EvalState) (size : Nat) (ptr : Nat) : - Except BytecodeError (Array G) := - match st.memory.getByKey size with - | none => .error (.invalidPointer size ptr) - | some bucket => - match bucket.getByIdx ptr with - | some (vs, _) => .ok vs - | none => .error (.invalidPointer size ptr) - -/-! ## `List` limb chains (`unconstrainedBigUintDivMod`) - -Mirrors `read_klimbs_u64` / `build_klimbs_u64` in `crates/aiur/src/execute.rs`: -nodes live in the width-10 memory bucket with the standard tagged-enum -layout `[tag, byte0..byte7, next_ptr]` — tag 0 = Cons, tag 1 = Nil, bytes -little-endian within the u64 limb. -/ - -/-- Walk a limb chain from `ptr`, returning the limbs head-first. `steps` -bounds the walk: a chain longer than the width-10 bucket must revisit a -pointer, i.e. a malformed cycle. -/ -def readLimbChain (st : EvalState) : Nat → Nat → - Except BytecodeError (List (Array G)) - | 0, _ => .error .unconstrainedBigUintDivModFailed - | steps+1, ptr => do - let vs ← memLoad st 10 ptr - match vs[0]?, vs[9]? with - | some tag, some next => - if tag == 1 then pure [] - else if tag == 0 then - let bytes := vs.extract 1 9 - if bytes.size == 8 && bytes.all (·.val < 256) then do - let rest ← readLimbChain st steps next.val.toNat - pure (bytes :: rest) - else .error .unconstrainedBigUintDivModFailed - else .error .unconstrainedBigUintDivModFailed - | _, _ => .error .unconstrainedBigUintDivModFailed - -/-- Build a limb chain from head-first `limbs`, returning the head pointer. -Same insertion order as the Rust builder (Nil first, then limbs in reverse), -so freshly-created pointer indices agree; `memStore` content-dedups like -`QueryMap` does. -/ -def buildLimbChain (st : EvalState) : List (Array G) → EvalState × Nat - | [] => memStore st (#[1] ++ Array.replicate 9 0) - | limb :: rest => - let (st', restPtr) := buildLimbChain st rest - memStore st' (#[0] ++ limb ++ #[.ofNat restPtr]) - -def pushMap (st : EvalState) (g : G) : EvalState := - { st with map := st.map.push g } - -def appendMap (st : EvalState) (gs : Array G) : EvalState := - { st with map := st.map ++ gs } - -def setIoBuffer (st : EvalState) (ioBuffer : IOBuffer) : EvalState := - { st with ioBuffer } - -/-! ## Termination helpers - -Lemmas proving that a `Block`'s sub-parts have strictly smaller `sizeOf`. -Used by the `decreasing_by` of the mutual block to discharge the -evalBlock → runOps (`sizeOf b.ops < sizeOf b`) and -evalBlock → evalCtrl (`sizeOf b.ctrl < sizeOf b`) obligations. -/ - -private theorem Block.sizeOf_ops_lt (b : Block) : sizeOf b.ops < sizeOf b := by - rcases b with ⟨ops, ctrl⟩ - show sizeOf ops < 1 + sizeOf ops + sizeOf ctrl - omega - -private theorem Block.sizeOf_ctrl_lt (b : Block) : sizeOf b.ctrl < sizeOf b := by - rcases b with ⟨ops, ctrl⟩ - show sizeOf ctrl < 1 + sizeOf ops + sizeOf ctrl - omega - -/-- For a match-case `(g, block)` drawn from `cases`, the block's `sizeOf` is -strictly less than `sizeOf cases + sizeOf defaultBlock`. -/ -private theorem sizeOf_caseBlock_lt - (cases : Array (G × Block)) (defaultBlock : Option Block) (i : Nat) - (h : i < cases.size) : - sizeOf cases[i].snd < sizeOf cases + sizeOf defaultBlock := by - have h1 : sizeOf cases[i] < sizeOf cases := Array.sizeOf_get cases i h - have h2 : sizeOf cases[i].snd < sizeOf cases[i] := by - rcases cases[i] with ⟨g, block⟩ - show sizeOf block < 1 + sizeOf g + sizeOf block - omega - omega - -/-- For `defaultBlock = some block`, the block's `sizeOf` is less than -`sizeOf cases + sizeOf defaultBlock`. -/ -private theorem sizeOf_defaultBlock_lt - (cases : Array (G × Block)) {block : Block} : - sizeOf block < sizeOf cases + sizeOf (some block : Option Block) := by - show sizeOf block < sizeOf cases + (1 + sizeOf block) - omega - -/-! ## Evaluator — mutual block over block/ctrl/ops recursion - -Fuel decrements only at `.call` (call-only accounting). Other -recursive calls use structural decrease on the block/ctrl/ops tree. Measure is -lex `(fuel, priority, sizeOf)`. --/ - -mutual - -/-- Evaluate a single `Op`, returning the new state. `call` is the only op that -consumes fuel. -/ -def evalOp (t : Bytecode.Toplevel) (fuel : Nat) (op : Op) (st : EvalState) : - Except BytecodeError EvalState := - match op with - | .const g => .ok (pushMap st g) - | .add a b => do - let x ← readIdx st a - let y ← readIdx st b - pure (pushMap st (x + y)) - | .sub a b => do - let x ← readIdx st a - let y ← readIdx st b - pure (pushMap st (x - y)) - | .mul a b => do - let x ← readIdx st a - let y ← readIdx st b - pure (pushMap st (x * y)) - | .eqZero a => do - let x ← readIdx st a - pure (pushMap st (if x.val == 0 then 1 else 0)) - | .call fi args outputSize _unconstrained => do - let argGs ← readIdxs st args - if h : fi < t.functions.size then - let f := t.functions[fi] - if f.layout.inputSize != argGs.size then - .error (.arityMismatch fi) - else - let innerSt : EvalState := { ioBuffer := st.ioBuffer - memory := st.memory - map := argGs } - match fuel with - | 0 => .error .outOfFuel - | fuel+1 => - -- Function boundary: an `earlyReturn` escaping the callee's body - -- is its normal return value. - match evalBlock t fuel f.body innerSt with - | .error (.earlyReturn outs innerSt') | .ok (outs, innerSt') => - if outs.size != outputSize then - .error .callOutputSizeMismatch - else - pure (appendMap (setIoBuffer { st with memory := innerSt'.memory } - innerSt'.ioBuffer) outs) - | .error e => .error e - else .error (.invalidFunIdx fi) - | .store vals => do - let argGs ← readIdxs st vals - let (st', idx) := memStore st argGs - pure (pushMap st' (.ofNat idx)) - | .load size ptr => do - let ptrG ← readIdx st ptr - let vs ← memLoad st size ptrG.val.toNat - pure (appendMap st vs) - | .assertEq as bs _ => do - let aGs ← readIdxs st as - let bGs ← readIdxs st bs - if aGs == bGs then .ok st else .error .assertFailed - | .ioGetInfo channelIdx keyIdxs => do - let channelG ← readIdx st channelIdx - let keyGs ← readIdxs st keyIdxs - match st.ioBuffer.map[(channelG, keyGs)]? with - | some info => - let st1 := pushMap st (.ofNat info.idx) - pure (pushMap st1 (.ofNat info.len)) - | none => .error .ioKeyNotFound - | .ioSetInfo channelIdx keyIdxs idxIdx lenIdx => do - let channelG ← readIdx st channelIdx - let keyGs ← readIdxs st keyIdxs - let iG ← readIdx st idxIdx - let lG ← readIdx st lenIdx - if st.ioBuffer.map.contains (channelG, keyGs) then - .error .ioKeyAlreadySet - else - let info : IOKeyInfo := ⟨iG.val.toNat, lG.val.toNat⟩ - let newMap := st.ioBuffer.map.insert (channelG, keyGs) info - pure (setIoBuffer st { st.ioBuffer with map := newMap }) - | .ioRead channelIdx idxIdx len => do - let channelG ← readIdx st channelIdx - let iG ← readIdx st idxIdx - let start := iG.val.toNat - let arena := st.ioBuffer.data.getD channelG #[] - if start + len > arena.size then - .error .ioReadOoB - else - pure (appendMap st (arena.extract start (start + len))) - | .ioWrite channelIdx dataIdxs => do - let channelG ← readIdx st channelIdx - let dataGs ← readIdxs st dataIdxs - let arena := st.ioBuffer.data.getD channelG #[] - let newData := st.ioBuffer.data.insert channelG (arena ++ dataGs) - pure (setIoBuffer st { st.ioBuffer with data := newData }) - | .u8BitDecomposition idx => do - let g ← readIdx st idx - let byte := g.val.toUInt8 - let bits := Array.ofFn fun (i : Fin 8) => - G.ofUInt8 ((byte >>> i.val.toUInt8) &&& 1) - pure (appendMap st bits) - | .u8ShiftLeft idx => do - let g ← readIdx st idx - pure (pushMap st (G.ofUInt8 (g.val.toUInt8 <<< 1))) - | .u8ShiftRight idx => do - let g ← readIdx st idx - pure (pushMap st (G.ofUInt8 (g.val.toUInt8 >>> 1))) - | .u8Xor a b => do - let x ← readIdx st a; let y ← readIdx st b - pure (pushMap st (G.ofUInt8 (x.val.toUInt8 ^^^ y.val.toUInt8))) - | .u8Add a b => do - let x ← readIdx st a; let y ← readIdx st b - let sum := x.val.toUInt8.toNat + y.val.toUInt8.toNat - let st1 := pushMap st (G.ofUInt8 sum.toUInt8) - pure (pushMap st1 (if sum ≥ 256 then 1 else 0)) - | .u8Mul a b => do - let x ← readIdx st a; let y ← readIdx st b - let prod := x.val.toUInt8.toNat * y.val.toUInt8.toNat - let st1 := pushMap st (G.ofUInt8 prod.toUInt8) - pure (pushMap st1 (G.ofUInt8 (prod / 256).toUInt8)) - | .u8XorSplit7 a b => do - let x ← readIdx st a; let y ← readIdx st b; let z := x.val.toUInt8 ^^^ y.val.toUInt8 - pure (pushMap (pushMap st (G.ofUInt8 (z >>> 7))) (G.ofUInt8 (z <<< 1))) - | .u8XorSplit4 a b => do - let x ← readIdx st a; let y ← readIdx st b; let z := x.val.toUInt8 ^^^ y.val.toUInt8 - pure (pushMap (pushMap st (G.ofUInt8 (z >>> 4))) (G.ofUInt8 (z <<< 4))) - | .u8Sub a b => do - let x ← readIdx st a; let y ← readIdx st b - let i := x.val.toUInt8; let j := y.val.toUInt8 - let st1 := pushMap st (G.ofUInt8 (i - j)) - pure (pushMap st1 (if j > i then 1 else 0)) - | .u8And a b => do - let x ← readIdx st a; let y ← readIdx st b - pure (pushMap st (G.ofUInt8 (x.val.toUInt8 &&& y.val.toUInt8))) - | .u8Or a b => do - let x ← readIdx st a; let y ← readIdx st b - pure (pushMap st (G.ofUInt8 (x.val.toUInt8 ||| y.val.toUInt8))) - | .u8LessThan a b => do - let x ← readIdx st a; let y ← readIdx st b - pure (pushMap st (if x.val.toUInt8 < y.val.toUInt8 then 1 else 0)) - | .u32LessThan a b => do - let x ← readIdx st a; let y ← readIdx st b - pure (pushMap st (if x.val.toUInt32 < y.val.toUInt32 then 1 else 0)) - | .unconstrainedU32Add a b => do - let pack (idxs : Array Nat) := idxs.toList.zipIdx.foldl - (fun n (idx, i) => n + (st.map[idx]?.getD 0).val.toNat * 256 ^ i) 0 - let sum := pack a + pack b - let bytes := #[0, 1, 2, 3].map fun i => G.ofNat ((sum / 256 ^ i) % 256) - pure (pushMap (appendMap st bytes) (.ofNat (sum / 0x100000000))) - | .unconstrainedU32Add3 a b c => do - let pack (idxs : Array Nat) := idxs.toList.zipIdx.foldl - (fun n (idx, i) => n + (st.map[idx]?.getD 0).val.toNat * 256 ^ i) 0 - let sum := pack a + pack b + pack c - let bytes := #[0, 1, 2, 3].map fun i => G.ofNat ((sum / 256 ^ i) % 256) - pure (pushMap (appendMap st bytes) (.ofNat (sum / 0x100000000))) - | .u32ToField bytes => do - let word := bytes.toList.zipIdx.foldl - (fun n (idx, i) => n + (st.map[idx]?.getD 0).val.toNat * 256 ^ i) 0 - pure (pushMap st (.ofNat word)) - | .u8RangeCheck a b => do - -- No value pushed: the `u8` results alias the inputs. Fails if either is - -- outside `[0, 256)` (exactly what the byte-chip lookup enforces). - let x ← readIdx st a; let y ← readIdx st b - if x.val < 256 && y.val < 256 then .ok st else .error .u8RangeCheckFailed - | .unconstrainedBigUintDivMod a b => do - let aPtr ← readIdx st a - let bPtr ← readIdx st b - -- Walk bound: the width-10 bucket size plus one (see `readLimbChain`). - let bound := (st.memory.getByKey 10 |>.map (·.size) |>.getD 0) + 1 - let aLimbs ← readLimbChain st bound aPtr.val.toNat - let bLimbs ← readLimbChain st bound bPtr.val.toNat - let aVal := limbsVal aLimbs - let bVal := limbsVal bLimbs - -- `Nat` division matches the runtime's `b = 0 → (0, a)` convention. - let (st1, qPtr) := buildLimbChain st (natToLimbsLE (aVal / bVal)) - let (st2, rPtr) := buildLimbChain st1 (natToLimbsLE (aVal % bVal)) - pure (pushMap (pushMap st2 (.ofNat qPtr)) (.ofNat rPtr)) - | .unconstrainedGToBytes idx => do - let g ← readIdx st idx - pure (appendMap st (Array.ofFn g.toLeBytes)) - | .unconstrainedGInverse idx => do - let g ← readIdx st idx - pure (pushMap st g.inverse) - | .debug _ _ => .ok st -termination_by (fuel, sizeOf op, 0) -decreasing_by all_goals first | decreasing_tactic | omega - -/-- Run an ordered sequence of ops. -/ -def runOps (t : Bytecode.Toplevel) (fuel : Nat) (ops : Array Op) - (st : EvalState) (i : Nat) : Except BytecodeError EvalState := - if h : i < ops.size then - match evalOp t fuel ops[i] st with - | .error e => .error e - | .ok st' => runOps t fuel ops st' (i+1) - else .ok st -termination_by (fuel, sizeOf ops, 1 + (ops.size - i)) -decreasing_by all_goals first | decreasing_tactic | omega - -/-- Evaluate a `Block`: run all ops, then dispatch on the control. -/ -def evalBlock (t : Bytecode.Toplevel) (fuel : Nat) - (b : Block) (st : EvalState) : Except BytecodeError (Array G × EvalState) := - match runOps t fuel b.ops st 0 with - | .error e => .error e - | .ok st' => evalCtrl t fuel b.ctrl st' -termination_by (fuel, sizeOf b, 4) -decreasing_by - all_goals first - | decreasing_tactic - | (apply Prod.Lex.right; apply Prod.Lex.left; exact Block.sizeOf_ops_lt _) - | (apply Prod.Lex.right; apply Prod.Lex.left; exact Block.sizeOf_ctrl_lt _) - | omega - -def evalCtrl (t : Bytecode.Toplevel) (fuel : Nat) - (ctrl : Ctrl) (st : EvalState) : Except BytecodeError (Array G × EvalState) := - match ctrl with - | .return _ outs => - -- Function-level return: escape via the `earlyReturn` sentinel so a - -- pending `matchContinue` continuation is skipped (Rust truncates the - -- continuation stack here). Unwrapped at the function boundary. - match readIdxs st outs with - | .error e => .error e - | .ok gs => .error (.earlyReturn gs st) - | .yield _ outs => - -- Continuation-level yield: normal result, consumed by the nearest - -- enclosing `matchContinue`. - match readIdxs st outs with - | .error e => .error e - | .ok gs => .ok (gs, st) - | .match scrutIdx cases defaultBlock => - match readIdx st scrutIdx with - | .error e => .error e - | .ok scrut => - evalMatchArm t fuel cases defaultBlock scrut st - | .matchContinue scrutIdx cases defaultBlock _outputSize _sharedAux _sharedLookups cont => - match readIdx st scrutIdx with - | .error e => .error e - | .ok scrut => - match evalMatchArm t fuel cases defaultBlock scrut st with - | .error e => .error e - | .ok (gs, st') => - -- The match acts as an atomic operation from the continuation's - -- perspective: any values a case pushed onto `map` are local to the - -- case and must not leak into the continuation's namespace. Restore - -- the pre-match `map` and append only the yield outputs. - let stMerged : EvalState := { st' with map := st.map ++ gs } - evalBlock t fuel cont stMerged -termination_by (fuel, sizeOf ctrl, 3) -decreasing_by all_goals first | decreasing_tactic | omega - -/-- Walk match cases structurally; picks the first arm whose discriminant -equals `scrut`, falling back to `defaultBlock` if none match. Structured as a -separate helper so each recursive step is structurally smaller than `cases`, -which lets `Array.sizeOf_get` discharge the termination goal when we call -`evalBlock` on an arm's `Block`. -/ -def evalMatchArm (t : Bytecode.Toplevel) (fuel : Nat) - (cases : Array (G × Block)) (defaultBlock : Option Block) - (scrut : G) (st : EvalState) (i : Nat := 0) : - Except BytecodeError (Array G × EvalState) := - if h : i < cases.size then - if cases[i].fst == scrut then evalBlock t fuel cases[i].snd st - else evalMatchArm t fuel cases defaultBlock scrut st (i + 1) - else evalDefaultBlock t fuel defaultBlock st -termination_by (fuel, sizeOf cases + sizeOf defaultBlock, 2 + (cases.size - i)) -decreasing_by - all_goals ( - clean_wf - first - | decreasing_tactic - | (apply Prod.Lex.right - apply Prod.Lex.left - first - | exact sizeOf_caseBlock_lt cases defaultBlock i ‹_› - | (cases cases with | mk l => show sizeOf defaultBlock < 1 + sizeOf l + sizeOf defaultBlock; omega)) - | omega) - -/-- Dispatch on the optional default block at the end of a `.match` arm. -/ -def evalDefaultBlock (t : Bytecode.Toplevel) (fuel : Nat) - (defaultBlock : Option Block) (st : EvalState) : - Except BytecodeError (Array G × EvalState) := - match defaultBlock with - | some block => evalBlock t fuel block st - | none => .error .unreachableAfterLayout -termination_by (fuel, sizeOf defaultBlock, 1) -decreasing_by - all_goals simp_wf - all_goals first - | decreasing_tactic - | (simp_arith; omega) - | omega - -end - -/-! ## Top-level entry -/ - -/-- Run a function by index with the given flat args and IO buffer. -/ -def runFunction (t : Bytecode.Toplevel) (funIdx : FunIdx) (args : Array G) - (ioBuffer : IOBuffer) (fuel : Nat) : - Except BytecodeError (Array G × IOBuffer) := - if h : funIdx < t.functions.size then - let f := t.functions[funIdx] - if f.layout.inputSize != args.size then - .error (.arityMismatch funIdx) - else - let st : EvalState := { map := args, ioBuffer } - match evalBlock t fuel f.body st with - | .error (.earlyReturn outs st') | .ok (outs, st') => .ok (outs, st'.ioBuffer) - | .error e => .error e - else .error (.invalidFunIdx funIdx) - -end Bytecode.Eval - -end Aiur - -end -- @[expose] section -end diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean deleted file mode 100644 index 03d7a0fff..000000000 --- a/Ix/Aiur/Semantics/BytecodeFfi.lean +++ /dev/null @@ -1,226 +0,0 @@ -module -public import Ix.Aiur.Stages.Bytecode -public import Std.Data.HashMap - -/-! -Opaque Rust FFI for bytecode execution. Split out of `Protocol.lean` so the -Lean-native reference evaluator (`Bytecode/Eval.lean`) can stand alone. - -The Rust executor is the production backend; our Lean reference is the specification. -A follow-up theorem relates the two under a purity assumption on IO. --/ - -public section - -namespace Aiur - -structure IOKeyInfo where - idx : Nat - len : Nat - deriving DecidableEq - -instance : BEq IOKeyInfo where - beq a b := a.idx == b.idx && a.len == b.len - -instance : LawfulBEq IOKeyInfo where - eq_of_beq {a b} h := by - simp [BEq.beq, Bool.and_eq_true] at h - cases a; cases b; simp_all - rfl {a} := by simp [BEq.beq] - -structure IOBuffer where - /-- Per-channel data arenas. `idx` slots into `data[channel]`. -/ - data : Std.HashMap G (Array G) - /-- Channel-keyed info map. Same `key` on different channels resolves - to distinct `IOKeyInfo`. -/ - map : Std.HashMap (G × Array G) IOKeyInfo - deriving Inhabited - -/-- Append `data` to the `channel` arena and register `key → (idx, len)` -on the same channel. -/ -def IOBuffer.extend (ioBuffer : IOBuffer) (channel : G) (key data : Array G) : - IOBuffer := - let ⟨channels, entries⟩ := ioBuffer - let idx := (channels.getD channel #[]).size - let len := data.size - -- `alter` releases the map's old arena before appending. Looking up the - -- arena and then inserting its extension keeps it shared during `++`, - -- copying the entire growing channel for every entry. - let channels := channels.alter channel (fun arena => some (arena.getD #[] ++ data)) - { data := channels - map := entries.insert (channel, key) { idx, len } } - -/-- Rebuild an `IOBuffer` from the flat arrays produced by the Rust FFI. -Hashmaps don't cross the FFI boundary; Rust returns arrays and the -hashmaps are populated here. -/ -def IOBuffer.ofArrays (data : Array (G × Array G)) - (map : Array ((G × Array G) × IOKeyInfo)) : IOBuffer := - ⟨data.foldl (fun acc (k, v) => acc.insert k v) ∅, - map.foldl (fun acc (k, v) => acc.insert k v) ∅⟩ - -instance : BEq IOBuffer where - beq x y := - @BEq.beq _ Std.HashMap.instBEq x.data y.data && - @BEq.beq _ Std.HashMap.instBEq x.map y.map - --- A `LawfulBEq IOBuffer` instance is not provided here. The reflexivity/ --- symmetry/transitivity facts needed downstream (`IOBuffer.equiv_refl`, --- `_symm`, `_trans`) are proved directly in `Ix/Aiur/Proofs/IOBufferEquiv.lean` --- via `Std.HashMap.beq_iff_equiv` + `Std.HashMap.Equiv.{refl,symm,trans}`, --- bypassing the need for `LawfulBEq` on the outer `IOBuffer`. - -/-- Per-circuit query counts for one circuit (one per function circuit, then -one per memory size). `uniqueRows` is the trace height; `totalHits` is the sum -of query multiplicities. The difference `totalHits - uniqueRows` is the number -of cache hits. -/ -structure QueryCount where - uniqueRows : Nat - totalHits : Nat - deriving Inhabited - -/-- Result of an execution FFI call, built directly by Rust -(`LeanAiurExecuteResult` in `crates/ffi/src/lean.rs`). `ioData`/`ioMap` -are the flattened `IOBuffer`; see `IOBuffer.ofArrays`. -/ -structure ExecuteResult where - output : Array G - ioData : Array (G × Array G) - ioMap : Array ((G × Array G) × IOKeyInfo) - queryCounts : Array QueryCount - --- =========================================================================== --- EnvHandle: Rust-owned `ixon::Env` exposed to Lean as an opaque handle. --- Built once per CLI invocation; reused across every per-claim and --- per-shard FFI call so the env is parsed exactly once. --- =========================================================================== - -private opaque EnvHandleNonempty : NonemptyType -def EnvHandle : Type := EnvHandleNonempty.type -instance : Nonempty EnvHandle := EnvHandleNonempty.property - -namespace EnvHandle - -@[extern "rs_aiur_env_handle_from_ixe"] -private opaque fromIxe' : @& ByteArray → Except String EnvHandle - -/-- Load an `EnvHandle` from a `.ixe` file path (UTF-8 ByteArray). - Rust mmap's the file zero-copy; the handle keeps the mapping - alive for as long as Lean retains it. -/ -def fromIxe (path : String) : Except String EnvHandle := - fromIxe' path.toUTF8 - -@[extern "rs_aiur_env_handle_from_bytes"] -private opaque fromBytes' : @& ByteArray → Except String EnvHandle - -/-- Build an `EnvHandle` from a serialized env blob (e.g. produced - by `Ixon.serEnv` on the compiled-Lean-env code path). -/ -def fromBytes (bytes : ByteArray) : Except String EnvHandle := - fromBytes' bytes - -end EnvHandle - -namespace Bytecode.Toplevel - -@[extern "rs_aiur_toplevel_execute"] -private opaque execute' : @& Bytecode.Toplevel → - @& Bytecode.FunIdx → @& Array G → - (ioData : @& Array (G × Array G)) → - (ioMap : @& Array ((G × Array G) × IOKeyInfo)) → - Except String ExecuteResult - -/-- Executes the bytecode function `funIdx` with the given `args` and `ioBuffer`, -returning the raw output of the function, the updated `IOBuffer`, and an array -of per-circuit `QueryCount`s. Returns `Except.error msg` when execution -fails (e.g. `assert_eq!` mismatch from a typechecker rejecting a constant), so -callers can recover instead of crashing. -/ -def execute (toplevel : @& Bytecode.Toplevel) - (funIdx : @& Bytecode.FunIdx) (args : @& Array G) (ioBuffer : IOBuffer) : - Except String (Array G × IOBuffer × Array QueryCount) := - (execute' toplevel funIdx args ioBuffer.data.toArray ioBuffer.map.toArray).map - fun r => (r.output, .ofArrays r.ioData r.ioMap, r.queryCounts) - -@[extern "rs_aiur_toplevel_execute_ixvm"] -private opaque executeIxVM' : @& Bytecode.Toplevel → - @& Bytecode.FunIdx → @& Array G → - (ioData : @& Array (G × Array G)) → - (ioMap : @& Array ((G × Array G) × IOKeyInfo)) → - Except String ExecuteResult - -/-- IxVM-native execution: same shape as `execute`, but routes the - function invocation through the codegen'd Rust kernel - (`crate::ix::aiur_ixvm::execute_generated`) instead of the - generic bytecode interpreter. The resulting `QueryRecord` is - byte-for-byte identical (modulo the standing codegen parity - invariant). Only valid when `toplevel` is the IxVM kernel's - `Bytecode.Toplevel` — other toplevels produce undefined results - because the generated function bodies are fixed at codegen time. -/ -def executeIxVM (toplevel : @& Bytecode.Toplevel) - (funIdx : @& Bytecode.FunIdx) (args : @& Array G) (ioBuffer : IOBuffer) : - Except String (Array G × IOBuffer × Array QueryCount) := - (executeIxVM' toplevel funIdx args ioBuffer.data.toArray ioBuffer.map.toArray).map - fun r => (r.output, .ofArrays r.ioData r.ioMap, r.queryCounts) - --- (EnvHandle opaque type + constructors live above `namespace --- Bytecode.Toplevel`; see `Aiur.EnvHandle`. The with-env FFI --- declarations below reference `EnvHandle` and `Bytecode.Toplevel` --- from the same scope.) - -@[extern "rs_aiur_toplevel_check_addr_with_env"] -private opaque checkAddrWithEnv' : @& Bytecode.Toplevel → - @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool → Bool → - Except String ExecuteResult - -/-- Per-claim check against a Rust-owned `EnvHandle`. `useBytecode` - selects the generic Aiur bytecode interpreter - (`Bytecode.Toplevel.execute`) over the codegen'd IxVM kernel - (`execute_ixvm`); useful for tight iteration loops on Lean-side - IxVM source where regenerating the Rust kernel is too slow. -/ -def checkAddrWithEnv (toplevel : @& Bytecode.Toplevel) - (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) - (addrBytes : ByteArray) (useBytecode : Bool := false) - (assumeBinding : Bool := false) - : Except String (Array G × IOBuffer × Array QueryCount) := - (checkAddrWithEnv' toplevel funIdx envHandle addrBytes useBytecode assumeBinding).map - fun r => (r.output, .ofArrays r.ioData r.ioMap, r.queryCounts) - -@[extern "rs_aiur_toplevel_check_addrs_with_env"] -private opaque checkAddrsWithEnv' : @& Bytecode.Toplevel → - @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool → @& Nat → - Except String (Array (String × String)) - -/-- Batch PARALLEL check of many full-closure claims: `addrsBlob` is - the concatenation of 32-byte addresses, and Rust checks them on a - rayon pool of `jobs` threads (0 = rayon default) — each claim - through the exact single-claim machinery over task-private data - (own witness io, own query record), nothing shared between tasks - but the read-only toplevel and env. Returns the FAILURES as - `(batch index as a decimal string, error)` pairs, resolving back to - the caller's label order; empty means all passed. Per-claim - outputs/records are not returned — use `checkAddrWithEnv` for a - single claim's full result. -/ -def checkAddrsWithEnv (toplevel : @& Bytecode.Toplevel) - (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) - (addrsBlob : ByteArray) (useBytecode : Bool := false) (jobs : Nat := 0) - : Except String (Array (String × String)) := - checkAddrsWithEnv' toplevel funIdx envHandle addrsBlob useBytecode jobs - -@[extern "rs_aiur_toplevel_shard_check_with_env"] -private opaque shardCheckWithEnv' : @& Bytecode.Toplevel → - @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool → Bool → - Except String ExecuteResult - -/-- Per-shard check with the witness shape (wrapper-augmented byte - scope for the kernel's kernel-side blake3'd projection addrs). Claim and - digest are identical to `shardCheckWithEnv`'s. -/ -def shardCheckWithEnv (toplevel : @& Bytecode.Toplevel) - (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) - (ownedBlob : ByteArray) (useBytecode : Bool := false) - (assumeBinding : Bool := false) - : Except String (Array G × IOBuffer × Array QueryCount) := - (shardCheckWithEnv' toplevel funIdx envHandle ownedBlob useBytecode assumeBinding).map - fun r => (r.output, .ofArrays r.ioData r.ioMap, r.queryCounts) - -end Bytecode.Toplevel - -end Aiur - -end diff --git a/Ix/Aiur/Semantics/Flatten.lean b/Ix/Aiur/Semantics/Flatten.lean deleted file mode 100644 index 81c643912..000000000 --- a/Ix/Aiur/Semantics/Flatten.lean +++ /dev/null @@ -1,353 +0,0 @@ -module -public import Ix.Aiur.Stages.Source -public import Ix.Aiur.Stages.Concrete -public import Ix.Aiur.Semantics.BytecodeFfi -public import Std.Data.HashSet - -/-! -Total flattening utilities: convert between structured `Value`s and flat `Array G`. - -Total by threading a `visited : HashSet Global` through `typFlatSize` / -`dataTypeFlatSize` to guard against direct datatype recursion without -`.pointer` indirection. --/ - -public section -@[expose] section - -namespace Aiur - -/-- Runtime values produced by the source-level reference evaluators. -See `Ix/Aiur/Source/Eval.lean` and `Ix/Aiur/Concrete/Eval.lean`. -/ -inductive Value : Type where - | unit : Value - | field : G → Value - | tuple : Array Value → Value - | array : Array Value → Value - | ctor : Global → Array Value → Value - | fn : Global → Value - /-- `width, index` — width is the flat size of the stored element's type. In the - Source-form evaluator only `index` is meaningful; in the Concrete-form - evaluator `width` selects the per-width memory bucket to match Rust's - `memory_queries`. -/ - | pointer : (width : Nat) → (index : Nat) → Value - deriving Repr, Hashable, Inhabited - -deriving instance DecidableEq for Global - -mutual - -def Value.decEq : (a b : Value) → Decidable (a = b) - | .unit, .unit => isTrue rfl - | .field g₁, .field g₂ => - if h : g₁ = g₂ then isTrue (h ▸ rfl) else isFalse fun h' => h (Value.field.inj h') - | .tuple vs₁, .tuple vs₂ => - match Value.arrayDecEq vs₁ vs₂ with - | isTrue h => isTrue (h ▸ rfl) - | isFalse h => isFalse fun h' => h (Value.tuple.inj h') - | .array vs₁, .array vs₂ => - match Value.arrayDecEq vs₁ vs₂ with - | isTrue h => isTrue (h ▸ rfl) - | isFalse h => isFalse fun h' => h (Value.array.inj h') - | .ctor g₁ vs₁, .ctor g₂ vs₂ => - if hg : g₁ = g₂ then - match Value.arrayDecEq vs₁ vs₂ with - | isTrue hvs => isTrue (hg ▸ hvs ▸ rfl) - | isFalse hvs => isFalse fun h' => hvs (Value.ctor.inj h').2 - else isFalse fun h' => hg (Value.ctor.inj h').1 - | .fn g₁, .fn g₂ => - if h : g₁ = g₂ then isTrue (h ▸ rfl) else isFalse fun h' => h (Value.fn.inj h') - | .pointer w₁ n₁, .pointer w₂ n₂ => - if hw : w₁ = w₂ then - if hn : n₁ = n₂ then isTrue (hw ▸ hn ▸ rfl) - else isFalse fun h' => hn (Value.pointer.inj h').2 - else isFalse fun h' => hw (Value.pointer.inj h').1 - | .unit, .field _ | .unit, .tuple _ | .unit, .array _ - | .unit, .ctor _ _ | .unit, .fn _ | .unit, .pointer _ _ - | .field _, .unit | .field _, .tuple _ | .field _, .array _ - | .field _, .ctor _ _ | .field _, .fn _ | .field _, .pointer _ _ - | .tuple _, .unit | .tuple _, .field _ | .tuple _, .array _ - | .tuple _, .ctor _ _ | .tuple _, .fn _ | .tuple _, .pointer _ _ - | .array _, .unit | .array _, .field _ | .array _, .tuple _ - | .array _, .ctor _ _ | .array _, .fn _ | .array _, .pointer _ _ - | .ctor _ _, .unit | .ctor _ _, .field _ | .ctor _ _, .tuple _ - | .ctor _ _, .array _ | .ctor _ _, .fn _ | .ctor _ _, .pointer _ _ - | .fn _, .unit | .fn _, .field _ | .fn _, .tuple _ - | .fn _, .array _ | .fn _, .ctor _ _ | .fn _, .pointer _ _ - | .pointer _ _, .unit | .pointer _ _, .field _ | .pointer _ _, .tuple _ - | .pointer _ _, .array _ | .pointer _ _, .ctor _ _ | .pointer _ _, .fn _ => - isFalse Value.noConfusion - -def Value.arrayDecEq : (a b : Array Value) → Decidable (a = b) - | ⟨as⟩, ⟨bs⟩ => - match Value.listDecEq as bs with - | isTrue h => isTrue (congrArg Array.mk h) - | isFalse h => isFalse fun h' => h (Array.mk.inj h') - -def Value.listDecEq : (as bs : List Value) → Decidable (as = bs) - | [], [] => isTrue rfl - | [], _::_ => isFalse (fun h => nomatch h) - | _::_, [] => isFalse (fun h => nomatch h) - | a::as, b::bs => - match Value.decEq a b, Value.listDecEq as bs with - | isTrue ha, isTrue ht => isTrue (ha ▸ ht ▸ rfl) - | isFalse h, _ => isFalse fun h' => h (List.cons.inj h').1 - | _, isFalse h => isFalse fun h' => h (List.cons.inj h').2 - -end - -instance : DecidableEq Value := Value.decEq - -/-- `OfNat Value n` produces `Value.field (G.ofNat n)` so numeric literals -write directly as `Value`s in test inputs and other contexts. -/ -instance : OfNat Value n := ⟨.field (G.ofNat n)⟩ - -/-! ## Flat size computation — total via `visited` set - -If a datatype is recursively referenced without a `.pointer` indirection, the -fixed-width flattening is ill-defined. The `visited` set makes the functions -total by detecting the cycle and returning `0` (a benign default that cannot -actually occur once the recursion-through-pointer-only invariant is established -by the checker). Mirrors `Layout.DataType.size:49-57`. - -**On the `Nat` parameter that looks like fuel.** It's a *bound* on the remaining -recursion depth, not user-facing fuel. The outer interfaces -`typFlatSize` / `dataTypeFlatSize` set the bound to `decls.size + 1`; the visited -set's monotonic growth (capped at `decls.size`) guarantees the bound is never -exhausted on well-formed inputs. To eliminate this Nat parameter entirely we'd -need to refine `visited` to a subtype enforcing `visited.size ≤ decls.size` — -that's a multi-hour refactor that produces equivalent provability with more -ceremony, so we keep the bound parameter. - -(This is *not* the same as the fuel in the reference evaluators, which is -genuine semantic call-counting and cannot be removed.) --/ - -open Std (HashSet) - -mutual - -/-- See `typFlatSize` for the outer interface. -/ -def typFlatSizeBound (decls : Source.Decls) : Nat → HashSet Global → Typ → Nat - | 0, _, _ => 0 - | _+1, _, .unit => 0 - | _+1, _, .field => 1 - | _+1, _, .u8 => 1 - | _+1, _, .pointer _ => 1 - | _+1, _, .function _ _ => 1 - | bound+1, visited, .tuple ts => - ts.attach.foldl (init := 0) - (fun acc ⟨t, _⟩ => acc + typFlatSizeBound decls bound visited t) - | bound+1, visited, .array t n => - n * typFlatSizeBound decls bound visited t - | bound+1, visited, .ref g - | bound+1, visited, .app g _ => - if visited.contains g then 0 - else match decls.getByKey g with - | some (.dataType dt) => - dataTypeFlatSizeBound decls bound (visited.insert g) dt - | _ => 0 - | _+1, _, .mvar _ => 0 - -/-- Flat size of a datatype (max constructor size + 1 for the tag; the `+ 1` -is dropped for single-variant enums, which carry no tag). -/ -def dataTypeFlatSizeBound (decls : Source.Decls) : Nat → HashSet Global → DataType → Nat - | 0, _, _ => 1 - | bound+1, visited, dt => - let ctorSizes := dt.constructors.map fun ctor => - ctor.argTypes.foldl (init := 0) - (fun acc t => acc + typFlatSizeBound decls bound visited t) - -- Single-variant enums carry no tag slot (tuple-identical layout). - if dt.constructors.length == 1 then ctorSizes.foldl max 0 - else ctorSizes.foldl max 0 + 1 - -end - -/-- Outer interface. The bound `decls.size + 1` cannot be exhausted given the -visited-set monotonicity (each step adds one fresh datatype name to `visited`, -which is bounded by `decls.size`), but the function is sound regardless: if the -bound were exhausted it returns `0`/`1`, which only matters on ill-formed inputs. -/ -def typFlatSize (decls : Source.Decls) (visited : HashSet Global) (t : Typ) : Nat := - typFlatSizeBound decls (decls.size + 1) visited t - -def dataTypeFlatSize (decls : Source.Decls) (visited : HashSet Global) (dt : DataType) : Nat := - dataTypeFlatSizeBound decls (decls.size + 1) visited dt - -/-! ## Flattening: `Value → Array G` -/ - -open Source in -/-- Flatten a `Value` to a flat `Array G`. Structural recursion on `Value`. -Total: `sizeOf` on the `Value` inductive sees through `Array.attach`. - -NOTE: post-concretize values carry mangled ctor names (`concretizeName g args`) -not present in source `decls`. The `.ctor` arm falls to the `| _ =>` branch -for such values, dropping tag+padding. `concretize_preserves_runFunction` -must bridge this via a ctor-rename relation (`ValueRelByConcretize`) or use -a concDecls-aware flatten variant. -/ -def flattenValue (decls : Decls) (funcIdx : Global → Option Nat) : - Value → Array G - | .unit => #[] - | .field g => #[g] - | .pointer _ n => #[.ofNat n] - | .fn g => #[.ofNat (funcIdx g |>.getD 0)] - | .tuple vs => - vs.attach.flatMap (fun ⟨v, _⟩ => flattenValue decls funcIdx v) - | .array vs => - vs.attach.flatMap (fun ⟨v, _⟩ => flattenValue decls funcIdx v) - | .ctor g args => - match decls.getByKey g with - | some (.constructor dt ctor) => - let dtSize := dataTypeFlatSize decls {} dt - let argsFlat := args.attach.flatMap (fun ⟨v, _⟩ => flattenValue decls funcIdx v) - -- Single-variant enums carry no tag slot (tuple-identical layout). - let flat := - if dt.constructors.length == 1 then argsFlat - else - let ctorIndex := dt.constructors.findIdx? (· == ctor) |>.getD 0 - #[.ofNat ctorIndex] ++ argsFlat - let padding := dtSize - flat.size - flat ++ Array.replicate padding 0 - | _ => args.attach.flatMap (fun ⟨v, _⟩ => flattenValue decls funcIdx v) -termination_by v => sizeOf v - -/-! ## Flat-size on `Concrete.Decls`. - -Post-concretize declarations use `Concrete.Typ` (no `.app`/`.mvar`), so flat- -size collapses to a simpler recursion. Mirrors `typFlatSize` structurally. -/ - -open Source in -mutual - -def Concrete.typFlatSizeBound (decls : Concrete.Decls) : - Nat → HashSet Global → Concrete.Typ → Nat - | 0, _, _ => 0 - | _+1, _, .unit => 0 - | _+1, _, .field => 1 - | _+1, _, .pointer _ => 1 - | _+1, _, .function _ _ => 1 - | bound+1, visited, .tuple ts => - ts.attach.foldl (init := 0) - (fun acc ⟨t, _⟩ => acc + Concrete.typFlatSizeBound decls bound visited t) - | bound+1, visited, .array t n => - n * Concrete.typFlatSizeBound decls bound visited t - | bound+1, visited, .ref g => - if visited.contains g then 0 - else match decls.getByKey g with - | some (.dataType dt) => - Concrete.dataTypeFlatSizeBound decls bound (visited.insert g) dt - | _ => 0 - -def Concrete.dataTypeFlatSizeBound (decls : Concrete.Decls) : - Nat → HashSet Global → Concrete.DataType → Nat - | 0, _, _ => 1 - | bound+1, visited, dt => - let ctorSizes := dt.constructors.map fun ctor => - ctor.argTypes.foldl (init := 0) - (fun acc t => acc + Concrete.typFlatSizeBound decls bound visited t) - ctorSizes.foldl max 0 + 1 - -end - -def Concrete.dataTypeFlatSize (decls : Concrete.Decls) - (visited : HashSet Global) (dt : Concrete.DataType) : Nat := - Concrete.dataTypeFlatSizeBound decls (decls.size + 1) visited dt - -/-! ## Flattening over `Concrete.Decls`. - -Mirror of `flattenValue` but resolves ctor names in `Concrete.Decls` instead -of `Source.Decls`. Used in `concretize_preserves_runFunction` to flatten -post-concretize values where ctor names are concretized (not in source decls). -/ - -def Concrete.flattenValue (decls : Concrete.Decls) (funcIdx : Global → Option Nat) : - Value → Array G - | .unit => #[] - | .field g => #[g] - | .pointer _ n => #[.ofNat n] - | .fn g => #[.ofNat (funcIdx g |>.getD 0)] - | .tuple vs => - vs.attach.flatMap (fun ⟨v, _⟩ => Concrete.flattenValue decls funcIdx v) - | .array vs => - vs.attach.flatMap (fun ⟨v, _⟩ => Concrete.flattenValue decls funcIdx v) - | .ctor g args => - match decls.getByKey g with - | some (.constructor dt ctor) => - let ctorIndex := dt.constructors.findIdx? (· == ctor) |>.getD 0 - let dtSize := Concrete.dataTypeFlatSize decls {} dt - let argsFlat := args.attach.flatMap - (fun ⟨v, _⟩ => Concrete.flattenValue decls funcIdx v) - let flat := #[.ofNat ctorIndex] ++ argsFlat - let padding := dtSize - flat.size - flat ++ Array.replicate padding 0 - | _ => args.attach.flatMap - (fun ⟨v, _⟩ => Concrete.flattenValue decls funcIdx v) -termination_by v => sizeOf v - -/-- Read a structured `Value` from a flat `Array G`, guided by the type. -Fuel-bounded like `typFlatSize`; the outer `unflattenValue` uses the same -`decls.size + 1` bound. -/ -def unflattenValueBound (decls : Source.Decls) (gs : Array G) : - Nat → Nat → Typ → Value × Nat - | 0, _, _ => (.unit, 0) - | _+1, _, .unit => (.unit, 0) - | _+1, offset, .field => (.field (gs.getD offset 0), 1) - | _+1, offset, .u8 => (.field (gs.getD offset 0), 1) - | _+1, offset, .pointer t => - let w := typFlatSize decls {} t - (.pointer w (gs.getD offset 0).val.toNat, 1) - | _+1, _, .function _ _ => (.fn ⟨.anonymous⟩, 1) - | bound+1, offset, .tuple ts => - let (vs, consumed) := ts.attach.foldl (init := (#[], 0)) - fun (acc, off) ⟨t, _⟩ => - let (v, n) := unflattenValueBound decls gs bound (offset + off) t - (acc.push v, off + n) - (.tuple vs, consumed) - | bound+1, offset, .array t n => - let eltSize := typFlatSize decls {} t - let vs := Array.ofFn fun (i : Fin n) => - (unflattenValueBound decls gs bound (offset + i.val * eltSize) t).1 - (.array vs, n * eltSize) - | bound+1, offset, .ref g - | bound+1, offset, .app g _ => - match decls.getByKey g with - | some (.dataType dt) => - let dtSize := dataTypeFlatSize decls {} dt - let tag := (gs.getD offset 0).val.toNat - let ctors := dt.constructors.toArray - if h : tag < ctors.size then - let ctor := ctors[tag] - let ctorName := dt.name.pushNamespace ctor.nameHead - let (args, _) := ctor.argTypes.foldl (init := (#[], 1)) fun (acc, off) t => - let (v, n) := unflattenValueBound decls gs bound (offset + off) t - (acc.push v, off + n) - (.ctor ctorName args, dtSize) - else (.field (gs.getD offset 0), dtSize) - | _ => (.field (gs.getD offset 0), 1) - | _+1, _, .mvar _ => (.unit, 0) -termination_by bound _ _ => bound - -/-- Outer interface; the recursion bound is `decls.size + 1` (see note above). -/ -def unflattenValue (decls : Source.Decls) (gs : Array G) (offset : Nat) (t : Typ) : - Value × Nat := - unflattenValueBound decls gs (decls.size + 1) offset t - -open Source in -/-- Reconstruct structured input `Value`s from a flat `Array G`. -/ -def unflattenInputs (decls : Decls) (gs : Array G) (inputTypes : List Typ) : - List Value := - let (vals, _) := inputTypes.foldl (init := (#[], 0)) fun (acc, off) t => - let (v, n) := unflattenValue decls gs off t - (acc.push v, off + n) - vals.toList - -/-! ## Naturally-list coercion for args, used in the compile_correct statement -/ - -open Source in -/-- The natural list-to-flat coercion used in the statement of `compile_correct`. -/ -def Flatten.args (decls : Decls) (funcIdx : Global → Option Nat) - (args : List Value) : Array G := - args.foldl (fun acc v => acc ++ flattenValue decls funcIdx v) #[] - -end Aiur - -end -- @[expose] section -end diff --git a/Ix/Aiur/Semantics/SourceEval.lean b/Ix/Aiur/Semantics/SourceEval.lean deleted file mode 100644 index c0ce18fc6..000000000 --- a/Ix/Aiur/Semantics/SourceEval.lean +++ /dev/null @@ -1,751 +0,0 @@ -module -public import Ix.Aiur.Stages.Source -public import Ix.Aiur.Semantics.Flatten -public import Ix.Aiur.Protocol - -/-! -Source-form reference evaluator — proof-bearing semantics on `Source.Term`. - -Design: -- **No cache.** The cache is a debug-interpreter optimization (`Ix/Aiur/Interpret.lean`) - and a Rust trace-multiplicity device, not part of the semantic model. -- **No stack trace.** Errors are tagged; debugging is the debug interpreter's job. -- **Fuel-indexed, call-only accounting.** `fuel : Nat` decrements only at `applyGlobal`. - Intra-body recursion is structural. -- **Errors return, never panic.** `ioSetInfo` on existing key, `ioRead` OOB, pattern - failure, type mismatch, etc. all produce `Except.error`. - -This source-level evaluator does not yet distinguish pointer widths — source -pointers are a single global store. The width-bucketed `Concrete.Eval` -evaluator fixes that divergence with Rust. --/ - -public section -@[expose] section - -namespace Aiur - -namespace Source.Eval - -open Source - -abbrev Bindings := List (Local × Value) -/-- Memory store, width-bucketed to match Rust `src/aiur/execute.rs` -`memory_queries: HashMap, QueryResult>>`. Each width -has its own `IndexMap`; `ptrVal` returns the local index within its width's -bucket. Distinct-width pointers may share the same local index. -/ -abbrev Store := Std.HashMap Nat (IndexMap (Array Value) Unit) - -structure EvalState where - store : Store := {} - ioBuffer : IOBuffer - deriving Inhabited - -/-- Opaque `Repr` so `SourceError` (whose `earlyReturn` sentinel carries the -state) can keep its derived instance; the state itself is not printable. -/ -instance : Repr EvalState := ⟨fun _ _ => .text ""⟩ - -/-- Tagged errors — small enum, no messages, for use in proof statements. - -The `earlyReturn` case is NOT an error: it is the escape channel for an -explicit `return` inside a function body (e.g. in a non-tail match arm). -It rides the `Except` error track so that every intermediate combinator -propagates it for free, and is unwrapped back into a normal result at the -function-call boundary (`applyGlobal`) — mirroring the Rust executor, -where `Ctrl::Return` unwinds the continuation stack and exits the -function. It never escapes `runFunction`. -/ -inductive SourceError - | outOfFuel - | unboundVar (l : Local) - | unboundGlobal (g : Global) - | typeMismatch (ctx : String) - | arityMismatch (g : Global) - | indexOoB (n : Nat) - | rangeOoB (i j : Nat) - | patternFail - | nonExhaustiveMatch - | ioKeyAlreadySet - | ioKeyNotFound - | ioReadOoB - | invalidPointer (n : Nat) - | notCallable (g : Global) - | notAFunctionValue - | earlyReturn (v : Value) (st : EvalState) - deriving Repr, Inhabited - -/-- Result of evaluation: either a successful value+state pair, or an error. -/ -abbrev EvalResult := Except SourceError (Value × EvalState) - -/-! ## Pattern matching (pure, reads store for pointer dereference) -/ - -mutual - -def matchPattern (store : Store) : - Pattern → Value → Option Bindings - | .wildcard, _ => some [] - | .var l, v => some [(l, v)] - | .field g, .field g' => if g == g' then some [] else none - | .tuple pats, .tuple vs => matchPatsArr store pats vs - | .array pats, .array vs => matchPatsArr store pats vs - | .ref g pats, .ctor g' vs => - if g != g' then none else matchPatsList store pats vs.toList - | .or p1 p2, v => - matchPattern store p1 v <|> matchPattern store p2 v - | .pointer p, .pointer w n => - match store[w]? with - | some inner => - match inner.getByIdx n with - | some (vs, _) => vs[0]?.bind (matchPattern store p ·) - | none => none - | none => none - | _, _ => none - -def matchPatsList (store : Store) : - List Pattern → List Value → Option Bindings - | [], [] => some [] - | p :: ps, v :: vs => do - let b1 ← matchPattern store p v - let b2 ← matchPatsList store ps vs - return b1 ++ b2 - | _, _ => none - -def matchPatsArr (store : Store) - (pats : Array Pattern) (vs : Array Value) : Option Bindings := - matchPatsList store pats.toList vs.toList - -end - -def expectFieldArray (vs : Array Value) : Option (Array G) := - vs.foldlM (init := #[]) fun acc v => - match v with - | .field g => some (acc.push g) - | _ => none - -/-! ## Evaluator - -`fuel : Nat` decrements only on `applyGlobal`. Intra-body recursion is structural. --/ - -def tryLocalLookup (g : Global) (bindings : Bindings) : Option Value := - match g.toName with - | .str .anonymous name => bindings.find? (·.1 == Local.str name) |>.map (·.2) - | _ => none - -/-- Store `v` in its width bucket (width = flat size), content-deduped; -returns the pointer value. Shared by the `.store` arm and the -`unconstrainedBigUintDivMod` chain builder, so hint chains allocate -identically to program stores. -/ -def storeValue (decls : Decls) (st : EvalState) (v : Value) : Value × EvalState := - let w := (flattenValue decls (fun _ => none) v).size - let inner := st.store[w]?.getD (default : IndexMap (Array Value) Unit) - if let some idx := inner.getIdxOf #[v] then - (.pointer w idx, st) - else - let idx := inner.size - let inner' := inner.insert #[v] () - (.pointer w idx, { st with store := st.store.insert w inner' }) - -/-- Dereference a `(width, index)` pointer. -/ -def loadValue (st : EvalState) (w n : Nat) : Except SourceError Value := - match st.store[w]? with - | some inner => - match inner.getByIdx n with - | some (vs, _) => - match vs[0]? with - | some v => .ok v - | none => .error (.invalidPointer n) - | none => .error (.invalidPointer n) - | none => .error (.invalidPointer n) - -/-! ### `List` limb chains (`unconstrainedBigUintDivMod`) - -Value-level mirror of `read_klimbs_u64` / `build_klimbs_u64` in -`crates/aiur/src/execute.rs`: nodes are two-constructor list values — -constructor 0 = Cons(limb, rest), constructor 1 = Nil — with `[U8; 8]` -limb bytes, little-endian within the u64 and head-first across limbs. -/ - -/-- Datatype and declaration-index (= runtime tag) of a constructor. -/ -def ctorInfo (decls : Decls) (g : Global) : - Except SourceError (DataType × Nat) := - match decls.getByKey g with - | some (.constructor dt ctor) => - .ok (dt, dt.constructors.findIdx? (· == ctor) |>.getD 0) - | _ => .error (.unboundGlobal g) - -/-- Walk a limb-chain pointer value, returning the node datatype and the -limbs head-first. `steps` bounds the walk (a chain longer than the store -must revisit a pointer, i.e. a malformed cycle). -/ -def readLimbChain (decls : Decls) (st : EvalState) : - Nat → Value → Except SourceError (DataType × List (Array G)) - | 0, _ => .error (.typeMismatch "unconstrainedBigUintDivMod: cyclic limb list") - | steps+1, ptrVal => do - match ptrVal with - | .pointer w n => - match ← loadValue st w n with - | .ctor g args => - let (dt, tag) ← ctorInfo decls g - if tag == 1 then pure (dt, []) - else if tag == 0 then - match args with - | #[.array byteVals, rest] => - let bytes ← byteVals.mapM fun bv => - match bv with - | .field b => - if b.val < 256 then pure b - else throw (.typeMismatch - "unconstrainedBigUintDivMod: limb byte out of range") - | _ => throw (.typeMismatch - "unconstrainedBigUintDivMod: limb byte not a field") - if bytes.size == 8 then do - let (_, restLimbs) ← readLimbChain decls st steps rest - pure (dt, bytes :: restLimbs) - else throw (.typeMismatch - "unconstrainedBigUintDivMod: limb is not [U8; 8]") - | _ => throw (.typeMismatch - "unconstrainedBigUintDivMod: malformed Cons node") - else throw (.typeMismatch - "unconstrainedBigUintDivMod: unexpected constructor tag") - | _ => throw (.typeMismatch - "unconstrainedBigUintDivMod: node is not a constructor") - | _ => throw (.typeMismatch - "unconstrainedBigUintDivMod: input is not a pointer") - -/-- Build a limb chain from head-first `limbs` using the given Cons/Nil -constructor names; returns the head pointer value. Same order as the Rust -builder (Nil first, then limbs in reverse). -/ -def buildLimbChain (decls : Decls) (consG nilG : Global) (st : EvalState) : - List (Array G) → Value × EvalState - | [] => storeValue decls st (.ctor nilG #[]) - | limb :: rest => - let (restPtr, st') := buildLimbChain decls consG nilG st rest - storeValue decls st' (.ctor consG #[.array (limb.map .field), restPtr]) - -/-- Semantic model of `unconstrainedBigUintDivMod` on already-evaluated -pointer values: walk both chains, divide as `Nat` (which matches the -runtime's `b = 0 → (0, a)` convention), and rebuild canonical result -chains with the input's own constructors. -/ -def bigUintDivModValue (decls : Decls) (aPtr bPtr : Value) - (st : EvalState) : EvalResult := do - let bound := st.store.fold (init := 1) fun acc _ inner => acc + inner.size - let (dt, aLimbs) ← readLimbChain decls st bound aPtr - let (_, bLimbs) ← readLimbChain decls st bound bPtr - match dt.constructors[0]?, dt.constructors[1]? with - | some cons, some nil => - let consG := dt.name.pushNamespace cons.nameHead - let nilG := dt.name.pushNamespace nil.nameHead - let aVal := limbsVal aLimbs - let bVal := limbsVal bLimbs - let (qPtr, st1) := buildLimbChain decls consG nilG st (natToLimbsLE (aVal / bVal)) - let (rPtr, st2) := buildLimbChain decls consG nilG st1 (natToLimbsLE (aVal % bVal)) - pure (.tuple #[qPtr, rPtr], st2) - | _, _ => throw (.typeMismatch - "unconstrainedBigUintDivMod: datatype has fewer than two constructors") - -/-- Array's `sizeOf` strictly exceeds its `toList`'s `sizeOf`. Used in -termination proofs that go from `interp .tuple ts` to `evalList ts.toList`. -/ -private theorem sizeOf_toList_lt {α : Type} [SizeOf α] (a : Array α) : - sizeOf a.toList < 1 + sizeOf a := by - rcases a with ⟨l⟩ - show sizeOf l < 1 + (1 + sizeOf l) - omega - -/-- Combine two pre-computed `interp` results into a binary field-arithmetic -op. Defined outside the mutual block so it bears no termination obligation — -the `interp` calls have already happened by the time this runs, supplied as -`r1 : EvalResult` and `r2 : EvalState → EvalResult` arguments. This replaces -a former `evalBinField` mutual member that introduced cross-function -termination headaches. -/ -@[inline] def combineFieldsResult - (k : G → G → Value) - (r1 : EvalResult) (r2 : EvalState → EvalResult) : EvalResult := - match r1 with - | .error e => .error e - | .ok (v1, st1) => - match r2 st1 with - | .error e => .error e - | .ok (v2, st2) => - match v1, v2 with - | .field a, .field b => .ok (k a b, st2) - | _, _ => .error (.typeMismatch "bin field") - -mutual - -/-- Apply a globally-named function or constructor. Decrements `fuel`; returns -`.outOfFuel` when exhausted. -/ -def applyGlobal (decls : Decls) (fuel : Nat) (g : Global) (args : List Value) - (st : EvalState) : EvalResult := - match fuel with - | 0 => .error .outOfFuel - | fuel+1 => - match decls.getByKey g with - | some (.function f) => - if args.length != f.inputs.length then .error (.arityMismatch g) - else - let bindings := f.inputs.map (·.1) |>.zip args - match interp decls fuel bindings f.body st with - | .error (.earlyReturn v st') => .ok (v, st') - | .error e => .error e - | .ok (v, st') => .ok (v, st') - | some (.constructor _ _) => .ok (.ctor g args.toArray, st) - | none => .error (.unboundGlobal g) - | some (.dataType _) => .error (.notCallable g) -termination_by (fuel, 0, 0) - -def applyLocal (decls : Decls) (fuel : Nat) (v : Value) (args : List Value) - (st : EvalState) : EvalResult := - match v with - | .fn g => applyGlobal decls fuel g args st - | _ => .error .notAFunctionValue -termination_by (fuel, 1, 0) - -/-- Big-step evaluator on `Source.Term`. `fuel` is only consumed at function-call -boundaries; the intra-body recursion here is structural. On a `.ret`, the return -value escapes via a bespoke path that the caller unwraps — implemented here as -a sentinel pattern in the `Except` result. -/ -def interp (decls : Decls) (fuel : Nat) (bindings : Bindings) - (t : Term) (st : EvalState) : EvalResult := - match t with - | .unit => .ok (.unit, st) - | .var l => - match bindings.find? (·.1 == l) with - | some (_, v) => .ok (v, st) - | none => .error (.unboundVar l) - | .ref g => - match decls.getByKey g with - | some (.function _) => .ok (.fn g, st) - | some (.constructor _ ctor) => - if ctor.argTypes.isEmpty then .ok (.ctor g #[], st) - else .error (.notCallable g) - | some (.dataType _) => .error (.notCallable g) - | none => .error (.unboundGlobal g) - | .field g => .ok (.field g, st) - | .tuple ts => - match evalList decls fuel bindings ts.toList st with - | .error e => .error e - | .ok (vs, st') => .ok (.tuple vs, st') - | .array ts => - match evalList decls fuel bindings ts.toList st with - | .error e => .error e - | .ok (vs, st') => .ok (.array vs, st') - | .ann _ t => interp decls fuel bindings t st - | .ret sub => - -- Escape to the enclosing function boundary via the `earlyReturn` - -- sentinel: a `return` inside a non-tail match arm (or any other - -- nested position) must NOT feed the surrounding continuation. - -- `applyGlobal`/`runFunction` unwrap it into a normal result. - match interp decls fuel bindings sub st with - | .error e => .error e - | .ok (v, st') => .error (.earlyReturn v st') - | .let p t1 t2 => - match interp decls fuel bindings t1 st with - | .error e => .error e - | .ok (v, st') => - match matchPattern st'.store p v with - | some bs => interp decls fuel (bs ++ bindings) t2 st' - | none => .error .patternFail - | .match t cases => - match interp decls fuel bindings t st with - | .error e => .error e - | .ok (v, st') => - evalMatchCases decls fuel bindings st' v cases - | .app g args _ => - match evalList decls fuel bindings args st with - | .error e => .error e - | .ok (vs, st') => - match tryLocalLookup g bindings with - | some v => applyLocal decls fuel v vs.toList st' - | none => applyGlobal decls fuel g vs.toList st' - | .add t1 t2 => - match interp decls fuel bindings t1 st with - | .error e => .error e - | .ok (v1, st1) => - match interp decls fuel bindings t2 st1 with - | .error e => .error e - | .ok (v2, st2) => - match v1, v2 with - | .field a, .field b => .ok (.field (a + b), st2) - | _, _ => .error (.typeMismatch "add") - | .sub t1 t2 => - match interp decls fuel bindings t1 st with - | .error e => .error e - | .ok (v1, st1) => - match interp decls fuel bindings t2 st1 with - | .error e => .error e - | .ok (v2, st2) => - match v1, v2 with - | .field a, .field b => .ok (.field (a - b), st2) - | _, _ => .error (.typeMismatch "sub") - | .mul t1 t2 => - match interp decls fuel bindings t1 st with - | .error e => .error e - | .ok (v1, st1) => - match interp decls fuel bindings t2 st1 with - | .error e => .error e - | .ok (v2, st2) => - match v1, v2 with - | .field a, .field b => .ok (.field (a * b), st2) - | _, _ => .error (.typeMismatch "mul") - | .eqZero t => - match interp decls fuel bindings t st with - | .error e => .error e - | .ok (v, st') => - match v with - | .field g => .ok (.field (if g.val == 0 then 1 else 0), st') - | _ => .error (.typeMismatch "eqZero") - | .proj t n => - match interp decls fuel bindings t st with - | .error e => .error e - | .ok (v, st') => - match v with - | .tuple vs => - if h : n < vs.size then .ok (vs[n], st') - else .error (.indexOoB n) - | _ => .error (.typeMismatch "proj") - | .get t n => - match interp decls fuel bindings t st with - | .error e => .error e - | .ok (v, st') => - match v with - | .array vs => - if h : n < vs.size then .ok (vs[n], st') - else .error (.indexOoB n) - | _ => .error (.typeMismatch "get") - | .slice t i j => - match interp decls fuel bindings t st with - | .error e => .error e - | .ok (v, st') => - match v with - | .array vs => .ok (.array (vs.extract i j), st') - | _ => .error (.typeMismatch "slice") - | .set t n vT => - match interp decls fuel bindings vT st with - | .error e => .error e - | .ok (val, st1) => - match interp decls fuel bindings t st1 with - | .error e => .error e - | .ok (arr, st2) => - match arr with - | .array vs => - if h : n < vs.size then .ok (.array (vs.set n val), st2) - else .error (.indexOoB n) - | _ => .error (.typeMismatch "set") - | .store t => - match interp decls fuel bindings t st with - | .error e => .error e - | .ok (v, st') => - -- Width-bucketed store (matches Rust `src/aiur/execute.rs:173-191`). - -- Width = flat size of the stored value (funcIdx-irrelevant for length). - let (ptr, st'') := storeValue decls st' v - .ok (ptr, st'') - | .load t => - match interp decls fuel bindings t st with - | .error e => .error e - | .ok (v, st') => - match v with - | .pointer w n => - match loadValue st' w n with - | .ok v' => .ok (v', st') - | .error e => .error e - | _ => .error (.typeMismatch "load") - | .ptrVal t => - match interp decls fuel bindings t st with - | .error e => .error e - | .ok (v, st') => - match v with - | .pointer _ n => .ok (.field (G.ofNat n), st') - | _ => .error (.typeMismatch "ptrVal") - | .assertEq t1 t2 msg ret => - match interp decls fuel bindings t1 st with - | .error e => .error e - | .ok (v1, st1) => - match interp decls fuel bindings t2 st1 with - | .error e => .error e - | .ok (v2, st2) => - if v1 != v2 then - .error (.typeMismatch (match msg with - | some m => s!"assertEq: {m}" - | none => "assertEq")) - else interp decls fuel bindings ret st2 - | .u8BitDecomposition t => - match interp decls fuel bindings t st with - | .error e => .error e - | .ok (v, st') => - match v with - | .field g => - let byte := g.val.toUInt8 - .ok (.array (Array.ofFn fun (i : Fin 8) => - .field (G.ofUInt8 ((byte >>> i.val.toUInt8) &&& 1))), st') - | _ => .error (.typeMismatch "u8BitDecomposition") - | .u8ShiftLeft t => - match interp decls fuel bindings t st with - | .error e => .error e - | .ok (v, st') => - match v with - | .field g => .ok (.field (G.ofUInt8 (g.val.toUInt8 <<< 1)), st') - | _ => .error (.typeMismatch "u8ShiftLeft") - | .u8ShiftRight t => - match interp decls fuel bindings t st with - | .error e => .error e - | .ok (v, st') => - match v with - | .field g => .ok (.field (G.ofUInt8 (g.val.toUInt8 >>> 1)), st') - | _ => .error (.typeMismatch "u8ShiftRight") - | .u8Xor t1 t2 => - combineFieldsResult (fun a b => .field (G.ofUInt8 (a.val.toUInt8 ^^^ b.val.toUInt8))) - (interp decls fuel bindings t1 st) - (fun st1 => interp decls fuel bindings t2 st1) - | .u8Add t1 t2 => - combineFieldsResult - (fun a b => - let x := a.val.toUInt8.toNat + b.val.toUInt8.toNat - .tuple #[.field (G.ofUInt8 x.toUInt8), - .field (if x >= 256 then 1 else 0)]) - (interp decls fuel bindings t1 st) - (fun st1 => interp decls fuel bindings t2 st1) - | .u8Mul t1 t2 => - combineFieldsResult - (fun a b => - let x := a.val.toUInt8.toNat * b.val.toUInt8.toNat - .tuple #[.field (G.ofUInt8 x.toUInt8), - .field (G.ofUInt8 (x / 256).toUInt8)]) - (interp decls fuel bindings t1 st) - (fun st1 => interp decls fuel bindings t2 st1) - | .u8XorSplit7 t1 t2 => - combineFieldsResult - (fun a b => - let x := a.val.toUInt8 ^^^ b.val.toUInt8 - .tuple #[.field (G.ofUInt8 (x >>> 7)), .field (G.ofUInt8 (x <<< 1))]) - (interp decls fuel bindings t1 st) - (fun st1 => interp decls fuel bindings t2 st1) - | .u8XorSplit4 t1 t2 => - combineFieldsResult - (fun a b => - let x := a.val.toUInt8 ^^^ b.val.toUInt8 - .tuple #[.field (G.ofUInt8 (x >>> 4)), .field (G.ofUInt8 (x <<< 4))]) - (interp decls fuel bindings t1 st) - (fun st1 => interp decls fuel bindings t2 st1) - | .u8Sub t1 t2 => - combineFieldsResult - (fun a b => - let i := a.val.toUInt8; let j := b.val.toUInt8 - .tuple #[.field (G.ofUInt8 (i - j)), .field (if j > i then 1 else 0)]) - (interp decls fuel bindings t1 st) - (fun st1 => interp decls fuel bindings t2 st1) - | .u8And t1 t2 => - combineFieldsResult (fun a b => .field (G.ofUInt8 (a.val.toUInt8 &&& b.val.toUInt8))) - (interp decls fuel bindings t1 st) - (fun st1 => interp decls fuel bindings t2 st1) - | .u8Or t1 t2 => - combineFieldsResult (fun a b => .field (G.ofUInt8 (a.val.toUInt8 ||| b.val.toUInt8))) - (interp decls fuel bindings t1 st) - (fun st1 => interp decls fuel bindings t2 st1) - | .u8LessThan t1 t2 => - combineFieldsResult (fun a b => .field (if a.val.toUInt8 < b.val.toUInt8 then 1 else 0)) - (interp decls fuel bindings t1 st) - (fun st1 => interp decls fuel bindings t2 st1) - | .u32LessThan t1 t2 => - combineFieldsResult (fun a b => .field (if a.val.toUInt32 < b.val.toUInt32 then 1 else 0)) - (interp decls fuel bindings t1 st) - (fun st1 => interp decls fuel bindings t2 st1) - | .unconstrainedU32Add t1 t2 => - match interp decls fuel bindings t1 st with - | .error e => .error e - | .ok (v1, st1) => match interp decls fuel bindings t2 st1 with - | .error e => .error e - | .ok (v2, st2) => match v1, v2 with - | .array a, .array b => - let pack (xs : Array Value) := xs.toList.zipIdx.foldl - (fun n (v, i) => match v with | .field g => n + g.val.toNat * 256 ^ i | _ => n) 0 - let sum := pack a + pack b - .ok (.tuple #[.array (#[0, 1, 2, 3].map fun i => .field (.ofNat ((sum / 256 ^ i) % 256))), - .field (.ofNat (sum / 0x100000000))], st2) - | _, _ => .error (.typeMismatch "unconstrainedU32Add") - | .unconstrainedU32Add3 t1 t2 t3 => - match interp decls fuel bindings t1 st with - | .error e => .error e - | .ok (v1, st1) => match interp decls fuel bindings t2 st1 with - | .error e => .error e - | .ok (v2, st2) => match interp decls fuel bindings t3 st2 with - | .error e => .error e - | .ok (v3, st3) => match v1, v2, v3 with - | .array a, .array b, .array c => - let pack (xs : Array Value) := xs.toList.zipIdx.foldl - (fun n (v, i) => match v with | .field g => n + g.val.toNat * 256 ^ i | _ => n) 0 - let sum := pack a + pack b + pack c - .ok (.tuple #[.array (#[0, 1, 2, 3].map fun i => .field (.ofNat ((sum / 256 ^ i) % 256))), - .field (.ofNat (sum / 0x100000000))], st3) - | _, _, _ => .error (.typeMismatch "unconstrainedU32Add3") - | .u32ToField t => - match interp decls fuel bindings t st with - | .error e => .error e - | .ok (.array a, st') => .ok (.field (.ofNat (a.toList.zipIdx.foldl - (fun n (v, i) => match v with | .field g => n + g.val.toNat * 256 ^ i | _ => n) 0)), st') - | .ok _ => .error (.typeMismatch "u32ToField") - | .u8RangeCheck t1 t2 => - match interp decls fuel bindings t1 st with - | .error e => .error e - | .ok (v1, st1) => - match interp decls fuel bindings t2 st1 with - | .error e => .error e - | .ok (v2, st2) => - match v1, v2 with - | .field a, .field b => - if a.val < 256 && b.val < 256 then - .ok (.tuple #[.field a, .field b], st2) - else .error (.typeMismatch "u8RangeCheck") - | _, _ => .error (.typeMismatch "u8RangeCheck") - | .unconstrainedBigUintDivMod t1 t2 => - match interp decls fuel bindings t1 st with - | .error e => .error e - | .ok (aPtr, st1) => - match interp decls fuel bindings t2 st1 with - | .error e => .error e - | .ok (bPtr, st2) => bigUintDivModValue decls aPtr bPtr st2 - | .unconstrainedGToBytes t => - match interp decls fuel bindings t st with - | .error e => .error e - | .ok (v, st') => - match v with - | .field g => - .ok (.array (Array.ofFn fun i => .field (g.toLeBytes i)), st') - | _ => .error (.typeMismatch "unconstrainedGToBytes") - | .unconstrainedGInverse t => - match interp decls fuel bindings t st with - | .error e => .error e - | .ok (v, st') => - match v with - | .field g => .ok (.field g.inverse, st') - | _ => .error (.typeMismatch "unconstrainedGInverse") - -- `toField` / `u8FromFieldUnsafe` are erased coercions: value unchanged. - | .toField t | .u8FromFieldUnsafe t => interp decls fuel bindings t st - | .u8Lit n => .ok (.field (G.ofNat n), st) - | .debug _ _ ret => interp decls fuel bindings ret st - | .ioGetInfo channel key => - match interp decls fuel bindings channel st with - | .error e => .error e - | .ok (vc, stc) => - match interp decls fuel bindings key stc with - | .error e => .error e - | .ok (v, st') => - match vc, v with - | .field channelG, .array vs => - match expectFieldArray vs with - | none => .error (.typeMismatch "ioGetInfo key") - | some keyGs => - match st'.ioBuffer.map[(channelG, keyGs)]? with - | some info => - .ok (.tuple #[.field (.ofNat info.idx), .field (.ofNat info.len)], st') - | none => .error .ioKeyNotFound - | _, _ => .error (.typeMismatch "ioGetInfo") - | .ioSetInfo channel key idx len ret => - match interp decls fuel bindings channel st with - | .error e => .error e - | .ok (vc, stc) => - match interp decls fuel bindings key stc with - | .error e => .error e - | .ok (vk, stk) => - match interp decls fuel bindings idx stk with - | .error e => .error e - | .ok (vi, sti) => - match interp decls fuel bindings len sti with - | .error e => .error e - | .ok (vl, stl) => - match vc, vk, vi, vl with - | .field channelG, .array vs, .field iG, .field lG => - match expectFieldArray vs with - | none => .error (.typeMismatch "ioSetInfo key") - | some keyGs => - if stl.ioBuffer.map.contains (channelG, keyGs) then - .error .ioKeyAlreadySet - else - let info : IOKeyInfo := ⟨iG.val.toNat, lG.val.toNat⟩ - let st' := { stl with ioBuffer := - { stl.ioBuffer with map := stl.ioBuffer.map.insert (channelG, keyGs) info } } - interp decls fuel bindings ret st' - | _, _, _, _ => .error (.typeMismatch "ioSetInfo") - | .ioRead channel idx len => - match interp decls fuel bindings channel st with - | .error e => .error e - | .ok (vc, stc) => - match interp decls fuel bindings idx stc with - | .error e => .error e - | .ok (v, st') => - match vc, v with - | .field channelG, .field g => - let start := g.val.toNat - let arena := st'.ioBuffer.data.getD channelG #[] - if start + len > arena.size then .error .ioReadOoB - else .ok (.array (arena.extract start (start + len) |>.map .field), st') - | _, _ => .error (.typeMismatch "ioRead") - | .ioWrite channel data ret => - match interp decls fuel bindings channel st with - | .error e => .error e - | .ok (vc, stc) => - match interp decls fuel bindings data stc with - | .error e => .error e - | .ok (v, st') => - match vc, v with - | .field channelG, .array vs => - match expectFieldArray vs with - | none => .error (.typeMismatch "ioWrite") - | some dataGs => - let arena := st'.ioBuffer.data.getD channelG #[] - let st'' := { st' with ioBuffer := - { st'.ioBuffer with data := st'.ioBuffer.data.insert channelG (arena ++ dataGs) } } - interp decls fuel bindings ret st'' - | _, _ => .error (.typeMismatch "ioWrite") -termination_by (fuel, 2, sizeOf t) -decreasing_by - all_goals first - | decreasing_tactic - | (apply Prod.Lex.right; apply Prod.Lex.right - show sizeOf (Array.toList _) < _ - have h := sizeOf_toList_lt (α := Term) - simp only [Term.tuple.sizeOf_spec, Term.array.sizeOf_spec] - exact h _) - -/-- Structurally-recursive `match` arm dispatcher. Walks `cases` and returns the -first arm that matches, evaluating its body. Splits out from `interp`'s `.match` -arm so termination is provable: each recursive `interp` call uses a `body` -that's structurally smaller than `cases` (via `List.sizeOf_lt_of_mem`). -/ -def evalMatchCases (decls : Decls) (fuel : Nat) (bindings : Bindings) - (st : EvalState) (v : Value) : - List (Pattern × Term) → EvalResult - | [] => .error .nonExhaustiveMatch - | (p, body) :: rest => - match matchPattern st.store p v with - | some bs => interp decls fuel (bs ++ bindings) body st - | none => evalMatchCases decls fuel bindings st v rest -termination_by cases => (fuel, 2, sizeOf cases) - -def evalList (decls : Decls) (fuel : Nat) (bindings : Bindings) - : List Term → EvalState → Except SourceError (Array Value × EvalState) - | [], st => .ok (#[], st) - | t :: ts, st => - match interp decls fuel bindings t st with - | .error e => .error e - | .ok (v, st') => - match evalList decls fuel bindings ts st' with - | .error e => .error e - | .ok (vs, st'') => .ok (#[v] ++ vs, st'') -termination_by ts _ => (fuel, 2, sizeOf ts) - -end - -/-! ## Top-level entry -/ - -/-- Run a named function with the given input values, under fuel. -/ -def runFunction (decls : Decls) (funcName : Global) (inputs : List Value) - (ioBuffer : IOBuffer := default) (fuel : Nat) : - Except SourceError (Value × IOBuffer) := - let st : EvalState := { ioBuffer } - match applyGlobal decls fuel funcName inputs st with - | .error e => .error e - | .ok (v, st') => .ok (v, st'.ioBuffer) - -end Source.Eval - -end Aiur - -end -- @[expose] section -end diff --git a/Ix/Aiur/Stages/Bytecode.lean b/Ix/Aiur/Stages/Bytecode.lean deleted file mode 100644 index f0251fbf5..000000000 --- a/Ix/Aiur/Stages/Bytecode.lean +++ /dev/null @@ -1,199 +0,0 @@ -module -public import Ix.Aiur.Goldilocks - -/-! -Stage 5 (Bytecode) IR — flat, post-lowering. - -Later passes (`deduplicate`, `needsCircuit`) produce Stage 6 bytecode with the -same datatype. --/ - -public section - -namespace Aiur - -namespace Bytecode - -abbrev FunIdx := Nat -abbrev ValIdx := Nat -abbrev SelIdx := Nat - -inductive Op - | const : G → Op - | add : ValIdx → ValIdx → Op - | sub : ValIdx → ValIdx → Op - | mul : ValIdx → ValIdx → Op - | eqZero : ValIdx → Op - | call : FunIdx → Array ValIdx → (outputSize : Nat) → (unconstrained : Bool) → Op - | store : Array ValIdx → Op - | load : (size : Nat) → ValIdx → Op - | assertEq : Array ValIdx → Array ValIdx → Option String → Op - | ioGetInfo : ValIdx → Array ValIdx → Op - | ioSetInfo : ValIdx → Array ValIdx → ValIdx → ValIdx → Op - | ioRead : ValIdx → ValIdx → Nat → Op - | ioWrite : ValIdx → Array ValIdx → Op - | u8BitDecomposition : ValIdx → Op - | u8ShiftLeft : ValIdx → Op - | u8ShiftRight : ValIdx → Op - | u8Xor : ValIdx → ValIdx → Op - | u8Add : ValIdx → ValIdx → Op - | u8Mul : ValIdx → ValIdx → Op - | u8Sub : ValIdx → ValIdx → Op - | u8And : ValIdx → ValIdx → Op - | u8Or : ValIdx → ValIdx → Op - | u8LessThan : ValIdx → ValIdx → Op - | u32LessThan : ValIdx → ValIdx → Op - | u8XorSplit7 : ValIdx → ValIdx → Op - | u8XorSplit4 : ValIdx → ValIdx → Op - | debug : String → Option (Array ValIdx) → Op - /-- Range-check the two values into `[0, 256)` via the byte chip. Produces no - new values: it is a pure side-effect (lookup), and its `u8` results alias the - two inputs. Kept last so its FFI tag (27) doesn't shift the others. -/ - | u8RangeCheck : ValIdx → ValIdx → Op - /-- Unconstrained LE byte-list division-modulo hint. Inputs are pointers to - two `List` (klimbs) values. Produces 2 fresh pointer values - `(q_ptr, r_ptr)` to newly-built `List` values such that `q*b + r = a` - and `0 ≤ r < b` (when `b > 0`). No constraint relation emitted; caller - must verify in constrained code. -/ - | unconstrainedBigUintDivMod : ValIdx → ValIdx → Op - /-- Unconstrained hint: the 8 LE bytes of a field element's canonical `u64` - value. 8 fresh auxiliary values, no constraint relation, no lookup; the - caller must range-check, recompose-assert, and canonicality-assert. - Appended last so the existing FFI tags don't shift (tag 29). -/ - | unconstrainedGToBytes : ValIdx → Op - /-- Unconstrained hint: the field inverse of a value (`0 ↦ 0`). One fresh - auxiliary value, no constraint relation; the caller must pin it via - multiply-and-assert. Appended last (tag 30). -/ - | unconstrainedGInverse : ValIdx → Op - /-- Native wrapping u32 addition. Four result bytes are advice columns; the - carry is a fifth logical output represented by a compound expression. -/ - | unconstrainedU32Add : Array ValIdx → Array ValIdx → Op - /-- Native wrapping three-input u32 addition, with virtual carry output. -/ - | unconstrainedU32Add3 : Array ValIdx → Array ValIdx → Array ValIdx → Op - /-- Virtual LE-byte packing expression; allocates no auxiliary column. -/ - | u32ToField : Array ValIdx → Op - deriving Repr, BEq, Hashable - -/-- Number of values appended to the bytecode value stack, including virtual -results that do not allocate witness columns. -/ -def Op.outputCount : Op → Nat - | .const _ => 1 - | .add .. | .sub .. | .mul .. | .eqZero .. => 1 - | .call _ _ size _ | .load size _ | .ioRead _ _ size => size - | .store .. => 1 - | .ioGetInfo .. => 2 - | .u8BitDecomposition .. | .unconstrainedGToBytes .. => 8 - | .u8ShiftLeft .. | .u8ShiftRight .. | .u8Xor .. | .u8And .. - | .u8Or .. | .u8LessThan .. | .u32LessThan .. => 1 - | .u8Mul .. | .u8Add .. | .u8Sub .. | .u8XorSplit7 .. - | .u8XorSplit4 .. | .unconstrainedBigUintDivMod .. => 2 - | .unconstrainedGInverse .. | .u32ToField .. => 1 - | .unconstrainedU32Add .. | .unconstrainedU32Add3 .. => 5 - | .assertEq .. | .ioSetInfo .. | .ioWrite .. | .u8RangeCheck .. - | .debug .. => 0 - -/-- Value-stack operands in source evaluation order. Function indices, -memory widths and result counts are metadata, not value references. -/ -def Op.inputs : Op → Array ValIdx - | .const _ => #[] - | .add a b | .sub a b | .mul a b | .u8Xor a b | .u8Add a b - | .u8Mul a b | .u8Sub a b | .u8And a b | .u8Or a b - | .u8LessThan a b | .u32LessThan a b | .u8XorSplit7 a b - | .u8XorSplit4 a b | .u8RangeCheck a b - | .unconstrainedBigUintDivMod a b => #[a, b] - | .eqZero a | .load _ a | .u8BitDecomposition a | .u8ShiftLeft a - | .u8ShiftRight a | .unconstrainedGToBytes a - | .unconstrainedGInverse a => #[a] - | .call _ args _ _ | .store args | .u32ToField args => args - | .assertEq xs ys _ | .unconstrainedU32Add xs ys => xs ++ ys - | .ioGetInfo channel key => #[channel] ++ key - | .ioSetInfo channel key idx len => #[channel] ++ key ++ #[idx, len] - | .ioRead channel idx _ => #[channel, idx] - | .ioWrite channel data => #[channel] ++ data - | .unconstrainedU32Add3 xs ys zs => xs ++ ys ++ zs - | .debug _ args => args.getD #[] - -mutual - inductive Ctrl where - | match : ValIdx → Array (G × Block) → Option Block → Ctrl - | return : SelIdx → Array ValIdx → Ctrl - | yield : SelIdx → Array ValIdx → Ctrl - | matchContinue : ValIdx → Array (G × Block) → Option Block - → (outputSize : Nat) → (sharedAuxiliaries : Nat) → (sharedLookups : Nat) - → Block → Ctrl - deriving Inhabited, Repr - - structure Block where - ops : Array Op - ctrl : Ctrl - deriving Inhabited, Repr -end - -deriving instance BEq, Hashable for Ctrl, Block - - -/-- The circuit layout of a function (non-semantic; the bytecode evaluator ignores it). -/ -structure FunctionLayout where - inputSize : Nat - selectors : Nat - auxiliaries : Nat - lookups : Nat - deriving Inhabited, Repr, BEq, Hashable, DecidableEq - -def FunctionLayout.width (l : FunctionLayout) : Nat := - l.inputSize + l.selectors + l.auxiliaries - -/-- Layout-only estimate of main and stage-2 width. This lacks the control -tree, compiled lookup degrees and PCS parameters; use the built system's -`circuitShapes` for actual widths after lookup tuning. -/ -def FunctionLayout.totalWidth (l : FunctionLayout) : Nat := - -- Stage 2 commits max(⌈L/k⌉, 1) chained partial accumulators (no message - -- inverses); see `multi_stark::lookup::stage2_width`. Retain the original - -- single-selector heuristic here; synthesis checks control flow and - -- retunes using compiled degrees and the FFT cost. - let slots := if l.selectors == 1 && l.lookups >= 2 - then (l.lookups + 1) / 2 - else max l.lookups 1 - l.width + G.extensionDegree * slots - -structure Function where - body : Block - layout: FunctionLayout - entry : Bool - constrained : Bool - deriving Inhabited, Repr - -/-- A circuit of the proving system, backing one or more functions. By -default every constrained function gets a singleton circuit named after it; -`CompiledToplevel.groupFunctions` can regroup several functions into one -circuit whose branching selects the member function. `layout` is the merged -layout: max `inputSize`, sum of `selectors`, max `auxiliaries` (which -includes the single shared multiplicity column), max `lookups` (slot 0 is -the shared return lookup). -/ -structure Circuit where - name : String - members : Array FunIdx - layout : FunctionLayout - deriving Inhabited, Repr - -/-- Merged layout of a group of functions (see `Circuit`). -/ -def FunctionLayout.merge (a b : FunctionLayout) : FunctionLayout where - inputSize := a.inputSize.max b.inputSize - selectors := a.selectors + b.selectors - auxiliaries := a.auxiliaries.max b.auxiliaries - lookups := a.lookups.max b.lookups - -structure Toplevel where - functions : Array Function - memorySizes : Array Nat - /-- Circuit partition of the constrained functions, in first-occurrence - order. Built by `Source.Toplevel.compile` (singletons by default; see - `CompiledToplevel.groupFunctions`); empty on a freshly lowered toplevel. -/ - circuits : Array Circuit := #[] - deriving Repr - -end Bytecode - -end Aiur - -end diff --git a/Ix/Aiur/Stages/Codegen.lean b/Ix/Aiur/Stages/Codegen.lean deleted file mode 100644 index 06ee0fb41..000000000 --- a/Ix/Aiur/Stages/Codegen.lean +++ /dev/null @@ -1,672 +0,0 @@ -/- - Aiur bytecode → structured Rust syntax → Rust source. - - Emits one const-generic Rust function per Aiur function. Ordinary calls - inherit UNCONSTRAINED, hint calls select true, and entry dispatch selects - false. Real Rust locals replace the interpreter's value stack. - - Correctness invariant: native execution preserves the interpreter's - QueryRecord, including insertion order, multiplicities, hint promotion, - byte-chip queries, and IO order. Return registration happens AFTER the - callee body and rechecks the complete input key, reusing the caller's hash. - - Syntax and formatting live in Codegen.Rust. This module only constructs - syntax trees; strings here are identifiers, diagnostic text, or the fixed - module header, never executable Rust fragments. --/ -module -public import Ix.Aiur.Stages.Bytecode -public import Ix.Aiur.Codegen.Rust - -public section -namespace Aiur.Codegen -open Bytecode - -/-! ## Shared syntax constructors -/ - -private def gTy : RustType := .named "G" -private def gArray (n : Nat) : RustType := .array gTy (.value n) -private def inputTy (idx : Nat) : RustType := .array gTy (.named s!"IN_{idx}") -private def outputTy (idx : Nat) : RustType := .array gTy (.named s!"OUT_{idx}") -private def resultTy (ty : RustType) : RustType := .app "Result" #[ty, .named "ExecError"] -private def method (e : RustExpr) (name : String) (args : Array RustExpr := #[]) : RustExpr := - .methodCall e name args -private def staticCall (ty name : String) (args : Array RustExpr) : RustExpr := - .call (.path #[ty, name]) args -private def runtimeCall (name : String) (args : Array RustExpr) : RustExpr := - .call (.path #["aiur", "execute", name]) args -private def errorValue (name : String) (args : Array RustExpr) : RustExpr := - staticCall "ExecError" name args -private def returnError (e : RustExpr) : RustStmt := .returnStmt (.call (.var "Err") #[e]) -private def tailBlock (e : RustExpr) : RustBlock := { tail := some e } -private def blockValue (ss : Array RustStmt) (e : RustExpr) : RustExpr := - .block { stmts := ss, tail := some e } -private def sliceRef (e : RustExpr) : RustExpr := .ref (.index e (.range none none)) -private def canonical (e : RustExpr) : RustExpr := method e "as_canonical_u64" -private def expect (e : RustExpr) (msg : String) : RustExpr := - method e "expect" #[.string msg] -private def checkedCast (ty : String) (e : RustExpr) (error : String) : RustExpr := - .tryExpr (method (method (staticCall ty "try_from" #[e]) "ok") "ok_or" - #[errorValue error #[e]]) -private def fixedArray (e : RustExpr) (size : Nat) : RustExpr := - method (method (.index e (.range none (some (.nat size)))) "try_into") "unwrap" - -def gZero : RustExpr := .path #["G", "ZERO"] -def gFromU64 (n : Nat) : RustExpr := staticCall "G" "from_u64" #[.nat n] -def gFromBool (e : RustExpr) : RustExpr := staticCall "G" "from_bool" #[e] -def gFromUsize (e : RustExpr) : RustExpr := staticCall "G" "from_usize" #[e] -def valVar (i : Nat) : RustExpr := .var s!"__v_{i}" -def declVal (i : Nat) (e : RustExpr) : RustStmt := - .letStmt false s!"__v_{i}" (some gTy) e -def argsAsArray (is : Array ValIdx) : RustExpr := .arrayLit (is.map valVar) -def funQueriesAt (idx : Nat) : RustExpr := - .index (.field (.var "record") "function_queries") (.nat idx) -def notUnconstrained : RustExpr := .not (.var "unconstrained") -private def whenConstrained (ss : Array RustStmt) : RustStmt := - .ifStmt notUnconstrained ss none -private def bumpMultiplicity (table idx : RustExpr) : RustStmt := - .exprStmt (method table "bump_multiplicity" #[idx]) -private def lookupKey (table key : RustExpr) : RustStmt := - .letPattern (.tuple #[.binding "__hash", .binding "__hit"]) none - (method table "lookup" #[sliceRef key]) -private def splatArray (out count : Nat) (name : String) : Array RustStmt := - (Array.range count).map fun k => declVal (out + k) (.index (.var name) (.nat k)) -private def splatTuple (out count : Nat) (name : String) : Array RustStmt := - (Array.range count).map fun k => declVal (out + k) (.field (.var name) (toString k)) -private def nativeCall (idx : Nat) (mode : RustExpr) (input hash : RustExpr) : RustExpr := - .tryExpr (.call (.constGeneric (.var s!"aiur_fn_{idx}") #[mode]) - #[input, hash, .var "record", .var "io_buffer"]) - -/-! ## Operation emission -/ - -private def emitConst (out : Nat) (c : Aiur.G) : Array RustStmt := - #[declVal out (gFromU64 c.n)] - -private def emitBinop (out : Nat) (op : RustBinOp) (a b : ValIdx) : Array RustStmt := - #[declVal out (.binop op (valVar a) (valVar b))] - -private def emitEqZero (out : Nat) (a : ValIdx) : Array RustStmt := - #[declVal out (gFromBool (.binop .eq (valVar a) gZero))] - -/-- Cached hints must be replayed in constrained mode to promote their whole - dependency tree, not just the cached row. A hit may only skip the body - when already constrained or when the caller also requests a hint. -/ -private def emitCall (out : Nat) (callee : FunIdx) (args : Array ValIdx) - (outSize : Nat) (opUn : Bool) : Array RustStmt := - let queries := funQueriesAt callee - let mode : RustExpr := if opUn then .bool true else .var "UNCONSTRAINED" - let guard : RustExpr := if opUn then .bool true else - .binop .or (.var "__cu") (.binop .ne (method queries "mult_at" #[.var "__i"]) gZero) - let bump := if opUn then #[] else - #[whenConstrained #[bumpMultiplicity queries (.var "__i")]] - -- Every row in this function's table has exactly OUT_N outputs. Preserve - -- the existing unchecked array copy, explicitly scoped as an unsafe block. - let cached := .unsafeBlock (tailBlock (.deref - (.cast (method (method queries "output_at" #[.var "__i"]) "as_ptr") - (.ptr false (outputTy callee))))) - let hit : MatchArm := { - pat := .constructor #["Some"] #[.binding "__i"], guard := some guard - body := { stmts := bump ++ #[.letStmt false "__ret" (some (outputTy callee)) cached] - tail := some (.var "__ret") } - } - let miss : MatchArm := { - pat := .wildcard - body := tailBlock (nativeCall callee mode (.var "__args") (.var "__hash")) - } - let lookup : RustBlock := { - stmts := #[lookupKey queries (.var "__args")] - tail := some (.matchExpr (.var "__hit") #[hit, miss]) - } - -- A constrained call another record answers is deferred: the caller's row - -- pushes it and nothing runs (mirrors execute.rs `Op::Call`). Only a callee - -- without outputs is ever deferrable, so the zero array is its whole result. - let body : RustExpr := if opUn then .block lookup else - .ifExpr (.binop .and notUnconstrained - (.tryExpr (method (.var "record") "defer_call" #[.nat callee, sliceRef (.var "__args")]))) - (tailBlock (.arrayRepeat gZero (.named s!"OUT_{callee}"))) - lookup - let rhs := blockValue #[ - .letStmt false "__args" (some (inputTy callee)) (argsAsArray args), - .letStmt false "__cu" none (if opUn then .bool true else .var "unconstrained") - ] body - #[.letStmt false "__r_arr" (some (outputTy callee)) rhs] ++ - splatArray out outSize "__r_arr" - -/-- Fixed table slots are validated once by entry dispatch. Standalone op - emission, which has no toplevel layout, uses the width-keyed fallback. -/ -private def memoryQuery (memorySizes : Array Nat) (size : Nat) : RustExpr := - let tables : RustExpr := .field (.var "record") "memory_queries" - let query := match memorySizes.findIdx? (· == size) with - | some slot => method (method tables "get_index_mut" #[.nat slot]) "map" - #[.closure #[.tuple #[.wildcard, .binding "q"]] (.var "q")] - | none => method tables "get_mut" #[.ref (.nat size)] - .tryExpr (method query "ok_or" #[errorValue "InvalidMemorySize" #[.nat size]]) - -private def emitStore (out : Nat) (values : Array ValIdx) - (memorySizes : Array Nat) : Array RustStmt := - let table : RustExpr := .var "__mq" - let hit : MatchArm := { - pat := .constructor #["Some"] #[.binding "__i"] - body := { - stmts := #[whenConstrained #[bumpMultiplicity table (.var "__i")]] - tail := some (.index (method table "output_at" #[.var "__i"]) (.nat 0)) - } - } - let miss : MatchArm := { - pat := .wildcard - body := { - -- Pointers are offset by the record's base so that the tables of a - -- batch of records never hand out the same address twice. - stmts := #[ - .exprStmt (.tryExpr (runtimeCall "check_store" - #[.ref (.field (.var "record") "budget"), table, .nat values.size])), - .letStmt false "__ptr" none (gFromUsize - (.binop .add (.field (.var "record") "pointer_base") (method table "len"))), - .exprStmt (.tryExpr (method table "insert_hashed" #[ - sliceRef (.var "__values"), .ref (.arrayLit #[.var "__ptr"]), - gFromBool notUnconstrained, .var "__hash"])) - ] - tail := some (.var "__ptr") - } - } - #[declVal out (blockValue #[ - .letStmt false "__values" (some (gArray values.size)) (argsAsArray values), - .letStmt false "__mq" none (memoryQuery memorySizes values.size), - lookupKey table (.var "__values") - ] (.matchExpr (.var "__hit") #[hit, miss]))] - -private def emitLoad (out size : Nat) (ptr : ValIdx) - (memorySizes : Array Nat) : Array RustStmt := - let table : RustExpr := .var "__mq" - -- The table index is the pointer less the record's base (see `emitStore`). - let index : RustExpr := .tryExpr (method (method (method - (checkedCast "usize" (.var "__ptr_u64") "PointerTooLarge") - "checked_sub" #[.var "__base"]) - "filter" #[.closure #[.binding "__i"] (.binop .lt (.deref (.var "__i")) (method table "len"))]) - "ok_or" #[.structLit #["ExecError", "UnboundPointer"] - #[("ptr", .var "__ptr_u64"), ("size", .nat size)]]) - let rhs := blockValue #[ - .letStmt false "__base" none (.field (.var "record") "pointer_base"), - .letStmt false "__mq" none (memoryQuery memorySizes size), - .letStmt false "__ptr_u64" none (canonical (valVar ptr)), - .letStmt false "__idx" none index, - whenConstrained #[bumpMultiplicity table (.var "__idx")], - .letPattern (.tuple #[.binding "__args", .wildcard]) none - (expect (method table "get_index" #[.var "__idx"]) "bounds checked above"), - .letStmt false "__arr" (some (gArray size)) (fixedArray (.var "__args") size) - ] (.var "__arr") - #[.letStmt false "__loaded" (some (gArray size)) rhs] ++ splatArray out size "__loaded" - -private def emitAssertEq (xs ys : Array ValIdx) (msg : Option String) : Array RustStmt := - let message : RustExpr := match msg with - | some m => .call (.var "Some") #[method (.string m) "to_string"] - | none => .var "None" - if xs.size != ys.size then - #[returnError (.structLit #["ExecError", "AssertEqLengthMismatch"] - #[("lhs", .nat xs.size), ("rhs", .nat ys.size)])] - else (xs.zip ys).map fun (x, y) => - .ifStmt (.binop .ne (valVar x) (valVar y)) - #[returnError (.structLit #["ExecError", "AssertEqMismatch"] - #[("lhs", canonical (valVar x)), ("rhs", canonical (valVar y)), ("msg", message)])] none - -/-! ### IO -/ - -private def emitIOGetInfo (out channel : Nat) (key : Array ValIdx) : Array RustStmt := - #[.letStmt false "__io_pair" (some (.tuple #[gTy, gTy])) (blockValue #[ - .letStmt false "__key" (some (gArray key.size)) (argsAsArray key), - .letStmt false "__info" none - (.tryExpr (method (.var "io_buffer") "get_info" #[valVar channel, sliceRef (.var "__key")])) - ] (.tuple #[gFromUsize (.field (.var "__info") "idx"), - gFromUsize (.field (.var "__info") "len")]))] ++ splatTuple out 2 "__io_pair" - -private def emitIOSetInfo (channel : ValIdx) (key : Array ValIdx) - (idx len : ValIdx) : Array RustStmt := - #[.block #[ - .letStmt false "__key" (some (gArray key.size)) (argsAsArray key), - .letStmt false "__idx" none (checkedCast "usize" (canonical (valVar idx)) "IndexTooLarge"), - .letStmt false "__len" none (checkedCast "usize" (canonical (valVar len)) "IndexTooLarge"), - .exprStmt (.tryExpr (method (.var "io_buffer") "set_info" - #[valVar channel, method (.var "__key") "to_vec", .var "__idx", .var "__len"])) - ]] - -private def emitIORead (out channel idx len : Nat) : Array RustStmt := - #[.letStmt false "__io_read" (some (gArray len)) (blockValue #[ - .letStmt false "__idx_u64" none (canonical (valVar idx)), - .letStmt false "__idx" none (checkedCast "usize" (.var "__idx_u64") "IndexTooLarge"), - .letStmt false "__data" none - (.tryExpr (method (.var "io_buffer") "read" #[valVar channel, .var "__idx", .nat len])), - .letStmt false "__arr" (some (gArray len)) (fixedArray (.var "__data") len) - ] (.var "__arr"))] ++ splatArray out len "__io_read" - -private def emitIOWrite (channel : ValIdx) (data : Array ValIdx) : Array RustStmt := - #[.exprStmt (method (.var "io_buffer") "write" - #[valVar channel, method (argsAsArray data) "into_iter"])] - -/-! ### Byte operations and hints -/ - -/-- Helper paths are explicit in the tree, not inferred by searching source. - The constrained helper records queries; the hint computes only values. -/ -private def byteResult (chip shortcut helper : String) (args : Array ValIdx) : RustExpr := - .ifExpr (.var "unconstrained") - (tailBlock (.call (.path #["aiur", "execute", chip, shortcut]) - (args.map fun i => .ref (valVar i)))) - (tailBlock (runtimeCall helper ((args.map valVar).push (.var "record")))) - -private def emitU8Bytes1 (out : Nat) (helper shortcut : String) - (byte : ValIdx) (outCount : Nat) : Array RustStmt := - if outCount == 1 then - #[declVal out (byteResult "CodegenBytes1" shortcut helper #[byte])] - else - -- The hint returns Vec, while the constrained helper returns [G; 8]. - let hint : RustBlock := { - stmts := #[ - .letStmt false "__v" (some (.app "Vec" #[gTy])) - (.call (.path #["aiur", "execute", "CodegenBytes1", shortcut]) #[.ref (valVar byte)]), - .letStmt false "__a" (some (gArray outCount)) - (method (method (.var "__v") "try_into") "unwrap") - ] - tail := some (.var "__a") - } - #[.letStmt false "__b1_out" (some (gArray outCount)) - (.ifExpr (.var "unconstrained") hint - (tailBlock (runtimeCall helper #[valVar byte, .var "record"])))] ++ - splatArray out outCount "__b1_out" - -private def emitU8Bytes2 (out : Nat) (helper shortcut : String) - (i j : ValIdx) (outCount : Nat) : Array RustStmt := - let rhs := byteResult "CodegenBytes2" shortcut helper #[i, j] - if outCount == 1 then #[declVal out rhs] - else - #[.letStmt false "__b2_out" (some (.tuple (Array.replicate outCount gTy))) rhs] ++ - splatTuple out outCount "__b2_out" - -private def emitU32LessThan (out x y : Nat) : Array RustStmt := - let bump (e : RustExpr) : RustStmt := - .exprStmt (method (.field (.var "record") "bytes2_queries") "bump_u16_range_check" - #[.cast e (.named "u16")]) - #[declVal out (blockValue #[ - .letStmt false "__a_val" none (canonical (valVar x)), - .letStmt false "__b_val" none (canonical (valVar y)), - .letStmt false "__a_u32" none (checkedCast "u32" (.var "__a_val") "U32OutOfRange"), - .letStmt false "__b_u32" none (checkedCast "u32" (.var "__b_val") "U32OutOfRange"), - .letStmt false "__result" none (gFromBool (.binop .lt (.var "__a_u32") (.var "__b_u32"))), - whenConstrained #[ - .letStmt false "__c_u32" none (method (.var "__a_u32") "wrapping_sub" #[.var "__b_u32"]), - .forStmt (.binding "__word") (.arrayLit #[.var "__a_u32", .var "__c_u32", .var "__b_u32"]) - #[bump (.binop .bitAnd (.var "__word") (.nat 65535)), - bump (.binop .shr (.var "__word") (.nat 16))] - ] - ] (.var "__result"))] - -private def u32PackExpr (xs : Array ValIdx) : RustExpr := - let terms := xs.mapIdx fun i idx => .binop .shl (canonical (valVar idx)) (.nat (8 * i)) - -- Valid bytecode supplies four limbs. Zero also gives a well-formed empty fold. - match terms.toList with - | [] => .nat 0 - | first :: rest => rest.foldl (.binop .bitOr) first - -private def emitUnconstrainedU32Add (out : Nat) (inputs : List (Array ValIdx)) : Array RustStmt := - let terms := inputs.map fun xs => staticCall "u128" "from" #[u32PackExpr xs] - let sum := match terms with - | [] => .nat 0 - | first :: rest => rest.foldl (.binop .add) first - #[ - .letStmt false "__u32_sum" (some (.named "u128")) sum, - .letStmt false "__u32_bytes" none (method - (expect (staticCall "u32" "try_from" #[.binop .bitAnd (.var "__u32_sum") (.nat 4294967295)]) - "masked") "to_le_bytes") - ] ++ (Array.range 4).map (fun i => - declVal (out + i) (staticCall "G" "from_u8" #[.index (.var "__u32_bytes") (.nat i)])) ++ - #[declVal (out + 4) (staticCall "G" "from_u64" #[ - expect (staticCall "u64" "try_from" #[.binop .shr (.var "__u32_sum") (.nat 32)]) - "u32 sum overflow fits u64"])] - -private def emitU32ToField (out : Nat) (bytes : Array ValIdx) : Array RustStmt := - #[declVal out (staticCall "G" "from_u64" #[u32PackExpr bytes])] - -private def emitU8RangeCheck (i j : ValIdx) : Array RustStmt := - #[whenConstrained #[ - .letStmt false "__vi" none (valVar i), - .letStmt false "__vj" none (valVar j), - .letStmt false "__bi" none (canonical (.var "__vi")), - .letStmt false "__bj" none (canonical (.var "__vj")), - .ifStmt (.binop .ge (.var "__bi") (.nat 256)) - #[returnError (errorValue "U8RangeCheckFailed" #[.var "__bi"])] none, - .ifStmt (.binop .ge (.var "__bj") (.nat 256)) - #[returnError (errorValue "U8RangeCheckFailed" #[.var "__bj"])] none, - .exprStmt (method (.field (.var "record") "bytes2_queries") "bump_range_check" - #[.ref (.var "__vi"), .ref (.var "__vj")]) - ]] - -private def emitUncBigUintDivMod (out a b : Nat) : Array RustStmt := - #[.letStmt false "__bu_qr" (some (.tuple #[gTy, gTy])) - (.tryExpr (runtimeCall "unconstrained_big_uint_div_mod_helper" - #[valVar a, valVar b, .var "record"]))] ++ splatTuple out 2 "__bu_qr" - -private def emitUncGToBytes (out a : Nat) : Array RustStmt := - #[.letStmt false "__gb" (some (.array (.named "u8") (.value 8))) - (method (canonical (valVar a)) "to_le_bytes")] ++ - (Array.range 8).map fun i => - declVal (out + i) (staticCall "G" "from_u8" #[.index (.var "__gb") (.nat i)]) - -private def emitUncGInverse (out a : Nat) : Array RustStmt := - #[declVal out (runtimeCall "g_inverse_value" #[valVar a])] - -private def emitDebug (label : String) (args : Option (Array ValIdx)) : Array RustStmt := - -- Format-string braces and Rust string escaping are separate concerns. - let label := label.replace "{" "{{" |>.replace "}" "}}" - let (format, values) := match args with - | none => (label, #[]) - | some idxs => - (label ++ ": " ++ ", ".intercalate (idxs.toList.map fun _ => "{}"), idxs.map valVar) - #[.exprStmt (.macroCall "println" (#[.string format] ++ values))] - -/-- Top-level op dispatch. `out` = the first ValIdx for outputs; - callers must advance their counter by `Op.outputCount`. -/ -def emitOp (out : Nat) (op : Op) (memorySizes : Array Nat := #[]) : Array RustStmt := - match op with - | .const c => emitConst out c - | .add a b => emitBinop out .add a b - | .sub a b => emitBinop out .sub a b - | .mul a b => emitBinop out .mul a b - | .eqZero a => emitEqZero out a - | .call callee args outSz opUn => emitCall out callee args outSz opUn - | .store vs => emitStore out vs memorySizes - | .load size ptr => emitLoad out size ptr memorySizes - | .assertEq xs ys msg => emitAssertEq xs ys msg - | .ioGetInfo ch key => emitIOGetInfo out ch key - | .ioSetInfo ch key idx len => emitIOSetInfo ch key idx len - | .ioRead ch idx len => emitIORead out ch idx len - | .ioWrite ch data => emitIOWrite ch data - | .u8BitDecomposition b => emitU8Bytes1 out "bytes1_bit_decompose_value" "bit_decompose" b 8 - | .u8ShiftLeft b => emitU8Bytes1 out "bytes1_shift_left_value" "shift_left" b 1 - | .u8ShiftRight b => emitU8Bytes1 out "bytes1_shift_right_value" "shift_right" b 1 - | .u8Xor i j => emitU8Bytes2 out "bytes2_xor_value" "xor" i j 1 - | .u8Mul i j => emitU8Bytes2 out "bytes2_mul_value" "mul" i j 2 - | .u8And i j => emitU8Bytes2 out "bytes2_and_value" "and" i j 1 - | .u8Or i j => emitU8Bytes2 out "bytes2_or_value" "or" i j 1 - | .u8LessThan i j => emitU8Bytes2 out "bytes2_less_than_value" "less_than" i j 1 - | .u8XorSplit7 i j => emitU8Bytes2 out "bytes2_xor_split7_value" "xor_split7" i j 2 - | .u8XorSplit4 i j => emitU8Bytes2 out "bytes2_xor_split4_value" "xor_split4" i j 2 - | .u8Add i j => emitU8Bytes2 out "bytes2_add_value" "add" i j 2 - | .u8Sub i j => emitU8Bytes2 out "bytes2_sub_value" "sub" i j 2 - | .u32LessThan a b => emitU32LessThan out a b - | .u8RangeCheck i j => emitU8RangeCheck i j - | .unconstrainedBigUintDivMod a b => emitUncBigUintDivMod out a b - | .unconstrainedGToBytes a => emitUncGToBytes out a - | .unconstrainedGInverse a => emitUncGInverse out a - | .unconstrainedU32Add a b => emitUnconstrainedU32Add out [a, b] - | .unconstrainedU32Add3 a b c => emitUnconstrainedU32Add out [a, b, c] - | .u32ToField a => emitU32ToField out a - | .debug label args => emitDebug label args - -/-! ## Ctrl emission -/ - -/-- Scan a Block for the first `Ctrl.return`'s arity. Aiur fn layouts - are fixed, so all Returns in a fn agree; we only need one. -/ -partial def findReturnArity (b : Block) : Option Nat := - ctrlArity b.ctrl -where - ctrlArity : Ctrl → Option Nat - | .return _ vals => some vals.size - | .yield _ _ => none - | .match _ cases dflt? => - let viaCases := cases.findSome? (fun ⟨_, blk⟩ => findReturnArity blk) - match viaCases with - | some n => some n - | none => dflt?.bind findReturnArity - | .matchContinue _ cases dflt? _ _ _ cont => - let viaCases := cases.findSome? (fun ⟨_, blk⟩ => findReturnArity blk) - let viaDflt := dflt?.bind findReturnArity - let viaCont := findReturnArity cont - viaCases <|> viaDflt <|> viaCont - -/-- Codegen state: `nextVal` is the next ValIdx slot to allocate for - op outputs (must match Aiur's value-stack growth exactly); - `nextLabel` is a fresh counter for unique `'__mc_N` labels in - nested `MatchContinue`s. -/ -structure EmitState where - nextVal : Nat - nextLabel : Nat - memorySizes : Array Nat := #[] - deriving Inhabited - -abbrev EmitM (α : Type) := StateM EmitState α - -@[inline] def freshLabel : EmitM String := do - let s ← get - set { s with nextLabel := s.nextLabel + 1 } - return s!"__mc_{s.nextLabel}" - -/-- Allocate `count` consecutive ValIdx slots and return the base. -/ -@[inline] def allocVals (count : Nat) : EmitM Nat := do - let s ← get - set { s with nextVal := s.nextVal + count } - return s.nextVal - -/-- Run `m` with the current `nextVal` snapshotted; on exit restore - `nextVal` to its value at entry. Used for `Match` / `MatchContinue` - case bodies, which logically execute from the SAME value-stack - snapshot that existed before the match dispatch. -/ -@[inline] def withSavedNextVal (m : EmitM α) : EmitM α := do - let saved := (← get).nextVal - let a ← m - modify ({ · with nextVal := saved }) - return a - -mutual - -/-- Emit a Block's stmts. `mcLabel?` is the label of the enclosing - `MatchContinue` (used by `Ctrl.yield` to `break` with values). - A Block whose Ctrl is `Return` does NOT bubble — it always emits - the outer fn's `return`. -/ -partial def emitBlock (funIdx : FunIdx) (mcLabel? : Option String) - (b : Block) : EmitM (Array RustStmt) := do - let mut stmts : Array RustStmt := #[] - for op in b.ops do - let outBase ← allocVals (Op.outputCount op) - stmts := stmts ++ emitOp outBase op (← get).memorySizes - let ctrlStmts ← emitCtrl funIdx mcLabel? b.ctrl - return stmts ++ ctrlStmts - -partial def emitCtrl (funIdx : FunIdx) (mcLabel? : Option String) - (ctrl : Ctrl) : EmitM (Array RustStmt) := do - match ctrl with - | .return _ outs => - -- Mirror execute.rs Ctrl::Return: build the output array, insert - -- into function_queries (binding to the per-fn `inp` slice for - -- args), then Rust-return the array. Ignores `mcLabel?` because - -- Return exits the whole fn. - let outArr : RustStmt := - .letStmt false "__ret" (some (outputTy funIdx)) - (.arrayLit (outs.map valVar)) - let insertCall : RustStmt := .exprStmt (.tryExpr (method (funQueriesAt funIdx) "finish_hashed" - #[sliceRef (.var "inp"), sliceRef (.var "__ret"), notUnconstrained, .var "input_hash"])) - -- Wrap in Ok(...) since fn now returns Result<[G; OUT_N], ExecError>. - return #[outArr, insertCall, - .returnStmt (.call (.var "Ok") #[.var "__ret"])] - | .match valIdx cases dflt? => do - -- Each arm body executes from the SAME value-stack snapshot as - -- match entry. Snapshot nextVal per arm so per-arm allocations - -- don't leak to siblings. - let mut arms : Array MatchArm := #[] - for ⟨key, blk⟩ in cases do - let armBody ← withSavedNextVal (emitBlock funIdx mcLabel? blk) - arms := arms.push { pat := .litU64 key.n, body := { stmts := armBody } } - let dfltBody ← (match dflt? with - | some d => withSavedNextVal (emitBlock funIdx mcLabel? d) - | none => pure #[ - .returnStmt - (.call (.var "Err") - #[.call (.path #["ExecError", "MatchNoCase"]) - #[canonical (valVar valIdx)]])]) - arms := arms.push { pat := .wildcard, body := { stmts := dfltBody } } - return #[.matchStmt - (canonical (valVar valIdx)) - arms] - | .matchContinue valIdx cases dflt? outputSize _shAux _shLk continuation => do - -- Snapshot the value-stack base for the case bodies; they all - -- run from this same snapshot. - -- - -- Generated shape (no `map`, only locals): - -- let __mc_out_N: [G; OUT_SIZE] = '__mc_N: { - -- match __v_{valIdx}.as_canonical_u64() { - -- K1 => { ... break '__mc_N [__v_a, __v_b, ...]; }, - -- ... - -- _ => { ... }, - -- } - -- }; - -- let __v_{base}: G = __mc_out_N[0]; - -- let __v_{base+1}: G = __mc_out_N[1]; - -- ... // outputSize values rebound at outer scope - -- /* continuation emitted with nextVal = base + outputSize */ - let label ← freshLabel - let mut arms : Array MatchArm := #[] - for ⟨key, blk⟩ in cases do - let armBody ← withSavedNextVal (emitBlock funIdx (some label) blk) - arms := arms.push { pat := .litU64 key.n, body := { stmts := armBody } } - let dfltBody ← (match dflt? with - | some d => withSavedNextVal (emitBlock funIdx (some label) d) - | none => pure #[ - .returnStmt - (.call (.var "Err") - #[.call (.path #["ExecError", "MatchNoCase"]) - #[canonical (valVar valIdx)]])]) - arms := arms.push { pat := .wildcard, body := { stmts := dfltBody } } - let matchStmt : RustStmt := - .matchStmt (canonical (valVar valIdx)) arms - -- Reserve `outputSize` slots at outer scope for the yielded values. - let outBase ← allocVals outputSize - let yieldedLet : RustStmt := - .letStmt false s!"__mc_out_{label}" (some (gArray outputSize)) - (.labeledBlock label { stmts := #[matchStmt] }) - let mut splat : Array RustStmt := #[] - for k in [0 : outputSize] do - splat := splat.push - (declVal (outBase + k) - (.index (.var s!"__mc_out_{label}") (.nat k))) - let contStmts ← emitBlock funIdx mcLabel? continuation - return #[yieldedLet] ++ splat ++ contStmts - | .yield _ outs => - -- Yield: bubble values to the enclosing `MatchContinue`'s labeled - -- block via `break '__mc_N [...];`. Only valid inside a - -- MatchContinue case body, so `mcLabel?` MUST be set; if it isn't, - -- emit a panic so the failure is obvious during testing. - match mcLabel? with - | some label => - return #[.breakWith label (.arrayLit (outs.map valVar))] - | none => - return #[.exprStmt - (.macroCall "unreachable" #[.string "Ctrl::Yield outside of MatchContinue context"])] - -end - - -/-! ## Functions and module emission -/ - -def emitFunction (funIdx : FunIdx) (f : Function) - (memorySizes : Array Nat := #[]) : Array RustItem := - let inSize := f.layout.inputSize - let outSize := (findReturnArity f.body).getD 0 - let bindInputs := (Array.range inSize).map fun i => - declVal i (.index (.var "inp") (.nat i)) - let initState : EmitState := { nextVal := inSize, nextLabel := 0, memorySizes } - let (stmts, _) := (emitBlock funIdx none f.body).run initState - -- The entry check propagates cancellation even through calls that allocate - -- no new query rows. - let entryCheck : RustStmt := .exprStmt (.tryExpr (runtimeCall "check_record_cap" - #[.ref (.field (.var "record") "budget")])) - let body : RustBlock := { - stmts := #[.letStmt false "unconstrained" none (.var "UNCONSTRAINED"), entryCheck] ++ - bindInputs ++ stmts - } - -- Preserve stack growth at every function entry: 64 KiB red zone, 4 MiB segment. - let guarded := .call (.path #["stacker", "maybe_grow"]) #[ - .binop .mul (.nat 64) (.nat 1024), - .binop .mul (.binop .mul (.nat 4) (.nat 1024)) (.nat 1024), - .closure #[] (.block body)] - #[ - .constUsize s!"INPUT_SIZE_{funIdx}" inSize, - .constUsize s!"IN_{funIdx}" inSize, - .constUsize s!"OUT_{funIdx}" outSize, - .function { - name := s!"aiur_fn_{funIdx}" - constParams := #[("UNCONSTRAINED", .named "bool")] - params := #[ - ("inp", inputTy funIdx), ("input_hash", .named "u64"), - ("record", .ref true (.named "QueryRecord")), - ("io_buffer", .ref true (.named "IOBuffer"))] - returnTy := resultTy (outputTy funIdx) - body := tailBlock guarded - } - ] - -/-- Entry dispatch validates the fixed memory-table layout before any mutation. - Generated functions and runtime helpers only insert rows, never tables. -/ -def emitDispatch (tl : Toplevel) : RustItem := Id.run do - let mut arms : Array MatchArm := #[] - for funIdx in [0 : tl.functions.size] do - arms := arms.push { - pat := .litU64 funIdx - body := { stmts := #[ - .letStmt false "__inp" (some (inputTy funIdx)) - (expect (method (.var "args") "try_into") "input size mismatch"), - .letStmt false "__out" none - (nativeCall funIdx (.bool false) (.var "__inp") (.var "__input_hash")), - .returnStmt (.call (.var "Ok") #[method (.var "__out") "to_vec"]) - ] } - } - arms := arms.push { - pat := .wildcard - body := { stmts := #[returnError (errorValue "InvalidFunIdx" #[.var "fun_idx"])] } - } - let mut body : Array RustStmt := #[] - for slot in [0 : tl.memorySizes.size] do - let size := tl.memorySizes[slot]! - let actual := method - (method (.field (.var "record") "memory_queries") "get_index" #[.nat slot]) - "map" #[.closure #[.tuple #[.binding "size", .wildcard]] (.deref (.var "size"))] - body := body.push (.ifStmt - (.binop .ne actual (.call (.var "Some") #[.nat size])) - #[returnError (errorValue "InvalidMemorySize" #[.nat size])] none) - body := body.push (.letStmt false "__input_hash" none - (.call (.path #["aiur", "querymap", "hash_g_slice"]) #[.var "args"])) - body := body.push (.matchStmt (.cast (.var "fun_idx") (.named "u64")) arms) - return .function { - name := "execute_generated" - visibility := .crate - params := #[ - ("fun_idx", .named "usize"), ("args", .ref false (.slice gTy)), - ("record", .ref true (.named "QueryRecord")), - ("io_buffer", .ref true (.named "IOBuffer"))] - returnTy := resultTy (.app "Vec" #[gTy]) - body := { stmts := body } - } - -/-- Fixed module-level boilerplate only. Runtime helper paths are carried - explicitly by expressions, so no rendered-source scanning is needed. -/ -def emitPreludeHeader : String := - "// Auto-generated by Aiur codegen. Do not edit.\n\ - // Mirrors crates/aiur/src/execute.rs QueryRecord side effects.\n\ - #![cfg_attr(rustfmt, rustfmt::skip)]\n\ - #![allow(unused_variables, unused_assignments, unused_mut, dead_code,\n\ - unused_parens, non_snake_case, clippy::all,\n\ - clippy::ptr_as_ptr, clippy::match_same_arms,\n\ - clippy::large_types_passed_by_value)]\n\ - use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64};\n\ - use aiur::G;\n\ - use aiur::execute::{ExecError, IOBuffer, QueryRecord};\n\n" - -/-- Build syntax for the complete module before rendering any source. -/ -def emitItems (tl : Toplevel) : Array RustItem := Id.run do - let mut items := #[] - for funIdx in [0 : tl.functions.size] do - items := items ++ emitFunction funIdx tl.functions[funIdx]! tl.memorySizes - return items.push (emitDispatch tl) - -def emit (tl : Toplevel) : String := - emitPreludeHeader ++ - (String.join ((emitItems tl).toList.map RustItem.toStr)).trimAsciiEnd.toString ++ "\n" - -end Aiur.Codegen -end diff --git a/Ix/Aiur/Stages/Concrete.lean b/Ix/Aiur/Stages/Concrete.lean deleted file mode 100644 index f563ecb5d..000000000 --- a/Ix/Aiur/Stages/Concrete.lean +++ /dev/null @@ -1,171 +0,0 @@ -module -public import Ix.Aiur.Stages.Simple - -/-! -Stage 4 (Concrete) IR — post monomorphization. - -Same term shape as `Simple`, but over `Concrete.Typ` that has no `.mvar` and no -parametric `.app`. Every polymorphic decl has been specialised and renamed via -`concretizeName`. The lowering pass `toBytecode` consumes only `Concrete.Term`, -so `typSize` has no `.mvar` / `.app` arms to reject. --/ - -public section - -namespace Aiur - -namespace Concrete - -/-- Types after monomorphization — no mvars, no parametric apps. -/ -inductive Typ where - | unit - | field - | tuple : Array Typ → Typ - | array : Typ → Nat → Typ - | pointer : Typ → Typ - /-- Monomorphic reference. The `Global` is the concretized (mangled) name. -/ - | ref : Global → Typ - | function : List Typ → Typ → Typ - deriving Repr, BEq, Hashable, Inhabited - -inductive Pattern - | wildcard - | field : G → Pattern - | ref : Global → Array Local → Pattern - | tuple : Array Local → Pattern - | array : Array Local → Pattern - deriving Repr, BEq, Hashable, Inhabited - -/-- Plain inductive form so each sub-Term is a direct constructor child, -making `sizeOf` propagate naturally through Lean's auto-derivation. - -Each constructor inlines `typ : Typ` and `escapes : Bool` as the first two -arguments. Accessors `Term.typ` and `Term.escapes` pattern-match across all -constructors. -/ -inductive Term : Type where - | unit (typ : Typ) (escapes : Bool) : Term - | var (typ : Typ) (escapes : Bool) (l : Local) : Term - | ref (typ : Typ) (escapes : Bool) (g : Global) : Term - | field (typ : Typ) (escapes : Bool) (g : G) : Term - | tuple (typ : Typ) (escapes : Bool) (ts : Array Term) : Term - | array (typ : Typ) (escapes : Bool) (ts : Array Term) : Term - | ret (typ : Typ) (escapes : Bool) (sub : Term) : Term - | letVar (typ : Typ) (escapes : Bool) (l : Local) (v : Term) (b : Term) : Term - | letWild (typ : Typ) (escapes : Bool) (v : Term) (b : Term) : Term - /-- `letLoad typ escapes dst dstTyp src body` — see `Simple.letLoad`. -/ - | letLoad (typ : Typ) (escapes : Bool) (dst : Local) (dstTyp : Typ) (src : Local) (b : Term) : Term - | match (typ : Typ) (escapes : Bool) (scrut : Local) - (cases : Array (Pattern × Term)) (defaultOpt : Option Term) : Term - | app (typ : Typ) (escapes : Bool) (g : Global) (args : List Term) (unconstrained : Bool) : Term - | add (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | sub (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | mul (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | eqZero (typ : Typ) (escapes : Bool) (a : Term) : Term - | proj (typ : Typ) (escapes : Bool) (a : Term) (n : Nat) : Term - | get (typ : Typ) (escapes : Bool) (a : Term) (n : Nat) : Term - | slice (typ : Typ) (escapes : Bool) (a : Term) (i : Nat) (j : Nat) : Term - | set (typ : Typ) (escapes : Bool) (a : Term) (n : Nat) (v : Term) : Term - | store (typ : Typ) (escapes : Bool) (a : Term) : Term - | load (typ : Typ) (escapes : Bool) (a : Term) : Term - | ptrVal (typ : Typ) (escapes : Bool) (a : Term) : Term - | assertEq (typ : Typ) (escapes : Bool) (a : Term) (b : Term) - (msg : Option String) (r : Term) : Term - | ioGetInfo (typ : Typ) (escapes : Bool) (c k : Term) : Term - | ioSetInfo (typ : Typ) (escapes : Bool) (c k i l r : Term) : Term - | ioRead (typ : Typ) (escapes : Bool) (c i : Term) (n : Nat) : Term - | ioWrite (typ : Typ) (escapes : Bool) (c d r : Term) : Term - | u8BitDecomposition (typ : Typ) (escapes : Bool) (a : Term) : Term - | u8ShiftLeft (typ : Typ) (escapes : Bool) (a : Term) : Term - | u8ShiftRight (typ : Typ) (escapes : Bool) (a : Term) : Term - | u8Xor (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8Add (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8Mul (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8Sub (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8And (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8Or (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8LessThan (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u32LessThan (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8XorSplit7 (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8XorSplit4 (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | unconstrainedU32Add (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | unconstrainedU32Add3 (typ : Typ) (escapes : Bool) (a : Term) (b : Term) (c : Term) : Term - | u32ToField (typ : Typ) (escapes : Bool) (a : Term) : Term - | u8RangeCheck (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | unconstrainedBigUintDivMod (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | unconstrainedGToBytes (typ : Typ) (escapes : Bool) (a : Term) : Term - | unconstrainedGInverse (typ : Typ) (escapes : Bool) (a : Term) : Term - | debug (typ : Typ) (escapes : Bool) (label : String) (t : Option Term) (r : Term) : Term - deriving Repr, Inhabited - -/-- Get the type annotation of a Concrete.Term, regardless of constructor. -/ -def Term.typ : Term → Typ - | .unit t _ | .var t _ _ | .ref t _ _ | .field t _ _ - | .tuple t _ _ | .array t _ _ | .ret t _ _ - | .letVar t _ _ _ _ | .letWild t _ _ _ | .letLoad t _ _ _ _ _ - | .match t _ _ _ _ | .app t _ _ _ _ - | .add t _ _ _ | .sub t _ _ _ | .mul t _ _ _ | .eqZero t _ _ - | .proj t _ _ _ | .get t _ _ _ | .slice t _ _ _ _ | .set t _ _ _ _ - | .store t _ _ | .load t _ _ | .ptrVal t _ _ - | .assertEq t _ _ _ _ _ | .ioGetInfo t _ _ _ | .ioSetInfo t _ _ _ _ _ _ - | .ioRead t _ _ _ _ | .ioWrite t _ _ _ _ - | .u8BitDecomposition t _ _ | .u8ShiftLeft t _ _ | .u8ShiftRight t _ _ - | .u8Xor t _ _ _ | .u8Add t _ _ _ | .u8Mul t _ _ _ | .u8Sub t _ _ _ - | .u8And t _ _ _ | .u8Or t _ _ _ | .u8LessThan t _ _ _ | .u32LessThan t _ _ _ - | .u8XorSplit7 t _ _ _ | .u8XorSplit4 t _ _ _ | .u8RangeCheck t _ _ _ - | .unconstrainedU32Add t _ _ _ | .unconstrainedU32Add3 t _ _ _ _ | .u32ToField t _ _ - | .unconstrainedBigUintDivMod t _ _ _ - | .unconstrainedGToBytes t _ _ | .unconstrainedGInverse t _ _ - | .debug t _ _ _ _ => t - -/-- Get the escapes flag of a Concrete.Term. -/ -def Term.escapes : Term → Bool - | .unit _ e | .var _ e _ | .ref _ e _ | .field _ e _ - | .tuple _ e _ | .array _ e _ | .ret _ e _ - | .letVar _ e _ _ _ | .letWild _ e _ _ | .letLoad _ e _ _ _ _ - | .match _ e _ _ _ | .app _ e _ _ _ - | .add _ e _ _ | .sub _ e _ _ | .mul _ e _ _ | .eqZero _ e _ - | .proj _ e _ _ | .get _ e _ _ | .slice _ e _ _ _ | .set _ e _ _ _ - | .store _ e _ | .load _ e _ | .ptrVal _ e _ - | .assertEq _ e _ _ _ _ | .ioGetInfo _ e _ _ | .ioSetInfo _ e _ _ _ _ _ - | .ioRead _ e _ _ _ | .ioWrite _ e _ _ _ - | .u8BitDecomposition _ e _ | .u8ShiftLeft _ e _ | .u8ShiftRight _ e _ - | .u8Xor _ e _ _ | .u8Add _ e _ _ | .u8Mul _ e _ _ | .u8Sub _ e _ _ - | .u8And _ e _ _ | .u8Or _ e _ _ | .u8LessThan _ e _ _ | .u32LessThan _ e _ _ - | .u8XorSplit7 _ e _ _ | .u8XorSplit4 _ e _ _ | .u8RangeCheck _ e _ _ - | .unconstrainedU32Add _ e _ _ | .unconstrainedU32Add3 _ e _ _ _ | .u32ToField _ e _ - | .unconstrainedBigUintDivMod _ e _ _ - | .unconstrainedGToBytes _ e _ | .unconstrainedGInverse _ e _ - | .debug _ e _ _ _ => e - -structure Constructor where - nameHead : String - argTypes : List Typ - deriving Repr, BEq, Inhabited - -structure DataType where - name : Global - constructors : List Constructor - deriving Repr, BEq, Inhabited - -/-- Monomorphic function. No `params`. -/ -structure Function where - name : Global - inputs : List (Local × Typ) - output : Typ - body : Term - entry : Bool - deriving Repr - -inductive Declaration - | function : Function → Declaration - | dataType : DataType → Declaration - | constructor : DataType → Constructor → Declaration - deriving Repr, Inhabited - -abbrev Decls := IndexMap Global Declaration - -end Concrete - -end Aiur - -end diff --git a/Ix/Aiur/Stages/Simple.lean b/Ix/Aiur/Stages/Simple.lean deleted file mode 100644 index 4e35c18e5..000000000 --- a/Ix/Aiur/Stages/Simple.lean +++ /dev/null @@ -1,159 +0,0 @@ -module -public import Ix.Aiur.Stages.Typed - -/-! -Stage 3 (Simple) IR — post match-compilation. - -Produced by the (rewritten) match compiler. Pattern shapes are: -`.wildcard`, `.field G`, `.ref Global (Array Local)`, `.tuple (Array Local)`, -`.array (Array Local)`. - -Type-level invariants: -- No `.or` subpatterns (match compiler eliminated them). -- No `.pointer` subpatterns (lowered to `.letLoad`). -- No nested subpatterns — pattern children are bare `Local`s. -- `.let` binds only a `Local` or is a wildcard. -- `.match` scrutinee is a `Local`. -- No non-exhaustive matches (fallback optional). -- `.match` appears only in let-RHS positions (non-tail match) or as tail - (the non-tail-in-arbitrary-position case is out of scope). --/ - -public section - -namespace Aiur - -namespace Simple - -/-- Simplified pattern: bare-local children only. -/ -inductive Pattern - | wildcard - | field : G → Pattern - | ref : Global → Array Local → Pattern - | tuple : Array Local → Pattern - | array : Array Local → Pattern - deriving Repr, BEq, Hashable, Inhabited - -/-- Plain inductive form (same shape as Concrete.Term, Typed.Term): -each constructor inlines `typ : Typ` and `escapes : Bool` so sub-Terms are -direct constructor children. -/ -inductive Term : Type where - | unit (typ : Typ) (escapes : Bool) : Term - | var (typ : Typ) (escapes : Bool) (l : Local) : Term - | ref (typ : Typ) (escapes : Bool) (g : Global) (tArgs : Array Typ) : Term - | field (typ : Typ) (escapes : Bool) (g : G) : Term - | tuple (typ : Typ) (escapes : Bool) (ts : Array Term) : Term - | array (typ : Typ) (escapes : Bool) (ts : Array Term) : Term - | ret (typ : Typ) (escapes : Bool) (sub : Term) : Term - | letVar (typ : Typ) (escapes : Bool) (l : Local) (v : Term) (b : Term) : Term - | letWild (typ : Typ) (escapes : Bool) (v : Term) (b : Term) : Term - /-- See module-doc note on letLoad. -/ - | letLoad (typ : Typ) (escapes : Bool) (dst : Local) (dstTyp : Typ) (src : Local) (b : Term) : Term - | match (typ : Typ) (escapes : Bool) (scrut : Local) - (cases : Array (Pattern × Term)) (defaultOpt : Option Term) : Term - | app (typ : Typ) (escapes : Bool) (g : Global) (tArgs : Array Typ) - (args : List Term) (unconstrained : Bool) : Term - | add (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | sub (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | mul (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | eqZero (typ : Typ) (escapes : Bool) (a : Term) : Term - | proj (typ : Typ) (escapes : Bool) (a : Term) (n : Nat) : Term - | get (typ : Typ) (escapes : Bool) (a : Term) (n : Nat) : Term - | slice (typ : Typ) (escapes : Bool) (a : Term) (i : Nat) (j : Nat) : Term - | set (typ : Typ) (escapes : Bool) (a : Term) (n : Nat) (v : Term) : Term - | store (typ : Typ) (escapes : Bool) (a : Term) : Term - | load (typ : Typ) (escapes : Bool) (a : Term) : Term - | ptrVal (typ : Typ) (escapes : Bool) (a : Term) : Term - | assertEq (typ : Typ) (escapes : Bool) (a : Term) (b : Term) - (msg : Option String) (r : Term) : Term - | ioGetInfo (typ : Typ) (escapes : Bool) (c k : Term) : Term - | ioSetInfo (typ : Typ) (escapes : Bool) (c k i l r : Term) : Term - | ioRead (typ : Typ) (escapes : Bool) (c i : Term) (n : Nat) : Term - | ioWrite (typ : Typ) (escapes : Bool) (c d r : Term) : Term - | u8BitDecomposition (typ : Typ) (escapes : Bool) (a : Term) : Term - | u8ShiftLeft (typ : Typ) (escapes : Bool) (a : Term) : Term - | u8ShiftRight (typ : Typ) (escapes : Bool) (a : Term) : Term - | u8Xor (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8Add (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8Mul (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8Sub (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8And (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8Or (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8LessThan (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u32LessThan (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8XorSplit7 (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8XorSplit4 (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | unconstrainedU32Add (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | unconstrainedU32Add3 (typ : Typ) (escapes : Bool) (a : Term) (b : Term) (c : Term) : Term - | u32ToField (typ : Typ) (escapes : Bool) (a : Term) : Term - | u8RangeCheck (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | unconstrainedBigUintDivMod (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | unconstrainedGToBytes (typ : Typ) (escapes : Bool) (a : Term) : Term - | unconstrainedGInverse (typ : Typ) (escapes : Bool) (a : Term) : Term - | toField (typ : Typ) (escapes : Bool) (a : Term) : Term - | u8FromFieldUnsafe (typ : Typ) (escapes : Bool) (a : Term) : Term - | debug (typ : Typ) (escapes : Bool) (label : String) (t : Option Term) (r : Term) : Term - deriving Repr, Inhabited - -def Term.typ : Term → Typ - | .unit t _ | .var t _ _ | .ref t _ _ _ | .field t _ _ - | .tuple t _ _ | .array t _ _ | .ret t _ _ - | .letVar t _ _ _ _ | .letWild t _ _ _ | .letLoad t _ _ _ _ _ - | .match t _ _ _ _ | .app t _ _ _ _ _ - | .add t _ _ _ | .sub t _ _ _ | .mul t _ _ _ | .eqZero t _ _ - | .proj t _ _ _ | .get t _ _ _ | .slice t _ _ _ _ | .set t _ _ _ _ - | .store t _ _ | .load t _ _ | .ptrVal t _ _ - | .assertEq t _ _ _ _ _ | .ioGetInfo t _ _ _ | .ioSetInfo t _ _ _ _ _ _ - | .ioRead t _ _ _ _ | .ioWrite t _ _ _ _ - | .u8BitDecomposition t _ _ | .u8ShiftLeft t _ _ | .u8ShiftRight t _ _ - | .u8Xor t _ _ _ | .u8Add t _ _ _ | .u8Mul t _ _ _ | .u8Sub t _ _ _ - | .u8And t _ _ _ | .u8Or t _ _ _ | .u8LessThan t _ _ _ | .u32LessThan t _ _ _ - | .u8XorSplit7 t _ _ _ | .u8XorSplit4 t _ _ _ | .u8RangeCheck t _ _ _ - | .unconstrainedU32Add t _ _ _ | .unconstrainedU32Add3 t _ _ _ _ | .u32ToField t _ _ - | .unconstrainedBigUintDivMod t _ _ _ - | .unconstrainedGToBytes t _ _ | .unconstrainedGInverse t _ _ - | .toField t _ _ | .u8FromFieldUnsafe t _ _ - | .debug t _ _ _ _ => t - -def Term.escapes : Term → Bool - | .unit _ e | .var _ e _ | .ref _ e _ _ | .field _ e _ - | .tuple _ e _ | .array _ e _ | .ret _ e _ - | .letVar _ e _ _ _ | .letWild _ e _ _ | .letLoad _ e _ _ _ _ - | .match _ e _ _ _ | .app _ e _ _ _ _ - | .add _ e _ _ | .sub _ e _ _ | .mul _ e _ _ | .eqZero _ e _ - | .proj _ e _ _ | .get _ e _ _ | .slice _ e _ _ _ | .set _ e _ _ _ - | .store _ e _ | .load _ e _ | .ptrVal _ e _ - | .assertEq _ e _ _ _ _ | .ioGetInfo _ e _ _ | .ioSetInfo _ e _ _ _ _ _ - | .ioRead _ e _ _ _ | .ioWrite _ e _ _ _ - | .u8BitDecomposition _ e _ | .u8ShiftLeft _ e _ | .u8ShiftRight _ e _ - | .u8Xor _ e _ _ | .u8Add _ e _ _ | .u8Mul _ e _ _ | .u8Sub _ e _ _ - | .u8And _ e _ _ | .u8Or _ e _ _ | .u8LessThan _ e _ _ | .u32LessThan _ e _ _ - | .u8XorSplit7 _ e _ _ | .u8XorSplit4 _ e _ _ | .u8RangeCheck _ e _ _ - | .unconstrainedU32Add _ e _ _ | .unconstrainedU32Add3 _ e _ _ _ | .u32ToField _ e _ - | .unconstrainedBigUintDivMod _ e _ _ - | .unconstrainedGToBytes _ e _ | .unconstrainedGInverse _ e _ - | .toField _ e _ | .u8FromFieldUnsafe _ e _ - | .debug _ e _ _ _ => e - -structure Function where - name : Global - params : List String - inputs : List (Local × Typ) - output : Typ - body : Term - entry : Bool - deriving Repr - -inductive Declaration - | function : Function → Declaration - | dataType : DataType → Declaration - | constructor : DataType → Constructor → Declaration - deriving Repr, Inhabited - -abbrev Decls := IndexMap Global Declaration - -end Simple - -end Aiur - -end diff --git a/Ix/Aiur/Stages/Source.lean b/Ix/Aiur/Stages/Source.lean deleted file mode 100644 index b7a1694a2..000000000 --- a/Ix/Aiur/Stages/Source.lean +++ /dev/null @@ -1,1282 +0,0 @@ -module -public import Std.Data.HashSet.Basic -public import Ix.Aiur.Goldilocks -public import Ix.IndexMap - -/-! -Stage 1 (Source) IR — the post-elaboration term language. - -The `Data` mutual child has been flattened into direct `Term.tuple` / -`Term.array` constructors to give cleaner induction principles. --/ - -public section -@[expose] section - -namespace Aiur - -inductive Local - | str : String → Local - | idx : Nat → Local - deriving Repr, Inhabited, Hashable - -instance : BEq Local where - beq - | .str s₁, .str s₂ => s₁ == s₂ - | .idx n₁, .idx n₂ => n₁ == n₂ - | _, _ => false - -structure Global where - toName : Lean.Name - deriving Repr, BEq, Inhabited - -instance : EquivBEq Global where - symm {_ _} h := by rw [BEq.beq] at h ⊢; exact BEq.symm h - trans {_ _ _} h₁ h₂ := by rw [BEq.beq] at h₁ h₂ ⊢; exact BEq.trans h₁ h₂ - rfl {_} := by rw [BEq.beq]; apply BEq.rfl - -instance : Hashable Global where - hash a := hash a.toName - -instance : LawfulHashable Global where - hash_eq a b h := LawfulHashable.hash_eq a.toName b.toName h - -instance : ToString Global where - toString g := g.toName.toString - -def Global.init (limb : String) : Global := - ⟨.mkSimple limb⟩ - -def Global.pushNamespace (global : Global) (limb : String) : Global := - ⟨global.toName.mkStr limb⟩ - -def Global.popNamespace (global : Global) : Option (String × Global) := - match global.toName with - | .str tail head => some (head, ⟨tail⟩) - | _ => none - -inductive Typ where - | unit - | field - /-- A field element known to be range-checked into `[0, 256)`. Same runtime - representation as `field`; the distinction is erased after type-checking - (`Concretize` collapses `u8` to `field`). -/ - | u8 - | tuple : Array Typ → Typ - | array : Typ → Nat → Typ - | pointer : Typ → Typ - | ref : Global → Typ - | app : Global → Array Typ → Typ - | function : List Typ → Typ → Typ - | mvar : Nat → Typ - deriving Repr, Hashable, Inhabited - -deriving instance DecidableEq for Global - -instance : LawfulBEq Global where - eq_of_beq {a b} h := by - rw [BEq.beq] at h - have : a.toName = b.toName := eq_of_beq h - cases a; cases b; congr - rfl {a} := by rw [BEq.beq]; exact BEq.rfl - -/-! ### Custom `BEq Typ` + `LawfulBEq Typ` - -`deriving BEq` on nested inductives produces an opaque `beq` function that -can't be unfolded in proofs. We instead define `Typ.beq` explicitly via -well-founded recursion on `sizeOf`, then prove it decides propositional -equality. `EquivBEq Typ` and `LawfulHashable Typ` follow from the stdlib -low-priority instances `[LawfulBEq α] → EquivBEq α` and -`[LawfulBEq α] → LawfulHashable α`. --/ - -namespace Typ - -/-- Structural boolean equality on `Typ`. Pairwise-compares nested `Array Typ` -and `List Typ` positions via `sizeOf` termination. -/ -def beq : Typ → Typ → Bool - | .unit, .unit => true - | .field, .field => true - | .u8, .u8 => true - | .tuple ts, .tuple ts' => - if hsz : ts.size = ts'.size then - (List.finRange ts.size).all fun i => - beq (ts[i.val]'i.isLt) (ts'[i.val]'(hsz ▸ i.isLt)) - else false - | .array t n, .array t' n' => beq t t' && n == n' - | .pointer t, .pointer t' => beq t t' - | .ref g, .ref g' => g == g' - | .app g args, .app g' args' => - (g == g') && - (if hsz : args.size = args'.size then - (List.finRange args.size).all fun i => - beq (args[i.val]'i.isLt) (args'[i.val]'(hsz ▸ i.isLt)) - else false) - | .function ins out, .function ins' out' => - beq out out' && listBeqAux ins ins' - | .mvar n, .mvar n' => n == n' - | _, _ => false -where - /-- Helper: pairwise equality on `List Typ`. Inlined into `Typ.beq` to stay - within a single well-founded recursion on `sizeOf`. -/ - listBeqAux : List Typ → List Typ → Bool - | [], [] => true - | _ :: _, [] => false - | [], _ :: _ => false - | t :: rest, t' :: rest' => beq t t' && listBeqAux rest rest' - -/-- Reflexivity of `Typ.beq` via the generated three-motive recursor. -We use a strengthened list motive so it supplies element-wise refl. -/ -theorem beq_refl (a : Typ) : beq a a = true := by - refine - @Typ.rec - (fun a => beq a a = true) - (fun as => ∀ (i : Nat) (h : i < as.size), beq (as[i]'h) (as[i]'h) = true) - (fun ts => beq.listBeqAux ts ts = true ∧ - ∀ (i : Nat) (h : i < ts.length), beq (ts[i]'h) (ts[i]'h) = true) - ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ a - -- case .unit - · unfold beq; rfl - -- case .field - · unfold beq; rfl - -- case .u8 - · unfold beq; rfl - -- case .tuple ts ih - · intro ts ih - unfold beq - simp only [↓reduceDIte] - rw [List.all_eq_true] - intro i _ - exact ih i.val i.isLt - -- case .array t n iht - · intro t n iht - unfold beq - simp only [Bool.and_eq_true] - exact ⟨iht, by simp⟩ - -- case .pointer t iht - · intro t iht - unfold beq - exact iht - -- case .ref g - · intro g - unfold beq - simp - -- case .app g args ih - · intro g args ih - unfold beq - simp only [Bool.and_eq_true] - refine ⟨by simp, ?_⟩ - simp only [↓reduceDIte] - rw [List.all_eq_true] - intro i _ - exact ih i.val i.isLt - -- case .function ins out ihList ihOut - · intro ins out ihList ihOut - unfold beq - simp only [Bool.and_eq_true] - exact ⟨ihOut, ihList.1⟩ - -- case .mvar n - · intro n - unfold beq - simp - -- Array.mk case - · intro ts ih - intro i h - have hAcc : (⟨ts⟩ : Array Typ)[i]'h = ts[i]'h := rfl - rw [hAcc] - exact ih.2 i h - -- List.nil - · refine ⟨?_, ?_⟩ - · unfold beq.listBeqAux; rfl - · intro i h; simp at h - -- List.cons hd tl ihHd ihTl - · intro hd tl ihHd ihTl - refine ⟨?_, ?_⟩ - · unfold beq.listBeqAux - simp only [Bool.and_eq_true] - exact ⟨ihHd, ihTl.1⟩ - · intro i h - cases i with - | zero => exact ihHd - | succ k => - have hk : k < tl.length := by simp [List.length] at h; omega - exact ihTl.2 k hk - -/-- Converse: `beq a b = true → a = b`. Same three-motive recursion. -/ -theorem eq_of_beq {a b : Typ} (h : beq a b = true) : a = b := by - revert b h - refine - @Typ.rec - (fun a => ∀ b, beq a b = true → a = b) - (fun as => ∀ (i : Nat) (h₁ : i < as.size) (t' : Typ), - beq (as[i]'h₁) t' = true → (as[i]'h₁) = t') - (fun ts => (∀ (ts' : List Typ), beq.listBeqAux ts ts' = true → ts = ts') ∧ - (∀ (i : Nat) (h : i < ts.length) (t' : Typ), - beq (ts[i]'h) t' = true → (ts[i]'h) = t')) - ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ ?_ a - -- case .unit - · intro b h - cases b <;> (unfold beq at h; first | rfl | cases h) - -- case .field - · intro b h - cases b <;> (unfold beq at h; first | rfl | cases h) - -- case .u8 - · intro b h - cases b <;> (unfold beq at h; first | rfl | cases h) - -- case .tuple ts ih - · intro ts ih b h - cases b <;> (try (unfold beq at h; cases h)) - rename_i ts' - unfold beq at h - split at h - · rename_i hsz - rw [List.all_eq_true] at h - apply congrArg - apply Array.ext (h₁ := hsz) - intro i hi₁ hi₂ - have hmem : ⟨i, hi₁⟩ ∈ List.finRange ts.size := List.mem_finRange _ - have hib := h ⟨i, hi₁⟩ hmem - exact ih i hi₁ (ts'[i]'hi₂) hib - · cases h - -- case .array t n iht - · intro t n iht b h - cases b <;> (try (unfold beq at h; cases h)) - rename_i t' n' - unfold beq at h - simp only [Bool.and_eq_true, beq_iff_eq] at h - obtain ⟨ht, hn⟩ := h - have := iht t' ht - subst this; subst hn; rfl - -- case .pointer t iht - · intro t iht b h - cases b <;> (try (unfold beq at h; cases h)) - rename_i t' - unfold beq at h - have := iht t' h - subst this; rfl - -- case .ref g - · intro g b h - cases b <;> (try (unfold beq at h; cases h)) - rename_i g' - unfold beq at h - have : g = g' := beq_iff_eq.mp h - subst this; rfl - -- case .app g args ih - · intro g args ih b h - cases b <;> (try (unfold beq at h; cases h)) - rename_i g' args' - unfold beq at h - simp only [Bool.and_eq_true] at h - obtain ⟨hg, ha⟩ := h - have hgeq : g = g' := beq_iff_eq.mp hg - subst hgeq - split at ha - · rename_i hsz - rw [List.all_eq_true] at ha - apply congrArg - apply Array.ext (h₁ := hsz) - intro i hi₁ hi₂ - have hmem : ⟨i, hi₁⟩ ∈ List.finRange args.size := List.mem_finRange _ - have hib := ha ⟨i, hi₁⟩ hmem - exact ih i hi₁ (args'[i]'hi₂) hib - · cases ha - -- case .function ins out ihList ihOut - · intro ins out ihList ihOut b h - cases b <;> (try (unfold beq at h; cases h)) - rename_i ins' out' - unfold beq at h - simp only [Bool.and_eq_true] at h - obtain ⟨hout, hins⟩ := h - have := ihOut out' hout - subst this - have := ihList.1 ins' hins - subst this; rfl - -- case .mvar n - · intro n b h - cases b <;> (try (unfold beq at h; cases h)) - rename_i n' - unfold beq at h - have : n = n' := beq_iff_eq.mp h - subst this; rfl - -- Array.mk case (motive_2) - · intro ts ih - intro i h₁ t' h - have hAcc : (⟨ts⟩ : Array Typ)[i]'h₁ = ts[i]'h₁ := rfl - rw [hAcc] at * - exact ih.2 i h₁ t' h - -- List.nil (motive_3) - · refine ⟨?_, ?_⟩ - · intro ts' h - cases ts' with - | nil => rfl - | cons _ _ => unfold beq.listBeqAux at h; cases h - · intro i h _ _; simp at h - -- List.cons hd tl ihHd ihTl (motive_3) - · intro hd tl ihHd ihTl - refine ⟨?_, ?_⟩ - · intro ts' h - cases ts' with - | nil => unfold beq.listBeqAux at h; cases h - | cons hd' tl' => - unfold beq.listBeqAux at h - simp only [Bool.and_eq_true] at h - obtain ⟨ht, hr⟩ := h - have := ihHd hd' ht - subst this - have := ihTl.1 tl' hr - subst this; rfl - · intro i h t' hb - cases i with - | zero => exact ihHd t' hb - | succ k => - have hk : k < tl.length := by simp [List.length] at h; omega - exact ihTl.2 k hk t' hb - -/-- Does `t` contain any `.pointer` subterm? Used to forbid pointer types in -the signatures of `entry = true` (public) functions. -/ -def hasPointer : Typ → Bool - | .unit | .field | .u8 | .ref _ | .mvar _ => false - | .pointer _ => true - | .tuple ts => ts.attach.any fun ⟨t, _⟩ => hasPointer t - | .array t _ => hasPointer t - | .app _ args => args.attach.any fun ⟨t, _⟩ => hasPointer t - | .function ins out => - hasPointer out || ins.attach.any fun ⟨t, _⟩ => hasPointer t -termination_by t => sizeOf t -decreasing_by - all_goals first - | decreasing_tactic - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - -end Typ - -instance : BEq Typ := ⟨Typ.beq⟩ - -instance : LawfulBEq Typ where - eq_of_beq := Typ.eq_of_beq - rfl := Typ.beq_refl _ - -instance : EquivBEq Typ := inferInstance - -instance : LawfulHashable Typ := inferInstance - -inductive Pattern - | var : Local → Pattern - | wildcard : Pattern - | ref : Global → List Pattern → Pattern - | field : G → Pattern - | tuple : Array Pattern → Pattern - | array : Array Pattern → Pattern - | or : Pattern → Pattern → Pattern - | pointer : Pattern → Pattern - deriving Repr, BEq, Hashable, Inhabited - -namespace Source - -/-- How a function application is compiled. -* `normal` — a constrained circuit call (its own circuit, a lookup, and - output columns at the call site). -* `unconstrained` — a call whose callee is trusted (no lookup / circuit - constraint); the old `unconstrained := true`. -* `inlined` — the callee's body is spliced into the caller at compile - time (no separate circuit, no interface columns). Eliminated by - `Toplevel.inlineCalls` before typechecking; forbidden for callees that - are (transitively) inline-recursive. -/ -inductive CallMode - | normal - | unconstrained - | inlined - deriving Repr, BEq, Hashable, Inhabited, DecidableEq - -/-- Stage 1 term language. `tuple` and `array` are direct constructors (no `Data` -mutual child); cf. `Ix/Aiur/Term.lean` which nested them under `.data`. -/ -inductive Term - | unit - | var : Local → Term - | ref : Global → Term - | field : G → Term - | tuple : Array Term → Term - | array : Array Term → Term - | ret : Term → Term - | let : Pattern → Term → Term → Term - | match : Term → List (Pattern × Term) → Term - | app : Global → List Term → (mode : CallMode) → Term - | add : Term → Term → Term - | sub : Term → Term → Term - | mul : Term → Term → Term - | eqZero : Term → Term - | proj : Term → Nat → Term - | get : Term → Nat → Term - | slice : Term → Nat → Nat → Term - | set : Term → Nat → Term → Term - | store : Term → Term - | load : Term → Term - | ptrVal : Term → Term - | ann : Typ → Term → Term - | assertEq : Term → Term → (msg : Option String) → (ret : Term) → Term - | ioGetInfo : (channel : Term) → (key : Term) → Term - | ioSetInfo : (channel : Term) → (key : Term) → (idx : Term) → (len : Term) → (ret : Term) → Term - | ioRead : (channel : Term) → (idx : Term) → (len : Nat) → Term - | ioWrite : (channel : Term) → (data : Term) → (ret : Term) → Term - | u8BitDecomposition : Term → Term - | u8ShiftLeft : Term → Term - | u8ShiftRight : Term → Term - | u8Xor : Term → Term → Term - | u8Add : Term → Term → Term - | u8Mul : Term → Term → Term - | u8Sub : Term → Term → Term - | u8And : Term → Term → Term - | u8Or : Term → Term → Term - | u8LessThan : Term → Term → Term - | u32LessThan : Term → Term → Term - | u8XorSplit7 : Term → Term → Term - | u8XorSplit4 : Term → Term → Term - /-- Native unconstrained u32 addition hint. The four result bytes are fresh - advice; the carry is a virtual value derived from the packed operands. -/ - | unconstrainedU32Add : Term → Term → Term - /-- Native unconstrained three-input u32 addition hint. -/ - | unconstrainedU32Add3 : Term → Term → Term → Term - /-- Pack four little-endian bytes into a field value. This is a virtual - linear expression and does not allocate an auxiliary column. -/ - | u32ToField : Term → Term - /-- Unconstrained LE byte-list division-modulo hint. Inputs are two - `List` (klimbs) values (LE limb order). Output is a tuple of two - fresh `List` values `(q, r)` with `q*b + r = a` and `0 ≤ r < b` - (when `b > 0`). Computed natively by the Aiur runtime via BigUint - div_rem; no constraints generated and no per-step memo growth. The - caller must verify `q*b + r == a` and `r < b` in constrained code. -/ - | unconstrainedBigUintDivMod : (a : Term) → (b : Term) → Term - /-- Unconstrained hint: the 8 little-endian bytes of a field element's - canonical `u64` value, as a `[G; 8]` — advice must not type as - range-checked bytes. Computed natively by the Aiur runtime; no - constraints generated. The caller must range-check each byte (minting - the `u8`s from the check outputs), assert they recompose to the input - (`Σ bᵢ·256ⁱ == x`), and assert canonicality (`< p`) in constrained - code; together these pin the unique canonical decomposition. -/ - | unconstrainedGToBytes : Term → Term - /-- Unconstrained hint: the field inverse of a field element (`0 ↦ 0`). - Computed natively by the Aiur runtime; no constraints generated — the - caller must pin it, e.g. via `t = x·i − 1; assert x·t == 0; - assert i·t == 0` (forces `i = x⁻¹` when `x ≠ 0` and `i = 0` otherwise). -/ - | unconstrainedGInverse : Term → Term - /-- A `U8` literal in `[0, 256)`. Lowered to a plain field constant of type - `u8` (no range-check lookup, since the value is statically in range). -/ - | u8Lit : Nat → Term - /-- Range-check two field elements into `[0, 256)`, producing two `u8`s. - Pairs because the byte chip already takes two elements per lookup row. -/ - | u8RangeCheck : Term → Term → Term - /-- Forget that a `u8` was range-checked, recovering the underlying `G`. -/ - | toField : Term → Term - /-- Reinterpret a `G` as a `u8` *without* a range check. Unsafe: the caller - asserts the value is already in `[0, 256)` (e.g. a sum of bytes known not to - overflow). Cheaper than `u8_range_check` since it adds no lookup. -/ - | u8FromFieldUnsafe : Term → Term - | debug : String → Option Term → Term → Term - deriving Repr, BEq, Hashable, Inhabited - -end Source - -structure Constructor where - nameHead : String - argTypes : List Typ - deriving Repr, BEq, Inhabited - -structure DataType where - name : Global - params : List String - constructors : List Constructor - deriving Repr, BEq, Inhabited - -structure TypeAlias where - name : Global - params : List String - expansion : Typ - deriving Repr, BEq, Inhabited - -namespace Source - -/-- `true` iff none of `inputs` nor `output` contain a `.pointer` subterm. -Used to enforce that public entry functions expose no pointer-typed values. -/ -def sigPointerFree (inputs : List (Local × Typ)) (output : Typ) : Bool := - !output.hasPointer && inputs.all (fun ⟨_, t⟩ => !t.hasPointer) - -structure Function where - name : Global - params : List String - inputs : List (Local × Typ) - output : Typ - body : Term - entry : Bool - /-- Polymorphic public entry points are forbidden by construction: - either the function is monomorphic (`params = []`) or not public - (`entry = false`). -/ - entryMonomorphic : params = [] ∨ entry = false := by - first | exact Or.inl rfl | exact Or.inr rfl - /-- Public entry points cannot expose pointer-typed values: either the - signature is pointer-free or the function is not public (`entry = false`). -/ - entryPointerFree : sigPointerFree inputs output = true ∨ entry = false := by - first | exact Or.inl rfl | exact Or.inr rfl - deriving Repr - -instance : Inhabited Function where - default := - { name := default, params := [], inputs := default, output := default, - body := default, entry := default, - entryMonomorphic := Or.inl rfl, - entryPointerFree := Or.inr rfl } - -/-- Smart constructor for non-entry monomorphic functions. -/ -def Function.monoNonEntry (name : Global) (inputs : List (Local × Typ)) - (output : Typ) (body : Term) : Function := - { name, params := [], inputs, output, body, entry := false, - entryMonomorphic := Or.inl rfl, entryPointerFree := Or.inr rfl } - -/-- Smart constructor for public entry functions. Requires a proof that the -signature contains no pointer types. -/ -def Function.monoEntry (name : Global) (inputs : List (Local × Typ)) - (output : Typ) (body : Term) - (h : sigPointerFree inputs output = true) : Function := - { name, params := [], inputs, output, body, entry := true, - entryMonomorphic := Or.inl rfl, entryPointerFree := Or.inl h } - -/-- Smart constructor for polymorphic functions (`entry = false` forced). -/ -def Function.poly (name : Global) (params : List String) (inputs : List (Local × Typ)) - (output : Typ) (body : Term) : Function := - { name, params, inputs, output, body, entry := false, - entryMonomorphic := Or.inr rfl, entryPointerFree := Or.inr rfl } - -structure Toplevel where - dataTypes : Array DataType - typeAliases : Array TypeAlias - functions : Array Function - deriving Repr - -def Toplevel.getFuncIdx (toplevel : Toplevel) (funcName : Lean.Name) : Option Nat := do - toplevel.functions.findIdx? fun function => function.name.toName == funcName - -def Toplevel.merge (x y : Toplevel) : Except Global Toplevel := do - let ⟨xDT, xTA, xF⟩ := x - let ⟨yDT, yTA, yF⟩ := y - let (globals, dataTypes) ← mergeArrays DataType.name ∅ xDT yDT - let (globals, typeAliases) ← mergeArrays TypeAlias.name globals xTA yTA - let (_, functions) ← mergeArrays Function.name globals xF yF - pure ⟨dataTypes, typeAliases, functions⟩ -where - mergeArrays {α : Type} (getName : α → Global) (globals : Std.HashSet Global) - (xs ys : Array α) : Except Global (Std.HashSet Global × Array α) := do - let mut globals := globals - let mut result := Array.emptyWithCapacity (xs.size + ys.size) - for set in [xs, ys] do - for item in set do - let n := getName item - if globals.contains n then throw n - globals := globals.insert n - result := result.push item - pure (globals, result) - -/-- A counter above every existing generated-name spelling. Source IR can be -built directly, so `inl#N` is not a reserved user namespace. -/ -def localFreshBound : Local → Nat - | .str s => if s.startsWith "inl#" then - ((s.drop 4).toString.toNat?).map (· + 1) |>.getD 0 - else 0 - | .idx _ => 0 - -def globalFreshBound (g : Global) : Nat := - match g.toName with - | .str .anonymous s => localFreshBound (.str s) - | _ => 0 - -/-- Map local binders, preserving repeated names, including names shared by -both alternatives of an `or` pattern. -/ -def Pattern.mapLocals (f : Local → Local) : Pattern → Pattern - | .var x => .var (f x) - | .wildcard => .wildcard - | .field g => .field g - | .ref g ps => .ref g (ps.attach.map fun ⟨p, _⟩ => Pattern.mapLocals f p) - | .tuple ps => .tuple (ps.attach.map fun ⟨p, _⟩ => Pattern.mapLocals f p) - | .array ps => .array (ps.attach.map fun ⟨p, _⟩ => Pattern.mapLocals f p) - | .or p q => .or (Pattern.mapLocals f p) (Pattern.mapLocals f q) - | .pointer p => .pointer (Pattern.mapLocals f p) -termination_by p => sizeOf p -decreasing_by - all_goals first - | decreasing_tactic - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - -def Pattern.locals : Pattern → List Local - | .var x => [x] - | .wildcard | .field _ => [] - | .ref _ ps => ps.attach.foldl (fun acc ⟨p, _⟩ => acc ++ Pattern.locals p) [] - | .tuple ps | .array ps => ps.attach.foldl (fun acc ⟨p, _⟩ => acc ++ Pattern.locals p) [] - | .or p q => Pattern.locals p ++ Pattern.locals q - | .pointer p => Pattern.locals p -termination_by p => sizeOf p -decreasing_by - all_goals first - | decreasing_tactic - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - -/-- Rename each distinct binder once, extending `subst` for this scope. -The per-pattern map starts empty: an inner binder must shadow an outer one, -but repeated binders within a pattern must remain repeated so typechecking -still rejects nonlinear patterns and still accepts valid `or` patterns. -The caller supplies a counter above all names already in use. -/ -def Pattern.freshen (cnt : Nat) (subst : Std.HashMap Local Local) (p : Pattern) : - Nat × Std.HashMap Local Local × Pattern := - let (cnt, renames) := (Pattern.locals p).foldl (init := (cnt, (∅ : Std.HashMap Local Local))) - fun (cnt, renames) x => - if renames.contains x then (cnt, renames) - else (cnt + 1, renames.insert x (.str s!"inl#{cnt}")) - (cnt, renames.fold (fun s x y => s.insert x y) subst, - Pattern.mapLocals (fun x => renames.getD x x) p) - -/-- Applications with an unqualified name can call a local function value. -Rename that head along with ordinary variable occurrences. Qualified globals -and explicit `.ref` terms do not use local lookup. -/ -def freshenCall (subst : Std.HashMap Local Local) (g : Global) : Global := - match g.toName with - | .str .anonymous s => match subst[Local.str s]? with - | some (.str s') => Global.init s' - | _ => g - | _ => g - -/-- Consistently α-rename the locals bound inside `t` to fresh names, -following `subst` for the currently-renamed variables. Used before -splicing an inlined body so its locals cannot collide with the caller's -(the `Simple` pass floats nested `let`s outward, which would otherwise -capture reused names). Only bound occurrences are rewritten; free -variables that are the callee's inputs are handled by `subst` seeded at -the call site. -/ -def Term.freshen (cnt : Nat) (subst : Std.HashMap Local Local) : - Term → Nat × Term := - fun t => - match t with - | .var x => (cnt, .var (subst.getD x x)) - | .unit | .ref _ | .field _ | .u8Lit _ => (cnt, t) - | .let p v b => - let (cnt, v') := Term.freshen cnt subst v - let (cnt, subst', p') := Pattern.freshen cnt subst p - let (cnt, b') := Term.freshen cnt subst' b - (cnt, .let p' v' b') - | .match s arms => - let (cnt, s') := Term.freshen cnt subst s - let (cnt, arms') := arms.attach.foldl (init := (cnt, ([] : List (Pattern × Term)))) - fun (cnt, acc) ⟨(p, a), _⟩ => - let (cnt, subst', p') := Pattern.freshen cnt subst p - let (cnt, a') := Term.freshen cnt subst' a - (cnt, acc ++ [(p', a')]) - (cnt, .match s' arms') - | .tuple ts => - let (cnt, ts') := ts.attach.foldl (init := (cnt, #[])) fun (cnt, acc) ⟨x, _⟩ => - let (cnt, x') := Term.freshen cnt subst x; (cnt, acc.push x') - (cnt, .tuple ts') - | .array ts => - let (cnt, ts') := ts.attach.foldl (init := (cnt, #[])) fun (cnt, acc) ⟨x, _⟩ => - let (cnt, x') := Term.freshen cnt subst x; (cnt, acc.push x') - (cnt, .array ts') - | .app g args mode => - let (cnt, args') := args.attach.foldl (init := (cnt, ([] : List Term))) fun (cnt, acc) ⟨x, _⟩ => - let (cnt, x') := Term.freshen cnt subst x; (cnt, acc ++ [x']) - (cnt, .app (freshenCall subst g) args' mode) - | .ret a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .ret a') - | .add a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .add a' b') - | .sub a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .sub a' b') - | .mul a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .mul a' b') - | .eqZero a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .eqZero a') - | .proj a n => let (cnt, a') := Term.freshen cnt subst a; (cnt, .proj a' n) - | .get a n => let (cnt, a') := Term.freshen cnt subst a; (cnt, .get a' n) - | .slice a i j => let (cnt, a') := Term.freshen cnt subst a; (cnt, .slice a' i j) - | .set a n v => let (cnt, a') := Term.freshen cnt subst a; let (cnt, v') := Term.freshen cnt subst v; (cnt, .set a' n v') - | .store a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .store a') - | .load a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .load a') - | .ptrVal a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .ptrVal a') - | .ann τ a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .ann τ a') - | .assertEq a b msg c => - let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; let (cnt, c') := Term.freshen cnt subst c - (cnt, .assertEq a' b' msg c') - | .ioGetInfo c k => let (cnt, c') := Term.freshen cnt subst c; let (cnt, k') := Term.freshen cnt subst k; (cnt, .ioGetInfo c' k') - | .ioSetInfo c k i l rv => - let (cnt, c') := Term.freshen cnt subst c; let (cnt, k') := Term.freshen cnt subst k; let (cnt, i') := Term.freshen cnt subst i - let (cnt, l') := Term.freshen cnt subst l; let (cnt, rv') := Term.freshen cnt subst rv - (cnt, .ioSetInfo c' k' i' l' rv') - | .ioRead c i n => let (cnt, c') := Term.freshen cnt subst c; let (cnt, i') := Term.freshen cnt subst i; (cnt, .ioRead c' i' n) - | .ioWrite c d rv => - let (cnt, c') := Term.freshen cnt subst c; let (cnt, d') := Term.freshen cnt subst d; let (cnt, rv') := Term.freshen cnt subst rv - (cnt, .ioWrite c' d' rv') - | .u8BitDecomposition a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .u8BitDecomposition a') - | .u8ShiftLeft a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .u8ShiftLeft a') - | .u8ShiftRight a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .u8ShiftRight a') - | .u8Xor a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8Xor a' b') - | .u8Add a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8Add a' b') - | .u8Mul a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8Mul a' b') - | .u8Sub a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8Sub a' b') - | .u8And a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8And a' b') - | .u8Or a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8Or a' b') - | .u8LessThan a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8LessThan a' b') - | .u32LessThan a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u32LessThan a' b') - | .u8XorSplit7 a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8XorSplit7 a' b') - | .u8XorSplit4 a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8XorSplit4 a' b') - | .unconstrainedU32Add a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .unconstrainedU32Add a' b') - | .unconstrainedU32Add3 a b c => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; let (cnt, c') := Term.freshen cnt subst c; (cnt, .unconstrainedU32Add3 a' b' c') - | .u32ToField a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .u32ToField a') - | .unconstrainedBigUintDivMod a b => - let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .unconstrainedBigUintDivMod a' b') - | .u8RangeCheck a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8RangeCheck a' b') - | .toField a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .toField a') - | .u8FromFieldUnsafe a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .u8FromFieldUnsafe a') - | .unconstrainedGToBytes a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .unconstrainedGToBytes a') - | .unconstrainedGInverse a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .unconstrainedGInverse a') - | .debug s o a => - let (cnt, o') := match o with - | none => (cnt, none) - | some x => let (cnt, x') := Term.freshen cnt subst x; (cnt, some x') - let (cnt, a') := Term.freshen cnt subst a - (cnt, .debug s o' a') -termination_by t => sizeOf t -decreasing_by - all_goals first - | decreasing_tactic - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - -/-- Bound for fresh names, including *free* locals and application heads. -Looking only at binders can turn an unbound reference into a bound one, or -capture a global call whose spelling happens to look compiler-generated. -/ -def Term.freshBound : Term → Nat - | .unit | .field _ | .u8Lit _ => 0 - | .var x => localFreshBound x - | .ref g => globalFreshBound g - | .app g args _ => args.attach.foldl - (fun acc ⟨a, _⟩ => max acc a.freshBound) (globalFreshBound g) - | .tuple ts | .array ts => ts.attach.foldl (fun acc ⟨a, _⟩ => max acc a.freshBound) 0 - | .let p v b => max ((Pattern.locals p).foldl (fun n x => max n (localFreshBound x)) 0) - (max v.freshBound b.freshBound) - | .match s arms => arms.attach.foldl (fun acc ⟨(p, a), _⟩ => - max acc (max ((Pattern.locals p).foldl (fun n x => max n (localFreshBound x)) 0) a.freshBound)) - s.freshBound - | .add a b | .sub a b | .mul a b | .set a _ b - | .u8Xor a b | .u8Add a b | .u8Mul a b | .u8Sub a b | .u8And a b | .u8Or a b - | .u8LessThan a b | .u32LessThan a b | .u8XorSplit7 a b | .u8XorSplit4 a b - | .unconstrainedU32Add a b | .unconstrainedBigUintDivMod a b | .u8RangeCheck a b - | .ioGetInfo a b | .ioRead a b _ => max a.freshBound b.freshBound - | .assertEq a b _ c | .ioWrite a b c | .unconstrainedU32Add3 a b c => - max a.freshBound (max b.freshBound c.freshBound) - | .ioSetInfo c k i l r => max c.freshBound - (max k.freshBound (max i.freshBound (max l.freshBound r.freshBound))) - | .ret a | .eqZero a | .proj a _ | .get a _ | .slice a _ _ | .store a | .load a - | .ptrVal a | .ann _ a | .u8BitDecomposition a | .u8ShiftLeft a | .u8ShiftRight a - | .toField a | .u8FromFieldUnsafe a | .unconstrainedGToBytes a - | .unconstrainedGInverse a | .u32ToField a => a.freshBound - | .debug _ o a => max a.freshBound (match o with | none => 0 | some b => b.freshBound) -termination_by t => sizeOf t -decreasing_by - all_goals first - | decreasing_tactic - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - -/-- Freshen the entire function, including its inputs, before any scope is -widened. Input types and entry-point restrictions are unchanged. -/ -def Function.freshen (cnt : Nat) (f : Function) : Nat × Function := - let (cnt, subst, _) := Pattern.freshen cnt ∅ - (.tuple (f.inputs.toArray.map fun (x, _) => .var x)) - let (cnt, body) := f.body.freshen cnt subst - let inputs := f.inputs.map fun (x, τ) => (subst.getD x x, τ) - let h : sigPointerFree inputs f.output = true ∨ f.entry = false := by - simpa [inputs, sigPointerFree, List.all_map, Function.comp_def] using f.entryPointerFree - (cnt, { f with inputs, body, entryPointerFree := h }) - -/-- Peel the leading `let` bindings off a term: returns the binding frames -(outermost first) and the non-`let` core. -/ -def Term.peelLets : Term → List (Pattern × Term) × Term - | .let p v b => let (fs, c) := Term.peelLets b; ((p, v) :: fs, c) - | t => ([], t) - -/-- Wrap `body` in a chain of `let` frames (first frame outermost). -/ -def Term.wrapLets : List (Pattern × Term) → Term → Term - | [], body => body - | (p, v) :: fs, body => .let p v (Term.wrapLets fs body) - -/-- Every `.inlined` call site in `t`, as `(callee, argCount)` pairs. Drives -both validation (callee exists, arity matches) and the inline-dependency -graph the bottom-up expansion is ordered by. -/ -def Term.inlineCallSites : Term → List (Global × Nat) - | .app g args .inlined => - args.attach.foldl (fun acc ⟨a, _⟩ => acc ++ a.inlineCallSites) [(g, args.length)] - | .app _ args _ => - args.attach.foldl (fun acc ⟨a, _⟩ => acc ++ a.inlineCallSites) [] - | .unit | .var _ | .ref _ | .field _ | .u8Lit _ => [] - | .tuple ts | .array ts => - ts.attach.foldl (fun acc ⟨a, _⟩ => acc ++ a.inlineCallSites) [] - | .match s arms => - arms.attach.foldl (fun acc ⟨(_, a), _⟩ => acc ++ a.inlineCallSites) s.inlineCallSites - | .let _ v b => v.inlineCallSites ++ b.inlineCallSites - | .add a b | .sub a b | .mul a b | .set a _ b - | .u8Xor a b | .u8Add a b | .u8Mul a b | .u8Sub a b | .u8And a b | .u8Or a b - | .u8LessThan a b | .u32LessThan a b | .u8XorSplit7 a b | .u8XorSplit4 a b | .unconstrainedU32Add a b - | .unconstrainedBigUintDivMod a b | .u8RangeCheck a b | .ioGetInfo a b => - a.inlineCallSites ++ b.inlineCallSites - | .assertEq a b _ c => a.inlineCallSites ++ b.inlineCallSites ++ c.inlineCallSites - | .ioWrite a b c => a.inlineCallSites ++ b.inlineCallSites ++ c.inlineCallSites - | .ioSetInfo c k i l rv => - c.inlineCallSites ++ k.inlineCallSites ++ i.inlineCallSites ++ l.inlineCallSites ++ rv.inlineCallSites - | .ioRead a b _ => a.inlineCallSites ++ b.inlineCallSites - | .ret a | .eqZero a | .proj a _ | .get a _ | .slice a _ _ | .store a | .load a - | .ptrVal a | .ann _ a | .u8BitDecomposition a | .u8ShiftLeft a | .u8ShiftRight a - | .toField a | .u8FromFieldUnsafe a - | .unconstrainedGToBytes a | .unconstrainedGInverse a => a.inlineCallSites - | .u32ToField a => a.inlineCallSites - | .unconstrainedU32Add3 a b c => a.inlineCallSites ++ b.inlineCallSites ++ c.inlineCallSites - | .debug _ o a => (match o with | none => [] | some x => x.inlineCallSites) ++ a.inlineCallSites -termination_by t => sizeOf t -decreasing_by - all_goals first - | decreasing_tactic - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - -/-- Structurally splice every `.app g args .inlined` in `t`, given `done`, -which maps each already-expanded callee to its input locals and its (already -inline-free) body. At an inline site the callee's inputs and body are -α-renamed to fresh `inl#N` names (`Term.freshen`, seeded with the inputs), -then each fresh input is bound to its argument via a `let`. Freshening the -inputs BEFORE binding the arguments is essential: arguments are caller terms, -so a fresh input name cannot shadow a caller local an argument references (nor -collide across copies). - -Bottom-up ordering (see `Toplevel.inlineCalls`) guarantees `done[g]` is -already inline-free, so the spliced body is NOT re-traversed — the recursion -is purely structural on `t` and needs no fuel. `cnt` threads the fresh-name -counter. If `done` lacks `g` the site is left untouched; the ordering makes -that unreachable. -/ -def Term.expandOnce (done : Std.HashMap Global (List Local × Term)) (cnt : Nat) : - Term → Nat × Term := fun t => match t with - | .app g args .inlined => - let (cnt, args') := args.attach.foldl (init := (cnt, ([] : List Term))) - fun (cnt, acc) ⟨a, _⟩ => let (cnt, a') := Term.expandOnce done cnt a; (cnt, acc ++ [a']) - match done[g]? with - | none => (cnt, .app g args' .inlined) - | some (ins, body) => - let (cnt, subst, freshInputs) := ins.foldl - (init := (cnt, (∅ : Std.HashMap Local Local), ([] : List Local))) - fun (cnt, subst, acc) inp => - let inp' : Local := .str s!"inl#{cnt}" - (cnt + 1, subst.insert inp inp', acc ++ [inp']) - let (cnt, freshBody) := Term.freshen cnt subst body - -- A branching callee ends in a `match`. In a strict argument position - -- the splice's leading lets hoist out (`Term.hoistLets`) but the match - -- core would stay put, which lowering rejects as a non-tail match in - -- arbitrary position. Bind the match to a fresh local so hoisting - -- leaves only a variable behind; in let-RHS/tail positions the extra - -- binding is harmless. - let (cnt, freshBody) := - match Term.peelLets freshBody with - | (fs, core@(.match ..)) => - let out : Local := .str s!"inl#{cnt}" - (cnt + 1, Term.wrapLets fs (.let (.var out) core (.var out))) - | _ => (cnt, freshBody) - (cnt, (freshInputs.zip args').foldr - (fun (input, arg) acc => Term.let (.var input) arg acc) freshBody) - | .app g args mode => - let (cnt, args') := args.attach.foldl (init := (cnt, ([] : List Term))) - fun (cnt, acc) ⟨a, _⟩ => let (cnt, a') := Term.expandOnce done cnt a; (cnt, acc ++ [a']) - (cnt, .app g args' mode) - | .unit | .var _ | .ref _ | .field _ | .u8Lit _ => (cnt, t) - | .tuple ts => - let (cnt, ts') := ts.attach.foldl (init := (cnt, #[])) - fun (cnt, acc) ⟨a, _⟩ => let (cnt, a') := Term.expandOnce done cnt a; (cnt, acc.push a') - (cnt, .tuple ts') - | .array ts => - let (cnt, ts') := ts.attach.foldl (init := (cnt, #[])) - fun (cnt, acc) ⟨a, _⟩ => let (cnt, a') := Term.expandOnce done cnt a; (cnt, acc.push a') - (cnt, .array ts') - | .match s arms => - let (cnt, s') := Term.expandOnce done cnt s - let (cnt, arms') := arms.attach.foldl (init := (cnt, ([] : List (Pattern × Term)))) - fun (cnt, acc) ⟨(p, a), _⟩ => let (cnt, a') := Term.expandOnce done cnt a; (cnt, acc ++ [(p, a')]) - (cnt, .match s' arms') - | .let p v b => - let (cnt, v') := Term.expandOnce done cnt v - let (cnt, b') := Term.expandOnce done cnt b - (cnt, .let p v' b') - | .ret a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .ret a') - | .add a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .add a' b') - | .sub a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .sub a' b') - | .mul a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .mul a' b') - | .eqZero a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .eqZero a') - | .proj a n => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .proj a' n) - | .get a n => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .get a' n) - | .slice a i j => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .slice a' i j) - | .set a n v => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, v') := Term.expandOnce done cnt v; (cnt, .set a' n v') - | .store a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .store a') - | .load a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .load a') - | .ptrVal a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .ptrVal a') - | .ann τ a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .ann τ a') - | .assertEq a b msg c => - let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b - let (cnt, c') := Term.expandOnce done cnt c; (cnt, .assertEq a' b' msg c') - | .ioGetInfo c k => let (cnt, c') := Term.expandOnce done cnt c; let (cnt, k') := Term.expandOnce done cnt k; (cnt, .ioGetInfo c' k') - | .ioSetInfo c k i l rv => - let (cnt, c') := Term.expandOnce done cnt c; let (cnt, k') := Term.expandOnce done cnt k - let (cnt, i') := Term.expandOnce done cnt i; let (cnt, l') := Term.expandOnce done cnt l - let (cnt, rv') := Term.expandOnce done cnt rv; (cnt, .ioSetInfo c' k' i' l' rv') - | .ioRead c i n => let (cnt, c') := Term.expandOnce done cnt c; let (cnt, i') := Term.expandOnce done cnt i; (cnt, .ioRead c' i' n) - | .ioWrite c d rv => - let (cnt, c') := Term.expandOnce done cnt c; let (cnt, d') := Term.expandOnce done cnt d - let (cnt, rv') := Term.expandOnce done cnt rv; (cnt, .ioWrite c' d' rv') - | .u8BitDecomposition a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .u8BitDecomposition a') - | .u8ShiftLeft a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .u8ShiftLeft a') - | .u8ShiftRight a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .u8ShiftRight a') - | .u8Xor a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8Xor a' b') - | .u8Add a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8Add a' b') - | .u8Mul a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8Mul a' b') - | .u8Sub a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8Sub a' b') - | .u8And a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8And a' b') - | .u8Or a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8Or a' b') - | .u8LessThan a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8LessThan a' b') - | .u32LessThan a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u32LessThan a' b') - | .u8XorSplit7 a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8XorSplit7 a' b') - | .u8XorSplit4 a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8XorSplit4 a' b') - | .unconstrainedU32Add a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .unconstrainedU32Add a' b') - | .unconstrainedU32Add3 a b c => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; let (cnt, c') := Term.expandOnce done cnt c; (cnt, .unconstrainedU32Add3 a' b' c') - | .u32ToField a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .u32ToField a') - | .unconstrainedBigUintDivMod a b => - let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .unconstrainedBigUintDivMod a' b') - | .u8RangeCheck a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8RangeCheck a' b') - | .toField a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .toField a') - | .u8FromFieldUnsafe a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .u8FromFieldUnsafe a') - | .unconstrainedGToBytes a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .unconstrainedGToBytes a') - | .unconstrainedGInverse a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .unconstrainedGInverse a') - | .debug s o a => - let (cnt, o') := match o with - | none => (cnt, none) - | some x => let (cnt, x') := Term.expandOnce done cnt x; (cnt, some x') - let (cnt, a') := Term.expandOnce done cnt a - (cnt, .debug s o' a') -termination_by t => sizeOf t -decreasing_by - all_goals first - | decreasing_tactic - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - -/-- These cores have no effects or computation to reorder in well-typed code. -Everything else is conservatively sequenced before a later argument's prefix. -/ -def Term.isAtomic : Term → Bool - | .unit | .var _ | .ref _ | .field _ | .u8Lit _ => true - | _ => false - -/-- Prepend an argument's complete evaluation before the later arguments' -hoisted prefixes. Merely concatenating let prefixes is insufficient: in -`f(effect₁(), (let x = effect₂(); x))`, `effect₁` must run first too. -`cnt` is a fresh-name supply; all existing binders must already be hygienic. -/ -def Term.peelListLets (ts : List Term) : StateM Nat (List (Pattern × Term) × List Term) := - ts.foldrM (init := ([], [])) fun t (fs, cs) => do - let (f, c) := Term.peelLets t - if fs.isEmpty || c.isAtomic then - return (f ++ fs, c :: cs) - else - let cnt ← getThe Nat - modify (fun (n : Nat) => n + 1) - let out : Local := .str s!"inl#{cnt}" - return (f ++ ((.var out, c) :: fs), .var out :: cs) - -def Term.hoistUnaryLets (build : Term → Term) (a : Term) : Term := - let (fs, c) := a.peelLets - Term.wrapLets fs (build c) - -def Term.hoistBinaryLets (build : Term → Term → Term) (a b : Term) : StateM Nat Term := do - let (fa, a) := a.peelLets - let (fb, b) := b.peelLets - if fb.isEmpty || a.isAtomic then - return Term.wrapLets (fa ++ fb) (build a b) - else - let cnt ← getThe Nat - modify (fun (n : Nat) => n + 1) - let out : Local := .str s!"inl#{cnt}" - return Term.wrapLets (fa ++ ((.var out, a) :: fb)) (build (.var out) b) - -/-- Hoist strict-argument prefixes in a hygienic term. Assertions and IO have -strict operands followed by a continuation, *not* one more operand. Represent -each statement as a unit-valued wildcard let: later prefix extraction then -carries the statement *before* its continuation's bindings. This also exposes -inlined non-tail matches to block lowering when a statement precedes them -inside an operand or let RHS. Match arms stay lazy and returns remain escapes. -/ -def Term.hoistLetsAux : Term → StateM Nat Term := fun t => do - match t with - | .unit | .var _ | .ref _ | .field _ | .u8Lit _ => return t - | .let p v b => return .let p (← v.hoistLetsAux) (← b.hoistLetsAux) - | .match s arms => - let (fs, sc) := (← s.hoistLetsAux).peelLets - let arms ← arms.attach.mapM fun ⟨(p, a), _⟩ => do return (p, ← a.hoistLetsAux) - return Term.wrapLets fs (.match sc arms) - | .ret a => return Term.hoistUnaryLets .ret (← a.hoistLetsAux) - | .debug s o a => - let o' : Option Term ← match o with - | none => pure none - | some x => do - let x ← x.hoistLetsAux - pure (some x) - return .let .wildcard (.debug s o' .unit) (← a.hoistLetsAux) - | .tuple ts => - let ts ← ts.attach.mapM fun ⟨x, _⟩ => x.hoistLetsAux - let (fs, cs) ← Term.peelListLets ts.toList - return Term.wrapLets fs (.tuple cs.toArray) - | .array ts => - let ts ← ts.attach.mapM fun ⟨x, _⟩ => x.hoistLetsAux - let (fs, cs) ← Term.peelListLets ts.toList - return Term.wrapLets fs (.array cs.toArray) - | .app g args mode => - let args ← args.attach.mapM fun ⟨x, _⟩ => x.hoistLetsAux - let (fs, cs) ← Term.peelListLets args - return Term.wrapLets fs (.app g cs mode) - | .assertEq a b msg c => - let a ← a.hoistLetsAux; let b ← b.hoistLetsAux; let c ← c.hoistLetsAux - Term.hoistBinaryLets (fun a b => .let .wildcard (.assertEq a b msg .unit) c) a b - | .ioSetInfo a b c d e => - let args := [← a.hoistLetsAux, ← b.hoistLetsAux, ← c.hoistLetsAux, ← d.hoistLetsAux] - let e ← e.hoistLetsAux - let (fs, cs) ← Term.peelListLets args - match cs with - | [a, b, c, d] => return Term.wrapLets fs (.let .wildcard (.ioSetInfo a b c d .unit) e) - | _ => return t - | .ioWrite a b c => - let a ← a.hoistLetsAux; let b ← b.hoistLetsAux; let c ← c.hoistLetsAux - Term.hoistBinaryLets (fun a b => .let .wildcard (.ioWrite a b .unit) c) a b - | .ioGetInfo a b => Term.hoistBinaryLets .ioGetInfo (← a.hoistLetsAux) (← b.hoistLetsAux) - | .ioRead a b n => Term.hoistBinaryLets (fun a b => .ioRead a b n) (← a.hoistLetsAux) (← b.hoistLetsAux) - | .add a b => Term.hoistBinaryLets .add (← a.hoistLetsAux) (← b.hoistLetsAux) - | .sub a b => Term.hoistBinaryLets .sub (← a.hoistLetsAux) (← b.hoistLetsAux) - | .mul a b => Term.hoistBinaryLets .mul (← a.hoistLetsAux) (← b.hoistLetsAux) - | .eqZero a => return Term.hoistUnaryLets .eqZero (← a.hoistLetsAux) - | .proj a n => return Term.hoistUnaryLets (fun a => .proj a n) (← a.hoistLetsAux) - | .get a n => return Term.hoistUnaryLets (fun a => .get a n) (← a.hoistLetsAux) - | .slice a i j => return Term.hoistUnaryLets (fun a => .slice a i j) (← a.hoistLetsAux) - | .set a n v => Term.hoistBinaryLets (fun a v => .set a n v) (← a.hoistLetsAux) (← v.hoistLetsAux) - | .store a => return Term.hoistUnaryLets .store (← a.hoistLetsAux) - | .load a => return Term.hoistUnaryLets .load (← a.hoistLetsAux) - | .ptrVal a => return Term.hoistUnaryLets .ptrVal (← a.hoistLetsAux) - | .ann τ a => return Term.hoistUnaryLets (.ann τ) (← a.hoistLetsAux) - | .u8BitDecomposition a => return Term.hoistUnaryLets .u8BitDecomposition (← a.hoistLetsAux) - | .u8ShiftLeft a => return Term.hoistUnaryLets .u8ShiftLeft (← a.hoistLetsAux) - | .u8ShiftRight a => return Term.hoistUnaryLets .u8ShiftRight (← a.hoistLetsAux) - | .toField a => return Term.hoistUnaryLets .toField (← a.hoistLetsAux) - | .u8FromFieldUnsafe a => return Term.hoistUnaryLets .u8FromFieldUnsafe (← a.hoistLetsAux) - | .unconstrainedGToBytes a => return Term.hoistUnaryLets .unconstrainedGToBytes (← a.hoistLetsAux) - | .unconstrainedGInverse a => return Term.hoistUnaryLets .unconstrainedGInverse (← a.hoistLetsAux) - | .u8Xor a b => Term.hoistBinaryLets .u8Xor (← a.hoistLetsAux) (← b.hoistLetsAux) - | .u8Add a b => Term.hoistBinaryLets .u8Add (← a.hoistLetsAux) (← b.hoistLetsAux) - | .u8Mul a b => Term.hoistBinaryLets .u8Mul (← a.hoistLetsAux) (← b.hoistLetsAux) - | .u8Sub a b => Term.hoistBinaryLets .u8Sub (← a.hoistLetsAux) (← b.hoistLetsAux) - | .u8And a b => Term.hoistBinaryLets .u8And (← a.hoistLetsAux) (← b.hoistLetsAux) - | .u8Or a b => Term.hoistBinaryLets .u8Or (← a.hoistLetsAux) (← b.hoistLetsAux) - | .u8LessThan a b => Term.hoistBinaryLets .u8LessThan (← a.hoistLetsAux) (← b.hoistLetsAux) - | .u32LessThan a b => Term.hoistBinaryLets .u32LessThan (← a.hoistLetsAux) (← b.hoistLetsAux) - | .u8XorSplit7 a b => Term.hoistBinaryLets .u8XorSplit7 (← a.hoistLetsAux) (← b.hoistLetsAux) - | .u8XorSplit4 a b => Term.hoistBinaryLets .u8XorSplit4 (← a.hoistLetsAux) (← b.hoistLetsAux) - | .unconstrainedU32Add a b => Term.hoistBinaryLets .unconstrainedU32Add (← a.hoistLetsAux) (← b.hoistLetsAux) - | .unconstrainedU32Add3 a b c => - let args := [← a.hoistLetsAux, ← b.hoistLetsAux, ← c.hoistLetsAux] - let (fs, cs) ← Term.peelListLets args - match cs with - | [a, b, c] => return Term.wrapLets fs (.unconstrainedU32Add3 a b c) - | _ => return t - | .u32ToField a => return Term.hoistUnaryLets .u32ToField (← a.hoistLetsAux) - | .unconstrainedBigUintDivMod a b => Term.hoistBinaryLets .unconstrainedBigUintDivMod (← a.hoistLetsAux) (← b.hoistLetsAux) - | .u8RangeCheck a b => Term.hoistBinaryLets .u8RangeCheck (← a.hoistLetsAux) (← b.hoistLetsAux) -termination_by t => sizeOf t -decreasing_by - all_goals first - | decreasing_tactic - | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind) - -/-- Scope-safe normalization, including caller-written lets (not only inline -splices). Freshen before widening any binder's scope; reserve all existing -free names too. The auxiliary pass threads the same fresh supply for the -temporary bindings that preserve left-to-right argument evaluation. -/ -def Term.hoistLets (t : Term) : Term := - let (cnt, t) := t.freshen t.freshBound ∅ - (t.hoistLetsAux cnt).1 - -/-- Kahn-style topological sort of the inline-dependency graph: each pass -emits every function whose inline-callees are already emitted, so callees -precede callers. `rounds` bounds the number of passes by the function count -— a DAG on N nodes has depth < N, so N passes suffice — which is the honest -structural termination measure (not an arbitrary fuel cap). A non-empty -remaining set with no ready function is an inline cycle and is rejected. -/ -def inlineTopo (deps : Std.HashMap Global (List Global)) : - Nat → List Global → Std.HashSet Global → List Global → Except String (List Global) - | 0, remaining, _, acc => - if remaining.isEmpty then pure acc - else throw "inline recursion: dependency graph did not converge" - | rounds + 1, remaining, emitted, acc => - match remaining with - | [] => pure acc - | _ => - let (ready, notReady) := remaining.partition fun g => - (deps.getD g []).all emitted.contains - match ready with - | [] => - throw s!"inline recursion among: {remaining.map Global.toName}" - | _ => - let emitted := ready.foldl (fun s g => s.insert g) emitted - inlineTopo deps rounds notReady emitted (acc ++ ready) -termination_by rounds _ _ _ => rounds - -/-- Restore matches that `Term.expandOnce`'s non-tail wrapping -(`let out = match …; out`) placed in TAIL position back to bare tail -matches. The wrap is only needed where a splice lands in a non-tail -context; left in tail position it turns a legal tail match into a -`matchContinue` whose arms may themselves end in matches — which -lowering rejects ("non-tail match in arbitrary position"). The rewrite -is the eta step `let x = v; x → v`, applied only through tail positions -(let bodies and match arms), so non-tail wraps are untouched. -/ -partial def Term.restoreTailMatches : Term → Term - | .let p v b => - match p, b with - | .var x, .var y => - if x == y then Term.restoreTailMatches v else .let p v b - | _, _ => .let p v (Term.restoreTailMatches b) - | .match s arms => .match s (arms.map fun (p, a) => (p, Term.restoreTailMatches a)) - | t => t - -/-- Inline-expand every function body in the toplevel, eliminating all -`.inlined` applications. Run before typechecking. - -Bottom-up and fuel-free: `.inlined` calls form a DAG (cycles are rejected as -inline recursion), so functions are expanded in topological order — every -callee is fully expanded before any caller inlines it. Each body is therefore -expanded exactly once (`Term.expandOnce`, structurally recursive on the term), -and its already-inline-free result is memoized in `done` and spliced (with -α-renaming) at every call site. -/ -def Toplevel.inlineCalls (t : Toplevel) : Except String Toplevel := do - -- Freshen caller scopes as well as callee splices. Starting above *all* - -- original names also prevents a free callee variable from accidentally - -- becoming bound by the caller, even in hand-built Source IR. - let cnt := t.functions.foldl (init := 0) fun cnt f => - f.inputs.foldl (fun cnt (x, _) => max cnt (localFreshBound x)) - (max cnt (max (globalFreshBound f.name) f.body.freshBound)) - let (cnt, functions) := t.functions.foldl (init := (cnt, #[])) fun (cnt, fs) f => - let (cnt, f) := f.freshen cnt - (cnt, fs.push f) - let t := { t with functions } - let funcs : Std.HashMap Global Function := - t.functions.foldl (fun m f => m.insert f.name f) ∅ - -- Inline dependencies per function, validating callee existence and arity. - let deps : Std.HashMap Global (List Global) ← t.functions.foldlM (init := ∅) - fun deps f => do - let gs ← f.body.inlineCallSites.foldlM (init := ([] : List Global)) - fun acc (g, n) => do - let some callee := funcs[g]? - | throw s!"inline call to unknown function `{g.toName}`" - if n != callee.inputs.length then - throw s!"inline `{g.toName}`: got {n} args, expects {callee.inputs.length}" - pure (acc ++ [g]) - pure (deps.insert f.name gs) - -- Topological order (callees first). `funcs.size` rounds bound the passes. - let names := t.functions.toList.map Function.name - let order ← inlineTopo deps names.length names ∅ [] - -- Expand each body once, in order, memoizing the inline-free result. - let (_, done) := order.foldl - (init := (cnt, (∅ : Std.HashMap Global (List Local × Term)))) fun (cnt, done) g => - match funcs[g]? with - | none => (cnt, done) - | some f => - let (cnt, body) := f.body.expandOnce done cnt - (cnt, done.insert g (f.inputs.map Prod.fst, body)) - -- Rebuild each function with its expanded body, then hoist argument-position - -- lets that splicing may have introduced. - let functions := t.functions.map fun f => - match done[f.name]? with - | none => f - | some (_, body) => { f with body := body.restoreTailMatches.hoistLets } - pure { t with functions } - -/-- Every `Global` referenced by a term: function calls and constructor -applications via `.app`, bare references via `.ref` (constants, nullary -constructors), plus constructor names inside `let`/`match` patterns. -Non-function references never match a function name, so callers can filter -against the function table. -/ -partial def Term.collectGlobals (acc : Std.HashSet Global) : Term → Std.HashSet Global - | .unit | .var _ | .field _ | .u8Lit _ => acc - | .ref g => acc.insert g - | .tuple ts | .array ts => ts.foldl Term.collectGlobals acc - | .ret t | .eqZero t | .proj t _ | .get t _ | .slice t _ _ | .store t - | .load t | .ptrVal t | .ann _ t | .u8BitDecomposition t | .u8ShiftLeft t - | .u8ShiftRight t | .unconstrainedGToBytes t | .unconstrainedGInverse t - | .u32ToField t - | .toField t | .u8FromFieldUnsafe t => t.collectGlobals acc - | .let p v b => b.collectGlobals (v.collectGlobals (patternGlobals acc p)) - | .match s bs => - bs.foldl (fun a (p, b) => b.collectGlobals (patternGlobals a p)) - (s.collectGlobals acc) - | .app g args _ => args.foldl (fun a t => t.collectGlobals a) (acc.insert g) - | .add a b | .sub a b | .mul a b | .u8Xor a b | .u8Add a b - | .u8Mul a b | .u8Sub a b | .u8And a b | .u8Or a b | .u8LessThan a b - | .u32LessThan a b | .u8XorSplit7 a b | .u8XorSplit4 a b | .unconstrainedU32Add a b - | .u8RangeCheck a b | .unconstrainedBigUintDivMod a b | .ioGetInfo a b => - b.collectGlobals (a.collectGlobals acc) - | .unconstrainedU32Add3 a b c => c.collectGlobals (b.collectGlobals (a.collectGlobals acc)) - | .set a _ v => v.collectGlobals (a.collectGlobals acc) - | .assertEq a b _ r => - r.collectGlobals (b.collectGlobals (a.collectGlobals acc)) - | .ioWrite a b r => - r.collectGlobals (b.collectGlobals (a.collectGlobals acc)) - | .ioSetInfo c k i l r => - r.collectGlobals (l.collectGlobals (i.collectGlobals - (k.collectGlobals (c.collectGlobals acc)))) - | .ioRead c i _ => i.collectGlobals (c.collectGlobals acc) - | .debug _ t r => - r.collectGlobals (match t with | none => acc | some t => t.collectGlobals acc) -where - patternGlobals (acc : Std.HashSet Global) : Pattern → Std.HashSet Global - | .var _ | .wildcard | .field _ => acc - | .ref g ps => ps.foldl patternGlobals (acc.insert g) - | .tuple ps | .array ps => ps.foldl patternGlobals acc - | .or a b => patternGlobals (patternGlobals acc a) b - | .pointer p => patternGlobals acc p - -/-- Keep only the functions reachable from `roots` (entry-point names). -Data types and type aliases are kept wholesale — only functions become -circuits, so pruning functions is what shrinks the committed system (every -compiled function is a committed matrix whose openings pad every proof, -used or not). What gets dropped: `pub` entry points other than the roots -(test/bench harness entries) and any function only they reach. Relative -function order is preserved, so surviving indices stay deterministic. -/ -partial def Toplevel.prune (toplevel : Toplevel) (roots : List Lean.Name) : Toplevel := - let byName : Std.HashMap Global Function := - toplevel.functions.foldl (fun a f => a.insert f.name f) ∅ - let rootGs := toplevel.functions.filterMap fun f => - if roots.contains f.name.toName then some f.name else none - let rec go (todo : List Global) (seen : Std.HashSet Global) : Std.HashSet Global := - match todo with - | [] => seen - | g :: rest => - if seen.contains g then go rest seen - else match byName.get? g with - | none => go rest seen -- constructor / datatype / alias reference - | some f => - let refs := f.body.collectGlobals ∅ - go (refs.toList ++ rest) (seen.insert g) - let keep := go rootGs.toList ∅ - { toplevel with functions := toplevel.functions.filter (keep.contains ·.name) } - -inductive Declaration - | function : Function → Declaration - | dataType : DataType → Declaration - | constructor : DataType → Constructor → Declaration - deriving Repr, Inhabited - -abbrev Decls := IndexMap Global Declaration - -end Source - -end Aiur - -end -- @[expose] section -end diff --git a/Ix/Aiur/Stages/TraceCodegen.lean b/Ix/Aiur/Stages/TraceCodegen.lean deleted file mode 100644 index dbad753d0..000000000 --- a/Ix/Aiur/Stages/TraceCodegen.lean +++ /dev/null @@ -1,385 +0,0 @@ -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 - 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 - -private def Mode.values (mode : Mode) (plan : FunctionPlan) : Array ValueId := - match mode with - | .row => plan.rowValues - | .pack | .typed => plan.preparationValues - -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 (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 _ => 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 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 == .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, .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 == .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]!}, write: {entries[2]!}" ++ " })") - 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 deleted file mode 100644 index 6aba5f6f9..000000000 --- a/Ix/Aiur/Stages/TraceContract.lean +++ /dev/null @@ -1,99 +0,0 @@ -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 deleted file mode 100644 index 363f05a77..000000000 --- a/Ix/Aiur/Stages/TraceCuda.lean +++ /dev/null @@ -1,289 +0,0 @@ -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 deleted file mode 100644 index 3fde01b23..000000000 --- a/Ix/Aiur/Stages/TracePlan.lean +++ /dev/null @@ -1,849 +0,0 @@ -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 - rowValues : Array ValueId - preparationValues : 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 := #[] - -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 } - 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 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, rowValues, preparationValues } - -- 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/Typed.lean b/Ix/Aiur/Stages/Typed.lean deleted file mode 100644 index 55bc14c4c..000000000 --- a/Ix/Aiur/Stages/Typed.lean +++ /dev/null @@ -1,135 +0,0 @@ -module -public import Ix.Aiur.Stages.Source - -/-! -Stage 2 (Typed) IR — produced by the type checker. - -Each subterm carries `typ : Typ` and `escapes : Bool`. The `TypedData` mutual -child has been flattened into direct `.tuple` / `.array` constructors. --/ - -public section - -namespace Aiur - -namespace Typed - -/-- Plain inductive form: each constructor inlines `typ : Typ` and -`escapes : Bool` as its first two fields, so sub-Terms are direct constructor -children (Lean's auto `sizeOf` propagates through naturally). -/ -inductive Term : Type where - | unit (typ : Typ) (escapes : Bool) : Term - | var (typ : Typ) (escapes : Bool) (l : Local) : Term - | ref (typ : Typ) (escapes : Bool) (g : Global) (tArgs : Array Typ) : Term - | field (typ : Typ) (escapes : Bool) (g : G) : Term - | tuple (typ : Typ) (escapes : Bool) (ts : Array Term) : Term - | array (typ : Typ) (escapes : Bool) (ts : Array Term) : Term - | ret (typ : Typ) (escapes : Bool) (sub : Term) : Term - | let (typ : Typ) (escapes : Bool) (pat : Pattern) (v : Term) (b : Term) : Term - | match (typ : Typ) (escapes : Bool) (scrut : Term) (cases : List (Pattern × Term)) : Term - | app (typ : Typ) (escapes : Bool) (g : Global) (tArgs : Array Typ) - (args : List Term) (unconstrained : Bool) : Term - | add (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | sub (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | mul (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | eqZero (typ : Typ) (escapes : Bool) (a : Term) : Term - | proj (typ : Typ) (escapes : Bool) (a : Term) (n : Nat) : Term - | get (typ : Typ) (escapes : Bool) (a : Term) (n : Nat) : Term - | slice (typ : Typ) (escapes : Bool) (a : Term) (i : Nat) (j : Nat) : Term - | set (typ : Typ) (escapes : Bool) (a : Term) (n : Nat) (v : Term) : Term - | store (typ : Typ) (escapes : Bool) (a : Term) : Term - | load (typ : Typ) (escapes : Bool) (a : Term) : Term - | ptrVal (typ : Typ) (escapes : Bool) (a : Term) : Term - | assertEq (typ : Typ) (escapes : Bool) (a : Term) (b : Term) - (msg : Option String) (r : Term) : Term - | ioGetInfo (typ : Typ) (escapes : Bool) (c k : Term) : Term - | ioSetInfo (typ : Typ) (escapes : Bool) (c k i l r : Term) : Term - | ioRead (typ : Typ) (escapes : Bool) (c i : Term) (n : Nat) : Term - | ioWrite (typ : Typ) (escapes : Bool) (c d r : Term) : Term - | u8BitDecomposition (typ : Typ) (escapes : Bool) (a : Term) : Term - | u8ShiftLeft (typ : Typ) (escapes : Bool) (a : Term) : Term - | u8ShiftRight (typ : Typ) (escapes : Bool) (a : Term) : Term - | u8Xor (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8Add (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8Mul (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8Sub (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8And (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8Or (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8LessThan (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u32LessThan (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8XorSplit7 (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | u8XorSplit4 (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | unconstrainedU32Add (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | unconstrainedU32Add3 (typ : Typ) (escapes : Bool) (a : Term) (b : Term) (c : Term) : Term - | u32ToField (typ : Typ) (escapes : Bool) (a : Term) : Term - | u8RangeCheck (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | unconstrainedBigUintDivMod (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term - | unconstrainedGToBytes (typ : Typ) (escapes : Bool) (a : Term) : Term - | unconstrainedGInverse (typ : Typ) (escapes : Bool) (a : Term) : Term - | toField (typ : Typ) (escapes : Bool) (a : Term) : Term - | u8FromFieldUnsafe (typ : Typ) (escapes : Bool) (a : Term) : Term - | debug (typ : Typ) (escapes : Bool) (label : String) (t : Option Term) (r : Term) : Term - deriving Repr, Inhabited - -/-- Get the type annotation, regardless of constructor. -/ -def Term.typ : Term → Typ - | .unit t _ | .var t _ _ | .ref t _ _ _ | .field t _ _ - | .tuple t _ _ | .array t _ _ | .ret t _ _ - | .let t _ _ _ _ | .match t _ _ _ | .app t _ _ _ _ _ - | .add t _ _ _ | .sub t _ _ _ | .mul t _ _ _ | .eqZero t _ _ - | .proj t _ _ _ | .get t _ _ _ | .slice t _ _ _ _ | .set t _ _ _ _ - | .store t _ _ | .load t _ _ | .ptrVal t _ _ - | .assertEq t _ _ _ _ _ | .ioGetInfo t _ _ _ | .ioSetInfo t _ _ _ _ _ _ - | .ioRead t _ _ _ _ | .ioWrite t _ _ _ _ - | .u8BitDecomposition t _ _ | .u8ShiftLeft t _ _ | .u8ShiftRight t _ _ - | .u8Xor t _ _ _ | .u8Add t _ _ _ | .u8Mul t _ _ _ | .u8Sub t _ _ _ - | .u8And t _ _ _ | .u8Or t _ _ _ | .u8LessThan t _ _ _ | .u32LessThan t _ _ _ - | .u8XorSplit7 t _ _ _ | .u8XorSplit4 t _ _ _ | .u8RangeCheck t _ _ _ - | .unconstrainedU32Add t _ _ _ | .unconstrainedU32Add3 t _ _ _ _ | .u32ToField t _ _ - | .unconstrainedBigUintDivMod t _ _ _ - | .unconstrainedGToBytes t _ _ | .unconstrainedGInverse t _ _ - | .toField t _ _ | .u8FromFieldUnsafe t _ _ - | .debug t _ _ _ _ => t - -/-- Get the escapes flag. -/ -def Term.escapes : Term → Bool - | .unit _ e | .var _ e _ | .ref _ e _ _ | .field _ e _ - | .tuple _ e _ | .array _ e _ | .ret _ e _ - | .let _ e _ _ _ | .match _ e _ _ | .app _ e _ _ _ _ - | .add _ e _ _ | .sub _ e _ _ | .mul _ e _ _ | .eqZero _ e _ - | .proj _ e _ _ | .get _ e _ _ | .slice _ e _ _ _ | .set _ e _ _ _ - | .store _ e _ | .load _ e _ | .ptrVal _ e _ - | .assertEq _ e _ _ _ _ | .ioGetInfo _ e _ _ | .ioSetInfo _ e _ _ _ _ _ - | .ioRead _ e _ _ _ | .ioWrite _ e _ _ _ - | .u8BitDecomposition _ e _ | .u8ShiftLeft _ e _ | .u8ShiftRight _ e _ - | .u8Xor _ e _ _ | .u8Add _ e _ _ | .u8Mul _ e _ _ | .u8Sub _ e _ _ - | .u8And _ e _ _ | .u8Or _ e _ _ | .u8LessThan _ e _ _ | .u32LessThan _ e _ _ - | .u8XorSplit7 _ e _ _ | .u8XorSplit4 _ e _ _ | .u8RangeCheck _ e _ _ - | .unconstrainedU32Add _ e _ _ | .unconstrainedU32Add3 _ e _ _ _ | .u32ToField _ e _ - | .unconstrainedBigUintDivMod _ e _ _ - | .unconstrainedGToBytes _ e _ | .unconstrainedGInverse _ e _ - | .toField _ e _ | .u8FromFieldUnsafe _ e _ - | .debug _ e _ _ _ => e - -structure Function where - name : Global - params : List String - inputs : List (Local × Typ) - output : Typ - body : Term - entry : Bool - deriving Repr - -inductive Declaration - | function : Function → Declaration - | dataType : DataType → Declaration - | constructor : DataType → Constructor → Declaration - deriving Repr, Inhabited - -abbrev Decls := IndexMap Global Declaration - -end Typed - -end Aiur - -end diff --git a/Ix/Aiur/Statistics.lean b/Ix/Aiur/Statistics.lean deleted file mode 100644 index 095a1d2d8..000000000 --- a/Ix/Aiur/Statistics.lean +++ /dev/null @@ -1,191 +0,0 @@ -module -public import Ix.Aiur.Compiler -public import Ix.Aiur.Semantics.BytecodeFfi -public import Ix.Aiur.Protocol - -/-! -Circuit statistics for Aiur executions. - -Given a `CompiledToplevel`, the per-circuit `QueryCount`s returned by -`execute`, and the per-circuit `CircuitShape`s read off the compiled Rust -`System`, computes per-circuit committed width, height (the unique-row -count), cache hits (sum of multiplicities), and the FFT cost for every -system circuit — constrained functions, memories, and the fixed-height -`Bytes1`/`Bytes2` byte gadgets. - -The FFT cost counts the transforms the pinned prover actually runs, per -committed column, using the raw (unpadded) height `h` so the statistic -stays sensitive to one-row changes (the real prover pads `h` to a power of -two; structural powers of two like the blowup `B` and the quotient degree -`q` stay exact): - -- each PCS trace commit (stage 1 width `m`, stage 2 width `s2`) is one - size-`h` inverse DFT plus `B` size-`h` coset DFTs per column - (`Radix2DitParallel::coset_lde_batch`), i.e. `(B+1)·F(h)`; -- the quotient runs one forward DFT of the `(q·h) × D` flattened quotient - (`D·F(q·h)`) and one zero-padded size-`B·h` DFT per chunk column - (`q·D·F(B·h)`, `lde_from_shifted_coefficients`); committing the - prebuilt chunk LDE (`Pcs::commit_ldes`) runs no transform, - -where `F(0) = 0` and `F(x) = x·log2(max(x, 2))`. Costs are `Float`s to -capture small changes continuously. Results are sorted by FFT cost in -decreasing order and printed with cumulative FFT cost percentages. --/ - -public section - -namespace Aiur - -structure CircuitStats where - name : String - width : Nat - height : Nat - cacheHits : Nat - fftCost : Float - /-- FFT cost at the uncached height `height + cacheHits` (fixed-height - gadget circuits keep their normal cost). Feeds `totalUncachedFftCost`. -/ - uncachedFftCost : Float - -structure ExecutionStats where - circuits : Array CircuitStats - totalFftCost : Float - totalUncachedFftCost : Float - totalCacheHits : Nat - deriving Inhabited - -/-- Continuous transform-size surrogate: `0` at `0` (an empty circuit is -deactivated by the prover), else `x·log2(max(x, 2))` — the clamp keeps a -height-1 transform nonzero. -/ -def transformCost (x : Nat) : Float := - if x == 0 then 0.0 - else - let xf := x.toFloat - xf * (max xf 2.0).log2 - -/-- FFT work of one circuit at height `h`: `(B+1)` size-`h` transforms per -trace column (stage 1 and 2 commits), plus the quotient's forward DFT and -its per-chunk-column size-`B·h` LDE transforms. See the module docstring. -/ -def fftCost (shape : CircuitShape) (h : Nat) (logBlowup : Nat) : Float := - let qD := shape.quotientDegree * G.extensionDegree - let traceWidth := shape.mainWidth + shape.stage2Width - ((2 ^ logBlowup) + 1).toFloat * traceWidth.toFloat * transformCost h - + G.extensionDegree.toFloat * transformCost (shape.quotientDegree * h) - + qD.toFloat * transformCost ((2 ^ logBlowup) * h) - -/-- Committed width of a circuit: stage 1 + stage 2 + quotient chunks. -/ -def CircuitShape.committedWidth (shape : CircuitShape) : Nat := - shape.mainWidth + shape.stage2Width + shape.quotientDegree * G.extensionDegree - -def computeStats (compiled : CompiledToplevel) (queryCounts : Array QueryCount) - (shapes : Array CircuitShape) - (logBlowup : Nat := defaultCommitmentParameters.logBlowup) : - ExecutionStats := - let t := compiled.bytecode - let nAllFuns := t.functions.size - -- Shapes arrive in canonical system order: function circuits (grouped; - -- singletons for ungrouped functions, in ascending member index), - -- memories, `Bytes1`, `Bytes2`. A mismatch means the shapes were built - -- from a different toplevel; misindexing would silently attribute costs - -- to the wrong circuits. - if shapes.size != t.circuits.size + t.memorySizes.size + 2 then - panic! s!"computeStats: {shapes.size} circuit shapes for \ - {t.circuits.size} function circuits + {t.memorySizes.size} memories + 2 gadgets" - else - let mkStats (name : String) (shape : CircuitShape) (h hits : Nat) : CircuitStats := - { name, width := shape.committedWidth, height := h, cacheHits := hits, - fftCost := fftCost shape h logBlowup, - uncachedFftCost := fftCost shape (h + hits) logBlowup } - -- One row per function circuit: heights and cache hits are summed over - -- the circuit's member functions (singletons sum over one). - let functionCircuits := t.circuits.mapIdx fun cIdx c => - let shape := shapes[cIdx]! - let (h, hits) := c.members.foldl (init := (0, 0)) fun (h, hits) i => - let qc := queryCounts[i]! - (h + qc.uniqueRows, hits + (qc.totalHits - qc.uniqueRows)) - mkStats c.name shape h hits - let memoryCircuits := t.memorySizes.mapIdx fun i size => - let shape := shapes[t.circuits.size + i]! - let qc := queryCounts[nAllFuns + i]! - mkStats s!"memory[{size}]" shape qc.uniqueRows (qc.totalHits - qc.uniqueRows) - -- The byte gadgets commit full-table traces in every proof: their height - -- is the (fixed) preprocessed height, independent of the query set, so - -- they carry no cache-hit counterfactual. - let gadgetCircuits := #["Bytes1", "Bytes2"].mapIdx fun i name => - let shape := shapes[t.circuits.size + t.memorySizes.size + i]! - mkStats name shape shape.preprocessedHeight 0 - let circuits := (functionCircuits ++ memoryCircuits ++ gadgetCircuits).qsort - (·.fftCost > ·.fftCost) - let totalFftCost := circuits.foldl (· + ·.fftCost) 0.0 - let totalUncachedFftCost := circuits.foldl (· + ·.uncachedFftCost) 0.0 - let totalCacheHits := circuits.foldl (· + ·.cacheHits) 0 - { circuits, totalFftCost, totalUncachedFftCost, totalCacheHits } - -private def padLeft (s : String) (n : Nat) : String := - let pad := n - s.length - String.ofList (List.replicate pad ' ') ++ s - -private def padRight (s : String) (n : Nat) : String := - let pad := n - s.length - s ++ String.ofList (List.replicate pad ' ') - -private def formatPercent (fftCost totalFftCost : Float) : String := - if totalFftCost == 0.0 then "0.00%" - else - let pct := fftCost * 100.0 / totalFftCost - let bps := (pct * 100.0).round.toUInt32.toNat - let whole := bps / 100 - let frac := bps % 100 - let fracStr := if frac < 10 then s!"0{frac}" else toString frac - s!"{whole}.{fracStr}%" - -/-- Scientific notation with a two-decimal mantissa (`1.74e8`). Only used -for nonnegative costs; any nonzero circuit cost is ≥ 1, so the exponent -is never negative. -/ -def formatSci (f : Float) : String := - if f == 0.0 then "0" - else - let e := f.log10.floor - let cents := (f / (10.0 ^ e) * 100.0).round - -- Rounding can push the mantissa to 10.00; carry into the exponent. - let (cents, e) := if cents >= 1000.0 then (100.0, e + 1.0) else (cents, e) - let cents := cents.toUInt64.toNat - let frac := cents % 100 - let fracStr := if frac < 10 then s!"0{frac}" else toString frac - s!"{cents / 100}.{fracStr}e{e.toUInt64.toNat}" - -def printStats (stats : ExecutionStats) : IO Unit := do - let wName := stats.circuits.foldl (fun m cs => Nat.max m cs.name.length) 4 - let wWidth := stats.circuits.foldl (fun m cs => Nat.max m (toString cs.width).length) 5 - let wHeight := stats.circuits.foldl (fun m cs => Nat.max m (toString cs.height).length) 6 - let wHits := stats.circuits.foldl (fun m cs => Nat.max m (toString cs.cacheHits).length) 5 - let formatCost (f : Float) : String := - let n := f.round.toUInt64.toNat - toString n - let wFftCost := stats.circuits.foldl (fun m cs => Nat.max m (formatSci cs.fftCost).length) 8 - let wPct := 7 - let wCum := 7 - let totalW := wName + 1 + wWidth + 1 + wHeight + 1 + wHits + 1 + wFftCost + 1 + wPct + 1 + wCum - let totalWidth := stats.circuits.foldl (· + ·.width) 0 - let savedPct := - if stats.totalUncachedFftCost == 0.0 then "0.00%" - else formatPercent (stats.totalUncachedFftCost - stats.totalFftCost) stats.totalUncachedFftCost - let sep := String.ofList (List.replicate totalW '-') - IO.println "=== Circuit Statistics ===" - IO.println s!"Circuits: {stats.circuits.size}" - IO.println s!"Total width: {totalWidth}" - IO.println s!"Total FFT cost: {formatCost stats.totalFftCost} ({formatSci stats.totalFftCost})" - IO.println s!"Total cache hits: {stats.totalCacheHits}" - IO.println s!"Total saved cost: {savedPct}" - IO.println sep - IO.println s!"{padRight "Name" wName} {padLeft "Width" wWidth} {padLeft "Height" wHeight} {padLeft "Hits" wHits} {padLeft "FFT cost" wFftCost} {padLeft "%" wPct} {padLeft "%++" wCum}" - IO.println sep - let mut cumFftCost : Float := 0.0 - for cs in stats.circuits do - cumFftCost := cumFftCost + cs.fftCost - let pct := formatPercent cs.fftCost stats.totalFftCost - let cum := formatPercent cumFftCost stats.totalFftCost - IO.println s!"{padRight cs.name wName} {padLeft (toString cs.width) wWidth} {padLeft (toString cs.height) wHeight} {padLeft (toString cs.cacheHits) wHits} {padLeft (formatSci cs.fftCost) wFftCost} {padLeft pct wPct} {padLeft cum wCum}" - -end Aiur - -end diff --git a/Ix/BenchConstants.lean b/Ix/BenchConstants.lean index 6dad4ea0b..e4958daeb 100644 --- a/Ix/BenchConstants.lean +++ b/Ix/BenchConstants.lean @@ -32,7 +32,7 @@ def benchConstants : Array BenchConstant := #[ { name := "Char.ofOrdinal_le_of_le", env := "InitStd" }, { name := "Std.HashMap", env := "InitStd" }, -- TODO: re-add bitblast once a prover can carry it. Its ~18B-step - -- atomic mutual block exceeds the available RAM on the Aiur prove, so a + -- atomic mutual block exceeds the available RAM on the LegacyAiur prove, so a -- scheduled run could only re-document the same OOM every push. Until then it -- runs on demand via `--consts` / BENCH_CONSTS, which bypass the -- curated set. diff --git a/Ix/Check.lean b/Ix/Check.lean index de5970c40..43367fd10 100644 --- a/Ix/Check.lean +++ b/Ix/Check.lean @@ -1,21 +1,16 @@ module public import Ix.Address -public import Ix.Aiur.Compiler -public import Ix.Aiur.Interpret public import Ix.Aiur.Protocol -public import Ix.Aiur.Statistics public import Ix.AssumptionTree public import Ix.Claim public import Ix.Common -public import Ix.IxVM -public import Ix.IxVM.Toplevel public import Ix.IxVM.ClaimHarness public import Ix.Ixon public import Ix.Meta public import Ix.Store public import Ix.Cli.NameResolve -/-! IxVM claim execution and target selection shared by check and prove. -/ +/-! IxVM claim target selection and witness preparation shared by check and prove. -/ public section @@ -44,10 +39,10 @@ def loadClaimAndTrees (claimHex : String) : throw <| IO.userError s!"error: claim bytes at {claimAddr} re-hash to {computed}" let treeRoots : Array Address := match claim with - | .check _ _ (some r) => #[r] - | .eval _ _ _ (some r) => #[r] - | .checkEnv _ root none => #[root] - | .checkEnv _ root (some r) => #[root, r] + | .check _ _ (some r) => #[r] + | .eval _ _ _ (some r) => #[r] + | .checkEnv _ root none => #[root] + | .checkEnv _ root (some r) => #[root, r] | .contains tree _ => #[tree] | _ => #[] let mut trees : Std.HashMap Address Ix.AssumptionTree := {} @@ -63,15 +58,17 @@ def loadClaimAndTrees (claimHex : String) : /-- The `Check` claim on `addr` (full transitive typecheck of the target's closure), relative to `ixonEnv`'s role binding. -/ -def checkClaimOf (ixonEnv : Ixon.Env) (addr : Address) : IO Ix.Claim := do - let ctx ← IO.ofExcept (Ix.ClaimContext.ofEnv ixonEnv) +def checkClaimOf (ixonEnv : Ixon.Env) (addr : Address) + (assumeBinding : Bool := false) : IO Ix.Claim := do + let ctx ← IO.ofExcept (Ix.ClaimContext.ofEnv ixonEnv assumeBinding) return Ix.Claim.check ctx addr none /-- Build a `ClaimWitness` for the `verify_claim` entrypoint against `checkClaimOf ixonEnv addr`. -/ -def mkWitness (addr : Address) (ixonEnv : Ixon.Env) : +def mkWitness (addr : Address) (ixonEnv : Ixon.Env) + (assumeBinding : Bool := false) : IO IxVM.ClaimHarness.ClaimWitness := do - let claim ← checkClaimOf ixonEnv addr + let claim ← checkClaimOf ixonEnv addr assumeBinding IO.ofExcept <| IxVM.ClaimHarness.buildClaimWitness ixonEnv claim {} @@ -95,218 +92,37 @@ def loadBoundIxe (path : String) : IO (Ixon.Env × Aiur.EnvHandle) := do | .error e => throw <| IO.userError s!"EnvHandle.fromBytes {path}: {e}" | .ok h => return (env, h) -/-- Compute + emit per-circuit stats. With `statsOut = none` prints to - stdout; with `some path` redirects stdout to the file for the - duration of `printStats` so the terminal stays clean. - - Circuit shapes come from the one-shot FFI (`Aiur.circuitShapes`), - which builds and drops an `AiurSystem` — the check flow never builds - one otherwise. That cost is paid only when stats are requested. -/ -def emitStats (compiled : Aiur.CompiledToplevel) - (queryCounts : Array Aiur.QueryCount) - (statsOut : Option String) : IO Unit := do - let shapes := Aiur.circuitShapes compiled.bytecode - Aiur.defaultCommitmentParameters Aiur.defaultFriParameters - let stats := Aiur.computeStats compiled queryCounts shapes - match statsOut with - | none => Aiur.printStats stats - | some path => do - let handle ← IO.FS.Handle.mk path .write - let stream := IO.FS.Stream.ofHandle handle - let old ← IO.setStdout stream - try Aiur.printStats stats - finally let _ ← IO.setStdout old - -/-- What a single `runOne` invocation is targeting. - - * `addr`: full-closure `Claim.check addr none` — dispatch via - `checkAddrWithEnv` / `proveAddrWithEnv` (handle required). - * `shard`: `Claim.checkEnv root none` over `owned` blocks — - dispatch via `shardCheckWithEnv` / `shardProveWithEnv` - (handle required). - * `leanW`: a pre-built `ClaimWitness` — used by `--interp` - mode and by `--claim ` over a non-`check addr none` - persisted claim. No envHandle needed. - - The env lives once per CLI invocation in a Rust-owned - `Aiur.EnvHandle`. Lean threads a `@& EnvHandle` reference - through every per-target FFI call, eliminating per-call env - re-parse. -/ +/-- What a single `runOne` invocation is targeting. -/ inductive Target where | addr (a : Address) | shard (owned : Array Address) | leanW (w : IxVM.ClaimHarness.ClaimWitness) -/-- Batch PARALLEL check over one `.ixe`: resolve the targets (explicit - names, or every named constant when `names` is empty), hand the - address list to Rust in one call (`checkAddrsWithEnv`), and let a - rayon pool of `jobs` threads check them — each claim through the - exact single-claim machinery over task-private data (its own - witness io and query record), nothing shared between tasks but the - read-only toplevel and env. Failures come back as batch indices - and resolve to labels here. -/ -def runBatchCheck (ixePath : String) (names : List String) (jobs : Nat) - (toplevel : Aiur.Source.Toplevel) (useBytecode : Bool) : IO UInt32 := do - let compiled : Aiur.CompiledToplevel ← - match toplevel.compileWithGroups IxVM.functionGroups with - | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 - | .ok c => pure c - let (ixonEnv, envHandle) ← loadBoundIxe ixePath - IO.println s!"Loaded {ixePath}: {ixonEnv.namedCount} named, \ - {ixonEnv.constCount} consts, {ixonEnv.blobCount} blobs" - -- Unresolved names are recorded and reported with the check - -- failures rather than aborting: the batch is inherently - -- keep-going (every target's result comes back), so resolution - -- failures get the same treatment. - let mut targets : Array (String × Address) := #[] - let mut unresolved : Array String := #[] - if names.isEmpty then - let sorted := ixonEnv.named.toArray.qsort - (fun a b => toString a.1 < toString b.1) - for (ixName, named) in sorted do - targets := targets.push (toString (ixNameToLeanName ixName), named.addr) - else - for arg in names do - match resolveIxeAddr ixonEnv arg with - | none => - IO.eprintln s!"{arg} not found in {ixePath}" - unresolved := unresolved.push arg - | some addr => targets := targets.push (arg, addr) - let funIdx := compiled.getFuncIdx `verify_claim |>.get! - let mut blob := ByteArray.empty - for (_, a) in targets do blob := blob ++ a.hash - IO.println s!"Typechecking {targets.size} constant(s), {jobs} thread(s)" - (← IO.getStdout).flush - match compiled.bytecode.checkAddrsWithEnv funIdx envHandle blob - useBytecode jobs with - | .error e => IO.eprintln s!"batch check: {e}"; return 1 - | .ok failures => - if failures.isEmpty && unresolved.isEmpty then - IO.println s!"All {targets.size} constant(s) passed" - return 0 - for (idxStr, err) in failures do - let label := match idxStr.toNat? with - | some i => - if h : i < targets.size then targets[i].1 else s!"index {idxStr}" - | none => s!"index {idxStr}" - IO.eprintln s!"{label}: IxVM-native Aiur execution error: {err}" - IO.eprintln - s!"{failures.size} of {targets.size} checked constant(s) FAILED\ - {if unresolved.isEmpty then "" else s!", {unresolved.size} unresolved"}" - return 1 - -/-- Run a single check claim through the codegen'd IxVM Rust kernel. - The `envHandle?` is `none` only for `.leanW` targets (`--interp` - fallback); the addr/shard arms require it. -/ -def runCompiled (compiled : Aiur.CompiledToplevel) (printStats : Bool) - (statsOut : Option String) - (useBytecode : Bool) - (envHandle? : Option Aiur.EnvHandle) - (target : Target) (label : String) : IO UInt32 := do - IO.println s!"Typechecking {label}" - (← IO.getStdout).flush - let funIdx := compiled.getFuncIdx `verify_claim |>.get! - let buildBlob (owned : Array Address) : ByteArray := Id.run do - let mut blob := ByteArray.empty - for x in owned do blob := blob ++ x.hash - pure blob - let res := - match target, envHandle? with - | .addr a, some envHandle => - compiled.bytecode.checkAddrWithEnv funIdx envHandle a.hash useBytecode - | .shard owned, some envHandle => - compiled.bytecode.shardCheckWithEnv funIdx envHandle (buildBlob owned) useBytecode - | .leanW witness, _ => - if useBytecode then - compiled.bytecode.execute funIdx witness.input witness.inputIOBuffer - else - compiled.bytecode.executeIxVM funIdx witness.input witness.inputIOBuffer - | _, none => - .error "internal: addr/shard target with no envHandle" - match res with - | .error e => - IO.eprintln s!"{label}: IxVM-native Aiur execution error: {e}" - return 1 - | .ok (_output, _ioBuffer, queryCounts) => - if printStats then emitStats compiled queryCounts statsOut - pure 0 - -/-- Run a single witness through the Aiur interpreter (richer errors). -/ -def runInterp (decls : Aiur.Source.Decls) - (witness : IxVM.ClaimHarness.ClaimWitness) (label : String) : IO UInt32 := do - IO.println s!"Interpreting {label}" - (← IO.getStdout).flush - let funcName := Aiur.Global.mk witness.funcName - let inputTypes ← match decls.getByKey funcName with - | some (.function f) => pure $ f.inputs.map (·.2) - | _ => IO.eprintln s!"{label}: function not found in decls"; return 1 - let inputs := Aiur.unflattenInputs decls witness.input inputTypes - match Aiur.runFunction decls funcName inputs witness.inputIOBuffer with - | (.error e, s) => - IO.eprintln s!"{label}: interpreter error:\n{e.ppDeref s.store 1 10}" - return 1 - | (.ok output, _) => - IO.println s!"{label}: {output}" - pure 0 - /-- The environment a claim about `name` is checked against when no `.ixe` is given: the closure of `name`, with the constants the kernel fabricates - during reduction and the roles' constants (the selection of - `IxVM.ClaimHarness.loadIxonEnv`), compiled by the certified Lean compiler - (`Ix.CompileM.compileCertified`) and bound to the default role table. -/ + during reduction and the roles' constants, compiled by the certified Lean + compiler (`Ix.CompileM.compileCertified`) and bound to the default role + table. -/ def loadNamedIxonEnv (name : Lean.Name) (leanEnv : Lean.Environment) : IO Ixon.Env := IxVM.ClaimHarness.loadIxonEnv name leanEnv -/-- Shared driver for `ix check` / `ix prove`. Loads either a `.ixe` - env (with optional `--claim` over a persisted claim, or per-name - iteration) or the compiled-in Lean env (per-name iteration only), - constructs each `(Claim, WitnessSource, label)` triple, and - dispatches to `runOne`. Accumulates failures + prints a `[logTag]` - summary. - - `runOne` ignores `Claim` for `ix check` (the witness encodes the - claim digest in its IO buffer); `ix prove` uses it to persist - the claim alongside the proof wrapper. - - The `WitnessSource` is `Native` (Rust-built witness from a - `.ixe` path + target addr) whenever both are available and the - claim is the common `Claim.check addr none` shape — avoids the - per-byte boxing into `Aiur.G` that dominates wall time on heavy - claims. Falls back to `Lean` when the env is the compiled-in - Lean env (no `.ixe` to mmap) or when the persisted `--claim` - variant isn't `check addr none`. - - Without a `.ixe`, each name's closure is compiled by the certified - Lean compiler (`loadNamedIxonEnv`). -/ +/-- Shared driver for `ix check` / `ix prove`. -/ def forEachClaim (ixePath : Option String) (claimHex : Option String) (names : List String) (keepGoing : Bool) (logTag : String) (forceLeanWitness : Bool) (runOne : Ix.Claim → Option Aiur.EnvHandle → Target → String → IO UInt32) + (assumeBinding : Bool := false) : IO UInt32 := do let mut failures : Array String := #[] match ixePath with | some path => - -- Build the env once for the entire batch. The lazy index parse - -- runs O(num_consts) once at handle construction; all per-name - -- FFI calls below share the parsed env (no per-call re-mmap). - -- The Lean-side Ixon.Env serves `resolveIxeAddr` (the name → address - -- resolution used by `--claim` / per-name modes), the claims' context - -- and the rare non-`check addr none` claim-variant Lean witness - -- builder. Anon load is lazy zero-copy. let (ixonEnv, envHandle) ← loadBoundIxe path IO.println s!"Loaded {path}: {ixonEnv.namedCount} named, \ {ixonEnv.constCount} consts, {ixonEnv.blobCount} blobs" if let some hex := claimHex then let (claim, trees) ← loadClaimAndTrees hex let label := s!"claim {hex}" - -- Persisted `--claim` may be any `Claim` variant; only the - -- `check addr none` shape has a Rust-witness fast path today. - -- Other variants (eval/reveal/contains/checkEnv-with-asm) - -- still build the witness in Lean. `forceLeanWitness` (set by - -- `--interp source`) always routes through the Lean witness - -- path even for the fast-path shape — `.addr` targets are - -- unreachable from `runInterp`. let target : Target ← match claim with | .check _ addr none => if forceLeanWitness then @@ -326,10 +142,10 @@ def forEachClaim for (ixName, named) in sorted do let leanName := ixNameToLeanName ixName let label := toString leanName - let claim ← checkClaimOf ixonEnv named.addr + let claim ← checkClaimOf ixonEnv named.addr assumeBinding let target : Target ← if forceLeanWitness then - let w ← mkWitness named.addr ixonEnv + let w ← mkWitness named.addr ixonEnv assumeBinding pure (.leanW w) else pure (.addr named.addr) if (← runOne claim (some envHandle) target label) ≠ 0 then @@ -344,10 +160,10 @@ def forEachClaim if !keepGoing then break | some addr => let label := arg - let claim ← checkClaimOf ixonEnv addr + let claim ← checkClaimOf ixonEnv addr assumeBinding let target : Target ← if forceLeanWitness then - let w ← mkWitness addr ixonEnv + let w ← mkWitness addr ixonEnv assumeBinding pure (.leanW w) else pure (.addr addr) if (← runOne claim (some envHandle) target label) ≠ 0 then @@ -357,22 +173,12 @@ def forEachClaim if claimHex.isSome then IO.eprintln "error: --claim requires --ixe "; return 1 let env ← get_env! - -- Compiled-Lean-env path. Builds a per-name Ixon env in Lean - -- memory, serializes to a byte blob, and constructs an - -- `EnvHandle` from it. Each name has its own closure-rooted - -- env, so the handle is rebuilt per name. (The `--ixe` arm - -- can share one handle across many names; this arm cannot - -- without a shared-env preprocess pass.) let runOneByName (name : Lean.Name) (label : String) : IO UInt32 := do - -- the kernel env loader: also seeds the constants the kernel fabricates - -- during reduction (Bool/Nat ctors, String-literal ctor form), - -- whose bytes must be in ch 2 even when the target's proof body - -- never references them. let ixonEnv ← loadNamedIxonEnv name env let addr ← IxVM.ClaimHarness.lookupAddr ixonEnv name - let claim ← checkClaimOf ixonEnv addr + let claim ← checkClaimOf ixonEnv addr assumeBinding if forceLeanWitness then - let w ← mkWitness addr ixonEnv + let w ← mkWitness addr ixonEnv assumeBinding runOne claim none (.leanW w) label else let envBytes ← match Ixon.serEnv ixonEnv with diff --git a/Ix/ClaimContext.lean b/Ix/ClaimContext.lean index 1cca62d04..a272e2feb 100644 --- a/Ix/ClaimContext.lean +++ b/Ix/ClaimContext.lean @@ -40,8 +40,8 @@ namespace Ix.ClaimContext open Ix.Kernel (Role RoleTable) /-- The context of a claim over the role binding with hash `binding`. -/ -def ofBinding (binding : Address) : Except String ClaimContext := do - return { spec := ← Ix.SpecDigest.specDigest, binding, axioms := none } +def ofBinding (binding : Address) (bindingAssumed : Bool := false) : Except String ClaimContext := do + return { spec := ← Ix.SpecDigest.specDigest, binding, axioms := none, bindingAssumed } /-- Safe axioms in `env` not bound by its role binding (`propext`, `Classical.choice` and `sorryAx` are role-bound; `Quot.sound` is a `.quot` @@ -65,12 +65,13 @@ def userAxiomTree (env : Ixon.Env) : Option AssumptionTree := /-- The context of a claim over an environment's own role binding and user axioms. -/ -def ofEnv (env : Ixon.Env) : Except String ClaimContext := do +def ofEnv (env : Ixon.Env) (bindingAssumed : Bool := false) : Except String ClaimContext := do let some binding := env.roleBinding | throw "claim context: the environment carries no role binding" return { spec := ← Ix.SpecDigest.specDigest binding := binding.address - axioms := (userAxiomTree env).map (·.root) } + axioms := (userAxiomTree env).map (·.root) + bindingAssumed } /-- The context of a claim over the default role table (`Ix.Kernel.Reader.defaultTable`), the generated table of the compiled diff --git a/Ix/Cli/AddrOfCmd.lean b/Ix/Cli/AddrOfCmd.lean index e8f4ee502..e8be65feb 100644 --- a/Ix/Cli/AddrOfCmd.lean +++ b/Ix/Cli/AddrOfCmd.lean @@ -42,10 +42,10 @@ def runAddrOfCmd (p : Cli.Parsed) : IO UInt32 := do IO.eprintln s!"error: failed to deserialize {path}: {e}"; return 1 | .ok env => pure env match resolveIxeAddr ixonEnv argStr with - | none => - IO.eprintln s!"error: {name} not found in {path}"; return 1 - | some addr => - IO.println (toString addr); return 0 + | none => + IO.eprintln s!"error: {name} not found in {path}"; return 1 + | some addr => + IO.println (toString addr); return 0 | none => let env ← get_env! if !env.constants.contains name then diff --git a/Ix/Cli/AggregateCmd.lean b/Ix/Cli/AggregateCmd.lean index 95bcc19a5..7215d5e6e 100644 --- a/Ix/Cli/AggregateCmd.lean +++ b/Ix/Cli/AggregateCmd.lean @@ -1,159 +1,21 @@ /- `ix aggregate --ixe E --ixes M ...` - - Bind persisted shard proof wrappers to every nonempty shard in a manifest, - wrap each IxVM proof into the single-entrypoint `ix_aggr` recursion system, - then execute/prove binary folds in the manifest's bisection-tree order. - Small folds use flat canonical subjects; folds above `--structural-above` - use an O(1) root-of-roots subject fold plus assumption-membership paths. - `--direct-joins` keeps raw IxVM leaves until their first parent as an - explicitly non-default policy. The final persisted wrapper carries the - aggregate `CheckEnv` claim and recursive proof bytes. - - The host driver schedules the fold as a dependency DAG. Ready slots run on - dedicated tasks under explicit job and RAM reservations; every completed - wrap/fold is persisted in a verified, content-addressed resume cache. + or `ix aggregate --ixc ...` -/ module -import Ix.TracingTexray public import Cli -public import Ix.Aggr -public import Ix.Aggr.Backend -public import Ix.IxVM -public import MultiStark -public import Ix.Store +public import Ix.Cli.FormalAggregate public import Ix.Cli.CatalogAggregate public section namespace Ix.Cli.AggregateCmd -open Aggr - -private def timed {α : Type} (action : IO α) : IO (α × Nat) := do - let started ← IO.monoMsNow - let result ← action - pure (result, (← IO.monoMsNow) - started) - -/-- Production Stage 2 entrypoint. The Lean-authored circuit sources still -compile here, in parallel with mmap-loading the environment. Once both Aiur -systems exist, one FFI call transfers the complete data-dependent pipeline to -Rust; no Lean statement tree or scheduler task survives on this path. -/ -private def runAggregateCmdNativeWith - (recursionParameters : Aggr.RecursionParameters) - (p : Cli.Parsed) : IO UInt32 := do - if let some ixc := (p.flag? "ixc").map (·.as! String) then - let maxRamGb? := (p.flag? "max-ram").map (·.as! Nat) - if maxRamGb? == some 0 then - IO.eprintln "error: --max-ram must be positive" - return 1 - let ramBudgetBytes ← match maxRamGb? with - | some gib => pure (gib * aggregateGiB) - | none => defaultAggregateRamBudgetBytes - let structuralAbove := ((p.flag? "structural-above").map (·.as! Nat)).getD - defaultStructuralAbove - return ← Ix.Cli.CatalogAggregate.aggregateCatalog ixc (p.variableArgsAs! String) - ramBudgetBytes structuralAbove recursionParameters - let some ixePath := (p.flag? "ixe").map (·.as! String) | do - p.printError "error: aggregate requires --ixe " - return 1 - let some manifestPath := (p.flag? "ixes").map (·.as! String) | do - p.printError "error: aggregate requires --ixes " - return 1 - let maxRamGb? := (p.flag? "max-ram").map (·.as! Nat) - if maxRamGb? == some 0 then - IO.eprintln "error: --max-ram must be positive" - return 1 - let ramBudgetBytes ← match maxRamGb? with - | some gib => pure (gib * aggregateGiB) - | none => defaultAggregateRamBudgetBytes - let jobs := ((p.flag? "jobs").map (·.as! Nat)).getD 0 - let structuralAbove := ((p.flag? "structural-above").map (·.as! Nat)).getD - defaultStructuralAbove - let reproveSlot? := (p.flag? "reprove-slot").map (·.as! Nat) - if reproveSlot?.isSome && p.hasFlag "plan-only" then - IO.eprintln "error: --reprove-slot cannot be combined with --plan-only" - return 1 - if reproveSlot?.isSome && p.hasFlag "no-cache" then - IO.eprintln "error: --reprove-slot requires aggregate cache reads" - return 1 - let reproveSlotCode := reproveSlot?.map (· + 1) |>.getD 0 - let subtree? := (p.flag? "subtree").map (·.as! Nat) - if subtree?.isSome && reproveSlot?.isSome then - IO.eprintln "error: --subtree cannot be combined with --reprove-slot" - return 1 - if subtree?.isSome && p.hasFlag "wrap-root" then - IO.eprintln "error: --wrap-root applies to the root; --subtree proves a subtree" - return 1 - if subtree?.isSome && p.hasFlag "no-cache" && !p.hasFlag "plan-only" then - IO.eprintln "error: --subtree publishes its root through the aggregate cache; \ - it cannot run with --no-cache" - return 1 - let subtreeCode := subtree?.map (· + 1) |>.getD 0 - let proofHexes := String.intercalate "\n" - (p.variableArgsAs! String).toList - - let setupStarted ← IO.monoMsNow - let envTask ← IO.asTask (prio := .dedicated) do - timed (IO.lazyPure fun _ => Aiur.EnvHandle.fromIxe ixePath) - let ixvmBackendTask ← IO.asTask (prio := .dedicated) do - timed (Aggr.compileBackend "IxVM" (fun _ => IxVM.ixVM) IxVM.functionGroups - Aiur.defaultCommitmentParameters Aiur.defaultFriParameters) - let aggrBackendTask ← IO.asTask (prio := .dedicated) do - timed (Aggr.compileBackend "ixAggr recursion" (fun _ => Aggr.ixAggr) - Aggr.functionGroups recursionParameters.commitment recursionParameters.fri) - - -- Join every setup branch before selecting an error, so a failed branch - -- cannot orphan compilation work in the process. - let (envResult, envMs) ← IO.ofExcept envTask.get - let (ixvmResult, ixvmMs) ← IO.ofExcept ixvmBackendTask.get - let (aggrResult, aggrMs) ← IO.ofExcept aggrBackendTask.get - let setupMs := (← IO.monoMsNow) - setupStarted - IO.println s!"[aggregate] parallel host setup: {setupMs}ms \ - (environment {envMs}ms, IxVM backend {ixvmMs}ms, ixAggr backend {aggrMs}ms)" - (← IO.getStdout).flush - - let envHandle ← match envResult with - | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1 - | .ok handle => pure handle - let ixvmBackend ← match ixvmResult with - | .error e => IO.eprintln e; return 1 - | .ok backend => pure backend - let aggrBackend ← match aggrResult with - | .error e => IO.eprintln e; return 1 - | .ok backend => pure backend - let verifyIdx := ixvmBackend.compiled.getFuncIdx `verify_claim |>.get! - let aggrIdx := aggrBackend.compiled.getFuncIdx `ix_aggr |>.get! - let nativeResult ← IO.lazyPure fun _ => - ixvmBackend.system.aggregateStage2 aggrBackend.system envHandle - manifestPath proofHexes verifyIdx aggrIdx jobs ramBudgetBytes - structuralAbove reproveSlotCode (p.hasFlag "direct-joins") - (p.hasFlag "plan-only") - recursionParameters.cacheFriBytes (!(p.hasFlag "no-cache")) - (!(p.hasFlag "no-write")) (p.hasFlag "trace-shards") - (((p.flag? "range").map (·.as! Nat)).getD 0) (p.hasFlag "wrap-root") - (((p.flag? "exec-ahead").map (·.as! Nat)).getD 1) false subtreeCode - (((p.flag? "binding-proof").map (·.as! String)).getD "") - match nativeResult with - | .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 such as `ix prove --ixe --ixes` reads; the log lines are on stderr. - if !address.isEmpty then - IO.println address - (← IO.getStdout).flush - return 0 - -/-- Aggregate through the native controller. -/ -def runAggregateCmdWith (recursionParameters : Aggr.RecursionParameters) - (p : Cli.Parsed) : IO UInt32 := - runAggregateCmdNativeWith recursionParameters p - def runAggregateCmd (p : Cli.Parsed) : IO UInt32 := do - -- Streamed `[texray]` span lines on stderr: the per-node wall and RSS - -- breakdown of every slot's execution, witness and STARK phases. - if ← TracingTexray.enabled (p.hasFlag "texray") then TracingTexray.init {} - runAggregateCmdWith Aggr.defaultRecursionParameters p + let _ ← FormalAiur.selected p + if let some ixc := (p.flag? "ixc").map (·.as! String) then + return ← CatalogAggregate.aggregateCatalog p ixc + FormalAggregate.run p end Ix.Cli.AggregateCmd @@ -163,6 +25,13 @@ def aggregateCmd : Cli.Cmd := `[Cli| "Wrap shard proofs and fold multi-shard manifests into one recursive aggregate" FLAGS: + "gpu-device" : Nat; "Use this CUDA device with the Aiur host (requires a CUDA build)." + "legacy"; "Retired legacy Aiur backend flag." + "formal"; "Compatibility alias for the default certified Aiur backend." + "aiur-artifact" : String; "Trusted formal IxVM artifact; otherwise compile/cache local sources." + "aggr-artifact" : String; "Trusted formal aggregation artifact; otherwise compile/cache local sources." + "shard-rows" : Nat; "Aiur: maximum rows per function/memory chip per trace shard (power of two; default 0, which lets the planner choose the largest shards within the RAM budget and, on CUDA, the device cell budget AIUR_TRACE_SHARD_MAX_CELLS, default 1.5e9). Small caps multiply recursive verification work." + "retention" : String; "Aiur: auto, retain or regenerate (default auto)." "ixe" : String; "Path to the serialized environment whose shards were proven. It must carry the role binding the shard claims are relative to." "ixes" : String; "Path to the shard manifest; its bisection tree determines join order." "ixc" : String; "A .ixc catalog directory: join the aggregate roots of its members, one per member (`ix aggregate --ixe --ixes --binding-proof ` on each piece), into one root. Members whose role bindings have one literal class are joined first, in manifest order (cross-binding pairs, under the class), then the classes into a Catalog claim. Each join is proven as trace shards within --max-ram. A member's statement is its piece's canonical claim, or the claim of `

deserializer, mirror (Kernel/Claim.lean:109). - fn get_opt_addr(stream: ByteStream) -> (Option‹Addr›, ByteStream) { - let (tag, s) = read_byte(stream); - match tag { - 0 => (Option.None, s), - 1 => - let (addr, s2) = get_address(s); - (Option.Some(addr), s2), - } - } - - -- A typing claim's context (`Ix.ClaimContext`): the specification - -- digest, which must be this circuit's; the role binding's hash; and the - -- optional merkle root of safe user axioms beyond the standard three. - -- Returns the binding hash, the axioms root, and the rest of the stream. - fn get_claim_context(stream: ByteStream) -> (Addr, Option‹Addr›, ByteStream) { - let (spec, s) = get_address(stream); - assert_eq!(address_eq(spec, @spec_digest()), 1, - "claim: specification digest is not this circuit's"); - let (binding, s2) = get_address(s); - let (axioms, s3) = get_opt_addr(s2); - (binding, axioms, s3) - } - - -- ============================================================================ - -- Reveal claim (variant 6). The machinery is Ixon-level rather than - -- typechecker-level: parse a `RevealConstantInfo` (per-field Option - -- mirror of `ConstantInfo`, Expr fields as content hashes), load the - -- committed constant, assert every Some(field) equals the real one. - - enum RevealRecursorRule { - Mk(U64, U64, Addr) - } - - enum RevealConstructorInfo { - Mk(Option‹G›, Option‹U64›, Option‹U64›, - Option‹U64›, Option‹U64›, Option‹Addr›) - } - - enum RevealMutConstInfo { - Defn(Option‹DefKind›, Option‹DefinitionSafety›, - Option‹U64›, Option‹Addr›, Option‹Addr›), - Indc(Option‹G›, - Option‹U64›, Option‹U64›, Option‹U64›, - Option‹Addr›, - Option‹List‹(U64, RevealConstructorInfo)››), - Recr(Option‹G›, Option‹G›, - Option‹U64›, Option‹U64›, Option‹U64›, - Option‹U64›, Option‹U64›, - Option‹Addr›, Option‹List‹RevealRecursorRule››) - } - - enum RevealConstantInfo { - Defn(Option‹DefKind›, Option‹DefinitionSafety›, - Option‹U64›, Option‹Addr›, Option‹Addr›), - Recr(Option‹G›, Option‹G›, - Option‹U64›, Option‹U64›, Option‹U64›, - Option‹U64›, Option‹U64›, - Option‹Addr›, Option‹List‹RevealRecursorRule››), - Axio(Option‹G›, Option‹U64›, Option‹Addr›), - Quot(Option‹QuotKind›, Option‹U64›, Option‹Addr›), - CPrj(Option‹U64›, Option‹U64›, Option‹Addr›), - RPrj(Option‹U64›, Option‹Addr›), - IPrj(Option‹U64›, Option‹Addr›), - DPrj(Option‹U64›, Option‹Addr›), - Muts(List‹(U64, RevealMutConstInfo)›) - } - - -- Bitmask-gated decoders for the per-field Reveal payloads. - fn get_opt_u64_masked(mb: G, stream: ByteStream) - -> (Option‹U64›, ByteStream) { - match mb { - 0 => (Option.None, stream), - _ => - let (n, s) = get_tagn0(stream); - (Option.Some(n), s), - } - } - - fn get_opt_addr_masked(mb: G, stream: ByteStream) - -> (Option‹Addr›, ByteStream) { - match mb { - 0 => (Option.None, stream), - _ => - let (a, s) = get_address(stream); - (Option.Some(a), s), - } - } - - fn get_opt_bool_masked(mb: G, stream: ByteStream) - -> (Option‹G›, ByteStream) { - match mb { - 0 => (Option.None, stream), - _ => - let (b, s) = read_byte(stream); - (Option.Some(to_field(b)), s), - } - } - - fn get_opt_def_kind_masked(mb: G, stream: ByteStream) - -> (Option‹DefKind›, ByteStream) { - match mb { - 0 => (Option.None, stream), - _ => - let (b, s) = read_byte(stream); - match b { - 0 => (Option.Some(DefKind.Definition), s), - 1 => (Option.Some(DefKind.Opaque), s), - 2 => (Option.Some(DefKind.Theorem), s), - }, - } - } - - fn get_opt_def_safety_masked(mb: G, stream: ByteStream) - -> (Option‹DefinitionSafety›, ByteStream) { - match mb { - 0 => (Option.None, stream), - _ => - let (b, s) = read_byte(stream); - match b { - 0 => (Option.Some(DefinitionSafety.Unsafe), s), - 1 => (Option.Some(DefinitionSafety.Safe), s), - 2 => (Option.Some(DefinitionSafety.Partial), s), - }, - } - } - - fn get_opt_quot_kind_masked(mb: G, stream: ByteStream) - -> (Option‹QuotKind›, ByteStream) { - match mb { - 0 => (Option.None, stream), - _ => - let (b, s) = read_byte(stream); - match b { - 0 => (Option.Some(QuotKind.Typ), s), - 1 => (Option.Some(QuotKind.Ctor), s), - 2 => (Option.Some(QuotKind.Lift), s), - 3 => (Option.Some(QuotKind.Ind), s), - }, - } - } - - -- RevealRecursorRule list parser. - -- Wire: `TagN0(count) + count × (TagN0(idx) + TagN0(fields) + Address)`. - fn get_reveal_rule(stream: ByteStream) -> (RevealRecursorRule, ByteStream) { - let (rule_idx, s) = get_tagn0(stream); - let (fields, s) = get_tagn0(s); - let (rhs, s) = get_address(s); - (RevealRecursorRule.Mk(rule_idx, fields, rhs), s) - } - - fn get_reveal_rule_list_inner(stream: ByteStream, count: U64) - -> (List‹RevealRecursorRule›, ByteStream) { - match u64_is_zero(count) { - 1 => (store(ListNode.Nil), stream), - _ => - let (rule, s) = get_reveal_rule(stream); - let (rest, s2) = get_reveal_rule_list_inner(s, relaxed_u64_pred(count)); - (store(ListNode.Cons(rule, rest)), s2), - } - } - - fn get_opt_rule_list_masked(mb: G, stream: ByteStream) - -> (Option‹List‹RevealRecursorRule››, ByteStream) { - match mb { - 0 => (Option.None, stream), - _ => - let (count, s) = get_tagn0(stream); - let (rules, s2) = get_reveal_rule_list_inner(s, count); - (Option.Some(rules), s2), - } - } - - -- RevealConstructorInfo parser. 6 optional fields, mask bits 0..5. - fn get_reveal_ctor_info(stream: ByteStream) - -> (RevealConstructorInfo, ByteStream) { - let (mask, s) = get_tagn0(stream); - let mask_lo = u8_bit_decomposition(mask[0]); - let [b0, b1, b2, b3, b4, b5, _, _] = mask_lo; - let (is_unsafe, s) = get_opt_bool_masked(b0, s); - let (lvls, s) = get_opt_u64_masked(b1, s); - let (cidx, s) = get_opt_u64_masked(b2, s); - let (params, s) = get_opt_u64_masked(b3, s); - let (fields, s) = get_opt_u64_masked(b4, s); - let (typ, s) = get_opt_addr_masked(b5, s); - (RevealConstructorInfo.Mk(is_unsafe, lvls, cidx, params, fields, typ), s) - } - - fn get_ctor_entry(stream: ByteStream) - -> ((U64, RevealConstructorInfo), ByteStream) { - let (idx, s) = get_tagn0(stream); - let (info, s) = get_reveal_ctor_info(s); - ((idx, info), s) - } - - fn get_ctor_entry_list_inner(stream: ByteStream, count: U64) - -> (List‹(U64, RevealConstructorInfo)›, ByteStream) { - match u64_is_zero(count) { - 1 => (store(ListNode.Nil), stream), - _ => - let (entry, s) = get_ctor_entry(stream); - let (rest, s2) = get_ctor_entry_list_inner(s, relaxed_u64_pred(count)); - (store(ListNode.Cons(entry, rest)), s2), - } - } - - fn get_opt_ctor_entry_list_masked(mb: G, stream: ByteStream) - -> (Option‹List‹(U64, RevealConstructorInfo)››, ByteStream) { - match mb { - 0 => (Option.None, stream), - _ => - let (count, s) = get_tagn0(stream); - let (list, s2) = get_ctor_entry_list_inner(s, count); - (Option.Some(list), s2), - } - } - - -- RevealMutConstInfo parser. variant + mask + per-bit fields. - fn get_reveal_mut_const_info(stream: ByteStream) - -> (RevealMutConstInfo, ByteStream) { - let (variant, s) = read_byte(stream); - let (mask, s) = get_tagn0(s); - let mask_lo = u8_bit_decomposition(mask[0]); - let [b0, b1, b2, b3, b4, b5, b6, b7] = mask_lo; - let mask_hi = u8_bit_decomposition(mask[1]); - let [b8, _, _, _, _, _, _, _] = mask_hi; - match variant { - 0 => - let (kind, s) = get_opt_def_kind_masked(b0, s); - let (safety, s) = get_opt_def_safety_masked(b1, s); - let (lvls, s) = get_opt_u64_masked(b2, s); - let (typ, s) = get_opt_addr_masked(b3, s); - let (value, s) = get_opt_addr_masked(b4, s); - (RevealMutConstInfo.Defn(kind, safety, lvls, typ, value), s), - 1 => - let (is_unsafe, s) = get_opt_bool_masked(b0, s); - let (lvls, s) = get_opt_u64_masked(b1, s); - let (params, s) = get_opt_u64_masked(b2, s); - let (indices, s) = get_opt_u64_masked(b3, s); - let (typ, s) = get_opt_addr_masked(b4, s); - let (ctors, s) = get_opt_ctor_entry_list_masked(b5, s); - (RevealMutConstInfo.Indc(is_unsafe, lvls, params, - indices, typ, ctors), s), - 2 => - let (k, s) = get_opt_bool_masked(b0, s); - let (is_unsafe, s) = get_opt_bool_masked(b1, s); - let (lvls, s) = get_opt_u64_masked(b2, s); - let (params, s) = get_opt_u64_masked(b3, s); - let (indices, s) = get_opt_u64_masked(b4, s); - let (motives, s) = get_opt_u64_masked(b5, s); - let (minors, s) = get_opt_u64_masked(b6, s); - let (typ, s) = get_opt_addr_masked(b7, s); - let (rules, s) = get_opt_rule_list_masked(b8, s); - (RevealMutConstInfo.Recr(k, is_unsafe, lvls, params, indices, - motives, minors, typ, rules), s), - } - } - - fn get_mut_entry(stream: ByteStream) - -> ((U64, RevealMutConstInfo), ByteStream) { - let (idx, s) = get_tagn0(stream); - let (info, s) = get_reveal_mut_const_info(s); - ((idx, info), s) - } - - fn get_mut_entry_list_inner(stream: ByteStream, count: U64) - -> (List‹(U64, RevealMutConstInfo)›, ByteStream) { - match u64_is_zero(count) { - 1 => (store(ListNode.Nil), stream), - _ => - let (entry, s) = get_mut_entry(stream); - let (rest, s2) = get_mut_entry_list_inner(s, relaxed_u64_pred(count)); - (store(ListNode.Cons(entry, rest)), s2), - } - } - - -- RevealConstantInfo parser. `variant + mask:TagN0 + per-bit fields`. - fn get_reveal_info(stream: ByteStream) -> (RevealConstantInfo, ByteStream) { - let (variant, s) = read_byte(stream); - let (mask, s) = get_tagn0(s); - let mask_lo = u8_bit_decomposition(mask[0]); - let [b0, b1, b2, b3, b4, b5, b6, b7] = mask_lo; - let mask_hi = u8_bit_decomposition(mask[1]); - let [b8, _, _, _, _, _, _, _] = mask_hi; - match variant { - 0 => - let (kind, s) = get_opt_def_kind_masked(b0, s); - let (safety, s) = get_opt_def_safety_masked(b1, s); - let (lvls, s) = get_opt_u64_masked(b2, s); - let (typ, s) = get_opt_addr_masked(b3, s); - let (value, s) = get_opt_addr_masked(b4, s); - (RevealConstantInfo.Defn(kind, safety, lvls, typ, value), s), - 1 => - let (k, s) = get_opt_bool_masked(b0, s); - let (is_unsafe, s) = get_opt_bool_masked(b1, s); - let (lvls, s) = get_opt_u64_masked(b2, s); - let (params, s) = get_opt_u64_masked(b3, s); - let (indices, s) = get_opt_u64_masked(b4, s); - let (motives, s) = get_opt_u64_masked(b5, s); - let (minors, s) = get_opt_u64_masked(b6, s); - let (typ, s) = get_opt_addr_masked(b7, s); - let (rules, s) = get_opt_rule_list_masked(b8, s); - (RevealConstantInfo.Recr(k, is_unsafe, lvls, params, indices, - motives, minors, typ, rules), s), - 2 => - let (is_unsafe, s) = get_opt_bool_masked(b0, s); - let (lvls, s) = get_opt_u64_masked(b1, s); - let (typ, s) = get_opt_addr_masked(b2, s); - (RevealConstantInfo.Axio(is_unsafe, lvls, typ), s), - 3 => - let (kind, s) = get_opt_quot_kind_masked(b0, s); - let (lvls, s) = get_opt_u64_masked(b1, s); - let (typ, s) = get_opt_addr_masked(b2, s); - (RevealConstantInfo.Quot(kind, lvls, typ), s), - 4 => - let (idx, s) = get_opt_u64_masked(b0, s); - let (cidx, s) = get_opt_u64_masked(b1, s); - let (block, s) = get_opt_addr_masked(b2, s); - (RevealConstantInfo.CPrj(idx, cidx, block), s), - 5 => - let (idx, s) = get_opt_u64_masked(b0, s); - let (block, s) = get_opt_addr_masked(b1, s); - (RevealConstantInfo.RPrj(idx, block), s), - 6 => - let (idx, s) = get_opt_u64_masked(b0, s); - let (block, s) = get_opt_addr_masked(b1, s); - (RevealConstantInfo.IPrj(idx, block), s), - 7 => - let (idx, s) = get_opt_u64_masked(b0, s); - let (block, s) = get_opt_addr_masked(b1, s); - (RevealConstantInfo.DPrj(idx, block), s), - 8 => - let (components, s) = match b0 { - 0 => (store(ListNode.Nil), s), - 1 => - let (count, s2) = get_tagn0(s); - get_mut_entry_list_inner(s2, count), - }; - (RevealConstantInfo.Muts(components), s), - } - } - - -- Content hash of an `Expr`: `blake3(put_expr expr)`. - fn expr_addr(e_ref: &Expr) -> Addr { - let bytes = put_expr(load(e_ref), store(ListNode.Nil)); - bytes_to_addr(bytes) - } - - -- Per-field equality checks. None = no-op (selective reveal); - -- Some(claimed) = assert equality with the real field. - fn def_kind_tag(k: DefKind) -> G { - match k { - DefKind.Definition => 0, - DefKind.Opaque => 1, - DefKind.Theorem => 2, - } - } - - fn def_safety_tag(s: DefinitionSafety) -> G { - match s { - DefinitionSafety.Unsafe => 0, - DefinitionSafety.Safe => 1, - DefinitionSafety.Partial => 2, - } - } - - fn quot_kind_tag(k: QuotKind) -> G { - match k { - QuotKind.Typ => 0, - QuotKind.Ctor => 1, - QuotKind.Lift => 2, - QuotKind.Ind => 3, - } - } - - fn check_opt_def_kind(real: DefKind, opt: Option‹DefKind›) { - match opt { - Option.None => (), - Option.Some(claimed) => - assert_eq!(def_kind_tag(real), def_kind_tag(claimed), - "Reveal: claimed definition kind != real"); - (), - } - } - - fn check_opt_def_safety(real: DefinitionSafety, - opt: Option‹DefinitionSafety›) { - match opt { - Option.None => (), - Option.Some(claimed) => - assert_eq!(def_safety_tag(real), def_safety_tag(claimed), - "Reveal: claimed definition safety != real"); - (), - } - } - - fn check_opt_quot_kind(real: QuotKind, opt: Option‹QuotKind›) { - match opt { - Option.None => (), - Option.Some(claimed) => - assert_eq!(quot_kind_tag(real), quot_kind_tag(claimed), - "Reveal: claimed quotient kind != real"); - (), - } - } - - fn check_opt_bool(real: G, opt: Option‹G›) { - match opt { - Option.None => (), - Option.Some(claimed) => - assert_eq!(real, claimed, "Reveal: claimed flag != real"); - (), - } - } - - fn check_opt_u64(real: U64, opt: Option‹U64›) { - match opt { - Option.None => (), - Option.Some(claimed) => - assert_eq!(real, claimed, "Reveal: claimed numeric field != real"); - (), - } - } - - fn check_opt_addr(real: Addr, opt: Option‹Addr›) { - match opt { - Option.None => (), - Option.Some(claimed) => - assert_eq!(load(real), load(claimed), - "Reveal: claimed address field != real"); - (), - } - } - - fn check_opt_expr_addr(real_e: &Expr, opt: Option‹Addr›) { - match opt { - Option.None => (), - Option.Some(claimed) => - let computed = expr_addr(real_e); - assert_eq!(load(computed), load(claimed), - "Reveal: claimed expr hash != hash of the real expr"); - (), - } - } - - -- Walk both lists in lockstep: claimed (idx, fields, rhs_addr) per - -- entry vs real (fields, rhs:&Expr). - -- - -- The claimed `idx` is part of the reveal's digest, so a consumer reads it - -- and believes it identifies WHICH rule was revealed. The comparison here - -- is positional, so without this assert a reveal could carry - -- `ruleIdx: 7` while matching the rule at position 0 — the consumer then - -- believes it learned rule 7 and it learned rule 0. Every sibling reveal - -- check (CPrj/RPrj/IPrj/DPrj) already validates its index. - fn check_recr_rules(real: List‹RecursorRule›, - claimed: List‹RevealRecursorRule›, - pos: U64) { - match load(claimed) { - ListNode.Nil => - match load(real) { - ListNode.Nil => (), - }, - ListNode.Cons(cr, rest_claimed) => - match load(real) { - ListNode.Cons(rr, rest_real) => - match cr { - RevealRecursorRule.Mk(c_idx, c_fields, c_rhs) => - match rr { - RecursorRule.Mk(r_fields, r_rhs) => - assert_eq!(c_idx, pos, - "Reveal: claimed recursor rule index != its position"); - assert_eq!(r_fields, c_fields, - "Reveal: claimed recursor rule field count != real"); - check_opt_expr_addr(r_rhs, Option.Some(c_rhs)); - check_recr_rules(rest_real, rest_claimed, - relaxed_u64_succ(pos)), - }, - }, - }, - } - } - - fn check_opt_recr_rules(real: List‹RecursorRule›, - opt: Option‹List‹RevealRecursorRule››) { - match opt { - Option.None => (), - Option.Some(claimed) => - check_recr_rules(real, claimed, - [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), - } - } - - -- Constructor revelation: compare the Constructor at position `idx` - -- in the real list against the per-field Option‹…› bits. - fn check_ctor_entry(real_list: List‹Constructor›, - idx: U64, - info: RevealConstructorInfo) { - let real_ctor = list_lookup_u64(real_list, idx); - match info { - RevealConstructorInfo.Mk(opt_unsafe, opt_lvls, opt_cidx, - opt_params, opt_fields, opt_typ) => - match real_ctor { - Constructor.Mk(r_unsafe, r_lvls, r_cidx, r_params, r_fields, r_typ) => - check_opt_bool(r_unsafe, opt_unsafe); - check_opt_u64(r_lvls, opt_lvls); - check_opt_u64(r_cidx, opt_cidx); - check_opt_u64(r_params, opt_params); - check_opt_u64(r_fields, opt_fields); - check_opt_expr_addr(r_typ, opt_typ), - }, - } - } - - fn check_ctor_entries(real_list: List‹Constructor›, - claimed: List‹(U64, RevealConstructorInfo)›) { - match load(claimed) { - ListNode.Nil => (), - ListNode.Cons(entry, rest) => - match entry { - (idx, info) => - check_ctor_entry(real_list, idx, info); - check_ctor_entries(real_list, rest), - }, - } - } - - fn check_opt_ctor_entries(real_list: List‹Constructor›, - opt: Option‹List‹(U64, RevealConstructorInfo)››) { - match opt { - Option.None => (), - Option.Some(claimed) => check_ctor_entries(real_list, claimed), - } - } - - -- MutConst revelation: dispatch on the real variant vs the claimed - -- variant; mismatched pairs fail. - fn check_mut_const(real: MutConst, claimed: RevealMutConstInfo) { - match real { - MutConst.Defn(d) => - match claimed { - RevealMutConstInfo.Defn(opt_kind, opt_safety, opt_lvls, - opt_typ, opt_value) => - match d { - Definition.Mk(r_kind, r_safety, r_lvls, r_typ, r_value) => - check_opt_def_kind(r_kind, opt_kind); - check_opt_def_safety(r_safety, opt_safety); - check_opt_u64(r_lvls, opt_lvls); - check_opt_expr_addr(r_typ, opt_typ); - check_opt_expr_addr(r_value, opt_value), - }, - }, - MutConst.Indc(i) => - match claimed { - RevealMutConstInfo.Indc(opt_unsafe, opt_lvls, - opt_params, opt_indices, - opt_typ, opt_ctors) => - match i { - Inductive.Mk(r_unsafe, r_lvls, r_params, - r_indices, r_typ, r_ctors) => - check_opt_bool(r_unsafe, opt_unsafe); - check_opt_u64(r_lvls, opt_lvls); - check_opt_u64(r_params, opt_params); - check_opt_u64(r_indices, opt_indices); - check_opt_expr_addr(r_typ, opt_typ); - check_opt_ctor_entries(r_ctors, opt_ctors), - }, - }, - MutConst.Recr(r) => - match claimed { - RevealMutConstInfo.Recr(opt_k, opt_unsafe, opt_lvls, opt_params, - opt_indices, opt_motives, opt_minors, - opt_typ, opt_rules) => - match r { - Recursor.Mk(r_k, r_unsafe, r_lvls, r_params, r_indices, - r_motives, r_minors, r_typ, r_rules) => - check_opt_bool(r_k, opt_k); - check_opt_bool(r_unsafe, opt_unsafe); - check_opt_u64(r_lvls, opt_lvls); - check_opt_u64(r_params, opt_params); - check_opt_u64(r_indices, opt_indices); - check_opt_u64(r_motives, opt_motives); - check_opt_u64(r_minors, opt_minors); - check_opt_expr_addr(r_typ, opt_typ); - check_opt_recr_rules(r_rules, opt_rules), - }, - }, - } - } - - fn check_muts_components(real: List‹MutConst›, - claimed: List‹(U64, RevealMutConstInfo)›) { - match load(claimed) { - ListNode.Nil => (), - ListNode.Cons(entry, rest_claimed) => - match entry { - (idx, info) => - let real_mc = list_lookup_u64(real, idx); - check_mut_const(real_mc, info); - check_muts_components(real, rest_claimed), - }, - } - } - - -- Reveal: real constant at `comm` must match the variant of `info` - -- AND every Some-field's claimed value must equal the real field. - fn run_reveal(comm_addr: Addr, info: RevealConstantInfo) { - let c = load_verified_constant(comm_addr); - match c { - Constant.Mk(ci, _, _, _) => - match ci { - ConstantInfo.Defn(d) => - match info { - RevealConstantInfo.Defn(opt_kind, opt_safety, opt_lvls, - opt_typ, opt_value) => - match d { - Definition.Mk(r_kind, r_safety, r_lvls, r_typ, r_value) => - check_opt_def_kind(r_kind, opt_kind); - check_opt_def_safety(r_safety, opt_safety); - check_opt_u64(r_lvls, opt_lvls); - check_opt_expr_addr(r_typ, opt_typ); - check_opt_expr_addr(r_value, opt_value), - }, - }, - ConstantInfo.Recr(r) => - match info { - RevealConstantInfo.Recr(opt_k, opt_unsafe, opt_lvls, opt_params, - opt_indices, opt_motives, opt_minors, - opt_typ, opt_rules) => - match r { - Recursor.Mk(r_k, r_unsafe, r_lvls, r_params, r_indices, - r_motives, r_minors, r_typ, r_rules) => - check_opt_bool(r_k, opt_k); - check_opt_bool(r_unsafe, opt_unsafe); - check_opt_u64(r_lvls, opt_lvls); - check_opt_u64(r_params, opt_params); - check_opt_u64(r_indices, opt_indices); - check_opt_u64(r_motives, opt_motives); - check_opt_u64(r_minors, opt_minors); - check_opt_expr_addr(r_typ, opt_typ); - check_opt_recr_rules(r_rules, opt_rules), - }, - }, - ConstantInfo.Axio(a) => - match info { - RevealConstantInfo.Axio(opt_unsafe, opt_lvls, opt_typ) => - match a { - Axiom.Mk(r_unsafe, r_lvls, r_typ) => - check_opt_bool(r_unsafe, opt_unsafe); - check_opt_u64(r_lvls, opt_lvls); - check_opt_expr_addr(r_typ, opt_typ), - }, - }, - ConstantInfo.Quot(q) => - match info { - RevealConstantInfo.Quot(opt_kind, opt_lvls, opt_typ) => - match q { - Quotient.Mk(r_kind, r_lvls, r_typ) => - check_opt_quot_kind(r_kind, opt_kind); - check_opt_u64(r_lvls, opt_lvls); - check_opt_expr_addr(r_typ, opt_typ), - }, - }, - ConstantInfo.CPrj(p) => - match info { - RevealConstantInfo.CPrj(opt_idx, opt_cidx, opt_block) => - match p { - ConstructorProj.Mk(r_idx, r_cidx, r_block) => - check_opt_u64(r_idx, opt_idx); - check_opt_u64(r_cidx, opt_cidx); - check_opt_addr(r_block, opt_block), - }, - }, - ConstantInfo.RPrj(p) => - match info { - RevealConstantInfo.RPrj(opt_idx, opt_block) => - match p { - RecursorProj.Mk(r_idx, r_block) => - check_opt_u64(r_idx, opt_idx); - check_opt_addr(r_block, opt_block), - }, - }, - ConstantInfo.IPrj(p) => - match info { - RevealConstantInfo.IPrj(opt_idx, opt_block) => - match p { - InductiveProj.Mk(r_idx, r_block) => - check_opt_u64(r_idx, opt_idx); - check_opt_addr(r_block, opt_block), - }, - }, - ConstantInfo.DPrj(p) => - match info { - RevealConstantInfo.DPrj(opt_idx, opt_block) => - match p { - DefinitionProj.Mk(r_idx, r_block) => - check_opt_u64(r_idx, opt_idx); - check_opt_addr(r_block, opt_block), - }, - }, - ConstantInfo.Muts(real_mc_list) => - match info { - RevealConstantInfo.Muts(claimed_components) => - check_muts_components(real_mc_list, claimed_components), - }, - }, - } - } - - -- Contains claim (variant 7): merkle membership of `target` in the - -- tree at `tree_root`. Mirror run_contains. - fn run_contains(tree_root: Addr, target: Addr) { - let leaves = load_assumption_tree(tree_root); - assert_eq!(se_addr_in(target, leaves), 1, - "Contains: target is not a leaf of the claimed tree"); - } - - -- Claim dispatch. Loads claim bytes at ch 0 keyed by digest, - -- blake3-verifies, and dispatches: - -- The typing variants 3-5 read their context first (`get_claim_context`): - -- variant 3 (Eval ctx input output asm?) → checked normalization. - -- variant 4 (Check ctx target asm?) → transitive check; with asm the - -- walk stops at frontier members (no owned-membership rule — - -- Check claims target + everything reachable, no ownership set). - -- variant 5 (CheckEnv ctx root asm?) → run_check_env: per-leaf - -- transitive walk, asm cutoff, strict owned-membership. - -- variant 6 (Reveal comm info) → run_reveal: selective field - -- revelation of the committed constant. - -- variant 7 (Contains tree target) → run_contains: merkle - -- membership. - -- variant 9 (Resource, `E8 01`) has an arm that fails explicitly: - -- resource validation is native, not proved here. - -- Variant 8 (Catalog, `E8 00`) has no arm by design: a Catalog claim is - -- verified by host or aggregate composition, not by this circuit. Other - -- unknown variants have no arm and abort rather than accepting the claim. - fn run_claim(digest: [G; 8]) { - -- `digest` is the packed-4-byte public claim digest; the ch-0 key uses - -- the same packed form (io keys are execution-side only — no columns). - let (idx, len) = io_get_info(0, digest); - let bytes = read_checked_byte_stream(0, idx, len); - -- Binding: the claim bytes must hash to the PUBLIC digest. Packed - -- comparison (8 wiring-packed words), no byte-form digest needed. - let h = @blake3(bytes); - assert_eq!(@b3_pack(h), digest, - "claim: bytes do not hash to the public claim digest"); - -- The claim header is TagN4(0xE, variant): variants 3-7 are the one - -- byte 0xE3-0xE7, and Resource (9) and Binding (10) are rung 2, - -- `E8 01` and `E8 02`. - let (tag, s) = get_tagn4(bytes); - let (flag, size) = tag; - assert_eq!(flag, 0xE, "claim: wrong TagN flag"); - -- Dispatch on the FULL TagN value, matching Rust `Claim::get`, which - -- matches `tag.value: u64`. The variant is only ever 3-10, so the high 7 - -- bytes must be zero; a value >= 256 whose low byte is a variant would - -- otherwise dispatch here while Rust rejects it as an unknown variant. - -- Sum is 0 iff every high byte is 0 (7 bytes, max sum 1785, no wrap). - let [_, sz1, sz2, sz3, sz4, sz5, sz6, sz7] = size; - assert_eq!(((((((to_field(sz1) + to_field(sz2)) + to_field(sz3)) - + to_field(sz4)) + to_field(sz5)) + to_field(sz6)) - + to_field(sz7)), 0, - "claim: TagN size exceeds a single byte"); - let variant = size[0]; - -- Object format 4 is Ixon v4, the wire format this circuit reads. - let (format, s) = read_byte(s); - assert_eq!(format, 4u8, "claim: unsupported object format"); - let (validator, s) = read_byte(s); - match variant { - 3 => - assert_eq!(validator, 3u8, "claim: wrong validator identity"); - let (binding, axioms, s) = get_claim_context(s); - let rc = load_role_ctx(binding, 3, axioms); - let (input, s) = get_address(s); - let (output, s) = get_address(s); - let (asm, rest) = get_opt_addr(s); - assert_eq!(load(rest), ListNode.Nil, "claim: trailing bytes"); - run_eval(rc, input, output, asm), - 4 => - -- Validator 3 validates the binding's roles as the claim uses - -- them; 4 assumes the binding meets the specifications. - let (binding, axioms, s) = get_claim_context(s); - let rc = load_role_ctx(binding, to_field(validator), axioms); - let (target, s2) = get_address(s); - let (asm, rest) = get_opt_addr(s2); - assert_eq!(load(rest), ListNode.Nil, "claim: trailing bytes"); - match asm { - Option.None => run_check_transitive(rc, target), - Option.Some(r) => - let asm_leaves = load_assumption_tree(r); - let asm_set = addr_set_build(asm_leaves, RBTreeMap.Nil); - -- strict = 2 rejects `target ∈ asm_set` at the root without - -- enforcing owned-set membership on transitive dependencies. - env_walk(rc, target, RBTreeMap.Nil, asm_set, 2), - }, - 5 => - let (binding, axioms, s) = get_claim_context(s); - let rc = load_role_ctx(binding, to_field(validator), axioms); - let (root, s2) = get_address(s); - let (asm, rest) = get_opt_addr(s2); - assert_eq!(load(rest), ListNode.Nil, "claim: trailing bytes"); - run_check_env(rc, root, asm), - 6 => - assert_eq!(validator, 0u8, "claim: wrong validator identity"); - let (comm, s2) = get_address(s); - let (info, rest) = get_reveal_info(s2); - assert_eq!(load(rest), ListNode.Nil, "claim: trailing bytes"); - run_reveal(comm, info), - 7 => - assert_eq!(validator, 0u8, "claim: wrong validator identity"); - let (tree, s2) = get_address(s); - let (target, rest) = get_address(s2); - assert_eq!(load(rest), ListNode.Nil, "claim: trailing bytes"); - run_contains(tree, target), - 9 => - assert_eq!(validator, 2u8, "claim: wrong resource validator identity"); - -- Native resource admission is not a circuit proof. Keep this - -- unsupported boundary explicit; no host success flag is trusted. - assert_eq!(0, 1, "claim: resource-v1 is not implemented by IxVM"); - (), - 10 => - -- The binding claim: the table binds every role and each bound - -- constant meets its specification, which admitting every group - -- checks. - assert_eq!(validator, 3u8, "claim: wrong validator identity"); - let (spec, s2) = get_address(s); - assert_eq!(address_eq(spec, @spec_digest()), 1, - "claim: specification digest is not this circuit's"); - let (binding, rest) = get_address(s2); - assert_eq!(load(rest), ListNode.Nil, "claim: trailing bytes"); - validate_binding(binding), - } - } -⟧ - -end IxVM - -end diff --git a/Ix/IxVM/Kernel/DefEq.lean b/Ix/IxVM/Kernel/DefEq.lean deleted file mode 100644 index f06cc0631..000000000 --- a/Ix/IxVM/Kernel/DefEq.lean +++ /dev/null @@ -1,1364 +0,0 @@ -module -public import Ix.Aiur.Meta -public import Ix.IxVM.KernelTypes -public import Ix.IxVM.Kernel.Subst -public import Ix.IxVM.Kernel.Levels -public import Ix.IxVM.Kernel.Klimbs -public import Ix.IxVM.Kernel.NatPrim -public import Ix.IxVM.Kernel.Whnf -public import Ix.IxVM.Kernel.InferOnly -public import Ix.IxVM.Ingress - -public section - -namespace IxVM - -/-! ## Def-Eq - -`k_is_def_eq(rc, a, b, types) → 1 iff a ≡ b`. Decided by a ladder of tiers, -cheapest first, because the expensive tiers are the ones that unfold -definitions and can blow up: - -pointer equality → memo lookup on a context-trimmed, pointer-ordered key -→ app congruence on a shared Const head (no unfolding) → string-literal -expansion → no-delta whnf (`whnf_nd`) plus `quick_def_eq` → proof -irrelevance → unit-like types → structure eta → Nat offset comparison → -lazy delta, unfolding the higher-ranked side first → full structural -compare. - -Tier order is load-bearing rather than a matter of taste; where a tier's -position matters for correctness and not just cost, the reason is -recorded at that tier. --/ - -def defEq := ⟦ - -- Level list equality (semantic, uses level normalization). - fn level_list_eq(a: List‹KLevel›, b: List‹KLevel›) -> G { - match load(a) { - ListNode.Nil => - match load(b) { - ListNode.Nil => 1, - _ => 0, - }, - ListNode.Cons(x, xs) => - match load(b) { - ListNode.Nil => 0, - ListNode.Cons(y, ys) => - match level_equal(x, y) { - 0 => 0, - _ => level_list_eq(xs, ys), - }, - }, - } - } - - -- Main entry: def-eq of two KExpr in a shared types context. - -- Context-trimmed memo key (mirror k_is_def_eq / Rust - -- def_eq_ctx_key): key on the suffix of `types` reachable from - -- either side; closed pairs (lbr 0) key to the empty context and - -- share across binder depths. Without the trim, the same pair - -- compared under every distinct binder context memoizes separately — - -- on deep dependent proof towers that is an exponential duplicate- - -- work (and QueryRecord memory) amplifier. - fn k_is_def_eq(rc: RoleCtx, a: KExpr, b: KExpr, types: List‹KExpr›) -> G { - match ptr_val(a) - ptr_val(b) { - 0 => 1, -- ptr-eq: same interned pointer = equal - _ => - let base = lbr_max(expr_lbr(a), expr_lbr(b)); - match base { - 0 => k_is_def_eq_core(rc, a, b, store(ListNode.Nil)), - _ => k_def_eq_rebase(rc, a, b, types, base), - }, - } - } - - -- Rebase an OPEN pair to its minimum loose index before keying. - -- The prefix trim alone cannot canonicalize a pair that references - -- only the OUTERMOST binders of a deep telescope: its lbr spans the - -- whole context, so the trim keeps every inner frame — and each - -- comparison site spells those (unreferenced) inner frames slightly - -- differently, minting a fresh memo key per site. Measured on the - -- mathlib monster: 2.48M distinct (a,b,types) core keys over 15,085 - -- distinct pairs — 164x context multiplicity, the dominant cost. - -- - -- Fix: `g = min(glb(a), glb(b))` frames at the inner end are loose in - -- NEITHER side, so lowering both sides by `g` and dropping those - -- frames is a bijection on derivations (context strengthening by - -- unreferenced frames — the same argument as the base=0 → Nil arm, - -- generalized). Def-eq returns a bit, so nothing needs lifting back. - -- Depth-shifted copies of the same tower also lower to the SAME - -- hash-consed pair, merging pairs across binder depths, not just - -- contexts. Kept frames only ever reference deeper (outward) frames, - -- all of which are kept. - fn k_def_eq_rebase(rc: RoleCtx, a: KExpr, b: KExpr, types: List‹KExpr›, - base: G) -> G { - -- Unconditional: a depth threshold (only rebase past base > 8) was - -- measured and rejected — it recovered only a third of the overhead - -- on binder-heavy Init proofs (+6.4% -> +4.2% on Array.append_assoc) - -- for no gain on the mathlib constant (its full closure was flat, - -- 8.71e11 vs 8.74e11): not worth a tuning constant. - let g = lbr_min(lbr_min(expr_glb(a, 0), expr_glb(b, 0)), - list_length(types)); - match g { - 0 => k_is_def_eq_core(rc, a, b, ctx_trim(types, base)), - _ => - k_is_def_eq_core(rc, expr_lower(a, g, 0), expr_lower(b, g, 0), - ctx_trim(list_drop(types, g), base - g)), - } - } - - -- Def-eq is symmetric (every tier treats the sides symmetrically or - -- tries both directions), so canonicalize the pair by pointer order - -- (mirror k_is_def_eq_core): (a, b) and (b, a) share one ordered - -- memo row, and the recursion below issues instantiation traffic - -- with a canonical orientation. - fn k_is_def_eq_core(rc: RoleCtx, a: KExpr, b: KExpr, types: List‹KExpr›) -> G { - match u32_less_than(ptr_val(a), ptr_val(b)) { - 1 => k_is_def_eq_ordered(rc, a, b, types), - _ => k_is_def_eq_ordered(rc, b, a, types), - } - } - - fn k_is_def_eq_ordered(rc: RoleCtx, a: KExpr, b: KExpr, types: List‹KExpr›) -> G { - -- Pre-WHNF lazy-delta app congruence. - -- When both sides share Const head + same lvl args + arity, - -- recurse on arg lists without unfolding — avoids expensive - -- delta on cases where args recursively def-eq. - match try_def_eq_app(rc, a, b, types) { - 1 => 1, - _ => k_is_def_eq_slow(rc, a, b, types), - } - } - - -- App-congruence PRE-WHNF: if both sides collect_spine to - -- (Const(addr), args) with same addr + same level args + same arity, - -- recurse on args pairwise. Sound: if all args def-eq, whole exprs - -- def-eq without unfolding the const. - fn try_def_eq_app(rc: RoleCtx, a: KExpr, b: KExpr, types: List‹KExpr›) -> G { - match collect_spine(a) { - (ah, aa) => - match collect_spine(b) { - (bh, bb) => - match load(ah) { - KExprNode.Const(a_addr, al) => - match load(bh) { - KExprNode.Const(b_addr, bl) => - match ptr_val(a_addr) - ptr_val(b_addr) { - 0 => - match level_list_eq(al, bl) { - 0 => 0, - _ => - match list_length(aa) - list_length(bb) { - 0 => de_args(rc, aa, bb, types), - _ => 0, - }, - }, - _ => 0, - }, - _ => 0, - }, - _ => 0, - }, - }, - } - } - - fn de_args(rc: RoleCtx, aa: List‹KExpr›, bb: List‹KExpr›, types: List‹KExpr›) -> G { - match load(aa) { - ListNode.Nil => - match load(bb) { - ListNode.Nil => 1, - _ => 0, - }, - ListNode.Cons(a, ar) => - match load(bb) { - ListNode.Nil => 0, - ListNode.Cons(b, br) => - match k_is_def_eq(rc, a, b, types) { - 0 => 0, - _ => de_args(rc, ar, br, types), - }, - }, - } - } - - -- Nat.zero recognition for offset-aware def_eq. - fn is_nat_zero(rc: RoleCtx, e: KExpr) -> G { - match load(e) { - KExprNode.Lit(lit) => - match lit { - KLiteral.Nat(limbs) => klimbs_is_zero(limbs), - _ => 0, - }, - KExprNode.Const(caddr, _) => role_is(rc, caddr, @role_nat_zero()), - _ => 0, - } - } - - -- Decompose a whnf'd Nat into (matched, base, offset). Recognizes: - -- Lit n -> (1, Lit 0, n) - -- Nat.succ e -> base/offset of e, offset+1 - -- Nat.add e (Lit m) -> base/offset of e, offset+m - -- Mirror nat_offset_of. - fn nat_offset_of(rc: RoleCtx, e: KExpr) -> (G, KExpr, KLimbs) { - match load(e) { - KExprNode.Lit(lit) => - match lit { - KLiteral.Nat(n) => (1, mk_nat_lit(store(ListNode.Nil)), n), - _ => (0, e, store(ListNode.Nil)), - }, - KExprNode.App(f, a) => - match load(f) { - KExprNode.Const(caddr, _) => - match role_is(rc, caddr, @role_nat_succ()) { - 1 => - match nat_offset_of(rc, a) { - (_, base, o) => (1, base, klimbs_succ(o)), - }, - _ => (0, e, store(ListNode.Nil)), - }, - KExprNode.App(g, x) => - match load(g) { - KExprNode.Const(caddr, _) => - match role_is(rc, caddr, @role_nat_add()) { - 1 => - match load(a) { - KExprNode.Lit(alit) => - match alit { - KLiteral.Nat(m) => - match nat_offset_of(rc, x) { - (1, base, o) => (1, base, klimbs_add(o, m)), - _ => (1, x, m), - }, - _ => (0, e, store(ListNode.Nil)), - }, - _ => (0, e, store(ListNode.Nil)), - }, - _ => (0, e, store(ListNode.Nil)), - }, - _ => (0, e, store(ListNode.Nil)), - }, - _ => (0, e, store(ListNode.Nil)), - }, - _ => (0, e, store(ListNode.Nil)), - } - } - - -- Offset-aware Nat def_eq. Returns (matched, eq). Sound because - -- `+k` is injective — equal offsets reduces the compare to base ≟ base. - -- Collapses `succ^k(x) ≟ succ^k(x)` from O(k) unary steps to O(1). - fn try_def_eq_nat(rc: RoleCtx, a: KExpr, b: KExpr, types: List‹KExpr›) -> (G, G) { - let za = is_nat_zero(rc, a); - let zb = is_nat_zero(rc, b); - match za * zb { - 1 => (1, 1), - _ => - match nat_offset_of(rc, a) { - (ma, ba, oa) => - match nat_offset_of(rc, b) { - (mb, bb, ob) => - match ma * mb { - 0 => (0, 0), - _ => - match klimbs_eq(oa, ob) { - 0 => (0, 0), - _ => (1, k_is_def_eq(rc, ba, bb, types)), - }, - }, - }, - }, - } - } - - -- Slow path: whnf both sides, structural compare, then proof-irrel - -- fallback. On both structural + proof-irrel misses, delta-unfold on - -- mismatched Const heads is done inside k_is_def_eq_struct via - -- try_lazy_delta_app. - -- Tier 1d (mirror DefEq.lean:85-97 / Rust quick_def_eq + - -- whnf_no_delta_for_def_eq): no-delta whnf both sides; many pairs - -- settle by ptr-eq, safe structural compare, or app-congruence on - -- the nd forms — without ever full-delta-unfolding large Defn - -- bodies. Only on fall-through do we pay Tier 2's full whnf. - -- Tier 1c (mirror DefEq.lean:78-84 / Rust def_eq.rs:295-304 - -- try_string_lit_expansion): if exactly one side is Lit(Str), expand - -- it to `String.ofList [Char.ofNat c, ...]` ctor form so both sides - -- reduce in lockstep through delta + iota instead of the literal - -- staying opaque while the other side delta-cascades. - fn try_string_lit_pair(rc: RoleCtx, a: KExpr, b: KExpr, types: List‹KExpr›) -> G { - match try_string_lit_one(rc, a, b, types) { - 1 => 1, - _ => try_string_lit_one(rc, b, a, types), - } - } - - fn try_string_lit_one(rc: RoleCtx, t: KExpr, s: KExpr, types: List‹KExpr›) -> G { - match load(t) { - KExprNode.Lit(lit) => - match lit { - KLiteral.Str(bs) => - k_is_def_eq(rc, str_lit_delta_step(rc, str_lit_to_ctor(rc, bs), types), - s, types), - _ => 0, - }, - _ => 0, - } - } - - fn k_is_def_eq_slow(rc: RoleCtx, a: KExpr, b: KExpr, types: List‹KExpr›) -> G { - match @try_string_lit_pair(rc, a, b, types) { - 1 => 1, - _ => k_is_def_eq_slow_nd(rc, a, b, types), - } - } - - fn k_is_def_eq_slow_nd(rc: RoleCtx, a: KExpr, b: KExpr, types: List‹KExpr›) -> G { - let a_core = whnf_struct_core(rc, a, types); - let b_core = whnf_struct_core(rc, b, types); - match ptr_val(a_core) - ptr_val(b_core) { - 0 => 1, - _ => - match k_is_def_eq_struct_safe(rc, a_core, b_core, types) { - 1 => 1, - _ => - match try_def_eq_app(rc, a_core, b_core, types) { - 1 => 1, - _ => k_is_def_eq_slow_nd_after_core(rc, a, b, a_core, b_core, types), - }, - }, - } - } - - fn k_is_def_eq_slow_nd_after_core(rc: RoleCtx, orig_a: KExpr, orig_b: KExpr, - a: KExpr, b: KExpr, - types: List‹KExpr›) -> G { - let aw_nd = whnf_nd(rc, a, types); - let bw_nd = whnf_nd(rc, b, types); - match ptr_val(aw_nd) - ptr_val(bw_nd) { - 0 => 1, - _ => - match k_is_def_eq_struct_safe(rc, aw_nd, bw_nd, types) { - 1 => 1, - _ => - match try_def_eq_app(rc, aw_nd, bw_nd, types) { - 1 => 1, - _ => k_is_def_eq_slow2(rc, orig_a, orig_b, aw_nd, bw_nd, types), - }, - }, - } - } - - -- Mirror of Rust `def_eq.rs::quick_def_eq`. - -- Sound on partially-whnf'd (no-delta) inputs because the handled - -- shapes (Sort/Lam/Forall) don't depend on further reduction for - -- their judgment. Returns 1 only when DEFINITELY def-eq; 0 = fall - -- through. - fn k_is_def_eq_struct_safe(rc: RoleCtx, a: KExpr, b: KExpr, types: List‹KExpr›) -> G { - match load(a) { - KExprNode.Srt(la) => - match load(b) { - KExprNode.Srt(lb) => level_equal(la, lb), - _ => 0, - }, - KExprNode.Lam(ty_a, body_a) => - match load(b) { - KExprNode.Lam(ty_b, body_b) => - match k_is_def_eq(rc, ty_a, ty_b, types) { - 1 => - let inner = store(ListNode.Cons(ty_a, types)); - k_is_def_eq(rc, body_a, body_b, inner), - _ => 0, - }, - _ => 0, - }, - KExprNode.Forall(ty_a, body_a) => - match load(b) { - KExprNode.Forall(ty_b, body_b) => - match k_is_def_eq(rc, ty_a, ty_b, types) { - 1 => - let inner = store(ListNode.Cons(ty_a, types)); - k_is_def_eq(rc, body_a, body_b, inner), - _ => 0, - }, - _ => 0, - }, - _ => 0, - } - } - - -- Tier order is load-bearing: proof_irrel comes BEFORE any - -- structural/eta machinery. With Thm heads stuck in whnf, proof-term - -- pairs stay high-level (Lam vs Thm-app etc.); eta-expanding a proof - -- fabricates over-applied proof terms whose infer_only aborts — - -- proof_irrel must get first shot. - -- Takes the no-delta forms slow_nd already computed and NEVER calls - -- full whnf: full WHNF here would delta-unfold stuck open primitives - -- such as `Nat.ble` into their recursive logical models and walk - -- enormous Nat offsets layer by layer (the retired Rust kernel's Tier 4c - -- whnf-core discipline). Delta happens only - -- inside lazy_delta_loop, one definitional step at a time, with the - -- cheap tiers re-consulted between steps; the loop hands back its - -- final forms for the structural fallback tiers. - fn k_is_def_eq_slow2(rc: RoleCtx, orig_a: KExpr, orig_b: KExpr, - aw: KExpr, bw: KExpr, - types: List‹KExpr›) -> G { - match ptr_val(aw) - ptr_val(bw) { - 0 => 1, - _ => - match try_proof_irrel(rc, aw, bw, types) { - 1 => 1, - _ => - match try_unit_like(rc, aw, bw, types) { - 1 => 1, - _ => - match try_eta_struct(rc, aw, bw, types) { - 1 => 1, - _ => - match try_eta_struct(rc, bw, aw, types) { - 1 => 1, - _ => - match try_def_eq_nat(rc, aw, bw, types) { - (1, eq) => eq, - _ => - match lazy_delta_loop(rc, aw, bw, 16, types) { - (1, _, _) => 1, - (_, fa, fb) => slow2_after_delta(rc, orig_a, orig_b, - fa, fb, types), - }, - }, - }, - }, - }, - }, - } - } - - -- Undecided lazy-delta exit. Re-offer the cheap terminal tiers once on - -- the final forms, but do not restart k_is_def_eq_slow2: doing so refreshes - -- the lazy budget whenever WHNF rebuilds a term at a fresh pointer and can - -- turn a bounded projection/constant alternation into an unbounded cycle. - -- If the accelerator cannot prove equality, restore the historical eager - -- path on its original inputs. - fn slow2_after_delta(rc: RoleCtx, orig_a: KExpr, orig_b: KExpr, - fa: KExpr, fb: KExpr, - types: List‹KExpr›) -> G { - match k_is_def_eq_struct_bounded(rc, fa, fb, 8, types) { - (1, _) => 1, - _ => match k_is_def_eq_structure_tree(rc, fa, fb, types) { - 1 => 1, - _ => slow2_eager_fallback(rc, orig_a, orig_b, types), - }, - } - } - - fn try_same_proj_head_app(rc: RoleCtx, a: KExpr, b: KExpr, - types: List‹KExpr›) -> G { - let (ah, aa) = collect_spine(a); - let (bh, ba) = collect_spine(b); - match list_length(aa) { - 0 => 0, - _ => match list_length(aa) - list_length(ba) { - 0 => match load(ah) { - KExprNode.Proj(sa, ia, ea) => match load(bh) { - KExprNode.Proj(sb, ib, eb) => - match address_eq(sa, sb) { - 1 => match ia - ib { - -- Projection congruence also holds for definitionally equal - -- scrutinees, not just identical pointers. Compare these - -- proper subterms before unfolding their large arguments. - 0 => match k_is_def_eq(rc, ea, eb, types) { - 1 => de_args(rc, aa, ba, types), - _ => 0, - }, - _ => 0, - }, - _ => 0, - }, - _ => 0, - }, - _ => 0, - }, - _ => 0, - }, - } - } - - fn k_is_def_eq_structure_tree(rc: RoleCtx, a: KExpr, b: KExpr, - types: List‹KExpr›) -> G { - match k_is_def_eq_struct_bounded(rc, a, b, 8, types) { - (1, _) => 1, - _ => match try_same_proj_head_app(rc, a, b, types) { - 1 => 1, - _ => k_is_def_eq_structure_tree_app(rc, a, b, types), - }, - } - } - - fn k_is_def_eq_structure_tree_app(rc: RoleCtx, a: KExpr, b: KExpr, - types: List‹KExpr›) -> G { - match load(a) { - KExprNode.App(af, ax) => match load(b) { - KExprNode.App(bf, bx) => match k_is_def_eq_structure_tree(rc, af, bf, types) { - 1 => k_is_def_eq_structure_tree(rc, ax, bx, types), - _ => 0, - }, - _ => 0, - }, - _ => 0, - } - } - - -- Structural comparison with one credit shared by the entire tree. The - -- credit permits a single bounded lazy reduction at the first mismatching - -- subtree; recursive function/argument comparisons thread the remainder, - -- so work cannot multiply with application depth or sibling count. - fn k_is_def_eq_struct_bounded(rc: RoleCtx, a: KExpr, b: KExpr, credit: G, - types: List‹KExpr›) -> (G, G) { - match ptr_val(a) - ptr_val(b) { - 0 => (1, credit), - _ => - match load(a) { - KExprNode.BVar(i) => - match load(b) { - KExprNode.BVar(j) => - match i - j { 0 => (1, credit), _ => (0, credit), }, - _ => k_is_def_eq_struct_spend(rc, a, b, credit, types), - }, - KExprNode.Srt(la) => - match load(b) { - KExprNode.Srt(lb) => (level_equal(la, lb), credit), - _ => k_is_def_eq_struct_spend(rc, a, b, credit, types), - }, - KExprNode.Const(addr_a, lvls_a) => - match load(b) { - KExprNode.Const(addr_b, lvls_b) => - match address_eq(addr_a, addr_b) { - 1 => (level_list_eq(lvls_a, lvls_b), credit), - _ => k_is_def_eq_struct_spend(rc, a, b, credit, types), - }, - _ => k_is_def_eq_struct_spend(rc, a, b, credit, types), - }, - KExprNode.App(fa, xa) => - match load(b) { - KExprNode.App(fb, xb) => - match k_is_def_eq_struct_bounded(rc, fa, fb, credit, types) { - (1, rest) => - k_is_def_eq_struct_bounded(rc, xa, xb, rest, types), - (_, rest) => (0, rest), - }, - _ => k_is_def_eq_struct_spend(rc, a, b, credit, types), - }, - KExprNode.Lam(ta, ba) => - match load(b) { - KExprNode.Lam(tb, bb) => - match k_is_def_eq_struct_bounded(rc, ta, tb, credit, types) { - (1, rest) => - let types2 = store(ListNode.Cons(ta, types)); - k_is_def_eq_struct_bounded(rc, ba, bb, rest, types2), - (_, rest) => (0, rest), - }, - _ => k_is_def_eq_struct_spend(rc, a, b, credit, types), - }, - KExprNode.Forall(ta, ba) => - match load(b) { - KExprNode.Forall(tb, bb) => - match k_is_def_eq_struct_bounded(rc, ta, tb, credit, types) { - (1, rest) => - let types2 = store(ListNode.Cons(ta, types)); - k_is_def_eq_struct_bounded(rc, ba, bb, rest, types2), - (_, rest) => (0, rest), - }, - _ => k_is_def_eq_struct_spend(rc, a, b, credit, types), - }, - KExprNode.Lit(la) => - match load(b) { - KExprNode.Lit(lb) => (literal_eq(la, lb), credit), - _ => k_is_def_eq_struct_spend(rc, a, b, credit, types), - }, - KExprNode.Proj(struct_a, fidx_a, ea) => - match load(b) { - KExprNode.Proj(struct_b, fidx_b, eb) => - match address_eq(struct_a, struct_b) { - 1 => - match fidx_a - fidx_b { - 0 => k_is_def_eq_struct_bounded(rc, ea, eb, credit, types), - _ => (0, credit), - }, - _ => k_is_def_eq_struct_spend(rc, a, b, credit, types), - }, - _ => k_is_def_eq_struct_spend(rc, a, b, credit, types), - }, - _ => k_is_def_eq_struct_spend(rc, a, b, credit, types), - }, - } - } - - fn k_is_def_eq_struct_spend(rc: RoleCtx, a: KExpr, b: KExpr, credit: G, - types: List‹KExpr›) -> (G, G) { - match credit { - 0 => (0, 0), - _ => - let rest = credit - 1; - let aw = whnf_nd(rc, a, types); - let bw = whnf_nd(rc, b, types); - match ptr_val(aw) - ptr_val(bw) { - 0 => (1, rest), - _ => - match try_def_eq_nat(rc, aw, bw, types) { - (1, eq) => (eq, rest), - _ => - match lazy_delta_loop(rc, aw, bw, 8, types) { - (1, _, _) => (1, rest), - (_, fa, fb) => - k_is_def_eq_struct_bounded(rc, fa, fb, rest, types), - }, - }, - }, - } - } - - -- Compatibility fallback for pairs the bounded lazy accelerator leaves - -- undecided. Full WHNF is deliberately applied to the original forms, not - -- the partially unfolded lazy state, so existing successful reduction - -- routes remain intact. - fn slow2_eager_fallback(rc: RoleCtx, a: KExpr, b: KExpr, types: List‹KExpr›) -> G { - let aw = whnf(rc, a, types); - let bw = whnf(rc, b, types); - match ptr_val(aw) - ptr_val(bw) { - 0 => 1, - _ => - match try_proof_irrel(rc, aw, bw, types) { - 1 => 1, - _ => - match try_unit_like(rc, aw, bw, types) { - 1 => 1, - _ => - match try_eta_struct(rc, aw, bw, types) { - 1 => 1, - _ => - match try_eta_struct(rc, bw, aw, types) { - 1 => 1, - _ => - match try_def_eq_nat(rc, aw, bw, types) { - (1, eq) => eq, - _ => - match try_eta_swap(rc, aw, bw, types) { - 1 => 1, - _ => k_is_def_eq_struct(rc, aw, bw, types), - }, - }, - }, - }, - }, - }, - } - } - - -- Struct-eta: if `s` is a fully-applied ctor of a single-ctor - -- 0-indices inductive (struct-like) and `t` is any expr, - -- accept when `Proj(induct, i, t) ≡ s_args[nparams + i]` for every - -- field. - fn try_eta_struct(rc: RoleCtx, t: KExpr, s: KExpr, types: List‹KExpr›) -> G { - match collect_spine(s) { - (s_head, s_args) => - match load(s_head) { - KExprNode.Const(ctor_addr, _) => - let ci = load(get_ci(ctor_addr)); - match ci { - KConstantInfo.Ctor(_, _, ind_block_addr, ind_idx, _, nparams, nfields, _) => - match list_length(s_args) - (nparams + nfields) { - 0 => - let ind_ci = load(get_ci_iprj(ind_block_addr, ind_idx)); - match ind_ci { - KConstantInfo.Induct(_, _, _, nindices, nctors, _, _, _) => - let shape_ok = eq_zero(nindices) * eq_zero(nctors - 1); - match shape_ok { - 0 => 0, - _ => - let struct_addr = compute_iprj_addr(ind_block_addr, ind_idx); - -- Eta holds for structure-LIKE inductives only, which - -- Lean defines as non-recursive on top of the shape - -- test above (`isStructureLike` requires - -- `isRec := false`). Firing on a recursive one-ctor - -- inductive accepts pairs Lean's kernel rejects. The - -- whnf-side struct-eta iota gates on the same - -- predicate. - match struct_is_rec(struct_addr) { - 1 => 0, - _ => - -- The two sides must have def-eq TYPES. - -- Without this the rule degenerates: for - -- ANY `t` of ANY type it would compare - -- `t` against `S.mk … (Proj S i t) …`, - -- and `compare_struct_fields` builds - -- exactly those projections, so the - -- pointer fast path matches them and the - -- pair is accepted. Those projections are - -- synthesized inside def-eq and never - -- inferred, so `k_infer_proj`'s own - -- head-address gate never sees them. - -- The types must be def-eq, as in - -- lean4lean's `tryEtaStructCore`. - let t_ty = k_infer_only(rc, t, types); - let s_ty = k_infer_only(rc, s, types); - match k_is_def_eq(rc, t_ty, s_ty, types) { - 0 => 0, - _ => - compare_struct_fields(rc, struct_addr, nparams, - nfields, t, s_args, 0, types), - }, - }, - }, - _ => 0, - }, - _ => 0, - }, - _ => 0, - }, - _ => 0, - }, - } - } - - fn compare_struct_fields(rc: RoleCtx, struct_addr: Addr, nparams: G, nfields: G, - t: KExpr, s_args: List‹KExpr›, i: G, - types: List‹KExpr›) -> G { - match nfields - i { - 0 => 1, - _ => - let proj_expr = store(KExprNode.Proj(struct_addr, i, t)); - let s_field = list_lookup(s_args, nparams + i); - match k_is_def_eq(rc, proj_expr, s_field, types) { - 0 => 0, - _ => compare_struct_fields(rc, struct_addr, nparams, nfields, t, - s_args, i + 1, types), - }, - } - } - - -- Synthesize the parent inductive's IPrj wrapper Addr for use as - -- the struct_addr in Proj nodes. Same recipe as Ingress' - -- projection_addr but specialized to Indc (no members lookup — - -- direct Ixon IPrj Constant + blake3). - fn compute_iprj_addr(block_addr: Addr, idx: G) -> Addr { - -- Range-check the index rather than truncating it: an unchecked - -- low-byte pack collides the synthesized wrapper addrs of members - -- 0 and 256. - let idx_u64 = idx_to_u64(idx); - let info = ConstantInfo.IPrj(InductiveProj.Mk(idx_u64, block_addr)); - let proj_c = Constant.Mk(info, - store(ListNode.Nil), - store(ListNode.Nil), - store(ListNode.Nil)); - let bytes = put_constant(proj_c, store(ListNode.Nil)); - bytes_to_addr(bytes) - } - - -- If exactly one side is a Lam, eta-expand the non-Lam side and retry. - fn try_eta_swap(rc: RoleCtx, a: KExpr, b: KExpr, types: List‹KExpr›) -> G { - match load(a) { - KExprNode.Lam(ta, ba) => - match load(b) { - KExprNode.Lam(_, _) => 0, - _ => try_eta_expand(rc, ta, ba, b, types), - }, - _ => - match load(b) { - KExprNode.Lam(tb, bb) => try_eta_expand(rc, tb, bb, a, types), - _ => 0, - }, - } - } - - -- Mirror try_unit_like (Kernel/DefEq.lean:211) / Rust - -- def_eq.rs:858-905 try_unit_like_eq: if `a`'s type whnfs to - -- `Const(I, _) args` for a single-ctor zero-field inductive - -- (PUnit, True, Unit-like structures), any two inhabitants are - -- definitionally equal — provided `b`'s type is def-eq to `a`'s. - -- Fires all over brecOn/below machinery (below-package PUnit slots). - fn try_unit_like(rc: RoleCtx, a: KExpr, b: KExpr, types: List‹KExpr›) -> G { - let ta = k_infer_only(rc, a, types); - let ta_w = whnf(rc, ta, types); - match is_unit_like_type(ta_w) { - 0 => 0, - _ => - let tb = k_infer_only(rc, b, types); - k_is_def_eq(rc, ta, tb, types), - } - } - - -- 1 iff ty is `Const(I, _) args` for a 1-ctor 0-field NON-INDEXED - -- inductive. - -- - -- The index count is part of the reference's test (`def_eq.rs:912`, - -- `if indices != 0 || ctors.len() != 1`) and of lean4lean's - -- (`numIndices := 0`); it was dropped here, which made `Eq α a b` and - -- every other 1-ctor 0-field indexed family read as unit-like. - fn is_unit_like_type(ty: KExpr) -> G { - match collect_spine(ty) { - (head, _) => - match load(head) { - KExprNode.Const(addr, _) => - let ci = load(get_ci(addr)); - match ci { - KConstantInfo.Induct(_, _, _, n_indices, num_ctors, _, block, idx) => - -- Nested rather than summed: these are field elements, so - -- `n_indices + (num_ctors - 1)` is zero not only at (0, 1) - -- but also at (1, 0), where `num_ctors - 1` wraps to p-1. - match n_indices { - 0 => - match num_ctors - 1 { - 0 => - let cci = load(get_ci_cprj(block, idx, 0)); - match cci { - KConstantInfo.Ctor(_, _, _, _, _, _, nfields, _) => - match nfields { - 0 => 1, - _ => 0, - }, - _ => 0, - }, - _ => 0, - }, - _ => 0, - }, - _ => 0, - }, - _ => 0, - }, - } - } - - -- Proof irrelevance: if `a`'s type is a Prop, - -- and `b`'s type is def-eq to `a`'s type, then a ≡ b as proof-terms. - -- Uses k_infer_only to avoid the def_eq ↔ check cycle. - fn try_proof_irrel(rc: RoleCtx, a: KExpr, b: KExpr, types: List‹KExpr›) -> G { - let a_ty = k_infer_only(rc, a, types); - match is_prop_type(rc, a_ty, types) { - 0 => 0, - _ => - let b_ty = k_infer_only(rc, b, types); - k_is_def_eq(rc, a_ty, b_ty, types), - } - } - - -- `λ ty_a. body_a` vs non-Lam `b` → compare `body_a` against - -- `App(lift(b, 1, 0), BVar 0)` under the extended context. - -- - -- `b`'s OWN domain decides whether this is legal, so infer it: all - -- three references build the wrapper lambda out of `b`'s inferred - -- binder type, not out of `ty_a`, and the ensuing Lam/Lam comparison - -- is what checks the two domains agree. Rust `try_eta_expansion` - -- (`def_eq.rs:1179-1211`) infers `s`, whnfs to `All`, and takes that - -- `ty`; `Ix/Tc` `tryEtaExpansion` (`DefEq.lean:946-951`) does the same - -- via `inferOnlyCall`; lean4lean `tryEtaExpansionCore` - -- (`TypeChecker.lean:507-511`) is `let .forallE name ty _ bi ← whnf - -- (← inferType s)`. - -- - -- Reusing `ty_a` and never looking at `b` accepted - -- `(λ x : A. f x) ≡ f` for any `f`, whatever its domain. Comparing the - -- domains here is equivalent to the references' route through Lam/Lam, - -- which compares the domains and then descends under the FIRST - -- lambda's — hence `ty_a` for the inner context below. - -- - -- `k_infer_only` to avoid the def-eq ↔ check cycle, as - -- `try_proof_irrel` does. A non-`Forall` inferred type means eta does - -- not apply and the ladder falls through to the structural compare, - -- matching the references' `return false`. - fn try_eta_expand(rc: RoleCtx, ty_a: KExpr, body_a: KExpr, b: KExpr, - types: List‹KExpr›) -> G { - let b_ty = k_infer_only(rc, b, types); - let b_ty_w = whnf(rc, b_ty, types); - match load(b_ty_w) { - KExprNode.Forall(dom_b, _) => - match k_is_def_eq(rc, ty_a, dom_b, types) { - 0 => 0, - _ => - let b_lifted = expr_lift(b, 1, 0); - let bvar0 = store(KExprNode.BVar(0)); - let b_app = store(KExprNode.App(b_lifted, bvar0)); - let inner = store(ListNode.Cons(ty_a, types)); - k_is_def_eq(rc, body_a, b_app, inner), - }, - _ => 0, - } - } - - -- 1 iff `whnf(rc, infer_only(ty))` is a `Sort` whose level is SEMANTICALLY - -- zero (i.e. `Prop`). - -- - -- SEMANTIC on purpose — `level_equal`, matching `is_inductive_prop` - -- (`Infer.lean:260`) and all three references: Rust gates both struct- - -- eta (`whnf.rs:1884`) and proof irrelevance (`def_eq.rs:878`) on - -- `KUniv::is_semantic_zero`, `Ix/Tc` on `isSemanticZero` - -- (`Whnf.lean:1139`, `DefEq.lean:817`), and lean4lean's `isProp` on - -- `Level.isAlwaysZero` (`TypeChecker.lean:230`), all of which normalize. - -- - -- A structural `KLevelNode.Zero` test is UNSOUND here: `convert_univ` - -- (`Convert.lean:87`) is a raw conversion, so a prover can author - -- `Sort (max 0 0)` / `Sort (imax 1 0)` — semantically zero, structurally - -- not — and `whnf` is the identity on `Srt`. Reading such a Prop as - -- "not Prop" fires `try_struct_eta_iota` on a proof, the reduction - -- lean4#14613 fixed (see `Tests/Ix/IxVM/Exploits.lean` - -- `struct-eta-fires-on-semantic-prop`). - fn is_prop_type(rc: RoleCtx, ty: KExpr, types: List‹KExpr›) -> G { - let sort = k_infer_only(rc, ty, types); - let sort_w = whnf(rc, sort, types); - match load(sort_w) { - KExprNode.Srt(l) => level_equal(l, store(KLevelNode.Zero)), - _ => 0, - } - } - - -- Structural arm-by-arm equality on WHNF'd exprs. The Lit arm - -- continues into `k_is_def_eq_struct_go` directly (see there); - -- keep the two-name split so that call can bypass nothing but the - -- entry itself. - fn k_is_def_eq_struct(rc: RoleCtx, a: KExpr, b: KExpr, types: List‹KExpr›) -> G { - k_is_def_eq_struct_go(rc, a, b, types) - } - - fn k_is_def_eq_struct_go(rc: RoleCtx, a: KExpr, b: KExpr, types: List‹KExpr›) -> G { - match load(a) { - KExprNode.BVar(i) => - match load(b) { - KExprNode.BVar(j) => match i - j { 0 => 1, _ => 0, }, - _ => 0, - }, - KExprNode.Srt(la) => - match load(b) { - KExprNode.Srt(lb) => level_equal(la, lb), - _ => 0, - }, - KExprNode.Const(addr_a, lvls_a) => - match load(b) { - KExprNode.Const(addr_b, lvls_b) => - -- Content equality decides which constant this is; pointer - -- inequality would not (see the `Addr` note in Core.lean). - match address_eq(addr_a, addr_b) { - 1 => level_list_eq(lvls_a, lvls_b), - _ => try_lazy_delta_app(rc, a, b, types), - }, - _ => try_lazy_delta_app(rc, a, b, types), - }, - KExprNode.App(fa, xa) => - match load(b) { - KExprNode.App(fb, xb) => - match k_is_def_eq(rc, fa, fb, types) { - 0 => try_lazy_delta_app(rc, a, b, types), - _ => - match k_is_def_eq(rc, xa, xb, types) { - 0 => try_lazy_delta_app(rc, a, b, types), - _ => 1, - }, - }, - _ => try_lazy_delta_app(rc, a, b, types), - }, - KExprNode.Lam(ta, ba) => - match load(b) { - KExprNode.Lam(tb, bb) => - match k_is_def_eq(rc, ta, tb, types) { - 0 => 0, - _ => - let types2 = store(ListNode.Cons(ta, types)); - k_is_def_eq(rc, ba, bb, types2), - }, - _ => try_eta_expand(rc, ta, ba, b, types), - }, - KExprNode.Forall(ta, ba) => - match load(b) { - KExprNode.Forall(tb, bb) => - match k_is_def_eq(rc, ta, tb, types) { - 0 => 0, - _ => - let types2 = store(ListNode.Cons(ta, types)); - k_is_def_eq(rc, ba, bb, types2), - }, - _ => 0, - }, - KExprNode.Let(_, _, _) => - -- whnf should have zeta-reduced Let already. - 0, - KExprNode.Lit(la) => - match load(b) { - -- Compare the VALUES, not just the shapes: two Lits are def-eq - -- only when their payloads are equal. Answering 1 for any pair of - -- Lits would accept `Lit 5 ≟ Lit 6` and certify `Nat.add 2 3 = 6`. - -- The earlier def_eq_nat tier handles offset-shaped Nat pairs, but - -- nothing guarantees it fired before this point, and it never - -- covers Str. - KExprNode.Lit(lb) => literal_eq(la, lb), - _ => - -- Lit vs non-Lit: convert `a` to ctor form (Nat.zero / - -- App(Nat.succ, Lit(k-1))) and retry STRUCTURALLY. Handles - -- the `Lit(Nat 0) ≡ Const(Nat.zero)` case that comes up - -- when one side reduces via nat_lit_to_ctor and the other - -- doesn't ( residual — Nat.pred_le). - -- MUST NOT re-enter full k_is_def_eq: its whnf collapses - -- the succ-wrapped form straight back to the same interned - -- Lit (nat prim), producing an infinite expand/collapse - -- cycle whenever `b` is a stuck non-ctor app. - let a_ctor = nat_lit_to_ctor_or_self(rc, a); - match ptr_val(a_ctor) - ptr_val(a) { - 0 => 0, -- didn't change, avoid infinite loop - _ => k_is_def_eq_struct_go(rc, a_ctor, b, types), - }, - }, - KExprNode.Proj(struct_a, fidx_a, ea) => - match load(b) { - KExprNode.Proj(struct_b, fidx_b, eb) => - -- Content equality decides; pointer inequality would not. - match address_eq(struct_a, struct_b) { - 1 => - match fidx_a - fidx_b { - 0 => k_is_def_eq(rc, ea, eb, types), - _ => 0, - }, - _ => 0, - }, - _ => 0, - }, - } - } - - -- Multi-step lazy-delta reduction loop (mirror Tier 4). - -- Both sides possibly Const-Defn/Thm-headed. Unfold one side per - -- iteration (prefer higher-rank/hint), re-normalize with whnf_nd - -- ONLY — full whnf here would delta-unfold stuck open primitives - -- (Nat.ble etc.) into their recursive logical models and walk - -- 2^32-scale offsets — then retry def_eq. Fuel-bounded to prevent - -- runaway on cyclic unfolds. Returns (1, _, _) when decided equal; - -- (0, fa, fb) hands the final forms to the caller's structural - -- fallback tiers. - fn lazy_delta_loop(rc: RoleCtx, a: KExpr, b: KExpr, fuel: G, - types: List‹KExpr›) -> (G, KExpr, KExpr) { - match fuel { - 0 => (0, a, b), - _ => - match ptr_val(a) - ptr_val(b) { - 0 => (1, a, b), - _ => - -- In-loop offset-aware Nat tier: compact `base + K` forms are - -- decided (either way) without any unfolding. - match try_def_eq_nat(rc, a, b, types) { - (1, eq) => (eq, a, b), - _ => - let (a_addr, a_is_const) = head_addr(a); - let (b_addr, b_is_const) = head_addr(b); - match a_is_const { - 1 => - match b_is_const { - 1 => - -- App congruence already ran before entering lazy delta. - -- Retrying it here recursively calls full k_is_def_eq for - -- every argument and resets the lazy budget. Continue the - -- current bounded reduction instead. - lazy_delta_step_const_const(rc, a_addr, b_addr, a, b, - fuel, types), - _ => lazy_delta_a_const_b_proj(rc, a_addr, a, b, fuel, types), - }, - _ => - match b_is_const { - 1 => lazy_delta_b_const_a_proj(rc, b_addr, a, b, fuel, types), - _ => - -- Neither Const-headed at spine head. Try unfold_proj_app - -- on both — if either side is Proj-headed with a - -- delta-eligible inner Const, unfold inner and rewrap. - lazy_delta_both_proj(rc, a, b, fuel, types), - }, - }, - }, - }, - } - } - - -- Reducibility rank for lazy-delta unfold ordering (mirror - -- delta_rank): Defn carries the ch 3 hint; Thm and everything else - -- rank 0. - fn delta_rank(ci: KConstantInfo) -> G { - match ci { - KConstantInfo.Defn(_, _, _, _, hint) => hint, - _ => 0, - } - } - - -- Both heads Const, congruence missed. Rank-ordered unfold (mirror - -- lazy_delta_step_const_const / Rust lazy_delta_reduction_step): - -- unfold the higher-rank side so both sides meet at the same - -- definitional height; equal ranks unfold both. - fn lazy_delta_step_const_const(rc: RoleCtx, a_addr: Addr, b_addr: Addr, a: KExpr, - b: KExpr, fuel: G, - types: List‹KExpr›) -> (G, KExpr, KExpr) { - let a_ci = load(get_ci(a_addr)); - let b_ci = load(get_ci(b_addr)); - let ae = is_defn_or_thm(a_ci); - let be = is_defn_or_thm(b_ci); - match ae { - 0 => - match be { - 0 => (0, a, b), - _ => unfold_b_and_loop(rc, a, b, fuel, types), - }, - _ => - match be { - 0 => unfold_a_and_loop(rc, a, b, fuel, types), - _ => - let ar = delta_rank(a_ci); - let br = delta_rank(b_ci); - match u32_less_than(br, ar) { - 1 => unfold_a_and_loop(rc, a, b, fuel, types), - _ => - match u32_less_than(ar, br) { - 1 => unfold_b_and_loop(rc, a, b, fuel, types), - _ => unfold_both_and_loop(rc, a, b, fuel, types), - }, - }, - }, - } - } - - fn unfold_a_and_loop(rc: RoleCtx, a: KExpr, b: KExpr, fuel: G, - types: List‹KExpr›) -> (G, KExpr, KExpr) { - match delta_unfold(a) { - (1, a2) => - let aw = whnf_nd(rc, a2, types); - lazy_delta_loop(rc, aw, b, fuel - 1, types), - _ => (0, a, b), - } - } - - fn unfold_b_and_loop(rc: RoleCtx, a: KExpr, b: KExpr, fuel: G, - types: List‹KExpr›) -> (G, KExpr, KExpr) { - match delta_unfold(b) { - (1, b2) => - let bw = whnf_nd(rc, b2, types); - lazy_delta_loop(rc, a, bw, fuel - 1, types), - _ => (0, a, b), - } - } - - fn unfold_both_and_loop(rc: RoleCtx, a: KExpr, b: KExpr, fuel: G, - types: List‹KExpr›) -> (G, KExpr, KExpr) { - match delta_unfold(a) { - (1, a2) => - match delta_unfold(b) { - (1, b2) => - let aw = whnf_nd(rc, a2, types); - let bw = whnf_nd(rc, b2, types); - lazy_delta_loop(rc, aw, bw, fuel - 1, types), - _ => (0, a, b), - }, - _ => (0, a, b), - } - } - - -- a is Const-headed spine; b is Proj-headed. Mirror - -- lazy_delta_step_a_const: try unfold_proj_app on b, else unfold a. - fn lazy_delta_a_const_b_proj(rc: RoleCtx, a_addr: Addr, a: KExpr, b: KExpr, fuel: G, - types: List‹KExpr›) -> (G, KExpr, KExpr) { - -- Proj-side unfolding is tried FIRST, independent of whether the - -- Const side is delta-eligible: under the lazy discipline a - -- Proj-headed side (e.g. `instLEUInt32.1`) can face a plain - -- non-Defn head (a ctor-built function constant) and still be one - -- proj-unfold away from it. - match try_unfold_proj_app(rc, b, types) { - (1, b2) => - lazy_delta_loop(rc, a, b2, fuel - 1, types), - _ => - let a_ci = load(get_ci(a_addr)); - match is_defn_or_thm(a_ci) { - 0 => (0, a, b), - _ => - let au = try_unfold_head(rc, a, a_ci, types); - match au { - (1, aw) => - lazy_delta_loop(rc, aw, b, fuel - 1, types), - _ => (0, a, b), - }, - }, - } - } - - -- Symmetric. - fn lazy_delta_b_const_a_proj(rc: RoleCtx, b_addr: Addr, a: KExpr, b: KExpr, fuel: G, - types: List‹KExpr›) -> (G, KExpr, KExpr) { - match try_unfold_proj_app(rc, a, types) { - (1, a2) => - lazy_delta_loop(rc, a2, b, fuel - 1, types), - _ => - let b_ci = load(get_ci(b_addr)); - match is_defn_or_thm(b_ci) { - 0 => (0, a, b), - _ => - let bu = try_unfold_head(rc, b, b_ci, types); - match bu { - (1, bw) => - lazy_delta_loop(rc, a, bw, fuel - 1, types), - _ => (0, a, b), - }, - }, - } - } - - -- Both are Proj-headed spines. Try unfold_proj_app on either or both. - -- Projection/head reductions continue this bounded loop directly. - -- Re-entering `k_is_def_eq` here would reset the lazy budget on every - -- step; alternating projection and constant spellings can then recurse - -- forever (Batteries' Char.toUpper proof cycles around Decidable.casesOn). - -- The loop itself rechecks ptr/Nat equality, and its caller applies the - -- remaining structural/eta/full-WHNF tiers to the final forms. - fn lazy_delta_both_proj(rc: RoleCtx, a: KExpr, b: KExpr, fuel: G, - types: List‹KExpr›) -> (G, KExpr, KExpr) { - let ua = try_unfold_proj_app(rc, a, types); - let ub = try_unfold_proj_app(rc, b, types); - match ua { - (1, a2) => - match ub { - (1, b2) => - lazy_delta_loop(rc, a2, b2, fuel - 1, types), - _ => - lazy_delta_loop(rc, a2, b, fuel - 1, types), - }, - _ => - match ub { - (1, b2) => - lazy_delta_loop(rc, a, b2, fuel - 1, types), - _ => (0, a, b), - }, - } - } - - fn is_defn_or_thm(ci: KConstantInfo) -> G { - match ci { - KConstantInfo.Defn(_, _, _, _, _) => 1, - KConstantInfo.Thm(_, _, _) => 1, - _ => 0, - } - } - - -- First reduce the whole projection-headed spine without delta, so cheap - -- projection/iota and primitive rules fire before we expose dictionary - -- implementations. Aiur WHNF may rebuild an unchanged stuck expression at - -- a fresh pointer (unlike Rust's hash-consed expressions), so real progress - -- means that the projection head disappeared. If it remains stuck, retain - -- the old single delta step on its scrutinee: signed-integer proofs need to - -- expose a ctor-built instance before the projection can fire. Continuing - -- the caller's bounded lazy loop prevents either path from resetting fuel. - fn try_unfold_proj_app(rc: RoleCtx, e: KExpr, types: List‹KExpr›) -> (G, KExpr) { - match collect_spine(e) { - (head, spine) => - match load(head) { - KExprNode.Proj(struct_addr, fidx, inner) => - let reduced = whnf_nd(rc, e, types); - match collect_spine(reduced) { - (reduced_head, _) => - match load(reduced_head) { - KExprNode.Proj(_, _, _) => - match delta_unfold(inner) { - (1, inner2) => - let new_head = store(KExprNode.Proj(struct_addr, fidx, inner2)); - (1, apply_spine(new_head, spine)), - _ => (0, e), - }, - _ => (1, reduced), - }, - }, - _ => (0, e), - }, - } - } - - -- Delta-unfold Const-headed e: replace Const with its Defn/Thm body, - -- keeping the spine. Returns (0, e) if head isn't Const-Defn/Thm. - fn delta_unfold(e: KExpr) -> (G, KExpr) { - match collect_spine(e) { - (head, spine) => - match load(head) { - KExprNode.Const(addr, lvls) => - let ci = load(get_ci(addr)); - match ci { - KConstantInfo.Defn(_, _, value, _, _) => - let body = expr_inst_levels(value, lvls); - (1, apply_spine(body, spine)), - KConstantInfo.Thm(_, _, value) => - let body = expr_inst_levels(value, lvls); - (1, apply_spine(body, spine)), - _ => (0, e), - }, - _ => (0, e), - }, - } - } - - -- Lazy delta: unfold Defn on one side (prefer whichever has body), - -- retry. On stuck (neither is Defn), give up. - fn try_lazy_delta_app(rc: RoleCtx, a: KExpr, b: KExpr, types: List‹KExpr›) -> G { - let (a_addr, a_is_const) = head_addr(a); - let (b_addr, b_is_const) = head_addr(b); - match a_is_const { - 0 => 0, - _ => - match b_is_const { - 0 => 0, - _ => - let a_ci = load(get_ci(a_addr)); - let b_ci = load(get_ci(b_addr)); - let a_unfolded = try_unfold_head(rc, a, a_ci, types); - let b_unfolded = try_unfold_head(rc, b, b_ci, types); - match a_unfolded { - (1, aw) => - match b_unfolded { - (1, bw) => k_is_def_eq(rc, aw, bw, types), - _ => k_is_def_eq(rc, aw, b, types), - }, - (0, _) => - match b_unfolded { - (1, bw) => k_is_def_eq(rc, a, bw, types), - _ => 0, - }, - }, - }, - } - } - - -- Extract Const head's addr from a spine expr. Returns (addr, is_const). - fn head_addr(e: KExpr) -> (Addr, G) { - match collect_spine(e) { - (head, _) => - match load(head) { - KExprNode.Const(addr, _) => (addr, 1), - _ => (store([0u8; 32]), 0), - }, - } - } - - -- If ci is a Defn or Thm, delta-unfold its body, reapply the spine, - -- and whnf. Thm must go through delta_unfold explicitly — whnf - -- keeps Thm heads stuck (mirror), so `whnf(rc, e)` alone would - -- return `e` unchanged for Thm and stall the lazy-delta loop. - fn try_unfold_head(rc: RoleCtx, e: KExpr, ci: KConstantInfo, - types: List‹KExpr›) -> (G, KExpr) { - match ci { - -- Defn must ALSO go through the explicit delta_unfold, not - -- `whnf(rc, e)`: offset-stuck compact forms (`Nat.add/div/mod base - -- lit`, whnf verdict 2) are whnf-FIXPOINTS, so "unfold via whnf" - -- returns the same pointer and the lazy-delta ladder recurses on - -- identical args forever. Explicit body substitution guarantees - -- progress (mirror delta_unfold). - KConstantInfo.Defn(_, _, _, _, _) => - match delta_unfold(e) { - (1, e2) => (1, whnf_nd(rc, e2, types)), - _ => (0, e), - }, - KConstantInfo.Thm(_, _, _) => - match delta_unfold(e) { - (1, e2) => (1, whnf_nd(rc, e2, types)), - _ => (0, e), - }, - _ => (0, e), - } - } -⟧ - -end IxVM - -end diff --git a/Ix/IxVM/Kernel/Eval.lean b/Ix/IxVM/Kernel/Eval.lean deleted file mode 100644 index f413f53e3..000000000 --- a/Ix/IxVM/Kernel/Eval.lean +++ /dev/null @@ -1,83 +0,0 @@ -module -public import Ix.Aiur.Meta -public import Ix.IxVM.Kernel.Whnf - -public section - -namespace IxVM - -/-- Recursive normalization using the kernel's existing WHNF rules. Output -definitions use ordinary constant transport and retain the input's type. -/ -def eval := ⟦ - fn eval_nf(rc: RoleCtx, e: KExpr, types: List‹KExpr›) -> KExpr { - let w = whnf(rc, e, types); - match load(w) { - KExprNode.Lam(t, b) => - let nt = eval_nf(rc, t, types); - store(KExprNode.Lam(nt, eval_nf(rc, b, store(ListNode.Cons(t, types))))), - KExprNode.Forall(t, b) => - let nt = eval_nf(rc, t, types); - store(KExprNode.Forall(nt, eval_nf(rc, b, store(ListNode.Cons(t, types))))), - _ => eval_nf_spine(rc, w, types), - } - } - - -- Preserve the head WHNF selected for the whole application. Unfolding - -- an isolated primitive head would destroy compact stuck Nat forms. - fn eval_nf_spine(rc: RoleCtx, e: KExpr, types: List‹KExpr›) -> KExpr { - match load(e) { - KExprNode.App(f, a) => - store(KExprNode.App(eval_nf_spine(rc, f, types), eval_nf(rc, a, types))), - KExprNode.Proj(addr, i, e) => - store(KExprNode.Proj(addr, i, eval_nf(rc, e, types))), - _ => e, - } - } - - fn eval_body(input: Addr) -> (G, KExpr, KExpr) { - let ci = load(get_ci(input)); - assert_eq!(is_unsafe_ci(ci), 0, "Eval: unsafe or partial input"); - match ci { - KConstantInfo.Defn(n, ty, value, _, _) => (n, ty, value), - KConstantInfo.Thm(n, ty, value) => (n, ty, value), - KConstantInfo.Opaque(n, ty, value, _) => (n, ty, value), - } - } - - fn eval_output(output: Addr, nlvls: G, input_type: KExpr) -> KExpr { - let Constant.Mk(info, sharing, refs, univs) = load_verified_constant(output); - let ConstantInfo.Defn(defn) = info; - let Definition.Mk(kind, safety, lvls, ty, value) = defn; - assert_eq!(kind, DefKind.Definition, "Eval: output must be a definition"); - assert_eq!(safety, DefinitionSafety.Safe, "Eval: unsafe or partial output"); - assert_eq!(flatten_u64(lvls), nlvls, "Eval: universe parameter count mismatch"); - let no_recur = store(ListNode.Nil); - let output_type = convert_expr(ty, sharing, refs, no_recur, univs); - assert_eq!(output_type, input_type, "Eval: output type does not match input"); - convert_expr(value, sharing, refs, no_recur, univs) - } - - fn run_eval(rc: RoleCtx, input: Addr, output: Addr, asm: Option‹Addr›) { - -- Assumptions waive dependency checks, never the subject check. - run_check(rc, input); - match asm { - Option.None => run_check_transitive(rc, input), - Option.Some(r) => - let asm_set = addr_set_build(load_assumption_tree(r), RBTreeMap.Nil); - assert_eq!(addr_set_member(input, asm_set), 0, "Eval: input is an assumption"); - env_walk(rc, input, RBTreeMap.Nil, asm_set, 0), - }; - let (nlvls, ty, body) = eval_body(input); - let expected = eval_output(output, nlvls, ty); - let result = eval_nf(rc, body, store(ListNode.Nil)); - -- Hash-consed pointers compare decoded, erased terms structurally. - -- Neither the proposed result nor its type is normalized here. Output - -- typing follows from the checked input and type-preserving reduction. - assert_eq!(result, expected, "Eval: result does not match output"); - () - } -⟧ - -end IxVM - -end diff --git a/Ix/IxVM/Kernel/Infer.lean b/Ix/IxVM/Kernel/Infer.lean deleted file mode 100644 index 3d6dc9bce..000000000 --- a/Ix/IxVM/Kernel/Infer.lean +++ /dev/null @@ -1,810 +0,0 @@ -module -public import Ix.Aiur.Meta -public import Ix.IxVM.KernelTypes -public import Ix.IxVM.Kernel.Subst -public import Ix.IxVM.Kernel.Levels -public import Ix.IxVM.Kernel.Whnf -public import Ix.IxVM.Kernel.DefEq -public import Ix.IxVM.Ingress - -public section - -namespace IxVM - -/-! ## Infer — type synthesis with checking - -Handles every KExpr node: Sort, BVar, Const, App, Lam, Forall, Let, Lit, -and Proj. Unlike `InferOnly`, this performs the inner validations as it -goes — argument types are checked against domains, binder types are -ensured to be sorts, and projections are checked against their structure. --/ - -def infer := ⟦ - -- Context lookup with lift - -- types[i] is the type of the i-th binder from the innermost. When we - -- look up BVar(i), we get types[i] but it was assembled at depth d-i-1 - -- (counting from outermost). The current context is at depth d, so we - -- need to lift the result by (i + 1). - fn types_lookup(types: List‹KExpr›, i: G) -> KExpr { - let ty = list_lookup(types, i); - expr_lift(ty, i + 1, 0) - } - - -- Mirror each KConstantInfo carries num_lvls as its first G field. - fn const_num_lvls(ci: KConstantInfo) -> G { - match ci { - KConstantInfo.Axiom(n, _, _) => n, - KConstantInfo.Defn(n, _, _, _, _) => n, - KConstantInfo.Thm(n, _, _) => n, - KConstantInfo.Opaque(n, _, _, _) => n, - KConstantInfo.Quot(n, _, _) => n, - KConstantInfo.Induct(n, _, _, _, _, _, _, _) => n, - KConstantInfo.Ctor(n, _, _, _, _, _, _, _) => n, - KConstantInfo.Rec(n, _, _, _, _, _, _, _, _, _, _) => n, - } - } - - -- Helpers: extract const declared type, Nat/Str literal types. - fn const_type_of(ci: KConstantInfo) -> KExpr { - match ci { - KConstantInfo.Axiom(_, ty, _) => ty, - KConstantInfo.Defn(_, ty, _, _, _) => ty, - KConstantInfo.Thm(_, ty, _) => ty, - KConstantInfo.Opaque(_, ty, _, _) => ty, - KConstantInfo.Quot(_, ty, _) => ty, - KConstantInfo.Induct(_, ty, _, _, _, _, _, _) => ty, - KConstantInfo.Ctor(_, ty, _, _, _, _, _, _) => ty, - KConstantInfo.Rec(_, ty, _, _, _, _, _, _, _, _, _) => ty, - } - } - - -- k_infer - -- Per-variant dispatch. - -- Lvls placed at outermost; level-params instantiation handled where - -- the constant's declared type is fetched. - -- Context-trimmed memo wrapper (mirror Rust `infer_key`): key inference on - -- the suffix of `types` reachable from `e`'s loose-bvar range, so a closed - -- subterm (`lbr == 0`) shares its inferred type across every binder depth. - fn k_infer(rc: RoleCtx, e: KExpr, types: List‹KExpr›) -> KExpr { - let base = expr_lbr(e); - match base { - 0 => k_infer_core(rc, e, store(ListNode.Nil)), - _ => k_infer_rebase(rc, e, types, base), - } - } - - -- Rebase an OPEN subject to its minimum loose index before keying - -- (the infer twin of k_def_eq_rebase; see that comment for the full - -- argument). The suffix trim alone cannot canonicalize a subject - -- that references only the OUTERMOST binders of a deep telescope: - -- its lbr spans the whole context, the trim keeps every inner frame, - -- and each inference site spells those (unreferenced) inner frames - -- slightly differently — minting a fresh k_infer_core key per site. - -- On `Simps.addProjections._unsafe_rec` (mathlib shard 211) this - -- multiplicity produced 15.7M distinct k_check calls in 150s with no - -- convergence. Frames below `g = min loose index` are loose in - -- neither the subject nor the kept frames (which only ever reference - -- deeper frames), so lowering by g and dropping those frames is a - -- bijection on typing derivations (context strengthening by - -- unreferenced frames). Unlike def-eq, which returns a bit, - -- inference returns a TYPE valid in the context it ran in — so the - -- result is lifted back by g. - fn k_infer_rebase(rc: RoleCtx, e: KExpr, types: List‹KExpr›, base: G) -> KExpr { - let g = lbr_min(expr_glb(e, 0), list_length(types)); - match g { - 0 => k_infer_core(rc, e, ctx_trim(types, base)), - _ => - let t = k_infer_core(rc, expr_lower(e, g, 0), - ctx_trim(list_drop(types, g), base - g)); - expr_lift(t, g, 0), - } - } - - fn k_infer_core(rc: RoleCtx, e: KExpr, types: List‹KExpr›) -> KExpr { - match load(e) { - KExprNode.BVar(i) => @types_lookup(types, i), - - KExprNode.Srt(l) => - store(KExprNode.Srt(level_reduce(store(KLevelNode.Succ(l))))), - - KExprNode.Const(addr, lvls) => - let ci = load(get_ci(addr)); - let expected = const_num_lvls(ci); - let given = list_length(lvls); - assert_eq!(given, expected, - "Const applied to wrong number of universe levels"); - let ty = const_type_of(ci); - expr_inst_levels(ty, lvls), - - KExprNode.App(_, _) => - match collect_spine(e) { - (head, args) => - let head_ty = k_infer(rc, head, types); - k_infer_app_spine_loop(rc, head_ty, args, store(ListNode.Nil), types), - }, - - KExprNode.Lam(ty, body) => - k_ensure_sort(rc, ty, types); - let types2 = store(ListNode.Cons(ty, types)); - let body_ty = k_infer(rc, body, types2); - store(KExprNode.Forall(ty, body_ty)), - - KExprNode.Forall(ty, body) => - let u1 = k_ensure_sort(rc, ty, types); - let types2 = store(ListNode.Cons(ty, types)); - let u2 = k_ensure_sort(rc, body, types2); - store(KExprNode.Srt(level_imax(u1, u2))), - - KExprNode.Let(ty, val, body) => k_infer_let_start(rc, ty, val, body, types), - - -- handlers: - KExprNode.Lit(lit) => k_infer_lit(rc, lit), - KExprNode.Proj(struct_addr, fidx, e1) => - k_infer_proj(rc, struct_addr, fidx, e1, types), - } - } - - -- Let-local inference environment. Values are closures in the environment - -- before their declaration; checked types are concrete at the saved depth. - -- Lambda locals keep their introduction depth, so extending the environment - -- does not eagerly lift every earlier value. No new expression kind is - -- introduced, and whnf/def-eq still consume ordinary concrete expressions. - enum InferLetEnvNode { - Id(List‹KExpr›, G), - Local(KExpr, G, InferLetEnv), - Let(KExpr, KExpr, InferLetEnv, G) - } - type InferLetEnv = &InferLetEnvNode - - fn k_infer_let_start(rc: RoleCtx, ty: KExpr, val: KExpr, body: KExpr, - types: List‹KExpr›) -> KExpr { - k_ensure_sort(rc, ty, types); - k_check(rc, val, ty, types); - let depth = list_length(types); - let env = store(InferLetEnvNode.Id(types, depth)); - k_infer_let_env(rc, body, store(InferLetEnvNode.Let(ty, val, env, depth)), types, depth) - } - - fn infer_let_var_type(env: InferLetEnv, i: G, - types: List‹KExpr›, depth: G) -> KExpr { - let (ty, created) = infer_let_lookup_type(env, i); - expr_lift(ty, depth - created, 0) - } - - fn infer_let_lookup_type(env: InferLetEnv, i: G) -> (KExpr, G) { - match load(env) { - InferLetEnvNode.Id(types, origin) => (types_lookup(types, i), origin), - InferLetEnvNode.Local(ty, introduced, outer) => match i { - 0 => (ty, introduced - 1), - _ => infer_let_lookup_type(outer, i - 1), - }, - InferLetEnvNode.Let(ty, _, outer, created) => match i { - 0 => (ty, created), - _ => infer_let_lookup_type(outer, i - 1), - }, - } - } - - fn infer_let_var_value(env: InferLetEnv, i: G, depth: G) -> KExpr { - let (value, created) = infer_let_lookup_value(env, i); - expr_lift(value, depth - created, 0) - } - - fn infer_let_lookup_value(env: InferLetEnv, i: G) -> (KExpr, G) { - match load(env) { - InferLetEnvNode.Id(_, origin) => (store(KExprNode.BVar(i)), origin), - InferLetEnvNode.Local(_, introduced, outer) => match i { - 0 => (store(KExprNode.BVar(0)), introduced), - _ => infer_let_lookup_value(outer, i - 1), - }, - InferLetEnvNode.Let(_, value, outer, created) => match i { - 0 => (infer_let_materialize(value, outer, created, 0), created), - _ => infer_let_lookup_value(outer, i - 1), - }, - } - } - - fn infer_let_materialize(e: KExpr, env: InferLetEnv, depth: G, cutoff: G) -> KExpr { - match memo_u32_less_than(cutoff, expr_lbr(e)) { - 0 => e, - _ => match load(e) { - KExprNode.BVar(i) => match memo_u32_less_than(i, cutoff) { - 1 => e, - _ => expr_lift(@infer_let_var_value(env, i - cutoff, depth), cutoff, 0), - }, - KExprNode.App(f, a) => store(KExprNode.App( - infer_let_materialize(f, env, depth, cutoff), infer_let_materialize(a, env, depth, cutoff))), - KExprNode.Lam(ty, body) => store(KExprNode.Lam( - infer_let_materialize(ty, env, depth, cutoff), infer_let_materialize(body, env, depth, cutoff + 1))), - KExprNode.Forall(ty, body) => store(KExprNode.Forall( - infer_let_materialize(ty, env, depth, cutoff), infer_let_materialize(body, env, depth, cutoff + 1))), - KExprNode.Let(ty, val, body) => store(KExprNode.Let( - infer_let_materialize(ty, env, depth, cutoff), infer_let_materialize(val, env, depth, cutoff), - infer_let_materialize(body, env, depth, cutoff + 1))), - KExprNode.Proj(addr, i, val) => store(KExprNode.Proj(addr, i, - infer_let_materialize(val, env, depth, cutoff))), - _ => e, - }, - } - } - - fn k_infer_let_env(rc: RoleCtx, e: KExpr, env: InferLetEnv, types: List‹KExpr›, depth: G) -> KExpr { - match expr_lbr(e) { - 0 => k_infer(rc, e, store(ListNode.Nil)), - _ => match load(e) { - -- Leave introductions delayed. Lowering a pure-let prefix can copy - -- nested continuations without shrinking the real type context, so - -- normalize applications only when a real local can be removed. - KExprNode.App(_, _) => match infer_let_local_cutoff(env) { - 0 => k_infer_let_env_core(rc, e, env, types, depth), - cutoff => match has_bvar_in_range(e, 0, cutoff) { - 1 => k_infer_let_env_core(rc, e, env, types, depth), - 0 => k_infer_let_env_rebase(rc, e, env, types, depth), - }, - }, - _ => k_infer_let_env_core(rc, e, env, types, depth), - }, - } - } - - -- One plus the first Local's raw index, or zero if there is no Local. - -- A real context slot can be removed exactly when the subject references - -- none of this prefix. The short-circuiting occurrence test above avoids - -- a full minimum-index walk when strengthening is impossible. - fn infer_let_local_cutoff(env: InferLetEnv) -> G { - match load(env) { - InferLetEnvNode.Id(_, _) => 0, - InferLetEnvNode.Local(_, _, _) => 1, - InferLetEnvNode.Let(_, _, outer, _) => match infer_let_local_cutoff(outer) { - 0 => 0, - n => n + 1, - }, - } - } - - fn k_infer_let_env_rebase(rc: RoleCtx, e: KExpr, env: InferLetEnv, - types: List‹KExpr›, depth: G) -> KExpr { - let (outer, removed, locals) = infer_let_drop_unused(env, expr_glb(e, 0)); - let subject = expr_lower(e, removed, 0); - let context = list_drop(types, locals); - let ty = k_infer_let_env_core(rc, subject, outer, context, depth - locals); - expr_lift(ty, locals, 0) - } - - -- Forget leading bindings below the subject's minimum loose index. - -- Their domains/values were already checked on entry to the environment. - -- Every retained closure was created before those bindings, so cannot - -- depend on them. Only Local nodes occupy real context slots: drop that - -- many type entries, and lift the inferred type back by that count. - -- Stop at Id and retain delayed application inference even there: rebasing - -- changes only the context, not the application-substitution algorithm. - fn infer_let_drop_unused(env: InferLetEnv, count: G) -> (InferLetEnv, G, G) { - match count { - 0 => (env, 0, 0), - _ => match load(env) { - InferLetEnvNode.Let(_, _, outer, _) => - let (rest, removed, locals) = infer_let_drop_unused(outer, count - 1); - (rest, removed + 1, locals), - InferLetEnvNode.Local(_, _, outer) => - let (rest, removed, locals) = infer_let_drop_unused(outer, count - 1); - (rest, removed + 1, locals + 1), - _ => (env, 0, 0), - }, - } - } - - fn k_infer_let_env_core(rc: RoleCtx, e: KExpr, env: InferLetEnv, - types: List‹KExpr›, depth: G) -> KExpr { - match load(e) { - KExprNode.BVar(i) => @infer_let_var_type(env, i, types, depth), - KExprNode.Lam(ty, body) => - let dom = infer_let_materialize(ty, env, depth, 0); - k_ensure_sort(rc, dom, types); - let inner_types = store(ListNode.Cons(dom, types)); - let inner_env = store(InferLetEnvNode.Local(dom, depth + 1, env)); - let body_ty = k_infer_let_env(rc, body, inner_env, inner_types, depth + 1); - store(KExprNode.Forall(dom, body_ty)), - KExprNode.Forall(ty, body) => - let dom = infer_let_materialize(ty, env, depth, 0); - let u1 = k_ensure_sort(rc, dom, types); - let inner_types = store(ListNode.Cons(dom, types)); - let inner_env = store(InferLetEnvNode.Local(dom, depth + 1, env)); - let bt = k_infer_let_env(rc, body, inner_env, inner_types, depth + 1); - let KExprNode.Srt(u2) = load(whnf(rc, bt, inner_types)); - store(KExprNode.Srt(level_imax(u1, u2))), - KExprNode.Let(ty, val, body) => - let dom = infer_let_materialize(ty, env, depth, 0); - k_ensure_sort(rc, dom, types); - let val_ty = k_infer_let_env(rc, val, env, types, depth); - assert_eq!(k_is_def_eq(rc, val_ty, dom, types), 1, "delayed let value type mismatch"); - k_infer_let_env(rc, body, store(InferLetEnvNode.Let(dom, val, env, depth)), types, depth), - KExprNode.App(f, a) => - let ft = k_infer_let_env(rc, f, env, types, depth); - let KExprNode.Forall(dom, cod) = load(whnf(rc, ft, types)); - let arg_ty = k_infer_let_env(rc, a, env, types, depth); - assert_eq!(k_is_def_eq(rc, arg_ty, dom, types), 1, "delayed application type mismatch"); - match has_bvar_in_range(cod, 0, 1) { - 0 => expr_lower(cod, 1, 1), - _ => expr_inst1(cod, infer_let_materialize(a, env, depth, 0), 0), - }, - _ => k_infer(rc, infer_let_materialize(e, env, depth, 0), types), - } - } - - -- Walk the head's Forall telescope arg-by-arg. `subs_rev` accumulates - -- substituted args INNERMOST-FIRST (so substs[0] = latest arg = the one - -- bound at BVar(0)). At each step we substitute prior args into the - -- current Forall's `dom` (one expr_inst_many walk of the ORIGINAL dom, - -- not a residual) for the check, then descend into `cod` with the - -- extended subs. At spine end, one final expr_inst_many on the remaining - -- `cod` yields the result type. - -- When `load(t)` isn't a Forall, materialise via whnf on the concretised - -- t (= prior subs applied to original t). Post-whnf dom/cod are in the - -- OUTER context, so we restart the descent with subs_rev = [a]. - fn k_infer_app_spine_loop(rc: RoleCtx, t: KExpr, args: List‹KExpr›, - subs_rev: List‹KExpr›, - types: List‹KExpr›) -> KExpr { - match load(args) { - ListNode.Nil => - match list_length(subs_rev) { - 0 => t, - _ => expr_inst_many(t, subs_rev, 0), - }, - ListNode.Cons(a, rest) => - match load(t) { - KExprNode.Forall(dom, cod) => - let dom_subst = match list_length(subs_rev) { - 0 => dom, - _ => expr_inst_many(dom, subs_rev, 0), - }; - k_check(rc, a, dom_subst, types); - k_infer_app_spine_loop(rc, cod, rest, - store(ListNode.Cons(a, subs_rev)), types), - _ => - let t_concrete = match list_length(subs_rev) { - 0 => t, - _ => expr_inst_many(t, subs_rev, 0), - }; - let t_w = whnf(rc, t_concrete, types); - match load(t_w) { - KExprNode.Forall(dom, cod) => - k_check(rc, a, dom, types); - k_infer_app_spine_loop(rc, cod, rest, - store(ListNode.Cons(a, store(ListNode.Nil))), types), - }, - }, - } - } - - -- A literal's type is the binding's `Nat` or `String`: typing a `Nat` - -- literal needs the `Nat` role, a string literal the `String` role, which - -- the claim then depends on (`role_used_implicitly`). - fn k_infer_lit(rc: RoleCtx, lit: KLiteral) -> KExpr { - match lit { - KLiteral.Nat(_) => store(KExprNode.Const(role_addr(rc, @role_nat()), store(ListNode.Nil))), - KLiteral.Str(_) => - store(KExprNode.Const(role_used_implicitly(rc, @role_string()), store(ListNode.Nil))), - } - } - - -- Peel `n_params` Foralls, substituting each with args[i]. - fn peel_params_subst(ty: KExpr, args: List‹KExpr›, n_params: G) -> KExpr { - match n_params { - 0 => ty, - _ => - match load(ty) { - KExprNode.Forall(_, body) => - match load(args) { - ListNode.Cons(arg, rest) => - let body_substed = expr_inst1(body, arg, 0); - peel_params_subst(body_substed, rest, n_params - 1), - }, - }, - } - } - - -- Walk ctor type's field foralls, substituting Proj(struct_addr, i, val) - -- for each preceding field. At target field, return its dom. - -- 1 iff the inductive's type, after peeling params+indices, lands in - -- Sort 0. Mirror is_inductive_prop (Infer.lean:493). - fn is_inductive_prop(rc: RoleCtx, ind_ty: KExpr, lvls: List‹KLevel›, n_skip: G, - types: List‹KExpr›) -> G { - let ind_ty_inst = expr_inst_levels(ind_ty, lvls); - let result = peel_n_alls_whnf(rc, ind_ty_inst, n_skip, types); - -- No fallthrough arm: an inductive whose type does not peel to a - -- Sort is malformed, and both references that implement this ERROR - -- rather than answering — Rust `inductive_app_is_prop` - -- (`infer.rs:485-517`, "projection: expected forall in inductive - -- type", then `ensure_sort`) and `Ix/Tc` `inductiveAppIsProp` - -- (`Infer.lean:296-324`), with the same message. lean4lean has no - -- counterpart: `inferProj` infers the type of the APPLIED struct - -- expression instead and never peels the declaration's telescope, so - -- it offers no data point either way. - -- - -- Answering 0 would be a false NEGATIVE — "not a Prop" — the unsafe - -- direction, since it silently disables the Prop gates in - -- `k_infer_proj` and would let a projection pull data out of a - -- proof. `check_const`'s `check_inductive_shape` rejects such an - -- inductive first, so this is defence in depth. - match load(result) { - KExprNode.Srt(l) => level_equal(l, store(KLevelNode.Zero)), - } - } - - -- Peel `n` Foralls, calling `whnf` on each step. Returns the whnf'd body. - fn peel_n_alls_whnf(rc: RoleCtx, e: KExpr, n: G, types: List‹KExpr›) -> KExpr { - match n { - 0 => whnf(rc, e, types), - _ => - let ew = whnf(rc, e, types); - match load(ew) { - KExprNode.Forall(dom, body) => - let t2 = store(ListNode.Cons(dom, types)); - peel_n_alls_whnf(rc, body, n - 1, t2), - _ => ew, - }, - } - } - - -- Prop-structure projection gates (mirror Infer.lean:507 / :457). - -- Projecting out of a Prop-valued structure would extract data from a - -- proof, breaking proof irrelevance. Two rules, both only for - -- `is_prop` structures: - -- * the TARGET field must itself be a Prop (Sort 0); - -- * any data field skipped on the way must not be depended on by - -- the remaining telescope (no loose bvars in the body). - fn check_prop_field_if_prop(rc: RoleCtx, is_prop: G, dom: KExpr, - types: List‹KExpr›) { - match is_prop { - 0 => (), - _ => - let lvl = k_ensure_sort(rc, dom, types); - assert_eq!(level_equal(lvl, store(KLevelNode.Zero)), 1, - "projection on a Prop structure: field is not a Prop"); - (), - } - } - - -- Dependent-data-field guard. - -- For Prop structures: a preceding data field (sort != 0) whose body - -- has any loose bvar (`body.lbr() > 0`) makes projection past it unsound. - -- Matches Rust's `body.lbr() > 0` check exactly. - fn check_no_dep_data_field_if_prop(rc: RoleCtx, is_prop: G, dom: KExpr, body: KExpr, - types: List‹KExpr›) { - match is_prop { - 0 => (), - _ => - let lvl = k_ensure_sort(rc, dom, types); - match level_equal(lvl, store(KLevelNode.Zero)) { - 1 => (), - _ => - -- data field: the rest of the telescope must not depend on it. - assert_eq!(expr_lbr(body), 0, - "projection on a Prop structure: later fields depend on a data field"); - (), - }, - } - } - - -- Ctor-field walk loop. - -- For each preceding field i < target_field, substitute body[Var(0) - -- := Proj(struct_idx, i, val)] before recursing. At i == target_field, - -- return the field's domain type. - -- For Prop structures (`is_prop == 1`), enforce two soundness checks: - -- (a) preceding data field whose body depends on BVar(0) is forbidden - -- (no projection past dependent data fields, mirror Rust line 433-444); - -- (b) projected (target) field must itself be in Prop (mirror Rust line 418-427). - fn peel_field_loop(rc: RoleCtx, ty: KExpr, target: G, current: G, - struct_addr: Addr, val: KExpr, is_prop: G, - types: List‹KExpr›) -> KExpr { - match load(ty) { - KExprNode.Forall(dom, body) => - match target - current { - 0 => - check_prop_field_if_prop(rc, is_prop, dom, types); - dom, - _ => - check_no_dep_data_field_if_prop(rc, is_prop, dom, body, types); - let proj_expr = store(KExprNode.Proj(struct_addr, current, val)); - let body_substed = expr_inst1(body, proj_expr, 0); - peel_field_loop(rc, body_substed, target, current + 1, - struct_addr, val, is_prop, types), - }, - } - } - - -- Cold-extracted Proj arm: the widest arm of `k_infer_core` by far - -- (~10 call sites) on a rare node kind. - fn k_infer_proj(rc: RoleCtx, struct_addr: Addr, fidx: G, e1: KExpr, - types: List‹KExpr›) -> KExpr { - let val_ty = k_infer(rc, e1, types); - let wty = whnf(rc, val_ty, types); - match collect_spine(wty) { - (head, args) => - match load(head) { - KExprNode.Const(head_addr, lvls) => - assert_eq!(ptr_val(head_addr), ptr_val(struct_addr), - "projection's structure type differs from the value's head"); - let ind_ci = load(get_ci(head_addr)); - match ind_ci { - KConstantInfo.Induct(_, ind_ty, n_params, n_indices, num_ctors, _, - block_addr, ind_idx) => - -- A projection is only meaningful on a structure: exactly one - -- constructor, so field `fidx` names an unambiguous field and - -- cidx=0 is the only choice. Without this a Proj on a - -- multi-ctor inductive silently reads ctor 0's field types - -- off a value built by a different ctor. - assert_eq!(num_ctors, 1, - "projection on an inductive with more than one constructor"); - let ctor_ci = load(get_ci_cprj(block_addr, ind_idx, 0)); - match ctor_ci { - KConstantInfo.Ctor(_, ctor_ty, _, _, _, _, _, _) => - let ctor_ty_inst = expr_inst_levels(ctor_ty, lvls); - let after_params = peel_params_subst(ctor_ty_inst, args, n_params); - -- Prop-valued structures get the projection gates. - let is_prop = is_inductive_prop(rc, ind_ty, lvls, - n_params + n_indices, types); - peel_field_loop(rc, after_params, fidx, 0, - struct_addr, e1, is_prop, types), - }, - }, - }, - } - } - - -- No fallthrough arm: a value whose type does not whnf to a Sort is not - -- a type, and the references error there too (Rust `ensure_sort`, - -- `tc.rs:648-658`, returns `TcError::TypeExpected`; `Ix/Tc` - -- `ensureSortWhnf` throws `.typeExpected`). Do not give it a default - -- level — that would make an ill-typed `Lam` usable as a type. - fn k_ensure_sort(rc: RoleCtx, e: KExpr, types: List‹KExpr›) -> KLevel { - let t = k_infer(rc, e, types); - let tw = whnf(rc, t, types); - match load(tw) { - KExprNode.Srt(l) => l, - } - } - - -- Check: infer the expr's type, def-eq against expected. - fn k_check(rc: RoleCtx, e: KExpr, expected: KExpr, types: List‹KExpr›) { - let inferred = k_infer(rc, e, types); - let d = k_is_def_eq(rc, inferred, expected, types); - assert_eq!(d, 1, "inferred type is not def-eq to the expected type"); - } - - -- ============================================================================ - -- Decidable dispatch. - -- - -- The decision procedures are roles (`natDecEq`, `natDecLe`, `natDecLt`), - -- each specified by one equation through `Decidable.decide`: `decide (d x y)` - -- is a certified `Bool` operation of `x y`. On literal arguments the rule - -- evaluates that operation to `v` and returns `isTrue P (of_decide_eq_true P - -- (d a c) rfl)` or `isFalse P (of_decide_eq_false P (d a c) rfl)`. `decide`'s - -- equations give that result the `decide` of `d a c`, and its - -- extensionality makes them equal, so the rule computes an instance of the - -- validated equations whatever shape the binding's `Decidable` has. `P` is - -- built from the specification's type, not inferred. - -- ============================================================================ - - -- Entry point. Whnf calls this on Const-headed apps of family 5, the - -- decision roles. Returns - -- (1, reduced) on success or (0, _) to fall through to Defn unfold. - fn try_dec_dispatch(rc: RoleCtx, head_addr: Addr, op: G, head_lvls: List‹KLevel›, - spine: List‹KExpr›, types: List‹KExpr›) - -> (G, KExpr) { - match u32_less_than(list_length(spine), 2) { - 1 => (0, store(KExprNode.BVar(0))), - _ => - match op { - 1 => dec_rewrite_lt_to_le(rc, spine, types), - 2 => dec_nat(rc, 1, head_addr, head_lvls, spine, types), - 3 => dec_nat(rc, 0, head_addr, head_lvls, spine, types), - 4 => dec_rewrite_int_lt_to_le(rc, spine, types), - 5 => dec_int(rc, 1, head_addr, head_lvls, spine, types), - 6 => dec_int(rc, 0, head_addr, head_lvls, spine, types), - _ => (0, store(KExprNode.BVar(0))), - }, - } - } - - -- decLt n m → decLe (n+1) m, by `natDecLt`'s equation `decLt x y = - -- decLe (succ x) y`: return (1, App(dec_le, succ_n_lit, m_e, ...post)). - -- Whnf re-whnfs the rewritten form, which re-enters dispatch as decLe. - fn dec_rewrite_lt_to_le(rc: RoleCtx, spine: List‹KExpr›, - types: List‹KExpr›) -> (G, KExpr) { - let n_e = list_lookup(spine, 0); - let m_e = list_lookup(spine, 1); - let n_w = whnf(rc, n_e, types); - match try_extract_nat(rc, n_w) { - (0, _) => (0, store(KExprNode.BVar(0))), - (1, n_klimbs) => - let succ_lit = mk_nat_lit(klimbs_succ(n_klimbs)); - let dec_le_head = store(KExprNode.Const( - role_addr(rc, @role_nat_dec_le()), store(ListNode.Nil))); - let app1 = store(KExprNode.App(dec_le_head, succ_lit)); - let app2 = store(KExprNode.App(app1, m_e)); - let post = list_drop(spine, 2); - (1, apply_spine(app2, post)), - } - } - - -- `Nat.decLe n m` (is_le = 1) or `Nat.decEq n m` (is_le = 0) on literals: - -- `decide` of it is `Nat.ble n m` or `Nat.beq n m` (the role's equation), - -- evaluated natively. `P` is `Nat.le n m` or `@Eq Nat n m`. - fn dec_nat(rc: RoleCtx, is_le: G, head_addr: Addr, head_lvls: List‹KLevel›, - spine: List‹KExpr›, types: List‹KExpr›) -> (G, KExpr) { - let n_e = list_lookup(spine, 0); - let m_e = list_lookup(spine, 1); - let n_w = whnf(rc, n_e, types); - let m_w = whnf(rc, m_e, types); - match try_extract_nat(rc, n_w) { - (0, _) => (0, store(KExprNode.BVar(0))), - (1, n_kl) => - match try_extract_nat(rc, m_w) { - (0, _) => (0, store(KExprNode.BVar(0))), - (1, m_kl) => - let verdict = match is_le { - 1 => klimbs_le(n_kl, m_kl), - _ => klimbs_eq(n_kl, m_kl), - }; - let prop = match is_le { - 1 => - let le_c = store(KExprNode.Const(role_used_implicitly(rc, @role_nat_le()), - store(ListNode.Nil))); - store(KExprNode.App(store(KExprNode.App(le_c, n_e)), m_e)), - _ => mk_eq1(rc, store(KExprNode.Const(role_addr(rc, @role_nat()), - store(ListNode.Nil))), n_e, m_e), - }; - let call = store(KExprNode.App(store(KExprNode.App( - store(KExprNode.Const(head_addr, head_lvls)), n_e)), m_e)); - (1, apply_spine(dec_result(rc, verdict, prop, call), list_drop(spine, 2))), - }, - } - } - - -- `Int.decLt a b` → `Int.decLe (a + 1) b`, by `intDecLt`'s equation, with - -- `a + 1` evaluated natively on a literal `a` (`intAdd`'s equations). - -- Whnf re-whnfs the rewritten form, which re-enters dispatch as decLe. - fn dec_rewrite_int_lt_to_le(rc: RoleCtx, spine: List‹KExpr›, - types: List‹KExpr›) -> (G, KExpr) { - let a_e = list_lookup(spine, 0); - let b_e = list_lookup(spine, 1); - let a_w = whnf(rc, a_e, types); - match try_extract_int_prim(rc, a_w) { - (0, _, _) => (0, store(KExprNode.BVar(0))), - (1, sa, na) => - let one = store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], - store(ListNode.Nil))); - let succ_a = int_add_prim(rc, sa, na, 0, one); - let dec_le_head = store(KExprNode.Const( - role_addr(rc, @role_int_dec_le()), store(ListNode.Nil))); - let app2 = store(KExprNode.App(store(KExprNode.App(dec_le_head, succ_a)), b_e)); - (1, apply_spine(app2, list_drop(spine, 2))), - } - } - - -- `Int.decLe a b` (is_le = 1) or `Int.decEq a b` (is_le = 0) on literals. - -- The role's equations give `decide` of it at the four constructor pairs; - -- the rule evaluates the same comparison in sign-magnitude form (`sign` - -- 1 for `negSucc`, whose magnitude is at least 1). `P` is `Int.le a b` or - -- `@Eq Int a b`. - fn dec_int(rc: RoleCtx, is_le: G, head_addr: Addr, head_lvls: List‹KLevel›, - spine: List‹KExpr›, types: List‹KExpr›) -> (G, KExpr) { - let a_e = list_lookup(spine, 0); - let b_e = list_lookup(spine, 1); - let a_w = whnf(rc, a_e, types); - let b_w = whnf(rc, b_e, types); - match try_extract_int_prim(rc, a_w) { - (0, _, _) => (0, store(KExprNode.BVar(0))), - (1, sa, na) => - match try_extract_int_prim(rc, b_w) { - (0, _, _) => (0, store(KExprNode.BVar(0))), - (1, sb, nb) => - let verdict = match is_le { - 1 => int_le_verdict(sa, na, sb, nb), - _ => (1 - (sa - sb) * (sa - sb)) * klimbs_eq(na, nb), - }; - let prop = match is_le { - 1 => - let le_c = store(KExprNode.Const(role_used_implicitly(rc, @role_int_le()), - store(ListNode.Nil))); - store(KExprNode.App(store(KExprNode.App(le_c, a_e)), b_e)), - _ => mk_eq1(rc, store(KExprNode.Const(role_used_implicitly(rc, @role_int()), - store(ListNode.Nil))), a_e, b_e), - }; - let call = store(KExprNode.App(store(KExprNode.App( - store(KExprNode.Const(head_addr, head_lvls)), a_e)), b_e)); - (1, apply_spine(dec_result(rc, verdict, prop, call), list_drop(spine, 2))), - }, - } - } - - -- `a ≤ b` for sign-magnitude integers. - fn int_le_verdict(sa: G, na: KLimbs, sb: G, nb: KLimbs) -> G { - match sa { - 0 => match sb { 0 => klimbs_le(na, nb), _ => 0, }, - _ => match sb { 0 => 1, _ => klimbs_le(nb, na), }, - } - } - - -- `@Eq.{1} ty a b`. - fn mk_eq1(rc: RoleCtx, ty: KExpr, a: KExpr, b: KExpr) -> KExpr { - let one_lvl = store(KLevelNode.Succ(store(KLevelNode.Zero))); - let eq_c = store(KExprNode.Const(role_addr(rc, @role_eq()), - store(ListNode.Cons(one_lvl, store(ListNode.Nil))))); - store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(eq_c, ty)), a)), b)) - } - - -- The value of a decision `call : Decidable prop` whose `decide` is - -- `verdict`: `Decidable.isTrue prop (of_decide_eq_true prop call (Eq.refl - -- true))` or `Decidable.isFalse prop (of_decide_eq_false prop call (Eq.refl - -- false))`. The constants it introduces are checked as the claim's - -- dependencies. - fn dec_result(rc: RoleCtx, verdict: G, prop: KExpr, call: KExpr) -> KExpr { - let one_lvl = store(KLevelNode.Succ(store(KLevelNode.Zero))); - let eq_refl_c = store(KExprNode.Const(role_addr(rc, @role_eq_refl()), - store(ListNode.Cons(one_lvl, store(ListNode.Nil))))); - let bool_c = store(KExprNode.Const(role_addr(rc, @role_bool()), store(ListNode.Nil))); - let refl = store(KExprNode.App(store(KExprNode.App(eq_refl_c, bool_c)), mk_bool(rc, verdict))); - let of_decide = match verdict { - 1 => role_used_implicitly(rc, @role_of_decide_eq_true()), - _ => role_used_implicitly(rc, @role_of_decide_eq_false()), - }; - let ctor = match verdict { - 1 => role_used_implicitly(rc, @role_decidable_is_true()), - _ => role_used_implicitly(rc, @role_decidable_is_false()), - }; - let proof = store(KExprNode.App(store(KExprNode.App(store(KExprNode.App( - store(KExprNode.Const(of_decide, store(ListNode.Nil))), prop)), call)), refl)); - store(KExprNode.App(store(KExprNode.App( - store(KExprNode.Const(ctor, store(ListNode.Nil))), prop)), proof)) - } - - -- String.decEq on two Lit(Str)-whnf'd args, when the bytestreams are equal: - -- the generic decision result for `decide (String.decEq s s) = true`, the - -- role's equation. Unequal bails. Entry point invoked from Whnf's - -- string primitive dispatch when head_addr matches string_dec_eq. - -- - -- head_addr, spine assumed pre-whnf'd (caller runs whnf_spine). - fn try_str_dec_eq(rc: RoleCtx, head_addr: Addr, spine: List‹KExpr›, - types: List‹KExpr›) -> (G, KExpr) { - match u32_less_than(list_length(spine), 2) { - 1 => (0, store(KExprNode.BVar(0))), - _ => - let a0 = list_lookup(spine, 0); - let a1 = list_lookup(spine, 1); - match load(a0) { - KExprNode.Lit(la) => - match la { - KLiteral.Str(sa) => - match load(a1) { - KExprNode.Lit(lb) => - match lb { - KLiteral.Str(sb) => - match bytestream_eq(sa, sb) { - 0 => (0, store(KExprNode.BVar(0))), - _ => - let str_c = store(KExprNode.Const(role_addr(rc, @role_string()), - store(ListNode.Nil))); - let call = store(KExprNode.App(store(KExprNode.App( - store(KExprNode.Const(head_addr, store(ListNode.Nil))), a0)), a1)); - (1, apply_spine(dec_result(rc, 1, mk_eq1(rc, str_c, a0, a1), call), - list_drop(spine, 2))), - }, - _ => (0, store(KExprNode.BVar(0))), - }, - _ => (0, store(KExprNode.BVar(0))), - }, - _ => (0, store(KExprNode.BVar(0))), - }, - _ => (0, store(KExprNode.BVar(0))), - }, - } - } - -⟧ - -end IxVM - -end - diff --git a/Ix/IxVM/Kernel/InferOnly.lean b/Ix/IxVM/Kernel/InferOnly.lean deleted file mode 100644 index 4eb72f1bd..000000000 --- a/Ix/IxVM/Kernel/InferOnly.lean +++ /dev/null @@ -1,230 +0,0 @@ -module -public import Ix.Aiur.Meta -public import Ix.IxVM.KernelTypes -public import Ix.IxVM.Kernel.Subst -public import Ix.IxVM.Kernel.Levels -public import Ix.IxVM.Kernel.Whnf -public import Ix.IxVM.Ingress - -public section - -namespace IxVM - -/-! ## Infer-Only - -Fast type-synthesis pass (`with_infer_only`). - -Type synthesis ONLY. Skips inner validations: App drops -`k_check(rc, a, dom)`, Lam drops `k_ensure_sort(rc, ty)`, Let drops val/ty -checks, Proj drops prop-field checks. - -Called by `try_proof_irrel` inside `k_is_def_eq` — placing it in -its own module breaks the DefEq ↔ Infer cycle. - -Safety: MUST NOT be called on ill-typed terms. Callers hand in -subterms already known well-typed (e.g. one whnf'd side of a running -def-eq comparison). --/ - -def inferOnly := ⟦ - fn io_types_lookup(types: List‹KExpr›, i: G) -> KExpr { - let ty = list_lookup(types, i); - expr_lift(ty, i + 1, 0) - } - - fn io_const_num_lvls(ci: KConstantInfo) -> G { - match ci { - KConstantInfo.Axiom(n, _, _) => n, - KConstantInfo.Defn(n, _, _, _, _) => n, - KConstantInfo.Thm(n, _, _) => n, - KConstantInfo.Opaque(n, _, _, _) => n, - KConstantInfo.Quot(n, _, _) => n, - KConstantInfo.Induct(n, _, _, _, _, _, _, _) => n, - KConstantInfo.Ctor(n, _, _, _, _, _, _, _) => n, - KConstantInfo.Rec(n, _, _, _, _, _, _, _, _, _, _) => n, - } - } - - fn io_const_type_of(ci: KConstantInfo) -> KExpr { - match ci { - KConstantInfo.Axiom(_, ty, _) => ty, - KConstantInfo.Defn(_, ty, _, _, _) => ty, - KConstantInfo.Thm(_, ty, _) => ty, - KConstantInfo.Opaque(_, ty, _, _) => ty, - KConstantInfo.Quot(_, ty, _) => ty, - KConstantInfo.Induct(_, ty, _, _, _, _, _, _) => ty, - KConstantInfo.Ctor(_, ty, _, _, _, _, _, _) => ty, - KConstantInfo.Rec(_, ty, _, _, _, _, _, _, _, _, _) => ty, - } - } - - -- k_infer_only: type-synthesis-only (mirror Rust `with_infer_only`). - -- Skips inner validations: App drops `k_check(rc, a, dom)`; Lam drops - -- `k_ensure_sort(rc, ty)`; Let drops val/ty checks. Distinct Aiur memo from - -- `k_infer` (parity with Rust's separate infer_cache / infer_only_cache). - -- Used at try_proof_irrel / is_prop_type / try_unit_like where only the - -- synthesized type is needed. - -- ## Safety invariant - -- `k_infer_only` is NOT safe to call on an arbitrary term — only on terms - -- already known to be well-typed (i.e., terms that would have passed - -- `k_infer`). The reason: our overall invariant is that evaluation only - -- happens after typechecking. `k_infer_only` evaluates types (e.g. the - -- substitution `B[a/x]` on an `App` arm) WITHOUT first checking that the - -- substituted-in argument `a` has the proper type (the dropped - -- `k_check(rc, a, dom)`). On an untyped or ill-typed term, that substitution - -- can take us out of the well-typed fragment, after which subsequent - -- `whnf` / `def_eq` work is unsound. - -- The current call sites (`try_proof_irrel`, `is_prop_type`, - -- `try_unit_like`) honor this invariant because they hand `k_infer_only` - -- a term obtained by `whnf`-ing a well-typed input. `whnf` of a - -- well-typed term yields a structurally different but still well-typed - -- term, so the no-checks shortcut is sound there even though the result - -- term itself was never the direct subject of `k_infer`. - -- ## Future: shared memo via non-deterministic hint - -- `k_infer_only`'s separate memo (parity with Rust) means an `infer_only` - -- call cannot reuse an existing `k_infer` hit on the same input. A - -- planned improvement: at each `try_proof_irrel` / `try_unit_like` site, - -- the prover supplies a hint `enum Hint { None, KInfer, KInferOnly }`: - -- 1. `None` — term is not unit-like and not a proof; skip both - -- and fall through to deep `def_eq`. - -- 2. `KInfer` — `k_infer`'s memo is a hit on this input; call - -- `k_infer` (cheap, reuses the cached row) and - -- check the result is a proof / unit-like. - -- 3. `KInferOnly` — `k_infer`'s memo would miss; call `k_infer_only` - -- (cheaper than a fresh `k_infer`) and check. - -- Dispatching on the hint with a `match` lets us share `k_infer`'s memo - -- where available and fall back to `k_infer_only` only when the cheaper - -- path won't pay off, instead of unconditionally paying the parallel - -- `infer_only` memo cost. - fn k_infer_only(rc: RoleCtx, e: KExpr, types: List‹KExpr›) -> KExpr { - @k_infer_only_core(rc, e, ctx_trim(types, expr_lbr(e))) - } - - fn k_infer_only_core(rc: RoleCtx, e: KExpr, types: List‹KExpr›) -> KExpr { - match load(e) { - KExprNode.BVar(i) => @io_types_lookup(types, i), - - KExprNode.Srt(l) => - store(KExprNode.Srt(level_reduce(store(KLevelNode.Succ(l))))), - - KExprNode.Const(addr, lvls) => - let ci = load(get_ci(addr)); - let expected = io_const_num_lvls(ci); - assert_eq!(list_length(lvls), expected, - "Const applied to wrong number of universe levels"); - let ty = io_const_type_of(ci); - expr_inst_levels(ty, lvls), - - KExprNode.App(f, a) => - let f_ty = k_infer_only(rc, f, types); - match load(f_ty) { - KExprNode.Forall(_, cod) => expr_inst1(cod, a, 0), - _ => - let f_ty_whnf = whnf(rc, f_ty, types); - match load(f_ty_whnf) { - KExprNode.Forall(_, cod) => expr_inst1(cod, a, 0), - }, - }, - - KExprNode.Lam(ty, body) => - let types2 = store(ListNode.Cons(ty, types)); - let body_ty = k_infer_only(rc, body, types2); - store(KExprNode.Forall(ty, body_ty)), - - KExprNode.Forall(ty, body) => - let u1 = ensure_sort_only(rc, ty, types); - let types2 = store(ListNode.Cons(ty, types)); - let u2 = ensure_sort_only(rc, body, types2); - store(KExprNode.Srt(level_imax(u1, u2))), - - KExprNode.Let(_, val, body) => - let body_substed = expr_inst1(body, val, 0); - k_infer_only(rc, body_substed, types), - - KExprNode.Lit(lit) => - match lit { - KLiteral.Nat(_) => - store(KExprNode.Const(role_addr(rc, @role_nat()), store(ListNode.Nil))), - KLiteral.Str(_) => - store(KExprNode.Const(role_used_implicitly(rc, @role_string()), store(ListNode.Nil))), - }, - - -- Proj arm: minimal, mirrors k_infer_proj without prop checks. - KExprNode.Proj(struct_addr, fidx, e1) => - let val_ty = k_infer_only(rc, e1, types); - let wty = whnf(rc, val_ty, types); - match collect_spine(wty) { - (head, args) => - match load(head) { - KExprNode.Const(head_addr, lvls) => - assert_eq!(ptr_val(head_addr), ptr_val(struct_addr), - "projection's structure type differs from the value's head"); - let ind_ci = load(get_ci(head_addr)); - match ind_ci { - KConstantInfo.Induct(_, _, n_params, _, num_ctors, _, - block_addr, ind_idx) => - -- Structure requirement, as in `k_infer_proj`. Enforced here - -- too: this path skips the inner checks, not the ones that - -- decide which constructor's fields are being read. - assert_eq!(num_ctors, 1, - "projection on an inductive with more than one constructor"); - let ctor_ci = load(get_ci_cprj(block_addr, ind_idx, 0)); - match ctor_ci { - KConstantInfo.Ctor(_, ctor_ty, _, _, _, _, _, _) => - let ctor_ty_inst = expr_inst_levels(ctor_ty, lvls); - let after_params = io_peel_params_subst(ctor_ty_inst, args, n_params); - io_peel_field_loop(after_params, fidx, 0, struct_addr, e1), - }, - }, - }, - }, - } - } - - fn ensure_sort_only(rc: RoleCtx, e: KExpr, types: List‹KExpr›) -> KLevel { - let ty = k_infer_only(rc, e, types); - match load(ty) { - KExprNode.Srt(l) => l, - _ => - let ty_whnf = whnf(rc, ty, types); - match load(ty_whnf) { - KExprNode.Srt(l) => l, - }, - } - } - - fn io_peel_params_subst(ty: KExpr, args: List‹KExpr›, n_params: G) -> KExpr { - match n_params { - 0 => ty, - _ => - match load(ty) { - KExprNode.Forall(_, body) => - match load(args) { - ListNode.Cons(arg, rest) => - let body_substed = expr_inst1(body, arg, 0); - io_peel_params_subst(body_substed, rest, n_params - 1), - }, - }, - } - } - - fn io_peel_field_loop(ty: KExpr, target: G, current: G, - struct_addr: Addr, val: KExpr) -> KExpr { - match load(ty) { - KExprNode.Forall(dom, body) => - match target - current { - 0 => dom, - _ => - let proj_expr = store(KExprNode.Proj(struct_addr, current, val)); - let body_substed = expr_inst1(body, proj_expr, 0); - io_peel_field_loop(body_substed, target, current + 1, - struct_addr, val), - }, - } - } -⟧ - -end IxVM - -end - diff --git a/Ix/IxVM/Kernel/Klimbs.lean b/Ix/IxVM/Kernel/Klimbs.lean deleted file mode 100644 index 9f7ac6696..000000000 --- a/Ix/IxVM/Kernel/Klimbs.lean +++ /dev/null @@ -1,551 +0,0 @@ -module -public import Ix.Aiur.Meta - -set_option maxRecDepth 8192 - -public section - -namespace IxVM - -/-! ## KLimbs bignum arithmetic - -Bignum gadgets backing the Nat primitives (`Ix/IxVM/Kernel/NatPrim.lean`). - -Kept in a module of its own, separate from the primitive dispatch that -consumes it, so the arithmetic can be read and tested without the -address-recognition machinery around it. - -Ops covered: -- klimbs_succ / klimbs_dec / klimbs_add / klimbs_sub / klimbs_le / - klimbs_is_zero / klimbs_normalize -- klimbs_mul (schoolbook) / klimbs_div / klimbs_mod / klimbs_div_mod - (unconstrained big-uint witness) -- klimbs_gcd (Euclidean) / klimbs_pow (binary exponentiation) -- klimbs_land / klimbs_lor / klimbs_xor_op -- klimbs_shl / klimbs_shr (via mul/div by 2^n) -- u64_add / u64_mul (radix-2^16 schoolbook) / u64_sub_with_borrow / - u64_and / u64_or / u64_xor_kbits (element-wise byte ops) -- divmod_256 (unconstrained witness generator for u32 byte decomposition) - -Aiur builtin gadgets used (compiler-provided): u8_add, u8_sub, -u8_xor, u8_and, u8_or, u8_from_field_unsafe, u32_less_than, -u64_add, u64_is_zero, list_snoc, unconstrained_big_uint_div_mod, -unconstrained_g_to_bytes. --/ - -set_option maxRecDepth 16384 in -def klimbs := ⟦ - - -- Mirror: BigUint::succ. Increment a KLimbs by 1; ripple carry. - fn klimbs_succ(n: KLimbs) -> KLimbs { - match load(n) { - ListNode.Nil => - store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))), - ListNode.Cons(limb, rest) => - let pair = u64_add(limb, [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); - match pair { - (sum, carry) => - match carry { - 0 => store(ListNode.Cons(sum, rest)), - _ => store(ListNode.Cons(sum, klimbs_succ(rest))), - }, - }, - } - } - - -- Mirror: BigUint::add. Limb-wise add with ripple carry. - -- KLimbs are little-endian; head = least significant. - -- Asymmetric lengths handled by terminating on shorter list and - -- propagating carry into the longer. - fn klimbs_add_carry(a: KLimbs, b: KLimbs, carry: G) -> KLimbs { - match load(a) { - ListNode.Nil => - match carry { - 0 => b, - _ => klimbs_succ(b), - }, - ListNode.Cons(la, ra) => - match load(b) { - ListNode.Nil => - match carry { - 0 => a, - _ => klimbs_succ(a), - }, - ListNode.Cons(lb, rb) => - let pair1 = u64_add(la, lb); - match pair1 { - (sum1, carry1) => - let pair2 = u64_add(sum1, [u8_from_field_unsafe(carry), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); - match pair2 { - (sum2, carry2) => - -- carry1, carry2 mutually exclusive: carry1=1 ⇒ sum1 ≤ - -- 2^64-2 ⇒ sum1 + carry_in ≤ 2^64-1 ⇒ carry2=0. - let total_carry = to_field(carry1) + to_field(carry2); - store(ListNode.Cons(sum2, klimbs_add_carry(ra, rb, total_carry))), - }, - }, - }, - } - } - - fn klimbs_add(a: KLimbs, b: KLimbs) -> KLimbs { - klimbs_add_carry(a, b, 0) - } - - -- Mirror: byte-wise u64_sub with explicit final borrow. - -- Per-byte: u_t = borrow(a_i - b_i); u_r = borrow((a_i + 256 - b_i) - br_in). - -- u_t = 1 ⇒ a_i + 256 - b_i ≥ 1 ⇒ subtracting br_in ∈ {0,1} cannot underflow - -- ⇒ u_r = 0. So `u_t` and `u_r` are mutually-exclusive 0/1 values; field `+` - -- substitutes for `g_or` (which charges +1 aux +1 lookup per call). See - -- [[reference_aiur_carry_add]]. - fn u64_sub_with_borrow(a: U64, b: U64) -> (U64, G) { - let [a0, a1, a2, a3, a4, a5, a6, a7] = a; - let [b0, b1, b2, b3, b4, b5, b6, b7] = b; - let (r0, br1) = u8_sub(a0, b0); - let (t1, u_t1) = u8_sub(a1, b1); - let (r1, u_r1) = u8_sub(t1, br1); - let br2 = to_field(u_t1) + to_field(u_r1); - let (t2, u_t2) = u8_sub(a2, b2); - let (r2, u_r2) = u8_sub(t2, u8_from_field_unsafe(br2)); - let br3 = to_field(u_t2) + to_field(u_r2); - let (t3, u_t3) = u8_sub(a3, b3); - let (r3, u_r3) = u8_sub(t3, u8_from_field_unsafe(br3)); - let br4 = to_field(u_t3) + to_field(u_r3); - let (t4, u_t4) = u8_sub(a4, b4); - let (r4, u_r4) = u8_sub(t4, u8_from_field_unsafe(br4)); - let br5 = to_field(u_t4) + to_field(u_r4); - let (t5, u_t5) = u8_sub(a5, b5); - let (r5, u_r5) = u8_sub(t5, u8_from_field_unsafe(br5)); - let br6 = to_field(u_t5) + to_field(u_r5); - let (t6, u_t6) = u8_sub(a6, b6); - let (r6, u_r6) = u8_sub(t6, u8_from_field_unsafe(br6)); - let br7 = to_field(u_t6) + to_field(u_r6); - let (t7, u_t7) = u8_sub(a7, b7); - let (r7, u_r7) = u8_sub(t7, u8_from_field_unsafe(br7)); - let final_borrow = to_field(u_t7) + to_field(u_r7); - ([r0, r1, r2, r3, r4, r5, r6, r7], final_borrow) - } - - -- Mirror: BigUint::sub with saturating-at-zero (Lean Nat.sub semantics). - -- a - b clamped to 0 when b > a. - -- - -- Walk both lists in parallel limb-by-limb with borrow ripple. If the - -- final borrow is 1 OR `b` has more limbs than `a`, return 0 (Nil). - -- Otherwise normalize trailing zero limbs. - fn klimbs_sub_borrow(a: KLimbs, b: KLimbs, borrow: G) -> (KLimbs, G) { - match load(a) { - ListNode.Nil => - match load(b) { - ListNode.Nil => - -- 0 - 0 - borrow: borrow=1 → underflow. - (store(ListNode.Nil), borrow), - ListNode.Cons(_, _) => - -- 0 - non-empty. A non-empty limb list is not necessarily a - -- non-zero number: trailing zero limbs are a valid encoding, and - -- `klimbs_div`/`klimbs_mod` hand back the raw prover-supplied - -- q/r, so denormalized operands do reach here. Treating every - -- non-empty `b` as an underflow made `klimbs_le([3], [2,0])` - -- certify "3 <= 2". - match klimbs_is_zero(b) { - 1 => (store(ListNode.Nil), borrow), - _ => (store(ListNode.Nil), 1), - }, - }, - ListNode.Cons(la, ra) => - match load(b) { - ListNode.Nil => - -- a - 0 - borrow: subtract borrow from la, propagate. - match borrow { - 0 => (a, 0), - _ => - let pair = u64_sub_with_borrow(la, [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); - match pair { - (diff, br) => - let pair2 = klimbs_sub_borrow(ra, store(ListNode.Nil), br); - match pair2 { - (rest_res, br2) => - (store(ListNode.Cons(diff, rest_res)), br2), - }, - }, - }, - ListNode.Cons(lb, rb) => - let pair1 = u64_sub_with_borrow(la, lb); - match pair1 { - (sum1, br1) => - let pair2 = u64_sub_with_borrow(sum1, [u8_from_field_unsafe(borrow), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); - match pair2 { - (sum2, br2) => - -- br1, br2 mutually exclusive: br1=1 ⇒ sum1 ≥ 1 ⇒ - -- sum1 - borrow ≥ 0 ⇒ br2=0. - let total = br1 + br2; - let rec_pair = klimbs_sub_borrow(ra, rb, total); - match rec_pair { - (rest_res, br_final) => - (store(ListNode.Cons(sum2, rest_res)), br_final), - }, - }, - }, - }, - } - } - - -- Convert a prover-supplied field-typed limb list into a checked - -- `KLimbs`: every byte is forced into [0, 256) and the CHECKED outputs - -- (typed `u8`) rebuild the limbs. This is the only door from - -- `unconstrained_big_uint_div_mod` advice (typed `List‹[G; 8]›` by the - -- checker precisely so it cannot pose as bytes) back into `KLimbs`. - -- - -- `KLimbs` is canonical in two independent ways — no trailing zero - -- limbs, and every byte in range — and `klimbs_normalize` only - -- establishes the first. The second matters because `klimbs_eq` is a - -- raw limb compare: a value-correct but digit-wrong `KLimbs` compares - -- unequal to its canonical form, so `Nat.beq` answers `false` where - -- Lean answers `true`. `u8_range_check` takes a pair per lookup row, - -- so eight bytes cost four. - fn glimbs_to_klimbs(n: List‹[G; 8]›) -> KLimbs { - let (limbs, _) = glimbs_to_klimbs_with_depth(n); - limbs - } - - -- Quotient/remainder advice can contain arbitrary pointers, including - -- cycles. Range-checking digits and checking q*b+r=a do not establish - -- termination of their recursive walks. Return a non-wrapping u32 depth - -- while checking the digits, before normalization or arithmetic sees them. - fn glimbs_to_klimbs_with_depth(n: List‹[G; 8]›) -> (KLimbs, G) { - match load(n) { - ListNode.Nil => (store(ListNode.Nil), 0), - ListNode.Cons(limb, rest) => - let [b0, b1, b2, b3, b4, b5, b6, b7] = limb; - let (c0, c1) = u8_range_check(b0, b1); - let (c2, c3) = u8_range_check(b2, b3); - let (c4, c5) = u8_range_check(b4, b5); - let (c6, c7) = u8_range_check(b6, b7); - let (tail, depth) = glimbs_to_klimbs_with_depth(rest); - let next_depth = checked_depth_succ(depth); - (store(ListNode.Cons([c0, c1, c2, c3, c4, c5, c6, c7], tail)), - next_depth), - } - } - - fn klimbs_normalize(n: KLimbs) -> KLimbs { - match load(n) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(limb, rest) => - let normalized_rest = klimbs_normalize(rest); - match load(normalized_rest) { - ListNode.Nil => - match u64_is_zero(limb) { - 1 => store(ListNode.Nil), - 0 => store(ListNode.Cons(limb, store(ListNode.Nil))), - }, - _ => store(ListNode.Cons(limb, normalized_rest)), - }, - } - } - - fn klimbs_sub(a: KLimbs, b: KLimbs) -> KLimbs { - let pair = klimbs_sub_borrow(a, b, 0); - match pair { - (result, borrow) => - match borrow { - 1 => store(ListNode.Nil), - 0 => klimbs_normalize(result), - }, - } - } - - -- Mirror: Nat.le. Returns 1 if a ≤ b, 0 otherwise. - -- Uses saturating sub: a ≤ b iff (a - b) saturates to 0. - fn klimbs_le(a: KLimbs, b: KLimbs) -> G { - let diff = klimbs_sub(a, b); - match load(diff) { - ListNode.Nil => 1, - _ => 0, - } - } - - -- Mirror: Nat.pred. Saturating decrement; pred(0) = 0. - fn klimbs_dec(a: KLimbs) -> KLimbs { - let one = store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))); - klimbs_sub(a, one) - } - - -- Returns (remainder, quotient): remainder = x mod 256, quotient = x / 256. - -- Repeated subtraction. Only invoked from the `#split_u32` - -- unconstrained witness generator, so the O(x/256) - -- iteration cost is off-circuit (untraced). - fn divmod_256(x: G, q: G) -> (G, G) { - match u32_less_than(x, 256) { - 1 => (x, q), - 0 => divmod_256(x - 256, q + 1), - } - } - - -- Radix-2^16 schoolbook multiplication: four digits per operand. - -- Even with arbitrary checked carry advice, each column is < 2^35: - -- at most four 16-bit products plus a 24-bit carry. Its reconstruction - -- from five checked bytes is < 2^40. Both bounds are - -- strictly below the field modulus, so field equality is integer equality. - -- Input and output representations are unchanged (eight LE bytes per limb). - fn u64_mul(a: U64, b: U64) -> (U64, U64) { - let a0 = to_field(a[0]) + 256 * to_field(a[1]); - let b0 = to_field(b[0]) + 256 * to_field(b[1]); - let a1 = to_field(a[2]) + 256 * to_field(a[3]); - let b1 = to_field(b[2]) + 256 * to_field(b[3]); - let a2 = to_field(a[4]) + 256 * to_field(a[5]); - let b2 = to_field(b[4]) + 256 * to_field(b[5]); - let a3 = to_field(a[6]) + 256 * to_field(a[7]); - let b3 = to_field(b[6]) + 256 * to_field(b[7]); - let (r0, c0) = @u64_mul_column((a0 * b0)); - let (r1, c1) = @u64_mul_column((a0 * b1) + (a1 * b0) + to_field(c0[0]) + 256 * to_field(c0[1]) + 65536 * to_field(c0[2])); - let (r2, c2) = @u64_mul_column((a0 * b2) + (a1 * b1) + (a2 * b0) + to_field(c1[0]) + 256 * to_field(c1[1]) + 65536 * to_field(c1[2])); - let (r3, c3) = @u64_mul_column((a0 * b3) + (a1 * b2) + (a2 * b1) + (a3 * b0) + to_field(c2[0]) + 256 * to_field(c2[1]) + 65536 * to_field(c2[2])); - let (r4, c4) = @u64_mul_column((a1 * b3) + (a2 * b2) + (a3 * b1) + to_field(c3[0]) + 256 * to_field(c3[1]) + 65536 * to_field(c3[2])); - let (r5, c5) = @u64_mul_column((a2 * b3) + (a3 * b2) + to_field(c4[0]) + 256 * to_field(c4[1]) + 65536 * to_field(c4[2])); - let (r6, c6) = @u64_mul_column((a3 * b3) + to_field(c5[0]) + 256 * to_field(c5[1]) + 65536 * to_field(c5[2])); - assert_eq!(c6[2], 0u8, "u64_mul: final carry exceeds one radix digit"); - ([r0[0], r0[1], r1[0], r1[1], r2[0], r2[1], r3[0], r3[1]], - [r4[0], r4[1], r5[0], r5[1], r6[0], r6[1], c6[0], c6[1]]) - } - - fn u64_mul_column(x: G) -> ([U8; 2], [U8; 3]) { - let bytes = unconstrained_g_to_bytes(x); - let (r0, r1) = u8_range_check(bytes[0], bytes[1]); - let (c0, c1) = u8_range_check(bytes[2], bytes[3]); - let (c2, _) = u8_range_check(bytes[4], 0); - assert_eq!(x, to_field(r0) + 256 * to_field(r1) - + 65536 * (to_field(c0) + 256 * to_field(c1) + 65536 * to_field(c2)), - "u64_mul: column hint does not recompose"); - ([r0, r1], [c0, c1, c2]) - } - - -- Mirror: BigUint::mul. Limb-wise schoolbook multiply. - fn klimbs_mul(a: KLimbs, b: KLimbs) -> KLimbs { - klimbs_mul_outer(a, b, store(ListNode.Nil), 0) - } - - fn klimbs_mul_outer(a: KLimbs, b: KLimbs, acc: KLimbs, shift: G) -> KLimbs { - match load(a) { - ListNode.Nil => acc, - ListNode.Cons(a_limb, rest) => - let prod = klimbs_mul_single(a_limb, b, [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); - let shifted = klimbs_shl_limbs(prod, shift); - let new_acc = klimbs_add(acc, shifted); - klimbs_mul_outer(rest, b, new_acc, shift + 1), - } - } - - -- Build the low limb onto the recursively computed tail. Repeated snoc - -- copied growing output prefixes; cons builds each result limb once and - -- removes the irrelevant output prefix from the memo key. The arithmetic - -- and the zero/trailing-limb representation are unchanged. - fn klimbs_mul_single(a_limb: U64, b: KLimbs, carry: U64) -> KLimbs { - match load(b) { - ListNode.Nil => - match u64_is_zero(carry) { - 1 => store(ListNode.Nil), - 0 => store(ListNode.Cons(carry, store(ListNode.Nil))), - }, - ListNode.Cons(b_limb, rest) => - match u64_mul(a_limb, b_limb) { - (lo, hi) => - match u64_add(lo, carry) { - (sum, carry_out) => - -- u64_mul range-checks ALL eight high bytes. The carry is - -- a bit, and the old addition discarded overflow, so reuse - -- hi or take its modular successor. - match carry_out { - 0 => store(ListNode.Cons(sum, - klimbs_mul_single(a_limb, rest, hi))), - _ => store(ListNode.Cons(sum, - klimbs_mul_single(a_limb, rest, relaxed_u64_succ(hi)))), - }, - }, - }, - } - } - - fn klimbs_shl_limbs(x: KLimbs, shift: G) -> KLimbs { - match shift { - 0 => x, - _ => - let prepended = store(ListNode.Cons([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], x)); - klimbs_shl_limbs(prepended, shift - 1), - } - } - - fn klimbs_is_zero(x: KLimbs) -> G { - match load(klimbs_normalize(x)) { - ListNode.Nil => 1, - _ => 0, - } - } - - -- Unconstrained Aiur op `unconstrained_big_uint_div_mod(a, b) -> (q, r)` - -- pushes prover-supplied (q, r) into the trace map; no constraints emitted - -- by the op itself. Caller verifies `q*b + r == a` (under normalize) and - -- `r < b` when `b != 0`. For `b == 0` the op returns `(0, a)`; only the - -- `q*b + r == a` equality is required (which holds: `0*0 + a == a`). - -- - -- Soundness on the prover-supplied bytes: pinned by the range checks - -- inside `glimbs_to_klimbs` below, NOT by the arithmetic — and the - -- checker enforces the discipline by typing the hint `List‹[G; 8]›`, - -- so the limbs cannot reach a `u8` consumer without that conversion. - -- `u64_mul` uses raw field products with checked decomposition hints, - -- whose u8 checks constrain the split OUTPUTS, not the input digits — - -- and it re-canonicalizes while multiplying, so a digit-wrong `q` - -- still yields a canonical `q*b` and sails through the equality below. - -- That left the quotient's VALUE pinned but its representation free, - -- which is enough: `klimbs_eq` compares limbs rather than values, so a - -- digit-wrong quotient makes `Nat.beq (Nat.div 300 1) 300` answer - -- `false`. Trailing junk limbs are caught by the post-normalize - -- equality. - fn klimbs_div_mod(a: KLimbs, b: KLimbs) -> (KLimbs, KLimbs) { - let (q_hint, r_hint) = unconstrained_big_uint_div_mod(a, b); - -- Convert (range-checking every byte), then normalize. The op is - -- unconstrained, so nothing stops the prover returning limb lists - -- with trailing zeros, and these values are returned to callers: - -- `klimbs_gcd` feeds the remainder straight back as the next - -- DIVISOR, where a trailing zero limb made the `r < b` test pass - -- vacuously. - let q = klimbs_normalize(glimbs_to_klimbs(q_hint)); - let r = klimbs_normalize(glimbs_to_klimbs(r_hint)); - let qb = klimbs_mul(q, b); - let lhs = klimbs_normalize(klimbs_add(qb, r)); - let rhs = klimbs_normalize(a); - -- Pins the unconstrained div/mod hint: q*b + r must equal a. - assert_eq!(lhs, rhs, "div/mod hint: q*b + r != a"); - match klimbs_is_zero(b) { - 1 => - -- `q * 0 + r == a` pins r to a but leaves q entirely free, so - -- without this the prover picks any quotient for `n / 0` — enough - -- to fold `Nat.div 1 0` to 1 against Lean's `Nat.div_zero = 0`. - assert_eq!(klimbs_is_zero(q), 1, - "div/mod hint: division by zero must yield a zero quotient"); - (q, r), - 0 => - -- r < b iff (r + 1) ≤ b. One klimbs_le on klimbs_succ(r); cheapest - -- of the sound variants empirically (vs `le(r,b)∧¬eq(r,b)` or - -- `¬le(b,r)`). - assert_eq!(klimbs_le(klimbs_succ(r), b), 1, - "div/mod hint: remainder is not less than the divisor"); - (q, r), - } - } - - fn klimbs_div(a: KLimbs, b: KLimbs) -> KLimbs { - match klimbs_div_mod(a, b) { (q, _) => q, } - } - - fn klimbs_mod(a: KLimbs, b: KLimbs) -> KLimbs { - match klimbs_div_mod(a, b) { (_, r) => r, } - } - - fn klimbs_gcd(a: KLimbs, b: KLimbs) -> KLimbs { - match klimbs_is_zero(b) { - 1 => a, - 0 => klimbs_gcd(b, klimbs_mod(a, b)), - } - } - - -- Binary exponentiation. Replaces the old O(exp) recursive - -- `klimbs_mul(base, klimbs_pow(base, klimbs_dec(exp)))` body, which - -- created one per-fn memo row per exponent step and OOM'd for - -- non-trivial exponents. Recursion depth is `log2(exp)` — for - -- `exp = 2^32` that's 32 memo entries instead of 4 billion. - -- - -- Both `klimbs_div2` (= `klimbs_div(exp, 2)`) and `klimbs_is_odd` - -- (= `klimbs_mod(exp, 2) != 0`) route through `klimbs_div_mod`, which - -- is itself native (unconstrained_big_uint_div_mod) — so the - -- division per step is O(1) work. - fn klimbs_pow(base: KLimbs, exp: KLimbs) -> KLimbs { - match klimbs_is_zero(exp) { - 1 => store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))), - 0 => - let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))); - let (half, r) = klimbs_div_mod(exp, two); - let sq = klimbs_pow(klimbs_normalize(klimbs_mul(base, base)), klimbs_normalize(half)); - match klimbs_is_zero(r) { - 1 => sq, - 0 => klimbs_mul(base, sq), - }, - } - } - - -- Byte-wise AND on two U64 limbs. - fn u64_and(a: U64, b: U64) -> U64 { - let [a0, a1, a2, a3, a4, a5, a6, a7] = a; - let [b0, b1, b2, b3, b4, b5, b6, b7] = b; - [u8_and(a0, b0), u8_and(a1, b1), u8_and(a2, b2), u8_and(a3, b3), - u8_and(a4, b4), u8_and(a5, b5), u8_and(a6, b6), u8_and(a7, b7)] - } - - fn u64_or(a: U64, b: U64) -> U64 { - let [a0, a1, a2, a3, a4, a5, a6, a7] = a; - let [b0, b1, b2, b3, b4, b5, b6, b7] = b; - [u8_or(a0, b0), u8_or(a1, b1), u8_or(a2, b2), u8_or(a3, b3), - u8_or(a4, b4), u8_or(a5, b5), u8_or(a6, b6), u8_or(a7, b7)] - } - - fn u64_xor_kbits(a: U64, b: U64) -> U64 { - let [a0, a1, a2, a3, a4, a5, a6, a7] = a; - let [b0, b1, b2, b3, b4, b5, b6, b7] = b; - [u8_xor(a0, b0), u8_xor(a1, b1), u8_xor(a2, b2), u8_xor(a3, b3), - u8_xor(a4, b4), u8_xor(a5, b5), u8_xor(a6, b6), u8_xor(a7, b7)] - } - - -- Mirror: BigUint::bitand. Walks parallel limbs; result length = min(len(a), len(b)). - fn klimbs_land(a: KLimbs, b: KLimbs) -> KLimbs { - match load(a) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(la, ra) => - match load(b) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(lb, rb) => - store(ListNode.Cons(u64_and(la, lb), klimbs_land(ra, rb))), - }, - } - } - - -- Mirror: BigUint::bitor. Result length = max(len(a), len(b)); shorter is zero-padded. - fn klimbs_lor(a: KLimbs, b: KLimbs) -> KLimbs { - match load(a) { - ListNode.Nil => b, - ListNode.Cons(la, ra) => - match load(b) { - ListNode.Nil => a, - ListNode.Cons(lb, rb) => - store(ListNode.Cons(u64_or(la, lb), klimbs_lor(ra, rb))), - }, - } - } - - -- Mirror: BigUint::bitxor. Result length = max(len(a), len(b)); zero-padded shorter. - fn klimbs_xor_op(a: KLimbs, b: KLimbs) -> KLimbs { - match load(a) { - ListNode.Nil => b, - ListNode.Cons(la, ra) => - match load(b) { - ListNode.Nil => a, - ListNode.Cons(lb, rb) => - store(ListNode.Cons(u64_xor_kbits(la, lb), klimbs_xor_op(ra, rb))), - }, - } - } - - -- Shift left by n bits via repeated multiplication by 2. - fn klimbs_shl(a: KLimbs, n: KLimbs) -> KLimbs { - let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))); - klimbs_mul(a, klimbs_pow(two, n)) - } - - -- Shift right by n bits via integer division by 2^n. - fn klimbs_shr(a: KLimbs, n: KLimbs) -> KLimbs { - let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))); - klimbs_div(a, klimbs_pow(two, n)) - } -⟧ - -end IxVM - -end diff --git a/Ix/IxVM/Kernel/Levels.lean b/Ix/IxVM/Kernel/Levels.lean deleted file mode 100644 index 282c57d6a..000000000 --- a/Ix/IxVM/Kernel/Levels.lean +++ /dev/null @@ -1,955 +0,0 @@ -module -public import Ix.Aiur.Meta -public import Ix.IxVM.KernelTypes - -public section - -namespace IxVM - -/-! ## Level operations + literal equality + expr_inst_levels - -Universe level operations and literal-equality helpers. Self-contained; -kernel modules (`Subst`/`Whnf`/`Infer`/`DefEq`/`Check`) import from here. --/ - -def levels := ⟦ - fn level_is_not_zero(l: KLevel) -> G { - match load(l) { - KLevelNode.Zero => 0, - KLevelNode.Param(_) => 0, - KLevelNode.Succ(_) => 1, - KLevelNode.Max(a, b) => match (level_is_not_zero(a), level_is_not_zero(b)) { - (0, 0) => 0, - _ => 1, - }, - KLevelNode.IMax(_, b) => level_is_not_zero(b), - } - } - - fn level_eq(a: KLevel, b: KLevel) -> G { - match load(a) { - KLevelNode.Zero => - match load(b) { - KLevelNode.Zero => 1, - _ => 0, - }, - KLevelNode.Succ(a1) => - match load(b) { - KLevelNode.Succ(b1) => level_eq(a1, b1), - _ => 0, - }, - KLevelNode.Max(a1, a2) => - match load(b) { - KLevelNode.Max(b1, b2) => level_eq(a1, b1) * level_eq(a2, b2), - _ => 0, - }, - KLevelNode.IMax(a1, a2) => - match load(b) { - KLevelNode.IMax(b1, b2) => level_eq(a1, b1) * level_eq(a2, b2), - _ => 0, - }, - KLevelNode.Param(i) => - match load(b) { - KLevelNode.Param(j) => eq_zero(i - j), - _ => 0, - }, - } - } - - -- ============================================================================ - -- Canonical level normalization (normalize_level / norm_level_eq / - -- norm_level_le, a port of Lean4Lean's Level.Normalize with the documented - -- subsumption and covers-split fixes). - -- - -- Semantic level comparison via the recursive `Level.leq` with its - -- two-way param-substitution split per Max/IMax-with-param is - -- exponential in the number of params, and every branch materializes - -- freshly substituted levels (the Int16.instRxcHasSize_eq pathology: - -- 93% of the record was level_subst_reduce/level_leq rows). - -- Normalization is linear in the level size, `level_normalize` is - -- keyed on the level ALONE so each distinct level normalizes once per - -- run, and equality/leq on canonical forms is cheap. - -- - -- Canonical form: a path-sorted list of entries `(path, const, vars)` - -- where `path` is the sorted list of param indices conditioning an - -- imax chain (all assumed >= 1 along that branch), `const` the max - -- constant contribution, `vars` the idx-sorted `(param, offset)` - -- contributions. - -- ============================================================================ - enum NLVar { - Mk(G, G) - } - - enum NLEntry { - Mk(List‹G›, G, List‹&NLVar›) - } - - -- Lexicographic compare of sorted G-lists: 0 = eq, 1 = a < b, 2 = a > b. - fn glist_cmp(a: List‹G›, b: List‹G›) -> G { - match load(a) { - ListNode.Nil => - match load(b) { - ListNode.Nil => 0, - ListNode.Cons(_, _) => 1, - }, - ListNode.Cons(x, ar) => - match load(b) { - ListNode.Nil => 2, - ListNode.Cons(y, br) => - match u32_less_than(x, y) { - 1 => 1, - 0 => - match u32_less_than(y, x) { - 1 => 2, - 0 => glist_cmp(ar, br), - }, - }, - }, - } - } - - -- Sorted-list subset test. - fn glist_subset(xs: List‹G›, ys: List‹G›) -> G { - match load(xs) { - ListNode.Nil => 1, - ListNode.Cons(x, xr) => - match load(ys) { - ListNode.Nil => 0, - ListNode.Cons(y, yr) => - match u32_less_than(x, y) { - 1 => 0, - 0 => - match u32_less_than(y, x) { - 1 => glist_subset(xs, yr), - 0 => glist_subset(xr, yr), - }, - }, - }, - } - } - - fn glist_eq_len(a: List‹G›, b: List‹G›) -> G { - match load(a) { - ListNode.Nil => - match load(b) { - ListNode.Nil => 1, - ListNode.Cons(_, _) => 0, - }, - ListNode.Cons(_, ar) => - match load(b) { - ListNode.Nil => 0, - ListNode.Cons(_, br) => glist_eq_len(ar, br), - }, - } - } - - -- Insert into a sorted G-list. Returns (1, new_list) on insert, - -- (0, original) when already present. Mirrors level.rs ordered_insert. - fn glist_ordered_insert(x: G, l: List‹G›) -> (G, List‹G›) { - match load(l) { - ListNode.Nil => (1, store(ListNode.Cons(x, store(ListNode.Nil)))), - ListNode.Cons(h, r) => - match u32_less_than(x, h) { - 1 => (1, store(ListNode.Cons(x, l))), - 0 => - match u32_less_than(h, x) { - 0 => (0, l), - 1 => - match glist_ordered_insert(x, r) { - (f, r2) => (f, store(ListNode.Cons(h, r2))), - }, - }, - }, - } - } - - -- Insert (idx, k) into an idx-sorted var list; on duplicate idx keep - -- the max offset. Mirrors Node::add_var. - fn nlvars_add(vars: List‹&NLVar›, idx: G, k: G) -> List‹&NLVar› { - match load(vars) { - ListNode.Nil => - store(ListNode.Cons(store(NLVar.Mk(idx, k)), store(ListNode.Nil))), - ListNode.Cons(v, rest) => - match load(v) { - NLVar.Mk(vi, vo) => - match u32_less_than(idx, vi) { - 1 => store(ListNode.Cons(store(NLVar.Mk(idx, k)), vars)), - 0 => - match u32_less_than(vi, idx) { - 1 => store(ListNode.Cons(v, nlvars_add(rest, idx, k))), - 0 => - match u32_less_than(vo, k) { - 1 => store(ListNode.Cons(store(NLVar.Mk(vi, k)), rest)), - 0 => vars, - }, - }, - }, - }, - } - } - - fn nlvars_eq(a: List‹&NLVar›, b: List‹&NLVar›) -> G { - match load(a) { - ListNode.Nil => - match load(b) { - ListNode.Nil => 1, - ListNode.Cons(_, _) => 0, - }, - ListNode.Cons(x, ar) => - match load(b) { - ListNode.Nil => 0, - ListNode.Cons(y, br) => - match load(x) { - NLVar.Mk(xi, xo) => - match load(y) { - NLVar.Mk(yi, yo) => - match xi - yi { - 0 => - match xo - yo { - 0 => nlvars_eq(ar, br), - _ => 0, - }, - _ => 0, - }, - }, - }, - }, - } - } - - fn nlvars_max_offset(vars: List‹&NLVar›) -> G { - match load(vars) { - ListNode.Nil => 0, - ListNode.Cons(v, rest) => - match load(v) { - NLVar.Mk(_, vo) => - let m = nlvars_max_offset(rest); - match u32_less_than(m, vo) { - 1 => vo, - 0 => m, - }, - }, - } - } - - -- Keep x in xs unless ys has the same idx with offset >= x's. - -- Mirrors level.rs subsume_vars (sorted merge walk). - fn nlvars_subsume(xs: List‹&NLVar›, ys: List‹&NLVar›) -> List‹&NLVar› { - match load(xs) { - ListNode.Nil => xs, - ListNode.Cons(x, xr) => - match load(ys) { - ListNode.Nil => xs, - ListNode.Cons(y, yr) => - match load(x) { - NLVar.Mk(xi, xo) => - match load(y) { - NLVar.Mk(yi, yo) => - match u32_less_than(xi, yi) { - 1 => store(ListNode.Cons(x, nlvars_subsume(xr, ys))), - 0 => - match u32_less_than(yi, xi) { - 1 => nlvars_subsume(xs, yr), - 0 => - match u32_less_than(yo, xo) { - 1 => store(ListNode.Cons(x, nlvars_subsume(xr, yr))), - 0 => nlvars_subsume(xr, yr), - }, - }, - }, - }, - }, - }, - } - } - - -- Max the constant contribution into the entry at `path` (path-sorted - -- insert). Mirrors norm_add_const incl. its skip rule: k = 0 never - -- contributes; k = 1 only at the empty path (along a non-empty path - -- all conditioning params are >= 1 so the branch value is >= 1 anyway). - fn nl_add_const(acc: List‹&NLEntry›, path: List‹G›, k: G) -> List‹&NLEntry› { - match k { - 0 => acc, - 1 => - match load(path) { - ListNode.Nil => nl_add_const_go(acc, path, k), - ListNode.Cons(_, _) => acc, - }, - _ => nl_add_const_go(acc, path, k), - } - } - - fn nl_add_const_go(acc: List‹&NLEntry›, path: List‹G›, k: G) -> List‹&NLEntry› { - match load(acc) { - ListNode.Nil => - store(ListNode.Cons( - store(NLEntry.Mk(path, k, store(ListNode.Nil))), - store(ListNode.Nil))), - ListNode.Cons(e, rest) => - match load(e) { - NLEntry.Mk(ep, ec, ev) => - match glist_cmp(path, ep) { - 0 => - match u32_less_than(ec, k) { - 1 => store(ListNode.Cons(store(NLEntry.Mk(ep, k, ev)), rest)), - 0 => acc, - }, - 1 => - store(ListNode.Cons( - store(NLEntry.Mk(path, k, store(ListNode.Nil))), acc)), - _ => store(ListNode.Cons(e, nl_add_const_go(rest, path, k))), - }, - }, - } - } - - -- Add var (idx, k) to the entry at `path` (path-sorted insert). - fn nl_add_var(acc: List‹&NLEntry›, path: List‹G›, idx: G, k: G) -> List‹&NLEntry› { - match load(acc) { - ListNode.Nil => - store(ListNode.Cons( - store(NLEntry.Mk(path, 0, - store(ListNode.Cons(store(NLVar.Mk(idx, k)), store(ListNode.Nil))))), - store(ListNode.Nil))), - ListNode.Cons(e, rest) => - match load(e) { - NLEntry.Mk(ep, ec, ev) => - match glist_cmp(path, ep) { - 0 => - store(ListNode.Cons( - store(NLEntry.Mk(ep, ec, nlvars_add(ev, idx, k))), rest)), - 1 => - store(ListNode.Cons( - store(NLEntry.Mk(path, 0, - store(ListNode.Cons(store(NLVar.Mk(idx, k)), store(ListNode.Nil))))), - acc)), - _ => store(ListNode.Cons(e, nl_add_var(rest, path, idx, k))), - }, - }, - } - } - - -- Flatten a level into canonical form. `path` = imax conditioning chain - -- (sorted param idxs), `k` = accumulated Succ offset. Mirrors - -- normalize_aux; the IMax arm delegates to the dispatch (whose cases - -- replicate the aux IMax-shape cases verbatim, as in level.rs). - fn normalize_aux(l: KLevel, path: List‹G›, k: G, - acc: List‹&NLEntry›) -> List‹&NLEntry› { - match load(l) { - KLevelNode.Zero => nl_add_const(acc, path, k), - KLevelNode.Succ(inner) => normalize_aux(inner, path, k + 1, acc), - KLevelNode.Max(a, b) => - normalize_aux(b, path, k, normalize_aux(a, path, k, acc)), - KLevelNode.IMax(u, b) => normalize_imax_dispatch(u, b, path, k, acc), - KLevelNode.Param(idx) => - match glist_ordered_insert(idx, path) { - (1, new_path) => - nl_add_var(nl_add_const(acc, path, k), new_path, idx, k), - (0, _) => - match k { - 0 => acc, - _ => nl_add_var(acc, path, idx, k), - }, - }, - } - } - - -- imax(a, b) by b's shape: zero kills the branch; succ is never-zero so - -- imax = max; max/imax distribute; param conditions the path. - fn normalize_imax_dispatch(a: KLevel, b: KLevel, path: List‹G›, k: G, - acc: List‹&NLEntry›) -> List‹&NLEntry› { - match load(b) { - KLevelNode.Zero => nl_add_const(acc, path, k), - KLevelNode.Succ(v) => - normalize_aux(v, path, k + 1, normalize_aux(a, path, k, acc)), - KLevelNode.Max(v, w) => - -- imax(a, max(v, w)) = max(imax(a, v), imax(a, w)) - normalize_imax_dispatch(a, w, path, k, - normalize_imax_dispatch(a, v, path, k, acc)), - KLevelNode.IMax(v, w) => - -- imax(a, imax(v, w)) = max(imax(a, w), imax(v, w)) - normalize_imax_dispatch(v, w, path, k, - normalize_imax_dispatch(a, w, path, k, acc)), - KLevelNode.Param(idx) => - match glist_ordered_insert(idx, path) { - (1, new_path) => - -- param(idx) = 0 branch: imax(a, 0) = 0, contributing k. - normalize_aux(a, new_path, k, - nl_add_var(nl_add_const(acc, path, k), new_path, idx, k)), - (0, _) => - let acc2 = match k { - 0 => acc, - _ => nl_add_var(acc, path, idx, k), - }; - normalize_aux(a, path, k, acc2), - }, - } - } - - -- subsumption: drop contributions dominated by another entry - -- whose path is a subset (active whenever the dominated one is). - -- Each entry folds over the ORIGINAL (snapshot) list, mirroring the - -- Rust snapshot semantics. Callers seed `snapshot` with the same list - -- they pass as `rem`. - fn nl_subsumption_walk(rem: List‹&NLEntry›, - snapshot: List‹&NLEntry›) -> List‹&NLEntry› { - match load(rem) { - ListNode.Nil => rem, - ListNode.Cons(e, rest) => - store(ListNode.Cons( - nl_subsume_entry(e, snapshot), - nl_subsumption_walk(rest, snapshot))), - } - } - - fn nl_subsume_entry(e: &NLEntry, snap: List‹&NLEntry›) -> &NLEntry { - match load(snap) { - ListNode.Nil => e, - ListNode.Cons(s, srest) => - match load(e) { - NLEntry.Mk(p1, c1, v1) => - match load(s) { - NLEntry.Mk(p2, c2, v2) => - match glist_subset(p2, p1) { - 0 => nl_subsume_entry(e, srest), - _ => - -- subset + equal length <=> p1 == p2 (self entry) - let same = glist_eq_len(p1, p2); - let c1n = match c1 { - 0 => 0, - _ => - let or1 = match same { - 1 => 1, - 0 => u32_less_than(c2, c1), - }; - let or2 = match load(v2) { - ListNode.Nil => 1, - ListNode.Cons(_, _) => - u32_less_than(nlvars_max_offset(v1) + 1, c1), - }; - match or1 * or2 { - 0 => 0, - _ => c1, - }, - }; - let v1n = match same { - 1 => v1, - 0 => - match load(v2) { - ListNode.Nil => v1, - ListNode.Cons(_, _) => nlvars_subsume(v1, v2), - }, - }; - nl_subsume_entry(store(NLEntry.Mk(p1, c1n, v1n)), srest), - }, - }, - }, - } - } - - -- Advance past EMPTY entries (const 0, no vars -- pure subsumption - -- bookkeeping; subsumption empties a dominated entry rather than - -- removing it). Canonicity 10.6 R5 option (b): counting them made - -- equality strictly finer than semantic equality (3 of 3,253,373 - -- whole-Mathlib entries). Mirrors level.rs norm_level_eq's filter. - fn nl_skip_empty(l: List‹&NLEntry›) -> List‹&NLEntry› { - match load(l) { - ListNode.Nil => l, - ListNode.Cons(e, rest) => - match load(e) { - NLEntry.Mk(_, c, v) => - match c { - 0 => - match load(v) { - ListNode.Nil => nl_skip_empty(rest), - ListNode.Cons(_, _) => l, - }, - _ => l, - }, - }, - } - } - - -- Entry-wise equality of two normal forms, IGNORING empty entries - -- (see nl_skip_empty; nl_le's coverage checks are already trivially - -- satisfied by empty entries, so this makes level_equal agree with - -- leq-antisymmetry -- the exact semantic quotient). - fn nl_eq(a0: List‹&NLEntry›, b0: List‹&NLEntry›) -> G { - let a = nl_skip_empty(a0); - let b = nl_skip_empty(b0); - match load(a) { - ListNode.Nil => - match load(b) { - ListNode.Nil => 1, - ListNode.Cons(_, _) => 0, - }, - ListNode.Cons(x, ar) => - match load(b) { - ListNode.Nil => 0, - ListNode.Cons(y, br) => - match load(x) { - NLEntry.Mk(xp, xc, xv) => - match load(y) { - NLEntry.Mk(yp, yc, yv) => - match glist_cmp(xp, yp) { - 0 => - match xc - yc { - 0 => - match nlvars_eq(xv, yv) { - 1 => nl_eq(ar, br), - 0 => 0, - }, - _ => 0, - }, - _ => 0, - }, - }, - }, - }, - } - } - - -- Does some entry (p2, n2) in l2 with p2 SUBSET-OF p1 dominate the - -- constant c along every assignment activating p1? n2.const counts - -- unconditionally in that branch; each var (idx, off) counts as - -- >= off + 1 because idx IN p2 implies the param is >= 1 there. - -- Mirrors level.rs covers_const (the fixed, split-search version). - fn nl_covers_const(l2: List‹&NLEntry›, p1: List‹G›, c: G) -> G { - match load(l2) { - ListNode.Nil => 0, - ListNode.Cons(e, rest) => - match load(e) { - NLEntry.Mk(p2, c2, v2) => - match glist_subset(p2, p1) { - 0 => nl_covers_const(rest, p1, c), - _ => - let hit = match u32_less_than(c2, c) { - 0 => 1, - 1 => nlvars_any_offset_geq(v2, c), - }; - match hit { - 1 => 1, - 0 => nl_covers_const(rest, p1, c), - }, - }, - }, - } - } - - -- Any var with offset + 1 >= c? - fn nlvars_any_offset_geq(vars: List‹&NLVar›, c: G) -> G { - match load(vars) { - ListNode.Nil => 0, - ListNode.Cons(v, rest) => - match load(v) { - NLVar.Mk(_, vo) => - match u32_less_than(vo + 1, c) { - 0 => 1, - 1 => nlvars_any_offset_geq(rest, c), - }, - }, - } - } - - -- Does some entry (p2, n2) in l2 with p2 SUBSET-OF p1 contain a var - -- (w, off2) with off2 >= off? Mirrors level.rs covers_var. - fn nl_covers_var(l2: List‹&NLEntry›, p1: List‹G›, w: G, off: G) -> G { - match load(l2) { - ListNode.Nil => 0, - ListNode.Cons(e, rest) => - match load(e) { - NLEntry.Mk(p2, _, v2) => - match glist_subset(p2, p1) { - 0 => nl_covers_var(rest, p1, w, off), - _ => - match nlvars_dominates(v2, w, off) { - 1 => 1, - 0 => nl_covers_var(rest, p1, w, off), - }, - }, - }, - } - } - - fn nlvars_dominates(vars: List‹&NLVar›, w: G, off: G) -> G { - match load(vars) { - ListNode.Nil => 0, - ListNode.Cons(v, rest) => - match load(v) { - NLVar.Mk(vi, vo) => - match vi - w { - 0 => - match u32_less_than(vo, off) { - 0 => 1, - 1 => nlvars_dominates(rest, w, off), - }, - _ => nlvars_dominates(rest, w, off), - }, - }, - } - } - - -- Semantic l1 <= l2 on canonical forms: every entry's contribution in - -- its activation branch must be dominated by subset-path entries of l2. - -- Mirrors level.rs norm_level_le (with its covers split, sound where - -- Lean4Lean's single-entry search is incomplete). - fn nl_le(l1: List‹&NLEntry›, l2: List‹&NLEntry›) -> G { - match load(l1) { - ListNode.Nil => 1, - ListNode.Cons(e, rest) => - match load(e) { - NLEntry.Mk(p1, c1, v1) => - let c_ok = match c1 { - 0 => 1, - _ => nl_covers_const(l2, p1, c1), - }; - match c_ok { - 0 => 0, - 1 => - match nl_le_vars(v1, l2, p1) { - 0 => 0, - 1 => nl_le(rest, l2), - }, - }, - }, - } - } - - fn nl_le_vars(vars: List‹&NLVar›, l2: List‹&NLEntry›, p1: List‹G›) -> G { - match load(vars) { - ListNode.Nil => 1, - ListNode.Cons(v, rest) => - match load(v) { - NLVar.Mk(vi, vo) => - match nl_covers_var(l2, p1, vi, vo) { - 0 => 0, - 1 => nl_le_vars(rest, l2, p1), - }, - }, - } - } - - -- Keyed on the level alone: each distinct level normalizes once per run. - -- Seeded with the empty-path entry, mirroring normalize_level. - fn level_normalize(l: KLevel) -> List‹&NLEntry› { - let seed = store(ListNode.Cons( - store(NLEntry.Mk(store(ListNode.Nil), 0, store(ListNode.Nil))), - store(ListNode.Nil))); - let raw = normalize_aux(l, store(ListNode.Nil), 0, seed); - nl_subsumption_walk(raw, raw) - } - - fn level_leq(a: KLevel, b: KLevel) -> G { - match level_eq(a, b) { - 1 => 1, - 0 => - match load(a) { - KLevelNode.Zero => 1, - _ => nl_le(level_normalize(a), level_normalize(b)), - }, - } - } - - -- Semantic level equality via canonical forms (mirror: level.rs - -- univ_eq). The previous leq(a,b)*leq(b,a) did a two-way - -- param-substitution split per Max/IMax-with-param -- exponential in - -- params and the dominant record cost on instance-heavy checks. - fn level_equal(a: KLevel, b: KLevel) -> G { - match level_eq(a, b) { - 1 => 1, - 0 => nl_eq(level_normalize(a), level_normalize(b)), - } - } - - -- Mirror level.rs KUniv::max exactly: explicit-numeral collapse, - -- STRUCTURAL equality (store dedup makes structurally identical levels - -- pointer-equal), zero absorption, max-subsumption, same-base offset - -- collapse — and NO Succ-over-Max factoring. Lean stores type-former - -- levels normalized with Succ distributed INTO Max (`max (u+1) (v+1)`); - -- factoring Succ back out here rebuilt Succ-headed forms whose variant - -- rank differs, diverging canonical-sort comparisons (aux view order) - -- from the stored/compile shapes. - fn level_max(a: KLevel, b: KLevel) -> KLevel { - match level_explicit_val(a) { - (1, na) => - match level_explicit_val(b) { - (1, nb) => - match u32_less_than(na, nb) { - 1 => b, - 0 => a, - }, - _ => level_max_go(a, b), - }, - _ => level_max_go(a, b), - } - } - - fn level_max_go(a: KLevel, b: KLevel) -> KLevel { - match level_struct_eq(a, b) { - 1 => a, - 0 => - match load(a) { - KLevelNode.Zero => b, - _ => - match load(b) { - KLevelNode.Zero => a, - _ => - match level_max_subsumes(b, a) { - 1 => b, - 0 => - match level_max_subsumes(a, b) { - 1 => a, - 0 => level_max_offsets(a, b), - }, - }, - }, - }, - } - } - - -- Structural (raw, non-normalizing) level equality — mirror of Rust's - -- KUniv `==` (hash equality over the raw structure). Pointer equality - -- is a sound fast path (same data), but pointer INEQUALITY does not - -- imply different data, so the fallback compares values recursively. - fn level_struct_eq(a: KLevel, b: KLevel) -> G { - match ptr_val(a) - ptr_val(b) { - 0 => 1, - _ => - match load(a) { - KLevelNode.Zero => - match load(b) { - KLevelNode.Zero => 1, - _ => 0, - }, - KLevelNode.Succ(x) => - match load(b) { - KLevelNode.Succ(y) => level_struct_eq(x, y), - _ => 0, - }, - KLevelNode.Max(x1, x2) => - match load(b) { - KLevelNode.Max(y1, y2) => - level_struct_eq(x1, y1) * level_struct_eq(x2, y2), - _ => 0, - }, - KLevelNode.IMax(x1, x2) => - match load(b) { - KLevelNode.IMax(y1, y2) => - level_struct_eq(x1, y1) * level_struct_eq(x2, y2), - _ => 0, - }, - KLevelNode.Param(i) => - match load(b) { - KLevelNode.Param(j) => - match i - j { - 0 => 1, - _ => 0, - }, - _ => 0, - }, - }, - } - } - - -- 1 iff `m` is `Max(l, r)` with `l` or `r` structurally equal to `x`: - -- max(x, max(x, b)) = max(x, b) etc. - fn level_max_subsumes(m: KLevel, x: KLevel) -> G { - match load(m) { - KLevelNode.Max(l, r) => - match level_struct_eq(l, x) { - 1 => 1, - 0 => level_struct_eq(r, x), - }, - _ => 0, - } - } - - -- Same-base offset collapse: succ^n(x) vs succ^m(x) with structurally - -- equal base → the larger; otherwise the raw Max node. - fn level_max_offsets(a: KLevel, b: KLevel) -> KLevel { - match level_offset_of(a, 0) { - (base_a, off_a) => - match level_offset_of(b, 0) { - (base_b, off_b) => - match level_struct_eq(base_a, base_b) { - 1 => - match u32_less_than(off_a, off_b) { - 1 => b, - 0 => a, - }, - 0 => store(KLevelNode.Max(a, b)), - }, - }, - } - } - - -- (1, n) iff the level is the explicit numeral succ^n(Zero). - fn level_explicit_val(l: KLevel) -> (G, G) { - match load(l) { - KLevelNode.Zero => (1, 0), - KLevelNode.Succ(inner) => - match level_explicit_val(inner) { - (1, n) => (1, n + 1), - _ => (0, 0), - }, - _ => (0, 0), - } - } - - -- Peel Succs: level_offset_of(succ^n(x), 0) = (x, n). - fn level_offset_of(l: KLevel, k: G) -> (KLevel, G) { - match load(l) { - KLevelNode.Succ(inner) => level_offset_of(inner, k + 1), - _ => (l, k), - } - } - - fn level_imax(a: KLevel, b: KLevel) -> KLevel { - match load(b) { - KLevelNode.Zero => store(KLevelNode.Zero), - KLevelNode.Succ(_) => level_max(a, b), - _ => - let not_zero = level_is_not_zero(b); - match not_zero { - 1 => level_max(a, b), - 0 => - match load(a) { - KLevelNode.Zero => b, - _ => - let eq = level_eq(a, b); - match eq { - 1 => a, - 0 => store(KLevelNode.IMax(a, b)), - }, - }, - }, - } - } - - fn level_reduce(l: KLevel) -> KLevel { - match load(l) { - KLevelNode.Zero => store(KLevelNode.Zero), - KLevelNode.Param(i) => store(KLevelNode.Param(i)), - KLevelNode.Succ(u) => store(KLevelNode.Succ(level_reduce(u))), - KLevelNode.Max(a, b) => level_max(level_reduce(a), level_reduce(b)), - KLevelNode.IMax(a, b) => level_imax(level_reduce(a), level_reduce(b)), - } - } - - fn level_inst_params(l: KLevel, params: List‹KLevel›) -> KLevel { - match load(l) { - KLevelNode.Zero => store(KLevelNode.Zero), - KLevelNode.Succ(u) => store(KLevelNode.Succ(level_inst_params(u, params))), - KLevelNode.Max(a, b) => - level_max(level_inst_params(a, params), level_inst_params(b, params)), - KLevelNode.IMax(a, b) => - level_imax(level_inst_params(a, params), level_inst_params(b, params)), - KLevelNode.Param(i) => list_lookup(params, i), - } - } - - fn level_list_inst(lvls: List‹KLevel›, params: List‹KLevel›) -> List‹KLevel› { - match load(lvls) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(l, rest) => - store(ListNode.Cons( - level_inst_params(l, params), - level_list_inst(rest, params))), - } - } - - fn expr_inst_levels(e: KExpr, params: List‹KLevel›) -> KExpr { - -- Fast path: empty param list = identity. Common when caller's lvls - -- list is Nil (constants with no universe params). - match load(params) { - ListNode.Nil => e, - _ => expr_inst_levels_walk(e, params), - } - } - - fn expr_inst_levels_walk(e: KExpr, params: List‹KLevel›) -> KExpr { - match load(e) { - KExprNode.BVar(i) => store(KExprNode.BVar(i)), - KExprNode.Srt(l) => - store(KExprNode.Srt(level_inst_params(l, params))), - KExprNode.Const(idx, lvls) => - store(KExprNode.Const(idx, level_list_inst(lvls, params))), - KExprNode.App(f, a) => - store(KExprNode.App(expr_inst_levels(f, params), expr_inst_levels(a, params))), - KExprNode.Lam(ty, body) => - store(KExprNode.Lam(expr_inst_levels(ty, params), expr_inst_levels(body, params))), - KExprNode.Forall(ty, body) => - store(KExprNode.Forall(expr_inst_levels(ty, params), expr_inst_levels(body, params))), - KExprNode.Let(ty, val, body) => - store(KExprNode.Let( - expr_inst_levels(ty, params), - expr_inst_levels(val, params), - expr_inst_levels(body, params))), - KExprNode.Lit(lit) => store(KExprNode.Lit(lit)), - KExprNode.Proj(tidx, fidx, e1) => - store(KExprNode.Proj(tidx, fidx, expr_inst_levels(e1, params))), - } - } - - -- ============================================================================ - -- Literal equality - -- ============================================================================ - - fn klimbs_eq(a: KLimbs, b: KLimbs) -> G { - match load(a) { - ListNode.Nil => - match load(b) { - ListNode.Nil => 1, - _ => 0, - }, - ListNode.Cons(la, ra) => - match load(b) { - ListNode.Nil => 0, - ListNode.Cons(lb, rb) => - let eq = u64_eq(la, lb); - match eq { - 1 => klimbs_eq(ra, rb), - 0 => 0, - }, - }, - } - } - - fn bytestream_eq(a: ByteStream, b: ByteStream) -> G { - match load(a) { - ListNode.Nil => - match load(b) { - ListNode.Nil => 1, - _ => 0, - }, - ListNode.Cons(ba, ra) => - match load(b) { - ListNode.Nil => 0, - ListNode.Cons(bb, rb) => - match to_field(ba) - to_field(bb) { - 0 => bytestream_eq(ra, rb), - _ => 0, - }, - }, - } - } - - fn literal_eq(a: KLiteral, b: KLiteral) -> G { - match a { - KLiteral.Nat(na) => - match b { - KLiteral.Nat(nb) => klimbs_eq(na, nb), - _ => 0, - }, - KLiteral.Str(sa) => - match b { - KLiteral.Str(sb) => bytestream_eq(sa, sb), - _ => 0, - }, - } - } -⟧ - -end IxVM - -end diff --git a/Ix/IxVM/Kernel/NatPrim.lean b/Ix/IxVM/Kernel/NatPrim.lean deleted file mode 100644 index 4b4fb135b..000000000 --- a/Ix/IxVM/Kernel/NatPrim.lean +++ /dev/null @@ -1,1271 +0,0 @@ -module -public import Ix.Aiur.Meta -public import Ix.IxVM.KernelTypes -public import Ix.IxVM.Kernel.Klimbs - -set_option maxRecDepth 8192 - -public section - -namespace IxVM - -/-! ## Nat primitive dispatch - -Nat/Str/BitVec/decidable reduction. Recognizes Const-headed applications of -Nat.succ / Nat.pred / Nat.add / Nat.sub / Nat.mul / Nat.div / Nat.mod / -Nat.pow / Nat.gcd / Nat.land / Nat.lor / Nat.xor / Nat.shl / Nat.shr / -Nat.beq / Nat.ble on Nat literals (or on Nat.zero / App(Nat.succ, ...) -ctor chains) and reduces them to a Nat or Bool literal via the -`klimbs_*` bignum ops. - -Recognition of a role (`Nat` and its operations, `Bool`, the literal support) -is by the claim's role binding (`role_is`, `role_addr`, `Ix/IxVM/Kernel/Roles.lean`): -a constant is `Nat.add` because the binding binds it to that role and the role -validated against its specification, never because of its address. The same -holds for the `Int`, `BitVec`, `String` and decision rules: each fires on a -role specified by its equations (`Spec.eqns`), and computes an instance of -them. No address is hardcoded. - -Beyond literal-on-literal folding, the dispatch also produces "stuck -compact forms" for symbolic bases (`Nat.add x 3`, `x / n`): reducing -those to successor towers or unfolding the division algorithm is what -makes naive Nat reduction explode, so they are kept in offset form and -compared structurally instead. --/ - -set_option maxRecDepth 16384 in -def natPrim := ⟦ - - -- Nothing reduces natively. `Lean.reduceBool` and `Lean.reduceNat` are - -- ordinary opaques that never reduce (and a claim that uses them depends on - -- `Lean.trustCompiler`, which the axiom policy declines); - -- `System.Platform.numBits` stays the value of the opaque `getNumBits ()`, - -- as in Lean's kernel; and `SizeOf.sizeOf` (with the `PUnit` instance's - -- `PUnit._sizeOf_1`) reduces through its definition. - - -- Bool value (0/1) → Const(Bool.false/Bool.true). - fn mk_bool(rc: RoleCtx, g: G) -> KExpr { - match g { - 0 => store(KExprNode.Const(role_addr(rc, @role_bool_false()), store(ListNode.Nil))), - _ => store(KExprNode.Const(role_addr(rc, @role_bool_true()), store(ListNode.Nil))), - } - } - - -- Compute BitVec.toNat internally: given (width_e, val_e), returns - -- (1, N mod 2^W) as KLimbs. (0, _) on miss. - fn bv_to_nat_via(rc: RoleCtx, width_e: KExpr, val_e: KExpr) -> (G, KLimbs) { - match bitvec_of_nat_args_direct(rc, val_e) { - (0, _, _) => (0, store(ListNode.Nil)), - (1, val_width, n_e) => - match try_extract_nat(rc, n_e) { - (0, _) => (0, store(ListNode.Nil)), - (1, n_kl) => - match try_extract_nat(rc, val_width) { - (0, _) => (0, store(ListNode.Nil)), - (1, w_kl) => - let two = store(ListNode.Cons( - [2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], - store(ListNode.Nil))); - let modulus = klimbs_pow(two, w_kl); - (1, klimbs_normalize(klimbs_mod(n_kl, modulus))), - }, - }, - } - } - - -- BitVec.ult width lhs rhs → mk_bool(rc, lhs_nat < rhs_nat) - fn try_reduce_bit_vec_ult(rc: RoleCtx, spine: List‹KExpr›) -> (G, KExpr) { - match u32_less_than(list_length(spine), 3) { - 1 => (0, store(KExprNode.BVar(0))), - _ => - let width_e = list_lookup(spine, 0); - let lhs_e = list_lookup(spine, 1); - let rhs_e = list_lookup(spine, 2); - match bv_to_nat_via(rc, width_e, lhs_e) { - (0, _) => (0, store(KExprNode.BVar(0))), - (1, lhs_n) => - match bv_to_nat_via(rc, width_e, rhs_e) { - (0, _) => (0, store(KExprNode.BVar(0))), - (1, rhs_n) => - -- lhs < rhs iff !(rhs ≤ lhs) - let r = 1 - klimbs_le(rhs_n, lhs_n); - (1, mk_bool(rc, r)), - }, - }, - } - } - - -- Extract (width, value) from `BitVec.ofNat W N` shape. Returns - -- (1, W, N) or (0, _, _). Direct form only: the `OfNat.ofNat`-wrapped - -- form is not recognized here, so a wrapped literal stays stuck rather - -- than folding. - fn bitvec_of_nat_args_direct(rc: RoleCtx, e: KExpr) -> (G, KExpr, KExpr) { - match collect_spine(e) { - (head, args) => - match load(head) { - KExprNode.Const(caddr, _) => - match role_is(rc, caddr, @role_bit_vec_of_nat()) { - 1 => - match list_length(args) - 2 { - 0 => (1, list_lookup(args, 0), list_lookup(args, 1)), - _ => (0, store(KExprNode.BVar(0)), store(KExprNode.BVar(0))), - }, - _ => (0, store(KExprNode.BVar(0)), store(KExprNode.BVar(0))), - }, - _ => (0, store(KExprNode.BVar(0)), store(KExprNode.BVar(0))), - }, - } - } - - -- BitVec.toNat (op 1) / BitVec.ult (op 2) dispatch: both heads are functions, - -- and the spine is prepared (whnf inner (W, N) args first). The class methods - -- `OfNat.ofNat (BitVec w) n inst` and `decide (@LT.lt (BitVec w) inst x - -- y)` take their value from the instance, so neither is read here. - fn try_bitvec_dispatch(rc: RoleCtx, op: G, spine: List‹KExpr›, - types: List‹KExpr›) -> (G, KExpr) { - match op { - 1 => - match u32_less_than(list_length(spine), 2) { - 1 => (0, store(KExprNode.BVar(0))), - _ => - let spine_p = bitvec_prep_spine(rc, spine, types); - let width_e = list_lookup(spine_p, 0); - let val_e = list_lookup(spine_p, 1); - match bv_to_nat_via(rc, width_e, val_e) { - (0, _) => (0, store(KExprNode.BVar(0))), - (1, kl) => (1, mk_nat_lit(kl)), - }, - }, - 2 => - let spine_p = bitvec_prep_spine_ult(rc, spine, types); - try_reduce_bit_vec_ult(rc, spine_p), - _ => (0, store(KExprNode.BVar(0))), - } - } - - -- BitVec.ult prep: whnf [width, lhs, rhs] and recursively whnf each - -- BitVec.ofNat inner args, mirror bitvec_prep_spine (toNat) shape. - fn bitvec_prep_spine_ult(rc: RoleCtx, spine: List‹KExpr›, types: List‹KExpr›) - -> List‹KExpr› { - let sw = whnf_spine(rc, spine, types); - match load(sw) { - ListNode.Nil => sw, - ListNode.Cons(width_e, r1) => - match load(r1) { - ListNode.Nil => sw, - ListNode.Cons(lhs_e, r2) => - match load(r2) { - ListNode.Nil => sw, - ListNode.Cons(rhs_e, tail) => - let lhs_p = np_whnf_inner_bv(rc, lhs_e, types); - let rhs_p = np_whnf_inner_bv(rc, rhs_e, types); - store(ListNode.Cons(width_e, - store(ListNode.Cons(lhs_p, - store(ListNode.Cons(rhs_p, tail)))))), - }, - }, - } - } - - -- If e = App*(head, args), whnf each arg once. - fn np_whnf_inner_bv(rc: RoleCtx, e: KExpr, types: List‹KExpr›) -> KExpr { - match collect_spine(e) { - (h, a) => apply_spine(h, whnf_spine(rc, a, types)), - } - } - - -- Native string-value fast paths (`string_append` / `string_dec_eq`): - -- literal append and literal decidable equality reduce natively in - -- whnf, keeping evaluator-grade - -- string values out of the structural ByteArray/UTF-8 model. - - -- String primitive dispatch (`op`: 1 ofList, 2 utf8ByteSize, 3 back, - -- 4 toByteArray, 5 decEq, 6 append). - -- Caller pre-whnfs spine's outermost args; the ofList arm recursively - -- whnfs Cons tails to reach further literal-ctor nodes. - fn try_str_dispatch(rc: RoleCtx, head_addr: Addr, op: G, spine: List‹KExpr›, - types: List‹KExpr›) -> (G, KExpr) { - let spine_len = list_length(spine); - match op { - 1 => - match spine_len { - 1 => - match walk_char_list_bytes(rc, list_lookup(spine, 0), types) { - (1, bs) => (1, store(KExprNode.Lit(KLiteral.Str(bs)))), - (0, _) => (0, store(KExprNode.BVar(0))), - }, - _ => (0, store(KExprNode.BVar(0))), - }, - 2 => - match u32_less_than(spine_len, 1) { - 1 => (0, store(KExprNode.BVar(0))), - _ => - let a0 = list_lookup(spine, 0); - match load(a0) { - KExprNode.Lit(lit) => - match lit { - KLiteral.Str(bs) => - -- `klimbs_from_g` range-checks its byte decomposition - -- (so a length >= 256 lands in the right limb) and - -- returns a canonical `KLimbs` — required because - -- `klimbs_eq` (behind `Nat.beq`/`Nat.decEq`/ - -- `literal_eq`) compares limbs without normalizing. - let limbs = klimbs_from_g(list_length(bs)); - (1, store(KExprNode.Lit(KLiteral.Nat(limbs)))), - _ => (0, store(KExprNode.BVar(0))), - }, - _ => (0, store(KExprNode.BVar(0))), - }, - }, - 3 => try_str_back(rc, spine), - 4 => try_str_to_byte_array(rc, spine), - 5 => try_str_dec_eq(rc, head_addr, spine, types), - 6 => - match u32_less_than(spine_len, 2) { - 1 => (0, store(KExprNode.BVar(0))), - _ => - let a0 = list_lookup(spine, 0); - let a1 = list_lookup(spine, 1); - match load(a0) { - KExprNode.Lit(la) => - match la { - KLiteral.Str(sa) => - match load(a1) { - KExprNode.Lit(lb) => - match lb { - KLiteral.Str(sb) => - let joined = list_concat(sa, sb); - (1, store(KExprNode.Lit(KLiteral.Str(joined)))), - _ => (0, store(KExprNode.BVar(0))), - }, - _ => (0, store(KExprNode.BVar(0))), - }, - _ => (0, store(KExprNode.BVar(0))), - }, - _ => (0, store(KExprNode.BVar(0))), - }, - }, - _ => (0, store(KExprNode.BVar(0))), - } - } - - -- String.back over Lit(Str(bs)) → - -- App(Const(char_of_nat), Lit(Nat last_cp)). Empty bs → 65 ('A'). - fn try_str_back(rc: RoleCtx, spine: List‹KExpr›) -> (G, KExpr) { - match u32_less_than(list_length(spine), 1) { - 1 => (0, store(KExprNode.BVar(0))), - _ => - match load(list_lookup(spine, 0)) { - KExprNode.Lit(lit) => - match lit { - KLiteral.Str(bs) => - let cp = utf8_last_codepoint(bs); - let cp_limbs = klimbs_from_g(cp); - let cp_lit = store(KExprNode.Lit(KLiteral.Nat(cp_limbs))); - let con = store(KExprNode.Const(role_used_implicitly(rc, @role_char_of_nat()), - store(ListNode.Nil))); - (1, store(KExprNode.App(con, cp_lit))), - _ => (0, store(KExprNode.BVar(0))), - }, - _ => (0, store(KExprNode.BVar(0))), - }, - } - } - - -- String.toByteArray on Lit(Str "") → Const(byte_array_empty). - -- Non-empty bails to structural (caller falls back to Defn unfold). - fn try_str_to_byte_array(rc: RoleCtx, spine: List‹KExpr›) -> (G, KExpr) { - match u32_less_than(list_length(spine), 1) { - 1 => (0, store(KExprNode.BVar(0))), - _ => - match load(list_lookup(spine, 0)) { - KExprNode.Lit(lit) => - match lit { - KLiteral.Str(bs) => - match load(bs) { - ListNode.Nil => - (1, store(KExprNode.Const(role_used_implicitly(rc, @role_byte_array_empty()), - store(ListNode.Nil)))), - _ => (0, store(KExprNode.BVar(0))), - }, - _ => (0, store(KExprNode.BVar(0))), - }, - _ => (0, store(KExprNode.BVar(0))), - }, - } - } - - -- Walk byte stream forward decoding UTF-8; return last codepoint. - -- Empty → 65 ('A') per Rust default. - -- Validate an entire byte stream as UTF-8, aborting on the first - -- malformed scalar. `utf8_decode_one` rejects out-of-range - -- continuation bytes, stray continuations as leaders, overlong forms, - -- surrogates and code points above 0x10FFFF, so walking the stream with - -- it is exactly the reference kernels' `String::from_utf8` check at - -- ingress: the accepted literals are the encodings of Lean strings. - -- - -- Needed at Str-literal CONVERSION, not just during string reduction: - -- `KLiteral.Str` is typed `String` by `k_infer_lit` without inspecting - -- the bytes, so a literal that is never decoded would otherwise - -- typecheck as a `String` that no Lean `String` corresponds to. - fn utf8_validate(bs: ByteStream) { - match load(bs) { - ListNode.Nil => (), - ListNode.Cons(b0, rest) => - match utf8_decode_one(b0, rest) { - (_, remaining) => utf8_validate(remaining), - }, - } - } - - fn utf8_last_codepoint(bs: ByteStream) -> G { - utf8_last_go(bs, 65) - } - - fn utf8_last_go(bs: ByteStream, prev: G) -> G { - match load(bs) { - ListNode.Nil => prev, - ListNode.Cons(b0, rest) => - match utf8_decode_one(b0, rest) { - (cp, remaining) => utf8_last_go(remaining, cp), - }, - } - } - - -- Decode one UTF-8 codepoint. Honors length prefix bits: - -- 0xxxxxxx → 1 byte; 110xxxxx 10xxxxxx → 2; 1110xxxx 10*2 → 3; - -- 11110xxx 10*3 → 4 bytes. - -- A UTF-8 continuation byte is `10xxxxxx`, i.e. in [0x80, 0xC0). Only - -- that range decodes to a 6-bit payload; matching the two valid-range - -- outcomes makes any other byte fall off the match and abort (the - -- kernel's reject). Both bounds are load-bearing for soundness, not - -- conformance nicety: a byte < 0x80 makes `to_field(b) - 128` wrap to a - -- ~2^64 field element, and a byte >= 0xC0 makes the payload spill into - -- [64,128), so e.g. `[0xC0, 0xC0]` would decode to codepoint 64 and - -- alias the valid char `'@'`. - fn utf8_cont(b: U8) -> G { - match u8_less_than(b, 128u8) { - 0 => - match u8_less_than(b, 192u8) { - 1 => to_field(b) - 128, - }, - } - } - - -- Decode one UTF-8 scalar, validating just enough to be INJECTIVE: no - -- two distinct byte sequences may decode to the same codepoint, or the - -- expanded `String.ofList` forms alias and def_eq accepts a false string - -- equality. That requires (a) continuation bytes in range (`utf8_cont`), - -- and (b) the per-length overlong minimum, so a codepoint that has a - -- shorter valid encoding cannot also be produced by a longer one. The - -- reference kernels validate the whole blob as UTF-8 at ingress; this is - -- the same rejection, done per scalar. It also rejects what is not a - -- Unicode scalar value: surrogates [0xD800, 0xDFFF] in the three-byte - -- form, and code points of 0x110000 and above in the four-byte form - -- (every leader from 0xF5 up gives one). Such a literal corresponds to - -- no Lean `String`: its `String.ofList` expansion has a `Char.ofNat` - -- that is `'\0'`, so a native rule that reads the bytes (the byte - -- length) would disagree with the expansion's definitional value. - fn utf8_decode_one(b0: U8, rest: ByteStream) -> (G, ByteStream) { - match u8_less_than(b0, 128u8) { - 1 => (to_field(b0), rest), - _ => - -- Reject stray continuation bytes [0x80, 0xC2) as leaders: [0x80, - -- 0xC0) are continuations, and 0xC0/0xC1 only ever encode overlong - -- two-byte forms. Valid multi-byte leaders are >= 0xC2. - match u8_less_than(b0, 194u8) { - 0 => - match u8_less_than(b0, 224u8) { - 1 => - match load(rest) { - ListNode.Cons(b1, r1) => - -- Two-byte cp is >= 0x80 for every leader >= 0xC2, so - -- no overlong is reachable once the leader is gated. - let cp = (to_field(b0) - 192) * 64 + utf8_cont(b1); - (cp, r1), - }, - _ => - match u8_less_than(b0, 240u8) { - 1 => - match load(rest) { - ListNode.Cons(b1, r1) => - match load(r1) { - ListNode.Cons(b2, r2) => - let cp = (to_field(b0) - 224) * 4096 - + utf8_cont(b1) * 64 - + utf8_cont(b2); - -- Overlong: a real three-byte scalar is - -- >= 0x800. Reject anything below (e.g. - -- [0xE0,0x80,0x80] -> 0, which would alias - -- the one-byte NUL). - match u32_less_than(cp, 2048) { - 0 => - -- Surrogates [0xD800, 0xDFFF] are not - -- scalar values. - match u32_less_than(cp, 55296) { - 1 => (cp, r2), - 0 => - match u32_less_than(cp, 57344) { - 0 => (cp, r2), - }, - }, - }, - }, - }, - _ => - match load(rest) { - ListNode.Cons(b1, r1) => - match load(r1) { - ListNode.Cons(b2, r2) => - match load(r2) { - ListNode.Cons(b3, r3) => - let cp = (to_field(b0) - 240) * 262144 - + utf8_cont(b1) * 4096 - + utf8_cont(b2) * 64 - + utf8_cont(b3); - -- Overlong: a real four-byte scalar is - -- >= 0x10000. - match u32_less_than(cp, 65536) { - 0 => - -- The last scalar value is 0x10FFFF. - match u32_less_than(cp, 1114112) { - 1 => (cp, r3), - }, - }, - }, - }, - }, - }, - }, - }, - } - } - - -- Mirror of Rust `def_eq.rs::str_lit_to_constructor`. Expands - -- Lit(Str(bs)) to ctor form - -- `String.ofList (List.cons.{0} Char (Char.ofNat c) (... List.nil.{0} Char))` - -- over the binding's roles. The claim references none of these - -- constants, so each is a dependency it checks (`role_used_implicitly`). - fn str_lit_to_ctor(rc: RoleCtx, bs: ByteStream) -> KExpr { - let zero_lvl = store(KLevelNode.Zero); - let ulvls = store(ListNode.Cons(zero_lvl, store(ListNode.Nil))); - let nil_const = store(KExprNode.Const(role_used_implicitly(rc, @role_list_nil()), ulvls)); - let cons_const = store(KExprNode.Const(role_used_implicitly(rc, @role_list_cons()), ulvls)); - let char_const = - store(KExprNode.Const(role_used_implicitly(rc, @role_char()), store(ListNode.Nil))); - let con_const = - store(KExprNode.Const(role_used_implicitly(rc, @role_char_of_nat()), store(ListNode.Nil))); - let str_const = - store(KExprNode.Const(role_used_implicitly(rc, @role_string_of_list()), store(ListNode.Nil))); - let nil_app = store(KExprNode.App(nil_const, char_const)); - let cons_partial = store(KExprNode.App(cons_const, char_const)); - let list_expr = build_char_list(bs, nil_app, cons_partial, con_const); - store(KExprNode.App(str_const, list_expr)) - } - - fn build_char_list(bs: ByteStream, nil_app: KExpr, - cons_partial: KExpr, con_const: KExpr) -> KExpr { - match load(bs) { - ListNode.Nil => nil_app, - ListNode.Cons(b0, rest) => - match utf8_decode_one(b0, rest) { - (cp, remaining) => - let cp_limbs = klimbs_from_g(cp); - let cp_lit = store(KExprNode.Lit(KLiteral.Nat(cp_limbs))); - let char_val = store(KExprNode.App(con_const, cp_lit)); - let with_head = store(KExprNode.App(cons_partial, char_val)); - let tail = build_char_list(remaining, nil_app, cons_partial, con_const); - store(KExprNode.App(with_head, tail)), - }, - } - } - - -- Mirror str_lit_delta_step (Primitive.lean:3074): take ONE delta - -- step past `String.ofList` when it is a Defn, settling the body with - -- whnf_nd — a plain whnf of the ofList application would fold straight - -- back into the Str literal via the native ofList collapse. - fn str_lit_delta_step(rc: RoleCtx, expanded: KExpr, types: List‹KExpr›) -> KExpr { - match load(expanded) { - KExprNode.App(f, list_arg) => - match load(f) { - KExprNode.Const(caddr, _) => - let ci = load(get_ci(caddr)); - match ci { - KConstantInfo.Defn(_, _, value, _, _) => - let body = expr_inst_levels(value, store(ListNode.Nil)); - match load(body) { - KExprNode.Lam(_, lam_body) => - whnf_nd(rc, expr_inst1(lam_body, list_arg, 0), types), - _ => whnf_nd(rc, store(KExprNode.App(body, list_arg)), types), - }, - _ => expanded, - }, - _ => expanded, - }, - _ => expanded, - } - } - - -- Lit(Str) → ctor form with the delta step; other exprs unchanged. - -- Mirror str_lit_to_ctor_app_or_self (Primitive.lean:3099). - fn str_lit_to_ctor_app_or_self(rc: RoleCtx, e: KExpr, types: List‹KExpr›) -> KExpr { - match load(e) { - KExprNode.Lit(lit) => - match lit { - KLiteral.Str(bs) => str_lit_delta_step(rc, str_lit_to_ctor(rc, bs), types), - _ => e, - }, - _ => e, - } - } - - -- G (< 2^32) → single-limb KLimbs via prover-provided 4-byte split. - -- Pinned by u8 range checks + reconstruction assert. `x >= 2^32` - -- rejected (assert fails), not silently truncated. - fn split_u32(x: G) -> (G, G, G, G) { - match divmod_256(x, 0) { - (b0, q1) => - match divmod_256(q1, 0) { - (b1, q2) => - match divmod_256(q2, 0) { - (b2, q3) => - match divmod_256(q3, 0) { - (b3, _) => (b0, b1, b2, b3), - }, - }, - }, - } - } - - -- Convert G value (< 2^32) into single-limb KLimbs. The 4-byte - -- decomposition is a prover-provided (unconstrained) witness, pinned by - -- four u8 range checks + the reconstruction assert. `x >= 2^32` is - -- rejected (assert fails) rather than silently truncated. - fn klimbs_from_g(x: G) -> KLimbs { - match #split_u32(x) { - (rb0, rb1, rb2, rb3) => - let b0 = u8_xor(u8_from_field_unsafe(rb0), 0u8); - let b1 = u8_xor(u8_from_field_unsafe(rb1), 0u8); - let b2 = u8_xor(u8_from_field_unsafe(rb2), 0u8); - let b3 = u8_xor(u8_from_field_unsafe(rb3), 0u8); - -- Pins the unconstrained byte-split hint: the four witnessed - -- bytes must recompose to exactly the field element they claim - -- to decompose. - assert_eq!(x, to_field(b0) + 256 * to_field(b1) - + 65536 * to_field(b2) + 16777216 * to_field(b3), - "u32 byte split does not recompose to the original value"); - -- Normalize HERE, not at each caller: `x == 0` gives the all-zero - -- limb, which is the denormalized `[[0;8]]`. `klimbs_eq` (behind - -- `Nat.beq`/`decEq`) compares limbs without normalizing, so an - -- unnormalized zero disagrees with the canonical empty list and - -- makes a reducer's literal wrong. Callers used to normalize - -- individually and one (`String.back`) was missed. - klimbs_normalize(store(ListNode.Cons( - [b0, b1, b2, b3, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)))), - } - } - - -- Mirror walk_char_list_bytes: whnf `list`, expect a fully applied - -- `List.nil` (1 lvl arg) or `List.cons` (1 lvl + head + tail). - -- Returns (0, _) on any non-literal-ctor node, wrong arity, or invalid - -- codepoint — caller falls back to structural. - fn walk_char_list_bytes(rc: RoleCtx, list: KExpr, types: List‹KExpr›) - -> (G, ByteStream) { - let w = whnf(rc, list, types); - match collect_spine(w) { - (head, args) => - match load(head) { - KExprNode.Const(caddr, _) => - match role_is(rc, caddr, @role_list_nil()) { - 1 => - match list_length(args) { - 1 => (1, store(ListNode.Nil)), - _ => (0, store(ListNode.Nil)), - }, - _ => - match role_is(rc, caddr, @role_list_cons()) { - 0 => (0, store(ListNode.Nil)), - _ => - match list_length(args) { - 3 => - match char_lit_codepoint(rc, list_lookup(args, 1), types) { - (0, _) => (0, store(ListNode.Nil)), - (1, cp) => - match walk_char_list_bytes(rc, list_lookup(args, 2), types) { - (0, t) => (0, t), - (1, t) => (1, utf8_encode_prepend(cp, t)), - }, - }, - _ => (0, store(ListNode.Nil)), - }, - }, - }, - _ => (0, store(ListNode.Nil)), - }, - } - } - - -- Recognize App(Const(Char.ofNat), Nat-lit). Retry once through whnf - -- when the syntactic match misses (mirror char_lit_value + - -- whnf_prim_arg). - fn char_lit_codepoint(rc: RoleCtx, e: KExpr, types: List‹KExpr›) -> (G, G) { - match char_lit_codepoint_syn(rc, e) { - (1, cp) => (1, cp), - _ => - let w = whnf(rc, e, types); - char_lit_codepoint_syn(rc, w), - } - } - - fn char_lit_codepoint_syn(rc: RoleCtx, e: KExpr) -> (G, G) { - match load(e) { - KExprNode.App(f, arg) => - match load(f) { - KExprNode.Const(caddr, _) => - match role_is(rc, caddr, @role_char_of_nat()) { - 0 => (0, 0), - _ => - match load(arg) { - KExprNode.Lit(lit) => - match lit { - KLiteral.Nat(limbs) => klimbs_scalar_value(limbs), - _ => (0, 0), - }, - _ => (0, 0), - }, - }, - _ => (0, 0), - }, - _ => (0, 0), - } - } - - -- Single-limb KLimbs → codepoint; multi-limb literals bail. Guards - -- to valid Unicode scalars (rejects surrogates 0xD800-0xDFFF and - -- codepoints ≥ 0x110000). - fn klimbs_scalar_value(limbs: KLimbs) -> (G, G) { - match load(limbs) { - ListNode.Cons(limb, rest) => - match load(rest) { - ListNode.Nil => - let [b0, b1, b2, b3, b4, b5, b6, b7] = limb; - let hi = to_field(b3) + to_field(b4) + to_field(b5) + to_field(b6) + to_field(b7); - match eq_zero(hi) { - 0 => (0, 0), - _ => - let cp = to_field(b0) + to_field(b1) * 256 + to_field(b2) * 65536; - match u32_less_than(cp, 55296) { - 1 => (1, cp), - _ => - match u32_less_than(57343, cp) { - 0 => (0, 0), - _ => - match u32_less_than(cp, 1114112) { - 1 => (1, cp), - _ => (0, 0), - }, - }, - }, - }, - _ => (0, 0), - }, - _ => (0, 0), - } - } - - -- Off-circuit 6-bit decomposition (repeated subtraction); prover- - -- provided results MUST be pinned by u8 + window range checks + - -- reconstruction assert. - fn divmod_64u(x: G, q: G) -> (G, G) { - match u32_less_than(x, 64) { - 1 => (x, q), - _ => divmod_64u(x - 64, q + 1), - } - } - - fn utf8_groups(cp: G) -> (G, G, G, G) { - match divmod_64u(cp, 0) { - (g0, q1) => - match divmod_64u(q1, 0) { - (g1, q2) => - match divmod_64u(q2, 0) { - (g2, g3) => (g0, g1, g2, g3), - }, - }, - } - } - - -- Constrained UTF-8 encode of a valid scalar `cp`, prepended to `tail`. - -- Length class chosen by u32_less_than compares on `cp` (already valid - -- per caller — no overlong branch). - fn utf8_encode_prepend(cp: G, tail: ByteStream) -> ByteStream { - match #utf8_groups(cp) { - (g0, g1, g2, g3) => - let g0u = u8_xor(u8_from_field_unsafe(g0), 0u8); - let g1u = u8_xor(u8_from_field_unsafe(g1), 0u8); - let g2u = u8_xor(u8_from_field_unsafe(g2), 0u8); - let g3u = u8_xor(u8_from_field_unsafe(g3), 0u8); - let f0 = to_field(g0u); - let f1 = to_field(g1u); - let f2 = to_field(g2u); - let f3 = to_field(g3u); - -- Pins the unconstrained UTF-8 group hint: each group is a - -- 6-bit value and together they recompose to the codepoint. - assert_eq!(u32_less_than(f0, 64), 1, - "utf8 group 0 is not a 6-bit value"); - assert_eq!(u32_less_than(f1, 64), 1, - "utf8 group 1 is not a 6-bit value"); - assert_eq!(u32_less_than(f2, 64), 1, - "utf8 group 2 is not a 6-bit value"); - assert_eq!(u32_less_than(f3, 64), 1, - "utf8 group 3 is not a 6-bit value"); - assert_eq!(cp, f0 + f1 * 64 + f2 * 4096 + f3 * 262144, - "utf8 groups do not recompose to the codepoint"); - match u32_less_than(cp, 128) { - 1 => store(ListNode.Cons(u8_from_field_unsafe(cp), tail)), - _ => - match u32_less_than(cp, 2048) { - 1 => - let t1 = u8_from_field_unsafe(f0 + 128); - let l1 = u8_from_field_unsafe(f1 + 192); - store(ListNode.Cons(l1, store(ListNode.Cons(t1, tail)))), - _ => - match u32_less_than(cp, 65536) { - 1 => - let t2 = u8_from_field_unsafe(f0 + 128); - let t1 = u8_from_field_unsafe(f1 + 128); - let l2 = u8_from_field_unsafe(f2 + 224); - store(ListNode.Cons(l2, store(ListNode.Cons(t1, store(ListNode.Cons(t2, tail)))))), - _ => - let t3 = u8_from_field_unsafe(f0 + 128); - let t2 = u8_from_field_unsafe(f1 + 128); - let t1 = u8_from_field_unsafe(f2 + 128); - let l3 = u8_from_field_unsafe(f3 + 240); - store(ListNode.Cons(l3, store(ListNode.Cons(t1, store(ListNode.Cons(t2, store(ListNode.Cons(t3, tail)))))))), - }, - }, - }, - } - } - - -- ============================================================================ - -- Extract Nat literal from KExpr - -- ============================================================================ - fn try_extract_nat(rc: RoleCtx, e: KExpr) -> (G, KLimbs) { - match load(e) { - KExprNode.Lit(lit) => - match lit { - KLiteral.Nat(limbs) => (1, limbs), - _ => (0, store(ListNode.Nil)), - }, - KExprNode.Const(caddr, _) => - match role_is(rc, caddr, @role_nat_zero()) { - 1 => (1, store(ListNode.Nil)), - _ => (0, store(ListNode.Nil)), - }, - KExprNode.App(f, a) => try_extract_nat_app(rc, f, a), - _ => (0, store(ListNode.Nil)), - } - } - - -- Cold-extracted App arm: list_lookup + address_eq + recursive - -- try_extract_nat + klimbs_succ is the widest arm; pulling it out lets - -- `try_extract_nat`'s main width drop to the leaf-arm width. - fn try_extract_nat_app(rc: RoleCtx, f: KExpr, a: KExpr) -> (G, KLimbs) { - match load(f) { - KExprNode.Const(caddr, _) => - match role_is(rc, caddr, @role_nat_succ()) { - 1 => - match try_extract_nat(rc, a) { - (1, pred_limbs) => (1, klimbs_succ(pred_limbs)), - _ => (0, store(ListNode.Nil)), - }, - _ => (0, store(ListNode.Nil)), - }, - _ => (0, store(ListNode.Nil)), - } - } - - fn mk_nat_lit(n: KLimbs) -> KExpr { - store(KExprNode.Lit(KLiteral.Nat(n))) - } - - -- Canonical Int literals are `Int.ofNat n` and `Int.negSucc n`. - -- Internally use (sign, absolute magnitude), with sign=1 negative. - fn try_extract_int_prim(rc: RoleCtx, e: KExpr) -> (G, G, KLimbs) { - match load(e) { - KExprNode.App(f, a) => match load(f) { - KExprNode.Const(caddr, _) => match try_extract_nat(rc, a) { - (1, n) => match role_is(rc, caddr, @role_int_of_nat()) { - 1 => (1, 0, klimbs_normalize(n)), - _ => match role_is(rc, caddr, @role_int_neg_succ()) { - 1 => (1, 1, klimbs_normalize(klimbs_succ(n))), - _ => (0, 0, store(ListNode.Nil)), - }, - }, - _ => (0, 0, store(ListNode.Nil)), - }, - _ => (0, 0, store(ListNode.Nil)), - }, - _ => (0, 0, store(ListNode.Nil)), - } - } - - fn mk_int_prim(rc: RoleCtx, sign: G, magnitude: KLimbs) -> KExpr { - let mag = klimbs_normalize(magnitude); - let neg = sign * (1 - klimbs_is_zero(mag)); - let caddr = match neg { - 0 => role_used_implicitly(rc, @role_int_of_nat()), - _ => role_used_implicitly(rc, @role_int_neg_succ()), - }; - let arg = match neg { 0 => mag, _ => klimbs_normalize(klimbs_dec(mag)), }; - store(KExprNode.App(store(KExprNode.Const(caddr, store(ListNode.Nil))), mk_nat_lit(arg))) - } - - fn int_add_prim(rc: RoleCtx, sa: G, a: KLimbs, sb: G, b: KLimbs) -> KExpr { - match sa - sb { - 0 => mk_int_prim(rc, sa, klimbs_add(a, b)), - _ => match klimbs_le(a, b) { - 1 => mk_int_prim(rc, sb, klimbs_sub(b, a)), - _ => mk_int_prim(rc, sa, klimbs_sub(a, b)), - }, - } - } - - -- Euclidean quotient/remainder for signed a,b. Remainder is always - -- nonnegative and smaller than |b| (unless b=0, where r=a and q=0). - fn int_emod_prim(rc: RoleCtx, sa: G, a: KLimbs, b: KLimbs) -> KExpr { - match klimbs_is_zero(b) { - 1 => mk_int_prim(rc, sa, a), - _ => - let r0 = klimbs_mod(a, b); - match sa * (1 - klimbs_is_zero(r0)) { - 1 => mk_int_prim(rc, 0, klimbs_sub(b, r0)), - _ => mk_int_prim(rc, 0, r0), - }, - } - } - - fn int_ediv_prim(rc: RoleCtx, sa: G, a: KLimbs, sb: G, b: KLimbs) -> KExpr { - match klimbs_is_zero(b) { - 1 => mk_int_prim(rc, 0, store(ListNode.Nil)), - _ => - let q0 = klimbs_div(a, b); - let r0 = klimbs_mod(a, b); - let q = match sa * (1 - klimbs_is_zero(r0)) { - 1 => klimbs_succ(q0), - _ => q0, - }; - mk_int_prim(rc, (sa + sb - 2 * sa * sb) * (1 - klimbs_is_zero(q)), q), - } - } - - fn int_bmod_prim(rc: RoleCtx, sa: G, a: KLimbs, m: KLimbs) -> KExpr { - match klimbs_is_zero(m) { - 1 => mk_int_prim(rc, sa, a), - _ => - let r0 = klimbs_mod(a, m); - let r = match sa * (1 - klimbs_is_zero(r0)) { - 1 => klimbs_sub(m, r0), - _ => r0, - }; - let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))); - let half = klimbs_div(klimbs_succ(m), two); - match klimbs_le(half, r) { - 1 => mk_int_prim(rc, 1, klimbs_sub(m, r)), - _ => mk_int_prim(rc, 0, r), - }, - } - } - - fn int_bdiv_prim(rc: RoleCtx, sa: G, a: KLimbs, m: KLimbs) -> KExpr { - match klimbs_is_zero(m) { - 1 => mk_int_prim(rc, 0, store(ListNode.Nil)), - _ => - let r0 = klimbs_mod(a, m); - let r = match sa * (1 - klimbs_is_zero(r0)) { - 1 => klimbs_sub(m, r0), - _ => r0, - }; - let q0 = klimbs_div(a, m); - let qmag = match sa * (1 - klimbs_is_zero(r0)) { 1 => klimbs_succ(q0), _ => q0, }; - let qsign = sa * (1 - klimbs_is_zero(qmag)); - let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))); - let half = klimbs_div(klimbs_succ(m), two); - match klimbs_le(half, r) { - 0 => mk_int_prim(rc, qsign, qmag), - _ => int_add_prim(rc, qsign, qmag, 0, - store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)))), - }, - } - } - - fn try_int_prim_dispatch(rc: RoleCtx, op: G, spine: List‹KExpr›, - types: List‹KExpr›) -> (G, KExpr) { - let sw = whnf_spine(rc, spine, types); - let n = list_length(sw); - match op { - 1 | 2 => match u32_less_than(n, 1) { - 1 => (0, store(KExprNode.BVar(0))), - _ => match try_extract_int_prim(rc, list_lookup(sw, 0)) { - (1, s, a) => - let v = match op { - 2 => mk_nat_lit(a), - _ => mk_int_prim(rc, (1 - s) * (1 - klimbs_is_zero(a)), a), - }; - (1, np_apply_spine(v, list_drop(sw, 1))), - _ => (0, store(KExprNode.BVar(0))), - }, - }, - _ => match u32_less_than(n, 2) { - 1 => (0, store(KExprNode.BVar(0))), - _ => match try_extract_int_prim(rc, list_lookup(sw, 0)) { - (1, sa, a) => try_int_prim_second(rc, op, sw, sa, a), - _ => (0, store(KExprNode.BVar(0))), - }, - }, - } - } - - fn try_int_prim_second(rc: RoleCtx, op: G, sw: List‹KExpr›, - sa: G, a: KLimbs) -> (G, KExpr) { - match op { - 3 | 4 | 5 => match try_extract_nat(rc, list_lookup(sw, 1)) { - (1, b) => - let v = match op { - 3 => int_bmod_prim(rc, sa, a, b), - 4 => int_bdiv_prim(rc, sa, a, b), - _ => - let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))); - let odd = 1 - klimbs_is_zero(klimbs_mod(b, two)); - mk_int_prim(rc, sa * odd, klimbs_pow(a, b)), - }; - (1, np_apply_spine(v, list_drop(sw, 2))), - _ => (0, store(KExprNode.BVar(0))), - }, - _ => match try_extract_int_prim(rc, list_lookup(sw, 1)) { - (1, sb, b) => - let v = match op { - 6 => int_add_prim(rc, sa, a, sb, b), - 7 => int_add_prim(rc, sa, a, (1 - sb) * (1 - klimbs_is_zero(b)), b), - 8 => mk_int_prim(rc, (sa + sb - 2 * sa * sb) - * (1 - klimbs_is_zero(a)) * (1 - klimbs_is_zero(b)), klimbs_mul(a, b)), - 9 => int_emod_prim(rc, sa, a, b), - _ => int_ediv_prim(rc, sa, a, sb, b), - }; - (1, np_apply_spine(v, list_drop(sw, 2))), - _ => (0, store(KExprNode.BVar(0))), - }, - } - } - - -- ============================================================================ - -- Apply spine (rebuild App chain). - -- ============================================================================ - fn np_apply_spine(head: KExpr, spine: List‹KExpr›) -> KExpr { - match load(spine) { - ListNode.Nil => head, - ListNode.Cons(a, rest) => - np_apply_spine(store(KExprNode.App(head, a)), rest), - } - } - - -- ============================================================================ - -- Binop dispatch by op code on two literal args. - -- ============================================================================ - fn try_nat_binop_addr(rc: RoleCtx, op: G, a: KLimbs, b: KLimbs) -> (G, KExpr) { - match op { - 3 => (1, mk_nat_lit(klimbs_normalize(klimbs_add(a, b)))), - 4 => (1, mk_nat_lit(klimbs_normalize(klimbs_sub(a, b)))), - 5 => (1, mk_nat_lit(klimbs_normalize(klimbs_mul(a, b)))), - 6 => (1, mk_nat_lit(klimbs_normalize(klimbs_div(a, b)))), - 7 => (1, mk_nat_lit(klimbs_normalize(klimbs_mod(a, b)))), - 8 => (1, mk_nat_lit(klimbs_normalize(klimbs_gcd(a, b)))), - 9 => (1, mk_nat_lit(klimbs_normalize(klimbs_pow(a, b)))), - 10 => (1, mk_nat_lit(klimbs_normalize(klimbs_land(a, b)))), - 11 => (1, mk_nat_lit(klimbs_normalize(klimbs_lor(a, b)))), - 12 => (1, mk_nat_lit(klimbs_normalize(klimbs_xor_op(a, b)))), - 13 => (1, mk_nat_lit(klimbs_normalize(klimbs_shl(a, b)))), - 14 => (1, mk_nat_lit(klimbs_normalize(klimbs_shr(a, b)))), - 15 => (1, mk_bool(rc, klimbs_eq(a, b))), - 16 => (1, mk_bool(rc, klimbs_le(a, b))), - _ => (0, store(KExprNode.BVar(0))), - } - } - - -- ============================================================================ - -- : nat_offset canonicalization + linear-rec fast path - -- ============================================================================ - - -- If head is Const(nat_add) applied to 2 args with rhs a Lit(Nat), - -- return (1, lhs, limbs). Else (0, _, _). - fn try_match_nat_add(rc: RoleCtx, head: KExpr, args: List‹KExpr›) -> (G, KExpr, KLimbs) { - match load(head) { - KExprNode.Const(caddr, _) => - match role_is(rc, caddr, @role_nat_add()) { - 0 => (0, head, store(ListNode.Nil)), - _ => - match list_length(args) - 2 { - 0 => - let lhs = list_lookup(args, 0); - let rhs = list_lookup(args, 1); - match load(rhs) { - KExprNode.Lit(lit) => - match lit { - KLiteral.Nat(limbs) => (1, lhs, limbs), - _ => (0, head, store(ListNode.Nil)), - }, - _ => (0, head, store(ListNode.Nil)), - }, - _ => (0, head, store(ListNode.Nil)), - }, - }, - _ => (0, head, store(ListNode.Nil)), - } - } - - -- Build `Nat.succ pred` where pred = base if lit==1, - -- else `Nat.add base (Lit lit-1)`. - fn build_succ_offset(rc: RoleCtx, base: KExpr, lit: KLimbs) -> KExpr { - let one = store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], - store(ListNode.Nil))); - let pred_lit_norm = klimbs_normalize(klimbs_sub(lit, one)); - let succ_const = store(KExprNode.Const(role_addr(rc, @role_nat_succ()), store(ListNode.Nil))); - match klimbs_is_zero(pred_lit_norm) { - 1 => store(KExprNode.App(succ_const, base)), - _ => - let add_const = store(KExprNode.Const(role_addr(rc, @role_nat_add()), store(ListNode.Nil))); - let pred_lit_expr = store(KExprNode.Lit(KLiteral.Nat(pred_lit_norm))); - let pred = store(KExprNode.App( - store(KExprNode.App(add_const, base)), - pred_lit_expr)); - store(KExprNode.App(succ_const, pred)), - } - } - - -- Expose one Nat.succ layer if `e` matches `Nat.add base (Lit n)` with - -- n > 0. Enables iota to fire on the exposed successor without - -- unfolding into an n-deep succ tower. Non-matching inputs pass through. - fn cleanup_nat_offset_major(rc: RoleCtx, e: KExpr) -> KExpr { - match load(e) { - KExprNode.Lit(_) => e, - _ => - match collect_spine(e) { - (head, args) => - match load(head) { - KExprNode.Const(_, _) => - match try_match_nat_add(rc, head, args) { - (1, base, lit) => - let lit_norm = klimbs_normalize(lit); - match klimbs_is_zero(lit_norm) { - 1 => e, - _ => build_succ_offset(rc, base, lit_norm), - }, - _ => e, - }, - _ => e, - }, - }, - } - } - - -- Build the compact stuck offset `Nat.add base (Lit n)` applied to - -- `post`. n = 0 collapses to bare `base`. Used by try_nat_linear_rec - -- to keep symbolic-base Nat.rec reductions in a memoizable - -- canonical form (defeq collapses across `Nat.add base k` with the - -- same base + k). - fn mk_nat_offset_stuck(rc: RoleCtx, base_w: KExpr, n: KLimbs, - post: List‹KExpr›) -> (G, KExpr) { - match klimbs_is_zero(n) { - 1 => (1, np_apply_spine(base_w, post)), - _ => - let add_const = store(KExprNode.Const(role_addr(rc, @role_nat_add()), store(ListNode.Nil))); - let off = store(KExprNode.App( - store(KExprNode.App(add_const, base_w)), - mk_nat_lit(n))); - (1, np_apply_spine(off, post)), - } - } - - -- Recognize `λ _ (λ _ (Nat.succ #0))` step function shape. - fn is_nat_succ_ih_step(rc: RoleCtx, step: KExpr) -> G { - match load(step) { - KExprNode.Lam(_, body1) => - match load(body1) { - KExprNode.Lam(_, body2) => - match collect_spine(body2) { - (head, args) => - match load(head) { - KExprNode.Const(caddr, _) => - match role_is(rc, caddr, @role_nat_succ()) { - 0 => 0, - _ => - match list_length(args) - 1 { - 0 => - match load(list_lookup(args, 0)) { - KExprNode.BVar(i) => eq_zero(i), - _ => 0, - }, - _ => 0, - }, - }, - _ => 0, - }, - }, - _ => 0, - }, - _ => 0, - } - } - - -- Fast path for `Nat.rec base (fun _ ih => succ ih) (Lit n)`. Yields - -- `Lit(base + n)` for literal base or the compact stuck offset - -- `Nat.add base (Lit n)` for symbolic base. Caller pre-whnfs step + - -- major (via whnf_spine). - fn try_nat_linear_rec(rc: RoleCtx, spine: List‹KExpr›, nparams: G, nmotives: G, - nminors: G, major_idx: G) -> (G, KExpr) { - match u32_less_than(nminors, 2) { - 1 => (0, store(KExprNode.BVar(0))), - _ => - let raw_major = list_lookup(spine, major_idx); - match try_extract_nat(rc, raw_major) { - (0, _) => (0, store(KExprNode.BVar(0))), - (1, n_klimbs) => - let base_idx = nparams + nmotives; - let step = list_lookup(spine, base_idx + 1); - match is_nat_succ_ih_step(rc, step) { - 0 => (0, store(KExprNode.BVar(0))), - _ => - let base = list_lookup(spine, base_idx); - let post = list_drop(spine, major_idx + 1); - match try_extract_nat(rc, base) { - (1, b_klimbs) => - (1, np_apply_spine(mk_nat_lit(klimbs_add(b_klimbs, n_klimbs)), post)), - _ => mk_nat_offset_stuck(rc, base, n_klimbs, post), - }, - }, - }, - } - } - - -- ============================================================================ - -- Top-level nat dispatch: unary (succ/pred) then binop. - -- Caller must whnf spine args before matching Ctor / Lit / literal. - -- ============================================================================ - fn try_nat_dispatch(rc: RoleCtx, head_addr: Addr, op: G, spine: List‹KExpr›, - types: List‹KExpr›) -> (G, KExpr) { - let spine_len = list_length(spine); - match op { - 1 => - match u32_less_than(spine_len, 1) { - 1 => (0, store(KExprNode.BVar(0))), - _ => - let a0 = list_lookup(spine, 0); - match try_extract_nat(rc, a0) { - (1, na) => - let post = list_drop(spine, 1); - (1, np_apply_spine(mk_nat_lit(klimbs_succ(na)), post)), - _ => (0, store(KExprNode.BVar(0))), - }, - }, - 2 => - match u32_less_than(spine_len, 1) { - 1 => (0, store(KExprNode.BVar(0))), - _ => - let a0 = list_lookup(spine, 0); - match try_extract_nat(rc, a0) { - (1, na) => - let post = list_drop(spine, 1); - (1, np_apply_spine(mk_nat_lit(klimbs_normalize(klimbs_dec(na))), post)), - _ => (0, store(KExprNode.BVar(0))), - }, - }, - _ => try_nat_binop_dispatch(rc, head_addr, op, spine, spine_len), - } - } - - -- Cold-extracted binop arm (mirror try_nat_binop_dispatch, - -- Primitive.lean:1671 / [[reference_aiur_hot_cold_split]]): the - -- binop branch (2× extract + binop-addr chain + offset dispatch + - -- apply_spine) is the widest arm of try_nat_dispatch, taxing - -- every Nat.succ/Nat.pred row when inlined. Its width now only - -- charges rows that actually dispatch a binop. - fn try_nat_binop_dispatch(rc: RoleCtx, head_addr: Addr, op: G, spine: List‹KExpr›, - spine_len: G) -> (G, KExpr) { - match u32_less_than(spine_len, 2) { - 1 => (0, store(KExprNode.BVar(0))), - _ => - let a0 = list_lookup(spine, 0); - let a1 = list_lookup(spine, 1); - match try_extract_nat(rc, a0) { - (1, na) => - match try_extract_nat(rc, a1) { - (1, nb) => - match try_nat_binop_addr(rc, op, na, nb) { - (1, result) => - let post = list_drop(spine, 2); - (1, np_apply_spine(result, post)), - _ => (0, store(KExprNode.BVar(0))), - }, - _ => (0, store(KExprNode.BVar(0))), - }, - _ => - -- Symbolic base: route to the offset-stuck check - -- (mirror try_nat_binop_dispatch's fall-through). - match try_extract_nat(rc, a1) { - (1, nb) => - try_nat_offset_dispatch(rc, head_addr, op, a0, nb, spine), - _ => (0, store(KExprNode.BVar(0))), - }, - }, - } - } - - -- Mirror try_nat_offset_dispatch (Primitive.lean:1712): a binary - -- Nat op whose whnf'd base is symbolic and whose second arg is - -- `Lit nb`. For `Nat.add` (any nb) and `Nat.div`/`Nat.mod` (nb >= 2) - -- the term is irreducible: return verdict 2 = "already stuck in - -- compact offset form" so whnf keeps it instead of delta-unfolding - -- into a succ^nb tower / the division algorithm. Pairs with the - -- offset-aware def_eq (try_def_eq_nat). - fn try_nat_offset_dispatch(rc: RoleCtx, head_addr: Addr, op: G, a0_w: KExpr, nb: KLimbs, - spine: List‹KExpr›) -> (G, KExpr) { - let post = list_drop(spine, 2); - -- `Nat.add` keeps the canonical add-offset shape (shared with - -- the linear-rec collapse). Div/mod MUST keep their own head: - -- routing them through the add builder rewrites `x / n` into - -- `x + n`. - match op { - 3 => - match mk_nat_offset_stuck(rc, a0_w, nb, post) { - (1, stuck) => (2, stuck), - _ => (0, store(KExprNode.BVar(0))), - }, - 6 | 7 => - let ge_two = (1 - klimbs_is_zero(nb)) - * (1 - klimbs_is_zero(klimbs_normalize(klimbs_dec(nb)))); - match ge_two { - 0 => (0, store(KExprNode.BVar(0))), - _ => (2, mk_nat_binop_stuck(head_addr, a0_w, nb, post)), - }, - _ => (0, store(KExprNode.BVar(0))), - } - } - - -- Rebuild a stuck binary Nat op `op base (Lit n)` applied to `post`, - -- preserving the op's own head (div stays div, mod stays mod). - -- Mirror mk_nat_binop_stuck (Primitive.lean:1750), addr-first. - fn mk_nat_binop_stuck(op_addr: Addr, base_w: KExpr, n: KLimbs, - post: List‹KExpr›) -> KExpr { - let op_const = store(KExprNode.Const(op_addr, store(ListNode.Nil))); - let stuck = store(KExprNode.App( - store(KExprNode.App(op_const, base_w)), - mk_nat_lit(n))); - np_apply_spine(stuck, post) - } -⟧ - -end IxVM - -end - diff --git a/Ix/IxVM/Kernel/RoleSpec.lean b/Ix/IxVM/Kernel/RoleSpec.lean deleted file mode 100644 index 9df5c69b5..000000000 --- a/Ix/IxVM/Kernel/RoleSpec.lean +++ /dev/null @@ -1,2698 +0,0 @@ -module -public import Ix.Aiur.Meta -public import Ix.IxVM.KernelTypes - -/-! # The role specifications, as circuit terms - -GENERATED by `lake exe ix codegen` from IxC's specifications -(`Ix.Kernel.Role.spec`, `Role.block`, `Role.deps`) by -`Ix/IxVM/RoleSpecGen.lean`; do not edit. `lake exe ix codegen --check` fails -when it is stale. The validators that read it are in -`Ix/IxVM/Kernel/Roles.lean`. -/ - -public section - -namespace IxVM - -set_option maxRecDepth 16384 in -def roleSpec := ⟦ - -- specVersion 3, specification digest 6d02153ea311f3efd1778c49b2ee5f31e79a0bae95e533a08d4914fc05572d33. - fn spec_version() -> G { - 3 - } - - fn spec_digest() -> Addr { - store([0x6du8, 0x02u8, 0x15u8, 0x3eu8, 0xa3u8, 0x11u8, 0xf3u8, 0xefu8, 0xd1u8, 0x77u8, 0x8cu8, 0x49u8, 0xb2u8, 0xeeu8, 0x5fu8, 0x31u8, 0xe7u8, 0x9au8, 0x0bu8, 0xaeu8, 0x95u8, 0xe5u8, 0x33u8, 0xa0u8, 0x8du8, 0x49u8, 0x14u8, 0xfcu8, 0x05u8, 0x57u8, 0x2du8, 0x33u8]) - } - - fn role_count() -> G { - 103 - } - - fn group_count() -> G { - 72 - } - - fn first_well_founded_group() -> G { - 33 - } - - fn first_equation_group() -> G { - 41 - } - - fn role_nat() -> G { - 0 - } - - fn role_nat_zero() -> G { - 1 - } - - fn role_nat_succ() -> G { - 2 - } - - fn role_nat_rec() -> G { - 3 - } - - fn role_bool() -> G { - 4 - } - - fn role_bool_false() -> G { - 5 - } - - fn role_bool_true() -> G { - 6 - } - - fn role_bool_rec() -> G { - 7 - } - - fn role_eq() -> G { - 8 - } - - fn role_eq_refl() -> G { - 9 - } - - fn role_eq_rec() -> G { - 10 - } - - fn role_punit() -> G { - 11 - } - - fn role_punit_unit() -> G { - 12 - } - - fn role_punit_rec() -> G { - 13 - } - - fn role_empty() -> G { - 14 - } - - fn role_empty_rec() -> G { - 15 - } - - fn role_false() -> G { - 16 - } - - fn role_false_rec() -> G { - 17 - } - - fn role_true() -> G { - 18 - } - - fn role_true_intro() -> G { - 19 - } - - fn role_and() -> G { - 20 - } - - fn role_and_intro() -> G { - 21 - } - - fn role_and_rec() -> G { - 22 - } - - fn role_iff() -> G { - 23 - } - - fn role_iff_intro() -> G { - 24 - } - - fn role_iff_rec() -> G { - 25 - } - - fn role_nonempty() -> G { - 26 - } - - fn role_nonempty_intro() -> G { - 27 - } - - fn role_nonempty_rec() -> G { - 28 - } - - fn role_list() -> G { - 29 - } - - fn role_list_nil() -> G { - 30 - } - - fn role_list_cons() -> G { - 31 - } - - fn role_quot() -> G { - 32 - } - - fn role_quot_mk() -> G { - 33 - } - - fn role_quot_lift() -> G { - 34 - } - - fn role_quot_ind() -> G { - 35 - } - - fn role_quot_sound() -> G { - 36 - } - - fn role_string() -> G { - 37 - } - - fn role_string_of_list() -> G { - 38 - } - - fn role_char() -> G { - 39 - } - - fn role_char_of_nat() -> G { - 40 - } - - fn role_nat_pred() -> G { - 41 - } - - fn role_nat_add() -> G { - 42 - } - - fn role_nat_sub() -> G { - 43 - } - - fn role_nat_mul() -> G { - 44 - } - - fn role_nat_pow() -> G { - 45 - } - - fn role_nat_beq() -> G { - 46 - } - - fn role_nat_ble() -> G { - 47 - } - - fn role_nat_div() -> G { - 48 - } - - fn role_nat_mod() -> G { - 49 - } - - fn role_nat_gcd() -> G { - 50 - } - - fn role_nat_land() -> G { - 51 - } - - fn role_nat_lor() -> G { - 52 - } - - fn role_nat_xor() -> G { - 53 - } - - fn role_nat_shift_left() -> G { - 54 - } - - fn role_nat_shift_right() -> G { - 55 - } - - fn role_propext() -> G { - 56 - } - - fn role_choice() -> G { - 57 - } - - fn role_sorry_ax() -> G { - 58 - } - - fn role_decidable() -> G { - 59 - } - - fn role_decidable_is_true() -> G { - 60 - } - - fn role_decidable_is_false() -> G { - 61 - } - - fn role_not_prop() -> G { - 62 - } - - fn role_of_decide_eq_true() -> G { - 63 - } - - fn role_of_decide_eq_false() -> G { - 64 - } - - fn role_decidable_decide() -> G { - 65 - } - - fn role_nat_le() -> G { - 66 - } - - fn role_nat_dec_eq() -> G { - 67 - } - - fn role_nat_dec_le() -> G { - 68 - } - - fn role_nat_dec_lt() -> G { - 69 - } - - fn role_int() -> G { - 70 - } - - fn role_int_of_nat() -> G { - 71 - } - - fn role_int_neg_succ() -> G { - 72 - } - - fn role_int_neg_of_nat() -> G { - 73 - } - - fn role_int_sub_nat_nat() -> G { - 74 - } - - fn role_int_neg() -> G { - 75 - } - - fn role_int_add() -> G { - 76 - } - - fn role_int_sub() -> G { - 77 - } - - fn role_int_mul() -> G { - 78 - } - - fn role_int_nat_abs() -> G { - 79 - } - - fn role_int_ediv() -> G { - 80 - } - - fn role_int_emod() -> G { - 81 - } - - fn role_int_pow() -> G { - 82 - } - - fn role_bit_vec() -> G { - 83 - } - - fn role_bit_vec_of_nat() -> G { - 84 - } - - fn role_bit_vec_to_nat() -> G { - 85 - } - - fn role_bit_vec_ult() -> G { - 86 - } - - fn role_string_dec_eq() -> G { - 87 - } - - fn role_byte_array() -> G { - 88 - } - - fn role_byte_array_empty() -> G { - 89 - } - - fn role_string_to_byte_array() -> G { - 90 - } - - fn role_list_append() -> G { - 91 - } - - fn role_string_append() -> G { - 92 - } - - fn role_if_then_else() -> G { - 93 - } - - fn role_int_le() -> G { - 94 - } - - fn role_int_dec_eq() -> G { - 95 - } - - fn role_int_dec_le() -> G { - 96 - } - - fn role_int_dec_lt() -> G { - 97 - } - - fn role_int_bmod() -> G { - 98 - } - - fn role_int_bdiv() -> G { - 99 - } - - fn role_char_utf8_size() -> G { - 100 - } - - fn role_string_utf8_byte_size() -> G { - 101 - } - - fn role_string_back() -> G { - 102 - } - - fn role_group(r: G) -> G { - match r { - 4 => 11, - 5 => 11, - 6 => 11, - 7 => 11, - 8 => 1, - 9 => 1, - 10 => 1, - 11 => 2, - 12 => 2, - 13 => 2, - 14 => 3, - 15 => 3, - 16 => 4, - 17 => 4, - 18 => 19, - 19 => 19, - 20 => 20, - 21 => 20, - 22 => 20, - 23 => 21, - 24 => 21, - 25 => 21, - 26 => 22, - 27 => 22, - 28 => 22, - 29 => 8, - 30 => 8, - 31 => 8, - 32 => 5, - 33 => 5, - 34 => 5, - 35 => 5, - 36 => 5, - 37 => 7, - 38 => 10, - 39 => 6, - 40 => 9, - 41 => 12, - 42 => 13, - 43 => 14, - 44 => 15, - 45 => 16, - 46 => 17, - 47 => 18, - 48 => 33, - 49 => 34, - 50 => 35, - 51 => 36, - 52 => 37, - 53 => 38, - 54 => 39, - 55 => 40, - 56 => 23, - 57 => 24, - 58 => 25, - 59 => 27, - 60 => 27, - 61 => 27, - 62 => 26, - 63 => 42, - 64 => 43, - 65 => 41, - 66 => 28, - 67 => 44, - 68 => 45, - 69 => 46, - 70 => 29, - 71 => 29, - 72 => 29, - 73 => 47, - 74 => 48, - 75 => 49, - 76 => 50, - 77 => 51, - 78 => 52, - 79 => 53, - 80 => 54, - 81 => 55, - 82 => 56, - 83 => 31, - 84 => 31, - 85 => 57, - 86 => 58, - 87 => 59, - 88 => 32, - 89 => 32, - 90 => 60, - 91 => 61, - 92 => 62, - 93 => 63, - 94 => 30, - 95 => 64, - 96 => 65, - 97 => 66, - 98 => 67, - 99 => 68, - 100 => 69, - 101 => 70, - 102 => 71, - _ => 0, - } - } - - fn group_roles(g: G) -> List‹G› { - match g { - 0 => store(ListNode.Cons(0, store(ListNode.Cons(1, store(ListNode.Cons(2, store(ListNode.Cons(3, store(ListNode.Nil))))))))), - 1 => store(ListNode.Cons(8, store(ListNode.Cons(9, store(ListNode.Cons(10, store(ListNode.Nil))))))), - 2 => store(ListNode.Cons(11, store(ListNode.Cons(12, store(ListNode.Cons(13, store(ListNode.Nil))))))), - 3 => store(ListNode.Cons(14, store(ListNode.Cons(15, store(ListNode.Nil))))), - 4 => store(ListNode.Cons(16, store(ListNode.Cons(17, store(ListNode.Nil))))), - 5 => store(ListNode.Cons(32, store(ListNode.Cons(33, store(ListNode.Cons(34, store(ListNode.Cons(35, store(ListNode.Cons(36, store(ListNode.Nil))))))))))), - 6 => store(ListNode.Cons(39, store(ListNode.Nil))), - 7 => store(ListNode.Cons(37, store(ListNode.Nil))), - 8 => store(ListNode.Cons(29, store(ListNode.Cons(30, store(ListNode.Cons(31, store(ListNode.Nil))))))), - 9 => store(ListNode.Cons(40, store(ListNode.Nil))), - 10 => store(ListNode.Cons(38, store(ListNode.Nil))), - 11 => store(ListNode.Cons(4, store(ListNode.Cons(5, store(ListNode.Cons(6, store(ListNode.Cons(7, store(ListNode.Nil))))))))), - 12 => store(ListNode.Cons(41, store(ListNode.Nil))), - 13 => store(ListNode.Cons(42, store(ListNode.Nil))), - 14 => store(ListNode.Cons(43, store(ListNode.Nil))), - 15 => store(ListNode.Cons(44, store(ListNode.Nil))), - 16 => store(ListNode.Cons(45, store(ListNode.Nil))), - 17 => store(ListNode.Cons(46, store(ListNode.Nil))), - 18 => store(ListNode.Cons(47, store(ListNode.Nil))), - 19 => store(ListNode.Cons(18, store(ListNode.Cons(19, store(ListNode.Nil))))), - 20 => store(ListNode.Cons(20, store(ListNode.Cons(21, store(ListNode.Cons(22, store(ListNode.Nil))))))), - 21 => store(ListNode.Cons(23, store(ListNode.Cons(24, store(ListNode.Cons(25, store(ListNode.Nil))))))), - 22 => store(ListNode.Cons(26, store(ListNode.Cons(27, store(ListNode.Cons(28, store(ListNode.Nil))))))), - 23 => store(ListNode.Cons(56, store(ListNode.Nil))), - 24 => store(ListNode.Cons(57, store(ListNode.Nil))), - 25 => store(ListNode.Cons(58, store(ListNode.Nil))), - 26 => store(ListNode.Cons(62, store(ListNode.Nil))), - 27 => store(ListNode.Cons(59, store(ListNode.Cons(60, store(ListNode.Cons(61, store(ListNode.Nil))))))), - 28 => store(ListNode.Cons(66, store(ListNode.Nil))), - 29 => store(ListNode.Cons(70, store(ListNode.Cons(71, store(ListNode.Cons(72, store(ListNode.Nil))))))), - 30 => store(ListNode.Cons(94, store(ListNode.Nil))), - 31 => store(ListNode.Cons(83, store(ListNode.Cons(84, store(ListNode.Nil))))), - 32 => store(ListNode.Cons(88, store(ListNode.Cons(89, store(ListNode.Nil))))), - 33 => store(ListNode.Cons(48, store(ListNode.Nil))), - 34 => store(ListNode.Cons(49, store(ListNode.Nil))), - 35 => store(ListNode.Cons(50, store(ListNode.Nil))), - 36 => store(ListNode.Cons(51, store(ListNode.Nil))), - 37 => store(ListNode.Cons(52, store(ListNode.Nil))), - 38 => store(ListNode.Cons(53, store(ListNode.Nil))), - 39 => store(ListNode.Cons(54, store(ListNode.Nil))), - 40 => store(ListNode.Cons(55, store(ListNode.Nil))), - 41 => store(ListNode.Cons(65, store(ListNode.Nil))), - 42 => store(ListNode.Cons(63, store(ListNode.Nil))), - 43 => store(ListNode.Cons(64, store(ListNode.Nil))), - 44 => store(ListNode.Cons(67, store(ListNode.Nil))), - 45 => store(ListNode.Cons(68, store(ListNode.Nil))), - 46 => store(ListNode.Cons(69, store(ListNode.Nil))), - 47 => store(ListNode.Cons(73, store(ListNode.Nil))), - 48 => store(ListNode.Cons(74, store(ListNode.Nil))), - 49 => store(ListNode.Cons(75, store(ListNode.Nil))), - 50 => store(ListNode.Cons(76, store(ListNode.Nil))), - 51 => store(ListNode.Cons(77, store(ListNode.Nil))), - 52 => store(ListNode.Cons(78, store(ListNode.Nil))), - 53 => store(ListNode.Cons(79, store(ListNode.Nil))), - 54 => store(ListNode.Cons(80, store(ListNode.Nil))), - 55 => store(ListNode.Cons(81, store(ListNode.Nil))), - 56 => store(ListNode.Cons(82, store(ListNode.Nil))), - 57 => store(ListNode.Cons(85, store(ListNode.Nil))), - 58 => store(ListNode.Cons(86, store(ListNode.Nil))), - 59 => store(ListNode.Cons(87, store(ListNode.Nil))), - 60 => store(ListNode.Cons(90, store(ListNode.Nil))), - 61 => store(ListNode.Cons(91, store(ListNode.Nil))), - 62 => store(ListNode.Cons(92, store(ListNode.Nil))), - 63 => store(ListNode.Cons(93, store(ListNode.Nil))), - 64 => store(ListNode.Cons(95, store(ListNode.Nil))), - 65 => store(ListNode.Cons(96, store(ListNode.Nil))), - 66 => store(ListNode.Cons(97, store(ListNode.Nil))), - 67 => store(ListNode.Cons(98, store(ListNode.Nil))), - 68 => store(ListNode.Cons(99, store(ListNode.Nil))), - 69 => store(ListNode.Cons(100, store(ListNode.Nil))), - 70 => store(ListNode.Cons(101, store(ListNode.Nil))), - 71 => store(ListNode.Cons(102, store(ListNode.Nil))), - _ => store(ListNode.Nil), - } - } - - fn group_needs(g: G) -> List‹G› { - match g { - 5 => store(ListNode.Cons(8, store(ListNode.Nil))), - 9 => store(ListNode.Cons(0, store(ListNode.Cons(39, store(ListNode.Nil))))), - 10 => store(ListNode.Cons(29, store(ListNode.Cons(39, store(ListNode.Cons(37, store(ListNode.Nil))))))), - 12 => store(ListNode.Cons(0, store(ListNode.Nil))), - 13 => store(ListNode.Cons(0, store(ListNode.Nil))), - 14 => store(ListNode.Cons(0, store(ListNode.Cons(41, store(ListNode.Nil))))), - 15 => store(ListNode.Cons(0, store(ListNode.Cons(42, store(ListNode.Nil))))), - 16 => store(ListNode.Cons(0, store(ListNode.Cons(42, store(ListNode.Cons(44, store(ListNode.Nil))))))), - 17 => store(ListNode.Cons(0, store(ListNode.Cons(4, store(ListNode.Nil))))), - 18 => store(ListNode.Cons(0, store(ListNode.Cons(4, store(ListNode.Nil))))), - 23 => store(ListNode.Cons(23, store(ListNode.Cons(8, store(ListNode.Nil))))), - 24 => store(ListNode.Cons(26, store(ListNode.Nil))), - 25 => store(ListNode.Cons(4, store(ListNode.Nil))), - 27 => store(ListNode.Cons(62, store(ListNode.Nil))), - 28 => store(ListNode.Cons(0, store(ListNode.Nil))), - 29 => store(ListNode.Cons(0, store(ListNode.Nil))), - 30 => store(ListNode.Cons(70, store(ListNode.Nil))), - 31 => store(ListNode.Cons(0, store(ListNode.Nil))), - 33 => store(ListNode.Cons(0, store(ListNode.Cons(41, store(ListNode.Cons(43, store(ListNode.Cons(47, store(ListNode.Cons(4, store(ListNode.Cons(8, store(ListNode.Nil))))))))))))), - 34 => store(ListNode.Cons(0, store(ListNode.Cons(41, store(ListNode.Cons(43, store(ListNode.Cons(47, store(ListNode.Cons(4, store(ListNode.Cons(8, store(ListNode.Nil))))))))))))), - 35 => store(ListNode.Cons(0, store(ListNode.Cons(47, store(ListNode.Cons(49, store(ListNode.Cons(4, store(ListNode.Cons(8, store(ListNode.Nil))))))))))), - 36 => store(ListNode.Cons(0, store(ListNode.Cons(42, store(ListNode.Cons(44, store(ListNode.Cons(47, store(ListNode.Cons(48, store(ListNode.Cons(49, store(ListNode.Cons(4, store(ListNode.Cons(8, store(ListNode.Nil))))))))))))))))), - 37 => store(ListNode.Cons(0, store(ListNode.Cons(42, store(ListNode.Cons(43, store(ListNode.Cons(44, store(ListNode.Cons(47, store(ListNode.Cons(48, store(ListNode.Cons(49, store(ListNode.Cons(4, store(ListNode.Cons(8, store(ListNode.Nil))))))))))))))))))), - 38 => store(ListNode.Cons(0, store(ListNode.Cons(42, store(ListNode.Cons(44, store(ListNode.Cons(47, store(ListNode.Cons(48, store(ListNode.Cons(49, store(ListNode.Cons(4, store(ListNode.Cons(8, store(ListNode.Nil))))))))))))))))), - 39 => store(ListNode.Cons(0, store(ListNode.Cons(43, store(ListNode.Cons(44, store(ListNode.Cons(47, store(ListNode.Cons(4, store(ListNode.Cons(8, store(ListNode.Nil))))))))))))), - 40 => store(ListNode.Cons(0, store(ListNode.Cons(43, store(ListNode.Cons(47, store(ListNode.Cons(48, store(ListNode.Cons(4, store(ListNode.Cons(8, store(ListNode.Nil))))))))))))), - 41 => store(ListNode.Cons(59, store(ListNode.Cons(62, store(ListNode.Cons(4, store(ListNode.Cons(8, store(ListNode.Nil))))))))), - 42 => store(ListNode.Cons(59, store(ListNode.Cons(65, store(ListNode.Cons(4, store(ListNode.Cons(8, store(ListNode.Nil))))))))), - 43 => store(ListNode.Cons(59, store(ListNode.Cons(65, store(ListNode.Cons(62, store(ListNode.Cons(4, store(ListNode.Cons(8, store(ListNode.Nil))))))))))), - 44 => store(ListNode.Cons(0, store(ListNode.Cons(4, store(ListNode.Cons(8, store(ListNode.Cons(59, store(ListNode.Cons(65, store(ListNode.Cons(46, store(ListNode.Nil))))))))))))), - 45 => store(ListNode.Cons(0, store(ListNode.Cons(4, store(ListNode.Cons(8, store(ListNode.Cons(59, store(ListNode.Cons(65, store(ListNode.Cons(66, store(ListNode.Cons(47, store(ListNode.Nil))))))))))))))), - 46 => store(ListNode.Cons(0, store(ListNode.Cons(8, store(ListNode.Cons(59, store(ListNode.Cons(66, store(ListNode.Cons(68, store(ListNode.Nil))))))))))), - 47 => store(ListNode.Cons(0, store(ListNode.Cons(70, store(ListNode.Cons(8, store(ListNode.Nil))))))), - 48 => store(ListNode.Cons(0, store(ListNode.Cons(70, store(ListNode.Cons(4, store(ListNode.Cons(8, store(ListNode.Cons(41, store(ListNode.Cons(43, store(ListNode.Cons(47, store(ListNode.Nil))))))))))))))), - 49 => store(ListNode.Cons(0, store(ListNode.Cons(70, store(ListNode.Cons(8, store(ListNode.Cons(73, store(ListNode.Nil))))))))), - 50 => store(ListNode.Cons(0, store(ListNode.Cons(70, store(ListNode.Cons(8, store(ListNode.Cons(42, store(ListNode.Cons(74, store(ListNode.Nil))))))))))), - 51 => store(ListNode.Cons(70, store(ListNode.Cons(8, store(ListNode.Cons(76, store(ListNode.Cons(75, store(ListNode.Nil))))))))), - 52 => store(ListNode.Cons(0, store(ListNode.Cons(70, store(ListNode.Cons(8, store(ListNode.Cons(44, store(ListNode.Cons(73, store(ListNode.Nil))))))))))), - 53 => store(ListNode.Cons(0, store(ListNode.Cons(70, store(ListNode.Cons(8, store(ListNode.Nil))))))), - 54 => store(ListNode.Cons(0, store(ListNode.Cons(70, store(ListNode.Cons(8, store(ListNode.Cons(48, store(ListNode.Cons(75, store(ListNode.Nil))))))))))), - 55 => store(ListNode.Cons(0, store(ListNode.Cons(70, store(ListNode.Cons(8, store(ListNode.Cons(49, store(ListNode.Cons(74, store(ListNode.Nil))))))))))), - 56 => store(ListNode.Cons(0, store(ListNode.Cons(70, store(ListNode.Cons(4, store(ListNode.Cons(8, store(ListNode.Cons(45, store(ListNode.Cons(49, store(ListNode.Cons(46, store(ListNode.Cons(75, store(ListNode.Nil))))))))))))))))), - 57 => store(ListNode.Cons(0, store(ListNode.Cons(8, store(ListNode.Cons(83, store(ListNode.Cons(49, store(ListNode.Cons(45, store(ListNode.Nil))))))))))), - 58 => store(ListNode.Cons(0, store(ListNode.Cons(4, store(ListNode.Cons(8, store(ListNode.Cons(83, store(ListNode.Cons(49, store(ListNode.Cons(45, store(ListNode.Cons(47, store(ListNode.Nil))))))))))))))), - 59 => store(ListNode.Cons(37, store(ListNode.Cons(4, store(ListNode.Cons(8, store(ListNode.Cons(59, store(ListNode.Cons(65, store(ListNode.Nil))))))))))), - 60 => store(ListNode.Cons(37, store(ListNode.Cons(29, store(ListNode.Cons(39, store(ListNode.Cons(38, store(ListNode.Cons(8, store(ListNode.Cons(88, store(ListNode.Nil))))))))))))), - 61 => store(ListNode.Cons(29, store(ListNode.Cons(8, store(ListNode.Nil))))), - 62 => store(ListNode.Cons(37, store(ListNode.Cons(29, store(ListNode.Cons(39, store(ListNode.Cons(38, store(ListNode.Cons(8, store(ListNode.Cons(91, store(ListNode.Nil))))))))))))), - 63 => store(ListNode.Cons(59, store(ListNode.Cons(62, store(ListNode.Cons(8, store(ListNode.Nil))))))), - 64 => store(ListNode.Cons(0, store(ListNode.Cons(70, store(ListNode.Cons(4, store(ListNode.Cons(8, store(ListNode.Cons(59, store(ListNode.Cons(65, store(ListNode.Cons(46, store(ListNode.Nil))))))))))))))), - 65 => store(ListNode.Cons(0, store(ListNode.Cons(70, store(ListNode.Cons(4, store(ListNode.Cons(8, store(ListNode.Cons(59, store(ListNode.Cons(65, store(ListNode.Cons(94, store(ListNode.Cons(47, store(ListNode.Nil))))))))))))))))), - 66 => store(ListNode.Cons(0, store(ListNode.Cons(70, store(ListNode.Cons(8, store(ListNode.Cons(59, store(ListNode.Cons(94, store(ListNode.Cons(76, store(ListNode.Cons(96, store(ListNode.Nil))))))))))))))), - 67 => store(ListNode.Cons(0, store(ListNode.Cons(70, store(ListNode.Cons(8, store(ListNode.Cons(93, store(ListNode.Cons(94, store(ListNode.Cons(76, store(ListNode.Cons(77, store(ListNode.Cons(80, store(ListNode.Cons(81, store(ListNode.Cons(97, store(ListNode.Nil))))))))))))))))))))), - 68 => store(ListNode.Cons(0, store(ListNode.Cons(70, store(ListNode.Cons(8, store(ListNode.Cons(93, store(ListNode.Cons(94, store(ListNode.Cons(76, store(ListNode.Cons(80, store(ListNode.Cons(81, store(ListNode.Cons(97, store(ListNode.Cons(67, store(ListNode.Nil))))))))))))))))))))), - 69 => store(ListNode.Cons(0, store(ListNode.Cons(39, store(ListNode.Cons(40, store(ListNode.Cons(4, store(ListNode.Cons(8, store(ListNode.Cons(44, store(ListNode.Cons(47, store(ListNode.Nil))))))))))))))), - 70 => store(ListNode.Cons(0, store(ListNode.Cons(37, store(ListNode.Cons(29, store(ListNode.Cons(39, store(ListNode.Cons(38, store(ListNode.Cons(8, store(ListNode.Cons(42, store(ListNode.Cons(100, store(ListNode.Nil))))))))))))))))), - 71 => store(ListNode.Cons(0, store(ListNode.Cons(37, store(ListNode.Cons(29, store(ListNode.Cons(39, store(ListNode.Cons(40, store(ListNode.Cons(38, store(ListNode.Cons(8, store(ListNode.Cons(44, store(ListNode.Nil))))))))))))))))), - _ => store(ListNode.Nil), - } - } - - fn role_spec_kind(r: G) -> G { - match r { - 4 => 1, - 5 => 1, - 6 => 1, - 7 => 1, - 18 => 1, - 19 => 1, - 20 => 1, - 21 => 1, - 22 => 1, - 29 => 1, - 30 => 1, - 31 => 1, - 37 => 1, - 38 => 1, - 39 => 1, - 40 => 1, - 41 => 2, - 42 => 2, - 43 => 2, - 44 => 2, - 45 => 2, - 46 => 2, - 47 => 2, - 48 => 2, - 49 => 2, - 50 => 2, - 51 => 2, - 52 => 2, - 53 => 2, - 54 => 2, - 55 => 2, - 56 => 3, - 57 => 3, - 58 => 4, - 59 => 1, - 60 => 1, - 61 => 1, - 62 => 1, - 63 => 1, - 64 => 1, - 65 => 5, - 66 => 1, - 67 => 5, - 68 => 5, - 69 => 5, - 70 => 1, - 71 => 1, - 72 => 1, - 73 => 5, - 74 => 5, - 75 => 5, - 76 => 5, - 77 => 5, - 78 => 5, - 79 => 5, - 80 => 5, - 81 => 5, - 82 => 5, - 83 => 1, - 84 => 1, - 85 => 5, - 86 => 5, - 87 => 5, - 88 => 1, - 89 => 1, - 90 => 5, - 91 => 5, - 92 => 5, - 93 => 5, - 94 => 1, - 95 => 5, - 96 => 5, - 97 => 5, - 98 => 5, - 99 => 5, - 100 => 5, - 101 => 5, - 102 => 5, - _ => 0, - } - } - - fn role_levels(r: G) -> G { - match r { - 3 => 1, - 7 => 1, - 8 => 1, - 9 => 1, - 10 => 2, - 11 => 1, - 12 => 1, - 13 => 2, - 15 => 1, - 17 => 1, - 22 => 1, - 25 => 1, - 26 => 1, - 27 => 1, - 28 => 1, - 29 => 1, - 30 => 1, - 31 => 1, - 32 => 1, - 33 => 1, - 34 => 2, - 35 => 1, - 36 => 1, - 57 => 1, - 58 => 1, - 91 => 1, - 93 => 1, - _ => 0, - } - } - - fn role_member_kind(r: G) -> G { - match r { - 1 => 1, - 2 => 1, - 3 => 2, - 9 => 1, - 10 => 2, - 12 => 1, - 13 => 2, - 15 => 2, - 17 => 2, - 24 => 1, - 25 => 2, - 27 => 1, - 28 => 2, - 32 => 4, - 33 => 5, - 34 => 6, - 35 => 7, - 36 => 3, - _ => 0, - } - } - - fn role_ctor_of(r: G) -> (G, G, G, G) { - match r { - 2 => (0, 1, 0, 1), - 9 => (8, 0, 2, 0), - 12 => (11, 0, 0, 0), - 24 => (23, 0, 2, 2), - 27 => (26, 0, 1, 1), - _ => (0, 0, 0, 0), - } - } - - fn role_ctor_count(r: G) -> G { - match r { - 0 => 2, - 8 => 1, - 11 => 1, - 23 => 1, - 26 => 1, - _ => 0, - } - } - - fn role_type(tbl: RoleTable, r: G) -> KExpr { - match r { - 0 => store(KExprNode.Srt(store(KLevelNode.Succ(store(KLevelNode.Zero))))), - 1 => store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))), - 2 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))); - store(KExprNode.Forall(x0, x0)), - 3 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.BVar(0)); - let x3 = store(KExprNode.BVar(3)); - store(KExprNode.Forall(store(KExprNode.Forall(x1, store(KExprNode.Srt(store(KLevelNode.Param(0)))))), store(KExprNode.Forall(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))), store(KExprNode.Forall(store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.BVar(2)), x2)), store(KExprNode.App(x3, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(1)))))))))), store(KExprNode.Forall(x1, store(KExprNode.App(x3, x2)))))))))), - 4 => store(KExprNode.Srt(store(KLevelNode.Succ(store(KLevelNode.Zero))))), - 5 => store(KExprNode.Const(role_bound_addr(tbl, 4), store(ListNode.Nil))), - 6 => store(KExprNode.Const(role_bound_addr(tbl, 4), store(ListNode.Nil))), - 7 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 4), x0)); - let x2 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(store(KExprNode.Forall(x1, store(KExprNode.Srt(store(KLevelNode.Param(0)))))), store(KExprNode.Forall(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.BVar(1)), store(KExprNode.Const(role_bound_addr(tbl, 6), x0)))), store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.BVar(3)), x2)))))))))), - 8 => store(KExprNode.Forall(store(KExprNode.Srt(store(KLevelNode.Param(0)))), store(KExprNode.Forall(store(KExprNode.BVar(0)), store(KExprNode.Forall(store(KExprNode.BVar(1)), store(KExprNode.Srt(store(KLevelNode.Zero))))))))), - 9 => - let x0 = store(KLevelNode.Param(0)); - let x1 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(store(KExprNode.Srt(x0)), store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(x0, store(ListNode.Nil))))), store(KExprNode.BVar(1)))), x1)), x1)))))), - 10 => - let x0 = store(KLevelNode.Param(1)); - let x1 = store(KExprNode.BVar(0)); - let x2 = store(KExprNode.BVar(1)); - let x3 = store(ListNode.Cons(x0, store(ListNode.Nil))); - let x4 = store(KExprNode.Const(role_bound_addr(tbl, 8), x3)); - let x5 = store(KExprNode.BVar(2)); - let x6 = store(KExprNode.BVar(3)); - store(KExprNode.Forall(store(KExprNode.Srt(x0)), store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.Forall(x2, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x4, x5)), x2)), x1)), store(KExprNode.Srt(store(KLevelNode.Param(0)))))))), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x1, x2)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 9), x3)), x5)), x2)))), store(KExprNode.Forall(x6, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x4, store(KExprNode.BVar(4)))), x6)), x1)), store(KExprNode.App(store(KExprNode.App(x6, x2)), x1)))))))))))))), - 11 => store(KExprNode.Srt(store(KLevelNode.Param(0)))), - 12 => store(KExprNode.Const(role_bound_addr(tbl, 11), store(ListNode.Cons(store(KLevelNode.Param(0)), store(ListNode.Nil))))), - 13 => - let x0 = store(ListNode.Cons(store(KLevelNode.Param(1)), store(ListNode.Nil))); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 11), x0)); - let x2 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(store(KExprNode.Forall(x1, store(KExprNode.Srt(store(KLevelNode.Param(0)))))), store(KExprNode.Forall(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 12), x0)))), store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.BVar(2)), x2)))))))), - 14 => store(KExprNode.Srt(store(KLevelNode.Succ(store(KLevelNode.Zero))))), - 15 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 14), store(ListNode.Nil))); - store(KExprNode.Forall(store(KExprNode.Forall(x0, store(KExprNode.Srt(store(KLevelNode.Param(0)))))), store(KExprNode.Forall(x0, store(KExprNode.App(store(KExprNode.BVar(1)), store(KExprNode.BVar(0)))))))), - 17 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 16), store(ListNode.Nil))); - store(KExprNode.Forall(store(KExprNode.Forall(x0, store(KExprNode.Srt(store(KLevelNode.Param(0)))))), store(KExprNode.Forall(x0, store(KExprNode.App(store(KExprNode.BVar(1)), store(KExprNode.BVar(0)))))))), - 19 => store(KExprNode.Const(role_bound_addr(tbl, 18), store(ListNode.Nil))), - 20 => - let x0 = store(KExprNode.Srt(store(KLevelNode.Zero))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, x0)))), - 21 => - let x0 = store(KExprNode.Srt(store(KLevelNode.Zero))); - let x1 = store(KExprNode.BVar(1)); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 20), store(ListNode.Nil))), store(KExprNode.BVar(3)))), store(KExprNode.BVar(2)))))))))))), - 22 => - let x0 = store(KExprNode.Srt(store(KLevelNode.Zero))); - let x1 = store(ListNode.Nil); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 20), x1)); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.BVar(0)); - let x5 = store(KExprNode.BVar(2)); - let x6 = store(KExprNode.BVar(3)); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, store(KExprNode.Forall(store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x2, x3)), x4)), store(KExprNode.Srt(store(KLevelNode.Param(0)))))), store(KExprNode.Forall(store(KExprNode.Forall(x5, store(KExprNode.Forall(x5, store(KExprNode.App(x5, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 21), x1)), store(KExprNode.BVar(4)))), x6)), x3)), x4)))))))), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x2, x6)), x5)), store(KExprNode.App(x5, x4)))))))))))), - 23 => - let x0 = store(KExprNode.Srt(store(KLevelNode.Zero))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, x0)))), - 24 => - let x0 = store(KExprNode.Srt(store(KLevelNode.Zero))); - let x1 = store(KExprNode.BVar(1)); - let x2 = store(KExprNode.BVar(3)); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, store(KExprNode.Forall(store(KExprNode.Forall(x1, x1)), store(KExprNode.Forall(store(KExprNode.Forall(x1, x2)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 23), store(ListNode.Nil))), x2)), store(KExprNode.BVar(2)))))))))))), - 25 => - let x0 = store(KExprNode.Srt(store(KLevelNode.Zero))); - let x1 = store(ListNode.Nil); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 23), x1)); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.BVar(0)); - let x5 = store(KExprNode.BVar(2)); - let x6 = store(KExprNode.BVar(4)); - let x7 = store(KExprNode.BVar(3)); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, store(KExprNode.Forall(store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x2, x3)), x4)), store(KExprNode.Srt(store(KLevelNode.Param(0)))))), store(KExprNode.Forall(store(KExprNode.Forall(store(KExprNode.Forall(x5, x5)), store(KExprNode.Forall(store(KExprNode.Forall(x5, x6)), store(KExprNode.App(x5, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 24), x1)), x6)), x7)), x3)), x4)))))))), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x2, x7)), x5)), store(KExprNode.App(x5, x4)))))))))))), - 26 => store(KExprNode.Forall(store(KExprNode.Srt(store(KLevelNode.Param(0)))), store(KExprNode.Srt(store(KLevelNode.Zero))))), - 27 => - let x0 = store(KLevelNode.Param(0)); - store(KExprNode.Forall(store(KExprNode.Srt(x0)), store(KExprNode.Forall(store(KExprNode.BVar(0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 26), store(ListNode.Cons(x0, store(ListNode.Nil))))), store(KExprNode.BVar(1)))))))), - 28 => - let x0 = store(KLevelNode.Param(0)); - let x1 = store(ListNode.Cons(x0, store(ListNode.Nil))); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 26), x1)); - let x3 = store(KExprNode.BVar(0)); - let x4 = store(KExprNode.BVar(1)); - let x5 = store(KExprNode.BVar(2)); - store(KExprNode.Forall(store(KExprNode.Srt(x0)), store(KExprNode.Forall(store(KExprNode.Forall(store(KExprNode.App(x2, x3)), store(KExprNode.Srt(store(KLevelNode.Zero))))), store(KExprNode.Forall(store(KExprNode.Forall(x4, store(KExprNode.App(x4, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 27), x1)), x5)), x3)))))), store(KExprNode.Forall(store(KExprNode.App(x2, x5)), store(KExprNode.App(x5, x3)))))))))), - 29 => - let x0 = store(KExprNode.Srt(store(KLevelNode.Succ(store(KLevelNode.Param(0)))))); - store(KExprNode.Forall(x0, x0)), - 30 => - let x0 = store(KLevelNode.Param(0)); - store(KExprNode.Forall(store(KExprNode.Srt(store(KLevelNode.Succ(x0)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 29), store(ListNode.Cons(x0, store(ListNode.Nil))))), store(KExprNode.BVar(0)))))), - 31 => - let x0 = store(KLevelNode.Param(0)); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 29), store(ListNode.Cons(x0, store(ListNode.Nil))))); - store(KExprNode.Forall(store(KExprNode.Srt(store(KLevelNode.Succ(x0)))), store(KExprNode.Forall(store(KExprNode.BVar(0)), store(KExprNode.Forall(store(KExprNode.App(x1, store(KExprNode.BVar(1)))), store(KExprNode.App(x1, store(KExprNode.BVar(2)))))))))), - 32 => - let x0 = store(KExprNode.Srt(store(KLevelNode.Param(0)))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(store(KExprNode.Forall(store(KExprNode.BVar(0)), store(KExprNode.Forall(store(KExprNode.BVar(1)), store(KExprNode.Srt(store(KLevelNode.Zero))))))), x0)))), - 33 => - let x0 = store(KLevelNode.Param(0)); - let x1 = store(KExprNode.BVar(1)); - store(KExprNode.Forall(store(KExprNode.Srt(x0)), store(KExprNode.Forall(store(KExprNode.Forall(store(KExprNode.BVar(0)), store(KExprNode.Forall(x1, store(KExprNode.Srt(store(KLevelNode.Zero))))))), store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 32), store(ListNode.Cons(x0, store(ListNode.Nil))))), store(KExprNode.BVar(2)))), x1)))))))), - 34 => - let x0 = store(KLevelNode.Param(0)); - let x1 = store(KExprNode.BVar(0)); - let x2 = store(KExprNode.BVar(1)); - let x3 = store(KLevelNode.Param(1)); - let x4 = store(KExprNode.BVar(2)); - let x5 = store(KExprNode.BVar(3)); - let x6 = store(KExprNode.BVar(4)); - let x7 = store(ListNode.Nil); - store(KExprNode.Forall(store(KExprNode.Srt(x0)), store(KExprNode.Forall(store(KExprNode.Forall(x1, store(KExprNode.Forall(x2, store(KExprNode.Srt(store(KLevelNode.Zero))))))), store(KExprNode.Forall(store(KExprNode.Srt(x3)), store(KExprNode.Forall(store(KExprNode.Forall(x4, x2)), store(KExprNode.Forall(store(KExprNode.Forall(x5, store(KExprNode.Forall(x6, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x6, x2)), x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(x3, x7)))), x6)), store(KExprNode.App(x5, x4)))), store(KExprNode.App(x5, x2)))))))))), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 32), store(ListNode.Cons(x0, x7)))), x6)), x5)), x5)))))))))))), - 35 => - let x0 = store(KLevelNode.Param(0)); - let x1 = store(KExprNode.BVar(0)); - let x2 = store(KExprNode.BVar(1)); - let x3 = store(KExprNode.Srt(store(KLevelNode.Zero))); - let x4 = store(ListNode.Cons(x0, store(ListNode.Nil))); - let x5 = store(KExprNode.Const(role_bound_addr(tbl, 32), x4)); - let x6 = store(KExprNode.BVar(2)); - let x7 = store(KExprNode.BVar(3)); - store(KExprNode.Forall(store(KExprNode.Srt(x0)), store(KExprNode.Forall(store(KExprNode.Forall(x1, store(KExprNode.Forall(x2, x3)))), store(KExprNode.Forall(store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x5, x2)), x1)), x3)), store(KExprNode.Forall(store(KExprNode.Forall(x6, store(KExprNode.App(x2, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 33), x4)), x7)), x6)), x1)))))), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x5, x7)), x6)), store(KExprNode.App(x6, x1)))))))))))), - 36 => - let x0 = store(KLevelNode.Param(0)); - let x1 = store(KExprNode.BVar(0)); - let x2 = store(KExprNode.BVar(1)); - let x3 = store(KExprNode.BVar(2)); - let x4 = store(ListNode.Cons(x0, store(ListNode.Nil))); - let x5 = store(KExprNode.BVar(4)); - let x6 = store(KExprNode.BVar(3)); - let x7 = store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 33), x4)), x5)), x6)); - store(KExprNode.Forall(store(KExprNode.Srt(x0)), store(KExprNode.Forall(store(KExprNode.Forall(x1, store(KExprNode.Forall(x2, store(KExprNode.Srt(store(KLevelNode.Zero))))))), store(KExprNode.Forall(x2, store(KExprNode.Forall(x3, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x3, x2)), x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), x4)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 32), x4)), x5)), x6)))), store(KExprNode.App(x7, x3)))), store(KExprNode.App(x7, x2)))))))))))))), - 37 => store(KExprNode.Srt(store(KLevelNode.Succ(store(KLevelNode.Zero))))), - 38 => - let x0 = store(ListNode.Nil); - store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 29), store(ListNode.Cons(store(KLevelNode.Zero), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 39), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 37), x0)))), - 39 => store(KExprNode.Srt(store(KLevelNode.Succ(store(KLevelNode.Zero))))), - 40 => - let x0 = store(ListNode.Nil); - store(KExprNode.Forall(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.Const(role_bound_addr(tbl, 39), x0)))), - 41 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))); - store(KExprNode.Forall(x0, x0)), - 42 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, x0)))), - 43 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, x0)))), - 44 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, x0)))), - 45 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, x0)))), - 46 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))))), - 47 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))))), - 48 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, x0)))), - 49 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, x0)))), - 50 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, x0)))), - 51 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, x0)))), - 52 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, x0)))), - 53 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, x0)))), - 54 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, x0)))), - 55 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, x0)))), - 56 => - let x0 = store(KLevelNode.Zero); - let x1 = store(KExprNode.Srt(x0)); - let x2 = store(ListNode.Nil); - let x3 = store(KExprNode.BVar(1)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 23), x2)), x3)), store(KExprNode.BVar(0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(x0)), x2)))), x1)), store(KExprNode.BVar(2)))), x3)))))))), - 57 => - let x0 = store(KLevelNode.Param(0)); - store(KExprNode.Forall(store(KExprNode.Srt(x0)), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 26), store(ListNode.Cons(x0, store(ListNode.Nil))))), store(KExprNode.BVar(0)))), store(KExprNode.BVar(1)))))), - 58 => store(KExprNode.Forall(store(KExprNode.Srt(store(KLevelNode.Param(0)))), store(KExprNode.Forall(store(KExprNode.Const(role_bound_addr(tbl, 4), store(ListNode.Nil))), store(KExprNode.BVar(1)))))), - 59 => - let x0 = store(KLevelNode.Zero); - store(KExprNode.Forall(store(KExprNode.Srt(x0)), store(KExprNode.Srt(store(KLevelNode.Succ(x0)))))), - 60 => store(KExprNode.Forall(store(KExprNode.Srt(store(KLevelNode.Zero))), store(KExprNode.Forall(store(KExprNode.BVar(0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 59), store(ListNode.Nil))), store(KExprNode.BVar(1)))))))), - 61 => - let x0 = store(ListNode.Nil); - store(KExprNode.Forall(store(KExprNode.Srt(store(KLevelNode.Zero))), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 62), x0)), store(KExprNode.BVar(0)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 59), x0)), store(KExprNode.BVar(1)))))))), - 62 => - let x0 = store(KExprNode.Srt(store(KLevelNode.Zero))); - store(KExprNode.Forall(x0, x0)), - 63 => - let x0 = store(KLevelNode.Zero); - let x1 = store(ListNode.Nil); - let x2 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(store(KExprNode.Srt(x0)), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 59), x1)), x2)), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(x0)), x1)))), store(KExprNode.Const(role_bound_addr(tbl, 4), x1)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x1)), store(KExprNode.BVar(1)))), x2)))), store(KExprNode.Const(role_bound_addr(tbl, 6), x1)))), store(KExprNode.BVar(2)))))))), - 64 => - let x0 = store(KLevelNode.Zero); - let x1 = store(ListNode.Nil); - let x2 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(store(KExprNode.Srt(x0)), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 59), x1)), x2)), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(x0)), x1)))), store(KExprNode.Const(role_bound_addr(tbl, 4), x1)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x1)), store(KExprNode.BVar(1)))), x2)))), store(KExprNode.Const(role_bound_addr(tbl, 5), x1)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 62), x1)), store(KExprNode.BVar(2)))))))))), - 65 => - let x0 = store(ListNode.Nil); - store(KExprNode.Forall(store(KExprNode.Srt(store(KLevelNode.Zero))), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 59), x0)), store(KExprNode.BVar(0)))), store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))))), - 66 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, store(KExprNode.Srt(store(KLevelNode.Zero))))))), - 67 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 59), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), x1)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))))), - 68 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 59), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 66), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))))), - 69 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 59), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 66), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(1)))))), store(KExprNode.BVar(0)))))))))), - 70 => store(KExprNode.Srt(store(KLevelNode.Succ(store(KLevelNode.Zero))))), - 71 => - let x0 = store(ListNode.Nil); - store(KExprNode.Forall(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), - 72 => - let x0 = store(ListNode.Nil); - store(KExprNode.Forall(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), - 73 => - let x0 = store(ListNode.Nil); - store(KExprNode.Forall(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), - 74 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))))), - 75 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 70), store(ListNode.Nil))); - store(KExprNode.Forall(x0, x0)), - 76 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 70), store(ListNode.Nil))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, x0)))), - 77 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 70), store(ListNode.Nil))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, x0)))), - 78 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 70), store(ListNode.Nil))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, x0)))), - 79 => - let x0 = store(ListNode.Nil); - store(KExprNode.Forall(store(KExprNode.Const(role_bound_addr(tbl, 70), x0)), store(KExprNode.Const(role_bound_addr(tbl, 0), x0)))), - 80 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 70), store(ListNode.Nil))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, x0)))), - 81 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 70), store(ListNode.Nil))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, x0)))), - 82 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 70), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), x1)))), - 83 => store(KExprNode.Forall(store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))), store(KExprNode.Srt(store(KLevelNode.Succ(store(KLevelNode.Zero))))))), - 84 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 83), x0)), store(KExprNode.BVar(1)))))))), - 85 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 83), x0)), store(KExprNode.BVar(0)))), x1)))), - 86 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 83), x0)); - store(KExprNode.Forall(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.Forall(store(KExprNode.App(x1, store(KExprNode.BVar(0)))), store(KExprNode.Forall(store(KExprNode.App(x1, store(KExprNode.BVar(1)))), store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))))))), - 87 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 37), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 59), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), x1)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))))), - 88 => store(KExprNode.Srt(store(KLevelNode.Succ(store(KLevelNode.Zero))))), - 89 => store(KExprNode.Const(role_bound_addr(tbl, 88), store(ListNode.Nil))), - 90 => - let x0 = store(ListNode.Nil); - store(KExprNode.Forall(store(KExprNode.Const(role_bound_addr(tbl, 37), x0)), store(KExprNode.Const(role_bound_addr(tbl, 88), x0)))), - 91 => - let x0 = store(KLevelNode.Param(0)); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 29), store(ListNode.Cons(x0, store(ListNode.Nil))))); - store(KExprNode.Forall(store(KExprNode.Srt(store(KLevelNode.Succ(x0)))), store(KExprNode.Forall(store(KExprNode.App(x1, store(KExprNode.BVar(0)))), store(KExprNode.Forall(store(KExprNode.App(x1, store(KExprNode.BVar(1)))), store(KExprNode.App(x1, store(KExprNode.BVar(2)))))))))), - 92 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 37), store(ListNode.Nil))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, x0)))), - 93 => store(KExprNode.Forall(store(KExprNode.Srt(store(KLevelNode.Param(0)))), store(KExprNode.Forall(store(KExprNode.Srt(store(KLevelNode.Zero))), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 59), store(ListNode.Nil))), store(KExprNode.BVar(0)))), store(KExprNode.Forall(store(KExprNode.BVar(2)), store(KExprNode.Forall(store(KExprNode.BVar(3)), store(KExprNode.BVar(4)))))))))))), - 94 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 70), store(ListNode.Nil))); - store(KExprNode.Forall(x0, store(KExprNode.Forall(x0, store(KExprNode.Srt(store(KLevelNode.Zero))))))), - 95 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 70), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 59), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), x1)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))))), - 96 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 70), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 59), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 94), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))))), - 97 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 70), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 59), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 94), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 76), x0)), store(KExprNode.BVar(1)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))))))), store(KExprNode.BVar(0)))))))))), - 98 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 70), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), x1)))), - 99 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 70), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), x1)))), - 100 => - let x0 = store(ListNode.Nil); - store(KExprNode.Forall(store(KExprNode.Const(role_bound_addr(tbl, 39), x0)), store(KExprNode.Const(role_bound_addr(tbl, 0), x0)))), - 101 => - let x0 = store(ListNode.Nil); - store(KExprNode.Forall(store(KExprNode.Const(role_bound_addr(tbl, 37), x0)), store(KExprNode.Const(role_bound_addr(tbl, 0), x0)))), - 102 => - let x0 = store(ListNode.Nil); - store(KExprNode.Forall(store(KExprNode.Const(role_bound_addr(tbl, 37), x0)), store(KExprNode.Const(role_bound_addr(tbl, 39), x0)))), - _ => store(KExprNode.Srt(store(KLevelNode.Zero))), - } - } - - fn op_equation_count(r: G) -> G { - match r { - 41 => 2, - 42 => 2, - 43 => 2, - 44 => 2, - 45 => 2, - 46 => 4, - 47 => 3, - 48 => 3, - 49 => 3, - 50 => 2, - 51 => 2, - 52 => 2, - 53 => 2, - 54 => 2, - 55 => 2, - _ => 0, - } - } - - fn op_evidence_is_proof(r: G) -> G { - match r { - 48 => 1, - 49 => 1, - 50 => 1, - 51 => 1, - 52 => 1, - 53 => 1, - 54 => 1, - 55 => 1, - _ => 0, - } - } - - fn op_equation_lhs(tbl: RoleTable, r: G, k: G) -> KExpr { - match 64 * r + k { - 2624 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 41), x0)), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))))), - 2625 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 41), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(1)))))))))), - 2688 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 42), x0)), store(KExprNode.BVar(1)))), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))))), - 2689 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 42), x0)), store(KExprNode.BVar(1)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(0)))))))))), - 2752 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 43), x0)), store(KExprNode.BVar(1)))), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))))), - 2753 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 43), x0)), store(KExprNode.BVar(1)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(0)))))))))), - 2816 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x0)), store(KExprNode.BVar(1)))), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))))), - 2817 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x0)), store(KExprNode.BVar(1)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(0)))))))))), - 2880 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 45), x0)), store(KExprNode.BVar(1)))), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))))), - 2881 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 45), x0)), store(KExprNode.BVar(1)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(0)))))))))), - 2944 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 1), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 46), x0)), x2)), x2)))))), - 2945 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 46), x0)), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(0)))))))))), - 2946 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 46), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(1)))))), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))))), - 2947 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 46), x0)), store(KExprNode.App(x2, store(KExprNode.BVar(1)))))), store(KExprNode.App(x2, store(KExprNode.BVar(0)))))))))), - 3008 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))), store(KExprNode.BVar(0)))))))), - 3009 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(1)))))), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))))), - 3010 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.App(x2, store(KExprNode.BVar(1)))))), store(KExprNode.App(x2, store(KExprNode.BVar(0)))))))))), - _ => store(KExprNode.Srt(store(KLevelNode.Zero))), - } - } - - fn op_equation_rhs(tbl: RoleTable, r: G, k: G) -> KExpr { - match 64 * r + k { - 2624 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))), - 2625 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))); - store(KExprNode.Lam(x0, store(KExprNode.Lam(x0, store(KExprNode.BVar(1)))))), - 2688 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))); - store(KExprNode.Lam(x0, store(KExprNode.Lam(x0, store(KExprNode.BVar(1)))))), - 2689 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 42), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))))), - 2752 => - let x0 = store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))); - store(KExprNode.Lam(x0, store(KExprNode.Lam(x0, store(KExprNode.BVar(1)))))), - 2753 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 41), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 43), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))))), - 2816 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))), - 2817 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.BVar(1)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 42), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x0)), x2)), store(KExprNode.BVar(0)))))), x2)))))), - 2880 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))))), - 2881 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.BVar(1)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 45), x0)), x2)), store(KExprNode.BVar(0)))))), x2)))))), - 2944 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.Const(role_bound_addr(tbl, 6), x0)))))), - 2945 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))))), - 2946 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))))), - 2947 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 46), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))), - 3008 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.Const(role_bound_addr(tbl, 6), x0)))))), - 3009 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))))), - 3010 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))), - _ => store(KExprNode.Srt(store(KLevelNode.Zero))), - } - } - - fn op_certificate(tbl: RoleTable, r: G, k: G) -> KExpr { - match 64 * r + k { - 3072 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))); - let x4 = store(KExprNode.Const(role_bound_addr(tbl, 47), x0)); - let x5 = store(KExprNode.BVar(1)); - let x6 = store(KExprNode.Const(role_bound_addr(tbl, 6), x0)); - let x7 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x8 = store(KExprNode.Const(role_bound_addr(tbl, 48), x0)); - let x9 = store(KExprNode.BVar(3)); - let x10 = store(KExprNode.BVar(2)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x3, store(KExprNode.App(store(KExprNode.App(x4, store(KExprNode.BVar(0)))), x5)))), x6)), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x3, store(KExprNode.App(store(KExprNode.App(x4, store(KExprNode.App(x7, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))), x5)))), x6)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.App(x8, x9)), x10)))), store(KExprNode.App(x7, store(KExprNode.App(store(KExprNode.App(x8, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 43), x0)), x9)), x10)))), x10)))))))))))))), - 3073 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.BVar(1)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.BVar(0)))), x3)))), store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 48), x0)), store(KExprNode.BVar(2)))), x3)))), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))))))), - 3074 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.Const(role_bound_addr(tbl, 1), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), x3)))), store(KExprNode.BVar(0)))))), store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 48), x0)), store(KExprNode.BVar(2)))), store(KExprNode.BVar(1)))))), x3)))))))), - 3136 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))); - let x4 = store(KExprNode.Const(role_bound_addr(tbl, 47), x0)); - let x5 = store(KExprNode.BVar(1)); - let x6 = store(KExprNode.Const(role_bound_addr(tbl, 6), x0)); - let x7 = store(KExprNode.Const(role_bound_addr(tbl, 49), x0)); - let x8 = store(KExprNode.BVar(3)); - let x9 = store(KExprNode.BVar(2)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x3, store(KExprNode.App(store(KExprNode.App(x4, store(KExprNode.BVar(0)))), x5)))), x6)), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x3, store(KExprNode.App(store(KExprNode.App(x4, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))), x5)))), x6)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.App(x7, x8)), x9)))), store(KExprNode.App(store(KExprNode.App(x7, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 43), x0)), x8)), x9)))), x9)))))))))))), - 3137 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.BVar(2)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.BVar(0)))), x3)))), store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 49), x0)), x4)), x3)))), x4)))))))), - 3138 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.BVar(2)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))), store(KExprNode.BVar(0)))))), store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 49), x0)), x3)), store(KExprNode.BVar(1)))))), x3)))))))), - 3200 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.Const(role_bound_addr(tbl, 50), x0)); - let x5 = store(KExprNode.BVar(2)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))), x3)))), store(KExprNode.Const(role_bound_addr(tbl, 6), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.App(x4, x5)), x3)))), store(KExprNode.App(store(KExprNode.App(x4, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 49), x0)), x3)), x5)))), x5)))))))))), - 3201 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.BVar(1)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))), x3)))), store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 50), x0)), store(KExprNode.BVar(2)))), x3)))), x3)))))))), - 3264 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x4 = store(KExprNode.App(x3, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))); - let x5 = store(KExprNode.BVar(1)); - let x6 = store(KExprNode.Const(role_bound_addr(tbl, 51), x0)); - let x7 = store(KExprNode.BVar(2)); - let x8 = store(KExprNode.Const(role_bound_addr(tbl, 44), x0)); - let x9 = store(KExprNode.App(x3, x4)); - let x10 = store(KExprNode.Const(role_bound_addr(tbl, 48), x0)); - let x11 = store(KExprNode.Const(role_bound_addr(tbl, 49), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), x4)), x5)))), store(KExprNode.Const(role_bound_addr(tbl, 6), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.App(x6, x7)), x5)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 42), x0)), store(KExprNode.App(store(KExprNode.App(x8, x9)), store(KExprNode.App(store(KExprNode.App(x6, store(KExprNode.App(store(KExprNode.App(x10, x7)), x9)))), store(KExprNode.App(store(KExprNode.App(x10, x5)), x9)))))))), store(KExprNode.App(store(KExprNode.App(x8, store(KExprNode.App(store(KExprNode.App(x11, x7)), x9)))), store(KExprNode.App(store(KExprNode.App(x11, x5)), x9)))))))))))))), - 3265 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.Const(role_bound_addr(tbl, 1), x0)); - let x4 = store(KExprNode.BVar(1)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), x3)))), x4)))), store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 51), x0)), store(KExprNode.BVar(2)))), x4)))), x3)))))))), - 3328 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x4 = store(KExprNode.App(x3, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))); - let x5 = store(KExprNode.BVar(1)); - let x6 = store(KExprNode.Const(role_bound_addr(tbl, 52), x0)); - let x7 = store(KExprNode.BVar(2)); - let x8 = store(KExprNode.Const(role_bound_addr(tbl, 42), x0)); - let x9 = store(KExprNode.Const(role_bound_addr(tbl, 44), x0)); - let x10 = store(KExprNode.App(x3, x4)); - let x11 = store(KExprNode.Const(role_bound_addr(tbl, 48), x0)); - let x12 = store(KExprNode.Const(role_bound_addr(tbl, 49), x0)); - let x13 = store(KExprNode.App(store(KExprNode.App(x12, x7)), x10)); - let x14 = store(KExprNode.App(store(KExprNode.App(x12, x5)), x10)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), x4)), x5)))), store(KExprNode.Const(role_bound_addr(tbl, 6), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.App(x6, x7)), x5)))), store(KExprNode.App(store(KExprNode.App(x8, store(KExprNode.App(store(KExprNode.App(x9, x10)), store(KExprNode.App(store(KExprNode.App(x6, store(KExprNode.App(store(KExprNode.App(x11, x7)), x10)))), store(KExprNode.App(store(KExprNode.App(x11, x5)), x10)))))))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 43), x0)), store(KExprNode.App(store(KExprNode.App(x8, x13)), x14)))), store(KExprNode.App(store(KExprNode.App(x9, x13)), x14)))))))))))))), - 3329 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.BVar(1)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))), x3)))), store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 52), x0)), store(KExprNode.BVar(2)))), x3)))), x3)))))))), - 3392 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x4 = store(KExprNode.App(x3, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))); - let x5 = store(KExprNode.BVar(1)); - let x6 = store(KExprNode.Const(role_bound_addr(tbl, 53), x0)); - let x7 = store(KExprNode.BVar(2)); - let x8 = store(KExprNode.Const(role_bound_addr(tbl, 42), x0)); - let x9 = store(KExprNode.App(x3, x4)); - let x10 = store(KExprNode.Const(role_bound_addr(tbl, 48), x0)); - let x11 = store(KExprNode.Const(role_bound_addr(tbl, 49), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), x4)), x5)))), store(KExprNode.Const(role_bound_addr(tbl, 6), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.App(x6, x7)), x5)))), store(KExprNode.App(store(KExprNode.App(x8, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x0)), x9)), store(KExprNode.App(store(KExprNode.App(x6, store(KExprNode.App(store(KExprNode.App(x10, x7)), x9)))), store(KExprNode.App(store(KExprNode.App(x10, x5)), x9)))))))), store(KExprNode.App(store(KExprNode.App(x11, store(KExprNode.App(store(KExprNode.App(x8, store(KExprNode.App(store(KExprNode.App(x11, x7)), x9)))), store(KExprNode.App(store(KExprNode.App(x11, x5)), x9)))))), x9)))))))))))), - 3393 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.BVar(1)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))), x3)))), store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 53), x0)), store(KExprNode.BVar(2)))), x3)))), x3)))))))), - 3456 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x4 = store(KExprNode.App(x3, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))); - let x5 = store(KExprNode.Const(role_bound_addr(tbl, 54), x0)); - let x6 = store(KExprNode.BVar(2)); - let x7 = store(KExprNode.BVar(1)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), x4)), store(KExprNode.BVar(0)))))), store(KExprNode.Const(role_bound_addr(tbl, 6), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.App(x5, x6)), x7)))), store(KExprNode.App(store(KExprNode.App(x5, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x0)), store(KExprNode.App(x3, x4)))), x6)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 43), x0)), x7)), x4)))))))))))), - 3457 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.BVar(2)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))), store(KExprNode.BVar(0)))))), store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 54), x0)), x3)), store(KExprNode.BVar(1)))))), x3)))))))), - 3520 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x4 = store(KExprNode.App(x3, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))); - let x5 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 55), x0)), store(KExprNode.BVar(2)))); - let x6 = store(KExprNode.BVar(1)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), x4)), store(KExprNode.BVar(0)))))), store(KExprNode.Const(role_bound_addr(tbl, 6), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(x5, x6)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 48), x0)), store(KExprNode.App(x5, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 43), x0)), x6)), x4)))))), store(KExprNode.App(x3, x4)))))))))))), - 3521 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.BVar(2)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))), store(KExprNode.BVar(0)))))), store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 55), x0)), x3)), store(KExprNode.BVar(1)))))), x3)))))))), - _ => store(KExprNode.Srt(store(KLevelNode.Zero))), - } - } - - fn eqns_equation_count(r: G) -> G { - match r { - 65 => 3, - 67 => 1, - 68 => 1, - 69 => 1, - 73 => 2, - 74 => 2, - 75 => 2, - 76 => 4, - 77 => 1, - 78 => 4, - 79 => 2, - 80 => 5, - 81 => 4, - 82 => 3, - 85 => 1, - 86 => 1, - 87 => 1, - 90 => 1, - 91 => 2, - 92 => 1, - 93 => 2, - 95 => 4, - 96 => 4, - 97 => 1, - 98 => 1, - 99 => 1, - 100 => 5, - 101 => 2, - 102 => 3, - _ => 0, - } - } - - fn eqns_conditional(r: G, k: G) -> G { - match 64 * r + k { - 4162 => 1, - 4736 => 1, - 4737 => 1, - 5249 => 1, - 5250 => 1, - 6400 => 1, - 6401 => 1, - 6402 => 1, - 6403 => 1, - 6404 => 1, - _ => 0, - } - } - - fn eqns_lhs(tbl: RoleTable, r: G, k: G) -> KExpr { - match 64 * r + k { - 4160 => - let x0 = store(KExprNode.BVar(0)); - let x1 = store(ListNode.Nil); - let x2 = store(KExprNode.BVar(1)); - store(KExprNode.Lam(store(KExprNode.Srt(store(KLevelNode.Zero))), store(KExprNode.Lam(x0, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x1)), x2)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 60), x1)), x2)), x0)))))))), - 4161 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.BVar(0)); - let x2 = store(KExprNode.BVar(1)); - store(KExprNode.Lam(store(KExprNode.Srt(store(KLevelNode.Zero))), store(KExprNode.Lam(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 62), x0)), x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), x2)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 61), x0)), x2)), x1)))))))), - 4288 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.BVar(1)); - let x3 = store(KExprNode.BVar(0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), x1)), x2)), x3)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 67), x0)), x2)), x3)))))))), - 4352 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.BVar(1)); - let x3 = store(KExprNode.BVar(0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 66), x0)), x2)), x3)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 68), x0)), x2)), x3)))))))), - 4416 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 69), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))), - 4672 => - let x0 = store(ListNode.Nil); - store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 73), x0)), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))), - 4673 => - let x0 = store(ListNode.Nil); - store(KExprNode.Lam(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 73), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(0)))))))), - 4800 => - let x0 = store(ListNode.Nil); - store(KExprNode.Lam(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 75), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.BVar(0)))))))), - 4801 => - let x0 = store(ListNode.Nil); - store(KExprNode.Lam(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 75), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(0)))))))), - 4864 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 71), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 76), x0)), store(KExprNode.App(x2, store(KExprNode.BVar(1)))))), store(KExprNode.App(x2, store(KExprNode.BVar(0)))))))))), - 4865 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 76), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.BVar(1)))))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(0)))))))))), - 4866 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 76), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(1)))))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.BVar(0)))))))))), - 4867 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 72), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 76), x0)), store(KExprNode.App(x2, store(KExprNode.BVar(1)))))), store(KExprNode.App(x2, store(KExprNode.BVar(0)))))))))), - 4928 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 70), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 77), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))), - 4992 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 71), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 78), x0)), store(KExprNode.App(x2, store(KExprNode.BVar(1)))))), store(KExprNode.App(x2, store(KExprNode.BVar(0)))))))))), - 4993 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 78), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.BVar(1)))))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(0)))))))))), - 4994 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 78), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(1)))))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.BVar(0)))))))))), - 4995 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 72), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 78), x0)), store(KExprNode.App(x2, store(KExprNode.BVar(1)))))), store(KExprNode.App(x2, store(KExprNode.BVar(0)))))))))), - 5056 => - let x0 = store(ListNode.Nil); - store(KExprNode.Lam(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 79), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.BVar(0)))))))), - 5057 => - let x0 = store(ListNode.Nil); - store(KExprNode.Lam(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 79), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(0)))))))), - 5120 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 71), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 80), x0)), store(KExprNode.App(x2, store(KExprNode.BVar(1)))))), store(KExprNode.App(x2, store(KExprNode.BVar(0)))))))))), - 5121 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 80), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.BVar(1)))))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(0)))))))))), - 5122 => - let x0 = store(ListNode.Nil); - store(KExprNode.Lam(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 80), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(0)))))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))))), - 5123 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 80), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(1)))))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(0)))))))))))), - 5124 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 72), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 80), x0)), store(KExprNode.App(x2, store(KExprNode.BVar(1)))))), store(KExprNode.App(x2, store(KExprNode.BVar(0)))))))))), - 5184 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 71), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 81), x0)), store(KExprNode.App(x2, store(KExprNode.BVar(1)))))), store(KExprNode.App(x2, store(KExprNode.BVar(0)))))))))), - 5185 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 81), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.BVar(1)))))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(0)))))))))), - 5186 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 81), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(1)))))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.BVar(0)))))))))), - 5187 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 72), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 81), x0)), store(KExprNode.App(x2, store(KExprNode.BVar(1)))))), store(KExprNode.App(x2, store(KExprNode.BVar(0)))))))))), - 5248 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 82), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.BVar(1)))))), store(KExprNode.BVar(0)))))))), - 5440 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.BVar(1)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 85), x0)), x2)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 84), x0)), x2)), store(KExprNode.BVar(0)))))))))), - 5504 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.BVar(2)); - let x3 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 84), x0)), x2)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 86), x0)), x2)), store(KExprNode.App(x3, store(KExprNode.BVar(1)))))), store(KExprNode.App(x3, store(KExprNode.BVar(0)))))))))))), - 5568 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 37), x0)); - let x2 = store(KExprNode.BVar(0)); - store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), x1)), x2)), x2)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 87), x0)), x2)), x2)))))), - 5760 => - let x0 = store(ListNode.Nil); - store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 90), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 38), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 30), store(ListNode.Cons(store(KLevelNode.Zero), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 39), x0)))))))), - 5824 => - let x0 = store(KLevelNode.Param(0)); - let x1 = store(ListNode.Cons(x0, store(ListNode.Nil))); - let x2 = store(KExprNode.BVar(0)); - let x3 = store(KExprNode.BVar(1)); - store(KExprNode.Lam(store(KExprNode.Srt(store(KLevelNode.Succ(x0)))), store(KExprNode.Lam(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 29), x1)), x2)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 91), x1)), x3)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 30), x1)), x3)))), x2)))))), - 5825 => - let x0 = store(KLevelNode.Param(0)); - let x1 = store(KExprNode.BVar(0)); - let x2 = store(ListNode.Cons(x0, store(ListNode.Nil))); - let x3 = store(KExprNode.Const(role_bound_addr(tbl, 29), x2)); - let x4 = store(KExprNode.BVar(1)); - let x5 = store(KExprNode.BVar(2)); - let x6 = store(KExprNode.BVar(3)); - store(KExprNode.Lam(store(KExprNode.Srt(store(KLevelNode.Succ(x0)))), store(KExprNode.Lam(x1, store(KExprNode.Lam(store(KExprNode.App(x3, x4)), store(KExprNode.Lam(store(KExprNode.App(x3, x5)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 91), x2)), x6)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 31), x2)), x6)), x5)), x4)))), x1)))))))))), - 5888 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 29), store(ListNode.Cons(store(KLevelNode.Zero), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 39), x0)))); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 38), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 92), x0)), store(KExprNode.App(x2, store(KExprNode.BVar(1)))))), store(KExprNode.App(x2, store(KExprNode.BVar(0)))))))))), - 5952 => - let x0 = store(KLevelNode.Param(0)); - let x1 = store(KExprNode.BVar(0)); - let x2 = store(KExprNode.BVar(2)); - let x3 = store(KExprNode.BVar(3)); - let x4 = store(ListNode.Nil); - store(KExprNode.Lam(store(KExprNode.Srt(x0)), store(KExprNode.Lam(store(KExprNode.Srt(store(KLevelNode.Zero))), store(KExprNode.Lam(x1, store(KExprNode.Lam(x2, store(KExprNode.Lam(x3, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 93), store(ListNode.Cons(x0, x4)))), store(KExprNode.BVar(4)))), x3)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 60), x4)), x3)), x2)))), store(KExprNode.BVar(1)))), x1)))))))))))), - 5953 => - let x0 = store(KLevelNode.Param(0)); - let x1 = store(ListNode.Nil); - let x2 = store(KExprNode.BVar(0)); - let x3 = store(KExprNode.BVar(2)); - let x4 = store(KExprNode.BVar(3)); - store(KExprNode.Lam(store(KExprNode.Srt(x0)), store(KExprNode.Lam(store(KExprNode.Srt(store(KLevelNode.Zero))), store(KExprNode.Lam(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 62), x1)), x2)), store(KExprNode.Lam(x3, store(KExprNode.Lam(x4, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 93), store(ListNode.Cons(x0, x1)))), store(KExprNode.BVar(4)))), x4)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 61), x1)), x4)), x3)))), store(KExprNode.BVar(1)))), x2)))))))))))), - 6080 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 71), x0)); - let x3 = store(KExprNode.App(x2, store(KExprNode.BVar(1)))); - let x4 = store(KExprNode.App(x2, store(KExprNode.BVar(0)))); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), x3)), x4)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 95), x0)), x3)), x4)))))))), - 6081 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.BVar(1)))); - let x3 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(0)))); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), x2)), x3)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 95), x0)), x2)), x3)))))))), - 6082 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(1)))); - let x3 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.BVar(0)))); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), x2)), x3)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 95), x0)), x2)), x3)))))))), - 6083 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 72), x0)); - let x3 = store(KExprNode.App(x2, store(KExprNode.BVar(1)))); - let x4 = store(KExprNode.App(x2, store(KExprNode.BVar(0)))); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), x3)), x4)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 95), x0)), x3)), x4)))))))), - 6144 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 71), x0)); - let x3 = store(KExprNode.App(x2, store(KExprNode.BVar(1)))); - let x4 = store(KExprNode.App(x2, store(KExprNode.BVar(0)))); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 94), x0)), x3)), x4)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 96), x0)), x3)), x4)))))))), - 6145 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.BVar(1)))); - let x3 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(0)))); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 94), x0)), x2)), x3)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 96), x0)), x2)), x3)))))))), - 6146 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(1)))); - let x3 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.BVar(0)))); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 94), x0)), x2)), x3)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 96), x0)), x2)), x3)))))))), - 6147 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 72), x0)); - let x3 = store(KExprNode.App(x2, store(KExprNode.BVar(1)))); - let x4 = store(KExprNode.App(x2, store(KExprNode.BVar(0)))); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 94), x0)), x3)), x4)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 96), x0)), x3)), x4)))))))), - 6208 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 70), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 97), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))), - 6272 => - let x0 = store(ListNode.Nil); - store(KExprNode.Lam(store(KExprNode.Const(role_bound_addr(tbl, 70), x0)), store(KExprNode.Lam(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 98), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))), - 6336 => - let x0 = store(ListNode.Nil); - store(KExprNode.Lam(store(KExprNode.Const(role_bound_addr(tbl, 70), x0)), store(KExprNode.Lam(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 99), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))), - 6464 => - let x0 = store(ListNode.Nil); - store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 101), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 38), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 30), store(ListNode.Cons(store(KLevelNode.Zero), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 39), x0)))))))), - 6465 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 39), x0)); - let x2 = store(ListNode.Cons(store(KLevelNode.Zero), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 29), x2)), x1)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 101), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 38), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 31), x2)), x1)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))))))), - 6528 => - let x0 = store(ListNode.Nil); - store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 102), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 38), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 30), store(ListNode.Cons(store(KLevelNode.Zero), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 39), x0)))))))), - 6529 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 39), x0)); - let x2 = store(ListNode.Cons(store(KLevelNode.Zero), x0)); - store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 102), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 38), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 31), x2)), x1)), store(KExprNode.BVar(0)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 30), x2)), x1)))))))))), - 6530 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 39), x0)); - let x2 = store(ListNode.Cons(store(KLevelNode.Zero), x0)); - let x3 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 31), x2)), x1)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.Lam(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 29), x2)), x1)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 102), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 38), x0)), store(KExprNode.App(store(KExprNode.App(x3, store(KExprNode.BVar(2)))), store(KExprNode.App(store(KExprNode.App(x3, store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))))))))))), - _ => store(KExprNode.Srt(store(KLevelNode.Zero))), - } - } - - fn eqns_rhs(tbl: RoleTable, r: G, k: G) -> KExpr { - match 64 * r + k { - 4160 => store(KExprNode.Lam(store(KExprNode.Srt(store(KLevelNode.Zero))), store(KExprNode.Lam(store(KExprNode.BVar(0)), store(KExprNode.Const(role_bound_addr(tbl, 6), store(ListNode.Nil))))))), - 4161 => - let x0 = store(ListNode.Nil); - store(KExprNode.Lam(store(KExprNode.Srt(store(KLevelNode.Zero))), store(KExprNode.Lam(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 62), x0)), store(KExprNode.BVar(0)))), store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))))), - 4288 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 46), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))), - 4352 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))), - 4416 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 68), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(1)))))), store(KExprNode.BVar(0)))))))), - 4672 => - let x0 = store(ListNode.Nil); - store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))), - 4673 => - let x0 = store(ListNode.Nil); - store(KExprNode.Lam(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(0)))))), - 4800 => - let x0 = store(ListNode.Nil); - store(KExprNode.Lam(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 73), x0)), store(KExprNode.BVar(0)))))), - 4801 => - let x0 = store(ListNode.Nil); - store(KExprNode.Lam(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(0)))))))), - 4864 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 42), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))))), - 4865 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 74), x0)), store(KExprNode.BVar(1)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(0)))))))))), - 4866 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 74), x0)), store(KExprNode.BVar(0)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(1)))))))))), - 4867 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 42), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))))))), - 4928 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 70), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 76), x0)), store(KExprNode.BVar(1)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 75), x0)), store(KExprNode.BVar(0)))))))))), - 4992 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))))), - 4993 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 73), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x0)), store(KExprNode.BVar(1)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(0)))))))))))), - 4994 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 73), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(1)))))), store(KExprNode.BVar(0)))))))))), - 4995 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x0)), store(KExprNode.App(x2, store(KExprNode.BVar(1)))))), store(KExprNode.App(x2, store(KExprNode.BVar(0)))))))))))), - 5056 => store(KExprNode.Lam(store(KExprNode.Const(role_bound_addr(tbl, 0), store(ListNode.Nil))), store(KExprNode.BVar(0)))), - 5057 => - let x0 = store(ListNode.Nil); - store(KExprNode.Lam(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(0)))))), - 5120 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 48), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))))), - 5121 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 75), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 48), x0)), store(KExprNode.BVar(1)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(0)))))))))))))), - 5122 => - let x0 = store(ListNode.Nil); - store(KExprNode.Lam(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))), - 5123 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 48), x0)), store(KExprNode.BVar(1)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(0)))))))))))), - 5124 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.App(x2, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 48), x0)), store(KExprNode.BVar(1)))), store(KExprNode.App(x2, store(KExprNode.BVar(0)))))))))))))), - 5184 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 49), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))))), - 5185 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 49), x0)), store(KExprNode.BVar(1)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(0)))))))))))), - 5186 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.BVar(0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 74), x0)), x2)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 49), x0)), store(KExprNode.BVar(1)))), x2)))))))))), - 5187 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x3 = store(KExprNode.App(x2, store(KExprNode.BVar(0)))); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 74), x0)), x3)), store(KExprNode.App(x2, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 49), x0)), store(KExprNode.BVar(1)))), x3)))))))))), - 5248 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 45), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))))), - 5440 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 49), x0)), store(KExprNode.BVar(0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 45), x0)), store(KExprNode.App(x2, store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))))), store(KExprNode.BVar(1)))))))))), - 5504 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x3 = store(KExprNode.Const(role_bound_addr(tbl, 49), x0)); - let x4 = store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 45), x0)), store(KExprNode.App(x2, store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))))), store(KExprNode.BVar(2)))); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.App(x2, store(KExprNode.App(store(KExprNode.App(x3, store(KExprNode.BVar(1)))), x4)))))), store(KExprNode.App(store(KExprNode.App(x3, store(KExprNode.BVar(0)))), x4)))))))))), - 5568 => - let x0 = store(ListNode.Nil); - store(KExprNode.Lam(store(KExprNode.Const(role_bound_addr(tbl, 37), x0)), store(KExprNode.Const(role_bound_addr(tbl, 6), x0)))), - 5760 => store(KExprNode.Const(role_bound_addr(tbl, 89), store(ListNode.Nil))), - 5824 => - let x0 = store(KLevelNode.Param(0)); - let x1 = store(KExprNode.BVar(0)); - store(KExprNode.Lam(store(KExprNode.Srt(store(KLevelNode.Succ(x0)))), store(KExprNode.Lam(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 29), store(ListNode.Cons(x0, store(ListNode.Nil))))), x1)), x1)))), - 5825 => - let x0 = store(KLevelNode.Param(0)); - let x1 = store(KExprNode.BVar(0)); - let x2 = store(ListNode.Cons(x0, store(ListNode.Nil))); - let x3 = store(KExprNode.Const(role_bound_addr(tbl, 29), x2)); - let x4 = store(KExprNode.BVar(1)); - let x5 = store(KExprNode.BVar(2)); - let x6 = store(KExprNode.BVar(3)); - store(KExprNode.Lam(store(KExprNode.Srt(store(KLevelNode.Succ(x0)))), store(KExprNode.Lam(x1, store(KExprNode.Lam(store(KExprNode.App(x3, x4)), store(KExprNode.Lam(store(KExprNode.App(x3, x5)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 31), x2)), x6)), x5)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 91), x2)), x6)), x4)), x1)))))))))))), - 5888 => - let x0 = store(ListNode.Nil); - let x1 = store(ListNode.Cons(store(KLevelNode.Zero), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 39), x0)); - let x3 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 29), x1)), x2)); - store(KExprNode.Lam(x3, store(KExprNode.Lam(x3, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 38), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 91), x1)), x2)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))))), - 5952 => store(KExprNode.Lam(store(KExprNode.Srt(store(KLevelNode.Param(0)))), store(KExprNode.Lam(store(KExprNode.Srt(store(KLevelNode.Zero))), store(KExprNode.Lam(store(KExprNode.BVar(0)), store(KExprNode.Lam(store(KExprNode.BVar(2)), store(KExprNode.Lam(store(KExprNode.BVar(3)), store(KExprNode.BVar(1)))))))))))), - 5953 => - let x0 = store(KExprNode.BVar(0)); - store(KExprNode.Lam(store(KExprNode.Srt(store(KLevelNode.Param(0)))), store(KExprNode.Lam(store(KExprNode.Srt(store(KLevelNode.Zero))), store(KExprNode.Lam(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 62), store(ListNode.Nil))), x0)), store(KExprNode.Lam(store(KExprNode.BVar(2)), store(KExprNode.Lam(store(KExprNode.BVar(3)), x0)))))))))), - 6080 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 46), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))), - 6081 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))))), - 6082 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))))), - 6083 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 46), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))), - 6144 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))), - 6145 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))))), - 6146 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.Const(role_bound_addr(tbl, 6), x0)))))), - 6147 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.BVar(0)))), store(KExprNode.BVar(1)))))))), - 6208 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 70), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 96), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 76), x0)), store(KExprNode.BVar(1)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))))))), store(KExprNode.BVar(0)))))))), - 6272 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 70), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 76), x0)); - let x3 = store(KExprNode.Const(role_bound_addr(tbl, 71), x0)); - let x4 = store(KExprNode.App(x3, store(KExprNode.BVar(0)))); - let x5 = store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 81), x0)), store(KExprNode.BVar(1)))), x4)); - let x6 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x7 = store(KExprNode.App(x6, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))); - let x8 = store(KExprNode.App(x3, x7)); - let x9 = store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 80), x0)), store(KExprNode.App(store(KExprNode.App(x2, x4)), x8)))), store(KExprNode.App(x3, store(KExprNode.App(x6, x7)))))); - store(KExprNode.Lam(x1, store(KExprNode.Lam(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 93), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 94), x0)), store(KExprNode.App(store(KExprNode.App(x2, x5)), x8)))), x9)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 97), x0)), x5)), x9)))), x5)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 77), x0)), x5)), x4)))))))), - 6336 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 70), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x3 = store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)); - let x4 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 93), x3)), x1)); - let x5 = store(KExprNode.BVar(0)); - let x6 = store(KExprNode.Const(role_bound_addr(tbl, 1), x0)); - let x7 = store(KExprNode.Const(role_bound_addr(tbl, 71), x0)); - let x8 = store(KExprNode.Const(role_bound_addr(tbl, 76), x0)); - let x9 = store(KExprNode.BVar(1)); - let x10 = store(KExprNode.App(x7, x5)); - let x11 = store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 81), x0)), x9)), x10)); - let x12 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x13 = store(KExprNode.App(x12, x6)); - let x14 = store(KExprNode.App(x7, x13)); - let x15 = store(KExprNode.Const(role_bound_addr(tbl, 80), x0)); - let x16 = store(KExprNode.App(store(KExprNode.App(x15, store(KExprNode.App(store(KExprNode.App(x8, x10)), x14)))), store(KExprNode.App(x7, store(KExprNode.App(x12, x13)))))); - let x17 = store(KExprNode.App(store(KExprNode.App(x15, x9)), x10)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x2, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x4, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), x3)), x2)), x5)), x6)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 67), x0)), x5)), x6)))), store(KExprNode.App(x7, x6)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x4, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 94), x0)), store(KExprNode.App(store(KExprNode.App(x8, x11)), x14)))), x16)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 97), x0)), x11)), x16)))), x17)), store(KExprNode.App(store(KExprNode.App(x8, x17)), x14)))))))))), - 6464 => store(KExprNode.Const(role_bound_addr(tbl, 1), store(ListNode.Nil))), - 6465 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 39), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 29), store(ListNode.Cons(store(KLevelNode.Zero), x0)))), x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 42), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 100), x0)), store(KExprNode.BVar(1)))))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 101), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 38), x0)), store(KExprNode.BVar(0)))))))))))), - 6528 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x2 = store(KExprNode.App(x1, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))); - let x3 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x0)), store(KExprNode.App(x1, x2)))); - store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 40), x0)), store(KExprNode.App(x1, store(KExprNode.App(x3, store(KExprNode.App(x3, store(KExprNode.App(x3, store(KExprNode.App(x3, store(KExprNode.App(x3, store(KExprNode.App(x3, x2)))))))))))))))), - 6529 => store(KExprNode.Lam(store(KExprNode.Const(role_bound_addr(tbl, 39), store(ListNode.Nil))), store(KExprNode.BVar(0)))), - 6530 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 39), x0)); - let x2 = store(ListNode.Cons(store(KLevelNode.Zero), x0)); - store(KExprNode.Lam(x1, store(KExprNode.Lam(x1, store(KExprNode.Lam(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 29), x2)), x1)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 102), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 38), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 31), x2)), x1)), store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))))))))))))), - _ => store(KExprNode.Srt(store(KLevelNode.Zero))), - } - } - - fn eqns_statement(tbl: RoleTable, r: G, k: G) -> KExpr { - match 64 * r + k { - 4160 => - let x0 = store(KLevelNode.Zero); - let x1 = store(KExprNode.BVar(0)); - let x2 = store(ListNode.Nil); - let x3 = store(KExprNode.BVar(1)); - store(KExprNode.Forall(store(KExprNode.Srt(x0)), store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(x0)), x2)))), store(KExprNode.Const(role_bound_addr(tbl, 4), x2)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x2)), x3)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 60), x2)), x3)), x1)))))), store(KExprNode.Const(role_bound_addr(tbl, 6), x2)))))))), - 4161 => - let x0 = store(KLevelNode.Zero); - let x1 = store(ListNode.Nil); - let x2 = store(KExprNode.BVar(0)); - let x3 = store(KExprNode.BVar(1)); - store(KExprNode.Forall(store(KExprNode.Srt(x0)), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 62), x1)), x2)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(x0)), x1)))), store(KExprNode.Const(role_bound_addr(tbl, 4), x1)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x1)), x3)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 61), x1)), x3)), x2)))))), store(KExprNode.Const(role_bound_addr(tbl, 5), x1)))))))), - 4162 => - let x0 = store(KLevelNode.Zero); - let x1 = store(ListNode.Nil); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 59), x1)); - let x3 = store(KExprNode.BVar(0)); - let x4 = store(KExprNode.BVar(1)); - let x5 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(x0)), x1)))); - let x6 = store(KExprNode.BVar(2)); - let x7 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x1)), x6)); - store(KExprNode.Forall(store(KExprNode.Srt(x0)), store(KExprNode.Forall(store(KExprNode.App(x2, x3)), store(KExprNode.Forall(store(KExprNode.App(x2, x4)), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x5, store(KExprNode.Const(role_bound_addr(tbl, 4), x1)))), store(KExprNode.App(x7, x4)))), store(KExprNode.App(x7, x3)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x5, store(KExprNode.App(x2, store(KExprNode.BVar(3)))))), x6)), x4)))))))))), - 4288 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), x3)), x4)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 67), x0)), x3)), x4)))))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 46), x0)), x3)), x4)))))))), - 4352 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.BVar(1)); - let x3 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 66), x0)), x2)), x3)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 68), x0)), x2)), x3)))))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), x2)), x3)))))))), - 4416 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.BVar(1)); - let x3 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), x2)); - let x4 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 59), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 66), x0)), x3)), x4)))))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 69), x0)), x2)), x4)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 68), x0)), x3)), x4)))))))), - 4672 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 1), x0)); - store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 73), x0)), x1)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), x1)))), - 4673 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 73), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), x1)))))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), x1)))))), - 4736 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.BVar(2)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.BVar(0)))), x3)))), store(KExprNode.Const(role_bound_addr(tbl, 6), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 74), x0)), x4)), x3)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 43), x0)), x4)), x3)))))))))))), - 4737 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.BVar(2)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.BVar(0)))), x3)))), store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 74), x0)), x4)), x3)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 41), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 43), x0)), x3)), x4)))))))))))))), - 4800 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 75), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), x1)))))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 73), x0)), x1)))))), - 4801 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 75), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), x1)))))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), x1)))))))), - 4864 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 71), x0)); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 76), x0)), store(KExprNode.App(x2, x3)))), store(KExprNode.App(x2, x4)))))), store(KExprNode.App(x2, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 42), x0)), x3)), x4)))))))))), - 4865 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.BVar(1)); - let x3 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 76), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), x2)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), x3)))))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 74), x0)), x2)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), x3)))))))))), - 4866 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.BVar(1)); - let x3 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 76), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), x2)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), x3)))))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 74), x0)), x3)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), x2)))))))))), - 4867 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 72), x0)); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 76), x0)), store(KExprNode.App(x2, x3)))), store(KExprNode.App(x2, x4)))))), store(KExprNode.App(x2, store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 42), x0)), x3)), x4)))))))))))), - 4928 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 70), x0)); - let x2 = store(KExprNode.BVar(1)); - let x3 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 77), x0)), x2)), x3)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 76), x0)), x2)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 75), x0)), x3)))))))))), - 4992 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 71), x0)); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 78), x0)), store(KExprNode.App(x2, x3)))), store(KExprNode.App(x2, x4)))))), store(KExprNode.App(x2, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x0)), x3)), x4)))))))))), - 4993 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.BVar(1)); - let x3 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 78), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), x2)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), x3)))))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 73), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x0)), x2)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), x3)))))))))))), - 4994 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.BVar(1)); - let x3 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 78), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), x2)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), x3)))))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 73), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), x2)))), x3)))))))))), - 4995 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 72), x0)); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.BVar(0)); - let x5 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 78), x0)), store(KExprNode.App(x2, x3)))), store(KExprNode.App(x2, x4)))))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x0)), store(KExprNode.App(x5, x3)))), store(KExprNode.App(x5, x4)))))))))))), - 5056 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), x1)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 79), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), x2)))))), x2)))), - 5057 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), x1)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 79), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), x2)))))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), x2)))))), - 5120 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 71), x0)); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 80), x0)), store(KExprNode.App(x2, x3)))), store(KExprNode.App(x2, x4)))))), store(KExprNode.App(x2, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 48), x0)), x3)), x4)))))))))), - 5121 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 71), x0)); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 80), x0)), store(KExprNode.App(x2, x3)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), x4)))))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 75), x0)), store(KExprNode.App(x2, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 48), x0)), x3)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), x4)))))))))))))), - 5122 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))); - store(KExprNode.Forall(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 80), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(0)))))), x1)))), x1)))), - 5123 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 72), x0)); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.BVar(0)))); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 80), x0)), store(KExprNode.App(x2, x3)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), x4)))))), store(KExprNode.App(x2, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 48), x0)), x3)), x4)))))))))), - 5124 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 72), x0)); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.BVar(0)); - let x5 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 80), x0)), store(KExprNode.App(x2, x3)))), store(KExprNode.App(x2, x4)))))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.App(x5, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 48), x0)), x3)), store(KExprNode.App(x5, x4)))))))))))))), - 5184 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 71), x0)); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 81), x0)), store(KExprNode.App(x2, x3)))), store(KExprNode.App(x2, x4)))))), store(KExprNode.App(x2, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 49), x0)), x3)), x4)))))))))), - 5185 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 71), x0)); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 81), x0)), store(KExprNode.App(x2, x3)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), x4)))))), store(KExprNode.App(x2, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 49), x0)), x3)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), x4)))))))))))), - 5186 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.BVar(1)); - let x3 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 81), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), x2)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), x3)))))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 74), x0)), x3)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 49), x0)), x2)), x3)))))))))))), - 5187 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 72), x0)); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.BVar(0)); - let x5 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x6 = store(KExprNode.App(x5, x4)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 81), x0)), store(KExprNode.App(x2, x3)))), store(KExprNode.App(x2, x4)))))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 74), x0)), x6)), store(KExprNode.App(x5, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 49), x0)), x3)), x6)))))))))))), - 5248 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 71), x0)); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 82), x0)), store(KExprNode.App(x2, x3)))), x4)))), store(KExprNode.App(x2, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 45), x0)), x3)), x4)))))))))), - 5249 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x4 = store(KExprNode.Const(role_bound_addr(tbl, 1), x0)); - let x5 = store(KExprNode.BVar(2)); - let x6 = store(KExprNode.BVar(1)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 46), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 49), x0)), store(KExprNode.BVar(0)))), store(KExprNode.App(x3, store(KExprNode.App(x3, x4)))))))), x4)))), store(KExprNode.Const(role_bound_addr(tbl, 6), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 82), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), x5)))), x6)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 45), x0)), store(KExprNode.App(x3, x5)))), x6)))))))))))), - 5250 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x4 = store(KExprNode.Const(role_bound_addr(tbl, 1), x0)); - let x5 = store(KExprNode.BVar(2)); - let x6 = store(KExprNode.BVar(1)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 46), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 49), x0)), store(KExprNode.BVar(0)))), store(KExprNode.App(x3, store(KExprNode.App(x3, x4)))))))), x4)))), store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 82), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), x5)))), x6)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 75), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 45), x0)), store(KExprNode.App(x3, x5)))), x6)))))))))))))), - 5440 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.BVar(1)); - let x3 = store(KExprNode.BVar(0)); - let x4 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 85), x0)), x2)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 84), x0)), x2)), x3)))))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 49), x0)), x3)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 45), x0)), store(KExprNode.App(x4, store(KExprNode.App(x4, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))))), x2)))))))))), - 5504 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.BVar(2)); - let x3 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 84), x0)), x2)); - let x4 = store(KExprNode.BVar(1)); - let x5 = store(KExprNode.BVar(0)); - let x6 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x7 = store(KExprNode.Const(role_bound_addr(tbl, 49), x0)); - let x8 = store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 45), x0)), store(KExprNode.App(x6, store(KExprNode.App(x6, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))))), x2)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 86), x0)), x2)), store(KExprNode.App(x3, x4)))), store(KExprNode.App(x3, x5)))))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.App(x6, store(KExprNode.App(store(KExprNode.App(x7, x4)), x8)))))), store(KExprNode.App(store(KExprNode.App(x7, x5)), x8)))))))))))), - 5568 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 37), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), x3)), x3)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 87), x0)), x3)), x3)))))), store(KExprNode.Const(role_bound_addr(tbl, 6), x0)))))), - 5760 => - let x0 = store(KLevelNode.Zero); - let x1 = store(ListNode.Nil); - store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(x0)), x1)))), store(KExprNode.Const(role_bound_addr(tbl, 88), x1)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 90), x1)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 38), x1)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 30), store(ListNode.Cons(x0, x1)))), store(KExprNode.Const(role_bound_addr(tbl, 39), x1)))))))))), store(KExprNode.Const(role_bound_addr(tbl, 89), x1)))), - 5824 => - let x0 = store(KLevelNode.Param(0)); - let x1 = store(KLevelNode.Succ(x0)); - let x2 = store(ListNode.Nil); - let x3 = store(ListNode.Cons(x0, x2)); - let x4 = store(KExprNode.Const(role_bound_addr(tbl, 29), x3)); - let x5 = store(KExprNode.BVar(0)); - let x6 = store(KExprNode.BVar(1)); - store(KExprNode.Forall(store(KExprNode.Srt(x1)), store(KExprNode.Forall(store(KExprNode.App(x4, x5)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(x1, x2)))), store(KExprNode.App(x4, x6)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 91), x3)), x6)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 30), x3)), x6)))), x5)))), x5)))))), - 5825 => - let x0 = store(KLevelNode.Param(0)); - let x1 = store(KLevelNode.Succ(x0)); - let x2 = store(KExprNode.BVar(0)); - let x3 = store(ListNode.Nil); - let x4 = store(ListNode.Cons(x0, x3)); - let x5 = store(KExprNode.Const(role_bound_addr(tbl, 29), x4)); - let x6 = store(KExprNode.BVar(1)); - let x7 = store(KExprNode.BVar(2)); - let x8 = store(KExprNode.BVar(3)); - let x9 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 91), x4)), x8)); - let x10 = store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 31), x4)), x8)), x7)); - store(KExprNode.Forall(store(KExprNode.Srt(x1)), store(KExprNode.Forall(x2, store(KExprNode.Forall(store(KExprNode.App(x5, x6)), store(KExprNode.Forall(store(KExprNode.App(x5, x7)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(x1, x3)))), store(KExprNode.App(x5, x8)))), store(KExprNode.App(store(KExprNode.App(x9, store(KExprNode.App(x10, x6)))), x2)))), store(KExprNode.App(x10, store(KExprNode.App(store(KExprNode.App(x9, x6)), x2)))))))))))))), - 5888 => - let x0 = store(KLevelNode.Zero); - let x1 = store(ListNode.Nil); - let x2 = store(ListNode.Cons(x0, x1)); - let x3 = store(KExprNode.Const(role_bound_addr(tbl, 39), x1)); - let x4 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 29), x2)), x3)); - let x5 = store(KExprNode.Const(role_bound_addr(tbl, 38), x1)); - let x6 = store(KExprNode.BVar(1)); - let x7 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x4, store(KExprNode.Forall(x4, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(x0)), x1)))), store(KExprNode.Const(role_bound_addr(tbl, 37), x1)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 92), x1)), store(KExprNode.App(x5, x6)))), store(KExprNode.App(x5, x7)))))), store(KExprNode.App(x5, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 91), x2)), x3)), x6)), x7)))))))))), - 5952 => - let x0 = store(KLevelNode.Param(0)); - let x1 = store(KExprNode.BVar(0)); - let x2 = store(KExprNode.BVar(2)); - let x3 = store(KExprNode.BVar(3)); - let x4 = store(ListNode.Nil); - let x5 = store(ListNode.Cons(x0, x4)); - let x6 = store(KExprNode.BVar(4)); - let x7 = store(KExprNode.BVar(1)); - store(KExprNode.Forall(store(KExprNode.Srt(x0)), store(KExprNode.Forall(store(KExprNode.Srt(store(KLevelNode.Zero))), store(KExprNode.Forall(x1, store(KExprNode.Forall(x2, store(KExprNode.Forall(x3, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), x5)), x6)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 93), x5)), x6)), x3)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 60), x4)), x3)), x2)))), x7)), x1)))), x7)))))))))))), - 5953 => - let x0 = store(KLevelNode.Param(0)); - let x1 = store(ListNode.Nil); - let x2 = store(KExprNode.BVar(0)); - let x3 = store(KExprNode.BVar(2)); - let x4 = store(KExprNode.BVar(3)); - let x5 = store(ListNode.Cons(x0, x1)); - let x6 = store(KExprNode.BVar(4)); - store(KExprNode.Forall(store(KExprNode.Srt(x0)), store(KExprNode.Forall(store(KExprNode.Srt(store(KLevelNode.Zero))), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 62), x1)), x2)), store(KExprNode.Forall(x3, store(KExprNode.Forall(x4, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), x5)), x6)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 93), x5)), x6)), x4)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 61), x1)), x4)), x3)))), store(KExprNode.BVar(1)))), x2)))), x2)))))))))))), - 6080 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.Const(role_bound_addr(tbl, 71), x0)); - let x4 = store(KExprNode.BVar(1)); - let x5 = store(KExprNode.App(x3, x4)); - let x6 = store(KExprNode.BVar(0)); - let x7 = store(KExprNode.App(x3, x6)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), x5)), x7)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 95), x0)), x5)), x7)))))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 46), x0)), x4)), x6)))))))), - 6081 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.BVar(1)))); - let x4 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(0)))); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), x3)), x4)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 95), x0)), x3)), x4)))))), store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))))))), - 6082 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(1)))); - let x4 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.BVar(0)))); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), x3)), x4)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 95), x0)), x3)), x4)))))), store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))))))), - 6083 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.Const(role_bound_addr(tbl, 72), x0)); - let x4 = store(KExprNode.BVar(1)); - let x5 = store(KExprNode.App(x3, x4)); - let x6 = store(KExprNode.BVar(0)); - let x7 = store(KExprNode.App(x3, x6)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 70), x0)))), x5)), x7)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 95), x0)), x5)), x7)))))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 46), x0)), x4)), x6)))))))), - 6144 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 71), x0)); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.App(x2, x3)); - let x5 = store(KExprNode.BVar(0)); - let x6 = store(KExprNode.App(x2, x5)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 94), x0)), x4)), x6)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 96), x0)), x4)), x6)))))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), x3)), x5)))))))), - 6145 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.BVar(1)))); - let x3 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(0)))); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 94), x0)), x2)), x3)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 96), x0)), x2)), x3)))))), store(KExprNode.Const(role_bound_addr(tbl, 5), x0)))))))), - 6146 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 72), x0)), store(KExprNode.BVar(1)))); - let x3 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.BVar(0)))); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 94), x0)), x2)), x3)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 96), x0)), x2)), x3)))))), store(KExprNode.Const(role_bound_addr(tbl, 6), x0)))))))), - 6147 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 72), x0)); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.App(x2, x3)); - let x5 = store(KExprNode.BVar(0)); - let x6 = store(KExprNode.App(x2, x5)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 65), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 94), x0)), x4)), x6)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 96), x0)), x4)), x6)))))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), x5)), x3)))))))), - 6208 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 70), x0)); - let x2 = store(KExprNode.BVar(1)); - let x3 = store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 76), x0)), x2)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 71), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 2), x0)), store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))))))); - let x4 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 59), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 94), x0)), x3)), x4)))))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 97), x0)), x2)), x4)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 96), x0)), x3)), x4)))))))), - 6272 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 70), x0)); - let x2 = store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)); - let x3 = store(KExprNode.BVar(1)); - let x4 = store(KExprNode.BVar(0)); - let x5 = store(KExprNode.Const(role_bound_addr(tbl, 76), x0)); - let x6 = store(KExprNode.Const(role_bound_addr(tbl, 71), x0)); - let x7 = store(KExprNode.App(x6, x4)); - let x8 = store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 81), x0)), x3)), x7)); - let x9 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x10 = store(KExprNode.App(x9, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))); - let x11 = store(KExprNode.App(x6, x10)); - let x12 = store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 80), x0)), store(KExprNode.App(store(KExprNode.App(x5, x7)), x11)))), store(KExprNode.App(x6, store(KExprNode.App(x9, x10)))))); - store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.Const(role_bound_addr(tbl, 0), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), x2)), x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 98), x0)), x3)), x4)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 93), x2)), x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 94), x0)), store(KExprNode.App(store(KExprNode.App(x5, x8)), x11)))), x12)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 97), x0)), x8)), x12)))), x8)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 77), x0)), x8)), x7)))))))))), - 6336 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 70), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x3 = store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)); - let x4 = store(KExprNode.Const(role_bound_addr(tbl, 8), x3)); - let x5 = store(KExprNode.BVar(1)); - let x6 = store(KExprNode.BVar(0)); - let x7 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 93), x3)), x1)); - let x8 = store(KExprNode.Const(role_bound_addr(tbl, 1), x0)); - let x9 = store(KExprNode.Const(role_bound_addr(tbl, 71), x0)); - let x10 = store(KExprNode.Const(role_bound_addr(tbl, 76), x0)); - let x11 = store(KExprNode.App(x9, x6)); - let x12 = store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 81), x0)), x5)), x11)); - let x13 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x14 = store(KExprNode.App(x13, x8)); - let x15 = store(KExprNode.App(x9, x14)); - let x16 = store(KExprNode.Const(role_bound_addr(tbl, 80), x0)); - let x17 = store(KExprNode.App(store(KExprNode.App(x16, store(KExprNode.App(store(KExprNode.App(x10, x11)), x15)))), store(KExprNode.App(x9, store(KExprNode.App(x13, x14)))))); - let x18 = store(KExprNode.App(store(KExprNode.App(x16, x5)), x11)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x2, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x4, x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 99), x0)), x5)), x6)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x7, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x4, x2)), x6)), x8)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 67), x0)), x6)), x8)))), store(KExprNode.App(x9, x8)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x7, store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 94), x0)), store(KExprNode.App(store(KExprNode.App(x10, x12)), x15)))), x17)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 97), x0)), x12)), x17)))), x18)), store(KExprNode.App(store(KExprNode.App(x10, x18)), x15)))))))))))), - 6400 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x4 = store(KExprNode.App(x3, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))); - let x5 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x0)), store(KExprNode.App(x3, x4)))); - store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 47), x0)), store(KExprNode.App(x3, store(KExprNode.BVar(0)))))), store(KExprNode.App(x5, store(KExprNode.App(x5, store(KExprNode.App(x5, store(KExprNode.App(x5, store(KExprNode.App(x5, store(KExprNode.App(x5, store(KExprNode.App(x5, x4)))))))))))))))))), store(KExprNode.Const(role_bound_addr(tbl, 6), x0)))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 100), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 40), x0)), store(KExprNode.BVar(1)))))))), x4)))))), - 6401 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))); - let x4 = store(KExprNode.Const(role_bound_addr(tbl, 47), x0)); - let x5 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x6 = store(KExprNode.App(x5, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))); - let x7 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x0)), store(KExprNode.App(x5, x6)))); - let x8 = store(KExprNode.App(x7, x6)); - let x9 = store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, x8)))))))))))); - let x10 = store(KExprNode.Const(role_bound_addr(tbl, 6), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x3, store(KExprNode.App(store(KExprNode.App(x4, x9)), store(KExprNode.BVar(0)))))), x10)), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x3, store(KExprNode.App(store(KExprNode.App(x4, store(KExprNode.App(x5, store(KExprNode.BVar(1)))))), store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, x9)))))))))))), x10)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 100), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 40), x0)), store(KExprNode.BVar(2)))))))), x8)))))))), - 6402 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))); - let x4 = store(KExprNode.Const(role_bound_addr(tbl, 47), x0)); - let x5 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x6 = store(KExprNode.App(x5, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))); - let x7 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x0)), store(KExprNode.App(x5, x6)))); - let x8 = store(KExprNode.App(x7, x6)); - let x9 = store(KExprNode.Const(role_bound_addr(tbl, 6), x0)); - let x10 = store(KExprNode.App(x5, x8)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x3, store(KExprNode.App(store(KExprNode.App(x4, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, x8)))))))))))))))))))))), store(KExprNode.BVar(0)))))), x9)), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x3, store(KExprNode.App(store(KExprNode.App(x4, store(KExprNode.App(x5, store(KExprNode.BVar(1)))))), store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x5, store(KExprNode.App(x7, store(KExprNode.App(x5, store(KExprNode.App(x7, store(KExprNode.App(x7, x10)))))))))))))))))))))))))))))))))))), x9)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 100), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 40), x0)), store(KExprNode.BVar(2)))))))), x10)))))))), - 6403 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))); - let x4 = store(KExprNode.Const(role_bound_addr(tbl, 47), x0)); - let x5 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x6 = store(KExprNode.App(x5, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))); - let x7 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x0)), store(KExprNode.App(x5, x6)))); - let x8 = store(KExprNode.App(x7, x6)); - let x9 = store(KExprNode.App(x5, x8)); - let x10 = store(KExprNode.Const(role_bound_addr(tbl, 6), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x3, store(KExprNode.App(store(KExprNode.App(x4, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x5, store(KExprNode.App(x7, x9)))))))))))))))))))))))))))))))), store(KExprNode.BVar(0)))))), x10)), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x3, store(KExprNode.App(store(KExprNode.App(x4, store(KExprNode.App(x5, store(KExprNode.BVar(1)))))), store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, x8)))))))))))))))))))))))))))))))))), x10)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 100), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 40), x0)), store(KExprNode.BVar(2)))))))), x9)))))))), - 6404 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 0), x0)); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(store(KLevelNode.Zero))), x0)))); - let x3 = store(KExprNode.App(x2, store(KExprNode.Const(role_bound_addr(tbl, 4), x0)))); - let x4 = store(KExprNode.Const(role_bound_addr(tbl, 47), x0)); - let x5 = store(KExprNode.Const(role_bound_addr(tbl, 2), x0)); - let x6 = store(KExprNode.App(x5, store(KExprNode.Const(role_bound_addr(tbl, 1), x0)))); - let x7 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x0)), store(KExprNode.App(x5, x6)))); - let x8 = store(KExprNode.App(x7, store(KExprNode.App(x7, x6)))); - let x9 = store(KExprNode.App(x7, store(KExprNode.App(x7, x8)))); - let x10 = store(KExprNode.Const(role_bound_addr(tbl, 6), x0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x3, store(KExprNode.App(store(KExprNode.App(x4, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, x9)))))))))))))))))))))))))), store(KExprNode.BVar(0)))))), x10)), store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.App(x3, store(KExprNode.App(store(KExprNode.App(x4, store(KExprNode.App(x5, store(KExprNode.BVar(1)))))), store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x7, store(KExprNode.App(x5, x9)))))))))))))))))))))))))))))))))))))), x10)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(x2, x1)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 100), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 40), x0)), store(KExprNode.BVar(2)))))))), x8)))))))), - 6464 => - let x0 = store(KLevelNode.Zero); - let x1 = store(ListNode.Nil); - store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(x0)), x1)))), store(KExprNode.Const(role_bound_addr(tbl, 0), x1)))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 101), x1)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 38), x1)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 30), store(ListNode.Cons(x0, x1)))), store(KExprNode.Const(role_bound_addr(tbl, 39), x1)))))))))), store(KExprNode.Const(role_bound_addr(tbl, 1), x1)))), - 6465 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 39), x0)); - let x2 = store(KLevelNode.Zero); - let x3 = store(ListNode.Cons(x2, x0)); - let x4 = store(KExprNode.Const(role_bound_addr(tbl, 101), x0)); - let x5 = store(KExprNode.Const(role_bound_addr(tbl, 38), x0)); - let x6 = store(KExprNode.BVar(1)); - let x7 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 29), x3)), x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(x2)), x0)))), store(KExprNode.Const(role_bound_addr(tbl, 0), x0)))), store(KExprNode.App(x4, store(KExprNode.App(x5, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 31), x3)), x1)), x6)), x7)))))))), store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 42), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 100), x0)), x6)))), store(KExprNode.App(x4, store(KExprNode.App(x5, x7)))))))))))), - 6528 => - let x0 = store(KLevelNode.Zero); - let x1 = store(ListNode.Nil); - let x2 = store(KExprNode.Const(role_bound_addr(tbl, 39), x1)); - let x3 = store(KExprNode.Const(role_bound_addr(tbl, 2), x1)); - let x4 = store(KExprNode.App(x3, store(KExprNode.Const(role_bound_addr(tbl, 1), x1)))); - let x5 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 44), x1)), store(KExprNode.App(x3, x4)))); - store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(x0)), x1)))), x2)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 102), x1)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 38), x1)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 30), store(ListNode.Cons(x0, x1)))), x2)))))))), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 40), x1)), store(KExprNode.App(x3, store(KExprNode.App(x5, store(KExprNode.App(x5, store(KExprNode.App(x5, store(KExprNode.App(x5, store(KExprNode.App(x5, store(KExprNode.App(x5, x4)))))))))))))))))), - 6529 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 39), x0)); - let x2 = store(KLevelNode.Zero); - let x3 = store(ListNode.Cons(x2, x0)); - let x4 = store(KExprNode.BVar(0)); - store(KExprNode.Forall(x1, store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(x2)), x0)))), x1)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 102), x0)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 38), x0)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 31), x3)), x1)), x4)), store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 30), x3)), x1)))))))))), x4)))), - 6530 => - let x0 = store(ListNode.Nil); - let x1 = store(KExprNode.Const(role_bound_addr(tbl, 39), x0)); - let x2 = store(KLevelNode.Zero); - let x3 = store(ListNode.Cons(x2, x0)); - let x4 = store(KExprNode.Const(role_bound_addr(tbl, 102), x0)); - let x5 = store(KExprNode.Const(role_bound_addr(tbl, 38), x0)); - let x6 = store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 31), x3)), x1)); - let x7 = store(KExprNode.App(store(KExprNode.App(x6, store(KExprNode.BVar(1)))), store(KExprNode.BVar(0)))); - store(KExprNode.Forall(x1, store(KExprNode.Forall(x1, store(KExprNode.Forall(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 29), x3)), x1)), store(KExprNode.App(store(KExprNode.App(store(KExprNode.App(store(KExprNode.Const(role_bound_addr(tbl, 8), store(ListNode.Cons(store(KLevelNode.Succ(x2)), x0)))), x1)), store(KExprNode.App(x4, store(KExprNode.App(x5, store(KExprNode.App(store(KExprNode.App(x6, store(KExprNode.BVar(2)))), x7)))))))), store(KExprNode.App(x4, store(KExprNode.App(x5, x7)))))))))))), - _ => store(KExprNode.Srt(store(KLevelNode.Zero))), - } - } - - fn role_prim_family(r: G) -> (G, G) { - match r { - 2 => (1, 1), - 38 => (2, 1), - 41 => (1, 2), - 42 => (1, 3), - 43 => (1, 4), - 44 => (1, 5), - 45 => (1, 9), - 46 => (1, 15), - 47 => (1, 16), - 48 => (1, 6), - 49 => (1, 7), - 50 => (1, 8), - 51 => (1, 10), - 52 => (1, 11), - 53 => (1, 12), - 54 => (1, 13), - 55 => (1, 14), - 67 => (5, 3), - 68 => (5, 2), - 69 => (5, 1), - 75 => (6, 1), - 76 => (6, 6), - 77 => (6, 7), - 78 => (6, 8), - 79 => (6, 2), - 80 => (6, 10), - 81 => (6, 9), - 82 => (6, 5), - 85 => (3, 1), - 86 => (3, 2), - 87 => (2, 5), - 90 => (2, 4), - 92 => (2, 6), - 95 => (5, 6), - 96 => (5, 5), - 97 => (5, 4), - 98 => (6, 3), - 99 => (6, 4), - 101 => (2, 2), - 102 => (2, 3), - _ => (0, 0), - } - } - -⟧ - -end IxVM - -end diff --git a/Ix/IxVM/Kernel/Roles.lean b/Ix/IxVM/Kernel/Roles.lean deleted file mode 100644 index a73469409..000000000 --- a/Ix/IxVM/Kernel/Roles.lean +++ /dev/null @@ -1,854 +0,0 @@ -module -public import Ix.Aiur.Meta -public import Ix.IxVM.KernelTypes -public import Ix.IxVM.Ingress - -public section - -namespace IxVM - -/-! ## Roles — the claim's binding, read and validated in the circuit - -A typing claim names a role binding (`Ix.ClaimContext.binding`): the BLAKE3 -hash of a role table's `E8 03` section, which binds IxC's roles -(`Ix.Kernel.Role`) to constants and carries the evidence of the `Nat` -operations. IxVM recognizes its primitives only through that table: a -constant plays a role because the table binds it, never because of its -address. - -The table is prover data, so no role is used before it is validated -against IxC's specification of it (`Ix/IxVM/Kernel/RoleSpec.lean`, rendered -from `Ix.Kernel.Role.spec`). Roles are validated by group, as the -specifications group them (`Role.block`), in the order of the rendered -`group_roles`, and a group is admitted whole or not at all: - -- a block member (the basis blocks and the standard axioms' families `Iff` - and `Nonempty`) must be a safe constant of the kind IxVM expects - (inductive, constructor, recursor, quotient or axiom) with the specified - level count and type, and its constructors must be the block's own; the - member is then checked like any constant, so its recursor's rules are the - canonical ones for the specified inductive; -- an anchor (the literal support, `Bool`, `True` and `And`) must be safe, - with the specified level count and type: its type alone, as IxC and the - Rust kernel validate it; -- a standard axiom (`propext`, `Classical.choice`) must be a safe axiom of - the specified type, over its families as blocks; `sorryAx` must be a safe - axiom of its specified type, and no use of it is accepted; -- an operation must be a safe level-0 definition of the specified type that - checks, and its equations must hold: each structural equation by - definitional equality, each well-founded one by a theorem of the - certificate's statement, which is checked with its dependencies. - -A group is validated under a role context (`RoleCtx`) that admits only the -groups before it, so an operation's own fast path cannot take part in -validating it. The well-founded operations form a contiguous block and share -the context before that block (`group_validation_limit`): no well-founded -operation's fast path takes part in validating any of them. Later groups -share the context before the first definition specified by equations. They -can use the already validated well-founded operations, but no equation -definition's fast path takes part in validating another. The generator checks -this group arrangement. Shared dependencies are checked once per context. -Validation is lazy and -memoized: it runs the first time a claim uses a role of the group, once per -claim. A binding that does not meet the specifications makes every claim -that uses the failing role abort; it never makes a role usable. - -A walk over a claim's dependencies that reaches a bound role whose -admission checks it with its dependencies (a basis inductive, constructor -or recursor, or an operation) checks it under the context its group is -validated in (`walk_ctx`), not the claim's. When the claim also uses the -role, the check is the admission's own, done once; when it does not, the -walk admits nothing and checks the constant as its group would. Checking -under fewer usable roles is never weaker. Under the standard axiom policy it -declines a little more: a constant bound to such a role whose dependencies -use a standard axiom whose group comes after its own is declined even when -the claim never uses the role, as its group's validation would decline it. - -A claim covers a constant's dependencies, not a whole environment, so the -constants the kernel introduces into a claim's terms without the claim -referencing them (a string literal's type and the constants of its -constructor form) are dependencies the claim checks like referenced ones -(`role_used_implicitly`). That check runs under the claim's context, not -while a group is validated. - -The role context is threaded through the kernel: every function that may -reach a primitive takes it. -/ - -def roles := ⟦ - enum RoleEvidence { - Defeq, - Proof(Addr) - } - - -- A role table: its binding hash, the bound address by role, 1 + the role - -- by bound address (keyed by the address's interned pointer, which - -- content addressing makes unique), and the evidence entries by role. - enum RoleTableNode { - Mk(Addr, RBTreeMap‹Addr›, RBTreeMap‹G›, RBTreeMap‹List‹RoleEvidence››) - } - - type RoleTable = &RoleTableNode - - -- A role context: a table, the number of groups usable under it, and the - -- claim's user axioms; or a table assumed to meet the specifications (a - -- claim that assumes its binding), under which every bound role is usable - -- and none is admitted. - enum RoleCtxNode { - Mk(RoleTable, G, RBTreeMap‹G›), - Assumed(RoleTable, RBTreeMap‹G›) - } - - type RoleCtx = &RoleCtxNode - - -- ========================================================================== - -- Reading the table (channel 6, keyed by the binding hash). - -- - -- `E8 03 v n (r a)ⁿ m (r k e₁…e_k)ᵐ`, one byte per integer; `e` is `00` - -- (definitional) or `01` and an address (proof). Role indices strictly - -- increase in both lists, as the canonical codec requires. - -- ========================================================================== - fn load_role_table(binding: Addr) -> RoleTable { - let raw = load(binding); - let (idx, len) = io_get_info(6, raw); - let bytes = read_checked_byte_stream(6, idx, len); - verify_bytes_against(bytes, raw); - let (t0, s) = read_byte(bytes); - assert_eq!(t0, 0xE8u8, "role table: not a binding section"); - let (t1, s) = read_byte(s); - assert_eq!(t1, 0x03u8, "role table: not a binding section"); - let (version, s) = read_byte(s); - assert_eq!(to_field(version), @spec_version(), - "role table: made for another specification version"); - let (n, s) = read_byte(s); - let (by_role, by_addr, _next, s) = - read_role_bindings(s, to_field(n), 0, RBTreeMap.Nil); - let (m, s) = read_byte(s); - let (evidence, _next, s) = read_role_evidence(s, to_field(m), 0); - assert_eq!(load(s), ListNode.Nil, "role table: trailing bytes"); - store(RoleTableNode.Mk(binding, by_role, by_addr, evidence)) - } - - -- The two maps keyed by role are read straight into balanced trees: the - -- entries arrive in strictly increasing role order, so the first half of - -- a run is the left subtree, the next entry the root and the rest the - -- right subtree, and no insertion or rebalancing is needed. Lookups ignore - -- colours, and nothing inserts into a table once it is read. The index by - -- address is keyed by interned pointers, in no particular order, so it is - -- built by insertion. - - -- `count` bindings, in order, each role index at least `next`: the tree - -- by role, the index by address extended, and the least role index the - -- next binding may have. - fn read_role_bindings(s: ByteStream, count: G, next: G, by_addr: RBTreeMap‹G›) - -> (RBTreeMap‹Addr›, RBTreeMap‹G›, G, ByteStream) { - match count { - 0 => (RBTreeMap.Nil, by_addr, next, s), - _ => - let half = to_field(u8_shift_right(u8_from_field_unsafe(count))); - let (left, by_addr, next, s) = read_role_bindings(s, half, next, by_addr); - let (rb, s) = read_byte(s); - let r = to_field(rb); - assert_eq!(u32_less_than(r, @role_count()), 1, "role table: unknown role"); - assert_eq!(u32_less_than(r, next), 0, "role table: roles out of order"); - let (a, s) = get_address(s); - assert_eq!(rbtree_map_lookup_or_default(ptr_val(a), by_addr, 0), 0, - "role table: an address is bound to two roles"); - let by_addr = rbtree_map_insert(ptr_val(a), r + 1, by_addr); - let (right, by_addr, next, s) = - read_role_bindings(s, count - (half + 1), r + 1, by_addr); - (RBTreeMap.Node(1, r, a, store(left), store(right)), by_addr, next, s), - } - } - - -- `count` evidence entries, in order, each role index at least `next`: - -- the tree by role and the least role index the next entry may have. - fn read_role_evidence(s: ByteStream, count: G, next: G) - -> (RBTreeMap‹List‹RoleEvidence››, G, ByteStream) { - match count { - 0 => (RBTreeMap.Nil, next, s), - _ => - let half = to_field(u8_shift_right(u8_from_field_unsafe(count))); - let (left, next, s) = read_role_evidence(s, half, next); - let (rb, s) = read_byte(s); - let r = to_field(rb); - assert_eq!(u32_less_than(r, @role_count()), 1, "role table: unknown role"); - assert_eq!(u32_less_than(r, next), 0, "role table: evidence out of order"); - let (kb, s) = read_byte(s); - let (entries, s) = read_evidence_entries(s, to_field(kb)); - let (right, next, s) = read_role_evidence(s, count - (half + 1), r + 1); - (RBTreeMap.Node(1, r, entries, store(left), store(right)), next, s), - } - } - - fn read_evidence_entries(s: ByteStream, count: G) -> (List‹RoleEvidence›, ByteStream) { - match count { - 0 => (store(ListNode.Nil), s), - _ => - let (tag, s) = read_byte(s); - match tag { - 0 => - let (rest, s) = read_evidence_entries(s, count - 1); - (store(ListNode.Cons(RoleEvidence.Defeq, rest)), s), - 1 => - let (a, s) = get_address(s); - let (rest, s) = read_evidence_entries(s, count - 1); - (store(ListNode.Cons(RoleEvidence.Proof(a), rest)), s), - }, - } - } - - -- ========================================================================== - -- Role contexts and admission. - -- ========================================================================== - - -- The context a claim is checked under: its binding's table, every group - -- usable, and no user axioms. - fn role_ctx_of_binding(binding: Addr) -> RoleCtx { - store(RoleCtxNode.Mk(load_role_table(binding), @group_count(), RBTreeMap.Nil)) - } - - -- The context of a claim that assumes its binding meets the - -- specifications: its binding's table, read but not validated, and no user - -- axioms. - fn role_ctx_assumed(binding: Addr) -> RoleCtx { - store(RoleCtxNode.Assumed(load_role_table(binding), RBTreeMap.Nil)) - } - - -- The context of a claim, by its validator: 3 validates the binding, 4 - -- assumes it (with no user axioms). - fn role_ctx_for_validator(binding: Addr, validator: G) -> RoleCtx { - load_role_ctx(binding, validator, Option.None) - } - - -- Validate every leaf in the claim's `axioms` tree: each must be a safe - -- `KConstantInfo.Axiom` not bound in `tbl`. - fn validate_user_axioms(tbl: RoleTable, leaves: List‹Addr›, acc: RBTreeMap‹G›) - -> RBTreeMap‹G› { - match load(leaves) { - ListNode.Nil => acc, - ListNode.Cons(a, rest) => - assert_eq!(rbtree_map_lookup_or_default(ptr_val(a), role_addr_index(tbl), 0), 0, - "claim: user axiom is bound in the role table"); - match load(get_ci(a)) { - KConstantInfo.Axiom(_, _, u) => - assert_eq!(u, 0, "claim: user axiom is unsafe"); - validate_user_axioms(tbl, rest, rbtree_map_insert(ptr_val(a), 1, acc)), - _ => - assert_eq!(0, 1, "claim: axioms tree entry is not an axiom"); - acc, - }, - } - } - - -- Load the role context for `(binding, validator, axioms_opt)`. - fn load_role_ctx(binding: Addr, validator: G, axioms_opt: Option‹Addr›) -> RoleCtx { - let tbl = load_role_table(binding); - let axioms = match axioms_opt { - Option.None => RBTreeMap.Nil, - Option.Some(ax_root) => - validate_user_axioms(tbl, load_assumption_tree(ax_root), RBTreeMap.Nil), - }; - match validator { - 3 => store(RoleCtxNode.Mk(tbl, @group_count(), axioms)), - 4 => store(RoleCtxNode.Assumed(tbl, axioms)), - _ => - assert_eq!(0, 1, "claim: wrong validator identity"); - store(RoleCtxNode.Mk(tbl, @group_count(), axioms)), - } - } - - -- The validator a claim checked under `rc` names: 3, or 4 when it - -- assumes its binding. - fn role_ctx_validator(rc: RoleCtx) -> G { - 3 + role_ctx_is_assumed(rc) - } - - fn role_ctx_table(rc: RoleCtx) -> RoleTable { - match load(rc) { - RoleCtxNode.Mk(tbl, _, _) => tbl, - RoleCtxNode.Assumed(tbl, _) => tbl, - } - } - - fn role_ctx_axioms(rc: RoleCtx) -> RBTreeMap‹G› { - match load(rc) { - RoleCtxNode.Mk(_, _, axioms) => axioms, - RoleCtxNode.Assumed(_, axioms) => axioms, - } - } - - -- 1 iff `rc` assumes its binding. - fn role_ctx_is_assumed(rc: RoleCtx) -> G { - match load(rc) { - RoleCtxNode.Mk(_, _, _) => 0, - RoleCtxNode.Assumed(_, _) => 1, - } - } - - -- The binding hash `rc` reads roles through. - fn role_ctx_binding(rc: RoleCtx) -> Addr { - match load(role_ctx_table(rc)) { - RoleTableNode.Mk(binding, _, _, _) => binding, - } - } - - -- The address the table binds to `r`, or the zero address when it binds - -- none. - fn role_bound_addr_or_zero(tbl: RoleTable, r: G) -> Addr { - match load(tbl) { - RoleTableNode.Mk(_, by_role, _, _) => - rbtree_map_lookup_or_default(r, by_role, store([0u8; 32])), - } - } - - -- 1 iff the table binds role `r`: its address maps back to `r`. - fn role_is_bound(tbl: RoleTable, r: G) -> G { - let a = role_bound_addr_or_zero(tbl, r); - match rbtree_map_lookup_or_default(ptr_val(a), role_addr_index(tbl), 0) - (r + 1) { - 0 => 1, - _ => 0, - } - } - - -- The address the table binds to `r`; the table must bind it. Used to - -- read specifications, which name other roles by their bound addresses. - fn role_bound_addr(tbl: RoleTable, r: G) -> Addr { - assert_eq!(role_is_bound(tbl, r), 1, - "role table does not bind a role the claim needs"); - role_bound_addr_or_zero(tbl, r) - } - - fn role_addr_index(tbl: RoleTable) -> RBTreeMap‹G› { - match load(tbl) { - RoleTableNode.Mk(_, _, by_addr, _) => by_addr, - } - } - - -- 1 + the role bound at `a` when its group is usable under `rc`, after - -- admitting that group; 0 when `a` plays no usable role. Every use of a - -- role's meaning goes through here or `role_addr`, so nothing is read from - -- a role that has not been validated, or, under an assumed binding, that - -- the claim's condition does not cover. - fn role_of(rc: RoleCtx, a: Addr) -> G { - match load(rc) { - RoleCtxNode.Mk(tbl, limit, _) => - let r1 = rbtree_map_lookup_or_default(ptr_val(a), role_addr_index(tbl), 0); - match r1 { - 0 => 0, - _ => - match u32_less_than(role_group(r1 - 1), limit) { - 1 => - group_admit(tbl, role_group(r1 - 1)); - r1, - _ => 0, - }, - }, - RoleCtxNode.Assumed(tbl, _) => - rbtree_map_lookup_or_default(ptr_val(a), role_addr_index(tbl), 0), - } - } - - -- 1 + the role the table of `rc` binds at `a`, whether or not its group - -- is usable; 0 when it binds none. Admits nothing: a caller that uses the - -- role's meaning goes through `role_of`. - fn role_index_of(rc: RoleCtx, a: Addr) -> G { - rbtree_map_lookup_or_default(ptr_val(a), role_addr_index(role_ctx_table(rc)), 0) - } - - -- 1 iff `a` is the bound address of role `r`, usable under `rc` (and so - -- admitted). Checks `role_index_of` first so non-matching addresses never - -- call `role_of` or admit another role's group. - fn role_is(rc: RoleCtx, a: Addr, r: G) -> G { - match role_index_of(rc, a) - (r + 1) { - 0 => - match role_of(rc, a) { - 0 => 0, - _ => 1, - }, - _ => 0, - } - } - - -- The address bound to role `r`, after admitting its group; the role must - -- be usable under `rc`. - fn role_addr(rc: RoleCtx, r: G) -> Addr { - match load(rc) { - RoleCtxNode.Mk(tbl, limit, _) => - assert_eq!(u32_less_than(role_group(r), limit), 1, - "a role is used before its group is admitted"); - let a = role_bound_addr(tbl, r); - group_admit(tbl, role_group(r)); - a, - RoleCtxNode.Assumed(tbl, _) => role_bound_addr(tbl, r), - } - } - - -- The address bound to role `r`, for a constant the kernel introduces into - -- a claim's terms without the claim referencing it: the constant is then - -- a dependency of the claim, checked with its own dependencies under `rc`. - fn role_used_implicitly(rc: RoleCtx, r: G) -> Addr { - let a = role_addr(rc, r); - run_check_transitive(rc, a); - a - } - - -- 1 iff role `r` is bound and usable under `rc`; admits it when it is. - fn role_usable(rc: RoleCtx, r: G) -> G { - match load(rc) { - RoleCtxNode.Mk(tbl, limit, _) => - match u32_less_than(role_group(r), limit) * role_is_bound(tbl, r) { - 0 => 0, - _ => - group_admit(tbl, role_group(r)); - 1, - }, - RoleCtxNode.Assumed(tbl, _) => role_is_bound(tbl, r), - } - } - - -- Validate group `g` of `tbl`, once: the groups it needs first, then each - -- of its roles under a context that admits only the earlier groups. - fn group_admit(tbl: RoleTable, g: G) { - group_admit_needs(tbl, group_needs(g)); - let rc = store(RoleCtxNode.Mk(tbl, group_validation_limit(g), RBTreeMap.Nil)); - validate_group_roles(rc, tbl, group_roles(g)) - } - - -- The number of groups usable while group `g` is validated: the groups - -- before it, the prefix before the well-founded block while validating - -- that block, or the prefix before the equation groups afterwards. The - -- generator checks that the well-founded groups occupy exactly the block - -- between these boundaries. Native lookup still admits every usable role. - fn group_validation_limit(g: G) -> G { - let first_wf = @first_well_founded_group(); - match u32_less_than(g, first_wf) { - 1 => g, - _ => - let first_equation = @first_equation_group(); - match u32_less_than(g, first_equation) { - 1 => first_wf, - _ => first_equation, - }, - } - } - - -- 1 iff role `r`'s admission checks its bound constant with its - -- dependencies: a basis inductive, constructor or recursor, or an - -- operation, or a - -- definition specified by its equations. Anchors, quotient members and - -- axioms are validated by type. - fn role_admission_checks(r: G) -> G { - match role_spec_kind(r) { - 0 => - match role_member_kind(r) { - 0 => 1, - 1 => 1, - 2 => 1, - _ => 0, - }, - 2 => 1, - 5 => 1, - _ => 0, - } - } - - -- The context a walk under `rc` checks the constant at `a` in: for a role - -- usable under `rc` whose admission checks it, the context its group is - -- validated in, so the walk's check is the admission's own; otherwise - -- `rc`. Admits nothing. - fn walk_ctx(rc: RoleCtx, a: Addr) -> RoleCtx { - match load(rc) { - RoleCtxNode.Mk(tbl, limit, _) => - let r1 = rbtree_map_lookup_or_default(ptr_val(a), role_addr_index(tbl), 0); - match r1 { - 0 => rc, - _ => - let g = role_group(r1 - 1); - match u32_less_than(g, limit) * role_admission_checks(r1 - 1) { - 0 => rc, - _ => store(RoleCtxNode.Mk(tbl, group_validation_limit(g), RBTreeMap.Nil)), - }, - }, - RoleCtxNode.Assumed(_, _) => rc, - } - } - - -- 1 iff a walk under `rc` leaves the constant at `a` to the binding claim: - -- under an assumed binding, a role whose admission checks it with its - -- dependencies (a basis inductive, constructor or recursor, or an - -- operation). The claim's condition, that the binding meets the - -- specifications, covers that check; anchors, quotient members and axioms, - -- which are validated by type, are still checked as dependencies. - fn walk_covered(rc: RoleCtx, a: Addr) -> G { - match load(rc) { - RoleCtxNode.Mk(_, _, _) => 0, - RoleCtxNode.Assumed(tbl, _) => - let r1 = rbtree_map_lookup_or_default(ptr_val(a), role_addr_index(tbl), 0); - match r1 { - 0 => 0, - _ => role_admission_checks(r1 - 1), - }, - } - } - - -- Validate every group of the binding `binding`, which must bind every - -- role: what a `binding` claim states. - fn validate_binding(binding: Addr) { - let tbl = load_role_table(binding); - assert_all_roles_bound(tbl, 0); - admit_all_groups(tbl, 0) - } - - fn assert_all_roles_bound(tbl: RoleTable, r: G) { - match r - @role_count() { - 0 => (), - _ => - assert_eq!(role_is_bound(tbl, r), 1, "binding claim: a role is unbound"); - assert_all_roles_bound(tbl, r + 1), - } - } - - fn admit_all_groups(tbl: RoleTable, g: G) { - match g - @group_count() { - 0 => (), - _ => - group_admit(tbl, g); - admit_all_groups(tbl, g + 1), - } - } - - fn group_admit_needs(tbl: RoleTable, needs: List‹G›) { - match load(needs) { - ListNode.Nil => (), - ListNode.Cons(r, rest) => - group_admit(tbl, role_group(r)); - group_admit_needs(tbl, rest), - } - } - - fn validate_group_roles(rc: RoleCtx, tbl: RoleTable, rs: List‹G›) { - match load(rs) { - ListNode.Nil => (), - ListNode.Cons(r, rest) => - validate_role(rc, tbl, r); - validate_group_roles(rc, tbl, rest), - } - } - - -- ========================================================================== - -- Validators. - -- ========================================================================== - - fn validate_role(rc: RoleCtx, tbl: RoleTable, r: G) { - let a = role_bound_addr(tbl, r); - let ci = load(get_ci(a)); - assert_eq!(const_num_lvls(ci), role_levels(r), - "a bound role has the wrong number of universe parameters"); - match role_spec_kind(r) { - 0 => validate_member(rc, tbl, r, a, ci), - 1 => validate_anchor(rc, tbl, r, ci), - 2 => validate_op(rc, tbl, r, a, ci), - 3 => validate_standard_axiom(rc, tbl, r, ci), - 4 => validate_inert_axiom(rc, tbl, r, ci), - 5 => validate_eqns(rc, tbl, r, a, ci), - } - } - - -- `ty` meets the specified type: the same term, or one definitionally - -- equal to it under the earlier groups. - fn assert_type_meets(rc: RoleCtx, ty: KExpr, spec: KExpr) { - match ptr_val(ty) - ptr_val(spec) { - 0 => (), - _ => - assert_eq!(k_is_def_eq(rc, ty, spec, store(ListNode.Nil)), 1, - "a bound role's type does not meet its specification"); - (), - } - } - - fn assert_safe_role(ci: KConstantInfo) { - assert_eq!(is_unsafe_ci(ci), 0, "a bound role is unsafe"); - () - } - - fn validate_member(rc: RoleCtx, tbl: RoleTable, r: G, a: Addr, - ci: KConstantInfo) { - assert_safe_role(ci); - assert_type_meets(rc, const_type_of(ci), role_type(tbl, r)); - match role_member_kind(r) { - 0 => - match ci { - KConstantInfo.Induct(_, _, _, _, nctors, _, _, _) => - assert_eq!(nctors, role_ctor_count(r), - "a bound inductive has the wrong number of constructors"); - run_check_transitive(rc, a), - }, - 1 => - match ci { - KConstantInfo.Ctor(_, _, block, ind_idx, cidx, nparams, nfields, _) => - let (ind_role, want_cidx, want_params, want_fields) = role_ctor_of(r); - match load(get_ci(role_bound_addr(tbl, ind_role))) { - KConstantInfo.Induct(_, _, _, _, _, _, ind_block, ind_ind_idx) => - assert_eq!(address_eq(block, ind_block), 1, - "a bound constructor is not its inductive's"); - assert_eq!(ind_idx, ind_ind_idx, - "a bound constructor is not its inductive's"); - (), - }; - assert_eq!(cidx, want_cidx, "a bound constructor has the wrong index"); - assert_eq!(nparams, want_params, - "a bound constructor has the wrong number of parameters"); - assert_eq!(nfields, want_fields, - "a bound constructor has the wrong number of fields"); - run_check_transitive(rc, a), - }, - 2 => - match ci { - KConstantInfo.Rec(_, _, _, _, _, _, _, _, _, _, _) => - run_check_transitive(rc, a), - }, - 3 => - match ci { - KConstantInfo.Axiom(_, ty, _) => - validate_expr_well_scoped(ty, 0, role_levels(r)); - k_ensure_sort(rc, ty, store(ListNode.Nil)); - (), - }, - 4 => assert_quot_kind(ci, 0), - 5 => assert_quot_kind(ci, 1), - 6 => assert_quot_kind(ci, 2), - 7 => assert_quot_kind(ci, 3), - } - } - - fn assert_quot_kind(ci: KConstantInfo, want: G) { - match ci { - KConstantInfo.Quot(_, _, kind) => - let k = match kind { - QuotKind.Typ => 0, - QuotKind.Ctor => 1, - QuotKind.Lift => 2, - QuotKind.Ind => 3, - }; - assert_eq!(k, want, "a bound quotient constant has the wrong kind"); - (), - } - } - - fn validate_anchor(rc: RoleCtx, tbl: RoleTable, r: G, ci: KConstantInfo) { - assert_safe_role(ci); - assert_type_meets(rc, const_type_of(ci), role_type(tbl, r)) - } - - -- `propext` and `Classical.choice`: safe axioms of the specified types. - -- Checked here rather than through `check_const`, whose axiom policy - -- admits a standard axiom only once its group is admitted. - fn validate_standard_axiom(rc: RoleCtx, tbl: RoleTable, r: G, - ci: KConstantInfo) { - match ci { - KConstantInfo.Axiom(nlvls, ty, u) => - assert_eq!(u, 0, "a bound standard axiom is unsafe"); - validate_expr_well_scoped(ty, 0, nlvls); - k_ensure_sort(rc, ty, store(ListNode.Nil)); - assert_type_meets(rc, ty, role_type(tbl, r)), - } - } - - -- `sorryAx`: a safe axiom of its specified type, `(α : Sort u) → Bool → α`. - -- It is tolerated as a declaration and any use of it declines; its type - -- fixes which declaration is tolerated. - fn validate_inert_axiom(rc: RoleCtx, tbl: RoleTable, r: G, - ci: KConstantInfo) { - match ci { - KConstantInfo.Axiom(nlvls, ty, u) => - assert_eq!(u, 0, "a bound inert axiom is unsafe"); - validate_expr_well_scoped(ty, 0, nlvls); - k_ensure_sort(rc, ty, store(ListNode.Nil)); - assert_type_meets(rc, ty, role_type(tbl, r)), - } - } - - fn role_evidence(tbl: RoleTable, r: G) -> List‹RoleEvidence› { - match load(tbl) { - RoleTableNode.Mk(_, _, _, evidence) => - rbtree_map_lookup_or_default(r, evidence, store(ListNode.Nil)), - } - } - - fn validate_op(rc: RoleCtx, tbl: RoleTable, r: G, a: Addr, - ci: KConstantInfo) { - match ci { - KConstantInfo.Defn(_, ty, _, safety, _) => - match safety { - DefinitionSafety.Safe => (), - _ => - assert_eq!(0, 1, "a bound operation is not a safe definition"); - (), - }; - assert_type_meets(rc, ty, role_type(tbl, r)); - run_check_transitive(rc, a); - let ev = role_evidence(tbl, r); - assert_eq!(list_length(ev), op_equation_count(r), - "an operation's evidence does not match its equations"); - validate_op_equations(rc, tbl, r, ev, 0), - } - } - - fn validate_op_equations(rc: RoleCtx, tbl: RoleTable, r: G, - ev: List‹RoleEvidence›, k: G) { - match load(ev) { - ListNode.Nil => (), - ListNode.Cons(e, rest) => - match op_evidence_is_proof(r) { - 0 => - match e { - RoleEvidence.Defeq => - assert_eq!(k_is_def_eq(rc, op_equation_lhs(tbl, r, k), - op_equation_rhs(tbl, r, k), store(ListNode.Nil)), 1, - "an operation's equation does not hold by definition"); - (), - RoleEvidence.Proof(_) => - assert_eq!(0, 1, "a structural operation's evidence must be definitional"); - (), - }, - _ => - match e { - RoleEvidence.Defeq => - assert_eq!(0, 1, "a well-founded operation's evidence must be proofs"); - (), - RoleEvidence.Proof(thm) => - match load(get_ci(thm)) { - KConstantInfo.Thm(nlvls, tty, _) => - assert_eq!(nlvls, 0, "certificate theorem has universe parameters"); - run_check_transitive(rc, thm); - assert_type_meets(rc, tty, op_certificate(tbl, r, k)), - }, - }, - }; - validate_op_equations(rc, tbl, r, rest, k + 1), - } - } - - -- A definition specified by its equations: a safe definition whose type - -- meets the specified type, checked with its dependencies, and one evidence - -- entry per equation. A definitional entry is allowed only for an - -- unconditional equation, whose sides, closed over its variables, must be - -- definitionally equal; a proof entry, for any equation, is a theorem of the - -- definition's level count, checked with its dependencies, whose type meets - -- the equation's statement. - fn validate_eqns(rc: RoleCtx, tbl: RoleTable, r: G, a: Addr, - ci: KConstantInfo) { - match ci { - KConstantInfo.Defn(nlvls, ty, _, safety, _) => - match safety { - DefinitionSafety.Safe => (), - _ => - assert_eq!(0, 1, "a bound definition is not safe"); - (), - }; - assert_eq!(nlvls, role_levels(r), - "a bound definition has another number of universe parameters"); - assert_type_meets(rc, ty, role_type(tbl, r)); - run_check_transitive(rc, a); - let ev = role_evidence(tbl, r); - assert_eq!(list_length(ev), eqns_equation_count(r), - "a definition's evidence does not match its equations"); - validate_eqns_equations(rc, tbl, r, ev, 0), - } - } - - fn validate_eqns_equations(rc: RoleCtx, tbl: RoleTable, r: G, - ev: List‹RoleEvidence›, k: G) { - match load(ev) { - ListNode.Nil => (), - ListNode.Cons(e, rest) => - match e { - RoleEvidence.Defeq => - assert_eq!(eqns_conditional(r, k), 0, - "a conditional equation's evidence must be a proof"); - assert_eq!(k_is_def_eq(rc, eqns_lhs(tbl, r, k), eqns_rhs(tbl, r, k), - store(ListNode.Nil)), 1, - "a definition's equation does not hold by definition"); - (), - RoleEvidence.Proof(thm) => - match load(get_ci(thm)) { - KConstantInfo.Thm(nlvls, tty, _) => - assert_eq!(nlvls, role_levels(r), - "an equation's proof has another number of universe parameters"); - run_check_transitive(rc, thm); - assert_type_meets(rc, tty, eqns_statement(tbl, r, k)), - }, - }; - validate_eqns_equations(rc, tbl, r, rest, k + 1), - } - } - - -- ========================================================================== - -- The axiom policy: Lean's theory over its standard axioms. - -- ========================================================================== - - -- How a safe axiom at `a` stands in the claim's theory: 1 for a standard - -- axiom (`propext`, `Classical.choice`, `Quot.sound`, as the binding binds - -- them) or an axiom in the claim's `axioms` tree, 2 for the binding's - -- `sorryAx`, which may be declared but not used, and 0 for any other, which - -- is declined. Recognition of a standard axiom admits its group like any - -- role's, under `rc`'s earlier-groups rule, and no other group: an - -- address that binds no axiom role admits nothing. - fn axiom_standing(rc: RoleCtx, a: Addr) -> G { - let tbl = role_ctx_table(rc); - let r1 = rbtree_map_lookup_or_default(ptr_val(a), role_addr_index(tbl), 0); - match r1 { - 0 => rbtree_map_lookup_or_default(ptr_val(a), role_ctx_axioms(rc), 0), - _ => - let standing = axiom_role_standing(r1); - match standing { - 0 => 0, - _ => - match role_of(rc, a) { - 0 => 0, - _ => standing, - }, - }, - } - } - - -- The standing of 1 + role `r1` (0: no role). - fn axiom_role_standing(r1: G) -> G { - match r1 { - 0 => 0, - _ => - let r = r1 - 1; - match r - @role_propext() { - 0 => 1, - _ => - match r - @role_choice() { - 0 => 1, - _ => - match r - @role_quot_sound() { - 0 => 1, - _ => - match r - @role_sorry_ax() { - 0 => 2, - _ => 0, - }, - }, - }, - }, - } - } - - -- A checked constant references `a` as a constant: `sorryAx` may be - -- declared but no constant may use it. - fn assert_ref_allowed(rc: RoleCtx, a: Addr) { - match axiom_standing(rc, a) { - 2 => - assert_eq!(0, 1, "a constant uses `sorryAx`"); - (), - _ => (), - } - } -⟧ - -end IxVM - -end diff --git a/Ix/IxVM/Kernel/Subst.lean b/Ix/IxVM/Kernel/Subst.lean deleted file mode 100644 index bdd5ec3f2..000000000 --- a/Ix/IxVM/Kernel/Subst.lean +++ /dev/null @@ -1,620 +0,0 @@ -module -public import Ix.Aiur.Meta -public import Ix.IxVM.KernelTypes - -public section - -namespace IxVM - -/-! ## Substitution primitives over `KExpr` - -Two core operations: - -* `expr_lift(e, shift, cutoff)` — shift `BVar(i)` to `BVar(i+shift)` when - `i ≥ cutoff`. Crossing a binder bumps `cutoff` by 1. No-op when - `shift = 0`. - -* `expr_inst1(body, arg, depth)` — substitute `BVar(depth)` with - `expr_lift(arg, depth, 0)`. Decrement `BVar(i)` for `i > depth`. - Crossing a binder bumps `depth` by 1. - -Aiur memoization caches calls automatically; no explicit cache table. - -`KExprNode` lives in `Ix/IxVM/KernelTypes.lean`: -``` -enum KExprNode { - BVar(G), Srt(KLevel), Const(G, List‹KLevel›), - App(KExpr, KExpr), Lam(KExpr, KExpr), Forall(KExpr, KExpr), - Let(KExpr, KExpr, KExpr), Lit(KLiteral), Proj(G, G, KExpr), -} -``` --/ - -def subst := ⟦ - -- ============================================================================ - -- expr_lbr - -- - -- Loose-bvar count: `1 + max(BVar idx)` over loose (non-binder-captured) - -- variables in `e`. Returns 0 iff `e` is closed (no loose BVars). Aiur - -- memoization caches per node, so repeat calls on the same KExpr ptr are - -- O(1). First traversal cost matches a single subst walk; the payoff is - -- short-circuiting subst that would otherwise re-walk closed subtrees. - -- - -- The retired Rust kernel precomputed this (`lbr` on `KExprNode`) at - -- intern time; here it is computed on demand, memoized via `store`. - -- ============================================================================ - fn expr_lbr(e: KExpr) -> G { - match load(e) { - KExprNode.BVar(i) => i + 1, - KExprNode.Srt(_) => 0, - KExprNode.Const(_, _) => 0, - KExprNode.Lit(_) => 0, - KExprNode.App(f, a) => lbr_max(expr_lbr(f), expr_lbr(a)), - KExprNode.Lam(ty, body) => - lbr_max(expr_lbr(ty), lbr_dec(expr_lbr(body))), - KExprNode.Forall(ty, body) => - lbr_max(expr_lbr(ty), lbr_dec(expr_lbr(body))), - KExprNode.Let(ty, val, body) => expr_lbr_let(ty, val, body), - KExprNode.Proj(_, _, e1) => expr_lbr(e1), - } - } - - -- Cold-extracted Let arm: 3 recursive expr_lbr calls is the widest arm, - -- charged on every row of `expr_lbr` even though Let is rare in most - -- expressions. Its own circuit costs only the Let-arm rows. - fn expr_lbr_let(ty: KExpr, val: KExpr, body: KExpr) -> G { - lbr_max(lbr_max(expr_lbr(ty), expr_lbr(val)), - lbr_dec(expr_lbr(body))) - } - - fn lbr_max(a: G, b: G) -> G { - match u32_less_than(a, b) { - 1 => b, - 0 => a, - } - } - - fn lbr_dec(n: G) -> G { - match n { - 0 => 0, - _ => n - 1, - } - } - - fn lbr_min(a: G, b: G) -> G { - match u32_less_than(a, b) { - 1 => a, - 0 => b, - } - } - - -- ============================================================================ - -- has_bvar_in_range - -- - -- 1 iff `e` has a loose BVar with index in `[lo, hi)`. Loose means - -- not captured by a binder inside `e`; both bounds shift by 1 under - -- Lam/Forall/Let bodies so the window keeps tracking the same outer - -- binders. `expr_lbr` cannot answer this: it is `1 + max` over loose - -- BVars, so a low (local) ref hidden next to a higher (param) ref is - -- invisible to it — e.g. `App(BVar(d), BVar(0))` at depth `d` has - -- lbr `d + 1` yet references the innermost field local. - -- - -- Used by the nested-occurrence spec_params validity check in - -- `Kernel/Inductive.lean`: at extraction depth `d`, a spec_param with - -- a loose BVar in `[0, d)` depends on a field/domain-local binder. - -- The retired Rust kernel tested `sp.has_fvars()` instead - -- (Rust opens field/domain binders as fvars; Aiur keeps de Bruijn, so - -- the same references appear as loose BVars below the depth). - -- ============================================================================ - fn has_bvar_in_range(e: KExpr, lo: G, hi: G) -> G { - match load(e) { - KExprNode.BVar(i) => has_bvar_in_range_bvar(i, lo, hi), - KExprNode.Srt(_) => 0, - KExprNode.Const(_, _) => 0, - KExprNode.Lit(_) => 0, - KExprNode.App(f, a) => - match has_bvar_in_range(f, lo, hi) { - 1 => 1, - 0 => has_bvar_in_range(a, lo, hi), - }, - KExprNode.Lam(ty, body) => has_bvar_in_range_binder(ty, body, lo, hi), - KExprNode.Forall(ty, body) => has_bvar_in_range_binder(ty, body, lo, hi), - KExprNode.Let(ty, val, body) => has_bvar_in_range_let(ty, val, body, lo, hi), - KExprNode.Proj(_, _, e1) => has_bvar_in_range(e1, lo, hi), - } - } - - -- The two range comparisons are wide, but only BVar rows need them. - -- Keep their order and short circuit, including refusal of out-of-range - -- fields, without charging their byte lookups to every compound node. - fn has_bvar_in_range_bvar(i: G, lo: G, hi: G) -> G { - match u32_less_than(i, lo) { - 1 => 0, - 0 => u32_less_than(i, hi), - } - } - - -- Cold-extracted binder arm (same pattern as `expr_lbr_let`): the - -- two-call arm would otherwise widen every row of the hot walk. - fn has_bvar_in_range_binder(ty: KExpr, body: KExpr, lo: G, hi: G) -> G { - match has_bvar_in_range(ty, lo, hi) { - 1 => 1, - 0 => has_bvar_in_range(body, lo + 1, hi + 1), - } - } - - fn has_bvar_in_range_let(ty: KExpr, val: KExpr, body: KExpr, lo: G, hi: G) -> G { - match has_bvar_in_range(ty, lo, hi) { - 1 => 1, - 0 => - match has_bvar_in_range(val, lo, hi) { - 1 => 1, - 0 => has_bvar_in_range(body, lo + 1, hi + 1), - }, - } - } - - -- Number of leading `types` frames an expr with loose-bvar-range `base` can - -- reach. `BVar(i)` reads `types[i]`, and a kept frame's own stored type can - -- reference further-out frames, so expand `need` to the fixpoint that closes - -- over every kept frame's loose range. Mirror Rust `ctx_addr_for_lbr` - -- (tc.rs). Trimming `types` to this prefix canonicalizes the whnf/infer/ - -- def-eq memo key: a closed expr (base 0) keys to the empty context and - -- shares across all binder depths. Memoized on (types, base). - fn ctx_reachable(types: List‹KExpr›, base: G) -> G { - let len = list_length(types); - ctx_seek_cut(types, lbr_min(base, len)) - } - - -- Valid-cut chain, materialized lazily in the memo table. - -- - -- A cut `m ∈ [1, len]` is *valid* iff every kept frame `i < m` has - -- `(i + 1) + expr_lbr(types[i]) ≤ m` — i.e. the top `m` frames close - -- over their own loose ranges, so the fixpoint answer for `need` is - -- the smallest valid cut ≥ `need`. Valid cuts compose across suffixes: - -- `cuts(L) = {c1} ∪ (c1 + cuts(drop(L, c1)))` for `c1` the smallest, - -- because frames above an established cut never reach below it. So the - -- chain is walked by hopping `ctx_next_cut` links, and since each hop - -- is keyed on (essentially) one list pointer, the chain for a context - -- suffix is computed once and shared by every query and binder depth - -- that reaches it. Rust instead memoizes per (ctx_id, lbr) in - -- `ctx_addr_cache` (tc.rs); the answers agree. - -- - -- Relies on frame well-formedness (a stored type's lbr never exceeds - -- the depth below it, so the bottom frame is closed and the chain - -- always terminates at cut `len`); the kernel maintains this and the - -- Rust mirror asserts the same invariant. - - -- Smallest valid cut ≥ `need`. Requires `1 ≤ need ≤ len`. - fn ctx_seek_cut(types: List‹KExpr›, need: G) -> G { - let c = ctx_next_cut(types); - match u32_less_than(c, need) { - 0 => c, - 1 => c + ctx_seek_cut(list_drop(types, c), need - c), - } - } - - -- Smallest valid cut ≥ 1 of the stack headed at `types` (nonempty). - fn ctx_next_cut(types: List‹KExpr›) -> G { - let ListNode.Cons(ty, rest) = load(types); - 1 + ctx_close_cut(rest, expr_lbr(ty)) - } - - -- Smallest `c ≥ l` that is 0 or a valid cut of `rest`: the depth a - -- frame with loose range `l` forces its cut past. - fn ctx_close_cut(rest: List‹KExpr›, l: G) -> G { - match l { - 0 => 0, - _ => - let c = ctx_next_cut(rest); - match u32_less_than(c, l) { - 0 => c, - 1 => c + ctx_close_cut(list_drop(rest, c), l - c), - }, - } - } - - -- Trim `types` to the suffix reachable from an expr with loose range `base`. - -- Fast paths skip the fixpoint: `base == 0` (closed) → empty context; - -- `base >= len` → nothing to trim. Only partially-open exprs pay the scan. - fn ctx_trim(types: List‹KExpr›, base: G) -> List‹KExpr› { - match base { - 0 => store(ListNode.Nil), - _ => - match u32_less_than(base, list_length(types)) { - 0 => types, - 1 => list_take(types, @ctx_reachable(types, base)), - }, - } - } - - -- ============================================================================ - -- expr_glb / expr_lower — def-eq key rebasing support. - -- - -- `expr_glb(e, c)`: MINIMUM loose-BVar index of `e` relative to cutoff - -- `c` (i.e. min over `{i - c : BVar i loose, i ≥ c}`), or the sentinel - -- `4294967295` when `e` has no loose BVar at or above `c`. The min of a - -- term that only references the OUTERMOST binders of a deep telescope - -- is large — and every context frame below that min is unreferenced. - -- - -- The lowering itself is the pre-existing `expr_lower` below; the - -- rebase caller's `g = min glb` guarantees its no-index-in- - -- `[cutoff, cutoff+shift)` precondition by construction. - -- ============================================================================ - fn expr_glb(e: KExpr, c: G) -> G { - -- Fast path: no loose BVar at or above `c` (lbr ≤ c) → sentinel, - -- skipping the walk of closed subtrees entirely. - match memo_u32_less_than(expr_lbr(e), c + 1) { - 1 => 4294967295, - _ => expr_glb_walk(e, c), - } - } - - fn expr_glb_walk(e: KExpr, c: G) -> G { - -- Zero is the least possible index. Once a child attains it, the - -- remaining children cannot change this minimum. Preserve the exact - -- summary and its memo key without traversing irrelevant proof tails. - match load(e) { - KExprNode.BVar(i) => - match memo_u32_less_than(i, c) { - 1 => 4294967295, - 0 => i - c, - }, - KExprNode.Srt(_) => 4294967295, - KExprNode.Const(_, _) => 4294967295, - KExprNode.Lit(_) => 4294967295, - KExprNode.App(f, a) => match expr_glb(f, c) { - 0 => 0, - n => lbr_min(n, expr_glb(a, c)), - }, - KExprNode.Lam(ty, body) => expr_glb_binder(ty, body, c), - KExprNode.Forall(ty, body) => expr_glb_binder(ty, body, c), - KExprNode.Let(ty, val, body) => expr_glb_let(ty, val, body, c), - KExprNode.Proj(_, _, e1) => expr_glb(e1, c), - } - } - - -- Cold binder arms (same extraction pattern as `expr_lbr_let`). - fn expr_glb_binder(ty: KExpr, body: KExpr, c: G) -> G { - match expr_glb(ty, c) { - 0 => 0, - n => lbr_min(n, expr_glb(body, c + 1)), - } - } - - fn expr_glb_let(ty: KExpr, val: KExpr, body: KExpr, c: G) -> G { - match expr_glb(ty, c) { - 0 => 0, - n => match expr_glb(val, c) { - 0 => 0, - m => lbr_min(lbr_min(n, m), expr_glb(body, c + 1)), - }, - } - } - - -- ============================================================================ - -- expr_lift - -- - -- Shift `BVar(i)` → `BVar(i + shift)` when `i ≥ cutoff`. Recursion bumps - -- `cutoff` by 1 when crossing a binder (Lam/Forall/Let). - -- - -- As the retired Rust kernel's `lift_no_intern`. - -- Fast path: when `expr_lbr(e) <= cutoff`, no loose BVar at or above the - -- cutoff exists, so `e` is unchanged. - -- ============================================================================ - fn expr_lift(e: KExpr, shift: G, cutoff: G) -> KExpr { - match shift { - 0 => e, - _ => - let l = expr_lbr(e); - match memo_u32_less_than(cutoff, l) { - 0 => e, - 1 => expr_lift_walk(e, shift, cutoff), - }, - } - } - - fn expr_lift_walk(e: KExpr, shift: G, cutoff: G) -> KExpr { - match load(e) { - KExprNode.BVar(i) => expr_lift_bvar(i, shift, cutoff), - KExprNode.Srt(l) => store(KExprNode.Srt(l)), - KExprNode.Const(idx, lvls) => store(KExprNode.Const(idx, lvls)), - KExprNode.App(f, a) => - store(KExprNode.App( - expr_lift(f, shift, cutoff), - expr_lift(a, shift, cutoff))), - KExprNode.Lam(ty, body) => - store(KExprNode.Lam( - expr_lift(ty, shift, cutoff), - expr_lift(body, shift, cutoff + 1))), - KExprNode.Forall(ty, body) => - store(KExprNode.Forall( - expr_lift(ty, shift, cutoff), - expr_lift(body, shift, cutoff + 1))), - KExprNode.Let(ty, val, body) => expr_lift_let(ty, val, body, shift, cutoff), - KExprNode.Lit(lit) => store(KExprNode.Lit(lit)), - KExprNode.Proj(tidx, fidx, e1) => - store(KExprNode.Proj(tidx, fidx, expr_lift(e1, shift, cutoff))), - } - } - - -- Cold BVar arm (mirror `expr_inst_many_bvar`): the compare/shift - -- machinery only charges the BVar rows, keeping the hot walk narrow. - -- `store(BVar(i))` content-dedups to the same pointer the inline arm - -- returned. - fn expr_lift_bvar(i: G, shift: G, cutoff: G) -> KExpr { - match u32_less_than(i, cutoff) { - 1 => store(KExprNode.BVar(i)), - 0 => store(KExprNode.BVar(i + shift)), - } - } - - -- Cold-extracted Let arm (same pattern as `expr_lbr_let`): three - -- recursive calls is the widest arm, and Let nodes are rare, so keeping - -- it inline would charge its width on every row of the hot walk. - fn expr_lift_let(ty: KExpr, val: KExpr, body: KExpr, shift: G, cutoff: G) - -> KExpr { - store(KExprNode.Let( - expr_lift(ty, shift, cutoff), - expr_lift(val, shift, cutoff), - expr_lift(body, shift, cutoff + 1))) - } - - -- ============================================================================ - -- expr_lower - -- - -- Shift `BVar(i)` → `BVar(i - shift)` when `i ≥ cutoff`. Inverse of - -- `expr_lift`. SOUNDNESS PRECONDITION: no loose BVar of `e` lies in - -- `[cutoff, cutoff + shift)` — otherwise the subtraction would capture - -- it under an unrelated binder (field arithmetic would even wrap for - -- `i - shift < 0`). The nested-occurrence extraction path guarantees - -- this via the `spec_params_valid` check before lowering. - -- - -- Used to de-lift extracted spec_params to the recursor-param frame - -- (block param j at `BVar(n_rec_params - 1 - j)`), the storage - -- convention every flat consumer assumes. Mirrors the depth-stability - -- Rust gets for free by opening field binders as fvars. - -- ============================================================================ - fn expr_lower(e: KExpr, shift: G, cutoff: G) -> KExpr { - match shift { - 0 => e, - _ => - let l = expr_lbr(e); - match memo_u32_less_than(cutoff, l) { - 0 => e, - 1 => expr_lower_walk(e, shift, cutoff), - }, - } - } - - fn expr_lower_walk(e: KExpr, shift: G, cutoff: G) -> KExpr { - match load(e) { - -- Only expr_lower calls this walk, after checking cutoff < expr_lbr(e). - -- For BVar(i), expr_lbr computes i + 1; that comparison range-checks - -- both operands, so i >= cutoff. The field-wrap case i + 1 = 0 - -- cannot pass the guard. No second comparison is needed here. - KExprNode.BVar(i) => store(KExprNode.BVar(i - shift)), - KExprNode.Srt(l) => store(KExprNode.Srt(l)), - KExprNode.Const(idx, lvls) => store(KExprNode.Const(idx, lvls)), - KExprNode.App(f, a) => - store(KExprNode.App( - expr_lower(f, shift, cutoff), - expr_lower(a, shift, cutoff))), - KExprNode.Lam(ty, body) => - store(KExprNode.Lam( - expr_lower(ty, shift, cutoff), - expr_lower(body, shift, cutoff + 1))), - KExprNode.Forall(ty, body) => - store(KExprNode.Forall( - expr_lower(ty, shift, cutoff), - expr_lower(body, shift, cutoff + 1))), - KExprNode.Let(ty, val, body) => expr_lower_let(ty, val, body, shift, cutoff), - KExprNode.Lit(lit) => store(KExprNode.Lit(lit)), - KExprNode.Proj(tidx, fidx, e1) => - store(KExprNode.Proj(tidx, fidx, expr_lower(e1, shift, cutoff))), - } - } - - -- As in expr_lift_let, the three-child arm gets its own circuit so the - -- common App/Lam/Forall rows pay only for two recursive calls. - fn expr_lower_let(ty: KExpr, val: KExpr, body: KExpr, shift: G, cutoff: G) -> KExpr { - store(KExprNode.Let( - expr_lower(ty, shift, cutoff), - expr_lower(val, shift, cutoff), - expr_lower(body, shift, cutoff + 1))) - } - - -- ============================================================================ - -- expr_inst1 - -- - -- Substitute `BVar(depth)` with `expr_lift(arg, depth, 0)` and decrement - -- `BVar(i)` for `i > depth`. Crossing a binder bumps `depth`. - -- - -- The single-arg form of `instantiate_rev`, - -- with a list of one element. For the lambda-eta case in def_eq we want - -- `body[BVar(0) := arg]` which is `expr_inst1(body, arg, 0)`. - -- ============================================================================ - -- Exact occurrence of the substitution target. Unlike `expr_lbr`, this - -- distinguishes a subtree that mentions only variables ABOVE `depth`: such - -- a subtree still has to be lowered after removing the binder, but its - -- result is independent of `arg`. Memoizing this predicate by `(e, depth)` - -- lets all arguments share that lowering path. - fn expr_has_bvar_at(e: KExpr, depth: G) -> G { - match load(e) { - KExprNode.BVar(i) => match i - depth { 0 => 1, _ => 0, }, - KExprNode.App(f, a) => - match expr_has_bvar_at(f, depth) { - 1 => 1, - _ => expr_has_bvar_at(a, depth), - }, - KExprNode.Lam(ty, body) => expr_has_bvar_at_binder(ty, body, depth), - KExprNode.Forall(ty, body) => expr_has_bvar_at_binder(ty, body, depth), - KExprNode.Let(ty, val, body) => expr_has_bvar_at_let(ty, val, body, depth), - KExprNode.Proj(_, _, inner) => expr_has_bvar_at(inner, depth), - _ => 0, - } - } - - fn expr_has_bvar_at_binder(ty: KExpr, body: KExpr, depth: G) -> G { - match expr_has_bvar_at(ty, depth) { - 1 => 1, - _ => expr_has_bvar_at(body, depth + 1), - } - } - - fn expr_has_bvar_at_let(ty: KExpr, val: KExpr, body: KExpr, depth: G) -> G { - match expr_has_bvar_at(ty, depth) { - 1 => 1, - _ => - match expr_has_bvar_at(val, depth) { - 1 => 1, - _ => expr_has_bvar_at(body, depth + 1), - }, - } - } - - fn expr_inst1(e: KExpr, arg: KExpr, depth: G) -> KExpr { - -- Fast path: when `expr_lbr(e) <= depth`, no BVar at or above depth - -- exists in `e`, so the substitution is a no-op. - let l = expr_lbr(e); - match memo_u32_less_than(depth, l) { - 0 => e, - 1 => - match expr_has_bvar_at(e, depth) { - 1 => expr_inst1_walk(e, arg, depth), - _ => expr_lower(e, 1, depth + 1), - }, - } - } - - fn expr_inst1_walk(e: KExpr, arg: KExpr, depth: G) -> KExpr { - match load(e) { - KExprNode.BVar(i) => expr_inst1_bvar(i, arg, depth), - KExprNode.Srt(l) => store(KExprNode.Srt(l)), - KExprNode.Const(idx, lvls) => store(KExprNode.Const(idx, lvls)), - KExprNode.App(f, a) => - store(KExprNode.App( - expr_inst1(f, arg, depth), - expr_inst1(a, arg, depth))), - KExprNode.Lam(ty, body) => - store(KExprNode.Lam( - expr_inst1(ty, arg, depth), - expr_inst1(body, arg, depth + 1))), - KExprNode.Forall(ty, body) => - store(KExprNode.Forall( - expr_inst1(ty, arg, depth), - expr_inst1(body, arg, depth + 1))), - KExprNode.Let(ty, val, body) => expr_inst1_let(ty, val, body, arg, depth), - KExprNode.Lit(lit) => store(KExprNode.Lit(lit)), - KExprNode.Proj(tidx, fidx, e1) => - store(KExprNode.Proj(tidx, fidx, expr_inst1(e1, arg, depth))), - } - } - - -- Cold BVar arm (mirror `expr_inst_many_bvar`): the compare/subtract/ - -- `expr_lift` machinery only charges the BVar rows, keeping the hot - -- walk narrow. `store(BVar(i))` content-dedups to the same pointer the - -- inline arm returned. - fn expr_inst1_bvar(i: G, arg: KExpr, depth: G) -> KExpr { - match memo_u32_less_than(i, depth) { - 1 => store(KExprNode.BVar(i)), - 0 => - match i - depth { - 0 => expr_lift(arg, depth, 0), - _ => store(KExprNode.BVar(i - 1)), - }, - } - } - - -- Cold-extracted Let arm (same pattern as `expr_lbr_let`). - fn expr_inst1_let(ty: KExpr, val: KExpr, body: KExpr, arg: KExpr, depth: G) - -> KExpr { - store(KExprNode.Let( - expr_inst1(ty, arg, depth), - expr_inst1(val, arg, depth), - expr_inst1(body, arg, depth + 1))) - } - - -- ============================================================================ - -- expr_inst_many — simultaneous substitution of `substs` for the `n` binders - -- at `depth` in ONE walk (as the retired Rust kernel's `simul_subst`). Used - -- for multi-arg beta: `(λλλ. body) x y z` substitutes all three at once - -- instead of three separate `expr_inst1` re-walks of the body. - -- - -- `substs` is innermost-first: `substs[0]` replaces `BVar(depth)`, …, - -- `substs[n-1]` replaces `BVar(depth+n-1)` (each lifted by `depth`); a free - -- `BVar(i ≥ depth+n)` shifts down by `n`. Same fast-path as `expr_inst1`. - -- ============================================================================ - fn expr_inst_many(e: KExpr, substs: List‹KExpr›, depth: G) -> KExpr { - let n = list_length(substs); - match n { - 0 => e, - _ => - let l = expr_lbr(e); - match memo_u32_less_than(depth, l) { - 0 => e, - 1 => - match has_bvar_in_range(e, depth, depth + n) { - 1 => expr_inst_many_walk(e, substs, depth), - _ => expr_lower(e, n, depth + n), - }, - }, - } - } - - -- Cold BVar arm of `expr_inst_many_walk`, split into its own circuit so the - -- hot App/Lam/… walk stays narrow (the `list_length` / `list_lookup` / - -- `expr_lift` machinery only charges the BVar rows). Mirror the hot/cold - -- split pattern used for `address_eq` / `whnf_with_spine`. - -- - -- The walk invariant gives `lbr(BVar i) = i + 1 > depth`, i.e. - -- `i ≥ depth`, so the window test reduces to one comparison on the - -- offset. A sub-`depth` index (invariant violation) wraps in the field - -- and fails the u32 range decomposition — no silent path. - fn expr_inst_many_bvar(i: G, substs: List‹KExpr›, depth: G) -> KExpr { - let n = list_length(substs); - let ofs = i - depth; - match memo_u32_less_than(ofs, n) { - 1 => expr_lift(list_lookup(substs, ofs), depth, 0), - 0 => store(KExprNode.BVar(i - n)), - } - } - - fn expr_inst_many_walk(e: KExpr, substs: List‹KExpr›, depth: G) -> KExpr { - match load(e) { - KExprNode.BVar(i) => expr_inst_many_bvar(i, substs, depth), - KExprNode.Srt(l) => store(KExprNode.Srt(l)), - KExprNode.Const(idx, lvls) => store(KExprNode.Const(idx, lvls)), - KExprNode.App(f, a) => - store(KExprNode.App( - expr_inst_many(f, substs, depth), - expr_inst_many(a, substs, depth))), - KExprNode.Lam(ty, body) => - store(KExprNode.Lam( - expr_inst_many(ty, substs, depth), - expr_inst_many(body, substs, depth + 1))), - KExprNode.Forall(ty, body) => - store(KExprNode.Forall( - expr_inst_many(ty, substs, depth), - expr_inst_many(body, substs, depth + 1))), - KExprNode.Let(ty, val, body) => - expr_inst_many_let(ty, val, body, substs, depth), - KExprNode.Lit(lit) => store(KExprNode.Lit(lit)), - KExprNode.Proj(tidx, fidx, e1) => - store(KExprNode.Proj(tidx, fidx, expr_inst_many(e1, substs, depth))), - } - } - - -- Cold-extracted Let arm (same pattern as `expr_lbr_let`). - fn expr_inst_many_let(ty: KExpr, val: KExpr, body: KExpr, - substs: List‹KExpr›, depth: G) -> KExpr { - store(KExprNode.Let( - expr_inst_many(ty, substs, depth), - expr_inst_many(val, substs, depth), - expr_inst_many(body, substs, depth + 1))) - } -⟧ - -end IxVM - -end diff --git a/Ix/IxVM/Kernel/Whnf.lean b/Ix/IxVM/Kernel/Whnf.lean deleted file mode 100644 index 83140d649..000000000 --- a/Ix/IxVM/Kernel/Whnf.lean +++ /dev/null @@ -1,1241 +0,0 @@ -module -public import Ix.Aiur.Meta -public import Ix.IxVM.KernelTypes -public import Ix.IxVM.Kernel.Subst -public import Ix.IxVM.Kernel.Levels -public import Ix.IxVM.Kernel.NatPrim -public import Ix.IxVM.Ingress - -public section - -namespace IxVM - -/-! ## Weak Head Normal Form - -Two reducers live here, differing only in whether delta fires: - -* `whnf` — the full reducer. Beta, zeta, iota (recursors, including the - K rule and structure eta), quotient lifting/induction, projections, - the Nat/BitVec/String primitive fast-paths, and delta on `Defn`. - `Thm` heads stay stuck: a theorem only unfolds through def-eq's - lazy-delta step, never by plain reduction. -* `whnf_nd` — the no-delta reducer (`_nd` suffix throughout). Everything - above except delta, so `Defn` and `Thm` heads both stay stuck. Def-eq - reduces with this first, since it is far cheaper and often enough to - decide a pair, and only then pays for unfolding. - -`get_ci(addr)` fault-loads and memoizes, so reduction needs no ambient -constant table — an addr is self-sufficient. The `types` argument is the -local binder context, threaded for the inference calls that gate the K -rule and structure eta. --/ - -def whnf := ⟦ - fn apply_spine(head: KExpr, spine: List‹KExpr›) -> KExpr { - match load(spine) { - ListNode.Nil => head, - ListNode.Cons(a, rest) => - apply_spine(store(KExprNode.App(head, a)), rest), - } - } - - -- Peel `Lam` telescope against spine, one arg per Lam. - fn peel_beta(lam: KExpr, spine: List‹KExpr›, acc: List‹KExpr›) - -> (KExpr, List‹KExpr›, List‹KExpr›) { - match load(lam) { - KExprNode.Lam(_, body) => - match load(spine) { - ListNode.Cons(a, rest) => - peel_beta(body, rest, store(ListNode.Cons(a, acc))), - ListNode.Nil => (lam, acc, spine), - }, - _ => (lam, acc, spine), - } - } - - -- Multi-arg beta: peel the whole - -- telescope and substitute all consumed args in ONE `expr_inst_many` walk, - -- instead of one `expr_inst1` re-walk of the body per arg. Single-arg betas - -- stay on the cheap `expr_inst1` path (no list overhead). - fn whnf_apply_beta(rc: RoleCtx, spine: List‹KExpr›, lam: KExpr, types: List‹KExpr›) -> KExpr { - match peel_beta(lam, spine, store(ListNode.Nil)) { - (deep, consumed, rest) => - match list_length(consumed) { - 0 => apply_spine(lam, spine), - 1 => - let body2 = expr_inst1(deep, list_lookup(consumed, 0), 0); - whnf_with_spine(rc, body2, rest, types), - _ => - let body2 = expr_inst_many(deep, consumed, 0); - whnf_with_spine(rc, body2, rest, types), - }, - } - } - - fn whnf_with_spine(rc: RoleCtx, head: KExpr, spine: List‹KExpr›, types: List‹KExpr›) -> KExpr { - match load(head) { - KExprNode.App(f, a) => - match collect_spine(head) { - (inner_head, inner_spine) => - whnf_with_spine(rc, inner_head, list_concat(inner_spine, spine), types), - }, - KExprNode.Lam(ty, body) => - whnf_apply_beta(rc, spine, head, types), - KExprNode.Const(addr, lvls) => - whnf_const_head(rc, addr, lvls, head, spine, types), - KExprNode.Let(_, val, body) => - let next = expr_inst1(body, val, 0); - whnf_with_spine(rc, next, spine, types), - KExprNode.Proj(struct_addr, fidx, inner) => - whnf_proj_head(rc, struct_addr, fidx, inner, spine, types), - _ => apply_spine(head, spine), - } - } - - -- Proj-head WHNF: whnf inner, if it's a Ctor application, pull the - -- corresponding field. Otherwise stays stuck as `Proj(struct, fidx, inner_whnf)` - -- (in particular over a recursor whose major is stuck, as in Lean). - fn whnf_proj_head(rc: RoleCtx, struct_addr: Addr, fidx: G, inner: KExpr, - spine: List‹KExpr›, types: List‹KExpr›) -> KExpr { - let inner_whnf = whnf(rc, inner, types); - -- Str-literal re-expansion (mirror whnf_proj_head): a Proj over - -- a Lit(Str) scrutinee needs the ctor form to pull fields. - let inner_exp = str_lit_to_ctor_app_or_self(rc, inner_whnf, types); - match collect_spine(inner_exp) { - (inner_head, inner_args) => - match load(inner_head) { - KExprNode.Const(_, _) => - match load(whnf_get_ctor_or_none(inner_head)) { - KConstantInfo.Ctor(_, _, _, _, _, nparams, _, _) => - let field = list_lookup(inner_args, nparams + fidx); - whnf_with_spine(rc, field, spine, types), - _ => - let stuck = store(KExprNode.Proj(struct_addr, fidx, inner_whnf)); - apply_spine(stuck, spine), - }, - _ => - let stuck = store(KExprNode.Proj(struct_addr, fidx, inner_whnf)); - apply_spine(stuck, spine), - }, - } - } - - -- The three quotient primitives reduction is allowed to fire on. - -- Same literals as `Kernel/Check.lean`'s; `Tests/Ix/Kernel/PrimAddrs.lean` - -- collects every `*_addr` function in the toplevel and asserts each - -- resolves to the constant its name claims, so a drifted copy fails - -- there rather than silently mis-reducing. - - -- Returns the Ctor KCI if `head` is a Const of a Ctor, else a stub axiom - -- KCI (harmless — the caller falls through on the non-Ctor match). - fn whnf_get_ctor_or_none(head: KExpr) -> &KConstantInfo { - match load(head) { - KExprNode.Const(addr, _) => get_ci(addr), - _ => - store(KConstantInfo.Axiom(0, store(KExprNode.Srt(store(KLevelNode.Zero))), 0)), - } - } - - -- Const head: delta-unfold Defn or iota-reduce Rec applied to Ctor - -- major. Ctor/Ind/Axiom/Quot etc. stay stuck. Before Defn delta, try - -- projection-definition shortcut: `def field := fun x => Prj S i x` - -- rewrites `field arg` to `Prj S i arg` without expanding the body. - -- WHNF each spine arg (needed before calling nat dispatch — args - -- must be normalized to Lit/Const-headed forms for try_extract_nat). - fn whnf_spine(rc: RoleCtx, spine: List‹KExpr›, types: List‹KExpr›) -> List‹KExpr› { - match load(spine) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(a, rest) => - let aw = whnf(rc, a, types); - store(ListNode.Cons(aw, whnf_spine(rc, rest, types))), - } - } - - -- Pre-whnf wrapper for nat dispatch: whnfs unary/binop args first - -- (2 first args or 1 first arg for succ/pred), then calls - -- try_nat_dispatch. - fn try_nat_dispatch_prewhnf(rc: RoleCtx, head_addr: Addr, op: G, spine: List‹KExpr›, - types: List‹KExpr›) -> (G, KExpr) { - let spine_w = whnf_spine(rc, spine, types); - @try_nat_dispatch(rc, head_addr, op, spine_w, types) - } - - -- Address-keyed primitive dispatch. Runs BEFORE KConstantInfo - -- discrimination so it fires regardless of whether the primitive - -- lives as Defn/Axiom/etc. in the loaded env (matters for - -- String.utf8ByteSize / String.append which may compile as Defn - -- with an external body or as Axiom). - -- For BitVec.toNat: whnf spine[1] (the val, expected to be - -- BitVec.ofNat W N form) then further whnf its inner args (W and N) - -- so try_extract_nat sees Lit(Nat) even when the source used - -- OfNat.ofNat wrappers. - fn bitvec_prep_spine(rc: RoleCtx, spine: List‹KExpr›, types: List‹KExpr›) - -> List‹KExpr› { - let spine_w = whnf_spine(rc, spine, types); - match load(spine_w) { - ListNode.Nil => spine_w, - ListNode.Cons(width_e, rest) => - match load(rest) { - ListNode.Nil => spine_w, - ListNode.Cons(val_e, tail) => - match collect_spine(val_e) { - (vh, va) => - let va_w = whnf_spine(rc, va, types); - let val_e2 = apply_spine(vh, va_w); - let width_w = whnf(rc, width_e, types); - store(ListNode.Cons(width_w, - store(ListNode.Cons(val_e2, tail)))), - }, - }, - } - } - - -- Primitive-family classification (mirror prim_family, - -- Primitive.lean:1419): map a Const-head address to the ONE reducer - -- family that could fire on it — 0 = none, 1 = nat, 2 = str, - -- 3 = bitvec, 5 = decidable, 6 = Int. A role's family is rendered from - -- the specification's roles (`role_prim_family`), and the role is read - -- through `role_of` only when it has one, so that a claim whose terms - -- merely mention a role's constant validates no group for it. Keyed on - -- the role context and the ADDRESS ALONE: one memo row per distinct - -- constant address in the run. - -- Replaces running the is_* gauntlet from try_prim_dispatch, whose key - -- includes the spine and context — 5 wide rows per Const-head whnf, - -- almost all guaranteed misses. - fn prim_family(rc: RoleCtx, a: Addr) -> (G, G) { - let r1 = role_index_of(rc, a); - let (f, op) = match r1 { 0 => (0, 0), _ => role_prim_family(r1 - 1), }; - match f { - 0 => (0, 0), - _ => match role_of(rc, a) { 0 => (0, 0), _ => (f, op), }, - } - } - - fn try_prim_dispatch(rc: RoleCtx, addr: Addr, lvls: List‹KLevel›, - spine: List‹KExpr›, - types: List‹KExpr›) -> (G, KExpr) { - let (fam, op) = prim_family(rc, addr); - match fam { - 1 => try_nat_dispatch_prewhnf(rc, addr, op, spine, types), - 2 => - let spine_w = whnf_spine(rc, spine, types); - try_str_dispatch(rc, addr, op, spine_w, types), - 3 => try_bitvec_dispatch(rc, op, spine, types), - 5 => try_dec_dispatch(rc, addr, op, lvls, spine, types), - 6 => try_int_prim_dispatch(rc, op, spine, types), - _ => (0, store(KExprNode.BVar(0))), - } - } - - -- Quot iota: Quot.lift α r β f sound (Quot.mk α' r' a) = f a - -- and Quot.ind α r motive m (Quot.mk α' r' a) = m a. Anything else - -- stays stuck. - -- - -- Dispatch is on the binding's quotient roles (`role_is`), and the stored - -- `QuotKind` is not consulted: recognizing a role admits the quotient - -- group, whose validation fixes each member's kind and type, while the - -- kind field of an arbitrary constant is unvalidated when reduction runs - -- (`get_ci` typechecks nothing). Lean's kernel and the Rust kernel also - -- decide by identity (lean4lean `quotReduceRec`, `Quot.lean:85-100`). - fn try_quot_iota(rc: RoleCtx, addr: Addr, spine: List‹KExpr›, - types: List‹KExpr›) -> (G, KExpr) { - match role_is(rc, addr, @role_quot_lift()) { - 1 => try_quot_lift(rc, spine, types), - _ => - match role_is(rc, addr, @role_quot_ind()) { - 1 => try_quot_ind(rc, spine, types), - _ => (0, store(KExprNode.BVar(0))), - }, - } - } - - fn try_quot_lift(rc: RoleCtx, spine: List‹KExpr›, types: List‹KExpr›) -> (G, KExpr) { - let n = list_length(spine); - match u32_less_than(n, 6) { - 1 => (0, store(KExprNode.BVar(0))), - _ => - let f = list_lookup(spine, 3); - let q = list_lookup(spine, 5); - match quot_extract_arg(rc, q, types) { - (1, a) => - let post = list_drop(spine, 6); - (1, apply_spine(store(KExprNode.App(f, a)), post)), - _ => (0, store(KExprNode.BVar(0))), - }, - } - } - - fn try_quot_ind(rc: RoleCtx, spine: List‹KExpr›, types: List‹KExpr›) -> (G, KExpr) { - let n = list_length(spine); - match u32_less_than(n, 5) { - 1 => (0, store(KExprNode.BVar(0))), - _ => - let m = list_lookup(spine, 3); - let q = list_lookup(spine, 4); - match quot_extract_arg(rc, q, types) { - (1, a) => - let post = list_drop(spine, 5); - (1, apply_spine(store(KExprNode.App(m, a)), post)), - _ => (0, store(KExprNode.BVar(0))), - }, - } - } - - -- WHNF q; if q reduces to `App-spine(Const(Quot.mk), [α, r, a])`, - -- return (1, a). Else (0, _). - -- - -- The head is recognised as the binding's `Quot.mk` role and the arity - -- must be exactly 3, which is all the references look at (lean4lean - -- `if !mk.isAppOfArity ``Quot.mk 3`, `Quot.lean:88`). No stored kind is - -- read: recognizing the role admits the validated quotient group. - fn quot_extract_arg(rc: RoleCtx, q: KExpr, types: List‹KExpr›) -> (G, KExpr) { - let q_w = whnf(rc, q, types); - match collect_spine(q_w) { - (head, args) => - match load(head) { - KExprNode.Const(caddr, _) => - match role_is(rc, caddr, @role_quot_mk()) { - 1 => - match list_length(args) - 3 { - 0 => (1, list_lookup(args, 2)), - _ => (0, store(KExprNode.BVar(0))), - }, - _ => (0, store(KExprNode.BVar(0))), - }, - _ => (0, store(KExprNode.BVar(0))), - }, - } - } - - -- Const-head WHNF dispatch, split out of `whnf_with_spine` (see its Const arm). - -- `head` is the original `Const(idx, lvls)` KExpr, passed for the stuck - -- `apply_spine(head, spine)` fallbacks. - fn whnf_const_head(rc: RoleCtx, addr: Addr, lvls: List‹KLevel›, head: KExpr, - spine: List‹KExpr›, types: List‹KExpr›) -> KExpr { - let prim = try_prim_dispatch(rc, addr, lvls, spine, types); - match prim { - (1, reduced) => whnf(rc, reduced, types), - -- verdict 2: the reducer normalized the term to an already-stuck - -- compact form (symbolic Nat offset); return it WITHOUT re-whnf - -- and WITHOUT falling to the Defn arm — delta-unfolding it would - -- expand a succ^n tower / the division algorithm. Mirror - -- whnf_const_head:230. - (2, stuck) => stuck, - _ => - let ci = load(get_ci(addr)); - match ci { - KConstantInfo.Defn(_, _, value, _, _) => - let pd = try_reduce_projection_definition(value, spine); - match pd { - (1, reduced) => whnf(rc, reduced, types), - _ => - let body = expr_inst_levels(value, lvls); - whnf_with_spine(rc, body, spine, types), - }, - -- Thm stays stuck in the general reducer. The reference unfolds - -- `Definition | Theorem` alike here (delta_unfold_one, whnf.rs), - -- but doing that globally cost `Std.Time...ofDays._proof_1` 14x - -- (5.1s -> 69.8s) for no verdict change: every proof term the - -- check touches then gets driven through its body. Theorem - -- unfolding is only NEEDED to drive an iota major to a - -- constructor, so it lives at that one site (`whnf_iota_major`), - -- and proof_irrel / congruence still get first shot at Thm-headed - -- pairs everywhere else. Under-reducing relative to the reference - -- is the safe direction: it can only leave a term stuck, never - -- manufacture a reduction. - KConstantInfo.Thm(_, _, _) => apply_spine(head, spine), - KConstantInfo.Quot(_, _, _) => - let quot = try_quot_iota(rc, addr, spine, types); - match quot { - (1, reduced) => whnf(rc, reduced, types), - _ => apply_spine(head, spine), - }, - KConstantInfo.Rec(nlvls, rec_ty, nparams, nindices, nmotives, nminors, - rules, k_flag, _unsafe, _block, _ridx) => - -- K-like recursors: try to synthesize the nullary K-ctor from the - -- RAW major BEFORE the major is whnf'd, mirroring the reference - -- (whnf.rs:1349-1356, `let major = if recr.k { synth_ctor_when_k - -- (major)... }` sits above the major-whnf). The gate costs one - -- inference plus an index def-eq; whnf'ing the major first can - -- cost arbitrarily more, because a K major is typically a PROOF - -- and whnf of a proof evaluates whatever decision procedure - -- produced it (`Std.Time...ofDays._proof_1` is an `Eq.rec` over a - -- `decide +kernel` proof — reducing that major runs the whole - -- Rat/Nat decision procedure over 14-digit literals). - -- - -- Ordering only; the verdict is unchanged. `try_k_synth_iota` - -- gates on `k_infer` of the raw major read from `spine`, so it - -- computes the same answer before and after a major whnf — which - -- is why the k_flag=1 stuck-fallback below is now redundant and - -- simply keeps the stuck form. - let k_skip = ((nparams + nmotives) + nminors) + nindices; - let k_pre = match k_flag { - 1 => - -- The recursor's OWN inductive, read from its declared major - -- premise. The K gate must check the major's inferred - -- inductive against this — comparing the major against its - -- own inductive's ctor is vacuous, and would strip an `I.rec` - -- over a major of some other inductive `J`. (An inductive-addr - -- comparison, not a `block`-field one, so the solo-wrapper - -- mismatch noted in k_synth_gate does not apply.) - match se_parent_addr(rec_ty, k_skip) { - (_, rec_parent) => - try_k_synth_iota(rc, lvls, spine, nparams, nmotives, - nminors, nindices, rules, - rec_parent, types), - }, - _ => (0, head), - }; - match k_pre { - (1, k_reduct) => k_reduct, - _ => - let iota = try_iota(rc, lvls, spine, nparams, nmotives, nminors, - nindices, rules, types, head, - rec_to_parent_addr(rec_ty, nparams, nmotives, - nminors, nindices)); - match iota { - (1, reduced) => whnf(rc, reduced, types), - (2, stuck) => - match k_flag { - -- Already attempted pre-whnf above with the same verdict. - 1 => stuck, - _ => - -- Struct-eta iota (mirror try_struct_eta_iota / - -- Rust whnf.rs:1244 / Lean toCtorWhenStructure): major - -- stuck but inductive is a structure (1 ctor, 0 - -- indices, non-recursive, non-Prop major) → synthesize - -- the ctor app from field projections of the major and - -- fire the single rule anyway. - match try_struct_eta_iota(rc, rec_ty, lvls, spine, nparams, - nmotives, nminors, nindices, rules, types) { - (1, r) => whnf(rc, r, types), - _ => stuck, - }, - }, - _ => apply_spine(head, spine), - }, - }, - _ => apply_spine(head, spine), - }, - } - } - - -- Recognize `λ x_1 ... x_n → Prj S i (BVar k)` and rewrite an - -- application of the constant to a direct Prj. Pure perf — standard - -- delta+beta produces the same result — but keeps binder-type WHNF - -- inside a proj scrutinee stuck at Const-inductive form rather than - -- descending into the body and getting stuck at a partially-applied - -- Lam. - fn try_reduce_projection_definition(value: KExpr, - spine: List‹KExpr›) -> (G, KExpr) { - match projection_definition_info(value, 0) { - (1, arity, struct_addr, field, struct_arg_idx) => - match u32_less_than(list_length(spine), arity) { - 1 => (0, store(KExprNode.BVar(0))), - _ => - let target_arg = list_lookup(spine, struct_arg_idx); - let proj_expr = store(KExprNode.Proj(struct_addr, field, target_arg)); - let post = list_drop(spine, arity); - (1, apply_spine(proj_expr, post)), - }, - _ => (0, store(KExprNode.BVar(0))), - } - } - - -- Returns (found, arity, struct_addr, field, struct_arg_idx). Walks - -- Lam bindings counting arity; expects body to be `Prj S i (BVar k)` - -- with `k < arity`. struct_arg_idx = (arity - 1) - k. - fn projection_definition_info(val: KExpr, arity: G) - -> (G, G, Addr, G, G) { - match load(val) { - KExprNode.Lam(_, body) => - projection_definition_info(body, arity + 1), - KExprNode.Proj(struct_addr, field, projected) => - match load(projected) { - KExprNode.BVar(i) => - match u32_less_than(i, arity) { - 1 => (1, arity, struct_addr, field, (arity - 1) - i), - _ => (0, 0, store([0u8; 32]), 0, 0), - }, - _ => (0, 0, store([0u8; 32]), 0, 0), - }, - _ => (0, 0, store([0u8; 32]), 0, 0), - } - } - - -- Canonical Nat.zero / Nat.succ addrs. - - -- Convert `Lit(Nat n)` to `Nat.zero` or `App(Nat.succ, Lit(n-1))`. - -- Non-Lit inputs pass through unchanged. Enables iota to fire on - -- Lit majors. - fn nat_lit_to_ctor_or_self(rc: RoleCtx, e: KExpr) -> KExpr { - match load(e) { - KExprNode.Lit(lit) => - match lit { - KLiteral.Nat(klimbs) => - match klimbs_is_zero(klimbs) { - 1 => store(KExprNode.Const(role_addr(rc, @role_nat_zero()), - store(ListNode.Nil))), - _ => - let pred_limbs = klimbs_normalize(klimbs_dec(klimbs)); - let pred = store(KExprNode.Lit(KLiteral.Nat(pred_limbs))); - let succ_const = store(KExprNode.Const(role_addr(rc, @role_nat_succ()), - store(ListNode.Nil))); - store(KExprNode.App(succ_const, pred)), - }, - _ => e, - }, - _ => e, - } - } - - -- K-recursor synth: fire rule[0] assuming the nullary K-ctor, but only - -- when the toCtorWhenK gate holds: infer the major's type, require its - -- head to be this recursor's inductive, synthesize the ctor app from - -- the type's params, and require def_eq(major_ty, ctor_ty). Without - -- the gate, an Eq.rec transport whose endpoints differ symbolically - -- gets stripped, producing mistyped reducts. - -- Returns (1, reduct) when the K gate fires, (0, _) on a miss. - -- - -- The gate reads the RAW major out of `spine` and infers ITS type, so - -- the outcome does not depend on whether the major has been whnf'd — - -- which is what lets the caller run this BEFORE the major whnf (see - -- the ordering note at the Rec arm of whnf_const_head). - fn try_k_synth_iota(rc: RoleCtx, lvls: List‹KLevel›, spine: List‹KExpr›, - nparams: G, nmotives: G, nminors: G, nindices: G, - rules: List‹KRecRule›, - rec_parent: Addr, types: List‹KExpr›) - -> (G, KExpr) { - match load(rules) { - ListNode.Cons(r, _) => - match r { - KRecRule.Mk(cidx, _rfields, rrhs) => - let major_idx = nparams + nmotives + nminors + nindices; - -- Same spine-length guard `try_iota` applies before reading its - -- major. A PARTIALLY APPLIED recursor has no major argument yet, - -- and `list_lookup` past the end of the spine hits `Nil` against - -- an irrefutable `Cons` binding and aborts. This used to be - -- unreachable — the only caller was `try_iota`'s stuck branch, - -- which had already proved the spine long enough — but the K gate - -- now runs BEFORE `try_iota`, so it must re-establish the - -- precondition itself. A recursor short of its major cannot iota - -- at all, so declining here is also the right verdict. - match memo_u32_less_than(major_idx, list_length(spine)) { - 0 => (0, store(KExprNode.BVar(0))), - _ => - let raw_major = list_lookup(spine, major_idx); - match k_synth_gate(rc, raw_major, cidx, nparams, rec_parent, types) { - 0 => (0, store(KExprNode.BVar(0))), - _ => - let rhs_lvled = expr_inst_levels(rrhs, lvls); - let pmm_end = nparams + nmotives + nminors; - let pmm = list_take(spine, pmm_end); - let post_major = list_drop(spine, major_idx + 1); - let r1 = apply_spine(rhs_lvled, pmm); - let r3 = apply_spine(r1, post_major); - (1, whnf(rc, r3, types)), - }, - }, - }, - _ => (0, store(KExprNode.BVar(0))), - } - } - - -- The toCtorWhenK gate: 1 iff whnf(rc, infer(major)) is `I params indices` - -- for this recursor's own inductive AND the synthesized ctor app - -- `I.ctor params` has type def-eq to the major's. - fn k_synth_gate(rc: RoleCtx, raw_major: KExpr, cidx: G, nparams: G, - rec_parent: Addr, types: List‹KExpr›) -> G { - let major_ty = k_infer(rc, raw_major, types); - let major_ty_w = whnf(rc, major_ty, types); - match collect_spine(major_ty_w) { - (ty_head, ty_args) => - match load(ty_head) { - KExprNode.Const(ind_addr, ctor_us) => - -- Identity: the major's inductive must be the recursor's own. - -- Everything below is derived from the major, so without this - -- the def_eq compares the major against its OWN inductive's - -- ctor and always holds — vacuous. `rec_parent` is the - -- inductive named in the recursor's declared major premise, so - -- this is an inductive-addr comparison, not the `block`-field - -- comparison the solo-wrapper case breaks. - match address_eq(ind_addr, rec_parent) { - 0 => 0, - _ => - let ind_ci = load(get_ci(ind_addr)); - match ind_ci { - KConstantInfo.Induct(_, _, _, _, _, _, ind_block, ind_idx) => - let cprj = projection_addr_ctor(ind_idx, cidx, ind_block); - let ctor_head = store(KExprNode.Const(cprj, ctor_us)); - let params = list_take(ty_args, nparams); - let ctor_app = apply_spine(ctor_head, params); - let ctor_ty = k_infer(rc, ctor_app, types); - k_is_def_eq(rc, major_ty_w, ctor_ty, types), - _ => 0, - }, - }, - _ => 0, - }, - } - } - - -- Attempt iota reduction: given a recursor head + spine, whnf the - -- major argument. If it's a Ctor application matching one of the - -- rules, apply the rule's rhs (Lam-wrapped) to - -- params ++ motives ++ minors ++ ctor_fields ++ post_major via - -- apply_spine so that outer whnf beta-reduces. - -- Rewrite spine with major (at major_idx) replaced by given whnf'd major. - fn replace_spine_major(spine: List‹KExpr›, major_idx: G, major_w: KExpr) - -> List‹KExpr› { - let pre = list_take(spine, major_idx); - let post = list_drop(spine, major_idx + 1); - let with_major = list_concat(pre, - store(ListNode.Cons(major_w, store(ListNode.Nil)))); - list_concat(with_major, post) - } - - -- whnf an iota MAJOR, unfolding theorem heads. `whnf` leaves a Thm - -- head stuck (see the Thm arm of whnf_const_head), but a recursor can - -- only fire once its major reaches constructor form, and a major can - -- legitimately BE a theorem: `abstractNestedProofs` lifts inline - -- proofs out into auto-theorems, so `And.rec motive minor MAJOR` gets - -- a `..._proof_1` there (`Rat.instEncodable`; the `thmMajorUse` - -- fixture). Without this the recursor stayed stuck and the constant - -- was rejected as "inferred type is not def-eq to the expected type". - -- - -- Recursive: a theorem body can be another theorem application, and - -- the reference's delta loop steps those the same way. Only the major - -- position pays this — the reference unfolds theorems in every full - -- whnf, which measured 14x worse on ofDays for no verdict change. - fn whnf_iota_major(rc: RoleCtx, e: KExpr, types: List‹KExpr›) -> KExpr { - let w = whnf(rc, e, types); - match collect_spine(w) { - (h, sp) => - match load(h) { - KExprNode.Const(addr, lvls) => - match load(get_ci(addr)) { - KConstantInfo.Thm(_, _, value) => - let body = expr_inst_levels(value, lvls); - whnf_iota_major(rc, whnf_with_spine(rc, body, sp, types), types), - _ => w, - }, - _ => w, - }, - } - } - - -- Status codes returned by try_iota: - -- 1 = fired, use returned expr as reduced form (re-whnf) - -- 2 = stuck with major whnf'd, returned expr is the canonical - -- stuck form — caller MUST NOT re-whnf (would infinite loop) - -- 0 = stuck without major work (major_idx >= spine_len) - fn try_iota(rc: RoleCtx, lvls: List‹KLevel›, spine: List‹KExpr›, - nparams: G, nmotives: G, nminors: G, nindices: G, - rules: List‹KRecRule›, types: List‹KExpr›, - head: KExpr, rec_parent: Addr) -> (G, KExpr) { - let major_idx = nparams + nmotives + nminors + nindices; - let spine_len = list_length(spine); - match u32_less_than(major_idx, spine_len) { - 0 => (0, store(KExprNode.BVar(0))), - _ => - -- linear-rec fast path: `Nat.rec base (fun _ ih => succ ih) (Lit n)` - -- collapses in O(1) to base+n / stuck offset, avoiding n iota expansions. - let lin = try_nat_linear_rec(rc, spine, nparams, nmotives, nminors, major_idx); - match lin { - (1, r) => (1, r), - _ => - let raw_major = list_lookup(spine, major_idx); - -- cleanup: expose one Nat.succ layer if major is - -- `Nat.add base (Lit n)` with n>0, so iota can fire without - -- unfolding into n unary succs. - let major_clean1 = cleanup_nat_offset_major(rc, raw_major); - let major_w = whnf_iota_major(rc, major_clean1, types); - let major_clean2 = cleanup_nat_offset_major(rc, major_w); - let major = nat_lit_to_ctor_or_self(rc, major_clean2); - match collect_spine_of_ctor(major) { - (1, ctor_cidx, ctor_parent, ctor_args) => - -- The constructor must belong to the inductive THIS recursor - -- eliminates. Rules are otherwise selected by index alone, so - -- any inductive's constructor with a matching index fires a - -- rule and the redex reduces to a branch of an unrelated - -- eliminator. Lean matches on the constructor's name, which - -- pins the inductive; this is the addr-first equivalent. - -- - -- `rec_to_parent_addr` reads the parent off the recursor's - -- own type (the major premise's head), and Aiur memoizes it - -- per argument tuple, so the walk is paid once per recursor - -- rather than once per reduction. - assert_eq!(address_eq(ctor_parent, rec_parent), 1, - "iota: major's constructor belongs to a different inductive"); - let rule = find_rule(rules, ctor_cidx); - match rule { - (0, _, _) => - -- No rule for this ctor — rebuild stuck with whnf'd major. - let new_spine = replace_spine_major(spine, major_idx, major_w); - (2, apply_spine(head, new_spine)), - (1, rfields, rrhs) => - let rhs_lvled = expr_inst_levels(rrhs, lvls); - let pmm_end = nparams + nmotives + nminors; - let pmm = list_take(spine, pmm_end); - let ctor_fields_len = list_length(ctor_args); - let field_start = ctor_fields_len - rfields; - let field_args = list_drop(ctor_args, field_start); - let post_major = list_drop(spine, major_idx + 1); - let r1 = apply_spine(rhs_lvled, pmm); - let r2 = apply_spine(r1, field_args); - let r3 = apply_spine(r2, post_major); - (1, r3), - }, - _ => - -- Major not a Ctor — stuck, but rebuild spine with whnf'd major - -- so downstream def_eq compares against canonical stuck form. - let new_spine = replace_spine_major(spine, major_idx, major_w); - (2, apply_spine(head, new_spine)), - }, - }, - } - } - - -- Collect a Ctor application: returns (1, cidx, args) if head is - -- Const(ctor_addr) with a Ctor KCI, else (0, 0, []). - -- Also returns the constructor's PARENT inductive, as the address of - -- its projection wrapper, so the caller can check that the constructor - -- actually belongs to the recursor being reduced. Without that, rules - -- are selected by index alone and any inductive's constructor with a - -- matching index fires a rule. Lean matches on the constructor's name, - -- which pins the inductive. - fn collect_spine_of_ctor(e: KExpr) -> (G, G, Addr, List‹KExpr›) { - match collect_spine(e) { - (head, args) => - match load(head) { - KExprNode.Const(addr, _) => - let ci = load(get_ci(addr)); - match ci { - KConstantInfo.Ctor(_, _, block_addr, ind_idx, cidx, _, _, _) => - (1, cidx, compute_iprj_addr(block_addr, ind_idx), args), - _ => (0, 0, store([0u8; 32]), store(ListNode.Nil)), - }, - _ => (0, 0, store([0u8; 32]), store(ListNode.Nil)), - }, - } - } - - -- Find rule matching cidx: returns (1, nfields, rhs) or (0, 0, ...). - fn find_rule(rules: List‹KRecRule›, cidx: G) -> (G, G, KExpr) { - match load(rules) { - ListNode.Nil => (0, 0, store(KExprNode.BVar(0))), - ListNode.Cons(r, rest) => - match r { - KRecRule.Mk(rcidx, nfields, rhs) => - match rcidx - cidx { - 0 => (1, nfields, rhs), - _ => find_rule(rest, cidx), - }, - }, - } - } - - -- Helpers (thin wrappers around Core list ops with concrete type params - -- to avoid monomorphization clash under toplevel). - - -- ========================================================================== - -- Struct-eta iota (mirror try_struct_eta_iota, Kernel/Whnf.lean:708; - -- Rust whnf.rs:1244-1301; Lean toCtorWhenStructure). When a - -- single-rule recursor's major premise is stuck but the parent - -- inductive is struct-like (1 ctor, 0 indices, non-recursive) and the - -- major isn't Prop-typed, the major is definitionally `Ctor major.0 - -- major.1 ...` (structure eta), so fire the rule with field - -- projections in place of ctor args. - -- ========================================================================== - fn try_struct_eta_iota(rc: RoleCtx, rec_ty: KExpr, lvls: List‹KLevel›, - spine: List‹KExpr›, nparams: G, nmotives: G, - nminors: G, nindices: G, - rules: List‹KRecRule›, - types: List‹KExpr›) -> (G, KExpr) { - match load(rules) { - ListNode.Nil => (0, store(KExprNode.BVar(0))), - ListNode.Cons(r, rest) => - match load(rest) { - ListNode.Cons(_, _) => (0, store(KExprNode.BVar(0))), - ListNode.Nil => - match r { - KRecRule.Mk(_, nf, rhs) => - let skip = ((nparams + nmotives) + nminors) + nindices; - match se_parent_addr(rec_ty, skip) { - (0, _) => (0, store(KExprNode.BVar(0))), - (_, parent) => - let ci = load(get_ci(parent)); - match ci { - KConstantInfo.Induct(_, _, _, ind_nidx, num_ctors, - _, _, _) => - match num_ctors - 1 { - 0 => - match ind_nidx { - 0 => - match struct_is_rec(parent) { - 1 => (0, store(KExprNode.BVar(0))), - _ => - let major = list_lookup(spine, skip); - -- Struct-eta is speculative. During - -- canonical recursor reconstruction, WHNF - -- can encounter a loose major under a - -- deliberately empty local context. The - -- reference declines eta when inference - -- cannot establish the major's type; do - -- the same instead of indexing past - -- `types` in `k_infer`. - match memo_u32_less_than(list_length(types), - expr_lbr(major)) { - 1 => (0, store(KExprNode.BVar(0))), - _ => - let major_ty = k_infer(rc, major, types); - match is_prop_type(rc, major_ty, types) { - 1 => (0, store(KExprNode.BVar(0))), - _ => - let rhs_inst = expr_inst_levels(rhs, lvls); - let pmm = list_take(spine, - (nparams + nmotives) + nminors); - let after_pmm = apply_spine(rhs_inst, pmm); - let with_projs = apply_n_projs( - after_pmm, parent, major, nf, 0); - let post = list_drop(spine, skip + 1); - (1, apply_spine(with_projs, post)), - }, - }, - }, - _ => (0, store(KExprNode.BVar(0))), - }, - _ => (0, store(KExprNode.BVar(0))), - }, - _ => (0, store(KExprNode.BVar(0))), - }, - }, - }, - }, - } - } - - -- Parse the recursor's parent inductive addr from its type: peel - -- (params+motives+minors+indices) foralls, take the major-premise - -- forall's dom, return its spine head Const addr. - fn se_parent_addr(rec_ty: KExpr, skip: G) -> (G, Addr) { - match skip { - 0 => - match load(rec_ty) { - KExprNode.Forall(dom, _) => - match collect_spine(dom) { - (h, _) => - match load(h) { - KExprNode.Const(a, _) => (1, a), - _ => (0, store([0u8; 32])), - }, - }, - _ => (0, store([0u8; 32])), - }, - _ => - match load(rec_ty) { - KExprNode.Forall(_, body) => se_parent_addr(body, skip - 1), - _ => (0, store([0u8; 32])), - }, - } - } - - fn apply_n_projs(head: KExpr, parent: Addr, major: KExpr, - n_fields: G, i: G) -> KExpr { - match n_fields - i { - 0 => head, - _ => - let p = store(KExprNode.Proj(parent, i, major)); - apply_n_projs(store(KExprNode.App(head, p)), parent, major, - n_fields, i + 1), - } - } - - -- 1 iff the inductive at `parent` is recursive: any ctor field dom - -- mentions a block-member addr (mirror computed_is_rec_ind, - -- Inductive.lean:376). Unknown shapes conservatively report 1 - -- (recursive) so struct-eta refuses. Aiur-memoized per parent. - fn struct_is_rec(parent: Addr) -> G { - let ci = load(get_ci(parent)); - match ci { - KConstantInfo.Induct(_, _, n_params, _, num_ctors, _, block, idx) => - let members = struct_block_member_addrs(parent, block); - struct_scan_ctors(block, idx, num_ctors, n_params, members, 0), - _ => 1, - } - } - - fn struct_block_member_addrs(parent: Addr, block: Addr) -> List‹Addr› { - let c = load_verified_constant(block); - match c { - Constant.Mk(info, _, _, _) => - match info { - ConstantInfo.Muts(members) => build_recur_addrs(members, block), - _ => store(ListNode.Cons(parent, store(ListNode.Nil))), - }, - } - } - - fn struct_scan_ctors(block: Addr, idx: G, num_ctors: G, n_params: G, - members: List‹Addr›, c: G) -> G { - match num_ctors - c { - 0 => 0, - _ => - let cci = load(get_ci_cprj(block, idx, c)); - match cci { - KConstantInfo.Ctor(_, cty, _, _, _, _, _, _) => - let after = se_peel_tol(cty, n_params); - match se_scan_fields(after, members) { - 1 => 1, - _ => struct_scan_ctors(block, idx, num_ctors, n_params, - members, c + 1), - }, - _ => 1, - }, - } - } - - fn se_peel_tol(ty: KExpr, n: G) -> KExpr { - match n { - 0 => ty, - _ => - match load(ty) { - KExprNode.Forall(_, body) => se_peel_tol(body, n - 1), - _ => ty, - }, - } - } - - fn se_scan_fields(ty: KExpr, members: List‹Addr›) -> G { - match load(ty) { - KExprNode.Forall(dom, body) => - match se_mentions(dom, members) { - 1 => 1, - _ => se_scan_fields(body, members), - }, - _ => 0, - } - } - - fn se_mentions(e: KExpr, members: List‹Addr›) -> G { - match load(e) { - KExprNode.Const(a, _) => se_addr_in(a, members), - KExprNode.App(f, x) => - match se_mentions(f, members) { - 1 => 1, - _ => se_mentions(x, members), - }, - KExprNode.Lam(t, b) => - match se_mentions(t, members) { - 1 => 1, - _ => se_mentions(b, members), - }, - KExprNode.Forall(t, b) => - match se_mentions(t, members) { - 1 => 1, - _ => se_mentions(b, members), - }, - KExprNode.Let(t, v, b) => - match se_mentions(t, members) { - 1 => 1, - _ => - match se_mentions(v, members) { - 1 => 1, - _ => se_mentions(b, members), - }, - }, - KExprNode.Proj(_, _, inner) => se_mentions(inner, members), - _ => 0, - } - } - - fn se_addr_in(a: Addr, xs: List‹Addr›) -> G { - match load(xs) { - ListNode.Nil => 0, - ListNode.Cons(x, rest) => - match address_eq(a, x) { - 1 => 1, - _ => se_addr_in(a, rest), - }, - } - } - - -- Fast path (mirror whnf): trivial whnf normal forms skip the - -- spine machinery and memo row entirely. - fn whnf(rc: RoleCtx, e: KExpr, types: List‹KExpr›) -> KExpr { - match load(e) { - KExprNode.Srt(_) => e, - KExprNode.Lit(_) => e, - KExprNode.Lam(_, _) => e, - KExprNode.Forall(_, _) => e, - KExprNode.BVar(_) => e, - _ => @whnf_core(rc, e, ctx_trim(types, expr_lbr(e))), - } - } - - fn whnf_core(rc: RoleCtx, e: KExpr, types: List‹KExpr›) -> KExpr { - whnf_with_spine(rc, e, store(ListNode.Nil), types) - } - - -- Structural WHNF for def-eq Tier 4c. Unlike the historical Aiur - -- `whnf_core` name above, this performs no delta and no primitive - -- dispatch. Projections use full reduction of their scrutinee, matching - -- the reference Tier 4c policy after bounded lazy delta has had its turn. - fn whnf_struct_core(rc: RoleCtx, e: KExpr, types: List‹KExpr›) -> KExpr { - match load(e) { - KExprNode.Srt(_) => e, - KExprNode.Lit(_) => e, - KExprNode.Lam(_, _) => e, - KExprNode.Forall(_, _) => e, - KExprNode.BVar(_) => e, - _ => whnf_struct_core_spine(rc, e, store(ListNode.Nil), - ctx_trim(types, expr_lbr(e))), - } - } - - fn whnf_struct_core_spine(rc: RoleCtx, head: KExpr, spine: List‹KExpr›, - types: List‹KExpr›) -> KExpr { - match load(head) { - KExprNode.App(_, _) => - match collect_spine(head) { - (h, s) => whnf_struct_core_spine(rc, h, list_concat(s, spine), types), - }, - KExprNode.Lam(_, _) => - match peel_beta(head, spine, store(ListNode.Nil)) { - (deep, consumed, rest) => - match list_length(consumed) { - 0 => apply_spine(head, spine), - 1 => whnf_struct_core_spine(rc, - expr_inst1(deep, list_lookup(consumed, 0), 0), rest, types), - _ => whnf_struct_core_spine(rc, - expr_inst_many(deep, consumed, 0), rest, types), - }, - }, - KExprNode.Let(_, val, body) => - whnf_struct_core_spine(rc, expr_inst1(body, val, 0), spine, types), - KExprNode.Proj(struct_addr, fidx, inner) => - whnf_struct_core_proj(rc, struct_addr, fidx, inner, spine, types, head), - KExprNode.Const(addr, lvls) => - whnf_struct_core_const(rc, addr, lvls, head, spine, types), - _ => apply_spine(head, spine), - } - } - - fn whnf_struct_core_proj(rc: RoleCtx, struct_addr: Addr, fidx: G, inner: KExpr, - spine: List‹KExpr›, types: List‹KExpr›, - original: KExpr) -> KExpr { - let inner_w = whnf_struct_core(rc, inner, types); - match collect_spine(inner_w) { - (ih, ia) => - match load(ih) { - KExprNode.Const(_, _) => - match load(whnf_get_ctor_or_none(ih)) { - KConstantInfo.Ctor(_, _, _, _, _, nparams, _, _) => - whnf_struct_core_spine(rc, list_lookup(ia, nparams + fidx), - spine, types), - _ => apply_spine(original, spine), - }, - _ => apply_spine(original, spine), - }, - } - } - - fn whnf_struct_core_const(rc: RoleCtx, addr: Addr, lvls: List‹KLevel›, head: KExpr, - spine: List‹KExpr›, - types: List‹KExpr›) -> KExpr { - match load(get_ci(addr)) { - KConstantInfo.Rec(_, rec_ty, nparams, nindices, nmotives, nminors, - rules, _k, _unsafe, _block, _ridx) => - match try_iota(rc, lvls, spine, nparams, nmotives, nminors, nindices, - rules, types, head, - rec_to_parent_addr(rec_ty, nparams, nmotives, nminors, - nindices)) { - (1, reduced) => whnf_struct_core(rc, reduced, types), - _ => apply_spine(head, spine), - }, - _ => apply_spine(head, spine), - } - } - - -- ============================================================================ - -- whnf_nd: WHNF without delta-unfolding. - -- - -- Same dispatch tree as whnf, but the Defn/Thm arms of the const - -- head return the stuck application instead of unfolding. Beta / zeta / - -- iota / proj / quot / primitives still fire — they don't need delta. - -- - -- Used by def_eq's Tier 1d structural pre-check: many comparisons - -- settle at no-delta whnf + ptr_eq or quick structural compare, - -- avoiding the cascading full-delta unfold of large Defn bodies. - -- ============================================================================ - fn whnf_nd(rc: RoleCtx, e: KExpr, types: List‹KExpr›) -> KExpr { - match load(e) { - KExprNode.Srt(_) => e, - KExprNode.Lit(_) => e, - KExprNode.Lam(_, _) => e, - KExprNode.Forall(_, _) => e, - KExprNode.BVar(_) => e, - _ => @whnf_nd_core(rc, e, ctx_trim(types, expr_lbr(e))), - } - } - - fn whnf_nd_core(rc: RoleCtx, e: KExpr, types: List‹KExpr›) -> KExpr { - whnf_nd_with_spine(rc, e, store(ListNode.Nil), types) - } - - fn whnf_nd_with_spine(rc: RoleCtx, head: KExpr, spine: List‹KExpr›, - types: List‹KExpr›) -> KExpr { - match load(head) { - KExprNode.App(f, a) => - match collect_spine(head) { - (inner_head, inner_spine) => - whnf_nd_with_spine(rc, inner_head, list_concat(inner_spine, spine), types), - }, - KExprNode.Lam(ty, body) => - whnf_nd_apply_beta(rc, spine, head, types), - KExprNode.Const(addr, lvls) => - whnf_nd_const_head(rc, addr, lvls, head, spine, types), - KExprNode.Let(_, val, body) => - let next = expr_inst1(body, val, 0); - whnf_nd_with_spine(rc, next, spine, types), - KExprNode.Proj(struct_addr, fidx, inner) => - whnf_nd_proj_head(rc, struct_addr, fidx, inner, spine, types), - _ => apply_spine(head, spine), - } - } - - fn whnf_nd_apply_beta(rc: RoleCtx, spine: List‹KExpr›, lam: KExpr, - types: List‹KExpr›) -> KExpr { - match peel_beta(lam, spine, store(ListNode.Nil)) { - (deep, consumed, rest) => - match list_length(consumed) { - 0 => apply_spine(lam, spine), - 1 => - let body2 = expr_inst1(deep, list_lookup(consumed, 0), 0); - whnf_nd_with_spine(rc, body2, rest, types), - _ => - let body2 = expr_inst_many(deep, consumed, 0); - whnf_nd_with_spine(rc, body2, rest, types), - }, - } - } - - -- Proj head in no-delta mode: whnf_nd the scrutinee; the ctor-field pull - -- still applies. - fn whnf_nd_proj_head(rc: RoleCtx, struct_addr: Addr, fidx: G, inner: KExpr, - spine: List‹KExpr›, types: List‹KExpr›) -> KExpr { - let inner_whnf = whnf_nd(rc, inner, types); - -- Same Str-literal re-expansion as whnf_proj_head. - let inner_exp = str_lit_to_ctor_app_or_self(rc, inner_whnf, types); - match collect_spine(inner_exp) { - (inner_head, inner_args) => - match load(inner_head) { - KExprNode.Const(_, _) => - match load(whnf_get_ctor_or_none(inner_head)) { - KConstantInfo.Ctor(_, _, _, _, _, nparams, _, _) => - let field = list_lookup(inner_args, nparams + fidx); - whnf_nd_with_spine(rc, field, spine, types), - _ => - let stuck = store(KExprNode.Proj(struct_addr, fidx, inner_whnf)); - apply_spine(stuck, spine), - }, - _ => - let stuck = store(KExprNode.Proj(struct_addr, fidx, inner_whnf)); - apply_spine(stuck, spine), - }, - } - } - - -- Difference from whnf_const_head: Defn/Thm arms return the stuck - -- application instead of unfolding. Iota, quot, primitives and the - -- projection-definition shortcut still apply (proj-def reads the Defn - -- value shape but never expands the body into the term). - fn whnf_nd_const_head(rc: RoleCtx, addr: Addr, lvls: List‹KLevel›, head: KExpr, - spine: List‹KExpr›, types: List‹KExpr›) -> KExpr { - -- Def-eq's no-delta reducer must not evaluate an open Nat primitive. - -- Its dispatcher prepares arguments with full WHNF, which can expose the - -- recursive logical body of Nat.ble and walk enormous symbolic offsets. - -- This mirrors the reference kernel's `has_fvars` gate: closed primitive - -- computations still reduce normally; open ones remain compact for lazy - -- delta / offset comparison. - let (fam, _op) = prim_family(rc, addr); - let prim = match fam { - 0 => (0, store(KExprNode.BVar(0))), - 1 => - let whole = apply_spine(head, spine); - match expr_lbr(whole) { - 0 => try_prim_dispatch(rc, addr, lvls, spine, types), - _ => (0, store(KExprNode.BVar(0))), - }, - _ => try_prim_dispatch(rc, addr, lvls, spine, types), - }; - match prim { - (1, reduced) => whnf_nd(rc, reduced, types), - -- verdict 2: already-stuck compact form; do not re-whnf. - (2, stuck) => stuck, - _ => - let ci = load(get_ci(addr)); - match ci { - KConstantInfo.Defn(_, _, value, _, _) => - let pd = try_reduce_projection_definition(value, spine); - match pd { - (1, reduced) => whnf_nd(rc, reduced, types), - _ => apply_spine(head, spine), - }, - KConstantInfo.Quot(_, _, _) => - let quot = try_quot_iota(rc, addr, spine, types); - match quot { - (1, reduced) => whnf_nd(rc, reduced, types), - _ => apply_spine(head, spine), - }, - KConstantInfo.Rec(nlvls, rec_ty, nparams, nindices, nmotives, nminors, - rules, k_flag, _unsafe, _block, _ridx) => - -- Mirror whnf_const_head's Rec arm, including the pre-whnf - -- K-ctor synthesis and the struct-eta fallback. Without the K - -- step, `Eq.rec` over an open proof (`cast (h : α = α) x`) - -- cannot reduce in no-delta mode — and the lazy def-eq tiers - -- normalize exclusively with whnf_nd, so K-closable pairs - -- (cast_eq shapes) would falsely reject. - let k_skip = ((nparams + nmotives) + nminors) + nindices; - let k_pre = match k_flag { - 1 => - match se_parent_addr(rec_ty, k_skip) { - (_, rec_parent) => - try_k_synth_iota(rc, lvls, spine, nparams, nmotives, - nminors, nindices, rules, - rec_parent, types), - }, - _ => (0, head), - }; - match k_pre { - (1, k_reduct) => k_reduct, - _ => - let iota = try_iota(rc, lvls, spine, nparams, nmotives, nminors, - nindices, rules, types, head, - rec_to_parent_addr(rec_ty, nparams, nmotives, - nminors, nindices)); - match iota { - (1, reduced) => whnf_nd(rc, reduced, types), - (2, stuck) => - match k_flag { - 1 => stuck, - _ => - match try_struct_eta_iota(rc, rec_ty, lvls, spine, nparams, - nmotives, nminors, nindices, rules, types) { - (1, r) => whnf_nd(rc, r, types), - _ => stuck, - }, - }, - _ => apply_spine(head, spine), - }, - }, - _ => apply_spine(head, spine), - }, - } - } -⟧ - -end IxVM - -end - diff --git a/Ix/IxVM/KernelTypes.lean b/Ix/IxVM/KernelTypes.lean deleted file mode 100644 index e51160bb8..000000000 --- a/Ix/IxVM/KernelTypes.lean +++ /dev/null @@ -1,120 +0,0 @@ -module -public import Ix.Aiur.Meta - -public section - -namespace IxVM - -def kernelTypes := ⟦ - -- ============================================================================ - -- KernelTypes — the addr-first kernel term representation - -- - -- Every constant reference in a KExpr is a content-hash `Addr`, never a - -- position. Consumers resolve refs through the memoized `get_ci(addr)`, - -- so no global constant list has to be threaded to interpret a term. - -- - -- Precondition: the Lean→Ixon compile alpha-collapses the env before - -- witness build, so every logical constant has exactly ONE canonical - -- addr and duplicate Muts wrappers are already merged. The kernel does - -- no dedup of its own — same content gives the same addr, which the - -- store interns to the same pointer, so sharing is automatic. - -- ============================================================================ - - -- Universe Levels. - enum KLevelNode { - Zero, - Succ(KLevel), - Max(KLevel, KLevel), - IMax(KLevel, KLevel), - Param(G) - } - - type KLevel = &KLevelNode - - -- Literals. Nat literals are little-endian U64 limb lists; see Klimbs. - type KLimbs = List‹U64› - - enum KLiteral { - Nat(KLimbs), - Str(ByteStream) - } - - -- ============================================================================ - -- Expressions — addr-first `Const(Addr, List)`. - -- - -- Proj carries its structure type as an `Addr` too, not an index, so a - -- projection is interpretable on its own; consumers resolve it via - -- `get_ci(addr)` like any other reference. - -- ============================================================================ - - enum KExprNode { - BVar(G), - Srt(KLevel), - Const(Addr, List‹KLevel›), - App(KExpr, KExpr), - Lam(KExpr, KExpr), - Forall(KExpr, KExpr), - Let(KExpr, KExpr, KExpr), - Lit(KLiteral), - Proj(Addr, G, KExpr) - } - - type KExpr = &KExprNode - - -- collect_spine: peel `App(f, a)` layers. Non-tail, memoized per `e`; - -- shared sub-spines dedup. - fn collect_spine(e: KExpr) -> (KExpr, List‹KExpr›) { - match load(e) { - KExprNode.App(f, a) => - let (head, args) = collect_spine(f); - (head, list_snoc(args, a)), - _ => (e, store(ListNode.Nil)), - } - } - - -- ============================================================================ - -- Recursor Rule - -- - -- the kernel: `cidx` identifies the constructor within the parent inductive. - -- Iota matches by `cidx == ctor.cidx`. Rule's ctor address is - -- (rec.block_addr, rec.ind_idx, cidx) — implicit from the rec's context. - -- ============================================================================ - - enum KRecRule { - Mk(G, G, KExpr) - } - - -- ============================================================================ - -- Constant Info — the kernel addr-first - -- - -- Ctor / Induct / Rec reference their parent Muts wrapper by - -- `(block_addr, ind_idx)` pair instead of a synthesized projection - -- addr. This avoids needing to compute blake3(IPrj(idx, block_addr)) - -- at kernel time. Consumers wanting the parent inductive's KCI call - -- `get_ci_ind_at(block_addr, ind_idx)`. - -- - -- CIInduct: (num_levels, type, num_params, num_indices, num_ctors, - -- is_unsafe, block_addr, ind_idx) - -- CICtor: (num_levels, type, block_addr, ind_idx, cidx, - -- num_params, num_fields, is_unsafe) - -- CIRec: (num_levels, type, num_params, num_indices, - -- num_motives, num_minors, rules, k_flag, is_unsafe, - -- block_addr, rec_idx) - -- ============================================================================ - - enum KConstantInfo { - Axiom(G, KExpr, G), - Defn(G, KExpr, KExpr, DefinitionSafety, G), - Thm(G, KExpr, KExpr), - Opaque(G, KExpr, KExpr, G), - Quot(G, KExpr, QuotKind), - Induct(G, KExpr, G, G, G, G, Addr, G), - Ctor(G, KExpr, Addr, G, G, G, G, G), - Rec(G, KExpr, G, G, G, G, List‹KRecRule›, G, G, Addr, G) - } - -⟧ - -end IxVM - -end diff --git a/Ix/IxVM/RBTreeMap.lean b/Ix/IxVM/RBTreeMap.lean deleted file mode 100644 index 16c4d8b56..000000000 --- a/Ix/IxVM/RBTreeMap.lean +++ /dev/null @@ -1,202 +0,0 @@ -module -public import Ix.Aiur.Meta - -public section - -namespace IxVM - -def rbTreeMap := ⟦ - enum RBTreeMap‹V› { - -- Color {0: red, 1: black}, key, value, left, right - Node(G, G, V, &RBTreeMap‹V›, &RBTreeMap‹V›), - Nil - } - - -- Okasaki-style balance: fixes red-red violations after insertion. - -- - -- A violation can only occur under a BLACK parent (color 1); a red - -- parent never rebalances. The 4 rebalance cases are WIDE (they deref a - -- red grandchild and rebuild 3 nodes), so they're factored into the cold - -- `rbtree_map_balance_fix`. Aiur lays a function's width as the max over - -- match arms, so keeping the hot path (red parent / black parent with no - -- violation) here as a narrow color-dispatch keeps `balance` itself - -- narrow; the wide rebalance machinery only taxes the rows that actually - -- reach `_fix` (black parents). - fn rbtree_map_balance‹V›(color: G, key: G, value: V, left: RBTreeMap‹V›, right: RBTreeMap‹V›) -> RBTreeMap‹V› { - match color { - 1 => rbtree_map_balance_fix(key, value, left, right), - _ => RBTreeMap.Node(color, key, value, store(left), store(right)), - } - } - - -- Cold path: parent is black (color 1). Match the 4 red-red grandchild - -- configurations; the fall-through is "black parent, no violation". - fn rbtree_map_balance_fix‹V›(key: G, value: V, left: RBTreeMap‹V›, right: RBTreeMap‹V›) -> RBTreeMap‹V› { - match (left, right) { - -- Case 1: left child red, left-left grandchild red - (RBTreeMap.Node(0, yk, yv, &RBTreeMap.Node(0, xk, xv, a, b), c), d) => - RBTreeMap.Node(0, yk, yv, - store(RBTreeMap.Node(1, xk, xv, a, b)), - store(RBTreeMap.Node(1, key, value, c, store(d)))), - -- Case 2: left child red, left-right grandchild red - (RBTreeMap.Node(0, xk, xv, a, &RBTreeMap.Node(0, yk, yv, b, c)), d) => - RBTreeMap.Node(0, yk, yv, - store(RBTreeMap.Node(1, xk, xv, a, b)), - store(RBTreeMap.Node(1, key, value, c, store(d)))), - -- Case 3: right child red, right-left grandchild red - (a, RBTreeMap.Node(0, zk, zv, &RBTreeMap.Node(0, yk, yv, b, c), d)) => - RBTreeMap.Node(0, yk, yv, - store(RBTreeMap.Node(1, key, value, store(a), b)), - store(RBTreeMap.Node(1, zk, zv, c, d))), - -- Case 4: right child red, right-right grandchild red - (a, RBTreeMap.Node(0, yk, yv, b, &RBTreeMap.Node(0, zk, zv, c, d))) => - RBTreeMap.Node(0, yk, yv, - store(RBTreeMap.Node(1, key, value, store(a), b)), - store(RBTreeMap.Node(1, zk, zv, c, d))), - -- No violation (black parent) - _ => RBTreeMap.Node(1, key, value, store(left), store(right)), - } - } - - -- Internal insert (new nodes are red) - fn rbtree_map_ins‹V›(key: G, value: V, tree: RBTreeMap‹V›) -> RBTreeMap‹V› { - match tree { - RBTreeMap.Nil => - RBTreeMap.Node(0, key, value, store(RBTreeMap.Nil), store(RBTreeMap.Nil)), - RBTreeMap.Node(color, k, v, &left, &right) => - let lt = u32_less_than(key, k); - match lt { - 1 => rbtree_map_balance(color, k, v, rbtree_map_ins(key, value, left), right), - _ => - -- key not < k. Distinguish equal (overwrite) from greater - -- (recurse right) with a field subtraction instead of a second - -- u32_less_than (which would cost +12 aux / +6 lookups). Keys - -- are u32-range field elements, so `key - k == 0` iff equal. - let eq = key - k; - match eq { - 0 => RBTreeMap.Node(color, key, value, store(left), store(right)), - _ => rbtree_map_balance(color, k, v, left, rbtree_map_ins(key, value, right)), - }, - }, - } - } - - -- Public insert: inserts key-value pair, enforces black root - fn rbtree_map_insert‹V›(key: G, value: V, tree: RBTreeMap‹V›) -> RBTreeMap‹V› { - let result = rbtree_map_ins(key, value, tree); - match result { - RBTreeMap.Node(_, k, v, left, right) => RBTreeMap.Node(1, k, v, left, right), - } - } - - -- Lookup: returns the value associated with the key. - -- Panics if the key is not found (no Nil case) — tightest circuit - -- when callers know the key is present by construction. - fn rbtree_map_lookup‹V›(key: G, tree: RBTreeMap‹V›) -> V { - match tree { - RBTreeMap.Node(_, k, v, &left, &right) => - let lt = u32_less_than(key, k); - match lt { - 1 => rbtree_map_lookup(key, left), - _ => - let eq = key - k; - match eq { - 0 => v, - _ => rbtree_map_lookup(key, right), - }, - }, - } - } - - -- Lookup with default: returns the value if found, else `default`. - -- Use when the caller can't statically guarantee key presence - -- (e.g. `find_addr_idx_safe`). - fn rbtree_map_lookup_or_default‹V›(key: G, tree: RBTreeMap‹V›, default: V) -> V { - match tree { - RBTreeMap.Nil => default, - RBTreeMap.Node(_, k, v, &left, &right) => - let lt = u32_less_than(key, k); - match lt { - 1 => rbtree_map_lookup_or_default(key, left, default), - _ => - let eq = key - k; - match eq { - 0 => v, - _ => rbtree_map_lookup_or_default(key, right, default), - }, - }, - } - } - - /- # Test entrypoints -/ - - pub fn rbtree_map_test() -> [G; 22] { - -- Single insert and lookup - let tree = rbtree_map_insert(5, 42, RBTreeMap.Nil); - let r0 = rbtree_map_lookup(5, tree); - - -- Three inserts - let tree = rbtree_map_insert(10, 100, RBTreeMap.Nil); - let tree = rbtree_map_insert(20, 200, tree); - let tree = rbtree_map_insert(5, 50, tree); - let r1 = rbtree_map_lookup(5, tree); - let r2 = rbtree_map_lookup(10, tree); - let r3 = rbtree_map_lookup(20, tree); - - -- Overwrite - let tree = rbtree_map_insert(10, 100, RBTreeMap.Nil); - let tree = rbtree_map_insert(10, 999, tree); - let r4 = rbtree_map_lookup(10, tree); - - -- Ascending insertion order - let tree = rbtree_map_insert(1, 10, RBTreeMap.Nil); - let tree = rbtree_map_insert(2, 20, tree); - let tree = rbtree_map_insert(3, 30, tree); - let tree = rbtree_map_insert(4, 40, tree); - let tree = rbtree_map_insert(5, 50, tree); - let r5 = rbtree_map_lookup(1, tree); - let r6 = rbtree_map_lookup(2, tree); - let r7 = rbtree_map_lookup(3, tree); - let r8 = rbtree_map_lookup(4, tree); - let r9 = rbtree_map_lookup(5, tree); - - -- Descending insertion order - let tree = rbtree_map_insert(5, 50, RBTreeMap.Nil); - let tree = rbtree_map_insert(4, 40, tree); - let tree = rbtree_map_insert(3, 30, tree); - let tree = rbtree_map_insert(2, 20, tree); - let tree = rbtree_map_insert(1, 10, tree); - let r10 = rbtree_map_lookup(1, tree); - let r11 = rbtree_map_lookup(2, tree); - let r12 = rbtree_map_lookup(3, tree); - let r13 = rbtree_map_lookup(4, tree); - let r14 = rbtree_map_lookup(5, tree); - - -- Mixed insertion order - let tree = rbtree_map_insert(50, 500, RBTreeMap.Nil); - let tree = rbtree_map_insert(30, 300, tree); - let tree = rbtree_map_insert(70, 700, tree); - let tree = rbtree_map_insert(20, 200, tree); - let tree = rbtree_map_insert(40, 400, tree); - let tree = rbtree_map_insert(60, 600, tree); - let tree = rbtree_map_insert(80, 800, tree); - let r15 = rbtree_map_lookup(20, tree); - let r16 = rbtree_map_lookup(30, tree); - let r17 = rbtree_map_lookup(40, tree); - let r18 = rbtree_map_lookup(50, tree); - let r19 = rbtree_map_lookup(60, tree); - let r20 = rbtree_map_lookup(70, tree); - let r21 = rbtree_map_lookup(80, tree); - - [r0, - r1, r2, r3, - r4, - r5, r6, r7, r8, r9, - r10, r11, r12, r13, r14, - r15, r16, r17, r18, r19, r20, r21] - } -⟧ - -end IxVM - -end diff --git a/Ix/IxVM/RoleSpecGen.lean b/Ix/IxVM/RoleSpecGen.lean index e195010c2..9744c3785 100644 --- a/Ix/IxVM/RoleSpecGen.lean +++ b/Ix/IxVM/RoleSpecGen.lean @@ -9,8 +9,8 @@ public import Ix.SpecDigest IxVM reads a claim's primitives through its role binding and validates each bound role against IxC's specification (`Ix.Kernel.Role.spec`) before using it. The circuit cannot evaluate Lean data, so this module renders the -specification set as Aiur source: `Ix/IxVM/Kernel/RoleSpec.lean`, which -`lake exe ix codegen` writes and `lake exe ix codegen --check` +specification set as Formal Aiur source: `IxVM/IxVM/Modules/KernelRoleSpec.aiur`, +which `lake exe ix codegen` writes and `lake exe ix codegen --check` compares against this renderer. The rendered file names `specVersion` and the specification digest, so a change to the specifications that is not regenerated here fails that check. @@ -139,7 +139,7 @@ def roleName (r : Role) : String := /-! ## Terms -/ def list (xs : List String) : String := - xs.foldr (fun x acc => s!"store(ListNode.Cons({x}, {acc}))") "store(ListNode.Nil)" + xs.foldr (fun x acc => s!"(&(Lists::Node::Cons({x}, {acc})))") "(&(Lists::Node::Nil))" /-- A structured pointer-valued circuit expression for per-arm DAG common subexpression elimination. -/ @@ -149,16 +149,16 @@ inductive RVal where deriving BEq, Hashable, Inhabited def rStore (ctor : String) (args : List RVal) : RVal := - if args.isEmpty then .node s!"store({ctor})" [] "" - else .node s!"store({ctor}(" args "))" + if args.isEmpty then .node s!"(&({ctor}))" [] "" + else .node s!"(&({ctor}(" args ")))" def rBoundAddr (r : Nat) : RVal := - .node "role_bound_addr(" [.raw "tbl", .raw (toString r)] ")" + .node "KernelRoles::role_bound_addr(" [.raw "tbl", .raw (toString r)] ")" -def rNil : RVal := rStore "ListNode.Nil" [] +def rNil : RVal := rStore "Lists::Node::Nil" [] def rList (xs : List RVal) : RVal := - xs.foldr (fun x acc => rStore "ListNode.Cons" [x, acc]) rNil + xs.foldr (fun x acc => rStore "Lists::Node::Cons" [x, acc]) rNil partial def collectPostOrder (v : RVal) (seen : Std.HashSet RVal) (order : Array RVal) : Std.HashSet RVal × Array RVal := @@ -193,7 +193,7 @@ def renderArm (root : RVal) : String := Id.run do if uses.getD n 0 >= 2 && n != root then let varName := s!"x{idx}" idx := idx + 1 - lets := lets ++ s!" let {varName} = {exprStr};\n" + lets := lets ++ s!" let {varName} = {exprStr};\n" env := env.insert n varName else env := env.insert n exprStr @@ -201,18 +201,18 @@ def renderArm (root : RVal) : String := Id.run do | .raw s => s | _ => env.getD root "" if lets.isEmpty then rootStr - else s!"\n{lets} {rootStr}" + else s!"\n{lets} {rootStr}" /-- A level under the level parameters `ps`: IxC names a parameter by its id, the circuit by its position in the constant's list (`Eq.rec.{u_1, u}` lists `u_1` first). -/ def level (ps : List LevelParam) : Level → Except String RVal - | .zero => pure (rStore "KLevelNode.Zero" []) - | .succ u => do pure (rStore "KLevelNode.Succ" [← level ps u]) - | .max u v => do pure (rStore "KLevelNode.Max" [← level ps u, ← level ps v]) - | .imax u v => do pure (rStore "KLevelNode.IMax" [← level ps u, ← level ps v]) + | .zero => pure (rStore "KernelTypes::KLevelNode::Zero" []) + | .succ u => do pure (rStore "KernelTypes::KLevelNode::Succ" [← level ps u]) + | .max u v => do pure (rStore "KernelTypes::KLevelNode::Max" [← level ps u, ← level ps v]) + | .imax u v => do pure (rStore "KernelTypes::KLevelNode::IMax" [← level ps u, ← level ps v]) | .param i => - if ps.contains i then pure (rStore "KLevelNode.Param" [.raw (toString (ps.idxOf i))]) + if ps.contains i then pure (rStore "KernelTypes::KLevelNode::Param" [.raw (toString (ps.idxOf i))]) else throw s!"level parameter {i} is not among {ps}" def roleKey : Key .anon → Except String Nat @@ -223,44 +223,44 @@ def roleKey : Key .anon → Except String Nat binders a caller closes over, outermost first, so `fvar i` is `BVar (depth - 1 - i)`. -/ def expr (ps : List LevelParam) (depth : Nat) : Expr .anon → Except String RVal - | .bvar i => pure (rStore "KExprNode.BVar" [.raw (toString i)]) + | .bvar i => pure (rStore "KernelTypes::KExprNode::BVar" [.raw (toString i)]) | .fvar i _ => - if i < depth then pure (rStore "KExprNode.BVar" [.raw (toString (depth - 1 - i))]) + if i < depth then pure (rStore "KernelTypes::KExprNode::BVar" [.raw (toString (depth - 1 - i))]) else throw s!"open variable {i} outside its binder" - | .sort u => do pure (rStore "KExprNode.Srt" [← level ps u]) + | .sort u => do pure (rStore "KernelTypes::KExprNode::Srt" [← level ps u]) | .const k us => do - pure (rStore "KExprNode.Const" [rBoundAddr (← roleKey k), rList (← us.mapM (level ps))]) - | .app f a => do pure (rStore "KExprNode.App" [← expr ps depth f, ← expr ps depth a]) - | .lam t b _ => do pure (rStore "KExprNode.Lam" [← expr ps depth t, ← expr ps (depth + 1) b]) + pure (rStore "KernelTypes::KExprNode::Const" [rBoundAddr (← roleKey k), rList (← us.mapM (level ps))]) + | .app f a => do pure (rStore "KernelTypes::KExprNode::App" [← expr ps depth f, ← expr ps depth a]) + | .lam t b _ => do pure (rStore "KernelTypes::KExprNode::Lam" [← expr ps depth t, ← expr ps (depth + 1) b]) | .forallE t b _ => do - pure (rStore "KExprNode.Forall" [← expr ps depth t, ← expr ps (depth + 1) b]) + pure (rStore "KernelTypes::KExprNode::Forall" [← expr ps depth t, ← expr ps (depth + 1) b]) | .letE t v b _ => do - pure (rStore "KExprNode.Let" [← expr ps depth t, ← expr ps depth v, ← expr ps (depth + 1) b]) + pure (rStore "KernelTypes::KExprNode::Let" [← expr ps depth t, ← expr ps depth v, ← expr ps (depth + 1) b]) | .lit _ => throw "a literal in a specification" | .proj s i e => do - pure (rStore "KExprNode.Proj" [rBoundAddr (← roleKey s), .raw (toString i), ← expr ps depth e]) + pure (rStore "KernelTypes::KExprNode::Proj" [rBoundAddr (← roleKey s), .raw (toString i), ← expr ps depth e]) /-- `Nat`, through the binding. -/ -def natT : RVal := rStore "KExprNode.Const" [rBoundAddr (roleIdx .nat), rNil] +def natT : RVal := rStore "KernelTypes::KExprNode::Const" [rBoundAddr (roleIdx .nat), rNil] /-- `λ (x y : Nat), side`. -/ def closeEquationSide (side : Expr .anon) : Except String String := do - let root := rStore "KExprNode.Lam" [natT, rStore "KExprNode.Lam" [natT, ← expr [] 2 side]] + let root := rStore "KernelTypes::KExprNode::Lam" [natT, rStore "KernelTypes::KExprNode::Lam" [natT, ← expr [] 2 side]] pure (renderArm root) /-- `Π (x y : Nat) (h₀ : hyp₀) …, @Eq.{1} Nat lhs rhs`. -/ def closeCertificate (hyps : List (Expr .anon)) (lhs rhs : Expr .anon) : Except String String := do let depth := 2 + hyps.length - let eqHead := rStore "KExprNode.Const" - [rBoundAddr (roleIdx .eq), rList [rStore "KLevelNode.Succ" [rStore "KLevelNode.Zero" []]]] - let eqn := rStore "KExprNode.App" - [rStore "KExprNode.App" [rStore "KExprNode.App" [eqHead, natT], ← expr [] depth lhs], + let eqHead := rStore "KernelTypes::KExprNode::Const" + [rBoundAddr (roleIdx .eq), rList [rStore "KernelTypes::KLevelNode::Succ" [rStore "KernelTypes::KLevelNode::Zero" []]]] + let eqn := rStore "KernelTypes::KExprNode::App" + [rStore "KernelTypes::KExprNode::App" [rStore "KernelTypes::KExprNode::App" [eqHead, natT], ← expr [] depth lhs], ← expr [] depth rhs] let mut body := eqn for (h, i) in hyps.zipIdx.reverse do - body := rStore "KExprNode.Forall" [← expr [] (2 + i) h, body] - let root := rStore "KExprNode.Forall" [natT, rStore "KExprNode.Forall" [natT, body]] + body := rStore "KernelTypes::KExprNode::Forall" [← expr [] (2 + i) h, body] + let root := rStore "KernelTypes::KExprNode::Forall" [natT, rStore "KernelTypes::KExprNode::Forall" [natT, body]] pure (renderArm root) /-! ## Per-role data -/ @@ -346,7 +346,7 @@ def specType (r : Role) : Except String String := do | .anchor n t => pure (renderArm (← expr (List.range n) 0 t)) | .ops t _ => pure (renderArm (← expr [] 0 t)) | .axiom n (some t) => pure (renderArm (← expr (List.range n) 0 t)) - | .axiom _ none => pure "store(KExprNode.Srt(store(KLevelNode.Zero)))" + | .axiom _ none => pure "(&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero)))))" | .eqns n t _ => pure (renderArm (← expr (List.range n) 0 t)) def equations (r : Role) : List (List (Expr .anon) × Expr .anon × Expr .anon) := @@ -409,7 +409,7 @@ def closeEqnSide (r : Role) (e : Equation .anon) (side : Expr .anon) : Except St let ps := eqnLevels r let mut body ← expr ps e.vars.length side for (t, i) in e.vars.zipIdx.reverse do - body := rStore "KExprNode.Lam" [← expr ps i t, body] + body := rStore "KernelTypes::KExprNode::Lam" [← expr ps i t, body] pure (renderArm body) /-- `Π vars, Π hyps, @Eq.{level} carrier lhs rhs`: an equation's statement, @@ -418,16 +418,16 @@ def closeEqnStatement (r : Role) (e : Equation .anon) : Except String String := let ps := eqnLevels r let n := e.vars.length let depth := n + e.hyps.length - let eqHead := rStore "KExprNode.Const" [rBoundAddr (roleIdx .eq), rList [← level ps e.level]] - let mut body := rStore "KExprNode.App" - [rStore "KExprNode.App" - [rStore "KExprNode.App" [eqHead, ← expr ps depth e.carrier], + let eqHead := rStore "KernelTypes::KExprNode::Const" [rBoundAddr (roleIdx .eq), rList [← level ps e.level]] + let mut body := rStore "KernelTypes::KExprNode::App" + [rStore "KernelTypes::KExprNode::App" + [rStore "KernelTypes::KExprNode::App" [eqHead, ← expr ps depth e.carrier], ← expr ps depth e.lhs], ← expr ps depth e.rhs] for (h, j) in e.hyps.zipIdx.reverse do - body := rStore "KExprNode.Forall" [← expr ps (n + j) h, body] + body := rStore "KernelTypes::KExprNode::Forall" [← expr ps (n + j) h, body] for (t, i) in e.vars.zipIdx.reverse do - body := rStore "KExprNode.Forall" [← expr ps i t, body] + body := rStore "KernelTypes::KExprNode::Forall" [← expr ps i t, body] pure (renderArm body) /-- The family of native rules that fires on a role's constant (1 `Nat` @@ -478,34 +478,20 @@ def primFamilyOp : Role → Nat × Nat def primFamily (r : Role) : Nat := (primFamilyOp r).1 -/-! ## The file -/ +/-! ## The file (`IxVM/IxVM/Modules/KernelRoleSpec.aiur`) -/ -def header : String := "module -public import Ix.Aiur.Meta -public import Ix.IxVM.KernelTypes +/-- The roles directly named by circuit modules (`role_`). -/ +def namedRoles : List Role := + [.nat, .natZero, .natSucc, .bool, .boolFalse, .boolTrue, .eq, .eqRefl, + .listNil, .listCons, .quot, .quotMk, .quotLift, .quotInd, .quotSound, + .string, .stringOfList, .char, .charOfNat, .natAdd, .propext, .choice, + .sorryAx, .decidableIsTrue, .decidableIsFalse, .ofDecideEqTrue, .ofDecideEqFalse, + .natLe, .natDecLe, .int, .intOfNat, .intNegSucc, .bitVecOfNat, .byteArrayEmpty, + .intLe, .intDecLe] -/-! # The role specifications, as circuit terms - -GENERATED by `lake exe ix codegen` from IxC's specifications -(`Ix.Kernel.Role.spec`, `Role.block`, `Role.deps`) by -`Ix/IxVM/RoleSpecGen.lean`; do not edit. `lake exe ix codegen --check` fails -when it is stale. The validators that read it are in -`Ix/IxVM/Kernel/Roles.lean`. -/ - -public section - -namespace IxVM - -set_option maxRecDepth 16384 in -def roleSpec := ⟦ -" - -def footer : String := "⟧ - -end IxVM - -end -" +def arm (k rhs : String) : String := + let sep := if rhs.startsWith "\n" then "" else " " + s!" {k} => \{{sep}{rhs} } ,\n" /-- A `match` on `r` over every role whose value differs from `fallback`, with `fallback` as the final arm. -/ @@ -514,110 +500,129 @@ def byRole (f : Role → Except String String) (fallback : String) : Except Stri for r in Role.all do let rhs ← f r if rhs != fallback then - arms := arms ++ s!" {roleIdx r} => {rhs},\n" - pure s!" match r \{\n{arms} _ => {fallback},\n }" + arms := arms ++ arm (toString (roleIdx r)) rhs + pure s!" match r \{\n{arms}{arm "_" fallback} }" -def aiurFn (sig body : String) : String := s!" {sig} \{\n{body}\n }\n\n" +def formalAiurFn (sig body : String) : String := s!" {sig} \{\n{body}\n }" -def render : Except String String := do +/-- Render `module KernelRoleSpec { ... }` directly in Formal Aiur syntax from +`Ix.Kernel.Role.all` and `Role.spec`. -/ +def renderFormalAiur : Except String String := do checkGroups let firstWf ← firstWellFoundedGroup let firstEquation ← firstEquationGroup let digest ← Ix.SpecDigest.specDigest - let bytes := digest.hash.data.toList.map fun b => s!"0x{hexOfByte b}u8" - let mut out := header - out := out ++ s!" -- specVersion {specVersion}, specification digest {digest}.\n" - out := out ++ aiurFn "fn spec_version() -> G" s!" {specVersion}" - out := out ++ aiurFn "fn spec_digest() -> Addr" s!" store([{", ".intercalate bytes}])" - out := out ++ aiurFn "fn role_count() -> G" s!" {Role.all.length}" - out := out ++ aiurFn "fn group_count() -> G" s!" {groups.length}" - out := out ++ aiurFn "fn first_well_founded_group() -> G" s!" {firstWf}" - out := out ++ aiurFn "fn first_equation_group() -> G" s!" {firstEquation}" - for r in Role.all do - out := out ++ aiurFn s!"fn role_{roleName r}() -> G" s!" {roleIdx r}" - out := out ++ aiurFn "fn role_group(r: G) -> G" (← byRole (fun r => pure (toString (groupOf r))) "0") + let bytes := digest.hash.data.toList.map fun b => s!"UInt8::BYTE_{b.toNat}" + let mut fns : Array String := #[] + fns := fns.push (formalAiurFn "inline fn spec_version() -> Field" s!" {specVersion}") + fns := fns.push (formalAiurFn "inline fn spec_digest() -> Bytes::AddressRef" s!" (&([{", ".intercalate bytes}]))") + fns := fns.push (formalAiurFn "inline fn role_count() -> Field" s!" {Role.all.length}") + fns := fns.push (formalAiurFn "inline fn group_count() -> Field" s!" {groups.length}") + fns := fns.push (formalAiurFn "inline fn first_well_founded_group() -> Field" s!" {firstWf}") + fns := fns.push (formalAiurFn "inline fn first_equation_group() -> Field" s!" {firstEquation}") + for r in namedRoles do + fns := fns.push (formalAiurFn s!"inline fn role_{roleName r}() -> Field" s!" {roleIdx r}") + fns := fns.push (formalAiurFn "fn role_group(r: Field) -> Field" + (← byRole (fun r => pure (toString (groupOf r))) "0")) let mut groupArms := "" let mut needArms := "" for (g, i) in groups.zipIdx do - groupArms := groupArms ++ s!" {i} => {list (g.map (toString ∘ roleIdx))},\n" + groupArms := groupArms ++ arm (toString i) (list (g.map (toString ∘ roleIdx))) let needs := groupNeeds g unless needs.isEmpty do - needArms := needArms ++ s!" {i} => {list (needs.map (toString ∘ roleIdx))},\n" - out := out ++ aiurFn "fn group_roles(g: G) -> List‹G›" - s!" match g \{\n{groupArms} _ => store(ListNode.Nil),\n }" - out := out ++ aiurFn "fn group_needs(g: G) -> List‹G›" - s!" match g \{\n{needArms} _ => store(ListNode.Nil),\n }" - out := out ++ aiurFn "fn role_spec_kind(r: G) -> G" (← byRole (fun r => pure (toString (specKind r))) "0") - out := out ++ aiurFn "fn role_levels(r: G) -> G" (← byRole (fun r => do return toString (← levels r)) "0") - out := out ++ aiurFn "fn role_member_kind(r: G) -> G" + needArms := needArms ++ arm (toString i) (list (needs.map (toString ∘ roleIdx))) + fns := fns.push (formalAiurFn "fn group_roles(g: Field) -> Lists::List" + s!" match g \{\n{groupArms}{arm "_" "(&(Lists::Node::Nil))"} }") + fns := fns.push (formalAiurFn "fn group_needs(g: Field) -> Lists::List" + s!" match g \{\n{needArms}{arm "_" "(&(Lists::Node::Nil))"} }") + fns := fns.push (formalAiurFn "fn role_spec_kind(r: Field) -> Field" + (← byRole (fun r => pure (toString (specKind r))) "0")) + fns := fns.push (formalAiurFn "fn role_levels(r: Field) -> Field" + (← byRole (fun r => do return toString (← levels r)) "0")) + fns := fns.push (formalAiurFn "fn role_member_kind(r: Field) -> Field" (← byRole (fun r => do if specKind r != 0 then return "0" - return toString (← memberKind r)) "0") - out := out ++ aiurFn "fn role_ctor_of(r: G) -> (G, G, G, G)" + return toString (← memberKind r)) "0")) + fns := fns.push (formalAiurFn "fn role_ctor_of(r: Field) -> (Field, Field, Field, Field)" (← byRole (fun r => do if specKind r != 0 then return "(0, 0, 0, 0)" if (← memberKind r) != 1 then return "(0, 0, 0, 0)" let (i, c, p, f) ← ctorOf r - pure s!"({i}, {c}, {p}, {f})") "(0, 0, 0, 0)") - out := out ++ aiurFn "fn role_ctor_count(r: G) -> G" + pure s!"({i}, {c}, {p}, {f})") "(0, 0, 0, 0)")) + fns := fns.push (formalAiurFn "fn role_ctor_count(r: Field) -> Field" (← byRole (fun r => do if specKind r != 0 then return "0" if (← memberKind r) != 0 then return "0" - return toString (← ctorCount r)) "0") - out := out ++ aiurFn "fn role_type(tbl: RoleTable, r: G) -> KExpr" - (← byRole specType "store(KExprNode.Srt(store(KLevelNode.Zero)))") - out := out ++ aiurFn "fn op_equation_count(r: G) -> G" - (← byRole (fun r => pure (toString (equations r).length)) "0") - out := out ++ aiurFn "fn op_evidence_is_proof(r: G) -> G" - (← byRole (fun r => pure (if (equations r).any (!·.1.isEmpty) then "1" else "0")) "0") + return toString (← ctorCount r)) "0")) + let dummy := "(&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero)))))" + fns := fns.push (formalAiurFn "fn role_type(tbl: KernelRoles::RoleTable, r: Field) -> KernelTypes::KExpr" + (← byRole specType dummy)) + fns := fns.push (formalAiurFn "fn op_equation_count(r: Field) -> Field" + (← byRole (fun r => pure (toString (equations r).length)) "0")) + fns := fns.push (formalAiurFn "fn op_evidence_is_proof(r: Field) -> Field" + (← byRole (fun r => pure (if (equations r).any (!·.1.isEmpty) then "1" else "0")) "0")) -- Equation sides and certificates, by role and equation index. let mut lhsArms := "" let mut rhsArms := "" let mut certArms := "" for r in Role.all do for ((hyps, l, rhs), k) in (equations r).zipIdx do - let key := 64 * roleIdx r + k + let key := toString (64 * roleIdx r + k) if hyps.isEmpty then - lhsArms := lhsArms ++ s!" {key} => {← closeEquationSide l},\n" - rhsArms := rhsArms ++ s!" {key} => {← closeEquationSide rhs},\n" + lhsArms := lhsArms ++ arm key (← closeEquationSide l) + rhsArms := rhsArms ++ arm key (← closeEquationSide rhs) else - certArms := certArms ++ s!" {key} => {← closeCertificate hyps l rhs},\n" - let dummy := "store(KExprNode.Srt(store(KLevelNode.Zero)))" - out := out ++ aiurFn "fn op_equation_lhs(tbl: RoleTable, r: G, k: G) -> KExpr" - s!" match 64 * r + k \{\n{lhsArms} _ => {dummy},\n }" - out := out ++ aiurFn "fn op_equation_rhs(tbl: RoleTable, r: G, k: G) -> KExpr" - s!" match 64 * r + k \{\n{rhsArms} _ => {dummy},\n }" - out := out ++ aiurFn "fn op_certificate(tbl: RoleTable, r: G, k: G) -> KExpr" - s!" match 64 * r + k \{\n{certArms} _ => {dummy},\n }" + certArms := certArms ++ arm key (← closeCertificate hyps l rhs) + fns := fns.push (formalAiurFn "fn op_equation_lhs(tbl: KernelRoles::RoleTable, r: Field, k: Field) -> KernelTypes::KExpr" + s!" match 64 * r + k \{\n{lhsArms}{arm "_" dummy} }") + fns := fns.push (formalAiurFn "fn op_equation_rhs(tbl: KernelRoles::RoleTable, r: Field, k: Field) -> KernelTypes::KExpr" + s!" match 64 * r + k \{\n{rhsArms}{arm "_" dummy} }") + fns := fns.push (formalAiurFn "fn op_certificate(tbl: KernelRoles::RoleTable, r: Field, k: Field) -> KernelTypes::KExpr" + s!" match 64 * r + k \{\n{certArms}{arm "_" dummy} }") -- Definitions specified by their equations, by role and equation index. - out := out ++ aiurFn "fn eqns_equation_count(r: G) -> G" - (← byRole (fun r => pure (toString (eqnsEquations r).length)) "0") + fns := fns.push (formalAiurFn "fn eqns_equation_count(r: Field) -> Field" + (← byRole (fun r => pure (toString (eqnsEquations r).length)) "0")) let mut condArms := "" let mut eLhsArms := "" let mut eRhsArms := "" let mut stmtArms := "" for r in Role.all do for (e, k) in (eqnsEquations r).zipIdx do - let key := 64 * roleIdx r + k - stmtArms := stmtArms ++ s!" {key} => {← closeEqnStatement r e},\n" + let key := toString (64 * roleIdx r + k) + stmtArms := stmtArms ++ arm key (← closeEqnStatement r e) if e.hyps.isEmpty then - eLhsArms := eLhsArms ++ s!" {key} => {← closeEqnSide r e e.lhs},\n" - eRhsArms := eRhsArms ++ s!" {key} => {← closeEqnSide r e e.rhs},\n" + eLhsArms := eLhsArms ++ arm key (← closeEqnSide r e e.lhs) + eRhsArms := eRhsArms ++ arm key (← closeEqnSide r e e.rhs) else - condArms := condArms ++ s!" {key} => 1,\n" - out := out ++ aiurFn "fn eqns_conditional(r: G, k: G) -> G" - s!" match 64 * r + k \{\n{condArms} _ => 0,\n }" - out := out ++ aiurFn "fn eqns_lhs(tbl: RoleTable, r: G, k: G) -> KExpr" - s!" match 64 * r + k \{\n{eLhsArms} _ => {dummy},\n }" - out := out ++ aiurFn "fn eqns_rhs(tbl: RoleTable, r: G, k: G) -> KExpr" - s!" match 64 * r + k \{\n{eRhsArms} _ => {dummy},\n }" - out := out ++ aiurFn "fn eqns_statement(tbl: RoleTable, r: G, k: G) -> KExpr" - s!" match 64 * r + k \{\n{stmtArms} _ => {dummy},\n }" - out := out ++ aiurFn "fn role_prim_family(r: G) -> (G, G)" + condArms := condArms ++ arm key "1" + fns := fns.push (formalAiurFn "fn eqns_conditional(r: Field, k: Field) -> Field" + s!" match 64 * r + k \{\n{condArms}{arm "_" "0"} }") + fns := fns.push (formalAiurFn "fn eqns_lhs(tbl: KernelRoles::RoleTable, r: Field, k: Field) -> KernelTypes::KExpr" + s!" match 64 * r + k \{\n{eLhsArms}{arm "_" dummy} }") + fns := fns.push (formalAiurFn "fn eqns_rhs(tbl: KernelRoles::RoleTable, r: Field, k: Field) -> KernelTypes::KExpr" + s!" match 64 * r + k \{\n{eRhsArms}{arm "_" dummy} }") + fns := fns.push (formalAiurFn "fn eqns_statement(tbl: KernelRoles::RoleTable, r: Field, k: Field) -> KernelTypes::KExpr" + s!" match 64 * r + k \{\n{stmtArms}{arm "_" dummy} }") + fns := fns.push (formalAiurFn "fn role_prim_family(r: Field) -> (Field, Field)" (← byRole (fun r => do let (fam, op) := primFamilyOp r - pure s!"({fam}, {op})") "(0, 0)") - pure (out ++ footer) + pure s!"({fam}, {op})") "(0, 0)")) + let header := "// Generated by tools/ixvm; edit the reviewed adapter or its source.\nmodule KernelRoleSpec {\n" + pure (header ++ "\n\n".intercalate fns.toList ++ "\n}\n") + +/-- An independent wire-shape fixture for Rust's candidate checks. -/ +def renderSpecShapeTsv : String := Id.run do + let indices (roles : List Role) := + ",".intercalate (roles.map fun r => toString (roleIdx r)) + let kind : Option Bool → String + | some true => "defeq" + | some false => "proof" + | none => "either" + let mut out := s!"# Role.block/deps and Spec.evidenceAllowed, version{specVersion}\n" + for r in Role.all do + let kinds := ",".intercalate ((r.spec (md := .anon)).evidenceAllowed.map kind) + out := out ++ s!"{roleIdx r}\t{indices r.block}\t{indices r.deps}\t{kinds}\n" + return out end IxVM.RoleSpecGen diff --git a/Ix/IxVM/Sha256.lean b/Ix/IxVM/Sha256.lean deleted file mode 100644 index d6669c3d8..000000000 --- a/Ix/IxVM/Sha256.lean +++ /dev/null @@ -1,819 +0,0 @@ -module -public import Ix.Aiur.Meta - -public section - -namespace IxVM - -def sha256 := ⟦ - /- # Test entrypoints -/ - - pub fn sha256_test() -> [[U8; 4]; 8] { - let (idx, len) = io_get_info(0, [0]); - let byte_stream = read_checked_byte_stream(0, idx, len); - sha256(byte_stream) - } - - /- # Benchmark entrypoints -/ - - pub fn sha256_bench(num_hashes: G) -> G { - let num_hashes_pred = num_hashes - 1; - let key = [num_hashes_pred]; - let (idx, len) = io_get_info(0, key); - let byte_stream = read_checked_byte_stream(0, idx, len); - sha256(byte_stream); - match num_hashes_pred { - 0 => 0, - _ => sha256_bench(num_hashes_pred), - } - } - - /- # Implementation -/ - - fn sha256(stream: ByteStream) -> [[U8; 4]; 8] { - let state = [ - [0x6au8, 0x09u8, 0xe6u8, 0x67u8], - [0xbbu8, 0x67u8, 0xaeu8, 0x85u8], - [0x3cu8, 0x6eu8, 0xf3u8, 0x72u8], - [0xa5u8, 0x4fu8, 0xf5u8, 0x3au8], - [0x51u8, 0x0eu8, 0x52u8, 0x7fu8], - [0x9bu8, 0x05u8, 0x68u8, 0x8cu8], - [0x1fu8, 0x83u8, 0xd9u8, 0xabu8], - [0x5bu8, 0xe0u8, 0xcdu8, 0x19u8] - ]; - sha256_aux(stream, [0u8; 8], state) - } - - fn sha256_aux(stream: ByteStream, len_be: U64, state: [[U8; 4]; 8]) -> [[U8; 4]; 8] { - let W = [[0u8; 4]; 16]; - match load(stream) { - ListNode.Nil => - let W = set(W, 0, [0x80u8, 0u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b0, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 8u8]); - let W = set(W, 0, [b0, 0x80u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b1, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 16u8]); - let W = set(W, 0, [b0, b1, 0x80u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b2, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 24u8]); - let W = set(W, 0, [b0, b1, b2, 0x80u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b3, tail) => - let W = set(W, 0, [b0, b1, b2, b3]); - match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 32u8]); - let W = set(W, 1, [0x80u8, 0u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b4, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 40u8]); - let W = set(W, 1, [b4, 0x80u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b5, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 48u8]); - let W = set(W, 1, [b4, b5, 0x80u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b6, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 56u8]); - let W = set(W, 1, [b4, b5, b6, 0x80u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b7, tail) => - let W = set(W, 1, [b4, b5, b6, b7]); - match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 64u8]); - let W = set(W, 2, [0x80u8, 0u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b8, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 72u8]); - let W = set(W, 2, [b8, 0x80u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b9, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 80u8]); - let W = set(W, 2, [b8, b9, 0x80u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b10, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 88u8]); - let W = set(W, 2, [b8, b9, b10, 0x80u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b11, tail) => - let W = set(W, 2, [b8, b9, b10, b11]); - match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 96u8]); - let W = set(W, 3, [0x80u8, 0u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b12, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 104u8]); - let W = set(W, 3, [b12, 0x80u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b13, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 112u8]); - let W = set(W, 3, [b12, b13, 0x80u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b14, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 120u8]); - let W = set(W, 3, [b12, b13, b14, 0x80u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b15, tail) => - let W = set(W, 3, [b12, b13, b14, b15]); - match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 128u8]); - let W = set(W, 4, [0x80u8, 0u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b16, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 136u8]); - let W = set(W, 4, [b16, 0x80u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b17, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 144u8]); - let W = set(W, 4, [b16, b17, 0x80u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b18, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 152u8]); - let W = set(W, 4, [b16, b17, b18, 0x80u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b19, tail) => - let W = set(W, 4, [b16, b17, b18, b19]); - match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 160u8]); - let W = set(W, 5, [0x80u8, 0u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b20, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 168u8]); - let W = set(W, 5, [b20, 0x80u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b21, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 176u8]); - let W = set(W, 5, [b20, b21, 0x80u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b22, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 184u8]); - let W = set(W, 5, [b20, b21, b22, 0x80u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b23, tail) => - let W = set(W, 5, [b20, b21, b22, b23]); - match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 192u8]); - let W = set(W, 6, [0x80u8, 0u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b24, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 200u8]); - let W = set(W, 6, [b24, 0x80u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b25, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 208u8]); - let W = set(W, 6, [b24, b25, 0x80u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b26, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 216u8]); - let W = set(W, 6, [b24, b25, b26, 0x80u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b27, tail) => - let W = set(W, 6, [b24, b25, b26, b27]); - match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 224u8]); - let W = set(W, 7, [0x80u8, 0u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b28, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 232u8]); - let W = set(W, 7, [b28, 0x80u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b29, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 240u8]); - let W = set(W, 7, [b28, b29, 0x80u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b30, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 248u8]); - let W = set(W, 7, [b28, b29, b30, 0x80u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b31, tail) => - let W = set(W, 7, [b28, b29, b30, b31]); - match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 0u8]); - let W = set(W, 8, [0x80u8, 0u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b32, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 8u8]); - let W = set(W, 8, [b32, 0x80u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b33, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 16u8]); - let W = set(W, 8, [b32, b33, 0x80u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b34, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 24u8]); - let W = set(W, 8, [b32, b33, b34, 0x80u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b35, tail) => - let W = set(W, 8, [b32, b33, b34, b35]); - match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 32u8]); - let W = set(W, 9, [0x80u8, 0u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b36, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 40u8]); - let W = set(W, 9, [b36, 0x80u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b37, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 48u8]); - let W = set(W, 9, [b36, b37, 0x80u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b38, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 56u8]); - let W = set(W, 9, [b36, b37, b38, 0x80u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b39, tail) => - let W = set(W, 9, [b36, b37, b38, b39]); - match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 64u8]); - let W = set(W, 10, [0x80u8, 0u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b40, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 72u8]); - let W = set(W, 10, [b40, 0x80u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b41, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 80u8]); - let W = set(W, 10, [b40, b41, 0x80u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b42, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 88u8]); - let W = set(W, 10, [b40, b41, b42, 0x80u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b43, tail) => - let W = set(W, 10, [b40, b41, b42, b43]); - match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 96u8]); - let W = set(W, 11, [0x80u8, 0u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b44, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 104u8]); - let W = set(W, 11, [b44, 0x80u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b45, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 112u8]); - let W = set(W, 11, [b44, b45, 0x80u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b46, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 120u8]); - let W = set(W, 11, [b44, b45, b46, 0x80u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b47, tail) => - let W = set(W, 11, [b44, b45, b46, b47]); - match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 128u8]); - let W = set(W, 12, [0x80u8, 0u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b48, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 136u8]); - let W = set(W, 12, [b48, 0x80u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b49, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 144u8]); - let W = set(W, 12, [b48, b49, 0x80u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b50, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 152u8]); - let W = set(W, 12, [b48, b49, b50, 0x80u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b51, tail) => - let W = set(W, 12, [b48, b49, b50, b51]); - match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 160u8]); - let W = set(W, 13, [0x80u8, 0u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b52, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 168u8]); - let W = set(W, 13, [b52, 0x80u8, 0u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b53, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 176u8]); - let W = set(W, 13, [b52, b53, 0x80u8, 0u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b54, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 184u8]); - let W = set(W, 13, [b52, b53, b54, 0x80u8]); - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state), - ListNode.Cons(b55, tail) => - let W = set(W, 13, [b52, b53, b54, b55]); - match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 192u8]); - let W = set(W, 14, [0x80u8, 0u8, 0u8, 0u8]); - let state = fill_W_and_run_rounds(W, state); - fill_W_with_length_and_run_rounds(len_be, state), - ListNode.Cons(b56, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 200u8]); - let W = set(W, 14, [b56, 0x80u8, 0u8, 0u8]); - let state = fill_W_and_run_rounds(W, state); - fill_W_with_length_and_run_rounds(len_be, state), - ListNode.Cons(b57, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 208u8]); - let W = set(W, 14, [b56, b57, 0x80u8, 0u8]); - let state = fill_W_and_run_rounds(W, state); - fill_W_with_length_and_run_rounds(len_be, state), - ListNode.Cons(b58, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 216u8]); - let W = set(W, 14, [b56, b57, b58, 0x80u8]); - let state = fill_W_and_run_rounds(W, state); - fill_W_with_length_and_run_rounds(len_be, state), - ListNode.Cons(b59, tail) => - let W = set(W, 14, [b56, b57, b58, b59]); - match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 224u8]); - let W = set(W, 15, [0x80u8, 0u8, 0u8, 0u8]); - let state = fill_W_and_run_rounds(W, state); - fill_W_with_length_and_run_rounds(len_be, state), - ListNode.Cons(b60, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 232u8]); - let W = set(W, 15, [b60, 0x80u8, 0u8, 0u8]); - let state = fill_W_and_run_rounds(W, state); - fill_W_with_length_and_run_rounds(len_be, state), - ListNode.Cons(b61, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 240u8]); - let W = set(W, 15, [b60, b61, 0x80u8, 0u8]); - let state = fill_W_and_run_rounds(W, state); - fill_W_with_length_and_run_rounds(len_be, state), - ListNode.Cons(b62, tail) => match load(tail) { - ListNode.Nil => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 248u8]); - let W = set(W, 15, [b60, b61, b62, 0x80u8]); - let state = fill_W_and_run_rounds(W, state); - fill_W_with_length_and_run_rounds(len_be, state), - ListNode.Cons(b63, tail) => - let len_be = relaxed_u64_be_add_2_bytes(len_be, [2u8, 0u8]); - let W = set(W, 15, [b60, b61, b62, b63]); - let state = fill_W_and_run_rounds(W, state); - sha256_aux(tail, len_be, state), - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - }, - } - } - - fn fill_W_with_length_and_run_rounds(len_be: U64, state: [[U8; 4]; 8]) -> [[U8; 4]; 8] { - let W = [[0u8; 4]; 16]; - let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]); - let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]); - fill_W_and_run_rounds(W, state) - } - - fn fill_W_and_run_rounds(W: [[U8; 4]; 16], state: [[U8; 4]; 8]) -> [[U8; 4]; 8] { - let K = [ - [0x42u8, 0x8au8, 0x2fu8, 0x98u8], [0x71u8, 0x37u8, 0x44u8, 0x91u8], [0xb5u8, 0xc0u8, 0xfbu8, 0xcfu8], [0xe9u8, 0xb5u8, 0xdbu8, 0xa5u8], - [0x39u8, 0x56u8, 0xc2u8, 0x5bu8], [0x59u8, 0xf1u8, 0x11u8, 0xf1u8], [0x92u8, 0x3fu8, 0x82u8, 0xa4u8], [0xabu8, 0x1cu8, 0x5eu8, 0xd5u8], - [0xd8u8, 0x07u8, 0xaau8, 0x98u8], [0x12u8, 0x83u8, 0x5bu8, 0x01u8], [0x24u8, 0x31u8, 0x85u8, 0xbeu8], [0x55u8, 0x0cu8, 0x7du8, 0xc3u8], - [0x72u8, 0xbeu8, 0x5du8, 0x74u8], [0x80u8, 0xdeu8, 0xb1u8, 0xfeu8], [0x9bu8, 0xdcu8, 0x06u8, 0xa7u8], [0xc1u8, 0x9bu8, 0xf1u8, 0x74u8], - [0xe4u8, 0x9bu8, 0x69u8, 0xc1u8], [0xefu8, 0xbeu8, 0x47u8, 0x86u8], [0x0fu8, 0xc1u8, 0x9du8, 0xc6u8], [0x24u8, 0x0cu8, 0xa1u8, 0xccu8], - [0x2du8, 0xe9u8, 0x2cu8, 0x6fu8], [0x4au8, 0x74u8, 0x84u8, 0xaau8], [0x5cu8, 0xb0u8, 0xa9u8, 0xdcu8], [0x76u8, 0xf9u8, 0x88u8, 0xdau8], - [0x98u8, 0x3eu8, 0x51u8, 0x52u8], [0xa8u8, 0x31u8, 0xc6u8, 0x6du8], [0xb0u8, 0x03u8, 0x27u8, 0xc8u8], [0xbfu8, 0x59u8, 0x7fu8, 0xc7u8], - [0xc6u8, 0xe0u8, 0x0bu8, 0xf3u8], [0xd5u8, 0xa7u8, 0x91u8, 0x47u8], [0x06u8, 0xcau8, 0x63u8, 0x51u8], [0x14u8, 0x29u8, 0x29u8, 0x67u8], - [0x27u8, 0xb7u8, 0x0au8, 0x85u8], [0x2eu8, 0x1bu8, 0x21u8, 0x38u8], [0x4du8, 0x2cu8, 0x6du8, 0xfcu8], [0x53u8, 0x38u8, 0x0du8, 0x13u8], - [0x65u8, 0x0au8, 0x73u8, 0x54u8], [0x76u8, 0x6au8, 0x0au8, 0xbbu8], [0x81u8, 0xc2u8, 0xc9u8, 0x2eu8], [0x92u8, 0x72u8, 0x2cu8, 0x85u8], - [0xa2u8, 0xbfu8, 0xe8u8, 0xa1u8], [0xa8u8, 0x1au8, 0x66u8, 0x4bu8], [0xc2u8, 0x4bu8, 0x8bu8, 0x70u8], [0xc7u8, 0x6cu8, 0x51u8, 0xa3u8], - [0xd1u8, 0x92u8, 0xe8u8, 0x19u8], [0xd6u8, 0x99u8, 0x06u8, 0x24u8], [0xf4u8, 0x0eu8, 0x35u8, 0x85u8], [0x10u8, 0x6au8, 0xa0u8, 0x70u8], - [0x19u8, 0xa4u8, 0xc1u8, 0x16u8], [0x1eu8, 0x37u8, 0x6cu8, 0x08u8], [0x27u8, 0x48u8, 0x77u8, 0x4cu8], [0x34u8, 0xb0u8, 0xbcu8, 0xb5u8], - [0x39u8, 0x1cu8, 0x0cu8, 0xb3u8], [0x4eu8, 0xd8u8, 0xaau8, 0x4au8], [0x5bu8, 0x9cu8, 0xcau8, 0x4fu8], [0x68u8, 0x2eu8, 0x6fu8, 0xf3u8], - [0x74u8, 0x8fu8, 0x82u8, 0xeeu8], [0x78u8, 0xa5u8, 0x63u8, 0x6fu8], [0x84u8, 0xc8u8, 0x78u8, 0x14u8], [0x8cu8, 0xc7u8, 0x02u8, 0x08u8], - [0x90u8, 0xbeu8, 0xffu8, 0xfau8], [0xa4u8, 0x50u8, 0x6cu8, 0xebu8], [0xbeu8, 0xf9u8, 0xa3u8, 0xf7u8], [0xc6u8, 0x71u8, 0x78u8, 0xf2u8] - ]; - - let W_16 = define_W_i(W[14], W[9], W[1], W[0]); - let W_17 = define_W_i(W[15], W[10], W[2], W[1]); - let W_18 = define_W_i(W_16, W[11], W[3], W[2]); - let W_19 = define_W_i(W_17, W[12], W[4], W[3]); - let W_20 = define_W_i(W_18, W[13], W[5], W[4]); - let W_21 = define_W_i(W_19, W[14], W[6], W[5]); - let W_22 = define_W_i(W_20, W[15], W[7], W[6]); - let W_23 = define_W_i(W_21, W_16, W[8], W[7]); - let W_24 = define_W_i(W_22, W_17, W[9], W[8]); - let W_25 = define_W_i(W_23, W_18, W[10], W[9]); - let W_26 = define_W_i(W_24, W_19, W[11], W[10]); - let W_27 = define_W_i(W_25, W_20, W[12], W[11]); - let W_28 = define_W_i(W_26, W_21, W[13], W[12]); - let W_29 = define_W_i(W_27, W_22, W[14], W[13]); - let W_30 = define_W_i(W_28, W_23, W[15], W[14]); - let W_31 = define_W_i(W_29, W_24, W_16, W[15]); - let W_32 = define_W_i(W_30, W_25, W_17, W_16); - let W_33 = define_W_i(W_31, W_26, W_18, W_17); - let W_34 = define_W_i(W_32, W_27, W_19, W_18); - let W_35 = define_W_i(W_33, W_28, W_20, W_19); - let W_36 = define_W_i(W_34, W_29, W_21, W_20); - let W_37 = define_W_i(W_35, W_30, W_22, W_21); - let W_38 = define_W_i(W_36, W_31, W_23, W_22); - let W_39 = define_W_i(W_37, W_32, W_24, W_23); - let W_40 = define_W_i(W_38, W_33, W_25, W_24); - let W_41 = define_W_i(W_39, W_34, W_26, W_25); - let W_42 = define_W_i(W_40, W_35, W_27, W_26); - let W_43 = define_W_i(W_41, W_36, W_28, W_27); - let W_44 = define_W_i(W_42, W_37, W_29, W_28); - let W_45 = define_W_i(W_43, W_38, W_30, W_29); - let W_46 = define_W_i(W_44, W_39, W_31, W_30); - let W_47 = define_W_i(W_45, W_40, W_32, W_31); - let W_48 = define_W_i(W_46, W_41, W_33, W_32); - let W_49 = define_W_i(W_47, W_42, W_34, W_33); - let W_50 = define_W_i(W_48, W_43, W_35, W_34); - let W_51 = define_W_i(W_49, W_44, W_36, W_35); - let W_52 = define_W_i(W_50, W_45, W_37, W_36); - let W_53 = define_W_i(W_51, W_46, W_38, W_37); - let W_54 = define_W_i(W_52, W_47, W_39, W_38); - let W_55 = define_W_i(W_53, W_48, W_40, W_39); - let W_56 = define_W_i(W_54, W_49, W_41, W_40); - let W_57 = define_W_i(W_55, W_50, W_42, W_41); - let W_58 = define_W_i(W_56, W_51, W_43, W_42); - let W_59 = define_W_i(W_57, W_52, W_44, W_43); - let W_60 = define_W_i(W_58, W_53, W_45, W_44); - let W_61 = define_W_i(W_59, W_54, W_46, W_45); - let W_62 = define_W_i(W_60, W_55, W_47, W_46); - let W_63 = define_W_i(W_61, W_56, W_48, W_47); - - let W = [ - W[0], W[1], W[2], W[3], W[4], W[5], W[6], W[7], - W[8], W[9], W[10], W[11], W[12], W[13], W[14], W[15], - W_16, W_17, W_18, W_19, W_20, W_21, W_22, W_23, - W_24, W_25, W_26, W_27, W_28, W_29, W_30, W_31, - W_32, W_33, W_34, W_35, W_36, W_37, W_38, W_39, - W_40, W_41, W_42, W_43, W_44, W_45, W_46, W_47, - W_48, W_49, W_50, W_51, W_52, W_53, W_54, W_55, - W_56, W_57, W_58, W_59, W_60, W_61, W_62, W_63 - ]; - - let state_new = fold(0 .. 64, state, |acc, @i| - let e_0_bits = u8_bit_decomposition(acc[4][3]); - let e_1_bits = u8_bit_decomposition(acc[4][2]); - let e_2_bits = u8_bit_decomposition(acc[4][1]); - let e_3_bits = u8_bit_decomposition(acc[4][0]); - - -- Each rotated/shifted byte is the weighted sum of 8 bits. Written - -- inline: it is pure arithmetic, so it costs no aux column or lookup. - let e_rotr6 = [ - u8_from_field_unsafe(e_3_bits[6] + 2 * e_3_bits[7] + 4 * e_0_bits[0] + 8 * e_0_bits[1] + 16 * e_0_bits[2] + 32 * e_0_bits[3] + 64 * e_0_bits[4] + 128 * e_0_bits[5]), - u8_from_field_unsafe(e_2_bits[6] + 2 * e_2_bits[7] + 4 * e_3_bits[0] + 8 * e_3_bits[1] + 16 * e_3_bits[2] + 32 * e_3_bits[3] + 64 * e_3_bits[4] + 128 * e_3_bits[5]), - u8_from_field_unsafe(e_1_bits[6] + 2 * e_1_bits[7] + 4 * e_2_bits[0] + 8 * e_2_bits[1] + 16 * e_2_bits[2] + 32 * e_2_bits[3] + 64 * e_2_bits[4] + 128 * e_2_bits[5]), - u8_from_field_unsafe(e_0_bits[6] + 2 * e_0_bits[7] + 4 * e_1_bits[0] + 8 * e_1_bits[1] + 16 * e_1_bits[2] + 32 * e_1_bits[3] + 64 * e_1_bits[4] + 128 * e_1_bits[5]) - ]; - - let e_rotr11 = [ - u8_from_field_unsafe(e_0_bits[3] + 2 * e_0_bits[4] + 4 * e_0_bits[5] + 8 * e_0_bits[6] + 16 * e_0_bits[7] + 32 * e_1_bits[0] + 64 * e_1_bits[1] + 128 * e_1_bits[2]), - u8_from_field_unsafe(e_3_bits[3] + 2 * e_3_bits[4] + 4 * e_3_bits[5] + 8 * e_3_bits[6] + 16 * e_3_bits[7] + 32 * e_0_bits[0] + 64 * e_0_bits[1] + 128 * e_0_bits[2]), - u8_from_field_unsafe(e_2_bits[3] + 2 * e_2_bits[4] + 4 * e_2_bits[5] + 8 * e_2_bits[6] + 16 * e_2_bits[7] + 32 * e_3_bits[0] + 64 * e_3_bits[1] + 128 * e_3_bits[2]), - u8_from_field_unsafe(e_1_bits[3] + 2 * e_1_bits[4] + 4 * e_1_bits[5] + 8 * e_1_bits[6] + 16 * e_1_bits[7] + 32 * e_2_bits[0] + 64 * e_2_bits[1] + 128 * e_2_bits[2]) - ]; - - let e_rotr25 = [ - u8_from_field_unsafe(e_2_bits[1] + 2 * e_2_bits[2] + 4 * e_2_bits[3] + 8 * e_2_bits[4] + 16 * e_2_bits[5] + 32 * e_2_bits[6] + 64 * e_2_bits[7] + 128 * e_3_bits[0]), - u8_from_field_unsafe(e_1_bits[1] + 2 * e_1_bits[2] + 4 * e_1_bits[3] + 8 * e_1_bits[4] + 16 * e_1_bits[5] + 32 * e_1_bits[6] + 64 * e_1_bits[7] + 128 * e_2_bits[0]), - u8_from_field_unsafe(e_0_bits[1] + 2 * e_0_bits[2] + 4 * e_0_bits[3] + 8 * e_0_bits[4] + 16 * e_0_bits[5] + 32 * e_0_bits[6] + 64 * e_0_bits[7] + 128 * e_1_bits[0]), - u8_from_field_unsafe(e_3_bits[1] + 2 * e_3_bits[2] + 4 * e_3_bits[3] + 8 * e_3_bits[4] + 16 * e_3_bits[5] + 32 * e_3_bits[6] + 64 * e_3_bits[7] + 128 * e_0_bits[0]) - ]; - - let e_not = [u8_from_field_unsafe(255 - to_field(acc[4][0])), u8_from_field_unsafe(255 - to_field(acc[4][1])), u8_from_field_unsafe(255 - to_field(acc[4][2])), u8_from_field_unsafe(255 - to_field(acc[4][3]))]; - - let s1 = u32_xor(e_rotr6, u32_xor(e_rotr11, e_rotr25)); - let ch = u32_xor(u32_and(acc[4], acc[5]), u32_and(e_not, acc[6])); - let temp1 = u32_be_add(acc[7], u32_be_add(s1, u32_be_add(ch, u32_be_add(K[@i], W[@i])))); - - let a_0_bits = u8_bit_decomposition(acc[0][3]); - let a_1_bits = u8_bit_decomposition(acc[0][2]); - let a_2_bits = u8_bit_decomposition(acc[0][1]); - let a_3_bits = u8_bit_decomposition(acc[0][0]); - - let a_rotr2 = [ - u8_from_field_unsafe(a_3_bits[2] + 2 * a_3_bits[3] + 4 * a_3_bits[4] + 8 * a_3_bits[5] + 16 * a_3_bits[6] + 32 * a_3_bits[7] + 64 * a_0_bits[0] + 128 * a_0_bits[1]), - u8_from_field_unsafe(a_2_bits[2] + 2 * a_2_bits[3] + 4 * a_2_bits[4] + 8 * a_2_bits[5] + 16 * a_2_bits[6] + 32 * a_2_bits[7] + 64 * a_3_bits[0] + 128 * a_3_bits[1]), - u8_from_field_unsafe(a_1_bits[2] + 2 * a_1_bits[3] + 4 * a_1_bits[4] + 8 * a_1_bits[5] + 16 * a_1_bits[6] + 32 * a_1_bits[7] + 64 * a_2_bits[0] + 128 * a_2_bits[1]), - u8_from_field_unsafe(a_0_bits[2] + 2 * a_0_bits[3] + 4 * a_0_bits[4] + 8 * a_0_bits[5] + 16 * a_0_bits[6] + 32 * a_0_bits[7] + 64 * a_1_bits[0] + 128 * a_1_bits[1]) - ]; - - let a_rotr13 = [ - u8_from_field_unsafe(a_0_bits[5] + 2 * a_0_bits[6] + 4 * a_0_bits[7] + 8 * a_1_bits[0] + 16 * a_1_bits[1] + 32 * a_1_bits[2] + 64 * a_1_bits[3] + 128 * a_1_bits[4]), - u8_from_field_unsafe(a_3_bits[5] + 2 * a_3_bits[6] + 4 * a_3_bits[7] + 8 * a_0_bits[0] + 16 * a_0_bits[1] + 32 * a_0_bits[2] + 64 * a_0_bits[3] + 128 * a_0_bits[4]), - u8_from_field_unsafe(a_2_bits[5] + 2 * a_2_bits[6] + 4 * a_2_bits[7] + 8 * a_3_bits[0] + 16 * a_3_bits[1] + 32 * a_3_bits[2] + 64 * a_3_bits[3] + 128 * a_3_bits[4]), - u8_from_field_unsafe(a_1_bits[5] + 2 * a_1_bits[6] + 4 * a_1_bits[7] + 8 * a_2_bits[0] + 16 * a_2_bits[1] + 32 * a_2_bits[2] + 64 * a_2_bits[3] + 128 * a_2_bits[4]) - ]; - - let a_rotr22 = [ - u8_from_field_unsafe(a_1_bits[6] + 2 * a_1_bits[7] + 4 * a_2_bits[0] + 8 * a_2_bits[1] + 16 * a_2_bits[2] + 32 * a_2_bits[3] + 64 * a_2_bits[4] + 128 * a_2_bits[5]), - u8_from_field_unsafe(a_0_bits[6] + 2 * a_0_bits[7] + 4 * a_1_bits[0] + 8 * a_1_bits[1] + 16 * a_1_bits[2] + 32 * a_1_bits[3] + 64 * a_1_bits[4] + 128 * a_1_bits[5]), - u8_from_field_unsafe(a_3_bits[6] + 2 * a_3_bits[7] + 4 * a_0_bits[0] + 8 * a_0_bits[1] + 16 * a_0_bits[2] + 32 * a_0_bits[3] + 64 * a_0_bits[4] + 128 * a_0_bits[5]), - u8_from_field_unsafe(a_2_bits[6] + 2 * a_2_bits[7] + 4 * a_3_bits[0] + 8 * a_3_bits[1] + 16 * a_3_bits[2] + 32 * a_3_bits[3] + 64 * a_3_bits[4] + 128 * a_3_bits[5]) - ]; - - let s0 = u32_xor(a_rotr2, u32_xor(a_rotr13, a_rotr22)); - let maj = u32_xor(u32_and(acc[0], acc[1]), u32_xor(u32_and(acc[0], acc[2]), u32_and(acc[1], acc[2]))); - let temp2 = u32_be_add(s0, maj); - - [u32_be_add(temp1, temp2), acc[0], acc[1], acc[2], u32_be_add(acc[3], temp1), acc[4], acc[5], acc[6]] - ); - - [ - u32_be_add(state[0], state_new[0]), - u32_be_add(state[1], state_new[1]), - u32_be_add(state[2], state_new[2]), - u32_be_add(state[3], state_new[3]), - u32_be_add(state[4], state_new[4]), - u32_be_add(state[5], state_new[5]), - u32_be_add(state[6], state_new[6]), - u32_be_add(state[7], state_new[7]) - ] - } - - fn define_W_i(«W_i-2»: [U8; 4], «W_i-7»: [U8; 4], «W_i-15»: [U8; 4], «W_i-16»: [U8; 4]) -> [U8; 4] { - let [«W_i-15_b3», «W_i-15_b2», «W_i-15_b1», «W_i-15_b0»] = «W_i-15»; - let [«W_i-15_b0_0», «W_i-15_b0_1», «W_i-15_b0_2», «W_i-15_b0_3», «W_i-15_b0_4», «W_i-15_b0_5», «W_i-15_b0_6», «W_i-15_b0_7»] = u8_bit_decomposition(«W_i-15_b0»); - let [«W_i-15_b1_0», «W_i-15_b1_1», «W_i-15_b1_2», «W_i-15_b1_3», «W_i-15_b1_4», «W_i-15_b1_5», «W_i-15_b1_6», «W_i-15_b1_7»] = u8_bit_decomposition(«W_i-15_b1»); - let [«W_i-15_b2_0», «W_i-15_b2_1», «W_i-15_b2_2», «W_i-15_b2_3», «W_i-15_b2_4», «W_i-15_b2_5», «W_i-15_b2_6», «W_i-15_b2_7»] = u8_bit_decomposition(«W_i-15_b2»); - let [«W_i-15_b3_0», «W_i-15_b3_1», «W_i-15_b3_2», «W_i-15_b3_3», «W_i-15_b3_4», «W_i-15_b3_5», «W_i-15_b3_6», «W_i-15_b3_7»] = u8_bit_decomposition(«W_i-15_b3»); - - let «W_i-15_rotr7» = [ - u8_from_field_unsafe(«W_i-15_b3_7» + 2 * «W_i-15_b0_0» + 4 * «W_i-15_b0_1» + 8 * «W_i-15_b0_2» + 16 * «W_i-15_b0_3» + 32 * «W_i-15_b0_4» + 64 * «W_i-15_b0_5» + 128 * «W_i-15_b0_6»), - u8_from_field_unsafe(«W_i-15_b2_7» + 2 * «W_i-15_b3_0» + 4 * «W_i-15_b3_1» + 8 * «W_i-15_b3_2» + 16 * «W_i-15_b3_3» + 32 * «W_i-15_b3_4» + 64 * «W_i-15_b3_5» + 128 * «W_i-15_b3_6»), - u8_from_field_unsafe(«W_i-15_b1_7» + 2 * «W_i-15_b2_0» + 4 * «W_i-15_b2_1» + 8 * «W_i-15_b2_2» + 16 * «W_i-15_b2_3» + 32 * «W_i-15_b2_4» + 64 * «W_i-15_b2_5» + 128 * «W_i-15_b2_6»), - u8_from_field_unsafe(«W_i-15_b0_7» + 2 * «W_i-15_b1_0» + 4 * «W_i-15_b1_1» + 8 * «W_i-15_b1_2» + 16 * «W_i-15_b1_3» + 32 * «W_i-15_b1_4» + 64 * «W_i-15_b1_5» + 128 * «W_i-15_b1_6») - ]; - - let «W_i-15_rotr18» = [ - u8_from_field_unsafe(«W_i-15_b1_2» + 2 * «W_i-15_b1_3» + 4 * «W_i-15_b1_4» + 8 * «W_i-15_b1_5» + 16 * «W_i-15_b1_6» + 32 * «W_i-15_b1_7» + 64 * «W_i-15_b2_0» + 128 * «W_i-15_b2_1»), - u8_from_field_unsafe(«W_i-15_b0_2» + 2 * «W_i-15_b0_3» + 4 * «W_i-15_b0_4» + 8 * «W_i-15_b0_5» + 16 * «W_i-15_b0_6» + 32 * «W_i-15_b0_7» + 64 * «W_i-15_b1_0» + 128 * «W_i-15_b1_1»), - u8_from_field_unsafe(«W_i-15_b3_2» + 2 * «W_i-15_b3_3» + 4 * «W_i-15_b3_4» + 8 * «W_i-15_b3_5» + 16 * «W_i-15_b3_6» + 32 * «W_i-15_b3_7» + 64 * «W_i-15_b0_0» + 128 * «W_i-15_b0_1»), - u8_from_field_unsafe(«W_i-15_b2_2» + 2 * «W_i-15_b2_3» + 4 * «W_i-15_b2_4» + 8 * «W_i-15_b2_5» + 16 * «W_i-15_b2_6» + 32 * «W_i-15_b2_7» + 64 * «W_i-15_b3_0» + 128 * «W_i-15_b3_1») - ]; - - let «W_i-15_shr3» = [ - u8_from_field_unsafe(«W_i-15_b3_3» + 2 * «W_i-15_b3_4» + 4 * «W_i-15_b3_5» + 8 * «W_i-15_b3_6» + 16 * «W_i-15_b3_7»), - u8_from_field_unsafe(«W_i-15_b2_3» + 2 * «W_i-15_b2_4» + 4 * «W_i-15_b2_5» + 8 * «W_i-15_b2_6» + 16 * «W_i-15_b2_7» + 32 * «W_i-15_b3_0» + 64 * «W_i-15_b3_1» + 128 * «W_i-15_b3_2»), - u8_from_field_unsafe(«W_i-15_b1_3» + 2 * «W_i-15_b1_4» + 4 * «W_i-15_b1_5» + 8 * «W_i-15_b1_6» + 16 * «W_i-15_b1_7» + 32 * «W_i-15_b2_0» + 64 * «W_i-15_b2_1» + 128 * «W_i-15_b2_2»), - u8_from_field_unsafe(«W_i-15_b0_3» + 2 * «W_i-15_b0_4» + 4 * «W_i-15_b0_5» + 8 * «W_i-15_b0_6» + 16 * «W_i-15_b0_7» + 32 * «W_i-15_b1_0» + 64 * «W_i-15_b1_1» + 128 * «W_i-15_b1_2») - ]; - - let [«W_i-2_b3», «W_i-2_b2», «W_i-2_b1», «W_i-2_b0»] = «W_i-2»; - let [«W_i-2_b0_0», «W_i-2_b0_1», «W_i-2_b0_2», «W_i-2_b0_3», «W_i-2_b0_4», «W_i-2_b0_5», «W_i-2_b0_6», «W_i-2_b0_7»] = u8_bit_decomposition(«W_i-2_b0»); - let [«W_i-2_b1_0», «W_i-2_b1_1», «W_i-2_b1_2», «W_i-2_b1_3», «W_i-2_b1_4», «W_i-2_b1_5», «W_i-2_b1_6», «W_i-2_b1_7»] = u8_bit_decomposition(«W_i-2_b1»); - let [«W_i-2_b2_0», «W_i-2_b2_1», «W_i-2_b2_2», «W_i-2_b2_3», «W_i-2_b2_4», «W_i-2_b2_5», «W_i-2_b2_6», «W_i-2_b2_7»] = u8_bit_decomposition(«W_i-2_b2»); - let [«W_i-2_b3_0», «W_i-2_b3_1», «W_i-2_b3_2», «W_i-2_b3_3», «W_i-2_b3_4», «W_i-2_b3_5», «W_i-2_b3_6», «W_i-2_b3_7»] = u8_bit_decomposition(«W_i-2_b3»); - - let «W_i-2_rotr17» = [ - u8_from_field_unsafe(«W_i-2_b1_1» + 2 * «W_i-2_b1_2» + 4 * «W_i-2_b1_3» + 8 * «W_i-2_b1_4» + 16 * «W_i-2_b1_5» + 32 * «W_i-2_b1_6» + 64 * «W_i-2_b1_7» + 128 * «W_i-2_b2_0»), - u8_from_field_unsafe(«W_i-2_b0_1» + 2 * «W_i-2_b0_2» + 4 * «W_i-2_b0_3» + 8 * «W_i-2_b0_4» + 16 * «W_i-2_b0_5» + 32 * «W_i-2_b0_6» + 64 * «W_i-2_b0_7» + 128 * «W_i-2_b1_0»), - u8_from_field_unsafe(«W_i-2_b3_1» + 2 * «W_i-2_b3_2» + 4 * «W_i-2_b3_3» + 8 * «W_i-2_b3_4» + 16 * «W_i-2_b3_5» + 32 * «W_i-2_b3_6» + 64 * «W_i-2_b3_7» + 128 * «W_i-2_b0_0»), - u8_from_field_unsafe(«W_i-2_b2_1» + 2 * «W_i-2_b2_2» + 4 * «W_i-2_b2_3» + 8 * «W_i-2_b2_4» + 16 * «W_i-2_b2_5» + 32 * «W_i-2_b2_6» + 64 * «W_i-2_b2_7» + 128 * «W_i-2_b3_0») - ]; - - let «W_i-2_rotr19» = [ - u8_from_field_unsafe(«W_i-2_b1_3» + 2 * «W_i-2_b1_4» + 4 * «W_i-2_b1_5» + 8 * «W_i-2_b1_6» + 16 * «W_i-2_b1_7» + 32 * «W_i-2_b2_0» + 64 * «W_i-2_b2_1» + 128 * «W_i-2_b2_2»), - u8_from_field_unsafe(«W_i-2_b0_3» + 2 * «W_i-2_b0_4» + 4 * «W_i-2_b0_5» + 8 * «W_i-2_b0_6» + 16 * «W_i-2_b0_7» + 32 * «W_i-2_b1_0» + 64 * «W_i-2_b1_1» + 128 * «W_i-2_b1_2»), - u8_from_field_unsafe(«W_i-2_b3_3» + 2 * «W_i-2_b3_4» + 4 * «W_i-2_b3_5» + 8 * «W_i-2_b3_6» + 16 * «W_i-2_b3_7» + 32 * «W_i-2_b0_0» + 64 * «W_i-2_b0_1» + 128 * «W_i-2_b0_2»), - u8_from_field_unsafe(«W_i-2_b2_3» + 2 * «W_i-2_b2_4» + 4 * «W_i-2_b2_5» + 8 * «W_i-2_b2_6» + 16 * «W_i-2_b2_7» + 32 * «W_i-2_b3_0» + 64 * «W_i-2_b3_1» + 128 * «W_i-2_b3_2») - ]; - - let «W_i-2_shr10» = [ - u8_from_field_unsafe(0), - u8_from_field_unsafe(«W_i-2_b3_2» + 2 * «W_i-2_b3_3» + 4 * «W_i-2_b3_4» + 8 * «W_i-2_b3_5» + 16 * «W_i-2_b3_6» + 32 * «W_i-2_b3_7»), - u8_from_field_unsafe(«W_i-2_b2_2» + 2 * «W_i-2_b2_3» + 4 * «W_i-2_b2_4» + 8 * «W_i-2_b2_5» + 16 * «W_i-2_b2_6» + 32 * «W_i-2_b2_7» + 64 * «W_i-2_b3_0» + 128 * «W_i-2_b3_1»), - u8_from_field_unsafe(«W_i-2_b1_2» + 2 * «W_i-2_b1_3» + 4 * «W_i-2_b1_4» + 8 * «W_i-2_b1_5» + 16 * «W_i-2_b1_6» + 32 * «W_i-2_b1_7» + 64 * «W_i-2_b2_0» + 128 * «W_i-2_b2_1») - ]; - - let «W_i_s0» = u32_xor(«W_i-15_rotr7», u32_xor(«W_i-15_rotr18», «W_i-15_shr3»)); - let «W_i_s1» = u32_xor(«W_i-2_rotr17», u32_xor(«W_i-2_rotr19», «W_i-2_shr10»)); - u32_be_add(«W_i-16», u32_be_add(«W_i_s0», u32_be_add(«W_i-7», «W_i_s1»))) - } -⟧ - -end IxVM - -end diff --git a/Ix/IxVM/Toplevel.lean b/Ix/IxVM/Toplevel.lean deleted file mode 100644 index 090f215ae..000000000 --- a/Ix/IxVM/Toplevel.lean +++ /dev/null @@ -1,238 +0,0 @@ -module -public import Ix.Aiur.Meta -public import Ix.Aiur.Library.Core -public import Ix.Aiur.Library.ByteStream -public import Ix.Aiur.Library.Blake3 -public import Ix.IxVM.RBTreeMap -public import Ix.IxVM.Ixon -public import Ix.IxVM.IxonSerialize -public import Ix.IxVM.IxonDeserialize -public import Ix.IxVM.KernelTypes -public import Ix.IxVM.Kernel.Klimbs -public import Ix.IxVM.Kernel.NatPrim -public import Ix.IxVM.Convert -public import Ix.IxVM.Ingress -public import Ix.IxVM.Kernel.Levels -public import Ix.IxVM.Kernel.Subst -public import Ix.IxVM.Kernel.Whnf -public import Ix.IxVM.Kernel.InferOnly -public import Ix.IxVM.Kernel.DefEq -public import Ix.IxVM.Kernel.Infer -public import Ix.IxVM.Kernel.Check -public import Ix.IxVM.Kernel.Claim -public import Ix.IxVM.Kernel.Eval -public import Ix.IxVM.Kernel.Roles -public import Ix.IxVM.Kernel.RoleSpec - -public section - -namespace IxVM - -def entrypoints := ⟦ - -- Check entrypoint. Loads the constant at `addr_bytes` and typechecks - -- it via run_check. Refs discovered during the check fault lazily via - -- get_ci rather than being walked up front. - -- - -- Checks the constant AT `addr_bytes` and nothing else: its refs are - -- ingressed and get_ci'd for their declared types, but are not - -- themselves checked. For the transitive discipline use `verify_claim` - -- with a Check or CheckEnv claim. Primitives are read through the role - -- binding with hash `binding`. - pub fn verify_check(binding: [U8; 32], addr_bytes: [U8; 32]) { - run_check(role_ctx_of_binding(store(binding)), store(addr_bytes)); - } - - -- CheckEnv entrypoint. Parses the env tree at `root_bytes` (ch 1), - -- checks every leaf via run_check. Faults constants lazily via - -- get_ci; shared subterms across leaves ingressed once (memoized). - pub fn verify_check_env(binding: [U8; 32], root_bytes: [U8; 32]) { - run_check_env(role_ctx_of_binding(store(binding)), store(root_bytes), Option.None); - } - - /- # Test entrypoints. These exercise shared infrastructure — the Ixon - serde round-trip and the level comparator — rather than the - typechecker proper, and are pruned out of the production `ixVM` - toplevel below. -/ - - pub fn ixon_serde_test(n: G) { - match n { - 0 => (), - _ => - let n_minus_1 = n - 1; - let (idx, len) = io_get_info(0, [n_minus_1]); - let bytes = read_checked_byte_stream(0, idx, len); - let (const, rest) = get_constant(bytes); - assert_eq!(load(rest), ListNode.Nil, - "ixon deserialization left trailing bytes"); - let bytes2 = put_constant(const, store(ListNode.Nil)); - assert_eq!(bytes, bytes2, - "ixon round-trip: re-serialized bytes differ from the input"); - ixon_serde_test(n_minus_1), - } - } - - fn level_cmp_tests() { - let zero = store(KLevelNode.Zero); - let p0 = store(KLevelNode.Param(0)); - let p1 = store(KLevelNode.Param(1)); - let succ_p0 = store(KLevelNode.Succ(p0)); - let succ_zero = store(KLevelNode.Succ(zero)); - - -- Zero ≤ anything - assert_eq!(level_leq(zero, p0), 1, "level_leq: 0 <= u must hold"); - - -- Param(u) ≤ Param(u) (reflexivity) - assert_eq!(level_leq(p0, p0), 1, "level_leq: u <= u must hold (reflexivity)"); - - -- Param(u) ≤ Param(v) fails (u ≠ v, set u > v) - assert_eq!(level_leq(p0, p1), 0, - "level_leq: distinct params must not compare <="); - - -- Succ(u) ≤ Succ(u) (peel both succs) - assert_eq!(level_leq(succ_p0, succ_p0), 1, - "level_leq: u+1 <= u+1 must hold (peel both succs)"); - - -- Succ(u) ≤ u fails (u+1 > u at any assignment) - assert_eq!(level_leq(succ_p0, p0), 0, - "level_leq: u+1 <= u must fail at every assignment"); - - -- Param(u) ≤ Succ(Param(u)) (u ≤ u+1) - assert_eq!(level_leq(p0, succ_p0), 1, "level_leq: u <= u+1 must hold"); - - -- max(u, v) ≤ max(u, v) (reflexivity via distribution) - let max_uv = store(KLevelNode.Max(p0, p1)); - assert_eq!(level_leq(max_uv, max_uv), 1, - "level_leq: max(u,v) <= max(u,v) must hold (reflexivity via distribution)"); - - -- u ≤ max(u, v) - assert_eq!(level_leq(p0, max_uv), 1, "level_leq: u <= max(u,v) must hold"); - - -- max(u, v) ≤ u fails - assert_eq!(level_leq(max_uv, p0), 0, "level_leq: max(u,v) <= u must fail"); - - -- imax(u, v) ≤ max(u, v) - let imax_uv = store(KLevelNode.IMax(p0, p1)); - assert_eq!(level_leq(imax_uv, max_uv), 1, - "level_leq: imax(u,v) <= max(u,v) must hold"); - - -- max(u, v) ≤ imax(u, v) fails - assert_eq!(level_leq(max_uv, imax_uv), 0, - "level_leq: max(u,v) <= imax(u,v) must fail"); - - -- u+1 = max(1, imax(u+1, u)): equal for all σ (case-split fix) - let a = succ_p0; - let b = store(KLevelNode.Max( - succ_zero, - store(KLevelNode.IMax(succ_p0, p0)))); - assert_eq!(level_equal(a, b), 1, - "level_equal: u+1 = max(1, imax(u+1, u)) must hold at every assignment"); - - -- imax(u, u) = u - assert_eq!(level_equal(store(KLevelNode.IMax(p0, p0)), p0), 1, - "level_equal: imax(u,u) = u must hold"); - - -- max(u, 0) = u - assert_eq!(level_equal(store(KLevelNode.Max(p0, zero)), p0), 1, - "level_equal: max(u,0) = u must hold"); - - -- level_imax reduces imax(u, 1+v) to max(u, 1+v) and imax(u, 0) to 0 - let succ_v = store(KLevelNode.Succ(p1)); - assert_eq!(level_eq( - level_imax(p0, succ_v), - store(KLevelNode.Max(p0, succ_v))), 1, - "level_imax must reduce imax(u, 1+v) to max(u, 1+v)"); - - assert_eq!(level_eq( - level_imax(p0, zero), - zero), 1, - "level_imax must reduce imax(u, 0) to 0"); - } - - pub fn kernel_unit_tests() { - level_cmp_tests() - } - - -- Subject-only typecheck. DEBUG entrypoint, NOT a claim: checks - -- `addr_bytes` alone and trusts its transitive deps (they are - -- get_ci'd for their declared types but never checked). Used by the - -- kernel-arena fixtures, where the - -- per-fixture speed matters (shared deps would otherwise be - -- revalidated once per fixture) and where a `bad_*` rejection must - -- be attributable to the SUBJECT rather than to a dep. - -- - -- Verifier policy must never accept this funcidx as a production - -- claim — it carries no claim digest and no assumption discipline. - -- Body is deliberately identical to `verify_check`: the two exist as - -- separate funcidxs precisely so policy can accept one and reject the - -- other. - pub fn verify_const(binding: [U8; 32], addr_bytes: [U8; 32]) { - run_check(role_ctx_of_binding(store(binding)), store(addr_bytes)); - } - - -- Claim-discipline entrypoint — the only production entrypoint. Loads - -- the claim bytes at ch 0 keyed by `claim_digest`, blake3-binds them - -- against that key (so the public input pins which claim was proved), - -- then dispatches on the claim variant: Eval, Check, CheckEnv, Reveal, and - -- Contains. See `run_claim` for the per-variant discipline. - -- The digest is public input as 8 field elements of 4 packed LE bytes - -- (injective in Goldilocks; 8 input columns instead of 32) — the same - -- representation the recursive verifier's entrypoint uses. - pub fn verify_claim(claim_digest: [G; 8]) { - run_claim(claim_digest); - } -⟧ - -open Aiur.Library (core byteStream blake3) -open IxVM (rbTreeMap ixon ixonSerialize ixonDeserialize) - -/-- The full IxVM kernel toplevel: shared modules (core, ixon, blake3, …) - merged with the kernel-specific `kernelTypes`, `convert`, `ingress`, - and `entrypoints`. Carries the test and benchmark entrypoints too; - `ixVM` below is the pruned production toplevel. -/ -def ixVMFull : Except Aiur.Global Aiur.Source.Toplevel := do - let vm ← core.merge byteStream - let vm ← vm.merge blake3 - let vm ← vm.merge rbTreeMap - let vm ← vm.merge ixon - let vm ← vm.merge ixonSerialize - let vm ← vm.merge ixonDeserialize - let vm ← vm.merge kernelTypes - let vm ← vm.merge klimbs - let vm ← vm.merge natPrim - let vm ← vm.merge convert - let vm ← vm.merge ingress - let vm ← vm.merge levels - let vm ← vm.merge subst - let vm ← vm.merge whnf - let vm ← vm.merge inferOnly - let vm ← vm.merge defEq - let vm ← vm.merge infer - let vm ← vm.merge roles - let vm ← vm.merge roleSpec - let vm ← vm.merge check - let vm ← vm.merge claim - let vm ← vm.merge eval - vm.merge entrypoints - -/-- Pruned production toplevel: `verify_claim` and nothing else. - - `verify_const` / `verify_check` / `verify_check_env` are DEBUG - entrypoints that trust their dependencies instead of walking them, so - a proof made with one attests far less than a claim does. Keeping - them here put them in the same verifying key as `verify_claim`, - leaving `ix verify`'s funcIdx check as the only thing standing - between a debug proof and acceptance — a policy, enforced in one - place, with no test asserting it, and no policy at all in the - recursive verifier. - - Pruning them makes it structural: under the production VK such a - proof cannot exist. Callers that genuinely want a subject-only check - build `ixVMFull` and are thereby using a different VK, which is the - honest signal. -/ -def ixVM : Except Aiur.Global Aiur.Source.Toplevel := do - let vm ← ixVMFull - pure (vm.prune [`verify_claim]) - -end IxVM - -end diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean index df7fa9031..6edc133e8 100644 --- a/Ix/Ixon.lean +++ b/Ix/Ixon.lean @@ -2907,7 +2907,7 @@ def RawEnvLazy.toEnv (raw : RawEnvLazy) (buf : ByteArray) : Env := Id.run do @[extern "rs_de_env_lazy"] opaque rsDeEnvLazyFFI : @& ByteArray → Except String RawEnvLazy -/-- Lazy, zero-copy, metadata-light deserialization for the Aiur check path. +/-- Lazy, zero-copy, metadata-light deserialization for the LegacyAiur check path. Constants are byte-window `LazyConstant`s into `bytes` (parsed on demand, only for the checked closure); binder metadata is dropped, keeping just `name → addr` and per-`Defn` hints. The returned env borrows `bytes` — keep diff --git a/MultiStark/Wire.lean b/Ix/MultiStark/Wire.lean similarity index 70% rename from MultiStark/Wire.lean rename to Ix/MultiStark/Wire.lean index 29e2644eb..200c21cd8 100644 --- a/MultiStark/Wire.lean +++ b/Ix/MultiStark/Wire.lean @@ -23,13 +23,8 @@ def serializeClaims (claims : Array (Array Aiur.G)) : ByteArray := Id.run do return ⟨out⟩ /-- Assemble `verify_multi_stark_proof`'s public input from the serialized vk -(`AiurSystem.vkBytes`) and claims (`serializeClaims`): vk digest ++ claims -digest, each as 8 packed-4-byte field elements (the entrypoint's format). The FRI parameters are read in-circuit from the digest-bound vk, not -passed publicly. The proof/vk/claims advice itself goes through the -natively-built IO buffer (`executeMultiStark` / `proveMultiStark`, which take -the raw byte blobs directly: channel 0 = the verified native proof transport -returned by `AiurSystem.proofToAdviceBytes`, 1 = vk, 2 = claims, each under -key `[0]`). -/ +and claims (`serializeClaims`): vk digest ++ claims digest, each as 8 +packed-4-byte field elements (the entrypoint's format). -/ def digestGs (bytes : ByteArray) : Array Aiur.G := let h := (Blake3.Rust.hash bytes).val.data (Array.range 8).map fun i => @@ -39,6 +34,5 @@ def digestGs (bytes : ByteArray) : Array Aiur.G := def verifierPubInput (vkBytes claimBytes : ByteArray) : Array Aiur.G := digestGs vkBytes ++ digestGs claimBytes - end MultiStark end diff --git a/Ix/Shard/Check.lean b/Ix/Shard/Check.lean index 61ce9648e..c02c6c7e3 100644 --- a/Ix/Shard/Check.lean +++ b/Ix/Shard/Check.lean @@ -5,7 +5,7 @@ public import Ix.Benchmark.Results public import Ix.TracingTexray public import Ix.Unsigned -/-! Manifest-driven IxVM execution, resource auditing, and shard refinement. -/ +/-! Manifest-driven IxVM execution helpers and shard refinement. -/ public section namespace Ix.Shard.Check @@ -23,32 +23,6 @@ def runShardOwned (ixonEnv : Ixon.Env) (blocks : Array Address) (shardK : Nat) | .error e => IO.eprintln s!"shard witness build failed: {e}"; return 1 | .ok (claim, witness) => runOne claim witness s!"shard {shardK}" -/-- IxVM-native fast path: dispatch through `shardCheckWithEnv` (a - Rust-owned `EnvHandle` reused across calls). Caller threads in - the pre-built envHandle so all shards in an all-shards run share - one env parse. -/ -def runShardOwnedNative (envHandle : Aiur.EnvHandle) (compiled : Aiur.CompiledToplevel) - (printStats : Bool) (statsOut : Option String) - (useBytecode : Bool) - (ixonEnv : Ixon.Env) (blocks : Array Address) (shardK : Nat) : IO UInt32 := do - let owned := ownedConstsForBlocks ixonEnv blocks - IO.println s!"[shard] shard {shardK}: {blocks.size} owned blocks → \ - {owned.size}/{ixonEnv.consts.size} owned consts" - let label := s!"shard {shardK}" - IO.println s!"Typechecking {label}" - (← IO.getStdout).flush - let funIdx := compiled.getFuncIdx `verify_claim |>.get! - let mut blob := ByteArray.empty - for a in owned do - blob := blob ++ a.hash - match compiled.bytecode.shardCheckWithEnv funIdx envHandle blob useBytecode with - | .error e => - IO.eprintln s!"{label}: IxVM-native shard check error: {e}" - return 1 - | .ok (_output, _ioBuffer, queryCounts) => - if printStats then emitStats compiled queryCounts statsOut - pure 0 - /-- Manifest-driven check/prove of one shard `shardK` of the partition. -/ def runShardCheckManifest (manifestPath ixePath : String) (shardK : Nat) (runOne : Ix.Claim → IxVM.ClaimHarness.ClaimWitness → String → IO UInt32) : IO UInt32 := do @@ -58,28 +32,8 @@ def runShardCheckManifest (manifestPath ixePath : String) (shardK : Nat) | none => IO.eprintln s!"shard {shardK} out of range ({shards.size} shards)"; return 1 | some blocks => runShardOwned ixonEnv blocks shardK runOne -/-- IxVM-native shard check, single shard. Builds an `EnvHandle` - once for this one call. -/ -def runShardCheckManifestNative (manifestPath ixePath : String) (shardK : Nat) - (compiled : Aiur.CompiledToplevel) (printStats : Bool) - (statsOut : Option String) - (useBytecode : Bool) : IO UInt32 := do - match (← loadEnvAndShards manifestPath ixePath) with - | .error e => IO.eprintln e; return 1 - | .ok (ixonEnv, shards) => match shards[shardK]? with - | none => IO.eprintln s!"shard {shardK} out of range ({shards.size} shards)"; return 1 - | some blocks => - let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with - | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1 - | .ok h => pure h - runShardOwnedNative envHandle compiled printStats statsOut - useBytecode ixonEnv blocks shardK - /-- Cut `blocks` into contiguous, nonempty, roughly equal-count parts - (`p` clamped to `[2, blocks.size]` — a rejection always needs at - least two parts, and the block list caps how many a cut can - produce). Equal block counts approximate the prover-row distribution. - Shared by the prove split recursion and the check wave loop. -/ + (`p` clamped to `[2, blocks.size]`). -/ def cutBlocks (blocks : Array Address) (p : Nat) : Array (Array Address) := let p := min (max p 2) blocks.size (Array.range p).map fun i => @@ -130,8 +84,7 @@ def refinementsOfRuns (n : Nat) | none => (rs, measured) /-- Decode the new-id table `Aiur.shardManifestRefine` returns: - `count(u32)`, then per refinement `n(u32) ‖ n × id(u32)`. Malformed - input yields the ids decoded so far, never a panic. -/ + `count(u32)`, then per refinement `n(u32) ‖ n × id(u32)`. -/ def decodeIdTable (bytes : ByteArray) : Array (Array Nat) := Id.run do let u32At (i : Nat) : Option Nat := if i + 4 ≤ bytes.size then @@ -153,14 +106,7 @@ def decodeIdTable (bytes : ByteArray) : Array (Array Nat) := Id.run do return table /-- Emit the partition a run actually validated as a refinement of the - manifest it started from — the shared tail of `ix prove --out-ixes` - and `ix check --ram-budget --out-ixes`. Untouched leaves keep their - records, ids and tree positions (`Aiur.shardManifestRefine`); a leaf - that split becomes a subtree over its parts, part 0 keeping the leaf's - id and later parts taking fresh ids after the last existing one. - `measured` carries the peaks of the leaves that ran unsplit. Skipped - with a note when any shard failed: a refined manifest describes a - fully-validated partition. Returns the parts' new ids per refinement. -/ + manifest it started from. -/ def emitRefinedManifest (tag : String) (envHandle : Aiur.EnvHandle) (sourcePath out : String) (refinements : Array LeafRefinement) (measured : Array Nat) (failures : Nat) : IO (Array (Array Nat)) := do @@ -176,24 +122,12 @@ def emitRefinedManifest (tag : String) (envHandle : Aiur.EnvHandle) /-- What a batch run is asked to do beyond the plain check. -/ structure AuditOptions where - /-- Leaves to execute in wave 0; `none` = every leaf of the manifest. -/ selection : Option (Array Nat) := none - /-- Decide, once the env and every leaf's owned constants are loaded, - which selected leaves a verified proof already covers: they are - reported `proven-kept`, never executed and never split (the - shard-proof index guard of `ix shard refine`). Receives the env, the - leaves' block lists, their owned constants, and the selected ids. -/ provenGuard : Option (Ixon.Env → Array (Array Address) → Array (Array Address) → Array Nat → IO (Std.HashMap Nat Address)) := none - /-- Write the provisional JSON report (`ix-refine/0`) here. -/ report : Option String := none - /-- `true` (`ix shard refine`): write `--out-ixes` even when some leaves - failed — they stay unchanged — and exit 2. `false` (`ix check`): skip - the manifest on any failure. -/ emitOnFailure : Bool := false - /-- The invoking command line, recorded in the report. -/ command : String := "" - /-- How the budget was chosen (`flag` or `detected`), for the report. -/ budgetSource : String := "flag" /-- One settled part of a leaf's cascade, for the manifest and the report. -/ @@ -206,9 +140,10 @@ structure PartReport where /-- Claim digest of a leaf from its already-known owned constants (no env rescan): the digest `ix prove` persists and `ix aggregate` matches on. -/ -def claimDigestOfOwned (ixonEnv : Ixon.Env) (owned : Array Address) : +def claimDigestOfOwned (ixonEnv : Ixon.Env) (owned : Array Address) + (assumeBinding : Bool := false) : Except String Address := do - let (claim, _) ← IxVM.ClaimHarness.shardCheckEnvClaimTrees ixonEnv owned + let (claim, _) ← IxVM.ClaimHarness.shardCheckEnvClaimTrees ixonEnv owned assumeBinding pure (Address.blake3 (Ix.Claim.ser claim)) /-- `K`, `a-b`, or a comma list of those: the leaf ids a run is restricted @@ -235,312 +170,8 @@ def parseShardSelection (s : String) : Except String (Array Nat) := do let sorted := ids.qsort (· < ·) pure (sorted.foldl (fun acc k => if acc.back? == some k then acc else acc.push k) #[]) -private def fileDigest (path : String) : IO (Option (String × Nat)) := do - try - let bytes ← IO.FS.readBinFile path - pure (some (toString (Address.blake3 bytes), bytes.size)) - catch _ => pure none - -private def gitRevision : IO String := do - try - let out ← IO.Process.output { cmd := "git", args := #["rev-parse", "HEAD"] } - pure (if out.exitCode == 0 then out.stdout.trimAscii.toString else "unknown") - catch _ => pure "unknown" - -private def fileJson (path : String) (digest : Option (String × Nat)) - (shards : Option Nat) : Lean.Json := - Lean.Json.mkObj ([("path", Lean.Json.str path)] - ++ (match digest with - | some (h, n) => [("blake3", Lean.Json.str h), ("bytes", Lean.toJson n)] - | none => []) - ++ (match shards with | some n => [("shards", Lean.toJson n)] | none => [])) - -/-- Whole-partition check as ONE Rust rayon batch: work-stealing across - shards, no chunk barriers (measured 2.3–2.5x faster than the - per-shard Lean-task scheduler it replaced, whose chunk-of-N full - barrier idled workers on each wave's slowest shard). Each shard - runs the identical single-shard machinery over its own record; per - shard the analytic prover RAM peak of the executed record is - reported — the input to split (over a prover budget) / merge (far - under it) decisions. Builds the `EnvHandle` ONCE, shared by every - shard. Coverage-gates the manifest before running any shard — exit - 0 has to mean "every env const was checked by some shard", same - soundness contract as `runShardCheckAll`. - - `opts` turns the batch into an audit: a selection of leaves, the - proven-leaf guard, a JSON report, and `ix shard refine`'s failure - policy. -/ -def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) - (compiled : Aiur.CompiledToplevel) (useBytecode : Bool) - (json? : Option (String × String)) - (maxRamBytes : Nat) (outIxes : Option String) - (opts : AuditOptions := {}) : - IO UInt32 := do - -- The row's peak-rss needs the process-tree RSS sampler running - -- (`peakTreeRssBytes` reports 0 otherwise); started before the env - -- load so the peak covers the whole run, like `check-lean`. - if json?.isSome then TracingTexray.startSampler - match (← loadEnvAndShards manifestPath ixePath) with - | .error e => IO.eprintln e; return 1 - | .ok (ixonEnv, shards) => - if !(← shardsCover ixonEnv shards) then return 1 - let selected : Array Nat ← match opts.selection with - | none => pure (Array.range shards.size) - | some sel => - if let some k := sel.find? (· ≥ shards.size) then - IO.eprintln s!"--shards: shard {k} out of range ({shards.size} shards)" - return 1 - pure sel - let selectedSet : Std.HashSet Nat := selected.foldl (·.insert ·) {} - let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with - | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1 - | .ok h => pure h - let funIdx := compiled.getFuncIdx `verify_claim |>.get! - let jobs := jobs?.getD 0 - -- The whole run's ownership assignment: one env pass here, and every - -- later wave's parts inherit their parent's owned consts via - -- `partitionOwned` — no wave ever rescans the env. - let ownedAll := ownedConstsPer ixonEnv shards - -- Leaves a verified proof already covers stay exactly as they are. - let proven : Std.HashMap Nat Address ← match opts.provenGuard with - | none => pure {} - | some guard => guard ixonEnv shards ownedAll selected - if !proven.isEmpty then - IO.println s!"[audit] {proven.size} selected leaf/leaves already have a \ - verified proof — kept unsplit" - let cutLabeled (origin : Nat) (label : String) (blocks owned : Array Address) - (p : Nat) : Array (Nat × String × Array Address × Array Address) := - let parts := cutBlocks blocks p - (parts.zip (partitionOwned ixonEnv owned parts)).mapIdx - fun i (part, po) => (origin, s!"{label}.{i}", part, po) - -- One loop over execution waves. Wave 0 is the selected part of the - -- planned partition; with a budget every over-budget leaf is cut into - -- the peak model's suggested part count and the parts re-batched as - -- the next wave, until everything fits or is a single block. Without - -- a budget the FFI answers 1 part everywhere and the loop is a single - -- wave — the plain batch check. - let mut wave : Array (Nat × String × Array Address × Array Address) := - selected.filterMap fun k => - if proven.contains k then none - else (shards[k]?).bind fun b => (ownedAll[k]?).map fun o => (k, s!"{k}", b, o) - let executed := wave.size - let mut waveNum := 0 - let mut failed : Array String := #[] - let mut final : Array (Array Address × Nat) := #[] - -- Per source leaf: its wave-0 peak, and the parts that ended its - -- cascade (fit, or failed) — what the manifest and the report describe. - let mut leafPeak : Std.HashMap Nat Nat := {} - let mut leafParts : Std.HashMap Nat (Array PartReport) := {} - let mut totalConsts := 0 - let mut elapsedMs := 0 - while wave.size > 0 do - if waveNum == 0 then - IO.println s!"Typechecking {wave.size} shard(s) in one rayon \ - batch, {jobs} thread(s) (0 = all)" - else - IO.println s!"[wave {waveNum}] re-executing {wave.size} part(s)" - (← IO.getStdout).flush - let ownedPer := wave.map (·.2.2.2) - let start ← IO.monoMsNow - match compiled.bytecode.shardCheckBatchWithEnv funIdx envHandle - (addrListsBlob ownedPer) useBytecode jobs - Aiur.defaultCommitmentParameters Aiur.defaultFriParameters - maxRamBytes with - | .error e => IO.eprintln s!"shard batch (wave {waveNum}): {e}"; return 1 - | .ok rs => - if waveNum == 0 then - -- The bench row's measured window: the planned partition's - -- batch call, matching `check-lean`. Split waves are audit - -- extras outside the benchmarked engine window. - elapsedMs := (← IO.monoMsNow) - start - totalConsts := ownedPer.foldl (· + ·.size) 0 - let mut next : Array (Nat × String × Array Address × Array Address) := #[] - for (r, origin, label, blocks, owned) in rs.zip wave do - let gib := toGib r.peakBytes - if waveNum == 0 then leafPeak := leafPeak.insert origin r.peakBytes - let mut settled : Option String := none - if !r.error.isEmpty then - IO.eprintln s!"[shard {label}] FAILED: {r.error}" - failed := failed.push s!"shard {label}: {r.error}" - settled := some r.error - else if r.suggestedParts <= 1 then - IO.println s!"[shard {label}] ok, projected prover peak {gib} GiB" - settled := some "" - else if blocks.size <= 1 then - IO.eprintln s!"[shard {label}] peak {gib} GiB over budget and a \ - single block — cannot split" - failed := failed.push s!"shard {label}: single block over budget" - settled := some "single block over budget" - else - IO.println s!"[shard {label}] peak {gib} GiB over budget — cut \ - into {r.suggestedParts}" - next := next ++ cutLabeled origin label blocks owned r.suggestedParts - if let some error := settled then - final := final.push (blocks, r.peakBytes) - leafParts := leafParts.insert origin ((leafParts.getD origin #[]).push - { label, blocks, owned, peak := r.peakBytes, error }) - wave := next - waveNum := waveNum + 1 - let tag := if opts.emitOnFailure then "refine" else "split-audit" - let waves := if waveNum == 0 then 0 else waveNum - 1 - if maxRamBytes > 0 then - IO.println s!"[{tag}] {final.size} part(s) from {executed} executed \ - leaf/leaves ({shards.size} in the manifest), {waves} split wave(s), \ - {failed.size} failure(s)" - -- A split leaf's parts in block order, whatever wave settled them. - let sortedParts (k : Nat) (parts : Array PartReport) : Array PartReport := - let pos : Std.HashMap Address Nat := - (((shards[k]?).getD #[]).mapIdx fun i a => (a, i)).foldl - (fun m (a, i) => m.insert a i) {} - let posOf (p : PartReport) : Nat := ((p.blocks[0]?).bind pos.get?).getD 0 - parts.qsort fun a b => posOf a < posOf b - -- The refined partition — what this run actually validated — written - -- as a refinement of the manifest it started from: untouched leaves - -- keep their records, ids and tree positions; a failed leaf stays as - -- in the source. - let runs : Array (Nat × Array (Array Address × Nat)) := - (Array.range shards.size).filterMap fun k => - (leafParts.get? k).bind fun ps => - if ps.any (·.error != "") then none - else some (k, (sortedParts k ps).map fun p => (p.blocks, p.peak)) - let mut idTable : Array (Array Nat) := #[] - let mut wroteManifest := false - if let some out := outIxes then - if failed.isEmpty || opts.emitOnFailure then - let (refinements, measured) := refinementsOfRuns shards.size runs - idTable ← emitRefinedManifest tag envHandle manifestPath out - refinements measured 0 - wroteManifest := true - else - IO.eprintln s!"--out-ixes {out} skipped: {failed.size} failure(s)" - if let some reportPath := opts.report then - -- New ids per split leaf, in refinement order (ascending leaf id). - let mut newIds : Std.HashMap Nat (Array Nat) := {} - for ((k, _), ids) in (runs.filter (·.2.size > 1)).zip idTable do - newIds := newIds.insert k ids - let digestJson (owned : Array Address) : Lean.Json := - match claimDigestOfOwned ixonEnv owned with - | .ok d => Lean.Json.str (toString d) - | .error _ => Lean.Json.null - let mut leaves : Array Lean.Json := #[] - let mut failures : Array Lean.Json := #[] - for k in [0:shards.size] do - let blocks := (shards[k]?).getD #[] - let owned := (ownedAll[k]?).getD #[] - let inRun := proven.contains k || selectedSet.contains k - let base := [("id", Lean.toJson k), ("blocks", Lean.toJson blocks.size), - ("consts", Lean.toJson owned.size), - ("claim", if inRun then digestJson owned else Lean.Json.null), - ("predicted_peak_bytes", match leafPeak.get? k with - | some p => Lean.toJson p | none => Lean.Json.null)] - let status (s : String) := Lean.Json.mkObj (base ++ [("status", Lean.Json.str s)]) - if let some addr := proven.get? k then - leaves := leaves.push (Lean.Json.mkObj (base ++ - [("status", Lean.Json.str "proven-kept"), ("proof", Lean.Json.str (toString addr))])) - else if !selectedSet.contains k then - leaves := leaves.push (status "unchanged") - else match leafParts.get? k with - | none => leaves := leaves.push (status "unchanged") - | some ps => - let ps := sortedParts k ps - let anyFailed := ps.any (·.error != "") - for p in ps do - if p.error != "" then - let names := (p.owned.filterMap fun a => - (ixonEnv.addrToName.get? a).map toString).extract 0 8 - failures := failures.push (Lean.Json.mkObj ([("id", Lean.toJson k), - ("label", Lean.Json.str p.label), ("reason", Lean.Json.str p.error), - ("blocks", Lean.toJson p.blocks.size), ("consts", Lean.toJson p.owned.size), - ("predicted_peak_bytes", Lean.toJson p.peak), - ("names", Lean.toJson names)] - ++ (match p.blocks[0]? with - | some b => if p.blocks.size == 1 then [("block", Lean.Json.str (toString b))] else [] - | none => []))) - if anyFailed then - leaves := leaves.push (status "failed") - else if ps.size == 1 then - leaves := leaves.push (status "measured") - else - let ids := (newIds.get? k).getD #[] - let depth := ps.foldl (fun d p => max d ((p.label.splitOn ".").length - 1)) 0 - let parts := ps.mapIdx fun i p => Lean.Json.mkObj [ - ("id", match ids[i]? with | some id => Lean.toJson id | none => Lean.Json.null), - ("label", Lean.Json.str p.label), ("blocks", Lean.toJson p.blocks.size), - ("consts", Lean.toJson p.owned.size), - ("predicted_peak_bytes", Lean.toJson p.peak), - ("claim", digestJson p.owned)] - leaves := leaves.push (Lean.Json.mkObj (base ++ - [("status", Lean.Json.str "split"), ("depth", Lean.toJson depth), - ("parts", Lean.Json.arr parts)])) - -- Consolidation: the leaf count the measured total says would fit the - -- budget — arithmetic from measured peaks, never an execution. - let consolidation := if maxRamBytes > 0 then - let sum := final.foldl (· + ·.2) 0 - let target := maxRamBytes * 95 / 100 - Lean.toJson (max 1 ((sum + target - 1) / target)) - else Lean.Json.null - let sourceDigest ← fileDigest manifestPath - let outJson ← match outIxes with - | some out => - if wroteManifest then do - let d ← fileDigest out - let n := shards.size + idTable.foldl (fun acc ids => acc + ids.size - 1) 0 - pure (fileJson out d (some n)) - else pure Lean.Json.null - | none => pure Lean.Json.null - let envBytes ← (do - try pure (Lean.toJson (← System.FilePath.metadata ixePath).byteSize.toNat) - catch _ => pure Lean.Json.null) - let report := Lean.Json.mkObj [ - ("schema", Lean.Json.str "ix-refine/0"), - ("revision", Lean.Json.str (← gitRevision)), - ("command", Lean.Json.str opts.command), - ("env", Lean.Json.mkObj [("path", Lean.Json.str ixePath), ("bytes", envBytes)]), - ("source", fileJson manifestPath sourceDigest (some shards.size)), - ("out", outJson), - ("budget_bytes", Lean.toJson maxRamBytes), - ("budget_source", Lean.Json.str opts.budgetSource), - ("jobs", Lean.toJson jobs), - ("selected", Lean.toJson selected.size), - ("executed", Lean.toJson executed), - ("waves", Lean.toJson waves), - ("consolidation_shards", consolidation), - ("leaves", Lean.Json.arr leaves), - ("failures", Lean.Json.arr failures)] - IO.FS.writeFile reportPath (report.pretty ++ "\n") - IO.println s!"[{tag}] report → {reportPath}" - -- One env-keyed results row for `ix bench run --backend aiur-sharded-env`: - -- the measured window is the wave-0 batch FFI call (env load and - -- blob setup are excluded, matching what the benchmark tracks — the - -- execution engine, not the loader). - if let some (path, key) := json? then - let secs := elapsedMs.toFloat / 1000.0 - let tput := if elapsedMs > 0 - then totalConsts.toFloat * 1000.0 / elapsedMs.toFloat else 0.0 - let peakRss ← TracingTexray.peakTreeRssBytes - let status := if failed.isEmpty then "ok" else "rejected" - Ix.Benchmark.Results.writeRow path key status - [ ("constants", Lean.toJson totalConsts) - , ("shards", Lean.toJson final.size) - , ("check-time", Ix.Benchmark.Results.jsonRound 3 secs) - , ("throughput", Ix.Benchmark.Results.jsonRound 2 tput) - , ("peak-rss", Lean.toJson peakRss) ] - if failed.isEmpty then - IO.println s!"All {final.size} shard(s) passed" - return 0 - IO.eprintln s!"{failed.size} of {final.size} shard(s) FAILED:" - for f in failed do IO.eprintln s!" {f}" - -- `ix shard refine` still wrote its manifest (failed leaves unchanged): - -- exit 2 tells the operator to read the report. Under `--json` a kernel - -- rejection is the benchmark's `rejected` exit (the row is already - -- written), same contract as `check-lean`. - if opts.emitOnFailure then return 2 - return if json?.isSome then Ix.Benchmark.Results.exitRejected else 1 - - /-- Run the shard operation over EVERY shard — the whole-partition behavior of - `--ixes` with no `--shard` (used by `prove`). Loads the env once. Returns 1 - if any shard fails, else 0. -/ + `--ixes` with no `--shard` (used by `prove`). -/ def runShardManifestAll (manifestPath ixePath : String) (runOne : Ix.Claim → IxVM.ClaimHarness.ClaimWitness → String → IO UInt32) : IO UInt32 := do match (← loadEnvAndShards manifestPath ixePath) with @@ -551,20 +182,13 @@ def runShardManifestAll (manifestPath ixePath : String) if (← runShardOwned ixonEnv blocks k runOne) != 0 then rc := 1 pure rc -/-- Check EVERY shard of the partition concurrently (shards are independent - bytecode runs) after verifying coverage — the whole-partition behavior of - `check --ixes` with no `--shard`. At most `jobs` shards run at once - (`none` ⇒ all of them); cap it to bound peak RAM, since each in-flight - shard's IO buffer re-ingests its whole closure. Returns 1 on a coverage gap - or any shard failure. -/ +/-- Check EVERY shard of the partition concurrently after verifying coverage. -/ def runShardCheckAll (manifestPath ixePath : String) (jobs? : Option Nat) (runOne : Ix.Claim → IxVM.ClaimHarness.ClaimWitness → String → IO UInt32) : IO UInt32 := do let (ixonEnv, shards) ← match (← loadEnvAndShards manifestPath ixePath) with | .error e => IO.eprintln e; return 1 | .ok r => pure r if !(← shardsCover ixonEnv shards) then return 1 - -- The env + compiled toplevel are read-only, so each shard runs on its own - -- dedicated task; chunk by `jobs` to cap the number in flight at once. let maxJobs := max 1 (jobs?.getD shards.size) let mut rc : UInt32 := 0 for chunk in (shards.mapIdx (fun k b => (b, k))).toList.toChunks maxJobs do diff --git a/Ix/Shard/Environment.lean b/Ix/Shard/Environment.lean index 9f61593c3..9c66c6d96 100644 --- a/Ix/Shard/Environment.lean +++ b/Ix/Shard/Environment.lean @@ -121,8 +121,7 @@ def IxesManifestView.pruneEmpty (view : IxesManifestView) def shardClaimDigest (ixonEnv : Ixon.Env) (blocks : Array Address) (assumeBinding : Bool := false) : Except String Address := do let (claim, _) ← IxVM.ClaimHarness.shardCheckEnvClaimTrees ixonEnv - (ownedConstsForBlocks ixonEnv blocks) - let claim := if assumeBinding then Ix.Claim.assumingBinding claim else claim + (ownedConstsForBlocks ixonEnv blocks) assumeBinding pure (Address.blake3 (Ix.Claim.ser claim)) /-- Load the `.ixe` env and the `.ixes` shard partition together (each file diff --git a/Ix/TracingTexray.lean b/Ix/TracingTexray.lean index 5ca100f3a..b22f31f06 100644 --- a/Ix/TracingTexray.lean +++ b/Ix/TracingTexray.lean @@ -1,7 +1,7 @@ /- tracing-texray + streaming Lean API. - The Rust prover emits `tracing` spans for each major Aiur proving stage + The Rust prover emits `tracing` spans for each major LegacyAiur proving stage (`aiur/execute`, `aiur/witness`, `aiur/prove`) and each STARK proving stage (`stark/...`). After `init` installs the subscriber: * a one-line `[texray] : ── RAM Δ +X peak Y` is streamed diff --git a/IxC/Fixtures/Codec.lean b/IxC/Fixtures/Codec.lean index 6d45fc0da..d40a1ee40 100644 --- a/IxC/Fixtures/Codec.lean +++ b/IxC/Fixtures/Codec.lean @@ -116,7 +116,7 @@ previous one ends, so every value has exactly one encoding and there is no nonminimal spelling to reject. The reader rejects exactly an invalid code (`f = 0, 2`), a 9-byte value reaching `2^64`, and truncation. The vectors are sharing's `Tests.Ixon.tagNUnits` (`Tests/Ix/Ixon.lean`) and the rejection -vectors of `Tests/Ix/IxVM/TagN.lean`. -/ +vectors of `Tests/Ix/LegacyIxVM/TagN.lean`. -/ /-- `(f, flag, value, bytes)`: the encodings of `Tests.Ixon.tagNUnits`, the first and last value of every rung, and `2^64 - 1` for each `f`. -/ diff --git a/IxVM/.gitignore b/IxVM/.gitignore new file mode 100644 index 000000000..01f8cdb63 --- /dev/null +++ b/IxVM/.gitignore @@ -0,0 +1 @@ +.lake/ diff --git a/IxVM/IxVM.lean b/IxVM/IxVM.lean new file mode 100644 index 000000000..b29917e88 --- /dev/null +++ b/IxVM/IxVM.lean @@ -0,0 +1 @@ +import IxVM.Program diff --git a/IxVM/IxVM/Compatibility.aiur b/IxVM/IxVM/Compatibility.aiur new file mode 100644 index 000000000..5b3e1009a --- /dev/null +++ b/IxVM/IxVM/Compatibility.aiur @@ -0,0 +1,124 @@ +// Stage-one adapters. Appended before static reachability pruning. +// U8 and U32 are opaque library values; U64 is an array of opaque bytes. +// Raw inputs are checked at construction; word arithmetic preserves their ranges. +// This IxVM instantiation selects Goldilocks explicitly in IxVM/Program.lean. +// Shared UInt8, UInt32, UInt64 and Blake3 modules own these operations. +type U8 = UInt8::U8; +type U32 = UInt32::U32; +inline fn store(value: T) -> &T { &value } +inline fn load(pointer: &T) -> T { *pointer } + +inline fn io_get_info(channel: Field, key: [U8; 32]) -> (Field, Field) { + hint::<(Field, Field)>("ixvm.io.info", (channel, Blake3::address_to_fields(key))) +} + +// Binary long division using ordinary recursive calls. No quotient pointers are +// accepted as advice; division by zero follows Lean Nat.div/Nat.mod. +fn ordinary_div_mod(a: KLimbs, b: KLimbs) -> (KLimbs, KLimbs) { + let a = klimbs_normalize(a); + let b = klimbs_normalize(b); + match klimbs_is_zero(b) { + 1 => (store(ListNode::Nil), a), + _ => divide_grow(a, b), + } +} +fn divide_grow(a: KLimbs, b: KLimbs) -> (KLimbs, KLimbs) { + match klimbs_le(b, a) { + 0 => (store(ListNode::Nil), a), + _ => { + let (q, r) = divide_grow(a, klimbs_add(b, b)); + let q = klimbs_add(q, q); + match klimbs_le(b, r) { + 0 => (q, r), + _ => (klimbs_succ(q), klimbs_sub(r, b)), + } + }, + } +} + +fn stream_equal(a: ByteStream, b: ByteStream) -> Field { + match (load(a), load(b)) { + (ListNode::Nil, ListNode::Nil) => 1, + (ListNode::Cons(x, xs), ListNode::Cons(y, ys)) => { + match UInt8::to_field(x) - UInt8::to_field(y) { 0 => stream_equal(xs, ys), _ => 0 } + }, + _ => 0, + } +} +fn verify_serde(digest: [Field; 32]) -> () { + let digest = Blake3::address_from_fields(digest); + let (idx, len) = io_get_info(2, digest); + let bytes = read_byte_stream(2, idx, len); + Blake3::verify_bytes_against(bytes, digest); + let (constant, rest) = get_constant(bytes); + let ListNode::Nil = load(rest); + let output = put_constant(constant, store(ListNode::Nil)); + assert_eq!(stream_equal(bytes, output), 1, "Ixon serialization round trip"); + () +} +fn default_binding_addr() -> Addr { + store([UInt8::BYTE_31, UInt8::BYTE_85, UInt8::BYTE_77, UInt8::BYTE_180, + UInt8::BYTE_29, UInt8::BYTE_45, UInt8::BYTE_45, UInt8::BYTE_119, + UInt8::BYTE_193, UInt8::BYTE_226, UInt8::BYTE_45, UInt8::BYTE_253, + UInt8::BYTE_219, UInt8::BYTE_204, UInt8::BYTE_179, UInt8::BYTE_132, + UInt8::BYTE_203, UInt8::BYTE_39, UInt8::BYTE_130, UInt8::BYTE_190, + UInt8::BYTE_29, UInt8::BYTE_192, UInt8::BYTE_214, UInt8::BYTE_122, + UInt8::BYTE_139, UInt8::BYTE_43, UInt8::BYTE_225, UInt8::BYTE_95, + UInt8::BYTE_211, UInt8::BYTE_158, UInt8::BYTE_62, UInt8::BYTE_114]) +} +fn verify_constant(digest: [Field; 32]) -> () { + run_check(role_ctx_assumed(default_binding_addr()), store(Blake3::address_from_fields(digest))) +} +fn verify_transitive(digest: [Field; 32]) -> () { + run_check_transitive(role_ctx_assumed(default_binding_addr()), store(Blake3::address_from_fields(digest))) +} +fn check_primitives() -> () { + assert_eq!(UInt32::compact_field(UInt32::compact(UInt32::add(UInt32::MAX, UInt32::ONE))), 0, "u32 carry"); + assert_eq!(UInt32::compact_field(UInt32::compact(UInt32::add3(UInt32::MAX, UInt32::MAX, UInt32::MAX))), 4294967293, "three-word carry"); + assert_eq!(UInt32::less_than_fields(255, 256), 1, "u32 compare"); + assert_eq!(UInt32::less_than_fields(256, 255), 0, "u32 compare reverse"); + let a = store(ListNode::Cons([UInt8::BYTE_25,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0], store(ListNode::Nil))); + let b = store(ListNode::Cons([UInt8::BYTE_7,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0], store(ListNode::Nil))); + let (q,r) = ordinary_div_mod(a,b); + let ListNode::Cons(q0, qt) = load(q); + let ListNode::Nil = load(qt); + assert_eq!(UInt64::eq(q0, [UInt8::BYTE_3,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0]), 1, "division"); + let ListNode::Cons(r0, rt) = load(r); + let ListNode::Nil = load(rt); + assert_eq!(UInt64::eq(r0, [UInt8::BYTE_4,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0]), 1, "remainder"); + // Identity fast paths are omitted; the original fallback still proves + // reflexivity for closed and open terms, and preserves unused credit. + let empty = store(ListNode::Nil); + let zero_addr = store([UInt8::BYTE_0; 32]); + let rc = store(RoleCtxNode::Assumed(store(RoleTableNode::Mk( + zero_addr, + RoleMap::Node(1, role_nat_zero(), zero_addr, store(RoleMap::Nil), store(RoleMap::Nil)), + RBTreeMap::Node(1, zero_addr, role_nat_zero() + 1, store(RBTreeMap::Nil), store(RBTreeMap::Nil)), + RoleMap::Nil)), RBTreeMap::Nil)); + let prop = store(KExprNode::Srt(store(KLevelNode::Zero))); + let var = store(KExprNode::BVar(0)); + let ctx = store(ListNode::Cons(prop, empty)); + let lam = store(KExprNode::Lam(prop, var)); + assert_eq!(k_is_def_eq(rc, prop, prop, empty), 1, "sort reflexivity without pointer shortcut"); + assert_eq!(k_is_def_eq(rc, var, var, ctx), 1, "open reflexivity without pointer shortcut"); + assert_eq!(k_is_def_eq(rc, var, var, empty), 1, "context-free variable comparison"); + let head = store(KExprNode::BVar(1)); + let app = store(KExprNode::App(head, var)); + assert_eq!(k_is_def_eq(rc, app, app, empty), 1, "context-free application comparison"); + let other = store(KExprNode::App(var, var)); + assert_eq!(try_def_eq_app(rc, app, other, empty), 0, "different variable heads"); + assert_eq!(k_is_def_eq(rc, lam, lam, empty), 1, "lambda reflexivity without pointer shortcut"); + assert_eq!(k_is_def_eq_struct_bounded(rc, lam, lam, 3, empty), (1, 3), "structural credit"); + let str = store(KExprNode::Lit(KLiteral::Str(store(ListNode::Nil)))); + assert_eq!(k_is_def_eq_struct_go(rc, str, var, ctx), 0, "string expansion makes no progress"); + let zero = store(KExprNode::Lit(KLiteral::Nat(store(ListNode::Nil)))); + let ctor = store(KExprNode::Const(zero_addr, store(ListNode::Nil))); + assert_eq!(k_is_def_eq_struct_go(rc, zero, ctor, empty), 1, "natural literal expansion"); + () +} + +// Production claims bind the packed digest to the parsed claim bytes. +fn verify_claim(digest: [Field; 8]) -> () { run_claim(digest) } +fn verify_check_env(digest: [Field; 32]) -> () { + run_check_env(role_ctx_assumed(default_binding_addr()), store(Blake3::address_from_fields(digest)), Option::None) +} diff --git a/IxVM/IxVM/FunctionGroups.lean b/IxVM/IxVM/FunctionGroups.lean new file mode 100644 index 000000000..3b60f1a0d --- /dev/null +++ b/IxVM/IxVM/FunctionGroups.lean @@ -0,0 +1,124 @@ +/-! Grouping tuned for the certified Aiur layout using measured small and +production workloads. The search accounts for padded rows, main/auxiliary +columns and FFT work; see docs/formal-aiur-grouping-tuning.md. +Physical deduplication is resolved before grouping. Missing/inlined members +are skipped, and entrypoints retain singleton circuits. -/ + +namespace IxVM + +def functionGroups : List (String × List String) := [ + ("ixvm_group_00", ["KernelClaim::run_claim", "Blake3::next_layer", "IxonDeserialize::get_recursor", "Ingress::get_ci_dprj", "${\"name\":\"WordLists::lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"Ixon::MutConst\"}}]}", "Ingress::projection_addr", "Ingress::muts_member_at", "IxonSerialize::put_expr_list", "${\"name\":\"WordLists::length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"Ixon::MutConst\"}}]}", "IxonSerialize::put_recursor", "Ingress::get_ci_iprj", "Ingress::get_ci_rprj", "KernelCheck::build_flat_block", "KernelCheck::first_recr_parent_block", "KernelCheck::aux_from_recrs_walk_ex", "KernelClaim::run_check_transitive"]), + ("ixvm_group_01", ["IxByteStream::read_finite_byte_stream", "IxonDeserialize::get_address_list"]), + ("ixvm_group_02", ["IxByteStream::read_byte_stream", "WordLists::checked_depth_succ"]), + ("ixvm_group_03", ["${\"name\":\"WordLists::depth_checked\",\"types\":[\"field\"]}", "Blake3::pad_block"]), + ("ixvm_group_04", ["Blake3::compress_layer", "KernelWhnf::whnf_apply_beta", "KernelClaim::env_walk_all"]), + ("ixvm_group_05", ["Blake3::finish", "Convert::convert_inductive", "Ingress::get_ci_cprj", "KernelSubst::expr_lift_bvar", "KernelClaim::walk_leaves_owned", "KernelClaim::check_muts_components"]), + ("ixvm_group_06", ["UInt64::is_zero", "KernelCheck::is_unsafe_ci"]), + ("ixvm_group_07", ["Blake3::bytes_to_block", "KernelInferOnly::k_infer_only", "KernelDefEq::head_addr"]), + ("ixvm_group_08", ["Blake3::compress_block", "IxVMCompat::check_owned"]), + ("ixvm_group_09", ["UInt64::wrapping_succ", "KernelCanonicalCheck::canon_sord_then", "KernelCanonicalCheck::canon_sord_of_g", "KernelCanonicalCheck::canon_sord_lt_strong", "KernelCanonicalCheck::canon_sord_gt_strong", "KernelCanonicalCheck::canon_cmp_kuniv_list", "KernelCanonicalCheck::canon_sord_eq_strong", "KernelLevels::level_leq", "KernelLevels::nl_le", "KernelLevels::nlvars_any_offset_geq", "KernelLevels::nl_covers_var", "KernelLevels::nlvars_dominates", "KernelCheck::assert_occ_param_bvars", "KernelCheck::check_rec_major_spine", "KernelCheck::args_contain_bvar", "KernelCheck::spec_params_dom_prefix_match"]), + ("ixvm_group_10", ["IxonDeserialize::get_tagn4", "IxonDeserialize::get_tagn0", "KernelWhnf::apply_spine"]), + ("ixvm_group_11", ["IxonDeserialize::get_tagn_tail", "KernelLevels::nl_subsumption_walk", "KernelSubst::ctx_close_cut"]), + ("ixvm_group_12", ["IxonDeserialize::get_tagn_wide", "IxonSerialize::put_u64_list", "KernelSubst::expr_lift_let", "KernelLevels::bytestream_eq", "KernelCanonicalCheck::canon_member_num_ctors", "KernelCanonicalCheck::canon_ctor_ctx_entries", "KernelCanonicalCheck::canon_refine_classes", "KernelCanonicalCheck::canon_cmp_kexpr_ctx", "KernelCanonicalCheck::canon_ctx_class_idx", "${\"name\":\"Lists::length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", "KernelCanonicalCheck::canon_group_consec", "KernelCheck::spec_params_ptr_eq", "KernelCheck::level_list_struct_eq", "KernelCheck::flat_find_pos", "KernelClaim::get_opt_rule_list_masked", "KernelClaim::get_opt_ctor_entry_list_masked"]), + ("ixvm_group_13", ["IxonDeserialize::get_u64_le", "KernelEval::run_eval", "IxonDeserialize::get_axiom", "IxonDeserialize::get_quotient", "IxonDeserialize::get_quot_kind", "KernelNatPrim::utf8_validate", "KernelNatPrim::utf8_decode_one", "KernelWhnf::try_quot_ind", "KernelNatPrim::walk_char_list_bytes", "KernelNatPrim::try_str_back", "KernelInfer::try_str_dec_eq", "KernelNatPrim::try_reduce_bit_vec_ult", "KernelNatPrim::int_bdiv_prim", "KernelCanonicalCheck::canon_build_ctx_members", "KernelCanonicalCheck::canon_cmp_member_ctx", "KernelCanonicalCheck::canon_cmp_u64_lex"]), + ("ixvm_group_14", ["UInt64::add", "IxonSerialize::all_telescope_count", "IxonSerialize::put_mut_const", "KernelKlimbs::klimbs_succ", "KernelWhnf::try_struct_eta_iota", "KernelWhnf::struct_scan_ctors", "KernelNatPrim::try_nat_binop_addr", "KernelLevels::klimbs_eq", "KernelNatPrim::try_reduce_decide_bitvec_lt", "KernelDefEq::try_eta_expand", "KernelInfer::check_no_dep_data_field_if_prop", "KernelCanonicalCheck::canon_member_ci", "KernelCanonicalCheck::canon_insert_sorted", "KernelCanonicalCheck::canon_cmp_member_same_kind_ctx", "KernelCheck::check_nested_ctors_positivity", "KernelCheck::detect_aux_from_recrs_ex"]), + ("ixvm_group_15", ["IxonDeserialize::read_byte", "KernelDefEq::k_is_def_eq_core"]), + ("ixvm_group_16", ["KernelClaim::get_opt_addr", "KernelLevels::level_imax", "KernelNatPrim::nat_shift_right_addr", "KernelNatPrim::bit_vec_ult_addr", "KernelNatPrim::try_match_nat_add", "KernelInfer::peel_n_alls_whnf", "KernelCheck::build_apply_bvars_decreasing"]), + ("ixvm_group_17", ["KernelClaim::run_check", "KernelWhnf::whnf_nd_apply_beta", "KernelWhnf::try_prim_dispatch"]), + ("ixvm_group_18", ["Ingress::get_ci", "KernelCheck::check_const", "KernelCheck::apply_ihs_full", "KernelClaim::check_muts_member_at", "KernelClaim::const_idxs_of", "KernelClaim::load_assumption_tree"]), + ("ixvm_group_19", ["Ingress::load_verified_constant", "IxonDeserialize::get_constant", "IxonDeserialize::get_mut_const_list", "KernelDefEq::k_is_def_eq_slow2", "KernelClaim::get_mut_entry_list_inner", "${\"name\":\"WordLists::lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"Ixon::Constructor\"}}]}"]), + ("ixvm_group_20", ["Blake3::verify_bytes_against", "IxonSerialize::put_constant", "KernelDefEq::is_defn_or_thm"]), + ("ixvm_group_21", ["IxonDeserialize::get_mut_const", "KernelWhnf::k_synth_gate", "KernelKlimbs::klimbs_mul", "KernelKlimbs::klimbs_div_mod", "IxVMCompat::ordinary_div_mod", "KernelKlimbs::klimbs_pow", "KernelKlimbs::klimbs_land", "KernelNatPrim::try_str_dispatch", "KernelNatPrim::klimbs_scalar_value", "KernelInfer::str_dec_eq_build", "KernelNatPrim::bitvec_of_nat_args_direct", "KernelNatPrim::try_native_dispatch", "KernelNatPrim::try_int_prim_dispatch", "KernelNatPrim::int_ediv_prim", "KernelCheck::check_eq_type", "KernelCanonicalCheck::canon_sort_loop"]), + ("ixvm_group_22", ["IxonDeserialize::get_definition", "UInt64::to_field", "KernelCheck::safe_refs_only"]), + ("ixvm_group_23", ["IxonDeserialize::unpack_def_kind_safety", "Ingress::defn_is_unsafe_ci", "${\"name\":\"RBTreeMap::rbtree_map_balance_fix\",\"types\":[\"field\"]}", "KernelClaim::env_walk_leaves"]), + ("ixvm_group_24", ["IxonDeserialize::get_expr", "IxonDeserialize::get_u64_list", "KernelCheck::validate_expr_well_scoped"]), + ("ixvm_group_25", ["IxonDeserialize::get_app_telescope", "KernelSubst::expr_inst_many_bvar"]), + ("ixvm_group_26", ["IxonDeserialize::get_lam_telescope", "KernelInfer::const_type_of", "KernelSubst::ctx_seek_cut", "${\"name\":\"RBTreeMap::rbtree_map_balance\",\"types\":[\"field\"]}"]), + ("ixvm_group_27", ["IxonDeserialize::get_lam_mode", "KernelSubst::expr_has_bvar_at"]), + ("ixvm_group_28", ["IxonDeserialize::binder_contract_from_bits", "KernelNatPrim::system_platform_num_bits_addr", "KernelNatPrim::cleanup_nat_offset_major", "KernelDefEq::nat_offset_of", "KernelCheck::check_param_agreement_go", "KernelCheck::walk_fields_classify"]), + ("ixvm_group_29", ["IxonDeserialize::value_contract_from_bits", "KernelNatPrim::is_bitvec_prim_addr", "KernelWhnf::try_reduce_projection_definition", "KernelDefEq::try_unit_like"]), + ("ixvm_group_30", ["IxonDeserialize::get_all_telescope", "KernelClaim::addr_set_build", "${\"name\":\"RBTreeMap::rbtree_map_insert\",\"types\":[\"field\"]}"]), + ("ixvm_group_31", ["IxonDeserialize::get_all_mode", "Convert::convert_expr"]), + ("ixvm_group_32", ["IxonDeserialize::get_expr_let", "IxonDeserialize::get_constant_info_by_variant", "IxonDeserialize::get_recursor_proj", "IxonDeserialize::get_univ", "KernelLevels::level_normalize"]), + ("ixvm_group_33", ["IxonDeserialize::get_inductive", "Ingress::load_verified_blob", "Convert::count_ctors", "KernelKlimbs::klimbs_mul_single", "KernelCanonicalCheck::check_canonical_block", "KernelCheck::peer_agree_walk", "KernelCheck::ind_is_solo", "KernelCheck::flat_originals_walk", "KernelCheck::find_peer_recursor_with_spec", "KernelClaim::env_walk"]), + ("ixvm_group_34", ["IxonDeserialize::assert_wire_bool", "KernelInferOnly::io_peel_params_subst", "KernelDefEq::unfold_a_and_loop", "KernelDefEq::k_is_def_eq_structure_tree_app", "KernelCheck::check_inductive_shape", "KernelCheck::get_result_sort_level", "${\"name\":\"Lists::reverse\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"KernelTypes::KExprNode\"}}}}]}", "KernelCheck::build_all_minors"]), + ("ixvm_group_35", ["IxonDeserialize::get_constructor_list", "${\"name\":\"WordLists::length_u64\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"Ixon::Expr\"}}}}]}", "Bytes::address_eq_tail"]), + ("ixvm_group_36", ["IxonDeserialize::get_constructor", "KernelSubst::expr_lbr_let", "KernelLevels::nl_add_var", "KernelNatPrim::nat_pred_addr", "KernelInferOnly::ensure_sort_only", "KernelNatPrim::try_nat_binop_dispatch", "KernelKlimbs::klimbs_shl_limbs", "KernelDefEq::compare_struct_fields", "KernelInfer::k_infer_lit", "KernelInfer::k_infer_proj", "KernelClaim::get_reveal_rule_list_inner"]), + ("ixvm_group_37", ["IxonDeserialize::get_recursor_rule_list", "Convert::bytes_to_u64_limb", "KernelWhnf::nat_lit_to_ctor_or_self", "UInt64::eq", "KernelCheck::compute_k_target", "KernelCheck::is_rec_field_peel", "KernelCheck::ctors_before_pos", "KernelCheck::populate_rules"]), + ("ixvm_group_38", ["IxonDeserialize::get_constructor_proj", "Convert::ctor_at", "KernelLevels::level_max", "KernelLevels::level_max_go", "KernelWhnf::prim_family", "KernelKlimbs::klimbs_sub", "KernelWhnf::collect_spine_of_ctor", "KernelWhnf::struct_block_member_addrs", "UInt64::mul", "KernelCheck::check_recursor_member", "KernelCheck::muts_indc_count_is_one", "KernelCheck::check_recursor_canonical_full", "KernelCheck::build_rec_type_from", "KernelEval::eval_output", "KernelClaim::get_mut_entry", "KernelClaim::check_recr_rules"]), + ("ixvm_group_39", ["IxonDeserialize::get_expr_list", "KernelClaim::leaf_hash", "KernelClaim::addr_set_member"]), + ("ixvm_group_40", ["IxonDeserialize::get_univ_list", "KernelCheck::peel_n_foralls", "KernelNatPrim::str_lit_to_ctor_app_or_self", "KernelDefEq::lazy_delta_a_const_b_proj", "KernelDefEq::lazy_delta_b_const_a_proj"]), + ("ixvm_group_41", ["IxonDeserialize::get_tagn2", "IxonSerialize::put_recursor_proj", "KernelLevels::level_list_inst"]), + ("ixvm_group_42", ["IxonDeserialize::build_succ_chain", "Ingress::build_recur_addrs_walk", "KernelLevels::level_equal", "KernelCanonicalCheck::canon_muts_has_kind", "KernelCheck::is_muts_block", "KernelClaim::check_muts_all"]), + ("ixvm_group_43", ["Ingress::load_constant_hint", "IxonSerialize::put_address", "KernelWhnf::whnf_nd_const_head"]), + ("ixvm_group_44", ["Convert::convert_definition", "IxonSerialize::put_refs", "KernelClaim::env_walk_refs"]), + ("ixvm_group_45", ["Convert::convert_univ", "IxonSerialize::put_tagn4", "KernelSubst::lbr_dec"]), + ("ixvm_group_46", ["Convert::convert_univ_idxs", "KernelClaim::const_idxs_expr"]), + ("ixvm_group_47", ["KernelNatPrim::utf8_cont", "Convert::convert_axiom", "Convert::convert_quotient", "Ingress::defn_member_recur_addrs", "IxonSerialize::put_tagn_tail", "IxonSerialize::put_tagn_wide", "IxonSerialize::put_u64_le", "IxonSerialize::put_expr", "IxonSerialize::app_telescope_count", "IxonSerialize::put_app_telescope", "IxonSerialize::lam_telescope_count", "KernelNatPrim::utf8_encode_prepend", "KernelCheck::aux_already_in", "KernelCheck::find_peer_rec_spec_walk", "KernelClaim::get_reveal_info", "KernelClaim::get_reveal_mut_const_info"]), + ("ixvm_group_48", ["Convert::bytes_to_limbs", "KernelWhnf::whnf_proj_head", "KernelWhnf::whnf_nd_proj_head", "KernelCheck::check_ctor_return_type"]), + ("ixvm_group_49", ["Convert::skip_bytes", "KernelLevels::level_inst_params", "KernelNatPrim::nat_xor_addr"]), + ("ixvm_group_50", ["Ingress::build_recur_addrs", "KernelSubst::lbr_min", "KernelCheck::assert_safety"]), + ("ixvm_group_51", ["UInt64::from_field", "IxonSerialize::put_sharing", "IxonSerialize::put_univs", "IxonSerialize::put_univ_list", "KernelNatPrim::mk_nat_lit", "KernelKlimbs::klimbs_is_zero", "KernelWhnf::find_rule", "KernelWhnf::struct_is_rec", "KernelInfer::k_infer_let_start", "KernelCanonicalCheck::canon_refine_one", "KernelCanonicalCheck::canon_ins_sort", "KernelCheck::flat_member_at", "KernelCheck::collect_n_doms_whnf", "KernelCheck::collect_index_doms", "KernelCheck::list_lift_each", "KernelCheck::build_ctor_app_params"]), + ("ixvm_group_52", ["IxonSerialize::put_tagn0", "KernelCheck::validate_univ_params_list", "KernelDefEq::level_list_eq"]), + ("ixvm_group_53", ["${\"name\":\"WordLists::length_u64\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", "IxonSerialize::put_univ", "IxonSerialize::univ_succ_count", "IxonSerialize::put_mut_const_list", "IxonSerialize::put_constructor_list", "${\"name\":\"WordLists::length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"Ixon::RecursorRule\"}}]}", "IxonSerialize::put_recursor_rule_list", "IxonSerialize::put_axiom", "IxonSerialize::put_quotient", "KernelKlimbs::klimbs_lor", "KernelKlimbs::klimbs_xor_op", "KernelCanonicalCheck::canon_cmp_klimbs_tail", "KernelCheck::extract_aux_spec_params_from_rec", "KernelCheck::extract_aux_occ_us", "KernelClaim::get_ctor_entry", "KernelClaim::check_ctor_entries"]), + ("ixvm_group_54", ["IxonSerialize::put_lam_telescope", "IxonSerialize::put_all_telescope", "IxonSerialize::put_definition", "IxonSerialize::put_inductive", "${\"name\":\"WordLists::length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"Ixon::Constructor\"}}]}", "IxonSerialize::put_constructor", "Convert::convert_constructor", "Convert::convert_recursor", "KernelCanonicalCheck::canon_indc_positions", "KernelCheck::check_block_peer_param_agreement", "KernelCheck::build_rec_type", "KernelCheck::build_all_motives_walk", "KernelCheck::build_all_minors_walk", "KernelCheck::build_minor_doms", "KernelCheck::flat_find_matching", "KernelClaim::const_idxs_muts"]), + ("ixvm_group_55", ["IxonSerialize::put_lam_mode", "IxonSerialize::binder_contract_code", "IxonSerialize::value_contract_code", "IxonSerialize::put_all_mode", "IxonSerialize::put_tagn2", "IxonSerialize::pack_def_kind_safety", "IxonSerialize::put_quot_kind", "KernelNatPrim::int_emod_prim", "KernelCanonicalCheck::canon_build_ctx_classes", "KernelCanonicalCheck::canon_cmp_kuniv", "KernelCanonicalCheck::canon_ctx_cmp_addr", "KernelCanonicalCheck::canon_cmp_klimbs", "KernelCanonicalCheck::canon_classes_eq", "KernelCheck::extract_aux_spec_params", "KernelCheck::spec_params_lower", "KernelCheck::apply_spec_params_lifted"]), + ("ixvm_group_56", ["IxonSerialize::put_address_list", "KernelLevels::level_max_offsets", "KernelWhnf::whnf_get_ctor_or_none", "KernelKlimbs::klimbs_le", "KernelCheck::addr_list_contains", "KernelLevels::nl_le_vars", "KernelCheck::check_parent_inductive_shape", "KernelCheck::check_large_prop_ctor", "KernelCheck::build_peer_recs", "${\"name\":\"Lists::length\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"KernelTypes::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"KernelTypes::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}", "KernelCheck::peel_motive_params_subst", "KernelCheck::list_lift_indices", "KernelEval::eval_nf_spine", "KernelClaim::get_opt_u64_masked"]), + ("ixvm_group_57", ["IxonSerialize::univ_succ_base", "IxonSerialize::put_recursor_rule", "KernelNatPrim::str_lit_delta_step", "KernelWhnf::se_addr_in", "KernelInferOnly::str_addr_io", "KernelWhnf::apply_n_projs", "KernelNatPrim::str_lit_to_ctor", "KernelNatPrim::list_nil_addr", "KernelNatPrim::list_cons_addr", "KernelNatPrim::char_type_addr", "UInt64::and", "UInt64::or", "KernelNatPrim::try_str_to_byte_array", "KernelNatPrim::try_reduce_subtype_val", "KernelInfer::dec_finish", "KernelNatPrim::try_int_prim_second"]), + ("ixvm_group_58", ["IxonSerialize::put_constant_info", "KernelLevels::level_explicit_val", "KernelNatPrim::nat_mul_addr", "KernelNatPrim::nat_gcd_addr", "KernelWhnf::try_reduce_fin_val_decidable_rec", "KernelKlimbs::klimbs_mul_outer", "KernelInfer::dec_dispatch_le_eq", "KernelInfer::dec_build_proof", "KernelCheck::peel_leading_foralls_acc", "KernelClaim::const_idxs_ctors"]), + ("ixvm_group_59", ["IxonSerialize::put_constructor_proj", "Convert::convert_rec_rules", "KernelCheck::validate_univ_params_seen", "KernelNatPrim::try_nat_linear_rec", "KernelCanonicalCheck::canon_kind_ord", "KernelEval::eval_nf"]), + ("ixvm_group_60", ["Blake3::bytes_to_addr", "${\"name\":\"RBTreeMap::rbtree_map_ins\",\"types\":[\"field\"]}", "${\"name\":\"RBTreeMap::rbtree_map_lookup_or_default\",\"types\":[\"field\"]}"]), + ("ixvm_group_61", ["KernelInfer::const_num_lvls", "KernelDefEq::k_is_def_eq_struct_spend"]), + ("ixvm_group_62", ["KernelInfer::k_ensure_sort", "KernelInfer::types_lookup", "KernelSubst::ctx_next_cut"]), + ("ixvm_group_63", ["KernelInfer::k_infer", "KernelSubst::expr_glb_walk"]), + ("ixvm_group_64", ["KernelSubst::expr_lbr", "${\"name\":\"Lists::concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"KernelTypes::KExprNode\"}}}}]}"]), + ("ixvm_group_65", ["KernelSubst::lbr_max", "KernelNatPrim::bit_vec_to_nat_addr", "KernelNatPrim::decidable_decide_addr"]), + ("ixvm_group_66", ["KernelInfer::k_infer_core", "KernelWhnf::whnf_struct_core_spine", "KernelClaim::node_hash"]), + ("ixvm_group_67", ["KernelSubst::expr_lift", "KernelSubst::expr_inst_many"]), + ("ixvm_group_68", ["KernelSubst::expr_lift_walk", "KernelDefEq::k_is_def_eq"]), + ("ixvm_group_69", ["KernelLevels::level_reduce", "KernelCheck::build_param_lvls_range", "${\"name\":\"Lists::lookup_or_default\",\"types\":[\"field\"]}", "KernelCheck::peel_leading_foralls", "KernelCheck::apply_indices_in_conclusion", "KernelCheck::wrap_lams", "KernelClaim::get_opt_def_kind_masked", "KernelClaim::get_opt_addr_masked", "KernelClaim::get_opt_bool_masked", "KernelClaim::get_opt_quot_kind_masked", "KernelClaim::check_opt_def_kind", "KernelClaim::check_opt_quot_kind"]), + ("ixvm_group_70", ["KernelLevels::level_struct_eq", "KernelNatPrim::string_utf8_byte_size_addr", "KernelCheck::wrap_foralls"]), + ("ixvm_group_71", ["KernelLevels::level_max_subsumes", "KernelLevels::glist_cmp", "KernelDefEq::unfold_b_and_loop", "KernelDefEq::unfold_both_and_loop", "KernelDefEq::try_eta_swap", "KernelInfer::check_prop_field_if_prop", "KernelCheck::assert_first_args_are_param_bvars", "KernelCheck::peel_n_lams_collect"]), + ("ixvm_group_72", ["KernelLevels::level_offset_of", "KernelLevels::nl_add_const", "KernelInfer::infer_let_local_cutoff", "KernelInfer::infer_let_lookup_value", "KernelCheck::check_field_universes_skip_params", "KernelCheck::check_positivity_fields", "KernelCheck::build_major_indices", "KernelCheck::build_apply_field_bvars", "KernelCheck::count_foralls_body"]), + ("ixvm_group_73", ["KernelLevels::level_is_not_zero", "KernelNatPrim::is_int_prim_addr", "KernelWhnf::try_iota", "KernelDefEq::is_unit_like_type", "KernelCheck::check_positivity_aug", "KernelCheck::canonical_rules_at_pos"]), + ("ixvm_group_74", ["KernelLevels::expr_inst_levels_walk", "KernelClaim::const_idxs_exprs"]), + ("ixvm_group_75", ["KernelTypes::collect_spine", "KernelInfer::k_check"]), + ("ixvm_group_76", ["${\"name\":\"Lists::snoc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"KernelTypes::KExprNode\"}}}}]}", "KernelSubst::expr_lower"]), + ("ixvm_group_77", ["KernelInfer::k_infer_app_spine_loop", "KernelSubst::expr_has_bvar_at_binder"]), + ("ixvm_group_78", ["KernelSubst::has_bvar_in_range_binder", "KernelSubst::expr_inst1_bvar", "KernelDefEq::k_is_def_eq_struct_safe"]), + ("ixvm_group_79", ["KernelSubst::has_bvar_in_range_let", "KernelSubst::expr_inst_many_let", "KernelLevels::normalize_imax_dispatch", "KernelLevels::nlvars_max_offset", "KernelLevels::nlvars_subsume", "KernelSubst::expr_has_bvar_at_let", "KernelSubst::expr_inst1_let", "KernelWhnf::try_quot_iota", "KernelWhnf::quot_lift_addr_iota", "KernelWhnf::try_quot_lift", "KernelWhnf::quot_extract_arg", "KernelWhnf::quot_ctor_addr_iota", "KernelWhnf::quot_ind_addr_iota", "KernelNatPrim::build_succ_offset", "KernelWhnf::se_mentions", "KernelCanonicalCheck::canon_cmp_kexpr_node_ctx"]), + ("ixvm_group_80", ["KernelSubst::expr_inst_many_walk", "KernelSubst::expr_lower_walk"]), + ("ixvm_group_81", ["KernelDefEq::de_args", "KernelWhnf::peel_beta"]), + ("ixvm_group_82", ["Bytes::address_eq", "KernelWhnf::whnf"]), + ("ixvm_group_83", ["KernelLevels::nl_eq", "KernelLevels::nl_subsume_entry", "KernelNatPrim::nat_sub_addr", "KernelNatPrim::nat_div_addr", "KernelNatPrim::try_extract_nat_app", "KernelWhnf::replace_spine_major", "KernelDefEq::try_unfold_head", "KernelCheck::projection_addr_ctor", "KernelCheck::peel_ctor_params_subst", "KernelCheck::build_rule_rhs"]), + ("ixvm_group_84", ["KernelLevels::nl_skip_empty", "KernelLevels::normalize_aux", "IxVMCompat::divide_grow"]), + ("ixvm_group_85", ["KernelLevels::nlvars_eq", "KernelLevels::glist_ordered_insert", "KernelWhnf::se_parent_addr", "KernelNatPrim::nat_zero_addr", "KernelWhnf::se_scan_fields", "KernelInferOnly::nat_addr_io", "KernelNatPrim::mk_bool", "KernelNatPrim::divmod_64u", "KernelNatPrim::utf8_last_codepoint", "KernelNatPrim::utf8_last_go", "KernelNatPrim::byte_array_empty_addr", "KernelNatPrim::np_whnf_inner_bv", "KernelNatPrim::mk_nat_literal_64", "KernelDefEq::k_is_def_eq_struct_go", "KernelCheck::build_rec_lvls_list", "${\"name\":\"Lists::snoc\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"KernelTypes::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"KernelTypes::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}"]), + ("ixvm_group_86", ["KernelLevels::nl_add_const_go", "KernelWhnf::try_nat_dispatch_prewhnf", "KernelInfer::try_dec_dispatch", "KernelInfer::dec_rewrite_lt_to_le", "KernelCheck::quot_type_addr", "${\"name\":\"Lists::concat\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\"]}}]}", "KernelCheck::check_valid_ind_app", "KernelEval::eval_body", "KernelClaim::def_kind_tag", "KernelClaim::check_opt_u64", "KernelClaim::check_opt_expr_addr", "KernelClaim::check_opt_bool", "KernelClaim::check_opt_recr_rules", "KernelClaim::check_opt_addr", "KernelClaim::check_opt_ctor_entries", "KernelClaim::run_contains"]), + ("ixvm_group_87", ["KernelLevels::nlvars_add", "KernelWhnf::try_k_synth_iota", "KernelNatPrim::mk_nat_offset_stuck", "KernelNatPrim::klimbs_from_g", "KernelWhnf::fin_addr", "UInt64::xor", "KernelInfer::is_int_dec_prim_addr", "KernelInfer::try_extract_int", "KernelInfer::normalize_int_dec_rebuild", "KernelNatPrim::try_extract_int_prim", "KernelLevels::literal_eq", "KernelCheck::check_quot", "KernelCheck::check_large_walk_fields", "KernelCheck::kexpr_struct_eq", "KernelCheck::subst_param_for", "KernelCheck::ctor_subst_param_for"]), + ("ixvm_group_88", ["KernelLevels::glist_subset", "KernelDefEq::delta_rank", "KernelInfer::k_infer_let_env", "KernelInfer::k_infer_let_env_rebase", "KernelCheck::build_major_params"]), + ("ixvm_group_89", ["KernelLevels::glist_eq_len", "KernelDefEq::slow2_after_delta", "KernelDefEq::k_is_def_eq_struct", "KernelCheck::peel_n_foralls_with_types", "${\"name\":\"Lists::reverse_acc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"KernelTypes::KExprNode\"}}}}]}"]), + ("ixvm_group_90", ["KernelDefEq::k_is_def_eq_slow", "KernelSubst::expr_inst1"]), + ("ixvm_group_91", ["KernelWhnf::whnf_nd", "KernelDefEq::try_proof_irrel", "KernelClaim::env_walk_refs_all"]), + ("ixvm_group_92", ["KernelNatPrim::nat_succ_addr", "KernelNatPrim::nat_add_addr", "KernelNatPrim::string_append_addr", "KernelNatPrim::subtype_val_addr", "KernelInfer::int_dec_le_addr_dec", "KernelInfer::int_dec_eq_addr_dec", "KernelInfer::int_dec_lt_addr_dec", "KernelNatPrim::int_add_addr", "KernelNatPrim::int_mul_addr", "KernelNatPrim::int_neg_addr", "KernelNatPrim::int_emod_addr", "KernelNatPrim::int_ediv_addr", "KernelNatPrim::int_bmod_addr", "KernelNatPrim::int_bdiv_addr", "KernelNatPrim::int_nat_abs_addr", "KernelNatPrim::int_pow_addr"]), + ("ixvm_group_93", ["KernelNatPrim::nat_mod_addr", "KernelNatPrim::nat_pow_addr", "KernelNatPrim::nat_beq_addr", "KernelNatPrim::string_of_list_addr", "KernelNatPrim::string_back_addr", "KernelNatPrim::string_legacy_back_addr", "KernelNatPrim::string_to_byte_array_addr", "KernelNatPrim::string_dec_eq_addr", "KernelNatPrim::punit_size_of_1_addr", "KernelNatPrim::reduce_bool_addr", "KernelNatPrim::reduce_nat_addr", "KernelCanonicalCheck::canon_ord_then"]), + ("ixvm_group_94", ["KernelNatPrim::nat_ble_addr", "KernelNatPrim::nat_land_addr", "KernelNatPrim::nat_lor_addr", "KernelNatPrim::nat_shift_left_addr", "KernelInfer::nat_dec_le_addr_dec", "KernelInfer::nat_dec_eq_addr_dec", "KernelInfer::nat_dec_lt_addr_dec", "KernelNatPrim::int_sub_addr"]), + ("ixvm_group_95", ["KernelNatPrim::is_str_prim_addr", "KernelNatPrim::is_native_prim_addr", "KernelDefEq::try_same_proj_head_app", "KernelInfer::infer_let_drop_unused"]), + ("ixvm_group_96", ["KernelInfer::is_dec_prim_addr", "KernelInfer::k_infer_let_env_core", "KernelInfer::peel_field_loop", "KernelCheck::assert_return_head_is_parent"]), + ("ixvm_group_97", ["KernelWhnf::whnf_spine", "KernelDefEq::lazy_delta_both_proj", "KernelInfer::infer_let_materialize"]), + ("ixvm_group_98", ["KernelWhnf::whnf_with_spine", "KernelDefEq::k_def_eq_rebase"]), + ("ixvm_group_99", ["KernelWhnf::whnf_const_head", "KernelWhnf::whnf_iota_major", "KernelDefEq::slow2_eager_fallback", "KernelCheck::check_inductive_shape_ctors"]), + ("ixvm_group_100", ["KernelWhnf::projection_definition_info", "KernelDefEq::k_is_def_eq_slow_nd_after_core", "KernelDefEq::delta_unfold", "KernelCheck::expr_mentions_block"]), + ("ixvm_group_101", ["KernelCanonicalCheck::canon_cprj_addr", "KernelNatPrim::is_nat_succ_ih_step", "KernelKlimbs::klimbs_add", "KernelKlimbs::klimbs_normalize", "UInt64::sub_with_borrow", "KernelDefEq::compute_iprj_addr", "KernelCheck::rec_to_parent_addr", "KernelInferOnly::io_peel_field_loop", "KernelCheck::assert_lvls_are_params", "${\"name\":\"Lists::length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"KernelTypes::KRecRule\"}}]}", "KernelCheck::is_large_eliminator", "KernelCheck::build_flat_own_params", "KernelCheck::flat_find_pos_kind", "KernelCheck::build_all_motives", "KernelCheck::build_motive_type_flat", "KernelClaim::walk_refs_transitive"]), + ("ixvm_group_102", ["${\"name\":\"Lists::take\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"KernelTypes::KExprNode\"}}}}]}", "KernelSubst::ctx_trim"]), + ("ixvm_group_103", ["KernelNatPrim::try_extract_nat", "KernelDefEq::is_prop_type", "KernelInfer::infer_let_lookup_type", "KernelInfer::is_inductive_prop", "KernelCheck::check_param_agreement", "KernelCheck::list_any_mentions_block", "KernelCheck::check_field_universes", "KernelCheck::check_field_universes_inner", "KernelCheck::check_positivity", "KernelCheck::is_rec_field"]), + ("ixvm_group_104", ["KernelKlimbs::klimbs_add_carry", "KernelKlimbs::klimbs_sub_borrow", "KernelWhnf::whnf_struct_core_proj", "KernelDefEq::lazy_delta_step_const_const", "KernelDefEq::try_lazy_delta_app", "KernelSubst::expr_glb_let", "KernelCheck::build_minor_at_depth", "KernelCheck::build_ih_doms", "KernelCheck::compare_rules"]), + ("ixvm_group_105", ["KernelKlimbs::klimbs_dec", "KernelWhnf::se_peel_tol", "KernelNatPrim::char_of_nat_addr", "KernelNatPrim::split_u32", "KernelKlimbs::divmod_256", "KernelKlimbs::klimbs_div", "KernelKlimbs::klimbs_mod", "KernelKlimbs::klimbs_gcd", "KernelKlimbs::klimbs_shl", "KernelKlimbs::klimbs_shr", "KernelNatPrim::mk_nat_binop_stuck", "KernelNatPrim::char_lit_codepoint", "KernelNatPrim::utf8_groups", "KernelNatPrim::int_add_prim", "KernelCheck::count_foralls_at_least", "KernelCheck::all_bvars_in_args"]), + ("ixvm_group_106", ["KernelNatPrim::build_char_list", "KernelNatPrim::try_nat_offset_dispatch", "KernelNatPrim::char_lit_codepoint_syn", "KernelNatPrim::try_bitvec_dispatch", "KernelWhnf::bitvec_prep_spine", "KernelNatPrim::bv_to_nat_via", "KernelNatPrim::bitvec_prep_spine_ult", "KernelNatPrim::mk_nat_one", "KernelNatPrim::system_platform_get_num_bits_addr", "KernelNatPrim::check_native_bool", "KernelNatPrim::check_native_nat", "KernelInfer::try_normalize_int_decidable", "KernelInfer::intern_int_lit", "KernelInfer::nat_not_le_of_not_ble_eq_true_addr_dec", "KernelNatPrim::mk_int_prim", "KernelNatPrim::int_bmod_prim"]), + ("ixvm_group_107", ["KernelWhnf::decidable_rec_addr", "KernelNatPrim::bool_false_addr", "KernelNatPrim::bool_true_addr", "KernelInfer::eq_refl_addr_dec", "KernelInfer::decidable_is_true_addr_dec", "KernelNatPrim::bit_vec_of_nat_addr", "KernelNatPrim::lt_lt_addr", "KernelNatPrim::bit_vec_addr", "KernelInfer::int_of_nat_addr_dec", "KernelInfer::int_neg_succ_addr_dec", "KernelInfer::bool_type_addr_dec", "KernelInfer::nat_le_of_ble_eq_true_addr_dec", "KernelInfer::nat_eq_of_beq_eq_true_addr_dec", "KernelInfer::nat_ne_of_beq_eq_false_addr_dec", "KernelInfer::decidable_is_false_addr_dec", "KernelCheck::eq_type_addr"]), + ("ixvm_group_108", ["KernelWhnf::whnf_struct_core_const", "KernelDefEq::try_unfold_proj_app", "KernelCheck::caddr_is_peer", "KernelCheck::check_rec_rules_wellscoped", "KernelClaim::const_idxs_rules", "KernelClaim::run_check_env"]), + ("ixvm_group_109", ["KernelDefEq::try_def_eq_nat", "KernelDefEq::lazy_delta_loop"]), + ("ixvm_group_110", ["KernelDefEq::k_is_def_eq_structure_tree", "KernelClaim::parse_atree_body"]), + ("ixvm_group_111", ["KernelCanonicalCheck::canon_cmp_kliteral", "KernelCanonicalCheck::canon_cmp_bytes", "KernelCanonicalCheck::canon_cmp_ctor_range_ctx", "KernelCanonicalCheck::canon_cmp_ctor_pair_ctx", "KernelCanonicalCheck::canon_cmp_krec_rule_list_ctx", "KernelCanonicalCheck::canon_cmp_krec_rule_ctx", "KernelCanonicalCheck::canon_group_walk", "KernelCanonicalCheck::canon_all_singleton", "KernelCanonicalCheck::canon_flatten", "KernelLevels::nl_covers_const", "KernelClaim::get_ctor_entry_list_inner", "KernelClaim::get_reveal_ctor_info", "KernelClaim::run_reveal", "KernelClaim::expr_addr", "KernelClaim::check_mut_const", "KernelClaim::check_ctor_entry"]), +] + +end IxVM diff --git a/IxVM/IxVM/Main.lean b/IxVM/IxVM/Main.lean new file mode 100644 index 000000000..662419b71 --- /dev/null +++ b/IxVM/IxVM/Main.lean @@ -0,0 +1,247 @@ +import IxVM +import IxVM.FunctionGroups +import Aiur.Execution.Encode +import Aiur.Optimized.Program +import Aiur.Trace.Export +import Aiur.SourceBundle +import IxVM.PropagationBench + +/-! Experimental stage-one port of IxVM. Prepare source, export bytecode and +typed data hints, execute Rust, or report circuit widths with `stats`, +`stats-no-propagation`, or `stats-reference`. +`export-trace` includes companion population plans for optimized function rows. +No proof generation runs here. -/ +namespace IxVM.Cli +open Aiur Lean + +private def sourcePath (relative : String) : IO System.FilePath := do + for base in ["IxVM", "IxVM/IxVM"] do + let path := System.FilePath.mk base / relative + if ← path.pathExists then return path + throw (IO.userError s!"cannot locate IxVM/{relative}; run from the Ix repository or IxVM package") + +private instance : ToJson F := ⟨fun x => toJson x.val⟩ +private instance : FromJson F := ⟨fun json => (fun n : Nat => (n : F)) <$> fromJson? json⟩ + +structure Serialized where + address : Array Nat + bytes : Array Nat + hint : Nat + deriving FromJson +structure Fixture where + format : String + name : String + address : Array Nat + addressHex : String + invalidProof : Serialized + constants : Array Serialized + blobs : Array Serialized + roles : Array Serialized := #[] + deriving FromJson + +private def scalar (n : Nat) : Execution.DataValue F := .field n +private def array (ns : Array Nat) : Execution.DataValue F := .array .field (ns.toList.map scalar) +private def tuple (vs : List (Execution.DataValue F)) : Execution.DataValue F := .tuple vs + +/-- The old IOBuffer becomes an explicit, typed dataset: address → (offset, +length), and (channel, offset) → byte. The Rust host prepares dense byte rows +as immutable vectors; the same entries remain usable by Lean's data provider. +Aiur ROM allocation happens inside the program. -/ +def Fixture.hints (fixture : Fixture) : Array (Execution.HintEntry F) := Id.run do + let mut hints : Array (Execution.HintEntry F) := #[] + for (channel, entries) in [(2,fixture.constants.push fixture.invalidProof), (4,fixture.blobs), (6,fixture.roles)] do + let mut offset := 0 + for entry in entries do + hints := hints.push ⟨.tuple [.field,.field], tuple [scalar channel, array entry.address], + tuple [scalar offset, scalar entry.bytes.size], "ixvm.io.info"⟩ + for i in [:entry.bytes.size] do + hints := hints.push ⟨.field, tuple [scalar channel, scalar (offset+i)], scalar entry.bytes[i]!, "ixvm.io.read"⟩ + offset := offset + entry.bytes.size + if channel == 2 then + hints := hints.push ⟨.field, tuple [scalar 3, array entry.address], scalar entry.hint, "ixvm.io.tag"⟩ + -- Sample data for bytes_le. The IxVM host binds + -- bytes_le to a closure, with no finite precomputed range (see crates/ixvm/src). + let decompositions : List Nat := List.range 4097 ++ [4294967294,4294967295] + for n in decompositions do + hints := hints.push ⟨.array .field 8, scalar n, + array (((List.range 8).map fun i => (n / 256^i) % 256).toArray), "bytes_le"⟩ + return hints + +@[noinline] private def timePhase (enabled : Bool) (label : String) + (action : Unit → Except String α) : IO α := do + let start ← IO.monoMsNow + let result ← IO.ofExcept (action ()) + if enabled then IO.eprintln s!"Phase {label}: {(← IO.monoMsNow) - start}ms" + return result + +private def dumpPropagation {source : Modules.Program F} + (prepared : Modules.Prepared source) (directory : String) : IO Unit := do + IO.eprintln "Specializing/inlining propagation fixtures..." + let specialized ← IO.ofExcept (Generic.specialize prepared.environment.source prepared.entries) + let inlined ← IO.ofExcept (Inlining.prepare specialized.program specialized.inlineNames prepared.entries) + IO.FS.createDirAll directory + for (name, symbol) in [("put_expr", "IxonSerialize::put_expr"), + ("get_expr", "IxonDeserialize::get_expr"), + ("blake3_compress", "Blake3::compress")] do + let some functionDecl := inlined.program.findFunction? symbol + | throw (IO.userError s!"missing function {name}") + let start ← IO.monoMsNow + let logical ← IO.ofExcept (Optimized.Compiler.function inlined.program {} functionDecl) + let chip ← IO.ofExcept (Optimized.layOut {propagateValues := false} logical) + PropagationBench.write (directory ++ "/" ++ name ++ ".json") chip.chip + IO.eprintln s!"Saved {name}: {chip.chip.numVars} columns in {(← IO.monoMsNow) - start}ms" + +/-- Actual circuit columns, before adding any lookup protocol, +memory-table chips, multiplicities or quotient commitments. -/ +private def reportColumns {source : Modules.Program F} + (prepared : Modules.Prepared source) (path : String) + (config : Optimized.Config := {}) (reference : Bool := false) + (profile : Bool := false) : IO Unit := do + let (system, representatives, unmerged, description) ← if reference then do + IO.eprintln "Compiling reference circuits..." + let compiled ← IO.ofExcept prepared.compile + let system := compiled.circuit.system + pure (system, system.chips.map (fun c => (c.name, c.name)), + system.chips.length, "reference") + else do + IO.eprintln s!"Compiling circuits: {reprStr config}" + let artifact ← if profile then do + let specialized ← timePhase true "specialization" fun _ => + Generic.specialize prepared.environment.source prepared.entries + let inlined ← timePhase true "inlining" fun _ => + Inlining.prepare specialized.program specialized.inlineNames prepared.entries + timePhase true "circuit compilation" fun _ => + Optimized.compile inlined.program prepared.entries config + else do + let compiled ← IO.ofExcept (prepared.compileOptimized config) + pure compiled.circuit.artifact + let physical ← timePhase profile "physical deduplication" fun _ => Optimized.Physical.prepare artifact + let representatives := artifact.representatives.map fun (name, _) => (name, physical.representative name) + pure (physical.system, representatives, artifact.unmerged.chips.length, + reprStr artifact.config) + let chips := system.stats.map fun s => Json.mkObj [ + ("name", toJson s.name), ("stage1", toJson s.columns), + ("constraint_degree", toJson s.maxConstraintDegree), + ("call_lookups", toJson s.callLookups), ("rom_lookups", toJson s.romLookups), + ("lookup_degree", toJson s.maxLookupDegree)] + let tables ← system.tables.mapM fun t => do + let layout ← IO.ofExcept ((system.enums.layout t.rowType).mapError reprStr) + pure <| Json.mkObj [("name", toJson t.name), ("rows", toJson t.rows.length), + ("width", toJson layout.width)] + let columns := system.stats.foldl (fun n s => n + s.columns) 0 + let result := Json.mkObj [ + ("modulus", toJson modulus), ("entries", toJson prepared.entries), + ("config", toJson description), + ("function_chips", toJson chips.length), ("function_stage1", toJson columns), + ("chips", toJson chips), ("representatives", toJson representatives), + ("unmerged_chips", toJson unmerged), + ("tables", toJson tables), ("static_maps", toJson system.maps.length)] + IO.FS.writeFile path (result.pretty 100) + IO.eprintln s!"Wrote {chips.length} chips / {columns} stage-1 columns to {path}" + +/-- The IxVM host binds the library's code hints. The general Lean FFI stays +data-only; it does not acquire a hardcoded registry of arithmetic operations. -/ +private def runHost (package : Json) (mode : String) : IO Unit := + IO.FS.withTempFile fun handle path => do + handle.putStr package.compress + handle.flush + let result ← IO.Process.output { + cmd := "cargo" + args := #["run", "--quiet", "--release", "--locked", "-p", "ixvm", "--bin", "ixvm", "--", + path.toString, mode] } + IO.print result.stdout + IO.eprint result.stderr + unless result.exitCode == 0 do + throw (IO.userError s!"IxVM host exited with code {result.exitCode}") + +unsafe def main (args : List String) : IO Unit := do + let totalStart ← IO.monoMsNow + let groups := if args.contains "--ungrouped" then [] else IxVM.functionGroups + let mode := args.headD "transitive" + let profile := mode == "stats-profile" + if mode == "propagation" || mode == "propagation-trace" then + let some path := args[1]? | throw (IO.userError "propagation requires a chip snapshot path") + return ← PropagationBench.run (F := F) path (mode == "propagation-trace") + unless ["transitive", "constant", "serde", "primitives", "check", "check-claim", "export-claim", "export-claim-trace", "export", "export-trace", "export-primitives", "stats", "stats-profile", "stats-no-propagation", "stats-reference", "dump-propagation", "grouping-snapshot"].contains mode do + throw (IO.userError s!"unknown mode '{mode}'; use transitive, constant, serde, primitives, check, export, export-trace, stats, stats-profile, stats-no-propagation, stats-reference, grouping-snapshot, dump-propagation, propagation, or propagation-trace") + let entry := match mode with + | "check-claim" | "export-claim" | "export-claim-trace" | "grouping-snapshot" => "IxVM::verify_claim" + | "serde" => "IxVM::verify_serde" + | "constant" => "IxVM::verify_constant" + | "primitives" | "export-primitives" => "IxVM::check_primitives" + | _ => "IxVM::verify_transitive" + let text ← SourceBundle.read (← sourcePath "Program.sources") + initSearchPath (← findSysroot) + enableInitializersExecution + let env ← importModules (loadExts := true) #[{module := `Aiur.Modules.Frontend}] {} 0 + if profile then IO.eprintln s!"Phase initialization: {(← IO.monoMsNow) - totalStart}ms" + IO.eprintln "Parsing and checking IxVM..." + let source ← timePhase profile "parsing and source checking" fun _ => IxVM.parse env text + IO.eprintln "Checking IxVM tables..." + let start ← IO.monoMsNow + let entries := if mode == "export" then ["IxVM::verify_transitive", "IxVM::verify_constant", "IxVM::verify_serde", "IxVM::check_primitives", "IxVM::check_port_cases"] else [entry] + let prepared ← timePhase profile "module/table preparation" fun _ => + Modules.prepare source entries + if mode == "dump-propagation" then + return ← dumpPropagation prepared (args[1]?.getD "/tmp/aiur-propagation") + if mode == "stats" || profile || mode == "stats-no-propagation" || mode == "stats-reference" then + reportColumns prepared (args[1]?.getD "/tmp/aiur-ixvm-columns.json") + {propagateValues := mode != "stats-no-propagation"} (mode == "stats-reference") profile + if profile then IO.eprintln s!"Phase total: {(← IO.monoMsNow) - totalStart}ms" + return + IO.eprintln s!"Checked in {(← IO.monoMsNow) - start}ms. Compiling bytecode..." + let exported ← IO.ofExcept prepared.exportExecution + IO.eprintln s!"Exported {exported.bytecode.functions.length} functions." + if mode == "check" || mode == "check-claim" then return + if mode == "grouping-snapshot" then + let compiled ← IO.ofExcept (prepared.compileOptimized {}) + let physical ← IO.ofExcept (Optimized.Physical.prepare compiled.circuit.artifact) + let snapshot := Optimized.Grouping.Snapshot.capture compiled.circuit.artifact physical + (exported.bytecode.functions.map (·.name) ++ exported.bytecode.maps.map (·.name)) groups + let path := args[1]?.getD "/tmp/ixvm-grouping.json" + IO.FS.writeFile path (toJson snapshot).compress + IO.eprintln s!"Wrote grouping snapshot {path}" + return + if mode == "export-claim" || mode == "export-claim-trace" then + let program ← IO.ofExcept (exported.toJson modulus ZMod.val) + let trace ← if mode == "export-claim-trace" then do + IO.eprintln "Compiling claim circuits and witness population plans..." + let compiled ← IO.ofExcept (prepared.compileOptimized {}) + pure <| some (← IO.ofExcept (Trace.exportJson modulus ZMod.val compiled.circuit.inlined.program + compiled.circuit.artifact exported.bytecode groups)) + else pure none + let package := Json.mkObj ([("program", program)] ++ trace.toList.map ("trace", ·)) + let path := args[1]?.getD "/tmp/ix-claim.json" + IO.FS.writeFile path package.compress + IO.eprintln s!"Wrote {path}" + return + let json ← IO.ofExcept (Json.parse (← IO.FS.readFile (← sourcePath "fixtures/nat-add-comm.json"))) + let fixture : Fixture ← IO.ofExcept (fromJson? json) + unless fixture.format == "ixon-v4" do throw (IO.userError "unsupported fixture format") + IO.eprintln "Building typed hints..." + let hints := fixture.hints + IO.eprintln s!"Preparing {hints.size} hint entries..." + let hints ← IO.ofExcept (exported.prepareHints hints) + IO.eprintln "Encoding bytecode..." + let program ← IO.ofExcept (exported.toJson modulus ZMod.val) + let trace ← if mode == "export-trace" then do + IO.eprintln "Compiling certified circuits and witness population plans..." + let compiled ← IO.ofExcept (prepared.compileOptimized {}) + pure <| some (← IO.ofExcept (Trace.exportJson modulus ZMod.val compiled.circuit.inlined.program + compiled.circuit.artifact exported.bytecode groups)) + else pure none + let package := Json.mkObj ([("program", program), ("address", toJson fixture.address), + ("invalid_address", toJson fixture.invalidProof.address), + ("hints", Execution.hintsJson ZMod.val hints)] ++ trace.toList.map ("trace", ·)) + if mode.startsWith "export" then + IO.eprintln "Writing execution package..." + let path := args[1]?.getD "/tmp/aiur-ixvm-package.json" + IO.FS.writeFile path package.compress + IO.eprintln s!"Wrote {path}" + return + IO.eprintln s!"Executing {entry}: {fixture.name} / {fixture.addressHex}" + runHost package mode + +end IxVM.Cli + +unsafe def main (args : List String) : IO Unit := IxVM.Cli.main args diff --git a/IxVM/IxVM/Modules/Convert.aiur b/IxVM/IxVM/Modules/Convert.aiur new file mode 100644 index 000000000..c418319b8 --- /dev/null +++ b/IxVM/IxVM/Modules/Convert.aiur @@ -0,0 +1,264 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module Convert { + fn bytes_to_u64_limb(bytes: Bytes::Stream, acc: UInt64::U64, pos: Field) -> UInt64::U64 { + match pos { + 8 => { acc } , + _ => { + match (*(bytes)) { + Lists::Node::Nil => { acc } , + Lists::Node::Cons(byte, rest) => { + let [v0, v1, v2, v3, v4, v5, v6, v7] = acc; + match pos { + 0 => { bytes_to_u64_limb(rest, [byte, v1, v2, v3, v4, v5, v6, v7], 1) } , + 1 => { bytes_to_u64_limb(rest, [v0, byte, v2, v3, v4, v5, v6, v7], 2) } , + 2 => { bytes_to_u64_limb(rest, [v0, v1, byte, v3, v4, v5, v6, v7], 3) } , + 3 => { bytes_to_u64_limb(rest, [v0, v1, v2, byte, v4, v5, v6, v7], 4) } , + 4 => { bytes_to_u64_limb(rest, [v0, v1, v2, v3, byte, v5, v6, v7], 5) } , + 5 => { bytes_to_u64_limb(rest, [v0, v1, v2, v3, v4, byte, v6, v7], 6) } , + 6 => { bytes_to_u64_limb(rest, [v0, v1, v2, v3, v4, v5, byte, v7], 7) } , + _ => { bytes_to_u64_limb(rest, [v0, v1, v2, v3, v4, v5, v6, byte], 8) } , + } } , + } } , + } + } + + fn skip_bytes(bytes: Bytes::Stream, n: Field) -> Bytes::Stream { + match n { + 0 => { bytes } , + _ => { + match (*(bytes)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(_, rest) => { skip_bytes(rest, n - 1) } , + } } , + } + } + + fn bytes_to_limbs(bytes: Bytes::Stream) -> KernelTypes::KLimbs { + let limb = bytes_to_u64_limb(bytes, [UInt8::BYTE_0; 8], 0); + let rest_bytes = skip_bytes(bytes, 8); + let rest_limbs = match (*(rest_bytes)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + _ => { bytes_to_limbs(rest_bytes) } , + }; + match (*(rest_limbs)) { + Lists::Node::Nil => { + match UInt64::is_zero(limb) { + 1 => { (&(Lists::Node::Nil)) } , + 0 => { (&(Lists::Node::Cons(limb, (&(Lists::Node::Nil))))) } , + } } , + _ => { (&(Lists::Node::Cons(limb, rest_limbs))) } , + } + } + + fn convert_univ(u: &Ixon::Univ) -> KernelTypes::KLevel { + match (*(u)) { + Ixon::Univ::Zero => { (&(KernelTypes::KLevelNode::Zero)) } , + Ixon::Univ::Succ(inner) => { (&(KernelTypes::KLevelNode::Succ(convert_univ(inner)))) } , + Ixon::Univ::Max(a, b) => { (&(KernelTypes::KLevelNode::Max(convert_univ(a), convert_univ(b)))) } , + Ixon::Univ::IMax(a, b) => { (&(KernelTypes::KLevelNode::IMax(convert_univ(a), convert_univ(b)))) } , + Ixon::Univ::Var(idx) => { (&(KernelTypes::KLevelNode::Param(UInt64::to_field(idx)))) } , + } + } + + fn convert_univ_idxs(idxs: Lists::List, univs: Lists::List<&Ixon::Univ>) -> Lists::List { + match (*(idxs)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(idx, rest) => { + let u_ref = Lists::lookup(univs, UInt64::to_field(idx)); + (&(Lists::Node::Cons(convert_univ(u_ref), convert_univ_idxs(rest, univs)))) } , + } + } + + fn convert_expr( + e: &Ixon::Expr, + sharing: Lists::List<&Ixon::Expr>, + refs: Lists::List, + recur_addrs: Lists::List, + univs: Lists::List<&Ixon::Univ> + ) -> KernelTypes::KExpr { + match (*(e)) { + Ixon::Expr::Srt(univ_idx) => { + let u_ref = Lists::lookup(univs, UInt64::to_field(univ_idx)); + (&(KernelTypes::KExprNode::Srt(convert_univ(u_ref)))) } , + + Ixon::Expr::Var(idx) => { + (&(KernelTypes::KExprNode::BVar(UInt64::to_field(idx)))) } , + + Ixon::Expr::Ref(ref_idx, univ_idxs) => { + let ref_addr = Lists::lookup(refs, UInt64::to_field(ref_idx)); + let levels = convert_univ_idxs(univ_idxs, univs); + (&(KernelTypes::KExprNode::Const(ref_addr, levels))) } , + + Ixon::Expr::Rec(rec_idx, univ_idxs) => { + + let ref_addr = Lists::lookup(recur_addrs, UInt64::to_field(rec_idx)); + let levels = convert_univ_idxs(univ_idxs, univs); + (&(KernelTypes::KExprNode::Const(ref_addr, levels))) } , + + Ixon::Expr::Prj(type_ref_idx, field_idx, inner) => { + let type_addr = Lists::lookup(refs, UInt64::to_field(type_ref_idx)); + (&(KernelTypes::KExprNode::Proj( + type_addr, + UInt64::to_field(field_idx), + convert_expr(inner, sharing, refs, recur_addrs, univs)))) } , + + Ixon::Expr::Str(blob_ref_idx) => { + let blob_addr = Lists::lookup(refs, UInt64::to_field(blob_ref_idx)); + let bs = Ingress::load_verified_blob(blob_addr); + + KernelNatPrim::utf8_validate(bs); + (&(KernelTypes::KExprNode::Lit(KernelTypes::KLiteral::Str(bs)))) } , + + Ixon::Expr::Nat(blob_ref_idx) => { + let blob_addr = Lists::lookup(refs, UInt64::to_field(blob_ref_idx)); + let bs = Ingress::load_verified_blob(blob_addr); + let limbs = bytes_to_limbs(bs); + (&(KernelTypes::KExprNode::Lit(KernelTypes::KLiteral::Nat(limbs)))) } , + + Ixon::Expr::App(f, a) => { + (&(KernelTypes::KExprNode::App( + convert_expr(f, sharing, refs, recur_addrs, univs), + convert_expr(a, sharing, refs, recur_addrs, univs)))) } , + + Ixon::Expr::Lam(_, ty, body) => { + (&(KernelTypes::KExprNode::Lam( + convert_expr(ty, sharing, refs, recur_addrs, univs), + convert_expr(body, sharing, refs, recur_addrs, univs)))) } , + + Ixon::Expr::All(_, _, ty, body) => { + (&(KernelTypes::KExprNode::Forall( + convert_expr(ty, sharing, refs, recur_addrs, univs), + convert_expr(body, sharing, refs, recur_addrs, univs)))) } , + + Ixon::Expr::Let(_, ty, val, body) => { + (&(KernelTypes::KExprNode::Let( + convert_expr(ty, sharing, refs, recur_addrs, univs), + convert_expr(val, sharing, refs, recur_addrs, univs), + convert_expr(body, sharing, refs, recur_addrs, univs)))) } , + + Ixon::Expr::Share(idx) => { + let Lists::Node::Cons(e, _) = (*(Lists::drop(sharing, UInt64::to_field(idx)))); + convert_expr(e, sharing, refs, recur_addrs, univs) } , + } + } + + fn convert_definition(d: Ixon::Definition, sharing: Lists::List<&Ixon::Expr>, + refs: Lists::List, recur_addrs: Lists::List, + univs: Lists::List<&Ixon::Univ>, hint: Field) -> KernelTypes::KConstantInfo { + match d { + Ixon::Definition::Mk(kind, safety, lvls, typ, value) => { + let ktyp = convert_expr(typ, sharing, refs, recur_addrs, univs); + let kval = convert_expr(value, sharing, refs, recur_addrs, univs); + let nlvls = UInt64::to_field(lvls); + match kind { + Ixon::DefKind::Definition => { + KernelTypes::KConstantInfo::Defn(nlvls, ktyp, kval, safety, hint) } , + Ixon::DefKind::Opaque => { + let is_unsafe = match safety { Ixon::DefinitionSafety::Unsafe => { 1 } , _ => { 0 } , }; + KernelTypes::KConstantInfo::Opaque(nlvls, ktyp, kval, is_unsafe) } , + Ixon::DefKind::Theorem => { + KernelTypes::KConstantInfo::Thm(nlvls, ktyp, kval) } , + } } , + } + } + + fn convert_axiom(a: Ixon::Axiom, sharing: Lists::List<&Ixon::Expr>, + refs: Lists::List, recur_addrs: Lists::List, + univs: Lists::List<&Ixon::Univ>) -> KernelTypes::KConstantInfo { + match a { + Ixon::Axiom::Mk(is_unsafe, lvls, typ) => { + let ktyp = convert_expr(typ, sharing, refs, recur_addrs, univs); + KernelTypes::KConstantInfo::Axiom(UInt64::to_field(lvls), ktyp, is_unsafe) } , + } + } + + fn convert_quotient(q: Ixon::Quotient, sharing: Lists::List<&Ixon::Expr>, + refs: Lists::List, recur_addrs: Lists::List, + univs: Lists::List<&Ixon::Univ>) -> KernelTypes::KConstantInfo { + match q { + Ixon::Quotient::Mk(kind, lvls, typ) => { + let ktyp = convert_expr(typ, sharing, refs, recur_addrs, univs); + KernelTypes::KConstantInfo::Quot(UInt64::to_field(lvls), ktyp, kind) } , + } + } + + fn count_ctors(cs: Lists::List) -> Field { + match (*(cs)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(_, rest) => { count_ctors(rest) + 1 } , + } + } + + fn ctor_at(cs: Lists::List, cidx: Field) -> Ixon::Constructor { + match (*(cs)) { + Lists::Node::Cons(c, rest) => { + match cidx { + 0 => { c } , + _ => { ctor_at(rest, cidx - 1) } , + } } , + } + } + + fn convert_inductive(ind: Ixon::Inductive, block_addr: Bytes::AddressRef, ind_idx: Field, + sharing: Lists::List<&Ixon::Expr>, refs: Lists::List, + recur_addrs: Lists::List, + univs: Lists::List<&Ixon::Univ>) -> KernelTypes::KConstantInfo { + match ind { + Ixon::Inductive::Mk(is_unsafe, lvls, params, indices, typ, ctors) => { + let ktyp = convert_expr(typ, sharing, refs, recur_addrs, univs); + KernelTypes::KConstantInfo::Induct( + UInt64::to_field(lvls), ktyp, + UInt64::to_field(params), UInt64::to_field(indices), + count_ctors(ctors), is_unsafe, + block_addr, ind_idx) } , + } + } + + fn convert_constructor(c: Ixon::Constructor, block_addr: Bytes::AddressRef, ind_idx: Field, + sharing: Lists::List<&Ixon::Expr>, refs: Lists::List, + recur_addrs: Lists::List, + univs: Lists::List<&Ixon::Univ>) -> KernelTypes::KConstantInfo { + match c { + Ixon::Constructor::Mk(is_unsafe, lvls, cidx, params, fields, typ) => { + let ktyp = convert_expr(typ, sharing, refs, recur_addrs, univs); + KernelTypes::KConstantInfo::Ctor( + UInt64::to_field(lvls), ktyp, + block_addr, ind_idx, UInt64::to_field(cidx), + UInt64::to_field(params), UInt64::to_field(fields), is_unsafe) } , + } + } + + fn convert_rec_rules(rs: Lists::List, sharing: Lists::List<&Ixon::Expr>, + refs: Lists::List, recur_addrs: Lists::List, + univs: Lists::List<&Ixon::Univ>, cidx: Field) -> Lists::List { + match (*(rs)) { + Lists::Node::Nil => { + (&(Lists::Node::Nil)) } , + Lists::Node::Cons(r, rest) => { + match r { + Ixon::RecursorRule::Mk(fields, rhs) => { + let krhs = convert_expr(rhs, sharing, refs, recur_addrs, univs); + (&(Lists::Node::Cons( + KernelTypes::KRecRule::Mk(cidx, UInt64::to_field(fields), krhs), + convert_rec_rules(rest, sharing, refs, recur_addrs, univs, cidx + 1)))) } , + } } , + } + } + + fn convert_recursor(r: Ixon::Recursor, block_addr: Bytes::AddressRef, rec_idx: Field, + sharing: Lists::List<&Ixon::Expr>, refs: Lists::List, + recur_addrs: Lists::List, + univs: Lists::List<&Ixon::Univ>) -> KernelTypes::KConstantInfo { + match r { + Ixon::Recursor::Mk(k, is_unsafe, lvls, params, indices, motives, minors, typ, rules) => { + let ktyp = convert_expr(typ, sharing, refs, recur_addrs, univs); + let krules = convert_rec_rules(rules, sharing, refs, recur_addrs, univs, 0); + KernelTypes::KConstantInfo::Rec( + UInt64::to_field(lvls), ktyp, + UInt64::to_field(params), UInt64::to_field(indices), + UInt64::to_field(motives), UInt64::to_field(minors), + krules, k, is_unsafe, + block_addr, rec_idx) } , + } + } +} diff --git a/IxVM/IxVM/Modules/Ingress.aiur b/IxVM/IxVM/Modules/Ingress.aiur new file mode 100644 index 000000000..a160669c4 --- /dev/null +++ b/IxVM/IxVM/Modules/Ingress.aiur @@ -0,0 +1,232 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module Ingress { + fn load_verified_constant(addr: Bytes::AddressRef) -> Ixon::Constant { + let raw = (*(addr)); + let (idx, len) = IxVMCompat::io_get_info(2, raw); + let bytes = IxByteStream::read_finite_byte_stream(2, idx, len); + Blake3::verify_bytes_against(bytes, raw); + let (constant, rest) = IxonDeserialize::get_constant(bytes); + let Lists::Node::Nil = (*(rest)); + constant + } + + fn definition_hint(addr: Bytes::AddressRef, d: Ixon::Definition) -> Field { + match d { + Ixon::Definition::Mk(kind, _, _, _, _) => { + match kind { + Ixon::DefKind::Definition => { load_constant_hint(addr) } , + _ => { 0 } , + } } , + } + } + + fn load_constant_hint(addr: Bytes::AddressRef) -> Field { + hint::("ixvm.io.tag", (3, Blake3::address_to_fields((*(addr))))) + } + + fn load_verified_blob(addr: Bytes::AddressRef) -> Bytes::Stream { + let raw = (*(addr)); + let (idx, len) = IxVMCompat::io_get_info(4, raw); + let bytes = IxByteStream::read_finite_byte_stream(4, idx, len); + Blake3::verify_bytes_against(bytes, raw); + bytes + } + + fn defn_is_unsafe_ci(kind: Ixon::DefKind, safety: Ixon::DefinitionSafety) -> Field { + match kind { + Ixon::DefKind::Theorem => { 0 } , + Ixon::DefKind::Opaque => { + match safety { + Ixon::DefinitionSafety::Unsafe => { 1 } , + _ => { 0 } , + } } , + Ixon::DefKind::Definition => { + match safety { + Ixon::DefinitionSafety::Safe => { 0 } , + _ => { 1 } , + } } , + } + } + + fn defn_member_recur_addrs(d: Ixon::Definition, members: Lists::List, + block_addr: Bytes::AddressRef) -> Lists::List { + match d { + Ixon::Definition::Mk(kind, safety, _, _, _) => { + match defn_is_unsafe_ci(kind, safety) { + 0 => { (&(Lists::Node::Nil)) } , + _ => { build_recur_addrs(members, block_addr) } , + } } , + } + } + + fn get_ci(addr: Bytes::AddressRef) -> &KernelTypes::KConstantInfo { + let c = load_verified_constant(addr); + match c { + Ixon::Constant::Mk(info, sharing, refs, univs) => { + match info { + Ixon::ConstantInfo::Defn(defn) => { + let hint = definition_hint(addr, defn); + + let self_recur = match defn { + Ixon::Definition::Mk(kind, safety, _, _, _) => { + match defn_is_unsafe_ci(kind, safety) { + 0 => { (&(Lists::Node::Nil)) } , + _ => { (&(Lists::Node::Cons(addr, (&(Lists::Node::Nil))))) } , + } } , + }; + (&(Convert::convert_definition(defn, sharing, refs, + self_recur, univs, hint))) } , + Ixon::ConstantInfo::Axio(axio) => { + + (&(Convert::convert_axiom(axio, sharing, refs, + (&(Lists::Node::Nil)), univs))) } , + Ixon::ConstantInfo::Quot(quot) => { + (&(Convert::convert_quotient(quot, sharing, refs, + (&(Lists::Node::Nil)), univs))) } , + Ixon::ConstantInfo::DPrj(prj) => { + match prj { + Ixon::DefinitionProj::Mk(idx, block_addr) => { + get_ci_dprj(addr, idx, block_addr) } , + } } , + Ixon::ConstantInfo::IPrj(prj) => { + match prj { + Ixon::InductiveProj::Mk(idx, block_addr) => { + get_ci_iprj(block_addr, UInt64::to_field(idx)) } , + } } , + Ixon::ConstantInfo::CPrj(prj) => { + match prj { + Ixon::ConstructorProj::Mk(idx, cidx, block_addr) => { + get_ci_cprj(block_addr, UInt64::to_field(idx), UInt64::to_field(cidx)) } , + } } , + Ixon::ConstantInfo::RPrj(prj) => { + match prj { + Ixon::RecursorProj::Mk(idx, block_addr) => { + get_ci_rprj(block_addr, UInt64::to_field(idx)) } , + } } , + + Ixon::ConstantInfo::Recr(recr) => { + + let self_recur = (&(Lists::Node::Cons(addr, (&(Lists::Node::Nil))))); + (&(Convert::convert_recursor(recr, addr, 0, + sharing, refs, self_recur, univs))) } , + } } , + } + } + + fn get_ci_dprj(dprj_addr: Bytes::AddressRef, idx: UInt64::U64, block_addr: Bytes::AddressRef) -> &KernelTypes::KConstantInfo { + let block_c = load_verified_constant(block_addr); + match block_c { + Ixon::Constant::Mk(info, sharing, refs, univs) => { + match info { + Ixon::ConstantInfo::Muts(members) => { + let mc = WordLists::lookup_u64(members, idx); + match mc { + Ixon::MutConst::Defn(d) => { + let hint = definition_hint(dprj_addr, d); + let recur_addrs = + defn_member_recur_addrs(d, members, block_addr); + (&(Convert::convert_definition(d, sharing, refs, recur_addrs, univs, hint))) } , + } } , + } } , + } + } + + fn get_ci_iprj(block_addr: Bytes::AddressRef, idx: Field) -> &KernelTypes::KConstantInfo { + let block_c = load_verified_constant(block_addr); + match block_c { + Ixon::Constant::Mk(info, sharing, refs, univs) => { + match info { + Ixon::ConstantInfo::Muts(members) => { + let mc = muts_member_at(members, idx); + match mc { + Ixon::MutConst::Indc(ind) => { + let recur_addrs = build_recur_addrs(members, block_addr); + (&(Convert::convert_inductive(ind, block_addr, idx, + sharing, refs, recur_addrs, univs))) } , + } } , + } } , + } + } + + fn get_ci_cprj(block_addr: Bytes::AddressRef, idx: Field, cidx: Field) -> &KernelTypes::KConstantInfo { + let block_c = load_verified_constant(block_addr); + match block_c { + Ixon::Constant::Mk(info, sharing, refs, univs) => { + match info { + Ixon::ConstantInfo::Muts(members) => { + let mc = muts_member_at(members, idx); + match mc { + Ixon::MutConst::Indc(ind) => { + match ind { + Ixon::Inductive::Mk(_, _, _, _, _, ctors) => { + let c = Convert::ctor_at(ctors, cidx); + let recur_addrs = build_recur_addrs(members, block_addr); + (&(Convert::convert_constructor(c, block_addr, idx, + sharing, refs, recur_addrs, univs))) } , + } } , + } } , + } } , + } + } + + fn get_ci_rprj(block_addr: Bytes::AddressRef, idx: Field) -> &KernelTypes::KConstantInfo { + let block_c = load_verified_constant(block_addr); + match block_c { + Ixon::Constant::Mk(info, sharing, refs, univs) => { + match info { + Ixon::ConstantInfo::Muts(members) => { + let mc = muts_member_at(members, idx); + match mc { + Ixon::MutConst::Recr(r) => { + let recur_addrs = build_recur_addrs(members, block_addr); + (&(Convert::convert_recursor(r, block_addr, idx, + sharing, refs, recur_addrs, univs))) } , + } } , + } } , + } + } + + fn muts_member_at(members: Lists::List, idx: Field) -> Ixon::MutConst { + match (*(members)) { + Lists::Node::Cons(m, rest) => { + match idx { + 0 => { m } , + _ => { muts_member_at(rest, idx - 1) } , + } } , + } + } + + fn projection_addr(members: Lists::List, block_addr: Bytes::AddressRef, idx: Field) -> Bytes::AddressRef { + let mc = muts_member_at(members, idx); + let idx_u64 = UInt64::from_field(idx); + let info = match mc { + Ixon::MutConst::Defn(_) => { + Ixon::ConstantInfo::DPrj(Ixon::DefinitionProj::Mk(idx_u64, block_addr)) } , + Ixon::MutConst::Indc(_) => { + Ixon::ConstantInfo::IPrj(Ixon::InductiveProj::Mk(idx_u64, block_addr)) } , + Ixon::MutConst::Recr(_) => { + Ixon::ConstantInfo::RPrj(Ixon::RecursorProj::Mk(idx_u64, block_addr)) } , + }; + let proj_c = Ixon::Constant::Mk(info, + (&(Lists::Node::Nil)), + (&(Lists::Node::Nil)), + (&(Lists::Node::Nil))); + let bytes = IxonSerialize::put_constant(proj_c, (&(Lists::Node::Nil))); + Blake3::bytes_to_addr(bytes) + } + + fn build_recur_addrs(members: Lists::List, block_addr: Bytes::AddressRef) -> Lists::List { + build_recur_addrs_walk(members, block_addr, members, 0) + } + + fn build_recur_addrs_walk(all_members: Lists::List, block_addr: Bytes::AddressRef, + cur: Lists::List, idx: Field) -> Lists::List { + match (*(cur)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(_, rest) => { + (&(Lists::Node::Cons( + projection_addr(all_members, block_addr, idx), + build_recur_addrs_walk(all_members, block_addr, rest, idx + 1)))) } , + } + } +} diff --git a/IxVM/IxVM/Modules/IxByteStream.aiur b/IxVM/IxVM/Modules/IxByteStream.aiur new file mode 100644 index 000000000..6a301590a --- /dev/null +++ b/IxVM/IxVM/Modules/IxByteStream.aiur @@ -0,0 +1,18 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module IxByteStream { + fn read_byte_stream(channel: Field, idx: Field, len: Field) -> Bytes::Stream { + + match len { + 0 => { (&(Lists::Node::Nil)) } , + _ => { let byte = hint::("ixvm.io.read", (channel, idx)); + let tail = read_byte_stream(channel, idx + 1, len - 1); + (&(Lists::Node::Cons(UInt8::from_field(byte), tail))) } , + } + } + + fn read_finite_byte_stream(channel: Field, idx: Field, len: Field) -> Bytes::Stream { + let bytes = read_byte_stream(channel, idx, len); + WordLists::depth_checked(bytes); + bytes + } +} diff --git a/IxVM/IxVM/Modules/IxVMCompat.aiur b/IxVM/IxVM/Modules/IxVMCompat.aiur new file mode 100644 index 000000000..89dc57a50 --- /dev/null +++ b/IxVM/IxVM/Modules/IxVMCompat.aiur @@ -0,0 +1,61 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module IxVMCompat { + fn check_owned(binding: [UInt8::U8; 32], validator: Field, bytes: [UInt8::U8; 32]) -> () { + KernelClaim::env_walk_all(KernelRoles::role_ctx_for_validator((&(binding)), validator), (&(bytes))) + } + + inline fn io_get_info(channel: Field, key: [UInt8::U8; 32]) -> (Field, Field) { + hint::<(Field, Field)>("ixvm.io.info", (channel, Blake3::address_to_fields(key))) + } + + fn ordinary_div_mod(a: KernelTypes::KLimbs, b: KernelTypes::KLimbs) -> (KernelTypes::KLimbs, KernelTypes::KLimbs) { + let a = KernelKlimbs::klimbs_normalize(a); + let b = KernelKlimbs::klimbs_normalize(b); + match KernelKlimbs::klimbs_is_zero(b) { + 1 => ((&(Lists::Node::Nil)), a), + _ => divide_grow(a, b), + } + } + + fn divide_grow(a: KernelTypes::KLimbs, b: KernelTypes::KLimbs) -> (KernelTypes::KLimbs, KernelTypes::KLimbs) { + match KernelKlimbs::klimbs_le(b, a) { + 0 => ((&(Lists::Node::Nil)), a), + _ => { + let (q, r) = divide_grow(a, KernelKlimbs::klimbs_add(b, b)); + let q = KernelKlimbs::klimbs_add(q, q); + match KernelKlimbs::klimbs_le(b, r) { + 0 => (q, r), + _ => (KernelKlimbs::klimbs_succ(q), KernelKlimbs::klimbs_sub(r, b)), + } + }, + } + } + + fn stream_equal(a: Bytes::Stream, b: Bytes::Stream) -> Field { + match ((*(a)), (*(b))) { + (Lists::Node::Nil, Lists::Node::Nil) => 1, + (Lists::Node::Cons(x, xs), Lists::Node::Cons(y, ys)) => { + match UInt8::to_field(x) - UInt8::to_field(y) { 0 => stream_equal(xs, ys), _ => 0 } + }, + _ => 0, + } + } + + fn default_binding_addr() -> Bytes::AddressRef { + (&([UInt8::BYTE_31, UInt8::BYTE_85, UInt8::BYTE_77, UInt8::BYTE_180, + UInt8::BYTE_29, UInt8::BYTE_45, UInt8::BYTE_45, UInt8::BYTE_119, + UInt8::BYTE_193, UInt8::BYTE_226, UInt8::BYTE_45, UInt8::BYTE_253, + UInt8::BYTE_219, UInt8::BYTE_204, UInt8::BYTE_179, UInt8::BYTE_132, + UInt8::BYTE_203, UInt8::BYTE_39, UInt8::BYTE_130, UInt8::BYTE_190, + UInt8::BYTE_29, UInt8::BYTE_192, UInt8::BYTE_214, UInt8::BYTE_122, + UInt8::BYTE_139, UInt8::BYTE_43, UInt8::BYTE_225, UInt8::BYTE_95, + UInt8::BYTE_211, UInt8::BYTE_158, UInt8::BYTE_62, UInt8::BYTE_114])) + } + + fn audit_div(a: KernelTypes::KLimbs, b: KernelTypes::KLimbs, expected_q: KernelTypes::KLimbs, expected_r: KernelTypes::KLimbs) -> () { + let (q, r) = KernelKlimbs::klimbs_div_mod(a, b); + assert_eq!(KernelLevels::klimbs_eq(q, expected_q), 1, "audit quotient"); + assert_eq!(KernelLevels::klimbs_eq(r, expected_r), 1, "audit remainder"); + () + } +} diff --git a/IxVM/IxVM/Modules/Ixon.aiur b/IxVM/IxVM/Modules/Ixon.aiur new file mode 100644 index 000000000..a0e7849a6 --- /dev/null +++ b/IxVM/IxVM/Modules/Ixon.aiur @@ -0,0 +1,136 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module Ixon { + enum Uses { + Erased, + Linear, + Affine, + Many + } + + enum Owned { + Unique, + Shared + } + + enum Locality { Unrestricted, Local } + + enum ValueContract { Mk(Owned, Locality) } + + enum BinderContract { Mk(Uses, ValueContract) } + + enum LetKind { Value, BorrowShared } + + enum LetContract { Mk(Field, LetKind, BinderContract) } + + enum Expr { + Srt(UInt64::U64), + Var(UInt64::U64), + Ref(UInt64::U64, Lists::List), + Rec(UInt64::U64, Lists::List), + Prj(UInt64::U64, UInt64::U64, &Expr), + Str(UInt64::U64), + Nat(UInt64::U64), + App(&Expr, &Expr), + Lam(BinderContract, &Expr, &Expr), + All(BinderContract, ValueContract, &Expr, &Expr), + Let(LetContract, &Expr, &Expr, &Expr), + Share(UInt64::U64) + } + + enum Univ { + Zero, + Succ(&Univ), + Max(&Univ, &Univ), + IMax(&Univ, &Univ), + Var(UInt64::U64) + } + + enum DefKind { + Definition, + Opaque, + Theorem + } + + enum DefinitionSafety { + Unsafe, + Safe, + Partial + } + + enum QuotKind { + Typ, + Ctor, + Lift, + Ind + } + + enum Definition { + Mk(DefKind, DefinitionSafety, UInt64::U64, &Expr, &Expr) + } + + enum RecursorRule { + Mk(UInt64::U64, &Expr) + } + + enum Recursor { + Mk(Field, Field, UInt64::U64, UInt64::U64, UInt64::U64, UInt64::U64, UInt64::U64, &Expr, Lists::List) + } + + enum Axiom { + Mk(Field, UInt64::U64, &Expr) + } + + enum Quotient { + Mk(QuotKind, UInt64::U64, &Expr) + } + + enum Constructor { + Mk(Field, UInt64::U64, UInt64::U64, UInt64::U64, UInt64::U64, &Expr) + } + + enum Inductive { + Mk(Field, UInt64::U64, UInt64::U64, UInt64::U64, &Expr, Lists::List) + } + + enum InductiveProj { + Mk(UInt64::U64, Bytes::AddressRef) + } + + enum ConstructorProj { + Mk(UInt64::U64, UInt64::U64, Bytes::AddressRef) + } + + enum RecursorProj { + Mk(UInt64::U64, Bytes::AddressRef) + } + + enum DefinitionProj { + Mk(UInt64::U64, Bytes::AddressRef) + } + + enum MutConst { + Defn(Definition), + Indc(Inductive), + Recr(Recursor) + } + + enum ConstantInfo { + Defn(Definition), + Recr(Recursor), + Axio(Axiom), + Quot(Quotient), + CPrj(ConstructorProj), + RPrj(RecursorProj), + IPrj(InductiveProj), + DPrj(DefinitionProj), + Muts(Lists::List) + } + + enum Constant { + Mk(ConstantInfo, Lists::List<&Expr>, Lists::List, Lists::List<&Univ>) + } + + enum BlobEntry { + Mk(Bytes::AddressRef, UInt64::U64) + } +} diff --git a/IxVM/IxVM/Modules/IxonDeserialize.aiur b/IxVM/IxVM/Modules/IxonDeserialize.aiur new file mode 100644 index 000000000..6233558c0 --- /dev/null +++ b/IxVM/IxVM/Modules/IxonDeserialize.aiur @@ -0,0 +1,601 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module IxonDeserialize { + fn read_byte(stream: Bytes::Stream) -> (UInt8::U8, Bytes::Stream) { + let Lists::Node::Cons(byte, rest) = (*(stream)); + (byte, rest) + } + + fn get_u64_le(stream: Bytes::Stream, num_bytes: Field) -> (UInt64::U64, Bytes::Stream) { + match num_bytes { + 0 => { ([UInt8::BYTE_0; 8], stream) } , + _ => { + let Lists::Node::Cons(byte, s) = (*(stream)); + let (rest_bytes, s2) = get_u64_le(s, num_bytes - 1); + let [r0, r1, r2, r3, r4, r5, r6, _] = rest_bytes; + ([byte, r0, r1, r2, r3, r4, r5, r6], s2) } , + } + } + + fn get_tagn4(stream: Bytes::Stream) -> ((Field, UInt64::U64), Bytes::Stream) { + let Lists::Node::Cons(byte, s) = (*(stream)); + let [b0, b1, b2, b3, b4, b5, b6, b7] = UInt8::bit_decomposition(byte); + let flag = b4 + 2 * b5 + 4 * b6 + 8 * b7; + let low = b0 + 2 * b1 + 4 * b2; + match b3 { + 0 => { ((flag, [UInt8::from_field(low), UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0]), s) } , + 1 => { + let (value, rest) = get_tagn_tail(low, 4, s); + ((flag, value), rest) } , + } + } + + fn get_tagn2(stream: Bytes::Stream) -> ((Field, UInt64::U64), Bytes::Stream) { + let Lists::Node::Cons(byte, s) = (*(stream)); + let [b0, b1, b2, b3, b4, b5, b6, b7] = UInt8::bit_decomposition(byte); + let flag = b6 + 2 * b7; + let low = b0 + 2 * b1 + 4 * b2 + 8 * b3 + 16 * b4; + match b5 { + 0 => { ((flag, [UInt8::from_field(low), UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0]), s) } , + 1 => { + let (value, rest) = get_tagn_tail(low, 16, s); + ((flag, value), rest) } , + } + } + + fn get_tagn0(stream: Bytes::Stream) -> (UInt64::U64, Bytes::Stream) { + let Lists::Node::Cons(byte, s) = (*(stream)); + match UInt8::less_than(byte, UInt8::BYTE_128) { + 1 => { ([byte, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], s) } , + 0 => { get_tagn_tail(UInt8::to_field(byte) - 128, 64, s) } , + } + } + + fn get_tagn_tail(q: Field, h: Field, stream: Bytes::Stream) -> (UInt64::U64, Bytes::Stream) { + match UInt8::raw_lt(q, h) { + + 1 => { + let Lists::Node::Cons(lo, s) = (*(stream)); + let (v0, carry) = UInt8::raw_add(UInt8::to_field(lo), 2 * h); + ([v0, UInt8::from_field(q + UInt8::to_field(carry)), UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], s) } , + 0 => { get_tagn_wide(q - h, h, stream) } , + } + } + + fn get_tagn_wide(c: Field, h: Field, stream: Bytes::Stream) -> (UInt64::U64, Bytes::Stream) { + let r0 = UInt8::from_field(2 * h); + let r1 = UInt8::from_field(h); + match c { + 0 => { + let (x, s) = get_u64_le(stream, 2); + let (value, _) = UInt64::add(x, [r0, r1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0]); + (value, s) } , + 1 => { + let (x, s) = get_u64_le(stream, 3); + let (value, _) = UInt64::add(x, [r0, r1, UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0]); + (value, s) } , + 2 => { + let (x, s) = get_u64_le(stream, 4); + let (value, _) = UInt64::add(x, [r0, r1, UInt8::BYTE_1, UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0]); + (value, s) } , + 3 => { + let (x, s) = get_u64_le(stream, 8); + let (value, carry) = UInt64::add(x, [r0, r1, UInt8::BYTE_1, UInt8::BYTE_1, UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0]); + assert_eq!(UInt8::to_field(carry), 0, "TagN value exceeds UInt64"); + (value, s) } , + } + } + + fn get_u64_list(stream: Bytes::Stream, count: UInt64::U64) -> (Lists::List, Bytes::Stream) { + let is_zero = UInt64::is_zero(count); + match is_zero { + 1 => { ((&(Lists::Node::Nil)), stream) } , + 0 => { + let (val, s) = get_tagn0(stream); + let (rest, s2) = get_u64_list(s, UInt64::saturating_pred(count)); + ((&(Lists::Node::Cons(val, rest))), s2) } , + } + } + + fn get_app_telescope(func: &Ixon::Expr, stream: Bytes::Stream, count: UInt64::U64) -> (&Ixon::Expr, Bytes::Stream) { + let is_zero = UInt64::is_zero(count); + match is_zero { + 1 => { (func, stream) } , + 0 => { + let (arg, s) = get_expr(stream); + get_app_telescope((&(Ixon::Expr::App(func, arg))), s, UInt64::saturating_pred(count)) } , + } + } + + fn value_contract_from_bits(owned_bit: Field, locality_bit: Field) -> Ixon::ValueContract { + let owned = match owned_bit { 0 => { Ixon::Owned::Unique } , 1 => { Ixon::Owned::Shared } , }; + let locality = match locality_bit { 0 => { Ixon::Locality::Unrestricted } , 1 => { Ixon::Locality::Local } , }; + Ixon::ValueContract::Mk(owned, locality) + } + + fn binder_contract_from_bits(b0: Field, b1: Field, b2: Field, b3: Field) -> Ixon::BinderContract { + let uses = match b0 + 2 * b1 { 0 => { Ixon::Uses::Erased } , 1 => { Ixon::Uses::Linear } , 2 => { Ixon::Uses::Affine } , 3 => { Ixon::Uses::Many } , }; + Ixon::BinderContract::Mk(uses, value_contract_from_bits(b2, b3)) + } + + fn get_lam_mode(stream: Bytes::Stream) -> (Ixon::BinderContract, Bytes::Stream) { + let (mode, s) = read_byte(stream); + let [b0, b1, b2, b3, b4, b5, b6, b7] = UInt8::bit_decomposition(mode); + assert_eq!(b4 + b5 + b6 + b7, 0, "reserved binder contract bits"); + (binder_contract_from_bits(b0, b1, b2, b3), s) + } + + fn get_all_mode(stream: Bytes::Stream) -> ((Ixon::BinderContract, Ixon::ValueContract), Bytes::Stream) { + let (mode, s) = read_byte(stream); + let [b0, b1, b2, b3, b4, b5, b6, b7] = UInt8::bit_decomposition(mode); + assert_eq!(b6 + b7, 0, "reserved forall contract bits"); + ((binder_contract_from_bits(b0, b1, b2, b3), value_contract_from_bits(b4, b5)), s) + } + + fn get_lam_telescope(stream: Bytes::Stream, count: UInt64::U64) -> (&Ixon::Expr, Bytes::Stream) { + let is_zero = UInt64::is_zero(count); + match is_zero { + 1 => { + let (body, s) = get_expr(stream); + match (*(body)) { + Ixon::Expr::Lam(_, _, _) => { + assert_eq!(0, 1, "non-canonical lambda telescope"); + (body, s) } , + _ => { (body, s) } , + } } , + 0 => { + let (contract, s) = get_lam_mode(stream); + let (ty, s2) = get_expr(s); + let (inner, s3) = get_lam_telescope(s2, UInt64::saturating_pred(count)); + ((&(Ixon::Expr::Lam(contract, ty, inner))), s3) } , + } + } + + fn get_all_telescope(stream: Bytes::Stream, count: UInt64::U64) -> (&Ixon::Expr, Bytes::Stream) { + let is_zero = UInt64::is_zero(count); + match is_zero { + 1 => { + let (body, s) = get_expr(stream); + match (*(body)) { + Ixon::Expr::All(_, _, _, _) => { + assert_eq!(0, 1, "non-canonical forall telescope"); + (body, s) } , + _ => { (body, s) } , + } } , + 0 => { + let (mode, s) = get_all_mode(stream); + let (input, result) = mode; + let (ty, s2) = get_expr(s); + let (inner, s3) = get_all_telescope(s2, UInt64::saturating_pred(count)); + ((&(Ixon::Expr::All(input, result, ty, inner))), s3) } , + } + } + + fn get_expr(stream: Bytes::Stream) -> (&Ixon::Expr, Bytes::Stream) { + let (tag, s) = get_tagn4(stream); + let (flag, size) = tag; + match flag { + + 0 => { ((&(Ixon::Expr::Srt(size))), s) } , + + 1 => { ((&(Ixon::Expr::Var(size))), s) } , + + 2 => { + let (ref_idx, s2) = get_tagn0(s); + let (univ_list, s3) = get_u64_list(s2, size); + ((&(Ixon::Expr::Ref(ref_idx, univ_list))), s3) } , + + 3 => { + let (rec_idx, s2) = get_tagn0(s); + let (univ_list, s3) = get_u64_list(s2, size); + ((&(Ixon::Expr::Rec(rec_idx, univ_list))), s3) } , + + 4 => { + let (type_ref_idx, s2) = get_tagn0(s); + let (val, s3) = get_expr(s2); + ((&(Ixon::Expr::Prj(type_ref_idx, size, val))), s3) } , + + 5 => { ((&(Ixon::Expr::Str(size))), s) } , + + 6 => { ((&(Ixon::Expr::Nat(size))), s) } , + + 7 => { + assert_eq!(UInt64::is_zero(size), 0, "App with zero arguments"); + let (func, s2) = get_expr(s); + + match (*(func)) { + Ixon::Expr::App(_, _) => { + assert_eq!(0, 1, "non-canonical application telescope"); + get_app_telescope(func, s2, size) } , + _ => { get_app_telescope(func, s2, size) } , + } } , + + 8 => { + assert_eq!(UInt64::is_zero(size), 0, "Lam with zero binders"); + get_lam_telescope(s, size) } , + + 9 => { + assert_eq!(UInt64::is_zero(size), 0, "All with zero binders"); + get_all_telescope(s, size) } , + + 10 => { get_expr_let(s, size) } , + + 11 => { ((&(Ixon::Expr::Share(size))), s) } , + } + } + + fn get_expr_let(s: Bytes::Stream, size: UInt64::U64) -> (&Ixon::Expr, Bytes::Stream) { + let [head, b1, b2, b3, b4, b5, b6, b7] = size; + assert_eq!(UInt8::to_field(b1) + UInt8::to_field(b2) + UInt8::to_field(b3) + UInt8::to_field(b4) + + UInt8::to_field(b5) + UInt8::to_field(b6) + UInt8::to_field(b7), 0, "oversized let flags"); + assert_eq!(UInt8::less_than(head, UInt8::BYTE_4), 1, "reserved let flags"); + let bits = UInt8::bit_decomposition(head); + let kind = match bits[1] { 0 => { Ixon::LetKind::Value } , 1 => { Ixon::LetKind::BorrowShared } , }; + let (contract, s1) = get_lam_mode(s); + let (ty, s2) = get_expr(s1); + let (value, s3) = get_expr(s2); + let (body, rest) = get_expr(s3); + ((&(Ixon::Expr::Let(Ixon::LetContract::Mk(bits[0], kind, contract), ty, value, body))), rest) + } + + fn build_succ_chain(base: Ixon::Univ, count: UInt64::U64) -> Ixon::Univ { + let is_zero = UInt64::is_zero(count); + match is_zero { + 1 => { base } , + 0 => { + let inner = build_succ_chain(base, UInt64::saturating_pred(count)); + Ixon::Univ::Succ((&(inner))) } , + } + } + + fn get_univ(stream: Bytes::Stream) -> (Ixon::Univ, Bytes::Stream) { + let (tag, s) = get_tagn2(stream); + let (flag, size) = tag; + match flag { + + 0 => { + let is_zero = UInt64::is_zero(size); + match is_zero { + 1 => { (Ixon::Univ::Zero, s) } , + 0 => { + let (base, s2) = get_univ(s); + (build_succ_chain(base, size), s2) } , + } } , + + 1 => { + let (a, s2) = get_univ(s); + let (b, s3) = get_univ(s2); + (Ixon::Univ::Max((&(a)), (&(b))), s3) } , + + 2 => { + let (a, s2) = get_univ(s); + let (b, s3) = get_univ(s2); + (Ixon::Univ::IMax((&(a)), (&(b))), s3) } , + + 3 => { (Ixon::Univ::Var(size), s) } , + } + } + + fn get_address(stream: Bytes::Stream) -> (Bytes::AddressRef, Bytes::Stream) { + let Lists::Node::Cons(b0, s) = (*(stream)); + let Lists::Node::Cons(b1, s) = (*(s)); + let Lists::Node::Cons(b2, s) = (*(s)); + let Lists::Node::Cons(b3, s) = (*(s)); + let Lists::Node::Cons(b4, s) = (*(s)); + let Lists::Node::Cons(b5, s) = (*(s)); + let Lists::Node::Cons(b6, s) = (*(s)); + let Lists::Node::Cons(b7, s) = (*(s)); + let Lists::Node::Cons(b8, s) = (*(s)); + let Lists::Node::Cons(b9, s) = (*(s)); + let Lists::Node::Cons(b10, s) = (*(s)); + let Lists::Node::Cons(b11, s) = (*(s)); + let Lists::Node::Cons(b12, s) = (*(s)); + let Lists::Node::Cons(b13, s) = (*(s)); + let Lists::Node::Cons(b14, s) = (*(s)); + let Lists::Node::Cons(b15, s) = (*(s)); + let Lists::Node::Cons(b16, s) = (*(s)); + let Lists::Node::Cons(b17, s) = (*(s)); + let Lists::Node::Cons(b18, s) = (*(s)); + let Lists::Node::Cons(b19, s) = (*(s)); + let Lists::Node::Cons(b20, s) = (*(s)); + let Lists::Node::Cons(b21, s) = (*(s)); + let Lists::Node::Cons(b22, s) = (*(s)); + let Lists::Node::Cons(b23, s) = (*(s)); + let Lists::Node::Cons(b24, s) = (*(s)); + let Lists::Node::Cons(b25, s) = (*(s)); + let Lists::Node::Cons(b26, s) = (*(s)); + let Lists::Node::Cons(b27, s) = (*(s)); + let Lists::Node::Cons(b28, s) = (*(s)); + let Lists::Node::Cons(b29, s) = (*(s)); + let Lists::Node::Cons(b30, s) = (*(s)); + let Lists::Node::Cons(b31, s) = (*(s)); + ((&([b0, b1, b2, + b3, b4, b5, + b6, b7, b8, + b9, b10, b11, + b12, b13, b14, + b15, b16, b17, + b18, b19, b20, + b21, b22, b23, + b24, b25, b26, + b27, b28, b29, + b30, b31])), s) + } + + fn get_expr_list(stream: Bytes::Stream, count: UInt64::U64) -> (Lists::List<&Ixon::Expr>, Bytes::Stream) { + let is_zero = UInt64::is_zero(count); + match is_zero { + 1 => { ((&(Lists::Node::Nil)), stream) } , + 0 => { + let (expr, s) = get_expr(stream); + let (rest, s2) = get_expr_list(s, UInt64::saturating_pred(count)); + ((&(Lists::Node::Cons(expr, rest))), s2) } , + } + } + + fn get_univ_list(stream: Bytes::Stream, count: UInt64::U64) -> (Lists::List<&Ixon::Univ>, Bytes::Stream) { + let is_zero = UInt64::is_zero(count); + match is_zero { + 1 => { ((&(Lists::Node::Nil)), stream) } , + 0 => { + let (u, s) = get_univ(stream); + let (rest, s2) = get_univ_list(s, UInt64::saturating_pred(count)); + ((&(Lists::Node::Cons((&(u)), rest))), s2) } , + } + } + + fn get_address_list(stream: Bytes::Stream, count: UInt64::U64) -> (Lists::List, Bytes::Stream) { + let is_zero = UInt64::is_zero(count); + match is_zero { + 1 => { ((&(Lists::Node::Nil)), stream) } , + 0 => { + let (addr, s) = get_address(stream); + let (rest, s2) = get_address_list(s, UInt64::saturating_pred(count)); + ((&(Lists::Node::Cons(addr, rest))), s2) } , + } + } + + inline fn get_sharing(stream: Bytes::Stream) -> (Lists::List<&Ixon::Expr>, Bytes::Stream) { + let (len, s) = get_tagn0(stream); + get_expr_list(s, len) + } + + inline fn get_refs(stream: Bytes::Stream) -> (Lists::List, Bytes::Stream) { + let (len, s) = get_tagn0(stream); + get_address_list(s, len) + } + + inline fn get_univs(stream: Bytes::Stream) -> (Lists::List<&Ixon::Univ>, Bytes::Stream) { + let (len, s) = get_tagn0(stream); + get_univ_list(s, len) + } + + fn unpack_def_kind_safety(byte: UInt8::U8) -> (Ixon::DefKind, Ixon::DefinitionSafety) { + match UInt8::to_field(byte) { + 0 => { (Ixon::DefKind::Definition, Ixon::DefinitionSafety::Unsafe) } , + 1 => { (Ixon::DefKind::Definition, Ixon::DefinitionSafety::Safe) } , + 2 => { (Ixon::DefKind::Definition, Ixon::DefinitionSafety::Partial) } , + 4 => { (Ixon::DefKind::Opaque, Ixon::DefinitionSafety::Unsafe) } , + 5 => { (Ixon::DefKind::Opaque, Ixon::DefinitionSafety::Safe) } , + 6 => { (Ixon::DefKind::Opaque, Ixon::DefinitionSafety::Partial) } , + 8 => { (Ixon::DefKind::Theorem, Ixon::DefinitionSafety::Unsafe) } , + 9 => { (Ixon::DefKind::Theorem, Ixon::DefinitionSafety::Safe) } , + 10 => { (Ixon::DefKind::Theorem, Ixon::DefinitionSafety::Partial) } , + } + } + + fn get_definition(stream: Bytes::Stream) -> (Ixon::Definition, Bytes::Stream) { + let (packed, s) = read_byte(stream); + let (kind, safety) = unpack_def_kind_safety(packed); + let (lvls, s2) = get_tagn0(s); + let (typ, s3) = get_expr(s2); + let (value, s4) = get_expr(s3); + (Ixon::Definition::Mk(kind, safety, lvls, typ, value), s4) + } + + inline fn get_recursor_rule(stream: Bytes::Stream) -> (Ixon::RecursorRule, Bytes::Stream) { + let (fields, s) = get_tagn0(stream); + let (rhs, s2) = get_expr(s); + (Ixon::RecursorRule::Mk(fields, rhs), s2) + } + + fn get_recursor_rule_list(stream: Bytes::Stream, count: UInt64::U64) -> (Lists::List, Bytes::Stream) { + let is_zero = UInt64::is_zero(count); + match is_zero { + 1 => { ((&(Lists::Node::Nil)), stream) } , + 0 => { + let (rule, s) = get_recursor_rule(stream); + let (rest, s2) = get_recursor_rule_list(s, UInt64::saturating_pred(count)); + ((&(Lists::Node::Cons(rule, rest))), s2) } , + } + } + + fn get_recursor(stream: Bytes::Stream) -> (Ixon::Recursor, Bytes::Stream) { + let (bools_byte, s) = read_byte(stream); + assert_eq!(UInt8::less_than(bools_byte, UInt8::BYTE_4), 1, "invalid recursor flags"); + let bits = UInt8::bit_decomposition(bools_byte); + let k = bits[0]; + let is_unsafe = bits[1]; + let (lvls, s2) = get_tagn0(s); + let (params, s3) = get_tagn0(s2); + let (indices, s4) = get_tagn0(s3); + let (motives, s5) = get_tagn0(s4); + let (minors, s6) = get_tagn0(s5); + let (typ, s7) = get_expr(s6); + let (rules_len, s8) = get_tagn0(s7); + let (rules, s9) = get_recursor_rule_list(s8, rules_len); + (Ixon::Recursor::Mk(k, is_unsafe, lvls, params, indices, motives, minors, typ, rules), s9) + } + + fn assert_wire_bool(b: UInt8::U8) -> () { + assert_eq!(UInt8::less_than(b, UInt8::BYTE_2), 1, "Bool byte is not 0 or 1"); + () + } + + fn get_axiom(stream: Bytes::Stream) -> (Ixon::Axiom, Bytes::Stream) { + let (is_unsafe, s) = read_byte(stream); + assert_wire_bool(is_unsafe); + let (lvls, s2) = get_tagn0(s); + let (typ, s3) = get_expr(s2); + (Ixon::Axiom::Mk(UInt8::to_field(is_unsafe), lvls, typ), s3) + } + + fn get_quot_kind(byte: UInt8::U8) -> Ixon::QuotKind { + match UInt8::to_field(byte) { + 0 => { Ixon::QuotKind::Typ } , + 1 => { Ixon::QuotKind::Ctor } , + 2 => { Ixon::QuotKind::Lift } , + 3 => { Ixon::QuotKind::Ind } , + } + } + + fn get_quotient(stream: Bytes::Stream) -> (Ixon::Quotient, Bytes::Stream) { + let (kind_byte, s) = read_byte(stream); + let kind = get_quot_kind(kind_byte); + let (lvls, s2) = get_tagn0(s); + let (typ, s3) = get_expr(s2); + (Ixon::Quotient::Mk(kind, lvls, typ), s3) + } + + fn get_constructor(stream: Bytes::Stream) -> (Ixon::Constructor, Bytes::Stream) { + let (is_unsafe, s) = read_byte(stream); + assert_wire_bool(is_unsafe); + let (lvls, s2) = get_tagn0(s); + let (cidx, s3) = get_tagn0(s2); + let (params, s4) = get_tagn0(s3); + let (fields, s5) = get_tagn0(s4); + let (typ, s6) = get_expr(s5); + (Ixon::Constructor::Mk(UInt8::to_field(is_unsafe), lvls, cidx, params, fields, typ), s6) + } + + fn get_constructor_list(stream: Bytes::Stream, count: UInt64::U64) -> (Lists::List, Bytes::Stream) { + let is_zero = UInt64::is_zero(count); + match is_zero { + 1 => { ((&(Lists::Node::Nil)), stream) } , + 0 => { + let (ctor, s) = get_constructor(stream); + let (rest, s2) = get_constructor_list(s, UInt64::saturating_pred(count)); + ((&(Lists::Node::Cons(ctor, rest))), s2) } , + } + } + + fn get_inductive(stream: Bytes::Stream) -> (Ixon::Inductive, Bytes::Stream) { + let (bools_byte, s) = read_byte(stream); + assert_wire_bool(bools_byte); + let bits = UInt8::bit_decomposition(bools_byte); + let is_unsafe = bits[0]; + let (lvls, s2) = get_tagn0(s); + let (params, s3) = get_tagn0(s2); + let (indices, s4) = get_tagn0(s3); + let (typ, s5) = get_expr(s4); + let (ctors_len, s6) = get_tagn0(s5); + let (ctors, s7) = get_constructor_list(s6, ctors_len); + (Ixon::Inductive::Mk(is_unsafe, lvls, params, indices, typ, ctors), s7) + } + + fn get_inductive_proj(stream: Bytes::Stream) -> (Ixon::InductiveProj, Bytes::Stream) { + let (idx, s) = get_tagn0(stream); + let (block, s2) = get_address(s); + (Ixon::InductiveProj::Mk(idx, block), s2) + } + + fn get_constructor_proj(stream: Bytes::Stream) -> (Ixon::ConstructorProj, Bytes::Stream) { + let (idx, s) = get_tagn0(stream); + let (cidx, s2) = get_tagn0(s); + let (block, s3) = get_address(s2); + (Ixon::ConstructorProj::Mk(idx, cidx, block), s3) + } + + fn get_recursor_proj(stream: Bytes::Stream) -> (Ixon::RecursorProj, Bytes::Stream) { + let (idx, s) = get_tagn0(stream); + let (block, s2) = get_address(s); + (Ixon::RecursorProj::Mk(idx, block), s2) + } + + fn get_definition_proj(stream: Bytes::Stream) -> (Ixon::DefinitionProj, Bytes::Stream) { + let (idx, s) = get_tagn0(stream); + let (block, s2) = get_address(s); + (Ixon::DefinitionProj::Mk(idx, block), s2) + } + + fn get_mut_const(stream: Bytes::Stream) -> (Ixon::MutConst, Bytes::Stream) { + let (tag, s) = read_byte(stream); + match UInt8::to_field(tag) { + 0 => { + let (defn, s2) = get_definition(s); + (Ixon::MutConst::Defn(defn), s2) } , + 1 => { + let (indc, s2) = get_inductive(s); + (Ixon::MutConst::Indc(indc), s2) } , + 2 => { + let (recr, s2) = get_recursor(s); + (Ixon::MutConst::Recr(recr), s2) } , + } + } + + fn get_mut_const_list(stream: Bytes::Stream, count: UInt64::U64) -> (Lists::List, Bytes::Stream) { + let is_zero = UInt64::is_zero(count); + match is_zero { + 1 => { ((&(Lists::Node::Nil)), stream) } , + 0 => { + let (mc, s) = get_mut_const(stream); + let (rest, s2) = get_mut_const_list(s, UInt64::saturating_pred(count)); + ((&(Lists::Node::Cons(mc, rest))), s2) } , + } + } + + fn get_constant_info_by_variant(variant: Field, stream: Bytes::Stream) -> (Ixon::ConstantInfo, Bytes::Stream) { + match variant { + 0 => { + let (defn, s) = get_definition(stream); + (Ixon::ConstantInfo::Defn(defn), s) } , + 1 => { + let (recr, s) = get_recursor(stream); + (Ixon::ConstantInfo::Recr(recr), s) } , + 2 => { + let (axim, s) = get_axiom(stream); + (Ixon::ConstantInfo::Axio(axim), s) } , + 3 => { + let (quot, s) = get_quotient(stream); + (Ixon::ConstantInfo::Quot(quot), s) } , + 4 => { + let (prj, s) = get_constructor_proj(stream); + (Ixon::ConstantInfo::CPrj(prj), s) } , + 5 => { + let (prj, s) = get_recursor_proj(stream); + (Ixon::ConstantInfo::RPrj(prj), s) } , + 6 => { + let (prj, s) = get_inductive_proj(stream); + (Ixon::ConstantInfo::IPrj(prj), s) } , + 7 => { + let (prj, s) = get_definition_proj(stream); + (Ixon::ConstantInfo::DPrj(prj), s) } , + } + } + + inline fn get_constant_info(flag: Field, size: UInt64::U64, stream: Bytes::Stream) -> (Ixon::ConstantInfo, Bytes::Stream) { + match flag { + + 12 => { + let (mutuals, s) = get_mut_const_list(stream, size); + (Ixon::ConstantInfo::Muts(mutuals), s) } , + + 13 => { + let [_, sz1, sz2, sz3, sz4, sz5, sz6, sz7] = size; + assert_eq!(((((((UInt8::to_field(sz1) + UInt8::to_field(sz2)) + UInt8::to_field(sz3)) + + UInt8::to_field(sz4)) + UInt8::to_field(sz5)) + UInt8::to_field(sz6)) + + UInt8::to_field(sz7)), 0, + "constant info: TagN size exceeds a single byte"); + get_constant_info_by_variant(UInt8::to_field(size[0]), stream) } , + } + } + + fn get_constant(stream: Bytes::Stream) -> (Ixon::Constant, Bytes::Stream) { + let (tag, s) = get_tagn4(stream); + let (flag, size) = tag; + let (info, s2) = get_constant_info(flag, size, s); + let (sharing, s3) = get_sharing(s2); + let (refs, s4) = get_refs(s3); + let (univs, s5) = get_univs(s4); + (Ixon::Constant::Mk(info, sharing, refs, univs), s5) + } +} diff --git a/IxVM/IxVM/Modules/IxonSerialize.aiur b/IxVM/IxVM/Modules/IxonSerialize.aiur new file mode 100644 index 000000000..e82acd477 --- /dev/null +++ b/IxVM/IxVM/Modules/IxonSerialize.aiur @@ -0,0 +1,531 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module IxonSerialize { + fn put_expr(expr: Ixon::Expr, rest: Bytes::Stream) -> Bytes::Stream { + match expr { + + Ixon::Expr::Srt(univ_idx) => { put_tagn4(0, univ_idx, rest) } , + + Ixon::Expr::Var(idx) => { put_tagn4(1, idx, rest) } , + + Ixon::Expr::Ref(ref_idx, univ_list) => { + let len = WordLists::length_u64(univ_list); + put_tagn4(2, len, put_tagn0(ref_idx, put_u64_list(univ_list, rest))) } , + + Ixon::Expr::Rec(rec_idx, univ_list) => { + let len = WordLists::length_u64(univ_list); + put_tagn4(3, len, put_tagn0(rec_idx, put_u64_list(univ_list, rest))) } , + + Ixon::Expr::Prj(type_ref_idx, field_idx, &val) => { + put_tagn4(4, field_idx, put_tagn0(type_ref_idx, put_expr(val, rest))) } , + + Ixon::Expr::Str(ref_idx) => { put_tagn4(5, ref_idx, rest) } , + + Ixon::Expr::Nat(ref_idx) => { put_tagn4(6, ref_idx, rest) } , + + Ixon::Expr::App(_, _) => { + let count = app_telescope_count(expr); + put_tagn4(7, count, put_app_telescope(expr, rest)) } , + + Ixon::Expr::Lam(_, _, _) => { + let count = lam_telescope_count(expr); + put_tagn4(8, count, put_lam_telescope(expr, rest)) } , + + Ixon::Expr::All(_, _, _, _) => { + let count = all_telescope_count(expr); + put_tagn4(9, count, put_all_telescope(expr, rest)) } , + + Ixon::Expr::Let(Ixon::LetContract::Mk(non_dep, kind, contract), &ty, &val, &body) => { + let kind_bit = match kind { Ixon::LetKind::Value => { 0 } , Ixon::LetKind::BorrowShared => { 1 } , }; + let flags = [UInt8::from_field(non_dep + 2 * kind_bit), UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0]; + put_tagn4(10, flags, put_lam_mode(contract, + put_expr(ty, put_expr(val, put_expr(body, rest))))) } , + + Ixon::Expr::Share(idx) => { put_tagn4(11, idx, rest) } , + } + } + + fn put_u64_le(bs: UInt64::U64, num_bytes: Field, rest: Bytes::Stream) -> Bytes::Stream { + match num_bytes { + 0 => { rest } , + _ => { + let [b1, b2, b3, b4, b5, b6, b7, b8] = bs; + let rest_shifted = [b2, b3, b4, b5, b6, b7, b8, UInt8::BYTE_0]; + (&(Lists::Node::Cons(b1, put_u64_le(rest_shifted, num_bytes - 1, rest)))) } , + } + } + + fn put_tagn4(flag: Field, v: UInt64::U64, rest: Bytes::Stream) -> Bytes::Stream { + let [v0, v1, v2, v3, v4, v5, v6, v7] = v; + match UInt8::to_field(v1) + UInt8::to_field(v2) + UInt8::to_field(v3) + UInt8::to_field(v4) + + UInt8::to_field(v5) + UInt8::to_field(v6) + UInt8::to_field(v7) { + 0 => { + match UInt8::less_than(v0, UInt8::BYTE_8) { + 1 => { (&(Lists::Node::Cons(UInt8::from_field(16 * flag + UInt8::to_field(v0)), rest))) } , + 0 => { put_tagn_tail(16 * flag, 4, v, rest) } , + } } , + _ => { put_tagn_tail(16 * flag, 4, v, rest) } , + } + } + + fn put_tagn2(flag: Field, v: UInt64::U64, rest: Bytes::Stream) -> Bytes::Stream { + let [v0, v1, v2, v3, v4, v5, v6, v7] = v; + match UInt8::to_field(v1) + UInt8::to_field(v2) + UInt8::to_field(v3) + UInt8::to_field(v4) + + UInt8::to_field(v5) + UInt8::to_field(v6) + UInt8::to_field(v7) { + 0 => { + match UInt8::less_than(v0, UInt8::BYTE_32) { + 1 => { (&(Lists::Node::Cons(UInt8::from_field(64 * flag + UInt8::to_field(v0)), rest))) } , + 0 => { put_tagn_tail(64 * flag, 16, v, rest) } , + } } , + _ => { put_tagn_tail(64 * flag, 16, v, rest) } , + } + } + + fn put_tagn0(v: UInt64::U64, rest: Bytes::Stream) -> Bytes::Stream { + let [v0, v1, v2, v3, v4, v5, v6, v7] = v; + match UInt8::to_field(v1) + UInt8::to_field(v2) + UInt8::to_field(v3) + UInt8::to_field(v4) + + UInt8::to_field(v5) + UInt8::to_field(v6) + UInt8::to_field(v7) { + 0 => { + match UInt8::less_than(v0, UInt8::BYTE_128) { + 1 => { (&(Lists::Node::Cons(v0, rest))) } , + 0 => { put_tagn_tail(0, 64, v, rest) } , + } } , + _ => { put_tagn_tail(0, 64, v, rest) } , + } + } + + fn put_tagn_tail(base: Field, h: Field, v: UInt64::U64, rest: Bytes::Stream) -> Bytes::Stream { + let (d, at_least_r2) = UInt64::add(v, [UInt8::from_field(256 - 2 * h), + UInt8::from_field(255 - h), UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255]); + match UInt8::to_field(at_least_r2) { + + 0 => { + let (lo, no_borrow) = UInt8::raw_add(UInt8::to_field(v[0]), 256 - 2 * h); + let hi = UInt8::to_field(v[1]) + UInt8::to_field(no_borrow) - 1; + (&(Lists::Node::Cons(UInt8::from_field(base + 2 * h + hi), + (&(Lists::Node::Cons(lo, rest)))))) } , + 1 => { put_tagn_wide(base + 3 * h, 0, d, rest) } , + } + } + + fn put_tagn_wide(header: Field, c: Field, d: UInt64::U64, rest: Bytes::Stream) -> Bytes::Stream { + let [_, _, d2, d3, d4, d5, d6, d7] = d; + match c { + 0 => { + match UInt8::to_field(d2) + UInt8::to_field(d3) + UInt8::to_field(d4) + UInt8::to_field(d5) + + UInt8::to_field(d6) + UInt8::to_field(d7) { + 0 => { (&(Lists::Node::Cons(UInt8::from_field(header), put_u64_le(d, 2, rest)))) } , + _ => { + let (next, _) = UInt64::add(d, [UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255]); + put_tagn_wide(header, 1, next, rest) } , + } } , + 1 => { + match UInt8::to_field(d3) + UInt8::to_field(d4) + UInt8::to_field(d5) + UInt8::to_field(d6) + UInt8::to_field(d7) { + 0 => { (&(Lists::Node::Cons(UInt8::from_field(header + 1), put_u64_le(d, 3, rest)))) } , + _ => { + let (next, _) = UInt64::add(d, [UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255]); + put_tagn_wide(header, 2, next, rest) } , + } } , + 2 => { + match UInt8::to_field(d4) + UInt8::to_field(d5) + UInt8::to_field(d6) + UInt8::to_field(d7) { + 0 => { (&(Lists::Node::Cons(UInt8::from_field(header + 2), put_u64_le(d, 4, rest)))) } , + _ => { + let (next, _) = UInt64::add(d, [UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255]); + put_tagn_wide(header, 3, next, rest) } , + } } , + 3 => { (&(Lists::Node::Cons(UInt8::from_field(header + 3), put_u64_le(d, 8, rest)))) } , + } + } + + fn put_u64_list(list: Lists::List, rest: Bytes::Stream) -> Bytes::Stream { + match (*(list)) { + Lists::Node::Nil => { rest } , + Lists::Node::Cons(idx, rest_list) => { + put_tagn0(idx, put_u64_list(rest_list, rest)) } , + } + } + + fn value_contract_code(value: Ixon::ValueContract) -> Field { + let Ixon::ValueContract::Mk(owned, locality) = value; + let o = match owned { Ixon::Owned::Unique => { 0 } , Ixon::Owned::Shared => { 1 } , }; + let l = match locality { Ixon::Locality::Unrestricted => { 0 } , Ixon::Locality::Local => { 1 } , }; + o + 2 * l + } + + fn binder_contract_code(contract: Ixon::BinderContract) -> Field { + let Ixon::BinderContract::Mk(uses, value) = contract; + let u = match uses { Ixon::Uses::Erased => { 0 } , Ixon::Uses::Linear => { 1 } , Ixon::Uses::Affine => { 2 } , Ixon::Uses::Many => { 3 } , }; + u + 4 * value_contract_code(value) + } + + fn put_lam_mode(contract: Ixon::BinderContract, rest: Bytes::Stream) -> Bytes::Stream { + (&(Lists::Node::Cons(UInt8::from_field(binder_contract_code(contract)), rest))) + } + + fn put_all_mode(contract: Ixon::BinderContract, result: Ixon::ValueContract, rest: Bytes::Stream) -> Bytes::Stream { + let code = binder_contract_code(contract) + 16 * value_contract_code(result); + (&(Lists::Node::Cons(UInt8::from_field(code), rest))) + } + + fn app_telescope_count(expr: Ixon::Expr) -> UInt64::U64 { + match expr { + Ixon::Expr::App(&func, _) => { UInt64::wrapping_succ(app_telescope_count(func)) } , + _ => { [UInt8::BYTE_0; 8] } , + } + } + + fn lam_telescope_count(expr: Ixon::Expr) -> UInt64::U64 { + match expr { + Ixon::Expr::Lam(_, _, &body) => { UInt64::wrapping_succ(lam_telescope_count(body)) } , + _ => { [UInt8::BYTE_0; 8] } , + } + } + + fn all_telescope_count(expr: Ixon::Expr) -> UInt64::U64 { + match expr { + Ixon::Expr::All(_, _, _, &body) => { UInt64::wrapping_succ(all_telescope_count(body)) } , + _ => { [UInt8::BYTE_0; 8] } , + } + } + + fn put_app_telescope(expr: Ixon::Expr, rest: Bytes::Stream) -> Bytes::Stream { + match expr { + Ixon::Expr::App(&func, &arg) => { + put_app_telescope(func, put_expr(arg, rest)) } , + _ => { put_expr(expr, rest) } , + } + } + + fn put_lam_telescope(expr: Ixon::Expr, rest: Bytes::Stream) -> Bytes::Stream { + match expr { + Ixon::Expr::Lam(contract, &ty, &body) => { + put_lam_mode(contract, put_expr(ty, put_lam_telescope(body, rest))) } , + _ => { put_expr(expr, rest) } , + } + } + + fn put_all_telescope(expr: Ixon::Expr, rest: Bytes::Stream) -> Bytes::Stream { + match expr { + Ixon::Expr::All(input, result, &ty, &body) => { + put_all_mode(input, result, put_expr(ty, put_all_telescope(body, rest))) } , + _ => { put_expr(expr, rest) } , + } + } + + fn put_address(a: Bytes::AddressRef, rest: Bytes::Stream) -> Bytes::Stream { + let arr = (*(a)); + let list31 = (&(Lists::Node::Cons(arr[31], rest))); + let list30 = (&(Lists::Node::Cons(arr[30], list31))); + let list29 = (&(Lists::Node::Cons(arr[29], list30))); + let list28 = (&(Lists::Node::Cons(arr[28], list29))); + let list27 = (&(Lists::Node::Cons(arr[27], list28))); + let list26 = (&(Lists::Node::Cons(arr[26], list27))); + let list25 = (&(Lists::Node::Cons(arr[25], list26))); + let list24 = (&(Lists::Node::Cons(arr[24], list25))); + let list23 = (&(Lists::Node::Cons(arr[23], list24))); + let list22 = (&(Lists::Node::Cons(arr[22], list23))); + let list21 = (&(Lists::Node::Cons(arr[21], list22))); + let list20 = (&(Lists::Node::Cons(arr[20], list21))); + let list19 = (&(Lists::Node::Cons(arr[19], list20))); + let list18 = (&(Lists::Node::Cons(arr[18], list19))); + let list17 = (&(Lists::Node::Cons(arr[17], list18))); + let list16 = (&(Lists::Node::Cons(arr[16], list17))); + let list15 = (&(Lists::Node::Cons(arr[15], list16))); + let list14 = (&(Lists::Node::Cons(arr[14], list15))); + let list13 = (&(Lists::Node::Cons(arr[13], list14))); + let list12 = (&(Lists::Node::Cons(arr[12], list13))); + let list11 = (&(Lists::Node::Cons(arr[11], list12))); + let list10 = (&(Lists::Node::Cons(arr[10], list11))); + let list9 = (&(Lists::Node::Cons(arr[9], list10))); + let list8 = (&(Lists::Node::Cons(arr[8], list9))); + let list7 = (&(Lists::Node::Cons(arr[7], list8))); + let list6 = (&(Lists::Node::Cons(arr[6], list7))); + let list5 = (&(Lists::Node::Cons(arr[5], list6))); + let list4 = (&(Lists::Node::Cons(arr[4], list5))); + let list3 = (&(Lists::Node::Cons(arr[3], list4))); + let list2 = (&(Lists::Node::Cons(arr[2], list3))); + let list1 = (&(Lists::Node::Cons(arr[1], list2))); + (&(Lists::Node::Cons(arr[0], list1))) + } + + fn pack_def_kind_safety(kind: Ixon::DefKind, safety: Ixon::DefinitionSafety) -> Field { + match (kind, safety) { + (Ixon::DefKind::Definition, Ixon::DefinitionSafety::Unsafe) => { 0 } , + (Ixon::DefKind::Definition, Ixon::DefinitionSafety::Safe) => { 1 } , + (Ixon::DefKind::Definition, Ixon::DefinitionSafety::Partial) => { 2 } , + (Ixon::DefKind::Opaque, Ixon::DefinitionSafety::Unsafe) => { 4 } , + (Ixon::DefKind::Opaque, Ixon::DefinitionSafety::Safe) => { 5 } , + (Ixon::DefKind::Opaque, Ixon::DefinitionSafety::Partial) => { 6 } , + (Ixon::DefKind::Theorem, Ixon::DefinitionSafety::Unsafe) => { 8 } , + (Ixon::DefKind::Theorem, Ixon::DefinitionSafety::Safe) => { 9 } , + (Ixon::DefKind::Theorem, Ixon::DefinitionSafety::Partial) => { 10 } , + } + } + + fn univ_succ_count(u: Ixon::Univ) -> UInt64::U64 { + match u { + Ixon::Univ::Succ(&inner) => { UInt64::wrapping_succ(univ_succ_count(inner)) } , + _ => { [UInt8::BYTE_0; 8] } , + } + } + + fn univ_succ_base(u: Ixon::Univ) -> Ixon::Univ { + match u { + Ixon::Univ::Succ(&inner) => { univ_succ_base(inner) } , + _ => { u } , + } + } + + fn put_univ(u: Ixon::Univ, rest: Bytes::Stream) -> Bytes::Stream { + match u { + Ixon::Univ::Zero => { + + (&(Lists::Node::Cons(UInt8::BYTE_0, rest))) } , + + Ixon::Univ::Succ(_) => { + + let count = univ_succ_count(u); + + let base = univ_succ_base(u); + + put_tagn2(0, count, put_univ(base, rest)) } , + + Ixon::Univ::Max(&a, &b) => { + + put_tagn2(1, [UInt8::BYTE_0; 8], put_univ(a, put_univ(b, rest))) } , + + Ixon::Univ::IMax(&a, &b) => { + + put_tagn2(2, [UInt8::BYTE_0; 8], put_univ(a, put_univ(b, rest))) } , + + Ixon::Univ::Var(idx) => { + + put_tagn2(3, idx, rest) } , + } + } + + fn put_expr_list(list: Lists::List<&Ixon::Expr>, rest: Bytes::Stream) -> Bytes::Stream { + match (*(list)) { + Lists::Node::Nil => { rest } , + Lists::Node::Cons(&expr, rest_list) => { + put_expr(expr, put_expr_list(rest_list, rest)) } , + } + } + + fn put_univ_list(list: Lists::List<&Ixon::Univ>, rest: Bytes::Stream) -> Bytes::Stream { + match (*(list)) { + Lists::Node::Nil => { rest } , + Lists::Node::Cons(&u, rest_list) => { + put_univ(u, put_univ_list(rest_list, rest)) } , + } + } + + fn put_address_list(list: Lists::List, rest: Bytes::Stream) -> Bytes::Stream { + match (*(list)) { + Lists::Node::Nil => { rest } , + Lists::Node::Cons(addr, rest_list) => { + put_address(addr, put_address_list(rest_list, rest)) } , + } + } + + fn put_quot_kind(kind: Ixon::QuotKind, rest: Bytes::Stream) -> Bytes::Stream { + match kind { + Ixon::QuotKind::Typ => { (&(Lists::Node::Cons(UInt8::BYTE_0, rest))) } , + Ixon::QuotKind::Ctor => { (&(Lists::Node::Cons(UInt8::BYTE_1, rest))) } , + Ixon::QuotKind::Lift => { (&(Lists::Node::Cons(UInt8::BYTE_2, rest))) } , + Ixon::QuotKind::Ind => { (&(Lists::Node::Cons(UInt8::BYTE_3, rest))) } , + } + } + + fn put_definition(defn: Ixon::Definition, rest: Bytes::Stream) -> Bytes::Stream { + match defn { + Ixon::Definition::Mk(kind, safety, lvls, &typ, &value) => { + let packed = pack_def_kind_safety(kind, safety); + (&(Lists::Node::Cons(UInt8::from_field(packed), put_tagn0(lvls, put_expr(typ, put_expr(value, rest)))))) } , + } + } + + fn put_recursor_rule(rule: Ixon::RecursorRule, rest: Bytes::Stream) -> Bytes::Stream { + match rule { + Ixon::RecursorRule::Mk(fields, &rhs) => { + put_tagn0(fields, put_expr(rhs, rest)) } , + } + } + + fn put_recursor_rule_list(list: Lists::List, rest: Bytes::Stream) -> Bytes::Stream { + match (*(list)) { + Lists::Node::Nil => { rest } , + Lists::Node::Cons(rule, rest_list) => { + put_recursor_rule(rule, put_recursor_rule_list(rest_list, rest)) } , + } + } + + fn put_recursor(recr: Ixon::Recursor, rest: Bytes::Stream) -> Bytes::Stream { + match recr { + Ixon::Recursor::Mk(k, is_unsafe, lvls, params, indices, motives, minors, &typ, rules) => { + let bools = k + 2 * is_unsafe; + let rules_len = WordLists::length_u64(rules); + (&(Lists::Node::Cons(UInt8::from_field(bools), + put_tagn0(lvls, + put_tagn0(params, + put_tagn0(indices, + put_tagn0(motives, + put_tagn0(minors, + put_expr(typ, + put_tagn0(rules_len, + put_recursor_rule_list(rules, rest))))))))))) } , + } + } + + fn put_axiom(axim: Ixon::Axiom, rest: Bytes::Stream) -> Bytes::Stream { + match axim { + Ixon::Axiom::Mk(is_unsafe, lvls, &typ) => { + (&(Lists::Node::Cons(UInt8::from_field(is_unsafe), put_tagn0(lvls, put_expr(typ, rest))))) } , + } + } + + fn put_quotient(quot: Ixon::Quotient, rest: Bytes::Stream) -> Bytes::Stream { + match quot { + Ixon::Quotient::Mk(kind, lvls, &typ) => { + put_quot_kind(kind, put_tagn0(lvls, put_expr(typ, rest))) } , + } + } + + fn put_constructor(ctor: Ixon::Constructor, rest: Bytes::Stream) -> Bytes::Stream { + match ctor { + Ixon::Constructor::Mk(is_unsafe, lvls, cidx, params, fields, &typ) => { + (&(Lists::Node::Cons(UInt8::from_field(is_unsafe), + put_tagn0(lvls, + put_tagn0(cidx, + put_tagn0(params, + put_tagn0(fields, + put_expr(typ, rest)))))))) } , + } + } + + fn put_constructor_list(list: Lists::List, rest: Bytes::Stream) -> Bytes::Stream { + match (*(list)) { + Lists::Node::Nil => { rest } , + Lists::Node::Cons(ctor, rest_list) => { + put_constructor(ctor, put_constructor_list(rest_list, rest)) } , + } + } + + fn put_inductive(indc: Ixon::Inductive, rest: Bytes::Stream) -> Bytes::Stream { + match indc { + Ixon::Inductive::Mk(is_unsafe, lvls, params, indices, &typ, ctors) => { + let ctors_len = WordLists::length_u64(ctors); + (&(Lists::Node::Cons(UInt8::from_field(is_unsafe), + put_tagn0(lvls, + put_tagn0(params, + put_tagn0(indices, + put_expr(typ, + put_tagn0(ctors_len, + put_constructor_list(ctors, rest))))))))) } , + } + } + + fn put_inductive_proj(prj: Ixon::InductiveProj, rest: Bytes::Stream) -> Bytes::Stream { + match prj { + Ixon::InductiveProj::Mk(idx, block) => { + put_tagn0(idx, put_address(block, rest)) } , + } + } + + fn put_constructor_proj(prj: Ixon::ConstructorProj, rest: Bytes::Stream) -> Bytes::Stream { + match prj { + Ixon::ConstructorProj::Mk(idx, cidx, block) => { + put_tagn0(idx, put_tagn0(cidx, put_address(block, rest))) } , + } + } + + fn put_recursor_proj(prj: Ixon::RecursorProj, rest: Bytes::Stream) -> Bytes::Stream { + match prj { + Ixon::RecursorProj::Mk(idx, block) => { + put_tagn0(idx, put_address(block, rest)) } , + } + } + + fn put_definition_proj(prj: Ixon::DefinitionProj, rest: Bytes::Stream) -> Bytes::Stream { + match prj { + Ixon::DefinitionProj::Mk(idx, block) => { + put_tagn0(idx, put_address(block, rest)) } , + } + } + + fn put_mut_const(mc: Ixon::MutConst, rest: Bytes::Stream) -> Bytes::Stream { + match mc { + Ixon::MutConst::Defn(defn) => { + (&(Lists::Node::Cons(UInt8::BYTE_0, put_definition(defn, rest)))) } , + Ixon::MutConst::Indc(indc) => { + (&(Lists::Node::Cons(UInt8::BYTE_1, put_inductive(indc, rest)))) } , + Ixon::MutConst::Recr(recr) => { + (&(Lists::Node::Cons(UInt8::BYTE_2, put_recursor(recr, rest)))) } , + } + } + + fn put_mut_const_list(list: Lists::List, rest: Bytes::Stream) -> Bytes::Stream { + match (*(list)) { + Lists::Node::Nil => { rest } , + Lists::Node::Cons(mc, rest_list) => { + put_mut_const(mc, put_mut_const_list(rest_list, rest)) } , + } + } + + fn put_constant_info(info: Ixon::ConstantInfo, rest: Bytes::Stream) -> Bytes::Stream { + match info { + Ixon::ConstantInfo::Defn(defn) => { put_definition(defn, rest) } , + Ixon::ConstantInfo::Recr(recr) => { put_recursor(recr, rest) } , + Ixon::ConstantInfo::Axio(axim) => { put_axiom(axim, rest) } , + Ixon::ConstantInfo::Quot(quot) => { put_quotient(quot, rest) } , + Ixon::ConstantInfo::CPrj(prj) => { put_constructor_proj(prj, rest) } , + Ixon::ConstantInfo::RPrj(prj) => { put_recursor_proj(prj, rest) } , + Ixon::ConstantInfo::IPrj(prj) => { put_inductive_proj(prj, rest) } , + Ixon::ConstantInfo::DPrj(prj) => { put_definition_proj(prj, rest) } , + } + } + + fn put_sharing(list: Lists::List<&Ixon::Expr>, rest: Bytes::Stream) -> Bytes::Stream { + let len = WordLists::length_u64(list); + put_tagn0(len, put_expr_list(list, rest)) + } + + fn put_refs(list: Lists::List, rest: Bytes::Stream) -> Bytes::Stream { + let len = WordLists::length_u64(list); + put_tagn0(len, put_address_list(list, rest)) + } + + fn put_univs(list: Lists::List<&Ixon::Univ>, rest: Bytes::Stream) -> Bytes::Stream { + let len = WordLists::length_u64(list); + put_tagn0(len, put_univ_list(list, rest)) + } + + fn put_constant(cnst: Ixon::Constant, rest: Bytes::Stream) -> Bytes::Stream { + match cnst { + Ixon::Constant::Mk(info, sharing, refs, univs) => { + let up_to_sharing = put_sharing(sharing, put_refs(refs, put_univs(univs, rest))); + match info { + Ixon::ConstantInfo::Muts(mutuals) => { + + let count = WordLists::length_u64(mutuals); + put_tagn4(12, count, put_mut_const_list(mutuals, up_to_sharing)) } , + + Ixon::ConstantInfo::Defn(_) => { + put_tagn4(13, [UInt8::BYTE_0; 8], put_constant_info(info, up_to_sharing)) } , + Ixon::ConstantInfo::Recr(_) => { + put_tagn4(13, [UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], put_constant_info(info, up_to_sharing)) } , + Ixon::ConstantInfo::Axio(_) => { + put_tagn4(13, [UInt8::BYTE_2, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], put_constant_info(info, up_to_sharing)) } , + Ixon::ConstantInfo::Quot(_) => { + put_tagn4(13, [UInt8::BYTE_3, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], put_constant_info(info, up_to_sharing)) } , + Ixon::ConstantInfo::CPrj(_) => { + put_tagn4(13, [UInt8::BYTE_4, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], put_constant_info(info, up_to_sharing)) } , + Ixon::ConstantInfo::RPrj(_) => { + put_tagn4(13, [UInt8::BYTE_5, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], put_constant_info(info, up_to_sharing)) } , + Ixon::ConstantInfo::IPrj(_) => { + put_tagn4(13, [UInt8::BYTE_6, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], put_constant_info(info, up_to_sharing)) } , + Ixon::ConstantInfo::DPrj(_) => { + put_tagn4(13, [UInt8::BYTE_7, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], put_constant_info(info, up_to_sharing)) } , + } } , + } + } +} diff --git a/IxVM/IxVM/Modules/KernelCheck.aiur b/IxVM/IxVM/Modules/KernelCheck.aiur new file mode 100644 index 000000000..186984135 --- /dev/null +++ b/IxVM/IxVM/Modules/KernelCheck.aiur @@ -0,0 +1,2526 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module KernelCheck { + fn is_unsafe_ci(ci: KernelTypes::KConstantInfo) -> Field { + match ci { + KernelTypes::KConstantInfo::Axiom(_, _, u) => { u } , + KernelTypes::KConstantInfo::Defn(_, _, _, s, _) => { + match s { + Ixon::DefinitionSafety::Safe => { 0 } , + _ => { 1 } , + } } , + KernelTypes::KConstantInfo::Thm(_, _, _) => { 0 } , + KernelTypes::KConstantInfo::Opaque(_, _, _, u) => { u } , + KernelTypes::KConstantInfo::Quot(_, _, _) => { 0 } , + KernelTypes::KConstantInfo::Induct(_, _, _, _, _, u, _, _) => { u } , + KernelTypes::KConstantInfo::Ctor(_, _, _, _, _, _, _, u) => { u } , + KernelTypes::KConstantInfo::Rec(_, _, _, _, _, _, _, _, u, _, _) => { u } , + } + } + + fn safe_refs_only(e: KernelTypes::KExpr) -> Field { + match (*(e)) { + KernelTypes::KExprNode::BVar(_) => { 1 } , + KernelTypes::KExprNode::Srt(_) => { 1 } , + KernelTypes::KExprNode::Const(caddr, _) => { + let ci = (*(Ingress::get_ci(caddr))); + 1 - is_unsafe_ci(ci) } , + KernelTypes::KExprNode::App(f, a) => { + safe_refs_only(f) * safe_refs_only(a) } , + KernelTypes::KExprNode::Lam(t, b) => { + safe_refs_only(t) * safe_refs_only(b) } , + KernelTypes::KExprNode::Forall(t, b) => { + safe_refs_only(t) * safe_refs_only(b) } , + KernelTypes::KExprNode::Let(t, v, b) => { + safe_refs_only(t) * safe_refs_only(v) * safe_refs_only(b) } , + KernelTypes::KExprNode::Lit(_) => { 1 } , + KernelTypes::KExprNode::Proj(_, _, e1) => { safe_refs_only(e1) } , + } + } + + fn assert_safety(self_unsafe: Field, e: KernelTypes::KExpr) -> () { + match self_unsafe { + 1 => { () } , + _ => { + assert_eq!(safe_refs_only(e), 1, + "safe constant references an unsafe constant"); + () } , + } + } + + fn validate_univ_params_seen(u: KernelTypes::KLevel, bound: Field) -> () { + match (*(u)) { + KernelTypes::KLevelNode::Zero => { () } , + KernelTypes::KLevelNode::Succ(inner) => { validate_univ_params_seen(inner, bound) } , + KernelTypes::KLevelNode::Max(a, b) => { + validate_univ_params_seen(a, bound); + validate_univ_params_seen(b, bound) } , + KernelTypes::KLevelNode::IMax(a, b) => { + validate_univ_params_seen(a, bound); + validate_univ_params_seen(b, bound) } , + KernelTypes::KLevelNode::Param(i) => { + assert_eq!(UInt32::less_than_fields(i, bound), 1, + "universe param index out of range"); + () } , + } + } + + fn validate_univ_params_list(lvls: Lists::List, bound: Field) -> () { + match (*(lvls)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(u, rest) => { + validate_univ_params_seen(u, bound); + validate_univ_params_list(rest, bound) } , + } + } + + fn validate_expr_well_scoped(e: KernelTypes::KExpr, depth: Field, bound: Field) -> () { + match (*(e)) { + KernelTypes::KExprNode::BVar(i) => { + assert_eq!(UInt32::less_than_fields(i, depth), 1, + "loose bound variable: BVar index exceeds binder depth"); + () } , + KernelTypes::KExprNode::Srt(l) => { validate_univ_params_seen(l, bound) } , + KernelTypes::KExprNode::Const(addr, lvls) => { + let ci = (*(Ingress::get_ci(addr))); + let expected = KernelInfer::const_num_lvls(ci); + assert_eq!(Lists::length(lvls), expected, + "Const applied to wrong number of universe levels"); + validate_univ_params_list(lvls, bound) } , + KernelTypes::KExprNode::App(f, a) => { + validate_expr_well_scoped(f, depth, bound); + validate_expr_well_scoped(a, depth, bound) } , + KernelTypes::KExprNode::Lam(t, b) => { + validate_expr_well_scoped(t, depth, bound); + validate_expr_well_scoped(b, depth + 1, bound) } , + KernelTypes::KExprNode::Forall(t, b) => { + validate_expr_well_scoped(t, depth, bound); + validate_expr_well_scoped(b, depth + 1, bound) } , + KernelTypes::KExprNode::Let(t, v, b) => { + validate_expr_well_scoped(t, depth, bound); + validate_expr_well_scoped(v, depth, bound); + validate_expr_well_scoped(b, depth + 1, bound) } , + KernelTypes::KExprNode::Lit(_) => { () } , + KernelTypes::KExprNode::Proj(_, _, e1) => { + validate_expr_well_scoped(e1, depth, bound) } , + } + } + + fn check_quot(rc: KernelRoles::RoleCtx, self_addr: Bytes::AddressRef, kind: Ixon::QuotKind) -> () { + let r = match kind { + Ixon::QuotKind::Typ => { KernelRoleSpec::role_quot() } , + Ixon::QuotKind::Ctor => { KernelRoleSpec::role_quot_mk() } , + Ixon::QuotKind::Lift => { KernelRoleSpec::role_quot_lift() } , + Ixon::QuotKind::Ind => { KernelRoleSpec::role_quot_ind() } , + }; + assert_eq!(KernelRoles::role_is(rc, self_addr, r), 1, + "a quotient constant is not the binding's quotient role of its kind"); + () + } + + fn peel_n_foralls(e: KernelTypes::KExpr, n: Field) -> KernelTypes::KExpr { + match n { + 0 => { e } , + _ => { + match (*(e)) { + KernelTypes::KExprNode::Forall(_, body) => { peel_n_foralls(body, n - 1) } , + } } , + } + } + + fn assert_lvls_are_params(lvls: Lists::List, count: Field, idx: Field) -> () { + match count { + 0 => { + assert_eq!(Lists::length(lvls), 0, + "more universe levels than the inductive declares"); + () } , + _ => { + match (*(lvls)) { + Lists::Node::Cons(l, rest) => { + match (*(l)) { + KernelTypes::KLevelNode::Param(i) => { + assert_eq!(i, idx, + "ctor return type: universe level is not Param(i) in order"); + assert_lvls_are_params(rest, count - 1, idx + 1); + () } , + } } , + } } , + } + } + + fn assert_first_args_are_param_bvars(args: Lists::List, + n_params: Field, n_fields: Field, i: Field) -> () { + match n_params - i { + 0 => { () } , + _ => { + match (*(args)) { + Lists::Node::Cons(arg, rest) => { + match (*(arg)) { + KernelTypes::KExprNode::BVar(j) => { + assert_eq!(j, ((n_fields + n_params) - 1) - i, + "ctor return type: param arg is not the expected param BVar"); + assert_first_args_are_param_bvars(rest, n_params, n_fields, i + 1); + () } , + } } , + } } , + } + } + + fn assert_return_head_is_parent(caddr: Bytes::AddressRef, block_addr: Bytes::AddressRef, + ind_idx: Field) -> () { + let ci = (*(Ingress::get_ci(caddr))); + match ci { + KernelTypes::KConstantInfo::Induct(_, _, _, _, _, _, ba, ii) => { + assert_eq!(Bytes::address_eq(ba, block_addr), 1, + "ctor return head belongs to a different block"); + assert_eq!(ii, ind_idx, + "ctor return head is a different member of the block"); + () } , + } + } + + fn check_ctor_return_type(ctor_ty: KernelTypes::KExpr, n_params: Field, + n_indices: Field, n_fields: Field, + ind_num_lvls: Field, block_addr: Bytes::AddressRef, + ind_idx: Field) -> () { + let body = peel_n_foralls(ctor_ty, n_params + n_fields); + match KernelTypes::collect_spine(body) { + (head, args) => { + match (*(head)) { + KernelTypes::KExprNode::Const(head_addr, lvls) => { + assert_return_head_is_parent(head_addr, block_addr, ind_idx); + assert_lvls_are_params(lvls, ind_num_lvls, 0); + assert_eq!(Lists::length(args), n_params + n_indices, + "ctor return type: wrong number of spine arguments"); + assert_first_args_are_param_bvars(args, n_params, n_fields, 0); + + let idx_args = Lists::drop(args, n_params); + let block_addrs = (&(Lists::Node::Cons(block_addr, + (&(Lists::Node::Nil))))); + assert_eq!(list_any_mentions_block(idx_args, block_addrs), 0, + "ctor return type: reflexive occurrence in an index argument"); + () } , + } } , + } + } + + fn check_param_agreement_go(rc: KernelRoles::RoleCtx, ta: KernelTypes::KExpr, tb: KernelTypes::KExpr, n: Field, + types: Lists::List) -> () { + match n { + 0 => { () } , + _ => { + match (*(ta)) { + KernelTypes::KExprNode::Forall(da, ba) => { + match (*(tb)) { + KernelTypes::KExprNode::Forall(db, bb) => { + let eq = KernelDefEq::k_is_def_eq(rc, da, db, types); + assert_eq!(eq, 1, + "ctor parameter type disagrees with the inductive's"); + let inner = (&(Lists::Node::Cons(da, types))); + check_param_agreement_go(rc, ba, bb, n - 1, inner) } , + } } , + } } , + } + } + + fn check_param_agreement(rc: KernelRoles::RoleCtx, ta: KernelTypes::KExpr, tb: KernelTypes::KExpr, n: Field) -> () { + check_param_agreement_go(rc, ta, tb, n, (&(Lists::Node::Nil))) + } + + fn get_result_sort_level(rc: KernelRoles::RoleCtx, ind_ty: KernelTypes::KExpr, n: Field, + types: Lists::List) -> KernelTypes::KLevel { + let w = KernelWhnf::whnf(rc, ind_ty, types); + match n { + 0 => { + match (*(w)) { + KernelTypes::KExprNode::Srt(l) => { l } , + } } , + _ => { + match (*(w)) { + KernelTypes::KExprNode::Forall(dom, body) => { + get_result_sort_level(rc, body, n - 1, + (&(Lists::Node::Cons(dom, types)))) } , + } } , + } + } + + fn check_field_universes_inner(rc: KernelRoles::RoleCtx, ty: KernelTypes::KExpr, ind_level: KernelTypes::KLevel, + types: Lists::List) -> () { + match (*(ty)) { + KernelTypes::KExprNode::Forall(dom, body) => { + let dom_level = KernelInfer::k_ensure_sort(rc, dom, types); + assert_eq!(KernelLevels::level_leq(dom_level, ind_level), 1, + "ctor field lives in a universe above the inductive's"); + check_field_universes_inner(rc, body, ind_level, + (&(Lists::Node::Cons(dom, types)))) } , + _ => { () } , + } + } + + fn check_field_universes_skip_params(rc: KernelRoles::RoleCtx, ctor_ty: KernelTypes::KExpr, n_params: Field, + ind_level: KernelTypes::KLevel, + types: Lists::List) -> () { + match n_params { + 0 => { check_field_universes_inner(rc, ctor_ty, ind_level, types) } , + _ => { + match (*(ctor_ty)) { + KernelTypes::KExprNode::Forall(dom, body) => { + check_field_universes_skip_params(rc, body, n_params - 1, + ind_level, (&(Lists::Node::Cons(dom, types)))) } , + } } , + } + } + + fn check_field_universes(rc: KernelRoles::RoleCtx, ctor_ty: KernelTypes::KExpr, n_params: Field, + ind_level: KernelTypes::KLevel) -> () { + match (*(ind_level)) { + KernelTypes::KLevelNode::Zero => { () } , + _ => { check_field_universes_skip_params(rc, ctor_ty, n_params, + ind_level, (&(Lists::Node::Nil))) } , + } + } + + inline fn ctor_parent_ind_ci(block_addr: Bytes::AddressRef, ind_idx: Field) + -> &KernelTypes::KConstantInfo { + Ingress::get_ci_iprj(block_addr, ind_idx) + } + + fn addr_list_contains(xs: Lists::List, target: Bytes::AddressRef) -> Field { + match (*(xs)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(a, rest) => { + match Bytes::address_eq(a, target) { + 1 => { 1 } , + _ => { addr_list_contains(rest, target) } , + } } , + } + } + + fn caddr_is_peer(caddr: Bytes::AddressRef, block_addrs: Lists::List) -> Field { + let ci = (*(Ingress::get_ci(caddr))); + match ci { + KernelTypes::KConstantInfo::Induct(_, _, _, _, _, _, ba, _) => { + addr_list_contains(block_addrs, ba) } , + _ => { 0 } , + } + } + + fn expr_mentions_block(e: KernelTypes::KExpr, block_addrs: Lists::List) -> Field { + match (*(e)) { + KernelTypes::KExprNode::BVar(_) => { 0 } , + KernelTypes::KExprNode::Srt(_) => { 0 } , + KernelTypes::KExprNode::Const(caddr, _) => { caddr_is_peer(caddr, block_addrs) } , + KernelTypes::KExprNode::App(f, a) => { + match expr_mentions_block(f, block_addrs) { + 1 => { 1 } , + _ => { expr_mentions_block(a, block_addrs) } , + } } , + KernelTypes::KExprNode::Lam(t, b) => { + match expr_mentions_block(t, block_addrs) { + 1 => { 1 } , + _ => { expr_mentions_block(b, block_addrs) } , + } } , + KernelTypes::KExprNode::Forall(t, b) => { + match expr_mentions_block(t, block_addrs) { + 1 => { 1 } , + _ => { expr_mentions_block(b, block_addrs) } , + } } , + KernelTypes::KExprNode::Let(t, v, b) => { + match expr_mentions_block(t, block_addrs) { + 1 => { 1 } , + _ => { + match expr_mentions_block(v, block_addrs) { + 1 => { 1 } , + _ => { expr_mentions_block(b, block_addrs) } , + } } , + } } , + KernelTypes::KExprNode::Lit(_) => { 0 } , + KernelTypes::KExprNode::Proj(_, _, e1) => { expr_mentions_block(e1, block_addrs) } , + } + } + + fn list_any_mentions_block(es: Lists::List, + block_addrs: Lists::List) -> Field { + match (*(es)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(e, rest) => { + match expr_mentions_block(e, block_addrs) { + 1 => { 1 } , + _ => { list_any_mentions_block(rest, block_addrs) } , + } } , + } + } + + fn peel_n_foralls_with_types(e: KernelTypes::KExpr, n: Field, + types: Lists::List) -> (KernelTypes::KExpr, Lists::List) { + match n { + 0 => { (e, types) } , + _ => { + match (*(e)) { + KernelTypes::KExprNode::Forall(dom, body) => { + let t2 = (&(Lists::Node::Cons(dom, types))); + peel_n_foralls_with_types(body, n - 1, t2) } , + _ => { (e, types) } , + } } , + } + } + + fn assert_occ_param_bvars(args: Lists::List, n_params: Field, depth: Field, + i: Field) -> () { + match n_params - i { + 0 => { () } , + _ => { + match (*(args)) { + Lists::Node::Cons(arg, rest) => { + match (*(arg)) { + KernelTypes::KExprNode::BVar(j) => { + assert_eq!(j, (depth - 1) - i, + "recursive occurrence: parameter arg is not the parameter binder"); + assert_occ_param_bvars(rest, n_params, depth, i + 1) } , + } } , + } } , + } + } + + fn check_valid_ind_app(caddr: Bytes::AddressRef, us: Lists::List, + args: Lists::List, block_addrs: Lists::List, + depth: Field) -> () { + let ci = (*(Ingress::get_ci(caddr))); + match ci { + KernelTypes::KConstantInfo::Induct(occ_nlvls, _, occ_params, occ_indices, + _, _, _, _) => { + assert_lvls_are_params(us, occ_nlvls, 0); + assert_eq!(Lists::length(args), occ_params + occ_indices, + "recursive occurrence is not fully applied"); + assert_occ_param_bvars(args, occ_params, depth, 0); + assert_eq!(list_any_mentions_block(Lists::drop(args, occ_params), + block_addrs), 0, + "recursive occurrence: index argument mentions the block"); + () } , + } + } + + fn check_positivity_aug(rc: KernelRoles::RoleCtx, dom: KernelTypes::KExpr, block_addrs: Lists::List, + types: Lists::List, check_params: Field) -> () { + match expr_mentions_block(dom, block_addrs) { + 0 => { () } , + _ => { + let dom_w = KernelWhnf::whnf(rc, dom, types); + match (*(dom_w)) { + KernelTypes::KExprNode::Forall(idom, ibody) => { + assert_eq!(expr_mentions_block(idom, block_addrs), 0, + "strict positivity: block occurs left of an arrow"); + let t2 = (&(Lists::Node::Cons(idom, types))); + check_positivity_aug(rc, ibody, block_addrs, t2, check_params) } , + _ => { + match KernelTypes::collect_spine(dom_w) { + (head, args) => { + match (*(head)) { + KernelTypes::KExprNode::Const(caddr, us) => { + match caddr_is_peer(caddr, block_addrs) { + 1 => { + match check_params { + 1 => { + check_valid_ind_app(caddr, us, args, + block_addrs, Lists::length(types)) } , + _ => { () } , + } } , + _ => { + let ci = (*(Ingress::get_ci(caddr))); + match ci { + KernelTypes::KConstantInfo::Induct(_, _, n_ctor_params, + _, ext_num_ctors, _, + ext_block_addr, ext_ind_idx) => { + let after_params = Lists::drop(args, n_ctor_params); + assert_eq!(list_any_mentions_block(after_params, + block_addrs), 0, + "strict positivity: block occurs in a nested inductive's index args"); + + let aug = (&(Lists::Node::Cons(ext_block_addr, + block_addrs))); + let rev_params = Lists::reverse( + Lists::take(args, n_ctor_params)); + check_nested_ctors_positivity(rc, ext_block_addr, + ext_ind_idx, ext_num_ctors, aug, 0, + n_ctor_params, rev_params) } , + } } , + } } , + } } , + } } , + } } , + } + } + + fn check_nested_ctors_positivity(rc: KernelRoles::RoleCtx, block_addr: Bytes::AddressRef, ind_idx: Field, + num_ctors: Field, aug: Lists::List, + cidx: Field, n_params: Field, + rev_params: Lists::List) -> () { + match num_ctors - cidx { + 0 => { () } , + _ => { + let ctor_ci = (*(Ingress::get_ci_cprj(block_addr, ind_idx, cidx))); + match ctor_ci { + KernelTypes::KConstantInfo::Ctor(_, ctor_ty, _, _, _, _, _, _) => { + match peel_n_foralls_with_types(ctor_ty, n_params, + (&(Lists::Node::Nil))) { + (body, _) => { + + check_positivity_fields(rc, KernelSubst::expr_inst_many(body, rev_params, 0), + aug, (&(Lists::Node::Nil)), 0); + check_nested_ctors_positivity(rc, block_addr, ind_idx, + num_ctors, aug, cidx + 1, n_params, rev_params) } , + } } , + } } , + } + } + + fn check_positivity_fields(rc: KernelRoles::RoleCtx, ty: KernelTypes::KExpr, block_addrs: Lists::List, + types: Lists::List, check_params: Field) -> () { + match (*(ty)) { + KernelTypes::KExprNode::Forall(dom, body) => { + check_positivity_aug(rc, dom, block_addrs, types, check_params); + let t2 = (&(Lists::Node::Cons(dom, types))); + check_positivity_fields(rc, body, block_addrs, t2, check_params) } , + _ => { () } , + } + } + + fn check_positivity(rc: KernelRoles::RoleCtx, ctor_ty: KernelTypes::KExpr, n_params: Field, + block_addr: Bytes::AddressRef, types: Lists::List) -> () { + let block_addrs = (&(Lists::Node::Cons(block_addr, (&(Lists::Node::Nil))))); + match peel_n_foralls_with_types(ctor_ty, n_params, types) { + (body, types_after) => { + check_positivity_fields(rc, body, block_addrs, types_after, 1) } , + } + } + + fn check_inductive_shape(rc: KernelRoles::RoleCtx, ty: KernelTypes::KExpr, n_params: Field, n_indices: Field, + num_ctors: Field, num_lvls: Field, + block_addr: Bytes::AddressRef, ind_idx: Field, + is_unsafe: Field) -> () { + let ind_level = get_result_sort_level(rc, ty, n_params + n_indices, + (&(Lists::Node::Nil))); + check_inductive_shape_ctors(rc, ty, n_params, n_indices, num_ctors, + num_lvls, block_addr, ind_idx, + ind_level, is_unsafe, 0) + } + + fn check_inductive_shape_ctors(rc: KernelRoles::RoleCtx, ind_ty: KernelTypes::KExpr, n_params: Field, + n_indices: Field, num_ctors: Field, + num_lvls: Field, block_addr: Bytes::AddressRef, + ind_idx: Field, ind_level: KernelTypes::KLevel, + is_unsafe: Field, cidx: Field) -> () { + match num_ctors - cidx { + 0 => { () } , + _ => { + let ctor_ci = (*(Ingress::get_ci_cprj(block_addr, ind_idx, cidx))); + match ctor_ci { + KernelTypes::KConstantInfo::Ctor(_, cty, c_block, c_ind_idx, c_cidx, + c_np, c_nf, _) => { + + assert_eq!(Bytes::address_eq(c_block, block_addr), 1, + "ctor belongs to a different block than its inductive"); + assert_eq!(c_ind_idx, ind_idx, + "ctor points at a different member of the block"); + assert_eq!(c_cidx, cidx, + "ctor's stored index differs from its position"); + assert_eq!(c_np, n_params, + "ctor parameter count differs from the inductive's"); + check_param_agreement(rc, ind_ty, cty, n_params); + check_ctor_return_type(cty, c_np, n_indices, c_nf, num_lvls, + block_addr, ind_idx); + check_field_universes(rc, cty, c_np, ind_level); + + match is_unsafe { + 0 => { check_positivity(rc, cty, c_np, block_addr, + (&(Lists::Node::Nil))) } , + _ => { () } , + }; + check_inductive_shape_ctors(rc, ind_ty, n_params, n_indices, + num_ctors, num_lvls, + block_addr, ind_idx, + ind_level, is_unsafe, + cidx + 1) } , + } } , + } + } + + fn check_parent_inductive_shape(rc: KernelRoles::RoleCtx, ind_ci: KernelTypes::KConstantInfo) -> () { + match ind_ci { + KernelTypes::KConstantInfo::Induct(nlvls, ty, n_params, n_indices, num_ctors, + is_unsafe, block_addr, ind_idx) => { + check_inductive_shape(rc, ty, n_params, n_indices, num_ctors, + nlvls, block_addr, ind_idx, is_unsafe) } , + _ => { () } , + } + } + + fn check_block_peer_param_agreement(rc: KernelRoles::RoleCtx, ind_ci: KernelTypes::KConstantInfo, addr: Bytes::AddressRef) -> () { + match ind_ci { + KernelTypes::KConstantInfo::Induct(_, self_ty, self_np, self_ni, _, _, + block_addr, self_ind_idx) => { + match Bytes::address_eq(block_addr, addr) { + 1 => { () } , + _ => { + let block_c = Ingress::load_verified_constant(block_addr); + match block_c { + Ixon::Constant::Mk(info, _, _, _) => { + match info { + Ixon::ConstantInfo::Muts(members) => { + peer_agree_walk(rc, members, self_ty, self_np, self_ni, + self_ind_idx, 0, block_addr) } , + _ => { () } , + } } , + } } , + } } , + _ => { () } , + } + } + + fn peer_agree_walk(rc: KernelRoles::RoleCtx, members: Lists::List, self_ty: KernelTypes::KExpr, + self_np: Field, self_ni: Field, + self_ind_idx: Field, pos: Field, block_addr: Bytes::AddressRef) -> () { + match (*(members)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(m, rest) => { + match m { + Ixon::MutConst::Indc(_) => { + let is_self = Fields::is_zero(pos - self_ind_idx); + match is_self { + 1 => { + peer_agree_walk(rc, rest, self_ty, self_np, self_ni, + self_ind_idx, pos + 1, block_addr) } , + _ => { + let peer_ci = (*(Ingress::get_ci_iprj(block_addr, pos))); + match peer_ci { + KernelTypes::KConstantInfo::Induct(_, peer_ty, peer_np, peer_ni, + _, _, _, _) => { + assert_eq!(peer_np, self_np, + "mutual block peers disagree on parameter count"); + check_param_agreement(rc, self_ty, peer_ty, self_np); + let self_lvl = get_result_sort_level(rc, self_ty, + self_np + self_ni, (&(Lists::Node::Nil))); + let peer_lvl = get_result_sort_level(rc, peer_ty, + peer_np + peer_ni, (&(Lists::Node::Nil))); + assert_eq!(KernelLevels::level_equal(self_lvl, peer_lvl), 1, + "mutual block peers land in different universes"); + peer_agree_walk(rc, rest, self_ty, self_np, self_ni, + self_ind_idx, pos + 1, block_addr) } , + _ => { + peer_agree_walk(rc, rest, self_ty, self_np, self_ni, + self_ind_idx, pos + 1, block_addr) } , + } } , + } } , + _ => { + peer_agree_walk(rc, rest, self_ty, self_np, self_ni, + self_ind_idx, pos + 1, block_addr) } , + } } , + } + } + + fn is_large_eliminator(rc: KernelRoles::RoleCtx, result_level: KernelTypes::KLevel, num_ctors: Field, + single_ctor_opt: (Field, KernelTypes::KConstantInfo), + is_solo: Field) -> Field { + match KernelLevels::level_is_not_zero(result_level) { + 1 => { 1 } , + _ => { + + match is_solo { + 0 => { 0 } , + _ => { + match num_ctors { + 0 => { 1 } , + 1 => { + match single_ctor_opt { + (present, ctor_ci) => { + match present { + 0 => { 0 } , + _ => { + match ctor_ci { + KernelTypes::KConstantInfo::Ctor(_, ctor_ty, _, _, _, n_params, + n_fields, _) => { + match n_fields { + 0 => { 1 } , + _ => { check_large_prop_ctor(rc, ctor_ty, n_params, + n_fields, + (&(Lists::Node::Nil))) } , + } } , + _ => { 0 } , + } } , + } } , + } } , + _ => { 0 } , + } } , + } } , + } + } + + fn check_large_prop_ctor(rc: KernelRoles::RoleCtx, ty: KernelTypes::KExpr, n_params: Field, n_fields: Field, + types: Lists::List) -> Field { + match n_params { + 0 => { + check_large_walk_fields(rc, ty, n_fields, 0, types, + (&(Lists::Node::Nil))) } , + _ => { + match (*(ty)) { + KernelTypes::KExprNode::Forall(dom, body) => { + let inner = (&(Lists::Node::Cons(dom, types))); + check_large_prop_ctor(rc, body, n_params - 1, n_fields, inner) } , + _ => { 0 } , + } } , + } + } + + fn check_large_walk_fields(rc: KernelRoles::RoleCtx, ty: KernelTypes::KExpr, n_fields: Field, field_idx: Field, + types: Lists::List, + data_bvars: Lists::List) -> Field { + match n_fields - field_idx { + 0 => { + match KernelTypes::collect_spine(ty) { + (_, args) => { all_bvars_in_args(data_bvars, args) } , + } } , + _ => { + match (*(ty)) { + KernelTypes::KExprNode::Forall(dom, body) => { + let lvl = KernelInfer::k_ensure_sort(rc, dom, types); + let is_data = 1 - KernelLevels::level_equal(lvl, (&(KernelTypes::KLevelNode::Zero))); + + let bvar_idx = (n_fields - 1) - field_idx; + let new_bvars = match is_data { + 0 => { data_bvars } , + _ => { (&(Lists::Node::Cons(bvar_idx, data_bvars))) } , + }; + let inner = (&(Lists::Node::Cons(dom, types))); + check_large_walk_fields(rc, body, n_fields, field_idx + 1, + inner, new_bvars) } , + _ => { 0 } , + } } , + } + } + + fn all_bvars_in_args(bvars: Lists::List, args: Lists::List) -> Field { + match (*(bvars)) { + Lists::Node::Nil => { 1 } , + Lists::Node::Cons(b, rest) => { + match args_contain_bvar(args, b) { + 0 => { 0 } , + _ => { all_bvars_in_args(rest, args) } , + } } , + } + } + + fn args_contain_bvar(args: Lists::List, target: Field) -> Field { + match (*(args)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(a, rest) => { + match (*(a)) { + KernelTypes::KExprNode::BVar(i) => { + match i - target { + 0 => { 1 } , + _ => { args_contain_bvar(rest, target) } , + } } , + _ => { args_contain_bvar(rest, target) } , + } } , + } + } + + fn compute_k_target(rc: KernelRoles::RoleCtx, ind_ci: KernelTypes::KConstantInfo, ind_addr: Bytes::AddressRef) -> Field { + match ind_ci { + KernelTypes::KConstantInfo::Induct(_, ind_ty, n_params, n_indices, num_ctors, + _, block_addr, ind_idx) => { + let is_solo = ind_is_solo(block_addr, ind_addr); + match is_solo { + 0 => { 0 } , + _ => { + let result_level = get_result_sort_level(rc, ind_ty, + n_params + n_indices, (&(Lists::Node::Nil))); + match KernelLevels::level_equal(result_level, (&(KernelTypes::KLevelNode::Zero))) { + 0 => { 0 } , + _ => { + match num_ctors { + 1 => { + let ctor_ci = (*(Ingress::get_ci_cprj(block_addr, + ind_idx, 0))); + match ctor_ci { + KernelTypes::KConstantInfo::Ctor(_, _, _, _, _, _, n_fields, _) => { + Fields::is_zero(n_fields) } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + } } , + } } , + _ => { 0 } , + } + } + + fn ind_is_solo(block_addr: Bytes::AddressRef, ind_addr: Bytes::AddressRef) -> Field { + match Bytes::address_eq(block_addr, ind_addr) { + 1 => { 1 } , + _ => { + let block_c = Ingress::load_verified_constant(block_addr); + match block_c { + Ixon::Constant::Mk(info, _, _, _) => { + match info { + Ixon::ConstantInfo::Muts(members) => { muts_indc_count_is_one(members, 0) } , + _ => { 0 } , + } } , + } } , + } + } + + fn is_muts_block(addr: Bytes::AddressRef) -> Field { + let block_c = Ingress::load_verified_constant(addr); + match block_c { + Ixon::Constant::Mk(info, _, _, _) => { + match info { + Ixon::ConstantInfo::Muts(_) => { 1 } , + _ => { 0 } , + } } , + } + } + + fn muts_indc_count_is_one(members: Lists::List, count: Field) -> Field { + match (*(members)) { + Lists::Node::Nil => { + match count { + 1 => { 1 } , + _ => { 0 } , + } } , + Lists::Node::Cons(m, rest) => { + match m { + Ixon::MutConst::Indc(_) => { muts_indc_count_is_one(rest, count + 1) } , + _ => { muts_indc_count_is_one(rest, count) } , + } } , + } + } + + fn rec_to_parent_addr(ty: KernelTypes::KExpr, n_p: Field, n_mot: Field, n_min: Field, + n_i: Field) -> Bytes::AddressRef { + let skip = n_p + n_mot + n_min + n_i; + let after_skip = peel_n_foralls(ty, skip); + match (*(after_skip)) { + KernelTypes::KExprNode::Forall(major_ty, _) => { + match KernelTypes::collect_spine(major_ty) { + (head, _) => { + match (*(head)) { + KernelTypes::KExprNode::Const(caddr, _) => { caddr } , + } } , + } } , + } + } + + fn extract_aux_occ_us(rec_ci: KernelTypes::KConstantInfo) -> Lists::List { + match rec_ci { + KernelTypes::KConstantInfo::Rec(_, ty, np, ni, nmot, nmin, _, _, _, _, _) => { + let skip = ((np + nmot) + nmin) + ni; + match (*(peel_n_foralls(ty, skip))) { + KernelTypes::KExprNode::Forall(major_ty, _) => { + match KernelTypes::collect_spine(major_ty) { + (head, _) => { + match (*(head)) { + KernelTypes::KExprNode::Const(_, us) => { us } , + _ => { (&(Lists::Node::Nil)) } , + } } , + } } , + _ => { (&(Lists::Node::Nil)) } , + } } , + _ => { (&(Lists::Node::Nil)) } , + } + } + + fn extract_aux_spec_params(ty: KernelTypes::KExpr, n_p: Field, n_mot: Field, n_min: Field, + n_i: Field, ext_np: Field) -> Lists::List { + let skip = n_p + n_mot + n_min + n_i; + let after_skip = peel_n_foralls(ty, skip); + match (*(after_skip)) { + KernelTypes::KExprNode::Forall(major_ty, _) => { + match KernelTypes::collect_spine(major_ty) { + (_head, args) => { + + spec_params_lower(Lists::take(args, ext_np), + (n_mot + n_min) + n_i) } , + } } , + } + } + + fn spec_params_lower(sps: Lists::List, d: Field) -> Lists::List { + match (*(sps)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(sp, rest) => { + assert_eq!(KernelSubst::has_bvar_in_range(sp, 0, d), 0, + "nested occurrence's parameter references a motive, minor, or index binder"); + (&(Lists::Node::Cons(KernelSubst::expr_lower(sp, d, 0), + spec_params_lower(rest, d)))) } , + } + } + + fn build_param_lvls_range(start: Field, count: Field, i: Field) -> Lists::List { + match count - i { + 0 => { (&(Lists::Node::Nil)) } , + _ => { + (&(Lists::Node::Cons( + (&(KernelTypes::KLevelNode::Param(start + i))), + build_param_lvls_range(start, count, i + 1)))) } , + } + } + + inline fn build_flat_originals(block_addr: Bytes::AddressRef, univ_offset: Field) + -> Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)> { + let block_c = Ingress::load_verified_constant(block_addr); + match block_c { + Ixon::Constant::Mk(info, _, _, _) => { + match info { + Ixon::ConstantInfo::Muts(members) => { + flat_originals_walk(members, members, block_addr, + univ_offset, 0) } , + _ => { + + let ci = (*(Ingress::get_ci(block_addr))); + match ci { + KernelTypes::KConstantInfo::Induct(nlvls, _, _, _, _, _, _, _) => { + let occ = build_param_lvls_range(univ_offset, nlvls, 0); + (&(Lists::Node::Cons( + (block_addr, 0, (&(Lists::Node::Nil)), occ), + (&(Lists::Node::Nil))))) } , + _ => { (&(Lists::Node::Nil)) } , + } } , + } } , + } + } + + fn flat_originals_walk(all_members: Lists::List, + cur: Lists::List, block_addr: Bytes::AddressRef, + univ_offset: Field, pos: Field) + -> Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)> { + match (*(cur)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(m, rest) => { + match m { + Ixon::MutConst::Indc(_) => { + let member_addr = Ingress::projection_addr(all_members, block_addr, pos); + let member_ci = (*(Ingress::get_ci_iprj(block_addr, pos))); + let nlvls = match member_ci { + KernelTypes::KConstantInfo::Induct(nl, _, _, _, _, _, _, _) => { nl } , + _ => { 0 } , + }; + let occ = build_param_lvls_range(univ_offset, nlvls, 0); + (&(Lists::Node::Cons( + (member_addr, 0, (&(Lists::Node::Nil)), occ), + flat_originals_walk(all_members, rest, block_addr, + univ_offset, pos + 1)))) } , + _ => { + flat_originals_walk(all_members, rest, block_addr, + univ_offset, pos + 1) } , + } } , + } + } + + fn aux_already_in(flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + target_addr: Bytes::AddressRef, + target_sp: Lists::List) -> Field { + match (*(flat)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(m, rest) => { + match m { + (addr, is_aux, sp, _ou) => { + match is_aux { + 1 => { + match Bytes::address_eq(addr, target_addr) { + 1 => { + match spec_params_ptr_eq(sp, target_sp) { + 1 => { 1 } , + _ => { aux_already_in(rest, target_addr, target_sp) } , + } } , + _ => { aux_already_in(rest, target_addr, target_sp) } , + } } , + _ => { aux_already_in(rest, target_addr, target_sp) } , + } } , + } } , + } + } + + fn kexpr_struct_eq(a: KernelTypes::KExpr, b: KernelTypes::KExpr) -> Field { + match (*(a)) { + KernelTypes::KExprNode::BVar(ia) => { + match (*(b)) { + KernelTypes::KExprNode::BVar(ib) => { + match ia - ib { 0 => { 1 } , _ => { 0 } , } } , + _ => { 0 } , + } } , + KernelTypes::KExprNode::Srt(la) => { + match (*(b)) { + KernelTypes::KExprNode::Srt(lb) => { KernelLevels::level_struct_eq(la, lb) } , + _ => { 0 } , + } } , + KernelTypes::KExprNode::Const(ca, lsa) => { + match (*(b)) { + KernelTypes::KExprNode::Const(cb, lsb) => { + match Bytes::address_eq(ca, cb) { + 1 => { level_list_struct_eq(lsa, lsb) } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + KernelTypes::KExprNode::App(fa, aa) => { + match (*(b)) { + KernelTypes::KExprNode::App(fb, ab) => { + match kexpr_struct_eq(fa, fb) { + 1 => { kexpr_struct_eq(aa, ab) } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + KernelTypes::KExprNode::Lam(ta, ba) => { + match (*(b)) { + KernelTypes::KExprNode::Lam(tb, bb) => { + match kexpr_struct_eq(ta, tb) { + 1 => { kexpr_struct_eq(ba, bb) } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + KernelTypes::KExprNode::Forall(da, xa) => { + match (*(b)) { + KernelTypes::KExprNode::Forall(db, xb) => { + match kexpr_struct_eq(da, db) { + 1 => { kexpr_struct_eq(xa, xb) } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + KernelTypes::KExprNode::Let(ta, va, ba) => { + match (*(b)) { + KernelTypes::KExprNode::Let(tb, vb, bb) => { + match kexpr_struct_eq(ta, tb) { + 1 => { + match kexpr_struct_eq(va, vb) { + 1 => { kexpr_struct_eq(ba, bb) } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + KernelTypes::KExprNode::Lit(la) => { + match (*(b)) { + KernelTypes::KExprNode::Lit(lb) => { KernelLevels::literal_eq(la, lb) } , + _ => { 0 } , + } } , + KernelTypes::KExprNode::Proj(sa, fa2, ea) => { + match (*(b)) { + KernelTypes::KExprNode::Proj(sb, fb2, eb) => { + match Bytes::address_eq(sa, sb) { + 1 => { + match fa2 - fb2 { + 0 => { kexpr_struct_eq(ea, eb) } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + } + } + + fn level_list_struct_eq(a: Lists::List, b: Lists::List) -> Field { + match (*(a)) { + Lists::Node::Nil => { + match (*(b)) { + Lists::Node::Nil => { 1 } , + _ => { 0 } , + } } , + Lists::Node::Cons(x, xr) => { + match (*(b)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(y, yr) => { + match KernelLevels::level_struct_eq(x, y) { + 1 => { level_list_struct_eq(xr, yr) } , + _ => { 0 } , + } } , + } } , + } + } + + fn spec_params_ptr_eq(a: Lists::List, b: Lists::List) -> Field { + match (*(a)) { + Lists::Node::Nil => { + match (*(b)) { + Lists::Node::Nil => { 1 } , + _ => { 0 } , + } } , + Lists::Node::Cons(x, xr) => { + match (*(b)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(y, yr) => { + match kexpr_struct_eq(x, y) { + 1 => { spec_params_ptr_eq(xr, yr) } , + _ => { 0 } , + } } , + } } , + } + } + + fn extract_aux_spec_params_from_rec(rec_ci: KernelTypes::KConstantInfo, + ext_np: Field) -> Lists::List { + match rec_ci { + KernelTypes::KConstantInfo::Rec(_, ty, np, ni, nmot, nmin, _, _, _, _, _) => { + extract_aux_spec_params(ty, np, nmot, nmin, ni, ext_np) } , + _ => { (&(Lists::Node::Nil)) } , + } + } + + inline fn primary_parent_block_of(rec_block_addr: Bytes::AddressRef, fallback: Bytes::AddressRef) -> Bytes::AddressRef { + let block_c = Ingress::load_verified_constant(rec_block_addr); + match block_c { + Ixon::Constant::Mk(info, _, _, _) => { + match info { + Ixon::ConstantInfo::Muts(members) => { + first_recr_parent_block(members, members, rec_block_addr, 0, + fallback) } , + _ => { fallback } , + } } , + } + } + + fn first_recr_parent_block(all_members: Lists::List, + cur: Lists::List, block_addr: Bytes::AddressRef, + pos: Field, fallback: Bytes::AddressRef) -> Bytes::AddressRef { + match (*(cur)) { + Lists::Node::Nil => { fallback } , + Lists::Node::Cons(m, rest) => { + match m { + Ixon::MutConst::Recr(_) => { + let wrapper = Ingress::projection_addr(all_members, block_addr, pos); + let rec_ci = (*(Ingress::get_ci(wrapper))); + match rec_ci { + KernelTypes::KConstantInfo::Rec(_, ty, np, ni, nmot, nmin, _, _, _, _, _) => { + let parent = rec_to_parent_addr(ty, np, nmot, nmin, ni); + let parent_ci = (*(Ingress::get_ci(parent))); + match parent_ci { + KernelTypes::KConstantInfo::Induct(_, _, _, _, _, _, pb, _) => { pb } , + _ => { fallback } , + } } , + _ => { fallback } , + } } , + _ => { first_recr_parent_block(all_members, rest, block_addr, + pos + 1, fallback) } , + } } , + } + } + + fn build_flat_block(rec_block_addr: Bytes::AddressRef, parent_block_addr: Bytes::AddressRef, + univ_offset: Field) + -> Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)> { + + let primary_block = primary_parent_block_of(rec_block_addr, + parent_block_addr); + let originals = build_flat_originals(primary_block, univ_offset); + match is_muts_block(rec_block_addr) { + 0 => { originals } , + _ => { + detect_aux_from_recrs_ex(rec_block_addr, primary_block, + univ_offset, originals) } , + } + } + + fn detect_aux_from_recrs_ex(rec_block_addr: Bytes::AddressRef, + parent_block_addr: Bytes::AddressRef, + univ_offset: Field, + originals: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>) + -> Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)> { + let block_c = Ingress::load_verified_constant(rec_block_addr); + match block_c { + Ixon::Constant::Mk(info, _, _, _) => { + match info { + Ixon::ConstantInfo::Muts(members) => { + aux_from_recrs_walk_ex(members, members, rec_block_addr, + parent_block_addr, univ_offset, + originals, 0) } , + _ => { originals } , + } } , + } + } + + fn aux_from_recrs_walk_ex(all_members: Lists::List, + cur: Lists::List, + rec_block_addr: Bytes::AddressRef, + primary_parent_block: Bytes::AddressRef, + univ_offset: Field, + acc: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + pos: Field) + -> Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)> { + match (*(cur)) { + Lists::Node::Nil => { acc } , + Lists::Node::Cons(m, rest) => { + match m { + Ixon::MutConst::Recr(_) => { + let rec_wrapper = Ingress::projection_addr(all_members, rec_block_addr, pos); + let rec_ci = (*(Ingress::get_ci(rec_wrapper))); + let entry_opt = match rec_ci { + KernelTypes::KConstantInfo::Rec(_, ty, np, ni, nmot, nmin, _, _, _, _, _) => { + let parent_addr = rec_to_parent_addr(ty, np, nmot, nmin, ni); + let parent_ci = (*(Ingress::get_ci(parent_addr))); + match parent_ci { + KernelTypes::KConstantInfo::Induct(pnlvls, _, pnp, _, _, _, pblock, _) => { + match Bytes::address_eq(pblock, primary_parent_block) { + 1 => { (0, parent_addr, 0, pnp, pnlvls) } , + _ => { (1, parent_addr, 1, pnp, pnlvls) } , + } } , + _ => { (0, parent_addr, 0, 0, 0) } , + } } , + _ => { (0, primary_parent_block, 0, 0, 0) } , + }; + match entry_opt { + (0, _, _, _, _) => { + aux_from_recrs_walk_ex(all_members, rest, rec_block_addr, + primary_parent_block, univ_offset, acc, pos + 1) } , + (_, parent_addr, _, pnp, pnlvls) => { + let spec_params = extract_aux_spec_params_from_rec( + rec_ci, pnp); + let occ = extract_aux_occ_us(rec_ci); + match aux_already_in(acc, parent_addr, spec_params) { + 1 => { + aux_from_recrs_walk_ex(all_members, rest, rec_block_addr, + primary_parent_block, univ_offset, acc, pos + 1) } , + _ => { + let new_acc = Lists::snoc(acc, + (parent_addr, 1, spec_params, occ)); + aux_from_recrs_walk_ex(all_members, rest, rec_block_addr, + primary_parent_block, univ_offset, new_acc, pos + 1) } , + } } , + } } , + _ => { + aux_from_recrs_walk_ex(all_members, rest, rec_block_addr, + primary_parent_block, univ_offset, acc, pos + 1) } , + } } , + } + } + + fn flat_find_pos(flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + target_addr: Bytes::AddressRef, pos: Field) -> (Field, Field) { + match (*(flat)) { + Lists::Node::Nil => { (0, 0) } , + Lists::Node::Cons(m, rest) => { + match m { + (member_addr, _is_aux, _sp, _ou) => { + match Bytes::address_eq(member_addr, target_addr) { + 1 => { (1, pos) } , + _ => { flat_find_pos(rest, target_addr, pos + 1) } , + } } , + } } , + } + } + + fn flat_find_pos_kind(flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + target_addr: Bytes::AddressRef, + want_aux: Field, + want_sp: Lists::List, + pos: Field) -> (Field, Field) { + match (*(flat)) { + Lists::Node::Nil => { (0, 0) } , + Lists::Node::Cons(m, rest) => { + match m { + (member_addr, is_aux, sp, _ou) => { + let addr_match = Bytes::address_eq(member_addr, target_addr); + let kind_eq = match want_aux - is_aux { + 0 => { 1 } , + _ => { 0 } , + }; + let sp_eq = match want_aux { + 1 => { spec_params_ptr_eq(sp, want_sp) } , + _ => { 1 } , + }; + match (addr_match * kind_eq) * sp_eq { + 1 => { (1, pos) } , + _ => { flat_find_pos_kind(rest, target_addr, want_aux, + want_sp, pos + 1) } , + } } , + } } , + } + } + + fn flat_member_at(flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + pos: Field) -> (Bytes::AddressRef, Field, Lists::List, Lists::List) { + match (*(flat)) { + Lists::Node::Nil => { ((&([UInt8::BYTE_0; 32])), 0, (&(Lists::Node::Nil)), + (&(Lists::Node::Nil))) } , + Lists::Node::Cons(m, rest) => { + match pos { + 0 => { m } , + _ => { flat_member_at(rest, pos - 1) } , + } } , + } + } + + fn subst_param_for(j: Field, n_rec_params: Field, is_aux: Field, + spec_params: Lists::List) -> KernelTypes::KExpr { + match is_aux { + 0 => { (&(KernelTypes::KExprNode::BVar((n_rec_params - 1) - j))) } , + _ => { + let len = Lists::length(spec_params); + match UInt32::less_than_fields(j, len) { + 1 => { Lists::lookup(spec_params, j) } , + _ => { (&(KernelTypes::KExprNode::BVar((n_rec_params - 1) - j))) } , + } } , + } + } + + fn peel_motive_params_subst(ty: KernelTypes::KExpr, n: Field, n_rec_params: Field, + is_aux: Field, spec_params: Lists::List, + j: Field) -> KernelTypes::KExpr { + match n { + 0 => { ty } , + _ => { + match (*(ty)) { + KernelTypes::KExprNode::Forall(_, body) => { + let p = subst_param_for(j, n_rec_params, is_aux, spec_params); + let body_substed = KernelSubst::expr_inst1(body, p, 0); + peel_motive_params_subst(body_substed, n - 1, n_rec_params, + is_aux, spec_params, j + 1) } , + } } , + } + } + + fn collect_index_doms(rc: KernelRoles::RoleCtx, ty: KernelTypes::KExpr, n: Field) -> Lists::List { + match n { + 0 => { (&(Lists::Node::Nil)) } , + _ => { + match (*(ty)) { + KernelTypes::KExprNode::Forall(dom, body) => { + (&(Lists::Node::Cons(dom, collect_index_doms(rc, body, n - 1)))) } , + _ => { + match (*(KernelWhnf::whnf(rc, ty, (&(Lists::Node::Nil))))) { + KernelTypes::KExprNode::Forall(dom, body) => { + (&(Lists::Node::Cons(dom, collect_index_doms(rc, body, n - 1)))) } , + _ => { (&(Lists::Node::Nil)) } , + } } , + } } , + } + } + + fn build_major_params(head: KernelTypes::KExpr, n_rec_params: Field, depth: Field, + i: Field) -> KernelTypes::KExpr { + match n_rec_params - i { + 0 => { head } , + _ => { + let v = (&(KernelTypes::KExprNode::BVar(((n_rec_params - 1) - i) + depth))); + build_major_params((&(KernelTypes::KExprNode::App(head, v))), + n_rec_params, depth, i + 1) } , + } + } + + fn apply_spec_params_lifted(head: KernelTypes::KExpr, spec_params: Lists::List, + depth: Field) -> KernelTypes::KExpr { + match (*(spec_params)) { + Lists::Node::Nil => { head } , + Lists::Node::Cons(sp, rest) => { + let lifted = KernelSubst::expr_lift(sp, depth, 0); + apply_spec_params_lifted((&(KernelTypes::KExprNode::App(head, lifted))), + rest, depth) } , + } + } + + inline fn build_major_args_for_member(head: KernelTypes::KExpr, n_rec_params: Field, + depth: Field, is_aux: Field, + spec_params: Lists::List) -> KernelTypes::KExpr { + match is_aux { + 0 => { build_major_params(head, n_rec_params, depth, 0) } , + _ => { apply_spec_params_lifted(head, spec_params, depth) } , + } + } + + fn build_major_indices(head: KernelTypes::KExpr, n_indices: Field, i: Field) -> KernelTypes::KExpr { + match n_indices - i { + 0 => { head } , + _ => { + let v = (&(KernelTypes::KExprNode::BVar((n_indices - 1) - i))); + build_major_indices((&(KernelTypes::KExprNode::App(head, v))), + n_indices, i + 1) } , + } + } + + fn wrap_foralls(body: KernelTypes::KExpr, doms: Lists::List) -> KernelTypes::KExpr { + match (*(doms)) { + Lists::Node::Nil => { body } , + Lists::Node::Cons(dom, rest) => { + (&(KernelTypes::KExprNode::Forall(dom, wrap_foralls(body, rest)))) } , + } + } + + fn collect_n_doms_whnf(rc: KernelRoles::RoleCtx, ty: KernelTypes::KExpr, n: Field) -> (Lists::List, KernelTypes::KExpr) { + match n { + 0 => { ((&(Lists::Node::Nil)), ty) } , + _ => { + + match (*(ty)) { + KernelTypes::KExprNode::Forall(dom, body) => { + match collect_n_doms_whnf(rc, body, n - 1) { + (rest, after) => { ((&(Lists::Node::Cons(dom, rest))), after) } , + } } , + _ => { + match (*(KernelWhnf::whnf(rc, ty, (&(Lists::Node::Nil))))) { + KernelTypes::KExprNode::Forall(dom, body) => { + match collect_n_doms_whnf(rc, body, n - 1) { + (rest, after) => { ((&(Lists::Node::Cons(dom, rest))), after) } , + } } , + + _ => { ((&(Lists::Node::Nil)), ty) } , + } } , + } } , + } + } + + fn list_lift_indices(doms: Lists::List, shift: Field, i: Field) -> Lists::List { + match (*(doms)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(d, rest) => { + (&(Lists::Node::Cons(KernelSubst::expr_lift(d, shift, i), + list_lift_indices(rest, shift, i + 1)))) } , + } + } + + inline fn build_major_args_for_self(head: KernelTypes::KExpr, n_rec_params: Field, + top_bvar: Field, spec_lift: Field, + is_aux: Field, + spec_params: Lists::List) -> KernelTypes::KExpr { + match is_aux { + 1 => { apply_spec_params_lifted(head, spec_params, spec_lift) } , + _ => { build_apply_bvars_decreasing(head, n_rec_params, top_bvar, 0) } , + } + } + + fn apply_indices_in_conclusion(head: KernelTypes::KExpr, n_indices: Field, i: Field) -> KernelTypes::KExpr { + match n_indices - i { + 0 => { head } , + _ => { + let v = (&(KernelTypes::KExprNode::BVar(n_indices - i))); + apply_indices_in_conclusion((&(KernelTypes::KExprNode::App(head, v))), + n_indices, i + 1) } , + } + } + + fn build_motive_type_flat(rc: KernelRoles::RoleCtx, member_addr: Bytes::AddressRef, ind_ty: KernelTypes::KExpr, + n_own_params: Field, n_indices: Field, + occurrence_us: Lists::List, + elim_level: KernelTypes::KLevel, + n_rec_params: Field, + is_aux: Field, + spec_params: Lists::List) -> KernelTypes::KExpr { + let ind_ty_inst = KernelLevels::expr_inst_levels(ind_ty, occurrence_us); + let after_params = peel_motive_params_subst(ind_ty_inst, n_own_params, + n_rec_params, is_aux, spec_params, 0); + let index_doms = collect_index_doms(rc, after_params, n_indices); + let head = (&(KernelTypes::KExprNode::Const(member_addr, occurrence_us))); + let with_args = build_major_args_for_member(head, n_rec_params, + n_indices, is_aux, spec_params); + let major_ty = build_major_indices(with_args, n_indices, 0); + let sort_e = (&(KernelTypes::KExprNode::Srt(elim_level))); + let with_major = (&(KernelTypes::KExprNode::Forall(major_ty, sort_e))); + wrap_foralls(with_major, index_doms) + } + + fn build_all_motives(rc: KernelRoles::RoleCtx, flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + elim_level: KernelTypes::KLevel, n_rec_params: Field) + -> Lists::List { + build_all_motives_walk(rc, flat, elim_level, n_rec_params, 0) + } + + fn build_motive_apps(head: KernelTypes::KExpr, n_motives: Field, start: Field, + i: Field) -> KernelTypes::KExpr { + match n_motives - i { + 0 => { head } , + _ => { + let v = (&(KernelTypes::KExprNode::BVar(start - i))); + build_motive_apps((&(KernelTypes::KExprNode::App(head, v))), n_motives, + start, i + 1) } , + } + } + + fn build_minor_apps(head: KernelTypes::KExpr, n_minors: Field, start: Field, + i: Field) -> KernelTypes::KExpr { + match n_minors - i { + 0 => { head } , + _ => { + let v = (&(KernelTypes::KExprNode::BVar(start - i))); + build_minor_apps((&(KernelTypes::KExprNode::App(head, v))), n_minors, + start, i + 1) } , + } + } + + fn wrap_lams(body: KernelTypes::KExpr, doms: Lists::List) -> KernelTypes::KExpr { + match (*(doms)) { + Lists::Node::Nil => { body } , + Lists::Node::Cons(dom, rest) => { + (&(KernelTypes::KExprNode::Lam(dom, wrap_lams(body, rest)))) } , + } + } + + fn build_rec_type(rc: KernelRoles::RoleCtx, ind_ty: KernelTypes::KExpr, ind_nlvls: Field, n_params: Field, n_indices: Field, + elim_level: KernelTypes::KLevel, univ_offset: Field, + flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + flat_own_params: Lists::List, self_pos: Field) -> KernelTypes::KExpr { + + match flat_member_at(flat, 0) { + (prim_addr, _pia, _pisp, _piou) => { + match (*(Ingress::get_ci(prim_addr))) { + KernelTypes::KConstantInfo::Induct(prim_nlvls, prim_ty, _, _, _, _, _, _) => { + build_rec_type_from(rc, prim_ty, prim_nlvls, ind_ty, ind_nlvls, + n_params, n_indices, elim_level, univ_offset, flat, + flat_own_params, self_pos) } , + _ => { + build_rec_type_from(rc, ind_ty, ind_nlvls, ind_ty, ind_nlvls, + n_params, n_indices, elim_level, univ_offset, flat, + flat_own_params, self_pos) } , + } } , + } + } + + fn build_rec_type_from(rc: KernelRoles::RoleCtx, prim_ty: KernelTypes::KExpr, prim_nlvls: Field, + ind_ty: KernelTypes::KExpr, ind_nlvls: Field, + n_params: Field, n_indices: Field, + elim_level: KernelTypes::KLevel, univ_offset: Field, + flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + flat_own_params: Lists::List, self_pos: Field) -> KernelTypes::KExpr { + let n_motives = Lists::length(flat); + let motive_base = n_params; + + let p_us = build_param_lvls_range(univ_offset, prim_nlvls, 0); + match collect_n_doms_whnf(rc, KernelLevels::expr_inst_levels(prim_ty, p_us), n_params) { + (param_doms, after_params) => { + let motive_doms = build_all_motives(rc, flat, elim_level, n_params); + let minor_doms = build_all_minors(rc, flat, flat_own_params, n_params, + n_motives, motive_base); + let n_minors = Lists::length(minor_doms); + let (self_addr, self_is_aux, self_spec_params, self_occ_us) = + flat_member_at(flat, self_pos); + + let KernelTypes::KConstantInfo::Induct(_, self_ind_ty, self_own_params, + _, _, _, _, _) = (*(Ingress::get_ci(self_addr))); + let self_ty_inst = KernelLevels::expr_inst_levels(self_ind_ty, self_occ_us); + let self_after_params = peel_motive_params_subst(self_ty_inst, + self_own_params, n_params, self_is_aux, self_spec_params, 0); + let index_doms_raw = collect_index_doms(rc, self_after_params, + n_indices); + let index_doms = list_lift_indices(index_doms_raw, + n_motives + n_minors, 0); + let head = (&(KernelTypes::KExprNode::Const(self_addr, self_occ_us))); + let pre_major_depth = ((n_params + n_motives) + n_minors) + n_indices; + let with_args = build_major_args_for_self(head, n_params, + pre_major_depth - 1, (n_motives + n_minors) + n_indices, + self_is_aux, self_spec_params); + let major_ty = build_major_indices(with_args, n_indices, 0); + + let depth_after_major = pre_major_depth + 1; + let motive_var = (depth_after_major - 1) - (motive_base + self_pos); + let motive_ref = (&(KernelTypes::KExprNode::BVar(motive_var))); + let with_indices = apply_indices_in_conclusion(motive_ref, + n_indices, 0); + let conclusion = (&(KernelTypes::KExprNode::App(with_indices, + (&(KernelTypes::KExprNode::BVar(0)))))); + let with_major = (&(KernelTypes::KExprNode::Forall(major_ty, conclusion))); + let with_idx_foralls = wrap_foralls(with_major, index_doms); + let with_minors = wrap_foralls(with_idx_foralls, minor_doms); + let with_motives = wrap_foralls(with_minors, motive_doms); + wrap_foralls(with_motives, param_doms) } , + } + } + + fn check_recursor_canonical_full(rc: KernelRoles::RoleCtx, rec_ci: KernelTypes::KConstantInfo, addr: Bytes::AddressRef, + parent_ci: KernelTypes::KConstantInfo, + parent_addr: Bytes::AddressRef) -> () { + match rec_ci { + KernelTypes::KConstantInfo::Rec(nlvls, ty, n_p, n_i, n_mot, n_min, rules, + _k_flag, _uns, rec_block_addr, _rec_idx) => { + match parent_ci { + KernelTypes::KConstantInfo::Induct(pnlvls, pty, pnp, pni, num_ctors, _, + parent_block_addr, parent_ind_idx) => { + let single_ctor_pair = match num_ctors { + 1 => { + let cci = (*(Ingress::get_ci_cprj(parent_block_addr, + parent_ind_idx, 0))); + (1, cci) } , + _ => { + (0, KernelTypes::KConstantInfo::Axiom(0, (&(KernelTypes::KExprNode::Srt( + (&(KernelTypes::KLevelNode::Zero))))), 0)) } , + }; + let result_level = get_result_sort_level(rc, pty, pnp + pni, + (&(Lists::Node::Nil))); + let univ_offset = is_large_eliminator(rc, result_level, + num_ctors, single_ctor_pair, + ind_is_solo(parent_block_addr, parent_addr)); + let elim_level = match univ_offset { + 1 => { (&(KernelTypes::KLevelNode::Param(0))) } , + _ => { (&(KernelTypes::KLevelNode::Zero)) } , + }; + let rec_lvls_list = build_rec_lvls_list(nlvls, 0); + let flat = build_flat_block(rec_block_addr, parent_block_addr, + univ_offset); + let peer_recs = build_peer_recs(flat, rec_block_addr, addr); + let flat_own_params = build_flat_own_params(flat); + let rec_is_aux = is_muts_block(rec_block_addr) * + is_muts_block(parent_block_addr) * + (1 - Bytes::address_eq(rec_block_addr, parent_block_addr)); + let rec_spec_params = match rec_is_aux { + 1 => { extract_aux_spec_params_from_rec(rec_ci, pnp) } , + _ => { (&(Lists::Node::Nil)) } , + }; + + let kind_hit = flat_find_pos_kind(flat, parent_addr, + rec_is_aux, + rec_spec_params, 0); + match kind_hit { + (1, self_pos) => { + canonical_rules_at_pos(rc, flat, self_pos, num_ctors, + parent_block_addr, parent_ind_idx, n_p, n_mot, n_min, + rec_lvls_list, peer_recs, flat_own_params, rules, + ty, pty, pnlvls, pni, elim_level, univ_offset) } , + _ => { + match flat_find_pos(flat, parent_addr, 0) { + (1, self_pos) => { + canonical_rules_at_pos(rc, flat, self_pos, num_ctors, + parent_block_addr, parent_ind_idx, n_p, n_mot, + n_min, rec_lvls_list, peer_recs, flat_own_params, + rules, ty, pty, pnlvls, pni, elim_level, univ_offset) } , + } } , + } } , + _ => { () } , + } } , + } + } + + fn canonical_rules_at_pos(rc: KernelRoles::RoleCtx, flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + self_pos: Field, num_ctors: Field, + parent_block_addr: Bytes::AddressRef, + parent_ind_idx: Field, n_p: Field, n_mot: Field, + n_min: Field, rec_lvls_list: Lists::List, + peer_recs: Lists::List, + flat_own_params: Lists::List, + rules: Lists::List, + ty: KernelTypes::KExpr, pty: KernelTypes::KExpr, pnlvls: Field, pni: Field, + elim_level: KernelTypes::KLevel, univ_offset: Field) -> () { + match flat_member_at(flat, self_pos) { + (_, is_aux, spec_params, occ_us) => { + + let canonical_ty = build_rec_type(rc, pty, pnlvls, n_p, pni, elim_level, + univ_offset, flat, flat_own_params, self_pos); + assert_eq!(KernelDefEq::k_is_def_eq(rc, ty, canonical_ty, (&(Lists::Node::Nil))), 1, + "recursor's declared type is not def-eq to the canonical reconstruction"); + + let canon_n_motives = Lists::length(flat); + let canon_n_minors = Lists::length(build_all_minors(rc, flat, + flat_own_params, n_p, canon_n_motives, n_p)); + assert_eq!(n_mot, canon_n_motives, + "recursor motive count disagrees with the canonical reconstruction"); + assert_eq!(n_min, canon_n_minors, + "recursor minor count disagrees with the canonical reconstruction"); + let self_ctors_offset = ctors_before_pos(flat, self_pos, 0); + let canonical = populate_rules(rc, num_ctors, self_ctors_offset, + parent_block_addr, parent_ind_idx, n_p, n_mot, n_min, occ_us, + rec_lvls_list, flat, peer_recs, flat_own_params, is_aux, + spec_params, 0); + compare_rules(rc, rules, canonical, n_p, n_mot, n_min, + parent_block_addr, parent_ind_idx, num_ctors, 0) } , + } + } + + fn ctors_before_pos(flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + target_pos: Field, cur_pos: Field) -> Field { + match cur_pos - target_pos { + 0 => { 0 } , + _ => { + match (*(flat)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(m, rest) => { + match m { + (addr, _, _, _) => { + let ci = (*(Ingress::get_ci(addr))); + let n = match ci { + KernelTypes::KConstantInfo::Induct(_, _, _, _, nc, _, _, _) => { nc } , + _ => { 0 } , + }; + n + ctors_before_pos(rest, target_pos, cur_pos + 1) } , + } } , + } } , + } + } + + fn populate_rules(rc: KernelRoles::RoleCtx, num_ctors: Field, self_ctors_offset: Field, + block_addr: Bytes::AddressRef, ind_idx: Field, + n_params: Field, n_motives: Field, n_minors: Field, + occurrence_us: Lists::List, + rec_lvls_list: Lists::List, + flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + peer_recs: Lists::List, + flat_own_params: Lists::List, + is_aux: Field, spec_params: Lists::List, + cidx: Field) -> Lists::List { + match num_ctors - cidx { + 0 => { (&(Lists::Node::Nil)) } , + _ => { + let ctor_ci = (*(Ingress::get_ci_cprj(block_addr, ind_idx, cidx))); + match ctor_ci { + KernelTypes::KConstantInfo::Ctor(_, ctor_ty, _, _, _, np, _, _) => { + let ctor_minor_index = self_ctors_offset + cidx; + let rhs = build_rule_rhs(rc, ctor_ty, ctor_minor_index, + n_params, n_motives, n_minors, np, occurrence_us, + rec_lvls_list, flat, peer_recs, flat_own_params, + is_aux, spec_params); + (&(Lists::Node::Cons(rhs, + populate_rules(rc, num_ctors, self_ctors_offset, block_addr, + ind_idx, n_params, n_motives, n_minors, occurrence_us, + rec_lvls_list, flat, peer_recs, flat_own_params, is_aux, + spec_params, cidx + 1)))) } , + _ => { (&(Lists::Node::Nil)) } , + } } , + } + } + + fn compare_rules(rc: KernelRoles::RoleCtx, stored: Lists::List, canonical: Lists::List, + n_p: Field, n_mot: Field, n_min: Field, + block_addr: Bytes::AddressRef, ind_idx: Field, num_ctors: Field, pos: Field) -> () { + match (*(stored)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(r, rest) => { + match r { + KernelTypes::KRecRule::Mk(cidx, nf, rhs) => { + + assert_eq!(cidx, pos, + "recursor rule is out of ctor order"); + assert_eq!(UInt32::less_than_fields(cidx, num_ctors), 1, + "recursor rule names a ctor index out of range"); + let ctor_ci = (*(Ingress::get_ci_cprj(block_addr, ind_idx, cidx))); + match ctor_ci { + KernelTypes::KConstantInfo::Ctor(_, _, _, _, _, _, c_nf, _) => { + assert_eq!(nf, c_nf, + "recursor rule field count differs from the ctor's"); + () } , + }; + match (*(canonical)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(cbody, crest) => { + let total = ((n_p + n_mot) + n_min) + nf; + match peel_n_lams_collect(rhs, total, 0, + (&(Lists::Node::Nil))) { + (stored_body, peeled, _) => { + assert_eq!(peeled, total, + "recursor rule rhs has too few binders to peel"); + + assert_eq!(KernelDefEq::k_is_def_eq(rc, stored_body, cbody, + (&(Lists::Node::Nil))), 1, + "recursor rule rhs differs from canonical reconstruction"); + () } , + }; + compare_rules(rc, rest, crest, n_p, n_mot, n_min, + block_addr, ind_idx, num_ctors, pos + 1) } , + } } , + } } , + } + } + + fn apply_ihs_full(rc: KernelRoles::RoleCtx, head: KernelTypes::KExpr, rec_indices: Lists::List, + rec_member_idxs: Lists::List, + field_doms: Lists::List, + peer_recs: Lists::List, + flat_own_params: Lists::List, + n_params: Field, n_motives: Field, n_minors: Field, + n_fields: Field, rec_lvls_list: Lists::List, + k: Field) -> KernelTypes::KExpr { + match (*(rec_indices)) { + Lists::Node::Nil => { head } , + Lists::Node::Cons(field_idx, rest) => { + let mem_idx = Lists::lookup_or_default(rec_member_idxs, k, 0); + let target_rec = Lists::lookup_or_default(peer_recs, mem_idx, + (&([UInt8::BYTE_0; 32]))); + let target_n_params = Lists::lookup_or_default(flat_own_params, + mem_idx, 0); + let body_depth = ((n_params + n_motives) + n_minors) + n_fields; + let dom = Lists::lookup(field_doms, field_idx); + let dom_s1 = KernelSubst::expr_lift(dom, n_fields - field_idx, 0); + let dom_lifted = KernelSubst::expr_lift(dom_s1, n_motives + n_minors, n_fields); + match peel_leading_foralls(dom_lifted) { + (forall_doms, inner_body) => { + let n_xs = Lists::length(forall_doms); + let inner_depth = body_depth + n_xs; + let rec_const = (&(KernelTypes::KExprNode::Const(target_rec, rec_lvls_list))); + let with_params = build_apply_bvars_decreasing(rec_const, + n_params, inner_depth - 1, 0); + let with_motives = build_motive_apps(with_params, n_motives, + (inner_depth - 1) - n_params, 0); + let with_minors = build_minor_apps(with_motives, n_minors, + ((inner_depth - 1) - n_params) - n_motives, 0); + + match KernelTypes::collect_spine(KernelWhnf::whnf(rc, inner_body, (&(Lists::Node::Nil)))) { + (_dh, dargs) => { + let idx_args = Lists::drop(dargs, target_n_params); + let with_idx = apply_spine_expr(with_minors, idx_args); + let field_base = ((n_fields - 1) - field_idx) + n_xs; + let field_ref = (&(KernelTypes::KExprNode::BVar(field_base))); + let field_app = build_apply_xs(field_ref, n_xs, 0); + let ih_inner = (&(KernelTypes::KExprNode::App(with_idx, field_app))); + let ih = wrap_lams(ih_inner, forall_doms); + let new_head = (&(KernelTypes::KExprNode::App(head, ih))); + apply_ihs_full(rc, new_head, rest, rec_member_idxs, + field_doms, peer_recs, flat_own_params, n_params, + n_motives, n_minors, n_fields, rec_lvls_list, k + 1) } , + } } , + } } , + } + } + + fn build_rule_rhs(rc: KernelRoles::RoleCtx, ctor_ty: KernelTypes::KExpr, ctor_minor_index: Field, + n_params: Field, n_motives: Field, n_minors: Field, + n_own_params: Field, + occurrence_us: Lists::List, + rec_lvls_list: Lists::List, + flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + peer_recs: Lists::List, + flat_own_params: Lists::List, + is_aux: Field, spec_params: Lists::List) -> KernelTypes::KExpr { + let ctor_ty_inst = KernelLevels::expr_inst_levels(ctor_ty, occurrence_us); + let after_params_raw = peel_n_foralls(ctor_ty_inst, n_own_params); + let n_fields = count_foralls_body(after_params_raw, 0); + let body_depth = ((n_params + n_motives) + n_minors) + n_fields; + + let after_params = peel_ctor_params_subst(rc, ctor_ty_inst, n_own_params, + n_own_params, 0, is_aux, spec_params, 0); + + match walk_fields_classify(rc, after_params, flat, (&(Lists::Node::Nil)), + (&(Lists::Node::Nil)), (&(Lists::Node::Nil)), 0, 0) { + (field_doms, rec_indices, rec_member_idxs, _ret_ty) => { + let minor_var = (body_depth - 1) - ((n_params + n_motives) + + ctor_minor_index); + let base = (&(KernelTypes::KExprNode::BVar(minor_var))); + let with_fields = build_apply_field_bvars(base, n_fields, + n_fields, 0); + apply_ihs_full(rc, with_fields, rec_indices, rec_member_idxs, + field_doms, peer_recs, flat_own_params, n_params, n_motives, + n_minors, n_fields, rec_lvls_list, 0) } , + } + } + + fn build_peer_recs(flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + rec_block_addr: Bytes::AddressRef, + rec_self_addr: Bytes::AddressRef) -> Lists::List { + match (*(flat)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(m, rest) => { + match m { + (member_addr, is_aux, sp, _ou) => { + let peer = find_peer_recursor_with_spec(rec_block_addr, + member_addr, sp, is_aux, rec_self_addr); + (&(Lists::Node::Cons(peer, + build_peer_recs(rest, rec_block_addr, rec_self_addr)))) } , + } } , + } + } + + fn find_peer_recursor_with_spec(block_addr: Bytes::AddressRef, + target_ind_addr: Bytes::AddressRef, + target_sp: Lists::List, + target_is_aux: Field, + rec_self_addr: Bytes::AddressRef) -> Bytes::AddressRef { + let block_c = Ingress::load_verified_constant(block_addr); + match block_c { + Ixon::Constant::Mk(info, _, _, _) => { + match info { + Ixon::ConstantInfo::Muts(members) => { + find_peer_rec_spec_walk(members, members, block_addr, + target_ind_addr, target_sp, target_is_aux, rec_self_addr, 0) } , + _ => { rec_self_addr } , + } } , + } + } + + fn find_peer_rec_spec_walk(all_members: Lists::List, + cur: Lists::List, block_addr: Bytes::AddressRef, + target_ind_addr: Bytes::AddressRef, + target_sp: Lists::List, + target_is_aux: Field, + rec_self_addr: Bytes::AddressRef, pos: Field) -> Bytes::AddressRef { + match (*(cur)) { + Lists::Node::Nil => { rec_self_addr } , + Lists::Node::Cons(m, rest) => { + match m { + Ixon::MutConst::Recr(_) => { + let rec_wrapper = Ingress::projection_addr(all_members, block_addr, pos); + let rec_ci = (*(Ingress::get_ci(rec_wrapper))); + let is_match = match rec_ci { + KernelTypes::KConstantInfo::Rec(_, ty, np, ni, nmot, nmin, _, _, _, _, _) => { + let parent = rec_to_parent_addr(ty, np, nmot, nmin, ni); + let parent_ci = (*(Ingress::get_ci(parent))); + let pnp = match parent_ci { + KernelTypes::KConstantInfo::Induct(_, _, p, _, _, _, _, _) => { p } , + _ => { 0 } , + }; + let addr_m = Bytes::address_eq(parent, target_ind_addr); + match addr_m { + 1 => { + match target_is_aux { + 0 => { 1 } , + _ => { + let rec_sp = extract_aux_spec_params(ty, np, + nmot, nmin, ni, pnp); + spec_params_ptr_eq(rec_sp, target_sp) } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + }; + match is_match { + 1 => { rec_wrapper } , + _ => { + find_peer_rec_spec_walk(all_members, rest, block_addr, + target_ind_addr, target_sp, target_is_aux, + rec_self_addr, pos + 1) } , + } } , + _ => { + find_peer_rec_spec_walk(all_members, rest, block_addr, + target_ind_addr, target_sp, target_is_aux, rec_self_addr, + pos + 1) } , + } } , + } + } + + fn build_flat_own_params(flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>) + -> Lists::List { + match (*(flat)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(m, rest) => { + match m { + (member_addr, _is_aux, _sp, _ou) => { + let ci = (*(Ingress::get_ci(member_addr))); + let np = match ci { + KernelTypes::KConstantInfo::Induct(_, _, n, _, _, _, _, _) => { n } , + _ => { 0 } , + }; + (&(Lists::Node::Cons(np, + build_flat_own_params(rest)))) } , + } } , + } + } + + fn projection_addr_ctor(ind_idx: Field, cidx: Field, + block_addr: Bytes::AddressRef) -> Bytes::AddressRef { + let idx_u64 = UInt64::from_field(ind_idx); + let cidx_u64 = UInt64::from_field(cidx); + let info = Ixon::ConstantInfo::CPrj(Ixon::ConstructorProj::Mk(idx_u64, cidx_u64, + block_addr)); + let proj_c = Ixon::Constant::Mk(info, + (&(Lists::Node::Nil)), (&(Lists::Node::Nil)), (&(Lists::Node::Nil))); + let bytes = IxonSerialize::put_constant(proj_c, (&(Lists::Node::Nil))); + Blake3::bytes_to_addr(bytes) + } + + fn build_minor_doms(rc: KernelRoles::RoleCtx, member_addr: Bytes::AddressRef, is_aux: Field, + spec_params: Lists::List, + occurrence_us: Lists::List, + flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + flat_own_params: Lists::List, + n_rec_params: Field, n_motives: Field, + motive_base: Field, self_mem_idx: Field, + block_addr: Bytes::AddressRef, ind_idx: Field, + num_ctors: Field, prev_minors: Field, + cidx: Field) -> Lists::List { + match num_ctors - cidx { + 0 => { (&(Lists::Node::Nil)) } , + _ => { + let ctor_ci = (*(Ingress::get_ci_cprj(block_addr, ind_idx, cidx))); + match ctor_ci { + KernelTypes::KConstantInfo::Ctor(_, ctor_ty, _, _, _, np, _nf, _) => { + let ctor_addr = projection_addr_ctor(ind_idx, cidx, block_addr); + let minor = build_minor_at_depth(rc, ctor_addr, ctor_ty, np, + is_aux, spec_params, occurrence_us, flat, flat_own_params, + n_rec_params, n_motives, prev_minors, motive_base, + self_mem_idx); + (&(Lists::Node::Cons(minor, + build_minor_doms(rc, member_addr, is_aux, spec_params, + occurrence_us, flat, flat_own_params, n_rec_params, + n_motives, motive_base, self_mem_idx, block_addr, ind_idx, + num_ctors, prev_minors + 1, cidx + 1)))) } , + + } } , + } + } + + fn build_all_minors(rc: KernelRoles::RoleCtx, flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + flat_own_params: Lists::List, + n_rec_params: Field, n_motives: Field, + motive_base: Field) -> Lists::List { + build_all_minors_walk(rc, flat, flat, flat_own_params, n_rec_params, + n_motives, motive_base, 0, 0) + } + + fn build_all_minors_walk(rc: KernelRoles::RoleCtx, flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + full_flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + flat_own_params: Lists::List, + n_rec_params: Field, n_motives: Field, + motive_base: Field, prev_minors: Field, + mem_pos: Field) -> Lists::List { + match (*(flat)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(m, rest) => { + match m { + (member_addr, is_aux, spec_params, occ_us) => { + let ci = (*(Ingress::get_ci(member_addr))); + match ci { + KernelTypes::KConstantInfo::Induct(_, _, _, _, num_ctors, _, + mem_block_addr, mem_ind_idx) => { + let m_minors = build_minor_doms(rc, member_addr, is_aux, + spec_params, occ_us, full_flat, flat_own_params, + n_rec_params, n_motives, motive_base, mem_pos, + mem_block_addr, mem_ind_idx, num_ctors, prev_minors, 0); + let added = Lists::length(m_minors); + let rest_minors = build_all_minors_walk(rc, rest, full_flat, + flat_own_params, n_rec_params, n_motives, motive_base, + prev_minors + added, mem_pos + 1); + Lists::concat(m_minors, rest_minors) } , + _ => { + build_all_minors_walk(rc, rest, full_flat, flat_own_params, + n_rec_params, n_motives, motive_base, prev_minors, + mem_pos + 1) } , + } } , + } } , + } + } + + fn ctor_subst_param_for(j: Field, depth: Field, spec_lift: Field, is_aux: Field, + spec_params: Lists::List) -> KernelTypes::KExpr { + match is_aux { + 0 => { (&(KernelTypes::KExprNode::BVar((depth - 1) - j))) } , + _ => { + let len = Lists::length(spec_params); + match UInt32::less_than_fields(j, len) { + 1 => { KernelSubst::expr_lift(Lists::lookup(spec_params, j), spec_lift, 0) } , + _ => { (&(KernelTypes::KExprNode::BVar((depth - 1) - j))) } , + } } , + } + } + + fn count_foralls_body(ty: KernelTypes::KExpr, acc: Field) -> Field { + match (*(ty)) { + KernelTypes::KExprNode::Forall(_, body) => { count_foralls_body(body, acc + 1) } , + _ => { acc } , + } + } + + fn peel_ctor_params_subst(rc: KernelRoles::RoleCtx, ty: KernelTypes::KExpr, n: Field, depth: Field, spec_lift: Field, + is_aux: Field, spec_params: Lists::List, + j: Field) -> KernelTypes::KExpr { + match n { + 0 => { ty } , + _ => { + + match (*(ty)) { + KernelTypes::KExprNode::Forall(_, body) => { + let p = ctor_subst_param_for(j, depth, spec_lift, is_aux, + spec_params); + let body_substed = KernelSubst::expr_inst1(body, p, 0); + peel_ctor_params_subst(rc, body_substed, n - 1, depth, + spec_lift, is_aux, spec_params, j + 1) } , + _ => { + match (*(KernelWhnf::whnf(rc, ty, (&(Lists::Node::Nil))))) { + KernelTypes::KExprNode::Forall(_, body) => { + let p = ctor_subst_param_for(j, depth, spec_lift, is_aux, + spec_params); + let body_substed = KernelSubst::expr_inst1(body, p, 0); + peel_ctor_params_subst(rc, body_substed, n - 1, depth, + spec_lift, is_aux, spec_params, j + 1) } , + } } , + } } , + } + } + + fn build_minor_at_depth(rc: KernelRoles::RoleCtx, ctor_addr: Bytes::AddressRef, ctor_ty: KernelTypes::KExpr, + n_own_params: Field, + is_aux: Field, spec_params: Lists::List, + occurrence_us: Lists::List, + flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + flat_own_params: Lists::List, + n_rec_params: Field, n_motives: Field, + prev_minors: Field, motive_base: Field, + self_mem_idx: Field) -> KernelTypes::KExpr { + let ctor_ty_inst = KernelLevels::expr_inst_levels(ctor_ty, occurrence_us); + let minor_saved = n_rec_params + n_motives + prev_minors; + let below_params = n_motives + prev_minors; + let after_params = peel_ctor_params_subst(rc, ctor_ty_inst, n_own_params, + minor_saved, below_params, is_aux, spec_params, 0); + match walk_fields_classify(rc, after_params, flat, (&(Lists::Node::Nil)), + (&(Lists::Node::Nil)), (&(Lists::Node::Nil)), 0, below_params) { + (field_doms, rec_indices, rec_member_idxs, ret_ty) => { + let n_fields = Lists::length(field_doms); + let n_ihs = Lists::length(rec_indices); + let n_binders = n_fields + n_ihs; + let depth_now = minor_saved + n_binders; + match KernelTypes::collect_spine(ret_ty) { + (_ret_head, ret_args) => { + let ret_indices = Lists::drop(ret_args, n_own_params); + let ret_indices_lifted = list_lift_each(ret_indices, n_ihs, 0); + let motive_var = (depth_now - 1) - (motive_base + self_mem_idx); + let motive_ref = (&(KernelTypes::KExprNode::BVar(motive_var))); + let with_indices = apply_spine_expr(motive_ref, + ret_indices_lifted); + let ctor_head = (&(KernelTypes::KExprNode::Const(ctor_addr, occurrence_us))); + let with_params = build_ctor_app_params(ctor_head, + n_own_params, n_rec_params, depth_now, is_aux, spec_params); + let ctor_app = build_apply_field_bvars(with_params, + n_fields, n_binders, 0); + let conclusion = (&(KernelTypes::KExprNode::App(with_indices, ctor_app))); + let ih_doms = build_ih_doms(rc, rec_indices, rec_member_idxs, + field_doms, flat_own_params, motive_base, n_fields, + minor_saved, 0); + let with_ihs = wrap_foralls(conclusion, ih_doms); + wrap_foralls(with_ihs, field_doms) } , + } } , + } + } + + fn peel_leading_foralls(ty: KernelTypes::KExpr) -> (Lists::List, KernelTypes::KExpr) { + let pair = peel_leading_foralls_acc(ty, (&(Lists::Node::Nil))); + match pair { + (rev_acc, body) => { (Lists::reverse(rev_acc), body) } , + } + } + + fn peel_leading_foralls_acc(ty: KernelTypes::KExpr, acc: Lists::List) + -> (Lists::List, KernelTypes::KExpr) { + match (*(ty)) { + KernelTypes::KExprNode::Forall(dom, body) => { + peel_leading_foralls_acc(body, (&(Lists::Node::Cons(dom, acc)))) } , + _ => { (acc, ty) } , + } + } + + fn build_apply_xs(head: KernelTypes::KExpr, n_xs: Field, i: Field) -> KernelTypes::KExpr { + match n_xs - i { + 0 => { head } , + _ => { + let v = (&(KernelTypes::KExprNode::BVar((n_xs - 1) - i))); + build_apply_xs((&(KernelTypes::KExprNode::App(head, v))), n_xs, i + 1) } , + } + } + + fn build_ih_doms(rc: KernelRoles::RoleCtx, rec_indices: Lists::List, rec_member_idxs: Lists::List, + field_doms: Lists::List, + flat_own_params: Lists::List, + motive_base: Field, n_fields: Field, minor_saved: Field, + k: Field) -> Lists::List { + match (*(rec_indices)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(field_idx, rest) => { + let mem_idx = Lists::lookup_or_default(rec_member_idxs, k, 0); + let target_n_params = Lists::lookup_or_default(flat_own_params, + mem_idx, 0); + let depth = minor_saved + n_fields + k; + let dom = Lists::lookup(field_doms, field_idx); + let dom_lifted = KernelSubst::expr_lift(dom, (n_fields - field_idx) + k, 0); + match peel_leading_foralls(dom_lifted) { + (forall_doms, inner_body) => { + let n_xs = Lists::length(forall_doms); + let inner_depth = depth + n_xs; + let motive_bvar = (inner_depth - 1) - (motive_base + mem_idx); + let field_bvar = (inner_depth - 1) - (minor_saved + field_idx); + + match KernelTypes::collect_spine(KernelWhnf::whnf(rc, inner_body, (&(Lists::Node::Nil)))) { + (_h, dom_args) => { + let idx_args = Lists::drop(dom_args, target_n_params); + let motive_ref = (&(KernelTypes::KExprNode::BVar(motive_bvar))); + let with_indices = apply_spine_expr(motive_ref, idx_args); + let field_ref = (&(KernelTypes::KExprNode::BVar(field_bvar))); + let field_app = build_apply_xs(field_ref, n_xs, 0); + let ih_body = (&(KernelTypes::KExprNode::App(with_indices, field_app))); + let ih_dom = wrap_foralls(ih_body, forall_doms); + (&(Lists::Node::Cons(ih_dom, + build_ih_doms(rc, rest, rec_member_idxs, field_doms, + flat_own_params, motive_base, n_fields, minor_saved, + k + 1)))) } , + } } , + } } , + } + } + + fn list_lift_each(es: Lists::List, shift: Field, cutoff: Field) + -> Lists::List { + match (*(es)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(e, rest) => { + (&(Lists::Node::Cons(KernelSubst::expr_lift(e, shift, cutoff), + list_lift_each(rest, shift, cutoff)))) } , + } + } + + fn build_apply_bvars_decreasing(head: KernelTypes::KExpr, n: Field, start: Field, + j: Field) -> KernelTypes::KExpr { + match n - j { + 0 => { head } , + _ => { + let v = (&(KernelTypes::KExprNode::BVar(start - j))); + build_apply_bvars_decreasing((&(KernelTypes::KExprNode::App(head, v))), + n, start, j + 1) } , + } + } + + fn build_apply_field_bvars(head: KernelTypes::KExpr, n_fields: Field, n_binders: Field, + i: Field) -> KernelTypes::KExpr { + match n_fields - i { + 0 => { head } , + _ => { + let v = (&(KernelTypes::KExprNode::BVar((n_binders - 1) - i))); + build_apply_field_bvars((&(KernelTypes::KExprNode::App(head, v))), + n_fields, n_binders, i + 1) } , + } + } + + fn build_ctor_app_params(head: KernelTypes::KExpr, n_own_params: Field, n_rec_params: Field, + depth_now: Field, is_aux: Field, + spec_params: Lists::List) -> KernelTypes::KExpr { + match is_aux { + 0 => { build_apply_bvars_decreasing(head, n_rec_params, + depth_now - 1, 0) } , + _ => { apply_spec_params_lifted(head, spec_params, + depth_now - n_rec_params) } , + } + } + + fn is_rec_field(rc: KernelRoles::RoleCtx, dom: KernelTypes::KExpr, + flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + spec_lift_by: Field) -> (Field, Field) { + is_rec_field_peel(rc, dom, flat, spec_lift_by) + } + + fn is_rec_field_peel(rc: KernelRoles::RoleCtx, ty: KernelTypes::KExpr, flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + spec_lift_by: Field) -> (Field, Field) { + let w = KernelWhnf::whnf(rc, ty, (&(Lists::Node::Nil))); + match (*(w)) { + KernelTypes::KExprNode::Forall(_, body) => { + is_rec_field_peel(rc, body, flat, spec_lift_by) } , + _ => { + match KernelTypes::collect_spine(w) { + (head, args) => { + match (*(head)) { + KernelTypes::KExprNode::Const(caddr, _) => { + flat_find_matching(flat, caddr, args, spec_lift_by, 0) } , + _ => { (0, 0) } , + } } , + } } , + } + } + + fn flat_find_matching(flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + caddr: Bytes::AddressRef, dom_args: Lists::List, + spec_lift_by: Field, pos: Field) -> (Field, Field) { + match (*(flat)) { + Lists::Node::Nil => { (0, 0) } , + Lists::Node::Cons(m, rest) => { + match m { + (member_addr, is_aux, sp, _) => { + let addr_match = Bytes::address_eq(member_addr, caddr); + let spec_match = match is_aux { + 0 => { 1 } , + _ => { spec_params_dom_prefix_match(sp, dom_args, + spec_lift_by) } , + }; + match addr_match * spec_match { + 1 => { (1, pos) } , + _ => { flat_find_matching(rest, caddr, dom_args, + spec_lift_by, pos + 1) } , + } } , + } } , + } + } + + fn spec_params_dom_prefix_match(sp: Lists::List, + args: Lists::List, + lift_by: Field) -> Field { + match (*(sp)) { + Lists::Node::Nil => { 1 } , + Lists::Node::Cons(s, sr) => { + match (*(args)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(a, ar) => { + let s_lifted = KernelSubst::expr_lift(s, lift_by, 0); + match kexpr_struct_eq(s_lifted, a) { + 1 => { spec_params_dom_prefix_match(sr, ar, lift_by) } , + _ => { 0 } , + } } , + } } , + } + } + + fn walk_fields_classify(rc: KernelRoles::RoleCtx, ty: KernelTypes::KExpr, + flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + doms_acc: Lists::List, rec_acc: Lists::List, + rec_mem_acc: Lists::List, + fidx: Field, spec_lift_by: Field) + -> (Lists::List, Lists::List, Lists::List, KernelTypes::KExpr) { + match (*(ty)) { + KernelTypes::KExprNode::Forall(dom, body) => { + + let r = is_rec_field(rc, dom, flat, spec_lift_by + fidx); + let new_doms = (&(Lists::Node::Cons(dom, doms_acc))); + match r { + (1, mem_idx) => { + let new_rec = (&(Lists::Node::Cons(fidx, rec_acc))); + let new_mem = (&(Lists::Node::Cons(mem_idx, rec_mem_acc))); + walk_fields_classify(rc, body, flat, new_doms, new_rec, + new_mem, fidx + 1, spec_lift_by) } , + _ => { + walk_fields_classify(rc, body, flat, new_doms, rec_acc, + rec_mem_acc, fidx + 1, spec_lift_by) } , + } } , + _ => { (Lists::reverse(doms_acc), Lists::reverse(rec_acc), + Lists::reverse(rec_mem_acc), ty) } , + } + } + + fn build_all_motives_walk(rc: KernelRoles::RoleCtx, flat: Lists::List<(Bytes::AddressRef, Field, Lists::List, Lists::List)>, + elim_level: KernelTypes::KLevel, n_rec_params: Field, + j: Field) -> Lists::List { + match (*(flat)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(m, rest) => { + match m { + (member_addr, is_aux, spec_params, occ_us) => { + let ci = (*(Ingress::get_ci(member_addr))); + match ci { + KernelTypes::KConstantInfo::Induct(_, m_ind_ty, m_own_params, m_n_indices, + _, _, _, _) => { + let mt = build_motive_type_flat(rc, member_addr, m_ind_ty, + m_own_params, m_n_indices, occ_us, elim_level, + n_rec_params, is_aux, spec_params); + let mt_lifted = KernelSubst::expr_lift(mt, j, 0); + (&(Lists::Node::Cons(mt_lifted, + build_all_motives_walk(rc, rest, elim_level, n_rec_params, + j + 1)))) } , + _ => { + build_all_motives_walk(rc, rest, elim_level, n_rec_params, j) } , + } } , + } } , + } + } + + fn check_recursor_member(rc: KernelRoles::RoleCtx, rec_ci: KernelTypes::KConstantInfo, addr: Bytes::AddressRef) -> () { + match rec_ci { + KernelTypes::KConstantInfo::Rec(nlvls, ty, n_p, n_i, n_mot, n_min, rules, k_flag, + _uns, rec_block_addr, _rec_idx) => { + let parent_addr = rec_to_parent_addr(ty, n_p, n_mot, n_min, n_i); + let parent_ci = (*(Ingress::get_ci(parent_addr))); + match parent_ci { + KernelTypes::KConstantInfo::Induct(_parent_nlvls, _, parent_np, parent_ni, + num_ctors, _, + parent_block_addr, parent_ind_idx) => { + + let is_aux = is_muts_block(rec_block_addr) * + is_muts_block(parent_block_addr) * + (1 - Bytes::address_eq(rec_block_addr, parent_block_addr)); + assert_eq!(Lists::length(rules), num_ctors, + "recursor rule count differs from the inductive's ctor count"); + peel_n_foralls(ty, + ((n_p + n_mot) + n_min + n_i) + 1); + check_rec_rules_wellscoped(rules, + n_p + n_mot + n_min, nlvls); + + match is_aux { + 1 => { () } , + _ => { + assert_eq!(n_p, parent_np, + "recursor parameter count differs from its inductive's"); + assert_eq!(n_i, parent_ni, + "recursor index count differs from its inductive's"); + check_rec_major_spine(ty, n_p, n_mot, n_min, n_i, + parent_np + parent_ni) } , + }; + + let computed_k = compute_k_target(rc, parent_ci, parent_addr); + assert_eq!(k_flag, computed_k, + "recursor k_flag disagrees with its inductive's K eligibility"); + + check_parent_inductive_shape(rc, parent_ci); + + check_recursor_canonical_full(rc, rec_ci, addr, parent_ci, parent_addr) } , + } } , + } + } + + fn check_rec_major_spine(ty: KernelTypes::KExpr, n_p: Field, n_mot: Field, n_min: Field, + n_i: Field, expected_args: Field) -> () { + let skip = n_p + n_mot + n_min + n_i; + let after_skip = peel_n_foralls(ty, skip); + match (*(after_skip)) { + KernelTypes::KExprNode::Forall(major_ty, _) => { + match KernelTypes::collect_spine(major_ty) { + (_head, args) => { + assert_eq!(Lists::length(args), expected_args, + "recursor major premise has the wrong number of spine args"); + () } , + } } , + } + } + + fn apply_spine_expr(head: KernelTypes::KExpr, args: Lists::List) -> KernelTypes::KExpr { + match (*(args)) { + Lists::Node::Nil => { head } , + Lists::Node::Cons(a, rest) => { + apply_spine_expr((&(KernelTypes::KExprNode::App(head, a))), rest) } , + } + } + + fn build_rec_lvls_list(total: Field, i: Field) -> Lists::List { + match total - i { + 0 => { (&(Lists::Node::Nil)) } , + _ => { + (&(Lists::Node::Cons( + (&(KernelTypes::KLevelNode::Param(i))), + build_rec_lvls_list(total, i + 1)))) } , + } + } + + fn check_rec_rules_wellscoped(rules: Lists::List, + outer_depth: Field, nlvls: Field) -> () { + match (*(rules)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(r, rest) => { + match r { + KernelTypes::KRecRule::Mk(_, nf, rhs) => { + validate_expr_well_scoped(rhs, outer_depth + nf, nlvls); + check_rec_rules_wellscoped(rest, outer_depth, nlvls) } , + } } , + } + } + + fn peel_n_lams_collect(e: KernelTypes::KExpr, n: Field, peeled: Field, acc: Lists::List) + -> (KernelTypes::KExpr, Field, Lists::List) { + match n { + 0 => { (e, peeled, acc) } , + _ => { + match (*(e)) { + KernelTypes::KExprNode::Lam(dom, body) => { + peel_n_lams_collect(body, n - 1, peeled + 1, + (&(Lists::Node::Cons(dom, acc)))) } , + _ => { (e, peeled, acc) } , + } } , + } + } + + fn muts_has_kind(members: Lists::List, want_defn: Field) -> Field { + match (*(members)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(m, rest) => { + let hit = match m { + Ixon::MutConst::Defn(_) => { want_defn } , + Ixon::MutConst::Indc(_) => { 1 - want_defn } , + Ixon::MutConst::Recr(_) => { 0 } , + }; + match hit { + 1 => { 1 } , + _ => { muts_has_kind(rest, want_defn) } , + } } , + } + } + + fn check_block_member_kinds(block_addr: Bytes::AddressRef) -> () { + let c = Ingress::load_verified_constant(block_addr); + match c { + Ixon::Constant::Mk(info, _, _, _) => { + match info { + Ixon::ConstantInfo::Muts(members) => { + + assert_eq!(muts_has_kind(members, 1) * muts_has_kind(members, 0), 0, + "mutual block mixes a definition member with inductives"); + () } , + _ => { () } , + } } , + } + } + + fn check_const(rc: KernelRoles::RoleCtx, ci: KernelTypes::KConstantInfo, addr: Bytes::AddressRef) -> () { + let u = is_unsafe_ci(ci); + match ci { + KernelTypes::KConstantInfo::Axiom(nlvls, ty, _) => { + validate_expr_well_scoped(ty, 0, nlvls); + KernelInfer::k_ensure_sort(rc, ty, (&(Lists::Node::Nil))); + assert_safety(u, ty); + + match u { + 1 => { () } , + _ => { + match KernelRoles::axiom_standing(rc, addr) { + 0 => { + assert_eq!(0, 1, "an axiom that is not one of Lean's standard axioms"); + () } , + _ => { () } , + } } , + } } , + KernelTypes::KConstantInfo::Defn(nlvls, ty, val, _, _) => { + validate_expr_well_scoped(ty, 0, nlvls); + validate_expr_well_scoped(val, 0, nlvls); + KernelInfer::k_ensure_sort(rc, ty, (&(Lists::Node::Nil))); + assert_safety(u, ty); + assert_safety(u, val); + KernelInfer::k_check(rc, val, ty, (&(Lists::Node::Nil))) } , + KernelTypes::KConstantInfo::Thm(nlvls, ty, val) => { + validate_expr_well_scoped(ty, 0, nlvls); + validate_expr_well_scoped(val, 0, nlvls); + let lvl = KernelInfer::k_ensure_sort(rc, ty, (&(Lists::Node::Nil))); + assert_eq!(KernelLevels::level_equal(lvl, (&(KernelTypes::KLevelNode::Zero))), 1, + "theorem's type is not a Prop"); + assert_safety(u, ty); + assert_safety(u, val); + KernelInfer::k_check(rc, val, ty, (&(Lists::Node::Nil))) } , + KernelTypes::KConstantInfo::Opaque(nlvls, ty, val, _) => { + validate_expr_well_scoped(ty, 0, nlvls); + validate_expr_well_scoped(val, 0, nlvls); + KernelInfer::k_ensure_sort(rc, ty, (&(Lists::Node::Nil))); + assert_safety(u, ty); + assert_safety(u, val); + KernelInfer::k_check(rc, val, ty, (&(Lists::Node::Nil))) } , + KernelTypes::KConstantInfo::Quot(nlvls, ty, kind) => { + validate_expr_well_scoped(ty, 0, nlvls); + KernelInfer::k_ensure_sort(rc, ty, (&(Lists::Node::Nil))); + assert_safety(u, ty); + check_quot(rc, addr, kind) } , + KernelTypes::KConstantInfo::Induct(nlvls, ty, n_params, n_indices, num_ctors, + ind_is_unsafe, ind_block, ind_idx) => { + validate_expr_well_scoped(ty, 0, nlvls); + KernelInfer::k_ensure_sort(rc, ty, (&(Lists::Node::Nil))); + assert_safety(u, ty); + + check_block_member_kinds(ind_block); + + check_inductive_shape(rc, ty, n_params, n_indices, num_ctors, + nlvls, ind_block, ind_idx, + ind_is_unsafe); + check_block_peer_param_agreement(rc, ci, addr) } , + KernelTypes::KConstantInfo::Ctor(nlvls, ty, block_addr, ind_idx, _cidx, + num_params, num_fields, _) => { + validate_expr_well_scoped(ty, 0, nlvls); + KernelInfer::k_ensure_sort(rc, ty, (&(Lists::Node::Nil))); + assert_safety(u, ty); + let ind_ci = (*(ctor_parent_ind_ci(block_addr, ind_idx))); + match ind_ci { + KernelTypes::KConstantInfo::Induct(ind_nlvls, ind_ty, ind_n_params, + ind_n_indices, _, ind_is_unsafe, _, _) => { + assert_eq!(num_params, ind_n_params, + "ctor parameter count differs from its inductive's"); + check_param_agreement(rc, ind_ty, ty, ind_n_params); + check_ctor_return_type(ty, num_params, ind_n_indices, + num_fields, ind_nlvls, block_addr, + ind_idx); + let ind_level = get_result_sort_level(rc, ind_ty, + ind_n_params + ind_n_indices, (&(Lists::Node::Nil))); + check_field_universes(rc, ty, num_params, ind_level); + + match ind_is_unsafe { + 0 => { check_positivity(rc, ty, num_params, block_addr, + (&(Lists::Node::Nil))) } , + _ => { () } , + } } , + } } , + KernelTypes::KConstantInfo::Rec(nlvls, ty, _, _, _, _, _, _, _, rec_block, _) => { + validate_expr_well_scoped(ty, 0, nlvls); + KernelInfer::k_ensure_sort(rc, ty, (&(Lists::Node::Nil))); + assert_safety(u, ty); + check_block_member_kinds(rec_block); + check_recursor_member(rc, ci, addr) } , + } + } +} diff --git a/IxVM/IxVM/Modules/KernelClaim.aiur b/IxVM/IxVM/Modules/KernelClaim.aiur new file mode 100644 index 000000000..541e5b0af --- /dev/null +++ b/IxVM/IxVM/Modules/KernelClaim.aiur @@ -0,0 +1,1210 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module KernelClaim { + enum RevealRecursorRule { + Mk(UInt64::U64, UInt64::U64, Bytes::AddressRef) + } + + enum RevealConstructorInfo { + Mk(Options::Option, Options::Option, Options::Option, + Options::Option, Options::Option, Options::Option) + } + + enum RevealMutConstInfo { + Defn(Options::Option, Options::Option, + Options::Option, Options::Option, Options::Option), + Indc(Options::Option, + Options::Option, Options::Option, Options::Option, + Options::Option, + Options::Option>), + Recr(Options::Option, Options::Option, + Options::Option, Options::Option, Options::Option, + Options::Option, Options::Option, + Options::Option, Options::Option>) + } + + enum RevealConstantInfo { + Defn(Options::Option, Options::Option, + Options::Option, Options::Option, Options::Option), + Recr(Options::Option, Options::Option, + Options::Option, Options::Option, Options::Option, + Options::Option, Options::Option, + Options::Option, Options::Option>), + Axio(Options::Option, Options::Option, Options::Option), + Quot(Options::Option, Options::Option, Options::Option), + CPrj(Options::Option, Options::Option, Options::Option), + RPrj(Options::Option, Options::Option), + IPrj(Options::Option, Options::Option), + DPrj(Options::Option, Options::Option), + Muts(Lists::List<(UInt64::U64, RevealMutConstInfo)>) + } + + fn run_check(rc: KernelRoles::RoleCtx, addr: Bytes::AddressRef) -> () { + let ci = (*(Ingress::get_ci(addr))); + KernelCheck::check_const(rc, ci, addr) + } + + fn const_idxs_expr(e: &Ixon::Expr) -> Lists::List { + match (*(e)) { + + Ixon::Expr::Ref(i, _) => { + (&(Lists::Node::Cons(UInt64::to_field(i), (&(Lists::Node::Nil))))) } , + Ixon::Expr::Prj(i, _, inner) => { + (&(Lists::Node::Cons(UInt64::to_field(i), const_idxs_expr(inner)))) } , + Ixon::Expr::App(f, a) => { Lists::concat(const_idxs_expr(f), const_idxs_expr(a)) } , + Ixon::Expr::Lam(_, t, b) => { Lists::concat(const_idxs_expr(t), const_idxs_expr(b)) } , + Ixon::Expr::All(_, _, t, b) => { Lists::concat(const_idxs_expr(t), const_idxs_expr(b)) } , + Ixon::Expr::Let(_, t, v, b) => { + Lists::concat(const_idxs_expr(t), + Lists::concat(const_idxs_expr(v), const_idxs_expr(b))) } , + + _ => { (&(Lists::Node::Nil)) } , + } + } + + fn const_idxs_exprs(es: Lists::List<&Ixon::Expr>) -> Lists::List { + match (*(es)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(e, rest) => { + Lists::concat(const_idxs_expr(e), const_idxs_exprs(rest)) } , + } + } + + fn const_idxs_rules(rs: Lists::List) -> Lists::List { + match (*(rs)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(r, rest) => { + match r { + Ixon::RecursorRule::Mk(_, rhs) => { + Lists::concat(const_idxs_expr(rhs), const_idxs_rules(rest)) } , + } } , + } + } + + fn const_idxs_ctors(cs: Lists::List) -> Lists::List { + match (*(cs)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(c, rest) => { + match c { + Ixon::Constructor::Mk(_, _, _, _, _, typ) => { + Lists::concat(const_idxs_expr(typ), const_idxs_ctors(rest)) } , + } } , + } + } + + fn const_idxs_muts(ms: Lists::List) -> Lists::List { + match (*(ms)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(m, rest) => { + match m { + Ixon::MutConst::Defn(d) => { + match d { + Ixon::Definition::Mk(_, _, _, typ, value) => { + Lists::concat( + Lists::concat(const_idxs_expr(typ), const_idxs_expr(value)), + const_idxs_muts(rest)) } , + } } , + Ixon::MutConst::Indc(i) => { + match i { + Ixon::Inductive::Mk(_, _, _, _, typ, ctors) => { + Lists::concat( + Lists::concat(const_idxs_expr(typ), const_idxs_ctors(ctors)), + const_idxs_muts(rest)) } , + } } , + Ixon::MutConst::Recr(r) => { + match r { + Ixon::Recursor::Mk(_, _, _, _, _, _, _, typ, rules) => { + Lists::concat( + Lists::concat(const_idxs_expr(typ), const_idxs_rules(rules)), + const_idxs_muts(rest)) } , + } } , + } } , + } + } + + fn const_idxs_of(c: Ixon::Constant) -> Lists::List { + match c { + Ixon::Constant::Mk(info, sharing, _, _) => { + let shared = const_idxs_exprs(sharing); + match info { + Ixon::ConstantInfo::Defn(d) => { + match d { + Ixon::Definition::Mk(_, _, _, typ, value) => { + Lists::concat(shared, + Lists::concat(const_idxs_expr(typ), const_idxs_expr(value))) } , + } } , + Ixon::ConstantInfo::Recr(r) => { + match r { + Ixon::Recursor::Mk(_, _, _, _, _, _, _, typ, rules) => { + Lists::concat(shared, + Lists::concat(const_idxs_expr(typ), const_idxs_rules(rules))) } , + } } , + Ixon::ConstantInfo::Axio(a) => { + match a { + Ixon::Axiom::Mk(_, _, typ) => { + Lists::concat(shared, const_idxs_expr(typ)) } , + } } , + Ixon::ConstantInfo::Quot(q) => { + match q { + Ixon::Quotient::Mk(_, _, typ) => { + Lists::concat(shared, const_idxs_expr(typ)) } , + } } , + Ixon::ConstantInfo::Muts(members) => { + Lists::concat(shared, const_idxs_muts(members)) } , + + _ => { shared } , + } } , + } + } + + fn g_list_has(xs: Lists::List, x: Field) -> Field { + match (*(xs)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(y, rest) => { + match y - x { + 0 => { 1 } , + _ => { g_list_has(rest, x) } , + } } , + } + } + + fn run_check_transitive(rc: KernelRoles::RoleCtx, addr: Bytes::AddressRef) -> () { + let c = Ingress::load_verified_constant(addr); + match c { + Ixon::Constant::Mk(info, _, refs, _) => { + match info { + Ixon::ConstantInfo::Muts(members) => { + check_muts_all(rc, addr, members, members, 0) } , + Ixon::ConstantInfo::DPrj(dprj) => { + match dprj { + Ixon::DefinitionProj::Mk(_, block_addr) => { + run_check(rc, addr); + run_check_transitive(rc, block_addr) } , + } } , + Ixon::ConstantInfo::IPrj(iprj) => { + match iprj { + Ixon::InductiveProj::Mk(_, block_addr) => { + run_check(rc, addr); + run_check_transitive(rc, block_addr) } , + } } , + Ixon::ConstantInfo::CPrj(cprj) => { + match cprj { + Ixon::ConstructorProj::Mk(_, _, block_addr) => { + run_check(rc, addr); + run_check_transitive(rc, block_addr) } , + } } , + Ixon::ConstantInfo::RPrj(rprj) => { + match rprj { + Ixon::RecursorProj::Mk(_, block_addr) => { + run_check(rc, addr); + run_check_transitive(rc, block_addr) } , + } } , + _ => { run_check(rc, addr) } , + }; + walk_refs_transitive(rc, refs, const_idxs_of(c), 0) } , + } + } + + fn walk_refs_transitive(rc: KernelRoles::RoleCtx, refs: Lists::List, consts: Lists::List, i: Field) -> () { + match (*(refs)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(a, rest) => { + match g_list_has(consts, i) { + 1 => { + KernelRoles::assert_ref_allowed(rc, a); + match KernelRoles::walk_covered(rc, a) { + 0 => { run_check_transitive(KernelRoles::walk_ctx(rc, a), a) } , + _ => { () } , + } } , + _ => { () } , + }; + walk_refs_transitive(rc, rest, consts, i + 1) } , + } + } + + fn check_muts_all(rc: KernelRoles::RoleCtx, block_addr: Bytes::AddressRef, all_members: Lists::List, + cur: Lists::List, pos: Field) -> () { + match (*(cur)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(m, rest) => { + check_muts_member_at(rc, block_addr, all_members, m, pos); + check_muts_all(rc, block_addr, all_members, rest, pos + 1) } , + } + } + + fn check_muts_member_at(rc: KernelRoles::RoleCtx, block_addr: Bytes::AddressRef, + all_members: Lists::List, + m: Ixon::MutConst, pos: Field) -> () { + let member_addr = Ingress::projection_addr(all_members, block_addr, pos); + let ci = (*(Ingress::get_ci(member_addr))); + KernelCheck::check_const(rc, ci, member_addr) + } + + fn leaf_hash(addr: Bytes::AddressRef) -> Bytes::AddressRef { + let tail = IxonSerialize::put_address(addr, (&(Lists::Node::Nil))); + let bytes = (&(Lists::Node::Cons(UInt8::BYTE_0, tail))); + Blake3::bytes_to_addr(bytes) + } + + fn node_hash(l: Bytes::AddressRef, r: Bytes::AddressRef) -> Bytes::AddressRef { + let tail = IxonSerialize::put_address(l, IxonSerialize::put_address(r, (&(Lists::Node::Nil)))); + let bytes = (&(Lists::Node::Cons(UInt8::BYTE_1, tail))); + Blake3::bytes_to_addr(bytes) + } + + fn parse_atree_body(stream: Bytes::Stream) -> (Bytes::AddressRef, Lists::List, Bytes::Stream) { + let (tag, s) = IxonDeserialize::read_byte(stream); + match UInt8::to_field(tag) { + 0 => { + let (addr, s2) = IxonDeserialize::get_address(s); + let h = leaf_hash(addr); + (h, (&(Lists::Node::Cons(addr, (&(Lists::Node::Nil))))), s2) } , + 1 => { + ((&([UInt8::BYTE_0; 32])), (&(Lists::Node::Nil)), s) } , + 2 => { + let (lh, ll, s2) = parse_atree_body(s); + let (rh, rl, s3) = parse_atree_body(s2); + let h = node_hash(lh, rh); + (h, Lists::concat(ll, rl), s3) } , + } + } + + fn load_assumption_tree(root: Bytes::AddressRef) -> Lists::List { + let raw = (*(root)); + let (idx, len) = IxVMCompat::io_get_info(1, raw); + + let bytes = IxByteStream::read_finite_byte_stream(1, idx, len); + + let (tag, s) = IxonDeserialize::read_byte(bytes); + assert_eq!(UInt8::to_field(tag), 226, "assumption tree: wrong TagN header"); + let (computed_root, leaves, rest) = parse_atree_body(s); + let Lists::Node::Nil = (*(rest)); + let computed_arr = (*(computed_root)); + + assert_eq!(Blake3::address_to_fields(computed_arr), Blake3::address_to_fields(raw), + "assumption tree: recomputed merkle root != requested root"); + leaves + } + + fn addr_set_build(leaves: Lists::List, acc: RBTreeMap::RBTreeMap) -> RBTreeMap::RBTreeMap { + match (*(leaves)) { + Lists::Node::Nil => { acc } , + Lists::Node::Cons(a, rest) => { + addr_set_build(rest, RBTreeMap::rbtree_map_insert(a, 1, acc)) } , + } + } + + fn addr_set_member(a: Bytes::AddressRef, tree: RBTreeMap::RBTreeMap) -> Field { + RBTreeMap::rbtree_map_lookup_or_default(a, tree, 0) + } + + fn env_walk(rc: KernelRoles::RoleCtx, addr: Bytes::AddressRef, owned: RBTreeMap::RBTreeMap, asm: RBTreeMap::RBTreeMap, + strict: Field) -> () { + + match addr_set_member(addr, asm) { + 1 => { + assert_eq!(Fields::is_zero(strict - 2), 0, + "Check: target is in the assumption set"); + () } , + _ => { + let next_strict = match strict { + 1 => { + assert_eq!(addr_set_member(addr, owned), 1, + "CheckEnv: walk reached a constant outside the owned set"); + 1 } , + _ => { 0 } , + }; + let c = Ingress::load_verified_constant(addr); + match c { + Ixon::Constant::Mk(info, _, refs, _) => { + match info { + Ixon::ConstantInfo::Muts(members) => { + check_muts_all(rc, addr, members, members, 0) } , + Ixon::ConstantInfo::DPrj(dprj) => { + match dprj { + Ixon::DefinitionProj::Mk(_, block_addr) => { + run_check(rc, addr); + env_walk(rc, block_addr, owned, asm, next_strict) } , + } } , + Ixon::ConstantInfo::IPrj(iprj) => { + match iprj { + Ixon::InductiveProj::Mk(_, block_addr) => { + run_check(rc, addr); + env_walk(rc, block_addr, owned, asm, next_strict) } , + } } , + Ixon::ConstantInfo::CPrj(cprj) => { + match cprj { + Ixon::ConstructorProj::Mk(_, _, block_addr) => { + run_check(rc, addr); + env_walk(rc, block_addr, owned, asm, next_strict) } , + } } , + Ixon::ConstantInfo::RPrj(rprj) => { + match rprj { + Ixon::RecursorProj::Mk(_, block_addr) => { + run_check(rc, addr); + env_walk(rc, block_addr, owned, asm, next_strict) } , + } } , + _ => { run_check(rc, addr) } , + }; + env_walk_refs(rc, refs, const_idxs_of(c), 0, owned, asm, next_strict) } , + } } , + } + } + + fn env_walk_refs(rc: KernelRoles::RoleCtx, refs: Lists::List, consts: Lists::List, i: Field, + owned: RBTreeMap::RBTreeMap, + asm: RBTreeMap::RBTreeMap, strict: Field) -> () { + match (*(refs)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(a, rest) => { + match g_list_has(consts, i) { + 1 => { + KernelRoles::assert_ref_allowed(rc, a); + match KernelRoles::walk_covered(rc, a) { + 0 => { env_walk(KernelRoles::walk_ctx(rc, a), a, owned, asm, strict) } , + _ => { () } , + } } , + _ => { () } , + }; + env_walk_refs(rc, rest, consts, i + 1, owned, asm, strict) } , + } + } + + fn env_walk_leaves(rc: KernelRoles::RoleCtx, leaves: Lists::List, owned: RBTreeMap::RBTreeMap, + asm: RBTreeMap::RBTreeMap) -> () { + match (*(leaves)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(a, rest) => { + + assert_eq!(addr_set_member(a, asm), 0, + "CheckEnv: owned constant is in the assumption set"); + env_walk(rc, a, owned, asm, 1); + env_walk_leaves(rc, rest, owned, asm) } , + } + } + + fn run_check_env(rc: KernelRoles::RoleCtx, env_root: Bytes::AddressRef, asm: Options::Option) -> () { + let owned = load_assumption_tree(env_root); + match (*(owned)) { + Lists::Node::Nil => { + assert_eq!(0, 1, "CheckEnv: owned tree has no leaves"); + () } , + Lists::Node::Cons(_, _) => { () } , + }; + match asm { + Options::Option::None => { + + match KernelRoles::role_ctx_axioms(rc) { + RBTreeMap::RBTreeMap::Nil => { walk_leaves_owned(rc, owned) } , + RBTreeMap::RBTreeMap::Node(_, _, _, _, _) => { walk_leaves_transitive(rc, owned) } , + } } , + Options::Option::Some(r) => { + let owned_set = addr_set_build(owned, RBTreeMap::RBTreeMap::Nil); + let asm_set = addr_set_build(load_assumption_tree(r), RBTreeMap::RBTreeMap::Nil); + env_walk_leaves(rc, owned, owned_set, asm_set) } , + } + } + + fn walk_leaves_transitive(rc: KernelRoles::RoleCtx, leaves: Lists::List) -> () { + match (*(leaves)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(a, rest) => { + run_check_transitive(rc, a); + walk_leaves_transitive(rc, rest) } , + } + } + + fn walk_leaves_owned(rc: KernelRoles::RoleCtx, leaves: Lists::List) -> () { + match (*(leaves)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(a, rest) => { + IxVMCompat::check_owned((*(KernelRoles::role_ctx_binding(rc))), KernelRoles::role_ctx_validator(rc), (*(a))); + walk_leaves_owned(rc, rest) } , + } + } + + fn env_walk_all(rc: KernelRoles::RoleCtx, addr: Bytes::AddressRef) -> () { + let c = Ingress::load_verified_constant(addr); + match c { + Ixon::Constant::Mk(info, _, refs, _) => { + match info { + Ixon::ConstantInfo::Muts(members) => { + check_muts_all(rc, addr, members, members, 0) } , + Ixon::ConstantInfo::DPrj(dprj) => { + match dprj { + Ixon::DefinitionProj::Mk(_, block_addr) => { + run_check(rc, addr); + IxVMCompat::check_owned((*(KernelRoles::role_ctx_binding(rc))), KernelRoles::role_ctx_validator(rc), (*(block_addr))) } , + } } , + Ixon::ConstantInfo::IPrj(iprj) => { + match iprj { + Ixon::InductiveProj::Mk(_, block_addr) => { + run_check(rc, addr); + IxVMCompat::check_owned((*(KernelRoles::role_ctx_binding(rc))), KernelRoles::role_ctx_validator(rc), (*(block_addr))) } , + } } , + Ixon::ConstantInfo::CPrj(cprj) => { + match cprj { + Ixon::ConstructorProj::Mk(_, _, block_addr) => { + run_check(rc, addr); + IxVMCompat::check_owned((*(KernelRoles::role_ctx_binding(rc))), KernelRoles::role_ctx_validator(rc), (*(block_addr))) } , + } } , + Ixon::ConstantInfo::RPrj(rprj) => { + match rprj { + Ixon::RecursorProj::Mk(_, block_addr) => { + run_check(rc, addr); + IxVMCompat::check_owned((*(KernelRoles::role_ctx_binding(rc))), KernelRoles::role_ctx_validator(rc), (*(block_addr))) } , + } } , + _ => { run_check(rc, addr) } , + }; + env_walk_refs_all(rc, refs, const_idxs_of(c), 0) } , + } + } + + fn env_walk_refs_all(rc: KernelRoles::RoleCtx, refs: Lists::List, consts: Lists::List, i: Field) -> () { + match (*(refs)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(a, rest) => { + match g_list_has(consts, i) { + 1 => { + KernelRoles::assert_ref_allowed(rc, a); + + match KernelRoles::walk_covered(rc, a) { + 0 => { + let wc = KernelRoles::walk_ctx(rc, a); + match KernelRoles::role_ctx_limit(wc) - KernelRoles::role_ctx_limit(rc) { + 0 => { IxVMCompat::check_owned((*(KernelRoles::role_ctx_binding(rc))), KernelRoles::role_ctx_validator(rc), + (*(a))) } , + _ => { run_check_transitive(wc, a) } , + } } , + _ => { () } , + } } , + _ => { () } , + }; + env_walk_refs_all(rc, rest, consts, i + 1) } , + } + } + + fn get_opt_addr(stream: Bytes::Stream) -> (Options::Option, Bytes::Stream) { + let (tag, s) = IxonDeserialize::read_byte(stream); + match UInt8::to_field(tag) { + 0 => { (Options::Option::None, s) } , + 1 => { + let (addr, s2) = IxonDeserialize::get_address(s); + (Options::Option::Some(addr), s2) } , + } + } + + fn get_claim_context(stream: Bytes::Stream) -> (Bytes::AddressRef, Options::Option, Bytes::Stream) { + let (spec, s) = IxonDeserialize::get_address(stream); + assert_eq!(Bytes::address_eq(spec, KernelRoleSpec::spec_digest()), 1, + "claim: specification digest is not this circuit's"); + let (binding, s2) = IxonDeserialize::get_address(s); + let (axioms, s3) = get_opt_addr(s2); + (binding, axioms, s3) + } + + fn get_opt_u64_masked(mb: Field, stream: Bytes::Stream) + -> (Options::Option, Bytes::Stream) { + match mb { + 0 => { (Options::Option::None, stream) } , + _ => { + let (n, s) = IxonDeserialize::get_tagn0(stream); + (Options::Option::Some(n), s) } , + } + } + + fn get_opt_addr_masked(mb: Field, stream: Bytes::Stream) + -> (Options::Option, Bytes::Stream) { + match mb { + 0 => { (Options::Option::None, stream) } , + _ => { + let (a, s) = IxonDeserialize::get_address(stream); + (Options::Option::Some(a), s) } , + } + } + + fn get_opt_bool_masked(mb: Field, stream: Bytes::Stream) + -> (Options::Option, Bytes::Stream) { + match mb { + 0 => { (Options::Option::None, stream) } , + _ => { + let (b, s) = IxonDeserialize::read_byte(stream); + (Options::Option::Some(UInt8::to_field(b)), s) } , + } + } + + fn get_opt_def_kind_masked(mb: Field, stream: Bytes::Stream) + -> (Options::Option, Bytes::Stream) { + match mb { + 0 => { (Options::Option::None, stream) } , + _ => { + let (b, s) = IxonDeserialize::read_byte(stream); + match UInt8::to_field(b) { + 0 => { (Options::Option::Some(Ixon::DefKind::Definition), s) } , + 1 => { (Options::Option::Some(Ixon::DefKind::Opaque), s) } , + 2 => { (Options::Option::Some(Ixon::DefKind::Theorem), s) } , + } } , + } + } + + fn get_opt_def_safety_masked(mb: Field, stream: Bytes::Stream) + -> (Options::Option, Bytes::Stream) { + match mb { + 0 => { (Options::Option::None, stream) } , + _ => { + let (b, s) = IxonDeserialize::read_byte(stream); + match UInt8::to_field(b) { + 0 => { (Options::Option::Some(Ixon::DefinitionSafety::Unsafe), s) } , + 1 => { (Options::Option::Some(Ixon::DefinitionSafety::Safe), s) } , + 2 => { (Options::Option::Some(Ixon::DefinitionSafety::Partial), s) } , + } } , + } + } + + fn get_opt_quot_kind_masked(mb: Field, stream: Bytes::Stream) + -> (Options::Option, Bytes::Stream) { + match mb { + 0 => { (Options::Option::None, stream) } , + _ => { + let (b, s) = IxonDeserialize::read_byte(stream); + match UInt8::to_field(b) { + 0 => { (Options::Option::Some(Ixon::QuotKind::Typ), s) } , + 1 => { (Options::Option::Some(Ixon::QuotKind::Ctor), s) } , + 2 => { (Options::Option::Some(Ixon::QuotKind::Lift), s) } , + 3 => { (Options::Option::Some(Ixon::QuotKind::Ind), s) } , + } } , + } + } + + fn get_reveal_rule(stream: Bytes::Stream) -> (RevealRecursorRule, Bytes::Stream) { + let (rule_idx, s) = IxonDeserialize::get_tagn0(stream); + let (fields, s) = IxonDeserialize::get_tagn0(s); + let (rhs, s) = IxonDeserialize::get_address(s); + (RevealRecursorRule::Mk(rule_idx, fields, rhs), s) + } + + fn get_reveal_rule_list_inner(stream: Bytes::Stream, count: UInt64::U64) + -> (Lists::List, Bytes::Stream) { + match UInt64::is_zero(count) { + 1 => { ((&(Lists::Node::Nil)), stream) } , + _ => { + let (rule, s) = get_reveal_rule(stream); + let (rest, s2) = get_reveal_rule_list_inner(s, UInt64::saturating_pred(count)); + ((&(Lists::Node::Cons(rule, rest))), s2) } , + } + } + + fn get_opt_rule_list_masked(mb: Field, stream: Bytes::Stream) + -> (Options::Option>, Bytes::Stream) { + match mb { + 0 => { (Options::Option::None, stream) } , + _ => { + let (count, s) = IxonDeserialize::get_tagn0(stream); + let (rules, s2) = get_reveal_rule_list_inner(s, count); + (Options::Option::Some(rules), s2) } , + } + } + + fn get_reveal_ctor_info(stream: Bytes::Stream) + -> (RevealConstructorInfo, Bytes::Stream) { + let (mask, s) = IxonDeserialize::get_tagn0(stream); + let mask_lo = UInt8::bit_decomposition(mask[0]); + let [b0, b1, b2, b3, b4, b5, _, _] = mask_lo; + let (is_unsafe, s) = get_opt_bool_masked(b0, s); + let (lvls, s) = get_opt_u64_masked(b1, s); + let (cidx, s) = get_opt_u64_masked(b2, s); + let (params, s) = get_opt_u64_masked(b3, s); + let (fields, s) = get_opt_u64_masked(b4, s); + let (typ, s) = get_opt_addr_masked(b5, s); + (RevealConstructorInfo::Mk(is_unsafe, lvls, cidx, params, fields, typ), s) + } + + fn get_ctor_entry(stream: Bytes::Stream) + -> ((UInt64::U64, RevealConstructorInfo), Bytes::Stream) { + let (idx, s) = IxonDeserialize::get_tagn0(stream); + let (info, s) = get_reveal_ctor_info(s); + ((idx, info), s) + } + + fn get_ctor_entry_list_inner(stream: Bytes::Stream, count: UInt64::U64) + -> (Lists::List<(UInt64::U64, RevealConstructorInfo)>, Bytes::Stream) { + match UInt64::is_zero(count) { + 1 => { ((&(Lists::Node::Nil)), stream) } , + _ => { + let (entry, s) = get_ctor_entry(stream); + let (rest, s2) = get_ctor_entry_list_inner(s, UInt64::saturating_pred(count)); + ((&(Lists::Node::Cons(entry, rest))), s2) } , + } + } + + fn get_opt_ctor_entry_list_masked(mb: Field, stream: Bytes::Stream) + -> (Options::Option>, Bytes::Stream) { + match mb { + 0 => { (Options::Option::None, stream) } , + _ => { + let (count, s) = IxonDeserialize::get_tagn0(stream); + let (list, s2) = get_ctor_entry_list_inner(s, count); + (Options::Option::Some(list), s2) } , + } + } + + fn get_reveal_mut_const_info(stream: Bytes::Stream) + -> (RevealMutConstInfo, Bytes::Stream) { + let (variant, s) = IxonDeserialize::read_byte(stream); + let (mask, s) = IxonDeserialize::get_tagn0(s); + let mask_lo = UInt8::bit_decomposition(mask[0]); + let [b0, b1, b2, b3, b4, b5, b6, b7] = mask_lo; + let mask_hi = UInt8::bit_decomposition(mask[1]); + let [b8, _, _, _, _, _, _, _] = mask_hi; + match UInt8::to_field(variant) { + 0 => { + let (kind, s) = get_opt_def_kind_masked(b0, s); + let (safety, s) = get_opt_def_safety_masked(b1, s); + let (lvls, s) = get_opt_u64_masked(b2, s); + let (typ, s) = get_opt_addr_masked(b3, s); + let (value, s) = get_opt_addr_masked(b4, s); + (RevealMutConstInfo::Defn(kind, safety, lvls, typ, value), s) } , + 1 => { + let (is_unsafe, s) = get_opt_bool_masked(b0, s); + let (lvls, s) = get_opt_u64_masked(b1, s); + let (params, s) = get_opt_u64_masked(b2, s); + let (indices, s) = get_opt_u64_masked(b3, s); + let (typ, s) = get_opt_addr_masked(b4, s); + let (ctors, s) = get_opt_ctor_entry_list_masked(b5, s); + (RevealMutConstInfo::Indc(is_unsafe, lvls, params, + indices, typ, ctors), s) } , + 2 => { + let (k, s) = get_opt_bool_masked(b0, s); + let (is_unsafe, s) = get_opt_bool_masked(b1, s); + let (lvls, s) = get_opt_u64_masked(b2, s); + let (params, s) = get_opt_u64_masked(b3, s); + let (indices, s) = get_opt_u64_masked(b4, s); + let (motives, s) = get_opt_u64_masked(b5, s); + let (minors, s) = get_opt_u64_masked(b6, s); + let (typ, s) = get_opt_addr_masked(b7, s); + let (rules, s) = get_opt_rule_list_masked(b8, s); + (RevealMutConstInfo::Recr(k, is_unsafe, lvls, params, indices, + motives, minors, typ, rules), s) } , + } + } + + fn get_mut_entry(stream: Bytes::Stream) + -> ((UInt64::U64, RevealMutConstInfo), Bytes::Stream) { + let (idx, s) = IxonDeserialize::get_tagn0(stream); + let (info, s) = get_reveal_mut_const_info(s); + ((idx, info), s) + } + + fn get_mut_entry_list_inner(stream: Bytes::Stream, count: UInt64::U64) + -> (Lists::List<(UInt64::U64, RevealMutConstInfo)>, Bytes::Stream) { + match UInt64::is_zero(count) { + 1 => { ((&(Lists::Node::Nil)), stream) } , + _ => { + let (entry, s) = get_mut_entry(stream); + let (rest, s2) = get_mut_entry_list_inner(s, UInt64::saturating_pred(count)); + ((&(Lists::Node::Cons(entry, rest))), s2) } , + } + } + + fn get_reveal_info(stream: Bytes::Stream) -> (RevealConstantInfo, Bytes::Stream) { + let (variant, s) = IxonDeserialize::read_byte(stream); + let (mask, s) = IxonDeserialize::get_tagn0(s); + let mask_lo = UInt8::bit_decomposition(mask[0]); + let [b0, b1, b2, b3, b4, b5, b6, b7] = mask_lo; + let mask_hi = UInt8::bit_decomposition(mask[1]); + let [b8, _, _, _, _, _, _, _] = mask_hi; + match UInt8::to_field(variant) { + 0 => { + let (kind, s) = get_opt_def_kind_masked(b0, s); + let (safety, s) = get_opt_def_safety_masked(b1, s); + let (lvls, s) = get_opt_u64_masked(b2, s); + let (typ, s) = get_opt_addr_masked(b3, s); + let (value, s) = get_opt_addr_masked(b4, s); + (RevealConstantInfo::Defn(kind, safety, lvls, typ, value), s) } , + 1 => { + let (k, s) = get_opt_bool_masked(b0, s); + let (is_unsafe, s) = get_opt_bool_masked(b1, s); + let (lvls, s) = get_opt_u64_masked(b2, s); + let (params, s) = get_opt_u64_masked(b3, s); + let (indices, s) = get_opt_u64_masked(b4, s); + let (motives, s) = get_opt_u64_masked(b5, s); + let (minors, s) = get_opt_u64_masked(b6, s); + let (typ, s) = get_opt_addr_masked(b7, s); + let (rules, s) = get_opt_rule_list_masked(b8, s); + (RevealConstantInfo::Recr(k, is_unsafe, lvls, params, indices, + motives, minors, typ, rules), s) } , + 2 => { + let (is_unsafe, s) = get_opt_bool_masked(b0, s); + let (lvls, s) = get_opt_u64_masked(b1, s); + let (typ, s) = get_opt_addr_masked(b2, s); + (RevealConstantInfo::Axio(is_unsafe, lvls, typ), s) } , + 3 => { + let (kind, s) = get_opt_quot_kind_masked(b0, s); + let (lvls, s) = get_opt_u64_masked(b1, s); + let (typ, s) = get_opt_addr_masked(b2, s); + (RevealConstantInfo::Quot(kind, lvls, typ), s) } , + 4 => { + let (idx, s) = get_opt_u64_masked(b0, s); + let (cidx, s) = get_opt_u64_masked(b1, s); + let (block, s) = get_opt_addr_masked(b2, s); + (RevealConstantInfo::CPrj(idx, cidx, block), s) } , + 5 => { + let (idx, s) = get_opt_u64_masked(b0, s); + let (block, s) = get_opt_addr_masked(b1, s); + (RevealConstantInfo::RPrj(idx, block), s) } , + 6 => { + let (idx, s) = get_opt_u64_masked(b0, s); + let (block, s) = get_opt_addr_masked(b1, s); + (RevealConstantInfo::IPrj(idx, block), s) } , + 7 => { + let (idx, s) = get_opt_u64_masked(b0, s); + let (block, s) = get_opt_addr_masked(b1, s); + (RevealConstantInfo::DPrj(idx, block), s) } , + 8 => { + let (components, s) = match b0 { + 0 => { ((&(Lists::Node::Nil)), s) } , + 1 => { + let (count, s2) = IxonDeserialize::get_tagn0(s); + get_mut_entry_list_inner(s2, count) } , + }; + (RevealConstantInfo::Muts(components), s) } , + } + } + + fn expr_addr(e_ref: &Ixon::Expr) -> Bytes::AddressRef { + let bytes = IxonSerialize::put_expr((*(e_ref)), (&(Lists::Node::Nil))); + Blake3::bytes_to_addr(bytes) + } + + fn def_kind_tag(k: Ixon::DefKind) -> Field { + match k { + Ixon::DefKind::Definition => { 0 } , + Ixon::DefKind::Opaque => { 1 } , + Ixon::DefKind::Theorem => { 2 } , + } + } + + fn def_safety_tag(s: Ixon::DefinitionSafety) -> Field { + match s { + Ixon::DefinitionSafety::Unsafe => { 0 } , + Ixon::DefinitionSafety::Safe => { 1 } , + Ixon::DefinitionSafety::Partial => { 2 } , + } + } + + fn quot_kind_tag(k: Ixon::QuotKind) -> Field { + match k { + Ixon::QuotKind::Typ => { 0 } , + Ixon::QuotKind::Ctor => { 1 } , + Ixon::QuotKind::Lift => { 2 } , + Ixon::QuotKind::Ind => { 3 } , + } + } + + fn check_opt_def_kind(real: Ixon::DefKind, opt: Options::Option) -> () { + match opt { + Options::Option::None => { () } , + Options::Option::Some(claimed) => { + assert_eq!(def_kind_tag(real), def_kind_tag(claimed), + "Reveal: claimed definition kind != real"); + () } , + } + } + + fn check_opt_def_safety(real: Ixon::DefinitionSafety, + opt: Options::Option) -> () { + match opt { + Options::Option::None => { () } , + Options::Option::Some(claimed) => { + assert_eq!(def_safety_tag(real), def_safety_tag(claimed), + "Reveal: claimed definition safety != real"); + () } , + } + } + + fn check_opt_quot_kind(real: Ixon::QuotKind, opt: Options::Option) -> () { + match opt { + Options::Option::None => { () } , + Options::Option::Some(claimed) => { + assert_eq!(quot_kind_tag(real), quot_kind_tag(claimed), + "Reveal: claimed quotient kind != real"); + () } , + } + } + + fn check_opt_bool(real: Field, opt: Options::Option) -> () { + match opt { + Options::Option::None => { () } , + Options::Option::Some(claimed) => { + assert_eq!(real, claimed, "Reveal: claimed flag != real"); + () } , + } + } + + fn check_opt_u64(real: UInt64::U64, opt: Options::Option) -> () { + match opt { + Options::Option::None => { () } , + Options::Option::Some(claimed) => { + assert_eq!(UInt64::eq(real, claimed), 1, "Reveal: claimed numeric field != real"); + () } , + } + } + + fn check_opt_addr(real: Bytes::AddressRef, opt: Options::Option) -> () { + match opt { + Options::Option::None => { () } , + Options::Option::Some(claimed) => { + assert_eq!(Bytes::address_eq(real, claimed), 1, + "Reveal: claimed address field != real"); + () } , + } + } + + fn check_opt_expr_addr(real_e: &Ixon::Expr, opt: Options::Option) -> () { + match opt { + Options::Option::None => { () } , + Options::Option::Some(claimed) => { + let computed = expr_addr(real_e); + assert_eq!(Bytes::address_eq(computed, claimed), 1, + "Reveal: claimed expr hash != hash of the real expr"); + () } , + } + } + + fn check_recr_rules(real: Lists::List, + claimed: Lists::List, + pos: UInt64::U64) -> () { + match (*(claimed)) { + Lists::Node::Nil => { + match (*(real)) { + Lists::Node::Nil => { () } , + } } , + Lists::Node::Cons(cr, rest_claimed) => { + match (*(real)) { + Lists::Node::Cons(rr, rest_real) => { + match cr { + RevealRecursorRule::Mk(c_idx, c_fields, c_rhs) => { + match rr { + Ixon::RecursorRule::Mk(r_fields, r_rhs) => { + assert_eq!(UInt64::eq(c_idx, pos), 1, + "Reveal: claimed recursor rule index != its position"); + assert_eq!(UInt64::eq(r_fields, c_fields), 1, + "Reveal: claimed recursor rule field count != real"); + check_opt_expr_addr(r_rhs, Options::Option::Some(c_rhs)); + check_recr_rules(rest_real, rest_claimed, + UInt64::wrapping_succ(pos)) } , + } } , + } } , + } } , + } + } + + fn check_opt_recr_rules(real: Lists::List, + opt: Options::Option>) -> () { + match opt { + Options::Option::None => { () } , + Options::Option::Some(claimed) => { + check_recr_rules(real, claimed, + [UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0]) } , + } + } + + fn check_ctor_entry(real_list: Lists::List, + idx: UInt64::U64, + info: RevealConstructorInfo) -> () { + let real_ctor = WordLists::lookup_u64(real_list, idx); + match info { + RevealConstructorInfo::Mk(opt_unsafe, opt_lvls, opt_cidx, + opt_params, opt_fields, opt_typ) => { + match real_ctor { + Ixon::Constructor::Mk(r_unsafe, r_lvls, r_cidx, r_params, r_fields, r_typ) => { + check_opt_bool(r_unsafe, opt_unsafe); + check_opt_u64(r_lvls, opt_lvls); + check_opt_u64(r_cidx, opt_cidx); + check_opt_u64(r_params, opt_params); + check_opt_u64(r_fields, opt_fields); + check_opt_expr_addr(r_typ, opt_typ) } , + } } , + } + } + + fn check_ctor_entries(real_list: Lists::List, + claimed: Lists::List<(UInt64::U64, RevealConstructorInfo)>) -> () { + match (*(claimed)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(entry, rest) => { + match entry { + (idx, info) => { + check_ctor_entry(real_list, idx, info); + check_ctor_entries(real_list, rest) } , + } } , + } + } + + fn check_opt_ctor_entries(real_list: Lists::List, + opt: Options::Option>) -> () { + match opt { + Options::Option::None => { () } , + Options::Option::Some(claimed) => { check_ctor_entries(real_list, claimed) } , + } + } + + fn check_mut_const(real: Ixon::MutConst, claimed: RevealMutConstInfo) -> () { + match real { + Ixon::MutConst::Defn(d) => { + match claimed { + RevealMutConstInfo::Defn(opt_kind, opt_safety, opt_lvls, + opt_typ, opt_value) => { + match d { + Ixon::Definition::Mk(r_kind, r_safety, r_lvls, r_typ, r_value) => { + check_opt_def_kind(r_kind, opt_kind); + check_opt_def_safety(r_safety, opt_safety); + check_opt_u64(r_lvls, opt_lvls); + check_opt_expr_addr(r_typ, opt_typ); + check_opt_expr_addr(r_value, opt_value) } , + } } , + } } , + Ixon::MutConst::Indc(i) => { + match claimed { + RevealMutConstInfo::Indc(opt_unsafe, opt_lvls, + opt_params, opt_indices, + opt_typ, opt_ctors) => { + match i { + Ixon::Inductive::Mk(r_unsafe, r_lvls, r_params, + r_indices, r_typ, r_ctors) => { + check_opt_bool(r_unsafe, opt_unsafe); + check_opt_u64(r_lvls, opt_lvls); + check_opt_u64(r_params, opt_params); + check_opt_u64(r_indices, opt_indices); + check_opt_expr_addr(r_typ, opt_typ); + check_opt_ctor_entries(r_ctors, opt_ctors) } , + } } , + } } , + Ixon::MutConst::Recr(r) => { + match claimed { + RevealMutConstInfo::Recr(opt_k, opt_unsafe, opt_lvls, opt_params, + opt_indices, opt_motives, opt_minors, + opt_typ, opt_rules) => { + match r { + Ixon::Recursor::Mk(r_k, r_unsafe, r_lvls, r_params, r_indices, + r_motives, r_minors, r_typ, r_rules) => { + check_opt_bool(r_k, opt_k); + check_opt_bool(r_unsafe, opt_unsafe); + check_opt_u64(r_lvls, opt_lvls); + check_opt_u64(r_params, opt_params); + check_opt_u64(r_indices, opt_indices); + check_opt_u64(r_motives, opt_motives); + check_opt_u64(r_minors, opt_minors); + check_opt_expr_addr(r_typ, opt_typ); + check_opt_recr_rules(r_rules, opt_rules) } , + } } , + } } , + } + } + + fn check_muts_components(real: Lists::List, + claimed: Lists::List<(UInt64::U64, RevealMutConstInfo)>) -> () { + match (*(claimed)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(entry, rest_claimed) => { + match entry { + (idx, info) => { + let real_mc = WordLists::lookup_u64(real, idx); + check_mut_const(real_mc, info); + check_muts_components(real, rest_claimed) } , + } } , + } + } + + fn run_reveal(comm_addr: Bytes::AddressRef, info: RevealConstantInfo) -> () { + let c = Ingress::load_verified_constant(comm_addr); + match c { + Ixon::Constant::Mk(ci, _, _, _) => { + match ci { + Ixon::ConstantInfo::Defn(d) => { + match info { + RevealConstantInfo::Defn(opt_kind, opt_safety, opt_lvls, + opt_typ, opt_value) => { + match d { + Ixon::Definition::Mk(r_kind, r_safety, r_lvls, r_typ, r_value) => { + check_opt_def_kind(r_kind, opt_kind); + check_opt_def_safety(r_safety, opt_safety); + check_opt_u64(r_lvls, opt_lvls); + check_opt_expr_addr(r_typ, opt_typ); + check_opt_expr_addr(r_value, opt_value) } , + } } , + } } , + Ixon::ConstantInfo::Recr(r) => { + match info { + RevealConstantInfo::Recr(opt_k, opt_unsafe, opt_lvls, opt_params, + opt_indices, opt_motives, opt_minors, + opt_typ, opt_rules) => { + match r { + Ixon::Recursor::Mk(r_k, r_unsafe, r_lvls, r_params, r_indices, + r_motives, r_minors, r_typ, r_rules) => { + check_opt_bool(r_k, opt_k); + check_opt_bool(r_unsafe, opt_unsafe); + check_opt_u64(r_lvls, opt_lvls); + check_opt_u64(r_params, opt_params); + check_opt_u64(r_indices, opt_indices); + check_opt_u64(r_motives, opt_motives); + check_opt_u64(r_minors, opt_minors); + check_opt_expr_addr(r_typ, opt_typ); + check_opt_recr_rules(r_rules, opt_rules) } , + } } , + } } , + Ixon::ConstantInfo::Axio(a) => { + match info { + RevealConstantInfo::Axio(opt_unsafe, opt_lvls, opt_typ) => { + match a { + Ixon::Axiom::Mk(r_unsafe, r_lvls, r_typ) => { + check_opt_bool(r_unsafe, opt_unsafe); + check_opt_u64(r_lvls, opt_lvls); + check_opt_expr_addr(r_typ, opt_typ) } , + } } , + } } , + Ixon::ConstantInfo::Quot(q) => { + match info { + RevealConstantInfo::Quot(opt_kind, opt_lvls, opt_typ) => { + match q { + Ixon::Quotient::Mk(r_kind, r_lvls, r_typ) => { + check_opt_quot_kind(r_kind, opt_kind); + check_opt_u64(r_lvls, opt_lvls); + check_opt_expr_addr(r_typ, opt_typ) } , + } } , + } } , + Ixon::ConstantInfo::CPrj(p) => { + match info { + RevealConstantInfo::CPrj(opt_idx, opt_cidx, opt_block) => { + match p { + Ixon::ConstructorProj::Mk(r_idx, r_cidx, r_block) => { + check_opt_u64(r_idx, opt_idx); + check_opt_u64(r_cidx, opt_cidx); + check_opt_addr(r_block, opt_block) } , + } } , + } } , + Ixon::ConstantInfo::RPrj(p) => { + match info { + RevealConstantInfo::RPrj(opt_idx, opt_block) => { + match p { + Ixon::RecursorProj::Mk(r_idx, r_block) => { + check_opt_u64(r_idx, opt_idx); + check_opt_addr(r_block, opt_block) } , + } } , + } } , + Ixon::ConstantInfo::IPrj(p) => { + match info { + RevealConstantInfo::IPrj(opt_idx, opt_block) => { + match p { + Ixon::InductiveProj::Mk(r_idx, r_block) => { + check_opt_u64(r_idx, opt_idx); + check_opt_addr(r_block, opt_block) } , + } } , + } } , + Ixon::ConstantInfo::DPrj(p) => { + match info { + RevealConstantInfo::DPrj(opt_idx, opt_block) => { + match p { + Ixon::DefinitionProj::Mk(r_idx, r_block) => { + check_opt_u64(r_idx, opt_idx); + check_opt_addr(r_block, opt_block) } , + } } , + } } , + Ixon::ConstantInfo::Muts(real_mc_list) => { + match info { + RevealConstantInfo::Muts(claimed_components) => { + check_muts_components(real_mc_list, claimed_components) } , + } } , + } } , + } + } + + fn run_contains(tree_root: Bytes::AddressRef, target: Bytes::AddressRef) -> () { + let leaves = load_assumption_tree(tree_root); + assert_eq!(KernelWhnf::se_addr_in(target, leaves), 1, + "Contains: target is not a leaf of the claimed tree"); + } + + fn run_claim(digest: [Field; 8]) -> () { + + let (idx, len) = hint::<(Field, Field)>("ixvm.io.claim", digest); + let bytes = IxByteStream::read_finite_byte_stream(0, idx, len); + + let h = Blake3::hash(bytes); + assert_eq!(Blake3::pack_digest(h), digest, + "claim: bytes do not hash to the public claim digest"); + + let (tag, s) = IxonDeserialize::get_tagn4(bytes); + let (flag, size) = tag; + assert_eq!(flag, 14, "claim: wrong TagN flag"); + + let [_, sz1, sz2, sz3, sz4, sz5, sz6, sz7] = size; + assert_eq!(((((((UInt8::to_field(sz1) + UInt8::to_field(sz2)) + UInt8::to_field(sz3)) + + UInt8::to_field(sz4)) + UInt8::to_field(sz5)) + UInt8::to_field(sz6)) + + UInt8::to_field(sz7)), 0, + "claim: TagN size exceeds a single byte"); + let variant = size[0]; + + let (format, s) = IxonDeserialize::read_byte(s); + assert_eq!(UInt8::to_field(format), 4, "claim: unsupported object format"); + let (validator, s) = IxonDeserialize::read_byte(s); + match UInt8::to_field(variant) { + 3 => { + assert_eq!(UInt8::to_field(validator), 3, "claim: wrong validator identity"); + let (binding, axioms, s) = get_claim_context(s); + let rc = KernelRoles::load_role_ctx(binding, 3, axioms); + let (input, s) = IxonDeserialize::get_address(s); + let (output, s) = IxonDeserialize::get_address(s); + let (asm, rest) = get_opt_addr(s); + let Lists::Node::Nil = (*(rest)); + KernelEval::run_eval(rc, input, output, asm) } , + 4 => { + + let (binding, axioms, s) = get_claim_context(s); + let rc = KernelRoles::load_role_ctx(binding, UInt8::to_field(validator), axioms); + let (target, s2) = IxonDeserialize::get_address(s); + let (asm, rest) = get_opt_addr(s2); + let Lists::Node::Nil = (*(rest)); + match asm { + Options::Option::None => { run_check_transitive(rc, target) } , + Options::Option::Some(r) => { + let asm_leaves = load_assumption_tree(r); + let asm_set = addr_set_build(asm_leaves, RBTreeMap::RBTreeMap::Nil); + + env_walk(rc, target, RBTreeMap::RBTreeMap::Nil, asm_set, 2) } , + } } , + 5 => { + let (binding, axioms, s) = get_claim_context(s); + let rc = KernelRoles::load_role_ctx(binding, UInt8::to_field(validator), axioms); + let (root, s2) = IxonDeserialize::get_address(s); + let (asm, rest) = get_opt_addr(s2); + let Lists::Node::Nil = (*(rest)); + run_check_env(rc, root, asm) } , + 6 => { + assert_eq!(UInt8::to_field(validator), 0, "claim: wrong validator identity"); + let (comm, s2) = IxonDeserialize::get_address(s); + let (info, rest) = get_reveal_info(s2); + let Lists::Node::Nil = (*(rest)); + run_reveal(comm, info) } , + 7 => { + assert_eq!(UInt8::to_field(validator), 0, "claim: wrong validator identity"); + let (tree, s2) = IxonDeserialize::get_address(s); + let (target, rest) = IxonDeserialize::get_address(s2); + let Lists::Node::Nil = (*(rest)); + run_contains(tree, target) } , + 9 => { + assert_eq!(UInt8::to_field(validator), 2, "claim: wrong resource validator identity"); + + assert_eq!(0, 1, "claim: resource-v1 is not implemented by IxVM"); + () } , + 10 => { + + assert_eq!(UInt8::to_field(validator), 3, "claim: wrong validator identity"); + let (spec, s2) = IxonDeserialize::get_address(s); + assert_eq!(Bytes::address_eq(spec, KernelRoleSpec::spec_digest()), 1, + "claim: specification digest is not this circuit's"); + let (binding, rest) = IxonDeserialize::get_address(s2); + let Lists::Node::Nil = (*(rest)); + KernelRoles::validate_binding(binding) } , + } + } +} diff --git a/IxVM/IxVM/Modules/KernelDefEq.aiur b/IxVM/IxVM/Modules/KernelDefEq.aiur new file mode 100644 index 000000000..ef80eca06 --- /dev/null +++ b/IxVM/IxVM/Modules/KernelDefEq.aiur @@ -0,0 +1,1043 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module KernelDefEq { + fn level_list_eq(a: Lists::List, b: Lists::List) -> Field { + match (*(a)) { + Lists::Node::Nil => { + match (*(b)) { + Lists::Node::Nil => { 1 } , + _ => { 0 } , + } } , + Lists::Node::Cons(x, xs) => { + match (*(b)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(y, ys) => { + match KernelLevels::level_equal(x, y) { + 0 => { 0 } , + _ => { level_list_eq(xs, ys) } , + } } , + } } , + } + } + + fn k_is_def_eq(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, types: Lists::List) -> Field { + let base = KernelSubst::lbr_max(KernelSubst::expr_lbr(a), KernelSubst::expr_lbr(b)); + match base { + 0 => { k_is_def_eq_core(rc, a, b, (&(Lists::Node::Nil))) } , + _ => { k_def_eq_rebase(rc, a, b, types, base) } , + } + } + + fn k_def_eq_rebase(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, types: Lists::List, + base: Field) -> Field { + + let g = KernelSubst::lbr_min(KernelSubst::lbr_min(KernelSubst::expr_glb(a, 0), KernelSubst::expr_glb(b, 0)), + Lists::length(types)); + match g { + 0 => { k_is_def_eq_core(rc, a, b, KernelSubst::ctx_trim(types, base)) } , + _ => { + k_is_def_eq_core(rc, KernelSubst::expr_lower(a, g, 0), KernelSubst::expr_lower(b, g, 0), + KernelSubst::ctx_trim(Lists::drop(types, g), base - g)) } , + } + } + + fn k_is_def_eq_core(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, types: Lists::List) -> Field { + k_is_def_eq_ordered(rc, a, b, types) + } + + fn k_is_def_eq_ordered(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, types: Lists::List) -> Field { + + match try_def_eq_app(rc, a, b, types) { + 1 => { 1 } , + _ => { k_is_def_eq_slow(rc, a, b, types) } , + } + } + + fn try_def_eq_app(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, types: Lists::List) -> Field { + match KernelTypes::collect_spine(a) { + (ah, aa) => { + match KernelTypes::collect_spine(b) { + (bh, bb) => { + match (*(ah)) { + KernelTypes::KExprNode::BVar(i) => { + match (*(bh)) { + KernelTypes::KExprNode::BVar(j) => { + match i - j { + 0 => { de_args(rc, aa, bb, types) } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + KernelTypes::KExprNode::Const(a_addr, al) => { + match (*(bh)) { + KernelTypes::KExprNode::Const(b_addr, bl) => { + match (1 - Bytes::address_eq(a_addr, b_addr)) { + 0 => { + match level_list_eq(al, bl) { + 0 => { 0 } , + _ => { + match Lists::length(aa) - Lists::length(bb) { + 0 => { de_args(rc, aa, bb, types) } , + _ => { 0 } , + } } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + } } , + } + } + + fn de_args(rc: KernelRoles::RoleCtx, aa: Lists::List, bb: Lists::List, types: Lists::List) -> Field { + match (*(aa)) { + Lists::Node::Nil => { + match (*(bb)) { + Lists::Node::Nil => { 1 } , + _ => { 0 } , + } } , + Lists::Node::Cons(a, ar) => { + match (*(bb)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(b, br) => { + match k_is_def_eq(rc, a, b, types) { + 0 => { 0 } , + _ => { de_args(rc, ar, br, types) } , + } } , + } } , + } + } + + fn is_nat_zero(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr) -> Field { + match (*(e)) { + KernelTypes::KExprNode::Lit(lit) => { + match lit { + KernelTypes::KLiteral::Nat(limbs) => { KernelKlimbs::klimbs_is_zero(limbs) } , + _ => { 0 } , + } } , + KernelTypes::KExprNode::Const(caddr, _) => { KernelRoles::role_is(rc, caddr, KernelRoleSpec::role_nat_zero()) } , + _ => { 0 } , + } + } + + fn nat_offset_of(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr) -> (Field, KernelTypes::KExpr, KernelTypes::KLimbs) { + match (*(e)) { + KernelTypes::KExprNode::Lit(lit) => { + match lit { + KernelTypes::KLiteral::Nat(n) => { (1, KernelNatPrim::mk_nat_lit((&(Lists::Node::Nil))), n) } , + _ => { (0, e, (&(Lists::Node::Nil))) } , + } } , + KernelTypes::KExprNode::App(f, a) => { + match (*(f)) { + KernelTypes::KExprNode::Const(caddr, _) => { + match KernelRoles::role_is(rc, caddr, KernelRoleSpec::role_nat_succ()) { + 1 => { + match nat_offset_of(rc, a) { + (_, base, o) => { (1, base, KernelKlimbs::klimbs_succ(o)) } , + } } , + _ => { (0, e, (&(Lists::Node::Nil))) } , + } } , + KernelTypes::KExprNode::App(g, x) => { + match (*(g)) { + KernelTypes::KExprNode::Const(caddr, _) => { + match KernelRoles::role_is(rc, caddr, KernelRoleSpec::role_nat_add()) { + 1 => { + match (*(a)) { + KernelTypes::KExprNode::Lit(alit) => { + match alit { + KernelTypes::KLiteral::Nat(m) => { + match nat_offset_of(rc, x) { + (1, base, o) => { (1, base, KernelKlimbs::klimbs_add(o, m)) } , + _ => { (1, x, m) } , + } } , + _ => { (0, e, (&(Lists::Node::Nil))) } , + } } , + _ => { (0, e, (&(Lists::Node::Nil))) } , + } } , + _ => { (0, e, (&(Lists::Node::Nil))) } , + } } , + _ => { (0, e, (&(Lists::Node::Nil))) } , + } } , + _ => { (0, e, (&(Lists::Node::Nil))) } , + } } , + _ => { (0, e, (&(Lists::Node::Nil))) } , + } + } + + fn try_def_eq_nat(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, types: Lists::List) -> (Field, Field) { + let za = is_nat_zero(rc, a); + let zb = is_nat_zero(rc, b); + match za * zb { + 1 => { (1, 1) } , + _ => { + match nat_offset_of(rc, a) { + (ma, ba, oa) => { + match nat_offset_of(rc, b) { + (mb, bb, ob) => { + match ma * mb { + 0 => { (0, 0) } , + _ => { + match KernelLevels::klimbs_eq(oa, ob) { + 0 => { (0, 0) } , + _ => { (1, k_is_def_eq(rc, ba, bb, types)) } , + } } , + } } , + } } , + } } , + } + } + + inline fn try_string_lit_pair(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, types: Lists::List) -> Field { + match try_string_lit_one(rc, a, b, types) { + 1 => { 1 } , + _ => { try_string_lit_one(rc, b, a, types) } , + } + } + + fn try_string_lit_one(rc: KernelRoles::RoleCtx, t: KernelTypes::KExpr, s: KernelTypes::KExpr, types: Lists::List) -> Field { + match (*(t)) { + KernelTypes::KExprNode::Lit(lit) => { + match lit { + KernelTypes::KLiteral::Str(bs) => { + k_is_def_eq(rc, KernelNatPrim::str_lit_delta_step(rc, KernelNatPrim::str_lit_to_ctor(rc, bs), types), + s, types) } , + _ => { 0 } , + } } , + _ => { 0 } , + } + } + + fn k_is_def_eq_slow(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, types: Lists::List) -> Field { + match try_string_lit_pair(rc, a, b, types) { + 1 => { 1 } , + _ => { k_is_def_eq_slow_nd(rc, a, b, types) } , + } + } + + fn k_is_def_eq_slow_nd(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, types: Lists::List) -> Field { + let a_core = KernelWhnf::whnf_struct_core(rc, a, types); + let b_core = KernelWhnf::whnf_struct_core(rc, b, types); + match k_is_def_eq_struct_safe(rc, a_core, b_core, types) { + 1 => { 1 } , + _ => { + match try_def_eq_app(rc, a_core, b_core, types) { + 1 => { 1 } , + _ => { k_is_def_eq_slow_nd_after_core(rc, a, b, a_core, b_core, types) } , + } } , + } + } + + fn k_is_def_eq_slow_nd_after_core(rc: KernelRoles::RoleCtx, orig_a: KernelTypes::KExpr, orig_b: KernelTypes::KExpr, + a: KernelTypes::KExpr, b: KernelTypes::KExpr, + types: Lists::List) -> Field { + let aw_nd = KernelWhnf::whnf_nd(rc, a, types); + let bw_nd = KernelWhnf::whnf_nd(rc, b, types); + match k_is_def_eq_struct_safe(rc, aw_nd, bw_nd, types) { + 1 => { 1 } , + _ => { + match try_def_eq_app(rc, aw_nd, bw_nd, types) { + 1 => { 1 } , + _ => { k_is_def_eq_slow2(rc, orig_a, orig_b, aw_nd, bw_nd, types) } , + } } , + } + } + + fn k_is_def_eq_struct_safe(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, types: Lists::List) -> Field { + match (*(a)) { + KernelTypes::KExprNode::BVar(i) => { + match (*(b)) { + KernelTypes::KExprNode::BVar(j) => { Fields::is_zero(i - j) } , + _ => { 0 } , + } } , + KernelTypes::KExprNode::Srt(la) => { + match (*(b)) { + KernelTypes::KExprNode::Srt(lb) => { KernelLevels::level_equal(la, lb) } , + _ => { 0 } , + } } , + KernelTypes::KExprNode::Lam(ty_a, body_a) => { + match (*(b)) { + KernelTypes::KExprNode::Lam(ty_b, body_b) => { + match k_is_def_eq(rc, ty_a, ty_b, types) { + 1 => { + let inner = (&(Lists::Node::Cons(ty_a, types))); + k_is_def_eq(rc, body_a, body_b, inner) } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + KernelTypes::KExprNode::Forall(ty_a, body_a) => { + match (*(b)) { + KernelTypes::KExprNode::Forall(ty_b, body_b) => { + match k_is_def_eq(rc, ty_a, ty_b, types) { + 1 => { + let inner = (&(Lists::Node::Cons(ty_a, types))); + k_is_def_eq(rc, body_a, body_b, inner) } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } + } + + fn k_is_def_eq_slow2(rc: KernelRoles::RoleCtx, orig_a: KernelTypes::KExpr, orig_b: KernelTypes::KExpr, + aw: KernelTypes::KExpr, bw: KernelTypes::KExpr, + types: Lists::List) -> Field { + match try_proof_irrel(rc, aw, bw, types) { + 1 => { 1 } , + _ => { + match try_unit_like(rc, aw, bw, types) { + 1 => { 1 } , + _ => { + match try_eta_struct(rc, aw, bw, types) { + 1 => { 1 } , + _ => { + match try_eta_struct(rc, bw, aw, types) { + 1 => { 1 } , + _ => { + match try_def_eq_nat(rc, aw, bw, types) { + (1, eq) => { eq } , + _ => { + match lazy_delta_loop(rc, aw, bw, 16, types) { + (1, _, _) => { 1 } , + (_, fa, fb) => { slow2_after_delta(rc, orig_a, orig_b, + fa, fb, types) } , + } } , + } } , + } } , + } } , + } } , + } + } + + fn slow2_after_delta(rc: KernelRoles::RoleCtx, orig_a: KernelTypes::KExpr, orig_b: KernelTypes::KExpr, + fa: KernelTypes::KExpr, fb: KernelTypes::KExpr, + types: Lists::List) -> Field { + match k_is_def_eq_struct_bounded(rc, fa, fb, 8, types) { + (1, _) => { 1 } , + _ => { match k_is_def_eq_structure_tree(rc, fa, fb, types) { + 1 => { 1 } , + _ => { slow2_eager_fallback(rc, orig_a, orig_b, types) } , + } } , + } + } + + fn try_same_proj_head_app(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, + types: Lists::List) -> Field { + let (ah, aa) = KernelTypes::collect_spine(a); + let (bh, ba) = KernelTypes::collect_spine(b); + match Lists::length(aa) { + 0 => { 0 } , + _ => { match Lists::length(aa) - Lists::length(ba) { + 0 => { match (*(ah)) { + KernelTypes::KExprNode::Proj(sa, ia, ea) => { match (*(bh)) { + KernelTypes::KExprNode::Proj(sb, ib, eb) => { + match Bytes::address_eq(sa, sb) { + 1 => { match ia - ib { + + 0 => { match k_is_def_eq(rc, ea, eb, types) { + 1 => { de_args(rc, aa, ba, types) } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + } + } + + fn k_is_def_eq_structure_tree(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, + types: Lists::List) -> Field { + match k_is_def_eq_struct_bounded(rc, a, b, 8, types) { + (1, _) => { 1 } , + _ => { match try_same_proj_head_app(rc, a, b, types) { + 1 => { 1 } , + _ => { k_is_def_eq_structure_tree_app(rc, a, b, types) } , + } } , + } + } + + fn k_is_def_eq_structure_tree_app(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, + types: Lists::List) -> Field { + match (*(a)) { + KernelTypes::KExprNode::App(af, ax) => { match (*(b)) { + KernelTypes::KExprNode::App(bf, bx) => { match k_is_def_eq_structure_tree(rc, af, bf, types) { + 1 => { k_is_def_eq_structure_tree(rc, ax, bx, types) } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } + } + + fn k_is_def_eq_struct_bounded(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, credit: Field, + types: Lists::List) -> (Field, Field) { + match (*(a)) { + KernelTypes::KExprNode::BVar(i) => { + match (*(b)) { + KernelTypes::KExprNode::BVar(j) => { + match i - j { 0 => { (1, credit) } , _ => { (0, credit) } , } } , + _ => { k_is_def_eq_struct_spend(rc, a, b, credit, types) } , + } } , + KernelTypes::KExprNode::Srt(la) => { + match (*(b)) { + KernelTypes::KExprNode::Srt(lb) => { (KernelLevels::level_equal(la, lb), credit) } , + _ => { k_is_def_eq_struct_spend(rc, a, b, credit, types) } , + } } , + KernelTypes::KExprNode::Const(addr_a, lvls_a) => { + match (*(b)) { + KernelTypes::KExprNode::Const(addr_b, lvls_b) => { + match Bytes::address_eq(addr_a, addr_b) { + 1 => { (level_list_eq(lvls_a, lvls_b), credit) } , + _ => { k_is_def_eq_struct_spend(rc, a, b, credit, types) } , + } } , + _ => { k_is_def_eq_struct_spend(rc, a, b, credit, types) } , + } } , + KernelTypes::KExprNode::App(fa, xa) => { + match (*(b)) { + KernelTypes::KExprNode::App(fb, xb) => { + match k_is_def_eq_struct_bounded(rc, fa, fb, credit, types) { + (1, rest) => { + k_is_def_eq_struct_bounded(rc, xa, xb, rest, types) } , + (_, rest) => { (0, rest) } , + } } , + _ => { k_is_def_eq_struct_spend(rc, a, b, credit, types) } , + } } , + KernelTypes::KExprNode::Lam(ta, ba) => { + match (*(b)) { + KernelTypes::KExprNode::Lam(tb, bb) => { + match k_is_def_eq_struct_bounded(rc, ta, tb, credit, types) { + (1, rest) => { + let types2 = (&(Lists::Node::Cons(ta, types))); + k_is_def_eq_struct_bounded(rc, ba, bb, rest, types2) } , + (_, rest) => { (0, rest) } , + } } , + _ => { k_is_def_eq_struct_spend(rc, a, b, credit, types) } , + } } , + KernelTypes::KExprNode::Forall(ta, ba) => { + match (*(b)) { + KernelTypes::KExprNode::Forall(tb, bb) => { + match k_is_def_eq_struct_bounded(rc, ta, tb, credit, types) { + (1, rest) => { + let types2 = (&(Lists::Node::Cons(ta, types))); + k_is_def_eq_struct_bounded(rc, ba, bb, rest, types2) } , + (_, rest) => { (0, rest) } , + } } , + _ => { k_is_def_eq_struct_spend(rc, a, b, credit, types) } , + } } , + KernelTypes::KExprNode::Lit(la) => { + match (*(b)) { + KernelTypes::KExprNode::Lit(lb) => { (KernelLevels::literal_eq(la, lb), credit) } , + _ => { k_is_def_eq_struct_spend(rc, a, b, credit, types) } , + } } , + KernelTypes::KExprNode::Proj(struct_a, fidx_a, ea) => { + match (*(b)) { + KernelTypes::KExprNode::Proj(struct_b, fidx_b, eb) => { + match Bytes::address_eq(struct_a, struct_b) { + 1 => { + match fidx_a - fidx_b { + 0 => { k_is_def_eq_struct_bounded(rc, ea, eb, credit, types) } , + _ => { (0, credit) } , + } } , + _ => { k_is_def_eq_struct_spend(rc, a, b, credit, types) } , + } } , + _ => { k_is_def_eq_struct_spend(rc, a, b, credit, types) } , + } } , + _ => { k_is_def_eq_struct_spend(rc, a, b, credit, types) } , + } + } + + fn k_is_def_eq_struct_spend(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, credit: Field, + types: Lists::List) -> (Field, Field) { + match credit { + 0 => { (0, 0) } , + _ => { + let rest = credit - 1; + let aw = KernelWhnf::whnf_nd(rc, a, types); + let bw = KernelWhnf::whnf_nd(rc, b, types); + match try_def_eq_nat(rc, aw, bw, types) { + (1, eq) => { (eq, rest) } , + _ => { + match lazy_delta_loop(rc, aw, bw, 8, types) { + (1, _, _) => { (1, rest) } , + (_, fa, fb) => { + k_is_def_eq_struct_bounded(rc, fa, fb, rest, types) } , + } } , + } } , + } + } + + fn slow2_eager_fallback(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, types: Lists::List) -> Field { + let aw = KernelWhnf::whnf(rc, a, types); + let bw = KernelWhnf::whnf(rc, b, types); + match try_proof_irrel(rc, aw, bw, types) { + 1 => { 1 } , + _ => { + match try_unit_like(rc, aw, bw, types) { + 1 => { 1 } , + _ => { + match try_eta_struct(rc, aw, bw, types) { + 1 => { 1 } , + _ => { + match try_eta_struct(rc, bw, aw, types) { + 1 => { 1 } , + _ => { + match try_def_eq_nat(rc, aw, bw, types) { + (1, eq) => { eq } , + _ => { + match try_eta_swap(rc, aw, bw, types) { + 1 => { 1 } , + _ => { k_is_def_eq_struct(rc, aw, bw, types) } , + } } , + } } , + } } , + } } , + } } , + } + } + + fn try_eta_struct(rc: KernelRoles::RoleCtx, t: KernelTypes::KExpr, s: KernelTypes::KExpr, types: Lists::List) -> Field { + match KernelTypes::collect_spine(s) { + (s_head, s_args) => { + match (*(s_head)) { + KernelTypes::KExprNode::Const(ctor_addr, _) => { + let ci = (*(Ingress::get_ci(ctor_addr))); + match ci { + KernelTypes::KConstantInfo::Ctor(_, _, ind_block_addr, ind_idx, _, nparams, nfields, _) => { + match Lists::length(s_args) - (nparams + nfields) { + 0 => { + let ind_ci = (*(Ingress::get_ci_iprj(ind_block_addr, ind_idx))); + match ind_ci { + KernelTypes::KConstantInfo::Induct(_, _, _, nindices, nctors, _, _, _) => { + let shape_ok = Fields::is_zero(nindices) * Fields::is_zero(nctors - 1); + match shape_ok { + 0 => { 0 } , + _ => { + let struct_addr = compute_iprj_addr(ind_block_addr, ind_idx); + + match KernelWhnf::struct_is_rec(struct_addr) { + 1 => { 0 } , + _ => { + + let t_ty = KernelInferOnly::k_infer_only(rc, t, types); + let s_ty = KernelInferOnly::k_infer_only(rc, s, types); + match k_is_def_eq(rc, t_ty, s_ty, types) { + 0 => { 0 } , + _ => { + compare_struct_fields(rc, struct_addr, nparams, + nfields, t, s_args, 0, types) } , + } } , + } } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + } + } + + fn compare_struct_fields(rc: KernelRoles::RoleCtx, struct_addr: Bytes::AddressRef, nparams: Field, nfields: Field, + t: KernelTypes::KExpr, s_args: Lists::List, i: Field, + types: Lists::List) -> Field { + match nfields - i { + 0 => { 1 } , + _ => { + let proj_expr = (&(KernelTypes::KExprNode::Proj(struct_addr, i, t))); + let s_field = Lists::lookup(s_args, nparams + i); + match k_is_def_eq(rc, proj_expr, s_field, types) { + 0 => { 0 } , + _ => { compare_struct_fields(rc, struct_addr, nparams, nfields, t, + s_args, i + 1, types) } , + } } , + } + } + + fn compute_iprj_addr(block_addr: Bytes::AddressRef, idx: Field) -> Bytes::AddressRef { + + let idx_u64 = UInt64::from_field(idx); + let info = Ixon::ConstantInfo::IPrj(Ixon::InductiveProj::Mk(idx_u64, block_addr)); + let proj_c = Ixon::Constant::Mk(info, + (&(Lists::Node::Nil)), + (&(Lists::Node::Nil)), + (&(Lists::Node::Nil))); + let bytes = IxonSerialize::put_constant(proj_c, (&(Lists::Node::Nil))); + Blake3::bytes_to_addr(bytes) + } + + fn try_eta_swap(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, types: Lists::List) -> Field { + match (*(a)) { + KernelTypes::KExprNode::Lam(ta, ba) => { + match (*(b)) { + KernelTypes::KExprNode::Lam(_, _) => { 0 } , + _ => { try_eta_expand(rc, ta, ba, b, types) } , + } } , + _ => { + match (*(b)) { + KernelTypes::KExprNode::Lam(tb, bb) => { try_eta_expand(rc, tb, bb, a, types) } , + _ => { 0 } , + } } , + } + } + + fn try_unit_like(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, types: Lists::List) -> Field { + let ta = KernelInferOnly::k_infer_only(rc, a, types); + let ta_w = KernelWhnf::whnf(rc, ta, types); + match is_unit_like_type(ta_w) { + 0 => { 0 } , + _ => { + let tb = KernelInferOnly::k_infer_only(rc, b, types); + k_is_def_eq(rc, ta, tb, types) } , + } + } + + fn is_unit_like_type(ty: KernelTypes::KExpr) -> Field { + match KernelTypes::collect_spine(ty) { + (head, _) => { + match (*(head)) { + KernelTypes::KExprNode::Const(addr, _) => { + let ci = (*(Ingress::get_ci(addr))); + match ci { + KernelTypes::KConstantInfo::Induct(_, _, _, n_indices, num_ctors, _, block, idx) => { + + match n_indices { + 0 => { + match num_ctors - 1 { + 0 => { + let cci = (*(Ingress::get_ci_cprj(block, idx, 0))); + match cci { + KernelTypes::KConstantInfo::Ctor(_, _, _, _, _, _, nfields, _) => { + match nfields { + 0 => { 1 } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + } + } + + fn try_proof_irrel(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, types: Lists::List) -> Field { + let a_ty = KernelInferOnly::k_infer_only(rc, a, types); + match is_prop_type(rc, a_ty, types) { + 0 => { 0 } , + _ => { + let b_ty = KernelInferOnly::k_infer_only(rc, b, types); + k_is_def_eq(rc, a_ty, b_ty, types) } , + } + } + + fn try_eta_expand(rc: KernelRoles::RoleCtx, ty_a: KernelTypes::KExpr, body_a: KernelTypes::KExpr, b: KernelTypes::KExpr, + types: Lists::List) -> Field { + let b_ty = KernelInferOnly::k_infer_only(rc, b, types); + let b_ty_w = KernelWhnf::whnf(rc, b_ty, types); + match (*(b_ty_w)) { + KernelTypes::KExprNode::Forall(dom_b, _) => { + match k_is_def_eq(rc, ty_a, dom_b, types) { + 0 => { 0 } , + _ => { + let b_lifted = KernelSubst::expr_lift(b, 1, 0); + let bvar0 = (&(KernelTypes::KExprNode::BVar(0))); + let b_app = (&(KernelTypes::KExprNode::App(b_lifted, bvar0))); + let inner = (&(Lists::Node::Cons(ty_a, types))); + k_is_def_eq(rc, body_a, b_app, inner) } , + } } , + _ => { 0 } , + } + } + + fn is_prop_type(rc: KernelRoles::RoleCtx, ty: KernelTypes::KExpr, types: Lists::List) -> Field { + let sort = KernelInferOnly::k_infer_only(rc, ty, types); + let sort_w = KernelWhnf::whnf(rc, sort, types); + match (*(sort_w)) { + KernelTypes::KExprNode::Srt(l) => { KernelLevels::level_equal(l, (&(KernelTypes::KLevelNode::Zero))) } , + _ => { 0 } , + } + } + + fn k_is_def_eq_struct(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, types: Lists::List) -> Field { + k_is_def_eq_struct_go(rc, a, b, types) + } + + fn k_is_def_eq_struct_go(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, types: Lists::List) -> Field { + match (*(a)) { + KernelTypes::KExprNode::BVar(i) => { + match (*(b)) { + KernelTypes::KExprNode::BVar(j) => { match i - j { 0 => { 1 } , _ => { 0 } , } } , + _ => { 0 } , + } } , + KernelTypes::KExprNode::Srt(la) => { + match (*(b)) { + KernelTypes::KExprNode::Srt(lb) => { KernelLevels::level_equal(la, lb) } , + _ => { 0 } , + } } , + KernelTypes::KExprNode::Const(addr_a, lvls_a) => { + match (*(b)) { + KernelTypes::KExprNode::Const(addr_b, lvls_b) => { + + match Bytes::address_eq(addr_a, addr_b) { + 1 => { level_list_eq(lvls_a, lvls_b) } , + _ => { try_lazy_delta_app(rc, a, b, types) } , + } } , + _ => { try_lazy_delta_app(rc, a, b, types) } , + } } , + KernelTypes::KExprNode::App(fa, xa) => { + match (*(b)) { + KernelTypes::KExprNode::App(fb, xb) => { + match k_is_def_eq(rc, fa, fb, types) { + 0 => { try_lazy_delta_app(rc, a, b, types) } , + _ => { + match k_is_def_eq(rc, xa, xb, types) { + 0 => { try_lazy_delta_app(rc, a, b, types) } , + _ => { 1 } , + } } , + } } , + _ => { try_lazy_delta_app(rc, a, b, types) } , + } } , + KernelTypes::KExprNode::Lam(ta, ba) => { + match (*(b)) { + KernelTypes::KExprNode::Lam(tb, bb) => { + match k_is_def_eq(rc, ta, tb, types) { + 0 => { 0 } , + _ => { + let types2 = (&(Lists::Node::Cons(ta, types))); + k_is_def_eq(rc, ba, bb, types2) } , + } } , + _ => { try_eta_expand(rc, ta, ba, b, types) } , + } } , + KernelTypes::KExprNode::Forall(ta, ba) => { + match (*(b)) { + KernelTypes::KExprNode::Forall(tb, bb) => { + match k_is_def_eq(rc, ta, tb, types) { + 0 => { 0 } , + _ => { + let types2 = (&(Lists::Node::Cons(ta, types))); + k_is_def_eq(rc, ba, bb, types2) } , + } } , + _ => { 0 } , + } } , + KernelTypes::KExprNode::Let(_, _, _) => { + + 0 } , + KernelTypes::KExprNode::Lit(la) => { + match (*(b)) { + + KernelTypes::KExprNode::Lit(lb) => { KernelLevels::literal_eq(la, lb) } , + _ => { + + match la { + KernelTypes::KLiteral::Nat(_) => { + k_is_def_eq_struct_go(rc, KernelWhnf::nat_lit_to_ctor_or_self(rc, a), b, types) } , + KernelTypes::KLiteral::Str(_) => { 0 } , + } } , + } } , + KernelTypes::KExprNode::Proj(struct_a, fidx_a, ea) => { + match (*(b)) { + KernelTypes::KExprNode::Proj(struct_b, fidx_b, eb) => { + + match Bytes::address_eq(struct_a, struct_b) { + 1 => { + match fidx_a - fidx_b { + 0 => { k_is_def_eq(rc, ea, eb, types) } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + } + } + + fn lazy_delta_loop(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, fuel: Field, + types: Lists::List) -> (Field, KernelTypes::KExpr, KernelTypes::KExpr) { + match fuel { + 0 => { (0, a, b) } , + _ => { + match try_def_eq_nat(rc, a, b, types) { + (1, eq) => { (eq, a, b) } , + _ => { + let (a_addr, a_is_const) = head_addr(a); + let (b_addr, b_is_const) = head_addr(b); + match a_is_const { + 1 => { + match b_is_const { + 1 => { + + lazy_delta_step_const_const(rc, a_addr, b_addr, a, b, + fuel, types) } , + _ => { lazy_delta_a_const_b_proj(rc, a_addr, a, b, fuel, types) } , + } } , + _ => { + match b_is_const { + 1 => { lazy_delta_b_const_a_proj(rc, b_addr, a, b, fuel, types) } , + _ => { + + lazy_delta_both_proj(rc, a, b, fuel, types) } , + } } , + } } , + } } , + } + } + + fn delta_rank(ci: KernelTypes::KConstantInfo) -> Field { + match ci { + KernelTypes::KConstantInfo::Defn(_, _, _, _, hint) => { hint } , + _ => { 0 } , + } + } + + fn lazy_delta_step_const_const(rc: KernelRoles::RoleCtx, a_addr: Bytes::AddressRef, b_addr: Bytes::AddressRef, a: KernelTypes::KExpr, + b: KernelTypes::KExpr, fuel: Field, + types: Lists::List) -> (Field, KernelTypes::KExpr, KernelTypes::KExpr) { + let a_ci = (*(Ingress::get_ci(a_addr))); + let b_ci = (*(Ingress::get_ci(b_addr))); + let ae = is_defn_or_thm(a_ci); + let be = is_defn_or_thm(b_ci); + match ae { + 0 => { + match be { + 0 => { (0, a, b) } , + _ => { unfold_b_and_loop(rc, a, b, fuel, types) } , + } } , + _ => { + match be { + 0 => { unfold_a_and_loop(rc, a, b, fuel, types) } , + _ => { + let ar = delta_rank(a_ci); + let br = delta_rank(b_ci); + match UInt32::less_than_fields(br, ar) { + 1 => { unfold_a_and_loop(rc, a, b, fuel, types) } , + _ => { + match UInt32::less_than_fields(ar, br) { + 1 => { unfold_b_and_loop(rc, a, b, fuel, types) } , + _ => { unfold_both_and_loop(rc, a, b, fuel, types) } , + } } , + } } , + } } , + } + } + + fn unfold_a_and_loop(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, fuel: Field, + types: Lists::List) -> (Field, KernelTypes::KExpr, KernelTypes::KExpr) { + match delta_unfold(a) { + (1, a2) => { + let aw = KernelWhnf::whnf_nd(rc, a2, types); + lazy_delta_loop(rc, aw, b, fuel - 1, types) } , + _ => { (0, a, b) } , + } + } + + fn unfold_b_and_loop(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, fuel: Field, + types: Lists::List) -> (Field, KernelTypes::KExpr, KernelTypes::KExpr) { + match delta_unfold(b) { + (1, b2) => { + let bw = KernelWhnf::whnf_nd(rc, b2, types); + lazy_delta_loop(rc, a, bw, fuel - 1, types) } , + _ => { (0, a, b) } , + } + } + + fn unfold_both_and_loop(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, fuel: Field, + types: Lists::List) -> (Field, KernelTypes::KExpr, KernelTypes::KExpr) { + match delta_unfold(a) { + (1, a2) => { + match delta_unfold(b) { + (1, b2) => { + let aw = KernelWhnf::whnf_nd(rc, a2, types); + let bw = KernelWhnf::whnf_nd(rc, b2, types); + lazy_delta_loop(rc, aw, bw, fuel - 1, types) } , + _ => { (0, a, b) } , + } } , + _ => { (0, a, b) } , + } + } + + fn lazy_delta_a_const_b_proj(rc: KernelRoles::RoleCtx, a_addr: Bytes::AddressRef, a: KernelTypes::KExpr, b: KernelTypes::KExpr, fuel: Field, + types: Lists::List) -> (Field, KernelTypes::KExpr, KernelTypes::KExpr) { + + match try_unfold_proj_app(rc, b, types) { + (1, b2) => { + lazy_delta_loop(rc, a, b2, fuel - 1, types) } , + _ => { + let a_ci = (*(Ingress::get_ci(a_addr))); + match is_defn_or_thm(a_ci) { + 0 => { (0, a, b) } , + _ => { + let au = try_unfold_head(rc, a, a_ci, types); + match au { + (1, aw) => { + lazy_delta_loop(rc, aw, b, fuel - 1, types) } , + _ => { (0, a, b) } , + } } , + } } , + } + } + + fn lazy_delta_b_const_a_proj(rc: KernelRoles::RoleCtx, b_addr: Bytes::AddressRef, a: KernelTypes::KExpr, b: KernelTypes::KExpr, fuel: Field, + types: Lists::List) -> (Field, KernelTypes::KExpr, KernelTypes::KExpr) { + match try_unfold_proj_app(rc, a, types) { + (1, a2) => { + lazy_delta_loop(rc, a2, b, fuel - 1, types) } , + _ => { + let b_ci = (*(Ingress::get_ci(b_addr))); + match is_defn_or_thm(b_ci) { + 0 => { (0, a, b) } , + _ => { + let bu = try_unfold_head(rc, b, b_ci, types); + match bu { + (1, bw) => { + lazy_delta_loop(rc, a, bw, fuel - 1, types) } , + _ => { (0, a, b) } , + } } , + } } , + } + } + + fn lazy_delta_both_proj(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, fuel: Field, + types: Lists::List) -> (Field, KernelTypes::KExpr, KernelTypes::KExpr) { + let ua = try_unfold_proj_app(rc, a, types); + let ub = try_unfold_proj_app(rc, b, types); + match ua { + (1, a2) => { + match ub { + (1, b2) => { + lazy_delta_loop(rc, a2, b2, fuel - 1, types) } , + _ => { + lazy_delta_loop(rc, a2, b, fuel - 1, types) } , + } } , + _ => { + match ub { + (1, b2) => { + lazy_delta_loop(rc, a, b2, fuel - 1, types) } , + _ => { (0, a, b) } , + } } , + } + } + + fn is_defn_or_thm(ci: KernelTypes::KConstantInfo) -> Field { + match ci { + KernelTypes::KConstantInfo::Defn(_, _, _, _, _) => { 1 } , + KernelTypes::KConstantInfo::Thm(_, _, _) => { 1 } , + _ => { 0 } , + } + } + + fn try_unfold_proj_app(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, types: Lists::List) -> (Field, KernelTypes::KExpr) { + match KernelTypes::collect_spine(e) { + (head, spine) => { + match (*(head)) { + KernelTypes::KExprNode::Proj(struct_addr, fidx, inner) => { + let reduced = KernelWhnf::whnf_nd(rc, e, types); + match KernelTypes::collect_spine(reduced) { + (reduced_head, _) => { + match (*(reduced_head)) { + KernelTypes::KExprNode::Proj(_, _, _) => { + match delta_unfold(inner) { + (1, inner2) => { + let new_head = (&(KernelTypes::KExprNode::Proj(struct_addr, fidx, inner2))); + (1, KernelWhnf::apply_spine(new_head, spine)) } , + _ => { (0, e) } , + } } , + _ => { (1, reduced) } , + } } , + } } , + _ => { (0, e) } , + } } , + } + } + + fn delta_unfold(e: KernelTypes::KExpr) -> (Field, KernelTypes::KExpr) { + match KernelTypes::collect_spine(e) { + (head, spine) => { + match (*(head)) { + KernelTypes::KExprNode::Const(addr, lvls) => { + let ci = (*(Ingress::get_ci(addr))); + match ci { + KernelTypes::KConstantInfo::Defn(_, _, value, _, _) => { + let body = KernelLevels::expr_inst_levels(value, lvls); + (1, KernelWhnf::apply_spine(body, spine)) } , + KernelTypes::KConstantInfo::Thm(_, _, value) => { + let body = KernelLevels::expr_inst_levels(value, lvls); + (1, KernelWhnf::apply_spine(body, spine)) } , + _ => { (0, e) } , + } } , + _ => { (0, e) } , + } } , + } + } + + fn try_lazy_delta_app(rc: KernelRoles::RoleCtx, a: KernelTypes::KExpr, b: KernelTypes::KExpr, types: Lists::List) -> Field { + let (a_addr, a_is_const) = head_addr(a); + let (b_addr, b_is_const) = head_addr(b); + match a_is_const { + 0 => { 0 } , + _ => { + match b_is_const { + 0 => { 0 } , + _ => { + let a_ci = (*(Ingress::get_ci(a_addr))); + let b_ci = (*(Ingress::get_ci(b_addr))); + let a_unfolded = try_unfold_head(rc, a, a_ci, types); + let b_unfolded = try_unfold_head(rc, b, b_ci, types); + match a_unfolded { + (1, aw) => { + match b_unfolded { + (1, bw) => { k_is_def_eq(rc, aw, bw, types) } , + _ => { k_is_def_eq(rc, aw, b, types) } , + } } , + (0, _) => { + match b_unfolded { + (1, bw) => { k_is_def_eq(rc, a, bw, types) } , + _ => { 0 } , + } } , + } } , + } } , + } + } + + fn head_addr(e: KernelTypes::KExpr) -> (Bytes::AddressRef, Field) { + match KernelTypes::collect_spine(e) { + (head, _) => { + match (*(head)) { + KernelTypes::KExprNode::Const(addr, _) => { (addr, 1) } , + _ => { ((&([UInt8::BYTE_0; 32])), 0) } , + } } , + } + } + + fn try_unfold_head(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, ci: KernelTypes::KConstantInfo, + types: Lists::List) -> (Field, KernelTypes::KExpr) { + match ci { + + KernelTypes::KConstantInfo::Defn(_, _, _, _, _) => { + match delta_unfold(e) { + (1, e2) => { (1, KernelWhnf::whnf_nd(rc, e2, types)) } , + _ => { (0, e) } , + } } , + KernelTypes::KConstantInfo::Thm(_, _, _) => { + match delta_unfold(e) { + (1, e2) => { (1, KernelWhnf::whnf_nd(rc, e2, types)) } , + _ => { (0, e) } , + } } , + _ => { (0, e) } , + } + } +} diff --git a/IxVM/IxVM/Modules/KernelEval.aiur b/IxVM/IxVM/Modules/KernelEval.aiur new file mode 100644 index 000000000..4a0bf19d0 --- /dev/null +++ b/IxVM/IxVM/Modules/KernelEval.aiur @@ -0,0 +1,66 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module KernelEval { + fn eval_nf(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, types: Lists::List) -> KernelTypes::KExpr { + let w = KernelWhnf::whnf(rc, e, types); + match (*(w)) { + KernelTypes::KExprNode::Lam(t, b) => { + let nt = eval_nf(rc, t, types); + (&(KernelTypes::KExprNode::Lam(nt, eval_nf(rc, b, (&(Lists::Node::Cons(t, types))))))) } , + KernelTypes::KExprNode::Forall(t, b) => { + let nt = eval_nf(rc, t, types); + (&(KernelTypes::KExprNode::Forall(nt, eval_nf(rc, b, (&(Lists::Node::Cons(t, types))))))) } , + _ => { eval_nf_spine(rc, w, types) } , + } + } + + fn eval_nf_spine(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, types: Lists::List) -> KernelTypes::KExpr { + match (*(e)) { + KernelTypes::KExprNode::App(f, a) => { + (&(KernelTypes::KExprNode::App(eval_nf_spine(rc, f, types), eval_nf(rc, a, types)))) } , + KernelTypes::KExprNode::Proj(addr, i, e) => { + (&(KernelTypes::KExprNode::Proj(addr, i, eval_nf(rc, e, types)))) } , + _ => { e } , + } + } + + fn eval_body(input: Bytes::AddressRef) -> (Field, KernelTypes::KExpr, KernelTypes::KExpr) { + let ci = (*(Ingress::get_ci(input))); + assert_eq!(KernelCheck::is_unsafe_ci(ci), 0, "Eval: unsafe or partial input"); + match ci { + KernelTypes::KConstantInfo::Defn(n, ty, value, _, _) => { (n, ty, value) } , + KernelTypes::KConstantInfo::Thm(n, ty, value) => { (n, ty, value) } , + KernelTypes::KConstantInfo::Opaque(n, ty, value, _) => { (n, ty, value) } , + } + } + + fn eval_output(output: Bytes::AddressRef, nlvls: Field, input_type: KernelTypes::KExpr) -> KernelTypes::KExpr { + let Ixon::Constant::Mk(info, sharing, refs, univs) = Ingress::load_verified_constant(output); + let Ixon::ConstantInfo::Defn(defn) = info; + let Ixon::Definition::Mk(kind, safety, lvls, ty, value) = defn; + assert_eq!(kind, Ixon::DefKind::Definition, "Eval: output must be a definition"); + assert_eq!(safety, Ixon::DefinitionSafety::Safe, "Eval: unsafe or partial output"); + assert_eq!(UInt64::to_field(lvls), nlvls, "Eval: universe parameter count mismatch"); + let no_recur = (&(Lists::Node::Nil)); + let output_type = Convert::convert_expr(ty, sharing, refs, no_recur, univs); + assert_eq!(KernelCheck::kexpr_struct_eq(output_type, input_type), 1, "Eval: output type does not match input"); + Convert::convert_expr(value, sharing, refs, no_recur, univs) + } + + fn run_eval(rc: KernelRoles::RoleCtx, input: Bytes::AddressRef, output: Bytes::AddressRef, asm: Options::Option) -> () { + + KernelClaim::run_check(rc, input); + match asm { + Options::Option::None => { KernelClaim::run_check_transitive(rc, input) } , + Options::Option::Some(r) => { + let asm_set = KernelClaim::addr_set_build(KernelClaim::load_assumption_tree(r), RBTreeMap::RBTreeMap::Nil); + assert_eq!(KernelClaim::addr_set_member(input, asm_set), 0, "Eval: input is an assumption"); + KernelClaim::env_walk(rc, input, RBTreeMap::RBTreeMap::Nil, asm_set, 0) } , + }; + let (nlvls, ty, body) = eval_body(input); + let expected = eval_output(output, nlvls, ty); + let result = eval_nf(rc, body, (&(Lists::Node::Nil))); + + assert_eq!(KernelCheck::kexpr_struct_eq(result, expected), 1, "Eval: result does not match output"); + () + } +} diff --git a/IxVM/IxVM/Modules/KernelInfer.aiur b/IxVM/IxVM/Modules/KernelInfer.aiur new file mode 100644 index 000000000..79fe14fcd --- /dev/null +++ b/IxVM/IxVM/Modules/KernelInfer.aiur @@ -0,0 +1,628 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module KernelInfer { + enum InferLetEnvNode { + Id(Lists::List, Field), + Local(KernelTypes::KExpr, Field, InferLetEnv), + Let(KernelTypes::KExpr, KernelTypes::KExpr, InferLetEnv, Field) + } + + type InferLetEnv = &InferLetEnvNode; + + fn types_lookup(types: Lists::List, i: Field) -> KernelTypes::KExpr { + let ty = Lists::lookup(types, i); + KernelSubst::expr_lift(ty, i + 1, 0) + } + + fn const_num_lvls(ci: KernelTypes::KConstantInfo) -> Field { + match ci { + KernelTypes::KConstantInfo::Axiom(n, _, _) => { n } , + KernelTypes::KConstantInfo::Defn(n, _, _, _, _) => { n } , + KernelTypes::KConstantInfo::Thm(n, _, _) => { n } , + KernelTypes::KConstantInfo::Opaque(n, _, _, _) => { n } , + KernelTypes::KConstantInfo::Quot(n, _, _) => { n } , + KernelTypes::KConstantInfo::Induct(n, _, _, _, _, _, _, _) => { n } , + KernelTypes::KConstantInfo::Ctor(n, _, _, _, _, _, _, _) => { n } , + KernelTypes::KConstantInfo::Rec(n, _, _, _, _, _, _, _, _, _, _) => { n } , + } + } + + fn const_type_of(ci: KernelTypes::KConstantInfo) -> KernelTypes::KExpr { + match ci { + KernelTypes::KConstantInfo::Axiom(_, ty, _) => { ty } , + KernelTypes::KConstantInfo::Defn(_, ty, _, _, _) => { ty } , + KernelTypes::KConstantInfo::Thm(_, ty, _) => { ty } , + KernelTypes::KConstantInfo::Opaque(_, ty, _, _) => { ty } , + KernelTypes::KConstantInfo::Quot(_, ty, _) => { ty } , + KernelTypes::KConstantInfo::Induct(_, ty, _, _, _, _, _, _) => { ty } , + KernelTypes::KConstantInfo::Ctor(_, ty, _, _, _, _, _, _) => { ty } , + KernelTypes::KConstantInfo::Rec(_, ty, _, _, _, _, _, _, _, _, _) => { ty } , + } + } + + fn k_infer(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, types: Lists::List) -> KernelTypes::KExpr { + let base = KernelSubst::expr_lbr(e); + match base { + 0 => { k_infer_core(rc, e, (&(Lists::Node::Nil))) } , + _ => { k_infer_rebase(rc, e, types, base) } , + } + } + + fn k_infer_rebase(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, types: Lists::List, base: Field) -> KernelTypes::KExpr { + let g = KernelSubst::lbr_min(KernelSubst::expr_glb(e, 0), Lists::length(types)); + match g { + 0 => { k_infer_core(rc, e, KernelSubst::ctx_trim(types, base)) } , + _ => { + let t = k_infer_core(rc, KernelSubst::expr_lower(e, g, 0), + KernelSubst::ctx_trim(Lists::drop(types, g), base - g)); + KernelSubst::expr_lift(t, g, 0) } , + } + } + + fn k_infer_core(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, types: Lists::List) -> KernelTypes::KExpr { + match (*(e)) { + KernelTypes::KExprNode::BVar(i) => { types_lookup(types, i) } , + + KernelTypes::KExprNode::Srt(l) => { + (&(KernelTypes::KExprNode::Srt(KernelLevels::level_reduce((&(KernelTypes::KLevelNode::Succ(l))))))) } , + + KernelTypes::KExprNode::Const(addr, lvls) => { + let ci = (*(Ingress::get_ci(addr))); + let expected = const_num_lvls(ci); + let given = Lists::length(lvls); + assert_eq!(given, expected, + "Const applied to wrong number of universe levels"); + let ty = const_type_of(ci); + KernelLevels::expr_inst_levels(ty, lvls) } , + + KernelTypes::KExprNode::App(_, _) => { + match KernelTypes::collect_spine(e) { + (head, args) => { + let head_ty = k_infer(rc, head, types); + k_infer_app_spine_loop(rc, head_ty, args, (&(Lists::Node::Nil)), types) } , + } } , + + KernelTypes::KExprNode::Lam(ty, body) => { + k_ensure_sort(rc, ty, types); + let types2 = (&(Lists::Node::Cons(ty, types))); + let body_ty = k_infer(rc, body, types2); + (&(KernelTypes::KExprNode::Forall(ty, body_ty))) } , + + KernelTypes::KExprNode::Forall(ty, body) => { + let u1 = k_ensure_sort(rc, ty, types); + let types2 = (&(Lists::Node::Cons(ty, types))); + let u2 = k_ensure_sort(rc, body, types2); + (&(KernelTypes::KExprNode::Srt(KernelLevels::level_imax(u1, u2)))) } , + + KernelTypes::KExprNode::Let(ty, val, body) => { k_infer_let_start(rc, ty, val, body, types) } , + + KernelTypes::KExprNode::Lit(lit) => { k_infer_lit(rc, lit) } , + KernelTypes::KExprNode::Proj(struct_addr, fidx, e1) => { + k_infer_proj(rc, struct_addr, fidx, e1, types) } , + } + } + + fn k_infer_let_start(rc: KernelRoles::RoleCtx, ty: KernelTypes::KExpr, val: KernelTypes::KExpr, body: KernelTypes::KExpr, + types: Lists::List) -> KernelTypes::KExpr { + k_ensure_sort(rc, ty, types); + k_check(rc, val, ty, types); + let depth = Lists::length(types); + let env = (&(InferLetEnvNode::Id(types, depth))); + k_infer_let_env(rc, body, (&(InferLetEnvNode::Let(ty, val, env, depth))), types, depth) + } + + inline fn infer_let_var_type(env: InferLetEnv, i: Field, + types: Lists::List, depth: Field) -> KernelTypes::KExpr { + let (ty, created) = infer_let_lookup_type(env, i); + KernelSubst::expr_lift(ty, depth - created, 0) + } + + fn infer_let_lookup_type(env: InferLetEnv, i: Field) -> (KernelTypes::KExpr, Field) { + match (*(env)) { + InferLetEnvNode::Id(types, origin) => { (types_lookup(types, i), origin) } , + InferLetEnvNode::Local(ty, introduced, outer) => { match i { + 0 => { (ty, introduced - 1) } , + _ => { infer_let_lookup_type(outer, i - 1) } , + } } , + InferLetEnvNode::Let(ty, _, outer, created) => { match i { + 0 => { (ty, created) } , + _ => { infer_let_lookup_type(outer, i - 1) } , + } } , + } + } + + inline fn infer_let_var_value(env: InferLetEnv, i: Field, depth: Field) -> KernelTypes::KExpr { + let (value, created) = infer_let_lookup_value(env, i); + KernelSubst::expr_lift(value, depth - created, 0) + } + + fn infer_let_lookup_value(env: InferLetEnv, i: Field) -> (KernelTypes::KExpr, Field) { + match (*(env)) { + InferLetEnvNode::Id(_, origin) => { ((&(KernelTypes::KExprNode::BVar(i))), origin) } , + InferLetEnvNode::Local(_, introduced, outer) => { match i { + 0 => { ((&(KernelTypes::KExprNode::BVar(0))), introduced) } , + _ => { infer_let_lookup_value(outer, i - 1) } , + } } , + InferLetEnvNode::Let(_, value, outer, created) => { match i { + 0 => { (infer_let_materialize(value, outer, created, 0), created) } , + _ => { infer_let_lookup_value(outer, i - 1) } , + } } , + } + } + + fn infer_let_materialize(e: KernelTypes::KExpr, env: InferLetEnv, depth: Field, cutoff: Field) -> KernelTypes::KExpr { + match UInt32::less_than_fields(cutoff, KernelSubst::expr_lbr(e)) { + 0 => { e } , + _ => { match (*(e)) { + KernelTypes::KExprNode::BVar(i) => { match UInt32::less_than_fields(i, cutoff) { + 1 => { e } , + _ => { KernelSubst::expr_lift(infer_let_var_value(env, i - cutoff, depth), cutoff, 0) } , + } } , + KernelTypes::KExprNode::App(f, a) => { (&(KernelTypes::KExprNode::App( + infer_let_materialize(f, env, depth, cutoff), infer_let_materialize(a, env, depth, cutoff)))) } , + KernelTypes::KExprNode::Lam(ty, body) => { (&(KernelTypes::KExprNode::Lam( + infer_let_materialize(ty, env, depth, cutoff), infer_let_materialize(body, env, depth, cutoff + 1)))) } , + KernelTypes::KExprNode::Forall(ty, body) => { (&(KernelTypes::KExprNode::Forall( + infer_let_materialize(ty, env, depth, cutoff), infer_let_materialize(body, env, depth, cutoff + 1)))) } , + KernelTypes::KExprNode::Let(ty, val, body) => { (&(KernelTypes::KExprNode::Let( + infer_let_materialize(ty, env, depth, cutoff), infer_let_materialize(val, env, depth, cutoff), + infer_let_materialize(body, env, depth, cutoff + 1)))) } , + KernelTypes::KExprNode::Proj(addr, i, val) => { (&(KernelTypes::KExprNode::Proj(addr, i, + infer_let_materialize(val, env, depth, cutoff)))) } , + _ => { e } , + } } , + } + } + + fn k_infer_let_env(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, env: InferLetEnv, types: Lists::List, depth: Field) -> KernelTypes::KExpr { + match KernelSubst::expr_lbr(e) { + 0 => { k_infer(rc, e, (&(Lists::Node::Nil))) } , + _ => { match (*(e)) { + + KernelTypes::KExprNode::App(_, _) => { match infer_let_local_cutoff(env) { + 0 => { k_infer_let_env_core(rc, e, env, types, depth) } , + cutoff => { match KernelSubst::has_bvar_in_range(e, 0, cutoff) { + 1 => { k_infer_let_env_core(rc, e, env, types, depth) } , + 0 => { k_infer_let_env_rebase(rc, e, env, types, depth) } , + } } , + } } , + _ => { k_infer_let_env_core(rc, e, env, types, depth) } , + } } , + } + } + + fn infer_let_local_cutoff(env: InferLetEnv) -> Field { + match (*(env)) { + InferLetEnvNode::Id(_, _) => { 0 } , + InferLetEnvNode::Local(_, _, _) => { 1 } , + InferLetEnvNode::Let(_, _, outer, _) => { match infer_let_local_cutoff(outer) { + 0 => { 0 } , + n => { n + 1 } , + } } , + } + } + + fn k_infer_let_env_rebase(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, env: InferLetEnv, + types: Lists::List, depth: Field) -> KernelTypes::KExpr { + let (outer, removed, locals) = infer_let_drop_unused(env, KernelSubst::expr_glb(e, 0)); + let subject = KernelSubst::expr_lower(e, removed, 0); + let context = Lists::drop(types, locals); + let ty = k_infer_let_env_core(rc, subject, outer, context, depth - locals); + KernelSubst::expr_lift(ty, locals, 0) + } + + fn infer_let_drop_unused(env: InferLetEnv, count: Field) -> (InferLetEnv, Field, Field) { + match count { + 0 => { (env, 0, 0) } , + _ => { match (*(env)) { + InferLetEnvNode::Let(_, _, outer, _) => { + let (rest, removed, locals) = infer_let_drop_unused(outer, count - 1); + (rest, removed + 1, locals) } , + InferLetEnvNode::Local(_, _, outer) => { + let (rest, removed, locals) = infer_let_drop_unused(outer, count - 1); + (rest, removed + 1, locals + 1) } , + _ => { (env, 0, 0) } , + } } , + } + } + + fn k_infer_let_env_core(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, env: InferLetEnv, + types: Lists::List, depth: Field) -> KernelTypes::KExpr { + match (*(e)) { + KernelTypes::KExprNode::BVar(i) => { infer_let_var_type(env, i, types, depth) } , + KernelTypes::KExprNode::Lam(ty, body) => { + let dom = infer_let_materialize(ty, env, depth, 0); + k_ensure_sort(rc, dom, types); + let inner_types = (&(Lists::Node::Cons(dom, types))); + let inner_env = (&(InferLetEnvNode::Local(dom, depth + 1, env))); + let body_ty = k_infer_let_env(rc, body, inner_env, inner_types, depth + 1); + (&(KernelTypes::KExprNode::Forall(dom, body_ty))) } , + KernelTypes::KExprNode::Forall(ty, body) => { + let dom = infer_let_materialize(ty, env, depth, 0); + let u1 = k_ensure_sort(rc, dom, types); + let inner_types = (&(Lists::Node::Cons(dom, types))); + let inner_env = (&(InferLetEnvNode::Local(dom, depth + 1, env))); + let bt = k_infer_let_env(rc, body, inner_env, inner_types, depth + 1); + let KernelTypes::KExprNode::Srt(u2) = (*(KernelWhnf::whnf(rc, bt, inner_types))); + (&(KernelTypes::KExprNode::Srt(KernelLevels::level_imax(u1, u2)))) } , + KernelTypes::KExprNode::Let(ty, val, body) => { + let dom = infer_let_materialize(ty, env, depth, 0); + k_ensure_sort(rc, dom, types); + let val_ty = k_infer_let_env(rc, val, env, types, depth); + assert_eq!(KernelDefEq::k_is_def_eq(rc, val_ty, dom, types), 1, "delayed let value type mismatch"); + k_infer_let_env(rc, body, (&(InferLetEnvNode::Let(dom, val, env, depth))), types, depth) } , + KernelTypes::KExprNode::App(f, a) => { + let ft = k_infer_let_env(rc, f, env, types, depth); + let KernelTypes::KExprNode::Forall(dom, cod) = (*(KernelWhnf::whnf(rc, ft, types))); + let arg_ty = k_infer_let_env(rc, a, env, types, depth); + assert_eq!(KernelDefEq::k_is_def_eq(rc, arg_ty, dom, types), 1, "delayed application type mismatch"); + match KernelSubst::has_bvar_in_range(cod, 0, 1) { + 0 => { KernelSubst::expr_lower(cod, 1, 1) } , + _ => { KernelSubst::expr_inst1(cod, infer_let_materialize(a, env, depth, 0), 0) } , + } } , + _ => { k_infer(rc, infer_let_materialize(e, env, depth, 0), types) } , + } + } + + fn k_infer_app_spine_loop(rc: KernelRoles::RoleCtx, t: KernelTypes::KExpr, args: Lists::List, + subs_rev: Lists::List, + types: Lists::List) -> KernelTypes::KExpr { + match (*(args)) { + Lists::Node::Nil => { + match Lists::length(subs_rev) { + 0 => { t } , + _ => { KernelSubst::expr_inst_many(t, subs_rev, 0) } , + } } , + Lists::Node::Cons(a, rest) => { + match (*(t)) { + KernelTypes::KExprNode::Forall(dom, cod) => { + let dom_subst = match Lists::length(subs_rev) { + 0 => { dom } , + _ => { KernelSubst::expr_inst_many(dom, subs_rev, 0) } , + }; + k_check(rc, a, dom_subst, types); + k_infer_app_spine_loop(rc, cod, rest, + (&(Lists::Node::Cons(a, subs_rev))), types) } , + _ => { + let t_concrete = match Lists::length(subs_rev) { + 0 => { t } , + _ => { KernelSubst::expr_inst_many(t, subs_rev, 0) } , + }; + let t_w = KernelWhnf::whnf(rc, t_concrete, types); + match (*(t_w)) { + KernelTypes::KExprNode::Forall(dom, cod) => { + k_check(rc, a, dom, types); + k_infer_app_spine_loop(rc, cod, rest, + (&(Lists::Node::Cons(a, (&(Lists::Node::Nil))))), types) } , + } } , + } } , + } + } + + fn k_infer_lit(rc: KernelRoles::RoleCtx, lit: KernelTypes::KLiteral) -> KernelTypes::KExpr { + match lit { + KernelTypes::KLiteral::Nat(_) => { (&(KernelTypes::KExprNode::Const(KernelRoles::role_addr(rc, KernelRoleSpec::role_nat()), (&(Lists::Node::Nil))))) } , + KernelTypes::KLiteral::Str(_) => { + (&(KernelTypes::KExprNode::Const(KernelRoles::role_used_implicitly(rc, KernelRoleSpec::role_string()), (&(Lists::Node::Nil))))) } , + } + } + + fn peel_params_subst(ty: KernelTypes::KExpr, args: Lists::List, n_params: Field) -> KernelTypes::KExpr { + match n_params { + 0 => { ty } , + _ => { + match (*(ty)) { + KernelTypes::KExprNode::Forall(_, body) => { + match (*(args)) { + Lists::Node::Cons(arg, rest) => { + let body_substed = KernelSubst::expr_inst1(body, arg, 0); + peel_params_subst(body_substed, rest, n_params - 1) } , + } } , + } } , + } + } + + fn is_inductive_prop(rc: KernelRoles::RoleCtx, ind_ty: KernelTypes::KExpr, lvls: Lists::List, n_skip: Field, + types: Lists::List) -> Field { + let ind_ty_inst = KernelLevels::expr_inst_levels(ind_ty, lvls); + let result = peel_n_alls_whnf(rc, ind_ty_inst, n_skip, types); + + match (*(result)) { + KernelTypes::KExprNode::Srt(l) => { KernelLevels::level_equal(l, (&(KernelTypes::KLevelNode::Zero))) } , + } + } + + fn peel_n_alls_whnf(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, n: Field, types: Lists::List) -> KernelTypes::KExpr { + match n { + 0 => { KernelWhnf::whnf(rc, e, types) } , + _ => { + let ew = KernelWhnf::whnf(rc, e, types); + match (*(ew)) { + KernelTypes::KExprNode::Forall(dom, body) => { + let t2 = (&(Lists::Node::Cons(dom, types))); + peel_n_alls_whnf(rc, body, n - 1, t2) } , + _ => { ew } , + } } , + } + } + + fn check_prop_field_if_prop(rc: KernelRoles::RoleCtx, is_prop: Field, dom: KernelTypes::KExpr, + types: Lists::List) -> () { + match is_prop { + 0 => { () } , + _ => { + let lvl = k_ensure_sort(rc, dom, types); + assert_eq!(KernelLevels::level_equal(lvl, (&(KernelTypes::KLevelNode::Zero))), 1, + "projection on a Prop structure: field is not a Prop"); + () } , + } + } + + fn check_no_dep_data_field_if_prop(rc: KernelRoles::RoleCtx, is_prop: Field, dom: KernelTypes::KExpr, body: KernelTypes::KExpr, + types: Lists::List) -> () { + match is_prop { + 0 => { () } , + _ => { + let lvl = k_ensure_sort(rc, dom, types); + match KernelLevels::level_equal(lvl, (&(KernelTypes::KLevelNode::Zero))) { + 1 => { () } , + _ => { + + assert_eq!(KernelSubst::expr_lbr(body), 0, + "projection on a Prop structure: later fields depend on a data field"); + () } , + } } , + } + } + + fn peel_field_loop(rc: KernelRoles::RoleCtx, ty: KernelTypes::KExpr, target: Field, current: Field, + struct_addr: Bytes::AddressRef, val: KernelTypes::KExpr, is_prop: Field, + types: Lists::List) -> KernelTypes::KExpr { + match (*(ty)) { + KernelTypes::KExprNode::Forall(dom, body) => { + match target - current { + 0 => { + check_prop_field_if_prop(rc, is_prop, dom, types); + dom } , + _ => { + check_no_dep_data_field_if_prop(rc, is_prop, dom, body, types); + let proj_expr = (&(KernelTypes::KExprNode::Proj(struct_addr, current, val))); + let body_substed = KernelSubst::expr_inst1(body, proj_expr, 0); + peel_field_loop(rc, body_substed, target, current + 1, + struct_addr, val, is_prop, types) } , + } } , + } + } + + fn k_infer_proj(rc: KernelRoles::RoleCtx, struct_addr: Bytes::AddressRef, fidx: Field, e1: KernelTypes::KExpr, + types: Lists::List) -> KernelTypes::KExpr { + let val_ty = k_infer(rc, e1, types); + let wty = KernelWhnf::whnf(rc, val_ty, types); + match KernelTypes::collect_spine(wty) { + (head, args) => { + match (*(head)) { + KernelTypes::KExprNode::Const(head_addr, lvls) => { + assert_eq!(Bytes::address_eq(head_addr, struct_addr), 1, + "projection's structure type differs from the value's head"); + let ind_ci = (*(Ingress::get_ci(head_addr))); + match ind_ci { + KernelTypes::KConstantInfo::Induct(_, ind_ty, n_params, n_indices, num_ctors, _, + block_addr, ind_idx) => { + + assert_eq!(num_ctors, 1, + "projection on an inductive with more than one constructor"); + let ctor_ci = (*(Ingress::get_ci_cprj(block_addr, ind_idx, 0))); + match ctor_ci { + KernelTypes::KConstantInfo::Ctor(_, ctor_ty, _, _, _, _, _, _) => { + let ctor_ty_inst = KernelLevels::expr_inst_levels(ctor_ty, lvls); + let after_params = peel_params_subst(ctor_ty_inst, args, n_params); + + let is_prop = is_inductive_prop(rc, ind_ty, lvls, + n_params + n_indices, types); + peel_field_loop(rc, after_params, fidx, 0, + struct_addr, e1, is_prop, types) } , + } } , + } } , + } } , + } + } + + fn k_ensure_sort(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, types: Lists::List) -> KernelTypes::KLevel { + let t = k_infer(rc, e, types); + let tw = KernelWhnf::whnf(rc, t, types); + match (*(tw)) { + KernelTypes::KExprNode::Srt(l) => { l } , + } + } + + fn k_check(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, expected: KernelTypes::KExpr, types: Lists::List) -> () { + let inferred = k_infer(rc, e, types); + let d = KernelDefEq::k_is_def_eq(rc, inferred, expected, types); + assert_eq!(d, 1, "inferred type is not def-eq to the expected type"); + } + + fn try_dec_dispatch(rc: KernelRoles::RoleCtx, head_addr: Bytes::AddressRef, op: Field, head_lvls: Lists::List, + spine: Lists::List, types: Lists::List) + -> (Field, KernelTypes::KExpr) { + match UInt32::less_than_fields(Lists::length(spine), 2) { + 1 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + match op { + 1 => { dec_rewrite_lt_to_le(rc, spine, types) } , + 2 => { dec_nat(rc, 1, head_addr, head_lvls, spine, types) } , + 3 => { dec_nat(rc, 0, head_addr, head_lvls, spine, types) } , + 4 => { dec_rewrite_int_lt_to_le(rc, spine, types) } , + 5 => { dec_int(rc, 1, head_addr, head_lvls, spine, types) } , + 6 => { dec_int(rc, 0, head_addr, head_lvls, spine, types) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + } + } + + fn dec_rewrite_lt_to_le(rc: KernelRoles::RoleCtx, spine: Lists::List, + types: Lists::List) -> (Field, KernelTypes::KExpr) { + let n_e = Lists::lookup(spine, 0); + let m_e = Lists::lookup(spine, 1); + let n_w = KernelWhnf::whnf(rc, n_e, types); + match KernelNatPrim::try_extract_nat(rc, n_w) { + (0, _) => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + (1, n_klimbs) => { + let succ_lit = KernelNatPrim::mk_nat_lit(KernelKlimbs::klimbs_succ(n_klimbs)); + let dec_le_head = (&(KernelTypes::KExprNode::Const( + KernelRoles::role_addr(rc, KernelRoleSpec::role_nat_dec_le()), (&(Lists::Node::Nil))))); + let app1 = (&(KernelTypes::KExprNode::App(dec_le_head, succ_lit))); + let app2 = (&(KernelTypes::KExprNode::App(app1, m_e))); + let post = Lists::drop(spine, 2); + (1, KernelWhnf::apply_spine(app2, post)) } , + } + } + + fn dec_nat(rc: KernelRoles::RoleCtx, is_le: Field, head_addr: Bytes::AddressRef, head_lvls: Lists::List, + spine: Lists::List, types: Lists::List) -> (Field, KernelTypes::KExpr) { + let n_e = Lists::lookup(spine, 0); + let m_e = Lists::lookup(spine, 1); + let n_w = KernelWhnf::whnf(rc, n_e, types); + let m_w = KernelWhnf::whnf(rc, m_e, types); + match KernelNatPrim::try_extract_nat(rc, n_w) { + (0, _) => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + (1, n_kl) => { + match KernelNatPrim::try_extract_nat(rc, m_w) { + (0, _) => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + (1, m_kl) => { + let verdict = match is_le { + 1 => { KernelKlimbs::klimbs_le(n_kl, m_kl) } , + _ => { KernelLevels::klimbs_eq(n_kl, m_kl) } , + }; + let prop = match is_le { + 1 => { + let le_c = (&(KernelTypes::KExprNode::Const(KernelRoles::role_used_implicitly(rc, KernelRoleSpec::role_nat_le()), + (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(le_c, n_e))), m_e))) } , + _ => { mk_eq1(rc, (&(KernelTypes::KExprNode::Const(KernelRoles::role_addr(rc, KernelRoleSpec::role_nat()), + (&(Lists::Node::Nil))))), n_e, m_e) } , + }; + let call = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App( + (&(KernelTypes::KExprNode::Const(head_addr, head_lvls))), n_e))), m_e))); + (1, KernelWhnf::apply_spine(dec_result(rc, verdict, prop, call), Lists::drop(spine, 2))) } , + } } , + } + } + + fn dec_rewrite_int_lt_to_le(rc: KernelRoles::RoleCtx, spine: Lists::List, + types: Lists::List) -> (Field, KernelTypes::KExpr) { + let a_e = Lists::lookup(spine, 0); + let b_e = Lists::lookup(spine, 1); + let a_w = KernelWhnf::whnf(rc, a_e, types); + match KernelNatPrim::try_extract_int_prim(rc, a_w) { + (0, _, _) => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + (1, sa, na) => { + let one = (&(Lists::Node::Cons([UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], + (&(Lists::Node::Nil))))); + let succ_a = KernelNatPrim::int_add_prim(rc, sa, na, 0, one); + let dec_le_head = (&(KernelTypes::KExprNode::Const( + KernelRoles::role_addr(rc, KernelRoleSpec::role_int_dec_le()), (&(Lists::Node::Nil))))); + let app2 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(dec_le_head, succ_a))), b_e))); + (1, KernelWhnf::apply_spine(app2, Lists::drop(spine, 2))) } , + } + } + + fn dec_int(rc: KernelRoles::RoleCtx, is_le: Field, head_addr: Bytes::AddressRef, head_lvls: Lists::List, + spine: Lists::List, types: Lists::List) -> (Field, KernelTypes::KExpr) { + let a_e = Lists::lookup(spine, 0); + let b_e = Lists::lookup(spine, 1); + let a_w = KernelWhnf::whnf(rc, a_e, types); + let b_w = KernelWhnf::whnf(rc, b_e, types); + match KernelNatPrim::try_extract_int_prim(rc, a_w) { + (0, _, _) => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + (1, sa, na) => { + match KernelNatPrim::try_extract_int_prim(rc, b_w) { + (0, _, _) => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + (1, sb, nb) => { + let verdict = match is_le { + 1 => { int_le_verdict(sa, na, sb, nb) } , + _ => { (1 - (sa - sb) * (sa - sb)) * KernelLevels::klimbs_eq(na, nb) } , + }; + let prop = match is_le { + 1 => { + let le_c = (&(KernelTypes::KExprNode::Const(KernelRoles::role_used_implicitly(rc, KernelRoleSpec::role_int_le()), + (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(le_c, a_e))), b_e))) } , + _ => { mk_eq1(rc, (&(KernelTypes::KExprNode::Const(KernelRoles::role_used_implicitly(rc, KernelRoleSpec::role_int()), + (&(Lists::Node::Nil))))), a_e, b_e) } , + }; + let call = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App( + (&(KernelTypes::KExprNode::Const(head_addr, head_lvls))), a_e))), b_e))); + (1, KernelWhnf::apply_spine(dec_result(rc, verdict, prop, call), Lists::drop(spine, 2))) } , + } } , + } + } + + fn int_le_verdict(sa: Field, na: KernelTypes::KLimbs, sb: Field, nb: KernelTypes::KLimbs) -> Field { + match sa { + 0 => { match sb { 0 => { KernelKlimbs::klimbs_le(na, nb) } , _ => { 0 } , } } , + _ => { match sb { 0 => { 1 } , _ => { KernelKlimbs::klimbs_le(nb, na) } , } } , + } + } + + fn mk_eq1(rc: KernelRoles::RoleCtx, ty: KernelTypes::KExpr, a: KernelTypes::KExpr, b: KernelTypes::KExpr) -> KernelTypes::KExpr { + let one_lvl = (&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))); + let eq_c = (&(KernelTypes::KExprNode::Const(KernelRoles::role_addr(rc, KernelRoleSpec::role_eq()), + (&(Lists::Node::Cons(one_lvl, (&(Lists::Node::Nil)))))))); + (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(eq_c, ty))), a))), b))) + } + + fn dec_result(rc: KernelRoles::RoleCtx, verdict: Field, prop: KernelTypes::KExpr, call: KernelTypes::KExpr) -> KernelTypes::KExpr { + let one_lvl = (&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))); + let eq_refl_c = (&(KernelTypes::KExprNode::Const(KernelRoles::role_addr(rc, KernelRoleSpec::role_eq_refl()), + (&(Lists::Node::Cons(one_lvl, (&(Lists::Node::Nil)))))))); + let bool_c = (&(KernelTypes::KExprNode::Const(KernelRoles::role_addr(rc, KernelRoleSpec::role_bool()), (&(Lists::Node::Nil))))); + let refl = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(eq_refl_c, bool_c))), KernelNatPrim::mk_bool(rc, verdict)))); + let of_decide = match verdict { + 1 => { KernelRoles::role_used_implicitly(rc, KernelRoleSpec::role_of_decide_eq_true()) } , + _ => { KernelRoles::role_used_implicitly(rc, KernelRoleSpec::role_of_decide_eq_false()) } , + }; + let ctor = match verdict { + 1 => { KernelRoles::role_used_implicitly(rc, KernelRoleSpec::role_decidable_is_true()) } , + _ => { KernelRoles::role_used_implicitly(rc, KernelRoleSpec::role_decidable_is_false()) } , + }; + let proof = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App( + (&(KernelTypes::KExprNode::Const(of_decide, (&(Lists::Node::Nil))))), prop))), call))), refl))); + (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App( + (&(KernelTypes::KExprNode::Const(ctor, (&(Lists::Node::Nil))))), prop))), proof))) + } + + fn try_str_dec_eq(rc: KernelRoles::RoleCtx, head_addr: Bytes::AddressRef, spine: Lists::List, + types: Lists::List) -> (Field, KernelTypes::KExpr) { + match UInt32::less_than_fields(Lists::length(spine), 2) { + 1 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + let a0 = Lists::lookup(spine, 0); + let a1 = Lists::lookup(spine, 1); + match (*(a0)) { + KernelTypes::KExprNode::Lit(la) => { + match la { + KernelTypes::KLiteral::Str(sa) => { + match (*(a1)) { + KernelTypes::KExprNode::Lit(lb) => { + match lb { + KernelTypes::KLiteral::Str(sb) => { + match KernelLevels::bytestream_eq(sa, sb) { + 0 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + let str_c = (&(KernelTypes::KExprNode::Const(KernelRoles::role_addr(rc, KernelRoleSpec::role_string()), + (&(Lists::Node::Nil))))); + let call = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App( + (&(KernelTypes::KExprNode::Const(head_addr, (&(Lists::Node::Nil))))), a0))), a1))); + (1, KernelWhnf::apply_spine(dec_result(rc, 1, mk_eq1(rc, str_c, a0, a1), call), + Lists::drop(spine, 2))) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + } + } +} diff --git a/IxVM/IxVM/Modules/KernelInferOnly.aiur b/IxVM/IxVM/Modules/KernelInferOnly.aiur new file mode 100644 index 000000000..a0f34f191 --- /dev/null +++ b/IxVM/IxVM/Modules/KernelInferOnly.aiur @@ -0,0 +1,157 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module KernelInferOnly { + inline fn io_types_lookup(types: Lists::List, i: Field) -> KernelTypes::KExpr { + let ty = Lists::lookup(types, i); + KernelSubst::expr_lift(ty, i + 1, 0) + } + + fn io_const_num_lvls(ci: KernelTypes::KConstantInfo) -> Field { + match ci { + KernelTypes::KConstantInfo::Axiom(n, _, _) => { n } , + KernelTypes::KConstantInfo::Defn(n, _, _, _, _) => { n } , + KernelTypes::KConstantInfo::Thm(n, _, _) => { n } , + KernelTypes::KConstantInfo::Opaque(n, _, _, _) => { n } , + KernelTypes::KConstantInfo::Quot(n, _, _) => { n } , + KernelTypes::KConstantInfo::Induct(n, _, _, _, _, _, _, _) => { n } , + KernelTypes::KConstantInfo::Ctor(n, _, _, _, _, _, _, _) => { n } , + KernelTypes::KConstantInfo::Rec(n, _, _, _, _, _, _, _, _, _, _) => { n } , + } + } + + fn io_const_type_of(ci: KernelTypes::KConstantInfo) -> KernelTypes::KExpr { + match ci { + KernelTypes::KConstantInfo::Axiom(_, ty, _) => { ty } , + KernelTypes::KConstantInfo::Defn(_, ty, _, _, _) => { ty } , + KernelTypes::KConstantInfo::Thm(_, ty, _) => { ty } , + KernelTypes::KConstantInfo::Opaque(_, ty, _, _) => { ty } , + KernelTypes::KConstantInfo::Quot(_, ty, _) => { ty } , + KernelTypes::KConstantInfo::Induct(_, ty, _, _, _, _, _, _) => { ty } , + KernelTypes::KConstantInfo::Ctor(_, ty, _, _, _, _, _, _) => { ty } , + KernelTypes::KConstantInfo::Rec(_, ty, _, _, _, _, _, _, _, _, _) => { ty } , + } + } + + fn k_infer_only(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, types: Lists::List) -> KernelTypes::KExpr { + k_infer_only_core(rc, e, KernelSubst::ctx_trim(types, KernelSubst::expr_lbr(e))) + } + + inline fn k_infer_only_core(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, types: Lists::List) -> KernelTypes::KExpr { + match (*(e)) { + KernelTypes::KExprNode::BVar(i) => { io_types_lookup(types, i) } , + + KernelTypes::KExprNode::Srt(l) => { + (&(KernelTypes::KExprNode::Srt(KernelLevels::level_reduce((&(KernelTypes::KLevelNode::Succ(l))))))) } , + + KernelTypes::KExprNode::Const(addr, lvls) => { + let ci = (*(Ingress::get_ci(addr))); + let expected = io_const_num_lvls(ci); + assert_eq!(Lists::length(lvls), expected, + "Const applied to wrong number of universe levels"); + let ty = io_const_type_of(ci); + KernelLevels::expr_inst_levels(ty, lvls) } , + + KernelTypes::KExprNode::App(f, a) => { + let f_ty = k_infer_only(rc, f, types); + match (*(f_ty)) { + KernelTypes::KExprNode::Forall(_, cod) => { KernelSubst::expr_inst1(cod, a, 0) } , + _ => { + let f_ty_whnf = KernelWhnf::whnf(rc, f_ty, types); + match (*(f_ty_whnf)) { + KernelTypes::KExprNode::Forall(_, cod) => { KernelSubst::expr_inst1(cod, a, 0) } , + } } , + } } , + + KernelTypes::KExprNode::Lam(ty, body) => { + let types2 = (&(Lists::Node::Cons(ty, types))); + let body_ty = k_infer_only(rc, body, types2); + (&(KernelTypes::KExprNode::Forall(ty, body_ty))) } , + + KernelTypes::KExprNode::Forall(ty, body) => { + let u1 = ensure_sort_only(rc, ty, types); + let types2 = (&(Lists::Node::Cons(ty, types))); + let u2 = ensure_sort_only(rc, body, types2); + (&(KernelTypes::KExprNode::Srt(KernelLevels::level_imax(u1, u2)))) } , + + KernelTypes::KExprNode::Let(_, val, body) => { + let body_substed = KernelSubst::expr_inst1(body, val, 0); + k_infer_only(rc, body_substed, types) } , + + KernelTypes::KExprNode::Lit(lit) => { + match lit { + KernelTypes::KLiteral::Nat(_) => { + (&(KernelTypes::KExprNode::Const(KernelRoles::role_addr(rc, KernelRoleSpec::role_nat()), (&(Lists::Node::Nil))))) } , + KernelTypes::KLiteral::Str(_) => { + (&(KernelTypes::KExprNode::Const(KernelRoles::role_used_implicitly(rc, KernelRoleSpec::role_string()), (&(Lists::Node::Nil))))) } , + } } , + + KernelTypes::KExprNode::Proj(struct_addr, fidx, e1) => { + let val_ty = k_infer_only(rc, e1, types); + let wty = KernelWhnf::whnf(rc, val_ty, types); + match KernelTypes::collect_spine(wty) { + (head, args) => { + match (*(head)) { + KernelTypes::KExprNode::Const(head_addr, lvls) => { + assert_eq!(Bytes::address_eq(head_addr, struct_addr), 1, + "projection's structure type differs from the value's head"); + let ind_ci = (*(Ingress::get_ci(head_addr))); + match ind_ci { + KernelTypes::KConstantInfo::Induct(_, _, n_params, _, num_ctors, _, + block_addr, ind_idx) => { + + assert_eq!(num_ctors, 1, + "projection on an inductive with more than one constructor"); + let ctor_ci = (*(Ingress::get_ci_cprj(block_addr, ind_idx, 0))); + match ctor_ci { + KernelTypes::KConstantInfo::Ctor(_, ctor_ty, _, _, _, _, _, _) => { + let ctor_ty_inst = KernelLevels::expr_inst_levels(ctor_ty, lvls); + let after_params = io_peel_params_subst(ctor_ty_inst, args, n_params); + io_peel_field_loop(after_params, fidx, 0, struct_addr, e1) } , + } } , + } } , + } } , + } } , + } + } + + fn ensure_sort_only(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, types: Lists::List) -> KernelTypes::KLevel { + let ty = k_infer_only(rc, e, types); + match (*(ty)) { + KernelTypes::KExprNode::Srt(l) => { l } , + _ => { + let ty_whnf = KernelWhnf::whnf(rc, ty, types); + match (*(ty_whnf)) { + KernelTypes::KExprNode::Srt(l) => { l } , + } } , + } + } + + fn io_peel_params_subst(ty: KernelTypes::KExpr, args: Lists::List, n_params: Field) -> KernelTypes::KExpr { + match n_params { + 0 => { ty } , + _ => { + match (*(ty)) { + KernelTypes::KExprNode::Forall(_, body) => { + match (*(args)) { + Lists::Node::Cons(arg, rest) => { + let body_substed = KernelSubst::expr_inst1(body, arg, 0); + io_peel_params_subst(body_substed, rest, n_params - 1) } , + } } , + } } , + } + } + + fn io_peel_field_loop(ty: KernelTypes::KExpr, target: Field, current: Field, + struct_addr: Bytes::AddressRef, val: KernelTypes::KExpr) -> KernelTypes::KExpr { + match (*(ty)) { + KernelTypes::KExprNode::Forall(dom, body) => { + match target - current { + 0 => { dom } , + _ => { + let proj_expr = (&(KernelTypes::KExprNode::Proj(struct_addr, current, val))); + let body_substed = KernelSubst::expr_inst1(body, proj_expr, 0); + io_peel_field_loop(body_substed, target, current + 1, + struct_addr, val) } , + } } , + } + } +} diff --git a/IxVM/IxVM/Modules/KernelKlimbs.aiur b/IxVM/IxVM/Modules/KernelKlimbs.aiur new file mode 100644 index 000000000..2dc5a2f74 --- /dev/null +++ b/IxVM/IxVM/Modules/KernelKlimbs.aiur @@ -0,0 +1,304 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module KernelKlimbs { + fn klimbs_succ(n: KernelTypes::KLimbs) -> KernelTypes::KLimbs { + match (*(n)) { + Lists::Node::Nil => { + (&(Lists::Node::Cons([UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))) } , + Lists::Node::Cons(limb, rest) => { + let pair = UInt64::add(limb, [UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0]); + match pair { + (sum, carry) => { + match UInt8::to_field(carry) { + 0 => { (&(Lists::Node::Cons(sum, rest))) } , + _ => { (&(Lists::Node::Cons(sum, klimbs_succ(rest)))) } , + } } , + } } , + } + } + + fn klimbs_add_carry(a: KernelTypes::KLimbs, b: KernelTypes::KLimbs, carry: Field) -> KernelTypes::KLimbs { + match (*(a)) { + Lists::Node::Nil => { + match carry { + 0 => { b } , + _ => { klimbs_succ(b) } , + } } , + Lists::Node::Cons(la, ra) => { + match (*(b)) { + Lists::Node::Nil => { + match carry { + 0 => { a } , + _ => { klimbs_succ(a) } , + } } , + Lists::Node::Cons(lb, rb) => { + let pair1 = UInt64::add(la, lb); + match pair1 { + (sum1, carry1) => { + let pair2 = UInt64::add(sum1, [UInt8::from_field(carry), UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0]); + match pair2 { + (sum2, carry2) => { + + let total_carry = UInt8::to_field(carry1) + UInt8::to_field(carry2); + (&(Lists::Node::Cons(sum2, klimbs_add_carry(ra, rb, total_carry)))) } , + } } , + } } , + } } , + } + } + + fn klimbs_add(a: KernelTypes::KLimbs, b: KernelTypes::KLimbs) -> KernelTypes::KLimbs { + klimbs_add_carry(a, b, 0) + } + + fn klimbs_sub_borrow(a: KernelTypes::KLimbs, b: KernelTypes::KLimbs, borrow: Field) -> (KernelTypes::KLimbs, Field) { + match (*(a)) { + Lists::Node::Nil => { + match (*(b)) { + Lists::Node::Nil => { + + ((&(Lists::Node::Nil)), borrow) } , + Lists::Node::Cons(_, _) => { + + match klimbs_is_zero(b) { + 1 => { ((&(Lists::Node::Nil)), borrow) } , + _ => { ((&(Lists::Node::Nil)), 1) } , + } } , + } } , + Lists::Node::Cons(la, ra) => { + match (*(b)) { + Lists::Node::Nil => { + + match borrow { + 0 => { (a, 0) } , + _ => { + let pair = UInt64::sub_with_borrow(la, [UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0]); + match pair { + (diff, br) => { + let pair2 = klimbs_sub_borrow(ra, (&(Lists::Node::Nil)), br); + match pair2 { + (rest_res, br2) => { + ((&(Lists::Node::Cons(diff, rest_res))), br2) } , + } } , + } } , + } } , + Lists::Node::Cons(lb, rb) => { + let pair1 = UInt64::sub_with_borrow(la, lb); + match pair1 { + (sum1, br1) => { + let pair2 = UInt64::sub_with_borrow(sum1, [UInt8::from_field(borrow), UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0]); + match pair2 { + (sum2, br2) => { + + let total = br1 + br2; + let rec_pair = klimbs_sub_borrow(ra, rb, total); + match rec_pair { + (rest_res, br_final) => { + ((&(Lists::Node::Cons(sum2, rest_res))), br_final) } , + } } , + } } , + } } , + } } , + } + } + + fn klimbs_normalize(n: KernelTypes::KLimbs) -> KernelTypes::KLimbs { + match (*(n)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(limb, rest) => { + let normalized_rest = klimbs_normalize(rest); + match (*(normalized_rest)) { + Lists::Node::Nil => { + match UInt64::is_zero(limb) { + 1 => { (&(Lists::Node::Nil)) } , + 0 => { (&(Lists::Node::Cons(limb, (&(Lists::Node::Nil))))) } , + } } , + _ => { (&(Lists::Node::Cons(limb, normalized_rest))) } , + } } , + } + } + + fn klimbs_sub(a: KernelTypes::KLimbs, b: KernelTypes::KLimbs) -> KernelTypes::KLimbs { + let pair = klimbs_sub_borrow(a, b, 0); + match pair { + (result, borrow) => { + match borrow { + 1 => { (&(Lists::Node::Nil)) } , + 0 => { klimbs_normalize(result) } , + } } , + } + } + + fn klimbs_le(a: KernelTypes::KLimbs, b: KernelTypes::KLimbs) -> Field { + let diff = klimbs_sub(a, b); + match (*(diff)) { + Lists::Node::Nil => { 1 } , + _ => { 0 } , + } + } + + fn klimbs_dec(a: KernelTypes::KLimbs) -> KernelTypes::KLimbs { + let one = (&(Lists::Node::Cons([UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))); + klimbs_sub(a, one) + } + + fn divmod_256(x: Field, q: Field) -> (Field, Field) { + match UInt32::less_than_fields(x, 256) { + 1 => { (x, q) } , + 0 => { divmod_256(x - 256, q + 1) } , + } + } + + fn klimbs_mul(a: KernelTypes::KLimbs, b: KernelTypes::KLimbs) -> KernelTypes::KLimbs { + klimbs_mul_outer(a, b, (&(Lists::Node::Nil)), 0) + } + + fn klimbs_mul_outer(a: KernelTypes::KLimbs, b: KernelTypes::KLimbs, acc: KernelTypes::KLimbs, shift: Field) -> KernelTypes::KLimbs { + match (*(a)) { + Lists::Node::Nil => { acc } , + Lists::Node::Cons(a_limb, rest) => { + let prod = klimbs_mul_single(a_limb, b, [UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0]); + let shifted = klimbs_shl_limbs(prod, shift); + let new_acc = klimbs_add(acc, shifted); + klimbs_mul_outer(rest, b, new_acc, shift + 1) } , + } + } + + fn klimbs_mul_single(a_limb: UInt64::U64, b: KernelTypes::KLimbs, carry: UInt64::U64) -> KernelTypes::KLimbs { + match (*(b)) { + Lists::Node::Nil => { + match UInt64::is_zero(carry) { + 1 => { (&(Lists::Node::Nil)) } , + 0 => { (&(Lists::Node::Cons(carry, (&(Lists::Node::Nil))))) } , + } } , + Lists::Node::Cons(b_limb, rest) => { + match UInt64::mul(a_limb, b_limb) { + (lo, hi) => { + match UInt64::add(lo, carry) { + (sum, carry_out) => { + + match UInt8::to_field(carry_out) { + 0 => { (&(Lists::Node::Cons(sum, + klimbs_mul_single(a_limb, rest, hi)))) } , + _ => { (&(Lists::Node::Cons(sum, + klimbs_mul_single(a_limb, rest, UInt64::wrapping_succ(hi))))) } , + } } , + } } , + } } , + } + } + + fn klimbs_shl_limbs(x: KernelTypes::KLimbs, shift: Field) -> KernelTypes::KLimbs { + match shift { + 0 => { x } , + _ => { + let prepended = (&(Lists::Node::Cons([UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], x))); + klimbs_shl_limbs(prepended, shift - 1) } , + } + } + + fn klimbs_is_zero(x: KernelTypes::KLimbs) -> Field { + match (*(klimbs_normalize(x))) { + Lists::Node::Nil => { 1 } , + _ => { 0 } , + } + } + + fn klimbs_div_mod(a: KernelTypes::KLimbs, b: KernelTypes::KLimbs) -> (KernelTypes::KLimbs, KernelTypes::KLimbs) { + let (q_hint, r_hint) = IxVMCompat::ordinary_div_mod(a, b); + + let q = klimbs_normalize(q_hint); + let r = klimbs_normalize(r_hint); + let qb = klimbs_mul(q, b); + let lhs = klimbs_normalize(klimbs_add(qb, r)); + let rhs = klimbs_normalize(a); + + assert_eq!(KernelLevels::klimbs_eq(lhs, rhs), 1, "div/mod hint: q*b + r != a"); + match klimbs_is_zero(b) { + 1 => { + + assert_eq!(klimbs_is_zero(q), 1, + "div/mod hint: division by zero must yield a zero quotient"); + (q, r) } , + 0 => { + + assert_eq!(klimbs_le(klimbs_succ(r), b), 1, + "div/mod hint: remainder is not less than the divisor"); + (q, r) } , + } + } + + fn klimbs_div(a: KernelTypes::KLimbs, b: KernelTypes::KLimbs) -> KernelTypes::KLimbs { + match klimbs_div_mod(a, b) { (q, _) => { q } , } + } + + fn klimbs_mod(a: KernelTypes::KLimbs, b: KernelTypes::KLimbs) -> KernelTypes::KLimbs { + match klimbs_div_mod(a, b) { (_, r) => { r } , } + } + + fn klimbs_gcd(a: KernelTypes::KLimbs, b: KernelTypes::KLimbs) -> KernelTypes::KLimbs { + match klimbs_is_zero(b) { + 1 => { a } , + 0 => { klimbs_gcd(b, klimbs_mod(a, b)) } , + } + } + + fn klimbs_pow(base: KernelTypes::KLimbs, exp: KernelTypes::KLimbs) -> KernelTypes::KLimbs { + match klimbs_is_zero(exp) { + 1 => { (&(Lists::Node::Cons([UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))) } , + 0 => { + let two = (&(Lists::Node::Cons([UInt8::BYTE_2, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))); + let (half, r) = klimbs_div_mod(exp, two); + let sq = klimbs_pow(klimbs_normalize(klimbs_mul(base, base)), klimbs_normalize(half)); + match klimbs_is_zero(r) { + 1 => { sq } , + 0 => { klimbs_mul(base, sq) } , + } } , + } + } + + fn klimbs_land(a: KernelTypes::KLimbs, b: KernelTypes::KLimbs) -> KernelTypes::KLimbs { + match (*(a)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(la, ra) => { + match (*(b)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(lb, rb) => { + (&(Lists::Node::Cons(UInt64::and(la, lb), klimbs_land(ra, rb)))) } , + } } , + } + } + + fn klimbs_lor(a: KernelTypes::KLimbs, b: KernelTypes::KLimbs) -> KernelTypes::KLimbs { + match (*(a)) { + Lists::Node::Nil => { b } , + Lists::Node::Cons(la, ra) => { + match (*(b)) { + Lists::Node::Nil => { a } , + Lists::Node::Cons(lb, rb) => { + (&(Lists::Node::Cons(UInt64::or(la, lb), klimbs_lor(ra, rb)))) } , + } } , + } + } + + fn klimbs_xor_op(a: KernelTypes::KLimbs, b: KernelTypes::KLimbs) -> KernelTypes::KLimbs { + match (*(a)) { + Lists::Node::Nil => { b } , + Lists::Node::Cons(la, ra) => { + match (*(b)) { + Lists::Node::Nil => { a } , + Lists::Node::Cons(lb, rb) => { + (&(Lists::Node::Cons(UInt64::xor(la, lb), klimbs_xor_op(ra, rb)))) } , + } } , + } + } + + fn klimbs_shl(a: KernelTypes::KLimbs, n: KernelTypes::KLimbs) -> KernelTypes::KLimbs { + let two = (&(Lists::Node::Cons([UInt8::BYTE_2, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))); + klimbs_mul(a, klimbs_pow(two, n)) + } + + fn klimbs_shr(a: KernelTypes::KLimbs, n: KernelTypes::KLimbs) -> KernelTypes::KLimbs { + let two = (&(Lists::Node::Cons([UInt8::BYTE_2, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))); + klimbs_div(a, klimbs_pow(two, n)) + } +} diff --git a/IxVM/IxVM/Modules/KernelLevels.aiur b/IxVM/IxVM/Modules/KernelLevels.aiur new file mode 100644 index 000000000..3cf51e49f --- /dev/null +++ b/IxVM/IxVM/Modules/KernelLevels.aiur @@ -0,0 +1,840 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module KernelLevels { + enum NLVar { + Mk(Field, Field) + } + + enum NLEntry { + Mk(Lists::List, Field, Lists::List<&NLVar>) + } + + fn level_is_not_zero(l: KernelTypes::KLevel) -> Field { + match (*(l)) { + KernelTypes::KLevelNode::Zero => { 0 } , + KernelTypes::KLevelNode::Param(_) => { 0 } , + KernelTypes::KLevelNode::Succ(_) => { 1 } , + KernelTypes::KLevelNode::Max(a, b) => { match (level_is_not_zero(a), level_is_not_zero(b)) { + (0, 0) => { 0 } , + _ => { 1 } , + } } , + KernelTypes::KLevelNode::IMax(_, b) => { level_is_not_zero(b) } , + } + } + + fn level_eq(a: KernelTypes::KLevel, b: KernelTypes::KLevel) -> Field { + match (*(a)) { + KernelTypes::KLevelNode::Zero => { + match (*(b)) { + KernelTypes::KLevelNode::Zero => { 1 } , + _ => { 0 } , + } } , + KernelTypes::KLevelNode::Succ(a1) => { + match (*(b)) { + KernelTypes::KLevelNode::Succ(b1) => { level_eq(a1, b1) } , + _ => { 0 } , + } } , + KernelTypes::KLevelNode::Max(a1, a2) => { + match (*(b)) { + KernelTypes::KLevelNode::Max(b1, b2) => { level_eq(a1, b1) * level_eq(a2, b2) } , + _ => { 0 } , + } } , + KernelTypes::KLevelNode::IMax(a1, a2) => { + match (*(b)) { + KernelTypes::KLevelNode::IMax(b1, b2) => { level_eq(a1, b1) * level_eq(a2, b2) } , + _ => { 0 } , + } } , + KernelTypes::KLevelNode::Param(i) => { + match (*(b)) { + KernelTypes::KLevelNode::Param(j) => { Fields::is_zero(i - j) } , + _ => { 0 } , + } } , + } + } + + fn glist_cmp(a: Lists::List, b: Lists::List) -> Field { + match (*(a)) { + Lists::Node::Nil => { + match (*(b)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(_, _) => { 1 } , + } } , + Lists::Node::Cons(x, ar) => { + match (*(b)) { + Lists::Node::Nil => { 2 } , + Lists::Node::Cons(y, br) => { + match UInt32::less_than_fields(x, y) { + 1 => { 1 } , + 0 => { + match UInt32::less_than_fields(y, x) { + 1 => { 2 } , + 0 => { glist_cmp(ar, br) } , + } } , + } } , + } } , + } + } + + fn glist_subset(xs: Lists::List, ys: Lists::List) -> Field { + match (*(xs)) { + Lists::Node::Nil => { 1 } , + Lists::Node::Cons(x, xr) => { + match (*(ys)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(y, yr) => { + match UInt32::less_than_fields(x, y) { + 1 => { 0 } , + 0 => { + match UInt32::less_than_fields(y, x) { + 1 => { glist_subset(xs, yr) } , + 0 => { glist_subset(xr, yr) } , + } } , + } } , + } } , + } + } + + fn glist_eq_len(a: Lists::List, b: Lists::List) -> Field { + match (*(a)) { + Lists::Node::Nil => { + match (*(b)) { + Lists::Node::Nil => { 1 } , + Lists::Node::Cons(_, _) => { 0 } , + } } , + Lists::Node::Cons(_, ar) => { + match (*(b)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(_, br) => { glist_eq_len(ar, br) } , + } } , + } + } + + fn glist_ordered_insert(x: Field, l: Lists::List) -> (Field, Lists::List) { + match (*(l)) { + Lists::Node::Nil => { (1, (&(Lists::Node::Cons(x, (&(Lists::Node::Nil)))))) } , + Lists::Node::Cons(h, r) => { + match UInt32::less_than_fields(x, h) { + 1 => { (1, (&(Lists::Node::Cons(x, l)))) } , + 0 => { + match UInt32::less_than_fields(h, x) { + 0 => { (0, l) } , + 1 => { + match glist_ordered_insert(x, r) { + (f, r2) => { (f, (&(Lists::Node::Cons(h, r2)))) } , + } } , + } } , + } } , + } + } + + fn nlvars_add(vars: Lists::List<&NLVar>, idx: Field, k: Field) -> Lists::List<&NLVar> { + match (*(vars)) { + Lists::Node::Nil => { + (&(Lists::Node::Cons((&(NLVar::Mk(idx, k))), (&(Lists::Node::Nil))))) } , + Lists::Node::Cons(v, rest) => { + match (*(v)) { + NLVar::Mk(vi, vo) => { + match UInt32::less_than_fields(idx, vi) { + 1 => { (&(Lists::Node::Cons((&(NLVar::Mk(idx, k))), vars))) } , + 0 => { + match UInt32::less_than_fields(vi, idx) { + 1 => { (&(Lists::Node::Cons(v, nlvars_add(rest, idx, k)))) } , + 0 => { + match UInt32::less_than_fields(vo, k) { + 1 => { (&(Lists::Node::Cons((&(NLVar::Mk(vi, k))), rest))) } , + 0 => { vars } , + } } , + } } , + } } , + } } , + } + } + + fn nlvars_eq(a: Lists::List<&NLVar>, b: Lists::List<&NLVar>) -> Field { + match (*(a)) { + Lists::Node::Nil => { + match (*(b)) { + Lists::Node::Nil => { 1 } , + Lists::Node::Cons(_, _) => { 0 } , + } } , + Lists::Node::Cons(x, ar) => { + match (*(b)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(y, br) => { + match (*(x)) { + NLVar::Mk(xi, xo) => { + match (*(y)) { + NLVar::Mk(yi, yo) => { + match xi - yi { + 0 => { + match xo - yo { + 0 => { nlvars_eq(ar, br) } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + } } , + } } , + } } , + } + } + + fn nlvars_max_offset(vars: Lists::List<&NLVar>) -> Field { + match (*(vars)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(v, rest) => { + match (*(v)) { + NLVar::Mk(_, vo) => { + let m = nlvars_max_offset(rest); + match UInt32::less_than_fields(m, vo) { + 1 => { vo } , + 0 => { m } , + } } , + } } , + } + } + + fn nlvars_subsume(xs: Lists::List<&NLVar>, ys: Lists::List<&NLVar>) -> Lists::List<&NLVar> { + match (*(xs)) { + Lists::Node::Nil => { xs } , + Lists::Node::Cons(x, xr) => { + match (*(ys)) { + Lists::Node::Nil => { xs } , + Lists::Node::Cons(y, yr) => { + match (*(x)) { + NLVar::Mk(xi, xo) => { + match (*(y)) { + NLVar::Mk(yi, yo) => { + match UInt32::less_than_fields(xi, yi) { + 1 => { (&(Lists::Node::Cons(x, nlvars_subsume(xr, ys)))) } , + 0 => { + match UInt32::less_than_fields(yi, xi) { + 1 => { nlvars_subsume(xs, yr) } , + 0 => { + match UInt32::less_than_fields(yo, xo) { + 1 => { (&(Lists::Node::Cons(x, nlvars_subsume(xr, yr)))) } , + 0 => { nlvars_subsume(xr, yr) } , + } } , + } } , + } } , + } } , + } } , + } } , + } + } + + fn nl_add_const(acc: Lists::List<&NLEntry>, path: Lists::List, k: Field) -> Lists::List<&NLEntry> { + match k { + 0 => { acc } , + 1 => { + match (*(path)) { + Lists::Node::Nil => { nl_add_const_go(acc, path, k) } , + Lists::Node::Cons(_, _) => { acc } , + } } , + _ => { nl_add_const_go(acc, path, k) } , + } + } + + fn nl_add_const_go(acc: Lists::List<&NLEntry>, path: Lists::List, k: Field) -> Lists::List<&NLEntry> { + match (*(acc)) { + Lists::Node::Nil => { + (&(Lists::Node::Cons( + (&(NLEntry::Mk(path, k, (&(Lists::Node::Nil))))), + (&(Lists::Node::Nil))))) } , + Lists::Node::Cons(e, rest) => { + match (*(e)) { + NLEntry::Mk(ep, ec, ev) => { + match glist_cmp(path, ep) { + 0 => { + match UInt32::less_than_fields(ec, k) { + 1 => { (&(Lists::Node::Cons((&(NLEntry::Mk(ep, k, ev))), rest))) } , + 0 => { acc } , + } } , + 1 => { + (&(Lists::Node::Cons( + (&(NLEntry::Mk(path, k, (&(Lists::Node::Nil))))), acc))) } , + _ => { (&(Lists::Node::Cons(e, nl_add_const_go(rest, path, k)))) } , + } } , + } } , + } + } + + fn nl_add_var(acc: Lists::List<&NLEntry>, path: Lists::List, idx: Field, k: Field) -> Lists::List<&NLEntry> { + match (*(acc)) { + Lists::Node::Nil => { + (&(Lists::Node::Cons( + (&(NLEntry::Mk(path, 0, + (&(Lists::Node::Cons((&(NLVar::Mk(idx, k))), (&(Lists::Node::Nil)))))))), + (&(Lists::Node::Nil))))) } , + Lists::Node::Cons(e, rest) => { + match (*(e)) { + NLEntry::Mk(ep, ec, ev) => { + match glist_cmp(path, ep) { + 0 => { + (&(Lists::Node::Cons( + (&(NLEntry::Mk(ep, ec, nlvars_add(ev, idx, k)))), rest))) } , + 1 => { + (&(Lists::Node::Cons( + (&(NLEntry::Mk(path, 0, + (&(Lists::Node::Cons((&(NLVar::Mk(idx, k))), (&(Lists::Node::Nil)))))))), + acc))) } , + _ => { (&(Lists::Node::Cons(e, nl_add_var(rest, path, idx, k)))) } , + } } , + } } , + } + } + + fn normalize_aux(l: KernelTypes::KLevel, path: Lists::List, k: Field, + acc: Lists::List<&NLEntry>) -> Lists::List<&NLEntry> { + match (*(l)) { + KernelTypes::KLevelNode::Zero => { nl_add_const(acc, path, k) } , + KernelTypes::KLevelNode::Succ(inner) => { normalize_aux(inner, path, k + 1, acc) } , + KernelTypes::KLevelNode::Max(a, b) => { + normalize_aux(b, path, k, normalize_aux(a, path, k, acc)) } , + KernelTypes::KLevelNode::IMax(u, b) => { normalize_imax_dispatch(u, b, path, k, acc) } , + KernelTypes::KLevelNode::Param(idx) => { + match glist_ordered_insert(idx, path) { + (1, new_path) => { + nl_add_var(nl_add_const(acc, path, k), new_path, idx, k) } , + (0, _) => { + match k { + 0 => { acc } , + _ => { nl_add_var(acc, path, idx, k) } , + } } , + } } , + } + } + + fn normalize_imax_dispatch(a: KernelTypes::KLevel, b: KernelTypes::KLevel, path: Lists::List, k: Field, + acc: Lists::List<&NLEntry>) -> Lists::List<&NLEntry> { + match (*(b)) { + KernelTypes::KLevelNode::Zero => { nl_add_const(acc, path, k) } , + KernelTypes::KLevelNode::Succ(v) => { + normalize_aux(v, path, k + 1, normalize_aux(a, path, k, acc)) } , + KernelTypes::KLevelNode::Max(v, w) => { + + normalize_imax_dispatch(a, w, path, k, + normalize_imax_dispatch(a, v, path, k, acc)) } , + KernelTypes::KLevelNode::IMax(v, w) => { + + normalize_imax_dispatch(v, w, path, k, + normalize_imax_dispatch(a, w, path, k, acc)) } , + KernelTypes::KLevelNode::Param(idx) => { + match glist_ordered_insert(idx, path) { + (1, new_path) => { + + normalize_aux(a, new_path, k, + nl_add_var(nl_add_const(acc, path, k), new_path, idx, k)) } , + (0, _) => { + let acc2 = match k { + 0 => { acc } , + _ => { nl_add_var(acc, path, idx, k) } , + }; + normalize_aux(a, path, k, acc2) } , + } } , + } + } + + fn nl_subsumption_walk(rem: Lists::List<&NLEntry>, + snapshot: Lists::List<&NLEntry>) -> Lists::List<&NLEntry> { + match (*(rem)) { + Lists::Node::Nil => { rem } , + Lists::Node::Cons(e, rest) => { + (&(Lists::Node::Cons( + nl_subsume_entry(e, snapshot), + nl_subsumption_walk(rest, snapshot)))) } , + } + } + + fn nl_subsume_entry(e: &NLEntry, snap: Lists::List<&NLEntry>) -> &NLEntry { + match (*(snap)) { + Lists::Node::Nil => { e } , + Lists::Node::Cons(s, srest) => { + match (*(e)) { + NLEntry::Mk(p1, c1, v1) => { + match (*(s)) { + NLEntry::Mk(p2, c2, v2) => { + match glist_subset(p2, p1) { + 0 => { nl_subsume_entry(e, srest) } , + _ => { + + let same = glist_eq_len(p1, p2); + let c1n = match c1 { + 0 => { 0 } , + _ => { + let or1 = match same { + 1 => { 1 } , + 0 => { UInt32::less_than_fields(c2, c1) } , + }; + let or2 = match (*(v2)) { + Lists::Node::Nil => { 1 } , + Lists::Node::Cons(_, _) => { + UInt32::less_than_fields(nlvars_max_offset(v1) + 1, c1) } , + }; + match or1 * or2 { + 0 => { 0 } , + _ => { c1 } , + } } , + }; + let v1n = match same { + 1 => { v1 } , + 0 => { + match (*(v2)) { + Lists::Node::Nil => { v1 } , + Lists::Node::Cons(_, _) => { nlvars_subsume(v1, v2) } , + } } , + }; + nl_subsume_entry((&(NLEntry::Mk(p1, c1n, v1n))), srest) } , + } } , + } } , + } } , + } + } + + fn nl_skip_empty(l: Lists::List<&NLEntry>) -> Lists::List<&NLEntry> { + match (*(l)) { + Lists::Node::Nil => { l } , + Lists::Node::Cons(e, rest) => { + match (*(e)) { + NLEntry::Mk(_, c, v) => { + match c { + 0 => { + match (*(v)) { + Lists::Node::Nil => { nl_skip_empty(rest) } , + Lists::Node::Cons(_, _) => { l } , + } } , + _ => { l } , + } } , + } } , + } + } + + fn nl_eq(a0: Lists::List<&NLEntry>, b0: Lists::List<&NLEntry>) -> Field { + let a = nl_skip_empty(a0); + let b = nl_skip_empty(b0); + match (*(a)) { + Lists::Node::Nil => { + match (*(b)) { + Lists::Node::Nil => { 1 } , + Lists::Node::Cons(_, _) => { 0 } , + } } , + Lists::Node::Cons(x, ar) => { + match (*(b)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(y, br) => { + match (*(x)) { + NLEntry::Mk(xp, xc, xv) => { + match (*(y)) { + NLEntry::Mk(yp, yc, yv) => { + match glist_cmp(xp, yp) { + 0 => { + match xc - yc { + 0 => { + match nlvars_eq(xv, yv) { + 1 => { nl_eq(ar, br) } , + 0 => { 0 } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + } } , + } } , + } } , + } + } + + fn nl_covers_const(l2: Lists::List<&NLEntry>, p1: Lists::List, c: Field) -> Field { + match (*(l2)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(e, rest) => { + match (*(e)) { + NLEntry::Mk(p2, c2, v2) => { + match glist_subset(p2, p1) { + 0 => { nl_covers_const(rest, p1, c) } , + _ => { + let hit = match UInt32::less_than_fields(c2, c) { + 0 => { 1 } , + 1 => { nlvars_any_offset_geq(v2, c) } , + }; + match hit { + 1 => { 1 } , + 0 => { nl_covers_const(rest, p1, c) } , + } } , + } } , + } } , + } + } + + fn nlvars_any_offset_geq(vars: Lists::List<&NLVar>, c: Field) -> Field { + match (*(vars)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(v, rest) => { + match (*(v)) { + NLVar::Mk(_, vo) => { + match UInt32::less_than_fields(vo + 1, c) { + 0 => { 1 } , + 1 => { nlvars_any_offset_geq(rest, c) } , + } } , + } } , + } + } + + fn nl_covers_var(l2: Lists::List<&NLEntry>, p1: Lists::List, w: Field, off: Field) -> Field { + match (*(l2)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(e, rest) => { + match (*(e)) { + NLEntry::Mk(p2, _, v2) => { + match glist_subset(p2, p1) { + 0 => { nl_covers_var(rest, p1, w, off) } , + _ => { + match nlvars_dominates(v2, w, off) { + 1 => { 1 } , + 0 => { nl_covers_var(rest, p1, w, off) } , + } } , + } } , + } } , + } + } + + fn nlvars_dominates(vars: Lists::List<&NLVar>, w: Field, off: Field) -> Field { + match (*(vars)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(v, rest) => { + match (*(v)) { + NLVar::Mk(vi, vo) => { + match vi - w { + 0 => { + match UInt32::less_than_fields(vo, off) { + 0 => { 1 } , + 1 => { nlvars_dominates(rest, w, off) } , + } } , + _ => { nlvars_dominates(rest, w, off) } , + } } , + } } , + } + } + + fn nl_le(l1: Lists::List<&NLEntry>, l2: Lists::List<&NLEntry>) -> Field { + match (*(l1)) { + Lists::Node::Nil => { 1 } , + Lists::Node::Cons(e, rest) => { + match (*(e)) { + NLEntry::Mk(p1, c1, v1) => { + let c_ok = match c1 { + 0 => { 1 } , + _ => { nl_covers_const(l2, p1, c1) } , + }; + match c_ok { + 0 => { 0 } , + 1 => { + match nl_le_vars(v1, l2, p1) { + 0 => { 0 } , + 1 => { nl_le(rest, l2) } , + } } , + } } , + } } , + } + } + + fn nl_le_vars(vars: Lists::List<&NLVar>, l2: Lists::List<&NLEntry>, p1: Lists::List) -> Field { + match (*(vars)) { + Lists::Node::Nil => { 1 } , + Lists::Node::Cons(v, rest) => { + match (*(v)) { + NLVar::Mk(vi, vo) => { + match nl_covers_var(l2, p1, vi, vo) { + 0 => { 0 } , + 1 => { nl_le_vars(rest, l2, p1) } , + } } , + } } , + } + } + + fn level_normalize(l: KernelTypes::KLevel) -> Lists::List<&NLEntry> { + let seed = (&(Lists::Node::Cons( + (&(NLEntry::Mk((&(Lists::Node::Nil)), 0, (&(Lists::Node::Nil))))), + (&(Lists::Node::Nil))))); + let raw = normalize_aux(l, (&(Lists::Node::Nil)), 0, seed); + nl_subsumption_walk(raw, raw) + } + + fn level_leq(a: KernelTypes::KLevel, b: KernelTypes::KLevel) -> Field { + match level_eq(a, b) { + 1 => { 1 } , + 0 => { + match (*(a)) { + KernelTypes::KLevelNode::Zero => { 1 } , + _ => { nl_le(level_normalize(a), level_normalize(b)) } , + } } , + } + } + + fn level_equal(a: KernelTypes::KLevel, b: KernelTypes::KLevel) -> Field { + match level_eq(a, b) { + 1 => { 1 } , + 0 => { nl_eq(level_normalize(a), level_normalize(b)) } , + } + } + + fn level_max(a: KernelTypes::KLevel, b: KernelTypes::KLevel) -> KernelTypes::KLevel { + match level_explicit_val(a) { + (1, na) => { + match level_explicit_val(b) { + (1, nb) => { + match UInt32::less_than_fields(na, nb) { + 1 => { b } , + 0 => { a } , + } } , + _ => { level_max_go(a, b) } , + } } , + _ => { level_max_go(a, b) } , + } + } + + fn level_max_go(a: KernelTypes::KLevel, b: KernelTypes::KLevel) -> KernelTypes::KLevel { + match level_struct_eq(a, b) { + 1 => { a } , + 0 => { + match (*(a)) { + KernelTypes::KLevelNode::Zero => { b } , + _ => { + match (*(b)) { + KernelTypes::KLevelNode::Zero => { a } , + _ => { + match level_max_subsumes(b, a) { + 1 => { b } , + 0 => { + match level_max_subsumes(a, b) { + 1 => { a } , + 0 => { level_max_offsets(a, b) } , + } } , + } } , + } } , + } } , + } + } + + fn level_struct_eq(a: KernelTypes::KLevel, b: KernelTypes::KLevel) -> Field { + match (*(a)) { + KernelTypes::KLevelNode::Zero => { + match (*(b)) { + KernelTypes::KLevelNode::Zero => { 1 } , + _ => { 0 } , + } } , + KernelTypes::KLevelNode::Succ(x) => { + match (*(b)) { + KernelTypes::KLevelNode::Succ(y) => { level_struct_eq(x, y) } , + _ => { 0 } , + } } , + KernelTypes::KLevelNode::Max(x1, x2) => { + match (*(b)) { + KernelTypes::KLevelNode::Max(y1, y2) => { + level_struct_eq(x1, y1) * level_struct_eq(x2, y2) } , + _ => { 0 } , + } } , + KernelTypes::KLevelNode::IMax(x1, x2) => { + match (*(b)) { + KernelTypes::KLevelNode::IMax(y1, y2) => { + level_struct_eq(x1, y1) * level_struct_eq(x2, y2) } , + _ => { 0 } , + } } , + KernelTypes::KLevelNode::Param(i) => { + match (*(b)) { + KernelTypes::KLevelNode::Param(j) => { + match i - j { + 0 => { 1 } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + } + } + + fn level_max_subsumes(m: KernelTypes::KLevel, x: KernelTypes::KLevel) -> Field { + match (*(m)) { + KernelTypes::KLevelNode::Max(l, r) => { + match level_struct_eq(l, x) { + 1 => { 1 } , + 0 => { level_struct_eq(r, x) } , + } } , + _ => { 0 } , + } + } + + fn level_max_offsets(a: KernelTypes::KLevel, b: KernelTypes::KLevel) -> KernelTypes::KLevel { + match level_offset_of(a, 0) { + (base_a, off_a) => { + match level_offset_of(b, 0) { + (base_b, off_b) => { + match level_struct_eq(base_a, base_b) { + 1 => { + match UInt32::less_than_fields(off_a, off_b) { + 1 => { b } , + 0 => { a } , + } } , + 0 => { (&(KernelTypes::KLevelNode::Max(a, b))) } , + } } , + } } , + } + } + + fn level_explicit_val(l: KernelTypes::KLevel) -> (Field, Field) { + match (*(l)) { + KernelTypes::KLevelNode::Zero => { (1, 0) } , + KernelTypes::KLevelNode::Succ(inner) => { + match level_explicit_val(inner) { + (1, n) => { (1, n + 1) } , + _ => { (0, 0) } , + } } , + _ => { (0, 0) } , + } + } + + fn level_offset_of(l: KernelTypes::KLevel, k: Field) -> (KernelTypes::KLevel, Field) { + match (*(l)) { + KernelTypes::KLevelNode::Succ(inner) => { level_offset_of(inner, k + 1) } , + _ => { (l, k) } , + } + } + + fn level_imax(a: KernelTypes::KLevel, b: KernelTypes::KLevel) -> KernelTypes::KLevel { + match (*(b)) { + KernelTypes::KLevelNode::Zero => { (&(KernelTypes::KLevelNode::Zero)) } , + KernelTypes::KLevelNode::Succ(_) => { level_max(a, b) } , + _ => { + let not_zero = level_is_not_zero(b); + match not_zero { + 1 => { level_max(a, b) } , + 0 => { + match (*(a)) { + KernelTypes::KLevelNode::Zero => { b } , + _ => { + let eq = level_eq(a, b); + match eq { + 1 => { a } , + 0 => { (&(KernelTypes::KLevelNode::IMax(a, b))) } , + } } , + } } , + } } , + } + } + + fn level_reduce(l: KernelTypes::KLevel) -> KernelTypes::KLevel { + match (*(l)) { + KernelTypes::KLevelNode::Zero => { (&(KernelTypes::KLevelNode::Zero)) } , + KernelTypes::KLevelNode::Param(i) => { (&(KernelTypes::KLevelNode::Param(i))) } , + KernelTypes::KLevelNode::Succ(u) => { (&(KernelTypes::KLevelNode::Succ(level_reduce(u)))) } , + KernelTypes::KLevelNode::Max(a, b) => { level_max(level_reduce(a), level_reduce(b)) } , + KernelTypes::KLevelNode::IMax(a, b) => { level_imax(level_reduce(a), level_reduce(b)) } , + } + } + + fn level_inst_params(l: KernelTypes::KLevel, params: Lists::List) -> KernelTypes::KLevel { + match (*(l)) { + KernelTypes::KLevelNode::Zero => { (&(KernelTypes::KLevelNode::Zero)) } , + KernelTypes::KLevelNode::Succ(u) => { (&(KernelTypes::KLevelNode::Succ(level_inst_params(u, params)))) } , + KernelTypes::KLevelNode::Max(a, b) => { + level_max(level_inst_params(a, params), level_inst_params(b, params)) } , + KernelTypes::KLevelNode::IMax(a, b) => { + level_imax(level_inst_params(a, params), level_inst_params(b, params)) } , + KernelTypes::KLevelNode::Param(i) => { Lists::lookup(params, i) } , + } + } + + fn level_list_inst(lvls: Lists::List, params: Lists::List) -> Lists::List { + match (*(lvls)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(l, rest) => { + (&(Lists::Node::Cons( + level_inst_params(l, params), + level_list_inst(rest, params)))) } , + } + } + + fn expr_inst_levels(e: KernelTypes::KExpr, params: Lists::List) -> KernelTypes::KExpr { + + match (*(params)) { + Lists::Node::Nil => { e } , + _ => { expr_inst_levels_walk(e, params) } , + } + } + + fn expr_inst_levels_walk(e: KernelTypes::KExpr, params: Lists::List) -> KernelTypes::KExpr { + match (*(e)) { + KernelTypes::KExprNode::BVar(i) => { (&(KernelTypes::KExprNode::BVar(i))) } , + KernelTypes::KExprNode::Srt(l) => { + (&(KernelTypes::KExprNode::Srt(level_inst_params(l, params)))) } , + KernelTypes::KExprNode::Const(idx, lvls) => { + (&(KernelTypes::KExprNode::Const(idx, level_list_inst(lvls, params)))) } , + KernelTypes::KExprNode::App(f, a) => { + (&(KernelTypes::KExprNode::App(expr_inst_levels(f, params), expr_inst_levels(a, params)))) } , + KernelTypes::KExprNode::Lam(ty, body) => { + (&(KernelTypes::KExprNode::Lam(expr_inst_levels(ty, params), expr_inst_levels(body, params)))) } , + KernelTypes::KExprNode::Forall(ty, body) => { + (&(KernelTypes::KExprNode::Forall(expr_inst_levels(ty, params), expr_inst_levels(body, params)))) } , + KernelTypes::KExprNode::Let(ty, val, body) => { + (&(KernelTypes::KExprNode::Let( + expr_inst_levels(ty, params), + expr_inst_levels(val, params), + expr_inst_levels(body, params)))) } , + KernelTypes::KExprNode::Lit(lit) => { (&(KernelTypes::KExprNode::Lit(lit))) } , + KernelTypes::KExprNode::Proj(tidx, fidx, e1) => { + (&(KernelTypes::KExprNode::Proj(tidx, fidx, expr_inst_levels(e1, params)))) } , + } + } + + fn klimbs_eq(a: KernelTypes::KLimbs, b: KernelTypes::KLimbs) -> Field { + match (*(a)) { + Lists::Node::Nil => { + match (*(b)) { + Lists::Node::Nil => { 1 } , + _ => { 0 } , + } } , + Lists::Node::Cons(la, ra) => { + match (*(b)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(lb, rb) => { + let eq = UInt64::eq(la, lb); + match eq { + 1 => { klimbs_eq(ra, rb) } , + 0 => { 0 } , + } } , + } } , + } + } + + fn bytestream_eq(a: Bytes::Stream, b: Bytes::Stream) -> Field { + match (*(a)) { + Lists::Node::Nil => { + match (*(b)) { + Lists::Node::Nil => { 1 } , + _ => { 0 } , + } } , + Lists::Node::Cons(ba, ra) => { + match (*(b)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(bb, rb) => { + match UInt8::to_field(ba) - UInt8::to_field(bb) { + 0 => { bytestream_eq(ra, rb) } , + _ => { 0 } , + } } , + } } , + } + } + + fn literal_eq(a: KernelTypes::KLiteral, b: KernelTypes::KLiteral) -> Field { + match a { + KernelTypes::KLiteral::Nat(na) => { + match b { + KernelTypes::KLiteral::Nat(nb) => { klimbs_eq(na, nb) } , + _ => { 0 } , + } } , + KernelTypes::KLiteral::Str(sa) => { + match b { + KernelTypes::KLiteral::Str(sb) => { bytestream_eq(sa, sb) } , + _ => { 0 } , + } } , + } + } +} diff --git a/IxVM/IxVM/Modules/KernelNatPrim.aiur b/IxVM/IxVM/Modules/KernelNatPrim.aiur new file mode 100644 index 000000000..7141522a1 --- /dev/null +++ b/IxVM/IxVM/Modules/KernelNatPrim.aiur @@ -0,0 +1,1042 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module KernelNatPrim { + fn mk_bool(rc: KernelRoles::RoleCtx, g: Field) -> KernelTypes::KExpr { + match g { + 0 => { (&(KernelTypes::KExprNode::Const(KernelRoles::role_addr(rc, KernelRoleSpec::role_bool_false()), (&(Lists::Node::Nil))))) } , + _ => { (&(KernelTypes::KExprNode::Const(KernelRoles::role_addr(rc, KernelRoleSpec::role_bool_true()), (&(Lists::Node::Nil))))) } , + } + } + + fn bv_to_nat_via(rc: KernelRoles::RoleCtx, width_e: KernelTypes::KExpr, val_e: KernelTypes::KExpr) -> (Field, KernelTypes::KLimbs) { + match bitvec_of_nat_args_direct(rc, val_e) { + (0, _, _) => { (0, (&(Lists::Node::Nil))) } , + (1, val_width, n_e) => { + match try_extract_nat(rc, n_e) { + (0, _) => { (0, (&(Lists::Node::Nil))) } , + (1, n_kl) => { + match try_extract_nat(rc, val_width) { + (0, _) => { (0, (&(Lists::Node::Nil))) } , + (1, w_kl) => { + let two = (&(Lists::Node::Cons( + [UInt8::BYTE_2, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], + (&(Lists::Node::Nil))))); + let modulus = KernelKlimbs::klimbs_pow(two, w_kl); + (1, KernelKlimbs::klimbs_normalize(KernelKlimbs::klimbs_mod(n_kl, modulus))) } , + } } , + } } , + } + } + + fn try_reduce_bit_vec_ult(rc: KernelRoles::RoleCtx, spine: Lists::List) -> (Field, KernelTypes::KExpr) { + match UInt32::less_than_fields(Lists::length(spine), 3) { + 1 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + let width_e = Lists::lookup(spine, 0); + let lhs_e = Lists::lookup(spine, 1); + let rhs_e = Lists::lookup(spine, 2); + match bv_to_nat_via(rc, width_e, lhs_e) { + (0, _) => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + (1, lhs_n) => { + match bv_to_nat_via(rc, width_e, rhs_e) { + (0, _) => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + (1, rhs_n) => { + + let r = 1 - KernelKlimbs::klimbs_le(rhs_n, lhs_n); + (1, mk_bool(rc, r)) } , + } } , + } } , + } + } + + fn bitvec_of_nat_args_direct(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr) -> (Field, KernelTypes::KExpr, KernelTypes::KExpr) { + match KernelTypes::collect_spine(e) { + (head, args) => { + match (*(head)) { + KernelTypes::KExprNode::Const(caddr, _) => { + match KernelRoles::role_is(rc, caddr, KernelRoleSpec::role_bit_vec_of_nat()) { + 1 => { + match Lists::length(args) - 2 { + 0 => { (1, Lists::lookup(args, 0), Lists::lookup(args, 1)) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0))), (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0))), (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0))), (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + } + } + + fn try_bitvec_dispatch(rc: KernelRoles::RoleCtx, op: Field, spine: Lists::List, + types: Lists::List) -> (Field, KernelTypes::KExpr) { + match op { + 1 => { + match UInt32::less_than_fields(Lists::length(spine), 2) { + 1 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + let spine_p = KernelWhnf::bitvec_prep_spine(rc, spine, types); + let width_e = Lists::lookup(spine_p, 0); + let val_e = Lists::lookup(spine_p, 1); + match bv_to_nat_via(rc, width_e, val_e) { + (0, _) => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + (1, kl) => { (1, mk_nat_lit(kl)) } , + } } , + } } , + 2 => { + let spine_p = bitvec_prep_spine_ult(rc, spine, types); + try_reduce_bit_vec_ult(rc, spine_p) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } + } + + fn bitvec_prep_spine_ult(rc: KernelRoles::RoleCtx, spine: Lists::List, types: Lists::List) + -> Lists::List { + let sw = KernelWhnf::whnf_spine(rc, spine, types); + match (*(sw)) { + Lists::Node::Nil => { sw } , + Lists::Node::Cons(width_e, r1) => { + match (*(r1)) { + Lists::Node::Nil => { sw } , + Lists::Node::Cons(lhs_e, r2) => { + match (*(r2)) { + Lists::Node::Nil => { sw } , + Lists::Node::Cons(rhs_e, tail) => { + let lhs_p = np_whnf_inner_bv(rc, lhs_e, types); + let rhs_p = np_whnf_inner_bv(rc, rhs_e, types); + (&(Lists::Node::Cons(width_e, + (&(Lists::Node::Cons(lhs_p, + (&(Lists::Node::Cons(rhs_p, tail))))))))) } , + } } , + } } , + } + } + + fn np_whnf_inner_bv(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, types: Lists::List) -> KernelTypes::KExpr { + match KernelTypes::collect_spine(e) { + (h, a) => { KernelWhnf::apply_spine(h, KernelWhnf::whnf_spine(rc, a, types)) } , + } + } + + fn try_str_dispatch(rc: KernelRoles::RoleCtx, head_addr: Bytes::AddressRef, op: Field, spine: Lists::List, + types: Lists::List) -> (Field, KernelTypes::KExpr) { + let spine_len = Lists::length(spine); + match op { + 1 => { + match spine_len { + 1 => { + match walk_char_list_bytes(rc, Lists::lookup(spine, 0), types) { + (1, bs) => { (1, (&(KernelTypes::KExprNode::Lit(KernelTypes::KLiteral::Str(bs))))) } , + (0, _) => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + 2 => { + match UInt32::less_than_fields(spine_len, 1) { + 1 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + let a0 = Lists::lookup(spine, 0); + match (*(a0)) { + KernelTypes::KExprNode::Lit(lit) => { + match lit { + KernelTypes::KLiteral::Str(bs) => { + + let limbs = klimbs_from_g(Lists::length(bs)); + (1, (&(KernelTypes::KExprNode::Lit(KernelTypes::KLiteral::Nat(limbs))))) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + } } , + 3 => { try_str_back(rc, spine) } , + 4 => { try_str_to_byte_array(rc, spine) } , + 5 => { KernelInfer::try_str_dec_eq(rc, head_addr, spine, types) } , + 6 => { + match UInt32::less_than_fields(spine_len, 2) { + 1 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + let a0 = Lists::lookup(spine, 0); + let a1 = Lists::lookup(spine, 1); + match (*(a0)) { + KernelTypes::KExprNode::Lit(la) => { + match la { + KernelTypes::KLiteral::Str(sa) => { + match (*(a1)) { + KernelTypes::KExprNode::Lit(lb) => { + match lb { + KernelTypes::KLiteral::Str(sb) => { + let joined = Lists::concat(sa, sb); + (1, (&(KernelTypes::KExprNode::Lit(KernelTypes::KLiteral::Str(joined))))) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } + } + + fn try_str_back(rc: KernelRoles::RoleCtx, spine: Lists::List) -> (Field, KernelTypes::KExpr) { + match UInt32::less_than_fields(Lists::length(spine), 1) { + 1 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + match (*(Lists::lookup(spine, 0))) { + KernelTypes::KExprNode::Lit(lit) => { + match lit { + KernelTypes::KLiteral::Str(bs) => { + let cp = utf8_last_codepoint(bs); + let cp_limbs = klimbs_from_g(cp); + let cp_lit = (&(KernelTypes::KExprNode::Lit(KernelTypes::KLiteral::Nat(cp_limbs)))); + let con = (&(KernelTypes::KExprNode::Const(KernelRoles::role_used_implicitly(rc, KernelRoleSpec::role_char_of_nat()), + (&(Lists::Node::Nil))))); + (1, (&(KernelTypes::KExprNode::App(con, cp_lit)))) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + } + } + + fn try_str_to_byte_array(rc: KernelRoles::RoleCtx, spine: Lists::List) -> (Field, KernelTypes::KExpr) { + match UInt32::less_than_fields(Lists::length(spine), 1) { + 1 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + match (*(Lists::lookup(spine, 0))) { + KernelTypes::KExprNode::Lit(lit) => { + match lit { + KernelTypes::KLiteral::Str(bs) => { + match (*(bs)) { + Lists::Node::Nil => { + (1, (&(KernelTypes::KExprNode::Const(KernelRoles::role_used_implicitly(rc, KernelRoleSpec::role_byte_array_empty()), + (&(Lists::Node::Nil)))))) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + } + } + + fn utf8_validate(bs: Bytes::Stream) -> () { + match (*(bs)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(b0, rest) => { + match utf8_decode_one(b0, rest) { + (_, remaining) => { utf8_validate(remaining) } , + } } , + } + } + + fn utf8_last_codepoint(bs: Bytes::Stream) -> Field { + utf8_last_go(bs, 65) + } + + fn utf8_last_go(bs: Bytes::Stream, prev: Field) -> Field { + match (*(bs)) { + Lists::Node::Nil => { prev } , + Lists::Node::Cons(b0, rest) => { + match utf8_decode_one(b0, rest) { + (cp, remaining) => { utf8_last_go(remaining, cp) } , + } } , + } + } + + fn utf8_cont(b: UInt8::U8) -> Field { + match UInt8::less_than(b, UInt8::BYTE_128) { + 0 => { + match UInt8::less_than(b, UInt8::BYTE_192) { + 1 => { UInt8::to_field(b) - 128 } , + } } , + } + } + + fn utf8_decode_one(b0: UInt8::U8, rest: Bytes::Stream) -> (Field, Bytes::Stream) { + match UInt8::less_than(b0, UInt8::BYTE_128) { + 1 => { (UInt8::to_field(b0), rest) } , + _ => { + + match UInt8::less_than(b0, UInt8::BYTE_194) { + 0 => { + match UInt8::less_than(b0, UInt8::BYTE_224) { + 1 => { + match (*(rest)) { + Lists::Node::Cons(b1, r1) => { + + let cp = (UInt8::to_field(b0) - 192) * 64 + utf8_cont(b1); + (cp, r1) } , + } } , + _ => { + match UInt8::less_than(b0, UInt8::BYTE_240) { + 1 => { + match (*(rest)) { + Lists::Node::Cons(b1, r1) => { + match (*(r1)) { + Lists::Node::Cons(b2, r2) => { + let cp = (UInt8::to_field(b0) - 224) * 4096 + + utf8_cont(b1) * 64 + + utf8_cont(b2); + + match UInt32::less_than_fields(cp, 2048) { + 0 => { + + match UInt32::less_than_fields(cp, 55296) { + 1 => { (cp, r2) } , + 0 => { + match UInt32::less_than_fields(cp, 57344) { + 0 => { (cp, r2) } , + } } , + } } , + } } , + } } , + } } , + _ => { + match (*(rest)) { + Lists::Node::Cons(b1, r1) => { + match (*(r1)) { + Lists::Node::Cons(b2, r2) => { + match (*(r2)) { + Lists::Node::Cons(b3, r3) => { + let cp = (UInt8::to_field(b0) - 240) * 262144 + + utf8_cont(b1) * 4096 + + utf8_cont(b2) * 64 + + utf8_cont(b3); + + match UInt32::less_than_fields(cp, 65536) { + 0 => { + + match UInt32::less_than_fields(cp, 1114112) { + 1 => { (cp, r3) } , + } } , + } } , + } } , + } } , + } } , + } } , + } } , + } } , + } + } + + fn str_lit_to_ctor(rc: KernelRoles::RoleCtx, bs: Bytes::Stream) -> KernelTypes::KExpr { + let zero_lvl = (&(KernelTypes::KLevelNode::Zero)); + let ulvls = (&(Lists::Node::Cons(zero_lvl, (&(Lists::Node::Nil))))); + let nil_const = (&(KernelTypes::KExprNode::Const(KernelRoles::role_used_implicitly(rc, KernelRoleSpec::role_list_nil()), ulvls))); + let cons_const = (&(KernelTypes::KExprNode::Const(KernelRoles::role_used_implicitly(rc, KernelRoleSpec::role_list_cons()), ulvls))); + let char_const = + (&(KernelTypes::KExprNode::Const(KernelRoles::role_used_implicitly(rc, KernelRoleSpec::role_char()), (&(Lists::Node::Nil))))); + let con_const = + (&(KernelTypes::KExprNode::Const(KernelRoles::role_used_implicitly(rc, KernelRoleSpec::role_char_of_nat()), (&(Lists::Node::Nil))))); + let str_const = + (&(KernelTypes::KExprNode::Const(KernelRoles::role_used_implicitly(rc, KernelRoleSpec::role_string_of_list()), (&(Lists::Node::Nil))))); + let nil_app = (&(KernelTypes::KExprNode::App(nil_const, char_const))); + let cons_partial = (&(KernelTypes::KExprNode::App(cons_const, char_const))); + let list_expr = build_char_list(bs, nil_app, cons_partial, con_const); + (&(KernelTypes::KExprNode::App(str_const, list_expr))) + } + + fn build_char_list(bs: Bytes::Stream, nil_app: KernelTypes::KExpr, + cons_partial: KernelTypes::KExpr, con_const: KernelTypes::KExpr) -> KernelTypes::KExpr { + match (*(bs)) { + Lists::Node::Nil => { nil_app } , + Lists::Node::Cons(b0, rest) => { + match utf8_decode_one(b0, rest) { + (cp, remaining) => { + let cp_limbs = klimbs_from_g(cp); + let cp_lit = (&(KernelTypes::KExprNode::Lit(KernelTypes::KLiteral::Nat(cp_limbs)))); + let char_val = (&(KernelTypes::KExprNode::App(con_const, cp_lit))); + let with_head = (&(KernelTypes::KExprNode::App(cons_partial, char_val))); + let tail = build_char_list(remaining, nil_app, cons_partial, con_const); + (&(KernelTypes::KExprNode::App(with_head, tail))) } , + } } , + } + } + + fn str_lit_delta_step(rc: KernelRoles::RoleCtx, expanded: KernelTypes::KExpr, types: Lists::List) -> KernelTypes::KExpr { + match (*(expanded)) { + KernelTypes::KExprNode::App(f, list_arg) => { + match (*(f)) { + KernelTypes::KExprNode::Const(caddr, _) => { + let ci = (*(Ingress::get_ci(caddr))); + match ci { + KernelTypes::KConstantInfo::Defn(_, _, value, _, _) => { + let body = KernelLevels::expr_inst_levels(value, (&(Lists::Node::Nil))); + match (*(body)) { + KernelTypes::KExprNode::Lam(_, lam_body) => { + KernelWhnf::whnf_nd(rc, KernelSubst::expr_inst1(lam_body, list_arg, 0), types) } , + _ => { KernelWhnf::whnf_nd(rc, (&(KernelTypes::KExprNode::App(body, list_arg))), types) } , + } } , + _ => { expanded } , + } } , + _ => { expanded } , + } } , + _ => { expanded } , + } + } + + fn str_lit_to_ctor_app_or_self(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, types: Lists::List) -> KernelTypes::KExpr { + match (*(e)) { + KernelTypes::KExprNode::Lit(lit) => { + match lit { + KernelTypes::KLiteral::Str(bs) => { str_lit_delta_step(rc, str_lit_to_ctor(rc, bs), types) } , + _ => { e } , + } } , + _ => { e } , + } + } + + fn split_u32(x: Field) -> (Field, Field, Field, Field) { + match KernelKlimbs::divmod_256(x, 0) { + (b0, q1) => { + match KernelKlimbs::divmod_256(q1, 0) { + (b1, q2) => { + match KernelKlimbs::divmod_256(q2, 0) { + (b2, q3) => { + match KernelKlimbs::divmod_256(q3, 0) { + (b3, _) => { (b0, b1, b2, b3) } , + } } , + } } , + } } , + } + } + + fn klimbs_from_g(x: Field) -> KernelTypes::KLimbs { + match split_u32(x) { + (rb0, rb1, rb2, rb3) => { + let b0 = UInt8::from_field(rb0); + let b1 = UInt8::from_field(rb1); + let b2 = UInt8::from_field(rb2); + let b3 = UInt8::from_field(rb3); + + constrain_eq!(x, UInt8::to_field(b0) + 256 * UInt8::to_field(b1) + + 65536 * UInt8::to_field(b2) + 16777216 * UInt8::to_field(b3), + "u32 byte split does not recompose to the original value"); + + KernelKlimbs::klimbs_normalize((&(Lists::Node::Cons( + [b0, b1, b2, b3, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil)))))) } , + } + } + + fn walk_char_list_bytes(rc: KernelRoles::RoleCtx, list: KernelTypes::KExpr, types: Lists::List) + -> (Field, Bytes::Stream) { + let w = KernelWhnf::whnf(rc, list, types); + match KernelTypes::collect_spine(w) { + (head, args) => { + match (*(head)) { + KernelTypes::KExprNode::Const(caddr, _) => { + match KernelRoles::role_is(rc, caddr, KernelRoleSpec::role_list_nil()) { + 1 => { + match Lists::length(args) { + 1 => { (1, (&(Lists::Node::Nil))) } , + _ => { (0, (&(Lists::Node::Nil))) } , + } } , + _ => { + match KernelRoles::role_is(rc, caddr, KernelRoleSpec::role_list_cons()) { + 0 => { (0, (&(Lists::Node::Nil))) } , + _ => { + match Lists::length(args) { + 3 => { + match char_lit_codepoint(rc, Lists::lookup(args, 1), types) { + (0, _) => { (0, (&(Lists::Node::Nil))) } , + (1, cp) => { + match walk_char_list_bytes(rc, Lists::lookup(args, 2), types) { + (0, t) => { (0, t) } , + (1, t) => { (1, utf8_encode_prepend(cp, t)) } , + } } , + } } , + _ => { (0, (&(Lists::Node::Nil))) } , + } } , + } } , + } } , + _ => { (0, (&(Lists::Node::Nil))) } , + } } , + } + } + + fn char_lit_codepoint(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, types: Lists::List) -> (Field, Field) { + match char_lit_codepoint_syn(rc, e) { + (1, cp) => { (1, cp) } , + _ => { + let w = KernelWhnf::whnf(rc, e, types); + char_lit_codepoint_syn(rc, w) } , + } + } + + fn char_lit_codepoint_syn(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr) -> (Field, Field) { + match (*(e)) { + KernelTypes::KExprNode::App(f, arg) => { + match (*(f)) { + KernelTypes::KExprNode::Const(caddr, _) => { + match KernelRoles::role_is(rc, caddr, KernelRoleSpec::role_char_of_nat()) { + 0 => { (0, 0) } , + _ => { + match (*(arg)) { + KernelTypes::KExprNode::Lit(lit) => { + match lit { + KernelTypes::KLiteral::Nat(limbs) => { klimbs_scalar_value(limbs) } , + _ => { (0, 0) } , + } } , + _ => { (0, 0) } , + } } , + } } , + _ => { (0, 0) } , + } } , + _ => { (0, 0) } , + } + } + + fn klimbs_scalar_value(limbs: KernelTypes::KLimbs) -> (Field, Field) { + match (*(limbs)) { + Lists::Node::Cons(limb, rest) => { + match (*(rest)) { + Lists::Node::Nil => { + let [b0, b1, b2, b3, b4, b5, b6, b7] = limb; + let hi = UInt8::to_field(b3) + UInt8::to_field(b4) + UInt8::to_field(b5) + UInt8::to_field(b6) + UInt8::to_field(b7); + match Fields::is_zero(hi) { + 0 => { (0, 0) } , + _ => { + let cp = UInt8::to_field(b0) + UInt8::to_field(b1) * 256 + UInt8::to_field(b2) * 65536; + match UInt32::less_than_fields(cp, 55296) { + 1 => { (1, cp) } , + _ => { + match UInt32::less_than_fields(57343, cp) { + 0 => { (0, 0) } , + _ => { + match UInt32::less_than_fields(cp, 1114112) { + 1 => { (1, cp) } , + _ => { (0, 0) } , + } } , + } } , + } } , + } } , + _ => { (0, 0) } , + } } , + _ => { (0, 0) } , + } + } + + fn divmod_64u(x: Field, q: Field) -> (Field, Field) { + match UInt32::less_than_fields(x, 64) { + 1 => { (x, q) } , + _ => { divmod_64u(x - 64, q + 1) } , + } + } + + fn utf8_groups(cp: Field) -> (Field, Field, Field, Field) { + match divmod_64u(cp, 0) { + (g0, q1) => { + match divmod_64u(q1, 0) { + (g1, q2) => { + match divmod_64u(q2, 0) { + (g2, g3) => { (g0, g1, g2, g3) } , + } } , + } } , + } + } + + fn utf8_encode_prepend(cp: Field, tail: Bytes::Stream) -> Bytes::Stream { + match utf8_groups(cp) { + (g0, g1, g2, g3) => { + let g0u = UInt8::from_field(g0); + let g1u = UInt8::from_field(g1); + let g2u = UInt8::from_field(g2); + let g3u = UInt8::from_field(g3); + let f0 = UInt8::to_field(g0u); + let f1 = UInt8::to_field(g1u); + let f2 = UInt8::to_field(g2u); + let f3 = UInt8::to_field(g3u); + + assert_eq!(UInt32::less_than_fields(f0, 64), 1, + "utf8 group 0 is not a 6-bit value"); + assert_eq!(UInt32::less_than_fields(f1, 64), 1, + "utf8 group 1 is not a 6-bit value"); + assert_eq!(UInt32::less_than_fields(f2, 64), 1, + "utf8 group 2 is not a 6-bit value"); + assert_eq!(UInt32::less_than_fields(f3, 64), 1, + "utf8 group 3 is not a 6-bit value"); + assert_eq!(cp, f0 + f1 * 64 + f2 * 4096 + f3 * 262144, + "utf8 groups do not recompose to the codepoint"); + match UInt32::less_than_fields(cp, 128) { + 1 => { (&(Lists::Node::Cons(UInt8::from_field(cp), tail))) } , + _ => { + match UInt32::less_than_fields(cp, 2048) { + 1 => { + let t1 = UInt8::from_field(f0 + 128); + let l1 = UInt8::from_field(f1 + 192); + (&(Lists::Node::Cons(l1, (&(Lists::Node::Cons(t1, tail)))))) } , + _ => { + match UInt32::less_than_fields(cp, 65536) { + 1 => { + let t2 = UInt8::from_field(f0 + 128); + let t1 = UInt8::from_field(f1 + 128); + let l2 = UInt8::from_field(f2 + 224); + (&(Lists::Node::Cons(l2, (&(Lists::Node::Cons(t1, (&(Lists::Node::Cons(t2, tail))))))))) } , + _ => { + let t3 = UInt8::from_field(f0 + 128); + let t2 = UInt8::from_field(f1 + 128); + let t1 = UInt8::from_field(f2 + 128); + let l3 = UInt8::from_field(f3 + 240); + (&(Lists::Node::Cons(l3, (&(Lists::Node::Cons(t1, (&(Lists::Node::Cons(t2, (&(Lists::Node::Cons(t3, tail)))))))))))) } , + } } , + } } , + } } , + } + } + + fn try_extract_nat(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr) -> (Field, KernelTypes::KLimbs) { + match (*(e)) { + KernelTypes::KExprNode::Lit(lit) => { + match lit { + KernelTypes::KLiteral::Nat(limbs) => { (1, limbs) } , + _ => { (0, (&(Lists::Node::Nil))) } , + } } , + KernelTypes::KExprNode::Const(caddr, _) => { + match KernelRoles::role_is(rc, caddr, KernelRoleSpec::role_nat_zero()) { + 1 => { (1, (&(Lists::Node::Nil))) } , + _ => { (0, (&(Lists::Node::Nil))) } , + } } , + KernelTypes::KExprNode::App(f, a) => { try_extract_nat_app(rc, f, a) } , + _ => { (0, (&(Lists::Node::Nil))) } , + } + } + + fn try_extract_nat_app(rc: KernelRoles::RoleCtx, f: KernelTypes::KExpr, a: KernelTypes::KExpr) -> (Field, KernelTypes::KLimbs) { + match (*(f)) { + KernelTypes::KExprNode::Const(caddr, _) => { + match KernelRoles::role_is(rc, caddr, KernelRoleSpec::role_nat_succ()) { + 1 => { + match try_extract_nat(rc, a) { + (1, pred_limbs) => { (1, KernelKlimbs::klimbs_succ(pred_limbs)) } , + _ => { (0, (&(Lists::Node::Nil))) } , + } } , + _ => { (0, (&(Lists::Node::Nil))) } , + } } , + _ => { (0, (&(Lists::Node::Nil))) } , + } + } + + fn mk_nat_lit(n: KernelTypes::KLimbs) -> KernelTypes::KExpr { + (&(KernelTypes::KExprNode::Lit(KernelTypes::KLiteral::Nat(n)))) + } + + fn try_extract_int_prim(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr) -> (Field, Field, KernelTypes::KLimbs) { + match (*(e)) { + KernelTypes::KExprNode::App(f, a) => { match (*(f)) { + KernelTypes::KExprNode::Const(caddr, _) => { match try_extract_nat(rc, a) { + (1, n) => { match KernelRoles::role_is(rc, caddr, KernelRoleSpec::role_int_of_nat()) { + 1 => { (1, 0, KernelKlimbs::klimbs_normalize(n)) } , + _ => { match KernelRoles::role_is(rc, caddr, KernelRoleSpec::role_int_neg_succ()) { + 1 => { (1, 1, KernelKlimbs::klimbs_normalize(KernelKlimbs::klimbs_succ(n))) } , + _ => { (0, 0, (&(Lists::Node::Nil))) } , + } } , + } } , + _ => { (0, 0, (&(Lists::Node::Nil))) } , + } } , + _ => { (0, 0, (&(Lists::Node::Nil))) } , + } } , + _ => { (0, 0, (&(Lists::Node::Nil))) } , + } + } + + fn mk_int_prim(rc: KernelRoles::RoleCtx, sign: Field, magnitude: KernelTypes::KLimbs) -> KernelTypes::KExpr { + let mag = KernelKlimbs::klimbs_normalize(magnitude); + let neg = sign * (1 - KernelKlimbs::klimbs_is_zero(mag)); + let caddr = match neg { + 0 => { KernelRoles::role_used_implicitly(rc, KernelRoleSpec::role_int_of_nat()) } , + _ => { KernelRoles::role_used_implicitly(rc, KernelRoleSpec::role_int_neg_succ()) } , + }; + let arg = match neg { 0 => { mag } , _ => { KernelKlimbs::klimbs_normalize(KernelKlimbs::klimbs_dec(mag)) } , }; + (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(caddr, (&(Lists::Node::Nil))))), mk_nat_lit(arg)))) + } + + fn int_add_prim(rc: KernelRoles::RoleCtx, sa: Field, a: KernelTypes::KLimbs, sb: Field, b: KernelTypes::KLimbs) -> KernelTypes::KExpr { + match sa - sb { + 0 => { mk_int_prim(rc, sa, KernelKlimbs::klimbs_add(a, b)) } , + _ => { match KernelKlimbs::klimbs_le(a, b) { + 1 => { mk_int_prim(rc, sb, KernelKlimbs::klimbs_sub(b, a)) } , + _ => { mk_int_prim(rc, sa, KernelKlimbs::klimbs_sub(a, b)) } , + } } , + } + } + + fn int_emod_prim(rc: KernelRoles::RoleCtx, sa: Field, a: KernelTypes::KLimbs, b: KernelTypes::KLimbs) -> KernelTypes::KExpr { + match KernelKlimbs::klimbs_is_zero(b) { + 1 => { mk_int_prim(rc, sa, a) } , + _ => { + let r0 = KernelKlimbs::klimbs_mod(a, b); + match sa * (1 - KernelKlimbs::klimbs_is_zero(r0)) { + 1 => { mk_int_prim(rc, 0, KernelKlimbs::klimbs_sub(b, r0)) } , + _ => { mk_int_prim(rc, 0, r0) } , + } } , + } + } + + fn int_ediv_prim(rc: KernelRoles::RoleCtx, sa: Field, a: KernelTypes::KLimbs, sb: Field, b: KernelTypes::KLimbs) -> KernelTypes::KExpr { + match KernelKlimbs::klimbs_is_zero(b) { + 1 => { mk_int_prim(rc, 0, (&(Lists::Node::Nil))) } , + _ => { + let q0 = KernelKlimbs::klimbs_div(a, b); + let r0 = KernelKlimbs::klimbs_mod(a, b); + let q = match sa * (1 - KernelKlimbs::klimbs_is_zero(r0)) { + 1 => { KernelKlimbs::klimbs_succ(q0) } , + _ => { q0 } , + }; + mk_int_prim(rc, (sa + sb - 2 * sa * sb) * (1 - KernelKlimbs::klimbs_is_zero(q)), q) } , + } + } + + fn int_bmod_prim(rc: KernelRoles::RoleCtx, sa: Field, a: KernelTypes::KLimbs, m: KernelTypes::KLimbs) -> KernelTypes::KExpr { + match KernelKlimbs::klimbs_is_zero(m) { + 1 => { mk_int_prim(rc, sa, a) } , + _ => { + let r0 = KernelKlimbs::klimbs_mod(a, m); + let r = match sa * (1 - KernelKlimbs::klimbs_is_zero(r0)) { + 1 => { KernelKlimbs::klimbs_sub(m, r0) } , + _ => { r0 } , + }; + let two = (&(Lists::Node::Cons([UInt8::BYTE_2, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))); + let half = KernelKlimbs::klimbs_div(KernelKlimbs::klimbs_succ(m), two); + match KernelKlimbs::klimbs_le(half, r) { + 1 => { mk_int_prim(rc, 1, KernelKlimbs::klimbs_sub(m, r)) } , + _ => { mk_int_prim(rc, 0, r) } , + } } , + } + } + + fn int_bdiv_prim(rc: KernelRoles::RoleCtx, sa: Field, a: KernelTypes::KLimbs, m: KernelTypes::KLimbs) -> KernelTypes::KExpr { + match KernelKlimbs::klimbs_is_zero(m) { + 1 => { mk_int_prim(rc, 0, (&(Lists::Node::Nil))) } , + _ => { + let r0 = KernelKlimbs::klimbs_mod(a, m); + let r = match sa * (1 - KernelKlimbs::klimbs_is_zero(r0)) { + 1 => { KernelKlimbs::klimbs_sub(m, r0) } , + _ => { r0 } , + }; + let q0 = KernelKlimbs::klimbs_div(a, m); + let qmag = match sa * (1 - KernelKlimbs::klimbs_is_zero(r0)) { 1 => { KernelKlimbs::klimbs_succ(q0) } , _ => { q0 } , }; + let qsign = sa * (1 - KernelKlimbs::klimbs_is_zero(qmag)); + let two = (&(Lists::Node::Cons([UInt8::BYTE_2, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))); + let half = KernelKlimbs::klimbs_div(KernelKlimbs::klimbs_succ(m), two); + match KernelKlimbs::klimbs_le(half, r) { + 0 => { mk_int_prim(rc, qsign, qmag) } , + _ => { int_add_prim(rc, qsign, qmag, 0, + (&(Lists::Node::Cons([UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil)))))) } , + } } , + } + } + + fn try_int_prim_dispatch(rc: KernelRoles::RoleCtx, op: Field, spine: Lists::List, + types: Lists::List) -> (Field, KernelTypes::KExpr) { + let sw = KernelWhnf::whnf_spine(rc, spine, types); + let n = Lists::length(sw); + match op { + 1 | 2 => { match UInt32::less_than_fields(n, 1) { + 1 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { match try_extract_int_prim(rc, Lists::lookup(sw, 0)) { + (1, s, a) => { + let v = match op { + 2 => { mk_nat_lit(a) } , + _ => { mk_int_prim(rc, (1 - s) * (1 - KernelKlimbs::klimbs_is_zero(a)), a) } , + }; + (1, np_apply_spine(v, Lists::drop(sw, 1))) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + } } , + _ => { match UInt32::less_than_fields(n, 2) { + 1 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { match try_extract_int_prim(rc, Lists::lookup(sw, 0)) { + (1, sa, a) => { try_int_prim_second(rc, op, sw, sa, a) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + } } , + } + } + + fn try_int_prim_second(rc: KernelRoles::RoleCtx, op: Field, sw: Lists::List, + sa: Field, a: KernelTypes::KLimbs) -> (Field, KernelTypes::KExpr) { + match op { + 3 | 4 | 5 => { match try_extract_nat(rc, Lists::lookup(sw, 1)) { + (1, b) => { + let v = match op { + 3 => { int_bmod_prim(rc, sa, a, b) } , + 4 => { int_bdiv_prim(rc, sa, a, b) } , + _ => { + let two = (&(Lists::Node::Cons([UInt8::BYTE_2, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))); + let odd = 1 - KernelKlimbs::klimbs_is_zero(KernelKlimbs::klimbs_mod(b, two)); + mk_int_prim(rc, sa * odd, KernelKlimbs::klimbs_pow(a, b)) } , + }; + (1, np_apply_spine(v, Lists::drop(sw, 2))) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { match try_extract_int_prim(rc, Lists::lookup(sw, 1)) { + (1, sb, b) => { + let v = match op { + 6 => { int_add_prim(rc, sa, a, sb, b) } , + 7 => { int_add_prim(rc, sa, a, (1 - sb) * (1 - KernelKlimbs::klimbs_is_zero(b)), b) } , + 8 => { mk_int_prim(rc, (sa + sb - 2 * sa * sb) + * (1 - KernelKlimbs::klimbs_is_zero(a)) * (1 - KernelKlimbs::klimbs_is_zero(b)), KernelKlimbs::klimbs_mul(a, b)) } , + 9 => { int_emod_prim(rc, sa, a, b) } , + _ => { int_ediv_prim(rc, sa, a, sb, b) } , + }; + (1, np_apply_spine(v, Lists::drop(sw, 2))) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + } + } + + fn np_apply_spine(head: KernelTypes::KExpr, spine: Lists::List) -> KernelTypes::KExpr { + match (*(spine)) { + Lists::Node::Nil => { head } , + Lists::Node::Cons(a, rest) => { + np_apply_spine((&(KernelTypes::KExprNode::App(head, a))), rest) } , + } + } + + fn try_nat_binop_addr(rc: KernelRoles::RoleCtx, op: Field, a: KernelTypes::KLimbs, b: KernelTypes::KLimbs) -> (Field, KernelTypes::KExpr) { + match op { + 3 => { (1, mk_nat_lit(KernelKlimbs::klimbs_normalize(KernelKlimbs::klimbs_add(a, b)))) } , + 4 => { (1, mk_nat_lit(KernelKlimbs::klimbs_normalize(KernelKlimbs::klimbs_sub(a, b)))) } , + 5 => { (1, mk_nat_lit(KernelKlimbs::klimbs_normalize(KernelKlimbs::klimbs_mul(a, b)))) } , + 6 => { (1, mk_nat_lit(KernelKlimbs::klimbs_normalize(KernelKlimbs::klimbs_div(a, b)))) } , + 7 => { (1, mk_nat_lit(KernelKlimbs::klimbs_normalize(KernelKlimbs::klimbs_mod(a, b)))) } , + 8 => { (1, mk_nat_lit(KernelKlimbs::klimbs_normalize(KernelKlimbs::klimbs_gcd(a, b)))) } , + 9 => { (1, mk_nat_lit(KernelKlimbs::klimbs_normalize(KernelKlimbs::klimbs_pow(a, b)))) } , + 10 => { (1, mk_nat_lit(KernelKlimbs::klimbs_normalize(KernelKlimbs::klimbs_land(a, b)))) } , + 11 => { (1, mk_nat_lit(KernelKlimbs::klimbs_normalize(KernelKlimbs::klimbs_lor(a, b)))) } , + 12 => { (1, mk_nat_lit(KernelKlimbs::klimbs_normalize(KernelKlimbs::klimbs_xor_op(a, b)))) } , + 13 => { (1, mk_nat_lit(KernelKlimbs::klimbs_normalize(KernelKlimbs::klimbs_shl(a, b)))) } , + 14 => { (1, mk_nat_lit(KernelKlimbs::klimbs_normalize(KernelKlimbs::klimbs_shr(a, b)))) } , + 15 => { (1, mk_bool(rc, KernelLevels::klimbs_eq(a, b))) } , + 16 => { (1, mk_bool(rc, KernelKlimbs::klimbs_le(a, b))) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } + } + + fn try_match_nat_add(rc: KernelRoles::RoleCtx, head: KernelTypes::KExpr, args: Lists::List) -> (Field, KernelTypes::KExpr, KernelTypes::KLimbs) { + match (*(head)) { + KernelTypes::KExprNode::Const(caddr, _) => { + match KernelRoles::role_is(rc, caddr, KernelRoleSpec::role_nat_add()) { + 0 => { (0, head, (&(Lists::Node::Nil))) } , + _ => { + match Lists::length(args) - 2 { + 0 => { + let lhs = Lists::lookup(args, 0); + let rhs = Lists::lookup(args, 1); + match (*(rhs)) { + KernelTypes::KExprNode::Lit(lit) => { + match lit { + KernelTypes::KLiteral::Nat(limbs) => { (1, lhs, limbs) } , + _ => { (0, head, (&(Lists::Node::Nil))) } , + } } , + _ => { (0, head, (&(Lists::Node::Nil))) } , + } } , + _ => { (0, head, (&(Lists::Node::Nil))) } , + } } , + } } , + _ => { (0, head, (&(Lists::Node::Nil))) } , + } + } + + fn build_succ_offset(rc: KernelRoles::RoleCtx, base: KernelTypes::KExpr, lit: KernelTypes::KLimbs) -> KernelTypes::KExpr { + let one = (&(Lists::Node::Cons([UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], + (&(Lists::Node::Nil))))); + let pred_lit_norm = KernelKlimbs::klimbs_normalize(KernelKlimbs::klimbs_sub(lit, one)); + let succ_const = (&(KernelTypes::KExprNode::Const(KernelRoles::role_addr(rc, KernelRoleSpec::role_nat_succ()), (&(Lists::Node::Nil))))); + match KernelKlimbs::klimbs_is_zero(pred_lit_norm) { + 1 => { (&(KernelTypes::KExprNode::App(succ_const, base))) } , + _ => { + let add_const = (&(KernelTypes::KExprNode::Const(KernelRoles::role_addr(rc, KernelRoleSpec::role_nat_add()), (&(Lists::Node::Nil))))); + let pred_lit_expr = (&(KernelTypes::KExprNode::Lit(KernelTypes::KLiteral::Nat(pred_lit_norm)))); + let pred = (&(KernelTypes::KExprNode::App( + (&(KernelTypes::KExprNode::App(add_const, base))), + pred_lit_expr))); + (&(KernelTypes::KExprNode::App(succ_const, pred))) } , + } + } + + fn cleanup_nat_offset_major(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr) -> KernelTypes::KExpr { + match (*(e)) { + KernelTypes::KExprNode::Lit(_) => { e } , + _ => { + match KernelTypes::collect_spine(e) { + (head, args) => { + match (*(head)) { + KernelTypes::KExprNode::Const(_, _) => { + match try_match_nat_add(rc, head, args) { + (1, base, lit) => { + let lit_norm = KernelKlimbs::klimbs_normalize(lit); + match KernelKlimbs::klimbs_is_zero(lit_norm) { + 1 => { e } , + _ => { build_succ_offset(rc, base, lit_norm) } , + } } , + _ => { e } , + } } , + _ => { e } , + } } , + } } , + } + } + + fn mk_nat_offset_stuck(rc: KernelRoles::RoleCtx, base_w: KernelTypes::KExpr, n: KernelTypes::KLimbs, + post: Lists::List) -> (Field, KernelTypes::KExpr) { + match KernelKlimbs::klimbs_is_zero(n) { + 1 => { (1, np_apply_spine(base_w, post)) } , + _ => { + let add_const = (&(KernelTypes::KExprNode::Const(KernelRoles::role_addr(rc, KernelRoleSpec::role_nat_add()), (&(Lists::Node::Nil))))); + let off = (&(KernelTypes::KExprNode::App( + (&(KernelTypes::KExprNode::App(add_const, base_w))), + mk_nat_lit(n)))); + (1, np_apply_spine(off, post)) } , + } + } + + fn is_nat_succ_ih_step(rc: KernelRoles::RoleCtx, step: KernelTypes::KExpr) -> Field { + match (*(step)) { + KernelTypes::KExprNode::Lam(_, body1) => { + match (*(body1)) { + KernelTypes::KExprNode::Lam(_, body2) => { + match KernelTypes::collect_spine(body2) { + (head, args) => { + match (*(head)) { + KernelTypes::KExprNode::Const(caddr, _) => { + match KernelRoles::role_is(rc, caddr, KernelRoleSpec::role_nat_succ()) { + 0 => { 0 } , + _ => { + match Lists::length(args) - 1 { + 0 => { + match (*(Lists::lookup(args, 0))) { + KernelTypes::KExprNode::BVar(i) => { Fields::is_zero(i) } , + _ => { 0 } , + } } , + _ => { 0 } , + } } , + } } , + _ => { 0 } , + } } , + } } , + _ => { 0 } , + } } , + _ => { 0 } , + } + } + + fn try_nat_linear_rec(rc: KernelRoles::RoleCtx, spine: Lists::List, nparams: Field, nmotives: Field, + nminors: Field, major_idx: Field) -> (Field, KernelTypes::KExpr) { + match UInt32::less_than_fields(nminors, 2) { + 1 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + let raw_major = Lists::lookup(spine, major_idx); + match try_extract_nat(rc, raw_major) { + (0, _) => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + (1, n_klimbs) => { + let base_idx = nparams + nmotives; + let step = Lists::lookup(spine, base_idx + 1); + match is_nat_succ_ih_step(rc, step) { + 0 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + let base = Lists::lookup(spine, base_idx); + let post = Lists::drop(spine, major_idx + 1); + match try_extract_nat(rc, base) { + (1, b_klimbs) => { + (1, np_apply_spine(mk_nat_lit(KernelKlimbs::klimbs_add(b_klimbs, n_klimbs)), post)) } , + _ => { mk_nat_offset_stuck(rc, base, n_klimbs, post) } , + } } , + } } , + } } , + } + } + + inline fn try_nat_dispatch(rc: KernelRoles::RoleCtx, head_addr: Bytes::AddressRef, op: Field, spine: Lists::List, + types: Lists::List) -> (Field, KernelTypes::KExpr) { + let spine_len = Lists::length(spine); + match op { + 1 => { + match UInt32::less_than_fields(spine_len, 1) { + 1 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + let a0 = Lists::lookup(spine, 0); + match try_extract_nat(rc, a0) { + (1, na) => { + let post = Lists::drop(spine, 1); + (1, np_apply_spine(mk_nat_lit(KernelKlimbs::klimbs_succ(na)), post)) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + } } , + 2 => { + match UInt32::less_than_fields(spine_len, 1) { + 1 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + let a0 = Lists::lookup(spine, 0); + match try_extract_nat(rc, a0) { + (1, na) => { + let post = Lists::drop(spine, 1); + (1, np_apply_spine(mk_nat_lit(KernelKlimbs::klimbs_normalize(KernelKlimbs::klimbs_dec(na))), post)) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + } } , + _ => { try_nat_binop_dispatch(rc, head_addr, op, spine, spine_len) } , + } + } + + fn try_nat_binop_dispatch(rc: KernelRoles::RoleCtx, head_addr: Bytes::AddressRef, op: Field, spine: Lists::List, + spine_len: Field) -> (Field, KernelTypes::KExpr) { + match UInt32::less_than_fields(spine_len, 2) { + 1 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + let a0 = Lists::lookup(spine, 0); + let a1 = Lists::lookup(spine, 1); + match try_extract_nat(rc, a0) { + (1, na) => { + match try_extract_nat(rc, a1) { + (1, nb) => { + match try_nat_binop_addr(rc, op, na, nb) { + (1, result) => { + let post = Lists::drop(spine, 2); + (1, np_apply_spine(result, post)) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { + + match try_extract_nat(rc, a1) { + (1, nb) => { + try_nat_offset_dispatch(rc, head_addr, op, a0, nb, spine) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + } } , + } + } + + fn try_nat_offset_dispatch(rc: KernelRoles::RoleCtx, head_addr: Bytes::AddressRef, op: Field, a0_w: KernelTypes::KExpr, nb: KernelTypes::KLimbs, + spine: Lists::List) -> (Field, KernelTypes::KExpr) { + let post = Lists::drop(spine, 2); + + match op { + 3 => { + match mk_nat_offset_stuck(rc, a0_w, nb, post) { + (1, stuck) => { (2, stuck) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + 6 | 7 => { + let ge_two = (1 - KernelKlimbs::klimbs_is_zero(nb)) + * (1 - KernelKlimbs::klimbs_is_zero(KernelKlimbs::klimbs_normalize(KernelKlimbs::klimbs_dec(nb)))); + match ge_two { + 0 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { (2, mk_nat_binop_stuck(head_addr, a0_w, nb, post)) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } + } + + fn mk_nat_binop_stuck(op_addr: Bytes::AddressRef, base_w: KernelTypes::KExpr, n: KernelTypes::KLimbs, + post: Lists::List) -> KernelTypes::KExpr { + let op_const = (&(KernelTypes::KExprNode::Const(op_addr, (&(Lists::Node::Nil))))); + let stuck = (&(KernelTypes::KExprNode::App( + (&(KernelTypes::KExprNode::App(op_const, base_w))), + mk_nat_lit(n)))); + np_apply_spine(stuck, post) + } +} diff --git a/IxVM/IxVM/Modules/KernelRoleSpec.aiur b/IxVM/IxVM/Modules/KernelRoleSpec.aiur new file mode 100644 index 000000000..a0fea8cb0 --- /dev/null +++ b/IxVM/IxVM/Modules/KernelRoleSpec.aiur @@ -0,0 +1,2408 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module KernelRoleSpec { + inline fn spec_version() -> Field { + 3 + } + + inline fn spec_digest() -> Bytes::AddressRef { + (&([UInt8::BYTE_109, UInt8::BYTE_2, UInt8::BYTE_21, UInt8::BYTE_62, UInt8::BYTE_163, UInt8::BYTE_17, UInt8::BYTE_243, UInt8::BYTE_239, UInt8::BYTE_209, UInt8::BYTE_119, UInt8::BYTE_140, UInt8::BYTE_73, UInt8::BYTE_178, UInt8::BYTE_238, UInt8::BYTE_95, UInt8::BYTE_49, UInt8::BYTE_231, UInt8::BYTE_154, UInt8::BYTE_11, UInt8::BYTE_174, UInt8::BYTE_149, UInt8::BYTE_229, UInt8::BYTE_51, UInt8::BYTE_160, UInt8::BYTE_141, UInt8::BYTE_73, UInt8::BYTE_20, UInt8::BYTE_252, UInt8::BYTE_5, UInt8::BYTE_87, UInt8::BYTE_45, UInt8::BYTE_51])) + } + + inline fn role_count() -> Field { + 103 + } + + inline fn group_count() -> Field { + 72 + } + + inline fn first_well_founded_group() -> Field { + 33 + } + + inline fn first_equation_group() -> Field { + 41 + } + + inline fn role_nat() -> Field { + 0 + } + + inline fn role_nat_zero() -> Field { + 1 + } + + inline fn role_nat_succ() -> Field { + 2 + } + + inline fn role_bool() -> Field { + 4 + } + + inline fn role_bool_false() -> Field { + 5 + } + + inline fn role_bool_true() -> Field { + 6 + } + + inline fn role_eq() -> Field { + 8 + } + + inline fn role_eq_refl() -> Field { + 9 + } + + inline fn role_list_nil() -> Field { + 30 + } + + inline fn role_list_cons() -> Field { + 31 + } + + inline fn role_quot() -> Field { + 32 + } + + inline fn role_quot_mk() -> Field { + 33 + } + + inline fn role_quot_lift() -> Field { + 34 + } + + inline fn role_quot_ind() -> Field { + 35 + } + + inline fn role_quot_sound() -> Field { + 36 + } + + inline fn role_string() -> Field { + 37 + } + + inline fn role_string_of_list() -> Field { + 38 + } + + inline fn role_char() -> Field { + 39 + } + + inline fn role_char_of_nat() -> Field { + 40 + } + + inline fn role_nat_add() -> Field { + 42 + } + + inline fn role_propext() -> Field { + 56 + } + + inline fn role_choice() -> Field { + 57 + } + + inline fn role_sorry_ax() -> Field { + 58 + } + + inline fn role_decidable_is_true() -> Field { + 60 + } + + inline fn role_decidable_is_false() -> Field { + 61 + } + + inline fn role_of_decide_eq_true() -> Field { + 63 + } + + inline fn role_of_decide_eq_false() -> Field { + 64 + } + + inline fn role_nat_le() -> Field { + 66 + } + + inline fn role_nat_dec_le() -> Field { + 68 + } + + inline fn role_int() -> Field { + 70 + } + + inline fn role_int_of_nat() -> Field { + 71 + } + + inline fn role_int_neg_succ() -> Field { + 72 + } + + inline fn role_bit_vec_of_nat() -> Field { + 84 + } + + inline fn role_byte_array_empty() -> Field { + 89 + } + + inline fn role_int_le() -> Field { + 94 + } + + inline fn role_int_dec_le() -> Field { + 96 + } + + fn role_group(r: Field) -> Field { + match r { + 4 => { 11 } , + 5 => { 11 } , + 6 => { 11 } , + 7 => { 11 } , + 8 => { 1 } , + 9 => { 1 } , + 10 => { 1 } , + 11 => { 2 } , + 12 => { 2 } , + 13 => { 2 } , + 14 => { 3 } , + 15 => { 3 } , + 16 => { 4 } , + 17 => { 4 } , + 18 => { 19 } , + 19 => { 19 } , + 20 => { 20 } , + 21 => { 20 } , + 22 => { 20 } , + 23 => { 21 } , + 24 => { 21 } , + 25 => { 21 } , + 26 => { 22 } , + 27 => { 22 } , + 28 => { 22 } , + 29 => { 8 } , + 30 => { 8 } , + 31 => { 8 } , + 32 => { 5 } , + 33 => { 5 } , + 34 => { 5 } , + 35 => { 5 } , + 36 => { 5 } , + 37 => { 7 } , + 38 => { 10 } , + 39 => { 6 } , + 40 => { 9 } , + 41 => { 12 } , + 42 => { 13 } , + 43 => { 14 } , + 44 => { 15 } , + 45 => { 16 } , + 46 => { 17 } , + 47 => { 18 } , + 48 => { 33 } , + 49 => { 34 } , + 50 => { 35 } , + 51 => { 36 } , + 52 => { 37 } , + 53 => { 38 } , + 54 => { 39 } , + 55 => { 40 } , + 56 => { 23 } , + 57 => { 24 } , + 58 => { 25 } , + 59 => { 27 } , + 60 => { 27 } , + 61 => { 27 } , + 62 => { 26 } , + 63 => { 42 } , + 64 => { 43 } , + 65 => { 41 } , + 66 => { 28 } , + 67 => { 44 } , + 68 => { 45 } , + 69 => { 46 } , + 70 => { 29 } , + 71 => { 29 } , + 72 => { 29 } , + 73 => { 47 } , + 74 => { 48 } , + 75 => { 49 } , + 76 => { 50 } , + 77 => { 51 } , + 78 => { 52 } , + 79 => { 53 } , + 80 => { 54 } , + 81 => { 55 } , + 82 => { 56 } , + 83 => { 31 } , + 84 => { 31 } , + 85 => { 57 } , + 86 => { 58 } , + 87 => { 59 } , + 88 => { 32 } , + 89 => { 32 } , + 90 => { 60 } , + 91 => { 61 } , + 92 => { 62 } , + 93 => { 63 } , + 94 => { 30 } , + 95 => { 64 } , + 96 => { 65 } , + 97 => { 66 } , + 98 => { 67 } , + 99 => { 68 } , + 100 => { 69 } , + 101 => { 70 } , + 102 => { 71 } , + _ => { 0 } , + } + } + + fn group_roles(g: Field) -> Lists::List { + match g { + 0 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(1, (&(Lists::Node::Cons(2, (&(Lists::Node::Cons(3, (&(Lists::Node::Nil)))))))))))))) } , + 1 => { (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(9, (&(Lists::Node::Cons(10, (&(Lists::Node::Nil))))))))))) } , + 2 => { (&(Lists::Node::Cons(11, (&(Lists::Node::Cons(12, (&(Lists::Node::Cons(13, (&(Lists::Node::Nil))))))))))) } , + 3 => { (&(Lists::Node::Cons(14, (&(Lists::Node::Cons(15, (&(Lists::Node::Nil)))))))) } , + 4 => { (&(Lists::Node::Cons(16, (&(Lists::Node::Cons(17, (&(Lists::Node::Nil)))))))) } , + 5 => { (&(Lists::Node::Cons(32, (&(Lists::Node::Cons(33, (&(Lists::Node::Cons(34, (&(Lists::Node::Cons(35, (&(Lists::Node::Cons(36, (&(Lists::Node::Nil))))))))))))))))) } , + 6 => { (&(Lists::Node::Cons(39, (&(Lists::Node::Nil))))) } , + 7 => { (&(Lists::Node::Cons(37, (&(Lists::Node::Nil))))) } , + 8 => { (&(Lists::Node::Cons(29, (&(Lists::Node::Cons(30, (&(Lists::Node::Cons(31, (&(Lists::Node::Nil))))))))))) } , + 9 => { (&(Lists::Node::Cons(40, (&(Lists::Node::Nil))))) } , + 10 => { (&(Lists::Node::Cons(38, (&(Lists::Node::Nil))))) } , + 11 => { (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(5, (&(Lists::Node::Cons(6, (&(Lists::Node::Cons(7, (&(Lists::Node::Nil)))))))))))))) } , + 12 => { (&(Lists::Node::Cons(41, (&(Lists::Node::Nil))))) } , + 13 => { (&(Lists::Node::Cons(42, (&(Lists::Node::Nil))))) } , + 14 => { (&(Lists::Node::Cons(43, (&(Lists::Node::Nil))))) } , + 15 => { (&(Lists::Node::Cons(44, (&(Lists::Node::Nil))))) } , + 16 => { (&(Lists::Node::Cons(45, (&(Lists::Node::Nil))))) } , + 17 => { (&(Lists::Node::Cons(46, (&(Lists::Node::Nil))))) } , + 18 => { (&(Lists::Node::Cons(47, (&(Lists::Node::Nil))))) } , + 19 => { (&(Lists::Node::Cons(18, (&(Lists::Node::Cons(19, (&(Lists::Node::Nil)))))))) } , + 20 => { (&(Lists::Node::Cons(20, (&(Lists::Node::Cons(21, (&(Lists::Node::Cons(22, (&(Lists::Node::Nil))))))))))) } , + 21 => { (&(Lists::Node::Cons(23, (&(Lists::Node::Cons(24, (&(Lists::Node::Cons(25, (&(Lists::Node::Nil))))))))))) } , + 22 => { (&(Lists::Node::Cons(26, (&(Lists::Node::Cons(27, (&(Lists::Node::Cons(28, (&(Lists::Node::Nil))))))))))) } , + 23 => { (&(Lists::Node::Cons(56, (&(Lists::Node::Nil))))) } , + 24 => { (&(Lists::Node::Cons(57, (&(Lists::Node::Nil))))) } , + 25 => { (&(Lists::Node::Cons(58, (&(Lists::Node::Nil))))) } , + 26 => { (&(Lists::Node::Cons(62, (&(Lists::Node::Nil))))) } , + 27 => { (&(Lists::Node::Cons(59, (&(Lists::Node::Cons(60, (&(Lists::Node::Cons(61, (&(Lists::Node::Nil))))))))))) } , + 28 => { (&(Lists::Node::Cons(66, (&(Lists::Node::Nil))))) } , + 29 => { (&(Lists::Node::Cons(70, (&(Lists::Node::Cons(71, (&(Lists::Node::Cons(72, (&(Lists::Node::Nil))))))))))) } , + 30 => { (&(Lists::Node::Cons(94, (&(Lists::Node::Nil))))) } , + 31 => { (&(Lists::Node::Cons(83, (&(Lists::Node::Cons(84, (&(Lists::Node::Nil)))))))) } , + 32 => { (&(Lists::Node::Cons(88, (&(Lists::Node::Cons(89, (&(Lists::Node::Nil)))))))) } , + 33 => { (&(Lists::Node::Cons(48, (&(Lists::Node::Nil))))) } , + 34 => { (&(Lists::Node::Cons(49, (&(Lists::Node::Nil))))) } , + 35 => { (&(Lists::Node::Cons(50, (&(Lists::Node::Nil))))) } , + 36 => { (&(Lists::Node::Cons(51, (&(Lists::Node::Nil))))) } , + 37 => { (&(Lists::Node::Cons(52, (&(Lists::Node::Nil))))) } , + 38 => { (&(Lists::Node::Cons(53, (&(Lists::Node::Nil))))) } , + 39 => { (&(Lists::Node::Cons(54, (&(Lists::Node::Nil))))) } , + 40 => { (&(Lists::Node::Cons(55, (&(Lists::Node::Nil))))) } , + 41 => { (&(Lists::Node::Cons(65, (&(Lists::Node::Nil))))) } , + 42 => { (&(Lists::Node::Cons(63, (&(Lists::Node::Nil))))) } , + 43 => { (&(Lists::Node::Cons(64, (&(Lists::Node::Nil))))) } , + 44 => { (&(Lists::Node::Cons(67, (&(Lists::Node::Nil))))) } , + 45 => { (&(Lists::Node::Cons(68, (&(Lists::Node::Nil))))) } , + 46 => { (&(Lists::Node::Cons(69, (&(Lists::Node::Nil))))) } , + 47 => { (&(Lists::Node::Cons(73, (&(Lists::Node::Nil))))) } , + 48 => { (&(Lists::Node::Cons(74, (&(Lists::Node::Nil))))) } , + 49 => { (&(Lists::Node::Cons(75, (&(Lists::Node::Nil))))) } , + 50 => { (&(Lists::Node::Cons(76, (&(Lists::Node::Nil))))) } , + 51 => { (&(Lists::Node::Cons(77, (&(Lists::Node::Nil))))) } , + 52 => { (&(Lists::Node::Cons(78, (&(Lists::Node::Nil))))) } , + 53 => { (&(Lists::Node::Cons(79, (&(Lists::Node::Nil))))) } , + 54 => { (&(Lists::Node::Cons(80, (&(Lists::Node::Nil))))) } , + 55 => { (&(Lists::Node::Cons(81, (&(Lists::Node::Nil))))) } , + 56 => { (&(Lists::Node::Cons(82, (&(Lists::Node::Nil))))) } , + 57 => { (&(Lists::Node::Cons(85, (&(Lists::Node::Nil))))) } , + 58 => { (&(Lists::Node::Cons(86, (&(Lists::Node::Nil))))) } , + 59 => { (&(Lists::Node::Cons(87, (&(Lists::Node::Nil))))) } , + 60 => { (&(Lists::Node::Cons(90, (&(Lists::Node::Nil))))) } , + 61 => { (&(Lists::Node::Cons(91, (&(Lists::Node::Nil))))) } , + 62 => { (&(Lists::Node::Cons(92, (&(Lists::Node::Nil))))) } , + 63 => { (&(Lists::Node::Cons(93, (&(Lists::Node::Nil))))) } , + 64 => { (&(Lists::Node::Cons(95, (&(Lists::Node::Nil))))) } , + 65 => { (&(Lists::Node::Cons(96, (&(Lists::Node::Nil))))) } , + 66 => { (&(Lists::Node::Cons(97, (&(Lists::Node::Nil))))) } , + 67 => { (&(Lists::Node::Cons(98, (&(Lists::Node::Nil))))) } , + 68 => { (&(Lists::Node::Cons(99, (&(Lists::Node::Nil))))) } , + 69 => { (&(Lists::Node::Cons(100, (&(Lists::Node::Nil))))) } , + 70 => { (&(Lists::Node::Cons(101, (&(Lists::Node::Nil))))) } , + 71 => { (&(Lists::Node::Cons(102, (&(Lists::Node::Nil))))) } , + _ => { (&(Lists::Node::Nil)) } , + } + } + + fn group_needs(g: Field) -> Lists::List { + match g { + 5 => { (&(Lists::Node::Cons(8, (&(Lists::Node::Nil))))) } , + 9 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(39, (&(Lists::Node::Nil)))))))) } , + 10 => { (&(Lists::Node::Cons(29, (&(Lists::Node::Cons(39, (&(Lists::Node::Cons(37, (&(Lists::Node::Nil))))))))))) } , + 12 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Nil))))) } , + 13 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Nil))))) } , + 14 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(41, (&(Lists::Node::Nil)))))))) } , + 15 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(42, (&(Lists::Node::Nil)))))))) } , + 16 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(42, (&(Lists::Node::Cons(44, (&(Lists::Node::Nil))))))))))) } , + 17 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(4, (&(Lists::Node::Nil)))))))) } , + 18 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(4, (&(Lists::Node::Nil)))))))) } , + 23 => { (&(Lists::Node::Cons(23, (&(Lists::Node::Cons(8, (&(Lists::Node::Nil)))))))) } , + 24 => { (&(Lists::Node::Cons(26, (&(Lists::Node::Nil))))) } , + 25 => { (&(Lists::Node::Cons(4, (&(Lists::Node::Nil))))) } , + 27 => { (&(Lists::Node::Cons(62, (&(Lists::Node::Nil))))) } , + 28 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Nil))))) } , + 29 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Nil))))) } , + 30 => { (&(Lists::Node::Cons(70, (&(Lists::Node::Nil))))) } , + 31 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Nil))))) } , + 33 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(41, (&(Lists::Node::Cons(43, (&(Lists::Node::Cons(47, (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(8, (&(Lists::Node::Nil)))))))))))))))))))) } , + 34 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(41, (&(Lists::Node::Cons(43, (&(Lists::Node::Cons(47, (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(8, (&(Lists::Node::Nil)))))))))))))))))))) } , + 35 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(47, (&(Lists::Node::Cons(49, (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(8, (&(Lists::Node::Nil))))))))))))))))) } , + 36 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(42, (&(Lists::Node::Cons(44, (&(Lists::Node::Cons(47, (&(Lists::Node::Cons(48, (&(Lists::Node::Cons(49, (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(8, (&(Lists::Node::Nil)))))))))))))))))))))))))) } , + 37 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(42, (&(Lists::Node::Cons(43, (&(Lists::Node::Cons(44, (&(Lists::Node::Cons(47, (&(Lists::Node::Cons(48, (&(Lists::Node::Cons(49, (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(8, (&(Lists::Node::Nil))))))))))))))))))))))))))))) } , + 38 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(42, (&(Lists::Node::Cons(44, (&(Lists::Node::Cons(47, (&(Lists::Node::Cons(48, (&(Lists::Node::Cons(49, (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(8, (&(Lists::Node::Nil)))))))))))))))))))))))))) } , + 39 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(43, (&(Lists::Node::Cons(44, (&(Lists::Node::Cons(47, (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(8, (&(Lists::Node::Nil)))))))))))))))))))) } , + 40 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(43, (&(Lists::Node::Cons(47, (&(Lists::Node::Cons(48, (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(8, (&(Lists::Node::Nil)))))))))))))))))))) } , + 41 => { (&(Lists::Node::Cons(59, (&(Lists::Node::Cons(62, (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(8, (&(Lists::Node::Nil)))))))))))))) } , + 42 => { (&(Lists::Node::Cons(59, (&(Lists::Node::Cons(65, (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(8, (&(Lists::Node::Nil)))))))))))))) } , + 43 => { (&(Lists::Node::Cons(59, (&(Lists::Node::Cons(65, (&(Lists::Node::Cons(62, (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(8, (&(Lists::Node::Nil))))))))))))))))) } , + 44 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(59, (&(Lists::Node::Cons(65, (&(Lists::Node::Cons(46, (&(Lists::Node::Nil)))))))))))))))))))) } , + 45 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(59, (&(Lists::Node::Cons(65, (&(Lists::Node::Cons(66, (&(Lists::Node::Cons(47, (&(Lists::Node::Nil))))))))))))))))))))))) } , + 46 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(59, (&(Lists::Node::Cons(66, (&(Lists::Node::Cons(68, (&(Lists::Node::Nil))))))))))))))))) } , + 47 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(70, (&(Lists::Node::Cons(8, (&(Lists::Node::Nil))))))))))) } , + 48 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(70, (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(41, (&(Lists::Node::Cons(43, (&(Lists::Node::Cons(47, (&(Lists::Node::Nil))))))))))))))))))))))) } , + 49 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(70, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(73, (&(Lists::Node::Nil)))))))))))))) } , + 50 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(70, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(42, (&(Lists::Node::Cons(74, (&(Lists::Node::Nil))))))))))))))))) } , + 51 => { (&(Lists::Node::Cons(70, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(76, (&(Lists::Node::Cons(75, (&(Lists::Node::Nil)))))))))))))) } , + 52 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(70, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(44, (&(Lists::Node::Cons(73, (&(Lists::Node::Nil))))))))))))))))) } , + 53 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(70, (&(Lists::Node::Cons(8, (&(Lists::Node::Nil))))))))))) } , + 54 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(70, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(48, (&(Lists::Node::Cons(75, (&(Lists::Node::Nil))))))))))))))))) } , + 55 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(70, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(49, (&(Lists::Node::Cons(74, (&(Lists::Node::Nil))))))))))))))))) } , + 56 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(70, (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(45, (&(Lists::Node::Cons(49, (&(Lists::Node::Cons(46, (&(Lists::Node::Cons(75, (&(Lists::Node::Nil)))))))))))))))))))))))))) } , + 57 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(83, (&(Lists::Node::Cons(49, (&(Lists::Node::Cons(45, (&(Lists::Node::Nil))))))))))))))))) } , + 58 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(83, (&(Lists::Node::Cons(49, (&(Lists::Node::Cons(45, (&(Lists::Node::Cons(47, (&(Lists::Node::Nil))))))))))))))))))))))) } , + 59 => { (&(Lists::Node::Cons(37, (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(59, (&(Lists::Node::Cons(65, (&(Lists::Node::Nil))))))))))))))))) } , + 60 => { (&(Lists::Node::Cons(37, (&(Lists::Node::Cons(29, (&(Lists::Node::Cons(39, (&(Lists::Node::Cons(38, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(88, (&(Lists::Node::Nil)))))))))))))))))))) } , + 61 => { (&(Lists::Node::Cons(29, (&(Lists::Node::Cons(8, (&(Lists::Node::Nil)))))))) } , + 62 => { (&(Lists::Node::Cons(37, (&(Lists::Node::Cons(29, (&(Lists::Node::Cons(39, (&(Lists::Node::Cons(38, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(91, (&(Lists::Node::Nil)))))))))))))))))))) } , + 63 => { (&(Lists::Node::Cons(59, (&(Lists::Node::Cons(62, (&(Lists::Node::Cons(8, (&(Lists::Node::Nil))))))))))) } , + 64 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(70, (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(59, (&(Lists::Node::Cons(65, (&(Lists::Node::Cons(46, (&(Lists::Node::Nil))))))))))))))))))))))) } , + 65 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(70, (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(59, (&(Lists::Node::Cons(65, (&(Lists::Node::Cons(94, (&(Lists::Node::Cons(47, (&(Lists::Node::Nil)))))))))))))))))))))))))) } , + 66 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(70, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(59, (&(Lists::Node::Cons(94, (&(Lists::Node::Cons(76, (&(Lists::Node::Cons(96, (&(Lists::Node::Nil))))))))))))))))))))))) } , + 67 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(70, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(93, (&(Lists::Node::Cons(94, (&(Lists::Node::Cons(76, (&(Lists::Node::Cons(77, (&(Lists::Node::Cons(80, (&(Lists::Node::Cons(81, (&(Lists::Node::Cons(97, (&(Lists::Node::Nil)))))))))))))))))))))))))))))))) } , + 68 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(70, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(93, (&(Lists::Node::Cons(94, (&(Lists::Node::Cons(76, (&(Lists::Node::Cons(80, (&(Lists::Node::Cons(81, (&(Lists::Node::Cons(97, (&(Lists::Node::Cons(67, (&(Lists::Node::Nil)))))))))))))))))))))))))))))))) } , + 69 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(39, (&(Lists::Node::Cons(40, (&(Lists::Node::Cons(4, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(44, (&(Lists::Node::Cons(47, (&(Lists::Node::Nil))))))))))))))))))))))) } , + 70 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(37, (&(Lists::Node::Cons(29, (&(Lists::Node::Cons(39, (&(Lists::Node::Cons(38, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(42, (&(Lists::Node::Cons(100, (&(Lists::Node::Nil)))))))))))))))))))))))))) } , + 71 => { (&(Lists::Node::Cons(0, (&(Lists::Node::Cons(37, (&(Lists::Node::Cons(29, (&(Lists::Node::Cons(39, (&(Lists::Node::Cons(40, (&(Lists::Node::Cons(38, (&(Lists::Node::Cons(8, (&(Lists::Node::Cons(44, (&(Lists::Node::Nil)))))))))))))))))))))))))) } , + _ => { (&(Lists::Node::Nil)) } , + } + } + + fn role_spec_kind(r: Field) -> Field { + match r { + 4 => { 1 } , + 5 => { 1 } , + 6 => { 1 } , + 7 => { 1 } , + 18 => { 1 } , + 19 => { 1 } , + 20 => { 1 } , + 21 => { 1 } , + 22 => { 1 } , + 29 => { 1 } , + 30 => { 1 } , + 31 => { 1 } , + 37 => { 1 } , + 38 => { 1 } , + 39 => { 1 } , + 40 => { 1 } , + 41 => { 2 } , + 42 => { 2 } , + 43 => { 2 } , + 44 => { 2 } , + 45 => { 2 } , + 46 => { 2 } , + 47 => { 2 } , + 48 => { 2 } , + 49 => { 2 } , + 50 => { 2 } , + 51 => { 2 } , + 52 => { 2 } , + 53 => { 2 } , + 54 => { 2 } , + 55 => { 2 } , + 56 => { 3 } , + 57 => { 3 } , + 58 => { 4 } , + 59 => { 1 } , + 60 => { 1 } , + 61 => { 1 } , + 62 => { 1 } , + 63 => { 1 } , + 64 => { 1 } , + 65 => { 5 } , + 66 => { 1 } , + 67 => { 5 } , + 68 => { 5 } , + 69 => { 5 } , + 70 => { 1 } , + 71 => { 1 } , + 72 => { 1 } , + 73 => { 5 } , + 74 => { 5 } , + 75 => { 5 } , + 76 => { 5 } , + 77 => { 5 } , + 78 => { 5 } , + 79 => { 5 } , + 80 => { 5 } , + 81 => { 5 } , + 82 => { 5 } , + 83 => { 1 } , + 84 => { 1 } , + 85 => { 5 } , + 86 => { 5 } , + 87 => { 5 } , + 88 => { 1 } , + 89 => { 1 } , + 90 => { 5 } , + 91 => { 5 } , + 92 => { 5 } , + 93 => { 5 } , + 94 => { 1 } , + 95 => { 5 } , + 96 => { 5 } , + 97 => { 5 } , + 98 => { 5 } , + 99 => { 5 } , + 100 => { 5 } , + 101 => { 5 } , + 102 => { 5 } , + _ => { 0 } , + } + } + + fn role_levels(r: Field) -> Field { + match r { + 3 => { 1 } , + 7 => { 1 } , + 8 => { 1 } , + 9 => { 1 } , + 10 => { 2 } , + 11 => { 1 } , + 12 => { 1 } , + 13 => { 2 } , + 15 => { 1 } , + 17 => { 1 } , + 22 => { 1 } , + 25 => { 1 } , + 26 => { 1 } , + 27 => { 1 } , + 28 => { 1 } , + 29 => { 1 } , + 30 => { 1 } , + 31 => { 1 } , + 32 => { 1 } , + 33 => { 1 } , + 34 => { 2 } , + 35 => { 1 } , + 36 => { 1 } , + 57 => { 1 } , + 58 => { 1 } , + 91 => { 1 } , + 93 => { 1 } , + _ => { 0 } , + } + } + + fn role_member_kind(r: Field) -> Field { + match r { + 1 => { 1 } , + 2 => { 1 } , + 3 => { 2 } , + 9 => { 1 } , + 10 => { 2 } , + 12 => { 1 } , + 13 => { 2 } , + 15 => { 2 } , + 17 => { 2 } , + 24 => { 1 } , + 25 => { 2 } , + 27 => { 1 } , + 28 => { 2 } , + 32 => { 4 } , + 33 => { 5 } , + 34 => { 6 } , + 35 => { 7 } , + 36 => { 3 } , + _ => { 0 } , + } + } + + fn role_ctor_of(r: Field) -> (Field, Field, Field, Field) { + match r { + 2 => { (0, 1, 0, 1) } , + 9 => { (8, 0, 2, 0) } , + 12 => { (11, 0, 0, 0) } , + 24 => { (23, 0, 2, 2) } , + 27 => { (26, 0, 1, 1) } , + _ => { (0, 0, 0, 0) } , + } + } + + fn role_ctor_count(r: Field) -> Field { + match r { + 0 => { 2 } , + 8 => { 1 } , + 11 => { 1 } , + 23 => { 1 } , + 26 => { 1 } , + _ => { 0 } , + } + } + + fn role_type(tbl: KernelRoles::RoleTable, r: Field) -> KernelTypes::KExpr { + match r { + 0 => { (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero)))))))) } , + 1 => { (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))) } , + 2 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, x0))) } , + 3 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(0))); + let x3 = (&(KernelTypes::KExprNode::BVar(3))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Param(0))))))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::BVar(2))), x2))), (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(1))))))))))))))), (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App(x3, x2))))))))))))))) } , + 4 => { (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero)))))))) } , + 5 => { (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), (&(Lists::Node::Nil))))) } , + 6 => { (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), (&(Lists::Node::Nil))))) } , + 7 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Param(0))))))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0)))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::BVar(1))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0)))))), (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::BVar(3))), x2))))))))))))))) } , + 8 => { (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Param(0)))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::BVar(0))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::BVar(1))), (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero)))))))))))))) } , + 9 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + let x1 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt(x0))), (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons(x0, (&(Lists::Node::Nil)))))))), (&(KernelTypes::KExprNode::BVar(1)))))), x1))), x1))))))))) } , + 10 => { + let x0 = (&(KernelTypes::KLevelNode::Param(1))); + let x1 = (&(KernelTypes::KExprNode::BVar(0))); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + let x3 = (&(Lists::Node::Cons(x0, (&(Lists::Node::Nil))))); + let x4 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), x3))); + let x5 = (&(KernelTypes::KExprNode::BVar(2))); + let x6 = (&(KernelTypes::KExprNode::BVar(3))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt(x0))), (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall(x2, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x4, x5))), x2))), x1))), (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Param(0)))))))))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x1, x2))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 9), x3))), x5))), x2)))))), (&(KernelTypes::KExprNode::Forall(x6, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::BVar(4)))))), x6))), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x6, x2))), x1))))))))))))))))))))) } , + 11 => { (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Param(0)))))) } , + 12 => { (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 11), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Param(0))), (&(Lists::Node::Nil)))))))) } , + 13 => { + let x0 = (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Param(1))), (&(Lists::Node::Nil))))); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 11), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Param(0))))))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 12), x0)))))), (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::BVar(2))), x2)))))))))))) } , + 14 => { (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero)))))))) } , + 15 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 14), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Param(0))))))))), (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::BVar(1))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 17 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 16), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Param(0))))))))), (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::BVar(1))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 19 => { (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 18), (&(Lists::Node::Nil))))) } , + 20 => { + let x0 = (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, x0)))))) } , + 21 => { + let x0 = (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))); + let x1 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 20), (&(Lists::Node::Nil))))), (&(KernelTypes::KExprNode::BVar(3)))))), (&(KernelTypes::KExprNode::BVar(2)))))))))))))))))) } , + 22 => { + let x0 = (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))); + let x1 = (&(Lists::Node::Nil)); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 20), x1))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::BVar(0))); + let x5 = (&(KernelTypes::KExprNode::BVar(2))); + let x6 = (&(KernelTypes::KExprNode::BVar(3))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x3))), x4))), (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Param(0))))))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall(x5, (&(KernelTypes::KExprNode::Forall(x5, (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 21), x1))), (&(KernelTypes::KExprNode::BVar(4)))))), x6))), x3))), x4)))))))))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x6))), x5))), (&(KernelTypes::KExprNode::App(x5, x4)))))))))))))))))) } , + 23 => { + let x0 = (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, x0)))))) } , + 24 => { + let x0 = (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))); + let x1 = (&(KernelTypes::KExprNode::BVar(1))); + let x2 = (&(KernelTypes::KExprNode::BVar(3))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall(x1, x1))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall(x1, x2))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 23), (&(Lists::Node::Nil))))), x2))), (&(KernelTypes::KExprNode::BVar(2)))))))))))))))))) } , + 25 => { + let x0 = (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))); + let x1 = (&(Lists::Node::Nil)); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 23), x1))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::BVar(0))); + let x5 = (&(KernelTypes::KExprNode::BVar(2))); + let x6 = (&(KernelTypes::KExprNode::BVar(4))); + let x7 = (&(KernelTypes::KExprNode::BVar(3))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x3))), x4))), (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Param(0))))))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall(x5, x5))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall(x5, x6))), (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 24), x1))), x6))), x7))), x3))), x4)))))))))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x7))), x5))), (&(KernelTypes::KExprNode::App(x5, x4)))))))))))))))))) } , + 26 => { (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Param(0)))))), (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero)))))))) } , + 27 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt(x0))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::BVar(0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 26), (&(Lists::Node::Cons(x0, (&(Lists::Node::Nil)))))))), (&(KernelTypes::KExprNode::BVar(1)))))))))))) } , + 28 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + let x1 = (&(Lists::Node::Cons(x0, (&(Lists::Node::Nil))))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 26), x1))); + let x3 = (&(KernelTypes::KExprNode::BVar(0))); + let x4 = (&(KernelTypes::KExprNode::BVar(1))); + let x5 = (&(KernelTypes::KExprNode::BVar(2))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt(x0))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App(x2, x3))), (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero)))))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall(x4, (&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 27), x1))), x5))), x3))))))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App(x2, x5))), (&(KernelTypes::KExprNode::App(x5, x3))))))))))))))) } , + 29 => { + let x0 = (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Param(0))))))))); + (&(KernelTypes::KExprNode::Forall(x0, x0))) } , + 30 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Succ(x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 29), (&(Lists::Node::Cons(x0, (&(Lists::Node::Nil)))))))), (&(KernelTypes::KExprNode::BVar(0))))))))) } , + 31 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 29), (&(Lists::Node::Cons(x0, (&(Lists::Node::Nil)))))))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Succ(x0)))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::BVar(0))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App(x1, (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::App(x1, (&(KernelTypes::KExprNode::BVar(2))))))))))))))) } , + 32 => { + let x0 = (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Param(0)))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::BVar(0))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::BVar(1))), (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))))))))), x0)))))) } , + 33 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + let x1 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt(x0))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::BVar(0))), (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))))))))), (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 32), (&(Lists::Node::Cons(x0, (&(Lists::Node::Nil)))))))), (&(KernelTypes::KExprNode::BVar(2)))))), x1)))))))))))) } , + 34 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + let x1 = (&(KernelTypes::KExprNode::BVar(0))); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + let x3 = (&(KernelTypes::KLevelNode::Param(1))); + let x4 = (&(KernelTypes::KExprNode::BVar(2))); + let x5 = (&(KernelTypes::KExprNode::BVar(3))); + let x6 = (&(KernelTypes::KExprNode::BVar(4))); + let x7 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt(x0))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x2, (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))))))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt(x3))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall(x4, x2))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall(x5, (&(KernelTypes::KExprNode::Forall(x6, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x6, x2))), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons(x3, x7)))))), x6))), (&(KernelTypes::KExprNode::App(x5, x4)))))), (&(KernelTypes::KExprNode::App(x5, x2))))))))))))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 32), (&(Lists::Node::Cons(x0, x7)))))), x6))), x5))), x5)))))))))))))))))) } , + 35 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + let x1 = (&(KernelTypes::KExprNode::BVar(0))); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + let x3 = (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))); + let x4 = (&(Lists::Node::Cons(x0, (&(Lists::Node::Nil))))); + let x5 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 32), x4))); + let x6 = (&(KernelTypes::KExprNode::BVar(2))); + let x7 = (&(KernelTypes::KExprNode::BVar(3))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt(x0))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x2, x3)))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x5, x2))), x1))), x3))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall(x6, (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 33), x4))), x7))), x6))), x1))))))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x5, x7))), x6))), (&(KernelTypes::KExprNode::App(x6, x1)))))))))))))))))) } , + 36 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + let x1 = (&(KernelTypes::KExprNode::BVar(0))); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + let x3 = (&(KernelTypes::KExprNode::BVar(2))); + let x4 = (&(Lists::Node::Cons(x0, (&(Lists::Node::Nil))))); + let x5 = (&(KernelTypes::KExprNode::BVar(4))); + let x6 = (&(KernelTypes::KExprNode::BVar(3))); + let x7 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 33), x4))), x5))), x6))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt(x0))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x2, (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))))))))), (&(KernelTypes::KExprNode::Forall(x2, (&(KernelTypes::KExprNode::Forall(x3, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x3, x2))), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), x4))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 32), x4))), x5))), x6)))))), (&(KernelTypes::KExprNode::App(x7, x3)))))), (&(KernelTypes::KExprNode::App(x7, x2))))))))))))))))))))) } , + 37 => { (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero)))))))) } , + 38 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 29), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Zero)), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 37), x0)))))) } , + 39 => { (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero)))))))) } , + 40 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x0)))))) } , + 41 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, x0))) } , + 42 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, x0)))))) } , + 43 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, x0)))))) } , + 44 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, x0)))))) } , + 45 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, x0)))))) } , + 46 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0))))))))) } , + 47 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0))))))))) } , + 48 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, x0)))))) } , + 49 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, x0)))))) } , + 50 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, x0)))))) } , + 51 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, x0)))))) } , + 52 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, x0)))))) } , + 53 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, x0)))))) } , + 54 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, x0)))))) } , + 55 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, x0)))))) } , + 56 => { + let x0 = (&(KernelTypes::KLevelNode::Zero)); + let x1 = (&(KernelTypes::KExprNode::Srt(x0))); + let x2 = (&(Lists::Node::Nil)); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 23), x2))), x3))), (&(KernelTypes::KExprNode::BVar(0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ(x0))), x2)))))), x1))), (&(KernelTypes::KExprNode::BVar(2)))))), x3)))))))))))) } , + 57 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt(x0))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 26), (&(Lists::Node::Cons(x0, (&(Lists::Node::Nil)))))))), (&(KernelTypes::KExprNode::BVar(0)))))), (&(KernelTypes::KExprNode::BVar(1))))))))) } , + 58 => { (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Param(0)))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), (&(Lists::Node::Nil))))), (&(KernelTypes::KExprNode::BVar(1))))))))) } , + 59 => { + let x0 = (&(KernelTypes::KLevelNode::Zero)); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt(x0))), (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Succ(x0))))))))) } , + 60 => { (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::BVar(0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 59), (&(Lists::Node::Nil))))), (&(KernelTypes::KExprNode::BVar(1)))))))))))) } , + 61 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 62), x0))), (&(KernelTypes::KExprNode::BVar(0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 59), x0))), (&(KernelTypes::KExprNode::BVar(1)))))))))))) } , + 62 => { + let x0 = (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))); + (&(KernelTypes::KExprNode::Forall(x0, x0))) } , + 63 => { + let x0 = (&(KernelTypes::KLevelNode::Zero)); + let x1 = (&(Lists::Node::Nil)); + let x2 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt(x0))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 59), x1))), x2))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ(x0))), x1)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x1)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x1))), (&(KernelTypes::KExprNode::BVar(1)))))), x2)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x1)))))), (&(KernelTypes::KExprNode::BVar(2)))))))))))) } , + 64 => { + let x0 = (&(KernelTypes::KLevelNode::Zero)); + let x1 = (&(Lists::Node::Nil)); + let x2 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt(x0))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 59), x1))), x2))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ(x0))), x1)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x1)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x1))), (&(KernelTypes::KExprNode::BVar(1)))))), x2)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x1)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 62), x1))), (&(KernelTypes::KExprNode::BVar(2))))))))))))))) } , + 65 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 59), x0))), (&(KernelTypes::KExprNode::BVar(0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0))))))))) } , + 66 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))))))))) } , + 67 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 59), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), x1))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 68 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 59), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 66), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 69 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 59), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 66), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 70 => { (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero)))))))) } , + 71 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))) } , + 72 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))) } , + 73 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))) } , + 74 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0))))))))) } , + 75 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, x0))) } , + 76 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, x0)))))) } , + 77 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, x0)))))) } , + 78 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, x0)))))) } , + 79 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0)))))) } , + 80 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, x0)))))) } , + 81 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, x0)))))) } , + 82 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), x1)))))) } , + 83 => { (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))), (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))))))))) } , + 84 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 83), x0))), (&(KernelTypes::KExprNode::BVar(1)))))))))))) } , + 85 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 83), x0))), (&(KernelTypes::KExprNode::BVar(0)))))), x1)))))) } , + 86 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 83), x0))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App(x1, (&(KernelTypes::KExprNode::BVar(0)))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App(x1, (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))))))))) } , + 87 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 37), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 59), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), x1))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 88 => { (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero)))))))) } , + 89 => { (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 88), (&(Lists::Node::Nil))))) } , + 90 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 37), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 88), x0)))))) } , + 91 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 29), (&(Lists::Node::Cons(x0, (&(Lists::Node::Nil)))))))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Succ(x0)))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App(x1, (&(KernelTypes::KExprNode::BVar(0)))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App(x1, (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::App(x1, (&(KernelTypes::KExprNode::BVar(2))))))))))))))) } , + 92 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 37), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, x0)))))) } , + 93 => { (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Param(0)))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 59), (&(Lists::Node::Nil))))), (&(KernelTypes::KExprNode::BVar(0)))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::BVar(2))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::BVar(3))), (&(KernelTypes::KExprNode::BVar(4)))))))))))))))))) } , + 94 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Forall(x0, (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))))))))) } , + 95 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 59), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), x1))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 96 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 59), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 94), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 97 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 59), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 94), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 76), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))))))))))))))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 98 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), x1)))))) } , + 99 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), x1)))))) } , + 100 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0)))))) } , + 101 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 37), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0)))))) } , + 102 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 37), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x0)))))) } , + _ => { (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))) } , + } + } + + fn op_equation_count(r: Field) -> Field { + match r { + 41 => { 2 } , + 42 => { 2 } , + 43 => { 2 } , + 44 => { 2 } , + 45 => { 2 } , + 46 => { 4 } , + 47 => { 3 } , + 48 => { 3 } , + 49 => { 3 } , + 50 => { 2 } , + 51 => { 2 } , + 52 => { 2 } , + 53 => { 2 } , + 54 => { 2 } , + 55 => { 2 } , + _ => { 0 } , + } + } + + fn op_evidence_is_proof(r: Field) -> Field { + match r { + 48 => { 1 } , + 49 => { 1 } , + 50 => { 1 } , + 51 => { 1 } , + 52 => { 1 } , + 53 => { 1 } , + 54 => { 1 } , + 55 => { 1 } , + _ => { 0 } , + } + } + + fn op_equation_lhs(tbl: KernelRoles::RoleTable, r: Field, k: Field) -> KernelTypes::KExpr { + match 64 * r + k { + 2624 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 41), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))))))))) } , + 2625 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 41), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(1))))))))))))))) } , + 2688 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 42), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))))))))) } , + 2689 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 42), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 2752 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 43), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))))))))) } , + 2753 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 43), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 2816 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))))))))) } , + 2817 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 2880 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 45), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))))))))) } , + 2881 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 45), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 2944 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 46), x0))), x2))), x2))))))))) } , + 2945 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 46), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 2946 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 46), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))))))))) } , + 2947 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 46), x0))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 3008 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 3009 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))))))))) } , + 3010 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + _ => { (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))) } , + } + } + + fn op_equation_rhs(tbl: KernelRoles::RoleTable, r: Field, k: Field) -> KernelTypes::KExpr { + match 64 * r + k { + 2624 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))))))))) } , + 2625 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Lam(x0, (&(KernelTypes::KExprNode::Lam(x0, (&(KernelTypes::KExprNode::BVar(1))))))))) } , + 2688 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Lam(x0, (&(KernelTypes::KExprNode::Lam(x0, (&(KernelTypes::KExprNode::BVar(1))))))))) } , + 2689 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 42), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 2752 => { + let x0 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::Lam(x0, (&(KernelTypes::KExprNode::Lam(x0, (&(KernelTypes::KExprNode::BVar(1))))))))) } , + 2753 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 41), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 43), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 2816 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))))))))) } , + 2817 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 42), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))), x2))), (&(KernelTypes::KExprNode::BVar(0))))))))), x2))))))))) } , + 2880 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))))))))) } , + 2881 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 45), x0))), x2))), (&(KernelTypes::KExprNode::BVar(0))))))))), x2))))))))) } , + 2944 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0))))))))) } , + 2945 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0))))))))) } , + 2946 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0))))))))) } , + 2947 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 46), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 3008 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0))))))))) } , + 3009 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0))))))))) } , + 3010 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + _ => { (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))) } , + } + } + + fn op_certificate(tbl: KernelRoles::RoleTable, r: Field, k: Field) -> KernelTypes::KExpr { + match 64 * r + k { + 3072 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))); + let x4 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))); + let x5 = (&(KernelTypes::KExprNode::BVar(1))); + let x6 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0))); + let x7 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x8 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 48), x0))); + let x9 = (&(KernelTypes::KExprNode::BVar(3))); + let x10 = (&(KernelTypes::KExprNode::BVar(2))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::BVar(0)))))), x5)))))), x6))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))))))))), x5)))))), x6))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x8, x9))), x10)))))), (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x8, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 43), x0))), x9))), x10)))))), x10))))))))))))))))))))) } , + 3073 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::BVar(0)))))), x3)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 48), x0))), (&(KernelTypes::KExprNode::BVar(2)))))), x3)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))))))))))))))) } , + 3074 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), x3)))))), (&(KernelTypes::KExprNode::BVar(0))))))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 48), x0))), (&(KernelTypes::KExprNode::BVar(2)))))), (&(KernelTypes::KExprNode::BVar(1))))))))), x3)))))))))))) } , + 3136 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))); + let x4 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))); + let x5 = (&(KernelTypes::KExprNode::BVar(1))); + let x6 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0))); + let x7 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))); + let x8 = (&(KernelTypes::KExprNode::BVar(3))); + let x9 = (&(KernelTypes::KExprNode::BVar(2))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::BVar(0)))))), x5)))))), x6))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))))))))), x5)))))), x6))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x7, x8))), x9)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 43), x0))), x8))), x9)))))), x9)))))))))))))))))) } , + 3137 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::BVar(2))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::BVar(0)))))), x3)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))), x4))), x3)))))), x4)))))))))))) } , + 3138 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::BVar(2))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))))))))), (&(KernelTypes::KExprNode::BVar(0))))))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))), x3))), (&(KernelTypes::KExprNode::BVar(1))))))))), x3)))))))))))) } , + 3200 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 50), x0))); + let x5 = (&(KernelTypes::KExprNode::BVar(2))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))))))))), x3)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x4, x5))), x3)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))), x3))), x5)))))), x5))))))))))))))) } , + 3201 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))))))))), x3)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 50), x0))), (&(KernelTypes::KExprNode::BVar(2)))))), x3)))))), x3)))))))))))) } , + 3264 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x4 = (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))); + let x5 = (&(KernelTypes::KExprNode::BVar(1))); + let x6 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 51), x0))); + let x7 = (&(KernelTypes::KExprNode::BVar(2))); + let x8 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))); + let x9 = (&(KernelTypes::KExprNode::App(x3, x4))); + let x10 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 48), x0))); + let x11 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), x4))), x5)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x6, x7))), x5)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 42), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x8, x9))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x6, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x10, x7))), x9)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x10, x5))), x9)))))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x8, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x11, x7))), x9)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x11, x5))), x9))))))))))))))))))))) } , + 3265 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))); + let x4 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), x3)))))), x4)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 51), x0))), (&(KernelTypes::KExprNode::BVar(2)))))), x4)))))), x3)))))))))))) } , + 3328 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x4 = (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))); + let x5 = (&(KernelTypes::KExprNode::BVar(1))); + let x6 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 52), x0))); + let x7 = (&(KernelTypes::KExprNode::BVar(2))); + let x8 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 42), x0))); + let x9 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))); + let x10 = (&(KernelTypes::KExprNode::App(x3, x4))); + let x11 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 48), x0))); + let x12 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))); + let x13 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x12, x7))), x10))); + let x14 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x12, x5))), x10))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), x4))), x5)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x6, x7))), x5)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x8, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x9, x10))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x6, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x11, x7))), x10)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x11, x5))), x10)))))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 43), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x8, x13))), x14)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x9, x13))), x14))))))))))))))))))))) } , + 3329 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))))))))), x3)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 52), x0))), (&(KernelTypes::KExprNode::BVar(2)))))), x3)))))), x3)))))))))))) } , + 3392 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x4 = (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))); + let x5 = (&(KernelTypes::KExprNode::BVar(1))); + let x6 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 53), x0))); + let x7 = (&(KernelTypes::KExprNode::BVar(2))); + let x8 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 42), x0))); + let x9 = (&(KernelTypes::KExprNode::App(x3, x4))); + let x10 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 48), x0))); + let x11 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), x4))), x5)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x6, x7))), x5)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x8, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))), x9))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x6, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x10, x7))), x9)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x10, x5))), x9)))))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x11, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x8, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x11, x7))), x9)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x11, x5))), x9))))))))), x9)))))))))))))))))) } , + 3393 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))))))))), x3)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 53), x0))), (&(KernelTypes::KExprNode::BVar(2)))))), x3)))))), x3)))))))))))) } , + 3456 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x4 = (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))); + let x5 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 54), x0))); + let x6 = (&(KernelTypes::KExprNode::BVar(2))); + let x7 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), x4))), (&(KernelTypes::KExprNode::BVar(0))))))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x5, x6))), x7)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))), (&(KernelTypes::KExprNode::App(x3, x4)))))), x6)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 43), x0))), x7))), x4)))))))))))))))))) } , + 3457 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::BVar(2))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))))))))), (&(KernelTypes::KExprNode::BVar(0))))))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 54), x0))), x3))), (&(KernelTypes::KExprNode::BVar(1))))))))), x3)))))))))))) } , + 3520 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x4 = (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))); + let x5 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 55), x0))), (&(KernelTypes::KExprNode::BVar(2)))))); + let x6 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), x4))), (&(KernelTypes::KExprNode::BVar(0))))))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App(x5, x6)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 48), x0))), (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 43), x0))), x6))), x4))))))))), (&(KernelTypes::KExprNode::App(x3, x4)))))))))))))))))) } , + 3521 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::BVar(2))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))))))))), (&(KernelTypes::KExprNode::BVar(0))))))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 55), x0))), x3))), (&(KernelTypes::KExprNode::BVar(1))))))))), x3)))))))))))) } , + _ => { (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))) } , + } + } + + fn eqns_equation_count(r: Field) -> Field { + match r { + 65 => { 3 } , + 67 => { 1 } , + 68 => { 1 } , + 69 => { 1 } , + 73 => { 2 } , + 74 => { 2 } , + 75 => { 2 } , + 76 => { 4 } , + 77 => { 1 } , + 78 => { 4 } , + 79 => { 2 } , + 80 => { 5 } , + 81 => { 4 } , + 82 => { 3 } , + 85 => { 1 } , + 86 => { 1 } , + 87 => { 1 } , + 90 => { 1 } , + 91 => { 2 } , + 92 => { 1 } , + 93 => { 2 } , + 95 => { 4 } , + 96 => { 4 } , + 97 => { 1 } , + 98 => { 1 } , + 99 => { 1 } , + 100 => { 5 } , + 101 => { 2 } , + 102 => { 3 } , + _ => { 0 } , + } + } + + fn eqns_conditional(r: Field, k: Field) -> Field { + match 64 * r + k { + 4162 => { 1 } , + 4736 => { 1 } , + 4737 => { 1 } , + 5249 => { 1 } , + 5250 => { 1 } , + 6400 => { 1 } , + 6401 => { 1 } , + 6402 => { 1 } , + 6403 => { 1 } , + 6404 => { 1 } , + _ => { 0 } , + } + } + + fn eqns_lhs(tbl: KernelRoles::RoleTable, r: Field, k: Field) -> KernelTypes::KExpr { + match 64 * r + k { + 4160 => { + let x0 = (&(KernelTypes::KExprNode::BVar(0))); + let x1 = (&(Lists::Node::Nil)); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))), (&(KernelTypes::KExprNode::Lam(x0, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x1))), x2))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 60), x1))), x2))), x0)))))))))))) } , + 4161 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::BVar(0))); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))), (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 62), x0))), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), x2))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 61), x0))), x2))), x1)))))))))))) } , + 4288 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + let x3 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), x1))), x2))), x3)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 67), x0))), x2))), x3)))))))))))) } , + 4352 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + let x3 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 66), x0))), x2))), x3)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 68), x0))), x2))), x3)))))))))))) } , + 4416 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 69), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 4672 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 73), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))) } , + 4673 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 73), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 4800 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 75), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 4801 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 75), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 4864 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 76), x0))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 4865 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 76), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 4866 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 76), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 4867 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 76), x0))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 4928 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 77), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 4992 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 78), x0))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 4993 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 78), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 4994 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 78), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 4995 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 78), x0))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 5056 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 79), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 5057 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 79), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 5120 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 80), x0))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 5121 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 80), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 5122 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 80), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(0))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))))))))) } , + 5123 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 80), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(0)))))))))))))))))) } , + 5124 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 80), x0))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 5184 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 81), x0))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 5185 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 81), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 5186 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 81), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 5187 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 81), x0))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 5248 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 82), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 5440 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 85), x0))), x2))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 84), x0))), x2))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 5504 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(2))); + let x3 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 84), x0))), x2))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 86), x0))), x2))), (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::BVar(0)))))))))))))))))) } , + 5568 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 37), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), x1))), x2))), x2)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 87), x0))), x2))), x2))))))))) } , + 5760 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 90), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 38), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 30), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Zero)), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x0)))))))))))) } , + 5824 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + let x1 = (&(Lists::Node::Cons(x0, (&(Lists::Node::Nil))))); + let x2 = (&(KernelTypes::KExprNode::BVar(0))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Succ(x0)))))), (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 29), x1))), x2))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 91), x1))), x3))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 30), x1))), x3)))))), x2))))))))) } , + 5825 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + let x1 = (&(KernelTypes::KExprNode::BVar(0))); + let x2 = (&(Lists::Node::Cons(x0, (&(Lists::Node::Nil))))); + let x3 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 29), x2))); + let x4 = (&(KernelTypes::KExprNode::BVar(1))); + let x5 = (&(KernelTypes::KExprNode::BVar(2))); + let x6 = (&(KernelTypes::KExprNode::BVar(3))); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Succ(x0)))))), (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::App(x3, x4))), (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::App(x3, x5))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 91), x2))), x6))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 31), x2))), x6))), x5))), x4)))))), x1))))))))))))))) } , + 5888 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 29), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Zero)), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x0)))))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 38), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 92), x0))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 5952 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + let x1 = (&(KernelTypes::KExprNode::BVar(0))); + let x2 = (&(KernelTypes::KExprNode::BVar(2))); + let x3 = (&(KernelTypes::KExprNode::BVar(3))); + let x4 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Srt(x0))), (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))), (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x2, (&(KernelTypes::KExprNode::Lam(x3, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 93), (&(Lists::Node::Cons(x0, x4)))))), (&(KernelTypes::KExprNode::BVar(4)))))), x3))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 60), x4))), x3))), x2)))))), (&(KernelTypes::KExprNode::BVar(1)))))), x1)))))))))))))))))) } , + 5953 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + let x1 = (&(Lists::Node::Nil)); + let x2 = (&(KernelTypes::KExprNode::BVar(0))); + let x3 = (&(KernelTypes::KExprNode::BVar(2))); + let x4 = (&(KernelTypes::KExprNode::BVar(3))); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Srt(x0))), (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))), (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 62), x1))), x2))), (&(KernelTypes::KExprNode::Lam(x3, (&(KernelTypes::KExprNode::Lam(x4, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 93), (&(Lists::Node::Cons(x0, x1)))))), (&(KernelTypes::KExprNode::BVar(4)))))), x4))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 61), x1))), x4))), x3)))))), (&(KernelTypes::KExprNode::BVar(1)))))), x2)))))))))))))))))) } , + 6080 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))); + let x3 = (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(1)))))); + let x4 = (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(0)))))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), x3))), x4)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 95), x0))), x3))), x4)))))))))))) } , + 6081 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::BVar(1)))))); + let x3 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(0)))))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), x2))), x3)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 95), x0))), x2))), x3)))))))))))) } , + 6082 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(1)))))); + let x3 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::BVar(0)))))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), x2))), x3)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 95), x0))), x2))), x3)))))))))))) } , + 6083 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))); + let x3 = (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(1)))))); + let x4 = (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(0)))))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), x3))), x4)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 95), x0))), x3))), x4)))))))))))) } , + 6144 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))); + let x3 = (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(1)))))); + let x4 = (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(0)))))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 94), x0))), x3))), x4)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 96), x0))), x3))), x4)))))))))))) } , + 6145 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::BVar(1)))))); + let x3 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(0)))))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 94), x0))), x2))), x3)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 96), x0))), x2))), x3)))))))))))) } , + 6146 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(1)))))); + let x3 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::BVar(0)))))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 94), x0))), x2))), x3)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 96), x0))), x2))), x3)))))))))))) } , + 6147 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))); + let x3 = (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(1)))))); + let x4 = (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(0)))))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 94), x0))), x3))), x4)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 96), x0))), x3))), x4)))))))))))) } , + 6208 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 97), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 6272 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0))), (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 98), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 6336 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0))), (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 99), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 6464 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 101), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 38), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 30), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Zero)), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x0)))))))))))) } , + 6465 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x0))); + let x2 = (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Zero)), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 29), x2))), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 101), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 38), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 31), x2))), x1))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0)))))))))))))))))) } , + 6528 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 102), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 38), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 30), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Zero)), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x0)))))))))))) } , + 6529 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x0))); + let x2 = (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Zero)), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 102), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 38), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 31), x2))), x1))), (&(KernelTypes::KExprNode::BVar(0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 30), x2))), x1))))))))))))))) } , + 6530 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x0))); + let x2 = (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Zero)), x0))); + let x3 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 31), x2))), x1))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 29), x2))), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 102), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 38), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::BVar(2)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0)))))))))))))))))))))))) } , + _ => { (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))) } , + } + } + + fn eqns_rhs(tbl: KernelRoles::RoleTable, r: Field, k: Field) -> KernelTypes::KExpr { + match 64 * r + k { + 4160 => { (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))), (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::BVar(0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), (&(Lists::Node::Nil))))))))))) } , + 4161 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))), (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 62), x0))), (&(KernelTypes::KExprNode::BVar(0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0))))))))) } , + 4288 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 46), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 4352 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 4416 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 68), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 4672 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))) } , + 4673 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(0))))))))) } , + 4800 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 73), x0))), (&(KernelTypes::KExprNode::BVar(0))))))))) } , + 4801 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 4864 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 42), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 4865 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 74), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 4866 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 74), x0))), (&(KernelTypes::KExprNode::BVar(0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(1))))))))))))))) } , + 4867 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 42), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0)))))))))))))))))) } , + 4928 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 76), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 75), x0))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 4992 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 4993 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 73), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(0)))))))))))))))))) } , + 4994 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 73), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 4995 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(0)))))))))))))))))) } , + 5056 => { (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), (&(Lists::Node::Nil))))), (&(KernelTypes::KExprNode::BVar(0)))))) } , + 5057 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(0))))))))) } , + 5120 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 48), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 5121 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 75), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 48), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))))))))) } , + 5122 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))))))))) } , + 5123 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 48), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(0)))))))))))))))))) } , + 5124 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 48), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(0))))))))))))))))))))) } , + 5184 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 5185 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(0)))))))))))))))))) } , + 5186 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 74), x0))), x2))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), x2))))))))))))))) } , + 5187 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x3 = (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(0)))))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 74), x0))), x3))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), x3))))))))))))))) } , + 5248 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 45), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 5440 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))), (&(KernelTypes::KExprNode::BVar(0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 45), x0))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))))))))), (&(KernelTypes::KExprNode::BVar(1))))))))))))))) } , + 5504 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x3 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))); + let x4 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 45), x0))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))))))))), (&(KernelTypes::KExprNode::BVar(2)))))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::BVar(1)))))), x4))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::BVar(0)))))), x4))))))))))))))) } , + 5568 => { + let x0 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 37), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0)))))) } , + 5760 => { (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 89), (&(Lists::Node::Nil))))) } , + 5824 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + let x1 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Succ(x0)))))), (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 29), (&(Lists::Node::Cons(x0, (&(Lists::Node::Nil)))))))), x1))), x1)))))) } , + 5825 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + let x1 = (&(KernelTypes::KExprNode::BVar(0))); + let x2 = (&(Lists::Node::Cons(x0, (&(Lists::Node::Nil))))); + let x3 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 29), x2))); + let x4 = (&(KernelTypes::KExprNode::BVar(1))); + let x5 = (&(KernelTypes::KExprNode::BVar(2))); + let x6 = (&(KernelTypes::KExprNode::BVar(3))); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Succ(x0)))))), (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::App(x3, x4))), (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::App(x3, x5))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 31), x2))), x6))), x5))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 91), x2))), x6))), x4))), x1)))))))))))))))))) } , + 5888 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Zero)), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x0))); + let x3 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 29), x1))), x2))); + (&(KernelTypes::KExprNode::Lam(x3, (&(KernelTypes::KExprNode::Lam(x3, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 38), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 91), x1))), x2))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))) } , + 5952 => { (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Param(0)))))), (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))), (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::BVar(0))), (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::BVar(2))), (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::BVar(3))), (&(KernelTypes::KExprNode::BVar(1)))))))))))))))))) } , + 5953 => { + let x0 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Param(0)))))), (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))), (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 62), (&(Lists::Node::Nil))))), x0))), (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::BVar(2))), (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::BVar(3))), x0))))))))))))))) } , + 6080 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 46), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 6081 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0))))))))) } , + 6082 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0))))))))) } , + 6083 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 46), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 6144 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 6145 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0))))))))) } , + 6146 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0))))))))) } , + 6147 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::BVar(0)))))), (&(KernelTypes::KExprNode::BVar(1)))))))))))) } , + 6208 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 96), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 76), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))))))))))))))), (&(KernelTypes::KExprNode::BVar(0)))))))))))) } , + 6272 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 76), x0))); + let x3 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))); + let x4 = (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::BVar(0)))))); + let x5 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 81), x0))), (&(KernelTypes::KExprNode::BVar(1)))))), x4))); + let x6 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x7 = (&(KernelTypes::KExprNode::App(x6, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))); + let x8 = (&(KernelTypes::KExprNode::App(x3, x7))); + let x9 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 80), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x4))), x8)))))), (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App(x6, x7))))))))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 93), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 94), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x5))), x8)))))), x9)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 97), x0))), x5))), x9)))))), x5))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 77), x0))), x5))), x4)))))))))))) } , + 6336 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x3 = (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0))); + let x4 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 93), x3))), x1))); + let x5 = (&(KernelTypes::KExprNode::BVar(0))); + let x6 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))); + let x7 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))); + let x8 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 76), x0))); + let x9 = (&(KernelTypes::KExprNode::BVar(1))); + let x10 = (&(KernelTypes::KExprNode::App(x7, x5))); + let x11 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 81), x0))), x9))), x10))); + let x12 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x13 = (&(KernelTypes::KExprNode::App(x12, x6))); + let x14 = (&(KernelTypes::KExprNode::App(x7, x13))); + let x15 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 80), x0))); + let x16 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x15, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x8, x10))), x14)))))), (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x12, x13))))))))); + let x17 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x15, x9))), x10))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x2, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), x3))), x2))), x5))), x6)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 67), x0))), x5))), x6)))))), (&(KernelTypes::KExprNode::App(x7, x6)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 94), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x8, x11))), x14)))))), x16)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 97), x0))), x11))), x16)))))), x17))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x8, x17))), x14))))))))))))))) } , + 6464 => { (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), (&(Lists::Node::Nil))))) } , + 6465 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 29), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Zero)), x0)))))), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 42), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 100), x0))), (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 101), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 38), x0))), (&(KernelTypes::KExprNode::BVar(0)))))))))))))))))) } , + 6528 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x2 = (&(KernelTypes::KExprNode::App(x1, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))); + let x3 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))), (&(KernelTypes::KExprNode::App(x1, x2)))))); + (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 40), x0))), (&(KernelTypes::KExprNode::App(x1, (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App(x3, x2)))))))))))))))))))))))) } , + 6529 => { (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), (&(Lists::Node::Nil))))), (&(KernelTypes::KExprNode::BVar(0)))))) } , + 6530 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x0))); + let x2 = (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Zero)), x0))); + (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam(x1, (&(KernelTypes::KExprNode::Lam((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 29), x2))), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 102), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 38), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 31), x2))), x1))), (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0))))))))))))))))))))) } , + _ => { (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))) } , + } + } + + fn eqns_statement(tbl: KernelRoles::RoleTable, r: Field, k: Field) -> KernelTypes::KExpr { + match 64 * r + k { + 4160 => { + let x0 = (&(KernelTypes::KLevelNode::Zero)); + let x1 = (&(KernelTypes::KExprNode::BVar(0))); + let x2 = (&(Lists::Node::Nil)); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt(x0))), (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ(x0))), x2)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x2)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x2))), x3))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 60), x2))), x3))), x1))))))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x2)))))))))))) } , + 4161 => { + let x0 = (&(KernelTypes::KLevelNode::Zero)); + let x1 = (&(Lists::Node::Nil)); + let x2 = (&(KernelTypes::KExprNode::BVar(0))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt(x0))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 62), x1))), x2))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ(x0))), x1)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x1)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x1))), x3))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 61), x1))), x3))), x2))))))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x1)))))))))))) } , + 4162 => { + let x0 = (&(KernelTypes::KLevelNode::Zero)); + let x1 = (&(Lists::Node::Nil)); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 59), x1))); + let x3 = (&(KernelTypes::KExprNode::BVar(0))); + let x4 = (&(KernelTypes::KExprNode::BVar(1))); + let x5 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ(x0))), x1)))))); + let x6 = (&(KernelTypes::KExprNode::BVar(2))); + let x7 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x1))), x6))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt(x0))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App(x2, x3))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App(x2, x4))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x1)))))), (&(KernelTypes::KExprNode::App(x7, x4)))))), (&(KernelTypes::KExprNode::App(x7, x3)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::BVar(3))))))))), x6))), x4))))))))))))))) } , + 4288 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), x3))), x4)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 67), x0))), x3))), x4))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 46), x0))), x3))), x4)))))))))))) } , + 4352 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + let x3 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 66), x0))), x2))), x3)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 68), x0))), x2))), x3))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), x2))), x3)))))))))))) } , + 4416 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + let x3 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), x2))); + let x4 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 59), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 66), x0))), x3))), x4))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 69), x0))), x2))), x4)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 68), x0))), x3))), x4)))))))))))) } , + 4672 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))); + (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 73), x0))), x1)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), x1)))))) } , + 4673 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 73), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), x1))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), x1))))))))) } , + 4736 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::BVar(2))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::BVar(0)))))), x3)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 74), x0))), x4))), x3)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 43), x0))), x4))), x3)))))))))))))))))) } , + 4737 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::BVar(2))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::BVar(0)))))), x3)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 74), x0))), x4))), x3)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 41), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 43), x0))), x3))), x4))))))))))))))))))))) } , + 4800 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 75), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), x1))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 73), x0))), x1))))))))) } , + 4801 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 75), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), x1))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), x1)))))))))))) } , + 4864 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 76), x0))), (&(KernelTypes::KExprNode::App(x2, x3)))))), (&(KernelTypes::KExprNode::App(x2, x4))))))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 42), x0))), x3))), x4))))))))))))))) } , + 4865 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + let x3 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 76), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), x2)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), x3))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 74), x0))), x2))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), x3))))))))))))))) } , + 4866 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + let x3 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 76), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), x2)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), x3))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 74), x0))), x3))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), x2))))))))))))))) } , + 4867 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 76), x0))), (&(KernelTypes::KExprNode::App(x2, x3)))))), (&(KernelTypes::KExprNode::App(x2, x4))))))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 42), x0))), x3))), x4)))))))))))))))))) } , + 4928 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + let x3 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 77), x0))), x2))), x3)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 76), x0))), x2))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 75), x0))), x3))))))))))))))) } , + 4992 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 78), x0))), (&(KernelTypes::KExprNode::App(x2, x3)))))), (&(KernelTypes::KExprNode::App(x2, x4))))))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))), x3))), x4))))))))))))))) } , + 4993 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + let x3 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 78), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), x2)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), x3))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 73), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))), x2))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), x3)))))))))))))))))) } , + 4994 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + let x3 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 78), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), x2)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), x3))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 73), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), x2)))))), x3))))))))))))))) } , + 4995 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::BVar(0))); + let x5 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 78), x0))), (&(KernelTypes::KExprNode::App(x2, x3)))))), (&(KernelTypes::KExprNode::App(x2, x4))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))), (&(KernelTypes::KExprNode::App(x5, x3)))))), (&(KernelTypes::KExprNode::App(x5, x4)))))))))))))))))) } , + 5056 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 79), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), x2))))))))), x2)))))) } , + 5057 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 79), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), x2))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), x2))))))))) } , + 5120 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 80), x0))), (&(KernelTypes::KExprNode::App(x2, x3)))))), (&(KernelTypes::KExprNode::App(x2, x4))))))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 48), x0))), x3))), x4))))))))))))))) } , + 5121 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 80), x0))), (&(KernelTypes::KExprNode::App(x2, x3)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), x4))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 75), x0))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 48), x0))), x3))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), x4))))))))))))))))))))) } , + 5122 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 80), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(0))))))))), x1)))))), x1)))))) } , + 5123 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::BVar(0)))))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 80), x0))), (&(KernelTypes::KExprNode::App(x2, x3)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), x4))))))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 48), x0))), x3))), x4))))))))))))))) } , + 5124 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::BVar(0))); + let x5 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 80), x0))), (&(KernelTypes::KExprNode::App(x2, x3)))))), (&(KernelTypes::KExprNode::App(x2, x4))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 48), x0))), x3))), (&(KernelTypes::KExprNode::App(x5, x4))))))))))))))))))))) } , + 5184 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 81), x0))), (&(KernelTypes::KExprNode::App(x2, x3)))))), (&(KernelTypes::KExprNode::App(x2, x4))))))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))), x3))), x4))))))))))))))) } , + 5185 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 81), x0))), (&(KernelTypes::KExprNode::App(x2, x3)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), x4))))))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))), x3))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), x4)))))))))))))))))) } , + 5186 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + let x3 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 81), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), x2)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), x3))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 74), x0))), x3))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))), x2))), x3)))))))))))))))))) } , + 5187 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::BVar(0))); + let x5 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x6 = (&(KernelTypes::KExprNode::App(x5, x4))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 81), x0))), (&(KernelTypes::KExprNode::App(x2, x3)))))), (&(KernelTypes::KExprNode::App(x2, x4))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 74), x0))), x6))), (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))), x3))), x6)))))))))))))))))) } , + 5248 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 82), x0))), (&(KernelTypes::KExprNode::App(x2, x3)))))), x4)))))), (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 45), x0))), x3))), x4))))))))))))))) } , + 5249 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x4 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))); + let x5 = (&(KernelTypes::KExprNode::BVar(2))); + let x6 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 46), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))), (&(KernelTypes::KExprNode::BVar(0)))))), (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App(x3, x4)))))))))))), x4)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 82), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), x5)))))), x6)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 45), x0))), (&(KernelTypes::KExprNode::App(x3, x5)))))), x6)))))))))))))))))) } , + 5250 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x4 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))); + let x5 = (&(KernelTypes::KExprNode::BVar(2))); + let x6 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 46), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))), (&(KernelTypes::KExprNode::BVar(0)))))), (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App(x3, x4)))))))))))), x4)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 82), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), x5)))))), x6)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 75), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 45), x0))), (&(KernelTypes::KExprNode::App(x3, x5)))))), x6))))))))))))))))))))) } , + 5440 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + let x3 = (&(KernelTypes::KExprNode::BVar(0))); + let x4 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 85), x0))), x2))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 84), x0))), x2))), x3))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))), x3))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 45), x0))), (&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))))))))), x2))))))))))))))) } , + 5504 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(2))); + let x3 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 84), x0))), x2))); + let x4 = (&(KernelTypes::KExprNode::BVar(1))); + let x5 = (&(KernelTypes::KExprNode::BVar(0))); + let x6 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x7 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 49), x0))); + let x8 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 45), x0))), (&(KernelTypes::KExprNode::App(x6, (&(KernelTypes::KExprNode::App(x6, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))))))))), x2))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 86), x0))), x2))), (&(KernelTypes::KExprNode::App(x3, x4)))))), (&(KernelTypes::KExprNode::App(x3, x5))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::App(x6, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x7, x4))), x8))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x7, x5))), x8)))))))))))))))))) } , + 5568 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 37), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), x3))), x3)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 87), x0))), x3))), x3))))))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0))))))))) } , + 5760 => { + let x0 = (&(KernelTypes::KLevelNode::Zero)); + let x1 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ(x0))), x1)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 88), x1)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 90), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 38), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 30), (&(Lists::Node::Cons(x0, x1)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x1))))))))))))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 89), x1)))))) } , + 5824 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + let x1 = (&(KernelTypes::KLevelNode::Succ(x0))); + let x2 = (&(Lists::Node::Nil)); + let x3 = (&(Lists::Node::Cons(x0, x2))); + let x4 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 29), x3))); + let x5 = (&(KernelTypes::KExprNode::BVar(0))); + let x6 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt(x1))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App(x4, x5))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons(x1, x2)))))), (&(KernelTypes::KExprNode::App(x4, x6)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 91), x3))), x6))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 30), x3))), x6)))))), x5)))))), x5))))))))) } , + 5825 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + let x1 = (&(KernelTypes::KLevelNode::Succ(x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(0))); + let x3 = (&(Lists::Node::Nil)); + let x4 = (&(Lists::Node::Cons(x0, x3))); + let x5 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 29), x4))); + let x6 = (&(KernelTypes::KExprNode::BVar(1))); + let x7 = (&(KernelTypes::KExprNode::BVar(2))); + let x8 = (&(KernelTypes::KExprNode::BVar(3))); + let x9 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 91), x4))), x8))); + let x10 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 31), x4))), x8))), x7))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt(x1))), (&(KernelTypes::KExprNode::Forall(x2, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App(x5, x6))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App(x5, x7))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons(x1, x3)))))), (&(KernelTypes::KExprNode::App(x5, x8)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x9, (&(KernelTypes::KExprNode::App(x10, x6)))))), x2)))))), (&(KernelTypes::KExprNode::App(x10, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x9, x6))), x2))))))))))))))))))))) } , + 5888 => { + let x0 = (&(KernelTypes::KLevelNode::Zero)); + let x1 = (&(Lists::Node::Nil)); + let x2 = (&(Lists::Node::Cons(x0, x1))); + let x3 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x1))); + let x4 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 29), x2))), x3))); + let x5 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 38), x1))); + let x6 = (&(KernelTypes::KExprNode::BVar(1))); + let x7 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x4, (&(KernelTypes::KExprNode::Forall(x4, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ(x0))), x1)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 37), x1)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 92), x1))), (&(KernelTypes::KExprNode::App(x5, x6)))))), (&(KernelTypes::KExprNode::App(x5, x7))))))))), (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 91), x2))), x3))), x6))), x7))))))))))))))) } , + 5952 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + let x1 = (&(KernelTypes::KExprNode::BVar(0))); + let x2 = (&(KernelTypes::KExprNode::BVar(2))); + let x3 = (&(KernelTypes::KExprNode::BVar(3))); + let x4 = (&(Lists::Node::Nil)); + let x5 = (&(Lists::Node::Cons(x0, x4))); + let x6 = (&(KernelTypes::KExprNode::BVar(4))); + let x7 = (&(KernelTypes::KExprNode::BVar(1))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt(x0))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))), (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x2, (&(KernelTypes::KExprNode::Forall(x3, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), x5))), x6))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 93), x5))), x6))), x3))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 60), x4))), x3))), x2)))))), x7))), x1)))))), x7)))))))))))))))))) } , + 5953 => { + let x0 = (&(KernelTypes::KLevelNode::Param(0))); + let x1 = (&(Lists::Node::Nil)); + let x2 = (&(KernelTypes::KExprNode::BVar(0))); + let x3 = (&(KernelTypes::KExprNode::BVar(2))); + let x4 = (&(KernelTypes::KExprNode::BVar(3))); + let x5 = (&(Lists::Node::Cons(x0, x1))); + let x6 = (&(KernelTypes::KExprNode::BVar(4))); + (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt(x0))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 62), x1))), x2))), (&(KernelTypes::KExprNode::Forall(x3, (&(KernelTypes::KExprNode::Forall(x4, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), x5))), x6))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 93), x5))), x6))), x4))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 61), x1))), x4))), x3)))))), (&(KernelTypes::KExprNode::BVar(1)))))), x2)))))), x2)))))))))))))))))) } , + 6080 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))); + let x4 = (&(KernelTypes::KExprNode::BVar(1))); + let x5 = (&(KernelTypes::KExprNode::App(x3, x4))); + let x6 = (&(KernelTypes::KExprNode::BVar(0))); + let x7 = (&(KernelTypes::KExprNode::App(x3, x6))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), x5))), x7)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 95), x0))), x5))), x7))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 46), x0))), x4))), x6)))))))))))) } , + 6081 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::BVar(1)))))); + let x4 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(0)))))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), x3))), x4)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 95), x0))), x3))), x4))))))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0)))))))))))) } , + 6082 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(1)))))); + let x4 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::BVar(0)))))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), x3))), x4)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 95), x0))), x3))), x4))))))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0)))))))))))) } , + 6083 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))); + let x4 = (&(KernelTypes::KExprNode::BVar(1))); + let x5 = (&(KernelTypes::KExprNode::App(x3, x4))); + let x6 = (&(KernelTypes::KExprNode::BVar(0))); + let x7 = (&(KernelTypes::KExprNode::App(x3, x6))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0)))))), x5))), x7)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 95), x0))), x5))), x7))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 46), x0))), x4))), x6)))))))))))) } , + 6144 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::App(x2, x3))); + let x5 = (&(KernelTypes::KExprNode::BVar(0))); + let x6 = (&(KernelTypes::KExprNode::App(x2, x5))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 94), x0))), x4))), x6)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 96), x0))), x4))), x6))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), x3))), x5)))))))))))) } , + 6145 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::BVar(1)))))); + let x3 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(0)))))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 94), x0))), x2))), x3)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 96), x0))), x2))), x3))))))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 5), x0)))))))))))) } , + 6146 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))), (&(KernelTypes::KExprNode::BVar(1)))))); + let x3 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::BVar(0)))))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 94), x0))), x2))), x3)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 96), x0))), x2))), x3))))))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0)))))))))))) } , + 6147 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 72), x0))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::App(x2, x3))); + let x5 = (&(KernelTypes::KExprNode::BVar(0))); + let x6 = (&(KernelTypes::KExprNode::App(x2, x5))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 65), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 94), x0))), x4))), x6)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 96), x0))), x4))), x6))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), x5))), x3)))))))))))) } , + 6208 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0))); + let x2 = (&(KernelTypes::KExprNode::BVar(1))); + let x3 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 76), x0))), x2))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))))))))); + let x4 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 59), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 94), x0))), x3))), x4))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 97), x0))), x2))), x4)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 96), x0))), x3))), x4)))))))))))) } , + 6272 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0))); + let x2 = (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0))); + let x3 = (&(KernelTypes::KExprNode::BVar(1))); + let x4 = (&(KernelTypes::KExprNode::BVar(0))); + let x5 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 76), x0))); + let x6 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))); + let x7 = (&(KernelTypes::KExprNode::App(x6, x4))); + let x8 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 81), x0))), x3))), x7))); + let x9 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x10 = (&(KernelTypes::KExprNode::App(x9, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))); + let x11 = (&(KernelTypes::KExprNode::App(x6, x10))); + let x12 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 80), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x5, x7))), x11)))))), (&(KernelTypes::KExprNode::App(x6, (&(KernelTypes::KExprNode::App(x9, x10))))))))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), x2))), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 98), x0))), x3))), x4)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 93), x2))), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 94), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x5, x8))), x11)))))), x12)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 97), x0))), x8))), x12)))))), x8))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 77), x0))), x8))), x7))))))))))))))) } , + 6336 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 70), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x3 = (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0))); + let x4 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), x3))); + let x5 = (&(KernelTypes::KExprNode::BVar(1))); + let x6 = (&(KernelTypes::KExprNode::BVar(0))); + let x7 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 93), x3))), x1))); + let x8 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0))); + let x9 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 71), x0))); + let x10 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 76), x0))); + let x11 = (&(KernelTypes::KExprNode::App(x9, x6))); + let x12 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 81), x0))), x5))), x11))); + let x13 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x14 = (&(KernelTypes::KExprNode::App(x13, x8))); + let x15 = (&(KernelTypes::KExprNode::App(x9, x14))); + let x16 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 80), x0))); + let x17 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x16, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x10, x11))), x15)))))), (&(KernelTypes::KExprNode::App(x9, (&(KernelTypes::KExprNode::App(x13, x14))))))))); + let x18 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x16, x5))), x11))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x2, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x4, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 99), x0))), x5))), x6)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x4, x2))), x6))), x8)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 67), x0))), x6))), x8)))))), (&(KernelTypes::KExprNode::App(x9, x8)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 94), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x10, x12))), x15)))))), x17)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 97), x0))), x12))), x17)))))), x18))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x10, x18))), x15)))))))))))))))))) } , + 6400 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x4 = (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))); + let x5 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))), (&(KernelTypes::KExprNode::App(x3, x4)))))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))), (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::BVar(0))))))))), (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App(x5, x4))))))))))))))))))))))))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 100), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 40), x0))), (&(KernelTypes::KExprNode::BVar(1)))))))))))), x4))))))))) } , + 6401 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))); + let x4 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))); + let x5 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x6 = (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))); + let x7 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))), (&(KernelTypes::KExprNode::App(x5, x6)))))); + let x8 = (&(KernelTypes::KExprNode::App(x7, x6))); + let x9 = (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, x8)))))))))))))))))); + let x10 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x4, x9))), (&(KernelTypes::KExprNode::BVar(0))))))))), x10))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, x9)))))))))))))))))), x10))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 100), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 40), x0))), (&(KernelTypes::KExprNode::BVar(2)))))))))))), x8)))))))))))) } , + 6402 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))); + let x4 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))); + let x5 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x6 = (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))); + let x7 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))), (&(KernelTypes::KExprNode::App(x5, x6)))))); + let x8 = (&(KernelTypes::KExprNode::App(x7, x6))); + let x9 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0))); + let x10 = (&(KernelTypes::KExprNode::App(x5, x8))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, x8))))))))))))))))))))))))))))))))), (&(KernelTypes::KExprNode::BVar(0))))))))), x9))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, x10)))))))))))))))))))))))))))))))))))))))))))))))))))))), x9))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 100), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 40), x0))), (&(KernelTypes::KExprNode::BVar(2)))))))))))), x10)))))))))))) } , + 6403 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))); + let x4 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))); + let x5 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x6 = (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))); + let x7 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))), (&(KernelTypes::KExprNode::App(x5, x6)))))); + let x8 = (&(KernelTypes::KExprNode::App(x7, x6))); + let x9 = (&(KernelTypes::KExprNode::App(x5, x8))); + let x10 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App(x7, x9)))))))))))))))))))))))))))))))))))))))))))))))), (&(KernelTypes::KExprNode::BVar(0))))))))), x10))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, x8))))))))))))))))))))))))))))))))))))))))))))))))))), x10))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 100), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 40), x0))), (&(KernelTypes::KExprNode::BVar(2)))))))))))), x9)))))))))))) } , + 6404 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0))); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ((&(KernelTypes::KLevelNode::Zero))))), x0)))))); + let x3 = (&(KernelTypes::KExprNode::App(x2, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 4), x0)))))); + let x4 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 47), x0))); + let x5 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x0))); + let x6 = (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x0)))))); + let x7 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x0))), (&(KernelTypes::KExprNode::App(x5, x6)))))); + let x8 = (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, x6)))))); + let x9 = (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, x8)))))); + let x10 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 6), x0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, x9))))))))))))))))))))))))))))))))))))))), (&(KernelTypes::KExprNode::BVar(0))))))))), x10))), (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::BVar(1))))))))), (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x7, (&(KernelTypes::KExprNode::App(x5, x9))))))))))))))))))))))))))))))))))))))))))))))))))))))))), x10))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x2, x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 100), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 40), x0))), (&(KernelTypes::KExprNode::BVar(2)))))))))))), x8)))))))))))) } , + 6464 => { + let x0 = (&(KernelTypes::KLevelNode::Zero)); + let x1 = (&(Lists::Node::Nil)); + (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ(x0))), x1)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x1)))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 101), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 38), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 30), (&(Lists::Node::Cons(x0, x1)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x1))))))))))))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x1)))))) } , + 6465 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x0))); + let x2 = (&(KernelTypes::KLevelNode::Zero)); + let x3 = (&(Lists::Node::Cons(x2, x0))); + let x4 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 101), x0))); + let x5 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 38), x0))); + let x6 = (&(KernelTypes::KExprNode::BVar(1))); + let x7 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 29), x3))), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ(x2))), x0)))))), (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 0), x0)))))), (&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 31), x3))), x1))), x6))), x7)))))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 42), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 100), x0))), x6)))))), (&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::App(x5, x7)))))))))))))))))) } , + 6528 => { + let x0 = (&(KernelTypes::KLevelNode::Zero)); + let x1 = (&(Lists::Node::Nil)); + let x2 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x1))); + let x3 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 2), x1))); + let x4 = (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 1), x1)))))); + let x5 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 44), x1))), (&(KernelTypes::KExprNode::App(x3, x4)))))); + (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ(x0))), x1)))))), x2))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 102), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 38), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 30), (&(Lists::Node::Cons(x0, x1)))))), x2)))))))))))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 40), x1))), (&(KernelTypes::KExprNode::App(x3, (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App(x5, x4))))))))))))))))))))))))))) } , + 6529 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x0))); + let x2 = (&(KernelTypes::KLevelNode::Zero)); + let x3 = (&(Lists::Node::Cons(x2, x0))); + let x4 = (&(KernelTypes::KExprNode::BVar(0))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ(x2))), x0)))))), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 102), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 38), x0))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 31), x3))), x1))), x4))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 30), x3))), x1))))))))))))))), x4)))))) } , + 6530 => { + let x0 = (&(Lists::Node::Nil)); + let x1 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 39), x0))); + let x2 = (&(KernelTypes::KLevelNode::Zero)); + let x3 = (&(Lists::Node::Cons(x2, x0))); + let x4 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 102), x0))); + let x5 = (&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 38), x0))); + let x6 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 31), x3))), x1))); + let x7 = (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x6, (&(KernelTypes::KExprNode::BVar(1)))))), (&(KernelTypes::KExprNode::BVar(0)))))); + (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall(x1, (&(KernelTypes::KExprNode::Forall((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 29), x3))), x1))), (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::Const(KernelRoles::role_bound_addr(tbl, 8), (&(Lists::Node::Cons((&(KernelTypes::KLevelNode::Succ(x2))), x0)))))), x1))), (&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::App(x5, (&(KernelTypes::KExprNode::App((&(KernelTypes::KExprNode::App(x6, (&(KernelTypes::KExprNode::BVar(2)))))), x7)))))))))))), (&(KernelTypes::KExprNode::App(x4, (&(KernelTypes::KExprNode::App(x5, x7)))))))))))))))))) } , + _ => { (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))) } , + } + } + + fn role_prim_family(r: Field) -> (Field, Field) { + match r { + 2 => { (1, 1) } , + 38 => { (2, 1) } , + 41 => { (1, 2) } , + 42 => { (1, 3) } , + 43 => { (1, 4) } , + 44 => { (1, 5) } , + 45 => { (1, 9) } , + 46 => { (1, 15) } , + 47 => { (1, 16) } , + 48 => { (1, 6) } , + 49 => { (1, 7) } , + 50 => { (1, 8) } , + 51 => { (1, 10) } , + 52 => { (1, 11) } , + 53 => { (1, 12) } , + 54 => { (1, 13) } , + 55 => { (1, 14) } , + 67 => { (5, 3) } , + 68 => { (5, 2) } , + 69 => { (5, 1) } , + 75 => { (6, 1) } , + 76 => { (6, 6) } , + 77 => { (6, 7) } , + 78 => { (6, 8) } , + 79 => { (6, 2) } , + 80 => { (6, 10) } , + 81 => { (6, 9) } , + 82 => { (6, 5) } , + 85 => { (3, 1) } , + 86 => { (3, 2) } , + 87 => { (2, 5) } , + 90 => { (2, 4) } , + 92 => { (2, 6) } , + 95 => { (5, 6) } , + 96 => { (5, 5) } , + 97 => { (5, 4) } , + 98 => { (6, 3) } , + 99 => { (6, 4) } , + 101 => { (2, 2) } , + 102 => { (2, 3) } , + _ => { (0, 0) } , + } + } +} diff --git a/IxVM/IxVM/Modules/KernelRoles.aiur b/IxVM/IxVM/Modules/KernelRoles.aiur new file mode 100644 index 000000000..4b3004b0a --- /dev/null +++ b/IxVM/IxVM/Modules/KernelRoles.aiur @@ -0,0 +1,660 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module KernelRoles { + enum RoleEvidence { + Defeq, + Proof(Bytes::AddressRef) + } + + enum RoleTableNode { + Mk(Bytes::AddressRef, RoleMap, RBTreeMap::RBTreeMap, RoleMap>) + } + + type RoleTable = &RoleTableNode; + + enum RoleCtxNode { + Mk(RoleTable, Field, RBTreeMap::RBTreeMap), + Assumed(RoleTable, RBTreeMap::RBTreeMap) + } + + type RoleCtx = &RoleCtxNode; + + enum RoleMap { + Nil, + Node(Field, Field, V, &RoleMap, &RoleMap) + } + + fn load_role_table(binding: Bytes::AddressRef) -> RoleTable { + let raw = (*(binding)); + let (idx, len) = IxVMCompat::io_get_info(6, raw); + let bytes = IxByteStream::read_finite_byte_stream(6, idx, len); + Blake3::verify_bytes_against(bytes, raw); + let (t0, s) = IxonDeserialize::read_byte(bytes); + assert_eq!(UInt8::to_field(t0), 232, "role table: not a binding section"); + let (t1, s) = IxonDeserialize::read_byte(s); + assert_eq!(UInt8::to_field(t1), 3, "role table: not a binding section"); + let (version, s) = IxonDeserialize::read_byte(s); + assert_eq!(UInt8::to_field(version), KernelRoleSpec::spec_version(), + "role table: made for another specification version"); + let (n, s) = IxonDeserialize::read_byte(s); + let (by_role, by_addr, _next, s) = + read_role_bindings(s, UInt8::to_field(n), 0, RBTreeMap::RBTreeMap::Nil); + let (m, s) = IxonDeserialize::read_byte(s); + let (evidence, _next, s) = read_role_evidence(s, UInt8::to_field(m), 0); + let Lists::Node::Nil = (*(s)); + (&(RoleTableNode::Mk(binding, by_role, by_addr, evidence))) + } + + fn read_role_bindings(s: Bytes::Stream, count: Field, next: Field, by_addr: RBTreeMap::RBTreeMap) + -> (RoleMap, RBTreeMap::RBTreeMap, Field, Bytes::Stream) { + match count { + 0 => { (RoleMap::Nil, by_addr, next, s) } , + _ => { + let [b0, _, _, _, _, _, _, _] = UInt8::raw_bit_decomposition(count); + let half = (count - b0) / 2; + let (left, by_addr, next, s) = read_role_bindings(s, half, next, by_addr); + let (rb, s) = IxonDeserialize::read_byte(s); + let r = UInt8::to_field(rb); + assert_eq!(UInt32::less_than_fields(r, KernelRoleSpec::role_count()), 1, "role table: unknown role"); + assert_eq!(UInt32::less_than_fields(r, next), 0, "role table: roles out of order"); + let (a, s) = IxonDeserialize::get_address(s); + assert_eq!(RBTreeMap::rbtree_map_lookup_or_default(a, by_addr, 0), 0, + "role table: an address is bound to two roles"); + let by_addr = RBTreeMap::rbtree_map_insert(a, r + 1, by_addr); + let (right, by_addr, next, s) = + read_role_bindings(s, count - (half + 1), r + 1, by_addr); + (RoleMap::Node(1, r, a, (&(left)), (&(right))), by_addr, next, s) } , + } + } + + fn read_role_evidence(s: Bytes::Stream, count: Field, next: Field) + -> (RoleMap>, Field, Bytes::Stream) { + match count { + 0 => { (RoleMap::Nil, next, s) } , + _ => { + let [b0, _, _, _, _, _, _, _] = UInt8::raw_bit_decomposition(count); + let half = (count - b0) / 2; + let (left, next, s) = read_role_evidence(s, half, next); + let (rb, s) = IxonDeserialize::read_byte(s); + let r = UInt8::to_field(rb); + assert_eq!(UInt32::less_than_fields(r, KernelRoleSpec::role_count()), 1, "role table: unknown role"); + assert_eq!(UInt32::less_than_fields(r, next), 0, "role table: evidence out of order"); + let (kb, s) = IxonDeserialize::read_byte(s); + let (entries, s) = read_evidence_entries(s, UInt8::to_field(kb)); + let (right, next, s) = read_role_evidence(s, count - (half + 1), r + 1); + (RoleMap::Node(1, r, entries, (&(left)), (&(right))), next, s) } , + } + } + + fn read_evidence_entries(s: Bytes::Stream, count: Field) -> (Lists::List, Bytes::Stream) { + match count { + 0 => { ((&(Lists::Node::Nil)), s) } , + _ => { + let (tag, s) = IxonDeserialize::read_byte(s); + match UInt8::to_field(tag) { + 0 => { + let (rest, s) = read_evidence_entries(s, count - 1); + ((&(Lists::Node::Cons(RoleEvidence::Defeq, rest))), s) } , + 1 => { + let (a, s) = IxonDeserialize::get_address(s); + let (rest, s) = read_evidence_entries(s, count - 1); + ((&(Lists::Node::Cons(RoleEvidence::Proof(a), rest))), s) } , + } } , + } + } + + fn role_ctx_assumed(binding: Bytes::AddressRef) -> RoleCtx { + (&(RoleCtxNode::Assumed(load_role_table(binding), RBTreeMap::RBTreeMap::Nil))) + } + + fn role_ctx_for_validator(binding: Bytes::AddressRef, validator: Field) -> RoleCtx { + load_role_ctx(binding, validator, Options::Option::None) + } + + fn validate_user_axioms(tbl: RoleTable, leaves: Lists::List, acc: RBTreeMap::RBTreeMap) + -> RBTreeMap::RBTreeMap { + match (*(leaves)) { + Lists::Node::Nil => { acc } , + Lists::Node::Cons(a, rest) => { + assert_eq!(RBTreeMap::rbtree_map_lookup_or_default(a, role_addr_index(tbl), 0), 0, + "claim: user axiom is bound in the role table"); + match (*(Ingress::get_ci(a))) { + KernelTypes::KConstantInfo::Axiom(_, _, u) => { + assert_eq!(u, 0, "claim: user axiom is unsafe"); + validate_user_axioms(tbl, rest, RBTreeMap::rbtree_map_insert(a, 1, acc)) } , + _ => { + assert_eq!(0, 1, "claim: axioms tree entry is not an axiom"); + acc } , + } } , + } + } + + fn load_role_ctx(binding: Bytes::AddressRef, validator: Field, axioms_opt: Options::Option) -> RoleCtx { + let tbl = load_role_table(binding); + let axioms = match axioms_opt { + Options::Option::None => { RBTreeMap::RBTreeMap::Nil } , + Options::Option::Some(ax_root) => { + validate_user_axioms(tbl, KernelClaim::load_assumption_tree(ax_root), RBTreeMap::RBTreeMap::Nil) } , + }; + match validator { + 3 => { (&(RoleCtxNode::Mk(tbl, KernelRoleSpec::group_count(), axioms))) } , + 4 => { (&(RoleCtxNode::Assumed(tbl, axioms))) } , + _ => { + assert_eq!(0, 1, "claim: wrong validator identity"); + (&(RoleCtxNode::Mk(tbl, KernelRoleSpec::group_count(), axioms))) } , + } + } + + fn role_ctx_validator(rc: RoleCtx) -> Field { + 3 + role_ctx_is_assumed(rc) + } + + fn role_ctx_table(rc: RoleCtx) -> RoleTable { + match (*(rc)) { + RoleCtxNode::Mk(tbl, _, _) => { tbl } , + RoleCtxNode::Assumed(tbl, _) => { tbl } , + } + } + + fn role_ctx_axioms(rc: RoleCtx) -> RBTreeMap::RBTreeMap { + match (*(rc)) { + RoleCtxNode::Mk(_, _, axioms) => { axioms } , + RoleCtxNode::Assumed(_, axioms) => { axioms } , + } + } + + fn role_ctx_is_assumed(rc: RoleCtx) -> Field { + match (*(rc)) { + RoleCtxNode::Mk(_, _, _) => { 0 } , + RoleCtxNode::Assumed(_, _) => { 1 } , + } + } + + fn role_ctx_binding(rc: RoleCtx) -> Bytes::AddressRef { + match (*(role_ctx_table(rc))) { + RoleTableNode::Mk(binding, _, _, _) => { binding } , + } + } + + fn role_bound_addr_or_zero(tbl: RoleTable, r: Field) -> Bytes::AddressRef { + match (*(tbl)) { + RoleTableNode::Mk(_, by_role, _, _) => { + role_map_lookup_or_default(r, by_role, (&([UInt8::BYTE_0; 32]))) } , + } + } + + fn role_is_bound(tbl: RoleTable, r: Field) -> Field { + let a = role_bound_addr_or_zero(tbl, r); + match RBTreeMap::rbtree_map_lookup_or_default(a, role_addr_index(tbl), 0) - (r + 1) { + 0 => { 1 } , + _ => { 0 } , + } + } + + fn role_bound_addr(tbl: RoleTable, r: Field) -> Bytes::AddressRef { + assert_eq!(role_is_bound(tbl, r), 1, + "role table does not bind a role the claim needs"); + role_bound_addr_or_zero(tbl, r) + } + + fn role_addr_index(tbl: RoleTable) -> RBTreeMap::RBTreeMap { + match (*(tbl)) { + RoleTableNode::Mk(_, _, by_addr, _) => { by_addr } , + } + } + + fn role_of(rc: RoleCtx, a: Bytes::AddressRef) -> Field { + match (*(rc)) { + RoleCtxNode::Mk(tbl, limit, _) => { + let r1 = RBTreeMap::rbtree_map_lookup_or_default(a, role_addr_index(tbl), 0); + match r1 { + 0 => { 0 } , + _ => { + match UInt32::less_than_fields(KernelRoleSpec::role_group(r1 - 1), limit) { + 1 => { + group_admit(tbl, KernelRoleSpec::role_group(r1 - 1)); + r1 } , + _ => { 0 } , + } } , + } } , + RoleCtxNode::Assumed(tbl, _) => { + RBTreeMap::rbtree_map_lookup_or_default(a, role_addr_index(tbl), 0) } , + } + } + + fn role_index_of(rc: RoleCtx, a: Bytes::AddressRef) -> Field { + RBTreeMap::rbtree_map_lookup_or_default(a, role_addr_index(role_ctx_table(rc)), 0) + } + + fn role_is(rc: RoleCtx, a: Bytes::AddressRef, r: Field) -> Field { + match role_index_of(rc, a) - (r + 1) { + 0 => { + match role_of(rc, a) { + 0 => { 0 } , + _ => { 1 } , + } } , + _ => { 0 } , + } + } + + fn role_addr(rc: RoleCtx, r: Field) -> Bytes::AddressRef { + match (*(rc)) { + RoleCtxNode::Mk(tbl, limit, _) => { + assert_eq!(UInt32::less_than_fields(KernelRoleSpec::role_group(r), limit), 1, + "a role is used before its group is admitted"); + let a = role_bound_addr(tbl, r); + group_admit(tbl, KernelRoleSpec::role_group(r)); + a } , + RoleCtxNode::Assumed(tbl, _) => { role_bound_addr(tbl, r) } , + } + } + + fn role_used_implicitly(rc: RoleCtx, r: Field) -> Bytes::AddressRef { + let a = role_addr(rc, r); + KernelClaim::run_check_transitive(rc, a); + a + } + + fn group_admit(tbl: RoleTable, g: Field) -> () { + group_admit_needs(tbl, KernelRoleSpec::group_needs(g)); + let rc = (&(RoleCtxNode::Mk(tbl, group_validation_limit(g), RBTreeMap::RBTreeMap::Nil))); + validate_group_roles(rc, tbl, KernelRoleSpec::group_roles(g)) + } + + fn group_validation_limit(g: Field) -> Field { + let first_wf = KernelRoleSpec::first_well_founded_group(); + match UInt32::less_than_fields(g, first_wf) { + 1 => { g } , + _ => { + let first_equation = KernelRoleSpec::first_equation_group(); + match UInt32::less_than_fields(g, first_equation) { + 1 => { first_wf } , + _ => { first_equation } , + } } , + } + } + + fn role_admission_checks(r: Field) -> Field { + match KernelRoleSpec::role_spec_kind(r) { + 0 => { + match KernelRoleSpec::role_member_kind(r) { + 0 => { 1 } , + 1 => { 1 } , + 2 => { 1 } , + _ => { 0 } , + } } , + 2 => { 1 } , + 5 => { 1 } , + _ => { 0 } , + } + } + + fn walk_ctx(rc: RoleCtx, a: Bytes::AddressRef) -> RoleCtx { + match (*(rc)) { + RoleCtxNode::Mk(tbl, limit, _) => { + let r1 = RBTreeMap::rbtree_map_lookup_or_default(a, role_addr_index(tbl), 0); + match r1 { + 0 => { rc } , + _ => { + let g = KernelRoleSpec::role_group(r1 - 1); + match UInt32::less_than_fields(g, limit) * role_admission_checks(r1 - 1) { + 0 => { rc } , + _ => { (&(RoleCtxNode::Mk(tbl, group_validation_limit(g), RBTreeMap::RBTreeMap::Nil))) } , + } } , + } } , + RoleCtxNode::Assumed(_, _) => { rc } , + } + } + + fn walk_covered(rc: RoleCtx, a: Bytes::AddressRef) -> Field { + match (*(rc)) { + RoleCtxNode::Mk(_, _, _) => { 0 } , + RoleCtxNode::Assumed(tbl, _) => { + let r1 = RBTreeMap::rbtree_map_lookup_or_default(a, role_addr_index(tbl), 0); + match r1 { + 0 => { 0 } , + _ => { role_admission_checks(r1 - 1) } , + } } , + } + } + + fn validate_binding(binding: Bytes::AddressRef) -> () { + let tbl = load_role_table(binding); + assert_all_roles_bound(tbl, 0); + admit_all_groups(tbl, 0) + } + + fn assert_all_roles_bound(tbl: RoleTable, r: Field) -> () { + match r - KernelRoleSpec::role_count() { + 0 => { () } , + _ => { + assert_eq!(role_is_bound(tbl, r), 1, "binding claim: a role is unbound"); + assert_all_roles_bound(tbl, r + 1) } , + } + } + + fn admit_all_groups(tbl: RoleTable, g: Field) -> () { + match g - KernelRoleSpec::group_count() { + 0 => { () } , + _ => { + group_admit(tbl, g); + admit_all_groups(tbl, g + 1) } , + } + } + + fn group_admit_needs(tbl: RoleTable, needs: Lists::List) -> () { + match (*(needs)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(r, rest) => { + group_admit(tbl, KernelRoleSpec::role_group(r)); + group_admit_needs(tbl, rest) } , + } + } + + fn validate_group_roles(rc: RoleCtx, tbl: RoleTable, rs: Lists::List) -> () { + match (*(rs)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(r, rest) => { + validate_role(rc, tbl, r); + validate_group_roles(rc, tbl, rest) } , + } + } + + fn validate_role(rc: RoleCtx, tbl: RoleTable, r: Field) -> () { + let a = role_bound_addr(tbl, r); + let ci = (*(Ingress::get_ci(a))); + assert_eq!(KernelInfer::const_num_lvls(ci), KernelRoleSpec::role_levels(r), + "a bound role has the wrong number of universe parameters"); + match KernelRoleSpec::role_spec_kind(r) { + 0 => { validate_member(rc, tbl, r, a, ci) } , + 1 => { validate_anchor(rc, tbl, r, ci) } , + 2 => { validate_op(rc, tbl, r, a, ci) } , + 3 => { validate_standard_axiom(rc, tbl, r, ci) } , + 4 => { validate_inert_axiom(rc, tbl, r, ci) } , + 5 => { validate_eqns(rc, tbl, r, a, ci) } , + } + } + + fn assert_type_meets(rc: RoleCtx, ty: KernelTypes::KExpr, spec: KernelTypes::KExpr) -> () { + assert_eq!(KernelDefEq::k_is_def_eq(rc, ty, spec, (&(Lists::Node::Nil))), 1, + "a bound role's type does not meet its specification"); + () + } + + fn assert_safe_role(ci: KernelTypes::KConstantInfo) -> () { + assert_eq!(KernelCheck::is_unsafe_ci(ci), 0, "a bound role is unsafe"); + () + } + + fn validate_member(rc: RoleCtx, tbl: RoleTable, r: Field, a: Bytes::AddressRef, + ci: KernelTypes::KConstantInfo) -> () { + assert_safe_role(ci); + assert_type_meets(rc, KernelInfer::const_type_of(ci), KernelRoleSpec::role_type(tbl, r)); + match KernelRoleSpec::role_member_kind(r) { + 0 => { + match ci { + KernelTypes::KConstantInfo::Induct(_, _, _, _, nctors, _, _, _) => { + assert_eq!(nctors, KernelRoleSpec::role_ctor_count(r), + "a bound inductive has the wrong number of constructors"); + KernelClaim::run_check_transitive(rc, a) } , + } } , + 1 => { + match ci { + KernelTypes::KConstantInfo::Ctor(_, _, block, ind_idx, cidx, nparams, nfields, _) => { + let (ind_role, want_cidx, want_params, want_fields) = KernelRoleSpec::role_ctor_of(r); + match (*(Ingress::get_ci(role_bound_addr(tbl, ind_role)))) { + KernelTypes::KConstantInfo::Induct(_, _, _, _, _, _, ind_block, ind_ind_idx) => { + assert_eq!(Bytes::address_eq(block, ind_block), 1, + "a bound constructor is not its inductive's"); + assert_eq!(ind_idx, ind_ind_idx, + "a bound constructor is not its inductive's"); + () } , + }; + assert_eq!(cidx, want_cidx, "a bound constructor has the wrong index"); + assert_eq!(nparams, want_params, + "a bound constructor has the wrong number of parameters"); + assert_eq!(nfields, want_fields, + "a bound constructor has the wrong number of fields"); + KernelClaim::run_check_transitive(rc, a) } , + } } , + 2 => { + match ci { + KernelTypes::KConstantInfo::Rec(_, _, _, _, _, _, _, _, _, _, _) => { + KernelClaim::run_check_transitive(rc, a) } , + } } , + 3 => { + match ci { + KernelTypes::KConstantInfo::Axiom(_, ty, _) => { + KernelCheck::validate_expr_well_scoped(ty, 0, KernelRoleSpec::role_levels(r)); + KernelInfer::k_ensure_sort(rc, ty, (&(Lists::Node::Nil))); + () } , + } } , + 4 => { assert_quot_kind(ci, 0) } , + 5 => { assert_quot_kind(ci, 1) } , + 6 => { assert_quot_kind(ci, 2) } , + 7 => { assert_quot_kind(ci, 3) } , + } + } + + fn assert_quot_kind(ci: KernelTypes::KConstantInfo, want: Field) -> () { + match ci { + KernelTypes::KConstantInfo::Quot(_, _, kind) => { + let k = match kind { + Ixon::QuotKind::Typ => { 0 } , + Ixon::QuotKind::Ctor => { 1 } , + Ixon::QuotKind::Lift => { 2 } , + Ixon::QuotKind::Ind => { 3 } , + }; + assert_eq!(k, want, "a bound quotient constant has the wrong kind"); + () } , + } + } + + fn validate_anchor(rc: RoleCtx, tbl: RoleTable, r: Field, ci: KernelTypes::KConstantInfo) -> () { + assert_safe_role(ci); + assert_type_meets(rc, KernelInfer::const_type_of(ci), KernelRoleSpec::role_type(tbl, r)) + } + + fn validate_standard_axiom(rc: RoleCtx, tbl: RoleTable, r: Field, + ci: KernelTypes::KConstantInfo) -> () { + match ci { + KernelTypes::KConstantInfo::Axiom(nlvls, ty, u) => { + assert_eq!(u, 0, "a bound standard axiom is unsafe"); + KernelCheck::validate_expr_well_scoped(ty, 0, nlvls); + KernelInfer::k_ensure_sort(rc, ty, (&(Lists::Node::Nil))); + assert_type_meets(rc, ty, KernelRoleSpec::role_type(tbl, r)) } , + } + } + + fn validate_inert_axiom(rc: RoleCtx, tbl: RoleTable, r: Field, + ci: KernelTypes::KConstantInfo) -> () { + match ci { + KernelTypes::KConstantInfo::Axiom(nlvls, ty, u) => { + assert_eq!(u, 0, "a bound inert axiom is unsafe"); + KernelCheck::validate_expr_well_scoped(ty, 0, nlvls); + KernelInfer::k_ensure_sort(rc, ty, (&(Lists::Node::Nil))); + assert_type_meets(rc, ty, KernelRoleSpec::role_type(tbl, r)) } , + } + } + + fn role_evidence(tbl: RoleTable, r: Field) -> Lists::List { + match (*(tbl)) { + RoleTableNode::Mk(_, _, _, evidence) => { + role_map_lookup_or_default(r, evidence, (&(Lists::Node::Nil))) } , + } + } + + fn validate_op(rc: RoleCtx, tbl: RoleTable, r: Field, a: Bytes::AddressRef, + ci: KernelTypes::KConstantInfo) -> () { + match ci { + KernelTypes::KConstantInfo::Defn(_, ty, _, safety, _) => { + match safety { + Ixon::DefinitionSafety::Safe => { () } , + _ => { + assert_eq!(0, 1, "a bound operation is not a safe definition"); + () } , + }; + assert_type_meets(rc, ty, KernelRoleSpec::role_type(tbl, r)); + KernelClaim::run_check_transitive(rc, a); + let ev = role_evidence(tbl, r); + assert_eq!(Lists::length(ev), KernelRoleSpec::op_equation_count(r), + "an operation's evidence does not match its equations"); + validate_op_equations(rc, tbl, r, ev, 0) } , + } + } + + fn validate_op_equations(rc: RoleCtx, tbl: RoleTable, r: Field, + ev: Lists::List, k: Field) -> () { + match (*(ev)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(e, rest) => { + match KernelRoleSpec::op_evidence_is_proof(r) { + 0 => { + match e { + RoleEvidence::Defeq => { + assert_eq!(KernelDefEq::k_is_def_eq(rc, KernelRoleSpec::op_equation_lhs(tbl, r, k), + KernelRoleSpec::op_equation_rhs(tbl, r, k), (&(Lists::Node::Nil))), 1, + "an operation's equation does not hold by definition"); + () } , + RoleEvidence::Proof(_) => { + assert_eq!(0, 1, "a structural operation's evidence must be definitional"); + () } , + } } , + _ => { + match e { + RoleEvidence::Defeq => { + assert_eq!(0, 1, "a well-founded operation's evidence must be proofs"); + () } , + RoleEvidence::Proof(thm) => { + match (*(Ingress::get_ci(thm))) { + KernelTypes::KConstantInfo::Thm(nlvls, tty, _) => { + assert_eq!(nlvls, 0, "certificate theorem has universe parameters"); + KernelClaim::run_check_transitive(rc, thm); + assert_type_meets(rc, tty, KernelRoleSpec::op_certificate(tbl, r, k)) } , + } } , + } } , + }; + validate_op_equations(rc, tbl, r, rest, k + 1) } , + } + } + + fn validate_eqns(rc: RoleCtx, tbl: RoleTable, r: Field, a: Bytes::AddressRef, + ci: KernelTypes::KConstantInfo) -> () { + match ci { + KernelTypes::KConstantInfo::Defn(nlvls, ty, _, safety, _) => { + match safety { + Ixon::DefinitionSafety::Safe => { () } , + _ => { + assert_eq!(0, 1, "a bound definition is not safe"); + () } , + }; + assert_eq!(nlvls, KernelRoleSpec::role_levels(r), + "a bound definition has another number of universe parameters"); + assert_type_meets(rc, ty, KernelRoleSpec::role_type(tbl, r)); + KernelClaim::run_check_transitive(rc, a); + let ev = role_evidence(tbl, r); + assert_eq!(Lists::length(ev), KernelRoleSpec::eqns_equation_count(r), + "a definition's evidence does not match its equations"); + validate_eqns_equations(rc, tbl, r, ev, 0) } , + } + } + + fn validate_eqns_equations(rc: RoleCtx, tbl: RoleTable, r: Field, + ev: Lists::List, k: Field) -> () { + match (*(ev)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(e, rest) => { + match e { + RoleEvidence::Defeq => { + assert_eq!(KernelRoleSpec::eqns_conditional(r, k), 0, + "a conditional equation's evidence must be a proof"); + assert_eq!(KernelDefEq::k_is_def_eq(rc, KernelRoleSpec::eqns_lhs(tbl, r, k), KernelRoleSpec::eqns_rhs(tbl, r, k), + (&(Lists::Node::Nil))), 1, + "a definition's equation does not hold by definition"); + () } , + RoleEvidence::Proof(thm) => { + match (*(Ingress::get_ci(thm))) { + KernelTypes::KConstantInfo::Thm(nlvls, tty, _) => { + assert_eq!(nlvls, KernelRoleSpec::role_levels(r), + "an equation's proof has another number of universe parameters"); + KernelClaim::run_check_transitive(rc, thm); + assert_type_meets(rc, tty, KernelRoleSpec::eqns_statement(tbl, r, k)) } , + } } , + }; + validate_eqns_equations(rc, tbl, r, rest, k + 1) } , + } + } + + fn axiom_standing(rc: RoleCtx, a: Bytes::AddressRef) -> Field { + let tbl = role_ctx_table(rc); + let r1 = RBTreeMap::rbtree_map_lookup_or_default(a, role_addr_index(tbl), 0); + match r1 { + 0 => { RBTreeMap::rbtree_map_lookup_or_default(a, role_ctx_axioms(rc), 0) } , + _ => { + let standing = axiom_role_standing(r1); + match standing { + 0 => { 0 } , + _ => { + match role_of(rc, a) { + 0 => { 0 } , + _ => { standing } , + } } , + } } , + } + } + + fn axiom_role_standing(r1: Field) -> Field { + match r1 { + 0 => { 0 } , + _ => { + let r = r1 - 1; + match r - KernelRoleSpec::role_propext() { + 0 => { 1 } , + _ => { + match r - KernelRoleSpec::role_choice() { + 0 => { 1 } , + _ => { + match r - KernelRoleSpec::role_quot_sound() { + 0 => { 1 } , + _ => { + match r - KernelRoleSpec::role_sorry_ax() { + 0 => { 2 } , + _ => { 0 } , + } } , + } } , + } } , + } } , + } + } + + fn assert_ref_allowed(rc: RoleCtx, a: Bytes::AddressRef) -> () { + match axiom_standing(rc, a) { + 2 => { + assert_eq!(0, 1, "a constant uses `sorryAx`"); + () } , + _ => { () } , + } + } + + fn role_map_lookup_or_default(key: Field, tree: RoleMap, default: V) -> V { + match tree { + RoleMap::Nil => { default } , + RoleMap::Node(_, k, v, left, right) => { + let eq = key - k; + match eq { + 0 => { v } , + _ => { + match UInt32::less_than_fields(key, k) { + 1 => { role_map_lookup_or_default(key, (*(left)), default) } , + _ => { role_map_lookup_or_default(key, (*(right)), default) } , + } } , + } } , + } + } + + fn role_ctx_limit(rc: RoleCtx) -> Field { + match (*(rc)) { + RoleCtxNode::Assumed(_, _) => { 0 } , + RoleCtxNode::Mk(_, limit, _) => { limit } , + } + } +} diff --git a/IxVM/IxVM/Modules/KernelSubst.aiur b/IxVM/IxVM/Modules/KernelSubst.aiur new file mode 100644 index 000000000..2bb73ccc9 --- /dev/null +++ b/IxVM/IxVM/Modules/KernelSubst.aiur @@ -0,0 +1,423 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module KernelSubst { + fn expr_lbr(e: KernelTypes::KExpr) -> Field { + match (*(e)) { + KernelTypes::KExprNode::BVar(i) => { i + 1 } , + KernelTypes::KExprNode::Srt(_) => { 0 } , + KernelTypes::KExprNode::Const(_, _) => { 0 } , + KernelTypes::KExprNode::Lit(_) => { 0 } , + KernelTypes::KExprNode::App(f, a) => { lbr_max(expr_lbr(f), expr_lbr(a)) } , + KernelTypes::KExprNode::Lam(ty, body) => { + lbr_max(expr_lbr(ty), lbr_dec(expr_lbr(body))) } , + KernelTypes::KExprNode::Forall(ty, body) => { + lbr_max(expr_lbr(ty), lbr_dec(expr_lbr(body))) } , + KernelTypes::KExprNode::Let(ty, val, body) => { expr_lbr_let(ty, val, body) } , + KernelTypes::KExprNode::Proj(_, _, e1) => { expr_lbr(e1) } , + } + } + + fn expr_lbr_let(ty: KernelTypes::KExpr, val: KernelTypes::KExpr, body: KernelTypes::KExpr) -> Field { + lbr_max(lbr_max(expr_lbr(ty), expr_lbr(val)), + lbr_dec(expr_lbr(body))) + } + + fn lbr_max(a: Field, b: Field) -> Field { + match UInt32::less_than_fields(a, b) { + 1 => { b } , + 0 => { a } , + } + } + + fn lbr_dec(n: Field) -> Field { + match n { + 0 => { 0 } , + _ => { n - 1 } , + } + } + + fn lbr_min(a: Field, b: Field) -> Field { + match UInt32::less_than_fields(a, b) { + 1 => { a } , + 0 => { b } , + } + } + + fn has_bvar_in_range(e: KernelTypes::KExpr, lo: Field, hi: Field) -> Field { + match (*(e)) { + KernelTypes::KExprNode::BVar(i) => { has_bvar_in_range_bvar(i, lo, hi) } , + KernelTypes::KExprNode::Srt(_) => { 0 } , + KernelTypes::KExprNode::Const(_, _) => { 0 } , + KernelTypes::KExprNode::Lit(_) => { 0 } , + KernelTypes::KExprNode::App(f, a) => { + match has_bvar_in_range(f, lo, hi) { + 1 => { 1 } , + 0 => { has_bvar_in_range(a, lo, hi) } , + } } , + KernelTypes::KExprNode::Lam(ty, body) => { has_bvar_in_range_binder(ty, body, lo, hi) } , + KernelTypes::KExprNode::Forall(ty, body) => { has_bvar_in_range_binder(ty, body, lo, hi) } , + KernelTypes::KExprNode::Let(ty, val, body) => { has_bvar_in_range_let(ty, val, body, lo, hi) } , + KernelTypes::KExprNode::Proj(_, _, e1) => { has_bvar_in_range(e1, lo, hi) } , + } + } + + fn has_bvar_in_range_bvar(i: Field, lo: Field, hi: Field) -> Field { + match UInt32::less_than_fields(i, lo) { + 1 => { 0 } , + 0 => { UInt32::less_than_fields(i, hi) } , + } + } + + fn has_bvar_in_range_binder(ty: KernelTypes::KExpr, body: KernelTypes::KExpr, lo: Field, hi: Field) -> Field { + match has_bvar_in_range(ty, lo, hi) { + 1 => { 1 } , + 0 => { has_bvar_in_range(body, lo + 1, hi + 1) } , + } + } + + fn has_bvar_in_range_let(ty: KernelTypes::KExpr, val: KernelTypes::KExpr, body: KernelTypes::KExpr, lo: Field, hi: Field) -> Field { + match has_bvar_in_range(ty, lo, hi) { + 1 => { 1 } , + 0 => { + match has_bvar_in_range(val, lo, hi) { + 1 => { 1 } , + 0 => { has_bvar_in_range(body, lo + 1, hi + 1) } , + } } , + } + } + + inline fn ctx_reachable(types: Lists::List, base: Field) -> Field { + let len = Lists::length(types); + ctx_seek_cut(types, lbr_min(base, len)) + } + + fn ctx_seek_cut(types: Lists::List, need: Field) -> Field { + let c = ctx_next_cut(types); + match UInt32::less_than_fields(c, need) { + 0 => { c } , + 1 => { c + ctx_seek_cut(Lists::drop(types, c), need - c) } , + } + } + + fn ctx_next_cut(types: Lists::List) -> Field { + let Lists::Node::Cons(ty, rest) = (*(types)); + 1 + ctx_close_cut(rest, expr_lbr(ty)) + } + + fn ctx_close_cut(rest: Lists::List, l: Field) -> Field { + match l { + 0 => { 0 } , + _ => { + match (*(rest)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(_, _) => { + let c = ctx_next_cut(rest); + match UInt32::less_than_fields(c, l) { + 0 => { c } , + 1 => { c + ctx_close_cut(Lists::drop(rest, c), l - c) } , + } } , + } } , + } + } + + fn ctx_trim(types: Lists::List, base: Field) -> Lists::List { + match base { + 0 => { (&(Lists::Node::Nil)) } , + _ => { + match UInt32::less_than_fields(base, Lists::length(types)) { + 0 => { types } , + 1 => { Lists::take(types, ctx_reachable(types, base)) } , + } } , + } + } + + fn expr_glb(e: KernelTypes::KExpr, c: Field) -> Field { + + match UInt32::less_than_fields(expr_lbr(e), c + 1) { + 1 => { 4294967295 } , + _ => { expr_glb_walk(e, c) } , + } + } + + fn expr_glb_walk(e: KernelTypes::KExpr, c: Field) -> Field { + + match (*(e)) { + KernelTypes::KExprNode::BVar(i) => { + match UInt32::less_than_fields(i, c) { + 1 => { 4294967295 } , + 0 => { i - c } , + } } , + KernelTypes::KExprNode::Srt(_) => { 4294967295 } , + KernelTypes::KExprNode::Const(_, _) => { 4294967295 } , + KernelTypes::KExprNode::Lit(_) => { 4294967295 } , + KernelTypes::KExprNode::App(f, a) => { match expr_glb(f, c) { + 0 => { 0 } , + n => { lbr_min(n, expr_glb(a, c)) } , + } } , + KernelTypes::KExprNode::Lam(ty, body) => { expr_glb_binder(ty, body, c) } , + KernelTypes::KExprNode::Forall(ty, body) => { expr_glb_binder(ty, body, c) } , + KernelTypes::KExprNode::Let(ty, val, body) => { expr_glb_let(ty, val, body, c) } , + KernelTypes::KExprNode::Proj(_, _, e1) => { expr_glb(e1, c) } , + } + } + + fn expr_glb_binder(ty: KernelTypes::KExpr, body: KernelTypes::KExpr, c: Field) -> Field { + match expr_glb(ty, c) { + 0 => { 0 } , + n => { lbr_min(n, expr_glb(body, c + 1)) } , + } + } + + fn expr_glb_let(ty: KernelTypes::KExpr, val: KernelTypes::KExpr, body: KernelTypes::KExpr, c: Field) -> Field { + match expr_glb(ty, c) { + 0 => { 0 } , + n => { match expr_glb(val, c) { + 0 => { 0 } , + m => { lbr_min(lbr_min(n, m), expr_glb(body, c + 1)) } , + } } , + } + } + + fn expr_lift(e: KernelTypes::KExpr, shift: Field, cutoff: Field) -> KernelTypes::KExpr { + match shift { + 0 => { e } , + _ => { + let l = expr_lbr(e); + match UInt32::less_than_fields(cutoff, l) { + 0 => { e } , + 1 => { expr_lift_walk(e, shift, cutoff) } , + } } , + } + } + + fn expr_lift_walk(e: KernelTypes::KExpr, shift: Field, cutoff: Field) -> KernelTypes::KExpr { + match (*(e)) { + KernelTypes::KExprNode::BVar(i) => { expr_lift_bvar(i, shift, cutoff) } , + KernelTypes::KExprNode::Srt(l) => { (&(KernelTypes::KExprNode::Srt(l))) } , + KernelTypes::KExprNode::Const(idx, lvls) => { (&(KernelTypes::KExprNode::Const(idx, lvls))) } , + KernelTypes::KExprNode::App(f, a) => { + (&(KernelTypes::KExprNode::App( + expr_lift(f, shift, cutoff), + expr_lift(a, shift, cutoff)))) } , + KernelTypes::KExprNode::Lam(ty, body) => { + (&(KernelTypes::KExprNode::Lam( + expr_lift(ty, shift, cutoff), + expr_lift(body, shift, cutoff + 1)))) } , + KernelTypes::KExprNode::Forall(ty, body) => { + (&(KernelTypes::KExprNode::Forall( + expr_lift(ty, shift, cutoff), + expr_lift(body, shift, cutoff + 1)))) } , + KernelTypes::KExprNode::Let(ty, val, body) => { expr_lift_let(ty, val, body, shift, cutoff) } , + KernelTypes::KExprNode::Lit(lit) => { (&(KernelTypes::KExprNode::Lit(lit))) } , + KernelTypes::KExprNode::Proj(tidx, fidx, e1) => { + (&(KernelTypes::KExprNode::Proj(tidx, fidx, expr_lift(e1, shift, cutoff)))) } , + } + } + + fn expr_lift_bvar(i: Field, shift: Field, cutoff: Field) -> KernelTypes::KExpr { + match UInt32::less_than_fields(i, cutoff) { + 1 => { (&(KernelTypes::KExprNode::BVar(i))) } , + 0 => { (&(KernelTypes::KExprNode::BVar(i + shift))) } , + } + } + + fn expr_lift_let(ty: KernelTypes::KExpr, val: KernelTypes::KExpr, body: KernelTypes::KExpr, shift: Field, cutoff: Field) + -> KernelTypes::KExpr { + (&(KernelTypes::KExprNode::Let( + expr_lift(ty, shift, cutoff), + expr_lift(val, shift, cutoff), + expr_lift(body, shift, cutoff + 1)))) + } + + fn expr_lower(e: KernelTypes::KExpr, shift: Field, cutoff: Field) -> KernelTypes::KExpr { + match shift { + 0 => { e } , + _ => { + let l = expr_lbr(e); + match UInt32::less_than_fields(cutoff, l) { + 0 => { e } , + 1 => { expr_lower_walk(e, shift, cutoff) } , + } } , + } + } + + fn expr_lower_walk(e: KernelTypes::KExpr, shift: Field, cutoff: Field) -> KernelTypes::KExpr { + match (*(e)) { + + KernelTypes::KExprNode::BVar(i) => { (&(KernelTypes::KExprNode::BVar(i - shift))) } , + KernelTypes::KExprNode::Srt(l) => { (&(KernelTypes::KExprNode::Srt(l))) } , + KernelTypes::KExprNode::Const(idx, lvls) => { (&(KernelTypes::KExprNode::Const(idx, lvls))) } , + KernelTypes::KExprNode::App(f, a) => { + (&(KernelTypes::KExprNode::App( + expr_lower(f, shift, cutoff), + expr_lower(a, shift, cutoff)))) } , + KernelTypes::KExprNode::Lam(ty, body) => { + (&(KernelTypes::KExprNode::Lam( + expr_lower(ty, shift, cutoff), + expr_lower(body, shift, cutoff + 1)))) } , + KernelTypes::KExprNode::Forall(ty, body) => { + (&(KernelTypes::KExprNode::Forall( + expr_lower(ty, shift, cutoff), + expr_lower(body, shift, cutoff + 1)))) } , + KernelTypes::KExprNode::Let(ty, val, body) => { expr_lower_let(ty, val, body, shift, cutoff) } , + KernelTypes::KExprNode::Lit(lit) => { (&(KernelTypes::KExprNode::Lit(lit))) } , + KernelTypes::KExprNode::Proj(tidx, fidx, e1) => { + (&(KernelTypes::KExprNode::Proj(tidx, fidx, expr_lower(e1, shift, cutoff)))) } , + } + } + + fn expr_lower_let(ty: KernelTypes::KExpr, val: KernelTypes::KExpr, body: KernelTypes::KExpr, shift: Field, cutoff: Field) -> KernelTypes::KExpr { + (&(KernelTypes::KExprNode::Let( + expr_lower(ty, shift, cutoff), + expr_lower(val, shift, cutoff), + expr_lower(body, shift, cutoff + 1)))) + } + + fn expr_has_bvar_at(e: KernelTypes::KExpr, depth: Field) -> Field { + match (*(e)) { + KernelTypes::KExprNode::BVar(i) => { match i - depth { 0 => { 1 } , _ => { 0 } , } } , + KernelTypes::KExprNode::App(f, a) => { + match expr_has_bvar_at(f, depth) { + 1 => { 1 } , + _ => { expr_has_bvar_at(a, depth) } , + } } , + KernelTypes::KExprNode::Lam(ty, body) => { expr_has_bvar_at_binder(ty, body, depth) } , + KernelTypes::KExprNode::Forall(ty, body) => { expr_has_bvar_at_binder(ty, body, depth) } , + KernelTypes::KExprNode::Let(ty, val, body) => { expr_has_bvar_at_let(ty, val, body, depth) } , + KernelTypes::KExprNode::Proj(_, _, inner) => { expr_has_bvar_at(inner, depth) } , + _ => { 0 } , + } + } + + fn expr_has_bvar_at_binder(ty: KernelTypes::KExpr, body: KernelTypes::KExpr, depth: Field) -> Field { + match expr_has_bvar_at(ty, depth) { + 1 => { 1 } , + _ => { expr_has_bvar_at(body, depth + 1) } , + } + } + + fn expr_has_bvar_at_let(ty: KernelTypes::KExpr, val: KernelTypes::KExpr, body: KernelTypes::KExpr, depth: Field) -> Field { + match expr_has_bvar_at(ty, depth) { + 1 => { 1 } , + _ => { + match expr_has_bvar_at(val, depth) { + 1 => { 1 } , + _ => { expr_has_bvar_at(body, depth + 1) } , + } } , + } + } + + fn expr_inst1(e: KernelTypes::KExpr, arg: KernelTypes::KExpr, depth: Field) -> KernelTypes::KExpr { + + let l = expr_lbr(e); + match UInt32::less_than_fields(depth, l) { + 0 => { e } , + 1 => { + match expr_has_bvar_at(e, depth) { + 1 => { expr_inst1_walk(e, arg, depth) } , + _ => { expr_lower(e, 1, depth + 1) } , + } } , + } + } + + fn expr_inst1_walk(e: KernelTypes::KExpr, arg: KernelTypes::KExpr, depth: Field) -> KernelTypes::KExpr { + match (*(e)) { + KernelTypes::KExprNode::BVar(i) => { expr_inst1_bvar(i, arg, depth) } , + KernelTypes::KExprNode::Srt(l) => { (&(KernelTypes::KExprNode::Srt(l))) } , + KernelTypes::KExprNode::Const(idx, lvls) => { (&(KernelTypes::KExprNode::Const(idx, lvls))) } , + KernelTypes::KExprNode::App(f, a) => { + (&(KernelTypes::KExprNode::App( + expr_inst1(f, arg, depth), + expr_inst1(a, arg, depth)))) } , + KernelTypes::KExprNode::Lam(ty, body) => { + (&(KernelTypes::KExprNode::Lam( + expr_inst1(ty, arg, depth), + expr_inst1(body, arg, depth + 1)))) } , + KernelTypes::KExprNode::Forall(ty, body) => { + (&(KernelTypes::KExprNode::Forall( + expr_inst1(ty, arg, depth), + expr_inst1(body, arg, depth + 1)))) } , + KernelTypes::KExprNode::Let(ty, val, body) => { expr_inst1_let(ty, val, body, arg, depth) } , + KernelTypes::KExprNode::Lit(lit) => { (&(KernelTypes::KExprNode::Lit(lit))) } , + KernelTypes::KExprNode::Proj(tidx, fidx, e1) => { + (&(KernelTypes::KExprNode::Proj(tidx, fidx, expr_inst1(e1, arg, depth)))) } , + } + } + + fn expr_inst1_bvar(i: Field, arg: KernelTypes::KExpr, depth: Field) -> KernelTypes::KExpr { + match UInt32::less_than_fields(i, depth) { + 1 => { (&(KernelTypes::KExprNode::BVar(i))) } , + 0 => { + match i - depth { + 0 => { expr_lift(arg, depth, 0) } , + _ => { (&(KernelTypes::KExprNode::BVar(i - 1))) } , + } } , + } + } + + fn expr_inst1_let(ty: KernelTypes::KExpr, val: KernelTypes::KExpr, body: KernelTypes::KExpr, arg: KernelTypes::KExpr, depth: Field) + -> KernelTypes::KExpr { + (&(KernelTypes::KExprNode::Let( + expr_inst1(ty, arg, depth), + expr_inst1(val, arg, depth), + expr_inst1(body, arg, depth + 1)))) + } + + fn expr_inst_many(e: KernelTypes::KExpr, substs: Lists::List, depth: Field) -> KernelTypes::KExpr { + let n = Lists::length(substs); + match n { + 0 => { e } , + _ => { + let l = expr_lbr(e); + match UInt32::less_than_fields(depth, l) { + 0 => { e } , + 1 => { + match has_bvar_in_range(e, depth, depth + n) { + 1 => { expr_inst_many_walk(e, substs, depth) } , + _ => { expr_lower(e, n, depth + n) } , + } } , + } } , + } + } + + fn expr_inst_many_bvar(i: Field, substs: Lists::List, depth: Field) -> KernelTypes::KExpr { + let n = Lists::length(substs); + let ofs = i - depth; + match UInt32::less_than_fields(ofs, n) { + 1 => { expr_lift(Lists::lookup(substs, ofs), depth, 0) } , + 0 => { (&(KernelTypes::KExprNode::BVar(i - n))) } , + } + } + + fn expr_inst_many_walk(e: KernelTypes::KExpr, substs: Lists::List, depth: Field) -> KernelTypes::KExpr { + match (*(e)) { + KernelTypes::KExprNode::BVar(i) => { expr_inst_many_bvar(i, substs, depth) } , + KernelTypes::KExprNode::Srt(l) => { (&(KernelTypes::KExprNode::Srt(l))) } , + KernelTypes::KExprNode::Const(idx, lvls) => { (&(KernelTypes::KExprNode::Const(idx, lvls))) } , + KernelTypes::KExprNode::App(f, a) => { + (&(KernelTypes::KExprNode::App( + expr_inst_many(f, substs, depth), + expr_inst_many(a, substs, depth)))) } , + KernelTypes::KExprNode::Lam(ty, body) => { + (&(KernelTypes::KExprNode::Lam( + expr_inst_many(ty, substs, depth), + expr_inst_many(body, substs, depth + 1)))) } , + KernelTypes::KExprNode::Forall(ty, body) => { + (&(KernelTypes::KExprNode::Forall( + expr_inst_many(ty, substs, depth), + expr_inst_many(body, substs, depth + 1)))) } , + KernelTypes::KExprNode::Let(ty, val, body) => { + expr_inst_many_let(ty, val, body, substs, depth) } , + KernelTypes::KExprNode::Lit(lit) => { (&(KernelTypes::KExprNode::Lit(lit))) } , + KernelTypes::KExprNode::Proj(tidx, fidx, e1) => { + (&(KernelTypes::KExprNode::Proj(tidx, fidx, expr_inst_many(e1, substs, depth)))) } , + } + } + + fn expr_inst_many_let(ty: KernelTypes::KExpr, val: KernelTypes::KExpr, body: KernelTypes::KExpr, + substs: Lists::List, depth: Field) -> KernelTypes::KExpr { + (&(KernelTypes::KExprNode::Let( + expr_inst_many(ty, substs, depth), + expr_inst_many(val, substs, depth), + expr_inst_many(body, substs, depth + 1)))) + } +} diff --git a/IxVM/IxVM/Modules/KernelTypes.aiur b/IxVM/IxVM/Modules/KernelTypes.aiur new file mode 100644 index 000000000..d9c85ba83 --- /dev/null +++ b/IxVM/IxVM/Modules/KernelTypes.aiur @@ -0,0 +1,57 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module KernelTypes { + enum KLevelNode { + Zero, + Succ(KLevel), + Max(KLevel, KLevel), + IMax(KLevel, KLevel), + Param(Field) + } + + type KLevel = &KLevelNode; + + type KLimbs = Lists::List; + + enum KLiteral { + Nat(KLimbs), + Str(Bytes::Stream) + } + + enum KExprNode { + BVar(Field), + Srt(KLevel), + Const(Bytes::AddressRef, Lists::List), + App(KExpr, KExpr), + Lam(KExpr, KExpr), + Forall(KExpr, KExpr), + Let(KExpr, KExpr, KExpr), + Lit(KLiteral), + Proj(Bytes::AddressRef, Field, KExpr) + } + + type KExpr = &KExprNode; + + enum KRecRule { + Mk(Field, Field, KExpr) + } + + enum KConstantInfo { + Axiom(Field, KExpr, Field), + Defn(Field, KExpr, KExpr, Ixon::DefinitionSafety, Field), + Thm(Field, KExpr, KExpr), + Opaque(Field, KExpr, KExpr, Field), + Quot(Field, KExpr, Ixon::QuotKind), + Induct(Field, KExpr, Field, Field, Field, Field, Bytes::AddressRef, Field), + Ctor(Field, KExpr, Bytes::AddressRef, Field, Field, Field, Field, Field), + Rec(Field, KExpr, Field, Field, Field, Field, Lists::List, Field, Field, Bytes::AddressRef, Field) + } + + fn collect_spine(e: KExpr) -> (KExpr, Lists::List) { + match (*(e)) { + KExprNode::App(f, a) => { + let (head, args) = collect_spine(f); + (head, Lists::snoc(args, a)) } , + _ => { (e, (&(Lists::Node::Nil))) } , + } + } +} diff --git a/IxVM/IxVM/Modules/KernelWhnf.aiur b/IxVM/IxVM/Modules/KernelWhnf.aiur new file mode 100644 index 000000000..6339f5975 --- /dev/null +++ b/IxVM/IxVM/Modules/KernelWhnf.aiur @@ -0,0 +1,949 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module KernelWhnf { + fn apply_spine(head: KernelTypes::KExpr, spine: Lists::List) -> KernelTypes::KExpr { + match (*(spine)) { + Lists::Node::Nil => { head } , + Lists::Node::Cons(a, rest) => { + apply_spine((&(KernelTypes::KExprNode::App(head, a))), rest) } , + } + } + + fn peel_beta(lam: KernelTypes::KExpr, spine: Lists::List, acc: Lists::List) + -> (KernelTypes::KExpr, Lists::List, Lists::List) { + match (*(lam)) { + KernelTypes::KExprNode::Lam(_, body) => { + match (*(spine)) { + Lists::Node::Cons(a, rest) => { + peel_beta(body, rest, (&(Lists::Node::Cons(a, acc)))) } , + Lists::Node::Nil => { (lam, acc, spine) } , + } } , + _ => { (lam, acc, spine) } , + } + } + + fn whnf_apply_beta(rc: KernelRoles::RoleCtx, spine: Lists::List, lam: KernelTypes::KExpr, types: Lists::List) -> KernelTypes::KExpr { + match peel_beta(lam, spine, (&(Lists::Node::Nil))) { + (deep, consumed, rest) => { + match Lists::length(consumed) { + 0 => { apply_spine(lam, spine) } , + 1 => { + let body2 = KernelSubst::expr_inst1(deep, Lists::lookup(consumed, 0), 0); + whnf_with_spine(rc, body2, rest, types) } , + _ => { + let body2 = KernelSubst::expr_inst_many(deep, consumed, 0); + whnf_with_spine(rc, body2, rest, types) } , + } } , + } + } + + fn whnf_with_spine(rc: KernelRoles::RoleCtx, head: KernelTypes::KExpr, spine: Lists::List, types: Lists::List) -> KernelTypes::KExpr { + match (*(head)) { + KernelTypes::KExprNode::App(f, a) => { + match KernelTypes::collect_spine(head) { + (inner_head, inner_spine) => { + whnf_with_spine(rc, inner_head, Lists::concat(inner_spine, spine), types) } , + } } , + KernelTypes::KExprNode::Lam(ty, body) => { + whnf_apply_beta(rc, spine, head, types) } , + KernelTypes::KExprNode::Const(addr, lvls) => { + whnf_const_head(rc, addr, lvls, head, spine, types) } , + KernelTypes::KExprNode::Let(_, val, body) => { + let next = KernelSubst::expr_inst1(body, val, 0); + whnf_with_spine(rc, next, spine, types) } , + KernelTypes::KExprNode::Proj(struct_addr, fidx, inner) => { + whnf_proj_head(rc, struct_addr, fidx, inner, spine, types) } , + _ => { apply_spine(head, spine) } , + } + } + + fn whnf_proj_head(rc: KernelRoles::RoleCtx, struct_addr: Bytes::AddressRef, fidx: Field, inner: KernelTypes::KExpr, + spine: Lists::List, types: Lists::List) -> KernelTypes::KExpr { + let inner_whnf = whnf(rc, inner, types); + + let inner_exp = KernelNatPrim::str_lit_to_ctor_app_or_self(rc, inner_whnf, types); + match KernelTypes::collect_spine(inner_exp) { + (inner_head, inner_args) => { + match (*(inner_head)) { + KernelTypes::KExprNode::Const(_, _) => { + match (*(whnf_get_ctor_or_none(inner_head))) { + KernelTypes::KConstantInfo::Ctor(_, _, _, _, _, nparams, _, _) => { + let field = Lists::lookup(inner_args, nparams + fidx); + whnf_with_spine(rc, field, spine, types) } , + _ => { + let stuck = (&(KernelTypes::KExprNode::Proj(struct_addr, fidx, inner_whnf))); + apply_spine(stuck, spine) } , + } } , + _ => { + let stuck = (&(KernelTypes::KExprNode::Proj(struct_addr, fidx, inner_whnf))); + apply_spine(stuck, spine) } , + } } , + } + } + + fn whnf_get_ctor_or_none(head: KernelTypes::KExpr) -> &KernelTypes::KConstantInfo { + match (*(head)) { + KernelTypes::KExprNode::Const(addr, _) => { Ingress::get_ci(addr) } , + _ => { + (&(KernelTypes::KConstantInfo::Axiom(0, (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))), 0))) } , + } + } + + fn whnf_spine(rc: KernelRoles::RoleCtx, spine: Lists::List, types: Lists::List) -> Lists::List { + match (*(spine)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(a, rest) => { + let aw = whnf(rc, a, types); + (&(Lists::Node::Cons(aw, whnf_spine(rc, rest, types)))) } , + } + } + + fn try_nat_dispatch_prewhnf(rc: KernelRoles::RoleCtx, head_addr: Bytes::AddressRef, op: Field, spine: Lists::List, + types: Lists::List) -> (Field, KernelTypes::KExpr) { + let spine_w = whnf_spine(rc, spine, types); + KernelNatPrim::try_nat_dispatch(rc, head_addr, op, spine_w, types) + } + + fn bitvec_prep_spine(rc: KernelRoles::RoleCtx, spine: Lists::List, types: Lists::List) + -> Lists::List { + let spine_w = whnf_spine(rc, spine, types); + match (*(spine_w)) { + Lists::Node::Nil => { spine_w } , + Lists::Node::Cons(width_e, rest) => { + match (*(rest)) { + Lists::Node::Nil => { spine_w } , + Lists::Node::Cons(val_e, tail) => { + match KernelTypes::collect_spine(val_e) { + (vh, va) => { + let va_w = whnf_spine(rc, va, types); + let val_e2 = apply_spine(vh, va_w); + let width_w = whnf(rc, width_e, types); + (&(Lists::Node::Cons(width_w, + (&(Lists::Node::Cons(val_e2, tail)))))) } , + } } , + } } , + } + } + + fn prim_family(rc: KernelRoles::RoleCtx, a: Bytes::AddressRef) -> (Field, Field) { + let r1 = KernelRoles::role_index_of(rc, a); + let (f, op) = match r1 { 0 => { (0, 0) } , _ => { KernelRoleSpec::role_prim_family(r1 - 1) } , }; + match f { + 0 => { (0, 0) } , + _ => { match KernelRoles::role_of(rc, a) { 0 => { (0, 0) } , _ => { (f, op) } , } } , + } + } + + fn try_prim_dispatch(rc: KernelRoles::RoleCtx, addr: Bytes::AddressRef, lvls: Lists::List, + spine: Lists::List, + types: Lists::List) -> (Field, KernelTypes::KExpr) { + let (fam, op) = prim_family(rc, addr); + match fam { + 1 => { try_nat_dispatch_prewhnf(rc, addr, op, spine, types) } , + 2 => { + let spine_w = whnf_spine(rc, spine, types); + KernelNatPrim::try_str_dispatch(rc, addr, op, spine_w, types) } , + 3 => { KernelNatPrim::try_bitvec_dispatch(rc, op, spine, types) } , + 5 => { KernelInfer::try_dec_dispatch(rc, addr, op, lvls, spine, types) } , + 6 => { KernelNatPrim::try_int_prim_dispatch(rc, op, spine, types) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } + } + + fn try_quot_iota(rc: KernelRoles::RoleCtx, addr: Bytes::AddressRef, spine: Lists::List, + types: Lists::List) -> (Field, KernelTypes::KExpr) { + match KernelRoles::role_is(rc, addr, KernelRoleSpec::role_quot_lift()) { + 1 => { try_quot_lift(rc, spine, types) } , + _ => { + match KernelRoles::role_is(rc, addr, KernelRoleSpec::role_quot_ind()) { + 1 => { try_quot_ind(rc, spine, types) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + } + } + + fn try_quot_lift(rc: KernelRoles::RoleCtx, spine: Lists::List, types: Lists::List) -> (Field, KernelTypes::KExpr) { + let n = Lists::length(spine); + match UInt32::less_than_fields(n, 6) { + 1 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + let f = Lists::lookup(spine, 3); + let q = Lists::lookup(spine, 5); + match quot_extract_arg(rc, q, types) { + (1, a) => { + let post = Lists::drop(spine, 6); + (1, apply_spine((&(KernelTypes::KExprNode::App(f, a))), post)) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + } + } + + fn try_quot_ind(rc: KernelRoles::RoleCtx, spine: Lists::List, types: Lists::List) -> (Field, KernelTypes::KExpr) { + let n = Lists::length(spine); + match UInt32::less_than_fields(n, 5) { + 1 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + let m = Lists::lookup(spine, 3); + let q = Lists::lookup(spine, 4); + match quot_extract_arg(rc, q, types) { + (1, a) => { + let post = Lists::drop(spine, 5); + (1, apply_spine((&(KernelTypes::KExprNode::App(m, a))), post)) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + } + } + + fn quot_extract_arg(rc: KernelRoles::RoleCtx, q: KernelTypes::KExpr, types: Lists::List) -> (Field, KernelTypes::KExpr) { + let q_w = whnf(rc, q, types); + match KernelTypes::collect_spine(q_w) { + (head, args) => { + match (*(head)) { + KernelTypes::KExprNode::Const(caddr, _) => { + match KernelRoles::role_is(rc, caddr, KernelRoleSpec::role_quot_mk()) { + 1 => { + match Lists::length(args) - 3 { + 0 => { (1, Lists::lookup(args, 2)) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + } + } + + fn whnf_const_head(rc: KernelRoles::RoleCtx, addr: Bytes::AddressRef, lvls: Lists::List, head: KernelTypes::KExpr, + spine: Lists::List, types: Lists::List) -> KernelTypes::KExpr { + let prim = try_prim_dispatch(rc, addr, lvls, spine, types); + match prim { + (1, reduced) => { whnf(rc, reduced, types) } , + + (2, stuck) => { stuck } , + _ => { + let ci = (*(Ingress::get_ci(addr))); + match ci { + KernelTypes::KConstantInfo::Defn(_, _, value, _, _) => { + let pd = try_reduce_projection_definition(value, spine); + match pd { + (1, reduced) => { whnf(rc, reduced, types) } , + _ => { + let body = KernelLevels::expr_inst_levels(value, lvls); + whnf_with_spine(rc, body, spine, types) } , + } } , + + KernelTypes::KConstantInfo::Thm(_, _, _) => { apply_spine(head, spine) } , + KernelTypes::KConstantInfo::Quot(_, _, _) => { + let quot = try_quot_iota(rc, addr, spine, types); + match quot { + (1, reduced) => { whnf(rc, reduced, types) } , + _ => { apply_spine(head, spine) } , + } } , + KernelTypes::KConstantInfo::Rec(nlvls, rec_ty, nparams, nindices, nmotives, nminors, + rules, k_flag, _unsafe, _block, _ridx) => { + + let k_skip = ((nparams + nmotives) + nminors) + nindices; + let k_pre = match k_flag { + 1 => { + + match se_parent_addr(rec_ty, k_skip) { + (_, rec_parent) => { + try_k_synth_iota(rc, lvls, spine, nparams, nmotives, + nminors, nindices, rules, + rec_parent, types) } , + } } , + _ => { (0, head) } , + }; + match k_pre { + (1, k_reduct) => { k_reduct } , + _ => { + let iota = try_iota(rc, lvls, spine, nparams, nmotives, nminors, + nindices, rules, types, head, + KernelCheck::rec_to_parent_addr(rec_ty, nparams, nmotives, + nminors, nindices)); + match iota { + (1, reduced) => { whnf(rc, reduced, types) } , + (2, stuck) => { + match k_flag { + + 1 => { stuck } , + _ => { + + match try_struct_eta_iota(rc, rec_ty, lvls, spine, nparams, + nmotives, nminors, nindices, rules, types) { + (1, r) => { whnf(rc, r, types) } , + _ => { stuck } , + } } , + } } , + _ => { apply_spine(head, spine) } , + } } , + } } , + _ => { apply_spine(head, spine) } , + } } , + } + } + + fn try_reduce_projection_definition(value: KernelTypes::KExpr, + spine: Lists::List) -> (Field, KernelTypes::KExpr) { + match projection_definition_info(value, 0) { + (1, arity, struct_addr, field, struct_arg_idx) => { + match UInt32::less_than_fields(Lists::length(spine), arity) { + 1 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + let target_arg = Lists::lookup(spine, struct_arg_idx); + let proj_expr = (&(KernelTypes::KExprNode::Proj(struct_addr, field, target_arg))); + let post = Lists::drop(spine, arity); + (1, apply_spine(proj_expr, post)) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } + } + + fn projection_definition_info(val: KernelTypes::KExpr, arity: Field) + -> (Field, Field, Bytes::AddressRef, Field, Field) { + match (*(val)) { + KernelTypes::KExprNode::Lam(_, body) => { + projection_definition_info(body, arity + 1) } , + KernelTypes::KExprNode::Proj(struct_addr, field, projected) => { + match (*(projected)) { + KernelTypes::KExprNode::BVar(i) => { + match UInt32::less_than_fields(i, arity) { + 1 => { (1, arity, struct_addr, field, (arity - 1) - i) } , + _ => { (0, 0, (&([UInt8::BYTE_0; 32])), 0, 0) } , + } } , + _ => { (0, 0, (&([UInt8::BYTE_0; 32])), 0, 0) } , + } } , + _ => { (0, 0, (&([UInt8::BYTE_0; 32])), 0, 0) } , + } + } + + fn nat_lit_to_ctor_or_self(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr) -> KernelTypes::KExpr { + match (*(e)) { + KernelTypes::KExprNode::Lit(lit) => { + match lit { + KernelTypes::KLiteral::Nat(klimbs) => { + match KernelKlimbs::klimbs_is_zero(klimbs) { + 1 => { (&(KernelTypes::KExprNode::Const(KernelRoles::role_addr(rc, KernelRoleSpec::role_nat_zero()), + (&(Lists::Node::Nil))))) } , + _ => { + let pred_limbs = KernelKlimbs::klimbs_normalize(KernelKlimbs::klimbs_dec(klimbs)); + let pred = (&(KernelTypes::KExprNode::Lit(KernelTypes::KLiteral::Nat(pred_limbs)))); + let succ_const = (&(KernelTypes::KExprNode::Const(KernelRoles::role_addr(rc, KernelRoleSpec::role_nat_succ()), + (&(Lists::Node::Nil))))); + (&(KernelTypes::KExprNode::App(succ_const, pred))) } , + } } , + _ => { e } , + } } , + _ => { e } , + } + } + + fn try_k_synth_iota(rc: KernelRoles::RoleCtx, lvls: Lists::List, spine: Lists::List, + nparams: Field, nmotives: Field, nminors: Field, nindices: Field, + rules: Lists::List, + rec_parent: Bytes::AddressRef, types: Lists::List) + -> (Field, KernelTypes::KExpr) { + match (*(rules)) { + Lists::Node::Cons(r, _) => { + match r { + KernelTypes::KRecRule::Mk(cidx, _rfields, rrhs) => { + let major_idx = nparams + nmotives + nminors + nindices; + + match UInt32::less_than_fields(major_idx, Lists::length(spine)) { + 0 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + let raw_major = Lists::lookup(spine, major_idx); + match k_synth_gate(rc, raw_major, cidx, nparams, rec_parent, types) { + 0 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + let rhs_lvled = KernelLevels::expr_inst_levels(rrhs, lvls); + let pmm_end = nparams + nmotives + nminors; + let pmm = Lists::take(spine, pmm_end); + let post_major = Lists::drop(spine, major_idx + 1); + let r1 = apply_spine(rhs_lvled, pmm); + let r3 = apply_spine(r1, post_major); + (1, whnf(rc, r3, types)) } , + } } , + } } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } + } + + fn k_synth_gate(rc: KernelRoles::RoleCtx, raw_major: KernelTypes::KExpr, cidx: Field, nparams: Field, + rec_parent: Bytes::AddressRef, types: Lists::List) -> Field { + let major_ty = KernelInfer::k_infer(rc, raw_major, types); + let major_ty_w = whnf(rc, major_ty, types); + match KernelTypes::collect_spine(major_ty_w) { + (ty_head, ty_args) => { + match (*(ty_head)) { + KernelTypes::KExprNode::Const(ind_addr, ctor_us) => { + + match Bytes::address_eq(ind_addr, rec_parent) { + 0 => { 0 } , + _ => { + let ind_ci = (*(Ingress::get_ci(ind_addr))); + match ind_ci { + KernelTypes::KConstantInfo::Induct(_, _, _, _, _, _, ind_block, ind_idx) => { + let cprj = KernelCheck::projection_addr_ctor(ind_idx, cidx, ind_block); + let ctor_head = (&(KernelTypes::KExprNode::Const(cprj, ctor_us))); + let params = Lists::take(ty_args, nparams); + let ctor_app = apply_spine(ctor_head, params); + let ctor_ty = KernelInfer::k_infer(rc, ctor_app, types); + KernelDefEq::k_is_def_eq(rc, major_ty_w, ctor_ty, types) } , + _ => { 0 } , + } } , + } } , + _ => { 0 } , + } } , + } + } + + fn replace_spine_major(spine: Lists::List, major_idx: Field, major_w: KernelTypes::KExpr) + -> Lists::List { + let pre = Lists::take(spine, major_idx); + let post = Lists::drop(spine, major_idx + 1); + let with_major = Lists::concat(pre, + (&(Lists::Node::Cons(major_w, (&(Lists::Node::Nil)))))); + Lists::concat(with_major, post) + } + + fn whnf_iota_major(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, types: Lists::List) -> KernelTypes::KExpr { + let w = whnf(rc, e, types); + match KernelTypes::collect_spine(w) { + (h, sp) => { + match (*(h)) { + KernelTypes::KExprNode::Const(addr, lvls) => { + match (*(Ingress::get_ci(addr))) { + KernelTypes::KConstantInfo::Thm(_, _, value) => { + let body = KernelLevels::expr_inst_levels(value, lvls); + whnf_iota_major(rc, whnf_with_spine(rc, body, sp, types), types) } , + _ => { w } , + } } , + _ => { w } , + } } , + } + } + + fn try_iota(rc: KernelRoles::RoleCtx, lvls: Lists::List, spine: Lists::List, + nparams: Field, nmotives: Field, nminors: Field, nindices: Field, + rules: Lists::List, types: Lists::List, + head: KernelTypes::KExpr, rec_parent: Bytes::AddressRef) -> (Field, KernelTypes::KExpr) { + let major_idx = nparams + nmotives + nminors + nindices; + let spine_len = Lists::length(spine); + match UInt32::less_than_fields(major_idx, spine_len) { + 0 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + + let lin = KernelNatPrim::try_nat_linear_rec(rc, spine, nparams, nmotives, nminors, major_idx); + match lin { + (1, r) => { (1, r) } , + _ => { + let raw_major = Lists::lookup(spine, major_idx); + + let major_clean1 = KernelNatPrim::cleanup_nat_offset_major(rc, raw_major); + let major_w = whnf_iota_major(rc, major_clean1, types); + let major_clean2 = KernelNatPrim::cleanup_nat_offset_major(rc, major_w); + let major = nat_lit_to_ctor_or_self(rc, major_clean2); + match collect_spine_of_ctor(major) { + (1, ctor_cidx, ctor_parent, ctor_args) => { + + assert_eq!(Bytes::address_eq(ctor_parent, rec_parent), 1, + "iota: major's constructor belongs to a different inductive"); + let rule = find_rule(rules, ctor_cidx); + match rule { + (0, _, _) => { + + let new_spine = replace_spine_major(spine, major_idx, major_w); + (2, apply_spine(head, new_spine)) } , + (1, rfields, rrhs) => { + let rhs_lvled = KernelLevels::expr_inst_levels(rrhs, lvls); + let pmm_end = nparams + nmotives + nminors; + let pmm = Lists::take(spine, pmm_end); + let ctor_fields_len = Lists::length(ctor_args); + let field_start = ctor_fields_len - rfields; + let field_args = Lists::drop(ctor_args, field_start); + let post_major = Lists::drop(spine, major_idx + 1); + let r1 = apply_spine(rhs_lvled, pmm); + let r2 = apply_spine(r1, field_args); + let r3 = apply_spine(r2, post_major); + (1, r3) } , + } } , + _ => { + + let new_spine = replace_spine_major(spine, major_idx, major_w); + (2, apply_spine(head, new_spine)) } , + } } , + } } , + } + } + + fn collect_spine_of_ctor(e: KernelTypes::KExpr) -> (Field, Field, Bytes::AddressRef, Lists::List) { + match KernelTypes::collect_spine(e) { + (head, args) => { + match (*(head)) { + KernelTypes::KExprNode::Const(addr, _) => { + let ci = (*(Ingress::get_ci(addr))); + match ci { + KernelTypes::KConstantInfo::Ctor(_, _, block_addr, ind_idx, cidx, _, _, _) => { + (1, cidx, KernelDefEq::compute_iprj_addr(block_addr, ind_idx), args) } , + _ => { (0, 0, (&([UInt8::BYTE_0; 32])), (&(Lists::Node::Nil))) } , + } } , + _ => { (0, 0, (&([UInt8::BYTE_0; 32])), (&(Lists::Node::Nil))) } , + } } , + } + } + + fn find_rule(rules: Lists::List, cidx: Field) -> (Field, Field, KernelTypes::KExpr) { + match (*(rules)) { + Lists::Node::Nil => { (0, 0, (&(KernelTypes::KExprNode::BVar(0)))) } , + Lists::Node::Cons(r, rest) => { + match r { + KernelTypes::KRecRule::Mk(rcidx, nfields, rhs) => { + match rcidx - cidx { + 0 => { (1, nfields, rhs) } , + _ => { find_rule(rest, cidx) } , + } } , + } } , + } + } + + fn try_struct_eta_iota(rc: KernelRoles::RoleCtx, rec_ty: KernelTypes::KExpr, lvls: Lists::List, + spine: Lists::List, nparams: Field, nmotives: Field, + nminors: Field, nindices: Field, + rules: Lists::List, + types: Lists::List) -> (Field, KernelTypes::KExpr) { + match (*(rules)) { + Lists::Node::Nil => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + Lists::Node::Cons(r, rest) => { + match (*(rest)) { + Lists::Node::Cons(_, _) => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + Lists::Node::Nil => { + match r { + KernelTypes::KRecRule::Mk(_, nf, rhs) => { + let skip = ((nparams + nmotives) + nminors) + nindices; + match se_parent_addr(rec_ty, skip) { + (0, _) => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + (_, parent) => { + let ci = (*(Ingress::get_ci(parent))); + match ci { + KernelTypes::KConstantInfo::Induct(_, _, _, ind_nidx, num_ctors, + _, _, _) => { + match num_ctors - 1 { + 0 => { + match ind_nidx { + 0 => { + match struct_is_rec(parent) { + 1 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + let major = Lists::lookup(spine, skip); + + match UInt32::less_than_fields(Lists::length(types), + KernelSubst::expr_lbr(major)) { + 1 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + let major_ty = KernelInfer::k_infer(rc, major, types); + match KernelDefEq::is_prop_type(rc, major_ty, types) { + 1 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + _ => { + let rhs_inst = KernelLevels::expr_inst_levels(rhs, lvls); + let pmm = Lists::take(spine, + (nparams + nmotives) + nminors); + let after_pmm = apply_spine(rhs_inst, pmm); + let with_projs = apply_n_projs( + after_pmm, parent, major, nf, 0); + let post = Lists::drop(spine, skip + 1); + (1, apply_spine(with_projs, post)) } , + } } , + } } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + } } , + } } , + } } , + } + } + + fn se_parent_addr(rec_ty: KernelTypes::KExpr, skip: Field) -> (Field, Bytes::AddressRef) { + match skip { + 0 => { + match (*(rec_ty)) { + KernelTypes::KExprNode::Forall(dom, _) => { + match KernelTypes::collect_spine(dom) { + (h, _) => { + match (*(h)) { + KernelTypes::KExprNode::Const(a, _) => { (1, a) } , + _ => { (0, (&([UInt8::BYTE_0; 32]))) } , + } } , + } } , + _ => { (0, (&([UInt8::BYTE_0; 32]))) } , + } } , + _ => { + match (*(rec_ty)) { + KernelTypes::KExprNode::Forall(_, body) => { se_parent_addr(body, skip - 1) } , + _ => { (0, (&([UInt8::BYTE_0; 32]))) } , + } } , + } + } + + fn apply_n_projs(head: KernelTypes::KExpr, parent: Bytes::AddressRef, major: KernelTypes::KExpr, + n_fields: Field, i: Field) -> KernelTypes::KExpr { + match n_fields - i { + 0 => { head } , + _ => { + let p = (&(KernelTypes::KExprNode::Proj(parent, i, major))); + apply_n_projs((&(KernelTypes::KExprNode::App(head, p))), parent, major, + n_fields, i + 1) } , + } + } + + fn struct_is_rec(parent: Bytes::AddressRef) -> Field { + let ci = (*(Ingress::get_ci(parent))); + match ci { + KernelTypes::KConstantInfo::Induct(_, _, n_params, _, num_ctors, _, block, idx) => { + let members = struct_block_member_addrs(parent, block); + struct_scan_ctors(block, idx, num_ctors, n_params, members, 0) } , + _ => { 1 } , + } + } + + fn struct_block_member_addrs(parent: Bytes::AddressRef, block: Bytes::AddressRef) -> Lists::List { + let c = Ingress::load_verified_constant(block); + match c { + Ixon::Constant::Mk(info, _, _, _) => { + match info { + Ixon::ConstantInfo::Muts(members) => { Ingress::build_recur_addrs(members, block) } , + _ => { (&(Lists::Node::Cons(parent, (&(Lists::Node::Nil))))) } , + } } , + } + } + + fn struct_scan_ctors(block: Bytes::AddressRef, idx: Field, num_ctors: Field, n_params: Field, + members: Lists::List, c: Field) -> Field { + match num_ctors - c { + 0 => { 0 } , + _ => { + let cci = (*(Ingress::get_ci_cprj(block, idx, c))); + match cci { + KernelTypes::KConstantInfo::Ctor(_, cty, _, _, _, _, _, _) => { + let after = se_peel_tol(cty, n_params); + match se_scan_fields(after, members) { + 1 => { 1 } , + _ => { struct_scan_ctors(block, idx, num_ctors, n_params, + members, c + 1) } , + } } , + _ => { 1 } , + } } , + } + } + + fn se_peel_tol(ty: KernelTypes::KExpr, n: Field) -> KernelTypes::KExpr { + match n { + 0 => { ty } , + _ => { + match (*(ty)) { + KernelTypes::KExprNode::Forall(_, body) => { se_peel_tol(body, n - 1) } , + _ => { ty } , + } } , + } + } + + fn se_scan_fields(ty: KernelTypes::KExpr, members: Lists::List) -> Field { + match (*(ty)) { + KernelTypes::KExprNode::Forall(dom, body) => { + match se_mentions(dom, members) { + 1 => { 1 } , + _ => { se_scan_fields(body, members) } , + } } , + _ => { 0 } , + } + } + + fn se_mentions(e: KernelTypes::KExpr, members: Lists::List) -> Field { + match (*(e)) { + KernelTypes::KExprNode::Const(a, _) => { se_addr_in(a, members) } , + KernelTypes::KExprNode::App(f, x) => { + match se_mentions(f, members) { + 1 => { 1 } , + _ => { se_mentions(x, members) } , + } } , + KernelTypes::KExprNode::Lam(t, b) => { + match se_mentions(t, members) { + 1 => { 1 } , + _ => { se_mentions(b, members) } , + } } , + KernelTypes::KExprNode::Forall(t, b) => { + match se_mentions(t, members) { + 1 => { 1 } , + _ => { se_mentions(b, members) } , + } } , + KernelTypes::KExprNode::Let(t, v, b) => { + match se_mentions(t, members) { + 1 => { 1 } , + _ => { + match se_mentions(v, members) { + 1 => { 1 } , + _ => { se_mentions(b, members) } , + } } , + } } , + KernelTypes::KExprNode::Proj(_, _, inner) => { se_mentions(inner, members) } , + _ => { 0 } , + } + } + + fn se_addr_in(a: Bytes::AddressRef, xs: Lists::List) -> Field { + match (*(xs)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(x, rest) => { + match Bytes::address_eq(a, x) { + 1 => { 1 } , + _ => { se_addr_in(a, rest) } , + } } , + } + } + + fn whnf(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, types: Lists::List) -> KernelTypes::KExpr { + match (*(e)) { + KernelTypes::KExprNode::Srt(_) => { e } , + KernelTypes::KExprNode::Lit(_) => { e } , + KernelTypes::KExprNode::Lam(_, _) => { e } , + KernelTypes::KExprNode::Forall(_, _) => { e } , + KernelTypes::KExprNode::BVar(_) => { e } , + _ => { whnf_core(rc, e, KernelSubst::ctx_trim(types, KernelSubst::expr_lbr(e))) } , + } + } + + inline fn whnf_core(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, types: Lists::List) -> KernelTypes::KExpr { + whnf_with_spine(rc, e, (&(Lists::Node::Nil)), types) + } + + fn whnf_struct_core(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, types: Lists::List) -> KernelTypes::KExpr { + match (*(e)) { + KernelTypes::KExprNode::Srt(_) => { e } , + KernelTypes::KExprNode::Lit(_) => { e } , + KernelTypes::KExprNode::Lam(_, _) => { e } , + KernelTypes::KExprNode::Forall(_, _) => { e } , + KernelTypes::KExprNode::BVar(_) => { e } , + _ => { whnf_struct_core_spine(rc, e, (&(Lists::Node::Nil)), + KernelSubst::ctx_trim(types, KernelSubst::expr_lbr(e))) } , + } + } + + fn whnf_struct_core_spine(rc: KernelRoles::RoleCtx, head: KernelTypes::KExpr, spine: Lists::List, + types: Lists::List) -> KernelTypes::KExpr { + match (*(head)) { + KernelTypes::KExprNode::App(_, _) => { + match KernelTypes::collect_spine(head) { + (h, s) => { whnf_struct_core_spine(rc, h, Lists::concat(s, spine), types) } , + } } , + KernelTypes::KExprNode::Lam(_, _) => { + match peel_beta(head, spine, (&(Lists::Node::Nil))) { + (deep, consumed, rest) => { + match Lists::length(consumed) { + 0 => { apply_spine(head, spine) } , + 1 => { whnf_struct_core_spine(rc, + KernelSubst::expr_inst1(deep, Lists::lookup(consumed, 0), 0), rest, types) } , + _ => { whnf_struct_core_spine(rc, + KernelSubst::expr_inst_many(deep, consumed, 0), rest, types) } , + } } , + } } , + KernelTypes::KExprNode::Let(_, val, body) => { + whnf_struct_core_spine(rc, KernelSubst::expr_inst1(body, val, 0), spine, types) } , + KernelTypes::KExprNode::Proj(struct_addr, fidx, inner) => { + whnf_struct_core_proj(rc, struct_addr, fidx, inner, spine, types, head) } , + KernelTypes::KExprNode::Const(addr, lvls) => { + whnf_struct_core_const(rc, addr, lvls, head, spine, types) } , + _ => { apply_spine(head, spine) } , + } + } + + fn whnf_struct_core_proj(rc: KernelRoles::RoleCtx, struct_addr: Bytes::AddressRef, fidx: Field, inner: KernelTypes::KExpr, + spine: Lists::List, types: Lists::List, + original: KernelTypes::KExpr) -> KernelTypes::KExpr { + let inner_w = whnf_struct_core(rc, inner, types); + match KernelTypes::collect_spine(inner_w) { + (ih, ia) => { + match (*(ih)) { + KernelTypes::KExprNode::Const(_, _) => { + match (*(whnf_get_ctor_or_none(ih))) { + KernelTypes::KConstantInfo::Ctor(_, _, _, _, _, nparams, _, _) => { + whnf_struct_core_spine(rc, Lists::lookup(ia, nparams + fidx), + spine, types) } , + _ => { apply_spine(original, spine) } , + } } , + _ => { apply_spine(original, spine) } , + } } , + } + } + + fn whnf_struct_core_const(rc: KernelRoles::RoleCtx, addr: Bytes::AddressRef, lvls: Lists::List, head: KernelTypes::KExpr, + spine: Lists::List, + types: Lists::List) -> KernelTypes::KExpr { + match (*(Ingress::get_ci(addr))) { + KernelTypes::KConstantInfo::Rec(_, rec_ty, nparams, nindices, nmotives, nminors, + rules, _k, _unsafe, _block, _ridx) => { + match try_iota(rc, lvls, spine, nparams, nmotives, nminors, nindices, + rules, types, head, + KernelCheck::rec_to_parent_addr(rec_ty, nparams, nmotives, nminors, + nindices)) { + (1, reduced) => { whnf_struct_core(rc, reduced, types) } , + _ => { apply_spine(head, spine) } , + } } , + _ => { apply_spine(head, spine) } , + } + } + + fn whnf_nd(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, types: Lists::List) -> KernelTypes::KExpr { + match (*(e)) { + KernelTypes::KExprNode::Srt(_) => { e } , + KernelTypes::KExprNode::Lit(_) => { e } , + KernelTypes::KExprNode::Lam(_, _) => { e } , + KernelTypes::KExprNode::Forall(_, _) => { e } , + KernelTypes::KExprNode::BVar(_) => { e } , + _ => { whnf_nd_core(rc, e, KernelSubst::ctx_trim(types, KernelSubst::expr_lbr(e))) } , + } + } + + inline fn whnf_nd_core(rc: KernelRoles::RoleCtx, e: KernelTypes::KExpr, types: Lists::List) -> KernelTypes::KExpr { + whnf_nd_with_spine(rc, e, (&(Lists::Node::Nil)), types) + } + + fn whnf_nd_with_spine(rc: KernelRoles::RoleCtx, head: KernelTypes::KExpr, spine: Lists::List, + types: Lists::List) -> KernelTypes::KExpr { + match (*(head)) { + KernelTypes::KExprNode::App(f, a) => { + match KernelTypes::collect_spine(head) { + (inner_head, inner_spine) => { + whnf_nd_with_spine(rc, inner_head, Lists::concat(inner_spine, spine), types) } , + } } , + KernelTypes::KExprNode::Lam(ty, body) => { + whnf_nd_apply_beta(rc, spine, head, types) } , + KernelTypes::KExprNode::Const(addr, lvls) => { + whnf_nd_const_head(rc, addr, lvls, head, spine, types) } , + KernelTypes::KExprNode::Let(_, val, body) => { + let next = KernelSubst::expr_inst1(body, val, 0); + whnf_nd_with_spine(rc, next, spine, types) } , + KernelTypes::KExprNode::Proj(struct_addr, fidx, inner) => { + whnf_nd_proj_head(rc, struct_addr, fidx, inner, spine, types) } , + _ => { apply_spine(head, spine) } , + } + } + + fn whnf_nd_apply_beta(rc: KernelRoles::RoleCtx, spine: Lists::List, lam: KernelTypes::KExpr, + types: Lists::List) -> KernelTypes::KExpr { + match peel_beta(lam, spine, (&(Lists::Node::Nil))) { + (deep, consumed, rest) => { + match Lists::length(consumed) { + 0 => { apply_spine(lam, spine) } , + 1 => { + let body2 = KernelSubst::expr_inst1(deep, Lists::lookup(consumed, 0), 0); + whnf_nd_with_spine(rc, body2, rest, types) } , + _ => { + let body2 = KernelSubst::expr_inst_many(deep, consumed, 0); + whnf_nd_with_spine(rc, body2, rest, types) } , + } } , + } + } + + fn whnf_nd_proj_head(rc: KernelRoles::RoleCtx, struct_addr: Bytes::AddressRef, fidx: Field, inner: KernelTypes::KExpr, + spine: Lists::List, types: Lists::List) -> KernelTypes::KExpr { + let inner_whnf = whnf_nd(rc, inner, types); + + let inner_exp = KernelNatPrim::str_lit_to_ctor_app_or_self(rc, inner_whnf, types); + match KernelTypes::collect_spine(inner_exp) { + (inner_head, inner_args) => { + match (*(inner_head)) { + KernelTypes::KExprNode::Const(_, _) => { + match (*(whnf_get_ctor_or_none(inner_head))) { + KernelTypes::KConstantInfo::Ctor(_, _, _, _, _, nparams, _, _) => { + let field = Lists::lookup(inner_args, nparams + fidx); + whnf_nd_with_spine(rc, field, spine, types) } , + _ => { + let stuck = (&(KernelTypes::KExprNode::Proj(struct_addr, fidx, inner_whnf))); + apply_spine(stuck, spine) } , + } } , + _ => { + let stuck = (&(KernelTypes::KExprNode::Proj(struct_addr, fidx, inner_whnf))); + apply_spine(stuck, spine) } , + } } , + } + } + + fn whnf_nd_const_head(rc: KernelRoles::RoleCtx, addr: Bytes::AddressRef, lvls: Lists::List, head: KernelTypes::KExpr, + spine: Lists::List, types: Lists::List) -> KernelTypes::KExpr { + + let (fam, _op) = prim_family(rc, addr); + let prim = match fam { + 0 => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + 1 => { + let whole = apply_spine(head, spine); + match KernelSubst::expr_lbr(whole) { + 0 => { try_prim_dispatch(rc, addr, lvls, spine, types) } , + _ => { (0, (&(KernelTypes::KExprNode::BVar(0)))) } , + } } , + _ => { try_prim_dispatch(rc, addr, lvls, spine, types) } , + }; + match prim { + (1, reduced) => { whnf_nd(rc, reduced, types) } , + + (2, stuck) => { stuck } , + _ => { + let ci = (*(Ingress::get_ci(addr))); + match ci { + KernelTypes::KConstantInfo::Defn(_, _, value, _, _) => { + let pd = try_reduce_projection_definition(value, spine); + match pd { + (1, reduced) => { whnf_nd(rc, reduced, types) } , + _ => { apply_spine(head, spine) } , + } } , + KernelTypes::KConstantInfo::Quot(_, _, _) => { + let quot = try_quot_iota(rc, addr, spine, types); + match quot { + (1, reduced) => { whnf_nd(rc, reduced, types) } , + _ => { apply_spine(head, spine) } , + } } , + KernelTypes::KConstantInfo::Rec(nlvls, rec_ty, nparams, nindices, nmotives, nminors, + rules, k_flag, _unsafe, _block, _ridx) => { + + let k_skip = ((nparams + nmotives) + nminors) + nindices; + let k_pre = match k_flag { + 1 => { + match se_parent_addr(rec_ty, k_skip) { + (_, rec_parent) => { + try_k_synth_iota(rc, lvls, spine, nparams, nmotives, + nminors, nindices, rules, + rec_parent, types) } , + } } , + _ => { (0, head) } , + }; + match k_pre { + (1, k_reduct) => { k_reduct } , + _ => { + let iota = try_iota(rc, lvls, spine, nparams, nmotives, nminors, + nindices, rules, types, head, + KernelCheck::rec_to_parent_addr(rec_ty, nparams, nmotives, + nminors, nindices)); + match iota { + (1, reduced) => { whnf_nd(rc, reduced, types) } , + (2, stuck) => { + match k_flag { + 1 => { stuck } , + _ => { + match try_struct_eta_iota(rc, rec_ty, lvls, spine, nparams, + nmotives, nminors, nindices, rules, types) { + (1, r) => { whnf_nd(rc, r, types) } , + _ => { stuck } , + } } , + } } , + _ => { apply_spine(head, spine) } , + } } , + } } , + _ => { apply_spine(head, spine) } , + } } , + } + } +} diff --git a/IxVM/IxVM/Modules/RBTreeMap.aiur b/IxVM/IxVM/Modules/RBTreeMap.aiur new file mode 100644 index 000000000..de0d18de3 --- /dev/null +++ b/IxVM/IxVM/Modules/RBTreeMap.aiur @@ -0,0 +1,131 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module RBTreeMap { + enum RBTreeMap { + + Node(Field, Bytes::AddressRef, V, &RBTreeMap::RBTreeMap, &RBTreeMap::RBTreeMap), + Nil + } + + fn rbtree_map_balance(color: Field, key: Bytes::AddressRef, value: V, left: RBTreeMap::RBTreeMap, right: RBTreeMap::RBTreeMap) -> RBTreeMap::RBTreeMap { + match color { + 1 => { rbtree_map_balance_fix(key, value, left, right) } , + _ => { RBTreeMap::RBTreeMap::Node(color, key, value, (&(left)), (&(right))) } , + } + } + + fn rbtree_map_balance_fix(key: Bytes::AddressRef, value: V, left: RBTreeMap::RBTreeMap, right: RBTreeMap::RBTreeMap) -> RBTreeMap::RBTreeMap { + match (left, right) { + + (RBTreeMap::RBTreeMap::Node(0, yk, yv, &RBTreeMap::RBTreeMap::Node(0, xk, xv, a, b), c), d) => { + RBTreeMap::RBTreeMap::Node(0, yk, yv, + (&(RBTreeMap::RBTreeMap::Node(1, xk, xv, a, b))), + (&(RBTreeMap::RBTreeMap::Node(1, key, value, c, (&(d)))))) } , + + (RBTreeMap::RBTreeMap::Node(0, xk, xv, a, &RBTreeMap::RBTreeMap::Node(0, yk, yv, b, c)), d) => { + RBTreeMap::RBTreeMap::Node(0, yk, yv, + (&(RBTreeMap::RBTreeMap::Node(1, xk, xv, a, b))), + (&(RBTreeMap::RBTreeMap::Node(1, key, value, c, (&(d)))))) } , + + (a, RBTreeMap::RBTreeMap::Node(0, zk, zv, &RBTreeMap::RBTreeMap::Node(0, yk, yv, b, c), d)) => { + RBTreeMap::RBTreeMap::Node(0, yk, yv, + (&(RBTreeMap::RBTreeMap::Node(1, key, value, (&(a)), b))), + (&(RBTreeMap::RBTreeMap::Node(1, zk, zv, c, d)))) } , + + (a, RBTreeMap::RBTreeMap::Node(0, yk, yv, b, &RBTreeMap::RBTreeMap::Node(0, zk, zv, c, d))) => { + RBTreeMap::RBTreeMap::Node(0, yk, yv, + (&(RBTreeMap::RBTreeMap::Node(1, key, value, (&(a)), b))), + (&(RBTreeMap::RBTreeMap::Node(1, zk, zv, c, d)))) } , + + _ => { RBTreeMap::RBTreeMap::Node(1, key, value, (&(left)), (&(right))) } , + } + } + + fn rbtree_map_ins(key: Bytes::AddressRef, value: V, tree: RBTreeMap::RBTreeMap) -> RBTreeMap::RBTreeMap { + match tree { + RBTreeMap::RBTreeMap::Nil => { + RBTreeMap::RBTreeMap::Node(0, key, value, (&(RBTreeMap::RBTreeMap::Nil)), (&(RBTreeMap::RBTreeMap::Nil))) } , + RBTreeMap::RBTreeMap::Node(color, k, v, &left, &right) => { + let lt = Fields::is_zero(canon_addr_cmp(key, k)); + match lt { + 1 => { rbtree_map_balance(color, k, v, rbtree_map_ins(key, value, left), right) } , + _ => { + + let eq = canon_addr_cmp(key, k) - 1; + match eq { + 0 => { RBTreeMap::RBTreeMap::Node(color, key, value, (&(left)), (&(right))) } , + _ => { rbtree_map_balance(color, k, v, left, rbtree_map_ins(key, value, right)) } , + } } , + } } , + } + } + + fn rbtree_map_insert(key: Bytes::AddressRef, value: V, tree: RBTreeMap::RBTreeMap) -> RBTreeMap::RBTreeMap { + let result = rbtree_map_ins(key, value, tree); + match result { + RBTreeMap::RBTreeMap::Node(_, k, v, left, right) => { RBTreeMap::RBTreeMap::Node(1, k, v, left, right) } , + } + } + + fn rbtree_map_lookup_or_default(key: Bytes::AddressRef, tree: RBTreeMap::RBTreeMap, default: V) -> V { + match tree { + RBTreeMap::RBTreeMap::Nil => { default } , + RBTreeMap::RBTreeMap::Node(_, k, v, &left, &right) => { + let lt = Fields::is_zero(canon_addr_cmp(key, k)); + match lt { + 1 => { rbtree_map_lookup_or_default(key, left, default) } , + _ => { + let eq = canon_addr_cmp(key, k) - 1; + match eq { + 0 => { v } , + _ => { rbtree_map_lookup_or_default(key, right, default) } , + } } , + } } , + } + } + + fn canon_ord_cmp_g(a: Field, b: Field) -> Field { + match a - b { + 0 => { 1 } , + _ => { + match UInt32::less_than_fields(a, b) { + 1 => { 0 } , + 0 => { 2 } , + } } , + } + } + + fn canon_ord_then(a: Field, b: Field) -> Field { + match a { + 1 => { b } , + _ => { a } , + } + } + + fn canon_addr_cmp(x: Bytes::AddressRef, y: Bytes::AddressRef) -> Field { + let xa = (*(x)); + let ya = (*(y)); + canon_ord_then(canon_addr_chunk(UInt8::to_field(xa[0]), UInt8::to_field(xa[1]), UInt8::to_field(xa[2]), UInt8::to_field(xa[3]), + UInt8::to_field(ya[0]), UInt8::to_field(ya[1]), UInt8::to_field(ya[2]), UInt8::to_field(ya[3])), + canon_ord_then(canon_addr_chunk(UInt8::to_field(xa[4]), UInt8::to_field(xa[5]), UInt8::to_field(xa[6]), UInt8::to_field(xa[7]), + UInt8::to_field(ya[4]), UInt8::to_field(ya[5]), UInt8::to_field(ya[6]), UInt8::to_field(ya[7])), + canon_ord_then(canon_addr_chunk(UInt8::to_field(xa[8]), UInt8::to_field(xa[9]), UInt8::to_field(xa[10]), UInt8::to_field(xa[11]), + UInt8::to_field(ya[8]), UInt8::to_field(ya[9]), UInt8::to_field(ya[10]), UInt8::to_field(ya[11])), + canon_ord_then(canon_addr_chunk(UInt8::to_field(xa[12]), UInt8::to_field(xa[13]), UInt8::to_field(xa[14]), UInt8::to_field(xa[15]), + UInt8::to_field(ya[12]), UInt8::to_field(ya[13]), UInt8::to_field(ya[14]), UInt8::to_field(ya[15])), + canon_ord_then(canon_addr_chunk(UInt8::to_field(xa[16]), UInt8::to_field(xa[17]), UInt8::to_field(xa[18]), UInt8::to_field(xa[19]), + UInt8::to_field(ya[16]), UInt8::to_field(ya[17]), UInt8::to_field(ya[18]), UInt8::to_field(ya[19])), + canon_ord_then(canon_addr_chunk(UInt8::to_field(xa[20]), UInt8::to_field(xa[21]), UInt8::to_field(xa[22]), UInt8::to_field(xa[23]), + UInt8::to_field(ya[20]), UInt8::to_field(ya[21]), UInt8::to_field(ya[22]), UInt8::to_field(ya[23])), + canon_ord_then(canon_addr_chunk(UInt8::to_field(xa[24]), UInt8::to_field(xa[25]), UInt8::to_field(xa[26]), UInt8::to_field(xa[27]), + UInt8::to_field(ya[24]), UInt8::to_field(ya[25]), UInt8::to_field(ya[26]), UInt8::to_field(ya[27])), + canon_addr_chunk(UInt8::to_field(xa[28]), UInt8::to_field(xa[29]), UInt8::to_field(xa[30]), UInt8::to_field(xa[31]), + UInt8::to_field(ya[28]), UInt8::to_field(ya[29]), UInt8::to_field(ya[30]), UInt8::to_field(ya[31]))))))))) + } + + fn canon_addr_chunk(x0: Field, x1: Field, x2: Field, x3: Field, + y0: Field, y1: Field, y2: Field, y3: Field) -> Field { + let xv = x0 * 16777216 + x1 * 65536 + x2 * 256 + x3; + let yv = y0 * 16777216 + y1 * 65536 + y2 * 256 + y3; + canon_ord_cmp_g(xv, yv) + } +} diff --git a/IxVM/IxVM/PortCases.aiur b/IxVM/IxVM/PortCases.aiur new file mode 100644 index 000000000..00b2bc935 --- /dev/null +++ b/IxVM/IxVM/PortCases.aiur @@ -0,0 +1,42 @@ +// Shared semantic probes; converted lexically for the Ix comparison exporter. +fn audit_div(a: KLimbs, b: KLimbs, expected_q: KLimbs, expected_r: KLimbs) -> () { + let (q, r) = klimbs_div_mod(a, b); + assert_eq!(klimbs_eq(q, expected_q), 1, "audit quotient"); + assert_eq!(klimbs_eq(r, expected_r), 1, "audit remainder"); + () +} +fn check_port_cases() -> () { + audit_div(store(ListNode::Nil), store(ListNode::Nil), store(ListNode::Nil), store(ListNode::Nil)); + audit_div(store(ListNode::Nil), store(ListNode::Cons([UInt8::BYTE_7, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil))), store(ListNode::Nil), store(ListNode::Nil)); + audit_div(store(ListNode::Cons([UInt8::BYTE_25, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil))), store(ListNode::Nil), store(ListNode::Nil), store(ListNode::Cons([UInt8::BYTE_25, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil)))); + audit_div(store(ListNode::Cons([UInt8::BYTE_25, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil))), store(ListNode::Cons([UInt8::BYTE_7, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil))), store(ListNode::Cons([UInt8::BYTE_3, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil))), store(ListNode::Cons([UInt8::BYTE_4, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil)))); + audit_div(store(ListNode::Cons([UInt8::BYTE_0, UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil))), store(ListNode::Cons([UInt8::BYTE_255, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil))), store(ListNode::Cons([UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil))), store(ListNode::Cons([UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil)))); + audit_div(store(ListNode::Cons([UInt8::BYTE_255, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil))), store(ListNode::Cons([UInt8::BYTE_0, UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil))), store(ListNode::Nil), store(ListNode::Cons([UInt8::BYTE_255, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil)))); + audit_div(store(ListNode::Cons([UInt8::BYTE_7, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Cons([UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil))))), store(ListNode::Cons([UInt8::BYTE_1, UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil))), store(ListNode::Cons([UInt8::BYTE_255, UInt8::BYTE_0, UInt8::BYTE_255, UInt8::BYTE_0, UInt8::BYTE_255, UInt8::BYTE_0, UInt8::BYTE_255, UInt8::BYTE_0], store(ListNode::Nil))), store(ListNode::Cons([UInt8::BYTE_8, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil)))); + audit_div(store(ListNode::Cons([UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255], store(ListNode::Cons([UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil))))), store(ListNode::Cons([UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil))), store(ListNode::Cons([UInt8::BYTE_254, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil))), store(ListNode::Cons([UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil)))); + audit_div(store(ListNode::Cons([UInt8::BYTE_123, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Cons([UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil))))), store(ListNode::Cons([UInt8::BYTE_5, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Cons([UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil))))), store(ListNode::Cons([UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], store(ListNode::Nil))), store(ListNode::Cons([UInt8::BYTE_128, UInt8::BYTE_0, UInt8::BYTE_251, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255], store(ListNode::Nil)))); + let empty = store(ListNode::Nil); + let rc = store(RoleCtxNode::Assumed(store(RoleTableNode::Mk( + store([UInt8::BYTE_0; 32]), + RoleMap::Nil, + RBTreeMap::Nil, + RoleMap::Nil)), RBTreeMap::Nil)); + let zero_level = store(KLevelNode::Zero); + let prop = store(KExprNode::Srt(zero_level)); + let v0 = store(KExprNode::BVar(0)); + let v1 = store(KExprNode::BVar(1)); + let lam = store(KExprNode::Lam(prop, v0)); + let app = store(KExprNode::App(lam, prop)); + assert_eq!(k_is_def_eq(rc, prop, prop, empty), 1, "reflexive sort"); + assert_eq!(k_is_def_eq(rc, lam, lam, empty), 1, "reflexive lambda"); + assert_eq!(k_is_def_eq(rc, app, prop, empty), 1, "beta reduction left"); + assert_eq!(k_is_def_eq(rc, prop, app, empty), 1, "beta reduction right"); + assert_eq!(kexpr_struct_eq(v0, v1), 0, "distinct variables"); + assert_eq!(kexpr_struct_eq(app, app), 1, "structural reflexivity"); + assert_eq!(level_struct_eq(zero_level, store(KLevelNode::Succ(zero_level))), 0, "distinct levels"); + assert_eq!(level_struct_eq(store(KLevelNode::Max(zero_level, zero_level)), store(KLevelNode::Max(zero_level, zero_level))), 1, "recursive level equality"); + assert_eq!(UInt32::less_than_fields(0, 4294967295), 1, "u32 upper bound"); + assert_eq!(UInt32::less_than_fields(4294967295, 0), 0, "u32 reverse upper bound"); + assert_eq!(UInt32::less_than_fields(4294967295, 4294967295), 0, "u32 equality"); + () +} diff --git a/IxVM/IxVM/Program.aiur b/IxVM/IxVM/Program.aiur new file mode 100644 index 000000000..64688659a --- /dev/null +++ b/IxVM/IxVM/Program.aiur @@ -0,0 +1,108 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module IxVM { + fn verify_serde(digest: [Field; 32]) -> () { + let digest = Blake3::address_from_fields(digest); + let (idx, len) = IxVMCompat::io_get_info(2, digest); + let bytes = IxByteStream::read_byte_stream(2, idx, len); + Blake3::verify_bytes_against(bytes, digest); + let (constant, rest) = IxonDeserialize::get_constant(bytes); + let Lists::Node::Nil = (*(rest)); + let output = IxonSerialize::put_constant(constant, (&(Lists::Node::Nil))); + assert_eq!(IxVMCompat::stream_equal(bytes, output), 1, "Ixon serialization round trip"); + () + } + + fn verify_constant(digest: [Field; 32]) -> () { + KernelClaim::run_check(KernelRoles::role_ctx_assumed(IxVMCompat::default_binding_addr()), (&(Blake3::address_from_fields(digest)))) + } + + fn verify_transitive(digest: [Field; 32]) -> () { + KernelClaim::run_check_transitive(KernelRoles::role_ctx_assumed(IxVMCompat::default_binding_addr()), (&(Blake3::address_from_fields(digest)))) + } + + fn check_primitives() -> () { + assert_eq!(UInt32::compact_field(UInt32::compact(UInt32::add(UInt32::MAX, UInt32::ONE))), 0, "u32 carry"); + assert_eq!(UInt32::compact_field(UInt32::compact(UInt32::add3(UInt32::MAX, UInt32::MAX, UInt32::MAX))), 4294967293, "three-word carry"); + assert_eq!(UInt32::less_than_fields(255, 256), 1, "u32 compare"); + assert_eq!(UInt32::less_than_fields(256, 255), 0, "u32 compare reverse"); + let a = (&(Lists::Node::Cons([UInt8::BYTE_25,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0], (&(Lists::Node::Nil))))); + let b = (&(Lists::Node::Cons([UInt8::BYTE_7,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0], (&(Lists::Node::Nil))))); + let (q,r) = IxVMCompat::ordinary_div_mod(a,b); + let Lists::Node::Cons(q0, qt) = (*(q)); + let Lists::Node::Nil = (*(qt)); + assert_eq!(UInt64::eq(q0, [UInt8::BYTE_3,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0]), 1, "division"); + let Lists::Node::Cons(r0, rt) = (*(r)); + let Lists::Node::Nil = (*(rt)); + assert_eq!(UInt64::eq(r0, [UInt8::BYTE_4,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0,UInt8::BYTE_0]), 1, "remainder"); + + let empty = (&(Lists::Node::Nil)); + let zero_addr = (&([UInt8::BYTE_0; 32])); + let rc = (&(KernelRoles::RoleCtxNode::Assumed((&(KernelRoles::RoleTableNode::Mk( + zero_addr, + KernelRoles::RoleMap::Node(1, KernelRoleSpec::role_nat_zero(), zero_addr, (&(KernelRoles::RoleMap::Nil)), (&(KernelRoles::RoleMap::Nil))), + RBTreeMap::RBTreeMap::Node(1, zero_addr, KernelRoleSpec::role_nat_zero() + 1, (&(RBTreeMap::RBTreeMap::Nil)), (&(RBTreeMap::RBTreeMap::Nil))), + KernelRoles::RoleMap::Nil))), RBTreeMap::RBTreeMap::Nil))); + let prop = (&(KernelTypes::KExprNode::Srt((&(KernelTypes::KLevelNode::Zero))))); + let var = (&(KernelTypes::KExprNode::BVar(0))); + let ctx = (&(Lists::Node::Cons(prop, empty))); + let lam = (&(KernelTypes::KExprNode::Lam(prop, var))); + assert_eq!(KernelDefEq::k_is_def_eq(rc, prop, prop, empty), 1, "sort reflexivity without pointer shortcut"); + assert_eq!(KernelDefEq::k_is_def_eq(rc, var, var, ctx), 1, "open reflexivity without pointer shortcut"); + assert_eq!(KernelDefEq::k_is_def_eq(rc, var, var, empty), 1, "context-free variable comparison"); + let head = (&(KernelTypes::KExprNode::BVar(1))); + let app = (&(KernelTypes::KExprNode::App(head, var))); + assert_eq!(KernelDefEq::k_is_def_eq(rc, app, app, empty), 1, "context-free application comparison"); + let other = (&(KernelTypes::KExprNode::App(var, var))); + assert_eq!(KernelDefEq::try_def_eq_app(rc, app, other, empty), 0, "different variable heads"); + assert_eq!(KernelDefEq::k_is_def_eq(rc, lam, lam, empty), 1, "lambda reflexivity without pointer shortcut"); + assert_eq!(KernelDefEq::k_is_def_eq_struct_bounded(rc, lam, lam, 3, empty), (1, 3), "structural credit"); + let str = (&(KernelTypes::KExprNode::Lit(KernelTypes::KLiteral::Str((&(Lists::Node::Nil)))))); + assert_eq!(KernelDefEq::k_is_def_eq_struct_go(rc, str, var, ctx), 0, "string expansion makes no progress"); + let zero = (&(KernelTypes::KExprNode::Lit(KernelTypes::KLiteral::Nat((&(Lists::Node::Nil)))))); + let ctor = (&(KernelTypes::KExprNode::Const(zero_addr, (&(Lists::Node::Nil))))); + assert_eq!(KernelDefEq::k_is_def_eq_struct_go(rc, zero, ctor, empty), 1, "natural literal expansion"); + () + } + + fn verify_claim(digest: [Field; 8]) -> () { KernelClaim::run_claim(digest) } + + fn verify_check_env(digest: [Field; 32]) -> () { + KernelClaim::run_check_env(KernelRoles::role_ctx_assumed(IxVMCompat::default_binding_addr()), (&(Blake3::address_from_fields(digest))), Options::Option::None) + } + + fn check_port_cases() -> () { + IxVMCompat::audit_div((&(Lists::Node::Nil)), (&(Lists::Node::Nil)), (&(Lists::Node::Nil)), (&(Lists::Node::Nil))); + IxVMCompat::audit_div((&(Lists::Node::Nil)), (&(Lists::Node::Cons([UInt8::BYTE_7, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))), (&(Lists::Node::Nil)), (&(Lists::Node::Nil))); + IxVMCompat::audit_div((&(Lists::Node::Cons([UInt8::BYTE_25, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))), (&(Lists::Node::Nil)), (&(Lists::Node::Nil)), (&(Lists::Node::Cons([UInt8::BYTE_25, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil)))))); + IxVMCompat::audit_div((&(Lists::Node::Cons([UInt8::BYTE_25, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))), (&(Lists::Node::Cons([UInt8::BYTE_7, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))), (&(Lists::Node::Cons([UInt8::BYTE_3, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))), (&(Lists::Node::Cons([UInt8::BYTE_4, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil)))))); + IxVMCompat::audit_div((&(Lists::Node::Cons([UInt8::BYTE_0, UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))), (&(Lists::Node::Cons([UInt8::BYTE_255, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))), (&(Lists::Node::Cons([UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))), (&(Lists::Node::Cons([UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil)))))); + IxVMCompat::audit_div((&(Lists::Node::Cons([UInt8::BYTE_255, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))), (&(Lists::Node::Cons([UInt8::BYTE_0, UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))), (&(Lists::Node::Nil)), (&(Lists::Node::Cons([UInt8::BYTE_255, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil)))))); + IxVMCompat::audit_div((&(Lists::Node::Cons([UInt8::BYTE_7, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Cons([UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil)))))))), (&(Lists::Node::Cons([UInt8::BYTE_1, UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))), (&(Lists::Node::Cons([UInt8::BYTE_255, UInt8::BYTE_0, UInt8::BYTE_255, UInt8::BYTE_0, UInt8::BYTE_255, UInt8::BYTE_0, UInt8::BYTE_255, UInt8::BYTE_0], (&(Lists::Node::Nil))))), (&(Lists::Node::Cons([UInt8::BYTE_8, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil)))))); + IxVMCompat::audit_div((&(Lists::Node::Cons([UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255], (&(Lists::Node::Cons([UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil)))))))), (&(Lists::Node::Cons([UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))), (&(Lists::Node::Cons([UInt8::BYTE_254, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))), (&(Lists::Node::Cons([UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil)))))); + IxVMCompat::audit_div((&(Lists::Node::Cons([UInt8::BYTE_123, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Cons([UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil)))))))), (&(Lists::Node::Cons([UInt8::BYTE_5, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Cons([UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil)))))))), (&(Lists::Node::Cons([UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], (&(Lists::Node::Nil))))), (&(Lists::Node::Cons([UInt8::BYTE_128, UInt8::BYTE_0, UInt8::BYTE_251, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255, UInt8::BYTE_255], (&(Lists::Node::Nil)))))); + let empty = (&(Lists::Node::Nil)); + let rc = (&(KernelRoles::RoleCtxNode::Assumed((&(KernelRoles::RoleTableNode::Mk( + (&([UInt8::BYTE_0; 32])), + KernelRoles::RoleMap::Nil, + RBTreeMap::RBTreeMap::Nil, + KernelRoles::RoleMap::Nil))), RBTreeMap::RBTreeMap::Nil))); + let zero_level = (&(KernelTypes::KLevelNode::Zero)); + let prop = (&(KernelTypes::KExprNode::Srt(zero_level))); + let v0 = (&(KernelTypes::KExprNode::BVar(0))); + let v1 = (&(KernelTypes::KExprNode::BVar(1))); + let lam = (&(KernelTypes::KExprNode::Lam(prop, v0))); + let app = (&(KernelTypes::KExprNode::App(lam, prop))); + assert_eq!(KernelDefEq::k_is_def_eq(rc, prop, prop, empty), 1, "reflexive sort"); + assert_eq!(KernelDefEq::k_is_def_eq(rc, lam, lam, empty), 1, "reflexive lambda"); + assert_eq!(KernelDefEq::k_is_def_eq(rc, app, prop, empty), 1, "beta reduction left"); + assert_eq!(KernelDefEq::k_is_def_eq(rc, prop, app, empty), 1, "beta reduction right"); + assert_eq!(KernelCheck::kexpr_struct_eq(v0, v1), 0, "distinct variables"); + assert_eq!(KernelCheck::kexpr_struct_eq(app, app), 1, "structural reflexivity"); + assert_eq!(KernelLevels::level_struct_eq(zero_level, (&(KernelTypes::KLevelNode::Succ(zero_level)))), 0, "distinct levels"); + assert_eq!(KernelLevels::level_struct_eq((&(KernelTypes::KLevelNode::Max(zero_level, zero_level))), (&(KernelTypes::KLevelNode::Max(zero_level, zero_level)))), 1, "recursive level equality"); + assert_eq!(UInt32::less_than_fields(0, 4294967295), 1, "u32 upper bound"); + assert_eq!(UInt32::less_than_fields(4294967295, 0), 0, "u32 reverse upper bound"); + assert_eq!(UInt32::less_than_fields(4294967295, 4294967295), 0, "u32 equality"); + () + } +} diff --git a/IxVM/IxVM/Program.lean b/IxVM/IxVM/Program.lean new file mode 100644 index 000000000..cf5492031 --- /dev/null +++ b/IxVM/IxVM/Program.lean @@ -0,0 +1,25 @@ +import Aiur.Modules.Frontend +import Aiur.Library.Blake3.Goldilocks +import Aiur.Library.List.Word +import Aiur.Library.Option + +/-! The stage-one IxVM application explicitly selects Goldilocks word and hash +implementations. The compiler, its proofs, and the runtime remain generic. -/ +namespace IxVM +open Aiur + +abbrev modulus := Library.U32.Goldilocks.modulus +abbrev F := Library.U32.Goldilocks.F + +/-- Parse and type-check the IxVM source, then attach its shared word/hash library. +Callers choose entrypoints with `Aiur.Modules.prepare` and may export bytecode, +certified circuits, or population plans from that prepared program. -/ +def parse (env : Lean.Environment) (text : String) : Except String (Modules.Program F) := do + let source ← Modules.Frontend.parse env text + Modules.checkTemplates (Library.Blake3.templates.append Library.List.Word.declarations + |>.append Library.Option.declarations |>.append source) + return Library.Blake3.Goldilocks.program.append (Library.List.Word.declarations.toField F) + |>.append (Library.Option.declarations.toField F) + |>.append (source.toField F) + +end IxVM diff --git a/IxVM/IxVM/Program.names.json b/IxVM/IxVM/Program.names.json new file mode 100644 index 000000000..fc8ce24d5 --- /dev/null +++ b/IxVM/IxVM/Program.names.json @@ -0,0 +1,834 @@ +{ + "IxVM::Addr": "Bytes::AddressRef", + "IxVM::Axiom": "Ixon::Axiom", + "IxVM::BinderContract": "Ixon::BinderContract", + "IxVM::BlobEntry": "Ixon::BlobEntry", + "IxVM::ByteStream": "Bytes::Stream", + "IxVM::Constant": "Ixon::Constant", + "IxVM::ConstantInfo": "Ixon::ConstantInfo", + "IxVM::Constructor": "Ixon::Constructor", + "IxVM::ConstructorProj": "Ixon::ConstructorProj", + "IxVM::DefKind": "Ixon::DefKind", + "IxVM::Definition": "Ixon::Definition", + "IxVM::DefinitionProj": "Ixon::DefinitionProj", + "IxVM::DefinitionSafety": "Ixon::DefinitionSafety", + "IxVM::Expr": "Ixon::Expr", + "IxVM::Inductive": "Ixon::Inductive", + "IxVM::InductiveProj": "Ixon::InductiveProj", + "IxVM::InferLetEnv": "KernelInfer::InferLetEnv", + "IxVM::InferLetEnvNode": "KernelInfer::InferLetEnvNode", + "IxVM::KConstantInfo": "KernelTypes::KConstantInfo", + "IxVM::KExpr": "KernelTypes::KExpr", + "IxVM::KExprNode": "KernelTypes::KExprNode", + "IxVM::KLevel": "KernelTypes::KLevel", + "IxVM::KLevelNode": "KernelTypes::KLevelNode", + "IxVM::KLimbs": "KernelTypes::KLimbs", + "IxVM::KLiteral": "KernelTypes::KLiteral", + "IxVM::KRecRule": "KernelTypes::KRecRule", + "IxVM::Layer": "Blake3::Layer", + "IxVM::LetContract": "Ixon::LetContract", + "IxVM::LetKind": "Ixon::LetKind", + "IxVM::List": "Lists::List", + "IxVM::Locality": "Ixon::Locality", + "IxVM::MutConst": "Ixon::MutConst", + "IxVM::NLEntry": "KernelLevels::NLEntry", + "IxVM::NLVar": "KernelLevels::NLVar", + "IxVM::Option": "Options::Option", + "IxVM::Owned": "Ixon::Owned", + "IxVM::QuotKind": "Ixon::QuotKind", + "IxVM::Quotient": "Ixon::Quotient", + "IxVM::RBTreeMap": "RBTreeMap::RBTreeMap", + "IxVM::Recursor": "Ixon::Recursor", + "IxVM::RecursorProj": "Ixon::RecursorProj", + "IxVM::RecursorRule": "Ixon::RecursorRule", + "IxVM::RevealConstantInfo": "KernelClaim::RevealConstantInfo", + "IxVM::RevealConstructorInfo": "KernelClaim::RevealConstructorInfo", + "IxVM::RevealMutConstInfo": "KernelClaim::RevealMutConstInfo", + "IxVM::RevealRecursorRule": "KernelClaim::RevealRecursorRule", + "IxVM::RoleCtx": "KernelRoles::RoleCtx", + "IxVM::RoleCtxNode": "KernelRoles::RoleCtxNode", + "IxVM::RoleEvidence": "KernelRoles::RoleEvidence", + "IxVM::RoleMap": "KernelRoles::RoleMap", + "IxVM::RoleTable": "KernelRoles::RoleTable", + "IxVM::RoleTableNode": "KernelRoles::RoleTableNode", + "IxVM::U32": "UInt32::U32", + "IxVM::U64": "UInt64::U64", + "IxVM::U8": "UInt8::U8", + "IxVM::Univ": "Ixon::Univ", + "IxVM::Uses": "Ixon::Uses", + "IxVM::ValueContract": "Ixon::ValueContract", + "IxVM::addr_list_contains": "KernelCheck::addr_list_contains", + "IxVM::addr_set_build": "KernelClaim::addr_set_build", + "IxVM::addr_set_member": "KernelClaim::addr_set_member", + "IxVM::address_eq": "Bytes::address_eq", + "IxVM::address_eq_tail": "Bytes::address_eq_tail", + "IxVM::admit_all_groups": "KernelRoles::admit_all_groups", + "IxVM::all_bvars_in_args": "KernelCheck::all_bvars_in_args", + "IxVM::all_telescope_count": "IxonSerialize::all_telescope_count", + "IxVM::app_telescope_count": "IxonSerialize::app_telescope_count", + "IxVM::apply_ihs_full": "KernelCheck::apply_ihs_full", + "IxVM::apply_indices_in_conclusion": "KernelCheck::apply_indices_in_conclusion", + "IxVM::apply_n_projs": "KernelWhnf::apply_n_projs", + "IxVM::apply_spec_params_lifted": "KernelCheck::apply_spec_params_lifted", + "IxVM::apply_spine": "KernelWhnf::apply_spine", + "IxVM::apply_spine_expr": "KernelCheck::apply_spine_expr", + "IxVM::args_contain_bvar": "KernelCheck::args_contain_bvar", + "IxVM::assert_all_roles_bound": "KernelRoles::assert_all_roles_bound", + "IxVM::assert_first_args_are_param_bvars": "KernelCheck::assert_first_args_are_param_bvars", + "IxVM::assert_lvls_are_params": "KernelCheck::assert_lvls_are_params", + "IxVM::assert_occ_param_bvars": "KernelCheck::assert_occ_param_bvars", + "IxVM::assert_quot_kind": "KernelRoles::assert_quot_kind", + "IxVM::assert_ref_allowed": "KernelRoles::assert_ref_allowed", + "IxVM::assert_return_head_is_parent": "KernelCheck::assert_return_head_is_parent", + "IxVM::assert_safe_role": "KernelRoles::assert_safe_role", + "IxVM::assert_safety": "KernelCheck::assert_safety", + "IxVM::assert_type_meets": "KernelRoles::assert_type_meets", + "IxVM::assert_wire_bool": "IxonDeserialize::assert_wire_bool", + "IxVM::audit_div": "IxVMCompat::audit_div", + "IxVM::aux_already_in": "KernelCheck::aux_already_in", + "IxVM::aux_from_recrs_walk_ex": "KernelCheck::aux_from_recrs_walk_ex", + "IxVM::axiom_role_standing": "KernelRoles::axiom_role_standing", + "IxVM::axiom_standing": "KernelRoles::axiom_standing", + "IxVM::b3_pack": "Blake3::pack_digest", + "IxVM::b3_pack_w": "Blake3::pack_word", + "IxVM::binder_contract_code": "IxonSerialize::binder_contract_code", + "IxVM::binder_contract_from_bits": "IxonDeserialize::binder_contract_from_bits", + "IxVM::bitvec_of_nat_args_direct": "KernelNatPrim::bitvec_of_nat_args_direct", + "IxVM::bitvec_prep_spine": "KernelWhnf::bitvec_prep_spine", + "IxVM::bitvec_prep_spine_ult": "KernelNatPrim::bitvec_prep_spine_ult", + "IxVM::build_all_minors": "KernelCheck::build_all_minors", + "IxVM::build_all_minors_walk": "KernelCheck::build_all_minors_walk", + "IxVM::build_all_motives": "KernelCheck::build_all_motives", + "IxVM::build_all_motives_walk": "KernelCheck::build_all_motives_walk", + "IxVM::build_apply_bvars_decreasing": "KernelCheck::build_apply_bvars_decreasing", + "IxVM::build_apply_field_bvars": "KernelCheck::build_apply_field_bvars", + "IxVM::build_apply_xs": "KernelCheck::build_apply_xs", + "IxVM::build_char_list": "KernelNatPrim::build_char_list", + "IxVM::build_ctor_app_params": "KernelCheck::build_ctor_app_params", + "IxVM::build_flat_block": "KernelCheck::build_flat_block", + "IxVM::build_flat_originals": "KernelCheck::build_flat_originals", + "IxVM::build_flat_own_params": "KernelCheck::build_flat_own_params", + "IxVM::build_ih_doms": "KernelCheck::build_ih_doms", + "IxVM::build_major_args_for_member": "KernelCheck::build_major_args_for_member", + "IxVM::build_major_args_for_self": "KernelCheck::build_major_args_for_self", + "IxVM::build_major_indices": "KernelCheck::build_major_indices", + "IxVM::build_major_params": "KernelCheck::build_major_params", + "IxVM::build_minor_apps": "KernelCheck::build_minor_apps", + "IxVM::build_minor_at_depth": "KernelCheck::build_minor_at_depth", + "IxVM::build_minor_doms": "KernelCheck::build_minor_doms", + "IxVM::build_motive_apps": "KernelCheck::build_motive_apps", + "IxVM::build_motive_type_flat": "KernelCheck::build_motive_type_flat", + "IxVM::build_param_lvls_range": "KernelCheck::build_param_lvls_range", + "IxVM::build_peer_recs": "KernelCheck::build_peer_recs", + "IxVM::build_rec_lvls_list": "KernelCheck::build_rec_lvls_list", + "IxVM::build_rec_type": "KernelCheck::build_rec_type", + "IxVM::build_rec_type_from": "KernelCheck::build_rec_type_from", + "IxVM::build_recur_addrs": "Ingress::build_recur_addrs", + "IxVM::build_recur_addrs_walk": "Ingress::build_recur_addrs_walk", + "IxVM::build_rule_rhs": "KernelCheck::build_rule_rhs", + "IxVM::build_succ_chain": "IxonDeserialize::build_succ_chain", + "IxVM::build_succ_offset": "KernelNatPrim::build_succ_offset", + "IxVM::bv_to_nat_via": "KernelNatPrim::bv_to_nat_via", + "IxVM::bytes_to_limbs": "Convert::bytes_to_limbs", + "IxVM::bytes_to_u64_limb": "Convert::bytes_to_u64_limb", + "IxVM::bytestream_eq": "KernelLevels::bytestream_eq", + "IxVM::caddr_is_peer": "KernelCheck::caddr_is_peer", + "IxVM::canon_addr_chunk": "RBTreeMap::canon_addr_chunk", + "IxVM::canon_addr_cmp": "RBTreeMap::canon_addr_cmp", + "IxVM::canon_ord_cmp_g": "RBTreeMap::canon_ord_cmp_g", + "IxVM::canon_ord_then": "RBTreeMap::canon_ord_then", + "IxVM::canonical_rules_at_pos": "KernelCheck::canonical_rules_at_pos", + "IxVM::char_lit_codepoint": "KernelNatPrim::char_lit_codepoint", + "IxVM::char_lit_codepoint_syn": "KernelNatPrim::char_lit_codepoint_syn", + "IxVM::check_block_member_kinds": "KernelCheck::check_block_member_kinds", + "IxVM::check_block_peer_param_agreement": "KernelCheck::check_block_peer_param_agreement", + "IxVM::check_const": "KernelCheck::check_const", + "IxVM::check_ctor_entries": "KernelClaim::check_ctor_entries", + "IxVM::check_ctor_entry": "KernelClaim::check_ctor_entry", + "IxVM::check_ctor_return_type": "KernelCheck::check_ctor_return_type", + "IxVM::check_field_universes": "KernelCheck::check_field_universes", + "IxVM::check_field_universes_inner": "KernelCheck::check_field_universes_inner", + "IxVM::check_field_universes_skip_params": "KernelCheck::check_field_universes_skip_params", + "IxVM::check_inductive_shape": "KernelCheck::check_inductive_shape", + "IxVM::check_inductive_shape_ctors": "KernelCheck::check_inductive_shape_ctors", + "IxVM::check_large_prop_ctor": "KernelCheck::check_large_prop_ctor", + "IxVM::check_large_walk_fields": "KernelCheck::check_large_walk_fields", + "IxVM::check_mut_const": "KernelClaim::check_mut_const", + "IxVM::check_muts_all": "KernelClaim::check_muts_all", + "IxVM::check_muts_components": "KernelClaim::check_muts_components", + "IxVM::check_muts_member_at": "KernelClaim::check_muts_member_at", + "IxVM::check_nested_ctors_positivity": "KernelCheck::check_nested_ctors_positivity", + "IxVM::check_no_dep_data_field_if_prop": "KernelInfer::check_no_dep_data_field_if_prop", + "IxVM::check_opt_addr": "KernelClaim::check_opt_addr", + "IxVM::check_opt_bool": "KernelClaim::check_opt_bool", + "IxVM::check_opt_ctor_entries": "KernelClaim::check_opt_ctor_entries", + "IxVM::check_opt_def_kind": "KernelClaim::check_opt_def_kind", + "IxVM::check_opt_def_safety": "KernelClaim::check_opt_def_safety", + "IxVM::check_opt_expr_addr": "KernelClaim::check_opt_expr_addr", + "IxVM::check_opt_quot_kind": "KernelClaim::check_opt_quot_kind", + "IxVM::check_opt_recr_rules": "KernelClaim::check_opt_recr_rules", + "IxVM::check_opt_u64": "KernelClaim::check_opt_u64", + "IxVM::check_owned": "IxVMCompat::check_owned", + "IxVM::check_param_agreement": "KernelCheck::check_param_agreement", + "IxVM::check_param_agreement_go": "KernelCheck::check_param_agreement_go", + "IxVM::check_parent_inductive_shape": "KernelCheck::check_parent_inductive_shape", + "IxVM::check_port_cases": "IxVM::check_port_cases", + "IxVM::check_positivity": "KernelCheck::check_positivity", + "IxVM::check_positivity_aug": "KernelCheck::check_positivity_aug", + "IxVM::check_positivity_fields": "KernelCheck::check_positivity_fields", + "IxVM::check_primitives": "IxVM::check_primitives", + "IxVM::check_prop_field_if_prop": "KernelInfer::check_prop_field_if_prop", + "IxVM::check_quot": "KernelCheck::check_quot", + "IxVM::check_rec_major_spine": "KernelCheck::check_rec_major_spine", + "IxVM::check_rec_rules_wellscoped": "KernelCheck::check_rec_rules_wellscoped", + "IxVM::check_recr_rules": "KernelClaim::check_recr_rules", + "IxVM::check_recursor_canonical_full": "KernelCheck::check_recursor_canonical_full", + "IxVM::check_recursor_member": "KernelCheck::check_recursor_member", + "IxVM::check_valid_ind_app": "KernelCheck::check_valid_ind_app", + "IxVM::checked_depth_succ": "WordLists::checked_depth_succ", + "IxVM::cleanup_nat_offset_major": "KernelNatPrim::cleanup_nat_offset_major", + "IxVM::collect_index_doms": "KernelCheck::collect_index_doms", + "IxVM::collect_n_doms_whnf": "KernelCheck::collect_n_doms_whnf", + "IxVM::collect_spine": "KernelTypes::collect_spine", + "IxVM::collect_spine_of_ctor": "KernelWhnf::collect_spine_of_ctor", + "IxVM::compare_rules": "KernelCheck::compare_rules", + "IxVM::compare_struct_fields": "KernelDefEq::compare_struct_fields", + "IxVM::compute_iprj_addr": "KernelDefEq::compute_iprj_addr", + "IxVM::compute_k_target": "KernelCheck::compute_k_target", + "IxVM::const_idxs_ctors": "KernelClaim::const_idxs_ctors", + "IxVM::const_idxs_expr": "KernelClaim::const_idxs_expr", + "IxVM::const_idxs_exprs": "KernelClaim::const_idxs_exprs", + "IxVM::const_idxs_muts": "KernelClaim::const_idxs_muts", + "IxVM::const_idxs_of": "KernelClaim::const_idxs_of", + "IxVM::const_idxs_rules": "KernelClaim::const_idxs_rules", + "IxVM::const_num_lvls": "KernelInfer::const_num_lvls", + "IxVM::const_type_of": "KernelInfer::const_type_of", + "IxVM::convert_axiom": "Convert::convert_axiom", + "IxVM::convert_constructor": "Convert::convert_constructor", + "IxVM::convert_definition": "Convert::convert_definition", + "IxVM::convert_expr": "Convert::convert_expr", + "IxVM::convert_inductive": "Convert::convert_inductive", + "IxVM::convert_quotient": "Convert::convert_quotient", + "IxVM::convert_rec_rules": "Convert::convert_rec_rules", + "IxVM::convert_recursor": "Convert::convert_recursor", + "IxVM::convert_univ": "Convert::convert_univ", + "IxVM::convert_univ_idxs": "Convert::convert_univ_idxs", + "IxVM::count_ctors": "Convert::count_ctors", + "IxVM::count_foralls_body": "KernelCheck::count_foralls_body", + "IxVM::ctor_at": "Convert::ctor_at", + "IxVM::ctor_parent_ind_ci": "KernelCheck::ctor_parent_ind_ci", + "IxVM::ctor_subst_param_for": "KernelCheck::ctor_subst_param_for", + "IxVM::ctors_before_pos": "KernelCheck::ctors_before_pos", + "IxVM::ctx_close_cut": "KernelSubst::ctx_close_cut", + "IxVM::ctx_next_cut": "KernelSubst::ctx_next_cut", + "IxVM::ctx_reachable": "KernelSubst::ctx_reachable", + "IxVM::ctx_seek_cut": "KernelSubst::ctx_seek_cut", + "IxVM::ctx_trim": "KernelSubst::ctx_trim", + "IxVM::de_args": "KernelDefEq::de_args", + "IxVM::dec_int": "KernelInfer::dec_int", + "IxVM::dec_nat": "KernelInfer::dec_nat", + "IxVM::dec_result": "KernelInfer::dec_result", + "IxVM::dec_rewrite_int_lt_to_le": "KernelInfer::dec_rewrite_int_lt_to_le", + "IxVM::dec_rewrite_lt_to_le": "KernelInfer::dec_rewrite_lt_to_le", + "IxVM::def_kind_tag": "KernelClaim::def_kind_tag", + "IxVM::def_safety_tag": "KernelClaim::def_safety_tag", + "IxVM::default_binding_addr": "IxVMCompat::default_binding_addr", + "IxVM::definition_hint": "Ingress::definition_hint", + "IxVM::defn_is_unsafe_ci": "Ingress::defn_is_unsafe_ci", + "IxVM::defn_member_recur_addrs": "Ingress::defn_member_recur_addrs", + "IxVM::delta_rank": "KernelDefEq::delta_rank", + "IxVM::delta_unfold": "KernelDefEq::delta_unfold", + "IxVM::detect_aux_from_recrs_ex": "KernelCheck::detect_aux_from_recrs_ex", + "IxVM::divide_grow": "IxVMCompat::divide_grow", + "IxVM::divmod_256": "KernelKlimbs::divmod_256", + "IxVM::divmod_64u": "KernelNatPrim::divmod_64u", + "IxVM::ensure_sort_only": "KernelInferOnly::ensure_sort_only", + "IxVM::env_walk": "KernelClaim::env_walk", + "IxVM::env_walk_all": "KernelClaim::env_walk_all", + "IxVM::env_walk_leaves": "KernelClaim::env_walk_leaves", + "IxVM::env_walk_refs": "KernelClaim::env_walk_refs", + "IxVM::env_walk_refs_all": "KernelClaim::env_walk_refs_all", + "IxVM::eqns_conditional": "KernelRoleSpec::eqns_conditional", + "IxVM::eqns_equation_count": "KernelRoleSpec::eqns_equation_count", + "IxVM::eqns_lhs": "KernelRoleSpec::eqns_lhs", + "IxVM::eqns_rhs": "KernelRoleSpec::eqns_rhs", + "IxVM::eqns_statement": "KernelRoleSpec::eqns_statement", + "IxVM::eval_body": "KernelEval::eval_body", + "IxVM::eval_nf": "KernelEval::eval_nf", + "IxVM::eval_nf_spine": "KernelEval::eval_nf_spine", + "IxVM::eval_output": "KernelEval::eval_output", + "IxVM::expr_addr": "KernelClaim::expr_addr", + "IxVM::expr_glb": "KernelSubst::expr_glb", + "IxVM::expr_glb_binder": "KernelSubst::expr_glb_binder", + "IxVM::expr_glb_let": "KernelSubst::expr_glb_let", + "IxVM::expr_glb_walk": "KernelSubst::expr_glb_walk", + "IxVM::expr_has_bvar_at": "KernelSubst::expr_has_bvar_at", + "IxVM::expr_has_bvar_at_binder": "KernelSubst::expr_has_bvar_at_binder", + "IxVM::expr_has_bvar_at_let": "KernelSubst::expr_has_bvar_at_let", + "IxVM::expr_inst1": "KernelSubst::expr_inst1", + "IxVM::expr_inst1_bvar": "KernelSubst::expr_inst1_bvar", + "IxVM::expr_inst1_let": "KernelSubst::expr_inst1_let", + "IxVM::expr_inst1_walk": "KernelSubst::expr_inst1_walk", + "IxVM::expr_inst_levels": "KernelLevels::expr_inst_levels", + "IxVM::expr_inst_levels_walk": "KernelLevels::expr_inst_levels_walk", + "IxVM::expr_inst_many": "KernelSubst::expr_inst_many", + "IxVM::expr_inst_many_bvar": "KernelSubst::expr_inst_many_bvar", + "IxVM::expr_inst_many_let": "KernelSubst::expr_inst_many_let", + "IxVM::expr_inst_many_walk": "KernelSubst::expr_inst_many_walk", + "IxVM::expr_lbr": "KernelSubst::expr_lbr", + "IxVM::expr_lbr_let": "KernelSubst::expr_lbr_let", + "IxVM::expr_lift": "KernelSubst::expr_lift", + "IxVM::expr_lift_bvar": "KernelSubst::expr_lift_bvar", + "IxVM::expr_lift_let": "KernelSubst::expr_lift_let", + "IxVM::expr_lift_walk": "KernelSubst::expr_lift_walk", + "IxVM::expr_lower": "KernelSubst::expr_lower", + "IxVM::expr_lower_let": "KernelSubst::expr_lower_let", + "IxVM::expr_lower_walk": "KernelSubst::expr_lower_walk", + "IxVM::expr_mentions_block": "KernelCheck::expr_mentions_block", + "IxVM::extract_aux_occ_us": "KernelCheck::extract_aux_occ_us", + "IxVM::extract_aux_spec_params": "KernelCheck::extract_aux_spec_params", + "IxVM::extract_aux_spec_params_from_rec": "KernelCheck::extract_aux_spec_params_from_rec", + "IxVM::find_peer_rec_spec_walk": "KernelCheck::find_peer_rec_spec_walk", + "IxVM::find_peer_recursor_with_spec": "KernelCheck::find_peer_recursor_with_spec", + "IxVM::find_rule": "KernelWhnf::find_rule", + "IxVM::first_equation_group": "KernelRoleSpec::first_equation_group", + "IxVM::first_recr_parent_block": "KernelCheck::first_recr_parent_block", + "IxVM::first_well_founded_group": "KernelRoleSpec::first_well_founded_group", + "IxVM::flat_find_matching": "KernelCheck::flat_find_matching", + "IxVM::flat_find_pos": "KernelCheck::flat_find_pos", + "IxVM::flat_find_pos_kind": "KernelCheck::flat_find_pos_kind", + "IxVM::flat_member_at": "KernelCheck::flat_member_at", + "IxVM::flat_originals_walk": "KernelCheck::flat_originals_walk", + "IxVM::g_list_has": "KernelClaim::g_list_has", + "IxVM::get_address": "IxonDeserialize::get_address", + "IxVM::get_address_list": "IxonDeserialize::get_address_list", + "IxVM::get_all_mode": "IxonDeserialize::get_all_mode", + "IxVM::get_all_telescope": "IxonDeserialize::get_all_telescope", + "IxVM::get_app_telescope": "IxonDeserialize::get_app_telescope", + "IxVM::get_axiom": "IxonDeserialize::get_axiom", + "IxVM::get_ci": "Ingress::get_ci", + "IxVM::get_ci_cprj": "Ingress::get_ci_cprj", + "IxVM::get_ci_dprj": "Ingress::get_ci_dprj", + "IxVM::get_ci_iprj": "Ingress::get_ci_iprj", + "IxVM::get_ci_rprj": "Ingress::get_ci_rprj", + "IxVM::get_claim_context": "KernelClaim::get_claim_context", + "IxVM::get_constant": "IxonDeserialize::get_constant", + "IxVM::get_constant_info": "IxonDeserialize::get_constant_info", + "IxVM::get_constant_info_by_variant": "IxonDeserialize::get_constant_info_by_variant", + "IxVM::get_constructor": "IxonDeserialize::get_constructor", + "IxVM::get_constructor_list": "IxonDeserialize::get_constructor_list", + "IxVM::get_constructor_proj": "IxonDeserialize::get_constructor_proj", + "IxVM::get_ctor_entry": "KernelClaim::get_ctor_entry", + "IxVM::get_ctor_entry_list_inner": "KernelClaim::get_ctor_entry_list_inner", + "IxVM::get_definition": "IxonDeserialize::get_definition", + "IxVM::get_definition_proj": "IxonDeserialize::get_definition_proj", + "IxVM::get_expr": "IxonDeserialize::get_expr", + "IxVM::get_expr_let": "IxonDeserialize::get_expr_let", + "IxVM::get_expr_list": "IxonDeserialize::get_expr_list", + "IxVM::get_inductive": "IxonDeserialize::get_inductive", + "IxVM::get_inductive_proj": "IxonDeserialize::get_inductive_proj", + "IxVM::get_lam_mode": "IxonDeserialize::get_lam_mode", + "IxVM::get_lam_telescope": "IxonDeserialize::get_lam_telescope", + "IxVM::get_mut_const": "IxonDeserialize::get_mut_const", + "IxVM::get_mut_const_list": "IxonDeserialize::get_mut_const_list", + "IxVM::get_mut_entry": "KernelClaim::get_mut_entry", + "IxVM::get_mut_entry_list_inner": "KernelClaim::get_mut_entry_list_inner", + "IxVM::get_opt_addr": "KernelClaim::get_opt_addr", + "IxVM::get_opt_addr_masked": "KernelClaim::get_opt_addr_masked", + "IxVM::get_opt_bool_masked": "KernelClaim::get_opt_bool_masked", + "IxVM::get_opt_ctor_entry_list_masked": "KernelClaim::get_opt_ctor_entry_list_masked", + "IxVM::get_opt_def_kind_masked": "KernelClaim::get_opt_def_kind_masked", + "IxVM::get_opt_def_safety_masked": "KernelClaim::get_opt_def_safety_masked", + "IxVM::get_opt_quot_kind_masked": "KernelClaim::get_opt_quot_kind_masked", + "IxVM::get_opt_rule_list_masked": "KernelClaim::get_opt_rule_list_masked", + "IxVM::get_opt_u64_masked": "KernelClaim::get_opt_u64_masked", + "IxVM::get_quot_kind": "IxonDeserialize::get_quot_kind", + "IxVM::get_quotient": "IxonDeserialize::get_quotient", + "IxVM::get_recursor": "IxonDeserialize::get_recursor", + "IxVM::get_recursor_proj": "IxonDeserialize::get_recursor_proj", + "IxVM::get_recursor_rule": "IxonDeserialize::get_recursor_rule", + "IxVM::get_recursor_rule_list": "IxonDeserialize::get_recursor_rule_list", + "IxVM::get_refs": "IxonDeserialize::get_refs", + "IxVM::get_result_sort_level": "KernelCheck::get_result_sort_level", + "IxVM::get_reveal_ctor_info": "KernelClaim::get_reveal_ctor_info", + "IxVM::get_reveal_info": "KernelClaim::get_reveal_info", + "IxVM::get_reveal_mut_const_info": "KernelClaim::get_reveal_mut_const_info", + "IxVM::get_reveal_rule": "KernelClaim::get_reveal_rule", + "IxVM::get_reveal_rule_list_inner": "KernelClaim::get_reveal_rule_list_inner", + "IxVM::get_sharing": "IxonDeserialize::get_sharing", + "IxVM::get_tagn0": "IxonDeserialize::get_tagn0", + "IxVM::get_tagn2": "IxonDeserialize::get_tagn2", + "IxVM::get_tagn4": "IxonDeserialize::get_tagn4", + "IxVM::get_tagn_tail": "IxonDeserialize::get_tagn_tail", + "IxVM::get_tagn_wide": "IxonDeserialize::get_tagn_wide", + "IxVM::get_u64_le": "IxonDeserialize::get_u64_le", + "IxVM::get_u64_list": "IxonDeserialize::get_u64_list", + "IxVM::get_univ": "IxonDeserialize::get_univ", + "IxVM::get_univ_list": "IxonDeserialize::get_univ_list", + "IxVM::get_univs": "IxonDeserialize::get_univs", + "IxVM::glist_cmp": "KernelLevels::glist_cmp", + "IxVM::glist_eq_len": "KernelLevels::glist_eq_len", + "IxVM::glist_ordered_insert": "KernelLevels::glist_ordered_insert", + "IxVM::glist_subset": "KernelLevels::glist_subset", + "IxVM::group_admit": "KernelRoles::group_admit", + "IxVM::group_admit_needs": "KernelRoles::group_admit_needs", + "IxVM::group_count": "KernelRoleSpec::group_count", + "IxVM::group_needs": "KernelRoleSpec::group_needs", + "IxVM::group_roles": "KernelRoleSpec::group_roles", + "IxVM::group_validation_limit": "KernelRoles::group_validation_limit", + "IxVM::has_bvar_in_range": "KernelSubst::has_bvar_in_range", + "IxVM::has_bvar_in_range_binder": "KernelSubst::has_bvar_in_range_binder", + "IxVM::has_bvar_in_range_bvar": "KernelSubst::has_bvar_in_range_bvar", + "IxVM::has_bvar_in_range_let": "KernelSubst::has_bvar_in_range_let", + "IxVM::head_addr": "KernelDefEq::head_addr", + "IxVM::ind_is_solo": "KernelCheck::ind_is_solo", + "IxVM::infer_let_drop_unused": "KernelInfer::infer_let_drop_unused", + "IxVM::infer_let_local_cutoff": "KernelInfer::infer_let_local_cutoff", + "IxVM::infer_let_lookup_type": "KernelInfer::infer_let_lookup_type", + "IxVM::infer_let_lookup_value": "KernelInfer::infer_let_lookup_value", + "IxVM::infer_let_materialize": "KernelInfer::infer_let_materialize", + "IxVM::infer_let_var_type": "KernelInfer::infer_let_var_type", + "IxVM::infer_let_var_value": "KernelInfer::infer_let_var_value", + "IxVM::int_add_prim": "KernelNatPrim::int_add_prim", + "IxVM::int_bdiv_prim": "KernelNatPrim::int_bdiv_prim", + "IxVM::int_bmod_prim": "KernelNatPrim::int_bmod_prim", + "IxVM::int_ediv_prim": "KernelNatPrim::int_ediv_prim", + "IxVM::int_emod_prim": "KernelNatPrim::int_emod_prim", + "IxVM::int_le_verdict": "KernelInfer::int_le_verdict", + "IxVM::io_const_num_lvls": "KernelInferOnly::io_const_num_lvls", + "IxVM::io_const_type_of": "KernelInferOnly::io_const_type_of", + "IxVM::io_get_info": "IxVMCompat::io_get_info", + "IxVM::io_peel_field_loop": "KernelInferOnly::io_peel_field_loop", + "IxVM::io_peel_params_subst": "KernelInferOnly::io_peel_params_subst", + "IxVM::io_types_lookup": "KernelInferOnly::io_types_lookup", + "IxVM::is_defn_or_thm": "KernelDefEq::is_defn_or_thm", + "IxVM::is_inductive_prop": "KernelInfer::is_inductive_prop", + "IxVM::is_large_eliminator": "KernelCheck::is_large_eliminator", + "IxVM::is_muts_block": "KernelCheck::is_muts_block", + "IxVM::is_nat_succ_ih_step": "KernelNatPrim::is_nat_succ_ih_step", + "IxVM::is_nat_zero": "KernelDefEq::is_nat_zero", + "IxVM::is_prop_type": "KernelDefEq::is_prop_type", + "IxVM::is_rec_field": "KernelCheck::is_rec_field", + "IxVM::is_rec_field_peel": "KernelCheck::is_rec_field_peel", + "IxVM::is_unit_like_type": "KernelDefEq::is_unit_like_type", + "IxVM::is_unsafe_ci": "KernelCheck::is_unsafe_ci", + "IxVM::k_check": "KernelInfer::k_check", + "IxVM::k_def_eq_rebase": "KernelDefEq::k_def_eq_rebase", + "IxVM::k_ensure_sort": "KernelInfer::k_ensure_sort", + "IxVM::k_infer": "KernelInfer::k_infer", + "IxVM::k_infer_app_spine_loop": "KernelInfer::k_infer_app_spine_loop", + "IxVM::k_infer_core": "KernelInfer::k_infer_core", + "IxVM::k_infer_let_env": "KernelInfer::k_infer_let_env", + "IxVM::k_infer_let_env_core": "KernelInfer::k_infer_let_env_core", + "IxVM::k_infer_let_env_rebase": "KernelInfer::k_infer_let_env_rebase", + "IxVM::k_infer_let_start": "KernelInfer::k_infer_let_start", + "IxVM::k_infer_lit": "KernelInfer::k_infer_lit", + "IxVM::k_infer_only": "KernelInferOnly::k_infer_only", + "IxVM::k_infer_only_core": "KernelInferOnly::k_infer_only_core", + "IxVM::k_infer_proj": "KernelInfer::k_infer_proj", + "IxVM::k_infer_rebase": "KernelInfer::k_infer_rebase", + "IxVM::k_is_def_eq": "KernelDefEq::k_is_def_eq", + "IxVM::k_is_def_eq_core": "KernelDefEq::k_is_def_eq_core", + "IxVM::k_is_def_eq_ordered": "KernelDefEq::k_is_def_eq_ordered", + "IxVM::k_is_def_eq_slow": "KernelDefEq::k_is_def_eq_slow", + "IxVM::k_is_def_eq_slow2": "KernelDefEq::k_is_def_eq_slow2", + "IxVM::k_is_def_eq_slow_nd": "KernelDefEq::k_is_def_eq_slow_nd", + "IxVM::k_is_def_eq_slow_nd_after_core": "KernelDefEq::k_is_def_eq_slow_nd_after_core", + "IxVM::k_is_def_eq_struct": "KernelDefEq::k_is_def_eq_struct", + "IxVM::k_is_def_eq_struct_bounded": "KernelDefEq::k_is_def_eq_struct_bounded", + "IxVM::k_is_def_eq_struct_go": "KernelDefEq::k_is_def_eq_struct_go", + "IxVM::k_is_def_eq_struct_safe": "KernelDefEq::k_is_def_eq_struct_safe", + "IxVM::k_is_def_eq_struct_spend": "KernelDefEq::k_is_def_eq_struct_spend", + "IxVM::k_is_def_eq_structure_tree": "KernelDefEq::k_is_def_eq_structure_tree", + "IxVM::k_is_def_eq_structure_tree_app": "KernelDefEq::k_is_def_eq_structure_tree_app", + "IxVM::k_synth_gate": "KernelWhnf::k_synth_gate", + "IxVM::kexpr_struct_eq": "KernelCheck::kexpr_struct_eq", + "IxVM::klimbs_add": "KernelKlimbs::klimbs_add", + "IxVM::klimbs_add_carry": "KernelKlimbs::klimbs_add_carry", + "IxVM::klimbs_dec": "KernelKlimbs::klimbs_dec", + "IxVM::klimbs_div": "KernelKlimbs::klimbs_div", + "IxVM::klimbs_div_mod": "KernelKlimbs::klimbs_div_mod", + "IxVM::klimbs_eq": "KernelLevels::klimbs_eq", + "IxVM::klimbs_from_g": "KernelNatPrim::klimbs_from_g", + "IxVM::klimbs_gcd": "KernelKlimbs::klimbs_gcd", + "IxVM::klimbs_is_zero": "KernelKlimbs::klimbs_is_zero", + "IxVM::klimbs_land": "KernelKlimbs::klimbs_land", + "IxVM::klimbs_le": "KernelKlimbs::klimbs_le", + "IxVM::klimbs_lor": "KernelKlimbs::klimbs_lor", + "IxVM::klimbs_mod": "KernelKlimbs::klimbs_mod", + "IxVM::klimbs_mul": "KernelKlimbs::klimbs_mul", + "IxVM::klimbs_mul_outer": "KernelKlimbs::klimbs_mul_outer", + "IxVM::klimbs_mul_single": "KernelKlimbs::klimbs_mul_single", + "IxVM::klimbs_normalize": "KernelKlimbs::klimbs_normalize", + "IxVM::klimbs_pow": "KernelKlimbs::klimbs_pow", + "IxVM::klimbs_scalar_value": "KernelNatPrim::klimbs_scalar_value", + "IxVM::klimbs_shl": "KernelKlimbs::klimbs_shl", + "IxVM::klimbs_shl_limbs": "KernelKlimbs::klimbs_shl_limbs", + "IxVM::klimbs_shr": "KernelKlimbs::klimbs_shr", + "IxVM::klimbs_sub": "KernelKlimbs::klimbs_sub", + "IxVM::klimbs_sub_borrow": "KernelKlimbs::klimbs_sub_borrow", + "IxVM::klimbs_succ": "KernelKlimbs::klimbs_succ", + "IxVM::klimbs_xor_op": "KernelKlimbs::klimbs_xor_op", + "IxVM::lam_telescope_count": "IxonSerialize::lam_telescope_count", + "IxVM::lazy_delta_a_const_b_proj": "KernelDefEq::lazy_delta_a_const_b_proj", + "IxVM::lazy_delta_b_const_a_proj": "KernelDefEq::lazy_delta_b_const_a_proj", + "IxVM::lazy_delta_both_proj": "KernelDefEq::lazy_delta_both_proj", + "IxVM::lazy_delta_loop": "KernelDefEq::lazy_delta_loop", + "IxVM::lazy_delta_step_const_const": "KernelDefEq::lazy_delta_step_const_const", + "IxVM::lbr_dec": "KernelSubst::lbr_dec", + "IxVM::lbr_max": "KernelSubst::lbr_max", + "IxVM::lbr_min": "KernelSubst::lbr_min", + "IxVM::leaf_hash": "KernelClaim::leaf_hash", + "IxVM::level_eq": "KernelLevels::level_eq", + "IxVM::level_equal": "KernelLevels::level_equal", + "IxVM::level_explicit_val": "KernelLevels::level_explicit_val", + "IxVM::level_imax": "KernelLevels::level_imax", + "IxVM::level_inst_params": "KernelLevels::level_inst_params", + "IxVM::level_is_not_zero": "KernelLevels::level_is_not_zero", + "IxVM::level_leq": "KernelLevels::level_leq", + "IxVM::level_list_eq": "KernelDefEq::level_list_eq", + "IxVM::level_list_inst": "KernelLevels::level_list_inst", + "IxVM::level_list_struct_eq": "KernelCheck::level_list_struct_eq", + "IxVM::level_max": "KernelLevels::level_max", + "IxVM::level_max_go": "KernelLevels::level_max_go", + "IxVM::level_max_offsets": "KernelLevels::level_max_offsets", + "IxVM::level_max_subsumes": "KernelLevels::level_max_subsumes", + "IxVM::level_normalize": "KernelLevels::level_normalize", + "IxVM::level_offset_of": "KernelLevels::level_offset_of", + "IxVM::level_reduce": "KernelLevels::level_reduce", + "IxVM::level_struct_eq": "KernelLevels::level_struct_eq", + "IxVM::list_any_mentions_block": "KernelCheck::list_any_mentions_block", + "IxVM::list_concat": "Lists::concat", + "IxVM::list_depth_checked": "WordLists::depth_checked", + "IxVM::list_drop": "Lists::drop", + "IxVM::list_length": "Lists::length", + "IxVM::list_length_u64": "WordLists::length_u64", + "IxVM::list_lift_each": "KernelCheck::list_lift_each", + "IxVM::list_lift_indices": "KernelCheck::list_lift_indices", + "IxVM::list_lookup": "Lists::lookup", + "IxVM::list_lookup_or_default": "Lists::lookup_or_default", + "IxVM::list_lookup_u64": "WordLists::lookup_u64", + "IxVM::list_reverse": "Lists::reverse", + "IxVM::list_reverse_acc": "Lists::reverse_acc", + "IxVM::list_snoc": "Lists::snoc", + "IxVM::list_take": "Lists::take", + "IxVM::literal_eq": "KernelLevels::literal_eq", + "IxVM::load_assumption_tree": "KernelClaim::load_assumption_tree", + "IxVM::load_constant_hint": "Ingress::load_constant_hint", + "IxVM::load_role_ctx": "KernelRoles::load_role_ctx", + "IxVM::load_role_table": "KernelRoles::load_role_table", + "IxVM::load_verified_blob": "Ingress::load_verified_blob", + "IxVM::load_verified_constant": "Ingress::load_verified_constant", + "IxVM::mk_bool": "KernelNatPrim::mk_bool", + "IxVM::mk_eq1": "KernelInfer::mk_eq1", + "IxVM::mk_int_prim": "KernelNatPrim::mk_int_prim", + "IxVM::mk_nat_binop_stuck": "KernelNatPrim::mk_nat_binop_stuck", + "IxVM::mk_nat_lit": "KernelNatPrim::mk_nat_lit", + "IxVM::mk_nat_offset_stuck": "KernelNatPrim::mk_nat_offset_stuck", + "IxVM::muts_has_kind": "KernelCheck::muts_has_kind", + "IxVM::muts_indc_count_is_one": "KernelCheck::muts_indc_count_is_one", + "IxVM::muts_member_at": "Ingress::muts_member_at", + "IxVM::nat_lit_to_ctor_or_self": "KernelWhnf::nat_lit_to_ctor_or_self", + "IxVM::nat_offset_of": "KernelDefEq::nat_offset_of", + "IxVM::nl_add_const": "KernelLevels::nl_add_const", + "IxVM::nl_add_const_go": "KernelLevels::nl_add_const_go", + "IxVM::nl_add_var": "KernelLevels::nl_add_var", + "IxVM::nl_covers_const": "KernelLevels::nl_covers_const", + "IxVM::nl_covers_var": "KernelLevels::nl_covers_var", + "IxVM::nl_eq": "KernelLevels::nl_eq", + "IxVM::nl_le": "KernelLevels::nl_le", + "IxVM::nl_le_vars": "KernelLevels::nl_le_vars", + "IxVM::nl_skip_empty": "KernelLevels::nl_skip_empty", + "IxVM::nl_subsume_entry": "KernelLevels::nl_subsume_entry", + "IxVM::nl_subsumption_walk": "KernelLevels::nl_subsumption_walk", + "IxVM::nlvars_add": "KernelLevels::nlvars_add", + "IxVM::nlvars_any_offset_geq": "KernelLevels::nlvars_any_offset_geq", + "IxVM::nlvars_dominates": "KernelLevels::nlvars_dominates", + "IxVM::nlvars_eq": "KernelLevels::nlvars_eq", + "IxVM::nlvars_max_offset": "KernelLevels::nlvars_max_offset", + "IxVM::nlvars_subsume": "KernelLevels::nlvars_subsume", + "IxVM::node_hash": "KernelClaim::node_hash", + "IxVM::normalize_aux": "KernelLevels::normalize_aux", + "IxVM::normalize_imax_dispatch": "KernelLevels::normalize_imax_dispatch", + "IxVM::np_apply_spine": "KernelNatPrim::np_apply_spine", + "IxVM::np_whnf_inner_bv": "KernelNatPrim::np_whnf_inner_bv", + "IxVM::op_certificate": "KernelRoleSpec::op_certificate", + "IxVM::op_equation_count": "KernelRoleSpec::op_equation_count", + "IxVM::op_equation_lhs": "KernelRoleSpec::op_equation_lhs", + "IxVM::op_equation_rhs": "KernelRoleSpec::op_equation_rhs", + "IxVM::op_evidence_is_proof": "KernelRoleSpec::op_evidence_is_proof", + "IxVM::ordinary_div_mod": "IxVMCompat::ordinary_div_mod", + "IxVM::pack_def_kind_safety": "IxonSerialize::pack_def_kind_safety", + "IxVM::parse_atree_body": "KernelClaim::parse_atree_body", + "IxVM::peel_beta": "KernelWhnf::peel_beta", + "IxVM::peel_ctor_params_subst": "KernelCheck::peel_ctor_params_subst", + "IxVM::peel_field_loop": "KernelInfer::peel_field_loop", + "IxVM::peel_leading_foralls": "KernelCheck::peel_leading_foralls", + "IxVM::peel_leading_foralls_acc": "KernelCheck::peel_leading_foralls_acc", + "IxVM::peel_motive_params_subst": "KernelCheck::peel_motive_params_subst", + "IxVM::peel_n_alls_whnf": "KernelInfer::peel_n_alls_whnf", + "IxVM::peel_n_foralls": "KernelCheck::peel_n_foralls", + "IxVM::peel_n_foralls_with_types": "KernelCheck::peel_n_foralls_with_types", + "IxVM::peel_n_lams_collect": "KernelCheck::peel_n_lams_collect", + "IxVM::peel_params_subst": "KernelInfer::peel_params_subst", + "IxVM::peer_agree_walk": "KernelCheck::peer_agree_walk", + "IxVM::populate_rules": "KernelCheck::populate_rules", + "IxVM::prim_family": "KernelWhnf::prim_family", + "IxVM::primary_parent_block_of": "KernelCheck::primary_parent_block_of", + "IxVM::projection_addr": "Ingress::projection_addr", + "IxVM::projection_addr_ctor": "KernelCheck::projection_addr_ctor", + "IxVM::projection_definition_info": "KernelWhnf::projection_definition_info", + "IxVM::put_address": "IxonSerialize::put_address", + "IxVM::put_address_list": "IxonSerialize::put_address_list", + "IxVM::put_all_mode": "IxonSerialize::put_all_mode", + "IxVM::put_all_telescope": "IxonSerialize::put_all_telescope", + "IxVM::put_app_telescope": "IxonSerialize::put_app_telescope", + "IxVM::put_axiom": "IxonSerialize::put_axiom", + "IxVM::put_constant": "IxonSerialize::put_constant", + "IxVM::put_constant_info": "IxonSerialize::put_constant_info", + "IxVM::put_constructor": "IxonSerialize::put_constructor", + "IxVM::put_constructor_list": "IxonSerialize::put_constructor_list", + "IxVM::put_constructor_proj": "IxonSerialize::put_constructor_proj", + "IxVM::put_definition": "IxonSerialize::put_definition", + "IxVM::put_definition_proj": "IxonSerialize::put_definition_proj", + "IxVM::put_expr": "IxonSerialize::put_expr", + "IxVM::put_expr_list": "IxonSerialize::put_expr_list", + "IxVM::put_inductive": "IxonSerialize::put_inductive", + "IxVM::put_inductive_proj": "IxonSerialize::put_inductive_proj", + "IxVM::put_lam_mode": "IxonSerialize::put_lam_mode", + "IxVM::put_lam_telescope": "IxonSerialize::put_lam_telescope", + "IxVM::put_mut_const": "IxonSerialize::put_mut_const", + "IxVM::put_mut_const_list": "IxonSerialize::put_mut_const_list", + "IxVM::put_quot_kind": "IxonSerialize::put_quot_kind", + "IxVM::put_quotient": "IxonSerialize::put_quotient", + "IxVM::put_recursor": "IxonSerialize::put_recursor", + "IxVM::put_recursor_proj": "IxonSerialize::put_recursor_proj", + "IxVM::put_recursor_rule": "IxonSerialize::put_recursor_rule", + "IxVM::put_recursor_rule_list": "IxonSerialize::put_recursor_rule_list", + "IxVM::put_refs": "IxonSerialize::put_refs", + "IxVM::put_sharing": "IxonSerialize::put_sharing", + "IxVM::put_tagn0": "IxonSerialize::put_tagn0", + "IxVM::put_tagn2": "IxonSerialize::put_tagn2", + "IxVM::put_tagn4": "IxonSerialize::put_tagn4", + "IxVM::put_tagn_tail": "IxonSerialize::put_tagn_tail", + "IxVM::put_tagn_wide": "IxonSerialize::put_tagn_wide", + "IxVM::put_u64_le": "IxonSerialize::put_u64_le", + "IxVM::put_u64_list": "IxonSerialize::put_u64_list", + "IxVM::put_univ": "IxonSerialize::put_univ", + "IxVM::put_univ_list": "IxonSerialize::put_univ_list", + "IxVM::put_univs": "IxonSerialize::put_univs", + "IxVM::quot_extract_arg": "KernelWhnf::quot_extract_arg", + "IxVM::quot_kind_tag": "KernelClaim::quot_kind_tag", + "IxVM::rbtree_map_balance": "RBTreeMap::rbtree_map_balance", + "IxVM::rbtree_map_balance_fix": "RBTreeMap::rbtree_map_balance_fix", + "IxVM::rbtree_map_ins": "RBTreeMap::rbtree_map_ins", + "IxVM::rbtree_map_insert": "RBTreeMap::rbtree_map_insert", + "IxVM::rbtree_map_lookup_or_default": "RBTreeMap::rbtree_map_lookup_or_default", + "IxVM::read_byte": "IxonDeserialize::read_byte", + "IxVM::read_byte_stream": "IxByteStream::read_byte_stream", + "IxVM::read_evidence_entries": "KernelRoles::read_evidence_entries", + "IxVM::read_finite_byte_stream": "IxByteStream::read_finite_byte_stream", + "IxVM::read_role_bindings": "KernelRoles::read_role_bindings", + "IxVM::read_role_evidence": "KernelRoles::read_role_evidence", + "IxVM::rec_to_parent_addr": "KernelCheck::rec_to_parent_addr", + "IxVM::replace_spine_major": "KernelWhnf::replace_spine_major", + "IxVM::role_addr": "KernelRoles::role_addr", + "IxVM::role_addr_index": "KernelRoles::role_addr_index", + "IxVM::role_admission_checks": "KernelRoles::role_admission_checks", + "IxVM::role_bit_vec_of_nat": "KernelRoleSpec::role_bit_vec_of_nat", + "IxVM::role_bool": "KernelRoleSpec::role_bool", + "IxVM::role_bool_false": "KernelRoleSpec::role_bool_false", + "IxVM::role_bool_true": "KernelRoleSpec::role_bool_true", + "IxVM::role_bound_addr": "KernelRoles::role_bound_addr", + "IxVM::role_bound_addr_or_zero": "KernelRoles::role_bound_addr_or_zero", + "IxVM::role_byte_array_empty": "KernelRoleSpec::role_byte_array_empty", + "IxVM::role_char": "KernelRoleSpec::role_char", + "IxVM::role_char_of_nat": "KernelRoleSpec::role_char_of_nat", + "IxVM::role_choice": "KernelRoleSpec::role_choice", + "IxVM::role_count": "KernelRoleSpec::role_count", + "IxVM::role_ctor_count": "KernelRoleSpec::role_ctor_count", + "IxVM::role_ctor_of": "KernelRoleSpec::role_ctor_of", + "IxVM::role_ctx_assumed": "KernelRoles::role_ctx_assumed", + "IxVM::role_ctx_axioms": "KernelRoles::role_ctx_axioms", + "IxVM::role_ctx_binding": "KernelRoles::role_ctx_binding", + "IxVM::role_ctx_for_validator": "KernelRoles::role_ctx_for_validator", + "IxVM::role_ctx_is_assumed": "KernelRoles::role_ctx_is_assumed", + "IxVM::role_ctx_limit": "KernelRoles::role_ctx_limit", + "IxVM::role_ctx_table": "KernelRoles::role_ctx_table", + "IxVM::role_ctx_validator": "KernelRoles::role_ctx_validator", + "IxVM::role_decidable_is_false": "KernelRoleSpec::role_decidable_is_false", + "IxVM::role_decidable_is_true": "KernelRoleSpec::role_decidable_is_true", + "IxVM::role_eq": "KernelRoleSpec::role_eq", + "IxVM::role_eq_refl": "KernelRoleSpec::role_eq_refl", + "IxVM::role_evidence": "KernelRoles::role_evidence", + "IxVM::role_group": "KernelRoleSpec::role_group", + "IxVM::role_index_of": "KernelRoles::role_index_of", + "IxVM::role_int": "KernelRoleSpec::role_int", + "IxVM::role_int_dec_le": "KernelRoleSpec::role_int_dec_le", + "IxVM::role_int_le": "KernelRoleSpec::role_int_le", + "IxVM::role_int_neg_succ": "KernelRoleSpec::role_int_neg_succ", + "IxVM::role_int_of_nat": "KernelRoleSpec::role_int_of_nat", + "IxVM::role_is": "KernelRoles::role_is", + "IxVM::role_is_bound": "KernelRoles::role_is_bound", + "IxVM::role_levels": "KernelRoleSpec::role_levels", + "IxVM::role_list_cons": "KernelRoleSpec::role_list_cons", + "IxVM::role_list_nil": "KernelRoleSpec::role_list_nil", + "IxVM::role_map_lookup_or_default": "KernelRoles::role_map_lookup_or_default", + "IxVM::role_member_kind": "KernelRoleSpec::role_member_kind", + "IxVM::role_nat": "KernelRoleSpec::role_nat", + "IxVM::role_nat_add": "KernelRoleSpec::role_nat_add", + "IxVM::role_nat_dec_le": "KernelRoleSpec::role_nat_dec_le", + "IxVM::role_nat_le": "KernelRoleSpec::role_nat_le", + "IxVM::role_nat_succ": "KernelRoleSpec::role_nat_succ", + "IxVM::role_nat_zero": "KernelRoleSpec::role_nat_zero", + "IxVM::role_of": "KernelRoles::role_of", + "IxVM::role_of_decide_eq_false": "KernelRoleSpec::role_of_decide_eq_false", + "IxVM::role_of_decide_eq_true": "KernelRoleSpec::role_of_decide_eq_true", + "IxVM::role_prim_family": "KernelRoleSpec::role_prim_family", + "IxVM::role_propext": "KernelRoleSpec::role_propext", + "IxVM::role_quot": "KernelRoleSpec::role_quot", + "IxVM::role_quot_ind": "KernelRoleSpec::role_quot_ind", + "IxVM::role_quot_lift": "KernelRoleSpec::role_quot_lift", + "IxVM::role_quot_mk": "KernelRoleSpec::role_quot_mk", + "IxVM::role_quot_sound": "KernelRoleSpec::role_quot_sound", + "IxVM::role_sorry_ax": "KernelRoleSpec::role_sorry_ax", + "IxVM::role_spec_kind": "KernelRoleSpec::role_spec_kind", + "IxVM::role_string": "KernelRoleSpec::role_string", + "IxVM::role_string_of_list": "KernelRoleSpec::role_string_of_list", + "IxVM::role_type": "KernelRoleSpec::role_type", + "IxVM::role_used_implicitly": "KernelRoles::role_used_implicitly", + "IxVM::run_check": "KernelClaim::run_check", + "IxVM::run_check_env": "KernelClaim::run_check_env", + "IxVM::run_check_transitive": "KernelClaim::run_check_transitive", + "IxVM::run_claim": "KernelClaim::run_claim", + "IxVM::run_contains": "KernelClaim::run_contains", + "IxVM::run_eval": "KernelEval::run_eval", + "IxVM::run_reveal": "KernelClaim::run_reveal", + "IxVM::safe_refs_only": "KernelCheck::safe_refs_only", + "IxVM::se_addr_in": "KernelWhnf::se_addr_in", + "IxVM::se_mentions": "KernelWhnf::se_mentions", + "IxVM::se_parent_addr": "KernelWhnf::se_parent_addr", + "IxVM::se_peel_tol": "KernelWhnf::se_peel_tol", + "IxVM::se_scan_fields": "KernelWhnf::se_scan_fields", + "IxVM::skip_bytes": "Convert::skip_bytes", + "IxVM::slow2_after_delta": "KernelDefEq::slow2_after_delta", + "IxVM::slow2_eager_fallback": "KernelDefEq::slow2_eager_fallback", + "IxVM::spec_digest": "KernelRoleSpec::spec_digest", + "IxVM::spec_params_dom_prefix_match": "KernelCheck::spec_params_dom_prefix_match", + "IxVM::spec_params_lower": "KernelCheck::spec_params_lower", + "IxVM::spec_params_ptr_eq": "KernelCheck::spec_params_ptr_eq", + "IxVM::spec_version": "KernelRoleSpec::spec_version", + "IxVM::split_u32": "KernelNatPrim::split_u32", + "IxVM::str_lit_delta_step": "KernelNatPrim::str_lit_delta_step", + "IxVM::str_lit_to_ctor": "KernelNatPrim::str_lit_to_ctor", + "IxVM::str_lit_to_ctor_app_or_self": "KernelNatPrim::str_lit_to_ctor_app_or_self", + "IxVM::stream_equal": "IxVMCompat::stream_equal", + "IxVM::struct_block_member_addrs": "KernelWhnf::struct_block_member_addrs", + "IxVM::struct_is_rec": "KernelWhnf::struct_is_rec", + "IxVM::struct_scan_ctors": "KernelWhnf::struct_scan_ctors", + "IxVM::subst_param_for": "KernelCheck::subst_param_for", + "IxVM::try_bitvec_dispatch": "KernelNatPrim::try_bitvec_dispatch", + "IxVM::try_dec_dispatch": "KernelInfer::try_dec_dispatch", + "IxVM::try_def_eq_app": "KernelDefEq::try_def_eq_app", + "IxVM::try_def_eq_nat": "KernelDefEq::try_def_eq_nat", + "IxVM::try_eta_expand": "KernelDefEq::try_eta_expand", + "IxVM::try_eta_struct": "KernelDefEq::try_eta_struct", + "IxVM::try_eta_swap": "KernelDefEq::try_eta_swap", + "IxVM::try_extract_int_prim": "KernelNatPrim::try_extract_int_prim", + "IxVM::try_extract_nat": "KernelNatPrim::try_extract_nat", + "IxVM::try_extract_nat_app": "KernelNatPrim::try_extract_nat_app", + "IxVM::try_int_prim_dispatch": "KernelNatPrim::try_int_prim_dispatch", + "IxVM::try_int_prim_second": "KernelNatPrim::try_int_prim_second", + "IxVM::try_iota": "KernelWhnf::try_iota", + "IxVM::try_k_synth_iota": "KernelWhnf::try_k_synth_iota", + "IxVM::try_lazy_delta_app": "KernelDefEq::try_lazy_delta_app", + "IxVM::try_match_nat_add": "KernelNatPrim::try_match_nat_add", + "IxVM::try_nat_binop_addr": "KernelNatPrim::try_nat_binop_addr", + "IxVM::try_nat_binop_dispatch": "KernelNatPrim::try_nat_binop_dispatch", + "IxVM::try_nat_dispatch": "KernelNatPrim::try_nat_dispatch", + "IxVM::try_nat_dispatch_prewhnf": "KernelWhnf::try_nat_dispatch_prewhnf", + "IxVM::try_nat_linear_rec": "KernelNatPrim::try_nat_linear_rec", + "IxVM::try_nat_offset_dispatch": "KernelNatPrim::try_nat_offset_dispatch", + "IxVM::try_prim_dispatch": "KernelWhnf::try_prim_dispatch", + "IxVM::try_proof_irrel": "KernelDefEq::try_proof_irrel", + "IxVM::try_quot_ind": "KernelWhnf::try_quot_ind", + "IxVM::try_quot_iota": "KernelWhnf::try_quot_iota", + "IxVM::try_quot_lift": "KernelWhnf::try_quot_lift", + "IxVM::try_reduce_bit_vec_ult": "KernelNatPrim::try_reduce_bit_vec_ult", + "IxVM::try_reduce_projection_definition": "KernelWhnf::try_reduce_projection_definition", + "IxVM::try_same_proj_head_app": "KernelDefEq::try_same_proj_head_app", + "IxVM::try_str_back": "KernelNatPrim::try_str_back", + "IxVM::try_str_dec_eq": "KernelInfer::try_str_dec_eq", + "IxVM::try_str_dispatch": "KernelNatPrim::try_str_dispatch", + "IxVM::try_str_to_byte_array": "KernelNatPrim::try_str_to_byte_array", + "IxVM::try_string_lit_one": "KernelDefEq::try_string_lit_one", + "IxVM::try_string_lit_pair": "KernelDefEq::try_string_lit_pair", + "IxVM::try_struct_eta_iota": "KernelWhnf::try_struct_eta_iota", + "IxVM::try_unfold_head": "KernelDefEq::try_unfold_head", + "IxVM::try_unfold_proj_app": "KernelDefEq::try_unfold_proj_app", + "IxVM::try_unit_like": "KernelDefEq::try_unit_like", + "IxVM::types_lookup": "KernelInfer::types_lookup", + "IxVM::unfold_a_and_loop": "KernelDefEq::unfold_a_and_loop", + "IxVM::unfold_b_and_loop": "KernelDefEq::unfold_b_and_loop", + "IxVM::unfold_both_and_loop": "KernelDefEq::unfold_both_and_loop", + "IxVM::univ_succ_base": "IxonSerialize::univ_succ_base", + "IxVM::univ_succ_count": "IxonSerialize::univ_succ_count", + "IxVM::unpack_def_kind_safety": "IxonDeserialize::unpack_def_kind_safety", + "IxVM::utf8_cont": "KernelNatPrim::utf8_cont", + "IxVM::utf8_decode_one": "KernelNatPrim::utf8_decode_one", + "IxVM::utf8_encode_prepend": "KernelNatPrim::utf8_encode_prepend", + "IxVM::utf8_groups": "KernelNatPrim::utf8_groups", + "IxVM::utf8_last_codepoint": "KernelNatPrim::utf8_last_codepoint", + "IxVM::utf8_last_go": "KernelNatPrim::utf8_last_go", + "IxVM::utf8_validate": "KernelNatPrim::utf8_validate", + "IxVM::validate_anchor": "KernelRoles::validate_anchor", + "IxVM::validate_binding": "KernelRoles::validate_binding", + "IxVM::validate_eqns": "KernelRoles::validate_eqns", + "IxVM::validate_eqns_equations": "KernelRoles::validate_eqns_equations", + "IxVM::validate_expr_well_scoped": "KernelCheck::validate_expr_well_scoped", + "IxVM::validate_group_roles": "KernelRoles::validate_group_roles", + "IxVM::validate_inert_axiom": "KernelRoles::validate_inert_axiom", + "IxVM::validate_member": "KernelRoles::validate_member", + "IxVM::validate_op": "KernelRoles::validate_op", + "IxVM::validate_op_equations": "KernelRoles::validate_op_equations", + "IxVM::validate_role": "KernelRoles::validate_role", + "IxVM::validate_standard_axiom": "KernelRoles::validate_standard_axiom", + "IxVM::validate_univ_params_list": "KernelCheck::validate_univ_params_list", + "IxVM::validate_univ_params_seen": "KernelCheck::validate_univ_params_seen", + "IxVM::validate_user_axioms": "KernelRoles::validate_user_axioms", + "IxVM::value_contract_code": "IxonSerialize::value_contract_code", + "IxVM::value_contract_from_bits": "IxonDeserialize::value_contract_from_bits", + "IxVM::verify_check_env": "IxVM::verify_check_env", + "IxVM::verify_claim": "IxVM::verify_claim", + "IxVM::verify_constant": "IxVM::verify_constant", + "IxVM::verify_serde": "IxVM::verify_serde", + "IxVM::verify_transitive": "IxVM::verify_transitive", + "IxVM::walk_char_list_bytes": "KernelNatPrim::walk_char_list_bytes", + "IxVM::walk_covered": "KernelRoles::walk_covered", + "IxVM::walk_ctx": "KernelRoles::walk_ctx", + "IxVM::walk_fields_classify": "KernelCheck::walk_fields_classify", + "IxVM::walk_leaves_owned": "KernelClaim::walk_leaves_owned", + "IxVM::walk_leaves_transitive": "KernelClaim::walk_leaves_transitive", + "IxVM::walk_refs_transitive": "KernelClaim::walk_refs_transitive", + "IxVM::whnf": "KernelWhnf::whnf", + "IxVM::whnf_apply_beta": "KernelWhnf::whnf_apply_beta", + "IxVM::whnf_const_head": "KernelWhnf::whnf_const_head", + "IxVM::whnf_core": "KernelWhnf::whnf_core", + "IxVM::whnf_get_ctor_or_none": "KernelWhnf::whnf_get_ctor_or_none", + "IxVM::whnf_iota_major": "KernelWhnf::whnf_iota_major", + "IxVM::whnf_nd": "KernelWhnf::whnf_nd", + "IxVM::whnf_nd_apply_beta": "KernelWhnf::whnf_nd_apply_beta", + "IxVM::whnf_nd_const_head": "KernelWhnf::whnf_nd_const_head", + "IxVM::whnf_nd_core": "KernelWhnf::whnf_nd_core", + "IxVM::whnf_nd_proj_head": "KernelWhnf::whnf_nd_proj_head", + "IxVM::whnf_nd_with_spine": "KernelWhnf::whnf_nd_with_spine", + "IxVM::whnf_proj_head": "KernelWhnf::whnf_proj_head", + "IxVM::whnf_spine": "KernelWhnf::whnf_spine", + "IxVM::whnf_struct_core": "KernelWhnf::whnf_struct_core", + "IxVM::whnf_struct_core_const": "KernelWhnf::whnf_struct_core_const", + "IxVM::whnf_struct_core_proj": "KernelWhnf::whnf_struct_core_proj", + "IxVM::whnf_struct_core_spine": "KernelWhnf::whnf_struct_core_spine", + "IxVM::whnf_with_spine": "KernelWhnf::whnf_with_spine", + "IxVM::wrap_foralls": "KernelCheck::wrap_foralls", + "IxVM::wrap_lams": "KernelCheck::wrap_lams" +} diff --git a/IxVM/IxVM/Program.sources b/IxVM/IxVM/Program.sources new file mode 100644 index 000000000..f56a1e0f4 --- /dev/null +++ b/IxVM/IxVM/Program.sources @@ -0,0 +1,24 @@ +# Ordered Aiur source bundle; paths are relative to this file. +Modules/RBTreeMap.aiur +Modules/Ixon.aiur +Modules/KernelTypes.aiur +Modules/KernelLevels.aiur +Modules/KernelRoles.aiur +Modules/KernelInfer.aiur +Modules/KernelClaim.aiur +Modules/IxByteStream.aiur +Modules/IxonSerialize.aiur +Modules/IxonDeserialize.aiur +Modules/KernelKlimbs.aiur +Modules/KernelNatPrim.aiur +Modules/Convert.aiur +Modules/Ingress.aiur +Modules/KernelSubst.aiur +Modules/KernelRoleSpec.aiur +Modules/KernelWhnf.aiur +Modules/KernelInferOnly.aiur +Modules/KernelDefEq.aiur +Modules/KernelCheck.aiur +Modules/IxVMCompat.aiur +Modules/KernelEval.aiur +Program.aiur diff --git a/IxVM/IxVM/PropagationBench.lean b/IxVM/IxVM/PropagationBench.lean new file mode 100644 index 000000000..2c95fbdb3 --- /dev/null +++ b/IxVM/IxVM/PropagationBench.lean @@ -0,0 +1,40 @@ +import Aiur.Optimized.Propagation +import Aiur.Optimized.Grouping.Snapshot +import Lean + +/-! Isolated physical-chip snapshots for profiling value propagation. -/ +namespace IxVM.PropagationBench +open Aiur +open Lean Optimized + +def write [ToJson F] (path : String) (chip : Circuit.Chip F) : IO Unit := + IO.FS.writeFile path (toJson chip).compress + +def run [Field F] [DecidableEq F] [FromJson F] (path : String) + (trace : Bool := false) : IO Unit := do + let json ← IO.ofExcept (Json.parse (← IO.FS.readFile path)) + let source : Circuit.Chip F ← IO.ofExcept (fromJson? json) + IO.eprintln s!"Loaded {source.name}: {source.numVars} columns, {source.constraints.length} equations" + let start ← IO.monoMsNow + if !trace then + let result ← IO.ofExcept (Propagation.run source) + unless result.chip.wellFormed do throw (IO.userError "propagation produced an invalid chip") + IO.eprintln s!"Propagation: {(← IO.monoMsNow) - start}ms, {result.chip.numVars} columns" + return + let mut chip := source + for iteration in [:source.numVars] do + let start ← IO.monoMsNow + let proposal := Propagation.proposal? chip + IO.eprintln s!"{iteration}: candidate id {proposal.map (·.candidate.id)}" + IO.eprintln s!"{iteration}: candidate {(← IO.monoMsNow) - start}ms" + let some proposal := proposal | break + let start ← IO.monoMsNow + let some checked := proposal.check chip | throw (IO.userError "candidate certificate rejected") + IO.eprintln s!"{iteration}: certificate {(← IO.monoMsNow) - start}ms" + let start ← IO.monoMsNow + chip := Propagation.rewrite chip id checked.val.replace + IO.eprintln s!"{iteration}: rewritten equations {chip.constraints.length}" + IO.eprintln s!"{iteration}: rewrite {(← IO.monoMsNow) - start}ms" + IO.eprintln s!"Propagation steps: {(← IO.monoMsNow) - start}ms" + +end IxVM.PropagationBench diff --git a/IxVM/IxVM/fixtures/nat-add-comm.json b/IxVM/IxVM/fixtures/nat-add-comm.json new file mode 100644 index 000000000..582673cbe --- /dev/null +++ b/IxVM/IxVM/fixtures/nat-add-comm.json @@ -0,0 +1 @@ +{"address":[188,232,122,2,85,172,116,174,184,244,216,102,9,91,242,158,6,18,96,128,141,181,109,245,5,48,51,167,93,68,147,59],"addressHex":"bce87a0255ac74aeb8f4d866095bf29e061260808db56df5053033a75d44933b","blobs":[{"address":[0,32,201,213,159,196,200,197,248,114,2,166,83,127,116,17,41,154,201,23,60,210,212,152,89,28,172,213,36,242,176,109],"bytes":[121,108,101,120],"hint":0},{"address":[0,38,60,169,245,127,113,119,244,149,227,113,31,140,221,89,150,122,10,26,77,232,149,177,235,238,86,108,209,136,62,212],"bytes":[32],"hint":0},{"address":[0,135,233,59,166,153,84,254,222,166,55,70,36,8,231,96,3,95,64,227,101,83,190,57,203,148,39,234,103,21,33,96],"bytes":[95,105,110,97,99,99,101,115,115,105,98,108,101],"hint":0},{"address":[1,92,48,58,221,74,247,229,122,6,216,44,59,91,107,166,204,64,129,227,249,231,115,38,121,129,54,45,85,102,183,107],"bytes":[67,104,97,114],"hint":0},{"address":[1,96,141,171,80,91,172,117,238,65,90,56,14,108,176,90,83,37,177,220,162,49,48,9,163,229,224,192,56,52,219,119],"bytes":[104,102,117,101,108],"hint":0},{"address":[2,147,7,187,64,144,147,15,74,160,76,5,116,212,165,209,55,207,225,205,78,79,245,66,72,252,219,227,146,65,48,92],"bytes":[95,102],"hint":0},{"address":[3,156,208,66,53,13,170,9,235,62,118,63,230,4,211,78,93,188,226,122,89,245,25,203,225,247,148,246,56,224,53,62],"bytes":[105,110,115,116,79,102,78,97,116,78,97,116],"hint":0},{"address":[4,97,52,230,253,51,253,236,70,59,212,13,74,129,98,192,207,213,127,28,33,239,189,43,162,88,7,229,246,198,242,20],"bytes":[116,97,105,108,95,105,104],"hint":0},{"address":[4,190,166,8,126,102,44,254,66,60,176,55,126,179,37,95,71,16,48,205,148,89,140,103,161,118,70,237,83,132,103,32],"bytes":[111,102,66,121,116,101,65,114,114,97,121],"hint":0},{"address":[5,35,191,213,8,34,178,31,62,226,244,143,232,101,105,43,79,57,8,160,251,212,27,195,135,233,162,147,185,100,144,218],"bytes":[108,116],"hint":0},{"address":[5,56,102,20,35,35,106,93,141,246,40,106,134,51,54,158,42,3,197,249,13,72,237,237,51,50,34,219,238,140,219,221],"bytes":[116],"hint":0},{"address":[6,140,186,30,158,176,90,74,110,219,77,135,223,181,58,249,171,203,208,140,176,54,217,182,45,5,207,128,39,184,19,201],"bytes":[72,68,105,118],"hint":0},{"address":[7,59,49,239,212,144,225,45,189,47,146,66,219,149,125,254,45,103,69,211,26,3,79,248,229,130,160,51,252,182,113,153],"bytes":[72,69,113],"hint":0},{"address":[7,153,248,6,197,202,207,25,212,0,144,184,188,93,114,164,213,174,119,100,21,156,219,2,235,54,19,229,152,104,80,218],"bytes":[52,57,98,54,50,50,55,48,97,56,52,97,98,57,48,56,53,55,100,48,56,100,49,57,99,56,50,53,98,54,50,53,100,51,52,101,51,55,102,53,100,49,56,56,57,49,98,102,101,99,97,48,50,57,57,99,102,53,50,53,51,100,49,52],"hint":0},{"address":[7,193,146,29,159,155,173,247,150,21,57,188,46,195,176,111,62,136,145,251,214,61,235,194,184,150,24,4,175,131,219,167],"bytes":[65,100,100],"hint":0},{"address":[8,17,42,158,51,76,231,48,66,181,49,194,86,104,207,92,177,42,30,224,64,164,50,106,254,172,6,84,97,7,154,6],"bytes":[121],"hint":0},{"address":[8,113,87,133,192,165,61,47,119,59,84,61,250,54,56,42,15,151,103,52,80,44,8,193,110,168,13,14,62,236,213,193],"bytes":[97,100,100,95,99,111,109,109],"hint":0},{"address":[8,144,183,106,157,7,64,18,173,42,241,255,191,125,223,127,113,110,65,53,99,96,0,72,2,198,128,243,47,250,133,102],"bytes":[115,117,98,95,108,116],"hint":0},{"address":[9,7,118,209,81,184,111,133,232,179,43,159,56,28,101,89,248,254,52,118,194,112,114,201,133,107,83,226,84,62,80,177],"bytes":[95,120,95,49],"hint":0},{"address":[9,31,9,169,231,129,20,102,17,225,184,170,177,10,141,161,181,113,74,94,40,12,118,196,79,0,106,101,74,1,58,90],"bytes":[80,85,110,105,116],"hint":0},{"address":[10,209,194,78,210,25,30,235,42,56,67,4,66,240,103,13,220,189,32,235,190,6,57,98,102,113,6,235,139,69,131,151],"bytes":[104,113],"hint":0},{"address":[10,250,164,157,47,25,46,98,140,35,27,223,174,78,182,83,32,200,125,224,95,184,51,62,118,94,13,165,98,232,243,3],"bytes":[109,97,116,99,104,95,49,95,49],"hint":0},{"address":[11,229,158,30,87,80,120,186,25,9,21,101,56,67,222,49,84,97,174,59,194,114,64,79,148,208,150,89,198,27,12,241],"bytes":[104,95,50],"hint":0},{"address":[12,200,176,123,189,35,232,6,65,243,29,18,53,227,28,107,28,241,86,158,66,179,148,51,147,176,127,24,149,36,249,237],"bytes":[105,104,95,105,104],"hint":0},{"address":[15,127,237,179,167,160,188,188,187,80,149,148,245,70,99,139,145,16,194,239,82,71,82,163,56,167,107,90,130,124,6,223],"bytes":[98,111,114,114,111,119,101,100],"hint":0},{"address":[16,147,175,214,204,93,99,168,17,187,230,37,96,70,125,235,238,162,244,159,32,129,190,210,174,102,251,109,82,194,120,43],"bytes":[104,112],"hint":0},{"address":[16,229,207,61,60,138,79,159,52,104,200,204,88,238,168,72,146,162,47,218,219,193,172,178,36,16,25,0,68,193,213,83],"bytes":[98],"hint":0},{"address":[17,39,125,173,207,148,161,92,134,236,87,51,227,111,206,97,189,135,158,223,102,139,153,76,108,80,62,28,125,113,252,157],"bytes":[100,101,99,105,100,101,95,101,113,95,102,97,108,115,101],"hint":0},{"address":[18,199,29,146,85,18,171,23,99,249,214,131,71,230,48,62,52,75,36,87,241,13,106,231,147,92,39,15,40,196,190,207],"bytes":[118,97,108],"hint":0},{"address":[19,94,72,231,232,166,196,108,84,182,145,220,19,227,206,32,184,66,103,85,237,82,173,95,147,235,180,182,98,21,179,24],"bytes":[117],"hint":0},{"address":[19,126,74,36,39,97,251,119,251,75,109,66,248,55,149,119,203,78,95,8,130,179,219,130,241,78,244,5,35,41,3,56],"bytes":[105,110,115,116,76,69,78,97,116],"hint":0},{"address":[22,72,79,142,53,164,137,99,70,179,126,121,175,91,183,83,20,187,60,114,20,236,177,131,13,127,93,109,170,194,148,211],"bytes":[112,111,119,95,112,111,115],"hint":0},{"address":[22,104,28,101,206,162,108,192,145,8,57,169,133,186,245,69,210,148,216,166,211,186,255,208,204,4,241,118,0,4,91,130],"bytes":[95],"hint":0},{"address":[23,118,47,221,217,105,164,83,146,93,101,113,122,195,238,162,19,32,182,107,84,52,47,222,21,18,141,108,175,33,33,95],"bytes":[97],"hint":0},{"address":[24,40,51,6,121,241,19,30,14,149,199,25,126,140,240,204,241,0,228,103,129,101,183,62,219,237,144,129,100,25,254,229],"bytes":[105,115,70,97,108,115,101],"hint":0},{"address":[24,109,103,202,2,75,74,237,84,93,89,156,194,85,23,26,216,156,185,179,202,206,108,116,146,112,174,40,254,242,134,18],"bytes":[101,113],"hint":0},{"address":[25,12,26,196,35,238,146,126,150,140,46,20,48,176,95,253,81,225,172,55,217,209,67,78,142,39,24,251,140,246,15,113],"bytes":[116,111,66,121,116,101,65,114,114,97,121],"hint":0},{"address":[26,22,254,98,233,26,159,26,138,193,132,117,216,89,101,99,233,115,47,113,113,12,25,71,73,114,35,44,252,158,76,144],"bytes":[69,113],"hint":0},{"address":[27,14,113,71,191,27,196,197,252,42,125,55,211,77,117,60,28,199,142,155,145,33,207,156,81,207,116,128,138,182,136,82],"bytes":[112,114,101,100,95,108,101],"hint":0},{"address":[28,206,167,112,96,180,240,110,215,102,63,221,59,250,102,185,211,218,131,95,198,188,110,94,128,206,168,149,17,123,157,25],"bytes":[105,115,86,97,108,105,100,67,104,97,114],"hint":0},{"address":[29,16,67,22,149,109,232,119,230,83,53,42,206,116,17,254,229,137,85,84,224,138,195,199,213,227,114,252,15,212,137,46],"bytes":[105,110,115,116,68,101,99,105,100,97,98,108,101,69,113,66,111,111,108],"hint":0},{"address":[29,141,244,212,197,229,187,159,38,157,89,3,95,219,121,231,91,158,215,156,143,21,130,30,77,67,170,8,31,128,35,70],"bytes":[48,98,53,101,53,57,51,102,98,49,52,54,50,97,56,55,51,57,56,52,100,51,50,49,100,101,48,48,54,55,53,101,99,54,54,98,48,55,51,98,52,99,53,53,48,101,49,100,49,99,100,51,54,97,49,54,97,57,101,50,100,100,102,100],"hint":0},{"address":[30,216,79,171,88,99,31,128,218,6,166,34,143,54,184,66,30,187,180,250,175,206,173,102,57,164,176,15,252,47,53,205],"bytes":[98,49,102,48,56,55,57,49,51,97,99,97,97,98,55,57,101,55,101,48,100,53,98,97,53,57,55,100,98,57,52,53,99,49,55,50,50,52,101,50,99,52,102,53,97,54,54,50,49,100,50,52,49,48,98,50,57,56,101,54,55,99,51,101],"hint":0},{"address":[31,79,69,189,52,134,225,49,212,181,22,86,5,172,133,52,28,129,130,147,174,9,73,105,247,89,245,232,64,98,206,50],"bytes":[95,112,114,105,118,97,116,101,95,49],"hint":0},{"address":[31,154,200,248,142,235,211,158,157,106,132,102,241,4,49,123,230,125,146,56,103,168,4,184,90,103,138,228,125,230,62,178],"bytes":[105,110,116,114,111],"hint":0},{"address":[31,184,39,57,153,23,180,153,35,60,206,143,9,79,92,48,126,218,101,152,216,123,254,249,140,108,21,190,25,129,240,110],"bytes":[95,64],"hint":0},{"address":[31,210,233,2,18,63,101,39,46,50,1,5,73,179,19,110,146,53,72,247,133,214,144,54,16,65,232,133,124,132,158,155],"bytes":[66,105,116,86,101,99],"hint":0},{"address":[32,132,67,238,104,119,15,160,32,122,143,89,66,180,191,75,145,40,179,74,24,19,50,248,91,236,246,230,112,22,95,28],"bytes":[108,101,95,114,101,102,108],"hint":0},{"address":[34,90,184,18,34,65,145,27,73,166,182,29,11,183,159,125,7,128,234,234,162,35,116,83,217,141,147,87,99,167,143,173],"bytes":[101,99,49,55,51,97,100,51,53,98,101,57,100,55,53,99,50,102,49,53,49,48,102,57,53,52,56,49,52,50,52,48,50,55,101,99,48,49,49,56,54,98,99,51,102,48,49,54,97,48,51,102,48,52,54,54,52,101,53,52,55,48,100,54],"hint":0},{"address":[35,51,45,113,18,236,7,38,9,211,196,74,76,40,239,41,224,98,183,141,148,44,99,77,223,83,253,220,95,164,201,50],"bytes":[68,97,116,97],"hint":0},{"address":[35,199,205,177,24,219,119,221,220,59,19,36,161,175,111,122,204,163,98,87,19,145,186,53,187,37,227,96,227,160,224,211],"bytes":[105,100],"hint":0},{"address":[35,211,88,137,229,145,234,108,215,100,102,31,183,200,4,165,0,44,122,205,5,123,3,68,129,197,232,159,127,55,139,59],"bytes":[105,110,114],"hint":0},{"address":[36,68,111,239,199,33,25,62,115,248,163,15,167,224,3,88,66,4,184,202,151,156,141,152,34,173,139,20,245,58,159,75],"bytes":[80,80,114,111,100],"hint":0},{"address":[36,150,150,251,95,149,169,59,14,202,235,210,90,129,144,213,43,201,230,126,167,73,222,237,130,123,230,117,100,255,9,178],"bytes":[104,108,101],"hint":0},{"address":[38,112,171,37,137,28,115,60,15,128,46,133,113,210,51,69,201,103,174,254,17,121,253,152,216,210,220,249,94,115,163,136],"bytes":[99,102,101,99,48,53,100,49,100,55,102,50,53,49,50,102,54,53,55,55,99,50,102,54,49,97,56,52,48,53,50,51,56,48,52,99,51,54,100,52,48,52,51,99,50,53,50,97,98,52,98,97,50,53,48,56,101,100,101,55,53,49,55,49],"hint":0},{"address":[39,187,73,46,16,139,245,233,199,36,23,109,122,231,93,76,237,196,34,254,64,101,2,11,214,20,12,63,202,211,169,231],"bytes":[101],"hint":0},{"address":[40,93,156,144,23,144,222,221,90,253,72,97,119,192,210,220,145,152,53,75,155,96,41,25,77,104,10,124,162,133,99,150],"bytes":[0,0,0,0,1],"hint":0},{"address":[40,162,73,194,228,211,169,43,192,161,110,216,241,181,207,131,202,32,65,94,225,46,80,43,9,102,36,144,43,188,151,189],"bytes":[100,97,116,97],"hint":0},{"address":[40,201,176,81,210,188,0,221,185,45,68,182,15,46,32,42,56,100,173,180,231,141,230,95,110,108,140,70,64,194,21,155],"bytes":[84,114,117,101],"hint":0},{"address":[40,208,17,145,237,226,173,235,39,235,63,236,115,223,194,148,18,116,104,251,234,253,252,109,172,16,179,199,48,32,92,7],"bytes":[100,101,99,105,100,101],"hint":0},{"address":[41,30,220,137,67,105,122,82,62,213,7,221,41,71,42,131,188,115,4,0,61,73,137,188,170,178,66,180,196,185,218,233],"bytes":[71,69],"hint":0},{"address":[41,205,155,167,25,142,157,3,172,142,235,37,34,234,159,125,77,198,77,62,208,210,0,88,64,250,230,134,243,24,200,190],"bytes":[110,98],"hint":0},{"address":[43,25,110,159,28,158,84,113,70,237,236,64,40,52,83,154,76,68,230,202,7,45,111,60,61,147,167,186,164,6,212,161],"bytes":[98,115],"hint":0},{"address":[45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19],"bytes":[0],"hint":0},{"address":[45,80,98,53,0,95,20,254,82,95,120,224,65,116,84,241,221,116,31,55,0,211,93,176,145,221,79,103,110,67,96,70],"bytes":[85,73,110,116,56],"hint":0},{"address":[46,243,224,221,165,41,59,218,150,93,10,220,237,252,125,56,114,68,172,115,106,96,20,167,32,193,214,63,160,237,224,47],"bytes":[8],"hint":0},{"address":[47,229,195,183,69,230,131,92,51,109,50,215,232,167,201,98,181,180,125,11,205,142,157,219,221,192,69,6,72,128,97,102],"bytes":[98,114,101,99,79,110],"hint":0},{"address":[48,3,92,204,142,100,175,218,171,34,126,161,7,167,68,29,133,240,192,67,184,183,52,4,30,137,187,11,15,167,227,202],"bytes":[100,113],"hint":0},{"address":[48,25,50,167,62,72,212,52,138,26,23,235,19,242,119,90,127,244,38,239,248,35,219,43,249,207,88,3,200,152,81,107],"bytes":[97,39],"hint":0},{"address":[50,13,230,127,30,135,20,107,94,59,211,241,211,208,193,4,157,217,185,162,41,115,159,174,239,150,32,40,195,145,134,150],"bytes":[105,110,115,116,72,77,111,100],"hint":0},{"address":[51,82,253,252,47,24,198,176,26,162,9,243,208,15,52,110,97,51,124,174,88,249,61,115,104,235,173,244,229,201,88,63],"bytes":[109,111,100,95,108,116],"hint":0},{"address":[52,132,234,175,50,212,37,187,125,88,35,157,56,202,217,136,89,121,178,225,164,212,242,208,101,108,250,3,246,247,103,53],"bytes":[104,95,52],"hint":0},{"address":[52,212,4,196,23,106,21,160,29,57,81,28,95,176,176,137,213,151,181,118,245,174,162,68,32,5,149,233,49,31,250,197],"bytes":[101,108,105,109],"hint":0},{"address":[52,244,209,183,237,246,56,209,175,123,90,80,215,125,228,161,19,12,60,36,105,212,225,163,211,143,85,176,44,64,61,212],"bytes":[112,117,115,104],"hint":0},{"address":[53,214,110,100,203,171,164,153,85,229,48,233,189,211,168,174,45,106,141,63,88,193,136,139,9,172,91,83,46,154,210,204],"bytes":[108,101,95,115,117,99,99,95,111,102,95,108,101],"hint":0},{"address":[53,241,234,0,43,251,0,193,37,136,78,101,15,134,64,70,182,135,224,164,138,110,220,26,89,28,69,159,140,52,29,165],"bytes":[104,101,97,100],"hint":0},{"address":[54,37,138,194,4,92,179,84,97,253,20,117,195,108,157,0,147,116,214,223,171,40,83,92,141,157,253,154,226,99,83,173],"bytes":[104,65,100,100],"hint":0},{"address":[54,51,92,168,44,83,55,144,243,6,205,218,100,24,228,61,56,185,120,55,197,35,103,9,169,138,138,177,74,126,195,197],"bytes":[72,65,100,100],"hint":0},{"address":[54,80,231,47,167,230,81,170,79,157,30,33,88,135,197,217,5,95,135,44,134,16,122,85,200,130,214,176,131,140,78,44],"bytes":[99,111,110,99,97,116],"hint":0},{"address":[54,200,104,77,5,180,173,166,21,175,54,86,112,8,152,157,64,89,200,255,86,179,14,120,218,40,107,165,11,149,241,120],"bytes":[117,116,102,56,69,110,99,111,100,101,67,104,97,114],"hint":0},{"address":[55,14,156,141,136,160,129,119,200,149,197,179,242,55,47,100,204,20,108,167,28,107,70,225,170,115,133,200,105,208,123,58],"bytes":[95,105,110,116,101,114,110,97,108],"hint":0},{"address":[56,185,244,228,199,23,106,10,198,168,204,2,51,71,162,123,146,232,108,129,147,212,218,132,171,214,34,75,235,175,138,206],"bytes":[101,48,54,51,101,56,48,99,56,55,97,98,97,48,101,101,97,50,100,101,53,102,99,56,100,102,55,54,56,57,97,50,100,52,54,57,48,100,101,50,50,49,97,50,99,50,102,57,51,56,102,55,99,51,100,51,48,56,98,101,53,102,102,49],"hint":0},{"address":[57,147,230,36,84,44,7,139,197,214,101,210,165,203,140,140,250,123,102,186,63,142,136,148,143,19,40,183,185,210,87,245],"bytes":[98,56,50,55,49,52,98,51,55,55,49,101,101,98,57,51,99,53,102,49,56,55,55,49,101,51,56,101,99,99,54,100,50,51,101,102,53,48,54,53,57,100,48,98,99,52,52,99,101,97,48,99,101,56,100,55,51,49,48,53,53,53,102,97],"hint":0},{"address":[58,3,204,193,45,117,68,208,41,238,11,13,169,250,180,215,22,4,43,226,179,34,182,188,85,49,221,39,150,98,220,156],"bytes":[97,100,100],"hint":0},{"address":[58,231,216,5,246,120,154,100,2,172,183,10,212,9,106,133,165,107,246,128,78,175,37,192,73,58,198,151,84,141,48,181],"bytes":[120],"hint":0},{"address":[59,182,69,34,57,91,37,157,93,27,104,173,99,139,119,231,170,222,35,36,104,210,203,60,153,40,235,25,241,141,11,251],"bytes":[0,0,4],"hint":0},{"address":[61,76,80,136,7,226,249,25,134,192,231,85,168,82,92,27,22,229,42,220,82,240,70,16,6,28,99,172,168,108,149,89],"bytes":[102,108,97,116,77,97,112],"hint":0},{"address":[61,159,49,69,228,101,168,188,2,180,69,73,201,70,187,118,23,145,42,36,137,92,199,211,5,100,125,216,28,136,61,11],"bytes":[206,177],"hint":0},{"address":[62,95,96,58,97,145,179,94,198,61,134,0,104,229,218,39,118,59,69,172,217,119,164,168,251,147,2,65,149,165,145,240],"bytes":[115,117,99,99,95,115,117,98,95,115,117,99,99,95,101,113,95,115,117,98],"hint":0},{"address":[64,31,24,173,12,202,56,85,144,134,195,111,158,2,149,241,202,58,112,35,229,240,149,174,239,105,23,122,155,143,16,206],"bytes":[102,97,108,115,101],"hint":0},{"address":[65,114,159,144,152,144,194,212,229,83,142,252,42,26,76,122,91,98,142,126,225,60,173,238,170,3,31,239,1,235,54,234],"bytes":[104,226,130,130],"hint":0},{"address":[65,165,54,218,206,55,252,190,223,68,32,56,27,67,0,31,131,178,179,122,49,123,52,206,36,123,121,115,88,212,207,166],"bytes":[122,101,114,111,95,97,100,100],"hint":0},{"address":[70,132,41,85,106,100,44,121,228,245,153,11,54,191,220,218,157,193,234,118,69,64,185,224,213,165,214,251,225,40,177,81],"bytes":[105,115,76,116],"hint":0},{"address":[71,40,56,78,152,56,32,108,146,44,98,108,171,138,200,114,11,159,201,10,185,191,233,252,22,233,113,154,26,23,117,139],"bytes":[114,101,115,111,108,118,101,95,114,105,103,104,116],"hint":0},{"address":[72,252,114,31,187,193,114,224,146,95,162,122,241,103,29,226,37,186,146,113,52,128,41,152,177,10,21,104,161,136,101,43],"bytes":[1],"hint":0},{"address":[73,200,74,112,1,183,247,211,70,156,44,16,63,179,58,42,115,67,13,158,34,244,197,9,197,250,166,229,177,243,10,46],"bytes":[109,111,100,67,111,114,101,95,108,116],"hint":0},{"address":[74,30,80,102,129,98,158,14,98,7,193,116,67,224,127,22,131,64,139,6,42,75,52,168,120,129,118,211,234,222,165,47],"bytes":[111,102,78,97,116],"hint":0},{"address":[74,123,215,121,137,241,147,89,210,103,222,101,96,24,109,34,48,164,136,73,125,244,242,88,115,141,156,153,3,131,214,52],"bytes":[105,110,115,116],"hint":0},{"address":[74,126,165,218,200,189,215,198,81,246,95,216,111,22,226,17,153,178,122,186,92,97,85,133,107,246,243,80,211,163,49,165],"bytes":[105,115,86,97,108,105,100,85,84,70,56],"hint":0},{"address":[75,165,150,177,56,25,158,185,138,206,172,119,115,146,106,237,79,24,62,158,20,7,26,186,225,17,223,229,143,192,200,72],"bytes":[100,105,118,95,114,101,99,95,102,117,101,108,95,108,101,109,109,97],"hint":0},{"address":[75,167,120,25,73,145,243,56,185,212,133,72,94,224,170,230,25,22,139,113,29,116,128,112,118,11,17,248,160,117,239,80],"bytes":[115,117,99,99],"hint":0},{"address":[75,174,236,73,192,171,209,15,18,189,34,120,140,239,118,16,0,41,3,121,247,73,19,129,131,90,192,71,35,230,27,32],"bytes":[95,104,121,103,67,116,120],"hint":0},{"address":[75,229,207,46,185,226,207,2,252,82,215,23,216,235,186,50,75,99,37,108,18,90,237,15,213,136,66,62,64,29,69,72],"bytes":[110,111,67,111,110,102,117,115,105,111,110],"hint":0},{"address":[78,44,210,101,101,104,193,45,206,78,46,66,92,57,183,13,219,227,215,195,59,199,184,1,151,192,141,178,0,90,208,195],"bytes":[110,100,114,101,99],"hint":0},{"address":[78,171,157,26,64,195,41,51,38,64,4,93,190,218,27,218,157,236,127,85,52,135,112,224,17,121,25,216,218,217,141,125],"bytes":[83,117,98],"hint":0},{"address":[79,44,254,127,37,183,92,83,190,85,177,89,98,227,63,72,198,113,95,217,221,108,126,182,251,106,141,100,31,97,214,208],"bytes":[122,101,114,111],"hint":0},{"address":[79,124,51,123,42,197,234,90,124,196,90,62,158,61,77,142,166,64,254,60,39,37,70,81,168,101,47,230,87,224,214,61],"bytes":[114,101,102,108],"hint":0},{"address":[79,240,65,94,201,138,22,102,22,105,222,169,164,0,252,233,3,116,90,246,145,199,85,206,187,50,124,68,91,117,65,179],"bytes":[111,102,95,100,101,99,105,100,101,95,101,113,95,116,114,117,101],"hint":0},{"address":[80,108,212,44,123,171,133,18,137,71,241,204,52,106,84,206,228,186,153,51,201,54,189,171,58,93,24,185,155,249,15,2],"bytes":[109,97,116,99,104,95,49,95,49,48],"hint":0},{"address":[82,255,28,46,230,97,7,50,187,70,68,89,64,172,129,140,215,120,114,106,177,14,42,173,88,30,48,43,72,234,255,21],"bytes":[54,99,102,102,57,48,54,100,98,102,97,50,98,100,97,102,101,48,101,99,50,98,102,48,49,51,49,101,56,48,48,53,50,99,99,101,55,101,50,99,54,53,51,98,56,49,52,57,53,102,101,53,49,57,55,101,53,51,97,99,54,55,97,98],"hint":0},{"address":[83,56,62,169,5,10,19,144,11,96,234,203,216,180,49,195,171,81,111,227,213,161,218,105,0,176,135,21,109,136,219,32],"bytes":[108,116,95,111,102,95,110,111,116,95,108,101],"hint":0},{"address":[83,157,65,35,69,181,57,154,184,69,61,55,129,9,213,178,112,130,20,99,253,76,143,131,223,190,102,2,122,166,8,128],"bytes":[72,77,111,100],"hint":0},{"address":[84,34,202,66,150,253,44,134,153,99,93,164,53,9,212,29,158,178,50,54,154,227,192,126,7,112,218,215,108,72,9,154],"bytes":[255,223],"hint":0},{"address":[84,189,80,219,85,231,97,165,28,134,114,117,155,179,31,39,229,72,74,179,236,254,211,154,6,193,41,18,171,154,163,159],"bytes":[0,216],"hint":0},{"address":[85,181,106,165,228,35,245,75,217,211,158,1,31,38,68,199,220,231,36,67,228,104,190,119,191,43,61,18,30,122,4,33],"bytes":[114,102,108],"hint":0},{"address":[86,29,183,134,35,11,227,125,171,62,125,50,93,123,78,84,144,20,84,34,203,112,5,129,198,210,68,228,198,145,82,57],"bytes":[117,116,102,56,69,110,99,111,100,101],"hint":0},{"address":[86,254,80,67,101,18,97,19,28,157,247,222,211,77,127,18,42,79,186,188,90,245,124,107,6,201,46,213,15,246,230,180],"bytes":[66,97,115,105,99],"hint":0},{"address":[87,190,78,200,25,225,74,168,198,9,120,245,148,94,232,142,216,129,184,17,196,156,244,79,56,26,90,198,116,154,59,79],"bytes":[105,110,108],"hint":0},{"address":[87,230,130,207,91,238,188,206,53,211,159,235,131,156,71,57,168,250,186,204,195,89,10,69,237,27,128,244,26,193,47,220],"bytes":[66,121,116,101,65,114,114,97,121],"hint":0},{"address":[87,249,25,215,109,83,175,253,88,204,199,35,145,114,1,229,162,251,66,228,129,143,154,201,71,47,147,55,168,198,8,187],"bytes":[116,104,105,115],"hint":0},{"address":[89,100,82,27,193,2,237,81,107,191,216,248,162,77,66,126,52,76,250,157,123,53,150,96,26,29,237,126,230,145,196,56],"bytes":[105,110,115,116,68,101,99,105,100,97,98,108,101,79,114],"hint":0},{"address":[90,67,156,79,61,19,211,108,78,159,159,172,216,208,219,172,79,113,8,70,125,53,143,132,8,62,99,187,141,33,119,225],"bytes":[108,116,95,115,117,99,99,95,115,101,108,102],"hint":0},{"address":[90,188,216,190,146,14,179,9,11,183,117,196,200,7,133,8,14,80,252,79,40,5,95,205,20,145,25,193,46,232,80,97],"bytes":[111,102,76,105,115,116],"hint":0},{"address":[91,58,123,142,68,237,234,219,142,149,77,33,70,96,232,117,205,111,161,242,26,163,137,78,40,21,248,155,123,94,48,252],"bytes":[100,101,99,69,113],"hint":0},{"address":[91,161,218,228,25,47,68,43,158,146,90,74,184,242,129,214,66,21,81,242,205,81,232,97,242,16,122,127,33,5,36,113],"bytes":[118,97,108,105,100],"hint":0},{"address":[92,188,176,206,232,36,185,24,102,205,103,245,122,102,67,221,203,124,212,56,32,41,3,144,67,81,57,83,199,89,36,107],"bytes":[107],"hint":0},{"address":[92,224,78,178,205,117,171,36,41,69,162,233,178,33,60,113,53,146,27,108,229,138,198,218,191,245,48,17,32,25,195,116],"bytes":[105,110,115,116,78,97,116,80,111,119,78,97,116],"hint":0},{"address":[93,215,80,235,102,208,28,241,54,227,138,169,36,74,138,251,156,111,213,10,132,171,146,160,71,76,28,158,122,120,217,254],"bytes":[99,97,115,116],"hint":0},{"address":[94,122,149,41,117,249,53,247,194,20,174,1,179,36,35,85,199,160,207,219,188,124,235,140,146,12,134,204,89,67,69,12],"bytes":[51,50,102,50,97,99,57,51,48,101,55,52,53,52,97,57,50,56,52,52,50,102,53,56,54,57,101,97,56,51,57,53,48,56,54,55,50,55,99,98,100,99,51,101,57,100,101,99,100,53,52,49,48,51,53,52,57,97,52,100,100,97,54,52],"hint":0},{"address":[97,37,108,246,123,60,166,180,129,241,202,251,223,246,55,8,193,117,209,208,22,91,58,230,96,4,17,8,102,131,76,90],"bytes":[121,115],"hint":0},{"address":[97,134,195,3,159,150,2,157,141,28,18,95,23,131,65,182,36,34,109,19,235,23,132,142,248,106,13,182,187,115,132,237],"bytes":[105,110,115,116,68,101,99,105,100,97,98,108,101,65,110,100],"hint":0},{"address":[98,22,183,31,47,0,198,6,140,44,139,168,40,152,253,175,78,112,235,141,21,17,155,39,224,226,76,1,67,213,210,191],"bytes":[117,110,105,116],"hint":0},{"address":[98,26,221,171,80,186,68,235,141,225,82,157,105,154,20,136,55,18,193,159,132,138,177,223,168,95,224,223,253,90,151,4],"bytes":[110,111,67,111,110,102,117,115,105,111,110,84,121,112,101],"hint":0},{"address":[98,63,214,96,11,159,230,100,88,32,162,170,89,197,166,34,42,81,141,174,82,115,150,183,222,125,59,140,4,249,158,234],"bytes":[110,111,67,111,110,102,117,115,105,111,110,95,111,102,95,78,97,116],"hint":0},{"address":[100,151,245,245,93,91,119,156,148,224,216,211,9,204,46,191,117,126,197,72,96,29,74,152,243,134,234,185,151,199,85,147],"bytes":[78,97,116],"hint":0},{"address":[100,186,135,125,65,58,41,19,171,75,209,141,59,193,37,81,180,185,78,178,138,245,59,85,12,242,226,114,21,235,100,201],"bytes":[56,49,57,98,50,48,53,100,56,50,55,101,100,56,48,49,97,101,50,99,49,48,100,102,55,52,49,97,50,52,52,49,102,97,51,97,49,99,57,102,51,49,53,101,51,52,99,101,55,102,49,98,99,56,102,51,97,50,54,99,100,99,57,101],"hint":0},{"address":[103,85,215,89,189,15,175,110,179,158,217,24,147,234,106,201,148,165,251,72,76,179,180,234,75,48,161,207,177,23,64,91],"bytes":[109,97,116,99,104,95,49,95,51],"hint":0},{"address":[103,118,32,175,170,149,149,62,225,65,234,14,114,50,116,49,48,159,122,38,233,64,231,61,82,16,99,127,192,210,220,147],"bytes":[104,80,111,119],"hint":0},{"address":[104,72,252,229,237,179,88,213,58,188,95,187,111,80,157,111,236,195,194,67,39,174,155,201,204,196,127,135,59,156,180,82],"bytes":[108,116,95,105,114,114,101,102,108],"hint":0},{"address":[104,109,93,80,175,237,146,137,185,175,22,254,68,137,151,51,252,151,98,7,219,27,246,28,69,51,72,186,242,223,173,176],"bytes":[103,101],"hint":0},{"address":[104,178,41,114,248,132,137,210,201,168,21,70,70,147,203,16,38,235,247,178,203,2,117,136,103,167,155,212,140,165,3,217],"bytes":[104,77,117,108],"hint":0},{"address":[104,192,4,239,221,73,144,202,138,249,43,251,168,208,136,73,88,77,203,160,123,181,98,31,169,69,106,139,132,65,152,63],"bytes":[224],"hint":0},{"address":[105,37,158,210,110,70,79,130,249,218,155,162,102,204,97,223,235,180,193,217,16,143,206,129,83,116,216,229,42,235,34,58],"bytes":[104,49],"hint":0},{"address":[107,223,63,229,80,82,131,29,34,47,198,184,43,43,160,63,50,179,89,148,16,250,253,49,118,66,226,25,37,195,143,22],"bytes":[101,109,112,116,121],"hint":0},{"address":[108,172,30,106,189,184,2,33,183,219,153,120,173,45,199,87,176,112,229,238,180,26,240,42,3,55,138,177,170,247,6,85],"bytes":[115,117,99,99,95,108,101,95,115,117,99,99],"hint":0},{"address":[110,53,131,95,222,162,147,8,89,255,5,233,47,209,167,196,160,107,153,28,213,66,141,83,248,197,4,202,3,143,196,130],"bytes":[116,111,66,105,116,86,101,99],"hint":0},{"address":[110,60,70,202,54,105,58,252,23,26,77,52,245,237,27,115,134,209,26,51,229,152,102,187,216,180,131,6,190,136,89,155],"bytes":[104,77,111,100],"hint":0},{"address":[110,89,51,163,248,172,202,57,162,113,70,238,6,44,48,187,244,150,46,41,209,237,140,228,73,42,79,153,21,173,18,41],"bytes":[50,50,99,57,100,101,50,98,57,51,102,101,52,102,52,54,48,99,57,102,55,51,48,51,51,97,53,100,51,55,52,98,57,51,101,97,102,51,56,51,57,57,48,55,56,97,51,100,99,55,101,57,49,49,51,98,98,52,48,98,99,57,55,102],"hint":0},{"address":[110,184,226,131,99,168,69,168,44,254,248,204,227,10,127,159,17,127,68,134,183,249,95,117,176,28,144,118,154,92,28,206],"bytes":[100,105,118],"hint":0},{"address":[110,246,63,44,146,21,213,192,203,40,208,40,74,168,248,101,181,29,232,58,28,183,241,14,135,67,5,26,161,48,14,5],"bytes":[109,111,116,105,118,101],"hint":0},{"address":[113,252,140,17,21,229,196,90,120,2,69,100,82,125,185,161,178,23,169,76,102,163,248,108,206,230,129,204,10,101,242,76],"bytes":[85,110,105,116],"hint":0},{"address":[114,21,241,190,102,72,193,168,223,111,157,22,110,159,198,164,123,240,118,186,141,53,158,83,156,34,59,200,238,239,243,134],"bytes":[102,117,101,108],"hint":0},{"address":[115,242,145,105,62,49,254,119,190,123,251,120,235,201,4,43,46,44,67,124,135,236,160,193,34,224,232,160,187,251,230,37],"bytes":[112],"hint":0},{"address":[116,57,196,27,236,18,155,157,66,120,10,35,160,217,229,170,202,66,114,23,185,140,244,70,51,226,223,176,166,216,149,229],"bytes":[76,69],"hint":0},{"address":[116,76,175,113,28,128,161,232,191,172,41,114,233,177,44,33,110,240,62,161,100,137,231,137,129,164,21,198,235,17,55,58],"bytes":[114,105,103,104,116],"hint":0},{"address":[117,60,206,154,61,181,22,42,17,112,159,235,74,182,25,89,181,103,75,80,58,204,79,98,254,96,80,130,44,48,120,107],"bytes":[104,98],"hint":0},{"address":[118,176,200,83,156,236,172,149,2,37,3,190,131,217,9,159,52,7,8,86,96,227,111,102,24,10,236,254,117,13,54,166],"bytes":[77,111,100],"hint":0},{"address":[119,99,55,85,191,144,206,180,55,40,126,137,47,124,224,57,94,194,4,99,178,140,147,92,214,138,1,72,198,24,70,132],"bytes":[105,110,115,116,80,111,119,78,97,116],"hint":0},{"address":[119,194,113,83,157,255,230,126,165,232,117,153,106,183,99,118,209,53,157,109,49,188,22,103,203,97,166,76,145,100,209,41],"bytes":[116,111,70,105,110],"hint":0},{"address":[126,95,147,179,245,208,97,254,126,174,63,75,35,102,197,144,82,97,47,193,173,22,131,91,22,116,28,185,40,43,60,15],"bytes":[108,116,95,115,117,99,99,95,111,102,95,108,101],"hint":0},{"address":[127,46,47,0,129,175,124,217,116,171,202,253,115,27,241,133,141,77,107,170,2,10,9,122,218,78,64,93,5,17,135,33],"bytes":[108,116,95,97,100,100,95,111,110,101],"hint":0},{"address":[127,96,87,232,80,24,37,51,114,189,188,157,80,227,85,224,114,194,30,230,179,66,230,2,89,154,28,119,78,16,113,43],"bytes":[112,114,101,100,95,108,101,95,112,114,101,100],"hint":0},{"address":[129,188,221,227,25,59,201,183,179,31,133,59,121,246,113,206,167,168,37,106,18,52,104,217,238,204,183,195,4,144,73,155],"bytes":[51,97,57,56,50,49,52,50,99,56,52,101,97,97,54,101,52,50,54,48,101,54,54,55,101,50,97,57,49,55,51,51,49,51,51,99,51,53,52,100,101,101,102,53,55,98,101,51,99,57,98,54,54,49,54,98,57,101,56,48,48,50,49,57],"hint":0},{"address":[131,205,51,210,148,76,241,164,239,130,137,146,74,44,7,119,110,172,164,16,85,34,132,206,234,18,162,68,165,248,131,237],"bytes":[49,53,53,50,98,100,53,52,52,53,97,54,51,57,102,49,53,97,102,100,101,55,49,57,97,100,52,57,53,101,52,57,50,56,49,98,99,54,101,101,99,51,54,57,101,102,48,101,54,51,56,55,99,98,98,49,98,101,54,101,101,52,53,50],"hint":0},{"address":[131,217,218,176,96,17,71,145,99,199,196,213,250,115,95,145,27,172,134,114,159,86,170,161,21,183,238,210,235,102,224,34],"bytes":[109],"hint":0},{"address":[131,228,190,30,171,75,156,207,102,188,31,187,137,225,234,30,90,12,181,32,60,107,70,198,114,98,195,192,8,41,221,183],"bytes":[80,111,119],"hint":0},{"address":[135,229,150,243,75,221,75,169,129,42,82,34,68,156,62,217,104,239,51,19,198,220,67,22,221,78,79,206,162,126,85,242],"bytes":[108,101,102,116],"hint":0},{"address":[135,245,83,3,203,218,62,33,143,60,50,9,206,23,6,137,179,39,216,194,3,220,212,142,15,210,100,106,68,176,183,213],"bytes":[117,95,49],"hint":0},{"address":[136,93,49,88,53,79,243,20,49,242,69,32,92,138,235,38,83,208,125,77,121,65,255,51,204,90,228,243,128,186,133,38],"bytes":[117,95,50],"hint":0},{"address":[136,232,211,126,85,198,138,161,136,242,103,4,37,127,73,125,161,198,123,37,242,35,89,49,67,219,186,55,248,162,185,163],"bytes":[109,97,116,99,104,95,49,95,53],"hint":0},{"address":[137,50,135,60,236,9,25,63,70,5,145,25,146,64,86,165,131,133,144,188,135,230,81,111,189,188,3,224,204,144,19,162],"bytes":[110,95,101,113],"hint":0},{"address":[137,52,167,41,137,217,110,231,236,148,155,59,109,43,89,172,251,72,130,251,216,132,222,110,43,108,130,26,92,141,139,87],"bytes":[97,226,130,129],"hint":0},{"address":[137,114,72,157,2,117,45,100,187,178,155,179,55,62,48,51,139,12,189,194,113,83,3,187,219,243,64,232,222,235,147,183],"bytes":[111,102,78,97,116,76,84],"hint":0},{"address":[139,29,209,70,213,66,116,215,94,170,204,187,206,43,113,81,241,180,67,42,134,234,204,213,188,107,85,5,214,206,203,188],"bytes":[97,115],"hint":0},{"address":[140,37,41,105,204,0,20,42,232,98,142,195,95,183,194,43,15,150,193,63,192,24,162,28,12,84,0,188,252,73,17,136],"bytes":[101,113,95,111,102,95,104,101,113],"hint":0},{"address":[140,136,56,126,131,64,13,163,206,76,57,44,36,111,139,167,196,84,48,27,176,77,170,151,254,12,0,133,65,49,74,18],"bytes":[105,110,115,116,83,117,98,78,97,116],"hint":0},{"address":[144,28,195,225,161,153,251,147,106,224,224,109,48,112,238,106,55,107,9,73,173,227,18,93,178,207,219,87,245,179,127,66],"bytes":[109,97,112],"hint":0},{"address":[144,196,13,194,105,178,100,4,231,194,110,254,157,188,221,216,162,184,90,96,40,228,120,86,13,148,103,134,217,61,105,220],"bytes":[97,53,51,97,48,51,51,50,98,51,51,97,48,53,97,55,97,101,54,100,57,52,57,97,100,53,97,100,101,48,51,98,100,53,49,98,102,53,97,97,97,52,99,54,48,48,99,51,56,50,53,53,101,100,98,97,57,99,98,51,49,101,50,97],"hint":0},{"address":[145,33,14,95,206,69,66,177,143,53,42,160,42,146,136,180,77,226,98,211,39,87,223,53,144,6,19,187,188,24,117,27],"bytes":[104,39],"hint":0},{"address":[145,71,75,232,138,8,250,20,183,178,248,245,35,121,43,208,161,20,78,252,73,22,166,200,230,26,201,86,155,93,28,34],"bytes":[52,99,54,50,99,57,55,54,53,57,56,98,102,102,98,52,50,98,55,99,99,57,100,50,55,102,49,52,97,50,57,56,54,101,102,50,56,56,50,57,49,51,50,52,56,56,54,48,100,50,49,98,98,101,49,98,55,56,57,49,100,56,48,102],"hint":0},{"address":[146,54,131,214,5,184,4,11,102,21,90,78,112,33,35,67,217,236,11,154,248,112,237,16,132,82,7,167,93,55,171,47],"bytes":[110,111,116,95,108,101,95,111,102,95,110,111,116,95,98,108,101,95,101,113,95,116,114,117,101],"hint":0},{"address":[146,120,103,213,178,51,162,211,196,118,225,165,117,43,126,230,68,83,6,135,90,187,180,221,222,40,144,46,214,220,35,41],"bytes":[105,115,86,97,108,105,100,67,104,97,114,95,85,73,110,116,51,50],"hint":0},{"address":[147,178,255,215,225,9,77,121,163,67,41,114,250,98,76,158,192,76,36,168,155,8,33,186,170,67,117,149,97,209,239,125],"bytes":[116,97,105,108],"hint":0},{"address":[147,196,193,156,172,209,189,145,59,143,239,63,84,73,193,210,6,8,220,204,105,185,3,229,89,138,99,79,35,187,251,121],"bytes":[100,101,99,76,101],"hint":0},{"address":[148,5,18,27,52,16,101,235,68,212,36,72,33,194,166,48,89,110,96,245,98,158,206,131,94,119,191,166,253,107,215,194],"bytes":[100,101,99,76,116],"hint":0},{"address":[148,6,6,172,29,225,110,152,177,231,182,249,124,232,203,4,89,71,39,124,229,9,126,153,185,206,174,108,153,213,50,246],"bytes":[112,111,119],"hint":0},{"address":[149,237,27,236,238,77,200,233,203,93,3,110,176,92,241,121,98,245,217,36,132,116,104,141,69,19,127,104,60,183,42,24],"bytes":[83,116,114,105,110,103],"hint":0},{"address":[151,68,217,220,99,137,230,121,134,175,165,99,241,159,19,59,40,56,83,25,235,186,34,102,173,253,151,217,198,83,100,35],"bytes":[64],"hint":0},{"address":[151,102,79,61,152,155,213,215,162,238,29,112,115,132,74,27,107,156,7,178,134,152,176,237,82,148,148,53,82,85,129,14],"bytes":[98,108,101,95,115,101,108,102,95,101,113,95,116,114,117,101],"hint":0},{"address":[152,227,20,40,154,107,112,242,123,224,218,161,36,247,126,48,157,38,5,238,35,90,115,151,230,171,8,235,194,126,154,205],"bytes":[99,116,111,114,73,100,120],"hint":0},{"address":[153,87,195,165,39,152,48,204,213,232,251,162,212,244,4,145,159,28,199,191,1,8,78,169,67,238,22,222,195,149,230,54],"bytes":[105,110,115,116,72,68,105,118],"hint":0},{"address":[154,64,185,48,225,91,88,123,174,184,133,93,73,118,1,48,14,123,41,67,227,244,90,123,253,156,43,224,163,144,38,173],"bytes":[99,111,110,115],"hint":0},{"address":[154,115,49,92,150,73,22,190,195,78,95,185,161,131,118,20,28,21,120,172,253,229,254,212,144,217,205,7,169,212,5,131],"bytes":[111,102,78,97,116,65,117,120],"hint":0},{"address":[154,176,90,19,177,19,154,94,180,49,227,82,123,39,41,227,121,216,29,63,122,36,62,134,7,238,219,86,17,61,123,137],"bytes":[109,97,116,99,104,95,49],"hint":0},{"address":[154,179,136,190,220,67,234,244,65,80,16,125,23,173,9,15,107,28,52,97,15,87,64,119,141,219,149,217,240,101,118,238],"bytes":[102],"hint":0},{"address":[156,49,128,108,184,133,13,86,27,174,36,160,106,155,107,167,239,50,30,82,57,224,174,65,252,136,228,87,146,44,189,43],"bytes":[104,226,130,129],"hint":0},{"address":[157,38,114,194,61,216,93,122,5,89,119,212,145,45,189,8,186,132,157,254,169,172,120,156,10,154,95,222,180,167,224,252],"bytes":[104,50],"hint":0},{"address":[157,100,192,32,160,172,79,253,164,79,64,112,43,61,134,126,172,73,73,198,102,3,227,0,148,101,128,253,175,138,247,53],"bytes":[80],"hint":0},{"address":[157,192,167,136,237,21,168,232,99,200,125,121,245,103,226,29,15,25,58,27,250,1,85,4,51,115,151,153,97,216,203,20],"bytes":[66,111,111,108],"hint":0},{"address":[158,178,200,229,7,246,118,110,183,43,166,8,134,179,190,72,236,155,248,22,10,160,57,96,245,175,115,152,255,40,105,240],"bytes":[51,98,100,100,56,48,100,99,57,99,57,49,54,55,48,97,52,57,52,53,51,57,57,50,56,51,99,56,102,97,57,48,55,52,54,102,55,53,100,101,54,53,100,97,97,98,100,55,51,97,52,48,98,101,100,52,100,52,98,49,97,51,56,56],"hint":0},{"address":[159,5,64,226,107,87,211,103,9,214,5,172,227,223,173,121,83,230,136,151,47,48,142,115,54,88,66,46,0,215,252,55],"bytes":[72,83,117,98],"hint":0},{"address":[159,53,28,234,36,128,130,114,253,80,228,19,181,230,165,195,227,135,14,65,68,239,22,191,248,9,135,56,182,161,85,128],"bytes":[98,108,101,95,115,117,99,99,95,101,113,95,116,114,117,101],"hint":0},{"address":[159,120,158,99,172,67,227,175,170,138,137,35,172,59,216,226,45,101,251,160,214,53,243,177,230,43,40,40,156,111,134,89],"bytes":[110,111,116,95,108,116,95,122,101,114,111],"hint":0},{"address":[159,157,5,19,75,153,99,40,142,85,219,145,129,253,105,12,55,98,173,166,35,214,120,144,70,137,221,39,2,160,225,241],"bytes":[109,97,116,99,104,95,49,95,55],"hint":0},{"address":[159,230,62,107,210,240,19,51,225,147,102,254,4,16,236,41,47,31,13,216,158,182,161,214,162,76,225,60,0,245,91,194],"bytes":[73,110,116,101,114,110,97,108],"hint":0},{"address":[160,88,52,110,236,23,107,167,178,164,156,157,34,127,253,49,191,10,110,237,229,103,66,208,35,130,14,236,61,216,136,3],"bytes":[116,111,76,105,115,116],"hint":0},{"address":[160,131,15,115,184,224,50,99,223,59,59,196,211,173,46,200,161,36,80,113,121,77,200,151,102,181,91,228,139,167,15,220],"bytes":[116,111,78,97,116],"hint":0},{"address":[161,48,79,106,6,190,181,127,29,74,131,232,78,73,172,24,203,55,192,193,120,65,165,219,226,2,54,250,78,157,160,117],"bytes":[49,97,55,51,48,99,50,99,48,101,52,52,54,50,54,52,97,97,50,56,49,99,50,98,52,99,57,54,51,49,51,57,57,56,57,100,54,55,101,57,55,55,97,101,97,100,101,56,98,56,48,56,50,54,100,102,100,97,101,49,97,55,100,102],"hint":0},{"address":[161,189,114,59,165,59,24,183,239,138,177,169,138,128,18,110,229,128,159,254,25,213,7,4,74,180,137,75,101,254,45,22],"bytes":[105,110,115,116,72,80,111,119],"hint":0},{"address":[161,230,124,48,240,104,78,237,181,240,243,225,26,181,185,198,206,105,151,134,5,126,28,218,110,5,216,151,222,239,86,232],"bytes":[122,101,114,111,95,108,116,95,115,117,99,99],"hint":0},{"address":[162,135,107,155,79,179,139,215,170,183,236,119,123,174,43,180,229,134,102,252,175,183,254,61,126,246,7,74,164,156,66,14],"bytes":[99,48,102,57,57,102,51,99,99,56,52,54,97,99,101,97,98,100,98,97,50,101,98,51,101,49,57,48,55,50,48,48,51,55,50,101,55,97,52,98,53,50,97,52,97,55,51,51,100,102,55,102,48,100,51,48,98,56,52,98,51,57,55,56],"hint":0},{"address":[162,138,244,165,219,196,195,6,92,28,59,169,13,220,77,150,70,211,155,67,173,247,201,129,8,127,33,239,107,73,152,203],"bytes":[104,68,105,118],"hint":0},{"address":[163,12,6,84,108,93,123,111,241,221,92,60,39,159,254,1,210,240,128,114,89,16,23,152,7,162,5,68,81,24,57,223],"bytes":[105,110,115,116,76,84,78,97,116],"hint":0},{"address":[163,64,239,65,40,150,149,85,182,230,121,6,95,88,48,231,99,93,51,91,4,183,31,162,206,197,125,46,92,175,58,111],"bytes":[108,116,95,116,114,97,110,115],"hint":0},{"address":[163,126,215,103,206,214,26,254,41,240,130,170,146,34,90,109,149,189,72,118,154,196,31,100,14,209,235,243,131,201,0,60],"bytes":[98,101,108,111,119],"hint":0},{"address":[163,171,119,31,10,10,54,193,170,233,40,217,186,240,182,42,206,12,121,24,35,200,244,186,80,238,92,24,39,8,110,168],"bytes":[104,121],"hint":0},{"address":[163,217,5,63,173,61,81,220,203,242,3,149,163,176,71,9,54,86,131,53,130,65,42,177,174,43,152,73,152,174,28,226],"bytes":[115,117,99,99,95,97,100,100],"hint":0},{"address":[164,37,125,4,177,15,129,218,181,92,25,207,231,133,6,210,224,218,253,30,130,205,48,23,226,204,252,7,36,71,22,73],"bytes":[0,0,17],"hint":0},{"address":[165,240,39,166,15,84,128,25,45,115,2,198,115,139,144,3,181,34,139,105,97,156,184,157,43,87,236,188,49,45,104,92],"bytes":[105,115,84,114,117,101],"hint":0},{"address":[166,15,43,41,137,113,173,230,118,126,225,210,97,41,98,197,79,13,163,56,55,105,225,143,57,244,245,55,58,62,6,136],"bytes":[57,101,56,100,49,101,56,99,50,50,97,56,57,98,100,48,49,57,57,48,100,48,57,49,101,48,97,55,57,100,101,99,99,52,98,51,98,55,100,55,54,56,102,52,50,49,99,49,99,56,97,101,57,102,99,98,49,50,48,55,57,98,54,49],"hint":0},{"address":[166,48,74,198,51,146,16,173,74,97,164,167,15,197,87,254,63,90,208,156,227,206,135,224,109,252,172,245,232,118,103,163],"bytes":[108,116,95,111,114,95,103,101],"hint":0},{"address":[166,85,207,242,253,212,240,83,170,185,28,182,165,91,51,129,127,153,209,25,200,45,215,25,105,45,180,148,220,169,41,248],"bytes":[95,112,114,111,111,102,95,49],"hint":0},{"address":[167,78,11,20,51,181,75,122,51,191,229,142,96,9,50,57,203,207,202,140,75,235,203,241,27,112,105,112,184,218,47,187],"bytes":[110],"hint":0},{"address":[167,124,144,97,39,133,81,131,105,139,173,33,141,106,190,45,129,116,36,181,75,7,154,116,183,242,42,193,175,55,148,117],"bytes":[255,255],"hint":0},{"address":[169,40,206,211,42,202,187,131,220,113,251,44,34,160,134,217,46,226,101,20,231,225,171,74,75,248,102,46,231,196,84,40],"bytes":[98,56,99,54,51,101,57,52,53,102,53,97,97,50,97,98,99,56,52,52,52,98,54,49,102,54,100,99,54,97,102,56,56,53,53,50,54,54,57,57,49,99,57,53,99,102,52,49,52,99,49,56,48,100,53,53,102,51,54,98,50,55,55,48],"hint":0},{"address":[169,105,219,93,215,153,5,125,219,85,228,253,136,115,87,27,100,73,231,245,131,100,144,38,120,66,168,199,151,39,189,217],"bytes":[110,95,105,104],"hint":0},{"address":[170,151,92,94,35,243,249,131,241,200,93,37,79,211,217,160,97,97,2,108,83,131,196,13,27,30,11,54,129,37,126,71],"bytes":[117,49],"hint":0},{"address":[171,19,190,223,66,232,75,174,15,124,98,199,221,106,138,218,87,30,136,41,190,214,234,85,130,23,240,54,27,94,37,208],"bytes":[2],"hint":0},{"address":[171,27,34,97,177,154,111,139,206,105,146,202,229,50,14,67,44,90,171,82,87,163,38,68,234,106,89,158,208,224,104,119],"bytes":[115,117,98],"hint":0},{"address":[172,28,145,176,15,4,106,229,34,207,27,8,191,197,89,149,218,176,147,147,122,178,82,104,19,93,162,59,12,118,37,98],"bytes":[98,108,101,95,101,113,95,116,114,117,101,95,111,102,95,108,101],"hint":0},{"address":[172,200,167,105,154,43,244,203,208,95,105,103,142,172,79,194,54,87,32,65,194,141,253,10,181,88,229,252,242,171,101,64],"bytes":[116,114,117,101],"hint":0},{"address":[173,145,94,98,144,174,31,52,75,130,95,92,109,143,218,139,22,5,100,106,206,176,124,176,108,90,93,65,83,229,119,193],"bytes":[111,102,66,105,116,86,101,99],"hint":0},{"address":[173,168,184,85,219,244,70,93,239,7,186,84,190,85,120,132,102,77,58,25,35,192,156,68,90,49,220,178,201,200,9,91],"bytes":[68,101,99,105,100,97,98,108,101,69,113],"hint":0},{"address":[174,129,77,71,138,242,110,38,50,234,234,177,190,237,211,129,215,47,46,110,255,134,158,94,165,53,93,219,101,250,203,165],"bytes":[54,98,48,99,56,48,102,57,56,57,56,53,54,49,52,49,50,52,53,102,100,54,102,100,51,99,57,49,49,53,102,57,53,99,50,53,57,100,100,50,99,54,53,49,51,102,50,53,50,57,54,57,99,52,48,98,56,56,56,98,56,97,50,56],"hint":0},{"address":[175,46,220,103,65,84,255,18,157,158,130,103,39,173,160,130,141,59,164,128,146,75,190,216,75,246,220,174,46,31,29,178],"bytes":[192],"hint":0},{"address":[175,53,180,187,170,116,108,119,203,251,95,62,75,173,212,4,190,7,223,189,184,79,212,12,115,130,61,44,199,225,176,84],"bytes":[0,16],"hint":0},{"address":[175,79,153,11,69,250,186,50,3,224,213,175,138,168,1,147,84,235,178,113,71,173,241,140,158,196,13,254,153,125,222,156],"bytes":[95,104,121,103],"hint":0},{"address":[175,143,235,64,145,45,8,232,202,205,223,141,14,37,64,193,236,232,147,84,52,56,130,138,172,125,153,37,41,176,203,194],"bytes":[105,110,115,116,72,65,100,100],"hint":0},{"address":[175,228,171,143,65,228,29,75,38,136,15,244,25,76,95,140,197,60,139,43,151,186,97,5,125,5,64,38,83,28,198,177],"bytes":[78,111,116],"hint":0},{"address":[176,121,142,145,64,250,128,232,114,239,154,221,163,86,58,255,230,138,85,109,96,126,107,59,51,129,115,182,123,32,70,102],"bytes":[105,110,115,116,77,111,100],"hint":0},{"address":[178,95,36,72,130,85,214,85,1,174,107,92,17,1,252,36,68,89,153,42,205,86,173,4,198,44,22,61,32,141,252,128],"bytes":[97,117,120],"hint":0},{"address":[178,96,95,177,184,108,45,149,3,11,22,7,113,12,28,98,25,32,101,92,157,59,71,186,242,70,248,59,214,47,34,202],"bytes":[108,101,95,116,114,97,110,115],"hint":0},{"address":[178,183,191,3,214,197,235,211,205,10,195,87,176,113,137,42,224,122,13,248,211,16,83,234,171,175,31,137,190,194,170,215],"bytes":[105,110,115,116,77,117,108,78,97,116],"hint":0},{"address":[178,222,164,141,102,123,40,33,169,188,246,158,222,211,154,36,88,161,216,22,92,167,252,172,100,195,85,123,105,167,234,8],"bytes":[114],"hint":0},{"address":[179,93,74,179,146,251,149,44,141,118,37,239,191,175,248,175,44,140,235,242,13,31,249,120,74,143,254,8,220,102,126,18],"bytes":[16],"hint":0},{"address":[180,135,247,71,163,82,7,105,204,53,233,33,17,175,254,179,51,209,246,30,127,141,30,100,112,244,175,180,86,253,139,161],"bytes":[110,97,109,101,100,80,97,116,116,101,114,110],"hint":0},{"address":[183,116,13,103,238,90,160,180,70,225,33,149,251,182,63,252,77,217,34,228,217,132,71,83,139,124,55,57,174,164,228,159],"bytes":[108,101,95,115,117,99,99],"hint":0},{"address":[184,239,38,163,15,175,46,68,1,74,209,100,153,101,172,47,134,166,224,231,68,251,229,150,43,26,212,152,41,226,100,241],"bytes":[206,178],"hint":0},{"address":[185,115,16,79,126,47,220,213,17,82,155,216,192,119,25,0,176,187,78,251,81,185,133,144,219,106,218,212,116,139,1,128],"bytes":[115,121,109,109],"hint":0},{"address":[185,173,237,109,66,141,23,60,78,205,24,209,168,199,229,174,4,170,229,136,29,10,77,23,26,79,236,19,55,81,140,207],"bytes":[68,101,99,105,100,97,98,108,101],"hint":0},{"address":[185,246,60,131,151,93,173,238,155,77,195,250,238,182,105,221,239,52,187,225,46,58,6,38,24,49,102,152,38,129,216,28],"bytes":[108],"hint":0},{"address":[186,34,63,194,165,220,22,244,188,106,77,9,95,78,211,19,24,129,46,82,49,10,66,8,103,246,64,1,27,187,72,203],"bytes":[110,111,73,109,112,108,105,99,105,116,76,97,109,98,100,97],"hint":0},{"address":[187,92,74,200,114,28,101,96,33,252,204,201,249,24,15,102,185,46,170,125,250,210,26,250,37,227,189,62,51,251,11,178],"bytes":[100,105,116,101],"hint":0},{"address":[187,230,169,245,160,20,106,31,77,3,129,233,176,237,26,194,241,169,121,206,157,90,216,78,70,255,11,88,243,107,95,70],"bytes":[128],"hint":0},{"address":[188,7,205,168,251,76,150,127,229,103,234,154,93,46,221,61,226,212,100,131,223,223,192,47,161,50,115,8,228,0,189,215],"bytes":[95,112,114,105,118,97,116,101],"hint":0},{"address":[188,125,98,104,61,192,39,82,126,212,205,227,225,128,50,34,54,30,193,107,31,76,234,168,103,62,78,95,230,142,253,233],"bytes":[255,7],"hint":0},{"address":[188,247,226,253,47,124,143,220,18,161,26,71,3,134,69,52,121,105,34,239,177,239,57,189,65,154,62,243,241,212,152,132],"bytes":[120,115],"hint":0},{"address":[189,4,218,159,233,253,227,45,79,78,214,63,110,15,222,199,123,140,176,15,21,243,100,106,106,233,42,1,249,3,50,142],"bytes":[97,226,130,130],"hint":0},{"address":[189,217,55,14,84,117,106,254,220,148,153,235,80,45,246,166,147,146,75,50,3,174,252,48,248,72,76,241,224,143,68,137],"bytes":[95,97],"hint":0},{"address":[190,45,223,164,31,166,14,235,81,172,178,86,17,193,86,176,36,133,163,95,238,72,209,68,105,48,43,149,186,129,81,215],"bytes":[102,108,97,116,116,101,110],"hint":0},{"address":[190,130,3,135,140,72,87,67,2,137,146,215,10,240,124,169,148,173,75,1,63,41,97,116,188,132,156,73,240,154,46,193],"bytes":[108,101],"hint":0},{"address":[191,55,0,153,182,42,40,84,120,13,30,95,165,249,91,41,69,111,161,232,6,46,50,42,32,153,178,173,253,191,209,103],"bytes":[57,50,99,50,51,55,101,55,54,100,57,51,99,50,53,98,48,100,98,99,52,55,97,49,56,49,101,57,50,100,53,102,57,55,55,100,99,48,54,52,99,52,53,99,97,48,97,49,53,56,102,51,101,56,51,52,97,53,97,56,49,56,49,99],"hint":0},{"address":[192,40,251,235,119,113,108,52,55,32,0,39,234,192,193,87,127,230,75,155,151,149,187,47,248,183,56,215,56,89,117,8],"bytes":[110,111,116,95,115,117,99,99,95,108,101,95,115,101,108,102],"hint":0},{"address":[192,84,33,170,66,71,23,219,3,250,131,113,94,31,86,47,137,228,31,122,202,56,77,139,63,76,91,106,193,160,104,249],"bytes":[108,101,95,111,102,95,108,116,95,115,117,99,99],"hint":0},{"address":[192,225,153,6,94,239,155,32,118,146,246,174,157,182,101,164,97,103,46,149,193,102,121,35,21,212,186,69,27,246,39,70],"bytes":[103,111],"hint":0},{"address":[192,246,58,240,76,122,178,25,179,179,99,54,204,186,1,159,220,199,8,192,186,220,109,187,183,8,48,150,42,201,132,77],"bytes":[105,104],"hint":0},{"address":[193,5,180,222,176,208,100,69,241,41,153,200,67,119,48,13,195,141,249,39,37,104,73,71,150,227,104,254,239,163,189,90],"bytes":[72,77,117,108],"hint":0},{"address":[193,40,224,168,35,193,4,166,8,85,23,57,87,197,127,8,151,9,199,196,164,21,122,89,255,159,240,138,120,61,153,157],"bytes":[55,56,54,99,56,98,102,49,54,54,97,53,56,99,49,57,49,48,102,56,48,52,50,102,101,54,55,51,99,52,49,52,52,100,51,48,97,101,48,50,102,50,57,99,97,101,98,49,99,102,52,99,98,56,56,48,57,99,52,54,97,99,57,51],"hint":0},{"address":[193,181,198,101,140,249,198,176,86,209,70,101,101,172,177,135,197,8,78,83,197,5,118,64,234,161,56,179,166,30,107,199],"bytes":[68,105,118],"hint":0},{"address":[194,28,5,179,68,35,209,59,136,178,152,168,0,209,138,86,64,47,235,112,28,207,229,194,119,227,244,192,233,188,158,61],"bytes":[50,52,100,54,54,50,54,53,54,97,50,57,52,49,102,55,56,51,55,100,52,57,99,53,52,54,55,51,54,101,99,98,52,102,97,49,53,101,97,98,57,102,54,99,97,48,57,97,97,102,49,98,98,102,99,56,49,50,57,50,101,51,56,49],"hint":0},{"address":[194,75,118,188,154,37,198,38,235,18,154,117,8,203,0,148,82,2,237,132,68,192,235,86,6,59,239,153,107,29,185,178],"bytes":[65,114,114,97,121],"hint":0},{"address":[194,196,125,104,171,68,46,140,236,15,252,153,169,175,162,17,27,218,69,39,239,203,37,61,25,95,231,213,177,163,114,246],"bytes":[108,101,95,111,102,95,115,117,99,99,95,108,101,95,115,117,99,99],"hint":0},{"address":[195,175,123,17,65,33,83,75,25,32,60,69,202,49,108,148,74,144,192,103,187,163,220,241,229,98,93,18,115,3,8,116],"bytes":[104],"hint":0},{"address":[197,118,126,195,90,209,144,15,77,170,173,33,189,98,36,51,240,16,25,218,2,138,74,141,199,205,237,213,211,182,98,163],"bytes":[104,110],"hint":0},{"address":[197,249,183,204,243,218,115,198,21,131,109,23,192,86,150,191,37,74,73,15,48,46,117,120,250,35,80,213,146,55,92,97],"bytes":[97,100,100,95,112,111,115,95,114,105,103,104,116],"hint":0},{"address":[198,29,4,98,190,26,208,143,176,8,227,8,109,45,5,117,168,32,3,250,220,223,8,80,21,119,135,14,8,109,71,52],"bytes":[72,80,111,119],"hint":0},{"address":[198,104,52,203,77,161,216,218,31,109,127,192,205,183,248,100,59,29,175,9,152,1,195,172,188,25,130,96,200,138,55,26],"bytes":[127],"hint":0},{"address":[198,239,89,126,124,77,192,84,147,215,4,247,150,204,117,186,43,177,75,231,139,220,160,178,221,29,153,235,68,69,226,63],"bytes":[101,109,112,116,121,87,105,116,104,67,97,112,97,99,105,116,121],"hint":0},{"address":[199,245,243,32,200,208,78,50,160,65,127,115,39,65,61,3,135,169,212,89,185,163,176,46,40,122,131,75,221,153,216,59],"bytes":[109,112,114],"hint":0},{"address":[200,76,241,11,118,120,177,243,64,104,83,52,42,145,101,26,208,72,167,232,10,165,3,46,84,235,95,26,19,196,220,237],"bytes":[102,117,110,84,121,112,101,95,49],"hint":0},{"address":[201,209,20,182,150,48,36,219,135,175,157,72,22,107,207,180,137,207,229,102,38,157,33,189,208,24,76,152,20,34,86,87],"bytes":[110,101,95,116,114,117,101,95,111,102,95,101,113,95,102,97,108,115,101],"hint":0},{"address":[202,183,11,136,183,83,173,8,94,142,139,216,210,211,189,107,195,56,212,148,217,137,225,96,188,247,122,225,44,71,55,163],"bytes":[97,57,101,102,53,99,48,57,50,97,49,98,49,54,53,51,51,51,56,98,98,57,102,98,57,100,102,97,97,57,101,49,56,54,49,100,52,57,50,49,98,54,57,52,97,101,56,98,48,102,98,97,48,99,49,102,97,54,100,97,102,101,100,56],"hint":0},{"address":[202,223,170,34,215,111,244,118,172,177,152,255,239,105,44,105,177,223,111,163,130,56,85,119,182,3,73,60,203,226,141,70],"bytes":[105,116,101],"hint":0},{"address":[204,88,45,44,132,83,157,127,199,213,36,112,164,163,131,46,174,230,84,84,131,76,115,45,39,143,254,154,111,102,205,175],"bytes":[109,111,100,67,111,114,101],"hint":0},{"address":[207,34,190,218,196,154,175,124,11,104,212,139,149,169,28,208,121,223,157,179,217,95,50,249,121,129,120,236,240,127,122,8],"bytes":[115,116,101,112],"hint":0},{"address":[207,196,55,194,217,78,158,96,203,211,177,42,227,163,64,128,166,161,156,68,40,245,48,137,155,237,70,242,57,35,224,246],"bytes":[67,111,114,101],"hint":0},{"address":[210,82,98,132,192,242,138,212,186,255,67,44,117,47,38,64,161,29,102,7,165,229,227,0,30,207,240,238,225,169,126,29],"bytes":[112,114,101,100],"hint":0},{"address":[211,4,7,80,165,156,119,238,161,35,103,34,254,131,48,140,146,158,61,212,84,149,140,41,185,83,115,56,66,250,14,83],"bytes":[105,110,115,116,68,105,118],"hint":0},{"address":[211,52,50,243,115,50,199,248,1,143,95,251,17,118,27,75,241,24,164,89,237,153,63,105,197,100,239,148,243,26,39,6],"bytes":[104,83,117,98],"hint":0},{"address":[211,57,5,113,96,107,220,66,85,215,165,246,153,193,56,84,249,216,99,119,188,196,95,246,93,94,91,159,202,187,48,129],"bytes":[109,111,100],"hint":0},{"address":[213,50,81,118,153,194,55,126,17,105,143,255,231,68,138,167,126,239,121,238,99,100,36,132,184,56,138,184,54,105,35,26],"bytes":[105,110,115,116,68,101,99,105,100,97,98,108,101,69,113,76,105,115,116],"hint":0},{"address":[213,72,122,167,166,18,93,76,106,8,94,94,98,17,143,57,172,126,242,244,79,140,9,44,34,125,110,12,226,9,14,107],"bytes":[100,112],"hint":0},{"address":[213,173,155,7,163,5,218,58,88,162,106,231,16,210,207,2,99,63,96,224,68,32,24,114,4,79,55,250,120,220,171,95],"bytes":[115,110,100],"hint":0},{"address":[213,198,171,45,58,27,74,196,150,146,31,118,153,188,215,10,227,44,149,194,110,43,240,90,160,229,20,64,172,72,46,126],"bytes":[48,57,49,100,50,56,56,97,98,52,54,48,97,100,54,50,102,99,55,54,102,97,102,53,51,55,55,57,48,54,100,99,57,102,98,56,97,54,52,49,100,51,101,56,97,102,52,57,53,97,48,101,100,49,52,54,100,50,56,97,100,57,54,100],"hint":0},{"address":[214,89,255,160,250,135,140,96,236,203,147,30,107,72,79,12,236,239,183,199,59,246,159,214,128,62,95,92,246,5,15,83],"bytes":[122,101,114,111,95,108,101],"hint":0},{"address":[214,225,52,69,202,102,20,134,163,60,86,168,7,161,207,160,129,161,55,194,2,201,26,232,88,93,143,84,33,66,105,110],"bytes":[73,110,105,116],"hint":0},{"address":[215,82,89,170,155,189,92,83,215,62,56,192,90,90,222,63,15,111,216,76,212,203,111,30,0,249,53,40,24,51,178,156],"bytes":[98,108,101],"hint":0},{"address":[215,113,123,93,40,22,245,24,45,2,106,5,71,19,19,112,24,133,19,63,138,124,86,233,157,127,55,152,12,170,0,170],"bytes":[97,112,112,101,110,100],"hint":0},{"address":[215,237,32,165,45,15,181,163,92,45,113,255,125,123,21,223,107,57,135,30,8,127,246,221,23,6,254,9,197,180,2,101],"bytes":[65,110,100],"hint":0},{"address":[216,94,92,181,53,32,105,80,52,87,245,104,0,101,77,91,9,200,61,213,157,252,156,185,249,125,250,49,34,154,234,133],"bytes":[80,114,101,108,117,100,101],"hint":0},{"address":[217,92,253,127,13,119,239,243,192,89,144,63,115,93,242,131,227,9,97,73,29,52,66,36,230,101,112,75,102,161,164,97],"bytes":[104,95,49],"hint":0},{"address":[219,174,29,217,51,198,82,235,54,70,220,167,250,61,66,205,20,42,17,182,5,243,209,168,129,91,162,177,67,145,199,64],"bytes":[101,113,95,111,114,95,108,116,95,111,102,95,108,101],"hint":0},{"address":[219,227,3,133,239,112,128,160,66,127,207,192,5,92,51,243,122,58,235,127,96,88,62,90,109,186,203,237,154,150,51,91],"bytes":[56,57,53,99,52,54,52,56,52,102,50,99,98,97,54,49,99,101,100,98,51,49,48,99,54,54,98,100,97,51,51,49,57,99,49,54,51,55,98,48,49,53,99,52,101,97,97,55,53,57,51,51,54,51,98,99,101,53,98,50,100,51,55,99],"hint":0},{"address":[220,155,122,227,194,202,208,187,199,82,68,131,63,2,148,97,93,224,115,10,116,62,108,112,58,175,237,30,146,240,193,168],"bytes":[108,111,111,112],"hint":0},{"address":[222,124,99,37,134,83,137,198,138,163,63,224,31,149,126,121,220,137,31,198,155,180,220,180,111,56,180,244,75,228,7,234],"bytes":[70,97,108,115,101],"hint":0},{"address":[223,109,59,193,170,63,140,3,165,94,129,212,110,216,21,102,2,179,94,31,21,224,211,239,68,190,182,25,219,152,125,116],"bytes":[99,97,115,101,115,79,110],"hint":0},{"address":[224,13,146,116,226,57,18,86,165,46,15,8,45,249,161,40,46,81,188,87,49,226,79,3,135,35,221,192,143,225,226,128],"bytes":[97,95,105,104],"hint":0},{"address":[224,84,183,135,137,32,215,163,24,177,212,70,247,46,119,119,204,142,52,131,74,43,137,177,69,255,243,47,159,202,154,57],"bytes":[100,105,118,95,114,101,99,95,108,101,109,109,97],"hint":0},{"address":[224,126,60,35,226,97,213,112,37,59,211,90,132,209,182,232,196,15,153,105,132,210,165,156,44,242,181,76,56,222,214,49],"bytes":[115,117,98,95,108,101],"hint":0},{"address":[225,205,168,77,161,2,242,188,204,9,84,24,160,118,2,184,88,221,20,4,101,183,96,205,235,136,17,149,10,254,184,33],"bytes":[104,97],"hint":0},{"address":[227,194,35,53,174,66,189,165,47,179,182,253,1,243,243,188,88,169,228,71,194,91,192,100,13,166,143,161,226,128,10,116],"bytes":[105,110,115,116,65,100,100,78,97,116],"hint":0},{"address":[228,119,12,67,144,253,62,143,13,103,130,82,96,135,136,126,131,159,139,106,48,108,50,187,226,9,228,237,4,144,142,33],"bytes":[102,115,116],"hint":0},{"address":[228,229,138,159,217,233,212,22,138,100,163,94,232,14,199,173,31,219,216,114,240,66,0,106,209,123,102,26,205,165,190,61],"bytes":[115,105,122,101],"hint":0},{"address":[229,218,50,224,81,241,56,248,222,157,41,84,183,139,48,145,72,162,111,42,36,244,142,220,72,18,42,107,29,8,198,253],"bytes":[105,110,115,116,72,83,117,98],"hint":0},{"address":[231,47,78,110,143,167,40,162,53,2,209,64,166,119,88,117,36,93,171,178,100,16,214,59,244,147,165,60,78,100,57,117],"bytes":[104,109],"hint":0},{"address":[231,100,26,67,41,205,43,218,75,146,111,28,80,68,226,160,33,97,78,5,140,132,90,91,200,66,193,120,52,34,164,109],"bytes":[85,73,110,116,51,50],"hint":0},{"address":[233,121,4,246,171,163,16,221,252,64,112,210,209,221,20,158,132,52,51,215,222,15,61,151,2,151,102,174,242,5,21,163],"bytes":[78,97,116,80,111,119],"hint":0},{"address":[233,131,224,169,229,83,12,43,119,20,230,120,233,61,188,129,150,148,124,190,111,195,63,163,212,106,36,240,111,251,98,193],"bytes":[240],"hint":0},{"address":[233,150,250,165,143,0,101,62,24,7,239,223,76,244,185,81,235,160,36,233,254,15,249,12,66,155,165,20,60,76,3,65],"bytes":[105,110,115,116,72,77,117,108],"hint":0},{"address":[233,192,186,8,1,87,105,160,196,53,69,148,185,108,224,223,191,39,201,235,83,74,47,131,120,80,137,133,247,50,255,109],"bytes":[105],"hint":0},{"address":[233,223,41,70,98,82,190,158,194,40,194,213,118,20,78,254,134,68,67,134,170,212,90,77,239,185,158,14,28,244,175,34],"bytes":[73,115,86,97,108,105,100,85,84,70,56],"hint":0},{"address":[234,97,198,198,190,130,67,11,34,183,240,4,112,38,25,97,212,204,126,90,186,175,163,13,200,25,123,152,14,226,221,250],"bytes":[95,112,114,111,111,102,95,50],"hint":0},{"address":[234,122,161,252,158,253,190,16,109,187,112,54,154,117,233,103,31,162,157,82,189,85,83,103,17,191,25,116,119,184,240,33],"bytes":[99],"hint":0},{"address":[234,187,137,201,231,200,151,146,174,122,215,89,159,231,121,108,162,183,138,220,222,117,225,158,17,153,29,225,217,107,216,191],"bytes":[70,95,49],"hint":0},{"address":[234,227,254,230,244,216,137,139,182,36,1,227,236,181,225,245,141,169,138,57,207,199,71,174,110,196,54,246,165,43,198,185],"bytes":[109,107],"hint":0},{"address":[235,114,114,141,157,55,213,76,152,69,8,248,195,80,116,158,148,226,166,223,117,33,169,172,238,88,4,60,143,245,81,95],"bytes":[104,95,51],"hint":0},{"address":[236,191,37,58,12,18,211,100,24,49,1,178,128,195,160,89,169,180,106,225,35,74,235,153,77,212,53,51,41,86,59,221],"bytes":[108,116,95,111,102,95,108,116,95,111,102,95,108,101],"hint":0},{"address":[237,94,30,243,46,167,145,225,43,0,107,242,180,122,159,148,173,14,158,16,40,65,242,241,26,190,148,79,142,169,11,5],"bytes":[77,117,108],"hint":0},{"address":[239,236,57,121,222,153,204,65,201,220,11,244,219,176,60,127,238,146,141,147,183,125,154,33,83,9,13,105,245,247,224,138],"bytes":[115,101,108,102],"hint":0},{"address":[240,3,219,60,143,221,195,97,28,215,92,220,176,81,8,96,105,35,224,188,19,126,153,245,58,131,191,221,92,143,214,214],"bytes":[113],"hint":0},{"address":[240,136,89,135,209,121,56,28,24,221,169,16,127,176,125,21,126,12,68,210,145,1,4,243,204,181,15,90,139,230,181,130],"bytes":[76],"hint":0},{"address":[240,150,229,250,22,65,6,118,195,134,190,240,166,81,118,69,34,145,26,115,126,60,88,36,198,223,87,149,161,127,63,138],"bytes":[70,105,110],"hint":0},{"address":[240,194,74,176,201,233,232,186,110,222,242,65,76,47,166,160,210,113,144,104,69,45,200,110,125,137,32,141,49,55,165,41],"bytes":[97,98,115,117,114,100],"hint":0},{"address":[241,98,95,248,56,66,50,41,199,33,237,174,140,97,227,228,138,34,243,50,47,244,107,128,181,150,14,173,62,192,136,34],"bytes":[108,101,95,111,102,95,98,108,101,95,101,113,95,116,114,117,101],"hint":0},{"address":[242,60,158,77,88,129,207,86,148,105,19,124,165,41,11,86,105,97,154,98,51,202,241,14,30,127,211,60,35,193,221,125],"bytes":[76,84],"hint":0},{"address":[242,235,175,196,150,15,59,207,251,215,155,36,120,148,42,220,188,8,70,253,102,243,112,14,203,85,39,84,221,216,131,197],"bytes":[110,105,108],"hint":0},{"address":[242,242,21,32,190,190,93,7,198,129,59,151,45,227,97,122,10,13,80,163,107,227,120,78,159,236,229,76,255,141,128,50],"bytes":[119],"hint":0},{"address":[245,85,30,121,28,216,127,97,162,137,44,67,136,230,49,223,119,56,202,28,147,221,62,60,79,59,56,156,235,20,178,150],"bytes":[109,117,108],"hint":0},{"address":[245,172,204,143,58,62,149,33,112,202,16,75,135,117,102,95,204,45,117,12,131,186,226,200,224,26,11,115,148,20,246,85],"bytes":[79,102,78,97,116],"hint":0},{"address":[245,228,196,43,209,195,19,90,46,61,64,71,188,228,19,45,141,161,71,72,21,142,225,251,163,66,93,146,128,135,132,96],"bytes":[98,101,113],"hint":0},{"address":[245,239,75,126,190,59,144,236,219,118,77,41,172,112,189,172,107,162,123,57,92,170,115,32,210,248,4,18,192,185,226,31],"bytes":[99,111,110,103,114,65,114,103],"hint":0},{"address":[246,13,44,192,242,157,137,40,142,7,11,173,210,171,94,98,64,7,29,161,254,114,32,215,178,214,1,254,7,131,40,239],"bytes":[206,179],"hint":0},{"address":[246,13,253,165,75,25,127,150,164,129,5,45,217,207,118,215,166,235,228,191,60,57,172,154,100,158,184,142,109,144,180,61],"bytes":[99,99,48,98,48,99,55,100,54,56,51,98,56,99,50,55,98,98,98,98,55,54,98,100,100,56,97,52,51,52,99,53,52,48,97,100,54,49,55,57,101,54,57,50,97,100,54,53,50,52,48,102,55,53,98,49,97,52,55,50,51,99,50,100],"hint":0},{"address":[247,149,135,73,40,132,111,129,43,65,219,112,74,187,184,26,176,97,40,234,35,251,74,160,24,61,227,182,90,95,22,86],"bytes":[121,112,111,115],"hint":0},{"address":[247,151,117,220,236,43,193,236,95,27,175,68,167,37,22,128,84,97,21,31,245,112,78,190,113,131,190,58,46,191,121,204],"bytes":[55,100,53,57,54,56,55,99,56,98,53,97,49,51,53,57,99,57,57,48,49,51,101,54,51,51,100,53,48,54,53,49,51,53,51,98,56,48,51,48,97,56,97,52,49,55,102,99,55,53,102,48,52,54,52,56,48,57,51,55,55,100,54,54],"hint":0},{"address":[247,253,4,23,119,157,106,71,226,172,56,151,172,165,52,84,131,112,129,85,142,213,196,227,84,182,215,226,106,60,124,214],"bytes":[116,39],"hint":0},{"address":[248,171,61,186,122,1,74,155,224,187,237,225,165,147,35,91,193,218,131,228,216,48,192,195,126,117,43,32,91,179,11,205],"bytes":[76,105,115,116],"hint":0},{"address":[248,174,244,124,168,110,7,155,93,15,6,1,161,38,26,103,184,76,4,198,73,92,220,12,179,220,127,141,236,4,48,191],"bytes":[110,111,116,95,115,117,99,99,95,108,101,95,122,101,114,111],"hint":0},{"address":[249,235,21,128,126,50,170,90,189,33,233,67,92,234,236,101,70,228,170,255,240,189,120,193,176,170,95,206,43,132,193,195],"bytes":[114,101,99],"hint":0},{"address":[251,43,81,220,194,163,254,79,240,80,225,67,126,23,91,136,243,218,242,34,174,120,137,185,158,102,231,8,131,219,93,38],"bytes":[111,117,116,80,97,114,97,109],"hint":0},{"address":[251,152,237,160,63,126,91,187,64,70,215,87,147,194,72,188,114,170,63,174,155,60,140,229,11,82,133,138,112,146,25,150],"bytes":[79,114],"hint":0},{"address":[251,247,18,144,147,66,146,147,213,88,179,153,60,161,57,136,218,186,137,63,74,25,27,194,177,193,229,181,42,13,1,114],"bytes":[118],"hint":0},{"address":[252,66,165,165,85,170,123,1,87,47,103,170,95,202,62,9,96,85,230,43,129,139,175,62,205,0,228,248,32,207,230,178],"bytes":[67],"hint":0},{"address":[252,118,248,140,66,2,216,229,4,142,172,111,63,183,53,240,194,200,25,238,8,97,35,14,1,144,205,98,200,152,252,173],"bytes":[109,111,100,67,111,114,101,71,111,95,108,116],"hint":0},{"address":[252,166,205,9,110,220,103,99,91,63,79,164,99,109,210,49,34,137,90,106,152,109,245,66,52,173,215,54,43,75,1,140],"bytes":[73,120],"hint":0},{"address":[253,208,92,189,132,68,9,152,41,8,59,206,210,58,166,197,205,130,95,136,143,103,205,18,247,145,68,41,152,133,100,109],"bytes":[109,117,108,95,112,111,115],"hint":0},{"address":[254,213,87,37,7,135,10,250,217,214,28,129,166,226,172,204,141,83,70,58,77,76,109,90,147,227,68,229,68,55,171,154],"bytes":[117,50],"hint":0},{"address":[255,118,166,206,51,67,122,158,21,176,17,225,138,135,138,226,197,1,39,186,140,12,243,100,182,176,149,130,7,215,33,38],"bytes":[111,102,70,105,110],"hint":0}],"constants":[{"address":[1,1,22,29,55,101,91,114,101,18,23,92,48,17,80,234,101,230,201,13,183,128,130,154,252,34,61,18,56,14,124,122],"bytes":[208,9,0,147,23,176,23,176,23,179,181,131,7,176,7,176,7,179,118,32,9,131,7,176,7,176,7,179,181,18,17,16,130,7,176,7,113,178,32,15,114,33,5,0,113,178,113,180,32,15,114,32,8,177,16,131,7,176,7,176,7,113,178,113,32,7,17,113,32,12,114,32,6,17,18,6,32,4,115,33,13,0,176,99,113,32,14,99,115,33,0,0,176,32,11,177,113,178,17,117,35,2,0,0,0,176,176,176,114,33,1,0,176,32,10,17,113,178,113,180,18,16,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,55,164,229,247,168,54,105,254,65,69,200,121,128,151,23,42,140,241,109,45,19,5,51,112,162,179,156,160,204,69,56,146,62,138,173,204,97,28,77,134,119,202,223,0,199,133,6,86,29,51,115,142,227,213,113,247,164,25,110,38,5,128,201,184,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,110,225,113,213,144,180,37,202,248,240,54,153,59,167,5,3,89,134,183,154,12,170,135,118,222,67,144,81,80,175,37,172,151,54,53,120,60,51,25,156,213,180,194,133,130,123,253,77,134,72,129,130,0,189,161,100,150,190,169,132,210,106,194,187,172,236,141,84,253,42,149,116,121,227,42,148,233,109,150,37,96,48,59,90,31,4,119,124,236,230,174,65,170,201,238,120,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,175,9,117,110,177,82,121,33,25,161,227,86,120,130,27,112,231,216,72,81,58,119,85,17,146,183,109,115,45,61,236,133,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,1,0],"hint":0},{"address":[1,52,162,6,154,222,214,241,18,20,204,33,47,37,177,194,163,224,207,41,103,92,148,75,153,178,28,90,2,159,76,39],"bytes":[208,9,0,149,23,176,23,176,23,176,23,179,23,179,114,177,20,18,133,7,176,7,176,7,176,7,179,7,179,160,7,147,23,176,23,184,2,23,184,1,0,131,7,176,7,184,2,7,184,1,114,177,23,18,118,32,7,20,130,7,176,7,184,0,145,23,114,177,23,22,115,19,18,16,17,19,17,132,7,176,7,184,0,7,116,32,6,22,130,7,176,7,114,177,23,16,145,23,182,115,21,18,16,17,17,16,7,114,177,180,23,120,2,32,2,178,180,20,132,7,176,7,114,177,181,178,7,114,177,181,17,7,114,184,3,18,16,114,177,183,19,19,16,18,17,129,7,182,16,133,7,182,7,176,7,114,32,3,181,16,7,114,184,3,17,16,7,145,23,114,177,183,24,4,115,178,19,16,18,115,32,5,24,6,19,113,16,20,18,12,32,1,114,33,0,0,176,32,4,24,1,114,177,18,17,24,0,24,2,114,177,178,180,24,5,114,177,21,16,114,177,21,17,114,177,21,20,114,32,6,24,3,130,7,176,7,114,177,24,4,16,145,23,114,177,24,6,183,115,181,18,16,17,8,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,111,123,60,108,110,90,226,50,236,153,200,90,156,221,158,125,125,111,245,39,51,43,252,62,186,225,134,61,116,152,66,74,143,112,180,160,174,152,116,193,51,244,179,211,36,51,17,25,136,171,75,61,193,164,122,107,230,246,195,65,167,219,176,175,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,187,67,180,68,88,106,58,237,43,170,13,123,116,49,202,109,205,20,171,148,68,188,119,146,13,19,67,51,208,191,229,116,218,224,24,9,166,175,10,253,129,230,253,211,161,211,159,239,134,168,168,196,233,8,24,177,163,87,225,128,221,218,178,89,241,234,181,89,14,243,85,127,115,217,213,16,117,241,14,246,8,112,69,108,235,128,246,108,61,93,23,111,158,121,188,189,1,0],"hint":0},{"address":[1,156,82,160,48,77,46,6,170,125,218,127,215,239,133,243,65,227,200,233,141,87,191,152,55,238,79,178,125,40,128,190],"bytes":[208,9,0,145,23,176,177,129,7,176,115,33,6,0,129,7,176,177,16,32,5,2,32,2,113,32,0,116,33,1,0,176,32,4,113,32,3,16,16,7,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,196,226,8,65,73,233,141,130,37,100,137,178,229,161,124,237,243,0,103,41,133,113,150,61,230,167,248,81,187,86,61,195,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,1,0],"hint":0},{"address":[1,210,87,183,1,146,38,189,176,77,45,212,108,97,145,226,7,228,101,81,222,88,168,234,40,104,82,126,191,140,146,236],"bytes":[214,0,107,12,128,249,137,133,97,65,36,95,214,253,60,145,21,249,92,37,157,210,198,81,63,37,41,105,196,11,136,139,138,40,0,0,0],"hint":0},{"address":[2,1,207,17,44,128,169,32,218,175,29,186,208,247,219,163,151,224,41,20,165,148,50,128,126,189,159,55,118,75,214,74],"bytes":[208,1,1,146,23,0,23,16,115,33,0,0,17,16,16,130,7,0,7,16,114,33,1,0,17,16,0,2,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,212,148,220,96,19,134,186,142,143,11,113,31,230,42,45,96,171,96,198,72,140,140,246,206,151,121,110,188,58,213,254,251,1,192],"hint":2},{"address":[3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122],"bytes":[208,1,0,145,23,0,0,129,7,0,145,23,16,32,0,0,1,161,35,96,69,20,10,194,171,190,21,41,88,52,132,52,251,132,73,101,150,249,252,93,203,189,88,91,129,116,196,57,39,1,0],"hint":2},{"address":[3,179,160,65,40,91,15,226,2,217,11,34,125,64,92,76,236,37,45,241,139,167,97,106,205,109,174,39,146,230,114,187],"bytes":[208,1,0,145,23,176,177,130,7,176,7,176,116,33,2,0,129,7,176,177,16,32,1,17,2,32,0,145,23,176,176,3,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,215,149,230,94,69,97,85,230,174,28,234,91,220,150,36,117,231,14,61,26,99,80,91,221,41,196,80,23,73,229,200,111,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,1,1,0],"hint":4},{"address":[5,199,182,224,138,234,68,58,149,61,8,60,30,231,110,202,98,58,85,180,216,170,221,68,152,250,235,100,244,23,155,77],"bytes":[208,9,2,150,23,1,23,2,23,17,23,18,23,179,23,180,115,177,20,178,113,17,18,134,7,1,7,2,7,17,7,18,7,179,7,180,118,34,2,0,1,21,19,130,7,21,7,115,176,22,20,16,115,177,22,113,19,21,113,19,17,114,33,0,2,20,178,18,16,5,33,1,1,33,1,2,113,17,19,145,23,19,19,115,176,20,18,17,3,2,1,207,17,44,128,169,32,218,175,29,186,208,247,219,163,151,224,41,20,165,148,50,128,126,189,159,55,118,75,214,74,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,251,3,245,167,225,65,216,64,37,179,165,3,222,220,83,206,134,242,151,189,227,107,188,27,152,104,122,234,180,53,153,104,3,0,192,193],"hint":0},{"address":[6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199],"bytes":[208,1,1,148,23,1,23,176,23,17,23,18,0,130,7,1,7,176,64,0,16,1,113,33,0,2,16,1,49,201,229,28,85,180,20,198,36,190,155,239,220,3,50,69,108,205,146,154,196,27,168,14,229,13,203,114,18,206,1,242,3,0,1,192,192],"hint":4294967295},{"address":[6,95,200,180,19,147,245,37,193,229,65,185,212,188,151,194,12,19,191,35,167,32,154,32,147,182,244,82,115,48,17,74],"bytes":[214,0,26,115,12,44,14,68,98,100,170,40,28,43,76,150,49,57,152,157,103,233,119,174,173,232,184,8,38,223,218,225,167,223,0,0,0],"hint":0},{"address":[6,130,169,187,145,109,99,25,149,171,18,87,167,82,105,228,15,62,82,43,99,203,13,117,117,79,27,182,17,178,98,154],"bytes":[208,1,2,150,23,1,23,16,23,178,23,177,23,19,23,179,113,19,17,134,7,1,7,16,7,178,7,177,7,19,7,179,118,34,1,0,1,21,20,130,7,21,7,115,176,22,21,16,113,21,17,18,17,16,4,33,0,1,113,16,17,145,23,17,0,115,176,20,19,16,2,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,251,3,245,167,225,65,216,64,37,179,165,3,222,220,83,206,134,242,151,189,227,107,188,27,152,104,122,234,180,53,153,104,2,192,193],"hint":4294967295},{"address":[6,181,53,250,160,34,165,49,126,121,184,243,251,101,120,161,62,234,9,141,151,244,239,16,210,170,46,245,180,2,164,244],"bytes":[208,1,0,150,23,176,23,183,23,176,23,184,0,23,176,23,182,176,134,7,176,7,183,7,176,7,184,0,7,176,7,182,118,33,17,1,17,130,7,176,7,114,179,18,16,145,23,113,181,17,176,19,16,131,7,176,7,114,179,18,113,32,6,16,7,113,181,113,32,6,17,117,33,15,1,176,180,114,32,7,177,20,129,7,180,114,64,9,17,118,35,3,0,0,0,176,176,176,114,33,2,0,176,32,16,21,24,1,118,32,8,21,24,1,19,177,16,18,129,7,113,32,0,180,21,18,9,32,5,24,0,113,33,1,0,176,113,178,32,11,115,178,32,12,177,20,113,33,10,1,129,7,176,146,23,176,23,114,179,16,17,176,114,179,16,18,114,179,115,33,13,0,176,100,113,32,14,100,16,113,181,16,18,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,123,182,89,135,102,113,224,61,7,49,196,86,232,148,206,158,111,125,232,37,10,180,174,112,17,61,192,142,36,83,33,39,139,123,54,247,176,117,50,42,91,202,116,89,16,34,227,81,167,157,230,116,45,88,171,50,18,192,247,253,51,230,140,46,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,228,14,118,142,182,13,77,21,4,125,13,195,184,32,234,175,107,253,251,200,161,173,38,141,205,120,114,45,50,22,74,185,235,80,53,253,14,237,19,39,158,181,89,13,194,124,130,114,1,54,228,250,165,233,124,128,18,170,79,204,128,120,19,52,238,14,28,167,126,90,205,78,70,91,168,94,39,242,68,66,47,0,98,9,95,223,66,32,87,29,140,28,39,84,116,163,2,0,1,0],"hint":4294967295},{"address":[9,29,40,138,180,96,173,98,252,118,250,245,55,121,6,220,159,184,166,65,211,232,175,73,90,14,209,70,210,138,217,109],"bytes":[193,1,0,0,1,0,145,23,0,1,2,0,0,0,1,1,146,23,0,23,113,32,0,16,176,0,0,1,1,1,146,23,0,23,16,176,1,113,48,0,17,1,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,2,0,1,0],"hint":0},{"address":[10,224,239,210,148,92,57,189,131,185,81,185,60,142,148,71,191,223,56,85,186,77,84,70,59,4,155,19,3,161,161,36],"bytes":[208,1,0,145,23,176,32,1,129,7,176,116,33,3,0,129,7,176,32,1,16,96,98,1,32,4,5,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,72,252,114,31,187,193,114,224,146,95,162,122,241,103,29,226,37,186,146,113,52,128,41,152,177,10,21,104,161,136,101,43,87,167,53,35,32,67,243,33,132,94,50,178,160,142,93,54,175,23,91,174,34,234,35,34,120,68,188,69,151,153,255,69,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,1,1,0],"hint":2},{"address":[11,94,89,63,177,70,42,135,57,132,211,33,222,0,103,94,198,107,7,59,76,85,14,29,28,211,106,22,169,226,221,253],"bytes":[193,1,0,0,0,0,0,0,0,0,1,0],"hint":0},{"address":[12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27],"bytes":[208,1,1,146,23,0,23,176,115,35,2,1,1,1,17,17,17,130,7,0,7,176,116,35,3,1,1,1,17,17,17,130,7,17,7,18,116,33,0,1,19,18,17,16,1,113,33,1,1,16,4,12,123,121,250,222,146,202,217,43,223,150,222,4,192,233,67,254,8,241,2,201,202,39,101,64,58,159,165,187,210,126,158,36,58,236,162,36,20,248,239,254,81,241,25,172,162,71,149,152,170,72,252,221,0,96,60,94,184,74,141,22,226,88,213,63,164,161,115,247,173,66,124,193,64,28,191,75,202,81,190,222,182,48,140,169,218,222,5,163,109,131,195,112,142,41,18,199,121,203,241,226,212,168,174,59,26,43,150,182,228,23,65,12,141,118,172,231,128,225,38,251,202,75,61,200,58,65,8,2,1,192,192],"hint":2},{"address":[12,123,121,250,222,146,202,217,43,223,150,222,4,192,233,67,254,8,241,2,201,202,39,101,64,58,159,165,187,210,126,158],"bytes":[208,1,1,148,23,0,23,176,23,17,23,18,19,130,7,0,7,176,64,0,16,1,113,33,0,1,16,1,36,58,236,162,36,20,248,239,254,81,241,25,172,162,71,149,152,170,72,252,221,0,96,60,94,184,74,141,22,226,88,213,2,1,192,192],"hint":4294967295},{"address":[12,233,210,122,204,93,107,209,245,173,188,23,77,72,97,124,252,67,223,107,211,227,73,136,93,215,165,81,60,34,58,251],"bytes":[208,9,0,147,23,176,23,176,23,115,177,32,5,17,16,115,177,32,4,18,113,32,2,17,130,7,176,7,176,114,32,3,17,16,2,32,1,113,33,0,0,176,6,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,151,132,217,203,192,166,42,149,193,109,208,0,206,72,203,57,80,119,186,178,120,104,47,33,60,16,108,141,97,80,185,190,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,1,0],"hint":0},{"address":[13,164,236,55,143,162,108,181,30,92,168,197,143,189,39,148,70,134,138,146,30,47,20,251,22,117,74,68,17,136,107,88],"bytes":[212,0,0,146,194,55,231,109,147,194,91,13,188,71,161,129,233,45,95,151,125,192,100,196,92,160,161,88,243,232,52,165,168,24,28,0,0,0],"hint":0},{"address":[14,140,157,90,31,226,163,144,223,50,193,100,1,212,239,112,30,85,166,100,127,243,255,35,237,59,47,103,30,124,173,51],"bytes":[208,1,0,146,23,176,23,176,176,130,7,176,7,176,117,33,11,1,176,178,114,32,8,177,16,129,7,178,117,32,2,17,16,113,32,5,18,18,113,32,6,18,129,7,113,32,0,178,18,3,32,4,115,33,9,0,176,99,113,32,10,99,116,33,1,0,176,32,7,177,16,12,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,35,3,107,242,16,62,77,46,221,118,183,89,205,206,176,124,5,155,123,120,198,200,166,96,11,7,5,144,220,84,160,0,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,127,96,33,226,23,139,62,99,123,68,50,158,52,254,48,20,156,40,131,171,199,254,37,234,170,171,3,154,196,227,32,26,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,175,88,107,7,84,110,31,202,154,176,120,13,28,35,106,248,211,96,196,198,187,50,187,12,208,62,201,202,99,211,218,150,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,228,14,118,142,182,13,77,21,4,125,13,195,184,32,234,175,107,253,251,200,161,173,38,141,205,120,114,45,50,22,74,185,2,0,1,0],"hint":7},{"address":[14,200,11,50,76,111,121,99,77,96,33,233,109,24,91,177,12,15,75,189,90,245,126,49,204,203,166,161,60,9,82,32],"bytes":[208,1,1,149,23,178,23,176,23,176,23,179,23,180,114,20,19,18,133,7,178,7,176,7,176,7,179,7,180,116,33,3,2,129,7,176,114,21,16,19,19,113,17,18,129,7,176,116,17,177,16,114,33,8,1,176,177,19,5,32,1,113,32,2,16,146,23,176,23,176,2,145,23,176,114,19,115,33,6,0,176,96,113,32,7,96,16,148,23,176,23,176,23,115,33,5,1,176,17,177,23,176,114,23,116,33,4,1,176,19,113,32,2,18,17,16,9,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,182,220,11,199,86,34,109,106,155,97,123,80,196,32,194,215,188,232,123,172,0,190,98,252,113,59,251,67,56,68,102,156,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,212,148,220,96,19,134,186,142,143,11,113,31,230,42,45,96,171,96,198,72,140,140,246,206,151,121,110,188,58,213,254,251,3,0,1,0,192],"hint":4294967295},{"address":[17,21,123,195,137,143,6,227,230,242,202,131,65,30,253,13,67,184,132,107,87,210,246,8,142,24,243,68,125,220,59,40],"bytes":[208,1,0,146,23,0,23,176,32,4,130,7,0,7,176,117,33,3,1,17,129,7,113,32,5,17,32,4,16,129,7,113,32,0,17,32,2,129,7,17,32,1,1,113,32,5,16,6,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,221,161,43,203,51,7,39,246,223,184,22,188,151,82,170,189,5,32,230,81,91,121,252,138,90,158,113,56,102,244,198,62,226,94,101,45,187,137,181,227,90,47,36,47,238,235,72,46,81,100,226,84,85,25,67,11,61,9,70,223,255,235,63,98,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,2,0,1,0],"hint":3},{"address":[17,57,94,11,168,111,246,177,22,200,19,9,72,121,252,64,171,24,91,139,219,212,182,27,23,168,83,212,188,164,20,37],"bytes":[208,1,0,150,23,176,23,180,23,176,23,179,23,178,23,181,114,20,19,18,134,7,176,7,180,7,176,7,179,7,178,7,181,118,32,3,21,20,17,131,7,176,7,114,177,22,16,7,114,22,17,16,114,19,18,17,19,18,6,32,0,32,2,114,18,19,113,32,5,19,114,177,18,16,146,23,176,23,114,177,17,16,0,146,23,176,23,114,177,21,16,114,21,113,32,1,17,115,32,4,22,17,16,6,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,143,112,180,160,174,152,116,193,51,244,179,211,36,51,17,25,136,171,75,61,193,164,122,107,230,246,195,65,167,219,176,175,173,229,14,160,69,134,173,157,62,239,68,203,61,253,196,132,125,56,45,99,133,231,44,217,206,217,217,212,158,140,47,136,187,67,180,68,88,106,58,237,43,170,13,123,116,49,202,109,205,20,171,148,68,188,119,146,13,19,67,51,208,191,229,116,244,242,199,63,63,176,199,189,250,212,209,10,144,100,144,38,99,103,162,129,151,44,249,218,31,186,104,181,104,141,20,40,1,0],"hint":4294967295},{"address":[17,146,100,56,42,156,10,108,6,243,220,48,64,63,1,185,87,3,109,197,231,92,16,150,170,139,135,228,229,133,38,211],"bytes":[208,9,0,147,23,176,23,176,23,183,114,178,114,181,18,17,18,131,7,176,7,176,7,183,117,32,5,18,17,129,7,114,32,8,182,114,179,17,18,114,178,114,181,19,18,19,16,130,7,182,7,114,179,18,19,116,32,6,20,19,117,32,13,180,19,20,17,16,17,8,32,4,113,33,0,0,176,113,177,32,7,113,177,32,9,115,33,10,0,176,99,113,32,11,99,116,35,2,0,0,0,176,176,176,114,33,1,0,176,32,12,114,178,180,17,114,32,8,114,178,180,16,114,179,16,17,14,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,99,44,5,220,29,218,230,235,217,222,27,86,228,242,159,73,193,224,31,157,213,15,255,132,44,53,221,209,65,60,200,47,113,68,18,70,255,205,26,50,174,12,218,3,107,21,86,215,23,242,75,32,237,113,18,160,92,173,191,173,229,204,184,53,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,178,136,217,224,36,44,255,41,120,139,158,183,34,54,222,165,15,112,144,89,71,169,35,37,231,162,123,37,240,169,206,134,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,235,80,53,253,14,237,19,39,158,181,89,13,194,124,130,114,1,54,228,250,165,233,124,128,18,170,79,204,128,120,19,52,253,28,62,122,65,53,75,163,172,98,77,234,69,37,114,204,91,7,129,94,255,156,225,255,127,60,82,197,17,103,175,80,1,0],"hint":0},{"address":[17,171,191,152,100,129,197,58,33,200,203,33,238,37,129,174,98,56,174,219,236,21,249,114,149,157,8,107,239,26,25,133],"bytes":[208,1,0,146,23,176,23,176,176,130,7,176,7,176,117,33,2,1,130,7,176,7,176,176,17,16,129,7,176,115,33,10,0,176,99,113,32,11,99,132,7,176,7,176,7,115,33,9,1,176,17,113,32,5,16,7,176,117,33,6,1,176,116,33,0,0,176,32,8,16,19,114,32,7,16,19,114,32,1,19,16,19,1,32,4,12,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,14,140,157,90,31,226,163,144,223,50,193,100,1,212,239,112,30,85,166,100,127,243,255,35,237,59,47,103,30,124,173,51,14,200,11,50,76,111,121,99,77,96,33,233,109,24,91,177,12,15,75,189,90,245,126,49,204,203,166,161,60,9,82,32,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,113,116,99,130,92,85,39,2,186,25,8,185,250,93,143,63,119,134,215,115,12,99,62,65,216,211,128,147,159,238,183,72,123,182,89,135,102,113,224,61,7,49,196,86,232,148,206,158,111,125,232,37,10,180,174,112,17,61,192,142,36,83,33,39,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,2,0,1,0],"hint":8},{"address":[17,198,157,44,229,108,78,127,200,211,19,164,228,97,121,43,44,89,248,48,208,180,61,255,199,56,2,225,15,168,240,154],"bytes":[212,0,0,73,182,34,112,168,74,185,8,87,208,141,25,200,37,182,37,211,78,55,245,209,136,145,191,236,160,41,156,245,37,61,20,0,0,0],"hint":0},{"address":[18,8,169,241,65,177,159,66,67,188,234,107,210,102,217,106,23,170,74,68,29,97,144,21,119,44,156,181,114,34,96,92],"bytes":[208,1,1,145,23,0,0,129,7,0,16,0,0,1,192],"hint":2},{"address":[19,44,22,70,108,13,131,176,21,217,17,234,193,117,7,178,214,81,243,139,41,186,248,144,186,132,223,237,94,242,252,202],"bytes":[208,1,2,149,23,0,23,182,23,180,23,183,23,184,0,113,19,18,133,7,0,7,182,7,180,7,183,7,184,0,117,34,4,2,1,177,129,7,181,113,20,16,18,113,17,32,2,130,7,177,7,113,176,179,114,18,17,16,9,33,1,1,113,176,20,113,176,19,113,176,21,113,176,113,176,17,113,176,177,145,23,113,176,113,176,16,2,145,23,32,3,113,18,113,33,0,1,178,146,23,178,23,181,113,20,115,33,5,1,179,17,16,6,57,148,188,81,227,104,111,48,161,212,131,214,157,10,131,90,123,72,77,137,35,147,192,132,248,122,88,73,222,84,243,2,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,120,192,56,5,248,234,247,211,103,224,245,121,9,171,213,102,217,74,43,235,207,98,112,254,47,231,74,249,84,237,13,0,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,150,145,212,243,57,243,164,63,121,161,201,51,86,245,77,129,59,198,227,235,59,233,116,46,93,47,105,5,167,53,185,3,179,167,216,2,73,253,130,49,0,238,3,98,98,50,209,65,42,14,131,53,39,93,93,245,59,146,148,56,135,182,80,247,3,1,192,192,193],"hint":4294967295},{"address":[21,82,189,84,69,166,57,241,90,253,231,25,173,73,94,73,40,27,198,238,195,105,239,14,99,135,203,177,190,110,228,82],"bytes":[193,1,0,0,0,0,0,2,0,0,0,0,0,176,0,0,1,0,1,145,23,176,176,1,48,0,0,1,1,0],"hint":0},{"address":[21,112,2,29,141,231,220,71,99,83,190,161,151,71,236,156,143,5,227,232,232,203,120,174,184,250,211,156,80,44,225,41],"bytes":[208,1,0,150,23,176,23,176,23,184,0,23,183,23,184,1,23,184,2,113,19,18,134,7,176,7,176,7,184,0,7,183,7,184,1,7,184,2,118,32,6,179,180,129,7,114,181,179,180,113,20,16,18,129,7,179,113,18,16,129,7,180,113,17,16,11,32,3,113,33,5,1,176,114,33,0,0,176,32,4,114,177,20,21,114,178,20,21,32,7,114,178,19,20,114,181,114,177,17,18,114,178,17,18,145,23,114,181,114,177,16,17,114,178,16,17,0,145,23,114,177,18,19,113,18,115,32,2,114,177,19,20,182,16,145,23,182,113,19,115,32,1,179,180,16,8,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,32,234,41,58,99,89,72,84,125,46,246,57,166,36,225,101,13,83,239,74,167,10,58,241,65,182,82,242,79,201,191,201,50,89,126,57,173,237,230,209,52,157,9,99,176,1,64,85,216,72,202,85,170,153,42,210,230,160,81,203,112,115,22,66,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,225,144,38,208,210,235,131,138,90,222,61,142,38,34,204,35,242,166,62,92,6,39,219,146,51,97,49,51,84,225,221,246,227,202,247,231,13,241,107,26,110,135,74,200,103,132,25,81,105,132,248,209,230,141,36,208,221,153,6,42,242,14,140,234,2,0,1,0],"hint":4294967295},{"address":[21,206,249,241,190,151,131,132,141,36,79,136,177,164,74,85,50,125,29,43,77,181,239,5,123,162,169,144,65,183,33,65],"bytes":[208,9,0,149,23,176,23,176,23,184,4,23,176,23,113,182,19,114,180,117,177,19,18,20,17,16,19,131,7,176,7,176,7,184,4,116,33,16,0,129,7,176,184,9,130,7,176,7,113,182,178,116,33,23,0,114,180,17,178,114,180,117,177,19,18,178,17,16,19,16,113,32,12,17,132,7,176,7,184,9,7,176,7,113,182,113,32,7,18,161,7,114,180,116,184,0,181,184,1,129,7,181,117,177,22,21,20,184,5,184,6,129,7,184,3,18,21,118,32,8,21,17,129,7,113,32,22,181,114,180,116,184,0,183,16,184,8,184,7,22,184,1,129,7,181,114,19,184,5,184,6,129,7,184,3,115,32,14,22,116,184,0,183,114,32,11,183,16,184,8,184,7,16,16,18,18,32,6,32,3,32,21,113,33,1,0,176,113,179,32,13,115,179,32,15,21,17,113,180,16,115,179,32,15,22,18,113,33,19,1,176,114,32,9,21,17,116,35,4,0,0,0,176,176,176,114,33,2,0,176,32,20,113,32,0,181,114,180,115,33,17,0,176,101,113,32,18,101,16,114,184,2,18,22,118,32,10,18,22,20,21,16,17,129,7,113,32,0,183,19,129,7,183,117,177,23,22,21,114,184,2,19,23,118,32,10,19,23,21,22,16,18,146,23,176,23,113,182,17,114,180,117,177,20,19,18,17,16,20,24,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,35,3,107,242,16,62,77,46,221,118,183,89,205,206,176,124,5,155,123,120,198,200,166,96,11,7,5,144,220,84,160,0,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,121,146,78,60,79,192,6,120,35,234,226,4,119,232,5,173,79,86,125,253,73,93,210,184,85,252,91,55,97,190,92,161,123,182,89,135,102,113,224,61,7,49,196,86,232,148,206,158,111,125,232,37,10,180,174,112,17,61,192,142,36,83,33,39,139,123,54,247,176,117,50,42,91,202,116,89,16,34,227,81,167,157,230,116,45,88,171,50,18,192,247,253,51,230,140,46,140,192,225,54,12,27,41,16,141,171,61,97,114,231,252,232,169,170,150,64,218,164,187,233,155,161,48,93,150,35,98,75,158,228,28,253,65,199,27,193,180,132,225,109,179,108,138,29,91,31,154,143,216,215,230,132,25,20,242,46,137,241,157,156,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,184,66,204,67,88,17,89,78,71,158,34,36,117,207,187,248,81,165,194,113,45,86,65,209,204,31,74,230,9,128,237,89,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,200,50,46,3,213,88,248,90,142,220,127,230,133,36,1,56,128,173,11,188,183,220,137,1,54,210,71,21,75,35,9,146,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,228,14,118,142,182,13,77,21,4,125,13,195,184,32,234,175,107,253,251,200,161,173,38,141,205,120,114,45,50,22,74,185,235,80,53,253,14,237,19,39,158,181,89,13,194,124,130,114,1,54,228,250,165,233,124,128,18,170,79,204,128,120,19,52,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,247,154,238,65,62,228,123,177,250,111,32,39,251,4,239,21,151,135,26,64,134,212,33,124,255,73,19,250,29,106,224,186,2,0,1,0],"hint":0},{"address":[23,28,138,233,37,6,143,6,176,45,1,57,84,157,86,128,52,221,140,123,97,223,123,219,80,48,211,53,10,54,119,118],"bytes":[214,0,120,108,139,241,102,165,140,25,16,248,4,47,230,115,196,20,77,48,174,2,242,156,174,177,207,76,184,128,156,70,172,147,0,0,0],"hint":0},{"address":[23,50,153,199,110,250,130,230,137,33,10,9,228,154,208,156,20,238,17,8,242,218,141,53,94,249,51,59,21,131,161,213],"bytes":[208,1,1,146,23,0,23,16,17,130,7,0,7,16,16,0,0,1,192],"hint":2},{"address":[25,134,155,57,9,150,155,120,176,235,163,138,14,162,252,217,208,21,113,131,31,60,236,184,157,206,95,175,197,12,127,94],"bytes":[212,0,0,34,201,222,43,147,254,79,70,12,159,115,3,58,93,55,75,147,234,243,131,153,7,138,61,199,233,17,59,180,11,201,127,0,0,0],"hint":0},{"address":[26,115,12,44,14,68,98,100,170,40,28,43,76,150,49,57,152,157,103,233,119,174,173,232,184,8,38,223,218,225,167,223],"bytes":[193,1,0,0,0,0,0,1,0,0,0,0,2,146,23,32,0,23,113,32,1,16,48,0,0,2,180,168,196,184,204,231,183,63,134,178,84,245,163,33,130,122,234,156,175,40,8,53,242,193,230,56,84,84,238,168,199,233,180,208,177,144,189,129,101,166,114,234,123,206,234,18,44,32,169,186,21,184,142,42,46,21,73,91,9,217,180,90,202,193,1,1,0],"hint":0},{"address":[28,198,170,57,66,155,94,154,215,67,234,247,227,38,134,154,148,23,219,188,113,182,19,23,101,3,43,107,88,39,70,117],"bytes":[208,1,0,148,23,177,23,176,23,179,23,178,113,19,18,132,7,177,7,176,7,179,7,178,116,33,5,0,129,7,176,113,20,16,18,113,17,32,3,129,7,176,113,17,16,4,32,1,145,23,176,0,145,23,176,113,19,113,32,2,16,145,23,32,4,113,18,115,33,6,0,176,96,113,32,7,96,8,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,120,192,56,5,248,234,247,211,103,224,245,121,9,171,213,102,217,74,43,235,207,98,112,254,47,231,74,249,84,237,13,0,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,1,0],"hint":4294967295},{"address":[30,26,43,187,25,32,237,74,18,129,163,222,202,100,106,211,19,202,156,123,247,234,189,195,101,89,135,121,124,204,12,85],"bytes":[214,0,76,98,201,118,89,139,255,180,43,124,201,210,127,20,162,152,110,242,136,41,19,36,136,96,210,27,190,27,120,145,216,15,0,0,0],"hint":0},{"address":[31,18,131,103,83,217,53,237,140,231,225,212,60,28,82,226,220,167,42,91,72,133,111,19,221,172,215,202,222,15,102,64],"bytes":[208,1,1,149,23,177,23,176,23,176,23,179,23,178,114,20,19,18,133,7,177,7,176,7,176,7,179,7,178,116,33,3,1,129,7,176,114,21,20,16,18,113,17,19,129,7,176,114,17,20,16,4,32,1,146,23,176,23,176,1,146,23,176,23,176,114,21,17,113,32,2,16,145,23,176,114,19,16,115,33,4,0,176,96,113,32,5,96,6,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,2,0,192],"hint":4294967295},{"address":[31,121,87,27,44,86,181,43,106,25,85,4,186,217,8,87,49,247,39,197,233,209,1,70,107,238,40,134,42,71,245,88],"bytes":[208,1,0,145,23,177,178,130,7,177,7,176,117,34,4,1,0,32,1,129,7,177,178,17,32,2,16,3,32,3,113,33,0,0,32,1,145,23,176,176,5,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,98,178,194,235,79,232,199,133,128,191,119,139,254,148,198,236,44,203,37,211,8,54,159,192,13,135,184,133,238,190,83,72,140,144,196,12,253,125,34,204,181,245,121,54,146,175,250,28,77,229,72,20,221,162,159,28,135,75,87,190,246,114,17,134,154,222,24,249,71,95,80,187,218,209,195,211,226,6,199,177,22,169,133,38,75,236,35,35,223,17,81,230,198,53,60,5,177,106,62,1,119,218,180,42,13,198,152,147,9,17,228,149,237,65,8,85,137,83,220,248,170,40,77,157,38,176,63,233,2,0,1,0],"hint":5},{"address":[31,181,154,127,225,27,53,79,1,145,116,89,241,61,225,54,55,151,173,12,23,60,111,134,41,121,101,6,10,234,138,44],"bytes":[212,0,0,204,11,12,125,104,59,140,39,187,187,118,189,216,164,52,197,64,173,97,121,230,146,173,101,36,15,117,177,164,114,60,45,0,0,0],"hint":0},{"address":[32,28,102,93,27,115,0,58,220,95,221,174,209,234,36,234,183,127,42,85,28,141,235,53,132,213,132,25,124,51,174,187],"bytes":[209,0,0,2,0,1,2,150,23,0,23,0,23,176,23,177,23,178,23,114,32,2,20,19,113,19,16,2,1,134,7,0,7,0,7,176,7,177,7,178,7,20,113,18,16,1,134,7,0,7,0,7,176,7,177,7,178,7,19,113,17,16,3,145,23,114,32,2,17,16,0,145,23,18,113,17,115,32,1,19,18,16,145,23,18,113,18,115,32,0,20,19,16,3,32,234,41,58,99,89,72,84,125,46,246,57,166,36,225,101,13,83,239,74,167,10,58,241,65,182,82,242,79,201,191,201,50,89,126,57,173,237,230,209,52,157,9,99,176,1,64,85,216,72,202,85,170,153,42,210,230,160,81,203,112,115,22,66,227,202,247,231,13,241,107,26,110,135,74,200,103,132,25,81,105,132,248,209,230,141,36,208,221,153,6,42,242,14,140,234,1,0],"hint":0},{"address":[32,40,229,141,134,249,165,75,158,83,196,244,32,27,83,204,172,130,78,42,55,51,160,111,244,198,164,61,93,133,155,81],"bytes":[208,1,1,147,23,2,23,176,23,176,2,131,7,2,7,176,7,176,115,177,17,115,177,16,145,23,18,19,129,7,176,19,129,7,176,115,177,17,19,129,7,176,145,23,145,23,115,33,2,0,176,17,16,21,21,2,32,0,113,33,1,1,129,7,176,2,3,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,3,1,0,1,192,192],"hint":4294967295},{"address":[32,217,139,252,39,149,55,152,200,20,2,45,71,255,113,205,190,106,103,51,155,35,71,203,255,82,186,185,0,162,246,141],"bytes":[208,1,1,148,23,0,23,176,23,17,23,32,1,19,130,7,0,7,176,64,0,16,1,113,33,0,1,16,2,23,28,138,233,37,6,143,6,176,45,1,57,84,157,86,128,52,221,140,123,97,223,123,219,80,48,211,53,10,54,119,118,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,2,1,192,192],"hint":4294967295},{"address":[32,234,41,58,99,89,72,84,125,46,246,57,166,36,225,101,13,83,239,74,167,10,58,241,65,182,82,242,79,201,191,201],"bytes":[212,0,1,165,58,3,50,179,58,5,167,174,109,148,154,213,173,224,59,213,27,245,170,164,198,0,195,130,85,237,186,156,179,30,42,0,0,0],"hint":0},{"address":[34,22,37,160,14,226,214,185,98,151,227,77,126,5,191,126,79,211,141,141,153,211,225,214,74,124,210,224,108,160,117,45],"bytes":[214,0,73,182,34,112,168,74,185,8,87,208,141,25,200,37,182,37,211,78,55,245,209,136,145,191,236,160,41,156,245,37,61,20,0,0,0],"hint":0},{"address":[34,188,206,129,171,151,91,110,227,170,108,194,69,113,177,50,138,249,169,239,200,164,15,214,191,105,88,120,228,81,106,107],"bytes":[208,1,0,152,0,23,176,23,184,1,23,184,2,23,176,23,181,23,184,0,23,182,23,184,3,183,136,0,7,176,7,184,1,7,184,2,7,176,7,181,7,184,0,7,182,7,184,3,120,0,32,8,23,22,21,17,133,7,176,7,114,178,177,16,7,116,180,179,177,17,16,7,114,179,18,17,7,115,179,19,18,17,113,183,17,20,19,18,12,32,0,24,0,32,2,24,1,32,5,114,178,19,16,115,19,21,113,32,6,21,114,32,4,21,20,115,21,20,19,18,116,180,20,19,17,16,146,23,176,23,114,178,17,16,0,147,23,176,23,114,178,18,16,23,116,180,19,18,17,16,0,148,23,176,23,114,178,23,16,23,116,180,177,23,17,16,23,114,177,18,17,115,177,113,32,1,19,115,32,3,24,2,19,18,118,32,7,24,2,179,19,18,17,16,9,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,143,112,180,160,174,152,116,193,51,244,179,211,36,51,17,25,136,171,75,61,193,164,122,107,230,246,195,65,167,219,176,175,187,67,180,68,88,106,58,237,43,170,13,123,116,49,202,109,205,20,171,148,68,188,119,146,13,19,67,51,208,191,229,116,212,242,86,44,127,148,111,155,110,164,100,223,38,78,46,178,220,160,215,184,60,235,121,164,78,31,105,70,61,221,236,0,218,224,24,9,166,175,10,253,129,230,253,211,161,211,159,239,134,168,168,196,233,8,24,177,163,87,225,128,221,218,178,89,244,242,199,63,63,176,199,189,250,212,209,10,144,100,144,38,99,103,162,129,151,44,249,218,31,186,104,181,104,141,20,40,246,128,13,148,231,34,20,133,128,99,68,60,242,66,168,9,86,193,105,174,52,239,213,78,213,211,91,48,17,10,201,204,251,123,94,98,97,36,207,110,50,255,172,240,28,176,159,60,222,84,163,60,149,219,95,212,138,134,185,17,5,244,201,47,1,0],"hint":4294967295},{"address":[34,201,222,43,147,254,79,70,12,159,115,3,58,93,55,75,147,234,243,131,153,7,138,61,199,233,17,59,180,11,201,127],"bytes":[193,1,0,1,1,0,145,23,1,1,1,0,1,0,1,1,146,23,1,23,146,23,16,23,17,0,113,49,0,2,17,0,0,3,0,1,192,192],"hint":0},{"address":[35,3,107,242,16,62,77,46,221,118,183,89,205,206,176,124,5,155,123,120,198,200,166,96,11,7,5,144,220,84,160,0],"bytes":[208,1,0,147,23,176,23,179,23,176,180,133,7,176,7,179,7,176,7,176,7,178,117,33,7,1,129,7,176,180,18,114,32,1,20,19,17,16,5,32,3,114,33,0,0,176,32,4,114,177,16,17,114,177,115,33,5,0,176,98,113,32,6,98,16,146,23,176,23,178,176,8,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,6,181,53,250,160,34,165,49,126,121,184,243,251,101,120,161,62,234,9,141,151,244,239,16,210,170,46,245,180,2,164,244,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,2,0,1,0],"hint":6},{"address":[36,58,236,162,36,20,248,239,254,81,241,25,172,162,71,149,152,170,72,252,221,0,96,60,94,184,74,141,22,226,88,213],"bytes":[214,0,236,23,58,211,91,233,215,92,47,21,16,249,84,129,66,64,39,236,1,24,107,195,240,22,160,63,4,102,78,84,112,214,0,0,0],"hint":0},{"address":[36,183,15,65,153,47,84,55,74,119,14,36,170,158,252,234,30,72,46,231,154,204,3,245,158,190,102,159,225,169,75,182],"bytes":[208,1,1,148,23,1,23,1,23,177,23,17,19,132,7,1,7,1,7,177,7,17,118,34,2,1,0,1,18,130,7,1,7,114,176,19,16,17,16,19,116,33,0,0,1,19,18,17,2,113,33,1,0,1,114,176,17,16,3,91,200,186,175,28,224,243,100,229,66,105,233,238,44,132,68,97,202,69,3,36,117,189,206,82,109,133,255,87,20,28,101,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,251,3,245,167,225,65,216,64,37,179,165,3,222,220,83,206,134,242,151,189,227,107,188,27,152,104,122,234,180,53,153,104,2,1,192,192],"hint":2},{"address":[36,214,98,101,106,41,65,247,131,125,73,197,70,115,110,203,79,161,94,171,159,108,160,154,175,27,191,200,18,146,227,129],"bytes":[193,1,0,0,2,2,148,23,176,23,178,23,176,23,179,0,2,0,0,0,2,0,146,23,176,23,178,116,177,17,16,17,113,32,4,17,0,0,1,2,4,150,23,176,23,178,23,176,23,179,23,116,177,19,18,17,16,23,114,19,18,17,116,177,21,20,113,32,1,19,115,32,3,21,19,18,4,32,0,48,0,146,23,176,23,114,32,2,17,16,0,114,32,2,18,16,5,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,143,112,180,160,174,152,116,193,51,244,179,211,36,51,17,25,136,171,75,61,193,164,122,107,230,246,195,65,167,219,176,175,187,67,180,68,88,106,58,237,43,170,13,123,116,49,202,109,205,20,171,148,68,188,119,146,13,19,67,51,208,191,229,116,244,242,199,63,63,176,199,189,250,212,209,10,144,100,144,38,99,103,162,129,151,44,249,218,31,186,104,181,104,141,20,40,1,0],"hint":0},{"address":[38,5,219,172,27,194,105,86,16,103,79,203,209,251,125,25,3,153,197,126,133,74,51,92,106,129,243,119,122,174,236,3],"bytes":[212,0,0,120,108,139,241,102,165,140,25,16,248,4,47,230,115,196,20,77,48,174,2,242,156,174,177,207,76,184,128,156,70,172,147,0,0,0],"hint":0},{"address":[38,19,240,10,77,89,35,190,7,115,135,206,235,135,240,254,104,205,54,26,233,135,189,129,142,6,111,96,66,38,76,23],"bytes":[208,1,0,145,23,176,176,129,7,176,116,33,3,0,129,7,176,176,16,96,129,7,176,98,1,32,1,4,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,72,252,114,31,187,193,114,224,146,95,162,122,241,103,29,226,37,186,146,113,52,128,41,152,177,10,21,104,161,136,101,43,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,1,1,0],"hint":2},{"address":[38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197],"bytes":[208,1,3,150,23,0,23,1,23,176,23,177,23,19,23,19,19,132,7,0,7,1,7,176,7,177,64,1,16,2,113,33,0,3,2,115,35,1,4,5,6,18,17,16,2,18,8,169,241,65,177,159,66,67,188,234,107,210,102,217,106,23,170,74,68,29,97,144,21,119,44,156,181,114,34,96,92,63,164,161,115,247,173,66,124,193,64,28,191,75,202,81,190,222,182,48,140,169,218,222,5,163,109,131,195,112,142,41,18,7,1,192,1,193,1,194,2,194,192,193,194],"hint":4294967295},{"address":[38,153,238,144,4,59,30,221,27,58,195,34,215,85,208,51,39,92,169,211,103,255,33,72,66,164,23,231,126,149,100,87],"bytes":[208,9,0,145,23,176,177,129,7,176,115,33,6,0,129,7,176,177,16,32,1,2,32,0,115,33,4,1,32,5,114,32,2,16,16,32,3,7,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,149,112,21,214,81,135,110,29,189,94,143,252,57,16,133,238,118,179,215,31,82,157,215,208,149,66,17,86,87,125,38,164,158,68,91,157,95,130,82,119,35,71,135,46,144,155,93,180,231,236,167,8,108,237,244,254,198,222,132,15,107,123,95,146,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,2,0,1,0],"hint":0},{"address":[40,31,185,246,89,203,215,51,143,227,241,144,88,119,89,157,240,255,94,122,211,158,188,80,96,47,215,211,224,232,17,19],"bytes":[208,1,2,150,23,0,23,179,23,177,23,18,23,180,23,181,114,20,19,18,134,7,0,7,179,7,177,7,18,7,180,7,181,117,34,2,2,1,21,129,7,178,114,21,16,19,19,113,17,18,130,7,21,7,113,176,22,115,18,17,16,20,6,33,1,1,113,176,17,113,176,21,146,23,113,176,16,23,17,2,145,23,19,114,19,113,33,0,1,20,16,147,23,20,23,178,23,22,114,22,115,33,3,1,23,18,17,16,4,57,148,188,81,227,104,111,48,161,212,131,214,157,10,131,90,123,72,77,137,35,147,192,132,248,122,88,73,222,84,243,2,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,150,145,212,243,57,243,164,63,121,161,201,51,86,245,77,129,59,198,227,235,59,233,116,46,93,47,105,5,167,53,185,3,179,167,216,2,73,253,130,49,0,238,3,98,98,50,209,65,42,14,131,53,39,93,93,245,59,146,148,56,135,182,80,247,3,1,192,192,193],"hint":4294967295},{"address":[41,127,249,85,100,178,96,167,6,74,210,67,66,113,229,76,4,196,152,70,218,146,228,158,164,59,100,217,127,240,115,188],"bytes":[208,9,0,145,23,176,116,33,0,0,176,32,3,16,113,32,2,16,129,7,176,115,32,4,16,16,113,32,5,16,1,32,1,6,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,187,67,180,68,88,106,58,237,43,170,13,123,116,49,202,109,205,20,171,148,68,188,119,146,13,19,67,51,208,191,229,116,244,242,199,63,63,176,199,189,250,212,209,10,144,100,144,38,99,103,162,129,151,44,249,218,31,186,104,181,104,141,20,40,1,0],"hint":0},{"address":[43,202,5,250,198,182,69,247,162,191,157,95,245,85,89,96,142,4,117,134,81,208,50,79,96,133,33,130,34,227,128,101],"bytes":[208,9,0,148,23,0,23,0,23,176,23,177,32,2,132,7,0,7,0,7,176,7,177,113,17,115,32,1,19,18,16,2,113,32,0,17,114,32,3,18,17,4,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,44,143,65,63,190,14,22,146,196,183,75,73,154,5,58,163,129,184,26,202,54,110,200,246,138,183,128,3,117,230,175,145,161,35,96,69,20,10,194,171,190,21,41,88,52,132,52,251,132,73,101,150,249,252,93,203,189,88,91,129,116,196,57,39,178,136,217,224,36,44,255,41,120,139,158,183,34,54,222,165,15,112,144,89,71,169,35,37,231,162,123,37,240,169,206,134,1,0],"hint":0},{"address":[44,143,65,63,190,14,22,146,196,183,75,73,154,5,58,163,129,184,26,202,54,110,200,246,138,183,128,3,117,230,175,145],"bytes":[208,9,0,147,23,0,23,0,23,176,18,131,7,0,7,0,7,176,64,0,16,1,114,32,0,17,16,1,178,136,217,224,36,44,255,41,120,139,158,183,34,54,222,165,15,112,144,89,71,169,35,37,231,162,123,37,240,169,206,134,1,0],"hint":0},{"address":[44,210,22,204,18,194,70,222,246,220,17,80,137,168,196,54,74,87,104,206,0,177,225,137,227,247,110,45,215,138,62,35],"bytes":[208,1,1,147,23,178,23,176,23,179,113,18,17,131,7,178,7,176,7,179,115,33,2,1,18,129,7,177,113,17,16,17,4,32,3,113,33,0,0,32,1,145,23,176,1,145,23,177,113,18,113,32,4,16,5,55,29,38,88,218,150,252,157,177,26,21,63,193,156,198,191,199,146,188,252,190,78,141,234,34,46,212,221,41,186,89,205,98,178,194,235,79,232,199,133,128,191,119,139,254,148,198,236,44,203,37,211,8,54,159,192,13,135,184,133,238,190,83,72,152,53,11,226,249,31,219,85,75,135,68,141,67,47,176,27,55,221,21,34,93,154,144,164,137,89,109,137,96,32,102,161,154,222,24,249,71,95,80,187,218,209,195,211,226,6,199,177,22,169,133,38,75,236,35,35,223,17,81,230,198,53,60,5,252,82,100,111,177,136,75,195,148,65,19,16,182,120,92,58,241,175,36,162,134,0,106,248,159,179,39,233,159,151,170,22,2,0,192],"hint":4294967295},{"address":[45,19,228,58,195,126,10,0,196,137,134,174,19,136,22,187,23,71,24,37,9,25,206,46,51,165,37,169,228,106,153,234],"bytes":[208,1,0,113,33,0,0,32,1,114,33,3,0,32,1,32,2,0,4,36,58,236,162,36,20,248,239,254,81,241,25,172,162,71,149,152,170,72,252,221,0,96,60,94,184,74,141,22,226,88,213,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,55,59,125,116,246,180,13,161,27,126,215,150,3,164,94,199,1,26,136,49,183,32,181,125,46,254,146,232,42,61,87,240,148,77,150,214,42,122,160,96,153,65,92,165,175,218,48,241,66,199,14,18,254,189,182,209,85,174,176,172,85,8,152,64,1,0],"hint":4},{"address":[45,146,134,208,64,215,133,108,174,176,110,188,41,30,135,83,226,230,8,38,174,193,97,4,162,5,86,221,33,31,79,159],"bytes":[208,1,0,146,23,176,23,179,177,131,7,176,7,179,7,176,120,0,33,6,0,130,7,176,7,176,145,23,113,178,17,32,8,18,16,130,7,32,3,7,180,32,5,130,7,176,7,180,32,7,130,7,176,7,113,178,113,32,1,16,32,7,131,7,176,7,176,7,113,178,113,32,1,17,113,64,2,16,17,17,5,32,0,145,23,176,32,8,113,33,4,0,129,7,176,177,113,178,16,113,178,32,9,10,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,212,206,220,104,102,212,61,230,187,167,17,118,228,84,101,185,106,118,79,1,199,64,218,16,151,169,247,119,95,212,111,164,221,161,43,203,51,7,39,246,223,184,22,188,151,82,170,189,5,32,230,81,91,121,252,138,90,158,113,56,102,244,198,62,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,1,1,0],"hint":4294967295},{"address":[45,252,22,175,1,184,43,59,145,194,255,112,68,9,215,98,54,168,63,149,108,12,110,102,89,166,79,226,29,118,105,91],"bytes":[214,0,50,242,172,147,14,116,84,169,40,68,47,88,105,234,131,149,8,103,39,203,220,62,157,236,213,65,3,84,154,77,218,100,0,0,0],"hint":0},{"address":[46,9,7,238,235,104,44,32,206,121,51,219,11,245,134,162,84,104,106,166,238,223,205,88,1,226,255,221,206,41,202,65],"bytes":[208,1,0,152,0,23,184,7,23,176,23,176,23,184,1,23,184,4,23,184,5,23,184,6,23,184,8,115,23,22,21,20,136,0,7,184,7,7,176,7,176,7,184,1,7,184,4,7,184,5,7,184,6,7,184,8,117,183,129,7,176,145,23,114,178,16,22,115,24,1,17,23,16,22,129,7,113,182,21,117,183,129,7,176,145,23,113,182,16,115,24,2,177,17,16,22,129,7,184,2,113,21,16,130,7,176,7,184,3,114,21,17,16,16,130,7,176,7,114,178,180,22,117,183,129,7,176,145,23,114,178,184,0,16,115,24,3,113,179,19,17,16,23,129,7,114,178,181,177,114,20,18,16,130,7,176,7,114,178,184,0,180,115,20,19,17,16,16,20,17,32,1,32,5,114,33,0,0,176,32,4,32,2,113,179,16,113,179,17,113,178,177,33,3,0,113,179,18,114,178,17,16,113,182,177,113,182,180,145,23,184,2,115,20,177,177,16,146,23,176,23,184,3,115,22,177,181,16,146,23,176,23,114,178,180,177,115,23,181,177,16,147,23,176,23,176,23,184,1,0,147,23,176,23,176,23,114,178,181,180,115,24,1,184,0,181,16,6,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,1,0],"hint":4294967295},{"address":[48,62,92,133,156,182,2,25,180,188,60,131,11,227,206,115,57,109,123,132,164,179,37,158,249,127,166,196,91,97,192,56],"bytes":[208,1,0,145,23,176,182,130,7,176,7,181,117,32,3,129,7,176,182,17,130,7,32,10,7,113,180,177,114,33,0,1,176,113,178,177,130,7,176,7,113,180,113,32,8,16,118,34,1,1,1,176,176,114,32,7,177,17,17,32,8,64,9,16,16,7,32,6,115,33,14,0,176,101,113,32,15,101,117,35,4,0,0,0,176,176,176,114,33,2,0,176,32,12,177,113,33,13,1,176,113,33,11,0,129,7,176,114,179,113,178,16,16,113,180,16,145,23,181,114,179,113,178,17,17,16,2,1,207,17,44,128,169,32,218,175,29,186,208,247,219,163,151,224,41,20,165,148,50,128,126,189,159,55,118,75,214,74,5,199,182,224,138,234,68,58,149,61,8,60,30,231,110,202,98,58,85,180,216,170,221,68,152,250,235,100,244,23,155,77,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,28,198,170,57,66,155,94,154,215,67,234,247,227,38,134,154,148,23,219,188,113,182,19,23,101,3,43,107,88,39,70,117,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,62,138,173,204,97,28,77,134,119,202,223,0,199,133,6,86,29,51,115,142,227,213,113,247,164,25,110,38,5,128,201,184,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,172,236,141,84,253,42,149,116,121,227,42,148,233,109,150,37,96,48,59,90,31,4,119,124,236,230,174,65,170,201,238,120,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,2,0,1,0],"hint":4294967295},{"address":[49,201,229,28,85,180,20,198,36,190,155,239,220,3,50,69,108,205,146,154,196,27,168,14,229,13,203,114,18,206,1,242],"bytes":[214,0,34,201,222,43,147,254,79,70,12,159,115,3,58,93,55,75,147,234,243,131,153,7,138,61,199,233,17,59,180,11,201,127,0,0,0],"hint":0},{"address":[50,68,104,115,1,215,121,236,117,114,116,118,29,144,61,239,62,179,19,81,119,50,123,112,155,203,216,84,239,73,111,121],"bytes":[208,1,0,145,23,176,176,129,7,176,116,33,5,1,129,7,176,176,16,129,7,32,2,115,33,3,0,176,96,113,32,4,96,129,7,176,16,1,32,1,6,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,254,151,194,209,128,155,98,73,123,114,24,233,54,53,80,136,220,22,237,127,20,28,103,136,201,83,126,133,111,54,178,226,2,0,1,0],"hint":3},{"address":[50,89,126,57,173,237,230,209,52,157,9,99,176,1,64,85,216,72,202,85,170,153,42,210,230,160,81,203,112,115,22,66],"bytes":[212,0,0,165,58,3,50,179,58,5,167,174,109,148,154,213,173,224,59,213,27,245,170,164,198,0,195,130,85,237,186,156,179,30,42,0,0,0],"hint":0},{"address":[50,242,172,147,14,116,84,169,40,68,47,88,105,234,131,149,8,103,39,203,220,62,157,236,213,65,3,84,154,77,218,100],"bytes":[193,1,0,1,0,0,0,1,0,1,0,0,0,49,0,0,0,0,1,192],"hint":0},{"address":[51,18,237,120,40,206,242,127,180,160,19,21,87,51,2,16,254,125,228,245,62,35,139,255,35,106,71,191,55,190,58,104],"bytes":[208,9,0,145,23,176,178,129,7,176,116,32,5,129,7,176,178,16,129,7,32,6,113,32,9,113,177,32,8,129,7,176,113,32,1,113,177,113,32,4,16,3,32,3,32,2,116,33,0,0,176,32,7,113,177,16,16,10,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,41,127,249,85,100,178,96,167,6,74,210,67,66,113,229,76,4,196,152,70,218,146,228,158,164,59,100,217,127,240,115,188,50,68,104,115,1,215,121,236,117,114,116,118,29,144,61,239,62,179,19,81,119,50,123,112,155,203,216,84,239,73,111,121,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,127,102,69,142,31,137,141,70,61,222,210,142,237,123,140,24,107,128,134,79,228,183,18,62,197,203,28,171,94,219,131,202,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,244,242,199,63,63,176,199,189,250,212,209,10,144,100,144,38,99,103,162,129,151,44,249,218,31,186,104,181,104,141,20,40,1,0],"hint":0},{"address":[51,52,114,218,81,164,158,201,126,219,71,65,146,239,73,222,114,22,130,75,39,118,45,50,83,218,125,44,223,39,73,206],"bytes":[208,1,0,145,23,176,32,4,129,7,176,113,32,5,116,34,6,0,0,32,0,32,2,32,3,16,1,113,33,1,0,32,0,7,6,95,200,180,19,147,245,37,193,229,65,185,212,188,151,194,12,19,191,35,167,32,154,32,147,182,244,82,115,48,17,74,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,98,178,194,235,79,232,199,133,128,191,119,139,254,148,198,236,44,203,37,211,8,54,159,192,13,135,184,133,238,190,83,72,132,147,219,244,185,115,159,176,245,9,36,27,253,226,235,26,132,121,236,124,91,215,133,170,248,33,27,167,133,11,126,20,154,222,24,249,71,95,80,187,218,209,195,211,226,6,199,177,22,169,133,38,75,236,35,35,223,17,81,230,198,53,60,5,179,59,142,103,87,122,243,6,163,52,27,123,216,94,231,85,2,234,140,32,208,30,84,96,196,38,22,117,138,251,137,184,255,131,252,50,174,0,106,5,53,100,74,163,253,112,17,187,161,157,183,70,104,173,84,222,26,223,166,137,22,238,221,157,1,0],"hint":14},{"address":[51,78,39,123,139,120,138,49,19,191,66,251,63,20,81,139,197,142,37,171,184,51,104,82,245,219,53,119,131,170,83,45],"bytes":[208,1,0,151,23,183,23,176,23,176,23,178,23,178,23,182,23,184,0,116,22,21,20,19,18,135,7,183,7,176,7,176,7,178,7,178,7,182,7,184,0,117,33,4,0,129,7,176,145,23,180,116,24,0,23,17,21,16,20,129,7,181,115,18,22,20,16,130,7,176,7,113,177,113,179,16,116,18,23,17,21,16,18,9,32,2,115,33,0,0,176,32,5,115,33,6,0,176,97,113,32,7,97,113,177,17,32,3,113,177,16,113,177,32,8,147,23,176,23,180,23,181,116,23,18,32,8,17,16,148,23,176,23,176,23,178,23,178,0,148,23,176,23,176,23,178,23,113,177,113,179,17,116,24,1,19,113,179,18,17,16,9,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,1,0],"hint":4294967295},{"address":[52,54,62,234,205,31,207,21,209,42,216,182,41,220,205,78,92,64,187,231,67,36,93,167,201,198,121,223,19,162,29,202],"bytes":[208,1,0,113,33,0,0,32,1,114,33,3,0,32,1,32,2,0,4,36,58,236,162,36,20,248,239,254,81,241,25,172,162,71,149,152,170,72,252,221,0,96,60,94,184,74,141,22,226,88,213,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,130,77,28,83,216,193,195,207,10,39,242,70,57,236,43,225,236,193,61,74,1,201,147,23,21,149,237,204,246,148,151,55,148,77,150,214,42,122,160,96,153,65,92,165,175,218,48,241,66,199,14,18,254,189,182,209,85,174,176,172,85,8,152,64,1,0],"hint":8},{"address":[53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188],"bytes":[214,0,21,82,189,84,69,166,57,241,90,253,231,25,173,73,94,73,40,27,198,238,195,105,239,14,99,135,203,177,190,110,228,82,0,0,0],"hint":0},{"address":[54,45,116,9,166,5,234,18,119,172,63,136,71,50,174,47,135,191,229,248,142,163,85,100,21,207,80,9,30,131,86,48],"bytes":[208,9,0,145,23,176,177,129,7,176,115,33,7,0,129,7,176,177,16,32,3,2,32,2,116,33,0,0,176,32,4,115,33,5,0,176,97,113,32,6,97,16,8,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,55,192,127,97,244,146,69,73,27,198,235,234,90,75,142,113,190,57,252,33,99,14,162,217,27,156,165,178,246,232,52,70,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,1,0],"hint":0},{"address":[54,61,7,17,130,190,65,78,26,88,89,155,131,245,225,159,155,135,55,35,5,79,66,135,186,105,112,90,175,239,39,218],"bytes":[212,0,1,9,29,40,138,180,96,173,98,252,118,250,245,55,121,6,220,159,184,166,65,211,232,175,73,90,14,209,70,210,138,217,109,0,0,0],"hint":0},{"address":[55,29,38,88,218,150,252,157,177,26,21,63,193,156,198,191,199,146,188,252,190,78,141,234,34,46,212,221,41,186,89,205],"bytes":[214,0,184,198,62,148,95,90,162,171,200,68,75,97,246,220,106,248,133,82,102,153,28,149,207,65,76,24,13,85,243,107,39,112,0,0,0],"hint":0},{"address":[55,59,125,116,246,180,13,161,27,126,215,150,3,164,94,199,1,26,136,49,183,32,181,125,46,254,146,232,42,61,87,240],"bytes":[208,1,0,145,23,176,177,130,7,176,7,176,116,33,2,0,129,7,176,177,16,32,1,17,2,32,0,145,23,176,176,3,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,147,74,116,228,235,198,149,135,216,64,209,83,170,17,11,168,129,219,222,78,51,220,92,163,171,6,228,194,85,17,42,181,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,1,1,0],"hint":3},{"address":[55,164,229,247,168,54,105,254,65,69,200,121,128,151,23,42,140,241,109,45,19,5,51,112,162,179,156,160,204,69,56,146],"bytes":[208,1,1,146,23,0,23,176,17,130,7,0,7,176,114,33,1,0,129,7,176,18,16,1,32,0,2,161,35,96,69,20,10,194,171,190,21,41,88,52,132,52,251,132,73,101,150,249,252,93,203,189,88,91,129,116,196,57,39,173,222,136,82,148,149,48,176,245,99,105,176,229,62,34,58,189,47,35,165,88,51,189,253,153,65,4,189,230,104,106,233,1,192],"hint":2},{"address":[55,192,127,97,244,146,69,73,27,198,235,234,90,75,142,113,190,57,252,33,99,14,162,217,27,156,165,178,246,232,52,70],"bytes":[208,1,0,145,23,176,181,130,7,176,7,180,117,32,4,129,7,176,181,17,130,7,32,6,7,113,179,32,12,113,32,13,177,130,7,176,7,113,179,113,32,3,16,115,32,9,177,17,64,5,16,16,6,32,2,115,33,10,0,176,97,113,32,11,97,115,33,0,0,176,32,8,177,113,33,7,0,129,7,176,113,178,16,113,179,16,145,23,180,113,178,17,14,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,127,102,69,142,31,137,141,70,61,222,210,142,237,123,140,24,107,128,134,79,228,183,18,62,197,203,28,171,94,219,131,202,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,187,67,180,68,88,106,58,237,43,170,13,123,116,49,202,109,205,20,171,148,68,188,119,146,13,19,67,51,208,191,229,116,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,244,242,199,63,63,176,199,189,250,212,209,10,144,100,144,38,99,103,162,129,151,44,249,218,31,186,104,181,104,141,20,40,1,0],"hint":4294967295},{"address":[57,106,200,100,213,170,98,76,193,241,114,201,124,222,57,35,140,200,34,160,37,143,33,86,52,21,95,220,196,159,228,20],"bytes":[208,9,0,146,23,176,23,176,114,179,114,177,17,16,17,130,7,176,7,176,116,33,10,0,129,7,176,180,113,32,8,114,177,17,32,12,130,7,176,7,180,117,32,0,114,177,19,113,32,7,17,178,19,113,32,5,178,16,16,5,32,6,116,35,4,0,0,0,176,176,176,114,33,3,0,176,32,11,114,32,1,19,17,114,33,2,0,176,32,9,114,179,114,177,18,16,18,13,1,52,162,6,154,222,214,241,18,20,204,33,47,37,177,194,163,224,207,41,103,92,148,75,153,178,28,90,2,159,76,39,3,179,160,65,40,91,15,226,2,217,11,34,125,64,92,76,236,37,45,241,139,167,97,106,205,109,174,39,146,230,114,187,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,51,18,237,120,40,206,242,127,180,160,19,21,87,51,2,16,254,125,228,245,62,35,139,255,35,106,71,191,55,190,58,104,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,96,216,116,231,204,103,223,155,196,38,250,152,158,223,135,142,180,37,214,16,87,76,159,105,22,153,73,21,72,244,10,91,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,200,50,46,3,213,88,248,90,142,220,127,230,133,36,1,56,128,173,11,188,183,220,137,1,54,210,71,21,75,35,9,146,235,80,53,253,14,237,19,39,158,181,89,13,194,124,130,114,1,54,228,250,165,233,124,128,18,170,79,204,128,120,19,52,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,1,0],"hint":0},{"address":[57,148,188,81,227,104,111,48,161,212,131,214,157,10,131,90,123,72,77,137,35,147,192,132,248,122,88,73,222,84,243,2],"bytes":[212,0,0,108,255,144,109,191,162,189,175,224,236,43,240,19,30,128,5,44,206,126,44,101,59,129,73,95,229,25,126,83,172,103,171,0,0,0],"hint":0},{"address":[57,226,177,52,39,60,228,186,35,11,80,230,171,31,164,52,150,81,152,112,119,136,39,157,210,113,219,190,19,192,70,164],"bytes":[208,1,0,145,23,32,2,32,1,129,7,32,2,114,32,6,115,33,3,0,32,1,96,113,32,4,96,113,32,5,16,0,7,0,38,60,169,245,127,113,119,244,149,227,113,31,140,221,89,150,122,10,26,77,232,149,177,235,238,86,108,209,136,62,212,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,180,168,196,184,204,231,183,63,134,178,84,245,163,33,130,122,234,156,175,40,8,53,242,193,230,56,84,84,238,168,199,233,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,215,232,145,191,245,80,90,115,115,146,60,98,136,250,62,191,168,139,239,108,80,21,89,142,164,225,192,24,137,42,27,254,250,222,45,191,177,215,247,124,48,194,71,213,45,241,40,191,81,110,237,206,1,248,23,211,99,206,136,218,19,207,172,43,1,0],"hint":7},{"address":[58,152,33,66,200,78,170,110,66,96,230,103,226,169,23,51,19,60,53,77,238,245,123,227,201,182,97,107,158,128,2,25],"bytes":[193,1,0,0,0,0,1,1,0,0,0,0,1,145,23,113,32,2,115,33,3,0,32,1,96,113,32,4,96,48,0,0,5,0,38,60,169,245,127,113,119,244,149,227,113,31,140,221,89,150,122,10,26,77,232,149,177,235,238,86,108,209,136,62,212,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,144,2,42,228,197,213,42,210,138,205,128,5,29,212,31,39,245,28,156,74,251,171,27,179,145,119,60,25,239,13,193,233,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,2,0,1,0],"hint":0},{"address":[58,236,205,2,58,251,8,54,114,70,20,83,101,26,139,56,25,138,160,207,142,51,135,194,251,159,62,139,56,116,159,169],"bytes":[208,1,1,148,23,179,23,177,23,176,23,180,114,19,18,17,132,7,179,7,177,7,176,7,180,115,33,0,1,129,7,177,114,20,16,18,18,129,7,178,114,17,16,18,5,32,2,32,3,113,33,1,0,176,146,23,177,23,176,1,146,23,178,23,176,114,20,113,32,4,17,16,5,44,210,22,204,18,194,70,222,246,220,17,80,137,168,196,54,74,87,104,206,0,177,225,137,227,247,110,45,215,138,62,35,55,29,38,88,218,150,252,157,177,26,21,63,193,156,198,191,199,146,188,252,190,78,141,234,34,46,212,221,41,186,89,205,98,178,194,235,79,232,199,133,128,191,119,139,254,148,198,236,44,203,37,211,8,54,159,192,13,135,184,133,238,190,83,72,154,222,24,249,71,95,80,187,218,209,195,211,226,6,199,177,22,169,133,38,75,236,35,35,223,17,81,230,198,53,60,5,252,82,100,111,177,136,75,195,148,65,19,16,182,120,92,58,241,175,36,162,134,0,106,248,159,179,39,233,159,151,170,22,2,0,192],"hint":4294967295},{"address":[59,221,128,220,156,145,103,10,73,69,57,146,131,200,250,144,116,111,117,222,101,218,171,215,58,64,190,212,212,177,163,136],"bytes":[193,1,0,2,2,0,146,23,1,23,2,0,1,0,2,0,2,2,148,23,1,23,2,23,17,23,17,114,50,0,1,2,19,18,0,0,3,64,192,64,193,1,0,192,193],"hint":0},{"address":[60,134,215,137,75,203,119,63,4,248,167,22,60,252,178,120,187,219,161,221,99,4,124,167,233,10,21,117,26,21,214,117],"bytes":[208,9,0,145,23,176,179,131,7,176,7,176,7,178,117,33,7,0,129,7,176,179,18,32,2,17,16,4,32,0,113,33,5,1,32,6,114,177,114,32,3,17,16,32,4,146,23,176,23,178,114,177,114,32,3,18,113,32,1,17,32,4,8,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,76,233,150,72,34,140,184,150,210,246,150,142,48,247,240,159,10,30,2,27,161,152,148,151,104,30,9,1,51,165,196,123,158,68,91,157,95,130,82,119,35,71,135,46,144,155,93,180,231,236,167,8,108,237,244,254,198,222,132,15,107,123,95,146,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,2,0,1,0],"hint":0},{"address":[62,138,173,204,97,28,77,134,119,202,223,0,199,133,6,86,29,51,115,142,227,213,113,247,164,25,110,38,5,128,201,184],"bytes":[208,1,0,145,23,176,177,130,7,176,7,176,116,33,1,0,129,7,176,177,16,32,2,17,2,32,0,145,23,176,176,3,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,254,79,58,139,185,184,145,29,160,23,169,108,155,21,32,138,186,117,189,255,121,82,200,110,154,172,157,3,23,76,84,114,1,1,0],"hint":2},{"address":[62,167,225,143,203,183,196,152,178,164,82,55,189,166,89,192,237,201,123,61,84,164,173,13,17,188,46,190,200,12,250,23],"bytes":[209,0,1,1,0,1,2,149,23,0,23,176,23,178,23,177,23,113,32,3,19,113,19,16,2,1,133,7,0,7,176,7,178,7,177,7,113,32,0,19,113,18,16,1,133,7,0,7,176,7,178,7,177,7,19,113,17,16,3,145,23,113,32,3,16,1,145,23,18,113,18,114,32,1,19,16,145,23,113,32,0,17,113,17,114,32,2,18,16,4,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,54,61,7,17,130,190,65,78,26,88,89,155,131,245,225,159,155,135,55,35,5,79,66,135,186,105,112,90,175,239,39,218,140,192,225,54,12,27,41,16,141,171,61,97,114,231,252,232,169,170,150,64,218,164,187,233,155,161,48,93,150,35,98,75,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,2,0,192],"hint":0},{"address":[63,71,128,249,162,66,128,224,18,166,239,86,248,17,105,96,166,198,13,163,60,188,86,222,193,25,251,191,237,189,182,67],"bytes":[208,1,1,151,23,182,23,176,23,176,23,183,23,184,0,23,184,1,23,184,2,114,22,21,20,135,7,182,7,176,7,176,7,183,7,184,0,7,184,1,7,184,2,116,181,129,7,176,114,23,16,21,21,116,181,129,7,176,114,23,178,16,20,113,19,179,113,18,179,116,181,129,7,176,114,23,177,16,20,113,17,179,113,16,179,11,32,5,32,3,32,4,32,1,32,2,33,0,0,146,23,176,23,176,0,145,23,180,114,19,178,178,145,23,180,114,20,178,177,145,23,180,114,21,177,178,145,23,180,114,22,177,177,6,87,167,53,35,32,67,243,33,132,94,50,178,160,142,93,54,175,23,91,174,34,234,35,34,120,68,188,69,151,153,255,69,120,192,56,5,248,234,247,211,103,224,245,121,9,171,213,102,217,74,43,235,207,98,112,254,47,231,74,249,84,237,13,0,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,221,161,43,203,51,7,39,246,223,184,22,188,151,82,170,189,5,32,230,81,91,121,252,138,90,158,113,56,102,244,198,62,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,1,192],"hint":4294967295},{"address":[63,164,161,115,247,173,66,124,193,64,28,191,75,202,81,190,222,182,48,140,169,218,222,5,163,109,131,195,112,142,41,18],"bytes":[214,0,177,240,135,145,58,202,171,121,231,224,213,186,89,125,185,69,193,114,36,226,196,245,166,98,29,36,16,178,152,230,124,62,0,0,0],"hint":0},{"address":[65,188,63,178,244,166,74,106,62,247,138,202,224,206,102,205,147,127,93,159,216,146,147,221,99,196,59,134,246,196,197,121],"bytes":[208,1,2,148,23,0,23,1,23,179,23,178,113,177,18,132,7,0,7,1,7,179,7,178,116,34,2,1,2,19,129,7,113,176,19,113,177,19,16,115,34,0,2,3,19,18,17,4,33,1,2,33,1,3,113,176,18,145,23,17,17,3,68,175,91,223,99,205,175,72,183,67,6,111,125,11,172,39,165,44,205,43,198,64,172,48,195,218,147,197,93,59,184,63,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,177,106,62,1,119,218,180,42,13,198,152,147,9,17,228,149,237,65,8,85,137,83,220,248,170,40,77,157,38,176,63,233,4,1,192,1,193,192,193],"hint":2},{"address":[65,203,206,252,92,156,117,180,222,102,252,183,74,81,252,254,25,214,27,206,74,8,52,84,1,166,203,146,119,254,232,151],"bytes":[208,9,0,146,23,176,23,176,114,179,114,178,113,177,17,16,113,177,114,178,17,16,130,7,176,7,176,116,33,7,0,129,7,176,145,23,176,114,179,114,178,113,177,16,17,113,177,114,178,16,17,16,32,4,17,4,32,2,32,3,116,35,1,0,0,0,176,176,176,114,33,0,0,176,32,5,113,33,6,1,176,8,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,83,180,178,166,83,17,39,253,108,155,192,130,101,163,44,2,4,192,176,123,70,115,242,157,231,60,95,148,135,81,85,91,172,236,141,84,253,42,149,116,121,227,42,148,233,109,150,37,96,48,59,90,31,4,119,124,236,230,174,65,170,201,238,120,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,2,0,1,0],"hint":0},{"address":[66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166],"bytes":[212,0,1,21,82,189,84,69,166,57,241,90,253,231,25,173,73,94,73,40,27,198,238,195,105,239,14,99,135,203,177,190,110,228,82,0,0,0],"hint":0},{"address":[68,175,91,223,99,205,175,72,183,67,6,111,125,11,172,39,165,44,205,43,198,64,172,48,195,218,147,197,93,59,184,63],"bytes":[208,1,2,149,23,0,23,1,23,183,23,179,23,184,1,181,133,7,0,7,1,7,183,7,179,7,184,1,118,34,5,3,2,20,129,7,113,176,20,145,23,113,184,0,16,182,17,130,7,32,3,7,113,184,0,113,33,0,3,21,113,33,0,4,21,131,7,20,7,180,7,115,178,22,129,7,113,176,22,113,177,22,115,33,6,3,22,17,16,115,33,6,4,22,113,21,18,64,2,16,16,10,33,1,3,33,1,4,34,4,1,3,113,176,18,113,176,21,113,177,19,113,177,21,145,23,17,17,114,178,21,129,7,180,182,115,178,19,129,7,113,176,19,181,16,7,57,148,188,81,227,104,111,48,161,212,131,214,157,10,131,90,123,72,77,137,35,147,192,132,248,122,88,73,222,84,243,2,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,154,188,179,8,71,233,245,145,108,38,16,126,148,119,150,163,32,109,86,206,46,122,164,98,116,232,5,70,234,163,248,235,178,212,245,211,140,116,84,134,58,215,4,56,245,216,90,238,79,156,121,45,75,131,28,156,231,56,80,213,237,244,149,188,179,167,216,2,73,253,130,49,0,238,3,98,98,50,209,65,42,14,131,53,39,93,93,245,59,146,148,56,135,182,80,247,5,1,192,1,193,64,1,192,1,193,192,193],"hint":4294967295},{"address":[69,217,26,77,35,69,244,83,106,57,96,36,76,155,206,182,249,199,138,44,4,183,135,176,18,155,207,7,58,44,74,113],"bytes":[208,1,2,150,23,1,23,16,23,179,23,18,23,178,23,177,114,19,18,17,134,7,1,7,16,7,179,7,18,7,178,7,177,118,34,2,0,1,21,20,19,16,18,17,4,33,0,1,114,18,19,114,33,1,1,20,19,115,176,19,18,16,146,23,17,23,115,176,18,17,16,0,3,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,212,148,220,96,19,134,186,142,143,11,113,31,230,42,45,96,171,96,198,72,140,140,246,206,151,121,110,188,58,213,254,251,251,3,245,167,225,65,216,64,37,179,165,3,222,220,83,206,134,242,151,189,227,107,188,27,152,104,122,234,180,53,153,104,2,192,193],"hint":4294967295},{"address":[69,220,179,197,229,173,163,188,12,165,45,98,166,111,127,157,218,53,7,223,113,6,26,92,32,10,222,160,207,36,16,20],"bytes":[208,1,0,145,23,176,32,2,129,7,176,114,32,1,113,32,3,16,113,32,5,16,1,113,33,4,0,32,0,6,6,95,200,180,19,147,245,37,193,229,65,185,212,188,151,194,12,19,191,35,167,32,154,32,147,182,244,82,115,48,17,74,17,198,157,44,229,108,78,127,200,211,19,164,228,97,121,43,44,89,248,48,208,180,61,255,199,56,2,225,15,168,240,154,34,22,37,160,14,226,214,185,98,151,227,77,126,5,191,126,79,211,141,141,153,211,225,214,74,124,210,224,108,160,117,45,51,52,114,218,81,164,158,201,126,219,71,65,146,239,73,222,114,22,130,75,39,118,45,50,83,218,125,44,223,39,73,206,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,121,36,8,240,243,193,179,109,144,242,3,38,249,166,144,50,89,229,153,225,214,42,166,4,226,138,239,193,4,80,198,44,1,0],"hint":15},{"address":[70,35,208,49,99,188,238,71,7,89,179,46,71,204,94,153,116,73,156,157,115,141,201,235,77,165,161,41,140,181,237,20],"bytes":[208,9,0,145,23,176,113,32,1,116,33,2,0,176,32,4,16,16,129,7,176,113,32,0,16,1,32,3,5,1,156,82,160,48,77,46,6,170,125,218,127,215,239,133,243,65,227,200,233,141,87,191,152,55,238,79,178,125,40,128,190,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,1,0],"hint":0},{"address":[71,131,44,144,254,87,111,212,189,165,149,103,212,177,190,138,20,108,207,137,97,200,143,209,169,214,252,183,44,121,177,153],"bytes":[208,1,0,147,23,176,23,176,23,178,113,32,6,18,131,7,176,7,176,7,178,114,32,1,18,115,32,4,113,177,18,17,16,3,32,3,117,35,2,0,0,0,176,176,176,115,34,11,0,0,176,176,114,33,5,0,176,32,12,115,33,9,0,176,103,113,32,10,103,116,33,0,0,176,32,8,16,113,177,17,13,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,13,164,236,55,143,162,108,181,30,92,168,197,143,189,39,148,70,134,138,146,30,47,20,251,22,117,74,68,17,136,107,88,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,90,217,16,70,80,53,182,167,10,100,133,228,237,107,172,102,24,66,112,204,57,162,193,238,51,174,240,219,155,127,204,66,97,77,217,229,201,188,180,126,143,59,37,173,22,90,151,122,31,61,199,114,50,70,93,227,182,142,40,95,119,199,135,53,144,2,42,228,197,213,42,210,138,205,128,5,29,212,31,39,245,28,156,74,251,171,27,179,145,119,60,25,239,13,193,233,171,19,190,223,66,232,75,174,15,124,98,199,221,106,138,218,87,30,136,41,190,214,234,85,130,23,240,54,27,94,37,208,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,209,175,140,47,93,246,86,19,16,237,169,150,109,112,205,159,81,104,143,0,40,10,227,135,239,113,101,70,169,212,21,251,254,77,94,53,147,241,44,126,254,17,58,115,217,127,219,138,235,250,120,184,27,185,29,195,210,9,55,161,132,15,154,69,1,0],"hint":6},{"address":[73,182,34,112,168,74,185,8,87,208,141,25,200,37,182,37,211,78,55,245,209,136,145,191,236,160,41,156,245,37,61,20],"bytes":[193,1,0,0,0,0,0,1,0,0,0,0,2,146,23,32,1,23,113,32,0,16,48,0,0,2,1,210,87,183,1,146,38,189,176,77,45,212,108,97,145,226,7,228,101,81,222,88,168,234,40,104,82,126,191,140,146,236,154,222,24,249,71,95,80,187,218,209,195,211,226,6,199,177,22,169,133,38,75,236,35,35,223,17,81,230,198,53,60,5,1,1,0],"hint":0},{"address":[74,235,129,46,154,144,255,245,231,81,244,96,55,184,237,120,247,17,154,118,116,55,124,237,29,169,61,176,43,238,174,2],"bytes":[208,1,0,146,23,176,23,176,180,131,7,176,7,176,7,179,117,33,10,1,129,7,176,180,17,130,7,32,6,7,113,177,114,178,96,113,32,9,96,114,178,100,113,32,9,100,130,7,176,7,113,177,113,32,3,16,114,32,2,64,5,16,20,16,5,32,1,113,33,7,1,129,7,176,176,113,33,8,0,176,113,177,16,145,23,179,176,11,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,55,59,125,116,246,180,13,161,27,126,215,150,3,164,94,199,1,26,136,49,183,32,181,125,46,254,146,232,42,61,87,240,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,72,252,114,31,187,193,114,224,146,95,162,122,241,103,29,226,37,186,146,113,52,128,41,152,177,10,21,104,161,136,101,43,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,254,151,194,209,128,155,98,73,123,114,24,233,54,53,80,136,220,22,237,127,20,28,103,136,201,83,126,133,111,54,178,226,2,0,1,0],"hint":4294967295},{"address":[75,13,16,143,157,143,107,37,249,179,226,109,160,151,234,193,147,18,35,66,89,91,201,38,77,88,172,166,119,142,12,185],"bytes":[208,1,0,150,23,176,23,176,23,184,0,23,183,23,184,1,23,184,2,113,19,18,134,7,176,7,176,7,184,0,7,183,7,184,1,7,184,2,118,32,6,179,180,129,7,114,181,179,180,113,20,16,18,129,7,179,113,18,16,129,7,180,113,17,16,11,32,3,113,33,5,1,176,114,33,0,0,176,32,4,114,177,21,20,114,178,21,20,32,7,114,178,20,19,114,181,114,177,18,17,114,178,18,17,145,23,114,181,114,177,17,16,114,178,17,16,0,145,23,114,177,19,18,113,18,115,32,2,114,177,20,19,182,16,145,23,182,113,19,115,32,1,179,180,16,8,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,32,234,41,58,99,89,72,84,125,46,246,57,166,36,225,101,13,83,239,74,167,10,58,241,65,182,82,242,79,201,191,201,50,89,126,57,173,237,230,209,52,157,9,99,176,1,64,85,216,72,202,85,170,153,42,210,230,160,81,203,112,115,22,66,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,225,144,38,208,210,235,131,138,90,222,61,142,38,34,204,35,242,166,62,92,6,39,219,146,51,97,49,51,84,225,221,246,227,202,247,231,13,241,107,26,110,135,74,200,103,132,25,81,105,132,248,209,230,141,36,208,221,153,6,42,242,14,140,234,2,0,1,0],"hint":4294967295},{"address":[76,98,201,118,89,139,255,180,43,124,201,210,127,20,162,152,110,242,136,41,19,36,136,96,210,27,190,27,120,145,216,15],"bytes":[193,1,0,0,1,0,145,23,176,1,1,0,0,0,1,2,147,23,176,23,176,23,116,33,0,0,176,32,2,16,17,113,48,0,18,1,32,1,3,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,2,0,1,0],"hint":0},{"address":[76,233,150,72,34,140,184,150,210,246,150,142,48,247,240,159,10,30,2,27,161,152,148,151,104,30,9,1,51,165,196,123],"bytes":[208,1,0,148,23,176,23,184,3,23,176,23,184,2,114,178,114,179,19,181,177,132,7,176,7,184,3,7,176,7,184,2,119,32,8,131,7,176,7,176,7,182,145,23,113,183,18,114,178,114,179,19,184,0,177,19,17,16,131,7,176,7,114,178,114,179,184,1,16,177,7,113,183,184,1,114,33,0,1,32,12,114,179,184,1,184,0,132,7,176,7,176,7,114,178,114,179,181,113,180,16,177,7,113,183,184,0,114,64,4,16,18,17,18,12,32,2,32,7,113,33,9,1,32,12,32,5,32,3,113,180,17,114,178,114,179,17,16,177,113,33,6,0,129,7,176,146,23,176,23,182,114,178,114,179,18,181,177,113,180,18,115,33,10,0,176,97,113,32,11,97,114,178,114,179,18,16,177,113,183,16,13,2,1,207,17,44,128,169,32,218,175,29,186,208,247,219,163,151,224,41,20,165,148,50,128,126,189,159,55,118,75,214,74,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,158,68,91,157,95,130,82,119,35,71,135,46,144,155,93,180,231,236,167,8,108,237,244,254,198,222,132,15,107,123,95,146,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,164,168,65,105,241,111,97,116,203,0,95,191,119,10,36,94,155,6,241,47,8,243,52,94,13,212,67,83,39,21,4,8,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,2,0,1,0],"hint":4294967295},{"address":[77,166,97,145,122,88,21,47,92,169,116,210,37,109,152,239,169,215,34,196,241,99,130,233,205,240,22,223,76,87,67,104],"bytes":[208,1,0,32,3,113,32,2,115,33,4,0,32,1,96,113,32,5,96,0,6,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,133,3,200,114,90,182,7,7,182,18,32,13,189,6,4,251,213,109,143,69,158,236,51,76,117,186,148,188,195,81,38,204,154,222,24,249,71,95,80,187,218,209,195,211,226,6,199,177,22,169,133,38,75,236,35,35,223,17,81,230,198,53,60,5,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,1,0],"hint":5},{"address":[78,220,8,226,238,119,236,166,207,247,218,76,93,236,68,144,114,114,234,148,60,220,39,239,145,229,191,202,76,6,185,233],"bytes":[208,9,0,145,23,176,177,129,7,176,115,33,7,0,129,7,176,177,16,32,6,2,32,0,116,33,2,1,129,7,32,5,0,32,1,32,4,114,32,3,16,16,8,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,161,35,96,69,20,10,194,171,190,21,41,88,52,132,52,251,132,73,101,150,249,252,93,203,189,88,91,129,116,196,57,39,176,177,13,178,135,1,45,21,180,105,78,118,183,137,193,46,197,228,30,252,157,184,166,99,207,215,84,191,47,196,151,23,211,216,255,146,74,249,220,75,92,216,105,118,6,21,179,231,238,128,145,107,182,23,37,157,69,137,12,105,244,18,131,55,227,90,177,115,88,250,231,168,30,251,61,148,161,100,253,63,133,171,139,12,136,138,170,7,28,254,13,96,255,188,28,172,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,233,94,127,120,200,105,105,125,102,16,144,15,71,189,136,171,225,49,243,95,82,198,241,78,250,182,101,53,78,94,169,30,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,2,0,1,0],"hint":0},{"address":[79,62,76,254,21,130,252,107,33,234,31,73,171,68,122,154,11,227,196,40,148,111,126,141,210,36,69,56,189,105,121,243],"bytes":[208,1,1,147,23,0,23,177,23,17,178,131,7,0,7,177,7,17,117,34,1,0,1,18,129,7,178,145,23,19,113,176,20,17,113,33,2,1,18,16,3,33,0,1,113,176,16,113,176,18,3,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,177,106,62,1,119,218,180,42,13,198,152,147,9,17,228,149,237,65,8,85,137,83,220,248,170,40,77,157,38,176,63,233,201,125,121,97,216,195,89,232,147,132,65,209,81,88,239,104,137,129,240,7,233,2,168,238,164,169,21,33,253,26,59,223,2,1,192,192],"hint":2},{"address":[79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1],"bytes":[214,0,108,255,144,109,191,162,189,175,224,236,43,240,19,30,128,5,44,206,126,44,101,59,129,73,95,229,25,126,83,172,103,171,0,0,0],"hint":0},{"address":[82,44,150,10,189,170,15,126,101,246,144,196,209,146,34,107,222,162,161,55,89,220,19,50,109,239,182,198,176,21,148,111],"bytes":[208,9,0,145,23,176,116,33,0,0,176,32,8,16,118,35,2,0,0,0,176,176,176,114,33,1,0,176,32,7,16,115,33,9,0,176,101,113,32,10,101,129,7,176,113,32,6,113,32,4,16,1,32,3,11,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,72,252,114,31,187,193,114,224,146,95,162,122,241,103,29,226,37,186,146,113,52,128,41,152,177,10,21,104,161,136,101,43,96,216,116,231,204,103,223,155,196,38,250,152,158,223,135,142,180,37,214,16,87,76,159,105,22,153,73,21,72,244,10,91,172,236,141,84,253,42,149,116,121,227,42,148,233,109,150,37,96,48,59,90,31,4,119,124,236,230,174,65,170,201,238,120,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,1,0],"hint":0},{"address":[82,153,185,151,42,214,73,93,9,72,77,231,241,19,167,27,131,2,6,126,109,29,115,202,179,206,26,62,172,1,142,88],"bytes":[208,1,0,149,23,32,3,23,183,23,113,32,6,17,23,184,5,23,184,6,113,19,18,133,7,32,3,7,183,7,113,32,6,17,7,184,5,7,184,6,118,32,14,184,0,184,3,129,7,113,32,6,20,113,20,16,18,129,7,184,0,113,18,16,129,7,184,3,117,33,10,0,181,182,129,7,184,4,113,21,115,32,1,114,176,22,178,114,32,9,113,180,22,184,2,16,16,130,7,181,7,184,2,114,19,17,16,15,114,33,0,0,32,3,32,8,113,33,11,0,32,3,114,177,101,113,32,12,101,114,177,103,113,32,12,103,113,176,114,177,100,113,32,12,100,113,180,21,114,176,21,179,145,23,113,32,6,16,0,114,176,20,178,114,176,20,179,114,176,22,179,114,32,9,113,180,20,184,1,114,32,9,181,182,145,23,114,176,18,178,113,18,115,32,2,114,176,19,178,114,32,9,113,180,19,114,176,19,179,16,146,23,113,180,19,23,184,1,113,20,115,32,1,114,176,21,178,184,4,116,32,13,181,182,17,16,15,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,32,234,41,58,99,89,72,84,125,46,246,57,166,36,225,101,13,83,239,74,167,10,58,241,65,182,82,242,79,201,191,201,50,89,126,57,173,237,230,209,52,157,9,99,176,1,64,85,216,72,202,85,170,153,42,210,230,160,81,203,112,115,22,66,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,84,34,202,66,150,253,44,134,153,99,93,164,53,9,212,29,158,178,50,54,154,227,192,126,7,112,218,215,108,72,9,154,84,189,80,219,85,231,97,165,28,134,114,117,155,179,31,39,229,72,74,179,236,254,211,154,6,193,41,18,171,154,163,159,108,2,97,83,46,232,241,9,2,14,144,215,132,206,23,128,196,29,235,100,150,14,53,178,85,49,173,240,253,100,220,172,164,37,125,4,177,15,129,218,181,92,25,207,231,133,6,210,224,218,253,30,130,205,48,23,226,204,252,7,36,71,22,73,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,178,136,217,224,36,44,255,41,120,139,158,183,34,54,222,165,15,112,144,89,71,169,35,37,231,162,123,37,240,169,206,134,201,246,30,101,150,110,86,213,47,91,58,245,40,216,252,203,191,236,197,170,225,8,225,37,173,234,135,66,224,51,188,191,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,207,50,3,156,237,177,155,180,170,133,230,150,209,37,133,187,7,146,233,229,90,111,207,83,182,187,14,36,246,25,140,200,225,144,38,208,210,235,131,138,90,222,61,142,38,34,204,35,242,166,62,92,6,39,219,146,51,97,49,51,84,225,221,246,1,0],"hint":4294967295},{"address":[83,180,178,166,83,17,39,253,108,155,192,130,101,163,44,2,4,192,176,123,70,115,242,157,231,60,95,148,135,81,85,91],"bytes":[208,1,0,147,23,176,23,182,23,176,114,179,114,178,180,18,113,177,114,178,16,18,131,7,176,7,182,7,176,118,32,9,130,7,176,7,176,145,23,182,114,179,114,178,183,17,113,177,114,178,18,17,16,18,130,7,176,7,113,181,184,1,114,33,0,1,176,114,178,113,177,17,184,1,131,7,176,7,176,7,113,181,180,118,34,1,1,1,176,176,114,32,6,183,17,114,178,18,114,178,17,114,184,0,104,0,113,32,15,104,0,177,113,64,10,16,18,17,10,32,5,32,7,116,35,3,0,0,0,176,176,176,114,33,2,0,176,32,12,113,33,13,1,176,113,177,16,113,33,11,0,129,7,176,145,23,176,114,179,114,178,180,17,113,177,114,178,16,17,113,181,16,113,177,18,113,33,14,0,176,114,184,0,100,113,32,15,100,16,2,1,207,17,44,128,169,32,218,175,29,186,208,247,219,163,151,224,41,20,165,148,50,128,126,189,159,55,118,75,214,74,5,199,182,224,138,234,68,58,149,61,8,60,30,231,110,202,98,58,85,180,216,170,221,68,152,250,235,100,244,23,155,77,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,62,138,173,204,97,28,77,134,119,202,223,0,199,133,6,86,29,51,115,142,227,213,113,247,164,25,110,38,5,128,201,184,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,72,252,114,31,187,193,114,224,146,95,162,122,241,103,29,226,37,186,146,113,52,128,41,152,177,10,21,104,161,136,101,43,92,222,176,89,123,161,71,220,53,210,199,178,245,85,175,89,32,246,183,107,147,85,7,232,93,188,37,191,80,218,238,196,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,172,236,141,84,253,42,149,116,121,227,42,148,233,109,150,37,96,48,59,90,31,4,119,124,236,230,174,65,170,201,238,120,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,2,0,1,0],"hint":4294967295},{"address":[85,120,123,177,28,48,132,118,226,91,10,155,31,223,119,61,88,98,42,55,231,75,228,202,197,111,98,159,100,1,53,248],"bytes":[208,1,0,149,23,176,23,182,23,181,23,183,23,184,0,113,19,18,133,7,176,7,182,7,181,7,183,7,184,0,117,33,9,0,178,129,7,113,179,178,113,20,16,18,129,7,113,32,0,178,113,17,16,129,7,178,113,18,16,9,32,3,115,33,1,0,176,32,6,115,33,7,0,176,98,113,32,8,98,113,177,20,32,10,113,177,19,113,179,113,177,17,145,23,113,179,113,177,16,0,145,23,113,177,18,113,18,114,32,4,180,16,145,23,113,32,0,180,113,19,114,32,5,178,16,11,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,54,61,7,17,130,190,65,78,26,88,89,155,131,245,225,159,155,135,55,35,5,79,66,135,186,105,112,90,175,239,39,218,140,192,225,54,12,27,41,16,141,171,61,97,114,231,252,232,169,170,150,64,218,164,187,233,155,161,48,93,150,35,98,75,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,226,94,101,45,187,137,181,227,90,47,36,47,238,235,72,46,81,100,226,84,85,25,67,11,61,9,70,223,255,235,63,98,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,1,0],"hint":4294967295},{"address":[85,159,66,11,164,200,9,64,82,232,61,120,69,142,78,144,84,195,5,164,97,48,61,72,60,140,77,86,62,240,237,0],"bytes":[208,1,0,149,23,0,23,178,23,177,23,179,23,180,113,19,18,133,7,0,7,178,7,177,7,179,7,180,117,33,3,0,20,129,7,113,176,20,113,20,16,18,129,7,113,32,0,20,113,17,16,129,7,20,113,18,16,5,32,4,113,176,17,145,23,113,176,16,0,145,23,18,113,18,114,32,1,19,16,145,23,113,32,0,19,113,19,114,32,2,20,16,5,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,54,61,7,17,130,190,65,78,26,88,89,155,131,245,225,159,155,135,55,35,5,79,66,135,186,105,112,90,175,239,39,218,140,192,225,54,12,27,41,16,141,171,61,97,114,231,252,232,169,170,150,64,218,164,187,233,155,161,48,93,150,35,98,75,226,94,101,45,187,137,181,227,90,47,36,47,238,235,72,46,81,100,226,84,85,25,67,11,61,9,70,223,255,235,63,98,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,1,0],"hint":4294967295},{"address":[85,179,191,20,47,181,168,7,138,211,183,81,95,144,171,35,156,50,174,4,67,223,227,131,182,125,174,111,75,161,127,197],"bytes":[208,1,1,148,23,1,23,176,23,176,23,179,115,177,19,18,17,132,7,1,7,176,7,176,7,179,118,34,0,1,0,176,18,129,7,176,115,177,20,19,16,116,33,2,1,129,7,176,115,177,20,16,16,18,178,178,17,16,4,32,4,33,1,1,129,7,19,16,115,33,3,0,176,17,16,5,6,130,169,187,145,109,99,25,149,171,18,87,167,82,105,228,15,62,82,43,99,203,13,117,117,79,27,182,17,178,98,154,85,205,208,226,18,230,22,59,11,225,48,54,15,21,182,23,118,217,12,186,165,145,6,171,85,229,17,165,167,106,19,251,87,167,53,35,32,67,243,33,132,94,50,178,160,142,93,54,175,23,91,174,34,234,35,34,120,68,188,69,151,153,255,69,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,2,1,0,192],"hint":4294967295},{"address":[85,205,208,226,18,230,22,59,11,225,48,54,15,21,182,23,118,217,12,186,165,145,6,171,85,229,17,165,167,106,19,251],"bytes":[208,1,1,147,23,1,23,176,23,176,1,131,7,1,7,176,7,176,115,178,17,115,178,16,177,18,115,178,16,18,177,3,32,1,145,23,18,19,113,33,0,0,129,7,176,1,2,87,167,53,35,32,67,243,33,132,94,50,178,160,142,93,54,175,23,91,174,34,234,35,34,120,68,188,69,151,153,255,69,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,2,1,192,192],"hint":4294967295},{"address":[86,127,104,203,166,137,223,62,206,224,136,213,12,53,197,34,75,200,55,9,96,44,30,201,151,219,212,152,53,116,57,116],"bytes":[208,1,1,148,23,1,23,176,23,176,23,179,115,177,19,18,17,132,7,1,7,176,7,176,7,179,118,34,0,1,0,176,18,129,7,176,115,177,20,19,16,116,33,3,1,129,7,176,115,177,20,16,16,18,129,7,19,16,130,7,176,7,145,23,114,178,16,16,21,113,16,114,33,5,0,176,17,17,16,4,32,2,33,1,1,113,33,4,0,176,114,178,17,16,6,6,130,169,187,145,109,99,25,149,171,18,87,167,82,105,228,15,62,82,43,99,203,13,117,117,79,27,182,17,178,98,154,32,40,229,141,134,249,165,75,158,83,196,244,32,27,83,204,172,130,78,42,55,51,160,111,244,198,164,61,93,133,155,81,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,212,148,220,96,19,134,186,142,143,11,113,31,230,42,45,96,171,96,198,72,140,140,246,206,151,121,110,188,58,213,254,251,2,1,0,192],"hint":4294967295},{"address":[87,37,236,155,87,31,47,96,62,242,235,229,144,227,237,62,133,119,138,63,77,207,200,178,204,121,242,2,203,120,236,204],"bytes":[214,0,129,155,32,93,130,126,216,1,174,44,16,223,116,26,36,65,250,58,28,159,49,94,52,206,127,27,200,243,162,108,220,158,0,0,0],"hint":0},{"address":[87,126,90,15,232,8,149,210,119,167,204,55,147,11,0,116,248,202,15,201,237,91,62,42,155,123,33,131,166,247,190,50],"bytes":[208,1,2,149,23,0,23,1,23,176,23,18,23,18,20,131,7,0,7,1,7,176,64,0,16,1,114,34,0,2,3,17,16,1,248,113,220,56,84,110,35,226,251,163,213,50,63,253,122,23,6,235,47,55,54,75,11,33,3,232,69,100,172,113,4,244,4,1,192,1,193,192,193],"hint":4294967295},{"address":[87,167,53,35,32,67,243,33,132,94,50,178,160,142,93,54,175,23,91,174,34,234,35,34,120,68,188,69,151,153,255,69],"bytes":[208,1,1,148,23,179,23,176,23,177,23,178,113,19,18,132,7,179,7,176,7,177,7,178,116,33,1,0,19,17,16,18,4,32,3,113,17,32,2,113,18,32,0,145,23,176,0,4,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,176,177,13,178,135,1,45,21,180,105,78,118,183,137,193,46,197,228,30,252,157,184,166,99,207,215,84,191,47,196,151,23,221,161,43,203,51,7,39,246,223,184,22,188,151,82,170,189,5,32,230,81,91,121,252,138,90,158,113,56,102,244,198,62,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,1,192],"hint":4294967295},{"address":[89,117,65,203,125,21,21,222,134,24,232,171,127,127,126,15,79,86,147,207,179,234,107,227,221,28,177,253,136,145,230,98],"bytes":[208,1,1,147,23,182,23,176,23,184,0,114,177,113,18,17,114,178,18,17,131,7,182,7,176,7,184,0,116,33,5,0,129,7,176,183,116,179,113,18,32,8,33,0,0,114,16,32,8,180,180,130,7,176,7,183,116,179,113,20,181,114,177,113,20,17,114,178,20,17,114,18,181,16,16,17,9,32,1,34,3,1,0,33,4,1,34,6,1,0,33,7,0,113,32,2,17,145,23,176,1,114,177,113,19,16,114,178,19,16,146,23,176,23,114,178,18,16,113,19,17,9,45,252,22,175,1,184,43,59,145,194,255,112,68,9,215,98,54,168,63,149,108,12,110,102,89,166,79,226,29,118,105,91,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,200,50,46,3,213,88,248,90,142,220,127,230,133,36,1,56,128,173,11,188,183,220,137,1,54,210,71,21,75,35,9,146,206,48,252,15,65,53,230,121,207,59,22,208,214,103,189,157,244,231,166,157,187,129,119,162,158,92,117,180,140,76,236,16,221,146,133,172,69,212,172,133,209,127,160,211,36,61,121,9,199,130,162,162,118,238,63,176,207,254,250,154,251,219,13,225,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,2,64,192,1,0,192],"hint":4294967295},{"address":[90,106,252,240,222,240,113,207,212,160,21,61,3,60,65,102,91,200,241,74,246,239,196,240,137,218,250,46,233,123,22,234],"bytes":[208,9,0,181,115,32,11,181,182,114,33,1,1,32,15,114,32,3,181,182,7,32,6,32,13,113,33,12,0,176,114,178,101,113,177,101,118,35,4,0,0,0,176,176,176,115,34,14,0,0,176,176,114,33,7,0,176,32,16,114,178,104,0,113,177,104,0,114,178,96,113,177,96,116,33,2,0,176,32,9,179,180,114,32,10,179,180,17,0,38,60,169,245,127,113,119,244,149,227,113,31,140,221,89,150,122,10,26,77,232,149,177,235,238,86,108,209,136,62,212,2,1,207,17,44,128,169,32,218,175,29,186,208,247,219,163,151,224,41,20,165,148,50,128,126,189,159,55,118,75,214,74,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,17,21,123,195,137,143,6,227,230,242,202,131,65,30,253,13,67,184,132,107,87,210,246,8,142,24,243,68,125,220,59,40,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,97,77,217,229,201,188,180,126,143,59,37,173,22,90,151,122,31,61,199,114,50,70,93,227,182,142,40,95,119,199,135,53,171,19,190,223,66,232,75,174,15,124,98,199,221,106,138,218,87,30,136,41,190,214,234,85,130,23,240,54,27,94,37,208,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,175,88,107,7,84,110,31,202,154,176,120,13,28,35,106,248,211,96,196,198,187,50,187,12,208,62,201,202,99,211,218,150,189,126,156,133,211,91,76,24,214,150,13,138,113,122,195,143,126,189,202,41,203,121,52,143,191,203,242,104,221,95,44,216,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,209,175,140,47,93,246,86,19,16,237,169,150,109,112,205,159,81,104,143,0,40,10,227,135,239,113,101,70,169,212,21,251,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,254,77,94,53,147,241,44,126,254,17,58,115,217,127,219,138,235,250,120,184,27,185,29,195,210,9,55,161,132,15,154,69,2,0,1,0],"hint":0},{"address":[90,217,16,70,80,53,182,167,10,100,133,228,237,107,172,102,24,66,112,204,57,162,193,238,51,174,240,219,155,127,204,66],"bytes":[212,0,0,76,98,201,118,89,139,255,180,43,124,201,210,127,20,162,152,110,242,136,41,19,36,136,96,210,27,190,27,120,145,216,15,0,0,0],"hint":0},{"address":[91,143,245,240,169,162,108,95,126,127,27,141,234,124,186,107,220,201,28,205,36,75,94,213,241,43,244,169,208,71,130,19],"bytes":[208,1,0,146,23,176,23,179,177,131,7,176,7,179,7,176,119,33,6,0,130,7,176,7,176,145,23,113,178,17,32,7,18,16,130,7,176,7,113,178,32,8,32,4,130,7,176,7,113,178,113,32,1,16,32,5,131,7,176,7,176,7,113,178,113,32,1,17,113,64,2,16,17,17,4,32,0,145,23,176,32,7,113,33,3,0,129,7,176,177,113,178,16,9,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,221,161,43,203,51,7,39,246,223,184,22,188,151,82,170,189,5,32,230,81,91,121,252,138,90,158,113,56,102,244,198,62,229,189,28,137,7,71,176,10,240,241,238,202,35,26,230,244,125,118,195,113,110,47,38,135,122,134,147,192,107,197,146,69,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,1,1,0],"hint":4294967295},{"address":[91,170,240,92,150,157,44,243,119,49,33,17,190,81,187,100,198,0,193,63,161,100,238,114,46,146,36,59,15,119,27,171],"bytes":[208,1,0,146,23,176,23,176,176,130,7,176,7,176,115,33,2,0,129,7,176,176,16,113,32,1,17,1,32,0,3,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,74,235,129,46,154,144,255,245,231,81,244,96,55,184,237,120,247,17,154,118,116,55,124,237,29,169,61,176,43,238,174,2,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,1,1,0],"hint":4},{"address":[91,200,186,175,28,224,243,100,229,66,105,233,238,44,132,68,97,202,69,3,36,117,189,206,82,109,133,255,87,20,28,101],"bytes":[208,9,1,148,23,1,23,16,23,17,23,177,115,176,19,17,18,132,7,1,7,16,7,17,7,177,118,34,2,0,1,19,18,130,7,19,7,115,176,20,19,16,115,176,21,17,20,114,33,0,1,19,18,17,16,2,33,1,1,115,176,18,17,16,3,2,1,207,17,44,128,169,32,218,175,29,186,208,247,219,163,151,224,41,20,165,148,50,128,126,189,159,55,118,75,214,74,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,251,3,245,167,225,65,216,64,37,179,165,3,222,220,83,206,134,242,151,189,227,107,188,27,152,104,122,234,180,53,153,104,2,0,192],"hint":0},{"address":[92,153,220,97,136,158,74,30,6,255,111,36,209,132,220,101,83,2,140,198,43,137,250,97,188,35,17,91,106,118,32,104],"bytes":[208,9,0,145,23,176,178,131,7,176,7,176,7,177,117,33,8,0,129,7,176,178,18,32,2,17,16,3,32,1,115,33,6,1,32,7,114,32,3,17,16,32,4,146,23,176,23,177,116,33,0,0,176,32,5,18,17,9,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,148,182,15,36,249,90,206,212,94,50,82,37,100,157,148,182,130,132,74,53,17,211,156,202,179,126,212,242,131,125,47,137,158,68,91,157,95,130,82,119,35,71,135,46,144,155,93,180,231,236,167,8,108,237,244,254,198,222,132,15,107,123,95,146,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,2,0,1,0],"hint":0},{"address":[92,222,176,89,123,161,71,220,53,210,199,178,245,85,175,89,32,246,183,107,147,85,7,232,93,188,37,191,80,218,238,196],"bytes":[208,1,0,149,23,177,23,176,23,176,23,179,23,178,114,20,19,18,133,7,177,7,176,7,176,7,179,7,178,116,33,3,0,129,7,176,114,21,20,16,18,113,17,19,129,7,176,114,17,20,16,4,32,1,146,23,176,23,176,0,146,23,176,23,176,114,21,17,113,32,2,16,145,23,176,114,19,16,115,33,4,0,176,96,113,32,5,96,6,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,1,0],"hint":4294967295},{"address":[96,204,108,254,69,119,185,154,48,17,61,9,233,146,31,34,83,250,193,95,227,213,173,151,107,157,195,98,110,220,104,34],"bytes":[212,0,0,26,115,12,44,14,68,98,100,170,40,28,43,76,150,49,57,152,157,103,233,119,174,173,232,184,8,38,223,218,225,167,223,0,0,0],"hint":0},{"address":[96,216,116,231,204,103,223,155,196,38,250,152,158,223,135,142,180,37,214,16,87,76,159,105,22,153,73,21,72,244,10,91],"bytes":[208,9,0,145,23,176,116,33,0,0,176,32,2,16,16,129,7,176,113,32,3,16,1,32,1,4,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,244,242,199,63,63,176,199,189,250,212,209,10,144,100,144,38,99,103,162,129,151,44,249,218,31,186,104,181,104,141,20,40,1,0],"hint":0},{"address":[97,77,217,229,201,188,180,126,143,59,37,173,22,90,151,122,31,61,199,114,50,70,93,227,182,142,40,95,119,199,135,53],"bytes":[208,1,1,146,23,1,23,177,114,34,4,2,0,17,176,130,7,1,7,177,115,34,3,2,0,17,176,130,7,17,7,176,116,33,1,2,19,18,17,16,2,32,2,113,33,0,2,16,5,23,28,138,233,37,6,143,6,176,45,1,57,84,157,86,128,52,221,140,123,97,223,123,219,80,48,211,53,10,54,119,118,32,217,139,252,39,149,55,152,200,20,2,45,71,255,113,205,190,106,103,51,155,35,71,203,255,82,186,185,0,162,246,141,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,189,64,10,187,205,147,144,138,240,187,61,117,87,199,124,94,66,185,103,83,138,193,224,112,164,244,242,210,233,122,176,243,248,113,220,56,84,110,35,226,251,163,213,50,63,253,122,23,6,235,47,55,54,75,11,33,3,232,69,100,172,113,4,244,3,0,1,192,192],"hint":2},{"address":[98,178,194,235,79,232,199,133,128,191,119,139,254,148,198,236,44,203,37,211,8,54,159,192,13,135,184,133,238,190,83,72],"bytes":[214,0,125,89,104,124,139,90,19,89,201,144,19,230,51,213,6,81,53,59,128,48,168,164,23,252,117,240,70,72,9,55,125,102,0,0,0],"hint":0},{"address":[99,44,5,220,29,218,230,235,217,222,27,86,228,242,159,73,193,224,31,157,213,15,255,132,44,53,221,209,65,60,200,47],"bytes":[208,1,0,149,23,176,23,176,23,184,1,23,184,0,23,184,2,113,18,17,133,7,176,7,176,7,184,1,7,184,0,7,184,2,117,33,6,0,182,181,129,7,114,177,182,181,113,19,16,17,130,7,182,7,183,114,18,17,16,11,32,2,32,4,113,33,0,0,176,114,178,32,3,115,33,7,0,176,97,113,32,8,97,113,178,32,5,114,180,19,20,113,179,19,114,180,20,21,114,177,113,179,17,114,180,17,18,145,23,114,177,113,179,16,114,180,16,17,0,146,23,113,179,18,23,181,113,19,116,32,9,113,179,20,183,17,16,10,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,178,136,217,224,36,44,255,41,120,139,158,183,34,54,222,165,15,112,144,89,71,169,35,37,231,162,123,37,240,169,206,134,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,201,246,30,101,150,110,86,213,47,91,58,245,40,216,252,203,191,236,197,170,225,8,225,37,173,234,135,66,224,51,188,191,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,207,50,3,156,237,177,155,180,170,133,230,150,209,37,133,187,7,146,233,229,90,111,207,83,182,187,14,36,246,25,140,200,1,0],"hint":4294967295},{"address":[99,235,45,177,245,110,195,241,41,10,225,62,43,223,229,48,94,151,17,133,112,236,45,190,68,58,165,168,215,235,241,181],"bytes":[212,0,0,107,12,128,249,137,133,97,65,36,95,214,253,60,145,21,249,92,37,157,210,198,81,63,37,41,105,196,11,136,139,138,40,0,0,0],"hint":0},{"address":[100,244,51,228,9,216,44,53,225,232,196,102,144,99,39,128,69,176,228,211,159,96,133,187,118,108,207,5,242,137,6,241],"bytes":[208,1,0,146,23,176,23,176,184,1,130,7,176,7,176,119,33,2,1,130,7,176,7,176,184,1,17,16,129,7,179,114,32,1,114,180,178,178,113,181,178,129,7,179,114,32,4,184,0,129,7,184,0,115,182,178,177,16,129,7,179,114,32,4,183,129,7,183,115,182,177,178,16,129,7,179,114,32,1,114,180,177,177,113,181,177,10,32,10,32,7,32,9,32,5,113,33,8,1,176,113,33,0,1,176,113,33,3,0,32,6,114,180,177,178,114,180,178,177,113,32,11,114,180,17,16,12,2,1,207,17,44,128,169,32,218,175,29,186,208,247,219,163,151,224,41,20,165,148,50,128,126,189,159,55,118,75,214,74,54,61,7,17,130,190,65,78,26,88,89,155,131,245,225,159,155,135,55,35,5,79,66,135,186,105,112,90,175,239,39,218,63,71,128,249,162,66,128,224,18,166,239,86,248,17,105,96,166,198,13,163,60,188,86,222,193,25,251,191,237,189,182,67,85,179,191,20,47,181,168,7,138,211,183,81,95,144,171,35,156,50,174,4,67,223,227,131,182,125,174,111,75,161,127,197,140,192,225,54,12,27,41,16,141,171,61,97,114,231,252,232,169,170,150,64,218,164,187,233,155,161,48,93,150,35,98,75,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,161,35,96,69,20,10,194,171,190,21,41,88,52,132,52,251,132,73,101,150,249,252,93,203,189,88,91,129,116,196,57,39,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,221,161,43,203,51,7,39,246,223,184,22,188,151,82,170,189,5,32,230,81,91,121,252,138,90,158,113,56,102,244,198,62,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,2,0,1,0],"hint":3},{"address":[101,174,8,193,235,39,253,23,31,79,191,179,242,251,192,93,231,205,242,59,93,195,164,17,236,63,141,223,15,216,90,163],"bytes":[208,1,0,150,23,0,23,182,23,181,23,178,23,183,23,184,0,114,20,19,18,134,7,0,7,182,7,181,7,178,7,183,7,184,0,117,33,3,0,21,129,7,113,177,21,114,21,16,19,19,129,7,180,114,17,16,19,129,7,21,114,18,16,19,9,32,0,32,4,113,176,18,113,176,20,113,176,21,113,177,17,146,23,113,177,16,23,113,176,17,0,146,23,19,23,179,114,20,114,32,1,21,17,16,146,23,179,23,180,114,21,114,32,2,22,17,16,5,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,54,61,7,17,130,190,65,78,26,88,89,155,131,245,225,159,155,135,55,35,5,79,66,135,186,105,112,90,175,239,39,218,140,192,225,54,12,27,41,16,141,171,61,97,114,231,252,232,169,170,150,64,218,164,187,233,155,161,48,93,150,35,98,75,226,94,101,45,187,137,181,227,90,47,36,47,238,235,72,46,81,100,226,84,85,25,67,11,61,9,70,223,255,235,63,98,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,1,0],"hint":4294967295},{"address":[103,22,11,151,103,147,6,210,130,4,69,56,58,109,116,14,111,233,131,156,37,69,234,72,104,15,242,167,123,11,233,134],"bytes":[208,1,0,146,23,176,23,176,113,32,5,17,130,7,176,7,176,114,32,0,17,115,32,7,118,35,1,0,0,0,176,176,176,115,34,10,0,0,176,176,114,33,3,0,176,32,11,115,33,8,0,176,102,113,32,9,102,17,113,32,4,17,16,1,32,2,12,13,164,236,55,143,162,108,181,30,92,168,197,143,189,39,148,70,134,138,146,30,47,20,251,22,117,74,68,17,136,107,88,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,97,77,217,229,201,188,180,126,143,59,37,173,22,90,151,122,31,61,199,114,50,70,93,227,182,142,40,95,119,199,135,53,126,204,91,227,4,131,198,182,251,205,112,40,223,196,199,12,110,66,19,88,162,214,216,71,24,148,123,57,108,97,100,51,144,2,42,228,197,213,42,210,138,205,128,5,29,212,31,39,245,28,156,74,251,171,27,179,145,119,60,25,239,13,193,233,171,19,190,223,66,232,75,174,15,124,98,199,221,106,138,218,87,30,136,41,190,214,234,85,130,23,240,54,27,94,37,208,171,251,80,142,140,20,2,169,17,155,172,167,212,106,57,90,138,33,121,239,9,22,123,162,161,225,165,108,244,106,135,4,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,209,175,140,47,93,246,86,19,16,237,169,150,109,112,205,159,81,104,143,0,40,10,227,135,239,113,101,70,169,212,21,251,254,77,94,53,147,241,44,126,254,17,58,115,217,127,219,138,235,250,120,184,27,185,29,195,210,9,55,161,132,15,154,69,1,0],"hint":11},{"address":[107,12,128,249,137,133,97,65,36,95,214,253,60,145,21,249,92,37,157,210,198,81,63,37,41,105,196,11,136,139,138,40],"bytes":[193,1,0,0,1,0,145,23,176,0,1,0,0,0,1,2,147,23,176,23,113,33,2,0,32,0,23,115,33,4,1,176,17,113,32,1,16,113,48,0,18,1,32,3,5,6,95,200,180,19,147,245,37,193,229,65,185,212,188,151,194,12,19,191,35,167,32,154,32,147,182,244,82,115,48,17,74,51,52,114,218,81,164,158,201,126,219,71,65,146,239,73,222,114,22,130,75,39,118,45,50,83,218,125,44,223,39,73,206,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,154,222,24,249,71,95,80,187,218,209,195,211,226,6,199,177,22,169,133,38,75,236,35,35,223,17,81,230,198,53,60,5,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,2,0,1,0],"hint":0},{"address":[108,2,97,83,46,232,241,9,2,14,144,215,132,206,23,128,196,29,235,100,150,14,53,178,85,49,173,240,253,100,220,172],"bytes":[208,1,0,145,23,176,0,129,7,176,114,32,9,114,179,16,114,178,99,113,177,99,114,32,6,114,179,114,178,98,113,177,98,16,114,179,16,114,178,100,113,177,100,4,32,1,32,8,113,33,7,0,176,114,33,0,0,176,32,5,10,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,84,34,202,66,150,253,44,134,153,99,93,164,53,9,212,29,158,178,50,54,154,227,192,126,7,112,218,215,108,72,9,154,84,189,80,219,85,231,97,165,28,134,114,117,155,179,31,39,229,72,74,179,236,254,211,154,6,193,41,18,171,154,163,159,164,37,125,4,177,15,129,218,181,92,25,207,231,133,6,210,224,218,253,30,130,205,48,23,226,204,252,7,36,71,22,73,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,178,136,217,224,36,44,255,41,120,139,158,183,34,54,222,165,15,112,144,89,71,169,35,37,231,162,123,37,240,169,206,134,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,227,202,247,231,13,241,107,26,110,135,74,200,103,132,25,81,105,132,248,209,230,141,36,208,221,153,6,42,242,14,140,234,1,0],"hint":4294967295},{"address":[108,255,144,109,191,162,189,175,224,236,43,240,19,30,128,5,44,206,126,44,101,59,129,73,95,229,25,126,83,172,103,171],"bytes":[193,1,0,1,1,0,145,23,0,0,2,0,1,0,1,0,145,23,0,113,176,16,0,1,1,1,2,147,23,0,23,16,23,113,176,17,113,176,18,1,49,0,1,0,2,1,192,192],"hint":0},{"address":[109,30,3,83,172,239,100,138,86,106,186,160,225,39,137,78,225,134,206,95,171,1,250,42,39,112,1,159,102,79,30,166],"bytes":[208,1,1,149,23,179,23,177,23,178,23,180,23,181,114,20,19,18,133,7,179,7,177,7,178,7,180,7,181,117,34,3,1,0,176,129,7,177,114,21,16,19,19,113,17,18,130,7,176,7,177,115,18,17,16,20,6,32,2,113,33,1,0,176,32,4,146,23,177,23,178,1,145,23,178,114,19,113,33,0,0,176,16,147,23,176,23,177,23,178,114,22,115,33,5,0,176,18,17,16,6,57,148,188,81,227,104,111,48,161,212,131,214,157,10,131,90,123,72,77,137,35,147,192,132,248,122,88,73,222,84,243,2,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,98,178,194,235,79,232,199,133,128,191,119,139,254,148,198,236,44,203,37,211,8,54,159,192,13,135,184,133,238,190,83,72,150,145,212,243,57,243,164,63,121,161,201,51,86,245,77,129,59,198,227,235,59,233,116,46,93,47,105,5,167,53,185,3,154,222,24,249,71,95,80,187,218,209,195,211,226,6,199,177,22,169,133,38,75,236,35,35,223,17,81,230,198,53,60,5,179,167,216,2,73,253,130,49,0,238,3,98,98,50,209,65,42,14,131,53,39,93,93,245,59,146,148,56,135,182,80,247,2,0,192],"hint":4294967295},{"address":[109,161,248,248,39,19,92,160,171,136,16,106,160,156,220,89,58,171,27,215,58,41,21,50,223,177,199,197,19,48,0,221],"bytes":[208,1,0,151,23,184,22,23,176,23,176,23,184,10,23,184,21,23,184,24,23,184,23,115,22,21,20,19,135,7,184,22,7,176,7,176,7,184,10,7,184,21,7,184,24,7,184,23,120,0,32,2,21,130,7,176,7,184,20,146,23,114,184,8,22,17,23,116,183,113,184,3,23,22,114,177,178,18,17,115,182,181,178,23,20,19,129,7,114,184,8,20,21,118,184,15,22,129,7,176,146,23,114,180,23,16,23,116,183,113,184,3,17,16,114,177,178,178,184,7,115,182,181,18,17,130,7,114,180,22,22,7,116,183,114,180,23,23,16,114,177,23,23,113,32,19,23,118,184,11,184,5,184,7,129,7,184,5,115,182,181,181,16,113,21,178,17,116,184,12,184,5,17,184,7,116,184,13,184,5,17,184,7,16,21,115,184,19,21,22,16,20,131,7,176,7,184,20,7,114,184,8,22,184,2,118,184,15,184,1,129,7,176,146,23,114,180,181,16,23,116,183,114,180,182,17,16,114,177,182,184,17,184,4,114,184,14,18,17,130,7,113,184,3,184,1,7,116,183,114,180,181,184,16,16,114,177,181,184,16,115,32,12,181,19,18,118,184,11,184,18,184,4,129,7,184,18,114,184,14,113,179,21,16,117,33,9,0,129,7,176,145,23,114,177,16,21,115,24,5,17,113,179,22,115,32,12,17,22,16,182,129,7,114,177,32,18,20,114,23,21,16,130,7,176,7,114,177,113,179,16,21,115,23,17,22,16,19,17,116,184,12,184,18,17,184,4,116,184,13,184,18,17,184,4,16,23,115,184,19,23,184,1,16,22,114,33,16,1,176,20,114,33,3,0,114,180,21,20,19,33,32,5,32,8,24,0,32,6,114,33,0,0,176,32,11,24,1,24,2,33,10,0,32,12,113,179,18,113,179,17,113,180,178,115,32,12,182,20,19,113,184,3,178,32,19,113,32,19,178,113,33,13,1,176,115,33,14,0,176,100,113,32,15,100,114,180,17,16,34,1,0,0,33,7,0,33,17,0,113,24,4,24,3,113,34,1,0,1,176,113,179,19,113,179,20,114,180,182,184,17,113,33,7,1,176,114,177,22,16,145,23,176,115,20,16,16,113,32,19,16,147,23,176,23,176,23,184,10,0,147,23,176,23,176,23,114,177,184,2,16,115,178,184,1,184,2,115,32,12,184,1,17,16,146,23,176,23,114,177,184,9,16,115,22,184,9,184,2,115,32,12,184,9,17,16,20,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,6,130,169,187,145,109,99,25,149,171,18,87,167,82,105,228,15,62,82,43,99,203,13,117,117,79,27,182,17,178,98,154,17,57,94,11,168,111,246,177,22,200,19,9,72,121,252,64,171,24,91,139,219,212,182,27,23,168,83,212,188,164,20,37,31,181,154,127,225,27,53,79,1,145,116,89,241,61,225,54,55,151,173,12,23,60,111,134,41,121,101,6,10,234,138,44,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,91,200,186,175,28,224,243,100,229,66,105,233,238,44,132,68,97,202,69,3,36,117,189,206,82,109,133,255,87,20,28,101,143,112,180,160,174,152,116,193,51,244,179,211,36,51,17,25,136,171,75,61,193,164,122,107,230,246,195,65,167,219,176,175,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,171,154,109,137,72,73,148,55,108,192,222,72,8,59,163,82,24,151,208,77,71,179,52,161,16,167,124,84,197,89,93,108,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,187,67,180,68,88,106,58,237,43,170,13,123,116,49,202,109,205,20,171,148,68,188,119,146,13,19,67,51,208,191,229,116,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,212,148,220,96,19,134,186,142,143,11,113,31,230,42,45,96,171,96,198,72,140,140,246,206,151,121,110,188,58,213,254,251,221,130,125,188,51,21,25,234,120,233,109,145,197,211,51,90,209,123,164,153,203,23,203,36,50,52,242,237,142,210,28,95,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,244,242,199,63,63,176,199,189,250,212,209,10,144,100,144,38,99,103,162,129,151,44,249,218,31,186,104,181,104,141,20,40,2,0,1,0],"hint":4294967295},{"address":[109,246,232,68,250,110,177,159,63,131,165,143,118,202,92,252,153,76,184,1,77,193,132,132,251,249,132,55,171,38,81,61],"bytes":[208,1,0,150,23,176,23,176,23,183,23,182,23,184,0,23,184,1,113,19,18,134,7,176,7,176,7,183,7,182,7,184,0,7,184,1,117,33,7,0,179,129,7,113,180,179,113,20,16,18,129,7,113,32,0,179,113,17,16,129,7,179,113,18,16,10,32,2,32,4,114,33,1,0,176,32,6,114,178,20,113,177,21,32,8,114,178,19,113,177,20,113,180,114,178,17,113,177,18,145,23,113,180,114,178,16,113,177,17,0,145,23,114,178,18,113,177,19,113,18,114,32,3,181,16,145,23,113,32,0,181,113,19,114,32,5,179,16,9,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,54,61,7,17,130,190,65,78,26,88,89,155,131,245,225,159,155,135,55,35,5,79,66,135,186,105,112,90,175,239,39,218,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,140,192,225,54,12,27,41,16,141,171,61,97,114,231,252,232,169,170,150,64,218,164,187,233,155,161,48,93,150,35,98,75,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,226,94,101,45,187,137,181,227,90,47,36,47,238,235,72,46,81,100,226,84,85,25,67,11,61,9,70,223,255,235,63,98,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,1,0],"hint":4294967295},{"address":[110,136,64,72,21,82,41,235,105,49,176,6,2,238,37,242,70,209,130,45,161,110,242,220,70,126,51,211,181,88,113,10],"bytes":[208,1,0,150,23,176,23,176,23,184,0,23,183,23,184,1,23,184,2,113,19,18,134,7,176,7,176,7,184,0,7,183,7,184,1,7,184,2,118,32,6,179,180,129,7,114,181,179,180,113,20,16,18,129,7,179,113,18,16,129,7,180,113,17,16,11,32,3,114,33,0,0,176,32,4,114,33,8,0,176,32,5,114,177,21,20,114,178,21,20,32,7,114,178,20,19,114,181,114,177,18,17,114,178,18,17,145,23,114,181,114,177,17,16,114,178,17,16,0,145,23,114,177,19,18,113,18,115,32,2,114,177,20,19,182,16,145,23,182,113,19,115,32,1,179,180,16,9,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,32,234,41,58,99,89,72,84,125,46,246,57,166,36,225,101,13,83,239,74,167,10,58,241,65,182,82,242,79,201,191,201,50,89,126,57,173,237,230,209,52,157,9,99,176,1,64,85,216,72,202,85,170,153,42,210,230,160,81,203,112,115,22,66,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,225,144,38,208,210,235,131,138,90,222,61,142,38,34,204,35,242,166,62,92,6,39,219,146,51,97,49,51,84,225,221,246,227,202,247,231,13,241,107,26,110,135,74,200,103,132,25,81,105,132,248,209,230,141,36,208,221,153,6,42,242,14,140,234,240,100,197,234,66,44,190,111,117,71,83,154,159,89,122,138,122,170,46,209,234,37,69,72,84,27,176,143,148,9,97,74,1,0],"hint":4294967295},{"address":[110,215,246,115,38,0,101,214,155,195,48,196,161,124,113,224,213,193,199,33,114,82,253,87,15,195,59,72,52,43,252,255],"bytes":[208,9,0,146,23,177,23,184,0,114,178,17,176,130,7,177,7,184,0,117,32,4,17,129,7,113,32,7,17,114,178,18,176,16,129,7,114,178,17,181,117,32,15,18,181,176,16,115,32,12,184,3,184,1,113,183,114,32,2,184,3,184,1,130,7,114,178,114,180,101,113,179,101,17,7,114,178,18,182,117,32,15,19,182,176,16,115,32,12,184,4,184,2,113,183,114,32,2,184,4,184,2,13,32,8,32,3,114,33,1,0,177,32,10,32,14,113,33,13,0,177,114,180,102,113,179,102,114,180,104,1,113,179,104,1,113,33,0,1,32,16,113,32,7,16,114,32,11,181,176,114,32,11,182,176,114,178,181,176,114,178,182,176,17,2,1,207,17,44,128,169,32,218,175,29,186,208,247,219,163,151,224,41,20,165,148,50,128,126,189,159,55,118,75,214,74,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,17,21,123,195,137,143,6,227,230,242,202,131,65,30,253,13,67,184,132,107,87,210,246,8,142,24,243,68,125,220,59,40,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,82,153,185,151,42,214,73,93,9,72,77,231,241,19,167,27,131,2,6,126,109,29,115,202,179,206,26,62,172,1,142,88,84,34,202,66,150,253,44,134,153,99,93,164,53,9,212,29,158,178,50,54,154,227,192,126,7,112,218,215,108,72,9,154,84,189,80,219,85,231,97,165,28,134,114,117,155,179,31,39,229,72,74,179,236,254,211,154,6,193,41,18,171,154,163,159,108,2,97,83,46,232,241,9,2,14,144,215,132,206,23,128,196,29,235,100,150,14,53,178,85,49,173,240,253,100,220,172,144,236,192,158,21,207,14,183,246,62,149,32,194,89,18,230,91,4,163,130,94,128,208,191,175,244,147,37,38,193,38,113,164,37,125,4,177,15,129,218,181,92,25,207,231,133,6,210,224,218,253,30,130,205,48,23,226,204,252,7,36,71,22,73,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,175,88,107,7,84,110,31,202,154,176,120,13,28,35,106,248,211,96,196,198,187,50,187,12,208,62,201,202,99,211,218,150,189,126,156,133,211,91,76,24,214,150,13,138,113,122,195,143,126,189,202,41,203,121,52,143,191,203,242,104,221,95,44,216,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,226,72,221,147,156,222,87,251,189,159,22,193,104,218,241,226,145,46,167,92,22,210,43,142,160,143,55,17,73,248,146,45,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,2,0,1,0],"hint":0},{"address":[110,225,113,213,144,180,37,202,248,240,54,153,59,167,5,3,89,134,183,154,12,170,135,118,222,67,144,81,80,175,37,172],"bytes":[208,9,0,146,23,176,23,114,184,1,113,178,16,177,179,129,7,176,161,7,147,23,176,23,184,3,23,184,4,179,131,7,176,7,184,3,7,184,4,119,32,2,182,130,7,176,7,184,2,145,23,114,180,17,177,179,18,16,129,7,114,180,182,177,115,184,0,183,177,16,131,7,176,7,184,2,7,114,180,113,178,17,177,115,184,0,181,177,16,17,114,16,177,114,33,0,1,176,177,13,32,4,115,33,11,0,176,99,113,32,12,99,32,5,32,8,113,33,10,1,176,113,178,18,113,178,19,113,178,20,113,33,6,0,179,114,33,1,0,176,32,9,114,32,7,183,16,114,180,16,177,114,184,1,181,17,13,2,1,207,17,44,128,169,32,218,175,29,186,208,247,219,163,151,224,41,20,165,148,50,128,126,189,159,55,118,75,214,74,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,17,57,94,11,168,111,246,177,22,200,19,9,72,121,252,64,171,24,91,139,219,212,182,27,23,168,83,212,188,164,20,37,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,86,127,104,203,166,137,223,62,206,224,136,213,12,53,197,34,75,200,55,9,96,44,30,201,151,219,212,152,53,116,57,116,143,112,180,160,174,152,116,193,51,244,179,211,36,51,17,25,136,171,75,61,193,164,122,107,230,246,195,65,167,219,176,175,161,35,96,69,20,10,194,171,190,21,41,88,52,132,52,251,132,73,101,150,249,252,93,203,189,88,91,129,116,196,57,39,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,2,0,1,0],"hint":0},{"address":[111,123,60,108,110,90,226,50,236,153,200,90,156,221,158,125,125,111,245,39,51,43,252,62,186,225,134,61,116,152,66,74],"bytes":[208,1,0,152,2,23,176,23,176,23,184,53,23,184,64,23,176,23,184,37,23,184,36,23,184,61,23,184,62,23,184,65,116,22,21,20,19,18,136,2,7,176,7,176,7,184,53,7,184,64,7,176,7,184,37,7,184,36,7,184,61,7,184,62,7,184,65,120,3,32,3,180,184,42,131,7,176,7,184,27,7,184,56,147,23,114,184,26,180,18,23,116,184,2,113,184,13,178,23,114,32,7,181,19,18,23,116,184,2,114,184,45,179,180,23,114,184,45,20,19,18,116,181,183,179,178,180,21,19,18,129,7,114,184,26,21,180,119,184,30,178,129,7,176,148,23,114,177,179,16,23,116,182,183,130,7,176,7,113,184,13,16,145,23,114,177,24,6,24,5,115,24,5,18,16,17,17,16,23,116,184,2,113,184,13,18,17,114,32,7,181,181,184,12,23,116,184,2,114,184,45,19,18,17,184,46,184,54,116,181,20,179,19,18,131,7,114,177,178,178,7,114,184,55,179,16,7,116,184,2,114,177,183,183,17,114,32,7,183,183,113,32,16,183,119,184,15,184,19,184,12,129,7,184,19,146,23,114,184,45,24,5,16,23,116,184,2,114,184,49,24,6,17,16,184,50,184,48,116,24,5,24,7,183,18,17,130,7,116,182,181,184,43,181,184,12,7,116,184,2,184,46,16,184,46,184,54,118,184,15,184,50,184,48,129,7,184,50,116,24,5,24,7,183,113,32,16,24,7,16,113,23,179,17,116,184,16,184,50,17,184,48,116,184,17,184,50,17,184,48,16,18,116,184,16,184,19,18,184,12,116,184,17,184,19,18,184,12,16,17,22,115,184,33,22,178,16,20,19,133,7,176,7,184,27,7,184,56,7,184,41,7,114,184,26,178,184,31,119,184,30,184,23,129,7,176,148,23,184,40,23,116,182,24,7,130,7,176,7,113,184,18,16,145,23,114,177,24,10,24,9,115,24,9,18,16,17,17,16,23,116,184,2,113,184,18,18,17,114,32,7,24,8,184,24,184,14,23,116,184,2,116,182,24,9,184,28,19,18,17,184,58,184,63,116,24,8,20,24,6,19,18,131,7,114,177,24,5,184,23,7,114,184,49,113,32,5,21,16,7,116,184,2,114,177,24,7,184,32,17,114,32,7,24,7,184,32,115,32,10,24,7,22,21,119,184,15,184,25,184,14,129,7,184,25,146,23,113,184,57,16,23,116,184,2,113,184,59,17,16,184,60,184,52,114,184,34,18,17,130,7,116,182,24,8,130,7,176,7,114,177,24,9,16,145,23,114,177,24,11,24,10,115,24,10,18,16,17,184,24,184,14,7,116,184,2,184,58,16,184,58,184,63,118,184,15,184,60,184,52,129,7,184,60,114,184,34,115,32,10,24,11,179,178,16,117,179,24,6,178,180,23,22,17,116,184,16,184,60,17,184,52,116,184,17,184,60,17,184,52,16,18,116,184,16,184,25,18,184,14,116,184,17,184,25,18,184,14,16,17,179,115,184,33,179,184,23,16,180,23,114,33,12,1,176,21,114,184,29,114,177,180,21,19,114,184,29,116,182,180,184,42,21,19,18,74,32,4,114,33,0,0,176,32,9,24,1,24,2,24,0,24,4,32,14,24,3,24,5,24,7,33,8,0,24,6,24,9,32,5,24,8,24,10,32,7,32,10,32,16,24,11,113,32,16,181,113,177,181,115,32,10,24,8,23,22,34,1,0,0,33,6,0,33,15,0,113,177,24,8,113,184,13,181,24,12,32,13,32,17,113,32,5,20,113,32,5,23,113,184,18,184,24,113,33,11,1,176,114,32,7,178,16,130,7,176,7,114,177,24,10,16,145,23,114,177,24,12,24,11,115,24,11,18,16,17,33,2,0,113,34,1,0,1,176,113,32,5,19,113,32,5,22,113,33,6,1,176,114,24,9,113,32,5,179,24,7,114,177,18,17,114,177,20,17,114,177,20,19,114,177,23,22,114,177,180,23,114,177,24,6,16,145,23,113,184,13,183,115,183,19,16,18,130,7,176,7,114,177,178,16,145,23,114,177,183,179,115,179,18,16,17,130,7,176,7,114,177,24,5,16,145,23,114,177,24,7,24,6,115,24,6,18,16,17,130,7,176,7,184,40,145,23,113,184,18,24,7,115,24,7,18,16,17,114,182,24,5,184,44,114,184,45,24,5,113,32,16,24,5,130,7,176,7,114,177,24,7,16,145,23,114,177,24,9,24,8,115,24,8,18,16,17,114,32,13,24,6,184,47,114,182,24,6,184,47,114,184,49,24,6,113,32,16,24,6,130,7,176,7,114,177,24,11,16,145,23,114,177,24,13,24,12,115,24,12,18,16,17,118,32,17,24,10,184,51,178,180,23,22,147,23,176,23,184,35,23,184,35,0,114,32,13,24,5,184,44,114,182,179,130,7,176,7,114,177,183,16,145,23,114,177,24,5,181,115,181,18,16,17,114,184,55,17,16,115,182,24,9,184,28,113,32,5,180,113,184,57,115,32,10,24,9,180,23,115,182,24,10,184,51,113,32,5,178,113,184,59,115,32,10,24,10,178,180,116,182,21,130,7,176,7,114,177,22,16,145,23,184,39,115,23,18,16,17,18,16,145,23,184,38,116,21,23,16,113,32,16,23,114,32,13,23,130,7,176,7,114,177,180,16,145,23,114,177,179,178,115,178,18,16,17,118,32,17,24,9,184,28,180,23,22,21,148,23,176,23,114,177,19,18,23,114,177,19,17,23,116,182,20,130,7,176,7,114,177,21,16,145,23,184,38,115,22,18,16,17,18,16,0,149,23,184,39,23,176,23,184,27,23,184,56,23,184,41,116,179,184,31,20,115,32,10,181,19,18,118,32,17,181,184,43,19,18,17,16,18,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,6,130,169,187,145,109,99,25,149,171,18,87,167,82,105,228,15,62,82,43,99,203,13,117,117,79,27,182,17,178,98,154,31,181,154,127,225,27,53,79,1,145,116,89,241,61,225,54,55,151,173,12,23,60,111,134,41,121,101,6,10,234,138,44,34,188,206,129,171,151,91,110,227,170,108,194,69,113,177,50,138,249,169,239,200,164,15,214,191,105,88,120,228,81,106,107,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,91,200,186,175,28,224,243,100,229,66,105,233,238,44,132,68,97,202,69,3,36,117,189,206,82,109,133,255,87,20,28,101,143,112,180,160,174,152,116,193,51,244,179,211,36,51,17,25,136,171,75,61,193,164,122,107,230,246,195,65,167,219,176,175,171,154,109,137,72,73,148,55,108,192,222,72,8,59,163,82,24,151,208,77,71,179,52,161,16,167,124,84,197,89,93,108,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,187,67,180,68,88,106,58,237,43,170,13,123,116,49,202,109,205,20,171,148,68,188,119,146,13,19,67,51,208,191,229,116,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,212,148,220,96,19,134,186,142,143,11,113,31,230,42,45,96,171,96,198,72,140,140,246,206,151,121,110,188,58,213,254,251,212,242,86,44,127,148,111,155,110,164,100,223,38,78,46,178,220,160,215,184,60,235,121,164,78,31,105,70,61,221,236,0,218,224,24,9,166,175,10,253,129,230,253,211,161,211,159,239,134,168,168,196,233,8,24,177,163,87,225,128,221,218,178,89,221,130,125,188,51,21,25,234,120,233,109,145,197,211,51,90,209,123,164,153,203,23,203,36,50,52,242,237,142,210,28,95,244,242,199,63,63,176,199,189,250,212,209,10,144,100,144,38,99,103,162,129,151,44,249,218,31,186,104,181,104,141,20,40,246,128,13,148,231,34,20,133,128,99,68,60,242,66,168,9,86,193,105,174,52,239,213,78,213,211,91,48,17,10,201,204,2,0,1,0],"hint":4294967295},{"address":[111,167,75,38,181,202,129,72,66,34,167,87,80,35,5,40,27,81,15,179,41,38,116,138,65,22,169,229,131,220,25,1],"bytes":[208,1,1,149,23,0,23,178,23,177,23,179,23,180,113,19,18,133,7,0,7,178,7,177,7,179,7,180,117,33,3,1,20,129,7,113,176,20,113,20,16,18,129,7,113,32,0,20,113,17,16,129,7,20,113,18,16,5,32,4,113,176,17,145,23,113,176,16,1,145,23,18,113,18,114,32,1,19,16,145,23,113,32,0,19,113,19,114,32,2,20,16,5,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,54,61,7,17,130,190,65,78,26,88,89,155,131,245,225,159,155,135,55,35,5,79,66,135,186,105,112,90,175,239,39,218,140,192,225,54,12,27,41,16,141,171,61,97,114,231,252,232,169,170,150,64,218,164,187,233,155,161,48,93,150,35,98,75,226,94,101,45,187,137,181,227,90,47,36,47,238,235,72,46,81,100,226,84,85,25,67,11,61,9,70,223,255,235,63,98,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,2,0,192],"hint":4294967295},{"address":[113,68,18,70,255,205,26,50,174,12,218,3,107,21,86,215,23,242,75,32,237,113,18,160,92,173,191,173,229,204,184,53],"bytes":[208,9,0,148,23,176,23,176,23,182,23,182,184,7,132,7,176,7,176,7,182,7,182,120,0,32,15,132,7,176,7,176,7,182,7,182,184,7,19,18,17,16,131,7,176,7,184,1,7,182,115,184,5,114,179,114,180,177,18,177,17,184,3,131,7,176,7,113,181,113,178,16,7,184,1,115,184,5,114,179,114,180,184,0,177,184,0,16,184,3,132,7,176,7,176,7,184,4,7,184,4,118,34,17,0,1,176,183,130,7,176,7,115,33,11,1,176,114,180,20,19,16,114,179,17,113,178,21,161,7,114,179,183,184,2,115,32,2,183,19,114,32,6,19,18,16,184,6,116,33,9,1,176,184,6,183,114,32,18,19,18,16,32,5,115,33,12,0,176,100,113,32,13,100,32,7,114,33,0,0,176,32,10,116,35,3,0,0,0,176,176,176,114,33,1,0,176,32,14,113,179,177,113,181,17,114,180,19,18,113,178,18,113,181,177,113,178,19,113,32,8,177,113,181,113,178,17,113,33,16,0,184,1,114,180,184,2,184,0,114,179,183,19,19,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,12,233,210,122,204,93,107,209,245,173,188,23,77,72,97,124,252,67,223,107,211,227,73,136,93,215,165,81,60,34,58,251,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,57,106,200,100,213,170,98,76,193,241,114,201,124,222,57,35,140,200,34,160,37,143,33,86,52,21,95,220,196,159,228,20,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,70,35,208,49,99,188,238,71,7,89,179,46,71,204,94,153,116,73,156,157,115,141,201,235,77,165,161,41,140,181,237,20,91,200,186,175,28,224,243,100,229,66,105,233,238,44,132,68,97,202,69,3,36,117,189,206,82,109,133,255,87,20,28,101,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,235,80,53,253,14,237,19,39,158,181,89,13,194,124,130,114,1,54,228,250,165,233,124,128,18,170,79,204,128,120,19,52,238,26,61,140,224,254,229,196,154,95,21,193,5,247,152,94,66,37,224,91,255,54,11,111,58,71,144,155,18,76,219,187,247,154,238,65,62,228,123,177,250,111,32,39,251,4,239,21,151,135,26,64,134,212,33,124,255,73,19,250,29,106,224,186,251,3,245,167,225,65,216,64,37,179,165,3,222,220,83,206,134,242,151,189,227,107,188,27,152,104,122,234,180,53,153,104,252,85,51,60,220,225,188,4,62,134,112,198,177,143,196,86,113,186,141,34,250,32,69,166,162,221,84,197,244,100,84,99,2,0,1,0],"hint":0},{"address":[113,116,99,130,92,85,39,2,186,25,8,185,250,93,143,63,119,134,215,115,12,99,62,65,216,211,128,147,159,238,183,72],"bytes":[208,1,1,149,23,1,23,0,23,176,23,18,23,19,20,133,7,1,7,0,7,176,7,18,7,19,117,33,1,1,19,129,7,113,32,2,19,21,18,129,7,113,32,0,19,17,129,7,19,18,1,113,32,2,16,3,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,226,94,101,45,187,137,181,227,90,47,36,47,238,235,72,46,81,100,226,84,85,25,67,11,61,9,70,223,255,235,63,98,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,2,0,192],"hint":3},{"address":[114,210,136,75,136,77,34,213,201,45,246,252,67,145,231,219,169,53,28,134,241,118,56,204,27,66,93,235,210,35,205,26],"bytes":[208,9,0,145,23,176,179,131,7,176,7,176,7,178,117,33,7,0,129,7,176,179,18,32,4,17,16,4,32,1,113,33,0,0,176,115,177,32,3,17,16,146,23,176,23,178,114,32,6,115,33,5,1,176,18,17,115,177,32,2,18,17,8,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,186,84,155,125,21,81,10,79,42,151,166,175,188,36,103,150,149,180,48,8,218,53,201,85,123,113,145,88,33,143,206,163,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,227,202,247,231,13,241,107,26,110,135,74,200,103,132,25,81,105,132,248,209,230,141,36,208,221,153,6,42,242,14,140,234,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,2,0,1,0],"hint":0},{"address":[115,212,178,99,138,214,188,141,223,68,211,170,230,99,3,57,95,70,25,85,25,55,98,216,54,179,90,48,113,121,249,251],"bytes":[208,1,0,150,23,176,23,180,23,176,23,178,23,179,23,181,114,20,19,18,134,7,176,7,180,7,176,7,178,7,179,7,181,116,33,4,0,129,7,176,114,21,16,19,19,113,17,18,129,7,176,114,17,16,19,6,32,2,115,33,0,0,176,32,5,115,33,6,0,176,97,113,32,7,97,113,177,18,145,23,113,177,19,114,19,32,8,16,146,23,176,23,113,177,17,0,146,23,176,23,113,177,21,114,21,113,32,3,17,16,9,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,1,0],"hint":4294967295},{"address":[116,129,248,50,7,172,22,52,112,238,167,107,224,144,138,118,130,209,23,76,230,235,194,196,12,235,21,158,220,100,24,146],"bytes":[208,1,0,113,33,1,0,32,2,114,33,3,0,32,2,32,0,0,4,17,171,191,152,100,129,197,58,33,200,203,33,238,37,129,174,98,56,174,219,236,21,249,114,149,157,8,107,239,26,25,133,36,58,236,162,36,20,248,239,254,81,241,25,172,162,71,149,152,170,72,252,221,0,96,60,94,184,74,141,22,226,88,213,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,148,77,150,214,42,122,160,96,153,65,92,165,175,218,48,241,66,199,14,18,254,189,182,209,85,174,176,172,85,8,152,64,1,0],"hint":9},{"address":[119,145,160,144,197,212,60,57,222,182,16,184,3,163,78,62,89,167,210,38,4,63,64,114,1,81,75,236,107,253,170,181],"bytes":[208,1,1,147,23,0,23,113,176,16,23,183,182,132,7,0,7,113,176,16,7,183,7,113,176,18,119,34,5,1,0,19,130,7,179,7,180,145,23,115,177,21,129,7,181,145,23,178,113,176,23,17,178,18,16,130,7,179,7,115,177,20,129,7,180,145,23,181,178,113,33,0,1,20,17,132,7,19,7,180,7,181,7,115,177,22,129,7,178,145,23,113,176,23,113,176,24,0,115,33,4,1,22,18,17,115,33,4,1,23,19,113,64,2,16,17,17,8,33,1,1,34,3,0,1,113,176,22,113,176,19,113,176,20,113,176,21,145,23,113,176,18,179,115,177,17,129,7,113,176,17,182,16,6,57,148,188,81,227,104,111,48,161,212,131,214,157,10,131,90,123,72,77,137,35,147,192,132,248,122,88,73,222,84,243,2,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,154,188,179,8,71,233,245,145,108,38,16,126,148,119,150,163,32,109,86,206,46,122,164,98,116,232,5,70,234,163,248,235,179,167,216,2,73,253,130,49,0,238,3,98,98,50,209,65,42,14,131,53,39,93,93,245,59,146,148,56,135,182,80,247,220,50,12,210,41,236,248,22,132,182,247,17,13,188,74,247,88,55,95,62,217,112,230,167,102,33,9,40,218,106,182,97,2,1,192,192],"hint":4294967295},{"address":[120,108,139,241,102,165,140,25,16,248,4,47,230,115,196,20,77,48,174,2,242,156,174,177,207,76,184,128,156,70,172,147],"bytes":[193,1,0,1,1,0,145,23,0,0,1,0,1,0,1,1,146,23,0,23,146,23,16,23,32,0,18,113,49,0,1,17,0,1,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,2,1,192,192],"hint":0},{"address":[120,192,56,5,248,234,247,211,103,224,245,121,9,171,213,102,217,74,43,235,207,98,112,254,47,231,74,249,84,237,13,0],"bytes":[208,1,0,32,0,33,1,0,0,2,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,221,146,133,172,69,212,172,133,209,127,160,211,36,61,121,9,199,130,162,162,118,238,63,176,207,254,250,154,251,219,13,225,1,1,0],"hint":4294967295},{"address":[121,36,8,240,243,193,179,109,144,242,3,38,249,166,144,50,89,229,153,225,214,42,166,4,226,138,239,193,4,80,198,44],"bytes":[208,9,0,145,23,177,113,32,0,176,129,7,177,115,32,5,176,16,114,33,1,1,32,6,176,2,113,32,3,16,113,33,4,0,32,2,7,1,210,87,183,1,146,38,189,176,77,45,212,108,97,145,226,7,228,101,81,222,88,168,234,40,104,82,126,191,140,146,236,2,1,207,17,44,128,169,32,218,175,29,186,208,247,219,163,151,224,41,20,165,148,50,128,126,189,159,55,118,75,214,74,6,95,200,180,19,147,245,37,193,229,65,185,212,188,151,194,12,19,191,35,167,32,154,32,147,182,244,82,115,48,17,74,51,52,114,218,81,164,158,201,126,219,71,65,146,239,73,222,114,22,130,75,39,118,45,50,83,218,125,44,223,39,73,206,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,99,235,45,177,245,110,195,241,41,10,225,62,43,223,229,48,94,151,17,133,112,236,45,190,68,58,165,168,215,235,241,181,154,222,24,249,71,95,80,187,218,209,195,211,226,6,199,177,22,169,133,38,75,236,35,35,223,17,81,230,198,53,60,5,2,0,1,0],"hint":0},{"address":[121,146,78,60,79,192,6,120,35,234,226,4,119,232,5,173,79,86,125,253,73,93,210,184,85,252,91,55,97,190,92,161],"bytes":[208,1,0,150,23,176,23,176,23,182,23,181,23,183,23,184,0,113,19,18,134,7,176,7,176,7,182,7,181,7,183,7,184,0,117,33,6,0,178,129,7,113,179,178,113,20,16,18,129,7,113,32,0,178,113,17,16,129,7,178,113,18,16,9,32,2,114,33,1,0,176,32,5,114,177,21,20,32,7,114,177,20,19,113,179,114,177,18,17,145,23,113,179,114,177,17,16,0,145,23,114,177,19,18,113,18,114,32,3,180,16,145,23,113,32,0,180,113,19,114,32,4,178,16,8,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,54,61,7,17,130,190,65,78,26,88,89,155,131,245,225,159,155,135,55,35,5,79,66,135,186,105,112,90,175,239,39,218,140,192,225,54,12,27,41,16,141,171,61,97,114,231,252,232,169,170,150,64,218,164,187,233,155,161,48,93,150,35,98,75,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,226,94,101,45,187,137,181,227,90,47,36,47,238,235,72,46,81,100,226,84,85,25,67,11,61,9,70,223,255,235,63,98,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,1,0],"hint":4294967295},{"address":[123,182,89,135,102,113,224,61,7,49,196,86,232,148,206,158,111,125,232,37,10,180,174,112,17,61,192,142,36,83,33,39],"bytes":[208,1,0,146,23,176,23,176,181,130,7,176,7,176,117,33,11,1,181,179,114,32,14,178,32,8,129,7,179,114,32,3,180,115,32,4,18,17,16,129,7,113,32,0,179,114,32,5,180,115,32,6,18,17,16,6,32,2,114,33,1,0,176,32,9,114,32,7,17,16,115,33,10,1,32,12,178,32,8,114,177,18,17,113,32,13,114,177,17,16,15,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,54,61,7,17,130,190,65,78,26,88,89,155,131,245,225,159,155,135,55,35,5,79,66,135,186,105,112,90,175,239,39,218,92,153,220,97,136,158,74,30,6,255,111,36,209,132,220,101,83,2,140,198,43,137,250,97,188,35,17,91,106,118,32,104,140,192,225,54,12,27,41,16,141,171,61,97,114,231,252,232,169,170,150,64,218,164,187,233,155,161,48,93,150,35,98,75,147,192,234,112,197,195,63,123,206,205,64,93,253,238,92,84,113,247,74,238,97,248,187,97,11,37,82,215,255,226,129,131,158,68,91,157,95,130,82,119,35,71,135,46,144,155,93,180,231,236,167,8,108,237,244,254,198,222,132,15,107,123,95,146,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,228,14,118,142,182,13,77,21,4,125,13,195,184,32,234,175,107,253,251,200,161,173,38,141,205,120,114,45,50,22,74,185,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,248,28,25,95,83,35,31,11,61,143,111,208,136,195,72,14,249,171,205,195,91,196,66,224,118,62,46,129,151,174,129,48,2,0,1,0],"hint":5},{"address":[125,5,202,27,89,81,239,15,178,70,105,218,191,12,42,52,131,94,52,226,173,174,122,30,113,112,73,15,34,82,122,87],"bytes":[208,1,0,152,0,23,176,23,184,46,23,184,57,23,176,23,184,32,23,184,53,23,184,55,23,184,58,115,21,20,19,18,136,0,7,176,7,184,46,7,184,57,7,176,7,184,32,7,184,53,7,184,55,7,184,58,120,3,32,3,23,184,35,131,7,176,7,184,31,7,184,54,147,23,114,184,23,23,18,23,116,182,113,184,15,177,23,114,32,8,183,19,18,23,116,182,114,184,38,179,177,23,114,184,38,20,19,18,115,183,180,179,177,20,19,18,129,7,114,184,23,20,23,119,184,26,177,129,7,176,148,23,184,33,23,116,181,180,184,36,17,16,23,116,182,113,184,15,18,17,114,32,8,183,183,184,10,23,116,182,114,184,38,19,18,17,184,39,184,47,115,183,20,19,18,131,7,114,178,177,177,7,114,184,48,179,16,7,116,182,114,178,180,180,17,114,32,8,180,180,113,32,18,180,119,184,12,184,16,184,10,129,7,184,16,146,23,114,184,38,24,4,16,23,116,182,114,184,42,24,5,17,16,184,43,184,41,115,24,4,24,6,18,17,130,7,116,181,183,130,7,176,7,114,178,24,4,16,114,24,4,17,16,183,184,10,7,116,182,184,39,16,184,39,184,47,118,184,12,184,43,184,41,129,7,184,43,115,24,4,24,6,113,32,18,24,6,16,113,23,32,7,17,116,184,13,184,43,17,184,41,116,184,14,184,43,17,184,41,16,18,116,184,13,184,16,18,184,10,116,184,14,184,16,18,184,10,16,17,21,115,184,29,21,177,16,20,19,133,7,176,7,184,31,7,184,54,7,114,179,18,17,7,114,184,23,177,184,27,119,184,26,184,20,129,7,176,148,23,184,34,23,116,181,24,6,130,7,176,7,114,178,24,7,16,114,24,7,17,16,17,16,23,116,182,114,178,24,7,18,17,114,32,8,24,7,184,21,184,11,23,116,182,116,181,24,8,184,24,19,18,17,184,50,184,56,115,24,7,20,19,18,131,7,114,178,24,4,184,20,7,114,184,42,113,32,5,21,16,7,116,182,114,178,24,6,184,28,17,114,32,8,24,6,184,28,115,32,12,24,6,22,21,119,184,12,184,22,184,11,129,7,184,22,146,23,113,184,49,16,23,116,182,113,184,51,17,16,184,52,184,45,114,184,30,18,17,130,7,116,181,24,7,130,7,176,7,114,178,24,8,16,114,24,8,17,16,184,21,184,11,7,116,182,184,50,16,184,50,184,56,118,184,12,184,52,184,45,129,7,184,52,114,184,30,115,32,12,24,10,180,179,16,116,180,179,177,23,22,17,116,184,13,184,52,17,184,45,116,184,14,184,52,17,184,45,16,18,116,184,13,184,22,18,184,11,116,184,14,184,22,18,184,11,16,17,179,115,184,29,179,184,20,16,177,23,114,33,14,1,176,20,114,184,25,114,178,23,20,19,114,184,25,116,181,23,184,35,20,19,18,67,32,4,24,0,114,33,0,0,176,32,11,24,1,24,2,32,16,33,10,0,24,3,24,4,24,6,24,7,32,5,24,5,24,8,32,8,32,12,32,18,24,9,113,32,18,183,115,32,12,24,7,23,22,34,1,0,0,33,6,0,33,17,0,113,178,183,113,184,15,183,24,10,32,15,32,19,113,32,5,20,113,32,5,23,114,178,24,7,184,21,113,33,13,1,176,130,7,176,7,114,178,24,9,16,114,24,9,17,16,33,2,0,113,34,1,0,1,176,113,32,5,19,113,32,5,22,113,33,6,1,176,113,24,8,113,32,5,180,114,32,8,177,16,114,178,19,16,114,178,179,16,114,178,24,5,16,130,7,176,7,114,178,177,16,114,177,17,16,130,7,176,7,113,184,15,16,114,183,17,16,130,7,176,7,184,34,114,24,5,17,16,114,181,24,4,184,37,114,184,38,24,4,113,32,18,24,4,130,7,176,7,114,178,24,6,16,114,24,6,17,16,114,32,15,24,5,184,40,114,181,24,5,184,40,114,184,42,24,5,113,32,18,24,5,130,7,176,7,114,178,24,10,16,114,24,10,17,16,118,32,19,24,9,184,44,179,177,23,22,146,23,176,23,114,178,17,16,0,114,32,15,24,4,184,37,114,181,179,130,7,176,7,114,178,180,16,114,180,17,16,115,181,24,8,184,24,113,32,5,177,113,184,49,115,32,12,24,8,177,23,115,181,24,9,184,44,113,32,5,179,113,184,51,115,32,12,24,9,179,177,116,181,20,130,7,176,7,114,178,21,16,114,21,17,16,17,16,114,184,48,17,16,145,23,32,9,115,20,22,113,32,18,22,114,32,15,22,130,7,176,7,114,178,23,16,114,23,17,16,118,32,19,24,8,184,24,177,23,22,21,147,23,176,23,114,178,18,16,23,116,181,19,130,7,176,7,114,178,20,16,114,20,17,16,17,16,0,148,23,176,23,114,32,8,23,16,23,116,181,177,130,7,176,7,184,33,114,179,17,16,17,16,23,114,177,18,17,115,177,184,27,115,32,12,180,19,18,118,32,19,180,184,36,19,18,17,16,20,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,6,130,169,187,145,109,99,25,149,171,18,87,167,82,105,228,15,62,82,43,99,203,13,117,117,79,27,182,17,178,98,154,31,181,154,127,225,27,53,79,1,145,116,89,241,61,225,54,55,151,173,12,23,60,111,134,41,121,101,6,10,234,138,44,34,188,206,129,171,151,91,110,227,170,108,194,69,113,177,50,138,249,169,239,200,164,15,214,191,105,88,120,228,81,106,107,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,91,200,186,175,28,224,243,100,229,66,105,233,238,44,132,68,97,202,69,3,36,117,189,206,82,109,133,255,87,20,28,101,120,192,56,5,248,234,247,211,103,224,245,121,9,171,213,102,217,74,43,235,207,98,112,254,47,231,74,249,84,237,13,0,143,112,180,160,174,152,116,193,51,244,179,211,36,51,17,25,136,171,75,61,193,164,122,107,230,246,195,65,167,219,176,175,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,171,154,109,137,72,73,148,55,108,192,222,72,8,59,163,82,24,151,208,77,71,179,52,161,16,167,124,84,197,89,93,108,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,187,67,180,68,88,106,58,237,43,170,13,123,116,49,202,109,205,20,171,148,68,188,119,146,13,19,67,51,208,191,229,116,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,212,148,220,96,19,134,186,142,143,11,113,31,230,42,45,96,171,96,198,72,140,140,246,206,151,121,110,188,58,213,254,251,212,242,86,44,127,148,111,155,110,164,100,223,38,78,46,178,220,160,215,184,60,235,121,164,78,31,105,70,61,221,236,0,218,224,24,9,166,175,10,253,129,230,253,211,161,211,159,239,134,168,168,196,233,8,24,177,163,87,225,128,221,218,178,89,221,130,125,188,51,21,25,234,120,233,109,145,197,211,51,90,209,123,164,153,203,23,203,36,50,52,242,237,142,210,28,95,244,242,199,63,63,176,199,189,250,212,209,10,144,100,144,38,99,103,162,129,151,44,249,218,31,186,104,181,104,141,20,40,246,128,13,148,231,34,20,133,128,99,68,60,242,66,168,9,86,193,105,174,52,239,213,78,213,211,91,48,17,10,201,204,2,0,1,0],"hint":4294967295},{"address":[125,89,104,124,139,90,19,89,201,144,19,230,51,213,6,81,53,59,128,48,168,164,23,252,117,240,70,72,9,55,125,102],"bytes":[193,1,0,0,0,0,1,1,0,0,0,0,1,145,23,113,32,2,115,33,3,0,32,1,96,113,32,4,96,48,0,0,5,46,243,224,221,165,41,59,218,150,93,10,220,237,252,125,56,114,68,172,115,106,96,20,167,32,193,214,63,160,237,224,47,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,144,2,42,228,197,213,42,210,138,205,128,5,29,212,31,39,245,28,156,74,251,171,27,179,145,119,60,25,239,13,193,233,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,2,0,1,0],"hint":0},{"address":[125,153,57,223,4,184,173,187,198,51,152,205,122,5,146,120,137,156,31,226,17,210,196,144,216,29,104,194,81,202,76,30],"bytes":[208,9,0,147,23,176,23,176,23,184,1,114,177,114,32,2,18,17,17,131,7,176,7,176,7,184,1,161,7,114,177,116,180,182,184,0,129,7,182,117,32,4,18,16,178,19,179,129,7,184,2,19,17,117,32,8,17,129,7,113,32,16,182,114,177,116,180,183,16,184,3,184,4,18,184,0,129,7,182,117,32,3,178,18,17,19,179,129,7,184,2,116,33,17,0,183,114,177,116,180,183,114,32,10,183,16,184,3,184,4,18,17,16,16,13,32,6,114,33,1,0,176,32,11,113,32,7,19,113,32,9,19,113,33,15,1,176,115,33,13,0,176,101,113,32,14,101,114,177,181,17,114,177,181,18,114,32,12,181,17,114,177,181,16,113,32,0,182,129,7,183,117,32,4,19,16,113,32,7,20,20,113,32,9,20,129,7,113,32,0,183,20,18,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,14,140,157,90,31,226,163,144,223,50,193,100,1,212,239,112,30,85,166,100,127,243,255,35,237,59,47,103,30,124,173,51,21,206,249,241,190,151,131,132,141,36,79,136,177,164,74,85,50,125,29,43,77,181,239,5,123,162,169,144,65,183,33,65,35,3,107,242,16,62,77,46,221,118,183,89,205,206,176,124,5,155,123,120,198,200,166,96,11,7,5,144,220,84,160,0,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,85,120,123,177,28,48,132,118,226,91,10,155,31,223,119,61,88,98,42,55,231,75,228,202,197,111,98,159,100,1,53,248,127,96,33,226,23,139,62,99,123,68,50,158,52,254,48,20,156,40,131,171,199,254,37,234,170,171,3,154,196,227,32,26,140,192,225,54,12,27,41,16,141,171,61,97,114,231,252,232,169,170,150,64,218,164,187,233,155,161,48,93,150,35,98,75,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,175,88,107,7,84,110,31,202,154,176,120,13,28,35,106,248,211,96,196,198,187,50,187,12,208,62,201,202,99,211,218,150,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,228,14,118,142,182,13,77,21,4,125,13,195,184,32,234,175,107,253,251,200,161,173,38,141,205,120,114,45,50,22,74,185,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,247,154,238,65,62,228,123,177,250,111,32,39,251,4,239,21,151,135,26,64,134,212,33,124,255,73,19,250,29,106,224,186,2,0,1,0],"hint":0},{"address":[126,8,30,243,213,142,60,213,171,66,50,211,216,144,184,115,186,113,80,205,98,137,50,70,133,87,62,251,71,244,135,32],"bytes":[208,1,1,145,23,1,0,129,7,1,146,23,16,23,17,113,32,1,115,33,0,1,18,17,16,0,2,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,2,64,192,1,0,192],"hint":4294967295},{"address":[126,204,91,227,4,131,198,182,251,205,112,40,223,196,199,12,110,66,19,88,162,214,216,71,24,148,123,57,108,97,100,51],"bytes":[208,9,0,145,23,176,116,33,0,0,176,32,8,114,178,98,113,177,98,118,35,1,0,0,0,176,176,176,115,34,12,0,0,176,176,114,33,5,0,176,32,13,179,16,129,7,176,115,32,7,179,16,113,32,9,114,178,100,113,177,100,4,32,3,32,11,113,33,10,0,176,114,178,102,113,177,102,14,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,72,252,114,31,187,193,114,224,146,95,162,122,241,103,29,226,37,186,146,113,52,128,41,152,177,10,21,104,161,136,101,43,97,77,217,229,201,188,180,126,143,59,37,173,22,90,151,122,31,61,199,114,50,70,93,227,182,142,40,95,119,199,135,53,171,19,190,223,66,232,75,174,15,124,98,199,221,106,138,218,87,30,136,41,190,214,234,85,130,23,240,54,27,94,37,208,171,46,242,123,57,90,146,109,185,97,242,57,187,55,95,114,4,106,121,3,42,193,105,121,128,74,49,7,50,221,235,99,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,175,9,117,110,177,82,121,33,25,161,227,86,120,130,27,112,231,216,72,81,58,119,85,17,146,183,109,115,45,61,236,133,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,209,175,140,47,93,246,86,19,16,237,169,150,109,112,205,159,81,104,143,0,40,10,227,135,239,113,101,70,169,212,21,251,254,77,94,53,147,241,44,126,254,17,58,115,217,127,219,138,235,250,120,184,27,185,29,195,210,9,55,161,132,15,154,69,1,0],"hint":0},{"address":[127,96,33,226,23,139,62,99,123,68,50,158,52,254,48,20,156,40,131,171,199,254,37,234,170,171,3,154,196,227,32,26],"bytes":[208,9,0,145,23,176,116,33,0,0,176,32,4,16,113,32,2,16,129,7,176,113,32,3,16,1,32,1,5,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,82,44,150,10,189,170,15,126,101,246,144,196,209,146,34,107,222,162,161,55,89,220,19,50,109,239,182,198,176,21,148,111,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,1,0],"hint":0},{"address":[127,102,69,142,31,137,141,70,61,222,210,142,237,123,140,24,107,128,134,79,228,183,18,62,197,203,28,171,94,219,131,202],"bytes":[208,1,0,148,23,177,23,176,23,178,23,179,113,19,18,132,7,177,7,176,7,178,7,179,116,33,4,0,129,7,176,113,20,16,18,113,17,32,2,129,7,176,113,17,16,4,32,0,145,23,176,0,145,23,32,3,113,18,32,5,145,23,176,113,19,113,32,1,16,6,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,120,192,56,5,248,234,247,211,103,224,245,121,9,171,213,102,217,74,43,235,207,98,112,254,47,231,74,249,84,237,13,0,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,1,0],"hint":4294967295},{"address":[129,155,32,93,130,126,216,1,174,44,16,223,116,26,36,65,250,58,28,159,49,94,52,206,127,27,200,243,162,108,220,158],"bytes":[193,1,0,1,2,0,146,23,0,23,32,0,0,1,0,1,0,2,1,147,23,0,23,32,0,23,17,114,49,0,1,18,17,0,1,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,2,1,192,192],"hint":0},{"address":[130,77,28,83,216,193,195,207,10,39,242,70,57,236,43,225,236,193,61,74,1,201,147,23,21,149,237,204,246,148,151,55],"bytes":[208,1,0,146,23,176,23,176,176,130,7,176,7,176,117,33,11,1,176,178,114,32,8,177,16,129,7,178,117,32,6,17,16,113,32,4,18,18,113,32,5,18,129,7,113,32,0,178,177,3,32,3,115,33,9,0,176,98,113,32,10,98,116,33,1,0,176,32,7,177,16,12,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,127,96,33,226,23,139,62,99,123,68,50,158,52,254,48,20,156,40,131,171,199,254,37,234,170,171,3,154,196,227,32,26,139,221,212,61,54,175,21,159,143,28,126,223,71,125,159,10,6,162,107,251,236,245,161,152,192,233,236,74,195,112,246,230,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,175,88,107,7,84,110,31,202,154,176,120,13,28,35,106,248,211,96,196,198,187,50,187,12,208,62,201,202,99,211,218,150,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,228,14,118,142,182,13,77,21,4,125,13,195,184,32,234,175,107,253,251,200,161,173,38,141,205,120,114,45,50,22,74,185,2,0,1,0],"hint":7},{"address":[131,135,96,192,74,148,59,17,226,30,167,195,67,59,148,213,121,177,173,50,185,209,206,151,139,226,230,173,62,22,167,230],"bytes":[208,9,0,149,23,0,23,0,23,176,23,176,23,177,32,1,133,7,0,7,0,7,176,7,176,7,177,118,32,3,20,19,129,7,114,32,2,20,19,32,1,16,129,7,20,113,19,16,129,7,19,113,18,16,2,113,32,0,17,114,32,2,19,18,4,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,161,35,96,69,20,10,194,171,190,21,41,88,52,132,52,251,132,73,101,150,249,252,93,203,189,88,91,129,116,196,57,39,227,202,247,231,13,241,107,26,110,135,74,200,103,132,25,81,105,132,248,209,230,141,36,208,221,153,6,42,242,14,140,234,239,98,173,170,214,208,43,159,81,45,36,236,23,22,199,59,255,122,224,141,138,228,95,227,48,224,153,37,165,171,147,165,1,0],"hint":0},{"address":[132,147,219,244,185,115,159,176,245,9,36,27,253,226,235,26,132,121,236,124,91,215,133,170,248,33,27,167,133,11,126,20],"bytes":[208,1,0,145,23,32,2,184,8,129,7,32,2,161,7,177,113,32,9,113,32,32,16,116,184,9,113,184,1,184,12,113,184,0,184,12,114,182,113,179,16,184,7,116,184,9,113,184,1,184,11,113,184,0,184,11,114,182,113,179,114,184,3,113,184,13,114,178,96,113,176,96,114,178,104,12,113,176,104,12,184,15,116,184,9,113,184,1,184,10,113,184,0,184,10,114,182,113,179,114,184,3,113,184,14,114,178,104,14,113,176,104,14,114,178,104,5,113,176,104,5,184,16,114,182,113,179,114,184,3,114,184,4,113,184,6,114,178,104,2,113,176,104,2,114,178,101,113,176,101,114,178,104,23,113,176,104,23,114,182,113,179,114,184,3,113,184,14,180,184,5,184,16,25,32,30,32,7,113,33,29,0,177,32,24,114,178,104,9,113,176,104,9,32,12,113,33,23,0,181,113,33,3,0,177,113,32,16,16,115,33,1,0,177,32,25,16,115,35,4,0,0,0,177,177,177,113,184,2,113,183,32,19,113,184,2,113,183,32,15,114,178,104,18,113,176,104,18,114,184,2,113,183,32,6,16,113,33,8,0,181,113,33,11,0,181,113,33,14,1,184,8,114,178,104,10,113,176,104,10,114,178,104,19,113,176,104,19,114,178,104,20,113,176,104,20,113,184,4,113,184,6,180,113,184,4,113,184,6,114,178,104,13,113,176,104,13,114,182,113,179,114,184,3,114,184,4,16,180,184,5,184,7,114,182,113,179,114,184,3,113,184,13,180,184,5,184,15,33,0,38,60,169,245,127,113,119,244,149,227,113,31,140,221,89,150,122,10,26,77,232,149,177,235,238,86,108,209,136,62,212,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,6,95,200,180,19,147,245,37,193,229,65,185,212,188,151,194,12,19,191,35,167,32,154,32,147,182,244,82,115,48,17,74,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,46,243,224,221,165,41,59,218,150,93,10,220,237,252,125,56,114,68,172,115,106,96,20,167,32,193,214,63,160,237,224,47,52,54,62,234,205,31,207,21,209,42,216,182,41,220,205,78,92,64,187,231,67,36,93,167,201,198,121,223,19,162,29,202,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,57,148,188,81,227,104,111,48,161,212,131,214,157,10,131,90,123,72,77,137,35,147,192,132,248,122,88,73,222,84,243,2,57,226,177,52,39,60,228,186,35,11,80,230,171,31,164,52,150,81,152,112,119,136,39,157,210,113,219,190,19,192,70,164,59,182,69,34,57,91,37,157,93,27,104,173,99,139,119,231,170,222,35,36,104,210,203,60,153,40,235,25,241,141,11,251,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,98,178,194,235,79,232,199,133,128,191,119,139,254,148,198,236,44,203,37,211,8,54,159,192,13,135,184,133,238,190,83,72,104,192,4,239,221,73,144,202,138,249,43,251,168,208,136,73,88,77,203,160,123,181,98,31,169,69,106,139,132,65,152,63,113,116,99,130,92,85,39,2,186,25,8,185,250,93,143,63,119,134,215,115,12,99,62,65,216,211,128,147,159,238,183,72,116,129,248,50,7,172,22,52,112,238,167,107,224,144,138,118,130,209,23,76,230,235,194,196,12,235,21,158,220,100,24,146,123,182,89,135,102,113,224,61,7,49,196,86,232,148,206,158,111,125,232,37,10,180,174,112,17,61,192,142,36,83,33,39,151,68,217,220,99,137,230,121,134,175,165,99,241,159,19,59,40,56,83,25,235,186,34,102,173,253,151,217,198,83,100,35,167,124,144,97,39,133,81,131,105,139,173,33,141,106,190,45,129,116,36,181,75,7,154,116,183,242,42,193,175,55,148,117,172,236,141,84,253,42,149,116,121,227,42,148,233,109,150,37,96,48,59,90,31,4,119,124,236,230,174,65,170,201,238,120,175,46,220,103,65,84,255,18,157,158,130,103,39,173,160,130,141,59,164,128,146,75,190,216,75,246,220,174,46,31,29,178,175,53,180,187,170,116,108,119,203,251,95,62,75,173,212,4,190,7,223,189,184,79,212,12,115,130,61,44,199,225,176,84,179,93,74,179,146,251,149,44,141,118,37,239,191,175,248,175,44,140,235,242,13,31,249,120,74,143,254,8,220,102,126,18,179,167,216,2,73,253,130,49,0,238,3,98,98,50,209,65,42,14,131,53,39,93,93,245,59,146,148,56,135,182,80,247,183,94,139,165,39,48,33,185,224,91,228,207,18,166,168,67,6,236,69,229,108,234,102,46,40,39,255,174,40,119,195,238,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,187,230,169,245,160,20,106,31,77,3,129,233,176,237,26,194,241,169,121,206,157,90,216,78,70,255,11,88,243,107,95,70,188,125,98,104,61,192,39,82,126,212,205,227,225,128,50,34,54,30,193,107,31,76,234,168,103,62,78,95,230,142,253,233,198,104,52,203,77,161,216,218,31,109,127,192,205,183,248,100,59,29,175,9,152,1,195,172,188,25,130,96,200,138,55,26,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,233,131,224,169,229,83,12,43,119,20,230,120,233,61,188,129,150,148,124,190,111,195,63,163,212,106,36,240,111,251,98,193,238,192,109,6,37,122,125,52,177,50,103,100,145,207,255,213,144,95,77,104,185,132,34,88,113,40,42,129,67,82,12,19,2,0,1,0],"hint":13},{"address":[133,3,200,114,90,182,7,7,182,18,32,13,189,6,4,251,213,109,143,69,158,236,51,76,117,186,148,188,195,81,38,204],"bytes":[208,1,0,145,23,32,0,32,2,129,7,32,0,113,32,4,113,33,3,0,32,1,0,5,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,98,178,194,235,79,232,199,133,128,191,119,139,254,148,198,236,44,203,37,211,8,54,159,192,13,135,184,133,238,190,83,72,154,222,24,249,71,95,80,187,218,209,195,211,226,6,199,177,22,169,133,38,75,236,35,35,223,17,81,230,198,53,60,5,170,155,70,130,59,202,137,231,207,210,17,18,106,123,118,233,159,8,59,137,189,243,213,177,58,40,31,254,139,115,172,124,252,82,100,111,177,136,75,195,148,65,19,16,182,120,92,58,241,175,36,162,134,0,106,248,159,179,39,233,159,151,170,22,1,0],"hint":4},{"address":[137,92,70,72,79,44,186,97,206,219,49,12,102,189,163,49,156,22,55,176,21,196,234,167,89,51,99,188,229,178,211,124],"bytes":[193,1,0,1,2,1,147,23,1,23,16,23,17,0,1,0,1,0,2,0,146,23,1,23,16,115,49,0,1,17,16,16,0,0,2,0,192],"hint":0},{"address":[139,11,199,157,86,9,51,217,45,130,112,128,119,28,221,245,157,52,122,54,189,148,176,68,60,2,29,119,115,99,154,60],"bytes":[208,1,1,146,23,0,23,32,0,113,33,1,1,17,130,7,0,7,32,0,114,33,3,1,17,113,33,2,1,17,0,4,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,55,29,38,88,218,150,252,157,177,26,21,63,193,156,198,191,199,146,188,252,190,78,141,234,34,46,212,221,41,186,89,205,57,148,188,81,227,104,111,48,161,212,131,214,157,10,131,90,123,72,77,137,35,147,192,132,248,122,88,73,222,84,243,2,227,86,40,45,77,213,30,146,205,54,42,123,250,52,38,33,61,187,80,133,102,142,246,134,172,18,220,46,181,75,122,39,2,1,192,192],"hint":2},{"address":[139,123,54,247,176,117,50,42,91,202,116,89,16,34,227,81,167,157,230,116,45,88,171,50,18,192,247,253,51,230,140,46],"bytes":[208,9,0,150,23,176,23,176,23,176,23,184,0,23,183,23,184,2,114,178,184,1,19,134,7,176,7,176,7,176,7,184,0,7,183,7,184,2,117,32,15,184,1,21,19,115,32,2,21,20,116,32,12,113,182,20,115,177,32,9,20,21,18,17,115,32,14,21,19,16,11,32,5,113,33,0,0,176,113,177,32,8,113,33,1,0,176,113,33,10,0,176,115,35,3,0,0,0,176,176,176,113,178,114,180,100,113,32,11,100,115,177,32,9,18,19,113,182,17,115,181,113,179,32,13,21,20,114,178,20,115,181,113,179,32,7,18,114,180,102,113,32,11,102,16,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,17,146,100,56,42,156,10,108,6,243,220,48,64,63,1,185,87,3,109,197,231,92,16,150,170,139,135,228,229,133,38,211,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,72,252,114,31,187,193,114,224,146,95,162,122,241,103,29,226,37,186,146,113,52,128,41,152,177,10,21,104,161,136,101,43,172,236,141,84,253,42,149,116,121,227,42,148,233,109,150,37,96,48,59,90,31,4,119,124,236,230,174,65,170,201,238,120,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,207,50,3,156,237,177,155,180,170,133,230,150,209,37,133,187,7,146,233,229,90,111,207,83,182,187,14,36,246,25,140,200,235,80,53,253,14,237,19,39,158,181,89,13,194,124,130,114,1,54,228,250,165,233,124,128,18,170,79,204,128,120,19,52,250,190,14,155,156,117,8,105,164,20,71,81,111,7,119,122,234,196,184,98,30,244,151,45,8,81,187,250,131,95,189,101,253,28,62,122,65,53,75,163,172,98,77,234,69,37,114,204,91,7,129,94,255,156,225,255,127,60,82,197,17,103,175,80,1,0],"hint":0},{"address":[139,221,212,61,54,175,21,159,143,28,126,223,71,125,159,10,6,162,107,251,236,245,161,152,192,233,236,74,195,112,246,230],"bytes":[208,1,0,147,23,176,23,179,23,176,180,133,7,176,7,179,7,176,7,176,7,178,117,33,7,1,129,7,176,180,18,114,32,3,20,19,17,16,5,32,2,114,33,0,0,176,32,4,114,177,16,17,114,177,115,33,5,0,176,97,113,32,6,97,16,146,23,176,23,178,176,8,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,149,231,30,204,176,183,138,159,68,145,226,179,5,29,53,187,145,138,96,124,167,77,240,95,2,189,13,14,240,230,201,7,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,2,0,1,0],"hint":6},{"address":[140,144,196,12,253,125,34,204,181,245,121,54,146,175,250,28,77,229,72,20,221,162,159,28,135,75,87,190,246,114,17,134],"bytes":[208,1,0,146,23,178,23,181,179,131,7,178,7,181,7,176,118,33,3,1,130,7,178,7,176,145,23,113,180,17,176,18,16,130,7,176,7,113,180,113,33,0,0,177,17,132,7,177,7,178,7,176,7,113,180,115,33,7,0,177,18,17,113,64,4,16,114,32,8,17,19,17,6,32,6,32,2,113,33,1,0,177,145,23,176,176,114,34,5,1,0,177,129,7,178,179,113,180,16,9,57,148,188,81,227,104,111,48,161,212,131,214,157,10,131,90,123,72,77,137,35,147,192,132,248,122,88,73,222,84,243,2,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,98,178,194,235,79,232,199,133,128,191,119,139,254,148,198,236,44,203,37,211,8,54,159,192,13,135,184,133,238,190,83,72,109,30,3,83,172,239,100,138,86,106,186,160,225,39,137,78,225,134,206,95,171,1,250,42,39,112,1,159,102,79,30,166,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,154,188,179,8,71,233,245,145,108,38,16,126,148,119,150,163,32,109,86,206,46,122,164,98,116,232,5,70,234,163,248,235,154,222,24,249,71,95,80,187,218,209,195,211,226,6,199,177,22,169,133,38,75,236,35,35,223,17,81,230,198,53,60,5,179,167,216,2,73,253,130,49,0,238,3,98,98,50,209,65,42,14,131,53,39,93,93,245,59,146,148,56,135,182,80,247,248,41,160,86,223,94,139,143,176,58,204,29,255,112,53,60,232,132,245,171,188,151,54,74,119,70,134,200,189,218,172,108,2,0,1,0],"hint":4294967295},{"address":[140,192,225,54,12,27,41,16,141,171,61,97,114,231,252,232,169,170,150,64,218,164,187,233,155,161,48,93,150,35,98,75],"bytes":[212,0,0,9,29,40,138,180,96,173,98,252,118,250,245,55,121,6,220,159,184,166,65,211,232,175,73,90,14,209,70,210,138,217,109,0,0,0],"hint":0},{"address":[142,175,227,143,95,174,39,47,195,224,240,85,45,230,216,109,53,71,90,221,25,175,1,212,99,8,121,173,76,212,24,47],"bytes":[208,1,0,146,23,176,23,177,32,1,130,7,176,7,177,114,32,4,113,32,7,115,32,3,115,33,8,0,176,96,113,32,9,96,17,114,32,6,17,16,16,2,32,2,113,32,5,16,10,0,38,60,169,245,127,113,119,244,149,227,113,31,140,221,89,150,122,10,26,77,232,149,177,235,238,86,108,209,136,62,212,6,95,200,180,19,147,245,37,193,229,65,185,212,188,151,194,12,19,191,35,167,32,154,32,147,182,244,82,115,48,17,74,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,71,131,44,144,254,87,111,212,189,165,149,103,212,177,190,138,20,108,207,137,97,200,143,209,169,214,252,183,44,121,177,153,96,204,108,254,69,119,185,154,48,17,61,9,233,146,31,34,83,250,193,95,227,213,173,151,107,157,195,98,110,220,104,34,108,2,97,83,46,232,241,9,2,14,144,215,132,206,23,128,196,29,235,100,150,14,53,178,85,49,173,240,253,100,220,172,168,94,48,219,151,98,133,182,195,128,226,12,147,197,0,13,98,1,27,249,241,66,162,110,88,34,183,87,98,186,117,157,180,109,191,145,180,250,142,240,68,254,199,235,233,45,238,32,161,168,22,83,32,223,200,226,178,109,201,104,56,241,158,175,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,1,0],"hint":7},{"address":[143,112,180,160,174,152,116,193,51,244,179,211,36,51,17,25,136,171,75,61,193,164,122,107,230,246,195,65,167,219,176,175],"bytes":[214,0,224,99,232,12,135,171,160,238,162,222,95,200,223,118,137,162,212,105,13,226,33,162,194,249,56,247,195,211,8,190,95,241,0,0,0],"hint":0},{"address":[144,2,42,228,197,213,42,210,138,205,128,5,29,212,31,39,245,28,156,74,251,171,27,179,145,119,60,25,239,13,193,233],"bytes":[214,0,146,194,55,231,109,147,194,91,13,188,71,161,129,233,45,95,151,125,192,100,196,92,160,161,88,243,232,52,165,168,24,28,0,0,0],"hint":0},{"address":[144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173],"bytes":[214,0,59,221,128,220,156,145,103,10,73,69,57,146,131,200,250,144,116,111,117,222,101,218,171,215,58,64,190,212,212,177,163,136,0,0,0],"hint":0},{"address":[144,236,192,158,21,207,14,183,246,62,149,32,194,89,18,230,91,4,163,130,94,128,208,191,175,244,147,37,38,193,38,113],"bytes":[208,1,0,32,1,115,33,2,0,32,1,96,113,32,3,96,0,4,40,93,156,144,23,144,222,221,90,253,72,97,119,192,210,220,145,152,53,75,155,96,41,25,77,104,10,124,162,133,99,150,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,1,0],"hint":4294967295},{"address":[145,65,192,84,248,91,138,184,197,158,129,191,208,155,167,57,240,160,186,252,228,177,132,110,187,26,51,229,20,40,97,102],"bytes":[208,1,1,149,23,177,23,176,23,176,23,178,23,179,114,20,19,18,133,7,177,7,176,7,176,7,178,7,179,116,33,2,0,129,7,176,114,21,20,16,18,113,17,19,129,7,176,114,17,20,16,4,32,0,146,23,176,23,176,0,145,23,176,114,19,16,32,3,146,23,176,23,176,114,21,17,113,32,1,16,4,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,1,192],"hint":4294967295},{"address":[146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235],"bytes":[208,1,0,0,33,0,0,0,1,45,252,22,175,1,184,43,59,145,194,255,112,68,9,215,98,54,168,63,149,108,12,110,102,89,166,79,226,29,118,105,91,1,1,0],"hint":4294967295},{"address":[146,75,13,234,223,73,92,90,18,161,36,151,251,180,100,187,34,242,192,180,142,201,165,85,185,172,181,141,39,237,203,46],"bytes":[208,1,0,146,23,176,23,177,176,130,7,176,7,177,64,0,16,2,32,1,113,32,0,16,2,30,26,43,187,25,32,237,74,18,129,163,222,202,100,106,211,19,202,156,123,247,234,189,195,101,89,135,121,124,204,12,85,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,0],"hint":4294967295},{"address":[146,194,55,231,109,147,194,91,13,188,71,161,129,233,45,95,151,125,192,100,196,92,160,161,88,243,232,52,165,168,24,28],"bytes":[193,1,0,0,1,0,145,23,176,1,1,0,0,0,1,1,146,23,176,23,113,32,0,118,35,1,0,0,0,176,176,176,115,34,7,0,0,176,176,114,33,3,0,176,32,8,115,33,5,0,176,100,113,32,6,100,16,113,48,0,17,1,32,2,9,30,26,43,187,25,32,237,74,18,129,163,222,202,100,106,211,19,202,156,123,247,234,189,195,101,89,135,121,124,204,12,85,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,97,77,217,229,201,188,180,126,143,59,37,173,22,90,151,122,31,61,199,114,50,70,93,227,182,142,40,95,119,199,135,53,171,19,190,223,66,232,75,174,15,124,98,199,221,106,138,218,87,30,136,41,190,214,234,85,130,23,240,54,27,94,37,208,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,209,175,140,47,93,246,86,19,16,237,169,150,109,112,205,159,81,104,143,0,40,10,227,135,239,113,101,70,169,212,21,251,254,77,94,53,147,241,44,126,254,17,58,115,217,127,219,138,235,250,120,184,27,185,29,195,210,9,55,161,132,15,154,69,2,0,1,0],"hint":0},{"address":[147,74,116,228,235,198,149,135,216,64,209,83,170,17,11,168,129,219,222,78,51,220,92,163,171,6,228,194,85,17,42,181],"bytes":[208,1,0,146,23,176,23,179,177,131,7,176,7,179,7,176,118,33,0,1,130,7,176,7,176,145,23,179,176,16,18,130,7,176,7,113,178,180,180,131,7,176,7,176,7,113,178,113,32,4,16,114,32,3,113,64,5,16,18,18,17,5,32,2,145,23,176,176,113,33,6,1,129,7,176,177,113,178,16,115,33,7,0,176,97,113,32,8,97,9,31,18,131,103,83,217,53,237,140,231,225,212,60,28,82,226,220,167,42,91,72,133,111,19,221,172,215,202,222,15,102,64,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,62,138,173,204,97,28,77,134,119,202,223,0,199,133,6,86,29,51,115,142,227,213,113,247,164,25,110,38,5,128,201,184,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,2,0,1,0],"hint":4294967295},{"address":[147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198],"bytes":[208,1,1,148,23,178,23,176,23,177,23,179,113,19,18,132,7,178,7,176,7,177,7,179,116,33,2,0,19,17,130,7,176,7,113,20,16,113,18,17,18,4,32,0,113,17,32,3,145,23,176,0,145,23,176,113,19,113,32,1,16,4,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,200,50,46,3,213,88,248,90,142,220,127,230,133,36,1,56,128,173,11,188,183,220,137,1,54,210,71,21,75,35,9,146,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,1,192],"hint":4294967295},{"address":[147,192,234,112,197,195,63,123,206,205,64,93,253,238,92,84,113,247,74,238,97,248,187,97,11,37,82,215,255,226,129,131],"bytes":[208,9,0,147,23,176,23,176,23,179,113,32,0,178,132,7,176,7,176,7,179,7,178,116,33,10,0,114,177,114,32,3,19,18,32,5,32,4,115,32,8,19,18,16,17,4,32,2,113,33,7,1,32,9,116,33,1,0,176,32,6,18,17,113,32,0,114,177,114,32,3,17,16,32,5,11,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,158,68,91,157,95,130,82,119,35,71,135,46,144,155,93,180,231,236,167,8,108,237,244,254,198,222,132,15,107,123,95,146,161,35,96,69,20,10,194,171,190,21,41,88,52,132,52,251,132,73,101,150,249,252,93,203,189,88,91,129,116,196,57,39,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,205,33,118,133,66,207,172,59,71,247,22,109,9,71,88,176,244,56,61,35,19,45,96,219,135,88,4,149,72,234,103,230,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,247,154,238,65,62,228,123,177,250,111,32,39,251,4,239,21,151,135,26,64,134,212,33,124,255,73,19,250,29,106,224,186,2,0,1,0],"hint":0},{"address":[148,77,150,214,42,122,160,96,153,65,92,165,175,218,48,241,66,199,14,18,254,189,182,209,85,174,176,172,85,8,152,64],"bytes":[212,0,0,236,23,58,211,91,233,215,92,47,21,16,249,84,129,66,64,39,236,1,24,107,195,240,22,160,63,4,102,78,84,112,214,0,0,0],"hint":0},{"address":[148,182,15,36,249,90,206,212,94,50,82,37,100,157,148,182,130,132,74,53,17,211,156,202,179,126,212,242,131,125,47,137],"bytes":[208,1,0,148,23,176,23,184,2,23,176,23,184,1,114,181,19,17,132,7,176,7,184,2,7,176,7,184,1,119,32,10,131,7,176,7,176,7,182,145,23,113,183,18,114,181,19,18,19,17,16,131,7,176,7,114,179,114,177,184,0,16,178,7,113,183,184,0,113,32,3,18,132,7,176,7,176,7,114,179,114,177,113,180,17,113,180,16,178,7,113,183,113,180,18,115,32,6,19,18,114,64,5,16,18,17,18,11,32,2,32,7,32,9,113,33,12,1,32,15,32,4,114,33,0,0,176,32,11,114,179,114,177,17,16,178,113,33,8,0,129,7,176,146,23,176,23,182,114,181,18,17,115,33,13,0,176,97,113,32,14,97,114,179,114,177,18,16,178,113,183,16,16,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,54,45,116,9,166,5,234,18,119,172,63,136,71,50,174,47,135,191,229,248,142,163,85,100,21,207,80,9,30,131,86,48,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,151,132,217,203,192,166,42,149,193,109,208,0,206,72,203,57,80,119,186,178,120,104,47,33,60,16,108,141,97,80,185,190,158,68,91,157,95,130,82,119,35,71,135,46,144,155,93,180,231,236,167,8,108,237,244,254,198,222,132,15,107,123,95,146,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,164,168,65,105,241,111,97,116,203,0,95,191,119,10,36,94,155,6,241,47,8,243,52,94,13,212,67,83,39,21,4,8,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,2,0,1,0],"hint":4294967295},{"address":[149,112,21,214,81,135,110,29,189,94,143,252,57,16,133,238,118,179,215,31,82,157,215,208,149,66,17,86,87,125,38,164],"bytes":[208,1,0,145,23,176,182,130,7,176,7,181,117,32,1,129,7,176,182,17,130,7,32,6,7,113,180,178,114,33,0,1,32,13,114,177,178,178,130,7,176,7,113,180,113,32,4,16,64,5,16,16,7,32,3,32,7,115,33,11,0,176,98,113,32,12,98,113,33,10,1,32,13,113,33,8,0,129,7,176,114,179,114,177,16,16,32,9,113,180,16,145,23,181,114,179,114,177,17,17,32,9,14,2,1,207,17,44,128,169,32,218,175,29,186,208,247,219,163,151,224,41,20,165,148,50,128,126,189,159,55,118,75,214,74,28,198,170,57,66,155,94,154,215,67,234,247,227,38,134,154,148,23,219,188,113,182,19,23,101,3,43,107,88,39,70,117,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,158,68,91,157,95,130,82,119,35,71,135,46,144,155,93,180,231,236,167,8,108,237,244,254,198,222,132,15,107,123,95,146,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,2,0,1,0],"hint":4294967295},{"address":[149,147,66,237,154,75,125,193,154,124,235,114,166,154,128,21,12,246,85,222,93,116,161,14,127,61,247,128,254,35,217,86],"bytes":[208,9,0,147,23,176,23,176,23,182,183,131,7,176,7,176,7,182,119,32,7,131,7,176,7,176,7,182,183,18,17,16,129,7,176,113,32,12,113,177,16,130,7,176,7,114,32,8,115,33,10,0,176,99,113,32,11,99,16,16,131,7,176,7,176,7,114,32,8,180,16,117,32,0,179,113,178,179,113,177,180,113,32,2,179,16,8,32,5,32,4,32,6,113,177,113,178,18,113,178,17,114,33,1,0,176,32,9,114,181,17,16,114,181,113,177,18,113,177,17,13,1,52,162,6,154,222,214,241,18,20,204,33,47,37,177,194,163,224,207,41,103,92,148,75,153,178,28,90,2,159,76,39,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,41,127,249,85,100,178,96,167,6,74,210,67,66,113,229,76,4,196,152,70,218,146,228,158,164,59,100,217,127,240,115,188,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,50,68,104,115,1,215,121,236,117,114,116,118,29,144,61,239,62,179,19,81,119,50,123,112,155,203,216,84,239,73,111,121,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,109,161,248,248,39,19,92,160,171,136,16,106,160,156,220,89,58,171,27,215,58,41,21,50,223,177,199,197,19,48,0,221,143,112,180,160,174,152,116,193,51,244,179,211,36,51,17,25,136,171,75,61,193,164,122,107,230,246,195,65,167,219,176,175,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,244,242,199,63,63,176,199,189,250,212,209,10,144,100,144,38,99,103,162,129,151,44,249,218,31,186,104,181,104,141,20,40,1,0],"hint":0},{"address":[149,231,30,204,176,183,138,159,68,145,226,179,5,29,53,187,145,138,96,124,167,77,240,95,2,189,13,14,240,230,201,7],"bytes":[208,1,0,150,23,176,23,184,3,23,176,23,184,4,23,176,23,184,2,176,134,7,176,7,184,3,7,176,7,184,4,7,176,7,184,2,118,33,19,1,17,130,7,176,7,114,179,18,16,145,23,113,181,17,176,19,16,131,7,176,7,114,179,18,113,32,6,16,7,113,181,113,32,6,17,117,33,17,1,176,180,114,32,8,177,20,129,7,180,115,184,0,113,182,32,12,114,64,10,17,115,184,0,113,182,32,18,21,24,1,118,32,9,21,24,1,19,177,16,18,114,183,103,113,32,16,103,129,7,113,32,0,180,184,1,18,13,32,5,24,0,113,33,1,0,176,113,178,32,13,115,178,32,14,177,20,113,33,11,1,129,7,176,146,23,176,23,114,179,16,17,176,113,33,2,0,176,113,33,15,0,176,115,35,3,0,0,0,176,176,176,114,183,100,113,32,16,100,114,179,16,18,114,179,184,1,16,113,181,16,20,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,72,252,114,31,187,193,114,224,146,95,162,122,241,103,29,226,37,186,146,113,52,128,41,152,177,10,21,104,161,136,101,43,123,182,89,135,102,113,224,61,7,49,196,86,232,148,206,158,111,125,232,37,10,180,174,112,17,61,192,142,36,83,33,39,139,123,54,247,176,117,50,42,91,202,116,89,16,34,227,81,167,157,230,116,45,88,171,50,18,192,247,253,51,230,140,46,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,172,236,141,84,253,42,149,116,121,227,42,148,233,109,150,37,96,48,59,90,31,4,119,124,236,230,174,65,170,201,238,120,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,228,14,118,142,182,13,77,21,4,125,13,195,184,32,234,175,107,253,251,200,161,173,38,141,205,120,114,45,50,22,74,185,235,80,53,253,14,237,19,39,158,181,89,13,194,124,130,114,1,54,228,250,165,233,124,128,18,170,79,204,128,120,19,52,238,14,28,167,126,90,205,78,70,91,168,94,39,242,68,66,47,0,98,9,95,223,66,32,87,29,140,28,39,84,116,163,2,0,1,0],"hint":4294967295},{"address":[150,145,212,243,57,243,164,63,121,161,201,51,86,245,77,129,59,198,227,235,59,233,116,46,93,47,105,5,167,53,185,3],"bytes":[208,1,2,149,23,0,23,179,23,177,23,178,23,180,113,19,18,133,7,0,7,179,7,177,7,178,7,180,117,34,3,1,2,20,19,17,131,7,20,7,113,176,21,7,113,21,16,114,19,18,17,18,5,33,1,2,113,176,17,113,17,113,33,0,2,18,145,23,113,176,16,1,146,23,19,23,113,176,20,113,20,115,33,2,2,21,17,16,4,57,148,188,81,227,104,111,48,161,212,131,214,157,10,131,90,123,72,77,137,35,147,192,132,248,122,88,73,222,84,243,2,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,179,167,216,2,73,253,130,49,0,238,3,98,98,50,209,65,42,14,131,53,39,93,93,245,59,146,148,56,135,182,80,247,201,125,114,130,94,113,116,53,122,105,247,215,16,79,78,166,25,65,214,223,92,24,132,252,87,193,182,173,19,254,164,198,3,1,193,192,193],"hint":4294967295},{"address":[151,54,53,120,60,51,25,156,213,180,194,133,130,123,253,77,134,72,129,130,0,189,161,100,150,190,169,132,210,106,194,187],"bytes":[208,1,0,150,23,182,23,176,23,176,23,179,23,181,23,183,115,21,20,19,18,134,7,182,7,176,7,176,7,179,7,181,7,183,117,33,4,0,129,7,176,145,23,113,177,16,115,23,17,21,16,20,129,7,180,114,18,20,16,130,7,176,7,113,177,113,178,16,115,18,17,21,16,18,8,32,2,115,33,0,0,176,32,5,115,33,6,0,176,97,113,32,7,97,32,3,113,177,17,113,177,32,8,146,23,176,23,180,115,21,32,8,17,16,147,23,176,23,176,23,179,0,147,23,176,23,176,23,113,177,113,178,17,115,23,113,178,18,17,16,9,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,1,0],"hint":4294967295},{"address":[151,132,217,203,192,166,42,149,193,109,208,0,206,72,203,57,80,119,186,178,120,104,47,33,60,16,108,141,97,80,185,190],"bytes":[208,9,0,147,23,176,23,176,23,181,114,177,180,179,131,7,176,7,176,7,181,160,7,146,23,176,23,182,0,130,7,176,7,182,114,177,113,178,20,179,117,32,15,19,130,7,176,7,183,114,18,17,16,18,17,131,7,176,7,183,7,116,32,14,21,130,7,176,7,114,177,22,16,114,20,17,16,17,16,120,0,32,6,22,19,131,7,176,7,114,177,23,16,7,184,0,114,177,113,178,24,1,180,18,17,16,129,7,32,8,113,32,16,113,178,23,132,7,176,7,114,32,7,23,16,7,184,0,7,114,22,18,17,115,32,11,113,178,24,2,118,35,2,0,0,0,176,176,176,114,33,1,0,176,32,9,19,115,33,12,0,176,101,113,32,13,101,16,9,32,3,114,33,0,0,176,32,10,32,4,113,178,17,113,178,18,114,177,17,16,114,177,19,16,114,177,20,16,116,32,14,24,0,130,7,176,7,114,177,24,1,16,114,23,17,16,17,16,17,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,72,252,114,31,187,193,114,224,146,95,162,122,241,103,29,226,37,186,146,113,52,128,41,152,177,10,21,104,161,136,101,43,125,5,202,27,89,81,239,15,178,70,105,218,191,12,42,52,131,94,52,226,173,174,122,30,113,112,73,15,34,82,122,87,143,112,180,160,174,152,116,193,51,244,179,211,36,51,17,25,136,171,75,61,193,164,122,107,230,246,195,65,167,219,176,175,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,172,236,141,84,253,42,149,116,121,227,42,148,233,109,150,37,96,48,59,90,31,4,119,124,236,230,174,65,170,201,238,120,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,187,67,180,68,88,106,58,237,43,170,13,123,116,49,202,109,205,20,171,148,68,188,119,146,13,19,67,51,208,191,229,116,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,218,224,24,9,166,175,10,253,129,230,253,211,161,211,159,239,134,168,168,196,233,8,24,177,163,87,225,128,221,218,178,89,241,234,181,89,14,243,85,127,115,217,213,16,117,241,14,246,8,112,69,108,235,128,246,108,61,93,23,111,158,121,188,189,244,242,199,63,63,176,199,189,250,212,209,10,144,100,144,38,99,103,162,129,151,44,249,218,31,186,104,181,104,141,20,40,1,0],"hint":0},{"address":[152,53,11,226,249,31,219,85,75,135,68,141,67,47,176,27,55,221,21,34,93,154,144,164,137,89,109,137,96,32,102,161],"bytes":[209,0,1,0,0,1,1,147,23,177,23,178,23,32,2,113,18,16,1,1,131,7,177,7,178,7,176,113,17,16,3,113,33,0,0,32,1,145,23,32,2,1,145,23,176,113,17,113,32,3,16,4,55,29,38,88,218,150,252,157,177,26,21,63,193,156,198,191,199,146,188,252,190,78,141,234,34,46,212,221,41,186,89,205,98,178,194,235,79,232,199,133,128,191,119,139,254,148,198,236,44,203,37,211,8,54,159,192,13,135,184,133,238,190,83,72,154,222,24,249,71,95,80,187,218,209,195,211,226,6,199,177,22,169,133,38,75,236,35,35,223,17,81,230,198,53,60,5,252,82,100,111,177,136,75,195,148,65,19,16,182,120,92,58,241,175,36,162,134,0,106,248,159,179,39,233,159,151,170,22,2,0,192],"hint":0},{"address":[154,188,179,8,71,233,245,145,108,38,16,126,148,119,150,163,32,109,86,206,46,122,164,98,116,232,5,70,234,163,248,235],"bytes":[208,1,2,147,23,0,23,178,23,177,2,131,7,0,7,178,7,177,117,34,3,1,4,18,129,7,113,176,18,2,33,0,2,131,7,18,7,113,176,19,7,2,114,34,2,3,2,113,20,17,16,16,3,33,1,4,113,176,17,145,23,113,176,16,3,4,45,252,22,175,1,184,43,59,145,194,255,112,68,9,215,98,54,168,63,149,108,12,110,102,89,166,79,226,29,118,105,91,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,201,125,114,130,94,113,116,53,122,105,247,215,16,79,78,166,25,65,214,223,92,24,132,252,87,193,182,173,19,254,164,198,5,1,193,64,1,192,2,193,64,192,1,193,192,193],"hint":4294967295},{"address":[154,222,24,249,71,95,80,187,218,209,195,211,226,6,199,177,22,169,133,38,75,236,35,35,223,17,81,230,198,53,60,5],"bytes":[214,0,158,141,30,140,34,168,155,208,25,144,208,145,224,167,157,236,196,179,183,215,104,244,33,193,200,174,159,203,18,7,155,97,0,0,0],"hint":0},{"address":[158,68,91,157,95,130,82,119,35,71,135,46,144,155,93,180,231,236,167,8,108,237,244,254,198,222,132,15,107,123,95,146],"bytes":[208,1,0,145,23,176,177,130,7,176,7,176,116,33,3,0,129,7,176,177,17,32,1,16,2,32,0,145,23,176,32,2,4,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,91,143,245,240,169,162,108,95,126,127,27,141,234,124,186,107,220,201,28,205,36,75,94,213,241,43,244,169,208,71,130,19,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,1,1,0],"hint":2},{"address":[158,141,30,140,34,168,155,208,25,144,208,145,224,167,157,236,196,179,183,215,104,244,33,193,200,174,159,203,18,7,155,97],"bytes":[193,1,0,0,0,0,1,1,0,0,0,0,1,145,23,113,33,0,0,32,1,48,0,0,2,55,29,38,88,218,150,252,157,177,26,21,63,193,156,198,191,199,146,188,252,190,78,141,234,34,46,212,221,41,186,89,205,98,178,194,235,79,232,199,133,128,191,119,139,254,148,198,236,44,203,37,211,8,54,159,192,13,135,184,133,238,190,83,72,2,0,1,0],"hint":0},{"address":[158,228,28,253,65,199,27,193,180,132,225,109,179,108,138,29,91,31,154,143,216,215,230,132,25,20,242,46,137,241,157,156],"bytes":[208,9,0,145,23,176,113,32,0,116,33,1,0,176,32,5,16,115,33,6,0,176,98,113,32,7,98,129,7,176,113,32,4,16,1,32,3,8,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,110,225,113,213,144,180,37,202,248,240,54,153,59,167,5,3,89,134,183,154,12,170,135,118,222,67,144,81,80,175,37,172,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,1,0],"hint":0},{"address":[161,35,96,69,20,10,194,171,190,21,41,88,52,132,52,251,132,73,101,150,249,252,93,203,189,88,91,129,116,196,57,39],"bytes":[214,0,11,94,89,63,177,70,42,135,57,132,211,33,222,0,103,94,198,107,7,59,76,85,14,29,28,211,106,22,169,226,221,253,0,0,0],"hint":0},{"address":[161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188],"bytes":[208,1,1,146,23,177,23,176,1,130,7,177,7,176,116,33,3,0,129,7,176,1,33,0,1,130,7,176,7,1,114,34,2,2,1,113,19,17,16,16,2,32,1,145,23,176,2,4,45,252,22,175,1,184,43,59,145,194,255,112,68,9,215,98,54,168,63,149,108,12,110,102,89,166,79,226,29,118,105,91,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,200,50,46,3,213,88,248,90,142,220,127,230,133,36,1,56,128,173,11,188,183,220,137,1,54,210,71,21,75,35,9,146,3,64,1,192,2,0,64,192,1,0,192],"hint":4294967295},{"address":[162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98],"bytes":[212,0,1,192,249,159,60,200,70,172,234,189,186,46,179,225,144,114,0,55,46,122,75,82,164,167,51,223,127,13,48,184,75,57,120,0,0,0],"hint":0},{"address":[164,47,5,8,127,94,79,129,139,58,181,5,19,189,222,52,76,132,128,133,99,6,43,140,116,201,206,133,61,67,92,182],"bytes":[208,1,1,146,23,0,23,176,113,33,1,1,17,130,7,0,7,176,64,0,16,1,113,33,0,1,16,2,55,29,38,88,218,150,252,157,177,26,21,63,193,156,198,191,199,146,188,252,190,78,141,234,34,46,212,221,41,186,89,205,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,2,1,192,192],"hint":4294967295},{"address":[164,168,65,105,241,111,97,116,203,0,95,191,119,10,36,94,155,6,241,47,8,243,52,94,13,212,67,83,39,21,4,8],"bytes":[208,1,0,150,23,184,12,23,177,23,177,23,184,3,23,184,14,23,184,13,115,21,20,19,18,134,7,184,12,7,177,7,177,7,184,3,7,184,14,7,184,13,117,184,5,129,7,177,145,23,114,182,114,178,16,20,176,115,23,17,21,16,20,129,7,114,182,114,178,179,19,176,114,18,20,16,130,7,177,7,114,182,114,178,184,0,20,176,117,184,5,129,7,177,145,23,114,182,114,178,183,16,176,115,24,1,184,7,17,16,21,129,7,114,182,114,178,184,1,179,176,114,184,4,115,24,0,183,179,16,120,0,34,6,0,1,181,184,2,130,7,181,7,114,182,184,8,16,146,23,114,182,176,17,23,116,184,6,113,184,11,176,19,113,184,11,18,17,32,9,176,16,129,7,114,182,176,184,2,114,184,4,145,23,116,184,6,114,182,184,8,176,17,114,182,184,8,184,8,113,184,9,184,8,32,9,117,33,19,1,181,32,0,176,32,16,16,113,184,9,176,114,33,1,0,114,182,184,2,176,16,130,7,177,7,114,182,114,178,183,184,0,176,115,20,19,17,16,16,18,23,32,10,32,3,32,8,32,18,32,5,32,17,113,33,12,1,181,113,180,18,113,180,16,113,180,17,114,178,183,179,114,182,114,178,17,16,176,33,4,0,33,7,0,33,11,0,113,180,19,114,178,184,7,179,113,33,15,1,181,115,33,13,0,177,98,113,32,14,98,113,182,114,178,113,180,21,179,147,23,177,23,177,23,184,3,0,147,23,177,23,177,23,114,182,114,178,184,1,184,0,176,115,23,183,184,1,16,146,23,177,23,114,182,114,178,184,10,16,176,115,21,184,10,17,16,20,10,224,239,210,148,92,57,189,131,185,81,185,60,142,148,71,191,223,56,85,186,77,84,70,59,4,155,19,3,161,161,36,31,181,154,127,225,27,53,79,1,145,116,89,241,61,225,54,55,151,173,12,23,60,111,134,41,121,101,6,10,234,138,44,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,55,164,229,247,168,54,105,254,65,69,200,121,128,151,23,42,140,241,109,45,19,5,51,112,162,179,156,160,204,69,56,146,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,69,217,26,77,35,69,244,83,106,57,96,36,76,155,206,182,249,199,138,44,4,183,135,176,18,155,207,7,58,44,74,113,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,158,68,91,157,95,130,82,119,35,71,135,46,144,155,93,180,231,236,167,8,108,237,244,254,198,222,132,15,107,123,95,146,161,35,96,69,20,10,194,171,190,21,41,88,52,132,52,251,132,73,101,150,249,252,93,203,189,88,91,129,116,196,57,39,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,171,154,109,137,72,73,148,55,108,192,222,72,8,59,163,82,24,151,208,77,71,179,52,161,16,167,124,84,197,89,93,108,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,212,148,220,96,19,134,186,142,143,11,113,31,230,42,45,96,171,96,198,72,140,140,246,206,151,121,110,188,58,213,254,251,221,161,43,203,51,7,39,246,223,184,22,188,151,82,170,189,5,32,230,81,91,121,252,138,90,158,113,56,102,244,198,62,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,255,53,45,34,4,221,221,232,92,181,199,177,120,224,147,215,13,109,75,176,104,182,165,230,62,138,27,117,112,112,44,164,2,0,1,0],"hint":4294967295},{"address":[165,58,3,50,179,58,5,167,174,109,148,154,213,173,224,59,213,27,245,170,164,198,0,195,130,85,237,186,156,179,30,42],"bytes":[193,1,0,0,2,0,146,23,0,23,0,0,2,0,0,0,2,1,147,23,0,23,0,23,17,176,0,0,1,2,1,147,23,0,23,0,23,16,176,1,114,48,0,18,17,0,1,0],"hint":0},{"address":[166,3,124,29,207,213,252,62,30,99,193,87,246,229,67,168,93,243,206,88,86,26,196,117,127,25,62,156,171,119,101,226],"bytes":[208,1,0,148,23,0,23,0,23,177,23,177,113,176,114,178,19,18,132,7,0,7,0,7,177,7,177,116,181,129,7,182,113,176,183,17,129,7,19,114,32,3,183,115,32,2,20,19,16,129,7,180,116,181,129,7,182,113,176,179,17,129,7,19,114,32,3,179,115,32,1,21,20,16,129,7,180,114,32,6,179,116,32,5,21,20,17,16,8,32,8,113,176,17,32,7,114,178,21,20,113,32,0,19,113,33,4,1,19,113,176,19,114,178,20,19,9,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,32,234,41,58,99,89,72,84,125,46,246,57,166,36,225,101,13,83,239,74,167,10,58,241,65,182,82,242,79,201,191,201,50,89,126,57,173,237,230,209,52,157,9,99,176,1,64,85,216,72,202,85,170,153,42,210,230,160,81,203,112,115,22,66,54,61,7,17,130,190,65,78,26,88,89,155,131,245,225,159,155,135,55,35,5,79,66,135,186,105,112,90,175,239,39,218,111,167,75,38,181,202,129,72,66,34,167,87,80,35,5,40,27,81,15,179,41,38,116,138,65,22,169,229,131,220,25,1,131,135,96,192,74,148,59,17,226,30,167,195,67,59,148,213,121,177,173,50,185,209,206,151,139,226,230,173,62,22,167,230,140,192,225,54,12,27,41,16,141,171,61,97,114,231,252,232,169,170,150,64,218,164,187,233,155,161,48,93,150,35,98,75,227,202,247,231,13,241,107,26,110,135,74,200,103,132,25,81,105,132,248,209,230,141,36,208,221,153,6,42,242,14,140,234,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,2,0,1,0],"hint":3},{"address":[167,145,43,100,15,214,55,2,164,136,15,132,50,239,255,47,63,205,37,156,238,99,34,69,188,178,201,89,25,133,224,255],"bytes":[208,9,0,145,23,176,177,129,7,176,115,33,9,0,129,7,176,177,16,32,3,2,32,4,115,33,6,1,176,118,35,1,0,0,0,176,176,176,114,33,0,0,176,32,5,115,33,7,0,176,98,113,32,8,98,16,16,10,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,48,62,92,133,156,182,2,25,180,188,60,131,11,227,206,115,57,109,123,132,164,179,37,158,249,127,166,196,91,97,192,56,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,172,236,141,84,253,42,149,116,121,227,42,148,233,109,150,37,96,48,59,90,31,4,119,124,236,230,174,65,170,201,238,120,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,2,0,1,0],"hint":0},{"address":[167,184,69,69,16,197,241,36,133,196,92,123,198,179,115,1,220,242,202,162,93,78,33,56,151,71,116,65,71,1,163,86],"bytes":[208,1,1,147,23,0,23,181,23,184,0,178,131,7,0,7,181,7,184,0,118,34,0,1,0,18,129,7,113,176,178,145,23,113,183,16,177,17,130,7,32,4,7,113,183,113,33,1,1,180,113,33,1,1,20,131,7,178,7,182,7,115,179,177,129,7,113,176,177,113,176,21,115,33,6,1,177,17,16,115,33,7,1,21,18,64,3,16,16,9,33,2,1,113,176,20,113,176,18,34,5,0,1,113,176,19,113,176,113,176,16,113,176,180,114,179,180,129,7,182,177,115,179,113,176,17,129,7,113,176,113,176,17,178,16,8,19,44,22,70,108,13,131,176,21,217,17,234,193,117,7,178,214,81,243,139,41,186,248,144,186,132,223,237,94,242,252,202,57,148,188,81,227,104,111,48,161,212,131,214,157,10,131,90,123,72,77,137,35,147,192,132,248,122,88,73,222,84,243,2,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,154,188,179,8,71,233,245,145,108,38,16,126,148,119,150,163,32,109,86,206,46,122,164,98,116,232,5,70,234,163,248,235,179,167,216,2,73,253,130,49,0,238,3,98,98,50,209,65,42,14,131,53,39,93,93,245,59,146,148,56,135,182,80,247,187,148,217,249,71,91,161,65,160,55,221,219,198,101,233,7,80,107,135,191,199,38,125,158,15,126,193,115,162,23,9,223,2,1,192,192],"hint":4294967295},{"address":[168,94,48,219,151,98,133,182,195,128,226,12,147,197,0,13,98,1,27,249,241,66,162,110,88,34,183,87,98,186,117,157],"bytes":[208,1,0,146,23,176,23,113,32,2,16,116,33,0,0,176,32,5,17,32,4,129,7,176,113,32,3,16,1,32,1,6,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,108,2,97,83,46,232,241,9,2,14,144,215,132,206,23,128,196,29,235,100,150,14,53,178,85,49,173,240,253,100,220,172,110,215,246,115,38,0,101,214,155,195,48,196,161,124,113,224,213,193,199,33,114,82,253,87,15,195,59,72,52,43,252,255,144,236,192,158,21,207,14,183,246,62,149,32,194,89,18,230,91,4,163,130,94,128,208,191,175,244,147,37,38,193,38,113,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,1,0],"hint":2},{"address":[168,203,14,0,159,175,239,138,124,198,237,81,124,169,138,223,143,62,25,126,246,225,41,117,133,187,152,118,28,37,253,215],"bytes":[208,1,2,148,23,0,23,183,23,182,23,184,1,114,177,113,18,17,115,178,19,18,17,132,7,0,7,183,7,182,7,184,1,117,34,6,1,3,19,129,7,113,176,19,114,177,113,19,16,115,178,20,19,16,116,179,113,18,181,33,0,1,114,16,181,180,180,131,7,19,7,113,176,20,7,114,177,113,20,16,115,178,21,20,16,116,179,113,21,184,0,114,177,113,21,17,115,178,22,21,17,114,19,184,0,16,16,17,10,33,2,3,34,3,2,1,34,4,2,3,34,7,2,1,33,8,1,113,33,1,3,19,113,176,17,145,23,113,176,16,2,115,33,5,3,22,18,17,146,23,113,176,18,23,115,178,19,18,16,113,19,17,9,45,252,22,175,1,184,43,59,145,194,255,112,68,9,215,98,54,168,63,149,108,12,110,102,89,166,79,226,29,118,105,91,57,148,188,81,227,104,111,48,161,212,131,214,157,10,131,90,123,72,77,137,35,147,192,132,248,122,88,73,222,84,243,2,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,154,188,179,8,71,233,245,145,108,38,16,126,148,119,150,163,32,109,86,206,46,122,164,98,116,232,5,70,234,163,248,235,179,167,216,2,73,253,130,49,0,238,3,98,98,50,209,65,42,14,131,53,39,93,93,245,59,146,148,56,135,182,80,247,201,125,114,130,94,113,116,53,122,105,247,215,16,79,78,166,25,65,214,223,92,24,132,252,87,193,182,173,19,254,164,198,206,48,252,15,65,53,230,121,207,59,22,208,214,103,189,157,244,231,166,157,187,129,119,162,158,92,117,180,140,76,236,16,221,146,133,172,69,212,172,133,209,127,160,211,36,61,121,9,199,130,162,162,118,238,63,176,207,254,250,154,251,219,13,225,4,1,193,64,192,1,193,192,193],"hint":4294967295},{"address":[169,239,92,9,42,27,22,83,51,139,185,251,157,250,169,225,134,29,73,33,182,148,174,139,15,186,12,31,166,218,254,216],"bytes":[193,1,0,0,2,0,146,23,0,23,0,0,1,0,0,0,2,2,148,23,0,23,0,23,17,23,17,114,48,0,19,18,0,0,1,0],"hint":0},{"address":[170,155,70,130,59,202,137,231,207,210,17,18,106,123,118,233,159,8,59,137,189,243,213,177,58,40,31,254,139,115,172,124],"bytes":[208,1,1,145,23,1,113,33,2,2,16,129,7,1,114,33,3,2,16,115,33,4,0,32,1,96,113,32,5,96,0,6,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,55,29,38,88,218,150,252,157,177,26,21,63,193,156,198,191,199,146,188,252,190,78,141,234,34,46,212,221,41,186,89,205,139,11,199,157,86,9,51,217,45,130,112,128,119,28,221,245,157,52,122,54,189,148,176,68,60,2,29,119,115,99,154,60,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,3,0,1,192,192],"hint":3},{"address":[171,46,242,123,57,90,146,109,185,97,242,57,187,55,95,114,4,106,121,3,42,193,105,121,128,74,49,7,50,221,235,99],"bytes":[208,9,0,147,23,176,23,176,23,179,113,177,114,178,18,17,131,7,176,7,176,7,179,116,33,10,0,129,7,176,145,23,113,177,19,113,177,114,178,20,17,17,113,32,9,18,16,4,32,3,115,33,0,0,176,32,5,115,33,6,0,176,98,113,32,7,98,116,35,1,0,0,0,176,176,176,115,34,8,0,0,176,176,114,33,4,0,176,32,11,113,177,17,12,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,97,77,217,229,201,188,180,126,143,59,37,173,22,90,151,122,31,61,199,114,50,70,93,227,182,142,40,95,119,199,135,53,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,209,175,140,47,93,246,86,19,16,237,169,150,109,112,205,159,81,104,143,0,40,10,227,135,239,113,101,70,169,212,21,251,250,218,246,185,13,90,225,102,11,48,47,89,65,202,55,215,222,207,92,54,177,71,74,196,221,217,165,237,206,111,158,11,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,254,77,94,53,147,241,44,126,254,17,58,115,217,127,219,138,235,250,120,184,27,185,29,195,210,9,55,161,132,15,154,69,1,0],"hint":0},{"address":[171,86,63,240,46,251,37,48,15,56,153,144,152,68,247,124,161,223,172,36,69,161,227,60,11,225,151,243,109,101,52,215],"bytes":[208,1,0,147,23,176,23,184,1,23,176,114,183,114,177,16,18,113,179,16,131,7,176,7,184,1,7,176,118,32,11,130,7,176,7,176,145,23,184,1,114,183,181,180,16,18,130,7,176,7,113,184,0,184,4,116,33,10,1,176,114,177,184,4,17,114,177,17,184,4,113,32,14,17,131,7,176,7,176,7,113,184,0,113,178,16,161,7,114,183,113,178,181,113,178,180,117,184,2,176,181,180,178,113,64,12,16,18,116,33,3,0,184,10,184,9,114,33,2,0,115,182,0,184,10,184,9,117,184,2,0,114,177,113,178,18,19,184,7,129,7,176,114,183,114,177,20,114,177,19,184,5,16,114,32,7,18,19,16,17,19,32,6,116,35,4,0,0,0,176,176,176,114,33,1,0,176,32,15,32,8,113,177,18,114,177,17,18,113,179,17,33,16,1,113,182,176,113,33,13,0,129,7,176,145,23,176,114,183,114,177,16,17,114,177,17,16,113,184,0,16,113,34,0,1,1,176,113,33,17,0,176,114,184,3,101,113,32,18,101,114,184,3,104,1,113,32,18,104,1,113,179,184,5,113,178,113,179,19,113,183,114,177,19,184,6,113,184,8,184,7,113,184,8,114,177,184,6,19,19,5,199,182,224,138,234,68,58,149,61,8,60,30,231,110,202,98,58,85,180,216,170,221,68,152,250,235,100,244,23,155,77,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,23,50,153,199,110,250,130,230,137,33,10,9,228,154,208,156,20,238,17,8,242,218,141,53,94,249,51,59,21,131,161,213,36,183,15,65,153,47,84,55,74,119,14,36,170,158,252,234,30,72,46,231,154,204,3,245,158,190,102,159,225,169,75,182,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,65,203,206,252,92,156,117,180,222,102,252,183,74,81,252,254,25,214,27,206,74,8,52,84,1,166,203,146,119,254,232,151,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,72,252,114,31,187,193,114,224,146,95,162,122,241,103,29,226,37,186,146,113,52,128,41,152,177,10,21,104,161,136,101,43,91,200,186,175,28,224,243,100,229,66,105,233,238,44,132,68,97,202,69,3,36,117,189,206,82,109,133,255,87,20,28,101,92,222,176,89,123,161,71,220,53,210,199,178,245,85,175,89,32,246,183,107,147,85,7,232,93,188,37,191,80,218,238,196,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,167,145,43,100,15,214,55,2,164,136,15,132,50,239,255,47,63,205,37,156,238,99,34,69,188,178,201,89,25,133,224,255,172,236,141,84,253,42,149,116,121,227,42,148,233,109,150,37,96,48,59,90,31,4,119,124,236,230,174,65,170,201,238,120,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,2,0,1,0],"hint":4294967295},{"address":[171,154,109,137,72,73,148,55,108,192,222,72,8,59,163,82,24,151,208,77,71,179,52,161,16,167,124,84,197,89,93,108],"bytes":[214,0,204,11,12,125,104,59,140,39,187,187,118,189,216,164,52,197,64,173,97,121,230,146,173,101,36,15,117,177,164,114,60,45,0,0,0],"hint":0},{"address":[171,251,80,142,140,20,2,169,17,155,172,167,212,106,57,90,138,33,121,239,9,22,123,162,161,225,165,108,244,106,135,4],"bytes":[208,1,0,147,23,176,23,177,23,176,113,32,2,18,131,7,176,7,177,7,176,115,32,6,18,118,35,3,0,0,0,176,176,176,114,33,1,0,176,32,7,16,18,115,32,10,16,18,17,2,32,5,116,33,0,0,176,32,8,115,33,9,0,176,100,113,32,11,100,16,12,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,30,26,43,187,25,32,237,74,18,129,163,222,202,100,106,211,19,202,156,123,247,234,189,195,101,89,135,121,124,204,12,85,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,90,217,16,70,80,53,182,167,10,100,133,228,237,107,172,102,24,66,112,204,57,162,193,238,51,174,240,219,155,127,204,66,116,129,248,50,7,172,22,52,112,238,167,107,224,144,138,118,130,209,23,76,230,235,194,196,12,235,21,158,220,100,24,146,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,204,0,4,254,212,83,179,96,130,8,37,30,76,98,73,39,255,65,177,239,242,177,51,213,14,93,125,196,205,89,180,81,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,1,0],"hint":10},{"address":[172,236,141,84,253,42,149,116,121,227,42,148,233,109,150,37,96,48,59,90,31,4,119,124,236,230,174,65,170,201,238,120],"bytes":[208,1,0,113,33,0,0,32,1,114,33,3,0,32,1,32,2,0,4,36,58,236,162,36,20,248,239,254,81,241,25,172,162,71,149,152,170,72,252,221,0,96,60,94,184,74,141,22,226,88,213,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,62,138,173,204,97,28,77,134,119,202,223,0,199,133,6,86,29,51,115,142,227,213,113,247,164,25,110,38,5,128,201,184,148,77,150,214,42,122,160,96,153,65,92,165,175,218,48,241,66,199,14,18,254,189,182,209,85,174,176,172,85,8,152,64,1,0],"hint":3},{"address":[173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214],"bytes":[208,1,0,113,33,1,0,32,2,114,33,0,0,32,2,32,3,0,4,25,134,155,57,9,150,155,120,176,235,163,138,14,162,252,217,208,21,113,131,31,60,236,184,157,206,95,175,197,12,127,94,49,201,229,28,85,180,20,198,36,190,155,239,220,3,50,69,108,205,146,154,196,27,168,14,229,13,203,114,18,206,1,242,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,246,25,208,107,19,247,55,49,65,93,17,97,8,159,153,218,218,152,134,191,80,154,29,245,43,83,22,113,2,200,108,114,1,0],"hint":3},{"address":[173,222,136,82,148,149,48,176,245,99,105,176,229,62,34,58,189,47,35,165,88,51,189,253,153,65,4,189,230,104,106,233],"bytes":[209,0,1,0,0,1,0,146,23,145,23,32,0,0,23,32,0,113,17,16,0,0,1,161,35,96,69,20,10,194,171,190,21,41,88,52,132,52,251,132,73,101,150,249,252,93,203,189,88,91,129,116,196,57,39,1,192],"hint":0},{"address":[173,229,14,160,69,134,173,157,62,239,68,203,61,253,196,132,125,56,45,99,133,231,44,217,206,217,217,212,158,140,47,136],"bytes":[209,0,0,1,1,1,2,150,23,176,23,179,23,178,23,180,23,176,23,181,114,20,17,16,2,0,132,7,176,7,179,7,178,7,180,17,2,134,7,176,7,179,7,178,7,180,7,176,7,181,115,18,17,16,118,48,0,21,20,19,18,17,16,6,32,0,32,2,114,16,17,113,32,4,17,146,23,176,23,114,177,17,16,0,147,23,176,23,114,177,19,16,23,114,19,17,16,114,20,113,32,1,18,115,32,3,21,18,17,114,177,20,16,5,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,143,112,180,160,174,152,116,193,51,244,179,211,36,51,17,25,136,171,75,61,193,164,122,107,230,246,195,65,167,219,176,175,187,67,180,68,88,106,58,237,43,170,13,123,116,49,202,109,205,20,171,148,68,188,119,146,13,19,67,51,208,191,229,116,244,242,199,63,63,176,199,189,250,212,209,10,144,100,144,38,99,103,162,129,151,44,249,218,31,186,104,181,104,141,20,40,1,0],"hint":0},{"address":[174,78,20,46,10,231,176,111,184,237,115,197,138,71,50,21,28,53,22,175,68,119,222,88,135,208,30,29,192,198,178,137],"bytes":[209,1,2,2,2,1,1,151,23,1,23,16,23,178,23,177,23,1,23,16,23,116,176,21,20,17,16,115,20,18,17,16,1,0,132,7,1,7,16,7,178,7,177,16,3,33,1,1,115,16,18,17,114,33,0,1,18,17,147,23,1,23,16,23,116,176,19,18,17,16,0,2,31,181,154,127,225,27,53,79,1,145,116,89,241,61,225,54,55,151,173,12,23,60,111,134,41,121,101,6,10,234,138,44,171,154,109,137,72,73,148,55,108,192,222,72,8,59,163,82,24,151,208,77,71,179,52,161,16,167,124,84,197,89,93,108,2,192,193],"hint":0},{"address":[175,9,117,110,177,82,121,33,25,161,227,86,120,130,27,112,231,216,72,81,58,119,85,17,146,183,109,115,45,61,236,133],"bytes":[208,9,0,145,23,176,116,33,0,0,176,32,6,177,113,32,4,16,129,7,176,115,32,5,177,16,113,32,3,16,2,32,2,115,33,7,0,176,97,113,32,8,97,9,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,54,45,116,9,166,5,234,18,119,172,63,136,71,50,174,47,135,191,229,248,142,163,85,100,21,207,80,9,30,131,86,48,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,151,132,217,203,192,166,42,149,193,109,208,0,206,72,203,57,80,119,186,178,120,104,47,33,60,16,108,141,97,80,185,190,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,1,0],"hint":0},{"address":[175,88,107,7,84,110,31,202,154,176,120,13,28,35,106,248,211,96,196,198,187,50,187,12,208,62,201,202,99,211,218,150],"bytes":[208,1,0,146,23,176,23,176,113,32,5,116,33,0,0,176,32,4,17,16,130,7,176,7,176,114,32,3,113,32,2,17,16,1,32,1,6,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,123,182,89,135,102,113,224,61,7,49,196,86,232,148,206,158,111,125,232,37,10,180,174,112,17,61,192,142,36,83,33,39,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,1,0],"hint":6},{"address":[176,140,230,6,226,126,183,234,205,174,192,129,103,182,254,254,134,166,172,133,196,33,83,112,178,231,169,224,244,77,188,186],"bytes":[208,9,0,146,23,178,23,180,182,130,7,178,7,180,117,32,5,130,7,178,7,180,182,17,16,129,7,114,179,176,177,116,181,113,32,0,114,179,176,176,176,177,16,130,7,114,179,177,177,7,114,179,177,176,116,181,32,2,177,176,16,7,32,3,32,6,32,7,113,33,4,1,178,114,179,16,177,33,1,0,113,32,0,114,179,17,176,8,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,85,179,191,20,47,181,168,7,138,211,183,81,95,144,171,35,156,50,174,4,67,223,227,131,182,125,174,111,75,161,127,197,161,35,96,69,20,10,194,171,190,21,41,88,52,132,52,251,132,73,101,150,249,252,93,203,189,88,91,129,116,196,57,39,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,218,228,37,45,123,48,184,54,162,73,61,192,145,170,139,211,132,252,73,173,213,163,61,3,152,47,222,46,171,101,17,185,221,161,43,203,51,7,39,246,223,184,22,188,151,82,170,189,5,32,230,81,91,121,252,138,90,158,113,56,102,244,198,62,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,2,0,1,0],"hint":0},{"address":[176,177,13,178,135,1,45,21,180,105,78,118,183,137,193,46,197,228,30,252,157,184,166,99,207,215,84,191,47,196,151,23],"bytes":[209,0,1,0,0,1,2,148,23,178,23,176,23,177,23,32,2,113,19,16,2,0,131,7,178,7,176,7,177,17,0,131,7,178,7,176,7,177,16,3,113,16,32,1,113,17,32,0,145,23,32,2,0,3,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,221,161,43,203,51,7,39,246,223,184,22,188,151,82,170,189,5,32,230,81,91,121,252,138,90,158,113,56,102,244,198,62,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,1,192],"hint":0},{"address":[177,106,62,1,119,218,180,42,13,198,152,147,9,17,228,149,237,65,8,85,137,83,220,248,170,40,77,157,38,176,63,233],"bytes":[208,1,2,148,23,0,23,178,23,177,23,179,113,18,17,132,7,0,7,178,7,177,7,179,64,1,116,34,3,1,2,19,18,17,16,4,33,0,2,113,176,17,145,23,113,176,16,1,146,23,113,176,18,23,115,34,2,1,2,19,18,16,113,19,17,4,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,154,188,179,8,71,233,245,145,108,38,16,126,148,119,150,163,32,109,86,206,46,122,164,98,116,232,5,70,234,163,248,235,168,203,14,0,159,175,239,138,124,198,237,81,124,169,138,223,143,62,25,126,246,225,41,117,133,187,152,118,28,37,253,215,3,1,193,192,193],"hint":4294967295},{"address":[177,240,135,145,58,202,171,121,231,224,213,186,89,125,185,69,193,114,36,226,196,245,166,98,29,36,16,178,152,230,124,62],"bytes":[193,1,0,3,3,0,147,23,0,23,1,23,176,4,1,0,3,0,3,1,148,23,0,23,1,23,176,23,146,23,18,23,18,18,115,51,0,5,6,7,19,18,17,1,113,33,0,3,2,1,18,8,169,241,65,177,159,66,67,188,234,107,210,102,217,106,23,170,74,68,29,97,144,21,119,44,156,181,114,34,96,92,8,1,192,1,193,1,194,2,194,64,1,192,64,1,193,1,194,192,193,194],"hint":0},{"address":[178,136,217,224,36,44,255,41,120,139,158,183,34,54,222,165,15,112,144,89,71,169,35,37,231,162,123,37,240,169,206,134],"bytes":[214,0,169,239,92,9,42,27,22,83,51,139,185,251,157,250,169,225,134,29,73,33,182,148,174,139,15,186,12,31,166,218,254,216,0,0,0],"hint":0},{"address":[178,212,245,211,140,116,84,134,58,215,4,56,245,216,90,238,79,156,121,45,75,131,28,156,231,56,80,213,237,244,149,188],"bytes":[208,1,2,149,23,0,23,179,23,177,23,180,23,181,113,19,18,133,7,0,7,179,7,177,7,180,7,181,117,34,4,2,1,20,129,7,178,113,20,16,18,113,17,32,2,130,7,20,7,113,176,21,114,18,17,16,6,33,1,1,113,176,17,113,176,20,145,23,113,176,16,2,145,23,32,3,113,18,113,33,0,1,19,146,23,19,23,178,113,20,115,33,5,1,21,17,16,6,57,148,188,81,227,104,111,48,161,212,131,214,157,10,131,90,123,72,77,137,35,147,192,132,248,122,88,73,222,84,243,2,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,120,192,56,5,248,234,247,211,103,224,245,121,9,171,213,102,217,74,43,235,207,98,112,254,47,231,74,249,84,237,13,0,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,150,145,212,243,57,243,164,63,121,161,201,51,86,245,77,129,59,198,227,235,59,233,116,46,93,47,105,5,167,53,185,3,179,167,216,2,73,253,130,49,0,238,3,98,98,50,209,65,42,14,131,53,39,93,93,245,59,146,148,56,135,182,80,247,3,1,192,192,193],"hint":4294967295},{"address":[179,59,142,103,87,122,243,6,163,52,27,123,216,94,231,85,2,234,140,32,208,30,84,96,196,38,22,117,138,251,137,184],"bytes":[208,1,0,145,23,176,32,4,129,7,176,114,32,0,16,32,1,1,113,33,2,0,32,3,5,31,121,87,27,44,86,181,43,106,25,85,4,186,217,8,87,49,247,39,197,233,209,1,70,107,238,40,134,42,71,245,88,77,166,97,145,122,88,21,47,92,169,116,210,37,109,152,239,169,215,34,196,241,99,130,233,205,240,22,223,76,87,67,104,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,98,178,194,235,79,232,199,133,128,191,119,139,254,148,198,236,44,203,37,211,8,54,159,192,13,135,184,133,238,190,83,72,154,222,24,249,71,95,80,187,218,209,195,211,226,6,199,177,22,169,133,38,75,236,35,35,223,17,81,230,198,53,60,5,1,0],"hint":6},{"address":[179,167,216,2,73,253,130,49,0,238,3,98,98,50,209,65,42,14,131,53,39,93,93,245,59,146,148,56,135,182,80,247],"bytes":[212,0,1,108,255,144,109,191,162,189,175,224,236,43,240,19,30,128,5,44,206,126,44,101,59,129,73,95,229,25,126,83,172,103,171,0,0,0],"hint":0},{"address":[180,109,191,145,180,250,142,240,68,254,199,235,233,45,238,32,161,168,22,83,32,223,200,226,178,109,201,104,56,241,158,175],"bytes":[212,0,0,58,152,33,66,200,78,170,110,66,96,230,103,226,169,23,51,19,60,53,77,238,245,123,227,201,182,97,107,158,128,2,25,0,0,0],"hint":0},{"address":[180,138,104,40,213,143,58,113,85,119,191,168,43,72,232,169,3,135,3,45,81,163,8,95,189,158,171,226,218,71,30,21],"bytes":[208,1,1,147,23,0,23,177,23,17,113,176,18,131,7,0,7,177,7,17,114,33,3,1,18,115,33,1,1,18,114,33,2,1,18,17,16,2,33,0,1,113,176,16,4,55,29,38,88,218,150,252,157,177,26,21,63,193,156,198,191,199,146,188,252,190,78,141,234,34,46,212,221,41,186,89,205,79,62,76,254,21,130,252,107,33,234,31,73,171,68,122,154,11,227,196,40,148,111,126,141,210,36,69,56,189,105,121,243,164,47,5,8,127,94,79,129,139,58,181,5,19,189,222,52,76,132,128,133,99,6,43,140,116,201,206,133,61,67,92,182,227,86,40,45,77,213,30,146,205,54,42,123,250,52,38,33,61,187,80,133,102,142,246,134,172,18,220,46,181,75,122,39,2,1,192,192],"hint":3},{"address":[180,168,196,184,204,231,183,63,134,178,84,245,163,33,130,122,234,156,175,40,8,53,242,193,230,56,84,84,238,168,199,233],"bytes":[214,0,58,152,33,66,200,78,170,110,66,96,230,103,226,169,23,51,19,60,53,77,238,245,123,227,201,182,97,107,158,128,2,25,0,0,0],"hint":0},{"address":[180,208,177,144,189,129,101,166,114,234,123,206,234,18,44,32,169,186,21,184,142,42,46,21,73,91,9,217,180,90,202,193],"bytes":[208,1,0,145,23,32,2,0,129,7,32,2,113,32,1,113,32,0,16,0,3,57,226,177,52,39,60,228,186,35,11,80,230,171,31,164,52,150,81,152,112,119,136,39,157,210,113,219,190,19,192,70,164,108,2,97,83,46,232,241,9,2,14,144,215,132,206,23,128,196,29,235,100,150,14,53,178,85,49,173,240,253,100,220,172,180,168,196,184,204,231,183,63,134,178,84,245,163,33,130,122,234,156,175,40,8,53,242,193,230,56,84,84,238,168,199,233,1,0],"hint":4294967295},{"address":[181,229,23,20,162,181,34,166,74,19,171,238,74,156,189,35,249,58,99,134,119,34,211,93,178,201,171,218,222,199,142,36],"bytes":[208,9,0,147,23,0,23,182,23,181,114,180,114,32,2,18,17,177,131,7,0,7,182,7,181,118,32,4,18,130,7,113,32,9,18,7,178,114,180,113,179,17,177,17,16,130,7,18,7,178,116,33,10,0,20,114,180,113,179,114,32,3,20,17,177,17,16,130,7,113,176,18,7,178,114,33,0,1,32,8,113,179,114,32,5,20,17,7,32,1,32,7,113,176,19,113,32,2,20,113,33,6,1,32,8,113,176,17,113,32,9,16,11,2,1,207,17,44,128,169,32,218,175,29,186,208,247,219,163,151,224,41,20,165,148,50,128,126,189,159,55,118,75,214,74,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,17,21,123,195,137,143,6,227,230,242,202,131,65,30,253,13,67,184,132,107,87,210,246,8,142,24,243,68,125,220,59,40,54,61,7,17,130,190,65,78,26,88,89,155,131,245,225,159,155,135,55,35,5,79,66,135,186,105,112,90,175,239,39,218,101,174,8,193,235,39,253,23,31,79,191,179,242,251,192,93,231,205,242,59,93,195,164,17,236,63,141,223,15,216,90,163,140,192,225,54,12,27,41,16,141,171,61,97,114,231,252,232,169,170,150,64,218,164,187,233,155,161,48,93,150,35,98,75,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,221,161,43,203,51,7,39,246,223,184,22,188,151,82,170,189,5,32,230,81,91,121,252,138,90,158,113,56,102,244,198,62,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,247,154,238,65,62,228,123,177,250,111,32,39,251,4,239,21,151,135,26,64,134,212,33,124,255,73,19,250,29,106,224,186,2,0,1,0],"hint":0},{"address":[182,16,57,189,216,69,215,110,241,157,157,160,35,172,146,59,99,233,26,27,119,223,37,237,127,240,136,224,141,81,9,191],"bytes":[212,0,0,125,89,104,124,139,90,19,89,201,144,19,230,51,213,6,81,53,59,128,48,168,164,23,252,117,240,70,72,9,55,125,102,0,0,0],"hint":0},{"address":[182,220,11,199,86,34,109,106,155,97,123,80,196,32,194,215,188,232,123,172,0,190,98,252,113,59,251,67,56,68,102,156],"bytes":[208,1,1,148,23,0,23,16,23,17,23,176,19,132,7,0,7,16,7,17,7,176,17,1,115,33,0,0,18,17,16,1,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,1,192],"hint":2},{"address":[183,94,139,165,39,48,33,185,224,91,228,207,18,166,168,67,6,236,69,229,108,234,102,46,40,39,255,174,40,119,195,238],"bytes":[208,1,0,145,23,176,32,2,129,7,176,113,32,4,114,32,3,115,33,5,0,176,96,113,32,6,96,16,1,32,1,7,46,243,224,221,165,41,59,218,150,93,10,220,237,252,125,56,114,68,172,115,106,96,20,167,32,193,214,63,160,237,224,47,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,98,178,194,235,79,232,199,133,128,191,119,139,254,148,198,236,44,203,37,211,8,54,159,192,13,135,184,133,238,190,83,72,103,22,11,151,103,147,6,210,130,4,69,56,58,109,116,14,111,233,131,156,37,69,234,72,104,15,242,167,123,11,233,134,182,16,57,189,216,69,215,110,241,157,157,160,35,172,146,59,99,233,26,27,119,223,37,237,127,240,136,224,141,81,9,191,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,1,0],"hint":12},{"address":[183,95,121,122,109,184,29,231,39,112,126,223,246,41,188,189,29,78,27,235,246,29,151,28,39,137,210,18,77,223,70,205],"bytes":[208,1,1,146,23,0,23,178,177,130,7,0,7,178,116,34,2,0,1,177,129,7,113,176,177,113,176,18,16,113,33,1,1,17,3,33,0,1,113,176,17,113,176,113,176,16,3,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,167,184,69,69,16,197,241,36,133,196,92,123,198,179,115,1,220,242,202,162,93,78,33,56,151,71,116,65,71,1,163,86,177,106,62,1,119,218,180,42,13,198,152,147,9,17,228,149,237,65,8,85,137,83,220,248,170,40,77,157,38,176,63,233,2,1,192,192],"hint":3},{"address":[184,39,20,179,119,30,235,147,197,241,135,113,227,142,204,109,35,239,80,101,157,11,196,76,234,12,232,215,49,5,85,250],"bytes":[193,1,0,2,2,0,146,23,0,23,1,2,1,0,2,0,2,1,147,23,0,23,1,23,146,23,17,23,17,19,114,50,0,3,4,18,17,0,0,5,1,192,1,193,64,1,192,1,193,192,193],"hint":0},{"address":[184,66,204,67,88,17,89,78,71,158,34,36,117,207,187,248,81,165,194,113,45,86,65,209,204,31,74,230,9,128,237,89],"bytes":[208,9,0,147,23,176,23,176,23,179,178,131,7,176,7,176,7,179,116,32,5,178,116,33,7,0,176,32,4,17,18,114,32,6,17,18,16,4,32,2,113,33,1,0,176,115,177,32,3,17,18,113,32,0,115,177,32,4,17,16,8,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,224,44,161,91,183,89,88,106,37,217,86,66,190,23,241,239,92,198,217,21,150,233,148,62,69,88,91,186,17,27,82,137,238,201,147,217,151,117,233,165,18,185,196,13,192,134,29,251,228,29,215,73,161,77,70,189,93,214,140,7,121,197,60,217,240,100,197,234,66,44,190,111,117,71,83,154,159,89,122,138,122,170,46,209,234,37,69,72,84,27,176,143,148,9,97,74,1,0],"hint":0},{"address":[184,150,129,100,248,126,196,245,228,122,187,161,51,128,37,115,237,51,68,189,137,112,206,106,160,26,77,165,138,101,221,230],"bytes":[208,1,1,148,23,1,23,1,23,177,23,18,18,132,7,1,7,1,7,177,7,18,118,34,1,1,0,1,19,130,7,1,7,114,176,20,16,17,16,18,17,2,113,33,0,0,1,114,176,17,16,2,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,251,3,245,167,225,65,216,64,37,179,165,3,222,220,83,206,134,242,151,189,227,107,188,27,152,104,122,234,180,53,153,104,2,1,192,192],"hint":2},{"address":[184,198,62,148,95,90,162,171,200,68,75,97,246,220,106,248,133,82,102,153,28,149,207,65,76,24,13,85,243,107,39,112],"bytes":[193,1,0,1,1,0,145,23,0,0,1,0,1,0,1,1,146,23,0,23,113,33,0,1,16,113,49,0,1,17,0,1,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,2,1,192,192],"hint":0},{"address":[185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65],"bytes":[208,1,0,113,33,1,0,32,2,114,33,0,0,32,2,32,3,0,4,25,134,155,57,9,150,155,120,176,235,163,138,14,162,252,217,208,21,113,131,31,60,236,184,157,206,95,175,197,12,127,94,49,201,229,28,85,180,20,198,36,190,155,239,220,3,50,69,108,205,146,154,196,27,168,14,229,13,203,114,18,206,1,242,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,143,112,180,160,174,152,116,193,51,244,179,211,36,51,17,25,136,171,75,61,193,164,122,107,230,246,195,65,167,219,176,175,1,0],"hint":2},{"address":[186,84,155,125,21,81,10,79,42,151,166,175,188,36,103,150,149,180,48,8,218,53,201,85,123,113,145,88,33,143,206,163],"bytes":[208,1,0,148,23,176,23,184,13,23,176,23,184,12,114,180,114,178,19,17,114,183,19,17,132,7,176,7,184,13,7,176,7,184,12,120,1,32,5,131,7,176,7,176,7,184,10,145,23,113,184,11,18,114,180,114,178,19,18,114,183,19,18,19,17,16,130,7,114,182,177,177,7,184,14,115,32,6,114,178,177,177,114,183,177,177,113,184,4,177,131,7,176,7,114,182,177,184,1,7,184,14,115,32,3,114,178,177,184,0,114,183,177,184,0,115,32,14,177,18,113,32,8,18,131,7,176,7,114,182,184,1,177,7,113,184,11,184,2,116,33,25,0,114,182,184,0,177,114,180,114,178,184,0,177,114,183,184,0,177,17,113,32,12,18,132,7,176,7,176,7,114,182,184,2,184,1,7,113,184,11,184,0,161,7,114,182,19,18,115,32,20,19,18,17,118,32,11,20,19,129,7,114,180,184,8,184,9,114,180,184,6,184,7,114,64,13,17,19,16,129,7,184,8,115,32,6,184,6,184,7,118,34,26,0,1,176,21,130,7,176,7,114,178,22,16,114,178,113,179,23,184,2,113,184,4,184,3,20,16,129,7,184,9,115,32,3,184,6,184,7,115,32,14,118,35,4,0,0,0,176,176,176,114,33,2,0,176,32,16,21,115,33,21,0,176,104,2,113,32,22,104,2,20,16,18,23,32,7,32,24,113,33,19,1,176,32,9,32,23,113,33,1,0,176,113,181,32,18,113,181,32,17,113,179,18,113,179,16,113,179,17,113,179,21,113,33,0,1,176,113,179,20,114,178,184,3,184,5,114,183,184,3,184,5,114,178,20,19,114,183,20,19,114,182,17,16,113,33,15,0,129,7,176,146,23,176,23,184,10,114,180,114,178,18,17,114,183,18,17,114,182,18,16,113,184,11,16,113,184,11,177,27,2,1,207,17,44,128,169,32,218,175,29,186,208,247,219,163,151,224,41,20,165,148,50,128,126,189,159,55,118,75,214,74,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,32,234,41,58,99,89,72,84,125,46,246,57,166,36,225,101,13,83,239,74,167,10,58,241,65,182,82,242,79,201,191,201,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,46,9,7,238,235,104,44,32,206,121,51,219,11,245,134,162,84,104,106,166,238,223,205,88,1,226,255,221,206,41,202,65,50,89,126,57,173,237,230,209,52,157,9,99,176,1,64,85,216,72,202,85,170,153,42,210,230,160,81,203,112,115,22,66,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,54,45,116,9,166,5,234,18,119,172,63,136,71,50,174,47,135,191,229,248,142,163,85,100,21,207,80,9,30,131,86,48,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,72,252,114,31,187,193,114,224,146,95,162,122,241,103,29,226,37,186,146,113,52,128,41,152,177,10,21,104,161,136,101,43,75,13,16,143,157,143,107,37,249,179,226,109,160,151,234,193,147,18,35,66,89,91,201,38,77,88,172,166,119,142,12,185,110,225,113,213,144,180,37,202,248,240,54,153,59,167,5,3,89,134,183,154,12,170,135,118,222,67,144,81,80,175,37,172,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,151,132,217,203,192,166,42,149,193,109,208,0,206,72,203,57,80,119,186,178,120,104,47,33,60,16,108,141,97,80,185,190,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,172,236,141,84,253,42,149,116,121,227,42,148,233,109,150,37,96,48,59,90,31,4,119,124,236,230,174,65,170,201,238,120,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,203,25,12,135,55,153,142,229,237,179,192,141,117,153,193,28,227,133,128,179,67,126,248,21,191,253,241,166,125,16,152,205,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,227,202,247,231,13,241,107,26,110,135,74,200,103,132,25,81,105,132,248,209,230,141,36,208,221,153,6,42,242,14,140,234,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,247,154,238,65,62,228,123,177,250,111,32,39,251,4,239,21,151,135,26,64,134,212,33,124,255,73,19,250,29,106,224,186,251,3,245,167,225,65,216,64,37,179,165,3,222,220,83,206,134,242,151,189,227,107,188,27,152,104,122,234,180,53,153,104,2,0,1,0],"hint":4294967295},{"address":[187,10,163,115,53,182,254,60,110,134,248,76,226,160,222,70,31,73,229,115,2,85,69,138,211,230,171,71,86,136,39,120],"bytes":[208,9,0,147,23,176,23,176,23,178,114,177,18,113,32,2,17,131,7,176,7,176,7,178,115,32,4,18,17,16,3,32,1,114,33,0,0,176,32,3,114,177,17,16,5,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,187,67,180,68,88,106,58,237,43,170,13,123,116,49,202,109,205,20,171,148,68,188,119,146,13,19,67,51,208,191,229,116,1,0],"hint":0},{"address":[187,67,180,68,88,106,58,237,43,170,13,123,116,49,202,109,205,20,171,148,68,188,119,146,13,19,67,51,208,191,229,116],"bytes":[212,0,1,224,99,232,12,135,171,160,238,162,222,95,200,223,118,137,162,212,105,13,226,33,162,194,249,56,247,195,211,8,190,95,241,0,0,0],"hint":0},{"address":[187,148,217,249,71,91,161,65,160,55,221,219,198,101,233,7,80,107,135,191,199,38,125,158,15,126,193,115,162,23,9,223],"bytes":[208,1,1,147,23,0,23,177,23,178,179,131,7,0,7,177,7,178,117,34,2,0,1,18,129,7,179,145,23,113,176,19,113,176,20,17,113,33,1,1,18,16,4,33,0,1,113,176,16,113,176,17,113,176,18,3,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,119,145,160,144,197,212,60,57,222,182,16,184,3,163,78,62,89,167,210,38,4,63,64,114,1,81,75,236,107,253,170,181,177,106,62,1,119,218,180,42,13,198,152,147,9,17,228,149,237,65,8,85,137,83,220,248,170,40,77,157,38,176,63,233,2,1,192,192],"hint":2},{"address":[188,232,122,2,85,172,116,174,184,244,216,102,9,91,242,158,6,18,96,128,141,181,109,245,5,48,51,167,93,68,147,59],"bytes":[208,9,0,146,23,176,23,176,114,177,180,179,130,7,176,7,176,116,33,6,0,129,7,176,145,23,176,114,177,179,180,16,32,3,17,5,32,2,113,33,5,1,176,116,35,1,0,0,0,176,176,176,114,33,0,0,176,32,4,114,178,16,17,114,178,17,16,7,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,171,86,63,240,46,251,37,48,15,56,153,144,152,68,247,124,161,223,172,36,69,161,227,60,11,225,151,243,109,101,52,215,172,236,141,84,253,42,149,116,121,227,42,148,233,109,150,37,96,48,59,90,31,4,119,124,236,230,174,65,170,201,238,120,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,2,0,1,0],"hint":0},{"address":[189,64,10,187,205,147,144,138,240,187,61,117,87,199,124,94,66,185,103,83,138,193,224,112,164,244,242,210,233,122,176,243],"bytes":[212,0,0,184,39,20,179,119,30,235,147,197,241,135,113,227,142,204,109,35,239,80,101,157,11,196,76,234,12,232,215,49,5,85,250,0,0,0],"hint":0},{"address":[189,116,117,144,194,169,51,23,167,254,237,136,194,69,103,236,153,25,211,140,54,87,202,77,87,29,15,149,109,41,223,113],"bytes":[208,9,0,148,23,176,23,176,23,179,23,179,181,132,7,176,7,176,7,179,7,179,119,32,6,132,7,176,7,176,7,179,7,179,181,19,18,17,16,131,7,176,7,113,178,16,7,113,178,32,15,114,33,9,0,113,178,114,180,18,32,15,114,32,11,177,16,132,7,176,7,176,7,179,7,113,178,113,32,10,17,115,32,0,19,114,32,8,19,18,17,6,32,7,115,33,13,0,176,101,113,32,14,101,115,33,1,0,176,32,12,177,113,178,17,116,35,3,0,0,0,176,176,176,114,33,2,0,176,32,4,113,178,114,180,19,18,16,1,1,22,29,55,101,91,114,101,18,23,92,48,17,80,234,101,230,201,13,183,128,130,154,252,34,61,18,56,14,124,122,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,45,19,228,58,195,126,10,0,196,137,134,174,19,136,22,187,23,71,24,37,9,25,206,46,51,165,37,169,228,106,153,234,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,51,78,39,123,139,120,138,49,19,191,66,251,63,20,81,139,197,142,37,171,184,51,104,82,245,219,53,119,131,170,83,45,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,55,59,125,116,246,180,13,161,27,126,215,150,3,164,94,199,1,26,136,49,183,32,181,125,46,254,146,232,42,61,87,240,55,164,229,247,168,54,105,254,65,69,200,121,128,151,23,42,140,241,109,45,19,5,51,112,162,179,156,160,204,69,56,146,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,110,225,113,213,144,180,37,202,248,240,54,153,59,167,5,3,89,134,183,154,12,170,135,118,222,67,144,81,80,175,37,172,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,1,0],"hint":0},{"address":[189,126,156,133,211,91,76,24,214,150,13,138,113,122,195,143,126,189,202,41,203,121,52,143,191,203,242,104,221,95,44,216],"bytes":[208,9,0,147,23,0,23,177,23,179,18,131,7,0,7,177,7,179,117,32,2,18,129,7,113,32,8,18,19,17,129,7,18,16,129,7,113,32,0,18,116,33,9,0,114,176,178,32,3,19,17,114,32,4,178,115,32,5,19,18,16,4,113,33,6,1,32,7,113,32,8,16,114,32,1,19,18,114,176,114,32,1,17,16,32,3,10,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,17,21,123,195,137,143,6,227,230,242,202,131,65,30,253,13,67,184,132,107,87,210,246,8,142,24,243,68,125,220,59,40,85,159,66,11,164,200,9,64,82,232,61,120,69,142,78,144,84,195,5,164,97,48,61,72,60,140,77,86,62,240,237,0,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,176,140,230,6,226,126,183,234,205,174,192,129,103,182,254,254,134,166,172,133,196,33,83,112,178,231,169,224,244,77,188,186,181,229,23,20,162,181,34,166,74,19,171,238,74,156,189,35,249,58,99,134,119,34,211,93,178,201,171,218,222,199,142,36,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,247,154,238,65,62,228,123,177,250,111,32,39,251,4,239,21,151,135,26,64,134,212,33,124,255,73,19,250,29,106,224,186,2,0,1,0],"hint":0},{"address":[192,249,159,60,200,70,172,234,189,186,46,179,225,144,114,0,55,46,122,75,82,164,167,51,223,127,13,48,184,75,57,120],"bytes":[193,1,0,0,0,0,0,2,0,0,0,0,0,48,0,0,0,1,0,0,48,0,0,0,1,1,0],"hint":0},{"address":[194,166,172,166,193,68,126,132,35,36,208,147,195,116,236,19,183,40,241,26,246,83,19,235,96,50,170,168,30,68,248,238],"bytes":[208,1,0,150,23,184,11,23,176,23,176,23,183,23,184,13,23,184,12,115,21,20,19,18,134,7,184,11,7,176,7,176,7,183,7,184,13,7,184,12,116,184,6,129,7,176,115,22,16,20,19,20,117,184,6,129,7,176,145,23,183,115,23,177,17,16,19,129,7,184,4,114,184,0,115,22,177,177,16,120,0,32,1,180,130,7,176,7,184,10,146,23,113,184,3,17,23,115,184,5,19,113,181,18,17,32,10,177,16,129,7,113,184,3,180,114,184,0,145,23,115,184,5,17,113,181,180,113,32,19,180,32,10,114,184,8,180,16,131,7,176,7,184,10,7,113,184,3,184,7,114,184,0,145,23,115,184,5,19,113,181,184,2,115,32,13,180,18,17,32,10,114,184,8,184,2,16,114,33,17,1,176,177,114,33,2,0,184,4,16,130,7,176,7,184,9,114,19,17,16,18,129,7,176,115,17,16,20,19,22,32,5,32,18,32,7,115,33,15,0,176,100,113,32,16,100,113,178,179,113,32,8,180,115,33,0,0,176,32,12,179,113,182,16,33,6,0,32,10,113,178,18,114,33,14,1,176,177,113,182,177,113,33,11,0,184,4,33,9,0,113,178,17,115,33,20,1,176,32,3,177,113,182,113,178,16,113,181,16,147,23,176,23,176,23,183,0,147,23,176,23,176,23,183,115,23,184,2,17,16,146,23,176,23,184,9,115,21,179,184,7,16,21,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,17,57,94,11,168,111,246,177,22,200,19,9,72,121,252,64,171,24,91,139,219,212,182,27,23,168,83,212,188,164,20,37,31,181,154,127,225,27,53,79,1,145,116,89,241,61,225,54,55,151,173,12,23,60,111,134,41,121,101,6,10,234,138,44,38,19,240,10,77,89,35,190,7,115,135,206,235,135,240,254,104,205,54,26,233,135,189,129,142,6,111,96,66,38,76,23,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,55,164,229,247,168,54,105,254,65,69,200,121,128,151,23,42,140,241,109,45,19,5,51,112,162,179,156,160,204,69,56,146,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,143,112,180,160,174,152,116,193,51,244,179,211,36,51,17,25,136,171,75,61,193,164,122,107,230,246,195,65,167,219,176,175,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,161,35,96,69,20,10,194,171,190,21,41,88,52,132,52,251,132,73,101,150,249,252,93,203,189,88,91,129,116,196,57,39,171,154,109,137,72,73,148,55,108,192,222,72,8,59,163,82,24,151,208,77,71,179,52,161,16,167,124,84,197,89,93,108,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,187,67,180,68,88,106,58,237,43,170,13,123,116,49,202,109,205,20,171,148,68,188,119,146,13,19,67,51,208,191,229,116,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,212,148,220,96,19,134,186,142,143,11,113,31,230,42,45,96,171,96,198,72,140,140,246,206,151,121,110,188,58,213,254,251,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,244,242,199,63,63,176,199,189,250,212,209,10,144,100,144,38,99,103,162,129,151,44,249,218,31,186,104,181,104,141,20,40,255,53,45,34,4,221,221,232,92,181,199,177,120,224,147,215,13,109,75,176,104,182,165,230,62,138,27,117,112,112,44,164,2,0,1,0],"hint":4294967295},{"address":[195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7],"bytes":[214,0,137,92,70,72,79,44,186,97,206,219,49,12,102,189,163,49,156,22,55,176,21,196,234,167,89,51,99,188,229,178,211,124,0,0,0],"hint":0},{"address":[196,226,8,65,73,233,141,130,37,100,137,178,229,161,124,237,243,0,103,41,133,113,150,61,230,167,248,81,187,86,61,195],"bytes":[208,1,0,145,23,176,184,2,130,7,176,7,184,1,117,32,3,129,7,176,184,2,17,130,7,32,11,7,113,181,183,113,32,9,183,131,7,176,7,113,181,180,7,114,177,113,178,179,179,116,33,19,0,114,177,184,0,18,32,12,115,32,16,184,0,18,16,64,10,17,16,11,32,6,114,33,1,0,176,32,15,32,7,113,178,17,113,178,16,113,33,13,0,129,7,176,113,32,0,114,177,180,16,113,33,17,0,176,114,182,101,113,32,18,101,118,35,4,0,0,0,176,176,176,114,33,2,0,176,32,14,18,114,182,104,0,113,32,18,104,0,113,181,16,145,23,184,1,113,32,0,114,177,179,17,20,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,28,198,170,57,66,155,94,154,215,67,234,247,227,38,134,154,148,23,219,188,113,182,19,23,101,3,43,107,88,39,70,117,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,72,252,114,31,187,193,114,224,146,95,162,122,241,103,29,226,37,186,146,113,52,128,41,152,177,10,21,104,161,136,101,43,110,225,113,213,144,180,37,202,248,240,54,153,59,167,5,3,89,134,183,154,12,170,135,118,222,67,144,81,80,175,37,172,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,161,35,96,69,20,10,194,171,190,21,41,88,52,132,52,251,132,73,101,150,249,252,93,203,189,88,91,129,116,196,57,39,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,172,236,141,84,253,42,149,116,121,227,42,148,233,109,150,37,96,48,59,90,31,4,119,124,236,230,174,65,170,201,238,120,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,203,25,12,135,55,153,142,229,237,179,192,141,117,153,193,28,227,133,128,179,67,126,248,21,191,253,241,166,125,16,152,205,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,247,154,238,65,62,228,123,177,250,111,32,39,251,4,239,21,151,135,26,64,134,212,33,124,255,73,19,250,29,106,224,186,1,0],"hint":4294967295},{"address":[199,121,203,241,226,212,168,174,59,26,43,150,182,228,23,65,12,141,118,172,231,128,225,38,251,202,75,61,200,58,65,8],"bytes":[212,0,0,177,240,135,145,58,202,171,121,231,224,213,186,89,125,185,69,193,114,36,226,196,245,166,98,29,36,16,178,152,230,124,62,0,0,0],"hint":0},{"address":[199,158,117,179,165,232,218,204,69,1,174,144,203,179,88,191,129,187,175,229,247,12,18,64,249,156,232,239,100,155,99,223],"bytes":[208,9,0,114,32,24,114,179,184,3,181,114,32,18,113,184,1,184,3,114,179,184,3,184,0,115,32,6,184,8,114,32,18,113,184,1,184,7,114,179,184,7,184,0,115,32,20,184,8,184,9,113,182,114,32,3,184,8,184,9,18,32,7,32,22,113,33,21,0,176,114,33,2,0,176,32,16,114,178,101,113,177,101,114,178,104,3,113,177,104,3,113,33,1,1,32,25,114,178,96,113,177,96,114,178,104,6,113,177,104,6,113,179,114,178,104,2,113,177,104,2,114,32,9,183,180,113,32,8,113,32,19,113,184,2,32,12,118,35,4,0,0,0,176,176,176,115,34,23,0,0,176,176,114,33,13,0,176,32,26,114,178,104,7,113,177,104,7,183,114,32,17,180,184,4,114,179,180,184,4,113,32,8,113,32,19,113,184,2,115,32,20,184,6,184,5,113,182,114,32,3,184,6,184,5,114,179,184,7,181,114,32,17,184,7,181,27,0,38,60,169,245,127,113,119,244,149,227,113,31,140,221,89,150,122,10,26,77,232,149,177,235,238,86,108,209,136,62,212,2,1,207,17,44,128,169,32,218,175,29,186,208,247,219,163,151,224,41,20,165,148,50,128,126,189,159,55,118,75,214,74,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,17,21,123,195,137,143,6,227,230,242,202,131,65,30,253,13,67,184,132,107,87,210,246,8,142,24,243,68,125,220,59,40,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,50,89,126,57,173,237,230,209,52,157,9,99,176,1,64,85,216,72,202,85,170,153,42,210,230,160,81,203,112,115,22,66,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,57,226,177,52,39,60,228,186,35,11,80,230,171,31,164,52,150,81,152,112,119,136,39,157,210,113,219,190,19,192,70,164,71,131,44,144,254,87,111,212,189,165,149,103,212,177,190,138,20,108,207,137,97,200,143,209,169,214,252,183,44,121,177,153,84,34,202,66,150,253,44,134,153,99,93,164,53,9,212,29,158,178,50,54,154,227,192,126,7,112,218,215,108,72,9,154,84,189,80,219,85,231,97,165,28,134,114,117,155,179,31,39,229,72,74,179,236,254,211,154,6,193,41,18,171,154,163,159,90,106,252,240,222,240,113,207,212,160,21,61,3,60,65,102,91,200,241,74,246,239,196,240,137,218,250,46,233,123,22,234,97,77,217,229,201,188,180,126,143,59,37,173,22,90,151,122,31,61,199,114,50,70,93,227,182,142,40,95,119,199,135,53,164,37,125,4,177,15,129,218,181,92,25,207,231,133,6,210,224,218,253,30,130,205,48,23,226,204,252,7,36,71,22,73,171,19,190,223,66,232,75,174,15,124,98,199,221,106,138,218,87,30,136,41,190,214,234,85,130,23,240,54,27,94,37,208,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,175,88,107,7,84,110,31,202,154,176,120,13,28,35,106,248,211,96,196,198,187,50,187,12,208,62,201,202,99,211,218,150,178,136,217,224,36,44,255,41,120,139,158,183,34,54,222,165,15,112,144,89,71,169,35,37,231,162,123,37,240,169,206,134,180,109,191,145,180,250,142,240,68,254,199,235,233,45,238,32,161,168,22,83,32,223,200,226,178,109,201,104,56,241,158,175,189,126,156,133,211,91,76,24,214,150,13,138,113,122,195,143,126,189,202,41,203,121,52,143,191,203,242,104,221,95,44,216,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,209,175,140,47,93,246,86,19,16,237,169,150,109,112,205,159,81,104,143,0,40,10,227,135,239,113,101,70,169,212,21,251,227,202,247,231,13,241,107,26,110,135,74,200,103,132,25,81,105,132,248,209,230,141,36,208,221,153,6,42,242,14,140,234,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,254,77,94,53,147,241,44,126,254,17,58,115,217,127,219,138,235,250,120,184,27,185,29,195,210,9,55,161,132,15,154,69,2,0,1,0],"hint":0},{"address":[200,25,111,139,173,4,113,17,180,147,46,124,84,80,253,40,19,60,115,182,116,170,192,128,210,86,136,151,205,182,174,94],"bytes":[208,1,0,146,23,176,23,177,113,32,0,118,35,1,0,0,0,176,176,176,115,34,8,0,0,176,176,114,33,3,0,176,32,9,115,33,6,0,176,101,113,32,7,101,17,130,7,176,7,177,64,4,16,2,32,2,113,32,4,16,10,30,26,43,187,25,32,237,74,18,129,163,222,202,100,106,211,19,202,156,123,247,234,189,195,101,89,135,121,124,204,12,85,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,97,77,217,229,201,188,180,126,143,59,37,173,22,90,151,122,31,61,199,114,50,70,93,227,182,142,40,95,119,199,135,53,144,2,42,228,197,213,42,210,138,205,128,5,29,212,31,39,245,28,156,74,251,171,27,179,145,119,60,25,239,13,193,233,171,19,190,223,66,232,75,174,15,124,98,199,221,106,138,218,87,30,136,41,190,214,234,85,130,23,240,54,27,94,37,208,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,209,175,140,47,93,246,86,19,16,237,169,150,109,112,205,159,81,104,143,0,40,10,227,135,239,113,101,70,169,212,21,251,254,77,94,53,147,241,44,126,254,17,58,115,217,127,219,138,235,250,120,184,27,185,29,195,210,9,55,161,132,15,154,69,1,0],"hint":4294967295},{"address":[200,50,46,3,213,88,248,90,142,220,127,230,133,36,1,56,128,173,11,188,183,220,137,1,54,210,71,21,75,35,9,146],"bytes":[209,0,1,0,0,1,2,148,23,178,23,177,23,179,23,176,113,19,16,2,0,131,7,178,7,177,7,179,17,1,132,7,178,7,177,7,179,7,176,114,17,16,116,49,0,0,19,18,17,16,4,32,0,113,16,32,2,145,23,176,0,146,23,176,23,113,18,16,113,19,113,32,1,17,3,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,1,192],"hint":0},{"address":[200,128,148,238,105,237,231,60,243,237,73,40,164,60,188,56,153,251,34,130,148,131,85,126,48,161,54,235,109,6,73,16],"bytes":[208,1,0,148,23,0,23,0,23,177,23,177,113,176,114,178,19,18,132,7,0,7,0,7,177,7,177,116,181,129,7,182,113,176,183,17,129,7,19,116,181,129,7,182,113,176,179,17,129,7,19,114,32,2,179,116,32,6,21,20,17,16,129,7,180,114,32,4,179,115,32,8,21,20,16,129,7,180,114,32,4,183,115,32,1,20,19,16,8,32,7,113,176,17,32,5,114,178,21,20,113,32,0,19,113,33,3,1,19,113,176,19,114,178,20,19,9,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,43,202,5,250,198,182,69,247,162,191,157,95,245,85,89,96,142,4,117,134,81,208,50,79,96,133,33,130,34,227,128,101,54,61,7,17,130,190,65,78,26,88,89,155,131,245,225,159,155,135,55,35,5,79,66,135,186,105,112,90,175,239,39,218,111,167,75,38,181,202,129,72,66,34,167,87,80,35,5,40,27,81,15,179,41,38,116,138,65,22,169,229,131,220,25,1,140,192,225,54,12,27,41,16,141,171,61,97,114,231,252,232,169,170,150,64,218,164,187,233,155,161,48,93,150,35,98,75,178,136,217,224,36,44,255,41,120,139,158,183,34,54,222,165,15,112,144,89,71,169,35,37,231,162,123,37,240,169,206,134,207,50,3,156,237,177,155,180,170,133,230,150,209,37,133,187,7,146,233,229,90,111,207,83,182,187,14,36,246,25,140,200,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,242,37,88,246,85,93,169,252,5,52,11,123,218,151,112,135,0,247,104,25,76,86,112,105,251,221,139,55,25,74,146,140,2,0,1,0],"hint":3},{"address":[201,125,114,130,94,113,116,53,122,105,247,215,16,79,78,166,25,65,214,223,92,24,132,252,87,193,182,173,19,254,164,198],"bytes":[209,0,2,1,0,1,2,149,23,0,23,178,23,177,23,181,23,180,179,2,0,132,7,0,7,178,7,177,7,181,17,2,134,7,0,7,178,7,177,7,181,7,19,7,113,176,20,115,18,17,16,117,50,0,1,2,21,20,19,18,16,6,33,1,2,113,16,113,33,0,2,17,145,23,113,176,16,1,113,19,16,113,176,19,147,23,18,23,180,23,179,113,20,115,33,2,2,21,18,17,3,57,148,188,81,227,104,111,48,161,212,131,214,157,10,131,90,123,72,77,137,35,147,192,132,248,122,88,73,222,84,243,2,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,179,167,216,2,73,253,130,49,0,238,3,98,98,50,209,65,42,14,131,53,39,93,93,245,59,146,148,56,135,182,80,247,3,1,193,192,193],"hint":0},{"address":[201,125,121,97,216,195,89,232,147,132,65,209,81,88,239,104,137,129,240,7,233,2,168,238,164,169,21,33,253,26,59,223],"bytes":[208,1,1,147,23,0,23,181,23,184,1,184,0,132,7,0,7,181,7,184,1,7,18,119,34,0,1,0,19,130,7,182,7,20,145,23,115,177,21,129,7,113,176,21,145,23,22,113,176,23,17,179,18,16,130,7,19,7,115,177,20,129,7,183,145,23,21,179,113,180,20,115,178,21,17,113,180,21,132,7,19,7,183,7,21,7,115,177,22,129,7,179,145,23,23,113,176,24,0,115,178,22,18,17,115,178,23,19,113,64,3,16,17,17,10,33,2,1,34,4,0,1,33,5,1,113,176,22,33,1,1,113,176,16,113,176,19,113,176,20,145,23,18,182,115,177,17,129,7,113,176,17,184,0,16,6,40,31,185,246,89,203,215,51,143,227,241,144,88,119,89,157,240,255,94,122,211,158,188,80,96,47,215,211,224,232,17,19,57,148,188,81,227,104,111,48,161,212,131,214,157,10,131,90,123,72,77,137,35,147,192,132,248,122,88,73,222,84,243,2,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,154,188,179,8,71,233,245,145,108,38,16,126,148,119,150,163,32,109,86,206,46,122,164,98,116,232,5,70,234,163,248,235,179,167,216,2,73,253,130,49,0,238,3,98,98,50,209,65,42,14,131,53,39,93,93,245,59,146,148,56,135,182,80,247,2,1,192,192],"hint":4294967295},{"address":[201,246,30,101,150,110,86,213,47,91,58,245,40,216,252,203,191,236,197,170,225,8,225,37,173,234,135,66,224,51,188,191],"bytes":[208,1,1,149,23,0,23,0,23,177,23,176,23,178,113,18,17,133,7,0,7,0,7,177,7,176,7,178,117,33,1,1,20,19,18,130,7,20,7,20,114,18,17,16,17,3,114,32,0,18,17,145,23,114,32,0,17,16,1,146,23,19,23,19,113,19,116,32,2,21,20,17,16,3,178,136,217,224,36,44,255,41,120,139,158,183,34,54,222,165,15,112,144,89,71,169,35,37,231,162,123,37,240,169,206,134,206,132,74,194,167,233,78,205,162,196,86,241,67,246,254,224,237,161,145,66,23,119,225,159,210,158,242,8,34,241,245,187,207,50,3,156,237,177,155,180,170,133,230,150,209,37,133,187,7,146,233,229,90,111,207,83,182,187,14,36,246,25,140,200,2,0,192],"hint":4294967295},{"address":[203,25,12,135,55,153,142,229,237,179,192,141,117,153,193,28,227,133,128,179,67,126,248,21,191,253,241,166,125,16,152,205],"bytes":[208,9,0,147,23,176,23,176,23,114,179,178,177,114,179,18,17,130,7,176,7,176,114,32,3,178,177,4,32,1,113,32,2,16,113,32,2,17,114,33,0,0,176,32,4,5,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,149,147,66,237,154,75,125,193,154,124,235,114,166,154,128,21,12,246,85,222,93,116,161,14,127,61,247,128,254,35,217,86,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,1,0],"hint":0},{"address":[203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91],"bytes":[208,1,1,147,23,0,23,32,0,23,176,18,131,7,0,7,32,0,7,176,64,1,16,1,114,33,1,1,17,16,2,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,87,37,236,155,87,31,47,96,62,242,235,229,144,227,237,62,133,119,138,63,77,207,200,178,204,121,242,2,203,120,236,204,2,1,192,192],"hint":4294967295},{"address":[204,0,4,254,212,83,179,96,130,8,37,30,76,98,73,39,255,65,177,239,242,177,51,213,14,93,125,196,205,89,180,81],"bytes":[208,9,0,147,23,176,23,176,23,184,4,184,5,131,7,176,7,176,7,184,4,118,32,18,131,7,176,7,176,7,184,4,184,5,18,17,16,130,7,176,7,113,184,3,113,177,16,113,32,15,17,131,7,176,7,176,7,184,4,161,7,114,181,116,183,182,184,1,114,32,3,179,17,179,17,118,32,8,18,17,129,7,113,32,21,182,114,181,116,183,184,0,16,184,2,178,18,184,1,129,7,182,115,32,12,178,18,17,129,7,113,32,0,182,115,32,16,18,116,183,184,0,114,32,13,184,0,16,184,2,178,16,16,14,32,6,32,7,113,177,19,113,177,18,113,33,1,0,176,113,180,32,14,115,180,32,17,17,179,113,33,9,1,176,115,180,32,17,18,178,114,32,11,17,179,114,32,3,178,18,113,181,115,33,19,0,176,101,113,32,20,101,113,184,3,16,114,181,118,35,4,0,0,0,176,176,176,114,33,2,0,176,32,10,18,17,17,22,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,14,140,157,90,31,226,163,144,223,50,193,100,1,212,239,112,30,85,166,100,127,243,255,35,237,59,47,103,30,124,173,51,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,109,246,232,68,250,110,177,159,63,131,165,143,118,202,92,252,153,76,184,1,77,193,132,132,251,249,132,55,171,38,81,61,113,116,99,130,92,85,39,2,186,25,8,185,250,93,143,63,119,134,215,115,12,99,62,65,216,211,128,147,159,238,183,72,116,129,248,50,7,172,22,52,112,238,167,107,224,144,138,118,130,209,23,76,230,235,194,196,12,235,21,158,220,100,24,146,123,182,89,135,102,113,224,61,7,49,196,86,232,148,206,158,111,125,232,37,10,180,174,112,17,61,192,142,36,83,33,39,125,153,57,223,4,184,173,187,198,51,152,205,122,5,146,120,137,156,31,226,17,210,196,144,216,29,104,194,81,202,76,30,140,192,225,54,12,27,41,16,141,171,61,97,114,231,252,232,169,170,150,64,218,164,187,233,155,161,48,93,150,35,98,75,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,175,9,117,110,177,82,121,33,25,161,227,86,120,130,27,112,231,216,72,81,58,119,85,17,146,183,109,115,45,61,236,133,184,66,204,67,88,17,89,78,71,158,34,36,117,207,187,248,81,165,194,113,45,86,65,209,204,31,74,230,9,128,237,89,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,194,166,172,166,193,68,126,132,35,36,208,147,195,116,236,19,183,40,241,26,246,83,19,235,96,50,170,168,30,68,248,238,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,2,0,1,0],"hint":0},{"address":[204,11,12,125,104,59,140,39,187,187,118,189,216,164,52,197,64,173,97,121,230,146,173,101,36,15,117,177,164,114,60,45],"bytes":[193,1,0,1,2,2,148,23,1,23,16,23,1,23,16,0,1,0,1,0,2,0,146,23,1,23,16,116,49,0,1,17,16,17,16,0,0,2,0,192],"hint":0},{"address":[205,33,118,133,66,207,172,59,71,247,22,109,9,71,88,176,244,56,61,35,19,45,96,219,135,88,4,149,72,234,103,230],"bytes":[208,9,0,147,23,176,23,176,23,181,114,180,114,178,18,17,179,131,7,176,7,176,7,181,160,7,146,23,176,23,182,0,130,7,176,7,182,114,180,114,178,20,17,179,117,32,13,19,130,7,176,7,183,114,18,17,16,18,17,131,7,176,7,183,7,116,32,11,21,130,7,176,7,114,177,22,16,114,20,17,16,17,16,120,0,32,4,22,19,131,7,176,7,114,177,23,16,7,184,0,114,180,114,178,24,1,18,179,18,17,16,129,7,32,6,113,32,1,23,132,7,176,7,114,32,5,23,16,7,184,0,7,114,22,18,17,115,32,3,24,2,19,16,9,32,2,114,33,0,0,176,32,9,32,7,32,8,113,33,10,1,32,12,114,177,17,16,114,177,19,16,114,177,20,16,116,32,11,24,0,130,7,176,7,114,177,24,1,16,114,23,17,16,17,16,14,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,38,153,238,144,4,59,30,221,27,58,195,34,215,85,208,51,39,92,169,211,103,255,33,72,66,164,23,231,126,149,100,87,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,60,134,215,137,75,203,119,63,4,248,167,22,60,252,178,120,187,219,161,221,99,4,124,167,233,10,21,117,26,21,214,117,125,5,202,27,89,81,239,15,178,70,105,218,191,12,42,52,131,94,52,226,173,174,122,30,113,112,73,15,34,82,122,87,143,112,180,160,174,152,116,193,51,244,179,211,36,51,17,25,136,171,75,61,193,164,122,107,230,246,195,65,167,219,176,175,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,158,68,91,157,95,130,82,119,35,71,135,46,144,155,93,180,231,236,167,8,108,237,244,254,198,222,132,15,107,123,95,146,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,218,224,24,9,166,175,10,253,129,230,253,211,161,211,159,239,134,168,168,196,233,8,24,177,163,87,225,128,221,218,178,89,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,241,234,181,89,14,243,85,127,115,217,213,16,117,241,14,246,8,112,69,108,235,128,246,108,61,93,23,111,158,121,188,189,2,0,1,0],"hint":0},{"address":[206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104],"bytes":[208,1,0,145,23,176,114,33,1,0,176,16,129,7,176,115,33,2,0,176,16,16,1,32,0,3,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,87,37,236,155,87,31,47,96,62,242,235,229,144,227,237,62,133,119,138,63,77,207,200,178,204,121,242,2,203,120,236,204,207,235,221,252,165,221,179,59,176,100,215,6,219,226,211,113,212,182,248,164,77,6,216,243,196,225,16,221,51,26,132,57,1,0],"hint":2},{"address":[206,48,252,15,65,53,230,121,207,59,22,208,214,103,189,157,244,231,166,157,187,129,119,162,158,92,117,180,140,76,236,16],"bytes":[212,0,0,59,221,128,220,156,145,103,10,73,69,57,146,131,200,250,144,116,111,117,222,101,218,171,215,58,64,190,212,212,177,163,136,0,0,0],"hint":0},{"address":[206,132,74,194,167,233,78,205,162,196,86,241,67,246,254,224,237,161,145,66,23,119,225,159,210,158,242,8,34,241,245,187],"bytes":[209,0,1,2,0,1,1,149,23,0,23,0,23,176,23,177,23,114,32,0,19,18,113,18,16,1,2,134,7,0,7,0,7,176,7,177,7,19,7,19,114,18,17,16,2,145,23,114,32,0,17,16,1,146,23,18,23,18,113,18,116,32,1,20,19,17,16,2,178,136,217,224,36,44,255,41,120,139,158,183,34,54,222,165,15,112,144,89,71,169,35,37,231,162,123,37,240,169,206,134,207,50,3,156,237,177,155,180,170,133,230,150,209,37,133,187,7,146,233,229,90,111,207,83,182,187,14,36,246,25,140,200,2,0,192],"hint":0},{"address":[207,50,3,156,237,177,155,180,170,133,230,150,209,37,133,187,7,146,233,229,90,111,207,83,182,187,14,36,246,25,140,200],"bytes":[212,0,0,169,239,92,9,42,27,22,83,51,139,185,251,157,250,169,225,134,29,73,33,182,148,174,139,15,186,12,31,166,218,254,216,0,0,0],"hint":0},{"address":[207,235,221,252,165,221,179,59,176,100,215,6,219,226,211,113,212,182,248,164,77,6,216,243,196,225,16,221,51,26,132,57],"bytes":[212,0,0,129,155,32,93,130,126,216,1,174,44,16,223,116,26,36,65,250,58,28,159,49,94,52,206,127,27,200,243,162,108,220,158,0,0,0],"hint":0},{"address":[207,236,5,209,215,242,81,47,101,119,194,246,26,132,5,35,128,76,54,212,4,60,37,42,180,186,37,8,237,231,81,113],"bytes":[193,1,0,0,0,0,0,1,0,0,0,0,0,48,0,0,0,1,0],"hint":0},{"address":[207,248,117,145,79,63,139,79,0,20,209,234,162,35,198,185,218,114,1,35,155,197,151,110,20,11,105,217,156,209,243,87],"bytes":[208,1,0,145,23,177,32,3,129,7,177,117,33,23,1,32,3,179,116,32,14,114,181,16,183,114,32,17,184,2,184,1,114,180,16,183,116,32,20,184,2,184,1,114,180,182,16,114,180,16,184,0,129,7,179,114,32,12,17,16,129,7,113,32,1,179,114,32,10,113,32,18,115,32,6,114,178,96,113,176,96,114,178,100,113,176,100,32,9,32,19,11,32,22,32,5,113,33,21,0,177,113,32,11,16,32,16,114,33,2,0,177,32,15,114,178,103,113,176,103,114,178,104,0,113,176,104,0,114,178,104,5,113,176,104,5,114,181,16,184,0,114,181,182,16,24,0,38,60,169,245,127,113,119,244,149,227,113,31,140,221,89,150,122,10,26,77,232,149,177,235,238,86,108,209,136,62,212,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,6,95,200,180,19,147,245,37,193,229,65,185,212,188,151,194,12,19,191,35,167,32,154,32,147,182,244,82,115,48,17,74,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,71,131,44,144,254,87,111,212,189,165,149,103,212,177,190,138,20,108,207,137,97,200,143,209,169,214,252,183,44,121,177,153,84,34,202,66,150,253,44,134,153,99,93,164,53,9,212,29,158,178,50,54,154,227,192,126,7,112,218,215,108,72,9,154,84,189,80,219,85,231,97,165,28,134,114,117,155,179,31,39,229,72,74,179,236,254,211,154,6,193,41,18,171,154,163,159,90,106,252,240,222,240,113,207,212,160,21,61,3,60,65,102,91,200,241,74,246,239,196,240,137,218,250,46,233,123,22,234,96,204,108,254,69,119,185,154,48,17,61,9,233,146,31,34,83,250,193,95,227,213,173,151,107,157,195,98,110,220,104,34,108,2,97,83,46,232,241,9,2,14,144,215,132,206,23,128,196,29,235,100,150,14,53,178,85,49,173,240,253,100,220,172,142,175,227,143,95,174,39,47,195,224,240,85,45,230,216,109,53,71,90,221,25,175,1,212,99,8,121,173,76,212,24,47,164,37,125,4,177,15,129,218,181,92,25,207,231,133,6,210,224,218,253,30,130,205,48,23,226,204,252,7,36,71,22,73,166,3,124,29,207,213,252,62,30,99,193,87,246,229,67,168,93,243,206,88,86,26,196,117,127,25,62,156,171,119,101,226,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,175,88,107,7,84,110,31,202,154,176,120,13,28,35,106,248,211,96,196,198,187,50,187,12,208,62,201,202,99,211,218,150,178,136,217,224,36,44,255,41,120,139,158,183,34,54,222,165,15,112,144,89,71,169,35,37,231,162,123,37,240,169,206,134,180,109,191,145,180,250,142,240,68,254,199,235,233,45,238,32,161,168,22,83,32,223,200,226,178,109,201,104,56,241,158,175,199,158,117,179,165,232,218,204,69,1,174,144,203,179,88,191,129,187,175,229,247,12,18,64,249,156,232,239,100,155,99,223,200,128,148,238,105,237,231,60,243,237,73,40,164,60,188,56,153,251,34,130,148,131,85,126,48,161,54,235,109,6,73,16,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,228,14,118,142,182,13,77,21,4,125,13,195,184,32,234,175,107,253,251,200,161,173,38,141,205,120,114,45,50,22,74,185,2,0,1,0],"hint":8},{"address":[209,175,140,47,93,246,86,19,16,237,169,150,109,112,205,159,81,104,143,0,40,10,227,135,239,113,101,70,169,212,21,251],"bytes":[208,1,2,147,23,0,23,1,23,176,115,35,0,2,3,2,18,17,18,131,7,0,7,1,7,176,116,35,2,2,3,2,18,17,18,130,7,18,7,18,117,34,1,2,3,20,19,18,17,16,1,114,34,3,2,3,17,16,4,63,164,161,115,247,173,66,124,193,64,28,191,75,202,81,190,222,182,48,140,169,218,222,5,163,109,131,195,112,142,41,18,87,126,90,15,232,8,149,210,119,167,204,55,147,11,0,116,248,202,15,201,237,91,62,42,155,123,33,131,166,247,190,50,199,121,203,241,226,212,168,174,59,26,43,150,182,228,23,65,12,141,118,172,231,128,225,38,251,202,75,61,200,58,65,8,248,113,220,56,84,110,35,226,251,163,213,50,63,253,122,23,6,235,47,55,54,75,11,33,3,232,69,100,172,113,4,244,4,1,192,1,193,192,193],"hint":2},{"address":[211,216,255,146,74,249,220,75,92,216,105,118,6,21,179,231,238,128,145,107,182,23,37,157,69,137,12,105,244,18,131,55],"bytes":[208,1,0,145,23,176,177,130,7,176,7,176,116,33,3,0,129,7,176,177,17,32,0,16,2,32,1,145,23,176,32,2,4,45,146,134,208,64,215,133,108,174,176,110,188,41,30,135,83,226,230,8,38,174,193,97,4,162,5,86,221,33,31,79,159,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,1,1,0],"hint":2},{"address":[212,148,220,96,19,134,186,142,143,11,113,31,230,42,45,96,171,96,198,72,140,140,246,206,151,121,110,188,58,213,254,251],"bytes":[212,0,0,137,92,70,72,79,44,186,97,206,219,49,12,102,189,163,49,156,22,55,176,21,196,234,167,89,51,99,188,229,178,211,124,0,0,0],"hint":0},{"address":[212,206,220,104,102,212,61,230,187,167,17,118,228,84,101,185,106,118,79,1,199,64,218,16,151,169,247,119,95,212,111,164],"bytes":[208,1,1,151,23,181,23,176,23,176,23,183,23,182,23,184,0,23,184,1,114,22,21,20,135,7,181,7,176,7,176,7,183,7,182,7,184,0,7,184,1,116,178,129,7,176,114,23,16,21,21,116,178,129,7,176,114,23,177,16,20,113,19,32,2,129,7,176,113,19,16,129,7,176,116,178,129,7,176,114,24,0,180,16,21,113,18,16,129,7,176,114,18,17,16,10,32,0,32,5,33,4,0,113,32,1,16,113,32,1,17,146,23,176,23,176,0,145,23,176,114,20,177,179,145,23,32,3,114,19,177,177,145,23,176,114,21,179,177,146,23,176,23,176,114,23,180,179,6,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,120,192,56,5,248,234,247,211,103,224,245,121,9,171,213,102,217,74,43,235,207,98,112,254,47,231,74,249,84,237,13,0,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,1,192],"hint":4294967295},{"address":[212,242,86,44,127,148,111,155,110,164,100,223,38,78,46,178,220,160,215,184,60,235,121,164,78,31,105,70,61,221,236,0],"bytes":[212,0,0,36,214,98,101,106,41,65,247,131,125,73,197,70,115,110,203,79,161,94,171,159,108,160,154,175,27,191,200,18,146,227,129,0,0,0],"hint":0},{"address":[215,149,230,94,69,97,85,230,174,28,234,91,220,150,36,117,231,14,61,26,99,80,91,221,41,196,80,23,73,229,200,111],"bytes":[208,1,0,146,23,176,23,179,177,131,7,176,7,179,7,176,118,33,0,1,130,7,176,7,176,145,23,179,176,16,18,130,7,176,7,113,178,115,33,7,0,176,97,113,32,8,97,17,131,7,176,7,176,7,113,178,113,32,4,16,113,32,2,113,64,5,16,18,17,4,32,3,145,23,176,176,113,33,6,1,129,7,176,177,113,178,16,9,31,18,131,103,83,217,53,237,140,231,225,212,60,28,82,226,220,167,42,91,72,133,111,19,221,172,215,202,222,15,102,64,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,50,68,104,115,1,215,121,236,117,114,116,118,29,144,61,239,62,179,19,81,119,50,123,112,155,203,216,84,239,73,111,121,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,2,0,1,0],"hint":4294967295},{"address":[215,232,145,191,245,80,90,115,115,146,60,98,136,250,62,191,168,139,239,108,80,21,89,142,164,225,192,24,137,42,27,254],"bytes":[208,1,0,145,23,32,3,113,32,2,115,33,4,0,32,1,96,113,32,5,96,129,7,32,3,64,3,16,0,6,0,38,60,169,245,127,113,119,244,149,227,113,31,140,221,89,150,122,10,26,77,232,149,177,235,238,86,108,209,136,62,212,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,144,2,42,228,197,213,42,210,138,205,128,5,29,212,31,39,245,28,156,74,251,171,27,179,145,119,60,25,239,13,193,233,180,168,196,184,204,231,183,63,134,178,84,245,163,33,130,122,234,156,175,40,8,53,242,193,230,56,84,84,238,168,199,233,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,1,0],"hint":4294967295},{"address":[218,224,24,9,166,175,10,253,129,230,253,211,161,211,159,239,134,168,168,196,233,8,24,177,163,87,225,128,221,218,178,89],"bytes":[214,0,36,214,98,101,106,41,65,247,131,125,73,197,70,115,110,203,79,161,94,171,159,108,160,154,175,27,191,200,18,146,227,129,0,0,0],"hint":0},{"address":[218,228,37,45,123,48,184,54,162,73,61,192,145,170,139,211,132,252,73,173,213,163,61,3,152,47,222,46,171,101,17,185],"bytes":[208,1,0,149,23,184,0,23,177,23,179,23,182,23,183,114,20,19,18,133,7,184,0,7,177,7,179,7,182,7,183,117,33,0,0,129,7,177,145,23,179,114,22,17,16,19,129,7,181,113,17,16,129,7,180,113,18,16,18,9,32,3,32,4,113,33,2,1,177,114,178,16,176,114,178,32,1,176,114,178,176,176,145,23,180,114,19,32,1,16,145,23,181,114,20,176,16,146,23,177,23,179,0,5,87,167,53,35,32,67,243,33,132,94,50,178,160,142,93,54,175,23,91,174,34,234,35,34,120,68,188,69,151,153,255,69,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,221,161,43,203,51,7,39,246,223,184,22,188,151,82,170,189,5,32,230,81,91,121,252,138,90,158,113,56,102,244,198,62,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,2,0,1,0],"hint":4294967295},{"address":[220,50,12,210,41,236,248,22,132,182,247,17,13,188,74,247,88,55,95,62,217,112,230,167,102,33,9,40,218,106,182,97],"bytes":[208,1,2,150,23,0,23,181,23,177,23,178,23,182,23,183,114,20,19,18,134,7,0,7,181,7,177,7,178,7,182,7,183,117,34,2,2,1,21,129,7,179,114,21,16,19,19,113,17,18,130,7,21,7,180,115,18,17,16,20,8,33,1,1,113,176,17,113,176,18,113,176,21,113,176,22,146,23,113,176,16,23,177,2,145,23,113,176,19,114,19,113,33,0,1,20,16,147,23,20,23,179,23,180,114,22,115,33,3,1,23,18,17,16,4,57,148,188,81,227,104,111,48,161,212,131,214,157,10,131,90,123,72,77,137,35,147,192,132,248,122,88,73,222,84,243,2,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,150,145,212,243,57,243,164,63,121,161,201,51,86,245,77,129,59,198,227,235,59,233,116,46,93,47,105,5,167,53,185,3,179,167,216,2,73,253,130,49,0,238,3,98,98,50,209,65,42,14,131,53,39,93,93,245,59,146,148,56,135,182,80,247,3,1,192,192,193],"hint":4294967295},{"address":[221,130,125,188,51,21,25,234,120,233,109,145,197,211,51,90,209,123,164,153,203,23,203,36,50,52,242,237,142,210,28,95],"bytes":[208,9,1,148,23,2,23,16,23,17,23,180,115,178,19,18,17,132,7,2,7,16,7,17,7,180,161,7,150,23,2,23,2,23,17,23,17,23,181,23,114,179,20,19,115,178,20,116,177,21,20,16,19,18,133,7,2,7,2,7,17,7,17,7,181,119,34,2,0,2,20,18,131,7,2,7,16,7,116,176,22,20,17,16,145,23,114,179,23,18,115,178,19,116,177,24,0,19,16,22,18,129,7,114,179,20,20,114,33,0,2,21,116,177,21,21,16,19,19,17,16,118,16,20,20,19,18,17,114,33,0,1,2,20,6,33,1,2,33,3,2,33,4,2,113,33,4,1,2,116,176,18,17,18,16,116,176,19,17,18,16,5,2,1,207,17,44,128,169,32,218,175,29,186,208,247,219,163,151,224,41,20,165,148,50,128,126,189,159,55,118,75,214,74,171,154,109,137,72,73,148,55,108,192,222,72,8,59,163,82,24,151,208,77,71,179,52,161,16,167,124,84,197,89,93,108,174,78,20,46,10,231,176,111,184,237,115,197,138,71,50,21,28,53,22,175,68,119,222,88,135,208,30,29,192,198,178,137,184,150,129,100,248,126,196,245,228,122,187,161,51,128,37,115,237,51,68,189,137,112,206,106,160,26,77,165,138,101,221,230,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,3,0,1,192,192],"hint":0},{"address":[221,137,250,145,252,150,133,26,24,234,68,119,188,113,59,159,39,228,129,192,240,63,248,73,153,65,47,27,98,62,218,102],"bytes":[208,1,0,147,23,176,23,176,23,184,13,114,177,114,178,18,17,114,180,18,17,131,7,176,7,176,7,184,13,117,32,10,129,7,176,145,23,113,184,2,16,184,12,17,130,7,32,12,7,113,184,2,181,115,32,2,114,178,20,181,114,180,20,181,113,32,5,20,130,7,176,7,113,184,2,113,179,16,118,32,8,20,17,129,7,184,12,114,177,184,9,184,11,64,11,16,129,7,184,8,115,32,3,184,9,184,11,115,32,16,184,4,18,16,129,7,184,10,118,32,1,21,18,129,7,114,177,184,6,184,7,114,177,183,184,0,115,32,9,18,21,16,129,7,184,6,115,32,3,183,184,0,118,34,21,0,1,176,19,130,7,176,7,114,184,5,20,16,114,178,17,184,4,113,32,7,182,22,16,129,7,184,7,115,32,2,183,184,0,16,16,22,32,4,32,18,114,33,0,0,176,32,14,32,6,114,33,20,0,176,32,15,32,19,113,179,19,114,178,22,182,114,180,22,182,33,13,0,113,184,1,129,7,176,114,177,114,178,20,16,114,180,20,16,113,179,18,113,179,21,113,33,17,1,176,114,184,5,18,21,114,178,18,21,114,178,20,17,114,178,21,184,3,114,180,20,17,114,180,21,184,3,114,177,184,8,184,10,114,184,1,129,7,176,114,177,114,178,18,16,114,180,18,16,16,22,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,21,112,2,29,141,231,220,71,99,83,190,161,151,71,236,156,143,5,227,232,232,203,120,174,184,250,211,156,80,44,225,41,32,234,41,58,99,89,72,84,125,46,246,57,166,36,225,101,13,83,239,74,167,10,58,241,65,182,82,242,79,201,191,201,50,89,126,57,173,237,230,209,52,157,9,99,176,1,64,85,216,72,202,85,170,153,42,210,230,160,81,203,112,115,22,66,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,54,45,116,9,166,5,234,18,119,172,63,136,71,50,174,47,135,191,229,248,142,163,85,100,21,207,80,9,30,131,86,48,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,96,216,116,231,204,103,223,155,196,38,250,152,158,223,135,142,180,37,214,16,87,76,159,105,22,153,73,21,72,244,10,91,110,136,64,72,21,82,41,235,105,49,176,6,2,238,37,242,70,209,130,45,161,110,242,220,70,126,51,211,181,88,113,10,114,210,136,75,136,77,34,213,201,45,246,252,67,145,231,219,169,53,28,134,241,118,56,204,27,66,93,235,210,35,205,26,127,102,69,142,31,137,141,70,61,222,210,142,237,123,140,24,107,128,134,79,228,183,18,62,197,203,28,171,94,219,131,202,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,187,10,163,115,53,182,254,60,110,134,248,76,226,160,222,70,31,73,229,115,2,85,69,138,211,230,171,71,86,136,39,120,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,227,202,247,231,13,241,107,26,110,135,74,200,103,132,25,81,105,132,248,209,230,141,36,208,221,153,6,42,242,14,140,234,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,240,100,197,234,66,44,190,111,117,71,83,154,159,89,122,138,122,170,46,209,234,37,69,72,84,27,176,143,148,9,97,74,251,3,245,167,225,65,216,64,37,179,165,3,222,220,83,206,134,242,151,189,227,107,188,27,152,104,122,234,180,53,153,104,2,0,1,0],"hint":4294967295},{"address":[221,146,133,172,69,212,172,133,209,127,160,211,36,61,121,9,199,130,162,162,118,238,63,176,207,254,250,154,251,219,13,225],"bytes":[212,0,0,50,242,172,147,14,116,84,169,40,68,47,88,105,234,131,149,8,103,39,203,220,62,157,236,213,65,3,84,154,77,218,100,0,0,0],"hint":0},{"address":[221,161,43,203,51,7,39,246,223,184,22,188,151,82,170,189,5,32,230,81,91,121,252,138,90,158,113,56,102,244,198,62],"bytes":[212,0,0,192,249,159,60,200,70,172,234,189,186,46,179,225,144,114,0,55,46,122,75,82,164,167,51,223,127,13,48,184,75,57,120,0,0,0],"hint":0},{"address":[224,44,161,91,183,89,88,106,37,217,86,66,190,23,241,239,92,198,217,21,150,233,148,62,69,88,91,186,17,27,82,137],"bytes":[208,9,0,148,23,0,23,0,23,177,23,176,19,132,7,0,7,0,7,177,7,176,118,32,3,19,18,19,17,113,33,1,0,19,129,7,18,116,33,4,0,19,20,16,17,2,113,32,0,17,114,32,2,17,16,5,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,23,50,153,199,110,250,130,230,137,33,10,9,228,154,208,156,20,238,17,8,242,218,141,53,94,249,51,59,21,131,161,213,227,202,247,231,13,241,107,26,110,135,74,200,103,132,25,81,105,132,248,209,230,141,36,208,221,153,6,42,242,14,140,234,242,216,6,110,100,213,143,218,10,242,106,251,22,37,29,29,150,192,110,224,46,20,56,30,194,117,199,85,160,13,178,120,247,154,238,65,62,228,123,177,250,111,32,39,251,4,239,21,151,135,26,64,134,212,33,124,255,73,19,250,29,106,224,186,1,0],"hint":0},{"address":[224,99,232,12,135,171,160,238,162,222,95,200,223,118,137,162,212,105,13,226,33,162,194,249,56,247,195,211,8,190,95,241],"bytes":[193,1,0,0,1,1,146,23,176,23,176,0,2,0,0,0,1,0,145,23,176,114,177,16,16,0,0,1,1,2,147,23,176,23,176,23,114,177,17,16,114,177,18,113,32,1,17,2,32,0,48,0,2,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,1,0],"hint":0},{"address":[225,144,38,208,210,235,131,138,90,222,61,142,38,34,204,35,242,166,62,92,6,39,219,146,51,97,49,51,84,225,221,246],"bytes":[208,1,0,150,23,0,23,0,23,177,23,176,23,178,23,179,113,19,18,134,7,0,7,0,7,177,7,176,7,178,7,179,118,32,0,21,20,19,129,7,21,113,18,16,129,7,20,113,17,16,18,4,114,32,3,18,17,145,23,114,32,3,17,16,0,145,23,19,113,18,115,32,2,20,19,16,145,23,19,113,19,115,32,1,21,20,16,4,32,28,102,93,27,115,0,58,220,95,221,174,209,234,36,234,183,127,42,85,28,141,235,53,132,213,132,25,124,51,174,187,32,234,41,58,99,89,72,84,125,46,246,57,166,36,225,101,13,83,239,74,167,10,58,241,65,182,82,242,79,201,191,201,50,89,126,57,173,237,230,209,52,157,9,99,176,1,64,85,216,72,202,85,170,153,42,210,230,160,81,203,112,115,22,66,227,202,247,231,13,241,107,26,110,135,74,200,103,132,25,81,105,132,248,209,230,141,36,208,221,153,6,42,242,14,140,234,1,0],"hint":4294967295},{"address":[226,72,221,147,156,222,87,251,189,159,22,193,104,218,241,226,145,46,167,92,22,210,43,142,160,143,55,17,73,248,146,45],"bytes":[208,9,0,149,23,176,23,176,23,176,23,179,23,179,114,178,20,18,132,7,176,7,176,7,176,7,179,116,32,0,177,113,32,3,18,17,115,32,5,177,18,16,4,32,2,113,32,3,19,114,33,1,0,176,32,4,114,178,18,17,6,1,52,162,6,154,222,214,241,18,20,204,33,47,37,177,194,163,224,207,41,103,92,148,75,153,178,28,90,2,159,76,39,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,187,10,163,115,53,182,254,60,110,134,248,76,226,160,222,70,31,73,229,115,2,85,69,138,211,230,171,71,86,136,39,120,1,0],"hint":0},{"address":[226,94,101,45,187,137,181,227,90,47,36,47,238,235,72,46,81,100,226,84,85,25,67,11,61,9,70,223,255,235,63,98],"bytes":[208,1,1,149,23,0,23,177,23,176,23,179,23,178,113,19,18,133,7,0,7,177,7,176,7,179,7,178,117,33,2,1,20,19,129,7,113,32,0,20,113,18,16,129,7,20,113,17,16,18,4,113,32,4,17,145,23,113,32,4,16,1,145,23,19,113,19,114,32,1,20,16,145,23,113,32,0,18,113,18,114,32,3,19,16,5,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,54,61,7,17,130,190,65,78,26,88,89,155,131,245,225,159,155,135,55,35,5,79,66,135,186,105,112,90,175,239,39,218,62,167,225,143,203,183,196,152,178,164,82,55,189,166,89,192,237,201,123,61,84,164,173,13,17,188,46,190,200,12,250,23,140,192,225,54,12,27,41,16,141,171,61,97,114,231,252,232,169,170,150,64,218,164,187,233,155,161,48,93,150,35,98,75,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,2,0,192],"hint":4294967295},{"address":[227,86,40,45,77,213,30,146,205,54,42,123,250,52,38,33,61,187,80,133,102,142,246,134,172,18,220,46,181,75,122,39],"bytes":[212,0,0,184,198,62,148,95,90,162,171,200,68,75,97,246,220,106,248,133,82,102,153,28,149,207,65,76,24,13,85,243,107,39,112,0,0,0],"hint":0},{"address":[227,90,177,115,88,250,231,168,30,251,61,148,161,100,253,63,133,171,139,12,136,138,170,7,28,254,13,96,255,188,28,172],"bytes":[214,0,207,236,5,209,215,242,81,47,101,119,194,246,26,132,5,35,128,76,54,212,4,60,37,42,180,186,37,8,237,231,81,113,0,0,0],"hint":0},{"address":[227,202,247,231,13,241,107,26,110,135,74,200,103,132,25,81,105,132,248,209,230,141,36,208,221,153,6,42,242,14,140,234],"bytes":[214,0,165,58,3,50,179,58,5,167,174,109,148,154,213,173,224,59,213,27,245,170,164,198,0,195,130,85,237,186,156,179,30,42,0,0,0],"hint":0},{"address":[228,14,118,142,182,13,77,21,4,125,13,195,184,32,234,175,107,253,251,200,161,173,38,141,205,120,114,45,50,22,74,185],"bytes":[208,1,1,149,23,1,23,0,23,176,23,177,23,178,20,133,7,1,7,0,7,176,7,177,7,178,117,33,1,1,19,129,7,113,32,2,19,21,18,16,17,3,113,32,2,16,145,23,17,19,145,23,113,32,0,18,20,3,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,226,94,101,45,187,137,181,227,90,47,36,47,238,235,72,46,81,100,226,84,85,25,67,11,61,9,70,223,255,235,63,98,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,2,0,192],"hint":3},{"address":[229,189,28,137,7,71,176,10,240,241,238,202,35,26,230,244,125,118,195,113,110,47,38,135,122,134,147,192,107,197,146,69],"bytes":[208,1,1,150,23,180,23,176,23,176,23,181,23,182,23,183,114,21,20,19,134,7,180,7,176,7,176,7,181,7,182,7,183,116,177,129,7,176,114,22,16,20,20,113,18,19,129,7,176,116,177,129,7,176,114,23,179,16,20,113,18,16,129,7,176,114,18,17,16,8,32,0,33,2,0,113,32,1,16,113,32,1,17,146,23,176,23,176,0,145,23,176,114,19,32,3,16,145,23,176,114,20,178,32,3,146,23,176,23,176,114,22,179,178,4,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,1,192],"hint":4294967295},{"address":[230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164],"bytes":[214,0,192,249,159,60,200,70,172,234,189,186,46,179,225,144,114,0,55,46,122,75,82,164,167,51,223,127,13,48,184,75,57,120,0,0,0],"hint":0},{"address":[233,94,127,120,200,105,105,125,102,16,144,15,71,189,136,171,225,49,243,95,82,198,241,78,250,182,101,53,78,94,169,30],"bytes":[208,1,0,145,23,176,180,130,7,176,7,179,117,32,2,129,7,176,180,17,130,7,32,4,7,113,178,32,11,32,12,130,7,176,7,113,178,113,32,1,16,64,3,16,16,5,32,0,115,33,7,1,129,7,32,10,0,32,5,32,9,113,33,6,0,129,7,176,113,177,114,32,8,16,16,113,178,16,145,23,179,113,177,114,32,8,17,17,13,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,127,102,69,142,31,137,141,70,61,222,210,142,237,123,140,24,107,128,134,79,228,183,18,62,197,203,28,171,94,219,131,202,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,161,35,96,69,20,10,194,171,190,21,41,88,52,132,52,251,132,73,101,150,249,252,93,203,189,88,91,129,116,196,57,39,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,176,177,13,178,135,1,45,21,180,105,78,118,183,137,193,46,197,228,30,252,157,184,166,99,207,215,84,191,47,196,151,23,211,216,255,146,74,249,220,75,92,216,105,118,6,21,179,231,238,128,145,107,182,23,37,157,69,137,12,105,244,18,131,55,227,90,177,115,88,250,231,168,30,251,61,148,161,100,253,63,133,171,139,12,136,138,170,7,28,254,13,96,255,188,28,172,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,244,188,42,158,142,38,142,179,82,247,25,101,125,136,6,176,114,165,85,162,159,46,184,94,114,128,95,221,201,205,1,145,2,0,1,0],"hint":4294967295},{"address":[234,19,119,4,22,131,84,128,64,102,33,157,192,155,47,160,234,144,126,86,252,192,64,164,178,197,109,13,129,29,118,93],"bytes":[208,9,0,147,23,0,23,0,23,176,17,131,7,0,7,0,7,176,65,0,16,1,114,32,0,17,16,1,178,136,217,224,36,44,255,41,120,139,158,183,34,54,222,165,15,112,144,89,71,169,35,37,231,162,123,37,240,169,206,134,1,0],"hint":0},{"address":[235,80,53,253,14,237,19,39,158,181,89,13,194,124,130,114,1,54,228,250,165,233,124,128,18,170,79,204,128,120,19,52],"bytes":[208,1,0,113,33,1,0,32,2,114,33,3,0,32,2,32,0,0,4,3,179,160,65,40,91,15,226,2,217,11,34,125,64,92,76,236,37,45,241,139,167,97,106,205,109,174,39,146,230,114,187,36,58,236,162,36,20,248,239,254,81,241,25,172,162,71,149,152,170,72,252,221,0,96,60,94,184,74,141,22,226,88,213,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,148,77,150,214,42,122,160,96,153,65,92,165,175,218,48,241,66,199,14,18,254,189,182,209,85,174,176,172,85,8,152,64,1,0],"hint":5},{"address":[236,23,58,211,91,233,215,92,47,21,16,249,84,129,66,64,39,236,1,24,107,195,240,22,160,63,4,102,78,84,112,214],"bytes":[193,1,0,1,1,0,145,23,0,0,1,0,1,0,1,1,146,23,0,23,146,23,16,23,17,18,113,49,0,1,17,0,0,2,1,192,192],"hint":0},{"address":[238,14,28,167,126,90,205,78,70,91,168,94,39,242,68,66,47,0,98,9,95,223,66,32,87,29,140,28,39,84,116,163],"bytes":[208,1,1,149,23,176,23,184,11,23,176,23,184,9,23,184,12,114,19,18,17,133,7,176,7,184,11,7,176,7,184,9,7,184,12,117,33,8,2,129,7,176,145,23,114,179,21,16,114,21,17,16,18,129,7,114,179,20,177,114,33,5,2,114,20,177,16,120,0,32,1,184,6,130,7,176,7,184,7,146,23,113,184,0,17,23,114,184,10,114,182,183,18,17,181,177,16,129,7,113,184,0,184,6,114,184,1,145,23,116,184,2,114,179,22,177,17,114,182,180,180,113,32,16,180,181,114,184,8,180,16,131,7,176,7,184,7,7,113,184,0,184,4,114,184,1,145,23,114,184,10,114,182,183,184,5,115,32,12,183,18,17,181,114,184,8,184,5,16,114,33,14,1,176,177,114,33,2,0,114,179,21,177,16,130,7,176,7,114,179,21,184,3,114,18,17,16,17,21,32,4,32,15,32,6,114,33,0,0,176,32,11,113,178,22,32,9,32,7,113,178,24,0,114,33,13,1,176,177,33,5,0,33,10,0,113,178,16,113,178,17,113,178,18,113,178,21,114,182,180,16,115,33,17,1,176,32,3,177,114,179,18,16,114,184,2,114,179,24,0,177,19,146,23,176,23,114,179,17,16,2,146,23,176,23,114,179,20,184,3,114,20,184,4,16,18,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,17,57,94,11,168,111,246,177,22,200,19,9,72,121,252,64,171,24,91,139,219,212,182,27,23,168,83,212,188,164,20,37,31,181,154,127,225,27,53,79,1,145,116,89,241,61,225,54,55,151,173,12,23,60,111,134,41,121,101,6,10,234,138,44,38,19,240,10,77,89,35,190,7,115,135,206,235,135,240,254,104,205,54,26,233,135,189,129,142,6,111,96,66,38,76,23,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,55,164,229,247,168,54,105,254,65,69,200,121,128,151,23,42,140,241,109,45,19,5,51,112,162,179,156,160,204,69,56,146,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,143,112,180,160,174,152,116,193,51,244,179,211,36,51,17,25,136,171,75,61,193,164,122,107,230,246,195,65,167,219,176,175,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,161,35,96,69,20,10,194,171,190,21,41,88,52,132,52,251,132,73,101,150,249,252,93,203,189,88,91,129,116,196,57,39,171,154,109,137,72,73,148,55,108,192,222,72,8,59,163,82,24,151,208,77,71,179,52,161,16,167,124,84,197,89,93,108,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,187,67,180,68,88,106,58,237,43,170,13,123,116,49,202,109,205,20,171,148,68,188,119,146,13,19,67,51,208,191,229,116,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,212,148,220,96,19,134,186,142,143,11,113,31,230,42,45,96,171,96,198,72,140,140,246,206,151,121,110,188,58,213,254,251,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,244,242,199,63,63,176,199,189,250,212,209,10,144,100,144,38,99,103,162,129,151,44,249,218,31,186,104,181,104,141,20,40,255,53,45,34,4,221,221,232,92,181,199,177,120,224,147,215,13,109,75,176,104,182,165,230,62,138,27,117,112,112,44,164,3,0,1,0,192],"hint":4294967295},{"address":[238,26,61,140,224,254,229,196,154,95,21,193,5,247,152,94,66,37,224,91,255,54,11,111,58,71,144,155,18,76,219,187],"bytes":[208,1,0,152,0,23,184,5,23,176,23,176,23,180,23,180,23,184,8,23,184,7,23,184,6,116,23,22,21,20,19,136,0,7,184,5,7,176,7,176,7,180,7,180,7,184,8,7,184,7,7,184,6,117,182,129,7,176,145,23,184,1,116,24,1,17,23,16,21,22,129,7,184,2,115,19,22,16,20,130,7,176,7,181,117,182,129,7,176,145,23,184,1,116,24,3,184,0,17,18,16,23,129,7,184,2,115,20,18,17,16,130,7,176,7,181,116,20,19,17,18,16,21,20,17,32,2,32,3,115,33,6,0,176,97,113,32,7,97,115,33,0,0,176,32,5,178,113,179,17,113,179,113,177,16,33,4,0,113,177,18,113,177,19,113,179,16,113,179,32,8,113,179,113,177,17,113,179,178,148,23,176,23,176,23,180,23,180,0,148,23,176,23,176,23,184,3,23,184,3,116,24,2,184,0,183,17,16,147,23,176,23,181,23,184,4,116,24,0,183,178,17,16,147,23,176,23,184,4,23,180,116,23,178,18,17,16,9,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,1,0],"hint":4294967295},{"address":[238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70],"bytes":[212,0,0,21,82,189,84,69,166,57,241,90,253,231,25,173,73,94,73,40,27,198,238,195,105,239,14,99,135,203,177,190,110,228,82,0,0,0],"hint":0},{"address":[238,192,109,6,37,122,125,52,177,50,103,100,145,207,255,213,144,95,77,104,185,132,34,88,113,40,42,129,67,82,12,19],"bytes":[208,1,0,145,23,32,0,32,1,129,7,32,0,64,0,16,0,2,6,95,200,180,19,147,245,37,193,229,65,185,212,188,151,194,12,19,191,35,167,32,154,32,147,182,244,82,115,48,17,74,180,168,196,184,204,231,183,63,134,178,84,245,163,33,130,122,234,156,175,40,8,53,242,193,230,56,84,84,238,168,199,233,0],"hint":4294967295},{"address":[238,201,147,217,151,117,233,165,18,185,196,13,192,134,29,251,228,29,215,73,161,77,70,189,93,214,140,7,121,197,60,217],"bytes":[208,9,0,146,23,176,23,176,114,32,5,114,177,17,16,114,178,17,16,130,7,176,7,176,115,33,7,0,129,7,176,114,32,5,114,177,18,16,114,178,18,16,16,113,32,4,17,3,32,1,114,33,0,0,176,32,2,114,33,6,0,176,32,3,8,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,221,137,250,145,252,150,133,26,24,234,68,119,188,113,59,159,39,228,129,192,240,63,248,73,153,65,47,27,98,62,218,102,227,202,247,231,13,241,107,26,110,135,74,200,103,132,25,81,105,132,248,209,230,141,36,208,221,153,6,42,242,14,140,234,240,100,197,234,66,44,190,111,117,71,83,154,159,89,122,138,122,170,46,209,234,37,69,72,84,27,176,143,148,9,97,74,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,1,0],"hint":0},{"address":[239,98,173,170,214,208,43,159,81,45,36,236,23,22,199,59,255,122,224,141,138,228,95,227,48,224,153,37,165,171,147,165],"bytes":[208,1,0,150,23,0,23,0,23,178,23,177,23,179,23,180,113,19,18,134,7,0,7,0,7,178,7,177,7,179,7,180,118,32,2,21,20,129,7,114,176,21,20,113,20,16,18,129,7,21,113,18,16,129,7,20,113,17,16,5,32,3,114,176,18,17,145,23,114,176,17,16,0,145,23,19,113,18,115,32,1,20,19,16,145,23,19,113,19,115,32,0,21,20,16,4,32,234,41,58,99,89,72,84,125,46,246,57,166,36,225,101,13,83,239,74,167,10,58,241,65,182,82,242,79,201,191,201,50,89,126,57,173,237,230,209,52,157,9,99,176,1,64,85,216,72,202,85,170,153,42,210,230,160,81,203,112,115,22,66,225,144,38,208,210,235,131,138,90,222,61,142,38,34,204,35,242,166,62,92,6,39,219,146,51,97,49,51,84,225,221,246,227,202,247,231,13,241,107,26,110,135,74,200,103,132,25,81,105,132,248,209,230,141,36,208,221,153,6,42,242,14,140,234,1,0],"hint":4294967295},{"address":[240,100,197,234,66,44,190,111,117,71,83,154,159,89,122,138,122,170,46,209,234,37,69,72,84,27,176,143,148,9,97,74],"bytes":[208,1,1,148,23,1,23,176,23,17,23,18,0,132,7,1,7,176,7,17,7,18,116,33,0,2,19,18,16,17,1,113,33,1,2,16,2,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,49,201,229,28,85,180,20,198,36,190,155,239,220,3,50,69,108,205,146,154,196,27,168,14,229,13,203,114,18,206,1,242,3,0,1,192,192],"hint":2},{"address":[240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95],"bytes":[214,0,9,29,40,138,180,96,173,98,252,118,250,245,55,121,6,220,159,184,166,65,211,232,175,73,90,14,209,70,210,138,217,109,0,0,0],"hint":0},{"address":[241,234,181,89,14,243,85,127,115,217,213,16,117,241,14,246,8,112,69,108,235,128,246,108,61,93,23,111,158,121,188,189],"bytes":[208,9,0,149,23,176,23,181,23,176,23,180,23,182,179,133,7,176,7,181,7,176,7,180,7,182,115,16,18,17,118,32,2,20,114,178,20,19,114,32,3,20,19,131,7,176,7,114,177,21,16,7,116,178,22,21,17,16,118,32,5,23,22,18,17,16,113,179,16,18,17,7,32,0,32,1,32,4,114,19,18,17,114,177,18,16,146,23,176,23,114,177,17,16,0,147,23,176,23,114,177,20,16,23,116,178,21,20,17,16,114,21,18,17,6,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,143,112,180,160,174,152,116,193,51,244,179,211,36,51,17,25,136,171,75,61,193,164,122,107,230,246,195,65,167,219,176,175,173,229,14,160,69,134,173,157,62,239,68,203,61,253,196,132,125,56,45,99,133,231,44,217,206,217,217,212,158,140,47,136,212,242,86,44,127,148,111,155,110,164,100,223,38,78,46,178,220,160,215,184,60,235,121,164,78,31,105,70,61,221,236,0,218,224,24,9,166,175,10,253,129,230,253,211,161,211,159,239,134,168,168,196,233,8,24,177,163,87,225,128,221,218,178,89,246,128,13,148,231,34,20,133,128,99,68,60,242,66,168,9,86,193,105,174,52,239,213,78,213,211,91,48,17,10,201,204,1,0],"hint":0},{"address":[242,37,88,246,85,93,169,252,5,52,11,123,218,151,112,135,0,247,104,25,76,86,112,105,251,221,139,55,25,74,146,140],"bytes":[208,9,0,148,23,0,23,0,23,176,23,177,32,1,132,7,0,7,0,7,176,7,177,113,17,115,32,3,19,18,16,2,113,32,0,16,114,32,2,18,17,4,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,161,35,96,69,20,10,194,171,190,21,41,88,52,132,52,251,132,73,101,150,249,252,93,203,189,88,91,129,116,196,57,39,178,136,217,224,36,44,255,41,120,139,158,183,34,54,222,165,15,112,144,89,71,169,35,37,231,162,123,37,240,169,206,134,234,19,119,4,22,131,84,128,64,102,33,157,192,155,47,160,234,144,126,86,252,192,64,164,178,197,109,13,129,29,118,93,1,0],"hint":0},{"address":[242,216,6,110,100,213,143,218,10,242,106,251,22,37,29,29,150,192,110,224,46,20,56,30,194,117,199,85,160,13,178,120],"bytes":[208,9,0,150,23,0,23,0,23,0,23,178,23,176,23,177,19,134,7,0,7,0,7,0,7,178,7,176,7,177,118,32,1,21,20,129,7,114,32,0,21,20,20,18,129,7,21,113,18,16,129,7,20,113,17,16,3,145,23,19,18,145,23,19,19,114,32,0,18,17,2,227,202,247,231,13,241,107,26,110,135,74,200,103,132,25,81,105,132,248,209,230,141,36,208,221,153,6,42,242,14,140,234,239,98,173,170,214,208,43,159,81,45,36,236,23,22,199,59,255,122,224,141,138,228,95,227,48,224,153,37,165,171,147,165,1,0],"hint":0},{"address":[244,188,42,158,142,38,142,179,82,247,25,101,125,136,6,176,114,165,85,162,159,46,184,94,114,128,95,221,201,205,1,145],"bytes":[212,0,0,207,236,5,209,215,242,81,47,101,119,194,246,26,132,5,35,128,76,54,212,4,60,37,42,180,186,37,8,237,231,81,113,0,0,0],"hint":0},{"address":[244,242,199,63,63,176,199,189,250,212,209,10,144,100,144,38,99,103,162,129,151,44,249,218,31,186,104,181,104,141,20,40],"bytes":[212,0,0,224,99,232,12,135,171,160,238,162,222,95,200,223,118,137,162,212,105,13,226,33,162,194,249,56,247,195,211,8,190,95,241,0,0,0],"hint":0},{"address":[246,25,208,107,19,247,55,49,65,93,17,97,8,159,153,218,218,152,134,191,80,154,29,245,43,83,22,113,2,200,108,114],"bytes":[208,1,0,146,23,176,23,176,0,130,7,176,7,176,114,32,2,113,32,1,17,16,1,32,0,3,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,143,112,180,160,174,152,116,193,51,244,179,211,36,51,17,25,136,171,75,61,193,164,122,107,230,246,195,65,167,219,176,175,1,0],"hint":2},{"address":[246,128,13,148,231,34,20,133,128,99,68,60,242,66,168,9,86,193,105,174,52,239,213,78,213,211,91,48,17,10,201,204],"bytes":[212,0,1,36,214,98,101,106,41,65,247,131,125,73,197,70,115,110,203,79,161,94,171,159,108,160,154,175,27,191,200,18,146,227,129,0,0,0],"hint":0},{"address":[247,154,238,65,62,228,123,177,250,111,32,39,251,4,239,21,151,135,26,64,134,212,33,124,255,73,19,250,29,106,224,186],"bytes":[208,1,1,148,23,0,23,1,23,17,23,176,18,132,7,0,7,1,7,17,7,176,114,33,2,1,129,7,32,1,19,113,16,17,1,113,32,0,18,3,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,161,35,96,69,20,10,194,171,190,21,41,88,52,132,52,251,132,73,101,150,249,252,93,203,189,88,91,129,116,196,57,39,173,222,136,82,148,149,48,176,245,99,105,176,229,62,34,58,189,47,35,165,88,51,189,253,153,65,4,189,230,104,106,233,2,0,192],"hint":3},{"address":[248,28,25,95,83,35,31,11,61,143,111,208,136,195,72,14,249,171,205,195,91,196,66,224,118,62,46,129,151,174,129,48],"bytes":[208,1,0,113,33,1,0,32,2,32,0,0,3,100,244,51,228,9,216,44,53,225,232,196,102,144,99,39,128,69,176,228,211,159,96,133,187,118,108,207,5,242,137,6,241,126,8,30,243,213,142,60,213,171,66,50,211,216,144,184,115,186,113,80,205,98,137,50,70,133,87,62,251,71,244,135,32,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,1,1,0],"hint":4},{"address":[248,41,160,86,223,94,139,143,176,58,204,29,255,112,53,60,232,132,245,171,188,151,54,74,119,70,134,200,189,218,172,108],"bytes":[208,1,0,146,23,177,23,176,177,130,7,177,7,176,116,33,1,1,130,7,177,7,176,177,17,16,130,7,113,33,0,0,176,7,176,113,32,5,115,33,4,0,176,17,16,2,32,2,32,3,6,55,29,38,88,218,150,252,157,177,26,21,63,193,156,198,191,199,146,188,252,190,78,141,234,34,46,212,221,41,186,89,205,58,236,205,2,58,251,8,54,114,70,20,83,101,26,139,56,25,138,160,207,142,51,135,194,251,159,62,139,56,116,159,169,98,178,194,235,79,232,199,133,128,191,119,139,254,148,198,236,44,203,37,211,8,54,159,192,13,135,184,133,238,190,83,72,154,222,24,249,71,95,80,187,218,209,195,211,226,6,199,177,22,169,133,38,75,236,35,35,223,17,81,230,198,53,60,5,180,138,104,40,213,143,58,113,85,119,191,168,43,72,232,169,3,135,3,45,81,163,8,95,189,158,171,226,218,71,30,21,252,82,100,111,177,136,75,195,148,65,19,16,182,120,92,58,241,175,36,162,134,0,106,248,159,179,39,233,159,151,170,22,2,0,1,0],"hint":4},{"address":[248,113,220,56,84,110,35,226,251,163,213,50,63,253,122,23,6,235,47,55,54,75,11,33,3,232,69,100,172,113,4,244],"bytes":[214,0,184,39,20,179,119,30,235,147,197,241,135,113,227,142,204,109,35,239,80,101,157,11,196,76,234,12,232,215,49,5,85,250,0,0,0],"hint":0},{"address":[250,190,14,155,156,117,8,105,164,20,71,81,111,7,119,122,234,196,184,98,30,244,151,45,8,81,187,250,131,95,189,101],"bytes":[208,9,0,147,23,176,23,176,23,115,177,32,3,17,113,32,2,16,115,177,32,4,18,17,130,7,176,7,176,114,32,5,17,16,2,32,1,113,33,0,0,176,6,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,203,25,12,135,55,153,142,229,237,179,192,141,117,153,193,28,227,133,128,179,67,126,248,21,191,253,241,166,125,16,152,205,1,0],"hint":0},{"address":[250,218,246,185,13,90,225,102,11,48,47,89,65,202,55,215,222,207,92,54,177,71,74,196,221,217,165,237,206,111,158,11],"bytes":[208,1,0,148,23,176,23,176,23,184,0,23,181,113,180,114,178,19,18,132,7,176,7,176,7,184,0,7,181,119,32,7,19,130,7,176,7,182,145,23,113,183,17,113,180,114,178,22,18,18,16,130,7,113,180,19,7,114,177,129,7,176,145,23,113,180,21,113,180,114,178,22,17,32,16,113,32,11,179,131,7,176,7,182,7,113,183,113,32,4,17,116,32,12,114,32,5,22,18,22,113,64,8,16,17,17,17,9,32,3,33,9,0,116,35,1,0,0,0,176,176,176,115,34,15,0,0,176,176,114,33,6,0,176,32,17,115,33,13,0,176,98,113,32,14,98,115,33,0,0,176,32,10,179,113,180,18,113,180,20,113,177,129,7,176,145,23,113,180,22,113,180,114,178,23,17,114,177,129,7,176,145,23,181,113,180,114,178,19,17,16,18,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,91,170,240,92,150,157,44,243,119,49,33,17,190,81,187,100,198,0,193,63,161,100,238,114,46,146,36,59,15,119,27,171,97,77,217,229,201,188,180,126,143,59,37,173,22,90,151,122,31,61,199,114,50,70,93,227,182,142,40,95,119,199,135,53,115,212,178,99,138,214,188,141,223,68,211,170,230,99,3,57,95,70,25,85,25,55,98,216,54,179,90,48,113,121,249,251,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,175,9,117,110,177,82,121,33,25,161,227,86,120,130,27,112,231,216,72,81,58,119,85,17,146,183,109,115,45,61,236,133,189,116,117,144,194,169,51,23,167,254,237,136,194,69,103,236,153,25,211,140,54,87,202,77,87,29,15,149,109,41,223,113,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,209,175,140,47,93,246,86,19,16,237,169,150,109,112,205,159,81,104,143,0,40,10,227,135,239,113,101,70,169,212,21,251,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,254,77,94,53,147,241,44,126,254,17,58,115,217,127,219,138,235,250,120,184,27,185,29,195,210,9,55,161,132,15,154,69,1,0],"hint":4294967295},{"address":[250,222,45,191,177,215,247,124,48,194,71,213,45,241,40,191,81,110,237,206,1,248,23,211,99,206,136,218,19,207,172,43],"bytes":[208,1,0,146,23,176,23,177,176,130,7,176,7,177,114,32,4,118,35,0,0,0,0,176,176,176,115,34,9,0,0,176,176,114,33,2,0,176,32,10,115,33,7,0,176,101,113,32,8,101,17,114,32,6,17,16,2,32,1,113,32,3,16,11,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,97,77,217,229,201,188,180,126,143,59,37,173,22,90,151,122,31,61,199,114,50,70,93,227,182,142,40,95,119,199,135,53,144,2,42,228,197,213,42,210,138,205,128,5,29,212,31,39,245,28,156,74,251,171,27,179,145,119,60,25,239,13,193,233,146,75,13,234,223,73,92,90,18,161,36,151,251,180,100,187,34,242,192,180,142,201,165,85,185,172,181,141,39,237,203,46,171,19,190,223,66,232,75,174,15,124,98,199,221,106,138,218,87,30,136,41,190,214,234,85,130,23,240,54,27,94,37,208,200,25,111,139,173,4,113,17,180,147,46,124,84,80,253,40,19,60,115,182,116,170,192,128,210,86,136,151,205,182,174,94,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,209,175,140,47,93,246,86,19,16,237,169,150,109,112,205,159,81,104,143,0,40,10,227,135,239,113,101,70,169,212,21,251,254,77,94,53,147,241,44,126,254,17,58,115,217,127,219,138,235,250,120,184,27,185,29,195,210,9,55,161,132,15,154,69,1,0],"hint":6},{"address":[251,3,245,167,225,65,216,64,37,179,165,3,222,220,83,206,134,242,151,189,227,107,188,27,152,104,122,234,180,53,153,104],"bytes":[209,1,2,2,1,1,1,150,23,1,23,16,23,178,23,177,23,19,23,115,176,20,19,16,114,19,17,16,1,0,132,7,1,7,16,7,178,7,177,16,3,33,0,1,114,16,17,114,33,1,1,18,17,146,23,17,23,115,176,18,17,16,0,2,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,212,148,220,96,19,134,186,142,143,11,113,31,230,42,45,96,171,96,198,72,140,140,246,206,151,121,110,188,58,213,254,251,2,192,193],"hint":0},{"address":[251,123,94,98,97,36,207,110,50,255,172,240,28,176,159,60,222,84,163,60,149,219,95,212,138,134,185,17,5,244,201,47],"bytes":[209,0,0,2,2,1,2,152,0,23,176,23,181,23,182,23,180,23,184,0,23,176,23,184,1,23,184,2,113,183,16,2,0,133,7,176,7,181,7,182,7,180,7,184,0,17,4,136,1,7,176,7,181,7,182,7,180,7,184,0,7,176,7,184,1,7,184,2,7,114,22,18,17,117,20,19,18,17,16,120,0,48,0,178,23,22,21,20,19,18,17,11,32,0,32,2,24,0,32,5,115,16,18,113,32,6,18,114,32,4,18,17,146,23,176,23,114,177,17,16,0,147,23,176,23,114,177,18,16,23,116,179,19,18,17,16,0,114,21,18,17,149,23,176,23,114,177,20,16,23,116,179,21,20,17,16,23,183,23,115,21,19,18,17,115,22,113,32,1,20,115,32,3,178,20,19,118,32,7,178,23,20,19,18,17,114,177,21,16,116,179,22,21,17,16,8,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,143,112,180,160,174,152,116,193,51,244,179,211,36,51,17,25,136,171,75,61,193,164,122,107,230,246,195,65,167,219,176,175,187,67,180,68,88,106,58,237,43,170,13,123,116,49,202,109,205,20,171,148,68,188,119,146,13,19,67,51,208,191,229,116,212,242,86,44,127,148,111,155,110,164,100,223,38,78,46,178,220,160,215,184,60,235,121,164,78,31,105,70,61,221,236,0,218,224,24,9,166,175,10,253,129,230,253,211,161,211,159,239,134,168,168,196,233,8,24,177,163,87,225,128,221,218,178,89,244,242,199,63,63,176,199,189,250,212,209,10,144,100,144,38,99,103,162,129,151,44,249,218,31,186,104,181,104,141,20,40,246,128,13,148,231,34,20,133,128,99,68,60,242,66,168,9,86,193,105,174,52,239,213,78,213,211,91,48,17,10,201,204,1,0],"hint":0},{"address":[252,82,100,111,177,136,75,195,148,65,19,16,182,120,92,58,241,175,36,162,134,0,106,248,159,179,39,233,159,151,170,22],"bytes":[212,0,0,158,141,30,140,34,168,155,208,25,144,208,145,224,167,157,236,196,179,183,215,104,244,33,193,200,174,159,203,18,7,155,97,0,0,0],"hint":0},{"address":[252,85,51,60,220,225,188,4,62,134,112,198,177,143,196,86,113,186,141,34,250,32,69,166,162,221,84,197,244,100,84,99],"bytes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hint":0},{"address":[253,28,62,122,65,53,75,163,172,98,77,234,69,37,114,204,91,7,129,94,255,156,225,255,127,60,82,197,17,103,175,80],"bytes":[208,9,0,149,23,176,23,176,23,176,23,115,177,32,4,18,17,23,115,177,32,5,18,17,115,177,32,4,20,18,131,7,176,7,176,7,176,115,32,0,113,32,3,18,17,16,2,32,2,113,33,1,0,176,6,1,52,162,6,154,222,214,241,18,20,204,33,47,37,177,194,163,224,207,41,103,92,148,75,153,178,28,90,2,159,76,39,6,28,38,88,199,106,104,217,9,120,133,152,36,153,59,187,225,93,191,155,153,104,97,147,37,66,14,124,131,155,5,199,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,173,10,219,236,225,128,43,251,173,234,148,198,57,88,22,243,137,10,196,160,207,169,144,70,14,166,178,170,135,45,216,214,185,199,100,8,219,24,235,118,170,131,23,247,179,160,116,171,122,63,161,12,159,132,212,13,114,177,213,214,31,40,87,65,1,0],"hint":0},{"address":[253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167],"bytes":[208,1,1,147,23,177,23,176,23,178,113,18,17,131,7,177,7,176,7,178,64,2,115,33,1,0,18,17,16,3,32,0,145,23,176,0,146,23,176,23,114,33,3,0,18,16,113,19,17,4,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,89,117,65,203,125,21,21,222,134,24,232,171,127,127,126,15,79,86,147,207,179,234,107,227,221,28,177,253,136,145,230,98,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,1,192],"hint":4294967295},{"address":[254,77,94,53,147,241,44,126,254,17,58,115,217,127,219,138,235,250,120,184,27,185,29,195,210,9,55,161,132,15,154,69],"bytes":[208,1,0,113,33,0,0,32,2,114,33,1,0,32,2,32,3,0,4,23,28,138,233,37,6,143,6,176,45,1,57,84,157,86,128,52,221,140,123,97,223,123,219,80,48,211,53,10,54,119,118,38,5,219,172,27,194,105,86,16,103,79,203,209,251,125,25,3,153,197,126,133,74,51,92,106,129,243,119,122,174,236,3,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,91,170,240,92,150,157,44,243,119,49,33,17,190,81,187,100,198,0,193,63,161,100,238,114,46,146,36,59,15,119,27,171,1,0],"hint":5},{"address":[254,79,58,139,185,184,145,29,160,23,169,108,155,21,32,138,186,117,189,255,121,82,200,110,154,172,157,3,23,76,84,114],"bytes":[208,1,0,146,23,176,23,179,177,131,7,176,7,179,7,176,118,33,3,0,130,7,176,7,176,145,23,179,176,16,18,130,7,176,7,113,178,32,5,17,131,7,176,7,176,7,113,178,113,32,1,16,113,32,1,113,64,2,16,18,17,4,32,0,145,23,176,176,113,33,4,0,129,7,176,177,113,178,16,6,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,144,202,91,207,153,93,104,215,223,203,60,124,254,70,105,134,220,75,234,164,2,178,98,202,57,91,62,83,195,111,108,173,145,65,192,84,248,91,138,184,197,158,129,191,208,155,167,57,240,160,186,252,228,177,132,110,187,26,51,229,20,40,97,102,161,125,169,10,132,125,146,232,2,77,152,15,21,33,1,163,238,143,32,150,186,166,117,221,198,203,105,115,43,45,30,188,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,1,1,0],"hint":4294967295},{"address":[254,151,194,209,128,155,98,73,123,114,24,233,54,53,80,136,220,22,237,127,20,28,103,136,201,83,126,133,111,54,178,226],"bytes":[208,1,1,148,23,177,23,176,23,179,23,178,113,19,18,132,7,177,7,176,7,179,7,178,116,33,5,1,129,7,176,113,20,16,18,113,17,32,3,129,7,176,113,17,16,4,32,1,145,23,176,1,145,23,176,113,19,113,32,2,16,145,23,32,4,113,18,115,33,6,0,176,96,113,32,7,96,8,45,58,222,223,241,27,97,241,76,136,110,53,175,160,54,115,109,205,135,167,77,39,181,193,81,2,37,208,245,146,226,19,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,120,192,56,5,248,234,247,211,103,224,245,121,9,171,213,102,217,74,43,235,207,98,112,254,47,231,74,249,84,237,13,0,146,50,73,134,103,247,101,244,55,222,218,172,130,142,85,95,108,198,122,32,230,219,40,246,20,253,243,194,98,113,15,235,147,115,116,237,9,184,182,47,54,239,117,240,111,30,228,109,212,135,199,169,243,231,77,185,25,189,228,139,183,107,44,198,203,132,191,250,109,112,146,163,9,99,2,20,175,41,217,236,78,53,205,94,0,3,235,156,223,117,238,72,78,36,146,91,206,13,10,44,84,49,114,91,64,42,207,250,119,144,4,61,197,11,142,105,170,208,72,97,99,111,183,89,220,39,237,104,2,0,192],"hint":4294967295},{"address":[255,53,45,34,4,221,221,232,92,181,199,177,120,224,147,215,13,109,75,176,104,182,165,230,62,138,27,117,112,112,44,164],"bytes":[208,9,1,149,23,2,23,179,23,17,23,18,23,180,113,181,114,32,6,177,178,133,7,2,7,179,7,17,7,18,7,180,118,34,9,0,1,176,177,130,7,176,7,115,33,5,1,176,113,20,19,16,113,181,114,32,6,113,21,20,17,113,32,2,177,178,118,34,0,2,1,20,176,18,17,19,16,6,32,1,113,19,18,113,19,17,145,23,16,176,115,33,5,2,19,17,16,115,33,4,1,129,7,32,8,0,32,3,32,7,10,5,199,182,224,138,234,68,58,149,61,8,60,30,231,110,202,98,58,85,180,216,170,221,68,152,250,235,100,244,23,155,77,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,78,220,8,226,238,119,236,166,207,247,218,76,93,236,68,144,114,114,234,148,60,220,39,239,145,229,191,202,76,6,185,233,161,35,96,69,20,10,194,171,190,21,41,88,52,132,52,251,132,73,101,150,249,252,93,203,189,88,91,129,116,196,57,39,176,177,13,178,135,1,45,21,180,105,78,118,183,137,193,46,197,228,30,252,157,184,166,99,207,215,84,191,47,196,151,23,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,211,216,255,146,74,249,220,75,92,216,105,118,6,21,179,231,238,128,145,107,182,23,37,157,69,137,12,105,244,18,131,55,227,90,177,115,88,250,231,168,30,251,61,148,161,100,253,63,133,171,139,12,136,138,170,7,28,254,13,96,255,188,28,172,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,251,3,245,167,225,65,216,64,37,179,165,3,222,220,83,206,134,242,151,189,227,107,188,27,152,104,122,234,180,53,153,104,3,0,1,0,192],"hint":0},{"address":[255,131,252,50,174,0,106,5,53,100,74,163,253,112,17,187,161,157,183,70,104,173,84,222,26,223,166,137,22,238,221,157],"bytes":[208,1,2,148,23,0,23,1,23,179,23,177,178,132,7,0,7,1,7,179,7,177,114,33,2,3,18,116,34,0,2,3,19,178,17,16,4,33,1,3,113,33,1,2,18,113,176,18,145,23,17,113,176,17,3,65,188,63,178,244,166,74,106,62,247,138,202,224,206,102,205,147,127,93,159,216,146,147,221,99,196,59,134,246,196,197,121,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,183,95,121,122,109,184,29,231,39,112,126,223,246,41,188,189,29,78,27,235,246,29,151,28,39,137,210,18,77,223,70,205,4,1,192,1,193,192,193],"hint":4}],"format":"ixon-v4","invalidProof":{"address":[182,79,166,131,2,33,137,136,172,10,163,13,100,64,124,158,148,182,228,17,81,222,72,127,226,107,137,103,217,58,185,192],"bytes":[208,9,0,146,23,176,23,176,114,177,180,179,146,23,176,23,176,114,177,180,179,5,32,2,113,33,5,1,176,116,35,1,0,0,0,176,176,176,114,33,0,0,176,32,4,114,178,16,17,114,178,17,16,7,12,68,241,215,132,187,26,179,28,58,250,165,135,107,185,37,249,5,154,11,159,163,31,86,105,0,109,220,94,174,241,27,38,58,123,56,136,39,35,3,128,243,118,204,133,193,22,45,159,216,143,199,217,113,124,206,151,95,194,52,194,106,97,197,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,171,86,63,240,46,251,37,48,15,56,153,144,152,68,247,124,161,223,172,36,69,161,227,60,11,225,151,243,109,101,52,215,172,236,141,84,253,42,149,116,121,227,42,148,233,109,150,37,96,48,59,90,31,4,119,124,236,230,174,65,170,201,238,120,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,253,133,173,38,39,25,216,58,18,252,29,149,14,156,186,181,161,94,221,241,83,236,56,219,205,95,197,7,33,105,39,167,2,0,1,0],"hint":0},"name":"Nat.add_comm","roles":[{"address":[31,85,77,180,29,45,45,119,193,226,45,253,219,204,179,132,203,39,130,190,29,192,214,122,139,43,225,95,211,158,62,114],"bytes":[232,3,3,103,0,53,225,204,128,159,111,7,101,33,164,63,133,6,141,85,146,34,4,7,192,83,43,106,8,149,47,64,216,82,61,4,188,1,238,178,230,38,143,246,208,230,178,233,118,77,153,64,184,27,182,75,159,143,75,19,88,210,148,255,152,23,230,148,26,70,2,66,214,237,49,83,111,9,88,23,111,29,201,115,56,56,8,172,133,131,34,55,70,235,202,120,219,227,137,182,83,33,166,3,200,50,46,3,213,88,248,90,142,220,127,230,133,36,1,56,128,173,11,188,183,220,137,1,54,210,71,21,75,35,9,146,4,230,235,163,200,180,209,159,106,16,118,179,159,168,154,236,97,220,203,185,96,248,61,154,98,230,172,243,90,105,201,160,164,5,221,161,43,203,51,7,39,246,223,184,22,188,151,82,170,189,5,32,230,81,91,121,252,138,90,158,113,56,102,244,198,62,6,162,154,99,97,118,207,17,53,208,119,235,7,71,152,249,0,124,120,231,128,19,131,233,207,243,99,186,229,237,240,87,98,7,176,177,13,178,135,1,45,21,180,105,78,118,183,137,193,46,197,228,30,252,157,184,166,99,207,215,84,191,47,196,151,23,8,195,125,98,144,224,15,184,101,251,93,183,188,225,143,214,158,109,22,116,173,87,55,36,184,84,102,234,159,117,120,162,7,9,212,148,220,96,19,134,186,142,143,11,113,31,230,42,45,96,171,96,198,72,140,140,246,206,151,121,110,188,58,213,254,251,10,251,3,245,167,225,65,216,64,37,179,165,3,222,220,83,206,134,242,151,189,227,107,188,27,152,104,122,234,180,53,153,104,11,45,252,22,175,1,184,43,59,145,194,255,112,68,9,215,98,54,168,63,149,108,12,110,102,89,166,79,226,29,118,105,91,12,221,146,133,172,69,212,172,133,209,127,160,211,36,61,121,9,199,130,162,162,118,238,63,176,207,254,250,154,251,219,13,225,13,45,239,140,157,194,47,98,228,63,15,124,89,54,226,65,141,71,110,15,203,188,171,120,14,241,205,166,66,161,91,244,95,14,10,197,6,186,115,77,24,9,99,88,68,137,40,42,28,192,71,193,75,4,233,197,99,78,116,29,4,179,120,10,184,42,15,222,130,168,50,138,114,194,195,114,127,183,21,206,44,200,30,53,131,216,58,113,231,240,208,37,15,83,24,249,255,128,30,16,161,35,96,69,20,10,194,171,190,21,41,88,52,132,52,251,132,73,101,150,249,252,93,203,189,88,91,129,116,196,57,39,17,173,222,136,82,148,149,48,176,245,99,105,176,229,62,34,58,189,47,35,165,88,51,189,253,153,65,4,189,230,104,106,233,18,227,90,177,115,88,250,231,168,30,251,61,148,161,100,253,63,133,171,139,12,136,138,170,7,28,254,13,96,255,188,28,172,19,244,188,42,158,142,38,142,179,82,247,25,101,125,136,6,176,114,165,85,162,159,46,184,94,114,128,95,221,201,205,1,145,20,178,136,217,224,36,44,255,41,120,139,158,183,34,54,222,165,15,112,144,89,71,169,35,37,231,162,123,37,240,169,206,134,21,207,50,3,156,237,177,155,180,170,133,230,150,209,37,133,187,7,146,233,229,90,111,207,83,182,187,14,36,246,25,140,200,22,206,132,74,194,167,233,78,205,162,196,86,241,67,246,254,224,237,161,145,66,23,119,225,159,210,158,242,8,34,241,245,187,23,4,85,218,131,44,103,248,65,211,11,41,154,121,230,147,243,67,171,240,221,191,71,28,74,190,118,3,123,44,91,121,182,24,105,74,25,54,31,11,202,32,237,40,82,128,126,107,62,184,50,42,250,114,122,103,129,249,233,248,117,134,158,20,182,159,25,46,41,129,157,27,1,141,151,208,52,226,193,8,254,90,91,165,162,86,175,239,34,135,196,219,30,33,109,226,252,95,80,26,94,122,206,208,94,249,217,170,224,61,36,210,33,186,138,30,212,67,9,216,221,41,1,121,246,79,117,163,16,252,1,226,27,77,55,11,128,69,65,220,32,110,209,14,209,241,189,246,210,78,52,147,135,148,200,165,81,241,138,238,108,119,54,110,2,28,210,147,223,197,228,102,190,22,146,183,91,197,247,123,98,188,141,130,51,20,232,181,20,244,214,22,137,137,168,105,155,92,29,79,182,180,28,48,83,46,106,180,172,180,238,254,1,218,19,20,238,127,33,41,175,137,137,253,99,247,236,39,122,175,1,30,57,148,188,81,227,104,111,48,161,212,131,214,157,10,131,90,123,72,77,137,35,147,192,132,248,122,88,73,222,84,243,2,31,179,167,216,2,73,253,130,49,0,238,3,98,98,50,209,65,42,14,131,53,39,93,93,245,59,146,148,56,135,182,80,247,32,69,4,11,49,38,133,81,105,218,217,25,169,112,169,199,44,238,88,117,101,138,237,179,189,31,137,252,223,140,136,237,250,33,129,22,0,223,165,159,54,18,203,3,192,240,71,90,241,82,57,157,239,255,146,38,198,225,159,214,72,4,26,104,153,169,34,134,179,101,231,91,180,35,15,4,198,228,243,167,202,105,136,173,245,116,97,109,121,163,215,71,122,214,92,172,16,33,16,35,23,69,73,28,13,101,29,224,190,165,137,213,255,251,201,188,77,127,190,137,124,29,128,91,31,127,89,202,150,150,166,239,36,155,40,116,231,84,217,149,219,141,39,134,143,129,0,235,77,153,192,124,194,200,191,208,153,187,30,41,134,208,166,120,74,37,34,22,37,160,14,226,214,185,98,151,227,77,126,5,191,126,79,211,141,141,153,211,225,214,74,124,210,224,108,160,117,45,38,69,220,179,197,229,173,163,188,12,165,45,98,166,111,127,157,218,53,7,223,113,6,26,92,32,10,222,160,207,36,16,20,39,6,95,200,180,19,147,245,37,193,229,65,185,212,188,151,194,12,19,191,35,167,32,154,32,147,182,244,82,115,48,17,74,40,207,248,117,145,79,63,139,79,0,20,209,234,162,35,198,185,218,114,1,35,155,197,151,110,20,11,105,217,156,209,243,87,41,50,68,104,115,1,215,121,236,117,114,116,118,29,144,61,239,62,179,19,81,119,50,123,112,155,203,216,84,239,73,111,121,42,62,138,173,204,97,28,77,134,119,202,223,0,199,133,6,86,29,51,115,142,227,213,113,247,164,25,110,38,5,128,201,184,43,3,179,160,65,40,91,15,226,2,217,11,34,125,64,92,76,236,37,45,241,139,167,97,106,205,109,174,39,146,230,114,187,44,55,59,125,116,246,180,13,161,27,126,215,150,3,164,94,199,1,26,136,49,183,32,181,125,46,254,146,232,42,61,87,240,45,91,170,240,92,150,157,44,243,119,49,33,17,190,81,187,100,198,0,193,63,161,100,238,114,46,146,36,59,15,119,27,171,46,211,216,255,146,74,249,220,75,92,216,105,118,6,21,179,231,238,128,145,107,182,23,37,157,69,137,12,105,244,18,131,55,47,158,68,91,157,95,130,82,119,35,71,135,46,144,155,93,180,231,236,167,8,108,237,244,254,198,222,132,15,107,123,95,146,48,130,77,28,83,216,193,195,207,10,39,242,70,57,236,43,225,236,193,61,74,1,201,147,23,21,149,237,204,246,148,151,55,49,17,171,191,152,100,129,197,58,33,200,203,33,238,37,129,174,98,56,174,219,236,21,249,114,149,157,8,107,239,26,25,133,50,171,169,75,251,65,53,29,77,179,97,114,195,121,165,18,240,66,25,239,33,220,84,84,215,21,144,150,125,78,143,145,63,51,222,140,16,12,34,248,42,92,53,51,198,126,67,112,103,24,19,67,74,111,236,93,2,57,152,222,208,144,223,74,73,52,52,147,175,193,205,41,140,99,96,110,95,70,141,30,89,137,171,70,128,210,86,233,93,7,168,100,42,136,181,198,184,88,225,53,119,221,64,215,182,202,49,12,197,148,102,209,242,77,244,241,128,239,80,225,176,15,216,80,105,132,88,205,38,144,28,93,54,5,187,101,126,139,157,93,194,36,231,239,61,83,229,65,83,206,58,194,109,168,209,241,177,214,16,105,163,114,101,102,205,55,37,1,159,244,133,252,245,112,149,151,205,30,7,252,195,206,121,103,118,239,63,113,90,109,24,126,181,131,28,99,180,190,56,32,156,150,81,22,72,208,148,89,1,151,1,246,225,0,84,9,50,10,113,10,60,253,24,149,229,103,33,52,22,30,52,57,207,163,147,100,168,124,117,97,174,65,229,9,57,21,233,124,204,237,32,197,144,126,247,246,124,2,172,112,41,66,60,64,58,22,187,161,161,175,172,127,247,4,139,169,147,222,62,54,159,65,95,240,241,56,126,65,138,116,232,187,148,11,37,137,148,59,240,190,240,85,240,59,74,166,195,155,121,129,129,252,105,255,94,50,19,81,92,184,222,211,74,47,22,246,162,62,164,95,60,54,61,7,17,130,190,65,78,26,88,89,155,131,245,225,159,155,135,55,35,5,79,66,135,186,105,112,90,175,239,39,218,61,140,192,225,54,12,27,41,16,141,171,61,97,114,231,252,232,169,170,150,64,218,164,187,233,155,161,48,93,150,35,98,75,62,3,97,140,79,182,202,233,231,64,202,25,152,208,232,99,134,0,200,194,93,22,156,150,218,228,225,187,70,201,168,178,122,63,189,126,156,133,211,91,76,24,214,150,13,138,113,122,195,143,126,189,202,41,203,121,52,143,191,203,242,104,221,95,44,216,64,198,131,251,215,184,178,252,197,235,9,255,94,22,249,164,167,111,12,93,4,205,93,141,242,61,180,151,2,213,89,123,195,65,17,21,123,195,137,143,6,227,230,242,202,131,65,30,253,13,67,184,132,107,87,210,246,8,142,24,243,68,125,220,59,40,66,143,112,180,160,174,152,116,193,51,244,179,211,36,51,17,25,136,171,75,61,193,164,122,107,230,246,195,65,167,219,176,175,67,241,222,113,3,128,46,188,83,9,4,27,218,173,234,74,101,101,45,84,175,55,230,106,170,244,23,135,177,216,145,149,87,68,123,182,89,135,102,113,224,61,7,49,196,86,232,148,206,158,111,125,232,37,10,180,174,112,17,61,192,142,36,83,33,39,69,175,88,107,7,84,110,31,202,154,176,120,13,28,35,106,248,211,96,196,198,187,50,187,12,208,62,201,202,99,211,218,150,70,198,12,149,227,205,191,78,208,16,217,153,179,39,127,78,31,211,105,94,140,48,38,8,118,16,41,5,215,179,98,65,162,71,10,153,244,156,199,58,185,244,39,131,9,46,113,32,97,50,37,103,11,171,137,185,214,53,51,209,173,239,200,118,24,47,72,247,19,13,88,100,225,186,119,176,246,167,51,143,146,21,156,53,189,81,71,224,254,188,241,235,237,69,110,81,53,56,204,73,154,55,32,189,208,239,234,136,197,101,199,4,192,14,153,181,214,97,106,117,161,182,126,75,228,123,18,167,116,4,94,50,74,249,8,242,153,23,162,188,22,223,133,139,172,49,25,38,180,199,92,162,6,35,146,149,191,65,249,153,198,227,41,74,239,75,25,200,118,73,249,161,120,9,242,72,190,255,123,195,127,86,159,84,142,36,169,141,138,124,221,213,184,46,184,8,229,166,76,182,102,146,91,16,71,63,190,26,118,48,236,73,111,224,125,121,156,82,72,102,125,177,226,48,47,202,95,228,197,12,182,77,124,96,4,61,96,22,226,240,239,93,118,78,26,183,146,57,104,212,61,92,56,129,134,221,246,200,60,40,240,36,1,122,78,157,255,148,158,77,2,130,57,50,19,4,42,54,166,154,244,183,26,88,112,144,150,234,163,222,81,48,186,224,175,132,243,79,1,231,199,36,80,136,151,224,30,93,11,143,114,226,207,162,96,124,234,95,240,211,82,208,8,208,231,81,42,171,47,70,80,83,228,4,245,221,60,83,105,59,195,181,191,174,88,43,4,150,236,60,5,175,12,238,10,70,195,138,182,98,197,127,223,81,19,201,126,132,251,138,195,238,129,32,233,35,214,31,202,111,126,107,185,36,30,195,170,93,53,155,165,220,229,66,170,17,82,162,137,88,215,71,232,123,90,96,228,250,7,239,126,216,217,73,246,154,220,188,68,175,226,149,132,130,211,238,155,51,101,83,144,2,42,228,197,213,42,210,138,205,128,5,29,212,31,39,245,28,156,74,251,171,27,179,145,119,60,25,239,13,193,233,84,103,22,11,151,103,147,6,210,130,4,69,56,58,109,116,14,111,233,131,156,37,69,234,72,104,15,242,167,123,11,233,134,85,250,222,45,191,177,215,247,124,48,194,71,213,45,241,40,191,81,110,237,206,1,248,23,211,99,206,136,218,19,207,172,43,86,47,156,156,54,144,69,3,109,154,53,255,123,56,40,93,202,59,151,100,38,200,26,143,54,111,206,17,97,176,144,214,13,87,218,123,179,49,224,152,249,191,92,218,188,185,96,154,126,149,61,255,198,9,173,157,144,135,26,20,192,22,197,42,48,17,88,154,222,24,249,71,95,80,187,218,209,195,211,226,6,199,177,22,169,133,38,75,236,35,35,223,17,81,230,198,53,60,5,89,77,166,97,145,122,88,21,47,92,169,116,210,37,109,152,239,169,215,34,196,241,99,130,233,205,240,22,223,76,87,67,104,90,222,1,48,36,197,152,229,240,195,220,208,103,245,6,225,210,227,39,73,87,53,34,172,181,57,182,20,0,98,124,248,151,91,187,148,217,249,71,91,161,65,160,55,221,219,198,101,233,7,80,107,135,191,199,38,125,158,15,126,193,115,162,23,9,223,92,14,174,105,243,248,177,152,209,255,172,103,185,232,141,57,82,107,27,3,159,245,25,205,135,238,193,6,246,57,116,134,12,93,113,116,99,130,92,85,39,2,186,25,8,185,250,93,143,63,119,134,215,115,12,99,62,65,216,211,128,147,159,238,183,72,94,150,187,62,182,53,39,188,227,166,159,224,129,58,19,30,71,66,201,45,149,96,53,183,63,171,46,118,166,203,149,199,198,95,53,169,237,114,2,227,196,56,87,205,196,6,62,172,18,63,231,183,127,6,49,21,74,197,64,219,162,201,151,189,242,36,96,23,16,3,74,81,127,36,159,92,130,101,232,226,120,59,230,6,25,240,200,232,95,78,171,98,94,133,152,58,189,114,46,97,83,24,135,122,230,30,29,163,121,128,216,12,17,227,228,122,54,216,80,195,228,62,153,113,97,34,241,230,239,240,30,159,98,208,56,13,201,182,58,254,235,50,53,167,122,222,179,85,168,181,43,7,48,151,21,149,9,55,65,236,44,109,87,205,73,99,32,154,202,98,204,31,157,210,192,169,40,205,132,215,43,180,21,112,170,151,193,253,131,62,95,255,197,103,193,198,64,31,100,135,19,251,145,68,31,63,147,234,120,109,196,207,183,6,76,215,142,169,64,244,124,79,137,238,157,186,158,97,100,209,70,101,76,8,104,38,204,103,157,243,182,170,87,162,159,61,9,58,138,146,208,222,78,222,206,244,106,144,141,131,152,115,61,192,102,106,71,212,192,42,123,208,150,50,52,136,241,193,21,8,31,176,223,232,252,150,81,117,29,224,46,0,202,110,10,104,241,44,41,2,0,0,42,2,0,0,43,2,0,0,44,2,0,0,45,2,0,0,46,4,0,0,0,0,47,3,0,0,0,48,3,1,28,65,127,125,175,40,244,7,193,63,109,207,169,215,3,175,94,137,213,18,244,113,96,41,109,152,231,183,146,243,255,176,1,72,181,207,25,254,220,74,180,248,189,149,196,75,60,67,78,167,220,89,126,219,120,101,174,226,67,227,167,212,228,154,224,1,8,178,93,220,90,45,247,245,81,187,130,136,98,152,115,54,104,56,27,212,227,49,205,199,25,173,228,241,220,68,121,200,49,3,1,111,45,168,3,126,61,254,171,20,198,135,204,25,51,135,92,114,29,182,61,108,178,54,20,223,201,181,43,8,75,84,187,1,254,222,166,70,210,60,229,49,124,72,123,31,130,234,176,235,149,118,18,253,71,234,136,41,117,236,87,155,211,160,107,194,1,125,114,23,73,211,172,78,216,236,215,192,200,83,182,119,227,39,109,179,76,238,4,96,79,241,18,14,52,218,162,16,221,50,2,1,80,193,242,220,8,183,133,182,141,247,97,128,239,150,103,155,22,251,136,6,171,218,81,76,62,110,77,226,36,66,204,28,1,66,25,247,250,155,94,251,131,240,69,179,245,170,111,127,150,235,86,33,250,6,132,4,52,36,165,166,25,198,16,201,211,51,2,1,213,35,227,160,40,255,95,57,113,33,44,114,70,132,37,209,51,249,132,169,194,144,13,6,119,173,120,26,121,191,192,37,1,46,138,23,144,5,39,13,157,236,155,212,84,203,97,123,71,198,14,225,121,131,170,236,220,130,227,178,191,213,180,10,90,52,2,1,121,125,214,224,175,108,206,101,133,199,252,196,128,83,52,34,255,39,254,189,225,217,84,69,4,239,95,237,142,97,109,172,1,70,131,195,89,109,254,57,55,226,52,171,17,123,207,208,75,25,51,117,56,55,152,34,129,151,11,223,32,151,8,12,72,53,2,1,105,128,231,193,156,232,170,39,115,18,64,72,162,48,180,215,120,141,34,140,212,83,210,10,51,28,151,28,115,177,108,43,1,29,57,228,37,48,194,180,154,218,22,110,121,14,139,106,180,172,168,246,249,106,128,52,125,41,40,30,221,138,60,28,197,54,2,1,138,188,165,205,229,101,19,213,126,186,240,242,108,237,204,12,229,235,27,228,190,144,46,142,118,69,215,83,120,7,58,177,1,246,231,185,130,123,43,118,233,131,108,228,213,189,149,129,50,7,96,127,26,34,211,28,150,28,211,134,17,14,83,240,54,55,2,1,163,233,12,187,73,122,136,74,144,111,252,153,168,48,249,76,25,241,127,18,35,225,79,214,94,91,22,52,186,116,10,96,1,53,26,186,227,22,197,29,40,15,118,202,93,124,219,176,146,56,51,134,22,219,209,8,93,11,207,194,89,30,228,42,212,65,3,0,0,1,137,0,34,248,76,153,37,185,233,230,69,250,33,99,168,63,206,68,194,159,226,131,27,155,110,221,189,160,201,21,89,251,67,1,1,15,23,152,80,2,212,218,133,202,216,195,66,128,168,195,225,216,29,25,154,157,181,249,199,181,38,172,120,117,80,51,114,68,1,1,223,92,183,43,165,119,213,145,145,184,20,104,178,20,180,212,62,116,199,135,102,158,48,140,132,212,118,120,44,231,17,59,69,1,0,73,2,0,0,74,2,1,74,82,212,166,140,70,200,159,178,225,1,154,2,149,18,242,113,22,39,123,201,63,197,131,187,79,9,238,241,205,133,136,1,217,162,50,69,97,65,204,182,206,175,199,52,210,230,85,81,57,27,106,216,24,8,126,218,135,147,93,249,161,179,135,204,75,2,0,0,76,4,0,0,0,0,77,1,0,78,4,0,0,0,0,79,2,0,0,80,5,0,0,0,0,0,81,4,0,0,0,0,82,3,0,1,254,237,99,245,7,2,108,199,63,228,90,41,251,132,25,17,41,74,64,49,66,96,62,145,87,205,121,203,183,94,208,196,1,82,233,208,35,141,167,150,238,215,1,198,121,85,226,218,226,27,177,234,66,112,244,253,185,20,70,163,211,182,168,171,153,85,1,0,86,1,1,174,133,99,70,25,254,44,154,235,71,83,133,69,40,147,174,200,197,140,241,196,242,4,249,207,224,239,108,130,157,239,27,87,1,1,153,126,193,36,123,103,150,113,174,182,26,32,66,43,70,140,76,15,93,182,67,48,221,214,18,86,3,38,184,132,22,140,90,1,0,91,2,0,0,92,1,1,122,62,217,3,72,111,47,182,152,89,113,111,67,249,1,195,91,177,244,5,246,213,67,32,59,103,223,118,175,224,11,22,93,2,0,0,95,4,1,2,222,241,34,22,28,174,80,15,119,240,13,138,128,14,78,156,72,75,111,3,169,13,187,9,227,74,33,59,101,240,77,0,0,1,169,89,140,8,4,208,124,185,24,176,9,23,5,71,150,246,76,92,2,195,153,251,247,59,177,40,5,181,55,181,78,184,96,4,1,209,172,130,142,145,5,71,163,227,208,4,129,234,145,19,147,42,0,110,165,85,152,137,35,105,71,183,154,141,29,18,99,1,65,216,237,229,0,198,3,147,246,150,222,66,205,111,178,178,77,52,151,96,116,240,124,121,13,79,71,184,203,249,102,205,0,1,205,175,194,166,111,111,144,151,201,115,231,211,148,171,49,126,103,239,103,88,186,80,182,4,145,19,74,76,92,244,58,172,97,1,0,98,1,0,99,1,0,100,5,1,15,90,241,139,180,25,7,185,29,162,79,233,101,188,66,1,193,101,137,67,134,35,28,220,35,219,80,203,36,110,47,214,1,69,38,70,67,10,242,13,18,234,179,164,163,249,114,182,250,118,2,142,28,146,225,50,243,231,131,232,191,24,193,53,69,1,118,88,241,247,100,243,199,69,205,201,249,204,222,31,96,143,124,1,40,66,209,226,113,225,5,241,38,185,192,154,198,0,1,252,158,246,246,227,14,199,11,6,54,108,13,249,40,238,247,192,151,197,38,233,134,240,19,100,168,121,70,226,208,14,211,1,144,91,48,181,71,212,70,74,74,139,102,184,19,20,172,204,185,39,89,64,110,46,116,73,70,239,82,133,74,201,77,221,101,2,0,1,97,157,145,97,167,167,255,62,142,152,30,65,176,204,245,254,208,147,108,60,175,45,211,23,55,247,118,28,84,149,90,146,102,3,0,1,85,29,209,157,48,204,230,42,88,129,22,16,123,29,253,59,227,90,138,5,97,155,130,72,204,233,181,55,38,199,252,208,1,161,140,132,182,214,119,48,34,28,52,245,177,105,196,170,183,184,32,50,80,154,185,178,180,148,185,122,242,43,95,209,161],"hint":0}]} diff --git a/IxVM/lake-manifest.json b/IxVM/lake-manifest.json new file mode 100644 index 000000000..3c183adff --- /dev/null +++ b/IxVM/lake-manifest.json @@ -0,0 +1,103 @@ +{"version": "1.2.0", + "packagesDir": ".lake/packages", + "packages": + [{"type": "path", + "scope": "", + "name": "aiur", + "manifestFile": "lake-manifest.json", + "inherited": false, + "dir": "../Aiur", + "configFile": "lakefile.lean"}, + {"url": "https://github.com/leanprover-community/mathlib4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "name": "mathlib", + "manifestFile": "lake-manifest.json", + "inputRev": "v4.34.1", + "inherited": true, + "configFile": "lakefile.lean"}, + {"url": "https://github.com/leanprover-community/plausible", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c", + "name": "plausible", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/LeanSearchClient", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707", + "name": "LeanSearchClient", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/import-graph", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "e928b72544873815af278d38681b31c0293588e3", + "name": "importGraph", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/ProofWidgets4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5", + "name": "proofwidgets", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.lean"}, + {"url": "https://github.com/leanprover-community/aesop", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "355695d523e41d0554926416cba2a2b3544fbbc9", + "name": "aesop", + "manifestFile": "lake-manifest.json", + "inputRev": "master", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/quote4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259", + "name": "Qq", + "manifestFile": "lake-manifest.json", + "inputRev": "master", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/batteries", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2", + "name": "batteries", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover/lean4-cli", + "type": "git", + "subDir": null, + "scope": "leanprover", + "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204", + "name": "Cli", + "manifestFile": "lake-manifest.json", + "inputRev": "v4.34.0", + "inherited": true, + "configFile": "lakefile.toml"}], + "name": "ixvm", + "lakeDir": ".lake", + "fixedToolchain": false} diff --git a/IxVM/lakefile.lean b/IxVM/lakefile.lean new file mode 100644 index 000000000..bbad09586 --- /dev/null +++ b/IxVM/lakefile.lean @@ -0,0 +1,14 @@ +import Lake +open System Lake DSL + +package ixvm where + version := v!"0.1.0" + +require aiur from "../Aiur" + +@[default_target] +lean_lib IxVM + +lean_exe ixvm where + root := `IxVM.Main + supportInterpreter := true diff --git a/IxVM/lean-toolchain b/IxVM/lean-toolchain new file mode 100644 index 000000000..ba8ebf2db --- /dev/null +++ b/IxVM/lean-toolchain @@ -0,0 +1 @@ +leanprover/lean4:v4.34.1 diff --git a/Main.lean b/Main.lean index 429b536f1..74b7e42b2 100644 --- a/Main.lean +++ b/Main.lean @@ -15,6 +15,7 @@ import Ix.Cli.DiffCmd import Ix.Cli.MergeCmd import Ix.Cli.NameOfCmd import Ix.Cli.PackCmd +import Ix.Cli.PrepareCmd import Ix.Cli.CompressCmd import Ix.Cli.ProveCmd import Ix.Cli.ProveBindingCmd @@ -50,6 +51,7 @@ def ixCmd : Cli.Cmd := `[Cli| diffCmd; packCmd; treeCmd; + prepareCmd; proveCmd; proveBindingCmd; compressCmd; diff --git a/MultiStark.lean b/MultiStark.lean deleted file mode 100644 index 755e46dbe..000000000 --- a/MultiStark.lean +++ /dev/null @@ -1,109 +0,0 @@ -module -public import MultiStark.FFI -public import Blake3.Rust -public import Ix.Aiur.Meta -public import Ix.Aiur.Protocol -public import Ix.Aiur.Library.Core -public import Ix.Aiur.Library.ByteStream -public import Ix.Aiur.Library.Blake3 -public import MultiStark.Goldilocks -public import MultiStark.Wire -public import MultiStark.Deserialize -public import MultiStark.Keccak -public import MultiStark.Pcs -public import MultiStark.SystemDeserialize -public import MultiStark.Verifier -public import MultiStark.VerifierFunctionGroups - -/-! -# Multi-STARK proof verifier (Aiur) - -The verifier entrypoint's public statement is purely existential: *"there -exists a valid multi-stark proof for the constraint system with this Blake3 -digest and these public claims."* The FRI parameters (blowup, query count, -PoW bits, …) are NOT separate public inputs: they live in the verifying key, -which the statement already binds through `system_digest` — repeating them -publicly would be redundant. The proof itself is -**non-deterministic advice** (fed on IO channel 0, -never hashed or otherwise bound as a public input): the Fiat-Shamir transcript -replay plus the Merkle/OOD/FRI checks are exactly what make any accepted advice -a valid proof — a hash binding of the proof bytes would add nothing to the -statement, while costing an extra in-circuit hash over those bytes. - -The verifying key and claims, by contrast, ARE digest-bound (`system_digest`, -`claims_digest`): they determine *what was proven*. - -Fixed protocol assumptions (our system): `capHeight = 0`, `maxLogArity = 1`, -`logFinalPolyLen = 0`. The variable FRI parameters (`num_queries`, -`commit_pow_bits`, `query_pow_bits`, `log_blowup`) are read from the -digest-bound verifying key. --/ - -public section - -namespace MultiStark - -def entrypoints := ⟦ - -- Public inputs: the Blake3 digests of the verifying key and the claims, - -- each as 8 field elements of 4 packed LE bytes (32 bytes; 4-byte packing - -- is injective in Goldilocks where 8-byte limbs are not, and costs 16 - -- input columns instead of 64). The proof is pure - -- non-deterministic advice on IO channel 0 — see the module docstring. One - -- stream per channel (0 = proof, 1 = vk, 2 = claims), each registered under - -- key `[0]` on its channel. - pub fn verify_multi_stark_proof(system_digest: [G; 8], claims_digest: [G; 8]) { - -- Proof advice from IO channel 0: a batch of trace shards (see - -- `MultiStark/Verifier.lean`, batch verification), deserialized - -- directly from the IO arena by byte offset and asserted fully consumed - -- inside `verify_batch_at`. The byte FETCHES inside the readers are - -- unconstrained (the proof is advice); the parse structure itself stays - -- constrained. - let (idx, len) = io_get_info(0, [0]); - -- Verifying key (`System`) from IO channel 1: read the bytes - -- once through the checked reader (finite, every element a byte), then - -- constrain both the hash and deserialization against that exact byte - -- stream (the same binding pattern as IxVM). Without the byte check the - -- digest would pin only packed 32-bit words, not the fields parsed from - -- them. - let (sidx, slen) = io_get_info(1, [0]); - let sbytes = read_checked_byte_stream(1, sidx, slen); - assert_eq!(@b3_pack(@blake3(sbytes)), system_digest); - let (sys, srest) = @read_system(sbytes); - assert_eq!(load(srest), ListNode.Nil); - -- Public claims (`&[&[Val]]`) from IO channel 2, read the same way: bind - -- the bytes to the public Blake3 `claims_digest`, then deserialize. The - -- batch's own claims (in its headers, bound by the batch transcript) - -- must equal them, which is what ties the public statement to the - -- lookup argument. - let (cidx, clen) = io_get_info(2, [0]); - let cbytes = read_checked_byte_stream(2, cidx, clen); - assert_eq!(@b3_pack(@blake3(cbytes)), claims_digest); - let (claims, crest) = @read_claims(cbytes); - assert_eq!(load(crest), ListNode.Nil); - -- Policy, batch transcript, every shard's shape/OOD/PCS checks, and the - -- residual balance. - assert_eq!(@verify_batch_at(sys, idx, len, claims), 1); - () - } -⟧ - -/-- Shared verifier circuits, without verification or aggregation entrypoints. -/ -def verifierBase : Except Aiur.Global Aiur.Source.Toplevel := do - let t ← Aiur.Library.core.merge Aiur.Library.byteStream - let t ← t.merge MultiStark.goldilocks - let t ← t.merge deserialize - let t ← t.merge Aiur.Library.blake3 - let t ← t.merge systemDeserialize - let t ← t.merge pcs - t.merge verifier - -/-- The generic verifier, pruned to its single public entrypoint. -/ -def multiStark : Except Aiur.Global Aiur.Source.Toplevel := do - let t ← verifierBase - let t ← t.merge entrypoints - pure (t.prune [`verify_multi_stark_proof]) - - -end MultiStark - -end diff --git a/MultiStark/.gitignore b/MultiStark/.gitignore new file mode 100644 index 000000000..01f8cdb63 --- /dev/null +++ b/MultiStark/.gitignore @@ -0,0 +1 @@ +.lake/ diff --git a/MultiStark/Deserialize.lean b/MultiStark/Deserialize.lean deleted file mode 100644 index 0126e3ae1..000000000 --- a/MultiStark/Deserialize.lean +++ /dev/null @@ -1,562 +0,0 @@ -module -public import Ix.Aiur.Meta -public import Ix.Aiur.Library.Core -public import Ix.Aiur.Library.ByteStream - -/-! -# Multi-STARK proof deserializer (Aiur) - -Aiur deserializer for `multi_stark::prover::Proof`, mirroring the hand-written -bincode reader in `multi-stark/src/manual_codec.rs` (`fn deserialize`). Only -the deserializer is ported (no serializer). - -The wire format is bincode `standard().with_little_endian().with_fixed_int_encoding()`: - -* every `Vec` / length prefix : `u64`, 8 bytes little-endian -* `Option` : 1 tag byte (`0` = None, `1` = Some), then value -* `u8` : 1 byte -* struct : fields in declaration order, no framing -* `[T; N]` / tuple : N elements back-to-back, no length prefix -* `Val` (Goldilocks) : raw `u64`, 8 bytes LE (NOT reduced mod p) -* `ExtVal` (deg-2 ext) : `[u64; 2]`, 16 bytes LE -* Merkle digest : `[u64; 4]`, 32 bytes LE - -The proof stream is pure non-deterministic advice on IO channel 0 (never -hashed — see `MultiStark.lean`), so the `read_proof` family reads it -**directly from the IO arena by index**: every reader threads a `(channel-0) -byte offset `i : G` and pulls fixed-size chunks with `io_read` (1/8/16/32 -bytes — `io_read`'s length is static). No per-byte `ListNode` chain is ever -materialized, which removes one memory store + one load per proof byte. -Variable-length content loops a fixed-size read per element, exactly like -the old stream readers looped `read_u8`. - -The byte-stream primitives (`read_u8`/`read_u64`/`read_count`/`read_digest`/ -`read_merkle_cap` over `ByteStream`) remain for the vk/claims streams, whose -bytes are digest-bound and therefore flow through blake3 as materialized -streams anyway (`read_system`, `read_claims`). - -`read_proof i` builds a `Proof` object and returns the end offset; -`MultiStark.lean` hangs the entrypoint (and full-consumption assert) -off it. --/ - -public section - -namespace MultiStark - -def deserialize := ⟦ - -- ========================================================================== - -- Wire-level type mirrors of `multi-stark/src/manual_codec.rs`. - -- `U64`/`ByteStream` come from `Aiur.Library.byteStream`; raw Goldilocks `Val` is the - -- non-canonical `u64`, kept here as the 8 little-endian bytes (`U64`). - -- ========================================================================== - - -- `ExtVal = BinomialExtensionField = 𝔽_p[X]/(X² - 7)`, stored - -- as its two NATIVE Goldilocks coefficients `[c0, c1]` (= `c0 + c1·X`) — - -- Aiur's field is Goldilocks, so extension arithmetic runs natively; byte - -- form exists only at ingest/observation boundaries (`Goldilocks.lean`). - type Ext = [G; 2] - - -- A Merkle digest: `[u64; DIGEST_ELEMS]` with `DIGEST_ELEMS = 4`. - type Digest = [U64; 4] - - -- Digests thread the Merkle machinery BY POINTER: a digest is 32 columns, - -- so every value crossing a circuit boundary (input, call output, list - -- node) paid 32; a pointer pays 1. `store` is content-addressed (same - -- digest -> same pointer), so pointer identity preserves the cross-query - -- compress memoization. Bytes are loaded only where actually consumed - -- (block assembly in mmcs_compress, cap observation, the root equality). - type DigestP = &Digest - - -- `Commitment = MerkleCap<..>`: only the `cap: Vec` is on the wire. - type MerkleCap = List‹DigestP› - - -- `OpenedValuesForRound = Vec>>`. - type OpenedRound = List‹List‹List‹Ext››› - - -- The three trace/quotient commitments at the head of a `Proof`. - enum Commitments { - Mk(MerkleCap, MerkleCap, MerkleCap) - } - - -- One input commitment opened at all query indices with a shared pruned - -- Merkle frontier. `opened_values[q][m]` is query q's row of matrix m. - enum BatchMultiOpening { - Mk(List‹List‹List‹U64›››, List‹DigestP›) - } - - -- `CommitPhaseProofStep`: one folding step of a FRI query. - -- log_arity : u8 - -- sibling_values : Vec (arity - 1 siblings) - -- opening_proof : Vec - enum CommitPhaseMultiStep { - Mk(U8, List‹List‹Ext››, List‹DigestP›) - } - - -- Per-query views derived in-circuit from the native batch openings. They - -- retain the existing FRI arithmetic organization; authentication is done - -- once per native multiproof before that arithmetic runs. - enum BatchOpening { Mk(List‹List‹U64››) } - enum CommitPhaseProofStep { Mk(U8, List‹Ext›) } - enum QueryProof { Mk(List‹BatchOpening›, List‹CommitPhaseProofStep›) } - - -- `PcsProof = FriProof`. - -- commit_phase_commits : Vec - -- commit_pow_witnesses : Vec - -- input_openings : Vec - -- commit_phase_openings: Vec - -- final_poly : Vec - -- query_pow_witness : Val - enum FriProof { - Mk(List‹MerkleCap›, List‹U64›, List‹BatchMultiOpening›, - List‹CommitPhaseMultiStep›, List‹Ext›, U64) - } - - -- `Option` for `preprocessed_opened_values`. A dedicated - -- non-generic enum keeps constructor inference unambiguous. - enum PreprocessedOpt { - NoPreprocessed, - SomePreprocessed(OpenedRound) - } - - -- Mirror of `multi_stark::prover::Proof`, in serialization order. - -- `active` is the sparse-activation bitmap over the system's canonical - -- circuit set (one 0/1 field value per circuit); every other per-circuit - -- sequence in the proof is indexed by ACTIVE position. - enum Proof { - Mk( - List‹G›, -- active - Commitments, -- commitments - List‹Ext›, -- intermediate_accumulators - List‹U8›, -- log_degrees - FriProof, -- opening_proof - OpenedRound, -- quotient_opened_values - PreprocessedOpt, -- preprocessed_opened_values - OpenedRound, -- stage_1_opened_values - OpenedRound -- stage_2_opened_values - ) - } - - -- ========================================================================== - -- Byte-stream primitives (vk/claims streams; digest-bound bytes that flow - -- through blake3 as materialized `ByteStream`s). - -- ========================================================================== - - fn read_u8(stream: ByteStream) -> (U8, ByteStream) { - match load(stream) { - ListNode.Cons(byte, rest) => (byte, rest), - ListNode.Nil => (0u8, store(ListNode.Nil)), - } - } - - -- One raw `u64`: 8 little-endian bytes, kept as `U64` (no field reduction). - fn read_u64(stream: ByteStream) -> (U64, ByteStream) { - let (b0, s0) = read_u8(stream); - let (b1, s1) = read_u8(s0); - let (b2, s2) = read_u8(s1); - let (b3, s3) = read_u8(s2); - let (b4, s4) = read_u8(s3); - let (b5, s5) = read_u8(s4); - let (b6, s6) = read_u8(s5); - let (b7, s7) = read_u8(s6); - ([b0, b1, b2, b3, b4, b5, b6, b7], s7) - } - - -- A bincode length prefix: a fixed-width `u64`, flattened to a field count. - -- `flatten_u64` asserts the top byte is zero (< 2^56), always true for the - -- list lengths in a proof. - fn read_count(stream: ByteStream) -> (G, ByteStream) { - let (val, s) = read_u64(stream); - (flatten_u64(val), s) - } - - -- Interpret a raw little-endian `u64` limb as a Goldilocks field element. The - -- field add/mul reduce mod p, so a non-canonical wire repr (e.g. `0` shipped - -- as `p = 0xFFFFFFFF00000001`) maps to the canonical field element. - fn limb_to_field(b: U64) -> G { - to_field(b[0]) - + 0x100 * to_field(b[1]) - + 0x10000 * to_field(b[2]) - + 0x1000000 * to_field(b[3]) - + 0x100000000 * to_field(b[4]) - + 0x10000000000 * to_field(b[5]) - + 0x1000000000000 * to_field(b[6]) - + 0x100000000000000 * to_field(b[7]) - } - - -- ========================================================================== - -- Indexed proof-stream primitives: read fixed-size chunks straight from the - -- IO arena of channel 0 at byte offset `i`, returning the advanced offset. - -- The cells come back as unconstrained field advice; `u8_from_field_unsafe` - -- reinterprets them exactly as the stream readers did (same trust model — - -- the proof is advice, and byte-ness is enforced downstream where needed). - -- ========================================================================== - - fn read_u8_at(i: G) -> (U8, G) { - let [b] = io_read(0, i, 1); - (u8_from_field_unsafe(b), i + 1) - } - - fn read_u64_at(i: G) -> (U64, G) { - let [b0, b1, b2, b3, b4, b5, b6, b7] = io_read(0, i, 8); - ([u8_from_field_unsafe(b0), u8_from_field_unsafe(b1), - u8_from_field_unsafe(b2), u8_from_field_unsafe(b3), - u8_from_field_unsafe(b4), u8_from_field_unsafe(b5), - u8_from_field_unsafe(b6), u8_from_field_unsafe(b7)], i + 8) - } - - fn read_count_at(i: G) -> (G, G) { - let (val, j) = #read_u64_at(i); - (flatten_u64(val), j) - } - - -- `ExtVal` -> two `u64` limbs (no length prefix), each canonicalized into a - -- Goldilocks element (`gl_reduce` maps a non-canonical wire repr, e.g. `0` - -- shipped as `p`, to its canonical `< p` bytes). - fn read_ext_at(i: G) -> (Ext, G) { - let (a, j0) = #read_u64_at(i); - let (b, j1) = #read_u64_at(j0); - ([@gl_val(a), @gl_val(b)], j1) - } - - fn read_digest_at(i: G) -> (Digest, G) { - let (a, j0) = #read_u64_at(i); - let (b, j1) = #read_u64_at(j0); - let (c, j2) = #read_u64_at(j1); - let (d, j3) = #read_u64_at(j2); - ([a, b, c, d], j3) - } - - -- ========================================================================== - -- Length-prefixed `Vec` readers over the indexed proof stream. - -- First-order, so one pair per element type: `read_T_vec` reads the `u64` - -- length then loops `read_T_vec_n`. - -- ========================================================================== - - fn read_u8_vec(i: G) -> (List‹U8›, G) { - let (n, j) = read_count_at(i); - read_u8_vec_n(j, n) - } - fn read_u8_vec_n(i: G, n: G) -> (List‹U8›, G) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (x, j) = #read_u8_at(i); - let (rest, j2) = read_u8_vec_n(j, n - 1); - (store(ListNode.Cons(x, rest)), j2), - } - } - - fn read_u64_vec(i: G) -> (List‹U64›, G) { - let (n, j) = read_count_at(i); - read_u64_vec_n(j, n) - } - fn read_u64_vec_n(i: G, n: G) -> (List‹U64›, G) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (x, j) = #read_u64_at(i); - let (rest, j2) = read_u64_vec_n(j, n - 1); - (store(ListNode.Cons(x, rest)), j2), - } - } - - fn read_ext_vec(i: G) -> (List‹Ext›, G) { - let (n, j) = read_count_at(i); - read_ext_vec_n(j, n) - } - fn read_ext_vec_n(i: G, n: G) -> (List‹Ext›, G) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (x, j) = @read_ext_at(i); - let (rest, j2) = read_ext_vec_n(j, n - 1); - (store(ListNode.Cons(x, rest)), j2), - } - } - - fn read_digest_vec_at(i: G) -> (List‹DigestP›, G) { - let (n, j) = read_count_at(i); - read_digest_vec_at_n(j, n) - } - fn read_digest_vec_at_n(i: G, n: G) -> (List‹DigestP›, G) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (x, j) = @read_digest_at(i); - let (rest, j2) = read_digest_vec_at_n(j, n - 1); - (store(ListNode.Cons(store(x), rest)), j2), - } - } - - -- `Vec>` for `BatchOpening.opened_values`. - fn read_u64_vec_vec(i: G) -> (List‹List‹U64››, G) { - let (n, j) = read_count_at(i); - read_u64_vec_vec_n(j, n) - } - fn read_u64_vec_vec_n(i: G, n: G) -> (List‹List‹U64››, G) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (x, j) = read_u64_vec(i); - let (rest, j2) = read_u64_vec_vec_n(j, n - 1); - (store(ListNode.Cons(x, rest)), j2), - } - } - - fn read_u64_vec_vec_vec(i: G) -> (List‹List‹List‹U64›››, G) { - let (n, j) = read_count_at(i); - read_u64_vec_vec_vec_n(j, n) - } - fn read_u64_vec_vec_vec_n(i: G, n: G) -> (List‹List‹List‹U64›››, G) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (x, j) = @read_u64_vec_vec(i); - let (rest, j2) = read_u64_vec_vec_vec_n(j, n - 1); - (store(ListNode.Cons(x, rest)), j2), - } - } - - -- `OpenedRound = Vec>>`, built bottom-up from `read_ext_vec`. - fn read_ext_vec_vec(i: G) -> (List‹List‹Ext››, G) { - let (n, j) = read_count_at(i); - read_ext_vec_vec_n(j, n) - } - fn read_ext_vec_vec_n(i: G, n: G) -> (List‹List‹Ext››, G) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (x, j) = read_ext_vec(i); - let (rest, j2) = read_ext_vec_vec_n(j, n - 1); - (store(ListNode.Cons(x, rest)), j2), - } - } - - fn read_opened_round(i: G) -> (OpenedRound, G) { - let (n, j) = read_count_at(i); - read_opened_round_n(j, n) - } - fn read_opened_round_n(i: G, n: G) -> (OpenedRound, G) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (x, j) = read_ext_vec_vec(i); - let (rest, j2) = read_opened_round_n(j, n - 1); - (store(ListNode.Cons(x, rest)), j2), - } - } - - -- ========================================================================== - -- Struct readers (fields in declaration order, no framing). - -- ========================================================================== - - fn read_merkle_cap_at(i: G) -> (MerkleCap, G) { - read_digest_vec_at(i) - } - fn read_merkle_cap_vec(i: G) -> (List‹MerkleCap›, G) { - let (n, j) = read_count_at(i); - read_merkle_cap_vec_n(j, n) - } - fn read_merkle_cap_vec_n(i: G, n: G) -> (List‹MerkleCap›, G) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (x, j) = @read_merkle_cap_at(i); - let (rest, j2) = read_merkle_cap_vec_n(j, n - 1); - (store(ListNode.Cons(x, rest)), j2), - } - } - - fn read_commitments(i: G) -> (Commitments, G) { - let (stage_1_trace, j0) = @read_merkle_cap_at(i); - let (stage_2_trace, j1) = @read_merkle_cap_at(j0); - let (quotient_chunks, j2) = @read_merkle_cap_at(j1); - (Commitments.Mk(stage_1_trace, stage_2_trace, quotient_chunks), j2) - } - - fn read_batch_opening(i: G) -> (BatchMultiOpening, G) { - let (opened_values, j0) = @read_u64_vec_vec_vec(i); - let (opening_proof, j1) = read_digest_vec_at(j0); - (BatchMultiOpening.Mk(opened_values, opening_proof), j1) - } - fn read_batch_opening_vec(i: G) -> (List‹BatchMultiOpening›, G) { - let (n, j) = read_count_at(i); - read_batch_opening_vec_n(j, n) - } - fn read_batch_opening_vec_n(i: G, n: G) -> (List‹BatchMultiOpening›, G) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (x, j) = @read_batch_opening(i); - let (rest, j2) = read_batch_opening_vec_n(j, n - 1); - (store(ListNode.Cons(x, rest)), j2), - } - } - - fn read_commit_phase_step(i: G) -> (CommitPhaseMultiStep, G) { - let (log_arity, j0) = #read_u8_at(i); - let (sibling_values, j1) = @read_ext_vec_vec(j0); - let (opening_proof, j2) = read_digest_vec_at(j1); - (CommitPhaseMultiStep.Mk(log_arity, sibling_values, opening_proof), j2) - } - fn read_commit_phase_step_vec(i: G) -> (List‹CommitPhaseMultiStep›, G) { - let (n, j) = read_count_at(i); - read_commit_phase_step_vec_n(j, n) - } - fn read_commit_phase_step_vec_n(i: G, n: G) -> (List‹CommitPhaseMultiStep›, G) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (x, j) = @read_commit_phase_step(i); - let (rest, j2) = read_commit_phase_step_vec_n(j, n - 1); - (store(ListNode.Cons(x, rest)), j2), - } - } - - fn read_fri_proof(i: G) -> (FriProof, G) { - let (commit_phase_commits, j0) = @read_merkle_cap_vec(i); - let (commit_pow_witnesses, j1) = read_u64_vec(j0); - let (input_openings, j2) = @read_batch_opening_vec(j1); - let (commit_phase_openings, j3) = @read_commit_phase_step_vec(j2); - let (final_poly, j4) = read_ext_vec(j3); - let (query_pow_witness, j5) = #read_u64_at(j4); - (FriProof.Mk(commit_phase_commits, commit_pow_witnesses, input_openings, - commit_phase_openings, final_poly, query_pow_witness), j5) - } - - -- The activation bitmap: `Vec` on the wire (u64 count, then one - -- 0/1 byte per circuit), kept as 0/1 field values. - fn read_active(i: G) -> (List‹G›, G) { - let (n, j) = read_count_at(i); - read_active_n(j, n) - } - fn read_active_n(i: G, n: G) -> (List‹G›, G) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (b, j) = #read_u8_at(i); - let (rest, j2) = read_active_n(j, n - 1); - (store(ListNode.Cons(to_field(b), rest)), j2), - } - } - - -- `Option`: 1 tag byte, then the value when `Some`. - fn read_preprocessed(i: G) -> (PreprocessedOpt, G) { - let (tag, j) = #read_u8_at(i); - match tag { - 0 => (PreprocessedOpt.NoPreprocessed, j), - _ => - let (r, j2) = read_opened_round(j); - (PreprocessedOpt.SomePreprocessed(r), j2), - } - } - - -- Full `Proof` in declaration order (see `manual_codec.rs::Reader::proof`), - -- read from the channel-0 IO arena starting at byte offset `i`. Returns the - -- end offset; the entrypoint asserts it equals `idx + len` (fully consumed). - fn read_proof(i: G) -> (Proof, G) { - let (active, ja) = @read_active(i); - let (commitments, j0) = @read_commitments(ja); - let (intermediate_accumulators, j1) = read_ext_vec(j0); - let (log_degrees, j2) = @read_u8_vec(j1); - let (opening_proof, j3) = @read_fri_proof(j2); - let (quotient_opened_values, j4) = read_opened_round(j3); - let (preprocessed_opened_values, j5) = read_preprocessed(j4); - let (stage_1_opened_values, j6) = read_opened_round(j5); - let (stage_2_opened_values, j7) = read_opened_round(j6); - (Proof.Mk(active, commitments, intermediate_accumulators, log_degrees, - opening_proof, quotient_opened_values, preprocessed_opened_values, - stage_1_opened_values, stage_2_opened_values), j7) - } - - -- ========================================================================== - -- `multi_stark::batch`: a vector of shard proofs under one preamble. The - -- preamble (headers, then messages) precedes the proofs on the wire. - -- ========================================================================== - - -- `ShardHeader`: activation bitmap, stage-1 commitment, log degrees, and - -- the shard's claims (`Vec>`, raw limbs). - enum ShardHeader { - Mk(List‹G›, MerkleCap, List‹U8›, List‹List‹U64››) - } - - -- `BatchMessage`: lookup arguments and a signed multiplicity, both raw - -- `Val` limbs. - enum BatchMessage { - Mk(List‹U64›, U64) - } - - -- `BatchProof`: the headers and messages of the preamble, then one proof - -- per header. - enum Batch { - Mk(List‹ShardHeader›, List‹BatchMessage›, List‹Proof›) - } - - fn read_header(i: G) -> (ShardHeader, G) { - let (active, j0) = @read_active(i); - let (stage_1, j1) = @read_merkle_cap_at(j0); - let (log_degrees, j2) = @read_u8_vec(j1); - let (claims, j3) = @read_u64_vec_vec(j2); - (ShardHeader.Mk(active, stage_1, log_degrees, claims), j3) - } - fn read_header_vec(i: G) -> (List‹ShardHeader›, G) { - let (n, j) = read_count_at(i); - read_header_vec_n(j, n) - } - fn read_header_vec_n(i: G, n: G) -> (List‹ShardHeader›, G) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (x, j) = @read_header(i); - let (rest, j2) = read_header_vec_n(j, n - 1); - (store(ListNode.Cons(x, rest)), j2), - } - } - - fn read_message(i: G) -> (BatchMessage, G) { - let (args, j0) = read_u64_vec(i); - let (multiplicity, j1) = #read_u64_at(j0); - (BatchMessage.Mk(args, multiplicity), j1) - } - fn read_message_vec(i: G) -> (List‹BatchMessage›, G) { - let (n, j) = read_count_at(i); - read_message_vec_n(j, n) - } - fn read_message_vec_n(i: G, n: G) -> (List‹BatchMessage›, G) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (x, j) = @read_message(i); - let (rest, j2) = read_message_vec_n(j, n - 1); - (store(ListNode.Cons(x, rest)), j2), - } - } - - fn read_proof_vec(i: G) -> (List‹Proof›, G) { - let (n, j) = read_count_at(i); - read_proof_vec_n(j, n) - } - fn read_proof_vec_n(i: G, n: G) -> (List‹Proof›, G) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (x, j) = read_proof(i); - let (rest, j2) = read_proof_vec_n(j, n - 1); - (store(ListNode.Cons(x, rest)), j2), - } - } - - -- Full `BatchProof` from the channel-0 IO arena at byte offset `i`; returns - -- the end offset, which the caller asserts equals the stream end. - fn read_batch(i: G) -> (Batch, G) { - let (headers, j0) = @read_header_vec(i); - let (messages, j1) = @read_message_vec(j0); - let (proofs, j2) = @read_proof_vec(j1); - (Batch.Mk(headers, messages, proofs), j2) - } -⟧ - -end MultiStark - -end diff --git a/MultiStark/FFI.lean b/MultiStark/FFI.lean deleted file mode 100644 index c16c66c38..000000000 --- a/MultiStark/FFI.lean +++ /dev/null @@ -1,54 +0,0 @@ -module -public import Ix.Aiur.Protocol - -/-! Native execution and proving for the generic Multi-STARK verifier. -/ - -public section -namespace Aiur -namespace Bytecode.Toplevel - -/-- MultiStark-native execution of `verify_multi_stark_proof`: the IO - advice buffer (channel 0 = proof, 1 = vk, 2 = claims, key `[0]` - each) is built natively in Rust from the raw byte blobs — no - per-byte boxing into Lean `G`s, no buffer marshalling across FFI. - `proofAdviceBytes` is the verified native proof transport returned by - `AiurSystem.proofToAdviceBytes`. - `useBytecode` selects the generic Aiur bytecode interpreter over - the codegen'd verifier (`crates/ixvm-codegen/src/aiur_multi_stark.rs`); - as with `executeIxVM`, the codegen'd path is only valid when - `toplevel` is the production `MultiStark.multiStark` bytecode — - other toplevels (e.g. `multiStarkTests`) must pass - `useBytecode := true`. Returns the output and per-circuit query - counts; the final buffer is not returned (the verifier only reads - its advice). -/ -@[extern "rs_aiur_multi_stark_execute"] -opaque executeMultiStark (toplevel : @& Bytecode.Toplevel) - (funIdx : @& Bytecode.FunIdx) (pubInput : @& Array G) - (proofAdviceBytes vkBytes claimBytes : @& ByteArray) (useBytecode : Bool := false) : - Except String (Array G × Array QueryCount) - - -end Bytecode.Toplevel -namespace AiurSystem - -/-- Prove the MultiStark recursive verifier over proof-advice/vk/claims -byte blobs. `proofAdviceBytes` must come from -`AiurSystem.proofToAdviceBytes`, which verifies and serializes the native -proof transport. The IO advice buffer is built natively in Rust (see - `Bytecode.Toplevel.executeMultiStark`); the execute step inside - the prove routes through the codegen'd verifier - (`crates/ixvm-codegen/src/aiur_multi_stark.rs`) unless - `useBytecode` is set. Only valid when `system` was built from the - production `MultiStark.multiStark` bytecode. Returns the claim - (`#[functionChannel, funIdx] ++ pubInput ++ output`) and the - `Proof`; the final buffer is not returned. -/ -@[extern "rs_aiur_multi_stark_prove"] -opaque proveMultiStark (system : @& AiurSystem) - (funIdx : @& Bytecode.FunIdx) (pubInput : @& Array G) - (proofAdviceBytes vkBytes claimBytes : @& ByteArray) (useBytecode : Bool := false) : - Except String (Array G × Proof) - - -end AiurSystem -end Aiur -end diff --git a/MultiStark/Goldilocks.lean b/MultiStark/Goldilocks.lean deleted file mode 100644 index d9873ac6c..000000000 --- a/MultiStark/Goldilocks.lean +++ /dev/null @@ -1,137 +0,0 @@ -module -public import Ix.Aiur.Meta - -/-! -# Goldilocks field arithmetic on the native field (`Goldilocks = G`) - -The recursive verifier computes on the *inner* proof's field (Goldilocks) — -and Aiur's outer field IS Goldilocks (`aiur::G = p3_goldilocks`), so the -arithmetic runs directly on native `+`/`*`. A `Goldilocks` element is a -plain field value (canonical by construction — `G` is the field), and -`ExtGoldilocks = [G; 2]` is the degree-2 extension `𝔽_p[X]/(X² − 7)`. - -Byte form exists only at true boundaries: - -- **ingest**: wire limbs (`U64`, 8 LE bytes, possibly non-canonical) fold - into native values with `gl_val`/`limb_to_field` (the field sum wraps - mod p — exactly the reduction); -- **egress**: challenger observations need the canonical LE bytes; - `gl_to_bytes` decomposes a native value via the `unconstrained_g_to_bytes` - hint, pinned by u8 range checks, a recomposition equality, and a - canonicality (`< p`) check — forcing the unique canonical decomposition. - -Inverses are hinted (`unconstrained_g_inverse`) and verified with one -multiplication, never computed. - -If Aiur is ever compiled to a different outer field (e.g. the BLS scalar -field), this module must be swapped for a field-agnostic byte-limb -implementation (see this file's git history for a complete one, validated -byte-for-byte against `multi-stark`'s `gl_ops_ref`). - -Validated against `multi-stark`'s native Goldilocks (`gl_ops_ref` in -`multi-stark/src/types.rs`) via the `multi-stark` self-test suite. --/ - -public section - -namespace MultiStark - -def goldilocks := ⟦ - type Goldilocks = G - type ExtGoldilocks = [G; 2] - - -- The native field value of 8 LE bytes: `Σ xᵢ·256ⁱ` (mod p). For an - -- arbitrary 8-byte value (< 2⁶⁴ < 2p) the field sum wraps at most once, - -- yielding exactly the reduced representative — so this is both the - -- canonical-bytes recomposition AND the wire-limb reduction. - fn gl_val(x: [U8; 8]) -> G { - to_field(x[0]) + 256 * to_field(x[1]) + 65536 * to_field(x[2]) - + 16777216 * to_field(x[3]) + 4294967296 * to_field(x[4]) - + 1099511627776 * to_field(x[5]) + 281474976710656 * to_field(x[6]) - + 72057594037927936 * to_field(x[7]) - } - - -- 1 iff the 8-byte LE integer is < p. Since p = (2³² − 1)·2³² + 1, we have - -- x ≥ p ⟺ (high word = 2³² − 1) ∧ (low word ≥ 1). The high word is maximal - -- iff its byte sum is 4·255 = 1020 (each byte is ≤ 255), and the low word - -- is zero iff its byte sum is zero (a sum of four bytes cannot wrap). - -- Inputs must be range-checked bytes. (Used by the challenger's rejection - -- sampling, which works on raw sampled bytes.) - fn gl_lt_p(x: [U8; 8]) -> G { - let hi_max = eq_zero( - to_field(x[4]) + to_field(x[5]) + to_field(x[6]) + to_field(x[7]) - 1020); - let lo_zero = eq_zero( - to_field(x[0]) + to_field(x[1]) + to_field(x[2]) + to_field(x[3])); - 1 - (hi_max * (1 - lo_zero)) - } - - -- Decompose a native field value into its canonical 8 LE bytes (egress: - -- challenger observations). The bytes are prover hints; the range checks + - -- recomposition equality + canonicality check pin the unique canonical - -- decomposition (two distinct byte strings < p have distinct field values). - fn gl_to_bytes(v: G) -> [U8; 8] { - let b = unconstrained_g_to_bytes(v); - let (c0, c1) = u8_range_check(b[0], b[1]); - let (c2, c3) = u8_range_check(b[2], b[3]); - let (c4, c5) = u8_range_check(b[4], b[5]); - let (c6, c7) = u8_range_check(b[6], b[7]); - let r = [c0, c1, c2, c3, c4, c5, c6, c7]; - assert_eq!(@gl_val(r), v); - assert_eq!(@gl_lt_p(r), 1); - r - } - - -- ========================================================================== - -- Base field inverse: hinted, verified with one multiplication. - -- `t = x·i − 1; x·t == 0 ∧ i·t == 0` forces `i = x⁻¹` when `x ≠ 0` (first - -- assert gives x·i = 1) and `i = 0` when `x = 0` (t = −1, second assert). - -- Matches the reference semantics `0⁻¹ = 0` (Fermat: 0^(p−2) = 0). - -- Always called inlined (`@gl_inverse`), so it compiles to no circuit. - -- ========================================================================== - fn gl_inverse(x: Goldilocks) -> Goldilocks { - let iv = unconstrained_g_inverse(x); - let t = (x * iv) - 1; - assert_eq!(x * t, 0); - assert_eq!(iv * t, 0); - iv - } - - -- ========================================================================== - -- Extension field ExtGoldilocks = 𝔽_p[X]/(X² − 7), native end-to-end. - -- ========================================================================== - fn eg_add(a: ExtGoldilocks, b: ExtGoldilocks) -> ExtGoldilocks { - [a[0] + b[0], a[1] + b[1]] - } - fn eg_sub(a: ExtGoldilocks, b: ExtGoldilocks) -> ExtGoldilocks { - [a[0] - b[0], a[1] - b[1]] - } - fn eg_neg(a: ExtGoldilocks) -> ExtGoldilocks { - [0 - a[0], 0 - a[1]] - } - -- (a0 + a1·X)(b0 + b1·X) = (a0·b0 + 7·a1·b1) + (a0·b1 + a1·b0)·X. - fn eg_mul(a: ExtGoldilocks, b: ExtGoldilocks) -> ExtGoldilocks { - [(a[0] * b[0]) + (7 * (a[1] * b[1])), (a[0] * b[1]) + (a[1] * b[0])] - } - -- conjugate ā = a0 − a1·X, norm a·ā = a0² − 7·a1² ∈ 𝔽_p, a⁻¹ = ā / norm. - -- The norm inverse is hinted and pinned like `gl_inverse`. - fn eg_inverse(a: ExtGoldilocks) -> ExtGoldilocks { - let norm = (a[0] * a[0]) - (7 * (a[1] * a[1])); - let ninv = unconstrained_g_inverse(norm); - let t = (norm * ninv) - 1; - assert_eq!(norm * t, 0); - assert_eq!(ninv * t, 0); - [a[0] * ninv, (0 - a[1]) * ninv] - } - fn eg_div(a: ExtGoldilocks, b: ExtGoldilocks) -> ExtGoldilocks { - @eg_mul(a, @eg_inverse(b)) - } - -- 1 iff two extension elements are equal. - fn eg_eq(a: ExtGoldilocks, b: ExtGoldilocks) -> G { - eq_zero(a[0] - b[0]) * eq_zero(a[1] - b[1]) - } - -⟧ - -end MultiStark - -end diff --git a/MultiStark/Keccak.lean b/MultiStark/Keccak.lean deleted file mode 100644 index 19160a09c..000000000 --- a/MultiStark/Keccak.lean +++ /dev/null @@ -1,355 +0,0 @@ -module -public import Ix.Aiur.Meta -public import Ix.Aiur.Library.Core -public import Ix.Aiur.Library.ByteStream - -/-! -# Keccak-256 in Aiur - -The hash multi-stark uses (`p3_keccak`: `Keccak256Hash` + `KeccakF` permutation, -keccak-f[1600] sponge). This is the Ethereum/original Keccak variant -(`tiny_keccak::Keccak::v256`): pad `10*1` with first pad byte `0x01` and final -`0x80`, rate = 136 bytes (17 lanes), capacity 512, 256-bit output. - -Representation: -* lane = 64-bit word = `[U8; 8]`, little-endian bytes (byte 0 = least significant). -* state = `[Lane; 25]`, lane index `L(x,y) = x + 5*y`. - -Bit ops use the `u8` gadgets (`u8_xor`/`u8_and`; NOT = `u8_xor(b, 0xFF)`). -Rotations go through `u8_bit_decomposition` (u8 → `[field; 8]`) and a generic -bit-list rotate, recomposing bytes with `u8_from_field_unsafe`. - -**Scope:** single-block only — message length ≤ 135 bytes (one keccak-f call). -Multi-block absorption is future work. --/ - -public section - -namespace MultiStark - -def keccak := ⟦ - -- A 64-bit Keccak lane: a pointer to 8 little-endian bytes. Storing lanes - -- behind a pointer keeps the state (and every lane-passing function) one - -- column wide instead of eight. - type Lane = &[U8; 8] - - -- The keccak-f state: a pointer to the 5×5 = 25 lanes. Passed behind a - -- pointer too, so state-threading functions stay one column wide. - type State = &[Lane; 25] - - -- ========================================================================== - -- Lane bit-logic (byte-wise u8 gadgets). - -- ========================================================================== - - fn xor8(a: Lane, b: Lane) -> Lane { - let x = load(a); - let y = load(b); - store([u8_xor(x[0], y[0]), u8_xor(x[1], y[1]), u8_xor(x[2], y[2]), u8_xor(x[3], y[3]), - u8_xor(x[4], y[4]), u8_xor(x[5], y[5]), u8_xor(x[6], y[6]), u8_xor(x[7], y[7])]) - } - - fn and8(a: Lane, b: Lane) -> Lane { - let x = load(a); - let y = load(b); - store([u8_and(x[0], y[0]), u8_and(x[1], y[1]), u8_and(x[2], y[2]), u8_and(x[3], y[3]), - u8_and(x[4], y[4]), u8_and(x[5], y[5]), u8_and(x[6], y[6]), u8_and(x[7], y[7])]) - } - - -- Bitwise NOT via XOR with 0xFF (keeps the byte `u8`-typed). - fn not8(a: Lane) -> Lane { - let x = load(a); - store([u8_xor(x[0], 255u8), u8_xor(x[1], 255u8), u8_xor(x[2], 255u8), u8_xor(x[3], 255u8), - u8_xor(x[4], 255u8), u8_xor(x[5], 255u8), u8_xor(x[6], 255u8), u8_xor(x[7], 255u8)]) - } - - -- ========================================================================== - -- Generic cyclic left-rotation of a lane by `n` bits (0 ≤ n < 64). - -- Decompose to a 64-element bit list (LSB first), reindex, recompose. - -- ========================================================================== - - -- Prepend the 8 bits of a byte decomposition (LSB first) onto `tail`. - fn cons8(d: [G; 8], tail: List‹G›) -> List‹G› { - store(ListNode.Cons(d[0], store(ListNode.Cons(d[1], store(ListNode.Cons(d[2], - store(ListNode.Cons(d[3], store(ListNode.Cons(d[4], store(ListNode.Cons(d[5], - store(ListNode.Cons(d[6], store(ListNode.Cons(d[7], tail)))))))))))))))) - } - - -- Lane → 64 bits, index z = 8*byte + bit, LSB first. - fn lane_bits(l: Lane) -> List‹G› { - let v = load(l); - cons8(u8_bit_decomposition(v[0]), - cons8(u8_bit_decomposition(v[1]), - cons8(u8_bit_decomposition(v[2]), - cons8(u8_bit_decomposition(v[3]), - cons8(u8_bit_decomposition(v[4]), - cons8(u8_bit_decomposition(v[5]), - cons8(u8_bit_decomposition(v[6]), - cons8(u8_bit_decomposition(v[7]), store(ListNode.Nil))))))))) - } - - -- x mod 64 for x in [0, 127]: drop the 64-bit (bit 6). - fn mod64(x: G) -> G { - let bits = u8_bit_decomposition(u8_from_field_unsafe(x)); - x - 64 * bits[6] - } - - -- Recompose a byte (as `u8`) from bits[off .. off+7] (LSB first). Indexed - -- access is inlined as `list_drop` (not `list_lookup`): `list_drop` recurses - -- on the same list pointer, so the consecutive drops here share the cached - -- drop-chain (far better caching than `list_lookup`). - fn byte_from_bits(bs: List‹G›, off: G) -> U8 { - -- One `list_drop` to the byte's first bit; the remaining 7 bits are the - -- successive tails (a deref each), so no further drops are needed. - let &ListNode.Cons(b0, r0) = list_drop(bs, off); - let &ListNode.Cons(b1, r1) = r0; - let &ListNode.Cons(b2, r2) = r1; - let &ListNode.Cons(b3, r3) = r2; - let &ListNode.Cons(b4, r4) = r3; - let &ListNode.Cons(b5, r5) = r4; - let &ListNode.Cons(b6, r6) = r5; - let &ListNode.Cons(b7, _) = r6; - u8_from_field_unsafe( - b0 + 2 * b1 + 4 * b2 + 8 * b3 + 16 * b4 + 32 * b5 + 64 * b6 + 128 * b7) - } - - fn lane_from_bits(bs: List‹G›) -> Lane { - store([byte_from_bits(bs, 0), byte_from_bits(bs, 8), byte_from_bits(bs, 16), byte_from_bits(bs, 24), - byte_from_bits(bs, 32), byte_from_bits(bs, 40), byte_from_bits(bs, 48), byte_from_bits(bs, 56)]) - } - - -- Build the rotated bit list: output position p (0..63) takes source - -- bit (p - n) mod 64 = mod64(p + 64 - n). - fn build_rot(bs: List‹G›, n: G, p: G) -> List‹G› { - match 64 - p { - 0 => store(ListNode.Nil), - _ => - let src = mod64(p + 64 - n); - let &ListNode.Cons(head, _) = list_drop(bs, src); - store(ListNode.Cons(head, build_rot(bs, n, p + 1))), - } - } - - fn rotl(l: Lane, n: G) -> Lane { - lane_from_bits(build_rot(lane_bits(l), n, 0)) - } - - -- ========================================================================== - -- keccak-f[1600]: 24 rounds of θ ρ π χ ι. - -- ========================================================================== - - fn keccak_round(sp: State, rc: Lane) -> State { - let s = load(sp); - -- θ: column parities and the D correction. - let c0 = xor8(xor8(xor8(xor8(s[0], s[5]), s[10]), s[15]), s[20]); - let c1 = xor8(xor8(xor8(xor8(s[1], s[6]), s[11]), s[16]), s[21]); - let c2 = xor8(xor8(xor8(xor8(s[2], s[7]), s[12]), s[17]), s[22]); - let c3 = xor8(xor8(xor8(xor8(s[3], s[8]), s[13]), s[18]), s[23]); - let c4 = xor8(xor8(xor8(xor8(s[4], s[9]), s[14]), s[19]), s[24]); - let d0 = xor8(c4, rotl(c1, 1)); - let d1 = xor8(c0, rotl(c2, 1)); - let d2 = xor8(c1, rotl(c3, 1)); - let d3 = xor8(c2, rotl(c4, 1)); - let d4 = xor8(c3, rotl(c0, 1)); - let a0 = xor8(s[0], d0); let a1 = xor8(s[1], d1); let a2 = xor8(s[2], d2); - let a3 = xor8(s[3], d3); let a4 = xor8(s[4], d4); - let a5 = xor8(s[5], d0); let a6 = xor8(s[6], d1); let a7 = xor8(s[7], d2); - let a8 = xor8(s[8], d3); let a9 = xor8(s[9], d4); - let a10 = xor8(s[10], d0); let a11 = xor8(s[11], d1); let a12 = xor8(s[12], d2); - let a13 = xor8(s[13], d3); let a14 = xor8(s[14], d4); - let a15 = xor8(s[15], d0); let a16 = xor8(s[16], d1); let a17 = xor8(s[17], d2); - let a18 = xor8(s[18], d3); let a19 = xor8(s[19], d4); - let a20 = xor8(s[20], d0); let a21 = xor8(s[21], d1); let a22 = xor8(s[22], d2); - let a23 = xor8(s[23], d3); let a24 = xor8(s[24], d4); - -- ρ + π: B[dest] = rotl(A'[src], offset). - let b0 = a0; - let b1 = rotl(a6, 44); - let b2 = rotl(a12, 43); - let b3 = rotl(a18, 21); - let b4 = rotl(a24, 14); - let b5 = rotl(a3, 28); - let b6 = rotl(a9, 20); - let b7 = rotl(a10, 3); - let b8 = rotl(a16, 45); - let b9 = rotl(a22, 61); - let b10 = rotl(a1, 1); - let b11 = rotl(a7, 6); - let b12 = rotl(a13, 25); - let b13 = rotl(a19, 8); - let b14 = rotl(a20, 18); - let b15 = rotl(a4, 27); - let b16 = rotl(a5, 36); - let b17 = rotl(a11, 10); - let b18 = rotl(a17, 15); - let b19 = rotl(a23, 56); - let b20 = rotl(a2, 62); - let b21 = rotl(a8, 55); - let b22 = rotl(a14, 39); - let b23 = rotl(a15, 41); - let b24 = rotl(a21, 2); - -- χ: A''[x][y] = B[x][y] ^ (¬B[x+1][y] & B[x+2][y]). - let e0 = xor8(b0, and8(not8(b1), b2)); - let e1 = xor8(b1, and8(not8(b2), b3)); - let e2 = xor8(b2, and8(not8(b3), b4)); - let e3 = xor8(b3, and8(not8(b4), b0)); - let e4 = xor8(b4, and8(not8(b0), b1)); - let e5 = xor8(b5, and8(not8(b6), b7)); - let e6 = xor8(b6, and8(not8(b7), b8)); - let e7 = xor8(b7, and8(not8(b8), b9)); - let e8 = xor8(b8, and8(not8(b9), b5)); - let e9 = xor8(b9, and8(not8(b5), b6)); - let e10 = xor8(b10, and8(not8(b11), b12)); - let e11 = xor8(b11, and8(not8(b12), b13)); - let e12 = xor8(b12, and8(not8(b13), b14)); - let e13 = xor8(b13, and8(not8(b14), b10)); - let e14 = xor8(b14, and8(not8(b10), b11)); - let e15 = xor8(b15, and8(not8(b16), b17)); - let e16 = xor8(b16, and8(not8(b17), b18)); - let e17 = xor8(b17, and8(not8(b18), b19)); - let e18 = xor8(b18, and8(not8(b19), b15)); - let e19 = xor8(b19, and8(not8(b15), b16)); - let e20 = xor8(b20, and8(not8(b21), b22)); - let e21 = xor8(b21, and8(not8(b22), b23)); - let e22 = xor8(b22, and8(not8(b23), b24)); - let e23 = xor8(b23, and8(not8(b24), b20)); - let e24 = xor8(b24, and8(not8(b20), b21)); - -- ι: add round constant to lane (0,0). - let f0 = xor8(e0, rc); - store([f0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, - e15, e16, e17, e18, e19, e20, e21, e22, e23, e24]) - } - - -- Round constant for round `i` (little-endian byte lane). A match (not an - -- array `get`, which needs a literal index) so it can be indexed at runtime. - fn rc_lane(i: G) -> Lane { - match i { - 0 => store([0x01u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8 ]), - 1 => store([0x82u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8 ]), - 2 => store([0x8au8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]), - 3 => store([0x00u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]), - 4 => store([0x8bu8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8 ]), - 5 => store([0x01u8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8 ]), - 6 => store([0x81u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]), - 7 => store([0x09u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]), - 8 => store([0x8au8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8 ]), - 9 => store([0x88u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8 ]), - 10 => store([0x09u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8 ]), - 11 => store([0x0au8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8 ]), - 12 => store([0x8bu8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8 ]), - 13 => store([0x8bu8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]), - 14 => store([0x89u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]), - 15 => store([0x03u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]), - 16 => store([0x02u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]), - 17 => store([0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]), - 18 => store([0x0au8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8 ]), - 19 => store([0x0au8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]), - 20 => store([0x81u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]), - 21 => store([0x80u8, 0x80u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0x80u8]), - 22 => store([0x01u8, 0u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0u8 ]), - _ => store([0x08u8, 0x80u8, 0u8, 0x80u8, 0u8, 0u8, 0u8, 0x80u8]), - } - } - - -- Apply the last `n` keccak-f rounds recursively (round index 24 - n), so - -- each round is its own call frame rather than 24 inlined copies (`fold`), - -- keeping the circuit narrow. `keccak_f_fold(s, 24)` is the full permutation. - fn keccak_f_fold(s: State, n: G) -> State { - match n { - 0 => s, - _ => keccak_f_fold(keccak_round(s, rc_lane(24 - n)), n - 1), - } - } - - -- ========================================================================== - -- Single-block sponge (keccak-256, message ≤ 135 bytes). - -- ========================================================================== - - -- Pad bytes for positions i..135 once the message is exhausted. `first`=1 at - -- position `len` (gets the 0x01 pad bit); position 135 gets the 0x80 bit - -- (combining to 0x81 when len == 135). - -- `first` is 1 on the first pad position (gets 0x01), 0 afterwards. The 0x80 - -- bit lands on position 135 (combining to 0x81 when first==1 there). Uses - -- `eq_zero` (an op) instead of a match so it stays tail-position-compilable. - fn build_pad(i: G, first: G) -> ByteStream { - match 136 - i { - 0 => store(ListNode.Nil), - _ => - store(ListNode.Cons(u8_from_field_unsafe(first + 128 * eq_zero(135 - i)), - build_pad(i + 1, 0))), - } - } - - -- Take one 136-byte rate block from `stream` starting at position `i`. - -- Returns (block, rest, full): a length-136 byte list, the unconsumed stream, - -- and full=1 if 136 message bytes were consumed (no padding yet), else 0 (the - -- message ended in this block, so pad10*1 was applied). When the stream is - -- already empty this yields an all-padding block with full=0 — the extra - -- block keccak appends when the message length is a multiple of 136. - fn read_block(stream: ByteStream, i: G) -> (ByteStream, ByteStream, G) { - match 136 - i { - 0 => (store(ListNode.Nil), stream, 1), - _ => match load(stream) { - ListNode.Cons(b, rest) => - let (blk, r, f) = read_block(rest, i + 1); - (store(ListNode.Cons(b, blk)), r, f), - ListNode.Nil => (build_pad(i, 1), store(ListNode.Nil), 0), - }, - } - } - - fn rate_lane(rate: ByteStream, b: G) -> Lane { - -- One `list_drop` to the lane's first byte; the next 7 are successive tails. - let &ListNode.Cons(r0, t0) = list_drop(rate, b); - let &ListNode.Cons(r1, t1) = t0; - let &ListNode.Cons(r2, t2) = t1; - let &ListNode.Cons(r3, t3) = t2; - let &ListNode.Cons(r4, t4) = t3; - let &ListNode.Cons(r5, t5) = t4; - let &ListNode.Cons(r6, t6) = t5; - let &ListNode.Cons(r7, _) = t6; - store([r0, r1, r2, r3, r4, r5, r6, r7]) - } - - -- XOR one 136-byte rate block into the first 17 lanes, then permute. - fn absorb_one(sp: State, rate: ByteStream) -> State { - let state = load(sp); - let s = store([ - xor8(state[0], rate_lane(rate, 0)), xor8(state[1], rate_lane(rate, 8)), - xor8(state[2], rate_lane(rate, 16)), xor8(state[3], rate_lane(rate, 24)), - xor8(state[4], rate_lane(rate, 32)), xor8(state[5], rate_lane(rate, 40)), - xor8(state[6], rate_lane(rate, 48)), xor8(state[7], rate_lane(rate, 56)), - xor8(state[8], rate_lane(rate, 64)), xor8(state[9], rate_lane(rate, 72)), - xor8(state[10], rate_lane(rate, 80)), xor8(state[11], rate_lane(rate, 88)), - xor8(state[12], rate_lane(rate, 96)), xor8(state[13], rate_lane(rate, 104)), - xor8(state[14], rate_lane(rate, 112)), xor8(state[15], rate_lane(rate, 120)), - xor8(state[16], rate_lane(rate, 128)), - state[17], state[18], state[19], state[20], state[21], state[22], state[23], state[24] - ]); - keccak_f_fold(s, 24) - } - - -- Absorb every rate block of the (padded) message into the state. - fn absorb_blocks(stream: ByteStream, state: State) -> State { - let (block, rest, full) = read_block(stream, 0); - let st2 = absorb_one(state, block); - match full { - 0 => st2, - _ => absorb_blocks(rest, st2), - } - } - - -- keccak-256: absorb the byte stream into the zero state, then squeeze the - -- first 32 bytes (lanes 0..3). Lanes are `load`ed back to inline bytes so the - -- digest is a plain `[[U8; 8]; 4]`. - fn keccak256(bytes: ByteStream) -> [[U8; 8]; 4] { - let z = store([0u8; 8]); - let init = store([z, z, z, z, z, z, z, z, z, z, z, z, z, z, z, z, z, z, z, z, z, z, z, z, z]); - let sp = absorb_blocks(bytes, init); - let s = load(sp); - [load(s[0]), load(s[1]), load(s[2]), load(s[3])] - } - -⟧ - -end MultiStark - -end diff --git a/MultiStark/MultiStark.lean b/MultiStark/MultiStark.lean new file mode 100644 index 000000000..f44f5313d --- /dev/null +++ b/MultiStark/MultiStark.lean @@ -0,0 +1 @@ +import MultiStark.Program diff --git a/MultiStark/MultiStark/Aggregate.aiur b/MultiStark/MultiStark/Aggregate.aiur new file mode 100644 index 000000000..1289b4e5e --- /dev/null +++ b/MultiStark/MultiStark/Aggregate.aiur @@ -0,0 +1,62 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module MultiStark { + fn ix_aggr(allowed_digest: [Field; 8], out_claim_digest: [Field; 8]) -> () { + + let (aidx, alen) = hint::<(Field, Field)>("stark.io.info", (3, 0)); + assert_eq!(alen, 80, + "aggr: allowed blob must be exactly 80 bytes"); + let allowed_bytes = StarkIO::read_byte_stream(3, aidx, alen); + assert_eq!(Blake3::pack_digest(Blake3::hash(allowed_bytes)), allowed_digest, + "aggr: allowed blob digest mismatch"); + let (ixvm_digest_addr, as1) = Aggregation::aggr_read_address(allowed_bytes); + let (verify_idx_limb, as2) = ProofDeserialize::read_u64(as1); + let (self_digest_addr, as3) = Aggregation::aggr_read_address(as2); + let (aggr_idx_limb, astop) = ProofDeserialize::read_u64(as3); + let Lists::Node::Nil = (*(astop)); + let ixvm_vk_digest = Aggregation::aggr_pack_address(ixvm_digest_addr); + let self_vk_digest = Aggregation::aggr_pack_address(self_digest_addr); + let verify_idx = UInt64::to_field(verify_idx_limb); + let aggr_idx = UInt64::to_field(aggr_idx_limb); + + let (hidx, hlen) = hint::<(Field, Field)>("stark.io.info", (6, 0)); + assert_eq!(hlen, 1, "aggr: shape hint must be exactly one byte"); + let hint = StarkIO::read_byte_stream(6, hidx, hlen); + let (shape, hstop) = Aggregation::aggr_read_byte(hint); + let Lists::Node::Nil = (*(hstop)); + match UInt8::to_field(shape) { + 0 => { Aggregation::aggr_wrap(0, ixvm_vk_digest, self_vk_digest, + verify_idx, aggr_idx, allowed_digest, out_claim_digest) } , + 1 => { Aggregation::aggr_wrap(1, ixvm_vk_digest, self_vk_digest, + verify_idx, aggr_idx, allowed_digest, out_claim_digest) } , + 2 => { Aggregation::aggr_pair(0, 0, ixvm_vk_digest, self_vk_digest, + verify_idx, aggr_idx, allowed_digest, out_claim_digest) } , + 3 => { Aggregation::aggr_pair(0, 1, ixvm_vk_digest, self_vk_digest, + verify_idx, aggr_idx, allowed_digest, out_claim_digest) } , + 4 => { Aggregation::aggr_pair(1, 0, ixvm_vk_digest, self_vk_digest, + verify_idx, aggr_idx, allowed_digest, out_claim_digest) } , + 5 => { Aggregation::aggr_pair(1, 1, ixvm_vk_digest, self_vk_digest, + verify_idx, aggr_idx, allowed_digest, out_claim_digest) } , + 6 => { Aggregation::aggr_pair_structural(0, 0, ixvm_vk_digest, self_vk_digest, + verify_idx, aggr_idx, allowed_digest, out_claim_digest) } , + 7 => { Aggregation::aggr_pair_structural(0, 1, ixvm_vk_digest, self_vk_digest, + verify_idx, aggr_idx, allowed_digest, out_claim_digest) } , + 8 => { Aggregation::aggr_pair_structural(1, 0, ixvm_vk_digest, self_vk_digest, + verify_idx, aggr_idx, allowed_digest, out_claim_digest) } , + 9 => { Aggregation::aggr_pair_structural(1, 1, ixvm_vk_digest, self_vk_digest, + verify_idx, aggr_idx, allowed_digest, out_claim_digest) } , + 10 => { Aggregation::aggr_range_leaf(ixvm_vk_digest, self_vk_digest, out_claim_digest) } , + 11 => { Aggregation::aggr_range_join(ixvm_vk_digest, self_vk_digest, + verify_idx, aggr_idx, allowed_digest, out_claim_digest) } , + 12 => { Aggregation::aggr_range_root(ixvm_vk_digest, self_vk_digest, + verify_idx, aggr_idx, allowed_digest, out_claim_digest) } , + 13 => { Aggregation::aggr_discharge_binding(0, ixvm_vk_digest, self_vk_digest, + verify_idx, aggr_idx, allowed_digest, out_claim_digest) } , + 14 => { Aggregation::aggr_discharge_binding(1, ixvm_vk_digest, self_vk_digest, + verify_idx, aggr_idx, allowed_digest, out_claim_digest) } , + 15 => { Aggregation::aggr_cross_binding(ixvm_vk_digest, self_vk_digest, + verify_idx, aggr_idx, allowed_digest, out_claim_digest) } , + 16 => { Aggregation::aggr_catalog_join(ixvm_vk_digest, self_vk_digest, + verify_idx, aggr_idx, allowed_digest, out_claim_digest) } , + } + } +} diff --git a/MultiStark/MultiStark/Aggregate.names.json b/MultiStark/MultiStark/Aggregate.names.json new file mode 100644 index 000000000..b44d19412 --- /dev/null +++ b/MultiStark/MultiStark/Aggregate.names.json @@ -0,0 +1,338 @@ +{ + "MultiStark::Addr": "Bytes::AddressRef", + "MultiStark::AggrNextAssumption": "Aggregation::AggrNextAssumption", + "MultiStark::Batch": "ProofDeserialize::Batch", + "MultiStark::BatchMessage": "ProofDeserialize::BatchMessage", + "MultiStark::BatchMultiOpening": "ProofDeserialize::BatchMultiOpening", + "MultiStark::BatchOpening": "ProofDeserialize::BatchOpening", + "MultiStark::Bucket": "Pcs::Bucket", + "MultiStark::ByteStream": "Bytes::Stream", + "MultiStark::CommitPhaseMultiStep": "ProofDeserialize::CommitPhaseMultiStep", + "MultiStark::CommitPhaseProofStep": "ProofDeserialize::CommitPhaseProofStep", + "MultiStark::Commitments": "ProofDeserialize::Commitments", + "MultiStark::Digest": "ProofDeserialize::Digest", + "MultiStark::DigestP": "ProofDeserialize::DigestP", + "MultiStark::Ext": "ProofDeserialize::Ext", + "MultiStark::ExtGoldilocks": "Goldilocks::ExtGoldilocks", + "MultiStark::FriProof": "ProofDeserialize::FriProof", + "MultiStark::FrontierNode": "Pcs::FrontierNode", + "MultiStark::Goldilocks": "Goldilocks::Goldilocks", + "MultiStark::Layer": "Blake3::Layer", + "MultiStark::List": "Lists::List", + "MultiStark::MerkleCap": "ProofDeserialize::MerkleCap", + "MultiStark::OpenedRound": "ProofDeserialize::OpenedRound", + "MultiStark::OptCommit": "SystemDeserialize::OptCommit", + "MultiStark::OptIdx": "SystemDeserialize::OptIdx", + "MultiStark::Option": "Options::Option", + "MultiStark::PreprocessedOpt": "ProofDeserialize::PreprocessedOpt", + "MultiStark::Proof": "ProofDeserialize::Proof", + "MultiStark::QueryProof": "ProofDeserialize::QueryProof", + "MultiStark::ShardHeader": "ProofDeserialize::ShardHeader", + "MultiStark::Sys": "SystemDeserialize::Sys", + "MultiStark::SysCircuit": "SystemDeserialize::SysCircuit", + "MultiStark::SysLookup": "SystemDeserialize::SysLookup", + "MultiStark::SysNode": "SystemDeserialize::SysNode", + "MultiStark::SysParams": "SystemDeserialize::SysParams", + "MultiStark::U32": "UInt32::U32", + "MultiStark::U64": "UInt64::U64", + "MultiStark::U8": "UInt8::U8", + "MultiStark::accs_onto": "StarkVerifier::accs_onto", + "MultiStark::active_onto": "StarkVerifier::active_onto", + "MultiStark::address_eq": "Bytes::address_eq", + "MultiStark::address_eq_tail": "Bytes::address_eq_tail", + "MultiStark::aggr_address_order": "Aggregation::aggr_address_order", + "MultiStark::aggr_assert_difference": "Aggregation::aggr_assert_difference", + "MultiStark::aggr_assert_digest": "Aggregation::aggr_assert_digest", + "MultiStark::aggr_assert_disjoint": "Aggregation::aggr_assert_disjoint", + "MultiStark::aggr_assert_disjoint_union": "Aggregation::aggr_assert_disjoint_union", + "MultiStark::aggr_assert_same_context": "Aggregation::aggr_assert_same_context", + "MultiStark::aggr_assert_same_list": "Aggregation::aggr_assert_same_list", + "MultiStark::aggr_assert_strict_sorted": "Aggregation::aggr_assert_strict_sorted", + "MultiStark::aggr_assert_structural_difference": "Aggregation::aggr_assert_structural_difference", + "MultiStark::aggr_assert_union": "Aggregation::aggr_assert_union", + "MultiStark::aggr_batch_challenges": "Aggregation::aggr_batch_challenges", + "MultiStark::aggr_binding_class": "Aggregation::aggr_binding_class", + "MultiStark::aggr_canonical_root": "Aggregation::aggr_canonical_root", + "MultiStark::aggr_catalog_join": "Aggregation::aggr_catalog_join", + "MultiStark::aggr_catalog_part": "Aggregation::aggr_catalog_part", + "MultiStark::aggr_child_check_env_digest": "Aggregation::aggr_child_check_env_digest", + "MultiStark::aggr_child_range": "Aggregation::aggr_child_range", + "MultiStark::aggr_claim_digest": "Aggregation::aggr_claim_digest", + "MultiStark::aggr_claim_field": "Aggregation::aggr_claim_field", + "MultiStark::aggr_class_walk": "Aggregation::aggr_class_walk", + "MultiStark::aggr_context_class": "Aggregation::aggr_context_class", + "MultiStark::aggr_cross_binding": "Aggregation::aggr_cross_binding", + "MultiStark::aggr_discharge_binding": "Aggregation::aggr_discharge_binding", + "MultiStark::aggr_discharge_choice": "Aggregation::aggr_discharge_choice", + "MultiStark::aggr_fold_path": "Aggregation::aggr_fold_path", + "MultiStark::aggr_get_opt_address": "Aggregation::aggr_get_opt_address", + "MultiStark::aggr_is_class_role": "Aggregation::aggr_is_class_role", + "MultiStark::aggr_leaf_hash": "Aggregation::aggr_leaf_hash", + "MultiStark::aggr_leaf_hashes": "Aggregation::aggr_leaf_hashes", + "MultiStark::aggr_load_canonical_tree": "Aggregation::aggr_load_canonical_tree", + "MultiStark::aggr_load_optional_tree": "Aggregation::aggr_load_optional_tree", + "MultiStark::aggr_load_preamble": "Aggregation::aggr_load_preamble", + "MultiStark::aggr_load_preimage": "Aggregation::aggr_load_preimage", + "MultiStark::aggr_load_sys": "Aggregation::aggr_load_sys", + "MultiStark::aggr_next_assumption": "Aggregation::aggr_next_assumption", + "MultiStark::aggr_node_hash": "Aggregation::aggr_node_hash", + "MultiStark::aggr_only_claim": "Aggregation::aggr_only_claim", + "MultiStark::aggr_opt_address_eq": "Aggregation::aggr_opt_address_eq", + "MultiStark::aggr_output_range": "Aggregation::aggr_output_range", + "MultiStark::aggr_pack_address": "Aggregation::aggr_pack_address", + "MultiStark::aggr_pack_be4": "Aggregation::aggr_pack_be4", + "MultiStark::aggr_pair": "Aggregation::aggr_pair", + "MultiStark::aggr_pair_hashes": "Aggregation::aggr_pair_hashes", + "MultiStark::aggr_pair_structural": "Aggregation::aggr_pair_structural", + "MultiStark::aggr_parse_binding": "Aggregation::aggr_parse_binding", + "MultiStark::aggr_parse_catalog": "Aggregation::aggr_parse_catalog", + "MultiStark::aggr_parse_check_env": "Aggregation::aggr_parse_check_env", + "MultiStark::aggr_parse_range": "Aggregation::aggr_parse_range", + "MultiStark::aggr_parse_tree_body": "Aggregation::aggr_parse_tree_body", + "MultiStark::aggr_put_address": "Aggregation::aggr_put_address", + "MultiStark::aggr_put_addresses": "Aggregation::aggr_put_addresses", + "MultiStark::aggr_range_join": "Aggregation::aggr_range_join", + "MultiStark::aggr_range_leaf": "Aggregation::aggr_range_leaf", + "MultiStark::aggr_range_root": "Aggregation::aggr_range_root", + "MultiStark::aggr_read_address": "Aggregation::aggr_read_address", + "MultiStark::aggr_read_bits_n": "Aggregation::aggr_read_bits_n", + "MultiStark::aggr_read_byte": "Aggregation::aggr_read_byte", + "MultiStark::aggr_read_bytes_n": "Aggregation::aggr_read_bytes_n", + "MultiStark::aggr_read_cap_n": "Aggregation::aggr_read_cap_n", + "MultiStark::aggr_read_digest": "Aggregation::aggr_read_digest", + "MultiStark::aggr_read_header": "Aggregation::aggr_read_header", + "MultiStark::aggr_read_headers_n": "Aggregation::aggr_read_headers_n", + "MultiStark::aggr_read_message": "Aggregation::aggr_read_message", + "MultiStark::aggr_read_messages_n": "Aggregation::aggr_read_messages_n", + "MultiStark::aggr_reduce_hashes": "Aggregation::aggr_reduce_hashes", + "MultiStark::aggr_seek_subject": "Aggregation::aggr_seek_subject", + "MultiStark::aggr_verify_child": "Aggregation::aggr_verify_child", + "MultiStark::aggr_verify_range": "Aggregation::aggr_verify_range", + "MultiStark::aggr_wrap": "Aggregation::aggr_wrap", + "MultiStark::assert_bits": "StarkVerifier::assert_bits", + "MultiStark::assert_blowup_zero": "Pcs::assert_blowup_zero", + "MultiStark::assert_closure_pairs": "StarkVerifier::assert_closure_pairs", + "MultiStark::assert_log_degrees_ok": "StarkVerifier::assert_log_degrees_ok", + "MultiStark::assert_same_bits": "StarkVerifier::assert_same_bits", + "MultiStark::assert_same_cap": "StarkVerifier::assert_same_cap", + "MultiStark::assert_same_claims": "StarkVerifier::assert_same_claims", + "MultiStark::assert_same_limbs": "StarkVerifier::assert_same_limbs", + "MultiStark::assert_same_u8s": "StarkVerifier::assert_same_u8s", + "MultiStark::assert_shard_count_ok": "StarkVerifier::assert_shard_count_ok", + "MultiStark::b3_flatten_onto": "StarkHash::b3_flatten_onto", + "MultiStark::b3_pack": "Blake3::pack_digest", + "MultiStark::b3_pack_w": "Blake3::pack_word", + "MultiStark::b3_rows": "StarkHash::b3_rows", + "MultiStark::b3_rows_chunks": "StarkHash::b3_rows_chunks", + "MultiStark::b3_to_digest": "StarkHash::b3_to_digest", + "MultiStark::b3_w4_onto": "StarkHash::b3_w4_onto", + "MultiStark::b8_onto": "StarkVerifier::b8_onto", + "MultiStark::batch_claims": "StarkVerifier::batch_claims", + "MultiStark::batch_fiat_shamir": "Transcript::batch_fiat_shamir", + "MultiStark::batch_views_at": "Pcs::batch_views_at", + "MultiStark::bits_to_num": "Pcs::bits_to_num", + "MultiStark::bucket_update": "Pcs::bucket_update", + "MultiStark::build_buckets": "Pcs::build_buckets", + "MultiStark::build_publics": "StarkVerifier::build_publics", + "MultiStark::bytes8_le": "StarkVerifier::bytes8_le", + "MultiStark::cap_onto": "StarkVerifier::cap_onto", + "MultiStark::ch_sample8": "Transcript::ch_sample8", + "MultiStark::ch_sample_bits": "Transcript::ch_sample_bits", + "MultiStark::ch_sample_ext": "Transcript::ch_sample_ext", + "MultiStark::ch_sample_field": "Transcript::ch_sample_field", + "MultiStark::circ_has_height": "Pcs::circ_has_height", + "MultiStark::claims_acc": "StarkVerifier::claims_acc", + "MultiStark::claims_onto": "StarkVerifier::claims_onto", + "MultiStark::claims_onto_each": "StarkVerifier::claims_onto_each", + "MultiStark::compress_ordered": "Pcs::compress_ordered", + "MultiStark::cons8": "StarkVerifier::cons8", + "MultiStark::cons_shape7": "SystemDeserialize::cons_shape7", + "MultiStark::count_ones": "StarkVerifier::count_ones", + "MultiStark::count_onto": "StarkVerifier::count_onto", + "MultiStark::digest_eq": "StarkHash::digest_eq", + "MultiStark::digest_onto": "StarkVerifier::digest_onto", + "MultiStark::drop_index_bits": "Pcs::drop_index_bits", + "MultiStark::eg_add": "Goldilocks::eg_add", + "MultiStark::eg_div": "Goldilocks::eg_div", + "MultiStark::eg_eq": "Goldilocks::eg_eq", + "MultiStark::eg_inverse": "Goldilocks::eg_inverse", + "MultiStark::eg_mul": "Goldilocks::eg_mul", + "MultiStark::eg_neg": "Goldilocks::eg_neg", + "MultiStark::eg_sub": "Goldilocks::eg_sub", + "MultiStark::eval_at": "StarkVerifier::eval_at", + "MultiStark::exp_by_bits": "Pcs::exp_by_bits", + "MultiStark::ext_exp_pow2": "StarkVerifier::ext_exp_pow2", + "MultiStark::ext_is_zero": "StarkVerifier::ext_is_zero", + "MultiStark::ext_row_onto": "Pcs::ext_row_onto", + "MultiStark::fingerprint_vals": "StarkVerifier::fingerprint_vals", + "MultiStark::flatten2": "Pcs::flatten2", + "MultiStark::fold_roots": "StarkVerifier::fold_roots", + "MultiStark::fri_fold2": "Pcs::fri_fold2", + "MultiStark::from_ext_basis": "StarkVerifier::from_ext_basis", + "MultiStark::frontier_fold": "Mmcs::frontier_fold", + "MultiStark::frontier_leaves": "Mmcs::frontier_leaves", + "MultiStark::frontier_level": "Mmcs::frontier_level", + "MultiStark::frontier_merge": "Mmcs::frontier_merge", + "MultiStark::frontier_sort": "Mmcs::frontier_sort", + "MultiStark::frontier_split": "Mmcs::frontier_split", + "MultiStark::gl_inverse": "Goldilocks::gl_inverse", + "MultiStark::gl_lt_p": "Goldilocks::gl_lt_p", + "MultiStark::gl_to_bytes": "Goldilocks::gl_to_bytes", + "MultiStark::gl_val": "Goldilocks::gl_val", + "MultiStark::glist_rev": "Pcs::glist_rev", + "MultiStark::has_height": "Pcs::has_height", + "MultiStark::header_onto": "StarkVerifier::header_onto", + "MultiStark::headers_onto": "StarkVerifier::headers_onto", + "MultiStark::heights_all": "Pcs::heights_all", + "MultiStark::heights_max": "Pcs::heights_max", + "MultiStark::heights_prep": "Pcs::heights_prep", + "MultiStark::inject_maybe": "Pcs::inject_maybe", + "MultiStark::ix_aggr": "MultiStark::ix_aggr", + "MultiStark::last_acc": "StarkVerifier::last_acc", + "MultiStark::le_step": "StarkVerifier::le_step", + "MultiStark::leaf_hash_at": "Pcs::leaf_hash_at", + "MultiStark::limb_to_field": "ProofDeserialize::limb_to_field", + "MultiStark::limbs_onto": "StarkVerifier::limbs_onto", + "MultiStark::list_concat": "Lists::concat", + "MultiStark::list_drop": "Lists::drop", + "MultiStark::list_length": "Lists::length", + "MultiStark::list_lookup": "Lists::lookup", + "MultiStark::log_degree_ok": "StarkVerifier::log_degree_ok", + "MultiStark::log_degrees_onto": "StarkVerifier::log_degrees_onto", + "MultiStark::logup_fingerprint": "StarkVerifier::logup_fingerprint", + "MultiStark::logup_steps_fold": "StarkVerifier::logup_steps_fold", + "MultiStark::lookup_groups_count": "SystemDeserialize::lookup_groups_count", + "MultiStark::messages_acc": "StarkVerifier::messages_acc", + "MultiStark::messages_onto": "StarkVerifier::messages_onto", + "MultiStark::messages_onto_each": "StarkVerifier::messages_onto_each", + "MultiStark::mmcs_compress": "Mmcs::mmcs_compress", + "MultiStark::mmcs_verify_multi": "Mmcs::mmcs_verify_multi", + "MultiStark::obs_log_arities": "Pcs::obs_log_arities", + "MultiStark::ood_composition": "StarkVerifier::ood_composition", + "MultiStark::ood_fold": "StarkVerifier::ood_fold", + "MultiStark::ood_loop": "StarkVerifier::ood_loop", + "MultiStark::ood_prep_rows": "StarkVerifier::ood_prep_rows", + "MultiStark::open_2pt_mat": "Pcs::open_2pt_mat", + "MultiStark::open_batch_2pt": "Pcs::open_batch_2pt", + "MultiStark::open_prep": "Pcs::open_prep", + "MultiStark::open_prep_batch": "Pcs::open_prep_batch", + "MultiStark::open_quotient": "Pcs::open_quotient", + "MultiStark::opt_commit_cap": "StarkVerifier::opt_commit_cap", + "MultiStark::pair_mul": "StarkVerifier::pair_mul", + "MultiStark::pcs_betas": "Pcs::pcs_betas", + "MultiStark::pcs_check_witness": "Pcs::pcs_check_witness", + "MultiStark::pcs_fri_verify": "Pcs::pcs_fri_verify", + "MultiStark::points_onto": "Pcs::points_onto", + "MultiStark::pow2": "StarkVerifier::pow2", + "MultiStark::prep_count": "Pcs::prep_count", + "MultiStark::prep_onto": "Pcs::prep_onto", + "MultiStark::query_loop": "Pcs::query_loop", + "MultiStark::query_views": "Pcs::query_views", + "MultiStark::quotient_degree_of": "StarkVerifier::quotient_degree_of", + "MultiStark::quotient_eval": "StarkVerifier::quotient_eval", + "MultiStark::read_active": "ProofDeserialize::read_active", + "MultiStark::read_active_n": "ProofDeserialize::read_active_n", + "MultiStark::read_batch": "ProofDeserialize::read_batch", + "MultiStark::read_batch_opening": "ProofDeserialize::read_batch_opening", + "MultiStark::read_batch_opening_vec": "ProofDeserialize::read_batch_opening_vec", + "MultiStark::read_batch_opening_vec_n": "ProofDeserialize::read_batch_opening_vec_n", + "MultiStark::read_byte_stream": "StarkIO::read_byte_stream", + "MultiStark::read_claim_vals_n": "StarkVerifier::read_claim_vals_n", + "MultiStark::read_claims": "StarkVerifier::read_claims", + "MultiStark::read_claims_n": "StarkVerifier::read_claims_n", + "MultiStark::read_commit_phase_step": "ProofDeserialize::read_commit_phase_step", + "MultiStark::read_commit_phase_step_vec": "ProofDeserialize::read_commit_phase_step_vec", + "MultiStark::read_commit_phase_step_vec_n": "ProofDeserialize::read_commit_phase_step_vec_n", + "MultiStark::read_commitments": "ProofDeserialize::read_commitments", + "MultiStark::read_count": "ProofDeserialize::read_count", + "MultiStark::read_count_at": "ProofDeserialize::read_count_at", + "MultiStark::read_digest_at": "ProofDeserialize::read_digest_at", + "MultiStark::read_digest_vec_at": "ProofDeserialize::read_digest_vec_at", + "MultiStark::read_digest_vec_at_n": "ProofDeserialize::read_digest_vec_at_n", + "MultiStark::read_ext_at": "ProofDeserialize::read_ext_at", + "MultiStark::read_ext_vec": "ProofDeserialize::read_ext_vec", + "MultiStark::read_ext_vec_n": "ProofDeserialize::read_ext_vec_n", + "MultiStark::read_ext_vec_vec": "ProofDeserialize::read_ext_vec_vec", + "MultiStark::read_ext_vec_vec_n": "ProofDeserialize::read_ext_vec_vec_n", + "MultiStark::read_field": "SystemDeserialize::read_field", + "MultiStark::read_fri_proof": "ProofDeserialize::read_fri_proof", + "MultiStark::read_header": "ProofDeserialize::read_header", + "MultiStark::read_header_vec": "ProofDeserialize::read_header_vec", + "MultiStark::read_header_vec_n": "ProofDeserialize::read_header_vec_n", + "MultiStark::read_merkle_cap_at": "ProofDeserialize::read_merkle_cap_at", + "MultiStark::read_merkle_cap_vec": "ProofDeserialize::read_merkle_cap_vec", + "MultiStark::read_merkle_cap_vec_n": "ProofDeserialize::read_merkle_cap_vec_n", + "MultiStark::read_message": "ProofDeserialize::read_message", + "MultiStark::read_message_vec": "ProofDeserialize::read_message_vec", + "MultiStark::read_message_vec_n": "ProofDeserialize::read_message_vec_n", + "MultiStark::read_node_ids_n": "SystemDeserialize::read_node_ids_n", + "MultiStark::read_nodes_n": "SystemDeserialize::read_nodes_n", + "MultiStark::read_one_claim": "StarkVerifier::read_one_claim", + "MultiStark::read_opened_round": "ProofDeserialize::read_opened_round", + "MultiStark::read_opened_round_n": "ProofDeserialize::read_opened_round_n", + "MultiStark::read_opt_commit": "SystemDeserialize::read_opt_commit", + "MultiStark::read_opt_idx_n": "SystemDeserialize::read_opt_idx_n", + "MultiStark::read_preprocessed": "ProofDeserialize::read_preprocessed", + "MultiStark::read_proof": "ProofDeserialize::read_proof", + "MultiStark::read_proof_vec": "ProofDeserialize::read_proof_vec", + "MultiStark::read_proof_vec_n": "ProofDeserialize::read_proof_vec_n", + "MultiStark::read_sys_circuit": "SystemDeserialize::read_sys_circuit", + "MultiStark::read_sys_circuits_n": "SystemDeserialize::read_sys_circuits_n", + "MultiStark::read_sys_lookup": "SystemDeserialize::read_sys_lookup", + "MultiStark::read_sys_lookups_n": "SystemDeserialize::read_sys_lookups_n", + "MultiStark::read_sys_params": "SystemDeserialize::read_sys_params", + "MultiStark::read_system": "SystemDeserialize::read_system", + "MultiStark::read_u64": "ProofDeserialize::read_u64", + "MultiStark::read_u64_at": "ProofDeserialize::read_u64_at", + "MultiStark::read_u64_vec": "ProofDeserialize::read_u64_vec", + "MultiStark::read_u64_vec_n": "ProofDeserialize::read_u64_vec_n", + "MultiStark::read_u64_vec_vec": "ProofDeserialize::read_u64_vec_vec", + "MultiStark::read_u64_vec_vec_n": "ProofDeserialize::read_u64_vec_vec_n", + "MultiStark::read_u64_vec_vec_vec": "ProofDeserialize::read_u64_vec_vec_vec", + "MultiStark::read_u64_vec_vec_vec_n": "ProofDeserialize::read_u64_vec_vec_vec_n", + "MultiStark::read_u8": "ProofDeserialize::read_u8", + "MultiStark::read_u8_at": "ProofDeserialize::read_u8_at", + "MultiStark::read_u8_vec": "ProofDeserialize::read_u8_vec", + "MultiStark::read_u8_vec_n": "ProofDeserialize::read_u8_vec_n", + "MultiStark::read_vk_cap_n": "SystemDeserialize::read_vk_cap_n", + "MultiStark::read_vk_digest": "SystemDeserialize::read_vk_digest", + "MultiStark::read_vk_tag": "SystemDeserialize::read_vk_tag", + "MultiStark::read_vk_u16": "SystemDeserialize::read_vk_u16", + "MultiStark::read_vk_u16_limb": "SystemDeserialize::read_vk_u16_limb", + "MultiStark::read_vk_u32_limb": "SystemDeserialize::read_vk_u32_limb", + "MultiStark::read_vk_u64": "SystemDeserialize::read_vk_u64", + "MultiStark::read_vk_u8": "SystemDeserialize::read_vk_u8", + "MultiStark::recon_evals": "Pcs::recon_evals", + "MultiStark::reconstruct_ext_row": "StarkVerifier::reconstruct_ext_row", + "MultiStark::rev_onto": "StarkVerifier::rev_onto", + "MultiStark::ri_apply": "Pcs::ri_apply", + "MultiStark::ro_fold": "Pcs::ro_fold", + "MultiStark::ro_x": "Pcs::ro_x", + "MultiStark::rollin": "Pcs::rollin", + "MultiStark::round_onto": "Pcs::round_onto", + "MultiStark::rows_at_round": "Pcs::rows_at_round", + "MultiStark::rows_pop": "Pcs::rows_pop", + "MultiStark::sample_query_indices": "Pcs::sample_query_indices", + "MultiStark::seed_tag_onto": "StarkVerifier::seed_tag_onto", + "MultiStark::select_active_circuits": "StarkVerifier::select_active_circuits", + "MultiStark::select_active_prep": "StarkVerifier::select_active_prep", + "MultiStark::select_rows": "Pcs::select_rows", + "MultiStark::select_rows_le": "Pcs::select_rows_le", + "MultiStark::shard_fiat_shamir": "Transcript::shard_fiat_shamir", + "MultiStark::snoc_b8": "StarkVerifier::snoc_b8", + "MultiStark::snoc_cap": "StarkVerifier::snoc_cap", + "MultiStark::step_views_at": "Pcs::step_views_at", + "MultiStark::take_bits": "StarkVerifier::take_bits", + "MultiStark::three_limbs": "StarkVerifier::three_limbs", + "MultiStark::trace_selectors": "StarkVerifier::trace_selectors", + "MultiStark::trace_vanishing": "StarkVerifier::trace_vanishing", + "MultiStark::two_adic_gen": "StarkVerifier::two_adic_gen", + "MultiStark::verify_batch": "StarkVerifier::verify_batch", + "MultiStark::verify_batch_at": "StarkVerifier::verify_batch_at", + "MultiStark::verify_commit_multi": "Pcs::verify_commit_multi", + "MultiStark::verify_input_multi": "Pcs::verify_input_multi", + "MultiStark::verify_one_query": "Pcs::verify_one_query", + "MultiStark::verify_query": "Pcs::verify_query", + "MultiStark::verify_shard": "StarkVerifier::verify_shard", + "MultiStark::verify_shards": "StarkVerifier::verify_shards" +} diff --git a/MultiStark/MultiStark/Aggregate.sources b/MultiStark/MultiStark/Aggregate.sources new file mode 100644 index 000000000..2c1330650 --- /dev/null +++ b/MultiStark/MultiStark/Aggregate.sources @@ -0,0 +1,11 @@ +# Ordered Aiur source bundle; paths are relative to this file. +Modules/ProofDeserialize.aiur +Modules/SystemDeserialize.aiur +Modules/Pcs.aiur +Modules/Aggregation.aiur +Modules/StarkIO.aiur +Modules/StarkHash.aiur +Modules/Mmcs.aiur +Modules/StarkVerifier.aiur +Modules/Transcript.aiur +Aggregate.aiur diff --git a/MultiStark/MultiStark/Compatibility.aiur b/MultiStark/MultiStark/Compatibility.aiur new file mode 100644 index 000000000..70a2473eb --- /dev/null +++ b/MultiStark/MultiStark/Compatibility.aiur @@ -0,0 +1,15 @@ +// Goldilocks arithmetic uses ordinary field operations and checked advice. +// Opaque library bytes/words can only be produced by their checked constructors. +type U8 = UInt8::U8; +type U32 = UInt32::U32; +inline fn store(value: T) -> &T { &value } +inline fn load(pointer: &T) -> T { *pointer } + +// Merkle equality is equality of all 256 digest bits, not equality modulo p +// or equality of prover-selected memory addresses. +fn digest_eq(ap: DigestP, bp: DigestP) -> Field { + let a = load(ap); + let b = load(bp); + UInt64::eq(a[0], b[0]) * UInt64::eq(a[1], b[1]) * + UInt64::eq(a[2], b[2]) * UInt64::eq(a[3], b[3]) +} diff --git a/MultiStark/MultiStark/FunctionGroups.lean b/MultiStark/MultiStark/FunctionGroups.lean new file mode 100644 index 000000000..1b795338e --- /dev/null +++ b/MultiStark/MultiStark/FunctionGroups.lean @@ -0,0 +1,51 @@ +/-! Grouping tuned for the certified Aiur layout using measured small and +production workloads. The search accounts for padded rows, main/auxiliary +columns and FFT work; see docs/formal-aiur-grouping-tuning.md. +Physical deduplication is resolved before grouping. Missing/inlined members +are skipped, and entrypoints retain singleton circuits. -/ + +namespace MultiStark + +def functionGroups : List (String × List String) := [ + ("verifier_group_00", ["StarkIO::read_byte_stream", "SystemDeserialize::read_vk_u16", "StarkVerifier::rev_onto"]), + ("verifier_group_01", ["Blake3::compress_layer", "Blake3::finish", "SystemDeserialize::read_vk_u64", "StarkVerifier::active_onto", "StarkHash::digest_eq"]), + ("verifier_group_02", ["Blake3::next_layer", "StarkVerifier::assert_closure_pairs", "StarkVerifier::verify_shard", "StarkVerifier::ood_loop", "Pcs::verify_query", "Pcs::verify_commit_multi", "StarkVerifier::last_acc"]), + ("verifier_group_03", ["UInt64::is_zero", "ProofDeserialize::read_merkle_cap_vec_n", "StarkVerifier::messages_onto_each", "StarkVerifier::messages_acc", "Pcs::obs_log_arities", "Pcs::verify_input_multi", "Pcs::assert_blowup_zero", "${\"name\":\"Lists::length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"Pcs::Bucket\"}}]}"]), + ("verifier_group_04", ["Blake3::bytes_to_block", "ProofDeserialize::read_digest_vec_at_n", "Transcript::batch_fiat_shamir", "Transcript::shard_fiat_shamir", "StarkVerifier::logup_steps_fold"]), + ("verifier_group_05", ["Blake3::compress_block", "StarkVerifier::cap_onto", "StarkHash::b3_rows_chunks", "Pcs::open_prep"]), + ("verifier_group_06", ["${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}", "StarkVerifier::accs_onto", "Pcs::select_rows_le", "Pcs::inject_maybe"]), + ("verifier_group_07", ["UInt64::wrapping_succ", "SystemDeserialize::read_vk_cap_n", "StarkVerifier::three_limbs", "StarkVerifier::bytes8_le", "StarkVerifier::le_step", "StarkVerifier::assert_same_cap", "Pcs::pcs_betas", "Pcs::pcs_check_witness", "Pcs::heights_prep", "Pcs::fri_fold2"]), + ("verifier_group_08", ["SystemDeserialize::read_vk_u16_limb", "${\"name\":\"Lists::drop\",\"types\":[\"field\"]}"]), + ("verifier_group_09", ["SystemDeserialize::read_sys_circuits_n", "ProofDeserialize::read_proof", "StarkVerifier::log_degree_ok", "Mmcs::mmcs_compress", "Pcs::verify_one_query"]), + ("verifier_group_10", ["SystemDeserialize::read_vk_u32_limb", "SystemDeserialize::read_field", "SystemDeserialize::read_sys_lookups_n", "ProofDeserialize::read_batch_opening_vec_n", "StarkVerifier::claims_onto", "StarkVerifier::claims_onto_each", "StarkVerifier::snoc_b8", "StarkVerifier::reconstruct_ext_row", "Pcs::prep_count"]), + ("verifier_group_11", ["UInt32::less_than_fields", "Pcs::select_rows"]), + ("verifier_group_12", ["SystemDeserialize::lookup_groups_count", "SystemDeserialize::read_opt_idx_n", "StarkVerifier::read_claims_n", "StarkVerifier::log_degrees_onto"]), + ("verifier_group_13", ["SystemDeserialize::read_opt_commit", "ProofDeserialize::read_header_vec_n", "ProofDeserialize::read_message_vec_n", "StarkVerifier::select_active_circuits", "StarkVerifier::quotient_eval", "Pcs::rollin"]), + ("verifier_group_14", ["${\"name\":\"Lists::concat\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", "ProofDeserialize::read_active_n", "ProofDeserialize::read_ext_vec", "${\"name\":\"Lists::length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"ProofDeserialize::BatchMessage\"}}]}", "Pcs::heights_all", "Mmcs::frontier_fold"]), + ("verifier_group_15", ["ProofDeserialize::read_count", "ProofDeserialize::read_proof_vec_n", "StarkVerifier::assert_shard_count_ok", "${\"name\":\"Lists::length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"ProofDeserialize::ShardHeader\"}}]}", "${\"name\":\"Lists::length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"ProofDeserialize::Proof\"}}]}", "StarkVerifier::claims_acc", "StarkVerifier::pow2", "${\"name\":\"Lists::length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"ProofDeserialize::CommitPhaseMultiStep\"}}]}", "Pcs::build_buckets"]), + ("verifier_group_16", ["ProofDeserialize::read_u64", "Pcs::ri_apply"]), + ("verifier_group_17", ["ProofDeserialize::read_u8", "ProofDeserialize::read_u8_at"]), + ("verifier_group_18", ["UInt64::to_field", "StarkVerifier::read_claim_vals_n", "ProofDeserialize::read_digest_vec_at", "StarkVerifier::headers_onto", "StarkVerifier::assert_same_bits", "StarkVerifier::snoc_cap", "Pcs::bits_to_num", "Pcs::has_height"]), + ("verifier_group_19", ["ProofDeserialize::read_count_at", "ProofDeserialize::read_u64_at"]), + ("verifier_group_20", ["ProofDeserialize::read_u64_vec", "ProofDeserialize::read_u64_vec_n", "${\"name\":\"Lists::lookup\",\"types\":[\"field\"]}"]), + ("verifier_group_21", ["ProofDeserialize::read_ext_vec_n", "ProofDeserialize::read_ext_vec_vec_n", "StarkVerifier::fingerprint_vals"]), + ("verifier_group_22", ["ProofDeserialize::read_u64_vec_vec_vec_n", "${\"name\":\"Lists::length\",\"types\":[\"field\"]}", "StarkHash::b3_w4_onto", "Pcs::batch_views_at"]), + ("verifier_group_23", ["ProofDeserialize::read_commit_phase_step_vec_n", "StarkVerifier::select_active_prep", "StarkVerifier::ext_exp_pow2", "Pcs::heights_max", "Pcs::drop_index_bits"]), + ("verifier_group_24", ["ProofDeserialize::read_ext_vec_vec", "ProofDeserialize::read_opened_round_n", "StarkVerifier::messages_onto", "StarkVerifier::assert_bits", "StarkVerifier::assert_log_degrees_ok", "StarkVerifier::count_ones"]), + ("verifier_group_25", ["ProofDeserialize::read_opened_round", "StarkVerifier::pair_mul", "Pcs::round_onto", "Pcs::compress_ordered"]), + ("verifier_group_26", ["ProofDeserialize::read_preprocessed", "StarkVerifier::verify_batch", "Pcs::leaf_hash_at", "Mmcs::frontier_level", "Pcs::circ_has_height", "Pcs::rows_at_round"]), + ("verifier_group_27", ["StarkVerifier::count_onto", "Mmcs::frontier_merge", "Pcs::open_prep_batch", "StarkVerifier::batch_claims"]), + ("verifier_group_28", ["${\"name\":\"Lists::length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", "${\"name\":\"Lists::lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"SystemDeserialize::SysNode\"}}]}"]), + ("verifier_group_29", ["StarkVerifier::limbs_onto", "Mmcs::frontier_sort", "Mmcs::frontier_split", "Mmcs::frontier_leaves"]), + ("verifier_group_30", ["StarkVerifier::header_onto", "Transcript::ch_sample8", "StarkVerifier::verify_shards", "StarkVerifier::quotient_degree_of", "Mmcs::mmcs_verify_multi"]), + ("verifier_group_31", ["Transcript::ch_sample_ext", "Transcript::ch_sample_field", "Pcs::query_loop"]), + ("verifier_group_32", ["${\"name\":\"Lists::length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", "Pcs::sample_query_indices", "Pcs::query_views", "Pcs::step_views_at"]), + ("verifier_group_33", ["UInt64::eq", "${\"name\":\"Lists::drop\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}"]), + ("verifier_group_34", ["${\"name\":\"Lists::lookup\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", "StarkVerifier::fold_roots", "StarkVerifier::logup_fingerprint", "Pcs::open_batch_2pt", "Pcs::open_2pt_mat", "Pcs::open_quotient"]), + ("verifier_group_35", ["StarkVerifier::eval_at", "StarkVerifier::assert_same_limbs"]), + ("verifier_group_36", ["${\"name\":\"Lists::drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"SystemDeserialize::SysNode\"}}]}", "StarkVerifier::ood_fold"]), + ("verifier_group_37", ["StarkVerifier::from_ext_basis", "Pcs::points_onto", "StarkVerifier::assert_same_claims", "Pcs::exp_by_bits"]), + ("verifier_group_38", ["Pcs::bucket_update", "Pcs::ro_fold"]), +] + +end MultiStark diff --git a/MultiStark/MultiStark/Main.lean b/MultiStark/MultiStark/Main.lean new file mode 100644 index 000000000..b35e96f86 --- /dev/null +++ b/MultiStark/MultiStark/Main.lean @@ -0,0 +1,52 @@ +import MultiStark +import MultiStark.FunctionGroups +import Aiur.Execution.Encode +import Aiur.Trace.Export +import Aiur.SourceBundle +import Aiur.Optimized.Grouping.Snapshot + +open Aiur Lean + +private instance : ToJson MultiStark.F := ⟨fun x => toJson x.val⟩ + +unsafe def main (args : List String) : IO Unit := do + let groups := if args.contains "--ungrouped" then [] else MultiStark.functionGroups + let mode := args.headD "check" + unless ["check", "export", "export-trace", "grouping-snapshot"].contains mode do + throw (IO.userError "usage: stark-export check|export|export-trace|grouping-snapshot [output.json] [--aggregate]") + let aggregate := args.contains "--aggregate" + let file := if aggregate then "Aggregate.sources" else "Program.sources" + let sourcePath ← [s!"MultiStark/{file}", s!"MultiStark/MultiStark/{file}"].findM? + fun path => (System.FilePath.mk path).pathExists + let some sourcePath := sourcePath | throw (IO.userError "cannot locate MultiStark source bundle") + initSearchPath (← findSysroot) + enableInitializersExecution + let env ← importModules (loadExts := true) #[{module := `Aiur.Modules.Frontend}] {} 0 + IO.eprintln "Parsing and checking recursive verifier..." + let source ← IO.ofExcept (MultiStark.parse env (← SourceBundle.read sourcePath)) + let entry := if aggregate then "MultiStark::ix_aggr" else "MultiStark::verify_multi_stark_proof" + let prepared ← IO.ofExcept (Modules.prepare source [entry]) + IO.eprintln "Compiling recursive verifier bytecode..." + let exported ← IO.ofExcept prepared.exportExecution + IO.eprintln s!"Exported {exported.bytecode.functions.length} functions." + if mode == "check" then return + if mode == "grouping-snapshot" then + let compiled ← IO.ofExcept (prepared.compileOptimized {}) + let physical ← IO.ofExcept (Optimized.Physical.prepare compiled.circuit.artifact) + let snapshot := Optimized.Grouping.Snapshot.capture compiled.circuit.artifact physical + (exported.bytecode.functions.map (·.name) ++ exported.bytecode.maps.map (·.name)) groups + let path := args[1]?.getD "/tmp/verifier-grouping.json" + IO.FS.writeFile path (toJson snapshot).compress + IO.eprintln s!"Wrote grouping snapshot {path}" + return + let program ← IO.ofExcept (exported.toJson MultiStark.modulus ZMod.val) + let trace ← if mode == "export-trace" then do + IO.eprintln "Compiling certified circuits and witness population plans..." + let compiled ← IO.ofExcept (prepared.compileOptimized {}) + pure <| some (← IO.ofExcept (Trace.exportJson MultiStark.modulus ZMod.val + compiled.circuit.inlined.program compiled.circuit.artifact exported.bytecode groups)) + else pure none + let package := Json.mkObj ([("program", program)] ++ trace.toList.map ("trace", ·)) + let path := args[1]?.getD "/tmp/ix-recursion.json" + IO.FS.writeFile path package.compress + IO.eprintln s!"Wrote {path}" diff --git a/MultiStark/MultiStark/Modules/Aggregation.aiur b/MultiStark/MultiStark/Modules/Aggregation.aiur new file mode 100644 index 000000000..51077cfa7 --- /dev/null +++ b/MultiStark/MultiStark/Modules/Aggregation.aiur @@ -0,0 +1,1096 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module Aggregation { + enum AggrNextAssumption { + Done, + More(Bytes::AddressRef, Field, Lists::List, Lists::List) + } + + fn aggr_read_byte(stream: Bytes::Stream) -> (UInt8::U8, Bytes::Stream) { + let Lists::Node::Cons(byte, rest) = (*(stream)); + (byte, rest) + } + + fn aggr_read_address(stream: Bytes::Stream) -> (Bytes::AddressRef, Bytes::Stream) { + let Lists::Node::Cons(b0, s) = (*(stream)); + let Lists::Node::Cons(b1, s) = (*(s)); + let Lists::Node::Cons(b2, s) = (*(s)); + let Lists::Node::Cons(b3, s) = (*(s)); + let Lists::Node::Cons(b4, s) = (*(s)); + let Lists::Node::Cons(b5, s) = (*(s)); + let Lists::Node::Cons(b6, s) = (*(s)); + let Lists::Node::Cons(b7, s) = (*(s)); + let Lists::Node::Cons(b8, s) = (*(s)); + let Lists::Node::Cons(b9, s) = (*(s)); + let Lists::Node::Cons(b10, s) = (*(s)); + let Lists::Node::Cons(b11, s) = (*(s)); + let Lists::Node::Cons(b12, s) = (*(s)); + let Lists::Node::Cons(b13, s) = (*(s)); + let Lists::Node::Cons(b14, s) = (*(s)); + let Lists::Node::Cons(b15, s) = (*(s)); + let Lists::Node::Cons(b16, s) = (*(s)); + let Lists::Node::Cons(b17, s) = (*(s)); + let Lists::Node::Cons(b18, s) = (*(s)); + let Lists::Node::Cons(b19, s) = (*(s)); + let Lists::Node::Cons(b20, s) = (*(s)); + let Lists::Node::Cons(b21, s) = (*(s)); + let Lists::Node::Cons(b22, s) = (*(s)); + let Lists::Node::Cons(b23, s) = (*(s)); + let Lists::Node::Cons(b24, s) = (*(s)); + let Lists::Node::Cons(b25, s) = (*(s)); + let Lists::Node::Cons(b26, s) = (*(s)); + let Lists::Node::Cons(b27, s) = (*(s)); + let Lists::Node::Cons(b28, s) = (*(s)); + let Lists::Node::Cons(b29, s) = (*(s)); + let Lists::Node::Cons(b30, s) = (*(s)); + let Lists::Node::Cons(b31, s) = (*(s)); + ((&([b0, b1, b2, b3, b4, b5, b6, b7, + b8, b9, b10, b11, b12, b13, b14, b15, + b16, b17, b18, b19, b20, b21, b22, b23, + b24, b25, b26, b27, b28, b29, b30, b31])), s) + } + + fn aggr_put_address(addr: Bytes::AddressRef, rest: Bytes::Stream) -> Bytes::Stream { + let a = (*(addr)); + let s31 = (&(Lists::Node::Cons(a[31], rest))); + let s30 = (&(Lists::Node::Cons(a[30], s31))); + let s29 = (&(Lists::Node::Cons(a[29], s30))); + let s28 = (&(Lists::Node::Cons(a[28], s29))); + let s27 = (&(Lists::Node::Cons(a[27], s28))); + let s26 = (&(Lists::Node::Cons(a[26], s27))); + let s25 = (&(Lists::Node::Cons(a[25], s26))); + let s24 = (&(Lists::Node::Cons(a[24], s25))); + let s23 = (&(Lists::Node::Cons(a[23], s24))); + let s22 = (&(Lists::Node::Cons(a[22], s23))); + let s21 = (&(Lists::Node::Cons(a[21], s22))); + let s20 = (&(Lists::Node::Cons(a[20], s21))); + let s19 = (&(Lists::Node::Cons(a[19], s20))); + let s18 = (&(Lists::Node::Cons(a[18], s19))); + let s17 = (&(Lists::Node::Cons(a[17], s18))); + let s16 = (&(Lists::Node::Cons(a[16], s17))); + let s15 = (&(Lists::Node::Cons(a[15], s16))); + let s14 = (&(Lists::Node::Cons(a[14], s15))); + let s13 = (&(Lists::Node::Cons(a[13], s14))); + let s12 = (&(Lists::Node::Cons(a[12], s13))); + let s11 = (&(Lists::Node::Cons(a[11], s12))); + let s10 = (&(Lists::Node::Cons(a[10], s11))); + let s9 = (&(Lists::Node::Cons(a[9], s10))); + let s8 = (&(Lists::Node::Cons(a[8], s9))); + let s7 = (&(Lists::Node::Cons(a[7], s8))); + let s6 = (&(Lists::Node::Cons(a[6], s7))); + let s5 = (&(Lists::Node::Cons(a[5], s6))); + let s4 = (&(Lists::Node::Cons(a[4], s5))); + let s3 = (&(Lists::Node::Cons(a[3], s4))); + let s2 = (&(Lists::Node::Cons(a[2], s3))); + let s1 = (&(Lists::Node::Cons(a[1], s2))); + (&(Lists::Node::Cons(a[0], s1))) + } + + fn aggr_pack_address(addr: Bytes::AddressRef) -> [Field; 8] { + let a = (*(addr)); + [Blake3::pack_word(UInt32::from_bytes([a[0], a[1], a[2], a[3]])), + Blake3::pack_word(UInt32::from_bytes([a[4], a[5], a[6], a[7]])), + Blake3::pack_word(UInt32::from_bytes([a[8], a[9], a[10], a[11]])), + Blake3::pack_word(UInt32::from_bytes([a[12], a[13], a[14], a[15]])), + Blake3::pack_word(UInt32::from_bytes([a[16], a[17], a[18], a[19]])), + Blake3::pack_word(UInt32::from_bytes([a[20], a[21], a[22], a[23]])), + Blake3::pack_word(UInt32::from_bytes([a[24], a[25], a[26], a[27]])), + Blake3::pack_word(UInt32::from_bytes([a[28], a[29], a[30], a[31]]))] + } + + fn aggr_node_hash(left: Bytes::AddressRef, right: Bytes::AddressRef) -> Bytes::AddressRef { + let tail = aggr_put_address(left, + aggr_put_address(right, (&(Lists::Node::Nil)))); + Blake3::bytes_to_addr((&(Lists::Node::Cons(UInt8::BYTE_1, tail)))) + } + + fn aggr_leaf_hash(addr: Bytes::AddressRef) -> Bytes::AddressRef { + let tail = aggr_put_address(addr, (&(Lists::Node::Nil))); + Blake3::bytes_to_addr((&(Lists::Node::Cons(UInt8::BYTE_0, tail)))) + } + + inline fn aggr_pack_be4(a: UInt8::U8, b: UInt8::U8, c: UInt8::U8, d: UInt8::U8) -> Field { + ((UInt8::to_field(a) * 256 + UInt8::to_field(b)) * 256 + UInt8::to_field(c)) * 256 + + UInt8::to_field(d) + } + + fn aggr_address_order(a: Bytes::AddressRef, b: Bytes::AddressRef) -> Field { + let av = (*(a)); + let bv = (*(b)); + let aw0 = aggr_pack_be4(av[0], av[1], av[2], av[3]); + let bw0 = aggr_pack_be4(bv[0], bv[1], bv[2], bv[3]); + match aw0 - bw0 { + 0 => { + let aw1 = aggr_pack_be4(av[4], av[5], av[6], av[7]); + let bw1 = aggr_pack_be4(bv[4], bv[5], bv[6], bv[7]); + match aw1 - bw1 { + 0 => { + let aw2 = aggr_pack_be4(av[8], av[9], av[10], av[11]); + let bw2 = aggr_pack_be4(bv[8], bv[9], bv[10], bv[11]); + match aw2 - bw2 { + 0 => { + let aw3 = aggr_pack_be4(av[12], av[13], av[14], av[15]); + let bw3 = aggr_pack_be4(bv[12], bv[13], bv[14], bv[15]); + match aw3 - bw3 { + 0 => { + let aw4 = aggr_pack_be4(av[16], av[17], av[18], av[19]); + let bw4 = aggr_pack_be4(bv[16], bv[17], bv[18], bv[19]); + match aw4 - bw4 { + 0 => { + let aw5 = aggr_pack_be4(av[20], av[21], av[22], av[23]); + let bw5 = aggr_pack_be4(bv[20], bv[21], bv[22], bv[23]); + match aw5 - bw5 { + 0 => { + let aw6 = aggr_pack_be4(av[24], av[25], av[26], av[27]); + let bw6 = aggr_pack_be4(bv[24], bv[25], bv[26], bv[27]); + match aw6 - bw6 { + 0 => { + let aw7 = aggr_pack_be4(av[28], av[29], av[30], av[31]); + let bw7 = aggr_pack_be4(bv[28], bv[29], bv[30], bv[31]); + match aw7 - bw7 { + 0 => { 1 } , + _ => { match UInt32::less_than_fields(aw7, bw7) { 1 => { 0 } , _ => { 2 } , } } , + } } , + _ => { match UInt32::less_than_fields(aw6, bw6) { 1 => { 0 } , _ => { 2 } , } } , + } } , + _ => { match UInt32::less_than_fields(aw5, bw5) { 1 => { 0 } , _ => { 2 } , } } , + } } , + _ => { match UInt32::less_than_fields(aw4, bw4) { 1 => { 0 } , _ => { 2 } , } } , + } } , + _ => { match UInt32::less_than_fields(aw3, bw3) { 1 => { 0 } , _ => { 2 } , } } , + } } , + _ => { match UInt32::less_than_fields(aw2, bw2) { 1 => { 0 } , _ => { 2 } , } } , + } } , + _ => { match UInt32::less_than_fields(aw1, bw1) { 1 => { 0 } , _ => { 2 } , } } , + } } , + _ => { match UInt32::less_than_fields(aw0, bw0) { 1 => { 0 } , _ => { 2 } , } } , + } + } + + fn aggr_assert_strict_sorted(leaves: Lists::List) -> () { + match (*(leaves)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(a, rest) => { + match (*(rest)) { + Lists::Node::Nil => { () } , + Lists::Node::Cons(b, _) => { + assert_eq!(aggr_address_order(a, b), 0, + "aggr: tree leaves are not strictly sorted"); + aggr_assert_strict_sorted(rest) } , + } } , + } + } + + fn aggr_parse_tree_body(stream: Bytes::Stream) -> (Lists::List, Bytes::Stream) { + let (tag, rest) = aggr_read_byte(stream); + match UInt8::to_field(tag) { + 0 => { + let (addr, stop) = aggr_read_address(rest); + ((&(Lists::Node::Cons(addr, (&(Lists::Node::Nil))))), stop) } , + 1 => { ((&(Lists::Node::Nil)), rest) } , + 2 => { + let (left, s2) = aggr_parse_tree_body(rest); + let (right, stop) = aggr_parse_tree_body(s2); + (Lists::concat(left, right), stop) } , + } + } + + fn aggr_leaf_hashes(leaves: Lists::List) -> Lists::List { + match (*(leaves)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(addr, rest) => { + (&(Lists::Node::Cons(aggr_leaf_hash(addr), aggr_leaf_hashes(rest)))) } , + } + } + + fn aggr_pair_hashes(nodes: Lists::List) -> Lists::List { + match (*(nodes)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(left, rest) => { + match (*(rest)) { + Lists::Node::Nil => { + let zero = (&([UInt8::BYTE_0; 32])); + (&(Lists::Node::Cons(aggr_node_hash(left, zero), (&(Lists::Node::Nil))))) } , + Lists::Node::Cons(right, tail) => { + (&(Lists::Node::Cons(aggr_node_hash(left, right), aggr_pair_hashes(tail)))) } , + } } , + } + } + + fn aggr_reduce_hashes(nodes: Lists::List) -> Bytes::AddressRef { + let Lists::Node::Cons(root, rest) = (*(nodes)); + match (*(rest)) { + Lists::Node::Nil => { root } , + _ => { aggr_reduce_hashes(aggr_pair_hashes(nodes)) } , + } + } + + fn aggr_canonical_root(leaves: Lists::List) -> Bytes::AddressRef { + aggr_reduce_hashes(aggr_leaf_hashes(leaves)) + } + + fn aggr_load_canonical_tree(root: Bytes::AddressRef) -> Lists::List { + let raw = (*(root)); + let (idx, len) = hint::<(Field, Field)>("stark.io.address", (5, Blake3::address_to_fields(raw))); + let bytes = StarkIO::read_byte_stream(5, idx, len); + let (tag, body) = aggr_read_byte(bytes); + assert_eq!(UInt8::to_field(tag), 226, "aggr: tree has the wrong Ixon tag"); + let (leaves, stop) = aggr_parse_tree_body(body); + let Lists::Node::Nil = (*(stop)); + assert_eq!(Lists::is_empty(leaves), 0, + "aggr: a present tree must contain at least one leaf"); + + aggr_assert_strict_sorted(leaves); + let expected = aggr_canonical_root(leaves); + assert_eq!(Bytes::address_eq(expected, root), 1, + "aggr: tree leaves do not reproduce the canonical root"); + leaves + } + + fn aggr_load_optional_tree(root: Options::Option) -> Lists::List { + match root { + Options::Option::None => { (&(Lists::Node::Nil)) } , + Options::Option::Some(addr) => { aggr_load_canonical_tree(addr) } , + } + } + + fn aggr_assert_same_list(left: Lists::List, right: Lists::List) -> () { + match ((*(left)), (*(right))) { + (Lists::Node::Nil, Lists::Node::Nil) => { () } , + (Lists::Node::Cons(a, ar), Lists::Node::Cons(b, br)) => { + assert_eq!(Bytes::address_eq(a, b), 1, "aggr: set element mismatch"); + aggr_assert_same_list(ar, br) } , + } + } + + fn aggr_assert_union(left: Lists::List, right: Lists::List, + output: Lists::List) -> () { + match ((*(left)), (*(right))) { + (Lists::Node::Nil, _) => { aggr_assert_same_list(right, output) } , + (_, Lists::Node::Nil) => { aggr_assert_same_list(left, output) } , + (Lists::Node::Cons(a, ar), Lists::Node::Cons(b, br)) => { + let Lists::Node::Cons(o, or) = (*(output)); + match aggr_address_order(a, b) { + 0 => { + assert_eq!(Bytes::address_eq(a, o), 1, "aggr: subject union mismatch"); + aggr_assert_union(ar, right, or) } , + 1 => { + assert_eq!(Bytes::address_eq(a, o), 1, "aggr: subject union mismatch"); + aggr_assert_union(ar, br, or) } , + _ => { + assert_eq!(Bytes::address_eq(b, o), 1, "aggr: subject union mismatch"); + aggr_assert_union(left, br, or) } , + } } , + } + } + + fn aggr_assert_disjoint_union(left: Lists::List, right: Lists::List, + output: Lists::List) -> () { + match ((*(left)), (*(right))) { + (Lists::Node::Nil, _) => { aggr_assert_same_list(right, output) } , + (_, Lists::Node::Nil) => { aggr_assert_same_list(left, output) } , + (Lists::Node::Cons(a, ar), Lists::Node::Cons(b, br)) => { + let Lists::Node::Cons(o, or) = (*(output)); + match aggr_address_order(a, b) { + 0 => { + assert_eq!(Bytes::address_eq(a, o), 1, "aggr: subject union mismatch"); + aggr_assert_disjoint_union(ar, right, or) } , + 1 => { + assert_eq!(0, 1, "aggr: child subject sets overlap"); + () } , + _ => { + assert_eq!(Bytes::address_eq(b, o), 1, "aggr: subject union mismatch"); + aggr_assert_disjoint_union(left, br, or) } , + } } , + } + } + + fn aggr_assert_disjoint(left: Lists::List, right: Lists::List) -> () { + match ((*(left)), (*(right))) { + (Lists::Node::Nil, _) => { () } , + (_, Lists::Node::Nil) => { () } , + (Lists::Node::Cons(a, ar), Lists::Node::Cons(b, br)) => { + match aggr_address_order(a, b) { + 0 => { aggr_assert_disjoint(ar, right) } , + 1 => { + assert_eq!(0, 1, "aggr: subject set overlaps assumption set"); + () } , + _ => { aggr_assert_disjoint(left, br) } , + } } , + } + } + + fn aggr_next_assumption(left: Lists::List, right: Lists::List) + -> AggrNextAssumption { + match ((*(left)), (*(right))) { + (Lists::Node::Nil, Lists::Node::Nil) => { AggrNextAssumption::Done } , + (Lists::Node::Cons(a, ar), Lists::Node::Nil) => { + AggrNextAssumption::More(a, 0, ar, right) } , + (Lists::Node::Nil, Lists::Node::Cons(b, br)) => { + AggrNextAssumption::More(b, 2, left, br) } , + (Lists::Node::Cons(a, ar), Lists::Node::Cons(b, br)) => { + match aggr_address_order(a, b) { + 0 => { AggrNextAssumption::More(a, 0, ar, right) } , + 1 => { AggrNextAssumption::More(a, 1, ar, br) } , + _ => { AggrNextAssumption::More(b, 2, left, br) } , + } } , + } + } + + fn aggr_seek_subject(target: Bytes::AddressRef, subjects: Lists::List) + -> (Field, Lists::List) { + match (*(subjects)) { + Lists::Node::Nil => { (0, subjects) } , + Lists::Node::Cons(subject, rest) => { + match aggr_address_order(subject, target) { + 0 => { aggr_seek_subject(target, rest) } , + 1 => { (1, rest) } , + _ => { (0, subjects) } , + } } , + } + } + + fn aggr_assert_difference(left: Lists::List, right: Lists::List, + subjects: Lists::List, output: Lists::List) -> () { + match aggr_next_assumption(left, right) { + AggrNextAssumption::Done => { + let Lists::Node::Nil = (*(output)); + () } , + AggrNextAssumption::More(candidate, _source, left_rest, right_rest) => { + let (discharged, subject_rest) = aggr_seek_subject(candidate, subjects); + match discharged { + 1 => { aggr_assert_difference(left_rest, right_rest, subject_rest, output) } , + _ => { + let Lists::Node::Cons(actual, output_rest) = (*(output)); + assert_eq!(Bytes::address_eq(candidate, actual), 1, + "aggr: outstanding assumption mismatch"); + aggr_assert_difference(left_rest, right_rest, subject_rest, output_rest) } , + } } , + } + } + + fn aggr_fold_path(hash: Bytes::AddressRef, remaining: Field, stream: Bytes::Stream) + -> (Bytes::AddressRef, Bytes::Stream) { + match remaining { + 0 => { (hash, stream) } , + _ => { + let (side, s1) = aggr_read_byte(stream); + assert_eq!(UInt8::less_than(side, UInt8::BYTE_2), 1, + "aggr structural: path side must be 0 or 1"); + let (sibling, s2) = aggr_read_address(s1); + let parent = match UInt8::to_field(side) { + 0 => { aggr_node_hash(sibling, hash) } , + _ => { aggr_node_hash(hash, sibling) } , + }; + aggr_fold_path(parent, remaining - 1, s2) } , + } + } + + fn aggr_discharge_choice(candidate: Bytes::AddressRef, source: Field, + left_root: Bytes::AddressRef, right_root: Bytes::AddressRef) -> Field { + let (idx, len) = hint::<(Field, Field)>("stark.io.address", (6, Blake3::address_to_fields((*(candidate))))); + let bytes = StarkIO::read_byte_stream(6, idx, len); + let (choice, rest) = aggr_read_byte(bytes); + assert_eq!(UInt8::less_than(choice, UInt8::BYTE_2), 1, + "aggr structural: discharge choice must be 0 or 1"); + match UInt8::to_field(choice) { + 0 => { + let Lists::Node::Nil = (*(rest)); + 0 } , + _ => { + let (count, path) = aggr_read_byte(rest); + assert_eq!(UInt8::less_than(UInt8::BYTE_0, count), 1, + "aggr structural: Merkle path must have at least 1 step"); + assert_eq!(UInt8::less_than(count, UInt8::BYTE_65), 1, + "aggr structural: Merkle path exceeds 64 steps"); + let (child_actual, last_step) = aggr_fold_path(aggr_leaf_hash(candidate), + UInt8::to_field(count) - 1, path); + let (last_side, s1) = aggr_read_byte(last_step); + let (last_sibling, stop) = aggr_read_address(s1); + let Lists::Node::Nil = (*(stop)); + match source { + 0 => { + assert_eq!(UInt8::to_field(last_side), 0, + "aggr structural: left assumption must be discharged by right child"); + assert_eq!(Bytes::address_eq(last_sibling, left_root), 1, + "aggr structural: final step sibling is not left subject root"); + assert_eq!(Bytes::address_eq(child_actual, right_root), 1, + "aggr structural: assumption path does not reach right subject root"); + 1 } , + 2 => { + assert_eq!(UInt8::to_field(last_side), 1, + "aggr structural: right assumption must be discharged by left child"); + assert_eq!(Bytes::address_eq(last_sibling, right_root), 1, + "aggr structural: final step sibling is not right subject root"); + assert_eq!(Bytes::address_eq(child_actual, left_root), 1, + "aggr structural: assumption path does not reach left subject root"); + 1 } , + _ => { + assert_eq!(0, 1, + "aggr structural: shared assumption cannot be discharged"); + 0 } , + } } , + } + } + + fn aggr_assert_structural_difference(left: Lists::List, right: Lists::List, + left_root: Bytes::AddressRef, right_root: Bytes::AddressRef, output: Lists::List) -> () { + match aggr_next_assumption(left, right) { + AggrNextAssumption::Done => { + let Lists::Node::Nil = (*(output)); + () } , + AggrNextAssumption::More(candidate, source, left_rest, right_rest) => { + match aggr_discharge_choice(candidate, source, left_root, right_root) { + 1 => { aggr_assert_structural_difference(left_rest, right_rest, + left_root, right_root, output) } , + _ => { + let Lists::Node::Cons(actual, output_rest) = (*(output)); + assert_eq!(Bytes::address_eq(candidate, actual), 1, + "aggr structural: outstanding assumption mismatch"); + aggr_assert_structural_difference(left_rest, right_rest, + left_root, right_root, output_rest) } , + } } , + } + } + + fn aggr_get_opt_address(stream: Bytes::Stream) -> (Options::Option, Bytes::Stream) { + let (tag, rest) = aggr_read_byte(stream); + match UInt8::to_field(tag) { + 0 => { (Options::Option::None, rest) } , + 1 => { + let (addr, stop) = aggr_read_address(rest); + (Options::Option::Some(addr), stop) } , + } + } + + fn aggr_parse_check_env(bytes: Bytes::Stream) + -> ((Bytes::AddressRef, Bytes::AddressRef, Options::Option, Field), Bytes::AddressRef, Options::Option) { + + let (tag, s) = aggr_read_byte(bytes); + assert_eq!(UInt8::to_field(tag), 229, "aggr: claim is not CheckEnv"); + let (format, s) = aggr_read_byte(s); + assert_eq!(UInt8::to_field(format), 4, "aggr: unsupported object format"); + let (validator_byte, s) = aggr_read_byte(s); + let validator = UInt8::to_field(validator_byte); + assert_eq!((validator - 3) * (validator - 4) * (validator - 5), 0, + "aggr: wrong validator identity"); + let (spec, s) = aggr_read_address(s); + let (binding, s) = aggr_read_address(s); + let (axioms, s) = aggr_get_opt_address(s); + let (root, s2) = aggr_read_address(s); + let (assumptions, stop) = aggr_get_opt_address(s2); + let Lists::Node::Nil = (*(stop)); + ((spec, binding, axioms, validator), root, assumptions) + } + + fn aggr_parse_binding(bytes: Bytes::Stream) -> (Bytes::AddressRef, Bytes::AddressRef) { + + let (tag0, s) = aggr_read_byte(bytes); + assert_eq!(UInt8::to_field(tag0), 232, "aggr: claim is not Binding"); + let (tag1, s) = aggr_read_byte(s); + assert_eq!(UInt8::to_field(tag1), 2, "aggr: claim is not Binding"); + let (format, s) = aggr_read_byte(s); + assert_eq!(UInt8::to_field(format), 4, "aggr: unsupported object format"); + let (validator, s) = aggr_read_byte(s); + assert_eq!(UInt8::to_field(validator), 3, "aggr: wrong validator identity"); + let (spec, s) = aggr_read_address(s); + let (binding, stop) = aggr_read_address(s); + let Lists::Node::Nil = (*(stop)); + (spec, binding) + } + + fn aggr_parse_catalog(bytes: Bytes::Stream) -> Bytes::AddressRef { + + let (tag0, s) = aggr_read_byte(bytes); + assert_eq!(UInt8::to_field(tag0), 232, "aggr: claim is not Catalog"); + let (tag1, s) = aggr_read_byte(s); + assert_eq!(UInt8::to_field(tag1), 0, "aggr: claim is not Catalog"); + let (format, s) = aggr_read_byte(s); + assert_eq!(UInt8::to_field(format), 4, "aggr: unsupported object format"); + let (validator, s) = aggr_read_byte(s); + assert_eq!(UInt8::to_field(validator), 3, "aggr: wrong validator identity"); + let (members, stop) = aggr_read_address(s); + let Lists::Node::Nil = (*(stop)); + members + } + + fn aggr_opt_address_eq(a: Options::Option, b: Options::Option) -> Field { + match a { + Options::Option::None => { + match b { + Options::Option::None => { 1 } , + Options::Option::Some(_) => { 0 } , + } } , + Options::Option::Some(x) => { + match b { + Options::Option::None => { 0 } , + Options::Option::Some(y) => { Bytes::address_eq(x, y) } , + } } , + } + } + + fn aggr_assert_same_context(a: (Bytes::AddressRef, Bytes::AddressRef, Options::Option, Field), + b: (Bytes::AddressRef, Bytes::AddressRef, Options::Option, Field)) -> () { + let (spec_a, binding_a, axioms_a, validator_a) = a; + let (spec_b, binding_b, axioms_b, validator_b) = b; + assert_eq!(Bytes::address_eq(spec_a, spec_b), 1, + "aggr: claims differ in specification digest"); + assert_eq!(Bytes::address_eq(binding_a, binding_b), 1, + "aggr: claims differ in binding hash"); + assert_eq!(aggr_opt_address_eq(axioms_a, axioms_b), 1, + "aggr: claims differ in axioms"); + assert_eq!(validator_a, validator_b, + "aggr: claims differ in whether they assume their binding"); + () + } + + fn aggr_load_preimage(digest: [Field; 8]) -> Bytes::Stream { + let (idx, len) = hint::<(Field, Field)>("stark.io.digest", digest); + let bytes = StarkIO::read_byte_stream(4, idx, len); + assert_eq!(Blake3::pack_digest(Blake3::hash(bytes)), digest, + "aggr: claim preimage digest mismatch"); + bytes + } + + fn aggr_claim_field(claim: Lists::List, index: Field) -> Field { + Goldilocks::gl_val(Lists::lookup(claim, index)) + } + + fn aggr_claim_digest(claim: Lists::List, start: Field) -> [Field; 8] { + [aggr_claim_field(claim, start), + aggr_claim_field(claim, start + 1), + aggr_claim_field(claim, start + 2), + aggr_claim_field(claim, start + 3), + aggr_claim_field(claim, start + 4), + aggr_claim_field(claim, start + 5), + aggr_claim_field(claim, start + 6), + aggr_claim_field(claim, start + 7)] + } + + fn aggr_assert_digest(actual: [Field; 8], expected: [Field; 8]) -> () { + assert_eq!(actual[0], expected[0]); + assert_eq!(actual[1], expected[1]); + assert_eq!(actual[2], expected[2]); + assert_eq!(actual[3], expected[3]); + assert_eq!(actual[4], expected[4]); + assert_eq!(actual[5], expected[5]); + assert_eq!(actual[6], expected[6]); + assert_eq!(actual[7], expected[7]); + () + } + + fn aggr_only_claim(claims: Lists::List>) -> Lists::List { + let Lists::Node::Cons(claim, rest) = (*(claims)); + let Lists::Node::Nil = (*(rest)); + claim + } + + fn aggr_load_sys(kind: Field, ixvm_vk_digest: [Field; 8], self_vk_digest: [Field; 8]) + -> SystemDeserialize::Sys { + + let (sidx, slen) = hint::<(Field, Field)>("stark.io.info", (1, kind)); + let sbytes = StarkIO::read_byte_stream(1, sidx, slen); + let digest = Blake3::pack_digest(Blake3::hash(sbytes)); + match kind { + 0 => { + aggr_assert_digest(digest, ixvm_vk_digest) } , + _ => { + aggr_assert_digest(digest, self_vk_digest) } , + }; + let (sys, srest) = SystemDeserialize::read_system(sbytes); + let Lists::Node::Nil = (*(srest)); + sys + } + + fn aggr_verify_child(sys: SystemDeserialize::Sys, key: Field) -> Lists::List> { + let (idx, len) = hint::<(Field, Field)>("stark.io.info", (0, key)); + let (cidx, clen) = hint::<(Field, Field)>("stark.io.info", (2, key)); + let cbytes = StarkIO::read_byte_stream(2, cidx, clen); + let (claims, crest) = StarkVerifier::read_claims(cbytes); + let Lists::Node::Nil = (*(crest)); + assert_eq!(StarkVerifier::verify_batch_at(sys, idx, len, claims), 1); + claims + } + + fn aggr_child_check_env_digest(kind: Field, key: Field, + ixvm_vk_digest: [Field; 8], self_vk_digest: [Field; 8], + verify_idx: Field, aggr_idx: Field, allowed_digest: [Field; 8]) -> [Field; 8] { + let sys = aggr_load_sys(kind, ixvm_vk_digest, self_vk_digest); + let claim = aggr_only_claim(aggr_verify_child(sys, key)); + assert_eq!(aggr_claim_field(claim, 0), 1, + "aggr: child has the wrong claim channel"); + match kind { + 0 => { + assert_eq!(Lists::length(claim), 10, + "aggr: IxVM child must expose a 10-word verify_claim claim"); + assert_eq!(aggr_claim_field(claim, 1), verify_idx, + "aggr: IxVM child has the wrong entrypoint"); + aggr_claim_digest(claim, 2) } , + _ => { + assert_eq!(Lists::length(claim), 18, + "aggr: recursive child must expose an 18-word ix_aggr claim"); + assert_eq!(aggr_claim_field(claim, 1), aggr_idx, + "aggr: recursive child has the wrong entrypoint"); + aggr_assert_digest(aggr_claim_digest(claim, 2), allowed_digest); + aggr_claim_digest(claim, 10) } , + } + } + + fn aggr_wrap(kind: Field, ixvm_vk_digest: [Field; 8], self_vk_digest: [Field; 8], + verify_idx: Field, aggr_idx: Field, allowed_digest: [Field; 8], + out_claim_digest: [Field; 8]) -> () { + let child = aggr_child_check_env_digest(kind, 0, + ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); + aggr_assert_digest(child, out_claim_digest) + } + + fn aggr_pair(left_kind: Field, right_kind: Field, + ixvm_vk_digest: [Field; 8], self_vk_digest: [Field; 8], + verify_idx: Field, aggr_idx: Field, allowed_digest: [Field; 8], + out_claim_digest: [Field; 8]) -> () { + let left_digest = aggr_child_check_env_digest(left_kind, 0, + ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); + let right_digest = aggr_child_check_env_digest(right_kind, 1, + ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); + let (left_ctx, left_root, left_asm) = + aggr_parse_check_env(aggr_load_preimage(left_digest)); + let (right_ctx, right_root, right_asm) = + aggr_parse_check_env(aggr_load_preimage(right_digest)); + + let (oidx, olen) = hint::<(Field, Field)>("stark.io.info", (2, 2)); + let output_bytes = StarkIO::read_byte_stream(2, oidx, olen); + assert_eq!(Blake3::pack_digest(Blake3::hash(output_bytes)), out_claim_digest, + "aggr: output claim digest mismatch"); + let (output_ctx, output_root, output_asm) = aggr_parse_check_env(output_bytes); + aggr_assert_same_context(left_ctx, right_ctx); + aggr_assert_same_context(left_ctx, output_ctx); + + let left_subjects = aggr_load_canonical_tree(left_root); + let right_subjects = aggr_load_canonical_tree(right_root); + let left_assumptions = aggr_load_optional_tree(left_asm); + let right_assumptions = aggr_load_optional_tree(right_asm); + let output_subjects = aggr_load_canonical_tree(output_root); + let output_assumptions = aggr_load_optional_tree(output_asm); + + aggr_assert_disjoint(left_subjects, left_assumptions); + aggr_assert_disjoint(right_subjects, right_assumptions); + aggr_assert_disjoint_union(left_subjects, right_subjects, output_subjects); + aggr_assert_difference(left_assumptions, right_assumptions, + output_subjects, output_assumptions); + () + } + + fn aggr_pair_structural(left_kind: Field, right_kind: Field, + ixvm_vk_digest: [Field; 8], self_vk_digest: [Field; 8], + verify_idx: Field, aggr_idx: Field, allowed_digest: [Field; 8], + out_claim_digest: [Field; 8]) -> () { + let left_digest = aggr_child_check_env_digest(left_kind, 0, + ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); + let right_digest = aggr_child_check_env_digest(right_kind, 1, + ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); + let (left_ctx, left_root, left_asm) = + aggr_parse_check_env(aggr_load_preimage(left_digest)); + let (right_ctx, right_root, right_asm) = + aggr_parse_check_env(aggr_load_preimage(right_digest)); + + let (oidx, olen) = hint::<(Field, Field)>("stark.io.info", (2, 2)); + let output_bytes = StarkIO::read_byte_stream(2, oidx, olen); + assert_eq!(Blake3::pack_digest(Blake3::hash(output_bytes)), out_claim_digest, + "aggr structural: output claim digest mismatch"); + let (output_ctx, output_root, output_asm) = aggr_parse_check_env(output_bytes); + aggr_assert_same_context(left_ctx, right_ctx); + aggr_assert_same_context(left_ctx, output_ctx); + + assert_eq!(Bytes::address_eq(left_root, right_root), 0, + "aggr structural: child subject roots must be distinct"); + let expected_root = aggr_node_hash(left_root, right_root); + assert_eq!(Bytes::address_eq(output_root, expected_root), 1, + "aggr structural: output subject root is not nodeHash(left, right)"); + + let left_assumptions = aggr_load_optional_tree(left_asm); + let right_assumptions = aggr_load_optional_tree(right_asm); + let output_assumptions = aggr_load_optional_tree(output_asm); + aggr_assert_structural_difference(left_assumptions, right_assumptions, + left_root, right_root, output_assumptions); + () + } + + fn aggr_discharge_binding(kind: Field, + ixvm_vk_digest: [Field; 8], self_vk_digest: [Field; 8], + verify_idx: Field, aggr_idx: Field, allowed_digest: [Field; 8], + out_claim_digest: [Field; 8]) -> () { + let child_digest = aggr_child_check_env_digest(kind, 0, + ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); + let binding_digest = aggr_child_check_env_digest(0, 1, + ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); + let (child_ctx, child_root, child_asm) = + aggr_parse_check_env(aggr_load_preimage(child_digest)); + let (spec, binding, axioms, validator) = child_ctx; + assert_eq!(validator, 4, + "aggr discharge: the claim does not assume its binding"); + let (bound_spec, bound_binding) = + aggr_parse_binding(aggr_load_preimage(binding_digest)); + assert_eq!(Bytes::address_eq(spec, bound_spec), 1, + "aggr discharge: the binding claim is for another specification digest"); + assert_eq!(Bytes::address_eq(binding, bound_binding), 1, + "aggr discharge: the binding claim is for another binding"); + + let (oidx, olen) = hint::<(Field, Field)>("stark.io.info", (2, 2)); + let output_bytes = StarkIO::read_byte_stream(2, oidx, olen); + assert_eq!(Blake3::pack_digest(Blake3::hash(output_bytes)), out_claim_digest, + "aggr discharge: output claim digest mismatch"); + let (output_ctx, output_root, output_asm) = aggr_parse_check_env(output_bytes); + aggr_assert_same_context((spec, binding, axioms, 3), output_ctx); + assert_eq!(Bytes::address_eq(child_root, output_root), 1, + "aggr discharge: output subject root differs from the child's"); + assert_eq!(aggr_opt_address_eq(child_asm, output_asm), 1, + "aggr discharge: output assumptions differ from the child's"); + () + } + + fn aggr_is_class_role(i: Field) -> Field { + match i { + 0 => { 1 } , + 1 => { 1 } , + 2 => { 1 } , + 29 => { 1 } , + 30 => { 1 } , + 31 => { 1 } , + 37 => { 1 } , + 38 => { 1 } , + 39 => { 1 } , + 40 => { 1 } , + 56 => { 1 } , + 57 => { 1 } , + _ => { 0 } , + } + } + + fn aggr_class_walk(stream: Bytes::Stream, i: Field, remaining: Field) -> Lists::List { + match remaining { + 0 => { (&(Lists::Node::Nil)) } , + _ => { + let (role, s) = aggr_read_byte(stream); + assert_eq!(UInt8::to_field(role), i, + "aggr cross-binding: the binding does not bind every role in order"); + let (addr, s2) = aggr_read_address(s); + let rest = aggr_class_walk(s2, i + 1, remaining - 1); + match aggr_is_class_role(i) { + 1 => { (&(Lists::Node::Cons(addr, rest))) } , + _ => { rest } , + } } , + } + } + + fn aggr_put_addresses(addrs: Lists::List, tail: Bytes::Stream) -> Bytes::Stream { + match (*(addrs)) { + Lists::Node::Nil => { tail } , + Lists::Node::Cons(a, rest) => { aggr_put_address(a, aggr_put_addresses(rest, tail)) } , + } + } + + fn aggr_binding_class(binding: Bytes::AddressRef) -> Bytes::AddressRef { + let bytes = aggr_load_preimage(aggr_pack_address(binding)); + let (tag0, s) = aggr_read_byte(bytes); + assert_eq!(UInt8::to_field(tag0), 232, "aggr cross-binding: not a role binding section"); + let (tag1, s) = aggr_read_byte(s); + assert_eq!(UInt8::to_field(tag1), 3, "aggr cross-binding: not a role binding section"); + let (_version, s) = aggr_read_byte(s); + let (count, s) = aggr_read_byte(s); + assert_eq!(UInt8::to_field(count), 103, + "aggr cross-binding: the binding does not bind every role"); + let addrs = aggr_class_walk(s, 0, 103); + let body = aggr_put_addresses(addrs, (&(Lists::Node::Nil))); + Blake3::bytes_to_addr((&(Lists::Node::Cons(UInt8::BYTE_232, (&(Lists::Node::Cons(UInt8::BYTE_4, body))))))) + } + + fn aggr_context_class(ctx: (Bytes::AddressRef, Bytes::AddressRef, Options::Option, Field)) -> Bytes::AddressRef { + let (_spec, binding, _axioms, validator) = ctx; + assert_eq!((validator - 3) * (validator - 5), 0, + "aggr cross-binding: the claim assumes its binding"); + match validator { + 5 => { binding } , + _ => { aggr_binding_class(binding) } , + } + } + + fn aggr_cross_binding(ixvm_vk_digest: [Field; 8], self_vk_digest: [Field; 8], + verify_idx: Field, aggr_idx: Field, allowed_digest: [Field; 8], + out_claim_digest: [Field; 8]) -> () { + let left_digest = aggr_child_check_env_digest(1, 0, + ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); + let right_digest = aggr_child_check_env_digest(1, 1, + ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); + let (left_ctx, left_root, left_asm) = + aggr_parse_check_env(aggr_load_preimage(left_digest)); + let (right_ctx, right_root, right_asm) = + aggr_parse_check_env(aggr_load_preimage(right_digest)); + let left_class = aggr_context_class(left_ctx); + let right_class = aggr_context_class(right_ctx); + assert_eq!(Bytes::address_eq(left_class, right_class), 1, + "aggr cross-binding: the bindings' literal classes differ"); + let (left_spec, _lb, left_axioms, _lv) = left_ctx; + let (right_spec, _rb, right_axioms, _rv) = right_ctx; + + let (oidx, olen) = hint::<(Field, Field)>("stark.io.info", (2, 2)); + let output_bytes = StarkIO::read_byte_stream(2, oidx, olen); + assert_eq!(Blake3::pack_digest(Blake3::hash(output_bytes)), out_claim_digest, + "aggr cross-binding: output claim digest mismatch"); + let (output_ctx, output_root, output_asm) = aggr_parse_check_env(output_bytes); + aggr_assert_same_context((left_spec, left_class, left_axioms, 5), output_ctx); + aggr_assert_same_context((right_spec, right_class, right_axioms, 5), output_ctx); + + assert_eq!(Bytes::address_eq(left_root, right_root), 0, + "aggr cross-binding: child subject roots must be distinct"); + let expected_root = aggr_node_hash(left_root, right_root); + assert_eq!(Bytes::address_eq(output_root, expected_root), 1, + "aggr cross-binding: output subject root is not nodeHash(left, right)"); + let left_assumptions = aggr_load_optional_tree(left_asm); + let right_assumptions = aggr_load_optional_tree(right_asm); + let output_assumptions = aggr_load_optional_tree(output_asm); + aggr_assert_structural_difference(left_assumptions, right_assumptions, + left_root, right_root, output_assumptions); + () + } + + fn aggr_catalog_part(digest: [Field; 8]) -> Lists::List { + let bytes = aggr_load_preimage(digest); + let (tag, _rest) = aggr_read_byte(bytes); + match UInt8::to_field(tag) { + 229 => { + let (ctx, _root, asm) = aggr_parse_check_env(bytes); + let (_spec, _binding, _axioms, validator) = ctx; + assert_eq!((validator - 3) * (validator - 5), 0, + "aggr catalog: a member claim assumes its binding"); + assert_eq!(aggr_opt_address_eq(asm, Options::Option::None), 1, + "aggr catalog: a member claim has assumptions"); + (&(Lists::Node::Cons(Blake3::bytes_to_addr(bytes), (&(Lists::Node::Nil))))) } , + _ => { aggr_load_canonical_tree(aggr_parse_catalog(bytes)) } , + } + } + + fn aggr_catalog_join(ixvm_vk_digest: [Field; 8], self_vk_digest: [Field; 8], + verify_idx: Field, aggr_idx: Field, allowed_digest: [Field; 8], + out_claim_digest: [Field; 8]) -> () { + let left_digest = aggr_child_check_env_digest(1, 0, + ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); + let right_digest = aggr_child_check_env_digest(1, 1, + ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); + let left = aggr_catalog_part(left_digest); + let right = aggr_catalog_part(right_digest); + + let (oidx, olen) = hint::<(Field, Field)>("stark.io.info", (2, 2)); + let output_bytes = StarkIO::read_byte_stream(2, oidx, olen); + assert_eq!(Blake3::pack_digest(Blake3::hash(output_bytes)), out_claim_digest, + "aggr catalog: output claim digest mismatch"); + let output = aggr_load_canonical_tree(aggr_parse_catalog(output_bytes)); + aggr_assert_union(left, right, output); + () + } + + fn aggr_parse_range(bytes: Bytes::Stream) -> (Bytes::AddressRef, UInt64::U64, UInt64::U64, ProofDeserialize::Ext) { + let (tag, s) = aggr_read_byte(bytes); + assert_eq!(UInt8::to_field(tag), 82, "aggr range: statement has the wrong tag"); + let (d, s2) = aggr_read_address(s); + let (lo, s3) = ProofDeserialize::read_u64(s2); + let (hi, s4) = ProofDeserialize::read_u64(s3); + let (r0, s5) = ProofDeserialize::read_u64(s4); + let (r1, stop) = ProofDeserialize::read_u64(s5); + let Lists::Node::Nil = (*(stop)); + (d, lo, hi, [Goldilocks::gl_val(r0), Goldilocks::gl_val(r1)]) + } + + fn aggr_read_digest(s: Bytes::Stream) -> (ProofDeserialize::DigestP, Bytes::Stream) { + let (a, s1) = ProofDeserialize::read_u64(s); + let (b, s2) = ProofDeserialize::read_u64(s1); + let (c, s3) = ProofDeserialize::read_u64(s2); + let (d, s4) = ProofDeserialize::read_u64(s3); + ((&([a, b, c, d])), s4) + } + + fn aggr_read_cap_n(s: Bytes::Stream, n: Field) -> (ProofDeserialize::MerkleCap, Bytes::Stream) { + match n { + 0 => { ((&(Lists::Node::Nil)), s) } , + _ => { + let (x, s1) = aggr_read_digest(s); + let (rest, s2) = aggr_read_cap_n(s1, n - 1); + ((&(Lists::Node::Cons(x, rest))), s2) } , + } + } + + fn aggr_read_bits_n(s: Bytes::Stream, n: Field) -> (Lists::List, Bytes::Stream) { + match n { + 0 => { ((&(Lists::Node::Nil)), s) } , + _ => { + let (b, s1) = aggr_read_byte(s); + let (rest, s2) = aggr_read_bits_n(s1, n - 1); + ((&(Lists::Node::Cons(UInt8::to_field(b), rest))), s2) } , + } + } + + fn aggr_read_bytes_n(s: Bytes::Stream, n: Field) -> (Lists::List, Bytes::Stream) { + match n { + 0 => { ((&(Lists::Node::Nil)), s) } , + _ => { + let (b, s1) = aggr_read_byte(s); + let (rest, s2) = aggr_read_bytes_n(s1, n - 1); + ((&(Lists::Node::Cons(b, rest))), s2) } , + } + } + + fn aggr_read_header(s: Bytes::Stream) -> (ProofDeserialize::ShardHeader, Bytes::Stream) { + let (na, s1) = ProofDeserialize::read_count(s); + let (active, s2) = aggr_read_bits_n(s1, na); + let (nc, s3) = ProofDeserialize::read_count(s2); + let (cap, s4) = aggr_read_cap_n(s3, nc); + let (nl, s5) = ProofDeserialize::read_count(s4); + let (lds, s6) = aggr_read_bytes_n(s5, nl); + let (claims, s7) = StarkVerifier::read_claims(s6); + (ProofDeserialize::ShardHeader::Mk(active, cap, lds, claims), s7) + } + + fn aggr_read_headers_n(s: Bytes::Stream, n: Field) -> (Lists::List, Bytes::Stream) { + match n { + 0 => { ((&(Lists::Node::Nil)), s) } , + _ => { + let (h, s1) = aggr_read_header(s); + let (rest, s2) = aggr_read_headers_n(s1, n - 1); + ((&(Lists::Node::Cons(h, rest))), s2) } , + } + } + + fn aggr_read_message(s: Bytes::Stream) -> (ProofDeserialize::BatchMessage, Bytes::Stream) { + let (args, s1) = StarkVerifier::read_one_claim(s); + let (mult, s2) = ProofDeserialize::read_u64(s1); + (ProofDeserialize::BatchMessage::Mk(args, mult), s2) + } + + fn aggr_read_messages_n(s: Bytes::Stream, n: Field) -> (Lists::List, Bytes::Stream) { + match n { + 0 => { ((&(Lists::Node::Nil)), s) } , + _ => { + let (m, s1) = aggr_read_message(s); + let (rest, s2) = aggr_read_messages_n(s1, n - 1); + ((&(Lists::Node::Cons(m, rest))), s2) } , + } + } + + fn aggr_load_preamble(key: Field, d: Bytes::AddressRef) -> (Lists::List, Lists::List) { + let (idx, len) = hint::<(Field, Field)>("stark.io.info", (0, key)); + let bytes = StarkIO::read_byte_stream(0, idx, len); + assert_eq!(Bytes::address_eq(Blake3::bytes_to_addr(bytes), d), 1, + "aggr range: preamble does not hash to the statement's batch digest"); + let (nh, s1) = ProofDeserialize::read_count(bytes); + let (headers, s2) = aggr_read_headers_n(s1, nh); + let (nm, s3) = ProofDeserialize::read_count(s2); + let (messages, stop) = aggr_read_messages_n(s3, nm); + let Lists::Node::Nil = (*(stop)); + (headers, messages) + } + + fn aggr_batch_challenges(sys: SystemDeserialize::Sys, headers: Lists::List, + messages: Lists::List) -> (ProofDeserialize::Ext, ProofDeserialize::Ext, Bytes::Stream) { + let SystemDeserialize::Sys::Mk(_params, tlimbs, _circuits, commit, _prep_indices) = sys; + let prep_cap = StarkVerifier::opt_commit_cap(commit); + Transcript::batch_fiat_shamir(tlimbs, prep_cap, headers, messages) + } + + fn aggr_verify_range(sys: SystemDeserialize::Sys, headers: Lists::List, i: Field, shard: Field, + n: Field, input: Bytes::Stream, lch: ProofDeserialize::Ext, fch: ProofDeserialize::Ext, acc: ProofDeserialize::Ext) -> (ProofDeserialize::Ext, Field) { + match n { + 0 => { (acc, i) } , + _ => { + let Lists::Node::Cons(h, hrest) = (*(headers)); + let (p, j) = ProofDeserialize::read_proof(i); + let r = StarkVerifier::verify_shard(sys, h, shard, p, input, lch, fch); + aggr_verify_range(sys, hrest, j, shard + 1, n - 1, input, lch, fch, + Goldilocks::eg_add(acc, r)) } , + } + } + + fn aggr_output_range(out_claim_digest: [Field; 8]) -> (Bytes::AddressRef, UInt64::U64, UInt64::U64, ProofDeserialize::Ext) { + let (oidx, olen) = hint::<(Field, Field)>("stark.io.info", (2, 2)); + let output_bytes = StarkIO::read_byte_stream(2, oidx, olen); + assert_eq!(Blake3::pack_digest(Blake3::hash(output_bytes)), out_claim_digest, + "aggr range: output statement digest mismatch"); + aggr_parse_range(output_bytes) + } + + fn aggr_child_range(key: Field, ixvm_vk_digest: [Field; 8], self_vk_digest: [Field; 8], + verify_idx: Field, aggr_idx: Field, allowed_digest: [Field; 8]) + -> (Bytes::AddressRef, UInt64::U64, UInt64::U64, ProofDeserialize::Ext) { + let digest = aggr_child_check_env_digest(1, key, + ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); + aggr_parse_range(aggr_load_preimage(digest)) + } + + fn aggr_range_leaf(ixvm_vk_digest: [Field; 8], self_vk_digest: [Field; 8], + out_claim_digest: [Field; 8]) -> () { + let sys = aggr_load_sys(0, ixvm_vk_digest, self_vk_digest); + let (d, lo_limb, hi_limb, r) = aggr_output_range(out_claim_digest); + let (headers, messages) = aggr_load_preamble(0, d); + let (lch, fch, input) = aggr_batch_challenges(sys, headers, messages); + assert_eq!(StarkVerifier::bytes8_le(lo_limb, hi_limb), 1, + "aggr range: the range ends before it starts"); + let lo = UInt64::to_field(lo_limb); + let n = UInt64::to_field(hi_limb) - lo; + let (pidx, plen) = hint::<(Field, Field)>("stark.io.info", (0, 1)); + let (count, j) = ProofDeserialize::read_count_at(pidx); + assert_eq!(count, n, "aggr range: proof count differs from the range"); + let (total, stop) = aggr_verify_range(sys, Lists::drop(headers, lo), j, lo, + n, input, lch, fch, [0, 0]); + assert_eq!(stop, pidx + plen, "aggr range: trailing bytes after the proofs"); + assert_eq!(Goldilocks::eg_eq(total, r), 1, + "aggr range: residual sum differs from the statement"); + () + } + + fn aggr_range_join(ixvm_vk_digest: [Field; 8], self_vk_digest: [Field; 8], + verify_idx: Field, aggr_idx: Field, allowed_digest: [Field; 8], + out_claim_digest: [Field; 8]) -> () { + let (ld, llo, lhi, lr) = aggr_child_range(0, + ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); + let (rd, rlo, rhi, rr) = aggr_child_range(1, + ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); + let (d, lo, hi, r) = aggr_output_range(out_claim_digest); + assert_eq!(Bytes::address_eq(ld, rd), 1, + "aggr range: children verify different batches"); + assert_eq!(Bytes::address_eq(d, ld), 1, + "aggr range: output names a different batch than the children"); + assert_eq!(UInt64::to_field(lhi), UInt64::to_field(rlo), + "aggr range: children are not adjacent"); + assert_eq!(UInt64::to_field(lo), UInt64::to_field(llo), + "aggr range: output starts elsewhere than the left child"); + assert_eq!(UInt64::to_field(hi), UInt64::to_field(rhi), + "aggr range: output ends elsewhere than the right child"); + assert_eq!(Goldilocks::eg_eq(Goldilocks::eg_add(lr, rr), r), 1, + "aggr range: output residual is not the children's sum"); + () + } + + fn aggr_range_root(ixvm_vk_digest: [Field; 8], self_vk_digest: [Field; 8], + verify_idx: Field, aggr_idx: Field, allowed_digest: [Field; 8], + out_claim_digest: [Field; 8]) -> () { + let (d, lo, hi, r) = aggr_child_range(0, + ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest); + let sys = aggr_load_sys(0, ixvm_vk_digest, self_vk_digest); + let (headers, messages) = aggr_load_preamble(1, d); + let k = Lists::length(headers); + assert_eq!(StarkVerifier::assert_shard_count_ok(k), 1); + assert_eq!(UInt64::to_field(lo), 0, + "aggr range: root range does not start at shard 0"); + assert_eq!(UInt64::to_field(hi), k, + "aggr range: root range does not end at the last shard"); + assert_eq!(StarkVerifier::assert_closure_pairs(messages, 0, 0), 1); + let (lch, fch, _input) = aggr_batch_challenges(sys, headers, messages); + let total = StarkVerifier::messages_acc(r, messages, lch, fch); + assert_eq!(StarkVerifier::ext_is_zero(total), 1, "aggr range: the batch does not balance"); + let claim = aggr_only_claim(StarkVerifier::batch_claims(headers)); + assert_eq!(Lists::length(claim), 10, + "aggr range: batch must carry a 10-word verify_claim claim"); + assert_eq!(aggr_claim_field(claim, 0), 1, + "aggr range: batch claim has the wrong channel"); + assert_eq!(aggr_claim_field(claim, 1), verify_idx, + "aggr range: batch claim has the wrong entrypoint"); + aggr_assert_digest(aggr_claim_digest(claim, 2), out_claim_digest) + } +} diff --git a/MultiStark/MultiStark/Modules/Mmcs.aiur b/MultiStark/MultiStark/Modules/Mmcs.aiur new file mode 100644 index 000000000..0e877e5fd --- /dev/null +++ b/MultiStark/MultiStark/Modules/Mmcs.aiur @@ -0,0 +1,134 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module Mmcs { + fn mmcs_compress(ap: ProofDeserialize::DigestP, bp: ProofDeserialize::DigestP) -> ProofDeserialize::DigestP { + let IV = [UInt32::from_bytes([UInt8::BYTE_103, UInt8::BYTE_230, UInt8::BYTE_9, UInt8::BYTE_106]), UInt32::from_bytes([UInt8::BYTE_133, UInt8::BYTE_174, UInt8::BYTE_103, UInt8::BYTE_187]), UInt32::from_bytes([UInt8::BYTE_114, UInt8::BYTE_243, UInt8::BYTE_110, UInt8::BYTE_60]), UInt32::from_bytes([UInt8::BYTE_58, UInt8::BYTE_245, UInt8::BYTE_79, UInt8::BYTE_165]), UInt32::from_bytes([UInt8::BYTE_127, UInt8::BYTE_82, UInt8::BYTE_14, UInt8::BYTE_81]), UInt32::from_bytes([UInt8::BYTE_140, UInt8::BYTE_104, UInt8::BYTE_5, UInt8::BYTE_155]), UInt32::from_bytes([UInt8::BYTE_171, UInt8::BYTE_217, UInt8::BYTE_131, UInt8::BYTE_31]), UInt32::from_bytes([UInt8::BYTE_25, UInt8::BYTE_205, UInt8::BYTE_224, UInt8::BYTE_91])]; + let a = (*(ap)); + let b = (*(bp)); + let block = [ + UInt32::from_bytes([a[0][0], a[0][1], a[0][2], a[0][3]]), UInt32::from_bytes([a[0][4], a[0][5], a[0][6], a[0][7]]), + UInt32::from_bytes([a[1][0], a[1][1], a[1][2], a[1][3]]), UInt32::from_bytes([a[1][4], a[1][5], a[1][6], a[1][7]]), + UInt32::from_bytes([a[2][0], a[2][1], a[2][2], a[2][3]]), UInt32::from_bytes([a[2][4], a[2][5], a[2][6], a[2][7]]), + UInt32::from_bytes([a[3][0], a[3][1], a[3][2], a[3][3]]), UInt32::from_bytes([a[3][4], a[3][5], a[3][6], a[3][7]]), + UInt32::from_bytes([b[0][0], b[0][1], b[0][2], b[0][3]]), UInt32::from_bytes([b[0][4], b[0][5], b[0][6], b[0][7]]), + UInt32::from_bytes([b[1][0], b[1][1], b[1][2], b[1][3]]), UInt32::from_bytes([b[1][4], b[1][5], b[1][6], b[1][7]]), + UInt32::from_bytes([b[2][0], b[2][1], b[2][2], b[2][3]]), UInt32::from_bytes([b[2][4], b[2][5], b[2][6], b[2][7]]), + UInt32::from_bytes([b[3][0], b[3][1], b[3][2], b[3][3]]), UInt32::from_bytes([b[3][4], b[3][5], b[3][6], b[3][7]])]; + (&(StarkHash::b3_to_digest(Blake3::compress_init(IV, block, [UInt8::BYTE_0; 8], 64, 11)))) + } + + fn frontier_merge(xs: Lists::List, ys: Lists::List) -> Lists::List { + match (*(xs)) { + Lists::Node::Nil => { ys } , + Lists::Node::Cons(x, xrest) => { match (*(ys)) { + Lists::Node::Nil => { xs } , + Lists::Node::Cons(y, yrest) => { + let Pcs::FrontierNode::Mk(xi, _xb, xr, xd) = x; + let Pcs::FrontierNode::Mk(yi, _yb, yr, yd) = y; + match UInt32::less_than_fields(xi, yi) { + 1 => { (&(Lists::Node::Cons(x, frontier_merge(xrest, ys)))) } , + _ => { match Fields::is_zero(xi - yi) { + 1 => { + + assert_eq!(StarkHash::digest_eq(xd, yd), 1); + assert_eq!(StarkVerifier::assert_same_claims(xr, yr), 1); + (&(Lists::Node::Cons(x, frontier_merge(xrest, yrest)))) } , + _ => { (&(Lists::Node::Cons(y, frontier_merge(xs, yrest)))) } , + } } , + } } , + } } , + } + } + + fn frontier_split(xs: Lists::List) -> (Lists::List, Lists::List) { + match (*(xs)) { + Lists::Node::Nil => { ((&(Lists::Node::Nil)), (&(Lists::Node::Nil))) } , + Lists::Node::Cons(x, rest) => { match (*(rest)) { + Lists::Node::Nil => { ((&(Lists::Node::Cons(x, (&(Lists::Node::Nil))))), (&(Lists::Node::Nil))) } , + Lists::Node::Cons(y, tail) => { + let (left, right) = frontier_split(tail); + ((&(Lists::Node::Cons(x, left))), (&(Lists::Node::Cons(y, right)))) } , + } } , + } + } + + fn frontier_sort(xs: Lists::List) -> Lists::List { + match (*(xs)) { + Lists::Node::Nil => { xs } , + Lists::Node::Cons(_x, rest) => { match (*(rest)) { + Lists::Node::Nil => { xs } , + Lists::Node::Cons(_y, _tail) => { + let (left, right) = frontier_split(xs); + frontier_merge(frontier_sort(left), frontier_sort(right)) } , + } } , + } + } + + fn frontier_leaves(indices: Lists::List>, rows: Lists::List>>, + lhs: Lists::List, log_max: Field) -> Lists::List { + match (*(indices)) { + Lists::Node::Nil => { + assert_eq!(Lists::length(rows), 0); + (&(Lists::Node::Nil)) } , + Lists::Node::Cons(bits, irest) => { + let &Lists::Node::Cons(r, rrest) = rows; + let d = Pcs::leaf_hash_at(r, lhs, log_max); + (&(Lists::Node::Cons(Pcs::FrontierNode::Mk(Pcs::bits_to_num(bits), bits, r, d), + frontier_leaves(irest, rrest, lhs, log_max)))) } , + } + } + + fn frontier_level(nodes: Lists::List, proof: Lists::List, + lhs: Lists::List, next_lh: Field) -> (Lists::List, Lists::List) { + match (*(nodes)) { + Lists::Node::Nil => { ((&(Lists::Node::Nil)), proof) } , + Lists::Node::Cons(a, rest) => { + let Pcs::FrontierNode::Mk(ai, abits, ar, ad) = a; + let &Lists::Node::Cons(abit, aparent_bits) = abits; + let aparent = Pcs::bits_to_num(aparent_bits); + match (*(rest)) { + Lists::Node::Cons(b, brest) => { + let Pcs::FrontierNode::Mk(bi, bbits, br, bd) = b; + let &Lists::Node::Cons(_bbit, bparent_bits) = bbits; + match Fields::is_zero(aparent - Pcs::bits_to_num(bparent_bits)) { + 1 => { + + assert_eq!(StarkVerifier::assert_same_claims(Pcs::select_rows_le(ar, lhs, next_lh), Pcs::select_rows_le(br, lhs, next_lh)), 1); + let parent = Pcs::inject_maybe(ar, lhs, next_lh, mmcs_compress(ad, bd)); + let (tail, p2) = frontier_level(brest, proof, lhs, next_lh); + ((&(Lists::Node::Cons(Pcs::FrontierNode::Mk(aparent, aparent_bits, ar, parent), tail))), p2) } , + _ => { + let &Lists::Node::Cons(sib, prest) = proof; + let parent = Pcs::inject_maybe(ar, lhs, next_lh, Pcs::compress_ordered(abit, ad, sib)); + let (tail, p2) = frontier_level(rest, prest, lhs, next_lh); + ((&(Lists::Node::Cons(Pcs::FrontierNode::Mk(aparent, aparent_bits, ar, parent), tail))), p2) } , + } } , + Lists::Node::Nil => { + let &Lists::Node::Cons(sib, prest) = proof; + let parent = Pcs::inject_maybe(ar, lhs, next_lh, Pcs::compress_ordered(abit, ad, sib)); + ((&(Lists::Node::Cons(Pcs::FrontierNode::Mk(aparent, aparent_bits, ar, parent), (&(Lists::Node::Nil))))), prest) } , + } } , + } + } + + fn frontier_fold(nodes: Lists::List, proof: Lists::List, + lhs: Lists::List, levels: Field) -> (Lists::List, Lists::List) { + match levels { + 0 => { (nodes, proof) } , + _ => { + let (next, p2) = frontier_level(nodes, proof, lhs, levels - 1); + frontier_fold(next, p2, lhs, levels - 1) } , + } + } + + fn mmcs_verify_multi(cap: ProofDeserialize::MerkleCap, rows: Lists::List>>, + lhs: Lists::List, indices: Lists::List>, proof: Lists::List, log_max: Field) -> Field { + assert_eq!(Fields::is_zero(Lists::length(rows) - Lists::length(indices)), 1); + let leaves = frontier_sort(frontier_leaves(indices, rows, lhs, log_max)); + let (roots, rest) = frontier_fold(leaves, proof, lhs, log_max); + assert_eq!(Lists::length(rest), 0); + let &Lists::Node::Cons(root, no_more) = roots; + assert_eq!(Lists::length(no_more), 0); + let Pcs::FrontierNode::Mk(capidx, _bits, _rows, digest) = root; + StarkHash::digest_eq(Lists::lookup(cap, capidx), digest) + } +} diff --git a/MultiStark/MultiStark/Modules/Pcs.aiur b/MultiStark/MultiStark/Modules/Pcs.aiur new file mode 100644 index 000000000..1d7ffaf50 --- /dev/null +++ b/MultiStark/MultiStark/Modules/Pcs.aiur @@ -0,0 +1,597 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module Pcs { + enum FrontierNode { Mk(Field, Lists::List, Lists::List>, ProofDeserialize::DigestP) } + + enum Bucket { Mk(Field, ProofDeserialize::Ext, ProofDeserialize::Ext) } + + fn compress_ordered(bit: Field, d: ProofDeserialize::DigestP, s: ProofDeserialize::DigestP) -> ProofDeserialize::DigestP { + match bit { + 0 => { Mmcs::mmcs_compress(d, s) } , + _ => { Mmcs::mmcs_compress(s, d) } , + } + } + + fn has_height(lhs: Lists::List, target: Field) -> Field { + match (*(lhs)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(h, rest) => { + match Fields::is_zero(h - target) { + 1 => { 1 } , + _ => { has_height(rest, target) } , + } } , + } + } + + fn select_rows(rows: Lists::List>, lhs: Lists::List, target: Field) -> Lists::List> { + match (*(rows)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(r, rrest) => { + let &Lists::Node::Cons(lh, lrest) = lhs; + match Fields::is_zero(lh - target) { + 0 => { select_rows(rrest, lrest, target) } , + _ => { match (*(r)) { + Lists::Node::Nil => { select_rows(rrest, lrest, target) } , + _ => { (&(Lists::Node::Cons(r, select_rows(rrest, lrest, target)))) } , + } } , + } } , + } + } + + fn select_rows_le(rows: Lists::List>, lhs: Lists::List, target: Field) -> Lists::List> { + match (*(rows)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(r, rrest) => { + let &Lists::Node::Cons(lh, lrest) = lhs; + match UInt32::less_than_fields(target, lh) { + 1 => { select_rows_le(rrest, lrest, target) } , + _ => { match (*(r)) { + Lists::Node::Nil => { select_rows_le(rrest, lrest, target) } , + _ => { (&(Lists::Node::Cons(r, select_rows_le(rrest, lrest, target)))) } , + } } , + } } , + } + } + + fn rows_pop(cur: Lists::List, rows: Lists::List>) -> (UInt64::U64, Lists::List, Lists::List>, Field) { + match (*(cur)) { + Lists::Node::Cons(x, rest) => { (Goldilocks::gl_to_bytes(Goldilocks::gl_val(x)), rest, rows, 1) } , + Lists::Node::Nil => { match (*(rows)) { + Lists::Node::Nil => { ([UInt8::BYTE_0; 8], cur, rows, 0) } , + Lists::Node::Cons(r, rrest) => { rows_pop(r, rrest) } , + } } , + } + } + + fn leaf_hash_at(rows: Lists::List>, lhs: Lists::List, target: Field) -> ProofDeserialize::DigestP { + (&(StarkHash::b3_to_digest(StarkHash::b3_rows(select_rows(rows, lhs, target))))) + } + + fn inject_maybe(rows: Lists::List>, lhs: Lists::List, lh: Field, d: ProofDeserialize::DigestP) -> ProofDeserialize::DigestP { + match has_height(lhs, lh) { + 0 => { d } , + _ => { Mmcs::mmcs_compress(d, leaf_hash_at(rows, lhs, lh)) } , + } + } + + fn bits_to_num(bits: Lists::List) -> Field { + match (*(bits)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(b, rest) => { b + 2 * bits_to_num(rest) } , + } + } + + fn glist_rev(l: Lists::List, acc: Lists::List) -> Lists::List { + match (*(l)) { + Lists::Node::Nil => { acc } , + Lists::Node::Cons(b, rest) => { glist_rev(rest, (&(Lists::Node::Cons(b, acc)))) } , + } + } + + fn exp_by_bits(base: Goldilocks::Goldilocks, bits: Lists::List) -> Goldilocks::Goldilocks { + match (*(bits)) { + Lists::Node::Nil => { 1 } , + Lists::Node::Cons(b, rest) => { + let half = exp_by_bits(base * base, rest); + match b { + 0 => { half } , + _ => { base * half } , + } } , + } + } + + fn fri_fold2(index_bits: Lists::List, log_height: Field, beta: ProofDeserialize::Ext, e0: ProofDeserialize::Ext, e1: ProofDeserialize::Ext) -> ProofDeserialize::Ext { + let g = StarkVerifier::two_adic_gen(log_height + 1); + let s = exp_by_bits(g, glist_rev(index_bits, (&(Lists::Node::Nil)))); + let two_s = s + s; + let t1 = Goldilocks::eg_div(Goldilocks::eg_add(e0, e1), [2, 0]); + let t2 = Goldilocks::eg_mul(beta, Goldilocks::eg_div(Goldilocks::eg_sub(e0, e1), [two_s, 0])); + Goldilocks::eg_add(t1, t2) + } + + inline fn ro_x(index_bits: Lists::List, log_height: Field) -> Goldilocks::Goldilocks { + 7 * exp_by_bits(StarkVerifier::two_adic_gen(log_height), glist_rev(index_bits, (&(Lists::Node::Nil)))) + } + + fn ro_fold(p_x: Lists::List, p_z: Lists::List, alpha: ProofDeserialize::Ext, s: ProofDeserialize::Ext, ap: ProofDeserialize::Ext) + -> (ProofDeserialize::Ext, ProofDeserialize::Ext) { + match (*(p_x)) { + Lists::Node::Nil => { (s, ap) } , + Lists::Node::Cons(lane, pxr) => { + let &Lists::Node::Cons(pz, pzr) = p_z; + let term = Goldilocks::eg_mul(ap, Goldilocks::eg_sub(pz, [ProofDeserialize::limb_to_field(lane), 0])); + ro_fold(pxr, pzr, alpha, Goldilocks::eg_add(s, term), Goldilocks::eg_mul(ap, alpha)) } , + } + } + + fn ext_row_onto(row: Lists::List, tail: Bytes::Stream) -> Bytes::Stream { + match (*(row)) { + Lists::Node::Nil => { tail } , + Lists::Node::Cons(e, rest) => { StarkVerifier::b8_onto(Goldilocks::gl_to_bytes(e[0]), StarkVerifier::b8_onto(Goldilocks::gl_to_bytes(e[1]), ext_row_onto(rest, tail))) } , + } + } + + fn points_onto(pts: Lists::List>, tail: Bytes::Stream) -> Bytes::Stream { + match (*(pts)) { + Lists::Node::Nil => { tail } , + Lists::Node::Cons(row, rest) => { ext_row_onto(row, points_onto(rest, tail)) } , + } + } + + fn round_onto(round: ProofDeserialize::OpenedRound, tail: Bytes::Stream) -> Bytes::Stream { + match (*(round)) { + Lists::Node::Nil => { tail } , + Lists::Node::Cons(mat, rest) => { points_onto(mat, round_onto(rest, tail)) } , + } + } + + inline fn prep_onto(prep_opt: ProofDeserialize::PreprocessedOpt, tail: Bytes::Stream) -> Bytes::Stream { + match prep_opt { + ProofDeserialize::PreprocessedOpt::NoPreprocessed => { tail } , + ProofDeserialize::PreprocessedOpt::SomePreprocessed(round) => { round_onto(round, tail) } , + } + } + + fn obs_log_arities(input: Bytes::Stream, comms: Lists::List) -> Bytes::Stream { + match (*(comms)) { + Lists::Node::Nil => { input } , + Lists::Node::Cons(_c, rest) => { + obs_log_arities(StarkVerifier::snoc_b8(input, [UInt8::BYTE_1, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0]), rest) } , + } + } + + fn pcs_check_witness(input: Bytes::Stream, witness: UInt64::U64, bits: Field) -> (Bytes::Stream, Bytes::Stream) { + match bits { + 0 => { (input, (&(Lists::Node::Nil))) } , + _ => { + let (pbits, i1, o1) = Transcript::ch_sample_bits(StarkVerifier::snoc_b8(input, witness), (&(Lists::Node::Nil)), bits); + assert_eq!(bits_to_num(pbits), 0); + (i1, o1) } , + } + } + + fn pcs_betas(input: Bytes::Stream, comms: Lists::List, witnesses: Lists::List, bits: Field) + -> (Lists::List, Bytes::Stream) { + match (*(comms)) { + Lists::Node::Nil => { ((&(Lists::Node::Nil)), input) } , + Lists::Node::Cons(c, rest) => { + let &Lists::Node::Cons(w, wrest) = witnesses; + let (i1, o1) = pcs_check_witness(StarkVerifier::snoc_cap(input, c), w, bits); + let (b0, b1, i2, _o) = Transcript::ch_sample_ext(i1, o1); + let (bs, i3) = pcs_betas(i2, rest, wrest, bits); + ((&(Lists::Node::Cons([Goldilocks::gl_val(b0), Goldilocks::gl_val(b1)], bs))), i3) } , + } + } + + fn circ_has_height(log_degrees: Lists::List, log_blowup: Field, rem: Field, i: Field, h: Field) -> Field { + match rem { + 0 => { 0 } , + _ => { match Fields::is_zero(UInt8::to_field(Lists::lookup(log_degrees, i)) + log_blowup - h) { + 1 => { 1 } , + _ => { circ_has_height(log_degrees, log_blowup, rem - 1, i + 1, h) } , + } } , + } + } + + fn build_buckets(log_degrees: Lists::List, log_blowup: Field, num_circuits: Field, h: Field) -> Lists::List { + match h { + 0 => { (&(Lists::Node::Nil)) } , + _ => { match circ_has_height(log_degrees, log_blowup, num_circuits, 0, h) { + 0 => { build_buckets(log_degrees, log_blowup, num_circuits, h - 1) } , + _ => { (&(Lists::Node::Cons( + Bucket::Mk(h, [1, 0], [0, 0]), + build_buckets(log_degrees, log_blowup, num_circuits, h - 1)))) } , + } } , + } + } + + fn bucket_update(buckets: Lists::List, lh: Field, p_x: Lists::List, p_z: Lists::List, + q: ProofDeserialize::Ext, alpha: ProofDeserialize::Ext) -> Lists::List { + match (*(buckets)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(b, rest) => { + let Bucket::Mk(h, ap, ro) = b; + match Fields::is_zero(h - lh) { + 1 => { + let (s, ap2) = ro_fold(p_x, p_z, alpha, [0, 0], ap); + let ro2 = Goldilocks::eg_add(ro, Goldilocks::eg_mul(q, s)); + (&(Lists::Node::Cons(Bucket::Mk(h, ap2, ro2), rest))) } , + _ => { (&(Lists::Node::Cons(b, bucket_update(rest, lh, p_x, p_z, q, alpha)))) } , + } } , + } + } + + fn assert_blowup_zero(buckets: Lists::List, log_blowup: Field) -> Field { + match (*(buckets)) { + Lists::Node::Nil => { 1 } , + Lists::Node::Cons(b, rest) => { + let Bucket::Mk(h, _ap, ro) = b; + match Fields::is_zero(h - log_blowup) { + 1 => { assert_eq!(Goldilocks::eg_eq(ro, [0, 0]), 1); 1 } , + _ => { assert_blowup_zero(rest, log_blowup) } , + } } , + } + } + + fn prep_count(prep_opt: ProofDeserialize::PreprocessedOpt) -> Field { + match prep_opt { + ProofDeserialize::PreprocessedOpt::NoPreprocessed => { 0 } , + ProofDeserialize::PreprocessedOpt::SomePreprocessed(_r) => { 1 } , + } + } + + fn ri_apply(buckets: Lists::List, lh: Field, idxbits: Lists::List, log_gmax: Field, + z: ProofDeserialize::Ext, p_x: Lists::List, p_z: Lists::List, alpha: ProofDeserialize::Ext) -> Lists::List { + + assert_eq!(Fields::is_zero(Lists::length(p_x) - Lists::length(p_z)), 1); + let x = ro_x(Lists::drop(idxbits, log_gmax - lh), lh); + let q = Goldilocks::eg_inverse(Goldilocks::eg_sub(z, [x, 0])); + bucket_update(buckets, lh, p_x, p_z, q, alpha) + } + + fn open_2pt_mat(buckets: Lists::List, idxbits: Lists::List, log_gmax: Field, lh: Field, + ldeg: Field, zeta: ProofDeserialize::Ext, p_x: Lists::List, mat: Lists::List>, alpha: ProofDeserialize::Ext) + -> Lists::List { + let pz0 = Lists::lookup(mat, 0); + let pz1 = Lists::lookup(mat, 1); + let zn = Goldilocks::eg_mul(zeta, [StarkVerifier::two_adic_gen(ldeg), 0]); + let b1 = ri_apply(buckets, lh, idxbits, log_gmax, zeta, p_x, pz0, alpha); + ri_apply(b1, lh, idxbits, log_gmax, zn, p_x, pz1, alpha) + } + + fn open_batch_2pt(buckets: Lists::List, idxbits: Lists::List, log_gmax: Field, log_blowup: Field, ci: Field, + rem: Field, log_degrees: Lists::List, zeta: ProofDeserialize::Ext, base_rows: Lists::List>, + opened: ProofDeserialize::OpenedRound, alpha: ProofDeserialize::Ext) -> Lists::List { + match rem { + 0 => { buckets } , + _ => { + let ldeg = UInt8::to_field(Lists::lookup(log_degrees, ci)); + let b = open_2pt_mat(buckets, idxbits, log_gmax, ldeg + log_blowup, ldeg, zeta, + Lists::lookup(base_rows, ci), Lists::lookup(opened, ci), alpha); + open_batch_2pt(b, idxbits, log_gmax, log_blowup, ci + 1, rem - 1, log_degrees, zeta, + base_rows, opened, alpha) } , + } + } + + fn open_quotient(buckets: Lists::List, idxbits: Lists::List, log_gmax: Field, log_blowup: Field, ci: Field, + rem: Field, log_degrees: Lists::List, zeta: ProofDeserialize::Ext, + base_rows: Lists::List>, q_opened: ProofDeserialize::OpenedRound, alpha: ProofDeserialize::Ext) -> Lists::List { + match rem { + 0 => { buckets } , + _ => { + let lh = UInt8::to_field(Lists::lookup(log_degrees, ci)) + log_blowup; + let b = ri_apply(buckets, lh, idxbits, log_gmax, zeta, + Lists::lookup(base_rows, ci), Lists::lookup(Lists::lookup(q_opened, ci), 0), alpha); + open_quotient(b, idxbits, log_gmax, log_blowup, ci + 1, rem - 1, log_degrees, zeta, base_rows, q_opened, alpha) } , + } + } + + fn open_prep(buckets: Lists::List, idxbits: Lists::List, log_gmax: Field, log_blowup: Field, ci: Field, rem: Field, + k: Field, log_degrees: Lists::List, prep_indices: Lists::List, zeta: ProofDeserialize::Ext, + base_rows: Lists::List>, prep_round: ProofDeserialize::OpenedRound, alpha: ProofDeserialize::Ext) -> Lists::List { + match rem { + 0 => { buckets } , + _ => { match Lists::lookup(prep_indices, ci) { + SystemDeserialize::OptIdx::NoIdx => { + open_prep(buckets, idxbits, log_gmax, log_blowup, ci + 1, rem - 1, k, log_degrees, + prep_indices, zeta, base_rows, prep_round, alpha) } , + SystemDeserialize::OptIdx::SomeIdx(_j) => { + let ldeg = UInt8::to_field(Lists::lookup(log_degrees, ci)); + let b = open_2pt_mat(buckets, idxbits, log_gmax, ldeg + log_blowup, ldeg, zeta, + Lists::lookup(base_rows, k), Lists::lookup(prep_round, k), alpha); + open_prep(b, idxbits, log_gmax, log_blowup, ci + 1, rem - 1, k + 1, log_degrees, + prep_indices, zeta, base_rows, prep_round, alpha) } , + } } , + } + } + + fn open_prep_batch(buckets: Lists::List, input_proof: Lists::List, + prep_commit: ProofDeserialize::MerkleCap, prep_opt: ProofDeserialize::PreprocessedOpt, prep_indices: Lists::List, + log_degrees: Lists::List, num_circuits: Field, idxbits: Lists::List, log_gmax: Field, log_blowup: Field, + zeta: ProofDeserialize::Ext, alpha: ProofDeserialize::Ext) -> Lists::List { + match prep_opt { + ProofDeserialize::PreprocessedOpt::NoPreprocessed => { buckets } , + ProofDeserialize::PreprocessedOpt::SomePreprocessed(prep_round) => { + let ProofDeserialize::BatchOpening::Mk(rows_p) = Lists::lookup(input_proof, 3); + + assert_eq!(Fields::is_zero(Lists::length(rows_p) - Lists::length(prep_round)), 1); + + let prep_heights = heights_prep(log_degrees, log_blowup, prep_indices, num_circuits, 0); + let log_pmax = heights_max(prep_heights); + open_prep(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, 0, log_degrees, + prep_indices, zeta, rows_p, prep_round, alpha) } , + } + } + + fn heights_all(log_degrees: Lists::List, log_blowup: Field, rem: Field, i: Field) -> Lists::List { + match rem { + 0 => { (&(Lists::Node::Nil)) } , + _ => { (&(Lists::Node::Cons(UInt8::to_field(Lists::lookup(log_degrees, i)) + log_blowup, + heights_all(log_degrees, log_blowup, rem - 1, i + 1)))) } , + } + } + + fn heights_max(hs: Lists::List) -> Field { + match (*(hs)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(h, rest) => { + let m = heights_max(rest); + match UInt32::less_than_fields(m, h) { + 0 => { m } , + _ => { h } , + } } , + } + } + + fn heights_prep(log_degrees: Lists::List, log_blowup: Field, prep_indices: Lists::List, rem: Field, i: Field) -> Lists::List { + match rem { + 0 => { (&(Lists::Node::Nil)) } , + _ => { match Lists::lookup(prep_indices, i) { + SystemDeserialize::OptIdx::NoIdx => { heights_prep(log_degrees, log_blowup, prep_indices, rem - 1, i + 1) } , + SystemDeserialize::OptIdx::SomeIdx(_j) => { + (&(Lists::Node::Cons(UInt8::to_field(Lists::lookup(log_degrees, i)) + log_blowup, + heights_prep(log_degrees, log_blowup, prep_indices, rem - 1, i + 1)))) } , + } } , + } + } + + inline fn recon_evals(bit: Field, folded: ProofDeserialize::Ext, sib: ProofDeserialize::Ext) -> (ProofDeserialize::Ext, ProofDeserialize::Ext) { + match bit { + 0 => { (folded, sib) } , + _ => { (sib, folded) } , + } + } + + inline fn flatten2(e0: ProofDeserialize::Ext, e1: ProofDeserialize::Ext) -> Lists::List { + (&(Lists::Node::Cons(Goldilocks::gl_to_bytes(e0[0]), (&(Lists::Node::Cons(Goldilocks::gl_to_bytes(e0[1]), + (&(Lists::Node::Cons(Goldilocks::gl_to_bytes(e1[0]), (&(Lists::Node::Cons(Goldilocks::gl_to_bytes(e1[1]), (&(Lists::Node::Nil)))))))))))))) + } + + fn rollin(folded: ProofDeserialize::Ext, log_folded: Field, beta: ProofDeserialize::Ext, ro_rest: Lists::List) -> (ProofDeserialize::Ext, Lists::List) { + match (*(ro_rest)) { + Lists::Node::Nil => { (folded, ro_rest) } , + Lists::Node::Cons(b, rest) => { + let Bucket::Mk(h, _ap, ro) = b; + match Fields::is_zero(h - log_folded) { + 1 => { (Goldilocks::eg_add(folded, Goldilocks::eg_mul(StarkVerifier::ext_exp_pow2(beta, 1), ro)), rest) } , + _ => { (folded, ro_rest) } , + } } , + } + } + + fn verify_query(folded: ProofDeserialize::Ext, betas: Lists::List, comms: Lists::List, + openings: Lists::List, domidx: Lists::List, log_cur: Field, + ro_rest: Lists::List, log_final: Field) -> (ProofDeserialize::Ext, Lists::List>) { + match (*(openings)) { + Lists::Node::Nil => { + + assert_eq!(Fields::is_zero(log_cur - log_final), 1); + assert_eq!(Lists::length(ro_rest), 0); + (folded, (&(Lists::Node::Nil))) } , + Lists::Node::Cons(op, op_rest) => { + let &Lists::Node::Cons(beta, beta_rest) = betas; + let &Lists::Node::Cons(comm, comm_rest) = comms; + let ProofDeserialize::CommitPhaseProofStep::Mk(_la, sibs) = op; + + assert_eq!(Lists::length(sibs), 1); + let &Lists::Node::Cons(ibit, idrest) = domidx; + let log_folded = log_cur - 1; + let (e0, e1) = recon_evals(ibit, folded, Lists::lookup(sibs, 0)); + let folded1 = fri_fold2(idrest, log_folded, beta, e0, e1); + let (folded2, ro_rest2) = rollin(folded1, log_folded, beta, ro_rest); + let (result, rows) = verify_query(folded2, beta_rest, comm_rest, op_rest, idrest, log_folded, ro_rest2, log_final); + (result, (&(Lists::Node::Cons(flatten2(e0, e1), rows)))) } , + } + } + + fn verify_one_query(idxbits: Lists::List, qp: ProofDeserialize::QueryProof, alpha: ProofDeserialize::Ext, + stage1: ProofDeserialize::OpenedRound, stage2: ProofDeserialize::OpenedRound, q_opened: ProofDeserialize::OpenedRound, + prep_opt: ProofDeserialize::PreprocessedOpt, s1c: ProofDeserialize::MerkleCap, s2c: ProofDeserialize::MerkleCap, qc: ProofDeserialize::MerkleCap, + prep_commit: ProofDeserialize::MerkleCap, prep_indices: Lists::List, + log_degrees: Lists::List, zeta: ProofDeserialize::Ext, num_circuits: Field, log_blowup: Field, log_gmax: Field, + betas: Lists::List, commit_phase_commits: Lists::List, final_poly: Lists::List, + num_rounds: Field) -> Lists::List> { + let ProofDeserialize::QueryProof::Mk(input_proof, commit_phase_openings) = qp; + + assert_eq!(Fields::is_zero(Lists::length(commit_phase_openings) - num_rounds), 1); + assert_eq!(Fields::is_zero(Lists::length(input_proof) - (3 + prep_count(prep_opt))), 1); + let buckets = build_buckets(log_degrees, log_blowup, num_circuits, log_gmax); + + let hall = heights_all(log_degrees, log_blowup, num_circuits, 0); + let ProofDeserialize::BatchOpening::Mk(rows_s1) = Lists::lookup(input_proof, 0); + assert_eq!(Fields::is_zero(Lists::length(rows_s1) - num_circuits), 1); + let buckets = open_batch_2pt(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, log_degrees, zeta, rows_s1, stage1, alpha); + let ProofDeserialize::BatchOpening::Mk(rows_s2) = Lists::lookup(input_proof, 1); + assert_eq!(Fields::is_zero(Lists::length(rows_s2) - num_circuits), 1); + let buckets = open_batch_2pt(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, log_degrees, zeta, rows_s2, stage2, alpha); + let ProofDeserialize::BatchOpening::Mk(rows_q) = Lists::lookup(input_proof, 2); + + assert_eq!(Fields::is_zero(Lists::length(rows_q) - num_circuits), 1); + let buckets = open_quotient(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, log_degrees, zeta, rows_q, q_opened, alpha); + let buckets = open_prep_batch(buckets, input_proof, prep_commit, prep_opt, prep_indices, log_degrees, num_circuits, idxbits, log_gmax, log_blowup, zeta, alpha); + + let _cz = assert_blowup_zero(buckets, log_blowup); + + let &Lists::Node::Cons(b0, ro_rest) = buckets; + let Bucket::Mk(h0, _ap0, folded_start) = b0; + assert_eq!(Fields::is_zero(h0 - log_gmax), 1); + let (folded, fri_rows) = verify_query(folded_start, betas, commit_phase_commits, commit_phase_openings, idxbits, log_gmax, ro_rest, log_blowup); + + assert_eq!(Goldilocks::eg_eq(Lists::lookup(final_poly, 0), folded), 1); + fri_rows + } + + fn query_loop(input: Bytes::Stream, output: Bytes::Stream, query_proofs: Lists::List, + alpha: ProofDeserialize::Ext, stage1: ProofDeserialize::OpenedRound, stage2: ProofDeserialize::OpenedRound, q_opened: ProofDeserialize::OpenedRound, + prep_opt: ProofDeserialize::PreprocessedOpt, s1c: ProofDeserialize::MerkleCap, s2c: ProofDeserialize::MerkleCap, qc: ProofDeserialize::MerkleCap, + prep_commit: ProofDeserialize::MerkleCap, prep_indices: Lists::List, + log_degrees: Lists::List, zeta: ProofDeserialize::Ext, num_circuits: Field, log_blowup: Field, log_gmax: Field, + betas: Lists::List, commit_phase_commits: Lists::List, final_poly: Lists::List, + num_rounds: Field) -> Lists::List>> { + match (*(query_proofs)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(qp, rest) => { + let (idxbits, input2, output2) = Transcript::ch_sample_bits(input, output, log_gmax); + let qrows = verify_one_query(idxbits, qp, alpha, stage1, stage2, q_opened, prep_opt, + s1c, s2c, qc, prep_commit, prep_indices, log_degrees, zeta, num_circuits, + log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds); + (&(Lists::Node::Cons(qrows, query_loop(input2, output2, rest, alpha, stage1, stage2, q_opened, prep_opt, + s1c, s2c, qc, prep_commit, prep_indices, log_degrees, zeta, num_circuits, + log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds)))) } , + } + } + + fn sample_query_indices(input: Bytes::Stream, output: Bytes::Stream, n: Field, + log_gmax: Field) -> Lists::List> { + match n { + 0 => { (&(Lists::Node::Nil)) } , + _ => { + let (bits, input2, output2) = Transcript::ch_sample_bits(input, output, log_gmax); + (&(Lists::Node::Cons(bits, sample_query_indices(input2, output2, n - 1, log_gmax)))) } , + } + } + + fn batch_views_at(bs: Lists::List, q: Field) -> Lists::List { + match (*(bs)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(b, rest) => { + let ProofDeserialize::BatchMultiOpening::Mk(rows, _proof) = b; + (&(Lists::Node::Cons(ProofDeserialize::BatchOpening::Mk(Lists::lookup(rows, q)), batch_views_at(rest, q)))) } , + } + } + + fn step_views_at(ss: Lists::List, q: Field) -> Lists::List { + match (*(ss)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(s, rest) => { + let ProofDeserialize::CommitPhaseMultiStep::Mk(la, sibs, _proof) = s; + (&(Lists::Node::Cons(ProofDeserialize::CommitPhaseProofStep::Mk(la, Lists::lookup(sibs, q)), step_views_at(rest, q)))) } , + } + } + + fn query_views(bs: Lists::List, ss: Lists::List, + q: Field, n: Field) -> Lists::List { + match n { + 0 => { (&(Lists::Node::Nil)) } , + _ => { (&(Lists::Node::Cons(ProofDeserialize::QueryProof::Mk(batch_views_at(bs, q), step_views_at(ss, q)), + query_views(bs, ss, q + 1, n - 1)))) } , + } + } + + fn verify_input_multi(bs: Lists::List, indices: Lists::List>, + s1c: ProofDeserialize::MerkleCap, s2c: ProofDeserialize::MerkleCap, qc: ProofDeserialize::MerkleCap, prep_commit: ProofDeserialize::MerkleCap, + prep_opt: ProofDeserialize::PreprocessedOpt, prep_indices: Lists::List, log_degrees: Lists::List, + num_circuits: Field, log_blowup: Field, log_gmax: Field) -> Field { + let hall = heights_all(log_degrees, log_blowup, num_circuits, 0); + let ProofDeserialize::BatchMultiOpening::Mk(s1rows, s1proof) = Lists::lookup(bs, 0); + let ProofDeserialize::BatchMultiOpening::Mk(s2rows, s2proof) = Lists::lookup(bs, 1); + let ProofDeserialize::BatchMultiOpening::Mk(qrows, qproof) = Lists::lookup(bs, 2); + assert_eq!(Mmcs::mmcs_verify_multi(s1c, s1rows, hall, indices, s1proof, log_gmax), 1); + assert_eq!(Mmcs::mmcs_verify_multi(s2c, s2rows, hall, indices, s2proof, log_gmax), 1); + assert_eq!(Mmcs::mmcs_verify_multi(qc, qrows, hall, indices, qproof, log_gmax), 1); + match prep_opt { + ProofDeserialize::PreprocessedOpt::NoPreprocessed => { 1 } , + ProofDeserialize::PreprocessedOpt::SomePreprocessed(_round) => { + let ProofDeserialize::BatchMultiOpening::Mk(prows, pproof) = Lists::lookup(bs, 3); + let ph = heights_prep(log_degrees, log_blowup, prep_indices, num_circuits, 0); + let lp = heights_max(ph); + let pindices = drop_index_bits(indices, log_gmax - lp); + Mmcs::mmcs_verify_multi(prep_commit, prows, ph, pindices, pproof, lp) } , + } + } + + fn drop_index_bits(indices: Lists::List>, n: Field) -> Lists::List> { + match (*(indices)) { + Lists::Node::Nil => { indices } , + Lists::Node::Cons(bits, rest) => { + (&(Lists::Node::Cons(Lists::drop(bits, n), drop_index_bits(rest, n)))) } , + } + } + + fn rows_at_round(rows: Lists::List>>, r: Field) -> Lists::List>> { + match (*(rows)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(qrows, rest) => { + (&(Lists::Node::Cons((&(Lists::Node::Cons(Lists::lookup(qrows, r), (&(Lists::Node::Nil))))), + rows_at_round(rest, r)))) } , + } + } + + fn verify_commit_multi(steps: Lists::List, comms: Lists::List, + all_rows: Lists::List>>, indices: Lists::List>, r: Field, + log_cur: Field) -> Field { + match (*(steps)) { + Lists::Node::Nil => { Fields::is_zero(Lists::length(comms)) } , + Lists::Node::Cons(s, srest) => { + let &Lists::Node::Cons(c, crest) = comms; + let ProofDeserialize::CommitPhaseMultiStep::Mk(la, sibs, proof) = s; + assert_eq!(UInt8::to_field(la), 1); + assert_eq!(Lists::length(sibs), Lists::length(indices)); + let next_indices = drop_index_bits(indices, 1); + let lh = log_cur - 1; + assert_eq!(Mmcs::mmcs_verify_multi(c, rows_at_round(all_rows, r), + (&(Lists::Node::Cons(lh, (&(Lists::Node::Nil))))), next_indices, proof, lh), 1); + verify_commit_multi(srest, crest, all_rows, next_indices, r + 1, lh) } , + } + } + + inline fn pcs_fri_verify(post_zeta_input: Bytes::Stream, stage1: ProofDeserialize::OpenedRound, stage2: ProofDeserialize::OpenedRound, + q_opened: ProofDeserialize::OpenedRound, prep_opt: ProofDeserialize::PreprocessedOpt, opening: ProofDeserialize::FriProof, + s1c: ProofDeserialize::MerkleCap, s2c: ProofDeserialize::MerkleCap, qc: ProofDeserialize::MerkleCap, prep_commit: ProofDeserialize::MerkleCap, + prep_indices: Lists::List, log_degrees: Lists::List, + zeta: ProofDeserialize::Ext, num_circuits: Field, log_blowup: Field, num_queries: Field, commit_pow_bits: Field, + query_pow_bits: Field) -> Field { + let ProofDeserialize::FriProof::Mk(commit_phase_commits, pw, input_openings, commit_phase_openings, + final_poly, qpw) = opening; + let num_rounds = Lists::length(commit_phase_commits); + + assert_eq!(Fields::is_zero(Lists::length(pw) - num_rounds), 1); + assert_eq!(Lists::length(input_openings), 3 + prep_count(prep_opt)); + assert_eq!(Fields::is_zero(Lists::length(commit_phase_openings) - num_rounds), 1); + assert_eq!(Lists::length(final_poly), 1); + + let obs = round_onto(stage1, round_onto(stage2, round_onto(q_opened, + prep_onto(prep_opt, (&(Lists::Node::Nil)))))); + let input = Lists::concat(post_zeta_input, obs); + + let (a0, a1, input, _oa) = Transcript::ch_sample_ext(input, (&(Lists::Node::Nil))); + let alpha = [Goldilocks::gl_val(a0), Goldilocks::gl_val(a1)]; + + let (betas, input) = pcs_betas(input, commit_phase_commits, pw, commit_pow_bits); + let input = Lists::concat(input, ext_row_onto(final_poly, (&(Lists::Node::Nil)))); + let input = obs_log_arities(input, commit_phase_commits); + + let (input, output) = pcs_check_witness(input, qpw, query_pow_bits); + + let log_gmax = num_rounds + log_blowup; + + assert_eq!(UInt32::less_than_fields(log_gmax, 33), 1); + let indices = sample_query_indices(input, output, num_queries, log_gmax); + assert_eq!(verify_input_multi(input_openings, indices, s1c, s2c, qc, + prep_commit, prep_opt, prep_indices, log_degrees, num_circuits, log_blowup, log_gmax), 1); + let query_proofs = query_views(input_openings, commit_phase_openings, 0, num_queries); + let fri_rows = query_loop(input, output, query_proofs, alpha, stage1, stage2, q_opened, + prep_opt, s1c, s2c, qc, prep_commit, prep_indices, log_degrees, zeta, + num_circuits, log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds); + verify_commit_multi(commit_phase_openings, commit_phase_commits, fri_rows, indices, 0, log_gmax) + } +} diff --git a/MultiStark/MultiStark/Modules/ProofDeserialize.aiur b/MultiStark/MultiStark/Modules/ProofDeserialize.aiur new file mode 100644 index 000000000..5163a9a7f --- /dev/null +++ b/MultiStark/MultiStark/Modules/ProofDeserialize.aiur @@ -0,0 +1,439 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module ProofDeserialize { + type Ext = [Field; 2]; + + type Digest = [UInt64::U64; 4]; + + type DigestP = &Digest; + + type MerkleCap = Lists::List; + + type OpenedRound = Lists::List>>; + + enum Commitments { + Mk(MerkleCap, MerkleCap, MerkleCap) + } + + enum BatchMultiOpening { + Mk(Lists::List>>, Lists::List) + } + + enum CommitPhaseMultiStep { + Mk(UInt8::U8, Lists::List>, Lists::List) + } + + enum BatchOpening { Mk(Lists::List>) } + + enum CommitPhaseProofStep { Mk(UInt8::U8, Lists::List) } + + enum QueryProof { Mk(Lists::List, Lists::List) } + + enum FriProof { + Mk(Lists::List, Lists::List, Lists::List, + Lists::List, Lists::List, UInt64::U64) + } + + enum PreprocessedOpt { + NoPreprocessed, + SomePreprocessed(OpenedRound) + } + + enum Proof { + Mk( + Lists::List, + Commitments, + Lists::List, + Lists::List, + FriProof, + OpenedRound, + PreprocessedOpt, + OpenedRound, + OpenedRound + ) + } + + enum ShardHeader { + Mk(Lists::List, MerkleCap, Lists::List, Lists::List>) + } + + enum BatchMessage { + Mk(Lists::List, UInt64::U64) + } + + enum Batch { + Mk(Lists::List, Lists::List, Lists::List) + } + + fn read_u8(stream: Bytes::Stream) -> (UInt8::U8, Bytes::Stream) { + match (*(stream)) { + Lists::Node::Cons(byte, rest) => { (byte, rest) } , + Lists::Node::Nil => { (UInt8::BYTE_0, (&(Lists::Node::Nil))) } , + } + } + + fn read_u64(stream: Bytes::Stream) -> (UInt64::U64, Bytes::Stream) { + let (b0, s0) = read_u8(stream); + let (b1, s1) = read_u8(s0); + let (b2, s2) = read_u8(s1); + let (b3, s3) = read_u8(s2); + let (b4, s4) = read_u8(s3); + let (b5, s5) = read_u8(s4); + let (b6, s6) = read_u8(s5); + let (b7, s7) = read_u8(s6); + ([b0, b1, b2, b3, b4, b5, b6, b7], s7) + } + + fn read_count(stream: Bytes::Stream) -> (Field, Bytes::Stream) { + let (val, s) = read_u64(stream); + (UInt64::to_field(val), s) + } + + inline fn limb_to_field(b: UInt64::U64) -> Field { + UInt8::to_field(b[0]) + + 256 * UInt8::to_field(b[1]) + + 65536 * UInt8::to_field(b[2]) + + 16777216 * UInt8::to_field(b[3]) + + 4294967296 * UInt8::to_field(b[4]) + + 1099511627776 * UInt8::to_field(b[5]) + + 281474976710656 * UInt8::to_field(b[6]) + + 72057594037927936 * UInt8::to_field(b[7]) + } + + fn read_u8_at(i: Field) -> (UInt8::U8, Field) { + let [b] = hint::<[Field; 1]>("stark.io.read1", (0, i)); + (UInt8::from_field(b), i + 1) + } + + fn read_u64_at(i: Field) -> (UInt64::U64, Field) { + let [b0, b1, b2, b3, b4, b5, b6, b7] = hint::<[Field; 8]>("stark.io.read8", (0, i)); + ([UInt8::from_field(b0), UInt8::from_field(b1), + UInt8::from_field(b2), UInt8::from_field(b3), + UInt8::from_field(b4), UInt8::from_field(b5), + UInt8::from_field(b6), UInt8::from_field(b7)], i + 8) + } + + fn read_count_at(i: Field) -> (Field, Field) { + let (val, j) = read_u64_at(i); + (UInt64::to_field(val), j) + } + + inline fn read_ext_at(i: Field) -> (Ext, Field) { + let (a, j0) = read_u64_at(i); + let (b, j1) = read_u64_at(j0); + ([Goldilocks::gl_val(a), Goldilocks::gl_val(b)], j1) + } + + inline fn read_digest_at(i: Field) -> (Digest, Field) { + let (a, j0) = read_u64_at(i); + let (b, j1) = read_u64_at(j0); + let (c, j2) = read_u64_at(j1); + let (d, j3) = read_u64_at(j2); + ([a, b, c, d], j3) + } + + inline fn read_u8_vec(i: Field) -> (Lists::List, Field) { + let (n, j) = read_count_at(i); + read_u8_vec_n(j, n) + } + + fn read_u8_vec_n(i: Field, n: Field) -> (Lists::List, Field) { + match n { + 0 => { ((&(Lists::Node::Nil)), i) } , + _ => { + let (x, j) = read_u8_at(i); + let (rest, j2) = read_u8_vec_n(j, n - 1); + ((&(Lists::Node::Cons(x, rest))), j2) } , + } + } + + fn read_u64_vec(i: Field) -> (Lists::List, Field) { + let (n, j) = read_count_at(i); + read_u64_vec_n(j, n) + } + + fn read_u64_vec_n(i: Field, n: Field) -> (Lists::List, Field) { + match n { + 0 => { ((&(Lists::Node::Nil)), i) } , + _ => { + let (x, j) = read_u64_at(i); + let (rest, j2) = read_u64_vec_n(j, n - 1); + ((&(Lists::Node::Cons(x, rest))), j2) } , + } + } + + fn read_ext_vec(i: Field) -> (Lists::List, Field) { + let (n, j) = read_count_at(i); + read_ext_vec_n(j, n) + } + + fn read_ext_vec_n(i: Field, n: Field) -> (Lists::List, Field) { + match n { + 0 => { ((&(Lists::Node::Nil)), i) } , + _ => { + let (x, j) = read_ext_at(i); + let (rest, j2) = read_ext_vec_n(j, n - 1); + ((&(Lists::Node::Cons(x, rest))), j2) } , + } + } + + fn read_digest_vec_at(i: Field) -> (Lists::List, Field) { + let (n, j) = read_count_at(i); + read_digest_vec_at_n(j, n) + } + + fn read_digest_vec_at_n(i: Field, n: Field) -> (Lists::List, Field) { + match n { + 0 => { ((&(Lists::Node::Nil)), i) } , + _ => { + let (x, j) = read_digest_at(i); + let (rest, j2) = read_digest_vec_at_n(j, n - 1); + ((&(Lists::Node::Cons((&(x)), rest))), j2) } , + } + } + + inline fn read_u64_vec_vec(i: Field) -> (Lists::List>, Field) { + let (n, j) = read_count_at(i); + read_u64_vec_vec_n(j, n) + } + + fn read_u64_vec_vec_n(i: Field, n: Field) -> (Lists::List>, Field) { + match n { + 0 => { ((&(Lists::Node::Nil)), i) } , + _ => { + let (x, j) = read_u64_vec(i); + let (rest, j2) = read_u64_vec_vec_n(j, n - 1); + ((&(Lists::Node::Cons(x, rest))), j2) } , + } + } + + inline fn read_u64_vec_vec_vec(i: Field) -> (Lists::List>>, Field) { + let (n, j) = read_count_at(i); + read_u64_vec_vec_vec_n(j, n) + } + + fn read_u64_vec_vec_vec_n(i: Field, n: Field) -> (Lists::List>>, Field) { + match n { + 0 => { ((&(Lists::Node::Nil)), i) } , + _ => { + let (x, j) = read_u64_vec_vec(i); + let (rest, j2) = read_u64_vec_vec_vec_n(j, n - 1); + ((&(Lists::Node::Cons(x, rest))), j2) } , + } + } + + fn read_ext_vec_vec(i: Field) -> (Lists::List>, Field) { + let (n, j) = read_count_at(i); + read_ext_vec_vec_n(j, n) + } + + fn read_ext_vec_vec_n(i: Field, n: Field) -> (Lists::List>, Field) { + match n { + 0 => { ((&(Lists::Node::Nil)), i) } , + _ => { + let (x, j) = read_ext_vec(i); + let (rest, j2) = read_ext_vec_vec_n(j, n - 1); + ((&(Lists::Node::Cons(x, rest))), j2) } , + } + } + + fn read_opened_round(i: Field) -> (OpenedRound, Field) { + let (n, j) = read_count_at(i); + read_opened_round_n(j, n) + } + + fn read_opened_round_n(i: Field, n: Field) -> (OpenedRound, Field) { + match n { + 0 => { ((&(Lists::Node::Nil)), i) } , + _ => { + let (x, j) = read_ext_vec_vec(i); + let (rest, j2) = read_opened_round_n(j, n - 1); + ((&(Lists::Node::Cons(x, rest))), j2) } , + } + } + + inline fn read_merkle_cap_at(i: Field) -> (MerkleCap, Field) { + read_digest_vec_at(i) + } + + inline fn read_merkle_cap_vec(i: Field) -> (Lists::List, Field) { + let (n, j) = read_count_at(i); + read_merkle_cap_vec_n(j, n) + } + + fn read_merkle_cap_vec_n(i: Field, n: Field) -> (Lists::List, Field) { + match n { + 0 => { ((&(Lists::Node::Nil)), i) } , + _ => { + let (x, j) = read_merkle_cap_at(i); + let (rest, j2) = read_merkle_cap_vec_n(j, n - 1); + ((&(Lists::Node::Cons(x, rest))), j2) } , + } + } + + inline fn read_commitments(i: Field) -> (Commitments, Field) { + let (stage_1_trace, j0) = read_merkle_cap_at(i); + let (stage_2_trace, j1) = read_merkle_cap_at(j0); + let (quotient_chunks, j2) = read_merkle_cap_at(j1); + (Commitments::Mk(stage_1_trace, stage_2_trace, quotient_chunks), j2) + } + + inline fn read_batch_opening(i: Field) -> (BatchMultiOpening, Field) { + let (opened_values, j0) = read_u64_vec_vec_vec(i); + let (opening_proof, j1) = read_digest_vec_at(j0); + (BatchMultiOpening::Mk(opened_values, opening_proof), j1) + } + + inline fn read_batch_opening_vec(i: Field) -> (Lists::List, Field) { + let (n, j) = read_count_at(i); + read_batch_opening_vec_n(j, n) + } + + fn read_batch_opening_vec_n(i: Field, n: Field) -> (Lists::List, Field) { + match n { + 0 => { ((&(Lists::Node::Nil)), i) } , + _ => { + let (x, j) = read_batch_opening(i); + let (rest, j2) = read_batch_opening_vec_n(j, n - 1); + ((&(Lists::Node::Cons(x, rest))), j2) } , + } + } + + inline fn read_commit_phase_step(i: Field) -> (CommitPhaseMultiStep, Field) { + let (log_arity, j0) = read_u8_at(i); + let (sibling_values, j1) = read_ext_vec_vec(j0); + let (opening_proof, j2) = read_digest_vec_at(j1); + (CommitPhaseMultiStep::Mk(log_arity, sibling_values, opening_proof), j2) + } + + inline fn read_commit_phase_step_vec(i: Field) -> (Lists::List, Field) { + let (n, j) = read_count_at(i); + read_commit_phase_step_vec_n(j, n) + } + + fn read_commit_phase_step_vec_n(i: Field, n: Field) -> (Lists::List, Field) { + match n { + 0 => { ((&(Lists::Node::Nil)), i) } , + _ => { + let (x, j) = read_commit_phase_step(i); + let (rest, j2) = read_commit_phase_step_vec_n(j, n - 1); + ((&(Lists::Node::Cons(x, rest))), j2) } , + } + } + + inline fn read_fri_proof(i: Field) -> (FriProof, Field) { + let (commit_phase_commits, j0) = read_merkle_cap_vec(i); + let (commit_pow_witnesses, j1) = read_u64_vec(j0); + let (input_openings, j2) = read_batch_opening_vec(j1); + let (commit_phase_openings, j3) = read_commit_phase_step_vec(j2); + let (final_poly, j4) = read_ext_vec(j3); + let (query_pow_witness, j5) = read_u64_at(j4); + (FriProof::Mk(commit_phase_commits, commit_pow_witnesses, input_openings, + commit_phase_openings, final_poly, query_pow_witness), j5) + } + + inline fn read_active(i: Field) -> (Lists::List, Field) { + let (n, j) = read_count_at(i); + read_active_n(j, n) + } + + fn read_active_n(i: Field, n: Field) -> (Lists::List, Field) { + match n { + 0 => { ((&(Lists::Node::Nil)), i) } , + _ => { + let (b, j) = read_u8_at(i); + let (rest, j2) = read_active_n(j, n - 1); + ((&(Lists::Node::Cons(UInt8::to_field(b), rest))), j2) } , + } + } + + fn read_preprocessed(i: Field) -> (PreprocessedOpt, Field) { + let (tag, j) = read_u8_at(i); + match UInt8::to_field(tag) { + 0 => { (PreprocessedOpt::NoPreprocessed, j) } , + _ => { + let (r, j2) = read_opened_round(j); + (PreprocessedOpt::SomePreprocessed(r), j2) } , + } + } + + fn read_proof(i: Field) -> (Proof, Field) { + let (active, ja) = read_active(i); + let (commitments, j0) = read_commitments(ja); + let (intermediate_accumulators, j1) = read_ext_vec(j0); + let (log_degrees, j2) = read_u8_vec(j1); + let (opening_proof, j3) = read_fri_proof(j2); + let (quotient_opened_values, j4) = read_opened_round(j3); + let (preprocessed_opened_values, j5) = read_preprocessed(j4); + let (stage_1_opened_values, j6) = read_opened_round(j5); + let (stage_2_opened_values, j7) = read_opened_round(j6); + (Proof::Mk(active, commitments, intermediate_accumulators, log_degrees, + opening_proof, quotient_opened_values, preprocessed_opened_values, + stage_1_opened_values, stage_2_opened_values), j7) + } + + inline fn read_header(i: Field) -> (ShardHeader, Field) { + let (active, j0) = read_active(i); + let (stage_1, j1) = read_merkle_cap_at(j0); + let (log_degrees, j2) = read_u8_vec(j1); + let (claims, j3) = read_u64_vec_vec(j2); + (ShardHeader::Mk(active, stage_1, log_degrees, claims), j3) + } + + inline fn read_header_vec(i: Field) -> (Lists::List, Field) { + let (n, j) = read_count_at(i); + read_header_vec_n(j, n) + } + + fn read_header_vec_n(i: Field, n: Field) -> (Lists::List, Field) { + match n { + 0 => { ((&(Lists::Node::Nil)), i) } , + _ => { + let (x, j) = read_header(i); + let (rest, j2) = read_header_vec_n(j, n - 1); + ((&(Lists::Node::Cons(x, rest))), j2) } , + } + } + + inline fn read_message(i: Field) -> (BatchMessage, Field) { + let (args, j0) = read_u64_vec(i); + let (multiplicity, j1) = read_u64_at(j0); + (BatchMessage::Mk(args, multiplicity), j1) + } + + inline fn read_message_vec(i: Field) -> (Lists::List, Field) { + let (n, j) = read_count_at(i); + read_message_vec_n(j, n) + } + + fn read_message_vec_n(i: Field, n: Field) -> (Lists::List, Field) { + match n { + 0 => { ((&(Lists::Node::Nil)), i) } , + _ => { + let (x, j) = read_message(i); + let (rest, j2) = read_message_vec_n(j, n - 1); + ((&(Lists::Node::Cons(x, rest))), j2) } , + } + } + + inline fn read_proof_vec(i: Field) -> (Lists::List, Field) { + let (n, j) = read_count_at(i); + read_proof_vec_n(j, n) + } + + fn read_proof_vec_n(i: Field, n: Field) -> (Lists::List, Field) { + match n { + 0 => { ((&(Lists::Node::Nil)), i) } , + _ => { + let (x, j) = read_proof(i); + let (rest, j2) = read_proof_vec_n(j, n - 1); + ((&(Lists::Node::Cons(x, rest))), j2) } , + } + } + + inline fn read_batch(i: Field) -> (Batch, Field) { + let (headers, j0) = read_header_vec(i); + let (messages, j1) = read_message_vec(j0); + let (proofs, j2) = read_proof_vec(j1); + (Batch::Mk(headers, messages, proofs), j2) + } +} diff --git a/MultiStark/MultiStark/Modules/StarkHash.aiur b/MultiStark/MultiStark/Modules/StarkHash.aiur new file mode 100644 index 000000000..341fdbd6a --- /dev/null +++ b/MultiStark/MultiStark/Modules/StarkHash.aiur @@ -0,0 +1,80 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module StarkHash { + fn b3_w4_onto(w: UInt32::U32, tail: Bytes::Stream) -> Bytes::Stream { + let w = UInt32::to_bytes(w); + (&(Lists::Node::Cons(w[0], (&(Lists::Node::Cons(w[1], (&(Lists::Node::Cons(w[2], + (&(Lists::Node::Cons(w[3], tail)))))))))))) + } + + inline fn b3_flatten_onto(h: [UInt32::U32; 8], tail: Bytes::Stream) -> Bytes::Stream { + b3_w4_onto(h[0], b3_w4_onto(h[1], b3_w4_onto(h[2], b3_w4_onto(h[3], + b3_w4_onto(h[4], b3_w4_onto(h[5], b3_w4_onto(h[6], b3_w4_onto(h[7], tail)))))))) + } + + inline fn b3_to_digest(h: [UInt32::U32; 8]) -> ProofDeserialize::Digest { + let h = [UInt32::to_bytes(h[0]), UInt32::to_bytes(h[1]), UInt32::to_bytes(h[2]), UInt32::to_bytes(h[3]), UInt32::to_bytes(h[4]), UInt32::to_bytes(h[5]), UInt32::to_bytes(h[6]), UInt32::to_bytes(h[7])]; + [[h[0][0], h[0][1], h[0][2], h[0][3], h[1][0], h[1][1], h[1][2], h[1][3]], + [h[2][0], h[2][1], h[2][2], h[2][3], h[3][0], h[3][1], h[3][2], h[3][3]], + [h[4][0], h[4][1], h[4][2], h[4][3], h[5][0], h[5][1], h[5][2], h[5][3]], + [h[6][0], h[6][1], h[6][2], h[6][3], h[7][0], h[7][1], h[7][2], h[7][3]]] + } + + fn digest_eq(ap: ProofDeserialize::DigestP, bp: ProofDeserialize::DigestP) -> Field { + let a = (*(ap)); + let b = (*(bp)); + UInt64::eq(a[0], b[0]) * UInt64::eq(a[1], b[1]) * + UInt64::eq(a[2], b[2]) * UInt64::eq(a[3], b[3]) + } + + fn b3_rows_chunks(cur: Lists::List, rows: Lists::List>, block_no: Field, chunk_count: &UInt64::U64, cv: &[UInt32::U32; 8], layer: Blake3::Layer) -> Blake3::Layer { + let (l0, c1, r1, g0) = Pcs::rows_pop(cur, rows); + match g0 { + + 0 => { + match UInt64::is_zero((*(chunk_count))) { 1 => { + (&(Blake3::LayerNode::Push(layer, Blake3::compress_init((*(cv)), [UInt32::ZERO; 16], (*(chunk_count)), 0, 11)))) } , + _ => { layer } , + } } , + _ => { + let (l1, c2, r2, g1) = Pcs::rows_pop(c1, r1); + let (l2, c3, r3, g2) = Pcs::rows_pop(c2, r2); + let (l3, c4, r4, g3) = Pcs::rows_pop(c3, r3); + let (l4, c5, r5, g4) = Pcs::rows_pop(c4, r4); + let (l5, c6, r6, g5) = Pcs::rows_pop(c5, r5); + let (l6, c7, r7, g6) = Pcs::rows_pop(c6, r6); + let (l7, c8, r8, g7) = Pcs::rows_pop(c7, r7); + let nbytes = 8 * (g0 + g1 + g2 + g3 + g4 + g5 + g6 + g7); + let block = [ + UInt32::from_bytes([l0[0], l0[1], l0[2], l0[3]]), UInt32::from_bytes([l0[4], l0[5], l0[6], l0[7]]), + UInt32::from_bytes([l1[0], l1[1], l1[2], l1[3]]), UInt32::from_bytes([l1[4], l1[5], l1[6], l1[7]]), + UInt32::from_bytes([l2[0], l2[1], l2[2], l2[3]]), UInt32::from_bytes([l2[4], l2[5], l2[6], l2[7]]), + UInt32::from_bytes([l3[0], l3[1], l3[2], l3[3]]), UInt32::from_bytes([l3[4], l3[5], l3[6], l3[7]]), + UInt32::from_bytes([l4[0], l4[1], l4[2], l4[3]]), UInt32::from_bytes([l4[4], l4[5], l4[6], l4[7]]), + UInt32::from_bytes([l5[0], l5[1], l5[2], l5[3]]), UInt32::from_bytes([l5[4], l5[5], l5[6], l5[7]]), + UInt32::from_bytes([l6[0], l6[1], l6[2], l6[3]]), UInt32::from_bytes([l6[4], l6[5], l6[6], l6[7]]), + UInt32::from_bytes([l7[0], l7[1], l7[2], l7[3]]), UInt32::from_bytes([l7[4], l7[5], l7[6], l7[7]])]; + let empty = match (*(c8)) { + Lists::Node::Nil => { match (*(r8)) { Lists::Node::Nil => { 1 } , _ => { 0 } , } } , + _ => { 0 } , + }; + let at15 = Fields::is_zero(block_no - 15); + let start_flag = Fields::is_zero(block_no); + let end_flag = empty + at15 - (empty * at15); + let root_flag = empty * UInt64::is_zero((*(chunk_count))); + let flags = start_flag + 2 * end_flag + 8 * root_flag; + let digest = Blake3::compress_init((*(cv)), block, (*(chunk_count)), nbytes, flags); + match (empty, at15) { + (1, _) => { (&(Blake3::LayerNode::Push(layer, digest))) } , + (_, 1) => { + let IV = [UInt32::from_bytes([UInt8::BYTE_103, UInt8::BYTE_230, UInt8::BYTE_9, UInt8::BYTE_106]), UInt32::from_bytes([UInt8::BYTE_133, UInt8::BYTE_174, UInt8::BYTE_103, UInt8::BYTE_187]), UInt32::from_bytes([UInt8::BYTE_114, UInt8::BYTE_243, UInt8::BYTE_110, UInt8::BYTE_60]), UInt32::from_bytes([UInt8::BYTE_58, UInt8::BYTE_245, UInt8::BYTE_79, UInt8::BYTE_165]), UInt32::from_bytes([UInt8::BYTE_127, UInt8::BYTE_82, UInt8::BYTE_14, UInt8::BYTE_81]), UInt32::from_bytes([UInt8::BYTE_140, UInt8::BYTE_104, UInt8::BYTE_5, UInt8::BYTE_155]), UInt32::from_bytes([UInt8::BYTE_171, UInt8::BYTE_217, UInt8::BYTE_131, UInt8::BYTE_31]), UInt32::from_bytes([UInt8::BYTE_25, UInt8::BYTE_205, UInt8::BYTE_224, UInt8::BYTE_91])]; + b3_rows_chunks(c8, r8, 0, (&(UInt64::wrapping_succ((*(chunk_count))))), (&(IV)), (&(Blake3::LayerNode::Push(layer, digest)))) } , + (_, _) => { b3_rows_chunks(c8, r8, block_no + 1, chunk_count, (&(digest)), layer) } , + } } , + } + } + + inline fn b3_rows(rows: Lists::List>) -> [UInt32::U32; 8] { + let IV = [UInt32::from_bytes([UInt8::BYTE_103, UInt8::BYTE_230, UInt8::BYTE_9, UInt8::BYTE_106]), UInt32::from_bytes([UInt8::BYTE_133, UInt8::BYTE_174, UInt8::BYTE_103, UInt8::BYTE_187]), UInt32::from_bytes([UInt8::BYTE_114, UInt8::BYTE_243, UInt8::BYTE_110, UInt8::BYTE_60]), UInt32::from_bytes([UInt8::BYTE_58, UInt8::BYTE_245, UInt8::BYTE_79, UInt8::BYTE_165]), UInt32::from_bytes([UInt8::BYTE_127, UInt8::BYTE_82, UInt8::BYTE_14, UInt8::BYTE_81]), UInt32::from_bytes([UInt8::BYTE_140, UInt8::BYTE_104, UInt8::BYTE_5, UInt8::BYTE_155]), UInt32::from_bytes([UInt8::BYTE_171, UInt8::BYTE_217, UInt8::BYTE_131, UInt8::BYTE_31]), UInt32::from_bytes([UInt8::BYTE_25, UInt8::BYTE_205, UInt8::BYTE_224, UInt8::BYTE_91])]; + Blake3::compress_layer(b3_rows_chunks((&(Lists::Node::Nil)), rows, 0, (&([UInt8::BYTE_0; 8])), (&(IV)), (&(Blake3::LayerNode::Nil)))) + } +} diff --git a/MultiStark/MultiStark/Modules/StarkIO.aiur b/MultiStark/MultiStark/Modules/StarkIO.aiur new file mode 100644 index 000000000..ff4b68f5c --- /dev/null +++ b/MultiStark/MultiStark/Modules/StarkIO.aiur @@ -0,0 +1,13 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module StarkIO { + fn read_byte_stream(channel: Field, idx: Field, len: Field) -> Bytes::Stream { + + match len { + 0 => { (&(Lists::Node::Nil)) } , + _ => { + let [byte] = hint::<[Field; 1]>("stark.io.read1", (channel, idx)); + let tail = read_byte_stream(channel, idx + 1, len - 1); + (&(Lists::Node::Cons(UInt8::from_field(byte), tail))) } , + } + } +} diff --git a/MultiStark/MultiStark/Modules/StarkVerifier.aiur b/MultiStark/MultiStark/Modules/StarkVerifier.aiur new file mode 100644 index 000000000..f1872225c --- /dev/null +++ b/MultiStark/MultiStark/Modules/StarkVerifier.aiur @@ -0,0 +1,773 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module StarkVerifier { + inline fn ext_is_zero(e: ProofDeserialize::Ext) -> Field { + Fields::is_zero(e[0]) * Fields::is_zero(e[1]) + } + + fn b8_onto(b: [UInt8::U8; 8], tail: Bytes::Stream) -> Bytes::Stream { + (&(Lists::Node::Cons(b[0], (&(Lists::Node::Cons(b[1], (&(Lists::Node::Cons(b[2], + (&(Lists::Node::Cons(b[3], (&(Lists::Node::Cons(b[4], (&(Lists::Node::Cons(b[5], + (&(Lists::Node::Cons(b[6], (&(Lists::Node::Cons(b[7], tail)))))))))))))))))))))))) + } + + inline fn digest_onto(d: ProofDeserialize::Digest, tail: Bytes::Stream) -> Bytes::Stream { + b8_onto(d[0], b8_onto(d[1], b8_onto(d[2], b8_onto(d[3], tail)))) + } + + fn cap_onto(cap: ProofDeserialize::MerkleCap, tail: Bytes::Stream) -> Bytes::Stream { + match (*(cap)) { + Lists::Node::Nil => { tail } , + Lists::Node::Cons(d, rest) => { digest_onto((*(d)), cap_onto(rest, tail)) } , + } + } + + fn log_degrees_onto(lds: Lists::List, tail: Bytes::Stream) -> Bytes::Stream { + match (*(lds)) { + Lists::Node::Nil => { tail } , + Lists::Node::Cons(ld, rest) => { + b8_onto([ld, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], log_degrees_onto(rest, tail)) } , + } + } + + fn rev_onto(l: Bytes::Stream, acc: Bytes::Stream) -> Bytes::Stream { + match (*(l)) { + Lists::Node::Nil => { acc } , + Lists::Node::Cons(b, rest) => { rev_onto(rest, (&(Lists::Node::Cons(b, acc)))) } , + } + } + + fn cons8(d: [Field; 8], tail: Lists::List) -> Lists::List { + (&(Lists::Node::Cons(d[0], (&(Lists::Node::Cons(d[1], (&(Lists::Node::Cons(d[2], + (&(Lists::Node::Cons(d[3], (&(Lists::Node::Cons(d[4], (&(Lists::Node::Cons(d[5], + (&(Lists::Node::Cons(d[6], (&(Lists::Node::Cons(d[7], tail)))))))))))))))))))))))) + } + + fn take_bits(bits: Lists::List, n: Field) -> Lists::List { + match n { + 0 => { (&(Lists::Node::Nil)) } , + _ => { + let &Lists::Node::Cons(b, rest) = bits; + (&(Lists::Node::Cons(b, take_bits(rest, n - 1)))) } , + } + } + + fn snoc_b8(input: Bytes::Stream, b: [UInt8::U8; 8]) -> Bytes::Stream { + Lists::concat(input, b8_onto(b, (&(Lists::Node::Nil)))) + } + + fn snoc_cap(input: Bytes::Stream, cap: ProofDeserialize::MerkleCap) -> Bytes::Stream { + Lists::concat(input, cap_onto(cap, (&(Lists::Node::Nil)))) + } + + fn accs_onto(accs: Lists::List, tail: Bytes::Stream) -> Bytes::Stream { + match (*(accs)) { + Lists::Node::Nil => { tail } , + Lists::Node::Cons(e, rest) => { b8_onto(Goldilocks::gl_to_bytes(e[0]), b8_onto(Goldilocks::gl_to_bytes(e[1]), accs_onto(rest, tail))) } , + } + } + + inline fn seed_tag_onto(tail: Bytes::Stream) -> Bytes::Stream { + (&(Lists::Node::Cons(UInt8::BYTE_109, (&(Lists::Node::Cons(UInt8::BYTE_117, (&(Lists::Node::Cons(UInt8::BYTE_108, + (&(Lists::Node::Cons(UInt8::BYTE_116, (&(Lists::Node::Cons(UInt8::BYTE_105, (&(Lists::Node::Cons(UInt8::BYTE_45, + (&(Lists::Node::Cons(UInt8::BYTE_115, (&(Lists::Node::Cons(UInt8::BYTE_116, (&(Lists::Node::Cons(UInt8::BYTE_97, + (&(Lists::Node::Cons(UInt8::BYTE_114, (&(Lists::Node::Cons(UInt8::BYTE_107, (&(Lists::Node::Cons(UInt8::BYTE_47, + (&(Lists::Node::Cons(UInt8::BYTE_118, (&(Lists::Node::Cons(UInt8::BYTE_48, + tail)))))))))))))))))))))))))))))))))))))))))) + } + + fn limbs_onto(ls: Lists::List, tail: Bytes::Stream) -> Bytes::Stream { + match (*(ls)) { + Lists::Node::Nil => { tail } , + Lists::Node::Cons(l, rest) => { b8_onto(l, limbs_onto(rest, tail)) } , + } + } + + inline fn opt_commit_cap(commit: SystemDeserialize::OptCommit) -> ProofDeserialize::MerkleCap { + match commit { + SystemDeserialize::OptCommit::NoCommit => { (&(Lists::Node::Nil)) } , + SystemDeserialize::OptCommit::SomeCommit(c) => { c } , + } + } + + fn active_onto(active: Lists::List, tail: Bytes::Stream) -> Bytes::Stream { + match (*(active)) { + Lists::Node::Nil => { tail } , + Lists::Node::Cons(b, rest) => { + b8_onto([UInt8::from_field(b), UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], + active_onto(rest, tail)) } , + } + } + + fn ext_exp_pow2(e: ProofDeserialize::Ext, k: Field) -> ProofDeserialize::Ext { + match k { + 0 => { e } , + _ => { ext_exp_pow2(Goldilocks::eg_mul(e, e), k - 1) } , + } + } + + fn two_adic_gen(bits: Field) -> Goldilocks::Goldilocks { + match bits { + 0 => { 1 } , + 32 => { 1753635133440165772 } , + _ => { + let g = two_adic_gen(bits + 1); + g * g } , + } + } + + inline fn trace_vanishing(zeta: ProofDeserialize::Ext, l: Field) -> ProofDeserialize::Ext { + Goldilocks::eg_sub(ext_exp_pow2(zeta, l), [1, 0]) + } + + fn pow2(l: Field) -> Field { + match l { + 0 => { 1 } , + _ => { 2 * pow2(l - 1) } , + } + } + + inline fn trace_selectors(zeta: ProofDeserialize::Ext, l: Field) -> (ProofDeserialize::Ext, ProofDeserialize::Ext, ProofDeserialize::Ext, ProofDeserialize::Ext) { + let zh = trace_vanishing(zeta, l); + let ginv = Goldilocks::gl_inverse(two_adic_gen(l)); + let is_first = Goldilocks::eg_div(zh, Goldilocks::eg_sub(zeta, [1, 0])); + let is_last = Goldilocks::eg_div(zh, Goldilocks::eg_sub(zeta, [ginv, 0])); + let is_trans = Goldilocks::eg_sub(zeta, [ginv, 0]); + let inv_van = Goldilocks::eg_inverse(zh); + (is_first, is_last, is_trans, inv_van) + } + + fn ood_fold(acc: ProofDeserialize::Ext, alpha: ProofDeserialize::Ext, x: ProofDeserialize::Ext) -> ProofDeserialize::Ext { + Goldilocks::eg_add(Goldilocks::eg_mul(acc, alpha), x) + } + + fn from_ext_basis(c0: ProofDeserialize::Ext, c1: ProofDeserialize::Ext) -> ProofDeserialize::Ext { + Goldilocks::eg_add(c0, Goldilocks::eg_mul(c1, [0, 1])) + } + + fn reconstruct_ext_row(raw: Lists::List) -> Lists::List { + match (*(raw)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(c0, t1) => { + let Lists::Node::Cons(c1, t2) = (*(t1)); + (&(Lists::Node::Cons(from_ext_basis(c0, c1), reconstruct_ext_row(t2)))) } , + } + } + + fn eval_at(nodes: Lists::List, i: Field, + main: Lists::List, main_next: Lists::List, prep: Lists::List, prep_next: Lists::List, + s2: Lists::List, s2next: Lists::List, publics: Lists::List, + isf: ProofDeserialize::Ext, isl: ProofDeserialize::Ext, ist: ProofDeserialize::Ext) -> ProofDeserialize::Ext { + let nd = Lists::lookup(nodes, i); + match nd { + SystemDeserialize::SysNode::Const(c) => { [c, 0] } , + SystemDeserialize::SysNode::Var(src, off, idx) => { + + let sel = src + src + off; + match sel { + 0 => { Lists::lookup(prep, idx) } , + 1 => { Lists::lookup(prep_next, idx) } , + 2 => { Lists::lookup(main, idx) } , + 3 => { Lists::lookup(main_next, idx) } , + 4 => { Lists::lookup(s2, idx) } , + _ => { Lists::lookup(s2next, idx) } , + } } , + SystemDeserialize::SysNode::Public(idx) => { Lists::lookup(publics, idx) } , + SystemDeserialize::SysNode::IsFirstRow => { isf } , + SystemDeserialize::SysNode::IsLastRow => { isl } , + SystemDeserialize::SysNode::IsTransition => { ist } , + SystemDeserialize::SysNode::Add(a, b) => { + Goldilocks::eg_add(eval_at(nodes, a, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist), + eval_at(nodes, b, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist)) } , + SystemDeserialize::SysNode::Sub(a, b) => { + Goldilocks::eg_sub(eval_at(nodes, a, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist), + eval_at(nodes, b, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist)) } , + SystemDeserialize::SysNode::Mul(a, b) => { + Goldilocks::eg_mul(eval_at(nodes, a, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist), + eval_at(nodes, b, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist)) } , + SystemDeserialize::SysNode::Neg(a) => { + Goldilocks::eg_neg(eval_at(nodes, a, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist)) } , + } + } + + fn fold_roots(acc: ProofDeserialize::Ext, alpha: ProofDeserialize::Ext, zeros: Lists::List, nodes: Lists::List, + main: Lists::List, main_next: Lists::List, prep: Lists::List, prep_next: Lists::List, + s2: Lists::List, s2next: Lists::List, publics: Lists::List, + isf: ProofDeserialize::Ext, isl: ProofDeserialize::Ext, ist: ProofDeserialize::Ext) -> ProofDeserialize::Ext { + match (*(zeros)) { + Lists::Node::Nil => { acc } , + Lists::Node::Cons(z, rest) => { + let v = eval_at(nodes, z, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist); + fold_roots(ood_fold(acc, alpha, v), alpha, rest, nodes, + main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist) } , + } + } + + fn pair_mul(a0: ProofDeserialize::Ext, a1: ProofDeserialize::Ext, b0: ProofDeserialize::Ext, b1: ProofDeserialize::Ext) -> (ProofDeserialize::Ext, ProofDeserialize::Ext) { + (Goldilocks::eg_add(Goldilocks::eg_mul(a0, b0), Goldilocks::eg_mul([7, 0], Goldilocks::eg_mul(a1, b1))), + Goldilocks::eg_add(Goldilocks::eg_mul(a0, b1), Goldilocks::eg_mul(a1, b0))) + } + + fn logup_fingerprint(args: Lists::List, g0: ProofDeserialize::Ext, g1: ProofDeserialize::Ext, nodes: Lists::List, + main: Lists::List, main_next: Lists::List, prep: Lists::List, prep_next: Lists::List, + s2: Lists::List, s2next: Lists::List, publics: Lists::List, + isf: ProofDeserialize::Ext, isl: ProofDeserialize::Ext, ist: ProofDeserialize::Ext) -> (ProofDeserialize::Ext, ProofDeserialize::Ext) { + match (*(args)) { + Lists::Node::Nil => { ([0, 0], [0, 0]) } , + Lists::Node::Cons(a, rest) => { + let (f0, f1) = logup_fingerprint(rest, g0, g1, nodes, + main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist); + let (m0, m1) = pair_mul(f0, f1, g0, g1); + let av = eval_at(nodes, a, main, main_next, prep, prep_next, s2, s2next, + publics, isf, isl, ist); + (Goldilocks::eg_add(m0, av), m1) } , + } + } + + fn logup_steps_fold(acc: ProofDeserialize::Ext, alpha: ProofDeserialize::Ext, lks: Lists::List, j: Field, lcount: Field, + g: Field, rem: Field, k: Field, p0: ProofDeserialize::Ext, p1: ProofDeserialize::Ext, r0: ProofDeserialize::Ext, r1: ProofDeserialize::Ext, + inj0: ProofDeserialize::Ext, inj1: ProofDeserialize::Ext, b0: ProofDeserialize::Ext, b1: ProofDeserialize::Ext, g0: ProofDeserialize::Ext, g1: ProofDeserialize::Ext, + nodes: Lists::List, + main: Lists::List, main_next: Lists::List, prep: Lists::List, prep_next: Lists::List, + s2: Lists::List, s2next: Lists::List, publics: Lists::List, + isf: ProofDeserialize::Ext, isl: ProofDeserialize::Ext, ist: ProofDeserialize::Ext) -> ProofDeserialize::Ext { + match (*(lks)) { + Lists::Node::Nil => { acc } , + Lists::Node::Cons(lk, rest) => { + let SystemDeserialize::SysLookup::Mk(mid, args) = lk; + let (f0, f1) = logup_fingerprint(args, g0, g1, nodes, + main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist); + let m0 = Goldilocks::eg_add(f0, b0); + let m1 = Goldilocks::eg_add(f1, b1); + let mv = eval_at(nodes, mid, main, main_next, prep, prep_next, s2, s2next, + publics, isf, isl, ist); + + let (rm0, rm1) = pair_mul(r0, r1, m0, m1); + let nr0 = Goldilocks::eg_add(rm0, Goldilocks::eg_mul(mv, p0)); + let nr1 = Goldilocks::eg_add(rm1, Goldilocks::eg_mul(mv, p1)); + let (np0, np1) = pair_mul(p0, p1, m0, m1); + match (j + 1 - lcount) { + 0 => { + + let s0 = Lists::lookup(s2, g + g); + let s1 = Lists::lookup(s2, g + g + 1); + let t0 = Goldilocks::eg_add(Lists::lookup(s2next, 0), inj0); + let t1 = Goldilocks::eg_add(Lists::lookup(s2next, 1), inj1); + let (c0, c1) = pair_mul(np0, np1, Goldilocks::eg_sub(t0, s0), Goldilocks::eg_sub(t1, s1)); + ood_fold(ood_fold(acc, alpha, Goldilocks::eg_sub(c0, nr0)), alpha, Goldilocks::eg_sub(c1, nr1)) } , + _ => { match rem - 1 { + 0 => { + + let s0 = Lists::lookup(s2, g + g); + let s1 = Lists::lookup(s2, g + g + 1); + let t0 = Lists::lookup(s2, g + g + 2); + let t1 = Lists::lookup(s2, g + g + 3); + let (c0, c1) = pair_mul(np0, np1, Goldilocks::eg_sub(t0, s0), Goldilocks::eg_sub(t1, s1)); + let acc1 = ood_fold(ood_fold(acc, alpha, Goldilocks::eg_sub(c0, nr0)), alpha, + Goldilocks::eg_sub(c1, nr1)); + logup_steps_fold(acc1, alpha, rest, j + 1, lcount, + g + 1, k, k, [1, 0], [0, 0], [0, 0], [0, 0], + inj0, inj1, b0, b1, g0, g1, nodes, + main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist) } , + _ => { + + logup_steps_fold(acc, alpha, rest, j + 1, lcount, + g, rem - 1, k, np0, np1, nr0, nr1, + inj0, inj1, b0, b1, g0, g1, nodes, + main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist) } , + } } , + } } , + } + } + + inline fn ood_composition(nodes: Lists::List, zeros: Lists::List, lks: Lists::List, + k: Field, + main: Lists::List, main_next: Lists::List, prep: Lists::List, prep_next: Lists::List, + s2: Lists::List, s2next: Lists::List, publics: Lists::List, + lch: ProofDeserialize::Ext, fch: ProofDeserialize::Ext, accp: ProofDeserialize::Ext, naccp: ProofDeserialize::Ext, + isf: ProofDeserialize::Ext, isl: ProofDeserialize::Ext, ist: ProofDeserialize::Ext, alpha: ProofDeserialize::Ext, inorm: Field) -> ProofDeserialize::Ext { + let base = fold_roots([0, 0], alpha, zeros, nodes, + main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist); + + let b0 = [lch[0], 0]; let b1 = [lch[1], 0]; + let g0 = [fch[0], 0]; let g1 = [fch[1], 0]; + let a0 = [accp[0], 0]; let a1 = [accp[1], 0]; + let na0 = [naccp[0], 0]; let na1 = [naccp[1], 0]; + + let inj0 = Goldilocks::eg_mul(isl, Goldilocks::eg_mul(Goldilocks::eg_sub(na0, a0), [inorm, 0])); + let inj1 = Goldilocks::eg_mul(isl, Goldilocks::eg_mul(Goldilocks::eg_sub(na1, a1), [inorm, 0])); + match (*(lks)) { + + Lists::Node::Nil => { + let acc = ood_fold(base, alpha, + Goldilocks::eg_add(Goldilocks::eg_sub(Lists::lookup(s2next, 0), Lists::lookup(s2, 0)), inj0)); + ood_fold(acc, alpha, + Goldilocks::eg_add(Goldilocks::eg_sub(Lists::lookup(s2next, 1), Lists::lookup(s2, 1)), inj1)) } , + Lists::Node::Cons(_h, _t) => { + logup_steps_fold(base, alpha, lks, 0, Lists::length(lks), + 0, k, k, [1, 0], [0, 0], [0, 0], [0, 0], inj0, inj1, + b0, b1, g0, g1, nodes, + main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist) } , + } + } + + inline fn build_publics(lch: ProofDeserialize::Ext, fch: ProofDeserialize::Ext, accp: ProofDeserialize::Ext, naccp: ProofDeserialize::Ext) -> Lists::List { + (&(Lists::Node::Cons([lch[0], 0], (&(Lists::Node::Cons([lch[1], 0], + (&(Lists::Node::Cons([fch[0], 0], (&(Lists::Node::Cons([fch[1], 0], + (&(Lists::Node::Cons([accp[0], 0], (&(Lists::Node::Cons([accp[1], 0], + (&(Lists::Node::Cons([naccp[0], 0], (&(Lists::Node::Cons([naccp[1], 0], + (&(Lists::Node::Nil)))))))))))))))))))))))))) + } + + fn quotient_eval(slices: Lists::List, zeta_pow_n: ProofDeserialize::Ext, pow: ProofDeserialize::Ext) -> ProofDeserialize::Ext { + match (*(slices)) { + Lists::Node::Nil => { [0, 0] } , + Lists::Node::Cons(c, rest) => { + Goldilocks::eg_add(Goldilocks::eg_mul(pow, c), quotient_eval(rest, zeta_pow_n, Goldilocks::eg_mul(pow, zeta_pow_n))) } , + } + } + + fn quotient_degree_of(md: Field) -> Field { + match md { + 0 => { 1 } , 1 => { 1 } , 2 => { 1 } , + 3 => { 2 } , + 4 => { 4 } , 5 => { 4 } , + 6 => { 8 } , 7 => { 8 } , 8 => { 8 } , 9 => { 8 } , + 10 => { 16 } , 11 => { 16 } , 12 => { 16 } , 13 => { 16 } , 14 => { 16 } , 15 => { 16 } , 16 => { 16 } , 17 => { 16 } , + _ => { 32 } , + } + } + + inline fn ood_prep_rows(prep_opt: ProofDeserialize::PreprocessedOpt, oi: SystemDeserialize::OptIdx) -> (Lists::List, Lists::List) { + match oi { + SystemDeserialize::OptIdx::NoIdx => { ((&(Lists::Node::Nil)), (&(Lists::Node::Nil))) } , + SystemDeserialize::OptIdx::SomeIdx(j) => { + match prep_opt { + ProofDeserialize::PreprocessedOpt::NoPreprocessed => { ((&(Lists::Node::Nil)), (&(Lists::Node::Nil))) } , + ProofDeserialize::PreprocessedOpt::SomePreprocessed(round) => { + let pr = Lists::lookup(round, j); + (Lists::lookup(pr, 0), Lists::lookup(pr, 1)) } , + } } , + } + } + + fn ood_loop(circuits: Lists::List, prep_indices: Lists::List, + log_degrees: Lists::List, accs: Lists::List, + stage1: ProofDeserialize::OpenedRound, stage2: ProofDeserialize::OpenedRound, prep_opt: ProofDeserialize::PreprocessedOpt, + q_opened: ProofDeserialize::OpenedRound, i: Field, accp: ProofDeserialize::Ext, + lch: ProofDeserialize::Ext, fch: ProofDeserialize::Ext, alpha: ProofDeserialize::Ext, zeta: ProofDeserialize::Ext) -> Field { + match (*(circuits)) { + Lists::Node::Nil => { 1 } , + Lists::Node::Cons(circ, rest) => { + let SystemDeserialize::SysCircuit::Mk(nodes, _node_count, zeros, md, lks, k, mw, pw, s2w) = circ; + + let ld8 = Lists::lookup(log_degrees, i); + assert_eq!(UInt8::less_than(ld8, UInt8::BYTE_32), 1); + let l = UInt8::to_field(ld8); + let qd = quotient_degree_of(md); + let naccp = Lists::lookup(accs, i); + let s1 = Lists::lookup(stage1, i); + let main = Lists::lookup(s1, 0); + let main_next = Lists::lookup(s1, 1); + let s2 = Lists::lookup(stage2, i); + + let s2row = Lists::lookup(s2, 0); + let s2next = Lists::lookup(s2, 1); + let (prep, prep_next) = ood_prep_rows(prep_opt, Lists::lookup(prep_indices, i)); + + assert_eq!(Fields::is_zero(Lists::length(main) - mw), 1); + assert_eq!(Fields::is_zero(Lists::length(main_next) - mw), 1); + assert_eq!(Fields::is_zero(Lists::length(s2row) - s2w), 1); + assert_eq!(Fields::is_zero(Lists::length(s2next) - s2w), 1); + assert_eq!(Fields::is_zero(Lists::length(prep) - pw), 1); + assert_eq!(Fields::is_zero(Lists::length(prep_next) - pw), 1); + let (isf, isl, ist, invv) = trace_selectors(zeta, l); + let publics = build_publics(lch, fch, accp, naccp); + let inorm = Goldilocks::gl_inverse(pow2(l) * two_adic_gen(l)); + let comp = ood_composition(nodes, zeros, lks, k, + main, main_next, prep, prep_next, s2row, s2next, + publics, lch, fch, accp, naccp, + isf, isl, ist, alpha, inorm); + + let slices = reconstruct_ext_row(Lists::lookup(Lists::lookup(q_opened, i), 0)); + assert_eq!(Fields::is_zero(Lists::length(slices) - qd), 1); + let quot = quotient_eval(slices, ext_exp_pow2(zeta, l), [1, 0]); + assert_eq!(Goldilocks::eg_eq(Goldilocks::eg_mul(comp, invv), quot), 1); + ood_loop(rest, prep_indices, log_degrees, accs, stage1, stage2, prep_opt, + q_opened, i + 1, naccp, lch, fch, alpha, zeta) } , + } + } + + fn fingerprint_vals(fch: ProofDeserialize::Ext, vals: Lists::List) -> ProofDeserialize::Ext { + match (*(vals)) { + Lists::Node::Nil => { [0, 0] } , + Lists::Node::Cons(v, rest) => { + Goldilocks::eg_add([Goldilocks::gl_val(v), 0], Goldilocks::eg_mul(fch, fingerprint_vals(fch, rest))) } , + } + } + + fn claims_acc(acc: ProofDeserialize::Ext, claims: Lists::List>, lch: ProofDeserialize::Ext, fch: ProofDeserialize::Ext) -> ProofDeserialize::Ext { + match (*(claims)) { + Lists::Node::Nil => { acc } , + Lists::Node::Cons(c, rest) => { + let msg = Goldilocks::eg_add(lch, fingerprint_vals(fch, c)); + claims_acc(Goldilocks::eg_add(acc, Goldilocks::eg_inverse(msg)), rest, lch, fch) } , + } + } + + fn assert_bits(l: Lists::List) -> Field { + match (*(l)) { + Lists::Node::Nil => { 1 } , + Lists::Node::Cons(b, rest) => { + assert_eq!(b * (b - 1), 0); + assert_bits(rest) } , + } + } + + fn select_active_circuits(circuits: Lists::List, active: Lists::List) -> Lists::List { + match (*(circuits)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(c, crest) => { + let &Lists::Node::Cons(b, arest) = active; + match b { + 0 => { select_active_circuits(crest, arest) } , + _ => { (&(Lists::Node::Cons(c, select_active_circuits(crest, arest)))) } , + } } , + } + } + + fn select_active_prep(prep_indices: Lists::List, active: Lists::List) -> Lists::List { + match (*(prep_indices)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(p, prest) => { + let &Lists::Node::Cons(b, arest) = active; + match b { + 0 => { select_active_prep(prest, arest) } , + _ => { (&(Lists::Node::Cons(p, select_active_prep(prest, arest)))) } , + } } , + } + } + + fn count_onto(n: Field, tail: Bytes::Stream) -> Bytes::Stream { + b8_onto(Goldilocks::gl_to_bytes(n), tail) + } + + fn claims_onto(claims: Lists::List>, tail: Bytes::Stream) -> Bytes::Stream { + count_onto(Lists::length(claims), claims_onto_each(claims, tail)) + } + + fn claims_onto_each(claims: Lists::List>, tail: Bytes::Stream) -> Bytes::Stream { + match (*(claims)) { + Lists::Node::Nil => { tail } , + Lists::Node::Cons(c, rest) => { + count_onto(Lists::length(c), limbs_onto(c, claims_onto_each(rest, tail))) } , + } + } + + fn header_onto(h: ProofDeserialize::ShardHeader, tail: Bytes::Stream) -> Bytes::Stream { + let ProofDeserialize::ShardHeader::Mk(active, cap, lds, claims) = h; + active_onto(active, + cap_onto(cap, + count_onto(Lists::length(lds), + log_degrees_onto(lds, claims_onto(claims, tail))))) + } + + fn headers_onto(hs: Lists::List, tail: Bytes::Stream) -> Bytes::Stream { + match (*(hs)) { + Lists::Node::Nil => { tail } , + Lists::Node::Cons(h, rest) => { header_onto(h, headers_onto(rest, tail)) } , + } + } + + fn messages_onto(ms: Lists::List, tail: Bytes::Stream) -> Bytes::Stream { + count_onto(Lists::length(ms), messages_onto_each(ms, tail)) + } + + fn messages_onto_each(ms: Lists::List, tail: Bytes::Stream) -> Bytes::Stream { + match (*(ms)) { + Lists::Node::Nil => { tail } , + Lists::Node::Cons(m, rest) => { + let ProofDeserialize::BatchMessage::Mk(args, mult) = m; + count_onto(Lists::length(args), + limbs_onto(args, b8_onto(mult, messages_onto_each(rest, tail)))) } , + } + } + + fn assert_same_bits(a: Lists::List, b: Lists::List) -> Field { + match (*(a)) { + Lists::Node::Nil => { + let Lists::Node::Nil = (*(b)); + 1 } , + Lists::Node::Cons(x, ra) => { + let Lists::Node::Cons(y, rb) = (*(b)); + assert_eq!(x, y); + assert_same_bits(ra, rb) } , + } + } + + fn assert_same_u8s(a: Lists::List, b: Lists::List) -> Field { + match (*(a)) { + Lists::Node::Nil => { + let Lists::Node::Nil = (*(b)); + 1 } , + Lists::Node::Cons(x, ra) => { + let Lists::Node::Cons(y, rb) = (*(b)); + assert_eq!(UInt8::to_field(x), UInt8::to_field(y)); + assert_same_u8s(ra, rb) } , + } + } + + fn assert_same_limbs(a: Lists::List, b: Lists::List) -> Field { + match (*(a)) { + Lists::Node::Nil => { + let Lists::Node::Nil = (*(b)); + 1 } , + Lists::Node::Cons(x, ra) => { + let Lists::Node::Cons(y, rb) = (*(b)); + assert_eq!(UInt64::eq(x, y), 1); + assert_same_limbs(ra, rb) } , + } + } + + fn assert_same_claims(a: Lists::List>, b: Lists::List>) -> Field { + match (*(a)) { + Lists::Node::Nil => { + let Lists::Node::Nil = (*(b)); + 1 } , + Lists::Node::Cons(x, ra) => { + let Lists::Node::Cons(y, rb) = (*(b)); + assert_eq!(assert_same_limbs(x, y), 1); + assert_same_claims(ra, rb) } , + } + } + + fn assert_same_cap(a: ProofDeserialize::MerkleCap, b: ProofDeserialize::MerkleCap) -> Field { + match (*(a)) { + Lists::Node::Nil => { + let Lists::Node::Nil = (*(b)); + 1 } , + Lists::Node::Cons(d, ra) => { + let Lists::Node::Cons(e, rb) = (*(b)); + let x = (*(d)); + let y = (*(e)); + assert_eq!(UInt64::eq(x[0], y[0]), 1); + assert_eq!(UInt64::eq(x[1], y[1]), 1); + assert_eq!(UInt64::eq(x[2], y[2]), 1); + assert_eq!(UInt64::eq(x[3], y[3]), 1); + assert_same_cap(ra, rb) } , + } + } + + fn last_acc(accs: Lists::List) -> ProofDeserialize::Ext { + let Lists::Node::Cons(e, rest) = (*(accs)); + match (*(rest)) { + Lists::Node::Nil => { e } , + _ => { last_acc(rest) } , + } + } + + fn messages_acc(acc: ProofDeserialize::Ext, ms: Lists::List, lch: ProofDeserialize::Ext, fch: ProofDeserialize::Ext) -> ProofDeserialize::Ext { + match (*(ms)) { + Lists::Node::Nil => { acc } , + Lists::Node::Cons(m, rest) => { + let ProofDeserialize::BatchMessage::Mk(args, mult) = m; + let msg = Goldilocks::eg_add(lch, fingerprint_vals(fch, args)); + let term = Goldilocks::eg_mul(Goldilocks::eg_inverse(msg), [Goldilocks::gl_val(mult), 0]); + messages_acc(Goldilocks::eg_add(acc, term), rest, lch, fch) } , + } + } + + fn log_degree_ok(ld: UInt8::U8) -> Field { + match UInt8::to_field(ld) { + 0 => { 1 } , 1 => { 1 } , 2 => { 1 } , 3 => { 1 } , 4 => { 1 } , 5 => { 1 } , 6 => { 1 } , 7 => { 1 } , 8 => { 1 } , + 9 => { 1 } , 10 => { 1 } , 11 => { 1 } , 12 => { 1 } , 13 => { 1 } , 14 => { 1 } , 15 => { 1 } , 16 => { 1 } , + 17 => { 1 } , 18 => { 1 } , 19 => { 1 } , 20 => { 1 } , 21 => { 1 } , 22 => { 1 } , 23 => { 1 } , 24 => { 1 } , + 25 => { 1 } , 26 => { 1 } , 27 => { 1 } , 28 => { 1 } , 29 => { 1 } , 30 => { 1 } , 31 => { 1 } , 32 => { 1 } , + _ => { 0 } , + } + } + + fn assert_log_degrees_ok(lds: Lists::List) -> Field { + match (*(lds)) { + Lists::Node::Nil => { 1 } , + Lists::Node::Cons(ld, rest) => { + assert_eq!(log_degree_ok(ld), 1); + assert_log_degrees_ok(rest) } , + } + } + + fn count_ones(bits: Lists::List) -> Field { + match (*(bits)) { + Lists::Node::Nil => { 0 } , + Lists::Node::Cons(b, rest) => { b + count_ones(rest) } , + } + } + + fn assert_shard_count_ok(k: Field) -> Field { + assert_eq!(Fields::is_zero(k), 0); + let b = Goldilocks::gl_to_bytes(k); + assert_eq!(UInt8::to_field(b[3]) + UInt8::to_field(b[4]) + UInt8::to_field(b[5]) + UInt8::to_field(b[6]) + UInt8::to_field(b[7]), 0); + let hi = UInt8::to_field(b[2]); + assert_eq!(hi * (hi - 1), 0); + assert_eq!(hi * (UInt8::to_field(b[0]) + UInt8::to_field(b[1])), 0); + 1 + } + + fn three_limbs(args: Lists::List) -> (UInt64::U64, UInt64::U64, UInt64::U64) { + let Lists::Node::Cons(a, r1) = (*(args)); + let Lists::Node::Cons(b, r2) = (*(r1)); + let Lists::Node::Cons(c, r3) = (*(r2)); + let Lists::Node::Nil = (*(r3)); + (a, b, c) + } + + fn le_step(xi: UInt8::U8, yi: UInt8::U8, rest: Field) -> Field { + UInt8::less_than(xi, yi) + Fields::is_zero(UInt8::to_field(xi) - UInt8::to_field(yi)) * rest + } + + fn bytes8_le(x: [UInt8::U8; 8], y: [UInt8::U8; 8]) -> Field { + le_step(x[7], y[7], le_step(x[6], y[6], le_step(x[5], y[5], + le_step(x[4], y[4], le_step(x[3], y[3], le_step(x[2], y[2], + le_step(x[1], y[1], le_step(x[0], y[0], 1)))))))) + } + + fn assert_closure_pairs(ms: Lists::List, prev_w: Field, prev_b: Field) -> Field { + match (*(ms)) { + Lists::Node::Nil => { 1 } , + Lists::Node::Cons(pull, rest1) => { + let Lists::Node::Cons(push, rest) = (*(rest1)); + let ProofDeserialize::BatchMessage::Mk(pargs, pmult) = pull; + let ProofDeserialize::BatchMessage::Mk(qargs, qmult) = push; + assert_eq!(Goldilocks::gl_val(pmult) + 1, 0); + assert_eq!(Goldilocks::gl_val(qmult), 1); + let (pc, pw, pa) = three_limbs(pargs); + let (qc, qw, qb) = three_limbs(qargs); + assert_eq!(Goldilocks::gl_val(pc), 16); + assert_eq!(Goldilocks::gl_val(qc), 16); + let w = Goldilocks::gl_val(pw); + assert_eq!(Goldilocks::gl_val(qw), w); + let a = Goldilocks::gl_val(pa); + let b = Goldilocks::gl_val(qb); + assert_eq!(bytes8_le(Goldilocks::gl_to_bytes(a), Goldilocks::gl_to_bytes(b)), 1); + + let same_w = Fields::is_zero(w - prev_w); + let w_up = 1 - bytes8_le(Goldilocks::gl_to_bytes(w), Goldilocks::gl_to_bytes(prev_w)); + assert_eq!( + w_up + same_w * bytes8_le(Goldilocks::gl_to_bytes(prev_b), Goldilocks::gl_to_bytes(a)), 1); + assert_closure_pairs(rest, w, b) } , + } + } + + fn verify_shard(sys: SystemDeserialize::Sys, header: ProofDeserialize::ShardHeader, shard: Field, proof: ProofDeserialize::Proof, + input: Bytes::Stream, lch: ProofDeserialize::Ext, fch: ProofDeserialize::Ext) -> ProofDeserialize::Ext { + let SystemDeserialize::Sys::Mk(params, _tlimbs, circuits, commit, prep_indices) = sys; + let SystemDeserialize::SysParams::Mk(log_blowup, cap_height, log_final_poly_len, + max_log_arity, num_queries, commit_pow_bits, + query_pow_bits) = params; + assert_eq!(cap_height, 0); + assert_eq!(log_final_poly_len, 0); + assert_eq!(max_log_arity, 1); + let ProofDeserialize::ShardHeader::Mk(h_active, h_cap, h_lds, h_claims) = header; + let ProofDeserialize::Proof::Mk(active, commitments, accs, log_degrees, opening, + q_opened, prep_opt, stage1, stage2) = proof; + let num_circuits = Lists::length(accs); + assert_eq!(Fields::is_zero(num_circuits), 0); + assert_eq!(Lists::length(stage1), num_circuits); + assert_eq!(Lists::length(stage2), num_circuits); + assert_eq!(Lists::length(q_opened), num_circuits); + assert_eq!(assert_bits(active), 1); + assert_eq!(Fields::is_zero(Lists::length(active) - Lists::length(circuits)), 1); + let acirc = select_active_circuits(circuits, active); + let aprep = select_active_prep(prep_indices, active); + assert_eq!(Fields::is_zero(Lists::length(acirc) - Lists::length(accs)), 1); + let ProofDeserialize::Commitments::Mk(s1c, s2c, qc) = commitments; + assert_eq!(assert_same_bits(h_active, active), 1); + assert_eq!(assert_same_cap(h_cap, s1c), 1); + assert_eq!(assert_same_u8s(h_lds, log_degrees), 1); + assert_eq!(assert_log_degrees_ok(log_degrees), 1); + assert_eq!(count_ones(active), Lists::length(log_degrees)); + let prep_cap = opt_commit_cap(commit); + let (alpha, zeta, post_zeta_input) = Transcript::shard_fiat_shamir(input, shard, s2c, qc, accs); + let acc0 = claims_acc([0, 0], h_claims, lch, fch); + let _ood = ood_loop(acirc, aprep, log_degrees, accs, stage1, stage2, + prep_opt, q_opened, 0, acc0, lch, fch, alpha, zeta); + assert_eq!(Pcs::pcs_fri_verify(post_zeta_input, stage1, stage2, q_opened, prep_opt, opening, + s1c, s2c, qc, prep_cap, aprep, log_degrees, zeta, + Lists::length(acirc), log_blowup, num_queries, commit_pow_bits, + query_pow_bits), 1); + last_acc(accs) + } + + fn verify_shards(sys: SystemDeserialize::Sys, headers: Lists::List, proofs: Lists::List, shard: Field, + input: Bytes::Stream, lch: ProofDeserialize::Ext, fch: ProofDeserialize::Ext, acc: ProofDeserialize::Ext) -> ProofDeserialize::Ext { + match (*(headers)) { + Lists::Node::Nil => { + let Lists::Node::Nil = (*(proofs)); + acc } , + Lists::Node::Cons(h, hrest) => { + let Lists::Node::Cons(p, prest) = (*(proofs)); + let r = verify_shard(sys, h, shard, p, input, lch, fch); + verify_shards(sys, hrest, prest, shard + 1, input, lch, fch, Goldilocks::eg_add(acc, r)) } , + } + } + + fn batch_claims(headers: Lists::List) -> Lists::List> { + match (*(headers)) { + Lists::Node::Nil => { (&(Lists::Node::Nil)) } , + Lists::Node::Cons(h, rest) => { + let ProofDeserialize::ShardHeader::Mk(_active, _cap, _lds, claims) = h; + Lists::concat(claims, batch_claims(rest)) } , + } + } + + fn verify_batch(sys: SystemDeserialize::Sys, batch: ProofDeserialize::Batch) -> Lists::List> { + let ProofDeserialize::Batch::Mk(headers, messages, proofs) = batch; + assert_eq!(assert_shard_count_ok(Lists::length(headers)), 1); + assert_eq!(Lists::length(proofs), Lists::length(headers)); + assert_eq!(assert_closure_pairs(messages, 0, 0), 1); + let SystemDeserialize::Sys::Mk(_params, tlimbs, _circuits, commit, _prep_indices) = sys; + let prep_cap = opt_commit_cap(commit); + let (lch, fch, input) = Transcript::batch_fiat_shamir(tlimbs, prep_cap, headers, messages); + let acc = messages_acc([0, 0], messages, lch, fch); + let total = verify_shards(sys, headers, proofs, 0, input, lch, fch, acc); + assert_eq!(ext_is_zero(total), 1); + batch_claims(headers) + } + + inline fn verify_batch_at(sys: SystemDeserialize::Sys, idx: Field, len: Field, claims: Lists::List>) -> Field { + let (batch, stop) = ProofDeserialize::read_batch(idx); + assert_eq!(stop, idx + len); + let found = verify_batch(sys, batch); + assert_eq!(assert_same_claims(found, claims), 1); + 1 + } + + inline fn read_claims(stream: Bytes::Stream) -> (Lists::List>, Bytes::Stream) { + let (n, s) = ProofDeserialize::read_count(stream); + read_claims_n(s, n) + } + + fn read_claims_n(stream: Bytes::Stream, n: Field) -> (Lists::List>, Bytes::Stream) { + match n { + 0 => { ((&(Lists::Node::Nil)), stream) } , + _ => { + let (c, s) = read_one_claim(stream); + let (rest, s2) = read_claims_n(s, n - 1); + ((&(Lists::Node::Cons(c, rest))), s2) } , + } + } + + inline fn read_one_claim(stream: Bytes::Stream) -> (Lists::List, Bytes::Stream) { + let (m, s) = ProofDeserialize::read_count(stream); + read_claim_vals_n(s, m) + } + + fn read_claim_vals_n(stream: Bytes::Stream, n: Field) -> (Lists::List, Bytes::Stream) { + match n { + 0 => { ((&(Lists::Node::Nil)), stream) } , + _ => { + let (x, s) = ProofDeserialize::read_u64(stream); + let (rest, s2) = read_claim_vals_n(s, n - 1); + ((&(Lists::Node::Cons(x, rest))), s2) } , + } + } +} diff --git a/MultiStark/MultiStark/Modules/SystemDeserialize.aiur b/MultiStark/MultiStark/Modules/SystemDeserialize.aiur new file mode 100644 index 000000000..824864a1c --- /dev/null +++ b/MultiStark/MultiStark/Modules/SystemDeserialize.aiur @@ -0,0 +1,308 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module SystemDeserialize { + enum SysNode { + Const(Field), + Var(Field, Field, Field), + Public(Field), + IsFirstRow, + IsLastRow, + IsTransition, + Add(Field, Field), + Sub(Field, Field), + Mul(Field, Field), + Neg(Field) + } + + enum SysLookup { Mk(Field, Lists::List) } + + enum SysCircuit { Mk(Lists::List, Field, Lists::List, Field, Lists::List, Field, Field, Field, Field) } + + enum SysParams { Mk(Field, Field, Field, Field, Field, Field, Field) } + + enum OptCommit { NoCommit, SomeCommit(ProofDeserialize::MerkleCap) } + + enum OptIdx { NoIdx, SomeIdx(Field) } + + enum Sys { Mk(SysParams, Lists::List, Lists::List, OptCommit, Lists::List) } + + fn read_vk_u8(s: Bytes::Stream) -> (UInt8::U8, Bytes::Stream) { + match (*(s)) { + Lists::Node::Cons(byte, rest) => { (byte, rest) } , + } + } + + fn read_vk_tag(s: Bytes::Stream) -> (Field, Bytes::Stream) { + let (b, rest) = read_vk_u8(s); + (UInt8::to_field(b), rest) + } + + fn read_vk_u16(s: Bytes::Stream) -> (Field, Bytes::Stream) { + let (b0, s0) = read_vk_u8(s); + let (b1, s1) = read_vk_u8(s0); + (UInt8::to_field(b0) + 256 * UInt8::to_field(b1), s1) + } + + fn read_vk_u16_limb(s: Bytes::Stream) -> (Field, UInt64::U64, Bytes::Stream) { + let (b0, s0) = read_vk_u8(s); + let (b1, s1) = read_vk_u8(s0); + (UInt8::to_field(b0) + 256 * UInt8::to_field(b1), + [b0, b1, + UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], + s1) + } + + fn read_vk_u32_limb(s: Bytes::Stream) -> (Field, UInt64::U64, Bytes::Stream) { + let (b0, s0) = read_vk_u8(s); let (b1, s1) = read_vk_u8(s0); + let (b2, s2) = read_vk_u8(s1); let (b3, s3) = read_vk_u8(s2); + (UInt8::to_field(b0) + 256 * UInt8::to_field(b1) + 65536 * UInt8::to_field(b2) + 16777216 * UInt8::to_field(b3), + [b0, b1, b2, b3, + UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0, UInt8::BYTE_0], + s3) + } + + fn read_vk_u64(s: Bytes::Stream) -> (UInt64::U64, Bytes::Stream) { + let (b0, s0) = read_vk_u8(s); let (b1, s1) = read_vk_u8(s0); + let (b2, s2) = read_vk_u8(s1); let (b3, s3) = read_vk_u8(s2); + let (b4, s4) = read_vk_u8(s3); let (b5, s5) = read_vk_u8(s4); + let (b6, s6) = read_vk_u8(s5); let (b7, s7) = read_vk_u8(s6); + ([b0, b1, b2, b3, b4, b5, b6, b7], s7) + } + + fn read_field(i: Bytes::Stream) -> (Field, Bytes::Stream) { + let (u, j) = read_vk_u64(i); + (Goldilocks::gl_val(u), j) + } + + inline fn read_vk_digest(i: Bytes::Stream) -> (ProofDeserialize::Digest, Bytes::Stream) { + let (a, j0) = read_vk_u64(i); + let (b, j1) = read_vk_u64(j0); + let (c, j2) = read_vk_u64(j1); + let (d, j3) = read_vk_u64(j2); + ([a, b, c, d], j3) + } + + fn read_vk_cap_n(i: Bytes::Stream, n: Field) -> (ProofDeserialize::MerkleCap, Bytes::Stream) { + match n { + 0 => { ((&(Lists::Node::Nil)), i) } , + _ => { + let (x, j) = read_vk_digest(i); + let (rest, j2) = read_vk_cap_n(j, n - 1); + ((&(Lists::Node::Cons((&(x)), rest))), j2) } , + } + } + + fn read_nodes_n(i: Bytes::Stream, n: Field, node_idx: Field) -> (Lists::List, Bytes::Stream) { + match n { + 0 => { ((&(Lists::Node::Nil)), i) } , + _ => { + let (tag, i1) = read_vk_tag(i); + match tag { + 0 => { + let (c, i2) = read_vk_u16(i1); + let (rest, i3) = read_nodes_n(i2, n - 1, node_idx + 1); + ((&(Lists::Node::Cons(SysNode::Const(c), rest))), i3) } , + 1 => { + let (c, i2) = read_field(i1); + let (rest, i3) = read_nodes_n(i2, n - 1, node_idx + 1); + ((&(Lists::Node::Cons(SysNode::Const(c), rest))), i3) } , + 2 => { + let (idx, i2) = read_vk_tag(i1); + let (rest, i3) = read_nodes_n(i2, n - 1, node_idx + 1); + ((&(Lists::Node::Cons(SysNode::Public(idx), rest))), i3) } , + 3 => { + let (rest, i3) = read_nodes_n(i1, n - 1, node_idx + 1); + ((&(Lists::Node::Cons(SysNode::IsFirstRow, rest))), i3) } , + 4 => { + let (rest, i3) = read_nodes_n(i1, n - 1, node_idx + 1); + ((&(Lists::Node::Cons(SysNode::IsLastRow, rest))), i3) } , + 5 => { + let (rest, i3) = read_nodes_n(i1, n - 1, node_idx + 1); + ((&(Lists::Node::Cons(SysNode::IsTransition, rest))), i3) } , + 6 => { + let (a, i2) = read_vk_u16(i1); + let (b, i3) = read_vk_u16(i2); + assert_eq!(UInt32::less_than_fields(a, node_idx), 1, + "vk: expression child must precede its parent"); + assert_eq!(UInt32::less_than_fields(b, node_idx), 1, + "vk: expression child must precede its parent"); + let (rest, i4) = read_nodes_n(i3, n - 1, node_idx + 1); + ((&(Lists::Node::Cons(SysNode::Add(a, b), rest))), i4) } , + 7 => { + let (a, i2) = read_vk_u16(i1); + let (b, i3) = read_vk_u16(i2); + assert_eq!(UInt32::less_than_fields(a, node_idx), 1, + "vk: expression child must precede its parent"); + assert_eq!(UInt32::less_than_fields(b, node_idx), 1, + "vk: expression child must precede its parent"); + let (rest, i4) = read_nodes_n(i3, n - 1, node_idx + 1); + ((&(Lists::Node::Cons(SysNode::Sub(a, b), rest))), i4) } , + 8 => { + let (a, i2) = read_vk_u16(i1); + let (b, i3) = read_vk_u16(i2); + assert_eq!(UInt32::less_than_fields(a, node_idx), 1, + "vk: expression child must precede its parent"); + assert_eq!(UInt32::less_than_fields(b, node_idx), 1, + "vk: expression child must precede its parent"); + let (rest, i4) = read_nodes_n(i3, n - 1, node_idx + 1); + ((&(Lists::Node::Cons(SysNode::Mul(a, b), rest))), i4) } , + 9 => { + let (a, i2) = read_vk_u16(i1); + assert_eq!(UInt32::less_than_fields(a, node_idx), 1, + "vk: expression child must precede its parent"); + let (rest, i3) = read_nodes_n(i2, n - 1, node_idx + 1); + ((&(Lists::Node::Cons(SysNode::Neg(a), rest))), i3) } , + 10 => { + let (idx, i2) = read_vk_u16(i1); + let (rest, i3) = read_nodes_n(i2, n - 1, node_idx + 1); + ((&(Lists::Node::Cons(SysNode::Var(0, 0, idx), rest))), i3) } , + 11 => { + let (idx, i2) = read_vk_u16(i1); + let (rest, i3) = read_nodes_n(i2, n - 1, node_idx + 1); + ((&(Lists::Node::Cons(SysNode::Var(0, 1, idx), rest))), i3) } , + 12 => { + let (idx, i2) = read_vk_u16(i1); + let (rest, i3) = read_nodes_n(i2, n - 1, node_idx + 1); + ((&(Lists::Node::Cons(SysNode::Var(1, 0, idx), rest))), i3) } , + 13 => { + let (idx, i2) = read_vk_u16(i1); + let (rest, i3) = read_nodes_n(i2, n - 1, node_idx + 1); + ((&(Lists::Node::Cons(SysNode::Var(1, 1, idx), rest))), i3) } , + 14 => { + let (idx, i2) = read_vk_u16(i1); + let (rest, i3) = read_nodes_n(i2, n - 1, node_idx + 1); + ((&(Lists::Node::Cons(SysNode::Var(2, 0, idx), rest))), i3) } , + _ => { + let (idx, i2) = read_vk_u16(i1); + let (rest, i3) = read_nodes_n(i2, n - 1, node_idx + 1); + ((&(Lists::Node::Cons(SysNode::Var(2, 1, idx), rest))), i3) } , + } } , + } + } + + fn read_node_ids_n(i: Bytes::Stream, n: Field) -> (Lists::List, Bytes::Stream) { + match n { + 0 => { ((&(Lists::Node::Nil)), i) } , + _ => { + let (id, i1) = read_vk_u16(i); + let (rest, i2) = read_node_ids_n(i1, n - 1); + ((&(Lists::Node::Cons(id, rest))), i2) } , + } + } + + inline fn read_sys_lookup(i: Bytes::Stream) -> (SysLookup, Bytes::Stream) { + let (m, i1) = read_vk_u16(i); + let (ac, i2) = read_vk_u16(i1); + let (args, i3) = read_node_ids_n(i2, ac); + (SysLookup::Mk(m, args), i3) + } + + fn read_sys_lookups_n(i: Bytes::Stream, n: Field) -> (Lists::List, Bytes::Stream) { + match n { + 0 => { ((&(Lists::Node::Nil)), i) } , + _ => { + let (x, j) = read_sys_lookup(i); + let (rest, j2) = read_sys_lookups_n(j, n - 1); + ((&(Lists::Node::Cons(x, rest))), j2) } , + } + } + + fn lookup_groups_count(n: Field, rem: Field, k: Field) -> Field { + match n { + 0 => { 0 } , + _ => { match rem { + 0 => { 1 + lookup_groups_count(n - 1, k - 1, k) } , + _ => { lookup_groups_count(n - 1, rem - 1, k) } , + } } , + } + } + + inline fn read_sys_circuit(base: Bytes::Stream) -> (SysCircuit, [UInt64::U64; 7], Bytes::Stream) { + let (mw, mwl, c1) = read_vk_u16_limb(base); + let (pw, pwl, c2) = read_vk_u16_limb(c1); + let (ph, phl, c3) = read_vk_u32_limb(c2); + let (md, mdl, c4) = read_vk_u16_limb(c3); + let (k, c4b) = read_vk_tag(c4); + let (ncount, c5) = read_vk_u16(c4b); + let (nodes, c6) = read_nodes_n(c5, ncount, 0); + let (zcount, c7) = read_vk_u16(c6); + let (zeros, c8) = read_node_ids_n(c7, zcount); + let (lcount, c9) = read_vk_u16(c8); + let (lks, c10) = read_sys_lookups_n(c9, lcount); + + let groups = lookup_groups_count(lcount, 0, k); + let gslots = groups + Fields::is_zero(groups); + let s2w = gslots + gslots; + let ccl = Goldilocks::gl_to_bytes(zcount + s2w); + let s2wl = Goldilocks::gl_to_bytes(s2w); + let kl = Goldilocks::gl_to_bytes(k); + (SysCircuit::Mk(nodes, ncount, zeros, md, lks, k, mw, pw, s2w), + [ccl, mdl, phl, pwl, mwl, s2wl, kl], c10) + } + + inline fn cons_shape7(l: [UInt64::U64; 7], tail: Lists::List) -> Lists::List { + (&(Lists::Node::Cons(l[0], (&(Lists::Node::Cons(l[1], (&(Lists::Node::Cons(l[2], + (&(Lists::Node::Cons(l[3], (&(Lists::Node::Cons(l[4], (&(Lists::Node::Cons(l[5], + (&(Lists::Node::Cons(l[6], tail))))))))))))))))))))) + } + + fn read_sys_circuits_n(i: Bytes::Stream, n: Field) -> (Lists::List, Lists::List, Bytes::Stream) { + match n { + 0 => { ((&(Lists::Node::Nil)), (&(Lists::Node::Nil)), i) } , + _ => { + let (x, xl, j) = read_sys_circuit(i); + let (rest, lrest, j2) = read_sys_circuits_n(j, n - 1); + ((&(Lists::Node::Cons(x, rest))), cons_shape7(xl, lrest), j2) } , + } + } + + fn read_opt_commit(i: Bytes::Stream) -> (OptCommit, Bytes::Stream) { + let (tag, j) = read_vk_u8(i); + match UInt8::to_field(tag) { + 0 => { (OptCommit::NoCommit, j) } , + _ => { + let (n, j1) = read_vk_u16(j); + let (c, j2) = read_vk_cap_n(j1, n); + (OptCommit::SomeCommit(c), j2) } , + } + } + + fn read_opt_idx_n(i: Bytes::Stream, n: Field) -> (Lists::List, Bytes::Stream) { + match n { + 0 => { ((&(Lists::Node::Nil)), i) } , + _ => { + let (v, j) = read_vk_u16(i); + let (rest, j2) = read_opt_idx_n(j, n - 1); + match v { + 65535 => { ((&(Lists::Node::Cons(OptIdx::NoIdx, rest))), j2) } , + _ => { ((&(Lists::Node::Cons(OptIdx::SomeIdx(v), rest))), j2) } , + } } , + } + } + + inline fn read_sys_params(i: Bytes::Stream) -> (SysParams, Lists::List, Bytes::Stream) { + let (p0, l0, j0) = read_vk_u16_limb(i); + let (p1, l1, j1) = read_vk_u16_limb(j0); + let (p2, l2, j2) = read_vk_u16_limb(j1); + let (p3, l3, j3) = read_vk_u16_limb(j2); + let (p4, l4, j4) = read_vk_u16_limb(j3); + let (p5, l5, j5) = read_vk_u16_limb(j4); + let (p6, l6, j6) = read_vk_u16_limb(j5); + (SysParams::Mk(p0, p1, p2, p3, p4, p5, p6), + (&(Lists::Node::Cons(l0, (&(Lists::Node::Cons(l1, (&(Lists::Node::Cons(l2, + (&(Lists::Node::Cons(l3, (&(Lists::Node::Cons(l4, (&(Lists::Node::Cons(l5, + (&(Lists::Node::Cons(l6, (&(Lists::Node::Nil))))))))))))))))))))))), + j6) + } + + inline fn read_system(i: Bytes::Stream) -> (Sys, Bytes::Stream) { + let (params, plimbs, j) = read_sys_params(i); + let (n, nlimb, j1) = read_vk_u16_limb(j); + let (circuits, climbs, j2) = read_sys_circuits_n(j1, n); + let (commit, j3) = read_opt_commit(j2); + let (indices, j4) = read_opt_idx_n(j3, n); + (Sys::Mk(params, + Lists::concat(plimbs, (&(Lists::Node::Cons(nlimb, climbs)))), + circuits, commit, indices), + j4) + } +} diff --git a/MultiStark/MultiStark/Modules/Transcript.aiur b/MultiStark/MultiStark/Modules/Transcript.aiur new file mode 100644 index 000000000..fd9e435b5 --- /dev/null +++ b/MultiStark/MultiStark/Modules/Transcript.aiur @@ -0,0 +1,81 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module Transcript { + fn ch_sample8(input: Bytes::Stream, output: Bytes::Stream) -> ([UInt8::U8; 8], Bytes::Stream, Bytes::Stream) { + match (*(output)) { + Lists::Node::Nil => { + + let h = Blake3::hash(input); + let fwd = StarkHash::b3_flatten_onto(h, (&(Lists::Node::Nil))); + let rev = StarkVerifier::rev_onto(fwd, (&(Lists::Node::Nil))); + let &Lists::Node::Cons(b0, r1) = rev; + let &Lists::Node::Cons(b1, r2) = r1; + let &Lists::Node::Cons(b2, r3) = r2; + let &Lists::Node::Cons(b3, r4) = r3; + let &Lists::Node::Cons(b4, r5) = r4; + let &Lists::Node::Cons(b5, r6) = r5; + let &Lists::Node::Cons(b6, r7) = r6; + let &Lists::Node::Cons(b7, r8) = r7; + ([b0, b1, b2, b3, b4, b5, b6, b7], fwd, r8) } , + Lists::Node::Cons(b0, r1) => { + let &Lists::Node::Cons(b1, r2) = r1; + let &Lists::Node::Cons(b2, r3) = r2; + let &Lists::Node::Cons(b3, r4) = r3; + let &Lists::Node::Cons(b4, r5) = r4; + let &Lists::Node::Cons(b5, r6) = r5; + let &Lists::Node::Cons(b6, r7) = r6; + let &Lists::Node::Cons(b7, r8) = r7; + ([b0, b1, b2, b3, b4, b5, b6, b7], input, r8) } , + } + } + + fn ch_sample_field(input: Bytes::Stream, output: Bytes::Stream) -> ([UInt8::U8; 8], Bytes::Stream, Bytes::Stream) { + let (raw, i1, o1) = ch_sample8(input, output); + match Goldilocks::gl_lt_p(raw) { + 1 => { (raw, i1, o1) } , + _ => { ch_sample_field(i1, o1) } , + } + } + + fn ch_sample_ext(input: Bytes::Stream, output: Bytes::Stream) -> ([UInt8::U8; 8], [UInt8::U8; 8], Bytes::Stream, Bytes::Stream) { + let (c0, i0, o0) = ch_sample_field(input, output); + let (c1, i1, o1) = ch_sample_field(i0, o0); + (c0, c1, i1, o1) + } + + fn ch_sample_bits(input: Bytes::Stream, output: Bytes::Stream, n: Field) + -> (Lists::List, Bytes::Stream, Bytes::Stream) { + let (bytes, i1, o1) = ch_sample8(input, output); + let bits = + StarkVerifier::cons8(UInt8::bit_decomposition(bytes[0]), + StarkVerifier::cons8(UInt8::bit_decomposition(bytes[1]), + StarkVerifier::cons8(UInt8::bit_decomposition(bytes[2]), + StarkVerifier::cons8(UInt8::bit_decomposition(bytes[3]), (&(Lists::Node::Nil)))))); + (StarkVerifier::take_bits(bits, n), i1, o1) + } + + fn batch_fiat_shamir(tlimbs: Lists::List, prep: ProofDeserialize::MerkleCap, headers: Lists::List, + messages: Lists::List) -> (ProofDeserialize::Ext, ProofDeserialize::Ext, Bytes::Stream) { + let input = StarkVerifier::messages_onto(messages, (&(Lists::Node::Nil))); + let input = StarkVerifier::headers_onto(headers, input); + let input = StarkVerifier::count_onto(Lists::length(headers), input); + let input = StarkVerifier::cap_onto(prep, input); + let input = StarkVerifier::limbs_onto(tlimbs, input); + let input = StarkVerifier::seed_tag_onto(input); + let (l0, l1, input, _ol) = ch_sample_ext(input, (&(Lists::Node::Nil))); + let input = Lists::concat(input, StarkVerifier::b8_onto(l0, StarkVerifier::b8_onto(l1, (&(Lists::Node::Nil))))); + let (f0, f1, input, _of) = ch_sample_ext(input, (&(Lists::Node::Nil))); + let input = Lists::concat(input, StarkVerifier::b8_onto(f0, StarkVerifier::b8_onto(f1, (&(Lists::Node::Nil))))); + ([Goldilocks::gl_val(l0), Goldilocks::gl_val(l1)], [Goldilocks::gl_val(f0), Goldilocks::gl_val(f1)], input) + } + + fn shard_fiat_shamir(input: Bytes::Stream, shard: Field, s2: ProofDeserialize::MerkleCap, q: ProofDeserialize::MerkleCap, + accs: Lists::List) -> (ProofDeserialize::Ext, ProofDeserialize::Ext, Bytes::Stream) { + let input = StarkVerifier::snoc_b8(input, Goldilocks::gl_to_bytes(shard)); + let input = StarkVerifier::snoc_cap(input, s2); + let input = Lists::concat(input, StarkVerifier::accs_onto(accs, (&(Lists::Node::Nil)))); + let (a0, a1, input, _oa) = ch_sample_ext(input, (&(Lists::Node::Nil))); + let input = StarkVerifier::snoc_cap(input, q); + let (z0, z1, zinput, _oz) = ch_sample_ext(input, (&(Lists::Node::Nil))); + ([Goldilocks::gl_val(a0), Goldilocks::gl_val(a1)], [Goldilocks::gl_val(z0), Goldilocks::gl_val(z1)], zinput) + } +} diff --git a/MultiStark/MultiStark/Program.aiur b/MultiStark/MultiStark/Program.aiur new file mode 100644 index 000000000..18361ae3d --- /dev/null +++ b/MultiStark/MultiStark/Program.aiur @@ -0,0 +1,22 @@ +// Generated by tools/ixvm; edit the reviewed adapter or its source. +module MultiStark { + fn verify_multi_stark_proof(system_digest: [Field; 8], claims_digest: [Field; 8]) -> () { + + let (idx, len) = hint::<(Field, Field)>("stark.io.info", (0, 0)); + + let (sidx, slen) = hint::<(Field, Field)>("stark.io.info", (1, 0)); + let sbytes = StarkIO::read_byte_stream(1, sidx, slen); + assert_eq!(Blake3::pack_digest(Blake3::hash(sbytes)), system_digest); + let (sys, srest) = SystemDeserialize::read_system(sbytes); + let Lists::Node::Nil = (*(srest)); + + let (cidx, clen) = hint::<(Field, Field)>("stark.io.info", (2, 0)); + let cbytes = StarkIO::read_byte_stream(2, cidx, clen); + assert_eq!(Blake3::pack_digest(Blake3::hash(cbytes)), claims_digest); + let (claims, crest) = StarkVerifier::read_claims(cbytes); + let Lists::Node::Nil = (*(crest)); + + assert_eq!(StarkVerifier::verify_batch_at(sys, idx, len, claims), 1); + () + } +} diff --git a/MultiStark/MultiStark/Program.lean b/MultiStark/MultiStark/Program.lean new file mode 100644 index 000000000..fc4da2f46 --- /dev/null +++ b/MultiStark/MultiStark/Program.lean @@ -0,0 +1,23 @@ +import Aiur.Modules.Frontend +import Aiur.Library.Blake3.Goldilocks +import Aiur.Library.Option +import Aiur.Library.Field.Goldilocks + +/-! Recursive multi-stark verification as an ordinary Aiur program. This package +selects Goldilocks explicitly, including its degree-two extension and Blake3 +transcript. It introduces no compiler or semantic primitives. -/ +namespace MultiStark +open Aiur + +abbrev modulus := Library.U32.Goldilocks.modulus +abbrev F := Library.U32.Goldilocks.F + +def parse (env : Lean.Environment) (text : String) : Except String (Modules.Program F) := do + let source ← Modules.Frontend.parse env text + Modules.checkTemplates (Library.Blake3.templates.append Library.Option.declarations + |>.append Library.Field.Goldilocks.declarations |>.append source) + return Library.Blake3.Goldilocks.program.append (Library.Option.declarations.toField F) + |>.append Library.Field.Goldilocks.program + |>.append (source.toField F) + +end MultiStark diff --git a/MultiStark/MultiStark/Program.names.json b/MultiStark/MultiStark/Program.names.json new file mode 100644 index 000000000..48b943605 --- /dev/null +++ b/MultiStark/MultiStark/Program.names.json @@ -0,0 +1,266 @@ +{ + "MultiStark::Addr": "Bytes::AddressRef", + "MultiStark::Batch": "ProofDeserialize::Batch", + "MultiStark::BatchMessage": "ProofDeserialize::BatchMessage", + "MultiStark::BatchMultiOpening": "ProofDeserialize::BatchMultiOpening", + "MultiStark::BatchOpening": "ProofDeserialize::BatchOpening", + "MultiStark::Bucket": "Pcs::Bucket", + "MultiStark::ByteStream": "Bytes::Stream", + "MultiStark::CommitPhaseMultiStep": "ProofDeserialize::CommitPhaseMultiStep", + "MultiStark::CommitPhaseProofStep": "ProofDeserialize::CommitPhaseProofStep", + "MultiStark::Commitments": "ProofDeserialize::Commitments", + "MultiStark::Digest": "ProofDeserialize::Digest", + "MultiStark::DigestP": "ProofDeserialize::DigestP", + "MultiStark::Ext": "ProofDeserialize::Ext", + "MultiStark::ExtGoldilocks": "Goldilocks::ExtGoldilocks", + "MultiStark::FriProof": "ProofDeserialize::FriProof", + "MultiStark::FrontierNode": "Pcs::FrontierNode", + "MultiStark::Goldilocks": "Goldilocks::Goldilocks", + "MultiStark::Layer": "Blake3::Layer", + "MultiStark::List": "Lists::List", + "MultiStark::MerkleCap": "ProofDeserialize::MerkleCap", + "MultiStark::OpenedRound": "ProofDeserialize::OpenedRound", + "MultiStark::OptCommit": "SystemDeserialize::OptCommit", + "MultiStark::OptIdx": "SystemDeserialize::OptIdx", + "MultiStark::Option": "Options::Option", + "MultiStark::PreprocessedOpt": "ProofDeserialize::PreprocessedOpt", + "MultiStark::Proof": "ProofDeserialize::Proof", + "MultiStark::QueryProof": "ProofDeserialize::QueryProof", + "MultiStark::ShardHeader": "ProofDeserialize::ShardHeader", + "MultiStark::Sys": "SystemDeserialize::Sys", + "MultiStark::SysCircuit": "SystemDeserialize::SysCircuit", + "MultiStark::SysLookup": "SystemDeserialize::SysLookup", + "MultiStark::SysNode": "SystemDeserialize::SysNode", + "MultiStark::SysParams": "SystemDeserialize::SysParams", + "MultiStark::U32": "UInt32::U32", + "MultiStark::U64": "UInt64::U64", + "MultiStark::U8": "UInt8::U8", + "MultiStark::accs_onto": "StarkVerifier::accs_onto", + "MultiStark::active_onto": "StarkVerifier::active_onto", + "MultiStark::assert_bits": "StarkVerifier::assert_bits", + "MultiStark::assert_blowup_zero": "Pcs::assert_blowup_zero", + "MultiStark::assert_closure_pairs": "StarkVerifier::assert_closure_pairs", + "MultiStark::assert_log_degrees_ok": "StarkVerifier::assert_log_degrees_ok", + "MultiStark::assert_same_bits": "StarkVerifier::assert_same_bits", + "MultiStark::assert_same_cap": "StarkVerifier::assert_same_cap", + "MultiStark::assert_same_claims": "StarkVerifier::assert_same_claims", + "MultiStark::assert_same_limbs": "StarkVerifier::assert_same_limbs", + "MultiStark::assert_same_u8s": "StarkVerifier::assert_same_u8s", + "MultiStark::assert_shard_count_ok": "StarkVerifier::assert_shard_count_ok", + "MultiStark::b3_flatten_onto": "StarkHash::b3_flatten_onto", + "MultiStark::b3_pack": "Blake3::pack_digest", + "MultiStark::b3_pack_w": "Blake3::pack_word", + "MultiStark::b3_rows": "StarkHash::b3_rows", + "MultiStark::b3_rows_chunks": "StarkHash::b3_rows_chunks", + "MultiStark::b3_to_digest": "StarkHash::b3_to_digest", + "MultiStark::b3_w4_onto": "StarkHash::b3_w4_onto", + "MultiStark::b8_onto": "StarkVerifier::b8_onto", + "MultiStark::batch_claims": "StarkVerifier::batch_claims", + "MultiStark::batch_fiat_shamir": "Transcript::batch_fiat_shamir", + "MultiStark::batch_views_at": "Pcs::batch_views_at", + "MultiStark::bits_to_num": "Pcs::bits_to_num", + "MultiStark::bucket_update": "Pcs::bucket_update", + "MultiStark::build_buckets": "Pcs::build_buckets", + "MultiStark::build_publics": "StarkVerifier::build_publics", + "MultiStark::bytes8_le": "StarkVerifier::bytes8_le", + "MultiStark::cap_onto": "StarkVerifier::cap_onto", + "MultiStark::ch_sample8": "Transcript::ch_sample8", + "MultiStark::ch_sample_bits": "Transcript::ch_sample_bits", + "MultiStark::ch_sample_ext": "Transcript::ch_sample_ext", + "MultiStark::ch_sample_field": "Transcript::ch_sample_field", + "MultiStark::circ_has_height": "Pcs::circ_has_height", + "MultiStark::claims_acc": "StarkVerifier::claims_acc", + "MultiStark::claims_onto": "StarkVerifier::claims_onto", + "MultiStark::claims_onto_each": "StarkVerifier::claims_onto_each", + "MultiStark::compress_ordered": "Pcs::compress_ordered", + "MultiStark::cons8": "StarkVerifier::cons8", + "MultiStark::cons_shape7": "SystemDeserialize::cons_shape7", + "MultiStark::count_ones": "StarkVerifier::count_ones", + "MultiStark::count_onto": "StarkVerifier::count_onto", + "MultiStark::digest_eq": "StarkHash::digest_eq", + "MultiStark::digest_onto": "StarkVerifier::digest_onto", + "MultiStark::drop_index_bits": "Pcs::drop_index_bits", + "MultiStark::eg_add": "Goldilocks::eg_add", + "MultiStark::eg_div": "Goldilocks::eg_div", + "MultiStark::eg_eq": "Goldilocks::eg_eq", + "MultiStark::eg_inverse": "Goldilocks::eg_inverse", + "MultiStark::eg_mul": "Goldilocks::eg_mul", + "MultiStark::eg_neg": "Goldilocks::eg_neg", + "MultiStark::eg_sub": "Goldilocks::eg_sub", + "MultiStark::eval_at": "StarkVerifier::eval_at", + "MultiStark::exp_by_bits": "Pcs::exp_by_bits", + "MultiStark::ext_exp_pow2": "StarkVerifier::ext_exp_pow2", + "MultiStark::ext_is_zero": "StarkVerifier::ext_is_zero", + "MultiStark::ext_row_onto": "Pcs::ext_row_onto", + "MultiStark::fingerprint_vals": "StarkVerifier::fingerprint_vals", + "MultiStark::flatten2": "Pcs::flatten2", + "MultiStark::fold_roots": "StarkVerifier::fold_roots", + "MultiStark::fri_fold2": "Pcs::fri_fold2", + "MultiStark::from_ext_basis": "StarkVerifier::from_ext_basis", + "MultiStark::frontier_fold": "Mmcs::frontier_fold", + "MultiStark::frontier_leaves": "Mmcs::frontier_leaves", + "MultiStark::frontier_level": "Mmcs::frontier_level", + "MultiStark::frontier_merge": "Mmcs::frontier_merge", + "MultiStark::frontier_sort": "Mmcs::frontier_sort", + "MultiStark::frontier_split": "Mmcs::frontier_split", + "MultiStark::gl_inverse": "Goldilocks::gl_inverse", + "MultiStark::gl_lt_p": "Goldilocks::gl_lt_p", + "MultiStark::gl_to_bytes": "Goldilocks::gl_to_bytes", + "MultiStark::gl_val": "Goldilocks::gl_val", + "MultiStark::glist_rev": "Pcs::glist_rev", + "MultiStark::has_height": "Pcs::has_height", + "MultiStark::header_onto": "StarkVerifier::header_onto", + "MultiStark::headers_onto": "StarkVerifier::headers_onto", + "MultiStark::heights_all": "Pcs::heights_all", + "MultiStark::heights_max": "Pcs::heights_max", + "MultiStark::heights_prep": "Pcs::heights_prep", + "MultiStark::inject_maybe": "Pcs::inject_maybe", + "MultiStark::last_acc": "StarkVerifier::last_acc", + "MultiStark::le_step": "StarkVerifier::le_step", + "MultiStark::leaf_hash_at": "Pcs::leaf_hash_at", + "MultiStark::limb_to_field": "ProofDeserialize::limb_to_field", + "MultiStark::limbs_onto": "StarkVerifier::limbs_onto", + "MultiStark::list_concat": "Lists::concat", + "MultiStark::list_drop": "Lists::drop", + "MultiStark::list_length": "Lists::length", + "MultiStark::list_lookup": "Lists::lookup", + "MultiStark::log_degree_ok": "StarkVerifier::log_degree_ok", + "MultiStark::log_degrees_onto": "StarkVerifier::log_degrees_onto", + "MultiStark::logup_fingerprint": "StarkVerifier::logup_fingerprint", + "MultiStark::logup_steps_fold": "StarkVerifier::logup_steps_fold", + "MultiStark::lookup_groups_count": "SystemDeserialize::lookup_groups_count", + "MultiStark::messages_acc": "StarkVerifier::messages_acc", + "MultiStark::messages_onto": "StarkVerifier::messages_onto", + "MultiStark::messages_onto_each": "StarkVerifier::messages_onto_each", + "MultiStark::mmcs_compress": "Mmcs::mmcs_compress", + "MultiStark::mmcs_verify_multi": "Mmcs::mmcs_verify_multi", + "MultiStark::obs_log_arities": "Pcs::obs_log_arities", + "MultiStark::ood_composition": "StarkVerifier::ood_composition", + "MultiStark::ood_fold": "StarkVerifier::ood_fold", + "MultiStark::ood_loop": "StarkVerifier::ood_loop", + "MultiStark::ood_prep_rows": "StarkVerifier::ood_prep_rows", + "MultiStark::open_2pt_mat": "Pcs::open_2pt_mat", + "MultiStark::open_batch_2pt": "Pcs::open_batch_2pt", + "MultiStark::open_prep": "Pcs::open_prep", + "MultiStark::open_prep_batch": "Pcs::open_prep_batch", + "MultiStark::open_quotient": "Pcs::open_quotient", + "MultiStark::opt_commit_cap": "StarkVerifier::opt_commit_cap", + "MultiStark::pair_mul": "StarkVerifier::pair_mul", + "MultiStark::pcs_betas": "Pcs::pcs_betas", + "MultiStark::pcs_check_witness": "Pcs::pcs_check_witness", + "MultiStark::pcs_fri_verify": "Pcs::pcs_fri_verify", + "MultiStark::points_onto": "Pcs::points_onto", + "MultiStark::pow2": "StarkVerifier::pow2", + "MultiStark::prep_count": "Pcs::prep_count", + "MultiStark::prep_onto": "Pcs::prep_onto", + "MultiStark::query_loop": "Pcs::query_loop", + "MultiStark::query_views": "Pcs::query_views", + "MultiStark::quotient_degree_of": "StarkVerifier::quotient_degree_of", + "MultiStark::quotient_eval": "StarkVerifier::quotient_eval", + "MultiStark::read_active": "ProofDeserialize::read_active", + "MultiStark::read_active_n": "ProofDeserialize::read_active_n", + "MultiStark::read_batch": "ProofDeserialize::read_batch", + "MultiStark::read_batch_opening": "ProofDeserialize::read_batch_opening", + "MultiStark::read_batch_opening_vec": "ProofDeserialize::read_batch_opening_vec", + "MultiStark::read_batch_opening_vec_n": "ProofDeserialize::read_batch_opening_vec_n", + "MultiStark::read_byte_stream": "StarkIO::read_byte_stream", + "MultiStark::read_claim_vals_n": "StarkVerifier::read_claim_vals_n", + "MultiStark::read_claims": "StarkVerifier::read_claims", + "MultiStark::read_claims_n": "StarkVerifier::read_claims_n", + "MultiStark::read_commit_phase_step": "ProofDeserialize::read_commit_phase_step", + "MultiStark::read_commit_phase_step_vec": "ProofDeserialize::read_commit_phase_step_vec", + "MultiStark::read_commit_phase_step_vec_n": "ProofDeserialize::read_commit_phase_step_vec_n", + "MultiStark::read_commitments": "ProofDeserialize::read_commitments", + "MultiStark::read_count": "ProofDeserialize::read_count", + "MultiStark::read_count_at": "ProofDeserialize::read_count_at", + "MultiStark::read_digest_at": "ProofDeserialize::read_digest_at", + "MultiStark::read_digest_vec_at": "ProofDeserialize::read_digest_vec_at", + "MultiStark::read_digest_vec_at_n": "ProofDeserialize::read_digest_vec_at_n", + "MultiStark::read_ext_at": "ProofDeserialize::read_ext_at", + "MultiStark::read_ext_vec": "ProofDeserialize::read_ext_vec", + "MultiStark::read_ext_vec_n": "ProofDeserialize::read_ext_vec_n", + "MultiStark::read_ext_vec_vec": "ProofDeserialize::read_ext_vec_vec", + "MultiStark::read_ext_vec_vec_n": "ProofDeserialize::read_ext_vec_vec_n", + "MultiStark::read_field": "SystemDeserialize::read_field", + "MultiStark::read_fri_proof": "ProofDeserialize::read_fri_proof", + "MultiStark::read_header": "ProofDeserialize::read_header", + "MultiStark::read_header_vec": "ProofDeserialize::read_header_vec", + "MultiStark::read_header_vec_n": "ProofDeserialize::read_header_vec_n", + "MultiStark::read_merkle_cap_at": "ProofDeserialize::read_merkle_cap_at", + "MultiStark::read_merkle_cap_vec": "ProofDeserialize::read_merkle_cap_vec", + "MultiStark::read_merkle_cap_vec_n": "ProofDeserialize::read_merkle_cap_vec_n", + "MultiStark::read_message": "ProofDeserialize::read_message", + "MultiStark::read_message_vec": "ProofDeserialize::read_message_vec", + "MultiStark::read_message_vec_n": "ProofDeserialize::read_message_vec_n", + "MultiStark::read_node_ids_n": "SystemDeserialize::read_node_ids_n", + "MultiStark::read_nodes_n": "SystemDeserialize::read_nodes_n", + "MultiStark::read_one_claim": "StarkVerifier::read_one_claim", + "MultiStark::read_opened_round": "ProofDeserialize::read_opened_round", + "MultiStark::read_opened_round_n": "ProofDeserialize::read_opened_round_n", + "MultiStark::read_opt_commit": "SystemDeserialize::read_opt_commit", + "MultiStark::read_opt_idx_n": "SystemDeserialize::read_opt_idx_n", + "MultiStark::read_preprocessed": "ProofDeserialize::read_preprocessed", + "MultiStark::read_proof": "ProofDeserialize::read_proof", + "MultiStark::read_proof_vec": "ProofDeserialize::read_proof_vec", + "MultiStark::read_proof_vec_n": "ProofDeserialize::read_proof_vec_n", + "MultiStark::read_sys_circuit": "SystemDeserialize::read_sys_circuit", + "MultiStark::read_sys_circuits_n": "SystemDeserialize::read_sys_circuits_n", + "MultiStark::read_sys_lookup": "SystemDeserialize::read_sys_lookup", + "MultiStark::read_sys_lookups_n": "SystemDeserialize::read_sys_lookups_n", + "MultiStark::read_sys_params": "SystemDeserialize::read_sys_params", + "MultiStark::read_system": "SystemDeserialize::read_system", + "MultiStark::read_u64": "ProofDeserialize::read_u64", + "MultiStark::read_u64_at": "ProofDeserialize::read_u64_at", + "MultiStark::read_u64_vec": "ProofDeserialize::read_u64_vec", + "MultiStark::read_u64_vec_n": "ProofDeserialize::read_u64_vec_n", + "MultiStark::read_u64_vec_vec": "ProofDeserialize::read_u64_vec_vec", + "MultiStark::read_u64_vec_vec_n": "ProofDeserialize::read_u64_vec_vec_n", + "MultiStark::read_u64_vec_vec_vec": "ProofDeserialize::read_u64_vec_vec_vec", + "MultiStark::read_u64_vec_vec_vec_n": "ProofDeserialize::read_u64_vec_vec_vec_n", + "MultiStark::read_u8": "ProofDeserialize::read_u8", + "MultiStark::read_u8_at": "ProofDeserialize::read_u8_at", + "MultiStark::read_u8_vec": "ProofDeserialize::read_u8_vec", + "MultiStark::read_u8_vec_n": "ProofDeserialize::read_u8_vec_n", + "MultiStark::read_vk_cap_n": "SystemDeserialize::read_vk_cap_n", + "MultiStark::read_vk_digest": "SystemDeserialize::read_vk_digest", + "MultiStark::read_vk_tag": "SystemDeserialize::read_vk_tag", + "MultiStark::read_vk_u16": "SystemDeserialize::read_vk_u16", + "MultiStark::read_vk_u16_limb": "SystemDeserialize::read_vk_u16_limb", + "MultiStark::read_vk_u32_limb": "SystemDeserialize::read_vk_u32_limb", + "MultiStark::read_vk_u64": "SystemDeserialize::read_vk_u64", + "MultiStark::read_vk_u8": "SystemDeserialize::read_vk_u8", + "MultiStark::recon_evals": "Pcs::recon_evals", + "MultiStark::reconstruct_ext_row": "StarkVerifier::reconstruct_ext_row", + "MultiStark::rev_onto": "StarkVerifier::rev_onto", + "MultiStark::ri_apply": "Pcs::ri_apply", + "MultiStark::ro_fold": "Pcs::ro_fold", + "MultiStark::ro_x": "Pcs::ro_x", + "MultiStark::rollin": "Pcs::rollin", + "MultiStark::round_onto": "Pcs::round_onto", + "MultiStark::rows_at_round": "Pcs::rows_at_round", + "MultiStark::rows_pop": "Pcs::rows_pop", + "MultiStark::sample_query_indices": "Pcs::sample_query_indices", + "MultiStark::seed_tag_onto": "StarkVerifier::seed_tag_onto", + "MultiStark::select_active_circuits": "StarkVerifier::select_active_circuits", + "MultiStark::select_active_prep": "StarkVerifier::select_active_prep", + "MultiStark::select_rows": "Pcs::select_rows", + "MultiStark::select_rows_le": "Pcs::select_rows_le", + "MultiStark::shard_fiat_shamir": "Transcript::shard_fiat_shamir", + "MultiStark::snoc_b8": "StarkVerifier::snoc_b8", + "MultiStark::snoc_cap": "StarkVerifier::snoc_cap", + "MultiStark::step_views_at": "Pcs::step_views_at", + "MultiStark::take_bits": "StarkVerifier::take_bits", + "MultiStark::three_limbs": "StarkVerifier::three_limbs", + "MultiStark::trace_selectors": "StarkVerifier::trace_selectors", + "MultiStark::trace_vanishing": "StarkVerifier::trace_vanishing", + "MultiStark::two_adic_gen": "StarkVerifier::two_adic_gen", + "MultiStark::verify_batch": "StarkVerifier::verify_batch", + "MultiStark::verify_batch_at": "StarkVerifier::verify_batch_at", + "MultiStark::verify_commit_multi": "Pcs::verify_commit_multi", + "MultiStark::verify_input_multi": "Pcs::verify_input_multi", + "MultiStark::verify_multi_stark_proof": "MultiStark::verify_multi_stark_proof", + "MultiStark::verify_one_query": "Pcs::verify_one_query", + "MultiStark::verify_query": "Pcs::verify_query", + "MultiStark::verify_shard": "StarkVerifier::verify_shard", + "MultiStark::verify_shards": "StarkVerifier::verify_shards" +} diff --git a/MultiStark/MultiStark/Program.sources b/MultiStark/MultiStark/Program.sources new file mode 100644 index 000000000..84c250d82 --- /dev/null +++ b/MultiStark/MultiStark/Program.sources @@ -0,0 +1,10 @@ +# Ordered Aiur source bundle; paths are relative to this file. +Modules/ProofDeserialize.aiur +Modules/SystemDeserialize.aiur +Modules/Pcs.aiur +Modules/StarkIO.aiur +Modules/StarkHash.aiur +Modules/Mmcs.aiur +Modules/StarkVerifier.aiur +Modules/Transcript.aiur +Program.aiur diff --git a/MultiStark/Pcs.lean b/MultiStark/Pcs.lean deleted file mode 100644 index 130e99bb4..000000000 --- a/MultiStark/Pcs.lean +++ /dev/null @@ -1,1311 +0,0 @@ -module -public import Ix.Aiur.Meta -public import MultiStark.Deserialize -public import MultiStark.Keccak - -/-! -# PCS (FRI) verification - -Ports `multi-stark/src/verifier.rs`'s `pcs.verify(...)` — a `TwoAdicFriPcs` FRI -verification: Merkle `verify_batch` (binary tree, multi-height injection), the -challenger continuation, the FRI fold chain (`open_input` / `verify_query`), and -the final-polynomial check. - -## Merkle (MMCS) hash primitives - -The input/commit-phase commitments are a `MerkleTreeMmcs` over Blake3 -(`multi-stark/src/types.rs`): - -* leaf hash : `SerializingHasher` — serialize each `Goldilocks` element - to its canonical 8 LE bytes, then `blake3` the row. -* compression: `CompressionFunctionFromHasher` — `blake3(a || b)` - of two 32-byte child digests. - -`Digest` is `[U64; 4]` = the 32 Blake3 output bytes (8-byte LE groups), so the -deserialized caps round-trip unchanged. The Blake3 gadget is `Ix/Aiur/Library/Blake3.lean`. --/ - -public section - -namespace MultiStark - -def pcs := ⟦ - -- ========================================================================== - -- Blake3 MMCS hash primitives. - -- - -- The input/commit-phase commitments are a `MerkleTreeMmcs` over Blake3: - -- leaf = `blake3(serialized row bytes)` (`SerializingHasher`) - -- 2-to-1 = `blake3(a || b)` (`CompressionFunctionFromHasher`) - -- A row's `Val`s are serialized as 8 LE bytes each (canonical `u64`). `Digest` - -- is `[U64; 4]` = the 32 blake3 output bytes (8-byte LE groups), so the - -- deserialized caps round-trip with zero change to the deserializer. - -- ========================================================================== - - -- 8 LE bytes of a `U64` lane (`SerializingHasher`: a `Val` is 8 LE bytes). - fn b3_u64_onto(v: U64, tail: ByteStream) -> ByteStream { - store(ListNode.Cons(v[0], store(ListNode.Cons(v[1], store(ListNode.Cons(v[2], - store(ListNode.Cons(v[3], store(ListNode.Cons(v[4], store(ListNode.Cons(v[5], - store(ListNode.Cons(v[6], store(ListNode.Cons(v[7], tail)))))))))))))))) - } - -- All lanes of a row, in order. - fn b3_row_onto(row: List‹U64›, tail: ByteStream) -> ByteStream { - match load(row) { - ListNode.Nil => tail, - ListNode.Cons(v, rest) => b3_u64_onto(v, b3_row_onto(rest, tail)), - } - } - -- A 4-byte blake3 output word. - fn b3_w4_onto(w: [U8; 4], tail: ByteStream) -> ByteStream { - store(ListNode.Cons(w[0], store(ListNode.Cons(w[1], store(ListNode.Cons(w[2], - store(ListNode.Cons(w[3], tail)))))))) - } - -- The 32 bytes of a blake3 digest (`[[U8;4];8]`, word order = output order). - fn b3_flatten_onto(h: [[U8; 4]; 8], tail: ByteStream) -> ByteStream { - b3_w4_onto(h[0], b3_w4_onto(h[1], b3_w4_onto(h[2], b3_w4_onto(h[3], - b3_w4_onto(h[4], b3_w4_onto(h[5], b3_w4_onto(h[6], b3_w4_onto(h[7], tail)))))))) - } - -- blake3 output `[[U8;4];8]` -> `Digest` `[U64;4]` (two words per LE lane). - fn b3_to_digest(h: [[U8; 4]; 8]) -> Digest { - [[h[0][0], h[0][1], h[0][2], h[0][3], h[1][0], h[1][1], h[1][2], h[1][3]], - [h[2][0], h[2][1], h[2][2], h[2][3], h[3][0], h[3][1], h[3][2], h[3][3]], - [h[4][0], h[4][1], h[4][2], h[4][3], h[5][0], h[5][1], h[5][2], h[5][3]], - [h[6][0], h[6][1], h[6][2], h[6][3], h[7][0], h[7][1], h[7][2], h[7][3]]] - } - -- ========================================================================== - -- Lane-granular blake3 for MMCS leaf rows. A leaf's input is a `List‹U64›` - -- of 8-byte lanes, so blocks (64 bytes = 8 lanes) can be assembled straight - -- from the lane values — one list `load` per lane — instead of serializing - -- to a byte list that `blake3` then walks, re-accumulates, and re-loads - -- (~4 memory ops per byte). Mirrors `blake3_compress_chunks`/`_block`/ - -- `_finish` at block granularity with the identical flag schedule - -- (CHUNK_START = 1, CHUNK_END = 2, ROOT = 8; chunk = 16 blocks), reusing - -- `blake3_compress` and the `Layer` chunk-tree fold unchanged. - -- ========================================================================== - - -- Pop up to 8 lanes (one block), zero-padding the tail. Returns the block's - -- lanes, its real byte length (8·k, so 64 for a full block), and the rest. - fn b3_lane_block(lanes: List‹U64›) -> ([U64; 8], G, List‹U64›) { - let z = [0u8; 8]; - match load(lanes) { - ListNode.Nil => ([z; 8], 0, lanes), - ListNode.Cons(v0, r0) => match load(r0) { - ListNode.Nil => ([v0, z, z, z, z, z, z, z], 8, r0), - ListNode.Cons(v1, r1) => match load(r1) { - ListNode.Nil => ([v0, v1, z, z, z, z, z, z], 16, r1), - ListNode.Cons(v2, r2) => match load(r2) { - ListNode.Nil => ([v0, v1, v2, z, z, z, z, z], 24, r2), - ListNode.Cons(v3, r3) => match load(r3) { - ListNode.Nil => ([v0, v1, v2, v3, z, z, z, z], 32, r3), - ListNode.Cons(v4, r4) => match load(r4) { - ListNode.Nil => ([v0, v1, v2, v3, v4, z, z, z], 40, r4), - ListNode.Cons(v5, r5) => match load(r5) { - ListNode.Nil => ([v0, v1, v2, v3, v4, v5, z, z], 48, r5), - ListNode.Cons(v6, r6) => match load(r6) { - ListNode.Nil => ([v0, v1, v2, v3, v4, v5, v6, z], 56, r6), - ListNode.Cons(v7, r7) => - ([v0, v1, v2, v3, v4, v5, v6, v7], 64, r7), - }, - }, - }, - }, - }, - }, - }, - } - } - - -- Block-granular chunk walk. `block_no` is the block index within the - -- current chunk (0..15); `cv` is the chaining value (IV at each chunk start); - -- chunk digests are pushed onto `layer` in order, exactly like the byte - -- driver, and folded by `blake3_compress_layer` at the end. - fn b3_lane_chunks(lanes: List‹U64›, block_no: G, chunk_count: &U64, cv: &[[U8; 4]; 8], layer: Layer) -> Layer { - match load(lanes) { - -- Exhausted with no block to compress: only reachable for an empty - -- input (every other path detects exhaustion after compressing). - -- Mirror of `blake3_finish`'s (0, 0) arm. - ListNode.Nil => - match load(chunk_count) { - [0, 0, 0, 0, 0, 0, 0, 0] => - store(LayerNode.Push(layer, @blake3_compress_init(load(cv), [[0u8; 4]; 16], load(chunk_count), 0, 11))), - _ => layer, - }, - _ => - let (v, nbytes, rest) = b3_lane_block(lanes); - let block = [ - [v[0][0], v[0][1], v[0][2], v[0][3]], [v[0][4], v[0][5], v[0][6], v[0][7]], - [v[1][0], v[1][1], v[1][2], v[1][3]], [v[1][4], v[1][5], v[1][6], v[1][7]], - [v[2][0], v[2][1], v[2][2], v[2][3]], [v[2][4], v[2][5], v[2][6], v[2][7]], - [v[3][0], v[3][1], v[3][2], v[3][3]], [v[3][4], v[3][5], v[3][6], v[3][7]], - [v[4][0], v[4][1], v[4][2], v[4][3]], [v[4][4], v[4][5], v[4][6], v[4][7]], - [v[5][0], v[5][1], v[5][2], v[5][3]], [v[5][4], v[5][5], v[5][6], v[5][7]], - [v[6][0], v[6][1], v[6][2], v[6][3]], [v[6][4], v[6][5], v[6][6], v[6][7]], - [v[7][0], v[7][1], v[7][2], v[7][3]], [v[7][4], v[7][5], v[7][6], v[7][7]]]; - let empty = match load(rest) { ListNode.Nil => 1, _ => 0, }; - let at15 = eq_zero(block_no - 15); - -- CHUNK_START on the chunk's first block; CHUNK_END iff this is the - -- chunk's 16th block OR the input ends here; ROOT only for the last - -- block of a single-chunk input (multi-chunk roots come from the - -- layer fold's PARENT+ROOT, as in the byte driver). - let start_flag = eq_zero(block_no); - let end_flag = empty + at15 - (empty * at15); - let root_flag = empty * u64_is_zero(load(chunk_count)); - let flags = start_flag + 2 * end_flag + 8 * root_flag; - let digest = @blake3_compress_init(load(cv), block, load(chunk_count), nbytes, flags); - match (empty, at15) { - (1, _) => store(LayerNode.Push(layer, digest)), - (_, 1) => - let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]]; - b3_lane_chunks(rest, 0, store(relaxed_u64_succ(load(chunk_count))), store(IV), store(LayerNode.Push(layer, digest))), - (_, _) => b3_lane_chunks(rest, block_no + 1, chunk_count, store(digest), layer), - }, - } - } - - -- ========================================================================== - -- blake3 straight from an IO channel arena: 64-byte `io_read` blocks fed - -- directly to `blake3_compress` — no byte list is materialized, walked, - -- accumulated, or re-loaded. Same flag schedule as the byte driver; the - -- (cold, once-per-hash) ≤63-byte tail reuses `pad_block`/`bytes_to_block`. - -- Kept as a differential-tested indexed IO hashing helper; no production - -- entrypoint reaches it. It does not range-check the IO cells, so its - -- digest binds only packed 32-bit words. Digest-bound inputs must not - -- hash and deserialize through separate `io_read` calls; the production - -- verifying-key path reads one shared `read_checked_byte_stream`. - -- ========================================================================== - - -- Reverse-ordered tail accumulator (head = last byte), the shape - -- `pad_block`/`bytes_to_block` expect. Reads one byte per step (io_read's - -- length is static); at most 63 steps, once per hash. - fn b3_io_tail_acc(ch: G, i: G, n: G, acc: ByteStream) -> ByteStream { - match n { - 0 => acc, - _ => - let [b] = io_read(ch, i, 1); - b3_io_tail_acc(ch, i + 1, n - 1, - store(ListNode.Cons(u8_from_field_unsafe(b), acc))), - } - } - - fn b3_io_chunks(ch: G, i: G, remaining: G, block_no: G, chunk_count: &U64, cv: &[[U8; 4]; 8], layer: Layer) -> Layer { - match u32_less_than(remaining, 64) { - 0 => - -- A full 64-byte block is available. - let [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, - b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, - b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47, - b48, b49, b50, b51, b52, b53, b54, b55, b56, b57, b58, b59, b60, b61, b62, b63] = - io_read(ch, i, 64); - let block = [ - [u8_from_field_unsafe(b0), u8_from_field_unsafe(b1), u8_from_field_unsafe(b2), u8_from_field_unsafe(b3)], - [u8_from_field_unsafe(b4), u8_from_field_unsafe(b5), u8_from_field_unsafe(b6), u8_from_field_unsafe(b7)], - [u8_from_field_unsafe(b8), u8_from_field_unsafe(b9), u8_from_field_unsafe(b10), u8_from_field_unsafe(b11)], - [u8_from_field_unsafe(b12), u8_from_field_unsafe(b13), u8_from_field_unsafe(b14), u8_from_field_unsafe(b15)], - [u8_from_field_unsafe(b16), u8_from_field_unsafe(b17), u8_from_field_unsafe(b18), u8_from_field_unsafe(b19)], - [u8_from_field_unsafe(b20), u8_from_field_unsafe(b21), u8_from_field_unsafe(b22), u8_from_field_unsafe(b23)], - [u8_from_field_unsafe(b24), u8_from_field_unsafe(b25), u8_from_field_unsafe(b26), u8_from_field_unsafe(b27)], - [u8_from_field_unsafe(b28), u8_from_field_unsafe(b29), u8_from_field_unsafe(b30), u8_from_field_unsafe(b31)], - [u8_from_field_unsafe(b32), u8_from_field_unsafe(b33), u8_from_field_unsafe(b34), u8_from_field_unsafe(b35)], - [u8_from_field_unsafe(b36), u8_from_field_unsafe(b37), u8_from_field_unsafe(b38), u8_from_field_unsafe(b39)], - [u8_from_field_unsafe(b40), u8_from_field_unsafe(b41), u8_from_field_unsafe(b42), u8_from_field_unsafe(b43)], - [u8_from_field_unsafe(b44), u8_from_field_unsafe(b45), u8_from_field_unsafe(b46), u8_from_field_unsafe(b47)], - [u8_from_field_unsafe(b48), u8_from_field_unsafe(b49), u8_from_field_unsafe(b50), u8_from_field_unsafe(b51)], - [u8_from_field_unsafe(b52), u8_from_field_unsafe(b53), u8_from_field_unsafe(b54), u8_from_field_unsafe(b55)], - [u8_from_field_unsafe(b56), u8_from_field_unsafe(b57), u8_from_field_unsafe(b58), u8_from_field_unsafe(b59)], - [u8_from_field_unsafe(b60), u8_from_field_unsafe(b61), u8_from_field_unsafe(b62), u8_from_field_unsafe(b63)]]; - let is_last = eq_zero(remaining - 64); - let at15 = eq_zero(block_no - 15); - let start_flag = eq_zero(block_no); - let end_flag = is_last + at15 - (is_last * at15); - let root_flag = is_last * u64_is_zero(load(chunk_count)); - let flags = start_flag + 2 * end_flag + 8 * root_flag; - let digest = @blake3_compress_init(load(cv), block, load(chunk_count), 64, flags); - match (is_last, at15) { - (1, _) => store(LayerNode.Push(layer, digest)), - (_, 1) => - let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]]; - b3_io_chunks(ch, i + 64, remaining - 64, 0, store(relaxed_u64_succ(load(chunk_count))), store(IV), store(LayerNode.Push(layer, digest))), - (_, _) => b3_io_chunks(ch, i + 64, remaining - 64, block_no + 1, chunk_count, store(digest), layer), - }, - _ => - -- Partial tail (< 64 bytes): always the input's last block. - match remaining { - 0 => - -- Empty input from the very start. Mirror of `blake3_finish`'s - -- (0, 0) arm (any other path compresses before exhausting). - match load(chunk_count) { - [0, 0, 0, 0, 0, 0, 0, 0] => - store(LayerNode.Push(layer, @blake3_compress_init(load(cv), [[0u8; 4]; 16], load(chunk_count), 0, 11))), - _ => layer, - }, - _ => - let block = bytes_to_block(pad_block( - b3_io_tail_acc(ch, i, remaining, store(ListNode.Nil)), 64 - remaining)); - let start_flag = eq_zero(block_no); - let flags = start_flag + 2 + 8 * u64_is_zero(load(chunk_count)); - store(LayerNode.Push(layer, @blake3_compress_init(load(cv), block, load(chunk_count), remaining, flags))), - }, - } - } - - -- blake3 of `len` bytes at offset `idx` on IO channel `ch` (identical - -- output to `blake3` over those bytes — pinned by `io_hash_test`). - fn b3_io(ch: G, idx: G, len: G) -> [[U8; 4]; 8] { - let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]]; - blake3_compress_layer(b3_io_chunks(ch, idx, len, 0, store([0u8; 8]), store(IV), store(LayerNode.Nil))) - } - - -- blake3 of a lane list (identical output to `blake3` over the lanes' LE - -- bytes — pinned by the `lane_hash_test` differential self-test). - fn b3_lanes(lanes: List‹U64›) -> [[U8; 4]; 8] { - let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]]; - blake3_compress_layer(b3_lane_chunks(lanes, 0, store([0u8; 8]), store(IV), store(LayerNode.Nil))) - } - - -- The MMCS leaf hash of a row (`SerializingHasher`). - fn mmcs_hash_row(row: List‹U64›) -> Digest { - @b3_to_digest(b3_lanes(row)) - } - -- The MMCS 2-to-1 compression (`CompressionFunctionFromHasher`). - -- `a || b` is exactly 64 bytes = one blake3 block of a single chunk, so this - -- is one direct `blake3_compress` with the same parameters that input takes - -- through `blake3_compress_chunks`: cv = IV, counter = 0, block_len = 64, - -- flags = CHUNK_START + CHUNK_END + ROOT (1 + 2 + 8). The block words are - -- assembled straight from the digest lanes (each `U64` lane = two LE 4-byte - -- words) — no byte list is built, walked, re-accumulated, or re-loaded. - -- In and out by pointer (see `DigestP`); the 64 block bytes are loaded - -- here, the only place they are consumed. - fn mmcs_compress(ap: DigestP, bp: DigestP) -> DigestP { - let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]]; - let a = load(ap); - let b = load(bp); - let block = [ - [a[0][0], a[0][1], a[0][2], a[0][3]], [a[0][4], a[0][5], a[0][6], a[0][7]], - [a[1][0], a[1][1], a[1][2], a[1][3]], [a[1][4], a[1][5], a[1][6], a[1][7]], - [a[2][0], a[2][1], a[2][2], a[2][3]], [a[2][4], a[2][5], a[2][6], a[2][7]], - [a[3][0], a[3][1], a[3][2], a[3][3]], [a[3][4], a[3][5], a[3][6], a[3][7]], - [b[0][0], b[0][1], b[0][2], b[0][3]], [b[0][4], b[0][5], b[0][6], b[0][7]], - [b[1][0], b[1][1], b[1][2], b[1][3]], [b[1][4], b[1][5], b[1][6], b[1][7]], - [b[2][0], b[2][1], b[2][2], b[2][3]], [b[2][4], b[2][5], b[2][6], b[2][7]], - [b[3][0], b[3][1], b[3][2], b[3][3]], [b[3][4], b[3][5], b[3][6], b[3][7]]]; - store(@b3_to_digest(@blake3_compress_init(IV, block, [0u8; 8], 64, 11))) - } - - -- ========================================================================== - -- Merkle MMCS `verify_batch` (binary tree, DIGEST_ELEMS = 4). - -- - -- Ports `multi-stark/Plonky3/merkle-tree/src/mmcs.rs::verify_batch` for the - -- binary (N = 2) case. All committed matrices have power-of-two heights, so a - -- matrix's height is `2^log_height`. The opened rows arrive in matrix order; - -- `lhs` is the matching list of per-matrix log-heights. The query `index` is - -- threaded as a bit list (LSB first = leaf→root path) to avoid field division. - -- - -- The leaf hash joins all matrices at the maximum log-height. Walking down, - -- each level folds with one proof sibling (ordered by the path bit), then — - -- if any matrix lives at the new log-height — injects that matrix group's leaf - -- hash via a second compression (this consumes no proof sibling), exactly as - -- the Rust loop's `next_height_openings_digest` injection. - -- ========================================================================== - - -- 1 iff two digests are equal (compared as field elements; hash outputs are - -- canonical so this is exact). - fn digest_eq(a: Digest, b: Digest) -> G { - eq_zero(@limb_to_field(a[0]) - @limb_to_field(b[0])) * - eq_zero(@limb_to_field(a[1]) - @limb_to_field(b[1])) * - eq_zero(@limb_to_field(a[2]) - @limb_to_field(b[2])) * - eq_zero(@limb_to_field(a[3]) - @limb_to_field(b[3])) - } - - -- Compress (current, sibling) in path order: path bit 0 ⇒ current is the left - -- child, bit 1 ⇒ current is the right child. - fn compress_ordered(bit: G, d: DigestP, s: DigestP) -> DigestP { - match bit { - 0 => mmcs_compress(d, s), - _ => mmcs_compress(s, d), - } - } - - -- 1 iff some matrix has log-height `target`. - fn has_height(lhs: List‹G›, target: G) -> G { - match load(lhs) { - ListNode.Nil => 0, - ListNode.Cons(h, rest) => - match eq_zero(h - target) { - 1 => 1, - _ => has_height(rest, target), - }, - } - } - - -- Concatenate the opened rows of every matrix whose log-height is `target` - -- (in matrix order — the stable height-sort preserves it), for the joint leaf - -- hash `hash_iter_slices`. - fn concat_at(rows: List‹List‹U64››, lhs: List‹G›, target: G) -> List‹U64› { - match load(rows) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(r, rrest) => - let &ListNode.Cons(lh, lrest) = lhs; - concat_at_step(eq_zero(lh - target), r, rrest, lrest, target), - } - } - fn concat_at_step(hit: G, r: List‹U64›, rrest: List‹List‹U64››, - lrest: List‹G›, target: G) -> List‹U64› { - match hit { - 0 => concat_at(rrest, lrest, target), - _ => list_concat(r, concat_at(rrest, lrest, target)), - } - } - - -- Canonicalize each lane: the MMCS leaf hash serializes `as_canonical_u64`, - -- but opened base values are on the wire in the (possibly non-canonical) - -- internal Goldilocks repr — e.g. field zero ships as `p`. `gl_reduce` maps - -- them to `< p` before hashing (idempotent on already-canonical lanes). - fn canon_lanes(l: List‹U64›) -> List‹U64› { - match load(l) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(x, rest) => store(ListNode.Cons(@gl_to_bytes(@gl_val(x)), canon_lanes(rest))), - } - } - -- ========================================================================== - -- Rows-walking leaf hash: hash the selected rows' lanes directly, with - -- on-the-fly canonicalization — no concatenated lane list is ever - -- materialized (`concat_at` rebuilt every selected lane per query, and - -- `canon_lanes` copied the result again). Differentially pinned against - -- the concat + canon reference by `rows_hash_test`. - -- ========================================================================== - - -- The rows at log-height `target`, dropped if empty (an empty row - -- contributes no bytes, and dropping it lets exhaustion be detected by - -- plain Nil checks in the block walker). - fn select_rows(rows: List‹List‹U64››, lhs: List‹G›, target: G) -> List‹List‹U64›› { - match load(rows) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(r, rrest) => - let &ListNode.Cons(lh, lrest) = lhs; - match eq_zero(lh - target) { - 0 => select_rows(rrest, lrest, target), - _ => match load(r) { - ListNode.Nil => select_rows(rrest, lrest, target), - _ => store(ListNode.Cons(r, select_rows(rrest, lrest, target))), - }, - }, - } - } - - -- Rows of matrices at log-height <= `target`, in circuit order. Used to - -- cross-check that two frontier queries sharing a parent agree on every - -- not-yet-injected (shorter) matrix: only the group lead's rows are hashed - -- into the shared frontier, so the others must be pinned to match it - -- (Plonky3 `verify_batch_pruned`'s `InconsistentGroupOpening`). Skips - -- empty (inactive-circuit) rows exactly as `select_rows`. - fn select_rows_le(rows: List‹List‹U64››, lhs: List‹G›, target: G) -> List‹List‹U64›› { - match load(rows) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(r, rrest) => - let &ListNode.Cons(lh, lrest) = lhs; - match u32_less_than(target, lh) { - 1 => select_rows_le(rrest, lrest, target), - _ => match load(r) { - ListNode.Nil => select_rows_le(rrest, lrest, target), - _ => store(ListNode.Cons(r, select_rows_le(rrest, lrest, target))), - }, - }, - } - } - - -- Pop one canonicalized lane across row boundaries. `got = 0` iff both the - -- current row and the remaining rows are exhausted (selected rows are - -- non-empty, so advancing to the next row always yields a lane). - fn rows_pop(cur: List‹U64›, rows: List‹List‹U64››) -> (U64, List‹U64›, List‹List‹U64››, G) { - match load(cur) { - ListNode.Cons(x, rest) => (@gl_to_bytes(@gl_val(x)), rest, rows, 1), - ListNode.Nil => match load(rows) { - ListNode.Nil => ([0u8; 8], cur, rows, 0), - ListNode.Cons(r, rrest) => rows_pop(r, rrest), - }, - } - } - - -- Block-granular chunk walk over rows-of-lanes; mirrors `b3_lane_chunks` - -- (same flag schedule, same `Layer` fold), gathering each 64-byte block - -- with eight cross-row pops. - fn b3_rows_chunks(cur: List‹U64›, rows: List‹List‹U64››, block_no: G, chunk_count: &U64, cv: &[[U8; 4]; 8], layer: Layer) -> Layer { - let (l0, c1, r1, g0) = rows_pop(cur, rows); - match g0 { - -- Exhausted with no block to compress: only reachable for an empty - -- input (every other path detects exhaustion after compressing). - 0 => - match load(chunk_count) { - [0, 0, 0, 0, 0, 0, 0, 0] => - store(LayerNode.Push(layer, @blake3_compress_init(load(cv), [[0u8; 4]; 16], load(chunk_count), 0, 11))), - _ => layer, - }, - _ => - let (l1, c2, r2, g1) = rows_pop(c1, r1); - let (l2, c3, r3, g2) = rows_pop(c2, r2); - let (l3, c4, r4, g3) = rows_pop(c3, r3); - let (l4, c5, r5, g4) = rows_pop(c4, r4); - let (l5, c6, r6, g5) = rows_pop(c5, r5); - let (l6, c7, r7, g6) = rows_pop(c6, r6); - let (l7, c8, r8, g7) = rows_pop(c7, r7); - let nbytes = 8 * (g0 + g1 + g2 + g3 + g4 + g5 + g6 + g7); - let block = [ - [l0[0], l0[1], l0[2], l0[3]], [l0[4], l0[5], l0[6], l0[7]], - [l1[0], l1[1], l1[2], l1[3]], [l1[4], l1[5], l1[6], l1[7]], - [l2[0], l2[1], l2[2], l2[3]], [l2[4], l2[5], l2[6], l2[7]], - [l3[0], l3[1], l3[2], l3[3]], [l3[4], l3[5], l3[6], l3[7]], - [l4[0], l4[1], l4[2], l4[3]], [l4[4], l4[5], l4[6], l4[7]], - [l5[0], l5[1], l5[2], l5[3]], [l5[4], l5[5], l5[6], l5[7]], - [l6[0], l6[1], l6[2], l6[3]], [l6[4], l6[5], l6[6], l6[7]], - [l7[0], l7[1], l7[2], l7[3]], [l7[4], l7[5], l7[6], l7[7]]]; - let empty = match load(c8) { - ListNode.Nil => match load(r8) { ListNode.Nil => 1, _ => 0, }, - _ => 0, - }; - let at15 = eq_zero(block_no - 15); - let start_flag = eq_zero(block_no); - let end_flag = empty + at15 - (empty * at15); - let root_flag = empty * u64_is_zero(load(chunk_count)); - let flags = start_flag + 2 * end_flag + 8 * root_flag; - let digest = @blake3_compress_init(load(cv), block, load(chunk_count), nbytes, flags); - match (empty, at15) { - (1, _) => store(LayerNode.Push(layer, digest)), - (_, 1) => - let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]]; - b3_rows_chunks(c8, r8, 0, store(relaxed_u64_succ(load(chunk_count))), store(IV), store(LayerNode.Push(layer, digest))), - (_, _) => b3_rows_chunks(c8, r8, block_no + 1, chunk_count, store(digest), layer), - }, - } - } - - fn b3_rows(rows: List‹List‹U64››) -> [[U8; 4]; 8] { - let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]]; - blake3_compress_layer(b3_rows_chunks(store(ListNode.Nil), rows, 0, store([0u8; 8]), store(IV), store(LayerNode.Nil))) - } - - -- The joint Blake3 leaf hash of all matrices at log-height `target`. - fn leaf_hash_at(rows: List‹List‹U64››, lhs: List‹G›, target: G) -> DigestP { - store(@b3_to_digest(@b3_rows(select_rows(rows, lhs, target)))) - } - - -- Inject the leaf hash of any matrices at log-height `lh` (if present) via a - -- second compression onto `d`. - fn inject_maybe(rows: List‹List‹U64››, lhs: List‹G›, lh: G, d: DigestP) -> DigestP { - match has_height(lhs, lh) { - 0 => d, - _ => mmcs_compress(d, leaf_hash_at(rows, lhs, lh)), - } - } - - -- Recompose remaining path bits (LSB first) into the cap index. - fn bits_to_num(bits: List‹G›) -> G { - match load(bits) { - ListNode.Nil => 0, - ListNode.Cons(b, rest) => b + 2 * bits_to_num(rest), - } - } - - -- Walk the authentication path: one proof sibling per level (fold), with a - -- possible leaf injection at the new log-height `lh`. Returns the recomputed - -- root and the leftover cap index. - fn mmcs_fold(d: DigestP, rows: List‹List‹U64››, lhs: List‹G›, - proof: List‹DigestP›, ibits: List‹G›, lh: G) -> (DigestP, G) { - match load(proof) { - ListNode.Nil => (d, bits_to_num(ibits)), - ListNode.Cons(s, prest) => - let &ListNode.Cons(bit, brest) = ibits; - let d1 = @compress_ordered(bit, d, s); - let d2 = @inject_maybe(rows, lhs, lh, d1); - mmcs_fold(d2, rows, lhs, prest, brest, lh - 1), - } - } - - -- Recompute the Merkle root from the opened rows + authentication path. - fn mmcs_root(rows: List‹List‹U64››, lhs: List‹G›, ibits: List‹G›, - proof: List‹DigestP›, log_max: G) -> (DigestP, G) { - let leaf = leaf_hash_at(rows, lhs, log_max); - mmcs_fold(leaf, rows, lhs, proof, ibits, log_max - 1) - } - - -- 1 iff the recomputed root matches the commitment cap at the cap index. - -- Compared BY POINTER: `store` is content-addressed (the executor keys - -- memory by value) so equal digests land on the same pointer, and the - -- memory argument binds one pointer to one value, so equal pointers imply - -- equal digests — no 2x32-column load. (Same pattern as the IxVM kernel's - -- address equality.) - fn mmcs_verify(cap: MerkleCap, rows: List‹List‹U64››, lhs: List‹G›, - ibits: List‹G›, proof: List‹DigestP›, log_max: G) -> G { - let (root, capidx) = @mmcs_root(rows, lhs, ibits, proof, log_max); - eq_zero(ptr_val(list_lookup(cap, capidx)) - ptr_val(root)) - } - - -- A node in the sorted multiproof frontier. Rows are retained from the - -- lead query so shorter matrices can be injected at their native height. - enum FrontierNode { Mk(G, List‹G›, List‹List‹U64››, DigestP) } - - fn frontier_merge(xs: List‹FrontierNode›, ys: List‹FrontierNode›) -> List‹FrontierNode› { - match load(xs) { - ListNode.Nil => ys, - ListNode.Cons(x, xrest) => match load(ys) { - ListNode.Nil => xs, - ListNode.Cons(y, yrest) => - let FrontierNode.Mk(xi, _xb, xr, xd) = x; - let FrontierNode.Mk(yi, _yb, yr, yd) = y; - match memo_u32_less_than(xi, yi) { - 1 => store(ListNode.Cons(x, frontier_merge(xrest, ys))), - _ => match eq_zero(xi - yi) { - 1 => - -- Duplicate transcript queries (same index) must open the - -- SAME full opened rows, not merely the same tallest-matrix - -- leaf digest: their shorter-matrix rows share a reduced index - -- too and both feed the FRI arithmetic (Plonky3 - -- `verify_batch_pruned`'s `InconsistentDuplicateOpenings`). - -- Pointer equality is admissible inside `assert_eq!`. - assert_eq!(ptr_val(xd), ptr_val(yd)); - assert_eq!(ptr_val(xr), ptr_val(yr)); - store(ListNode.Cons(x, frontier_merge(xrest, yrest))), - _ => store(ListNode.Cons(y, frontier_merge(xs, yrest))), - }, - }, - }, - } - } - - -- Deal alternating elements into two half-sized lists. Their internal order - -- is irrelevant because each half is recursively sorted before merging. - fn frontier_split(xs: List‹FrontierNode›) -> (List‹FrontierNode›, List‹FrontierNode›) { - match load(xs) { - ListNode.Nil => (store(ListNode.Nil), store(ListNode.Nil)), - ListNode.Cons(x, rest) => match load(rest) { - ListNode.Nil => (store(ListNode.Cons(x, store(ListNode.Nil))), store(ListNode.Nil)), - ListNode.Cons(y, tail) => - let (left, right) = frontier_split(tail); - (store(ListNode.Cons(x, left)), store(ListNode.Cons(y, right))), - }, - } - } - - fn frontier_sort(xs: List‹FrontierNode›) -> List‹FrontierNode› { - match load(xs) { - ListNode.Nil => xs, - ListNode.Cons(_x, rest) => match load(rest) { - ListNode.Nil => xs, - ListNode.Cons(_y, _tail) => - let (left, right) = frontier_split(xs); - frontier_merge(frontier_sort(left), frontier_sort(right)), - }, - } - } - - fn frontier_leaves(indices: List‹List‹G››, rows: List‹List‹List‹U64›››, - lhs: List‹G›, log_max: G) -> List‹FrontierNode› { - match load(indices) { - ListNode.Nil => - assert_eq!(list_length(rows), 0); - store(ListNode.Nil), - ListNode.Cons(bits, irest) => - let &ListNode.Cons(r, rrest) = rows; - let d = leaf_hash_at(r, lhs, log_max); - store(ListNode.Cons(FrontierNode.Mk(bits_to_num(bits), bits, r, d), - frontier_leaves(irest, rrest, lhs, log_max))), - } - } - - -- Fold one binary frontier level. Boundary siblings are consumed in the - -- exact ascending-parent/ascending-child order used by Plonky3 pruning. - fn frontier_level(nodes: List‹FrontierNode›, proof: List‹DigestP›, - lhs: List‹G›, next_lh: G) -> (List‹FrontierNode›, List‹DigestP›) { - match load(nodes) { - ListNode.Nil => (store(ListNode.Nil), proof), - ListNode.Cons(a, rest) => - let FrontierNode.Mk(ai, abits, ar, ad) = a; - let &ListNode.Cons(abit, aparent_bits) = abits; - let aparent = bits_to_num(aparent_bits); - match load(rest) { - ListNode.Cons(b, brest) => - let FrontierNode.Mk(bi, bbits, br, bd) = b; - let &ListNode.Cons(_bbit, bparent_bits) = bbits; - match eq_zero(aparent - bits_to_num(bparent_bits)) { - 1 => - -- Group members sharing a parent are collapsed to the lead - -- `a`; only `ar` is injected from here up, so `b` must agree - -- with `a` on every not-yet-injected (height <= next_lh) - -- matrix. Otherwise `b`'s shorter-matrix opened rows, still - -- consumed in its own FRI arithmetic, would go unauthenticated - -- (Plonky3 `verify_batch_pruned`'s `InconsistentGroupOpening`; - -- pointer equality is admissible inside `assert_eq!` — see - -- `Aiur.Library.Core`). Transitive across pairwise merges, so the whole - -- group is pinned. - assert_eq!(ptr_val(select_rows_le(ar, lhs, next_lh)), - ptr_val(select_rows_le(br, lhs, next_lh))); - let parent = inject_maybe(ar, lhs, next_lh, mmcs_compress(ad, bd)); - let (tail, p2) = frontier_level(brest, proof, lhs, next_lh); - (store(ListNode.Cons(FrontierNode.Mk(aparent, aparent_bits, ar, parent), tail)), p2), - _ => - let &ListNode.Cons(sib, prest) = proof; - let parent = inject_maybe(ar, lhs, next_lh, compress_ordered(abit, ad, sib)); - let (tail, p2) = frontier_level(rest, prest, lhs, next_lh); - (store(ListNode.Cons(FrontierNode.Mk(aparent, aparent_bits, ar, parent), tail)), p2), - }, - ListNode.Nil => - let &ListNode.Cons(sib, prest) = proof; - let parent = inject_maybe(ar, lhs, next_lh, compress_ordered(abit, ad, sib)); - (store(ListNode.Cons(FrontierNode.Mk(aparent, aparent_bits, ar, parent), store(ListNode.Nil))), prest), - }, - } - } - - fn frontier_fold(nodes: List‹FrontierNode›, proof: List‹DigestP›, - lhs: List‹G›, levels: G) -> (List‹FrontierNode›, List‹DigestP›) { - match levels { - 0 => (nodes, proof), - _ => - let (next, p2) = frontier_level(nodes, proof, lhs, levels - 1); - frontier_fold(next, p2, lhs, levels - 1), - } - } - - fn mmcs_verify_multi(cap: MerkleCap, rows: List‹List‹List‹U64›››, - lhs: List‹G›, indices: List‹List‹G››, proof: List‹DigestP›, log_max: G) -> G { - assert_eq!(eq_zero(list_length(rows) - list_length(indices)), 1); - let leaves = frontier_sort(frontier_leaves(indices, rows, lhs, log_max)); - let (roots, rest) = frontier_fold(leaves, proof, lhs, log_max); - assert_eq!(list_length(rest), 0); - let &ListNode.Cons(root, no_more) = roots; - assert_eq!(list_length(no_more), 0); - let FrontierNode.Mk(capidx, _bits, _rows, digest) = root; - eq_zero(ptr_val(list_lookup(cap, capidx)) - ptr_val(digest)) - } - - -- ========================================================================== - -- FRI fold step (`TwoAdicFriFolding::fold_row`, arity-2 case). - -- - -- `innerFri` uses `maxLogArity = 1`, so every FRI fold is binary. Ports - -- `fold_row` for `log_arity = 1`: given the sibling pair (e0, e1) of a node - -- and the round challenge β, - -- folded = (e0 + e1)/2 + β·(e0 − e1)/(2s), - -- s = g_{log_height+1}^{reverse_bits_len(index, log_height)} (base field) - -- where `g_k = two_adic_gen(k)`. The index is threaded as its low-`log_height` - -- bit list (LSB first), matching `ch_sample_bits`; `reverse_bits_len` is then - -- just reversing that list. - -- ========================================================================== - - -- Reverse a `G` (bit) list onto `acc`. - fn glist_rev(l: List‹G›, acc: List‹G›) -> List‹G› { - match load(l) { - ListNode.Nil => acc, - ListNode.Cons(b, rest) => glist_rev(rest, store(ListNode.Cons(b, acc))), - } - } - - -- base^(Σ bits_i · 2^i), bits LSB-first (square-and-multiply over the bits). - -- `base` is a native Goldilocks element; `bits` is a native bit list. - fn exp_by_bits(base: Goldilocks, bits: List‹G›) -> Goldilocks { - match load(bits) { - ListNode.Nil => 1, - ListNode.Cons(b, rest) => - let half = exp_by_bits(base * base, rest); - match b { - 0 => half, - _ => base * half, - }, - } - } - - -- The arity-2 FRI fold. `index_bits` = the low `log_height` index bits, LSB - -- first (so `reverse_bits_len` = reversing the list). - fn fri_fold2(index_bits: List‹G›, log_height: G, beta: Ext, e0: Ext, e1: Ext) -> Ext { - let g = two_adic_gen(log_height + 1); - let s = exp_by_bits(g, glist_rev(index_bits, store(ListNode.Nil))); - let two_s = s + s; - let t1 = @eg_div(@eg_add(e0, e1), [2, 0]); - let t2 = @eg_mul(beta, @eg_div(@eg_sub(e0, e1), [two_s, 0])); - @eg_add(t1, t2) - } - - -- ========================================================================== - -- `open_input` reduced openings (`fri/verifier.rs::open_input` inner loop). - -- - -- For a matrix opened at a point z with verifier domain point x, accumulate - -- over the matrix columns: - -- ro += alpha_pow · (p_z − p_x) · q ; alpha_pow *= alpha, q = 1/(z − x) - -- where p_x are the INPUT opened base values (from the query's batch opening, - -- authenticated by the input MMCS) and p_z the OOD opened ext values. The - -- query domain point is - -- x = GENERATOR(7) · two_adic_gen(log_height)^{reverse_bits_len(idx, log_height)}. - -- All extension arithmetic — no Merkle hashing here. - -- ========================================================================== - - -- The base-field query domain point x. `index_bits` = low-`log_height` index - -- bits, LSB first (so reverse_bits_len = reversing the list). - fn ro_x(index_bits: List‹G›, log_height: G) -> Goldilocks { - 7 * exp_by_bits(two_adic_gen(log_height), glist_rev(index_bits, store(ListNode.Nil))) - } - - -- Accumulate one matrix-point's column contributions WITHOUT the quotient - -- factor: `s = Σᵢ apᵢ·(p_zᵢ − p_xᵢ)`. The caller multiplies by - -- `q = 1/(z − x)` once per matrix-point (it is constant across the - -- point's columns), saving an ext mul per column. `p_x` is the RAW wire - -- lane list — `limb_to_field` reduces mod p as pure wiring, so no - -- intermediate `List‹Goldilocks›` is ever materialized (the former - -- `lanes_to_gl` pass and its per-lane stores/loads). - -- Both rows must end together: a short p_z fails the Cons match, and a - -- long p_z fails the Nil check. This also checks their widths in the - -- existing fold, without separate list-length traversals per query row. - fn ro_fold(p_x: List‹U64›, p_z: List‹Ext›, alpha: Ext, s: Ext, ap: Ext) - -> (Ext, Ext) { - match load(p_x) { - ListNode.Nil => - let &ListNode.Nil = p_z; - (s, ap), - ListNode.Cons(lane, pxr) => - let &ListNode.Cons(pz, pzr) = p_z; - let term = @eg_mul(ap, @eg_sub(pz, [@limb_to_field(lane), 0])); - ro_fold(pxr, pzr, alpha, @eg_add(s, term), @eg_mul(ap, alpha)), - } - } - - -- ========================================================================== - -- PCS (FRI) verification — `two_adic_pcs::verify` + `fri::verify_fri`. - -- - -- Specialised to our system: arity 2 (log_arity = 1 every round) and - -- log_final_poly_len = 0 (final_poly is ONE constant coefficient ⇒ the final - -- Horner eval is just `final_poly[0]`, no `x` needed). The variable FRI - -- parameters (log_blowup, num_queries, commit/query PoW bits) come in as - -- arguments. Field arithmetic is the non-native byte Goldilocks - -- (`gl_*`/`eg_*`). - -- - -- A reduced-opening accumulator, one per distinct log-height. `alpha_pow` - -- threads across every (batch, matrix, point, column) at that height, in the - -- prover's observation order (stage_1, stage_2, quotient, preprocessed). - -- ========================================================================== - enum Bucket { Mk(G, Ext, Ext) } -- log_height, alpha_pow, reduced_opening - - -- ── challenger: observe the opened values (observe_algebra_slice) ────────── - -- Built with the PREPEND helpers (`b8_onto` composition, O(1) per element), - -- front-to-back, so the whole observation batch costs one `list_concat` at - -- the end. Appending item-by-item onto the accumulated input (`snoc_b8`) - -- re-walks and rebuilds the entire buffer per observation — quadratic in - -- transcript size; at kernel scale the opened-values batch alone made that - -- billions of memory records. - -- One ext element = its two base coordinates, each 8 LE bytes. - fn ext_row_onto(row: List‹Ext›, tail: ByteStream) -> ByteStream { - match load(row) { - ListNode.Nil => tail, - ListNode.Cons(e, rest) => b8_onto(@gl_to_bytes(e[0]), b8_onto(@gl_to_bytes(e[1]), ext_row_onto(rest, tail))), - } - } - fn points_onto(pts: List‹List‹Ext››, tail: ByteStream) -> ByteStream { - match load(pts) { - ListNode.Nil => tail, - ListNode.Cons(row, rest) => ext_row_onto(row, points_onto(rest, tail)), - } - } - fn round_onto(round: OpenedRound, tail: ByteStream) -> ByteStream { - match load(round) { - ListNode.Nil => tail, - ListNode.Cons(mat, rest) => points_onto(mat, round_onto(rest, tail)), - } - } - fn prep_onto(prep_opt: PreprocessedOpt, tail: ByteStream) -> ByteStream { - match prep_opt { - PreprocessedOpt.NoPreprocessed => tail, - PreprocessedOpt.SomePreprocessed(round) => round_onto(round, tail), - } - } - -- Observe one Val (= 1) per FRI round, the variable-arity schedule. - fn obs_log_arities(input: ByteStream, comms: List‹MerkleCap›) -> ByteStream { - match load(comms) { - ListNode.Nil => input, - ListNode.Cons(_c, rest) => - obs_log_arities(snoc_b8(input, [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), rest), - } - } - -- `GrindingChallenger::check_witness`, shared by the commit-phase (per-round) - -- and query-phase grinding checks: when `bits > 0`, observe the PoW witness - -- then sample `bits` bits and assert they are all zero (else - -- InvalidPowWitness). Returns the post-PoW `(input, output)` so the - -- immediately-following sample (β / query index) continues the SAME hash - -- stream (no observe in between). `bits == 0` is the short-circuit: no - -- observe, no sample. - fn pcs_check_witness(input: ByteStream, witness: U64, bits: G) -> (ByteStream, ByteStream) { - match bits { - 0 => (input, store(ListNode.Nil)), - _ => - let (pbits, i1, o1) = ch_sample_bits(snoc_b8(input, witness), store(ListNode.Nil), bits); - assert_eq!(bits_to_num(pbits), 0); - (i1, o1), - } - } - -- Per round: observe the commitment, run the commit-phase PoW check, then - -- sample the folding challenge β (continuing the challenger past the PoW). - fn pcs_betas(input: ByteStream, comms: List‹MerkleCap›, witnesses: List‹U64›, bits: G) - -> (List‹Ext›, ByteStream) { - match load(comms) { - ListNode.Nil => (store(ListNode.Nil), input), - ListNode.Cons(c, rest) => - let &ListNode.Cons(w, wrest) = witnesses; - let (i1, o1) = pcs_check_witness(snoc_cap(input, c), w, bits); - let (b0, b1, i2, _o) = ch_sample_ext(i1, o1); - let (bs, i3) = pcs_betas(i2, rest, wrest, bits); - (store(ListNode.Cons([@gl_val(b0), @gl_val(b1)], bs)), i3), - } - } - - -- ── reduced-opening buckets ─────────────────────────────────────────────── - -- 1 iff some circuit `i < rem` has log-height `log_degrees[i] + log_blowup == h`. - fn circ_has_height(log_degrees: List‹U8›, log_blowup: G, rem: G, i: G, h: G) -> G { - match rem { - 0 => 0, - _ => match eq_zero(to_field(list_lookup(log_degrees, i)) + log_blowup - h) { - 1 => 1, - _ => circ_has_height(log_degrees, log_blowup, rem - 1, i + 1, h), - }, - } - } - -- One bucket per distinct log-height, built DESCENDING by counting `h` down - -- from `log_global_max`. Each starts (alpha_pow = 1, reduced_opening = 0). - fn build_buckets(log_degrees: List‹U8›, log_blowup: G, num_circuits: G, h: G) -> List‹Bucket› { - match h { - 0 => store(ListNode.Nil), - _ => match circ_has_height(log_degrees, log_blowup, num_circuits, 0, h) { - 0 => build_buckets(log_degrees, log_blowup, num_circuits, h - 1), - _ => store(ListNode.Cons( - Bucket.Mk(h, [1, 0], [0, 0]), - build_buckets(log_degrees, log_blowup, num_circuits, h - 1))), - }, - } - } - -- Find the bucket at log-height `lh`, fold one matrix-point's columns into it - -- (`ro_fold` threads its `alpha_pow`), and write it back. - fn bucket_update(buckets: List‹Bucket›, lh: G, p_x: List‹U64›, p_z: List‹Ext›, - q: Ext, alpha: Ext) -> List‹Bucket› { - match load(buckets) { - ListNode.Nil => - -- A missing bucket does not run ro_fold. Keep the original width - -- check on this defensive path as well. - assert_eq!(eq_zero(list_length(p_x) - list_length(p_z)), 1); - store(ListNode.Nil), - ListNode.Cons(b, rest) => - let Bucket.Mk(h, ap, ro) = b; - match eq_zero(h - lh) { - 1 => - let (s, ap2) = ro_fold(p_x, p_z, alpha, [0, 0], ap); - let ro2 = @eg_add(ro, @eg_mul(q, s)); - store(ListNode.Cons(Bucket.Mk(h, ap2, ro2), rest)), - _ => store(ListNode.Cons(b, bucket_update(rest, lh, p_x, p_z, q, alpha))), - }, - } - } - -- A bucket at log-height `log_blowup` would come from a trace matrix of height - -- 1 (a constant polynomial); then `(f(ζ) − f(x))/(ζ − x)` must be 0. Assert it - -- (`open_input`'s `FinalPolyMismatch` guard). No-op if no such bucket exists. - fn assert_blowup_zero(buckets: List‹Bucket›, log_blowup: G) -> G { - match load(buckets) { - ListNode.Nil => 1, - ListNode.Cons(b, rest) => - let Bucket.Mk(h, _ap, ro) = b; - match eq_zero(h - log_blowup) { - 1 => assert_eq!(@eg_eq(ro, [0, 0]), 1); 1, - _ => assert_blowup_zero(rest, log_blowup), - }, - } - } - -- 1 iff the proof carries a preprocessed opened round (used for the input-proof - -- batch-count check). - fn prep_count(prep_opt: PreprocessedOpt) -> G { - match prep_opt { - PreprocessedOpt.NoPreprocessed => 0, - PreprocessedOpt.SomePreprocessed(_r) => 1, - } - } - -- Compute x = GENERATOR·g^{revbits} for this height and fold the contribution. - fn ri_apply(buckets: List‹Bucket›, lh: G, idxbits: List‹G›, log_gmax: G, - z: Ext, p_x: List‹U64›, p_z: List‹Ext›, alpha: Ext) -> List‹Bucket› { - -- Equal widths (PointEvaluationCountMismatch) are checked while ro_fold - -- consumes both rows; bucket_update retains the check on a bucket miss. - let x = @ro_x(list_drop(idxbits, log_gmax - lh), lh); - let q = @eg_inverse(@eg_sub(z, [x, 0])); - bucket_update(buckets, lh, p_x, p_z, q, alpha) - } - - -- A stage_1/stage_2/preprocessed-style matrix: two opening points - -- (ζ, ζ·g) with the same base row `p_x`. `g` = trace subgroup generator. - fn open_2pt_mat(buckets: List‹Bucket›, idxbits: List‹G›, log_gmax: G, lh: G, - ldeg: G, zeta: Ext, p_x: List‹U64›, mat: List‹List‹Ext››, alpha: Ext) - -> List‹Bucket› { - let pz0 = list_lookup(mat, 0); - let pz1 = list_lookup(mat, 1); - let zn = @eg_mul(zeta, [two_adic_gen(ldeg), 0]); - let b1 = ri_apply(buckets, lh, idxbits, log_gmax, zeta, p_x, pz0, alpha); - ri_apply(b1, lh, idxbits, log_gmax, zn, p_x, pz1, alpha) - } - fn open_batch_2pt(buckets: List‹Bucket›, idxbits: List‹G›, log_gmax: G, log_blowup: G, ci: G, - rem: G, log_degrees: List‹U8›, zeta: Ext, base_rows: List‹List‹U64››, - opened: OpenedRound, alpha: Ext) -> List‹Bucket› { - match rem { - 0 => buckets, - _ => - let ldeg = to_field(list_lookup(log_degrees, ci)); - let b = open_2pt_mat(buckets, idxbits, log_gmax, ldeg + log_blowup, ldeg, zeta, - list_lookup(base_rows, ci), list_lookup(opened, ci), alpha); - open_batch_2pt(b, idxbits, log_gmax, log_blowup, ci + 1, rem - 1, log_degrees, zeta, - base_rows, opened, alpha), - } - } - - -- The quotient batch: ONE wide matrix per circuit (all its coefficient - -- slices), on the trace domain, opened at the single point ζ. - fn open_quotient(buckets: List‹Bucket›, idxbits: List‹G›, log_gmax: G, log_blowup: G, ci: G, - rem: G, log_degrees: List‹U8›, zeta: Ext, - base_rows: List‹List‹U64››, q_opened: OpenedRound, alpha: Ext) -> List‹Bucket› { - match rem { - 0 => buckets, - _ => - let lh = to_field(list_lookup(log_degrees, ci)) + log_blowup; - let b = ri_apply(buckets, lh, idxbits, log_gmax, zeta, - list_lookup(base_rows, ci), list_lookup(list_lookup(q_opened, ci), 0), alpha); - open_quotient(b, idxbits, log_gmax, log_blowup, ci + 1, rem - 1, log_degrees, zeta, base_rows, q_opened, alpha), - } - } - - -- The preprocessed batch: only circuits with `prep_indices[i] = Some(j)`; - -- `k` tracks the position in the preprocessed commitment (= base-row index). - fn open_prep(buckets: List‹Bucket›, idxbits: List‹G›, log_gmax: G, log_blowup: G, ci: G, rem: G, - k: G, log_degrees: List‹U8›, prep_indices: List‹OptIdx›, zeta: Ext, - base_rows: List‹List‹U64››, prep_round: OpenedRound, alpha: Ext) -> List‹Bucket› { - match rem { - 0 => buckets, - _ => match list_lookup(prep_indices, ci) { - OptIdx.NoIdx => - open_prep(buckets, idxbits, log_gmax, log_blowup, ci + 1, rem - 1, k, log_degrees, - prep_indices, zeta, base_rows, prep_round, alpha), - OptIdx.SomeIdx(_j) => - let ldeg = to_field(list_lookup(log_degrees, ci)); - let b = open_2pt_mat(buckets, idxbits, log_gmax, ldeg + log_blowup, ldeg, zeta, - list_lookup(base_rows, k), list_lookup(prep_round, k), alpha); - open_prep(b, idxbits, log_gmax, log_blowup, ci + 1, rem - 1, k + 1, log_degrees, - prep_indices, zeta, base_rows, prep_round, alpha), - }, - } - } - fn open_prep_batch(buckets: List‹Bucket›, input_proof: List‹BatchOpening›, - prep_commit: MerkleCap, prep_opt: PreprocessedOpt, prep_indices: List‹OptIdx›, - log_degrees: List‹U8›, num_circuits: G, idxbits: List‹G›, log_gmax: G, log_blowup: G, - zeta: Ext, alpha: Ext) -> List‹Bucket› { - match prep_opt { - PreprocessedOpt.NoPreprocessed => buckets, - PreprocessedOpt.SomePreprocessed(prep_round) => - let BatchOpening.Mk(rows_p) = list_lookup(input_proof, 3); - -- one opened base row per preprocessed matrix (BatchOpenedValuesCountMismatch) - assert_eq!(eq_zero(list_length(rows_p) - list_length(prep_round)), 1); - -- The preprocessed tree's max height is over the PREP circuits only, so - -- it can be SHORTER than the global max when the tallest circuits carry - -- no preprocessed matrix. Mirror Plonky3's per-batch index reduction - -- (`index >> (log_global_max - log_batch_max)` — dropping the low bits - -- of the LSB-first bit list) and verify against the batch's own height. - let prep_heights = heights_prep(log_degrees, log_blowup, prep_indices, num_circuits, 0); - let log_pmax = heights_max(prep_heights); - open_prep(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, 0, log_degrees, - prep_indices, zeta, rows_p, prep_round, alpha), - } - } - - -- ── per-batch input-MMCS matrix log-heights (`log_degree + log_blowup`) ──── - fn heights_all(log_degrees: List‹U8›, log_blowup: G, rem: G, i: G) -> List‹G› { - match rem { - 0 => store(ListNode.Nil), - _ => store(ListNode.Cons(to_field(list_lookup(log_degrees, i)) + log_blowup, - heights_all(log_degrees, log_blowup, rem - 1, i + 1))), - } - } - -- Max of a height list (0 when empty): Plonky3's - -- `batch_heights.iter().max().unwrap_or(0)` for the per-batch index reduction. - fn heights_max(hs: List‹G›) -> G { - match load(hs) { - ListNode.Nil => 0, - ListNode.Cons(h, rest) => - let m = heights_max(rest); - match u32_less_than(m, h) { - 0 => m, - _ => h, - }, - } - } - fn heights_prep(log_degrees: List‹U8›, log_blowup: G, prep_indices: List‹OptIdx›, rem: G, i: G) -> List‹G› { - match rem { - 0 => store(ListNode.Nil), - _ => match list_lookup(prep_indices, i) { - OptIdx.NoIdx => heights_prep(log_degrees, log_blowup, prep_indices, rem - 1, i + 1), - OptIdx.SomeIdx(_j) => - store(ListNode.Cons(to_field(list_lookup(log_degrees, i)) + log_blowup, - heights_prep(log_degrees, log_blowup, prep_indices, rem - 1, i + 1))), - }, - } - } - - -- ── FRI fold chain (`verify_query`, arity 2) ────────────────────────────── - -- Reconstruct the sibling pair: evals[index_in_group] = folded, other = sib. - fn recon_evals(bit: G, folded: Ext, sib: Ext) -> (Ext, Ext) { - match bit { - 0 => (folded, sib), - _ => (sib, folded), - } - } - -- Flatten two ext evals to the 4 base coords of the ExtensionMmcs leaf row. - fn flatten2(e0: Ext, e1: Ext) -> List‹U64› { - store(ListNode.Cons(@gl_to_bytes(e0[0]), store(ListNode.Cons(@gl_to_bytes(e0[1]), - store(ListNode.Cons(@gl_to_bytes(e1[0]), store(ListNode.Cons(@gl_to_bytes(e1[1]), store(ListNode.Nil))))))))) - } - -- Roll the next reduced opening into the folded eval when its height matches - -- the new folded height: `folded += beta^(2^log_arity) · ro` (log_arity = 1). - fn rollin(folded: Ext, log_folded: G, beta: Ext, ro_rest: List‹Bucket›) -> (Ext, List‹Bucket›) { - match load(ro_rest) { - ListNode.Nil => (folded, ro_rest), - ListNode.Cons(b, rest) => - let Bucket.Mk(h, _ap, ro) = b; - match eq_zero(h - log_folded) { - 1 => (@eg_add(folded, @eg_mul(ext_exp_pow2(beta, 1), ro)), rest), - _ => (folded, ro_rest), - }, - } - } - fn verify_query(folded: Ext, betas: List‹Ext›, comms: List‹MerkleCap›, - openings: List‹CommitPhaseProofStep›, domidx: List‹G›, log_cur: G, - ro_rest: List‹Bucket›, log_final: G) -> (Ext, List‹List‹U64››) { - match load(openings) { - ListNode.Nil => - -- must have folded down to exactly the final domain size, and every - -- reduced opening must have been rolled in (FinalFoldHeightMismatch / - -- UnconsumedReducedOpenings). - assert_eq!(eq_zero(log_cur - log_final), 1); - assert_eq!(list_length(ro_rest), 0); - (folded, store(ListNode.Nil)), - ListNode.Cons(op, op_rest) => - let &ListNode.Cons(beta, beta_rest) = betas; - let &ListNode.Cons(comm, comm_rest) = comms; - let CommitPhaseProofStep.Mk(_la, sibs) = op; - -- arity 2 ⇒ exactly arity-1 = 1 sibling (SiblingValuesLengthMismatch). - assert_eq!(list_length(sibs), 1); - let &ListNode.Cons(ibit, idrest) = domidx; -- index_in_group = LSB - let log_folded = log_cur - 1; - let (e0, e1) = @recon_evals(ibit, folded, list_lookup(sibs, 0)); - let folded1 = fri_fold2(idrest, log_folded, beta, e0, e1); - let (folded2, ro_rest2) = rollin(folded1, log_folded, beta, ro_rest); - let (result, rows) = verify_query(folded2, beta_rest, comm_rest, op_rest, idrest, log_folded, ro_rest2, log_final); - (result, store(ListNode.Cons(@flatten2(e0, e1), rows))), - } - } - - -- ── one FRI query ───────────────────────────────────────────────────────── - -- For the query index `idxbits`: build the reduced-opening accumulators, - -- authenticate each input batch (input MMCS), run the fold chain, and check - -- the final polynomial. `log_final = log_blowup` (log_final_poly_len = 0). - fn verify_one_query(idxbits: List‹G›, qp: QueryProof, alpha: Ext, - stage1: OpenedRound, stage2: OpenedRound, q_opened: OpenedRound, - prep_opt: PreprocessedOpt, s1c: MerkleCap, s2c: MerkleCap, qc: MerkleCap, - prep_commit: MerkleCap, prep_indices: List‹OptIdx›, - log_degrees: List‹U8›, zeta: Ext, num_circuits: G, log_blowup: G, log_gmax: G, - betas: List‹Ext›, commit_phase_commits: List‹MerkleCap›, final_poly: List‹Ext›, - num_rounds: G) -> List‹List‹U64›› { - let QueryProof.Mk(input_proof, commit_phase_openings) = qp; - -- one commit-phase opening per round (QueryCommitPhaseOpeningsCountMismatch), - -- one input batch per commitment (InputProofBatchCountMismatch). - assert_eq!(eq_zero(list_length(commit_phase_openings) - num_rounds), 1); - assert_eq!(eq_zero(list_length(input_proof) - (3 + prep_count(prep_opt))), 1); - let buckets = build_buckets(log_degrees, log_blowup, num_circuits, log_gmax); - -- one heights list for all three stage batches (memoized anyway; this - -- also drops two call-output columns per proof) - let hall = heights_all(log_degrees, log_blowup, num_circuits, 0); - let BatchOpening.Mk(rows_s1) = list_lookup(input_proof, 0); - assert_eq!(eq_zero(list_length(rows_s1) - num_circuits), 1); - let buckets = open_batch_2pt(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, log_degrees, zeta, rows_s1, stage1, alpha); - let BatchOpening.Mk(rows_s2) = list_lookup(input_proof, 1); - assert_eq!(eq_zero(list_length(rows_s2) - num_circuits), 1); - let buckets = open_batch_2pt(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, log_degrees, zeta, rows_s2, stage2, alpha); - let BatchOpening.Mk(rows_q) = list_lookup(input_proof, 2); - -- one wide quotient matrix per circuit, on the trace domain, so the - -- quotient batch's heights are the same per-circuit heights as the stages - assert_eq!(eq_zero(list_length(rows_q) - num_circuits), 1); - let buckets = open_quotient(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, log_degrees, zeta, rows_q, q_opened, alpha); - let buckets = open_prep_batch(buckets, input_proof, prep_commit, prep_opt, prep_indices, log_degrees, num_circuits, idxbits, log_gmax, log_blowup, zeta, alpha); - -- a height-`log_blowup` (constant-poly) reduced opening must be zero - let _cz = assert_blowup_zero(buckets, log_blowup); - -- the first reduced opening must sit at log_global_max_height - -- (InitialReducedOpeningHeightMismatch). - let &ListNode.Cons(b0, ro_rest) = buckets; - let Bucket.Mk(h0, _ap0, folded_start) = b0; - assert_eq!(eq_zero(h0 - log_gmax), 1); - let (folded, fri_rows) = verify_query(folded_start, betas, commit_phase_commits, commit_phase_openings, idxbits, log_gmax, ro_rest, log_blowup); - -- final check: with log_final_poly_len = 0, eval = final_poly[0] - assert_eq!(@eg_eq(list_lookup(final_poly, 0), folded), 1); - fri_rows - } - - -- Loop over all `num_queries` query proofs, sampling one index per query - -- (consecutive `sample_bits` continue the same challenger stream). - fn query_loop(input: ByteStream, output: ByteStream, query_proofs: List‹QueryProof›, - alpha: Ext, stage1: OpenedRound, stage2: OpenedRound, q_opened: OpenedRound, - prep_opt: PreprocessedOpt, s1c: MerkleCap, s2c: MerkleCap, qc: MerkleCap, - prep_commit: MerkleCap, prep_indices: List‹OptIdx›, - log_degrees: List‹U8›, zeta: Ext, num_circuits: G, log_blowup: G, log_gmax: G, - betas: List‹Ext›, commit_phase_commits: List‹MerkleCap›, final_poly: List‹Ext›, - num_rounds: G) -> List‹List‹List‹U64››› { - match load(query_proofs) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(qp, rest) => - let (idxbits, input2, output2) = ch_sample_bits(input, output, log_gmax); - let qrows = verify_one_query(idxbits, qp, alpha, stage1, stage2, q_opened, prep_opt, - s1c, s2c, qc, prep_commit, prep_indices, log_degrees, zeta, num_circuits, - log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds); - store(ListNode.Cons(qrows, query_loop(input2, output2, rest, alpha, stage1, stage2, q_opened, prep_opt, - s1c, s2c, qc, prep_commit, prep_indices, log_degrees, zeta, num_circuits, - log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds))), - } - } - - fn sample_query_indices(input: ByteStream, output: ByteStream, n: G, - log_gmax: G) -> List‹List‹G›› { - match n { - 0 => store(ListNode.Nil), - _ => - let (bits, input2, output2) = ch_sample_bits(input, output, log_gmax); - store(ListNode.Cons(bits, sample_query_indices(input2, output2, n - 1, log_gmax))), - } - } - - fn batch_views_at(bs: List‹BatchMultiOpening›, q: G) -> List‹BatchOpening› { - match load(bs) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(b, rest) => - let BatchMultiOpening.Mk(rows, _proof) = b; - store(ListNode.Cons(BatchOpening.Mk(list_lookup(rows, q)), batch_views_at(rest, q))), - } - } - fn step_views_at(ss: List‹CommitPhaseMultiStep›, q: G) -> List‹CommitPhaseProofStep› { - match load(ss) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(s, rest) => - let CommitPhaseMultiStep.Mk(la, sibs, _proof) = s; - store(ListNode.Cons(CommitPhaseProofStep.Mk(la, list_lookup(sibs, q)), step_views_at(rest, q))), - } - } - fn query_views(bs: List‹BatchMultiOpening›, ss: List‹CommitPhaseMultiStep›, - q: G, n: G) -> List‹QueryProof› { - match n { - 0 => store(ListNode.Nil), - _ => store(ListNode.Cons(QueryProof.Mk(batch_views_at(bs, q), step_views_at(ss, q)), - query_views(bs, ss, q + 1, n - 1))), - } - } - - fn verify_input_multi(bs: List‹BatchMultiOpening›, indices: List‹List‹G››, - s1c: MerkleCap, s2c: MerkleCap, qc: MerkleCap, prep_commit: MerkleCap, - prep_opt: PreprocessedOpt, prep_indices: List‹OptIdx›, log_degrees: List‹U8›, - num_circuits: G, log_blowup: G, log_gmax: G) -> G { - let hall = heights_all(log_degrees, log_blowup, num_circuits, 0); - let BatchMultiOpening.Mk(s1rows, s1proof) = list_lookup(bs, 0); - let BatchMultiOpening.Mk(s2rows, s2proof) = list_lookup(bs, 1); - let BatchMultiOpening.Mk(qrows, qproof) = list_lookup(bs, 2); - assert_eq!(mmcs_verify_multi(s1c, s1rows, hall, indices, s1proof, log_gmax), 1); - assert_eq!(mmcs_verify_multi(s2c, s2rows, hall, indices, s2proof, log_gmax), 1); - assert_eq!(mmcs_verify_multi(qc, qrows, hall, indices, qproof, log_gmax), 1); - match prep_opt { - PreprocessedOpt.NoPreprocessed => 1, - PreprocessedOpt.SomePreprocessed(_round) => - let BatchMultiOpening.Mk(prows, pproof) = list_lookup(bs, 3); - let ph = heights_prep(log_degrees, log_blowup, prep_indices, num_circuits, 0); - let lp = heights_max(ph); - let pindices = drop_index_bits(indices, log_gmax - lp); - mmcs_verify_multi(prep_commit, prows, ph, pindices, pproof, lp), - } - } - fn drop_index_bits(indices: List‹List‹G››, n: G) -> List‹List‹G›› { - match load(indices) { - ListNode.Nil => indices, - ListNode.Cons(bits, rest) => - store(ListNode.Cons(list_drop(bits, n), drop_index_bits(rest, n))), - } - } - fn rows_at_round(rows: List‹List‹List‹U64›››, r: G) -> List‹List‹List‹U64››› { - match load(rows) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(qrows, rest) => - store(ListNode.Cons(store(ListNode.Cons(list_lookup(qrows, r), store(ListNode.Nil))), - rows_at_round(rest, r))), - } - } - fn verify_commit_multi(steps: List‹CommitPhaseMultiStep›, comms: List‹MerkleCap›, - all_rows: List‹List‹List‹U64›››, indices: List‹List‹G››, r: G, - log_cur: G) -> G { - match load(steps) { - ListNode.Nil => eq_zero(list_length(comms)), - ListNode.Cons(s, srest) => - let &ListNode.Cons(c, crest) = comms; - let CommitPhaseMultiStep.Mk(la, sibs, proof) = s; - assert_eq!(to_field(la), 1); - assert_eq!(list_length(sibs), list_length(indices)); - let next_indices = drop_index_bits(indices, 1); - let lh = log_cur - 1; - assert_eq!(mmcs_verify_multi(c, rows_at_round(all_rows, r), - store(ListNode.Cons(lh, store(ListNode.Nil))), next_indices, proof, lh), 1); - verify_commit_multi(srest, crest, all_rows, next_indices, r + 1, lh), - } - } - - -- ── top-level FRI verification ──────────────────────────────────────────── - -- All FRI parameters (`log_blowup`, `num_queries`, `commit_pow_bits`, - -- `query_pow_bits`) come from the digest-bound verifying key. - fn pcs_fri_verify(post_zeta_input: ByteStream, stage1: OpenedRound, stage2: OpenedRound, - q_opened: OpenedRound, prep_opt: PreprocessedOpt, opening: FriProof, - s1c: MerkleCap, s2c: MerkleCap, qc: MerkleCap, prep_commit: MerkleCap, - prep_indices: List‹OptIdx›, log_degrees: List‹U8›, - zeta: Ext, num_circuits: G, log_blowup: G, num_queries: G, commit_pow_bits: G, - query_pow_bits: G) -> G { - let FriProof.Mk(commit_phase_commits, pw, input_openings, commit_phase_openings, - final_poly, qpw) = opening; - let num_rounds = list_length(commit_phase_commits); - -- FRI shape: one PoW witness per round, num_queries query proofs, and (since - -- log_final_poly_len = 0) a single final-poly coefficient. - assert_eq!(eq_zero(list_length(pw) - num_rounds), 1); - assert_eq!(list_length(input_openings), 3 + prep_count(prep_opt)); - assert_eq!(eq_zero(list_length(commit_phase_openings) - num_rounds), 1); - assert_eq!(list_length(final_poly), 1); - -- challenger continuation: observe all opened values (coms_to_verify - -- order), built as one front-to-back suffix + a single concat (the input - -- is only ~32 bytes here — it collapses to the digest on every flush). - let obs = round_onto(stage1, round_onto(stage2, round_onto(q_opened, - @prep_onto(prep_opt, store(ListNode.Nil))))); - let input = list_concat(post_zeta_input, obs); - -- PCS batch-combination challenge α - let (a0, a1, input, _oa) = ch_sample_ext(input, store(ListNode.Nil)); - let alpha = [@gl_val(a0), @gl_val(a1)]; - -- per-round FRI fold challenges β (with commit-phase PoW), then observe - -- final_poly + the log-arity schedule. - let (betas, input) = pcs_betas(input, commit_phase_commits, pw, commit_pow_bits); - let input = list_concat(input, ext_row_onto(final_poly, store(ListNode.Nil))); - let input = obs_log_arities(input, commit_phase_commits); - -- query-phase grinding: check_witness over the query PoW witness, sampled - -- AFTER the log-arity schedule and BEFORE the query indices (the query - -- sampling continues the post-PoW stream). No-op when query_pow_bits == 0. - let (input, output) = pcs_check_witness(input, qpw, query_pow_bits); - -- query indices + per-query verification (log_global_max_height = #rounds + log_blowup) - let log_gmax = num_rounds + log_blowup; - -- num_rounds is proof advice (commit-phase commitment count); bound the - -- max height so `two_adic_gen`'s squaring chain (bits ≤ 32) and the - -- 32-bit query-index decomposition stay within range. - assert_eq!(u32_less_than(log_gmax, 33), 1); - let indices = sample_query_indices(input, output, num_queries, log_gmax); - assert_eq!(verify_input_multi(input_openings, indices, s1c, s2c, qc, - prep_commit, prep_opt, prep_indices, log_degrees, num_circuits, log_blowup, log_gmax), 1); - let query_proofs = query_views(input_openings, commit_phase_openings, 0, num_queries); - let fri_rows = query_loop(input, output, query_proofs, alpha, stage1, stage2, q_opened, - prep_opt, s1c, s2c, qc, prep_commit, prep_indices, log_degrees, zeta, - num_circuits, log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds); - verify_commit_multi(commit_phase_openings, commit_phase_commits, fri_rows, indices, 0, log_gmax) - } - -⟧ - -end MultiStark - -end diff --git a/MultiStark/SystemDeserialize.lean b/MultiStark/SystemDeserialize.lean deleted file mode 100644 index 88a5820d4..000000000 --- a/MultiStark/SystemDeserialize.lean +++ /dev/null @@ -1,489 +0,0 @@ -module -public import Ix.Aiur.Meta -public import Ix.Aiur.Library.Core -public import Ix.Aiur.Library.ByteStream -public import MultiStark.Deserialize - -/-! -# Verifying-key deserializer (Aiur) - -Aiur port of `crates/aiur/src/vk_codec.rs` — reconstructs the verifier's -`System` from the bytes the prover places on the IO channel. - -Wire format (v3, mirrors `vk_codec.rs` — see its module docs for the full -layout). The multi-stark constraint-IR migration replaced the per-circuit -*symbolic* AIR (`SymbolicExpression` trees + `LookupAir`) with a *compiled* -flat base-field node graph, so this reader parses that compiled form: - -* GLOBAL HEADER: 7 × u16 parameters + u16 circuit count. -* PER-CIRCUIT RECORD (no framing prefix; nothing derivable is serialized — - constraint_count, stage_2_width, num_publics, and lookup_prefix_len are - all recomputed from the counts below): - - u16 main_width, u16 preprocessed_width, u32 preprocessed_height, - u16 max_constraint_degree (combined user + logUp), - u8 lookup_group_size (k: lookups per chained accumulator step), - u16 node_count - - `node_count` tagged nodes (dense v5: u16 children, never sub-trees): - 0 ConstSmall(u16) · 1 ConstBig(u64) · 2 Public(u8) · - 3 IsFirstRow · 4 IsLastRow · 5 IsTransition · - 6 Add(u16,u16) · 7 Sub(u16,u16) · 8 Mul(u16,u16) · 9 Neg(u16) · - 10..15 Var(u16 index) with (source, offset) packed in the tag - (tag = 10 + 2·source + offset) - - u16 zero_count, then that many u16 constraint-root NodeIds (USER - constraints only — the logUp constraints are never compiled) - - u16 lookup_count, then the compiled lookups (u16 multiplicity NodeId, - u16 arg count, u16 arg NodeIds) — these drive the verifier's direct - logUp constraint evaluation (`Verifier.lean`). -* TRAILER: preprocessed commit (`0` = None / `1` + MerkleCap) then one u16 - per circuit for the preprocessed index (`0xFFFF` = None). - -The vk stream (IO channel 1) is read once through `read_checked_byte_stream`, -then both hashed and deserialized from that same `ByteStream`. The checked -reader proves the stream finite and every element a byte. The byte check is -what lets the hash bind every reconstructed value to `system_digest`: BLAKE3 -absorbs message bytes as packed 32-bit words, and elements that are not bytes -could keep those words while `read_vk_u8` and `read_vk_u16` return other -values (a `ConstSmall` high byte lowered by 512 turns the next `Add` tag -into `Mul`). The constrained countdown readers terminate, and the caller -requires an empty remainder. Expression children must also precede their -parents, as in the native compiled graph: a finite node list can still encode -a cyclic graph. Per-node degrees are neither serialized nor needed. - -The Fiat-Shamir shape limbs (`observe_shape`): the circuit count then, -per circuit, the seven words constraint_count, max_constraint_degree, -preprocessed_height, preprocessed_width, main_width, stage_2_width, -lookup_group_size (as 8-byte LE limbs). --/ - -public section - -namespace MultiStark - -def systemDeserialize := ⟦ - -- ========================================================================== - -- Reconstructed `System` as Aiur data (compiled form). - -- ========================================================================== - - -- A compiled constraint node (`multi_stark::circuit::Node`). Children of - -- Add/Sub/Mul/Neg are NodeIds (indices into the circuit's node vector), - -- not sub-trees: the graph is flat and topologically ordered (a node's - -- children always have smaller indices). - enum SysNode { - Const(G), -- native Goldilocks constant (reduced on read) - Var(G, G, G), -- source (0 Preprocessed, 1 Main, 2 Stage2), offset (0 current, 1 next), column index - Public(G), -- public-input coordinate index - IsFirstRow, - IsLastRow, - IsTransition, - Add(G, G), -- child NodeIds - Sub(G, G), - Mul(G, G), - Neg(G) - } - - -- A compiled circuit: the flat node vector, its length, the constraint-root - -- NodeIds (`zeros`), and the maximum constraint degree (for the quotient - -- degree). The lookups are omitted — their constraints are compiled into - -- `zeros`, so the verifier never needs them. - -- A compiled lookup: multiplicity node id + argument node ids (all into - -- the graph's lookup prefix). Drives the direct logUp evaluation. - enum SysLookup { Mk(G, List‹G›) } - -- nodes, node_count, zeros, max_constraint_degree, lookups, - -- lookup_group_size, main_width, preprocessed_width, stage_2_width: the - -- three widths pin every opened row of the circuit to the verifying key. - enum SysCircuit { Mk(List‹SysNode›, G, List‹G›, G, List‹SysLookup›, G, G, G, G) } - - -- log_blowup, cap_height, log_final_poly_len, max_log_arity, num_queries, - -- commit_proof_of_work_bits, query_proof_of_work_bits — the commitment + FRI - -- parameters the config (and its challenger seed) was built from. - enum SysParams { Mk(G, G, G, G, G, G, G) } - - -- `Option`s as dedicated non-generic enums (unambiguous constructors). - enum OptCommit { NoCommit, SomeCommit(MerkleCap) } - enum OptIdx { NoIdx, SomeIdx(G) } - - -- parameters, transcript limbs, circuits, preprocessed_commit, - -- preprocessed_indices. The transcript limbs are the u64 words the - -- challenger observes before any commitment — the 7 parameters (bound via - -- the challenger seed) followed by the system shape (`observe_shape`: the - -- circuit count, then 7 metadata words per circuit) — kept as limbs because - -- the Fiat-Shamir replay needs their little-endian bytes. - enum Sys { Mk(SysParams, List‹U64›, List‹SysCircuit›, OptCommit, List‹OptIdx›) } - - -- ========================================================================== - -- Byte primitives over the already materialized vk stream. Each returns - -- the remaining stream. The `_limb` variants also - -- return the value's 8-LE-byte u64 limb for the Fiat-Shamir replay. - -- ========================================================================== - - fn read_vk_u8(s: ByteStream) -> (U8, ByteStream) { - match load(s) { - ListNode.Cons(byte, rest) => (byte, rest), - } - } - - -- A single byte kept as a raw field value for match dispatch (tags, source, - -- offset). - fn read_vk_tag(s: ByteStream) -> (G, ByteStream) { - let (b, rest) = read_vk_u8(s); - (to_field(b), rest) - } - - fn read_vk_u16(s: ByteStream) -> (G, ByteStream) { - let (b0, s0) = read_vk_u8(s); - let (b1, s1) = read_vk_u8(s0); - (to_field(b0) + 0x100 * to_field(b1), s1) - } - - fn read_vk_u16_limb(s: ByteStream) -> (G, U64, ByteStream) { - let (b0, s0) = read_vk_u8(s); - let (b1, s1) = read_vk_u8(s0); - (to_field(b0) + 0x100 * to_field(b1), - [b0, b1, - 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], - s1) - } - - fn read_vk_u32(s: ByteStream) -> (G, ByteStream) { - let (b0, s0) = read_vk_u8(s); let (b1, s1) = read_vk_u8(s0); - let (b2, s2) = read_vk_u8(s1); let (b3, s3) = read_vk_u8(s2); - (to_field(b0) + 0x100 * to_field(b1) + 0x10000 * to_field(b2) + 0x1000000 * to_field(b3), s3) - } - - fn read_vk_u32_limb(s: ByteStream) -> (G, U64, ByteStream) { - let (b0, s0) = read_vk_u8(s); let (b1, s1) = read_vk_u8(s0); - let (b2, s2) = read_vk_u8(s1); let (b3, s3) = read_vk_u8(s2); - (to_field(b0) + 0x100 * to_field(b1) + 0x10000 * to_field(b2) + 0x1000000 * to_field(b3), - [b0, b1, b2, b3, - 0u8, 0u8, 0u8, 0u8], - s3) - } - - fn read_vk_u64(s: ByteStream) -> (U64, ByteStream) { - let (b0, s0) = read_vk_u8(s); let (b1, s1) = read_vk_u8(s0); - let (b2, s2) = read_vk_u8(s1); let (b3, s3) = read_vk_u8(s2); - let (b4, s4) = read_vk_u8(s3); let (b5, s5) = read_vk_u8(s4); - let (b6, s6) = read_vk_u8(s5); let (b7, s7) = read_vk_u8(s6); - ([b0, b1, b2, b3, b4, b5, b6, b7], s7) - } - - -- A full (u64) Goldilocks constant, reduced into a native field value so it - -- can feed the composition arithmetic directly. - fn read_field(i: ByteStream) -> (G, ByteStream) { - let (u, j) = read_vk_u64(i); - (@gl_val(u), j) - } - - fn read_vk_digest(i: ByteStream) -> (Digest, ByteStream) { - let (a, j0) = read_vk_u64(i); - let (b, j1) = read_vk_u64(j0); - let (c, j2) = read_vk_u64(j1); - let (d, j3) = read_vk_u64(j2); - ([a, b, c, d], j3) - } - fn read_vk_cap_n(i: ByteStream, n: G) -> (MerkleCap, ByteStream) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (x, j) = @read_vk_digest(i); - let (rest, j2) = read_vk_cap_n(j, n - 1); - (store(ListNode.Cons(store(x), rest)), j2), - } - } - - -- ========================================================================== - -- Node reader. A node is a single tagged record whose children (when any) - -- are u32 NodeIds — there is no recursion over sub-expressions. - -- ========================================================================== - - -- Dense (v5) node encoding: u16 child ids and column indices; the Var - -- (source, offset) pair packed into the tag (10 + 2·source + offset); - -- small (u16) / big (u64) constant split; u8 public index. - fn read_node(i: ByteStream) -> (SysNode, ByteStream) { - let (tag, i1) = read_vk_tag(i); - match tag { - 0 => let (c, i2) = read_vk_u16(i1); (SysNode.Const(c), i2), - 1 => let (c, i2) = read_field(i1); (SysNode.Const(c), i2), - 2 => let (idx, i2) = read_vk_tag(i1); (SysNode.Public(idx), i2), - 3 => (SysNode.IsFirstRow, i1), - 4 => (SysNode.IsLastRow, i1), - 5 => (SysNode.IsTransition, i1), - 6 => - let (a, i2) = read_vk_u16(i1); - let (b, i3) = read_vk_u16(i2); - (SysNode.Add(a, b), i3), - 7 => - let (a, i2) = read_vk_u16(i1); - let (b, i3) = read_vk_u16(i2); - (SysNode.Sub(a, b), i3), - 8 => - let (a, i2) = read_vk_u16(i1); - let (b, i3) = read_vk_u16(i2); - (SysNode.Mul(a, b), i3), - 9 => - let (a, i2) = read_vk_u16(i1); - (SysNode.Neg(a), i2), - 10 => let (idx, i2) = read_vk_u16(i1); (SysNode.Var(0, 0, idx), i2), - 11 => let (idx, i2) = read_vk_u16(i1); (SysNode.Var(0, 1, idx), i2), - 12 => let (idx, i2) = read_vk_u16(i1); (SysNode.Var(1, 0, idx), i2), - 13 => let (idx, i2) = read_vk_u16(i1); (SysNode.Var(1, 1, idx), i2), - 14 => let (idx, i2) = read_vk_u16(i1); (SysNode.Var(2, 0, idx), i2), - _ => let (idx, i2) = read_vk_u16(i1); (SysNode.Var(2, 1, idx), i2), - } - } - - -- `read_node` is folded in as a TAIL match, with the cons + recursion - -- continuation duplicated into every arm: exclusive arms share aux/lookup - -- columns (max, not sum), so the duplication is free and the separate - -- `read_node` circuit (49 wide) disappears. (An `@read_node` splice is not - -- possible: its lets + tail match building the multi-variant SysNode trips - -- the inliner — scratchpad InlineRepro case G3.) - -- `node_idx` starts at zero. Checking every child against its parent index - -- gives eval_at a strictly decreasing rank without adding depth to each - -- evaluation. The native graph compiler emits this topological order. - fn read_nodes_n(i: ByteStream, n: G, node_idx: G) -> (List‹SysNode›, ByteStream) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (tag, i1) = read_vk_tag(i); - match tag { - 0 => - let (c, i2) = read_vk_u16(i1); - let (rest, i3) = read_nodes_n(i2, n - 1, node_idx + 1); - (store(ListNode.Cons(SysNode.Const(c), rest)), i3), - 1 => - let (c, i2) = read_field(i1); - let (rest, i3) = read_nodes_n(i2, n - 1, node_idx + 1); - (store(ListNode.Cons(SysNode.Const(c), rest)), i3), - 2 => - let (idx, i2) = read_vk_tag(i1); - let (rest, i3) = read_nodes_n(i2, n - 1, node_idx + 1); - (store(ListNode.Cons(SysNode.Public(idx), rest)), i3), - 3 => - let (rest, i3) = read_nodes_n(i1, n - 1, node_idx + 1); - (store(ListNode.Cons(SysNode.IsFirstRow, rest)), i3), - 4 => - let (rest, i3) = read_nodes_n(i1, n - 1, node_idx + 1); - (store(ListNode.Cons(SysNode.IsLastRow, rest)), i3), - 5 => - let (rest, i3) = read_nodes_n(i1, n - 1, node_idx + 1); - (store(ListNode.Cons(SysNode.IsTransition, rest)), i3), - 6 => - let (a, i2) = read_vk_u16(i1); - let (b, i3) = read_vk_u16(i2); - assert_eq!(memo_u32_less_than(a, node_idx), 1, - "vk: expression child must precede its parent"); - assert_eq!(memo_u32_less_than(b, node_idx), 1, - "vk: expression child must precede its parent"); - let (rest, i4) = read_nodes_n(i3, n - 1, node_idx + 1); - (store(ListNode.Cons(SysNode.Add(a, b), rest)), i4), - 7 => - let (a, i2) = read_vk_u16(i1); - let (b, i3) = read_vk_u16(i2); - assert_eq!(memo_u32_less_than(a, node_idx), 1, - "vk: expression child must precede its parent"); - assert_eq!(memo_u32_less_than(b, node_idx), 1, - "vk: expression child must precede its parent"); - let (rest, i4) = read_nodes_n(i3, n - 1, node_idx + 1); - (store(ListNode.Cons(SysNode.Sub(a, b), rest)), i4), - 8 => - let (a, i2) = read_vk_u16(i1); - let (b, i3) = read_vk_u16(i2); - assert_eq!(memo_u32_less_than(a, node_idx), 1, - "vk: expression child must precede its parent"); - assert_eq!(memo_u32_less_than(b, node_idx), 1, - "vk: expression child must precede its parent"); - let (rest, i4) = read_nodes_n(i3, n - 1, node_idx + 1); - (store(ListNode.Cons(SysNode.Mul(a, b), rest)), i4), - 9 => - let (a, i2) = read_vk_u16(i1); - assert_eq!(memo_u32_less_than(a, node_idx), 1, - "vk: expression child must precede its parent"); - let (rest, i3) = read_nodes_n(i2, n - 1, node_idx + 1); - (store(ListNode.Cons(SysNode.Neg(a), rest)), i3), - 10 => - let (idx, i2) = read_vk_u16(i1); - let (rest, i3) = read_nodes_n(i2, n - 1, node_idx + 1); - (store(ListNode.Cons(SysNode.Var(0, 0, idx), rest)), i3), - 11 => - let (idx, i2) = read_vk_u16(i1); - let (rest, i3) = read_nodes_n(i2, n - 1, node_idx + 1); - (store(ListNode.Cons(SysNode.Var(0, 1, idx), rest)), i3), - 12 => - let (idx, i2) = read_vk_u16(i1); - let (rest, i3) = read_nodes_n(i2, n - 1, node_idx + 1); - (store(ListNode.Cons(SysNode.Var(1, 0, idx), rest)), i3), - 13 => - let (idx, i2) = read_vk_u16(i1); - let (rest, i3) = read_nodes_n(i2, n - 1, node_idx + 1); - (store(ListNode.Cons(SysNode.Var(1, 1, idx), rest)), i3), - 14 => - let (idx, i2) = read_vk_u16(i1); - let (rest, i3) = read_nodes_n(i2, n - 1, node_idx + 1); - (store(ListNode.Cons(SysNode.Var(2, 0, idx), rest)), i3), - _ => - let (idx, i2) = read_vk_u16(i1); - let (rest, i3) = read_nodes_n(i2, n - 1, node_idx + 1); - (store(ListNode.Cons(SysNode.Var(2, 1, idx), rest)), i3), - }, - } - } - - -- A run of u16 NodeIds (constraint roots / lookup argument ids). - fn read_node_ids_n(i: ByteStream, n: G) -> (List‹G›, ByteStream) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (id, i1) = read_vk_u16(i); - let (rest, i2) = read_node_ids_n(i1, n - 1); - (store(ListNode.Cons(id, rest)), i2), - } - } - - fn read_sys_lookup(i: ByteStream) -> (SysLookup, ByteStream) { - let (m, i1) = read_vk_u16(i); - let (ac, i2) = read_vk_u16(i1); - let (args, i3) = read_node_ids_n(i2, ac); - (SysLookup.Mk(m, args), i3) - } - fn read_sys_lookups_n(i: ByteStream, n: G) -> (List‹SysLookup›, ByteStream) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (x, j) = @read_sys_lookup(i); - let (rest, j2) = read_sys_lookups_n(j, n - 1); - (store(ListNode.Cons(x, rest)), j2), - } - } - - -- ⌈n/k⌉ by walking the lookups with a within-group countdown (`rem`, - -- 0 = a new group starts on the next lookup). No in-circuit division. - fn lookup_groups_count(n: G, rem: G, k: G) -> G { - match n { - 0 => 0, - _ => match rem { - 0 => 1 + lookup_groups_count(n - 1, k - 1, k), - _ => lookup_groups_count(n - 1, rem - 1, k), - }, - } - } - - -- One circuit record: a u32 length prefix then the contiguous record. The - -- 8-word header, the node stream, the zeros, and the compiled lookups - -- (which drive the direct logUp evaluation) are all parsed. Besides the - -- parsed circuit, returns its 7 shape words as u64 limbs, in - -- `observe_shape` order: constraint_count (user roots + ⌈L/k⌉·D, read - -- from the header), max_constraint_degree (combined), - -- preprocessed_height, preprocessed_width, main_width, stage_2_width, - -- lookup_group_size. - fn read_sys_circuit(base: ByteStream) -> (SysCircuit, [U64; 7], ByteStream) { - let (mw, mwl, c1) = read_vk_u16_limb(base); - let (pw, pwl, c2) = read_vk_u16_limb(c1); - let (ph, phl, c3) = read_vk_u32_limb(c2); - let (md, mdl, c4) = read_vk_u16_limb(c3); - let (k, c4b) = read_vk_tag(c4); - let (ncount, c5) = read_vk_u16(c4b); - let (nodes, c6) = read_nodes_n(c5, ncount, 0); - let (zcount, c7) = read_vk_u16(c6); - let (zeros, c8) = read_node_ids_n(c7, zcount); - let (lcount, c9) = read_vk_u16(c8); - let (lks, c10) = read_sys_lookups_n(c9, lcount); - -- Derived shape values (not serialized): constraint_count = user roots - -- + ⌈L/k⌉·D and stage_2_width = max(⌈L/k⌉, 1)·D, their observation - -- limbs built by byte decomposition (both values are far below 2^32, so - -- the canonical decomposition IS the little-endian u64 limb). - -- Grouped chained logUp: one accumulator slot and one constraint per - -- lookup GROUP (`k` consecutive lookups; the last group may be smaller). - -- ⌈L/k⌉ groups, +1 iff L = 0 (single pass-through slot). Branch-free so - -- the record reader stays a single-path body: its lookups group 2 per - -- stage-2 slot, and — with no internal match — it can @-inline into - -- `read_sys_circuits_n` (a let-bound match here tripped the inliner). - let groups = lookup_groups_count(lcount, 0, k); - let gslots = groups + eq_zero(groups); - let s2w = gslots + gslots; - let ccl = @gl_to_bytes(zcount + s2w); - let s2wl = @gl_to_bytes(s2w); - let kl = @gl_to_bytes(k); - (SysCircuit.Mk(nodes, ncount, zeros, md, lks, k, mw, pw, s2w), - [ccl, mdl, phl, pwl, mwl, s2wl, kl], c10) - } - fn cons_shape7(l: [U64; 7], tail: List‹U64›) -> List‹U64› { - store(ListNode.Cons(l[0], store(ListNode.Cons(l[1], store(ListNode.Cons(l[2], - store(ListNode.Cons(l[3], store(ListNode.Cons(l[4], store(ListNode.Cons(l[5], - store(ListNode.Cons(l[6], tail)))))))))))))) - } - -- Returns the circuits plus their shape limbs (`observe_shape` order: each - -- circuit's 7 metadata words; the count limb is consed by `read_system`). - fn read_sys_circuits_n(i: ByteStream, n: G) -> (List‹SysCircuit›, List‹U64›, ByteStream) { - match n { - 0 => (store(ListNode.Nil), store(ListNode.Nil), i), - _ => - let (x, xl, j) = @read_sys_circuit(i); - let (rest, lrest, j2) = read_sys_circuits_n(j, n - 1); - (store(ListNode.Cons(x, rest)), @cons_shape7(xl, lrest), j2), - } - } - - -- ========================================================================== - -- Trailer. - -- ========================================================================== - - fn read_opt_commit(i: ByteStream) -> (OptCommit, ByteStream) { - let (tag, j) = read_vk_u8(i); - match tag { - 0 => (OptCommit.NoCommit, j), - _ => - let (n, j1) = read_vk_u16(j); - let (c, j2) = read_vk_cap_n(j1, n); - (OptCommit.SomeCommit(c), j2), - } - } - -- One u16 per circuit; 0xFFFF is the None sentinel. - fn read_opt_idx_n(i: ByteStream, n: G) -> (List‹OptIdx›, ByteStream) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (v, j) = read_vk_u16(i); - let (rest, j2) = read_opt_idx_n(j, n - 1); - match v { - 65535 => (store(ListNode.Cons(OptIdx.NoIdx, rest)), j2), - _ => (store(ListNode.Cons(OptIdx.SomeIdx(v), rest)), j2), - }, - } - } - - -- The 7 protocol parameters, both as field values (for the verifier logic) - -- and as u64 limbs (their LE bytes seed the challenger). - fn read_sys_params(i: ByteStream) -> (SysParams, List‹U64›, ByteStream) { - let (p0, l0, j0) = read_vk_u16_limb(i); - let (p1, l1, j1) = read_vk_u16_limb(j0); - let (p2, l2, j2) = read_vk_u16_limb(j1); - let (p3, l3, j3) = read_vk_u16_limb(j2); - let (p4, l4, j4) = read_vk_u16_limb(j3); - let (p5, l5, j5) = read_vk_u16_limb(j4); - let (p6, l6, j6) = read_vk_u16_limb(j5); - (SysParams.Mk(p0, p1, p2, p3, p4, p5, p6), - store(ListNode.Cons(l0, store(ListNode.Cons(l1, store(ListNode.Cons(l2, - store(ListNode.Cons(l3, store(ListNode.Cons(l4, store(ListNode.Cons(l5, - store(ListNode.Cons(l6, store(ListNode.Nil))))))))))))))), - j6) - } - - -- Full `System` parsed from the digest-bound byte stream. - -- Returns the unconsumed suffix; the entrypoint asserts it is empty. - fn read_system(i: ByteStream) -> (Sys, ByteStream) { - let (params, plimbs, j) = @read_sys_params(i); - let (n, nlimb, j1) = read_vk_u16_limb(j); - let (circuits, climbs, j2) = read_sys_circuits_n(j1, n); - let (commit, j3) = read_opt_commit(j2); - let (indices, j4) = read_opt_idx_n(j3, n); - (Sys.Mk(params, - list_concat(plimbs, store(ListNode.Cons(nlimb, climbs))), - circuits, commit, indices), - j4) - } -⟧ - -end MultiStark - -end diff --git a/MultiStark/Verifier.lean b/MultiStark/Verifier.lean deleted file mode 100644 index e1d0eb55d..000000000 --- a/MultiStark/Verifier.lean +++ /dev/null @@ -1,1237 +0,0 @@ -module -public import Ix.Aiur.Meta -public import Ix.Aiur.Library.Core -public import Ix.Aiur.Library.ByteStream -public import MultiStark.Deserialize -public import MultiStark.Keccak -public import MultiStark.Pcs -public import MultiStark.SystemDeserialize - -/-! -# Multi-STARK verifier (Aiur) - -Reimplementation of `multi-stark/src/verifier.rs` (`System::verify_multiple_claims`) -over the deserialized `Proof` (`MultiStark/Deserialize.lean`). - -The Rust verifier runs these steps: - -1. **Shape check** — proof array dimensions match the system's circuit count and - column widths. -2. **Accumulator balance** — the last intermediate accumulator is zero (all - lookup pushes/pulls cancel). -3. **Fiat-Shamir replay** — reconstruct the challenger: observe - commitments / trace heights / claims, sample (lookup, fingerprint, α, ζ). -4. **PCS verification** — FRI opening proofs (see `MultiStark/Pcs.lean`). -5. **OOD evaluation** — recompute the composition polynomial at ζ and check - `composition(ζ) · inv_vanishing(ζ) == quotient(ζ)`. - -### Implemented here -* Step 1: the proof is internally consistent — `stage_1`, `stage_2` and - `intermediate_accumulators` all have the same length (the circuit count) - and it is non-zero — and every opened row of every active circuit has the - width the verifying key gives it (main, stage 2, preprocessed in - `ood_loop`; the quotient through its degree), as `verify_shape` requires - natively. -* Step 2: accumulator balance — each shard's last `intermediate_accumulator` - is its residual, and the batch balances when the residuals plus the batch - messages' contributions sum to zero (`verify_batch`). -* Step 3: the Fiat-Shamir challenger replay (`batch_fiat_shamir` through the - lookup challenges, `shard_fiat_shamir` per shard). Prover-faithful: starts - from the parameter-seeded challenger (`b"multi-stark/v0"` + the 7 protocol - parameters), observes the system shape, the verifying key's preprocessed - commitment, the shard count, every shard header (activation bits, stage_1 - commitment, trace heights, length-prefixed claims) and the batch messages, - then samples and re-observes the lookup/fingerprint challenges; each shard - then observes its index, stage_2 and the intermediate accumulators, samples - α, observes the quotient commitment, and samples ζ — matching - `verify_batch` byte-for-byte. -* Step 5: the out-of-domain composition/quotient check (`verify_shard`). For each - circuit it recomputes `composition(ζ)` by replaying the AIR constraint folder - (`VerifierConstraintFolder` + `LookupAir::eval`) over the deserialized - symbolic system and the opened values, recomputes `quotient(ζ)` from the - opened quotient coefficient slices (the power series - `Q(ζ) = Σᵢ ζ^(i·n)·cᵢ(ζ)`), and asserts - `composition(ζ) · inv_vanishing(ζ) == quotient(ζ)`. - Validated end-to-end against a real factorial proof (the `recursive-verifier` - test runner, `Tests/MultiStark.lean`): the verifier accepts the honest proof - and rejects a tampered claim. - -* Step 4: the PCS/FRI opening proof (`pcs_fri_verify`, `MultiStark/Pcs.lean`) - — Merkle `verify_batch`, the challenger continuation, the FRI fold chain, and - the final-polynomial check. - -### Notes -* Base-field samples are rejection-sampled (`ch_sample_field`): a raw 8-byte - limb in the band `[p, 2⁶⁴)` (probability ≈ 2⁻³²) is discarded and redrawn, - consuming challenger bytes exactly as `SerializingChallenger64::sample` does. --/ - -public section - -namespace MultiStark - -def verifier := ⟦ - -- An extension element `[c0, c1]` (`= c0 + c1·X`) is zero iff both Goldilocks - -- coefficients are zero. (`read_ext` already reduced the limbs mod p.) - fn ext_is_zero(e: Ext) -> G { - eq_zero(e[0]) * eq_zero(e[1]) - } - - -- ========================================================================== - -- Fiat-Shamir challenger: `SerializingChallenger64>`. The inner byte challenger keeps an `input` buffer; a - -- `sample` with empty `output` flushes (`input := output := blake3(input)`) - -- and pops bytes from the END of the hash output. The outer layer serializes - -- field elements as 8 little-endian bytes and samples field elements as - -- 8-byte little-endian u64s. - -- - -- The challenger is threaded as a pair `(input, output)` of byte lists, where - -- `output` is held in pop order (front = next byte = hash byte 31, 30, …). - -- ========================================================================== - - -- Cons 8 bytes (LSB-first) of `b` onto `tail` (one byte list segment). - fn b8_onto(b: [U8; 8], tail: ByteStream) -> ByteStream { - store(ListNode.Cons(b[0], store(ListNode.Cons(b[1], store(ListNode.Cons(b[2], - store(ListNode.Cons(b[3], store(ListNode.Cons(b[4], store(ListNode.Cons(b[5], - store(ListNode.Cons(b[6], store(ListNode.Cons(b[7], tail)))))))))))))))) - } - - -- A digest = `[u64; 4]` = 32 bytes (each limb little-endian) onto `tail`. - fn digest_onto(d: Digest, tail: ByteStream) -> ByteStream { - b8_onto(d[0], b8_onto(d[1], b8_onto(d[2], b8_onto(d[3], tail)))) - } - - -- A commitment (`MerkleCap` = `Vec`): all digest bytes, onto `tail`. - fn cap_onto(cap: MerkleCap, tail: ByteStream) -> ByteStream { - match load(cap) { - ListNode.Nil => tail, - ListNode.Cons(d, rest) => @digest_onto(load(d), cap_onto(rest, tail)), - } - } - - -- Observe `log_degrees`: each is a `Val::from_u8`, i.e. 8 LE bytes `[ld,0,…]`. - fn log_degrees_onto(lds: List‹U8›, tail: ByteStream) -> ByteStream { - match load(lds) { - ListNode.Nil => tail, - ListNode.Cons(ld, rest) => - b8_onto([ld, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], log_degrees_onto(rest, tail)), - } - } - - -- Reverse `l` onto `acc` (used to put a hash output into pop order). - fn rev_onto(l: ByteStream, acc: ByteStream) -> ByteStream { - match load(l) { - ListNode.Nil => acc, - ListNode.Cons(b, rest) => rev_onto(rest, store(ListNode.Cons(b, acc))), - } - } - - -- Sample 8 bytes = `sample_array()` (for one base-field element, LE). - -- The output buffer always holds a multiple of 8 bytes at a draw boundary - -- (a flush refills 32, every draw takes 8, an observe clears to Nil), so - -- the empty check happens at most once per draw: flush, then pop 8. The - -- two arms' pops share columns (branch aux/lookups combine by max), which - -- is what makes this strictly narrower than a per-byte sampler circuit. - fn ch_sample8(input: ByteStream, output: ByteStream) -> ([U8; 8], ByteStream, ByteStream) { - match load(output) { - ListNode.Nil => - -- `HashChallenger` flush: hash the `input` buffer with - -- blake3; `b3_flatten_onto` (Pcs.lean) gives the 32 output bytes, popped - -- from the END (rev), with the `input := output := hash` update. - let h = @blake3(input); - let fwd = @b3_flatten_onto(h, store(ListNode.Nil)); - let rev = rev_onto(fwd, store(ListNode.Nil)); - let &ListNode.Cons(b0, r1) = rev; - let &ListNode.Cons(b1, r2) = r1; - let &ListNode.Cons(b2, r3) = r2; - let &ListNode.Cons(b3, r4) = r3; - let &ListNode.Cons(b4, r5) = r4; - let &ListNode.Cons(b5, r6) = r5; - let &ListNode.Cons(b6, r7) = r6; - let &ListNode.Cons(b7, r8) = r7; - ([b0, b1, b2, b3, b4, b5, b6, b7], fwd, r8), - ListNode.Cons(b0, r1) => - let &ListNode.Cons(b1, r2) = r1; - let &ListNode.Cons(b2, r3) = r2; - let &ListNode.Cons(b3, r4) = r3; - let &ListNode.Cons(b4, r5) = r4; - let &ListNode.Cons(b5, r6) = r5; - let &ListNode.Cons(b6, r7) = r6; - let &ListNode.Cons(b7, r8) = r7; - ([b0, b1, b2, b3, b4, b5, b6, b7], input, r8), - } - } - - -- Sample one base-field element with REJECTION SAMPLING, mirroring - -- `SerializingChallenger64::sample`'s inner loop: draw 8 bytes as a LE u64 - -- (the `log2_ceil(p) = 64` mask is a no-op for Goldilocks); if the raw value - -- is ≥ p (probability ≈ 2⁻³²), DISCARD it and draw the next 8 bytes — a - -- rejected draw consumes challenger bytes, shifting every later sample, - -- exactly as in the reference. `gl_lt_p` decides `raw < p`; the accepted - -- limb is canonical (< p) by construction. - fn ch_sample_field(input: ByteStream, output: ByteStream) -> ([U8; 8], ByteStream, ByteStream) { - let (raw, i1, o1) = ch_sample8(input, output); - match @gl_lt_p(raw) { - 1 => (raw, i1, o1), - _ => ch_sample_field(i1, o1), - } - } - - -- Sample a degree-2 extension element: two base samples (`from_basis_*`), - -- each rejection-sampled, returning their 8-byte LE limbs (canonical, but - -- also re-observable as raw bytes) and the threaded challenger. - fn ch_sample_ext(input: ByteStream, output: ByteStream) -> ([U8; 8], [U8; 8], ByteStream, ByteStream) { - let (c0, i0, o0) = ch_sample_field(input, output); - let (c1, i1, o1) = ch_sample_field(i0, o0); - (c0, c1, i1, o1) - } - - -- Prepend the 8 elements of `d` onto `tail` (generic list helper). - fn cons8(d: [G; 8], tail: List‹G›) -> List‹G› { - store(ListNode.Cons(d[0], store(ListNode.Cons(d[1], store(ListNode.Cons(d[2], - store(ListNode.Cons(d[3], store(ListNode.Cons(d[4], store(ListNode.Cons(d[5], - store(ListNode.Cons(d[6], store(ListNode.Cons(d[7], tail)))))))))))))))) - } - - -- `sample_bits(n)` (FRI query index). `SerializingChallenger64::sample_bits` - -- reads one 8-byte sample as a little-endian u64 and masks the low `n` bits. - -- We return the low `n` bits as a list (LSB first = the leaf→root Merkle/FRI - -- path). Only the low 4 bytes are decomposed: 32 bits bound every - -- log-height (Goldilocks two-adicity is 32), and `take_bits` aborts on the - -- Nil match if `n` ever exceeded 32 — exactly as it did at 64 with the old - -- full decomposition. The full 8 bytes are still drawn (Fiat-Shamir - -- alignment with the reference challenger). - fn take_bits(bits: List‹G›, n: G) -> List‹G› { - match n { - 0 => store(ListNode.Nil), - _ => - let &ListNode.Cons(b, rest) = bits; - store(ListNode.Cons(b, take_bits(rest, n - 1))), - } - } - fn ch_sample_bits(input: ByteStream, output: ByteStream, n: G) - -> (List‹G›, ByteStream, ByteStream) { - let (bytes, i1, o1) = ch_sample8(input, output); - let bits = - cons8(u8_bit_decomposition(bytes[0]), - cons8(u8_bit_decomposition(bytes[1]), - cons8(u8_bit_decomposition(bytes[2]), - cons8(u8_bit_decomposition(bytes[3]), store(ListNode.Nil))))); - (take_bits(bits, n), i1, o1) - } - - -- Append (observe) 8 little-endian bytes of `b` at the END of the challenger - -- input buffer. The transcript is held front-to-back (front = first observed = - -- first hashed, matching `blake3`'s absorption order), so an observation - -- appends — `b8_onto` PREPENDS, hence the `list_concat`. - fn snoc_b8(input: ByteStream, b: [U8; 8]) -> ByteStream { - list_concat(input, b8_onto(b, store(ListNode.Nil))) - } - -- Append (observe) a commitment (`MerkleCap`) at the end of the buffer. - fn snoc_cap(input: ByteStream, cap: MerkleCap) -> ByteStream { - list_concat(input, cap_onto(cap, store(ListNode.Nil))) - } - -- The intermediate accumulators as a prepend-built stream, in order — each - -- an `observe_algebra_element`: two canonical 8-LE-byte limbs. (`read_ext` - -- reduced the limbs mod p, matching `as_canonical_u64` serialization.) - -- Prepend-composed so observing all of them is one `list_concat`, not a - -- per-element re-walk of the input buffer. - fn accs_onto(accs: List‹Ext›, tail: ByteStream) -> ByteStream { - match load(accs) { - ListNode.Nil => tail, - ListNode.Cons(e, rest) => b8_onto(@gl_to_bytes(e[0]), b8_onto(@gl_to_bytes(e[1]), accs_onto(rest, tail))), - } - } - - -- ========================================================================== - -- PCS challenger continuation (Phase 4): the post-ζ transcript that - -- `two_adic_pcs::verify` + `verify_fri` replay. Unlike `fiat_shamir` — where - -- every sample is followed by an observe (so each sample re-flushes from an - -- empty `output`) — the PCS phase has *consecutive* samples with no observe - -- between (the PCS batch challenge α, then immediately the FRI batch challenge - -- α). So both challenger buffers must be threaded: `output` carries the - -- leftover hash bytes from one sample into the next instead of re-flushing. - -- ========================================================================== - - -- Observe one `Val` (8 LE bytes): append to `input`, CLEAR `output` (any - -- leftover sampled bytes are discarded), per `HashChallenger::observe`. - fn ch_observe_val(input: ByteStream, v: U64) -> (ByteStream, ByteStream) { - (snoc_b8(input, v), store(ListNode.Nil)) - } - - -- Sample a degree-2 extension element, threading BOTH challenger buffers so a - -- following consecutive sample continues from the same hash `output` stream - -- (no re-flush). Limbs are rejection-sampled (`ch_sample_field`), so they are - -- canonical; the `gl_reduce` is a no-op kept for type/intent clarity. - fn pcs_sample_ext(input: ByteStream, output: ByteStream) - -> (Ext, ByteStream, ByteStream) { - let (c0, c1, i1, o1) = ch_sample_ext(input, output); - ([@gl_val(c0), @gl_val(c1)], i1, o1) - } - - -- `b"multi-stark/v0"` — the domain-separation tag the challenger seed - -- starts with (`GoldilocksBlake3Config::new`). - fn seed_tag_onto(tail: ByteStream) -> ByteStream { - store(ListNode.Cons(109u8, store(ListNode.Cons(117u8, store(ListNode.Cons(108u8, - store(ListNode.Cons(116u8, store(ListNode.Cons(105u8, store(ListNode.Cons(45u8, - store(ListNode.Cons(115u8, store(ListNode.Cons(116u8, store(ListNode.Cons(97u8, - store(ListNode.Cons(114u8, store(ListNode.Cons(107u8, store(ListNode.Cons(47u8, - store(ListNode.Cons(118u8, store(ListNode.Cons(48u8, - tail)))))))))))))))))))))))))))) - } - -- Raw u64 wire words (protocol parameters + system shape), each as its 8 LE - -- bytes, in order. - fn limbs_onto(ls: List‹U64›, tail: ByteStream) -> ByteStream { - match load(ls) { - ListNode.Nil => tail, - ListNode.Cons(l, rest) => b8_onto(l, limbs_onto(rest, tail)), - } - } - - -- The preprocessed commitment cap from the verifying key, or an empty cap - -- (observes nothing) when there is none. - fn opt_commit_cap(commit: OptCommit) -> MerkleCap { - match commit { - OptCommit.NoCommit => store(ListNode.Nil), - OptCommit.SomeCommit(c) => c, - } - } - - -- Replay the verifier transcript and derive the four challenges - -- `(lookup, fingerprint, alpha, zeta)`. Mirrors `verify_multiple_claims`'s - -- challenger sequence exactly: - -- seed = tag + protocol parameters; observe_shape - -- (circuit count + 7 metadata words per circuit) → preprocessed_commit - -- (if any) → stage_1 → - -- log_degrees → length-prefixed claims; - -- sample lookup, observe it; sample fingerprint, observe it; - -- observe stage_2; observe the intermediate accumulators; sample α; - -- observe quotient; sample ζ. - -- `observe` clears the challenger's output buffer, and every sample here is - -- preceded by an observe, so each `ch_sample_ext` re-flushes from an empty - -- output (hence the `store(ListNode.Nil)` output argument each time). - -- Every sample is rejection-sampled (`ch_sample_field` inside - -- `ch_sample_ext`), so a limb in the band `[p, 2⁶⁴)` is redrawn exactly as in - -- the reference challenger, and the limbs observed back are canonical. - -- Also returns the post-ζ challenger `input` buffer, which the PCS phase - -- (Phase 4+) continues observing into. The leftover `output` after the ζ - -- sample is discarded — the next challenger op is an observe (of the opened - -- values), which clears `output` anyway. - -- Each activation bit as an observed `Val` (8 LE bytes, 0 or 1). - fn active_onto(active: List‹G›, tail: ByteStream) -> ByteStream { - match load(active) { - ListNode.Nil => tail, - ListNode.Cons(b, rest) => - b8_onto([u8_from_field_unsafe(b), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], - active_onto(rest, tail)), - } - } - - -- ========================================================================== - -- OOD evaluation domain math (`TwoAdicMultiplicativeCoset`, Goldilocks). - -- The trace domain for a circuit of size 2^L is the order-2^L subgroup H - -- (shift = 1) generated by `two_adic_gen(L)`. - -- ========================================================================== - - -- e^(2^k) in the extension field. - fn ext_exp_pow2(e: Ext, k: G) -> Ext { - match k { - 0 => e, - _ => ext_exp_pow2(@eg_mul(e, e), k - 1), - } - } - - -- `two_adic_generator(bits)` — a primitive 2^bits root of unity in - -- Goldilocks, derived by repeated squaring from the maximal (2^32) - -- generator: `g_k = g_{k+1}^2` (matches Plonky3's TWO_ADIC_GENERATORS - -- table, checked value-by-value). The 33-arm table cost 32 default-arm - -- aux + 33 selectors; the chain is one short memoized circuit — the - -- first call materialises ≤ 32 rows, every later call is a cache hit. - -- Callers must keep `bits ≤ 32` (guarded where `bits` comes from proof - -- advice: log_degrees in `ood_loop`, log_gmax in `pcs_fri_verify`); - -- an unguarded larger value would recurse without a base case. - fn two_adic_gen(bits: G) -> Goldilocks { - match bits { - 0 => 1, - 32 => 1753635133440165772, - _ => - let g = two_adic_gen(bits + 1); - g * g, - } - } - - -- Vanishing polynomial of the trace domain (shift = 1, size 2^L) at point ζ: - -- `Z_H(ζ) = ζ^(2^L) - 1`. - fn trace_vanishing(zeta: Ext, l: G) -> Ext { - @eg_sub(ext_exp_pow2(zeta, l), [1, 0]) - } - - -- Lagrange selectors at ζ for the trace domain (shift = 1), mirroring - -- `domain.rs::selectors_at_point`: - -- is_first_row = Z_H(ζ) / (ζ - 1) - -- is_last_row = Z_H(ζ) / (ζ - g⁻¹) - -- is_transition = ζ - g⁻¹ - -- inv_vanishing = 1 / Z_H(ζ) - -- where g = two_adic_gen(L) is the subgroup generator. - -- 2^l as a field value (l is a small log-height). - fn pow2(l: G) -> G { - match l { - 0 => 1, - _ => 2 * pow2(l - 1), - } - } - - fn trace_selectors(zeta: Ext, l: G) -> (Ext, Ext, Ext, Ext) { - let zh = @trace_vanishing(zeta, l); - let ginv = @gl_inverse(two_adic_gen(l)); - let is_first = @eg_div(zh, @eg_sub(zeta, [1, 0])); - let is_last = @eg_div(zh, @eg_sub(zeta, [ginv, 0])); - let is_trans = @eg_sub(zeta, [ginv, 0]); - let inv_van = @eg_inverse(zh); - (is_first, is_last, is_trans, inv_van) - } - - -- ========================================================================== - -- Step 5: out-of-domain (OOD) evaluation. - -- - -- Mirrors the per-circuit loop in `verifier.rs::verify_multiple_claims`. - -- For each circuit it recomputes the composition polynomial - -- `composition(ζ)` from the opened values by replaying the AIR constraint - -- folder (`VerifierConstraintFolder` + `LookupAir::eval`), recomputes the - -- quotient `quotient(ζ)` from the opened coefficient slices via the power - -- series `Q(ζ) = Σᵢ ζ^(i·n)·cᵢ(ζ)`, and asserts - -- composition(ζ) · inv_vanishing(ζ) == quotient(ζ). - -- - -- The challenges (lookup, fingerprint, α, ζ) come from `fiat_shamir` above. - -- The running lookup accumulator starts from the public claims - -- (`claims_acc`; ExtVal::ZERO when there are none). - -- ========================================================================== - - -- One Horner fold step of the constraint folder: `acc := acc·α + x` - -- (`VerifierConstraintFolder::assert_zero` / `assert_zero_ext`). - fn ood_fold(acc: Ext, alpha: Ext, x: Ext) -> Ext { - @eg_add(@eg_mul(acc, alpha), x) - } - - -- Reconstruct an extension element from its two opened base coordinates, - -- `from_ext_basis([c0, c1]) = c0 + c1·X` (the ExtVal basis is `[1, X]`). - fn from_ext_basis(c0: Ext, c1: Ext) -> Ext { - @eg_add(c0, @eg_mul(c1, [0, 1])) - } - - -- A stage-2 / quotient opened row arrives as `stage_2_width·2` extension - -- coordinates; fold consecutive pairs back into `stage_2_width` extension - -- elements (Rust: `chunks_exact(2).map(from_ext_basis)`). - fn reconstruct_ext_row(raw: List‹Ext›) -> List‹Ext› { - match load(raw) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(c0, t1) => - let ListNode.Cons(c1, t2) = load(t1); - store(ListNode.Cons(from_ext_basis(c0, c1), reconstruct_ext_row(t2))), - } - } - - -- ========================================================================== - -- Compiled node-graph evaluation (replaces the symbolic AIR folder). - -- - -- The composition polynomial at ζ is `Σᵢ α^(k-1-i)·zeroᵢ`, where each `zeroᵢ` - -- is the value of a constraint-root node. The nodes form a flat, - -- topologically ordered DAG (children by NodeId, children precede parents). - -- Instead of the Rust prover's dense forward sweep (which would build an - -- O(n²) temporary value-buffer list here), `eval_at` interprets the graph - -- directly by recursing into children. Aiur memoizes calls by argument - -- pointers, so each node is evaluated at most once per opening context and - -- every further reference — DAG sharing, later constraint roots — is a - -- cache hit; node fetches share `list_drop`'s cached drop-chain over the - -- one `nodes` list. The lookup-argument constraints are already compiled - -- into `zeros`, so nothing special is done for them (Rust `verifier.rs` - -- evaluates one node graph and Horner-folds the roots). - -- ========================================================================== - - -- Evaluate node `i` of the graph into an ExtVal, given the leaf context. - -- Stage-2 columns are the OPENED BASE columns used directly (no - -- `from_ext_basis` reassembly). - fn eval_at(nodes: List‹SysNode›, i: G, - main: List‹Ext›, main_next: List‹Ext›, prep: List‹Ext›, prep_next: List‹Ext›, - s2: List‹Ext›, s2next: List‹Ext›, publics: List‹Ext›, - isf: Ext, isl: Ext, ist: Ext) -> Ext { - let nd = list_lookup(nodes, i); - match nd { - SysNode.Const(c) => [c, 0], - SysNode.Var(src, off, idx) => - -- flatten (source, offset) into one selector: 2·source + offset, - -- with source 0 Preprocessed / 1 Main / 2 Stage2, offset 0 cur / 1 next. - let sel = src + src + off; - match sel { - 0 => list_lookup(prep, idx), - 1 => list_lookup(prep_next, idx), - 2 => list_lookup(main, idx), - 3 => list_lookup(main_next, idx), - 4 => list_lookup(s2, idx), - _ => list_lookup(s2next, idx), - }, - SysNode.Public(idx) => list_lookup(publics, idx), - SysNode.IsFirstRow => isf, - SysNode.IsLastRow => isl, - SysNode.IsTransition => ist, - SysNode.Add(a, b) => - @eg_add(eval_at(nodes, a, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist), - eval_at(nodes, b, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist)), - SysNode.Sub(a, b) => - @eg_sub(eval_at(nodes, a, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist), - eval_at(nodes, b, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist)), - SysNode.Mul(a, b) => - @eg_mul(eval_at(nodes, a, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist), - eval_at(nodes, b, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist)), - SysNode.Neg(a) => - @eg_neg(eval_at(nodes, a, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist)), - } - } - - -- Horner-fold the constraint roots with α: `acc := acc·α + eval_at(z)` for - -- each root NodeId `z`, in `zeros` order (the canonical compiled order the - -- prover folded in). Roots share subgraphs, so their evaluations hit the - -- `eval_at` cache. - fn fold_roots(acc: Ext, alpha: Ext, zeros: List‹G›, nodes: List‹SysNode›, - main: List‹Ext›, main_next: List‹Ext›, prep: List‹Ext›, prep_next: List‹Ext›, - s2: List‹Ext›, s2next: List‹Ext›, publics: List‹Ext›, - isf: Ext, isl: Ext, ist: Ext) -> Ext { - match load(zeros) { - ListNode.Nil => acc, - ListNode.Cons(z, rest) => - let v = eval_at(nodes, z, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist); - fold_roots(ood_fold(acc, alpha, v), alpha, rest, nodes, - main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist), - } - } - - -- ========================================================================== - -- Direct logUp constraint evaluation (mirrors Rust - -- `lookup::logup_constraint_values`). The logUp constraints are protocol - -- machinery, never compiled into the vk's node graph: their values at ζ - -- are computed here from the lookup ids (evaluated through the memoized - -- `eval_at`), the stage-2 openings, and the lookup publics, and folded - -- with α after the user roots — per lookup GROUP the 2 coordinates of - -- the chained-accumulator step constraint (see `logup_steps_fold`). - -- - -- Coordinates: a coordinate-expanded logUp constraint is a PAIR of - -- base-field polynomials; at ζ each coordinate is an Ext value. Pair - -- products are in X² = 7 with Ext coefficients: - -- (a0·b0 + 7·a1·b1, a0·b1 + a1·b0). - -- ========================================================================== - fn pair_mul(a0: Ext, a1: Ext, b0: Ext, b1: Ext) -> (Ext, Ext) { - (@eg_add(@eg_mul(a0, b0), @eg_mul([7, 0], @eg_mul(a1, b1))), - @eg_add(@eg_mul(a0, b1), @eg_mul(a1, b0))) - } - - -- fingerprint(γ, args) = Σᵢ argsᵢ·γ^i as a coordinate pair: - -- fp(Cons(a, rest)) = (eval a, 0) + γ ⊗ fp(rest); args embed in coord 0. - fn logup_fingerprint(args: List‹G›, g0: Ext, g1: Ext, nodes: List‹SysNode›, - main: List‹Ext›, main_next: List‹Ext›, prep: List‹Ext›, prep_next: List‹Ext›, - s2: List‹Ext›, s2next: List‹Ext›, publics: List‹Ext›, - isf: Ext, isl: Ext, ist: Ext) -> (Ext, Ext) { - match load(args) { - ListNode.Nil => ([0, 0], [0, 0]), - ListNode.Cons(a, rest) => - let (f0, f1) = logup_fingerprint(rest, g0, g1, nodes, - main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist); - let (m0, m1) = pair_mul(f0, f1, g0, g1); - let av = eval_at(nodes, a, main, main_next, prep, prep_next, s2, s2next, - publics, isf, isl, ist); - (@eg_add(m0, av), m1), - } - } - - -- Per-GROUP chained-accumulator constraints, folding into the α - -- accumulator as we go (Rust `lookup::logup_constraint_values`): stage-2 - -- slot `g` holds `acc_g`, the running sum entering group `g`'s step. A - -- group of `k` consecutive lookups (the last group may be smaller) - -- asserts `(Π_j m_j)·(acc_{g+1} − acc_g) − Σ_j mult_j·Π_{j'≠j} m_{j'}`; - -- the wrap step (last group) targets the NEXT row's slot 0 plus the - -- boundary injection `is_last_row·(acc_final − acc_initial)` (`inj`), - -- which converts the cyclic telescoped sum into the public accumulator - -- difference. Group state is built in one pass with the recurrence - -- `R ← R·m + mult·P; P ← P·m` (P the message product, R the mult sum); - -- `rem` counts the group's remaining capacity, `j` the lookup index. - -- Ungrouped (k = 1) closes every step: P = m, R = (mult, 0), exactly the - -- per-lookup chained constraint. - fn logup_steps_fold(acc: Ext, alpha: Ext, lks: List‹SysLookup›, j: G, lcount: G, - g: G, rem: G, k: G, p0: Ext, p1: Ext, r0: Ext, r1: Ext, - inj0: Ext, inj1: Ext, b0: Ext, b1: Ext, g0: Ext, g1: Ext, - nodes: List‹SysNode›, - main: List‹Ext›, main_next: List‹Ext›, prep: List‹Ext›, prep_next: List‹Ext›, - s2: List‹Ext›, s2next: List‹Ext›, publics: List‹Ext›, - isf: Ext, isl: Ext, ist: Ext) -> Ext { - match load(lks) { - ListNode.Nil => acc, - ListNode.Cons(lk, rest) => - let SysLookup.Mk(mid, args) = lk; - let (f0, f1) = logup_fingerprint(args, g0, g1, nodes, - main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist); - let m0 = @eg_add(f0, b0); - let m1 = @eg_add(f1, b1); - let mv = eval_at(nodes, mid, main, main_next, prep, prep_next, s2, s2next, - publics, isf, isl, ist); - -- R ← R·m + mult·P, then P ← P·m. - let (rm0, rm1) = pair_mul(r0, r1, m0, m1); - let nr0 = @eg_add(rm0, @eg_mul(mv, p0)); - let nr1 = @eg_add(rm1, @eg_mul(mv, p1)); - let (np0, np1) = pair_mul(p0, p1, m0, m1); - match (j + 1 - lcount) { - 0 => - -- Final lookup: close the (possibly smaller) last group against - -- the wrap target. - let s0 = list_lookup(s2, g + g); - let s1 = list_lookup(s2, g + g + 1); - let t0 = @eg_add(list_lookup(s2next, 0), inj0); - let t1 = @eg_add(list_lookup(s2next, 1), inj1); - let (c0, c1) = pair_mul(np0, np1, @eg_sub(t0, s0), @eg_sub(t1, s1)); - ood_fold(ood_fold(acc, alpha, @eg_sub(c0, nr0)), alpha, @eg_sub(c1, nr1)), - _ => match rem - 1 { - 0 => - -- Group full: close against the next slot, reset the state. - let s0 = list_lookup(s2, g + g); - let s1 = list_lookup(s2, g + g + 1); - let t0 = list_lookup(s2, g + g + 2); - let t1 = list_lookup(s2, g + g + 3); - let (c0, c1) = pair_mul(np0, np1, @eg_sub(t0, s0), @eg_sub(t1, s1)); - let acc1 = ood_fold(ood_fold(acc, alpha, @eg_sub(c0, nr0)), alpha, - @eg_sub(c1, nr1)); - logup_steps_fold(acc1, alpha, rest, j + 1, lcount, - g + 1, k, k, [1, 0], [0, 0], [0, 0], [0, 0], - inj0, inj1, b0, b1, g0, g1, nodes, - main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist), - _ => - -- Keep accumulating within the group. - logup_steps_fold(acc, alpha, rest, j + 1, lcount, - g, rem - 1, k, np0, np1, nr0, nr1, - inj0, inj1, b0, b1, g0, g1, nodes, - main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist), - }, - }, - } - } - - -- The composition polynomial `composition(ζ)` for one circuit: interpret - -- the compiled node graph at each USER constraint root, then fold the - -- directly-evaluated chained-logUp step values, all Horner-folded with α - -- in the canonical protocol order. - fn ood_composition(nodes: List‹SysNode›, zeros: List‹G›, lks: List‹SysLookup›, - k: G, - main: List‹Ext›, main_next: List‹Ext›, prep: List‹Ext›, prep_next: List‹Ext›, - s2: List‹Ext›, s2next: List‹Ext›, publics: List‹Ext›, - lch: Ext, fch: Ext, accp: Ext, naccp: Ext, - isf: Ext, isl: Ext, ist: Ext, alpha: Ext, inorm: G) -> Ext { - let base = fold_roots([0, 0], alpha, zeros, nodes, - main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist); - -- The lookup-argument coordinates come straight from the challenge / - -- accumulator values (pure wiring) — `publics` is only for the node - -- graph's Public(idx) leaves; looking these 8 back out of the list cost - -- 8 calls for values already in hand. - let b0 = [lch[0], 0]; let b1 = [lch[1], 0]; - let g0 = [fch[0], 0]; let g1 = [fch[1], 0]; - let a0 = [accp[0], 0]; let a1 = [accp[1], 0]; - let na0 = [naccp[0], 0]; let na1 = [naccp[1], 0]; - -- Boundary injection: is_last_row·(acc_final − acc_initial) with the - -- selector's normalization constant 1/(n·g) absorbed into Δ (`inorm`; - -- p3's raw selector has value n·g at the last row, and Δ is constant - -- across the domain, mirroring the Rust prover/verifier). - let inj0 = @eg_mul(isl, @eg_mul(@eg_sub(na0, a0), [inorm, 0])); - let inj1 = @eg_mul(isl, @eg_mul(@eg_sub(na1, a1), [inorm, 0])); - match load(lks) { - -- No lookups: single pass-through column, acc′ − acc + inj = 0. - ListNode.Nil => - let acc = ood_fold(base, alpha, - @eg_add(@eg_sub(list_lookup(s2next, 0), list_lookup(s2, 0)), inj0)); - ood_fold(acc, alpha, - @eg_add(@eg_sub(list_lookup(s2next, 1), list_lookup(s2, 1)), inj1)), - ListNode.Cons(_h, _t) => - logup_steps_fold(base, alpha, lks, 0, list_length(lks), - 0, k, k, [1, 0], [0, 0], [0, 0], [0, 0], inj0, inj1, - b0, b1, g0, g1, nodes, - main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist), - } - } - - -- The public-input coordinates for one circuit's lookup argument: the base - -- coordinates of (β, γ, current acc, next acc), each lifted into ExtVal - -- (`EF::from(coord)`). Indexed by the compiled `Public` node index - -- (`num_publics = 4·D`, `D = 2`). - fn build_publics(lch: Ext, fch: Ext, accp: Ext, naccp: Ext) -> List‹Ext› { - store(ListNode.Cons([lch[0], 0], store(ListNode.Cons([lch[1], 0], - store(ListNode.Cons([fch[0], 0], store(ListNode.Cons([fch[1], 0], - store(ListNode.Cons([accp[0], 0], store(ListNode.Cons([accp[1], 0], - store(ListNode.Cons([naccp[0], 0], store(ListNode.Cons([naccp[1], 0], - store(ListNode.Nil))))))))))))))))) - } - - -- ========================================================================== - -- Quotient evaluation from the opened quotient row. - -- - -- The quotient is sliced by COEFFICIENTS — `Q(X) = Σᵢ X^(i·n)·cᵢ(X)` with - -- each `cᵢ` of degree < n = 2^L — and all `qd` slices of a circuit live in - -- one wide matrix on the trace domain, opened once at ζ. Recombination is - -- the plain power series - -- quotient(ζ) = Σᵢ ζ^(i·n) · cᵢ(ζ), - -- over the slice values reconstructed from the opened row - -- (`reconstruct_ext_row`, pairs of base coordinates → extension elements). - -- ========================================================================== - - -- `Σᵢ powᵢ·sliceᵢ` with `powᵢ = zeta_pow_n^i` (`pow` threads the running - -- power, starting at 1). - fn quotient_eval(slices: List‹Ext›, zeta_pow_n: Ext, pow: Ext) -> Ext { - match load(slices) { - ListNode.Nil => [0, 0], - ListNode.Cons(c, rest) => - @eg_add(@eg_mul(pow, c), quotient_eval(rest, zeta_pow_n, @eg_mul(pow, zeta_pow_n))), - } - } - - -- `quotient_degree = (max(md, 2) - 1).next_power_of_two()`. - -- Tabulated for `max_constraint_degree ≤ 17` (covers all current circuits); - -- larger degrees fall through to the `_` arm. - fn quotient_degree_of(md: G) -> G { - match md { - 0 => 1, 1 => 1, 2 => 1, - 3 => 2, - 4 => 4, 5 => 4, - 6 => 8, 7 => 8, 8 => 8, 9 => 8, - 10 => 16, 11 => 16, 12 => 16, 13 => 16, 14 => 16, 15 => 16, 16 => 16, 17 => 16, - _ => 32, - } - } - - -- The preprocessed opened rows (current, next) at ζ for circuit `i`, or - -- `(Nil, Nil)` if the circuit has no preprocessed trace. - fn ood_prep_rows(prep_opt: PreprocessedOpt, oi: OptIdx) -> (List‹Ext›, List‹Ext›) { - match oi { - OptIdx.NoIdx => (store(ListNode.Nil), store(ListNode.Nil)), - OptIdx.SomeIdx(j) => - match prep_opt { - PreprocessedOpt.NoPreprocessed => (store(ListNode.Nil), store(ListNode.Nil)), - PreprocessedOpt.SomePreprocessed(round) => - let pr = list_lookup(round, j); - (list_lookup(pr, 0), list_lookup(pr, 1)), - }, - } - } - - -- Per-circuit OOD loop: for each circuit, recompute composition(ζ) and - -- quotient(ζ) and assert `composition · inv_vanishing == quotient`. Threads - -- the running lookup accumulator `accp`. - fn ood_loop(circuits: List‹SysCircuit›, prep_indices: List‹OptIdx›, - log_degrees: List‹U8›, accs: List‹Ext›, - stage1: OpenedRound, stage2: OpenedRound, prep_opt: PreprocessedOpt, - q_opened: OpenedRound, i: G, accp: Ext, - lch: Ext, fch: Ext, alpha: Ext, zeta: Ext) -> G { - match load(circuits) { - ListNode.Nil => 1, - ListNode.Cons(circ, rest) => - let SysCircuit.Mk(nodes, _node_count, zeros, md, lks, k, mw, pw, s2w) = circ; - -- log_degrees is proof advice; bound it so `two_adic_gen`'s squaring - -- chain (bits ≤ 32) is never entered above its base case. - let ld8 = list_lookup(log_degrees, i); - assert_eq!(u8_less_than(ld8, 32u8), 1); - let l = to_field(ld8); - let qd = quotient_degree_of(md); - let naccp = list_lookup(accs, i); - let s1 = list_lookup(stage1, i); - let main = list_lookup(s1, 0); - let main_next = list_lookup(s1, 1); - let s2 = list_lookup(stage2, i); - -- Stage-2 opened rows are base columns; used directly (no pairing). - let s2row = list_lookup(s2, 0); - let s2next = list_lookup(s2, 1); - let (prep, prep_next) = @ood_prep_rows(prep_opt, list_lookup(prep_indices, i)); - -- Every opened row has the width the verifying key gives the circuit - -- (Rust: `verify_shape`). Matrices of one height share a leaf hash, - -- so the commitment alone does not fix their column boundaries; the - -- PCS then pins the query rows to these rows by width. - assert_eq!(eq_zero(list_length(main) - mw), 1); - assert_eq!(eq_zero(list_length(main_next) - mw), 1); - assert_eq!(eq_zero(list_length(s2row) - s2w), 1); - assert_eq!(eq_zero(list_length(s2next) - s2w), 1); - assert_eq!(eq_zero(list_length(prep) - pw), 1); - assert_eq!(eq_zero(list_length(prep_next) - pw), 1); - let (isf, isl, ist, invv) = @trace_selectors(zeta, l); - let publics = @build_publics(lch, fch, accp, naccp); - let inorm = @gl_inverse(pow2(l) * two_adic_gen(l)); - let comp = @ood_composition(nodes, zeros, lks, k, - main, main_next, prep, prep_next, s2row, s2next, - publics, lch, fch, accp, naccp, - isf, isl, ist, alpha, inorm); - -- circuit i's wide quotient row, its base-coordinate pairs folded back - -- into the `qd` slice values (Rust: `quotient_row.chunks_exact(D)`) - let slices = reconstruct_ext_row(list_lookup(list_lookup(q_opened, i), 0)); - assert_eq!(eq_zero(list_length(slices) - qd), 1); - let quot = quotient_eval(slices, ext_exp_pow2(zeta, l), [1, 0]); - assert_eq!(@eg_eq(@eg_mul(comp, invv), quot), 1); - ood_loop(rest, prep_indices, log_degrees, accs, stage1, stage2, prep_opt, - q_opened, i + 1, naccp, lch, fch, alpha, zeta), - } - } - - -- The fingerprint of one claim's values: `Σ vᵢ · fch^i` (each `vᵢ` lifted from - -- its raw u64 limb to an extension element). Mirrors `lookup::fingerprint`. - fn fingerprint_vals(fch: Ext, vals: List‹U64›) -> Ext { - match load(vals) { - ListNode.Nil => [0, 0], - ListNode.Cons(v, rest) => - @eg_add([@gl_val(v), 0], @eg_mul(fch, fingerprint_vals(fch, rest))), - } - } - - -- The initial lookup accumulator built from the public claims: - -- `acc = Σ_claims 1 / (lookup_challenge + fingerprint(fingerprint_challenge, claim))` - -- (Rust `verify_multiple_claims`, lines 227-232). Empty claim list → zero. - fn claims_acc(acc: Ext, claims: List‹List‹U64››, lch: Ext, fch: Ext) -> Ext { - match load(claims) { - ListNode.Nil => acc, - ListNode.Cons(c, rest) => - let msg = @eg_add(lch, fingerprint_vals(fch, c)); - claims_acc(@eg_add(acc, @eg_inverse(msg)), rest, lch, fch), - } - } - - -- 1 iff every element of `l` is boolean (0 or 1). - fn assert_bits(l: List‹G›) -> G { - match load(l) { - ListNode.Nil => 1, - ListNode.Cons(b, rest) => - assert_eq!(b * (b - 1), 0); - assert_bits(rest), - } - } - -- The verifying key's circuits at active positions, in order. - fn select_active_circuits(circuits: List‹SysCircuit›, active: List‹G›) -> List‹SysCircuit› { - match load(circuits) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(c, crest) => - let &ListNode.Cons(b, arest) = active; - match b { - 0 => select_active_circuits(crest, arest), - _ => store(ListNode.Cons(c, select_active_circuits(crest, arest))), - }, - } - } - -- The preprocessed-index entries at active positions, in order. - fn select_active_prep(prep_indices: List‹OptIdx›, active: List‹G›) -> List‹OptIdx› { - match load(prep_indices) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(p, prest) => - let &ListNode.Cons(b, arest) = active; - match b { - 0 => select_active_prep(prest, arest), - _ => store(ListNode.Cons(p, select_active_prep(prest, arest))), - }, - } - } - - -- ========================================================================== - -- Batch verification (`multi_stark::batch`): K shard proofs of one system - -- under one pair of lookup challenges. - -- - -- The batch transcript observes the seed, the shape, the preprocessed - -- commitment, the shard count, every shard header (activation bits, - -- stage-1 commitment, heights, claims) and every batch message, then - -- samples β and γ; each shard forks that state at its index and continues - -- as a single proof does from the stage-2 commitment on. A shard's final - -- accumulator is its residual; the batch balances iff the residuals plus - -- the messages' contributions sum to zero. Mirrors `System::verify_batch`. - -- - -- Aiur's policy over the batch (`aiur::shard::check_batch_policy`) is - -- checked here as well, so every consumer of a batch gets it: the - -- messages are closure pairs on the memseg channel, sorted into disjoint - -- intervals per width, - -- every shard's heights are at most 2^32, and there are at most 2^16 - -- shards — which bounds the batch's total rows below the field - -- characteristic without a circuit-to-width table. The claim policy (one - -- claim, equal to the expected one) is the caller's, as for a single proof. - -- ========================================================================== - - -- A `Val::from_usize(n)` observation: the count's 8 canonical LE bytes. - fn count_onto(n: G, tail: ByteStream) -> ByteStream { - b8_onto(@gl_to_bytes(n), tail) - } - -- Length-prefixed claims as `observe_claims` sees them: the claim count, - -- then per claim its length and raw limbs (identical to their wire bytes). - fn claims_onto(claims: List‹List‹U64››, tail: ByteStream) -> ByteStream { - count_onto(list_length(claims), claims_onto_each(claims, tail)) - } - fn claims_onto_each(claims: List‹List‹U64››, tail: ByteStream) -> ByteStream { - match load(claims) { - ListNode.Nil => tail, - ListNode.Cons(c, rest) => - count_onto(list_length(c), limbs_onto(c, claims_onto_each(rest, tail))), - } - } - -- One shard header as the batch challenger observes it: activation bits, - -- the stage-1 cap, the height count and heights, the claims. - fn header_onto(h: ShardHeader, tail: ByteStream) -> ByteStream { - let ShardHeader.Mk(active, cap, lds, claims) = h; - active_onto(active, - cap_onto(cap, - count_onto(list_length(lds), - log_degrees_onto(lds, claims_onto(claims, tail))))) - } - fn headers_onto(hs: List‹ShardHeader›, tail: ByteStream) -> ByteStream { - match load(hs) { - ListNode.Nil => tail, - ListNode.Cons(h, rest) => header_onto(h, headers_onto(rest, tail)), - } - } - -- The batch messages as observed: the count, then per message its - -- argument count, arguments and multiplicity limb. - fn messages_onto(ms: List‹BatchMessage›, tail: ByteStream) -> ByteStream { - count_onto(list_length(ms), messages_onto_each(ms, tail)) - } - fn messages_onto_each(ms: List‹BatchMessage›, tail: ByteStream) -> ByteStream { - match load(ms) { - ListNode.Nil => tail, - ListNode.Cons(m, rest) => - let BatchMessage.Mk(args, mult) = m; - count_onto(list_length(args), - limbs_onto(args, b8_onto(mult, messages_onto_each(rest, tail)))), - } - } - - -- The batch transcript through the lookup challenges (`batch_challenger`): - -- seed tag, parameter/shape limbs, the preprocessed cap, the shard count, - -- every header, the messages; sample β and observe it back, sample γ and - -- observe it back. Returns (β, γ, input): the state every shard forks from. - fn batch_fiat_shamir(tlimbs: List‹U64›, prep: MerkleCap, headers: List‹ShardHeader›, - messages: List‹BatchMessage›) -> (Ext, Ext, ByteStream) { - let input = messages_onto(messages, store(ListNode.Nil)); - let input = headers_onto(headers, input); - let input = count_onto(list_length(headers), input); - let input = cap_onto(prep, input); - let input = limbs_onto(tlimbs, input); - let input = @seed_tag_onto(input); - let (l0, l1, input, _ol) = ch_sample_ext(input, store(ListNode.Nil)); - let input = list_concat(input, b8_onto(l0, b8_onto(l1, store(ListNode.Nil)))); - let (f0, f1, input, _of) = ch_sample_ext(input, store(ListNode.Nil)); - let input = list_concat(input, b8_onto(f0, b8_onto(f1, store(ListNode.Nil)))); - ([@gl_val(l0), @gl_val(l1)], [@gl_val(f0), @gl_val(f1)], input) - } - - -- One shard's continuation of the batch transcript: observe the shard - -- index, the stage-2 commitment and the accumulators; sample α; observe - -- the quotient commitment; sample ζ. Returns (α, ζ, post-ζ input). - fn shard_fiat_shamir(input: ByteStream, shard: G, s2: MerkleCap, q: MerkleCap, - accs: List‹Ext›) -> (Ext, Ext, ByteStream) { - let input = snoc_b8(input, @gl_to_bytes(shard)); - let input = snoc_cap(input, s2); - let input = list_concat(input, accs_onto(accs, store(ListNode.Nil))); - let (a0, a1, input, _oa) = ch_sample_ext(input, store(ListNode.Nil)); - let input = snoc_cap(input, q); - let (z0, z1, zinput, _oz) = ch_sample_ext(input, store(ListNode.Nil)); - ([@gl_val(a0), @gl_val(a1)], [@gl_val(z0), @gl_val(z1)], zinput) - } - - -- Header/proof agreement. The challenges were derived from the header, so - -- the proof must be exactly the one it describes; bytes are compared as - -- field values, which is exact for range-checked bytes (both sides are - -- hashed elsewhere in this verifier, which pins them to bytes). - fn assert_same_bits(a: List‹G›, b: List‹G›) -> G { - match load(a) { - ListNode.Nil => - assert_eq!(load(b), ListNode.Nil); - 1, - ListNode.Cons(x, ra) => - let ListNode.Cons(y, rb) = load(b); - assert_eq!(x, y); - assert_same_bits(ra, rb), - } - } - fn assert_same_u8s(a: List‹U8›, b: List‹U8›) -> G { - match load(a) { - ListNode.Nil => - assert_eq!(load(b), ListNode.Nil); - 1, - ListNode.Cons(x, ra) => - let ListNode.Cons(y, rb) = load(b); - assert_eq!(to_field(x), to_field(y)); - assert_same_u8s(ra, rb), - } - } - fn assert_same_limbs(a: List‹U64›, b: List‹U64›) -> G { - match load(a) { - ListNode.Nil => - assert_eq!(load(b), ListNode.Nil); - 1, - ListNode.Cons(x, ra) => - let ListNode.Cons(y, rb) = load(b); - assert_eq!(u64_eq(x, y), 1); - assert_same_limbs(ra, rb), - } - } - fn assert_same_claims(a: List‹List‹U64››, b: List‹List‹U64››) -> G { - match load(a) { - ListNode.Nil => - assert_eq!(load(b), ListNode.Nil); - 1, - ListNode.Cons(x, ra) => - let ListNode.Cons(y, rb) = load(b); - assert_eq!(assert_same_limbs(x, y), 1); - assert_same_claims(ra, rb), - } - } - fn assert_same_cap(a: MerkleCap, b: MerkleCap) -> G { - match load(a) { - ListNode.Nil => - assert_eq!(load(b), ListNode.Nil); - 1, - ListNode.Cons(d, ra) => - let ListNode.Cons(e, rb) = load(b); - let x = load(d); - let y = load(e); - assert_eq!(u64_eq(x[0], y[0]), 1); - assert_eq!(u64_eq(x[1], y[1]), 1); - assert_eq!(u64_eq(x[2], y[2]), 1); - assert_eq!(u64_eq(x[3], y[3]), 1); - assert_same_cap(ra, rb), - } - } - - -- The last intermediate accumulator: the shard's residual. - fn last_acc(accs: List‹Ext›) -> Ext { - let ListNode.Cons(e, rest) = load(accs); - match load(rest) { - ListNode.Nil => e, - _ => last_acc(rest), - } - } - - -- `Σ multiplicity · (β + fingerprint(γ, args))⁻¹` over the batch messages. - -- The multiplicity limb is reduced mod p, so `p − 1` reads as `−1`. - fn messages_acc(acc: Ext, ms: List‹BatchMessage›, lch: Ext, fch: Ext) -> Ext { - match load(ms) { - ListNode.Nil => acc, - ListNode.Cons(m, rest) => - let BatchMessage.Mk(args, mult) = m; - let msg = @eg_add(lch, fingerprint_vals(fch, args)); - let term = @eg_mul(@eg_inverse(msg), [@gl_val(mult), 0]); - messages_acc(@eg_add(acc, term), rest, lch, fch), - } - } - - -- ---- Aiur's batch policy ---- - - -- 1 iff `ld ≤ 32`, the largest trace height the Goldilocks PCS can serve. - fn log_degree_ok(ld: U8) -> G { - match to_field(ld) { - 0 => 1, 1 => 1, 2 => 1, 3 => 1, 4 => 1, 5 => 1, 6 => 1, 7 => 1, 8 => 1, - 9 => 1, 10 => 1, 11 => 1, 12 => 1, 13 => 1, 14 => 1, 15 => 1, 16 => 1, - 17 => 1, 18 => 1, 19 => 1, 20 => 1, 21 => 1, 22 => 1, 23 => 1, 24 => 1, - 25 => 1, 26 => 1, 27 => 1, 28 => 1, 29 => 1, 30 => 1, 31 => 1, 32 => 1, - _ => 0, - } - } - fn assert_log_degrees_ok(lds: List‹U8›) -> G { - match load(lds) { - ListNode.Nil => 1, - ListNode.Cons(ld, rest) => - assert_eq!(log_degree_ok(ld), 1); - assert_log_degrees_ok(rest), - } - } - -- The number of active circuits a header declares. - fn count_ones(bits: List‹G›) -> G { - match load(bits) { - ListNode.Nil => 0, - ListNode.Cons(b, rest) => b + count_ones(rest), - } - } - -- `1 ≤ k ≤ 2^16`: the canonical bytes of `k` vanish above byte 2, and byte 2 - -- is boolean with the low bytes zero when it is set. - fn assert_shard_count_ok(k: G) -> G { - assert_eq!(eq_zero(k), 0); - let b = @gl_to_bytes(k); - assert_eq!(to_field(b[3]) + to_field(b[4]) + to_field(b[5]) + to_field(b[6]) + to_field(b[7]), 0); - let hi = to_field(b[2]); - assert_eq!(hi * (hi - 1), 0); - assert_eq!(hi * (to_field(b[0]) + to_field(b[1])), 0); - 1 - } - -- Exactly three limbs. - fn three_limbs(args: List‹U64›) -> (U64, U64, U64) { - let ListNode.Cons(a, r1) = load(args); - let ListNode.Cons(b, r2) = load(r1); - let ListNode.Cons(c, r3) = load(r2); - assert_eq!(load(r3), ListNode.Nil); - (a, b, c) - } - -- `x ≤ y` as integers, one byte of each little-endian pair at a time: - -- 1 iff `xi < yi`, or `xi = yi` and the lower bytes say `rest`. - fn le_step(xi: U8, yi: U8, rest: G) -> G { - u8_less_than(xi, yi) + eq_zero(to_field(xi) - to_field(yi)) * rest - } - -- 1 iff `x ≤ y` as integers, both given as range-checked little-endian - -- bytes (`gl_to_bytes`), compared from the most significant byte down. - fn bytes8_le(x: [U8; 8], y: [U8; 8]) -> G { - le_step(x[7], y[7], le_step(x[6], y[6], le_step(x[5], y[5], - le_step(x[4], y[4], le_step(x[3], y[3], le_step(x[2], y[2], - le_step(x[1], y[1], le_step(x[0], y[0], 1)))))))) - } - -- The memseg closure pairs (`aiur::memseg_channel` = 16): a pull of an - -- interval's first pointer `a` with multiplicity −1 and a push of one - -- past its last `b` with multiplicity 1, the same width in both and - -- `a ≤ b`; the pairs sorted by width and, within a width, into disjoint - -- intervals (`b` of one at most `a` of the next). Widths and pointers - -- compare as the integers their canonical field values are. `prev_w` - -- and `prev_b` are the previous pair's width and end, `(0, 0)` before - -- the first: every width is at least one. - fn assert_closure_pairs(ms: List‹BatchMessage›, prev_w: G, prev_b: G) -> G { - match load(ms) { - ListNode.Nil => 1, - ListNode.Cons(pull, rest1) => - let ListNode.Cons(push, rest) = load(rest1); - let BatchMessage.Mk(pargs, pmult) = pull; - let BatchMessage.Mk(qargs, qmult) = push; - assert_eq!(@gl_val(pmult) + 1, 0); - assert_eq!(@gl_val(qmult), 1); - let (pc, pw, pa) = three_limbs(pargs); - let (qc, qw, qb) = three_limbs(qargs); - assert_eq!(@gl_val(pc), 16); - assert_eq!(@gl_val(qc), 16); - let w = @gl_val(pw); - assert_eq!(@gl_val(qw), w); - let a = @gl_val(pa); - let b = @gl_val(qb); - assert_eq!(bytes8_le(@gl_to_bytes(a), @gl_to_bytes(b)), 1); - -- `prev_w < w`, or the same width with `prev_b ≤ a`; the two - -- summands are exclusive, since equal widths are not increasing. - let same_w = eq_zero(w - prev_w); - let w_up = 1 - bytes8_le(@gl_to_bytes(w), @gl_to_bytes(prev_w)); - assert_eq!( - w_up + same_w * bytes8_le(@gl_to_bytes(prev_b), @gl_to_bytes(a)), 1); - assert_closure_pairs(rest, w, b), - } - } - - -- Verify shard `shard` against its header under the batch challenges and - -- return its residual. Mirrors `verify_batch_shard`: shape, header - -- agreement, the shard's transcript fork, the OOD identity, the PCS. - fn verify_shard(sys: Sys, header: ShardHeader, shard: G, proof: Proof, - input: ByteStream, lch: Ext, fch: Ext) -> Ext { - let Sys.Mk(params, _tlimbs, circuits, commit, prep_indices) = sys; - let SysParams.Mk(log_blowup, cap_height, log_final_poly_len, - max_log_arity, num_queries, commit_pow_bits, - query_pow_bits) = params; - assert_eq!(cap_height, 0); - assert_eq!(log_final_poly_len, 0); - assert_eq!(max_log_arity, 1); - let ShardHeader.Mk(h_active, h_cap, h_lds, h_claims) = header; - let Proof.Mk(active, commitments, accs, log_degrees, opening, - q_opened, prep_opt, stage1, stage2) = proof; - let num_circuits = list_length(accs); - assert_eq!(eq_zero(num_circuits), 0); - assert_eq!(list_length(stage1), num_circuits); - assert_eq!(list_length(stage2), num_circuits); - assert_eq!(list_length(q_opened), num_circuits); - assert_eq!(assert_bits(active), 1); - assert_eq!(eq_zero(list_length(active) - list_length(circuits)), 1); - let acirc = select_active_circuits(circuits, active); - let aprep = select_active_prep(prep_indices, active); - assert_eq!(eq_zero(list_length(acirc) - list_length(accs)), 1); - let Commitments.Mk(s1c, s2c, qc) = commitments; - assert_eq!(assert_same_bits(h_active, active), 1); - assert_eq!(assert_same_cap(h_cap, s1c), 1); - assert_eq!(assert_same_u8s(h_lds, log_degrees), 1); - assert_eq!(assert_log_degrees_ok(log_degrees), 1); - assert_eq!(count_ones(active), list_length(log_degrees)); - let prep_cap = @opt_commit_cap(commit); - let (alpha, zeta, post_zeta_input) = shard_fiat_shamir(input, shard, s2c, qc, accs); - let acc0 = claims_acc([0, 0], h_claims, lch, fch); - let _ood = ood_loop(acirc, aprep, log_degrees, accs, stage1, stage2, - prep_opt, q_opened, 0, acc0, lch, fch, alpha, zeta); - assert_eq!(@pcs_fri_verify(post_zeta_input, stage1, stage2, q_opened, prep_opt, opening, - s1c, s2c, qc, prep_cap, aprep, log_degrees, zeta, - list_length(acirc), log_blowup, num_queries, commit_pow_bits, - query_pow_bits), 1); - last_acc(accs) - } - -- Verify every shard in order, accumulating residuals into `acc`. - fn verify_shards(sys: Sys, headers: List‹ShardHeader›, proofs: List‹Proof›, shard: G, - input: ByteStream, lch: Ext, fch: Ext, acc: Ext) -> Ext { - match load(headers) { - ListNode.Nil => - assert_eq!(load(proofs), ListNode.Nil); - acc, - ListNode.Cons(h, hrest) => - let ListNode.Cons(p, prest) = load(proofs); - let r = verify_shard(sys, h, shard, p, input, lch, fch); - verify_shards(sys, hrest, prest, shard + 1, input, lch, fch, @eg_add(acc, r)), - } - } - -- All claims of the batch, in shard order. - fn batch_claims(headers: List‹ShardHeader›) -> List‹List‹U64›› { - match load(headers) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(h, rest) => - let ShardHeader.Mk(_active, _cap, _lds, claims) = h; - list_concat(claims, batch_claims(rest)), - } - } - - -- Verify a whole batch: policy, the batch transcript, every shard, and the - -- residual balance. Returns the batch's claims for the caller to bind. - fn verify_batch(sys: Sys, batch: Batch) -> List‹List‹U64›› { - let Batch.Mk(headers, messages, proofs) = batch; - assert_eq!(assert_shard_count_ok(list_length(headers)), 1); - assert_eq!(list_length(proofs), list_length(headers)); - assert_eq!(assert_closure_pairs(messages, 0, 0), 1); - let Sys.Mk(_params, tlimbs, _circuits, commit, _prep_indices) = sys; - let prep_cap = @opt_commit_cap(commit); - let (lch, fch, input) = batch_fiat_shamir(tlimbs, prep_cap, headers, messages); - let acc = messages_acc([0, 0], messages, lch, fch); - let total = verify_shards(sys, headers, proofs, 0, input, lch, fch, acc); - assert_eq!(@ext_is_zero(total), 1); - batch_claims(headers) - } - - -- Read the batch at channel-0 offset `idx` (asserting the stream is fully - -- consumed at `idx + len`), verify it, and bind its claims to `claims` - -- (the digest-bound claims of the caller's channel). Returns 1. - fn verify_batch_at(sys: Sys, idx: G, len: G, claims: List‹List‹U64››) -> G { - let (batch, stop) = @read_batch(idx); - assert_eq!(stop, idx + len); - let found = verify_batch(sys, batch); - assert_eq!(assert_same_claims(found, claims), 1); - 1 - } - - -- Read the public claims from the verifier's IO channel. Wire format (set by - -- the prover-side harness): u64 `num_claims`, then per claim a u64 `num_vals` - -- followed by `num_vals` raw `u64` `Val`s (8 LE bytes each, canonical < p). - fn read_claims(stream: ByteStream) -> (List‹List‹U64››, ByteStream) { - let (n, s) = read_count(stream); - read_claims_n(s, n) - } - fn read_claims_n(stream: ByteStream, n: G) -> (List‹List‹U64››, ByteStream) { - match n { - 0 => (store(ListNode.Nil), stream), - _ => - let (c, s) = @read_one_claim(stream); - let (rest, s2) = read_claims_n(s, n - 1); - (store(ListNode.Cons(c, rest)), s2), - } - } - fn read_one_claim(stream: ByteStream) -> (List‹U64›, ByteStream) { - let (m, s) = read_count(stream); - read_claim_vals_n(s, m) - } - fn read_claim_vals_n(stream: ByteStream, n: G) -> (List‹U64›, ByteStream) { - match n { - 0 => (store(ListNode.Nil), stream), - _ => - let (x, s) = read_u64(stream); - let (rest, s2) = read_claim_vals_n(s, n - 1); - (store(ListNode.Cons(x, rest)), s2), - } - } -⟧ - -end MultiStark - -end diff --git a/MultiStark/VerifierFunctionGroups.lean b/MultiStark/VerifierFunctionGroups.lean deleted file mode 100644 index 12fda10f6..000000000 --- a/MultiStark/VerifierFunctionGroups.lean +++ /dev/null @@ -1,190 +0,0 @@ -module - -/-! -Function-grouping data for the standalone Multi-STARK verifier toplevel -(`MultiStark.multiStark`), applied wherever it is compiled for proving or -verifying (see `CompiledToplevel.groupFunctions`). Empty = no grouping: -every constrained function keeps its singleton circuit. Fill from measured -workload statistics; a stale grouping stays sound (grouping never affects -semantics), only less efficient. --/ - -public section - -namespace MultiStark - --- Retain the measured verifier groups, removing members reachable only --- from the retired join entrypoints. Group names remain stable. -def verifierFunctionGroups : Array (String × Array String) := #[ - ("verifier_group_00", #[ - "memo_u32_less_than", - "u64_is_zero", - "relaxed_u64_succ", - "flatten_u64", - "read_sys_lookups_n", - "frontier_merge", - "frontier_split", - "frontier_sort", - "frontier_leaves", - "rows_at_round", - "limbs_onto", - "from_ext_basis" - ]), - ("verifier_group_02", #[ - "read_u8", - "read_digest_vec_at", - "read_vk_u32_limb", - "read_field", - "lookup_groups_count", - "assert_blowup_zero", - "ext_exp_pow2", - "reconstruct_ext_row", - "assert_bits", - "select_active_circuits", - "select_active_prep", - "list_length.SysCircuit" - ]), - ("verifier_group_03", #[ - "read_u64", - "blake3_next_layer", - "blake3_compress_layer", - "read_vk_u64", - "mmcs_verify_multi", - "pcs_check_witness", - "open_prep_batch", - "query_loop", - "verify_commit_multi", - "ch_sample_field", - "ch_sample_ext", - "snoc_b8", - "logup_steps_fold" - ]), - ("verifier_group_04", #[ - "read_count", - "read_opened_round", - "read_batch_opening_vec_n", - "read_commit_phase_step_vec_n", - "read_preprocessed", - "mmcs_compress", - "pcs_betas", - "verify_query", - "cap_onto", - "ch_sample_bits", - "fingerprint_vals", - "read_claim_vals_n", - "list_length.Bucket", - "list_concat.U8_8" - ]), - ("verifier_group_05", #[ - "read_count_at", - "list_drop.SysNode" - ]), - ("verifier_group_06", #[ - "read_active_n", - "read_u64_vec_vec_vec_n", - "read_opened_round_n", - "b3_w4_onto", - "frontier_fold", - "circ_has_height", - "heights_all", - "heights_prep", - "batch_views_at", - "step_views_at", - "drop_index_bits", - "take_bits" - ]), - ("verifier_group_07", #[ - "read_u64_vec", - "list_length.Ptr.U8_8_4" - ]), - ("verifier_group_08", #[ - "read_ext_vec", - "read_ext_vec_vec", - "read_ext_vec_vec_n", - "pad_block", - "read_vk_u16_limb", - "has_height", - "bits_to_num", - "exp_by_bits", - "points_onto", - "round_onto", - "log_degrees_onto" - ]), - ("verifier_group_09", #[ - "read_ext_vec_n", - "pair_mul" - ]), - ("verifier_group_10", #[ - "read_digest_vec_at_n", - "read_merkle_cap_vec_n", - "read_opt_idx_n", - "leaf_hash_at", - "fri_fold2", - "obs_log_arities", - "build_buckets", - "rollin", - "sample_query_indices", - "query_views", - "snoc_cap", - "two_adic_gen", - "pow2", - "quotient_eval", - "list_length.CommitPhaseMultiStep" - ]), - ("verifier_group_11", #[ - "read_u64_vec_vec_n", - "read_node_ids_n" - ]), - ("verifier_group_12", #[ - "bytes_to_block", - "blake3_finish", - "blake3_compress_block", - "read_sys_circuits_n", - "ch_sample8", - "ood_loop" - ]), - ("verifier_group_13", #[ - "read_vk_cap_n", - "read_opt_commit", - "prep_count", - "heights_max", - "verify_one_query", - "verify_input_multi", - "quotient_degree_of", - "claims_acc", - "read_claims_n", - "list_length.FrontierNode" - ]), - ("verifier_group_14", #[ - "compress_ordered", - "ood_fold" - ]), - ("verifier_group_15", #[ - "select_rows_le", - "frontier_level", - "accs_onto" - ]), - ("verifier_group_16", #[ - "inject_maybe", - "rev_onto", - "list_lookup.G_2", - "list_drop.G_2" - ]), - ("verifier_group_17", #[ - "open_2pt_mat", - "open_batch_2pt", - "open_quotient", - "open_prep", - "fold_roots", - "logup_fingerprint" - ]), - ("verifier_group_19", #[ - "list_lookup.BatchOpening", - "list_length.CommitPhaseProofStep", - "list_drop.G" - ]) -] - -end MultiStark - -end diff --git a/MultiStark/lake-manifest.json b/MultiStark/lake-manifest.json new file mode 100644 index 000000000..7a9db199f --- /dev/null +++ b/MultiStark/lake-manifest.json @@ -0,0 +1,103 @@ +{"version": "1.2.0", + "packagesDir": ".lake/packages", + "packages": + [{"type": "path", + "scope": "", + "name": "aiur", + "manifestFile": "lake-manifest.json", + "inherited": false, + "dir": "../Aiur", + "configFile": "lakefile.lean"}, + {"url": "https://github.com/leanprover-community/mathlib4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "name": "mathlib", + "manifestFile": "lake-manifest.json", + "inputRev": "v4.34.1", + "inherited": true, + "configFile": "lakefile.lean"}, + {"url": "https://github.com/leanprover-community/plausible", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c", + "name": "plausible", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/LeanSearchClient", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707", + "name": "LeanSearchClient", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/import-graph", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "e928b72544873815af278d38681b31c0293588e3", + "name": "importGraph", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/ProofWidgets4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5", + "name": "proofwidgets", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.lean"}, + {"url": "https://github.com/leanprover-community/aesop", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "355695d523e41d0554926416cba2a2b3544fbbc9", + "name": "aesop", + "manifestFile": "lake-manifest.json", + "inputRev": "master", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/quote4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259", + "name": "Qq", + "manifestFile": "lake-manifest.json", + "inputRev": "master", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/batteries", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2", + "name": "batteries", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover/lean4-cli", + "type": "git", + "subDir": null, + "scope": "leanprover", + "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204", + "name": "Cli", + "manifestFile": "lake-manifest.json", + "inputRev": "v4.34.0", + "inherited": true, + "configFile": "lakefile.toml"}], + "name": "multiStark", + "lakeDir": ".lake", + "fixedToolchain": false} diff --git a/MultiStark/lakefile.lean b/MultiStark/lakefile.lean new file mode 100644 index 000000000..26a424a50 --- /dev/null +++ b/MultiStark/lakefile.lean @@ -0,0 +1,14 @@ +import Lake +open System Lake DSL + +package multiStark where + version := v!"0.1.0" + +require aiur from "../Aiur" + +@[default_target] +lean_lib MultiStark + +lean_exe «stark-export» where + root := `MultiStark.Main + supportInterpreter := true diff --git a/MultiStark/lean-toolchain b/MultiStark/lean-toolchain new file mode 100644 index 000000000..ba8ebf2db --- /dev/null +++ b/MultiStark/lean-toolchain @@ -0,0 +1 @@ +leanprover/lean4:v4.34.1 diff --git a/README.md b/README.md index 3c714d2a0..f93cab683 100644 --- a/README.md +++ b/README.md @@ -34,6 +34,10 @@ transactions over proofs. > :warning: **This repository is a pre-alpha work in progress and should not be used for any purpose.** +The formal Aiur compiler and runtime now live in separate Lean and Rust packages. +See [the migration guide](docs/formal-aiur-migration.md) for their build commands +and the boundary around the retained legacy implementation. + ## Use Cases Our expectation is that Ix, and **zkPCC** in general, will allow applications to frictionlessly ship @@ -164,7 +168,7 @@ Ix consists of the following core components: The compiler also includes a decompiler to convert `ixon` objects back into Lean programs (by preserving the alpha-relevant metadata in a separate ixon object and re-merging the computationally relevant and irrelevant parts). -- The [Aiur zkDSL](https://github.com/argumentcomputer/ix/tree/main/Ix/Aiur) +- The [Aiur zkDSL](https://github.com/argumentcomputer/ix/tree/main/Aiur) which is a first-order functional programming language that generates multi-STARK circuits. - The IxVM (not yet released), which implements reduction and typechecking diff --git a/Scripts/Performance/FunctionGrouping.lean b/Scripts/Performance/FunctionGrouping.lean deleted file mode 100644 index 490fe9f1c..000000000 --- a/Scripts/Performance/FunctionGrouping.lean +++ /dev/null @@ -1,162 +0,0 @@ -import Ix.IxVM.Toplevel -import Ix.IxVM.FunctionGroups -import Ix.Aggr -import Ix.Aiur.Statistics -import Lean.Data.Json - -/-! Native function-group validation and cost comparison without Rust/CUDA -regeneration. `check ixvm|aggr` checks the production partition and preserves -the complete function library. `measure KIND BEFORE AFTER PROFILE OUTPUT` -compares two JSON arrays of `(groupName, memberNames)` pairs; `-` selects the -production groups. PROFILE contains the per-function rows, names and layouts -reported by the execution profiler. It must describe the same function -library; its digest, indices, names and layouts are checked. The digest is -a stale-profile diagnostic, separate from the function-preservation checks. - -The report uses actual synthesized AIR shapes, raw and power-of-two padded -function FFT costs, active committed width and serialized VK size. Function -heights are unchanged by grouping; memory/gadget costs are unchanged and are -excluded from the function cost totals. Proofs and security parameters are -not modified by this fixture. --/ - -namespace FunctionGrouping - -open Aiur Lean - -private abbrev Groups := Array (String × Array String) - -private structure FunctionProfile where - index : Nat - names : Array String - rows : Nat - inputs : Nat - selectors : Nat - auxiliaries : Nat - lookups : Nat - constrained : Bool - deriving FromJson, Inhabited - -private structure Profile where - libraryDigest : String - functions : Array FunctionProfile - deriving FromJson - -private def libraryDigest (compiled : CompiledToplevel) : String := - toString (Address.blake3 (reprStr (compiled.bytecode.functions, compiled.bytecode.memorySizes)).toUTF8) - -private def compileProgram (kind : String) : IO (CompiledToplevel × Groups) := do - let (top, groups) ← match kind with - | "ixvm" => do - let top ← IO.ofExcept (IxVM.ixVM.mapError toString) - pure (top, IxVM.functionGroups) - | "aggr" => do - let top ← IO.ofExcept (Aggr.ixAggr.mapError toString) - pure (top, Aggr.functionGroups) - | _ => throw (IO.userError "expected ixvm or aggr") - return (← IO.ofExcept top.compile, groups) - -private def readGroups (path : String) (production : Groups) : IO Groups := do - if path == "-" then return production - let json ← IO.ofExcept (Json.parse (← IO.FS.readFile path)) - IO.ofExcept (fromJson? json) - -private def validate (raw grouped : CompiledToplevel) : IO Unit := do - unless raw.bytecode.memorySizes == grouped.bytecode.memorySizes && - raw.bytecode.functions.size == grouped.bytecode.functions.size && - raw.nameMap.size == grouped.nameMap.size do - throw (IO.userError "grouping changed the program interface") - for (name, index) in raw.nameMap do - unless grouped.nameMap.get? name == some index do - throw (IO.userError s!"grouping changed function index {name}") - for (before, after) in raw.bytecode.functions.zip grouped.bytecode.functions do - unless before.body == after.body && before.layout == after.layout && - before.entry == after.entry && before.constrained == after.constrained do - throw (IO.userError "grouping changed a function body, layout or execution flag") - let mut seen : Std.HashSet Nat := {} - for circuit in grouped.bytecode.circuits do - unless !circuit.members.isEmpty do throw (IO.userError "empty circuit") - for index in circuit.members do - let some func := grouped.bytecode.functions[index]? - | throw (IO.userError "circuit member is outside the function library") - unless func.constrained && !seen.contains index && - (!func.entry || circuit.members.size == 1) do - throw (IO.userError "duplicate, unconstrained or grouped entry function") - seen := seen.insert index - for index in [:raw.bytecode.functions.size] do - unless seen.contains index == raw.bytecode.functions[index]!.constrained do - throw (IO.userError "the partition does not cover exactly the constrained functions") - -private def readRows (raw : CompiledToplevel) (path : String) : IO (Array Nat) := do - let json ← IO.ofExcept (Json.parse (← IO.FS.readFile path)) - let profile : Profile ← IO.ofExcept (fromJson? json) - unless profile.libraryDigest == libraryDigest raw do - throw (IO.userError "profile function-library digest does not match the compiled program") - unless profile.functions.size == raw.bytecode.functions.size do - throw (IO.userError "profile has a different function count") - let byName := raw.nameMap.fold (init := ({} : Std.HashMap String Nat)) - fun map name index => map.insert (toString name) index - for index in [:profile.functions.size] do - let row := profile.functions[index]! - let func := raw.bytecode.functions[index]! - unless row.index == index && !row.names.isEmpty && - row.names.all (fun name => byName.get? name == some index) && - row.inputs == func.layout.inputSize && row.selectors == func.layout.selectors && - row.auxiliaries == func.layout.auxiliaries && row.lookups == func.layout.lookups && - row.constrained == func.constrained do - throw (IO.userError s!"profile index, names or layout differ at function {index}") - return profile.functions.map (·.rows) - -private def reportGroups (raw : CompiledToplevel) (groups : Groups) - (rows : Option (Array Nat)) : IO Json := do - let compiled ← IO.ofExcept (raw.groupFunctions groups) - validate raw compiled - let system ← IO.lazyPure fun _ => AiurSystem.build compiled.bytecode - defaultCommitmentParameters defaultFriParameters - let shapes := system.circuitShapes - let mut activeWidth := 0 - let mut cost := 0.0 - let mut paddedCost := 0.0 - let mut circuits : Array Json := #[] - for index in [:compiled.bytecode.circuits.size] do - let circuit := compiled.bytecode.circuits[index]! - let shape := shapes[index]! - let height := rows.map fun counts => circuit.members.foldl (fun n i => n + counts[i]!) 0 - if let some h := height then - if h > 0 then activeWidth := activeWidth + shape.committedWidth - cost := cost + fftCost shape h defaultCommitmentParameters.logBlowup - let padded := if h == 0 then 0 else Nat.nextPowerOfTwo h - paddedCost := paddedCost + fftCost shape padded defaultCommitmentParameters.logBlowup - circuits := circuits.push (Json.mkObj [ - ("name", toJson circuit.name), ("members", toJson circuit.members), - ("height", toJson height), ("mainWidth", toJson shape.mainWidth), - ("stage2Width", toJson shape.stage2Width), ("quotientDegree", toJson shape.quotientDegree), - ("committedWidth", toJson shape.committedWidth)]) - return Json.mkObj [ - ("libraryDigest", toJson (libraryDigest raw)), - ("functionLibraryUnchanged", toJson true), ("functionCount", toJson raw.bytecode.functions.size), - ("circuitCount", toJson circuits.size), ("vkBytes", toJson system.vkBytes.size), - ("totalCommittedWidth", toJson (shapes.foldl (fun n s => n + s.committedWidth) 0)), - ("hasProfile", toJson rows.isSome), ("activeFunctionWidth", toJson activeWidth), - ("functionFftCost", toJson cost), ("paddedFunctionFftCost", toJson paddedCost), - ("circuits", toJson circuits)] - -def run (args : List String) : IO Unit := do - match args with - | ["check", kind] => - let (raw, groups) ← compileProgram kind - let report ← reportGroups raw groups none - IO.println report.compress - | ["measure", kind, before, after, profile, output] => - let (raw, production) ← compileProgram kind - let rows ← readRows raw profile - let baseline ← reportGroups raw (← readGroups before production) (some rows) - let candidate ← reportGroups raw (← readGroups after production) (some rows) - IO.FS.writeFile output (Json.mkObj [("baseline", baseline), ("candidate", candidate)]).pretty - IO.println s!"Grouping comparison written to {output}; function library and partition validated" - | _ => throw (IO.userError - "expected check ixvm|aggr, or measure KIND BEFORE_GROUPS AFTER_GROUPS PROFILE OUTPUT") - -end FunctionGrouping - -def main (args : List String) : IO Unit := FunctionGrouping.run args diff --git a/Scripts/Performance/ProvingProfile.lean b/Scripts/Performance/ProvingProfile.lean deleted file mode 100644 index eb49246ee..000000000 --- a/Scripts/Performance/ProvingProfile.lean +++ /dev/null @@ -1,87 +0,0 @@ -import Ix.IxVM.Toplevel -import Ix.IxVM.FunctionGroups -import Ix.Aiur.Statistics -import Ix.Ixon -import Lean.Data.Json - -/-! Per-function query heights and actual AIR shapes for full-closure IxVM -claims. Arguments: `IXE CONSTANT OUTPUT_JSON`. Execution always uses the -generic bytecode backend, so source and grouping changes can be profiled -before regenerating native Rust/CUDA. Its elapsed time is a diagnostic, not -a native-execution benchmark; query counts and FFT costs are comparable. - -The JSON is the input of `Scripts/Performance/FunctionGrouping.lean`. -The system uses the benchmark's recursive parameters: blowup 4, 50 queries, -and zero proof-of-work bits. No dependency, role, or admission check is skipped. --/ - -open Lean (Json toJson) - -/-- A stale-profile diagnostic over the complete function library. Circuit -grouping is excluded so the same execution counts can evaluate new groups. -/ -private def libraryDigest (compiled : Aiur.CompiledToplevel) : String := - toString (Address.blake3 (reprStr (compiled.bytecode.functions, compiled.bytecode.memorySizes)).toUTF8) - -private def profile (compiled : Aiur.CompiledToplevel) (queries : Array Aiur.QueryCount) - (shapes : Array Aiur.CircuitShape) (metadata : List (String × Json)) : Json := Id.run do - let mut names : Std.HashMap Nat (Array String) := {} - for (name, index) in compiled.nameMap do - let old := names.getD index #[] - names := names.erase index - names := names.insert index (old.push (toString name)) - let functions := compiled.bytecode.functions.mapIdx fun i f => - let q := queries[i]! - Json.mkObj [ - ("index", toJson i), ("names", toJson (names.getD i #[])), - ("rows", toJson q.uniqueRows), ("hits", toJson q.totalHits), - ("constrained", toJson f.constrained), - ("inputs", toJson f.layout.inputSize), ("selectors", toJson f.layout.selectors), - ("auxiliaries", toJson f.layout.auxiliaries), ("lookups", toJson f.layout.lookups)] - let circuits := compiled.bytecode.circuits.mapIdx fun i c => - let shape := shapes[i]! - let rows := c.members.foldl (fun n j => n + queries[j]!.uniqueRows) 0 - Json.mkObj [ - ("name", toJson c.name), ("members", toJson c.members), ("rows", toJson rows), - ("mainWidth", toJson shape.mainWidth), ("stage2Width", toJson shape.stage2Width), - ("quotientDegree", toJson shape.quotientDegree), - ("committedWidth", toJson shape.committedWidth), - ("fftCost", toJson (Aiur.fftCost shape rows 2))] - return Json.mkObj (metadata ++ [("functions", Json.arr functions), ("circuits", Json.arr circuits)]) - -def main (args : List String) : IO Unit := do - let [path, label, output] := args | throw (IO.userError "expected IXE NAME OUTPUT") - let toplevel ← IO.ofExcept IxVM.ixVM - let compiled ← IO.ofExcept (toplevel.compileWithGroups IxVM.functionGroups) - let some entry := compiled.getFuncIdx `verify_claim | throw (IO.userError "missing verify_claim") - let some check := compiled.getFuncIdx `check_const | throw (IO.userError "missing check_const") - let handle ← IO.ofExcept (Aiur.EnvHandle.fromIxe path) - let bytes ← IO.FS.readBinFile path - let env ← IO.ofExcept (Ixon.deEnvAnon bytes) - let address ← match env.named.get? (Ix.Name.fromLeanName label.toName) with - | some named => pure named.addr - | none => match env.named.toArray.find? (fun (name, _) => toString name == label) with - | some (_, named) => pure named.addr - | none => throw (IO.userError s!"missing {label}") - let system := Aiur.AiurSystem.build compiled.bytecode { logBlowup := 2, capHeight := 0 } - { logFinalPolyLen := 0, maxLogArity := 1, numQueries := 50, - commitProofOfWorkBits := 0, queryProofOfWorkBits := 0 } - let shapes := system.circuitShapes - IO.println s!"profiling {label}: functions={compiled.bytecode.functions.size} circuits={shapes.size}" - (← IO.getStdout).flush - let start ← IO.monoMsNow - let (_, _, queries) ← IO.ofExcept (← IO.lazyPure fun _ => - compiled.bytecode.checkAddrWithEnv entry handle address.hash true) - let elapsed := (← IO.monoMsNow) - start - let stats := Aiur.computeStats compiled queries shapes 2 - IO.println s!"{label}: constants={queries[check]!.uniqueRows} fft={stats.totalFftCost} interp-ms={elapsed}" - Aiur.printStats stats - let metadata := [ - ("libraryDigest", toJson (libraryDigest compiled)), - ("input", Json.mkObj [("path", toJson path), ("bytes", toJson bytes.size), - ("binding", toJson (env.roleBinding.map (fun b => toString b.address))), - ("constant", toJson label)]), - ("executionBackend", toJson "bytecode"), - ("constants", toJson queries[check]!.uniqueRows), - ("totalFftCost", toJson stats.totalFftCost), - ("logBlowup", toJson (2 : Nat)), ("numQueries", toJson (50 : Nat))] - IO.FS.writeFile output ((profile compiled queries shapes metadata).pretty ++ "\n") diff --git a/Scripts/SourceHygiene.lean b/Scripts/SourceHygiene.lean index 3ca3c487c..cbc4e30d5 100644 --- a/Scripts/SourceHygiene.lean +++ b/Scripts/SourceHygiene.lean @@ -95,8 +95,8 @@ def sourceFile (path : System.FilePath) : Bool := def files : IO (Array System.FilePath) := do let mut result : Array System.FilePath := - #["Ix.lean", "Main.lean", "Tests.lean", "Apps.lean", "MultiStark.lean", "README.md", "lakefile.lean"] - for root in ["Ix", "IxC", "IxSharingVerify", "Tests", "crates", "docs", "Benchmarks", "Apps", "MultiStark"] do + #["Ix.lean", "Main.lean", "Tests.lean", "Apps.lean", "README.md", "lakefile.lean"] + for root in ["Ix", "IxC", "IxSharingVerify", "Tests", "crates", "docs", "Benchmarks", "Apps", "Aiur", "IxVM", "MultiStark"] do for path in ← System.FilePath.walkDir root (fun p => pure (!([".lake", "target", ".git"].contains (p.fileName.getD "")))) do if sourceFile path then result := result.push path diff --git a/Tests/Aggr.lean b/Tests/Aggr.lean deleted file mode 100644 index 026b09eba..000000000 --- a/Tests/Aggr.lean +++ /dev/null @@ -1,1106 +0,0 @@ -module - -public import LSpec -public import Ix.Aggr -public import Ix.Aiur.Compiler -public import Ix.Claim -public import Ix.AssumptionTree -public import Ix.Aggr.Reference -public import Ix.Aggr.CatalogPlan -public import Ix.ClaimContext -public import Tests.ProofHelpers - -/-! -# Tests for the heterogeneous `ix_aggr` circuit - -`ix-aggr` — `smokeSuite`. Executes the production `ix_aggr` entrypoint (the -pure-Lean interpreter over a Lean-built IO buffer) across all thirteen shapes, with -real Multi-STARK child proofs from two cheap stand-in systems: - -* a "fake IxVM" system whose `fake_verify_claim` reproduces `verify_claim`'s - 10-word claim layout, and -* a "fake self" system (same bytecode, different FRI parameters, hence a - different verifying key) whose `fake_aggr` reproduces `ix_aggr`'s 18-word - claim layout. - -The circuit under test still verifies real proofs and enforces every binding: -per-kind vk digests, entrypoint indices, the transitive allowed digest of self -children, wrap digest pass-through, canonical union/difference folding, and -structural root/path folding. The negative cases each break exactly one of -those bindings. - -Proving the real `ix_aggr` system recursively (self children that are actual -`ix_aggr` proofs) needs the native prover and tens of GiB; that path belongs to -the CLI/benchmark layer, not this suite. --/ - -public section - -open LSpec Aiur - -namespace Tests.Aggr - -open Tests.ProofHelpers (expectOk expectErr recCommitParams innerFri) - -private def expectErrContains [ToString ε] (descr : String) (needle : String) - (e : Except ε α) : TestSeq := - match e with - | .error msg => - if (toString msg).contains needle then - test descr true - else - test s!"{descr} — rejected with unexpected error: {msg} (expected '{needle}')" false - | .ok _ => test s!"{descr} — expected a rejection but it was accepted" false - -/-- Cheap stand-in children. `fake_verify_claim` mirrors the IxVM -`verify_claim` claim shape (10 words), `fake_aggr` mirrors the `ix_aggr` claim -shape (18 words). Bodies touch memory so the proofs have a non-trivial trace. -/ -def childProgram : Source.Toplevel := ⟦ - pub fn fake_verify_claim(digest: [G; 8]) { - assert_eq!(load(store(digest[0])), digest[0]); - () - } - pub fn fake_aggr(allowed_digest: [G; 8], _out_claim_digest: [G; 8]) { - assert_eq!(load(store(allowed_digest[0])), allowed_digest[0]); - () - } -⟧ - -/-- A fixed claim context for the statements below: a stand-in specification - digest and binding hash, no axiom beyond the standard three. -/ -def testCtx : Ix.ClaimContext := - { spec := Address.blake3 "aggregate-test-spec".toUTF8 - binding := Address.blake3 "aggregate-test-binding".toUTF8 - axioms := none } - -private def canonicalTree (leaves : Array Address) : Ix.AssumptionTree := - (Ix.AssumptionTree.canonical leaves).get! - -/-- One child slot: verified serialized proof transport on channel 0 and -serialized claims on channel 2. -/ -private structure ChildSlot where - proofAdviceBytes : ByteArray - claimsBytes : ByteArray - -/-- Assemble the full advice buffer the way the native FFI will: identity blob -and shape byte, per-kind vks, child slots in key order, then the optional -output claim, `CheckEnv` preimages, and canonical trees. -/ -private def mkIO (allowed : ByteArray) (shape : Nat) - (ixvmVk aggrVk : ByteArray) (children : Array ChildSlot) - (outClaim? : Option ByteArray := none) - (preimages : Array ByteArray := #[]) - (trees : Array Ix.AssumptionTree := #[]) - (paths : Array (Address × Option Ix.Merkle.MerklePath) := #[]) : - IOBuffer := Id.run do - let mut io := Aggr.extendIdentity default allowed shape - io := Aggr.extendVk io .ixvm ixvmVk - io := Aggr.extendVk io .aggr aggrVk - for (child, key) in children.mapIdx (fun key child => (child, key)) do - io := Aggr.extendChild io key child.proofAdviceBytes child.claimsBytes - if let some bytes := outClaim? then - io := Aggr.extendOutputClaim io bytes - for bytes in preimages do - io := Aggr.extendPreimage io bytes - for tree in trees do - io := Aggr.extendTree io tree - for (candidate, path?) in paths do - io := Aggr.extendPath io candidate path? - return io - -def smokeSuite : IO UInt32 := do - let childCompiled ← match childProgram.compile with - | .error e => IO.eprintln s!"aggr child compilation failed: {e}"; return 1 - | .ok c => pure c - let fakeVerifyIdx := childCompiled.getFuncIdx `fake_verify_claim |>.get! - let fakeAggrIdx := childCompiled.getFuncIdx `fake_aggr |>.get! - -- Two DIFFERENT verifying keys from one bytecode: the "self" system tunes - -- the query count, so a child proof only verifies under its own kind's vk - -- and the per-kind digest binding is meaningfully exercised. - let ixvmSystem := AiurSystem.build childCompiled.bytecode recCommitParams innerFri - let aggrSystem := AiurSystem.build childCompiled.bytecode recCommitParams - { innerFri with numQueries := 4 } - let ixvmVk := ixvmSystem.vkBytes - let aggrVk := aggrSystem.vkBytes - let allowed := Aggr.allowedBlob ixvmVk fakeVerifyIdx aggrVk fakeAggrIdx - - -- ── the production system under test ──────────────────────────────────── - let aggrTop ← match Aggr.ixAggr with - | .error e => IO.eprintln s!"ixAggr toplevel merge failed: {e}"; return 1 - | .ok t => pure t - let aggrCompiled ← match aggrTop.compileWithGroups Aggr.functionGroups with - | .error e => IO.eprintln s!"ixAggr compilation failed: {e}"; return 1 - | .ok c => pure c - let some ixAggrIdx := aggrCompiled.getFuncIdx `ix_aggr - | IO.eprintln "ix_aggr entrypoint not found"; return 1 - -- The Ix-agnostic lift entrypoint must NOT survive the ixAggr prune. - let liftPruned := aggrCompiled.getFuncIdx `verify_multi_stark_proof |>.isNone - - -- ── two shard statements whose assumptions cross the subject boundary ─── - -- subjects = {a,b} ∪ {c} = {a,b,c} - -- assumptions = ({c,d} ∪ {a}) ∖ {a,b,c} = {d} - let a := Address.blake3 "aggr-a".toUTF8 - let b := Address.blake3 "aggr-b".toUTF8 - let c := Address.blake3 "aggr-c".toUTF8 - let d := Address.blake3 "aggr-d".toUTF8 - let e := Address.blake3 "aggr-extra".toUTF8 - let leftStatement : Aggr.CheckEnvTrees := - { ctx := testCtx, subjects := canonicalTree #[a, b] - assumptions := some (canonicalTree #[c, d]) } - let rightStatement : Aggr.CheckEnvTrees := - { ctx := testCtx, subjects := canonicalTree #[c] - assumptions := some (canonicalTree #[a]) } - let outputStatement := leftStatement.join rightStatement - let adviceTrees := Aggr.CheckEnvTrees.adviceTrees - leftStatement rightStatement outputStatement - let leftClaimBytes := Ix.Claim.ser leftStatement.claim - let rightClaimBytes := Ix.Claim.ser rightStatement.claim - let outputClaimBytes := Ix.Claim.ser outputStatement.claim - let structuralOutput := leftStatement.joinStructural rightStatement - let structuralClaimBytes := Ix.Claim.ser structuralOutput.claim - let structuralTrees := Aggr.CheckEnvTrees.structuralAdviceTrees - leftStatement rightStatement structuralOutput - let structuralPathAdvice := Aggr.CheckEnvTrees.structuralPathAdvice - leftStatement rightStatement structuralOutput - - -- ── M1-d production policy / claim derivation ────────────────────────── - -- Three leaves make the direct policy exercise both the IxVM+IxVM and - -- aggregate+IxVM pair shapes. The threshold keeps the lower fold flat and - -- the root structural. - let driverOps : Array Ix.Shard.AggregationTree.FoldOp := - #[.leaf 0, .leaf 1, .join 0 1, .leaf 2, .join 2 3] - let defaultDriverPlan := Aggr.Reference.schedulePlan - driverOps #[2, 1, 1] 3 - let directDriverPlan := Aggr.Reference.schedulePlan - driverOps #[2, 1, 1] 3 true - let singletonDirectPlan := Aggr.Reference.schedulePlan - #[.leaf 0] #[2] 0 true - -- M1-f's four-shard box fixture is a balanced post-order fold. With every - -- pair above the structural threshold, wrap-first proves 0×4 then 9×3; - -- direct mode keeps leaves raw, proves two shape-6 lower pairs, then shape 9. - let m1fOps : Array Ix.Shard.AggregationTree.FoldOp := #[ - .leaf 0, .leaf 1, .join 0 1, - .leaf 2, .leaf 3, .join 3 4, - .join 2 5 - ] - let m1fWrapPlan := Aggr.Reference.schedulePlan - m1fOps #[2500, 2500, 2500, 2500] 4096 - let m1fDirectPlan := Aggr.Reference.schedulePlan - m1fOps #[2500, 2500, 2500, 2500] 4096 true - let wrapFirstShapes : Bool := match defaultDriverPlan with - | .ok plan => - plan.map (·.shape?) == #[some 0, some 0, some 5, some 0, some 9] && - plan.all (·.kind == .aggr) - | .error _ => false - let directShapes : Bool := match directDriverPlan with - | .ok plan => - plan.map (·.shape?) == #[none, none, some 2, none, some 8] && - plan.map (·.kind) == #[.ixvm, .ixvm, .aggr, .ixvm, .aggr] - | .error _ => false - let singletonStillWraps : Bool := match singletonDirectPlan with - | .ok #[slot] => slot.kind == .aggr && slot.shape? == some 0 - | _ => false - let m1fWrapShapes : Bool := match m1fWrapPlan with - | .ok plan => - plan.map (·.shape?) == - #[some 0, some 0, some 9, some 0, some 0, some 9, some 9] && - plan.all (·.kind == .aggr) - | .error _ => false - let m1fDirectShapes : Bool := match m1fDirectPlan with - | .ok plan => - plan.map (·.shape?) == - #[none, none, some 6, none, none, some 6, some 9] && - plan.map (·.kind) == - #[.ixvm, .ixvm, .aggr, .ixvm, .ixvm, .aggr, .aggr] - | .error _ => false - let shapeWeightsBounded : Bool := match defaultDriverPlan, directDriverPlan with - | .ok wraps, .ok direct => - Aggr.Reference.aggregateSlotRamWeights wraps == #[ - Aggr.Reference.aggregateWrapRamBytes, - Aggr.Reference.aggregateWrapRamBytes, - Aggr.Reference.aggregateStructuralJoinRamBytes + - 3 * Aggr.Reference.aggregateFlatJoinRamPerSubjectBytes, - Aggr.Reference.aggregateWrapRamBytes, - Aggr.Reference.aggregateStructuralJoinRamBytes] && - Aggr.Reference.aggregateSlotRamWeights direct == #[ - Aggr.Reference.aggregateRawShardRamBytes, - Aggr.Reference.aggregateRawShardRamBytes, - Aggr.Reference.aggregateDirectJoinRamBytes, - Aggr.Reference.aggregateRawShardRamBytes, - Aggr.Reference.aggregateMixedJoinRamBytes] - | _, _ => false - let driverPrepared : Array Aggr.Reference.PreparedShard := #[ - { claim := leftStatement.claim - statement := leftStatement }, - { claim := rightStatement.claim - statement := rightStatement }, - { claim := rightStatement.claim - statement := rightStatement } - ] - let driverParameters : Aggr.RecursionParameters := { - commitment := recCommitParams, fri := innerFri - } - let defaultDriverSpecs := defaultDriverPlan.bind fun plan => - Aggr.Reference.buildAggrSlotSpecs plan driverPrepared aggrVk allowed - fakeVerifyIdx fakeAggrIdx driverParameters - let directDriverSpecs := directDriverPlan.bind fun plan => - Aggr.Reference.buildAggrSlotSpecs plan driverPrepared aggrVk allowed - fakeVerifyIdx fakeAggrIdx driverParameters - let uniformDriverClaims : Bool := match defaultDriverSpecs, directDriverSpecs with - | .ok wraps, .ok direct => match wraps[0]?, wraps.back?, direct[0]?, direct.back? with - | some wrappedLeaf, some wrappedRoot, some rawLeaf, some directRoot => - wrappedLeaf.outerClaim == Aggr.aggregateOuterClaim - allowed fakeAggrIdx leftStatement.claim && - rawLeaf.kind == .ixvm && directRoot.kind == .aggr && - wrappedRoot.outerClaim == directRoot.outerClaim && - Aggr.aggregateCacheVersion == 2 && - wrappedLeaf.cacheKey != Aggr.aggregateCacheKey - aggrVk driverParameters wrappedLeaf.outerClaim 1 - | _, _, _, _ => false - | _, _ => false - - -- ── child proofs ──────────────────────────────────────────────────────── - -- Kind 0 ("IxVM"): claim = [0, fake_verify_claim, digest(CheckEnv bytes)]. - let mkIxvmChild (claimBytes : ByteArray) : Except String ChildSlot := do - let (claim, proof, _) ← - ixvmSystem.prove fakeVerifyIdx (MultiStark.digestGs claimBytes) default - let proofAdviceBytes ← ixvmSystem.proofToAdviceBytes claim proof - pure ⟨proofAdviceBytes, MultiStark.serializeClaims #[claim]⟩ - -- Kind 1 ("self"): claim = [0, fake_aggr, digest(allowed), digest(CheckEnv)]. - let mkSelfChild (blob claimBytes : ByteArray) : Except String ChildSlot := do - let (claim, proof, _) ← - aggrSystem.prove fakeAggrIdx (Aggr.pubInput blob claimBytes) default - let proofAdviceBytes ← aggrSystem.proofToAdviceBytes claim proof - pure ⟨proofAdviceBytes, MultiStark.serializeClaims #[claim]⟩ - let leftIxvm ← match mkIxvmChild leftClaimBytes with - | .error e => IO.eprintln s!"left IxVM proof advice encoding failed: {e}"; return 1 - | .ok child => pure child - let rightIxvm ← match mkIxvmChild rightClaimBytes with - | .error e => IO.eprintln s!"right IxVM proof advice encoding failed: {e}"; return 1 - | .ok child => pure child - let leftSelf ← match mkSelfChild allowed leftClaimBytes with - | .error e => IO.eprintln s!"left self proof advice encoding failed: {e}"; return 1 - | .ok child => pure child - let rightSelf ← match mkSelfChild allowed rightClaimBytes with - | .error e => IO.eprintln s!"right self proof advice encoding failed: {e}"; return 1 - | .ok child => pure child - let structuralSelf ← match mkSelfChild allowed structuralClaimBytes with - | .error e => IO.eprintln s!"structural self proof advice encoding failed: {e}"; return 1 - | .ok child => pure child - - let run (shape : Nat) (children : Array ChildSlot) (outBytes : ByteArray) - (outClaim? : Option ByteArray := none) - (preimages : Array ByteArray := #[]) - (trees : Array Ix.AssumptionTree := #[]) - (paths : Array (Address × Option Ix.Merkle.MerklePath) := #[]) := - aggrCompiled.bytecode.execute ixAggrIdx (Aggr.pubInput allowed outBytes) - (mkIO allowed shape ixvmVk aggrVk children outClaim? preimages trees paths) - let pairShape (l r : Aggr.ChildKind) := Aggr.shapeCode (l, some r) - let runPair (l r : Aggr.ChildKind) (leftChild rightChild : ChildSlot) := - run (pairShape l r) #[leftChild, rightChild] outputClaimBytes - (outClaim? := some outputClaimBytes) - (preimages := #[leftClaimBytes, rightClaimBytes]) - (trees := adviceTrees) - let runStructural (l r : Aggr.ChildKind) - (leftChild rightChild : ChildSlot) - (paths := structuralPathAdvice) := - run (Aggr.structuralShapeCode l r) #[leftChild, rightChild] - structuralClaimBytes (outClaim? := some structuralClaimBytes) - (preimages := #[leftClaimBytes, rightClaimBytes]) - (trees := structuralTrees) (paths := paths) - - IO.println "ix-aggr (proving stand-in children + interpreting all shapes)…" - (← IO.getStdout).flush - - -- ── positive shapes ───────────────────────────────────────────────────── - let wrapIxvm := run (Aggr.shapeCode (.ixvm, none)) #[leftIxvm] leftClaimBytes - let wrapSelf := run (Aggr.shapeCode (.aggr, none)) #[leftSelf] leftClaimBytes - let pairII := runPair .ixvm .ixvm leftIxvm rightIxvm - let pairIA := runPair .ixvm .aggr leftIxvm rightSelf - let pairAI := runPair .aggr .ixvm leftSelf rightIxvm - let pairAA := runPair .aggr .aggr leftSelf rightSelf - let structuralII := runStructural .ixvm .ixvm leftIxvm rightIxvm - let structuralIA := runStructural .ixvm .aggr leftIxvm rightSelf - let structuralAI := runStructural .aggr .ixvm leftSelf rightIxvm - let structuralAA := runStructural .aggr .aggr leftSelf rightSelf - - -- A structural parent consumes a structural child's free-form subject root - -- opaquely. This is the monotone composition path used above the scheduler - -- threshold: once structural, all ancestors remain structural. - let nestedStructuralOutput := structuralOutput.joinStructural rightStatement - let nestedStructuralBytes := Ix.Claim.ser nestedStructuralOutput.claim - let nestedStructural := run (Aggr.structuralShapeCode .aggr .ixvm) - #[structuralSelf, rightIxvm] nestedStructuralBytes - (outClaim? := some nestedStructuralBytes) - (preimages := #[structuralClaimBytes, rightClaimBytes]) - (trees := Aggr.CheckEnvTrees.structuralAdviceTrees - structuralOutput rightStatement nestedStructuralOutput) - (paths := Aggr.CheckEnvTrees.structuralPathAdvice - structuralOutput rightStatement nestedStructuralOutput) - - -- ── codegen/native parity ─────────────────────────────────────────────── - -- The generated Rust aggregator (`crates/ixvm-codegen/src/aiur_ix_aggr.rs`) - -- plus the native advice builder must reproduce the interpreter's output - -- and per-circuit query counts exactly — the standing parity invariant. - let sameCounts (native : Except String (Array Aiur.G × Array QueryCount)) - (interp : Except String (Array Aiur.G × IOBuffer × Array QueryCount)) : - Bool := - match native, interp with - | .ok (out, qc), .ok (outI, _, qcI) => - out == outI && qc.size == qcI.size && - (qc.zip qcI).all fun (a, b) => - a.uniqueRows == b.uniqueRows && a.totalHits == b.totalHits - | _, _ => false - let nativePair := aggrCompiled.bytecode.executeIxAggr ixAggrIdx - (Aggr.pubInput allowed outputClaimBytes) (pairShape .ixvm .ixvm) - leftIxvm.proofAdviceBytes rightIxvm.proofAdviceBytes ixvmVk aggrVk - leftIxvm.claimsBytes rightIxvm.claimsBytes outputClaimBytes allowed - (Aggr.preimagesBlob #[leftClaimBytes, rightClaimBytes]) - (Aggr.treesBlob adviceTrees) (Aggr.pathsBlob #[]) - let nativeWrap := aggrCompiled.bytecode.executeIxAggr ixAggrIdx - (Aggr.pubInput allowed leftClaimBytes) (Aggr.shapeCode (.ixvm, none)) - leftIxvm.proofAdviceBytes ByteArray.empty ixvmVk aggrVk - leftIxvm.claimsBytes ByteArray.empty leftClaimBytes allowed - (Aggr.preimagesBlob #[]) (Aggr.treesBlob #[]) (Aggr.pathsBlob #[]) - let nativeStructural := aggrCompiled.bytecode.executeIxAggr ixAggrIdx - (Aggr.pubInput allowed structuralClaimBytes) - (Aggr.structuralShapeCode .ixvm .ixvm) - leftIxvm.proofAdviceBytes rightIxvm.proofAdviceBytes ixvmVk aggrVk - leftIxvm.claimsBytes rightIxvm.claimsBytes structuralClaimBytes allowed - (Aggr.preimagesBlob #[leftClaimBytes, rightClaimBytes]) - (Aggr.treesBlob structuralTrees) (Aggr.pathsBlob structuralPathAdvice) - - -- Native keyed-blob framing is strict: even an otherwise honest pair must - -- reject a preimage blob that omits its u32 entry count. - let malformedNativeFraming := aggrCompiled.bytecode.executeIxAggr ixAggrIdx - (Aggr.pubInput allowed outputClaimBytes) (pairShape .ixvm .ixvm) - leftIxvm.proofAdviceBytes rightIxvm.proofAdviceBytes ixvmVk aggrVk - leftIxvm.claimsBytes rightIxvm.claimsBytes outputClaimBytes allowed - ⟨#[]⟩ (Aggr.treesBlob adviceTrees) (Aggr.pathsBlob #[]) - - let structuralHostCorrect := - structuralOutput.subjects.root == - Ix.Merkle.nodeHash leftStatement.subjects.root rightStatement.subjects.root && - structuralOutput.assumptions.map (·.leaves) == some #[d] && - structuralPathAdvice.size == 3 - - -- A path that stops at the left child root never reaches the structural - -- output root. - let wrongRootPathAdvice := structuralPathAdvice.map fun (candidate, path?) => - if candidate == a then - (candidate, leftStatement.subjects.merkleProof candidate) - else (candidate, path?) - let wrongRootPath := runStructural .ixvm .ixvm leftIxvm rightIxvm - (paths := wrongRootPathAdvice) - - -- Alter one sibling while retaining a syntactically valid path. - let tamperedPathAdvice := structuralPathAdvice.map fun (candidate, path?) => - if candidate == a then - match path? with - | some path => match path[0]? with - | some (_, side) => (candidate, some (path.set! 0 (e, side))) - | none => (candidate, path?) - | none => (candidate, path?) - else (candidate, path?) - let tamperedPath := runStructural .ixvm .ixvm leftIxvm rightIxvm - (paths := tamperedPathAdvice) - - -- Every candidate requires an explicit keyed choice; there is no implicit - -- carry default. - let droppedPathAdvice := structuralPathAdvice.filter fun (candidate, _) => - candidate != d - let droppedPath := runStructural .ixvm .ixvm leftIxvm rightIxvm - (paths := droppedPathAdvice) - - -- Candidate d chooses carry, but this output omits it. - let missingCarriedOutput : Aggr.CheckEnvTrees := - { ctx := testCtx, subjects := structuralOutput.subjects, assumptions := none } - let missingCarriedBytes := Ix.Claim.ser missingCarriedOutput.claim - let missingCarried := run (Aggr.structuralShapeCode .ixvm .ixvm) - #[leftIxvm, rightIxvm] missingCarriedBytes - (outClaim? := some missingCarriedBytes) - (preimages := #[leftClaimBytes, rightClaimBytes]) - (trees := Aggr.CheckEnvTrees.structuralAdviceTrees - leftStatement rightStatement missingCarriedOutput) - (paths := Aggr.CheckEnvTrees.structuralPathAdvice - leftStatement rightStatement missingCarriedOutput) - - -- The same child statements cannot switch between flat and structural - -- semantics merely by changing the shape hint: each arm binds a different - -- output root equation. - let structuralHintOnFlatOutput := run - (Aggr.structuralShapeCode .ixvm .ixvm) #[leftIxvm, rightIxvm] - outputClaimBytes (outClaim? := some outputClaimBytes) - (preimages := #[leftClaimBytes, rightClaimBytes]) - (trees := structuralTrees) (paths := structuralPathAdvice) - let flatHintOnStructuralOutput := run (pairShape .ixvm .ixvm) - #[leftIxvm, rightIxvm] structuralClaimBytes - (outClaim? := some structuralClaimBytes) - (preimages := #[leftClaimBytes, rightClaimBytes]) - (trees := Aggr.CheckEnvTrees.adviceTrees - leftStatement rightStatement structuralOutput) - - -- A flat parent must reopen every subject as a canonical tree. Feeding it - -- a genuinely structural child therefore rejects, while the structural - -- parent above accepts the same child root opaquely. - let flatAfterStructuralOutput := structuralOutput.join rightStatement - let flatAfterStructuralBytes := Ix.Claim.ser flatAfterStructuralOutput.claim - let flatFedStructuralChild := run (pairShape .aggr .ixvm) - #[structuralSelf, rightIxvm] flatAfterStructuralBytes - (outClaim? := some flatAfterStructuralBytes) - (preimages := #[structuralClaimBytes, rightClaimBytes]) - (trees := Aggr.CheckEnvTrees.adviceTrees - structuralOutput rightStatement flatAfterStructuralOutput) - - -- ── negative cases — one broken binding each ──────────────────────────── - -- Shape hint lies about the child's system: a self proof cannot verify - -- against the IxVM vk the hinted kind binds. - let shapeLie := run (Aggr.shapeCode (.ixvm, none)) #[leftSelf] leftClaimBytes - -- Tampered proof advice. - let tamperedBytes := leftIxvm.proofAdviceBytes.set! 0 - (UInt8.ofNat ((leftIxvm.proofAdviceBytes.data[0]!.toNat + 1) % 256)) - let tampered := run (Aggr.shapeCode (.ixvm, none)) - #[{ leftIxvm with proofAdviceBytes := tamperedBytes }] leftClaimBytes - -- A self child minted under a FOREIGN aggregation identity (different - -- entrypoint index) must not be joinable under this one. - let foreignAllowed := Aggr.allowedBlob ixvmVk fakeVerifyIdx aggrVk - (fakeAggrIdx + 1) - let foreignSelf ← match mkSelfChild foreignAllowed leftClaimBytes with - | .error e => IO.eprintln s!"foreign self proof advice encoding failed: {e}"; return 1 - | .ok child => pure child - let foreignIdentity := run (Aggr.shapeCode (.aggr, none)) #[foreignSelf] - leftClaimBytes - -- Wrap must pass the child statement through unchanged. - let wrapMismatch := run (Aggr.shapeCode (.ixvm, none)) #[leftIxvm] - rightClaimBytes - -- A pair fold that drops the outstanding assumption {d}. - let droppedStatement : Aggr.CheckEnvTrees := - { outputStatement with assumptions := none } - let droppedBytes := Ix.Claim.ser droppedStatement.claim - let droppedAssumption := run (pairShape .ixvm .ixvm) #[leftIxvm, rightIxvm] - droppedBytes (outClaim? := some droppedBytes) - (preimages := #[leftClaimBytes, rightClaimBytes]) - (trees := Aggr.CheckEnvTrees.adviceTrees - leftStatement rightStatement droppedStatement) - -- Children under different contexts do not fold: the right statement - -- names another role binding. - let otherCtxRight : Aggr.CheckEnvTrees := - { rightStatement with - ctx := { testCtx with binding := Address.blake3 "aggr-other-binding".toUTF8 } } - let otherCtxRightBytes := Ix.Claim.ser otherCtxRight.claim - let otherCtxRightIxvm ← match mkIxvmChild otherCtxRightBytes with - | .error e => IO.eprintln s!"other-context IxVM proof advice encoding failed: {e}"; return 1 - | .ok child => pure child - let contextMismatch := run (pairShape .ixvm .ixvm) #[leftIxvm, otherCtxRightIxvm] - outputClaimBytes (outClaim? := some outputClaimBytes) - (preimages := #[leftClaimBytes, otherCtxRightBytes]) - (trees := Aggr.CheckEnvTrees.adviceTrees - leftStatement otherCtxRight outputStatement) - -- A pair fold whose output subjects contain an extra address {e}. - let paddedStatement : Aggr.CheckEnvTrees := - { ctx := testCtx, subjects := canonicalTree #[a, b, c, e] - assumptions := outputStatement.assumptions } - let paddedBytes := Ix.Claim.ser paddedStatement.claim - let extraSubject := run (pairShape .ixvm .ixvm) #[leftIxvm, rightIxvm] - paddedBytes (outClaim? := some paddedBytes) - (preimages := #[leftClaimBytes, rightClaimBytes]) - (trees := Aggr.CheckEnvTrees.adviceTrees - leftStatement rightStatement paddedStatement) - -- Tree advice whose leaves do not reproduce the keyed root: seed the - -- output-subject slot with the padded tree's serialization under the honest - -- root's key. The circuit recomputes the canonical root from the leaves. - let mismatchedIO := Id.run do - let mut io := mkIO allowed (pairShape .ixvm .ixvm) ixvmVk aggrVk - #[leftIxvm, rightIxvm] (outClaim? := some outputClaimBytes) - (preimages := #[leftClaimBytes, rightClaimBytes]) - (trees := #[leftStatement.subjects, leftStatement.assumptions.get!, - rightStatement.subjects, rightStatement.assumptions.get!, - outputStatement.assumptions.get!]) - io := io.extend 5 (Aggr.byteGs outputStatement.subjects.root.hash) - (Aggr.byteGs (Ix.AssumptionTree.ser paddedStatement.subjects)) - return io - let mismatchedTree := aggrCompiled.bytecode.execute ixAggrIdx - (Aggr.pubInput allowed outputClaimBytes) mismatchedIO - - -- A self-consistent free-form tree with descending leaves is not a - -- canonical set tree, even when its root matches the public output claim. - let sortedOutputLeaves := (#[a, b, c]).qsort fun x y => compare x y == .lt - let unsortedSubjects : Ix.AssumptionTree := - .node (.node (.leaf sortedOutputLeaves[2]!) (.leaf sortedOutputLeaves[1]!)) - (.leaf sortedOutputLeaves[0]!) - let unsortedStatement : Aggr.CheckEnvTrees := { - ctx := testCtx - subjects := unsortedSubjects - assumptions := outputStatement.assumptions - } - let unsortedBytes := Ix.Claim.ser unsortedStatement.claim - let unsorted := run (pairShape .ixvm .ixvm) #[leftIxvm, rightIxvm] - unsortedBytes (outClaim? := some unsortedBytes) - (preimages := #[leftClaimBytes, rightClaimBytes]) - (trees := Aggr.CheckEnvTrees.adviceTrees - leftStatement rightStatement unsortedStatement) - - -- Identity framing and shape dispatch are closed: malformed lengths and - -- out-of-range shape bytes cannot select a permissive arm. - let shortAllowed := allowed.extract 0 72 - let shortIdentity := aggrCompiled.bytecode.execute ixAggrIdx - (Aggr.pubInput shortAllowed leftClaimBytes) - (mkIO shortAllowed (Aggr.shapeCode (.ixvm, none)) ixvmVk aggrVk - #[leftIxvm]) - let longAllowed := allowed ++ ⟨Array.replicate 16 0⟩ - let longIdentity := aggrCompiled.bytecode.execute ixAggrIdx - (Aggr.pubInput longAllowed leftClaimBytes) - (mkIO longAllowed (Aggr.shapeCode (.ixvm, none)) ixvmVk aggrVk - #[leftIxvm]) - -- 17 is the first shape hint past the catalog join (16). - let invalidShape := run 17 #[leftIxvm] leftClaimBytes - - -- ── binding discharge (shapes 13–14) ──────────────────────────────────── - -- Children that assume their binding (validator 4) and one stand-in proof - -- of the binding claim for their context, written to a file and read back: - -- the same proof file discharges two different claim sets, each to its - -- claim validating the binding (the validator-3 bytes above). - let assumedCtx := { testCtx with bindingAssumed := true } - let assumedLeftBytes := Ix.Claim.ser { leftStatement with ctx := assumedCtx }.claim - let assumedRightBytes := Ix.Claim.ser { rightStatement with ctx := assumedCtx }.claim - let bindingClaim : Ix.Claim := .binding testCtx.spec testCtx.binding - let bindingBytes := Ix.Claim.ser bindingClaim - let bindingFile ← IO.FS.createTempFile - let (_, bindingProof, _) ← IO.ofExcept <| - ixvmSystem.prove fakeVerifyIdx (MultiStark.digestGs bindingBytes) default - IO.FS.writeBinFile bindingFile.2 - (Ixon.Proof.ser { claim := bindingClaim, proof := bindingProof.toBytes }) - let readBinding : IO ChildSlot := do - let wrapper ← IO.ofExcept (Ixon.Proof.de (← IO.FS.readBinFile bindingFile.2)) - let proof ← IO.ofExcept (Aiur.Proof.ofBytesChecked wrapper.proof) - let claim := Aiur.buildClaim fakeVerifyIdx - (MultiStark.digestGs (Ix.Claim.ser wrapper.claim)) #[] - let advice ← IO.ofExcept (ixvmSystem.proofToAdviceBytes claim proof) - pure ⟨advice, MultiStark.serializeClaims #[claim]⟩ - let bindingSlot ← readBinding - let otherBindingBytes := Ix.Claim.ser - (Ix.Claim.binding testCtx.spec (Address.blake3 "another binding".toUTF8)) - let otherBindingSlot ← IO.ofExcept (mkIxvmChild otherBindingBytes) - let assumedLeftIxvm ← IO.ofExcept (mkIxvmChild assumedLeftBytes) - let assumedRightIxvm ← IO.ofExcept (mkIxvmChild assumedRightBytes) - let assumedLeftSelf ← IO.ofExcept (mkSelfChild allowed assumedLeftBytes) - let runDischarge (kind : Aggr.ChildKind) (child binding : ChildSlot) - (childBytes bindingClaimBytes outBytes : ByteArray) := - run (Aggr.dischargeShapeCode kind) #[child, binding] outBytes - (outClaim? := some outBytes) (preimages := #[childBytes, bindingClaimBytes]) - let dischargeLeft := runDischarge .ixvm assumedLeftIxvm bindingSlot - assumedLeftBytes bindingBytes leftClaimBytes - let dischargeRight := runDischarge .ixvm assumedRightIxvm bindingSlot - assumedRightBytes bindingBytes rightClaimBytes - let dischargeSelf := runDischarge .aggr assumedLeftSelf bindingSlot - assumedLeftBytes bindingBytes leftClaimBytes - let dischargeValidating := runDischarge .ixvm leftIxvm bindingSlot - leftClaimBytes bindingBytes leftClaimBytes - let dischargeOtherBinding := runDischarge .ixvm assumedLeftIxvm otherBindingSlot - assumedLeftBytes otherBindingBytes leftClaimBytes - let dischargeKeepsAssumed := runDischarge .ixvm assumedLeftIxvm bindingSlot - assumedLeftBytes bindingBytes assumedLeftBytes - let dischargeOtherSubjects := runDischarge .ixvm assumedLeftIxvm bindingSlot - assumedLeftBytes bindingBytes rightClaimBytes - -- A fold never mixes a claim that assumes its binding with one that - -- validates it. - let pairMixedValidators := run (pairShape .ixvm .ixvm) #[leftIxvm, assumedRightIxvm] - outputClaimBytes (outClaim? := some outputClaimBytes) - (preimages := #[leftClaimBytes, assumedRightBytes]) (trees := adviceTrees) - - -- ── claims under different role bindings (shapes 15–16) ───────────────── - -- Complete role tables: `tableA` and `tableB` bind every role, and differ - -- only in `Nat.land`, so they have one literal class; `tableC` also binds - -- `Char.ofNat` elsewhere, a class role, so its class differs. - let tableOf (rebind : List Ix.Kernel.Role) (tag : String) : ByteArray := - Ix.Kernel.RoleTable.toBytes { - version := Ix.Kernel.specVersion, evidence := #[] - bound := Ix.Kernel.Role.all.toArray.map fun r => - (r, Address.blake3 (if rebind.contains r then s!"{tag} {r.leanName}" - else s!"bound {r.leanName}").toUTF8) } - let tableA := tableOf [] "a" - let tableB := tableOf [.natLand] "b" - let tableC := tableOf [.natLand, .charOfNat] "c" - let incompleteTable := Ix.Kernel.RoleTable.toBytes { - version := Ix.Kernel.specVersion, evidence := #[] - bound := (Ix.Kernel.Role.all.toArray.map fun r => - (r, Address.blake3 s!"bound {r.leanName}".toUTF8)).pop } - let klass ← IO.ofExcept (Ix.ClaimContext.literalClassOfBytes tableA) - let classB ← IO.ofExcept (Ix.ClaimContext.literalClassOfBytes tableB) - let classC ← IO.ofExcept (Ix.ClaimContext.literalClassOfBytes tableC) - let underTable (table : ByteArray) (statement : Aggr.CheckEnvTrees) : Aggr.CheckEnvTrees := - { statement with ctx := { testCtx with binding := Address.blake3 table } } - let memberA := underTable tableA { leftStatement with assumptions := none } - let memberB := underTable tableB { rightStatement with assumptions := none } - let memberC := underTable tableC { rightStatement with assumptions := none } - let memberIncomplete := underTable incompleteTable { rightStatement with assumptions := none } - let selfOf (statement : Aggr.CheckEnvTrees) : IO (ChildSlot × ByteArray) := do - let bytes := Ix.Claim.ser statement.claim - pure (← IO.ofExcept (mkSelfChild allowed bytes), bytes) - let (childA, bytesA) ← selfOf memberA - let (childB, bytesB) ← selfOf memberB - let (childC, bytesC) ← selfOf memberC - let (childIncomplete, bytesIncomplete) ← selfOf memberIncomplete - let crossAB := memberA.joinCrossBinding klass memberB - let crossBytes := Ix.Claim.ser crossAB.claim - let runCross (left right : ChildSlot) (preimages : Array ByteArray) (outBytes : ByteArray) := - run Aggr.crossBindingShapeCode #[left, right] outBytes (outClaim? := some outBytes) - (preimages := preimages) - let crossAccepts := runCross childA childB #[bytesA, bytesB, tableA, tableB] crossBytes - -- A claim already under the class joins a member of the class. - let (childCross, _) ← selfOf crossAB - let crossNested := memberA.joinCrossBinding klass crossAB - let crossNestedBytes := Ix.Claim.ser crossNested.claim - let crossOfClass := runCross childA childCross #[bytesA, crossBytes, tableA] - crossNestedBytes - let crossOtherClass := runCross childA childC #[bytesA, bytesC, tableA, tableC] - (Ix.Claim.ser (memberA.joinCrossBinding klass memberC).claim) - let crossIncomplete := runCross childA childIncomplete - #[bytesA, bytesIncomplete, tableA, incompleteTable] - (Ix.Claim.ser (memberA.joinCrossBinding klass memberIncomplete).claim) - let assumedA := { memberA with ctx := { memberA.ctx with bindingAssumed := true } } - let (childAssumedA, bytesAssumedA) ← selfOf assumedA - let crossAssumed := runCross childAssumedA childB #[bytesAssumedA, bytesB, tableA, tableB] - crossBytes - let crossWrongClass := runCross childA childB #[bytesA, bytesB, tableA, tableB] - (Ix.Claim.ser { crossAB with ctx := { crossAB.ctx with binding := classC } }.claim) - let crossValidatorThree := runCross childA childB #[bytesA, bytesB, tableA, tableB] - (Ix.Claim.ser { crossAB with ctx := { crossAB.ctx with literalClass := false } }.claim) - -- Folds that require one context still refuse the two bindings. - let pairAcrossBindings := run (pairShape .aggr .aggr) #[childA, childB] - (Ix.Claim.ser (memberA.join memberB).claim) - (outClaim? := some (Ix.Claim.ser (memberA.join memberB).claim)) - (preimages := #[bytesA, bytesB]) - (trees := Aggr.CheckEnvTrees.adviceTrees memberA memberB (memberA.join memberB)) - -- Catalog joins: two member claims, then a catalog and a member claim. - let catalogAC := Aggr.CatalogTrees.join (.inl memberA.claim) (.inl memberC.claim) - let catalogBytes := Ix.Claim.ser catalogAC.claim - let runCatalog (left right : ChildSlot) (preimages : Array ByteArray) - (trees : Array Ix.AssumptionTree) (outBytes : ByteArray) := - run Aggr.catalogShapeCode #[left, right] outBytes (outClaim? := some outBytes) - (preimages := preimages) (trees := trees) - let catalogAccepts := runCatalog childA childC #[bytesA, bytesC] #[catalogAC.members] - catalogBytes - let catalogWithPartial := Aggr.CatalogTrees.join (.inl memberA.claim) (.inl memberIncomplete.claim) - let catalogPartial := runCatalog childA childIncomplete #[bytesA, bytesIncomplete] - #[catalogWithPartial.members] (Ix.Claim.ser catalogWithPartial.claim) - let completeMember (label : String) (claim : Ix.Claim) (table : ByteArray) : Aggr.CatalogMember := - { label, toolchain := "fixture", claim, bindingSection := table, literalClass := some klass } - let partialMember : Aggr.CatalogMember := - { label := "partial", toolchain := "fixture", claim := memberIncomplete.claim, - bindingSection := incompleteTable, literalClass := none } - let mixedPlan ← IO.ofExcept (Aggr.catalogPlan #[ - completeMember "left" memberA.claim tableA, partialMember, - completeMember "right" memberB.claim tableB]) - let anotherPartialClaim := (underTable incompleteTable { leftStatement with assumptions := none }).claim - let partialPlan ← IO.ofExcept (Aggr.catalogPlan #[partialMember, - { partialMember with label := "another partial", claim := anotherPartialClaim }]) - let plansKeepPartial := mixedPlan.nodes.size == 5 && - mixedPlan.nodes.any (fun | .crossBinding k 0 2 => k == klass | _ => false) && - partialPlan.nodes.size == 3 && - (match partialPlan.nodes[partialPlan.root]! with | .catalogJoin 0 1 => true | _ => false) && - partialPlan.statements[partialPlan.root]!.claim == - (Aggr.CatalogTrees.join (.inl partialMember.claim) (.inl anotherPartialClaim)).claim - let childCatalog ← IO.ofExcept (mkSelfChild allowed catalogBytes) - let catalogACB := Aggr.CatalogTrees.join (.inr catalogAC) (.inl crossAB.claim) - let catalogNested := runCatalog childCatalog childCross #[catalogBytes, crossBytes] - #[catalogAC.members, catalogACB.members] (Ix.Claim.ser catalogACB.claim) - let catalogMissing := runCatalog childA childC #[bytesA, bytesC] - #[(Ix.AssumptionTree.canonical #[Ix.Claim.commit memberA.claim]).get!] - (Ix.Claim.ser (Ix.Claim.catalog (Ix.AssumptionTree.canonical - #[Ix.Claim.commit memberA.claim]).get!.root)) - let conditionalA := underTable tableA leftStatement - let (childConditional, bytesConditional) ← selfOf conditionalA - let catalogConditional := runCatalog childConditional childC - #[bytesConditional, bytesC] - #[(Ix.AssumptionTree.canonical #[Ix.Claim.commit conditionalA.claim, - Ix.Claim.commit memberC.claim]).get!] - (Ix.Claim.ser (Ix.Claim.catalog (Ix.AssumptionTree.canonical - #[Ix.Claim.commit conditionalA.claim, Ix.Claim.commit memberC.claim]).get!.root)) - let catalogAssumed := runCatalog childAssumedA childC #[bytesAssumedA, bytesC] - #[(Ix.AssumptionTree.canonical #[Ix.Claim.commit assumedA.claim, - Ix.Claim.commit memberC.claim]).get!] - (Ix.Claim.ser (Ix.Claim.catalog (Ix.AssumptionTree.canonical - #[Ix.Claim.commit assumedA.claim, Ix.Claim.commit memberC.claim]).get!.root)) - let bindingMemberBytes := Ix.Claim.ser (Ix.Claim.binding testCtx.spec (Address.blake3 tableA)) - let childBindingMember ← IO.ofExcept (mkSelfChild allowed bindingMemberBytes) - let catalogOfBinding := runCatalog childBindingMember childC #[bindingMemberBytes, bytesC] - #[(Ix.AssumptionTree.canonical #[Address.blake3 bindingMemberBytes, - Ix.Claim.commit memberC.claim]).get!] - (Ix.Claim.ser (Ix.Claim.catalog (Ix.AssumptionTree.canonical - #[Address.blake3 bindingMemberBytes, Ix.Claim.commit memberC.claim]).get!.root)) - let catalogTampered := runCatalog childCatalog childCross #[catalogBytes, crossBytes] - #[catalogACB.members] (Ix.Claim.ser catalogACB.claim) - let classesDistinct := klass == classB && klass != classC - - -- ── range-sum recursion (shapes 10–12) over one IxVM batch ───────────── - -- `prove` yields a one-shard batch, so its ranges are `[0, 0)` and - -- `[0, 1)`: a leaf for each, a join adding them into `[0, 1)`, and a root - -- closing the batch and emitting the wrap's statement. - let rangeBatch ← match ixvmSystem.prove fakeVerifyIdx - (MultiStark.digestGs leftClaimBytes) default with - | .error e => IO.eprintln s!"range batch proof failed: {e}"; return 1 - | .ok (_, proof, _) => pure proof - let (preamble, fullProofs, fullResidual) ← match rangeBatch.rangeAdvice 0 1 with - | .error e => IO.eprintln s!"range advice failed: {e}"; return 1 - | .ok advice => pure advice - let (_, emptyProofs, emptyResidual) ← match rangeBatch.rangeAdvice 0 0 with - | .error e => IO.eprintln s!"empty range advice failed: {e}"; return 1 - | .ok advice => pure advice - let fullStmt := Aggr.rangeStatement preamble 0 1 fullResidual - let emptyStmt := Aggr.rangeStatement preamble 0 0 emptyResidual - let tamperedResidual := fullResidual.set! 0 (fullResidual.data[0]! ^^^ 1) - let tamperedStmt := Aggr.rangeStatement preamble 0 1 tamperedResidual - let preambleSlot : ChildSlot := ⟨preamble, ByteArray.empty⟩ - let leafSlots (proofs : ByteArray) : Array ChildSlot := - #[preambleSlot, ⟨proofs, ByteArray.empty⟩] - let rangeLeaf := run Aggr.rangeLeafShape (leafSlots fullProofs) fullStmt - (outClaim? := some fullStmt) - let emptyRangeLeaf := run Aggr.rangeLeafShape (leafSlots emptyProofs) - emptyStmt (outClaim? := some emptyStmt) - let leafWrongResidual := run Aggr.rangeLeafShape (leafSlots fullProofs) - tamperedStmt (outClaim? := some tamperedStmt) - let leafCountMismatch := run Aggr.rangeLeafShape (leafSlots fullProofs) - emptyStmt (outClaim? := some emptyStmt) - let reversedStmt := Aggr.rangeStatement preamble 1 0 emptyResidual - let leafReversed := run Aggr.rangeLeafShape (leafSlots emptyProofs) - reversedStmt (outClaim? := some reversedStmt) - let leafWrongBatch := run Aggr.rangeLeafShape - #[⟨preamble.set! 0 (preamble.data[0]! ^^^ 1), ByteArray.empty⟩, - ⟨fullProofs, ByteArray.empty⟩] fullStmt (outClaim? := some fullStmt) - let emptyRange ← match mkSelfChild allowed emptyStmt with - | .error e => IO.eprintln s!"empty range self proof failed: {e}"; return 1 - | .ok child => pure child - let fullRange ← match mkSelfChild allowed fullStmt with - | .error e => IO.eprintln s!"full range self proof failed: {e}"; return 1 - | .ok child => pure child - let rangeJoin := run Aggr.rangeJoinShape #[emptyRange, fullRange] fullStmt - (outClaim? := some fullStmt) (preimages := #[emptyStmt, fullStmt]) - let joinNotAdjacent := run Aggr.rangeJoinShape #[fullRange, fullRange] - fullStmt (outClaim? := some fullStmt) (preimages := #[fullStmt]) - let joinWrongSum := run Aggr.rangeJoinShape #[emptyRange, fullRange] - tamperedStmt (outClaim? := some tamperedStmt) - (preimages := #[emptyStmt, fullStmt]) - let rangeRoot := run Aggr.rangeRootShape #[fullRange, preambleSlot] - leftClaimBytes (preimages := #[fullStmt]) - let rootPartial := run Aggr.rangeRootShape #[emptyRange, preambleSlot] - leftClaimBytes (preimages := #[emptyStmt]) - let rootClaimLie := run Aggr.rangeRootShape #[fullRange, preambleSlot] - rightClaimBytes (preimages := #[fullStmt]) - -- A range statement is not a `CheckEnv` claim: a pair cannot open it. - let rangeAsCheckEnv := run (pairShape .aggr .ixvm) #[fullRange, rightIxvm] - outputClaimBytes (outClaim? := some outputClaimBytes) - (preimages := #[fullStmt, rightClaimBytes]) (trees := adviceTrees) - let nativeRangeLeaf := aggrCompiled.bytecode.executeIxAggr ixAggrIdx - (Aggr.pubInput allowed fullStmt) Aggr.rangeLeafShape - preamble fullProofs ixvmVk aggrVk ByteArray.empty ByteArray.empty - fullStmt allowed (Aggr.preimagesBlob #[]) (Aggr.treesBlob #[]) - (Aggr.pathsBlob #[]) - let nativeRangeRoot := aggrCompiled.bytecode.executeIxAggr ixAggrIdx - (Aggr.pubInput allowed leftClaimBytes) Aggr.rangeRootShape - fullRange.proofAdviceBytes preamble ixvmVk aggrVk - fullRange.claimsBytes ByteArray.empty leftClaimBytes allowed - (Aggr.preimagesBlob #[fullStmt]) (Aggr.treesBlob #[]) (Aggr.pathsBlob #[]) - - -- ── R01 self-assumption and cross-discharge regressions ───────────────── - -- 1. Duplicated self-assuming child `q = CheckEnv(ctx, {a}, {a})` in flat - -- and structural joins attempting `join(q, q) -> CheckEnv(ctx, {a}, none)`. - let selfAssumingA : Aggr.CheckEnvTrees := - { ctx := testCtx, subjects := canonicalTree #[a] - assumptions := some (canonicalTree #[a]) } - let selfAssumingABytes := Ix.Claim.ser selfAssumingA.claim - let selfAssumingAIxvm ← IO.ofExcept (mkIxvmChild selfAssumingABytes) - let selfDischargedFlatOut : Aggr.CheckEnvTrees := - { ctx := testCtx, subjects := canonicalTree #[a], assumptions := none } - let selfDischargedFlatBytes := Ix.Claim.ser selfDischargedFlatOut.claim - let selfAssumingFlatDuplicate := run (pairShape .ixvm .ixvm) - #[selfAssumingAIxvm, selfAssumingAIxvm] selfDischargedFlatBytes - (outClaim? := some selfDischargedFlatBytes) - (preimages := #[selfAssumingABytes]) - (trees := #[selfAssumingA.subjects]) - -- 2. Flat pair where left child's subjects and right child's subjects are - -- disjoint (`{a}` vs `{c}`), but left child assumes its own subject `a`. - let selfDischargedCrossFlatOut : Aggr.CheckEnvTrees := - { ctx := testCtx, subjects := canonicalTree #[a, c] - assumptions := none } - let selfDischargedCrossFlatBytes := Ix.Claim.ser selfDischargedCrossFlatOut.claim - let selfAssumingFlatDisjointSubjects := run (pairShape .ixvm .ixvm) - #[selfAssumingAIxvm, rightIxvm] selfDischargedCrossFlatBytes - (outClaim? := some selfDischargedCrossFlatBytes) - (preimages := #[selfAssumingABytes, rightClaimBytes]) - (trees := Aggr.CheckEnvTrees.adviceTrees - selfAssumingA rightStatement selfDischargedCrossFlatOut) - -- 3. Flat pair where each child has `subjects ∩ assumptions = ∅`, but the - -- two children have overlapping subject sets (`leftStatement` with itself). - let overlappingFlatSubjects := run (pairShape .ixvm .ixvm) - #[leftIxvm, leftIxvm] leftClaimBytes - (outClaim? := some leftClaimBytes) - (preimages := #[leftClaimBytes]) - (trees := #[leftStatement.subjects, leftStatement.assumptions.get!]) - -- 4. Structural pair with duplicated self-assuming child `joinStructural(q, q)`. - let selfDischargedStructOut : Aggr.CheckEnvTrees := - { ctx := testCtx - subjects := Ix.AssumptionTree.join selfAssumingA.subjects selfAssumingA.subjects - assumptions := none } - let selfDischargedStructBytes := Ix.Claim.ser selfDischargedStructOut.claim - let selfAssumingStructuralDuplicate := run (Aggr.structuralShapeCode .ixvm .ixvm) - #[selfAssumingAIxvm, selfAssumingAIxvm] selfDischargedStructBytes - (outClaim? := some selfDischargedStructBytes) - (preimages := #[selfAssumingABytes]) - (trees := #[selfAssumingA.assumptions.get!]) - (paths := #[(a, selfDischargedStructOut.subjects.merkleProof a)]) - -- 5. Structural pair where a left-only assumption (`b`) is discharged by a - -- valid Merkle path into `left_root` instead of `right_root`. - let leftSelfAssumingB : Aggr.CheckEnvTrees := - { ctx := testCtx, subjects := canonicalTree #[a, b] - assumptions := some (canonicalTree #[b, c]) } - let leftSelfAssumingBBytes := Ix.Claim.ser leftSelfAssumingB.claim - let leftSelfAssumingBIxvm ← IO.ofExcept (mkIxvmChild leftSelfAssumingBBytes) - let selfDischargeLeftStructOut : Aggr.CheckEnvTrees := - { ctx := testCtx - subjects := Ix.AssumptionTree.join leftSelfAssumingB.subjects rightStatement.subjects - assumptions := none } - let selfDischargeLeftStructBytes := Ix.Claim.ser selfDischargeLeftStructOut.claim - let selfAssumingStructuralSelfDischarge := run (Aggr.structuralShapeCode .ixvm .ixvm) - #[leftSelfAssumingBIxvm, rightIxvm] selfDischargeLeftStructBytes - (outClaim? := some selfDischargeLeftStructBytes) - (preimages := #[leftSelfAssumingBBytes, rightClaimBytes]) - (trees := Aggr.CheckEnvTrees.structuralAdviceTrees - leftSelfAssumingB rightStatement selfDischargeLeftStructOut) - (paths := #[ - (a, selfDischargeLeftStructOut.subjects.merkleProof a), - (b, selfDischargeLeftStructOut.subjects.merkleProof b), - (c, selfDischargeLeftStructOut.subjects.merkleProof c), - (d, none)]) - -- 6. Structural pair where a right-only assumption (`c`) is discharged by a - -- valid Merkle path into `right_root` instead of `left_root`. - let leftOnlyAssumingD : Aggr.CheckEnvTrees := - { ctx := testCtx, subjects := canonicalTree #[a, b] - assumptions := some (canonicalTree #[d]) } - let leftOnlyAssumingDBytes := Ix.Claim.ser leftOnlyAssumingD.claim - let leftOnlyAssumingDIxvm ← IO.ofExcept (mkIxvmChild leftOnlyAssumingDBytes) - let rightSelfAssumingC : Aggr.CheckEnvTrees := - { ctx := testCtx, subjects := canonicalTree #[c] - assumptions := some (canonicalTree #[a, c]) } - let rightSelfAssumingCBytes := Ix.Claim.ser rightSelfAssumingC.claim - let rightSelfAssumingCIxvm ← IO.ofExcept (mkIxvmChild rightSelfAssumingCBytes) - let selfDischargeRightStructOut : Aggr.CheckEnvTrees := - { ctx := testCtx - subjects := Ix.AssumptionTree.join leftOnlyAssumingD.subjects rightSelfAssumingC.subjects - assumptions := some (canonicalTree #[d]) } - let selfDischargeRightStructBytes := Ix.Claim.ser selfDischargeRightStructOut.claim - let selfAssumingStructuralRightSelfDischarge := run (Aggr.structuralShapeCode .ixvm .ixvm) - #[leftOnlyAssumingDIxvm, rightSelfAssumingCIxvm] selfDischargeRightStructBytes - (outClaim? := some selfDischargeRightStructBytes) - (preimages := #[leftOnlyAssumingDBytes, rightSelfAssumingCBytes]) - (trees := Aggr.CheckEnvTrees.structuralAdviceTrees - leftOnlyAssumingD rightSelfAssumingC selfDischargeRightStructOut) - (paths := #[ - (a, selfDischargeRightStructOut.subjects.merkleProof a), - (c, (rightSelfAssumingC.subjects.merkleProof c).map fun p => - p.push (leftOnlyAssumingD.subjects.root, true)), - (d, none)]) - -- 7. Structural pair where an assumption shared by both children (`d`) is - -- discharged instead of carried. - let rightOwningD : Aggr.CheckEnvTrees := - { ctx := testCtx, subjects := canonicalTree #[c, d] - assumptions := some (canonicalTree #[a, d]) } - let rightOwningDBytes := Ix.Claim.ser rightOwningD.claim - let rightOwningDIxvm ← IO.ofExcept (mkIxvmChild rightOwningDBytes) - let sharedDischargedStructOut : Aggr.CheckEnvTrees := - { ctx := testCtx - subjects := Ix.AssumptionTree.join leftStatement.subjects rightOwningD.subjects - assumptions := none } - let sharedDischargedStructBytes := Ix.Claim.ser sharedDischargedStructOut.claim - let sharedStructuralAssumptionDischarged := run (Aggr.structuralShapeCode .ixvm .ixvm) - #[leftIxvm, rightOwningDIxvm] sharedDischargedStructBytes - (outClaim? := some sharedDischargedStructBytes) - (preimages := #[leftClaimBytes, rightOwningDBytes]) - (trees := Aggr.CheckEnvTrees.structuralAdviceTrees - leftStatement rightOwningD sharedDischargedStructOut) - (paths := #[ - (a, sharedDischargedStructOut.subjects.merkleProof a), - (c, sharedDischargedStructOut.subjects.merkleProof c), - (d, sharedDischargedStructOut.subjects.merkleProof d)]) - -- 8. Cross-binding structural pair (shape 15) rejecting duplicated subject - -- roots and self-discharging assumptions. - let crossDuplicateOut := memberA.joinCrossBinding klass - (underTable tableB { leftStatement with assumptions := none }) - let crossDuplicateBytes := Ix.Claim.ser crossDuplicateOut.claim - let (childBLeftSubjects, bytesBLeftSubjects) ← - selfOf (underTable tableB { leftStatement with assumptions := none }) - let selfAssumingCrossBindingDuplicate := runCross childA childBLeftSubjects - #[bytesA, bytesBLeftSubjects, tableA, tableB] crossDuplicateBytes - let crossSelfLeft := underTable tableA leftSelfAssumingB - let crossRightHonest := underTable tableB rightStatement - let (childCrossSelfLeft, bytesCrossSelfLeft) ← selfOf crossSelfLeft - let (childCrossRightHonest, bytesCrossRightHonest) ← selfOf crossRightHonest - let crossSelfDischargeOut : Aggr.CheckEnvTrees := - { ctx := { testCtx with binding := klass, bindingAssumed := false, literalClass := true } - subjects := Ix.AssumptionTree.join crossSelfLeft.subjects crossRightHonest.subjects - assumptions := none } - let crossSelfDischargeBytes := Ix.Claim.ser crossSelfDischargeOut.claim - let selfAssumingCrossBindingSelfDischarge := run Aggr.crossBindingShapeCode - #[childCrossSelfLeft, childCrossRightHonest] crossSelfDischargeBytes - (outClaim? := some crossSelfDischargeBytes) - (preimages := #[bytesCrossSelfLeft, bytesCrossRightHonest, tableA, tableB]) - (trees := Aggr.CheckEnvTrees.structuralAdviceTrees - crossSelfLeft crossRightHonest crossSelfDischargeOut) - (paths := #[ - (a, crossSelfDischargeOut.subjects.merkleProof a), - (b, crossSelfDischargeOut.subjects.merkleProof b), - (c, crossSelfDischargeOut.subjects.merkleProof c), - (d, none)]) - - lspecIO (.ofList [("ix-aggr", [ - test "ixAggr prunes the Ix-agnostic lift entrypoint" liftPruned, - test "pair fold leaves exactly one outstanding assumption" - (outputStatement.assumptions.map (·.leaves) == some #[d]), - test "structural fold is nodeHash(left,right) with one carried assumption" - structuralHostCorrect, - test "production wrap-first policy selects shapes 0, 5, and 9" - wrapFirstShapes, - test "direct-join policy selects raw leaves plus shapes 2 and 8" - directShapes, - test "direct mode still wraps a singleton root" singletonStillWraps, - test "M1-f wrap-first plan is shapes 0x4 then 9x3" m1fWrapShapes, - test "M1-f direct plan is raw leaves then shapes 6, 6, and 9" - m1fDirectShapes, - test "scheduler RAM weights follow the selected ix_aggr shapes" - shapeWeightsBounded, - test "driver specs use uniform aggregate claims and cache version 2" - uniformDriverClaims, - expectOk "wrap of an IxVM child accepts" wrapIxvm, - expectOk "wrap of a self child accepts" wrapSelf, - expectOk "pair (IxVM, IxVM) accepts" pairII, - expectOk "pair (IxVM, self) accepts" pairIA, - expectOk "pair (self, IxVM) accepts" pairAI, - expectOk "pair (self, self) accepts" pairAA, - expectOk "structural pair (IxVM, IxVM) accepts" structuralII, - expectOk "structural pair (IxVM, self) accepts" structuralIA, - expectOk "structural pair (self, IxVM) accepts" structuralAI, - expectOk "structural pair (self, self) accepts" structuralAA, - expectOk "structural parent accepts a structural self child" - nestedStructural, - test "codegen'd pair matches interpreter (output + query counts)" - (sameCounts nativePair pairII), - test "codegen'd wrap matches interpreter (output + query counts)" - (sameCounts nativeWrap wrapIxvm), - test "codegen'd structural pair matches interpreter (output + query counts)" - (sameCounts nativeStructural structuralII), - expectErr "shape hint lying about the child system is rejected" shapeLie, - expectErr "tampered proof advice is rejected" tampered, - expectErr "self child under a foreign identity is rejected" foreignIdentity, - expectErr "wrap output differing from the child statement is rejected" - wrapMismatch, - expectErr "pair output dropping an assumption is rejected" droppedAssumption, - expectErr "pair of children under different claim contexts is rejected" - contextMismatch, - expectErr "pair output with an extra subject is rejected" extraSubject, - expectErr "tree advice not reproducing its keyed root is rejected" - mismatchedTree, - expectErr "flat pair rejects a self-consistent unsorted subject tree" - unsorted, - expectErr "native pair rejects malformed keyed-blob framing" - malformedNativeFraming, - expectErr "ix_aggr rejects a shortened identity blob" shortIdentity, - expectErr "ix_aggr rejects the retired 96-byte identity layout" longIdentity, - expectErr "ix_aggr rejects an out-of-range shape hint" invalidShape, - expectOk "binding discharge of an IxVM child accepts" dischargeLeft, - expectOk "the same binding proof file discharges another claim set" dischargeRight, - expectOk "binding discharge of a self child accepts" dischargeSelf, - expectErr "binding discharge rejects a child that validates its binding" - dischargeValidating, - expectErr "binding discharge rejects a binding claim for another binding" - dischargeOtherBinding, - expectErr "binding discharge rejects an output that still assumes the binding" - dischargeKeepsAssumed, - expectErr "binding discharge rejects an output for other subjects" - dischargeOtherSubjects, - expectErr "a fold rejects children that differ in assuming their binding" - pairMixedValidators, - expectErr "structural pair rejects a path to the wrong root" wrongRootPath, - expectErr "structural pair rejects a tampered path sibling" tamperedPath, - expectErr "structural pair rejects a missing path choice" droppedPath, - expectErr "structural pair rejects an omitted carried assumption" - missingCarried, - expectErr "structural shape hint rejects a flat output root" - structuralHintOnFlatOutput, - expectErr "flat shape hint rejects a structural output root" - flatHintOnStructuralOutput, - expectErr "flat pair rejects a genuinely structural child subject root" - flatFedStructuralChild, - expectOk "range leaf over the whole one-shard batch accepts" rangeLeaf, - expectOk "range leaf over an empty range accepts" emptyRangeLeaf, - expectOk "range join of adjacent ranges accepts" rangeJoin, - expectOk "range root over the whole batch emits the wrap's statement" - rangeRoot, - test "codegen'd range leaf matches interpreter (output + query counts)" - (sameCounts nativeRangeLeaf rangeLeaf), - test "codegen'd range root matches interpreter (output + query counts)" - (sameCounts nativeRangeRoot rangeRoot), - expectErr "range leaf rejects a wrong residual sum" leafWrongResidual, - expectErr "range leaf rejects a proof count differing from the range" - leafCountMismatch, - expectErr "range leaf rejects a range ending before it starts" leafReversed, - expectErr "range leaf rejects a preamble not hashing to the batch digest" - leafWrongBatch, - expectErr "range join rejects non-adjacent ranges" joinNotAdjacent, - expectErr "range join rejects a wrong residual sum" joinWrongSum, - expectErr "range root rejects a range not covering the batch" rootPartial, - expectErr "range root rejects a claim other than the batch's" rootClaimLie, - expectErr "a range statement is not a CheckEnv claim" rangeAsCheckEnv, - test "tables differing in Nat.land share a literal class; Char.ofNat moves it" - classesDistinct, - expectOk "cross-binding pair of one literal class accepts" crossAccepts, - expectOk "cross-binding pair accepts a child already under the class" crossOfClass, - expectErr "cross-binding pair rejects bindings of different literal classes" - crossOtherClass, - expectErr "cross-binding pair rejects a binding that does not bind every role" - crossIncomplete, - expectErr "cross-binding pair rejects a child that assumes its binding" crossAssumed, - expectErr "cross-binding pair rejects an output under another class" crossWrongClass, - expectErr "cross-binding pair rejects an output naming a binding, not a class" - crossValidatorThree, - expectErr "a pair fold rejects claims under two bindings" pairAcrossBindings, - expectOk "catalog join of two member claims accepts" catalogAccepts, - expectOk "catalog join retains a member with an incomplete binding" catalogPartial, - test "catalog plans keep incomplete bindings separate from class folds" plansKeepPartial, - expectOk "catalog join of a catalog and a class claim accepts" catalogNested, - expectErr "catalog join rejects an output missing a member" catalogMissing, - expectErr "catalog join rejects a conditional member claim" catalogConditional, - expectErr "catalog join rejects a member that assumes its binding" catalogAssumed, - expectErr "catalog join rejects a binding claim as a member" catalogOfBinding, - expectErr "catalog join rejects a catalog child without its members tree" - catalogTampered, - expectErrContains "flat pair rejects duplicated self-assuming children join(q, q)" - "aggr: subject set overlaps assumption set" - selfAssumingFlatDuplicate, - expectErrContains "flat pair rejects a child whose subject set overlaps its own assumptions" - "aggr: subject set overlaps assumption set" - selfAssumingFlatDisjointSubjects, - expectErrContains "flat pair rejects children with overlapping subject sets" - "aggr: child subject sets overlap" - overlappingFlatSubjects, - expectErrContains "structural pair rejects duplicated self-assuming children join(q, q)" - "aggr structural: child subject roots must be distinct" - selfAssumingStructuralDuplicate, - expectErrContains "structural pair rejects discharging a left assumption against the left subject tree" - "aggr structural: left assumption must be discharged by right child" - selfAssumingStructuralSelfDischarge, - expectErrContains "structural pair rejects discharging a right assumption against the right subject tree" - "aggr structural: right assumption must be discharged by left child" - selfAssumingStructuralRightSelfDischarge, - expectErrContains "structural pair rejects discharging an assumption shared by both children" - "aggr structural: shared assumption cannot be discharged" - sharedStructuralAssumptionDischarged, - expectErrContains "cross-binding pair rejects children with identical subject roots" - "aggr cross-binding: child subject roots must be distinct" - selfAssumingCrossBindingDuplicate, - expectErrContains "cross-binding pair rejects discharging a left assumption against the left subject tree" - "aggr structural: left assumption must be discharged by right child" - selfAssumingCrossBindingSelfDischarge, - ])]) [] - -end Tests.Aggr - -end diff --git a/Tests/AggrActivation.lean b/Tests/AggrActivation.lean deleted file mode 100644 index 90d5ec8db..000000000 --- a/Tests/AggrActivation.lean +++ /dev/null @@ -1,554 +0,0 @@ -module - -public import Tests.Aggr - -/-! -# `ix_aggr` activation audit - -M1-e replaces the pre-convergence lift/flat/structural-entrypoint audit with -an audit of the one production `ix_aggr` entrypoint and all ten verified shape -arms. The deterministic matrix crosses: - -* two controlled child trace heights; -* wrap shapes 0–1; -* pair shapes 2–9; -* optional assumptions independently on the left and right; and -* assumptions that are either discharged by the other subject tree or carried - into the output. - -That produces 4 wrap executions plus 128 pair executions. The runner executes -the complete 132-case matrix twice through the generated native path, compares -every per-circuit query count, and emits a Markdown report. It records -activation only; dummy-call policy remains deferred until a static final circuit -is selected. --/ - -public section - -open Aiur - -namespace Tests.Aggr -namespace ActivationAudit - -inductive Height where - | short - | tall - deriving BEq, Repr - -private def Height.label : Height → String - | .short => "short" - | .tall => "tall" - -inductive ChildKind where - | ixvm - | aggr - deriving BEq, Repr - -private def ChildKind.label : ChildKind → String - | .ixvm => "ixvm" - | .aggr => "aggr" - -private def ChildKind.shapeCode : ChildKind → Nat - | .ixvm => 0 - | .aggr => 1 - -inductive Disposition where - | discharge - | carry - deriving BEq, Repr - -private def Disposition.label : Disposition → String - | .discharge => "discharge" - | .carry => "carry" - -/-- Cheap parameters are sufficient here: the audit studies which verifier -circuits execute, not production soundness calibration or proof size. -/ -private def auditFri : Aiur.FriParameters := - { logFinalPolyLen := 0, maxLogArity := 1, numQueries := 1, - commitProofOfWorkBits := 0, queryProofOfWorkBits := 0 } - -/-- The two fake child entrypoints have the exact public-claim layouts accepted -by `ix_aggr`. Both vary their trace height from the output-claim digest, letting -one statement fixture drive the same height through either child kind. -/ -private def childProgram : Source.Toplevel := ⟦ - fn activation_height_probe(n: G) { - match n { - 0 => (), - _ => activation_height_probe(n - 1), - } - } - - fn activation_vary_height(digest: [G; 8]) { - match u32_less_than(digest[0], digest[1]) { - 1 => activation_height_probe(1), - _ => activation_height_probe(4), - } - } - - pub fn fake_verify_claim(digest: [G; 8]) { - activation_vary_height(digest) - } - - pub fn fake_aggr(allowed_digest: [G; 8], out_claim_digest: [G; 8]) { - activation_vary_height(out_claim_digest); - assert_eq!(load(store(allowed_digest[0])), allowed_digest[0]); - () - } -⟧ - -private def canonicalTree (leaves : Array Address) : Ix.AssumptionTree := - (Ix.AssumptionTree.canonical leaves).get! - -private def digestSelectsShort (digest : Array Aiur.G) : Bool := - match digest[0]?, digest[1]? with - | some a, some b => decide (a.n < b.n) - | _, _ => false - -private structure Indices where - verify : Aiur.Bytecode.FunIdx - aggr : Aiur.Bytecode.FunIdx - -private structure Fixture where - height : Height - salt : Nat - leftNone : Aggr.CheckEnvTrees - leftDischarge : Aggr.CheckEnvTrees - leftCarry : Aggr.CheckEnvTrees - rightNone : Aggr.CheckEnvTrees - rightDischarge : Aggr.CheckEnvTrees - rightCarry : Aggr.CheckEnvTrees - -private def fixtureAt (height : Height) (salt : Nat) : Fixture := - let address (side : String) := - Address.blake3 (s!"ix-aggr-activation-{salt}-{side}").toUTF8 - let a := address "subject-left" - let b := address "subject-right" - let c := address "carry-left" - let d := address "carry-right" - let leftSubjects := canonicalTree #[a] - let rightSubjects := canonicalTree #[b] - { - height - salt - leftNone := { ctx := testCtx, subjects := leftSubjects, assumptions := none } - leftDischarge := { - ctx := testCtx, subjects := leftSubjects, assumptions := some (canonicalTree #[b]) } - leftCarry := { - ctx := testCtx, subjects := leftSubjects, assumptions := some (canonicalTree #[c]) } - rightNone := { ctx := testCtx, subjects := rightSubjects, assumptions := none } - rightDischarge := { - ctx := testCtx, subjects := rightSubjects, assumptions := some (canonicalTree #[a]) } - rightCarry := { - ctx := testCtx, subjects := rightSubjects, assumptions := some (canonicalTree #[d]) } - } - -private def Fixture.statements (fixture : Fixture) : Array Aggr.CheckEnvTrees := - #[fixture.leftNone, fixture.leftDischarge, fixture.leftCarry, - fixture.rightNone, fixture.rightDischarge, fixture.rightCarry] - -/-- Find six related statements whose claim digests all select the requested -height branch. The expected search is 64 salts; the generous bound keeps the -fixture deterministic without baking opaque addresses into the source. -/ -private def findFixture (height : Height) : Except String Fixture := do - let wantShort := height == .short - let some salt := (Array.range 65536).find? fun salt => - let fixture := fixtureAt height salt - fixture.statements.all fun statement => - digestSelectsShort (MultiStark.digestGs (Ix.Claim.ser statement.claim)) == - wantShort - | throw s!"activation audit: no {height.label} statement fixture found" - pure (fixtureAt height salt) - -private structure HeightConfig where - fixture : Fixture - probeRows : Nat - -private def prepareHeightConfig (compiled : Aiur.CompiledToplevel) - (indices : Indices) (probeIdx : Aiur.Bytecode.FunIdx) (height : Height) : - Except String HeightConfig := do - let fixture ← findFixture height - let input := MultiStark.digestGs (Ix.Claim.ser fixture.leftNone.claim) - let (_, _, counts) ← compiled.bytecode.execute indices.verify input default - let some count := counts[probeIdx]? - | throw s!"activation audit: missing height-probe query count {probeIdx}" - pure { fixture, probeRows := count.uniqueRows } - -private def selectStatement (withoutAsm discharge carry : Aggr.CheckEnvTrees) - (present : Bool) (disposition : Disposition) : Aggr.CheckEnvTrees := - if !present then withoutAsm - else match disposition with - | .discharge => discharge - | .carry => carry - -private def assumptionLabel (present : Bool) : String := - if present then "some" else "none" - -private structure PreparedChild where - proofAdviceBytes : ByteArray - claimsBytes : ByteArray - -private def prepareChild (ixvmSystem selfSystem : Aiur.AiurSystem) - (indices : Indices) (allowed : ByteArray) (kind : ChildKind) - (statement : Aggr.CheckEnvTrees) : Except String PreparedChild := do - let claimBytes := Ix.Claim.ser statement.claim - let (system, idx, input) := match kind with - | .ixvm => (ixvmSystem, indices.verify, MultiStark.digestGs claimBytes) - | .aggr => (selfSystem, indices.aggr, Aggr.pubInput allowed claimBytes) - let (outer, proof, _) ← system.prove idx input default - let proofAdviceBytes ← system.proofToAdviceBytes outer proof - pure { - proofAdviceBytes - claimsBytes := MultiStark.serializeClaims #[outer] - } - -private structure PairShape where - shape : Nat - structural : Bool - leftKind : ChildKind - rightKind : ChildKind - -private def pairShapes : Array PairShape := #[ - { shape := 2, structural := false, leftKind := .ixvm, rightKind := .ixvm }, - { shape := 3, structural := false, leftKind := .ixvm, rightKind := .aggr }, - { shape := 4, structural := false, leftKind := .aggr, rightKind := .ixvm }, - { shape := 5, structural := false, leftKind := .aggr, rightKind := .aggr }, - { shape := 6, structural := true, leftKind := .ixvm, rightKind := .ixvm }, - { shape := 7, structural := true, leftKind := .ixvm, rightKind := .aggr }, - { shape := 8, structural := true, leftKind := .aggr, rightKind := .ixvm }, - { shape := 9, structural := true, leftKind := .aggr, rightKind := .aggr } -] - -private structure WrapCase where - label : String - shape : Nat - statement : Aggr.CheckEnvTrees - child : PreparedChild - -private structure PairCase where - label : String - pair : PairShape - left : Aggr.CheckEnvTrees - right : Aggr.CheckEnvTrees - leftChild : PreparedChild - rightChild : PreparedChild - -private def prepareWrapCases (ixvmSystem selfSystem : Aiur.AiurSystem) - (indices : Indices) (allowed : ByteArray) - (configs : Array HeightConfig) : Except String (Array WrapCase) := do - let mut cases : Array WrapCase := #[] - for config in configs do - for kind in #[ChildKind.ixvm, .aggr] do - let child ← prepareChild ixvmSystem selfSystem indices allowed kind - config.fixture.leftNone - cases := cases.push { - label := s!"shape={kind.shapeCode},height={config.fixture.height.label},\ - child={kind.label}" - shape := kind.shapeCode - statement := config.fixture.leftNone - child - } - pure cases - -private def preparePairCases (ixvmSystem selfSystem : Aiur.AiurSystem) - (indices : Indices) (allowed : ByteArray) - (configs : Array HeightConfig) : Except String (Array PairCase) := do - let mut cases : Array PairCase := #[] - for config in configs do - let fixture := config.fixture - for disposition in #[Disposition.discharge, .carry] do - for leftAsm in #[false, true] do - for rightAsm in #[false, true] do - let left := selectStatement fixture.leftNone fixture.leftDischarge - fixture.leftCarry leftAsm disposition - let right := selectStatement fixture.rightNone fixture.rightDischarge - fixture.rightCarry rightAsm disposition - for pair in pairShapes do - let leftChild ← prepareChild ixvmSystem selfSystem indices allowed - pair.leftKind left - let rightChild ← prepareChild ixvmSystem selfSystem indices allowed - pair.rightKind right - cases := cases.push { - label := s!"shape={pair.shape},height={fixture.height.label},\ - left-asm={assumptionLabel leftAsm},\ - right-asm={assumptionLabel rightAsm},\ - disposition={disposition.label},\ - children={pair.leftKind.label}+{pair.rightKind.label}" - pair - left - right - leftChild - rightChild - } - pure cases - -private structure Sample where - label : String - shape : Nat - queryCounts : Array Aiur.QueryCount - -private def runWrap (compiled : Aiur.CompiledToplevel) - (idx : Aiur.Bytecode.FunIdx) (ixvmVk selfVk allowed : ByteArray) - (case : WrapCase) : Except String Sample := do - let claimBytes := Ix.Claim.ser case.statement.claim - let (_, queryCounts) ← match compiled.bytecode.executeIxAggr idx - (Aggr.pubInput allowed claimBytes) case.shape - case.child.proofAdviceBytes ByteArray.empty ixvmVk selfVk - case.child.claimsBytes ByteArray.empty claimBytes allowed - (Aggr.preimagesBlob #[]) (Aggr.treesBlob #[]) (Aggr.pathsBlob #[]) with - | .ok result => pure result - | .error e => throw s!"{case.label}: {e}" - pure { label := case.label, shape := case.shape, queryCounts } - -private def runPair (compiled : Aiur.CompiledToplevel) - (idx : Aiur.Bytecode.FunIdx) (ixvmVk selfVk allowed : ByteArray) - (case : PairCase) : Except String Sample := do - let output := if case.pair.structural then - case.left.joinStructural case.right - else - case.left.join case.right - let trees := if case.pair.structural then - Aggr.CheckEnvTrees.structuralAdviceTrees case.left case.right output - else - Aggr.CheckEnvTrees.adviceTrees case.left case.right output - let paths := if case.pair.structural then - Aggr.CheckEnvTrees.structuralPathAdvice case.left case.right output - else #[] - let leftBytes := Ix.Claim.ser case.left.claim - let rightBytes := Ix.Claim.ser case.right.claim - let outputBytes := Ix.Claim.ser output.claim - let (_, queryCounts) ← match compiled.bytecode.executeIxAggr idx - (Aggr.pubInput allowed outputBytes) case.pair.shape - case.leftChild.proofAdviceBytes case.rightChild.proofAdviceBytes - ixvmVk selfVk case.leftChild.claimsBytes case.rightChild.claimsBytes - outputBytes allowed (Aggr.preimagesBlob #[leftBytes, rightBytes]) - (Aggr.treesBlob trees) (Aggr.pathsBlob paths) with - | .ok result => pure result - | .error e => throw s!"{case.label}: {e}" - pure { label := case.label, shape := case.pair.shape, queryCounts } - -private def collect (compiled : Aiur.CompiledToplevel) - (idx : Aiur.Bytecode.FunIdx) (ixvmVk selfVk allowed : ByteArray) - (wrapCases : Array WrapCase) (pairCases : Array PairCase) : - Except String (Array Sample) := do - let mut samples : Array Sample := #[] - for case in wrapCases do - samples := samples.push (← runWrap compiled idx ixvmVk selfVk allowed case) - for case in pairCases do - samples := samples.push (← runPair compiled idx ixvmVk selfVk allowed case) - pure samples - -private def queryCountsEq (left right : Array Aiur.QueryCount) : Bool := - left.size == right.size && (left.zip right).all fun (a, b) => - a.uniqueRows == b.uniqueRows && a.totalHits == b.totalHits - -private def samplesEq (left right : Array Sample) : Bool := - left.size == right.size && (left.zip right).all fun (a, b) => - a.label == b.label && a.shape == b.shape && - queryCountsEq a.queryCounts b.queryCounts - -private structure Circuit where - name : String - queryIdx : Nat - -private def circuits (compiled : Aiur.CompiledToplevel) : Array Circuit := Id.run do - let reverseNames := compiled.nameMap.fold - (init := ({} : Std.HashMap Aiur.Bytecode.FunIdx String)) - fun names global idx => - let name := toString global - match names[idx]? with - | none => names.insert idx name - | some old => if compare name old == .lt then names.insert idx name else names - let mut result : Array Circuit := #[] - for (function, idx) in compiled.bytecode.functions.mapIdx - fun idx function => (function, idx) do - if function.constrained then - result := result.push { - name := reverseNames[idx]?.getD s!"fn[{idx}]" - queryIdx := idx - } - let functionCount := compiled.bytecode.functions.size - for (width, idx) in compiled.bytecode.memorySizes.mapIdx fun idx width => - (width, idx) do - result := result.push { - name := s!"memory[{width}]" - queryIdx := functionCount + idx - } - pure result - -private structure Cell where - active : Nat - total : Nat - minActiveRows : Nat - maxActiveRows : Nat - -private def rowsAt (sample : Sample) (queryIdx : Nat) : Nat := - match sample.queryCounts[queryIdx]? with - | some count => count.uniqueRows - | none => 0 - -private def cell (samples : Array Sample) (queryIdx : Nat) : Cell := - let activeRows := samples.map (rowsAt · queryIdx) |>.filter (· != 0) - let minActiveRows := match activeRows[0]? with - | none => 0 - | some first => activeRows.foldl Nat.min first - { - active := activeRows.size - total := samples.size - minActiveRows - maxActiveRows := activeRows.foldl Nat.max 0 - } - -private def Cell.render (summary : Cell) : String := - if summary.active == 0 then s!"0/{summary.total}" - else s!"{summary.active}/{summary.total} \ - ({summary.minActiveRows}..{summary.maxActiveRows})" - -private def shapeSamples (samples : Array Sample) (shape : Nat) : Array Sample := - samples.filter fun sample => sample.shape == shape - -private def activationSignature (samples : Array Sample) : Address := - let lines := samples.map fun sample => - let counts := sample.queryCounts.map fun count => - s!"{count.uniqueRows}/{count.totalHits}" - sample.label ++ ":" ++ String.intercalate "," counts.toList - Address.blake3 (String.intercalate "\n" lines.toList).toUTF8 - -private def report (compiled : Aiur.CompiledToplevel) - (configs : Array HeightConfig) (samples : Array Sample) : String := - let catalog := circuits compiled - let affected := catalog.filter fun circuit => - let summary := cell samples circuit.queryIdx - summary.active < summary.total - let alwaysActive := catalog.countP fun circuit => - (cell samples circuit.queryIdx).active == samples.size - let variableCount := catalog.countP fun circuit => - let summary := cell samples circuit.queryIdx - summary.active != 0 && summary.active < summary.total - let neverObserved := catalog.countP fun circuit => - (cell samples circuit.queryIdx).active == 0 - let shapeCounts := (Array.range 10).map fun shape => - s!"shape {shape}: {(shapeSamples samples shape).size}" - let configRows := configs.map fun config => - s!"| {config.fixture.height.label} | {config.fixture.salt} | \ - {config.probeRows} |" - let tableHeader := "| Circuit | " ++ - String.intercalate " | " ((Array.range 10).map fun shape => - s!"Shape {shape}").toList ++ " |" - let tableDivider := "|---|" ++ - String.intercalate "" ((Array.range 10).map fun _ => "---:|").toList - let circuitRows := affected.map fun circuit => - let cells := (Array.range 10).map fun shape => - (cell (shapeSamples samples shape) circuit.queryIdx).render - s!"| `{circuit.name}` | {String.intercalate " | " cells.toList} |" - let introduction := #[] - |>.push "# `ix_aggr` activation audit" - |>.push "" - |>.push s!"- Matrix signature: `{activationSignature samples}`" - |>.push s!"- Accepted executions: {samples.size} \ - ({String.intercalate ", " shapeCounts.toList})" - |>.push "- Axes: two child trace heights; both wrap shapes; every flat and \ - structural child-kind shape; assumption root `{none,some}` independently \ - per side; and `{discharge,carry}`." - |>.push "- Counts are `active cases / total cases (min..max unique rows when active)`." - |>.push "- Catalog covers constrained function circuits and memory circuits. \ - `Bytes1`/`Bytes2` are fixed-height preprocessed circuits and are not \ - represented in the execute FFI's query-count array." - |>.push s!"- Catalog summary: {catalog.size} circuits; {alwaysActive} active \ - in every case; {variableCount} input-dependent; {neverObserved} never observed." - |>.push "- Dummy calls remain deferred until a static final circuit is selected." - |>.push "" - |>.push "## Trace-height control" - |>.push "" - |>.push "| Height | Fixture salt | `activation_height_probe` unique rows |" - |>.push "|---|---:|---:|" - let circuitHeader := (introduction ++ configRows) - |>.push "" - |>.push "## Circuits inactive in at least one audited shape" - |>.push "" - |>.push tableHeader - |>.push tableDivider - String.intercalate "\n" (circuitHeader ++ circuitRows).toList - -def run : IO UInt32 := do - IO.println "aggregate-activation (132-case ix_aggr matrix, two deterministic passes)…" - let childCompiled ← match childProgram.compile with - | .error e => IO.eprintln s!"activation child compilation failed: {e}"; return 1 - | .ok compiled => pure compiled - let some verifyIdx := childCompiled.getFuncIdx `fake_verify_claim | do - IO.eprintln "activation audit: fake_verify_claim entrypoint not found"; return 1 - let some fakeAggrIdx := childCompiled.getFuncIdx `fake_aggr | do - IO.eprintln "activation audit: fake_aggr entrypoint not found"; return 1 - let some probeIdx := childCompiled.getFuncIdx `activation_height_probe | do - IO.eprintln "activation audit: height probe not found"; return 1 - let indices : Indices := { verify := verifyIdx, aggr := fakeAggrIdx } - let ixvmSystem := Aiur.AiurSystem.build childCompiled.bytecode - Tests.ProofHelpers.recCommitParams auditFri - let selfSystem := Aiur.AiurSystem.build childCompiled.bytecode - Tests.ProofHelpers.recCommitParams { auditFri with numQueries := 2 } - let ixvmVk := ixvmSystem.vkBytes - let selfVk := selfSystem.vkBytes - let allowed := Aggr.allowedBlob ixvmVk verifyIdx selfVk fakeAggrIdx - - let short ← match prepareHeightConfig childCompiled indices probeIdx .short with - | .error e => IO.eprintln e; return 1 - | .ok config => pure config - let tall ← match prepareHeightConfig childCompiled indices probeIdx .tall with - | .error e => IO.eprintln e; return 1 - | .ok config => pure config - if short.probeRows >= tall.probeRows then - IO.eprintln s!"activation audit: height controls did not vary the trace \ - ({short.probeRows} vs {tall.probeRows} rows)" - return 1 - let configs := #[short, tall] - let wrapCases ← match prepareWrapCases ixvmSystem selfSystem indices allowed configs with - | .error e => IO.eprintln s!"activation wrap preparation failed: {e}"; return 1 - | .ok cases => pure cases - let pairCases ← match preparePairCases ixvmSystem selfSystem indices allowed configs with - | .error e => IO.eprintln s!"activation pair preparation failed: {e}"; return 1 - | .ok cases => pure cases - if wrapCases.size != 4 || pairCases.size != 128 then - IO.eprintln s!"activation audit: expected 4 wraps + 128 pairs, built \ - {wrapCases.size} + {pairCases.size}" - return 1 - - let top ← match Aggr.ixAggr with - | .error e => IO.eprintln s!"activation toplevel merge failed: {e}"; return 1 - | .ok top => pure top - let compiled ← match top.compileWithGroups Aggr.functionGroups with - | .error e => IO.eprintln s!"activation toplevel compilation failed: {e}"; return 1 - | .ok compiled => pure compiled - let some ixAggrIdx := compiled.getFuncIdx `ix_aggr | do - IO.eprintln "activation audit: ix_aggr entrypoint not found"; return 1 - - let first ← match collect compiled ixAggrIdx ixvmVk selfVk allowed - wrapCases pairCases with - | .error e => IO.eprintln s!"activation audit pass 1 failed: {e}"; return 1 - | .ok samples => pure samples - let second ← match collect compiled ixAggrIdx ixvmVk selfVk allowed - wrapCases pairCases with - | .error e => IO.eprintln s!"activation audit pass 2 failed: {e}"; return 1 - | .ok samples => pure samples - if first.size != 132 then - IO.eprintln s!"activation audit: expected 132 samples, collected {first.size}" - return 1 - let expectedQueryCounts := compiled.bytecode.functions.size + - compiled.bytecode.memorySizes.size - if first.any fun sample => sample.queryCounts.size != expectedQueryCounts then - IO.eprintln s!"activation audit: a sample returned the wrong query-count \ - cardinality (expected {expectedQueryCounts})" - return 1 - if !samplesEq first second then - IO.eprintln "activation audit: query-count matrix changed between passes" - return 1 - IO.println (report compiled configs first) - IO.println "" - IO.println "[activation-audit] stable across two passes" - return 0 - -end ActivationAudit - -def activationAudit : IO UInt32 := ActivationAudit.run - -end Tests.Aggr - -end diff --git a/Tests/AggrProof.lean b/Tests/AggrProof.lean deleted file mode 100644 index c0ef55bfd..000000000 --- a/Tests/AggrProof.lean +++ /dev/null @@ -1,58 +0,0 @@ -module - -public import Tests.Aggr - -/-! -A current-format proof round trip through the production `ix_aggr` circuit. -The child is a small stand-in for IxVM; both systems use one query and no PoW -to keep this explicit integration gate tractable. These are test parameters, -not the production security configuration. --/ - -public section - -namespace Tests.Aggr - -def proofRoundTrip : IO UInt32 := do - let commitment : Aiur.CommitmentParameters := { logBlowup := 1, capHeight := 0 } - let fri : Aiur.FriParameters := { - logFinalPolyLen := 0, maxLogArity := 1, numQueries := 1 - commitProofOfWorkBits := 0, queryProofOfWorkBits := 0 } - let child ← IO.ofExcept childProgram.compile - let childIdx := child.getFuncIdx `fake_verify_claim |>.get! - let childSystem := Aiur.AiurSystem.build child.bytecode commitment fri - let top ← IO.ofExcept <| Aggr.ixAggr.mapError (fun e => s!"{e}") - let compiled ← IO.ofExcept <| top.compileWithGroups Aggr.functionGroups - let idx := compiled.getFuncIdx `ix_aggr |>.get! - let system := Aiur.AiurSystem.build compiled.bytecode commitment fri - let childVk := childSystem.vkBytes - let selfVk := system.vkBytes - let allowed := Aggr.allowedBlob childVk childIdx selfVk idx - let statement : Aggr.CheckEnvTrees := { - ctx := testCtx - subjects := (Ix.AssumptionTree.canonical #[Address.blake3 "proof-round-trip".toUTF8]).get! - assumptions := none } - let bytes := Ix.Claim.ser statement.claim - let (childClaim, childProof, _) ← IO.ofExcept <| - childSystem.prove childIdx (MultiStark.digestGs bytes) default - let childAdvice ← IO.ofExcept <| childSystem.proofToAdviceBytes childClaim childProof - let claims := MultiStark.serializeClaims #[childClaim] - IO.println "Proving the production ix_aggr wrap with one-query test parameters…" - let (claim, proof) ← IO.ofExcept <| system.proveIxAggr idx - (Aggr.pubInput allowed bytes) 0 childAdvice ByteArray.empty childVk selfVk - claims ByteArray.empty bytes allowed - (Aggr.preimagesBlob #[]) (Aggr.treesBlob #[]) (Aggr.pathsBlob #[]) - let expected := Aiur.buildClaim idx (Aggr.pubInput allowed bytes) #[] - let decoded := Aiur.Proof.ofBytesChecked proof.toBytes - let tampered := expected.set! 2 ((expected[2]?).getD 0 + 1) - LSpec.lspecIO (.ofList [("aggregate-proof", [ - LSpec.test "production aggregation returns the exact outer claim" (claim == expected), - Tests.ProofHelpers.expectOk "production aggregate proof verifies" (system.verify expected proof), - Tests.ProofHelpers.expectOk "current proof bytes decode and verify" - (decoded.bind (system.verify expected)), - Tests.ProofHelpers.expectErr "aggregate proof rejects a changed outer claim" - (system.verify tampered proof) - ])]) [] - -end Tests.Aggr -end diff --git a/Tests/AggrSemantics.lean b/Tests/AggrSemantics.lean index 0c211383b..99a7818f6 100644 --- a/Tests/AggrSemantics.lean +++ b/Tests/AggrSemantics.lean @@ -1,15 +1,14 @@ module -public import Tests.Aggr +public import LSpec +public import Tests.ProofHelpers public import Ix.Aggr.Reference public import Ix.Cli.VerifyCmd /-! # Aggregate statements, manifests, and verification -Pure statement/plan checks and cross-language manifest tests complement the -production circuit tests in `Tests/Aggr.lean`. Native cache and scheduler -regressions live beside the Rust controller. +Pure statement/plan checks and cross-language manifest tests. -/ public section @@ -40,17 +39,11 @@ private def minimalIxesFor (shards : Array (Array Address)) private def minimalIxes (treeTail : Array UInt8) : ByteArray := minimalIxesFor #[#[], #[]] treeTail -/-- The test environments carry the default role binding, as every - environment a claim is made over must: its section alone. They are - partitioned, planned and audited here, never checked, so they leave out - the records the circuit validates roles against - (`IxVM.ClaimHarness.withDefaultRoleBinding`), which no shard owns. -/ private def bound (env : Ixon.Env) : Ixon.Env := match Ix.Kernel.Reader.defaultTableBytes, Ix.Kernel.Reader.defaultTableAddress with | .ok bytes, .ok address => { env with roleBinding := some { address, bytes } } | _, _ => env -/-- The claims' context: the default role table's. -/ private def envCtx : Ix.ClaimContext := Ix.ClaimContext.ofDefaultTable.toOption.getD default @@ -71,8 +64,6 @@ private def pairIxonEnv : Ixon.Env × Address × Address := |>.storeConst rightAddress right (bound env, leftAddress, rightAddress) -/-- Two owned constants with one shared dependency exercise the one-pass -witness-closure union retained by the converged driver. -/ private def sharedClosureIxonEnv : Ixon.Env × Array Address × Address := let shared : Ixon.Constant := ⟨.defn ⟨.defn, .safe, 0, .sort 1, .sort 0⟩, #[], #[], #[.zero, .succ .zero]⟩ @@ -102,13 +93,6 @@ private def stage2FixtureStorePath (home : System.FilePath) : System.FilePath := home / ".ix" / "store" / "c2" / "fd" / "ce" / "660eb66899efa303b41d4ca1611a62a688ef20684fdc327739d38bd67f" -/-- Pin a real whole-Mathlib root at the persisted-proof boundary. The 3.33 GB -environment and 52.5 MB manifest are identified in the adjacent provenance -record rather than checked in. This proof predates the a8aab731 protocol -bump, the batch wire format and the Ixon v3 claim envelope. The gate -re-hashes the exact old wrapper, pins its root bytes and unconditional flag, -and checks rejection at the format boundary. No legacy decoding path is -added to the production reader. -/ private def stage2FixturePinnedAndFenced : IO Bool := do try unless (← stage2FixturePath.pathExists) do @@ -156,13 +140,10 @@ private def stage2FixturePinnedAndFenced : IO Bool := do if out.exitCode == 0 then IO.eprintln "historical Stage 2 fixture unexpectedly verified under the current protocol" return false - -- The fence is the protocol boundary, wherever it currently falls: a - -- claim envelope the reader no longer accepts, a decoded proof of an - -- incompatible shape, or bytes that no longer decode as a proof at - -- all (the batch wire format). let fenced (s : String) : Bool := s.contains "claim: unsupported object format" || - s.contains "InvalidProofShape" || s.contains "does not decode" + s.contains "InvalidProofShape" || s.contains "does not decode" || + s.contains "unrecognized proof format" unless fenced out.stderr || fenced out.stdout do IO.eprintln s!"obsolete Stage 2 fixture failed for an unexpected reason \ ({out.exitCode}): {out.stderr.take 500}" @@ -175,48 +156,30 @@ private def stage2FixturePinnedAndFenced : IO Bool := do return false def semanticSuite : IO UInt32 := do - let childCompiled ← match childProgram.compile with - | .error e => IO.eprintln s!"aggr semantic child compilation failed: {e}"; return 1 - | .ok compiled => pure compiled - let verifyIdx := childCompiled.getFuncIdx `fake_verify_claim |>.get! - let fakeAggrIdx := childCompiled.getFuncIdx `fake_aggr |>.get! - let ixvmSystem := AiurSystem.build childCompiled.bytecode recCommitParams innerFri - let selfSystem := AiurSystem.build childCompiled.bytecode recCommitParams - { innerFri with numQueries := 4 } - let ixvmVk := ixvmSystem.vkBytes - let selfVk := selfSystem.vkBytes + let verifyIdx : Nat := 0 + let fakeAggrIdx : Nat := 1 + let ixvmVk := "standin-ixvm-vk".toUTF8 + let selfVk := "standin-aggr-vk".toUTF8 let allowed := Aggr.allowedBlob ixvmVk verifyIdx selfVk fakeAggrIdx -- Recursion parameter and cache-key contract. let recursionDefaults := Aggr.defaultRecursionParameters - let defaultRecursionSystem := - Aggr.buildRecursionSystem childCompiled.bytecode recursionDefaults - let directDefaultSystem := AiurSystem.build childCompiled.bytecode - Aiur.defaultCommitmentParameters Aiur.defaultFriParameters let expectedDefaultFriBytes : ByteArray := ⟨u64le 0 ++ u64le 1 ++ u64le 100 ++ u64le 0 ++ u64le 20⟩ let tunedFri : Aiur.FriParameters := { recursionDefaults.fri with numQueries := 50 } let tunedFriParameters : Aggr.RecursionParameters := { recursionDefaults with fri := tunedFri } - let tunedFriSystem := - Aggr.buildRecursionSystem childCompiled.bytecode tunedFriParameters let tunedCommitment : Aiur.CommitmentParameters := { recursionDefaults.commitment with logBlowup := 3 } let tunedCommitmentParameters : Aggr.RecursionParameters := { recursionDefaults with commitment := tunedCommitment } - let tunedCommitmentSystem := - Aggr.buildRecursionSystem childCompiled.bytecode tunedCommitmentParameters - let defaultRecursionIdentityPreserved := - defaultRecursionSystem.vkBytes == directDefaultSystem.vkBytes let defaultFriEncodingStable := recursionDefaults.cacheFriBytes.size == 40 && recursionDefaults.cacheFriBytes == expectedDefaultFriBytes let recursionParametersIndependent := tunedFriParameters.cacheFriBytes != recursionDefaults.cacheFriBytes && - tunedFriSystem.vkBytes != defaultRecursionSystem.vkBytes && - tunedCommitmentParameters.cacheFriBytes == recursionDefaults.cacheFriBytes && - tunedCommitmentSystem.vkBytes != defaultRecursionSystem.vkBytes + tunedCommitmentParameters.cacheFriBytes == recursionDefaults.cacheFriBytes -- Two conditional statements whose assumptions cross the subject boundary. let a := Address.blake3 "aggr-semantics-a".toUTF8 @@ -254,8 +217,6 @@ def semanticSuite : IO UInt32 := do let hostJoinRejectsSelfDischarge := (selfAssumingStmt.join selfAssumingStmt).assumptions.map (·.leaves) == some #[a] && (selfAssumingStmt.joinStructural selfAssumingStmt).assumptions.map (·.leaves) == some #[a] - let leftBytes := Ix.Claim.ser left.claim - let rightBytes := Ix.Claim.ser right.claim let flatBytes := Ix.Claim.ser flatOutput.claim let leftOuter := Aggr.aggregateOuterClaim allowed fakeAggrIdx left.claim @@ -263,14 +224,6 @@ def semanticSuite : IO UInt32 := do allowed fakeAggrIdx right.claim let flatOuter := Aggr.aggregateOuterClaim allowed fakeAggrIdx flatOutput.claim - let (_, leftProof, _) ← match selfSystem.prove fakeAggrIdx - (Aggr.pubInput allowed leftBytes) default with - | .error e => IO.eprintln s!"left aggregate prove failed: {e}"; return 1 - | .ok result => pure result - let (_, rightProof, _) ← match selfSystem.prove fakeAggrIdx - (Aggr.pubInput allowed rightBytes) default with - | .error e => IO.eprintln s!"right aggregate prove failed: {e}"; return 1 - | .ok result => pure result let outerClaimBindsValue := leftOuter != rightOuter && flatOuter == Aiur.buildClaim fakeAggrIdx (Aggr.pubInput allowed flatBytes) #[] @@ -343,10 +296,9 @@ def semanticSuite : IO UInt32 := do direct.back?.map (·.outerClaim) | _, _ => false - -- Verified cache/resume against the converged outer claim. let cachedWrapper : Ixon.Proof := { claim := left.claim - proof := leftProof.toBytes + proof := "standin-proof".toUTF8 } let cachedAddress := Address.blake3 (Ixon.Proof.ser cachedWrapper) let cachedBytes := Ixon.Proof.ser cachedWrapper @@ -360,7 +312,7 @@ def semanticSuite : IO UInt32 := do match Aggr.decodeAggregateWrapperAt wrongAddress cachedBytes with | .error _ => true | .ok _ => false - -- Manifest parsing, validate-before-prune, and value-based verification. + let manifestPlan := (Ix.Shard.AggregationTree.node (.node (.leaf 0) (.leaf 1)) (.leaf 2)).foldPlan @@ -399,34 +351,6 @@ def semanticSuite : IO UInt32 := do statement.claim == .checkEnv envCtx (canonicalTree #[singleAddr]).root none | .error _ => false | .error _ => false - let (nativePlanOnlyFfiWorks, nativeVerifyRootMatches) ← do - let dir ← IO.FS.createTempDir - let ixePath := dir / "native-plan.ixe" - let ixesPath := dir / "native-plan.ixes" - match Ixon.serEnv singleEnv with - | .error _ => pure (false, false) - | .ok envBytes => - IO.FS.writeBinFile ixePath envBytes - IO.FS.writeBinFile ixesPath <| minimalIxesFor #[#[singleAddr]] - (#[1, 0] ++ u32le4 0 ++ #[0]) - match Aiur.EnvHandle.fromIxe ixePath.toString with - | .error _ => pure (false, false) - | .ok handle => - let planWorks := (ixvmSystem.aggregateStage2 selfSystem handle - ixesPath.toString "" verifyIdx fakeAggrIdx 1 - (16 * 1024 * 1024 * 1024) 4096 0 false true - childRecursionParameters.cacheFriBytes false true false 0 false 1 - false 0 "").isOk - let expectedMatches := match Aiur.AiurSystem.aggregateExpected - handle ixesPath.toString 4096 with - | .error _ => false - | .ok expected => - expected.constantCount == 1 && match - Ixon.runGet Ix.Claim.get expected.claimBytes with - | .ok claim => - claim == .checkEnv envCtx (canonicalTree #[singleAddr]).root none - | .error _ => false - pure (planWorks, expectedMatches) let (pairEnv, pairLeft, pairRight) := pairIxonEnv let pairManifest := Ix.Shard.parseIxesManifest @@ -484,36 +408,18 @@ def semanticSuite : IO UInt32 := do treesFull.contains expectedFrontier.root | _, _ => false - -- A real aggregate-verifier audit fixture: two constants in one shard both - -- depend on a constant in the other. The structural fold must discharge the - -- frontier, and one verified stand-in aggregate proof then certifies exactly - -- the three constants committed by the root statement. let (auditEnv, auditOwned, auditShared) := sharedClosureIxonEnv let auditManifest := Ix.Shard.parseIxesManifest (minimalIxesFor #[auditOwned, #[auditShared]] (#[1, 1, 0] ++ u32le4 0 ++ #[0] ++ u32le4 1)) let auditStatement := auditManifest.bind fun view => Aggr.Reference.expectedFromManifest auditEnv view 0 - let aggregateProofAuditsEveryConstant ← match auditStatement with - | .error _ => pure false + let aggregateProofAuditsEveryConstant : Bool := match auditStatement with + | .error _ => false | .ok statement => - let expectedOuter := Aggr.aggregateOuterClaim - allowed fakeAggrIdx statement.claim - match selfSystem.prove fakeAggrIdx - (Aggr.pubInput allowed (Ix.Claim.ser statement.claim)) default with - | .error _ => pure false - | .ok (outer, proof, _) => - let wrapper : Ixon.Proof := { claim := statement.claim, proof := proof.toBytes } - let bytes := Ixon.Proof.ser wrapper - let address := Address.blake3 bytes - let decoded := match Aggr.decodeAggregateWrapperAt address bytes with - | .ok decoded => decoded.claim == statement.claim && decoded.proof == proof.toBytes - | .error _ => false - let audited := match Aggr.auditAggregateConstants auditEnv statement with - | .ok count => count == 3 - | .error _ => false - pure <| decoded && audited && outer == expectedOuter && - (selfSystem.verify expectedOuter proof).isOk + match Aggr.auditAggregateConstants auditEnv statement with + | .ok count => count == 3 + | .error _ => false let auditLeaves := auditOwned.push auditShared let rejected (result : Except String Nat) : Bool := match result with @@ -546,7 +452,6 @@ def semanticSuite : IO UInt32 := do }) let productionStage2FixturePinnedAndFenced ← stage2FixturePinnedAndFenced - -- Threshold policy and the RAM-gated DAG controller. let mixedSchedule := Aggr.Reference.schedulePlan manifestPlan #[2, 2, 1] 4 let mixedScheduleCorrect : Bool := match mixedSchedule with @@ -570,8 +475,6 @@ def semanticSuite : IO UInt32 := do | .ok _ => false lspecIO (.ofList [("ix-aggr-semantics", [ - test "default recursion parameters preserve direct construction" - defaultRecursionIdentityPreserved, test "recursion FRI cache encoding is the pinned 40-byte layout" defaultFriEncodingStable, test "FRI and commitment overrides independently change recursion identity" @@ -611,10 +514,6 @@ def semanticSuite : IO UInt32 := do test "empty manifest leaves contract and retained ids remap densely" emptyPruningCorrect, test "one retained shard reconstructs one value-based root" singletonValueRoot, - test "native Stage 2 FFI plans a serialized environment end-to-end" - nativePlanOnlyFfiWorks, - test "native verifier orchestration reproduces the Stage 2 root claim" - nativeVerifyRootMatches, test "two-shard manifest passes exact environment coverage" pairCoverage, test "aggregate startup prepares every shard from one ownership pass" batchedShardPreparationCorrect, @@ -644,17 +543,10 @@ def semanticSuite : IO UInt32 := do flatWeightAffine, test "aggregate scheduler parses MemTotal for its default budget" memTotalParsing, - test "invalid non-post-order schedules are rejected" invalidScheduleRejected, - expectOk "stand-in aggregate proof verifies under its uniform outer claim" - (selfSystem.verify leftOuter leftProof), - expectOk "second stand-in aggregate proof verifies independently" - (selfSystem.verify rightOuter rightProof) + test "invalid non-post-order schedules are rejected" invalidScheduleRejected ])]) [] -def convergedSuite : IO UInt32 := do - let shapes ← smokeSuite - let semantics ← semanticSuite - return if shapes == 0 && semantics == 0 then 0 else 1 +def convergedSuite : IO UInt32 := semanticSuite end Tests.Aggr diff --git a/Tests/Aiur.lean b/Tests/Aiur.lean deleted file mode 100644 index 4c3000f87..000000000 --- a/Tests/Aiur.lean +++ /dev/null @@ -1,9 +0,0 @@ -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/Aiur.lean b/Tests/Aiur/Aiur.lean deleted file mode 100644 index 15415bdf6..000000000 --- a/Tests/Aiur/Aiur.lean +++ /dev/null @@ -1,1037 +0,0 @@ -module - -public import Tests.Aiur.Common -public import Ix.Aiur.Meta - -public section - -open LSpec - --- The PROVING corpus: only functions reachable from the proving cases in --- `aiurTestCases` below live here — every function compiles to a circuit --- that every proof commits (empty or not). Execution/interpreter coverage --- for frontend constructs (data-structure layout, templates, aliases, --- single-op wrappers, …) lives in `aiur-cross` (`Tests/Aiur/Cross.lean`). -def toplevel := ⟦ - -- Callee for match_lookup_ops and inline_test - pub fn id(n: G) -> G { - n - } - - --------------------------------------------------------------------------- - -- Match coverage: active/inactive paths, inequality witnesses, nesting - --------------------------------------------------------------------------- - - -- 1 explicit case + default. Default branch has degree-2+ Mul. - -- x=0: explicit active, default's Mul constraints inactive. - -- x≠0: default active, explicit inactive. - pub fn match_mul(x: G) -> G { - match x { - 0 => 0, - _ => x * x * x, - } - } - - -- 3 explicit cases + default. Default path requires 3 inequality witnesses. - pub fn multi_match(x: G) -> G { - match x { - 0 => 100, - 1 => 200, - 2 => 300, - _ => x * x, - } - } - - -- Nested match: outer block selector = sum of inner selectors. Tests - -- inequality witnesses at both nesting levels and computation in the - -- deepest default path. - pub fn nested_match(x: G, y: G) -> G { - match x { - 0 => match y { - 0 => 10, - _ => 20, - }, - _ => match y { - 0 => 30, - _ => x + y, - }, - } - } - - --------------------------------------------------------------------------- - -- Active/inactive sel-gating: polynomial constraints - -- - -- The inactive branch (case 1) has DIFFERENT computations from the active - -- branch (case 0), so the shared auxiliary columns hold "wrong" values for - -- the inactive branch. Additionally, assert_eq!(0, 1) on the inactive path - -- produces constraint sel * (0 - 1) = -sel, which is 0 only when sel = 0. - --------------------------------------------------------------------------- - pub fn match_poly_ops(x: G) -> (G, G) { - match 0 { - 0 => assert_eq!([x], [x]); (x * x, eq_zero(x)), - 1 => assert_eq!([0], [1]); ((x + 1) * (x + 1), eq_zero(x + 1)), - } - } - - --------------------------------------------------------------------------- - -- Active/inactive sel-gating: lookup multiplicities - -- - -- Same operations in both branches. If lookup multiplicity were not gated - -- by sel, both branches would contribute multiplicity, doubling it from 1 - -- to 2 and failing the lookup argument check. - --------------------------------------------------------------------------- - pub fn match_lookup_ops(x: G) -> (G, G) { - match 0 { - 0 => (id(x), load(store(x))), - 1 => (id(x), load(store(x))), - } - } - - --------------------------------------------------------------------------- - -- Active/inactive sel-gating: gadget lookups + U32LessThan constraints - -- - -- Same Bytes1/Bytes2 ops test lookup multiplicity gating. Swapped args for - -- U32LessThan on the inactive path create mismatched byte decompositions - -- and carry chains in the shared auxiliary columns, testing that the - -- polynomial constraints (decomposition + carry boolean) are properly gated. - --------------------------------------------------------------------------- - pub fn match_gadget_ops(i: U8, j: U8) -> (U8, U8, G) { - match 0 { - 0 => (u8_shift_right(i), u8_xor(i, j), u32_less_than(to_field(i), to_field(j))), - 1 => (u8_shift_right(i), u8_xor(i, j), u32_less_than(to_field(j), to_field(i))), - } - } - - --------------------------------------------------------------------------- - -- Active/inactive sel-gating: multi-output gadget lookups - -- - -- u8_add has output_size=2, testing the same missing-sel bug in - -- bytes2_constraints for the multi-output case. u8_bit_decomposition has - -- output_size=8, testing it for bytes1_constraints. - --------------------------------------------------------------------------- - pub fn match_gadget_ops_multi(i: U8, j: U8) -> ((U8, U8), [G; 8]) { - match 0 { - 0 => (u8_add(i, j), u8_bit_decomposition(i)), - 1 => (u8_add(i, j), u8_bit_decomposition(i)), - } - } - - --------------------------------------------------------------------------- - -- EqZero: both constant (degree 0, no constraints) and non-constant - -- (degree 1, two constraints: sel * a * x = 0, sel * (a*d + x - 1) = 0) - --------------------------------------------------------------------------- - pub fn eq_zero_dummy(a: G, b: G) -> [G; 4] { - let c = 0; - let d = 101; - [eq_zero(a), eq_zero(b), eq_zero(c), eq_zero(d)] - } - - --------------------------------------------------------------------------- - -- Enum with 2 constructors, pointer patterns, mutual recursion - --------------------------------------------------------------------------- - enum Nat { - Zero, - Succ(&Nat) - } - - fn even(m: Nat) -> G { - match m { - Nat.Zero => 1, - Nat.Succ(m) => odd(load(m)), - } - } - - fn odd(m: Nat) -> G { - match m { - Nat.Zero => 0, - Nat.Succ(m) => even(load(m)), - } - } - - pub fn is_2_even() -> G { - even(Nat.Succ(store(Nat.Succ(store(Nat.Zero))))) - } - - --------------------------------------------------------------------------- - -- 3-constructor enum: tests tag dispatch with 3 cases, constructor field - -- extraction at different offsets, and padding. Also an implicit - -- active/inactive Mul test: Circle and Rect both have degree-2 Mul but - -- with different operands, sharing the same auxiliary column. - -- - -- Datatype size = max(|Circle|, |Rect|, |Tri|) + 1 = 3 + 1 = 4 - -- Circle(r): [0, r, pad, pad] - -- Rect(w, h): [1, w, h, pad] - -- Tri(a, b, c): [2, a, b, c] - --------------------------------------------------------------------------- - enum Shape { - Circle(G), - Rect(G, G), - Tri(G, G, G) - } - - pub fn shape_area(s: Shape) -> G { - match s { - Shape.Circle(r) => r * r, - Shape.Rect(w, h) => w * h, - Shape.Tri(a, b, c) => a + b + c, - } - } - - --------------------------------------------------------------------------- - -- Constrained and unconstrained recursion - --------------------------------------------------------------------------- - pub fn factorial(n: G) -> G { - match n { - 0 => 1, - _ => n * factorial(n - 1), - } - } - - pub fn fibonacci(n: G) -> G { - match n { - 0 => 1, - _ => - let n_minus_1 = n - 1; - match n_minus_1 { - 0 => 1, - _ => - let n_minus_2 = n_minus_1 - 1; - fibonacci(n_minus_1) + fibonacci(n_minus_2), - }, - } - } - - pub fn unconstrained_fibonacci(n: G) -> G { - match n { - 0 => 1, - _ => - let n_minus_1 = n - 1; - match n_minus_1 { - 0 => 1, - _ => - let n_minus_2 = n_minus_1 - 1; - #fibonacci(n_minus_2) + unconstrained_fibonacci(n_minus_1), - }, - } - } - - -- Regression: a constrained call must recursively promote an identical - -- query previously cached by an unconstrained call. `promotion_nested` - -- calls another function so promoting only its own multiplicity leaves - -- the nested function channel unbalanced. - fn promotion_leaf(x: G) -> G { - x + 1 - } - - fn promotion_nested(x: G) -> G { - promotion_leaf(x) - } - - pub fn unconstrained_call_promotion(x: G) -> G { - let hinted = #promotion_nested(x); - let constrained = promotion_nested(x); - assert_eq!(hinted, constrained); - constrained - } - - --------------------------------------------------------------------------- - -- IO - --------------------------------------------------------------------------- - -- Exercises channel disambiguation: same key #[0] on channels 0 and 1 - -- resolves to distinct (idx, len) and arenas. Reads from each, writes - -- the concatenation back to channel 2, and registers `[1]` on channel 0. - pub fn read_write_io() { - let (idx_a, len_a) = io_get_info(0, [0]); - let (idx_b, _len_b) = io_get_info(1, [0]); - let xs: [G; 4] = io_read(0, idx_a, 4); - let ys: [G; 4] = io_read(1, idx_b, 4); - io_write(2, xs); - io_write(2, ys); - io_set_info(0, [1], idx_a, len_a + 4); - } - - --------------------------------------------------------------------------- - -- Byte operations - --------------------------------------------------------------------------- - pub fn shr_shr_shl_decompose(byte: U8) -> [G; 8] { - let byte_shr = u8_shift_right(byte); - let byte_shr_shr = u8_shift_right(byte_shr); - let byte_shr_shr_shl = u8_shift_left(byte_shr_shr); - u8_bit_decomposition(byte_shr_shr_shl) - } - - pub fn u8_add_xor(i: U8, j: U8) -> ((U8, U8), (U8, U8)) { - let i_xor_j = u8_xor(i, j); - (u8_add(i_xor_j, i), u8_add(i_xor_j, j)) - } - - -- Full u32 xor + right-rotation by 7, built from the fused per-byte - -- xor-split gadget (4 lookups + 4 free field adds). - pub fn u32_xor_rotr7(a: [U8; 4], b: [U8; 4]) -> [U8; 4] { - let (h0, l0) = u8_xor_split7(a[0], b[0]); - let (h1, l1) = u8_xor_split7(a[1], b[1]); - let (h2, l2) = u8_xor_split7(a[2], b[2]); - let (h3, l3) = u8_xor_split7(a[3], b[3]); - [u8_from_field_unsafe(to_field(h0) + to_field(l1)), - u8_from_field_unsafe(to_field(h1) + to_field(l2)), - u8_from_field_unsafe(to_field(h2) + to_field(l3)), - u8_from_field_unsafe(to_field(h3) + to_field(l0))] - } - - --------------------------------------------------------------------------- - -- u32 comparison - --------------------------------------------------------------------------- - pub fn u32_less_than_function(x: G, y: G) -> G { - u32_less_than(x, y) - } - - --------------------------------------------------------------------------- - -- u8 range-check / to_field - --------------------------------------------------------------------------- - pub fn range_check_id(a: G, b: G) -> (G, G) { - let (x, y) = u8_range_check(a, b); - (to_field(x), to_field(y)) - } - - --------------------------------------------------------------------------- - -- EqZero degree-tracking regression: non-constant eq_zero followed by a - -- constant and then a degree-2 multiplication chain. The layout must push - -- exactly 1 degree entry for eq_zero (the boolean result); pushing 2 - -- (one phantom for the internal inverse witness) desynchronises the degree - -- array from bytecode value indices, causing the layout to under-count - -- auxiliary columns and the circuit builder to access out-of-bounds columns. - --------------------------------------------------------------------------- - pub fn eq_zero_degree_desync(x: G) -> G { - let a = eq_zero(x); - let b = 100; - let c = x * x; - let d = c * c; - a + b + d - } - - --------------------------------------------------------------------------- - -- Non-tail match: exercises basic, early return, sequential, and nested - -- cases. All paths tested via a single entry point to minimise proof count. - --------------------------------------------------------------------------- - - fn ntm_basic(a: G) -> G { - let y = match a { 0 => 100, 1 => 200, _ => a * a, }; - y + 1 - } - fn ntm_early_ret(a: G) -> G { - let y = match a { 0 => return 999, _ => a + a, }; - y * y - } - fn ntm_sequential(a: G, b: G) -> G { - let x = match a { 0 => 1, 1 => 2, _ => a, }; - let y = match b { 0 => 10, 1 => 20, _ => b, }; - x + y - } - fn ntm_nested(a: G, b: G) -> G { - let x = match a { - 0 => match b { 0 => return 0, _ => 42, }, - _ => 99, - }; - x + 1 - } - -- Pre-branch constant multiplied in a branch (no default). - -- c has degree 0; exposes sharedAux over-count when all branches are - -- explicit field cases (no inverse-witness auxiliaries to mask the gap). - fn ntm_const_mul(a: G) -> G { - let c = 5; - let x = match a { 0 => c * c, 1 => c * c * c, }; - x + 1 - } - -- Non-tail match returning a tuple (multi-output merge) - fn ntm_tuple(a: G) -> (G, G) { - let (x, y) = match a { 0 => (10, 20), 1 => (30, 40), _ => (a, a * a), }; - (x + 1, y + 1) - } - - -- Non-tail match followed by a tail match (continuation is itself a match) - fn ntm_then_tail_match(a: G, b: G) -> G { - let x = match a { 0 => 100, _ => a, }; - match b { 0 => x, _ => x + b, } - } - - -- Non-tail match with function calls in branches - fn ntm_helper(x: G) -> G { x * x + 1 } - fn ntm_call_in_branch(a: G) -> G { - let x = match a { 0 => ntm_helper(5), _ => ntm_helper(a), }; - x + 1 - } - - -- Non-tail match whose scrutinee is a function call (`let x = match foo(bar) {...}`). - -- The scrutinee is hoisted into a fresh let by the match compiler; the - -- continuation must still reach `matchContinue`. ntm_helper(x) = x*x+1, - -- so a=0 -> 1 -> 100 -> 101. - fn ntm_match_on_call(a: G) -> G { - let x = match ntm_helper(a) { 1 => 100, 5 => 200, _ => a * a, }; - x + 1 - } - - -- Non-tail match with store/load in branches (lookup gating) - fn ntm_store_load(a: G) -> G { - let x = match a { 0 => load(store(42)), _ => load(store(a)), }; - x + 1 - } - - -- Refutable pattern destructuring in a let (like `let Nat.Succ(&x) = n;`) - fn ntm_ctor_let(n: Nat) -> G { - let Nat.Succ(&inner) = n; - match inner { Nat.Zero => 1, Nat.Succ(_) => 2, } - } - - -- Refutable pattern let with a stored enum (Shape through pointer) - fn ntm_shape_let() -> G { - let s = store(Shape.Rect(3, 4)); - let Shape.Rect(w, h) = load(s); - w + h - } - - -- Large match (8 branches, no default) — like const_num_levels - fn ntm_large(a: G) -> G { - let x = match a { - 0 => 10, 1 => 20, 2 => 30, 3 => 40, - 4 => 50, 5 => 60, 6 => 70, 7 => 80, - }; - x + 1 - } - - -- Non-tail match where one branch has a lookup (store) and another doesn't, - -- followed by a continuation that also does a lookup. Tests sharedLookups. - fn ntm_mixed_lookups(a: G) -> G { - let x = match a { - 0 => 42, - _ => load(store(a)), - }; - load(store(x + 1)) - } - - -- Non-tail match where branches call different functions with different - -- lookup counts. Replicates the IxVM get_constant_info_by_variant pattern. - fn ntm_heavy_calls(a: G) -> G { load(store(load(store(a)))) } - fn ntm_light_calls(a: G) -> G { a + 1 } - fn ntm_asymmetric_lookups(a: G, b: G) -> G { - let x = match a { - 0 => ntm_heavy_calls(b), - 1 => ntm_light_calls(b), - _ => b, - }; - load(store(x)) - } - - -- Non-tail match inside a tail match branch (like get_constant_info) - -- Minimal reproducer: non-tail match inside a tail match branch - fn ntm_inside_tail_match(flag: G, a: G) -> G { - match flag { - 0 => - let x = match a { 0 => 100, 1 => 200, }; - x + 1, - _ => a, - } - } - - -- Explicit branches heavier than default: CKind.B and CKind.E have - -- pointer derefs (&Nat) that generate load ops, making those branches - -- use more auxiliaries than CKind.A/C/D/F. When the match compiler - -- places a light branch as the default, the default has fewer auxiliaries - -- than the heavy explicit branches. This catches the bug where - -- Ctrl::Match left state.column at the default's level, missing the - -- explicit branches' higher water mark. - fn ntm_heavy_explicit(flag: G, kind: CKind) -> G { - match flag { - 0 => - let val = match kind { - CKind.A(x) => x, - CKind.B(x, &extra) => - match extra { Nat.Zero => x, Nat.Succ(_) => x + 10, }, - CKind.C(x) => x * x, - CKind.D(x, y) => x + y, - CKind.E(x, &extra) => - match extra { Nat.Zero => x * x, Nat.Succ(_) => x + 100, }, - CKind.F(x) => x, - }; - val + 1, - _ => 0, - } - } - - -- Replicates const_num_levels: 8-branch non-tail match (no default) - -- inside a many-branch outer tail match - fn ntm_large_inside_tail(outer: G, inner: G) -> G { - match outer { - 0 => inner, - 1 => inner + 1, - 2 => - let x = match inner { - 0 => 10, 1 => 20, 2 => 30, 3 => 40, - 4 => 50, 5 => 60, 6 => 70, 7 => 80, - }; - x + 1, - _ => inner * inner, - } - } - - -- Replicates rec_rule_first_ctor: refutable pattern let with pointer deref - -- inside a deeply nested tail match. The `let` destructures a stored - -- enum value through a pointer. - fn ntm_refutable_let_in_match(flag: G) -> G { - let list = store(Nat.Succ(store(Nat.Zero))); - match flag { - 0 => - let Nat.Succ(&inner) = load(list); - match inner { Nat.Zero => 42, _ => 99, }, - _ => 0, - } - } - - -- Replicates convert_all: matchContinue inside List.Cons branch, - -- continuation has store + function call - -- Replicates convert_all: recursive function with matchContinue inside - -- a List.Cons branch, continuation stores + recurses - -- Replicates convert_all: recursive list processing with a non-tail match - -- in the Cons branch where branches call functions with different lookups - -- Replicates convert_all pattern: recursive function with 6-branch - -- non-tail match in the Cons branch. Each branch calls a different - -- function with different lookup counts. Continuation stores + recurses. - fn ntm_cv_a(x: G) -> G { x } - fn ntm_cv_b(x: G) -> G { load(store(x)) } - fn ntm_cv_c(x: G) -> G { store(x); load(store(x + 1)) } - fn ntm_cv_d(x: G) -> G { x * x } - fn ntm_cv_e(x: G) -> G { load(store(load(store(x)))) } - fn ntm_cv_f(x: G, y: G) -> G { x + y } - -- Replicates convert_all exactly: Cons branch with pointer derefs in - -- the pattern, non-tail match with branches that have different arg - -- counts (some with pointer derefs), continuation stores + recurses. - -- 6-variant enum with pointer fields, matching convert_one's ConvertKind - enum CKind { - A(G), - B(G, &Nat), - C(G), - D(G, G), - E(G, &Nat), - F(G) - } - fn ntm_cv_a2(x: G) -> G { x + 1 } - fn ntm_cv_b2(x: G, extra: Nat) -> G { - match extra { Nat.Zero => x, Nat.Succ(_) => x + 10, } - } - fn ntm_cv_c2(x: G) -> G { x * x } - fn ntm_cv_d2(x: G, y: G) -> G { x + y } - fn ntm_cv_e2(x: G, extra: Nat) -> G { - match extra { Nat.Zero => x * x, Nat.Succ(_) => x + 100, } - } - fn ntm_cv_f2(x: G) -> G { load(store(x)) } - fn ntm_convert_all(inputs: Nat, kind: CKind) -> G { - match inputs { - Nat.Zero => 0, - Nat.Succ(&rest) => - let ci = match kind { - CKind.A(x) => ntm_cv_a2(x), - CKind.B(x, &extra) => ntm_cv_b2(x, extra), - CKind.C(x) => ntm_cv_c2(x), - CKind.D(x, y) => ntm_cv_d2(x, y), - CKind.E(x, &extra) => ntm_cv_e2(x, extra), - CKind.F(x) => ntm_cv_f2(x), - }; - store(ci); - ci + ntm_convert_all(rest, kind), - } - } - - fn ntm_recursive_test() -> G { - let zero = Nat.Zero; - let one = Nat.Succ(store(Nat.Zero)); - let two = Nat.Succ(store(Nat.Succ(store(Nat.Zero)))); - -- Exercise ALL 6 branches AND both Nil/Cons paths of the outer match. - -- Multiple iterations to stress shared columns across many trace rows. - let r1 = ntm_convert_all(two, CKind.A(10)); - let r2 = ntm_convert_all(one, CKind.B(5, store(Nat.Succ(store(Nat.Zero))))); - let r3 = ntm_convert_all(two, CKind.C(3)); - let r4 = ntm_convert_all(one, CKind.D(2, 3)); - let r5 = ntm_convert_all(one, CKind.E(7, store(Nat.Zero))); - let r6 = ntm_convert_all(two, CKind.F(4)); - -- Also call with zero iterations (Nil path only) - let r7 = ntm_convert_all(zero, CKind.A(99)); - r1 + r2 + r3 + r4 + r5 + r6 + r7 - } - - fn ntm_tuple_sum(a: G) -> G { - let (x, y) = ntm_tuple(a); - x + y - } - pub fn non_tail_match() -> G { - -- Basic, early return, sequential, nested, const mul - let r1 = ntm_basic(0) + ntm_basic(5); - let r2 = ntm_early_ret(0) + ntm_early_ret(3); - let r3 = ntm_sequential(1, 1); - let r4 = ntm_nested(0, 1) + ntm_nested(1, 0); - let r5 = ntm_const_mul(0); - -- Tuple output, tail-match continuation, calls/store in branches - let r6 = ntm_tuple_sum(0); - let r7 = ntm_then_tail_match(0, 3); - let r8 = ntm_call_in_branch(0); - let r9 = ntm_store_load(0); - -- Large match, constructor patterns, mixed lookups - let r10 = ntm_large(0); - let r11 = ntm_ctor_let(Nat.Succ(store(Nat.Zero))); - let r12 = ntm_mixed_lookups(0); - let r13 = ntm_shape_let(); - let r14 = ntm_asymmetric_lookups(1, 10); - -- matchContinue inside tail match (both branches exercised) - let r15 = ntm_inside_tail_match(0, 0) + ntm_inside_tail_match(0, 1) - + ntm_inside_tail_match(1, 5); - -- Large match inside tail match (all outer+inner branches) - let r16 = ntm_large_inside_tail(2, 0) + ntm_large_inside_tail(2, 3) - + ntm_large_inside_tail(2, 7) + ntm_large_inside_tail(0, 5) - + ntm_large_inside_tail(1, 5) + ntm_large_inside_tail(3, 4); - -- Heavy explicit branches (pointer derefs heavier than default) - let r17 = ntm_heavy_explicit(0, CKind.B(5, store(Nat.Succ(store(Nat.Zero))))) - + ntm_heavy_explicit(0, CKind.A(7)) + ntm_heavy_explicit(1, CKind.A(99)); - -- Refutable pattern let - let r18 = ntm_refutable_let_in_match(0); - -- Recursive with all 6 branches + Nil path exercised - let r19 = ntm_recursive_test(); - -- Nested early return (yields 0, sum unchanged) - let r20 = ntm_nested(0, 0); - -- Function-call scrutinee: 101 + 201 + 10 = 312 - let r21 = ntm_match_on_call(0) + ntm_match_on_call(2) + ntm_match_on_call(3); - r1 + r2 + r3 + r4 + r5 + r6 + r7 + r8 + r9 + r10 - + r11 + r12 + r13 + r14 + r15 + r16 + r17 + r18 + r19 + r20 + r21 - } - - --------------------------------------------------------------------------- - -- Inlined function calls (`@fn(args)`) - -- - -- An `@`-call splices the callee's body into the caller's circuit: no - -- separate circuit, no call interface. These cases cover the splice in - -- every position lowering treats specially (let-RHS, strict argument - -- slots), plus alpha-renaming, nesting, branching callees, gadget - -- lookups joining the caller, and mixing inlined with normal calls. - --------------------------------------------------------------------------- - - fn inl_double(x: G) -> G { - let t = x + x; - t - } - - fn inl_sq(x: G) -> G { x * x } - - -- Callee that itself @-inlines another helper (nested splice) - fn inl_sq_plus(x: G, y: G) -> G { @inl_sq(x) + y } - - -- Multi-output callee - fn inl_pair(x: G) -> (G, G) { (x + 1, x * 2) } - - -- Branching callee: tail match spliced into a let-RHS position - fn inl_sign(x: G) -> G { - match x { - 0 => 0, - _ => 1, - } - } - - -- Gadget lookup inside the callee - fn inl_add8(a: U8, b: U8) -> (U8, U8) { u8_add(a, b) } - - -- Single aggregate entry: every scenario in one circuit/proof. - pub fn inline_test() -> G { - -- Basic splice - let r1 = @inl_double(21); -- 42 - -- Nested splice (callee @-inlines another helper) - let r2 = @inl_sq_plus(3, 4); -- 13 - -- Capture safety: caller binds `t` (the callee's local name) and the - -- argument mentions it - let t = 5; - let r3 = @inl_double(t + 1) + t; -- 17 - -- Strict positions: array elements, operator operands, call argument - let arr = [@inl_double(3), @inl_sq(3)]; -- [6, 9] - let r4 = arr[0] + arr[1] * 100; -- 906 - let r5 = @inl_double(3) + @inl_sq(3); -- 15 - let r6 = id(@inl_double(7)); -- 14 - -- Multi-output callee - let (p1, p2) = @inl_pair(5); -- (6, 10) - let r7 = p1 + p2 * 100; -- 1006 - -- Branching callee in operand position, both paths (the spliced match - -- gets bound to a fresh local before hoisting) - let r8 = @inl_sign(0) + @inl_sign(5) * 100; -- 100 - -- Same callee inlined and normally called: the normal call keeps its - -- own circuit + lookup, the inlined one joins this circuit - let r9 = @inl_sq(3) + inl_sq(4); -- 25 - -- Gadget lookup in the callee joins this circuit - let (s, c) = @inl_add8(200u8, 100u8); -- (44, 1) - let r10 = to_field(s) + to_field(c) * 1000; -- 1044 - r1 + r2 + r3 + r4 + r5 + r6 + r7 + r8 + r9 + r10 - } - - -- An assertion runs before the statements after it, even when those - -- begin with an inlined call whose splice hoists `let`s: the spliced - -- lets stay in the continuation instead of wrapping the assertion. - pub fn assert_before_inline(x: G) -> G { - assert_eq!(x, 1, "assertion first"); - let (p1, p2) = @inl_pair(x); -- (2, 2) - p1 + p2 - } - - --------------------------------------------------------------------------- - -- Unconstrained big-uint div/mod: lists of [U8; 8] limbs in, the same - -- list datatype at [G; 8] out. The datatype must declare Cons FIRST - -- (runtime tag contract: 0 = Cons, 1 = Nil). Limbs are little-endian - -- u64s, head-first. - --------------------------------------------------------------------------- - enum BNode‹T› { - BCons(T, &BNode‹T›), - BNil - } - - fn blist0() -> &BNode‹[U8; 8]› { store(BNode.BNil) } - fn blist1(l: [U8; 8]) -> &BNode‹[U8; 8]› { store(BNode.BCons(l, blist0())) } - fn blist2(l0: [U8; 8], l1: [U8; 8]) -> &BNode‹[U8; 8]› { - store(BNode.BCons(l0, blist1(l1))) - } - - -- u64 value of the first result limb (fits in G for the cases below). - fn glimb_val(p: &BNode‹[G; 8]›) -> G { - match load(p) { - BNode.BCons(l, _) => l[0] + 256 * l[1] + 65536 * l[2] + 16777216 * l[3] - + 4294967296 * l[4] + 1099511627776 * l[5] + 281474976710656 * l[6] - + 72057594037927936 * l[7], - BNode.BNil => 0, - } - } - - fn glist_is_nil(p: &BNode‹[G; 8]›) -> G { - match load(p) { - BNode.BNil => 1, - BNode.BCons(_, _) => 0, - } - } - - -- Aggregate: plain divide (300/7), unit divisor (300/1), zero divisor - -- (300/0 → (Nil, 300) by convention), and a two-limb dividend with a - -- Nil remainder (2^64 / 2 → (2^63, Nil), canonical single-limb q). - pub fn divmod_test() -> G { - let a300 = blist1([44u8, 1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); - let b7 = blist1([7u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); - let (q1, r1) = unconstrained_big_uint_div_mod(a300, b7); - let s1 = glimb_val(q1) + 1000 * glimb_val(r1); -- 42 + 6000 - let b1 = blist1([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); - let (q2, _r2) = unconstrained_big_uint_div_mod(a300, b1); - let s2 = glimb_val(q2); -- 300 - let (q3, r3) = unconstrained_big_uint_div_mod(a300, blist0()); - let s3 = 1000000 * glist_is_nil(q3) + glimb_val(r3); -- 1000300 - let a64 = blist2([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], - [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); - let b2 = blist1([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); - let (q4, r4) = unconstrained_big_uint_div_mod(a64, b2); - let s4 = glimb_val(q4) + glist_is_nil(r4); -- 2^63 + 1 - s1 + s2 + s3 + s4 - } - - --------------------------------------------------------------------------- - -- Hoisting regressions share one proof: caller shadowing, strict operand - -- order, statement continuations, and an assertion before an inline match. - fn hoist_emit(x: G) -> G { io_write(0, [x]); x } - fn hoist_twice(x: G) -> G { let tmp = x + x; tmp } - fn hoist_guarded(x: G) -> G { - assert_eq!(x, 0); - let y = match x { 0 => 7, _ => 9, }; - y - } - pub fn hoisting_regression(x: G) -> [G; 8] { - let rhs = (let x = 2; x); - let operand = x + (let x = 2; x); - let inlined = x + @hoist_twice((let x = 2; x)); - assert_eq!(x, 9); - let x = 0; - io_write(0, [7]); - let ys = io_read(0, 0, 1); - io_set_info(0, [7], 3, 4); - let (i, n) = io_get_info(0, [7]); - let sum = hoist_emit(1) + @hoist_twice(hoist_emit(2)); - let guarded = @hoist_guarded(x) + 1; - [rhs, operand, inlined, ys[0], i, n, sum, guarded] - } - - -- Unconstrained field hints: `g_to_bytes` returns the 8 LE bytes of the - -- CANONICAL u64 value as raw [G; 8] advice; `g_inverse` the field - -- inverse with 0 ↦ 0. - --------------------------------------------------------------------------- - pub fn hint_test() -> G { - -- 300 = 0x012C → LE bytes [44, 1, 0, ...] - let b = unconstrained_g_to_bytes(300); - let s1 = b[0] + 1000 * b[1]; -- 1044 - let s2 = b[7]; -- 0 - -- x * x⁻¹ = 1 for x ≠ 0; 0 ↦ 0 - let s3 = unconstrained_g_inverse(7) * 7; -- 1 - let s4 = unconstrained_g_inverse(0); -- 0 - -- Canonicality: 0 - 1 wraps to p - 1 = 0xFFFFFFFF00000000 - let c = unconstrained_g_to_bytes(0 - 1); - let s5 = c[4] + c[0]; -- 255 - s1 + s2 + 10 * s3 + s4 + s5 -- 1309 - } - - --------------------------------------------------------------------------- - -- Grouped circuits (`CompiledToplevel.groupFunctions`): the test runner - -- groups these three into one circuit whose branching selects the member. - -- Grouping is a circuit-level choice, so there is NO source annotation: - -- the same functions also run ungrouped in the plain suite. Members - -- differ in arity, output and branch count, call each other (through the - -- shared circuit) and recurse. - --------------------------------------------------------------------------- - fn grouped_double(x: G) -> G { - x + x - } - - -- Different arity, a match (two selectors), calls a fellow group member. - fn grouped_pick(t: G, a: G, b: G) -> G { - match t { - 0 => grouped_double(a), - _ => b, - } - } - - -- Recursive group member: self-calls route through the shared circuit. - fn grouped_sum_range(n: G) -> G { - match n { - 0 => 0, - _ => n + grouped_sum_range(n - 1), - } - } - - pub fn calls_grouped(t: G, a: G, b: G) -> G { - grouped_pick(t, a, b) + grouped_sum_range(a) - } - - pub fn match_scrut_call(x: G) -> G { - match id(x) { - 0 => 7, - n => n + n, - } - } - - -- Reused products and stores change polynomial columns and lookup counts. - -- Exercise both branches and a continuation with independent local values. - pub fn cse_constraints(tag: G, x: G) -> (G, G, G, G) { - let p = store(x); - let q = store(x); - assert_eq!(ptr_val(p), ptr_val(q)); - let a = load(p); - let b = load(q); - let y = match tag { - 0 => (x * x) + (x * x), - _ => (x + 1) * (x + 1), - }; - (y, a + b, (x * x) + (x * x), eq_zero(x) + eq_zero(x)) - } -⟧ - -/-- The PROVING suite: every case runs the full prove+verify pipeline - (plus execute and interpret, which come for free in `runTestCase`). - A case belongs here only when it pins a distinct constraint, - selector-gating, or lookup-argument configuration — the things - execution never evaluates. Execution-semantics coverage (compiler, - evaluators, interpreter) lives in `aiur-cross` - (`Tests/Aiur/Cross.lean`). When several inputs of the same function - differ only in which path is active, only a minimal covering set of - proofs is kept — the other paths run in `aiur-cross`. -/ -def aiurTestCases : List AiurTestCase := [ - .prove `cse_constraints #[0, 7] #[98, 14, 98, 0] (label := "CSE explicit branch"), - .prove `cse_constraints #[1, 7] #[64, 14, 98, 0] (label := "CSE default branch"), - .prove `cse_constraints #[0, 0] #[0, 0, 0, 2] (label := "CSE zero input"), - .prove `match_scrut_call #[0] #[7] (label := "match scrutinee explicit"), - .prove `match_scrut_call #[3] #[6] (label := "match scrutinee variable fallback"), - -- Match: 1 explicit case + default, prove both paths (each side gates - -- the other's constraints) - .prove `match_mul #[0] #[0] (label := "match_mul(0)"), - .prove `match_mul #[2] #[8] (label := "match_mul(2)"), - - -- Match: 3 explicit cases + default. Prove one explicit path and the - -- default path (3 inequality witnesses); the remaining explicit paths - -- exercise the same witness layout - .prove `multi_match #[0] #[100] (label := "multi_match(0)"), - .prove `multi_match #[5] #[25] (label := "multi_match(5)"), - - -- Nested match: 4 leaf selectors. Prove one explicit-explicit and one - -- default-default leaf (witnesses at both nesting levels); the two - -- mixed leaves repeat those layouts - .prove `nested_match #[0, 0] #[10] (label := "nested_match(0,0)"), - .prove `nested_match #[2, 3] #[5] (label := "nested_match(2,3)"), - - -- Sel-gating: polynomial constraints (Mul, EqZero, AssertEq). - -- Inactive branch has assert_eq!(0,1) (fails without sel=0), - -- different Mul (aux mismatch), different EqZero (witness mismatch). - -- x=0 chosen so inactive EqZero constraint `sel*(x+1)*x_result = - -- sel*1*1 = sel` is nonzero without gating. - .prove `match_poly_ops #[0] #[0, 1], - - -- Sel-gating: function and memory lookup multiplicity - .prove `match_lookup_ops #[42] #[42, 42], - - -- Sel-gating: gadget lookups (Bytes1, Bytes2) and U32LessThan polynomial - -- constraints (swapped args on inactive path create decomposition mismatch) - .prove `match_gadget_ops #[45, 131] #[22, 174, 1], - - -- Sel-gating: multi-output gadget lookups (Bytes2 output_size=2, - -- Bytes1 output_size=8). Guards against partial fixes that only - -- address output_size=1. - .prove `match_gadget_ops_multi #[45, 131] #[176, 0, 1, 0, 1, 1, 0, 1, 0, 0], - - -- EqZero: constant path (c=0, d=101) and non-constant path (a=0, b=37) - .prove `eq_zero_dummy #[0, 37] #[1, 0, 1, 0], - - -- Mutual recursion: prove only the deepest case (cross-circuit - -- lookups through both functions); shallower depths are sub-traces - .prove `is_2_even #[] #[1], - - -- 3-constructor enum: tag dispatch, field extraction at varying offsets, - -- padding. Circle and Rect have degree-2 Mul in different branches with - -- different operands sharing aux columns (implicit sel-gating test). - -- Circle and Rect are the degree-2 pair sharing aux columns (the - -- implicit sel-gating test): prove both. Tri (addition only) runs in - -- aiur-cross. - -- Circle(5): [tag=0, r=5, pad, pad] → 5*5 = 25 - .prove `shape_area #[0, 5, 0, 0] #[25] (label := "shape_area(Circle(5))"), - -- Rect(3,4): [tag=1, w=3, h=4, pad] → 3*4 = 12 - .prove `shape_area #[1, 3, 4, 0] #[12] (label := "shape_area(Rect(3,4))"), - - -- Constrained recursion - .prove `factorial #[5] #[120] (label := "factorial(5)"), - - -- Fibonacci: prove the deep case (call-lookup multiplicities > 1) - .prove `fibonacci #[6] #[13] (label := "fibonacci(6)"), - - -- Unconstrained recursion: mixed constrained/unconstrained calls - .prove `unconstrained_fibonacci #[6] #[13], - - -- A constrained call reuses an identical unconstrained cached query and - -- must recursively promote the nested callee's lookup multiplicity. - .prove `unconstrained_call_promotion #[3] #[4], - - -- IO - { functionName := `read_write_io - inputIOBuffer := - ⟨.ofList [(0, #[1, 2, 3, 4]), (1, #[5, 6, 7, 8])], - .ofList [((0, #[0]), ⟨0, 4⟩), ((1, #[0]), ⟨0, 4⟩)]⟩ - expectedIOBuffer := - ⟨.ofList [(0, #[1, 2, 3, 4]), - (1, #[5, 6, 7, 8]), - (2, #[1, 2, 3, 4, 5, 6, 7, 8])], - .ofList [((0, #[0]), ⟨0, 4⟩), ((1, #[0]), ⟨0, 4⟩), - ((0, #[1]), ⟨0, 8⟩)]⟩ }, - - -- Byte operations: the gadget LOOKUP ARGUMENT (Bytes1/Bytes2 - -- multiplicities) is what proving checks; op results are table - -- content, verified by execution. Prove one Bytes1 chain, one - -- multi-output Bytes2 case, and the chain-gadget combination; the - -- single-op wrappers repeat the same lookup mechanics in aiur-cross. - .prove `shr_shr_shl_decompose #[87] #[0, 1, 0, 1, 0, 1, 0, 0], - .prove `u8_add_xor #[45, 131] #[219, 0, 49, 1], - .prove `u32_xor_rotr7 #[45, 131, 200, 17, 0, 0, 0, 0] #[6, 145, 35, 90] - (label := "u32_xor_rotr7(x, 0) = rotr7(x)"), - .prove `u32_xor_rotr7 #[45, 131, 200, 17, 200, 17, 45, 131] #[37, 203, 37, 203] - (label := "u32_xor_rotr7(a, b)"), - - -- u8 range-check: prove the boundary case (U8RangeCheck circuit op) - .prove `range_check_id #[0, 255] #[0, 255], - - -- u32 comparison: prove strict-less and the equality edge (distinct - -- carry-chain witnesses); a > b repeats the a = b carry layout - .prove `u32_less_than_function #[300, 500] #[1] - (label := "u32_less_than(300,500)"), - .prove `u32_less_than_function #[500, 500] #[0] - (label := "u32_less_than(500,500)"), - - -- EqZero degree-tracking regression (eq_zero(3)=0, 100, 3*3=9, 9*9=81, 0+100+81=181) - .prove `eq_zero_degree_desync #[3] #[181], - - -- Non-tail match: all patterns in one proof (incl. function-call scrutinee) - .prove `non_tail_match #[] #[2593], - - -- Inlined function calls (`@fn(args)`): all scenarios in one proof - .prove `inline_test #[] #[3182], - .prove `assert_before_inline #[1] #[4], - - { AiurTestCase.prove `hoisting_regression #[9] #[2, 11, 13, 7, 3, 4, 5, 8] with - expectedIOBuffer := { - data := .ofList [(0, #[7, 1, 2])], - map := .ofList [((0, #[7]), ⟨3, 4⟩)] } }, - - -- Unconstrained big-uint div/mod: all cases in one proof - -- (6042 + 300 + 1000300 + 2^63 + 1) - .prove `divmod_test #[] #[9223372036855782451], - - -- Unconstrained g_to_bytes / g_inverse hints: all cases in one proof - .prove `hint_test #[] #[1309], - - -- Grouped-circuit member functions, run UNGROUPED here (the grouped - -- variant runs in the grouped env; see `testGroups`). - -- t=0 → grouped_double(5) + Σ1..5 = 10 + 15 = 25; t≠0 → 9 + Σ1..3 = 15. - .prove `calls_grouped #[0, 5, 9] #[25] - (label := "calls_grouped(0,5,9)"), - .prove `calls_grouped #[1, 3, 9] #[15] - (label := "calls_grouped(1,3,9)"), - ] - -/-- The grouping the `aiur` runner applies for the grouped environment. -/ -def testGroups : Array (String × Array String) := - #[("test_group", #["grouped_double", "grouped_pick", "grouped_sum_range"])] - -def groupedTestCases : List AiurTestCase := [ - .prove `calls_grouped #[0, 5, 9] #[25] - (label := "calls_grouped(0,5,9) [grouped]"), - .prove `calls_grouped #[1, 3, 9] #[15] - (label := "calls_grouped(1,3,9) [grouped]"), -] - -/-- The compiled `assert_before_inline` keeps its assertion ahead of the -inlined continuation: the `assertEq` op precedes every `call` op. -/ -def assertOrderChecks (compiled : Aiur.CompiledToplevel) : TestSeq := - match compiled.getFuncIdx `assert_before_inline with - | none => test "assert_before_inline compiles" false - | some idx => - let ops := compiled.bytecode.functions[idx]!.body.ops - let isAssert : Aiur.Bytecode.Op → Bool - | .assertEq .. => true - | _ => false - let isCall : Aiur.Bytecode.Op → Bool - | .call .. => true - | _ => false - let firstAssert := ops.findIdx? isAssert - let firstCall := ops.findIdx? isCall - let ordered : Bool := match firstAssert, firstCall with - | some a, some c => a < c - | some _, none => true - | _, _ => false - test "assertion precedes the inlined continuation's calls" ordered - -/-- Structural checks on the grouped partition: the grouped circuit exists, -holds exactly its members, its layout follows the merge rule (max inputs, -summed selectors, max auxiliaries, max lookups), and every constrained -function lands in exactly one circuit. -/ -def groupingStructureChecks (compiled : Aiur.CompiledToplevel) : TestSeq := - let t := compiled.bytecode - let memberOf := fun (name : Lean.Name) => compiled.getFuncIdx name |>.get! - let expectedMembers := - #[`grouped_double, `grouped_pick, `grouped_sum_range].map memberOf - match t.circuits.find? (·.name == "test_group") with - | none => test "test_group circuit exists" false - | some c => - let layouts := c.members.map (t.functions[·]!.layout) - let expected := layouts.foldl (init := (⟨0, 0, 0, 0⟩ : Aiur.Bytecode.FunctionLayout)) - Aiur.Bytecode.FunctionLayout.merge - let allCircuitMembers := t.circuits.flatMap (·.members) - let constrained := (Array.range t.functions.size).filter - (t.functions[·]!.constrained) - test "test_group circuit exists" true ++ - test "test_group members" (c.members == expectedMembers) ++ - test "test_group layout follows the merge rule" - (c.layout.inputSize == expected.inputSize && - c.layout.selectors == expected.selectors && - c.layout.auxiliaries == expected.auxiliaries && - c.layout.lookups == expected.lookups) ++ - test "every constrained function is in exactly one circuit" - (allCircuitMembers.qsort (· < ·) == constrained) - -end diff --git a/Tests/Aiur/Common.lean b/Tests/Aiur/Common.lean deleted file mode 100644 index afd13803d..000000000 --- a/Tests/Aiur/Common.lean +++ /dev/null @@ -1,152 +0,0 @@ -module - -public import LSpec -public import Ix.Unsigned -public import Ix.Aiur.Goldilocks -public import Ix.Aiur.Protocol -public import Ix.Aiur.Compiler -public import Ix.Aiur.Interpret -public import Ix.Aiur.Statistics - -public section - -open LSpec - -/-- Every case executes; `interpret` and `withProof` independently add the - interpreter agreement check and the prove/verify pipeline. All three - used combinations have a constructor: `prove` (execute + interpret + - prove), `interp` (execute + interpret), `exec` (execute only). -/ -structure AiurTestCase where - functionName : Lean.Name - label : String := toString functionName - input : Array Aiur.G := #[] - expectedOutput : Array Aiur.G := #[] - inputIOBuffer : Aiur.IOBuffer := default - expectedIOBuffer : Aiur.IOBuffer := default - interpret : Bool := true - withProof : Bool := true - /-- When set, asserts the total FFT cost equals this value (rounded to - `UInt64`). Pins per-circuit cost regressions: any kernel change that - shifts FFT cost forces a manual update to the expected value. -/ - expectedFftCost : Option Nat := none - -/-- Full pipeline: execute + interpret + prove/verify. -/ -def AiurTestCase.prove (functionName : Lean.Name) - (input expectedOutput : Array Aiur.G) - (label : String := toString functionName) : AiurTestCase := - { functionName, label, input, expectedOutput } - -/-- Execute + interpret, no proof. -/ -def AiurTestCase.interp (functionName : Lean.Name) - (input expectedOutput : Array Aiur.G) - (label : String := toString functionName) : AiurTestCase := - { functionName, label, input, expectedOutput, withProof := false } - -/-- Execute only. -/ -def AiurTestCase.exec (functionName : Lean.Name) - (input : Array Aiur.G := #[]) (expectedOutput : Array Aiur.G := #[]) - (label : String := toString functionName) : AiurTestCase := - { functionName, label, input, expectedOutput, - interpret := false, withProof := false } - -def commitmentParameters : Aiur.CommitmentParameters := { - logBlowup := 2 - capHeight := 0 -} - -/-- Test-only FRI parameters: soundness margin is irrelevant here, so no - proof-of-work grinding (it adds a fixed 2^bits hashing cost to every - proof and tests nothing) and the same query count the Rust-side unit - tests use (`crates/aiur/src/synthesis.rs`). -/ -def friParameters : Aiur.FriParameters := { - logFinalPolyLen := 0 - maxLogArity := 1 - numQueries := 64 - commitProofOfWorkBits := 0 - queryProofOfWorkBits := 0 -} - -structure AiurTestEnv where - compiled : Aiur.CompiledToplevel - decls : Aiur.Source.Decls - aiurSystem : Aiur.AiurSystem - shapes : Array Aiur.CircuitShape - -def AiurTestEnv.build (toplevelFn : Except Aiur.Global Aiur.Source.Toplevel) - (groups : Array (String × Array String) := #[]) : - Except String AiurTestEnv := do - let toplevel ← toplevelFn.mapError toString - let compiled ← toplevel.compile - let compiled ← if groups.isEmpty then pure compiled - else compiled.groupFunctions groups - let decls ← toplevel.mkDecls.mapError toString - let aiurSystem := Aiur.AiurSystem.build compiled.bytecode commitmentParameters friParameters - return ⟨compiled, decls, aiurSystem, aiurSystem.circuitShapes⟩ - -def AiurTestEnv.interpTest (env : AiurTestEnv) (testCase : AiurTestCase) - (execOutput : Array Aiur.G) (execIOBuffer : Aiur.IOBuffer) : TestSeq := - let label := testCase.label - let funcName := Aiur.Global.mk testCase.functionName - let inputTypes := match env.decls.getByKey funcName with - | some (.function f) => f.inputs.map (·.2) - | _ => [] - let inputs := Aiur.unflattenInputs env.decls testCase.input inputTypes - let funcIdx g := env.compiled.getFuncIdx g.toName - match Aiur.runFunction env.decls funcName inputs testCase.inputIOBuffer with - | (.error e, _) => - test s!"Interpret succeeds for {label}: {e}" false - | (.ok output, state) => - let flat := Aiur.flattenValue env.decls funcIdx output - let interpOutputTest := test s!"Interpret output matches for {label}" - (flat == execOutput) - let interpIOTest := test s!"Interpret IOBuffer matches for {label}" - (state.ioBuffer == execIOBuffer) - interpOutputTest ++ interpIOTest - -def AiurTestEnv.runTestCase (env : AiurTestEnv) (testCase : AiurTestCase) : TestSeq := - let label := testCase.label - let funIdx := env.compiled.getFuncIdx testCase.functionName |>.get! - match env.compiled.bytecode.execute funIdx testCase.input testCase.inputIOBuffer with - | .error e => test s!"Execute succeeds for {label}: {e}" false - | .ok (execOutput, execIOBuffer, queryCounts) => - let execOutputTest := test s!"Execute output matches for {label}" - (execOutput == testCase.expectedOutput) - let execIOTest := test s!"Execute IOBuffer matches for {label}" - (execIOBuffer == testCase.expectedIOBuffer) - let fftTest := match testCase.expectedFftCost with - | none => .done - | some expected => - let stats := Aiur.computeStats env.compiled queryCounts env.shapes - let actual := stats.totalFftCost.round.toUInt64.toNat - test s!"FFT cost matches for {label}: expected {expected}, got {actual}" - (actual == expected) - let execTest := execOutputTest ++ execIOTest ++ fftTest - let interpTest := - if testCase.interpret then env.interpTest testCase execOutput execIOBuffer - else .done - if !testCase.withProof then execTest ++ interpTest - else - match env.aiurSystem.prove funIdx testCase.input testCase.inputIOBuffer with - | .error _ => - execTest ++ interpTest ++ test s!"Prove succeeds for {label}" false - | .ok (claim, proof, ioBuffer) => - let claimTest := test s!"Claim matches for {label}" - (claim == Aiur.buildClaim funIdx testCase.input testCase.expectedOutput) - let ioTest := test s!"IOBuffer matches for {label}" - (ioBuffer == testCase.expectedIOBuffer) - let proof := .ofBytes proof.toBytes - let pvTest := withExceptOk s!"Prove/verify works for {label}" - (env.aiurSystem.verify claim proof) fun _ => .done - execTest ++ interpTest ++ claimTest ++ ioTest ++ pvTest - -def mkAiurTests (toplevelFn : Except Aiur.Global Aiur.Source.Toplevel) - (cases : List AiurTestCase) : TestSeq := - withExceptOk "Toplevel merging succeeds" toplevelFn fun toplevel => - withExceptOk "Compilation succeeds" toplevel.compile fun compiled => - withExceptOk "mkDecls succeeds" (toplevel.mkDecls.mapError toString) fun decls => - let aiurSystem := Aiur.AiurSystem.build compiled.bytecode commitmentParameters friParameters - let env : AiurTestEnv := ⟨compiled, decls, aiurSystem, aiurSystem.circuitShapes⟩ - cases.foldl (init := .done) fun tSeq testCase => - tSeq ++ env.runTestCase testCase - -end diff --git a/Tests/Aiur/Cost.lean b/Tests/Aiur/Cost.lean deleted file mode 100644 index 7378705e4..000000000 --- a/Tests/Aiur/Cost.lean +++ /dev/null @@ -1,79 +0,0 @@ -module - -public import LSpec -public import Ix.Aiur - -/-! -Unit tests for the pure FFT cost model in `Ix/Aiur/Statistics.lean`. - -Everything here is `Float` arithmetic over integer inputs — fully -deterministic, no execution, no FFI. Exact equalities stick to inputs -whose logs are integral (powers of two); everything else is checked via -strict monotonicity, including across power-of-two boundaries where the -real (padded) prover would plateau. --/ - -public section - -open LSpec Aiur - -namespace AiurTests.Cost - -/-- A small function-like circuit: main width 4, one lookup -(stage 2 width `D = 2`), quotient degree 2 (today's uniform value). -/ -def fnShape : CircuitShape := - { mainWidth := 4, stage2Width := 2, quotientDegree := 2, - preprocessedWidth := 0, preprocessedHeight := 0 } - -/-- `logBlowup = 2` (production `B = 4`): trace width `4 + 2 = 6`, -quotient chunks `q·D = 4`; at `h = 8`: -`(B+1)·6·F(8) + D·F(16) + q·D·F(32) = 30·24 + 2·64 + 4·160 = 1488`. -/ -def handComputed : Float := 1488.0 - -def transformCostTests : TestSeq := - test "F(0) = 0 (empty circuit is deactivated)" (transformCost 0 == 0.0) ++ - test "F(1) = 1 (clamp keeps height-1 transforms nonzero)" - (transformCost 1 == 1.0) ++ - test "F(2) = 2" (transformCost 2 == 2.0) ++ - test "F(4) = 8" (transformCost 4 == 8.0) ++ - test "F(1024) = 10240" (transformCost 1024 == 10240.0) ++ - test "F strictly increases across a power-of-two boundary" - (transformCost 1023 < transformCost 1024 && - transformCost 1024 < transformCost 1025) - -def fftCostTests : TestSeq := - test "cost is zero at h = 0" (fftCost fnShape 0 2 == 0.0) ++ - test "hand-computed value at h = 8, logBlowup = 2" - (fftCost fnShape 8 2 == handComputed) ++ - test "one-row sensitivity at small heights" - (fftCost fnShape 1 2 < fftCost fnShape 2 2 && - fftCost fnShape 2 2 < fftCost fnShape 3 2) ++ - test "one-row sensitivity across a power-of-two boundary" - (fftCost fnShape 1023 2 < fftCost fnShape 1024 2 && - fftCost fnShape 1024 2 < fftCost fnShape 1025 2) ++ - test "wider main trace costs more" - (fftCost fnShape 8 2 < - fftCost { fnShape with mainWidth := fnShape.mainWidth + 1 } 8 2) ++ - test "extra lookup (wider stage 2) costs more" - (fftCost fnShape 8 2 < - fftCost { fnShape with stage2Width := fnShape.stage2Width + 2 } 8 2) ++ - test "higher quotient degree costs more" - (fftCost fnShape 8 2 < - fftCost { fnShape with quotientDegree := 4 } 8 2) ++ - test "larger blowup costs more" - (fftCost fnShape 8 1 < fftCost fnShape 8 2) ++ - test "committedWidth = main + stage2 + q·D" - (fnShape.committedWidth == 4 + 2 + 2 * G.extensionDegree) - -def formatSciTests : TestSeq := - test "formatSci 0 = 0" (formatSci 0.0 == "0") ++ - test "formatSci 1 = 1.00e0" (formatSci 1.0 == "1.00e0") ++ - test "formatSci 1424 = 1.42e3" (formatSci 1424.0 == "1.42e3") ++ - test "formatSci 174253453 = 1.74e8" (formatSci 174253453.0 == "1.74e8") ++ - test "mantissa carry: formatSci 999.9 = 1.00e3" (formatSci 999.9 == "1.00e3") - -def tests : TestSeq := transformCostTests ++ fftCostTests ++ formatSciTests - -end AiurTests.Cost - -end diff --git a/Tests/Aiur/Cross.lean b/Tests/Aiur/Cross.lean deleted file mode 100644 index e74598b98..000000000 --- a/Tests/Aiur/Cross.lean +++ /dev/null @@ -1,1881 +0,0 @@ -module - -public import LSpec -public import Ix.Aiur -public import Ix.Aiur.Meta - -/-! -End-to-end pipeline cross-tests for `Ix/Aiur`: the compiler and -interpreter suite. - -A single `toplevel` collects every Aiur surface-language program needed -by the test corpus (datatypes, type aliases, mutually-recursive -functions, etc.). The `runAgreement` helper evaluates one entry point -through every execution-level engine — the source-level reference -evaluator (`Source.Eval`), the source interpreter (`Aiur.Interpret`), -the lowered bytecode evaluator (`Bytecode.Eval`) and the native -bytecode executor — asserting that the flat-encoded return value and -the `IOBuffer` agree across all of them. - -Proving lives elsewhere: the `aiur-prove` suite (`Tests/Aiur/Aiur.lean`) -proves the constraint/lookup configurations, and this suite carries the -execution-semantics coverage. --/ - -public section - -open LSpec Aiur - -namespace AiurTests.Cross - -/-- Single shared toplevel for every cross-test. Functions are entry -points iff prefixed `pub fn`. -/ -def toplevel : Source.Toplevel := ⟦ - -- Type aliases - type MyField = G - type Pair‹T› = (T, T) - - -- Datatypes - enum MyOpt { Some(G), None } - enum MyOpt2 { Some2(MyOpt), None2 } - enum Wrap { W(MyOpt2) } - enum APair { Mk(G, G) } - enum MyList { Nil, Cons(G, &MyList) } - - -- Arithmetic + control flow - pub fn add_one(x: G) -> G { x + 1 } - - pub fn arith(a: G, b: G) -> G { - let s = a + b; - let p = s * 2; - p - 1 - } - - pub fn fst(p: (G, G)) -> G { proj(p, 0) } - pub fn second(a: [G; 3]) -> G { a[1] } - - pub fn roundtrip(x: G) -> G { - let p = store(x); - load(p) - } - - -- Basic-block CSE must reuse values, not effects, and must not leak value - -- indices across sibling branches or from an arm into a continuation. - pub fn cse_arithmetic(x: G) -> (G, G, G, G) { - (x * x, x * x, eq_zero(x), eq_zero(x)) - } - fn cse_load(p: &G) -> (G, G) { (load(p), load(p)) } - pub fn cse_memory(x: G) -> (G, G, (G, G)) { - let p = store(x); - let q = store(x); - assert_eq!(ptr_val(p), ptr_val(q)); - (load(p), load(q), cse_load(p)) - } - pub fn cse_memory_widths(x: G) -> (G, (G, G)) { - let p = store(x); - let q = store((x, x)); - (load(p), load(q)) - } - enum CseUnit { Mk } - pub fn cse_empty_memory() -> G { - let p = store(CseUnit.Mk); - let q = store(CseUnit.Mk); - let a = load(p); - let b = load(q); - ptr_val(p) + ptr_val(q) - } - pub fn cse_join(tag: G, x: G) -> (G, G, G) { - let y = match tag { - 0 => (x * x) + (x * x), - 1 => (x + 1) * (x + 1), - _ => (x + 2) * (x + 2), - }; - (y, x * x, x * x) - } - pub fn cse_nested(tag: G, x: G) -> (G, G) { - match tag { - 0 => let y = x * x; (y, x * x), - _ => let y = (x + 1) * (x + 1); (y, x * x), - } - } - pub fn cse_calls(x: G) -> (G, G) { (helper(x), helper(x)) } - pub fn cse_assertions(x: G, y: G) -> G { - let a = x * x; - assert_eq!(x, y); - let b = x * x; - assert_eq!(x, y); - a + b - } - pub fn cse_io(x: G) -> ((G, G), (G, G)) { - io_write(0, [x]); - io_write(0, [x]); - io_set_info(0, [x], 0, 1); - let a = io_get_info(0, [x]); - let b = io_get_info(0, [x]); - (a, b) - } - pub fn cse_duplicate_io_key(x: G) -> G { - io_write(0, [x]); - io_set_info(0, [x], 0, 1); - io_set_info(0, [x], 0, 1); - x - } - pub fn cse_hints(x: G) -> (G, G) { - (unconstrained_g_inverse(x), unconstrained_g_inverse(x)) - } - - fn scrut_value(x: G) -> G { x * x + 1 } - pub fn match_scrut_call(x: G) -> G { - match scrut_value(x) { - 1 => 3, - n => n + n, - } - } - fn scrut_assert(x: G) -> G { assert_eq!(x, 0); x } - pub fn match_scrut_wildcard(x: G) -> G { - match scrut_assert(x) { _ => 7, } - } - pub fn match_scrut_nested(x: G) -> G { - match scrut_value(x) { - 1 => 3, - n => match scrut_value(n) { 5 => n, m => n + m, }, - } - } - fn scrut_emit(x: G) -> G { io_write(0, [x]); x } - pub fn match_scrut_effect(x: G) -> G { - match scrut_emit(x) { 0 => 1, n => n + n, } - } - pub fn match_scrut_unused(x: G) -> G { - match scrut_emit(x) { _ => 7, } - } - - -- Function calls - fn helper(x: G) -> G { x * x } - pub fn call_helper(x: G) -> G { helper(x) + 1 } - - -- u8 / u32 ops - pub fn xor_bytes(a: U8, b: U8) -> U8 { u8_xor(a, b) } - pub fn add8(a: U8, b: U8) -> (U8, U8) { u8_add(a, b) } - pub fn lt32(a: G, b: G) -> G { u32_less_than(a, b) } - - -- Slice / set - pub fn middle(a: [G; 4]) -> [G; 2] { a[1..3] } - pub fn set_mid(a: [G; 3]) -> [G; 3] { set(a, 1, 99) } - - -- Assertions / IO / pointer ops - pub fn assert_same(x: G, y: G) -> G { assert_eq!(x, y); x } - pub fn io_roundtrip(x: G) -> [G; 1] { - io_write(0, [x]); io_read(0, 0, 1) - } - pub fn ptr_index(x: G) -> G { - let p = store(x); - ptr_val(p) - } - - -- Nested expressions - pub fn dot(a: (G, G), b: (G, G)) -> G { - let a0 = proj(a, 0); - let a1 = proj(a, 1); - let b0 = proj(b, 0); - let b1 = proj(b, 1); - (a0 * b0) + (a1 * b1) - } - - pub fn deep_chain(x: G) -> G { - let a = x + 1; - let b = a + 1; - let c = b + 1; - let d = c + 1; - let e = d + 1; - e - } - - -- Type aliases - pub fn aliased(x: MyField) -> MyField { x + 1 } - pub fn pair_sum(p: Pair‹G›) -> G { - match p { (a, b) => a + b, } - } - - pub fn factorial(n: G) -> G { - match n { - 0 => 1, - _ => n * factorial(n - 1), - } - } - - -- Unconstrained call: same semantics as constrained, exercises the - -- `unconstrained` flag through the pipeline. - pub fn call_helper_unc(x: G) -> G { #helper(x) + 1 } - - -- Recursion - pub fn fib(n: G) -> G { - let z = eq_zero(n); - match z { - 1 => 0, - _ => let z1 = eq_zero(n - 1); - match z1 { - 1 => 1, - _ => fib(n - 1) + fib(n - 2), - }, - } - } - - -- Mutual recursion - pub fn is_even(n: G) -> G { - let z = eq_zero(n); - match z { - 1 => 1, - _ => is_odd(n - 1), - } - } - pub fn is_odd(n: G) -> G { - let z = eq_zero(n); - match z { - 1 => 0, - _ => is_even(n - 1), - } - } - - -- Match end-to-end (single-level, .or, nested, .pointer, mixed, - -- non-`.var` scrutinee) - pub fn unwrap_or(opt: MyOpt, dflt: G) -> G { - match opt { - MyOpt.Some(x) => x, - MyOpt.None => dflt, - } - } - - pub fn sum_pair(p: APair) -> G { - match p { APair.Mk(a, b) => a + b, } - } - - pub fn fst_field(p: APair) -> G { - match p { APair.Mk(a, _) => a, } - } - - fn mk_some(x: G) -> MyOpt { MyOpt.Some(x) } - pub fn unwrap_call(x: G) -> G { - match mk_some(x) { - MyOpt.Some(v) => v, - MyOpt.None => 0, - } - } - - pub fn or_match(x: G) -> G { - match x { - 0 | 1 => 42, - _ => x, - } - } - - -- Active branch differs from default depending on value - pub fn match_mul(x: G) -> G { - match x { - 0 => 0, - _ => x * x * x, - } - } - - pub fn multi_match(x: G) -> G { - match x { - 0 => 100, - 1 => 200, - 2 => 300, - _ => 999, - } - } - - pub fn early_ret(x: G) -> G { - match x { - 0 => return 100, - _ => x + 1, - } - } - - pub fn deep(o: MyOpt2) -> G { - match o { - MyOpt2.Some2(MyOpt.Some(x)) => x, - _ => 99, - } - } - - pub fn tag_lookup(a: G, b: G) -> G { - match (a, b) { - (x, 1) => x, - (_, y) => y, - } - } - - pub fn nested_match(opt: MyOpt, fb: MyOpt) -> G { - match opt { - MyOpt.Some(x) => x, - MyOpt.None => match fb { - MyOpt.Some(y) => y, - MyOpt.None => 0, - }, - } - } - - pub fn dot_pair(p: (G, G)) -> G { - match p { (a, b) => a * b, } - } - - pub fn arr_fst(a: [G; 3]) -> G { - match a { [x, _, _] => x, } - } - - pub fn deref_match(x: G) -> G { - let p = store(x); - match p { &v => v + 10, } - } - - pub fn deep_deep(w: Wrap) -> G { - match w { - Wrap.W(MyOpt2.Some2(MyOpt.Some(x))) => x, - _ => 7, - } - } - - enum Nat { Zero, Succ(&Nat) } - pub fn pointer_match() -> G { - let two = Nat.Succ(store(Nat.Succ(store(Nat.Zero)))); - match two { - Nat.Succ(&Nat.Succ(&Nat.Zero)) => 1, - _ => 0, - } - } - - -- Multi-element tuple destructuring + projection - pub fn projections(a: (G, G, G, G, G)) -> (G, G) { - (proj(a, 1), proj(a, 3)) - } - - -- Slice + array index combined - pub fn slice_and_get(a: [G; 5]) -> [G; 2] { - let left = a[0..2]; - let right = a[3..5]; - [left[1], right[0]] - } - - -- Full IO: get_info + read + write + set_info - -- Exercises channel disambiguation: same key #[0] on channels 0 and 1 - -- resolves to distinct (idx, len) and arenas. Reads from each, writes - -- the concatenation back to channel 2, and registers `[1]` on channel 0. - pub fn read_write_io() { - let (idx_a, len_a) = io_get_info(0, [0]); - let (idx_b, _len_b) = io_get_info(1, [0]); - let xs: [G; 4] = io_read(0, idx_a, 4); - let ys: [G; 4] = io_read(1, idx_b, 4); - io_write(2, xs); - io_write(2, ys); - io_set_info(0, [1], idx_a, len_a + 4); - } - - -- u8 shifts + bit decomposition chain - pub fn shr_shr_shl_decompose(byte: U8) -> [G; 8] { - let s1 = u8_shift_right(byte); - let s2 = u8_shift_right(s1); - let s3 = u8_shift_left(s2); - u8_bit_decomposition(s3) - } - - -- u8_add and u8_xor combined - pub fn u8_add_xor(i: U8, j: U8) -> ((U8, U8), (U8, U8)) { - let xor = u8_xor(i, j); - (u8_add(xor, i), u8_add(xor, j)) - } - - -- `set` on an array of tuples — exercises set with multi-G elements - pub fn array_set(arr: [(G, G); 3]) -> [(G, G); 3] { - set(arr, 1, (0, 0)) - } - - -- `proj` on a mixed-size tuple — offset arithmetic with non-uniform - -- element sizes - pub fn proj_mixed(t: (G, (G, G), G)) -> (G, G) { - proj(t, 1) - } - - -- `let` with non-trivial pattern → simplifier hoists into match - pub fn deconstruct_tuple(as: (G, G, G, G, G)) -> (G, G) { - let (_, b, _, d, _) = as; - (b, d) - } - - pub fn deconstruct_array(as: [G; 5]) -> [G; 2] { - let [_, b, _, d, _] = as; - [b, d] - } - - -- Array return assembled from multiple eq_zero calls - pub fn eq_zero_dummy(a: G, b: G) -> [G; 4] { - let c = 0; - let d = 101; - [eq_zero(a), eq_zero(b), eq_zero(c), eq_zero(d)] - } - - -- Datatype with multiple-arity constructors (similar to a Shape ADT) - enum Shape { - Circle(G), - Rect(G, G), - Tri(G, G, G) - } - pub fn shape_area(s: Shape) -> G { - match s { - Shape.Circle(r) => r * r, - Shape.Rect(w, h) => w * h, - Shape.Tri(a, b, c) => a + b + c, - } - } - - -- Nested match with field patterns - pub fn nested_match2(x: G, y: G) -> G { - match x { - 0 => match y { - 0 => 10, - _ => 20, - }, - _ => match y { - 0 => 30, - _ => x + y, - }, - } - } - - -- Recursive datatype via pointer indirection - fn sum_list(l: MyList) -> G { - match l { - MyList.Nil => 0, - MyList.Cons(h, t) => h + sum_list(load(t)), - } - } - - pub fn run() -> G { - let p0 = store(MyList.Nil); - let p1 = store(MyList.Cons(3, p0)); - let p2 = store(MyList.Cons(2, p1)); - sum_list(MyList.Cons(1, p2)) - } - - -- ----- Direct ports from Tests/Aiur/Aiur.lean --------------------------- - - -- Trivial arithmetic - pub fn id(n: G) -> G { n } - pub fn proj1(a: G, _b: G) -> G { a } - pub fn sum(x: G, y: G) -> G { x + y } - pub fn prod(x: G, y: G) -> G { x * y } - pub fn sum_prod(x: G, y: G, z: G) -> G { (x + y) * z } - - -- Assertion (returns unit) - pub fn assert_eq_trivial() { - assert_eq!([1, 2, 3], [1, 2, 3]); - } - - -- Store/load named like Aiur - pub fn store_and_load(x: G) -> G { - load(store(x)) - } - - -- u8 op single-call wrappers - pub fn u8_sub_function(i: U8, j: U8) -> (U8, U8) { u8_sub(i, j) } - pub fn u8_mul_function(i: U8, j: U8) -> (U8, U8) { u8_mul(i, j) } - pub fn u8_less_than_function(i: U8, j: U8) -> G { u8_less_than(i, j) } - pub fn u8_and_function(i: U8, j: U8) -> U8 { u8_and(i, j) } - pub fn u8_or_function(i: U8, j: U8) -> U8 { u8_or(i, j) } - pub fn u8_xor_split7_function(i: U8, j: U8) -> (U8, U8) { u8_xor_split7(i, j) } - pub fn u8_xor_split4_function(i: U8, j: U8) -> (U8, U8) { u8_xor_split4(i, j) } - - -- Full u32 xor + right-rotation by 7, built from the fused per-byte - -- xor-split gadget (4 lookups + 4 free field adds). - pub fn u32_xor_rotr7(a: [U8; 4], b: [U8; 4]) -> [U8; 4] { - let (h0, l0) = u8_xor_split7(a[0], b[0]); - let (h1, l1) = u8_xor_split7(a[1], b[1]); - let (h2, l2) = u8_xor_split7(a[2], b[2]); - let (h3, l3) = u8_xor_split7(a[3], b[3]); - [u8_from_field_unsafe(to_field(h0) + to_field(l1)), - u8_from_field_unsafe(to_field(h1) + to_field(l2)), - u8_from_field_unsafe(to_field(h2) + to_field(l3)), - u8_from_field_unsafe(to_field(h3) + to_field(l0))] - } - - -- u32 less-than wrapper (named to match Aiur) - pub fn u32_less_than_function(x: G, y: G) -> G { u32_less_than(x, y) } - - -- u8 range-check / to_field / literal exercises - pub fn range_check_id(a: G, b: G) -> (G, G) { - let (x, y) = u8_range_check(a, b); - (to_field(x), to_field(y)) - } - pub fn u8_lit_xor(a: G) -> G { - let (x, _) = u8_range_check(a, a); - to_field(u8_xor(x, 200u8)) - } - pub fn u8_lits() -> (G, G, G) { - (to_field(0u8), to_field(127u8), to_field(255u8)) - } - -- Pattern-matching directly on a U8 scrutinee with byte-literal patterns. - pub fn classify_byte(a: G) -> G { - let (x, _) = u8_range_check(a, a); - match x { - 0u8 => 100, - 255u8 => 200, - _ => 7, - } - } - - -- EqZero degree-tracking regression - pub fn eq_zero_degree_desync(x: G) -> G { - let a = eq_zero(x); - let b = 100; - let c = x * x; - let d = c * c; - a + b + d - } - - -- Array get + set boundary cases on array-of-tuples - pub fn array_get_set(arr: [(G, G); 3]) -> [(G, G); 3] { - let p = arr[2]; - set(arr, 0, p) - } - - -- Unconstrained recursion mirroring `fib` - pub fn unconstrained_fibonacci(n: G) -> G { - let z = eq_zero(n); - match z { - 1 => 0, - _ => let z1 = eq_zero(n - 1); - match z1 { - 1 => 1, - _ => #unconstrained_fibonacci(n - 1) + unconstrained_fibonacci(n - 2), - }, - } - } - - -- Sel-gating: polynomial constraints (Mul, EqZero, AssertEq) - -- Non-exhaustive match on field literal; only the 0 arm is reachable here. - pub fn match_poly_ops(x: G) -> (G, G) { - match 0 { - 0 => assert_eq!([x], [x]); (x * x, eq_zero(x)), - 1 => assert_eq!([0], [1]); ((x + 1) * (x + 1), eq_zero(x + 1)), - } - } - - -- Sel-gating: function and memory lookup multiplicity - pub fn match_lookup_ops(x: G) -> (G, G) { - match 0 { - 0 => (id(x), load(store(x))), - 1 => (id(x), load(store(x))), - } - } - - -- Gadget ops under a match: same shapes the `aiur-prove` suite proves for - -- sel-gating; here they pin the execution semantics of gadget calls - -- inside branches - pub fn match_gadget_ops(i: U8, j: U8) -> (U8, U8, G) { - match 0 { - 0 => (u8_shift_right(i), u8_xor(i, j), u32_less_than(to_field(i), to_field(j))), - 1 => (u8_shift_right(i), u8_xor(i, j), u32_less_than(to_field(j), to_field(i))), - } - } - - pub fn match_gadget_ops_multi(i: U8, j: U8) -> ((U8, U8), [G; 8]) { - match 0 { - 0 => (u8_add(i, j), u8_bit_decomposition(i)), - 1 => (u8_add(i, j), u8_bit_decomposition(i)), - } - } - - -- Fold/iteration: compile-time unrolling with `@`-indices - pub fn fold_matrix_sum(m: [[G; 2]; 2]) -> G { - fold(0 .. 2, 0, |acc_outer, @i| - fold(0 .. 2, acc_outer, |acc_inner, @j| - acc_inner + m[@i][@j] - ) - ) - } - - -- Nested type aliases (`U8` is now a builtin type, not an alias) - type U16 = (U8, U8) - type U32 = (U16, U16) - type U64 = [U8; 8] - - pub fn alias_conversion(x: U64) -> U32 { - ((x[0], x[1]), (x[2], x[3])) - } - - -- Mutual recursion on `Nat` datatype (structural, pointer-based) - fn nat_even(m: Nat) -> G { - match m { - Nat.Zero => 1, - Nat.Succ(m) => nat_odd(load(m)), - } - } - fn nat_odd(m: Nat) -> G { - match m { - Nat.Zero => 0, - Nat.Succ(m) => nat_even(load(m)), - } - } - - pub fn is_0_even() -> G { nat_even(Nat.Zero) } - pub fn is_1_even() -> G { nat_even(Nat.Succ(store(Nat.Zero))) } - pub fn is_2_even() -> G { - nat_even(Nat.Succ(store(Nat.Succ(store(Nat.Zero))))) - } - pub fn is_0_odd() -> G { nat_odd(Nat.Zero) } - pub fn is_1_odd() -> G { nat_odd(Nat.Succ(store(Nat.Zero))) } - - -- Non-tail match (match bound to let, used afterwards) - pub fn ntm_basic(a: G) -> G { - let y = match a { 0 => 100, 1 => 200, _ => a * a, }; - y + 1 - } - - pub fn ntm_sequential(a: G, b: G) -> G { - let x = match a { 0 => 1, 1 => 2, _ => a, }; - let y = match b { 0 => 10, 1 => 20, _ => b, }; - x + y - } - - pub fn ntm_then_tail_match(a: G, b: G) -> G { - let x = match a { 0 => 100, _ => a, }; - match b { 0 => x, _ => x + b, } - } - - -- Non-tail match inside a tail match branch - pub fn ntm_inside_tail_match(flag: G, a: G) -> G { - match flag { - 0 => - let x = match a { 0 => 100, 1 => 200, _ => a * a, }; - x + 1, - _ => a, - } - } - - -- Non-tail match with store/load in branches (lookup gating) - pub fn ntm_store_load(a: G) -> G { - let x = match a { 0 => load(store(42)), _ => load(store(a)), }; - x + 1 - } - - -- Non-tail match with function calls in branches - fn ntm_helper(x: G) -> G { x * x + 1 } - pub fn ntm_call_in_branch(a: G) -> G { - let x = match a { 0 => ntm_helper(5), _ => ntm_helper(a), }; - x + 1 - } - - -- Non-tail match whose scrutinee is a function call (`let x = match foo(bar) {...}`). - -- The scrutinee is hoisted into a fresh let by the match compiler; the - -- continuation must still reach `matchContinue`. ntm_helper(x) = x*x+1, - -- so a=0 -> 101, a=2 -> 201, a=3 -> 10. - fn ntm_match_on_call(a: G) -> G { - let x = match ntm_helper(a) { 1 => 100, 5 => 200, _ => a * a, }; - x + 1 - } - - -- Pre-branch constant multiplied in a branch (no default) - pub fn ntm_const_mul(a: G) -> G { - let c = 5; - let x = match a { 0 => c * c, 1 => c * c * c, }; - x + 1 - } - - -- Non-tail match returning a tuple (multi-output merge) - pub fn ntm_tuple(a: G) -> (G, G) { - let (x, y) = match a { 0 => (10, 20), 1 => (30, 40), _ => (a, a * a), }; - (x + 1, y + 1) - } - - -- Non-tail match with early return - pub fn ntm_early_ret(a: G) -> G { - let y = match a { 0 => return 999, _ => a + a, }; - y * y - } - - -- Nested non-tail match - pub fn ntm_nested(a: G, b: G) -> G { - let x = match a { - 0 => match b { 0 => return 0, _ => 42, }, - _ => 99, - }; - x + 1 - } - - -- Large non-tail match (8 branches, no default) - pub fn ntm_large(a: G) -> G { - let x = match a { - 0 => 10, 1 => 20, 2 => 30, 3 => 40, - 4 => 50, 5 => 60, 6 => 70, 7 => 80, - }; - x + 1 - } - - -- Refutable pattern let with stored enum (Shape through pointer) - pub fn ntm_shape_let() -> G { - let s = store(Shape.Rect(3, 4)); - let Shape.Rect(w, h) = load(s); - w + h - } - - -- Templates (parametric datatypes + functions) - enum Wrapper‹A› { MkW(A) } - - fn unwrap‹A›(w: Wrapper‹A›) -> A { - match w { - Wrapper.MkW(x) => x, - } - } - - pub fn template_basic() -> G { - let w = Wrapper.MkW(42); - unwrap(w) - } - - enum TOpt‹A› { TSome(A), TNone } - - fn t_unwrap_or‹A›(opt: TOpt‹A›, default: A) -> A { - match opt { - TOpt.TSome(x) => x, - TOpt.TNone => default, - } - } - - pub fn template_unwrap_some() -> G { - let opt = TOpt.TSome(42); - t_unwrap_or(opt, 0) - } - - pub fn template_unwrap_none() -> G { - let opt = TOpt.TNone; - t_unwrap_or(opt, 99) - } - - enum TPair‹A, B› { TMk(A, B) } - - fn tpair_first‹A, B›(p: TPair‹A, B›) -> A { - match p { TPair.TMk(a, _) => a, } - } - fn tpair_second‹A, B›(p: TPair‹A, B›) -> B { - match p { TPair.TMk(_, b) => b, } - } - - pub fn template_pair() -> (G, G) { - let p = TPair.TMk(10, 20); - (tpair_first(p), tpair_second(p)) - } - - pub fn template_nested() -> G { - let inner = TPair.TMk(3, 4); - let opt = TOpt.TSome(inner); - let p = t_unwrap_or(opt, TPair.TMk(0, 0)); - tpair_first(p) + tpair_second(p) - } - - -- Template function calling another template function: exercises the - -- worklist's transitive specialization (unwrap_pair on Wrapper‹TPair‹G,G››). - fn unwrap_pair‹A, B›(w: Wrapper‹TPair‹A, B››) -> (A, B) { - let p = unwrap(w); - (tpair_first(p), tpair_second(p)) - } - - pub fn template_trans() -> G { - let p = TPair.TMk(7, 8); - let w = Wrapper.MkW(p); - let (a, b) = unwrap_pair(w); - a + b - } - - -- Same template instantiated with different concrete types in one program: - -- mono map must produce distinct monomorphic copies for `Wrapper‹G›` and - -- `Wrapper‹TPair‹G, G››`. - pub fn template_multi() -> G { - let w1 = Wrapper.MkW(11); - let w2 = Wrapper.MkW(TPair.TMk(3, 5)); - let v1 = unwrap(w1); - let p = unwrap(w2); - v1 + tpair_first(p) + tpair_second(p) - } - - -- Template instantiated at an array type: exercises `Typ.appendNameLimbs` - -- on the `[G; n]` arm (mangles to `G_3`). - pub fn template_array() -> G { - let w = Wrapper.MkW([10, 20, 30]); - let arr = unwrap(w); - arr[0] + arr[1] + arr[2] - } - - -- Template with tuple arg type-argument. - pub fn template_tuple_arg() -> G { - let w = Wrapper.MkW((4, 5)); - let p = unwrap(w); - proj(p, 0) + proj(p, 1) - } - - -- Template with pointer arg type-argument: Wrapper‹&G›. - pub fn template_pointer_arg() -> G { - let p = store(77); - let w = Wrapper.MkW(p); - let p' = unwrap(w); - load(p') - } - - -- Mutual-recursive templated datatype fields: exercises the worklist's - -- iterative discovery through recursive type references. - enum TMaybe‹A› { TJust(A), TNothing } - fn t_or_default‹A›(m: TMaybe‹A›, d: A) -> A { - match m { - TMaybe.TJust(x) => x, - TMaybe.TNothing => d, - } - } - pub fn template_chain() -> G { - -- Three specialisations of TMaybe: on G, on (G,G), on [G;2]. - let m1 = TMaybe.TJust(42); - let m2 = TMaybe.TJust((3, 5)); - let m3 = TMaybe.TNothing; - let v1 = t_or_default(m1, 0); - let p = t_or_default(m2, (0, 0)); - let arr : [G; 2] = t_or_default(m3, [10, 20]); - v1 + proj(p, 0) + proj(p, 1) + arr[0] + arr[1] - } - - -- Non-templated function consuming a specialised template (non-recursive): exercises - -- the worklist seeding from a non-template function's input type. - fn first_elt_g(l: TList‹G›) -> G { - match l { - TList.TNil => 0, - TList.TCons(h, _) => h, - } - } - - pub fn template_simple_consumer() -> G { - let l0 : TList‹G› = TList.TNil; - let l1 : TList‹G› = TList.TCons(42, store(l0)); - first_elt_g(l1) - } - - - -- Recursive templated datatype: TList‹A› with a pointer-back to itself. - -- Exercises the worklist on self-referential type arguments. - enum TList‹A› { TNil, TCons(A, &TList‹A›) } - - fn tlist_len‹A›(l: TList‹A›) -> G { - match l { - TList.TNil => 0, - TList.TCons(_, t) => 1 + tlist_len(load(t)), - } - } - - -- Reproduce the bug: recursive non-templated consumer of specialised template. - fn tlist_sum_g(l: TList‹G›) -> G { - match l { - TList.TNil => 0, - TList.TCons(h, t) => h + tlist_sum_g(load(t)), - } - } - - pub fn template_rec_consumer() -> G { - let l0 : TList‹G› = TList.TNil; - let l1 : TList‹G› = TList.TCons(5, store(l0)); - tlist_sum_g(l1) - } - - -- Two distinct specialisations of the same recursive template in one program. - pub fn template_multi_rec() -> G { - let l0g : TList‹G› = TList.TNil; - let l1g : TList‹G› = TList.TCons(7, store(l0g)); - let l2g : TList‹G› = TList.TCons(8, store(l1g)); - let l0p : TList‹(G, G)› = TList.TNil; - let l1p : TList‹(G, G)› = TList.TCons((1, 2), store(l0p)); - tlist_sum_g(l2g) + tlist_len(l1p) - } - - -- Non-templated match on a tuple-arg specialisation: the fresh match - -- compiler vars for `h` get type `(G, G)` (via the A=(G,G) substitution). - fn tlist_first_pair(l: TList‹(G, G)›) -> G { - match l { - TList.TNil => 0, - TList.TCons(p, _) => proj(p, 0) + proj(p, 1), - } - } - - pub fn template_tuple_match() -> G { - let l0 : TList‹(G, G)› = TList.TNil; - let l1 : TList‹(G, G)› = TList.TCons((3, 4), store(l0)); - tlist_first_pair(l1) - } - - -- Refutable-let on a templated constructor: flows through simplify's - -- match compiler, which is where the `constructorArgTypes` bug lived. - pub fn template_refutable_let() -> G { - let l : TList‹G› = TList.TCons(77, store(TList.TNil)); - let TList.TCons(h, _) = l; - h - } - - -- Pointer-deref pattern on a template: `TList.TCons(_, &rest) => ...` - -- uses pointer sub-patterns inside a templated constructor. - fn tlist_second(l: TList‹G›) -> G { - match l { - TList.TNil => 0, - TList.TCons(_, &rest) => - match rest { - TList.TNil => 0, - TList.TCons(h, _) => h, - }, - } - } - - pub fn template_pointer_pat() -> G { - let l0 : TList‹G› = TList.TNil; - let l1 : TList‹G› = TList.TCons(20, store(l0)); - let l2 : TList‹G› = TList.TCons(10, store(l1)); - tlist_second(l2) - } - - -- Template embedded in another template: Wrapper‹TList‹G››. - pub fn template_nested_rec() -> G { - let inner : TList‹G› = TList.TCons(42, store(TList.TNil)); - let w = Wrapper.MkW(inner); - let inner' = unwrap(w); - match inner' { - TList.TNil => 0, - TList.TCons(h, _) => h, - } - } - - -- Mutually recursive non-templated functions over a templated type. - fn tlist_mut_a(l: TList‹G›) -> G { - match l { - TList.TNil => 0, - TList.TCons(h, t) => h + tlist_mut_b(load(t)), - } - } - fn tlist_mut_b(l: TList‹G›) -> G { - match l { - TList.TNil => 0, - TList.TCons(h, t) => h * 2 + tlist_mut_a(load(t)), - } - } - pub fn template_mutual_rec() -> G { - let l0 : TList‹G› = TList.TNil; - let l1 : TList‹G› = TList.TCons(1, store(l0)); - let l2 : TList‹G› = TList.TCons(2, store(l1)); - let l3 : TList‹G› = TList.TCons(3, store(l2)); - tlist_mut_a(l3) - } - - -- Two templated args in one function: TPair‹A, B›-style through a template. - fn tpair_of_wrappers‹A, B›(w1: Wrapper‹A›, w2: Wrapper‹B›) -> (A, B) { - (unwrap(w1), unwrap(w2)) - } - pub fn template_dual_args() -> G { - let w1 = Wrapper.MkW(11); - let w2 = Wrapper.MkW((3, 4)); - let p = tpair_of_wrappers(w1, w2); - proj(p, 0) + proj(proj(p, 1), 0) + proj(proj(p, 1), 1) - } - - -- Unconstrained call to a template: `#unwrap(w)`. - pub fn template_unconstrained() -> G { - let w = Wrapper.MkW(99); - #unwrap(w) - } - - -- Nested refutable lets with pointer deref, on a templated type. - pub fn template_nested_refutable() -> G { - let inner : TList‹G› = TList.TCons(7, store(TList.TNil)); - let wrapped = TList.TCons(5, store(inner)); - let TList.TCons(h1, &rest) = wrapped; - let TList.TCons(h2, _) = rest; - h1 + h2 - } - - pub fn template_rec_list() -> G { - let l0 : TList‹G› = TList.TNil; - let l1 : TList‹G› = TList.TCons(10, store(l0)); - let l2 : TList‹G› = TList.TCons(20, store(l1)); - let l3 : TList‹G› = TList.TCons(30, store(l2)); - tlist_len(l3) - } - - - - -- Deeper nesting: Wrapper‹TMaybe‹G››. - pub fn template_deep_nest() -> G { - let inner = TMaybe.TJust(100); - let w = Wrapper.MkW(inner); - let m = unwrap(w); - t_or_default(m, 0) - } - - -- ----- Further ports from Tests/Aiur/Aiur.lean --------------------------- - - -- Fibonacci using the let-then-match style (distinct from the inline `fib` - -- above): catches simplifier regressions around let-bound scrutinees. - pub fn fibonacci(n: G) -> G { - match n { - 0 => 1, - _ => - let n_minus_1 = n - 1; - match n_minus_1 { - 0 => 1, - _ => - let n_minus_2 = n_minus_1 - 1; - fibonacci(n_minus_1) + fibonacci(n_minus_2), - }, - } - } - - -- Non-tail match returning a tuple that's then destructured: exercises the - -- multi-output merge + subsequent projection. - fn ntm_tuple_sum(a: G) -> G { - let (x, y) = ntm_tuple(a); - x + y - } - - -- Refutable-pattern let destructuring a `Nat` through a pointer. - fn ntm_ctor_let(n: Nat) -> G { - let Nat.Succ(&inner) = n; - match inner { Nat.Zero => 1, Nat.Succ(_) => 2, } - } - - -- Non-tail match branches with asymmetric lookup counts; continuation also - -- has a lookup. Exercises `sharedLookups` layout computation. - fn ntm_mixed_lookups(a: G) -> G { - let x = match a { - 0 => 42, - _ => load(store(a)), - }; - load(store(x + 1)) - } - - -- Asymmetric function-call lookups across branches (heavy vs light callee). - fn ntm_heavy_calls(a: G) -> G { load(store(load(store(a)))) } - fn ntm_light_calls(a: G) -> G { a + 1 } - fn ntm_asymmetric_lookups(a: G, b: G) -> G { - let x = match a { - 0 => ntm_heavy_calls(b), - 1 => ntm_light_calls(b), - _ => b, - }; - load(store(x)) - } - - -- 8-branch non-tail match inside a tail-match branch with multiple outer - -- arms: stresses sharedAux over-count under nested matches. - fn ntm_large_inside_tail(outer: G, inner: G) -> G { - match outer { - 0 => inner, - 1 => inner + 1, - 2 => - let x = match inner { - 0 => 10, 1 => 20, 2 => 30, 3 => 40, - 4 => 50, 5 => 60, 6 => 70, 7 => 80, - }; - x + 1, - _ => inner * inner, - } - } - - -- Refutable-pattern let (through pointer) nested inside a tail match. - fn ntm_refutable_let_in_match(flag: G) -> G { - let list = store(Nat.Succ(store(Nat.Zero))); - match flag { - 0 => - let Nat.Succ(&inner) = load(list); - match inner { Nat.Zero => 42, _ => 99, }, - _ => 0, - } - } - - -- Heavy-explicit branches: some constructor arms have pointer derefs that - -- generate load ops, while others don't. Used to be a sharedAux watermark - -- regression in the v1 pipeline. - enum CKind { - A(G), - B(G, &Nat), - C(G), - D(G, G), - E(G, &Nat), - F(G) - } - - fn ntm_heavy_explicit(flag: G, kind: CKind) -> G { - match flag { - 0 => - let val = match kind { - CKind.A(x) => x, - CKind.B(x, &extra) => - match extra { Nat.Zero => x, Nat.Succ(_) => x + 10, }, - CKind.C(x) => x * x, - CKind.D(x, y) => x + y, - CKind.E(x, &extra) => - match extra { Nat.Zero => x * x, Nat.Succ(_) => x + 100, }, - CKind.F(x) => x, - }; - val + 1, - _ => 0, - } - } - - -- 6-branch match with mixed per-branch lookup profiles, feeding a recursive - -- outer call: replicates the convert_all pattern from IxVM. - fn ntm_cv_a2(x: G) -> G { x + 1 } - fn ntm_cv_b2(x: G, extra: Nat) -> G { - match extra { Nat.Zero => x, Nat.Succ(_) => x + 10, } - } - fn ntm_cv_c2(x: G) -> G { x * x } - fn ntm_cv_d2(x: G, y: G) -> G { x + y } - fn ntm_cv_e2(x: G, extra: Nat) -> G { - match extra { Nat.Zero => x * x, Nat.Succ(_) => x + 100, } - } - fn ntm_cv_f2(x: G) -> G { load(store(x)) } - - fn ntm_convert_all(inputs: Nat, kind: CKind) -> G { - match inputs { - Nat.Zero => 0, - Nat.Succ(&rest) => - let ci = match kind { - CKind.A(x) => ntm_cv_a2(x), - CKind.B(x, &extra) => ntm_cv_b2(x, extra), - CKind.C(x) => ntm_cv_c2(x), - CKind.D(x, y) => ntm_cv_d2(x, y), - CKind.E(x, &extra) => ntm_cv_e2(x, extra), - CKind.F(x) => ntm_cv_f2(x), - }; - store(ci); - ci + ntm_convert_all(rest, kind), - } - } - - -- Exercise all 6 CKind branches + both Nil/Cons paths of the outer match. - pub fn ntm_recursive_test() -> G { - let zero = Nat.Zero; - let one = Nat.Succ(store(Nat.Zero)); - let two = Nat.Succ(store(Nat.Succ(store(Nat.Zero)))); - let r1 = ntm_convert_all(two, CKind.A(10)); - let r2 = ntm_convert_all(one, CKind.B(5, store(Nat.Succ(store(Nat.Zero))))); - let r3 = ntm_convert_all(two, CKind.C(3)); - let r4 = ntm_convert_all(one, CKind.D(2, 3)); - let r5 = ntm_convert_all(one, CKind.E(7, store(Nat.Zero))); - let r6 = ntm_convert_all(two, CKind.F(4)); - let r7 = ntm_convert_all(zero, CKind.A(99)); - r1 + r2 + r3 + r4 + r5 + r6 + r7 - } - - -- Large end-to-end entry aggregating the whole ntm_* family. - pub fn non_tail_match() -> G { - let r1 = ntm_basic(0) + ntm_basic(5); - let r2 = ntm_early_ret(0) + ntm_early_ret(3); - let r3 = ntm_sequential(1, 1); - let r4 = ntm_nested(0, 1) + ntm_nested(1, 0); - let r5 = ntm_const_mul(0); - let r6 = ntm_tuple_sum(0); - let r7 = ntm_then_tail_match(0, 3); - let r8 = ntm_call_in_branch(0); - let r9 = ntm_store_load(0); - let r10 = ntm_large(0); - let r11 = ntm_ctor_let(Nat.Succ(store(Nat.Zero))); - let r12 = ntm_mixed_lookups(0); - let r13 = ntm_shape_let(); - let r14 = ntm_asymmetric_lookups(1, 10); - let r15 = ntm_inside_tail_match(0, 0) + ntm_inside_tail_match(0, 1) - + ntm_inside_tail_match(1, 5); - let r16 = ntm_large_inside_tail(2, 0) + ntm_large_inside_tail(2, 3) - + ntm_large_inside_tail(2, 7) + ntm_large_inside_tail(0, 5) - + ntm_large_inside_tail(1, 5) + ntm_large_inside_tail(3, 4); - let r17 = ntm_heavy_explicit(0, CKind.B(5, store(Nat.Succ(store(Nat.Zero))))) - + ntm_heavy_explicit(0, CKind.A(7)) + ntm_heavy_explicit(1, CKind.A(99)); - let r18 = ntm_refutable_let_in_match(0); - let r19 = ntm_recursive_test(); - let r20 = ntm_nested(0, 0); - -- Function-call scrutinee: 101 + 201 + 10 = 312 - let r21 = ntm_match_on_call(0) + ntm_match_on_call(2) + ntm_match_on_call(3); - r1 + r2 + r3 + r4 + r5 + r6 + r7 + r8 + r9 + r10 - + r11 + r12 + r13 + r14 + r15 + r16 + r17 + r18 + r19 + r20 + r21 - } - - -- Inlined function calls (`@fn(args)`): the engines execute an - -- inlined call exactly like a normal one, so cross-engine agreement - -- checks the splice (alpha-renaming, nesting, strict-position hoisting, - -- branching callees, multi-output and gadget callees) preserved the - -- semantics. Mirrors the `aiur-prove` suite's `inline_test` scenarios. - fn inl_double(x: G) -> G { - let t = x + x; - t - } - - fn inl_sq(x: G) -> G { x * x } - - fn inl_sq_plus(x: G, y: G) -> G { @inl_sq(x) + y } - - -- Multi-output callee - fn inl_pair(x: G) -> (G, G) { (x + 1, x * 2) } - - fn inl_sign(x: G) -> G { - match x { - 0 => 0, - _ => 1, - } - } - - -- Gadget lookup inside the callee - fn inl_add8(a: U8, b: U8) -> (U8, U8) { u8_add(a, b) } - - -- Single aggregate entry: every scenario in one agreement run. - pub fn inline_test() -> G { - -- Basic splice - let r1 = @inl_double(21); -- 42 - -- Nested splice (callee @-inlines another helper) - let r2 = @inl_sq_plus(3, 4); -- 13 - -- Capture safety: caller binds `t` (the callee's local name) and the - -- argument mentions it - let t = 5; - let r3 = @inl_double(t + 1) + t; -- 17 - -- Strict positions: array elements, operator operands, call argument - let arr = [@inl_double(3), @inl_sq(3)]; -- [6, 9] - let r4 = arr[0] + arr[1] * 100; -- 906 - let r5 = @inl_double(3) + @inl_sq(3); -- 15 - let r6 = id(@inl_double(7)); -- 14 - -- Multi-output callee - let (p1, p2) = @inl_pair(5); -- (6, 10) - let r7 = p1 + p2 * 100; -- 1006 - -- Branching callee in operand position, both paths (the spliced match - -- gets bound to a fresh local before hoisting) - let r8 = @inl_sign(0) + @inl_sign(5) * 100; -- 100 - -- Same callee inlined and normally called - let r9 = @inl_sq(3) + inl_sq(4); -- 25 - -- Gadget lookup in the callee - let (s, c) = @inl_add8(200u8, 100u8); -- (44, 1) - let r10 = to_field(s) + to_field(c) * 1000; -- 1044 - r1 + r2 + r3 + r4 + r5 + r6 + r7 + r8 + r9 + r10 - } - - -- Unconstrained big-uint div/mod: lists of [U8; 8] limbs in, the same - -- list datatype at [G; 8] out. The datatype must declare Cons FIRST - -- (runtime tag contract: 0 = Cons, 1 = Nil). Limbs are little-endian - -- u64s, head-first. - enum BNode‹T› { - BCons(T, &BNode‹T›), - BNil - } - - fn blist0() -> &BNode‹[U8; 8]› { store(BNode.BNil) } - fn blist1(l: [U8; 8]) -> &BNode‹[U8; 8]› { store(BNode.BCons(l, blist0())) } - fn blist2(l0: [U8; 8], l1: [U8; 8]) -> &BNode‹[U8; 8]› { - store(BNode.BCons(l0, blist1(l1))) - } - - -- u64 value of the first result limb (fits in G for the cases below). - fn glimb_val(p: &BNode‹[G; 8]›) -> G { - match load(p) { - BNode.BCons(l, _) => l[0] + 256 * l[1] + 65536 * l[2] + 16777216 * l[3] - + 4294967296 * l[4] + 1099511627776 * l[5] + 281474976710656 * l[6] - + 72057594037927936 * l[7], - BNode.BNil => 0, - } - } - - fn glist_is_nil(p: &BNode‹[G; 8]›) -> G { - match load(p) { - BNode.BNil => 1, - BNode.BCons(_, _) => 0, - } - } - - -- Aggregate: plain divide (300/7), unit divisor (300/1), zero divisor - -- (300/0 → (Nil, 300) by convention), and a two-limb dividend with a - -- Nil remainder (2^64 / 2 → (2^63, Nil), canonical single-limb q). - pub fn divmod_test() -> G { - let a300 = blist1([44u8, 1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); - let b7 = blist1([7u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); - let (q1, r1) = unconstrained_big_uint_div_mod(a300, b7); - let s1 = glimb_val(q1) + 1000 * glimb_val(r1); -- 42 + 6000 - let b1 = blist1([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); - let (q2, _r2) = unconstrained_big_uint_div_mod(a300, b1); - let s2 = glimb_val(q2); -- 300 - let (q3, r3) = unconstrained_big_uint_div_mod(a300, blist0()); - let s3 = 1000000 * glist_is_nil(q3) + glimb_val(r3); -- 1000300 - let a64 = blist2([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], - [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); - let b2 = blist1([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); - let (q4, r4) = unconstrained_big_uint_div_mod(a64, b2); - let s4 = glimb_val(q4) + glist_is_nil(r4); -- 2^63 + 1 - s1 + s2 + s3 + s4 - } - - -- Hoisting must preserve caller scopes and left-to-right effects, including - -- a statement's position before lets in its continuation. - fn hoist_pair(a: G, b: G) -> (G, G) { (a, b) } - fn hoist_emit(x: G) -> G { io_write(0, [x]); x } - fn hoist_twice(x: G) -> G { let tmp = x + x; tmp } - enum HoistChoice { Left(G), Right(G) } - fn hoist_choose(c: HoistChoice) -> G { - match c { HoistChoice.Left(x) | HoistChoice.Right(x) => x, } - } - fn hoist_guarded(x: G) -> G { - assert_eq!(x, 0); - let y = @hoist_choose(HoistChoice.Left(7)); - y - } - pub fn hoist_guarded_operand(x: G) -> G { @hoist_guarded(x) + 1 } - pub fn hoist_guarded_rhs(x: G) -> G { let y = @hoist_guarded(x); y + 1 } - pub fn hoist_guarded_return(x: G) -> G { return @hoist_guarded(x) } - pub fn hoist_write_then_branch(x: G) -> G { - let y = (io_write(0, [x]); let z = @hoist_choose(HoistChoice.Right(x)); z); - y + 1 - } - pub fn hoist_metadata_then_branch(x: G) -> G { - let y = (io_set_info(0, [x], 3, 4); let z = @hoist_choose(HoistChoice.Right(x)); z); - y + 1 - } - pub fn hoist_or_inline() -> (G, G) { - (@hoist_choose(HoistChoice.Left(4)), @hoist_choose(HoistChoice.Right(6))) - } - - pub fn hoist_assert_shadow(x: G) -> G { - assert_eq!(x, 0); - let x = 0; - x - } - pub fn hoist_write_read(x: G) -> G { - io_write(0, [x]); - let ys = io_read(0, 0, 1); - ys[0] - } - pub fn hoist_set_get(x: G) -> (G, G) { - io_set_info(0, [x], 3, 4); - let info = io_get_info(0, [x]); - info - } - pub fn hoist_write_shadow(x: G) -> G { - let channel = 0; - io_write(channel, [x]); - let channel = 1; - io_write(channel, [x + 1]); - x - } - pub fn hoist_rhs_shadow(x: G) -> (G, G) { - let y = (let x = 2; x); - (x, y) - } - pub fn hoist_operand_shadow(x: G) -> G { x + (let x = 2; x) } - pub fn hoist_array_shadow(x: G) -> [G; 2] { [(let x = 2; x), x] } - pub fn hoist_call_shadow(x: G) -> (G, G) { hoist_pair((let x = 2; x), x) } - pub fn hoist_match_shadow(x: G) -> G { - match (let x = 0; x) { 0 => x, _ => 99, } - } - pub fn hoist_argument_order() -> G { hoist_emit(1) + (let x = hoist_emit(2); x) } - pub fn hoist_argument_cores() -> (G, G) { - hoist_pair((let x = 1; hoist_emit(x)), (let x = hoist_emit(2); x)) - } - pub fn hoist_array_order() -> [G; 2] { [hoist_emit(1), (let x = hoist_emit(2); x)] } - pub fn hoist_inline_shadow(x: G) -> G { x + @hoist_twice((let x = 2; x)) } - -- Generated-looking names are valid identifiers too. - pub fn hoist_fresh_name(«inl#0»: G) -> G { - let y = @hoist_twice(2); - «inl#0» + y - } - pub fn hoist_inline_order() -> G { hoist_emit(1) + @hoist_twice(hoist_emit(2)) } - pub fn hoist_assert_argument_order() -> G { - assert_eq!(hoist_emit(1), (let ignored = hoist_emit(2); 1)); - 7 - } - pub fn hoist_io_argument_order() -> G { - io_write(hoist_emit(0), [(let ignored = hoist_emit(1); 2)]); - 7 - } - pub fn hoist_info_argument_order() -> (G, G) { - io_set_info(hoist_emit(0), [(let ignored = hoist_emit(1); 7)], - (let ignored = hoist_emit(2); 3), (let ignored = hoist_emit(3); 4)); - let info = io_get_info(0, [7]); - info - } - pub fn hoist_allocation_order() -> (G, G) { - (ptr_val(store(1)), (let p = store(2); ptr_val(p))) - } - pub fn hoist_return_continuation(x: G) -> G { - assert_eq!(x, 0); - let x = 7; - return x - } - pub fn hoist_lazy_arm(x: G) -> G { - match x { - 0 => 7, - _ => assert_eq!(0, 1); let x = hoist_emit(9); x, - } - } - - -- Unconstrained field hints: `g_to_bytes` returns the 8 LE bytes of the - -- CANONICAL u64 value as raw [G; 8] advice; `g_inverse` the field - -- inverse with 0 ↦ 0. - pub fn hint_test() -> G { - -- 300 = 0x012C → LE bytes [44, 1, 0, ...] - let b = unconstrained_g_to_bytes(300); - let s1 = b[0] + 1000 * b[1]; -- 1044 - let s2 = b[7]; -- 0 - -- x * x⁻¹ = 1 for x ≠ 0; 0 ↦ 0 - let s3 = unconstrained_g_inverse(7) * 7; -- 1 - let s4 = unconstrained_g_inverse(0); -- 0 - -- Canonicality: 0 - 1 wraps to p - 1 = 0xFFFFFFFF00000000 - let c = unconstrained_g_to_bytes(0 - 1); - let s5 = c[4] + c[0]; -- 255 - s1 + s2 + 10 * s3 + s4 + s5 -- 1309 - } -⟧ - -/-- Compiler outputs shared by every agreement case. Top-level closed -defs are computed once at module initialization, so the toplevel is -type-checked and compiled a single time instead of once per case. -/ -private def crossDecls : Except String Source.Decls := - toplevel.mkDecls.mapError toString - -private def crossCompiled : Except String CompiledToplevel := - toplevel.compile - -/-- Generic helper: run one entry point through all four engines — the -source-level reference evaluator (`Source.Eval`), the source interpreter -(`Aiur.Interpret`), the lowered bytecode evaluator (`Bytecode.Eval`) and -the native bytecode executor — asserting that the flat-encoded return -value and the `IOBuffer` of each engine agree with the reference -evaluator. An optional `io` arg seeds every engine with a pre-populated -`IOBuffer`. -/ -def runAgreement - (label : String) (entryName : String) - (inputs : List Value) (io : IOBuffer := default) (fuel : Nat := 1000) : - TestSeq := Id.run do - let globalName : Global := .init entryName - match crossDecls with - | .error e => pure (test s!"{label}: mkDecls ({e})" false) - | .ok decls => - match Source.Eval.runFunction decls globalName inputs io fuel with - | .error e => pure (test s!"{label}: Source.Eval ({repr e})" false) - | .ok (srcVal, srcIo) => - match crossCompiled with - | .error e => pure (test s!"{label}: Compile ({e})" false) - | .ok ct => - let funIdx := ct.getFuncIdx (.mkSimple entryName) |>.getD 0 - let funcIdx := fun g => ct.nameMap[g]? - let srcFlat := flattenValue decls funcIdx srcVal - let flatArgs : Array Aiur.G := inputs.foldl - (fun acc v => acc ++ flattenValue decls funcIdx v) #[] - let bcTests := match Bytecode.Eval.runFunction ct.bytecode funIdx flatArgs io fuel with - | .error e => test s!"{label}: Bytecode.Eval ({repr e})" false - | .ok (bcOut, bcIo) => - test s!"{label}: Bytecode.Eval values agree (src={srcFlat}, bc={bcOut})" - (srcFlat == bcOut) - ++ test s!"{label}: Bytecode.Eval io agree" (srcIo == bcIo) - let interpTests := match Aiur.runFunction decls globalName inputs io with - | (.error e, _) => test s!"{label}: Interpret ({e})" false - | (.ok interpVal, state) => - let interpFlat := flattenValue decls funcIdx interpVal - test s!"{label}: Interpret values agree (src={srcFlat}, interp={interpFlat})" - (srcFlat == interpFlat) - ++ test s!"{label}: Interpret io agree" (srcIo == state.ioBuffer) - let execTests := match ct.bytecode.execute funIdx flatArgs io with - | .error e => test s!"{label}: execute ({e})" false - | .ok (exOut, exIo, _) => - test s!"{label}: execute values agree (src={srcFlat}, exec={exOut})" - (srcFlat == exOut) - ++ test s!"{label}: execute io agree" (srcIo == exIo) - pure (bcTests ++ interpTests ++ execTests) - -/-- Negative-path agreement: every engine must REJECT the run. A single -engine accepting (or crashing differently) where the others error is a -semantics divergence even though no success value exists to compare — -the `return`-handling bugs hid exactly this way. Error *messages* are -engine-specific, so only rejection itself is asserted. -/ -def runFailureAgreement - (label : String) (entryName : String) - (inputs : List Value) (io : IOBuffer := default) (fuel : Nat := 1000) : - TestSeq := Id.run do - let globalName : Global := .init entryName - match crossDecls, crossCompiled with - | .error e, _ => pure (test s!"{label}: mkDecls ({e})" false) - | _, .error e => pure (test s!"{label}: Compile ({e})" false) - | .ok decls, .ok ct => - let funIdx := ct.getFuncIdx (.mkSimple entryName) |>.getD 0 - let funcIdx := fun g => ct.nameMap[g]? - let flatArgs : Array Aiur.G := inputs.foldl - (fun acc v => acc ++ flattenValue decls funcIdx v) #[] - let srcRejects := match Source.Eval.runFunction decls globalName inputs io fuel with - | .error _ => true | .ok _ => false - let bcRejects := match Bytecode.Eval.runFunction ct.bytecode funIdx flatArgs io fuel with - | .error _ => true | .ok _ => false - let interpRejects := match Aiur.runFunction decls globalName inputs io with - | (.error _, _) => true | (.ok _, _) => false - let execRejects := match ct.bytecode.execute funIdx flatArgs io with - | .error _ => true | .ok _ => false - pure <| - test s!"{label}: Source.Eval rejects" (srcRejects = true) - ++ test s!"{label}: Bytecode.Eval rejects" (bcRejects = true) - ++ test s!"{label}: Interpret rejects" (interpRejects = true) - ++ test s!"{label}: execute rejects" (execRejects = true) - -private def myOpt (limb : String) : Global := Global.init "MyOpt" |>.pushNamespace limb -private def myOpt2 (limb : String) : Global := Global.init "MyOpt2" |>.pushNamespace limb -private def wrap (limb : String) : Global := Global.init "Wrap" |>.pushNamespace limb -private def apair (limb : String) : Global := Global.init "APair" |>.pushNamespace limb - --- Renaming must preserve invalid binding patterns so the checker still --- rejects them, while `hoist_or_inline` exercises a valid shared binder. -private def hoistPatternRejections : TestSeq := - let duplicate : Source.Toplevel := ⟦ - pub fn duplicate(x: G) -> G { let (y, y) = (x, x); y } - ⟧ - let alternatives : Source.Toplevel := ⟦ - pub fn alternatives(x: G) -> G { - match (x, x) { (0, y) | (z, 1) => 0, _ => 1, } - } - ⟧ - (withExceptOk "normalize duplicate binders" duplicate.inlineCalls fun t => - let rejects : Bool := match t.checkAndSimplify with - | .error (.duplicatedBind _) => true | _ => false - test "duplicate binders remain invalid" (rejects = true)) ++ - (withExceptOk "normalize mismatched or-pattern binders" alternatives.inlineCalls fun t => - let rejects : Bool := match t.checkAndSimplify with - | .error (.differentBindings _ _) => true | _ => false - test "mismatched or-pattern binders remain invalid" (rejects = true)) - -/-- The variable fallback must alias the already-evaluated scrutinee, not -contain a second call. This guards bytecode shape even when runtime memoization -would conceal the duplicate computation in an output-only test. -/ -def matchScrutineeTests : TestSeq := - withExceptOk "match scrutinee compilation succeeds" toplevel.compile fun compiled => - let f := compiled.bytecode.functions[compiled.getFuncIdx `match_scrut_call |>.get!]! - test "call scrutinee is emitted exactly once" - ((Bytecode.collectCalleesBlock f.body).size == 1) - -def cseStructureTests : TestSeq := - withExceptOk "CSE compilation succeeds" toplevel.compile fun compiled => - let ops := fun name => - compiled.bytecode.functions[compiled.getFuncIdx name |>.get!]!.body.ops - test "repeated arithmetic has only one mul and one eqZero" - (ops `cse_arithmetic == #[.mul 0 0, .eqZero 0]) ++ - test "repeated load has only one lookup" - (ops `cse_load == #[.load 1 0]) ++ - test "duplicate stores share a pointer; their loads are forwarded" - ((ops `cse_memory).filter (fun op => match op with - | .store _ | .load .. => true | _ => false) == #[.store #[0]]) ++ - test "CSE preserves both calls" - (((ops `cse_calls).filter (fun op => match op with - | .call .. => true | _ => false)).size == 2) ++ - test "CSE preserves both assertions" - (((ops `cse_assertions).filter (fun op => match op with - | .assertEq .. => true | _ => false)).size == 2) ++ - test "CSE preserves both unconstrained hints" - (ops `cse_hints == #[.unconstrainedGInverse 0, .unconstrainedGInverse 0]) - -def tests : TestSeq := - cseStructureTests ++ - runAgreement "cse_arithmetic(0)" "cse_arithmetic" [0] ++ - runAgreement "cse_arithmetic(7)" "cse_arithmetic" [7] ++ - runAgreement "cse_memory(7)" "cse_memory" [7] ++ - runAgreement "cse_memory_widths(7)" "cse_memory_widths" [7] ++ - runAgreement "cse_empty_memory" "cse_empty_memory" [] ++ - runFailureAgreement "CSE retains the first invalid load" "cse_load" [.pointer 1 999] ++ - runAgreement "cse_join(0,7)" "cse_join" [0, 7] ++ - runAgreement "cse_join(1,7)" "cse_join" [1, 7] ++ - runAgreement "cse_join(2,7)" "cse_join" [2, 7] ++ - runAgreement "cse_nested(0,7)" "cse_nested" [0, 7] ++ - runAgreement "cse_nested(1,7)" "cse_nested" [1, 7] ++ - runAgreement "cse_calls(7)" "cse_calls" [7] ++ - runAgreement "cse_assertions(7,7)" "cse_assertions" [7, 7] ++ - runFailureAgreement "CSE preserves rejecting assertions" "cse_assertions" [7, 8] ++ - runAgreement "cse_io(7)" "cse_io" [7] ++ - runFailureAgreement "CSE preserves duplicate IO key rejection" "cse_duplicate_io_key" [7] ++ - runAgreement "cse_hints(7)" "cse_hints" [7] ++ - matchScrutineeTests ++ - runAgreement "match_scrut_call(0)" "match_scrut_call" [0] ++ - runAgreement "match_scrut_call(7)" "match_scrut_call" [7] ++ - runAgreement "match_scrut_nested(0)" "match_scrut_nested" [0] ++ - runAgreement "match_scrut_nested(1)" "match_scrut_nested" [1] ++ - runAgreement "match_scrut_nested(2)" "match_scrut_nested" [2] ++ - runAgreement "match_scrut_wildcard(0)" "match_scrut_wildcard" [0] ++ - runAgreement "match_scrut_effect(0)" "match_scrut_effect" [0] ++ - runAgreement "match_scrut_effect(7)" "match_scrut_effect" [7] ++ - runAgreement "match_scrut_unused(7)" "match_scrut_unused" [7] ++ - runFailureAgreement "wildcard still evaluates its scrutinee" "match_scrut_wildcard" [1] ++ - hoistPatternRejections ++ - -- Arithmetic + simple control flow - runAgreement "add_one(41)" "add_one" [41] ++ - runAgreement "arith(3,4)" "arith" [3, 4] ++ - runAgreement "fst((7,9))" "fst" - [.tuple #[7, 9]] ++ - runAgreement "second(#[10,20,30])" "second" - [.array #[10, 20, 30]] ++ - runAgreement "roundtrip(99)" "roundtrip" [99] ++ - runAgreement "call_helper(5)" "call_helper" [5] ++ - runAgreement "call_helper_unc(5)" "call_helper_unc" [5] ++ - runAgreement "deep_chain(0)" "deep_chain" [0] ++ - runAgreement "dot((3,4),(5,6))" "dot" - [.tuple #[3, 4], .tuple #[5, 6]] ++ - -- u8 / u32 / slice / set / asserts / IO - runAgreement "xor_bytes(0xAA,0x55)" "xor_bytes" [0xAA, 0x55] ++ - runAgreement "add8(200,100)" "add8" [200, 100] ++ - runAgreement "lt32(3,5)" "lt32" [3, 5] ++ - runAgreement "lt32(5,3)" "lt32" [5, 3] ++ - runAgreement "middle(#[1,2,3,4])" "middle" - [.array #[1, 2, 3, 4]] ++ - runAgreement "set_mid(#[1,2,3])" "set_mid" - [.array #[1, 2, 3]] ++ - runAgreement "assert_same(7,7)" "assert_same" [7, 7] ++ - runAgreement "io_roundtrip(55)" "io_roundtrip" [55] ++ - runAgreement "ptr_index(77)" "ptr_index" [77] ++ - -- Type aliases - runAgreement "aliased(41)" "aliased" [41] ++ - runAgreement "pair_sum((4,5))" "pair_sum" - [.tuple #[4, 5]] ++ - -- Recursion + mutual recursion - runAgreement "fib(5)" "fib" [5] ++ - runAgreement "fib(6)" "fib" [6] ++ - runAgreement "factorial(5)" "factorial" [5] ++ - runAgreement "factorial(6)" "factorial" [6] ++ - runAgreement "is_even(4)" "is_even" [4] ++ - runAgreement "is_even(5)" "is_even" [5] ++ - runAgreement "is_odd(3)" "is_odd" [3] ++ - -- Pattern matching - runAgreement "unwrap_or(Some 7, 0)" "unwrap_or" - [.ctor (myOpt "Some") #[7], 0] ++ - runAgreement "unwrap_or(None, 99)" "unwrap_or" - [.ctor (myOpt "None") #[], 99] ++ - runAgreement "sum_pair(Mk 10 20)" "sum_pair" - [.ctor (apair "Mk") #[10, 20]] ++ - runAgreement "fst_field(Mk 42 99)" "fst_field" - [.ctor (apair "Mk") #[42, 99]] ++ - runAgreement "unwrap_call(13)" "unwrap_call" [13] ++ - runAgreement "or_match(0)" "or_match" [0] ++ - runAgreement "or_match(1)" "or_match" [1] ++ - runAgreement "or_match(5)" "or_match" [5] ++ - runAgreement "match_mul(0)" "match_mul" [0] ++ - runAgreement "match_mul(2)" "match_mul" [2] ++ - runAgreement "match_mul(3)" "match_mul" [3] ++ - runAgreement "multi_match(0)" "multi_match" [0] ++ - runAgreement "multi_match(1)" "multi_match" [1] ++ - runAgreement "multi_match(2)" "multi_match" [2] ++ - runAgreement "multi_match(5)" "multi_match" [5] ++ - runAgreement "multi_match(7)" "multi_match" [7] ++ - runAgreement "early_ret(0)" "early_ret" [0] ++ - runAgreement "early_ret(5)" "early_ret" [5] ++ - runAgreement "deep(Some2(Some 7))" "deep" - [.ctor (myOpt2 "Some2") #[.ctor (myOpt "Some") #[7]]] ++ - runAgreement "deep(Some2(None))" "deep" - [.ctor (myOpt2 "Some2") #[.ctor (myOpt "None") #[]]] ++ - runAgreement "deep(None2)" "deep" - [.ctor (myOpt2 "None2") #[]] ++ - runAgreement "tag_lookup(7,1)" "tag_lookup" [7, 1] ++ - runAgreement "tag_lookup(7,2)" "tag_lookup" [7, 2] ++ - runAgreement "nested_match(Some 5, Some 99)" "nested_match" - [.ctor (myOpt "Some") #[5], .ctor (myOpt "Some") #[99]] ++ - runAgreement "nested_match(None, Some 99)" "nested_match" - [.ctor (myOpt "None") #[], .ctor (myOpt "Some") #[99]] ++ - runAgreement "nested_match(None, None)" "nested_match" - [.ctor (myOpt "None") #[], .ctor (myOpt "None") #[]] ++ - runAgreement "dot_pair((6,7))" "dot_pair" - [.tuple #[6, 7]] ++ - runAgreement "arr_fst(#[11,22,33])" "arr_fst" - [.array #[11, 22, 33]] ++ - runAgreement "deref_match(15)" "deref_match" [15] ++ - runAgreement "deep_deep(W (Some2 (Some 42)))" "deep_deep" - [.ctor (wrap "W") - #[.ctor (myOpt2 "Some2") - #[.ctor (myOpt "Some") #[42]]]] ++ - runAgreement "deep_deep(W (Some2 None))" "deep_deep" - [.ctor (wrap "W") - #[.ctor (myOpt2 "Some2") #[.ctor (myOpt "None") #[]]]] ++ - runAgreement "deep_deep(W None2)" "deep_deep" - [.ctor (wrap "W") #[.ctor (myOpt2 "None2") #[]]] ++ - runAgreement "pointer_match()" "pointer_match" [] ++ - runAgreement "projections((1,2,3,4,5))" "projections" - [.tuple #[1, 2, 3, 4, 5]] ++ - runAgreement "slice_and_get(#[10,20,30,40,50])" "slice_and_get" - [.array #[10, 20, 30, 40, 50]] ++ - runAgreement "shr_shr_shl_decompose(0xCA)" "shr_shr_shl_decompose" - [0xCA] ++ - runAgreement "u8_add_xor(0xAA,0x55)" "u8_add_xor" [0xAA, 0x55] ++ - runAgreement "array_set" "array_set" - [.array #[.tuple #[1, 2], .tuple #[3, 4], .tuple #[5, 6]]] ++ - runAgreement "proj_mixed((1,(2,3),4))" "proj_mixed" - [.tuple #[1, .tuple #[2, 3], 4]] ++ - runAgreement "deconstruct_tuple(1..5)" "deconstruct_tuple" - [.tuple #[1, 2, 3, 4, 5]] ++ - runAgreement "deconstruct_array(#[1..5])" "deconstruct_array" - [.array #[1, 2, 3, 4, 5]] ++ - runAgreement "eq_zero_dummy(0,5)" "eq_zero_dummy" [0, 5] ++ - runAgreement "eq_zero_dummy(0,37)" "eq_zero_dummy" [0, 37] ++ - runAgreement "shape_area(Circle 5)" "shape_area" - [.ctor (Global.init "Shape" |>.pushNamespace "Circle") #[5]] ++ - runAgreement "shape_area(Rect 3 7)" "shape_area" - [.ctor (Global.init "Shape" |>.pushNamespace "Rect") #[3, 7]] ++ - runAgreement "shape_area(Tri 1 2 3)" "shape_area" - [.ctor (Global.init "Shape" |>.pushNamespace "Tri") #[1, 2, 3]] ++ - runAgreement "nested_match2(0,0)" "nested_match2" [0, 0] ++ - runAgreement "nested_match2(0,1)" "nested_match2" [0, 1] ++ - runAgreement "nested_match2(0,5)" "nested_match2" [0, 5] ++ - runAgreement "nested_match2(2,0)" "nested_match2" [2, 0] ++ - runAgreement "nested_match2(2,3)" "nested_match2" [2, 3] ++ - runAgreement "nested_match2(3,0)" "nested_match2" [3, 0] ++ - runAgreement "nested_match2(3,4)" "nested_match2" [3, 4] ++ - -- Recursive datatype + pointer - runAgreement "sum_list[1,2,3]" "run" [] ++ - -- ----- Direct ports from Tests/Aiur/Aiur.lean ----------------------------- - runAgreement "id(42)" "id" [42] ++ - runAgreement "proj1(42,64)" "proj1" [42, 64] ++ - runAgreement "sum(3,5)" "sum" [3, 5] ++ - runAgreement "prod(3,5)" "prod" [3, 5] ++ - runAgreement "sum_prod(2,3,4)" "sum_prod" [2, 3, 4] ++ - runAgreement "assert_eq_trivial" "assert_eq_trivial" [] ++ - runAgreement "store_and_load(42)" "store_and_load" [42] ++ - runAgreement "u8_sub_function(45,131)" "u8_sub_function" [45, 131] ++ - runAgreement "u8_mul_function(45,131)" "u8_mul_function" [45, 131] ++ - runAgreement "u8_mul_function(255,255)" "u8_mul_function" [255, 255] ++ - runAgreement "u8_less_than_function(45,131)" "u8_less_than_function" [45, 131] ++ - runAgreement "u8_less_than_function(131,45)" "u8_less_than_function" [131, 45] ++ - runAgreement "u8_and_function(45,131)" "u8_and_function" [45, 131] ++ - runAgreement "u8_or_function(45,131)" "u8_or_function" [45, 131] ++ - runAgreement "u8_xor_split7_function(45,131)" "u8_xor_split7_function" [45, 131] ++ - runAgreement "u8_xor_split7_function(0,255)" "u8_xor_split7_function" [0, 255] ++ - runAgreement "u8_xor_split4_function(45,131)" "u8_xor_split4_function" [45, 131] ++ - runAgreement "u8_xor_split4_function(255,255)" "u8_xor_split4_function" [255, 255] ++ - runAgreement "u32_xor_rotr7(a,b)" "u32_xor_rotr7" - [.array #[45, 131, 200, 17], .array #[200, 17, 45, 131]] ++ - runAgreement "range_check_id(45,200)" "range_check_id" [45, 200] ++ - runAgreement "range_check_id(0,255)" "range_check_id" [0, 255] ++ - runAgreement "u8_lit_xor(45)" "u8_lit_xor" [45] ++ - runAgreement "u8_lits" "u8_lits" [] ++ - runAgreement "classify_byte(0)" "classify_byte" [0] ++ - runAgreement "classify_byte(255)" "classify_byte" [255] ++ - runAgreement "classify_byte(42)" "classify_byte" [42] ++ - runAgreement "u32_less_than_function(300,500)" "u32_less_than_function" [300, 500] ++ - runAgreement "u32_less_than_function(500,300)" "u32_less_than_function" [500, 300] ++ - runAgreement "u32_less_than_function(500,500)" "u32_less_than_function" [500, 500] ++ - runAgreement "eq_zero_degree_desync(3)" "eq_zero_degree_desync" [3] ++ - runAgreement "array_get_set" "array_get_set" - [.array #[.tuple #[1, 1], .tuple #[2, 2], .tuple #[3, 3]]] ++ - runAgreement "unconstrained_fibonacci(6)" "unconstrained_fibonacci" [6] ++ - runAgreement "match_poly_ops(42)" "match_poly_ops" [42] ++ - runAgreement "match_lookup_ops(42)" "match_lookup_ops" [42] ++ - runAgreement "match_gadget_ops(45,131)" "match_gadget_ops" [45, 131] ++ - runAgreement "match_gadget_ops_multi(45,131)" "match_gadget_ops_multi" [45, 131] ++ - runAgreement "fold_matrix_sum([[1,2],[3,4]])" "fold_matrix_sum" - [.array #[.array #[1, 2], .array #[3, 4]]] ++ - runAgreement "alias_conversion[1..8]" "alias_conversion" - [.array #[1, 2, 3, 4, 5, 6, 7, 8]] ++ - runAgreement "is_0_even" "is_0_even" [] ++ - runAgreement "is_1_even" "is_1_even" [] ++ - runAgreement "is_2_even" "is_2_even" [] ++ - runAgreement "is_0_odd" "is_0_odd" [] ++ - runAgreement "is_1_odd" "is_1_odd" [] ++ - -- Non-tail match tests - runAgreement "ntm_basic(0)" "ntm_basic" [0] ++ - runAgreement "ntm_basic(5)" "ntm_basic" [5] ++ - runAgreement "ntm_sequential(1,1)" "ntm_sequential" [1, 1] ++ - runAgreement "ntm_then_tail_match(0,3)" "ntm_then_tail_match" [0, 3] ++ - runAgreement "ntm_inside_tail_match(0,0)" "ntm_inside_tail_match" [0, 0] ++ - runAgreement "ntm_inside_tail_match(0,1)" "ntm_inside_tail_match" [0, 1] ++ - runAgreement "ntm_inside_tail_match(1,5)" "ntm_inside_tail_match" [1, 5] ++ - runAgreement "ntm_store_load(0)" "ntm_store_load" [0] ++ - runAgreement "ntm_call_in_branch(0)" "ntm_call_in_branch" [0] ++ - runAgreement "ntm_const_mul(0)" "ntm_const_mul" [0] ++ - runAgreement "ntm_tuple(0)" "ntm_tuple" [0] ++ - runAgreement "ntm_early_ret(0)" "ntm_early_ret" [0] ++ - runAgreement "ntm_early_ret(3)" "ntm_early_ret" [3] ++ - runAgreement "ntm_nested(0,0)" "ntm_nested" [0, 0] ++ - runAgreement "ntm_nested(0,5)" "ntm_nested" [0, 5] ++ - runAgreement "ntm_nested(3,0)" "ntm_nested" [3, 0] ++ - runAgreement "ntm_large(0)" "ntm_large" [0] ++ - runAgreement "ntm_large(5)" "ntm_large" [5] ++ - runAgreement "ntm_shape_let" "ntm_shape_let" [] ++ - runAgreement "read_write_io" "read_write_io" [] - (io := { data := .ofList [(0, #[1, 2, 3, 4]), (1, #[5, 6, 7, 8])], - map := .ofList [((0, #[0]), ⟨0, 4⟩), ((1, #[0]), ⟨0, 4⟩)] }) ++ - runAgreement "template_basic" "template_basic" [] ++ - runAgreement "template_unwrap_some" "template_unwrap_some" [] ++ - runAgreement "template_unwrap_none" "template_unwrap_none" [] ++ - runAgreement "template_pair" "template_pair" [] ++ - runAgreement "template_nested" "template_nested" [] ++ - runAgreement "template_trans" "template_trans" [] ++ - runAgreement "template_multi" "template_multi" [] ++ - runAgreement "template_array" "template_array" [] ++ - runAgreement "template_tuple_arg" "template_tuple_arg" [] ++ - runAgreement "template_pointer_arg" "template_pointer_arg" [] ++ - runAgreement "template_chain" "template_chain" [] ++ - runAgreement "template_rec_list" "template_rec_list" [] ++ - runAgreement "template_rec_consumer" "template_rec_consumer" [] ++ - runAgreement "template_multi_rec" "template_multi_rec" [] ++ - runAgreement "template_tuple_match" "template_tuple_match" [] ++ - runAgreement "template_refutable_let" "template_refutable_let" [] ++ - runAgreement "template_pointer_pat" "template_pointer_pat" [] ++ - runAgreement "template_nested_rec" "template_nested_rec" [] ++ - runAgreement "template_mutual_rec" "template_mutual_rec" [] ++ - runAgreement "template_dual_args" "template_dual_args" [] ++ - runAgreement "template_unconstrained" "template_unconstrained" [] ++ - runAgreement "template_nested_refutable" "template_nested_refutable" [] ++ - runAgreement "template_simple_consumer" "template_simple_consumer" [] ++ - runAgreement "template_deep_nest" "template_deep_nest" [] ++ - -- Fibonacci (let-then-match style, distinct from `fib`) - runAgreement "fibonacci(0)" "fibonacci" [0] ++ - runAgreement "fibonacci(1)" "fibonacci" [1] ++ - runAgreement "fibonacci(6)" "fibonacci" [6] ++ - -- End-to-end non-tail match entry aggregating many ntm_* helpers - runAgreement "ntm_recursive_test" "ntm_recursive_test" [] ++ - runAgreement "non_tail_match" "non_tail_match" [] ++ - -- Inlined function calls (`@fn(args)`): all scenarios in one entry - runAgreement "inline_test" "inline_test" [] ++ - -- Unconstrained big-uint div/mod: all cases in one entry - runAgreement "divmod_test" "divmod_test" [] ++ - -- Unconstrained g_to_bytes / g_inverse hints: all cases in one entry - runAgreement "hint_test" "hint_test" [] ++ - -- Scope and effect-order regressions: compare values AND IO across engines. - runAgreement "hoist_guarded_operand(0)" "hoist_guarded_operand" [0] ++ - runAgreement "hoist_guarded_rhs(0)" "hoist_guarded_rhs" [0] ++ - runAgreement "hoist_guarded_return(0)" "hoist_guarded_return" [0] ++ - runAgreement "hoist_write_then_branch(7)" "hoist_write_then_branch" [7] ++ - runAgreement "hoist_metadata_then_branch(7)" "hoist_metadata_then_branch" [7] ++ - runAgreement "hoist_or_inline" "hoist_or_inline" [] ++ - runAgreement "hoist_assert_shadow(0)" "hoist_assert_shadow" [0] ++ - runAgreement "hoist_write_read(7)" "hoist_write_read" [7] ++ - runAgreement "hoist_set_get(7)" "hoist_set_get" [7] ++ - runAgreement "hoist_write_shadow(7)" "hoist_write_shadow" [7] ++ - runAgreement "hoist_rhs_shadow(9)" "hoist_rhs_shadow" [9] ++ - runAgreement "hoist_operand_shadow(9)" "hoist_operand_shadow" [9] ++ - runAgreement "hoist_array_shadow(9)" "hoist_array_shadow" [9] ++ - runAgreement "hoist_call_shadow(9)" "hoist_call_shadow" [9] ++ - runAgreement "hoist_match_shadow(9)" "hoist_match_shadow" [9] ++ - runAgreement "hoist_argument_order" "hoist_argument_order" [] ++ - runAgreement "hoist_argument_cores" "hoist_argument_cores" [] ++ - runAgreement "hoist_array_order" "hoist_array_order" [] ++ - runAgreement "hoist_inline_shadow(9)" "hoist_inline_shadow" [9] ++ - runAgreement "hoist_fresh_name(9)" "hoist_fresh_name" [9] ++ - runAgreement "hoist_inline_order" "hoist_inline_order" [] ++ - runAgreement "hoist_assert_argument_order" "hoist_assert_argument_order" [] ++ - runAgreement "hoist_io_argument_order" "hoist_io_argument_order" [] ++ - runAgreement "hoist_info_argument_order" "hoist_info_argument_order" [] ++ - runAgreement "hoist_allocation_order" "hoist_allocation_order" [] ++ - runAgreement "hoist_return_continuation(0)" "hoist_return_continuation" [0] ++ - runAgreement "hoist_lazy_arm(0)" "hoist_lazy_arm" [0] ++ - -- ----- Negative paths: every engine must reject -------------------------- - runFailureAgreement "hoist_guarded_operand(1) rejects" "hoist_guarded_operand" [1] ++ - runFailureAgreement "hoist_guarded_rhs(1) rejects" "hoist_guarded_rhs" [1] ++ - runFailureAgreement "hoist_guarded_return(1) rejects" "hoist_guarded_return" [1] ++ - runFailureAgreement "hoist_assert_shadow(1) rejects" "hoist_assert_shadow" [1] ++ - runFailureAgreement "hoist_return_continuation(1) rejects" "hoist_return_continuation" [1] ++ - runFailureAgreement "hoist_lazy_arm(1) rejects" "hoist_lazy_arm" [1] ++ - -- assert_eq! mismatch - runFailureAgreement "assert_same(7,8) rejects" "assert_same" [7, 8] ++ - -- u8_range_check out of range - runFailureAgreement "range_check_id(300,1) rejects" "range_check_id" [300, 1] ++ - -- Non-exhaustive match: 8 explicit branches, no default, scrutinee 9 - runFailureAgreement "ntm_large(9) rejects" "ntm_large" [9] ++ - -- io_get_info on a missing key (empty IO buffer) - runFailureAgreement "read_write_io missing key rejects" "read_write_io" [] ++ - -- io_read past the arena end: key registered with len 4, arena holds 2 - runFailureAgreement "read_write_io OOB read rejects" "read_write_io" [] - (io := { data := .ofList [(0, #[1, 2]), (1, #[5, 6, 7, 8])], - map := .ofList [((0, #[0]), ⟨0, 4⟩), ((1, #[0]), ⟨0, 4⟩)] }) - -end AiurTests.Cross - -end diff --git a/Tests/Aiur/Hashes.lean b/Tests/Aiur/Hashes.lean deleted file mode 100644 index f0bd2ab38..000000000 --- a/Tests/Aiur/Hashes.lean +++ /dev/null @@ -1,124 +0,0 @@ -module - -public import Tests.Aiur.Common -public import Ix.Aiur.Library.ByteStream -public import Ix.Aiur.Library.Blake3 -public import Ix.IxVM.Sha256 -public import Tests.Sha256 -public import Blake3.Rust - -/-! -The size sweeps exercise execution paths (padding, chunk/block -boundaries, tree parents); correctness per size is checked against the -Rust reference output by execution alone. Constraint and lookup coverage -saturates with one small and one multi-chunk proof per hash, so only the -`prove := true` sizes pay for prove+verify. --/ - -def mkBlake3HashTestCase (size : Nat) (prove : Bool := false) - (interp : Bool := false) : AiurTestCase := - let inputBytes := Array.range size |>.map Nat.toUInt8 - let outputBytes := Blake3.Rust.hash ⟨inputBytes⟩ |>.val.data - let input := inputBytes.map .ofUInt8 - let output := outputBytes.map .ofUInt8 - let buffer : Aiur.IOBuffer := - ⟨.ofList [(0, input)], .ofList [((0, #[0]), ⟨0, size⟩)]⟩ - -- channel 0; key fixed as #[0] - { functionName := `blake3_test, label := s!"blake3 (size={size})" - expectedOutput := output, inputIOBuffer := buffer, expectedIOBuffer := buffer - interpret := interp, withProof := prove } - -def mkSha256HashTestCase (size : Nat) (prove : Bool := false) - (interp : Bool := false) : AiurTestCase := - let inputBytes := Array.range size |>.map Nat.toUInt8 - let outputBytes := Sha256.hash ⟨inputBytes⟩ |>.data - let input := inputBytes.map .ofUInt8 - let output := outputBytes.map .ofUInt8 - let buffer : Aiur.IOBuffer := - ⟨.ofList [(0, input)], .ofList [((0, #[0]), ⟨0, size⟩)]⟩ - -- channel 0; key fixed as #[0] - { functionName := `sha256_test, label := s!"sha256 (size={size})" - expectedOutput := output, inputIOBuffer := buffer, expectedIOBuffer := buffer - interpret := interp, withProof := prove } - -/-- Resume the ordinary chunk loop after a checked prefix. This exercises -every byte's boundary checks without assuming a multiple-of-four offset. -/ -public def blake3BoundaryProgram := ⟦ - fn blake3_resume_seek(input: ByteStream, acc: ByteStream, offset: G) -> (ByteStream, ByteStream) { - match offset { - 0 => (input, acc), - _ => - let &ListNode.Cons(head, tail) = input; - blake3_resume_seek(tail, store(ListNode.Cons(head, acc)), offset - 1), - } - } - pub fn blake3_resume_test(offset: G) -> [[U8; 4]; 8] { - assert_eq!(u32_less_than(offset, 64), 1); - let (idx, len) = io_get_info(0, [0]); - let stream = read_checked_byte_stream(0, idx, len); - let (rest, acc) = blake3_resume_seek(stream, store(ListNode.Nil), offset); - let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]]; - blake3_compress_layer(blake3_compress_chunks(rest, acc, offset, offset, - store([0u8; 8]), store(IV), store(LayerNode.Nil))) - } -⟧ - -public def blake3ResumeTestCases : List AiurTestCase := - ([1, 2, 3, 4, 60, 61, 62, 63] : List Nat).flatMap fun offset => - [offset, offset + 1, offset + 2, offset + 3, 64, 65, 1023, 1024, 1025, 2049].map fun size => - let tc := mkBlake3HashTestCase size - { tc with - functionName := `blake3_resume_test, - label := s!"blake3 (size={size}, resume={offset})", - input := #[Aiur.G.ofNat offset] } - -public def blake3TestCases : List AiurTestCase := [ - -- prove: empty input (padding-only path) and a two-chunk input with a - -- parent node (chunk = 1024 bytes). interp: the two smallest sizes give - -- the interpreter real-program coverage at bounded cost. - mkBlake3HashTestCase 0 (prove := true) (interp := true), - mkBlake3HashTestCase 1 (interp := true), - mkBlake3HashTestCase 2 (interp := true), - mkBlake3HashTestCase 3 (interp := true), - mkBlake3HashTestCase 4 (interp := true), - mkBlake3HashTestCase 32 (interp := true), - mkBlake3HashTestCase 63, - mkBlake3HashTestCase 64, - mkBlake3HashTestCase 65, - mkBlake3HashTestCase 96, - mkBlake3HashTestCase 1023, - mkBlake3HashTestCase 1024, - mkBlake3HashTestCase 1025, - mkBlake3HashTestCase 1056, - mkBlake3HashTestCase 1088 (prove := true), - mkBlake3HashTestCase 1120, - mkBlake3HashTestCase 2048, - mkBlake3HashTestCase 2049, - mkBlake3HashTestCase 2080, - mkBlake3HashTestCase 2112, - mkBlake3HashTestCase 2144, - mkBlake3HashTestCase 3072, - mkBlake3HashTestCase 3073, - mkBlake3HashTestCase 3104, - mkBlake3HashTestCase 3136, - mkBlake3HashTestCase 3168, -] ++ blake3ResumeTestCases - -public def sha256TestCases : List AiurTestCase := [ - -- prove: empty input (padding-only path) and a two-block input whose - -- length spills past the first block (block = 64 bytes). interp: the two - -- smallest sizes give the interpreter real-program coverage at bounded cost. - mkSha256HashTestCase 0 (prove := true) (interp := true), - mkSha256HashTestCase 1 (interp := true), - mkSha256HashTestCase 14, - mkSha256HashTestCase 16, - mkSha256HashTestCase 17, - mkSha256HashTestCase 31, - mkSha256HashTestCase 32, - mkSha256HashTestCase 33, - mkSha256HashTestCase 63, - mkSha256HashTestCase 64, - mkSha256HashTestCase 65 (prove := true), - mkSha256HashTestCase 120, - mkSha256HashTestCase 1200, -] diff --git a/Tests/Aiur/IOBuffer.lean b/Tests/Aiur/IOBuffer.lean deleted file mode 100644 index 676f8eeb1..000000000 --- a/Tests/Aiur/IOBuffer.lean +++ /dev/null @@ -1,151 +0,0 @@ -module - -public import Ix.Aiur.Semantics.BytecodeFfi - -/-! The host advice-buffer append must preserve the old data and entry-map -representations as well as lookup behavior. These controls cover both a -consumed buffer and retained versions, without performance thresholds. --/ - -public section - -namespace AiurTests.IOBuffer - -private structure Append where - channel : Aiur.G - key : Array Aiur.G - payload : Array Aiur.G - -/-- Reference implementation before the ownership optimization. -/ -private def referenceExtend (buffer : Aiur.IOBuffer) (channel : Aiur.G) - (key payload : Array Aiur.G) : Aiur.IOBuffer := - let arena := buffer.data.getD channel #[] - let idx := arena.size - let len := payload.size - { buffer with - data := buffer.data.insert channel (arena ++ payload) - map := buffer.map.insert (channel, key) { idx, len } } - -private def need (label : String) (condition : Bool) : IO Unit := - unless condition do throw (IO.userError label) - -private def same (label : String) (actual expected : Aiur.IOBuffer) : IO Unit := do - need s!"{label}: buffer equality differs" (actual == expected) - need s!"{label}: data iteration or arena contents differ" - (actual.data.toArray == expected.data.toArray) - need s!"{label}: entry iteration or offsets differ" - (actual.map.toArray == expected.map.toArray) - -private def contents (buffer : Aiur.IOBuffer) (channel : Aiur.G) - (key : Array Aiur.G) : Option (Array Aiur.G) := do - let info ← buffer.map.get? (channel, key) - let arena ← buffer.data.get? channel - if info.idx + info.len > arena.size then none - else some (arena.extract info.idx (info.idx + info.len)) - -private def applyAll (extend : Aiur.IOBuffer → Aiur.G → Array Aiur.G → Array Aiur.G → Aiur.IOBuffer) - (initial : Aiur.IOBuffer) (ops : Array Append) : Aiur.IOBuffer := - ops.foldl (fun buffer op => extend buffer op.channel op.key op.payload) initial - -private def checkSequence (label : String) (initial : Aiur.IOBuffer) - (ops : Array Append) : IO Unit := do - -- No intermediate actual buffers survive this fold: exercise the uniquely - -- owned arena path in addition to the shared-history path below. - let final := applyAll Aiur.IOBuffer.extend initial ops - let expectedFinal := applyAll referenceExtend initial ops - same s!"{label}/consumed" final expectedFinal - let mut actual := initial - let mut expected := initial - let mut history : Array (Aiur.IOBuffer × Aiur.IOBuffer) := #[] - for h : index in [:ops.size] do - let op := ops[index] - history := history.push (actual, expected) - let before := actual.data.getD op.channel #[] - actual := actual.extend op.channel op.key op.payload - expected := referenceExtend expected op.channel op.key op.payload - same s!"{label}/step {index}" actual expected - need s!"{label}/step {index}: append changed the prior arena prefix" - (actual.data.get? op.channel == some (before ++ op.payload)) - need s!"{label}/step {index}: wrong offset or length" - (actual.map.get? (op.channel, op.key) == some { idx := before.size, len := op.payload.size }) - need s!"{label}/step {index}: key does not resolve to its latest payload" - (contents actual op.channel op.key == some op.payload) - same s!"{label}/retained result" actual final - for index in [:history.size] do - let (old, oldReference) := history[index]! - same s!"{label}/history {index}" old oldReference - let left := old.extend 0 #[101] #[102, 103] - let right := old.extend 1 #[] #[] - same s!"{label}/left branch {index}" left (referenceExtend oldReference 0 #[101] #[102, 103]) - same s!"{label}/right branch {index}" right (referenceExtend oldReference 1 #[] #[]) - same s!"{label}/history after branching {index}" old oldReference - -private def channelChecks : IO Unit := do - let ops : Array Append := #[ - { channel := 0, key := #[], payload := #[] }, - { channel := 1, key := #[7], payload := #[11, 12] }, - { channel := 2, key := #[7], payload := #[21] }, - { channel := 1, key := #[], payload := #[13, 14, 15] }, - { channel := 2, key := #[], payload := #[] }, - { channel := 1, key := #[7], payload := #[16] }, - { channel := 1, key := #[7], payload := #[] }, - { channel := 0, key := #[7], payload := #[31, 32] }] - checkSequence "channels, duplicate keys and empty payloads" default ops - let result := applyAll Aiur.IOBuffer.extend default ops - need "an empty first append must register its empty channel and key" - (contents result 0 #[] == some #[]) - need "duplicate-key replacement did not retain the appended bytes" - (result.data.get? 1 == some #[11, 12, 13, 14, 15, 16] && - result.map.get? (1, #[7]) == some { idx := 6, len := 0 }) - need "equal keys on different channels interfere" - (contents result 0 #[7] == some #[31, 32] && contents result 2 #[7] == some #[21]) - -private def collisionChecks : IO Unit := do - -- All these channels share their low eight hash bits, so they collide - -- throughout the small map's growth instead of relying on random keys. - let channels := Id.run do - let mut found : Array Aiur.G := #[] - for i in [:65536] do - let channel := Aiur.G.ofNat i - if hash channel &&& 255 == 0 then found := found.push channel - if found.size == 64 then break - return found - need "collision fixture did not find 64 distinct channels" (channels.size == 64) - need "collision fixture hash prefixes differ" (channels.all (fun ch => hash ch &&& 255 == 0)) - let ops := Id.run do - let mut result : Array Append := #[] - for round in [:3] do - for i in [:channels.size] do - let channel := channels[(17 * i + round) % channels.size]?.getD 0 - let key := if round == 2 then #[] else #[7] - let payload := if round == 1 && i % 5 == 0 then #[] - else #[Aiur.G.ofNat round, Aiur.G.ofNat i] - result := result.push { channel, key, payload } - return result - checkSequence "colliding channels and map growth" default ops - -private def sharingChecks : IO Unit := do - let initial := Aiur.IOBuffer.ofArrays #[(5, #[10, 20]), (8, #[])] #[] - let initialOrder ← IO.lazyPure fun _ => initial.data.toArray - let arena := initial.data.getD 5 #[] - let ops : Array Append := #[ - { channel := 5, key := arena, payload := arena }, - { channel := 8, key := arena, payload := arena }, - { channel := 5, key := #[1], payload := #[] }, - { channel := 8, key := arena, payload := #[30] }] - checkSequence "arena shared with keys, payloads and historical buffers" initial ops - need "append mutated its caller's retained input arena" - (arena == #[10, 20] && initial.data.toArray == initialOrder && - initial.data.get? 5 == some #[10, 20] && initial.data.get? 8 == some #[] && - initial.map.isEmpty) - -def runSuite : IO UInt32 := do - channelChecks - collisionChecks - sharingChecks - IO.println "IOBuffer append reference, collision and persistence controls PASS" - return 0 - -end AiurTests.IOBuffer - -end diff --git a/Tests/Aiur/RBTreeMap.lean b/Tests/Aiur/RBTreeMap.lean deleted file mode 100644 index 488b3fc77..000000000 --- a/Tests/Aiur/RBTreeMap.lean +++ /dev/null @@ -1,22 +0,0 @@ -module - -public import Tests.Aiur.Common -public import Ix.IxVM.RBTreeMap - -public section - -public def rbTreeMapTestCases : List AiurTestCase := [ - -- Data-structure logic test: asserts insert/lookup outputs. The - -- constraint machinery it compiles to (match, load/store, compares) is - -- proven by the `aiur-prove` suite, so execute + interpret is the whole - -- signal here. - .interp `rbtree_map_test #[] #[ - 42, - 50, 100, 200, - 999, - 10, 20, 30, 40, 50, - 10, 20, 30, 40, 50, - 200, 300, 400, 500, 600, 700, 800], -] - -end diff --git a/Tests/Aiur/RustSyntax.lean b/Tests/Aiur/RustSyntax.lean deleted file mode 100644 index 0b318a660..000000000 --- a/Tests/Aiur/RustSyntax.lean +++ /dev/null @@ -1,108 +0,0 @@ -module -public import Ix.Aiur.Stages.Codegen - -public section -namespace AiurTests.RustSyntax -open Aiur.Codegen - -private def assertEq (actual expected : RustExpr) : RustStmt := - .exprStmt (.macroCall "assert_eq" #[actual, expected]) - -private def debugLabel : String := "debug {} quote: \" slash: \\ newline:\nλ" - -/-- Compile and execute the rendered tree rather than asserting source-text - snapshots. Covers precedence, escaping, block values, guarded patterns, - closures, const parameters, and early return through a closure. -/ -private def program : Array RustItem := Id.run do - let text := "quote: \" slash: \\ newline:\n\r\t\x00 braces: {} unicode: λ" - let bytes : Array RustExpr := text.toUTF8.data.map (fun b => .nat b.toNat) - let guardedMatch (value : Nat) : RustExpr := .matchExpr (.call (.var "Some") #[.nat value]) #[ - { pat := .constructor #["Some"] #[.binding "x"] - guard := some (.binop .lt (.var "x") (.nat 10)) - body := { tail := some (.var "x") } }, - { pat := .wildcard, body := { tail := some (.nat 99) } }] - let closure : RustExpr := .closure #[.binding "x"] (.binop .add (.var "x") (.nat 1)) - let labelValue : RustExpr := .labeledBlock "value" { - stmts := #[.forStmt (.binding "x") (.arrayLit #[.nat 4, .nat 5]) #[ - .ifStmt (.binop .eq (.var "x") (.nat 5)) - #[.breakWith "value" (.var "x")] none]] - tail := some (.nat 0) } - let resultTy : RustType := .app "Result" #[.named "u64", .named "u64"] - let earlyReturn : RustItem := .function { - name := "early_return" - params := #[("fail", .named "bool")] - returnTy := resultTy - body := { stmts := #[ - .letStmt false "result" (some resultTy) (.call (.closure #[] (.block { - stmts := #[ - .ifStmt (.var "fail") #[.returnStmt (.call (.var "Err") #[.nat 13])] none, - .returnStmt (.call (.var "Ok") #[.nat 9])] - })) #[]), - .letStmt false "answer" none (.tryExpr (.var "result")), - .returnStmt (.call (.var "Ok") #[.var "answer"]) - ] } } - let choose : RustItem := .function { - name := "choose" - constParams := #[("MODE", .named "bool")] - params := #[] - returnTy := .named "u64" - body := { tail := some (.ifExpr (.var "MODE") - { tail := some (.nat 3) } { tail := some (.nat 8) }) } } - let main : RustItem := .function { - name := "main", params := #[], returnTy := .tuple #[] - body := { stmts := (#[ - assertEq (.methodCall (.string text) "as_bytes" #[]) (.ref (.arrayLit bytes)), - assertEq (.binop .mul (.binop .add (.nat 2) (.nat 3)) (.nat 4)) (.nat 20), - assertEq (.call closure #[.nat 4]) (.nat 5), - assertEq (guardedMatch 7) (.nat 7), - assertEq (guardedMatch 17) (.nat 99), - assertEq labelValue (.nat 5), - assertEq (.call (.constGeneric (.var "choose") #[.bool true]) #[]) (.nat 3), - assertEq (.call (.constGeneric (.var "choose") #[.bool false]) #[]) (.nat 8), - assertEq (.call (.var "early_return") #[.bool false]) (.call (.var "Ok") #[.nat 9]), - assertEq (.call (.var "early_return") #[.bool true]) (.call (.var "Err") #[.nat 13]), - .letStmt false "pair" none (.tuple #[.nat 6]), - assertEq (.field (.var "pair") "0") (.nat 6), - .letStmt false "values" (some (.array (.named "u64") (.value 2))) - (.arrayLit #[.nat 11, .nat 12]), - .letStmt false "ptr" none - (.cast (.ref (.var "values")) (.ptr false (.array (.named "u64") (.value 2)))), - assertEq (.index (.unsafeBlock { tail := some (.deref (.var "ptr")) }) (.nat 1)) (.nat 12), - assertEq (.index (.ref (.var "values")) (.nat 0)) (.nat 11), - assertEq (.methodCall (.ref (.var "values")) "len" #[]) (.nat 2), - .letStmt false "callbacks" none (.tuple #[closure]), - assertEq (.call (.field (.var "callbacks") "0") #[.nat 4]) (.nat 5), - assertEq (.field (.ifExpr (.bool true) { tail := some (.tuple #[.nat 2]) } - { tail := some (.tuple #[.nat 3]) }) "0") (.nat 2), - .letStmt false "__v_0" (some (.named "u64")) (.nat 41), - .letStmt false "__v_1" (some (.named "u64")) (.nat 7) - ] ++ emitOp 0 (.debug debugLabel none) ++ - emitOp 0 (.debug debugLabel (some #[])) ++ - emitOp 0 (.debug debugLabel (some #[0, 1]))) } } - return #[earlyReturn, choose, main] - -def run : IO UInt32 := IO.FS.withTempDir fun dir => do - let source := dir / "syntax.rs" - let binary := dir / "syntax-test" - IO.FS.writeFile source (String.join (program.toList.map RustItem.toStr)) - let compile ← IO.Process.output { - cmd := "rustc" - args := #["--edition=2024", "--crate-name", "aiur_syntax_test", source.toString, - "-o", binary.toString] - } - if compile.exitCode != 0 then - IO.eprintln s!"Rust syntax test failed to compile:\n{compile.stderr}" - return 1 - let result ← IO.Process.output { cmd := binary.toString } - if result.exitCode != 0 then - IO.eprintln s!"Rust syntax test failed at runtime:\n{result.stderr}" - return 1 - let expectedOutput := debugLabel ++ "\n" ++ debugLabel ++ ": \n" ++ debugLabel ++ ": 41, 7\n" - if result.stdout != expectedOutput then - IO.eprintln s!"Generated debug operation printed unexpected output: {repr result.stdout}" - return 1 - IO.println "aiur-rust-syntax: generated Rust compiled and all runtime assertions passed" - return 0 - -end AiurTests.RustSyntax -end diff --git a/Tests/Aiur/TraceCodegen.lean b/Tests/Aiur/TraceCodegen.lean deleted file mode 100644 index c0978222c..000000000 --- a/Tests/Aiur/TraceCodegen.lean +++ /dev/null @@ -1,172 +0,0 @@ -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 deleted file mode 100644 index c0e42e0d9..000000000 --- a/Tests/Aiur/TraceFixtures.lean +++ /dev/null @@ -1,43 +0,0 @@ -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 deleted file mode 100644 index cbf85d018..000000000 --- a/Tests/Aiur/TracePlan.lean +++ /dev/null @@ -1,355 +0,0 @@ -module - -public import LSpec -public import Ix.Aiur.Stages.TracePlan - -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" - (singletonProgram #[returnedCall, identityFunction]) (fun plan => - plan.seedWords == 3 && plan.preparationOperations == #[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] } - - -def tests : TestSeq := allocationTests ++ preparationTests ++ schemaTests ++ - malformedTests ++ groupingTests - -end AiurTests.TracePlan - -end diff --git a/Tests/CompressionCli.lean b/Tests/CompressionCli.lean index d35c82721..ea62f9d1f 100644 --- a/Tests/CompressionCli.lean +++ b/Tests/CompressionCli.lean @@ -39,11 +39,13 @@ public def run : IO Unit := do let help ← invoke home #["compress", "--help"] unless help.exitCode == 0 && (help.stdout.splitOn "--root-vk").length > 1 do throw <| IO.userError s!"compress help failed: {help.stdout} {help.stderr}" - let claim := Ix.Claim.checkEnv default (Address.blake3 "test".toUTF8) none + let testHash := Address.blake3 "test".toUTF8 + let ctx : Ix.ClaimContext := { spec := testHash, binding := testHash, axioms := none } + let claim := Ix.Claim.checkEnv ctx testHash none let native : Ixon.Proof := { claim, proof := "native".toUTF8 } let compressed : Ixon.Proof := { claim, proof := "IXCMP".toUTF8 } let other : Ixon.Proof := - { claim := Ix.Claim.check default (Address.blake3 "test".toUTF8) none, proof := "native".toUTF8 } + { claim := Ix.Claim.check ctx testHash none, proof := "native".toUTF8 } let old ← putProof home (Ixon.Proof.ser native) let addr ← putProof home (Ixon.Proof.ser compressed) let otherAddr ← putProof home (Ixon.Proof.ser other) diff --git a/Tests/FormalAggregate.lean b/Tests/FormalAggregate.lean new file mode 100644 index 000000000..ccd3a6a63 --- /dev/null +++ b/Tests/FormalAggregate.lean @@ -0,0 +1,154 @@ +import Ix.Cli.FormalAggregate + +/-! Execute all thirteen aggregation shapes against small real STARK children. +The stand-in keys deliberately accept arbitrary digests; only the production +aggregator's bindings and fold relation are under test. -/ +open Lean Aggr Ix.Cli Ix.Cli.FormalAggregate + +private def fixture (dir : System.FilePath) (args : Array Aiur.G) : IO Unit := do + IO.FS.withTempFile fun h path => do + h.putStr (toJson (args.map (·.n))).compress + h.flush + FormalAiur.command "target/release/examples/claim_fixture" #[path.toString, dir.toString] + +private def node (ctx : Context) (dir : System.FilePath) (kind : ChildKind) + (statement : CheckEnvTrees) : IO Node := do + let input := (outerClaim ctx kind statement.claim).extract 2 18 + fixture dir input + let magic := (if kind == .ixvm then "IXAIUR2\x00" else "IXAGGR2\x00").toUTF8 + let proof ← IO.FS.readBinFile (dir / "proof.bin") + return { kind, statement, wrapper := { claim := statement.claim, proof := magic ++ proof } } + +private def test (ctx : Context) (label : String) (bytes : ByteArray) (io : Aiur.IOBuffer) + (accept : Bool := true) : Json := + Json.mkObj [("label", toJson label), ("accept", toJson accept), + ("invocation", FormalAiur.invocation (pubInput ctx.allowed bytes) io "MultiStark::ix_aggr")] + +def main (args : List String) : IO Unit := do + let started ← IO.mkRef false + let completed ← IO.mkRef false + let failed ← try + let _ ← FormalAiur.boundedMap 2 #[false, true] fun _ sibling => do + if sibling then + started.set true + IO.sleep 30 + completed.set true + else + while !(← started.get) do IO.sleep 1 + throw (IO.userError "intentional scheduler failure") + pure false + catch _ => pure true + unless failed && (← completed.get) do + throw (IO.userError "failed scheduler returned before its admitted peer finished") + let reservation : FormalAiur.HostOptions := { ram := 1024, threads := 4 } + unless (reservation.forWave 2 1).ram == 2048 && (reservation.forWave 2 2).threads == 4 do + throw (IO.userError "partial waves lost their RAM/CPU reservations") + let schedule ← IO.ofExcept (Reference.schedulePlan + #[.leaf 0, .leaf 1, .join 0 1, .leaf 2, .join 2 3] #[2, 3, 4] 4096) + unless (← IO.ofExcept (neededSlots schedule 2)) == #[true, true, true, false, false] do + throw (IO.userError "subtree scheduling escaped its dependency closure") + if (neededSlots schedule 5).toOption.isSome then + throw (IO.userError "out-of-range subtree was accepted") + let path := args.headD "/tmp/ix-formal-aggregate-cases.json" + IO.FS.withTempDir fun dir => do + fixture (dir / "ixvm") (Array.replicate 8 0) + fixture (dir / "self") (Array.replicate 16 0) + let ixvmKey ← IO.FS.readBinFile (dir / "ixvm" / "key.bin") + let aggrKey ← IO.FS.readBinFile (dir / "self" / "key.bin") + let ctx : Context := { + ixvmArtifact := "" + aggrArtifact := "" + ixvm := ⟨ixvmKey, 0⟩ + aggr := ⟨aggrKey, 0⟩ + allowed := allowedBlob ixvmKey 0 aggrKey 0 } + let a := Address.blake3 "formal-a".toUTF8 + let b := Address.blake3 "formal-b".toUTF8 + let c := Address.blake3 "formal-c".toUTF8 + let d := Address.blake3 "formal-d".toUTF8 + let tree (xs : Array Address) := (Ix.AssumptionTree.canonical xs).get! + let claimCtx ← IO.ofExcept Ix.ClaimContext.ofDefaultTable + let left : CheckEnvTrees := { ctx := claimCtx, subjects := tree #[a, b], assumptions := some (tree #[c, d]) } + let right : CheckEnvTrees := { ctx := claimCtx, subjects := tree #[c], assumptions := some (tree #[a]) } + let li ← node ctx (dir / "li") .ixvm left + let ri ← node ctx (dir / "ri") .ixvm right + let la ← node ctx (dir / "la") .aggr left + let ra ← node ctx (dir / "ra") .aggr right + let bytes := Ix.Claim.ser left.claim + let mut tests : Array Json := #[] + for n in #[li, la] do + tests := tests.push (test ctx s!"wrap {n.kind.code}" bytes (← advice ctx n none left false)) + for l in #[li, la] do + for r in #[ri, ra] do + for structural in #[false, true] do + let output := if structural then left.joinStructural right else left.join right + let shape := if structural then structuralShapeCode l.kind r.kind else shapeCode (l.kind, some r.kind) + let io ← advice ctx l (some r) output structural + tests := tests.push (test ctx s!"pair shape {shape}" (Ix.Claim.ser output.claim) io) + let dropped := { output with assumptions := none } + tests := tests.push (test ctx s!"shape {shape} rejects dropped assumption" + (Ix.Claim.ser dropped.claim) (extendOutputClaim io (Ix.Claim.ser dropped.claim)) false) + -- No child assumes its own subject, the children's subjects are disjoint, + -- and a structural join discharges an assumption only against the other + -- child's subjects. `advice` derives trees and paths without these checks. + let selfA : CheckEnvTrees := { ctx := claimCtx, subjects := tree #[a], assumptions := some (tree #[a]) } + let leftB : CheckEnvTrees := { ctx := claimCtx, subjects := tree #[a, b], assumptions := some (tree #[b, c]) } + let qi ← node ctx (dir / "q") .ixvm selfA + let lbi ← node ctx (dir / "lb") .ixvm leftB + let selfJoins : Array (String × Node × Node × CheckEnvTrees × Bool) := #[ + ("flat pair rejects duplicated self-assuming children", qi, qi, + { ctx := claimCtx, subjects := tree #[a], assumptions := none }, false), + ("flat pair rejects a child that assumes its own subject", qi, ri, + { ctx := claimCtx, subjects := tree #[a, c], assumptions := none }, false), + ("flat pair rejects overlapping subject sets", li, li, left, false), + ("structural pair rejects duplicated self-assuming children", qi, qi, + { ctx := claimCtx, subjects := .join selfA.subjects selfA.subjects, assumptions := none }, true), + ("structural pair rejects discharging an assumption against its own subjects", lbi, ri, + { ctx := claimCtx, subjects := .join leftB.subjects right.subjects, assumptions := none }, true)] + for (label, l, r, output, structural) in selfJoins do + tests := tests.push (test ctx label (Ix.Claim.ser output.claim) + (← advice ctx l (some r) output structural) false) + let wrap ← advice ctx li none left false + tests := tests.push (test ctx "wrong output digest" (Ix.Claim.ser right.claim) wrap false) + tests := tests.push (test ctx "wrong child kind" bytes (extendIdentity wrap ctx.allowed 1) false) + tests := tests.push (test ctx "invalid shape" bytes (extendIdentity wrap ctx.allowed 17) false) + let badIdentity := ctx.allowed.set! 0 (ctx.allowed.data[0]! ^^^ 1) + tests := tests.push (test ctx "wrong allowed identity" bytes (extendIdentity wrap badIdentity 0) false) + let corrupt := li.wrapper.proof.extract 8 li.wrapper.proof.size + let corrupt := corrupt.extract 0 (corrupt.size - 1) + let io := extendChild wrap 0 corrupt (MultiStark.serializeClaims #[outerClaim ctx .ixvm left.claim]) + tests := tests.push (test ctx "truncated child proof" bytes io false) + -- Range leaves bind the preamble, exact interval, and residual. + let preamble ← IO.FS.readBinFile (dir / "li" / "preamble.bin") + let full ← IO.FS.readBinFile (dir / "li" / "statement-1.bin") + let empty ← IO.FS.readBinFile (dir / "li" / "statement-0.bin") + for (hi, statement) in #[(0, empty), (1, full)] do + let io := extendVk (extendIdentity default ctx.allowed 10) .ixvm ctx.ixvm.key + let io := extendChild io 0 preamble ByteArray.empty + let io := extendChild io 1 (← IO.FS.readBinFile (dir / "li" / s!"range-{hi}.bin")) ByteArray.empty + let io := extendOutputClaim io statement + tests := tests.push (test ctx s!"range leaf {hi}" statement io) + let bad := statement.set! 49 (statement.data[49]! ^^^ 1) + tests := tests.push (test ctx s!"range leaf {hi} rejects false residual" bad (extendOutputClaim io bad) false) + -- Stand-in self proofs have exactly the public statement a range node emits. + fixture (dir / "empty") (pubInput ctx.allowed empty) + fixture (dir / "full") (pubInput ctx.allowed full) + let addRange (io : Aiur.IOBuffer) (slot : Nat) (name : String) (stmt : ByteArray) : IO Aiur.IOBuffer := do + let io := extendVk io .aggr ctx.aggr.key + let io := extendChild io slot (← IO.FS.readBinFile (dir / name / "proof.bin")) + (← IO.FS.readBinFile (dir / name / "claims.bin")) + return extendPreimage io stmt + let io ← addRange (extendIdentity default ctx.allowed 11) 0 "empty" empty + let io ← addRange io 1 "full" full + tests := tests.push (test ctx "range join" full (extendOutputClaim io full)) + let bad := full.set! 49 (full.data[49]! ^^^ 1) + tests := tests.push (test ctx "range join rejects wrong sum" bad (extendOutputClaim io bad) false) + let io ← addRange (extendIdentity default ctx.allowed 12) 0 "full" full + let io := extendVk (extendChild io 1 preamble ByteArray.empty) .ixvm ctx.ixvm.key + tests := tests.push (test ctx "range root" bytes io) + tests := tests.push (test ctx "range root rejects wrong claim" (Ix.Claim.ser right.claim) io false) + let io ← addRange (extendIdentity default ctx.allowed 12) 0 "empty" empty + let io := extendVk (extendChild io 1 preamble ByteArray.empty) .ixvm ctx.ixvm.key + tests := tests.push (test ctx "range root rejects incomplete batch" bytes io false) + IO.FS.writeFile path (toJson tests).compress + IO.FS.writeFile (path ++ ".wrap.json") (FormalAiur.invocation (pubInput ctx.allowed bytes) wrap "MultiStark::ix_aggr").compress + IO.println s!"Wrote {tests.size} aggregation cases, including every shape and negative bindings" diff --git a/Tests/FormalAiur.lean b/Tests/FormalAiur.lean new file mode 100644 index 000000000..fdd2413f5 --- /dev/null +++ b/Tests/FormalAiur.lean @@ -0,0 +1,193 @@ +import Ix.Cli.FormalAiur +import Ix.IxVM.ClaimHarness + +/-! Real claim fixtures, plus independently specified evaluation inputs. +Run through the Rust host. -/ +open Lean IxVM.ClaimHarness + +private def caseJson (label : String) (w : ClaimWitness) (accept : Bool := true) : Json := + Json.mkObj [("label", toJson label), ("accept", toJson accept), + ("invocation", Ix.Cli.FormalAiur.invocation w.input w.inputIOBuffer)] + +private def evalCases : Except String (Array Json) := do + let ty : Ixon.Expr := .leanAll (.sort 0) (.leanAll (.var 0) (.var 1)) + let value : Ixon.Expr := .leanLam (.sort 0) (.leanLam (.var 0) (.var 0)) + let beta : Ixon.Expr := .app (.leanLam ty (.var 0)) value + let constant v : Ixon.Constant := ⟨.defn ⟨.defn, .safe, 0, ty, v⟩, #[], #[], #[.zero]⟩ + let input := constant beta + let output := constant value + let ia := Address.blake3 (Ixon.ser input) + let oa := Address.blake3 (Ixon.ser output) + let env := ({} : Ixon.Env).storeConst ia input |>.storeConst oa output + let env := { env with anonHints := env.anonHints.insert ia (.regular 0) |>.insert oa (.regular 0) } + let ctx ← Ix.ClaimContext.ofDefaultTable + let good ← buildClaimWitness env (.eval ctx ia oa none) + let unreduced ← buildClaimWitness env (.eval ctx ia ia none) + return #[caseJson "Eval beta normal form" good, + caseJson "Eval rejects an unreduced claimed result" unreduced false] + +/-- Small, dependency-bearing environment for the orchestration gate. This +exercises real IxVM checking and cross-record calls without importing Init. -/ +private def controllerEnv : Ixon.Env := Id.run do + let ty : Ixon.Expr := .leanAll (.sort 0) (.leanAll (.var 0) (.var 1)) + let value : Ixon.Expr := .leanLam (.sort 0) (.leanLam (.var 0) (.var 0)) + let mut env : Ixon.Env := {} + let mut prior : Option Address := none + for i in [:3] do + let body := if i == 0 then value else if i == 1 then .ref 0 #[] + else .app (.leanLam ty (.var 0)) (.ref 0 #[]) + let c : Ixon.Constant := ⟨.defn ⟨.defn, .safe, 0, ty, body⟩, + #[], prior.toArray, #[.zero]⟩ + let addr := Address.blake3 (Ixon.ser c) + env := env.storeConst addr c + env := { env with anonHints := env.anonHints.insert addr (.regular 0) } + prior := some addr + let emptyTable : Ix.Kernel.RoleTable := { version := Ix.Kernel.specVersion, bound := #[], evidence := #[] } + let bytes := emptyTable.toBytes + return { env with roleBinding := some { address := Address.blake3 bytes, bytes } } + +private def findConstWithOrThrow (ixonEnv : Ixon.Env) (label : String) + (pred : Ixon.ConstantInfo → Bool) : IO (Address × Ixon.ConstantInfo) := do + for (addr, lc) in ixonEnv.consts do + if let some c := lc.get? then + if pred c.info then return (addr, c.info) + throw <| IO.userError s!"no {label} const found in shared smoke env" + +private def singletonTrees (tree : Ix.AssumptionTree) : + Std.HashMap Address Ix.AssumptionTree := + ({} : Std.HashMap _ _).insert tree.root tree + +/-- No claim assumes its own subject, and a `CheckEnv` claim owns at least one +constant. Each case pairs the ill-typed `Prop : Prop` with an assumption tree +that would let the circuit skip checking it; the control shows the circuit +rejects it when it is checked. -/ +private def assumptionCases : Except String (Array Json) := do + let prop : Ixon.Expr := .sort 0 + let bad : Ixon.Constant := ⟨.defn ⟨.defn, .safe, 0, prop, prop⟩, #[], #[], #[.zero]⟩ + let ba := Address.blake3 (Ixon.ser bad) + let env := ({} : Ixon.Env).storeConst ba bad + let env := { env with anonHints := env.anonHints.insert ba (.regular 0) } + let ctx ← Ix.ClaimContext.ofDefaultTable + let some self := Ix.AssumptionTree.canonical #[ba] + | .error "assumptionCases: no tree for the ill-typed constant" + let empty : Ix.AssumptionTree := .node .padding .padding + let control ← buildClaimWitness env (.check ctx ba none) + let selfCheck ← buildClaimWitness env (.check ctx ba (some self.root)) (singletonTrees self) + let selfEnv ← buildClaimWitness env (.checkEnv ctx self.root (some self.root)) + (singletonTrees self) + let emptyEnv ← buildClaimWitness env (.checkEnv ctx empty.root none) (singletonTrees empty) + return #[caseJson "Check rejects the ill-typed constant (control)" control false, + caseJson "Check rejects a target in its own assumption set" selfCheck false, + caseJson "CheckEnv rejects an owned subject in its own assumption set" selfEnv false, + caseJson "CheckEnv rejects an owned tree with no leaves" emptyEnv false] + +private def claimCheckWithAsm (ixonEnv : Ixon.Env) : IO (String × ClaimWitness) := do + let target ← lookupAddr ixonEnv ``Nat.zero + let closure := closureFrom ixonEnv target + let depLeaves : Array Address := + closure.fold (init := #[]) fun acc a => + if a == target then acc else acc.push a + let some tree := Ix.AssumptionTree.canonical depLeaves + | throw <| IO.userError "deps unexpectedly empty for Nat.zero" + let witness ← IO.ofExcept <| buildClaimWitness ixonEnv + (Ix.Claim.check (← IO.ofExcept (Ix.ClaimContext.ofEnv ixonEnv)) target (some tree.root)) + (singletonTrees tree) + pure ("Claim Check with-asm (Nat.zero)", witness) + +private def claimCheckEnvFull (ixonEnv : Ixon.Env) : IO (String × ClaimWitness) := do + let some tree := envCanonicalTree ixonEnv + | throw <| IO.userError "envCanonicalTree empty" + let witness ← IO.ofExcept <| buildClaimWitness ixonEnv + (Ix.Claim.checkEnv (← IO.ofExcept (Ix.ClaimContext.ofEnv ixonEnv)) tree.root none) + (singletonTrees tree) + pure ("CheckEnv self-contained (shared smoke env)", witness) + +private def claimCheckEnvFrontier (ixonEnv : Ixon.Env) : IO (String × ClaimWitness) := do + let target ← lookupAddr ixonEnv ``Nat.add_comm + let some c := ixonEnv.getConst? target + | throw <| IO.userError "Nat.add_comm constant missing" + let some ownedTree := Ix.AssumptionTree.canonical #[target] + | throw <| IO.userError "owned tree build failed" + let some asmTree := Ix.AssumptionTree.canonical c.refs + | throw <| IO.userError "asm (frontier) tree build failed" + let trees := (singletonTrees ownedTree).insert asmTree.root asmTree + let witness ← IO.ofExcept <| buildClaimWitness ixonEnv + (Ix.Claim.checkEnv (← IO.ofExcept (Ix.ClaimContext.ofEnv ixonEnv)) ownedTree.root + (some asmTree.root)) trees + pure ("CheckEnv frontier-asm (Nat.add_comm)", witness) + +private def claimRevealDefnFields (ixonEnv : Ixon.Env) : IO (String × ClaimWitness) := do + let (comm, info) ← findConstWithOrThrow ixonEnv "Defn" + fun ci => match ci with | .defn _ => true | _ => false + let .defn d := info + | throw <| IO.userError "findConstWith returned non-Defn" + let revealInfo : Ix.RevealConstantInfo := + .defn (some d.kind) (some d.safety) none none none + let witness ← IO.ofExcept <| buildClaimWitness ixonEnv + (Ix.Claim.reveal comm revealInfo) {} + pure ("Claim Reveal Defn (kind+safety)", witness) + +private def claimRevealDefnExpr (ixonEnv : Ixon.Env) : IO (String × ClaimWitness) := do + let (comm, info) ← findConstWithOrThrow ixonEnv "Defn" + fun ci => match ci with | .defn _ => true | _ => false + let .defn d := info + | throw <| IO.userError "findConstWith returned non-Defn" + let typAddr := Address.blake3 (Ixon.runPut (Ixon.putExpr d.typ)) + let revealInfo : Ix.RevealConstantInfo := + .defn none none none (some typAddr) none + let witness ← IO.ofExcept <| buildClaimWitness ixonEnv + (Ix.Claim.reveal comm revealInfo) {} + pure ("Claim Reveal Defn (typ Expr addr)", witness) + +private def claimRevealBinderModes : IO (String × ClaimWitness) := do + let typ : Ixon.Expr := + .all .linear .unique (.sort 0) + (.lam .affine (.sort 0) + (.all .erased .shared (.sort 0) (.var 0))) + let c : Ixon.Constant := + ⟨.axio ⟨false, 0, typ⟩, #[], #[], #[.zero]⟩ + let addr := Address.blake3 (Ixon.ser c) + let ixonEnv := ({} : Ixon.Env).storeConst addr c + let typAddr := Address.blake3 (Ixon.runPut (Ixon.putExpr typ)) + let witness ← IO.ofExcept <| buildClaimWitness ixonEnv + (Ix.Claim.reveal addr (.axio none none (some typAddr))) {} + pure ("Claim Reveal Expr (v3 binder modes)", witness) + +private def claimRevealCPrj (ixonEnv : Ixon.Env) : IO (String × ClaimWitness) := do + let (comm, info) ← findConstWithOrThrow ixonEnv "CPrj" + fun ci => match ci with | .cPrj _ => true | _ => false + let .cPrj p := info + | throw <| IO.userError "findConstWith returned non-CPrj" + let revealInfo : Ix.RevealConstantInfo := + .cPrj (some p.idx) (some p.cidx) (some p.block) + let witness ← IO.ofExcept <| buildClaimWitness ixonEnv + (Ix.Claim.reveal comm revealInfo) {} + pure ("Claim Reveal CPrj (all fields)", witness) + +private def claimContains : IO (String × ClaimWitness) := do + let a : Address := ⟨⟨Array.replicate 32 0x11⟩⟩ + let b : Address := ⟨⟨Array.replicate 32 0x22⟩⟩ + let c : Address := ⟨⟨Array.replicate 32 0x33⟩⟩ + let some tree := Ix.AssumptionTree.canonical #[a, b, c] + | throw <| IO.userError "Contains tree build failed" + let witness ← IO.ofExcept <| buildClaimWitness ({} : Ixon.Env) + (Ix.Claim.contains tree.root b) (singletonTrees tree) + pure ("Claim Contains (synthetic 3-leaf)", witness) + +def main (args : List String) : IO Unit := do + let path := args.headD "/tmp/ix-formal-claims.json" + let env ← get_env! + let fixture ← loadIxonEnv ``Nat.add_comm env + IO.FS.writeBinFile (path ++ ".ixe") (← IO.ofExcept (Ixon.serEnv fixture)) + IO.FS.writeBinFile (path ++ ".controller.ixe") (← IO.ofExcept (Ixon.serEnv controllerEnv)) + let mut cases := (← IO.ofExcept evalCases) ++ (← IO.ofExcept assumptionCases) + for build in [claimCheckWithAsm, + claimCheckEnvFull, claimCheckEnvFrontier, + claimRevealDefnFields, claimRevealDefnExpr, + claimRevealCPrj] do + let (label, witness) ← build fixture + cases := cases.push (caseJson label witness) + for (label, witness) in [← claimContains, ← claimRevealBinderModes] do + cases := cases.push (caseJson label witness) + IO.FS.writeFile path (toJson cases).compress + IO.println s!"Wrote {cases.size} production claim cases and .ixe fixture to {path}" diff --git a/Tests/Ix/BenchMeasures.lean b/Tests/Ix/BenchMeasures.lean index 7aeaa14a7..c3211ab09 100644 --- a/Tests/Ix/BenchMeasures.lean +++ b/Tests/Ix/BenchMeasures.lean @@ -64,7 +64,7 @@ def testJoinReport : TestSeq := Id.run do let joinSection := scopeAiurSection names { heading := "Aggregate flat join", metrics := #["join-prove-time"] } let ixvmSection := scopeAiurSection names - { heading := "IxVM on FRI", metrics := #["ixvm-prove-time"] } + { heading := "LegacyIxVM on FRI", metrics := #["ixvm-prove-time"] } let rows := Lean.Json.mkObj [ ("Nat.add_comm", Lean.Json.mkObj [("ixvm-prove-time", Lean.toJson (1 : Nat))]), (pair, Lean.Json.mkObj [("status", Lean.Json.str "oom")])] diff --git a/Tests/Ix/Compile/ValidateAux.lean b/Tests/Ix/Compile/ValidateAux.lean index c19ad366d..f105cd726 100644 --- a/Tests/Ix/Compile/ValidateAux.lean +++ b/Tests/Ix/Compile/ValidateAux.lean @@ -9,6 +9,7 @@ import Ix.Meta import Tests.Ix.Compile.Mutual import Tests.Ix.Compile.Canonicity import Tests.Ix.Compile.LevelSpellings +import Tests.Ix.IxVMFixtures import Tests.Ix.Kernel.TutorialDefs import Lean @@ -72,7 +73,7 @@ def validateAuxClosure (env : Lean.Environment) -- Level-spelling fixtures (canonicity §10.6): mk*-reducible spellings -- per rule, spelling twins, Géran order twins, a WF eq_def. `Tests.Ix.Compile.LevelSpellings, - -- IxVM ingress fixtures (Tests.Ix.IxVM) — nested/dedup shapes like + -- LegacyIxVM ingress fixtures (Tests.Ix.LegacyIxVM) — nested/dedup shapes like -- IxVMInd.DedupM (two nested occurrences of one external inductive -- with distinct spec_params) that only otherwise compile under the -- full-env `rust-compile` runner. diff --git a/Tests/Ix/IOIngress.lean b/Tests/Ix/IOIngress.lean deleted file mode 100644 index 13bb340b2..000000000 --- a/Tests/Ix/IOIngress.lean +++ /dev/null @@ -1,223 +0,0 @@ -module -public import Tests.Aiur.Common -public import Ix.IxVM.Toplevel -public import Ix.Aggr -public import Ix.Ixon - -/-! -# Every byte a circuit reads from IO is range-checked - -`read_checked_byte_stream` (`Ix/Aiur/Library/ByteStream.lean`) is the one -reader for byte streams on IO channels. It proves the stream finite and every -element below 256 before anything hashes or parses it. The check matters -because BLAKE3 absorbs message bytes only as packed 32-bit words: elements -that are not bytes could keep a stream's digest while the parsers read other -fields out of them. - -Two kinds of check: - -* **Structural**, over the compiled IxVM, `ix_aggr` and multi-stark verifier - toplevels: - - `io_read` occurs only in the stream materializer and the multi-stark - proof-stream readers; - - the unchecked materializer is called only by the checked reader and by - IxVM's advisory channel-3 hint; - - the checked reader is never called unconstrained, and it calls - `assert_byte_stream` constrained. - - A new IO read path that bypasses the checked reader fails here. -* **Execution**, for one IxVM constant read, one `ix_aggr` claim-preimage read - and one verifying-key read: genuine bytes are accepted. The same bytes with - one word's elements shifted out of byte range, keeping the word's packed - value, are refused by the range check before anything is hashed. --/ - -public section - -namespace Tests.IOIngress - -open LSpec Aiur - -/-! ## Structural -/ - -/-- Every op of a function body, through every match arm and continuation. -/ -def blockOps (body : Bytecode.Block) : Array Bytecode.Op := Id.run do - let mut stack := #[body] - let mut ops := #[] - while !stack.isEmpty do - let block := stack.back! - stack := stack.pop - ops := ops ++ block.ops - match block.ctrl with - | .match _ cases dflt => stack := stack ++ cases.map (·.2) ++ dflt.toArray - | .matchContinue _ cases dflt _ _ _ continuation => - stack := (stack ++ cases.map (·.2) ++ dflt.toArray).push continuation - | .return .. | .yield .. => pure () - return ops - -/-- The functions that may read IO cells directly. -* `read_checked_byte_stream` reads, range-checks, and materializes a byte stream - in a single constrained pass. -* `read_byte_stream_unchecked` materializes an advisory stream as advice. -* `read_u8_at` and `read_u64_at` read the multi-stark proof stream. The proof - is advice read as field values; the transcript and the Merkle and FRI checks - bind those values, so the stream is never hashed and re-parsed - (`MultiStark/Deserialize.lean`). -/ -def ioReadAllowed : List String := - ["read_checked_byte_stream", "read_byte_stream_unchecked", "read_u8_at", "read_u64_at"] - -/-- The callers allowed to use the unchecked materializer. -* `read_byte_stream_unchecked` recurses. -* `load_constant_hint` reads IxVM's channel-3 reducibility hint. It is - advisory: the hint only selects a reduction heuristic and def-eq is sound - under any value, so no content of it is unsafe. -/ -def uncheckedCallers : List String := - ["read_byte_stream_unchecked", "load_constant_hint"] - -/-- The ingress violations of one compiled toplevel. -/ -def violations (label : String) (compiled : CompiledToplevel) : Array String := Id.run do - let names : Std.HashMap Nat (Array String) := - compiled.nameMap.fold (init := {}) fun acc global index => - acc.insert index ((acc.getD index #[]).push (toString global)) - let nameOf (index : Nat) := ", ".intercalate (names.getD index #[s!""]).toList - let isOneOf (index : Nat) (allowed : List String) := (names.getD index #[]).any allowed.contains - let unchecked? := compiled.getFuncIdx `read_byte_stream_unchecked - let some checked := compiled.getFuncIdx `read_checked_byte_stream - | return #[s!"{label}: no read_checked_byte_stream"] - let mut found := #[] - let mut checkedRangeChecks := false - for (function, index) in compiled.bytecode.functions.zipIdx do - for op in blockOps function.body do - match op with - | .ioRead .. => - unless isOneOf index ioReadAllowed do - found := found.push s!"{label}: {nameOf index} reads IO cells directly" - | .u8RangeCheck .. => - if index == checked then - checkedRangeChecks := true - | .call callee _ _ unconstrained => - if some callee == unchecked? && !isOneOf index uncheckedCallers then - found := found.push s!"{label}: {nameOf index} calls read_byte_stream_unchecked" - if callee == checked && unconstrained then - found := found.push - s!"{label}: {nameOf index} calls read_checked_byte_stream unconstrained" - | _ => pure () - unless checkedRangeChecks do - found := found.push - s!"{label}: read_checked_byte_stream does not range-check its bytes" - return found - -/-- The toplevels whose IO reads must all be checked: IxVM with its test and -benchmark entrypoints, and the production `ix_aggr` and multi-stark verifier -toplevels. The multi-stark library's indexed IO hasher (`b3_io`) is a -test helper outside every production toplevel; were a production entrypoint -to reach it, its `io_read` would be reported here. -/ -def targets : List (String × Except Global Source.Toplevel) := - [("ixvm", IxVM.ixVMFull), ("ix_aggr", Aggr.ixAggr), ("multi_stark", MultiStark.multiStark)] - -def structural : IO TestSeq := do - let mut tests := TestSeq.done - for (label, toplevel) in targets do - let compiled ← IO.ofExcept ((toplevel.mapError toString).bind (·.compile)) - let found := violations label compiled - for violation in found do IO.eprintln violation - tests := tests ++ test s!"{label}: every IO read goes through the checked reader" - found.isEmpty - return tests - -/-! ## Execution -/ - -def ixvmProbe := ⟦ - pub fn ingress_constant_probe(addr: [U8; 32]) { - let _constant = load_verified_constant(store(addr)); - () - } -⟧ - -def aggrProbe := ⟦ - pub fn ingress_preimage_probe(digest: [G; 8]) { - let _bytes = aggr_load_preimage(digest); - () - } - - pub fn ingress_vk_probe(digest: [G; 8]) { - let _system = aggr_load_sys(0, digest, digest); - () - } -⟧ - -def ixvmProbeToplevel : Except Global Source.Toplevel := do - let vm ← IxVM.ixVMFull - let vm ← vm.merge ixvmProbe - return vm.prune [`ingress_constant_probe] - -def aggrProbeToplevel : Except Global Source.Toplevel := do - let t ← Aggr.ixAggrFull - let t ← t.merge aggrProbe - return t.prune [`ingress_preimage_probe, `ingress_vk_probe] - -def bytesGs (bytes : ByteArray) : Array Aiur.G := bytes.data.map .ofUInt8 - -/-- `bytes` as IO elements with one 4-byte word's elements moved out of byte -range: element `k` gains 256 and element `k + 1`, in the same word, loses 1, -so the word's packed value `b0 + 2^8 b1 + 2^16 b2 + 2^24 b3` is unchanged. -/ -def shifted (bytes : ByteArray) : Option (Array Aiur.G) := do - let k ← (List.range (bytes.size - 1)).find? fun k => k % 4 != 3 && bytes[k + 1]! != 0 - let raised : Aiur.G := .ofNat (bytes[k]!.toNat + 256) - let lowered : Aiur.G := .ofNat (bytes[k + 1]!.toNat - 1) - return ((bytesGs bytes).set! k raised).set! (k + 1) lowered - -/-- Accepted on genuine bytes, refused by the range check on shifted ones. -/ -def checkIngress (label : String) (compiled : CompiledToplevel) (entry : Lean.Name) - (input : Array Aiur.G) (bytes : ByteArray) (buffer : Array Aiur.G → IOBuffer) : - IO TestSeq := do - let some index := compiled.getFuncIdx entry - | throw (IO.userError s!"{label}: missing entrypoint {entry}") - let some bad := shifted bytes - | throw (IO.userError s!"{label}: no word to shift") - let genuine ← match compiled.bytecode.execute index input (buffer (bytesGs bytes)) with - | .ok _ => pure true - | .error e => do - IO.eprintln s!"{label}: genuine bytes failed: {e}" - pure false - let refused ← match compiled.bytecode.execute index input (buffer bad) with - | .ok _ => do - IO.eprintln s!"{label}: shifted bytes were accepted" - pure false - | .error e => do - let byRangeCheck : Bool := (e.splitOn "out of u8 range").length > 1 - unless byRangeCheck do IO.eprintln s!"{label}: shifted bytes failed otherwise: {e}" - pure byRangeCheck - return test s!"{label}: genuine bytes accepted" genuine ++ - test s!"{label}: shifted bytes refused by the range check" refused - -def execution : IO TestSeq := do - let vm ← IO.ofExcept ((ixvmProbeToplevel.mapError toString).bind (·.compile)) - let constant : Ixon.Constant := - { info := .axio { isUnsafe := false, lvls := 0, typ := .sort 0 }, - sharing := #[], refs := #[Address.blake3 "io ingress".toUTF8], univs := #[] } - let constantBytes := Ixon.serConstant constant - let address := Address.blake3 constantBytes - let constantTest ← checkIngress "IxVM constant" vm `ingress_constant_probe - (bytesGs address.hash) constantBytes - fun elements => (default : IOBuffer).extend 2 (bytesGs address.hash) elements - - let aggr ← IO.ofExcept ((aggrProbeToplevel.mapError toString).bind (·.compile)) - let preimage := "a claim preimage on channel 4".toUTF8 - let preimageTest ← checkIngress "ix_aggr preimage" aggr `ingress_preimage_probe - (MultiStark.digestGs preimage) preimage - fun elements => (default : IOBuffer).extend 4 (MultiStark.digestGs preimage) elements - - let system := AiurSystem.build aggr.bytecode commitmentParameters friParameters - let vk := system.vkBytes - let vkTest ← checkIngress "verifying key" aggr `ingress_vk_probe - (MultiStark.digestGs vk) vk - fun elements => (default : IOBuffer).extend 1 #[.ofNat 0] elements - return constantTest ++ preimageTest ++ vkTest - -def suite : IO (List TestSeq) := do - return [← structural, ← execution] - -end Tests.IOIngress - -end diff --git a/Tests/Ix/ImportIxe.lean b/Tests/Ix/ImportIxe.lean index 42622142a..8bb357e66 100644 --- a/Tests/Ix/ImportIxe.lean +++ b/Tests/Ix/ImportIxe.lean @@ -390,7 +390,7 @@ private def elabTest : IO (Bool × Nat × Nat × Option String) := do imported function applied to the commitment (`Ix.Commit.evalClaim`) — all with a closure-scoped compile, so cost tracks the claim, not the environment. (Proving the claim is - `ix prove`'s job; the IxVM eval arm is still landing.) -/ + `ix prove`'s job; the LegacyIxVM eval arm is still landing.) -/ private def zkPatternTest : IO (Bool × Nat × Nat × Option String) := do let dir ← IO.FS.createTempDir let ixePath := (dir / "fixture.ixe").toString diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean deleted file mode 100644 index ff11b516a..000000000 --- a/Tests/Ix/IxVM.lean +++ /dev/null @@ -1,827 +0,0 @@ -module - -public import Ix.Meta -public import Ix.AssumptionTree -public import Ix.IxVM.ClaimHarness -public import Tests.Aiur.Common - -open IxVM.ClaimHarness LSpec - -/-! # Aiur kernel test fixtures - -Test-purpose declarations exercised by the `ixvm` test runner. Layout: - - * `IxVMPrim` — theorems whose `rfl` proofs force the kernel to drive - each primitive reduction (Nat / String / BitVec / Decidable). - * `IxVMPerf` — synthetic FFT-cost guards for delayed let inference, - context strengthening, and multi-limb multiplication. - * `IxVMInd` — sample inductives covering mutual blocks and nested - parameters; their auto-generated recursors round-trip through the - Aiur kernel. - * `serdeNatAddComm` — Ixon serialize/deserialize round-trip via the - `ixon_serde_test` Aiur entrypoint. - * `kernelCheck` / `kernelChecks` — single-constant and curated-list - runners against the `verify_claim` Aiur entrypoint, driving a - `Ix.Claim.check addr none` claim. --/ - -/-! ## Primitive reduction theorems -/ - -namespace IxVMPrim - --- Nat arithmetic (try_nat_dispatch / try_nat_binop_addr) -public theorem nat_add_lit : 100 + 200 = 300 := rfl -public theorem nat_sub_lit : 1000 - 250 = 750 := rfl -public theorem nat_mul_lit : Nat.mul 6 7 = 42 := rfl -public theorem nat_mul_big : Nat.mul 1000000 1000000 = 1000000000000 := rfl -public theorem nat_div_lit : Nat.div 100 7 = 14 := rfl -public theorem nat_mod_lit : Nat.mod 100 7 = 2 := rfl -public theorem nat_succ_lit : Nat.succ 41 = 42 := rfl -public theorem nat_pred_lit : Nat.pred 42 = 41 := rfl -public theorem nat_gcd_lit : Nat.gcd 144 60 = 12 := rfl - --- Nat bitwise ops -public theorem nat_land_lit : Nat.land 0xff 0x0f = 0x0f := rfl -public theorem nat_lor_lit : Nat.lor 0xf0 0x0f = 0xff := rfl -public theorem nat_xor_lit : Nat.xor 0xff 0x0f = 0xf0 := rfl -public theorem nat_shl_lit : Nat.shiftLeft 1 8 = 256 := rfl -public theorem nat_shr_lit : Nat.shiftRight 256 4 = 16 := rfl --- Synthetic: exercises `klimbs_pow` at a non-trivial exponent so the cost --- of the current O(exp) recursive implementation shows up in the FFT pin. --- Sized to terminate under typical caps with the current O(exp) body — a --- proxy for the eventual binary-exponentiation rewrite. -set_option exponentiation.threshold 65536 in -set_option maxRecDepth 65536 in -public theorem nat_pow_big : (2 ^ 16384 : Nat) - (2 ^ 16384) = 0 := rfl - --- Nat predicates (return Bool ctors) -public theorem nat_beq_lit : Nat.beq 42 42 = true := rfl -public theorem nat_ble_lit : Nat.ble 5 10 = true := rfl - --- Limb-boundary iota: Nat.casesOn on a literal ≥ 2^32 forces the kernel's --- one-layer ctor exposure across a limb boundary, where an unnormalized --- `klimbs_dec` (trailing zero limb) sends the countdown past zero forever. -public theorem nat_cases_big : - (match (4294967296 : Nat) with | 0 => (0 : Nat) | n+1 => n) = 4294967295 := rfl - --- Decidable instances (try_reduce_decidable) -public theorem nat_dec_le : decide (5 ≤ 10) = true := rfl -public theorem nat_dec_lt : decide (5 < 10) = true := rfl -public theorem nat_dec_eq : decide (5 = 5 : Prop) = true := rfl - --- Open big-offset primitive comparison from the Char/ASCII regression. --- Full WHNF would unroll the offset as a successor chain; lazy def-eq --- should expose the wrapper and close the applications structurally. -@[reducible] public def lazyBigOff (x : Nat) : Nat := x + 4294967295 -public theorem lazy_ble_offset (x : Nat) : - Nat.ble (lazyBigOff x) 4294967290 = Nat.ble (x + 4294967295) 4294967290 := by - with_reducible rfl - --- Small analogue of Time's indexed UnitVal conversion and cast, using --- only Nat so its transitive closure stays suitable for a unit test. -public structure LazyUnit (scale : Nat) where - val : Nat - -public def LazyUnit.mul (x : LazyUnit a) (factor : Nat) : - LazyUnit (a * factor) := ⟨x.val * factor⟩ - -public def LazyUnit.cast (_ : a = b) (x : LazyUnit a) : LazyUnit b := - ⟨x.val⟩ - -public def lazy_unit_cast (x : LazyUnit 6) : LazyUnit 60 := - (x.mul 10).cast (by decide +kernel) - --- String primitives (try_str_dispatch) -public theorem str_size_lit : "hello".utf8ByteSize = 5 := rfl - --- BitVec primitives (try_bitvec_dispatch) -public theorem bv_to_nat_lit : (BitVec.ofNat 16 1234).toNat = 1234 := rfl - --- `SizeOf.sizeOf Unit` is no longer natively folded to 1: it must reduce --- honestly, delta-unfolding the CANONICAL `SizeOf Unit` instance (a --- `Const`, not a literal `SizeOf.mk`) to expose its field, projecting it --- and applying `()`. A prover-chosen instance would give a different --- value — that's the hole the fold left open. This pins that the honest --- reduction still fires: if the projection path regresses, the constant --- goes stuck and this check fails. -public theorem sizeof_unit : sizeOf () = 1 := rfl - -end IxVMPrim - -/-! ## FLT performance regressions - -Small synthetic witnesses for FLT optimizations, including PR #624. Generate -ordinary Lean terms at elaboration time; checking these constants still uses -the full production kernel, including hashing and dependency traversal. --/ - -namespace IxVMPerf - --- Alternate lets with applications/lambdas instead of just batching a let --- chain. Each saved value feeds the next continuation, whose body remains --- open under another binder. Eager substitution repeatedly rewrites the --- remaining continuation; the let-local inference environment avoids this. --- 64 stages: 374,093,264 FFT with eager inference vs 168,523,602 with delayed inference. -local macro "letContinuations% " n:num a:ident x:ident : term => do - let mut body : Lean.TSyntax `term := ← `(term| $x) - for _ in [:n.getNat] do - body ← `(term| let saved : $a := $x - (fun k : $a → $a => k saved) (fun $x : $a => $body)) - return body - -public def let_continuations (A : Type) (x : A) : A := letContinuations% 64 A x - --- Multiply one full limb by a long, varied row, exercising carry propagation --- and the final carry limb. A fixed LCG generates literal operands and the --- expected product at elaboration time: no PRNG/power computation enters the --- checked term. Regular/repeated limbs would let memoization hide the old --- quadratic list_snoc copying. Cons construction builds the row once. --- 512 limbs: 1,051,404,589 FFT with snoc vs 425,316,349 with the fix. -local macro "mulRow% " n:num : term => do - let mut b := 0 - let mut limb := 1 - for _ in [:n.getNat] do - limb := (limb * 6364136223846793005 + 1442695040888963407) % 2^64 - b := b * 2^64 + limb - let a := 2^64 - 1 - let lhs := Lean.Syntax.mkNumLit (toString a) - let rhs := Lean.Syntax.mkNumLit (toString b) - let product := Lean.Syntax.mkNumLit (toString (a * b)) - `(term| Nat.mul $lhs $rhs = $product) - -public theorem mul_row : mulRow% 512 := rfl - --- Repeat the same application under mixed Let/Local prefixes. The real --- locals are unused by the application, but its result type refers to the --- outer A: strengthening must distinguish raw binding slots from type slots --- and lift that type back. Rebase before inference to share the repeated --- work; keep introductions and pure-let prefixes delayed. --- 808,853,595 FFT with strengthening disabled vs 514,164,080 with it. -local macro "contextTower% " n:num a:ident x:ident : term => do - let mut body : Lean.TSyntax `term := ← `(term| $x) - let mut work : Lean.TSyntax `term := ← `(term| $x) - for _ in [:32] do - work ← `(term| (fun z : $a => z) $work) - for _ in [:n.getNat] do - body ← `(term| let saved : $a := $work - (fun unused : Nat => $body) 0) - return body - -public def context_tower (A : Type) (x : A) : A := contextTower% 64 A x - --- Unlike mul_row's repeated all-ones limb, vary BOTH operands so that --- memoization cannot hide column/carry work. Only literal operands and the --- independently computed product enter the kernel; the generator runs at --- elaboration time. Covers radix-2^16 multiplication and carry propagation. --- 277,782,128 FFT with the old arithmetic vs 266,740,297 with the new one. -local macro "mulWide% " n:num : term => do - let mut a := 0 - let mut b := 0 - let mut seed := 7 - for _ in [:n.getNat] do - seed := (seed * 6364136223846793005 + 1442695040888963407) % 2^64 - a := a * 2^64 + seed - seed := (seed * 6364136223846793005 + 1442695040888963407) % 2^64 - b := b * 2^64 + seed - let lhs := Lean.Syntax.mkNumLit (toString a) - let rhs := Lean.Syntax.mkNumLit (toString b) - let result := Lean.Syntax.mkNumLit (toString (a*b)) - `(term| Nat.mul $lhs $rhs = $result) - -public theorem mul_wide : mulWide% 32 := rfl - -end IxVMPerf - -/-! ## Inductive shape fixtures -/ - -namespace IxVMInd - --- Mutual inductive (true mutual block: Even/Odd reference each other). -mutual - public inductive Even : Nat → Prop where - | zero : Even 0 - | succ : ∀ n, Odd n → Even (n + 1) - public inductive Odd : Nat → Prop where - | succ : ∀ n, Even n → Odd (n + 1) -end - --- Mutual members with DISTINCT index telescopes (the mathlib --- `Lists.Equiv.rec` failure shape, minimized: `Lists.Equiv : Lists α → --- Lists α → Prop` mutual with `Lists'.Subset : Lists' α true → Lists' α --- true → Prop`). The canonical recursor reconstruction used to collect --- the index binder domains from the PRIMARY member (flat position 0) --- for every member of the block, so whichever recursor's parent sits at --- flat position 1 got member 0's index types and was rejected. Two --- ctors per member keep the large-elim path out of the picture (see --- SoloA/SoloB below for that half). Pins the self-member index --- extraction in `build_rec_type_from`. -mutual - public inductive IdxTeleN : Nat → Prop where - | z : IdxTeleN 0 - | s : ∀ n, IdxTeleB true → IdxTeleN n - public inductive IdxTeleB : Bool → Prop where - | t : IdxTeleB true - | f : ∀ b, IdxTeleN 0 → IdxTeleB b -end - --- Mutual single-ctor Props (the second bug the fixture above uncovered --- while being minimized): large elimination FROM Prop requires a --- SINGLE inductive in the block (inductive.rs is_large_eliminator: --- mutual Props never large-eliminate), but the IxVM's gate only looked --- at the parent's ctor count — a mutual pair of single-ctor Props was --- misclassified as large-eliminating, the reconstructed motives landed --- in `Sort u` against the declared `Prop`, and both recursors were --- rejected. Pins the `ind_is_solo` gate in `is_large_eliminator`. -mutual - public inductive SoloA : Nat → Prop where - | mk : ∀ n, SoloB true → SoloA n - public inductive SoloB : Bool → Prop where - | mk : ∀ b, SoloA 0 → SoloB b -end - --- Unsafe inductive with a BVar-headed recursive occurrence (the --- Batteries `MLList.MLListImpl` failure shape, minimized): Lean admits --- it because it is unsafe, and strict positivity must be SKIPPED for --- unsafe inductives (inductive.rs:441). Pre-gate the IxVM ran the --- positivity walker anyway and aborted with `no match case for value 0` --- on the `m (…)` spine head (BVar, tag 0) — a false rejection of every --- env containing such a constant. Pins the `is_unsafe` gate on both --- `check_positivity` call sites. -public unsafe inductive UnsafeSquash (m : Type → Type) : Type where - | mk : (Unit → m (UnsafeSquash m)) → UnsafeSquash m - --- Nested inductive (Tree with List Tree → aux _nested.List_Tree). -public inductive Tree where - | mk : List Tree → Tree - --- Aux dedup key: two nested occurrences of the SAME external inductive --- with DISTINCT spec_params. flat must be [DedupM, Bar2⟨DedupM,Nat⟩, --- Bar2⟨DedupM,Bool⟩] (3 motives); a dedup keyed on the base const idx --- alone collapses the two Bar2 auxes. -public inductive Bar2 (α β : Type) where - | mk : α → Bar2 α β - -public inductive DedupM where - | mk : Bar2 DedupM Nat → Bar2 DedupM Bool → DedupM - --- Universe dedup key: two nested occurrences of one external inductive --- with the SAME term spec_param at DISTINCT universe instantiations --- (the phantom universe appears only in the result sort). Lean emits --- distinct motives — flat must be [UnivM, PhantomBox.{0}⟨UnivM⟩, --- PhantomBox.{1}⟨UnivM⟩] (3 motives); a dedup keyed on (family, term --- spec_params) alone collapses the two PhantomBox auxes, and a --- compute_aux_perm source match that ignores head levels maps both --- source auxes onto one canonical slot. -public inductive PhantomBox (α : Type 2) : Type (max 2 u) where - | mk : α → PhantomBox α - -public inductive UnivM : Type 2 where - | mk : PhantomBox.{0} UnivM → PhantomBox.{1} UnivM → UnivM - --- De-lift guard: the SAME spec_param (`Bar1 (DepthM α)`) at field --- depths 0 and 2. In the un-opened de Bruijn view the block-param ref --- is BVar(0) vs BVar(2); without de-lifting to the param context a --- structural/ptr dedup would see two distinct auxes where flat must --- have exactly one. -public inductive Bar1 (α : Type) where - | mk : α → Bar1 α - -public inductive DepthM (α : Type) where - | mk : Bar1 (DepthM α) → Nat → Bar1 (DepthM α) → DepthM α - --- Canonical-aux-order marker driver (the Lean.Json.rec bug shape, --- verified failing on the pre-marker kernel): WrapC/WrapI are --- same-shaped wrappers over same-shaped containers with different --- payloads (Char vs Int). The wraps' aux views tie weak through --- sentinels; pre-marker they resolved by the containers' refinement- --- class order (payload address), which for this payload pair disagrees --- with the compile-side order. Only the trailing identity marker --- (ext applied to spec params, external consts by address) recovers --- compile order. -public inductive CellC (α : Type) where - | mk : α → Char → CellC α - -public inductive CellI (α : Type) where - | mk : α → Int → CellI α - -public inductive WrapC (α : Type) where - | mk : CellC α → WrapC α - -public inductive WrapI (α : Type) where - | mk : CellI α → WrapI α - -public inductive AuxTie where - | c : WrapC AuxTie → AuxTie - | i : WrapI AuxTie → AuxTie - --- Wrapper-hidden index binder (the --- CategoryTheory.MorphismProperty.ofHoms.rec failure shape, minimized — --- ~30 mathlib recursors share it): the inductive's declared type is a --- definitional wrapper (an `abbrev` — the elaborator demands --- reducibility to accept it, but the declaration stores the wrapper --- un-unfolded), so the index binder only appears after whnf. The --- canonical recursor reconstruction collects index domains off that --- declared type; a structural-only peel meets the `App` node instead of --- a `Forall` and aborts mid-execution, wrongly rejecting the recursor. --- Pins the whnf fallback in `collect_index_doms`. -public abbrev PredOver (α : Type) : Type := α → Prop - -public inductive HiddenIdx (α : Type) : PredOver α where - | mk : (a : α) → HiddenIdx α a - --- Theorem-headed iota major (the Rat.instEncodable failure shape, --- minimized): reducing `And.rec motive minor MAJOR` requires the major --- to reach `And.intro`, and here the major is a THEOREM constant. The --- general reducer keeps `Thm` heads stuck, so the iota could not fire, --- the recursor application stayed stuck, and the check failed with --- "inferred type is not def-eq to the expected type". Pins --- `whnf_iota_major`, which unfolds theorems in the major position only. --- --- Construction: the And proof is written INLINE, so the elaborator's --- Meta def-eq (which treats theorems as opaque, unlike the kernel) sees --- `And.rec` over `And.intro` and accepts; `abstractNestedProofs` then --- lifts the proof out as the auto-theorem `thmMajorUse._proof_1` at --- declaration time — the same mechanism that produced --- `Rat.instEncodable._proof_1`. The KERNEL therefore checks --- `Eq.refl 1 : 1 = 1` against the domain `(And.rec … ._proof_1) = 1`, --- forcing def-eq `1 ≟ And.rec … thmMajorUse._proof_1` with a Thm-headed --- major. `And` is used for its subsingleton large elimination: an --- And.rec whose only reduction path is through the major. -public def thmMajorWant (n : Nat) (_pf : n = 1) : Nat := n - -@[expose] public def thmMajorUse : Nat := - thmMajorWant - (And.rec (motive := fun _ => Nat) (fun _ _ => 1) - (⟨Nat.zero_lt_succ 0, Nat.zero_lt_succ 1⟩ : 0 < 1 ∧ 0 < 2)) - (Eq.refl 1) - --- PARTIALLY APPLIED K-recursor (the second half of the same fix): the --- K-synthesis gate reads the major straight out of the spine with --- `list_lookup`, which binds `Cons` irrefutably. Its only caller used to --- be `try_iota`'s stuck branch, which had already established --- `major_idx < spine_len`; hoisting the gate ABOVE `try_iota` (needed so --- a K major is never whnf'd, see `whnf_iota_major`) let a short spine --- reach that lookup, walk off the end, and abort on `Nil` — surfacing as --- "no match case for value 1" on two `Std.Tactic.BVDecide` constants. --- --- `Eq.rec` is the K recursor here (nparams=2, nmotives=1, nminors=1, --- nindices=1), so the major sits at spine index 5 and the five-argument --- application below is exactly one short. Stating it as an equation --- against an eta-expanded lambda forces the kernel to def-eq the TERM, --- which drives `whnf` into `whnf_const_head`'s Rec arm with that short --- spine. Pins the spine-length guard in `try_k_synth_iota`. -public theorem partialKRec : - (@Eq.rec Nat 0 (fun _ _ => Nat) 1 0) = (fun _ => 1) := rfl - --- Deep-telescope outer-reference shape (the mathlib --- `Algebra.kerTensorProductMapIdToAlgHomEquiv._proof_1` failure shape, --- minimized): the def-eq obligations under the inner binders reference --- ONLY the outermost binder, so in de Bruijn their loose range spans --- the whole context and the prefix trim keeps every (unreferenced) --- inner frame. Without rebasing, each comparison site's inner-frame --- spelling mints a fresh memo key — measured 164x context multiplicity --- per distinct pair on the mathlib constant. Pins `k_def_eq_rebase`: --- both sides lower by their shared minimum loose index and the --- unreferenced frames drop from the key. -public theorem deepRebase : - ∀ (n : Nat) (_a _b _c _d _e _f _g _h _i _j : Nat), - n + 0 = n := - fun n _ _ _ _ _ _ _ _ _ _ => Nat.add_zero n - -end IxVMInd - -/-! ## Test runners -/ - -/-- Round-trip `Nat.add_comm`'s Ixon env through the - `ixon_serde_test` entrypoint. -/ -public def serdeNatAddComm (env : Lean.Environment) : IO AiurTestCase := do - let ixonEnv ← loadIxonEnv ``Nat.add_comm env - let (ioBuffer, n) := buildSerdeIOBuffer ixonEnv - pure { functionName := `ixon_serde_test, label := "Ixon serde test" - input := #[.ofNat n], inputIOBuffer := ioBuffer - expectedIOBuffer := ioBuffer - interpret := false, withProof := false } - -/-- Kernel `Claim.check` with transitive typecheck semantics (`kernelCheckEntries`). - Builds an `Ix.Claim.check` claim over `name`'s shared Ixon closure, where - `run_check_transitive` walks the block-level ref DAG lazily without an - `AssumptionTree`. By default (`assumeBinding := true`), the claim assumes its - role binding (validator 4); `assumeBinding := false` validates the roles used - in its own proof (validator 3). - - Blake3 binding is preserved end-to-end: every closure member - reaches the kernel via `get_ci(addr)` which reads bytes from - ch 2 and asserts blake3(bytes) == addr before returning. -/ -public def kernelCheckWithEnv (ixonEnv : Ixon.Env) (name : Lean.Name) - (assumeBinding : Bool := true) : IO AiurTestCase := do - let target ← lookupAddr ixonEnv name - -- Claim.Check with transitive semantics: run_check_transitive walks the - -- block-level ref DAG lazily. No AssumptionTree needed — Aiur - -- memoization ensures every reachable const/block gets checked exactly - -- once, and the FFT cost stays pure typecheck cost with no tree - -- hash-verify overhead folded in. By default the claim assumes its - -- binding (validator 4), as the claims of an aggregate do, whose binding - -- claim is proven once; `assumeBinding := false` validates the roles the - -- claim uses in its own proof (validator 3). - let ctx ← IO.ofExcept (Ix.ClaimContext.ofEnv ixonEnv) - let claim := Ix.Claim.check { ctx with bindingAssumed := assumeBinding } target none - let witness ← IO.ofExcept <| buildClaimWitness ixonEnv claim {} - let label := if assumeBinding then s!"Kernel check {name}" - else s!"Kernel check validating its binding {name}" - pure { functionName := witness.funcName, label - input := witness.input, inputIOBuffer := witness.inputIOBuffer - expectedIOBuffer := witness.inputIOBuffer - interpret := false, withProof := false } - -public def kernelCheck (name : Lean.Name) (env : Lean.Environment) - (assumeBinding : Bool := true) : IO AiurTestCase := do - let ixonEnv ← loadIxonEnv name env - kernelCheckWithEnv ixonEnv name assumeBinding - -private def nameOfString (str : String) : Lean.Name := - str.splitOn "." |>.foldl (init := .anonymous) fun acc s => - match s.toNat? with - | some n => .mkNum acc n - | none => .mkStr acc s - -/-- Exact FFT-cost pins, one per checked constant. These are equality - assertions, not budgets: any kernel change that shifts the cost of a - listed constant fails the suite, so a regression cannot land quietly - and an improvement has to be acknowledged by re-pinning. These pins - include v4 TagN and contract decoding, canonicality checks, and scoped - claim headers. -/ -private def kernelCheckEntries : List (String × Nat) := [ - ("HEq", 177_456_126), - ("HEq.rec", 182_223_634), - ("Eq.rec", 181_293_061), - ("Nat", 177_332_122), - ("Nat.add", 218_693_979), - ("Nat.add_comm", 351_624_045), - ("Nat.decEq", 396_034_820), - ("Nat.decLe", 767_469_169), - ("Nat.sub_le_of_le_add", 1_617_315_103), - ("Nat.shiftRight_succ", 317_394_095), - ("Trans.mk", 185_115_903), - ("Array.append_assoc", 7_400_908_470), - ("Vector.append", 7_581_904_654), - ("IxVMPrim.nat_add_lit", 215_245_218), - ("IxVMPrim.nat_sub_lit", 215_234_163), - ("IxVMPrim.nat_mul_lit", 196_343_916), - ("IxVMPrim.nat_mul_big", 195_065_266), - ("IxVMPrim.nat_div_lit", 200_555_916), - ("IxVMPrim.nat_mod_lit", 200_664_503), - ("IxVMPrim.nat_succ_lit", 193_541_387), - ("IxVMPrim.nat_pred_lit", 196_296_439), - ("IxVMPrim.nat_gcd_lit", 196_466_150), - ("IxVMPrim.nat_land_lit", 194_479_846), - ("IxVMPrim.nat_lor_lit", 195_721_250), - ("IxVMPrim.nat_xor_lit", 197_049_773), - ("IxVMPrim.nat_shl_lit", 196_510_360), - ("IxVMPrim.nat_shr_lit", 196_454_661), - ("IxVMPrim.nat_pow_big", 350_839_899), - ("IxVMPrim.nat_beq_lit", 197_169_714), - ("IxVMPrim.nat_ble_lit", 198_003_588), - ("IxVMPrim.nat_cases_big", 213_182_669), - ("IxVMPrim.nat_dec_le", 306_807_687), - ("IxVMPrim.nat_dec_lt", 304_761_914), - ("IxVMPrim.nat_dec_eq", 296_365_496), - ("IxVMPrim.str_size_lit", 2_043_299_173), - ("IxVMPrim.bv_to_nat_lit", 1_740_155_969), - ("IxVMInd.Even", 209_713_017), - ("IxVMInd.Odd", 209_720_203), - ("IxVMInd.Even.rec", 227_222_690), - ("IxVMInd.Odd.rec", 227_222_181), - ("IxVMInd.IdxTeleN.rec", 209_825_728), - ("IxVMInd.IdxTeleB.rec", 209_825_728), - ("IxVMInd.SoloA.rec", 204_986_095), - ("IxVMInd.SoloB.rec", 204_984_844), - ("IxVMInd.UnsafeSquash", 179_987_550), - ("IxVMInd.Tree", 179_284_510), - ("IxVMInd.Tree.rec", 190_670_366), - ("IxVMInd.DedupM", 183_129_460), - ("IxVMInd.DedupM.rec", 197_667_811), - ("IxVMInd.DepthM", 181_146_385), - ("IxVMInd.DepthM.rec", 192_670_190), - ("String.Internal.append", 2_050_833_668), - ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 2_284_177_051), - ("Lean.Syntax.rec", 2_105_310_165), - ("IxVMInd.AuxTie", 281_817_395), - ("IxVMInd.AuxTie.rec", 321_476_538), - ("IxVMInd.HiddenIdx", 178_618_892), - ("IxVMInd.HiddenIdx.rec", 182_631_424), - ("IxVMInd.thmMajorUse", 511_764_182), - ("IxVMInd.partialKRec", 197_435_424), - ("IxVMInd.deepRebase", 246_311_194), - ("String.Slice.Pattern.Model.NoPrefixPatternModel.rec", 2_070_555_900), - ("Lean.Widget.TaggedText.rec", 2_076_271_093), - ("Lean.Doc.Part.rec", 2_114_900_192), - ("Lean.Doc.Block.rec", 2_313_344_708), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 181_592_009), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 215_254_576), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 215_255_826), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 215_257_077), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 199_433_831), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 180_778_440), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 206_728_123), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 206_728_123), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 206_728_123), - ("strOfListFoldSize", 2_310_765_047), - ("strOfListFoldSizeAscii", 2_311_375_426), - ("IxVMPrim.lazy_ble_offset", 220_893_731), - ("IxVMPrim.lazy_unit_cast", 345_818_198), - ("IxVMPrim.sizeof_unit", 209_770_262), - ("IxVMPerf.let_continuations", 216_744_623), - ("IxVMPerf.mul_row", 408_073_396), - ("IxVMPerf.context_tower", 520_505_224), - ("IxVMPerf.mul_wide", 253_273_713), -] - -/-- Claims that validate their binding in their own proof (validator 3), - one per cost class: no operation or one structural group, structural - operations, `div`/`mod`/shifts, and `gcd`/`land`/`lor`/`xor`. They keep - the lazy in-circuit role validation measured; `kernelCheckEntries` - measure the same kind of claims assuming the binding. -/ -private def validatingCheckEntries : List (String × Nat) := [ - ("IxVMPrim.nat_succ_lit", 198_531_475), - ("IxVMPrim.nat_mul_lit", 267_673_634), - ("IxVMPrim.nat_div_lit", 1_660_328_650), - ("IxVMPrim.nat_land_lit", 5_173_245_291), -] - -/-- The binding claim for the default table: every group validated once, - the proof aggregates reuse. -/ -private def bindingCheckEntry : Nat := 277_988_605_740 - -/-- The binding claim for the default table, over `ixonEnv`. -/ -public def bindingCheckWithEnv (ixonEnv : Ixon.Env) : IO AiurTestCase := do - let ctx ← IO.ofExcept (Ix.ClaimContext.ofEnv ixonEnv) - let claim := Ix.Claim.binding ctx.spec ctx.binding - let witness ← IO.ofExcept <| buildClaimWitness ixonEnv claim {} - pure { functionName := witness.funcName, label := "Binding claim for the default table" - input := witness.input, inputIOBuffer := witness.inputIOBuffer - expectedIOBuffer := witness.inputIOBuffer - interpret := false, withProof := false } - -/-- The binding claim for the default table, over the test environment - with the table's support records. -/ -public def bindingCheck (env : Lean.Environment) : IO AiurTestCase := do - let ixonEnv ← loadSharedIxonEnv #[] env - bindingCheckWithEnv ixonEnv - -/-- Variant of `kernelChecks`, pinned to the baseline - (`kernelCheckEntries`). Any kernel change that shifts the kernel FFT - cost fails the suite and forces a manual pin bump. -/ -public def kernelChecks (env : Lean.Environment) : IO (List AiurTestCase) := do - let allNames := - (kernelCheckEntries.map fun (name, _) => nameOfString name).toArray ++ - (validatingCheckEntries.map fun (name, _) => nameOfString name).toArray ++ - synthesizedPrimNames - let ixonEnv ← loadSharedIxonEnv allNames env - let assumed ← kernelCheckEntries.mapM fun (name, expected) => do - let tc ← kernelCheckWithEnv ixonEnv (nameOfString name) - pure { tc with expectedFftCost := some expected } - let validating ← validatingCheckEntries.mapM fun (name, expected) => do - let tc ← kernelCheckWithEnv ixonEnv (nameOfString name) (assumeBinding := false) - pure { tc with expectedFftCost := some expected } - let binding ← bindingCheckWithEnv ixonEnv - return assumed ++ validating ++ [{ binding with expectedFftCost := some bindingCheckEntry }] - -/-! ## Codegen ↔ bytecode parity - -Runs the same `AiurTestCase` through both `Toplevel.execute` (Aiur -bytecode interpreter) and `Toplevel.executeIxVM` (codegen'd Rust -kernel), diffing the two triples. Guards against the invariant the -whole codegen design rests on — "generated kernel ≡ interpreter on -the `QueryRecord`" — turning it from reviewed-by-hand into -checked-by-CI. -/ -public def runParityCase (compiled : Aiur.CompiledToplevel) - (tc : AiurTestCase) : TestSeq := - let label := tc.label - let funIdx := compiled.getFuncIdx tc.functionName |>.get! - match compiled.bytecode.execute funIdx tc.input tc.inputIOBuffer, - compiled.bytecode.executeIxVM funIdx tc.input tc.inputIOBuffer with - | .error e, _ => test s!"[parity] bytecode execute succeeds for {label}: {e}" false - | _, .error e => test s!"[parity] codegen execute succeeds for {label}: {e}" false - | .ok (bOut, bIO, bQC), .ok (cOut, cIO, cQC) => - test s!"[parity] output matches for {label}" (bOut == cOut) - ++ test s!"[parity] IOBuffer matches for {label}" (bIO == cIO) - ++ test s!"[parity] QueryCount matches for {label}" - (bQC.size == cQC.size && - (bQC.zip cQC).all fun (b, c) => - b.uniqueRows == c.uniqueRows && b.totalHits == c.totalHits) - -/-! ## Claim variant smoke tests - -Each builds an `AiurTestCase` exercising one of the non-`Check-None` -arms of `verify_claim`. The compiled-environment tests share a single Ixon env -built once over `{Nat.zero, Nat.add_comm}` — `Nat.zero` for its -small CPrj + Muts (the `Nat` block), `Nat.add_comm` for its Defn -theorems. Loading once instead of per-test cuts Lean→Ixon compile -work by ~6×. -/ - -/-- Wrap a `ClaimWitness` as an execution-only `AiurTestCase`. -/ -private def asTestCase (label : String) (witness : ClaimWitness) : AiurTestCase := - { functionName := witness.funcName, label - input := witness.input, inputIOBuffer := witness.inputIOBuffer - expectedIOBuffer := witness.inputIOBuffer - interpret := false, withProof := false } - -/-- Locate the first constant in `env.consts` whose `ConstantInfo` - satisfies `pred`, or fail with `IO.userError`. -/ -private def findConstWithOrThrow (ixonEnv : Ixon.Env) (label : String) - (pred : Ixon.ConstantInfo → Bool) : IO (Address × Ixon.ConstantInfo) := do - for (addr, lc) in ixonEnv.consts do - if let some c := lc.get? then - if pred c.info then return (addr, c.info) - throw <| IO.userError s!"no {label} const found in shared smoke env" - -/-- Single-entry HashMap for one `(root, tree)` pairing. -/ -private def singletonTrees (tree : Ix.AssumptionTree) : - Std.HashMap Address Ix.AssumptionTree := - ({} : Std.HashMap _ _).insert tree.root tree - -/-- The kernel `Check` with `assumptions = some tree.root` covering every - transitive dep — the cutoff walk (strict=0) stops at each frontier - member, so the kernel ends up checking only the subject. The kernel analog - of `claimCheckWithAsm`. -/ -public def claimCheckWithAsm (ixonEnv : Ixon.Env) : IO AiurTestCase := do - let target ← lookupAddr ixonEnv ``Nat.zero - let closure := closureFrom ixonEnv target - let depLeaves : Array Address := - closure.fold (init := #[]) fun acc a => - if a == target then acc else acc.push a - let some tree := Ix.AssumptionTree.canonical depLeaves - | throw <| IO.userError "deps unexpectedly empty for Nat.zero" - let witness ← IO.ofExcept <| buildClaimWitness ixonEnv - (Ix.Claim.check (← IO.ofExcept (Ix.ClaimContext.ofEnv ixonEnv)) target (some tree.root)) - (singletonTrees tree) - pure (asTestCase "Claim Check with-asm (Nat.zero)" witness) - -/-- The kernel CheckEnv, self-contained: owned tree = every env constant. - Exercises the strict owned-membership rule over a closure that - covers itself (walk-reachable ⊆ owned, empty asm). -/ -public def claimCheckEnvFull (ixonEnv : Ixon.Env) : IO AiurTestCase := do - let some tree := envCanonicalTree ixonEnv - | throw <| IO.userError "envCanonicalTree empty" - let witness ← IO.ofExcept <| buildClaimWitness ixonEnv - (Ix.Claim.checkEnv (← IO.ofExcept (Ix.ClaimContext.ofEnv ixonEnv)) tree.root none) - (singletonTrees tree) - pure (asTestCase "CheckEnv self-contained (shared smoke env)" witness) - -/-- The kernel CheckEnv with a thin frontier asm: owned = {Nat.add_comm}, - asm = the direct block-level refs of its constant. Exercises the - asm-cutoff walk: the single owned leaf is checked, the walk - stops at every frontier member (no recursion below), and strict - membership passes because the leaf is owned. Bytes for the full - closure stay in ch 2 — delta unfolding punches through the - frontier, only the CHECK scope stops there. -/ -public def claimCheckEnvFrontier (ixonEnv : Ixon.Env) : IO AiurTestCase := do - let target ← lookupAddr ixonEnv ``Nat.add_comm - let some c := ixonEnv.getConst? target - | throw <| IO.userError "Nat.add_comm constant missing" - let some ownedTree := Ix.AssumptionTree.canonical #[target] - | throw <| IO.userError "owned tree build failed" - let some asmTree := Ix.AssumptionTree.canonical c.refs - | throw <| IO.userError "asm (frontier) tree build failed" - let trees := (singletonTrees ownedTree).insert asmTree.root asmTree - let witness ← IO.ofExcept <| buildClaimWitness ixonEnv - (Ix.Claim.checkEnv (← IO.ofExcept (Ix.ClaimContext.ofEnv ixonEnv)) ownedTree.root - (some asmTree.root)) trees - pure (asTestCase "CheckEnv frontier-asm (Nat.add_comm)" witness) - -/-- The kernel `Reveal` Defn (kind+safety) — coverage. -/ -public def claimRevealDefnFields (ixonEnv : Ixon.Env) : IO AiurTestCase := do - let (comm, info) ← findConstWithOrThrow ixonEnv "Defn" - fun ci => match ci with | .defn _ => true | _ => false - let .defn d := info - | throw <| IO.userError "findConstWith returned non-Defn" - let revealInfo : Ix.RevealConstantInfo := - .defn (some d.kind) (some d.safety) none none none - let witness ← IO.ofExcept <| buildClaimWitness ixonEnv - (Ix.Claim.reveal comm revealInfo) {} - pure (asTestCase "Claim Reveal Defn (kind+safety)" witness) - -/-- The kernel `Reveal` Defn `typ` via content-hash binding — exercises the - kernel `expr_addr` path. -/ -public def claimRevealDefnExpr (ixonEnv : Ixon.Env) : IO AiurTestCase := do - let (comm, info) ← findConstWithOrThrow ixonEnv "Defn" - fun ci => match ci with | .defn _ => true | _ => false - let .defn d := info - | throw <| IO.userError "findConstWith returned non-Defn" - let typAddr := Address.blake3 (Ixon.runPut (Ixon.putExpr d.typ)) - let revealInfo : Ix.RevealConstantInfo := - .defn none none none (some typAddr) none - let witness ← IO.ofExcept <| buildClaimWitness ixonEnv - (Ix.Claim.reveal comm revealInfo) {} - pure (asTestCase "Claim Reveal Defn (typ Expr addr)" witness) - -/-- Reveal the type hash of a hand-built expression carrying every - non-conservative binder feature that ordinary Lean compilation cannot yet - produce. This is the positive end-to-end guard that the circuit preserves - mode bytes while parsing and reproduces them in `expr_addr`; conversion may - erase the modes only after that content-address boundary. -/ -public def claimRevealBinderModes : IO AiurTestCase := do - let typ : Ixon.Expr := - .all .linear .unique (.sort 0) - (.lam .affine (.sort 0) - (.all .erased .shared (.sort 0) (.var 0))) - let c : Ixon.Constant := - ⟨.axio ⟨false, 0, typ⟩, #[], #[], #[.zero]⟩ - let addr := Address.blake3 (Ixon.ser c) - let ixonEnv := ({} : Ixon.Env).storeConst addr c - let typAddr := Address.blake3 (Ixon.runPut (Ixon.putExpr typ)) - let witness ← IO.ofExcept <| buildClaimWitness ixonEnv - (Ix.Claim.reveal addr (.axio none none (some typAddr))) {} - pure (asTestCase "Claim Reveal Expr (v3 binder modes)" witness) - -/-- The kernel `Reveal` CPrj — all projection fields. Coverage. -/ -public def claimRevealCPrj (ixonEnv : Ixon.Env) : IO AiurTestCase := do - let (comm, info) ← findConstWithOrThrow ixonEnv "CPrj" - fun ci => match ci with | .cPrj _ => true | _ => false - let .cPrj p := info - | throw <| IO.userError "findConstWith returned non-CPrj" - let revealInfo : Ix.RevealConstantInfo := - .cPrj (some p.idx) (some p.cidx) (some p.block) - let witness ← IO.ofExcept <| buildClaimWitness ixonEnv - (Ix.Claim.reveal comm revealInfo) {} - pure (asTestCase "Claim Reveal CPrj (all fields)" witness) - -/-- The kernel `Contains` against a synthetic 3-leaf tree. -/ -public def claimContains : IO AiurTestCase := do - let a : Address := ⟨⟨Array.replicate 32 0x11⟩⟩ - let b : Address := ⟨⟨Array.replicate 32 0x22⟩⟩ - let c : Address := ⟨⟨Array.replicate 32 0x33⟩⟩ - let some tree := Ix.AssumptionTree.canonical #[a, b, c] - | throw <| IO.userError "Contains tree build failed" - let witness ← IO.ofExcept <| buildClaimWitness ({} : Ixon.Env) - (Ix.Claim.contains tree.root b) (singletonTrees tree) - pure (asTestCase "Claim Contains (synthetic 3-leaf)" witness) - - -/-! ## Shard pipeline - -The one path where the WITNESS is built in Rust rather than Lean: -`shardCheckWithEnv` hands an `EnvHandle` plus an owned-address blob to -`build_shard_check_env_witness`, which walks the closure, converts -bytes, and commits the thin-frontier asm tree in parallel Rust. Every -other suite case builds its witness Lean-side, so without this the -Rust builder — including the thin-frontier convention that determines -CheckEnv claim digests — would be untested. -/ - -/-- Group key for shard partitioning: projection wrappers group with - their block, everything else is its own group. Keeps a block and - all its wrappers in one shard, so an owned set is walk-closed at - both block and wrapper granularity. -/ -private def shardGroupOf (a : Address) (ci : Ixon.ConstantInfo) : Address := - match ci with - | .iPrj p | .cPrj p | .rPrj p | .dPrj p => p.block - | _ => a - -/-- Root namespace component of an Ixon name (`String.utf8ByteSize` → - `"String"`). -/ -private partial def ixNameRoot : Ix.Name → Option String - | .str (.anonymous _) s _ => some s - | .str p _ _ => ixNameRoot p - | .num p _ _ => ixNameRoot p - | .anonymous _ => none - -/-- Synthetic shard over the utf8-decode theorem's closure: owned = the - `String`/`Char` subsystem's block groups, frontier = its direct - out-of-owned refs. Non-toy on all three axes (owned in the dozens, - closure in the thousands, frontier in the hundreds) while staying - inside a few B FFT. - - Runs through the Rust witness builder + native kernel via - `shardCheckWithEnv`. Execution-only: the pinned FFT cost is the - regression signal. -/ -public def shardCheckEnvCase (env : Lean.Environment) : - IO (Option (Aiur.EnvHandle × ByteArray)) := do - let base : Lean.Name := - .str (.str .anonymous "ByteArray") "utf8DecodeChar?_utf8EncodeChar_append" - if !env.constants.contains base then return none - let ixonEnv ← loadIxonEnv base env - let mut groups : Std.HashMap Address (Array Address) := {} - let mut ownedGroups : Std.HashSet Address := {} - for (a, lc) in ixonEnv.consts do - if let some c := lc.get? then - let k := shardGroupOf a c.info - groups := groups.insert k ((groups.getD k #[]).push a) - if let some n := ixonEnv.addrToName[a]? then - if ixNameRoot n == some "String" || ixNameRoot n == some "Char" then - ownedGroups := ownedGroups.insert k - let mut owned : Array Address := #[] - for k in ownedGroups.toArray do owned := owned ++ groups.getD k #[] - -- Distinct from the `none` above, which means the target constant is - -- absent from this toolchain. Reaching here means the target EXISTS but - -- the shard partitioning selected nothing to own, i.e. the fixture - -- stopped exercising the Rust witness builder and thin-frontier claim - -- convention. Reporting that as a skip would leave the only test of - -- that path permanently green while testing nothing. - if owned.isEmpty then - throw <| IO.userError "shardCheckEnvCase: target present but the \ - partition selected zero owned constants — fixture no longer \ - exercises the shard pipeline" - let envBytes ← IO.ofExcept (Ixon.serEnv ixonEnv) - let handle ← IO.ofExcept (Aiur.EnvHandle.fromBytes envBytes) - let ownedBlob : ByteArray := owned.foldl (fun b a => b ++ a.hash) .empty - return some (handle, ownedBlob) diff --git a/Tests/Ix/IxVM/BindingAnchors.lean b/Tests/Ix/IxVM/BindingAnchors.lean deleted file mode 100644 index 854737ccc..000000000 --- a/Tests/Ix/IxVM/BindingAnchors.lean +++ /dev/null @@ -1,164 +0,0 @@ -module - -public import Ix.IxVM.ClaimHarness -public import Ix.Aiur.Compiler - -/-! Type-only binding anchors defer body checking to consumers. These fixtures -leave every original operation and proof record untouched, while an Int.negSucc -alias uses a helper with either a valid or an ill-typed erased argument. Native -negative results must check the synthesized constructor reference, including -when the consuming claim assumes its binding. -/ - -@[expose] public section - -namespace Tests.Ix.IxVM.BindingAnchors - -open Ix.Kernel (Role RoleTable) - -def need (label : String) (condition : Bool) : Except String Unit := - if condition then .ok () else .error label - -def address (table : RoleTable) (role : Role) : Except String Address := - match table.bound.find? (·.1 == role) with - | some (_, value) => pure value - | none => throw s!"missing role {role.leanName}" - -def putConstant (env : Ixon.Env) (constant : Ixon.Constant) : Ixon.Env × Address := - let key := Address.blake3 (Ixon.ser constant) - let env := env.storeConst key constant - ({ env with anonHints := env.anonHints.insert key .opaque }, key) - -def definition (typ value : Ixon.Expr) (refs : Array Address) : Ixon.Constant := - ⟨.defn ⟨.defn, .safe, 0, typ, value⟩, #[], refs, #[]⟩ - -structure Fixture where - env : Ixon.Env - helper : Address - anchor : Address - -def fixture (base : Ixon.Env) (table : RoleTable) (illTyped : Bool) : Except String Fixture := do - let nat ← address table .nat - let int ← address table .int - let original ← address table .intNegSucc - let discarded ← address table (if illTyped then .trueIntro else .natZero) - let typ : Ixon.Expr := .all default default (.ref 0 #[]) (.ref 1 #[]) - let value : Ixon.Expr := .lam default (.ref 0 #[]) - (.app (.lam default (.ref 0 #[]) (.app (.ref 2 #[]) (.var 1))) (.ref 3 #[])) - let (env, helper) := putConstant base (definition typ value #[nat, int, original, discarded]) - let (env, anchor) := putConstant env (definition typ (.ref 2 #[]) #[nat, int, helper]) - let replaced : RoleTable := { table with bound := table.bound.map fun (role, key) => - (role, if role == Role.intNegSucc then anchor else key) } - need "proof evidence changed" (replaced.evidence == table.evidence) - need "role count changed" (replaced.bound.size == Role.all.length) - replaced.check - let bytes := replaced.toBytes - let env := { env with roleBinding := some ⟨Address.blake3 bytes, bytes⟩ } - let mut roots := table.bound.filterMap fun (role, key) => - match role.spec (md := .anon) with - | .ops .. | .eqns .. => some key - | _ => none - for (_, evidence) in table.evidence do - for entry in evidence do - if let .proof key := entry then roots := roots.push key - let closure := IxVM.ClaimHarness.closureFromRoots env roots - need "the new anchor occurs in an original operation/proof closure" (!closure.contains anchor) - need "the new helper occurs in an original operation/proof closure" (!closure.contains helper) - return { env, helper, anchor } - -def bindingClaim (env : Ixon.Env) : Except String Ix.Claim := do - let context ← Ix.ClaimContext.ofEnv env - return .binding context.spec context.binding - -def helperClaim (fixture : Fixture) : Except String Ix.Claim := do - return .check (← Ix.ClaimContext.ofEnv fixture.env) fixture.helper none - -/-- A valid original theorem whose native reduction synthesizes the rebound -constructor. The helper/alias are absent from its original reference closure. -/ -def consumer (table : RoleTable) (fixture : Fixture) (assumed : Bool) : - Except String (Ixon.Env × Ix.Claim) := do - let refs ← #[Role.eq, .int, .intNeg, .intOfNat, .natSucc, .natZero, - .intNegSucc, .eqRefl].mapM (address table) - let one : Ixon.Expr := .app (.ref 4 #[]) (.ref 5 #[]) - let lhs : Ixon.Expr := .app (.ref 2 #[]) (.app (.ref 3 #[]) one) - let rhs : Ixon.Expr := .app (.ref 6 #[]) (.ref 5 #[]) - let typ : Ixon.Expr := .app (.app (.app (.ref 0 #[0]) (.ref 1 #[])) lhs) rhs - let value : Ixon.Expr := .app (.app (.ref 7 #[0]) (.ref 1 #[])) rhs - let proofRecord : Ixon.Constant := ⟨.defn ⟨.thm, .safe, 0, typ, value⟩, - #[], refs, #[.succ .zero]⟩ - let (env, target) := putConstant fixture.env proofRecord - let closure := IxVM.ClaimHarness.closureFromRoots env #[target] - need "consumer directly references the new anchor" (!closure.contains fixture.anchor) - need "consumer directly references the new helper" (!closure.contains fixture.helper) - let context ← Ix.ClaimContext.ofEnv env - return (env, .check { context with bindingAssumed := assumed } target none) - -structure Case where - name : String - env : Ixon.Env - claim : Ix.Claim - expectAccept : Bool - requireNativeInt : Bool := false - -def cases (base : Ixon.Env) : Except String (Array Case) := do - let some binding := base.roleBinding | throw "fixture environment has no binding" - let some table := RoleTable.ofBytes binding.bytes | throw "malformed fixture binding" - table.check - need "consumer fixtures require a complete binding" (table.bound.size == Role.all.length) - let good ← fixture base table false - let bad ← fixture base table true - let goodHelper ← helperClaim good - let badHelper ← helperClaim bad - let mut result := #[ - { name := "binding-anchor-valid-helper", env := good.env, - claim := goodHelper, expectAccept := true : Case }, - { name := "binding-anchor-invalid-helper", env := bad.env, - claim := badHelper, expectAccept := false : Case }] - for assumed in [false, true] do - for (label, value, accept) in [("valid", good, true), ("invalid", bad, false)] do - let (env, claim) ← consumer table value assumed - let entry : Case := { - name := s!"binding-anchor-{label}-consumer-assumed-{assumed}" - env := env - claim := claim - expectAccept := accept - requireNativeInt := accept } - result := result.push entry - return result - -/-- Focused consumer checks with exact backend parity. Successful native -controls must reach the constructor builder; failures must be the planted -type error, not missing witness data or another setup error. -/ -def checks (compiled : Aiur.CompiledToplevel) (base : Ixon.Env) : IO (Array (String × Bool)) := do - let some entry := compiled.getFuncIdx `verify_claim | throw (IO.userError "missing verify_claim") - let some nativeInt := compiled.getFuncIdx `mk_int_prim | throw (IO.userError "missing mk_int_prim") - let mut result := #[] - for c in ← IO.ofExcept (cases base) do - let witness ← IO.ofExcept (IxVM.ClaimHarness.buildClaimWitness c.env c.claim) - let interpreted ← IO.lazyPure fun _ => - compiled.bytecode.execute entry witness.input witness.inputIOBuffer - let generated ← IO.lazyPure fun _ => - compiled.bytecode.executeIxVM entry witness.input witness.inputIOBuffer - let parity := match interpreted, generated with - | .error a, .error b => a == b - | .ok (a, ai, aq), .ok (b, bi, bq) => - a == b && ai == bi && aq.size == bq.size && - (aq.zip bq).all fun (a, b) => a.uniqueRows == b.uniqueRows && a.totalHits == b.totalHits - | _, _ => false - result := result.push (s!"{c.name}: interpreter/generated parity", parity) - match interpreted with - | .ok (_, _, counts) => - result := result.push (s!"{c.name}: accepted", c.expectAccept) - if c.requireNativeInt then - result := result.push (s!"{c.name}: native constructor path exercised", - (counts[nativeInt]?.map fun count => decide (count.uniqueRows > 0)).getD false) - | .error error => - let isTypeError := (error.splitOn "inferred type is not def-eq to the expected type").length > 1 - result := result.push (s!"{c.name}: rejected ({error})", !c.expectAccept && isTypeError) - return result - -def defaultChecks (compiled : Aiur.CompiledToplevel) : IO (Array (String × Bool)) := do - let table ← IO.ofExcept Ix.Kernel.Reader.defaultTable - let base ← IO.ofExcept (IxVM.ClaimHarness.withRoleTable {} table.toBytes) - checks compiled base - -end Tests.Ix.IxVM.BindingAnchors diff --git a/Tests/Ix/IxVM/BindingFrontier.lean b/Tests/Ix/IxVM/BindingFrontier.lean deleted file mode 100644 index 8a6577e54..000000000 --- a/Tests/Ix/IxVM/BindingFrontier.lean +++ /dev/null @@ -1,161 +0,0 @@ -module - -public import Tests.Ix.IxVM.BindingAnchors -public import Ix.IxVM.RoleSpecGen - -/-! Production claims must validate earlier native operations lazily and check -the bodies of anchors synthesized by native reduction. The original operation -and evidence records remain unchanged in the anchor fixtures. Their new helper -is absent from the consumer's stored reference closure. -/ - -@[expose] public section - -namespace Tests.Ix.IxVM.BindingFrontier - -open Ix.Kernel (Role RoleTable) -open BindingAnchors (need address putConstant definition) - -def rebind (env : Ixon.Env) (table : RoleTable) : Except String Ixon.Env := do - table.check - let bytes := table.toBytes - return { env with roleBinding := some ⟨Address.blake3 bytes, bytes⟩ } - -structure AnchorFixture where - env : Ixon.Env - helper : Address - anchor : Address - -/-- A valid alias and an alias with an ill-typed erased argument reduce to the -same original constructor. Type-only admission cannot distinguish their bodies. -/ -def anchorFixture (base : Ixon.Env) (table : RoleTable) - (illTyped : Bool) : Except String AnchorFixture := do - let refs ← #[Role.nat, .char, .charOfNat, - if illTyped then .trueIntro else .natZero].mapM (address table) - let typ : Ixon.Expr := .all default default (.ref 0 #[]) (.ref 1 #[]) - let original : Ixon.Expr := .app (.ref 2 #[]) (.var 1) - let erased : Ixon.Expr := .app (.lam default (.ref 0 #[]) original) (.ref 3 #[]) - let value := .lam default (.ref 0 #[]) erased - let (env, helper) := putConstant base (definition typ value refs) - let (env, anchor) := putConstant env (definition typ (.ref 2 #[]) #[refs[0]!, refs[1]!, helper]) - let replaced : RoleTable := { table with bound := table.bound.map fun (r, key) => - (r, if r == .charOfNat then anchor else key) } - need "anchor fixture changed evidence" (replaced.evidence == table.evidence) - need "anchor fixture changed the role count" (replaced.bound.size == Role.all.length) - return { env := ← rebind env replaced, helper, anchor } - -def theoremClaim (env : Ixon.Env) (refs : Array Address) - (lhs rhs : Ixon.Expr) (assumed : Bool := false) : Except String (Ixon.Env × Ix.Claim) := do - -- refs[0..2] are Eq, the carrier and Eq.refl, respectively. - let typ : Ixon.Expr := .app (.app (.app (.ref 0 #[0]) (.ref 1 #[])) lhs) rhs - let value : Ixon.Expr := .app (.app (.ref 2 #[0]) (.ref 1 #[])) rhs - let (env, target) := putConstant env - ⟨.defn ⟨.thm, .safe, 0, typ, value⟩, #[], refs, #[.succ .zero]⟩ - let context ← Ix.ClaimContext.ofEnv env - return (env, .check { context with bindingAssumed := assumed } target none) - -/-- A multibyte string selects a non-ASCII native Char result. -/ -def charConsumer (env : Ixon.Env) (table : RoleTable) (assumed : Bool := false) : - Except String (Ixon.Env × Ix.Claim) := do - let text := "aλ".toUTF8 - let codepoint : ByteArray := ⟨#[0xBB, 0x03]⟩ - let textKey := Address.blake3 text - let codepointKey := Address.blake3 codepoint - let env := { env with blobs := (env.blobs.insert textKey text).insert codepointKey codepoint } - let refs ← #[Role.eq, .char, .eqRefl, .stringBack, .charOfNat].mapM (address table) - theoremClaim env (refs ++ #[textKey, codepointKey]) - (.app (.ref 3 #[]) (.str 5)) (.app (.ref 4 #[]) (.nat 6)) assumed - -def absentFromConsumer (fixture : AnchorFixture) (env : Ixon.Env) - (claim : Ix.Claim) : Except String Unit := do - let .check _ target _ := claim | throw "expected a typing claim" - let closure := IxVM.ClaimHarness.closureFromRoots env #[target] - need "consumer references the rebound anchor" (!closure.contains fixture.anchor) - need "consumer references the erased helper" (!closure.contains fixture.helper) - -def invalidWfEvidence (base : Ixon.Env) (table : RoleTable) : Except String Ixon.Env := do - let refs ← #[Role.false, .trueIntro].mapM (address table) - let (env, proof) := putConstant base - ⟨.defn ⟨.thm, .safe, 0, .ref 0 #[], .ref 1 #[]⟩, #[], refs, #[]⟩ - let wfRole (role : Role) := (IxVM.RoleSpecGen.equations role).any (!·.1.isEmpty) - need "fixture has no well-founded evidence" (table.evidence.any fun (role, _) => wfRole role) - rebind env { table with evidence := table.evidence.map fun (role, entries) => - (role, if wfRole role then entries.map (fun _ => .proof proof) else entries) } - -structure Case where - name : String - env : Ixon.Env - claim : Ix.Claim - expectedError : Option String := none - requiredQuery : Option Lean.Name := none - -def cases (base : Ixon.Env) : Except String (Array Case) := do - let some binding := base.roleBinding | throw "frontier fixture has no role binding" - let some table := RoleTable.ofBytes binding.bytes | throw "frontier fixture has a malformed table" - table.check - need "frontier controls require every role" (table.bound.size == Role.all.length) - let typeError := "inferred type is not def-eq to the expected type" - let mut result : Array Case := #[] - for illTyped in [false, true] do - let fixture ← anchorFixture base table illTyped - for assumed in [false, true] do - let (env, claim) ← charConsumer fixture.env table assumed - absentFromConsumer fixture env claim - result := result.push { - name := s!"native-Char.ofNat-erased-helper-{illTyped}-assumed-{assumed}" - env, claim - expectedError := if illTyped then some typeError else none - requiredQuery := if illTyped then none else some `try_str_back } - let (valid, validClaim) ← charConsumer base table - result := result.push { - name := "late-equation-valid-earlier-evidence" - env := valid, claim := validClaim, requiredQuery := some `try_str_back } - let invalid ← invalidWfEvidence base table - let (invalid, invalidClaim) ← charConsumer invalid table - result := result.push { - name := "late-equation-refuses-invalid-earlier-evidence" - env := invalid, claim := invalidClaim, expectedError := some typeError } - return result - -/-- Every call starts a fresh interpreter and generated executor. Compare the -complete outputs, IO and query counts; negative controls must hit their planted -error, and positive consumers must reach the relevant native constructor. -Standalone source candidates may disable generated execution until regeneration; -the registered suite always retains parity. -/ -def checks (compiled : Aiur.CompiledToplevel) (base : Ixon.Env) - (selection : String := "") (useGenerated : Bool := true) : IO (Array (String × Bool)) := do - let some entry := compiled.getFuncIdx `verify_claim | throw (IO.userError "missing verify_claim") - let mut results := #[] - for c in ← IO.ofExcept (cases base) do - if !selection.isEmpty && (c.name.splitOn selection).length == 1 then continue - IO.println s!"[binding-frontier] checking {c.name}" - (← IO.getStdout).flush - let witness ← IO.ofExcept (IxVM.ClaimHarness.buildClaimWitness c.env c.claim) - let interpreted ← IO.lazyPure fun _ => compiled.bytecode.execute entry witness.input witness.inputIOBuffer - if useGenerated then - let generated ← IO.lazyPure fun _ => compiled.bytecode.executeIxVM entry witness.input witness.inputIOBuffer - let parity := match interpreted, generated with - | .error a, .error b => a == b - | .ok (a, ai, aq), .ok (b, bi, bq) => - a == b && ai == bi && aq.size == bq.size && - (aq.zip bq).all fun (a, b) => a.uniqueRows == b.uniqueRows && a.totalHits == b.totalHits - | _, _ => false - results := results.push (s!"{c.name}: interpreter/generated parity", parity) - match interpreted with - | .ok (_, _, counts) => - results := results.push (s!"{c.name}: accepted", c.expectedError.isNone) - if let some name := c.requiredQuery then - let some query := compiled.getFuncIdx name | throw (IO.userError s!"missing {name}") - results := results.push (s!"{c.name}: native result exercised", - (counts[query]?.map fun count => decide (count.uniqueRows > 0)).getD false) - | .error error => - let expected := c.expectedError.any fun fragment => (error.splitOn fragment).length > 1 - results := results.push (s!"{c.name}: rejected ({error})", expected) - if results.isEmpty then throw (IO.userError s!"no frontier controls selected by '{selection}'") - return results - -def defaultChecks (compiled : Aiur.CompiledToplevel) : IO (Array (String × Bool)) := do - let table ← IO.ofExcept Ix.Kernel.Reader.defaultTable - let base ← IO.ofExcept (IxVM.ClaimHarness.withRoleTable {} table.toBytes) - checks compiled base - -end Tests.Ix.IxVM.BindingFrontier diff --git a/Tests/Ix/IxVM/DefinitionDependencies.lean b/Tests/Ix/IxVM/DefinitionDependencies.lean deleted file mode 100644 index 7b2aad3d3..000000000 --- a/Tests/Ix/IxVM/DefinitionDependencies.lean +++ /dev/null @@ -1,104 +0,0 @@ -import Tests.Ix.IxVM.Exploits - -/-! - Definition dependency tests for IxVM (`Tests.Ix.IxVM.DefinitionDependencies`). --/ - -namespace Tests.Ix.IxVM.DefinitionDependencies - -open LSpec Exploits - -/-- `∀ P : Prop, P` has no closed inhabitant; no axiom is needed for this exploit. -/ -private def everyProp : Ixon.Expr := .leanAll (.sort 0) (.var 0) - -private def identityType : Ixon.Expr := - .leanAll (.sort 0) (.leanAll (.var 0) (.var 1)) - -private def identityValue : Ixon.Expr := - .leanLam (.sort 0) (.leanLam (.var 0) (.var 0)) - -private def definition (kind : Ix.DefKind) (ty value : Ixon.Expr) : Ixon.Definition := - ⟨kind, .safe, 0, ty, value⟩ - -private def block (definitions : Array Ixon.Definition) - (sharing : Array Ixon.Expr := #[]) : Ixon.Env × Address := Id.run do - let (source, address) := storeAt {} - ⟨.muts (definitions.map .defn), sharing, #[], #[.zero]⟩ - let mut source := source - let mut first := address - for i in [:definitions.size] do - let (updated, projection) := storeAt source - ⟨.dPrj ⟨i.toUInt64, address⟩, #[], #[], #[]⟩ - source := { updated with anonHints := updated.anonHints.insert projection (.regular 0) } - if i == 0 then first := projection - return (source, first) - -private def asCase (name intent : String) (fixture : Ixon.Env × Address) - (accept : Bool := false) : ExploitCase := - { name, intent, env := fixture.1 - claim := .check (Ix.ClaimContext.ofDefaultTable.toOption.getD default) fixture.2 none - expectAccept := accept } - -/-- Hand-authored, hash-bound Ixon environments for the Rust soundness fix. -IxVM already rejects circular safe definitions by denying relative peer slots. -Only the rejection cases are shared with IxVM: accepting valid forward peer -references would require a separate completeness change to that kernel. -/ -def cases : Array ExploitCase := Id.run do - let mut result := #[] - for (label, kind) in [("definition", Ix.DefKind.defn), ("theorem", .thm), ("opaque", .opaq)] do - result := result.push (asCase s!"axiom-free-self-{label}" - "prove every proposition by citing the declaration itself" - (storeAt {} ⟨.defn (definition kind everyProp (.recur 0 #[])), #[], #[], #[.zero]⟩)) - result := result.push (asCase s!"mutual-self-{label}" - "hide the same false proof in a one-member mutual block" - (block #[definition kind everyProp (.recur 0 #[])])) - result := result.push (asCase "mutual-two-member-cycle" - "two declarations justify each other's proof of every proposition" - (block #[definition .thm everyProp (.recur 1 #[]), - definition .opaq everyProp (.recur 0 #[])])) - result := result.push (asCase "mutual-cycle-in-let-initializer" - "a let initializer hides a circular proof even when the body ignores it" - (block #[definition .thm identityType - (.leanLet true everyProp (.recur 1 #[]) identityValue), - definition .thm everyProp (.recur 1 #[])])) - result := result.push (asCase "mutual-cycle-through-sharing" - "sharing must not hide an edge of a declaration cycle" - (block #[definition .thm everyProp (.share 0), - definition .opaq everyProp (.recur 0 #[])] #[.recur 1 #[]])) - result := result.push (asCase "mutual-cycle-in-type" - "a declaration type must not depend on its own definition" - (block #[definition .defn (.recur 0 #[]) identityValue])) - result := result.push (asCase "control-acyclic-forward-definition" - "a forward reference to a genuine identity proof is valid" - (block #[definition .thm identityType (.recur 1 #[]), - definition .defn identityType identityValue]) true) - result := result.push (asCase "control-acyclic-forward-type" - "declaration types may depend on a later acyclic type alias" - (block #[definition .thm (.recur 1 #[]) identityValue, - definition .defn (.sort 0) identityType]) true) - result := result.push (asCase "control-acyclic-shared-diamond" - "shared live references are traversed, but unused sharing creates no dependency" - (block #[definition .thm identityType (.share 0), - definition .opaq identityType (.share 0), - definition .defn identityType identityValue] #[.recur 2 #[]]) true) - return result - -/-- IxVM classifies theorems as logical regardless of the safety byte, and -opaque declarations as logical unless explicitly unsafe. Mutual ingress must -use that effective classification too, as standalone ingress already does. -/ -private def ixvmSafetyCases : Array ExploitCase := - #[("theorem-unsafe", Ix.DefKind.thm, Ix.DefinitionSafety.unsaf), - ("theorem-partial", .thm, .part), ("opaque-partial", .opaq, .part)].map - fun (label, kind, safety) => - asCase s!"mutual-self-{label}" - "the wire safety byte must not bypass the safe declaration peer-slot restriction" - (block #[{ definition kind everyProp (.recur 0 #[]) with safety }]) - -def tests (compiled : Aiur.CompiledToplevel) : IO TestSeq := do - let control := asCase "control-closed-identity" - "a genuine closed proof must still be accepted" - (storeAt {} ⟨.defn (definition .thm identityType identityValue), #[], #[], #[.zero]⟩) true - let ixvmCases := cases.filter (fun c => !c.expectAccept) ++ ixvmSafetyCases ++ #[control] - return (← runCases compiled ixvmCases) ++ (← runCases compiled ixvmCases true) - -end Tests.Ix.IxVM.DefinitionDependencies diff --git a/Tests/Ix/IxVM/Eval.lean b/Tests/Ix/IxVM/Eval.lean deleted file mode 100644 index 7c3773aa8..000000000 --- a/Tests/Ix/IxVM/Eval.lean +++ /dev/null @@ -1,670 +0,0 @@ -module -public import Ix.IxVM.Toplevel -public import Ix.IxVM.ClaimHarness -public import Tests.Aiur.Common -public import Ix.Meta -public import Ix.CompileCertified -public import Ix.Commit -public import Ix.IxEval - -/-! - IxVM evaluation claim tests (`Tests.Ix.IxVM.Eval`). --/ - -public section -namespace Tests.Ix.IxVM.Eval - -open LSpec IxVM.ClaimHarness - -private def idType : Ixon.Expr := - .leanAll (.sort 0) (.leanAll (.var 0) (.var 1)) -private def idValue : Ixon.Expr := - .leanLam (.sort 0) (.leanLam (.var 0) (.var 0)) - -private def definition (ty value : Ixon.Expr) (refs : Array Address := #[]) - (lvls : UInt64 := 0) (univs : Array Ixon.Univ := #[.zero]) : Ixon.Constant := - ⟨.defn ⟨.defn, .safe, lvls, ty, value⟩, #[], refs, univs⟩ - -private def withValue (c : Ixon.Constant) (value : Ixon.Expr) : Ixon.Constant := - match c.info with - | .defn d => { c with info := .defn { d with value } } - | _ => c - -private def storeConstant (env : Ixon.Env) (c : Ixon.Constant) : Ixon.Env × Address := - let addr := Address.blake3 (Ixon.ser c) - let env := env.storeConst addr c - ({ env with anonHints := env.anonHints.insert addr (.regular 0) }, addr) - -private def storeDef (env : Ixon.Env) (ty value : Ixon.Expr) - (refs : Array Address := #[]) (lvls : UInt64 := 0) - (univs : Array Ixon.Univ := #[.zero]) : Ixon.Env × Address := - storeConstant env (definition ty value refs lvls univs) - -private def idOutput := definition idType idValue - -/-- The claims' context: the default role table's. -/ -private def evalCtx : Ix.ClaimContext := - Ix.ClaimContext.ofDefaultTable.toOption.getD default - -private def witness (env : Ixon.Env) (input : Address) (out : Ixon.Constant) - (tree : Option Ix.AssumptionTree := none) : IO ClaimWitness := do - let (env, output) := storeConstant env out - let trees := match tree with - | none => {} - | some t => ({} : Std.HashMap Address Ix.AssumptionTree).insert t.root t - IO.ofExcept (buildClaimWitness env (.eval evalCtx input output (tree.map (·.root))) trees) - -/-- Exact whole-claim FFT costs for successful evaluations. -/ -private def evalFftCosts : List (String × Nat) := [ - ("identity", 177_067_244), - ("beta", 177_684_567), - ("zeta", 177_680_846), - ("reduction under lambda", 177_688_401), - ("delta", 178_420_882), - ("theorem body", 177_696_243), - ("opaque body", 177_695_536), - ("mutual definition projection", 178_351_019), - ("assumed dependency still unfolds", 179_085_893), - ("input type need not be normalized", 177_709_573), - ("universe-polymorphic normalization", 177_694_614), - ("open sharing under binder", 178_479_341), - ("normalization in lambda domain", 177_724_190), - ("normalization in Pi domain and dependent codomain", 177_749_702), - ("capture-avoiding beta under nested binders", 177_826_046), - ("preserves theorem reference", 177_801_116), - ("preserves opaque reference", 177_799_151), - - ("Tests.Ix.IxVM.Eval.Fixtures.arithmetic", 283_180_015), - ("Tests.Ix.IxVM.Eval.Fixtures.listResult", 296_498_277), - ("Tests.Ix.IxVM.Eval.Fixtures.recurResult", 317_807_847), - ("Tests.Ix.IxVM.Eval.Fixtures.projResult", 200_766_956), - ("Tests.Ix.IxVM.Eval.Fixtures.stringResult", 3_116_872_195), - ("command claim after bundle transport", 284_631_854), - - ("Lean differential: Tests.Ix.IxVM.Eval.Fixtures.indexedZip", 1_094_762_732), - ("Lean differential: Tests.Ix.IxVM.Eval.Fixtures.dependentBuild", 490_655_990), - ("Lean differential: Tests.Ix.IxVM.Eval.Fixtures.mutualEven", 347_045_724), - ("Lean differential: Tests.Ix.IxVM.Eval.Fixtures.mutualOdd", 345_921_139), - ("Lean differential: Tests.Ix.IxVM.Eval.Fixtures.nestedTree", 298_326_030), - ("Lean differential: Tests.Ix.IxVM.Eval.Fixtures.higherOrder", 413_068_963), - ("Lean differential: Tests.Ix.IxVM.Eval.Fixtures.largeArithmetic", 1_695_166_262), - ("Lean differential: Tests.Ix.IxVM.Eval.Fixtures.limbPredecessor", 211_437_514), - ("Lean differential: Tests.Ix.IxVM.Eval.Fixtures.dependentCast", 482_720_171), - ("Lean differential: Tests.Ix.IxVM.Eval.Fixtures.neutralApplication", 177_954_502), - ("Lean differential: Tests.Ix.IxVM.Eval.Fixtures.neutralProjection", 185_297_866), - ("Lean differential: Tests.Ix.IxVM.Eval.Fixtures.dependentProjection", 267_040_526), - ("well-founded recursion through accessibility proofs", 1_105_402_727), - ("compact symbolic Nat offset beyond 32 bits", 240_461_536), - ("symbolic Nat addition exposes zero after argument reduction", 275_401_938), - - ("generated arithmetic 0, seed 1230526029", 2_157_040_543), - ("generated arithmetic 1, seed 5227010138933557030", 2_161_889_491), - ("generated arithmetic 2, seed 9740023657447289539", 2_165_164_849), - ("generated arithmetic 3, seed 312873973889897908", 2_159_588_294), - ("generated arithmetic 4, seed 14324766925872067785", 2_160_585_809), - ("generated arithmetic 5, seed 5865597085624116754", 2_166_456_112), - ("generated arithmetic 6, seed 8838574616595545567", 2_158_562_860), - ("generated arithmetic 7, seed 5951150478550409152", 2_163_027_335), - ("generated arithmetic 8, seed 13867390926732686213", 2_156_108_081), - ("generated arithmetic 9, seed 3876320172222402110", 2_163_510_744), - ("generated arithmetic 10, seed 9199945194732150587", 2_163_673_181), - ("generated arithmetic 11, seed 13341985934152315148", 2_154_444_827), - ("generated arithmetic 12, seed 16617329689835589249", 2_144_975_205), - ("generated arithmetic 13, seed 88728717077797802", 2_134_750_391), - ("generated arithmetic 14, seed 1948624928862008023", 2_159_334_841), - ("generated arithmetic 15, seed 6240852391080220056", 2_162_798_418), - ("generated arithmetic 16, seed 15042951194288734653", 2_136_561_446), - ("generated arithmetic 17, seed 6069444241543887446", 1_698_050_182), - ("generated arithmetic 18, seed 9883539672627336371", 2_160_567_554), - ("generated arithmetic 19, seed 4057147670932478308", 1_905_864_223), - ("generated arithmetic 20, seed 5561980989402630457", 2_139_862_531), - ("generated arithmetic 21, seed 215210223919765058", 2_162_003_188), - ("generated arithmetic 22, seed 7293824100597899471", 1_695_962_049), - ("generated arithmetic 23, seed 2714453358506657904", 1_904_468_036), -] - -private def execute (vm : AiurTestEnv) (name : String) - (w : ClaimWitness) (error : Option String := none) : TestSeq := - let idx := vm.compiled.getFuncIdx `verify_claim |>.get! - let result := vm.compiled.bytecode.execute idx w.input w.inputIOBuffer - let native := vm.compiled.bytecode.executeIxVM idx w.input w.inputIOBuffer - match result, error with - | .ok (out, io, counts), none => - let actual := (Aiur.computeStats vm.compiled counts vm.shapes).totalFftCost.round.toUInt64.toNat - let costTest := match evalFftCosts.lookup name with - | some expected => - test s!"Eval FFT cost matches for {name}: expected {expected}, got {actual}" - (actual == expected) - | none => test s!"Eval FFT cost missing for {name}: got {actual}" false - let parity := match native with - | .ok (nOut, nIO, nCounts) => - test s!"Eval bytecode/generated parity: {name}" - (out == nOut && io == nIO && - counts.size == nCounts.size && - (counts.zip nCounts).all fun (b, c) => - b.uniqueRows == c.uniqueRows && b.totalHits == c.totalHits) - | .error e => test s!"Eval bytecode/generated parity: {name}: {e}" false - test s!"Eval accepts {name}" (out.isEmpty && io == w.inputIOBuffer) ++ costTest ++ parity - | .error e, some expected => - let parity := match native with - | .error nErr => test s!"Eval bytecode/generated error parity: {name}" (e == nErr) - | .ok _ => test s!"Eval bytecode/generated error parity: {name}" false - test s!"Eval rejects {name}: {e}" (expected.isEmpty || ((toString e).splitOn expected).length > 1) ++ parity - | .error e, none => test s!"Eval accepts {name}: {e}" false - | .ok _, some _ => test s!"Eval rejects {name}" false - --- Bypass host parsing so malformed and unauthenticated constants reach Aiur. -private def rawWitness (env : Ixon.Env) (input : Address) (bytes : ByteArray) - (outputKey : Option Address := none) : ClaimWitness := - let output := outputKey.getD (Address.blake3 bytes) - let claimBytes := Ix.Claim.ser (.eval evalCtx input output none) - let digest := packedDigestKey (Address.blake3 claimBytes) - -- The claim's context names the default table, which the circuit reads - -- before anything else. - let env := match withDefaultRoleBinding env with - | .ok bound => bound - | .error _ => env - let io := addEntries env (fun _ => true) (seedBinding env default) - let io := io.extend 0 digest (claimBytes.data.map .ofUInt8) - let io := io.extend 2 (output.hash.data.map Aiur.G.ofUInt8) (bytes.data.map .ofUInt8) - { funcName := `verify_claim, input := digest, inputIOBuffer := io } - -def tests (vm : AiurTestEnv) : IO TestSeq := do - let mut seq : TestSeq := .done - let beta := Ixon.Expr.app (.leanLam idType (.var 0)) idValue - let underBinder := Ixon.Expr.leanLam (.sort 0) - (.leanLam (.var 0) (.app (.leanLam (.var 1) (.var 0)) (.var 0))) - for (label, value) in [ - ("identity", idValue), ("beta", beta), - ("zeta", Ixon.Expr.leanLet false idType idValue (.var 0)), - ("reduction under lambda", underBinder)] do - let (env, input) := storeDef {} idType value - seq := seq ++ execute vm label (← witness env input idOutput) - let (env, dep) := storeDef {} idType beta - let (env, input) := storeDef env idType (.ref 0 #[]) #[dep] - seq := seq ++ execute vm "delta" (← witness env input idOutput) - let (axiomEnv, axiomInput) := storeConstant {} { idOutput with info := .axio ⟨false, 0, idType⟩ } - seq := seq ++ execute vm "input without a body" - (← witness axiomEnv axiomInput idOutput) (some "") - for (label, kind) in [("theorem body", Ix.DefKind.thm), ("opaque body", .opaq)] do - let c : Ixon.Constant := ⟨.defn ⟨kind, .safe, 0, idType, beta⟩, #[], #[], #[.zero]⟩ - let (fixture, a) := storeConstant {} c - let fixture := { fixture with anonHints := fixture.anonHints.insert a .opaque } - seq := seq ++ execute vm label (← witness fixture a idOutput) - seq := seq ++ execute vm "output must be an ordinary definition" - (← witness env input c) (some "output must be a definition") - for safety in [Ix.DefinitionSafety.unsaf, .part] do - let c : Ixon.Constant := ⟨.defn ⟨.defn, safety, 0, idType, idValue⟩, #[], #[], #[.zero]⟩ - let (fixture, a) := storeConstant {} c - seq := seq ++ execute vm "unsafe/partial subject" (← witness fixture a idOutput) - (some "unsafe or partial") - seq := seq ++ execute vm "unsafe/partial output" (← witness env input c) - (some "unsafe or partial output") - let block : Ixon.Constant := - ⟨.muts #[.defn ⟨.defn, .safe, 0, idType, beta⟩], #[], #[], #[.zero]⟩ - let (fixture, ba) := storeConstant {} block - let projection : Ixon.Constant := ⟨.dPrj ⟨0, ba⟩, #[], #[], #[]⟩ - let (fixture, pa) := storeConstant fixture projection - seq := seq ++ execute vm "mutual definition projection" (← witness fixture pa idOutput) - let tree := Ix.AssumptionTree.canonical #[dep] |>.get! - seq := seq ++ execute vm "assumed dependency still unfolds" (← witness env input idOutput tree) - let selfTree := Ix.AssumptionTree.canonical #[input] |>.get! - seq := seq ++ execute vm "subject in assumptions" (← witness env input idOutput selfTree) - (some "input is an assumption") - seq := seq ++ execute vm "wrong output" (← witness env input (withValue idOutput (.sort 0))) - (some "result does not match") - seq := seq ++ execute vm "unreduced output" (← witness env input (withValue idOutput beta)) - (some "result does not match") - seq := seq ++ execute vm "universe count mismatch" - (← witness env input (definition idType idValue #[] 1)) (some "universe parameter count") - seq := seq ++ execute vm "correct value with a false declared type" - (← witness env input (definition (.sort 0) idValue)) (some "output type does not match") - -- Convertible types are deliberately insufficient: preserve the input's type - -- structurally, rather than silently changing the output wrapper's contract. - let aliasTy := Ixon.Expr.leanLet false (.sort 0) idType (.var 0) - seq := seq ++ execute vm "convertible but different output type" - (← witness env input (definition aliasTy idValue)) (some "output type does not match") - let (aliasEnv, aliasInput) := storeDef {} aliasTy beta - seq := seq ++ execute vm "input type need not be normalized" - (← witness aliasEnv aliasInput (definition aliasTy idValue)) - let (badEnv, badInput) := storeDef {} (.sort 0) idValue - let w ← witness badEnv badInput (definition (.sort 0) idValue) - seq := seq ++ execute vm "ill-typed input with matching output" - w (some "") - let badSelf := Ix.AssumptionTree.canonical #[badInput] |>.get! - seq := seq ++ execute vm "assumptions cannot waive input typechecking" - (← witness badEnv badInput idOutput badSelf) (some "") - let (badEnv, badDep) := storeDef {} idType (.sort 0) - let (badEnv, badInput) := storeDef badEnv idType (.ref 0 #[]) #[badDep] - seq := seq ++ execute vm "ill-typed transitive dependency" - (← witness badEnv badInput (withValue idOutput (.sort 0))) (some "") - let (polyEnv, polyInput) := storeDef {} idType underBinder #[] 1 #[.var 0] - seq := seq ++ execute vm "universe-polymorphic normalization" - (← witness polyEnv polyInput (definition idType idValue #[] 1 #[.var 0])) - let shared := { (withValue idOutput (.leanLam (.sort 0) (.leanLam (.var 0) (.share 0)))) with - sharing := #[.var 0] } - seq := seq ++ execute vm "open sharing under binder" (← witness env input shared) - let propLet := Ixon.Expr.leanLet false (.sort 1) (.sort 0) (.var 0) - let (binderEnv, binderInput) := storeDef {} idType - (.leanLam propLet (.leanLam (.var 0) (.var 0))) #[] 0 #[.zero, .succ .zero] - seq := seq ++ execute vm "normalization in lambda domain" - (← witness binderEnv binderInput idOutput) - let propBeta := fun p => Ixon.Expr.app (.leanLam (.sort 0) (.var 0)) p - let pi := Ixon.Expr.leanAll propLet - (.leanAll (propBeta (.var 0)) (propBeta (.var 1))) - let (piEnv, piInput) := storeDef {} (.sort 0) pi #[] 0 #[.zero, .succ .zero] - seq := seq ++ execute vm "normalization in Pi domain and dependent codomain" - (← witness piEnv piInput (definition (.sort 0) idType)) - let captureTy := Ixon.Expr.leanAll (.sort 0) - (.leanAll (.var 0) (.leanAll (.var 1) (.var 2))) - let captureBody := Ixon.Expr.leanLam (.sort 0) (.leanLam (.var 0) - (.app (.leanLam (.var 1) (.leanLam (.var 2) (.var 1))) (.var 0))) - let captureNF := Ixon.Expr.leanLam (.sort 0) - (.leanLam (.var 0) (.leanLam (.var 1) (.var 1))) - let (captureEnv, captureInput) := storeDef {} captureTy captureBody - seq := seq ++ execute vm "capture-avoiding beta under nested binders" - (← witness captureEnv captureInput (definition captureTy captureNF)) - let captured := Ixon.Expr.leanLam (.sort 0) - (.leanLam (.var 0) (.leanLam (.var 1) (.var 0))) - seq := seq ++ execute vm "captured variable with the same type" - (← witness captureEnv captureInput (definition captureTy captured)) (some "result does not match") - for (label, kind) in [("theorem reference", Ix.DefKind.thm), ("opaque reference", .opaq)] do - let c : Ixon.Constant := ⟨.defn ⟨kind, .safe, 0, idType, idValue⟩, #[], #[], #[.zero]⟩ - let (fixture, a) := storeConstant {} c - let (fixture, b) := storeConstant fixture (withValue c beta) - let fixture := { fixture with anonHints := fixture.anonHints.insert a .opaque |>.insert b .opaque } - let (fixture, subject) := storeDef fixture idType (.ref 0 #[]) #[a] - let expected := definition idType (.ref 0 #[]) #[a] - seq := seq ++ execute vm s!"preserves {label}" (← witness fixture subject expected) - seq := seq ++ execute vm s!"does not unfold {label}" - (← witness fixture subject idOutput) (some "result does not match") - seq := seq ++ execute vm s!"does not replace {label} by an equivalent proof" - (← witness fixture subject { expected with refs := #[b] }) (some "result does not match") - for (name, c) in [ - ("free variable", withValue idOutput (.var 0)), - ("bad ref", withValue idOutput (.ref 0 #[])), - ("bad universe index", withValue idOutput (.sort 1)), - ("bad universe parameter", { idOutput with univs := #[.var 0] }), - ("relative Rec", withValue idOutput (.recur 0 #[])), - ("free variable through sharing", { (withValue idOutput (.share 0)) with sharing := #[.var 0] }), - ("output axiom", { idOutput with info := .axio ⟨false, 0, idType⟩ }), - ("output projection", projection), ("output block", block)] do - seq := seq ++ execute vm name (rawWitness env input (Ixon.ser c)) (some "") - let outputBytes := Ixon.ser idOutput - seq := seq ++ execute vm "trailing output bytes" - (rawWitness env input (outputBytes.push 0)) (some "trailing bytes") - for n in [:outputBytes.size] do - seq := seq ++ execute vm s!"truncated output at {n}" - (rawWitness env input (outputBytes.extract 0 n)) (some "") - let w ← witness env input idOutput - let cb := Ix.Claim.ser (.eval evalCtx input (Address.blake3 outputBytes) none) - for (label, bytes) in [ - ("wrong format", cb.set! 1 3), ("wrong validator", cb.set! 2 0), - ("trailing claim bytes", cb.push 0)] do - let digest := packedDigestKey (Address.blake3 bytes) - let io := w.inputIOBuffer.extend 0 digest (bytes.data.map .ofUInt8) - seq := seq ++ execute vm label { w with input := digest, inputIOBuffer := io } (some "") - seq := seq ++ execute vm "unauthenticated output bytes" - (rawWitness env input (Ixon.ser (withValue idOutput (.sort 0))) - (some (Address.blake3 outputBytes))) (some "") - return seq - --- Ordinary compiled Lean programs exercise primitive, recursor, constructor, --- projection, and literal paths with all dependencies checked. -namespace Fixtures -def arithmetic : Nat := 6 * 7 -def fortyTwo : Nat := 42 -def listResult : List Nat := [6 * 7, 10 + 2] -def listExpected : List Nat := [42, 12] -def recurResult : Nat := List.foldl Nat.add 0 [1, 2, 3] -def six : Nat := 6 -def projResult : Nat := (7, 9).2 -def nine : Nat := 9 -def stringResult : String := (fun s => s) "hello" -def stringExpected : String := "hello" - -inductive Vec (α : Type) : Nat → Type where - | nil : Vec α 0 - | cons : α → Vec α n → Vec α (n + 1) - -def Vec.map (f : α → β) : Vec α n → Vec β n - | .nil => .nil - | .cons x xs => .cons (f x) (xs.map f) - -def Vec.zipWith (f : α → β → γ) : Vec α n → Vec β n → Vec γ n - | .nil, .nil => .nil - | .cons x xs, .cons y ys => .cons (f x y) (xs.zipWith f ys) - -def Vec.sum : Vec Nat n → Nat - | .nil => 0 - | .cons x xs => x + xs.sum - -def Vec.build : (n : Nat) → Vec Nat n - | 0 => .nil - | n + 1 => .cons (n + 1) (build n) - -def indexedZip : Nat := - Vec.sum (Vec.zipWith Nat.mul - (Vec.map (fun n => n + 1) (.cons 1 (.cons 2 (.cons 3 .nil)))) - (.cons 4 (.cons 5 (.cons 6 .nil)))) -def dependentBuild : Nat := (Vec.build 6).sum - -mutual - def even : Nat → Bool - | 0 => true - | n + 1 => odd n - def odd : Nat → Bool - | 0 => false - | n + 1 => even n -end -def mutualEven : Nat := if even 12 then 17 else 23 -def mutualOdd : Nat := if even 11 then 17 else 23 - -inductive Rose where - | node : Nat → List Rose → Rose - -def Rose.totalWF : Rose → Nat - | .node n children => n + (children.map Rose.totalWF).foldl Nat.add 0 - -noncomputable def Rose.total (t : Rose) : Nat := - Rose.rec (motive_1 := fun _ => Nat) (motive_2 := fun _ => Nat) - (fun n _ children => n + children) 0 (fun _ _ head tail => head + tail) t - -def tree : Rose := .node 1 [.node 2 [.node 3 [], .node 4 []], .node 5 []] -noncomputable def nestedTree : Nat := tree.total -def wellFoundedTree : Nat := tree.totalWF - --- Explicit accessibility proof: unlike elaborator-generated general WF --- recursion, this does not insert Lean.opaqueId around the proof. -noncomputable def transparentWF : Nat → Nat := - WellFounded.fix Nat.lt_wfRel.wf fun n recurse => - match n with - | 0 => 0 - | k + 1 => (k + 1) + recurse k (Nat.lt_succ_self k) -noncomputable def wellFoundedSum : Nat := transparentWF 6 - -def higherOrder : Nat := - ([1, 2, 3, 4, 5].map (fun x => (fun f => f (x * x)) (fun n => n + 1))).foldl Nat.add 0 - -def largeArithmetic : Nat := ((4294967296 + 17) * 4294967299) / 7 -def limbPredecessor : Nat := match (4294967296 : Nat) with | 0 => 7 | n + 1 => n - -theorem threeEq : (1 + 2 : Nat) = 3 := rfl -def dependentCast : Nat := - (Eq.ndrec (motive := Vec Nat) (Vec.build (1 + 2)) threeEq).sum - -def neutralApplication : (α : Type) → (α → α) → α → α := - fun α f x => f ((fun y : α => y) x) -def neutralProjection : Nat × Nat → Nat := fun p => (fun q : Nat × Nat => q.1) p -def dependentProjection : (p : Sigma (fun n => Vec Nat n)) → Vec Nat p.1 := - fun p => (fun q : Sigma (fun n => Vec Nat n) => q.2) p - -def openOffset : Nat → Nat := fun n => Nat.add n (Nat.add 4294967296 17) -def openZero : Nat → Nat := fun n => Nat.add n (Nat.sub 7 7) -end Fixtures - -private def natOutput (env : Ixon.Env) (n : Nat) : IO (Ixon.Env × Ixon.Constant) := do - let nat ← lookupAddr env ``Nat - let (env, addr) := env.storeBlob (ByteArray.mk (Nat.toBytesLE n)) - return (env, definition (.ref 0 #[]) (.nat 1) #[nat, addr] 0 #[]) - -private def listOutput (env : Ixon.Env) : IO (Ixon.Env × Ixon.Constant) := do - let nat ← lookupAddr env ``Nat - let consAddr ← lookupAddr env ``List.cons - let nilAddr ← lookupAddr env ``List.nil - let listAddr ← lookupAddr env ``List - let (env, a) := env.storeBlob (ByteArray.mk (Nat.toBytesLE 42)) - let (env, b) := env.storeBlob (ByteArray.mk (Nat.toBytesLE 12)) - let ty := Ixon.Expr.ref 0 #[] - let cons := Ixon.Expr.app (.ref 1 #[0]) ty - let nil := Ixon.Expr.app (.ref 2 #[0]) ty - let root := Ixon.Expr.app (.app cons (.nat 3)) (.app (.app cons (.nat 4)) nil) - return (env, definition (.app (.ref 5 #[0]) ty) root - #[nat, consAddr, nilAddr, a, b, listAddr]) - -def compiledTests (leanEnv : Lean.Environment) (vm : AiurTestEnv) : IO TestSeq := do - let pairs := #[ - (``Fixtures.arithmetic, ``Fixtures.fortyTwo), - (``Fixtures.listResult, ``Fixtures.listExpected), - (``Fixtures.recurResult, ``Fixtures.six), - (``Fixtures.projResult, ``Fixtures.nine), - (``Fixtures.stringResult, ``Fixtures.stringExpected)] - let env ← loadSharedIxonEnv (pairs.flatMap (fun (a, b) => #[a, b]) ++ synthesizedPrimNames) leanEnv - let mut seq : TestSeq := .done - for (a, b) in pairs do - let input ← lookupAddr env a - let output ← lookupAddr env b - let some c := env.getConst? output | throw <| IO.userError "missing fixture" - let raw := c - -- Lean numeral syntax elaborates to OfNat applications. Specify the - -- expected normal forms independently, with actual literal nodes. - let (fixture, obj) ← - if b == ``Fixtures.fortyTwo then natOutput env 42 - else if b == ``Fixtures.six then natOutput env 6 - else if b == ``Fixtures.nine then natOutput env 9 - else if b == ``Fixtures.listExpected then listOutput env - else pure (env, raw) - seq := seq ++ execute vm (toString a) (← witness fixture input obj) - if a == ``Fixtures.arithmetic then - seq := seq ++ execute vm "unreduced OfNat output" - (← witness env input raw) (some "result does not match") - let (fixture, wrongObj) ← natOutput env 9 - seq := seq ++ execute vm "wrong result with the same type" - (← witness fixture input wrongObj) (some "result does not match") - return seq - -private def compileClosure (leanEnv : Lean.Environment) (names : Array Lean.Name) : - IO Ix.CompileM.CompilePhases := do - let mut seen : Lean.NameSet := {} - let mut entries := #[] - for n in names ++ synthesizedPrimNames do - for entry in Lean.collectDependencies n leanEnv.constants do - unless seen.contains entry.1 do - seen := seen.insert entry.1 - entries := entries.push entry - Ix.CompileM.compilePhasesOf leanEnv entries.toList - -private def compiledOutput (base : Ix.CompileM.CompileEnv) (env : Ixon.Env) - (lvls : List Lean.Name) (ty value : Lean.Expr) : IO (Ixon.Env × Ixon.Constant) := do - let (addr, cache) ← IO.ofExcept (Ix.Commit.compileDef base lvls ty value) - let some bytes := cache.constants[addr]? | throw <| IO.userError "missing compiled output" - let obj ← IO.ofExcept (Ixon.de bytes) - return ({ env with blobs := cache.blobs }, obj) - -/-- Independent Lean reduction supplies the expected terms, never IxVM's own -normalizer. Closed numeric examples additionally pin a hand-computed result. -Neutral terms deliberately avoid arithmetic, where Lean and IxVM choose -different representations for stuck primitives. -/ -def difficultTests (leanEnv : Lean.Environment) (vm : AiurTestEnv) : IO TestSeq := do - let numeric : Array (Lean.Name × Nat) := #[ - (``Fixtures.indexedZip, 47), (``Fixtures.dependentBuild, 21), - (``Fixtures.mutualEven, 17), (``Fixtures.mutualOdd, 23), - (``Fixtures.nestedTree, 15), (``Fixtures.higherOrder, 60), - (``Fixtures.largeArithmetic, ((4294967296 + 17) * 4294967299) / 7), - (``Fixtures.limbPredecessor, 4294967295), (``Fixtures.dependentCast, 6)] - let neutral := #[``Fixtures.neutralApplication, ``Fixtures.neutralProjection, - ``Fixtures.dependentProjection] - let phases ← compileClosure leanEnv - (numeric.map Prod.fst ++ neutral ++ - #[``Fixtures.wellFoundedTree, ``Fixtures.wellFoundedSum, - ``Fixtures.openOffset, ``Fixtures.openZero]) - let base := Ix.Commit.mkCompileEnv phases - let env := phases.compileEnv - let mut seq : TestSeq := .done - for name in numeric.map Prod.fst ++ neutral do - let some (.defnInfo info) := leanEnv.find? name - | throw <| IO.userError s!"expected definition: {name}" - let expected ← runMeta (Lean.Meta.withTransparency .all (Lean.Meta.reduceAll info.value)) leanEnv - if let some (_, n) := numeric.find? (fun p => p.1 == name) then - seq := seq ++ test s!"Lean oracle agrees with pinned result: {name}" - (expected == .lit (.natVal n)) - let input ← lookupAddr env name - let (fixture, obj) ← compiledOutput base env info.levelParams info.type expected - seq := seq ++ execute vm s!"Lean differential: {name}" (← witness fixture input obj) - if let some (_, n) := numeric.find? (fun p => p.1 == name) then - let (fixture, wrong) ← natOutput env (n + 1) - seq := seq ++ execute vm s!"incorrect result: {name}" - (← witness fixture input wrong) (some "result does not match") - -- The elaborator deliberately wraps this accessibility proof in opaqueId. - -- A kernel-reduction claim must respect that boundary, even though native - -- compilation can execute the function by erasing proofs. - let input ← lookupAddr env ``Fixtures.wellFoundedTree - let (fixture, output) ← natOutput env 15 - let opaqueId ← lookupAddr env ``Lean.opaqueId - seq := seq ++ test "generated WF fixture contains the opaqueId dependency" - ((closureFrom env input).contains opaqueId) - seq := seq ++ execute vm "opaque accessibility proof blocks kernel evaluation" - (← witness fixture input output) (some "result does not match") - -- This explicit proof does expose constructors to Acc.rec. Meta keeps its - -- theorem heads opaque, so pin the independent triangular-number answer. - let input ← lookupAddr env ``Fixtures.wellFoundedSum - let (fixture, output) ← natOutput env 21 - seq := seq ++ execute vm "well-founded recursion through accessibility proofs" - (← witness fixture input output) - let (fixture, wrong) ← natOutput env 22 - seq := seq ++ execute vm "incorrect well-founded recursion result" - (← witness fixture input wrong) (some "result does not match") - -- Open Nat offset must remain compact; unfolding Nat.add's implementation - -- here would expand billions of successors or leave a different normal form. - let nat ← lookupAddr env ``Nat - let add ← lookupAddr env ``Nat.add - let (fixture, literal) := env.storeBlob (ByteArray.mk (Nat.toBytesLE 4294967313)) - let natArrow := Ixon.Expr.leanAll (.ref 0 #[]) (.ref 0 #[]) - let output := definition natArrow - (.leanLam (.ref 0 #[]) (.app (.app (.ref 1 #[]) (.var 0)) (.nat 2))) - #[nat, add, literal] 0 #[] - let input ← lookupAddr env ``Fixtures.openOffset - seq := seq ++ execute vm "compact symbolic Nat offset beyond 32 bits" - (← witness fixture input output) - let input ← lookupAddr env ``Fixtures.openZero - seq := seq ++ execute vm "symbolic Nat addition exposes zero after argument reduction" - (← witness env input (definition natArrow (.leanLam (.ref 0 #[]) (.var 0)) #[nat] 0 #[])) - return seq - -private structure GenState where - seed : UInt64 := 0x4958564d - coverage : Array Nat := Array.replicate 7 0 - -private def draw (bound : Nat) : StateM GenState Nat := do - modify fun s => { s with seed := s.seed * 6364136223846793005 + 1442695040888963407 } - return ((← get).seed >>> 32).toNat % bound - -/-- Typed arithmetic terms with lexical binders. The second component is an -independent numeric interpretation; it does not inspect either reducer's output. -Fuel bounds term size, and successor denominators keep division nonzero. -/ -private def genNat (fuel : Nat) (locals : List Nat) : - StateM GenState (Lean.Expr × Nat) := do - let nat := Lean.mkConst ``Nat - match fuel with - | 0 => - if !locals.isEmpty && (← draw 2) == 0 then - let i ← draw locals.length - return (.bvar i, locals[i]!) - let n ← draw 17 - return (Lean.mkNatLit n, n) - | fuel + 1 => - let mode ← draw 7 - modify fun s => { s with coverage := s.coverage.modify mode (· + 1) } - let (a, av) ← genNat fuel locals - if mode == 3 || mode == 4 then - let (body, value) ← genNat fuel (av :: locals) - if mode == 3 then - return (.letE `x nat a body false, value) - return (.app (.lam `x nat body .default) a, value) - let (b, bv) ← genNat fuel locals - let binary := fun name b => Lean.mkApp2 (Lean.mkConst name) a b - match mode with - | 0 => return (binary ``Nat.add b, av + bv) - | 1 => return (binary ``Nat.mul b, av * bv) - | 2 => return (binary ``Nat.sub b, av - bv) - | 5 => return (binary ``Nat.div (Lean.mkApp (Lean.mkConst ``Nat.succ) b), av / (bv + 1)) - | _ => return (binary ``Nat.mod (Lean.mkApp (Lean.mkConst ``Nat.succ) b), av % (bv + 1)) - -def differentialTests (leanEnv : Lean.Environment) (vm : AiurTestEnv) : IO TestSeq := do - let phases ← compileClosure leanEnv - #[``Nat.add, ``Nat.mul, ``Nat.sub, ``Nat.div, ``Nat.mod, ``Nat.succ] - let base := Ix.Commit.mkCompileEnv phases - let ty := Lean.mkConst ``Nat - let mut state : GenState := {} - let mut seq : TestSeq := .done - for i in [:24] do - let seed := state.seed - let ((value, answer), next) := (genNat 4 []).run state - state := next - let label := s!"generated arithmetic {i}, seed {seed}" - let nf ← runMeta (Lean.Meta.withTransparency .all (Lean.Meta.reduceAll value)) leanEnv - seq := seq ++ test s!"Lean agrees with independent numeric oracle: {label}" - (nf == .lit (.natVal answer)) - let (input, cache) ← IO.ofExcept (Ix.Commit.compileDef base [] ty value) - let some bytes := cache.constants[input]? | throw <| IO.userError "missing generated input" - let c : Ixon.Constant ← IO.ofExcept (Ixon.de bytes) - let env := phases.compileEnv.storeConst input c - let env := { env with blobs := cache.blobs, anonHints := env.anonHints.insert input (.regular 0) } - let (fixture, output) ← compiledOutput cache env [] ty nf - seq := seq ++ execute vm label (← witness fixture input output) - let (fixture, wrong) ← natOutput fixture (answer + 1) - seq := seq ++ execute vm s!"mutated output: {label}" - (← witness fixture input wrong) (some "result does not match") - seq := seq ++ test "generated corpus covers add/mul/sub/let/beta/div/mod" - (state.coverage.all (· > 0)) - return seq - -private def packBundle (env : Ixon.Env) (root : Address) : IO Ixon.Env := do - let name := Ix.Name.mkStr Ix.Name.mkAnon "_obj" - let (names, blobs) := Ixon.RawEnv.addNameComponentsWithBlobs env.names env.blobs name - let env := { env with names, blobs }.registerName name { addr := root, constMeta := .empty } - let dir ← IO.FS.createTempDir - try - let source := dir / "source.ixe" - let target := dir / "bundle.ixe" - IO.FS.writeBinFile source (← IO.ofExcept (Ixon.serEnv env)) - Ixon.rsPackEnv source.toString "_obj" #[] target.toString true false - IO.ofExcept (Ixon.runGetExact Ixon.Env.getEnv (← IO.FS.readBinFile target)) - finally - IO.FS.removeDirAll dir - -/-- Check the command's printed claim against an independent construction, -transport both endpoints through ordinary bundles, then execute the claim. -/ -def commandTests (leanEnv : Lean.Environment) (vm : AiurTestEnv) : IO TestSeq := do - let phases ← compileClosure leanEnv #[``Fixtures.arithmetic] - let base := Ix.Commit.mkCompileEnv phases - let (claim, cache) ← IO.ofExcept (Ix.Commit.evalClaimWithEnv evalCtx base [] - (Lean.mkConst ``Fixtures.arithmetic) (.lit (.natVal 42)) (Lean.mkConst ``Nat)) - let .eval _ input output _ := claim | throw <| IO.userError "expected Eval claim" - let some bytes := cache.constants[input]? | throw <| IO.userError "missing command input" - let c : Ixon.Constant ← IO.ofExcept (Ixon.de bytes) - let env := phases.compileEnv.storeConst input c - let some bytes := cache.constants[output]? | throw <| IO.userError "missing command output" - let c : Ixon.Constant ← IO.ofExcept (Ixon.de bytes) - let env := env.storeConst output c - let env := { env with - blobs := cache.blobs - anonHints := env.anonHints.insert input (.regular 0) |>.insert output (.regular 0) } - let command : Lean.Elab.Command.CommandElabM Unit := do - Lean.Elab.Command.elabCommand - (← `(command| #ixeval Tests.Ix.IxVM.Eval.Fixtures.arithmetic)) - let ctx : Lean.Elab.Command.Context := { - fileName := "commandTests", fileMap := Lean.FileMap.ofString "" - snap? := none, cancelTk? := none } - let (_, state) ← match ← EIO.toIO' ((command ctx).run (Lean.Elab.Command.mkState leanEnv)) with - | .ok result => pure result - | .error e => throw <| IO.userError (← e.toMessageData.toString) - let messages ← state.messages.toList.mapM fun msg => do - pure (msg.severity, ← msg.data.toString) - let expected := s!"42\n{claim}\ndigest {Address.blake3 (Ix.Claim.ser claim)}" - let seq := test "command prints the expected result, Eval claim, and digest" - (messages == [(.information, expected)]) - let inputBundle ← packBundle env input - let outputBundle ← packBundle env output - let seq := seq ++ test "bundles retain the claim's individual constant addresses" - (inputBundle.main == some input && outputBundle.main == some output) - ++ test "output bundle prunes the input and display metadata" - (!outputBundle.consts.contains input && outputBundle.named.isEmpty) - let transported := { inputBundle with - consts := outputBundle.consts.fold (fun m k v => m.insert k v) inputBundle.consts - blobs := outputBundle.blobs.fold (fun m k v => m.insert k v) inputBundle.blobs - anonHints := outputBundle.anonHints.fold (fun m k v => m.insert k v) inputBundle.anonHints } - let w ← IO.ofExcept (buildClaimWitness transported claim) - return seq ++ execute vm "command claim after bundle transport" w - -end Tests.Ix.IxVM.Eval diff --git a/Tests/Ix/IxVM/Exploits.lean b/Tests/Ix/IxVM/Exploits.lean deleted file mode 100644 index dde654d9e..000000000 --- a/Tests/Ix/IxVM/Exploits.lean +++ /dev/null @@ -1,2143 +0,0 @@ -import Ix.Ixon -import Ix.Claim -import Ix.IxVM -import Ix.IxVM.ClaimHarness -import Ix.Aiur.Protocol -import Ix.Aiur.Compiler -import Tests.Aiur.Common -import Tests.Ix.Kernel.FastPathDefs -import Tests.Ix.Kernel.FastPaths -import LSpec - -/-! - Adversarial Ixon fixtures: exploit attempts authored DIRECTLY as - `Ixon.Constant` values, bypassing the Lean → Ixon compiler. - - The kernel-arena corpus (`Tests.Ix.Kernel.Arena`) attacks the layer - ABOVE this one: its `bad_*` fixtures are raw `Lean.ConstantInfo` - declarations that skip Lean's elaborator, but they are still compiled - by the Ixon compiler, so the Ixon they produce is always well-formed — - `sharing` comes from real sharing analysis, `refs` from the `IndexSet` - of addresses actually referenced. An honest compiler cannot emit the - malformed Ixon a real prover is free to author. - - This suite closes that gap. A prover controls the constant bytes and - the IOBuffer; content-addressing binds bytes to an address, but NOT - the shape of those bytes to anything the compiler would have produced. - So every structural premise the kernel relies on but does not assert - is reachable from here. - - ## Threat model - - This is a zkDSL: resource exhaustion and aborts are NOT threats (a - dishonest prover only pays its own trace). The only threat is a WRONG - ANSWER — the kernel ACCEPTING a claim that is false. So an exploit case - asserts REJECTION, and a case that flips to accepting is a soundness - hole (or a fixture that stopped reaching its target). - - A case may instead assert ACCEPTANCE when accepting is the specified - semantics and the claim is merely VACUOUS rather than false — a - conditional claim that assumes an unsatisfiable role binding being the - example. Those mark where the kernel's obligation ends and a consumer's - begins; they are pinned so the boundary cannot move silently. - - ## Writing a case - - Each `ExploitCase` carries the intent it would buy an attacker, so a - failure reads as a security statement rather than a broken test. Pair - every exploit with CONTROLS that differ minimally from it: one showing - the smuggled-past constant really is ill-typed, one showing the kernel - catches it absent the exploit trick. Without those a green suite may - only mean the fixture never reached the code it targets. --/ - -open LSpec - -namespace Tests.Ix.IxVM.Exploits - -/-- An attempted exploit, or a control that anchors one. - - `expectAccept := false` (the default) means the kernel MUST reject: - execution has to fail, and it should fail via an in-kernel - `assert_eq!` rather than by accident. -/ -structure ExploitCase where - /-- Short kebab-case identifier, used in the test label. -/ - name : String - /-- The false statement the kernel would endorse by accepting. Read - this first when the case fails. -/ - intent : String - /-- The adversarial env: hand-built constants, stored at their own - content addresses. -/ - env : Ixon.Env - /-- The claim submitted against `env`. -/ - claim : Ix.Claim - /-- Assumption trees the claim's roots refer to, if any. -/ - trees : Std.HashMap Address Ix.AssumptionTree := {} - /-- Whether the kernel is expected to ACCEPT. Exploits set `false`; - controls that must typecheck set `true`. -/ - expectAccept : Bool := false - /-- For a rejection, text the execution error must contain: the in-kernel - `assert_eq!` message expected to fire, when the case pins one. -/ - rejectsWith : Option String := none - -/-! ## Ixon construction helpers - -The compiler is deliberately not involved: these build the bytes a -prover would. `constAddr` is the same content-addressing the kernel -enforces (`load_verified_constant` asserts `blake3(bytes) == addr`), so -a fixture cannot accidentally desync its address from its content. -/ - -/-- Content address of a hand-built constant: `blake3` over its Ixon - serialization, matching the kernel's `verify_bytes_against`. -/ -def constAddr (c : Ixon.Constant) : Address := - Address.blake3 (Ixon.ser c) - -/-- Store `c` at its own content address; returns the updated env and - that address. - - A `Defn` also gets a reducibility hint registered: `get_ci` faults - one from channel 3 for every definition it resolves, so a hand-built - env without it aborts with `invalid IO key` long before the checker - runs. `.opaque` keeps delta-unfolding out of the picture, which is - what a structural fixture wants. -/ -def storeAt (env : Ixon.Env) (c : Ixon.Constant) : Ixon.Env × Address := - let addr := constAddr c - let env := env.storeConst addr c - -- A `DPrj` resolves to its block's definition member and faults the - -- hint under the WRAPPER's address (`get_ci_dprj`), so wrappers need - -- one just as standalone definitions do. - let env := match c.info with - | .defn _ | .dPrj _ => - { env with anonHints := env.anonHints.insert addr .opaque } - | _ => env - (env, addr) - -/-- A `Definition`-flavoured constant with explicit tables. `sharing` is - a parameter because it is exactly what the compiler would never let - an attacker choose. -/ -def defnConst (kind : Ix.DefKind) (typ value : Ixon.Expr) - (sharing : Array Ixon.Expr := #[]) (refs : Array Address := #[]) - (univs : Array Ixon.Univ := #[]) : Ixon.Constant := - ⟨.defn ⟨kind, .safe, 0, typ, value⟩, sharing, refs, univs⟩ - -/-- `Sort 0` (i.e. `Prop`), resolving through `univs[0] = Univ.zero`. -/ -def prop : Ixon.Expr := .sort 0 - -/-- The single-entry universe table `prop` indexes into. -/ -def univsZero : Array Ixon.Univ := #[.zero] - -/-! ## Fixtures -/ - -/-- The constant every case in this group smuggles past the checker. - - Declared type `Prop`, value the term `Prop`. `Prop : Type` (i.e. - `Sort 1`), NOT `Prop`, so this is ill-typed and the kernel must - reject it whenever it is actually checked. Its declared type is - nonetheless perfectly usable by `k_infer`, which reads a `Const` - node's DECLARED type without checking it (`Kernel/Infer.lean`). -/ -def illTypedConst : Ixon.Constant := - defnConst .defn prop prop (univs := univsZero) - -/-- Builds the group: an ill-typed constant plus a target that depends - on it, where `deadSharing` decides whether the target carries a - `sharing` entry no `Expr.Share` node references. - - `Expr.nat 0` names index 0 of `refs`, so `blob_idxs_of` records - index 0 as a blob payload — and `walk_refs_transitive` / - `env_walk_refs` skip a marked index unconditionally. The entry is - never converted (conversion reaches `sharing` only via - `Expr.Share`), never typechecked, and needs no blob on channel 4; - it exists purely to be seen by the blob-index pass. -/ -def dependentTarget (deadSharing : Bool) : Ixon.Env × Address := - let (env, badAddr) := storeAt {} illTypedConst - let sharing : Array Ixon.Expr := if deadSharing then #[.nat 0] else #[] - -- Declared type `Prop`, value `refs[0]` — whose DECLARED type is also - -- `Prop`, so the target typechecks against the dependency's claim - -- about itself. Only walking into the dependency exposes the lie. - let target := defnConst .defn prop (.ref 0 #[]) sharing #[badAddr] univsZero - storeAt env target - -/-- Target whose value is `Let(Nat 0, Ref 0)`: index 0 of `refs` is named - by a `Nat` literal AND by a constant reference. The `Nat` use needs a - blob on channel 4 under the same address, which costs nothing — - `load_verified_blob` parses nothing, so any byte string is a valid - blob, and blob and constant addresses share one un-domain-separated - blake3 space. -/ -def bothUsedTarget : Ixon.Env × Address := Id.run do - let (env, badAddr) := storeAt {} illTypedConst - -- Seed the dependency's own serialized bytes as a blob under its own - -- address: `verify_bytes_against` passes because it is the same byte - -- string. - let env := { env with blobs := env.blobs.insert badAddr (Ixon.ser illTypedConst) } - let target := defnConst .defn prop - (.letE (.lean false) prop (.nat 0) (.ref 0 #[])) #[] #[badAddr] univsZero - storeAt env target - -/-- A definition whose declared type is `String` and whose value is a - string literal over `bytes`. - - `refs[0]` is the real `String` constant (used as `Ref`, so the walk - checks it) and `refs[1]` is the literal's blob (used as `Str`, so it - is a payload, not a walk target). Conversion wraps the blob in - `KLiteral.Str` and `k_infer_lit` types it `String` unconditionally, - so nothing on this path ever looks at the bytes. -/ -def strLiteralConst (strAddr blobAddr : Address) : Ixon.Constant := - defnConst .defn (.ref 0 #[]) (.str 1) #[] #[strAddr, blobAddr] #[] - -/-- Env carrying `bytes` as a blob plus a definition asserting it is a - `String`, over a base env that supplies the real `String` constant. -/ -def strLiteralTarget (base : Ixon.Env) (strAddr : Address) - (bytes : ByteArray) : Ixon.Env × Address := - let blobAddr := Address.blake3 bytes - let env := { base with blobs := base.blobs.insert blobAddr bytes } - storeAt env (strLiteralConst strAddr blobAddr) - -/-- A mutual block with `n` trivially well-typed members, plus the - projection wrapper for each so `get_ci` can resolve them. - - Each member is `Sort 0 : Sort 1`, i.e. `Prop : Type`, which is - well-typed, so the whole block must check. With `n > 256` this - exercises the width of the synthesized projection index: the member - address is derived by serializing `DPrj{idx, block}`, so `idx` has to - survive the round trip at its full `u64` width. -/ -def mutsBlockOfSize (n : Nat) : Ixon.Env × Address := Id.run do - let member : Ixon.MutConst := .defn ⟨.defn, .safe, 0, .sort 1, .sort 0⟩ - let block : Ixon.Constant := - ⟨.muts (Array.replicate n member), #[], #[], #[.zero, .succ .zero]⟩ - let (env, blockAddr) := storeAt {} block - let mut e := env - for i in [:n] do - e := (storeAt e ⟨.dPrj ⟨i.toUInt64, blockAddr⟩, #[], #[], #[]⟩).1 - return (e, blockAddr) - -/-- A one-member mutual block, plus a definition referencing member 0 - either through its projection wrapper (`viaBlock := false`) or - through the BLOCK's own address (`viaBlock := true`). - - `get_ci` on a `Muts` constant falls back to its FIRST member's KCI - (`Ix/IxVM/Ingress.lean:150-153`), so if the second form checks, one - constant has two working addresses — the same aliasing the encoding - tricks buy, but reached through the resolver rather than the decoder. - - The reducibility hint is seeded under the BLOCK address because - `get_ci_muts_member` faults it from `muts_addr`, not from the - wrapper; without it the case would abort on a missing IO key and the - verdict would say nothing about aliasing. -/ -def blockAliasTarget (viaBlock : Bool) : Ixon.Env × Address := Id.run do - let member : Ixon.MutConst := .defn ⟨.defn, .safe, 0, .sort 1, .sort 0⟩ - let block : Ixon.Constant := - ⟨.muts #[member], #[], #[], #[.zero, .succ .zero]⟩ - let (env, blockAddr) := storeAt {} block - let (env, wrapperAddr) := storeAt env ⟨.dPrj ⟨0, blockAddr⟩, #[], #[], #[]⟩ - let env := { env with anonHints := env.anonHints.insert blockAddr .opaque } - let ref := if viaBlock then blockAddr else wrapperAddr - storeAt env - ⟨.defn ⟨.defn, .safe, 0, .sort 1, .ref 0 #[]⟩, #[], #[ref], - #[.zero, .succ .zero]⟩ - -/-! ### Member order of a mutual block - -The kernel checks a block's members in the order they are stored and does -not ask for any particular order. Lean's declarations are compiled in -their own order, and the order is part of the block's content: members -are reached by `IPrj{idx, block}` and recursors by member position, so -two orders of the same declarations are two different blocks with -different addresses, each checked on its own terms. Two members that are -equal up to the block's own renaming are likewise two members. -/ - -/-- Two structurally distinct inductives in one block, in one of the two - possible member orders. `A : Prop | mkA : A` has a nullary - constructor; `B : Prop | mkB : B → B` has a recursive field. - - `Rec` indices name member POSITIONS, so they are renumbered with the - swap — the two blocks are genuinely different constants, not a - permutation of one, and both must check. -/ -def twoIndcBlock (swap : Bool) : Ixon.Constant := - let posA : UInt64 := if swap then 1 else 0 - let posB : UInt64 := if swap then 0 else 1 - let indA : Ixon.Inductive := - ⟨false, 0, 0, 0, .sort 0, #[⟨false, 0, 0, 0, 0, .recur posA #[]⟩]⟩ - let indB : Ixon.Inductive := - ⟨false, 0, 0, 0, .sort 0, - #[⟨false, 0, 0, 0, 1, .leanAll (.recur posB #[]) (.recur posB #[])⟩]⟩ - let members : Array Ixon.MutConst := - if swap then #[.indc indB, .indc indA] else #[.indc indA, .indc indB] - ⟨.muts members, #[], #[], #[.zero]⟩ - -/-- Two inductives that are the same up to the block's own renaming: - `A : Prop | mkA : A` and `B : Prop | mkB : B`. Each constructor names - its own member, so the two records differ only in the `Rec` index of - that self-reference. Lean accepts such a block, so it must CHECK. -/ -def twinIndcBlock : Ixon.Constant := - let indA : Ixon.Inductive := - ⟨false, 0, 0, 0, .sort 0, #[⟨false, 0, 0, 0, 0, .recur 0 #[]⟩]⟩ - let indB : Ixon.Inductive := - ⟨false, 0, 0, 0, .sort 0, #[⟨false, 0, 0, 0, 0, .recur 1 #[]⟩]⟩ - ⟨.muts #[.indc indA, .indc indB], #[], #[], #[.zero]⟩ - -/-- A mutual pair whose first member has more constructors and fewer - indices than the second. `Q : Prop` has three constructors and no - indices; `P : Prop → Prop` has one constructor and one index. - `refs[0]` is `False`, used as `P`'s index argument. - - Legitimate, so it must CHECK: Lean forces mutual inductives to share - parameters and universes, not indices or constructor counts. Any code - that walks one member's constructors while resolving another's must - not index past the shorter list. -/ -def unevenCtorBlock (falseAddr : Address) : Ixon.Constant := - let pApp : Ixon.Expr := .app (.recur 1 #[]) (.ref 0 #[]) - let q1 : Ixon.Constructor := ⟨false, 0, 0, 0, 0, .recur 0 #[]⟩ - let q2 : Ixon.Constructor := - ⟨false, 0, 1, 0, 1, .leanAll pApp (.recur 0 #[])⟩ - let q3 : Ixon.Constructor := - ⟨false, 0, 2, 0, 1, .leanAll (.recur 0 #[]) (.recur 0 #[])⟩ - let p1 : Ixon.Constructor := - ⟨false, 0, 0, 0, 1, .leanAll (.recur 0 #[]) pApp⟩ - let indQ : Ixon.Inductive := ⟨false, 0, 0, 0, .sort 0, #[q1, q2, q3]⟩ - let indP : Ixon.Inductive := - ⟨false, 0, 0, 1, .leanAll (.sort 0) (.sort 0), #[p1]⟩ - ⟨.muts #[.indc indQ, .indc indP], #[], #[falseAddr], #[.zero]⟩ - -/-- Store a block whose members have `ctorCounts` constructors each, - plus every `IPrj`/`CPrj` wrapper, returning member 0's address. -/ -def storeMutsIndc (base : Ixon.Env) (block : Ixon.Constant) - (ctorCounts : Array Nat) : Ixon.Env × Address := Id.run do - let (env, blockAddr) := storeAt base block - let mut e := env - let mut target := blockAddr - for i in [:ctorCounts.size] do - let (e1, indAddr) := storeAt e ⟨.iPrj ⟨i.toUInt64, blockAddr⟩, #[], #[], #[]⟩ - e := e1 - for c in [:ctorCounts[i]!] do - e := (storeAt e ⟨.cPrj ⟨i.toUInt64, c.toUInt64, blockAddr⟩, - #[], #[], #[]⟩).1 - if i == 0 then target := indAddr - return (e, target) - -/-- Store a two-inductive block plus both members' projection wrappers, - returning member 0's inductive address as the claim target. -/ -def storeTwoIndc (base : Ixon.Env) (swap : Bool) : Ixon.Env × Address := - Id.run do - let (env, blockAddr) := storeAt base (twoIndcBlock swap) - let mut e := env - let mut target := blockAddr - for i in [:2] do - let (e1, indAddr) := storeAt e ⟨.iPrj ⟨i.toUInt64, blockAddr⟩, #[], #[], #[]⟩ - e := (storeAt e1 ⟨.cPrj ⟨i.toUInt64, 0, blockAddr⟩, #[], #[], #[]⟩).1 - if i == 0 then target := indAddr - return (e, target) - -/-- `theorem bad : False := bad`, written directly in Ixon. - - `Expr.recur 0` is the self-reference. `get_ci` hands a standalone - `Defn` a one-element `recur_addrs` whose only entry is the constant's - OWN address, and conversion erases `Rec` into an ordinary `Const`, so - the value becomes `Const(self)`. `k_infer` on a `Const` reads the - referenced constant's DECLARED type without checking it, and here the - referenced constant is the one being checked — whose declared type is - `False`. So the body typechecks against the type by citing itself. - - The ref-walk cannot save this: `const_idxs_expr` deliberately does - not follow `Rec`, and the target of the self-reference is the - constant already under check. Lean's own kernel forbids exactly this - by checking a definition in an environment that does not yet contain - it, admitting self-reference only for `unsafe`. -/ -def selfReferentialTheorem (falseAddr : Address) : Ixon.Constant := - ⟨.defn ⟨.thm, .safe, 0, .ref 0 #[], .recur 0 #[]⟩, #[], #[falseAddr], #[]⟩ - -/-! ### Recursor rule right-hand sides - -`compare_rules` peels the binders off the STORED rule and uses that -term's own `Lam` domains as the local context for the def-eq against the -canonical reconstruction. Those domains are prover-authored and are never -checked, so they decide what the comparison's two sides infer to. - -Rather than hand-build a recursor — its declared type has to survive -`build_rec_type`'s def-eq, and constructor references inside a block are -circular with the block's own address — these take a REAL compiled block -and rewrite only a rule's right-hand side. Everything else stays exactly -as the compiler emitted it. -/ - -/-- The `Muts` block a projection wrapper points at. -/ -def blockOfWrapper (env : Ixon.Env) (wrapper : Address) : - Option (Address × Ixon.Constant) := do - let c ← env.getConst? wrapper - let blockAddr ← match c.info with - | .iPrj p | .cPrj p | .rPrj p | .dPrj p => some p.block - | _ => none - let block ← env.getConst? blockAddr - some (blockAddr, block) - -/-- A block carrying a recursor with at least two rules, chosen - deterministically by address so the fixture does not depend on hash - iteration order. Recursors do not necessarily share their inductive's - block, so this searches rather than following a wrapper. -/ -def findRecrBlock (env : Ixon.Env) : Option Ixon.Constant := Id.run do - let mut best : Option (Address × Ixon.Constant) := none - for (addr, lc) in env.consts do - if let some c := lc.get? then - -- A non-mutual recursor is a STANDALONE `Recr` constant, not a - -- `Muts` member; accept either shape. - -- Require every rule to be field-free. A rule with fields has a - -- body that APPLIES its minor premise, so retyping that binder to - -- a Prop makes it a non-function and the run aborts before the - -- comparison — which would mask the acceptance being probed. - let usable (r : Ixon.Recursor) : Bool := - r.rules.size ≥ 2 && r.rules.all (fun rule => rule.fields == 0) - let hasRules : Bool := match c.info with - | .recr r => usable r - | .muts members => members.any fun m => - match m with | .recr r => usable r | _ => false - | _ => false - if hasRules then - match best with - | none => best := some (addr, c) - | some (a, _) => if addr.hash.data < a.hash.data then best := some (addr, c) - return best.map (·.2) - -/-- Replace the outermost `n+1` binder DOMAINS of a rule right-hand side - with `dom`, keeping its body and binder count. The kernel peels - exactly these binders and adopts their domains as the context it - infers through. -/ -partial def retypeBinders (n : Nat) (dom : Ixon.Expr) : Ixon.Expr → Ixon.Expr - | .lam uses _ body => if n == 0 then .lam uses dom body - else .lam uses dom (retypeBinders (n - 1) dom body) - | e => e - -/-- Swap the right-hand sides of the recursor's first two rules, so each - constructor reduces to the other's branch — wrong under any reading. - When `retype` is given, also replace the outermost `nBinders` binder - DOMAINS of each rule with it. -/ -def corruptRecrRules (c : Ixon.Constant) (nBinders : Nat) - (retype : Option Ixon.Expr) : Ixon.Constant := - let corruptOne (r : Ixon.Recursor) : Ixon.Recursor := - if r.rules.size < 2 then r else - let a := r.rules[0]! - let b := r.rules[1]! - let swapped := - #[{ a with rhs := b.rhs }, { b with rhs := a.rhs }] - ++ r.rules.extract 2 r.rules.size - { r with rules := match retype with - | none => swapped - | some d => swapped.map fun rule => - { rule with rhs := retypeBinders nBinders d rule.rhs } } - match c.info with - | .recr r => { c with info := .recr (corruptOne r) } - | .muts members => - { c with info := .muts <| members.map fun m => - match m with - | .recr r => .recr (corruptOne r) - | other => other } - | _ => c - -/-! ### Recursor `motives`/`minors` arity metadata - -`compare_rules` reconstructs each canonical rule body and asserts it is -def-eq to the STORED rule body, and the declared recursor type is matched -against `build_rec_type`. Both derive their motive/minor counts from the -inductive block (`flat`), so they stay honest. But EVERY consumer uses -only the SUM `motives + minors` — the peel count, the major-spine -position, the type reconstruction — EXCEPT `minor_var` -(`Kernel/Check.lean:2573`), where `n_minors` ALONE selects which binder -each canonical body points at. IxVM never compares the prover's declared -`motives`/`minors` against the reconstruction; both references do -(`inductive.rs:4945`, `Ix/Tc/Inductive.lean:2346`, error "arity metadata -mismatch"). -/ - -/-- Replace the innermost (non-`lam`) body of a `lam` telescope, keeping - the binder count and every domain. -/ -partial def setLamBody (newBody : Ixon.Expr) : Ixon.Expr → Ixon.Expr - | .lam uses d b => .lam uses d (setLamBody newBody b) - | _ => newBody - -/-- Move all of `motives` into `minors` (sum preserved, so the peel count - and declared type are unchanged), then rewrite each FIELD-FREE rule's - body to the BVar the reconstruction now expects, - `minor_var = (minors' - 1) - ctorIdx`. Under the honest split every - body pointed at its own minor premise; under the forged split the - first rule's body points one binder further out — at the MOTIVE — so - `R mo m0 … c0` reduces to `mo`, i.e. `(I → Type) : Type`. Only - applies to a recursor whose rules are all nullary (`fields == 0`), so - the canonical body is a bare minor variable with no IH application. -/ -def forgeRecMetadata (c : Ixon.Constant) : Ixon.Constant := - let forgeOne (r : Ixon.Recursor) : Ixon.Recursor := - if r.rules.size < 2 || r.motives == 0 || r.rules.any (·.fields != 0) then r - else - let minors' : UInt64 := r.motives + r.minors - let rules' := (Array.range r.rules.size).map fun i => - let target : UInt64 := (minors' - 1) - i.toUInt64 - { r.rules[i]! with rhs := setLamBody (.var target) r.rules[i]!.rhs } - { r with motives := 0, minors := minors', rules := rules' } - match c.info with - | .recr r => { c with info := .recr (forgeOne r) } - | .muts members => - { c with info := .muts <| members.map fun m => - match m with - | .recr r => .recr (forgeOne r) - | other => other } - | _ => c - -/-! ### Byte-level encodings - -Every other fixture here is built from an `Ixon.Constant` VALUE and -addressed via `Ixon.ser`, which always emits canonical bytes — so no such -fixture can express a non-canonical ENCODING. These store hand-authored -bytes directly, which is what a prover actually controls. -/ - -/-- Store a hand-authored byte string as a constant at its own content - address. `addEntries` seeds channel 2 from `rawBytes`, so the kernel - faults exactly these bytes, blake3-verifies them against the key, and - parses them with the in-circuit parser. -/ -def storeRawAt (env : Ixon.Env) (bytes : ByteArray) : Ixon.Env × Address := - let addr := Address.blake3 bytes - ({ env with - consts := env.consts.insert addr - (Ixon.LazyConstant.ofSlice bytes 0 bytes.size) }, addr) - -/-- Replace the one-byte TagN0 at `off` with `encoding`. - - TagN is bijective, so no integer has a second encoding; what a reader - can still get wrong is a byte string the format does not define. The - two cases below use the two kinds there are. `0xC4 0x00 0x00` is code - 4, which has no rung: a reader that kept only the code's low two bits - would read rung 3 and the value 16512. `0xC3` and eight `0xFF` reach - 2^64 on the 8-byte rung: a reader that wrapped would read - 4311826559. Rust and the Lean host reject both, so a circuit that - accepted either would give one address a reading no host has. -/ -def tagN0At (bytes : ByteArray) (off : Nat) (encoding : Array UInt8) : - ByteArray := - bytes.extract 0 off ++ (⟨encoding⟩ : ByteArray) - ++ bytes.extract (off + 1) bytes.size - -/-- An axiom `_ : Prop`. Serializes as - `[0xD2][isUnsafe][lvls TagN0][typ…][sharing][refs][univs]`, so the - `lvls` TagN0 is at byte 2 — the field the rewrites above target, - `isUnsafe` is byte 1, and the type expression starts at byte 3. -/ -def propAxiom : Ixon.Constant := - ⟨.axio ⟨false, 0, .sort 0⟩, #[], #[], #[.zero]⟩ - -/-- `unsafe axiom _ : Prop`: the same constant outside a claim's theory, which - a typing claim types without the axiom policy (that declines a safe - one), so the encoding cases below rewrite its bytes and a rejection is - the encoding's alone. Byte 1, `isUnsafe`, is 1. -/ -def unsafePropAxiom : Ixon.Constant := - ⟨.axio ⟨true, 0, .sort 0⟩, #[], #[], #[.zero]⟩ - -/-! ### Encodings the format forbids and the circuit reads anyway - -A TagN4 header is `[flag:4][L][M][c:2]`; a value below 8 is the one byte -`flag * 16 + value`. The rewrites below are all well-formed TagN4 integers -carrying values the Rust reference rejects outright. Each yields a SECOND -address for a constant the circuit reads identically — never two readings of one -address, which would need a blake3 collision — so none is a false -theorem on its own. What they cost is the property every canonicality -argument here leans on: that the circuit's accepted language is the -format's. In particular `canon_addr_cmp` decides canonical `Muts` member -order by comparing external ref addresses, and an attacker who can mint -alternate addresses for one constant can steer that comparison. -/ - -/-- Prefix the expression at `off` with a zero-count binder telescope. - `0x80` is `Lam` with `size = 0`, `0x90` is `All`, `0x70` is `App`. - - `get_lam_telescope`/`get_all_telescope` return `get_expr(stream)` - unchanged at count 0, and `get_app_telescope` returns its function, - so each byte is a no-op prefix and the term is unchanged. Rust - rejects all three (`serialize.rs:501-530`). Chaining k of them gives - 3^k encodings of one expression — about 1.58 bits of address - grinding per byte. -/ -def zeroTelescopeAt (bytes : ByteArray) (off : Nat) (head : UInt8) : - ByteArray := - bytes.extract 0 off ++ (⟨#[head]⟩ : ByteArray) - ++ bytes.extract off bytes.size - -/-- Rewrite the leading `ConstantInfo` TagN4 so its size is - `variant + 0x100`, whose LOW byte is still the variant number. - - That size is rung 2, two bytes (`0xD8 0xFA` for variant 2). Were - `get_constant_info` to dispatch on `size[0]` alone, the circuit would - parse the variant; Rust matches the full `u64` and errors on anything - outside 0-7. -/ -def wideVariantTagN (bytes : ByteArray) (variant : UInt8) : ByteArray := - Ixon.runPut (Ixon.putTagN 4 0xD (variant.toUInt64 + 0x100)) - ++ bytes.extract 1 bytes.size - -/-- Set the byte at `off` — used to put a non-Bool value in a field the - format says is a `Bool`. -/ -def setByteAt (bytes : ByteArray) (off : Nat) (b : UInt8) : ByteArray := - bytes.extract 0 off ++ (⟨#[b]⟩ : ByteArray) - ++ bytes.extract (off + 1) bytes.size - -/-- Replace a one-byte expression at `off` with hand-authored expression - bytes. Used to wrap the host codec's strict-expression vectors in a real - hash-bound constant and drive them through the production Reveal path. -/ -def replaceOneByteExprAt (bytes : ByteArray) (off : Nat) - (expr : Array UInt8) : ByteArray := - bytes.extract 0 off ++ (⟨expr⟩ : ByteArray) - ++ bytes.extract (off + 1) bytes.size - -/-! ### Canonicality of computed Nat literals - -`klimbs_eq` — which backs `Nat.beq`, `Nat.decEq` and `literal_eq` — is a -raw limb-by-limb compare with no normalization, so it distinguishes two -`KLimbs` that denote the same natural. Any reducer that emits a -non-canonical literal therefore makes `Nat.beq` disagree with Lean. -/ - -/-- `theorem _ : Nat.beq (String.utf8ByteSize "") 0 = rhs := Eq.refl Bool rhs` - - Reduction of the left side is what the kernel has to get right; the - proof is `rfl`, so the declaration typechecks exactly when the kernel - reduces the equation's two sides to the same value. - - `refs[4]` is the empty blob, used both as the string literal `""` and - as the nat literal `0` — the same bytes read two ways, which is - exactly what the Expr context is for. -/ -def utf8SizeBeq (eqA boolA beqA sizeA blobA rhsA reflA : Address) : - Ixon.Constant := - let lhs : Ixon.Expr := - .app (.app (.ref 2 #[]) (.app (.ref 3 #[]) (.str 4))) (.nat 4) - let typ : Ixon.Expr := - .app (.app (.app (.ref 0 #[0]) (.ref 1 #[])) lhs) (.ref 5 #[]) - let val : Ixon.Expr := .app (.app (.ref 6 #[0]) (.ref 1 #[])) (.ref 5 #[]) - ⟨.defn ⟨.thm, .safe, 0, typ, val⟩, #[], - #[eqA, boolA, beqA, sizeA, blobA, rhsA, reflA], #[.succ .zero]⟩ - -/-! ### Native `SizeOf.sizeOf` reduction ignores the instance - -`try_reduce_size_of_unit` (`Ix/IxVM/Kernel/NatPrim.lean:354-374`) folds -`@SizeOf.sizeOf Unit _ x` to `Lit(Nat 1)` after inspecting ONLY the type -argument — the `[self : SizeOf Unit]` instance is never read. But -`SizeOf` is a one-field class, so its instance is prover-chosen: -`@SizeOf.sizeOf Unit ⟨fun _ => 5⟩ ()` is `5` in Lean (project the field, -apply). lean4lean unfolds the instance and computes `5`; the fold -answered `1`. No kernel here has the rule any more (`whnf.rs` and -`Ix/Tc/Whnf.lean` dropped it after IxVM; see -`Tests.Ix.Kernel.FastPathDefs`), and this case pins that the instance is -read. -/ - -/-- `theorem _ : @SizeOf.sizeOf Unit ⟨fun _ => payload⟩ () = rhs := Eq.refl Nat rhs` - - `refs`: 0=Eq, 1=Nat, 2=SizeOf.sizeOf, 3=SizeOf.mk, 4=Unit, - 5=Unit.unit, 6=Eq.refl, then the appended nat-literal blobs. Both the - instance's payload and the right-hand side are `Expr.nat` indices into - those blobs. All four polymorphic heads instantiate at `Sort 1` - (`Nat, Unit : Type`), so a single `univs = #[Succ Zero]` entry serves - every `#[0]`. -/ -def sizeOfUnitInstanceThm (eqA natA sizeOfA mkA unitA unitUnitA reflA : Address) - (blobRefs : Array Address) (payloadIdx rhsIdx : UInt64) : Ixon.Constant := - -- `@SizeOf.mk.{1} Unit (fun (_ : Unit) => Nat.lit payload)` - let inst : Ixon.Expr := - .app (.app (.ref 3 #[0]) (.ref 4 #[])) (.leanLam (.ref 4 #[]) (.nat payloadIdx)) - -- `@SizeOf.sizeOf.{1} Unit inst Unit.unit` - let lhs : Ixon.Expr := - .app (.app (.app (.ref 2 #[0]) (.ref 4 #[])) inst) (.ref 5 #[]) - let typ : Ixon.Expr := - .app (.app (.app (.ref 0 #[0]) (.ref 1 #[])) lhs) (.nat rhsIdx) - let val : Ixon.Expr := .app (.app (.ref 6 #[0]) (.ref 1 #[])) (.nat rhsIdx) - ⟨.defn ⟨.thm, .safe, 0, typ, val⟩, #[], - #[eqA, natA, sizeOfA, mkA, unitA, unitUnitA, reflA] ++ blobRefs, - #[.succ .zero]⟩ - -/-! ### Struct-eta on a semantically-Prop major - -`is_prop_type` (`Ix/IxVM/Kernel/DefEq.lean`) decides Prop by testing the -inferred sort for SEMANTIC zero (`level_equal(l, Zero)`), as all three -references do (`is_semantic_zero` / `isAlwaysZero`, lean4lean being the ground -truth). `convert_univ` is a raw conversion, so a prover can author -`Sort (max 0 0)`: semantically Prop, structurally `Max`. A structural test -would answer "not Prop" there, and `try_struct_eta_iota` would reduce a -recursor on a Prop-typed major where every reference leaves it stuck, the -reduction lean4#14613 was filed and fixed for. The equation it would prove -is true by proof irrelevance, so this pins a defense-in-depth layer rather -than a false theorem: both spellings are rejected. -/ - -/-- `J := Iff False False`, declared at `Sort sortUniv`. `Iff False False` - is `Prop`, and `level_equal` is semantic, so it typechecks for any - semantically-zero `sortUniv`; the DECLARED spelling is what - `is_prop_type` later reads verbatim. refs: 0=Iff, 1=False. -/ -def propAliasAtSort (iffA falseA : Address) (sortUniv : Ixon.Univ) : - Ixon.Constant := - defnConst .defn (.sort 0) - (.app (.app (.ref 0 #[]) (.ref 1 #[])) (.ref 1 #[])) - (refs := #[iffA, falseA]) (univs := #[sortUniv]) - -/-- `theorem _ (h : J) : @Iff.rec False False (fun _ => Nat) - (fun _ _ => 0) h = 0 := fun _ => Eq.refl Nat 0` - - `Iff` is a subsingleton (single ctor, both fields Prop), so it is - struct-like and large-eliminating — the motive may land in `Type`. - Struct-eta on the opaque `h : J` reduces `Iff.rec … h` to - `(fun _ _ => 0) (h.1) (h.2)`, i.e. `0`, so the `rfl` typechecks — but - only if `is_prop_type(J)` answered "not Prop". With `J : Sort 0` it - answers Prop and eta declines (the control); with `J : Sort (max 0 0)` - the semantic test answers Prop too, where a structural one would answer - "not Prop" and let eta fire. - refs: 0=Eq,1=Nat,2=Iff.rec,3=Iff,4=False,5=Eq.refl,6=J,7=nat-0 blob. -/ -def structEtaOnAlias (eqA natA iffRecA iffA falseA reflA jA zeroBlobA : - Address) : Ixon.Constant := - let iffFF : Ixon.Expr := .app (.app (.ref 3 #[]) (.ref 4 #[])) (.ref 4 #[]) - let motiveE : Ixon.Expr := .leanLam iffFF (.ref 1 #[]) - let ffArrow : Ixon.Expr := .leanAll (.ref 4 #[]) (.ref 4 #[]) - let minorE : Ixon.Expr := .leanLam ffArrow (.leanLam ffArrow (.nat 7)) - -- `@Iff.rec.{1} False False motive minor h`, with `h` the `∀`-bound BVar. - let lhs : Ixon.Expr := - .app (.app (.app (.app (.app (.ref 2 #[0]) (.ref 4 #[])) (.ref 4 #[])) - motiveE) minorE) (.var 0) - let eqE : Ixon.Expr := - .app (.app (.app (.ref 0 #[0]) (.ref 1 #[])) lhs) (.nat 7) - let typ : Ixon.Expr := .leanAll (.ref 6 #[]) eqE - let val : Ixon.Expr := - .leanLam (.ref 6 #[]) (.app (.app (.ref 5 #[0]) (.ref 1 #[])) (.nat 7)) - ⟨.defn ⟨.thm, .safe, 0, typ, val⟩, #[], - #[eqA, natA, iffRecA, iffA, falseA, reflA, jA, zeroBlobA], #[.succ .zero]⟩ - -/-! ### Nested-inductive positivity - -Two single-inductive blocks in `Prop`. The outer one takes the inner -applied to ITSELF as its constructor's field, so whether the outer is -positive depends entirely on where its own type lands inside the inner -one's constructor — i.e. on the nested check substituting the parameter -arguments before looking. -/ - -/-- A one-inductive block `P (α : Prop) : Prop | mk : field → P α`, where - `field` is written under two binders (`α`, then the field itself). -/ -def paramInductiveBlock (refs : Array Address) (field : Ixon.Expr) : - Ixon.Constant := - let mkTyp : Ixon.Expr := - .leanAll (.sort 0) (.leanAll field (.app (.recur 0 #[]) (.var 1))) - let ind : Ixon.Inductive := - ⟨false, 0, 1, 0, .leanAll (.sort 0) (.sort 0), #[⟨false, 0, 0, 1, 1, mkTyp⟩]⟩ - ⟨.muts #[.indc ind], #[], refs, #[.zero]⟩ - -/-- `Host : Prop | mk : Inner Host → Host`, where `Inner` is `refs[0]`. -/ -def hostBlock (innerAddr : Address) : Ixon.Constant := - let mkTyp : Ixon.Expr := - .leanAll (.app (.ref 0 #[]) (.recur 0 #[])) (.recur 0 #[]) - let ind : Ixon.Inductive := - ⟨false, 0, 0, 0, .sort 0, #[⟨false, 0, 0, 0, 1, mkTyp⟩]⟩ - ⟨.muts #[.indc ind], #[], #[innerAddr], #[.zero]⟩ - -/-! ### Uniformity of recursive occurrences in constructor fields - -`check_ctor_return_type` inspects a constructor's RETURN type closely: -the spine length, the parameter arguments as the expected de Bruijn -binders, the universe arguments, and index arguments that do not mention -the block. `check_positivity_aug` inspects a recursive occurrence in a -FIELD not at all — it accepts on head identity alone -(`Kernel/Check.lean:628-630`), discarding the spine and, via the `_` in -the `Const` pattern, the universe arguments too. - -Lean requires the same of every occurrence, historically in -`is_valid_ind_app` and explicitly since #14582's `check_uniform_params` -and `check_ind_app_idxs`. The two cases below are the shapes those -guards exist for. -/ - -/-- `K : Prop → Prop` with `params = 0, indices = 1`, one constructor - `K.mk : K fieldIndex → K False`. `refs[0]` is `False`. - - With `fieldIndex := K False` the recursive occurrence's INDEX - mentions the datatype being declared — lean4 #2125. The return type's - index is plain `False`, so `check_ctor_return_type`'s index check - (which only ever sees the return type) has nothing to object to. -/ -def indexRecBlock (falseAddr : Address) (fieldIndex : Ixon.Expr) : - Ixon.Constant := - let kFalse : Ixon.Expr := .app (.recur 0 #[]) (.ref 0 #[]) - let mkTyp : Ixon.Expr := .leanAll (.app (.recur 0 #[]) fieldIndex) kFalse - let ind : Ixon.Inductive := - ⟨false, 0, 0, 1, .leanAll (.sort 0) (.sort 0), #[⟨false, 0, 0, 0, 1, mkTyp⟩]⟩ - ⟨.muts #[.indc ind], #[], #[falseAddr], #[.zero]⟩ - -/-- Store a single-inductive block plus the projection wrappers `get_ci` - resolves its member and constructor through. Returns the env and the - inductive's wrapper address. -/ -def storeInductive (env : Ixon.Env) (block : Ixon.Constant) : - Ixon.Env × Address := Id.run do - let (env, blockAddr) := storeAt env block - let (env, indAddr) := storeAt env ⟨.iPrj ⟨0, blockAddr⟩, #[], #[], #[]⟩ - let (env, _) := storeAt env ⟨.cPrj ⟨0, 0, blockAddr⟩, #[], #[], #[]⟩ - return (env, indAddr) - -/-- `Host` over an inner inductive whose constructor field is `innerField` - (written under the inner's own two binders). Returns the env and - `Host`'s wrapper address. -/ -def nestedHost (base : Ixon.Env) (innerRefs : Array Address) - (innerField : Ixon.Expr) : Ixon.Env × Address := - let (env, innerAddr) := - storeInductive base (paramInductiveBlock innerRefs innerField) - storeInductive env (hostBlock innerAddr) - -/-! ### Self-reference through the safety bit - -`get_ci` hands a STANDALONE definition a self-`Rec` slot exactly when its -safety is not `Safe` (`Ix/IxVM/Ingress.lean:114-120`). That guard is what -stops a constant discharging its own declared type: `Rec` converts to a -plain `Const`, and `k_infer` reads a `Const`'s declared type without -checking it, so a constant able to name itself proves whatever it claims. - -Two ways past it, below. Both keep the shape of -`self-referential-theorem-proves-false` — which ships `⟨.thm, .safe⟩` -and is correctly rejected — and change one wire bit. -/ - -/-- `bad : typ := bad`, with `kind` and `safety` chosen independently. - - They are independent bytes on the wire: `unpack_def_kind_safety` - (`Ix/IxVM/IxonDeserialize.lean:391-403`) admits all nine - combinations of the packed `kind * 4 + safety`. So `safety` can be - picked to open the recur slot while `kind` is picked to keep the - constant classified Safe — `convert_definition` - (`Ix/IxVM/Convert.lean:214-222`) drops `safety` outright on the - `Theorem` branch and maps `Partial` to "not unsafe" on the `Opaque` - one. -/ -def selfRefDefn (kind : Ix.DefKind) (safety : Ix.DefinitionSafety) - (falseAddr : Address) : Ixon.Constant := - ⟨.defn ⟨kind, safety, 0, .ref 0 #[], .recur 0 #[]⟩, #[], #[falseAddr], #[]⟩ - -/-- A one-member mutual block holding a `Safe` definition whose value is - `Rec 0` — itself, via the block's own projection wrapper. - - `build_recur_addrs` (`Ix/IxVM/Ingress.lean:342-355`) gives every - member a peer slot with no safety test, and `get_ci_dprj` (`:164-179`) - hands that list straight to `convert_definition`. The `Safe ⇒ no self - slot` rule exists only on the standalone path, so the same - `theorem bad : False := bad` walks through unmodified — this fixture - does not even need to touch the safety bit. -/ -def selfRefMutsBlock (falseAddr : Address) : Ixon.Constant := - ⟨.muts #[.defn ⟨.defn, .safe, 0, .ref 0 #[], .recur 0 #[]⟩], - #[], #[falseAddr], #[]⟩ - -/-- Store the block plus the `DPrj` wrapper `Rec 0` resolves to. The - wrapper's address is `blake3` of `DPrj{0, block}` serialized, which - is exactly what `projection_addr` recomputes in-circuit, so the - self-edge closes without an address cycle. -/ -def selfRefMuts (base : Ixon.Env) (falseAddr : Address) : - Ixon.Env × Address := - let (env, blockAddr) := storeAt base (selfRefMutsBlock falseAddr) - storeAt env ⟨.dPrj ⟨0, blockAddr⟩, #[], #[], #[]⟩ - -/-! ### Positivity through a block-local definition - -`check_positivity_aug` (`Ix/IxVM/Kernel/Check.lean:612-616`) returns -immediately unless the field's domain SYNTACTICALLY mentions a block -inductive, and `caddr_is_peer` (`:534-541`) counts a `Const` only when -its constant-info is an `Induct`. A `Const` resolving to a definition -scores zero, so `whnf` is never reached and a negative occurrence hiding -one delta-step away is never seen. - -Lean is safe from this by declaration order — a definition cannot mention -an inductive declared after it — and content-addressing normally forbids -the cycle too, since each address would have to hash the other. A `Muts` -block dissolves both: `MutConst` admits `Defn` and `Indc` in one list, -and their peer addresses are both derived from the block address alone. -Nothing rejects the mixture. -/ - -/-- `Neg : Prop := negBody` and `Bad : Prop | mk : field → Bad`, as two - members of one block. Inside it `Rec 0` is `Neg` and `Rec 1` is - `Bad`, so `negBody` may mention `Bad` and `field` may mention `Neg`. - `refs[0]` is `False`. -/ -def defnIndBlock (falseAddr : Address) (negBody field : Ixon.Expr) : - Ixon.Constant := - let ind : Ixon.Inductive := - ⟨false, 0, 0, 0, .sort 0, #[⟨false, 0, 0, 0, 1, .leanAll field (.recur 1 #[])⟩]⟩ - ⟨.muts #[.defn ⟨.defn, .safe, 0, .sort 0, negBody⟩, .indc ind], - #[], #[falseAddr], #[.zero]⟩ - -/-- Store the block plus every wrapper `get_ci` resolves through, and - return the INDUCTIVE's address — the subject of the claim, since it - is the inductive's acceptance that is at stake. -/ -def storeDefnInd (base : Ixon.Env) (block : Ixon.Constant) : - Ixon.Env × Address := Id.run do - let (env, blockAddr) := storeAt base block - let (env, _) := storeAt env ⟨.dPrj ⟨0, blockAddr⟩, #[], #[], #[]⟩ - let (env, indAddr) := storeAt env ⟨.iPrj ⟨1, blockAddr⟩, #[], #[], #[]⟩ - let (env, _) := storeAt env ⟨.cPrj ⟨1, 0, blockAddr⟩, #[], #[], #[]⟩ - return (env, indAddr) - -/-- `Bad → False`, written with `Bad` as the block's second member. -/ -def badArrowFalse : Ixon.Expr := .leanAll (.recur 1 #[]) (.ref 0 #[]) - -/-- `Bad : Prop | mk : field → Bad` alone in its block, so the - mixed-block ban does not apply and the verdict is strict - positivity's alone. Here `Bad` is `Rec 0`. -/ -def indOnlyBlock (falseAddr : Address) (field : Ixon.Expr) : Ixon.Constant := - let ind : Ixon.Inductive := - ⟨false, 0, 0, 0, .sort 0, #[⟨false, 0, 0, 0, 1, .leanAll field (.recur 0 #[])⟩]⟩ - ⟨.muts #[.indc ind], #[], #[falseAddr], #[.zero]⟩ - -def cases (ctx : Ix.ClaimContext) (base : Ixon.Env) (strAddr falseAddr : Address) - (eqA boolA beqA sizeA trueA falseBoolA reflA : Address) - (natA sizeOfSizeOfA sizeOfMkA unitA unitUnitA : Address) - (iffA iffRecA : Address) : - Array ExploitCase := Id.run do - -- `""` and `0` share one blob: both are the empty byte string. - let emptyBlob : ByteArray := ⟨#[]⟩ - let blobA := Address.blake3 emptyBlob - let blobEnv := { base with blobs := base.blobs.insert blobA emptyBlob } - let (beqTrueEnv, beqTrueAddr) := - storeAt blobEnv (utf8SizeBeq eqA boolA beqA sizeA blobA trueA reflA) - let (beqFalseEnv, beqFalseAddr) := - storeAt blobEnv (utf8SizeBeq eqA boolA beqA sizeA blobA falseBoolA reflA) - -- Recursor-rule fixtures, built from `Bool`'s real compiled block: - -- two nullary constructors, so each rule's binders are exactly - -- (motive, minor, minor) and swapping the two right-hand sides makes - -- each constructor reduce to the other's branch. - let recrCases : Array ExploitCase := - match findRecrBlock base with - | none => - -- Never silently skip: no recursor block means the fixture is not - -- exercising `compare_rules` at all. - #[{ name := "recursor-fixture-found-no-recursor-block" - intent := "the fixture must locate a recursor with >= 2 rules" - env := base, claim := .check ctx falseAddr none - expectAccept := true }] - | some block => - -- Both variants carry the same extended refs table, so the only - -- difference between them is the binder domains. - let refIdx := block.refs.size.toUInt64 - let block := { block with refs := block.refs.push falseAddr } - let mkFrom (corrupted : Ixon.Constant) : Ixon.Env × Address := Id.run do - let (env, blockAddr) := storeAt base corrupted - let mut e := env - for i in [:2] do - e := (storeAt e ⟨.iPrj ⟨i.toUInt64, blockAddr⟩, #[], #[], #[]⟩).1 - e := (storeAt e ⟨.rPrj ⟨i.toUInt64, blockAddr⟩, #[], #[], #[]⟩).1 - e := (storeAt e ⟨.cPrj ⟨i.toUInt64, 0, blockAddr⟩, #[], #[], #[]⟩).1 - e := (storeAt e ⟨.cPrj ⟨i.toUInt64, 1, blockAddr⟩, #[], #[], #[]⟩).1 - return (e, blockAddr) - let (honestEnv, honestAddr) := mkFrom (corruptRecrRules block 2 none) - let (doctoredEnv, doctoredAddr) := - mkFrom (corruptRecrRules block 2 (some (.ref refIdx #[]))) - let (forgedEnv, forgedAddr) := mkFrom (forgeRecMetadata block) - #[ - -- CONTROL: swapped rules with the compiler's own binder domains. - -- The comparison then infers through honest types and the - -- mismatch is caught. - { name := "control-swapped-recursor-rules" - intent := "a recursor whose two rules are swapped, with honest \ - binder domains — must be rejected" - env := honestEnv, claim := .check ctx honestAddr none }, - -- The same swap, with every peeled binder domain replaced by a - -- Prop. `compare_rules` adopts those domains as the context it - -- infers through, so both sides type as that Prop and proof - -- irrelevance accepts any body. - { name := "recursor-rule-rhs-doctored-binder-domains" - intent := "a recursor accepted with swapped computation rules, \ - because the rule's own binder domains chose the context the \ - comparison infers through" - env := doctoredEnv, claim := .check ctx doctoredAddr none }, - -- EXPLOIT: forge the motives/minors SPLIT (sum preserved) and - -- shift each rule body to the binder the reconstruction expects - -- under that split. The declared type still matches - -- `build_rec_type` (which reads the honest counts from the - -- block), and `compare_rules` reconstructs the SAME shifted - -- bodies, so the def-eq passes — but the reduction now fires the - -- first rule against the motive instead of its minor. References - -- reject via the arity-metadata equality check IxVM omits. - { name := "recursor-motives-minors-split-forged" - intent := "a recursor accepted with a forged motives/minors \ - split: `minor_var` reads `minors` alone, so `R mo m0 m1 c0` \ - reduces to `mo` — an impredicative `(I → Type) : Type`, from \ - which Girard yields False" - env := forgedEnv, claim := .check ctx forgedAddr none } - ] - let axiomBytes := Ixon.ser unsafePropAxiom - let (canonBytesEnv, canonBytesAddr) := storeRawAt base axiomBytes - let (badCodeEnv, badCodeAddr) := - storeRawAt base (tagN0At axiomBytes 2 #[0xC4, 0x00, 0x00]) - let (overflowEnv, overflowAddr) := - storeRawAt base (tagN0At axiomBytes 2 (#[0xC3] ++ Array.replicate 8 0xFF)) - -- The type expression starts at byte 3; each prefix is a no-op. - let (zeroLamEnv, zeroLamAddr) := - storeRawAt base (zeroTelescopeAt axiomBytes 3 0x80) - let (zeroAllEnv, zeroAllAddr) := - storeRawAt base (zeroTelescopeAt axiomBytes 3 0x90) - -- `.axio` is variant 2, so the wide size is 0x0102 = 258. - let (wideVariantEnv, wideVariantAddr) := - storeRawAt base (wideVariantTagN axiomBytes 2) - -- Byte 1 is the axiom's `isUnsafe`, which the format says is a Bool. - let (nonBoolEnv, nonBoolAddr) := - storeRawAt base (setByteAt axiomBytes 1 2) - -- Mirror `Tests.Ix.Ixon.strictExprUnits` below the host codec: Reveal - -- parses the committed constant but performs no typechecking, so rejection - -- is attributable solely to the circuit's v2 wire grammar. - let rawExpr (expr : Array UInt8) : Ixon.Env × Address := - storeRawAt base (replaceOneByteExprAt axiomBytes 3 expr) - let (nestedAppEnv, nestedAppAddr) := - rawExpr #[0x71, 0x71, 0x10, 0x11, 0x12] - let (nestedLamEnv, nestedLamAddr) := - rawExpr #[0x81, 0x07, 0x00, 0x81, 0x07, 0x00, 0x10] - let (nestedAllEnv, nestedAllAddr) := - rawExpr #[0x91, 0x17, 0x00, 0x91, 0x17, 0x00, 0x10] - let (badLetFlagEnv, badLetFlagAddr) := - rawExpr #[0xA4, 0x07, 0x00, 0x00, 0x00] - let (badLamModeEnv, badLamModeAddr) := - rawExpr #[0x81, 0x10, 0x00, 0x10] - let (badAllModeEnv, badAllModeAddr) := - rawExpr #[0x91, 0x40, 0x00, 0x10] - -- `Inner α | mk : α → Inner α` — α strictly positive. `Host` is fine. - let (posEnv, posAddr) := nestedHost base #[] (.var 0) - -- `Inner α | mk : (α → False) → Inner α` — α NEGATIVE. Substituting - -- `α := Host` turns Host's field into `(Host → False) → …`, so `Host` - -- must be rejected. - let (negEnv, negAddr) := - nestedHost base #[falseAddr] (.leanAll (.var 0) (.ref 0 #[])) - -- `I α | mk : I α → I α` — the recursive field's parameter argument is - -- the declared parameter, which is what uniformity asks for. - let (uniformFieldEnv, uniformFieldAddr) := - storeInductive base (paramInductiveBlock #[] (.app (.recur 0 #[]) (.var 0))) - -- `I α | mk : I False → I α` — same shape, but the occurrence is at - -- `False` rather than at `α`. - let (nonUniformFieldEnv, nonUniformFieldAddr) := - storeInductive base - (paramInductiveBlock #[falseAddr] (.app (.recur 0 #[]) (.ref 0 #[]))) - -- `K : Prop → Prop | mk : K False → K False` — the occurrence's index - -- is an ordinary constant. - let (uniformIndexEnv, uniformIndexAddr) := - storeInductive base (indexRecBlock falseAddr (.ref 0 #[])) - -- `K | mk : K (K False) → K False` — the occurrence's index mentions K. - let (selfIndexEnv, selfIndexAddr) := - storeInductive base - (indexRecBlock falseAddr (.app (.recur 0 #[]) (.ref 0 #[]))) - let (viaWrapperEnv, viaWrapperAddr) := blockAliasTarget (viaBlock := false) - let (viaBlockEnv, viaBlockAddr) := blockAliasTarget (viaBlock := true) - let (unevenEnv, unevenAddr) := - storeMutsIndc base (unevenCtorBlock falseAddr) #[3, 1] - let (orderAEnv, orderAAddr) := storeTwoIndc base (swap := false) - let (orderBEnv, orderBAddr) := storeTwoIndc base (swap := true) - let (twinEnv, twinAddr) := storeMutsIndc base twinIndcBlock #[1, 1] - let (selfRefEnv, selfRefAddr) := storeAt base (selfReferentialTheorem falseAddr) - -- Same shape as `selfReferentialTheorem`, one wire bit apart. - let (thmUnsafeEnv, thmUnsafeAddr) := - storeAt base (selfRefDefn .thm .unsaf falseAddr) - let (opaqPartEnv, opaqPartAddr) := - storeAt base (selfRefDefn .opaq .part falseAddr) - let (mutsSelfEnv, mutsSelfAddr) := selfRefMuts base falseAddr - -- Pure inductive blocks, exercising strict positivity with nothing - -- structural in the way: `mk : False → Bad` is positive, - -- `mk : (Bad → False) → Bad` is not. - let (posIndEnv, posIndAddr) := - storeInductive base (indOnlyBlock falseAddr (.ref 0 #[])) - let (directNegEnv, directNegAddr) := - storeInductive base - (indOnlyBlock falseAddr (.leanAll (.recur 0 #[]) (.ref 0 #[]))) - -- Mixed Defn+Indc blocks. The first is benign — `Neg := False`, so the - -- field `Neg → Bad` is positive however you unfold it — and pins that - -- the ban is on the SHAPE, not on the badness. - let (benignMixedEnv, benignMixedAddr) := - storeDefnInd base (defnIndBlock falseAddr (.ref 0 #[]) (.recur 0 #[])) - -- The second hides `Bad → False` one delta-step away, behind the - -- block's own definition member. - let (hiddenNegEnv, hiddenNegAddr) := - storeDefnInd base (defnIndBlock falseAddr badArrowFalse (.recur 0 #[])) - let (smallBlockEnv, smallBlockAddr) := mutsBlockOfSize 2 - let (bigBlockEnv, bigBlockAddr) := mutsBlockOfSize 257 - -- 0xFF can never appear in well-formed UTF-8; `String::from_utf8` - -- rejects it, and so must the kernel. - let (badUtf8Env, badUtf8Addr) := - strLiteralTarget base strAddr ⟨#[0xFF]⟩ - let (okUtf8Env, okUtf8Addr) := - strLiteralTarget base strAddr ⟨#[0x68, 0x69]⟩ - -- Well-formed UTF-8 that is not a Unicode scalar value: the surrogate - -- U+D800 in the three-byte form, U+110000 in the four-byte form, and a - -- four-byte leader from 0xF5 up. `String::from_utf8` rejects all three. - -- Accepting one would also be inconsistent: the literal's `String.ofList` - -- expansion has `Char.ofNat 55296`, which is `'\0'` (one byte), while - -- the native `String.utf8ByteSize` reads the literal's three bytes. - let (surrogateEnv, surrogateAddr) := - strLiteralTarget base strAddr ⟨#[0xED, 0xA0, 0x80]⟩ - let (aboveMaxEnv, aboveMaxAddr) := - strLiteralTarget base strAddr ⟨#[0xF4, 0x90, 0x80, 0x80]⟩ - let (leaderF5Env, leaderF5Addr) := - strLiteralTarget base strAddr ⟨#[0xF5, 0x80, 0x80, 0x80]⟩ - -- The scalar values next to those ranges: U+D7FF, U+E000 and U+10FFFF. - let (scalarEdgesEnv, scalarEdgesAddr) := - strLiteralTarget base strAddr - ⟨#[0xED, 0x9F, 0xBF, 0xEE, 0x80, 0x80, 0xF4, 0x8F, 0xBF, 0xBF]⟩ - let (badEnv, badAddr) := storeAt {} illTypedConst - let (plainEnv, plainAddr) := dependentTarget (deadSharing := false) - let (deadEnv, deadAddr) := dependentTarget (deadSharing := true) - let (bothEnv, bothAddr) := bothUsedTarget - -- `SizeOf.sizeOf Unit ()`: nat-literal blobs for the - -- instance payload (5) and the claimed result (1). A one-byte LE - -- magnitude decodes to the canonical `KLimbs` via `bytes_to_limbs`. - let blob1 : ByteArray := ⟨#[0x01]⟩ - let blob5 : ByteArray := ⟨#[0x05]⟩ - let blob1A := Address.blake3 blob1 - let blob5A := Address.blake3 blob5 - let sizeOfEnv := { base with - blobs := (base.blobs.insert blob1A blob1).insert blob5A blob5 } - -- refs append order: [..7 consts.., blob1A@7, blob5A@8]. - let blobRefs : Array Address := #[blob1A, blob5A] - let (sizeOfExploitEnv, sizeOfExploitAddr) := storeAt sizeOfEnv - (sizeOfUnitInstanceThm eqA natA sizeOfSizeOfA sizeOfMkA unitA unitUnitA - reflA blobRefs (payloadIdx := 8) (rhsIdx := 7)) - let (sizeOfControlEnv, sizeOfControlAddr) := storeAt sizeOfEnv - (sizeOfUnitInstanceThm eqA natA sizeOfSizeOfA sizeOfMkA unitA unitUnitA - reflA blobRefs (payloadIdx := 7) (rhsIdx := 7)) - -- Struct-eta: `J := Iff False False` declared at two Prop spellings. - -- The nat `0` is the empty blob (shared with `bytes_to_limbs`). - let etaZeroBlob : ByteArray := ⟨#[]⟩ - let etaZeroBlobA := Address.blake3 etaZeroBlob - let etaBase := { base with blobs := base.blobs.insert etaZeroBlobA etaZeroBlob } - let mkEta (sortUniv : Ixon.Univ) : Ixon.Env × Address := Id.run do - let (env, jA) := storeAt etaBase (propAliasAtSort iffA falseAddr sortUniv) - storeAt env - (structEtaOnAlias eqA natA iffRecA iffA falseAddr reflA jA etaZeroBlobA) - -- CONTROL spelling `Sort 0`: `is_prop_type` says Prop, eta declines, - -- the `rfl` fails to typecheck, so the kernel rejects (as it must). - let (etaCtrlEnv, etaCtrlAddr) := mkEta .zero - -- `Sort (max 0 0)`: semantically the same Prop, which the semantic test - -- sees, so eta declines and the kernel rejects here too; a structural - -- test would let eta fire where every reference leaves the recursor stuck. - let (etaExploitEnv, etaExploitAddr) := mkEta (.max .zero .zero) - let selfTree := (Ix.AssumptionTree.canonical #[badAddr]).get! - let selfTrees : Std.HashMap Address Ix.AssumptionTree := - ({} : Std.HashMap Address Ix.AssumptionTree).insert selfTree.root selfTree - -- a well-formed tree whose every slot is padding: no leaf - let emptyTree : Ix.AssumptionTree := .node .padding .padding - let emptyTrees : Std.HashMap Address Ix.AssumptionTree := - ({} : Std.HashMap Address Ix.AssumptionTree).insert emptyTree.root emptyTree - #[ - -- CONTROL: the smuggled constant is genuinely ill-typed. If this - -- ever passes, the exploit below proves nothing. - { name := "control-ill-typed-dep-alone" - intent := "`Prop : Prop` — a definition whose value's type is \ - `Sort 1`, not its declared `Sort 0`" - env := badEnv, claim := .check ctx badAddr none }, - -- CONTROL: without the trick the ref-walk reaches the dependency - -- and rejects. Differs from the exploit ONLY in `sharing`. - { name := "control-dep-walked-without-dead-sharing" - intent := "a definition whose dependency is ill-typed, with \ - nothing suppressing the ref-walk" - env := plainEnv, claim := .check ctx plainAddr none }, - -- EXPLOIT: one dead `sharing` entry marks the dependency's refs - -- index as a blob payload, so the walk skips it. The kernel then - -- accepts a constant whose transitive closure is ill-typed. - { name := "dead-sharing-entry-suppresses-ref-walk" - intent := "a definition accepted as well-typed while its \ - transitive closure contains an ill-typed constant that was \ - never checked" - env := deadEnv, claim := .check ctx deadAddr none }, - -- The same dependency reached through an index used as BOTH a `Nat` - -- literal and a `Ref`. `refs` is one index space and the entries are - -- deduplicated by address, so the two uses can share an index; under - -- the old blob-exclusion rule the `Nat` use would have suppressed the - -- `Ref` walk. Rejected, though by abort rather than by the type - -- error: the positive rule admits the index, and treating one address - -- as both a constant and a blob payload trips a channel fault first. - -- That is the safe direction — an abort only costs a dishonest prover. - { name := "index-used-as-both-nat-and-ref" - intent := "a definition whose ill-typed dependency is hidden \ - behind an index that also carries a Nat literal" - env := bothEnv, claim := .check ctx bothAddr none }, - -- CONTROL: the same shape with the CANONICAL `SizeOf Unit` value. - -- The instance returns 1, which matches IxVM's hardcoded fold, so - -- both IxVM and Lean accept — this proves the term is well-formed and - -- the native fold fires, isolating the exploit to the payload byte. - { name := "control-sizeof-unit-canonical-value" - intent := "`@SizeOf.sizeOf Unit ⟨fun _ => 1⟩ () = 1` — true in \ - Lean and folded to 1 by the kernel, which must be accepted" - env := sizeOfControlEnv, claim := .check ctx sizeOfControlAddr none - expectAccept := true }, - -- EXPLOIT: `SizeOf` is a one-field class, so the instance is - -- prover-chosen. `@SizeOf.sizeOf Unit ⟨fun _ => 5⟩ ()` is 5 in Lean - -- (project the field, apply `()`), but `try_reduce_size_of_unit` - -- reads only the TYPE argument and folds to 1, so `… = 1` typechecks - -- by rfl. lean4lean unfolds the instance and rejects. - { name := "sizeof-unit-ignores-instance" - intent := "`@SizeOf.sizeOf Unit ⟨fun _ => 5⟩ () = 1` accepted by \ - rfl — a false equation, since projecting the prover's instance \ - gives 5, not the kernel's hardcoded 1" - env := sizeOfExploitEnv, claim := .check ctx sizeOfExploitAddr none }, - -- CONTROL: the same theorem with `J : Sort 0` (syntactic `Zero`). - -- `is_prop_type` returns 1, struct-eta declines, the recursor stays - -- stuck and the `rfl` fails to typecheck — the kernel MUST reject, - -- proving the fixture reaches the struct-eta guard. - { name := "control-struct-eta-syntactic-prop-declines" - intent := "`Iff.rec … h = 0` over `h : (J : Sort 0)` — a correct \ - kernel leaves the recursor stuck, so the rfl must be rejected" - env := etaCtrlEnv, claim := .check ctx etaCtrlAddr none }, - -- `J : Sort (max 0 0)` is the SAME Prop semantically. `is_prop_type` - -- tests semantic zero (`level_equal(l, Zero)`), as every reference does, - -- so struct-eta declines and the rfl is rejected. A structural `Zero` - -- test would let struct-eta fire and accept it; the equation is true - -- (proof irrelevance), so this pins the guard, not a false theorem. - { name := "struct-eta-fires-on-semantic-prop" - intent := "`Iff.rec … h = 0` over `h : (J : Sort (max 0 0))` \ - accepted via struct-eta on a Prop-typed major — the reduction \ - lean4#14613 fixed, reachable if `is_prop_type` tested \ - structural rather than semantic zero" - env := etaExploitEnv, claim := .check ctx etaExploitAddr none }, - -- Assumptions waive out-of-shard dependency checks, never the check of - -- a claim's own target or owned subjects (`Eval`, `Check`, and `CheckEnv`). - -- Allowing a `Check` or `CheckEnv` claim to assume its own subject would - -- let `verify_claim` accept a malformed constant without loading or - -- checking it, and any downstream consumer or aggregator would see the - -- constant in the subject tree without it ever having been typechecked. - { name := "self-assumption-covers-claim-target" - intent := "an ill-typed constant accepted under a `Check` claim that \ - places its own target in the assumption set, skipping the subject check" - env := badEnv, claim := .check ctx badAddr (some selfTree.root) - trees := selfTrees }, - { name := "check-env-self-assumption-covers-owned-subject" - intent := "an ill-typed constant accepted under a `CheckEnv` claim whose \ - owned subject tree and assumption tree both contain that constant, \ - skipping `run_check` on the owned leaf" - env := badEnv, - claim := .checkEnv ctx selfTree.root (some selfTree.root) - trees := selfTrees }, - -- An owned tree with no leaf owns no constant: a `CheckEnv` claim over it - -- would check nothing and still state that an environment typechecks. - -- `run_check_env` refuses it before any walk. - { name := "check-env-empty-owned-tree" - intent := "a `CheckEnv` claim accepted over an owned tree with no leaves, \ - checking no constant at all" - env := badEnv, claim := .checkEnv ctx emptyTree.root none - trees := emptyTrees - rejectsWith := some "owned tree has no leaves" }, - -- CONTROL: the same shape over well-formed UTF-8 must typecheck, so - -- a rejection below is attributable to the bytes and not to the - -- fixture's shape. - { name := "control-valid-utf8-string-literal" - intent := "a well-formed `String` literal, which must be accepted" - env := okUtf8Env, claim := .check ctx okUtf8Addr none - expectAccept := true }, - -- `Expr.Str` conversion wraps any hash-valid blob in `KLiteral.Str` - -- and `k_infer_lit` types it `String` without inspecting the bytes, - -- so a literal that is not valid UTF-8 typechecks. The reference - -- kernel rejects it at ingress (`String::from_utf8`), and no Lean - -- `String` corresponds to these bytes, so accepting is a wrong - -- answer. The UTF-8 validation on the string DECODER does not cover - -- this: ordinary checking of a literal never decodes it. - { name := "invalid-utf8-accepted-as-string" - intent := "a definition accepted as `x : String` whose literal is \ - not valid UTF-8, which the reference kernel rejects" - env := badUtf8Env, claim := .check ctx badUtf8Addr none }, - -- CONTROL: the last scalar values before the surrogates and the end - -- of the code space, and the first after the surrogates, are accepted. - { name := "control-utf8-scalar-edges" - intent := "a `String` literal of U+D7FF, U+E000 and U+10FFFF, which \ - must be accepted" - env := scalarEdgesEnv, claim := .check ctx scalarEdgesAddr none - expectAccept := true }, - { name := "utf8-surrogate-accepted-as-string" - intent := "a definition accepted as `x : String` whose literal encodes \ - the surrogate U+D800, which is no `Char`" - env := surrogateEnv, claim := .check ctx surrogateAddr none }, - { name := "utf8-above-max-scalar-accepted-as-string" - intent := "a definition accepted as `x : String` whose literal encodes \ - U+110000, past the last scalar value" - env := aboveMaxEnv, claim := .check ctx aboveMaxAddr none }, - { name := "utf8-f5-leader-accepted-as-string" - intent := "a definition accepted as `x : String` whose literal starts \ - with the leader byte 0xF5, which no scalar value has" - env := leaderF5Env, claim := .check ctx leaderF5Addr none }, - -- CONTROL: the same block shape below the index width, to show the - -- fixture's members and wrappers are well-formed. - { name := "control-small-muts-block" - intent := "a two-member mutual block of well-typed definitions, \ - which must be accepted" - env := smallBlockEnv, claim := .check ctx smallBlockAddr none - expectAccept := true }, - -- Member and constructor indices are synthesized into the projection - -- wrapper's `u64` field, whose bytes `idx_to_u64` obtains from a hint - -- and constrains to recompose to the index. A block past the former - -- single-byte range is otherwise valid and must check. - { name := "muts-block-past-single-byte-index" - intent := "a valid 257-member mutual block, which must be \ - checkable rather than rejected for its size" - env := bigBlockEnv, claim := .check ctx bigBlockAddr none - expectAccept := true }, - -- The sharpest statement available: accepting this is a proof of - -- `False`. - { name := "self-referential-theorem-proves-false" - intent := "`theorem bad : False := bad` accepted as well-typed — a \ - proof of False, since the body is the constant itself" - env := selfRefEnv, claim := .check ctx selfRefAddr none }, - -- The case above ships `⟨.thm, .safe⟩` (packed byte 9) and the - -- `Safe ⇒ no self slot` guard rejects it. These three reach the - -- same self-reference around that guard. - -- - -- Packed byte 8. `safety = Unsafe` opens the recur slot; - -- `kind = Theorem` makes `convert_definition` emit - -- `KConstantInfo.Thm`, which `is_unsafe_ci` classifies as - -- unconditionally safe — the safety byte is simply dropped. - { name := "self-referential-theorem-unsafe-bit" - intent := "`theorem bad : False := bad` accepted, reaching the \ - self-`Rec` slot via `safety = Unsafe` while `kind = Theorem` \ - discards that same byte and keeps the constant Safe-classified" - env := thmUnsafeEnv, claim := .check ctx thmUnsafeAddr none }, - -- Packed byte 6, and sharper: the `Opaque` arm of `check_const` - -- carries no Prop restriction, so this shape inhabits ANY declared - -- type, not just a proposition. `False` here for the flattest - -- statement of what it buys. - { name := "self-referential-opaque-partial-bit" - intent := "`opaque bad : False := bad` accepted, since \ - `Partial` opens the recur slot but maps to `is_unsafe = 0` — \ - and the Opaque arm has no Prop restriction, so the same shape \ - inhabits any type" - env := opaqPartEnv, claim := .check ctx opaqPartAddr none }, - -- No safety bit touched at all: a `Safe` definition, self-referring - -- through its own block's projection wrapper. The guard was only - -- ever written on the standalone path. - { name := "self-referential-defn-through-muts-block" - intent := "`bad : False := bad` accepted for a Safe definition \ - whose self-reference goes through its block's peer slot, which \ - `build_recur_addrs` populates without consulting safety" - env := mutsSelfEnv, claim := .check ctx mutsSelfAddr none }, - -- CONTROL: strict positivity's positive side, in a block with no - -- definition member so nothing structural intervenes. - { name := "control-ind-block-positive-field" - intent := "`Bad : Prop | mk : False → Bad` — strictly positive, \ - must be accepted" - env := posIndEnv, claim := .check ctx posIndAddr none - expectAccept := true }, - -- CONTROL: the negative occurrence written where the checker can see - -- it. Pins that positivity itself still fires, independently of the - -- structural ban the two cases below rely on. - { name := "control-ind-block-direct-negative" - intent := "`Bad : Prop | mk : (Bad → False) → Bad` with the \ - occurrence inline — strict positivity must reject it" - env := directNegEnv, claim := .check ctx directNegAddr none }, - -- CONTROL: a mixed block with nothing negative in it. The ban is on - -- the SHAPE, so this is rejected too — deliberately - -- over-approximate, since Lean emits no such block. Pinned so that - -- narrowing the rule later has to be a deliberate act. - { name := "defn-member-alongside-inductives" - intent := "`Neg : Prop := False` and `Bad | mk : Neg → Bad` in one \ - block — benign, but rejected structurally because a definition \ - member alongside inductives is what makes a hidden occurrence \ - expressible at all" - env := benignMixedEnv, claim := .check ctx benignMixedAddr none }, - -- EXPLOIT: the badness of `control-ind-block-direct-negative`, moved - -- one delta-step away. `check_positivity_aug` skips a field whose - -- domain does not syntactically mention a block inductive, and - -- `caddr_is_peer` counts only `Induct`s, so a `Const` resolving to a - -- definition is invisible and the domain is never reduced. - { name := "negative-occurrence-behind-block-local-defn" - intent := "an inductive accepted despite a non-strictly-positive \ - constructor field, because the occurrence sits behind a `Defn` \ - member of its own block and the occurrence test resolves \ - constants but only counts inductives — `Bad | mk : (Bad → \ - False) → Bad` admits False via Curry's paradox" - env := hiddenNegEnv, claim := .check ctx hiddenNegAddr none }, - -- A legitimate mutual pair whose members have different constructor - -- counts. Must check: Lean forces mutual inductives to share - -- parameters and universes, not constructor counts. - { name := "mutual-block-with-uneven-ctor-counts" - intent := "a valid mutual block whose first member has more \ - constructors — `Q : Prop` with three ahead of `P : Prop → Prop` \ - with one — which must be checkable" - env := unevenEnv, claim := .check ctx unevenAddr none - expectAccept := true }, - -- The same two inductives in both member orders, with `Rec` indices - -- renumbered to match. The two orders are two different blocks, and - -- the kernel takes members in whatever order a block stores them, as - -- Lean declares them: BOTH must check. - { name := "two-inductive-block-in-declared-order" - intent := "a two-inductive block, nullary-constructor member first, \ - which must be accepted" - env := orderAEnv, claim := .check ctx orderAAddr none - expectAccept := true }, - { name := "two-inductive-block-in-swapped-order" - intent := "the same two inductives with the member order swapped, \ - which must be accepted as well" - env := orderBEnv, claim := .check ctx orderBAddr none - expectAccept := true }, - -- Two members equal up to the block's own renaming. Must check: they - -- are two members, as in Lean's block. - { name := "two-inductive-block-with-alpha-equal-members" - intent := "`A : Prop | mkA : A` and `B : Prop | mkB : B` in one \ - block, which must be accepted" - env := twinEnv, claim := .check ctx twinAddr none - expectAccept := true }, - -- CONTROL: the honest way to name a block member, through its - -- projection wrapper. Establishes the block, its hint and the - -- reference all resolve, so the verdict below is about the address - -- used and nothing else. - { name := "control-block-member-via-projection-wrapper" - intent := "a definition referencing a mutual block's member \ - through its `DPrj` wrapper, which must be accepted" - env := viaWrapperEnv, claim := .check ctx viaWrapperAddr none - expectAccept := true }, - -- PROBE: the same reference through the BLOCK's address. `get_ci` - -- falls back to the first member's KCI for a `Muts` constant, so if - -- this checks then one constant has two working addresses. - { name := "constant-aliased-by-its-block-address" - intent := "a definition accepted while naming a block member by \ - the BLOCK's address, giving one constant a second address and \ - so a second lexicographic position wherever addresses are \ - compared (`canon_addr_cmp` orders Muts members by external ref)" - env := viaBlockEnv, claim := .check ctx viaBlockAddr none }, - -- CONTROL: the uniform occurrence, which must keep checking — every - -- honest recursive field has this shape. - { name := "control-uniform-recursive-field" - intent := "`I α | mk : I α → I α` — the recursive field is at the \ - declared parameter, which must be accepted" - env := uniformFieldEnv, claim := .check ctx uniformFieldAddr none - expectAccept := true }, - -- EXPLOIT: the parameter argument of a recursive occurrence in a - -- FIELD is never looked at. `check_positivity_aug` accepts on head - -- identity and drops the spine, so `I False` passes inside `I α`. - { name := "nonuniform-param-in-recursive-field" - intent := "an inductive accepted whose recursive constructor field \ - sits at a different parameter than the one declared — Lean's \ - `check_uniform_params` rejects it, and the recursor generated \ - for it applies `motive : I α → _` to a field of type `I False`" - env := nonUniformFieldEnv, claim := .check ctx nonUniformFieldAddr none }, - -- CONTROL: the same indexed shape with an ordinary index. - { name := "control-ordinary-index-in-recursive-field" - intent := "`K | mk : K False → K False` — the occurrence's index \ - is a plain constant, which must be accepted" - env := uniformIndexEnv, claim := .check ctx uniformIndexAddr none - expectAccept := true }, - -- EXPLOIT: lean4 #2125. The index of a recursive occurrence mentions - -- the datatype being declared. The return type's index is clean, so - -- `check_ctor_return_type`'s index check never sees it, and the - -- field checker does not look at indices at all. - { name := "block-occurrence-in-recursive-field-index" - intent := "an inductive accepted whose recursive constructor \ - field's INDEX mentions the datatype being declared — the guard \ - Lean added as `check_ind_app_idxs`, absent for field occurrences" - env := selfIndexEnv, claim := .check ctx selfIndexAddr none }, - -- CONTROL: nesting through a strictly-positive inductive is fine and - -- must keep checking, so a rejection below is attributable to the - -- negative occurrence rather than to nesting itself. - { name := "control-nested-positive-inductive" - intent := "`Host | mk : Inner Host → Host` where `Inner α | mk : α \ - → Inner α` is strictly positive — must be accepted" - env := posEnv, claim := .check ctx posAddr none - expectAccept := true }, - -- The nested positivity check drops the parameter arguments - -- (`list_drop(args, n_ctor_params)`) and descends into the inner - -- inductive's constructors WITHOUT substituting them. The inner - -- constructor's field mentions its parameter as a `BVar`, so the - -- block-occurrence test sees nothing and passes vacuously — exactly - -- the positions that matter. Both references substitute first. - { name := "nested-inductive-negative-occurrence" - intent := "an inductive accepted despite occurring negatively \ - through a nested inductive's parameter — admits `False`" - env := negEnv, claim := .check ctx negAddr none }, - -- CONTROL: the TRUE equation. `"".utf8ByteSize` is 0, so `Nat.beq` - -- of it against 0 is `true` and this must check. - { name := "control-utf8-size-beq-true" - intent := "`Nat.beq (String.utf8ByteSize \"\") 0 = true`, which is \ - true in Lean and must be accepted" - env := beqTrueEnv, claim := .check ctx beqTrueAddr none - expectAccept := true }, - -- `bytestream_length_u64` builds the length as a single unchecked - -- byte with no `klimbs_normalize`, so the empty string's size is the - -- DENORMALIZED zero `[[0;8]]` rather than the canonical empty limb - -- list. `klimbs_eq` compares limbs without normalizing, so `Nat.beq` - -- answers `false` where Lean answers `true`, and the false equation - -- typechecks by `rfl`. - { name := "utf8-size-beq-false-accepted" - intent := "`Nat.beq (String.utf8ByteSize \"\") 0 = false` accepted \ - by rfl — a false equation, since the size really is 0" - env := beqFalseEnv, claim := .check ctx beqFalseAddr none } - ] ++ recrCases ++ #[ - -- CONTROL: the same axiom with CANONICAL bytes, stored raw through - -- the same path. Establishes that the constant is well-formed and - -- that raw-byte storage works, so a rejection below is attributable - -- to the encoding alone. - { name := "control-canonical-tagn-axiom" - intent := "an unsafe axiom `_ : Prop` with canonical bytes, which \ - must be accepted" - env := canonBytesEnv, claim := .check ctx canonBytesAddr none - expectAccept := true }, - -- The same axiom with its `lvls` TagN0 replaced by a string the format - -- does not define (`tagN0At`). No host accepts these bytes, so the - -- kernel accepting them would mean its accepted language is wider than - -- the format, and one address denotes a constant no host can read. - { name := "invalid-tagn-code-accepted" - intent := "a constant accepted from a TagN0 header with code 4, \ - which Rust and the Lean host reject — a reader masking the code \ - to two bits reads 16512 universe parameters" - env := badCodeEnv, claim := .check ctx badCodeAddr none }, - { name := "tagn-overflow-accepted" - intent := "a constant accepted from an 8-byte TagN0 whose value \ - reaches 2^64, which Rust and the Lean host reject — a wrapping \ - reader reads 4311826559 universe parameters" - env := overflowEnv, claim := .check ctx overflowAddr none }, - -- Same axiom, its type expression prefixed by a binder telescope - -- announcing zero binders. The telescope helpers are the identity at - -- count 0, so the term is unchanged and only the address moves. - { name := "zero-count-lam-telescope-accepted" - intent := "a constant accepted from a `Lam` telescope announcing \ - zero binders, which Rust rejects — every expression gains 3^k \ - addresses at k such bytes, all reading as the same constant" - env := zeroLamEnv, claim := .check ctx zeroLamAddr none }, - { name := "zero-count-all-telescope-accepted" - intent := "the same for an `All` telescope announcing zero \ - binders, so the aliasing is not specific to one flag" - env := zeroAllEnv, claim := .check ctx zeroAllAddr none }, - -- The variant number is read from the low byte of a size the format - -- requires to fit in one byte. - { name := "wide-constant-info-variant-accepted" - intent := "a constant parsed from a `ConstantInfo` tag whose size \ - is 258, because dispatch reads only its low byte — Rust matches \ - the full u64 and rejects the buffer" - env := wideVariantEnv, claim := .check ctx wideVariantAddr none }, - -- A field the format declares `Bool`, carrying 2. - { name := "non-bool-is-unsafe-byte-accepted" - intent := "an axiom accepted with `isUnsafe = 2`, a value Rust's \ - `get_bool` rejects — the flag is consumed multiplicatively by \ - `safe_refs_only`, where two such references cancel to 1 and \ - satisfy the Safe→Unsafe wall" - env := nonBoolEnv, claim := .check ctx nonBoolAddr none }, - { name := "non-maximal-app-telescope" - intent := "Reveal rejects an App telescope whose base is another App; \ - host codecs require one maximal telescope" - env := nestedAppEnv - claim := .reveal nestedAppAddr (.axio none none none) }, - { name := "non-maximal-lam-telescope" - intent := "Reveal rejects a Lam telescope whose body is another Lam" - env := nestedLamEnv - claim := .reveal nestedLamAddr (.axio none none none) }, - { name := "non-maximal-all-telescope" - intent := "Reveal rejects a forall telescope whose codomain is another \ - forall" - env := nestedAllEnv - claim := .reveal nestedAllAddr (.axio none none none) }, - { name := "invalid-let-flags" - intent := "Reveal rejects a Let whose TagN value exceeds the two let flag bits" - env := badLetFlagEnv - claim := .reveal badLetFlagAddr (.axio none none none) }, - { name := "invalid-lambda-mode" - intent := "Reveal rejects reserved bits above the four-bit lambda contract" - env := badLamModeEnv - claim := .reveal badLamModeAddr (.axio none none none) }, - { name := "invalid-forall-mode" - intent := "Reveal rejects reserved bits in a forall mode byte" - env := badAllModeEnv - claim := .reveal badAllModeAddr (.axio none none none) } - ] - -/-! ### Reductions beyond Lean's, from compiled Lean declarations - -Unlike the cases above, these come through Ix's compiler: the fixtures of -`Tests.Ix.Kernel.FastPathDefs`, each submitted as a transitive `Check` -claim, so a claim on a derivation of `False` reaches the false lemma it -uses. The rejected ones are the three equations that held only because a -class method was reduced without its instance, the two conversions Lean's -kernel does not make (`numBits ≡ 64` and the `Fin.val`/`Decidable.rec` -commute), and the derivations; the accepted ones are the controls: the -canonical instances, the non-canonical instances' true values, and the -removed rules' shapes reduced honestly. -/ - -def fastPathCases (ctx : Ix.ClaimContext) (leanEnv : Lean.Environment) : - IO (Array ExploitCase) := do - let defs (n : String) : Lean.Name := `Tests.Ix.Kernel.FastPathDefs ++ n.toName - let rejected : Array (String × String) := #[ - ("badLt", "`decide (@LT.lt (BitVec 8) ⟨fun _ _ => False⟩ 0 1) = true` by \ - rfl — false: the instance makes the proposition `False`"), - ("badLtOfNat", "the same with the operands spelled `BitVec.ofNat 8 n`, the \ - only spelling the circuit's `decide`/`LT.lt` rule read"), - ("badOfNat", "`(@OfNat.ofNat (BitVec 8) 5 ⟨0#8⟩).toNat = 5` by rfl — false: \ - the instance's value is `0#8`"), - ("badSizeOf", "`@SizeOf.sizeOf Unit ⟨fun _ => 7⟩ () = 1` by rfl — false: \ - the instance gives 7"), - ("numBits64", "`System.Platform.numBits = 64` by rfl — `getNumBits` is an \ - opaque, which Lean's kernel does not reduce"), - ("finCommute", "`(Decidable.rec … d).val` equated with `Decidable.rec \ - (… .val) d` on a variable `d` — a conversion Lean's kernel does not make"), - ("falseLt", "a closed proof of `False` through `badLt`"), - ("falseLtOfNat", "a closed proof of `False` through `badLtOfNat`"), - ("falseOfNat", "a closed proof of `False` through `badOfNat`"), - ("falseSizeOf", "a closed proof of `False` through `badSizeOf`")] - let accepted : Array String := #["okLt", "okOfNat", "okSizeOf", "weirdLtVal", - "weirdOfNatVal", "weirdSizeOfVal", "okUlt", "okSizeOfVar", "okSizeOfPUnitVar", - "okFinRec"] - let names := rejected.map (defs ·.1) ++ accepted.map defs - let env ← IxVM.ClaimHarness.loadSharedIxonEnv - (names ++ IxVM.ClaimHarness.synthesizedPrimNames) leanEnv - let mut out : Array ExploitCase := #[] - for (n, intent) in rejected do - let addr ← IxVM.ClaimHarness.lookupAddr env (defs n) - out := out.push { name := s!"fast-path-{n}", intent, env, claim := .check ctx addr none } - for n in accepted do - let addr ← IxVM.ClaimHarness.lookupAddr env (defs n) - out := out.push { name := s!"fast-path-control-{n}" - intent := s!"`{n}`, true in Lean and checked by Lean's kernel, \ - which must be accepted" - env, claim := .check ctx addr none, expectAccept := true } - return out - -/-! ## Role binding - -A typing claim reads its primitives through its role binding (the claim -context's `binding`), and each role is validated against IxC's -specification before the kernel uses it. These cases rebind the default -table. Swapping two operations makes each fail the other's equations, so -neither fast path is used; swapping `Bool.true` and `Bool.false` makes the -`Bool` group fail (`Bool.rec`'s specified type names `false` first), so no -comparison answers through it; a table that binds no `Nat` gives a numeral -no type. A table that leaves an operation unbound is not an attack: the -operation is then an ordinary definition and reduces as one. -/ - -/-- The literal blob of a numeral below 256: its little-endian bytes. -/ -def smallNatBlob (n : Nat) : ByteArray := - if n == 0 then .empty else ⟨#[n.toUInt8]⟩ - -/-- `theorem _ : @Eq.{1} T (op a b) rhs := @Eq.refl.{1} T rhs` over `env`, - with the numerals (below 256) stored as blobs. `rhs` is a numeral or a - constant. refs: 0=Eq, 1=T, 2=op, 3=Eq.refl, 4 and 5 the blobs of `a` and - `b`, 6 the blob or constant of `rhs`. -/ -def opEquationThm (env : Ixon.Env) (eqA tyA opA reflA : Address) (a b : Nat) - (rhs : Nat ⊕ Address) : Ixon.Env × Address := - let numerals := [a, b] ++ (match rhs with | .inl c => [c] | .inr _ => []) - let env := numerals.foldl (fun env n => - let bytes := smallNatBlob n - { env with blobs := env.blobs.insert (Address.blake3 bytes) bytes }) env - let (rhsRef, rhsE) : Address × Ixon.Expr := match rhs with - | .inl c => (Address.blake3 (smallNatBlob c), .nat 6) - | .inr k => (k, .ref 6 #[]) - let lhs : Ixon.Expr := .app (.app (.ref 2 #[]) (.nat 4)) (.nat 5) - let typ : Ixon.Expr := .app (.app (.app (.ref 0 #[0]) (.ref 1 #[])) lhs) rhsE - let val : Ixon.Expr := .app (.app (.ref 3 #[0]) (.ref 1 #[])) rhsE - storeAt env ⟨.defn ⟨.thm, .safe, 0, typ, val⟩, #[], - #[eqA, tyA, opA, reflA, Address.blake3 (smallNatBlob a), - Address.blake3 (smallNatBlob b), rhsRef], #[.succ .zero]⟩ - -open _root_.Ix.Kernel (Role RoleTable) in -/-- The role-binding cases over `base`, each claim relative to its own - table. -/ -def roleCases (base : Ixon.Env) : Except String (Array ExploitCase) := do - let table ← Ix.Kernel.Reader.defaultTable - let addrOf (r : Role) : Except String Address := - match table.bound.find? (·.1 == r) with - | some (_, a) => pure a - | none => throw s!"the default table binds no {repr r}" - let eqA ← addrOf .eq - let natA ← addrOf .nat - let reflA ← addrOf .eqRefl - let boolA ← addrOf .bool - let falseA ← addrOf .boolFalse - let addA ← addrOf .natAdd - let beqA ← addrOf .natBeq - let swap (r s : Role) : Except String RoleTable := do - let ra ← addrOf r - let sa ← addrOf s - pure { table with bound := table.bound.map fun (q, a) => - if q == r then (q, sa) else if q == s then (q, ra) else (q, a) } - let drop (rs : List Role) : RoleTable := - { table with bound := table.bound.filter (!rs.contains ·.1) - evidence := table.evidence.filter (!rs.contains ·.1) } - let add (a b : Nat) (rhs : Nat ⊕ Address) env := opEquationThm env eqA natA addA reflA a b rhs - let mk (name intent : String) (t : RoleTable) - (thm : Ixon.Env → Ixon.Env × Address) (expectAccept : Bool) : - Except String ExploitCase := do - let (env, addr) := thm (← IxVM.ClaimHarness.withRoleTable base t.toBytes) - pure { name, intent, env, claim := .check (← Ix.ClaimContext.ofEnv env) addr none, - expectAccept } - -- The same claim assuming its binding (validator 4). - let mkAssumed (name intent : String) (t : RoleTable) - (thm : Ixon.Env → Ixon.Env × Address) (expectAccept : Bool) : - Except String ExploitCase := do - let (env, addr) := thm (← IxVM.ClaimHarness.withRoleTable base t.toBytes) - let ctx ← Ix.ClaimContext.ofEnv env - pure { name, intent, env, claim := .check { ctx with bindingAssumed := true } addr none, - expectAccept } - -- The binding claim for table `t`. - let mkBinding (name intent : String) (t : RoleTable) (expectAccept : Bool) : - Except String ExploitCase := do - let env ← IxVM.ClaimHarness.withRoleTable base t.toBytes - let ctx ← Ix.ClaimContext.ofEnv env - pure { name, intent, env, claim := .binding ctx.spec ctx.binding, expectAccept } - let bindingCases := #[ - ← mkBinding "binding-claim-control" - "the default table binds every role to a constant meeting its \ - specification, which must be accepted" - table true, - ← mkBinding "binding-claim-swap-add-mul" - "a table that binds `Nat.mul`'s role to `Nat.add` and `Nat.add`'s to \ - `Nat.mul` meets the specifications" - (← swap .natAdd .natMul) false, - ← mkBinding "binding-claim-swap-bool-anchors" - "a table that swaps `Bool.true` and `Bool.false` meets the specifications" - (← swap .boolTrue .boolFalse) false, - ← mkBinding "binding-claim-swap-decidable-constructors" - "a table that swaps `Decidable.isTrue` and `Decidable.isFalse` meets the \ - specifications" - (← swap .decidableIsTrue .decidableIsFalse) false, - ← mkBinding "binding-claim-swap-nat-decisions" - "a table that binds `Nat.decLe`'s role to `Nat.decEq` and `Nat.decEq`'s to \ - `Nat.decLe` meets the specifications" - (← swap .natDecLe .natDecEq) false, - ← mkBinding "binding-claim-swap-int-add-sub" - "a table that binds `Int.add`'s role to `Int.sub` and `Int.sub`'s to \ - `Int.add` meets the specifications" - (← swap .intAdd .intSub) false, - ← mkBinding "binding-claim-swap-int-constructors" - "a table that swaps `Int.ofNat` and `Int.negSucc` (anchors of one type) \ - meets the specifications of the `Int` operations" - (← swap .intOfNat .intNegSucc) false, - ← mkBinding "binding-claim-incomplete" - "a table that binds no `Nat.add` binds every role" - (drop [.natAdd]) false, - ← mkAssumed "assumed-binding-control" - "`2 + 3 = 5` under the default table, assuming the binding, which must \ - be accepted" - table (add 2 3 (.inl 5)) true, - -- The kernel's obligation ends at the condition: a claim that assumes a - -- table meeting no specification states nothing false, and only the - -- binding claim for that table, refused above, could discharge it. - ← mkAssumed "assumed-binding-swap-add-mul-is-conditional" - "`2 + 3 = 6` assuming a table that swaps `Nat.add` and `Nat.mul` meets \ - the specifications: vacuous, since that table's binding claim is \ - refused, and must be accepted as the conditional it is" - (← swap .natAdd .natMul) (add 2 3 (.inl 6)) true] - -- Tables the reader must refuse, whatever they bind: the reader builds - -- balanced trees from the entries in order, so each fault is placed at - -- the first entries, at the last entry of the first half, and at the - -- entry after it (the root of the tree by role). - let half := table.bound.size / 2 - let swapBound (i : Nat) : RoleTable := - { table with bound := table.bound.swapIfInBounds i (i + 1) } - let swapEvidence (i : Nat) : RoleTable := - { table with evidence := table.evidence.swapIfInBounds i (i + 1) } - let rawCase (name intent : String) (bytes : ByteArray) : Except String ExploitCase := do - let (env, addr) := add 2 3 (.inl 5) (← IxVM.ClaimHarness.withRoleTable base bytes) - pure { name, intent, env, claim := .check (← Ix.ClaimContext.ofEnv env) addr none, - expectAccept := false } - let some (_, firstAddress) := table.bound[0]? - | throw "the default table binds nothing" - -- The last binding's role byte, raised to the first index past the roles. - let unknownRole : ByteArray := - table.toBytes.set! (4 + 33 * (table.bound.size - 1)) (UInt8.ofNat Role.all.length) - let readerCases := #[ - ← rawCase "role-table-first-roles-out-of-order" - "`2 + 3 = 5` under a table whose first two bindings are out of role order" - (swapBound 0).toBytes, - ← rawCase "role-table-half-roles-out-of-order" - "`2 + 3 = 5` under a table whose bindings either side of the end of its \ - first half are out of role order" - (swapBound (half - 1)).toBytes, - ← rawCase "role-table-root-roles-out-of-order" - "`2 + 3 = 5` under a table whose two bindings after its first half are \ - out of role order" - (swapBound half).toBytes, - ← rawCase "role-table-address-bound-twice" - "`2 + 3 = 5` under a table that binds its first address to two roles" - { table with bound := table.bound.modify 1 fun (r, _) => (r, firstAddress) }.toBytes, - ← rawCase "role-table-unknown-role" - "`2 + 3 = 5` under a table that binds a role past the specification's" - unknownRole, - ← rawCase "role-table-first-evidence-out-of-order" - "`2 + 3 = 5` under a table whose first two evidence entries are out of \ - role order" - (swapEvidence 0).toBytes, - ← rawCase "role-table-half-evidence-out-of-order" - "`2 + 3 = 5` under a table whose evidence entries either side of the end \ - of its first half are out of role order" - (swapEvidence (table.evidence.size / 2 - 1)).toBytes] - return bindingCases ++ readerCases ++ #[ - ← mk "role-control-add" - "`2 + 3 = 5` under the default table, which must be accepted" - table (add 2 3 (.inl 5)) true, - ← mk "role-swap-add-mul" - "`2 + 3 = 6`, read through a table that binds `Nat.mul`'s role to \ - `Nat.add` and `Nat.add`'s to `Nat.mul`" - (← swap .natAdd .natMul) (add 2 3 (.inl 6)) false, - ← mk "role-swap-bool-anchors" - "`Nat.beq 2 2 = false`, read through a table that binds `Bool.true`'s \ - role to `Bool.false` and `Bool.false`'s to `Bool.true`" - (← swap .boolTrue .boolFalse) - (fun env => opEquationThm env eqA boolA beqA reflA 2 2 (.inr falseA)) false, - ← mk "role-unbound-nat" - "`2 + 3 = 5` with its numerals typed at `Nat` under a table that binds \ - no `Nat`" - (drop [.nat, .natZero, .natSucc, .natRec]) (add 2 3 (.inl 5)) false, - ← mk "role-unbound-op-control" - "`2 + 3 = 5` under a table that binds no `Nat.add`: the operation is an \ - ordinary definition and reduces as one, which must be accepted" - (drop [.natAdd]) (add 2 3 (.inl 5)) true] - -/-! ### The standard axioms' families - -An admitted standard axiom is true only of the families its type quantifies -over, so `Iff` and `Nonempty` are block roles, bound to inductives, never -type-only anchors. These tables bind each family to definitions of the -specified types that collapse it to `True`, with the axiom rebound to one of -its specified type over them: -- `Nonempty' := fun _ => True`, whose recursor is defined through the - rebound `Classical.choice`; then `choice' False True.intro : False`; -- `Iff' := fun _ _ => True`, whose recursor is defined through the rebound - `propext`; then `propext' True.intro : True = False`. - -Every definition is well typed (each recursor by proof irrelevance), so only -the families' specifications can refuse them. Each table's binding claim is -refused, and so is the claim of `False` under it. (The `Iff` table's binding -claim would be refused in any case: the default evidence of the well-founded -operations uses Lean's `propext`, which that table no longer binds. Its claim -of `False` is the one that reaches the family.) A table that binds -`sorryAx` to `axiom evil.{u} : False` is refused too: `sorryAx` has its -type, though it is inert. -/ - -/-- The universe table of the one-level fixtures: `Sort u`, `Prop`, `1`. -/ -def famUnivs : Array Ixon.Univ := #[.var 0, .zero, .succ .zero] - -/-- `Nonempty'.{u} (α : Sort u) : Prop := True`. refs: 0=True. -/ -def fakeNonempty (trueA : Address) : Ixon.Constant := - ⟨.defn ⟨.defn, .safe, 1, .leanAll (.sort 0) (.sort 1), .leanLam (.sort 0) (.ref 0 #[])⟩, - #[], #[trueA], famUnivs⟩ - -/-- `Nonempty'.intro.{u} (α : Sort u) (val : α) : Nonempty' α := True.intro`. - refs: 0=Nonempty', 1=True.intro. -/ -def fakeNonemptyIntro (neA trueIntroA : Address) : Ixon.Constant := - ⟨.defn ⟨.defn, .safe, 1, - .leanAll (.sort 0) (.leanAll (.var 0) (.app (.ref 0 #[0]) (.var 1))), - .leanLam (.sort 0) (.leanLam (.var 0) (.ref 1 #[]))⟩, - #[], #[neA, trueIntroA], famUnivs⟩ - -/-- `axiom choice'.{u} (α : Sort u) : Nonempty' α → α`, `Classical.choice`'s - specified type over `Nonempty'`. refs: 0=Nonempty'. -/ -def fakeChoice (neA : Address) : Ixon.Constant := - ⟨.axio ⟨false, 1, .leanAll (.sort 0) (.leanAll (.app (.ref 0 #[0]) (.var 0)) (.var 1))⟩, - #[], #[neA], famUnivs⟩ - -/-- `Nonempty'.rec.{u} (α : Sort u) (motive : Nonempty' α → Prop) - (intro : ∀ val, motive (Nonempty'.intro α val)) (t : Nonempty' α) : - motive t := intro (choice' α t)`: `Nonempty' α` is `True`, so the two - proofs of it are equal. refs: 0=Nonempty', 1=Nonempty'.intro, 2=choice'. -/ -def fakeNonemptyRec (neA introA choiceA : Address) : Ixon.Constant := - let motive : Ixon.Expr := .leanAll (.app (.ref 0 #[0]) (.var 0)) (.sort 1) - let minor : Ixon.Expr := - .leanAll (.var 1) (.app (.var 1) (.app (.app (.ref 1 #[0]) (.var 2)) (.var 0))) - let major : Ixon.Expr := .app (.ref 0 #[0]) (.var 2) - ⟨.defn ⟨.defn, .safe, 1, - .leanAll (.sort 0) (.leanAll motive (.leanAll minor - (.leanAll major (.app (.var 2) (.var 0))))), - .leanLam (.sort 0) (.leanLam motive (.leanLam minor (.leanLam major - (.app (.var 1) (.app (.app (.ref 2 #[0]) (.var 3)) (.var 0))))))⟩, - #[], #[neA, introA, choiceA], famUnivs⟩ - -/-- `theorem _ : False := choice'.{0} False True.intro`, since - `Nonempty' False` is `True`. refs: 0=False, 1=choice', 2=True.intro. -/ -def falseByChoice (falseA choiceA trueIntroA : Address) : Ixon.Constant := - ⟨.defn ⟨.thm, .safe, 0, .ref 0 #[], .app (.app (.ref 1 #[0]) (.ref 0 #[])) (.ref 2 #[])⟩, - #[], #[falseA, choiceA, trueIntroA], #[.zero]⟩ - -/-- `Iff' (a b : Prop) : Prop := True`. refs: 0=True. -/ -def fakeIff (trueA : Address) : Ixon.Constant := - ⟨.defn ⟨.defn, .safe, 0, .leanAll (.sort 0) (.leanAll (.sort 0) (.sort 0)), - .leanLam (.sort 0) (.leanLam (.sort 0) (.ref 0 #[]))⟩, #[], #[trueA], #[.zero]⟩ - -/-- `Iff'.intro (a b : Prop) (mp : a → b) (mpr : b → a) : Iff' a b := - True.intro`. refs: 0=Iff', 1=True.intro. -/ -def fakeIffIntro (iffA trueIntroA : Address) : Ixon.Constant := - let p : Ixon.Expr := .sort 0 - ⟨.defn ⟨.defn, .safe, 0, - .leanAll p (.leanAll p (.leanAll (.leanAll (.var 1) (.var 1)) - (.leanAll (.leanAll (.var 1) (.var 3)) (.app (.app (.ref 0 #[]) (.var 3)) (.var 2))))), - .leanLam p (.leanLam p (.leanLam (.leanAll (.var 1) (.var 1)) - (.leanLam (.leanAll (.var 1) (.var 3)) (.ref 1 #[]))))⟩, - #[], #[iffA, trueIntroA], #[.zero]⟩ - -/-- `axiom propext' (a b : Prop) : Iff' a b → @Eq.{1} Prop a b`, `propext`'s - specified type over `Iff'`. refs: 0=Iff', 1=Eq. -/ -def fakePropext (iffA eqA : Address) : Ixon.Constant := - let p : Ixon.Expr := .sort 0 - ⟨.axio ⟨false, 0, .leanAll p (.leanAll p - (.leanAll (.app (.app (.ref 0 #[]) (.var 1)) (.var 0)) - (.app (.app (.app (.ref 1 #[1]) p) (.var 2)) (.var 1))))⟩, - #[], #[iffA, eqA], #[.zero, .succ .zero]⟩ - -/-- `Iff'.rec.{u} (a b : Prop) (motive : Iff' a b → Sort u) - (intro : ∀ (mp : a → b) (mpr : b → a), motive (Iff'.intro a b mp mpr)) - (t : Iff' a b) : motive t := intro (cast (propext' a b t)) - (cast (propext' b a True.intro))`, each cast an `Eq.rec.{0, 1}` at the - motive `fun x _ => x`; `Iff' a b` is `True`, so the two proofs of it are - equal. refs: 0=Iff', 1=Iff'.intro, 2=Eq, 3=Eq.rec, 4=propext', - 5=True.intro. -/ -def fakeIffRec (iffA introA eqA eqRecA propextA trueIntroA : Address) : Ixon.Constant := - let p : Ixon.Expr := .sort 1 - let iff2 (a b : Ixon.Expr) : Ixon.Expr := .app (.app (.ref 0 #[]) a) b - let eq1 (a b : Ixon.Expr) : Ixon.Expr := .app (.app (.app (.ref 2 #[2]) p) a) b - let eqRec (args : List Ixon.Expr) : Ixon.Expr := args.foldl .app (.ref 3 #[1, 2]) - let propext (a b h : Ixon.Expr) : Ixon.Expr := .app (.app (.app (.ref 4 #[]) a) b) h - -- `fun (y : Prop) (_ : a = y) => y`, with `a` at `.var aIdx` outside it. - let motiveOf (aIdx : UInt64) : Ixon.Expr := - .leanLam p (.leanLam (eq1 (.var (aIdx + 1)) (.var 0)) (.var 1)) - let motive : Ixon.Expr := .leanAll (iff2 (.var 1) (.var 0)) (.sort 0) - let minor : Ixon.Expr := - .leanAll (.leanAll (.var 2) (.var 2)) (.leanAll (.leanAll (.var 2) (.var 4)) - (.app (.var 2) ([Ixon.Expr.var 4, .var 3, .var 1, .var 0].foldl .app (.ref 1 #[])))) - let major : Ixon.Expr := iff2 (.var 3) (.var 2) - -- Under `a b motive intro t`: `a` is 4, `b` is 3, `t` is 0. - let mp : Ixon.Expr := .leanLam (.var 4) - (eqRec [p, .var 5, motiveOf 5, .var 0, .var 4, propext (.var 5) (.var 4) (.var 1)]) - let mpr : Ixon.Expr := .leanLam (.var 3) - (eqRec [p, .var 4, motiveOf 4, .var 0, .var 5, propext (.var 4) (.var 5) (.ref 5 #[])]) - ⟨.defn ⟨.defn, .safe, 1, - .leanAll p (.leanAll p (.leanAll motive (.leanAll minor - (.leanAll major (.app (.var 2) (.var 0)))))), - .leanLam p (.leanLam p (.leanLam motive (.leanLam minor (.leanLam major - (.app (.app (.var 1) mp) mpr)))))⟩, - #[], #[iffA, introA, eqA, eqRecA, propextA, trueIntroA], famUnivs⟩ - -/-- `theorem _ : False := @Eq.rec.{0, 1} Prop True (fun x _ => x) True.intro - False (propext' True False True.intro)`, since `Iff' True False` is - `True`. refs: 0=False, 1=Eq, 2=Eq.rec, 3=propext', 4=True, 5=True.intro. -/ -def falseByPropext (falseA eqA eqRecA propextA trueA trueIntroA : Address) : Ixon.Constant := - let p : Ixon.Expr := .sort 0 - let motive : Ixon.Expr := - .leanLam p (.leanLam (.app (.app (.app (.ref 1 #[1]) p) (.ref 4 #[])) (.var 0)) (.var 1)) - let h : Ixon.Expr := .app (.app (.app (.ref 3 #[]) (.ref 4 #[])) (.ref 0 #[])) (.ref 5 #[]) - ⟨.defn ⟨.thm, .safe, 0, .ref 0 #[], - [p, .ref 4 #[], motive, .ref 5 #[], .ref 0 #[], h].foldl .app (.ref 2 #[0, 1])⟩, - #[], #[falseA, eqA, eqRecA, propextA, trueA, trueIntroA], #[.zero, .succ .zero]⟩ - -/-- `axiom evil.{u} : False`. refs: 0=False. -/ -def falseAxiom (falseA : Address) : Ixon.Constant := - ⟨.axio ⟨false, 1, .ref 0 #[]⟩, #[], #[falseA], #[]⟩ - -open _root_.Ix.Kernel (Role RoleTable) in -/-- The cases of the standard axioms' families and of `sorryAx`, over - `base`: each table's binding claim, and the claim of `False` (or of the - rebound `sorryAx` itself) under it. -/ -def familyCases (base : Ixon.Env) : Except String (Array ExploitCase) := do - let table ← Ix.Kernel.Reader.defaultTable - let addrOf (r : Role) : Except String Address := - match table.bound.find? (·.1 == r) with - | some (_, a) => pure a - | none => throw s!"the default table binds no {repr r}" - let trueA ← addrOf .true - let trueIntroA ← addrOf .trueIntro - let falseA ← addrOf .false - let eqA ← addrOf .eq - let eqRecA ← addrOf .eqRec - let rebind (pairs : List (Role × Ixon.Constant)) : RoleTable := - { table with bound := table.bound.map fun (q, a) => - match pairs.find? (·.1 == q) with - | some (_, c) => (q, constAddr c) - | none => (q, a) } - -- The table binding `pairs`' constants, its binding claim, and the claim of - -- `target` under it. - let mkCases (stem intent : String) (pairs : List (Role × Ixon.Constant)) - (target : Ixon.Constant) : - Except String (Array ExploitCase) := do - let mut env ← IxVM.ClaimHarness.withRoleTable base (rebind pairs).toBytes - for c in pairs.map (·.2) ++ [target] do - env := (storeAt env c).1 - let ctx ← Ix.ClaimContext.ofEnv env - pure #[ - { name := s!"binding-claim-{stem}" - intent := s!"a table that binds {intent} meets the specifications" - env, claim := .binding ctx.spec ctx.binding }, - { name := s!"role-{stem}" - intent := s!"`False`, under a table that binds {intent}" - env, claim := .check ctx (constAddr target) none }] - let ne := fakeNonempty trueA - let neIntro := fakeNonemptyIntro (constAddr ne) trueIntroA - let choice := fakeChoice (constAddr ne) - let neRec := fakeNonemptyRec (constAddr ne) (constAddr neIntro) (constAddr choice) - let iff := fakeIff trueA - let iffIntro := fakeIffIntro (constAddr iff) trueIntroA - let propext := fakePropext (constAddr iff) eqA - let iffRec := fakeIffRec (constAddr iff) (constAddr iffIntro) eqA eqRecA (constAddr propext) - trueIntroA - let evil := falseAxiom falseA - return (← mkCases "nonempty-definition" - "`Nonempty` to `fun _ => True` and `Classical.choice` to an axiom of its \ - specified type over it" - [(.nonempty, ne), (.nonemptyIntro, neIntro), (.nonemptyRec, neRec), (.choice, choice)] - (falseByChoice falseA (constAddr choice) trueIntroA)) - ++ (← mkCases "iff-definition" - "`Iff` to `fun _ _ => True` and `propext` to an axiom of its specified type over it" - [(.iff, iff), (.iffIntro, iffIntro), (.iffRec, iffRec), (.propext, propext)] - (falseByPropext falseA eqA eqRecA (constAddr propext) trueA trueIntroA)) - ++ (← mkCases "sorry-false-axiom" - "`sorryAx` to `axiom evil.{u} : False`, which is then declared" - [(.sorryAx, evil)] evil) - -/-! ### A bound role reached by a walk - -A walk over a claim's dependencies checks a constant bound to an operation or -a basis member under the context its group is validated in, whether or not -the claim uses the role. Under the standard axiom policy that context has no -`propext` for a structural operation (the axioms' groups come after the -structural operations'), so a claim that only references a definition the -binding binds to `Nat.add`'s role, and whose dependencies use `propext`, is -declined, as that group's validation would decline the definition. The -control references the same definition under the default table, where it is -an ordinary definition. -/ - -/-- A definition of `Nat.add`'s type whose value uses `propext`. -/ -def addThroughPropext (a b : Nat) : Nat := - Eq.mpr (congrArg (fun _ : Prop => Nat) (propext (Iff.refl True))) (a + b) - -/-- A reference to `addThroughPropext` that never applies it. -/ -theorem addThroughPropextRefl : addThroughPropext = addThroughPropext := rfl - -open _root_.Ix.Kernel (Role RoleTable) in -/-- The walk-context cases: a reference to `addThroughPropext` under a table - that binds `Nat.add`'s role to it, and under the default table. -/ -def walkContextCases (leanEnv : Lean.Environment) : IO (Array ExploitCase) := do - let env ← IxVM.ClaimHarness.loadSharedIxonEnv - #[``addThroughPropext, ``addThroughPropextRefl] leanEnv - let opA ← IxVM.ClaimHarness.lookupAddr env ``addThroughPropext - let thmA ← IxVM.ClaimHarness.lookupAddr env ``addThroughPropextRefl - let table ← IO.ofExcept Ix.Kernel.Reader.defaultTable - let rebound : RoleTable := { table with bound := table.bound.map fun (q, a) => - if q == Role.natAdd then (q, opA) else (q, a) } - let boundEnv ← IO.ofExcept (IxVM.ClaimHarness.withRoleTable env rebound.toBytes) - let boundCtx ← IO.ofExcept (Ix.ClaimContext.ofEnv boundEnv) - let ctx ← IO.ofExcept Ix.ClaimContext.ofDefaultTable - return #[ - { name := "role-referenced-op-uses-propext" - intent := "under the standard axiom policy, a reference to a definition \ - the binding binds to `Nat.add`'s role whose dependencies use `propext`, \ - an axiom that role's group is validated without" - env := boundEnv, claim := .check boundCtx thmA none }, - { name := "role-referenced-op-control" - intent := "the same reference under the default table, where the \ - definition is an ordinary one and `propext` a standard axiom, which \ - must be accepted" - env, claim := .check ctx thmA none, expectAccept := true }] - -/-! ## Axiom policy - -A typing claim's theory is Lean's over its three standard axioms, which the -binding binds (`axiom_standing`). A safe axiom is declared only when it is -one of them or `sorryAx`, which is inert: declared, but used by no constant. -Native evaluation is outside that theory. Of its five constants the three -axioms (`Lean.trustCompiler`, `Lean.ofReduceBool`, `Lean.ofReduceNat`) are -declined as axioms, and the opaques `Lean.reduceBool` and `Lean.reduceNat`, -which never reduce, through their dependency on `Lean.trustCompiler`. IxC's -strict checking, the default of every entry and of `ix check-lean` and -`kernel-check-ixe`, refuses the same five, and the cases pin IxC's verdicts -beside IxVM's. Only `--allow-user-axioms` admits the three axioms, as user -axioms of an uncertified conditional run that lists them, issues no host -statement and exits 5 (`Ix.Cli.CheckLeanCmd.exitConditional`). -/ - -/-- `theorem _ : False := @sorryAx.{0} False Bool.false`. - refs: 0=sorryAx, 1=False, 2=Bool.false. -/ -def sorryProof (sorryA falseA boolFalseA : Address) : Ixon.Constant := - ⟨.defn ⟨.thm, .safe, 0, .ref 1 #[], .app (.app (.ref 0 #[0]) (.ref 1 #[])) (.ref 2 #[])⟩, - #[], #[sorryA, falseA, boolFalseA], #[.zero]⟩ - -/-- Lean's native-evaluation constants. -/ -def nativeEvaluationNames : List Lean.Name := - [``Lean.trustCompiler, ``Lean.ofReduceBool, ``Lean.ofReduceNat, ``Lean.reduceBool, - ``Lean.reduceNat] - -/-- The axiom-policy cases, and the check that IxC refuses each - native-evaluation constant as IxVM must. -/ -def axiomPolicyCases (ctx : Ix.ClaimContext) (leanEnv : Lean.Environment) : - IO (Array ExploitCase × TestSeq) := do - let closed ← IO.ofExcept - (Tests.Ix.Kernel.ReaderFidelity.closure leanEnv nativeEvaluationNames.toArray) - let compiled ← match ← Ix.CompileM.compileCertified leanEnv closed 4 with - | .ok out => pure out - | .error e => throw (IO.userError s!"compiling the native-evaluation closure: {e}") - let ixc ← Tests.Ix.Kernel.FastPaths.ixcVerdicts compiled nativeEvaluationNames - let ixcTests := nativeEvaluationNames.foldl (init := .done) fun acc n => - let verdict := ixc.getD n (.reject "no IxC verdict") - acc ++ test s!"IxC refuses {n} ({verdict.label})" - (ixc.contains n && !verdict.isAccept) - let env ← IxVM.ClaimHarness.loadSharedIxonEnv - (nativeEvaluationNames.toArray ++ #[``sorryAx, ``False, ``Bool.false, ``propext]) - leanEnv - let mut out : Array ExploitCase := #[] - for n in nativeEvaluationNames do - let addr ← IxVM.ClaimHarness.lookupAddr env n - out := out.push { name := s!"native-{n}" - intent := s!"`{n}` declared, though native evaluation trusts the \ - compiler, outside Lean's theory over its standard axioms" - env, claim := .check ctx addr none } - let (axEnv, axAddr) := storeAt env propAxiom - out := out.push { name := "axiom-arbitrary" - intent := "an arbitrary safe axiom (`axiom _ : Prop`) declared in a \ - claim's theory" - env := axEnv, claim := .check ctx axAddr none } - let sorryA ← IxVM.ClaimHarness.lookupAddr env ``sorryAx - let falseA ← IxVM.ClaimHarness.lookupAddr env ``False - let boolFalseA ← IxVM.ClaimHarness.lookupAddr env ``Bool.false - let (sorryEnv, sorryUseAddr) := storeAt env (sorryProof sorryA falseA boolFalseA) - out := out.push { name := "sorry-used" - intent := "`False`, proved by `sorryAx False false`" - env := sorryEnv, claim := .check ctx sorryUseAddr none } - out := out.push { name := "control-sorry-declared" - intent := "`sorryAx` declared and used by nothing, which must be accepted" - env, claim := .check ctx sorryA none, expectAccept := true } - let propextA ← IxVM.ClaimHarness.lookupAddr env ``propext - out := out.push { name := "control-propext-declared" - intent := "`propext`, a standard axiom, which must be accepted" - env, claim := .check ctx propextA none, expectAccept := true } - return (out, ixcTests) - -/-! ## Runner -/ - -/-- Run raw-Ixon cases through the production claim entrypoint. -/ -def runCases (compiled : Aiur.CompiledToplevel) (fixtures : Array ExploitCase) - (useCodegen : Bool := false) : - IO TestSeq := do - let funIdx ← match compiled.getFuncIdx `verify_claim with - | some i => pure i - | none => throw <| IO.userError "verify_claim entrypoint missing" - let mut tests : TestSeq := .done - for c in fixtures do - let verdict := if c.expectAccept then "ACCEPT" else "REJECT" - let engine := if useCodegen then "codegen" else "bytecode" - let label := s!"exploit {engine} {verdict} {c.name}" - match IxVM.ClaimHarness.buildClaimWitness c.env c.claim c.trees with - | .error e => - tests := tests ++ test s!"{label}: witness build failed ({e})" false - | .ok witness => - let execution := if useCodegen then - compiled.bytecode.executeIxVM funIdx witness.input witness.inputIOBuffer - else compiled.bytecode.execute funIdx witness.input witness.inputIOBuffer - match execution with - | .ok _ => - tests := tests ++ - test s!"{label} (accepted — buys: {c.intent})" c.expectAccept - | .error e => - IO.println s!" [{c.name}] rejected by: {e}" - let cause := c.rejectsWith.all fun m => (toString e).contains m - tests := tests ++ test label (!c.expectAccept && cause) - return tests - -/-- Run every case against the compiled `IxVM.ixVM` toplevel through the - `verify_claim` entrypoint (the production claim path — never the - `verify_const` debug entrypoint, whose whole contract is to trust - dependencies). - - Execution goes through `Bytecode.Toplevel.execute`, the generic - bytecode interpreter. Do NOT switch this to `executeIxVM`: that - routes through the codegen'd Rust kernel, which is only as current - as the last `ix codegen`, so an Aiur-source fix would appear to fail - (or a live exploit appear to be closed) against a stale kernel. -/ -def exploitTests (leanEnv : Lean.Environment) - (compiled : Aiur.CompiledToplevel) : IO TestSeq := do - -- Cases that assert something about `String` need the real `String` - -- constant to declare a type against; everything else is built from - -- nothing. - let base ← IxVM.ClaimHarness.loadSharedIxonEnv - #[``String, ``False, ``Eq, ``Eq.refl, ``Bool, ``Nat.beq, - ``String.utf8ByteSize, ``Nat, ``SizeOf.sizeOf, ``SizeOf.mk, - ``Unit, ``Unit.unit, ``Iff, ``Iff.rec] leanEnv - let strAddr ← IxVM.ClaimHarness.lookupAddr base ``String - let falseAddr ← IxVM.ClaimHarness.lookupAddr base ``False - let eqA ← IxVM.ClaimHarness.lookupAddr base ``Eq - let boolA ← IxVM.ClaimHarness.lookupAddr base ``Bool - let beqA ← IxVM.ClaimHarness.lookupAddr base ``Nat.beq - let sizeA ← IxVM.ClaimHarness.lookupAddr base ``String.utf8ByteSize - let trueA ← IxVM.ClaimHarness.lookupAddr base ``Bool.true - let falseBoolA ← IxVM.ClaimHarness.lookupAddr base ``Bool.false - let reflA ← IxVM.ClaimHarness.lookupAddr base ``Eq.refl - let natA ← IxVM.ClaimHarness.lookupAddr base ``Nat - let sizeOfSizeOfA ← IxVM.ClaimHarness.lookupAddr base ``SizeOf.sizeOf - let sizeOfMkA ← IxVM.ClaimHarness.lookupAddr base ``SizeOf.mk - let unitA ← IxVM.ClaimHarness.lookupAddr base ``Unit - let unitUnitA ← IxVM.ClaimHarness.lookupAddr base ``Unit.unit - let iffA ← IxVM.ClaimHarness.lookupAddr base ``Iff - let iffRecA ← IxVM.ClaimHarness.lookupAddr base ``Iff.rec - let ctx ← IO.ofExcept Ix.ClaimContext.ofDefaultTable - let (axiomCases, ixcTests) ← axiomPolicyCases ctx leanEnv - let ixvmTests ← runCases compiled (cases ctx base strAddr falseAddr eqA boolA beqA sizeA - trueA falseBoolA reflA natA sizeOfSizeOfA sizeOfMkA unitA unitUnitA iffA iffRecA - ++ (← fastPathCases ctx leanEnv) ++ (← IO.ofExcept (roleCases base)) - ++ (← IO.ofExcept (familyCases base)) - ++ (← walkContextCases leanEnv) ++ axiomCases) - return ixvmTests ++ ixcTests - -end Tests.Ix.IxVM.Exploits diff --git a/Tests/Ix/IxVM/SubstBoundaries.lean b/Tests/Ix/IxVM/SubstBoundaries.lean deleted file mode 100644 index a28e04b1a..000000000 --- a/Tests/Ix/IxVM/SubstBoundaries.lean +++ /dev/null @@ -1,211 +0,0 @@ -import Ix.IxVM.Toplevel -import Ix.Aiur.Compiler -import Ix.Aiur.Protocol - -/-! Regression controls for the substitution circuits' scope guards. The -reference functions retain the former control flow. Execute both through the -constrained bytecode backend, including field values outside the u32 range: -the comparison gadgets' refusals are part of the expected behavior. - -The probe entrypoints are test-only and are absent from production IxVM. -/ - -namespace Tests.Ix.IxVM.SubstBoundaries - -open Aiur - -private def probes := ⟦ - fn boundary_lower_ref(e: KExpr, shift: G, cutoff: G) -> KExpr { - match shift { - 0 => e, - _ => - let l = expr_lbr(e); - match memo_u32_less_than(cutoff, l) { - 0 => e, - 1 => boundary_lower_walk_ref(e, shift, cutoff), - }, - } - } - - fn boundary_lower_walk_ref(e: KExpr, shift: G, cutoff: G) -> KExpr { - match load(e) { - KExprNode.BVar(i) => - let lt = u32_less_than(i, cutoff); - match lt { - 1 => e, - 0 => store(KExprNode.BVar(i - shift)), - }, - KExprNode.Srt(l) => store(KExprNode.Srt(l)), - KExprNode.Const(idx, lvls) => store(KExprNode.Const(idx, lvls)), - KExprNode.App(f, a) => - store(KExprNode.App( - boundary_lower_ref(f, shift, cutoff), - boundary_lower_ref(a, shift, cutoff))), - KExprNode.Lam(ty, body) => - store(KExprNode.Lam( - boundary_lower_ref(ty, shift, cutoff), - boundary_lower_ref(body, shift, cutoff + 1))), - KExprNode.Forall(ty, body) => - store(KExprNode.Forall( - boundary_lower_ref(ty, shift, cutoff), - boundary_lower_ref(body, shift, cutoff + 1))), - KExprNode.Let(ty, val, body) => - store(KExprNode.Let( - boundary_lower_ref(ty, shift, cutoff), - boundary_lower_ref(val, shift, cutoff), - boundary_lower_ref(body, shift, cutoff + 1))), - KExprNode.Lit(lit) => store(KExprNode.Lit(lit)), - KExprNode.Proj(tidx, fidx, e1) => - store(KExprNode.Proj(tidx, fidx, boundary_lower_ref(e1, shift, cutoff))), - } - } - - fn boundary_range_ref(e: KExpr, lo: G, hi: G) -> G { - match load(e) { - KExprNode.BVar(i) => - match u32_less_than(i, lo) { - 1 => 0, - 0 => u32_less_than(i, hi), - }, - KExprNode.Srt(_) => 0, - KExprNode.Const(_, _) => 0, - KExprNode.Lit(_) => 0, - KExprNode.App(f, a) => - match boundary_range_ref(f, lo, hi) { - 1 => 1, - 0 => boundary_range_ref(a, lo, hi), - }, - KExprNode.Lam(ty, body) => boundary_range_ref_binder(ty, body, lo, hi), - KExprNode.Forall(ty, body) => boundary_range_ref_binder(ty, body, lo, hi), - KExprNode.Let(ty, val, body) => boundary_range_ref_let(ty, val, body, lo, hi), - KExprNode.Proj(_, _, e1) => boundary_range_ref(e1, lo, hi), - } - } - - -- Cold-extracted binder arm (same pattern as `expr_lbr_let`): the - -- two-call arm would otherwise widen every row of the hot walk. - fn boundary_range_ref_binder(ty: KExpr, body: KExpr, lo: G, hi: G) -> G { - match boundary_range_ref(ty, lo, hi) { - 1 => 1, - 0 => boundary_range_ref(body, lo + 1, hi + 1), - } - } - - fn boundary_range_ref_let(ty: KExpr, val: KExpr, body: KExpr, lo: G, hi: G) -> G { - match boundary_range_ref(ty, lo, hi) { - 1 => 1, - 0 => - match boundary_range_ref(val, lo, hi) { - 1 => 1, - 0 => boundary_range_ref(body, lo + 1, hi + 1), - }, - } - } - - fn boundary_expr(i: G, j: G) -> KExpr { - let x = store(KExprNode.BVar(i)); - let y = store(KExprNode.BVar(j)); - store(KExprNode.Let(x, store(KExprNode.App(x, y)), store(KExprNode.Lam(x, y)))) - } - - fn boundary_read(e: KExpr) -> [G; 5] { - let KExprNode.Let(a, b, c) = load(e); - let KExprNode.BVar(a1) = load(a); - let KExprNode.App(b1, b2) = load(b); - let KExprNode.BVar(b1) = load(b1); - let KExprNode.BVar(b2) = load(b2); - let KExprNode.Lam(c1, c2) = load(c); - let KExprNode.BVar(c1) = load(c1); - let KExprNode.BVar(c2) = load(c2); - [a1, b1, b2, c1, c2] - } - - pub fn boundary_lower(i: G, shift: G, cutoff: G) -> G { - let KExprNode.BVar(j) = load(expr_lower(store(KExprNode.BVar(i)), shift, cutoff)); - j - } - pub fn boundary_lower_reference(i: G, shift: G, cutoff: G) -> G { - let KExprNode.BVar(j) = load(boundary_lower_ref(store(KExprNode.BVar(i)), shift, cutoff)); - j - } - pub fn boundary_lower_let(i: G, j: G, shift: G, cutoff: G) -> [G; 5] { - boundary_read(expr_lower(boundary_expr(i, j), shift, cutoff)) - } - pub fn boundary_lower_let_reference(i: G, j: G, shift: G, cutoff: G) -> [G; 5] { - boundary_read(boundary_lower_ref(boundary_expr(i, j), shift, cutoff)) - } - pub fn boundary_range(i: G, lo: G, hi: G) -> G { - has_bvar_in_range(store(KExprNode.BVar(i)), lo, hi) - } - pub fn boundary_range_reference(i: G, lo: G, hi: G) -> G { - boundary_range_ref(store(KExprNode.BVar(i)), lo, hi) - } - pub fn boundary_range_let(i: G, j: G, lo: G, hi: G) -> G { - has_bvar_in_range(boundary_expr(i, j), lo, hi) - } - pub fn boundary_range_let_reference(i: G, j: G, lo: G, hi: G) -> G { - boundary_range_ref(boundary_expr(i, j), lo, hi) - } -⟧ - -private def entries : List Lean.Name := [ - `boundary_lower, `boundary_lower_reference, - `boundary_lower_let, `boundary_lower_let_reference, - `boundary_range, `boundary_range_reference, - `boundary_range_let, `boundary_range_let_reference] - -private def compareCase (compiled : CompiledToplevel) (actual reference : Lean.Name) - (args : Array Nat) : Except String Bool := do - let input := args.map G.ofNat - let some actualIdx := compiled.getFuncIdx actual | throw s!"missing {actual}" - let some referenceIdx := compiled.getFuncIdx reference | throw s!"missing {reference}" - let lhs := (compiled.bytecode.execute actualIdx input default).map (·.1) - let rhs := (compiled.bytecode.execute referenceIdx input default).map (·.1) - match lhs, rhs with - | .ok a, .ok r => - unless a == r do throw s!"output mismatch {actual} {args}: {a} vs {r}" - return true - | .error _, .error _ => return false - | .ok a, .error r => throw s!"lost refusal {actual} {args}: {a} vs {r}" - | .error a, .ok r => throw s!"new refusal {actual} {args}: {a} vs {r}" - -/-- All cutoff boundaries, zero shifts, u32 overflow and field wraparound, -including traversal under both a let and a lambda. -/ -def checks : Except String (Nat × Nat) := do - let source ← (IxVM.ixVMFull >>= (·.merge probes)).mapError toString - let compiled ← (source.prune entries).compile - let p := 18446744069414584321 - let indices := [0, 1, 2, 3, 17, 4294967293, 4294967294, 4294967295, 4294967296, - 72057594037927935, p - 2, p - 1] - let cutoffs := [0, 1, 2, 17, 4294967294, 4294967295, 4294967296, p - 1] - let shifts := [0, 1, 2, 4294967295, p - 1] - let mut accepted := 0 - let mut refused := 0 - for i in indices do - for cutoff in cutoffs do - for shift in shifts do - if ← compareCase compiled `boundary_lower `boundary_lower_reference #[i, shift, cutoff] then - accepted := accepted + 1 - else refused := refused + 1 - for shift in [0, 1, 2] do - if ← compareCase compiled `boundary_lower_let `boundary_lower_let_reference #[i, 4, shift, cutoff] then - accepted := accepted + 1 - else refused := refused + 1 - for hi in cutoffs do - if ← compareCase compiled `boundary_range `boundary_range_reference #[i, cutoff, hi] then - accepted := accepted + 1 - else refused := refused + 1 - if ← compareCase compiled `boundary_range_let `boundary_range_let_reference #[i, 4, cutoff, hi] then - accepted := accepted + 1 - else refused := refused + 1 - unless accepted > 0 && refused > 0 && accepted + refused == 2304 do - throw s!"boundary coverage changed: {accepted} successes, {refused} refusals" - return (accepted, refused) - -def runSuite : IO UInt32 := do - match checks with - | .error error => IO.eprintln error; return 1 - | .ok (accepted, refused) => - IO.println s!"substitution boundaries: {accepted} successes and {refused} refusals match" - return 0 - -end Tests.Ix.IxVM.SubstBoundaries diff --git a/Tests/Ix/IxVM/TagN.lean b/Tests/Ix/IxVM/TagN.lean deleted file mode 100644 index 24fec0c4e..000000000 --- a/Tests/Ix/IxVM/TagN.lean +++ /dev/null @@ -1,297 +0,0 @@ -/- - TagN in the IxVM circuit. - - The circuit carries its own TagN readers (`get_tagn0/2/4`, - `Ix/IxVM/IxonDeserialize.lean`) and writers (`put_tagn0/2/4`, - `Ix/IxVM/IxonSerialize.lean`). These tests hold them to the host codec - (`Ixon.putTagN` / `Ixon.getTagN`) on the vectors of `Tests.Ixon.tagNUnits`: - every rung boundary for f = 0, 2 and 4 with the lowest and the highest flag, - the expected encodings, the rejection vectors, every invalid code followed - by as many bytes as a valid rung reads, the 2^64 limit of the 8-byte rung, - truncations, and a sweep of one- and two-byte strings. - - A string the circuit accepts must decode to the host's flag and value and - re-encode to the same bytes (checked inside the circuit); a string the host - rejects, the circuit must reject. The explicit vectors also run through the - source interpreter, and one value per rung is proved and verified. --/ -import Ix.Ixon -import Ix.IxVM.Toplevel -import Ix.Aiur.Compiler -import Ix.Aiur.Interpret -import Tests.Aiur.Common -import LSpec - -open LSpec - -namespace Tests.Ix.IxVM.TagN - -/-- Test entrypoints over the production codec modules. -/ -def entrypoints := ⟦ - -- Decode the TagN integer on ch 0 with an `f`-bit flag, require every - -- byte consumed, re-encode the value and require the same bytes. - pub fn tagn_codec(f: G) -> (G, U64) { - let (idx, len) = io_get_info(0, [0]); - let bytes = read_checked_byte_stream(0, idx, len); - match f { - 0 => - let (value, rest) = get_tagn0(bytes); - assert_eq!(load(rest), ListNode.Nil, "trailing TagN bytes"); - assert_eq!(put_tagn0(value, store(ListNode.Nil)), bytes, - "TagN re-encoding differs"); - (0, value), - 2 => - let (tag, rest) = get_tagn2(bytes); - let (flag, value) = tag; - assert_eq!(load(rest), ListNode.Nil, "trailing TagN bytes"); - assert_eq!(put_tagn2(flag, value, store(ListNode.Nil)), bytes, - "TagN re-encoding differs"); - (flag, value), - 4 => - let (tag, rest) = get_tagn4(bytes); - let (flag, value) = tag; - assert_eq!(load(rest), ListNode.Nil, "trailing TagN bytes"); - assert_eq!(put_tagn4(flag, value, store(ListNode.Nil)), bytes, - "TagN re-encoding differs"); - (flag, value), - } - } - - -- Decode only: a rejection here is the reader's alone. - pub fn tagn_decode(f: G) { - let (idx, len) = io_get_info(0, [0]); - let bytes = read_checked_byte_stream(0, idx, len); - let rest = match f { - 0 => - let (_, r) = get_tagn0(bytes); - r, - 2 => - let (_, r) = get_tagn2(bytes); - r, - 4 => - let (_, r) = get_tagn4(bytes); - r, - }; - assert_eq!(load(rest), ListNode.Nil, "trailing TagN bytes"); - } -⟧ - -def toplevel : Except Aiur.Global Aiur.Source.Toplevel := do - let vm ← Aiur.Library.core.merge Aiur.Library.byteStream - let vm ← vm.merge IxVM.ixon - let vm ← vm.merge IxVM.ixonSerialize - let vm ← vm.merge IxVM.ixonDeserialize - let vm ← vm.merge entrypoints - return vm.prune [`tagn_codec, `tagn_decode] - -def buffer (bytes : ByteArray) : Aiur.IOBuffer := - (default : Aiur.IOBuffer).extend 0 #[0] (bytes.data.map .ofUInt8) - -/-- The entrypoint output for a decoded flag and value: the flag, then the -value's eight little-endian bytes. -/ -def output (flag : UInt8) (value : UInt64) : Array Aiur.G := - #[.ofNat flag.toNat] ++ - (Array.range 8).map fun i => .ofNat ((value.toNat >>> (8 * i)) % 256) - -/-- The host reading of `bytes`, as the circuit should report it. -/ -def host (f : Nat) (bytes : ByteArray) : Option (Array Aiur.G) := - match Ixon.runGetExact (Ixon.getTagN f) bytes with - | .ok t => some (output t.flag t.value) - | .error _ => none - -/-- Run `entry` on `bytes` in the bytecode executor: the output, or `none` if -execution fails. -/ -def run (env : AiurTestEnv) (entry : Lean.Name) (f : Nat) (bytes : ByteArray) : - Option (Array Aiur.G) := - match env.compiled.getFuncIdx entry with - | none => none - | some idx => - match env.compiled.bytecode.execute idx #[.ofNat f] (buffer bytes) with - | .ok (out, _, _) => some out - | .error _ => none - -/-- Run `entry` on `bytes` in the source interpreter. -/ -def interpret (env : AiurTestEnv) (entry : Lean.Name) (f : Nat) (bytes : ByteArray) : - Option (Array Aiur.G) := - let name := Aiur.Global.mk entry - match env.decls.getByKey name with - | some (.function function) => - let inputs := Aiur.unflattenInputs env.decls #[.ofNat f] (function.inputs.map (·.2)) - match Aiur.runFunction env.decls name inputs (buffer bytes) with - | (.ok value, _) => - some (Aiur.flattenValue env.decls (fun g => env.compiled.getFuncIdx g.toName) value) - | (.error _, _) => none - | _ => none - -/-- The circuit agrees with the host on `bytes`: the same value when the host -accepts (and the circuit's re-encoding is the input), a rejection when it does -not. With `decode`, a host rejection must also reject in the decode-only -entrypoint, so it cannot come from the writer. -/ -def agrees (env : AiurTestEnv) (f : Nat) (bytes : ByteArray) (decode : Bool := true) : - Bool := - match host f bytes with - | some expected => run env `tagn_codec f bytes == some expected - | none => - (run env `tagn_codec f bytes).isNone && - (!decode || (run env `tagn_decode f bytes).isNone) - -/-- `agrees`, and the source interpreter agrees as well. -/ -def agreesEverywhere (env : AiurTestEnv) (f : Nat) (bytes : ByteArray) : Bool := - agrees env f bytes && - match host f bytes with - | some expected => interpret env `tagn_codec f bytes == some expected - | none => - (interpret env `tagn_codec f bytes).isNone && - (interpret env `tagn_decode f bytes).isNone - -def tagNBytes (f : Nat) (flag : UInt8) (v : Nat) : ByteArray := - Ixon.runPut (Ixon.putTagN f flag v.toUInt64) - -/-- Rung boundary values for an `f`-bit flag, plus the `UInt64` extremes. -/ -def boundaries (f : Nat) : List Nat := - let ends := [Ixon.tagNEnd1 f, Ixon.tagNEnd2 f, Ixon.tagNEnd3 f, Ixon.tagNEnd4 f, - Ixon.tagNEnd5 f] - [0, 1, 2 ^ 64 - 1] ++ ends.flatMap fun e => [e - 1, e, e + 1] - -/-- The encoding of `v`, its proper prefixes, and the encoding with a -trailing byte: the first decodes to `v`, the others are rejected. -/ -def encodingChecks (env : AiurTestEnv) (f : Nat) (flag : UInt8) (v : Nat) : Bool := - let bytes := tagNBytes f flag v - host f bytes == some (output flag v.toUInt64) && - agreesEverywhere env f bytes && - agrees env f (bytes.push 0) && - (List.range bytes.size).all fun n => agrees env f (bytes.extract 0 n) - -def boundaryTests (env : AiurTestEnv) : TestSeq := - [0, 2, 4].foldl (init := .done) fun acc f => - [0, (2 ^ f - 1 : Nat)].foldl (init := acc) fun acc flag => - (boundaries f).foldl (init := acc) fun acc v => - acc ++ test s!"circuit TagN f={f} flag={flag} value={v}: decode, re-encode, \ - truncations and trailing byte" (encodingChecks env f flag.toUInt8 v) - -/-- The expected encodings of `Tests.Ixon.tagNUnits`, as the circuit reads and -writes them. -/ -def expectedVectors : List (Nat × UInt8 × Nat × Array UInt8) := [ - (4, 0xA, 7, #[0xA7]), - (4, 0xA, 8, #[0xA8, 0x00]), - (4, 0x1, 1031, #[0x1B, 0xFF]), - (4, 0, 1032, #[0x0C, 0x00, 0x00]), - (4, 0, 66567, #[0x0C, 0xFF, 0xFF]), - (4, 0, 66568, #[0x0D, 0, 0, 0]), - (4, 0, 16843783, #[0x0D, 0xFF, 0xFF, 0xFF]), - (4, 0, 16843784, #[0x0E, 0, 0, 0, 0]), - (4, 0, 4311811079, #[0x0E, 0xFF, 0xFF, 0xFF, 0xFF]), - (4, 0, 4311811080, #[0x0F, 0, 0, 0, 0, 0, 0, 0, 0]), - (0, 0, 127, #[0x7F]), - (0, 0, 128, #[0x80, 0x00]), - (0, 0, 16512, #[0xC0, 0x00, 0x00]), - (0, 0, 82047, #[0xC0, 0xFF, 0xFF]), - (0, 0, 82048, #[0xC1, 0, 0, 0]), - (0, 0, 16859263, #[0xC1, 0xFF, 0xFF, 0xFF]), - (0, 0, 16859264, #[0xC2, 0, 0, 0, 0]), - (0, 0, 4311826560, #[0xC3, 0, 0, 0, 0, 0, 0, 0, 0]), - (0, 0, 2 ^ 64 - 1, #[0xC3, 0x7F, 0xBF, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF]), - (2, 3, 32, #[0xE0, 0x00]), - (2, 3, 4128, #[0xF0, 0x00, 0x00]), - (2, 3, 69663, #[0xF0, 0xFF, 0xFF]), - (2, 3, 69664, #[0xF1, 0, 0, 0]), - (2, 3, 16846879, #[0xF1, 0xFF, 0xFF, 0xFF]), - (2, 3, 16846880, #[0xF2, 0, 0, 0, 0]), - (2, 3, 4311814176, #[0xF3, 0, 0, 0, 0, 0, 0, 0, 0]) -] - -def expectedTests (env : AiurTestEnv) : TestSeq := - expectedVectors.foldl (init := .done) fun acc (f, flag, v, bytes) => - let bytes := ByteArray.mk bytes - acc ++ test s!"circuit TagN f={f} bytes of {v}" - (tagNBytes f flag v == bytes && agreesEverywhere env f bytes && - run env `tagn_codec f bytes == some (output flag v.toUInt64)) - -/-- Little-endian bytes of `x`, `n` of them. -/ -def le (n x : Nat) : Array UInt8 := - (Array.range n).map fun i => ((x >>> (8 * i)) % 256).toUInt8 - -/-- The rejection vectors of `Tests.Ixon.tagNUnits`, plus the exact 2^64 -limit of the 8-byte rung for every flag width. -/ -def rejectedVectors : List (String × Nat × Array UInt8) := [ - ("f=2 code 4", 2, #[0x34]), - ("f=2 code 15", 2, #[0x3F]), - ("f=0 code 4", 0, #[0xC4]), - ("f=0 code 63", 0, #[0xFF]), - ("f=0 code 4 with eight payload bytes", 0, #[0xC4, 0, 0, 0, 0, 0, 0, 0, 0]), - ("f=4 overflow", 4, #[0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]), - ("f=2 overflow", 2, #[0xF3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]), - ("f=0 overflow", 0, #[0xC3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]), - ("truncated rung 2", 4, #[0x08]), - ("truncated rung 4", 4, #[0x0D, 0x00, 0x00]), - ("truncated rung 6", 4, #[0x0F, 0x00, 0x00, 0x00]), - ("trailing byte", 4, #[0x07, 0x00]) -] ++ [0, 2, 4].map fun f => - -- Code 3 sits at payload 3h + 3, h = 2^(6 - f). - (s!"f={f} value 2^64", f, - #[Ixon.tagNHeader f 0 (3 * 2 ^ (6 - f) + 3)] ++ le 8 (2 ^ 64 - Ixon.tagNEnd5 f)) - -def rejectedTests (env : AiurTestEnv) : TestSeq := - rejectedVectors.foldl (init := .done) fun acc (name, f, bytes) => - let bytes := ByteArray.mk bytes - acc ++ test s!"circuit TagN rejects {name}" - ((host f bytes).isNone && agreesEverywhere env f bytes) - -/-- Every invalid code (4..63 for f = 0, 4..15 for f = 2; code `c` sits at -payload `3h + c`, `h = 2^(6 - f)`) followed by exactly as many zero bytes as a -valid rung reads (2, 3, 4 or 8). Length alone does not reject these: a reader -that kept only the code's low two bits would accept each as a valid rung. -/ -def invalidCodeTests (env : AiurTestEnv) : TestSeq := - [(0, 63), (2, 15)].foldl (init := .done) fun acc (f, lastCode) => - [2, 3, 4, 8].foldl (init := acc) fun acc width => - let strings := (List.range (lastCode - 3)).map fun i => - ByteArray.mk (#[Ixon.tagNHeader f 0 (3 * 2 ^ (6 - f) + 4 + i)] ++ - Array.replicate width 0) - let disagreements := strings.filter fun bytes => - (host f bytes).isSome || !agreesEverywhere env f bytes - acc ++ test s!"circuit TagN f={f}: invalid codes 4..{lastCode} with {width} \ - following bytes are rejected ({disagreements.length} accepted)" - disagreements.isEmpty - -/-- Every one-byte string, and every header followed by a sample of second -bytes: the circuit's verdict and value match the host's on each, and a string -the host rejects is rejected by the decode-only entrypoint too. -/ -def sweepTests (env : AiurTestEnv) : TestSeq := - let seconds : List UInt8 := [0x00, 0x01, 0x7F, 0x80, 0xFE, 0xFF] - [0, 2, 4].foldl (init := .done) fun acc f => - let strings := (List.range 256).flatMap fun a => - ByteArray.mk #[a.toUInt8] :: seconds.map fun b => ByteArray.mk #[a.toUInt8, b] - let disagreements := strings.filter fun bytes => !agrees env f bytes - acc ++ test s!"circuit TagN f={f}: {strings.length} one- and two-byte strings \ - agree with the host ({disagreements.length} disagree)" disagreements.isEmpty - -/-- Prove and verify one value per rung for f = 4, and the largest value for -f = 0 and 2, through the codec entrypoint. -/ -def proofTests (env : AiurTestEnv) : IO TestSeq := do - let some idx := env.compiled.getFuncIdx `tagn_codec - | return test "tagn_codec entrypoint present" false - let values : List (Nat × UInt8 × Nat) := - [(4, 0xB, 7), (4, 0xB, 8), (4, 0xB, 1032), (4, 0xB, 66568), (4, 0xB, 16843784), - (4, 0xB, 4311811080), (2, 3, 2 ^ 64 - 1), (0, 0, 2 ^ 64 - 1)] - let mut tests : TestSeq := .done - for (f, flag, v) in values do - let bytes := tagNBytes f flag v - let ok : Bool := match env.aiurSystem.prove idx #[.ofNat f] (buffer bytes) with - | .ok (claim, proof, _) => - claim == Aiur.buildClaim idx #[.ofNat f] (output flag v.toUInt64) && - (env.aiurSystem.verify claim (Aiur.Proof.ofBytes proof.toBytes)).toOption.isSome - | .error _ => false - tests := tests ++ test s!"circuit TagN f={f} value={v}: prove and verify" ok - return tests - -def runSuite : IO UInt32 := do - IO.println "ixvm-tagn" - match AiurTestEnv.build toplevel with - | .error e => IO.eprintln s!"TagN codec toplevel failed: {e}"; return 1 - | .ok env => - let proofs ← proofTests env - LSpec.lspecIO (.ofList [("ixvm-tagn", - [expectedTests env, rejectedTests env, invalidCodeTests env, boundaryTests env, - sweepTests env, proofs])]) [] - -end Tests.Ix.IxVM.TagN diff --git a/Tests/Ix/IxVMFixtures.lean b/Tests/Ix/IxVMFixtures.lean new file mode 100644 index 000000000..f82c47cc2 --- /dev/null +++ b/Tests/Ix/IxVMFixtures.lean @@ -0,0 +1,225 @@ +module + +public import Lean + +/-! # IxVM kernel test fixtures + +Pure Lean declarations exercised by compiler and kernel test suites: + * `IxVMPrim` — theorems whose `rfl` proofs force primitive reductions. + * `IxVMPerf` — synthetic witnesses for delayed let inference, + context strengthening, and multi-limb multiplication. + * `IxVMInd` — sample inductives covering mutual blocks and nested + parameters. +-/ + +/-! ## Primitive reduction theorems -/ + +namespace IxVMPrim + +-- Nat arithmetic (try_nat_dispatch / try_nat_binop_addr) +public theorem nat_add_lit : 100 + 200 = 300 := rfl +public theorem nat_sub_lit : 1000 - 250 = 750 := rfl +public theorem nat_mul_lit : Nat.mul 6 7 = 42 := rfl +public theorem nat_mul_big : Nat.mul 1000000 1000000 = 1000000000000 := rfl +public theorem nat_div_lit : Nat.div 100 7 = 14 := rfl +public theorem nat_mod_lit : Nat.mod 100 7 = 2 := rfl +public theorem nat_succ_lit : Nat.succ 41 = 42 := rfl +public theorem nat_pred_lit : Nat.pred 42 = 41 := rfl +public theorem nat_gcd_lit : Nat.gcd 144 60 = 12 := rfl + +-- Nat bitwise ops +public theorem nat_land_lit : Nat.land 0xff 0x0f = 0x0f := rfl +public theorem nat_lor_lit : Nat.lor 0xf0 0x0f = 0xff := rfl +public theorem nat_xor_lit : Nat.xor 0xff 0x0f = 0xf0 := rfl +public theorem nat_shl_lit : Nat.shiftLeft 1 8 = 256 := rfl +public theorem nat_shr_lit : Nat.shiftRight 256 4 = 16 := rfl +set_option exponentiation.threshold 65536 in +set_option maxRecDepth 65536 in +public theorem nat_pow_big : (2 ^ 16384 : Nat) - (2 ^ 16384) = 0 := rfl + +-- Nat predicates (return Bool ctors) +public theorem nat_beq_lit : Nat.beq 42 42 = true := rfl +public theorem nat_ble_lit : Nat.ble 5 10 = true := rfl + +public theorem nat_cases_big : + (match (4294967296 : Nat) with | 0 => (0 : Nat) | n+1 => n) = 4294967295 := rfl + +-- Decidable instances (try_reduce_decidable) +public theorem nat_dec_le : decide (5 ≤ 10) = true := rfl +public theorem nat_dec_lt : decide (5 < 10) = true := rfl +public theorem nat_dec_eq : decide (5 = 5 : Prop) = true := rfl + +@[reducible] public def lazyBigOff (x : Nat) : Nat := x + 4294967295 +public theorem lazy_ble_offset (x : Nat) : + Nat.ble (lazyBigOff x) 4294967290 = Nat.ble (x + 4294967295) 4294967290 := by + with_reducible rfl + +public structure LazyUnit (scale : Nat) where + val : Nat + +public def LazyUnit.mul (x : LazyUnit a) (factor : Nat) : + LazyUnit (a * factor) := ⟨x.val * factor⟩ + +public def LazyUnit.cast (_ : a = b) (x : LazyUnit a) : LazyUnit b := + ⟨x.val⟩ + +public def lazy_unit_cast (x : LazyUnit 6) : LazyUnit 60 := + (x.mul 10).cast (by decide +kernel) + +-- String primitives (try_str_dispatch) +public theorem str_size_lit : "hello".utf8ByteSize = 5 := rfl + +-- BitVec primitives (try_bitvec_dispatch) +public theorem bv_to_nat_lit : (BitVec.ofNat 16 1234).toNat = 1234 := rfl + +public theorem sizeof_unit : sizeOf () = 1 := rfl + +end IxVMPrim + +/-! ## FLT performance regressions -/ + +namespace IxVMPerf + +local macro "letContinuations% " n:num a:ident x:ident : term => do + let mut body : Lean.TSyntax `term := ← `(term| $x) + for _ in [:n.getNat] do + body ← `(term| let saved : $a := $x + (fun k : $a → $a => k saved) (fun $x : $a => $body)) + return body + +public def let_continuations (A : Type) (x : A) : A := letContinuations% 64 A x + +local macro "mulRow% " n:num : term => do + let mut b := 0 + let mut limb := 1 + for _ in [:n.getNat] do + limb := (limb * 6364136223846793005 + 1442695040888963407) % 2^64 + b := b * 2^64 + limb + let a := 2^64 - 1 + let lhs := Lean.Syntax.mkNumLit (toString a) + let rhs := Lean.Syntax.mkNumLit (toString b) + let product := Lean.Syntax.mkNumLit (toString (a * b)) + `(term| Nat.mul $lhs $rhs = $product) + +public theorem mul_row : mulRow% 512 := rfl + +local macro "contextTower% " n:num a:ident x:ident : term => do + let mut body : Lean.TSyntax `term := ← `(term| $x) + let mut work : Lean.TSyntax `term := ← `(term| $x) + for _ in [:32] do + work ← `(term| (fun z : $a => z) $work) + for _ in [:n.getNat] do + body ← `(term| let saved : $a := $work + (fun unused : Nat => $body) 0) + return body + +public def context_tower (A : Type) (x : A) : A := contextTower% 64 A x + +local macro "mulWide% " n:num : term => do + let mut a := 0 + let mut b := 0 + let mut seed := 7 + for _ in [:n.getNat] do + seed := (seed * 6364136223846793005 + 1442695040888963407) % 2^64 + a := a * 2^64 + seed + seed := (seed * 6364136223846793005 + 1442695040888963407) % 2^64 + b := b * 2^64 + seed + let lhs := Lean.Syntax.mkNumLit (toString a) + let rhs := Lean.Syntax.mkNumLit (toString b) + let result := Lean.Syntax.mkNumLit (toString (a*b)) + `(term| Nat.mul $lhs $rhs = $result) + +public theorem mul_wide : mulWide% 32 := rfl + +end IxVMPerf + +/-! ## Inductive shape fixtures -/ + +namespace IxVMInd + +mutual + public inductive Even : Nat → Prop where + | zero : Even 0 + | succ : ∀ n, Odd n → Even (n + 1) + public inductive Odd : Nat → Prop where + | succ : ∀ n, Even n → Odd (n + 1) +end + +mutual + public inductive IdxTeleN : Nat → Prop where + | z : IdxTeleN 0 + | s : ∀ n, IdxTeleB true → IdxTeleN n + public inductive IdxTeleB : Bool → Prop where + | t : IdxTeleB true + | f : ∀ b, IdxTeleN 0 → IdxTeleB b +end + +mutual + public inductive SoloA : Nat → Prop where + | mk : ∀ n, SoloB true → SoloA n + public inductive SoloB : Bool → Prop where + | mk : ∀ b, SoloA 0 → SoloB b +end + +public unsafe inductive UnsafeSquash (m : Type → Type) : Type where + | mk : (Unit → m (UnsafeSquash m)) → UnsafeSquash m + +public inductive Tree where + | mk : List Tree → Tree + +public inductive Bar2 (α β : Type) where + | mk : α → Bar2 α β + +public inductive DedupM where + | mk : Bar2 DedupM Nat → Bar2 DedupM Bool → DedupM + +public inductive PhantomBox (α : Type 2) : Type (max 2 u) where + | mk : α → PhantomBox α + +public inductive UnivM : Type 2 where + | mk : PhantomBox.{0} UnivM → PhantomBox.{1} UnivM → UnivM + +public inductive Bar1 (α : Type) where + | mk : α → Bar1 α + +public inductive DepthM (α : Type) where + | mk : Bar1 (DepthM α) → Nat → Bar1 (DepthM α) → DepthM α + +public inductive CellC (α : Type) where + | mk : α → Char → CellC α + +public inductive CellI (α : Type) where + | mk : α → Int → CellI α + +public inductive WrapC (α : Type) where + | mk : CellC α → WrapC α + +public inductive WrapI (α : Type) where + | mk : CellI α → WrapI α + +public inductive AuxTie where + | c : WrapC AuxTie → AuxTie + | i : WrapI AuxTie → AuxTie + +public abbrev PredOver (α : Type) : Type := α → Prop + +public inductive HiddenIdx (α : Type) : PredOver α where + | mk : (a : α) → HiddenIdx α a + +public def thmMajorWant (n : Nat) (_pf : n = 1) : Nat := n + +@[expose] public def thmMajorUse : Nat := + thmMajorWant + (And.rec (motive := fun _ => Nat) (fun _ _ => 1) + (⟨Nat.zero_lt_succ 0, Nat.zero_lt_succ 1⟩ : 0 < 1 ∧ 0 < 2)) + (Eq.refl 1) + +public theorem partialKRec : + (@Eq.rec Nat 0 (fun _ _ => Nat) 1 0) = (fun _ => 1) := rfl + +public theorem deepRebase : + ∀ (n : Nat) (_a _b _c _d _e _f _g _h _i _j : Nat), + n + 0 = n := + fun n _ _ _ _ _ _ _ _ _ _ => Nat.add_zero n + +end IxVMInd diff --git a/Tests/Ix/IxonV4VM.lean b/Tests/Ix/IxonV4VM.lean deleted file mode 100644 index cd39d3ec4..000000000 --- a/Tests/Ix/IxonV4VM.lean +++ /dev/null @@ -1,263 +0,0 @@ -module -public import Tests.Ix.IxonV4 -public import Tests.Aiur.Common -public import Ix.IxVM.Toplevel -public import Ix.IxVM.ClaimHarness -public import Ix.Resource.Claim -public import Tests.Ix.ResourceAddressed - -public section -namespace Tests.IxonV4 - -def codecEntrypoints := ⟦ - pub fn ixon_expr_decode() { - let (idx, len) = io_get_info(0, [0]); - let bytes = read_checked_byte_stream(0, idx, len); - let (_, rest) = get_expr(bytes); - assert_eq!(load(rest), ListNode.Nil, "trailing expression bytes"); - } - - pub fn ixon_const_decode() { - let (idx, len) = io_get_info(0, [0]); - let bytes = read_checked_byte_stream(0, idx, len); - let (_, rest) = get_constant(bytes); - assert_eq!(load(rest), ListNode.Nil, "trailing constant bytes"); - } - - pub fn ixon_expr_codec() { - let (idx, len) = io_get_info(0, [0]); - let bytes = read_checked_byte_stream(0, idx, len); - let (expr, rest) = get_expr(bytes); - assert_eq!(load(rest), ListNode.Nil, "trailing expression bytes"); - let encoded = put_expr(load(expr), store(ListNode.Nil)); - assert_eq!(bytes, encoded, "VM expression bytes differ"); - } - - pub fn ixon_const_codec() { - let (idx, len) = io_get_info(0, [0]); - let bytes = read_checked_byte_stream(0, idx, len); - let (constant, rest) = get_constant(bytes); - assert_eq!(load(rest), ListNode.Nil, "trailing constant bytes"); - let encoded = put_constant(constant, store(ListNode.Nil)); - assert_eq!(bytes, encoded, "VM constant bytes differ"); - } -⟧ - -def codecToplevel : Except Aiur.Global Aiur.Source.Toplevel := do - let vm ← Aiur.Library.core.merge Aiur.Library.byteStream - let vm ← vm.merge IxVM.ixon - let vm ← vm.merge IxVM.ixonSerialize - let vm ← vm.merge IxVM.ixonDeserialize - let vm ← vm.merge codecEntrypoints - return vm.prune [`ixon_expr_codec, `ixon_const_codec, - `ixon_expr_decode, `ixon_const_decode] - -def codecBuffer (bytes : ByteArray) : Aiur.IOBuffer := - (default : Aiur.IOBuffer).extend 0 #[0] (bytes.data.map .ofUInt8) - -/-- Check acceptance, empty output, and an unchanged I/O buffer on each interpreter. -Production claims also run through the generated Rust VM with query-count parity. -/ -def checkVM (env : AiurTestEnv) (label : String) (fnName : Lean.Name) - (input : Array Aiur.G) (buffer : Aiur.IOBuffer) (accept : Bool) - (generated : Bool := false) : IO Nat := do - let some index := env.compiled.getFuncIdx fnName - | throw <| IO.userError s!"{label}: missing VM entrypoint {fnName}" - let executed := env.compiled.bytecode.execute index input buffer - match executed with - | .ok (out, io, _) => - unless accept && out.isEmpty && io == buffer do - throw <| IO.userError s!"{label}: VM unexpectedly accepted or changed output" - | .error e => - if accept then throw <| IO.userError s!"{label}: VM execution failed: {e}" - if generated then - match env.compiled.bytecode.executeIxVM index input buffer with - | .ok (out, io, counts) => - let .ok (expectedOut, expectedIO, expectedCounts) := executed - | throw <| IO.userError s!"{label}: generated VM accepted a rejected input" - unless accept && out == expectedOut && io == expectedIO && - counts.size == expectedCounts.size && - (counts.zip expectedCounts).all (fun (actual, expected) => - actual.uniqueRows == expected.uniqueRows && actual.totalHits == expected.totalHits) do - throw <| IO.userError s!"{label}: generated VM output or query counts differ" - | .error e => - if accept then throw <| IO.userError s!"{label}: generated VM execution failed: {e}" - let name := Aiur.Global.mk fnName - let some (.function function) := env.decls.getByKey name - | throw <| IO.userError s!"{label}: missing source entrypoint {fnName}" - let inputs := Aiur.unflattenInputs env.decls input (function.inputs.map (·.2)) - let (interpreted, state) := Aiur.runFunction env.decls name inputs buffer - match interpreted with - | .ok value => - let flattened := Aiur.flattenValue env.decls (fun g => env.compiled.getFuncIdx g.toName) value - unless accept && flattened.isEmpty && state.ioBuffer == buffer do - throw <| IO.userError s!"{label}: source interpretation unexpectedly accepted or changed output" - | .error e => - if accept then throw <| IO.userError s!"{label}: source interpretation failed: {e}" - return if generated then 3 else 2 - -def checkVMBytes (env : AiurTestEnv) (name : String) (bytes : ByteArray) - (accept : Bool) (fnName : Lean.Name := `ixon_expr_codec) : IO Nat := - checkVM env name fnName #[] (codecBuffer bytes) accept - -def checkVMEncoding (env : AiurTestEnv) (name : String) (bytes : ByteArray) - (fnName : Lean.Name := `ixon_expr_codec) : IO Nat := do - let mut checks ← checkVMBytes env name bytes true fnName - checks := checks + (← checkVMBytes env s!"{name}-trailing" (bytes.push 0) false fnName) - for n in [:bytes.size] do - checks := checks + (← checkVMBytes env s!"{name}-truncated-{n}" (bytes.extract 0 n) false fnName) - return checks - -def checkVMProof (env : AiurTestEnv) (fnName : Lean.Name) - (input : Array Aiur.G) (buffer : Aiur.IOBuffer) : IO Unit := do - let index := env.compiled.getFuncIdx fnName |>.get! - let (claim, proof, _) ← IO.ofExcept (env.aiurSystem.prove index input buffer) - IO.ofExcept (env.aiurSystem.verify claim (Aiur.Proof.ofBytes proof.toBytes)) - -/-- Every counted decoding path accepts one complete element and rejects a -short stream when the count is two, 128 (a two-byte TagN count for both -f = 0 and f = 4) or the largest UInt64 (nine bytes). Each truncated stream -supplies one element, then ends. The decode-only entrypoints ensure rejection -happens before reserialization. -/ -def runCountTruncations (env : AiurTestEnv) : IO Nat := do - let mut checks := 0 - for count in [1, 2, 128, (2 ^ 64 - 1 : Nat)] do - let large := count == 2 ^ 64 - 1 - let accept := count == 1 - let tag0 : ByteArray := Ixon.runPut (Ixon.putTagN 0 0 count.toUInt64) - let tag4 (flag : UInt8) : ByteArray := Ixon.runPut (Ixon.putTagN 4 flag count.toUInt64) - let finish (bytes tail : ByteArray) := if accept then bytes ++ tail else bytes - let countLabel := if large then "max-u64" else toString count - for (label, bytes) in [ - ("ref-universes", tag4 2 ++ .mk #[0, 0]), - ("rec-universes", tag4 3 ++ .mk #[0, 0]), - ("app-arguments", tag4 7 ++ .mk #[0x10, 0x10]), - ("lambda-binders", finish (tag4 8 ++ .mk #[0x07, 0x00]) (.mk #[0x10])), - ("forall-binders", finish (tag4 9 ++ .mk #[0x17, 0x00]) (.mk #[0x10]))] do - checks := checks + (← checkVMBytes env s!"{label}-{countLabel}" - bytes accept `ixon_expr_decode) - let axiomPrefix : ByteArray := .mk #[0xd2, 0, 0, 0] - for (label, bytes) in [ - ("sharing", finish (axiomPrefix ++ tag0 ++ .mk #[0x10]) (.mk #[0, 0])), - ("references", finish (axiomPrefix ++ .mk #[0] ++ tag0 ++ - .mk (Array.replicate 32 0)) (.mk #[0])), - ("universes", axiomPrefix ++ .mk #[0, 0] ++ tag0 ++ .mk #[0]), - ("recursor-rules", finish (.mk #[0xd1, 0, 0, 0, 0, 0, 0, 0] ++ - tag0 ++ .mk #[0, 0x10]) (.mk #[0, 0, 0])), - ("constructors", finish (.mk #[0xc1, 1, 0, 0, 0, 0, 0] ++ - tag0 ++ .mk #[0, 0, 0, 0, 0, 0]) (.mk #[0, 0, 0])), - ("mutual-members", finish (tag4 12 ++ .mk #[0, 0x06, 0x05, 0x00, 0x10]) - (.mk #[0, 0, 0]))] do - checks := checks + (← checkVMBytes env s!"{label}-{countLabel}" - bytes accept `ixon_const_decode) - return checks - -def replaceClaimBytes (witness : IxVM.ClaimHarness.ClaimWitness) (bytes : ByteArray) : - IxVM.ClaimHarness.ClaimWitness := - let key := IxVM.ClaimHarness.packedDigestKey (Address.blake3 bytes) - { witness with - input := key - inputIOBuffer := witness.inputIOBuffer.extend 0 key (bytes.data.map .ofUInt8) } - -def checkVMClaim (env : AiurTestEnv) (label : String) - (witness : IxVM.ClaimHarness.ClaimWitness) (accept : Bool) : IO Nat := - checkVM env label witness.funcName witness.input witness.inputIOBuffer accept (generated := true) - -def runVMClaims : IO Nat := do - let vm ← IO.ofExcept (AiurTestEnv.build IxVM.ixVM) - let (base, unit) := Tests.ResourceAddressed.unitEnv - let constant := Tests.ResourceAddressed.identity unit - let (env, validTarget) := Tests.ResourceAddressed.store base constant - let env := { env with anonHints := env.anonHints.insert validTarget .opaque } - let some tree := IxVM.ClaimHarness.envCanonicalTree env - | throw <| IO.userError "VM claim fixture has no tree" - let trees := ({} : Std.HashMap Address Ix.AssumptionTree).insert tree.root tree - let ctx ← IO.ofExcept Ix.ClaimContext.ofDefaultTable - let mut checks := 0 - let revealedType := Address.blake3 (Ixon.runPut (Ixon.putExpr - (.all Tests.ResourceAddressed.linearLocal .localShared (.ref 0 #[]) (.ref 0 #[])))) - for (name, claim) in [ - ("check", Ix.Claim.check ctx validTarget none), - ("check-env", .checkEnv ctx tree.root none), - ("reveal", .reveal validTarget (.defn none none none (some revealedType) none)), - ("contains", .contains tree.root validTarget)] do - let witness ← IO.ofExcept (IxVM.ClaimHarness.buildClaimWitness env claim trees) - checks := checks + (← checkVMClaim vm name witness true) - let bytes := Ix.Claim.ser claim - -- Positive control: the unchanged bytes, sent through the same - -- `replaceClaimBytes` as the mutations below, are accepted. Without it a - -- broken replacement would make every mutation pass vacuously. - checks := checks + (← checkVMClaim vm s!"{name}-identity" - (replaceClaimBytes witness bytes) true) - -- Byte 1 is the object format; the circuit accepts exactly - -- `Ixon.Env.OBJECT_FORMAT` (4), not the previous format or a later one. - for (mutation, bad) in [ - ("trailing", bytes.push 0), - ("legacy-version", bytes.set! 1 (Ixon.Env.OBJECT_FORMAT - 1)), - ("future-version", bytes.set! 1 (Ixon.Env.OBJECT_FORMAT + 1)), - ("wrong-validator", bytes.set! 2 255), ("truncated", bytes.extract 0 (bytes.size - 1))] do - checks := checks + (← checkVMClaim vm s!"{name}-{mutation}" - (replaceClaimBytes witness bad) false) - -- A typing claim's context: the retired validator, another - -- specification digest, and an axiom set beyond the standard three are - -- each refused. - if name == "check" || name == "check-env" then - for (mutation, bad) in [ - ("retired-validator", bytes.set! 2 1), - ("other-specification", bytes.set! 3 (bytes[3]! ^^^ 1)), - ("further-axioms", Ix.Claim.ser (match claim with - | .check c t a => .check { c with axioms := some tree.root } t a - | .checkEnv c r a => .checkEnv { c with axioms := some tree.root } r a - | other => other))] do - checks := checks + (← checkVMClaim vm s!"{name}-{mutation}" - (replaceClaimBytes witness bad) false) - -- A Catalog claim (the two-byte tag `E8 00`) has no circuit arm: Catalog - -- is verified by host or aggregate composition, never by `run_claim`. - if name == "check" then - checks := checks + (← checkVMClaim vm "catalog-no-arm" - (replaceClaimBytes witness (Ix.Claim.ser (.catalog tree.root))) false) - -- Erased typing deliberately accepts a resource-invalid body. The - -- validator byte keeps that fact separate from resource admission. - let (escaping, escapingTarget) := Tests.ResourceAddressed.store base - (Tests.ResourceAddressed.identity unit Tests.ResourceAddressed.linearLocal .shared) - let escaping := { escaping with anonHints := escaping.anonHints.insert escapingTarget .opaque } - let witness ← IO.ofExcept (IxVM.ClaimHarness.buildClaimWitness escaping (.check ctx escapingTarget none)) - checks := checks + (← checkVMClaim vm "explicit erased typing" witness true) - unless (Ix.Resource.validate escaping {}).toOption.isNone do - throw <| IO.userError "escaping fixture passed native resource validation" - -- Resource claims have a native validator, and must fail explicitly at - -- the circuit boundary rather than accepting a host validation result. - let profile : Ix.Resource.Profile := {} - let claim ← IO.ofExcept (Ix.Resource.makeClaim env profile) - let profileAddr ← IO.ofExcept profile.address - let witness ← IO.ofExcept (IxVM.ClaimHarness.buildClaimWitness env claim trees - (({} : Std.HashMap Address ByteArray).insert profileAddr profile.bytes)) - checks := checks + (← checkVMClaim vm "unsupported circuit resource validator" witness false) - let checkWitness ← IO.ofExcept (IxVM.ClaimHarness.buildClaimWitness env (.check ctx validTarget none)) - checkVMProof vm checkWitness.funcName checkWitness.input checkWitness.inputIOBuffer - return checks + 1 - -def runVM (cases : List ExprCase) : IO Nat := do - let env ← IO.ofExcept (AiurTestEnv.build codecToplevel) - let mut checks := 0 - for test in cases do - checks := checks + (← checkVMEncoding env test.name test.bytes) - for (name, bytes) in rejectedExprCases do - checks := checks + (← checkVMBytes env name bytes false) - checks := checks + (← runCountTruncations env) - -- Independently authored declaration bytes cover the six unchanged headers. - for (name, hex) in [ - ("definition", "d006050010000000"), - ("recursor", "d101050102030400010310000000"), - ("axiom", "d2010500000000"), - ("quotient", "d3020500000000"), - ("mutual", "c101000502030001010501020300000000")] do - let some bytes := bytesOfHex hex - | throw <| IO.userError s!"invalid declaration fixture hex: {name}" - checks := checks + (← checkVMEncoding env name bytes `ixon_const_codec) - -- Exercise the proof pipeline for an explicit scoped-borrow representation. - let bytes := ByteArray.mk #[0xA2, 0x0e, 0x00, 0x41, 0x02, 0x11, 0x10] - checkVMProof env `ixon_expr_codec #[] (codecBuffer bytes) - -- Execute and prove the actual production claim boundary as well. - return checks + 2 + (← runVMClaims) - -end Tests.IxonV4 diff --git a/Tests/Ix/Kernel/Arena.lean b/Tests/Ix/Kernel/Arena.lean deleted file mode 100644 index 22e1d302e..000000000 --- a/Tests/Ix/Kernel/Arena.lean +++ /dev/null @@ -1,169 +0,0 @@ -import Ix.Meta -import Ix.CompileCertified -import Ix.Aiur.Protocol -import Ix.Aiur.Compiler -import Ix.IxVM -import Ix.IxVM.ClaimHarness -import Tests.Aiur.Common -import Tests.Ix.Kernel.TutorialMeta -import Tests.Ix.Kernel.TutorialDefs -import Tests.Ix.Kernel.NatReduction -import LSpec - -/-! - Drives the Aiur kernel through every lean-kernel-arena tutorial - fixture (`Tests.Ix.Kernel.TutorialDefs` + `NatReduction`) using the - shared `IxVM.ixVMFull` toplevel + `verify_const` entrypoint. - - Each fixture's outcome is classified against the test case's expected - outcome (good must typecheck; bad must be rejected via Aiur execution - error, where the error originates from an `assert_eq!` failure inside - the Aiur kernel source). - - `verify_const` is a DEBUG entrypoint, not a claim — it - type-checks only the target and trusts transitive deps. Arena uses - it for the per-fixture speed advantage (shared deps would otherwise - be revalidated N times). Verifier policy must never accept this - funcidx as a production claim. - - Raw-const fixtures (`good_raw_consts` / `bad_raw_consts`, whose decls - live in `TutorialMeta.rawConstsExt` rather than `env.constants`) are - compiled into the shared Ixon env via `collectDepsWithExtras`, same - as the Rust tutorial suite. - - Skips: - - renaming test cases (collision tests, not single-constant - typechecks); - - constants filtered by `compile_env` (ungrounded blocks); - - constants in `knownIncompatible` (meta-only Lean kernel checks the - Aiur kernel structurally cannot see). --/ - -open LSpec -open Tests.Ix.Kernel.TutorialMeta -open IxVM.ClaimHarness - -namespace Tests.Ix.Kernel.Arena - -structure ArenaCheck where - name : Lean.Name - expectPass : Bool - -/-- Constants the Aiur kernel structurally cannot adjudicate. Skipped - rather than counted as pass/fail. -/ -def knownIncompatible : Array (Lean.Name × String) := #[ - -- Duplicate `levelParams` is a meta-mode hygiene check (Lean's - -- `Level.Param` is name-keyed). Ixon Anon erases the structural - -- duplication pattern (only `lvls : UInt64` count survives) and the - -- Ixon compiler resolves `Param u` via first-occurrence, silently - -- making the second binder dead. Rejection happens only in the Rust - -- kernel via `has_duplicate_level_params` (Meta-mode only). - (`tut06_bad01, - "duplicate levelParams: Anon-mode hygiene check, see src/ix/kernel/check.rs:107"), - -- AdvNat.rec is a malformed raw recursor payload. Tests.Ix.Kernel.Tutorial - -- checks it through a dedicated path (`rsCheckMalformedRecRuleIxonFFI`) - -- that injects the bad rule into Ixon. - (`Tests.Ix.Kernel.TutorialDefs.AdvNat.rec, - "malformed rec rule; Tutorial uses bespoke FFI"), - -- Same reason as tut06_bad01: duplicate levelParams is Meta-mode - -- hygiene; Ixon Anon stores only the `lvls` COUNT, so the duplication - -- pattern is erased before the Aiur kernel can see it. - (`inductLevelParam, - "duplicate levelParams: Anon-mode hygiene check, see src/ix/kernel/check.rs:107") -] - -/-- Fixtures proved by `native_decide`, which the tutorial expects Lean's kernel - to accept by native evaluation. A claim's theory has none: `Lean.reduceBool` - never reduces, so IxVM rejects them. -/ -def nativeEvaluationFixtures : Array Lean.Name := #[ - `Tests.Ix.Kernel.TutorialDefs.natBleTrue, `Tests.Ix.Kernel.TutorialDefs.natBleFalse, - `Tests.Ix.Kernel.TutorialDefs.natBeqTrue, `Tests.Ix.Kernel.TutorialDefs.natBeqFalse] - -private def collectChecks (env : Lean.Environment) : Array ArenaCheck := Id.run do - let skipSet : Std.HashSet Lean.Name := - knownIncompatible.foldl (init := {}) (fun s (n, _) => s.insert n) - -- Raw consts (`good_raw_consts` / `bad_raw_consts`) never enter - -- `env.constants` (the Lean kernel refused them); they are compiled - -- into the shared Ixon env via `collectDepsWithExtras` below. Consts - -- `compile_env` refuses to ground surface as skips in `buildInput`. - let rawNames : Std.HashSet Lean.Name := - (getRawConsts env).foldl (fun s ci => s.insert ci.name) {} - let mut out : Array ArenaCheck := #[] - let mut seen : Std.HashSet Lean.Name := {} - for tc in getTestCases env do - if tc.renamings.size > 0 then continue - let pass := tc.outcome == .good - for n in tc.decls do - if seen.contains n then continue - seen := seen.insert n - if !env.constants.contains n && !rawNames.contains n then continue - if skipSet.contains n then continue - out := out.push { name := n, expectPass := pass && !nativeEvaluationFixtures.contains n } - return out - -/-- Build the `verify_const` input for `name` against the shared - `ixonEnv`. Returns `error` when `compile_env` filtered the - constant (no Ixon address) — caller treats that as a skip. -/ -private def buildInput (ixonEnv : Ixon.Env) (name : Lean.Name) : - Except String (Array Aiur.G × Aiur.IOBuffer) := - match ixonEnv.getAddr? (Ix.Name.fromLeanName name) with - | none => .error "ungrounded by compile_env" - | some addr => - -- Subject-only check via `verify_const`. Each fixture runs in - -- isolation; we don't revalidate transitive deps N times. - match buildVerifyConst ixonEnv addr with - | .ok witness => .ok (witness.input, witness.inputIOBuffer) - | .error e => .error e - -/-- Run the arena suite against `compiled` (already-compiled Aiur - `IxVM.ixVMFull` toplevel) using a single shared Ixon env. Returns one - `TestSeq` entry per fixture. -/ -def arenaTests (env : Lean.Environment) - (compiled : Aiur.CompiledToplevel) : IO TestSeq := do - let funIdx ← match compiled.getFuncIdx `verify_const with - | some i => pure i - | none => throw <| IO.userError "verify_const entrypoint missing" - let checks := collectChecks env - -- Raw fixtures don't live in `env.constants`; close over the check - -- names with the raw consts as extra lookups, then append the raw - -- consts themselves so `compile_env` grounds them (mirrors the Rust - -- tutorial suite's env build). - let rawConsts := getRawConsts env - let rawMap : Std.HashMap Lean.Name Lean.ConstantInfo := - rawConsts.foldl (fun m ci => m.insert ci.name ci) - (Std.HashMap.emptyWithCapacity rawConsts.size) - let (_, closed) := collectDepsWithExtras env rawMap - ((checks.map (·.name)).toList ++ (rawConsts.toList.map (·.name))) - let allConsts := closed ++ rawConsts.toList.map fun ci => (ci.name, ci) - let (rawEnv, _, _) ← IO.ofExcept <| - Ix.Cert.compileUnchecked (Ix.CompileM.canonInput allConsts.toArray 32) - let ixonEnv ← IO.ofExcept (IxVM.ClaimHarness.withDefaultRoleBinding rawEnv) - let mut tests : TestSeq := .done - for c in checks do - let label := s!"arena {if c.expectPass then "GOOD" else "BAD"} {c.name}" - match buildInput ixonEnv c.name with - | .error reason => tests := tests ++ test s!"{label}: skipped ({reason})" true - | .ok (input, ioBuffer) => - match compiled.bytecode.execute funIdx input ioBuffer with - | .ok _ => - tests := tests ++ - test label (c.expectPass) - | .error e => - -- A `bad_*` fixture counts as correctly rejected only when the - -- kernel actually REFUSED it. `assert_eq!` failures qualify, and - -- so do unmatched-match aborts: this kernel deliberately relies - -- on an unmatched runtime value aborting rather than spending - -- circuit width on `_ => assert_eq!(0, 1)` arms, so "no match - -- case for value N" is a verdict too. - -- - -- `invalid IO key` is NOT. It means the witness never supplied - -- the bytes, so execution died before reaching the logic under - -- test — scoring it as a rejection is how a fixture rots into a - -- green test that checks nothing. No fixture currently relies on - -- it; this keeps it that way. - let refused := (e.splitOn "invalid IO key").length == 1 - tests := tests ++ - test s!"{label} ({e})" (!c.expectPass && refused) - return tests - -end Tests.Ix.Kernel.Arena diff --git a/Tests/Ix/Kernel/ArenaExclude.lean b/Tests/Ix/Kernel/ArenaExclude.lean index 634ece970..67ca34a0b 100644 --- a/Tests/Ix/Kernel/ArenaExclude.lean +++ b/Tests/Ix/Kernel/ArenaExclude.lean @@ -4,8 +4,8 @@ - Constants registered under a `.bad` test-case outcome (intentional kernel rejections). - - Constants in `Tests.Ix.Kernel.Arena.knownIncompatible` (cases the - Aiur kernel structurally cannot adjudicate — see comments there). + - Constants in `knownIncompatible` (cases the + kernel structurally cannot adjudicate). - Constants whose test case carries a non-empty `renamings` field (collision tests, not single-constant typechecks). @@ -18,10 +18,17 @@ -/ import Ix.Meta import Tests.Ix.Kernel.TutorialMeta -import Tests.Ix.Kernel.Arena open Tests.Ix.Kernel.TutorialMeta -open Tests.Ix.Kernel.Arena (knownIncompatible) + +def knownIncompatible : Array (Lean.Name × String) := #[ + (`tut06_bad01, + "duplicate levelParams: Anon-mode hygiene check"), + (`Tests.Ix.Kernel.TutorialDefs.AdvNat.rec, + "malformed rec rule; Tutorial uses bespoke FFI"), + (`inductLevelParam, + "duplicate levelParams: Anon-mode hygiene check") +] /-- Parse `--out ` / `--out=` from the arg list. Last one wins. -/ private def outPath? : List String → Option String diff --git a/Tests/Ix/Kernel/BuildPrimitives.lean b/Tests/Ix/Kernel/BuildPrimitives.lean index b0cf58f4c..ac6060ef2 100644 --- a/Tests/Ix/Kernel/BuildPrimitives.lean +++ b/Tests/Ix/Kernel/BuildPrimitives.lean @@ -196,13 +196,13 @@ opaque rsPrimAddrsCanonicalFFI : IO (Array (String × String)) compiling that primitive's Lean declaration through the live certified compile pipeline. A mismatch means someone changed the compile/serialize logic in a way that altered a primitive's - content hash — Aiur and downstream kernel primitive resolution + content hash — LegacyAiur and downstream kernel primitive resolution will silently break if `PrimAddrs::new()` isn't updated. On failure: re-run `lake test -- --ignored rust-kernel-build-primitives` to dump the fresh table, then update `PrimAddrs::new` in `crates/common/src/prim_addrs.rs` and its - Lean/Aiur mirrors. + Lean/LegacyAiur mirrors. Exception: `eagerReduce` is a synthetic kernel marker whose PrimAddrs value (`0xff…3`) intentionally diverges from its diff --git a/Tests/Ix/Kernel/PrimAddrs.lean b/Tests/Ix/Kernel/PrimAddrs.lean index 5b7dba834..a28b5685f 100644 --- a/Tests/Ix/Kernel/PrimAddrs.lean +++ b/Tests/Ix/Kernel/PrimAddrs.lean @@ -1,28 +1,4 @@ -/- - Guards the IxVM's address literals. - - The IxVM kernel once hardcoded ~77 primitive constant addresses as - 32-byte literals (`fn nat_add_addr() -> Addr { store([0xd6u8, ...]) }`) - so reduction could recognize `Nat.add` etc. by address alone. A single - wrong byte was a soundness-relevant defect, invisible to the FFT-pinned - suite and the arena fixtures; one shipped for months (`bool_false_addr`, - last 8 bytes wrong). Every constant a native rule recognizes or builds - is now a role, read through the claim's role binding and validated - against its specification, so the only literal left is the - specification digest. - - This test keeps it that way. It reads the byte arrays out of the - ELABORATED toplevel — not the source text — and requires the - specification digest, equal to `Ix.SpecDigest.specDigest`, to be the - only one: an address literal reappearing fails, and so does the - extractor finding nothing (e.g. an AST shape change). A literal that - did reappear must also resolve to the canonical address its name - claims, computed at test runtime from `Ix.PrimAddrs`. --/ import Ix.Meta -import Ix.Aiur.Compiler -import Ix.IxVM -import Ix.IxVM.Toplevel import Ix.PrimAddrs import Ix.SpecDigest import Tests.Ix.Kernel.PrimitiveTable @@ -32,125 +8,16 @@ open LSpec namespace Tests.Ix.Kernel.PrimAddrs -/-- Read a 32-byte address literal out of an elaborated function body. - Recognizes exactly the shape the addr helpers use: - `store([b0u8, …, b31u8])`. Anything else → `none` (the function is - not an address constant). -/ -private def addrLiteralOf (body : Aiur.Source.Term) : Option Address := - match body with - | .store (.array elts) | .array elts => - if elts.size != 32 then none else Id.run do - let mut bytes : Array UInt8 := Array.mkEmpty 32 - for e in elts do - match e with - | .u8Lit n => bytes := bytes.push (UInt8.ofNat n) - | _ => return none - return some ⟨⟨bytes⟩⟩ - | _ => none - -/-- Every `fn () -> Addr`-shaped constant in the toplevel, paired - with the address its literal encodes. -/ -private def collectAddrFns (t : Aiur.Source.Toplevel) : - Array (String × Address) := Id.run do - let mut out : Array (String × Address) := #[] - for f in t.functions do - if !f.inputs.isEmpty then continue - if let some a := addrLiteralOf f.body then - out := out.push (f.name.toName.toString, a) - return out - -/-- The IxVM's address literals, besides its specification digest: none. Every - constant a native rule recognizes or builds is a role, read through the - claim's role binding and validated against its specification. -/ -private def expectedAddrFns : Array String := #[] - -/-- The canonical address set, computed at test runtime from the Lean - parity table + reserved markers — the same source the host closure - walker (`Ix.primAddrSet`) consults. -/ -private def canonical : Std.HashMap Address String := Id.run do - let mut m : Std.HashMap Address String := {} - for (name, a) in Ix.PrimAddrs.leanParityTable do - m := m.insert a name - for (name, a) in Ix.PrimAddrs.reservedMarkerAddrs do - m := m.insert a name - return m - -/-- Fold a name to a comparison key: drop namespace separators and - underscores, lowercase. `nat_add_addr` and `Nat.add` both become - `natadd`. -/ -private def normKey (s : String) : String := - ((s.replace "_" "").replace "." "").toLower - -private def dropSuffix (s suf : String) : String := - if s.endsWith suf then (s.dropEnd suf.length).toString else s - -/-- The addr function's key: last namespace component, with the - dispatch-site suffix (`_dec`/`_io`/`_iota` — several primitives have - one addr function per call site), the `_addr` marker, and a trailing - `_type`/`_ty` removed, then normalized. `str` is spelled out, since - the kernel abbreviates `String`. -/ -private def fnKey (fnName : String) : String := - let base := (fnName.splitOn ".").getLast! - let base := ["_dec", "_io", "_iota", "_pin"].foldl dropSuffix base - let base := dropSuffix base "_addr" - let base := ["_type", "_ty"].foldl dropSuffix base - let k := normKey base - if k == "str" || (k.startsWith "str" && !k.startsWith "string") - then "string" ++ k.drop 3 else k - -/-- Addr functions whose name does not follow `snake_case` of the Lean - constant even after the normalizations above. Maps the function's key - to the constant it must resolve to; anything absent is required to - match by normalized name. -/ -private def nameExceptions : Std.HashMap String String := .ofList [ - ("quotctor", "Quot.mk"), - ("quotlift", "Quot.lift"), - ("quotind", "Quot.ind") -] - -def suite : List TestSeq := Id.run do - let some toplevel := (IxVM.ixVMFull).toOption - | [test "IxVM toplevel builds" false] - let fns := collectAddrFns toplevel - let mut tests : TestSeq := - -- Exactly the expected literals: the specification digest alone. An - -- address literal reappearing, or the extractor silently matching - -- nothing (an AST shape change: the digest must be found), fails here. - test s!"the only address literal is the specification digest ({fns.size})" - (fns.size == expectedAddrFns.size + 1 && - ((fns.map (·.1.splitOn "." |>.getLast!)).filter (· != "spec_digest")).qsort (· < ·) - == expectedAddrFns.qsort (· < ·)) - for (fnName, addr) in fns do - -- The circuit's specification digest is a digest, not a primitive - -- address: it must equal `Ix.SpecDigest.specDigest`. - if (fnName.splitOn ".").getLast! == "spec_digest" then - tests := tests ++ test s!"{fnName} = Ix.SpecDigest.specDigest" - (Ix.SpecDigest.specDigest.toOption == some addr) - continue - match canonical[addr]? with - | some canonName => - -- Assert the function resolves to the constant its NAME claims. - -- Membership alone is not enough: this map is keyed by address, so - -- a table where `int_add_addr` held `Int.mul`'s bytes would still - -- find a canonical entry and pass. That permutation is precisely - -- the defect this suite exists to catch — the kernel would apply - -- one primitive's native semantics under another's name. - -- The addr function may spell the constant fully (`int_add_addr` ↔ - -- `Int.add`) or only its final component; both are accepted, anything - -- else must be declared in `nameExceptions`. - let k := fnKey fnName - let ok : Bool := match nameExceptions[k]? with - | some want => canonName == want - | none => k == normKey canonName || k == fnKey canonName - tests := tests ++ test s!"{fnName} = {canonName}" ok - | none => - -- A named address constant that matches no canonical address is - -- the defect this test exists for: the kernel will never - -- recognize the primitive it thinks it encodes. Report the bytes. - -- (Sentinel fillers must be written inline, not as named addr - -- functions — see the zero-Addr tuple returns in Whnf/DefEq.) - tests := tests ++ - test s!"{fnName}: {addr} not in canonical primitive table" false - return [tests] ++ Tests.Ix.Kernel.PrimitiveTable.suite +def specDigestParity : TestSeq := + .individualIO "KernelRoleSpec.aiur spec_digest matches Ix.SpecDigest.specDigest" none (do + let source ← IO.FS.readFile "IxVM/IxVM/Modules/KernelRoleSpec.aiur" + let .ok digest := Ix.SpecDigest.specDigest + | return (false, 0, 1, some "Ix.SpecDigest.specDigest failed") + let expected := ", ".intercalate (digest.hash.data.toList.map fun b => s!"UInt8::BYTE_{b.toNat}") + let ok := (source.splitOn expected).length > 1 + return (ok, if ok then 1 else 0, 1, + if ok then none else some s!"KernelRoleSpec.aiur did not contain {expected}")) .done + +def suite : List TestSeq := [specDigestParity] ++ Tests.Ix.Kernel.PrimitiveTable.suite end Tests.Ix.Kernel.PrimAddrs diff --git a/Tests/IxonV4Main.lean b/Tests/IxonV4Main.lean index 21d43c9fe..c0f57f4c3 100644 --- a/Tests/IxonV4Main.lean +++ b/Tests/IxonV4Main.lean @@ -1,6 +1,5 @@ import Tests.Ix.IxonV4 import Tests.Ix.IxonV4FFI -import Tests.Ix.IxonV4VM import Tests.Ix.IxonText import Tests.Ix.ResourceAdmit import Tests.Ix.ResourceAddressed @@ -64,8 +63,6 @@ def main (args : List String) : IO Unit := do IO.println s!"Ixon v4: {checks} golden byte and rejection checks passed" let ffiChecks ← Tests.IxonV4.runFFI cases IO.println s!"Ixon v4: {ffiChecks} FFI roundtrip and Lean/Rust byte parity checks passed" - let vmChecks ← Tests.IxonV4.runVM cases - IO.println s!"Ixon v4: {vmChecks} VM execution, interpretation, and proof checks passed" let textChecks ← Tests.IxonText.runText IO.println s!"Ixon text grammar {Ixon.Syntax.VERSION}: {textChecks} text contract and \ rejection checks passed" diff --git a/Tests/IxonV4Primitives.lean b/Tests/IxonV4Primitives.lean index 83923556e..b039795d9 100644 --- a/Tests/IxonV4Primitives.lean +++ b/Tests/IxonV4Primitives.lean @@ -48,7 +48,7 @@ def main (args : List String) : IO Unit := do IO.println s!"Exported {kernelPrimitives.size} primitive addresses and \ {env.consts.size} constants to {dir}" -- The checked-in table must be this output: it is the record the Rust - -- `PrimAddrs::new`, `Ix/Tc/Primitive.lean` and the IxVM literals mirror. + -- `PrimAddrs::new`, `Ix/Tc/Primitive.lean` and the LegacyIxVM literals mirror. unless (← IO.FS.readFile "Tests/Fixtures/ixon-v4/primitives.tsv") == text do throw <| IO.userError s!"Tests/Fixtures/ixon-v4/primitives.tsv differs from the live \ addresses; copy {tsvPath} over it and update `PrimAddrs::new`" diff --git a/Tests/Main.lean b/Tests/Main.lean index 34a6684ad..fa961eaed 100644 --- a/Tests/Main.lean +++ b/Tests/Main.lean @@ -1,17 +1,6 @@ -import Tests.Aiur -import Tests.Aiur.IOBuffer -import Tests.Aiur.RustSyntax import Tests.Ix.Ixon import Tests.Ix.IxonRejectParity import Tests.Ix.IxonSyntax -import Tests.Ix.IxVM -import Tests.Ix.IxVM.Eval -import Tests.Ix.IxVM.Exploits -import Tests.Ix.IxVM.DefinitionDependencies -import Tests.Ix.IxVM.BindingAnchors -import Tests.Ix.IxVM.BindingFrontier -import Tests.Ix.IxVM.TagN -import Tests.Ix.IOIngress import Tests.Ix.Claim import Tests.Ix.Merkle import Tests.Ix.AssumptionTree @@ -33,7 +22,6 @@ import Tests.Ix.Compile.SelectedClosure import Tests.Ix.Compile.ClosureWhole import Tests.Ix.Compile.CheckerSupport import Tests.Ix.Compile.PackUnits -import Tests.Ix.IxVM.SubstBoundaries import Tests.Ix.Decompile import Tests.Ix.Kernel.BuildPrimitives import Tests.Ix.Kernel.CheckCompPoly @@ -41,7 +29,6 @@ import Tests.Ix.Kernel.CheckPrimeGaps import Tests.Ix.Kernel.CheckTauCeti import Tests.Ix.Kernel.CheckTauCetiReduction import Tests.Ix.Kernel.Tutorial -import Tests.Ix.Kernel.Arena import Tests.Ix.Kernel.FastPaths import Tests.Ix.Kernel.PrimAddrs import Tests.Ix.Kernel.ReaderRoundtrip @@ -72,13 +59,9 @@ import Tests.Ix.Kernel.Pins import Tests.Ix.Kernel.AccelSemantics import Tests.FFI import Tests.Keccak -import Tests.MultiStark -import Tests.Aggr -import Tests.AggrProof import Tests.AggrBindingReuse import Tests.AggrToolchains import Tests.AggrSemantics -import Tests.AggrActivation import Tests.Cli import Tests.CompressionCli import Tests.Ix.Ixes @@ -92,7 +75,6 @@ import Tests.Ix.TruthMines import Tests.Registry import Ix.Common import Ix.Meta -import Ix.IxVM /-! Main test runner and registry for `IxTests`. @@ -129,14 +111,9 @@ def registry : List Entry := [ -- the strict readers of the checkers' reports (Tests.Ix.Compile.KernelReport) .suite "compiler-reports" .primary Tests.Ix.Compile.KernelReportTests.suite, .suite "compiler-lean-reports" .primary Tests.Ix.Compile.LeanReportTests.suite, - .runner "ixvm-subst-boundaries" .primary Tests.Ix.IxVM.SubstBoundaries.runSuite, -- selected closures (`collectSelectedDeps`): whole logical units, a -- matcher's unit, mutual siblings, checker support from `Role.deps` .suite "compiler-selected-closure" .primary Tests.Ix.Compile.SelectedClosure.suite, - .suite "aiur-cross" .primary [AiurTests.Cross.tests], - .runner "aiur-io-buffer" .primary AiurTests.IOBuffer.runSuite, - .suite "aiur-cost" .primary [AiurTests.Cost.tests], - .suite "aiur-trace-plan" .primary [AiurTests.TracePlan.tests], .suite "prim-addrs" .primary Tests.Ix.Kernel.PrimAddrs.suite, -- the role table's wire vectors (Tests/Fixtures/ixon-v4/role-table.tsv), which -- Rust's codec is tested against, are IxC's codec's @@ -166,62 +143,11 @@ def registry : List Entry := [ .suite "decompile-unit" .primary Tests.Decompile.unitSuite, -- getFileEnv body-inclusion regression guard (IO: loads a fixture file) .suiteIO "getfileenv-body" .primary (do return [← Tests.Ix.EnvBody.suite]), - -- primary runners: quick suites kept as deferred `IO` actions (not - -- `TestSeq` values) so their setup (Aiur system builds, STARK proofs) does - -- not run at module initialization for unrelated invocations. All are - -- seconds-scale: ixvm-tagn about 16 s, aiur-prove - -- about 11 s and the rest 2-4 s each. - .runner "aiur-rust-syntax" .primary AiurTests.RustSyntax.run, -- Reductions no kernel may make beyond Lean's (class methods reduced -- without their instance, `numBits ≡ 64`, the `Fin.val` commute): every -- probe's closure through IxC. .runner "kernel-fast-paths" .primary Tests.Ix.Kernel.FastPaths.run, - -- The circuit TagN codec against the host codec (about 16 s). - .runner "ixvm-tagn" .primary Tests.Ix.IxVM.TagN.runSuite, - -- every IO byte stream of the IxVM, ix_aggr and multi-stark verifier - -- circuits goes through the range-checked reader - .suiteIO "io-ingress" .primary Tests.IOIngress.suite, - .runner "aiur-prove" .primary (do - IO.println "aiur-prove" - match AiurTestEnv.build (pure toplevel) with - | .error e => IO.eprintln s!"Aiur setup failed: {e}"; return 1 - | .ok env => do - let r1 ← LSpec.lspecEachIO aiurTestCases fun tc => pure (env.runTestCase tc) - -- The same toplevel with `testGroups` applied: the members share one - -- circuit, and the whole suite of grouped cases proves through it. - match AiurTestEnv.build (pure toplevel) testGroups with - | .error e => IO.eprintln s!"Aiur grouped setup failed: {e}"; return 1 - | .ok genv => do - let r2 ← LSpec.lspecEachIO groupedTestCases fun tc => pure (genv.runTestCase tc) - let r3 ← LSpec.lspecIO - (.ofList [("aiur-grouping", [groupingStructureChecks genv.compiled]), - ("aiur-inline-order", [assertOrderChecks env.compiled])]) [] - return if r1 == 0 && r2 == 0 && r3 == 0 then 0 else 1), - .runner "aiur-hashes" .primary (do - IO.println "aiur-hashes" - let .ok blake3Env := AiurTestEnv.build (do - let t ← Aiur.Library.core.merge Aiur.Library.byteStream - let t ← t.merge Aiur.Library.blake3 - t.merge blake3BoundaryProgram) - | IO.eprintln "Blake3 setup failed"; return 1 - let r1 ← LSpec.lspecEachIO blake3TestCases fun tc => pure (blake3Env.runTestCase tc) - let .ok sha256Env := AiurTestEnv.build (do - let t ← Aiur.Library.core.merge Aiur.Library.byteStream; t.merge IxVM.sha256) - | IO.eprintln "SHA256 setup failed"; return 1 - let r2 ← LSpec.lspecEachIO sha256TestCases fun tc => pure (sha256Env.runTestCase tc) - return if r1 == 0 && r2 == 0 then 0 else 1), - .runner "rbtree-map" .primary (do - IO.println "rbtree-map" - match AiurTestEnv.build (pure IxVM.rbTreeMap) with - | .error e => IO.eprintln s!"RBTreeMap setup failed: {e}"; return 1 - | .ok env => LSpec.lspecEachIO rbTreeMapTestCases fun tc => pure (env.runTestCase tc)), - -- Multi-STARK recursive verifier: `multi-stark` runs the verifier's - -- primitive self-tests, `recursive-verifier` the full - -- factorial-prove → recursive-verify → reject-tampering pipeline. - .runner "multi-stark" .primary Tests.MultiStark.selfTestSuite, - .runner "recursive-verifier" .primary Tests.MultiStark.endToEndSuite, - -- Converged heterogeneous aggregation circuit: all fifteen `ix_aggr` shapes, - -- driver/cache semantics, and one negative case per broken binding. + -- Aggregate driver/cache/manifest semantics. .runner "ix-aggr" .primary Tests.Aggr.convergedSuite, -- `.ixes` manifest parser: trailing tree/peaks sections and strictness. .runner "ixes-manifest" .primary Tests.Ix.Ixes.suite, @@ -270,111 +196,8 @@ def registry : List Entry := [ -- decompile fidelity .runner "fidelity-initstd" (.ci .landingInitStdCli) Tests.Ix.InitStd.fidelity, .suite "cert-evidence-agreement" .primary Tests.Ix.Cert.Statement.evidenceSuite, - .runner "aggregate-proof" (.manual "a proof round trip through the production ix_aggr circuit; minutes of proving") Tests.Aggr.proofRoundTrip, .runner "aggregate-binding-reuse" (.manual "one binding proof file discharges two aggregates, end to end through the `ix` binary; minutes of recursion and about 190 GB, needs `lake build ix`; `binding-proof-cli` runs it without the aggregates") Tests.Aggr.BindingReuse.run, .runner "aggregate-toolchains" (.manual "libraries from four Lean toolchains proven with one IxVM key and joined into one catalog root, end to end through the `ix` binary; tens of minutes of proving, needs `lake build ix` and `zstd`; IX_TOOLCHAINS_MAX_RAM sets the aggregate RAM budget in GiB (default 140)") Tests.Aggr.Toolchains.run, - .runner "kernel-dependencies" (.manual "the IxVM definition-dependency checks alone; `ixvm` runs them too") (do - match AiurTestEnv.build IxVM.ixVM IxVM.functionGroups with - | .error e => IO.eprintln s!"IxVM setup failed: {e}"; return 1 - | .ok vm => - let tests ← Tests.Ix.IxVM.DefinitionDependencies.tests vm.compiled - LSpec.lspecIO (.ofList [("kernel-dependencies", [tests])]) []), - .env "ixvm" (.ci .misc) fun env => do - let kernelChecks ← kernelChecks env - -- The kernel CheckEnv smokes. - let claimEnv ← IxVM.ClaimHarness.loadIxonEnv ``Nat.add_comm env - let envFull ← claimCheckEnvFull claimEnv - let envFrontier ← claimCheckEnvFrontier claimEnv - let checkAsm ← claimCheckWithAsm claimEnv - let revealFields ← claimRevealDefnFields claimEnv - let revealExpr ← claimRevealDefnExpr claimEnv - let revealModes ← claimRevealBinderModes - let revealCPrj ← claimRevealCPrj claimEnv - let containsTc ← claimContains - -- Shared-infrastructure test entrypoints live only in the FULL - -- toplevel (pruning drops them so test-only circuits never widen a - -- committed kernel system). - let kernelUnitTests := .exec `kernel_unit_tests - let serdeTest ← serdeNatAddComm env - match AiurTestEnv.build IxVM.ixVM IxVM.functionGroups, AiurTestEnv.build IxVM.ixVMFull with - | .error e, _ | _, .error e => - IO.eprintln s!"IxVM env build failed: {e}"; return 1 - | .ok vmEnv, .ok fullVmEnv => - IO.eprintln "[ixvm] eval: reduction, output contracts, and compiled fixtures" - let evalSeq ← Tests.Ix.IxVM.Eval.tests vmEnv - let evalCompiledSeq ← Tests.Ix.IxVM.Eval.compiledTests env vmEnv - let evalCommandSeq ← Tests.Ix.IxVM.Eval.commandTests env vmEnv - IO.eprintln "[ixvm] eval: dependent, recursive, and neutral-term fixtures" - let evalDifficultSeq ← Tests.Ix.IxVM.Eval.difficultTests env vmEnv - IO.eprintln "[ixvm] eval: generated differential corpus (24 samples)" - let evalDifferentialSeq ← Tests.Ix.IxVM.Eval.differentialTests env vmEnv - -- Kernel-arena fixtures: the repo's NEGATIVE corpus (every - -- `bad_*` must be rejected by an in-kernel assert_eq!). Runs - -- through the kernel's subject-only `verify_const` debug - -- entrypoint, which lives only in the FULL toplevel — the - -- production one carries `verify_claim` alone. - let arenaSeq ← Tests.Ix.Kernel.Arena.arenaTests env fullVmEnv.compiled - -- Adversarial Ixon: exploit attempts authored as raw Ixon - -- constants, below the layer the arena's Lean fixtures can - -- reach. Each case pins the kernel's verdict, which is REJECT - -- except where accepting is the specified claim semantics. - let exploitSeq ← Tests.Ix.IxVM.Exploits.exploitTests env vmEnv.compiled - let dependencySeq ← Tests.Ix.IxVM.DefinitionDependencies.tests vmEnv.compiled - let bindingAnchorChecks ← Tests.Ix.IxVM.BindingAnchors.defaultChecks vmEnv.compiled - let bindingAnchorSeq := bindingAnchorChecks.foldl - (fun tests (name, passed) => tests ++ LSpec.test name passed) LSpec.TestSeq.done - let bindingFrontierChecks ← Tests.Ix.IxVM.BindingFrontier.defaultChecks vmEnv.compiled - let bindingFrontierSeq := bindingFrontierChecks.foldl - (fun tests (name, passed) => tests ++ LSpec.test name passed) LSpec.TestSeq.done - let aiurSeq := (kernelChecks ++ - [envFull, envFrontier, checkAsm, - revealFields, revealExpr, revealModes, revealCPrj, containsTc]).foldl - (init := .done) fun s tc => s ++ vmEnv.runTestCase tc - -- Codegen parity gate: the generated Rust kernel is emitted from - -- the toplevel, so this runs the same witnesses through both - -- engines and asserts they agree. It is only meaningful against a - -- CURRENT `ix codegen` output — regenerate after any Aiur edit, or - -- this gate compares against a stale kernel. Reuses the - -- `kernelChecks` cases (`runParityCase` ignores the FFT pins), so - -- the per-constant witness setup runs once, not twice. - let parityTasks ← kernelChecks.mapM fun tc => - IO.asTask (pure (runParityCase vmEnv.compiled tc)) - let paritySeq ← parityTasks.foldlM (init := .done) fun s task => do - let seq ← IO.ofExcept task.get - pure (s ++ seq) - let fullSeq := [kernelUnitTests, serdeTest].foldl (init := .done) - fun s tc => s ++ fullVmEnv.runTestCase tc - -- Shard pipeline: witness built in Rust (thin-frontier claim, - -- parallel closure walk) and run on the native kernel. Pinned FFT - -- is the regression signal. - let shardSeq ← match (← shardCheckEnvCase env) with - -- The target constant is absent from this toolchain: a failure, as - -- an absent pinned constant is in `kernelChecks`, so that a - -- toolchain bump that renames it cannot turn the pin into a pass. - -- A fixture that no longer selects any owned constants throws. - | none => pure (LSpec.test - "shard pipeline: the target ByteArray.utf8DecodeChar?_utf8EncodeChar_append is in the environment" - false) - | some (handle, ownedBlob) => - let funIdx := vmEnv.compiled.getFuncIdx `verify_claim |>.get! - match vmEnv.compiled.bytecode.shardCheckWithEnv - funIdx handle ownedBlob false with - | .error e => - pure (LSpec.test s!"shard pipeline execution: {e}" false) - | .ok (_, _, qc) => - -- Exact pin, same convention as `kernelCheckEntries` - -- (`.round.toUInt64.toNat`): any cost shift must be an - -- explicit, reviewed bump. - let actual := - (Aiur.computeStats vmEnv.compiled qc vmEnv.shapes).totalFftCost.round.toUInt64.toNat - pure (LSpec.test - s!"Shard pipeline FFT matches: expected 85_826_059_914, got {actual}" - (actual = 85_826_059_914)) - LSpec.lspecIO - (.ofList [("ixvm", - [evalSeq, evalCompiledSeq, evalCommandSeq, evalDifficultSeq, evalDifferentialSeq, - fullSeq, aiurSeq, arenaSeq, exploitSeq, dependencySeq, bindingAnchorSeq, - bindingFrontierSeq, paritySeq, shardSeq])]) [], -- Selected closures (Tests.Ix.Compile.{SelectedClosure,ClosureWhole,CheckerSupport,PackUnits}): -- closure against whole, checker-support ground, and `ix pack` carrying the reference closure. .runner "compiler-selected-closure-e2e" (.ci .compilerClosures) Tests.Ix.Compile.SelectedClosure.run, @@ -385,9 +208,6 @@ def registry : List Entry := [ .runner "tc-pins" (.ci .compilerClosures) Tests.Tc.Pins.run, -- Exact retained acceleration inputs, value/head witnesses and full closures. .runner "kernel-accel-semantics" (.ci .compilerClosures) Tests.Ix.Kernel.AccelSemantics.run, - -- the 132-case, twice-executed `ix_aggr` activation matrix, kept out of the - -- primary suite and independent of the large environment - .runner "aggregate-activation" (.manual "a diagnostic matrix (132 cases, run twice)") Tests.Aggr.activationAudit, -- Compression CLI setup and proof-rejection checks, run explicitly. .runner "compression-cli" (.manual "compression CLI setup and proof-rejection checks; needs `lake build ix`") (do Tests.CompressionCli.run @@ -404,7 +224,6 @@ def required : List (String × String) := [ ("cert-evidence-agreement", "primary"), ("ix-aggr", "primary"), ("lean-export", "primary"), - ("io-ingress", "primary"), ("kernel-source-ingress", "primary"), ("kernel-reader-roundtrip", "primary"), ("kernel-bundle-evidence", "primary"), @@ -416,7 +235,6 @@ def required : List (String × String) := [ ("exact-sharing", "primary"), ("ixon-reject-parity", "primary"), ("role-equations", "primary"), - ("ixvm-tagn", "primary"), ("ixes-manifest", "primary"), ("kernel-record-check", "primary"), ("compile-ind-flags", "primary"), @@ -432,7 +250,6 @@ def required : List (String × String) := [ ("checker-support-regression", "ci:compiler-closures"), ("tc-pins", "ci:compiler-closures"), ("kernel-accel-semantics", "ci:compiler-closures"), - ("ixvm", "ci:misc"), ("kernel-tutorial", "ci:misc"), ("initstd-reference", "ci:landing-initstd-cli"), ("admission-hash-diff-initstd", "ci:landing-initstd-cli"), diff --git a/Tests/MultiStark.lean b/Tests/MultiStark.lean deleted file mode 100644 index a3fad9a93..000000000 --- a/Tests/MultiStark.lean +++ /dev/null @@ -1,284 +0,0 @@ -module - -public import Tests.ProofHelpers -public import Tests.MultiStarkCircuits -public import Ix.Aiur.Meta -public import Ix.Aiur.Protocol -public import Ix.Aiur.Compiler -public import MultiStark -public import Blake3.Rust - -/-! -# Tests for the Multi-STARK recursive verifier - -These exercise `MultiStark.lean` (the in-circuit verifier) the way the former -standalone `RecursiveVerifier.lean` executable did, split into two primary -runners (registered in `Tests/Main.lean`, both wired into `ci.yml`): - -* **`multi-stark`** — `selfTestSuite`. Executes the verifier's primitive - `*_test` entrypoints (`Tests/MultiStarkCircuits.lean`), each of which validates one - primitive (Blake3 MMCS leaf/compress, Merkle `verify_batch`, the challenger, - FRI fold + reduced openings, non-native Goldilocks/ExtGoldilocks arithmetic) - against the Rust reference values from `multi-stark` (`gen_pcs_refs`). Cheap: just - bytecode execution, no proving. The in-circuit `assert_eq!`s do the checking; - every entrypoint returns `1` on success. - -* **`recursive-verifier`** — `endToEndSuite`. The full pipeline (a few - seconds, dominated by proving + the verifier executions): - 1. prove `factorial(5) = 120` with the Multi-STARK backend, - 2. feed that proof as non-deterministic advice (IO channel 0; vk on 1, claims - on 2) and run `verify_multi_stark_proof` over it — it must accept, - 3. two negative tests: a tampered proof byte and a tampered claim must both be - rejected by the verifier's own checks (Fiat-Shamir / Merkle / OOD / FRI). - -The verifier toplevel is compiled separately from the test toplevel -(`MultiStark.multiStark` vs `MultiStark.multiStarkTests`) so the `*_test` -circuits never widen the production verifier — see `Tests/MultiStarkCircuits.lean`. --/ - -public section - -open LSpec Aiur - -namespace Tests.MultiStark -open Tests.ProofHelpers - --- ════════════════════════════════════════════════════════════════════════════ --- `multi-stark`: verifier primitive self-tests (execution-only, no proving) --- ════════════════════════════════════════════════════════════════════════════ - -/-- The verifier's primitive self-test entrypoints (`Tests/MultiStarkCircuits.lean`) -and a one-line description of what each validates against the Rust reference. -/ -def selfTests : List (Lean.Name × String) := [ - (`pcs_hash_test, "Blake3 MMCS leaf/compress match reference"), - (`pcs_merkle_test, "Merkle verify_batch matches reference (root + tamper)"), - (`lane_hash_test, "lane-granular leaf blake3 matches byte blake3 (blocks/chunks/fold)"), - (`io_hash_test, "IO-slice blake3 matches byte blake3 (blocks/chunks/fold)"), - (`rows_hash_test, "rows-walking leaf hash matches concat+canon reference"), - (`sample_bits_test, "challenger sample_bits matches reference"), - (`pcs_challenger4_test, "PCS challenger continuation (α_pcs/α_fri/β/index) matches reference"), - (`fri_fold_test, "FRI arity-2 fold_row matches reference"), - (`ro_fold_test, "open_input reduced-opening math matches reference"), - (`gl_addsub_test, "non-native Goldilocks add/sub match reference"), - (`gl_muldiv_test, "non-native Goldilocks mul/inverse/div match reference"), - (`eg_ops_test, "non-native ExtGoldilocks add/mul/inverse/div match reference"), -] - -/-- Compile the verifier-plus-tests toplevel once, then execute each `*_test` -entrypoint and assert it returns `1`. -/ -def selfTestSuite : IO UInt32 := do - IO.println "multi-stark" - let top ← match MultiStark.multiStarkTests with - | .error e => IO.eprintln s!"verifier-tests toplevel merge failed: {e}"; return 1 - | .ok t => pure t - let compiled ← match top.compile with - | .error e => IO.eprintln s!"verifier-tests compilation failed: {e}"; return 1 - | .ok c => pure c - let primitives ← lspecEachIO selfTests fun (name, desc) => pure <| - match compiled.getFuncIdx name with - | none => test s!"{name}: {desc} — entrypoint not found" false - | some idx => - match compiled.bytecode.execute idx #[] default with - | .error e => test s!"{name}: {desc} — execution failed: {e}" false - | .ok (output, _, _) => test s!"{name}: {desc}" (output == #[Aiur.G.ofNat 1]) - let some rowIdx := compiled.getFuncIdx `pcs_row_shape_test - | IO.eprintln "PCS row-shape entrypoint missing"; return 1 - let some lengthIdx := compiled.getFuncIdx (`list_length ++ `U8_8) - | IO.eprintln "PCS defensive row-length check missing"; return 1 - let cases := ([0, 1, 3, 8, 17] : List Nat).flatMap fun nx => - ([0, 1, 3, 8, 17] : List Nat).flatMap fun nz => - [0, 1, 2].map fun mode => (nx, nz, mode) - let shapes ← lspecEachIO cases fun (nx, nz, mode) => pure <| - let result := compiled.bytecode.execute rowIdx - #[Aiur.G.ofNat nx, Aiur.G.ofNat nz, Aiur.G.ofNat mode] default - let label := s!"PCS row widths {nx}/{nz}, bucket mode {mode}" - if nx != nz then expectErr label result else - match result with - | .error e => test s!"{label} — execution failed: {e}" false - | .ok (output, _, counts) => - test label (output == #[Aiur.G.ofNat (if mode == 0 then 0 else 1)] && - (mode != 1 || counts[lengthIdx]!.uniqueRows == 0)) - return if primitives == 0 && shapes == 0 then 0 else 1 - --- ════════════════════════════════════════════════════════════════════════════ --- `recursive-verifier`: prove factorial(5)=120, verify it, reject tampering --- ════════════════════════════════════════════════════════════════════════════ - -/-- A branching entrypoint with eighteen gated store/call/return lookups for -synthesis to choose two messages per accumulator at quotient degree four. -The smaller factorial and memory circuits retain quotient degree two, so -recursive verification exercises both degrees within the same proof. Loads -are behind a call boundary so local store/load forwarding cannot remove the -lookups that this coverage fixture deliberately needs. -/ -def factorialProgram : Source.Toplevel := ⟦ - fn read_cell(ptr: &G) -> G { - load(ptr) - } - - pub fn factorial(n: G) -> G { - match n { - 0 => 1, - _ => n * factorial(n - 1), - } - } - - pub fn fact_entry(n: G) -> G { - match n { - 0 => 1, - _ => - let a = read_cell(store(n)); - let b = read_cell(store(n + 1)); - let c = read_cell(store(n + 2)); - let d = read_cell(store(n + 3)); - let e = read_cell(store(n + 4)); - let f = read_cell(store(n + 5)); - let g = read_cell(store(n + 6)); - let h = read_cell(store(n + 7)); - assert_eq!(b, a + 1); - assert_eq!(c, a + 2); - assert_eq!(d, a + 3); - assert_eq!(e, a + 4); - assert_eq!(f, a + 5); - assert_eq!(g, a + 6); - assert_eq!(h, a + 7); - factorial(a), - } - } -⟧ - -/-- Serialize the public claims for the verifier's IO channel, matching the -in-circuit `read_claims` wire format: u64 `num_claims`, then per claim a u64 -`num_vals` followed by the `Val`s as canonical 8-byte little-endian `u64`s. -/ -def serializeClaims (claims : Array (Array Aiur.G)) : ByteArray := Id.run do - let mut out : Array UInt8 := u64le claims.size - for c in claims do - out := out ++ u64le c.size - for g in c do - out := out ++ u64le g.val.toNat - return ⟨out⟩ - -def endToEndSuite : IO UInt32 := do - -- ── factorial system ────────────────────────────────────────────────────── - let facCompiled ← match factorialProgram.compile with - | .error e => IO.eprintln s!"factorial compilation failed: {e}"; return 1 - | .ok c => pure c - let facSystem := AiurSystem.build facCompiled.bytecode recCommitParams innerFri - let facIdx ← match facCompiled.getFuncIdx `fact_entry with - | some i => pure i - | none => IO.eprintln "fact_entry entrypoint not found"; return 1 - - -- ── prove factorial(5) = 120 (`G` is a reserved DSL token, spell it qualified) - let input := #[Aiur.G.ofNat 5] - let (claim, proof, _) ← match facSystem.prove facIdx input default with - | .ok result => pure result - | .error e => IO.eprintln s!"factorial prove failed: {e}"; return 1 - let expectedClaim := buildClaim facIdx input #[Aiur.G.ofNat 120] - let mixedQuotients := facSystem.circuitShapes.any (·.quotientDegree == 4) && - facSystem.circuitShapes.any (·.quotientDegree == 2) - -- Verify and serialize the proof transport consumed in-circuit. - let proofBytes ← match facSystem.proofToAdviceBytes claim proof with - | .ok bytes => pure bytes - | .error e => IO.eprintln s!"advice re-encoding failed: {e}"; return 1 - - -- ── serialize proof (advice) + vk + claims, with public Blake3 digests ── - let proofGs : Array Aiur.G := proofBytes.data.map .ofUInt8 - let vkBytes := facSystem.vkBytes - let vkGs : Array Aiur.G := vkBytes.data.map .ofUInt8 - let claimBytes := serializeClaims #[claim] - let claimGs : Array Aiur.G := claimBytes.data.map .ofUInt8 - -- Public input = vk digest ++ claims digest as packed-4-byte field - -- elements (the FRI parameters are read in-circuit from the digest-bound - -- vk, not passed publicly). `verifierPubInput` is the single home of the - -- packing recipe. - let pubInput : Array Aiur.G := MultiStark.verifierPubInput vkBytes claimBytes - -- IO advice buffer: proof on channel 0, vk on 1, claims on 2 (each keyed `[0]`). - let mkIO := fun (pGs cGs : Array Aiur.G) => - (((default : IOBuffer).extend 0 #[Aiur.G.ofNat 0] pGs).extend 1 #[Aiur.G.ofNat 0] vkGs).extend - 2 #[Aiur.G.ofNat 0] cGs - - -- ── verifier system (the PRODUCTION toplevel — no test circuits) ──────────── - let vTop ← match MultiStark.multiStark with - | .error e => IO.eprintln s!"verifier toplevel merge failed: {e}"; return 1 - | .ok t => pure t - let vCompiled ← match vTop.compileWithGroups MultiStark.verifierFunctionGroups with - | .error e => IO.eprintln s!"verifier compilation failed: {e}"; return 1 - | .ok c => pure c - let vIdx ← match vCompiled.getFuncIdx `verify_multi_stark_proof with - | some i => pure i - | none => IO.eprintln "verify_multi_stark_proof entrypoint not found"; return 1 - - -- ── negative-test inputs ──────────────────────────────────────────────────── - -- Tampered proof advice: locate the first byte of the stage-1 commitment - -- in the batch's first shard header — after the `u64` shard count, the - -- header's `Vec` activation bitmap and the cap-length prefix. This - -- keeps the batch structurally parseable while making the header disagree - -- with the proof it describes (and moving the lookup challenges away from - -- the ones the proof was produced under). - let activeLen := (List.range 8).foldl (fun n i => - n ||| (proofBytes.data[8 + i]!.toUInt64 <<< (i * 8).toUInt64)) 0 - let firstCommitByte := 8 + 8 + activeLen.toNat + 8 - let badProofBytes := - proofBytes.set! firstCommitByte - (UInt8.ofNat ((proofBytes.data[firstCommitByte]!.toNat + 1) % 256)) - -- Widened opened row: the last stage-2 row of the last shard's last active - -- circuit — the tail of the stream, a `u64` count then that many extension - -- elements of two limbs — gains one zero column. The stream still parses - -- to its end, but the row no longer has the width the verifying key gives - -- the circuit, which `ood_loop` pins before the PCS runs. - let widenedProofBytes := - let n := proofBytes.size - let u64At (p : Nat) : Nat := (List.range 8).foldl (fun a i => - a + (proofBytes.data[p + i]!.toNat <<< (8 * i))) 0 - match (List.range 256).find? (fun c => c > 0 && u64At (n - 16 * c - 8) == c) with - | some c => - proofBytes.set! (n - 16 * c - 8) (UInt8.ofNat (c + 1)) ++ - ByteArray.mk #[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] - | none => proofBytes - -- Tampered claim (with a matching keccak digest): 120 → 121. Feeds a different - -- value into Fiat-Shamir (→ different ζ) and the lookup accumulator, so the - -- composition/quotient identity no longer holds even though the binding passes. - let badClaim : Array Aiur.G := claim.set! (claim.size - 1) (Aiur.G.ofNat 121) - let badClaimBytes := serializeClaims #[badClaim] - let badClaimInput : Array Aiur.G := - MultiStark.verifierPubInput vkBytes badClaimBytes - - -- ── run the (expensive) checks, then assert ───────────────────────────────── - IO.println "recursive-verifier (proving + recursive verification, ~1.5 min)…" - -- Native wire-format roundtrip before exercising the in-circuit path. - let innerVerify := facSystem.verify claim (.ofBytes proof.toBytes) - -- Native path: Rust-built advice buffer + codegen'd verifier - -- (`crates/ixvm-codegen/src/aiur_multi_stark.rs`). - let honest := - vCompiled.bytecode.executeMultiStark vIdx pubInput proofBytes vkBytes claimBytes - -- Interpreter over the Lean-built buffer: the parity reference for the - -- codegen'd verifier — same output, same per-circuit query counts. - let honestInterp := vCompiled.bytecode.execute vIdx pubInput (mkIO proofGs claimGs) - let parity : Bool := match honest, honestInterp with - | .ok (out, qc), .ok (outI, _, qcI) => - out == outI && qc.size == qcI.size && - (qc.zip qcI).all fun (a, b) => - a.uniqueRows == b.uniqueRows && a.totalHits == b.totalHits - | _, _ => false - let tamperedProof := - vCompiled.bytecode.executeMultiStark vIdx pubInput badProofBytes vkBytes claimBytes - let tamperedClaim := - vCompiled.bytecode.executeMultiStark vIdx badClaimInput proofBytes vkBytes badClaimBytes - let widenedRow := - vCompiled.bytecode.executeMultiStark vIdx pubInput widenedProofBytes vkBytes claimBytes - lspecIO (.ofList [("recursive-verifier", [ - test "factorial(5) claim = #[functionChannel, facIdx, 5, 120]" (claim == expectedClaim), - test s!"inner proof exercises quotient degrees two and four (main/stage2/quotient: {facSystem.circuitShapes.map fun s => (s.mainWidth, s.stage2Width, s.quotientDegree)})" mixedQuotients, - expectOk "inner factorial proof verifies" innerVerify, - expectOk "verifier accepts honest proof (vk digest bound + OOD + FRI)" honest, - test "codegen'd verifier matches interpreter (output + query counts)" parity, - expectErr "tampered proof advice rejected (verification checks)" tamperedProof, - expectErr "tampered claim rejected (OOD/accumulator mismatch)" tamperedClaim, - test "widened opened row still parses to the stream's end" - (widenedProofBytes.size == proofBytes.size + 16), - expectErr "opened row wider than the verifying key's width rejected" widenedRow, - ])]) [] - - -end Tests.MultiStark - -end diff --git a/Tests/MultiStarkCircuits.lean b/Tests/MultiStarkCircuits.lean deleted file mode 100644 index 5f4a4e14a..000000000 --- a/Tests/MultiStarkCircuits.lean +++ /dev/null @@ -1,423 +0,0 @@ -module -public import MultiStark - -/-! -# Self-tests for the Multi-STARK recursive verifier - -The `pub fn *_test` entrypoints validating the verifier's primitives against -Rust reference values (`multi-stark/src/types.rs` test outputs). They live in a -SEPARATE toplevel fragment, merged on top of the production verifier toplevel -(`MultiStark.multiStarkTests` in `Tests/MultiStarkCircuits.lean`): every `pub fn` adds a -circuit to the compiled system, so keeping the tests out of -`MultiStark.multiStark` keeps the production verifier's width free of -test-only circuits. - -Cross-fragment references (e.g. `gl_val`, `mmcs_hash_row`, `fri_fold2`, -`ch_sample_bits`) resolve after the merge — the merged toplevel has a flat -namespace. --/ - -public section - -namespace MultiStark - -def tests := ⟦ - -- Equal-width checks must survive empty rows and a missing/wrong-height - -- bucket. A matching bucket checks widths during the existing fold. - fn pcs_shape_px(n: G) -> List‹U64› { - match n { - 0 => store(ListNode.Nil), - _ => store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], pcs_shape_px(n - 1))), - } - } - fn pcs_shape_pz(n: G) -> List‹Ext› { - match n { - 0 => store(ListNode.Nil), - _ => store(ListNode.Cons([3, 5], pcs_shape_pz(n - 1))), - } - } - pub fn pcs_row_shape_test(nx: G, nz: G, mode: G) -> G { - let buckets = match mode { - 0 => store(ListNode.Nil), - 1 => store(ListNode.Cons(Bucket.Mk(1, [1, 0], [0, 0]), store(ListNode.Nil))), - _ => store(ListNode.Cons(Bucket.Mk(2, [1, 0], [0, 0]), store(ListNode.Nil))), - }; - let bits = store(ListNode.Cons(0, store(ListNode.Nil))); - let result = ri_apply(buckets, 1, bits, 1, [3, 5], pcs_shape_px(nx), pcs_shape_pz(nz), [7, 3]); - list_length(result) - } - - -- ========================================================================== - -- Native Goldilocks arithmetic (vs `gl_ops_ref`; reference vectors kept as - -- their canonical LE bytes and folded with `gl_val`, which is injective on - -- canonical bytes). - -- ========================================================================== - fn assert_g8(x: Goldilocks, e: Goldilocks) -> G { - assert_eq!(x, e); - 1 - } - pub fn gl_addsub_test() -> G { - let a = @gl_val([16u8, 50u8, 84u8, 118u8, 152u8, 186u8, 220u8, 254u8]); -- 0xFEDCBA9876543210 - let b = @gl_val([240u8, 222u8, 188u8, 154u8, 120u8, 86u8, 52u8, 18u8]); -- 0x123456789ABCDEF0 - assert_eq!(assert_g8(a + b, @gl_val([255u8, 16u8, 17u8, 17u8, 18u8, 17u8, 17u8, 17u8])), 1); - assert_eq!(assert_g8(a - b, @gl_val([32u8, 83u8, 151u8, 219u8, 31u8, 100u8, 168u8, 236u8])), 1); - assert_eq!(assert_g8(b - a, @gl_val([225u8, 172u8, 104u8, 36u8, 223u8, 155u8, 87u8, 19u8])), 1); - -- edge: (p-1) + 5 ≡ 4 ; 5 - (p-1) ≡ 6 - let pm1 = @gl_val([0u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8]); -- 0xFFFFFFFF00000000 - let five = @gl_val([5u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); - assert_eq!(assert_g8(pm1 + five, @gl_val([4u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])), 1); - assert_eq!(assert_g8(five - pm1, @gl_val([6u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])), 1); - 1 - } - - fn assert_eg(x: ExtGoldilocks, e0: Goldilocks, e1: Goldilocks) -> G { - assert_eq!(assert_g8(x[0], e0), 1); - assert_eq!(assert_g8(x[1], e1), 1); - 1 - } - pub fn gl_muldiv_test() -> G { - let a = @gl_val([16u8, 50u8, 84u8, 118u8, 152u8, 186u8, 220u8, 254u8]); -- 0xFEDCBA9876543210 - let b = @gl_val([240u8, 222u8, 188u8, 154u8, 120u8, 86u8, 52u8, 18u8]); -- 0x123456789ABCDEF0 - assert_eq!(assert_g8(a * b, @gl_val([212u8, 186u8, 123u8, 108u8, 31u8, 253u8, 234u8, 250u8])), 1); - assert_eq!(assert_g8(@gl_inverse(a), @gl_val([97u8, 29u8, 109u8, 46u8, 183u8, 100u8, 8u8, 102u8])), 1); - assert_eq!(assert_g8(a * @gl_inverse(b), @gl_val([63u8, 59u8, 61u8, 54u8, 46u8, 255u8, 29u8, 186u8])), 1); - -- edge: (p-1)·5 ≡ p-5 - let pm1 = @gl_val([0u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8]); - let five = @gl_val([5u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); - assert_eq!(assert_g8(pm1 * five, @gl_val([252u8, 255u8, 255u8, 255u8, 254u8, 255u8, 255u8, 255u8])), 1); - -- a·a⁻¹ = 1 and b·b⁻¹ = 1 - assert_eq!(assert_g8(a * @gl_inverse(a), 1), 1); - assert_eq!(assert_g8(b * @gl_inverse(b), 1), 1); - 1 - } - pub fn eg_ops_test() -> G { - -- e0 = (0xFEDCBA9876543210, 0x0123456789ABCDEF), e1 = (0x1111111122222222, 0x3333333344444444) - let e0 = [@gl_val([16u8, 50u8, 84u8, 118u8, 152u8, 186u8, 220u8, 254u8]), - @gl_val([239u8, 205u8, 171u8, 137u8, 103u8, 69u8, 35u8, 1u8])]; - let e1 = [@gl_val([34u8, 34u8, 34u8, 34u8, 17u8, 17u8, 17u8, 17u8]), - @gl_val([68u8, 68u8, 68u8, 68u8, 51u8, 51u8, 51u8, 51u8])]; - assert_eq!(assert_eg(@eg_add(e0, e1), - @gl_val([49u8, 84u8, 118u8, 152u8, 170u8, 203u8, 237u8, 15u8]), - @gl_val([51u8, 18u8, 240u8, 205u8, 154u8, 120u8, 86u8, 52u8])), 1); - assert_eq!(assert_eg(@eg_mul(e0, e1), - @gl_val([10u8, 238u8, 162u8, 36u8, 224u8, 127u8, 182u8, 134u8]), - @gl_val([215u8, 234u8, 152u8, 224u8, 219u8, 254u8, 32u8, 67u8])), 1); - assert_eq!(assert_eg(@eg_inverse(e0), - @gl_val([221u8, 238u8, 29u8, 131u8, 179u8, 89u8, 214u8, 216u8]), - @gl_val([114u8, 99u8, 206u8, 108u8, 15u8, 88u8, 161u8, 246u8])), 1); - assert_eq!(assert_eg(@eg_div(e0, e1), - @gl_val([42u8, 59u8, 64u8, 77u8, 226u8, 214u8, 95u8, 63u8]), - @gl_val([200u8, 46u8, 148u8, 147u8, 124u8, 180u8, 248u8, 140u8])), 1); - -- e0 · e0⁻¹ = 1 - assert_eq!(assert_eg(@eg_mul(e0, @eg_inverse(e0)), 1, 0), 1); - 1 - } - - -- ========================================================================== - -- Challenger (vs `pcs_challenger_ref` / `pcs_challenger4_ref`). - -- ========================================================================== - - -- Self-test: `sample_bits(20)` after observing the single `Val` - -- `0x0102030405060708` (8 LE bytes) must equal the reference `799146` - -- (`pcs_challenger_ref` in `multi-stark/src/types.rs`). - pub fn sample_bits_test() -> G { - let input = store(ListNode.Cons(8u8, store(ListNode.Cons(7u8, store(ListNode.Cons(6u8, - store(ListNode.Cons(5u8, store(ListNode.Cons(4u8, store(ListNode.Cons(3u8, - store(ListNode.Cons(2u8, store(ListNode.Cons(1u8, store(ListNode.Nil))))))))))))))))); - let (bits, _i, _o) = ch_sample_bits(input, store(ListNode.Nil), 20); - assert_eq!(bits_to_num(bits), 1019203); - 1 - } - - -- Self-test: replay the synthetic PCS challenger sequence from - -- `pcs_challenger4_ref` (multi-stark/src/types.rs) and check every sampled - -- challenge against the reference. Decisively exercises the two consecutive - -- ext samples (α_pcs then α_fri) sharing one hash `output` stream. - pub fn pcs_challenger4_test() -> G { - -- post-ζ input buffer = observe V0 then V1 (forward / observation order). - let v0 = [8u8, 7u8, 6u8, 5u8, 4u8, 3u8, 2u8, 1u8]; -- 0x0102030405060708 - let v1 = [136u8, 119u8, 102u8, 85u8, 68u8, 51u8, 34u8, 17u8]; -- 0x1122334455667788 - let input = snoc_b8(snoc_b8(store(ListNode.Nil), v0), v1); - -- α_pcs (output empty ⇒ flush), then α_fri (CONSECUTIVE ⇒ thread output). - let (apcs, input, o1) = pcs_sample_ext(input, store(ListNode.Nil)); - let (afri, input, o2) = pcs_sample_ext(input, o1); - assert_eq!(apcs[0], 17795849114622667264); - assert_eq!(apcs[1], 4116843485681689527); - assert_eq!(afri[0], 11768399386651893439); - assert_eq!(afri[1], 10948618071942561750); - -- observe commit (clears output), sample β. - let v2 = [239u8, 190u8, 173u8, 222u8, 0u8, 0u8, 0u8, 0u8]; -- 0x00000000deadbeef - let (input, _oc) = ch_observe_val(input, v2); - let (beta, input, _ob) = pcs_sample_ext(input, store(ListNode.Nil)); - assert_eq!(beta[0], 12096272534537655203); - assert_eq!(beta[1], 11431251745744402868); - -- observe final_poly coeff + log_arity (each a Val), then sample the index. - let v3 = [4u8, 3u8, 2u8, 1u8, 13u8, 12u8, 11u8, 10u8]; -- 0x0a0b0c0d01020304 - let v4 = [2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]; -- 0x0000000000000002 - let (input, _o3) = ch_observe_val(input, v3); - let (input, _o4) = ch_observe_val(input, v4); - let (bits, _bi, _bo) = ch_sample_bits(input, store(ListNode.Nil), 20); - assert_eq!(bits_to_num(bits), 458922); - 1 - } - - -- ========================================================================== - -- FRI fold + reduced openings (vs `fri_fold_ref` / `ro_fold_ref`). - -- ========================================================================== - - -- Self-test: arity-2 fold at index 5, log_height 3 vs the `fri_fold_ref` - -- reference (computed by the real `TwoAdicFriFolding::fold_row`). - pub fn fri_fold_test() -> G { - let index_bits = store(ListNode.Cons(1, store(ListNode.Cons(0, - store(ListNode.Cons(1, store(ListNode.Nil))))))); - let e0 = [@gl_val([17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8]), - @gl_val([34u8, 34u8, 34u8, 34u8, 34u8, 34u8, 34u8, 34u8])]; - let e1 = [@gl_val([51u8, 51u8, 51u8, 51u8, 51u8, 51u8, 51u8, 51u8]), - @gl_val([68u8, 68u8, 68u8, 68u8, 68u8, 68u8, 68u8, 68u8])]; - let beta = [@gl_val([85u8, 85u8, 85u8, 85u8, 85u8, 85u8, 85u8, 85u8]), - @gl_val([102u8, 102u8, 102u8, 102u8, 102u8, 102u8, 102u8, 102u8])]; - let folded = fri_fold2(index_bits, 3, beta, e0, e1); - assert_eq!(folded[0], 9349172584842537206); - assert_eq!(folded[1], 984486879173118962); - 1 - } - - -- Self-test vs `ro_fold_ref`: x at index 5 / log_height 3, then accumulate - -- (p_z − p_x)/(z − x) over 3 columns with alpha powers. - pub fn ro_fold_test() -> G { - let index_bits = store(ListNode.Cons(1, store(ListNode.Cons(0, - store(ListNode.Cons(1, store(ListNode.Nil))))))); - let x = ro_x(index_bits, 3); - assert_eq!(x, 117440512); - let z = [@gl_val([154u8, 120u8, 86u8, 52u8, 18u8, 0u8, 0u8, 0u8]), - @gl_val([1u8, 239u8, 205u8, 171u8, 0u8, 0u8, 0u8, 0u8])]; - let alpha = [@gl_val([17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8]), - @gl_val([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])]; - let px0 = [11u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]; - let px1 = [22u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]; - let px2 = [33u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]; - let p_x = store(ListNode.Cons(px0, store(ListNode.Cons(px1, - store(ListNode.Cons(px2, store(ListNode.Nil))))))); - let pz0 = [@gl_val([100u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), @gl_val([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])]; - let pz1 = [@gl_val([200u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), @gl_val([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])]; - let pz2 = [@gl_val([44u8, 1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), @gl_val([3u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])]; - let p_z = store(ListNode.Cons(pz0, store(ListNode.Cons(pz1, - store(ListNode.Cons(pz2, store(ListNode.Nil))))))); - let q = @eg_inverse(@eg_sub(z, [x, 0])); - let (s, _ap) = ro_fold(p_x, p_z, alpha, [0, 0], [1, 0]); - let ro = @eg_mul(q, s); - assert_eq!(ro[0], 7130765474285082575); - assert_eq!(ro[1], 12254464995725315436); - 1 - } - - -- ========================================================================== - -- Keccak MMCS sponge/compression + Merkle verify_batch - -- (vs `pcs_ref_values` / `pcs_merkle_ref`). Compares each output lane mod p - -- via `limb_to_field` (all reference lanes are canonical, so this is exact). - -- ========================================================================== - - -- A small single-byte value as a `U64` (8 LE bytes). - fn u64_of(b: U8) -> U64 { - [b, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8] - } - -- `[i+1, i+2, …, n]` as a `List‹U64›`. - fn build_range(i: G, n: G) -> List‹U64› { - match n - i { - 0 => store(ListNode.Nil), - _ => store(ListNode.Cons(u64_of(u8_from_field_unsafe(i + 1)), build_range(i + 1, n))), - } - } - fn assert_digest(d: Digest, e0: G, e1: G, e2: G, e3: G) -> G { - assert_eq!(@limb_to_field(d[0]), e0); - assert_eq!(@limb_to_field(d[1]), e1); - assert_eq!(@limb_to_field(d[2]), e2); - assert_eq!(@limb_to_field(d[3]), e3); - 1 - } - pub fn pcs_hash_test() -> G { - -- Leaf hashes: `blake3` over the row's canonical 8-LE-byte serialization - -- (`SerializingHasher`). Reference digests from the `gen_pcs_refs` - -- generator in `multi-stark`, cross-checked with `b3sum`. - let d3 = mmcs_hash_row(build_range(0, 3)); - assert_eq!(assert_digest(d3, 4163513704854067712, 9384471110237386207, - 13671380075168847140, 1533933974187331481), 1); - let d17 = mmcs_hash_row(build_range(0, 17)); - assert_eq!(assert_digest(d17, 8431665677194841246, 4495111673672851816, - 7709594803249897978, 12683511314940902790), 1); - let d22 = mmcs_hash_row(build_range(0, 22)); - assert_eq!(assert_digest(d22, 14017803411919507972, 9236340131056405306, - 11356520758956579629, 2008168271701183309), 1); - let d20 = mmcs_hash_row(build_range(0, 20)); - assert_eq!(assert_digest(d20, 8822819174011220231, 9835070768970864367, - 9646176123001837413, 1210344881395534089), 1); - -- Compression: `blake3(a_bytes || b_bytes)` of two 32-byte child digests. - let c = mmcs_compress(store([u64_of(1u8), u64_of(2u8), u64_of(3u8), u64_of(4u8)]), - store([u64_of(5u8), u64_of(6u8), u64_of(7u8), u64_of(8u8)])); - assert_eq!(assert_digest(load(c), 16432952784711837466, 12565756115161032165, - 6915939387221618258, 11123773279136987111), 1); - 1 - } - - -- Merkle `verify_batch` self-test against the `pcs_merkle_ref` reference: a - -- cap-height-0 tree over 3 matrices of heights 8/4/2 (log-heights 3/2/1), - -- opened at index 5 (path bits 1,0,1). Checks the recomputed root matches the - -- committed root and that the cap index is 0, then that a tampered opened row - -- yields a different (rejected) root. - pub fn pcs_merkle_test() -> G { - -- opened rows (matrix order): m0 row5, m1 row2, m2 row1. - let row0 = store(ListNode.Cons(u64_of(11u8), store(ListNode.Cons(u64_of(12u8), store(ListNode.Nil))))); - let row1 = store(ListNode.Cons(u64_of(107u8), store(ListNode.Cons(u64_of(108u8), - store(ListNode.Cons(u64_of(109u8), store(ListNode.Nil))))))); - let row2 = store(ListNode.Cons(u64_of(202u8), store(ListNode.Nil))); - let rows = store(ListNode.Cons(row0, store(ListNode.Cons(row1, - store(ListNode.Cons(row2, store(ListNode.Nil))))))); - -- log-heights and path bits (index 5 = 0b101, LSB first). - let lhs = store(ListNode.Cons(3, store(ListNode.Cons(2, store(ListNode.Cons(1, store(ListNode.Nil))))))); - let ibits = store(ListNode.Cons(1, store(ListNode.Cons(0, store(ListNode.Cons(1, store(ListNode.Nil))))))); - -- authentication path SIB0, SIB1, SIB2 (each a Digest = [U64; 4]). - let sib0 = [[229u8, 114u8, 223u8, 248u8, 35u8, 4u8, 112u8, 11u8], - [133u8, 106u8, 85u8, 90u8, 195u8, 164u8, 85u8, 141u8], - [13u8, 243u8, 100u8, 106u8, 55u8, 39u8, 129u8, 101u8], - [0u8, 39u8, 10u8, 147u8, 198u8, 106u8, 172u8, 30u8]]; - let sib1 = [[234u8, 150u8, 163u8, 93u8, 30u8, 78u8, 129u8, 226u8], - [24u8, 27u8, 220u8, 33u8, 92u8, 142u8, 194u8, 191u8], - [193u8, 63u8, 223u8, 131u8, 67u8, 230u8, 55u8, 63u8], - [169u8, 209u8, 214u8, 101u8, 245u8, 28u8, 141u8, 193u8]]; - let sib2 = [[167u8, 176u8, 170u8, 74u8, 66u8, 157u8, 36u8, 153u8], - [220u8, 192u8, 39u8, 69u8, 198u8, 24u8, 123u8, 147u8], - [63u8, 5u8, 74u8, 98u8, 77u8, 73u8, 181u8, 252u8], - [134u8, 86u8, 33u8, 32u8, 240u8, 13u8, 134u8, 153u8]]; - let proof = store(ListNode.Cons(store(sib0), store(ListNode.Cons(store(sib1), - store(ListNode.Cons(store(sib2), store(ListNode.Nil))))))); - let (root, capidx) = mmcs_root(rows, lhs, ibits, proof, 3); - assert_eq!(capidx, 0); - assert_eq!(assert_digest(load(root), 4722047561722553901, 2839201037098837684, - 4926058068911485563, 1219861215742277604), 1); - -- tamper: perturb m0's first opened value → root must change. - let bad0 = store(ListNode.Cons(u64_of(99u8), store(ListNode.Cons(u64_of(12u8), store(ListNode.Nil))))); - let bad_rows = store(ListNode.Cons(bad0, store(ListNode.Cons(row1, - store(ListNode.Cons(row2, store(ListNode.Nil))))))); - let cap = store(ListNode.Cons(store([[45u8, 230u8, 248u8, 40u8, 61u8, 21u8, 136u8, 65u8], - [180u8, 102u8, 50u8, 238u8, 76u8, 222u8, 102u8, 39u8], - [123u8, 114u8, 106u8, 220u8, 182u8, 223u8, 92u8, 68u8], - [228u8, 55u8, 152u8, 7u8, 80u8, 209u8, 237u8, 16u8]]), - store(ListNode.Nil))); - assert_eq!(mmcs_verify(cap, rows, lhs, ibits, proof, 3), 1); - assert_eq!(mmcs_verify(cap, bad_rows, lhs, ibits, proof, 3), 0); - 1 - } - - -- Differential test for the lane-granular leaf hasher: `b3_lanes` must - -- agree with byte-granular `blake3` over the lanes' LE bytes at every - -- structural boundary — empty input, partial block, exact block (8 lanes), - -- block + 1, exact chunk (128 lanes), chunk + 1, a 2-chunk input with - -- varied bytes, and a 4-chunk input (deeper layer fold). Lane bytes vary - -- with the index so lane- or word-order bugs change the digest. - fn lane_test_row(n: G) -> List‹U64› { - match n { - 0 => store(ListNode.Nil), - _ => - -- n mod 256, valid for n ≤ 511 (largest size used below is 500). - let lo = u8_from_field_unsafe(n - 256 * u32_less_than(255, n)); - store(ListNode.Cons([lo, 1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8], - lane_test_row(n - 1))), - } - } - fn lane_hash_check(n: G) -> G { - let row = lane_test_row(n); - digest_eq(b3_to_digest(b3_lanes(row)), - b3_to_digest(@blake3(b3_row_onto(row, store(ListNode.Nil))))) - } - pub fn lane_hash_test() -> G { - lane_hash_check(0) * lane_hash_check(1) * lane_hash_check(7) - * lane_hash_check(8) * lane_hash_check(9) * lane_hash_check(127) - * lane_hash_check(128) * lane_hash_check(129) * lane_hash_check(255) - * lane_hash_check(500) - } - - -- Differential test for the rows-walking leaf hasher: `b3_rows` over the - -- selected rows must agree with the concat + canon reference - -- (`mmcs_hash_row(canon_lanes(concat_at(...)))`) across shapes: all/none/ - -- some rows selected, an empty row mixed in, exact-block totals, and a - -- multi-chunk total (layer fold). Rows reuse `lane_test_row`'s varied - -- bytes. - fn rows_test_rows(spec: List‹G›) -> List‹List‹U64›› { - match load(spec) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(n, rest) => store(ListNode.Cons(lane_test_row(n), rows_test_rows(rest))), - } - } - fn rows_hash_check(spec: List‹G›, lhs: List‹G›, target: G) -> G { - let rows = rows_test_rows(spec); - digest_eq(b3_to_digest(b3_rows(select_rows(rows, lhs, target))), - mmcs_hash_row(canon_lanes(concat_at(rows, lhs, target)))) - } - fn g1(a: G) -> List‹G› { store(ListNode.Cons(a, store(ListNode.Nil))) } - fn g2(a: G, b: G) -> List‹G› { store(ListNode.Cons(a, g1(b))) } - fn g3(a: G, b: G, c: G) -> List‹G› { store(ListNode.Cons(a, g2(b, c))) } - pub fn rows_hash_test() -> G { - rows_hash_check(g3(3, 5, 2), g3(7, 7, 7), 7) - * rows_hash_check(g3(3, 5, 2), g3(7, 7, 7), 5) - * rows_hash_check(g3(3, 0, 5), g3(7, 7, 7), 7) - * rows_hash_check(g1(8), g1(4), 4) - * rows_hash_check(g2(130, 130), g2(9, 9), 9) - * rows_hash_check(g3(5, 9, 3), g3(2, 9, 2), 2) - } - - -- Differential test for the IO-slice hasher: `b3_io` over the bytes the - -- test writes to a channel arena must agree with byte-granular `blake3` - -- over the same bytes, at the same structural boundaries as the lane test - -- (empty, partial/exact/over block, partial/exact/over chunk, multi-chunk - -- with layer fold). Uses `io_write` to populate channel 9 (unused by any - -- production stream), with each length's bytes at a distinct offset. - fn io_test_fill(n: G, off: G, b: G) -> G { - match n { - 0 => off, - _ => - -- `b` cycles 255 → 0 → 255 → …, so any length gets varied, - -- always-in-range bytes. - io_write(9, [b]); - let z = eq_zero(b); - io_test_fill(n - 1, off + 1, ((b - 1) * (1 - z)) + (255 * z)), - } - } - fn io_test_bytes(n: G, off: G) -> ByteStream { - match n { - 0 => store(ListNode.Nil), - _ => - let [b] = io_read(9, off, 1); - store(ListNode.Cons(u8_from_field_unsafe(b), io_test_bytes(n - 1, off + 1))), - } - } - fn io_hash_check(n: G, off: G) -> (G, G) { - let stop = io_test_fill(n, off, 173); - let a = b3_io(9, off, n); - let b = @blake3(io_test_bytes(n, off)); - (digest_eq(b3_to_digest(a), b3_to_digest(b)), stop) - } - pub fn io_hash_test() -> G { - let (r0, o0) = io_hash_check(0, 0); - let (r1, o1) = io_hash_check(1, o0); - let (r2, o2) = io_hash_check(7, o1); - let (r3, o3) = io_hash_check(8, o2); - let (r4, o4) = io_hash_check(63, o3); - let (r5, o5) = io_hash_check(64, o4); - let (r6, o6) = io_hash_check(65, o5); - let (r7, o7) = io_hash_check(1023, o6); - let (r8, o8) = io_hash_check(1024, o7); - let (r9, o9) = io_hash_check(1025, o8); - let (r10, _o10) = io_hash_check(2500, o9); - r0 * r1 * r2 * r3 * r4 * r5 * r6 * r7 * r8 * r9 * r10 - } -⟧ - -/-- Generic verifier circuits plus their execution-only test entrypoints. -/ -def multiStarkTests : Except Aiur.Global Aiur.Source.Toplevel := do - let t ← verifierBase - let t ← t.merge entrypoints - t.merge tests - -end MultiStark - -end diff --git a/Tests/ProofHelpers.lean b/Tests/ProofHelpers.lean index 06df13d38..50b167125 100644 --- a/Tests/ProofHelpers.lean +++ b/Tests/ProofHelpers.lean @@ -18,11 +18,7 @@ def expectErr (descr : String) (e : Except ε α) : TestSeq := | .error _ => test descr true | .ok _ => test s!"{descr} — expected a rejection but it was accepted" false -/-- Inner-proof commitment/FRI parameters. A tractable subset of production -(`numQueries := 3`, standard PoW regime: commit 0 / query 20); the verifier -code itself is blowup/query-count agnostic, and `pcs_check_witness` is shared -by both PoW phases, so the query-phase grinding exercises the commit-phase -code path too. -/ +/-- Inner-proof commitment/FRI parameters. -/ def recCommitParams : Aiur.CommitmentParameters := { logBlowup := 2, capHeight := 0 } def innerFri : Aiur.FriParameters := @@ -33,6 +29,5 @@ def innerFri : Aiur.FriParameters := def u64le (n : Nat) : Array UInt8 := (Array.range 8).map (fun i => UInt8.ofNat ((n >>> (8 * i)) % 256)) - end Tests.ProofHelpers end diff --git a/crates/aiur/Cargo.toml b/crates/aiur/Cargo.toml index 4343adc1e..286476903 100644 --- a/crates/aiur/Cargo.toml +++ b/crates/aiur/Cargo.toml @@ -1,38 +1,50 @@ [package] name = "aiur" -version.workspace = true -edition.workspace = true -license.workspace = true +version = "0.1.0" +edition = "2024" +authors = ["Argument Engineering "] +license = "MIT OR Apache-2.0" +rust-version = "1.98" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -blake3 = { workspace = true } -bincode = { version = "2", features = ["serde"] } -hashbrown = { workspace = true } -indexmap = { workspace = true } -libc = { workspace = true } +record-pool = { workspace = true } +stark-key = { workspace = true, optional = true } +hashbrown = "0.17" multi-stark = { workspace = true } -num-bigint = { workspace = true } -rayon = { workspace = true } -rustc-hash = { workspace = true } -tracing = { workspace = true } -tracing-texray = { workspace = true, optional = true } - -[build-dependencies] -blake3 = { workspace = true } +rustc-hash = "2.1.2" +rayon = { version = "1", optional = true } +serde = { version = "1", features = ["derive"] } serde_json = { workspace = true } [dev-dependencies] -# Exercise the native MMCS at the same Plonky3 revision as multi-stark. -p3-blake3 = { git = "https://github.com/Plonky3/Plonky3", rev = "3152b14a89067c83775a8076cc262ffc48a1fd7c" } -p3-commit = { git = "https://github.com/Plonky3/Plonky3", rev = "3152b14a89067c83775a8076cc262ffc48a1fd7c" } -p3-symmetric = { git = "https://github.com/Plonky3/Plonky3", rev = "3152b14a89067c83775a8076cc262ffc48a1fd7c" } +blake3 = "1.8.7" + +[lib] +crate-type = ["rlib", "staticlib"] [features] -default = ["texray"] -parallel = ["multi-stark/parallel"] -cuda = ["multi-stark/cuda"] -cuda-trace-codegen = ["cuda"] -texray = ["dep:tracing-texray"] - -[lints] -workspace = true +default = [] +function-profile = [] +function-profile-ops = ["function-profile"] +trace-profile = ["stark"] +stark = ["dep:stark-key"] +parallel = ["stark", "multi-stark/parallel", "dep:rayon"] +cuda = ["stark", "multi-stark/cuda"] + +[[example]] +name = "prove" +required-features = ["stark"] + +[[example]] +name = "trie_bench" +required-features = ["stark"] + +[[example]] +name = "u32_check" +required-features = ["stark"] + +[[example]] +name = "library_check" +required-features = ["stark"] diff --git a/crates/aiur/build.rs b/crates/aiur/build.rs index abdf2fde0..4baf99c61 100644 --- a/crates/aiur/build.rs +++ b/crates/aiur/build.rs @@ -1,190 +1,129 @@ -//! 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. +//! CUDA build isolation. A no-op unless Cargo enables the `cuda` feature, so +//! CPU builds need neither nvcc nor CUDA headers. With it, compiles the GPU +//! stage-one population (`cuda/population.cu`) against multi-stark's shared +//! Goldilocks header, using multi-stark's stream and runtime conventions. use std::env; -use std::ffi::OsString; use std::path::PathBuf; use std::process::Command; -/// Toolchain metadata from multi-stark's CUDA build, so the trace writers -/// target the same compiler and GPUs as the backend they link against. -fn multi_stark_cuda(key: &str) -> OsString { - env::var_os(format!("DEP_MULTI_STARK_CUDA_{key}")) - .unwrap_or_else(|| panic!("multi-stark's CUDA build did not report {key}")) -} - fn main() { println!("cargo:rerun-if-changed=build.rs"); - println!("cargo:rerun-if-env-changed=NVCC_CCBIN"); - println!("cargo:rerun-if-env-changed=NVCC_PREPEND_FLAGS"); - println!("cargo:rerun-if-env-changed=NVCC_APPEND_FLAGS"); - + println!("cargo:rerun-if-changed=cuda/population.cu"); + 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" - ); - - // 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 nvcc = multi_stark_cuda("NVCC"); - let architectures: Vec = multi_stark_cuda("ARCHS") - .into_string() - .expect("CUDA architectures are ASCII") - .split(',') - .map(str::to_owned) - .collect(); + 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 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!( + let include = PathBuf::from( + env::var_os("DEP_MULTI_STARK_CUDA_INCLUDE") + .expect("multi-stark exports its CUDA field header directory"), + ); + println!( + "cargo:rerun-if-changed={}", + include.join("goldilocks.cuh").display() + ); + let object = out_dir.join("population.o"); + let library = out_dir.join("libaiur_population.a"); + let mut compile = Command::new(&nvcc); + compile.args([ + "--std=c++17", + "--cudart=static", + "--default-stream=per-thread", + "-O3", + "-lineinfo", + "--compiler-options=-fPIC", + ]); + for architecture in architectures(&nvcc) { + compile.arg(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); - } + compile + .arg("-I") + .arg(&include) + .args(["-c", "cuda/population.cu", "-o"]) + .arg(&object); + let status = compile.status().expect("failed to execute nvcc"); + assert!(status.success(), "nvcc failed for cuda/population.cu: {status}"); let _ = std::fs::remove_file(&library); let status = Command::new(&nvcc) .arg("--lib") .arg("-o") .arg(&library) - .args(&objects) + .arg(&object) .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=aiur_population"); + // As in multi-stark: bundle the CUDA runtime so staticlib consumers (Lean) + // resolve its registration symbols too. 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 env::split_paths(&multi_stark_cuda("LIB_DIRS")) { + for library in ["dl", "rt", "pthread", "stdc++"] { + println!("cargo:rustc-link-lib=dylib={library}"); + } + let root = PathBuf::from(&nvcc) + .parent() + .and_then(|bin| bin.parent()) + .map(PathBuf::from); + for directory in root.iter().flat_map(|root| { + [root.join("lib64"), root.join("targets/x86_64-linux/lib")] + }) { 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() +} + +/// `MULTI_STARK_CUDA_ARCHS` when set (multi-stark uses the same variable), +/// otherwise the visible GPUs' architectures, otherwise sm_80. +fn architectures(_nvcc: &std::ffi::OsStr) -> Vec { + let configured = env::var("MULTI_STARK_CUDA_ARCHS").ok().or_else(|| { + let output = Command::new("nvidia-smi") + .args(["--query-gpu=compute_cap", "--format=csv,noheader"]) + .output() + .ok()?; + let text = String::from_utf8(output.stdout).ok()?; + let mut found: Vec = text + .lines() + .map(|line| line.chars().filter(char::is_ascii_digit).collect()) + .filter(|arch: &String| !arch.is_empty()) + .collect(); + found.sort(); + found.dedup(); + (!found.is_empty()).then(|| found.join(",")) + }); + let architectures: Vec = configured + .unwrap_or_else(|| "80".into()) + .split(',') + .map(str::trim) + .filter(|a| !a.is_empty()) + .map(str::to_owned) + .collect(); + assert!( + architectures.iter().all(|a| a.chars().all(|c| c.is_ascii_digit())), + "invalid MULTI_STARK_CUDA_ARCHS" + ); + architectures +} diff --git a/crates/aiur/cuda/generated/blake3.cu b/crates/aiur/cuda/generated/blake3.cu deleted file mode 100644 index 939305af2..000000000 --- a/crates/aiur/cuda/generated/blake3.cu +++ /dev/null @@ -1,1649 +0,0 @@ -// 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 = goldilocks_mul(v_165, v_167); - row[layout.auxiliaries + 6] = v_168; - const uint64_t v_169 = 2ULL; - const uint64_t v_170 = goldilocks_sub(v_165, v_169); - const uint64_t v_171 = goldilocks_mul(v_168, 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_mul(v_199, v_200); - row[layout.auxiliaries + 29] = v_201; - const uint64_t v_202 = goldilocks_sub(v_199, v_169); - const uint64_t v_203 = goldilocks_mul(v_201, 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_mul(v_230, v_231); - row[layout.auxiliaries + 52] = v_232; - const uint64_t v_233 = goldilocks_sub(v_230, v_169); - const uint64_t v_234 = goldilocks_mul(v_232, 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_mul(v_261, v_262); - row[layout.auxiliaries + 75] = v_263; - const uint64_t v_264 = goldilocks_sub(v_261, v_169); - const uint64_t v_265 = goldilocks_mul(v_263, 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_mul(v_292, v_293); - row[layout.auxiliaries + 98] = v_294; - const uint64_t v_295 = goldilocks_sub(v_292, v_169); - const uint64_t v_296 = goldilocks_mul(v_294, 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_mul(v_323, v_324); - row[layout.auxiliaries + 121] = v_325; - const uint64_t v_326 = goldilocks_sub(v_323, v_169); - const uint64_t v_327 = goldilocks_mul(v_325, 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_mul(v_354, v_355); - row[layout.auxiliaries + 144] = v_356; - const uint64_t v_357 = goldilocks_sub(v_354, v_169); - const uint64_t v_358 = goldilocks_mul(v_356, 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_mul(v_385, v_386); - row[layout.auxiliaries + 167] = v_387; - const uint64_t v_388 = goldilocks_sub(v_385, v_169); - const uint64_t v_389 = goldilocks_mul(v_387, 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_mul(v_416, v_417); - row[layout.auxiliaries + 190] = v_418; - const uint64_t v_419 = goldilocks_sub(v_416, v_169); - const uint64_t v_420 = goldilocks_mul(v_418, 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_mul(v_447, v_448); - row[layout.auxiliaries + 213] = v_449; - const uint64_t v_450 = goldilocks_sub(v_447, v_169); - const uint64_t v_451 = goldilocks_mul(v_449, 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_mul(v_478, v_479); - row[layout.auxiliaries + 236] = v_480; - const uint64_t v_481 = goldilocks_sub(v_478, v_169); - const uint64_t v_482 = goldilocks_mul(v_480, 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_mul(v_509, v_510); - row[layout.auxiliaries + 259] = v_511; - const uint64_t v_512 = goldilocks_sub(v_509, v_169); - const uint64_t v_513 = goldilocks_mul(v_511, 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_mul(v_540, v_541); - row[layout.auxiliaries + 282] = v_542; - const uint64_t v_543 = goldilocks_sub(v_540, v_169); - const uint64_t v_544 = goldilocks_mul(v_542, 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_mul(v_571, v_572); - row[layout.auxiliaries + 305] = v_573; - const uint64_t v_574 = goldilocks_sub(v_571, v_169); - const uint64_t v_575 = goldilocks_mul(v_573, 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_mul(v_602, v_603); - row[layout.auxiliaries + 328] = v_604; - const uint64_t v_605 = goldilocks_sub(v_602, v_169); - const uint64_t v_606 = goldilocks_mul(v_604, 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_mul(v_633, v_634); - row[layout.auxiliaries + 351] = v_635; - const uint64_t v_636 = goldilocks_sub(v_633, v_169); - const uint64_t v_637 = goldilocks_mul(v_635, 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] = {58, 213, 204, 64, 57, 46, 134, 177, 30, 246, 254, 175, 75, 41, 50, 24, 114, 80, 186, 84, 61, 41, 13, 140, 14, 107, 159, 30, 218, 19, 75, 152}; - 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 deleted file mode 100644 index abead3b48..000000000 --- a/crates/aiur/cuda/generated/fixtures.cu +++ /dev/null @@ -1,3108 +0,0 @@ -// 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 = goldilocks_mul(v_165, v_167); - row[layout.auxiliaries + 6] = v_168; - const uint64_t v_169 = 2ULL; - const uint64_t v_170 = goldilocks_sub(v_165, v_169); - const uint64_t v_171 = goldilocks_mul(v_168, 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_mul(v_199, v_200); - row[layout.auxiliaries + 29] = v_201; - const uint64_t v_202 = goldilocks_sub(v_199, v_169); - const uint64_t v_203 = goldilocks_mul(v_201, 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_mul(v_230, v_231); - row[layout.auxiliaries + 52] = v_232; - const uint64_t v_233 = goldilocks_sub(v_230, v_169); - const uint64_t v_234 = goldilocks_mul(v_232, 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_mul(v_261, v_262); - row[layout.auxiliaries + 75] = v_263; - const uint64_t v_264 = goldilocks_sub(v_261, v_169); - const uint64_t v_265 = goldilocks_mul(v_263, 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_mul(v_292, v_293); - row[layout.auxiliaries + 98] = v_294; - const uint64_t v_295 = goldilocks_sub(v_292, v_169); - const uint64_t v_296 = goldilocks_mul(v_294, 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_mul(v_323, v_324); - row[layout.auxiliaries + 121] = v_325; - const uint64_t v_326 = goldilocks_sub(v_323, v_169); - const uint64_t v_327 = goldilocks_mul(v_325, 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_mul(v_354, v_355); - row[layout.auxiliaries + 144] = v_356; - const uint64_t v_357 = goldilocks_sub(v_354, v_169); - const uint64_t v_358 = goldilocks_mul(v_356, 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_mul(v_385, v_386); - row[layout.auxiliaries + 167] = v_387; - const uint64_t v_388 = goldilocks_sub(v_385, v_169); - const uint64_t v_389 = goldilocks_mul(v_387, 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_mul(v_416, v_417); - row[layout.auxiliaries + 190] = v_418; - const uint64_t v_419 = goldilocks_sub(v_416, v_169); - const uint64_t v_420 = goldilocks_mul(v_418, 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_mul(v_447, v_448); - row[layout.auxiliaries + 213] = v_449; - const uint64_t v_450 = goldilocks_sub(v_447, v_169); - const uint64_t v_451 = goldilocks_mul(v_449, 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_mul(v_478, v_479); - row[layout.auxiliaries + 236] = v_480; - const uint64_t v_481 = goldilocks_sub(v_478, v_169); - const uint64_t v_482 = goldilocks_mul(v_480, 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_mul(v_509, v_510); - row[layout.auxiliaries + 259] = v_511; - const uint64_t v_512 = goldilocks_sub(v_509, v_169); - const uint64_t v_513 = goldilocks_mul(v_511, 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_mul(v_540, v_541); - row[layout.auxiliaries + 282] = v_542; - const uint64_t v_543 = goldilocks_sub(v_540, v_169); - const uint64_t v_544 = goldilocks_mul(v_542, 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_mul(v_571, v_572); - row[layout.auxiliaries + 305] = v_573; - const uint64_t v_574 = goldilocks_sub(v_571, v_169); - const uint64_t v_575 = goldilocks_mul(v_573, 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_mul(v_602, v_603); - row[layout.auxiliaries + 328] = v_604; - const uint64_t v_605 = goldilocks_sub(v_602, v_169); - const uint64_t v_606 = goldilocks_mul(v_604, 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_mul(v_633, v_634); - row[layout.auxiliaries + 351] = v_635; - const uint64_t v_636 = goldilocks_sub(v_633, v_169); - const uint64_t v_637 = goldilocks_mul(v_635, 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_45 = 65536ULL; - const uint64_t v_46 = goldilocks_mul(v_16, v_37); - const uint64_t v_48 = goldilocks_mul(v_45, v_38); - 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_52, v_53); - const uint64_t v_55 = goldilocks_add(v_54, v_36); - const uint64_t v_56 = goldilocks_add(v_55, v_46); - const uint64_t v_57 = goldilocks_add(v_56, v_48); - const uint64_t v_58 = ((v_57 >> 0) & 255ULL); - const uint64_t v_59 = ((v_57 >> 8) & 255ULL); - const uint64_t v_60 = ((v_57 >> 16) & 255ULL); - const uint64_t v_61 = ((v_57 >> 24) & 255ULL); - const uint64_t v_62 = ((v_57 >> 32) & 255ULL); - const uint64_t v_63 = ((v_57 >> 40) & 255ULL); - const uint64_t v_64 = ((v_57 >> 48) & 255ULL); - const uint64_t v_65 = ((v_57 >> 56) & 255ULL); - row[layout.auxiliaries + 12] = v_58; - row[layout.auxiliaries + 13] = v_59; - row[layout.auxiliaries + 14] = v_60; - row[layout.auxiliaries + 15] = v_61; - row[layout.auxiliaries + 16] = v_62; - row[layout.auxiliaries + 17] = v_63; - row[layout.auxiliaries + 18] = v_64; - row[layout.auxiliaries + 19] = v_65; - const uint64_t v_68 = goldilocks_mul(v_16, v_61); - const uint64_t v_70 = goldilocks_mul(v_45, v_62); - const uint64_t v_74 = goldilocks_mul(v_18, v_28); - row[layout.auxiliaries + 20] = v_74; - const uint64_t v_75 = goldilocks_mul(v_22, v_24); - row[layout.auxiliaries + 21] = v_75; - const uint64_t v_76 = goldilocks_add(v_74, v_75); - const uint64_t v_77 = goldilocks_mul(v_26, v_20); - row[layout.auxiliaries + 22] = v_77; - const uint64_t v_78 = goldilocks_add(v_76, v_77); - const uint64_t v_79 = goldilocks_add(v_78, v_60); - const uint64_t v_80 = goldilocks_add(v_79, v_68); - const uint64_t v_81 = goldilocks_add(v_80, v_70); - const uint64_t v_82 = ((v_81 >> 0) & 255ULL); - const uint64_t v_83 = ((v_81 >> 8) & 255ULL); - const uint64_t v_84 = ((v_81 >> 16) & 255ULL); - const uint64_t v_85 = ((v_81 >> 24) & 255ULL); - const uint64_t v_86 = ((v_81 >> 32) & 255ULL); - const uint64_t v_87 = ((v_81 >> 40) & 255ULL); - const uint64_t v_88 = ((v_81 >> 48) & 255ULL); - const uint64_t v_89 = ((v_81 >> 56) & 255ULL); - row[layout.auxiliaries + 23] = v_82; - row[layout.auxiliaries + 24] = v_83; - row[layout.auxiliaries + 25] = v_84; - row[layout.auxiliaries + 26] = v_85; - row[layout.auxiliaries + 27] = v_86; - row[layout.auxiliaries + 28] = v_87; - row[layout.auxiliaries + 29] = v_88; - row[layout.auxiliaries + 30] = v_89; - const uint64_t v_92 = goldilocks_mul(v_16, v_85); - const uint64_t v_94 = goldilocks_mul(v_45, v_86); - const uint64_t v_98 = goldilocks_mul(v_18, v_32); - row[layout.auxiliaries + 31] = v_98; - const uint64_t v_99 = goldilocks_mul(v_22, v_28); - row[layout.auxiliaries + 32] = v_99; - const uint64_t v_100 = goldilocks_add(v_98, v_99); - const uint64_t v_101 = goldilocks_mul(v_26, v_24); - row[layout.auxiliaries + 33] = v_101; - const uint64_t v_102 = goldilocks_add(v_100, v_101); - const uint64_t v_103 = goldilocks_mul(v_30, v_20); - row[layout.auxiliaries + 34] = v_103; - const uint64_t v_104 = goldilocks_add(v_102, v_103); - const uint64_t v_105 = goldilocks_add(v_104, v_84); - const uint64_t v_106 = goldilocks_add(v_105, v_92); - const uint64_t v_107 = goldilocks_add(v_106, v_94); - const uint64_t v_108 = ((v_107 >> 0) & 255ULL); - const uint64_t v_109 = ((v_107 >> 8) & 255ULL); - const uint64_t v_110 = ((v_107 >> 16) & 255ULL); - const uint64_t v_111 = ((v_107 >> 24) & 255ULL); - const uint64_t v_112 = ((v_107 >> 32) & 255ULL); - const uint64_t v_113 = ((v_107 >> 40) & 255ULL); - const uint64_t v_114 = ((v_107 >> 48) & 255ULL); - const uint64_t v_115 = ((v_107 >> 56) & 255ULL); - row[layout.auxiliaries + 35] = v_108; - row[layout.auxiliaries + 36] = v_109; - row[layout.auxiliaries + 37] = v_110; - row[layout.auxiliaries + 38] = v_111; - row[layout.auxiliaries + 39] = v_112; - row[layout.auxiliaries + 40] = v_113; - row[layout.auxiliaries + 41] = v_114; - row[layout.auxiliaries + 42] = v_115; - const uint64_t v_118 = goldilocks_mul(v_16, v_111); - const uint64_t v_120 = goldilocks_mul(v_45, v_112); - const uint64_t v_124 = goldilocks_mul(v_22, v_32); - row[layout.auxiliaries + 43] = v_124; - const uint64_t v_125 = goldilocks_mul(v_26, v_28); - row[layout.auxiliaries + 44] = v_125; - const uint64_t v_126 = goldilocks_add(v_124, v_125); - const uint64_t v_127 = goldilocks_mul(v_30, v_24); - row[layout.auxiliaries + 45] = v_127; - const uint64_t v_128 = goldilocks_add(v_126, v_127); - const uint64_t v_129 = goldilocks_add(v_128, v_110); - const uint64_t v_130 = goldilocks_add(v_129, v_118); - const uint64_t v_131 = goldilocks_add(v_130, v_120); - const uint64_t v_132 = ((v_131 >> 0) & 255ULL); - const uint64_t v_133 = ((v_131 >> 8) & 255ULL); - const uint64_t v_134 = ((v_131 >> 16) & 255ULL); - const uint64_t v_135 = ((v_131 >> 24) & 255ULL); - const uint64_t v_136 = ((v_131 >> 32) & 255ULL); - const uint64_t v_137 = ((v_131 >> 40) & 255ULL); - const uint64_t v_138 = ((v_131 >> 48) & 255ULL); - const uint64_t v_139 = ((v_131 >> 56) & 255ULL); - row[layout.auxiliaries + 46] = v_132; - row[layout.auxiliaries + 47] = v_133; - row[layout.auxiliaries + 48] = v_134; - row[layout.auxiliaries + 49] = v_135; - row[layout.auxiliaries + 50] = v_136; - row[layout.auxiliaries + 51] = v_137; - row[layout.auxiliaries + 52] = v_138; - row[layout.auxiliaries + 53] = v_139; - const uint64_t v_142 = goldilocks_mul(v_16, v_135); - const uint64_t v_144 = goldilocks_mul(v_45, v_136); - const uint64_t v_148 = goldilocks_mul(v_26, v_32); - row[layout.auxiliaries + 54] = v_148; - const uint64_t v_149 = goldilocks_mul(v_30, v_28); - row[layout.auxiliaries + 55] = v_149; - const uint64_t v_150 = goldilocks_add(v_148, v_149); - const uint64_t v_151 = goldilocks_add(v_150, v_134); - const uint64_t v_152 = goldilocks_add(v_151, v_142); - const uint64_t v_153 = goldilocks_add(v_152, v_144); - const uint64_t v_154 = ((v_153 >> 0) & 255ULL); - const uint64_t v_155 = ((v_153 >> 8) & 255ULL); - const uint64_t v_156 = ((v_153 >> 16) & 255ULL); - const uint64_t v_157 = ((v_153 >> 24) & 255ULL); - const uint64_t v_158 = ((v_153 >> 32) & 255ULL); - const uint64_t v_159 = ((v_153 >> 40) & 255ULL); - const uint64_t v_160 = ((v_153 >> 48) & 255ULL); - const uint64_t v_161 = ((v_153 >> 56) & 255ULL); - row[layout.auxiliaries + 56] = v_154; - row[layout.auxiliaries + 57] = v_155; - row[layout.auxiliaries + 58] = v_156; - row[layout.auxiliaries + 59] = v_157; - row[layout.auxiliaries + 60] = v_158; - row[layout.auxiliaries + 61] = v_159; - row[layout.auxiliaries + 62] = v_160; - row[layout.auxiliaries + 63] = v_161; - const uint64_t v_164 = goldilocks_mul(v_16, v_157); - const uint64_t v_166 = goldilocks_mul(v_45, v_158); - const uint64_t v_170 = goldilocks_mul(v_30, v_32); - row[layout.auxiliaries + 64] = v_170; - const uint64_t v_171 = goldilocks_add(v_170, v_156); - const uint64_t v_172 = goldilocks_add(v_171, v_164); - const uint64_t v_173 = goldilocks_add(v_172, v_166); - const uint64_t v_174 = ((v_173 >> 0) & 255ULL); - const uint64_t v_175 = ((v_173 >> 8) & 255ULL); - const uint64_t v_176 = ((v_173 >> 16) & 255ULL); - const uint64_t v_177 = ((v_173 >> 24) & 255ULL); - const uint64_t v_178 = ((v_173 >> 32) & 255ULL); - const uint64_t v_179 = ((v_173 >> 40) & 255ULL); - const uint64_t v_180 = ((v_173 >> 48) & 255ULL); - const uint64_t v_181 = ((v_173 >> 56) & 255ULL); - row[layout.auxiliaries + 65] = v_174; - row[layout.auxiliaries + 66] = v_175; - row[layout.auxiliaries + 67] = v_176; - row[layout.auxiliaries + 68] = v_177; - row[layout.auxiliaries + 69] = v_178; - row[layout.auxiliaries + 70] = v_179; - row[layout.auxiliaries + 71] = v_180; - row[layout.auxiliaries + 72] = v_181; - 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] = {205, 89, 45, 81, 115, 192, 43, 229, 178, 117, 203, 87, 188, 146, 231, 25, 106, 211, 41, 51, 208, 189, 121, 121, 56, 36, 50, 146, 157, 240, 103, 180}; - 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 deleted file mode 100644 index 8ae8a5ac8..000000000 --- a/crates/aiur/cuda/generated/production/ix_aggr.cu +++ /dev/null @@ -1,3025 +0,0 @@ -// 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_89_0[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -template struct Seed_ix_aggr_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_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_89(Seed_ix_aggr_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); - 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_89_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 = goldilocks_mul(v_165, v_167); - row[layout.auxiliaries + 6] = v_168; - const uint64_t v_169 = 2ULL; - const uint64_t v_170 = goldilocks_sub(v_165, v_169); - const uint64_t v_171 = goldilocks_mul(v_168, 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_mul(v_199, v_200); - row[layout.auxiliaries + 29] = v_201; - const uint64_t v_202 = goldilocks_sub(v_199, v_169); - const uint64_t v_203 = goldilocks_mul(v_201, 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_mul(v_230, v_231); - row[layout.auxiliaries + 52] = v_232; - const uint64_t v_233 = goldilocks_sub(v_230, v_169); - const uint64_t v_234 = goldilocks_mul(v_232, 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_mul(v_261, v_262); - row[layout.auxiliaries + 75] = v_263; - const uint64_t v_264 = goldilocks_sub(v_261, v_169); - const uint64_t v_265 = goldilocks_mul(v_263, 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_mul(v_292, v_293); - row[layout.auxiliaries + 98] = v_294; - const uint64_t v_295 = goldilocks_sub(v_292, v_169); - const uint64_t v_296 = goldilocks_mul(v_294, 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_mul(v_323, v_324); - row[layout.auxiliaries + 121] = v_325; - const uint64_t v_326 = goldilocks_sub(v_323, v_169); - const uint64_t v_327 = goldilocks_mul(v_325, 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_mul(v_354, v_355); - row[layout.auxiliaries + 144] = v_356; - const uint64_t v_357 = goldilocks_sub(v_354, v_169); - const uint64_t v_358 = goldilocks_mul(v_356, 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_mul(v_385, v_386); - row[layout.auxiliaries + 167] = v_387; - const uint64_t v_388 = goldilocks_sub(v_385, v_169); - const uint64_t v_389 = goldilocks_mul(v_387, 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_mul(v_416, v_417); - row[layout.auxiliaries + 190] = v_418; - const uint64_t v_419 = goldilocks_sub(v_416, v_169); - const uint64_t v_420 = goldilocks_mul(v_418, 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_mul(v_447, v_448); - row[layout.auxiliaries + 213] = v_449; - const uint64_t v_450 = goldilocks_sub(v_447, v_169); - const uint64_t v_451 = goldilocks_mul(v_449, 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_mul(v_478, v_479); - row[layout.auxiliaries + 236] = v_480; - const uint64_t v_481 = goldilocks_sub(v_478, v_169); - const uint64_t v_482 = goldilocks_mul(v_480, 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_mul(v_509, v_510); - row[layout.auxiliaries + 259] = v_511; - const uint64_t v_512 = goldilocks_sub(v_509, v_169); - const uint64_t v_513 = goldilocks_mul(v_511, 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_mul(v_540, v_541); - row[layout.auxiliaries + 282] = v_542; - const uint64_t v_543 = goldilocks_sub(v_540, v_169); - const uint64_t v_544 = goldilocks_mul(v_542, 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_mul(v_571, v_572); - row[layout.auxiliaries + 305] = v_573; - const uint64_t v_574 = goldilocks_sub(v_571, v_169); - const uint64_t v_575 = goldilocks_mul(v_573, 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_mul(v_602, v_603); - row[layout.auxiliaries + 328] = v_604; - const uint64_t v_605 = goldilocks_sub(v_602, v_169); - const uint64_t v_606 = goldilocks_mul(v_604, 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_mul(v_633, v_634); - row[layout.auxiliaries + 351] = v_635; - const uint64_t v_636 = goldilocks_sub(v_633, v_169); - const uint64_t v_637 = goldilocks_mul(v_635, 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_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 ? 176 : 1296; - const Seed_ix_aggr_89 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ix_aggr_89(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ix_aggr_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_ix_aggr_89<<>>(seeds, real, rows, layout, output, error); - else kernel_ix_aggr_89<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ix_aggr_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 < 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_89); -} - -__device__ __constant__ uint64_t inverse_120_0[] = {0ULL}; -__device__ __constant__ uint64_t inverse_120_1[] = {0ULL}; -__device__ __constant__ uint64_t inverse_120_2[] = {0ULL}; -__device__ __constant__ uint64_t inverse_120_3[] = {0ULL}; -__device__ __constant__ uint64_t inverse_120_4[] = {0ULL}; -__device__ __constant__ uint64_t inverse_120_5[] = {0ULL}; -__device__ __constant__ uint64_t inverse_120_6[] = {0ULL}; -__device__ __constant__ uint64_t inverse_120_7[] = {0ULL}; -__device__ __constant__ uint64_t inverse_120_8[] = {0ULL}; -__device__ __constant__ uint64_t inverse_120_10[] = {18446744069414584320ULL, 0ULL}; -__device__ __constant__ uint64_t inverse_120_11[] = {18446744069414584320ULL, 0ULL}; -__device__ __constant__ uint64_t inverse_120_12[] = {18446744069414584320ULL, 0ULL}; -__device__ __constant__ uint64_t inverse_120_13[] = {18446744069414584320ULL, 0ULL}; -template struct Seed_ix_aggr_120 { - 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_120(Seed_ix_aggr_120 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_120_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_120_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_120_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_120_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_120_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_120_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_120_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_120_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_120_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_120_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_120_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_223 = goldilocks_mul(v_217, v_220); - row[layout.auxiliaries + 109] = v_223; - 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_120_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_120_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_120(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_120 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ix_aggr_120(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ix_aggr_120(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_120<<>>(seeds, real, rows, layout, output, error); - else kernel_ix_aggr_120<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ix_aggr_120(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_120); -} - -template struct Seed_ix_aggr_223 { - 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_223(Seed_ix_aggr_223 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_223(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_223 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ix_aggr_223(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ix_aggr_223(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_223<<>>(seeds, real, rows, layout, output, error); - else kernel_ix_aggr_223<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ix_aggr_223(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_223); -} - -template struct Seed_ix_aggr_233 { - 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_233(Seed_ix_aggr_233 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_233(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_233 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ix_aggr_233(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ix_aggr_233(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_233<<>>(seeds, real, rows, layout, output, error); - else kernel_ix_aggr_233<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ix_aggr_233(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_233); -} - -__device__ __constant__ uint64_t inverse_261_0[] = {0ULL, 1ULL}; -__device__ __constant__ uint64_t inverse_261_1[] = {18446744069414584320ULL, 0ULL}; -template struct Seed_ix_aggr_261 { - 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 + 44); - case 5: return load_u32(data + 20); - case 6: return load_u32(data + 24); - case 7: return load_u8(data + 45); - case 8: return load_u32(data + 28); - case 9: return load_u32(data + 32); - case 10: return load_u8(data + 46); - case 11: return load_u32(data + 36); - case 12: return load_u32(data + 40); - case 13: return load_u8(data + 47); - case 14: return load_u8(data + 48); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ix_aggr_261(Seed_ix_aggr_261 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; - const uint64_t v_6 = seed.word(7); - const uint64_t v_7 = seed.word(8); - const uint64_t v_8 = seed.word(9); - row[layout.auxiliaries + 4] = v_6; - row[layout.auxiliaries + 5] = v_7; - row[layout.auxiliaries + 6] = v_8; - switch (v_3) { - case 1ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - case 0ULL: { - switch (v_6) { - case 1ULL: { - row[layout.selectors + 1] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_9 = seed.word(10); - const uint64_t v_10 = seed.word(11); - const uint64_t v_11 = seed.word(12); - row[layout.auxiliaries + 7] = v_9; - row[layout.auxiliaries + 8] = v_10; - row[layout.auxiliaries + 9] = v_11; - switch (v_9) { - case 0ULL: { - const uint64_t v_12 = seed.word(13); - row[layout.auxiliaries + 10] = v_12; - switch (v_12) { - case 0ULL: { - const uint64_t v_13 = seed.word(14); - row[layout.auxiliaries + 11] = v_13; - row[layout.selectors + 2] = 1; - return 0; - } - case 1ULL: { - row[layout.selectors + 3] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 11] = (v_12 <= 1ULL ? inverse_261_0[v_12] : inverse(goldilocks_sub(v_12, 0ULL))); - row[layout.auxiliaries + 12] = (v_12 <= 1ULL ? inverse_261_1[v_12] : inverse(goldilocks_sub(v_12, 1ULL))); - const uint64_t v_17 = seed.word(14); - row[layout.auxiliaries + 13] = v_17; - row[layout.selectors + 4] = 1; - return 0; - } - } - } - default: { - return 2; - } - } - } - default: { - return 2; - } - } - } - default: { - return 2; - } - } -} -template __global__ void kernel_ix_aggr_261(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 : 120; - const Seed_ix_aggr_261 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ix_aggr_261(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ix_aggr_261(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_261<<>>(seeds, real, rows, layout, output, error); - else kernel_ix_aggr_261<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ix_aggr_261(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 < 14) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 56 : encoding == 0 ? 120 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ix_aggr_261); -} - -__device__ __constant__ uint64_t inverse_262_0[] = {0ULL, 1ULL}; -__device__ __constant__ uint64_t inverse_262_1[] = {18446744069414584320ULL, 0ULL}; -template struct Seed_ix_aggr_262 { - 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); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ix_aggr_262(Seed_ix_aggr_262 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; - 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; - switch (v_2) { - case 1ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - case 0ULL: { - switch (v_5) { - case 1ULL: { - row[layout.selectors + 1] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_8 = seed.word(9); - row[layout.auxiliaries + 7] = v_8; - switch (v_8) { - case 0ULL: { - row[layout.selectors + 2] = 1; - return 0; - } - case 1ULL: { - row[layout.selectors + 3] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 8] = (v_8 <= 1ULL ? inverse_262_0[v_8] : inverse(goldilocks_sub(v_8, 0ULL))); - row[layout.auxiliaries + 9] = (v_8 <= 1ULL ? inverse_262_1[v_8] : inverse(goldilocks_sub(v_8, 1ULL))); - row[layout.selectors + 4] = 1; - return 0; - } - } - } - default: { - return 2; - } - } - } - default: { - return 2; - } - } -} -template __global__ void kernel_ix_aggr_262(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_ix_aggr_262 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ix_aggr_262(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ix_aggr_262(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_262<<>>(seeds, real, rows, layout, output, error); - else kernel_ix_aggr_262<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ix_aggr_262(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 < 5 || width < auxiliaries || width - auxiliaries < 10) 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_ix_aggr_262); -} - -extern "C" const uint8_t* aiur_trace_ix_aggr_contract() { - static const uint8_t hash[32] = {16, 192, 139, 155, 202, 145, 36, 243, 93, 246, 216, 189, 250, 221, 54, 36, 149, 240, 11, 40, 210, 134, 183, 238, 67, 74, 234, 134, 107, 96, 246, 23}; - return hash; -} -extern "C" const uint8_t* aiur_trace_ix_aggr_schema() { - static const uint8_t hash[32] = {171, 117, 94, 141, 24, 100, 81, 45, 119, 242, 237, 174, 47, 213, 20, 154, 88, 248, 88, 222, 223, 0, 127, 104, 180, 202, 215, 87, 114, 235, 156, 106}; - return hash; -} -} diff --git a/crates/aiur/cuda/generated/production/ixvm.cu b/crates/aiur/cuda/generated/production/ixvm.cu deleted file mode 100644 index ce5acc45c..000000000 --- a/crates/aiur/cuda/generated/production/ixvm.cu +++ /dev/null @@ -1,19970 +0,0 @@ -// 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; - -__device__ __constant__ uint64_t inverse_24_0[] = {18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_24 { - 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 + 280); - case 2: return load_u8(data + 296); - case 3: return load_u8(data + 297); - case 4: return load_u8(data + 298); - case 5: return load_u8(data + 299); - case 6: return load_u8(data + 300); - case 7: return load_u8(data + 301); - case 8: return load_u8(data + 302); - case 9: return load_u8(data + 303); - case 10: return load_u8(data + 304); - case 11: return load_u8(data + 305); - case 12: return load_u8(data + 306); - case 13: return load_u8(data + 307); - case 14: return load_u8(data + 308); - case 15: return load_u8(data + 309); - case 16: return load_u8(data + 310); - case 17: return load_u8(data + 311); - case 18: return load_u8(data + 312); - case 19: return load_u8(data + 313); - case 20: return load_u8(data + 314); - case 21: return load_u8(data + 315); - case 22: return load_u8(data + 316); - case 23: return load_u8(data + 317); - case 24: return load_u8(data + 318); - case 25: return load_u8(data + 319); - case 26: return load_u8(data + 320); - case 27: return load_u8(data + 321); - case 28: return load_u8(data + 322); - case 29: return load_u8(data + 323); - case 30: return load_u8(data + 324); - case 31: return load_u8(data + 325); - case 32: return load_u8(data + 326); - case 33: return load_u8(data + 327); - case 34: return load_u64(data + 8); - case 35: return load_u8(data + 328); - case 36: return load_u32(data + 284); - case 37: return load_u8(data + 329); - case 38: return load_u8(data + 330); - case 39: return load_u8(data + 331); - case 40: return load_u8(data + 332); - case 41: return load_u8(data + 333); - case 42: return load_u8(data + 334); - case 43: return load_u8(data + 335); - case 44: return load_u8(data + 336); - case 45: return load_u8(data + 337); - case 46: return load_u8(data + 338); - case 47: return load_u8(data + 339); - case 48: return load_u8(data + 340); - case 49: return load_u8(data + 341); - case 50: return load_u8(data + 342); - case 51: return load_u8(data + 343); - case 52: return load_u8(data + 344); - case 53: return load_u8(data + 345); - case 54: return load_u8(data + 346); - case 55: return load_u8(data + 347); - case 56: return load_u8(data + 348); - case 57: return load_u8(data + 349); - case 58: return load_u8(data + 350); - case 59: return load_u8(data + 351); - case 60: return load_u8(data + 352); - case 61: return load_u8(data + 353); - case 62: return load_u8(data + 354); - case 63: return load_u8(data + 355); - case 64: return load_u8(data + 356); - case 65: return load_u8(data + 357); - case 66: return load_u8(data + 358); - case 67: return load_u8(data + 359); - case 68: return load_u8(data + 360); - case 69: return load_u8(data + 361); - case 70: return load_u8(data + 362); - case 71: return load_u8(data + 363); - case 72: return load_u8(data + 364); - case 73: return load_u8(data + 365); - case 74: return load_u8(data + 366); - case 75: return load_u8(data + 367); - case 76: return load_u8(data + 368); - case 77: return load_u8(data + 369); - case 78: return load_u8(data + 370); - case 79: return load_u8(data + 371); - case 80: return load_u8(data + 372); - case 81: return load_u8(data + 373); - case 82: return load_u8(data + 374); - case 83: return load_u8(data + 375); - case 84: return load_u8(data + 376); - case 85: return load_u8(data + 377); - case 86: return load_u8(data + 378); - case 87: return load_u8(data + 379); - case 88: return load_u8(data + 380); - case 89: return load_u8(data + 381); - case 90: return load_u8(data + 382); - case 91: return load_u8(data + 383); - case 92: return load_u8(data + 384); - case 93: return load_u8(data + 385); - case 94: return load_u8(data + 386); - case 95: return load_u8(data + 387); - case 96: return load_u8(data + 388); - case 97: return load_u8(data + 389); - case 98: return load_u8(data + 390); - case 99: return load_u8(data + 391); - case 100: return load_u8(data + 392); - case 101: return load_u8(data + 393); - case 102: return load_u32(data + 288); - case 103: return load_u8(data + 394); - case 104: return load_u64(data + 16); - case 105: return load_u64(data + 24); - case 106: return load_u64(data + 32); - case 107: return load_u64(data + 40); - case 108: return load_u64(data + 48); - case 109: return load_u64(data + 56); - case 110: return load_u64(data + 64); - case 111: return load_u64(data + 72); - case 112: return load_u64(data + 80); - case 113: return load_u64(data + 88); - case 114: return load_u64(data + 96); - case 115: return load_u64(data + 104); - case 116: return load_u64(data + 112); - case 117: return load_u64(data + 120); - case 118: return load_u64(data + 128); - case 119: return load_u64(data + 136); - case 120: return load_u64(data + 144); - case 121: return load_u64(data + 152); - case 122: return load_u64(data + 160); - case 123: return load_u64(data + 168); - case 124: return load_u64(data + 176); - case 125: return load_u64(data + 184); - case 126: return load_u64(data + 192); - case 127: return load_u64(data + 200); - case 128: return load_u64(data + 208); - case 129: return load_u64(data + 216); - case 130: return load_u64(data + 224); - case 131: return load_u64(data + 232); - case 132: return load_u64(data + 240); - case 133: return load_u64(data + 248); - case 134: return load_u64(data + 256); - case 135: return load_u64(data + 264); - case 136: return load_u64(data + 272); - case 137: return load_u8(data + 395); - case 138: return load_u8(data + 396); - case 139: return load_u8(data + 397); - case 140: return load_u8(data + 398); - case 141: return load_u8(data + 399); - case 142: return load_u8(data + 400); - case 143: return load_u8(data + 401); - case 144: return load_u8(data + 402); - case 145: return load_u8(data + 403); - case 146: return load_u8(data + 404); - case 147: return load_u8(data + 405); - case 148: return load_u8(data + 406); - case 149: return load_u8(data + 407); - case 150: return load_u8(data + 408); - case 151: return load_u8(data + 409); - case 152: return load_u8(data + 410); - case 153: return load_u8(data + 411); - case 154: return load_u8(data + 412); - case 155: return load_u8(data + 413); - case 156: return load_u8(data + 414); - case 157: return load_u8(data + 415); - case 158: return load_u8(data + 416); - case 159: return load_u8(data + 417); - case 160: return load_u8(data + 418); - case 161: return load_u8(data + 419); - case 162: return load_u8(data + 420); - case 163: return load_u8(data + 421); - case 164: return load_u8(data + 422); - case 165: return load_u8(data + 423); - case 166: return load_u8(data + 424); - case 167: return load_u8(data + 425); - case 168: return load_u8(data + 426); - case 169: return load_u32(data + 292); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_24(Seed_ixvm_24 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); - 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); - const uint64_t v_57 = seed.word(58); - const uint64_t v_58 = seed.word(59); - const uint64_t v_59 = seed.word(60); - const uint64_t v_60 = seed.word(61); - const uint64_t v_61 = seed.word(62); - const uint64_t v_62 = seed.word(63); - const uint64_t v_63 = seed.word(64); - const uint64_t v_64 = seed.word(65); - const uint64_t v_65 = seed.word(66); - const uint64_t v_66 = seed.word(67); - const uint64_t v_67 = seed.word(68); - row[layout.auxiliaries + 1] = v_34; - row[layout.auxiliaries + 2] = v_35; - row[layout.auxiliaries + 3] = v_36; - row[layout.auxiliaries + 4] = v_37; - row[layout.auxiliaries + 5] = v_38; - row[layout.auxiliaries + 6] = v_39; - row[layout.auxiliaries + 7] = v_40; - row[layout.auxiliaries + 8] = v_41; - row[layout.auxiliaries + 9] = v_42; - row[layout.auxiliaries + 10] = v_43; - 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; - row[layout.auxiliaries + 20] = v_53; - row[layout.auxiliaries + 21] = v_54; - row[layout.auxiliaries + 22] = v_55; - row[layout.auxiliaries + 23] = v_56; - row[layout.auxiliaries + 24] = v_57; - row[layout.auxiliaries + 25] = v_58; - row[layout.auxiliaries + 26] = v_59; - row[layout.auxiliaries + 27] = v_60; - row[layout.auxiliaries + 28] = v_61; - row[layout.auxiliaries + 29] = v_62; - row[layout.auxiliaries + 30] = v_63; - row[layout.auxiliaries + 31] = v_64; - row[layout.auxiliaries + 32] = v_65; - row[layout.auxiliaries + 33] = v_66; - row[layout.auxiliaries + 34] = v_67; - switch (v_34) { - case 1ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_70 = seed.word(69); - const uint64_t v_71 = seed.word(70); - const uint64_t v_72 = seed.word(71); - const uint64_t v_73 = seed.word(72); - const uint64_t v_74 = seed.word(73); - const uint64_t v_75 = seed.word(74); - const uint64_t v_76 = seed.word(75); - const uint64_t v_77 = seed.word(76); - const uint64_t v_78 = seed.word(77); - const uint64_t v_79 = seed.word(78); - const uint64_t v_80 = seed.word(79); - const uint64_t v_81 = seed.word(80); - const uint64_t v_82 = seed.word(81); - const uint64_t v_83 = seed.word(82); - const uint64_t v_84 = seed.word(83); - const uint64_t v_85 = seed.word(84); - const uint64_t v_86 = seed.word(85); - const uint64_t v_87 = seed.word(86); - const uint64_t v_88 = seed.word(87); - const uint64_t v_89 = seed.word(88); - const uint64_t v_90 = seed.word(89); - const uint64_t v_91 = seed.word(90); - const uint64_t v_92 = seed.word(91); - const uint64_t v_93 = seed.word(92); - const uint64_t v_94 = seed.word(93); - const uint64_t v_95 = seed.word(94); - const uint64_t v_96 = seed.word(95); - const uint64_t v_97 = seed.word(96); - const uint64_t v_98 = seed.word(97); - const uint64_t v_99 = seed.word(98); - const uint64_t v_100 = seed.word(99); - const uint64_t v_101 = seed.word(100); - const uint64_t v_102 = seed.word(101); - const uint64_t v_103 = seed.word(102); - row[layout.auxiliaries + 35] = v_70; - row[layout.auxiliaries + 36] = v_71; - row[layout.auxiliaries + 37] = v_72; - row[layout.auxiliaries + 38] = v_73; - row[layout.auxiliaries + 39] = v_74; - row[layout.auxiliaries + 40] = v_75; - row[layout.auxiliaries + 41] = v_76; - row[layout.auxiliaries + 42] = v_77; - row[layout.auxiliaries + 43] = v_78; - row[layout.auxiliaries + 44] = v_79; - row[layout.auxiliaries + 45] = v_80; - row[layout.auxiliaries + 46] = v_81; - row[layout.auxiliaries + 47] = v_82; - row[layout.auxiliaries + 48] = v_83; - row[layout.auxiliaries + 49] = v_84; - row[layout.auxiliaries + 50] = v_85; - row[layout.auxiliaries + 51] = v_86; - row[layout.auxiliaries + 52] = v_87; - row[layout.auxiliaries + 53] = v_88; - row[layout.auxiliaries + 54] = v_89; - row[layout.auxiliaries + 55] = v_90; - row[layout.auxiliaries + 56] = v_91; - row[layout.auxiliaries + 57] = v_92; - row[layout.auxiliaries + 58] = v_93; - row[layout.auxiliaries + 59] = v_94; - row[layout.auxiliaries + 60] = v_95; - row[layout.auxiliaries + 61] = v_96; - row[layout.auxiliaries + 62] = v_97; - row[layout.auxiliaries + 63] = v_98; - row[layout.auxiliaries + 64] = v_99; - row[layout.auxiliaries + 65] = v_100; - row[layout.auxiliaries + 66] = v_101; - row[layout.auxiliaries + 67] = v_102; - row[layout.auxiliaries + 68] = v_103; - switch (v_70) { - case 0ULL: { - row[layout.selectors + 1] = 1; - return 0; - } - case 1ULL: { - const uint64_t v_138 = seed.word(103); - const uint64_t v_139 = seed.word(104); - const uint64_t v_140 = seed.word(105); - const uint64_t v_141 = seed.word(106); - const uint64_t v_142 = seed.word(107); - const uint64_t v_143 = seed.word(108); - const uint64_t v_144 = seed.word(109); - const uint64_t v_145 = seed.word(110); - const uint64_t v_146 = seed.word(111); - const uint64_t v_147 = seed.word(112); - const uint64_t v_148 = seed.word(113); - const uint64_t v_149 = seed.word(114); - const uint64_t v_150 = seed.word(115); - const uint64_t v_151 = seed.word(116); - const uint64_t v_152 = seed.word(117); - const uint64_t v_153 = seed.word(118); - const uint64_t v_154 = seed.word(119); - const uint64_t v_155 = seed.word(120); - const uint64_t v_156 = seed.word(121); - const uint64_t v_157 = seed.word(122); - const uint64_t v_158 = seed.word(123); - const uint64_t v_159 = seed.word(124); - const uint64_t v_160 = seed.word(125); - const uint64_t v_161 = seed.word(126); - const uint64_t v_162 = seed.word(127); - const uint64_t v_163 = seed.word(128); - const uint64_t v_164 = seed.word(129); - const uint64_t v_165 = seed.word(130); - const uint64_t v_166 = seed.word(131); - const uint64_t v_167 = seed.word(132); - const uint64_t v_168 = seed.word(133); - const uint64_t v_169 = seed.word(134); - const uint64_t v_170 = seed.word(135); - const uint64_t v_171 = seed.word(136); - row[layout.auxiliaries + 69] = v_138; - row[layout.auxiliaries + 70] = v_139; - row[layout.auxiliaries + 71] = v_140; - row[layout.auxiliaries + 72] = v_141; - row[layout.auxiliaries + 73] = v_142; - row[layout.auxiliaries + 74] = v_143; - row[layout.auxiliaries + 75] = v_144; - row[layout.auxiliaries + 76] = v_145; - row[layout.auxiliaries + 77] = v_146; - row[layout.auxiliaries + 78] = v_147; - row[layout.auxiliaries + 79] = v_148; - row[layout.auxiliaries + 80] = v_149; - row[layout.auxiliaries + 81] = v_150; - row[layout.auxiliaries + 82] = v_151; - row[layout.auxiliaries + 83] = v_152; - row[layout.auxiliaries + 84] = v_153; - row[layout.auxiliaries + 85] = v_154; - row[layout.auxiliaries + 86] = v_155; - row[layout.auxiliaries + 87] = v_156; - row[layout.auxiliaries + 88] = v_157; - row[layout.auxiliaries + 89] = v_158; - row[layout.auxiliaries + 90] = v_159; - row[layout.auxiliaries + 91] = v_160; - row[layout.auxiliaries + 92] = v_161; - row[layout.auxiliaries + 93] = v_162; - row[layout.auxiliaries + 94] = v_163; - row[layout.auxiliaries + 95] = v_164; - row[layout.auxiliaries + 96] = v_165; - row[layout.auxiliaries + 97] = v_166; - row[layout.auxiliaries + 98] = v_167; - row[layout.auxiliaries + 99] = v_168; - row[layout.auxiliaries + 100] = v_169; - row[layout.auxiliaries + 101] = v_170; - row[layout.auxiliaries + 102] = v_171; - switch (v_138) { - case 1ULL: { - const uint64_t v_191 = seed.word(137); - const uint64_t v_192 = seed.word(138); - const uint64_t v_193 = seed.word(139); - const uint64_t v_194 = seed.word(140); - const uint64_t v_195 = seed.word(141); - const uint64_t v_196 = seed.word(142); - const uint64_t v_197 = seed.word(143); - const uint64_t v_198 = seed.word(144); - const uint64_t v_199 = seed.word(145); - const uint64_t v_200 = seed.word(146); - const uint64_t v_201 = seed.word(147); - const uint64_t v_202 = seed.word(148); - const uint64_t v_203 = seed.word(149); - const uint64_t v_204 = seed.word(150); - const uint64_t v_205 = seed.word(151); - const uint64_t v_206 = seed.word(152); - const uint64_t v_207 = seed.word(153); - const uint64_t v_208 = seed.word(154); - const uint64_t v_209 = seed.word(155); - const uint64_t v_210 = seed.word(156); - const uint64_t v_211 = seed.word(157); - const uint64_t v_212 = seed.word(158); - const uint64_t v_213 = seed.word(159); - const uint64_t v_214 = seed.word(160); - const uint64_t v_215 = seed.word(161); - const uint64_t v_216 = seed.word(162); - const uint64_t v_217 = seed.word(163); - const uint64_t v_218 = seed.word(164); - const uint64_t v_219 = seed.word(165); - const uint64_t v_220 = seed.word(166); - const uint64_t v_221 = seed.word(167); - const uint64_t v_222 = seed.word(168); - row[layout.auxiliaries + 103] = v_191; - row[layout.auxiliaries + 104] = v_192; - row[layout.auxiliaries + 105] = v_193; - row[layout.auxiliaries + 106] = v_194; - row[layout.auxiliaries + 107] = v_195; - row[layout.auxiliaries + 108] = v_196; - row[layout.auxiliaries + 109] = v_197; - row[layout.auxiliaries + 110] = v_198; - row[layout.auxiliaries + 111] = v_199; - row[layout.auxiliaries + 112] = v_200; - row[layout.auxiliaries + 113] = v_201; - row[layout.auxiliaries + 114] = v_202; - row[layout.auxiliaries + 115] = v_203; - row[layout.auxiliaries + 116] = v_204; - row[layout.auxiliaries + 117] = v_205; - row[layout.auxiliaries + 118] = v_206; - row[layout.auxiliaries + 119] = v_207; - row[layout.auxiliaries + 120] = v_208; - row[layout.auxiliaries + 121] = v_209; - row[layout.auxiliaries + 122] = v_210; - row[layout.auxiliaries + 123] = v_211; - row[layout.auxiliaries + 124] = v_212; - row[layout.auxiliaries + 125] = v_213; - row[layout.auxiliaries + 126] = v_214; - row[layout.auxiliaries + 127] = v_215; - row[layout.auxiliaries + 128] = v_216; - row[layout.auxiliaries + 129] = v_217; - row[layout.auxiliaries + 130] = v_218; - row[layout.auxiliaries + 131] = v_219; - row[layout.auxiliaries + 132] = v_220; - row[layout.auxiliaries + 133] = v_221; - row[layout.auxiliaries + 134] = v_222; - const uint64_t v_223 = seed.word(169); - row[layout.auxiliaries + 135] = v_223; - row[layout.selectors + 2] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 103] = (v_138 <= 1ULL ? inverse_24_0[v_138] : inverse(goldilocks_sub(v_138, 1ULL))); - const uint64_t v_241 = seed.word(137); - const uint64_t v_242 = seed.word(138); - const uint64_t v_243 = seed.word(139); - const uint64_t v_244 = seed.word(140); - const uint64_t v_245 = seed.word(141); - const uint64_t v_246 = seed.word(142); - const uint64_t v_247 = seed.word(143); - const uint64_t v_248 = seed.word(144); - const uint64_t v_249 = seed.word(145); - const uint64_t v_250 = seed.word(146); - const uint64_t v_251 = seed.word(147); - const uint64_t v_252 = seed.word(148); - const uint64_t v_253 = seed.word(149); - const uint64_t v_254 = seed.word(150); - const uint64_t v_255 = seed.word(151); - const uint64_t v_256 = seed.word(152); - const uint64_t v_257 = seed.word(153); - const uint64_t v_258 = seed.word(154); - const uint64_t v_259 = seed.word(155); - const uint64_t v_260 = seed.word(156); - const uint64_t v_261 = seed.word(157); - const uint64_t v_262 = seed.word(158); - const uint64_t v_263 = seed.word(159); - const uint64_t v_264 = seed.word(160); - const uint64_t v_265 = seed.word(161); - const uint64_t v_266 = seed.word(162); - const uint64_t v_267 = seed.word(163); - const uint64_t v_268 = seed.word(164); - const uint64_t v_269 = seed.word(165); - const uint64_t v_270 = seed.word(166); - const uint64_t v_271 = seed.word(167); - const uint64_t v_272 = seed.word(168); - 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; - row[layout.auxiliaries + 112] = v_249; - row[layout.auxiliaries + 113] = v_250; - row[layout.auxiliaries + 114] = v_251; - row[layout.auxiliaries + 115] = v_252; - row[layout.auxiliaries + 116] = v_253; - row[layout.auxiliaries + 117] = v_254; - row[layout.auxiliaries + 118] = v_255; - row[layout.auxiliaries + 119] = v_256; - row[layout.auxiliaries + 120] = v_257; - row[layout.auxiliaries + 121] = v_258; - row[layout.auxiliaries + 122] = v_259; - row[layout.auxiliaries + 123] = v_260; - row[layout.auxiliaries + 124] = v_261; - row[layout.auxiliaries + 125] = v_262; - row[layout.auxiliaries + 126] = v_263; - row[layout.auxiliaries + 127] = v_264; - row[layout.auxiliaries + 128] = v_265; - row[layout.auxiliaries + 129] = v_266; - row[layout.auxiliaries + 130] = v_267; - row[layout.auxiliaries + 131] = v_268; - row[layout.auxiliaries + 132] = v_269; - row[layout.auxiliaries + 133] = v_270; - row[layout.auxiliaries + 134] = v_271; - row[layout.auxiliaries + 135] = v_272; - const uint64_t v_273 = seed.word(169); - row[layout.auxiliaries + 136] = v_273; - row[layout.selectors + 3] = 1; - return 0; - } - } - } - default: { - return 2; - } - } - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_24(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 ? 432 : 1360; - const Seed_ixvm_24 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_24(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_24(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_24<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_24<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_24(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 < 34 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 137) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 432 : encoding == 0 ? 1360 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_24); -} - -template struct Seed_ixvm_26 { - 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_u8(data + 156); - case 4: return load_u64(data + 16); - case 5: return load_u32(data + 132); - case 6: return load_u32(data + 136); - case 7: return load_u64(data + 24); - case 8: return load_u8(data + 157); - case 9: return load_u64(data + 32); - case 10: return load_u32(data + 140); - case 11: return load_u64(data + 40); - case 12: return load_u64(data + 48); - case 13: return load_u64(data + 56); - case 14: return load_u32(data + 144); - 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_u32(data + 148); - case 19: return load_u64(data + 88); - case 20: return load_u64(data + 96); - case 21: return load_u64(data + 104); - case 22: return load_u32(data + 152); - case 23: return load_u64(data + 112); - case 24: return load_u64(data + 120); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_26(Seed_ixvm_26 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_14 = 1ULL; - const uint64_t v_15 = goldilocks_add(v_2, v_14); - const uint64_t v_17 = seed.word(12); - const uint64_t v_18 = seed.word(13); - const uint64_t v_19 = seed.word(14); - row[layout.auxiliaries + 6] = v_17; - row[layout.auxiliaries + 7] = v_18; - row[layout.auxiliaries + 8] = v_19; - switch (v_17) { - case 1ULL: { - const uint64_t v_20 = seed.word(15); - row[layout.auxiliaries + 9] = v_20; - row[layout.selectors + 2] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_22 = seed.word(15); - row[layout.auxiliaries + 9] = v_22; - switch (v_15) { - case 63ULL: { - const uint64_t v_23 = seed.word(16); - row[layout.auxiliaries + 10] = v_23; - row[layout.selectors + 3] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 10] = inverse(goldilocks_sub(v_15, 63ULL)); - const uint64_t v_24 = 1ULL; - const uint64_t v_25 = goldilocks_add(v_15, v_24); - 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 + 11] = v_27; - row[layout.auxiliaries + 12] = v_28; - row[layout.auxiliaries + 13] = v_29; - switch (v_27) { - case 1ULL: { - const uint64_t v_30 = seed.word(19); - row[layout.auxiliaries + 14] = v_30; - row[layout.selectors + 4] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_32 = seed.word(19); - row[layout.auxiliaries + 14] = v_32; - switch (v_25) { - case 63ULL: { - const uint64_t v_33 = seed.word(20); - row[layout.auxiliaries + 15] = v_33; - row[layout.selectors + 5] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 15] = inverse(goldilocks_sub(v_25, 63ULL)); - const uint64_t v_34 = 1ULL; - const uint64_t v_35 = goldilocks_add(v_25, v_34); - const uint64_t v_37 = seed.word(20); - const uint64_t v_38 = seed.word(21); - const uint64_t v_39 = seed.word(22); - row[layout.auxiliaries + 16] = v_37; - row[layout.auxiliaries + 17] = v_38; - row[layout.auxiliaries + 18] = v_39; - switch (v_37) { - case 1ULL: { - const uint64_t v_40 = seed.word(23); - row[layout.auxiliaries + 19] = v_40; - row[layout.selectors + 6] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_42 = seed.word(23); - row[layout.auxiliaries + 19] = v_42; - switch (v_35) { - case 63ULL: { - const uint64_t v_43 = seed.word(24); - row[layout.auxiliaries + 20] = v_43; - row[layout.selectors + 7] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 20] = inverse(goldilocks_sub(v_35, 63ULL)); - const uint64_t v_47 = seed.word(24); - row[layout.auxiliaries + 21] = v_47; - row[layout.selectors + 8] = 1; - return 0; - } - } - } - default: { - return 2; - } - } - } - } - } - default: { - return 2; - } - } - } - } - } - default: { - return 2; - } - } - } - } - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_26(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 ? 160 : 200; - const Seed_ixvm_26 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_26(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_26(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_26<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_26<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_26(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 < 9 || width < auxiliaries || width - auxiliaries < 22) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 160 : encoding == 0 ? 200 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_26); -} - -template struct Seed_ixvm_30 { - 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_30(Seed_ixvm_30 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_30(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_30 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_30(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_30(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_30<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_30<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_30(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_30); -} - -template struct Seed_ixvm_33 { - 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_33(Seed_ixvm_33 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 = goldilocks_mul(v_8, v_73); - const uint64_t v_75 = seed.word(72); - const uint64_t v_76 = seed.word(73); - const uint64_t v_77 = seed.word(74); - const uint64_t v_78 = seed.word(75); - const uint64_t v_79 = seed.word(76); - const uint64_t v_80 = seed.word(77); - const uint64_t v_81 = seed.word(78); - const uint64_t v_82 = seed.word(79); - row[layout.auxiliaries + 66] = v_75; - row[layout.auxiliaries + 67] = v_76; - row[layout.auxiliaries + 68] = v_77; - row[layout.auxiliaries + 69] = v_78; - row[layout.auxiliaries + 70] = v_79; - row[layout.auxiliaries + 71] = v_80; - row[layout.auxiliaries + 72] = v_81; - row[layout.auxiliaries + 73] = v_82; - const uint64_t v_83 = seed.word(80); - row[layout.auxiliaries + 74] = v_83; - const uint64_t v_84 = goldilocks_mul(v_74, v_83); - row[layout.auxiliaries + 75] = v_84; - 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_199, v_208); - row[layout.auxiliaries + 77] = v_209; - 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_33(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_33 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_33(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_33(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_33<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_33<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_33(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_33); -} - -__device__ __constant__ uint64_t inverse_37_0[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_37 { - 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_37(Seed_ixvm_37 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_37_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 = goldilocks_mul(v_165, v_167); - row[layout.auxiliaries + 6] = v_168; - const uint64_t v_169 = 2ULL; - const uint64_t v_170 = goldilocks_sub(v_165, v_169); - const uint64_t v_171 = goldilocks_mul(v_168, 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_mul(v_199, v_200); - row[layout.auxiliaries + 29] = v_201; - const uint64_t v_202 = goldilocks_sub(v_199, v_169); - const uint64_t v_203 = goldilocks_mul(v_201, 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_mul(v_230, v_231); - row[layout.auxiliaries + 52] = v_232; - const uint64_t v_233 = goldilocks_sub(v_230, v_169); - const uint64_t v_234 = goldilocks_mul(v_232, 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_mul(v_261, v_262); - row[layout.auxiliaries + 75] = v_263; - const uint64_t v_264 = goldilocks_sub(v_261, v_169); - const uint64_t v_265 = goldilocks_mul(v_263, 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_mul(v_292, v_293); - row[layout.auxiliaries + 98] = v_294; - const uint64_t v_295 = goldilocks_sub(v_292, v_169); - const uint64_t v_296 = goldilocks_mul(v_294, 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_mul(v_323, v_324); - row[layout.auxiliaries + 121] = v_325; - const uint64_t v_326 = goldilocks_sub(v_323, v_169); - const uint64_t v_327 = goldilocks_mul(v_325, 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_mul(v_354, v_355); - row[layout.auxiliaries + 144] = v_356; - const uint64_t v_357 = goldilocks_sub(v_354, v_169); - const uint64_t v_358 = goldilocks_mul(v_356, 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_mul(v_385, v_386); - row[layout.auxiliaries + 167] = v_387; - const uint64_t v_388 = goldilocks_sub(v_385, v_169); - const uint64_t v_389 = goldilocks_mul(v_387, 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_mul(v_416, v_417); - row[layout.auxiliaries + 190] = v_418; - const uint64_t v_419 = goldilocks_sub(v_416, v_169); - const uint64_t v_420 = goldilocks_mul(v_418, 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_mul(v_447, v_448); - row[layout.auxiliaries + 213] = v_449; - const uint64_t v_450 = goldilocks_sub(v_447, v_169); - const uint64_t v_451 = goldilocks_mul(v_449, 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_mul(v_478, v_479); - row[layout.auxiliaries + 236] = v_480; - const uint64_t v_481 = goldilocks_sub(v_478, v_169); - const uint64_t v_482 = goldilocks_mul(v_480, 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_mul(v_509, v_510); - row[layout.auxiliaries + 259] = v_511; - const uint64_t v_512 = goldilocks_sub(v_509, v_169); - const uint64_t v_513 = goldilocks_mul(v_511, 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_mul(v_540, v_541); - row[layout.auxiliaries + 282] = v_542; - const uint64_t v_543 = goldilocks_sub(v_540, v_169); - const uint64_t v_544 = goldilocks_mul(v_542, 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_mul(v_571, v_572); - row[layout.auxiliaries + 305] = v_573; - const uint64_t v_574 = goldilocks_sub(v_571, v_169); - const uint64_t v_575 = goldilocks_mul(v_573, 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_mul(v_602, v_603); - row[layout.auxiliaries + 328] = v_604; - const uint64_t v_605 = goldilocks_sub(v_602, v_169); - const uint64_t v_606 = goldilocks_mul(v_604, 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_mul(v_633, v_634); - row[layout.auxiliaries + 351] = v_635; - const uint64_t v_636 = goldilocks_sub(v_633, v_169); - const uint64_t v_637 = goldilocks_mul(v_635, 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_37(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_37 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_37(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_37(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_37<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_37<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_37(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_37); -} - -__device__ __constant__ uint64_t inverse_41_0[] = {0ULL}; -template struct Seed_ixvm_41 { - 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 + 28); - case 3: return load_u8(data + 29); - case 4: return load_u8(data + 30); - case 5: return load_u8(data + 31); - case 6: return load_u8(data + 32); - case 7: return load_u8(data + 33); - case 8: return load_u8(data + 34); - case 9: return load_u8(data + 35); - case 10: return load_u64(data + 16); - case 11: return load_u32(data + 24); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_41(Seed_ixvm_41 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 = goldilocks_add(v_2, v_3); - const uint64_t v_11 = goldilocks_add(v_10, v_4); - const uint64_t v_12 = goldilocks_add(v_11, v_5); - const uint64_t v_13 = goldilocks_add(v_12, v_6); - const uint64_t v_14 = goldilocks_add(v_13, v_7); - const uint64_t v_15 = goldilocks_add(v_14, v_8); - switch (v_15) { - case 0ULL: { - const uint64_t v_16 = 32ULL; - if (v_1 > 255 || v_16 > 255) return 1; - const uint64_t v_17 = uint64_t(v_1 < v_16); - row[layout.auxiliaries + 1] = v_17; - switch (v_17) { - case 1ULL: { - const uint64_t v_22 = seed.word(11); - row[layout.auxiliaries + 2] = v_22; - row[layout.selectors + 0] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_26 = seed.word(11); - row[layout.auxiliaries + 2] = v_26; - row[layout.selectors + 1] = 1; - return 0; - } - default: { - return 2; - } - } - } - default: { - row[layout.auxiliaries + 1] = (v_15 <= 0ULL ? inverse_41_0[v_15] : inverse(goldilocks_sub(v_15, 0ULL))); - const uint64_t v_30 = seed.word(11); - row[layout.auxiliaries + 2] = v_30; - row[layout.selectors + 2] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_41(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 : 96; - const Seed_ixvm_41 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_41(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_41(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_41<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_41<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_41(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 < 3 || width < auxiliaries || width - auxiliaries < 3) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 40 : encoding == 0 ? 96 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_41); -} - -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_u64(data + 8); - case 2: return load_u64(data + 16); - case 3: return load_u8(data + 40); - case 4: return load_u8(data + 41); - case 5: return load_u8(data + 42); - case 6: return load_u8(data + 43); - case 7: return load_u8(data + 44); - case 8: return load_u8(data + 45); - case 9: return load_u8(data + 46); - case 10: return load_u8(data + 47); - case 11: return load_u64(data + 24); - case 12: return load_u8(data + 48); - case 13: return load_u8(data + 49); - case 14: return load_u8(data + 50); - case 15: return load_u8(data + 51); - case 16: return load_u8(data + 52); - case 17: return load_u8(data + 53); - case 18: return load_u8(data + 54); - case 19: return load_u8(data + 55); - case 20: return load_u8(data + 56); - case 21: return load_u32(data + 32); - case 22: return load_u32(data + 36); - 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; - 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_17 = seed.word(12); - const uint64_t v_18 = seed.word(13); - const uint64_t v_19 = seed.word(14); - const uint64_t v_20 = seed.word(15); - const uint64_t v_21 = seed.word(16); - const uint64_t v_22 = seed.word(17); - const uint64_t v_23 = seed.word(18); - const uint64_t v_24 = seed.word(19); - const uint64_t v_25 = seed.word(20); - 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; - switch (v_25) { - case 0ULL: { - const uint64_t v_26 = 256ULL; - const uint64_t v_27 = 2ULL; - const uint64_t v_28 = goldilocks_mul(v_27, v_1); - const uint64_t v_29 = goldilocks_sub(v_26, v_28); - if (v_2 > 255 || v_29 > 255) return 1; - const uint64_t v_30 = ((v_2 + v_29) & 255ULL); - const uint64_t v_31 = ((v_2 + v_29) >> 8); - row[layout.auxiliaries + 10] = v_30; - const uint64_t v_38 = seed.word(21); - row[layout.auxiliaries + 11] = v_38; - const uint64_t v_39 = seed.word(22); - row[layout.auxiliaries + 12] = v_39; - row[layout.selectors + 0] = 1; - return 0; - } - case 1ULL: { - const uint64_t v_44 = seed.word(21); - row[layout.auxiliaries + 10] = v_44; - row[layout.selectors + 1] = 1; - return 0; - } - default: { - return 2; - } - } -} -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 ? 64 : 184; - 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 < 11 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 13) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 64 : encoding == 0 ? 184 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_43); -} - -__device__ __constant__ uint64_t inverse_44_0[] = {0ULL}; -__device__ __constant__ uint64_t inverse_44_1[] = {0ULL}; -__device__ __constant__ uint64_t inverse_44_2[] = {0ULL}; -template struct Seed_ixvm_44 { - 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 + 40); - case 3: return load_u8(data + 41); - case 4: return load_u8(data + 42); - case 5: return load_u8(data + 43); - case 6: return load_u8(data + 44); - case 7: return load_u8(data + 45); - case 8: return load_u8(data + 46); - case 9: return load_u8(data + 47); - case 10: return load_u8(data + 48); - case 11: return load_u64(data + 16); - case 12: return load_u64(data + 24); - case 13: return load_u32(data + 32); - case 14: return load_u8(data + 49); - case 15: return load_u8(data + 50); - case 16: return load_u8(data + 51); - case 17: return load_u8(data + 52); - case 18: return load_u8(data + 53); - case 19: return load_u8(data + 54); - case 20: return load_u8(data + 55); - case 21: return load_u32(data + 36); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_44(Seed_ixvm_44 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; - switch (v_1) { - case 0ULL: { - const uint64_t v_11 = goldilocks_add(v_4, v_5); - const uint64_t v_12 = goldilocks_add(v_11, v_6); - const uint64_t v_13 = goldilocks_add(v_12, v_7); - const uint64_t v_14 = goldilocks_add(v_13, v_8); - const uint64_t v_15 = goldilocks_add(v_14, v_9); - switch (v_15) { - case 0ULL: { - const uint64_t v_18 = seed.word(12); - row[layout.auxiliaries + 1] = v_18; - const uint64_t v_19 = seed.word(13); - row[layout.auxiliaries + 2] = v_19; - row[layout.selectors + 0] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 1] = (v_15 <= 0ULL ? inverse_44_0[v_15] : inverse(goldilocks_sub(v_15, 0ULL))); - const uint64_t v_22 = seed.word(12); - const uint64_t v_23 = seed.word(13); - const uint64_t v_24 = seed.word(14); - const uint64_t v_25 = seed.word(15); - const uint64_t v_26 = seed.word(16); - const uint64_t v_27 = seed.word(17); - const uint64_t v_28 = seed.word(18); - const uint64_t v_29 = seed.word(19); - const uint64_t v_30 = seed.word(20); - row[layout.auxiliaries + 2] = v_22; - row[layout.auxiliaries + 3] = v_23; - row[layout.auxiliaries + 4] = v_24; - row[layout.auxiliaries + 5] = v_25; - row[layout.auxiliaries + 6] = v_26; - row[layout.auxiliaries + 7] = v_27; - row[layout.auxiliaries + 8] = v_28; - row[layout.auxiliaries + 9] = v_29; - row[layout.auxiliaries + 10] = v_30; - const uint64_t v_32 = seed.word(21); - row[layout.auxiliaries + 11] = v_32; - row[layout.selectors + 1] = 1; - return 0; - } - } - } - case 1ULL: { - const uint64_t v_33 = goldilocks_add(v_5, v_6); - const uint64_t v_34 = goldilocks_add(v_33, v_7); - const uint64_t v_35 = goldilocks_add(v_34, v_8); - const uint64_t v_36 = goldilocks_add(v_35, v_9); - switch (v_36) { - case 0ULL: { - const uint64_t v_41 = seed.word(12); - row[layout.auxiliaries + 1] = v_41; - const uint64_t v_42 = seed.word(13); - row[layout.auxiliaries + 2] = v_42; - row[layout.selectors + 2] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 1] = (v_36 <= 0ULL ? inverse_44_1[v_36] : inverse(goldilocks_sub(v_36, 0ULL))); - const uint64_t v_45 = seed.word(12); - const uint64_t v_46 = seed.word(13); - const uint64_t v_47 = seed.word(14); - const uint64_t v_48 = seed.word(15); - const uint64_t v_49 = seed.word(16); - const uint64_t v_50 = seed.word(17); - const uint64_t v_51 = seed.word(18); - const uint64_t v_52 = seed.word(19); - const uint64_t v_53 = seed.word(20); - row[layout.auxiliaries + 2] = v_45; - row[layout.auxiliaries + 3] = v_46; - row[layout.auxiliaries + 4] = v_47; - row[layout.auxiliaries + 5] = v_48; - row[layout.auxiliaries + 6] = v_49; - row[layout.auxiliaries + 7] = v_50; - row[layout.auxiliaries + 8] = v_51; - row[layout.auxiliaries + 9] = v_52; - row[layout.auxiliaries + 10] = v_53; - const uint64_t v_55 = seed.word(21); - row[layout.auxiliaries + 11] = v_55; - row[layout.selectors + 3] = 1; - return 0; - } - } - } - case 2ULL: { - const uint64_t v_56 = goldilocks_add(v_6, v_7); - const uint64_t v_57 = goldilocks_add(v_56, v_8); - const uint64_t v_58 = goldilocks_add(v_57, v_9); - switch (v_58) { - case 0ULL: { - const uint64_t v_63 = seed.word(12); - row[layout.auxiliaries + 1] = v_63; - const uint64_t v_64 = seed.word(13); - row[layout.auxiliaries + 2] = v_64; - row[layout.selectors + 4] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 1] = (v_58 <= 0ULL ? inverse_44_2[v_58] : inverse(goldilocks_sub(v_58, 0ULL))); - const uint64_t v_67 = seed.word(12); - const uint64_t v_68 = seed.word(13); - const uint64_t v_69 = seed.word(14); - const uint64_t v_70 = seed.word(15); - const uint64_t v_71 = seed.word(16); - const uint64_t v_72 = seed.word(17); - const uint64_t v_73 = seed.word(18); - const uint64_t v_74 = seed.word(19); - const uint64_t v_75 = seed.word(20); - row[layout.auxiliaries + 2] = v_67; - row[layout.auxiliaries + 3] = v_68; - row[layout.auxiliaries + 4] = v_69; - row[layout.auxiliaries + 5] = v_70; - row[layout.auxiliaries + 6] = v_71; - row[layout.auxiliaries + 7] = v_72; - row[layout.auxiliaries + 8] = v_73; - row[layout.auxiliaries + 9] = v_74; - row[layout.auxiliaries + 10] = v_75; - const uint64_t v_77 = seed.word(21); - row[layout.auxiliaries + 11] = v_77; - row[layout.selectors + 5] = 1; - return 0; - } - } - } - case 3ULL: { - const uint64_t v_82 = seed.word(12); - row[layout.auxiliaries + 1] = v_82; - const uint64_t v_83 = seed.word(13); - row[layout.auxiliaries + 2] = v_83; - row[layout.selectors + 6] = 1; - return 0; - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_44(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 : 176; - const Seed_ixvm_44 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_44(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_44(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_44<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_44<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_44(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 < 11 || auxiliaries < selectors || auxiliaries - selectors < 7 || width < auxiliaries || width - auxiliaries < 12) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 56 : encoding == 0 ? 176 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_44); -} - -template struct Seed_ixvm_47 { - 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_47(Seed_ixvm_47 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_47(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_47 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_47(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_47(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_47<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_47<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_47(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_47); -} - -__device__ __constant__ uint64_t inverse_50_0[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_50 { - 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 + 336); - 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_u64(data + 80); - case 12: return load_u64(data + 88); - case 13: return load_u64(data + 96); - case 14: return load_u64(data + 104); - case 15: return load_u64(data + 112); - case 16: return load_u64(data + 120); - case 17: return load_u64(data + 128); - case 18: return load_u64(data + 136); - case 19: return load_u8(data + 348); - case 20: return load_u32(data + 340); - case 21: return load_u64(data + 144); - case 22: return load_u8(data + 349); - 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_u32(data + 344); - case 29: return load_u64(data + 192); - case 30: return load_u8(data + 350); - case 31: return load_u8(data + 351); - case 32: return load_u8(data + 352); - case 33: return load_u8(data + 353); - case 34: return load_u8(data + 354); - case 35: return load_u8(data + 355); - case 36: return load_u64(data + 200); - case 37: return load_u64(data + 208); - case 38: return load_u64(data + 216); - case 39: return load_u64(data + 224); - case 40: return load_u64(data + 232); - case 41: return load_u64(data + 240); - case 42: return load_u64(data + 248); - case 43: return load_u64(data + 256); - case 44: return load_u64(data + 264); - case 45: return load_u64(data + 272); - case 46: return load_u64(data + 280); - case 47: return load_u64(data + 288); - case 48: return load_u64(data + 296); - case 49: return load_u64(data + 304); - case 50: return load_u64(data + 312); - case 51: return load_u64(data + 320); - case 52: return load_u64(data + 328); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_50(Seed_ixvm_50 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; - switch (v_0) { - case 7ULL: { - 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); - 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); - row[layout.auxiliaries + 1] = v_18; - row[layout.auxiliaries + 2] = v_19; - row[layout.auxiliaries + 3] = v_20; - row[layout.auxiliaries + 4] = v_21; - row[layout.auxiliaries + 5] = v_22; - row[layout.auxiliaries + 6] = v_23; - row[layout.auxiliaries + 7] = v_24; - row[layout.auxiliaries + 8] = v_25; - row[layout.auxiliaries + 9] = v_26; - row[layout.auxiliaries + 10] = v_27; - row[layout.auxiliaries + 11] = v_28; - row[layout.auxiliaries + 12] = v_29; - row[layout.auxiliaries + 13] = v_30; - row[layout.auxiliaries + 14] = v_31; - row[layout.auxiliaries + 15] = v_32; - row[layout.auxiliaries + 16] = v_33; - row[layout.auxiliaries + 17] = v_34; - row[layout.auxiliaries + 18] = v_35; - 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); - row[layout.auxiliaries + 19] = v_36; - row[layout.auxiliaries + 20] = v_37; - row[layout.auxiliaries + 21] = v_38; - row[layout.auxiliaries + 22] = v_39; - row[layout.auxiliaries + 23] = v_40; - row[layout.auxiliaries + 24] = v_41; - row[layout.auxiliaries + 25] = v_42; - row[layout.auxiliaries + 26] = v_43; - 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); - row[layout.auxiliaries + 27] = v_44; - row[layout.auxiliaries + 28] = v_45; - row[layout.auxiliaries + 29] = v_46; - row[layout.auxiliaries + 30] = v_47; - row[layout.auxiliaries + 31] = v_48; - row[layout.auxiliaries + 32] = v_49; - row[layout.auxiliaries + 33] = v_50; - row[layout.auxiliaries + 34] = v_51; - row[layout.selectors + 0] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 1] = (v_0 <= 7ULL ? inverse_50_0[v_0] : inverse(goldilocks_sub(v_0, 7ULL))); - row[layout.selectors + 1] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_50(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 ? 360 : 424; - const Seed_ixvm_50 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_50(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_50(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_50<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_50<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_50(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 < 18 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 35) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 360 : encoding == 0 ? 424 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_50); -} - -__device__ __constant__ uint64_t inverse_51_0[] = {2305843008676823040ULL, 15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_51 { - 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_u32(data + 336); - 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_u64(data + 80); - case 12: return load_u64(data + 88); - case 13: return load_u64(data + 96); - case 14: return load_u64(data + 104); - case 15: return load_u64(data + 112); - case 16: return load_u64(data + 120); - case 17: return load_u64(data + 128); - case 18: return load_u64(data + 136); - case 19: return load_u8(data + 348); - case 20: return load_u64(data + 144); - case 21: return load_u64(data + 152); - case 22: return load_u8(data + 349); - case 23: return load_u64(data + 160); - case 24: return load_u32(data + 340); - 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_u32(data + 344); - case 29: return load_u64(data + 192); - case 30: return load_u8(data + 350); - case 31: return load_u8(data + 351); - case 32: return load_u8(data + 352); - case 33: return load_u8(data + 353); - case 34: return load_u8(data + 354); - case 35: return load_u8(data + 355); - case 36: return load_u64(data + 200); - case 37: return load_u64(data + 208); - case 38: return load_u64(data + 216); - case 39: return load_u64(data + 224); - case 40: return load_u64(data + 232); - case 41: return load_u64(data + 240); - case 42: return load_u64(data + 248); - case 43: return load_u64(data + 256); - case 44: return load_u64(data + 264); - case 45: return load_u64(data + 272); - case 46: return load_u64(data + 280); - case 47: return load_u64(data + 288); - case 48: return load_u64(data + 296); - case 49: return load_u64(data + 304); - case 50: return load_u64(data + 312); - case 51: return load_u64(data + 320); - case 52: return load_u64(data + 328); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_51(Seed_ixvm_51 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; - switch (v_0) { - case 8ULL: { - 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); - 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); - row[layout.auxiliaries + 1] = v_18; - row[layout.auxiliaries + 2] = v_19; - row[layout.auxiliaries + 3] = v_20; - row[layout.auxiliaries + 4] = v_21; - row[layout.auxiliaries + 5] = v_22; - row[layout.auxiliaries + 6] = v_23; - row[layout.auxiliaries + 7] = v_24; - row[layout.auxiliaries + 8] = v_25; - row[layout.auxiliaries + 9] = v_26; - row[layout.auxiliaries + 10] = v_27; - row[layout.auxiliaries + 11] = v_28; - row[layout.auxiliaries + 12] = v_29; - row[layout.auxiliaries + 13] = v_30; - row[layout.auxiliaries + 14] = v_31; - row[layout.auxiliaries + 15] = v_32; - row[layout.auxiliaries + 16] = v_33; - row[layout.auxiliaries + 17] = v_34; - row[layout.auxiliaries + 18] = v_35; - 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); - row[layout.auxiliaries + 19] = v_36; - row[layout.auxiliaries + 20] = v_37; - row[layout.auxiliaries + 21] = v_38; - row[layout.auxiliaries + 22] = v_39; - row[layout.auxiliaries + 23] = v_40; - row[layout.auxiliaries + 24] = v_41; - row[layout.auxiliaries + 25] = v_42; - row[layout.auxiliaries + 26] = v_43; - 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); - row[layout.auxiliaries + 27] = v_44; - row[layout.auxiliaries + 28] = v_45; - row[layout.auxiliaries + 29] = v_46; - row[layout.auxiliaries + 30] = v_47; - row[layout.auxiliaries + 31] = v_48; - row[layout.auxiliaries + 32] = v_49; - row[layout.auxiliaries + 33] = v_50; - row[layout.auxiliaries + 34] = v_51; - row[layout.selectors + 0] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 1] = (v_0 <= 8ULL ? inverse_51_0[v_0] : inverse(goldilocks_sub(v_0, 8ULL))); - row[layout.selectors + 1] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_51(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 ? 360 : 424; - const Seed_ixvm_51 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_51(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_51(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_51<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_51<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_51(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 < 18 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 35) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 360 : encoding == 0 ? 424 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_51); -} - -__device__ __constant__ uint64_t inverse_52_0[] = {14347467609544676694ULL, 2305843008676823040ULL, 15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_52 { - 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_u32(data + 336); - case 9: return load_u64(data + 64); - case 10: return load_u64(data + 72); - case 11: return load_u64(data + 80); - case 12: return load_u64(data + 88); - case 13: return load_u64(data + 96); - case 14: return load_u64(data + 104); - case 15: return load_u64(data + 112); - case 16: return load_u64(data + 120); - case 17: return load_u64(data + 128); - case 18: return load_u64(data + 136); - case 19: return load_u8(data + 348); - case 20: return load_u64(data + 144); - case 21: return load_u64(data + 152); - case 22: return load_u8(data + 349); - 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_u32(data + 340); - case 27: return load_u64(data + 184); - case 28: return load_u32(data + 344); - case 29: return load_u64(data + 192); - case 30: return load_u8(data + 350); - case 31: return load_u8(data + 351); - case 32: return load_u8(data + 352); - case 33: return load_u8(data + 353); - case 34: return load_u8(data + 354); - case 35: return load_u8(data + 355); - case 36: return load_u64(data + 200); - case 37: return load_u64(data + 208); - case 38: return load_u64(data + 216); - case 39: return load_u64(data + 224); - case 40: return load_u64(data + 232); - case 41: return load_u64(data + 240); - case 42: return load_u64(data + 248); - case 43: return load_u64(data + 256); - case 44: return load_u64(data + 264); - case 45: return load_u64(data + 272); - case 46: return load_u64(data + 280); - case 47: return load_u64(data + 288); - case 48: return load_u64(data + 296); - case 49: return load_u64(data + 304); - case 50: return load_u64(data + 312); - case 51: return load_u64(data + 320); - case 52: return load_u64(data + 328); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_52(Seed_ixvm_52 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; - switch (v_0) { - case 9ULL: { - 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); - 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); - row[layout.auxiliaries + 1] = v_18; - row[layout.auxiliaries + 2] = v_19; - row[layout.auxiliaries + 3] = v_20; - row[layout.auxiliaries + 4] = v_21; - row[layout.auxiliaries + 5] = v_22; - row[layout.auxiliaries + 6] = v_23; - row[layout.auxiliaries + 7] = v_24; - row[layout.auxiliaries + 8] = v_25; - row[layout.auxiliaries + 9] = v_26; - row[layout.auxiliaries + 10] = v_27; - row[layout.auxiliaries + 11] = v_28; - row[layout.auxiliaries + 12] = v_29; - row[layout.auxiliaries + 13] = v_30; - row[layout.auxiliaries + 14] = v_31; - row[layout.auxiliaries + 15] = v_32; - row[layout.auxiliaries + 16] = v_33; - row[layout.auxiliaries + 17] = v_34; - row[layout.auxiliaries + 18] = v_35; - 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); - row[layout.auxiliaries + 19] = v_36; - row[layout.auxiliaries + 20] = v_37; - row[layout.auxiliaries + 21] = v_38; - row[layout.auxiliaries + 22] = v_39; - row[layout.auxiliaries + 23] = v_40; - row[layout.auxiliaries + 24] = v_41; - row[layout.auxiliaries + 25] = v_42; - row[layout.auxiliaries + 26] = v_43; - 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); - row[layout.auxiliaries + 27] = v_44; - row[layout.auxiliaries + 28] = v_45; - row[layout.auxiliaries + 29] = v_46; - row[layout.auxiliaries + 30] = v_47; - row[layout.auxiliaries + 31] = v_48; - row[layout.auxiliaries + 32] = v_49; - row[layout.auxiliaries + 33] = v_50; - row[layout.auxiliaries + 34] = v_51; - row[layout.selectors + 0] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 1] = (v_0 <= 9ULL ? inverse_52_0[v_0] : inverse(goldilocks_sub(v_0, 9ULL))); - row[layout.selectors + 1] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_52(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 ? 360 : 424; - const Seed_ixvm_52 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_52(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_52(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_52<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_52<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_52(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 < 18 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 35) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 360 : encoding == 0 ? 424 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_52); -} - -__device__ __constant__ uint64_t inverse_53_0[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_53 { - 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 + 40); - case 2: return load_u8(data + 41); - case 3: return load_u8(data + 42); - case 4: return load_u8(data + 43); - case 5: return load_u8(data + 44); - case 6: return load_u8(data + 45); - case 7: return load_u8(data + 46); - case 8: return load_u8(data + 47); - case 9: return load_u8(data + 48); - case 10: return load_u8(data + 49); - case 11: return load_u8(data + 50); - case 12: return load_u8(data + 51); - case 13: return load_u8(data + 52); - case 14: return load_u8(data + 53); - 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_u32(data + 16); - case 19: return load_u64(data + 8); - case 20: return load_u32(data + 20); - case 21: return load_u8(data + 57); - case 22: return load_u8(data + 58); - case 23: return load_u8(data + 59); - case 24: return load_u8(data + 60); - case 25: return load_u8(data + 61); - case 26: return load_u8(data + 62); - case 27: return load_u8(data + 63); - case 28: return load_u8(data + 64); - case 29: return load_u8(data + 65); - case 30: return load_u8(data + 66); - case 31: return load_u8(data + 67); - case 32: return load_u8(data + 68); - case 33: return load_u8(data + 69); - case 34: return load_u8(data + 70); - case 35: return load_u8(data + 71); - case 36: return load_u8(data + 72); - case 37: return load_u32(data + 24); - case 38: return load_u8(data + 73); - case 39: return load_u8(data + 74); - case 40: return load_u8(data + 75); - case 41: return load_u8(data + 76); - case 42: return load_u8(data + 77); - case 43: return load_u8(data + 78); - case 44: return load_u8(data + 79); - case 45: return load_u8(data + 80); - case 46: return load_u8(data + 81); - case 47: return load_u8(data + 82); - case 48: return load_u8(data + 83); - case 49: return load_u8(data + 84); - case 50: return load_u8(data + 85); - case 51: return load_u8(data + 86); - case 52: return load_u8(data + 87); - case 53: return load_u8(data + 88); - case 54: return load_u8(data + 89); - case 55: return load_u32(data + 28); - case 56: return load_u32(data + 32); - case 57: return load_u32(data + 36); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_53(Seed_ixvm_53 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; - switch (v_0) { - case 7ULL: { - 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); - 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); - row[layout.auxiliaries + 1] = v_19; - row[layout.auxiliaries + 2] = v_20; - row[layout.auxiliaries + 3] = v_21; - row[layout.auxiliaries + 4] = v_22; - row[layout.auxiliaries + 5] = v_23; - row[layout.auxiliaries + 6] = v_24; - row[layout.auxiliaries + 7] = v_25; - row[layout.auxiliaries + 8] = v_26; - row[layout.auxiliaries + 9] = v_27; - row[layout.auxiliaries + 10] = v_28; - row[layout.auxiliaries + 11] = v_29; - row[layout.auxiliaries + 12] = v_30; - row[layout.auxiliaries + 13] = v_31; - row[layout.auxiliaries + 14] = v_32; - row[layout.auxiliaries + 15] = v_33; - row[layout.auxiliaries + 16] = v_34; - row[layout.auxiliaries + 17] = v_35; - row[layout.auxiliaries + 18] = v_36; - 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); - row[layout.auxiliaries + 19] = v_37; - row[layout.auxiliaries + 20] = v_38; - row[layout.auxiliaries + 21] = v_39; - row[layout.auxiliaries + 22] = v_40; - row[layout.auxiliaries + 23] = v_41; - row[layout.auxiliaries + 24] = v_42; - row[layout.auxiliaries + 25] = v_43; - row[layout.auxiliaries + 26] = v_44; - row[layout.auxiliaries + 27] = v_45; - row[layout.auxiliaries + 28] = v_46; - row[layout.auxiliaries + 29] = v_47; - row[layout.auxiliaries + 30] = v_48; - row[layout.auxiliaries + 31] = v_49; - row[layout.auxiliaries + 32] = v_50; - row[layout.auxiliaries + 33] = v_51; - row[layout.auxiliaries + 34] = v_52; - row[layout.auxiliaries + 35] = v_53; - row[layout.auxiliaries + 36] = v_54; - const uint64_t v_55 = seed.word(56); - row[layout.auxiliaries + 37] = v_55; - const uint64_t v_56 = seed.word(57); - row[layout.auxiliaries + 38] = v_56; - row[layout.selectors + 0] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 1] = (v_0 <= 7ULL ? inverse_53_0[v_0] : inverse(goldilocks_sub(v_0, 7ULL))); - const uint64_t v_57 = seed.word(20); - row[layout.auxiliaries + 2] = v_57; - row[layout.selectors + 1] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_53(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 ? 96 : 464; - const Seed_ixvm_53 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_53(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_53(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_53<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_53<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_53(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 < 19 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 39) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 96 : encoding == 0 ? 464 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_53); -} - -__device__ __constant__ uint64_t inverse_54_0[] = {2305843008676823040ULL, 15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_54 { - 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 + 44); - case 2: return load_u8(data + 45); - case 3: return load_u8(data + 46); - case 4: return load_u8(data + 47); - case 5: return load_u8(data + 48); - case 6: return load_u8(data + 49); - case 7: return load_u8(data + 50); - case 8: return load_u8(data + 51); - case 9: return load_u8(data + 52); - case 10: return load_u8(data + 53); - case 11: return load_u8(data + 54); - case 12: return load_u8(data + 55); - case 13: return load_u8(data + 56); - case 14: return load_u8(data + 57); - case 15: return load_u8(data + 58); - case 16: return load_u8(data + 59); - case 17: return load_u8(data + 60); - case 18: return load_u32(data + 16); - case 19: return load_u64(data + 8); - case 20: return load_u32(data + 20); - case 21: return load_u8(data + 61); - case 22: return load_u8(data + 62); - case 23: return load_u8(data + 63); - case 24: return load_u8(data + 64); - case 25: return load_u8(data + 65); - case 26: return load_u8(data + 66); - case 27: return load_u8(data + 67); - case 28: return load_u8(data + 68); - case 29: return load_u8(data + 69); - case 30: return load_u8(data + 70); - case 31: return load_u8(data + 71); - case 32: return load_u8(data + 72); - case 33: return load_u8(data + 73); - case 34: return load_u8(data + 74); - case 35: return load_u8(data + 75); - case 36: return load_u8(data + 76); - case 37: return load_u32(data + 24); - case 38: return load_u8(data + 77); - case 39: return load_u8(data + 78); - case 40: return load_u8(data + 79); - case 41: return load_u8(data + 80); - case 42: return load_u8(data + 81); - case 43: return load_u8(data + 82); - case 44: return load_u8(data + 83); - case 45: return load_u8(data + 84); - case 46: return load_u8(data + 85); - case 47: return load_u8(data + 86); - case 48: return load_u8(data + 87); - case 49: return load_u8(data + 88); - case 50: return load_u8(data + 89); - case 51: return load_u8(data + 90); - case 52: return load_u8(data + 91); - case 53: return load_u8(data + 92); - case 54: return load_u8(data + 93); - case 55: return load_u32(data + 28); - case 56: return load_u32(data + 32); - case 57: return load_u32(data + 36); - case 58: return load_u32(data + 40); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_54(Seed_ixvm_54 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; - switch (v_0) { - case 8ULL: { - 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); - 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); - row[layout.auxiliaries + 1] = v_19; - row[layout.auxiliaries + 2] = v_20; - row[layout.auxiliaries + 3] = v_21; - row[layout.auxiliaries + 4] = v_22; - row[layout.auxiliaries + 5] = v_23; - row[layout.auxiliaries + 6] = v_24; - row[layout.auxiliaries + 7] = v_25; - row[layout.auxiliaries + 8] = v_26; - row[layout.auxiliaries + 9] = v_27; - row[layout.auxiliaries + 10] = v_28; - row[layout.auxiliaries + 11] = v_29; - row[layout.auxiliaries + 12] = v_30; - row[layout.auxiliaries + 13] = v_31; - row[layout.auxiliaries + 14] = v_32; - row[layout.auxiliaries + 15] = v_33; - row[layout.auxiliaries + 16] = v_34; - row[layout.auxiliaries + 17] = v_35; - row[layout.auxiliaries + 18] = v_36; - 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); - row[layout.auxiliaries + 19] = v_37; - row[layout.auxiliaries + 20] = v_38; - row[layout.auxiliaries + 21] = v_39; - row[layout.auxiliaries + 22] = v_40; - row[layout.auxiliaries + 23] = v_41; - row[layout.auxiliaries + 24] = v_42; - row[layout.auxiliaries + 25] = v_43; - row[layout.auxiliaries + 26] = v_44; - row[layout.auxiliaries + 27] = v_45; - row[layout.auxiliaries + 28] = v_46; - row[layout.auxiliaries + 29] = v_47; - row[layout.auxiliaries + 30] = v_48; - row[layout.auxiliaries + 31] = v_49; - row[layout.auxiliaries + 32] = v_50; - row[layout.auxiliaries + 33] = v_51; - row[layout.auxiliaries + 34] = v_52; - row[layout.auxiliaries + 35] = v_53; - row[layout.auxiliaries + 36] = v_54; - const uint64_t v_55 = seed.word(56); - row[layout.auxiliaries + 37] = v_55; - const uint64_t v_56 = seed.word(57); - row[layout.auxiliaries + 38] = v_56; - const uint64_t v_57 = seed.word(58); - row[layout.auxiliaries + 39] = v_57; - row[layout.selectors + 0] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 1] = (v_0 <= 8ULL ? inverse_54_0[v_0] : inverse(goldilocks_sub(v_0, 8ULL))); - const uint64_t v_58 = seed.word(20); - row[layout.auxiliaries + 2] = v_58; - row[layout.selectors + 1] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_54(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 ? 96 : 472; - const Seed_ixvm_54 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_54(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_54(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_54<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_54<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_54(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 < 19 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 40) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 96 : encoding == 0 ? 472 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_54); -} - -__device__ __constant__ uint64_t inverse_55_0[] = {14347467609544676694ULL, 2305843008676823040ULL, 15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_55 { - 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 + 44); - case 2: return load_u8(data + 45); - case 3: return load_u8(data + 46); - case 4: return load_u8(data + 47); - case 5: return load_u8(data + 48); - case 6: return load_u8(data + 49); - case 7: return load_u8(data + 50); - case 8: return load_u8(data + 51); - case 9: return load_u8(data + 52); - case 10: return load_u8(data + 53); - case 11: return load_u8(data + 54); - case 12: return load_u8(data + 55); - case 13: return load_u8(data + 56); - case 14: return load_u8(data + 57); - case 15: return load_u8(data + 58); - case 16: return load_u8(data + 59); - case 17: return load_u8(data + 60); - case 18: return load_u32(data + 16); - case 19: return load_u64(data + 8); - case 20: return load_u32(data + 20); - case 21: return load_u8(data + 61); - case 22: return load_u8(data + 62); - case 23: return load_u8(data + 63); - case 24: return load_u8(data + 64); - case 25: return load_u8(data + 65); - case 26: return load_u8(data + 66); - case 27: return load_u8(data + 67); - case 28: return load_u8(data + 68); - case 29: return load_u8(data + 69); - case 30: return load_u8(data + 70); - case 31: return load_u8(data + 71); - case 32: return load_u8(data + 72); - case 33: return load_u8(data + 73); - case 34: return load_u8(data + 74); - case 35: return load_u8(data + 75); - case 36: return load_u8(data + 76); - case 37: return load_u32(data + 24); - case 38: return load_u8(data + 77); - case 39: return load_u8(data + 78); - case 40: return load_u8(data + 79); - case 41: return load_u8(data + 80); - case 42: return load_u8(data + 81); - case 43: return load_u8(data + 82); - case 44: return load_u8(data + 83); - case 45: return load_u8(data + 84); - case 46: return load_u8(data + 85); - case 47: return load_u8(data + 86); - case 48: return load_u8(data + 87); - case 49: return load_u8(data + 88); - case 50: return load_u8(data + 89); - case 51: return load_u8(data + 90); - case 52: return load_u8(data + 91); - case 53: return load_u8(data + 92); - case 54: return load_u8(data + 93); - case 55: return load_u32(data + 28); - case 56: return load_u32(data + 32); - case 57: return load_u32(data + 36); - case 58: return load_u32(data + 40); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_55(Seed_ixvm_55 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; - switch (v_0) { - case 9ULL: { - 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); - 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); - row[layout.auxiliaries + 1] = v_19; - row[layout.auxiliaries + 2] = v_20; - row[layout.auxiliaries + 3] = v_21; - row[layout.auxiliaries + 4] = v_22; - row[layout.auxiliaries + 5] = v_23; - row[layout.auxiliaries + 6] = v_24; - row[layout.auxiliaries + 7] = v_25; - row[layout.auxiliaries + 8] = v_26; - row[layout.auxiliaries + 9] = v_27; - row[layout.auxiliaries + 10] = v_28; - row[layout.auxiliaries + 11] = v_29; - row[layout.auxiliaries + 12] = v_30; - row[layout.auxiliaries + 13] = v_31; - row[layout.auxiliaries + 14] = v_32; - row[layout.auxiliaries + 15] = v_33; - row[layout.auxiliaries + 16] = v_34; - row[layout.auxiliaries + 17] = v_35; - row[layout.auxiliaries + 18] = v_36; - 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); - row[layout.auxiliaries + 19] = v_37; - row[layout.auxiliaries + 20] = v_38; - row[layout.auxiliaries + 21] = v_39; - row[layout.auxiliaries + 22] = v_40; - row[layout.auxiliaries + 23] = v_41; - row[layout.auxiliaries + 24] = v_42; - row[layout.auxiliaries + 25] = v_43; - row[layout.auxiliaries + 26] = v_44; - row[layout.auxiliaries + 27] = v_45; - row[layout.auxiliaries + 28] = v_46; - row[layout.auxiliaries + 29] = v_47; - row[layout.auxiliaries + 30] = v_48; - row[layout.auxiliaries + 31] = v_49; - row[layout.auxiliaries + 32] = v_50; - row[layout.auxiliaries + 33] = v_51; - row[layout.auxiliaries + 34] = v_52; - row[layout.auxiliaries + 35] = v_53; - row[layout.auxiliaries + 36] = v_54; - const uint64_t v_55 = seed.word(56); - row[layout.auxiliaries + 37] = v_55; - const uint64_t v_56 = seed.word(57); - row[layout.auxiliaries + 38] = v_56; - const uint64_t v_57 = seed.word(58); - row[layout.auxiliaries + 39] = v_57; - row[layout.selectors + 0] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 1] = (v_0 <= 9ULL ? inverse_55_0[v_0] : inverse(goldilocks_sub(v_0, 9ULL))); - const uint64_t v_58 = seed.word(20); - row[layout.auxiliaries + 2] = v_58; - row[layout.selectors + 1] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_55(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 ? 96 : 472; - const Seed_ixvm_55 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_55(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_55(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_55<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_55<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_55(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 < 19 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 40) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 96 : encoding == 0 ? 472 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_55); -} - -__device__ __constant__ uint64_t inverse_58_0[] = {18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_58 { - 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 + 264); - 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_u32(data + 268); - 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_u64(data + 152); - case 22: return load_u64(data + 160); - case 23: return load_u64(data + 168); - case 24: return load_u64(data + 176); - case 25: return load_u64(data + 184); - case 26: return load_u64(data + 192); - case 27: return load_u64(data + 200); - case 28: return load_u64(data + 208); - case 29: return load_u64(data + 216); - case 30: return load_u64(data + 224); - case 31: return load_u64(data + 232); - case 32: return load_u64(data + 240); - case 33: return load_u64(data + 248); - case 34: return load_u64(data + 256); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_58(Seed_ixvm_58 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; - switch (v_0) { - case 1ULL: { - 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); - const uint64_t v_17 = seed.word(18); - 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; - 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); - 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; - 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); - 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.selectors + 0] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 1] = (v_0 <= 1ULL ? inverse_58_0[v_0] : inverse(goldilocks_sub(v_0, 1ULL))); - row[layout.selectors + 1] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_58(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 : 280; - const Seed_ixvm_58 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_58(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_58(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_58<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_58<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_58(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 < 26) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 272 : encoding == 0 ? 280 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_58); -} - -__device__ __constant__ uint64_t inverse_59_0[] = {18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_59 { - 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 + 208); - 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_u32(data + 212); - 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_u64(data + 152); - case 22: return load_u64(data + 160); - case 23: return load_u64(data + 168); - case 24: return load_u64(data + 176); - case 25: return load_u64(data + 184); - case 26: return load_u64(data + 192); - case 27: return load_u64(data + 200); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_59(Seed_ixvm_59 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; - switch (v_0) { - case 1ULL: { - 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); - const uint64_t v_17 = seed.word(18); - 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; - 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 + 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.selectors + 0] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 1] = (v_0 <= 1ULL ? inverse_59_0[v_0] : inverse(goldilocks_sub(v_0, 1ULL))); - row[layout.selectors + 1] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_59(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 ? 216 : 224; - const Seed_ixvm_59 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_59(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_59(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_59<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_59<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_59(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 < 19) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 216 : encoding == 0 ? 224 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_59); -} - -template struct Seed_ixvm_60 { - 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 + 36); - case 2: return load_u8(data + 37); - case 3: return load_u8(data + 38); - case 4: return load_u8(data + 39); - case 5: return load_u8(data + 40); - case 6: return load_u8(data + 41); - case 7: return load_u8(data + 42); - case 8: return load_u8(data + 43); - case 9: return load_u8(data + 44); - case 10: return load_u64(data + 8); - case 11: return load_u32(data + 16); - case 12: return load_u8(data + 45); - case 13: return load_u8(data + 46); - case 14: return load_u8(data + 47); - case 15: return load_u8(data + 48); - case 16: return load_u8(data + 49); - case 17: return load_u8(data + 50); - case 18: return load_u8(data + 51); - case 19: return load_u8(data + 52); - case 20: return load_u8(data + 53); - case 21: return load_u8(data + 54); - case 22: return load_u8(data + 55); - case 23: return load_u8(data + 56); - case 24: return load_u8(data + 57); - case 25: return load_u8(data + 58); - case 26: return load_u8(data + 59); - case 27: return load_u8(data + 60); - case 28: return load_u32(data + 20); - case 29: return load_u32(data + 24); - case 30: return load_u32(data + 28); - case 31: return load_u32(data + 32); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_60(Seed_ixvm_60 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; - switch (v_0) { - case 0ULL: { - const uint64_t v_11 = seed.word(11); - row[layout.auxiliaries + 1] = v_11; - row[layout.selectors + 0] = 1; - return 0; - } - case 1ULL: { - const uint64_t v_12 = seed.word(11); - const uint64_t v_13 = seed.word(12); - 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); - row[layout.auxiliaries + 1] = v_12; - row[layout.auxiliaries + 2] = v_13; - row[layout.auxiliaries + 3] = v_14; - row[layout.auxiliaries + 4] = v_15; - row[layout.auxiliaries + 5] = v_16; - row[layout.auxiliaries + 6] = v_17; - row[layout.auxiliaries + 7] = v_18; - row[layout.auxiliaries + 8] = v_19; - 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); - const uint64_t v_24 = seed.word(23); - 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); - row[layout.auxiliaries + 9] = v_20; - row[layout.auxiliaries + 10] = v_21; - row[layout.auxiliaries + 11] = v_22; - row[layout.auxiliaries + 12] = v_23; - row[layout.auxiliaries + 13] = v_24; - row[layout.auxiliaries + 14] = v_25; - row[layout.auxiliaries + 15] = v_26; - row[layout.auxiliaries + 16] = v_27; - row[layout.auxiliaries + 17] = v_28; - const uint64_t v_30 = seed.word(28); - row[layout.auxiliaries + 18] = v_30; - const uint64_t v_31 = seed.word(29); - row[layout.auxiliaries + 19] = v_31; - row[layout.selectors + 1] = 1; - return 0; - } - case 2ULL: { - const uint64_t v_32 = seed.word(11); - const uint64_t v_33 = seed.word(12); - const uint64_t v_34 = seed.word(13); - const uint64_t v_35 = seed.word(14); - const uint64_t v_36 = seed.word(15); - const uint64_t v_37 = seed.word(16); - const uint64_t v_38 = seed.word(17); - const uint64_t v_39 = seed.word(18); - const uint64_t v_40 = seed.word(19); - row[layout.auxiliaries + 1] = v_32; - row[layout.auxiliaries + 2] = v_33; - row[layout.auxiliaries + 3] = v_34; - row[layout.auxiliaries + 4] = v_35; - row[layout.auxiliaries + 5] = v_36; - row[layout.auxiliaries + 6] = v_37; - row[layout.auxiliaries + 7] = v_38; - row[layout.auxiliaries + 8] = v_39; - row[layout.auxiliaries + 9] = v_40; - const uint64_t v_41 = seed.word(20); - const uint64_t v_42 = seed.word(21); - const uint64_t v_43 = seed.word(22); - const uint64_t v_44 = seed.word(23); - const uint64_t v_45 = seed.word(24); - const uint64_t v_46 = seed.word(25); - const uint64_t v_47 = seed.word(26); - const uint64_t v_48 = seed.word(27); - const uint64_t v_49 = seed.word(28); - row[layout.auxiliaries + 10] = v_41; - row[layout.auxiliaries + 11] = v_42; - row[layout.auxiliaries + 12] = v_43; - row[layout.auxiliaries + 13] = v_44; - row[layout.auxiliaries + 14] = v_45; - row[layout.auxiliaries + 15] = v_46; - row[layout.auxiliaries + 16] = v_47; - row[layout.auxiliaries + 17] = v_48; - row[layout.auxiliaries + 18] = v_49; - const uint64_t v_52 = seed.word(29); - row[layout.auxiliaries + 19] = v_52; - const uint64_t v_53 = seed.word(30); - row[layout.auxiliaries + 20] = v_53; - const uint64_t v_54 = seed.word(31); - row[layout.auxiliaries + 21] = v_54; - row[layout.selectors + 2] = 1; - return 0; - } - case 3ULL: { - const uint64_t v_55 = seed.word(11); - const uint64_t v_56 = seed.word(12); - const uint64_t v_57 = seed.word(13); - const uint64_t v_58 = seed.word(14); - const uint64_t v_59 = seed.word(15); - const uint64_t v_60 = seed.word(16); - const uint64_t v_61 = seed.word(17); - const uint64_t v_62 = seed.word(18); - const uint64_t v_63 = seed.word(19); - row[layout.auxiliaries + 1] = v_55; - row[layout.auxiliaries + 2] = v_56; - row[layout.auxiliaries + 3] = v_57; - row[layout.auxiliaries + 4] = v_58; - row[layout.auxiliaries + 5] = v_59; - row[layout.auxiliaries + 6] = v_60; - row[layout.auxiliaries + 7] = v_61; - row[layout.auxiliaries + 8] = v_62; - row[layout.auxiliaries + 9] = v_63; - const uint64_t v_64 = seed.word(20); - const uint64_t v_65 = seed.word(21); - const uint64_t v_66 = seed.word(22); - const uint64_t v_67 = seed.word(23); - const uint64_t v_68 = seed.word(24); - const uint64_t v_69 = seed.word(25); - const uint64_t v_70 = seed.word(26); - const uint64_t v_71 = seed.word(27); - const uint64_t v_72 = seed.word(28); - row[layout.auxiliaries + 10] = v_64; - row[layout.auxiliaries + 11] = v_65; - row[layout.auxiliaries + 12] = v_66; - row[layout.auxiliaries + 13] = v_67; - row[layout.auxiliaries + 14] = v_68; - row[layout.auxiliaries + 15] = v_69; - row[layout.auxiliaries + 16] = v_70; - row[layout.auxiliaries + 17] = v_71; - row[layout.auxiliaries + 18] = v_72; - const uint64_t v_75 = seed.word(29); - row[layout.auxiliaries + 19] = v_75; - const uint64_t v_76 = seed.word(30); - row[layout.auxiliaries + 20] = v_76; - const uint64_t v_77 = seed.word(31); - row[layout.auxiliaries + 21] = v_77; - row[layout.selectors + 3] = 1; - return 0; - } - case 4ULL: { - const uint64_t v_79 = seed.word(11); - row[layout.auxiliaries + 1] = v_79; - row[layout.selectors + 4] = 1; - return 0; - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_60(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 : 256; - const Seed_ixvm_60 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_60(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_60(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_60<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_60<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_60(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 < 5 || width < auxiliaries || width - auxiliaries < 22) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 64 : encoding == 0 ? 256 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_60); -} - -template struct Seed_ixvm_65 { - 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 + 48); - case 2: return load_u8(data + 49); - case 3: return load_u8(data + 50); - case 4: return load_u8(data + 51); - case 5: return load_u8(data + 52); - case 6: return load_u8(data + 53); - case 7: return load_u8(data + 54); - case 8: return load_u8(data + 55); - case 9: return load_u8(data + 56); - case 10: return load_u8(data + 57); - case 11: return load_u32(data + 16); - case 12: return load_u32(data + 20); - case 13: return load_u64(data + 8); - case 14: return load_u8(data + 58); - case 15: return load_u8(data + 59); - case 16: return load_u8(data + 60); - case 17: return load_u8(data + 61); - case 18: return load_u8(data + 62); - case 19: return load_u8(data + 63); - case 20: return load_u8(data + 64); - case 21: return load_u8(data + 65); - case 22: return load_u8(data + 66); - case 23: return load_u8(data + 67); - case 24: return load_u8(data + 68); - case 25: return load_u8(data + 69); - case 26: return load_u8(data + 70); - case 27: return load_u8(data + 71); - case 28: return load_u8(data + 72); - case 29: return load_u8(data + 73); - case 30: return load_u8(data + 74); - case 31: return load_u32(data + 24); - case 32: return load_u8(data + 75); - case 33: return load_u8(data + 76); - case 34: return load_u8(data + 77); - case 35: return load_u8(data + 78); - case 36: return load_u8(data + 79); - case 37: return load_u8(data + 80); - case 38: return load_u8(data + 81); - case 39: return load_u8(data + 82); - case 40: return load_u8(data + 83); - case 41: return load_u8(data + 84); - case 42: return load_u8(data + 85); - case 43: return load_u8(data + 86); - case 44: return load_u8(data + 87); - case 45: return load_u8(data + 88); - case 46: return load_u8(data + 89); - case 47: return load_u8(data + 90); - case 48: return load_u8(data + 91); - case 49: return load_u32(data + 28); - case 50: return load_u8(data + 92); - case 51: return load_u32(data + 32); - case 52: return load_u32(data + 36); - case 53: return load_u32(data + 40); - case 54: return load_u32(data + 44); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_65(Seed_ixvm_65 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; - switch (v_0) { - default: { - 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); - 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); - 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_13; - row[layout.auxiliaries + 2] = v_14; - row[layout.auxiliaries + 3] = v_15; - row[layout.auxiliaries + 4] = v_16; - row[layout.auxiliaries + 5] = v_17; - row[layout.auxiliaries + 6] = v_18; - row[layout.auxiliaries + 7] = v_19; - row[layout.auxiliaries + 8] = v_20; - row[layout.auxiliaries + 9] = v_21; - row[layout.auxiliaries + 10] = v_22; - row[layout.auxiliaries + 11] = v_23; - row[layout.auxiliaries + 12] = v_24; - row[layout.auxiliaries + 13] = v_25; - row[layout.auxiliaries + 14] = v_26; - row[layout.auxiliaries + 15] = v_27; - row[layout.auxiliaries + 16] = v_28; - row[layout.auxiliaries + 17] = v_29; - row[layout.auxiliaries + 18] = v_30; - 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); - row[layout.auxiliaries + 19] = v_31; - row[layout.auxiliaries + 20] = v_32; - row[layout.auxiliaries + 21] = v_33; - row[layout.auxiliaries + 22] = v_34; - row[layout.auxiliaries + 23] = v_35; - row[layout.auxiliaries + 24] = v_36; - row[layout.auxiliaries + 25] = v_37; - row[layout.auxiliaries + 26] = v_38; - row[layout.auxiliaries + 27] = v_39; - row[layout.auxiliaries + 28] = v_40; - row[layout.auxiliaries + 29] = v_41; - row[layout.auxiliaries + 30] = v_42; - row[layout.auxiliaries + 31] = v_43; - row[layout.auxiliaries + 32] = v_44; - row[layout.auxiliaries + 33] = v_45; - row[layout.auxiliaries + 34] = v_46; - row[layout.auxiliaries + 35] = v_47; - row[layout.auxiliaries + 36] = v_48; - const uint64_t v_49 = seed.word(50); - row[layout.auxiliaries + 37] = v_49; - const uint64_t v_51 = seed.word(51); - row[layout.auxiliaries + 38] = v_51; - const uint64_t v_52 = seed.word(52); - row[layout.auxiliaries + 39] = v_52; - const uint64_t v_53 = seed.word(53); - row[layout.auxiliaries + 40] = v_53; - const uint64_t v_54 = seed.word(54); - row[layout.auxiliaries + 41] = v_54; - row[layout.selectors + 0] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_65(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 ? 96 : 440; - const Seed_ixvm_65 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_65(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_65(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_65<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_65<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_65(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 < 1 || width < auxiliaries || width - auxiliaries < 42) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 96 : encoding == 0 ? 440 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_65); -} - -template struct Seed_ixvm_66 { - 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 + 32); - case 2: return load_u8(data + 33); - case 3: return load_u8(data + 34); - case 4: return load_u8(data + 35); - case 5: return load_u8(data + 36); - case 6: return load_u8(data + 37); - case 7: return load_u8(data + 38); - case 8: return load_u8(data + 39); - case 9: return load_u32(data + 16); - case 10: return load_u64(data + 8); - case 11: return load_u8(data + 40); - case 12: return load_u8(data + 41); - case 13: return load_u8(data + 42); - case 14: return load_u8(data + 43); - case 15: return load_u8(data + 44); - case 16: return load_u8(data + 45); - case 17: return load_u8(data + 46); - case 18: return load_u8(data + 47); - case 19: return load_u8(data + 48); - case 20: return load_u8(data + 49); - case 21: return load_u8(data + 50); - case 22: return load_u8(data + 51); - case 23: return load_u8(data + 52); - case 24: return load_u8(data + 53); - case 25: return load_u8(data + 54); - case 26: return load_u8(data + 55); - case 27: return load_u8(data + 56); - case 28: return load_u32(data + 20); - case 29: return load_u32(data + 24); - case 30: return load_u32(data + 28); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_66(Seed_ixvm_66 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; - switch (v_0) { - default: { - 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); - 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); - const uint64_t v_27 = seed.word(28); - row[layout.auxiliaries + 1] = v_10; - row[layout.auxiliaries + 2] = v_11; - row[layout.auxiliaries + 3] = v_12; - row[layout.auxiliaries + 4] = v_13; - row[layout.auxiliaries + 5] = v_14; - row[layout.auxiliaries + 6] = v_15; - row[layout.auxiliaries + 7] = v_16; - row[layout.auxiliaries + 8] = v_17; - row[layout.auxiliaries + 9] = v_18; - row[layout.auxiliaries + 10] = v_19; - row[layout.auxiliaries + 11] = v_20; - row[layout.auxiliaries + 12] = v_21; - row[layout.auxiliaries + 13] = v_22; - row[layout.auxiliaries + 14] = v_23; - row[layout.auxiliaries + 15] = v_24; - row[layout.auxiliaries + 16] = v_25; - row[layout.auxiliaries + 17] = v_26; - row[layout.auxiliaries + 18] = v_27; - const uint64_t v_28 = seed.word(29); - row[layout.auxiliaries + 19] = v_28; - const uint64_t v_29 = seed.word(30); - row[layout.auxiliaries + 20] = v_29; - row[layout.selectors + 0] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_66(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 : 248; - const Seed_ixvm_66 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_66(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_66(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_66<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_66<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_66(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 < 1 || width < auxiliaries || width - auxiliaries < 21) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 64 : encoding == 0 ? 248 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_66); -} - -template struct Seed_ixvm_69 { - 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 + 44); - case 3: return load_u8(data + 45); - case 4: return load_u8(data + 46); - case 5: return load_u8(data + 47); - case 6: return load_u8(data + 48); - case 7: return load_u8(data + 49); - case 8: return load_u8(data + 50); - case 9: return load_u8(data + 51); - case 10: return load_u32(data + 24); - case 11: return load_u64(data + 16); - case 12: return load_u8(data + 52); - case 13: return load_u8(data + 53); - case 14: return load_u8(data + 54); - case 15: return load_u8(data + 55); - case 16: return load_u8(data + 56); - case 17: return load_u8(data + 57); - case 18: return load_u8(data + 58); - case 19: return load_u8(data + 59); - case 20: return load_u8(data + 60); - case 21: return load_u8(data + 61); - case 22: return load_u8(data + 62); - case 23: return load_u8(data + 63); - case 24: return load_u8(data + 64); - case 25: return load_u8(data + 65); - case 26: return load_u8(data + 66); - case 27: return load_u8(data + 67); - case 28: return load_u8(data + 68); - case 29: return load_u32(data + 28); - case 30: return load_u32(data + 32); - case 31: return load_u32(data + 36); - case 32: return load_u32(data + 40); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_69(Seed_ixvm_69 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; - switch (v_0) { - default: { - 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); - 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); - const uint64_t v_27 = seed.word(28); - const uint64_t v_28 = seed.word(29); - row[layout.auxiliaries + 1] = v_11; - row[layout.auxiliaries + 2] = v_12; - row[layout.auxiliaries + 3] = v_13; - 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; - 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; - const uint64_t v_30 = seed.word(30); - row[layout.auxiliaries + 19] = v_30; - const uint64_t v_31 = seed.word(31); - row[layout.auxiliaries + 20] = v_31; - const uint64_t v_32 = seed.word(32); - row[layout.auxiliaries + 21] = v_32; - row[layout.selectors + 0] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_69(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 : 264; - const Seed_ixvm_69 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_69(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_69(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_69<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_69<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_69(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 < 11 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 22) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 72 : encoding == 0 ? 264 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_69); -} - -template struct Seed_ixvm_70 { - 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 + 36); - case 2: return load_u8(data + 37); - case 3: return load_u8(data + 38); - case 4: return load_u8(data + 39); - case 5: return load_u8(data + 40); - case 6: return load_u8(data + 41); - case 7: return load_u8(data + 42); - case 8: return load_u8(data + 43); - case 9: return load_u8(data + 44); - case 10: return load_u32(data + 16); - case 11: return load_u64(data + 8); - case 12: return load_u8(data + 45); - case 13: return load_u8(data + 46); - case 14: return load_u8(data + 47); - case 15: return load_u8(data + 48); - case 16: return load_u8(data + 49); - case 17: return load_u8(data + 50); - case 18: return load_u8(data + 51); - case 19: return load_u8(data + 52); - case 20: return load_u8(data + 53); - case 21: return load_u8(data + 54); - case 22: return load_u8(data + 55); - case 23: return load_u8(data + 56); - case 24: return load_u8(data + 57); - case 25: return load_u8(data + 58); - case 26: return load_u8(data + 59); - case 27: return load_u8(data + 60); - case 28: return load_u8(data + 61); - case 29: return load_u32(data + 20); - case 30: return load_u32(data + 24); - case 31: return load_u32(data + 28); - case 32: return load_u32(data + 32); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_70(Seed_ixvm_70 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; - switch (v_0) { - default: { - 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); - 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); - const uint64_t v_27 = seed.word(28); - const uint64_t v_28 = seed.word(29); - row[layout.auxiliaries + 1] = v_11; - row[layout.auxiliaries + 2] = v_12; - row[layout.auxiliaries + 3] = v_13; - 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; - 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; - const uint64_t v_29 = seed.word(30); - row[layout.auxiliaries + 19] = v_29; - const uint64_t v_30 = seed.word(31); - row[layout.auxiliaries + 20] = v_30; - const uint64_t v_31 = seed.word(32); - row[layout.auxiliaries + 21] = v_31; - row[layout.selectors + 0] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_70(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 : 264; - const Seed_ixvm_70 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_70(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_70(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_70<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_70<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_70(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 < 11 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 22) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 64 : encoding == 0 ? 264 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_70); -} - -template struct Seed_ixvm_71 { - 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 + 56); - case 3: return load_u8(data + 57); - case 4: return load_u8(data + 58); - case 5: return load_u8(data + 59); - case 6: return load_u8(data + 60); - case 7: return load_u8(data + 61); - case 8: return load_u8(data + 62); - case 9: return load_u8(data + 63); - case 10: return load_u8(data + 64); - case 11: return load_u8(data + 65); - case 12: return load_u8(data + 66); - case 13: return load_u8(data + 67); - case 14: return load_u8(data + 68); - case 15: return load_u8(data + 69); - case 16: return load_u8(data + 70); - case 17: return load_u8(data + 71); - case 18: return load_u8(data + 72); - case 19: return load_u8(data + 73); - case 20: return load_u8(data + 74); - case 21: return load_u8(data + 75); - case 22: return load_u8(data + 76); - case 23: return load_u8(data + 77); - case 24: return load_u8(data + 78); - case 25: return load_u8(data + 79); - case 26: return load_u8(data + 80); - case 27: return load_u8(data + 81); - case 28: return load_u8(data + 82); - case 29: return load_u8(data + 83); - case 30: return load_u8(data + 84); - case 31: return load_u8(data + 85); - case 32: return load_u8(data + 86); - case 33: return load_u8(data + 87); - case 34: return load_u32(data + 24); - case 35: return load_u64(data + 16); - case 36: return load_u8(data + 88); - case 37: return load_u8(data + 89); - case 38: return load_u8(data + 90); - case 39: return load_u8(data + 91); - case 40: return load_u8(data + 92); - case 41: return load_u8(data + 93); - case 42: return load_u8(data + 94); - case 43: return load_u8(data + 95); - case 44: return load_u8(data + 96); - case 45: return load_u8(data + 97); - case 46: return load_u8(data + 98); - case 47: return load_u8(data + 99); - case 48: return load_u8(data + 100); - case 49: return load_u8(data + 101); - case 50: return load_u8(data + 102); - case 51: return load_u8(data + 103); - case 52: return load_u8(data + 104); - case 53: return load_u32(data + 28); - case 54: return load_u32(data + 32); - case 55: return load_u32(data + 36); - case 56: return load_u32(data + 40); - case 57: return load_u32(data + 44); - case 58: return load_u32(data + 48); - case 59: return load_u32(data + 52); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_71(Seed_ixvm_71 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; - switch (v_0) { - default: { - 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); - row[layout.auxiliaries + 1] = v_35; - row[layout.auxiliaries + 2] = v_36; - row[layout.auxiliaries + 3] = v_37; - row[layout.auxiliaries + 4] = v_38; - row[layout.auxiliaries + 5] = v_39; - row[layout.auxiliaries + 6] = v_40; - row[layout.auxiliaries + 7] = v_41; - row[layout.auxiliaries + 8] = v_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; - const uint64_t v_54 = seed.word(54); - row[layout.auxiliaries + 19] = v_54; - const uint64_t v_55 = seed.word(55); - row[layout.auxiliaries + 20] = v_55; - const uint64_t v_56 = seed.word(56); - row[layout.auxiliaries + 21] = v_56; - const uint64_t v_57 = seed.word(57); - row[layout.auxiliaries + 22] = v_57; - const uint64_t v_58 = seed.word(58); - row[layout.auxiliaries + 23] = v_58; - const uint64_t v_59 = seed.word(59); - row[layout.auxiliaries + 24] = v_59; - row[layout.selectors + 0] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_71(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 : 480; - const Seed_ixvm_71 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_71(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_71(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_71<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_71<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_71(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 < 35 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 25) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 112 : encoding == 0 ? 480 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_71); -} - -template struct Seed_ixvm_72 { - 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 + 48); - case 4: return load_u64(data + 16); - case 5: return load_u8(data + 49); - case 6: return load_u8(data + 50); - case 7: return load_u8(data + 51); - case 8: return load_u8(data + 52); - case 9: return load_u8(data + 53); - case 10: return load_u8(data + 54); - case 11: return load_u8(data + 55); - case 12: return load_u8(data + 56); - case 13: return load_u8(data + 57); - case 14: return load_u8(data + 58); - case 15: return load_u8(data + 59); - case 16: return load_u8(data + 60); - case 17: return load_u8(data + 61); - case 18: return load_u8(data + 62); - case 19: return load_u8(data + 63); - case 20: return load_u8(data + 64); - case 21: return load_u8(data + 65); - case 22: return load_u8(data + 66); - case 23: return load_u8(data + 67); - case 24: return load_u8(data + 68); - case 25: return load_u8(data + 69); - case 26: return load_u8(data + 70); - case 27: return load_u8(data + 71); - case 28: return load_u8(data + 72); - case 29: return load_u8(data + 73); - case 30: return load_u8(data + 74); - case 31: return load_u8(data + 75); - case 32: return load_u8(data + 76); - case 33: return load_u8(data + 77); - case 34: return load_u8(data + 78); - case 35: return load_u8(data + 79); - case 36: return load_u8(data + 80); - case 37: return load_u32(data + 36); - case 38: return load_u32(data + 40); - case 39: return load_u64(data + 24); - case 40: return load_u32(data + 44); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_72(Seed_ixvm_72 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); - 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); - 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); - 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); - 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; - 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.auxiliaries + 13] = v_14; - row[layout.auxiliaries + 14] = v_15; - row[layout.auxiliaries + 15] = v_16; - row[layout.auxiliaries + 16] = v_17; - row[layout.auxiliaries + 17] = v_18; - row[layout.auxiliaries + 18] = v_19; - row[layout.auxiliaries + 19] = v_20; - row[layout.auxiliaries + 20] = v_21; - row[layout.auxiliaries + 21] = v_22; - row[layout.auxiliaries + 22] = v_23; - row[layout.auxiliaries + 23] = v_24; - row[layout.auxiliaries + 24] = v_25; - row[layout.auxiliaries + 25] = v_26; - row[layout.auxiliaries + 26] = v_27; - row[layout.auxiliaries + 27] = v_28; - row[layout.auxiliaries + 28] = v_29; - row[layout.auxiliaries + 29] = v_30; - row[layout.auxiliaries + 30] = v_31; - row[layout.auxiliaries + 31] = v_32; - row[layout.auxiliaries + 32] = v_33; - row[layout.auxiliaries + 33] = v_34; - row[layout.auxiliaries + 34] = v_35; - row[layout.auxiliaries + 35] = v_36; - row[layout.auxiliaries + 36] = v_37; - switch (v_2) { - case 1ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_38 = seed.word(39); - row[layout.auxiliaries + 37] = v_38; - const uint64_t v_39 = seed.word(40); - row[layout.auxiliaries + 38] = v_39; - row[layout.selectors + 1] = 1; - return 0; - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_72(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 : 328; - const Seed_ixvm_72 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_72(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_72(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_72<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_72<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_72(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 < 39) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 88 : encoding == 0 ? 328 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_72); -} - -template struct Seed_ixvm_73 { - 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 + 68); - case 3: return load_u8(data + 69); - case 4: return load_u8(data + 70); - case 5: return load_u8(data + 71); - case 6: return load_u8(data + 72); - case 7: return load_u8(data + 73); - case 8: return load_u8(data + 74); - case 9: return load_u8(data + 75); - case 10: return load_u8(data + 76); - case 11: return load_u8(data + 77); - case 12: return load_u8(data + 78); - case 13: return load_u8(data + 79); - case 14: return load_u8(data + 80); - case 15: return load_u8(data + 81); - case 16: return load_u8(data + 82); - case 17: return load_u8(data + 83); - case 18: return load_u8(data + 84); - case 19: return load_u8(data + 85); - case 20: return load_u8(data + 86); - case 21: return load_u8(data + 87); - case 22: return load_u8(data + 88); - case 23: return load_u8(data + 89); - case 24: return load_u8(data + 90); - case 25: return load_u8(data + 91); - case 26: return load_u32(data + 32); - case 27: return load_u32(data + 36); - case 28: return load_u64(data + 16); - case 29: return load_u8(data + 92); - case 30: return load_u8(data + 93); - case 31: return load_u8(data + 94); - case 32: return load_u8(data + 95); - case 33: return load_u8(data + 96); - case 34: return load_u8(data + 97); - case 35: return load_u8(data + 98); - case 36: return load_u8(data + 99); - case 37: return load_u8(data + 100); - case 38: return load_u8(data + 101); - case 39: return load_u8(data + 102); - case 40: return load_u8(data + 103); - case 41: return load_u8(data + 104); - case 42: return load_u8(data + 105); - case 43: return load_u8(data + 106); - case 44: return load_u8(data + 107); - case 45: return load_u8(data + 108); - case 46: return load_u32(data + 40); - case 47: return load_u8(data + 109); - case 48: return load_u8(data + 110); - case 49: return load_u8(data + 111); - case 50: return load_u8(data + 112); - case 51: return load_u8(data + 113); - case 52: return load_u8(data + 114); - case 53: return load_u8(data + 115); - case 54: return load_u8(data + 116); - case 55: return load_u64(data + 24); - case 56: return load_u32(data + 44); - case 57: return load_u32(data + 48); - case 58: return load_u32(data + 52); - case 59: return load_u32(data + 56); - case 60: return load_u32(data + 60); - case 61: return load_u32(data + 64); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_73(Seed_ixvm_73 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; - switch (v_0) { - default: { - 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); - row[layout.auxiliaries + 1] = v_28; - row[layout.auxiliaries + 2] = v_29; - row[layout.auxiliaries + 3] = v_30; - row[layout.auxiliaries + 4] = v_31; - row[layout.auxiliaries + 5] = v_32; - row[layout.auxiliaries + 6] = v_33; - row[layout.auxiliaries + 7] = v_34; - row[layout.auxiliaries + 8] = v_35; - row[layout.auxiliaries + 9] = v_36; - row[layout.auxiliaries + 10] = v_37; - row[layout.auxiliaries + 11] = v_38; - row[layout.auxiliaries + 12] = v_39; - row[layout.auxiliaries + 13] = v_40; - row[layout.auxiliaries + 14] = v_41; - row[layout.auxiliaries + 15] = v_42; - row[layout.auxiliaries + 16] = v_43; - row[layout.auxiliaries + 17] = v_44; - row[layout.auxiliaries + 18] = v_45; - 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); - row[layout.auxiliaries + 19] = v_46; - row[layout.auxiliaries + 20] = v_47; - row[layout.auxiliaries + 21] = v_48; - row[layout.auxiliaries + 22] = v_49; - row[layout.auxiliaries + 23] = v_50; - row[layout.auxiliaries + 24] = v_51; - row[layout.auxiliaries + 25] = v_52; - row[layout.auxiliaries + 26] = v_53; - const uint64_t v_55 = seed.word(55); - row[layout.auxiliaries + 27] = v_55; - const uint64_t v_56 = seed.word(56); - row[layout.auxiliaries + 28] = v_56; - const uint64_t v_57 = seed.word(57); - row[layout.auxiliaries + 29] = v_57; - const uint64_t v_58 = seed.word(58); - row[layout.auxiliaries + 30] = v_58; - const uint64_t v_59 = seed.word(59); - row[layout.auxiliaries + 31] = v_59; - const uint64_t v_60 = seed.word(60); - row[layout.auxiliaries + 32] = v_60; - const uint64_t v_61 = seed.word(61); - row[layout.auxiliaries + 33] = v_61; - row[layout.selectors + 0] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_73(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 : 496; - const Seed_ixvm_73 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_73(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_73(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_73<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_73<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_73(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 < 28 || auxiliaries < selectors || auxiliaries - selectors < 1 || width < auxiliaries || width - auxiliaries < 34) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 120 : encoding == 0 ? 496 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_73); -} - -template struct Seed_ixvm_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_u8(data + 32); - case 2: return load_u8(data + 33); - case 3: return load_u8(data + 34); - case 4: return load_u8(data + 35); - case 5: return load_u8(data + 36); - case 6: return load_u8(data + 37); - case 7: return load_u8(data + 38); - case 8: return load_u8(data + 39); - case 9: return load_u8(data + 40); - case 10: return load_u8(data + 41); - case 11: return load_u8(data + 42); - case 12: return load_u8(data + 43); - case 13: return load_u8(data + 44); - case 14: return load_u8(data + 45); - case 15: return load_u8(data + 46); - case 16: return load_u8(data + 47); - case 17: return load_u8(data + 48); - case 18: return load_u8(data + 49); - case 19: return load_u8(data + 50); - case 20: return load_u8(data + 51); - case 21: return load_u8(data + 52); - case 22: return load_u8(data + 53); - case 23: return load_u8(data + 54); - case 24: return load_u8(data + 55); - case 25: return load_u8(data + 56); - case 26: return load_u8(data + 57); - case 27: return load_u8(data + 58); - case 28: return load_u8(data + 59); - case 29: return load_u8(data + 60); - case 30: return load_u8(data + 61); - case 31: return load_u8(data + 62); - case 32: return load_u8(data + 63); - case 33: return load_u8(data + 64); - case 34: return load_u8(data + 65); - case 35: return load_u8(data + 66); - case 36: return load_u8(data + 67); - case 37: return load_u8(data + 68); - case 38: return load_u8(data + 69); - case 39: return load_u8(data + 70); - case 40: return load_u8(data + 71); - case 41: return load_u8(data + 72); - case 42: return load_u8(data + 73); - case 43: return load_u8(data + 74); - case 44: return load_u32(data + 16); - case 45: return load_u32(data + 20); - case 46: return load_u64(data + 8); - case 47: return load_u32(data + 24); - case 48: return load_u32(data + 28); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_76(Seed_ixvm_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); - 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; - switch (v_0) { - case 0ULL: { - const uint64_t v_47 = seed.word(47); - row[layout.auxiliaries + 1] = v_47; - const uint64_t v_48 = seed.word(48); - row[layout.auxiliaries + 2] = v_48; - row[layout.selectors + 0] = 1; - return 0; - } - case 1ULL: { - const uint64_t v_51 = seed.word(47); - row[layout.auxiliaries + 1] = v_51; - const uint64_t v_52 = seed.word(48); - row[layout.auxiliaries + 2] = v_52; - row[layout.selectors + 1] = 1; - return 0; - } - case 2ULL: { - const uint64_t v_55 = seed.word(47); - row[layout.auxiliaries + 1] = v_55; - const uint64_t v_56 = seed.word(48); - row[layout.auxiliaries + 2] = v_56; - row[layout.selectors + 2] = 1; - return 0; - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_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 ? 80 : 392; - const Seed_ixvm_76 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_76(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_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_ixvm_76<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_76<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_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 < 46 || auxiliaries < selectors || auxiliaries - selectors < 3 || width < auxiliaries || width - auxiliaries < 3) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 80 : encoding == 0 ? 392 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_76); -} - -template struct Seed_ixvm_77 { - 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 + 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_u8(data + 54); - case 14: return load_u8(data + 55); - case 15: return load_u8(data + 56); - case 16: return load_u8(data + 57); - case 17: return load_u8(data + 58); - case 18: return load_u8(data + 59); - case 19: return load_u8(data + 60); - case 20: return load_u8(data + 61); - case 21: return load_u8(data + 62); - case 22: return load_u8(data + 63); - case 23: return load_u8(data + 64); - case 24: return load_u8(data + 65); - case 25: return load_u8(data + 66); - case 26: return load_u8(data + 67); - case 27: return load_u8(data + 68); - case 28: return load_u8(data + 69); - case 29: return load_u8(data + 70); - case 30: return load_u8(data + 71); - case 31: return load_u8(data + 72); - case 32: return load_u8(data + 73); - case 33: return load_u8(data + 74); - case 34: return load_u8(data + 75); - case 35: return load_u8(data + 76); - case 36: return load_u8(data + 77); - case 37: return load_u8(data + 78); - case 38: return load_u8(data + 79); - case 39: return load_u8(data + 80); - case 40: return load_u8(data + 81); - case 41: return load_u8(data + 82); - case 42: return load_u8(data + 83); - case 43: return load_u8(data + 84); - case 44: return load_u8(data + 85); - case 45: return load_u8(data + 86); - case 46: return load_u8(data + 87); - case 47: return load_u32(data + 28); - case 48: return load_u32(data + 32); - case 49: return load_u32(data + 36); - case 50: return load_u64(data + 16); - case 51: return load_u32(data + 40); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_77(Seed_ixvm_77 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); - 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); - 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); - 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); - 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; - 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.auxiliaries + 13] = v_14; - row[layout.auxiliaries + 14] = v_15; - row[layout.auxiliaries + 15] = v_16; - row[layout.auxiliaries + 16] = v_17; - row[layout.auxiliaries + 17] = v_18; - row[layout.auxiliaries + 18] = v_19; - row[layout.auxiliaries + 19] = v_20; - row[layout.auxiliaries + 20] = v_21; - row[layout.auxiliaries + 21] = v_22; - row[layout.auxiliaries + 22] = v_23; - row[layout.auxiliaries + 23] = v_24; - row[layout.auxiliaries + 24] = v_25; - row[layout.auxiliaries + 25] = v_26; - row[layout.auxiliaries + 26] = v_27; - row[layout.auxiliaries + 27] = v_28; - row[layout.auxiliaries + 28] = v_29; - row[layout.auxiliaries + 29] = v_30; - row[layout.auxiliaries + 30] = v_31; - row[layout.auxiliaries + 31] = v_32; - row[layout.auxiliaries + 32] = v_33; - row[layout.auxiliaries + 33] = v_34; - row[layout.auxiliaries + 34] = v_35; - row[layout.auxiliaries + 35] = v_36; - row[layout.auxiliaries + 36] = v_37; - row[layout.auxiliaries + 37] = v_38; - row[layout.auxiliaries + 38] = v_39; - row[layout.auxiliaries + 39] = v_40; - row[layout.auxiliaries + 40] = v_41; - row[layout.auxiliaries + 41] = v_42; - row[layout.auxiliaries + 42] = v_43; - row[layout.auxiliaries + 43] = v_44; - row[layout.auxiliaries + 44] = v_45; - row[layout.auxiliaries + 45] = v_46; - row[layout.auxiliaries + 46] = v_47; - row[layout.auxiliaries + 47] = v_48; - switch (v_2) { - case 1ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_49 = seed.word(50); - row[layout.auxiliaries + 48] = v_49; - const uint64_t v_50 = seed.word(51); - row[layout.auxiliaries + 49] = v_50; - row[layout.selectors + 1] = 1; - return 0; - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_77(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 : 416; - const Seed_ixvm_77 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_77(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_77(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_77<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_77<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_77(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 < 50) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 88 : encoding == 0 ? 416 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_77); -} - -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 + 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_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: { - row[layout.selectors + 0] = 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 ? 32 : 40; - 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 < 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_83); -} - -__device__ __constant__ uint64_t inverse_84_0[] = {0ULL}; -template struct Seed_ixvm_84 { - 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_84(Seed_ixvm_84 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_84_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_84(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_84 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_84(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_84(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_84<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_84<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_84(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_84); -} - -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_u32(data + 24); - case 2: return load_u8(data + 32); - case 3: return load_u8(data + 33); - case 4: return load_u32(data + 28); - case 5: return load_u8(data + 34); - case 6: return load_u64(data + 8); - case 7: return load_u8(data + 35); - case 8: return load_u8(data + 36); - case 9: return load_u8(data + 37); - case 10: return load_u8(data + 38); - case 11: return load_u8(data + 39); - case 12: return load_u8(data + 40); - case 13: return load_u64(data + 16); - 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); - 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; - switch (v_7) { - case 0ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - case 1ULL: { - const uint64_t v_27 = seed.word(5); - const uint64_t v_28 = seed.word(6); - const uint64_t v_29 = seed.word(7); - const uint64_t v_30 = seed.word(8); - const uint64_t v_31 = seed.word(9); - const uint64_t v_32 = seed.word(10); - const uint64_t v_33 = seed.word(11); - const uint64_t v_34 = seed.word(12); - const uint64_t v_35 = seed.word(13); - row[layout.auxiliaries + 12] = v_27; - 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.selectors + 1] = 1; - return 0; - } - default: { - return 2; - } - } - } - 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 ? 48 : 112; - 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 < 1 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 21) 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_85); -} - -template struct Seed_ixvm_87 { - 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 + 32); - case 3: return load_u8(data + 33); - case 4: return load_u32(data + 28); - case 5: return load_u8(data + 34); - case 6: return load_u64(data + 8); - case 7: return load_u8(data + 35); - case 8: return load_u8(data + 36); - case 9: return load_u8(data + 37); - case 10: return load_u8(data + 38); - case 11: return load_u8(data + 39); - case 12: return load_u8(data + 40); - case 13: return load_u64(data + 16); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_87(Seed_ixvm_87 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 = 128ULL; - if (v_2 > 255 || v_4 > 255) return 1; - const uint64_t v_5 = uint64_t(v_2 < v_4); - row[layout.auxiliaries + 4] = v_5; - switch (v_5) { - case 1ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_10 = seed.word(5); - const uint64_t v_11 = seed.word(6); - const uint64_t v_12 = seed.word(7); - const uint64_t v_13 = seed.word(8); - const uint64_t v_14 = seed.word(9); - const uint64_t v_15 = seed.word(10); - const uint64_t v_16 = seed.word(11); - const uint64_t v_17 = seed.word(12); - const uint64_t v_18 = seed.word(13); - 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; - row[layout.auxiliaries + 12] = v_17; - row[layout.auxiliaries + 13] = v_18; - row[layout.selectors + 1] = 1; - return 0; - } - default: { - return 2; - } - } - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_87(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_87 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_87(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_87(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_87<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_87<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_87(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 < 14) 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_87); -} - -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_u8(data + 28); - case 2: return load_u8(data + 29); - case 3: return load_u32(data + 24); - case 4: return load_u8(data + 30); - case 5: return load_u8(data + 31); - case 6: return load_u64(data + 8); - case 7: return load_u8(data + 32); - case 8: return load_u8(data + 33); - case 9: return load_u8(data + 34); - case 10: return load_u8(data + 35); - case 11: return load_u8(data + 36); - case 12: return load_u64(data + 16); - 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); - row[1] = v_1; - const uint64_t v_2 = seed.word(3); - row[2] = v_2; - if (v_0 > 255 || v_1 > 255) return 1; - const uint64_t v_3 = uint64_t(v_0 < v_1); - row[layout.auxiliaries + 1] = v_3; - switch (v_3) { - case 1ULL: { - const uint64_t v_4 = seed.word(4); - const uint64_t v_5 = seed.word(5); - const uint64_t v_6 = seed.word(6); - row[layout.auxiliaries + 2] = v_4; - row[layout.auxiliaries + 3] = v_5; - row[layout.auxiliaries + 4] = v_6; - switch (v_4) { - case 0ULL: { - const uint64_t v_7 = 2ULL; - const uint64_t v_8 = goldilocks_mul(v_7, v_1); - if (v_5 > 255 || v_8 > 255) return 1; - const uint64_t v_9 = ((v_5 + v_8) & 255ULL); - const uint64_t v_10 = ((v_5 + v_8) >> 8); - row[layout.auxiliaries + 5] = v_9; - row[layout.selectors + 0] = 1; - return 0; - } - default: { - return 2; - } - } - } - case 0ULL: { - const uint64_t v_14 = seed.word(4); - const uint64_t v_15 = seed.word(5); - const uint64_t v_16 = seed.word(6); - const uint64_t v_17 = seed.word(7); - const uint64_t v_18 = seed.word(8); - const uint64_t v_19 = seed.word(9); - const uint64_t v_20 = seed.word(10); - const uint64_t v_21 = seed.word(11); - const uint64_t v_22 = seed.word(12); - row[layout.auxiliaries + 2] = v_14; - row[layout.auxiliaries + 3] = v_15; - row[layout.auxiliaries + 4] = v_16; - row[layout.auxiliaries + 5] = v_17; - row[layout.auxiliaries + 6] = v_18; - row[layout.auxiliaries + 7] = v_19; - row[layout.auxiliaries + 8] = v_20; - row[layout.auxiliaries + 9] = v_21; - row[layout.auxiliaries + 10] = v_22; - row[layout.selectors + 1] = 1; - return 0; - } - default: { - return 2; - } - } -} -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 ? 40 : 104; - 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 < 3 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 11) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 40 : encoding == 0 ? 104 : 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_u8(data + 20); - case 2: return load_u8(data + 21); - case 3: return load_u32(data + 16); - case 4: return load_u8(data + 22); - case 5: return load_u8(data + 23); - case 6: return load_u8(data + 24); - case 7: return load_u8(data + 25); - case 8: return load_u8(data + 26); - case 9: return load_u8(data + 27); - case 10: return load_u8(data + 28); - case 11: return load_u8(data + 29); - case 12: return load_u64(data + 8); - case 13: return load_u8(data + 30); - case 14: return load_u8(data + 31); - case 15: return load_u8(data + 32); - case 16: return load_u8(data + 33); - case 17: return load_u8(data + 34); - case 18: return load_u8(data + 35); - case 19: return load_u8(data + 36); - case 20: return load_u8(data + 37); - case 21: return load_u8(data + 38); - 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); - row[1] = v_1; - const uint64_t v_2 = seed.word(3); - row[2] = v_2; - switch (v_0) { - case 0ULL: { - 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 + 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; - const uint64_t v_16 = seed.word(13); - const uint64_t v_17 = seed.word(14); - const uint64_t v_18 = seed.word(15); - const uint64_t v_19 = seed.word(16); - const uint64_t v_20 = seed.word(17); - const uint64_t v_21 = seed.word(18); - const uint64_t v_22 = seed.word(19); - const uint64_t v_23 = seed.word(20); - const uint64_t v_24 = seed.word(21); - row[layout.auxiliaries + 10] = v_16; - row[layout.auxiliaries + 11] = v_17; - row[layout.auxiliaries + 12] = v_18; - row[layout.auxiliaries + 13] = v_19; - row[layout.auxiliaries + 14] = v_20; - row[layout.auxiliaries + 15] = v_21; - row[layout.auxiliaries + 16] = v_22; - row[layout.auxiliaries + 17] = v_23; - row[layout.auxiliaries + 18] = v_24; - row[layout.selectors + 0] = 1; - return 0; - } - case 1ULL: { - const uint64_t v_26 = seed.word(4); - const uint64_t v_27 = seed.word(5); - const uint64_t v_28 = seed.word(6); - const uint64_t v_29 = seed.word(7); - const uint64_t v_30 = seed.word(8); - const uint64_t v_31 = seed.word(9); - const uint64_t v_32 = seed.word(10); - const uint64_t v_33 = seed.word(11); - const uint64_t v_34 = seed.word(12); - row[layout.auxiliaries + 1] = v_26; - row[layout.auxiliaries + 2] = v_27; - row[layout.auxiliaries + 3] = v_28; - row[layout.auxiliaries + 4] = v_29; - row[layout.auxiliaries + 5] = v_30; - row[layout.auxiliaries + 6] = v_31; - row[layout.auxiliaries + 7] = v_32; - row[layout.auxiliaries + 8] = v_33; - row[layout.auxiliaries + 9] = v_34; - const uint64_t v_37 = seed.word(13); - const uint64_t v_38 = seed.word(14); - const uint64_t v_39 = seed.word(15); - const uint64_t v_40 = seed.word(16); - const uint64_t v_41 = seed.word(17); - const uint64_t v_42 = seed.word(18); - const uint64_t v_43 = seed.word(19); - const uint64_t v_44 = seed.word(20); - const uint64_t v_45 = seed.word(21); - row[layout.auxiliaries + 10] = v_37; - row[layout.auxiliaries + 11] = v_38; - row[layout.auxiliaries + 12] = v_39; - row[layout.auxiliaries + 13] = v_40; - row[layout.auxiliaries + 14] = v_41; - row[layout.auxiliaries + 15] = v_42; - row[layout.auxiliaries + 16] = v_43; - row[layout.auxiliaries + 17] = v_44; - row[layout.auxiliaries + 18] = v_45; - row[layout.selectors + 1] = 1; - return 0; - } - case 2ULL: { - const uint64_t v_47 = seed.word(4); - const uint64_t v_48 = seed.word(5); - const uint64_t v_49 = seed.word(6); - const uint64_t v_50 = seed.word(7); - const uint64_t v_51 = seed.word(8); - const uint64_t v_52 = seed.word(9); - const uint64_t v_53 = seed.word(10); - const uint64_t v_54 = seed.word(11); - const uint64_t v_55 = seed.word(12); - row[layout.auxiliaries + 1] = v_47; - row[layout.auxiliaries + 2] = v_48; - row[layout.auxiliaries + 3] = v_49; - row[layout.auxiliaries + 4] = v_50; - row[layout.auxiliaries + 5] = v_51; - row[layout.auxiliaries + 6] = v_52; - row[layout.auxiliaries + 7] = v_53; - row[layout.auxiliaries + 8] = v_54; - row[layout.auxiliaries + 9] = v_55; - const uint64_t v_58 = seed.word(13); - const uint64_t v_59 = seed.word(14); - const uint64_t v_60 = seed.word(15); - const uint64_t v_61 = seed.word(16); - const uint64_t v_62 = seed.word(17); - const uint64_t v_63 = seed.word(18); - const uint64_t v_64 = seed.word(19); - const uint64_t v_65 = seed.word(20); - const uint64_t v_66 = seed.word(21); - row[layout.auxiliaries + 10] = v_58; - row[layout.auxiliaries + 11] = v_59; - row[layout.auxiliaries + 12] = v_60; - row[layout.auxiliaries + 13] = v_61; - row[layout.auxiliaries + 14] = v_62; - row[layout.auxiliaries + 15] = v_63; - row[layout.auxiliaries + 16] = v_64; - row[layout.auxiliaries + 17] = v_65; - row[layout.auxiliaries + 18] = v_66; - row[layout.selectors + 2] = 1; - return 0; - } - case 3ULL: { - const uint64_t v_68 = seed.word(4); - const uint64_t v_69 = seed.word(5); - const uint64_t v_70 = seed.word(6); - const uint64_t v_71 = seed.word(7); - const uint64_t v_72 = seed.word(8); - const uint64_t v_73 = seed.word(9); - const uint64_t v_74 = seed.word(10); - const uint64_t v_75 = seed.word(11); - const uint64_t v_76 = seed.word(12); - row[layout.auxiliaries + 1] = v_68; - row[layout.auxiliaries + 2] = v_69; - row[layout.auxiliaries + 3] = v_70; - row[layout.auxiliaries + 4] = v_71; - row[layout.auxiliaries + 5] = v_72; - row[layout.auxiliaries + 6] = v_73; - row[layout.auxiliaries + 7] = v_74; - row[layout.auxiliaries + 8] = v_75; - row[layout.auxiliaries + 9] = v_76; - const uint64_t v_79 = seed.word(13); - const uint64_t v_80 = seed.word(14); - const uint64_t v_81 = seed.word(15); - const uint64_t v_82 = seed.word(16); - const uint64_t v_83 = seed.word(17); - const uint64_t v_84 = seed.word(18); - const uint64_t v_85 = seed.word(19); - const uint64_t v_86 = seed.word(20); - const uint64_t v_87 = seed.word(21); - row[layout.auxiliaries + 10] = v_79; - row[layout.auxiliaries + 11] = v_80; - row[layout.auxiliaries + 12] = v_81; - row[layout.auxiliaries + 13] = v_82; - row[layout.auxiliaries + 14] = v_83; - row[layout.auxiliaries + 15] = v_84; - row[layout.auxiliaries + 16] = v_85; - row[layout.auxiliaries + 17] = v_86; - row[layout.auxiliaries + 18] = v_87; - row[layout.selectors + 3] = 1; - return 0; - } - default: { - return 2; - } - } -} -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 ? 40 : 176; - 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 < 3 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 19) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 40 : encoding == 0 ? 176 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_89); -} - -template struct Seed_ixvm_91 { - 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_91(Seed_ixvm_91 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_91(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_91 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_91(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_91(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_91<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_91<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_91(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_91); -} - -template struct Seed_ixvm_94 { - 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_94(Seed_ixvm_94 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_94(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_94 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_94(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_94(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_94<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_94<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_94(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_94); -} - -template struct Seed_ixvm_95 { - 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_95(Seed_ixvm_95 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_95(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_95 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_95(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_95(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_95<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_95<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_95(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_95); -} - -__device__ __constant__ uint64_t inverse_98_0[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_98 { - 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_u8(data + 140); - case 3: return load_u8(data + 141); - case 4: return load_u64(data + 8); - case 5: return load_u8(data + 142); - case 6: return load_u8(data + 143); - case 7: return load_u8(data + 144); - case 8: return load_u8(data + 145); - case 9: return load_u8(data + 146); - case 10: return load_u8(data + 147); - case 11: return load_u32(data + 132); - case 12: return load_u64(data + 16); - case 13: return load_u64(data + 24); - case 14: return load_u64(data + 32); - case 15: return load_u8(data + 148); - case 16: return load_u64(data + 40); - case 17: return load_u64(data + 48); - case 18: return load_u8(data + 149); - case 19: return load_u64(data + 56); - case 20: return load_u64(data + 64); - 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_u32(data + 136); - case 25: return load_u64(data + 96); - case 26: return load_u8(data + 150); - case 27: return load_u8(data + 151); - case 28: return load_u8(data + 152); - case 29: return load_u8(data + 153); - case 30: return load_u8(data + 154); - case 31: return load_u8(data + 155); - case 32: return load_u64(data + 104); - case 33: return load_u64(data + 112); - case 34: return load_u64(data + 120); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_98(Seed_ixvm_98 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_98_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_98(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 ? 160 : 280; - const Seed_ixvm_98 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_98(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_98(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_98<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_98<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_98(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 ? 160 : encoding == 0 ? 280 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_98); -} - -template struct Seed_ixvm_103 { - 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_103(Seed_ixvm_103 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_103(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_103 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_103(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_103(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_103<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_103<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_103(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_103); -} - -template struct Seed_ixvm_125 { - 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 + 164); - case 2: return load_u32(data + 152); - case 3: return load_u64(data + 8); - case 4: return load_u64(data + 16); - case 5: return load_u64(data + 24); - case 6: return load_u64(data + 32); - case 7: return load_u8(data + 165); - case 8: return load_u8(data + 166); - case 9: return load_u8(data + 167); - case 10: return load_u8(data + 168); - case 11: return load_u64(data + 40); - case 12: return load_u64(data + 48); - case 13: return load_u64(data + 56); - case 14: return load_u64(data + 64); - case 15: return load_u64(data + 72); - case 16: return load_u8(data + 169); - case 17: return load_u8(data + 170); - case 18: return load_u8(data + 171); - case 19: return load_u32(data + 156); - 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_u8(data + 172); - case 24: return load_u8(data + 173); - case 25: return load_u8(data + 174); - case 26: return load_u8(data + 175); - case 27: return load_u8(data + 176); - case 28: return load_u8(data + 177); - case 29: return load_u64(data + 104); - case 30: return load_u64(data + 112); - 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_u64(data + 120); - case 38: return load_u64(data + 128); - case 39: return load_u8(data + 184); - case 40: return load_u8(data + 185); - case 41: return load_u8(data + 186); - case 42: return load_u8(data + 187); - case 43: return load_u8(data + 188); - case 44: return load_u8(data + 189); - case 45: return load_u64(data + 136); - case 46: return load_u32(data + 160); - case 47: return load_u64(data + 144); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_125(Seed_ixvm_125 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_0) { - case 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); - 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); - 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; - 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.auxiliaries + 13] = v_14; - row[layout.selectors + 0] = 1; - return 0; - } - case 1ULL: { - const uint64_t v_16 = seed.word(3); - const uint64_t v_17 = seed.word(4); - const uint64_t v_18 = seed.word(5); - const uint64_t v_19 = seed.word(6); - const uint64_t v_20 = seed.word(7); - const uint64_t v_21 = seed.word(8); - const uint64_t v_22 = seed.word(9); - const uint64_t v_23 = seed.word(10); - const uint64_t v_24 = seed.word(11); - const uint64_t v_25 = seed.word(12); - const uint64_t v_26 = seed.word(13); - const uint64_t v_27 = seed.word(14); - const uint64_t v_28 = seed.word(15); - const uint64_t v_29 = seed.word(16); - const uint64_t v_30 = seed.word(17); - const uint64_t v_31 = seed.word(18); - const uint64_t v_32 = seed.word(19); - const uint64_t v_33 = seed.word(20); - const uint64_t v_34 = seed.word(21); - const uint64_t v_35 = seed.word(22); - const uint64_t v_36 = seed.word(23); - const uint64_t v_37 = seed.word(24); - const uint64_t v_38 = seed.word(25); - const uint64_t v_39 = seed.word(26); - const uint64_t v_40 = seed.word(27); - const uint64_t v_41 = seed.word(28); - const uint64_t v_42 = seed.word(29); - const uint64_t v_43 = seed.word(30); - const uint64_t v_44 = seed.word(31); - const uint64_t v_45 = seed.word(32); - const uint64_t v_46 = seed.word(33); - const uint64_t v_47 = seed.word(34); - const uint64_t v_48 = seed.word(35); - const uint64_t v_49 = seed.word(36); - const uint64_t v_50 = seed.word(37); - const uint64_t v_51 = seed.word(38); - const uint64_t v_52 = seed.word(39); - const uint64_t v_53 = seed.word(40); - const uint64_t v_54 = seed.word(41); - const uint64_t v_55 = seed.word(42); - const uint64_t v_56 = seed.word(43); - const uint64_t v_57 = seed.word(44); - const uint64_t v_58 = seed.word(45); - const uint64_t v_59 = seed.word(46); - const uint64_t v_60 = seed.word(47); - row[layout.auxiliaries + 1] = v_16; - row[layout.auxiliaries + 2] = v_17; - row[layout.auxiliaries + 3] = v_18; - row[layout.auxiliaries + 4] = v_19; - row[layout.auxiliaries + 5] = v_20; - row[layout.auxiliaries + 6] = v_21; - row[layout.auxiliaries + 7] = v_22; - row[layout.auxiliaries + 8] = v_23; - row[layout.auxiliaries + 9] = v_24; - row[layout.auxiliaries + 10] = v_25; - row[layout.auxiliaries + 11] = v_26; - row[layout.auxiliaries + 12] = v_27; - 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; - row[layout.auxiliaries + 22] = v_37; - row[layout.auxiliaries + 23] = v_38; - row[layout.auxiliaries + 24] = v_39; - row[layout.auxiliaries + 25] = v_40; - row[layout.auxiliaries + 26] = v_41; - row[layout.auxiliaries + 27] = v_42; - row[layout.auxiliaries + 28] = v_43; - row[layout.auxiliaries + 29] = v_44; - row[layout.auxiliaries + 30] = v_45; - row[layout.auxiliaries + 31] = v_46; - row[layout.auxiliaries + 32] = v_47; - row[layout.auxiliaries + 33] = v_48; - row[layout.auxiliaries + 34] = v_49; - row[layout.auxiliaries + 35] = v_50; - row[layout.auxiliaries + 36] = v_51; - row[layout.auxiliaries + 37] = v_52; - row[layout.auxiliaries + 38] = v_53; - row[layout.auxiliaries + 39] = v_54; - row[layout.auxiliaries + 40] = v_55; - row[layout.auxiliaries + 41] = v_56; - row[layout.auxiliaries + 42] = v_57; - row[layout.auxiliaries + 43] = v_58; - row[layout.auxiliaries + 44] = v_59; - row[layout.auxiliaries + 45] = v_60; - row[layout.selectors + 1] = 1; - return 0; - } - case 2ULL: { - const uint64_t v_62 = seed.word(3); - const uint64_t v_63 = seed.word(4); - const uint64_t v_64 = seed.word(5); - const uint64_t v_65 = seed.word(6); - const uint64_t v_66 = seed.word(7); - const uint64_t v_67 = seed.word(8); - const uint64_t v_68 = seed.word(9); - const uint64_t v_69 = seed.word(10); - const uint64_t v_70 = seed.word(11); - const uint64_t v_71 = seed.word(12); - const uint64_t v_72 = seed.word(13); - row[layout.auxiliaries + 1] = v_62; - row[layout.auxiliaries + 2] = v_63; - row[layout.auxiliaries + 3] = v_64; - row[layout.auxiliaries + 4] = v_65; - row[layout.auxiliaries + 5] = v_66; - row[layout.auxiliaries + 6] = v_67; - row[layout.auxiliaries + 7] = v_68; - row[layout.auxiliaries + 8] = v_69; - row[layout.auxiliaries + 9] = v_70; - row[layout.auxiliaries + 10] = v_71; - row[layout.auxiliaries + 11] = v_72; - row[layout.selectors + 2] = 1; - return 0; - } - case 3ULL: { - const uint64_t v_75 = seed.word(3); - const uint64_t v_76 = seed.word(4); - const uint64_t v_77 = seed.word(5); - const uint64_t v_78 = seed.word(6); - const uint64_t v_79 = seed.word(7); - const uint64_t v_80 = seed.word(8); - const uint64_t v_81 = seed.word(9); - const uint64_t v_82 = seed.word(10); - const uint64_t v_83 = seed.word(11); - const uint64_t v_84 = seed.word(12); - const uint64_t v_85 = seed.word(13); - row[layout.auxiliaries + 1] = v_75; - row[layout.auxiliaries + 2] = v_76; - row[layout.auxiliaries + 3] = v_77; - row[layout.auxiliaries + 4] = v_78; - row[layout.auxiliaries + 5] = v_79; - row[layout.auxiliaries + 6] = v_80; - row[layout.auxiliaries + 7] = v_81; - row[layout.auxiliaries + 8] = v_82; - row[layout.auxiliaries + 9] = v_83; - row[layout.auxiliaries + 10] = v_84; - row[layout.auxiliaries + 11] = v_85; - row[layout.selectors + 3] = 1; - return 0; - } - case 4ULL: { - const uint64_t v_88 = seed.word(3); - const uint64_t v_89 = seed.word(4); - const uint64_t v_90 = seed.word(5); - const uint64_t v_91 = seed.word(6); - const uint64_t v_92 = seed.word(7); - const uint64_t v_93 = seed.word(8); - const uint64_t v_94 = seed.word(9); - const uint64_t v_95 = seed.word(10); - const uint64_t v_96 = seed.word(11); - const uint64_t v_97 = seed.word(12); - const uint64_t v_98 = seed.word(13); - const uint64_t v_99 = seed.word(14); - const uint64_t v_100 = seed.word(15); - const uint64_t v_101 = seed.word(16); - const uint64_t v_102 = seed.word(17); - const uint64_t v_103 = seed.word(18); - const uint64_t v_104 = seed.word(19); - const uint64_t v_105 = seed.word(20); - row[layout.auxiliaries + 1] = v_88; - row[layout.auxiliaries + 2] = v_89; - row[layout.auxiliaries + 3] = v_90; - row[layout.auxiliaries + 4] = v_91; - row[layout.auxiliaries + 5] = v_92; - row[layout.auxiliaries + 6] = v_93; - row[layout.auxiliaries + 7] = v_94; - row[layout.auxiliaries + 8] = v_95; - row[layout.auxiliaries + 9] = v_96; - row[layout.auxiliaries + 10] = v_97; - row[layout.auxiliaries + 11] = v_98; - row[layout.auxiliaries + 12] = v_99; - row[layout.auxiliaries + 13] = v_100; - row[layout.auxiliaries + 14] = v_101; - row[layout.auxiliaries + 15] = v_102; - row[layout.auxiliaries + 16] = v_103; - row[layout.auxiliaries + 17] = v_104; - row[layout.auxiliaries + 18] = v_105; - row[layout.selectors + 4] = 1; - return 0; - } - case 5ULL: { - const uint64_t v_108 = seed.word(3); - const uint64_t v_109 = seed.word(4); - const uint64_t v_110 = seed.word(5); - const uint64_t v_111 = seed.word(6); - const uint64_t v_112 = seed.word(7); - const uint64_t v_113 = seed.word(8); - const uint64_t v_114 = seed.word(9); - const uint64_t v_115 = seed.word(10); - const uint64_t v_116 = seed.word(11); - const uint64_t v_117 = seed.word(12); - row[layout.auxiliaries + 1] = v_108; - 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.selectors + 5] = 1; - return 0; - } - case 6ULL: { - const uint64_t v_120 = seed.word(3); - const uint64_t v_121 = seed.word(4); - const uint64_t v_122 = seed.word(5); - const uint64_t v_123 = seed.word(6); - const uint64_t v_124 = seed.word(7); - const uint64_t v_125 = seed.word(8); - const uint64_t v_126 = seed.word(9); - const uint64_t v_127 = seed.word(10); - const uint64_t v_128 = seed.word(11); - const uint64_t v_129 = seed.word(12); - row[layout.auxiliaries + 1] = v_120; - row[layout.auxiliaries + 2] = v_121; - row[layout.auxiliaries + 3] = v_122; - row[layout.auxiliaries + 4] = v_123; - row[layout.auxiliaries + 5] = v_124; - row[layout.auxiliaries + 6] = v_125; - row[layout.auxiliaries + 7] = v_126; - row[layout.auxiliaries + 8] = v_127; - row[layout.auxiliaries + 9] = v_128; - row[layout.auxiliaries + 10] = v_129; - row[layout.selectors + 6] = 1; - return 0; - } - case 7ULL: { - const uint64_t v_132 = seed.word(3); - const uint64_t v_133 = seed.word(4); - const uint64_t v_134 = seed.word(5); - const uint64_t v_135 = seed.word(6); - const uint64_t v_136 = seed.word(7); - const uint64_t v_137 = seed.word(8); - const uint64_t v_138 = seed.word(9); - const uint64_t v_139 = seed.word(10); - const uint64_t v_140 = seed.word(11); - const uint64_t v_141 = seed.word(12); - row[layout.auxiliaries + 1] = v_132; - row[layout.auxiliaries + 2] = v_133; - row[layout.auxiliaries + 3] = v_134; - row[layout.auxiliaries + 4] = v_135; - row[layout.auxiliaries + 5] = v_136; - row[layout.auxiliaries + 6] = v_137; - row[layout.auxiliaries + 7] = v_138; - row[layout.auxiliaries + 8] = v_139; - row[layout.auxiliaries + 9] = v_140; - row[layout.auxiliaries + 10] = v_141; - row[layout.selectors + 7] = 1; - return 0; - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_125(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 ? 192 : 384; - const Seed_ixvm_125 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_125(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_125(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_125<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_125<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_125(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 < 8 || width < auxiliaries || width - auxiliaries < 46) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 192 : encoding == 0 ? 384 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_125); -} - -__device__ __constant__ uint64_t inverse_128_0[] = {6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_128 { - 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_128(Seed_ixvm_128 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_128_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_128(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_128 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_128(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_128(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_128<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_128<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_128(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_128); -} - -__device__ __constant__ uint64_t inverse_130_0[] = {0ULL}; -__device__ __constant__ uint64_t inverse_130_1[] = {0ULL}; -template struct Seed_ixvm_130 { - 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_130(Seed_ixvm_130 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_130_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_130_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_130(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_130 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_130(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_130(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_130<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_130<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_130(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_130); -} - -template struct Seed_ixvm_135 { - 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_135(Seed_ixvm_135 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_135(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_135 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_135(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_135(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_135<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_135<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_135(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_135); -} - -template struct Seed_ixvm_143 { - 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_143(Seed_ixvm_143 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_143(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_143 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_143(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_143(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_143<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_143<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_143(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_143); -} - -__device__ __constant__ uint64_t inverse_145_0[] = {0ULL}; -template struct Seed_ixvm_145 { - 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_145(Seed_ixvm_145 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_145_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_145(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_145 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_145(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_145(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_145<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_145<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_145(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_145); -} - -template struct Seed_ixvm_154 { - 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_154(Seed_ixvm_154 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); - row[layout.auxiliaries + 1] = v_16; - if (v_1 > 255 || v_9 > 255) return 1; - const uint64_t v_17 = (v_1 | v_9); - row[layout.auxiliaries + 2] = v_17; - if (v_2 > 255 || v_10 > 255) return 1; - const uint64_t v_18 = (v_2 | v_10); - row[layout.auxiliaries + 3] = v_18; - if (v_3 > 255 || v_11 > 255) return 1; - const uint64_t v_19 = (v_3 | v_11); - row[layout.auxiliaries + 4] = v_19; - if (v_4 > 255 || v_12 > 255) return 1; - const uint64_t v_20 = (v_4 | v_12); - row[layout.auxiliaries + 5] = v_20; - if (v_5 > 255 || v_13 > 255) return 1; - const uint64_t v_21 = (v_5 | v_13); - row[layout.auxiliaries + 6] = v_21; - if (v_6 > 255 || v_14 > 255) return 1; - const uint64_t v_22 = (v_6 | v_14); - row[layout.auxiliaries + 7] = v_22; - if (v_7 > 255 || v_15 > 255) return 1; - const uint64_t v_23 = (v_7 | v_15); - row[layout.auxiliaries + 8] = v_23; - row[layout.selectors + 0] = 1; - return 0; -} -template __global__ void kernel_ixvm_154(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_154 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_154(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_154(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_154<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_154<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_154(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 ? 24 : encoding == 0 ? 136 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_154); -} - -template struct Seed_ixvm_155 { - 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_155(Seed_ixvm_155 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); - row[layout.auxiliaries + 1] = v_16; - if (v_1 > 255 || v_9 > 255) return 1; - const uint64_t v_17 = (v_1 ^ v_9); - row[layout.auxiliaries + 2] = v_17; - if (v_2 > 255 || v_10 > 255) return 1; - const uint64_t v_18 = (v_2 ^ v_10); - row[layout.auxiliaries + 3] = v_18; - if (v_3 > 255 || v_11 > 255) return 1; - const uint64_t v_19 = (v_3 ^ v_11); - row[layout.auxiliaries + 4] = v_19; - if (v_4 > 255 || v_12 > 255) return 1; - const uint64_t v_20 = (v_4 ^ v_12); - row[layout.auxiliaries + 5] = v_20; - if (v_5 > 255 || v_13 > 255) return 1; - const uint64_t v_21 = (v_5 ^ v_13); - row[layout.auxiliaries + 6] = v_21; - if (v_6 > 255 || v_14 > 255) return 1; - const uint64_t v_22 = (v_6 ^ v_14); - row[layout.auxiliaries + 7] = v_22; - if (v_7 > 255 || v_15 > 255) return 1; - const uint64_t v_23 = (v_7 ^ v_15); - row[layout.auxiliaries + 8] = v_23; - row[layout.selectors + 0] = 1; - return 0; -} -template __global__ void kernel_ixvm_155(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_155 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_155(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_155(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_155<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_155<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_155(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 ? 24 : encoding == 0 ? 136 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_155); -} - -template struct Seed_ixvm_157 { - 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 + 36); - case 4: return load_u8(data + 37); - case 5: return load_u8(data + 38); - case 6: return load_u8(data + 39); - case 7: return load_u8(data + 40); - case 8: return load_u8(data + 41); - case 9: return load_u8(data + 42); - case 10: return load_u8(data + 43); - case 11: return load_u8(data + 44); - case 12: return load_u32(data + 24); - case 13: return load_u8(data + 45); - case 14: return load_u8(data + 46); - case 15: return load_u8(data + 47); - case 16: return load_u8(data + 48); - case 17: return load_u8(data + 49); - case 18: return load_u8(data + 50); - case 19: return load_u8(data + 51); - case 20: return load_u8(data + 52); - case 21: return load_u8(data + 53); - case 22: return load_u32(data + 28); - case 23: return load_u8(data + 54); - case 24: return load_u8(data + 55); - case 25: return load_u8(data + 56); - case 26: return load_u8(data + 57); - case 27: return load_u8(data + 58); - case 28: return load_u8(data + 59); - case 29: return load_u8(data + 60); - case 30: return load_u8(data + 61); - case 31: return load_u64(data + 8); - case 32: return load_u32(data + 32); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_157(Seed_ixvm_157 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); - 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); - 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; - row[layout.auxiliaries + 9] = v_10; - row[layout.auxiliaries + 10] = v_11; - switch (v_2) { - case 1ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - case 0ULL: { - 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); - 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); - row[layout.auxiliaries + 11] = v_12; - row[layout.auxiliaries + 12] = v_13; - row[layout.auxiliaries + 13] = v_14; - row[layout.auxiliaries + 14] = v_15; - row[layout.auxiliaries + 15] = v_16; - row[layout.auxiliaries + 16] = v_17; - row[layout.auxiliaries + 17] = v_18; - row[layout.auxiliaries + 18] = v_19; - row[layout.auxiliaries + 19] = v_20; - row[layout.auxiliaries + 20] = v_21; - switch (v_12) { - case 1ULL: { - row[layout.selectors + 1] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_23 = seed.word(23); - const uint64_t v_24 = seed.word(24); - const uint64_t v_25 = seed.word(25); - const uint64_t v_26 = seed.word(26); - const uint64_t v_27 = seed.word(27); - const uint64_t v_28 = seed.word(28); - const uint64_t v_29 = seed.word(29); - const uint64_t v_30 = seed.word(30); - row[layout.auxiliaries + 21] = v_23; - row[layout.auxiliaries + 22] = v_24; - row[layout.auxiliaries + 23] = v_25; - row[layout.auxiliaries + 24] = v_26; - row[layout.auxiliaries + 25] = v_27; - row[layout.auxiliaries + 26] = v_28; - row[layout.auxiliaries + 27] = v_29; - row[layout.auxiliaries + 28] = v_30; - const uint64_t v_31 = seed.word(31); - row[layout.auxiliaries + 29] = v_31; - const uint64_t v_32 = seed.word(32); - row[layout.auxiliaries + 30] = v_32; - row[layout.selectors + 2] = 1; - return 0; - } - default: { - return 2; - } - } - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_157(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 : 264; - const Seed_ixvm_157 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_157(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_157(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_157<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_157<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_157(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 < 31) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 64 : encoding == 0 ? 264 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_157); -} - -template struct Seed_ixvm_158 { - 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 + 36); - case 4: return load_u8(data + 37); - case 5: return load_u8(data + 38); - case 6: return load_u8(data + 39); - case 7: return load_u8(data + 40); - case 8: return load_u8(data + 41); - case 9: return load_u8(data + 42); - case 10: return load_u8(data + 43); - case 11: return load_u8(data + 44); - case 12: return load_u32(data + 24); - case 13: return load_u8(data + 45); - case 14: return load_u8(data + 46); - case 15: return load_u8(data + 47); - case 16: return load_u8(data + 48); - case 17: return load_u8(data + 49); - case 18: return load_u8(data + 50); - case 19: return load_u8(data + 51); - case 20: return load_u8(data + 52); - case 21: return load_u8(data + 53); - case 22: return load_u32(data + 28); - case 23: return load_u8(data + 54); - case 24: return load_u8(data + 55); - case 25: return load_u8(data + 56); - case 26: return load_u8(data + 57); - case 27: return load_u8(data + 58); - case 28: return load_u8(data + 59); - case 29: return load_u8(data + 60); - case 30: return load_u8(data + 61); - case 31: return load_u64(data + 8); - case 32: return load_u32(data + 32); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_158(Seed_ixvm_158 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); - 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); - 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; - row[layout.auxiliaries + 9] = v_10; - row[layout.auxiliaries + 10] = v_11; - switch (v_2) { - case 1ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - case 0ULL: { - 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); - 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); - row[layout.auxiliaries + 11] = v_12; - row[layout.auxiliaries + 12] = v_13; - row[layout.auxiliaries + 13] = v_14; - row[layout.auxiliaries + 14] = v_15; - row[layout.auxiliaries + 15] = v_16; - row[layout.auxiliaries + 16] = v_17; - row[layout.auxiliaries + 17] = v_18; - row[layout.auxiliaries + 18] = v_19; - row[layout.auxiliaries + 19] = v_20; - row[layout.auxiliaries + 20] = v_21; - switch (v_12) { - case 1ULL: { - row[layout.selectors + 1] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_23 = seed.word(23); - const uint64_t v_24 = seed.word(24); - const uint64_t v_25 = seed.word(25); - const uint64_t v_26 = seed.word(26); - const uint64_t v_27 = seed.word(27); - const uint64_t v_28 = seed.word(28); - const uint64_t v_29 = seed.word(29); - const uint64_t v_30 = seed.word(30); - row[layout.auxiliaries + 21] = v_23; - row[layout.auxiliaries + 22] = v_24; - row[layout.auxiliaries + 23] = v_25; - row[layout.auxiliaries + 24] = v_26; - row[layout.auxiliaries + 25] = v_27; - row[layout.auxiliaries + 26] = v_28; - row[layout.auxiliaries + 27] = v_29; - row[layout.auxiliaries + 28] = v_30; - const uint64_t v_31 = seed.word(31); - row[layout.auxiliaries + 29] = v_31; - const uint64_t v_32 = seed.word(32); - row[layout.auxiliaries + 30] = v_32; - row[layout.selectors + 2] = 1; - return 0; - } - default: { - return 2; - } - } - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_158(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 : 264; - const Seed_ixvm_158 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_158(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_158(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_158<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_158<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_158(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 < 31) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 64 : encoding == 0 ? 264 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_158); -} - -__device__ __constant__ uint64_t inverse_178_0[] = {4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -__device__ __constant__ uint64_t inverse_178_1[] = {18446744069414584320ULL, 0ULL}; -__device__ __constant__ uint64_t inverse_178_2[] = {9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -__device__ __constant__ uint64_t inverse_178_3[] = {6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_178 { - 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_u32(data + 132); - case 3: return load_u32(data + 136); - case 4: return load_u8(data + 180); - case 5: return load_u32(data + 140); - case 6: return load_u32(data + 144); - case 7: return load_u64(data + 8); - case 8: return load_u8(data + 181); - case 9: return load_u32(data + 148); - case 10: return load_u64(data + 16); - case 11: return load_u64(data + 24); - case 12: return load_u32(data + 152); - case 13: return load_u8(data + 182); - case 14: return load_u64(data + 32); - case 15: return load_u32(data + 156); - case 16: return load_u32(data + 160); - case 17: return load_u64(data + 40); - case 18: return load_u64(data + 48); - case 19: return load_u64(data + 56); - case 20: return load_u64(data + 64); - 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_u32(data + 164); - case 26: return load_u32(data + 168); - case 27: return load_u8(data + 183); - case 28: return load_u64(data + 104); - case 29: return load_u32(data + 172); - case 30: return load_u64(data + 112); - case 31: return load_u32(data + 176); - case 32: return load_u64(data + 120); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_178(Seed_ixvm_178 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 3ULL: { - 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 + 5] = v_7; - row[layout.auxiliaries + 6] = v_8; - row[layout.auxiliaries + 7] = v_9; - row[layout.auxiliaries + 8] = v_10; - switch (v_7) { - case 2ULL: { - const uint64_t v_11 = seed.word(12); - row[layout.auxiliaries + 9] = v_11; - 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); - 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); - row[layout.auxiliaries + 10] = v_12; - row[layout.auxiliaries + 11] = v_13; - row[layout.auxiliaries + 12] = v_14; - row[layout.auxiliaries + 13] = v_15; - row[layout.auxiliaries + 14] = v_16; - row[layout.auxiliaries + 15] = v_17; - row[layout.auxiliaries + 16] = v_18; - row[layout.auxiliaries + 17] = v_19; - row[layout.auxiliaries + 18] = v_20; - row[layout.auxiliaries + 19] = v_21; - row[layout.auxiliaries + 20] = v_22; - row[layout.auxiliaries + 21] = v_23; - switch (v_12) { - case 1ULL: { - const uint64_t v_25 = seed.word(25); - row[layout.auxiliaries + 22] = v_25; - const uint64_t v_26 = seed.word(26); - row[layout.auxiliaries + 23] = v_26; - const uint64_t v_27 = seed.word(27); - const uint64_t v_28 = seed.word(28); - const uint64_t v_29 = seed.word(29); - const uint64_t v_30 = seed.word(30); - row[layout.auxiliaries + 24] = v_27; - row[layout.auxiliaries + 25] = v_28; - row[layout.auxiliaries + 26] = v_29; - row[layout.auxiliaries + 27] = v_30; - switch (v_27) { - case 4ULL: { - const uint64_t v_32 = seed.word(31); - row[layout.auxiliaries + 28] = v_32; - const uint64_t v_33 = seed.word(32); - row[layout.auxiliaries + 29] = v_33; - row[layout.selectors + 0] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 28] = (v_27 <= 4ULL ? inverse_178_0[v_27] : inverse(goldilocks_sub(v_27, 4ULL))); - const uint64_t v_36 = seed.word(31); - row[layout.auxiliaries + 29] = v_36; - const uint64_t v_37 = seed.word(32); - row[layout.auxiliaries + 30] = v_37; - row[layout.selectors + 1] = 1; - return 0; - } - } - } - default: { - row[layout.auxiliaries + 22] = (v_12 <= 1ULL ? inverse_178_1[v_12] : inverse(goldilocks_sub(v_12, 1ULL))); - row[layout.selectors + 2] = 1; - return 0; - } - } - } - default: { - row[layout.auxiliaries + 9] = (v_7 <= 2ULL ? inverse_178_2[v_7] : inverse(goldilocks_sub(v_7, 2ULL))); - row[layout.selectors + 3] = 1; - return 0; - } - } - } - default: { - row[layout.auxiliaries + 5] = (v_3 <= 3ULL ? inverse_178_3[v_3] : inverse(goldilocks_sub(v_3, 3ULL))); - row[layout.selectors + 4] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_178(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_178 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_178(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_178(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_178<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_178<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_178(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 < 31) 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_178); -} - -template struct Seed_ixvm_201 { - 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_201(Seed_ixvm_201 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_201(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_201 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_201(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_201(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_201<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_201<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_201(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_201); -} - -__device__ __constant__ uint64_t inverse_233_0[] = {0ULL}; -template struct Seed_ixvm_233 { - 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 + 104); - 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_u64(data + 72); - case 11: return load_u64(data + 80); - case 12: return load_u64(data + 88); - case 13: return load_u32(data + 96); - case 14: return load_u8(data + 105); - case 15: return load_u8(data + 106); - case 16: return load_u32(data + 100); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_233(Seed_ixvm_233 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; - switch (v_0) { - default: { - const uint64_t v_14 = seed.word(15); - row[layout.auxiliaries + 1] = v_14; - switch (v_14) { - case 0ULL: { - const uint64_t v_16 = seed.word(16); - row[layout.auxiliaries + 2] = v_16; - row[layout.selectors + 0] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 2] = (v_14 <= 0ULL ? inverse_233_0[v_14] : inverse(goldilocks_sub(v_14, 0ULL))); - const uint64_t v_17 = seed.word(16); - row[layout.auxiliaries + 3] = v_17; - row[layout.selectors + 1] = 1; - return 0; - } - } - } - } -} -template __global__ void kernel_ixvm_233(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 : 136; - const Seed_ixvm_233 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_233(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_233(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_233<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_233<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_233(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 < 14 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 4) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 112 : encoding == 0 ? 136 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_233); -} - -template struct Seed_ixvm_236 { - 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 + 336); - case 2: return load_u64(data + 8); - case 3: return load_u8(data + 337); - case 4: return load_u32(data + 288); - 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_u8(data + 338); - case 9: return load_u8(data + 339); - case 10: return load_u8(data + 340); - case 11: return load_u8(data + 341); - 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_u8(data + 342); - case 17: return load_u8(data + 343); - case 18: return load_u8(data + 344); - case 19: return load_u8(data + 345); - case 20: return load_u32(data + 292); - case 21: return load_u8(data + 346); - case 22: return load_u64(data + 72); - case 23: return load_u64(data + 80); - case 24: return load_u8(data + 347); - case 25: return load_u8(data + 348); - case 26: return load_u8(data + 349); - case 27: return load_u8(data + 350); - case 28: return load_u8(data + 351); - case 29: return load_u8(data + 352); - case 30: return load_u64(data + 88); - case 31: return load_u64(data + 96); - case 32: return load_u8(data + 353); - case 33: return load_u8(data + 354); - case 34: return load_u8(data + 355); - case 35: return load_u8(data + 356); - case 36: return load_u8(data + 357); - case 37: return load_u8(data + 358); - case 38: return load_u64(data + 104); - case 39: return load_u64(data + 112); - case 40: return load_u8(data + 359); - case 41: return load_u8(data + 360); - case 42: return load_u8(data + 361); - case 43: return load_u8(data + 362); - case 44: return load_u8(data + 363); - case 45: return load_u8(data + 364); - case 46: return load_u64(data + 120); - case 47: return load_u32(data + 296); - case 48: return load_u32(data + 300); - case 49: return load_u32(data + 304); - case 50: return load_u32(data + 308); - case 51: return load_u8(data + 365); - case 52: return load_u8(data + 366); - case 53: return load_u64(data + 128); - case 54: return load_u64(data + 136); - case 55: return load_u64(data + 144); - case 56: return load_u8(data + 367); - case 57: return load_u8(data + 368); - case 58: return load_u8(data + 369); - case 59: return load_u8(data + 370); - case 60: return load_u8(data + 371); - case 61: return load_u64(data + 152); - case 62: return load_u64(data + 160); - case 63: return load_u64(data + 168); - case 64: return load_u8(data + 372); - case 65: return load_u8(data + 373); - case 66: return load_u8(data + 374); - case 67: return load_u8(data + 375); - case 68: return load_u8(data + 376); - case 69: return load_u64(data + 176); - case 70: return load_u64(data + 184); - case 71: return load_u64(data + 192); - case 72: return load_u8(data + 377); - case 73: return load_u8(data + 378); - case 74: return load_u8(data + 379); - case 75: return load_u8(data + 380); - case 76: return load_u8(data + 381); - case 77: return load_u32(data + 312); - case 78: return load_u32(data + 316); - case 79: return load_u64(data + 200); - case 80: return load_u8(data + 382); - case 81: return load_u8(data + 383); - case 82: return load_u8(data + 384); - case 83: return load_u8(data + 385); - case 84: return load_u8(data + 386); - case 85: return load_u8(data + 387); - case 86: return load_u64(data + 208); - case 87: return load_u64(data + 216); - case 88: return load_u8(data + 388); - case 89: return load_u8(data + 389); - case 90: return load_u8(data + 390); - case 91: return load_u8(data + 391); - case 92: return load_u8(data + 392); - case 93: return load_u8(data + 393); - case 94: return load_u64(data + 224); - case 95: return load_u32(data + 320); - case 96: return load_u32(data + 324); - case 97: return load_u8(data + 394); - case 98: return load_u64(data + 232); - case 99: return load_u32(data + 328); - case 100: return load_u64(data + 240); - case 101: return load_u64(data + 248); - case 102: return load_u64(data + 256); - case 103: return load_u64(data + 264); - case 104: return load_u64(data + 272); - case 105: return load_u64(data + 280); - case 106: return load_u8(data + 395); - case 107: return load_u8(data + 396); - case 108: return load_u8(data + 397); - case 109: return load_u32(data + 332); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_236(Seed_ixvm_236 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); - 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); - 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); - 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); - 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; - 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.auxiliaries + 13] = v_14; - row[layout.auxiliaries + 14] = v_15; - row[layout.auxiliaries + 15] = v_16; - row[layout.auxiliaries + 16] = v_17; - row[layout.auxiliaries + 17] = v_18; - row[layout.auxiliaries + 18] = v_19; - row[layout.auxiliaries + 19] = v_20; - row[layout.auxiliaries + 20] = v_21; - row[layout.auxiliaries + 21] = v_22; - row[layout.auxiliaries + 22] = v_23; - row[layout.auxiliaries + 23] = v_24; - row[layout.auxiliaries + 24] = v_25; - row[layout.auxiliaries + 25] = v_26; - row[layout.auxiliaries + 26] = v_27; - row[layout.auxiliaries + 27] = v_28; - row[layout.auxiliaries + 28] = v_29; - row[layout.auxiliaries + 29] = v_30; - row[layout.auxiliaries + 30] = v_31; - row[layout.auxiliaries + 31] = v_32; - row[layout.auxiliaries + 32] = v_33; - row[layout.auxiliaries + 33] = v_34; - row[layout.auxiliaries + 34] = v_35; - row[layout.auxiliaries + 35] = v_36; - row[layout.auxiliaries + 36] = v_37; - row[layout.auxiliaries + 37] = v_38; - row[layout.auxiliaries + 38] = v_39; - row[layout.auxiliaries + 39] = v_40; - row[layout.auxiliaries + 40] = v_41; - row[layout.auxiliaries + 41] = v_42; - row[layout.auxiliaries + 42] = v_43; - row[layout.auxiliaries + 43] = v_44; - row[layout.auxiliaries + 44] = v_45; - row[layout.auxiliaries + 45] = v_46; - row[layout.auxiliaries + 46] = v_47; - row[layout.auxiliaries + 47] = v_48; - row[layout.auxiliaries + 48] = v_49; - switch (v_2) { - default: { - switch (v_2) { - case 8ULL: { - 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); - const uint64_t v_57 = seed.word(58); - const uint64_t v_58 = seed.word(59); - const uint64_t v_59 = seed.word(60); - const uint64_t v_60 = seed.word(61); - const uint64_t v_61 = seed.word(62); - const uint64_t v_62 = seed.word(63); - const uint64_t v_63 = seed.word(64); - const uint64_t v_64 = seed.word(65); - const uint64_t v_65 = seed.word(66); - const uint64_t v_66 = seed.word(67); - const uint64_t v_67 = seed.word(68); - const uint64_t v_68 = seed.word(69); - const uint64_t v_69 = seed.word(70); - const uint64_t v_70 = seed.word(71); - const uint64_t v_71 = seed.word(72); - const uint64_t v_72 = seed.word(73); - const uint64_t v_73 = seed.word(74); - const uint64_t v_74 = seed.word(75); - const uint64_t v_75 = seed.word(76); - const uint64_t v_76 = seed.word(77); - const uint64_t v_77 = seed.word(78); - const uint64_t v_78 = seed.word(79); - const uint64_t v_79 = seed.word(80); - const uint64_t v_80 = seed.word(81); - const uint64_t v_81 = seed.word(82); - const uint64_t v_82 = seed.word(83); - const uint64_t v_83 = seed.word(84); - const uint64_t v_84 = seed.word(85); - const uint64_t v_85 = seed.word(86); - const uint64_t v_86 = seed.word(87); - const uint64_t v_87 = seed.word(88); - const uint64_t v_88 = seed.word(89); - const uint64_t v_89 = seed.word(90); - const uint64_t v_90 = seed.word(91); - const uint64_t v_91 = seed.word(92); - const uint64_t v_92 = seed.word(93); - const uint64_t v_93 = seed.word(94); - const uint64_t v_94 = seed.word(95); - row[layout.auxiliaries + 49] = v_50; - row[layout.auxiliaries + 50] = v_51; - row[layout.auxiliaries + 51] = v_52; - row[layout.auxiliaries + 52] = v_53; - row[layout.auxiliaries + 53] = v_54; - row[layout.auxiliaries + 54] = v_55; - row[layout.auxiliaries + 55] = v_56; - row[layout.auxiliaries + 56] = v_57; - row[layout.auxiliaries + 57] = v_58; - row[layout.auxiliaries + 58] = v_59; - row[layout.auxiliaries + 59] = v_60; - row[layout.auxiliaries + 60] = v_61; - row[layout.auxiliaries + 61] = v_62; - row[layout.auxiliaries + 62] = v_63; - row[layout.auxiliaries + 63] = v_64; - row[layout.auxiliaries + 64] = v_65; - row[layout.auxiliaries + 65] = v_66; - row[layout.auxiliaries + 66] = v_67; - row[layout.auxiliaries + 67] = v_68; - row[layout.auxiliaries + 68] = v_69; - row[layout.auxiliaries + 69] = v_70; - row[layout.auxiliaries + 70] = v_71; - row[layout.auxiliaries + 71] = v_72; - row[layout.auxiliaries + 72] = v_73; - row[layout.auxiliaries + 73] = v_74; - row[layout.auxiliaries + 74] = v_75; - row[layout.auxiliaries + 75] = v_76; - row[layout.auxiliaries + 76] = v_77; - row[layout.auxiliaries + 77] = v_78; - row[layout.auxiliaries + 78] = v_79; - row[layout.auxiliaries + 79] = v_80; - row[layout.auxiliaries + 80] = v_81; - row[layout.auxiliaries + 81] = v_82; - row[layout.auxiliaries + 82] = v_83; - row[layout.auxiliaries + 83] = v_84; - row[layout.auxiliaries + 84] = v_85; - row[layout.auxiliaries + 85] = v_86; - row[layout.auxiliaries + 86] = v_87; - row[layout.auxiliaries + 87] = v_88; - row[layout.auxiliaries + 88] = v_89; - row[layout.auxiliaries + 89] = v_90; - row[layout.auxiliaries + 90] = v_91; - row[layout.auxiliaries + 91] = v_92; - row[layout.auxiliaries + 92] = v_93; - row[layout.auxiliaries + 93] = v_94; - switch (v_50) { - case 1ULL: { - const uint64_t v_95 = seed.word(96); - row[layout.auxiliaries + 94] = v_95; - const uint64_t v_96 = seed.word(97); - const uint64_t v_97 = seed.word(98); - const uint64_t v_98 = seed.word(99); - const uint64_t v_99 = seed.word(100); - const uint64_t v_100 = seed.word(101); - const uint64_t v_101 = seed.word(102); - const uint64_t v_102 = seed.word(103); - const uint64_t v_103 = seed.word(104); - const uint64_t v_104 = seed.word(105); - const uint64_t v_105 = seed.word(106); - const uint64_t v_106 = seed.word(107); - const uint64_t v_107 = seed.word(108); - row[layout.auxiliaries + 95] = v_96; - row[layout.auxiliaries + 96] = v_97; - row[layout.auxiliaries + 97] = v_98; - row[layout.auxiliaries + 98] = v_99; - row[layout.auxiliaries + 99] = v_100; - row[layout.auxiliaries + 100] = v_101; - row[layout.auxiliaries + 101] = v_102; - row[layout.auxiliaries + 102] = v_103; - row[layout.auxiliaries + 103] = v_104; - row[layout.auxiliaries + 104] = v_105; - row[layout.auxiliaries + 105] = v_106; - row[layout.auxiliaries + 106] = v_107; - const uint64_t v_108 = seed.word(109); - row[layout.auxiliaries + 107] = v_108; - row[layout.selectors + 0] = 1; - return 0; - } - default: { - return 2; - } - } - } - default: { - return 2; - } - } - } - } -} -template __global__ void kernel_ixvm_236(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 ? 400 : 880; - const Seed_ixvm_236 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_236(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_236(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_236<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_236<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_236(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 < 108) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 400 : encoding == 0 ? 880 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_236); -} - -template struct Seed_ixvm_237 { - 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 + 424); - case 2: return load_u64(data + 8); - case 3: return load_u64(data + 16); - case 4: return load_u8(data + 425); - case 5: return load_u32(data + 376); - 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_u8(data + 426); - case 10: return load_u8(data + 427); - case 11: return load_u8(data + 428); - case 12: return load_u8(data + 429); - 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_u8(data + 430); - case 18: return load_u8(data + 431); - case 19: return load_u8(data + 432); - case 20: return load_u8(data + 433); - case 21: return load_u32(data + 380); - case 22: return load_u8(data + 434); - case 23: return load_u64(data + 80); - case 24: return load_u64(data + 88); - case 25: return load_u8(data + 435); - case 26: return load_u8(data + 436); - case 27: return load_u8(data + 437); - case 28: return load_u8(data + 438); - case 29: return load_u8(data + 439); - case 30: return load_u8(data + 440); - case 31: return load_u64(data + 96); - case 32: return load_u64(data + 104); - case 33: return load_u8(data + 441); - case 34: return load_u8(data + 442); - case 35: return load_u8(data + 443); - case 36: return load_u8(data + 444); - case 37: return load_u8(data + 445); - case 38: return load_u8(data + 446); - case 39: return load_u64(data + 112); - case 40: return load_u64(data + 120); - case 41: return load_u8(data + 447); - case 42: return load_u8(data + 448); - case 43: return load_u8(data + 449); - case 44: return load_u8(data + 450); - case 45: return load_u8(data + 451); - case 46: return load_u8(data + 452); - case 47: return load_u64(data + 128); - case 48: return load_u32(data + 384); - case 49: return load_u32(data + 388); - case 50: return load_u32(data + 392); - case 51: return load_u32(data + 396); - case 52: return load_u8(data + 453); - case 53: return load_u8(data + 454); - case 54: return load_u64(data + 136); - case 55: return load_u64(data + 144); - case 56: return load_u64(data + 152); - case 57: return load_u8(data + 455); - case 58: return load_u8(data + 456); - case 59: return load_u8(data + 457); - case 60: return load_u8(data + 458); - case 61: return load_u8(data + 459); - case 62: return load_u64(data + 160); - case 63: return load_u64(data + 168); - case 64: return load_u64(data + 176); - case 65: return load_u8(data + 460); - case 66: return load_u8(data + 461); - case 67: return load_u8(data + 462); - case 68: return load_u8(data + 463); - case 69: return load_u8(data + 464); - case 70: return load_u64(data + 184); - case 71: return load_u64(data + 192); - case 72: return load_u64(data + 200); - case 73: return load_u8(data + 465); - case 74: return load_u8(data + 466); - case 75: return load_u8(data + 467); - case 76: return load_u8(data + 468); - case 77: return load_u8(data + 469); - case 78: return load_u64(data + 208); - case 79: return load_u32(data + 400); - case 80: return load_u64(data + 216); - case 81: return load_u8(data + 470); - case 82: return load_u8(data + 471); - case 83: return load_u8(data + 472); - case 84: return load_u8(data + 473); - case 85: return load_u8(data + 474); - case 86: return load_u8(data + 475); - case 87: return load_u64(data + 224); - case 88: return load_u64(data + 232); - case 89: return load_u8(data + 476); - case 90: return load_u8(data + 477); - case 91: return load_u8(data + 478); - case 92: return load_u8(data + 479); - case 93: return load_u8(data + 480); - case 94: return load_u8(data + 481); - case 95: return load_u64(data + 240); - case 96: return load_u32(data + 404); - case 97: return load_u64(data + 248); - case 98: return load_u64(data + 256); - case 99: return load_u64(data + 264); - case 100: return load_u8(data + 482); - case 101: return load_u8(data + 483); - case 102: return load_u8(data + 484); - case 103: return load_u8(data + 485); - case 104: return load_u8(data + 486); - case 105: return load_u8(data + 487); - case 106: return load_u64(data + 272); - case 107: return load_u64(data + 280); - case 108: return load_u8(data + 488); - case 109: return load_u8(data + 489); - case 110: return load_u8(data + 490); - case 111: return load_u8(data + 491); - case 112: return load_u8(data + 492); - case 113: return load_u8(data + 493); - case 114: return load_u64(data + 288); - case 115: return load_u64(data + 296); - case 116: return load_u8(data + 494); - case 117: return load_u8(data + 495); - case 118: return load_u8(data + 496); - case 119: return load_u8(data + 497); - case 120: return load_u8(data + 498); - case 121: return load_u8(data + 499); - case 122: return load_u64(data + 304); - case 123: return load_u64(data + 312); - case 124: return load_u8(data + 500); - case 125: return load_u8(data + 501); - case 126: return load_u8(data + 502); - case 127: return load_u8(data + 503); - case 128: return load_u8(data + 504); - case 129: return load_u8(data + 505); - case 130: return load_u32(data + 408); - case 131: return load_u32(data + 412); - case 132: return load_u8(data + 506); - case 133: return load_u64(data + 320); - case 134: return load_u32(data + 416); - case 135: return load_u64(data + 328); - case 136: return load_u64(data + 336); - case 137: return load_u64(data + 344); - case 138: return load_u64(data + 352); - case 139: return load_u64(data + 360); - case 140: return load_u64(data + 368); - case 141: return load_u8(data + 507); - case 142: return load_u8(data + 508); - case 143: return load_u8(data + 509); - case 144: return load_u32(data + 420); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_237(Seed_ixvm_237 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); - 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); - 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); - 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); - 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; - row[layout.auxiliaries + 11] = v_13; - row[layout.auxiliaries + 12] = v_14; - row[layout.auxiliaries + 13] = v_15; - row[layout.auxiliaries + 14] = v_16; - row[layout.auxiliaries + 15] = v_17; - row[layout.auxiliaries + 16] = v_18; - row[layout.auxiliaries + 17] = v_19; - row[layout.auxiliaries + 18] = v_20; - row[layout.auxiliaries + 19] = v_21; - row[layout.auxiliaries + 20] = v_22; - row[layout.auxiliaries + 21] = v_23; - row[layout.auxiliaries + 22] = v_24; - row[layout.auxiliaries + 23] = v_25; - row[layout.auxiliaries + 24] = v_26; - row[layout.auxiliaries + 25] = v_27; - row[layout.auxiliaries + 26] = v_28; - row[layout.auxiliaries + 27] = v_29; - row[layout.auxiliaries + 28] = v_30; - row[layout.auxiliaries + 29] = v_31; - row[layout.auxiliaries + 30] = v_32; - row[layout.auxiliaries + 31] = v_33; - row[layout.auxiliaries + 32] = v_34; - row[layout.auxiliaries + 33] = v_35; - row[layout.auxiliaries + 34] = v_36; - row[layout.auxiliaries + 35] = v_37; - row[layout.auxiliaries + 36] = v_38; - row[layout.auxiliaries + 37] = v_39; - row[layout.auxiliaries + 38] = v_40; - row[layout.auxiliaries + 39] = v_41; - row[layout.auxiliaries + 40] = v_42; - row[layout.auxiliaries + 41] = v_43; - row[layout.auxiliaries + 42] = v_44; - row[layout.auxiliaries + 43] = v_45; - row[layout.auxiliaries + 44] = v_46; - row[layout.auxiliaries + 45] = v_47; - row[layout.auxiliaries + 46] = v_48; - row[layout.auxiliaries + 47] = v_49; - row[layout.auxiliaries + 48] = v_50; - switch (v_3) { - default: { - switch (v_3) { - case 8ULL: { - 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); - const uint64_t v_57 = seed.word(58); - const uint64_t v_58 = seed.word(59); - const uint64_t v_59 = seed.word(60); - const uint64_t v_60 = seed.word(61); - const uint64_t v_61 = seed.word(62); - const uint64_t v_62 = seed.word(63); - const uint64_t v_63 = seed.word(64); - const uint64_t v_64 = seed.word(65); - const uint64_t v_65 = seed.word(66); - const uint64_t v_66 = seed.word(67); - const uint64_t v_67 = seed.word(68); - const uint64_t v_68 = seed.word(69); - const uint64_t v_69 = seed.word(70); - const uint64_t v_70 = seed.word(71); - const uint64_t v_71 = seed.word(72); - const uint64_t v_72 = seed.word(73); - const uint64_t v_73 = seed.word(74); - const uint64_t v_74 = seed.word(75); - const uint64_t v_75 = seed.word(76); - const uint64_t v_76 = seed.word(77); - const uint64_t v_77 = seed.word(78); - const uint64_t v_78 = seed.word(79); - const uint64_t v_79 = seed.word(80); - const uint64_t v_80 = seed.word(81); - const uint64_t v_81 = seed.word(82); - const uint64_t v_82 = seed.word(83); - const uint64_t v_83 = seed.word(84); - const uint64_t v_84 = seed.word(85); - const uint64_t v_85 = seed.word(86); - const uint64_t v_86 = seed.word(87); - const uint64_t v_87 = seed.word(88); - const uint64_t v_88 = seed.word(89); - const uint64_t v_89 = seed.word(90); - const uint64_t v_90 = seed.word(91); - const uint64_t v_91 = seed.word(92); - const uint64_t v_92 = seed.word(93); - const uint64_t v_93 = seed.word(94); - const uint64_t v_94 = seed.word(95); - const uint64_t v_95 = seed.word(96); - row[layout.auxiliaries + 49] = v_51; - row[layout.auxiliaries + 50] = v_52; - row[layout.auxiliaries + 51] = v_53; - row[layout.auxiliaries + 52] = v_54; - row[layout.auxiliaries + 53] = v_55; - row[layout.auxiliaries + 54] = v_56; - row[layout.auxiliaries + 55] = v_57; - row[layout.auxiliaries + 56] = v_58; - row[layout.auxiliaries + 57] = v_59; - row[layout.auxiliaries + 58] = v_60; - row[layout.auxiliaries + 59] = v_61; - row[layout.auxiliaries + 60] = v_62; - row[layout.auxiliaries + 61] = v_63; - row[layout.auxiliaries + 62] = v_64; - row[layout.auxiliaries + 63] = v_65; - row[layout.auxiliaries + 64] = v_66; - row[layout.auxiliaries + 65] = v_67; - row[layout.auxiliaries + 66] = v_68; - row[layout.auxiliaries + 67] = v_69; - row[layout.auxiliaries + 68] = v_70; - row[layout.auxiliaries + 69] = v_71; - row[layout.auxiliaries + 70] = v_72; - row[layout.auxiliaries + 71] = v_73; - row[layout.auxiliaries + 72] = v_74; - row[layout.auxiliaries + 73] = v_75; - row[layout.auxiliaries + 74] = v_76; - row[layout.auxiliaries + 75] = v_77; - row[layout.auxiliaries + 76] = v_78; - row[layout.auxiliaries + 77] = v_79; - row[layout.auxiliaries + 78] = v_80; - row[layout.auxiliaries + 79] = v_81; - row[layout.auxiliaries + 80] = v_82; - row[layout.auxiliaries + 81] = v_83; - row[layout.auxiliaries + 82] = v_84; - row[layout.auxiliaries + 83] = v_85; - row[layout.auxiliaries + 84] = v_86; - row[layout.auxiliaries + 85] = v_87; - row[layout.auxiliaries + 86] = v_88; - row[layout.auxiliaries + 87] = v_89; - row[layout.auxiliaries + 88] = v_90; - row[layout.auxiliaries + 89] = v_91; - row[layout.auxiliaries + 90] = v_92; - row[layout.auxiliaries + 91] = v_93; - row[layout.auxiliaries + 92] = v_94; - row[layout.auxiliaries + 93] = v_95; - switch (v_51) { - case 1ULL: { - switch (v_52) { - default: { - const uint64_t v_96 = seed.word(97); - const uint64_t v_97 = seed.word(98); - const uint64_t v_98 = seed.word(99); - const uint64_t v_99 = seed.word(100); - const uint64_t v_100 = seed.word(101); - const uint64_t v_101 = seed.word(102); - const uint64_t v_102 = seed.word(103); - const uint64_t v_103 = seed.word(104); - const uint64_t v_104 = seed.word(105); - const uint64_t v_105 = seed.word(106); - const uint64_t v_106 = seed.word(107); - const uint64_t v_107 = seed.word(108); - const uint64_t v_108 = seed.word(109); - const uint64_t v_109 = seed.word(110); - const uint64_t v_110 = seed.word(111); - const uint64_t v_111 = seed.word(112); - const uint64_t v_112 = seed.word(113); - const uint64_t v_113 = seed.word(114); - const uint64_t v_114 = seed.word(115); - const uint64_t v_115 = seed.word(116); - const uint64_t v_116 = seed.word(117); - const uint64_t v_117 = seed.word(118); - const uint64_t v_118 = seed.word(119); - const uint64_t v_119 = seed.word(120); - const uint64_t v_120 = seed.word(121); - const uint64_t v_121 = seed.word(122); - const uint64_t v_122 = seed.word(123); - const uint64_t v_123 = seed.word(124); - const uint64_t v_124 = seed.word(125); - const uint64_t v_125 = seed.word(126); - const uint64_t v_126 = seed.word(127); - 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 + 94] = v_96; - row[layout.auxiliaries + 95] = v_97; - row[layout.auxiliaries + 96] = v_98; - row[layout.auxiliaries + 97] = v_99; - row[layout.auxiliaries + 98] = v_100; - row[layout.auxiliaries + 99] = v_101; - row[layout.auxiliaries + 100] = v_102; - row[layout.auxiliaries + 101] = v_103; - row[layout.auxiliaries + 102] = v_104; - row[layout.auxiliaries + 103] = v_105; - row[layout.auxiliaries + 104] = v_106; - row[layout.auxiliaries + 105] = v_107; - row[layout.auxiliaries + 106] = v_108; - row[layout.auxiliaries + 107] = v_109; - row[layout.auxiliaries + 108] = v_110; - row[layout.auxiliaries + 109] = v_111; - row[layout.auxiliaries + 110] = v_112; - row[layout.auxiliaries + 111] = v_113; - row[layout.auxiliaries + 112] = v_114; - row[layout.auxiliaries + 113] = v_115; - row[layout.auxiliaries + 114] = v_116; - row[layout.auxiliaries + 115] = v_117; - row[layout.auxiliaries + 116] = v_118; - row[layout.auxiliaries + 117] = v_119; - row[layout.auxiliaries + 118] = v_120; - row[layout.auxiliaries + 119] = v_121; - row[layout.auxiliaries + 120] = v_122; - row[layout.auxiliaries + 121] = v_123; - row[layout.auxiliaries + 122] = v_124; - row[layout.auxiliaries + 123] = v_125; - row[layout.auxiliaries + 124] = v_126; - row[layout.auxiliaries + 125] = v_127; - row[layout.auxiliaries + 126] = v_128; - row[layout.auxiliaries + 127] = v_129; - const uint64_t v_130 = seed.word(131); - row[layout.auxiliaries + 128] = v_130; - const uint64_t v_131 = seed.word(132); - const uint64_t v_132 = seed.word(133); - const uint64_t v_133 = seed.word(134); - const uint64_t v_134 = seed.word(135); - const uint64_t v_135 = seed.word(136); - const uint64_t v_136 = seed.word(137); - const uint64_t v_137 = seed.word(138); - const uint64_t v_138 = seed.word(139); - const uint64_t v_139 = seed.word(140); - const uint64_t v_140 = seed.word(141); - const uint64_t v_141 = seed.word(142); - const uint64_t v_142 = seed.word(143); - row[layout.auxiliaries + 129] = v_131; - row[layout.auxiliaries + 130] = v_132; - row[layout.auxiliaries + 131] = v_133; - row[layout.auxiliaries + 132] = v_134; - row[layout.auxiliaries + 133] = v_135; - row[layout.auxiliaries + 134] = v_136; - row[layout.auxiliaries + 135] = v_137; - row[layout.auxiliaries + 136] = v_138; - row[layout.auxiliaries + 137] = v_139; - row[layout.auxiliaries + 138] = v_140; - row[layout.auxiliaries + 139] = v_141; - row[layout.auxiliaries + 140] = v_142; - const uint64_t v_143 = seed.word(144); - row[layout.auxiliaries + 141] = v_143; - row[layout.selectors + 0] = 1; - return 0; - } - } - } - default: { - return 2; - } - } - } - default: { - return 2; - } - } - } - } -} -template __global__ void kernel_ixvm_237(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 ? 512 : 1160; - const Seed_ixvm_237 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_237(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_237(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_237<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_237<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_237(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 < 1 || width < auxiliaries || width - auxiliaries < 142) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 512 : encoding == 0 ? 1160 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_237); -} - -__device__ __constant__ uint64_t inverse_239_0[] = {0ULL}; -template struct Seed_ixvm_239 { - 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 + 256); - case 2: return load_u64(data + 8); - case 3: return load_u8(data + 272); - case 4: return load_u8(data + 273); - case 5: return load_u8(data + 274); - case 6: return load_u64(data + 16); - case 7: return load_u64(data + 24); - case 8: return load_u64(data + 32); - case 9: return load_u8(data + 275); - case 10: return load_u8(data + 276); - case 11: return load_u8(data + 277); - case 12: return load_u8(data + 278); - case 13: return load_u8(data + 279); - case 14: return load_u64(data + 40); - case 15: return load_u64(data + 48); - case 16: return load_u64(data + 56); - case 17: return load_u8(data + 280); - case 18: return load_u8(data + 281); - case 19: return load_u8(data + 282); - case 20: return load_u8(data + 283); - case 21: return load_u8(data + 284); - case 22: return load_u64(data + 64); - case 23: return load_u64(data + 72); - case 24: return load_u64(data + 80); - case 25: return load_u8(data + 285); - case 26: return load_u8(data + 286); - case 27: return load_u8(data + 287); - case 28: return load_u8(data + 288); - case 29: return load_u8(data + 289); - case 30: return load_u64(data + 88); - case 31: return load_u64(data + 96); - case 32: return load_u64(data + 104); - case 33: return load_u8(data + 290); - case 34: return load_u8(data + 291); - case 35: return load_u8(data + 292); - case 36: return load_u8(data + 293); - case 37: return load_u8(data + 294); - case 38: return load_u8(data + 295); - case 39: return load_u64(data + 112); - case 40: return load_u64(data + 120); - case 41: return load_u8(data + 296); - case 42: return load_u8(data + 297); - case 43: return load_u8(data + 298); - case 44: return load_u8(data + 299); - case 45: return load_u8(data + 300); - case 46: return load_u8(data + 301); - case 47: return load_u64(data + 128); - case 48: return load_u32(data + 260); - case 49: return load_u32(data + 264); - case 50: return load_u8(data + 302); - case 51: return load_u8(data + 303); - case 52: return load_u64(data + 136); - case 53: return load_u64(data + 144); - case 54: return load_u64(data + 152); - case 55: return load_u8(data + 304); - case 56: return load_u8(data + 305); - case 57: return load_u8(data + 306); - case 58: return load_u8(data + 307); - case 59: return load_u8(data + 308); - case 60: return load_u64(data + 160); - case 61: return load_u64(data + 168); - case 62: return load_u64(data + 176); - case 63: return load_u8(data + 309); - case 64: return load_u8(data + 310); - case 65: return load_u8(data + 311); - case 66: return load_u8(data + 312); - case 67: return load_u8(data + 313); - case 68: return load_u64(data + 184); - case 69: return load_u64(data + 192); - case 70: return load_u64(data + 200); - case 71: return load_u8(data + 314); - case 72: return load_u8(data + 315); - case 73: return load_u8(data + 316); - case 74: return load_u8(data + 317); - case 75: return load_u8(data + 318); - case 76: return load_u64(data + 208); - case 77: return load_u64(data + 216); - case 78: return load_u64(data + 224); - case 79: return load_u8(data + 319); - case 80: return load_u8(data + 320); - case 81: return load_u8(data + 321); - case 82: return load_u8(data + 322); - case 83: return load_u8(data + 323); - case 84: return load_u8(data + 324); - case 85: return load_u64(data + 232); - case 86: return load_u64(data + 240); - case 87: return load_u8(data + 325); - case 88: return load_u8(data + 326); - case 89: return load_u8(data + 327); - case 90: return load_u8(data + 328); - case 91: return load_u8(data + 329); - case 92: return load_u8(data + 330); - case 93: return load_u64(data + 248); - case 94: return load_u32(data + 268); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_239(Seed_ixvm_239 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); - 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); - 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); - 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); - 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; - 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.auxiliaries + 13] = v_14; - row[layout.auxiliaries + 14] = v_15; - row[layout.auxiliaries + 15] = v_16; - row[layout.auxiliaries + 16] = v_17; - row[layout.auxiliaries + 17] = v_18; - row[layout.auxiliaries + 18] = v_19; - row[layout.auxiliaries + 19] = v_20; - row[layout.auxiliaries + 20] = v_21; - row[layout.auxiliaries + 21] = v_22; - row[layout.auxiliaries + 22] = v_23; - row[layout.auxiliaries + 23] = v_24; - row[layout.auxiliaries + 24] = v_25; - row[layout.auxiliaries + 25] = v_26; - row[layout.auxiliaries + 26] = v_27; - row[layout.auxiliaries + 27] = v_28; - row[layout.auxiliaries + 28] = v_29; - row[layout.auxiliaries + 29] = v_30; - row[layout.auxiliaries + 30] = v_31; - row[layout.auxiliaries + 31] = v_32; - row[layout.auxiliaries + 32] = v_33; - row[layout.auxiliaries + 33] = v_34; - row[layout.auxiliaries + 34] = v_35; - row[layout.auxiliaries + 35] = v_36; - row[layout.auxiliaries + 36] = v_37; - row[layout.auxiliaries + 37] = v_38; - row[layout.auxiliaries + 38] = v_39; - row[layout.auxiliaries + 39] = v_40; - row[layout.auxiliaries + 40] = v_41; - row[layout.auxiliaries + 41] = v_42; - row[layout.auxiliaries + 42] = v_43; - row[layout.auxiliaries + 43] = v_44; - row[layout.auxiliaries + 44] = v_45; - row[layout.auxiliaries + 45] = v_46; - row[layout.auxiliaries + 46] = v_47; - row[layout.auxiliaries + 47] = v_48; - switch (v_2) { - case 0ULL: { - switch (v_1) { - case 0ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 48] = (v_1 <= 0ULL ? inverse_239_0[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); - const uint64_t v_51 = seed.word(50); - const uint64_t v_52 = seed.word(51); - const uint64_t v_53 = seed.word(52); - const uint64_t v_54 = seed.word(53); - const uint64_t v_55 = seed.word(54); - const uint64_t v_56 = seed.word(55); - const uint64_t v_57 = seed.word(56); - const uint64_t v_58 = seed.word(57); - const uint64_t v_59 = seed.word(58); - const uint64_t v_60 = seed.word(59); - const uint64_t v_61 = seed.word(60); - const uint64_t v_62 = seed.word(61); - const uint64_t v_63 = seed.word(62); - const uint64_t v_64 = seed.word(63); - const uint64_t v_65 = seed.word(64); - const uint64_t v_66 = seed.word(65); - const uint64_t v_67 = seed.word(66); - const uint64_t v_68 = seed.word(67); - const uint64_t v_69 = seed.word(68); - const uint64_t v_70 = seed.word(69); - const uint64_t v_71 = seed.word(70); - const uint64_t v_72 = seed.word(71); - const uint64_t v_73 = seed.word(72); - const uint64_t v_74 = seed.word(73); - const uint64_t v_75 = seed.word(74); - const uint64_t v_76 = seed.word(75); - const uint64_t v_77 = seed.word(76); - const uint64_t v_78 = seed.word(77); - const uint64_t v_79 = seed.word(78); - const uint64_t v_80 = seed.word(79); - const uint64_t v_81 = seed.word(80); - const uint64_t v_82 = seed.word(81); - const uint64_t v_83 = seed.word(82); - const uint64_t v_84 = seed.word(83); - const uint64_t v_85 = seed.word(84); - const uint64_t v_86 = seed.word(85); - const uint64_t v_87 = seed.word(86); - const uint64_t v_88 = seed.word(87); - const uint64_t v_89 = seed.word(88); - const uint64_t v_90 = seed.word(89); - const uint64_t v_91 = seed.word(90); - const uint64_t v_92 = seed.word(91); - const uint64_t v_93 = seed.word(92); - const uint64_t v_94 = seed.word(93); - const uint64_t v_95 = seed.word(94); - row[layout.auxiliaries + 49] = v_51; - row[layout.auxiliaries + 50] = v_52; - row[layout.auxiliaries + 51] = v_53; - row[layout.auxiliaries + 52] = v_54; - row[layout.auxiliaries + 53] = v_55; - row[layout.auxiliaries + 54] = v_56; - row[layout.auxiliaries + 55] = v_57; - row[layout.auxiliaries + 56] = v_58; - row[layout.auxiliaries + 57] = v_59; - row[layout.auxiliaries + 58] = v_60; - row[layout.auxiliaries + 59] = v_61; - row[layout.auxiliaries + 60] = v_62; - row[layout.auxiliaries + 61] = v_63; - row[layout.auxiliaries + 62] = v_64; - row[layout.auxiliaries + 63] = v_65; - row[layout.auxiliaries + 64] = v_66; - row[layout.auxiliaries + 65] = v_67; - row[layout.auxiliaries + 66] = v_68; - row[layout.auxiliaries + 67] = v_69; - row[layout.auxiliaries + 68] = v_70; - row[layout.auxiliaries + 69] = v_71; - row[layout.auxiliaries + 70] = v_72; - row[layout.auxiliaries + 71] = v_73; - row[layout.auxiliaries + 72] = v_74; - row[layout.auxiliaries + 73] = v_75; - row[layout.auxiliaries + 74] = v_76; - row[layout.auxiliaries + 75] = v_77; - row[layout.auxiliaries + 76] = v_78; - row[layout.auxiliaries + 77] = v_79; - row[layout.auxiliaries + 78] = v_80; - row[layout.auxiliaries + 79] = v_81; - row[layout.auxiliaries + 80] = v_82; - row[layout.auxiliaries + 81] = v_83; - row[layout.auxiliaries + 82] = v_84; - row[layout.auxiliaries + 83] = v_85; - row[layout.auxiliaries + 84] = v_86; - row[layout.auxiliaries + 85] = v_87; - row[layout.auxiliaries + 86] = v_88; - row[layout.auxiliaries + 87] = v_89; - row[layout.auxiliaries + 88] = v_90; - row[layout.auxiliaries + 89] = v_91; - row[layout.auxiliaries + 90] = v_92; - row[layout.auxiliaries + 91] = v_93; - row[layout.auxiliaries + 92] = v_94; - row[layout.auxiliaries + 93] = v_95; - row[layout.selectors + 1] = 1; - return 0; - } - } - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_239(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 ? 336 : 760; - const Seed_ixvm_239 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_239(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_239(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_239<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_239<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_239(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 < 94) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 336 : encoding == 0 ? 760 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_239); -} - -template struct Seed_ixvm_241 { - 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 + 136); - case 2: return load_u8(data + 156); - case 3: return load_u64(data + 8); - case 4: return load_u8(data + 157); - case 5: return load_u8(data + 158); - case 6: return load_u64(data + 16); - case 7: return load_u64(data + 24); - case 8: return load_u64(data + 32); - case 9: return load_u8(data + 159); - case 10: return load_u8(data + 160); - case 11: return load_u8(data + 161); - case 12: return load_u8(data + 162); - case 13: return load_u8(data + 163); - case 14: return load_u64(data + 40); - case 15: return load_u64(data + 48); - case 16: return load_u64(data + 56); - case 17: return load_u8(data + 164); - case 18: return load_u8(data + 165); - case 19: return load_u8(data + 166); - case 20: return load_u8(data + 167); - case 21: return load_u8(data + 168); - case 22: return load_u64(data + 64); - case 23: return load_u64(data + 72); - case 24: return load_u64(data + 80); - case 25: return load_u8(data + 169); - case 26: return load_u8(data + 170); - case 27: return load_u8(data + 171); - case 28: return load_u8(data + 172); - case 29: return load_u8(data + 173); - case 30: return load_u64(data + 88); - case 31: return load_u64(data + 96); - case 32: return load_u64(data + 104); - case 33: return load_u8(data + 174); - case 34: return load_u8(data + 175); - case 35: return load_u8(data + 176); - case 36: return load_u8(data + 177); - case 37: return load_u8(data + 178); - case 38: return load_u8(data + 179); - case 39: return load_u64(data + 112); - case 40: return load_u64(data + 120); - case 41: return load_u8(data + 180); - case 42: return load_u8(data + 181); - case 43: return load_u8(data + 182); - case 44: return load_u8(data + 183); - case 45: return load_u8(data + 184); - case 46: return load_u8(data + 185); - case 47: return load_u64(data + 128); - case 48: return load_u32(data + 140); - case 49: return load_u8(data + 186); - case 50: return load_u8(data + 187); - case 51: return load_u8(data + 188); - case 52: return load_u8(data + 189); - case 53: return load_u8(data + 190); - case 54: return load_u8(data + 191); - case 55: return load_u8(data + 192); - case 56: return load_u8(data + 193); - case 57: return load_u32(data + 144); - case 58: return load_u32(data + 148); - case 59: return load_u32(data + 152); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_241(Seed_ixvm_241 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); - 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); - 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); - 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); - 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; - row[layout.auxiliaries + 11] = v_13; - row[layout.auxiliaries + 12] = v_14; - row[layout.auxiliaries + 13] = v_15; - row[layout.auxiliaries + 14] = v_16; - row[layout.auxiliaries + 15] = v_17; - row[layout.auxiliaries + 16] = v_18; - row[layout.auxiliaries + 17] = v_19; - row[layout.auxiliaries + 18] = v_20; - row[layout.auxiliaries + 19] = v_21; - row[layout.auxiliaries + 20] = v_22; - row[layout.auxiliaries + 21] = v_23; - row[layout.auxiliaries + 22] = v_24; - row[layout.auxiliaries + 23] = v_25; - row[layout.auxiliaries + 24] = v_26; - row[layout.auxiliaries + 25] = v_27; - row[layout.auxiliaries + 26] = v_28; - row[layout.auxiliaries + 27] = v_29; - row[layout.auxiliaries + 28] = v_30; - row[layout.auxiliaries + 29] = v_31; - row[layout.auxiliaries + 30] = v_32; - row[layout.auxiliaries + 31] = v_33; - row[layout.auxiliaries + 32] = v_34; - row[layout.auxiliaries + 33] = v_35; - row[layout.auxiliaries + 34] = v_36; - row[layout.auxiliaries + 35] = v_37; - row[layout.auxiliaries + 36] = v_38; - row[layout.auxiliaries + 37] = v_39; - row[layout.auxiliaries + 38] = v_40; - row[layout.auxiliaries + 39] = v_41; - row[layout.auxiliaries + 40] = v_42; - row[layout.auxiliaries + 41] = v_43; - row[layout.auxiliaries + 42] = v_44; - row[layout.auxiliaries + 43] = v_45; - row[layout.auxiliaries + 44] = v_46; - row[layout.auxiliaries + 45] = v_47; - 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); - row[layout.auxiliaries + 46] = v_48; - row[layout.auxiliaries + 47] = v_49; - row[layout.auxiliaries + 48] = v_50; - row[layout.auxiliaries + 49] = v_51; - row[layout.auxiliaries + 50] = v_52; - row[layout.auxiliaries + 51] = v_53; - row[layout.auxiliaries + 52] = v_54; - row[layout.auxiliaries + 53] = v_55; - uint64_t v_62; - uint64_t v_63; - uint64_t v_64; - uint64_t v_65; - uint64_t v_66; - uint64_t v_67; - uint64_t v_68; - uint64_t v_69; - uint64_t v_70; - uint64_t v_71; - uint64_t v_72; - uint64_t v_73; - uint64_t v_74; - uint64_t v_75; - uint64_t v_76; - uint64_t v_77; - uint64_t v_78; - uint64_t v_79; - uint64_t v_80; - uint64_t v_81; - uint64_t v_82; - uint64_t v_83; - uint64_t v_84; - uint64_t v_85; - uint64_t v_86; - uint64_t v_87; - uint64_t v_88; - uint64_t v_89; - uint64_t v_90; - uint64_t v_91; - uint64_t v_92; - uint64_t v_93; - uint64_t v_94; - uint64_t v_95; - uint64_t v_96; - uint64_t v_97; - uint64_t v_98; - uint64_t v_99; - uint64_t v_100; - uint64_t v_101; - uint64_t v_102; - uint64_t v_103; - uint64_t v_104; - uint64_t v_105; - uint64_t v_106; - switch (v_3) { - case 0ULL: { - const uint64_t v_56 = 7ULL; - const uint64_t v_57 = 0ULL; - row[layout.selectors + 0] = 1; - v_62 = v_56; - v_63 = v_48; - v_64 = v_49; - v_65 = v_50; - v_66 = v_51; - v_67 = v_52; - v_68 = v_53; - v_69 = v_54; - v_70 = v_55; - v_71 = v_1; - v_72 = v_57; - v_73 = v_57; - v_74 = v_57; - v_75 = v_57; - v_76 = v_57; - v_77 = v_57; - v_78 = v_57; - v_79 = v_57; - v_80 = v_57; - v_81 = v_57; - v_82 = v_57; - v_83 = v_57; - v_84 = v_57; - v_85 = v_57; - v_86 = v_57; - v_87 = v_57; - v_88 = v_57; - v_89 = v_57; - v_90 = v_57; - v_91 = v_57; - v_92 = v_57; - v_93 = v_57; - v_94 = v_57; - v_95 = v_57; - v_96 = v_57; - v_97 = v_57; - v_98 = v_57; - v_99 = v_57; - v_100 = v_57; - v_101 = v_57; - v_102 = v_57; - v_103 = v_57; - v_104 = v_57; - v_105 = v_57; - v_106 = v_57; - goto continuation_0; - } - case 1ULL: { - const uint64_t v_58 = 6ULL; - const uint64_t v_59 = 0ULL; - row[layout.selectors + 1] = 1; - v_62 = v_58; - v_63 = v_48; - v_64 = v_49; - v_65 = v_50; - v_66 = v_51; - v_67 = v_52; - v_68 = v_53; - v_69 = v_54; - v_70 = v_55; - v_71 = v_1; - v_72 = v_59; - v_73 = v_59; - v_74 = v_59; - v_75 = v_59; - v_76 = v_59; - v_77 = v_59; - v_78 = v_59; - v_79 = v_59; - v_80 = v_59; - v_81 = v_59; - v_82 = v_59; - v_83 = v_59; - v_84 = v_59; - v_85 = v_59; - v_86 = v_59; - v_87 = v_59; - v_88 = v_59; - v_89 = v_59; - v_90 = v_59; - v_91 = v_59; - v_92 = v_59; - v_93 = v_59; - v_94 = v_59; - v_95 = v_59; - v_96 = v_59; - v_97 = v_59; - v_98 = v_59; - v_99 = v_59; - v_100 = v_59; - v_101 = v_59; - v_102 = v_59; - v_103 = v_59; - v_104 = v_59; - v_105 = v_59; - v_106 = v_59; - goto continuation_0; - } - case 2ULL: { - const uint64_t v_60 = 5ULL; - const uint64_t v_61 = 0ULL; - row[layout.selectors + 2] = 1; - v_62 = v_60; - v_63 = v_48; - v_64 = v_49; - v_65 = v_50; - v_66 = v_51; - v_67 = v_52; - v_68 = v_53; - v_69 = v_54; - v_70 = v_55; - v_71 = v_1; - v_72 = v_61; - v_73 = v_61; - v_74 = v_61; - v_75 = v_61; - v_76 = v_61; - v_77 = v_61; - v_78 = v_61; - v_79 = v_61; - v_80 = v_61; - v_81 = v_61; - v_82 = v_61; - v_83 = v_61; - v_84 = v_61; - v_85 = v_61; - v_86 = v_61; - v_87 = v_61; - v_88 = v_61; - v_89 = v_61; - v_90 = v_61; - v_91 = v_61; - v_92 = v_61; - v_93 = v_61; - v_94 = v_61; - v_95 = v_61; - v_96 = v_61; - v_97 = v_61; - v_98 = v_61; - v_99 = v_61; - v_100 = v_61; - v_101 = v_61; - v_102 = v_61; - v_103 = v_61; - v_104 = v_61; - v_105 = v_61; - v_106 = v_61; - goto continuation_0; - } - default: { - return 2; - } - } - continuation_0:; - 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; - row[layout.auxiliaries + 65] = v_73; - 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; - row[layout.auxiliaries + 74] = v_82; - row[layout.auxiliaries + 75] = v_83; - row[layout.auxiliaries + 76] = v_84; - row[layout.auxiliaries + 77] = v_85; - row[layout.auxiliaries + 78] = v_86; - row[layout.auxiliaries + 79] = v_87; - row[layout.auxiliaries + 80] = v_88; - row[layout.auxiliaries + 81] = v_89; - row[layout.auxiliaries + 82] = v_90; - row[layout.auxiliaries + 83] = v_91; - row[layout.auxiliaries + 84] = v_92; - row[layout.auxiliaries + 85] = v_93; - row[layout.auxiliaries + 86] = v_94; - row[layout.auxiliaries + 87] = v_95; - row[layout.auxiliaries + 88] = v_96; - row[layout.auxiliaries + 89] = v_97; - row[layout.auxiliaries + 90] = v_98; - row[layout.auxiliaries + 91] = v_99; - row[layout.auxiliaries + 92] = v_100; - row[layout.auxiliaries + 93] = v_101; - row[layout.auxiliaries + 94] = v_102; - row[layout.auxiliaries + 95] = v_103; - row[layout.auxiliaries + 96] = v_104; - row[layout.auxiliaries + 97] = v_105; - row[layout.auxiliaries + 98] = v_106; - const uint64_t v_108 = seed.word(57); - row[layout.auxiliaries + 99] = v_108; - const uint64_t v_109 = seed.word(58); - row[layout.auxiliaries + 100] = v_109; - const uint64_t v_110 = seed.word(59); - row[layout.auxiliaries + 101] = v_110; - row[layout.selectors + 3] = 1; - return 0; -} -template __global__ void kernel_ixvm_241(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 ? 200 : 480; - const Seed_ixvm_241 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_241(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_241(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_241<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_241<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_241(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 < 102) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 200 : encoding == 0 ? 480 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_241); -} - -template struct Seed_ixvm_288 { - 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_288(Seed_ixvm_288 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_288(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_288 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_288(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_288(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_288<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_288<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_288(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_288); -} - -template struct Seed_ixvm_293 { - 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_293(Seed_ixvm_293 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: { - 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_11 = seed.word(8); - row[layout.auxiliaries + 5] = v_11; - switch (v_11) { - case 1ULL: { - row[layout.selectors + 4] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_13 = seed.word(9); - row[layout.auxiliaries + 6] = v_13; - row[layout.selectors + 5] = 1; - return 0; - } - default: { - return 2; - } - } - } - case 4ULL: { - const uint64_t v_14 = seed.word(8); - row[layout.auxiliaries + 5] = v_14; - row[layout.selectors + 6] = 1; - return 0; - } - case 5ULL: { - const uint64_t v_15 = seed.word(8); - row[layout.auxiliaries + 5] = v_15; - row[layout.selectors + 7] = 1; - return 0; - } - case 6ULL: { - const uint64_t v_16 = seed.word(8); - row[layout.auxiliaries + 5] = v_16; - row[layout.selectors + 8] = 1; - return 0; - } - case 8ULL: { - const uint64_t v_17 = seed.word(8); - row[layout.auxiliaries + 5] = v_17; - row[layout.selectors + 9] = 1; - return 0; - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_293(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_293 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_293(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_293(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_293<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_293<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_293(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 < 7) 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_293); -} - -__device__ __constant__ uint64_t inverse_302_0[] = {18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_302 { - 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_302(Seed_ixvm_302 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_302_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_302(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_302 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_302(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_302(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_302<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_302<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_302(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_302); -} - -__device__ __constant__ uint64_t inverse_303_0[] = {0ULL}; -template struct Seed_ixvm_303 { - 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_303(Seed_ixvm_303 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_303_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_303(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_303 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_303(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_303(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_303<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_303<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_303(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_303); -} - -__device__ __constant__ uint64_t inverse_310_0[] = {0ULL}; -template struct Seed_ixvm_310 { - 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); - case 3: return load_u32(data + 20); - case 4: return load_u32(data + 24); - case 5: return load_u8(data + 32); - case 6: return load_u32(data + 28); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_310(Seed_ixvm_310 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_310_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_310(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_310 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_310(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_310(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_310<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_310<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_310(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_310); -} - -template struct Seed_ixvm_311 { - 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_u32(data + 36); - case 4: return load_u8(data + 56); - case 5: return load_u32(data + 40); - case 6: return load_u32(data + 44); - case 7: return load_u32(data + 48); - case 8: return load_u64(data + 16); - case 9: return load_u64(data + 24); - case 10: return load_u32(data + 52); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_311(Seed_ixvm_311 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_9 = seed.word(8); - row[layout.auxiliaries + 5] = v_9; - row[layout.selectors + 0] = 1; - return 0; - } - case 1ULL: { - const uint64_t v_12 = seed.word(8); - row[layout.auxiliaries + 5] = v_12; - row[layout.selectors + 1] = 1; - return 0; - } - case 2ULL: { - const uint64_t v_15 = seed.word(8); - row[layout.auxiliaries + 5] = v_15; - row[layout.selectors + 2] = 1; - return 0; - } - case 3ULL: { - const uint64_t v_17 = seed.word(8); - row[layout.auxiliaries + 5] = v_17; - const uint64_t v_18 = seed.word(9); - row[layout.auxiliaries + 6] = v_18; - const uint64_t v_20 = seed.word(10); - row[layout.auxiliaries + 7] = v_20; - row[layout.selectors + 3] = 1; - return 0; - } - case 4ULL: { - const uint64_t v_22 = seed.word(8); - row[layout.auxiliaries + 5] = v_22; - const uint64_t v_25 = seed.word(9); - row[layout.auxiliaries + 6] = v_25; - const uint64_t v_27 = seed.word(10); - row[layout.auxiliaries + 7] = v_27; - row[layout.selectors + 4] = 1; - return 0; - } - case 5ULL: { - const uint64_t v_29 = seed.word(8); - row[layout.auxiliaries + 5] = v_29; - const uint64_t v_32 = seed.word(9); - row[layout.auxiliaries + 6] = v_32; - const uint64_t v_34 = seed.word(10); - row[layout.auxiliaries + 7] = v_34; - row[layout.selectors + 5] = 1; - return 0; - } - case 6ULL: { - const uint64_t v_35 = seed.word(8); - row[layout.auxiliaries + 5] = v_35; - row[layout.selectors + 6] = 1; - return 0; - } - case 7ULL: { - const uint64_t v_38 = seed.word(8); - row[layout.auxiliaries + 5] = v_38; - row[layout.selectors + 7] = 1; - return 0; - } - case 8ULL: { - const uint64_t v_40 = seed.word(8); - row[layout.auxiliaries + 5] = v_40; - const uint64_t v_41 = seed.word(9); - row[layout.auxiliaries + 6] = v_41; - row[layout.selectors + 8] = 1; - return 0; - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_311(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 : 88; - const Seed_ixvm_311 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_311(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_311(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_311<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_311<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_311(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 ? 64 : encoding == 0 ? 88 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_311); -} - -__device__ __constant__ uint64_t inverse_318_0[] = {0ULL}; -template struct Seed_ixvm_318 { - 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_318(Seed_ixvm_318 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_318_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_318(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_318 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_318(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_318(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_318<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_318<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_318(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_318); -} - -__device__ __constant__ uint64_t inverse_320_0[] = {0ULL}; -__device__ __constant__ uint64_t inverse_320_1[] = {18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_320 { - 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_320(Seed_ixvm_320 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_320_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_320_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_320(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_320 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_320(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_320(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_320<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_320<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_320(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_320); -} - -template struct Seed_ixvm_321 { - 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_321(Seed_ixvm_321 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_321(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_321 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_321(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_321(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_321<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_321<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_321(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_321); -} - -template struct Seed_ixvm_322 { - 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_322(Seed_ixvm_322 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_322(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_322 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_322(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_322(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_322<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_322<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_322(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_322); -} - -__device__ __constant__ uint64_t inverse_382_0[] = {18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_382 { - 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_u32(data + 20); - case 5: return load_u8(data + 24); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_382(Seed_ixvm_382 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; - if (v_1 > 0xffffffffULL || v_2 > 0xffffffffULL) return 3; - const uint32_t op_0 = uint32_t(v_1) - uint32_t(v_2); - const uint64_t v_4 = uint64_t(v_1 < v_2); - row[layout.auxiliaries + 1] = (v_1 & 0xffffULL); - row[layout.auxiliaries + 2] = ((v_1 >> 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_2 & 0xffffULL); - row[layout.auxiliaries + 6] = ((v_2 >> 16) & 0xffffULL); - switch (v_4) { - case 1ULL: { - const uint64_t v_5 = seed.word(5); - row[layout.auxiliaries + 7] = v_5; - row[layout.selectors + 0] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 7] = (v_4 <= 1ULL ? inverse_382_0[v_4] : inverse(goldilocks_sub(v_4, 1ULL))); - const uint64_t v_6 = seed.word(5); - row[layout.auxiliaries + 8] = v_6; - row[layout.selectors + 1] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_382(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_382 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_382(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_382(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_382<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_382<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_382(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 < 9) 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_382); -} - -__device__ __constant__ uint64_t inverse_388_0[] = {18446744069414584320ULL, 0ULL}; -__device__ __constant__ uint64_t inverse_388_1[] = {0ULL}; -__device__ __constant__ uint64_t inverse_388_2[] = {0ULL}; -template struct Seed_ixvm_388 { - 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_u32(data + 20); - case 5: return load_u8(data + 40); - case 6: return load_u8(data + 41); - case 7: return load_u8(data + 42); - case 8: return load_u32(data + 24); - case 9: return load_u32(data + 28); - case 10: return load_u8(data + 43); - case 11: return load_u32(data + 32); - case 12: return load_u32(data + 36); - case 13: return load_u8(data + 44); - case 14: return load_u8(data + 45); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_388(Seed_ixvm_388 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; - const uint64_t v_6 = goldilocks_mul(v_4, v_5); - row[layout.auxiliaries + 3] = v_6; - switch (v_6) { - case 1ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 4] = (v_6 <= 1ULL ? inverse_388_0[v_6] : inverse(goldilocks_sub(v_6, 1ULL))); - const uint64_t v_8 = seed.word(7); - const uint64_t v_9 = seed.word(8); - const uint64_t v_10 = seed.word(9); - row[layout.auxiliaries + 5] = v_8; - row[layout.auxiliaries + 6] = v_9; - row[layout.auxiliaries + 7] = v_10; - const uint64_t v_11 = seed.word(10); - const uint64_t v_12 = seed.word(11); - const uint64_t v_13 = seed.word(12); - row[layout.auxiliaries + 8] = v_11; - row[layout.auxiliaries + 9] = v_12; - row[layout.auxiliaries + 10] = v_13; - const uint64_t v_14 = goldilocks_mul(v_8, v_11); - row[layout.auxiliaries + 11] = v_14; - switch (v_14) { - case 0ULL: { - row[layout.selectors + 1] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 12] = (v_14 <= 0ULL ? inverse_388_1[v_14] : inverse(goldilocks_sub(v_14, 0ULL))); - const uint64_t v_16 = seed.word(13); - row[layout.auxiliaries + 13] = v_16; - switch (v_16) { - case 0ULL: { - row[layout.selectors + 2] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 14] = (v_16 <= 0ULL ? inverse_388_2[v_16] : inverse(goldilocks_sub(v_16, 0ULL))); - const uint64_t v_19 = seed.word(14); - row[layout.auxiliaries + 15] = v_19; - row[layout.selectors + 3] = 1; - return 0; - } - } - } - } - } - } -} -template __global__ void kernel_ixvm_388(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 : 120; - const Seed_ixvm_388 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_388(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_388(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_388<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_388<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_388(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 < 4 || width < auxiliaries || width - auxiliaries < 16) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 120 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_388); -} - -__device__ __constant__ uint64_t inverse_418_0[] = {18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_418 { - 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_u32(data + 40); - case 4: return load_u64(data + 8); - case 5: return load_u32(data + 44); - case 6: return load_u8(data + 56); - case 7: return load_u32(data + 48); - case 8: return load_u32(data + 52); - case 9: return load_u8(data + 57); - case 10: return load_u64(data + 16); - case 11: return load_u64(data + 24); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_418(Seed_ixvm_418 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); - const uint64_t v_6 = seed.word(7); - row[layout.auxiliaries + 1] = v_5; - row[layout.auxiliaries + 2] = v_6; - switch (v_5) { - case 1ULL: { - const uint64_t v_7 = seed.word(8); - row[layout.auxiliaries + 3] = v_7; - 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 + 4] = v_10; - row[layout.auxiliaries + 5] = v_11; - row[layout.auxiliaries + 6] = v_12; - row[layout.selectors + 0] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 3] = (v_5 <= 1ULL ? inverse_418_0[v_5] : inverse(goldilocks_sub(v_5, 1ULL))); - row[layout.selectors + 1] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_418(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 : 96; - const Seed_ixvm_418 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_418(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_418(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_418<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_418<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_418(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 < 5 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 7) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 64 : encoding == 0 ? 96 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_418); -} - -__device__ __constant__ uint64_t inverse_443_0[] = {0ULL}; -__device__ __constant__ uint64_t inverse_443_2[] = {0ULL}; -__device__ __constant__ uint64_t inverse_443_3[] = {3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -__device__ __constant__ uint64_t inverse_443_5[] = {0ULL}; -template struct Seed_ixvm_443 { - 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_u32(data + 80); - case 6: return load_u8(data + 120); - case 7: return load_u32(data + 84); - case 8: return load_u32(data + 88); - case 9: return load_u64(data + 8); - case 10: return load_u64(data + 16); - case 11: return load_u32(data + 92); - case 12: return load_u64(data + 24); - case 13: return load_u64(data + 32); - case 14: return load_u32(data + 96); - case 15: return load_u32(data + 100); - case 16: return load_u64(data + 40); - case 17: return load_u32(data + 104); - case 18: return load_u32(data + 108); - case 19: return load_u64(data + 48); - case 20: return load_u32(data + 112); - case 21: return load_u32(data + 116); - case 22: return load_u64(data + 56); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_443(Seed_ixvm_443 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); - const uint64_t v_6 = seed.word(7); - const uint64_t v_7 = seed.word(8); - row[layout.auxiliaries + 1] = v_5; - row[layout.auxiliaries + 2] = v_6; - row[layout.auxiliaries + 3] = v_7; - switch (v_5) { - case 1ULL: { - const uint64_t v_8 = seed.word(9); - row[layout.auxiliaries + 4] = v_8; - switch (v_8) { - case 0ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 5] = (v_8 <= 0ULL ? inverse_443_0[v_8] : inverse(goldilocks_sub(v_8, 0ULL))); - const uint64_t v_10 = seed.word(10); - row[layout.auxiliaries + 6] = v_10; - row[layout.selectors + 1] = 1; - return 0; - } - } - } - case 0ULL: { - 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 + 4] = v_11; - row[layout.auxiliaries + 5] = v_12; - row[layout.auxiliaries + 6] = v_13; - row[layout.auxiliaries + 7] = v_14; - switch (v_11) { - case 5ULL: { - const uint64_t v_15 = seed.word(13); - row[layout.auxiliaries + 8] = v_15; - uint64_t v_18; - switch (v_15) { - case 0ULL: { - row[layout.selectors + 2] = 1; - v_18 = v_12; - goto continuation_1; - } - default: { - row[layout.auxiliaries + 9] = (v_15 <= 0ULL ? inverse_443_2[v_15] : inverse(goldilocks_sub(v_15, 0ULL))); - const uint64_t v_17 = seed.word(14); - row[layout.auxiliaries + 10] = v_17; - row[layout.selectors + 3] = 1; - v_18 = v_17; - goto continuation_1; - } - } - continuation_1:; - row[layout.auxiliaries + 11] = v_18; - const uint64_t v_20 = seed.word(15); - row[layout.auxiliaries + 12] = v_20; - const uint64_t v_21 = seed.word(16); - row[layout.auxiliaries + 13] = v_21; - row[layout.selectors + 4] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 8] = (v_11 <= 5ULL ? inverse_443_3[v_11] : inverse(goldilocks_sub(v_11, 5ULL))); - const uint64_t v_22 = seed.word(13); - row[layout.auxiliaries + 9] = v_22; - uint64_t v_25; - switch (v_22) { - case 0ULL: { - row[layout.selectors + 5] = 1; - v_25 = v_1; - goto continuation_4; - } - default: { - row[layout.auxiliaries + 10] = (v_22 <= 0ULL ? inverse_443_5[v_22] : inverse(goldilocks_sub(v_22, 0ULL))); - const uint64_t v_24 = seed.word(14); - row[layout.auxiliaries + 11] = v_24; - row[layout.selectors + 6] = 1; - v_25 = v_24; - goto continuation_4; - } - } - continuation_4:; - row[layout.auxiliaries + 12] = v_25; - const uint64_t v_26 = seed.word(15); - row[layout.auxiliaries + 13] = v_26; - const uint64_t v_27 = seed.word(16); - const uint64_t v_28 = seed.word(17); - const uint64_t v_29 = seed.word(18); - const uint64_t v_30 = seed.word(19); - row[layout.auxiliaries + 14] = v_27; - row[layout.auxiliaries + 15] = v_28; - row[layout.auxiliaries + 16] = v_29; - row[layout.auxiliaries + 17] = v_30; - switch (v_27) { - case 5ULL: { - const uint64_t v_33 = seed.word(20); - row[layout.auxiliaries + 18] = v_33; - const uint64_t v_34 = seed.word(21); - row[layout.auxiliaries + 19] = v_34; - const uint64_t v_35 = seed.word(22); - row[layout.auxiliaries + 20] = v_35; - row[layout.selectors + 7] = 1; - return 0; - } - default: { - return 2; - } - } - } - } - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_443(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 ? 128 : 184; - const Seed_ixvm_443 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_443(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_443(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_443<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_443<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_443(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 < 5 || auxiliaries < selectors || auxiliaries - selectors < 8 || width < auxiliaries || width - auxiliaries < 21) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 128 : encoding == 0 ? 184 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_443); -} - -template struct Seed_ixvm_462 { - 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_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_u64(data + 72); - case 11: return load_u64(data + 80); - case 12: return load_u64(data + 88); - case 13: return load_u64(data + 96); - case 14: return load_u64(data + 104); - case 15: return load_u64(data + 112); - case 16: return load_u64(data + 120); - case 17: return load_u64(data + 128); - case 18: return load_u64(data + 136); - case 19: return load_u64(data + 144); - case 20: return load_u64(data + 152); - case 21: return load_u64(data + 160); - case 22: return load_u64(data + 168); - case 23: return load_u64(data + 176); - case 24: return load_u64(data + 184); - case 25: return load_u64(data + 192); - case 26: return load_u64(data + 200); - case 27: return load_u64(data + 208); - case 28: return load_u64(data + 216); - case 29: return load_u64(data + 224); - case 30: return load_u64(data + 232); - case 31: return load_u64(data + 240); - case 32: return load_u64(data + 248); - case 33: return load_u64(data + 256); - case 34: return load_u32(data + 364); - case 35: return load_u32(data + 368); - case 36: return load_u32(data + 372); - case 37: return load_u8(data + 424); - case 38: return load_u32(data + 376); - case 39: return load_u8(data + 425); - case 40: return load_u32(data + 380); - case 41: return load_u8(data + 426); - case 42: return load_u32(data + 384); - case 43: return load_u8(data + 427); - case 44: return load_u64(data + 264); - case 45: return load_u8(data + 428); - case 46: return load_u8(data + 429); - case 47: return load_u64(data + 272); - case 48: return load_u32(data + 388); - case 49: return load_u32(data + 392); - case 50: return load_u32(data + 396); - 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_u64(data + 320); - case 57: return load_u64(data + 328); - case 58: return load_u32(data + 400); - case 59: return load_u8(data + 430); - case 60: return load_u64(data + 336); - case 61: return load_u8(data + 431); - case 62: return load_u8(data + 432); - case 63: return load_u64(data + 344); - case 64: return load_u32(data + 404); - case 65: return load_u32(data + 408); - case 66: return load_u32(data + 412); - case 67: return load_u64(data + 352); - case 68: return load_u32(data + 416); - case 69: return load_u8(data + 433); - case 70: return load_u8(data + 434); - case 71: return load_u8(data + 435); - case 72: return load_u32(data + 420); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_462(Seed_ixvm_462 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); - 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); - 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); - 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); - 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; - row[layout.auxiliaries + 11] = v_11; - row[layout.auxiliaries + 12] = v_12; - row[layout.auxiliaries + 13] = v_13; - row[layout.auxiliaries + 14] = v_14; - row[layout.auxiliaries + 15] = v_15; - row[layout.auxiliaries + 16] = v_16; - row[layout.auxiliaries + 17] = v_17; - row[layout.auxiliaries + 18] = v_18; - row[layout.auxiliaries + 19] = v_19; - row[layout.auxiliaries + 20] = v_20; - row[layout.auxiliaries + 21] = v_21; - row[layout.auxiliaries + 22] = v_22; - row[layout.auxiliaries + 23] = v_23; - row[layout.auxiliaries + 24] = v_24; - row[layout.auxiliaries + 25] = v_25; - row[layout.auxiliaries + 26] = v_26; - row[layout.auxiliaries + 27] = v_27; - row[layout.auxiliaries + 28] = v_28; - row[layout.auxiliaries + 29] = v_29; - row[layout.auxiliaries + 30] = v_30; - row[layout.auxiliaries + 31] = v_31; - row[layout.auxiliaries + 32] = v_32; - const uint64_t v_34 = seed.word(34); - const uint64_t v_35 = seed.word(35); - row[layout.auxiliaries + 33] = v_34; - row[layout.auxiliaries + 34] = v_35; - const uint64_t v_36 = seed.word(36); - row[layout.auxiliaries + 35] = v_36; - const uint64_t v_37 = seed.word(37); - const uint64_t v_38 = seed.word(38); - row[layout.auxiliaries + 36] = v_37; - row[layout.auxiliaries + 37] = v_38; - const uint64_t v_40 = seed.word(39); - const uint64_t v_41 = seed.word(40); - row[layout.auxiliaries + 38] = v_40; - row[layout.auxiliaries + 39] = v_41; - const uint64_t v_43 = seed.word(41); - const uint64_t v_44 = seed.word(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_49 = seed.word(45); - const uint64_t v_50 = seed.word(46); - const uint64_t v_51 = seed.word(47); - const uint64_t v_52 = seed.word(48); - const uint64_t v_53 = seed.word(49); - const uint64_t v_54 = seed.word(50); - const uint64_t v_55 = seed.word(51); - const uint64_t v_56 = seed.word(52); - const uint64_t v_57 = seed.word(53); - const uint64_t v_58 = seed.word(54); - const uint64_t v_59 = seed.word(55); - const uint64_t v_60 = seed.word(56); - const uint64_t v_61 = seed.word(57); - const uint64_t v_62 = seed.word(58); - 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; - row[layout.auxiliaries + 52] = v_57; - row[layout.auxiliaries + 53] = v_58; - row[layout.auxiliaries + 54] = v_59; - row[layout.auxiliaries + 55] = v_60; - row[layout.auxiliaries + 56] = v_61; - row[layout.auxiliaries + 57] = v_62; - const uint64_t v_63 = seed.word(59); - const uint64_t v_64 = seed.word(60); - row[layout.auxiliaries + 58] = v_63; - row[layout.auxiliaries + 59] = v_64; - const uint64_t v_65 = seed.word(61); - const uint64_t v_66 = seed.word(62); - const uint64_t v_67 = seed.word(63); - const uint64_t v_68 = seed.word(64); - const uint64_t v_69 = seed.word(65); - const uint64_t v_70 = seed.word(66); - const uint64_t v_71 = seed.word(67); - const uint64_t v_72 = seed.word(68); - row[layout.auxiliaries + 60] = v_65; - row[layout.auxiliaries + 61] = v_66; - row[layout.auxiliaries + 62] = v_67; - row[layout.auxiliaries + 63] = v_68; - row[layout.auxiliaries + 64] = v_69; - row[layout.auxiliaries + 65] = v_70; - row[layout.auxiliaries + 66] = v_71; - row[layout.auxiliaries + 67] = v_72; - const uint64_t v_73 = seed.word(69); - const uint64_t v_74 = seed.word(70); - const uint64_t v_75 = seed.word(71); - row[layout.auxiliaries + 68] = v_73; - row[layout.auxiliaries + 69] = v_74; - row[layout.auxiliaries + 70] = v_75; - const uint64_t v_76 = seed.word(72); - row[layout.auxiliaries + 71] = v_76; - row[layout.selectors + 0] = 1; - return 0; -} -template __global__ void kernel_ixvm_462(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 ? 440 : 584; - const Seed_ixvm_462 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_462(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_462(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_462<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_462<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_462(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 < 72) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 440 : encoding == 0 ? 584 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_462); -} - -__device__ __constant__ uint64_t inverse_463_0[] = {0ULL}; -template struct Seed_ixvm_463 { - 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 + 264); - 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 + 265); - case 11: return load_u8(data + 266); - case 12: return load_u64(data + 72); - case 13: return load_u32(data + 192); - case 14: return load_u32(data + 196); - case 15: return load_u32(data + 200); - case 16: return load_u8(data + 267); - case 17: return load_u64(data + 80); - case 18: return load_u32(data + 204); - case 19: return load_u64(data + 88); - case 20: return load_u32(data + 208); - case 21: return load_u32(data + 212); - case 22: return load_u32(data + 216); - case 23: return load_u32(data + 220); - case 24: return load_u32(data + 224); - case 25: return load_u32(data + 228); - case 26: return load_u32(data + 232); - case 27: return load_u64(data + 96); - case 28: return load_u8(data + 268); - case 29: return load_u8(data + 269); - case 30: return load_u8(data + 270); - case 31: return load_u64(data + 104); - case 32: return load_u64(data + 112); - case 33: return load_u32(data + 236); - case 34: return load_u32(data + 240); - case 35: return load_u8(data + 271); - case 36: return load_u8(data + 272); - case 37: return load_u64(data + 120); - case 38: return load_u32(data + 244); - case 39: return load_u32(data + 248); - case 40: return load_u32(data + 252); - case 41: return load_u64(data + 128); - case 42: return load_u64(data + 136); - case 43: return load_u64(data + 144); - case 44: return load_u64(data + 152); - case 45: return load_u64(data + 160); - case 46: return load_u64(data + 168); - case 47: return load_u64(data + 176); - case 48: return load_u64(data + 184); - case 49: return load_u32(data + 256); - case 50: return load_u32(data + 260); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_463(Seed_ixvm_463 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; - switch (v_1) { - case 0ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 1] = (v_1 <= 0ULL ? inverse_463_0[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); - const uint64_t v_10 = (v_1 >> 1); - row[layout.auxiliaries + 2] = v_10; - const uint64_t v_11 = seed.word(10); - const uint64_t v_12 = seed.word(11); - const uint64_t v_13 = seed.word(12); - 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); - const uint64_t v_22 = seed.word(21); - const uint64_t v_23 = seed.word(22); - const uint64_t v_24 = seed.word(23); - 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; - const uint64_t v_25 = seed.word(24); - const uint64_t v_26 = seed.word(25); - row[layout.auxiliaries + 17] = v_25; - row[layout.auxiliaries + 18] = v_26; - const uint64_t v_27 = 103ULL; - if (v_25 > 0xffffffffULL || v_27 > 0xffffffffULL) return 3; - const uint32_t op_5 = uint32_t(v_25) - uint32_t(v_27); - const uint64_t v_28 = uint64_t(v_25 < v_27); - row[layout.auxiliaries + 19] = (v_25 & 0xffffULL); - row[layout.auxiliaries + 20] = ((v_25 >> 16) & 0xffffULL); - row[layout.auxiliaries + 21] = (uint64_t(op_5) & 0xffffULL); - row[layout.auxiliaries + 22] = ((uint64_t(op_5) >> 16) & 0xffffULL); - row[layout.auxiliaries + 23] = (v_27 & 0xffffULL); - row[layout.auxiliaries + 24] = ((v_27 >> 16) & 0xffffULL); - if (v_25 > 0xffffffffULL || v_23 > 0xffffffffULL) return 3; - const uint32_t op_8 = uint32_t(v_25) - uint32_t(v_23); - const uint64_t v_30 = uint64_t(v_25 < v_23); - row[layout.auxiliaries + 25] = (v_25 & 0xffffULL); - row[layout.auxiliaries + 26] = ((v_25 >> 16) & 0xffffULL); - row[layout.auxiliaries + 27] = (uint64_t(op_8) & 0xffffULL); - row[layout.auxiliaries + 28] = ((uint64_t(op_8) >> 16) & 0xffffULL); - row[layout.auxiliaries + 29] = (v_23 & 0xffffULL); - row[layout.auxiliaries + 30] = ((v_23 >> 16) & 0xffffULL); - const uint64_t v_32 = seed.word(26); - const uint64_t v_33 = seed.word(27); - row[layout.auxiliaries + 31] = v_32; - row[layout.auxiliaries + 32] = v_33; - const uint64_t v_34 = seed.word(28); - row[layout.auxiliaries + 33] = v_34; - const uint64_t v_36 = seed.word(29); - const uint64_t v_37 = seed.word(30); - const uint64_t v_38 = seed.word(31); - const uint64_t v_39 = seed.word(32); - const uint64_t v_40 = seed.word(33); - const uint64_t v_41 = seed.word(34); - row[layout.auxiliaries + 34] = v_36; - row[layout.auxiliaries + 35] = v_37; - row[layout.auxiliaries + 36] = v_38; - row[layout.auxiliaries + 37] = v_39; - row[layout.auxiliaries + 38] = v_40; - row[layout.auxiliaries + 39] = v_41; - const uint64_t v_44 = seed.word(35); - const uint64_t v_45 = seed.word(36); - const uint64_t v_46 = seed.word(37); - const uint64_t v_47 = seed.word(38); - const uint64_t v_48 = seed.word(39); - const uint64_t v_49 = seed.word(40); - const uint64_t v_50 = seed.word(41); - const uint64_t v_51 = seed.word(42); - const uint64_t v_52 = seed.word(43); - const uint64_t v_53 = seed.word(44); - const uint64_t v_54 = seed.word(45); - const uint64_t v_55 = seed.word(46); - const uint64_t v_56 = seed.word(47); - const uint64_t v_57 = seed.word(48); - row[layout.auxiliaries + 40] = v_44; - row[layout.auxiliaries + 41] = v_45; - row[layout.auxiliaries + 42] = v_46; - row[layout.auxiliaries + 43] = v_47; - row[layout.auxiliaries + 44] = v_48; - row[layout.auxiliaries + 45] = v_49; - row[layout.auxiliaries + 46] = v_50; - row[layout.auxiliaries + 47] = v_51; - row[layout.auxiliaries + 48] = v_52; - row[layout.auxiliaries + 49] = v_53; - row[layout.auxiliaries + 50] = v_54; - row[layout.auxiliaries + 51] = v_55; - row[layout.auxiliaries + 52] = v_56; - row[layout.auxiliaries + 53] = v_57; - const uint64_t v_58 = seed.word(49); - row[layout.auxiliaries + 54] = v_58; - const uint64_t v_59 = seed.word(50); - row[layout.auxiliaries + 55] = v_59; - row[layout.selectors + 1] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_463(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 ? 280 : 408; - const Seed_ixvm_463 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_463(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_463(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_463<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_463<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_463(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 < 56) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 280 : encoding == 0 ? 408 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_463); -} - -__device__ __constant__ uint64_t inverse_464_0[] = {0ULL}; -template struct Seed_ixvm_464 { - 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 + 128); - case 3: return load_u64(data + 16); - case 4: return load_u8(data + 129); - case 5: return load_u8(data + 130); - case 6: return load_u64(data + 24); - case 7: return load_u32(data + 72); - case 8: return load_u32(data + 76); - case 9: return load_u32(data + 80); - case 10: return load_u32(data + 84); - case 11: return load_u32(data + 88); - case 12: return load_u32(data + 92); - case 13: return load_u32(data + 96); - case 14: return load_u64(data + 32); - case 15: return load_u32(data + 100); - case 16: return load_u32(data + 104); - case 17: return load_u64(data + 40); - case 18: return load_u8(data + 131); - case 19: return load_u8(data + 132); - case 20: return load_u64(data + 48); - case 21: return load_u32(data + 108); - case 22: return load_u32(data + 112); - case 23: return load_u32(data + 116); - case 24: return load_u64(data + 56); - case 25: return load_u64(data + 64); - case 26: return load_u32(data + 120); - case 27: return load_u32(data + 124); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_464(Seed_ixvm_464 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_464_0[v_1] : inverse(goldilocks_sub(v_1, 0ULL))); - const uint64_t v_4 = (v_1 >> 1); - 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); - 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); - const uint64_t v_12 = seed.word(11); - 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; - const uint64_t v_13 = seed.word(12); - const uint64_t v_14 = seed.word(13); - row[layout.auxiliaries + 11] = v_13; - row[layout.auxiliaries + 12] = v_14; - const uint64_t v_15 = 103ULL; - if (v_13 > 0xffffffffULL || v_15 > 0xffffffffULL) return 3; - const uint32_t op_5 = uint32_t(v_13) - uint32_t(v_15); - const uint64_t v_16 = uint64_t(v_13 < v_15); - row[layout.auxiliaries + 13] = (v_13 & 0xffffULL); - row[layout.auxiliaries + 14] = ((v_13 >> 16) & 0xffffULL); - row[layout.auxiliaries + 15] = (uint64_t(op_5) & 0xffffULL); - row[layout.auxiliaries + 16] = ((uint64_t(op_5) >> 16) & 0xffffULL); - row[layout.auxiliaries + 17] = (v_15 & 0xffffULL); - row[layout.auxiliaries + 18] = ((v_15 >> 16) & 0xffffULL); - if (v_13 > 0xffffffffULL || v_11 > 0xffffffffULL) return 3; - const uint32_t op_8 = uint32_t(v_13) - uint32_t(v_11); - const uint64_t v_18 = uint64_t(v_13 < v_11); - row[layout.auxiliaries + 19] = (v_13 & 0xffffULL); - row[layout.auxiliaries + 20] = ((v_13 >> 16) & 0xffffULL); - row[layout.auxiliaries + 21] = (uint64_t(op_8) & 0xffffULL); - row[layout.auxiliaries + 22] = ((uint64_t(op_8) >> 16) & 0xffffULL); - row[layout.auxiliaries + 23] = (v_11 & 0xffffULL); - row[layout.auxiliaries + 24] = ((v_11 >> 16) & 0xffffULL); - const uint64_t v_20 = seed.word(14); - const uint64_t v_21 = seed.word(15); - row[layout.auxiliaries + 25] = v_20; - row[layout.auxiliaries + 26] = v_21; - const uint64_t v_22 = seed.word(16); - const uint64_t v_23 = seed.word(17); - row[layout.auxiliaries + 27] = v_22; - row[layout.auxiliaries + 28] = v_23; - const uint64_t v_27 = seed.word(18); - const uint64_t v_28 = seed.word(19); - const uint64_t v_29 = seed.word(20); - const uint64_t v_30 = seed.word(21); - const uint64_t v_31 = seed.word(22); - const uint64_t v_32 = seed.word(23); - const uint64_t v_33 = seed.word(24); - const uint64_t v_34 = seed.word(25); - row[layout.auxiliaries + 29] = v_27; - row[layout.auxiliaries + 30] = v_28; - row[layout.auxiliaries + 31] = v_29; - row[layout.auxiliaries + 32] = v_30; - row[layout.auxiliaries + 33] = v_31; - row[layout.auxiliaries + 34] = v_32; - row[layout.auxiliaries + 35] = v_33; - row[layout.auxiliaries + 36] = v_34; - const uint64_t v_35 = seed.word(26); - row[layout.auxiliaries + 37] = v_35; - const uint64_t v_36 = seed.word(27); - row[layout.auxiliaries + 38] = v_36; - row[layout.selectors + 1] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_464(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 : 224; - const Seed_ixvm_464 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_464(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_464(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_464<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_464<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_464(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 < 39) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 136 : encoding == 0 ? 224 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_464); -} - -template struct Seed_ixvm_477 { - 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_u64(data + 16); - case 4: return load_u64(data + 24); - case 5: return load_u64(data + 32); - case 6: return load_u32(data + 100); - case 7: return load_u32(data + 104); - case 8: return load_u32(data + 108); - case 9: return load_u64(data + 40); - case 10: return load_u64(data + 48); - case 11: return load_u64(data + 56); - 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_u8(data + 124); - case 16: return load_u8(data + 125); - case 17: return load_u64(data + 88); - case 18: return load_u32(data + 112); - case 19: return load_u32(data + 116); - case 20: return load_u32(data + 120); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_477(Seed_ixvm_477 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); - 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); - const uint64_t v_17 = seed.word(18); - const uint64_t v_18 = seed.word(19); - const uint64_t v_19 = seed.word(20); - 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; - row[layout.auxiliaries + 11] = v_11; - row[layout.auxiliaries + 12] = v_12; - row[layout.auxiliaries + 13] = v_13; - row[layout.auxiliaries + 14] = v_14; - row[layout.auxiliaries + 15] = v_15; - row[layout.auxiliaries + 16] = v_16; - row[layout.auxiliaries + 17] = v_17; - row[layout.auxiliaries + 18] = v_18; - row[layout.auxiliaries + 19] = v_19; - switch (v_1) { - default: { - row[layout.selectors + 0] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_477(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 ? 128 : 168; - const Seed_ixvm_477 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_477(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_477(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_477<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_477<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_477(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 < 20) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 128 : encoding == 0 ? 168 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_477); -} - -__device__ __constant__ uint64_t inverse_576_0[] = {0ULL}; -template struct Seed_ixvm_576 { - 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_576(Seed_ixvm_576 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_576_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_576(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_576 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_576(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_576(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_576<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_576<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_576(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_576); -} - -__device__ __constant__ uint64_t inverse_614_0[] = {9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -__device__ __constant__ uint64_t inverse_614_1[] = {3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -__device__ __constant__ uint64_t inverse_614_2[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_614 { - 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 + 136); - 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_u64(data + 80); - case 12: return load_u64(data + 88); - case 13: return load_u32(data + 140); - case 14: return load_u8(data + 160); - case 15: return load_u32(data + 144); - case 16: return load_u64(data + 96); - case 17: return load_u64(data + 104); - case 18: return load_u32(data + 148); - case 19: return load_u32(data + 152); - case 20: return load_u8(data + 161); - 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_u32(data + 156); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_614(Seed_ixvm_614 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; - switch (v_0) { - case 7ULL: { - const uint64_t v_15 = seed.word(13); - row[layout.auxiliaries + 1] = v_15; - 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); - row[layout.auxiliaries + 2] = v_16; - row[layout.auxiliaries + 3] = v_17; - row[layout.auxiliaries + 4] = v_18; - row[layout.auxiliaries + 5] = v_19; - switch (v_16) { - case 5ULL: { - const uint64_t v_20 = seed.word(18); - const uint64_t v_21 = seed.word(19); - row[layout.auxiliaries + 6] = v_20; - row[layout.auxiliaries + 7] = v_21; - 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); - row[layout.auxiliaries + 8] = v_22; - row[layout.auxiliaries + 9] = v_23; - row[layout.auxiliaries + 10] = v_24; - row[layout.auxiliaries + 11] = v_25; - switch (v_22) { - case 2ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 12] = (v_22 <= 2ULL ? inverse_614_0[v_22] : inverse(goldilocks_sub(v_22, 2ULL))); - const uint64_t v_27 = seed.word(24); - row[layout.auxiliaries + 13] = v_27; - row[layout.selectors + 1] = 1; - return 0; - } - } - } - default: { - row[layout.auxiliaries + 6] = (v_16 <= 5ULL ? inverse_614_1[v_16] : inverse(goldilocks_sub(v_16, 5ULL))); - const uint64_t v_29 = seed.word(18); - row[layout.auxiliaries + 7] = v_29; - row[layout.selectors + 2] = 1; - return 0; - } - } - } - default: { - row[layout.auxiliaries + 1] = (v_0 <= 7ULL ? inverse_614_2[v_0] : inverse(goldilocks_sub(v_0, 7ULL))); - const uint64_t v_31 = seed.word(13); - row[layout.auxiliaries + 2] = v_31; - row[layout.selectors + 3] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_614(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 ? 168 : 200; - const Seed_ixvm_614 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_614(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_614(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_614<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_614<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_614(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 < 4 || width < auxiliaries || width - auxiliaries < 14) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 168 : encoding == 0 ? 200 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_614); -} - -__device__ __constant__ uint64_t inverse_620_0[] = {18446744069414584320ULL, 0ULL}; -__device__ __constant__ uint64_t inverse_620_1[] = {18446744069414584320ULL, 0ULL}; -__device__ __constant__ uint64_t inverse_620_2[] = {18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_620 { - 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 + 48); - case 5: return load_u32(data + 36); - case 6: return load_u64(data + 8); - case 7: return load_u32(data + 40); - case 8: return load_u64(data + 16); - case 9: return load_u32(data + 44); - case 10: return load_u8(data + 49); - case 11: return load_u8(data + 50); - case 12: return load_u8(data + 51); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_620(Seed_ixvm_620 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); - 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; - switch (v_3) { - case 1ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - case 0ULL: { - switch (v_5) { - case 1ULL: { - const uint64_t v_10 = seed.word(10); - row[layout.auxiliaries + 7] = v_10; - switch (v_10) { - case 1ULL: { - const uint64_t v_11 = seed.word(11); - row[layout.auxiliaries + 8] = v_11; - switch (v_11) { - case 1ULL: { - row[layout.selectors + 1] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 9] = (v_11 <= 1ULL ? inverse_620_0[v_11] : inverse(goldilocks_sub(v_11, 1ULL))); - const uint64_t v_13 = seed.word(12); - row[layout.auxiliaries + 10] = v_13; - row[layout.selectors + 2] = 1; - return 0; - } - } - } - default: { - row[layout.auxiliaries + 8] = (v_10 <= 1ULL ? inverse_620_1[v_10] : inverse(goldilocks_sub(v_10, 1ULL))); - const uint64_t v_14 = seed.word(11); - row[layout.auxiliaries + 9] = v_14; - row[layout.selectors + 3] = 1; - return 0; - } - } - } - default: { - row[layout.auxiliaries + 7] = (v_5 <= 1ULL ? inverse_620_2[v_5] : inverse(goldilocks_sub(v_5, 1ULL))); - const uint64_t v_15 = seed.word(10); - row[layout.auxiliaries + 8] = v_15; - row[layout.selectors + 4] = 1; - return 0; - } - } - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_620(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 : 104; - const Seed_ixvm_620 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_620(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_620(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_620<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_620<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_620(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 < 11) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 56 : encoding == 0 ? 104 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_620); -} - -__device__ __constant__ uint64_t inverse_627_1[] = {2305843008676823040ULL, 15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -__device__ __constant__ uint64_t inverse_627_3[] = {2305843008676823040ULL, 15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -__device__ __constant__ uint64_t inverse_627_4[] = {3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -__device__ __constant__ uint64_t inverse_627_5[] = {0ULL}; -template struct Seed_ixvm_627 { - 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 + 400); - case 2: return load_u8(data + 401); - case 3: return load_u64(data + 8); - case 4: return load_u8(data + 402); - case 5: return load_u32(data + 328); - case 6: return load_u64(data + 16); - case 7: return load_u64(data + 24); - case 8: return load_u64(data + 32); - case 9: return load_u8(data + 403); - case 10: return load_u8(data + 404); - case 11: return load_u8(data + 405); - case 12: return load_u8(data + 406); - 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_u64(data + 64); - case 17: return load_u8(data + 407); - case 18: return load_u8(data + 408); - case 19: return load_u8(data + 409); - case 20: return load_u8(data + 410); - case 21: return load_u32(data + 332); - case 22: return load_u8(data + 411); - case 23: return load_u64(data + 72); - case 24: return load_u64(data + 80); - case 25: return load_u8(data + 412); - case 26: return load_u8(data + 413); - case 27: return load_u8(data + 414); - case 28: return load_u8(data + 415); - case 29: return load_u8(data + 416); - case 30: return load_u8(data + 417); - case 31: return load_u64(data + 88); - case 32: return load_u64(data + 96); - 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_u8(data + 422); - case 38: return load_u8(data + 423); - case 39: return load_u64(data + 104); - case 40: return load_u64(data + 112); - 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_u64(data + 120); - case 48: return load_u32(data + 336); - case 49: return load_u32(data + 340); - case 50: return load_u32(data + 344); - case 51: return load_u32(data + 348); - case 52: return load_u8(data + 430); - case 53: return load_u8(data + 431); - case 54: return load_u32(data + 352); - case 55: return load_u64(data + 128); - case 56: return load_u64(data + 136); - case 57: return load_u64(data + 144); - case 58: return load_u8(data + 432); - case 59: return load_u8(data + 433); - case 60: return load_u8(data + 434); - case 61: return load_u8(data + 435); - case 62: return load_u64(data + 152); - case 63: return load_u64(data + 160); - case 64: return load_u64(data + 168); - case 65: return load_u64(data + 176); - case 66: return load_u8(data + 436); - case 67: return load_u8(data + 437); - case 68: return load_u8(data + 438); - case 69: return load_u8(data + 439); - case 70: return load_u32(data + 356); - case 71: return load_u8(data + 440); - case 72: return load_u64(data + 184); - case 73: return load_u64(data + 192); - case 74: return load_u8(data + 441); - case 75: return load_u8(data + 442); - case 76: return load_u8(data + 443); - case 77: return load_u8(data + 444); - case 78: return load_u8(data + 445); - case 79: return load_u8(data + 446); - case 80: return load_u64(data + 200); - case 81: return load_u64(data + 208); - case 82: return load_u8(data + 447); - case 83: return load_u8(data + 448); - case 84: return load_u8(data + 449); - case 85: return load_u8(data + 450); - case 86: return load_u8(data + 451); - case 87: return load_u8(data + 452); - case 88: return load_u64(data + 216); - case 89: return load_u64(data + 224); - case 90: return load_u8(data + 453); - case 91: return load_u8(data + 454); - case 92: return load_u8(data + 455); - case 93: return load_u8(data + 456); - case 94: return load_u8(data + 457); - case 95: return load_u8(data + 458); - case 96: return load_u64(data + 232); - case 97: return load_u32(data + 360); - case 98: return load_u32(data + 364); - case 99: return load_u32(data + 368); - case 100: return load_u32(data + 372); - case 101: return load_u32(data + 376); - case 102: return load_u8(data + 459); - case 103: return load_u64(data + 240); - case 104: return load_u32(data + 380); - case 105: return load_u64(data + 248); - case 106: return load_u64(data + 256); - case 107: return load_u64(data + 264); - case 108: return load_u64(data + 272); - case 109: return load_u64(data + 280); - case 110: return load_u64(data + 288); - case 111: return load_u64(data + 296); - case 112: return load_u64(data + 304); - case 113: return load_u64(data + 312); - case 114: return load_u32(data + 384); - case 115: return load_u32(data + 388); - case 116: return load_u32(data + 392); - case 117: return load_u32(data + 396); - case 118: return load_u8(data + 460); - case 119: return load_u64(data + 320); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_627(Seed_ixvm_627 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); - 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); - 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); - 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); - 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; - row[layout.auxiliaries + 11] = v_13; - row[layout.auxiliaries + 12] = v_14; - row[layout.auxiliaries + 13] = v_15; - row[layout.auxiliaries + 14] = v_16; - row[layout.auxiliaries + 15] = v_17; - row[layout.auxiliaries + 16] = v_18; - row[layout.auxiliaries + 17] = v_19; - row[layout.auxiliaries + 18] = v_20; - row[layout.auxiliaries + 19] = v_21; - row[layout.auxiliaries + 20] = v_22; - row[layout.auxiliaries + 21] = v_23; - row[layout.auxiliaries + 22] = v_24; - row[layout.auxiliaries + 23] = v_25; - row[layout.auxiliaries + 24] = v_26; - row[layout.auxiliaries + 25] = v_27; - row[layout.auxiliaries + 26] = v_28; - row[layout.auxiliaries + 27] = v_29; - row[layout.auxiliaries + 28] = v_30; - row[layout.auxiliaries + 29] = v_31; - row[layout.auxiliaries + 30] = v_32; - row[layout.auxiliaries + 31] = v_33; - row[layout.auxiliaries + 32] = v_34; - row[layout.auxiliaries + 33] = v_35; - row[layout.auxiliaries + 34] = v_36; - row[layout.auxiliaries + 35] = v_37; - row[layout.auxiliaries + 36] = v_38; - row[layout.auxiliaries + 37] = v_39; - row[layout.auxiliaries + 38] = v_40; - row[layout.auxiliaries + 39] = v_41; - row[layout.auxiliaries + 40] = v_42; - row[layout.auxiliaries + 41] = v_43; - row[layout.auxiliaries + 42] = v_44; - row[layout.auxiliaries + 43] = v_45; - row[layout.auxiliaries + 44] = v_46; - row[layout.auxiliaries + 45] = v_47; - row[layout.auxiliaries + 46] = v_48; - row[layout.auxiliaries + 47] = v_49; - row[layout.auxiliaries + 48] = v_50; - uint64_t v_53; - switch (v_3) { - default: { - switch (v_3) { - case 8ULL: { - const uint64_t v_52 = seed.word(52); - row[layout.auxiliaries + 49] = v_52; - row[layout.selectors + 0] = 1; - v_53 = v_52; - goto continuation_0; - } - default: { - row[layout.auxiliaries + 49] = (v_3 <= 8ULL ? inverse_627_1[v_3] : inverse(goldilocks_sub(v_3, 8ULL))); - row[layout.selectors + 1] = 1; - v_53 = v_1; - goto continuation_0; - } - } - } - } - continuation_0:; - row[layout.auxiliaries + 50] = v_53; - const uint64_t v_54 = seed.word(53); - const uint64_t v_55 = seed.word(54); - const uint64_t v_56 = seed.word(55); - const uint64_t v_57 = seed.word(56); - const uint64_t v_58 = seed.word(57); - const uint64_t v_59 = seed.word(58); - const uint64_t v_60 = seed.word(59); - const uint64_t v_61 = seed.word(60); - const uint64_t v_62 = seed.word(61); - const uint64_t v_63 = seed.word(62); - const uint64_t v_64 = seed.word(63); - const uint64_t v_65 = seed.word(64); - const uint64_t v_66 = seed.word(65); - const uint64_t v_67 = seed.word(66); - const uint64_t v_68 = seed.word(67); - const uint64_t v_69 = seed.word(68); - const uint64_t v_70 = seed.word(69); - const uint64_t v_71 = seed.word(70); - const uint64_t v_72 = seed.word(71); - const uint64_t v_73 = seed.word(72); - const uint64_t v_74 = seed.word(73); - const uint64_t v_75 = seed.word(74); - const uint64_t v_76 = seed.word(75); - const uint64_t v_77 = seed.word(76); - const uint64_t v_78 = seed.word(77); - const uint64_t v_79 = seed.word(78); - const uint64_t v_80 = seed.word(79); - const uint64_t v_81 = seed.word(80); - const uint64_t v_82 = seed.word(81); - const uint64_t v_83 = seed.word(82); - const uint64_t v_84 = seed.word(83); - const uint64_t v_85 = seed.word(84); - const uint64_t v_86 = seed.word(85); - const uint64_t v_87 = seed.word(86); - const uint64_t v_88 = seed.word(87); - const uint64_t v_89 = seed.word(88); - const uint64_t v_90 = seed.word(89); - const uint64_t v_91 = seed.word(90); - const uint64_t v_92 = seed.word(91); - const uint64_t v_93 = seed.word(92); - const uint64_t v_94 = seed.word(93); - const uint64_t v_95 = seed.word(94); - const uint64_t v_96 = seed.word(95); - const uint64_t v_97 = seed.word(96); - const uint64_t v_98 = seed.word(97); - const uint64_t v_99 = seed.word(98); - const uint64_t v_100 = seed.word(99); - const uint64_t v_101 = seed.word(100); - row[layout.auxiliaries + 51] = v_54; - row[layout.auxiliaries + 52] = v_55; - row[layout.auxiliaries + 53] = v_56; - row[layout.auxiliaries + 54] = v_57; - row[layout.auxiliaries + 55] = v_58; - row[layout.auxiliaries + 56] = v_59; - row[layout.auxiliaries + 57] = v_60; - row[layout.auxiliaries + 58] = v_61; - row[layout.auxiliaries + 59] = v_62; - row[layout.auxiliaries + 60] = v_63; - row[layout.auxiliaries + 61] = v_64; - row[layout.auxiliaries + 62] = v_65; - row[layout.auxiliaries + 63] = v_66; - row[layout.auxiliaries + 64] = v_67; - row[layout.auxiliaries + 65] = v_68; - row[layout.auxiliaries + 66] = v_69; - row[layout.auxiliaries + 67] = v_70; - row[layout.auxiliaries + 68] = v_71; - row[layout.auxiliaries + 69] = v_72; - row[layout.auxiliaries + 70] = v_73; - row[layout.auxiliaries + 71] = v_74; - row[layout.auxiliaries + 72] = v_75; - row[layout.auxiliaries + 73] = v_76; - row[layout.auxiliaries + 74] = v_77; - row[layout.auxiliaries + 75] = v_78; - row[layout.auxiliaries + 76] = v_79; - row[layout.auxiliaries + 77] = v_80; - row[layout.auxiliaries + 78] = v_81; - row[layout.auxiliaries + 79] = v_82; - row[layout.auxiliaries + 80] = v_83; - row[layout.auxiliaries + 81] = v_84; - row[layout.auxiliaries + 82] = v_85; - row[layout.auxiliaries + 83] = v_86; - row[layout.auxiliaries + 84] = v_87; - row[layout.auxiliaries + 85] = v_88; - row[layout.auxiliaries + 86] = v_89; - row[layout.auxiliaries + 87] = v_90; - row[layout.auxiliaries + 88] = v_91; - row[layout.auxiliaries + 89] = v_92; - row[layout.auxiliaries + 90] = v_93; - row[layout.auxiliaries + 91] = v_94; - row[layout.auxiliaries + 92] = v_95; - row[layout.auxiliaries + 93] = v_96; - row[layout.auxiliaries + 94] = v_97; - row[layout.auxiliaries + 95] = v_98; - row[layout.auxiliaries + 96] = v_99; - row[layout.auxiliaries + 97] = v_100; - row[layout.auxiliaries + 98] = v_101; - uint64_t v_125; - switch (v_54) { - default: { - switch (v_54) { - case 8ULL: { - const uint64_t v_103 = seed.word(101); - row[layout.auxiliaries + 99] = v_103; - row[layout.selectors + 2] = 1; - v_125 = v_103; - goto continuation_2; - } - default: { - row[layout.auxiliaries + 99] = (v_54 <= 8ULL ? inverse_627_3[v_54] : inverse(goldilocks_sub(v_54, 8ULL))); - const uint64_t v_104 = seed.word(101); - row[layout.auxiliaries + 100] = v_104; - const uint64_t v_105 = seed.word(102); - const uint64_t v_106 = seed.word(103); - const uint64_t v_107 = seed.word(104); - const uint64_t v_108 = seed.word(105); - const uint64_t v_109 = seed.word(106); - const uint64_t v_110 = seed.word(107); - const uint64_t v_111 = seed.word(108); - const uint64_t v_112 = seed.word(109); - const uint64_t v_113 = seed.word(110); - const uint64_t v_114 = seed.word(111); - const uint64_t v_115 = seed.word(112); - const uint64_t v_116 = seed.word(113); - row[layout.auxiliaries + 101] = v_105; - row[layout.auxiliaries + 102] = v_106; - row[layout.auxiliaries + 103] = v_107; - row[layout.auxiliaries + 104] = v_108; - row[layout.auxiliaries + 105] = v_109; - row[layout.auxiliaries + 106] = v_110; - row[layout.auxiliaries + 107] = v_111; - row[layout.auxiliaries + 108] = v_112; - row[layout.auxiliaries + 109] = v_113; - row[layout.auxiliaries + 110] = v_114; - row[layout.auxiliaries + 111] = v_115; - row[layout.auxiliaries + 112] = v_116; - switch (v_105) { - case 5ULL: { - const uint64_t v_118 = seed.word(114); - row[layout.auxiliaries + 113] = v_118; - const uint64_t v_120 = seed.word(115); - row[layout.auxiliaries + 114] = v_120; - const uint64_t v_121 = seed.word(116); - row[layout.auxiliaries + 115] = v_121; - const uint64_t v_122 = seed.word(117); - row[layout.auxiliaries + 116] = v_122; - row[layout.selectors + 3] = 1; - v_125 = v_122; - goto continuation_2; - } - default: { - row[layout.auxiliaries + 113] = (v_105 <= 5ULL ? inverse_627_4[v_105] : inverse(goldilocks_sub(v_105, 5ULL))); - const uint64_t v_124 = seed.word(114); - row[layout.auxiliaries + 114] = v_124; - row[layout.selectors + 4] = 1; - v_125 = v_124; - goto continuation_2; - } - } - } - } - } - } - continuation_2:; - row[layout.auxiliaries + 117] = v_125; - const uint64_t v_126 = seed.word(118); - row[layout.auxiliaries + 118] = v_126; - switch (v_126) { - case 0ULL: { - row[layout.selectors + 5] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 119] = (v_126 <= 0ULL ? inverse_627_5[v_126] : inverse(goldilocks_sub(v_126, 0ULL))); - const uint64_t v_127 = seed.word(119); - row[layout.auxiliaries + 120] = v_127; - row[layout.selectors + 6] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_627(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 : 960; - const Seed_ixvm_627 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_627(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_627(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_627<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_627<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_627(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 < 7 || width < auxiliaries || width - auxiliaries < 121) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 464 : encoding == 0 ? 960 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_627); -} - -__device__ __constant__ uint64_t inverse_628_0[] = {2305843008676823040ULL, 15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_628 { - 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 + 168); - case 2: return load_u32(data + 136); - case 3: return load_u64(data + 8); - case 4: return load_u32(data + 140); - case 5: return load_u8(data + 169); - case 6: return load_u32(data + 144); - 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_u8(data + 170); - case 11: return load_u8(data + 171); - case 12: return load_u8(data + 172); - case 13: return load_u8(data + 173); - case 14: return load_u64(data + 40); - case 15: return load_u64(data + 48); - case 16: return load_u64(data + 56); - case 17: return load_u64(data + 64); - case 18: return load_u8(data + 174); - case 19: return load_u8(data + 175); - case 20: return load_u8(data + 176); - case 21: return load_u8(data + 177); - case 22: return load_u32(data + 148); - case 23: return load_u8(data + 178); - case 24: return load_u64(data + 72); - case 25: return load_u64(data + 80); - case 26: return load_u8(data + 179); - case 27: return load_u8(data + 180); - case 28: return load_u8(data + 181); - case 29: return load_u8(data + 182); - case 30: return load_u8(data + 183); - case 31: return load_u8(data + 184); - case 32: return load_u64(data + 88); - case 33: return load_u64(data + 96); - case 34: return load_u8(data + 185); - case 35: return load_u8(data + 186); - case 36: return load_u8(data + 187); - case 37: return load_u8(data + 188); - case 38: return load_u8(data + 189); - case 39: return load_u8(data + 190); - case 40: return load_u64(data + 104); - case 41: return load_u64(data + 112); - case 42: return load_u8(data + 191); - case 43: return load_u8(data + 192); - case 44: return load_u8(data + 193); - case 45: return load_u8(data + 194); - case 46: return load_u8(data + 195); - case 47: return load_u8(data + 196); - case 48: return load_u64(data + 120); - case 49: return load_u32(data + 152); - case 50: return load_u32(data + 156); - case 51: return load_u32(data + 160); - case 52: return load_u32(data + 164); - case 53: return load_u64(data + 128); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_628(Seed_ixvm_628 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); - 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); - 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); - 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); - row[layout.auxiliaries + 1] = v_4; - 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; - 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; - 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; - 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; - row[layout.auxiliaries + 42] = v_45; - row[layout.auxiliaries + 43] = v_46; - row[layout.auxiliaries + 44] = v_47; - row[layout.auxiliaries + 45] = v_48; - row[layout.auxiliaries + 46] = v_49; - row[layout.auxiliaries + 47] = v_50; - row[layout.auxiliaries + 48] = v_51; - switch (v_4) { - default: { - switch (v_4) { - case 8ULL: { - const uint64_t v_53 = seed.word(53); - row[layout.auxiliaries + 49] = v_53; - row[layout.selectors + 0] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 49] = (v_4 <= 8ULL ? inverse_628_0[v_4] : inverse(goldilocks_sub(v_4, 8ULL))); - row[layout.selectors + 1] = 1; - return 0; - } - } - } - } -} -template __global__ void kernel_ixvm_628(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 ? 200 : 432; - const Seed_ixvm_628 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_628(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_628(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_628<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_628<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_628(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 < 50) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 200 : encoding == 0 ? 432 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_628); -} - -__device__ __constant__ uint64_t inverse_679_0[] = {18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_679 { - 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_u64(data + 8); - case 4: return load_u8(data + 52); - case 5: return load_u32(data + 32); - case 6: return load_u32(data + 36); - case 7: return load_u8(data + 53); - case 8: return load_u32(data + 40); - case 9: return load_u32(data + 44); - case 10: return load_u32(data + 48); - case 11: return load_u64(data + 16); - case 12: return load_u8(data + 54); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_679(Seed_ixvm_679 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_7 = seed.word(7); - const uint64_t v_8 = seed.word(8); - const uint64_t v_9 = seed.word(9); - row[layout.auxiliaries + 4] = v_7; - row[layout.auxiliaries + 5] = v_8; - row[layout.auxiliaries + 6] = v_9; - switch (v_7) { - case 1ULL: { - row[layout.selectors + 1] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_12 = seed.word(10); - row[layout.auxiliaries + 7] = v_12; - const uint64_t v_13 = seed.word(11); - row[layout.auxiliaries + 8] = v_13; - switch (v_13) { - case 1ULL: { - const uint64_t v_14 = seed.word(12); - row[layout.auxiliaries + 9] = v_14; - row[layout.selectors + 2] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 9] = (v_13 <= 1ULL ? inverse_679_0[v_13] : inverse(goldilocks_sub(v_13, 1ULL))); - row[layout.selectors + 3] = 1; - return 0; - } - } - } - default: { - return 2; - } - } - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_679(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 : 104; - const Seed_ixvm_679 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_679(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_679(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_679<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_679<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_679(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 < 10) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 56 : encoding == 0 ? 104 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_679); -} - -__device__ __constant__ uint64_t inverse_697_0[] = {0ULL}; -template struct Seed_ixvm_697 { - 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_697(Seed_ixvm_697 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_697_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_697(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_697 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_697(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_697(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_697<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_697<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_697(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_697); -} - -__device__ __constant__ uint64_t inverse_698_1[] = {2305843008676823040ULL, 15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -__device__ __constant__ uint64_t inverse_698_2[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL, 1ULL}; -__device__ __constant__ uint64_t inverse_698_3[] = {3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL, 1ULL, 9223372034707292161ULL}; -__device__ __constant__ uint64_t inverse_698_4[] = {4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL, 1ULL, 9223372034707292161ULL, 12297829379609722881ULL, 13835058052060938241ULL}; -__device__ __constant__ uint64_t inverse_698_5[] = {3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL, 1ULL, 9223372034707292161ULL, 12297829379609722881ULL}; -template struct Seed_ixvm_698 { - 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 + 80); - case 2: return load_u8(data + 124); - case 3: return load_u8(data + 125); - case 4: return load_u32(data + 84); - 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 + 126); - case 9: return load_u8(data + 127); - case 10: return load_u8(data + 128); - case 11: return load_u8(data + 129); - case 12: return load_u8(data + 130); - case 13: return load_u32(data + 88); - case 14: return load_u32(data + 92); - case 15: return load_u32(data + 96); - case 16: return load_u8(data + 131); - case 17: return load_u8(data + 132); - case 18: return load_u8(data + 133); - case 19: return load_u8(data + 134); - case 20: return load_u8(data + 135); - case 21: return load_u8(data + 136); - case 22: return load_u64(data + 32); - case 23: return load_u64(data + 40); - case 24: return load_u8(data + 137); - case 25: return load_u8(data + 138); - case 26: return load_u8(data + 139); - case 27: return load_u8(data + 140); - case 28: return load_u8(data + 141); - case 29: return load_u8(data + 142); - case 30: return load_u64(data + 48); - case 31: return load_u64(data + 56); - case 32: return load_u8(data + 143); - case 33: return load_u8(data + 144); - case 34: return load_u8(data + 145); - case 35: return load_u8(data + 146); - case 36: return load_u8(data + 147); - case 37: return load_u8(data + 148); - case 38: return load_u64(data + 64); - case 39: return load_u64(data + 72); - case 40: return load_u8(data + 149); - case 41: return load_u8(data + 150); - case 42: return load_u8(data + 151); - case 43: return load_u8(data + 152); - case 44: return load_u8(data + 153); - case 45: return load_u8(data + 154); - case 46: return load_u32(data + 100); - case 47: return load_u32(data + 104); - case 48: return load_u32(data + 108); - case 49: return load_u32(data + 112); - case 50: return load_u32(data + 116); - case 51: return load_u32(data + 120); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_698(Seed_ixvm_698 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); - 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); - 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); - 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); - 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; - 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.auxiliaries + 13] = v_14; - row[layout.auxiliaries + 14] = v_15; - row[layout.auxiliaries + 15] = v_16; - row[layout.auxiliaries + 16] = v_17; - row[layout.auxiliaries + 17] = v_18; - row[layout.auxiliaries + 18] = v_19; - row[layout.auxiliaries + 19] = v_20; - row[layout.auxiliaries + 20] = v_21; - row[layout.auxiliaries + 21] = v_22; - row[layout.auxiliaries + 22] = v_23; - row[layout.auxiliaries + 23] = v_24; - row[layout.auxiliaries + 24] = v_25; - row[layout.auxiliaries + 25] = v_26; - row[layout.auxiliaries + 26] = v_27; - row[layout.auxiliaries + 27] = v_28; - row[layout.auxiliaries + 28] = v_29; - row[layout.auxiliaries + 29] = v_30; - row[layout.auxiliaries + 30] = v_31; - row[layout.auxiliaries + 31] = v_32; - row[layout.auxiliaries + 32] = v_33; - row[layout.auxiliaries + 33] = v_34; - row[layout.auxiliaries + 34] = v_35; - row[layout.auxiliaries + 35] = v_36; - row[layout.auxiliaries + 36] = v_37; - row[layout.auxiliaries + 37] = v_38; - row[layout.auxiliaries + 38] = v_39; - row[layout.auxiliaries + 39] = v_40; - row[layout.auxiliaries + 40] = v_41; - row[layout.auxiliaries + 41] = v_42; - row[layout.auxiliaries + 42] = v_43; - row[layout.auxiliaries + 43] = v_44; - row[layout.auxiliaries + 44] = v_45; - row[layout.auxiliaries + 45] = v_46; - row[layout.auxiliaries + 46] = v_47; - row[layout.auxiliaries + 47] = v_48; - row[layout.auxiliaries + 48] = v_49; - switch (v_2) { - default: { - switch (v_2) { - case 8ULL: { - row[layout.selectors + 0] = 1; - goto continuation_0; - } - case 7ULL: { - switch (v_3) { - default: { - row[layout.selectors + 1] = 1; - goto continuation_0; - } - } - } - case 6ULL: { - switch (v_3) { - default: { - row[layout.selectors + 2] = 1; - goto continuation_0; - } - } - } - case 4ULL: { - switch (v_3) { - default: { - row[layout.selectors + 3] = 1; - goto continuation_0; - } - } - } - case 5ULL: { - switch (v_3) { - default: { - row[layout.selectors + 4] = 1; - goto continuation_0; - } - } - } - default: { - row[layout.auxiliaries + 49] = (v_2 <= 8ULL ? inverse_698_1[v_2] : inverse(goldilocks_sub(v_2, 8ULL))); - row[layout.auxiliaries + 50] = (v_2 <= 8ULL ? inverse_698_2[v_2] : inverse(goldilocks_sub(v_2, 7ULL))); - row[layout.auxiliaries + 51] = (v_2 <= 8ULL ? inverse_698_3[v_2] : inverse(goldilocks_sub(v_2, 6ULL))); - row[layout.auxiliaries + 52] = (v_2 <= 8ULL ? inverse_698_4[v_2] : inverse(goldilocks_sub(v_2, 4ULL))); - row[layout.auxiliaries + 53] = (v_2 <= 8ULL ? inverse_698_5[v_2] : inverse(goldilocks_sub(v_2, 5ULL))); - row[layout.selectors + 5] = 1; - goto continuation_0; - } - } - continuation_0:; - const uint64_t v_51 = seed.word(51); - row[layout.auxiliaries + 54] = v_51; - row[layout.selectors + 6] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_698(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 ? 160 : 416; - const Seed_ixvm_698 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_698(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_698(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_698<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_698<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_698(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 < 7 || width < auxiliaries || width - auxiliaries < 55) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 160 : encoding == 0 ? 416 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_698); -} - -__device__ __constant__ uint64_t inverse_699_1[] = {0ULL}; -__device__ __constant__ uint64_t inverse_699_2[] = {18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_699 { - 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); - case 5: return load_u8(data + 36); - case 6: return load_u8(data + 37); - case 7: return load_u32(data + 28); - case 8: return load_u8(data + 38); - case 9: return load_u8(data + 39); - case 10: return load_u32(data + 32); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_699(Seed_ixvm_699 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: { - row[layout.selectors + 0] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_7 = seed.word(8); - row[layout.auxiliaries + 4] = v_7; - switch (v_7) { - case 1ULL: { - const uint64_t v_8 = seed.word(9); - row[layout.auxiliaries + 5] = v_8; - switch (v_8) { - case 0ULL: { - const uint64_t v_9 = seed.word(10); - row[layout.auxiliaries + 6] = v_9; - row[layout.selectors + 1] = 1; - goto continuation_0; - } - default: { - row[layout.auxiliaries + 6] = (v_8 <= 0ULL ? inverse_699_1[v_8] : inverse(goldilocks_sub(v_8, 0ULL))); - row[layout.selectors + 2] = 1; - goto continuation_0; - } - } - } - default: { - row[layout.auxiliaries + 5] = (v_7 <= 1ULL ? inverse_699_2[v_7] : inverse(goldilocks_sub(v_7, 1ULL))); - row[layout.selectors + 3] = 1; - goto continuation_0; - } - } - continuation_0:; - row[layout.selectors + 4] = 1; - return 0; - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_699(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_ixvm_699 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_699(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_699(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_699<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_699<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_699(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 < 5 || width < auxiliaries || width - auxiliaries < 7) 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_ixvm_699); -} - -template struct Seed_ixvm_706 { - 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 + 80); - case 2: return load_u8(data + 116); - case 3: return load_u64(data + 8); - case 4: return load_u32(data + 84); - case 5: return load_u64(data + 16); - case 6: return load_u32(data + 88); - case 7: return load_u32(data + 92); - case 8: return load_u8(data + 117); - case 9: return load_u32(data + 96); - case 10: return load_u32(data + 100); - case 11: return load_u8(data + 118); - case 12: return load_u8(data + 119); - case 13: return load_u32(data + 104); - case 14: return load_u64(data + 24); - case 15: return load_u32(data + 108); - case 16: return load_u32(data + 112); - case 17: return load_u64(data + 32); - case 18: return load_u64(data + 40); - case 19: return load_u64(data + 48); - case 20: return load_u64(data + 56); - case 21: return load_u64(data + 64); - case 22: return load_u64(data + 72); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_706(Seed_ixvm_706 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: { - row[layout.selectors + 0] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_11 = seed.word(11); - const uint64_t v_12 = seed.word(12); - const uint64_t v_13 = seed.word(13); - const uint64_t v_14 = seed.word(14); - const uint64_t v_15 = seed.word(15); - const uint64_t v_16 = seed.word(16); - row[layout.auxiliaries + 4] = v_11; - row[layout.auxiliaries + 5] = v_12; - row[layout.auxiliaries + 6] = v_13; - row[layout.auxiliaries + 7] = v_14; - row[layout.auxiliaries + 8] = v_15; - row[layout.auxiliaries + 9] = v_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); - row[layout.auxiliaries + 10] = v_17; - row[layout.auxiliaries + 11] = v_18; - row[layout.auxiliaries + 12] = v_19; - row[layout.auxiliaries + 13] = v_20; - row[layout.auxiliaries + 14] = v_21; - row[layout.auxiliaries + 15] = v_22; - row[layout.selectors + 1] = 1; - return 0; - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_706(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 : 184; - const Seed_ixvm_706 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_706(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_706(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_706<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_706<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_706(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 < 2 || width < auxiliaries || width - auxiliaries < 16) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 120 : encoding == 0 ? 184 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_706); -} - -__device__ __constant__ uint64_t inverse_709_1[] = {0ULL}; -__device__ __constant__ uint64_t inverse_709_2[] = {18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_709 { - 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_u32(data + 60); - case 3: return load_u32(data + 64); - case 4: return load_u64(data + 8); - case 5: return load_u8(data + 100); - case 6: return load_u64(data + 16); - case 7: return load_u32(data + 68); - case 8: return load_u64(data + 24); - case 9: return load_u32(data + 72); - case 10: return load_u32(data + 76); - case 11: return load_u8(data + 101); - case 12: return load_u64(data + 32); - case 13: return load_u32(data + 80); - case 14: return load_u64(data + 40); - case 15: return load_u32(data + 84); - case 16: return load_u32(data + 88); - case 17: return load_u64(data + 48); - case 18: return load_u8(data + 102); - case 19: return load_u8(data + 103); - case 20: return load_u32(data + 92); - case 21: return load_u8(data + 104); - case 22: return load_u8(data + 105); - case 23: return load_u32(data + 96); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_709(Seed_ixvm_709 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); - row[layout.auxiliaries + 1] = v_17; - row[layout.auxiliaries + 2] = v_18; - row[layout.auxiliaries + 3] = v_19; - switch (v_17) { - case 1ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_20 = seed.word(21); - row[layout.auxiliaries + 4] = v_20; - switch (v_20) { - case 1ULL: { - const uint64_t v_21 = seed.word(22); - row[layout.auxiliaries + 5] = v_21; - switch (v_21) { - case 0ULL: { - const uint64_t v_22 = seed.word(23); - row[layout.auxiliaries + 6] = v_22; - row[layout.selectors + 1] = 1; - goto continuation_0; - } - default: { - row[layout.auxiliaries + 6] = (v_21 <= 0ULL ? inverse_709_1[v_21] : inverse(goldilocks_sub(v_21, 0ULL))); - row[layout.selectors + 2] = 1; - goto continuation_0; - } - } - } - default: { - row[layout.auxiliaries + 5] = (v_20 <= 1ULL ? inverse_709_2[v_20] : inverse(goldilocks_sub(v_20, 1ULL))); - row[layout.selectors + 3] = 1; - goto continuation_0; - } - } - continuation_0:; - row[layout.selectors + 4] = 1; - return 0; - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_709(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 : 192; - const Seed_ixvm_709 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_709(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_709(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_709<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_709<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_709(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 < 5 || width < auxiliaries || width - auxiliaries < 7) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 112 : encoding == 0 ? 192 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_709); -} - -template struct Seed_ixvm_710 { - 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_u32(data + 44); - case 3: return load_u8(data + 76); - case 4: return load_u64(data + 8); - case 5: return load_u32(data + 48); - case 6: return load_u64(data + 16); - case 7: return load_u32(data + 52); - case 8: return load_u32(data + 56); - case 9: return load_u8(data + 77); - case 10: return load_u64(data + 24); - case 11: return load_u32(data + 60); - case 12: return load_u64(data + 32); - case 13: return load_u32(data + 64); - case 14: return load_u32(data + 68); - case 15: return load_u8(data + 78); - case 16: return load_u8(data + 79); - case 17: return load_u32(data + 72); - case 18: return load_u8(data + 80); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_710(Seed_ixvm_710 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); - const uint64_t v_15 = seed.word(16); - const uint64_t v_16 = seed.word(17); - row[layout.auxiliaries + 1] = v_14; - row[layout.auxiliaries + 2] = v_15; - row[layout.auxiliaries + 3] = v_16; - switch (v_14) { - case 1ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_17 = seed.word(18); - row[layout.auxiliaries + 4] = v_17; - row[layout.selectors + 1] = 1; - return 0; - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_710(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 : 152; - const Seed_ixvm_710 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_710(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_710(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_710<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_710<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_710(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 < 14 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 5) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 88 : encoding == 0 ? 152 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_710); -} - -template struct Seed_ixvm_712 { - 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 + 20); - case 4: return load_u8(data + 21); - case 5: return load_u32(data + 16); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_712(Seed_ixvm_712 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: { - row[layout.selectors + 1] = 1; - return 0; - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_712(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 : 48; - const Seed_ixvm_712 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_712(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_712(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_712<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_712<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_712(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 < 4) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 24 : encoding == 0 ? 48 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_712); -} - -__device__ __constant__ uint64_t inverse_724_0[] = {18446744069414584320ULL, 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 + 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_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 + 196); - case 11: return load_u64(data + 72); - case 12: return load_u64(data + 80); - case 13: return load_u8(data + 197); - case 14: return load_u8(data + 198); - case 15: return load_u8(data + 199); - case 16: return load_u8(data + 200); - case 17: return load_u8(data + 201); - case 18: return load_u8(data + 202); - case 19: return load_u64(data + 88); - case 20: return load_u64(data + 96); - case 21: return load_u8(data + 203); - case 22: return load_u8(data + 204); - case 23: return load_u8(data + 205); - case 24: return load_u8(data + 206); - case 25: return load_u8(data + 207); - case 26: return load_u8(data + 208); - case 27: return load_u32(data + 180); - case 28: return load_u32(data + 184); - case 29: return load_u64(data + 104); - case 30: return load_u64(data + 112); - case 31: return load_u64(data + 120); - case 32: return load_u64(data + 128); - case 33: return load_u64(data + 136); - case 34: return load_u64(data + 144); - case 35: return load_u64(data + 152); - case 36: return load_u64(data + 160); - case 37: return load_u32(data + 188); - case 38: return load_u64(data + 168); - case 39: return load_u32(data + 192); - 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); - 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; - } - default: { - row[layout.auxiliaries + 2] = (v_9 <= 1ULL ? inverse_724_0[v_9] : inverse(goldilocks_sub(v_9, 1ULL))); - const uint64_t v_12 = seed.word(11); - const uint64_t v_13 = seed.word(12); - 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); - const uint64_t v_22 = seed.word(21); - const uint64_t v_23 = seed.word(22); - const uint64_t v_24 = seed.word(23); - 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); - row[layout.auxiliaries + 3] = v_12; - row[layout.auxiliaries + 4] = v_13; - row[layout.auxiliaries + 5] = v_14; - row[layout.auxiliaries + 6] = v_15; - row[layout.auxiliaries + 7] = v_16; - row[layout.auxiliaries + 8] = v_17; - row[layout.auxiliaries + 9] = v_18; - row[layout.auxiliaries + 10] = v_19; - row[layout.auxiliaries + 11] = v_20; - row[layout.auxiliaries + 12] = v_21; - row[layout.auxiliaries + 13] = v_22; - row[layout.auxiliaries + 14] = v_23; - row[layout.auxiliaries + 15] = v_24; - row[layout.auxiliaries + 16] = v_25; - row[layout.auxiliaries + 17] = v_26; - row[layout.auxiliaries + 18] = v_27; - row[layout.auxiliaries + 19] = v_28; - row[layout.auxiliaries + 20] = v_29; - 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); - const uint64_t v_34 = seed.word(33); - const uint64_t v_35 = seed.word(34); - const uint64_t v_36 = seed.word(35); - const uint64_t v_37 = seed.word(36); - row[layout.auxiliaries + 21] = v_30; - row[layout.auxiliaries + 22] = v_31; - row[layout.auxiliaries + 23] = v_32; - row[layout.auxiliaries + 24] = v_33; - row[layout.auxiliaries + 25] = v_34; - row[layout.auxiliaries + 26] = v_35; - row[layout.auxiliaries + 27] = v_36; - row[layout.auxiliaries + 28] = v_37; - const uint64_t v_38 = seed.word(37); - const uint64_t v_39 = seed.word(38); - row[layout.auxiliaries + 29] = v_38; - row[layout.auxiliaries + 30] = v_39; - const uint64_t v_41 = seed.word(39); - row[layout.auxiliaries + 31] = v_41; - row[layout.selectors + 1] = 1; - return 0; - } - } -} -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 ? 216 : 320; - 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 < 9 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 32) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 216 : encoding == 0 ? 320 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_724); -} - -template struct Seed_ixvm_727 { - 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 + 104); - case 2: return load_u64(data + 8); - case 3: return load_u64(data + 16); - case 4: return load_u8(data + 116); - case 5: return load_u8(data + 117); - case 6: return load_u8(data + 118); - case 7: return load_u8(data + 119); - case 8: return load_u8(data + 120); - case 9: return load_u8(data + 121); - case 10: return load_u32(data + 108); - case 11: return load_u8(data + 122); - case 12: return load_u64(data + 24); - case 13: return load_u8(data + 123); - case 14: return load_u64(data + 32); - case 15: return load_u64(data + 40); - case 16: return load_u8(data + 124); - case 17: return load_u8(data + 125); - case 18: return load_u8(data + 126); - case 19: return load_u8(data + 127); - case 20: return load_u8(data + 128); - case 21: return load_u8(data + 129); - case 22: return load_u8(data + 130); - case 23: return load_u64(data + 48); - case 24: return load_u64(data + 56); - case 25: return load_u8(data + 131); - case 26: return load_u8(data + 132); - case 27: return load_u8(data + 133); - case 28: return load_u8(data + 134); - case 29: return load_u8(data + 135); - case 30: return load_u8(data + 136); - case 31: return load_u8(data + 137); - case 32: return load_u64(data + 64); - case 33: return load_u64(data + 72); - case 34: return load_u8(data + 138); - case 35: return load_u8(data + 139); - case 36: return load_u8(data + 140); - case 37: return load_u8(data + 141); - case 38: return load_u8(data + 142); - case 39: return load_u8(data + 143); - case 40: return load_u8(data + 144); - case 41: return load_u64(data + 80); - case 42: return load_u64(data + 88); - case 43: return load_u8(data + 145); - case 44: return load_u8(data + 146); - case 45: return load_u8(data + 147); - case 46: return load_u8(data + 148); - case 47: return load_u8(data + 149); - case 48: return load_u8(data + 150); - case 49: return load_u8(data + 151); - case 50: return load_u32(data + 112); - case 51: return load_u64(data + 96); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_727(Seed_ixvm_727 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); - 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; - 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); - 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); - 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); - row[layout.auxiliaries + 10] = v_10; - row[layout.auxiliaries + 11] = v_11; - row[layout.auxiliaries + 12] = v_12; - row[layout.auxiliaries + 13] = v_13; - row[layout.auxiliaries + 14] = v_14; - row[layout.auxiliaries + 15] = v_15; - row[layout.auxiliaries + 16] = v_16; - row[layout.auxiliaries + 17] = v_17; - row[layout.auxiliaries + 18] = v_18; - row[layout.auxiliaries + 19] = v_19; - row[layout.auxiliaries + 20] = v_20; - row[layout.auxiliaries + 21] = v_21; - row[layout.auxiliaries + 22] = v_22; - row[layout.auxiliaries + 23] = v_23; - row[layout.auxiliaries + 24] = v_24; - row[layout.auxiliaries + 25] = v_25; - row[layout.auxiliaries + 26] = v_26; - row[layout.auxiliaries + 27] = v_27; - row[layout.auxiliaries + 28] = v_28; - row[layout.auxiliaries + 29] = v_29; - row[layout.auxiliaries + 30] = v_30; - row[layout.auxiliaries + 31] = v_31; - row[layout.auxiliaries + 32] = v_32; - row[layout.auxiliaries + 33] = v_33; - row[layout.auxiliaries + 34] = v_34; - row[layout.auxiliaries + 35] = v_35; - row[layout.auxiliaries + 36] = v_36; - row[layout.auxiliaries + 37] = v_37; - row[layout.auxiliaries + 38] = v_38; - row[layout.auxiliaries + 39] = v_39; - row[layout.auxiliaries + 40] = v_40; - row[layout.auxiliaries + 41] = v_41; - row[layout.auxiliaries + 42] = v_42; - row[layout.auxiliaries + 43] = v_43; - row[layout.auxiliaries + 44] = v_44; - row[layout.auxiliaries + 45] = v_45; - row[layout.auxiliaries + 46] = v_46; - row[layout.auxiliaries + 47] = v_47; - row[layout.auxiliaries + 48] = v_48; - row[layout.auxiliaries + 49] = v_49; - row[layout.auxiliaries + 50] = v_50; - row[layout.selectors + 0] = 1; - return 0; -} -template __global__ void kernel_ixvm_727(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 ? 152 : 416; - const Seed_ixvm_727 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_727(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_727(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_727<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_727<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_727(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 < 51) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 152 : encoding == 0 ? 416 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_727); -} - -template struct Seed_ixvm_734 { - 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_u8(data + 28); - case 3: return load_u8(data + 29); - case 4: return load_u8(data + 30); - case 5: return load_u8(data + 31); - case 6: return load_u8(data + 32); - case 7: return load_u8(data + 33); - case 8: return load_u8(data + 34); - case 9: return load_u8(data + 35); - case 10: return load_u8(data + 36); - case 11: return load_u8(data + 37); - case 12: return load_u8(data + 38); - case 13: return load_u8(data + 39); - case 14: return load_u8(data + 40); - case 15: return load_u8(data + 41); - case 16: return load_u8(data + 42); - case 17: return load_u8(data + 43); - case 18: return load_u8(data + 44); - case 19: return load_u32(data + 12); - case 20: return load_u32(data + 16); - case 21: return load_u32(data + 20); - case 22: return load_u32(data + 24); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_734(Seed_ixvm_734 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); - 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); - const uint64_t v_17 = seed.word(18); - const uint64_t v_18 = seed.word(19); - 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; - row[layout.auxiliaries + 11] = v_11; - row[layout.auxiliaries + 12] = v_12; - row[layout.auxiliaries + 13] = v_13; - row[layout.auxiliaries + 14] = v_14; - row[layout.auxiliaries + 15] = v_15; - row[layout.auxiliaries + 16] = v_16; - row[layout.auxiliaries + 17] = v_17; - row[layout.auxiliaries + 18] = v_18; - const uint64_t v_20 = seed.word(20); - row[layout.auxiliaries + 19] = v_20; - const uint64_t v_21 = seed.word(21); - row[layout.auxiliaries + 20] = v_21; - const uint64_t v_22 = seed.word(22); - row[layout.auxiliaries + 21] = v_22; - row[layout.selectors + 0] = 1; - return 0; -} -template __global__ void kernel_ixvm_734(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 : 184; - const Seed_ixvm_734 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_734(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_734(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_734<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_734<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_734(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 < 22) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 48 : encoding == 0 ? 184 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_734); -} - -template struct Seed_ixvm_743 { - 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 + 168); - case 2: return load_u32(data + 172); - case 3: return load_u64(data + 8); - case 4: return load_u64(data + 16); - case 5: return load_u64(data + 24); - case 6: return load_u32(data + 176); - case 7: return load_u32(data + 180); - case 8: return load_u32(data + 184); - case 9: return load_u64(data + 32); - case 10: return load_u64(data + 40); - case 11: return load_u8(data + 224); - case 12: return load_u64(data + 48); - case 13: return load_u64(data + 56); - case 14: return load_u64(data + 64); - case 15: return load_u32(data + 188); - case 16: return load_u32(data + 192); - case 17: return load_u32(data + 196); - case 18: return load_u64(data + 72); - case 19: return load_u64(data + 80); - case 20: return load_u64(data + 88); - case 21: return load_u64(data + 96); - case 22: return load_u8(data + 225); - case 23: return load_u8(data + 226); - case 24: return load_u8(data + 227); - case 25: return load_u8(data + 228); - case 26: return load_u8(data + 229); - case 27: return load_u8(data + 230); - case 28: return load_u32(data + 200); - case 29: return load_u32(data + 204); - case 30: return load_u8(data + 231); - case 31: return load_u64(data + 104); - case 32: return load_u64(data + 112); - case 33: return load_u8(data + 232); - case 34: return load_u8(data + 233); - case 35: return load_u8(data + 234); - case 36: return load_u8(data + 235); - case 37: return load_u8(data + 236); - case 38: return load_u8(data + 237); - case 39: return load_u64(data + 120); - case 40: return load_u32(data + 208); - case 41: return load_u64(data + 128); - case 42: return load_u64(data + 136); - case 43: return load_u64(data + 144); - case 44: return load_u32(data + 212); - case 45: return load_u32(data + 216); - case 46: return load_u32(data + 220); - case 47: return load_u64(data + 152); - case 48: return load_u64(data + 160); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_743(Seed_ixvm_743 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); - 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); - 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); - const uint64_t v_27 = seed.word(28); - const uint64_t v_28 = seed.word(29); - row[layout.auxiliaries + 1] = v_10; - row[layout.auxiliaries + 2] = v_11; - row[layout.auxiliaries + 3] = v_12; - row[layout.auxiliaries + 4] = v_13; - row[layout.auxiliaries + 5] = v_14; - row[layout.auxiliaries + 6] = v_15; - row[layout.auxiliaries + 7] = v_16; - row[layout.auxiliaries + 8] = v_17; - row[layout.auxiliaries + 9] = v_18; - row[layout.auxiliaries + 10] = v_19; - row[layout.auxiliaries + 11] = v_20; - row[layout.auxiliaries + 12] = v_21; - row[layout.auxiliaries + 13] = v_22; - row[layout.auxiliaries + 14] = v_23; - row[layout.auxiliaries + 15] = v_24; - row[layout.auxiliaries + 16] = v_25; - row[layout.auxiliaries + 17] = v_26; - row[layout.auxiliaries + 18] = v_27; - row[layout.auxiliaries + 19] = v_28; - switch (v_10) { - case 1ULL: { - 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); - row[layout.auxiliaries + 20] = v_29; - row[layout.auxiliaries + 21] = v_30; - row[layout.auxiliaries + 22] = v_31; - row[layout.auxiliaries + 23] = v_32; - row[layout.auxiliaries + 24] = v_33; - row[layout.auxiliaries + 25] = v_34; - row[layout.auxiliaries + 26] = v_35; - row[layout.auxiliaries + 27] = v_36; - row[layout.auxiliaries + 28] = v_37; - row[layout.auxiliaries + 29] = v_38; - row[layout.auxiliaries + 30] = v_39; - switch (v_29) { - case 1ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - default: { - return 2; - } - } - } - case 0ULL: { - const uint64_t v_40 = seed.word(30); - const uint64_t v_41 = seed.word(31); - const uint64_t v_42 = seed.word(32); - const uint64_t v_43 = seed.word(33); - const uint64_t v_44 = seed.word(34); - const uint64_t v_45 = seed.word(35); - const uint64_t v_46 = seed.word(36); - const uint64_t v_47 = seed.word(37); - const uint64_t v_48 = seed.word(38); - const uint64_t v_49 = seed.word(39); - const uint64_t v_50 = seed.word(40); - row[layout.auxiliaries + 20] = v_40; - row[layout.auxiliaries + 21] = v_41; - row[layout.auxiliaries + 22] = v_42; - row[layout.auxiliaries + 23] = v_43; - row[layout.auxiliaries + 24] = v_44; - row[layout.auxiliaries + 25] = v_45; - row[layout.auxiliaries + 26] = v_46; - row[layout.auxiliaries + 27] = v_47; - row[layout.auxiliaries + 28] = v_48; - row[layout.auxiliaries + 29] = v_49; - row[layout.auxiliaries + 30] = v_50; - switch (v_40) { - case 0ULL: { - switch (v_11) { - default: { - switch (v_41) { - default: { - const uint64_t v_52 = seed.word(41); - const uint64_t v_53 = seed.word(42); - const uint64_t v_54 = seed.word(43); - const uint64_t v_55 = seed.word(44); - const uint64_t v_56 = seed.word(45); - const uint64_t v_57 = seed.word(46); - const uint64_t v_58 = seed.word(47); - const uint64_t v_59 = seed.word(48); - row[layout.auxiliaries + 31] = v_52; - row[layout.auxiliaries + 32] = v_53; - row[layout.auxiliaries + 33] = v_54; - row[layout.auxiliaries + 34] = v_55; - row[layout.auxiliaries + 35] = v_56; - row[layout.auxiliaries + 36] = v_57; - row[layout.auxiliaries + 37] = v_58; - row[layout.auxiliaries + 38] = v_59; - row[layout.selectors + 1] = 1; - return 0; - } - } - } - } - } - default: { - return 2; - } - } - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_743(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 : 392; - const Seed_ixvm_743 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_743(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_743(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_743<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_743<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_743(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 < 39) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 240 : encoding == 0 ? 392 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_743); -} - -template struct Seed_ixvm_746 { - 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_u8(data + 112); - case 4: return load_u64(data + 8); - case 5: return load_u64(data + 16); - case 6: return load_u8(data + 113); - case 7: return load_u8(data + 114); - case 8: return load_u8(data + 115); - case 9: return load_u8(data + 116); - case 10: return load_u8(data + 117); - case 11: return load_u8(data + 118); - case 12: return load_u8(data + 119); - case 13: return load_u64(data + 24); - case 14: return load_u8(data + 120); - case 15: return load_u64(data + 32); - case 16: return load_u64(data + 40); - case 17: return load_u8(data + 121); - case 18: return load_u8(data + 122); - case 19: return load_u8(data + 123); - case 20: return load_u8(data + 124); - case 21: return load_u8(data + 125); - case 22: return load_u8(data + 126); - case 23: return load_u8(data + 127); - case 24: return load_u64(data + 48); - case 25: return load_u64(data + 56); - case 26: return load_u8(data + 128); - case 27: return load_u8(data + 129); - case 28: return load_u8(data + 130); - case 29: return load_u8(data + 131); - case 30: return load_u8(data + 132); - case 31: return load_u8(data + 133); - case 32: return load_u8(data + 134); - case 33: return load_u64(data + 64); - case 34: return load_u64(data + 72); - case 35: return load_u8(data + 135); - case 36: return load_u8(data + 136); - case 37: return load_u8(data + 137); - case 38: return load_u8(data + 138); - case 39: return load_u8(data + 139); - case 40: return load_u8(data + 140); - case 41: return load_u8(data + 141); - case 42: return load_u64(data + 80); - case 43: return load_u64(data + 88); - case 44: return load_u8(data + 142); - case 45: return load_u8(data + 143); - case 46: return load_u8(data + 144); - case 47: return load_u8(data + 145); - case 48: return load_u8(data + 146); - case 49: return load_u8(data + 147); - case 50: return load_u8(data + 148); - case 51: return load_u32(data + 104); - case 52: return load_u32(data + 108); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_746(Seed_ixvm_746 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); - 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); - 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); - 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); - 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; - 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.auxiliaries + 13] = v_14; - row[layout.auxiliaries + 14] = v_15; - row[layout.auxiliaries + 15] = v_16; - row[layout.auxiliaries + 16] = v_17; - row[layout.auxiliaries + 17] = v_18; - row[layout.auxiliaries + 18] = v_19; - row[layout.auxiliaries + 19] = v_20; - row[layout.auxiliaries + 20] = v_21; - row[layout.auxiliaries + 21] = v_22; - row[layout.auxiliaries + 22] = v_23; - row[layout.auxiliaries + 23] = v_24; - row[layout.auxiliaries + 24] = v_25; - row[layout.auxiliaries + 25] = v_26; - row[layout.auxiliaries + 26] = v_27; - row[layout.auxiliaries + 27] = v_28; - row[layout.auxiliaries + 28] = v_29; - row[layout.auxiliaries + 29] = v_30; - row[layout.auxiliaries + 30] = v_31; - row[layout.auxiliaries + 31] = v_32; - row[layout.auxiliaries + 32] = v_33; - row[layout.auxiliaries + 33] = v_34; - row[layout.auxiliaries + 34] = v_35; - row[layout.auxiliaries + 35] = v_36; - row[layout.auxiliaries + 36] = v_37; - row[layout.auxiliaries + 37] = v_38; - row[layout.auxiliaries + 38] = v_39; - row[layout.auxiliaries + 39] = v_40; - row[layout.auxiliaries + 40] = v_41; - row[layout.auxiliaries + 41] = v_42; - row[layout.auxiliaries + 42] = v_43; - row[layout.auxiliaries + 43] = v_44; - row[layout.auxiliaries + 44] = v_45; - row[layout.auxiliaries + 45] = v_46; - row[layout.auxiliaries + 46] = v_47; - row[layout.auxiliaries + 47] = v_48; - row[layout.auxiliaries + 48] = v_49; - row[layout.auxiliaries + 49] = v_50; - row[layout.auxiliaries + 50] = v_51; - switch (v_2) { - case 1ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - case 0ULL: { - row[layout.selectors + 1] = 1; - return 0; - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_746(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 ? 152 : 424; - const Seed_ixvm_746 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_746(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_746(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_746<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_746<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_746(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 < 51) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 152 : encoding == 0 ? 424 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_746); -} - -template struct Seed_ixvm_752 { - 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 + 416); - case 10: return load_u32(data + 420); - case 11: return load_u32(data + 424); - case 12: return load_u32(data + 428); - case 13: return load_u32(data + 432); - case 14: return load_u32(data + 436); - case 15: return load_u32(data + 440); - case 16: return load_u32(data + 444); - case 17: return load_u64(data + 72); - case 18: return load_u64(data + 80); - case 19: return load_u64(data + 88); - case 20: return load_u64(data + 96); - case 21: return load_u64(data + 104); - case 22: return load_u64(data + 112); - case 23: return load_u64(data + 120); - case 24: return load_u64(data + 128); - case 25: return load_u64(data + 136); - case 26: return load_u64(data + 144); - case 27: return load_u64(data + 152); - case 28: return load_u64(data + 160); - case 29: return load_u64(data + 168); - case 30: return load_u64(data + 176); - case 31: return load_u64(data + 184); - case 32: return load_u64(data + 192); - case 33: return load_u64(data + 200); - case 34: return load_u64(data + 208); - case 35: return load_u64(data + 216); - case 36: return load_u64(data + 224); - case 37: return load_u64(data + 232); - case 38: return load_u64(data + 240); - case 39: return load_u64(data + 248); - case 40: return load_u64(data + 256); - case 41: return load_u64(data + 264); - case 42: return load_u64(data + 272); - case 43: return load_u64(data + 280); - case 44: return load_u64(data + 288); - case 45: return load_u64(data + 296); - case 46: return load_u64(data + 304); - case 47: return load_u64(data + 312); - case 48: return load_u64(data + 320); - case 49: return load_u8(data + 532); - case 50: return load_u8(data + 533); - case 51: return load_u64(data + 328); - case 52: return load_u8(data + 534); - case 53: return load_u8(data + 535); - case 54: return load_u8(data + 536); - case 55: return load_u8(data + 537); - case 56: return load_u8(data + 538); - case 57: return load_u8(data + 539); - case 58: return load_u32(data + 448); - case 59: return load_u8(data + 540); - case 60: return load_u32(data + 452); - case 61: return load_u8(data + 541); - case 62: return load_u32(data + 456); - case 63: return load_u32(data + 460); - case 64: return load_u32(data + 464); - case 65: return load_u32(data + 468); - case 66: return load_u32(data + 472); - case 67: return load_u32(data + 476); - case 68: return load_u32(data + 480); - case 69: return load_u32(data + 484); - case 70: return load_u32(data + 488); - case 71: return load_u64(data + 336); - case 72: return load_u64(data + 344); - case 73: return load_u32(data + 492); - case 74: return load_u32(data + 496); - case 75: return load_u8(data + 542); - case 76: return load_u32(data + 500); - case 77: return load_u8(data + 543); - case 78: return load_u64(data + 352); - case 79: return load_u32(data + 504); - case 80: return load_u64(data + 360); - case 81: return load_u32(data + 508); - case 82: return load_u32(data + 512); - case 83: return load_u8(data + 544); - case 84: return load_u8(data + 545); - case 85: return load_u32(data + 516); - case 86: return load_u8(data + 546); - case 87: return load_u8(data + 547); - case 88: return load_u8(data + 548); - case 89: return load_u64(data + 368); - case 90: return load_u64(data + 376); - case 91: return load_u8(data + 549); - case 92: return load_u8(data + 550); - case 93: return load_u8(data + 551); - case 94: return load_u8(data + 552); - case 95: return load_u8(data + 553); - case 96: return load_u8(data + 554); - case 97: return load_u8(data + 555); - case 98: return load_u64(data + 384); - case 99: return load_u64(data + 392); - case 100: return load_u8(data + 556); - case 101: return load_u8(data + 557); - case 102: return load_u8(data + 558); - case 103: return load_u8(data + 559); - case 104: return load_u8(data + 560); - case 105: return load_u8(data + 561); - case 106: return load_u8(data + 562); - case 107: return load_u64(data + 400); - case 108: return load_u64(data + 408); - case 109: return load_u8(data + 563); - case 110: return load_u8(data + 564); - case 111: return load_u8(data + 565); - case 112: return load_u8(data + 566); - case 113: return load_u8(data + 567); - case 114: return load_u8(data + 568); - case 115: return load_u8(data + 569); - case 116: return load_u32(data + 520); - case 117: return load_u8(data + 570); - case 118: return load_u32(data + 524); - case 119: return load_u32(data + 528); - case 120: return load_u8(data + 571); - case 121: return load_u8(data + 572); - case 122: return load_u8(data + 573); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_752(Seed_ixvm_752 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_9 = seed.word(9); - const uint64_t v_10 = seed.word(10); - row[layout.auxiliaries + 1] = v_9; - row[layout.auxiliaries + 2] = v_10; - const uint64_t v_11 = seed.word(11); - row[layout.auxiliaries + 3] = v_11; - const uint64_t v_44 = seed.word(12); - row[layout.auxiliaries + 4] = v_44; - const uint64_t v_45 = seed.word(13); - row[layout.auxiliaries + 5] = v_45; - const uint64_t v_46 = seed.word(14); - row[layout.auxiliaries + 6] = v_46; - const uint64_t v_47 = seed.word(15); - row[layout.auxiliaries + 7] = v_47; - const uint64_t v_48 = seed.word(16); - row[layout.auxiliaries + 8] = v_48; - 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); - const uint64_t v_75 = seed.word(43); - const uint64_t v_76 = seed.word(44); - const uint64_t v_77 = seed.word(45); - const uint64_t v_78 = seed.word(46); - const uint64_t v_79 = seed.word(47); - const uint64_t v_80 = seed.word(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; - row[layout.auxiliaries + 17] = v_57; - row[layout.auxiliaries + 18] = v_58; - row[layout.auxiliaries + 19] = v_59; - row[layout.auxiliaries + 20] = v_60; - row[layout.auxiliaries + 21] = v_61; - row[layout.auxiliaries + 22] = v_62; - row[layout.auxiliaries + 23] = v_63; - row[layout.auxiliaries + 24] = v_64; - row[layout.auxiliaries + 25] = v_65; - row[layout.auxiliaries + 26] = v_66; - row[layout.auxiliaries + 27] = v_67; - row[layout.auxiliaries + 28] = v_68; - row[layout.auxiliaries + 29] = v_69; - row[layout.auxiliaries + 30] = v_70; - row[layout.auxiliaries + 31] = v_71; - row[layout.auxiliaries + 32] = v_72; - row[layout.auxiliaries + 33] = v_73; - row[layout.auxiliaries + 34] = v_74; - row[layout.auxiliaries + 35] = v_75; - row[layout.auxiliaries + 36] = v_76; - row[layout.auxiliaries + 37] = v_77; - row[layout.auxiliaries + 38] = v_78; - row[layout.auxiliaries + 39] = v_79; - row[layout.auxiliaries + 40] = v_80; - const uint64_t v_132 = seed.word(49); - const uint64_t v_133 = seed.word(50); - const uint64_t v_134 = seed.word(51); - const uint64_t v_135 = seed.word(52); - const uint64_t v_136 = seed.word(53); - const uint64_t v_137 = seed.word(54); - const uint64_t v_138 = seed.word(55); - const uint64_t v_139 = seed.word(56); - const uint64_t v_140 = seed.word(57); - const uint64_t v_141 = seed.word(58); - row[layout.auxiliaries + 41] = v_132; - row[layout.auxiliaries + 42] = v_133; - row[layout.auxiliaries + 43] = v_134; - row[layout.auxiliaries + 44] = v_135; - row[layout.auxiliaries + 45] = v_136; - row[layout.auxiliaries + 46] = v_137; - row[layout.auxiliaries + 47] = v_138; - row[layout.auxiliaries + 48] = v_139; - row[layout.auxiliaries + 49] = v_140; - row[layout.auxiliaries + 50] = v_141; - const uint64_t v_148 = seed.word(59); - const uint64_t v_149 = seed.word(60); - row[layout.auxiliaries + 51] = v_148; - row[layout.auxiliaries + 52] = v_149; - const uint64_t v_151 = seed.word(61); - const uint64_t v_152 = seed.word(62); - row[layout.auxiliaries + 53] = v_151; - row[layout.auxiliaries + 54] = v_152; - switch (v_133) { - case 3ULL: { - const uint64_t v_154 = seed.word(63); - const uint64_t v_155 = seed.word(64); - const uint64_t v_156 = seed.word(65); - const uint64_t v_157 = seed.word(66); - row[layout.auxiliaries + 55] = v_154; - row[layout.auxiliaries + 56] = v_155; - row[layout.auxiliaries + 57] = v_156; - row[layout.auxiliaries + 58] = v_157; - const uint64_t v_158 = seed.word(67); - row[layout.auxiliaries + 59] = v_158; - const uint64_t v_159 = seed.word(68); - const uint64_t v_160 = seed.word(69); - row[layout.auxiliaries + 60] = v_159; - row[layout.auxiliaries + 61] = v_160; - const uint64_t v_161 = seed.word(70); - const uint64_t v_162 = seed.word(71); - row[layout.auxiliaries + 62] = v_161; - row[layout.auxiliaries + 63] = v_162; - const uint64_t v_163 = seed.word(72); - const uint64_t v_164 = seed.word(73); - const uint64_t v_165 = seed.word(74); - row[layout.auxiliaries + 64] = v_163; - row[layout.auxiliaries + 65] = v_164; - row[layout.auxiliaries + 66] = v_165; - const uint64_t v_166 = seed.word(75); - const uint64_t v_167 = seed.word(76); - const uint64_t v_168 = seed.word(77); - row[layout.auxiliaries + 67] = v_166; - row[layout.auxiliaries + 68] = v_167; - row[layout.auxiliaries + 69] = v_168; - row[layout.selectors + 0] = 1; - return 0; - } - case 4ULL: { - const uint64_t v_170 = seed.word(63); - const uint64_t v_171 = seed.word(64); - const uint64_t v_172 = seed.word(65); - const uint64_t v_173 = seed.word(66); - row[layout.auxiliaries + 55] = v_170; - row[layout.auxiliaries + 56] = v_171; - row[layout.auxiliaries + 57] = v_172; - row[layout.auxiliaries + 58] = v_173; - const uint64_t v_174 = seed.word(67); - row[layout.auxiliaries + 59] = v_174; - const uint64_t v_175 = seed.word(68); - const uint64_t v_176 = seed.word(69); - row[layout.auxiliaries + 60] = v_175; - row[layout.auxiliaries + 61] = v_176; - const uint64_t v_177 = seed.word(70); - const uint64_t v_178 = seed.word(71); - const uint64_t v_179 = seed.word(72); - row[layout.auxiliaries + 62] = v_177; - row[layout.auxiliaries + 63] = v_178; - row[layout.auxiliaries + 64] = v_179; - const uint64_t v_180 = seed.word(73); - const uint64_t v_181 = seed.word(74); - const uint64_t v_182 = seed.word(75); - row[layout.auxiliaries + 65] = v_180; - row[layout.auxiliaries + 66] = v_181; - row[layout.auxiliaries + 67] = v_182; - switch (v_177) { - case 1ULL: { - row[layout.selectors + 1] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_184 = seed.word(76); - row[layout.auxiliaries + 68] = v_184; - const uint64_t v_186 = seed.word(77); - const uint64_t v_187 = seed.word(78); - const uint64_t v_188 = seed.word(79); - const uint64_t v_189 = seed.word(80); - const uint64_t v_190 = seed.word(81); - const uint64_t v_191 = seed.word(82); - row[layout.auxiliaries + 69] = v_186; - row[layout.auxiliaries + 70] = v_187; - row[layout.auxiliaries + 71] = v_188; - row[layout.auxiliaries + 72] = v_189; - row[layout.auxiliaries + 73] = v_190; - row[layout.auxiliaries + 74] = v_191; - row[layout.selectors + 2] = 1; - return 0; - } - default: { - return 2; - } - } - } - case 5ULL: { - const uint64_t v_193 = seed.word(63); - const uint64_t v_194 = seed.word(64); - const uint64_t v_195 = seed.word(65); - const uint64_t v_196 = seed.word(66); - row[layout.auxiliaries + 55] = v_193; - row[layout.auxiliaries + 56] = v_194; - row[layout.auxiliaries + 57] = v_195; - row[layout.auxiliaries + 58] = v_196; - const uint64_t v_197 = seed.word(67); - row[layout.auxiliaries + 59] = v_197; - const uint64_t v_198 = seed.word(68); - const uint64_t v_199 = seed.word(69); - row[layout.auxiliaries + 60] = v_198; - row[layout.auxiliaries + 61] = v_199; - const uint64_t v_200 = seed.word(70); - const uint64_t v_201 = seed.word(71); - const uint64_t v_202 = seed.word(72); - row[layout.auxiliaries + 62] = v_200; - row[layout.auxiliaries + 63] = v_201; - row[layout.auxiliaries + 64] = v_202; - const uint64_t v_203 = seed.word(73); - const uint64_t v_204 = seed.word(74); - const uint64_t v_205 = seed.word(75); - row[layout.auxiliaries + 65] = v_203; - row[layout.auxiliaries + 66] = v_204; - row[layout.auxiliaries + 67] = v_205; - row[layout.selectors + 3] = 1; - return 0; - } - case 6ULL: { - const uint64_t v_208 = seed.word(63); - const uint64_t v_209 = seed.word(64); - row[layout.auxiliaries + 55] = v_208; - row[layout.auxiliaries + 56] = v_209; - const uint64_t v_210 = seed.word(65); - const uint64_t v_211 = seed.word(66); - const uint64_t v_212 = seed.word(67); - const uint64_t v_213 = seed.word(68); - const uint64_t v_214 = seed.word(69); - const uint64_t v_215 = seed.word(70); - const uint64_t v_216 = seed.word(71); - const uint64_t v_217 = seed.word(72); - const uint64_t v_218 = seed.word(73); - const uint64_t v_219 = seed.word(74); - const uint64_t v_220 = seed.word(75); - const uint64_t v_221 = seed.word(76); - const uint64_t v_222 = seed.word(77); - const uint64_t v_223 = seed.word(78); - const uint64_t v_224 = seed.word(79); - const uint64_t v_225 = seed.word(80); - const uint64_t v_226 = seed.word(81); - const uint64_t v_227 = seed.word(82); - const uint64_t v_228 = seed.word(83); - const uint64_t v_229 = seed.word(84); - const uint64_t v_230 = seed.word(85); - const uint64_t v_231 = seed.word(86); - const uint64_t v_232 = seed.word(87); - const uint64_t v_233 = seed.word(88); - const uint64_t v_234 = seed.word(89); - const uint64_t v_235 = seed.word(90); - const uint64_t v_236 = seed.word(91); - const uint64_t v_237 = seed.word(92); - const uint64_t v_238 = seed.word(93); - const uint64_t v_239 = seed.word(94); - const uint64_t v_240 = seed.word(95); - const uint64_t v_241 = seed.word(96); - const uint64_t v_242 = seed.word(97); - const uint64_t v_243 = seed.word(98); - const uint64_t v_244 = seed.word(99); - const uint64_t v_245 = seed.word(100); - const uint64_t v_246 = seed.word(101); - const uint64_t v_247 = seed.word(102); - const uint64_t v_248 = seed.word(103); - const uint64_t v_249 = seed.word(104); - const uint64_t v_250 = seed.word(105); - const uint64_t v_251 = seed.word(106); - const uint64_t v_252 = seed.word(107); - const uint64_t v_253 = seed.word(108); - const uint64_t v_254 = seed.word(109); - const uint64_t v_255 = seed.word(110); - const uint64_t v_256 = seed.word(111); - const uint64_t v_257 = seed.word(112); - const uint64_t v_258 = seed.word(113); - const uint64_t v_259 = seed.word(114); - const uint64_t v_260 = seed.word(115); - const uint64_t v_261 = seed.word(116); - const uint64_t v_262 = seed.word(117); - const uint64_t v_263 = seed.word(118); - const uint64_t v_264 = seed.word(119); - row[layout.auxiliaries + 57] = v_210; - row[layout.auxiliaries + 58] = v_211; - row[layout.auxiliaries + 59] = v_212; - row[layout.auxiliaries + 60] = v_213; - row[layout.auxiliaries + 61] = v_214; - row[layout.auxiliaries + 62] = v_215; - row[layout.auxiliaries + 63] = v_216; - row[layout.auxiliaries + 64] = v_217; - row[layout.auxiliaries + 65] = v_218; - row[layout.auxiliaries + 66] = v_219; - row[layout.auxiliaries + 67] = v_220; - row[layout.auxiliaries + 68] = v_221; - row[layout.auxiliaries + 69] = v_222; - row[layout.auxiliaries + 70] = v_223; - row[layout.auxiliaries + 71] = v_224; - row[layout.auxiliaries + 72] = v_225; - row[layout.auxiliaries + 73] = v_226; - row[layout.auxiliaries + 74] = v_227; - row[layout.auxiliaries + 75] = v_228; - row[layout.auxiliaries + 76] = v_229; - row[layout.auxiliaries + 77] = v_230; - row[layout.auxiliaries + 78] = v_231; - row[layout.auxiliaries + 79] = v_232; - row[layout.auxiliaries + 80] = v_233; - row[layout.auxiliaries + 81] = v_234; - row[layout.auxiliaries + 82] = v_235; - row[layout.auxiliaries + 83] = v_236; - row[layout.auxiliaries + 84] = v_237; - row[layout.auxiliaries + 85] = v_238; - row[layout.auxiliaries + 86] = v_239; - row[layout.auxiliaries + 87] = v_240; - row[layout.auxiliaries + 88] = v_241; - row[layout.auxiliaries + 89] = v_242; - row[layout.auxiliaries + 90] = v_243; - row[layout.auxiliaries + 91] = v_244; - row[layout.auxiliaries + 92] = v_245; - row[layout.auxiliaries + 93] = v_246; - row[layout.auxiliaries + 94] = v_247; - row[layout.auxiliaries + 95] = v_248; - row[layout.auxiliaries + 96] = v_249; - row[layout.auxiliaries + 97] = v_250; - row[layout.auxiliaries + 98] = v_251; - row[layout.auxiliaries + 99] = v_252; - row[layout.auxiliaries + 100] = v_253; - row[layout.auxiliaries + 101] = v_254; - row[layout.auxiliaries + 102] = v_255; - row[layout.auxiliaries + 103] = v_256; - row[layout.auxiliaries + 104] = v_257; - row[layout.auxiliaries + 105] = v_258; - row[layout.auxiliaries + 106] = v_259; - row[layout.auxiliaries + 107] = v_260; - row[layout.auxiliaries + 108] = v_261; - row[layout.auxiliaries + 109] = v_262; - row[layout.auxiliaries + 110] = v_263; - row[layout.auxiliaries + 111] = v_264; - const uint64_t v_265 = seed.word(120); - const uint64_t v_266 = seed.word(121); - const uint64_t v_267 = seed.word(122); - row[layout.auxiliaries + 112] = v_265; - row[layout.auxiliaries + 113] = v_266; - row[layout.auxiliaries + 114] = v_267; - row[layout.selectors + 4] = 1; - return 0; - } - case 7ULL: { - const uint64_t v_270 = seed.word(63); - const uint64_t v_271 = seed.word(64); - row[layout.auxiliaries + 55] = v_270; - row[layout.auxiliaries + 56] = v_271; - const uint64_t v_272 = seed.word(65); - const uint64_t v_273 = seed.word(66); - row[layout.auxiliaries + 57] = v_272; - row[layout.auxiliaries + 58] = v_273; - const uint64_t v_274 = seed.word(67); - const uint64_t v_275 = seed.word(68); - const uint64_t v_276 = seed.word(69); - row[layout.auxiliaries + 59] = v_274; - row[layout.auxiliaries + 60] = v_275; - row[layout.auxiliaries + 61] = v_276; - row[layout.selectors + 5] = 1; - return 0; - } - case 9ULL: { - row[layout.selectors + 6] = 1; - return 0; - } - case 10ULL: { - const uint64_t v_282 = seed.word(63); - const uint64_t v_283 = seed.word(64); - row[layout.auxiliaries + 55] = v_282; - row[layout.auxiliaries + 56] = v_283; - const uint64_t v_314 = seed.word(65); - row[layout.auxiliaries + 57] = v_314; - const uint64_t v_315 = seed.word(66); - row[layout.auxiliaries + 58] = v_315; - const uint64_t v_317 = seed.word(67); - const uint64_t v_318 = seed.word(68); - row[layout.auxiliaries + 59] = v_317; - row[layout.auxiliaries + 60] = v_318; - const uint64_t v_319 = seed.word(69); - const uint64_t v_320 = seed.word(70); - const uint64_t v_321 = seed.word(71); - row[layout.auxiliaries + 61] = v_319; - row[layout.auxiliaries + 62] = v_320; - row[layout.auxiliaries + 63] = v_321; - row[layout.selectors + 7] = 1; - return 0; - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_752(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 ? 576 : 984; - const Seed_ixvm_752 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_752(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_752(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_752<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_752<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_752(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 < 8 || auxiliaries < selectors || auxiliaries - selectors < 8 || width < auxiliaries || width - auxiliaries < 115) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 576 : encoding == 0 ? 984 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_752); -} - -template struct Seed_ixvm_756 { - 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 + 104); - case 2: return load_u64(data + 8); - case 3: return load_u32(data + 108); - case 4: return load_u8(data + 152); - case 5: return load_u8(data + 153); - case 6: return load_u8(data + 154); - case 7: return load_u64(data + 16); - case 8: return load_u64(data + 24); - case 9: return load_u8(data + 155); - case 10: return load_u8(data + 156); - case 11: return load_u8(data + 157); - case 12: return load_u8(data + 158); - case 13: return load_u64(data + 32); - case 14: return load_u8(data + 159); - case 15: return load_u32(data + 112); - case 16: return load_u32(data + 116); - case 17: return load_u8(data + 160); - case 18: return load_u8(data + 161); - case 19: return load_u8(data + 162); - case 20: return load_u8(data + 163); - case 21: return load_u32(data + 120); - case 22: return load_u8(data + 164); - case 23: return load_u64(data + 40); - case 24: return load_u64(data + 48); - case 25: return load_u8(data + 165); - case 26: return load_u8(data + 166); - case 27: return load_u8(data + 167); - case 28: return load_u8(data + 168); - case 29: return load_u8(data + 169); - case 30: return load_u8(data + 170); - case 31: return load_u64(data + 56); - case 32: return load_u64(data + 64); - case 33: return load_u8(data + 171); - case 34: return load_u8(data + 172); - case 35: return load_u8(data + 173); - case 36: return load_u8(data + 174); - case 37: return load_u8(data + 175); - case 38: return load_u8(data + 176); - case 39: return load_u64(data + 72); - case 40: return load_u64(data + 80); - case 41: return load_u8(data + 177); - case 42: return load_u8(data + 178); - case 43: return load_u8(data + 179); - case 44: return load_u8(data + 180); - case 45: return load_u8(data + 181); - case 46: return load_u8(data + 182); - case 47: return load_u64(data + 88); - case 48: return load_u32(data + 124); - case 49: return load_u32(data + 128); - case 50: return load_u32(data + 132); - case 51: return load_u32(data + 136); - case 52: return load_u64(data + 96); - case 53: return load_u32(data + 140); - case 54: return load_u32(data + 144); - case 55: return load_u32(data + 148); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_756(Seed_ixvm_756 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); - 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); - 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); - 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); - 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; - row[layout.auxiliaries + 11] = v_13; - row[layout.auxiliaries + 12] = v_14; - row[layout.auxiliaries + 13] = v_15; - row[layout.auxiliaries + 14] = v_16; - row[layout.auxiliaries + 15] = v_17; - row[layout.auxiliaries + 16] = v_18; - row[layout.auxiliaries + 17] = v_19; - row[layout.auxiliaries + 18] = v_20; - row[layout.auxiliaries + 19] = v_21; - row[layout.auxiliaries + 20] = v_22; - row[layout.auxiliaries + 21] = v_23; - row[layout.auxiliaries + 22] = v_24; - row[layout.auxiliaries + 23] = v_25; - row[layout.auxiliaries + 24] = v_26; - row[layout.auxiliaries + 25] = v_27; - row[layout.auxiliaries + 26] = v_28; - row[layout.auxiliaries + 27] = v_29; - row[layout.auxiliaries + 28] = v_30; - row[layout.auxiliaries + 29] = v_31; - row[layout.auxiliaries + 30] = v_32; - row[layout.auxiliaries + 31] = v_33; - row[layout.auxiliaries + 32] = v_34; - row[layout.auxiliaries + 33] = v_35; - row[layout.auxiliaries + 34] = v_36; - row[layout.auxiliaries + 35] = v_37; - row[layout.auxiliaries + 36] = v_38; - row[layout.auxiliaries + 37] = v_39; - row[layout.auxiliaries + 38] = v_40; - row[layout.auxiliaries + 39] = v_41; - row[layout.auxiliaries + 40] = v_42; - row[layout.auxiliaries + 41] = v_43; - row[layout.auxiliaries + 42] = v_44; - row[layout.auxiliaries + 43] = v_45; - row[layout.auxiliaries + 44] = v_46; - row[layout.auxiliaries + 45] = v_47; - row[layout.auxiliaries + 46] = v_48; - row[layout.auxiliaries + 47] = v_49; - row[layout.auxiliaries + 48] = v_50; - switch (v_3) { - default: { - switch (v_3) { - case 0ULL: { - switch (v_4) { - default: { - const uint64_t v_53 = seed.word(52); - row[layout.auxiliaries + 49] = v_53; - const uint64_t v_54 = seed.word(53); - row[layout.auxiliaries + 50] = v_54; - const uint64_t v_55 = seed.word(54); - row[layout.auxiliaries + 51] = v_55; - const uint64_t v_56 = seed.word(55); - row[layout.auxiliaries + 52] = v_56; - row[layout.selectors + 0] = 1; - return 0; - } - } - } - default: { - return 2; - } - } - } - } -} -template __global__ void kernel_ixvm_756(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 : 448; - const Seed_ixvm_756 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_756(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_756(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_756<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_756<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_756(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 < 1 || width < auxiliaries || width - auxiliaries < 53) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 184 : encoding == 0 ? 448 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_756); -} - -template struct Seed_ixvm_761 { - 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 + 200); - case 2: return load_u8(data + 208); - case 3: return load_u64(data + 8); - case 4: return load_u64(data + 16); - 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_u32(data + 204); - 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); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_761(Seed_ixvm_761 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: { - row[layout.selectors + 0] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_12 = seed.word(12); - const uint64_t v_13 = seed.word(13); - 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); - row[layout.auxiliaries + 11] = v_12; - row[layout.auxiliaries + 12] = v_13; - row[layout.auxiliaries + 13] = v_14; - row[layout.auxiliaries + 14] = v_15; - row[layout.auxiliaries + 15] = v_16; - row[layout.auxiliaries + 16] = v_17; - row[layout.auxiliaries + 17] = v_18; - row[layout.auxiliaries + 18] = v_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); - const uint64_t v_24 = seed.word(24); - const uint64_t v_25 = seed.word(25); - const uint64_t v_26 = seed.word(26); - const uint64_t v_27 = seed.word(27); - row[layout.auxiliaries + 19] = v_20; - row[layout.auxiliaries + 20] = v_21; - row[layout.auxiliaries + 21] = v_22; - row[layout.auxiliaries + 22] = v_23; - row[layout.auxiliaries + 23] = v_24; - row[layout.auxiliaries + 24] = v_25; - row[layout.auxiliaries + 25] = v_26; - row[layout.auxiliaries + 26] = v_27; - row[layout.selectors + 1] = 1; - return 0; - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_761(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 ? 216 : 224; - const Seed_ixvm_761 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_761(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_761(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_761<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_761<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_761(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 < 27) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 216 : encoding == 0 ? 224 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_761); -} - -__device__ __constant__ uint64_t inverse_763_0[] = {18446744069414584320ULL, 0ULL}; -__device__ __constant__ uint64_t inverse_763_1[] = {0ULL}; -template struct Seed_ixvm_763 { - 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 + 112); - case 3: return load_u64(data + 8); - case 4: return load_u32(data + 76); - case 5: return load_u64(data + 16); - case 6: return load_u32(data + 80); - case 7: return load_u32(data + 84); - case 8: return load_u64(data + 24); - case 9: return load_u8(data + 113); - case 10: return load_u64(data + 32); - case 11: return load_u32(data + 88); - case 12: return load_u64(data + 40); - case 13: return load_u32(data + 92); - case 14: return load_u32(data + 96); - case 15: return load_u8(data + 114); - case 16: return load_u64(data + 48); - case 17: return load_u32(data + 100); - case 18: return load_u64(data + 56); - case 19: return load_u32(data + 104); - case 20: return load_u32(data + 108); - case 21: return load_u64(data + 64); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_763(Seed_ixvm_763 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; - switch (v_1) { - case 1ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - case 0ULL: { - 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 + 1] = v_8; - row[layout.auxiliaries + 2] = v_9; - row[layout.auxiliaries + 3] = v_10; - row[layout.auxiliaries + 4] = v_11; - row[layout.auxiliaries + 5] = v_12; - row[layout.auxiliaries + 6] = v_13; - const uint64_t v_14 = seed.word(15); - const uint64_t v_15 = seed.word(16); - const uint64_t v_16 = seed.word(17); - const uint64_t v_17 = seed.word(18); - const uint64_t v_18 = seed.word(19); - const uint64_t v_19 = seed.word(20); - row[layout.auxiliaries + 7] = v_14; - row[layout.auxiliaries + 8] = v_15; - row[layout.auxiliaries + 9] = v_16; - row[layout.auxiliaries + 10] = v_17; - row[layout.auxiliaries + 11] = v_18; - row[layout.auxiliaries + 12] = v_19; - if (v_0 > 0xffffffffULL || v_3 > 0xffffffffULL) return 3; - const uint32_t op_2 = uint32_t(v_0) - uint32_t(v_3); - const uint64_t v_20 = uint64_t(v_0 < v_3); - row[layout.auxiliaries + 13] = (v_0 & 0xffffULL); - row[layout.auxiliaries + 14] = ((v_0 >> 16) & 0xffffULL); - row[layout.auxiliaries + 15] = (uint64_t(op_2) & 0xffffULL); - row[layout.auxiliaries + 16] = ((uint64_t(op_2) >> 16) & 0xffffULL); - row[layout.auxiliaries + 17] = (v_3 & 0xffffULL); - row[layout.auxiliaries + 18] = ((v_3 >> 16) & 0xffffULL); - switch (v_20) { - case 1ULL: { - const uint64_t v_21 = seed.word(21); - row[layout.auxiliaries + 19] = v_21; - row[layout.selectors + 1] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 19] = (v_20 <= 1ULL ? inverse_763_0[v_20] : inverse(goldilocks_sub(v_20, 1ULL))); - const uint64_t v_22 = goldilocks_sub(v_0, v_3); - switch (v_22) { - case 0ULL: { - row[layout.selectors + 2] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 20] = (v_22 <= 0ULL ? inverse_763_1[v_22] : inverse(goldilocks_sub(v_22, 0ULL))); - const uint64_t v_23 = seed.word(21); - row[layout.auxiliaries + 21] = v_23; - row[layout.selectors + 3] = 1; - return 0; - } - } - } - } - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_763(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_763 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_763(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_763(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_763<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_763<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_763(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 < 8 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 22) 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_763); -} - -template struct Seed_ixvm_765 { - 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_765(Seed_ixvm_765 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_765(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_765 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_765(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_765(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_765<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_765<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_765(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_765); -} - -template struct Seed_ixvm_766 { - 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 + 216); - case 2: return load_u8(data + 224); - case 3: return load_u64(data + 8); - case 4: return load_u64(data + 16); - case 5: return load_u64(data + 24); - case 6: return load_u8(data + 225); - case 7: return load_u8(data + 226); - case 8: return load_u8(data + 227); - case 9: return load_u8(data + 228); - case 10: return load_u8(data + 229); - case 11: return load_u8(data + 230); - case 12: return load_u64(data + 32); - case 13: return load_u64(data + 40); - case 14: return load_u8(data + 231); - case 15: return load_u8(data + 232); - case 16: return load_u8(data + 233); - case 17: return load_u8(data + 234); - case 18: return load_u8(data + 235); - case 19: return load_u8(data + 236); - case 20: return load_u64(data + 48); - case 21: return load_u64(data + 56); - case 22: return load_u8(data + 237); - case 23: return load_u8(data + 238); - case 24: return load_u8(data + 239); - case 25: return load_u8(data + 240); - case 26: return load_u8(data + 241); - case 27: return load_u8(data + 242); - case 28: return load_u64(data + 64); - case 29: return load_u64(data + 72); - case 30: return load_u8(data + 243); - case 31: return load_u8(data + 244); - case 32: return load_u8(data + 245); - case 33: return load_u8(data + 246); - case 34: return load_u8(data + 247); - case 35: return load_u8(data + 248); - case 36: return load_u64(data + 80); - case 37: return load_u32(data + 220); - case 38: return load_u64(data + 88); - case 39: return load_u64(data + 96); - case 40: return load_u64(data + 104); - case 41: return load_u64(data + 112); - case 42: return load_u64(data + 120); - case 43: return load_u64(data + 128); - case 44: return load_u64(data + 136); - case 45: return load_u64(data + 144); - case 46: return load_u64(data + 152); - case 47: return load_u64(data + 160); - case 48: return load_u64(data + 168); - case 49: return load_u64(data + 176); - case 50: return load_u64(data + 184); - case 51: return load_u64(data + 192); - case 52: return load_u64(data + 200); - case 53: return load_u64(data + 208); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_766(Seed_ixvm_766 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); - 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); - 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); - 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); - 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; - row[layout.auxiliaries + 11] = v_11; - row[layout.auxiliaries + 12] = v_12; - row[layout.auxiliaries + 13] = v_13; - row[layout.auxiliaries + 14] = v_14; - row[layout.auxiliaries + 15] = v_15; - row[layout.auxiliaries + 16] = v_16; - row[layout.auxiliaries + 17] = v_17; - row[layout.auxiliaries + 18] = v_18; - row[layout.auxiliaries + 19] = v_19; - row[layout.auxiliaries + 20] = v_20; - row[layout.auxiliaries + 21] = v_21; - row[layout.auxiliaries + 22] = v_22; - row[layout.auxiliaries + 23] = v_23; - row[layout.auxiliaries + 24] = v_24; - row[layout.auxiliaries + 25] = v_25; - row[layout.auxiliaries + 26] = v_26; - row[layout.auxiliaries + 27] = v_27; - row[layout.auxiliaries + 28] = v_28; - row[layout.auxiliaries + 29] = v_29; - row[layout.auxiliaries + 30] = v_30; - row[layout.auxiliaries + 31] = v_31; - row[layout.auxiliaries + 32] = v_32; - row[layout.auxiliaries + 33] = v_33; - row[layout.auxiliaries + 34] = v_34; - row[layout.auxiliaries + 35] = v_35; - row[layout.auxiliaries + 36] = v_36; - switch (v_1) { - case 1ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_38 = seed.word(38); - const uint64_t v_39 = seed.word(39); - const uint64_t v_40 = seed.word(40); - const uint64_t v_41 = seed.word(41); - const uint64_t v_42 = seed.word(42); - const uint64_t v_43 = seed.word(43); - const uint64_t v_44 = seed.word(44); - const uint64_t v_45 = seed.word(45); - row[layout.auxiliaries + 37] = v_38; - row[layout.auxiliaries + 38] = v_39; - row[layout.auxiliaries + 39] = v_40; - row[layout.auxiliaries + 40] = v_41; - row[layout.auxiliaries + 41] = v_42; - row[layout.auxiliaries + 42] = v_43; - row[layout.auxiliaries + 43] = v_44; - row[layout.auxiliaries + 44] = v_45; - const uint64_t v_46 = seed.word(46); - const uint64_t v_47 = seed.word(47); - const uint64_t v_48 = seed.word(48); - const uint64_t v_49 = seed.word(49); - const uint64_t v_50 = seed.word(50); - const uint64_t v_51 = seed.word(51); - const uint64_t v_52 = seed.word(52); - const uint64_t v_53 = seed.word(53); - row[layout.auxiliaries + 45] = v_46; - row[layout.auxiliaries + 46] = v_47; - row[layout.auxiliaries + 47] = v_48; - row[layout.auxiliaries + 48] = v_49; - row[layout.auxiliaries + 49] = v_50; - row[layout.auxiliaries + 50] = v_51; - row[layout.auxiliaries + 51] = v_52; - row[layout.auxiliaries + 52] = v_53; - row[layout.selectors + 1] = 1; - return 0; - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_766(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 ? 256 : 432; - const Seed_ixvm_766 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_766(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_766(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_766<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_766<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_766(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 < 53) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 256 : encoding == 0 ? 432 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_766); -} - -template struct Seed_ixvm_768 { - 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_768(Seed_ixvm_768 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_768(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_768 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_768(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_768(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_768<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_768<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_768(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_768); -} - -template struct Seed_ixvm_771 { - 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 + 160); - case 2: return load_u8(data + 168); - case 3: return load_u64(data + 8); - case 4: return load_u64(data + 16); - case 5: return load_u8(data + 169); - case 6: return load_u8(data + 170); - case 7: return load_u8(data + 171); - case 8: return load_u8(data + 172); - case 9: return load_u8(data + 173); - case 10: return load_u8(data + 174); - case 11: return load_u64(data + 24); - case 12: return load_u32(data + 164); - case 13: return load_u64(data + 32); - case 14: return load_u64(data + 40); - case 15: return load_u64(data + 48); - case 16: return load_u64(data + 56); - case 17: return load_u64(data + 64); - case 18: return load_u64(data + 72); - case 19: return load_u64(data + 80); - case 20: return load_u64(data + 88); - case 21: return load_u64(data + 96); - case 22: return load_u64(data + 104); - case 23: return load_u64(data + 112); - case 24: return load_u64(data + 120); - case 25: return load_u64(data + 128); - case 26: return load_u64(data + 136); - case 27: return load_u64(data + 144); - case 28: return load_u64(data + 152); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_771(Seed_ixvm_771 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); - const uint64_t v_11 = seed.word(12); - 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; - row[layout.auxiliaries + 11] = v_11; - switch (v_1) { - case 1ULL: { - row[layout.selectors + 0] = 1; - return 0; - } - case 0ULL: { - const uint64_t v_13 = seed.word(13); - 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); - row[layout.auxiliaries + 12] = v_13; - row[layout.auxiliaries + 13] = v_14; - row[layout.auxiliaries + 14] = v_15; - row[layout.auxiliaries + 15] = v_16; - row[layout.auxiliaries + 16] = v_17; - row[layout.auxiliaries + 17] = v_18; - row[layout.auxiliaries + 18] = v_19; - row[layout.auxiliaries + 19] = v_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); - const uint64_t v_24 = seed.word(24); - const uint64_t v_25 = seed.word(25); - const uint64_t v_26 = seed.word(26); - const uint64_t v_27 = seed.word(27); - const uint64_t v_28 = seed.word(28); - row[layout.auxiliaries + 20] = v_21; - row[layout.auxiliaries + 21] = v_22; - row[layout.auxiliaries + 22] = v_23; - row[layout.auxiliaries + 23] = v_24; - row[layout.auxiliaries + 24] = v_25; - row[layout.auxiliaries + 25] = v_26; - row[layout.auxiliaries + 26] = v_27; - row[layout.auxiliaries + 27] = v_28; - row[layout.selectors + 1] = 1; - return 0; - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_771(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 : 232; - const Seed_ixvm_771 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_771(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_771(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_771<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_771<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_771(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 < 28) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 176 : encoding == 0 ? 232 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_771); -} - -__device__ __constant__ uint64_t inverse_777_0[] = {0ULL}; -template struct Seed_ixvm_777 { - 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_777(Seed_ixvm_777 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_777_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_777(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_777 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_777(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_777(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_777<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_777<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_777(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_777); -} - -__device__ __constant__ uint64_t inverse_782_0[] = {18446744069414584320ULL, 0ULL}; -__device__ __constant__ uint64_t inverse_782_1[] = {0ULL}; -template struct Seed_ixvm_782 { - 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 + 112); - case 2: return load_u64(data + 8); - case 3: return load_u8(data + 176); - case 4: return load_u64(data + 16); - case 5: return load_u32(data + 116); - case 6: return load_u64(data + 24); - case 7: return load_u32(data + 120); - case 8: return load_u32(data + 124); - case 9: return load_u32(data + 128); - case 10: return load_u64(data + 32); - case 11: return load_u32(data + 132); - case 12: return load_u64(data + 40); - case 13: return load_u32(data + 136); - case 14: return load_u32(data + 140); - case 15: return load_u8(data + 177); - case 16: return load_u64(data + 48); - case 17: return load_u32(data + 144); - case 18: return load_u64(data + 56); - case 19: return load_u32(data + 148); - case 20: return load_u32(data + 152); - case 21: return load_u32(data + 156); - case 22: return load_u64(data + 64); - case 23: return load_u64(data + 72); - case 24: return load_u64(data + 80); - case 25: return load_u32(data + 160); - case 26: return load_u32(data + 164); - case 27: return load_u8(data + 178); - case 28: return load_u64(data + 88); - case 29: return load_u64(data + 96); - case 30: return load_u64(data + 104); - case 31: return load_u32(data + 168); - case 32: return load_u32(data + 172); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_782(Seed_ixvm_782 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; - switch (v_2) { - case 1ULL: { - const uint64_t v_10 = seed.word(9); - row[layout.auxiliaries + 1] = v_10; - row[layout.selectors + 0] = 1; - return 0; - } - case 0ULL: { - 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_11; - row[layout.auxiliaries + 2] = v_12; - row[layout.auxiliaries + 3] = v_13; - row[layout.auxiliaries + 4] = v_14; - row[layout.auxiliaries + 5] = v_15; - row[layout.auxiliaries + 6] = v_16; - 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); - 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; - row[layout.auxiliaries + 12] = v_22; - if (v_0 > 0xffffffffULL || v_4 > 0xffffffffULL) return 3; - const uint32_t op_5 = uint32_t(v_0) - uint32_t(v_4); - const uint64_t v_23 = uint64_t(v_0 < v_4); - row[layout.auxiliaries + 13] = (v_0 & 0xffffULL); - row[layout.auxiliaries + 14] = ((v_0 >> 16) & 0xffffULL); - row[layout.auxiliaries + 15] = (uint64_t(op_5) & 0xffffULL); - row[layout.auxiliaries + 16] = ((uint64_t(op_5) >> 16) & 0xffffULL); - row[layout.auxiliaries + 17] = (v_4 & 0xffffULL); - row[layout.auxiliaries + 18] = ((v_4 >> 16) & 0xffffULL); - switch (v_23) { - case 1ULL: { - const uint64_t v_24 = seed.word(21); - const uint64_t v_25 = seed.word(22); - const uint64_t v_26 = seed.word(23); - const uint64_t v_27 = seed.word(24); - const uint64_t v_28 = seed.word(25); - const uint64_t v_29 = seed.word(26); - row[layout.auxiliaries + 19] = v_24; - 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; - const uint64_t v_30 = seed.word(27); - const uint64_t v_31 = seed.word(28); - const uint64_t v_32 = seed.word(29); - const uint64_t v_33 = seed.word(30); - const uint64_t v_34 = seed.word(31); - const uint64_t v_35 = seed.word(32); - 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.selectors + 1] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 19] = (v_23 <= 1ULL ? inverse_782_0[v_23] : inverse(goldilocks_sub(v_23, 1ULL))); - const uint64_t v_36 = goldilocks_sub(v_0, v_4); - switch (v_36) { - case 0ULL: { - const uint64_t v_38 = seed.word(21); - row[layout.auxiliaries + 20] = v_38; - const uint64_t v_39 = seed.word(22); - row[layout.auxiliaries + 21] = v_39; - row[layout.selectors + 2] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 20] = (v_36 <= 0ULL ? inverse_782_1[v_36] : inverse(goldilocks_sub(v_36, 0ULL))); - const uint64_t v_40 = seed.word(21); - const uint64_t v_41 = seed.word(22); - const uint64_t v_42 = seed.word(23); - const uint64_t v_43 = seed.word(24); - const uint64_t v_44 = seed.word(25); - const uint64_t v_45 = seed.word(26); - row[layout.auxiliaries + 21] = v_40; - row[layout.auxiliaries + 22] = v_41; - row[layout.auxiliaries + 23] = v_42; - row[layout.auxiliaries + 24] = v_43; - row[layout.auxiliaries + 25] = v_44; - row[layout.auxiliaries + 26] = v_45; - const uint64_t v_46 = seed.word(27); - const uint64_t v_47 = seed.word(28); - const uint64_t v_48 = seed.word(29); - const uint64_t v_49 = seed.word(30); - const uint64_t v_50 = seed.word(31); - const uint64_t v_51 = seed.word(32); - row[layout.auxiliaries + 27] = v_46; - row[layout.auxiliaries + 28] = v_47; - row[layout.auxiliaries + 29] = v_48; - row[layout.auxiliaries + 30] = v_49; - row[layout.auxiliaries + 31] = v_50; - row[layout.auxiliaries + 32] = v_51; - row[layout.selectors + 3] = 1; - return 0; - } - } - } - } - } - default: { - return 2; - } - } -} -template __global__ void kernel_ixvm_782(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_782 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_782(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_782(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_782<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_782<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_782(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 < 8 || auxiliaries < selectors || auxiliaries - selectors < 4 || width < auxiliaries || width - auxiliaries < 33) 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_782); -} - -__device__ __constant__ uint64_t inverse_783_0[] = {18446744069414584320ULL, 0ULL}; -template struct Seed_ixvm_783 { - 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_u32(data + 112); - case 9: return load_u32(data + 116); - 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_u32(data + 120); - case 15: return load_u32(data + 124); - case 16: return load_u32(data + 128); - case 17: return load_u32(data + 132); - case 18: return load_u64(data + 96); - case 19: return load_u64(data + 104); - case 20: return load_u32(data + 136); - case 21: return load_u32(data + 140); - default: return 0; - } - } -}; -template __device__ __forceinline__ uint32_t row_ixvm_783(Seed_ixvm_783 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; - switch (v_0) { - case 1ULL: { - const uint64_t v_15 = seed.word(16); - const uint64_t v_16 = seed.word(17); - 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); - row[layout.auxiliaries + 1] = v_15; - row[layout.auxiliaries + 2] = v_16; - row[layout.auxiliaries + 3] = v_17; - row[layout.auxiliaries + 4] = v_18; - row[layout.auxiliaries + 5] = v_19; - row[layout.auxiliaries + 6] = v_20; - row[layout.selectors + 0] = 1; - return 0; - } - default: { - row[layout.auxiliaries + 1] = (v_0 <= 1ULL ? inverse_783_0[v_0] : inverse(goldilocks_sub(v_0, 1ULL))); - const uint64_t v_22 = seed.word(16); - row[layout.auxiliaries + 2] = v_22; - const uint64_t v_23 = seed.word(17); - row[layout.auxiliaries + 3] = v_23; - row[layout.selectors + 1] = 1; - return 0; - } - } -} -template __global__ void kernel_ixvm_783(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 ? 144 : 176; - const Seed_ixvm_783 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_ixvm_783(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_ixvm_783(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_783<<>>(seeds, real, rows, layout, output, error); - else kernel_ixvm_783<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_ixvm_783(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 < 15 || auxiliaries < selectors || auxiliaries - selectors < 2 || width < auxiliaries || width - auxiliaries < 7) return int(cudaErrorInvalidValue); - const size_t stride = encoding == 1 ? 144 : encoding == 0 ? 176 : 0; - return upload(device, seeds, encoding, stride, real, rows, {width, selectors, auxiliaries}, output, launch_ixvm_783); -} - -extern "C" const uint8_t* aiur_trace_ixvm_contract() { - static const uint8_t hash[32] = {134, 255, 142, 155, 247, 231, 0, 155, 156, 136, 201, 185, 23, 188, 13, 83, 187, 4, 113, 195, 47, 43, 101, 210, 29, 29, 27, 138, 47, 144, 112, 191}; - return hash; -} -extern "C" const uint8_t* aiur_trace_ixvm_schema() { - static const uint8_t hash[32] = {63, 91, 117, 50, 80, 90, 212, 4, 235, 24, 107, 94, 84, 249, 63, 203, 8, 1, 215, 241, 165, 238, 247, 222, 166, 172, 140, 73, 23, 5, 219, 38}; - return hash; -} -} diff --git a/crates/aiur/cuda/generated/production/multi_stark.cu b/crates/aiur/cuda/generated/production/multi_stark.cu deleted file mode 100644 index c18bf55db..000000000 --- a/crates/aiur/cuda/generated/production/multi_stark.cu +++ /dev/null @@ -1,6707 +0,0 @@ -// 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_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 + 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_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); - 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_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 ? 848 : 1552; - 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 < 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_79); -} - -__device__ __constant__ uint64_t inverse_81_0[] = {0ULL}; -__device__ __constant__ uint64_t inverse_81_1[] = {0ULL}; -__device__ __constant__ uint64_t inverse_81_2[] = {0ULL}; -__device__ __constant__ uint64_t inverse_81_3[] = {0ULL}; -__device__ __constant__ uint64_t inverse_81_4[] = {0ULL}; -__device__ __constant__ uint64_t inverse_81_5[] = {0ULL}; -__device__ __constant__ uint64_t inverse_81_6[] = {0ULL}; -__device__ __constant__ uint64_t inverse_81_7[] = {0ULL}; -__device__ __constant__ uint64_t inverse_81_8[] = {0ULL}; -__device__ __constant__ uint64_t inverse_81_9[] = {0ULL}; -template struct Seed_multi_stark_81 { - 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_81(Seed_multi_stark_81 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_81_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_81_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_81_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_81_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_81_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_81_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_81_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_81_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_81_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_81_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_153 = goldilocks_sub(v_2, v_1); - const uint64_t v_154 = uint64_t(v_153 == 0); - row[layout.auxiliaries + 11] = inverse(v_153); - row[layout.auxiliaries + 12] = v_154; - 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_81(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_81 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_multi_stark_81(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_multi_stark_81(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_81<<>>(seeds, real, rows, layout, output, error); - else kernel_multi_stark_81<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_multi_stark_81(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_81); -} - -template struct Seed_multi_stark_82 { - 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_82(Seed_multi_stark_82 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 = goldilocks_mul(v_8, v_73); - const uint64_t v_75 = seed.word(72); - const uint64_t v_76 = seed.word(73); - const uint64_t v_77 = seed.word(74); - const uint64_t v_78 = seed.word(75); - const uint64_t v_79 = seed.word(76); - const uint64_t v_80 = seed.word(77); - const uint64_t v_81 = seed.word(78); - const uint64_t v_82 = seed.word(79); - row[layout.auxiliaries + 66] = v_75; - row[layout.auxiliaries + 67] = v_76; - row[layout.auxiliaries + 68] = v_77; - row[layout.auxiliaries + 69] = v_78; - row[layout.auxiliaries + 70] = v_79; - row[layout.auxiliaries + 71] = v_80; - row[layout.auxiliaries + 72] = v_81; - row[layout.auxiliaries + 73] = v_82; - const uint64_t v_83 = seed.word(80); - row[layout.auxiliaries + 74] = v_83; - const uint64_t v_84 = goldilocks_mul(v_74, v_83); - row[layout.auxiliaries + 75] = v_84; - 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_199, v_208); - row[layout.auxiliaries + 77] = v_209; - 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_82(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_82 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_multi_stark_82(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_multi_stark_82(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_82<<>>(seeds, real, rows, layout, output, error); - else kernel_multi_stark_82<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_multi_stark_82(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_82); -} - -__device__ __constant__ uint64_t inverse_86_0[] = {15811494916641072275ULL, 3074457344902430720ULL, 3689348813882916864ULL, 4611686017353646080ULL, 6148914689804861440ULL, 9223372034707292160ULL, 18446744069414584320ULL, 0ULL}; -template struct Seed_multi_stark_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_multi_stark_86(Seed_multi_stark_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 = goldilocks_mul(v_165, v_167); - row[layout.auxiliaries + 6] = v_168; - const uint64_t v_169 = 2ULL; - const uint64_t v_170 = goldilocks_sub(v_165, v_169); - const uint64_t v_171 = goldilocks_mul(v_168, 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_mul(v_199, v_200); - row[layout.auxiliaries + 29] = v_201; - const uint64_t v_202 = goldilocks_sub(v_199, v_169); - const uint64_t v_203 = goldilocks_mul(v_201, 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_mul(v_230, v_231); - row[layout.auxiliaries + 52] = v_232; - const uint64_t v_233 = goldilocks_sub(v_230, v_169); - const uint64_t v_234 = goldilocks_mul(v_232, 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_mul(v_261, v_262); - row[layout.auxiliaries + 75] = v_263; - const uint64_t v_264 = goldilocks_sub(v_261, v_169); - const uint64_t v_265 = goldilocks_mul(v_263, 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_mul(v_292, v_293); - row[layout.auxiliaries + 98] = v_294; - const uint64_t v_295 = goldilocks_sub(v_292, v_169); - const uint64_t v_296 = goldilocks_mul(v_294, 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_mul(v_323, v_324); - row[layout.auxiliaries + 121] = v_325; - const uint64_t v_326 = goldilocks_sub(v_323, v_169); - const uint64_t v_327 = goldilocks_mul(v_325, 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_mul(v_354, v_355); - row[layout.auxiliaries + 144] = v_356; - const uint64_t v_357 = goldilocks_sub(v_354, v_169); - const uint64_t v_358 = goldilocks_mul(v_356, 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_mul(v_385, v_386); - row[layout.auxiliaries + 167] = v_387; - const uint64_t v_388 = goldilocks_sub(v_385, v_169); - const uint64_t v_389 = goldilocks_mul(v_387, 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_mul(v_416, v_417); - row[layout.auxiliaries + 190] = v_418; - const uint64_t v_419 = goldilocks_sub(v_416, v_169); - const uint64_t v_420 = goldilocks_mul(v_418, 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_mul(v_447, v_448); - row[layout.auxiliaries + 213] = v_449; - const uint64_t v_450 = goldilocks_sub(v_447, v_169); - const uint64_t v_451 = goldilocks_mul(v_449, 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_mul(v_478, v_479); - row[layout.auxiliaries + 236] = v_480; - const uint64_t v_481 = goldilocks_sub(v_478, v_169); - const uint64_t v_482 = goldilocks_mul(v_480, 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_mul(v_509, v_510); - row[layout.auxiliaries + 259] = v_511; - const uint64_t v_512 = goldilocks_sub(v_509, v_169); - const uint64_t v_513 = goldilocks_mul(v_511, 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_mul(v_540, v_541); - row[layout.auxiliaries + 282] = v_542; - const uint64_t v_543 = goldilocks_sub(v_540, v_169); - const uint64_t v_544 = goldilocks_mul(v_542, 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_mul(v_571, v_572); - row[layout.auxiliaries + 305] = v_573; - const uint64_t v_574 = goldilocks_sub(v_571, v_169); - const uint64_t v_575 = goldilocks_mul(v_573, 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_mul(v_602, v_603); - row[layout.auxiliaries + 328] = v_604; - const uint64_t v_605 = goldilocks_sub(v_602, v_169); - const uint64_t v_606 = goldilocks_mul(v_604, 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_mul(v_633, v_634); - row[layout.auxiliaries + 351] = v_635; - const uint64_t v_636 = goldilocks_sub(v_633, v_169); - const uint64_t v_637 = goldilocks_mul(v_635, 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_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_multi_stark_86 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_multi_stark_86(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_multi_stark_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_multi_stark_86<<>>(seeds, real, rows, layout, output, error); - else kernel_multi_stark_86<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_multi_stark_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_multi_stark_86); -} - -__device__ __constant__ uint64_t inverse_103_0[] = {0ULL}; -template struct Seed_multi_stark_103 { - 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_103(Seed_multi_stark_103 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_103_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 = goldilocks_add(v_69, v_70); - const uint64_t v_95 = goldilocks_add(v_94, v_71); - const uint64_t v_96 = goldilocks_add(v_95, v_72); - const uint64_t v_97 = 1020ULL; - const uint64_t v_98 = goldilocks_sub(v_96, 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_65, v_66); - const uint64_t v_101 = goldilocks_add(v_100, v_67); - const uint64_t v_102 = goldilocks_add(v_101, v_68); - 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_add(v_112, v_113); - const uint64_t v_131 = goldilocks_add(v_130, v_114); - const uint64_t v_132 = goldilocks_add(v_131, v_115); - const uint64_t v_133 = goldilocks_sub(v_132, v_97); - 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_108, v_109); - const uint64_t v_136 = goldilocks_add(v_135, v_110); - const uint64_t v_137 = goldilocks_add(v_136, v_111); - 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_add(v_146, v_147); - const uint64_t v_165 = goldilocks_add(v_164, v_148); - const uint64_t v_166 = goldilocks_add(v_165, v_149); - const uint64_t v_167 = goldilocks_sub(v_166, v_97); - 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_142, v_143); - const uint64_t v_170 = goldilocks_add(v_169, v_144); - const uint64_t v_171 = goldilocks_add(v_170, v_145); - 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_103(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_103 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_multi_stark_103(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_multi_stark_103(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_103<<>>(seeds, real, rows, layout, output, error); - else kernel_multi_stark_103<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_multi_stark_103(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_103); -} - -__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_multi_stark_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_multi_stark_117(Seed_multi_stark_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_223 = goldilocks_mul(v_217, v_220); - row[layout.auxiliaries + 109] = v_223; - 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_multi_stark_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_multi_stark_117 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_multi_stark_117(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_multi_stark_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_multi_stark_117<<>>(seeds, real, rows, layout, output, error); - else kernel_multi_stark_117<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_multi_stark_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_multi_stark_117); -} - -template struct Seed_multi_stark_175 { - 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_175(Seed_multi_stark_175 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_175(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_175 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_multi_stark_175(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_multi_stark_175(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_175<<>>(seeds, real, rows, layout, output, error); - else kernel_multi_stark_175<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_multi_stark_175(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_175); -} - -template struct Seed_multi_stark_203 { - 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_203(Seed_multi_stark_203 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_203(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_203 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_multi_stark_203(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_multi_stark_203(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_203<<>>(seeds, real, rows, layout, output, error); - else kernel_multi_stark_203<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_multi_stark_203(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_203); -} - -template struct Seed_multi_stark_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_multi_stark_220(Seed_multi_stark_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_multi_stark_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_multi_stark_220 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_multi_stark_220(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_multi_stark_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_multi_stark_220<<>>(seeds, real, rows, layout, output, error); - else kernel_multi_stark_220<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_multi_stark_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_multi_stark_220); -} - -template struct Seed_multi_stark_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_multi_stark_230(Seed_multi_stark_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_multi_stark_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_multi_stark_230 seed{seeds + r * stride}; - row[layout.auxiliaries] = seed.word(0); - const uint32_t status = row_multi_stark_230(seed, layout, row); - if (status) atomicCAS(error, 0U, status); -} -cudaError_t launch_multi_stark_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_multi_stark_230<<>>(seeds, real, rows, layout, output, error); - else kernel_multi_stark_230<<>>(seeds, real, rows, layout, output, error); - return cudaGetLastError(); -} -extern "C" int aiur_trace_multi_stark_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_multi_stark_230); -} - -extern "C" const uint8_t* aiur_trace_multi_stark_contract() { - static const uint8_t hash[32] = {87, 27, 221, 210, 4, 48, 191, 225, 86, 204, 54, 145, 96, 172, 15, 58, 83, 30, 136, 181, 161, 157, 101, 136, 23, 109, 212, 12, 145, 122, 135, 142}; - return hash; -} -extern "C" const uint8_t* aiur_trace_multi_stark_schema() { - static const uint8_t hash[32] = {105, 41, 233, 159, 250, 24, 100, 231, 195, 57, 124, 247, 26, 138, 78, 204, 167, 40, 6, 104, 2, 198, 160, 185, 202, 205, 230, 237, 66, 77, 71, 31}; - return hash; -} -} diff --git a/crates/aiur/cuda/population.cu b/crates/aiur/cuda/population.cu new file mode 100644 index 000000000..97abfec45 --- /dev/null +++ b/crates/aiur/cuda/population.cu @@ -0,0 +1,522 @@ +// SPDX-License-Identifier: MIT OR Apache-2.0 +// +// Stage-one row population on the GPU for the certified Aiur trace plans. +// +// Each row is filled by interpreting its function's compiled population plan +// (the same dataflow graph the host `FillPlan` runs): guarded arithmetic, +// inverses, branch and failure witnesses, the U8 library's byte tables, the +// U32/U64 word hints, and calls resolved from the callee's recorded queries +// through a device hash index. Then the function's placement in its physical +// circuit is applied: column writes, selector, group writes and multiplicity. +// Plans needing host-only state (memory stores and loads, stream hints) are +// never encoded, so their circuits stay on the host. +// +// Every value is a canonical Goldilocks word. The encoding is produced by +// `crates/aiur/src/trace/stark/gpu.rs`; keep the two in sync. + +#include +#include + +#include +#include + +using namespace multi_stark_cuda; + +namespace { + +// Plan opcodes. +constexpr uint32_t OP_ADD = 0, OP_SUB = 1, OP_MUL = 2, OP_SELECT = 3, + OP_INVERSE = 4, OP_CHOICE = 5, OP_FAILURE = 6, OP_MAP = 7, + OP_CALL = 8, OP_HINT = 9; +// Byte-table maps of the U8 library. +constexpr uint32_t MAP_FROM_FIELD = 0, MAP_BITS = 1, MAP_RANGE_PAIR = 2, + MAP_XOR = 3, MAP_AND = 4, MAP_OR = 5, MAP_LT = 6, + MAP_ADD = 7, MAP_SUB = 8, MAP_MUL = 9, MAP_XOR_SPLIT4 = 10, + MAP_XOR_SPLIT7 = 11, MAP_SUM_BYTE = 12; +// Word hints. +constexpr uint32_t HINT_U32_BYTES = 0, HINT_U32_SUB = 1, HINT_U32_ADD = 2, + HINT_U32_ADD3 = 3, HINT_U32_LT = 4, HINT_BYTES_LE = 5; +// Group-write polynomial tokens. +constexpr uint32_t POLY_CONST = 0, POLY_VAR = 1, POLY_ADD = 2, POLY_SUB = 3, + POLY_MUL = 4; +// Population failures, reported with the first failing row. +constexpr int32_t ERROR_ZERO_INVERSE = 1, ERROR_NO_ARM = 2, + ERROR_NO_FAILURE = 3, ERROR_MAP_DOMAIN = 4, + ERROR_MISSING_CALLEE = 5, ERROR_HINT_DOMAIN = 6, + ERROR_ENCODING = 7, ERROR_POLY_STACK = 8; +constexpr uint32_t CONSTANT = 0x80000000u; +constexpr uint32_t EMPTY = 0; +constexpr int POLY_STACK = 64; +// Operands and results of byte maps and word hints (at most 12). +constexpr uint32_t SMALL = 16; + +} // namespace + +// Layouts shared with `gpu.rs` (`#[repr(C)]`). +// A member function of a circuit. Its recorded queries are `count` rows of +// `stride` words (inputs, then outputs), filling circuit rows from `first`. +struct AiurFunction { + const uint32_t* code; + const uint64_t* constants; + const uint64_t* rows; + const uint64_t* multiplicities; + uint64_t count; + uint64_t first; + uint32_t code_len; + uint32_t scratch; + uint32_t inputs; + uint32_t outputs; + uint32_t stride; + uint32_t pad; +}; + +// A function whose recorded outputs calls read, indexed by input. +struct AiurCallee { + const uint64_t* rows; + const uint32_t* index; + uint64_t count; + uint32_t mask; + uint32_t inputs; + uint32_t outputs; + uint32_t stride; +}; + +struct AiurCircuit { + const AiurFunction* members; + const AiurCallee* callees; + uint64_t real; + uint32_t member_count; + uint32_t width; + uint32_t scratch; + uint32_t pad; +}; + +struct AiurPopulationError { + int32_t code; + uint32_t op; + uint64_t row; +}; + +namespace { + +// One hash for stored keys and for keys read from plan operands. +__device__ __forceinline__ uint64_t hash_step(uint64_t h, uint64_t word) { + h ^= word; + h *= 0x100000001b3ULL; + return h ^ (h >> 29); +} +__device__ __forceinline__ uint64_t hash_finish(uint64_t h) { + h ^= h >> 32; + h *= 0xd6e8feb86659fd93ULL; + return h ^ (h >> 32); +} +__device__ __forceinline__ uint64_t key_hash(const uint64_t* words, uint32_t width) { + uint64_t h = 0x9e3779b97f4a7c15ULL ^ width; + for (uint32_t i = 0; i < width; ++i) h = hash_step(h, words[i]); + return hash_finish(h); +} + +__device__ void fail(AiurPopulationError* error, int32_t code, uint32_t op, uint64_t row) { + if (atomicCAS(&error->code, 0, code) == 0) { + error->op = op; + error->row = row; + } +} + +__device__ __forceinline__ uint64_t inverse(uint64_t value) { + return goldilocks_pow(value, GOLDILOCKS_P - 2); +} + +struct Scratch { + uint64_t* base; + size_t stride; + __device__ __forceinline__ uint64_t& operator[](uint32_t slot) const { + return base[size_t(slot) * stride]; + } +}; + +__device__ __forceinline__ uint64_t value_of(uint32_t value, const uint64_t* constants, + const Scratch& scratch) { + return (value & CONSTANT) ? constants[value & ~CONSTANT] : scratch[value]; +} + +// A callee query whose recorded input equals the plan operands `key`. +__device__ int64_t find_query(const AiurCallee& callee, const uint32_t* key, + const uint64_t* constants, const Scratch& scratch) { + uint64_t h = 0x9e3779b97f4a7c15ULL ^ callee.inputs; + for (uint32_t i = 0; i < callee.inputs; ++i) + h = hash_step(h, value_of(key[i], constants, scratch)); + uint64_t slot = hash_finish(h) & callee.mask; + for (uint64_t probe = 0; probe <= callee.mask; ++probe) { + const uint32_t entry = callee.index[slot]; + if (entry == EMPTY) return -1; + const uint64_t query = entry - 1; + const uint64_t* stored = callee.rows + query * callee.stride; + bool equal = true; + for (uint32_t i = 0; i < callee.inputs && equal; ++i) + equal = stored[i] == value_of(key[i], constants, scratch); + if (equal) return int64_t(query); + slot = (slot + 1) & callee.mask; + } + return -1; +} + +__device__ bool evaluate_map(uint32_t kind, const uint64_t* in, uint64_t* out) { + const uint64_t a = in[0]; + switch (kind) { + case MAP_FROM_FIELD: + if (a >= 256) return false; + out[0] = a; + return true; + case MAP_BITS: + if (a >= 256) return false; + for (int i = 0; i < 8; ++i) out[i] = (a >> i) & 1; + return true; + case MAP_SUM_BYTE: + if (a >= 768) return false; + out[0] = a & 255; + return true; + default: + break; + } + const uint64_t b = in[1]; + if ((a | b) > 255) return false; + switch (kind) { + case MAP_RANGE_PAIR: return true; + case MAP_XOR: out[0] = a ^ b; return true; + case MAP_AND: out[0] = a & b; return true; + case MAP_OR: out[0] = a | b; return true; + case MAP_LT: out[0] = a < b ? 1 : 0; return true; + case MAP_ADD: out[0] = (a + b) & 255; out[1] = (a + b) >> 8; return true; + case MAP_SUB: out[0] = (a - b) & 255; out[1] = a < b ? 1 : 0; return true; + case MAP_MUL: out[0] = (a * b) & 255; out[1] = (a * b) >> 8; return true; + case MAP_XOR_SPLIT4: out[0] = (a ^ b) >> 4; out[1] = ((a ^ b) & 15) << 4; return true; + case MAP_XOR_SPLIT7: out[0] = (a ^ b) >> 7; out[1] = ((a ^ b) & 127) << 1; return true; + default: return false; + } +} + +__device__ __forceinline__ void word_bytes(uint32_t word, uint64_t* out) { + for (int i = 0; i < 4; ++i) out[i] = (word >> (8 * i)) & 255; +} + +__device__ bool evaluate_hint(uint32_t kind, const uint64_t* in, uint32_t nargs, uint64_t* out) { + switch (kind) { + case HINT_U32_BYTES: + word_bytes(uint32_t(in[0]), out); + return true; + case HINT_U32_SUB: + word_bytes(uint32_t(in[0]) - uint32_t(in[1]), out); + return true; + case HINT_U32_ADD: + case HINT_U32_ADD3: { + uint32_t sum = 0; + for (uint32_t word = 0; word < nargs / 4; ++word) { + uint32_t value = 0; + for (int i = 0; i < 4; ++i) { + const uint64_t byte = in[4 * word + i]; + if (byte > 255) return false; + value |= uint32_t(byte) << (8 * i); + } + sum += value; + } + word_bytes(sum, out); + return true; + } + case HINT_U32_LT: { + const uint32_t a = uint32_t(in[0]), b = uint32_t(in[1]); + word_bytes(a, out); + word_bytes(a - b, out + 4); + word_bytes(b, out + 8); + return true; + } + case HINT_BYTES_LE: + for (int i = 0; i < 8; ++i) out[i] = (in[0] >> (8 * i)) & 255; + return true; + default: + return false; + } +} + + +// Interprets one function's plan for one query into `row`. Returns false on +// a population failure, which `fail` has recorded. +__device__ bool fill_row(const AiurFunction& f, const AiurCallee* callees, uint64_t query, + uint64_t row_index, const Scratch& scratch, uint64_t* row, + uint32_t width, AiurPopulationError* error) { + const uint64_t* constants = f.constants; + const uint64_t* recorded = f.rows + query * f.stride; + for (uint32_t i = 0; i < f.inputs + f.outputs; ++i) scratch[i] = recorded[i]; + uint64_t buffer[SMALL]; + const uint32_t* code = f.code; + uint32_t pc = 0; + const uint32_t kernels = code[pc++]; + for (uint32_t k = 0; k < kernels; ++k) { + const uint32_t op = code[pc++]; + const uint32_t guard = code[pc++]; + const uint32_t start = code[pc++]; + const uint32_t width_k = code[pc++]; + const uint32_t size = code[pc++]; // words that follow, so inactive kernels skip them + const uint32_t body = pc; + pc += size; + if (value_of(guard, constants, scratch) != 1) { + for (uint32_t i = 0; i < width_k; ++i) scratch[start + i] = 0; + continue; + } + const uint32_t* args = code + body; + switch (op) { + case OP_ADD: + scratch[start] = goldilocks_add(value_of(args[0], constants, scratch), + value_of(args[1], constants, scratch)); + break; + case OP_SUB: + scratch[start] = goldilocks_sub(value_of(args[0], constants, scratch), + value_of(args[1], constants, scratch)); + break; + case OP_MUL: + scratch[start] = goldilocks_mul(value_of(args[0], constants, scratch), + value_of(args[1], constants, scratch)); + break; + case OP_SELECT: + scratch[start] = value_of(args[0], constants, scratch) == 1 + ? value_of(args[1], constants, scratch) + : value_of(args[2], constants, scratch); + break; + case OP_INVERSE: { + const uint64_t v = value_of(args[0], constants, scratch); + if (v == 0) { fail(error, ERROR_ZERO_INVERSE, k, row_index); return false; } + scratch[start] = inverse(v); + break; + } + case OP_CHOICE: { + for (uint32_t i = 0; i < width_k; ++i) scratch[start + i] = 0; + uint32_t at = 0; + const uint32_t tests = args[at++]; + int64_t selected = -1; + for (uint32_t t = 0; t < tests; ++t) { + const uint32_t len = args[at++]; + bool zero = true; + for (uint32_t i = 0; i < len; ++i) + zero = zero && value_of(args[at + i], constants, scratch) == 0; + at += len; + if (zero && selected < 0) selected = t; + } + if (selected < 0) { fail(error, ERROR_NO_ARM, k, row_index); return false; } + scratch[start + uint32_t(selected)] = 1; + break; + } + case OP_FAILURE: { + for (uint32_t i = 0; i < width_k; ++i) scratch[start + i] = 0; + const uint32_t len = args[0]; + int64_t found = -1; + uint64_t witness = 0; + for (uint32_t i = 0; i < len && found < 0; ++i) { + const uint64_t x = value_of(args[1 + i], constants, scratch); + if (x != 0) { found = i; witness = x; } + } + if (found < 0) { fail(error, ERROR_NO_FAILURE, k, row_index); return false; } + scratch[start + uint32_t(found)] = inverse(witness); + break; + } + case OP_MAP: + case OP_HINT: { + const uint32_t target = args[0]; + const uint32_t nargs = args[1]; + if (nargs > SMALL || width_k > SMALL) { + fail(error, ERROR_ENCODING, k, row_index); + return false; + } + for (uint32_t i = 0; i < nargs; ++i) + buffer[i] = value_of(args[2 + i], constants, scratch); + uint64_t out[SMALL]; + const bool ok = op == OP_MAP ? evaluate_map(target, buffer, out) + : evaluate_hint(target, buffer, nargs, out); + if (!ok) { + fail(error, op == OP_MAP ? ERROR_MAP_DOMAIN : ERROR_HINT_DOMAIN, k, row_index); + return false; + } + for (uint32_t i = 0; i < width_k; ++i) scratch[start + i] = out[i]; + break; + } + case OP_CALL: { + const AiurCallee& callee = callees[args[0]]; + if (args[1] != callee.inputs || width_k != callee.outputs) { + fail(error, ERROR_ENCODING, k, row_index); + return false; + } + const int64_t found = find_query(callee, args + 2, constants, scratch); + if (found < 0) { + fail(error, ERROR_MISSING_CALLEE, k, row_index); + return false; + } + const uint64_t* values = callee.rows + uint64_t(found) * callee.stride + callee.inputs; + for (uint32_t i = 0; i < width_k; ++i) scratch[start + i] = values[i]; + break; + } + default: + fail(error, ERROR_ENCODING, k, row_index); + return false; + } + } + // Column writes, already mapped to the physical circuit. + const uint32_t writes = code[pc++]; + for (uint32_t w = 0; w < writes; ++w) { + const uint32_t guard = code[pc++], column = code[pc++], value = code[pc++]; + if (value_of(guard, constants, scratch) == 1) + row[column] = value_of(value, constants, scratch); + } + // Placement: selector, group writes over the row, multiplicity. + const uint32_t selector = code[pc++]; + row[selector] = 1; + const uint32_t group_writes = code[pc++]; + for (uint32_t g = 0; g < group_writes; ++g) { + const uint32_t column = code[pc++]; + const uint32_t tokens = code[pc++]; + uint64_t stack[POLY_STACK]; + int depth = 0; + for (uint32_t t = 0; t < tokens; ++t) { + const uint32_t token = code[pc++]; + const uint32_t payload = code[pc++]; + if (token == POLY_CONST || token == POLY_VAR) { + if (depth == POLY_STACK) { fail(error, ERROR_POLY_STACK, g, row_index); return false; } + stack[depth++] = token == POLY_CONST ? constants[payload] : row[payload]; + } else { + if (depth < 2) { fail(error, ERROR_POLY_STACK, g, row_index); return false; } + const uint64_t b = stack[--depth], a = stack[--depth]; + if (token == POLY_ADD) stack[depth++] = goldilocks_add(a, b); + else if (token == POLY_SUB) stack[depth++] = goldilocks_sub(a, b); + else if (token == POLY_MUL) stack[depth++] = goldilocks_mul(a, b); + else { fail(error, ERROR_ENCODING, g, row_index); return false; } + } + } + if (depth != 1) { fail(error, ERROR_POLY_STACK, g, row_index); return false; } + row[column] = stack[0]; + } + row[width - 1] = f.multiplicities[query]; + return true; +} + +// Row `r` of the output is circuit row `base + (first + r) % height`: a +// shard of `height` rows starting at `base`, wrapped for lookup halos. +__global__ void populate_kernel(AiurCircuit circuit, uint64_t* output, uint64_t base, + uint64_t first, uint64_t rows, uint64_t height, + uint64_t* scratch_base, AiurPopulationError* error) { + const uint64_t threads = uint64_t(gridDim.x) * blockDim.x; + const uint64_t thread = uint64_t(blockIdx.x) * blockDim.x + threadIdx.x; + const Scratch scratch{scratch_base + thread, size_t(threads)}; + for (uint64_t r = thread; r < rows; r += threads) { + uint64_t* row = output + r * circuit.width; + for (uint32_t c = 0; c < circuit.width; ++c) row[c] = 0; + const uint64_t index = base + (first + r) % height; + if (index >= circuit.real) continue; + uint32_t member = 0; + while (member + 1 < circuit.member_count && circuit.members[member + 1].first <= index) + ++member; + const AiurFunction& f = circuit.members[member]; + fill_row(f, circuit.callees, index - f.first, index, scratch, row, circuit.width, error); + } +} + +__global__ void canonicalize_kernel(uint64_t* words, uint64_t count) { + const uint64_t stride = uint64_t(gridDim.x) * blockDim.x; + for (uint64_t i = uint64_t(blockIdx.x) * blockDim.x + threadIdx.x; i < count; i += stride) + words[i] = canonicalize(words[i]); +} + +__global__ void index_kernel(const uint64_t* rows, uint64_t count, uint32_t inputs, + uint32_t row_stride, uint32_t* index, uint32_t mask) { + const uint64_t stride = uint64_t(gridDim.x) * blockDim.x; + for (uint64_t q = uint64_t(blockIdx.x) * blockDim.x + threadIdx.x; q < count; q += stride) { + uint64_t slot = key_hash(rows + q * row_stride, inputs) & mask; + while (atomicCAS(&index[slot], EMPTY, uint32_t(q + 1)) != EMPTY) slot = (slot + 1) & mask; + } +} + +constexpr unsigned BLOCK = 128; + +unsigned blocks_for(uint64_t work, unsigned limit) { + const uint64_t blocks = (work + BLOCK - 1) / BLOCK; + return unsigned(blocks == 0 ? 1 : (blocks < limit ? blocks : limit)); +} + +} // namespace + +extern "C" { + +// Threads a population launch uses at most; the caller sizes the scratch +// buffer as `aiur_gpu_population_threads() * circuit.scratch` words. +uint64_t aiur_gpu_population_threads() { return uint64_t(BLOCK) * 512; } + +int aiur_gpu_malloc(int device, size_t bytes, void** output) { + cudaError_t status = cudaSetDevice(device); + if (status != cudaSuccess) return status; + return cudaMalloc(output, bytes == 0 ? 8 : bytes); +} + +int aiur_gpu_free(int device, void* pointer) { + cudaError_t status = cudaSetDevice(device); + if (status != cudaSuccess) return status; + return cudaFree(pointer); +} + +int aiur_gpu_upload(int device, void* destination, const void* source, size_t bytes) { + cudaError_t status = cudaSetDevice(device); + if (status != cudaSuccess || bytes == 0) return status; + return cudaMemcpy(destination, source, bytes, cudaMemcpyHostToDevice); +} + +int aiur_gpu_download(int device, void* destination, const void* source, size_t bytes) { + cudaError_t status = cudaSetDevice(device); + if (status != cudaSuccess || bytes == 0) return status; + return cudaMemcpy(destination, source, bytes, cudaMemcpyDeviceToHost); +} + +int aiur_gpu_canonicalize(int device, uint64_t* words, uint64_t count) { + cudaError_t status = cudaSetDevice(device); + if (status != cudaSuccess || count == 0) return status; + canonicalize_kernel<<>>(words, count); + status = cudaGetLastError(); + if (status != cudaSuccess) return status; + return cudaStreamSynchronize(cudaStreamPerThread); +} + +int aiur_gpu_build_index(int device, const uint64_t* rows, uint64_t count, uint32_t inputs, + uint32_t row_stride, uint32_t* index, uint32_t mask) { + cudaError_t status = cudaSetDevice(device); + if (status != cudaSuccess) return status; + status = cudaMemsetAsync(index, 0, (uint64_t(mask) + 1) * sizeof(uint32_t), + cudaStreamPerThread); + if (status != cudaSuccess || count == 0) { + return status != cudaSuccess ? status : cudaStreamSynchronize(cudaStreamPerThread); + } + index_kernel<<>>(rows, count, inputs, row_stride, index, mask); + status = cudaGetLastError(); + if (status != cudaSuccess) return status; + return cudaStreamSynchronize(cudaStreamPerThread); +} + +// Fills `rows` rows of the shard of `circuit` that starts at row `base` and +// has `height` rows, starting at shard row `first` and wrapping, into +// `output` (row-major device memory), synchronously on the calling thread's +// default stream. `scratch` holds `aiur_gpu_population_threads() * +// circuit->scratch` words; `error` must start zeroed and reports the first +// failing row. +int aiur_gpu_populate(int device, const AiurCircuit* circuit, uint64_t* output, uint64_t base, + uint64_t first, uint64_t rows, uint64_t height, uint64_t* scratch, + AiurPopulationError* error) { + cudaError_t status = cudaSetDevice(device); + if (status != cudaSuccess || rows == 0) return status; + const unsigned blocks = blocks_for(rows, unsigned(aiur_gpu_population_threads() / BLOCK)); + // Scratch is laid out for the full thread count the kernel strides by. + populate_kernel<<>>(*circuit, output, base, first, rows, height, scratch, + error); + status = cudaGetLastError(); + if (status != cudaSuccess) return status; + return cudaStreamSynchronize(cudaStreamPerThread); +} + +const char* aiur_gpu_error_string(int status) { + return cudaGetErrorString(static_cast(status)); +} + +} // extern "C" diff --git a/crates/aiur/cuda/trace-manifest.json b/crates/aiur/cuda/trace-manifest.json deleted file mode 100644 index 30654d1cb..000000000 --- a/crates/aiur/cuda/trace-manifest.json +++ /dev/null @@ -1,70 +0,0 @@ -{"units": - [{"source": "cuda/generated/fixtures.cu", - "digest": - [206, - 17, - 70, - 193, - 109, - 68, - 98, - 125, - 87, - 126, - 27, - 221, - 75, - 62, - 93, - 104, - 42, - 163, - 70, - 70, - 18, - 163, - 196, - 216, - 114, - 251, - 77, - 134, - 156, - 91, - 254, - 186]}, - {"source": "cuda/generated/blake3.cu", - "digest": - [237, - 14, - 28, - 96, - 126, - 206, - 152, - 72, - 223, - 232, - 94, - 251, - 145, - 83, - 56, - 221, - 118, - 0, - 109, - 58, - 239, - 190, - 94, - 180, - 190, - 81, - 65, - 140, - 86, - 227, - 226, - 170]}], - "abi": 2} diff --git a/crates/aiur/cuda/trace_primitives.cuh b/crates/aiur/cuda/trace_primitives.cuh deleted file mode 100644 index f60c70b6a..000000000 --- a/crates/aiur/cuda/trace_primitives.cuh +++ /dev/null @@ -1,24 +0,0 @@ -#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 deleted file mode 100644 index c3213226f..000000000 --- a/crates/aiur/cuda/trace_runtime.cu +++ /dev/null @@ -1,296 +0,0 @@ -#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); -} - -// A tile of `words` u64 on `device` for a caller that drives a writer -// outside the prover and reads the rows back; `aiur_trace_tile_download` -// copies it out after the per-thread stream's work on it and frees it. -extern "C" int aiur_trace_tile_alloc(int device, size_t words, uint64_t** tile) { - if (!tile) return int(cudaErrorInvalidValue); - *tile = nullptr; - cudaError_t status = cudaSetDevice(device); - if (status != cudaSuccess) return int(status); - status = cudaMalloc(reinterpret_cast(tile), words * sizeof(uint64_t)); - if (status != cudaSuccess) { - cudaGetLastError(); - *tile = nullptr; - } - return int(status); -} - -extern "C" int aiur_trace_tile_download(int device, uint64_t* tile, size_t words, - uint64_t* host) { - if (!tile || !host) return int(cudaErrorInvalidValue); - cudaError_t status = cudaSetDevice(device); - if (status == cudaSuccess) - status = cudaMemcpyAsync(host, tile, words * sizeof(uint64_t), - cudaMemcpyDeviceToHost, cudaStreamPerThread); - const auto synced = cudaStreamSynchronize(cudaStreamPerThread); - if (status == cudaSuccess) status = synced; - const auto freed = cudaFree(tile); - if (status == cudaSuccess) status = freed; - 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 deleted file mode 100644 index 2215e13c4..000000000 --- a/crates/aiur/cuda/trace_runtime.cuh +++ /dev/null @@ -1,58 +0,0 @@ -#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); -// A device tile for driving a writer outside the prover; the download copies -// it to `host` after the per-thread stream's work on it and frees it. -int aiur_trace_tile_alloc(int device, size_t words, uint64_t** tile); -int aiur_trace_tile_download(int device, uint64_t* tile, size_t words, uint64_t* host); -} diff --git a/crates/aiur/examples/library_check.rs b/crates/aiur/examples/library_check.rs new file mode 100644 index 000000000..21259b80a --- /dev/null +++ b/crates/aiur/examples/library_check.rs @@ -0,0 +1,209 @@ +//! Check the shared modules exported by `lake exe library_tests PACKAGE.json`. +use aiur::{ + Program, + bytecode::Type, + hints::HintChannels, + maps::MapOverrides, + trace::{ + TraceArtifact, TracePlan, + stark::{Backend, Parameters}, + }, +}; +use serde::Deserialize; +use std::error::Error; + +#[derive(Deserialize)] +struct Package { + program: Program, + trace: TraceArtifact, +} + +fn bytes(word: u64) -> Vec { + word.to_le_bytes().into_iter().map(u64::from).collect() +} + +fn main() -> Result<(), Box> { + let path = + std::env::args().nth(1).ok_or("usage: library_check PACKAGE.json")?; + let package: Package = serde_json::from_slice(&std::fs::read(path)?)?; + let program = package.program.check()?; + let mut channels = HintChannels::new(); + aiur::library::u32::register(&mut channels, program.field())?; + aiur::library::u64::register(&mut channels, program.field())?; + let mut maps = MapOverrides::new(); + aiur::library::u8::register_maps(&program, &mut maps)?; + let tables = program.prepare_hint_channels(&[], &channels)?; + let accelerated = + program.prepare_hint_channels(&[], &channels)?.with_map_overrides(&maps)?; + let plan = TracePlan::new(&program, package.trace)?; + let backend = Backend::new(&plan, Parameters::default())?; + let mut checks = 0; + let mut check = |entry: &str, + args: Vec, + expected: Vec| + -> Result<_, Box> { + let record = accelerated.execute(entry, args.clone())?; + assert_eq!(record.output, expected, "{entry}({args:?})"); + let fallback = tables.execute(entry, args.clone())?; + assert_eq!(record.output, fallback.output); + assert_eq!(record.queries, fallback.queries); + let trace = plan.generate(&record, entry, &args, true)?; + plan.check(&record, &trace, entry, &args)?; + assert_eq!(trace, plan.generate_reference(&record, entry, &args, true)?); + checks += 1; + Ok(()) + }; + check("InterfaceBytes::run", vec![173, 99], vec![206])?; + check("InterfaceWords::run", vec![u64::from(u32::MAX), 1], vec![0])?; + for byte in 0..256 { + check("ByteChecks::checked", vec![byte], vec![byte])?; + } + for sum in 0..768 { + check("ByteChecks::split", vec![sum], vec![sum % 256, sum / 256])?; + } + for a in [0, 1, 15, 16, 127, 128, 254, 255] { + for b in [0, 1, 15, 16, 127, 128, 254, 255] { + check("ByteChecks::less_than", vec![a, b], vec![u64::from(a < b)])?; + check("ByteChecks::and", vec![a, b], vec![a & b])?; + check("ByteChecks::or", vec![a, b], vec![a | b])?; + check("ByteChecks::add", vec![a, b], vec![(a + b) % 256, (a + b) / 256])?; + check( + "ByteChecks::sub", + vec![a, b], + vec![(a + 256 - b) % 256, u64::from(a < b)], + )?; + check("ByteChecks::mul", vec![a, b], vec![(a * b) % 256, (a * b) / 256])?; + check("ByteChecks::join4", vec![a, b], vec![a / 16 + (b % 16) * 16])?; + check("ByteChecks::join7", vec![a, b], vec![a / 128 + (b % 128) * 2])?; + } + } + let mut values = vec![ + 0, + 1, + 255, + 256, + 65535, + 65536, + 1 << 32, + 1 << 56, + 1 << 63, + u64::MAX - 1, + u64::MAX, + ]; + let mut seed = 0x93c4_18bd_u64; + for _ in 0..16 { + seed = + seed.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407); + values.push(seed); + } + for a in values { + check("Wide::wrapping_succ", bytes(a), bytes(a.wrapping_add(1)))?; + check("Wide::saturating_pred", bytes(a), bytes(a.saturating_sub(1)))?; + check("Wide::is_zero", bytes(a), vec![u64::from(a == 0)])?; + for b in [0, 1, u64::MAX, a, a.rotate_left(13)] { + let args = [bytes(a), bytes(b)].concat(); + let (sum, carry) = a.overflowing_add(b); + check( + "Wide::add", + args.clone(), + [bytes(sum), vec![u64::from(carry)]].concat(), + )?; + let (diff, borrow) = a.overflowing_sub(b); + check( + "Wide::sub", + args.clone(), + [bytes(diff), vec![u64::from(borrow)]].concat(), + )?; + let product = u128::from(a) * u128::from(b); + check( + "Wide::mul", + args.clone(), + [bytes(product as u64), bytes((product >> 64) as u64)].concat(), + )?; + check("Wide::eq", args.clone(), vec![u64::from(a == b)])?; + for (op, result) in [("and", a & b), ("or", a | b), ("xor", a ^ b)] { + check(&format!("Wide::{op}"), args.clone(), bytes(result))?; + } + } + } + for word in [0, 1, 255, 256, (1 << 56) - 1] { + check("Wide::from_field", vec![word], bytes(word))?; + check("Wide::to_field", bytes(word), vec![word])?; + } + // Block/chunk boundaries and odd Merkle layers, compared with the Rust + // Blake3 crate. This tests the library, not a copied hash implementation. + for length in [0, 1, 63, 64, 65, 1023, 1024, 1025, 2048, 2049, 3072, 4097] { + let input: Vec = (0..length).map(|i| i as u8).collect(); + let expected = + blake3::hash(&input).as_bytes().iter().copied().map(u64::from).collect(); + check("Benchmark::hash", vec![length], expected)?; + } + println!( + "Passed {checks} native/table execution and reference-trace comparisons." + ); + + for (entry, args) in [ + ("ByteChecks::checked", vec![256]), + ("ByteChecks::checked", vec![program.field().modulus() - 1]), + ("ByteChecks::less_than", vec![256, 0]), + ("ByteChecks::less_than", vec![0, 256]), + ("ByteChecks::less_than", vec![program.field().modulus() - 1, 0]), + ("ByteChecks::less_than", vec![0, program.field().modulus() - 1]), + ("ByteChecks::split", vec![768]), + ("ByteChecks::split", vec![program.field().modulus() - 1]), + ("ByteChecks::add", vec![256, 0]), + ("ByteChecks::add", vec![0, 256]), + ("ByteChecks::sub", vec![0, 256]), + ("ByteChecks::join4", vec![256, 0]), + ("ByteChecks::join7", vec![0, 256]), + ("Wide::add", [vec![256, 0, 0, 0, 0, 0, 0, 0], bytes(0)].concat()), + ("Wide::from_field", vec![1 << 56]), + ("Wide::to_field", bytes(1 << 56)), + ] { + assert!( + accelerated.execute(entry, args.clone()).is_err(), + "{entry}({args:?})" + ); + assert!(tables.execute(entry, args.clone()).is_err(), "{entry}({args:?})"); + } + // Wrong raw advice still executes under constrain_eq!, but its proof fails. + let mut dishonest = HintChannels::new(); + dishonest.insert( + "bytes_le", + Type::Field, + Type::Tuple { items: vec![Type::Field; 8] }, + |_, out| { + out.fill(0); + Ok(()) + }, + )?; + let bad = program.prepare_hint_channels(&[], &dishonest)?; + for (entry, args) in [ + ("Wide::from_field", vec![1]), + ("Wide::mul", [bytes(1), bytes(1)].concat()), + ] { + let record = bad.execute(entry, args.clone())?; + let witness = backend.generate(&record, entry, &args)?; + let proof = backend.prove(entry, &args, &record.output, witness)?; + assert!(backend.verify(entry, &args, &record.output, &proof).is_err()); + } + for (entry, args) in [ + ("Wide::mul", [bytes(u64::MAX), bytes(u64::MAX)].concat()), + ("Benchmark::hash", vec![1025]), + ] { + let record = accelerated.execute(entry, args.clone())?; + let trace = plan.generate(&record, entry, &args, true)?; + let witness = backend.generate(&record, entry, &args)?; + let reference = backend.witness(&record, &trace)?; + for (a, b) in witness.traces.iter().zip(&reference.traces) { + assert_eq!(a.width, b.width); + assert_eq!(a.values, b.values); + } + let proof = backend.prove(entry, &args, &record.output, witness)?; + backend.verify(entry, &args, &record.output, &proof)?; + } + println!( + "Passed invalid-domain checks, 2 rejected dishonest-hint proofs and 2 verified U64/Blake3 proofs." + ); + Ok(()) +} diff --git a/crates/aiur/examples/prove.rs b/crates/aiur/examples/prove.rs new file mode 100644 index 000000000..0c17b2f04 --- /dev/null +++ b/crates/aiur/examples/prove.rs @@ -0,0 +1,153 @@ +//! Prove a Lean `export-trace` package. The default entry is its first selected +//! entrypoint. See design/multi-stark.md for the trust boundary and commands. +use aiur::field::FieldBackend; +use aiur::{ + Program, + hints::HintEntry, + trace::{ + TraceArtifact, TracePlan, + stark::{Backend, Parameters, Proof}, + }, +}; +use multi_stark::p3_field::PrimeField64; +use multi_stark::p3_matrix::Matrix; +use serde::Deserialize; +use serde_json::json; +use std::{error::Error, time::Instant}; + +#[derive(Deserialize)] +struct Package { + program: Program, + #[serde(default)] + hints: Vec, + #[serde(alias = "args")] + address: Vec, + trace: TraceArtifact, +} + +fn main() -> Result<(), Box> { + let args: Vec<_> = std::env::args().collect(); + let path = + args.get(1).ok_or("usage: prove PACKAGE.json [PROOF.bin] [REPORT.json]")?; + let start = Instant::now(); + let package: Package = serde_json::from_slice(&std::fs::read(path)?)?; + let program = package.program.check_field::()?; + let address = program.field().decode(&package.address)?; + let hints = program.prepare_hints(&package.hints)?; + let plan = TracePlan::new(&program, package.trace)?; + let entry = + &program.program().entries.first().ok_or("no selected entrypoint")?.name; + let prepare_seconds = start.elapsed().as_secs_f64(); + + let mut parameters = Parameters::default(); + if let Ok(n) = std::env::var("AIUR_STARK_LOG_BLOWUP") { + parameters.log_blowup = n.parse()?; + } + if let Ok(n) = std::env::var("AIUR_STARK_QUERIES") { + parameters.num_queries = n.parse()?; + } + eprintln!("Setting up circuits and committing fixed tables..."); + let start = Instant::now(); + let backend = Backend::new(&plan, parameters)?; + let setup_seconds = start.elapsed().as_secs_f64(); + + let start = Instant::now(); + let record = hints.execute(entry, address.clone())?; + let execution_seconds = start.elapsed().as_secs_f64(); + let reference = std::env::var_os("AIUR_WITNESS_REFERENCE").is_some(); + let (witness, generation_seconds, witness_seconds, check_seconds) = + if reference { + let start = Instant::now(); + let trace = plan.generate(&record, entry, &address, true)?; + let generation_seconds = start.elapsed().as_secs_f64(); + let start = Instant::now(); + plan.check(&record, &trace, entry, &address)?; + let check_seconds = start.elapsed().as_secs_f64(); + let start = Instant::now(); + let witness = backend.witness(&record, &trace)?; + ( + witness, + generation_seconds, + start.elapsed().as_secs_f64(), + check_seconds, + ) + } else { + let start = Instant::now(); + let witness = backend.generate(&record, entry, &address)?; + let witness_seconds = start.elapsed().as_secs_f64(); + // Diagnostics remain outside witness/proving measurements. Check the + // independent writer and compare every function column and count. + let start = Instant::now(); + let trace = plan.generate_reference(&record, entry, &address, true)?; + plan.check(&record, &trace, entry, &address)?; + for (matrix, actual) in trace.matrices.iter().zip(&witness.traces) { + if actual.width != matrix.width + 1 || actual.height() != matrix.height + { + return Err("fused witness shape differs from the reference".into()); + } + for r in 0..matrix.height { + let row = &actual.values[r * actual.width..(r + 1) * actual.width]; + if !row[..matrix.width] + .iter() + .copied() + .eq(matrix.row(r).iter().copied()) + || row[matrix.width].as_canonical_u64() != matrix.multiplicities[r] + { + return Err("fused witness differs from the reference".into()); + } + } + } + (witness, 0.0, witness_seconds, start.elapsed().as_secs_f64()) + }; + let statistics = backend.statistics(); + let circuits: Vec<_> = statistics + .iter() + .zip(&witness.traces) + .map(|(s, t)| { + let mut value = serde_json::to_value(s).unwrap(); + value["height"] = json!(t.height()); + value + }) + .collect(); + let stage1_words: usize = witness.traces.iter().map(|t| t.values.len()).sum(); + let output = record.output.clone(); + drop(record); + eprintln!( + "Proving {} active circuits ({} stage-1 words)...", + witness.traces.iter().filter(|t| t.height() > 0).count(), + stage1_words + ); + let start = Instant::now(); + let proof = backend.prove(entry, &address, &output, witness)?; + let prove_seconds = start.elapsed().as_secs_f64(); + let bytes = proof.to_bytes()?; + let proof = Proof::from_bytes(&bytes)?; + eprintln!("Verifying serialized proof ({} bytes)...", bytes.len()); + let start = Instant::now(); + backend.verify(entry, &address, &output, &proof)?; + let verify_seconds = start.elapsed().as_secs_f64(); + if let Some(path) = args.get(2) { + std::fs::write(path, &bytes)?; + } + let report = json!({ + "entry": entry, "args": address, "output": output, "parameters": parameters, + "prepare_seconds": prepare_seconds, "setup_seconds": setup_seconds, + "execution_seconds": execution_seconds, "generation_seconds": generation_seconds, + "check_seconds": check_seconds, "witness_seconds": witness_seconds, + "witness_mode": if reference { "reference" } else { "fused" }, + "prove_seconds": prove_seconds, "verify_seconds": verify_seconds, + "proof_bytes": bytes.len(), "stage1_words": stage1_words, + "verified": true, "circuits": circuits, + }); + if let Some(path) = args.get(3) { + serde_json::to_writer_pretty( + std::io::BufWriter::new(std::fs::File::create(path)?), + &report, + )?; + } + // Circuit details go in the report; stdout is a short timing summary. + let mut summary = report; + summary.as_object_mut().unwrap().remove("circuits"); + println!("{}", serde_json::to_string_pretty(&summary)?); + Ok(()) +} diff --git a/crates/aiur/examples/trie_bench.rs b/crates/aiur/examples/trie_bench.rs new file mode 100644 index 000000000..a4bc20dcd --- /dev/null +++ b/crates/aiur/examples/trie_bench.rs @@ -0,0 +1,146 @@ +//! Bytecode-only, hint-free persistent trie benchmark. +use aiur::field::FieldBackend; +use aiur::{ + Program, + trace::{ + TraceArtifact, TracePlan, + stark::{Backend, Parameters, Proof}, + }, +}; +use multi_stark::p3_matrix::Matrix; +use serde::Deserialize; +use serde_json::json; +use std::{error::Error, time::Instant}; + +#[path = "../../../tools/bench/profile.rs"] +mod profile; + +#[derive(Deserialize)] +struct Package { + program: Program, + trace: TraceArtifact, +} +#[derive(Deserialize)] +struct Fixture { + args: Vec, + expected: Vec, +} + +fn main() -> Result<(), Box> { + let cli: Vec<_> = std::env::args().collect(); + if cli.len() != 5 { + return Err( + "usage: trie_bench PACKAGE.json FIXTURE.json prove|execute|witness SAMPLES".into(), + ); + } + let mode = &cli[3]; + let samples: usize = cli[4].parse()?; + if !["prove", "execute", "witness"].contains(&mode.as_str()) || samples == 0 { + return Err("invalid mode or sample count".into()); + } + let start = Instant::now(); + let package: Package = serde_json::from_slice(&std::fs::read(&cli[1])?)?; + let fixture: Fixture = serde_json::from_slice(&std::fs::read(&cli[2])?)?; + let program = package.program.check_field::()?; + let args = program.field().decode(&fixture.args)?; + let expected = program.field().decode(&fixture.expected)?; + assert!(program.program().functions.iter().all(|f| { + f.code + .iter() + .all(|op| !matches!(op, aiur::bytecode::Instruction::Hint { .. })) + })); + let plan = TracePlan::new(&program, package.trace)?; + let entry = &program.program().entries[0].name; + let prepare_seconds = start.elapsed().as_secs_f64(); + let parameters = Parameters::default(); + let start = Instant::now(); + let backend = Backend::new(&plan, parameters)?; + let setup_seconds = start.elapsed().as_secs_f64(); + let profiler = profile::Profiler::from_env()?; + let mut times = vec![]; + if mode == "execute" { + for sample in 0..samples + 2 { + let guard = if sample >= 2 { + profiler.as_ref().map(|p| p.start("execute", sample - 2)).transpose()? + } else { + None + }; + let start = Instant::now(); + let record = program.execute(entry, args.clone())?; + let elapsed = start.elapsed().as_secs_f64(); + drop(guard); + assert_eq!(record.output, expected); + if sample >= 2 { + times.push(elapsed); + } + } + println!( + "{}", + json!({"engine": "new-aiur-bytecode", "mode": mode, "seconds": times, "output": expected}) + ); + return Ok(()); + } + let start = Instant::now(); + let record = program.execute(entry, args.clone())?; + let execution_seconds = start.elapsed().as_secs_f64(); + assert_eq!(record.output, expected); + let counts = json!({"function_queries": record.queries.len(), "memory_queries": record.memory.len(), "instructions": record.instructions}); + let mut raw_rows = std::collections::HashMap::new(); + for key in record.queries.keys() { + *raw_rows + .entry(program.program().functions[key.function].name.clone()) + .or_insert(0usize) += 1; + } + for cell in record.memory.iter() { + *raw_rows.entry(format!("", cell.cell.value.len())).or_insert(0) += + 1; + } + let mut last = None; + for sample in 0..if mode == "witness" { samples + 2 } else { 1 } { + let guard = if mode == "witness" && sample >= 2 { + profiler.as_ref().map(|p| p.start("witness", sample - 2)).transpose()? + } else { + None + }; + let start = Instant::now(); + let witness = backend.generate(&record, entry, &args)?; + let elapsed = start.elapsed().as_secs_f64(); + drop(guard); + if mode == "prove" || sample >= 2 { + times.push(elapsed); + } + last = Some(witness); + } + let witness = last.unwrap(); + let statistics = backend.statistics(); + let circuits: Vec<_> = statistics + .iter() + .zip(&witness.traces) + .map(|(s, t)| { + let mut value = serde_json::to_value(s).unwrap(); + value["height"] = json!(t.height()); + value["rows"] = + json!(raw_rows.get(s.name.as_str()).copied().unwrap_or(0)); + value + }) + .collect(); + let stage1_words: usize = witness.traces.iter().map(|t| t.values.len()).sum(); + drop(record); + let start = Instant::now(); + let proof = backend.prove(entry, &args, &expected, witness)?; + let prove_seconds = start.elapsed().as_secs_f64(); + let bytes = proof.to_bytes()?; + let proof = Proof::from_bytes(&bytes)?; + let start = Instant::now(); + backend.verify(entry, &args, &expected, &proof)?; + let verify_seconds = start.elapsed().as_secs_f64(); + println!( + "{}", + json!({"engine": "new-aiur-bytecode", "mode": mode, "args": args, "output": expected, + "prepare_seconds": prepare_seconds, "setup_seconds": setup_seconds, + "execution_seconds": execution_seconds, "witness_seconds": times[0], "seconds": times, + "prove_seconds": prove_seconds, "verify_seconds": verify_seconds, "proof_bytes": bytes.len(), + "counts": counts, "stage1_words": stage1_words, "circuits": circuits, "verified": true}) + ); + Ok(()) +} diff --git a/crates/aiur/examples/u32_check.rs b/crates/aiur/examples/u32_check.rs new file mode 100644 index 000000000..60d6052ce --- /dev/null +++ b/crates/aiur/examples/u32_check.rs @@ -0,0 +1,270 @@ +//! Exercise the actual Lean-exported opaque word library, including malicious +//! advice and mutated circuit rows. Run after `lake exe u32_tests PACKAGE.json`. +use aiur::{ + Program, + bytecode::Type, + execute::Execution, + hints::HintChannels, + maps::MapOverrides, + trace::{ + TraceArtifact, TracePlan, + stark::{Backend, Parameters}, + }, +}; +use serde::Deserialize; +use std::error::Error; + +#[derive(Deserialize)] +struct Package { + program: Program, + trace: TraceArtifact, +} + +fn bytes(word: u32) -> Vec { + word.to_le_bytes().into_iter().map(u64::from).collect() +} + +fn main() -> Result<(), Box> { + let path = std::env::args().nth(1).ok_or("usage: u32_check PACKAGE.json")?; + let package: Package = serde_json::from_slice(&std::fs::read(path)?)?; + let program = package.program.check()?; + let mut channels = HintChannels::new(); + aiur::library::u32::register(&mut channels, program.field())?; + let mut maps = MapOverrides::new(); + aiur::library::u8::register_maps(&program, &mut maps)?; + let hints = + program.prepare_hint_channels(&[], &channels)?.with_map_overrides(&maps)?; + let table_hints = program.prepare_hint_channels(&[], &channels)?; + let plan = TracePlan::new(&program, package.trace)?; + let backend = Backend::new(&plan, Parameters::default())?; + let mut checks = 0; + let mut check = |name: &str, + args: Vec, + expected: Vec| + -> Result<_, Box> { + let entry = format!("Words::{name}"); + let record = hints.execute(&entry, args.clone())?; + assert_eq!(record.output, expected, "{entry}({args:?})"); + let fallback = table_hints.execute(&entry, args.clone())?; + assert_eq!(record.output, fallback.output); + assert_eq!(record.queries, fallback.queries); + let trace = plan.generate(&record, &entry, &args, true)?; + plan.check(&record, &trace, &entry, &args)?; + assert_eq!(trace, plan.generate_reference(&record, &entry, &args, true)?); + checks += 1; + Ok(()) + }; + let mut values = + vec![0, 1, 255, 256, 65535, 65536, 1 << 31, u32::MAX - 1, u32::MAX]; + let mut seed = 0x93c4_18bd_u32; + for _ in 0..32 { + seed = seed.wrapping_mul(1664525).wrapping_add(1013904223); + values.push(seed); + } + for &a in &values { + check("pack", bytes(a), vec![u64::from(a)])?; + check("expand", vec![u64::from(a)], bytes(a))?; + check("rotr8", bytes(a), vec![u64::from(a.rotate_right(8))])?; + check("rotr16", bytes(a), vec![u64::from(a.rotate_right(16))])?; + for b in [0, 1, u32::MAX, a.rotate_left(13)] { + let args: Vec<_> = bytes(a).into_iter().chain(bytes(b)).collect(); + for (operation, result) in [ + ("add", a.wrapping_add(b)), + ("sub", a.wrapping_sub(b)), + ("lt", u32::from(a < b)), + ("xor", a ^ b), + ("and", a & b), + ("or", a | b), + ("xor_rotr7", (a ^ b).rotate_right(7)), + ("xor_rotr12", (a ^ b).rotate_right(12)), + ] { + check(operation, args.clone(), vec![u64::from(result)])?; + } + check("compact_lt", vec![a.into(), b.into()], vec![u64::from(a < b)])?; + check("raw_lt", vec![a.into(), b.into()], vec![u64::from(a < b)])?; + let args = args.into_iter().chain(bytes(b)).collect(); + check("add3", args, vec![u64::from(a.wrapping_add(b).wrapping_add(b))])?; + } + } + check("overflow", vec![], vec![0])?; + check("overflow3", vec![], vec![u64::from(u32::MAX - 2)])?; + check("conversion", vec![], vec![u64::from(u32::MAX)])?; + + // constrain_eq! intentionally permits candidate execution. Both population + // paths must retain the equality, and a proof of a wrong result must not verify. + let reject = |record: &Execution, + entry: &str, + args: &[u64], + prove: bool| + -> Result<(), Box> { + let trace = plan.generate(record, entry, args, true)?; + assert!( + plan.check(record, &trace, entry, args).is_err(), + "{entry}({args:?}), output {:?}", + record.output + ); + assert_eq!(trace, plan.generate_reference(record, entry, args, true)?); + if prove { + let witness = backend.generate(record, entry, args)?; + let reference = backend.witness(record, &trace)?; + for (a, b) in witness.traces.iter().zip(&reference.traces) { + assert_eq!(a.width, b.width); + assert_eq!(a.values, b.values); + } + let proof = backend.prove(entry, args, &record.output, witness)?; + assert!(backend.verify(entry, args, &record.output, &proof).is_err()); + } + Ok(()) + }; + for (entry, args) in [ + ("byte", vec![256]), + ("pack", vec![256, 0, 0, 0]), + ("expand", vec![1 << 32]), + ("compact_lt", vec![0, 1 << 32]), + ("compact_lt", vec![program.field().modulus() - 1, 0]), + ("raw_lt", vec![0, 1 << 32]), + ("raw_lt", vec![program.field().modulus() - 1, 0]), + ] { + let range_error = entry == "byte" || entry == "pack"; + let entry = format!("Words::{entry}"); + let candidate = hints.execute(&entry, args.clone()); + if range_error { + assert!(candidate.is_err()); + } else { + reject(&candidate?, &entry, &args, false)?; + } + } + let byte_type = Type::Tuple { items: vec![Type::Field; 4] }; + for (entry, channel, arity, wrong) in [ + ("overflow", "u32.add", 2, [1, 0, 0, 0]), + ("overflow", "u32.add", 2, [256, 0, 0, 0]), + ("overflow", "u32.add", 2, [255, 255, 255, 255]), + ("overflow3", "u32.add3", 3, [254, 255, 255, 255]), + ("overflow3", "u32.add3", 3, [252, 255, 255, 255]), + ] { + let mut bad = HintChannels::new(); + bad.insert( + channel, + Type::Tuple { items: vec![byte_type.clone(); arity] }, + byte_type.clone(), + move |input, output| { + let expected = if arity == 2 { + [bytes(u32::MAX), bytes(1)].concat() + } else { + bytes(u32::MAX).repeat(3) + }; + assert_eq!(input, expected, "addition hints take byte operands"); + output.copy_from_slice(&wrong); + Ok(()) + }, + )?; + let entry = format!("Words::{entry}"); + let prepared = program.prepare_hint_channels(&[], &bad)?; + if wrong[0] == 256 { + assert!(prepared.execute(&entry, vec![]).is_err()); + } else { + let record = prepared.execute(&entry, vec![])?; + reject(&record, &entry, &[], true)?; + } + } + let mut bad = HintChannels::new(); + bad.insert( + "u32.sub", + Type::Tuple { items: vec![Type::Field; 2] }, + byte_type.clone(), + |_, output| { + output.fill(0); + Ok(()) + }, + )?; + let args = [bytes(0), bytes(1)].concat(); + let record = program + .prepare_hint_channels(&[], &bad)? + .execute("Words::lt", args.clone())?; + reject(&record, "Words::lt", &args, true)?; + for wrong in [ + [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0], + [256, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0], + [0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0], + [0, 0, 0, 0, 254, 255, 255, 255, 1, 0, 0, 0], + ] { + let mut bad = HintChannels::new(); + bad.insert( + "u32.lt", + Type::Tuple { items: vec![Type::Field; 2] }, + Type::Tuple { items: vec![byte_type.clone(); 3] }, + move |_, out| { + out.copy_from_slice(&wrong); + Ok(()) + }, + )?; + let prepared = program.prepare_hint_channels(&[], &bad)?; + if wrong[0] == 256 { + assert!(prepared.execute("Words::raw_lt", vec![0, 1]).is_err()); + } else { + let record = prepared.execute("Words::raw_lt", vec![0, 1])?; + if wrong[8] == 0 { + // The borrow/result is correct. Value propagation reconstructs + // the right operand's bytes from b=1, so the row checker accepts + // the repair. Static-table counts still describe the original + // advice: only the full STARK lookup balance rejects this witness. + assert_eq!(record.output, [1]); + let trace = plan.generate(&record, "Words::raw_lt", &[0, 1], true)?; + plan.check(&record, &trace, "Words::raw_lt", &[0, 1])?; + assert_eq!( + trace, + plan.generate_reference(&record, "Words::raw_lt", &[0, 1], true)? + ); + let witness = backend.generate(&record, "Words::raw_lt", &[0, 1])?; + let proof = backend.prove("Words::raw_lt", &[0, 1], &[1], witness)?; + let error = + backend.verify("Words::raw_lt", &[0, 1], &[1], &proof).unwrap_err(); + println!( + "Recomposed advice passed row checks; verifier rejected: {error}" + ); + } else { + reject(&record, "Words::raw_lt", &[0, 1], true)?; + } + } + } + + // Mutate populated rows independently of the interpreter and host providers. + let entry = "Words::overflow3"; + let record = hints.execute(entry, vec![])?; + let trace = plan.generate(&record, entry, &[], true)?; + let matrix = trace + .matrices + .iter() + .position(|m| m.unpadded_height > 0) + .ok_or("no active row")?; + let mut mutations = 0; + for column in 0..trace.matrices[matrix].width { + let mut bad = trace.clone(); + let value = &mut bad.matrices[matrix].values[column]; + *value = program.field().add(*value, 1); + assert!( + plan.check(&record, &bad, entry, &[]).is_err(), + "unconstrained column {column}" + ); + mutations += 1; + } + let witness = backend.generate(&record, entry, &[])?; + let reference = backend.witness(&record, &trace)?; + for (a, b) in witness.traces.iter().zip(&reference.traces) { + assert_eq!(a.width, b.width); + assert_eq!(a.values, b.values); + } + let proof = backend.prove(entry, &[], &record.output, witness)?; + backend.verify(entry, &[], &record.output, &proof)?; + assert!( + aiur::library::u32::register( + &mut HintChannels::new(), + aiur::field::PrimeField::new(65537).unwrap() + ) + .is_err() + ); + println!( + "Passed {checks} execution/reference-trace cases, invalid inputs/advice, 8 rejected proofs from dishonest advice, {mutations} row mutations, and a verified proof." + ); + Ok(()) +} diff --git a/crates/aiur/src/budget.rs b/crates/aiur/src/budget.rs new file mode 100644 index 000000000..2e5fb1fbd --- /dev/null +++ b/crates/aiur/src/budget.rs @@ -0,0 +1,79 @@ +//! Optional counted storage reservations for resident execution pools. +//! Charges cover allocation capacity, conservatively including hash buckets. +//! Program artifacts, host advice and prover workspaces are charged by the host. +pub use record_pool::{BudgetError, RecordPool, RecordReservation}; + +#[derive(Clone, Debug, Default)] +pub(crate) struct Budget(pub Option); + +#[derive(Debug)] +pub(crate) enum StorageError { + Resource(BudgetError), + Invalid(&'static str), +} +impl From for StorageError { + fn from(error: BudgetError) -> Self { + Self::Resource(error) + } +} +impl From<&'static str> for StorageError { + fn from(error: &'static str) -> Self { + Self::Invalid(error) + } +} +impl std::fmt::Display for StorageError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::Resource(e) => e.fmt(f), + Self::Invalid(e) => f.write_str(e), + } + } +} + +impl Budget { + #[inline] + pub fn reserve(&self, bytes: usize) -> Result<(), BudgetError> { + if let Some(reservation) = &self.0 { + reservation.reserve(bytes)?; + } + Ok(()) + } + + #[inline] + pub fn vector( + &self, + values: &Vec, + additional: usize, + ) -> Result<(), BudgetError> { + if self.0.is_some() + && values.len().saturating_add(additional) > values.capacity() + { + let capacity = values + .len() + .saturating_add(additional) + .max(values.capacity().saturating_mul(2)) + .max(8); + self.reserve(capacity.saturating_mul(std::mem::size_of::()))?; + } + Ok(()) + } + + #[inline] + pub fn hash( + &self, + len: usize, + capacity: usize, + ) -> Result<(), BudgetError> { + if self.0.is_some() && len == capacity { + // At least twice the required capacity, including the control bytes. + self.reserve( + len + .saturating_add(1) + .next_power_of_two() + .saturating_mul(4) + .saturating_mul(std::mem::size_of::() + 1), + )?; + } + Ok(()) + } +} diff --git a/crates/aiur/src/bytecode.rs b/crates/aiur/src/bytecode.rs index 5a2d226fa..3f57ae320 100644 --- a/crates/aiur/src/bytecode.rs +++ b/crates/aiur/src/bytecode.rs @@ -1,127 +1,1075 @@ -use crate::FxIndexMap; +//! Execution-only interchange format and its one-time validation/linking pass. +use crate::{ + field::{FieldBackend, NativeField, PrimeField, PrimeField64}, + value::IoType, +}; +use serde::{Deserialize, Serialize}; +use std::collections::{HashMap, HashSet}; -use super::G; +mod dead_code; -pub struct Toplevel { +pub const VERSION: u32 = 2; + +fn default_runtime_check() -> bool { + true +} + +#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] +#[serde(tag = "kind", rename_all = "snake_case")] +pub enum Type { + Field, + Tuple { items: Vec }, + Ptr { target: Box }, + Enum { name: String }, +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct Constructor { + pub name: String, + pub fields: Vec, +} +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct Enum { + pub name: String, + pub constructors: Vec, +} + +#[derive(Clone, Copy, Debug, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum Binary { + Add, + Sub, + Mul, + Div, +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +#[serde(tag = "op", rename_all = "snake_case")] +pub enum Instruction { + Literal { + dest: usize, + value: F, + }, + Copy { + dest: Vec, + source: Vec, + }, + Neg { + dest: usize, + source: usize, + }, + Binary { + dest: usize, + operator: Binary, + left: usize, + right: usize, + }, + Guard { + tests: Vec<(usize, F)>, + message: String, + }, + Branch { + tests: Vec<(usize, F)>, + otherwise: usize, + }, + Jump { + target: usize, + }, + Call { + function: usize, + args: Vec, + dest: Vec, + }, + Store { + r#type: Type, + value: Vec, + dest: usize, + }, + Load { + r#type: Type, + pointer: usize, + dest: Vec, + }, + Hint { + #[serde(default)] + channel: String, + r#type: Type, + key_type: Type, + key: Vec, + dest: Vec, + }, + AssertEq { + left: Vec, + right: Vec, + message: Option, + #[serde(default = "default_runtime_check")] + runtime_check: bool, + }, + Ret { + value: Vec, + }, + Fail { + message: String, + }, +} + +impl Instruction { + fn map_constants(self, f: impl Fn(u64) -> F) -> Instruction { + match self { + Self::Literal { dest, value } => { + Instruction::Literal { dest, value: f(value) } + }, + Self::Copy { dest, source } => Instruction::Copy { dest, source }, + Self::Neg { dest, source } => Instruction::Neg { dest, source }, + Self::Binary { dest, operator, left, right } => { + Instruction::Binary { dest, operator, left, right } + }, + Self::Guard { tests, message } => Instruction::Guard { + tests: tests.into_iter().map(|(r, v)| (r, f(v))).collect(), + message, + }, + Self::Branch { tests, otherwise } => Instruction::Branch { + tests: tests.into_iter().map(|(r, v)| (r, f(v))).collect(), + otherwise, + }, + Self::Jump { target } => Instruction::Jump { target }, + Self::Call { function, args, dest } => { + Instruction::Call { function, args, dest } + }, + Self::Store { r#type, value, dest } => { + Instruction::Store { r#type, value, dest } + }, + Self::Load { r#type, pointer, dest } => { + Instruction::Load { r#type, pointer, dest } + }, + Self::Hint { channel, r#type, key_type, key, dest } => { + Instruction::Hint { channel, r#type, key_type, key, dest } + }, + Self::AssertEq { left, right, message, runtime_check } => { + Instruction::AssertEq { left, right, message, runtime_check } + }, + Self::Ret { value } => Instruction::Ret { value }, + Self::Fail { message } => Instruction::Fail { message }, + } + } +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct Function { + pub name: String, + pub params: Vec, + pub result: Type, + pub registers: usize, + pub code: Vec>, +} +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct Table { + pub name: String, + pub r#type: Type, + pub rows: Vec>, +} +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct Map { + pub name: String, + pub params: Vec, + pub result: Type, + pub input: usize, + pub output: usize, +} +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct Entry { + pub name: String, + pub function: usize, + /// Only entrypoints retain source IO descriptions. + pub inputs: Vec, + /// None means the result contains a pointer or opaque type. + pub output: Option, +} +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct Program { + pub version: u32, + pub modulus: u64, pub functions: Vec, - pub memory_sizes: Vec, - /// Circuit partition of the constrained functions, in first-occurrence - /// order. Computed by the Lean compiler (singletons by default; - /// `CompiledToplevel.groupFunctions` regroups); every constrained - /// function appears in exactly one circuit. - pub circuits: Vec, -} - -/// A circuit of the proving system, backing one or more functions. Ungrouped -/// functions get a singleton circuit; grouped functions share one circuit -/// whose branching selects the member function. -/// -/// `layout` is the merged layout: max `input_size`, sum of `selectors`, max -/// `auxiliaries` (which includes the single shared multiplicity column), max -/// `lookups` (slot 0 is the shared return lookup). -pub struct Circuit { - pub members: Vec, - pub layout: FunctionLayout, -} - -pub struct Function { - pub body: Block, - pub layout: FunctionLayout, - pub entry: bool, - pub constrained: bool, -} - -#[derive(Clone, Copy, PartialEq, Eq)] -pub struct FunctionLayout { - pub input_size: usize, - pub selectors: usize, - pub auxiliaries: usize, - pub lookups: usize, -} - -impl FunctionLayout { - pub fn width(&self) -> usize { - self.input_size + self.selectors + self.auxiliaries - } -} - -#[derive(PartialEq, Eq)] -pub struct Block { - pub ops: Vec, - pub ctrl: Ctrl, -} - -#[derive(PartialEq, Eq)] -pub enum Op { - Const(G), - Add(ValIdx, ValIdx), - Sub(ValIdx, ValIdx), - Mul(ValIdx, ValIdx), - EqZero(ValIdx), - Call(FunIdx, Vec, usize, bool), - Store(Vec), - Load(usize, ValIdx), - AssertEq(Vec, Vec, Option), - IOGetInfo(ValIdx, Vec), - IOSetInfo(ValIdx, Vec, ValIdx, ValIdx), - IORead(ValIdx, ValIdx, usize), - IOWrite(ValIdx, Vec), - U8BitDecomposition(ValIdx), - U8ShiftLeft(ValIdx), - U8ShiftRight(ValIdx), - U8Xor(ValIdx, ValIdx), - U8Add(ValIdx, ValIdx), - U8Mul(ValIdx, ValIdx), - U8Sub(ValIdx, ValIdx), - U8And(ValIdx, ValIdx), - U8Or(ValIdx, ValIdx), - U8LessThan(ValIdx, ValIdx), - U32LessThan(ValIdx, ValIdx), - U8XorSplit7(ValIdx, ValIdx), - U8XorSplit4(ValIdx, ValIdx), - Debug(String, Option>), - /// Range-check two values into `[0, 256)` via the byte chip. Produces no new - /// values: its `u8` results alias the two inputs (cf. `AssertEq`). - U8RangeCheck(ValIdx, ValIdx), - /// Unconstrained `BigUint` division-modulo hint. Inputs are two pointers - /// to `KLimbs` (= `List`) values storing the dividend `a` and divisor - /// `b` as little-endian u64 limb chains. Outputs two new pointers to - /// `KLimbs` values for the quotient `q` and remainder `r` such that - /// `q * b + r = a` with `0 ≤ r < b` (when `b > 0`). Computed natively by - /// the runtime via `num_bigint::BigUint::div_rem`; no in-circuit recursion - /// and no constraints generated. The caller is responsible for verifying - /// the relation in constrained code. - UnconstrainedBigUintDivMod(ValIdx, ValIdx), - /// Unconstrained hint: the 8 little-endian bytes of a field element's - /// canonical `u64` value. 8 fresh auxiliary values, no constraints, no - /// lookup; the caller must range-check the bytes, assert they recompose - /// to the input, and assert canonicality (`< p`) in constrained code. - UnconstrainedGToBytes(ValIdx), - /// Unconstrained hint: the field inverse of a value (`0 ↦ 0`). One fresh - /// auxiliary value, no constraints; the caller must pin it via - /// multiply-and-assert. - UnconstrainedGInverse(ValIdx), - UnconstrainedU32Add(Vec, Vec), - UnconstrainedU32Add3(Vec, Vec, Vec), - U32ToField(Vec), -} - -#[derive(PartialEq, Eq)] -pub enum Ctrl { - Match(ValIdx, FxIndexMap, Option>), - Return(SelIdx, Vec), - Yield(SelIdx, Vec), - MatchContinue( - ValIdx, - FxIndexMap, - Option>, - usize, // output_size - usize, // shared_auxiliaries - usize, // shared_lookups - Box, // continuation - ), -} - -pub type SelIdx = usize; -pub type ValIdx = usize; -pub type FunIdx = usize; + pub enums: Vec, + pub tables: Vec, + pub maps: Vec, + pub entries: Vec, +} + +#[derive(Clone, Debug)] +pub(crate) enum Layout { + Field, + Pointer, + Tuple { items: Vec, width: usize, shape_checks: bool }, + Enum { constructors: Vec, payload: usize, shape_checks: bool }, +} +impl Layout { + pub(crate) fn width(&self) -> usize { + match self { + Self::Field | Self::Pointer => 1, + Self::Tuple { width, .. } => *width, + Self::Enum { constructors, payload, .. } => { + payload + usize::from(constructors.len() > 1) + }, + } + } + pub(crate) fn pointer_free(&self) -> bool { + match self { + Self::Field => true, + Self::Pointer => false, + Self::Tuple { items, .. } => items.iter().all(Self::pointer_free), + Self::Enum { constructors, .. } => { + constructors.iter().all(Self::pointer_free) + }, + } + } + pub(crate) fn has_shape_checks(&self) -> bool { + match self { + Self::Field | Self::Pointer => false, + Self::Tuple { shape_checks, .. } => *shape_checks, + Self::Enum { shape_checks, .. } => *shape_checks, + } + } + pub(crate) fn validate( + &self, + words: &[B::Element], + field: B, + ) -> Result<(), String> { + if words.len() != self.width() || words.iter().any(|v| !field.valid(*v)) { + return Err("incorrect value width or noncanonical field element".into()); + } + self.validate_shape(words, field) + } + + // Width and canonicality were checked once over the whole value. Recursion + // only checks constructor tags and padding; it must not rescan every word. + fn validate_shape( + &self, + words: &[B::Element], + field: B, + ) -> Result<(), String> { + match self { + Self::Field | Self::Pointer => Ok(()), + Self::Tuple { shape_checks: false, .. } + | Self::Enum { shape_checks: false, .. } => Ok(()), + Self::Tuple { items, .. } => { + let mut offset = 0; + for item in items { + item.validate_shape(&words[offset..offset + item.width()], field)?; + offset += item.width(); + } + Ok(()) + }, + Self::Enum { constructors, .. } => { + let (tag, payload) = if constructors.len() > 1 { + ( + usize::try_from(field.to_u64(words[0])) + .map_err(|_| "enum tag too large")?, + &words[1..], + ) + } else { + (0, words) + }; + let ctor = constructors.get(tag).ok_or("invalid enum tag")?; + ctor.validate_shape(&payload[..ctor.width()], field)?; + if payload[ctor.width()..].iter().any(|v| *v != field.zero()) { + return Err("nonzero enum padding".into()); + } + Ok(()) + }, + } + } + + /// Register values are valid field elements by construction: checked wire + /// values, native field arithmetic and bounded ROM addresses preserve this + /// invariant. Native elements need not have a canonical in-memory encoding. + /// The bytecode checker establishes operand widths. + /// Stores/returns still need dynamic constructor and zero-padding checks. + #[inline] + pub(crate) fn validate_registers( + &self, + words: &[B::Element], + field: B, + ) -> Result<(), String> { + debug_assert_eq!(words.len(), self.width()); + debug_assert!(words.iter().all(|v| field.valid(*v))); + self.validate_shape(words, field) + } +} + +impl Type { + pub(crate) fn layout( + &self, + enums: &[Enum], + path: &mut Vec, + ) -> Result { + match self { + Self::Field => Ok(Layout::Field), + Self::Ptr { .. } => Ok(Layout::Pointer), + Self::Tuple { items } => { + let items = items + .iter() + .map(|t| t.layout(enums, path)) + .collect::, _>>()?; + let width = items.iter().map(Layout::width).sum(); + let shape_checks = items.iter().any(Layout::has_shape_checks); + Ok(Layout::Tuple { items, width, shape_checks }) + }, + Self::Enum { name } => { + if path.contains(name) { + return Err(format!("recursive inline layout {name}")); + } + let decl = enums + .iter() + .find(|e| e.name == *name) + .ok_or_else(|| format!("unknown enum {name}"))?; + path.push(name.clone()); + let constructors = decl + .constructors + .iter() + .map(|c| Type::Tuple { items: c.fields.clone() }.layout(enums, path)) + .collect::, _>>()?; + path.pop(); + let payload = constructors.iter().map(Layout::width).max().unwrap_or(0); + // A one-constructor wrapper has neither a tag nor padding. + // Opaque aliases use this representation; only their payload + // can require shape checks. Keep checks for empty enums and + // for multi-constructor enums nested inside a wrapper. + let shape_checks = + constructors.len() != 1 || constructors[0].has_shape_checks(); + Ok(Layout::Enum { constructors, payload, shape_checks }) + }, + } + } +} + +#[cfg(test)] +mod layout_tests { + use super::*; + + #[test] + fn tagless_wrappers_preserve_nested_validation() { + let named = |name: &str| Type::Enum { name: name.into() }; + let wrapped = |name: &str, inner: Type| Enum { + name: name.into(), + constructors: vec![Constructor { + name: "Wrap".into(), + fields: vec![inner], + }], + }; + let enums = vec![ + Enum { + name: "Choice".into(), + constructors: vec![ + Constructor { name: "None".into(), fields: vec![] }, + Constructor { name: "Some".into(), fields: vec![Type::Field] }, + ], + }, + wrapped("Outer", named("Choice")), + wrapped("Twice", named("Outer")), + wrapped("Scalar", Type::Field), + Enum { name: "Empty".into(), constructors: vec![] }, + wrapped("Impossible", named("Empty")), + ]; + let field = PrimeField::new(97).unwrap(); + for name in ["Choice", "Outer", "Twice"] { + let layout = named(name).layout(&enums, &mut vec![]).unwrap(); + assert!(layout.validate(&[0, 0], field).is_ok()); + assert!(layout.validate(&[1, 96], field).is_ok()); + for bad in [[2, 0], [0, 1], [1, 97]] { + assert!(layout.validate(&bad, field).is_err(), "{name}: {bad:?}"); + } + } + let scalar = named("Scalar").layout(&enums, &mut vec![]).unwrap(); + assert!(scalar.validate(&[96], field).is_ok()); + assert!(scalar.validate(&[97], field).is_err()); + assert!(scalar.validate(&[], field).is_err()); + for name in ["Empty", "Impossible"] { + assert!( + named(name) + .layout(&enums, &mut vec![]) + .unwrap() + .validate(&[], field) + .is_err() + ); + } + } +} + +/// Validated bytecode plus prebuilt indexes shared by all maps using a table. +#[derive(Debug)] +pub struct CheckedProgram { + pub(crate) program: std::sync::Arc, + pub(crate) field: B, + pub(crate) inputs: Vec, + pub(crate) outputs: Vec, + pub(crate) memory_layouts: HashMap, + pub(crate) memory_types: Vec<(Type, Layout)>, + pub(crate) map_indexes: + Vec>>>, + pub(crate) tables: std::sync::Arc>>>, + pub(crate) division_inverses: Vec>>, + pub(crate) steps: Vec>, + pub(crate) returns: Vec>>, + pub(crate) execution_functions: Vec>, + pub(crate) initial_registers: Vec>, +} + +// Only globally immutable registers may be aliased. Inputs count as writes; +// overwritten parameters, branch joins and simultaneous swaps stay explicit. +// PCs and operation counts are retained in the linked interpreter bytecode. +fn link_registers( + function: &Function, + input: usize, + field: PrimeField, +) -> (Function, Vec<(usize, u64)>) { + let mut writes = vec![0usize; function.registers]; + writes[..input].fill(1); + for op in &function.code { + use Instruction::*; + let dest: &[usize] = match op { + Literal { dest, .. } + | Neg { dest, .. } + | Binary { dest, .. } + | Store { dest, .. } => std::slice::from_ref(dest), + Copy { dest, .. } + | Call { dest, .. } + | Load { dest, .. } + | Hint { dest, .. } => dest, + _ => &[], + }; + for ® in dest { + if let Some(count) = writes.get_mut(reg) { + *count = count.saturating_add(1); + } + } + } + let mut aliases: Vec<_> = (0..function.registers).collect(); + for op in &function.code { + if let Instruction::Copy { dest, source } = op { + for (&dest, &source) in dest.iter().zip(source) { + if writes.get(dest) == Some(&1) + && writes.get(source) == Some(&1) + && dest >= input + { + aliases[dest] = aliases[source]; + } + } + } + } + let initial: Vec<_> = function + .code + .iter() + .filter_map(|op| match op { + Instruction::Literal { dest, value } + if writes.get(*dest) == Some(&1) + && *dest >= input + && field.contains(*value) => + { + Some((*dest, *value)) + }, + _ => None, + }) + .collect(); + let mut linked = function.clone(); + let read = |reg: &mut usize| { + *reg = aliases.get(*reg).copied().unwrap_or(*reg); + }; + for op in &mut linked.code { + use Instruction::*; + match op { + Copy { dest, source } => { + dest.iter_mut().for_each(read); + source.iter_mut().for_each(read); + }, + Neg { source, .. } => read(source), + Binary { left, right, .. } => { + read(left); + read(right); + }, + Guard { tests, .. } | Branch { tests, .. } => { + tests.iter_mut().for_each(|(reg, _)| read(reg)) + }, + Call { args, .. } => args.iter_mut().for_each(read), + Store { value, .. } | Ret { value } => value.iter_mut().for_each(read), + Load { pointer, .. } => read(pointer), + Hint { key, .. } => key.iter_mut().for_each(read), + AssertEq { left, right, .. } => { + left.iter_mut().for_each(read); + right.iter_mut().for_each(read); + }, + _ => {}, + } + } + (linked, initial) +} + +#[derive(Clone, Debug)] +pub(crate) struct ReturnPlan { + pub(crate) values: Vec, + pub(crate) pc: usize, + pub(crate) instructions: u64, +} + +// A copy/jump-only suffix has no observable work except its returned values. +// Compose simultaneous copies backwards, retaining the original return PC and +// logical instruction count. The serialized bytecode and hint PCs stay intact. +fn return_plans(function: &Function) -> Vec> { + let mut plans: Vec> = vec![None; function.code.len()]; + for (pc, op) in function.code.iter().enumerate().rev() { + let next = match op { + Instruction::Ret { value } => { + plans[pc] = + Some(ReturnPlan { values: value.clone(), pc, instructions: 1 }); + continue; + }, + Instruction::Copy { .. } => pc + 1, + Instruction::Jump { target } => *target, + Instruction::Guard { tests, .. } | Instruction::Branch { tests, .. } + if tests.is_empty() => + { + pc + 1 + }, + _ => continue, + }; + if let Some(Some(plan)) = plans.get(next) { + let mut plan = plan.clone(); + if let Instruction::Copy { dest, source } = op { + // Unreachable instructions need not have a valid interface. + if dest.len() != source.len() { + continue; + } + for value in &mut plan.values { + if let Some(i) = dest.iter().rposition(|d| d == value) { + *value = source[i]; + } + } + } + plan.instructions += 1; + plans[pc] = Some(plan); + } + } + plans +} + +#[derive(Clone, Copy, Debug)] +pub(crate) struct Step { + pub(crate) pc: usize, + pub(crate) skipped: u64, + pub(crate) memory_type: usize, +} + +fn execution_steps( + function: &Function, + memory_ids: &HashMap, + initial: &[(usize, u64)], +) -> Vec { + let mut steps: Vec<_> = (0..function.code.len()) + .map(|pc| Step { + pc, + skipped: 0, + memory_type: match &function.code[pc] { + Instruction::Store { r#type, .. } + | Instruction::Load { r#type, .. } => { + memory_ids.get(r#type).copied().unwrap_or(usize::MAX) + }, + _ => usize::MAX, + }, + }) + .collect(); + for (pc, op) in function.code.iter().enumerate().rev() { + let next = match op { + Instruction::Literal { dest, value } + if initial.contains(&(*dest, *value)) => + { + Some(pc + 1) + }, + Instruction::Guard { tests, .. } | Instruction::Branch { tests, .. } + if tests.is_empty() => + { + Some(pc + 1) + }, + Instruction::Copy { dest, source } if dest == source => Some(pc + 1), + Instruction::AssertEq { left, right, .. } if left == right => { + Some(pc + 1) + }, + Instruction::Jump { target } => Some(*target), + _ => None, + }; + if let Some(next) = next.filter(|&next| next > pc && next < steps.len()) { + steps[pc] = Step { + pc: steps[next].pc, + skipped: steps[next].skipped + 1, + memory_type: steps[next].memory_type, + }; + } + } + steps +} +impl CheckedProgram { + pub fn program(&self) -> &Program { + &self.program + } + pub fn field(&self) -> B { + self.field + } + pub fn entry(&self, name: &str) -> Result<&Entry, String> { + self + .program + .entries + .iter() + .find(|e| e.name == name) + .ok_or_else(|| format!("unselected entrypoint {name}")) + } + pub fn callable_name(&self, id: usize) -> Option<&str> { + if let Some(f) = self.program.functions.get(id) { + Some(&f.name) + } else { + self + .program + .maps + .get(id.checked_sub(self.program.functions.len())?) + .map(|m| m.name.as_str()) + } + } +} + +fn unique<'a>(names: impl Iterator) -> Result<(), String> { + let mut seen = HashSet::new(); + for name in names { + if !seen.insert(name) { + return Err(format!("duplicate name {name}")); + } + } + Ok(()) +} +impl Program { + pub fn check(self) -> Result { + let field = PrimeField::new(self.modulus)?; + self.check_with(field) + } + + /// Select the native field once. All prepared values and host callbacks + /// then use F directly; interchange integers are checked before conversion. + pub fn check_field( + self, + ) -> Result>, String> { + self.check_with(NativeField::::new()) + } + + pub fn check_with( + self, + backend: B, + ) -> Result, String> { + if self.modulus != backend.modulus() { + return Err("execution package / field mismatch".into()); + } + // Version 1 has only the default channel. New exporters use version 2 so + // an old runtime cannot silently ignore named-channel metadata. + if self.version != 1 && self.version != VERSION { + return Err(format!( + "unsupported execution bytecode version {}", + self.version + )); + } + let field = PrimeField::new(self.modulus)?; + unique( + self + .functions + .iter() + .map(|f| f.name.as_str()) + .chain(self.maps.iter().map(|m| m.name.as_str())), + )?; + unique(self.enums.iter().map(|e| e.name.as_str()))?; + unique(self.tables.iter().map(|t| t.name.as_str()))?; + unique(self.entries.iter().map(|e| e.name.as_str()))?; + for decl in &self.enums { + unique(decl.constructors.iter().map(|c| c.name.as_str()))?; + if decl.constructors.len() as u128 > u128::from(field.modulus()) { + return Err("enum tags do not fit in the field".into()); + } + Type::Enum { name: decl.name.clone() } + .layout(&self.enums, &mut vec![])?; + } + let signatures = self + .functions + .iter() + .map(|f| (&f.params, &f.result)) + .chain(self.maps.iter().map(|m| (&m.params, &m.result))); + let mut inputs = vec![]; + let mut outputs = vec![]; + for (params, result) in signatures { + inputs.push( + Type::Tuple { items: params.clone() } + .layout(&self.enums, &mut vec![])?, + ); + outputs.push(result.layout(&self.enums, &mut vec![])?); + } + for entry in &self.entries { + let input = + inputs.get(entry.function).ok_or("invalid entry function ID")?; + if !input.pointer_free() { + return Err("entry arguments contain pointers".into()); + } + let input_width = entry + .inputs + .iter() + .map(IoType::checked_width) + .collect::, _>>()? + .iter() + .sum::(); + if input_width != input.width() { + return Err("entry input description width mismatch".into()); + } + if let Some(output) = &entry.output + && (output.checked_width()? != outputs[entry.function].width() + || !outputs[entry.function].pointer_free()) + { + return Err("entry output description mismatch".into()); + } + } + for table in &self.tables { + let layout = table.r#type.layout(&self.enums, &mut vec![])?; + if !layout.pointer_free() { + return Err("table contains pointers".into()); + } + for row in &table.rows { + layout.validate(row, field)?; + } + } + let tables = std::sync::Arc::new( + self + .tables + .iter() + .map(|table| { + table + .rows + .iter() + .map(|row| backend.decode(row)) + .collect::, _>>() + }) + .collect::, _>>()?, + ); + let mut map_indexes = vec![None; self.tables.len()]; + for map in &self.maps { + let input = self.tables.get(map.input).ok_or("invalid input table ID")?; + let output = + self.tables.get(map.output).ok_or("invalid output table ID")?; + if input.r#type != (Type::Tuple { items: map.params.clone() }) + || output.r#type != map.result + || input.rows.len() != output.rows.len() + { + return Err(format!("table/map interface mismatch for {}", map.name)); + } + if map_indexes[map.input].is_none() { + map_indexes[map.input] = Some(std::sync::Arc::new( + crate::table::TableIndex::new(&tables[map.input], backend)?, + )); + } + } + let mut memory_layouts = HashMap::new(); + for (id, function) in self.functions.iter().enumerate() { + check_function( + function, + inputs[id].width(), + outputs[id].width(), + &inputs, + &outputs, + &self.enums, + field, + &mut memory_layouts, + ) + .map_err(|e| format!("{}: {e}", function.name))?; + } + let division_inverses: Vec<_> = + self.functions.iter().map(|f| constant_divisions(f, backend)).collect(); + // Resolve structural memory types and layouts once. Type IDs are local + // to this checked program; the public record retains the full types. + let memory_types: Vec<_> = memory_layouts + .iter() + .map(|(ty, layout)| (ty.clone(), layout.clone())) + .collect(); + let memory_ids = memory_types + .iter() + .enumerate() + .map(|(i, (ty, _))| (ty.clone(), i)) + .collect(); + let (execution_functions, initial_registers): (Vec<_>, Vec<_>) = self + .functions + .iter() + .zip(&inputs) + .zip(&division_inverses) + .map(|((f, input), inverses)| { + let mut f = f.clone(); + dead_code::eliminate(&mut f, inverses); + link_registers(&f, input.width(), field) + }) + .unzip(); + let steps = execution_functions + .iter() + .zip(&initial_registers) + .map(|(f, initial)| execution_steps(f, &memory_ids, initial)) + .collect(); + let returns = execution_functions.iter().map(return_plans).collect(); + let initial_registers = initial_registers + .into_iter() + .map(|row| { + row + .into_iter() + .map(|(reg, value)| (reg, backend.from_u64(value))) + .collect() + }) + .collect(); + let execution_functions = execution_functions + .into_iter() + .map(|f| Function { + name: f.name, + params: f.params, + result: f.result, + registers: f.registers, + code: f + .code + .into_iter() + .map(|op| op.map_constants(|v| backend.from_u64(v))) + .collect(), + }) + .collect(); + Ok(CheckedProgram { + program: std::sync::Arc::new(self), + field: backend, + inputs, + outputs, + memory_layouts, + memory_types, + map_indexes, + tables, + division_inverses, + steps, + returns, + execution_functions, + initial_registers, + }) + } +} + +/// Cache inverses of literal denominators within a basic block. Keep the wire +/// bytecode and instruction sites intact for diagnostics and saved hint answers. +/// Forget facts at every join; a zero denominator still fails only if executed. +fn constant_divisions( + function: &Function, + field: B, +) -> Vec> { + let mut targets = vec![false; function.code.len()]; + for op in &function.code { + let target = match op { + Instruction::Branch { otherwise, .. } => Some(*otherwise), + Instruction::Jump { target } => Some(*target), + _ => None, + }; + if let Some(target) = target.and_then(|i| targets.get_mut(i)) { + *target = true; + } + } + let mut constants = vec![None; function.registers]; + let mut inverses = vec![None; function.code.len()]; + for (pc, op) in function.code.iter().enumerate() { + if targets[pc] { + constants.fill(None); + } + // Validation permits unreachable instructions to be arbitrary. Facts + // are a performance aid, so an out-of-range register simply has none. + let mut writes = vec![]; + match op { + Instruction::Literal { dest, value } => { + writes.push((*dest, Some(*value))) + }, + Instruction::Copy { dest, source } => { + for (dest, source) in dest.iter().zip(source) { + writes.push((*dest, constants.get(*source).copied().flatten())); + } + }, + Instruction::Binary { dest, operator, right, .. } => { + if matches!(operator, Binary::Div) { + inverses[pc] = constants + .get(*right) + .copied() + .flatten() + .filter(|&x| field.contains(x)) + .and_then(|x| field.inverse(field.from_u64(x))); + } + writes.push((*dest, None)); + }, + Instruction::Neg { dest, .. } | Instruction::Store { dest, .. } => { + writes.push((*dest, None)) + }, + Instruction::Call { dest, .. } + | Instruction::Load { dest, .. } + | Instruction::Hint { dest, .. } => { + writes.extend(dest.iter().map(|dest| (*dest, None))); + }, + Instruction::Jump { .. } + | Instruction::Ret { .. } + | Instruction::Fail { .. } => constants.fill(None), + _ => {}, + } + for (dest, value) in writes { + if let Some(slot) = constants.get_mut(dest) { + *slot = value; + } + } + } + inverses +} + +// Intra-function control flow is forward-only; recursion uses an explicit VM +// call stack. A forward dataflow pass checks initialization on every path. +#[allow(clippy::too_many_arguments)] +fn check_function( + f: &Function, + input: usize, + output: usize, + inputs: &[Layout], + outputs: &[Layout], + enums: &[Enum], + field: PrimeField, + layouts: &mut HashMap, +) -> Result<(), String> { + if input > f.registers || f.code.is_empty() { + return Err("missing input registers or empty code".into()); + } + let mut states: Vec>> = vec![None; f.code.len()]; + let mut initial = vec![false; f.registers]; + initial[..input].fill(true); + states[0] = Some(initial); + for (pc, instruction) in f.code.iter().enumerate() { + let Some(mut initialized) = states[pc].take() else { + continue; + }; + let mut reads = vec![]; + let mut writes = vec![]; + let mut successors = vec![pc + 1]; + use Instruction::*; + match instruction { + Literal { dest, value } => { + if !field.contains(*value) { + return Err("noncanonical literal".into()); + } + writes.push(*dest); + }, + Copy { dest, source } => { + if dest.len() != source.len() { + return Err("copy width mismatch".into()); + } + reads.extend(source); + writes.extend(dest); + }, + Neg { dest, source } => { + reads.push(*source); + writes.push(*dest); + }, + Binary { dest, left, right, .. } => { + reads.extend([left, right]); + writes.push(*dest); + }, + Guard { tests, .. } | Branch { tests, .. } => { + for (reg, value) in tests { + if !field.contains(*value) { + return Err("noncanonical pattern literal".into()); + } + reads.push(*reg); + } + if let Branch { otherwise, tests } = instruction + && !tests.is_empty() + { + successors.push(*otherwise); + } + }, + Jump { target } => { + successors = vec![*target]; + }, + Call { function, args, dest } => { + if inputs.get(*function).is_none_or(|l| l.width() != args.len()) + || outputs.get(*function).is_none_or(|l| l.width() != dest.len()) + { + return Err("call interface mismatch".into()); + } + reads.extend(args); + writes.extend(dest); + }, + Store { r#type, value, dest } => { + let layout = r#type.layout(enums, &mut vec![])?; + if layout.width() != value.len() { + return Err("store width mismatch".into()); + } + layouts.insert(r#type.clone(), layout); + reads.extend(value); + writes.push(*dest); + }, + Load { r#type, pointer, dest } => { + let layout = r#type.layout(enums, &mut vec![])?; + if layout.width() != dest.len() { + return Err("load width mismatch".into()); + } + layouts.insert(r#type.clone(), layout); + reads.push(*pointer); + writes.extend(dest); + }, + Hint { r#type, key_type, key, dest, .. } => { + let layout = r#type.layout(enums, &mut vec![])?; + let key_layout = key_type.layout(enums, &mut vec![])?; + if !layout.pointer_free() + || !key_layout.pointer_free() + || layout.width() != dest.len() + || key_layout.width() != key.len() + { + return Err("invalid hint type or width".into()); + } + reads.extend(key); + writes.extend(dest); + }, + AssertEq { left, right, .. } => { + if left.len() != right.len() { + return Err("assertion width mismatch".into()); + } + reads.extend(left); + reads.extend(right); + }, + Ret { value } => { + if value.len() != output { + return Err("return width mismatch".into()); + } + reads.extend(value); + successors.clear(); + }, + Fail { .. } => { + successors.clear(); + }, + } + for reg in reads { + if initialized.get(reg) != Some(&true) { + return Err(format!("instruction {pc} reads undefined register {reg}")); + } + } + for reg in writes { + *initialized + .get_mut(reg) + .ok_or("destination register out of bounds")? = true; + } + for next in successors { + if next <= pc || next >= f.code.len() { + return Err(format!( + "invalid forward jump/fallthrough from {pc} to {next}" + )); + } + match &mut states[next] { + None => states[next] = Some(initialized.clone()), + Some(state) => { + for (old, new) in state.iter_mut().zip(&initialized) { + *old &= new; + } + }, + } + } + } + Ok(()) +} diff --git a/crates/aiur/src/bytecode/dead_code.rs b/crates/aiur/src/bytecode/dead_code.rs new file mode 100644 index 000000000..33b103823 --- /dev/null +++ b/crates/aiur/src/bytecode/dead_code.rs @@ -0,0 +1,317 @@ +//! Execution liveness after validation. The original bytecode and circuit stay +//! intact. Empty copies stand in for omitted instructions so PCs, hint sites, +//! error locations, and logical instruction counts retain their meanings. +use super::{Function, Instruction}; + +fn contains(live: &[u64], register: usize) -> bool { + live.get(register / 64).is_some_and(|word| word & (1 << (register % 64)) != 0) +} + +fn set(live: &mut [u64], register: usize, value: bool) { + // Unreachable instructions may contain arbitrary register indices. + if let Some(word) = live.get_mut(register / 64) { + let bit = 1 << (register % 64); + if value { + *word |= bit; + } else { + *word &= !bit; + } + } +} + +fn reads(live: &mut [u64], registers: &[usize]) { + for ®ister in registers { + set(live, register, true); + } +} + +fn writes(live: &mut [u64], registers: &[usize]) { + for ®ister in registers { + set(live, register, false); + } +} + +fn nop() -> Instruction { + Instruction::Copy { dest: vec![], source: vec![] } +} + +pub(super) fn eliminate(function: &mut Function, inverses: &[Option]) { + let empty = vec![0u64; function.registers.div_ceil(64)]; + let mut before = vec![empty.clone(); function.code.len() + 1]; + // Validated intra-function control flow is forward-only. Union successor + // liveness before processing each instruction, including both branch arms. + for pc in (0..function.code.len()).rev() { + use Instruction::*; + let mut live = match &function.code[pc] { + Ret { .. } | Fail { .. } => empty.clone(), + Jump { target } => before.get(*target).unwrap_or(&empty).clone(), + _ => before[pc + 1].clone(), + }; + if let Branch { tests, otherwise } = &function.code[pc] + && !tests.is_empty() + && let Some(other) = before.get(*otherwise) + { + for (live, other) in live.iter_mut().zip(other) { + *live |= other; + } + } + let op = &mut function.code[pc]; + match op { + Literal { dest, .. } => { + if contains(&live, *dest) { + set(&mut live, *dest, false); + } else { + *op = nop(); + } + }, + Copy { dest, source } if dest.len() == source.len() => { + // Copies read all sources before writing. For duplicate + // destinations only the last assignment is observable. + let mut kept = Vec::new(); + for (&d, &s) in dest.iter().zip(source.iter()).rev() { + if contains(&live, d) { + set(&mut live, d, false); + kept.push((d, s)); + } + } + kept.reverse(); + (*dest, *source) = kept.into_iter().unzip(); + reads(&mut live, source); + }, + Copy { dest, source } => { + // Malformed unreachable copies must not panic the linker. + writes(&mut live, dest); + reads(&mut live, source); + }, + Neg { dest, source } => { + if contains(&live, *dest) { + set(&mut live, *dest, false); + set(&mut live, *source, true); + } else { + *op = nop(); + } + }, + Binary { dest, operator, left, right } => { + // Division can fail even if unused. Only a cached, nonzero + // constant denominator makes it safe to discard. + let may_fail = matches!(operator, super::Binary::Div) + && inverses.get(pc).is_none_or(Option::is_none); + if contains(&live, *dest) || may_fail { + set(&mut live, *dest, false); + reads(&mut live, &[*left, *right]); + } else { + *op = nop(); + } + }, + AssertEq { runtime_check: false, .. } => *op = nop(), + AssertEq { left, right, .. } => { + reads(&mut live, left); + reads(&mut live, right); + }, + Guard { tests, .. } | Branch { tests, .. } => { + for (register, _) in tests { + set(&mut live, *register, true); + } + }, + Call { args, dest, .. } => { + writes(&mut live, dest); + reads(&mut live, args); + }, + Store { value, dest, .. } => { + set(&mut live, *dest, false); + reads(&mut live, value); + }, + Load { pointer, dest, .. } => { + writes(&mut live, dest); + set(&mut live, *pointer, true); + }, + Hint { key, dest, .. } => { + writes(&mut live, dest); + reads(&mut live, key); + }, + Ret { value } => reads(&mut live, value), + Jump { .. } | Fail { .. } => {}, + } + before[pc] = live; + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::{ + bytecode::{Program, Type}, + hints::HintChannels, + }; + use serde_json::{Value, json}; + + fn program(code: Value, registers: usize) -> Program { + serde_json::from_value(json!({ + "version": 2, "modulus": 65537, "enums": [], "tables": [], "maps": [], + "functions": [{"name": "root", "params": [{"kind": "field"}], + "result": {"kind": "field"}, "registers": registers, "code": code}], + "entries": [{"name": "root", "function": 0, + "inputs": [{"kind": "field"}], "output": {"kind": "field"}}] + })) + .unwrap() + } + + #[test] + fn dead_arithmetic_is_removed_but_query_hint_and_rom_effects_remain() { + let mut source = program( + json!([ + {"op": "literal", "dest": 1, "value": 9}, + {"op": "binary", "operator": "mul", "dest": 2, "left": 0, "right": 0}, + {"op": "literal", "dest": 3, "value": 256}, + {"op": "binary", "operator": "div", "dest": 4, "left": 2, "right": 3}, + {"op": "assert_eq", "left": [4], "right": [1], "runtime_check": false}, + {"op": "call", "function": 1, "args": [0], "dest": [5]}, + {"op": "hint", "channel": "identity", "type": {"kind": "field"}, + "key_type": {"kind": "field"}, "key": [0], "dest": [6]}, + {"op": "store", "type": {"kind": "field"}, "value": [6], "dest": 7}, + {"op": "load", "type": {"kind": "field"}, "pointer": 7, "dest": [8]}, + {"op": "call", "function": 2, "args": [8], "dest": [9]}, + {"op": "assert_eq", "left": [5], "right": [9], "runtime_check": false}, + {"op": "ret", "value": [0]} + ]), + 10, + ); + source.functions.push( + serde_json::from_value(json!({ + "name": "identity", "params": [{"kind": "field"}], + "result": {"kind": "field"}, "registers": 1, + "code": [{"op": "ret", "value": [0]}] + })) + .unwrap(), + ); + source.tables = serde_json::from_value(json!([ + {"name": "input", "type": {"kind": "tuple", "items": [{"kind": "field"}]}, "rows": [[3], [48]]}, + {"name": "output", "type": {"kind": "field"}, "rows": [[3], [48]]} + ])).unwrap(); + source.maps = serde_json::from_value(json!([ + {"name": "table_identity", "params": [{"kind": "field"}], + "result": {"kind": "field"}, "input": 0, "output": 1} + ])) + .unwrap(); + let deferred = source.clone().check().unwrap(); + for op in &mut source.functions[0].code { + if let Instruction::AssertEq { runtime_check, .. } = op { + *runtime_check = true; + } + } + let checked = source.check().unwrap(); + assert!(deferred.execution_functions[0].code.iter().all(|op| !matches!( + op, + Instruction::Binary { .. } | Instruction::AssertEq { .. } + ))); + assert!(deferred.program.functions[0].code.iter().any(|op| matches!( + op, + Instruction::AssertEq { runtime_check: false, .. } + ))); + let mut channels = HintChannels::new(); + channels + .insert("identity", Type::Field, Type::Field, |input, output| { + output.copy_from_slice(input); + Ok(()) + }) + .unwrap(); + let deferred = deferred.prepare_hint_channels(&[], &channels).unwrap(); + let checked = checked.prepare_hint_channels(&[], &channels).unwrap(); + let actual = deferred.execute("root", vec![48]).unwrap(); + let expected = checked.execute("root", vec![48]).unwrap(); + assert_eq!(actual.output, expected.output); + assert_eq!(actual.queries, expected.queries); + assert_eq!(actual.instructions, expected.instructions); + assert_eq!( + serde_json::to_value(&actual.memory).unwrap(), + serde_json::to_value(&expected.memory).unwrap() + ); + assert_eq!(actual.queries.len(), 3); + assert_eq!(actual.memory.get(0).unwrap().multiplicity, 2); + assert_eq!(deferred.execute("root", vec![3]).unwrap().output, [3]); + assert_eq!(checked.execute("root", vec![3]).unwrap_err().instruction, 4); + } + + #[test] + fn deferred_assertions_do_not_hide_division_errors() { + let source = program( + json!([ + {"op": "literal", "dest": 1, "value": 1}, + {"op": "binary", "operator": "div", "dest": 2, "left": 1, "right": 0}, + {"op": "assert_eq", "left": [2], "right": [1], "runtime_check": false}, + {"op": "ret", "value": [0]} + ]), + 3, + ); + let checked = source.clone().check().unwrap(); + assert_eq!(checked.execute("root", vec![2]).unwrap().output, [2]); + assert_eq!(checked.execute("root", vec![0]).unwrap_err().instruction, 1); + // A provably nonzero denominator permits removal, including its inputs. + let mut constant = source.clone(); + if let Instruction::Binary { right, .. } = + &mut constant.functions[0].code[1] + { + *right = 1; + } + let checked = constant.check().unwrap(); + assert!( + checked.execution_functions[0] + .code + .iter() + .all(|op| !matches!(op, Instruction::Binary { .. })) + ); + assert_eq!(checked.execute("root", vec![0]).unwrap().output, [0]); + // A constant zero denominator still fails even though the result is dead. + let mut zero = source; + if let Instruction::Literal { value, .. } = &mut zero.functions[0].code[0] { + *value = 0; + } + if let Instruction::Binary { right, .. } = &mut zero.functions[0].code[1] { + *right = 1; + } + assert_eq!( + zero.check().unwrap().execute("root", vec![2]).unwrap_err().instruction, + 1 + ); + } + + #[test] + fn both_branch_successors_and_legacy_assertions_are_live() { + let source = program( + json!([ + {"op": "literal", "dest": 1, "value": 7}, + {"op": "literal", "dest": 2, "value": 13}, + {"op": "binary", "operator": "mul", "dest": 3, "left": 1, "right": 2}, + {"op": "assert_eq", "left": [3], "right": [0], "runtime_check": false}, + {"op": "branch", "tests": [[0, 0]], "otherwise": 7}, + {"op": "copy", "dest": [3], "source": [1]}, + {"op": "jump", "target": 8}, + {"op": "copy", "dest": [3, 3], "source": [1, 2]}, + {"op": "ret", "value": [3]} + ]), + 4, + ) + .check() + .unwrap(); + assert_eq!(source.execute("root", vec![0]).unwrap().output, [7]); + assert_eq!(source.execute("root", vec![5]).unwrap().output, [13]); + assert!(!matches!( + source.execution_functions[0].code[2], + Instruction::Binary { .. } + )); + + let legacy = program( + json!([ + {"op": "literal", "dest": 1, "value": 4}, + {"op": "binary", "operator": "mul", "dest": 2, "left": 0, "right": 0}, + {"op": "assert_eq", "left": [2], "right": [1]}, + {"op": "ret", "value": [0]} + ]), + 3, + ) + .check() + .unwrap(); + assert_eq!(legacy.execute("root", vec![2]).unwrap().output, [2]); + assert_eq!(legacy.execute("root", vec![3]).unwrap_err().instruction, 2); + } +} diff --git a/crates/aiur/src/constraints.rs b/crates/aiur/src/constraints.rs deleted file mode 100644 index 83ecd7c31..000000000 --- a/crates/aiur/src/constraints.rs +++ /dev/null @@ -1,873 +0,0 @@ -use multi_stark::{ - lookup::Lookup, - p3_field::{Field, PrimeCharacteristicRing}, -}; -use std::{array, ops::Range, sync::LazyLock}; - -use crate::{ - FxIndexMap, G, - bytecode::{Block, Ctrl, Op, Toplevel, ValIdx}, - function_channel, - gadgets::{ - AiurGadget, - bytes1::{Bytes1, Bytes1Op}, - bytes2::{Bytes2, Bytes2Op}, - }, - memory_channel, u8_add_channel, u8_bit_decomposition_channel, u8_mul_channel, - u8_range_check_channel, u8_shift_left_channel, u8_shift_right_channel, - u8_sub_channel, u8_xor_channel, u8_xor_split4_channel, u8_xor_split7_channel, - u16_range_check_channel, -}; - -type Expr = multi_stark::expr::Expr; -type Degree = u8; - -/// Main-trace column variable at index `i`. -#[inline] -fn var(i: usize) -> Expr { - Expr::main(u32::try_from(i).expect("column index exceeds u32")) -} - -/// Base-field constant expression. -#[inline] -fn konst(value: G) -> Expr { - Expr::constant(value) -} - -/// `256⁻¹` in the Goldilocks field. The field inversion is expensive, so it is -/// computed once and reused by the byte carry-chain constraints. -static INV_256: LazyLock = LazyLock::new(|| G::from_u64(256).inverse()); -/// Constant expression for `(2^32)⁻¹`, built once from its Goldilocks -/// value and cloned into every virtual u32 carry. -static INV_2_POW_32_EXPR: LazyLock = - LazyLock::new(|| konst(G::from_u64(0xffff_fffe_0000_0002))); - -fn pack_u32_expr( - bytes: impl ExactSizeIterator, -) -> (Expr, Degree) { - assert_eq!(bytes.len(), 4, "u32 operation requires four bytes"); - bytes.enumerate().fold( - (konst(G::ZERO), 0), - |(expr, degree), (i, (byte, byte_degree))| { - ( - expr + byte * konst(G::from_u64(1_u64 << (8 * i))), - degree.max(byte_degree), - ) - }, - ) -} - -/// Holds data for a function circuit. -pub struct Constraints { - pub zeros: Vec, - pub selectors: Range, - pub width: usize, -} - -struct ConstraintState { - /// Index of the circuit member currently being walked. - function_index: G, - /// One function with terminal control and one selector: operation slots - /// have one writer. Selector count alone does not exclude empty branches. - branchless: bool, - /// Input size of the current member (inputs live in columns - /// `0..input_size` for every member; the circuit reserves the max). - input_size: usize, - /// Column of the current member's first selector: the circuit's input - /// block plus the selector counts of the members walked before it. - sel_base: usize, - column: usize, - lookup: usize, - lookups: Vec>, - map: Vec<(Expr, Degree)>, - constraints: Constraints, - /// Yield info collected from branches, used by MatchContinue. - /// NOT part of save/restore so yields persist across branch restores. - yield_info: Vec<(Expr, Vec<(Expr, Degree)>)>, -} - -struct SharedState { - column: usize, - lookup: usize, - map_len: usize, -} - -impl ConstraintState { - fn selector_index(&self, sel: usize) -> usize { - sel + self.sel_base - } - - /// Selector-gate a lookup argument. Lookup slots shared across branches - /// superpose their arguments (`Σ_b sel_b·arg_b`, sound because the - /// selectors are mutually exclusive), which needs the weighting — but it - /// costs a degree: the argument becomes degree 2. A branchless function - /// has a single branch, so its arguments are sent RAW (degree ≤ 1): the - /// multiplicity (still selector-gated) alone decides whether the lookup - /// counts, and on inactive (padding) rows a zero multiplicity makes the - /// message value irrelevant. Degree-1 messages leave the degree headroom - /// to group two lookups per chained-accumulator step. - fn gate(&self, sel: &Expr, arg: Expr) -> Expr { - if self.branchless { arg } else { sel.clone() * arg } - } - - fn next_lookup(&mut self) -> &mut Lookup { - let lookup = &mut self.lookups[self.lookup]; - self.lookup += 1; - lookup - } - - fn next_auxiliary(&mut self) -> Expr { - self.column += 1; - var(self.column - 1) - } - - fn range_u16(&mut self, sel: &Expr, limb: Expr) { - let args = vec![ - self.gate(sel, konst(u16_range_check_channel())), - self.gate(sel, limb), - ]; - let lookup = self.next_lookup(); - combine_lookup_args(lookup, args); - lookup.multiplicity = lookup.multiplicity.clone() + sel.clone(); - } - - fn save(&mut self) -> SharedState { - SharedState { - column: self.column, - lookup: self.lookup, - map_len: self.map.len(), - } - } - - fn restore(&mut self, init: &SharedState) { - self.column = init.column; - self.lookup = init.lookup; - self.map.truncate(init.map_len); - } -} - -impl Toplevel { - /// Ungated lookup arguments are safe only with one writer per slot. - /// A branch with no return/yield still writes lookups, so counting the - /// terminal selectors alone does not establish that condition. - pub(crate) fn circuit_is_branchless(&self, circuit_index: usize) -> bool { - let circuit = &self.circuits[circuit_index]; - let [member] = circuit.members.as_slice() else { - return false; - }; - circuit.layout.selectors == 1 - && self.functions.get(*member).is_some_and(|function| { - matches!(function.body.ctrl, Ctrl::Return(..) | Ctrl::Yield(..)) - }) - } - - /// Build the constraints of one circuit. The circuit's members are walked - /// like branches of a single function: each walk restarts the auxiliary - /// column / lookup-slot counters (so members share those, like match arms - /// do), while selector columns are laid out consecutively per member. All - /// members fold their return message into the shared lookup slot 0, gated - /// by their own selectors and carrying their own function index, against - /// the single shared multiplicity column. - pub fn build_constraints( - &self, - circuit_index: usize, - ) -> (Constraints, Vec>) { - let circuit = &self.circuits[circuit_index]; - let layout = circuit.layout; - let constraints = Constraints { - zeros: vec![], - selectors: layout.input_size..layout.input_size + layout.selectors, - width: layout.width(), - }; - let mut state = ConstraintState { - function_index: G::ZERO, - branchless: self.circuit_is_branchless(circuit_index), - input_size: 0, - sel_base: 0, - column: 0, - lookup: 0, - map: vec![], - lookups: vec![empty_lookup(); layout.lookups], - constraints, - yield_info: vec![], - }; - // The shared multiplicity column: first auxiliary, right after the - // selectors. The return lookup occupies the first lookup slot. - let multiplicity = var(layout.input_size + layout.selectors); - state.lookups[0].multiplicity = -multiplicity.clone(); - let aux_start = layout.input_size + layout.selectors + 1; - let mut sel_base = layout.input_size; - let mut circuit_sel = Expr::from(G::ZERO); - for &member in &circuit.members { - let function = &self.functions[member]; - state.function_index = G::from_usize(member); - state.input_size = function.layout.input_size; - state.sel_base = sel_base; - state.column = aux_start; - state.lookup = 1; - state.map.clear(); - (0..function.layout.input_size).for_each(|i| state.map.push((var(i), 1))); - let body_sel = function.body.get_block_selector(&state); - circuit_sel = circuit_sel + body_sel.clone(); - function.body.collect_constraints(body_sel, &mut state); - debug_assert!(state.yield_info.is_empty()); - sel_base += function.layout.selectors; - } - // The old `Air::eval` asserted each selector column boolean; the new - // system compiles a constraint vector, so materialize those explicitly. - for sel in state.constraints.selectors.clone() { - let s = var(sel); - state.constraints.zeros.push(s.clone() * (s - konst(G::ONE))); - } - // Cross-member exclusivity: the circuit-level selector (the sum of the - // members' top-block selectors) must be boolean, so at most one member - // is active per row and the shared return lookup emits a single - // member's message. A singleton circuit already gets this from its top - // block's own boolean constraint. - if circuit.members.len() > 1 { - state - .constraints - .zeros - .push(circuit_sel.clone() * (Expr::from(G::ONE) - circuit_sel.clone())); - } - // Only active members can supply return lookups. Keep the lookup - // multiplicity linear and constrain its activity here, including every - // member of a grouped circuit. - state.constraints.zeros.push(multiplicity * (konst(G::ONE) - circuit_sel)); - (state.constraints, state.lookups) - } -} - -fn empty_lookup() -> Lookup { - Lookup { multiplicity: konst(G::ZERO), args: vec![] } -} - -impl Block { - fn collect_constraints(&self, sel: Expr, state: &mut ConstraintState) { - // Boolean constraint for this block's selector - let block_sel = self.get_block_selector(state); - state - .constraints - .zeros - .push(block_sel.clone() * (konst(G::ONE) - block_sel)); - self.ops.iter().for_each(|op| op.collect_constraints(&sel, state)); - self.ctrl.collect_constraints(sel, state); - } - - /// Compute this block's selector as the sum of its immediate children's - /// selectors. For leaf blocks (Return/Yield) this is the single selector - /// variable. For Match/MatchContinue this is the sum of case branch - /// selectors — crucially excluding the MatchContinue's continuation, - /// whose return selector fires alongside a yield selector and must not - /// be double-counted. - fn get_block_selector(&self, state: &ConstraintState) -> Expr { - match &self.ctrl { - Ctrl::Return(sel, _) | Ctrl::Yield(sel, _) => { - var(state.selector_index(*sel)) - }, - Ctrl::Match(_, cases, def) | Ctrl::MatchContinue(_, cases, def, ..) => { - let mut sel = konst(G::ZERO); - for branch in cases.values() { - sel = sel + branch.get_block_selector(state); - } - if let Some(branch) = def { - sel = sel + branch.get_block_selector(state); - } - sel - }, - } - } -} - -/// Process match cases and optional default branch, emitting selector-gated -/// constraints. Each branch is processed with save/restore so branches share -/// auxiliary columns. Returns (max_column, max_lookup) across all branches. -fn collect_branch_constraints( - var_idx: ValIdx, - cases: &FxIndexMap, - def: &Option>, - state: &mut ConstraintState, -) -> (usize, usize) { - let (matched, _) = state.map[var_idx].clone(); - let init = state.save(); - let mut max_column = init.column; - let mut max_lookup = init.lookup; - for (&value, branch) in cases.iter() { - let branch_sel = branch.get_block_selector(state); - state - .constraints - .zeros - .push(branch_sel.clone() * (matched.clone() - konst(value))); - branch.collect_constraints(branch_sel, state); - max_column = max_column.max(state.column); - max_lookup = max_lookup.max(state.lookup); - state.restore(&init); - } - if let Some(branch) = def { - let branch_sel = branch.get_block_selector(state); - for &value in cases.keys() { - let inverse = state.next_auxiliary(); - state.constraints.zeros.push( - branch_sel.clone() - * ((matched.clone() - konst(value)) * inverse - konst(G::ONE)), - ); - } - branch.collect_constraints(branch_sel, state); - max_column = max_column.max(state.column); - max_lookup = max_lookup.max(state.lookup); - state.restore(&init); - } - (max_column, max_lookup) -} - -impl Ctrl { - #[allow(clippy::needless_pass_by_value)] - fn collect_constraints(&self, sel: Expr, state: &mut ConstraintState) { - match self { - Ctrl::Return(_, values) => { - // channel and function index - let mut args = vec![ - state.gate(&sel, konst(function_channel())), - state.gate(&sel, konst(state.function_index)), - ]; - // input - args.extend( - (0..state.input_size) - .map(|arg| state.gate(&sel, state.map[arg].0.clone())), - ); - // output - args.extend( - values.iter().map(|arg| state.gate(&sel, state.map[*arg].0.clone())), - ); - let lookup = &mut state.lookups[0]; - combine_lookup_args(lookup, args); - // multiplicity is already set - }, - Ctrl::Yield(sel, values) => { - let yield_sel = var(state.selector_index(*sel)); - let yield_vals: Vec<(Expr, Degree)> = - values.iter().map(|&v| state.map[v].clone()).collect(); - state.yield_info.push((yield_sel, yield_vals)); - }, - Ctrl::Match(var_idx, cases, def) => { - let (max_column, max_lookup) = - collect_branch_constraints(*var_idx, cases, def, state); - state.column = max_column; - state.lookup = max_lookup; - }, - Ctrl::MatchContinue( - var_idx, - cases, - def, - output_size, - _shared_aux, - _shared_lookups, - continuation, - ) => { - let yield_info_base = state.yield_info.len(); - let (max_column, max_lookup) = - collect_branch_constraints(*var_idx, cases, def, state); - - // Advance past the shared branch region so merge + continuation - // auxiliaries don't collide with branch auxiliaries. - state.column = max_column; - state.lookup = max_lookup; - - // Collect yield info from branches - let yields: Vec<_> = - state.yield_info.drain(yield_info_base..).collect(); - - // Compute continuation selector = sum of yield selectors - let cont_sel = yields - .iter() - .map(|(sel, _)| sel.clone()) - .fold(konst(G::ZERO), |a, b| a + b); - - // Merge constraints, gated by the parent selector `sel`. Gating is - // required because a matchContinue inside a tail match branch may be - // inactive (the other branch was taken). At the OOD evaluation point, - // ungated constraints on shared auxiliary columns don't evaluate to 0. - for i in 0..*output_size { - let merged = state.next_auxiliary(); - let sum = yields - .iter() - .map(|(sel_j, vals)| sel_j.clone() * vals[i].0.clone()) - .fold(konst(G::ZERO), |a, b| a + b); - state.constraints.zeros.push(sel.clone() * (merged.clone() - sum)); - state.map.push((merged, 1)); - } - - // Link continuation selector to the continuation block's selector - let cont_block_sel = continuation.get_block_selector(state); - state.constraints.zeros.push(cont_block_sel - cont_sel.clone()); - - // Collect constraints for the continuation, gated by cont_sel - continuation.collect_constraints(cont_sel, state); - }, - } - } -} - -impl Op { - fn collect_constraints(&self, sel: &Expr, state: &mut ConstraintState) { - match self { - Op::Const(f) => state.map.push(((*f).into(), 0)), - Op::Add(a, b) => { - let (a, a_deg) = &state.map[*a]; - let (b, b_deg) = &state.map[*b]; - let deg = a_deg.max(b_deg); - state.map.push((a.clone() + b.clone(), *deg)); - }, - Op::Sub(a, b) => { - let (a, a_deg) = &state.map[*a]; - let (b, b_deg) = &state.map[*b]; - let deg = a_deg.max(b_deg); - state.map.push((a.clone() - b.clone(), *deg)); - }, - Op::Mul(a, b) => { - let (a, a_deg) = &state.map[*a]; - let (b, b_deg) = &state.map[*b]; - let deg = a_deg + b_deg; - let mul = a.clone() * b.clone(); - if deg < 2 { - state.map.push((mul, deg)); - } else { - let col = state.next_auxiliary(); - state.map.push((col.clone(), 1)); - state.constraints.zeros.push(sel.clone() * (col - mul)); - } - }, - Op::EqZero(a) => { - let (a, deg) = state.map[*a].clone(); - if let Expr::Const(a) = a { - assert_eq!(deg, 0); - state.map.push((konst(G::from_bool(a == G::ZERO)), 0)); - } else { - // We have two constraints: - // 1. ax = 0 - // 2. ad + x = 1 - // When a = 0, the first constraint is trivial and the second - // constraint enforces x = 1. - // When a ≠ 0, the first constraint enforces x = 0 and the - // second constraint can be satisfied with d = a⁻¹. - // In both cases, x has the semantics that we want. - let d = state.next_auxiliary(); - let x = state.next_auxiliary(); - state.constraints.zeros.push(sel.clone() * a.clone() * x.clone()); - state - .constraints - .zeros - .push(sel.clone() * (a * d + x.clone() - konst(G::ONE))); - state.map.push((x, 1)); - } - }, - Op::Call(function_index, inputs, output_size, op_unconstrained) => { - if *op_unconstrained { - // No lookup constraint -- unconstrained call - for _ in 0..*output_size { - let col = state.next_auxiliary(); - state.map.push((col.clone(), 1)); - } - } else { - // channel and function index - let mut lookup_args = vec![ - state.gate(sel, konst(function_channel())), - state.gate(sel, konst(G::from_usize(*function_index))), - ]; - // input - lookup_args.extend( - inputs.iter().map(|arg| state.gate(sel, state.map[*arg].0.clone())), - ); - // output - let output: Vec = (0..*output_size) - .map(|_| { - let col = state.next_auxiliary(); - state.map.push((col.clone(), 1)); - col - }) - .collect(); - lookup_args - .extend(output.into_iter().map(|col| state.gate(sel, col))); - - let lookup = state.next_lookup(); - combine_lookup_args(lookup, lookup_args); - lookup.multiplicity = lookup.multiplicity.clone() + sel.clone(); - } - }, - Op::Store(values) => { - let size = values.len(); - // channel, function index and pointer - let ptr = state.next_auxiliary(); - state.map.push((ptr.clone(), 1)); - let mut lookup_args = vec![ - state.gate(sel, konst(memory_channel())), - state.gate(sel, konst(G::from_usize(size))), - state.gate(sel, ptr), - ]; - // stored values - lookup_args.extend( - values - .iter() - .map(|value| state.gate(sel, state.map[*value].0.clone())), - ); - - let lookup = state.next_lookup(); - combine_lookup_args(lookup, lookup_args); - lookup.multiplicity = lookup.multiplicity.clone() + sel.clone(); - }, - Op::Load(size, ptr) => { - // channel, size and pointer - let mut lookup_args = vec![ - state.gate(sel, konst(memory_channel())), - state.gate(sel, konst(G::from_usize(*size))), - state.gate(sel, state.map[*ptr].0.clone()), - ]; - // loaded values - let values: Vec = (0..*size) - .map(|_| { - let col = state.next_auxiliary(); - state.map.push((col.clone(), 1)); - col - }) - .collect(); - lookup_args.extend(values.into_iter().map(|col| state.gate(sel, col))); - - let lookup = state.next_lookup(); - combine_lookup_args(lookup, lookup_args); - lookup.multiplicity = lookup.multiplicity.clone() + sel.clone(); - }, - // The message is diagnostic only — it never enters the constraint - // system, so a labelled and an unlabelled assert are identical in - // the circuit. - Op::AssertEq(xs, ys, _) => { - assert_eq!(xs.len(), ys.len()); - for (x, y) in xs.iter().zip(ys) { - let (x, _) = &state.map[*x]; - let (y, _) = &state.map[*y]; - state.constraints.zeros.push(sel.clone() * (x.clone() - y.clone())); - } - }, - Op::IOGetInfo(_, _) => (0..2).for_each(|_| { - let col = state.next_auxiliary(); - state.map.push((col, 1)); - }), - Op::IORead(_, _, len) => (0..*len).for_each(|_| { - let col = state.next_auxiliary(); - state.map.push((col, 1)); - }), - Op::U8BitDecomposition(byte) => bytes1_constraints( - *byte, - &Bytes1Op::BitDecomposition, - u8_bit_decomposition_channel(), - sel.clone(), - state, - ), - Op::U8ShiftLeft(byte) => bytes1_constraints( - *byte, - &Bytes1Op::ShiftLeft, - u8_shift_left_channel(), - sel.clone(), - state, - ), - Op::U8ShiftRight(byte) => bytes1_constraints( - *byte, - &Bytes1Op::ShiftRight, - u8_shift_right_channel(), - sel.clone(), - state, - ), - Op::U8Xor(i, j) => bytes2_constraints( - *i, - *j, - &Bytes2Op::Xor, - u8_xor_channel(), - sel.clone(), - state, - ), - Op::U8Add(i, j) => { - // The add lookup pins only the low byte `z = (x + y) mod 256`. The - // carry is then `c = (x + y - z) / 256`, a compound expression that - // needs no auxiliary column or lookup output. - let (x, x_deg) = state.map[*i].clone(); - let (y, y_deg) = state.map[*j].clone(); - let z = state.next_auxiliary(); - let lookup_args = vec![ - state.gate(sel, konst(u8_add_channel())), - state.gate(sel, x.clone()), - state.gate(sel, y.clone()), - state.gate(sel, z.clone()), - ]; - let lookup = state.next_lookup(); - combine_lookup_args(lookup, lookup_args); - lookup.multiplicity = lookup.multiplicity.clone() + sel.clone(); - let carry = (x + y - z.clone()) * konst(*INV_256); - state.map.push((z, 1)); - state.map.push((carry, x_deg.max(y_deg).max(1))); - }, - Op::UnconstrainedU32Add(a, b) => { - let (x, x_deg) = - pack_u32_expr(a.iter().map(|idx| state.map[*idx].clone())); - let (y, y_deg) = - pack_u32_expr(b.iter().map(|idx| state.map[*idx].clone())); - let z_bytes: Vec<_> = (0..4).map(|_| state.next_auxiliary()).collect(); - let (z, z_deg) = - pack_u32_expr(z_bytes.iter().cloned().map(|byte| (byte, 1))); - for byte in z_bytes { - state.map.push((byte, 1)); - } - state.map.push(( - (x + y - z) * (*INV_2_POW_32_EXPR).clone(), - x_deg.max(y_deg).max(z_deg), - )); - }, - Op::UnconstrainedU32Add3(a, b, c) => { - let (x, x_deg) = - pack_u32_expr(a.iter().map(|idx| state.map[*idx].clone())); - let (y, y_deg) = - pack_u32_expr(b.iter().map(|idx| state.map[*idx].clone())); - let (w, w_deg) = - pack_u32_expr(c.iter().map(|idx| state.map[*idx].clone())); - let z_bytes: Vec<_> = (0..4).map(|_| state.next_auxiliary()).collect(); - let (z, z_deg) = - pack_u32_expr(z_bytes.iter().cloned().map(|byte| (byte, 1))); - for byte in z_bytes { - state.map.push((byte, 1)); - } - state.map.push(( - (x + y + w - z) * (*INV_2_POW_32_EXPR).clone(), - x_deg.max(y_deg).max(w_deg).max(z_deg), - )); - }, - Op::U32ToField(bytes) => { - state - .map - .push(pack_u32_expr(bytes.iter().map(|idx| state.map[*idx].clone()))); - }, - Op::U8Mul(i, j) => bytes2_constraints( - *i, - *j, - &Bytes2Op::Mul, - u8_mul_channel(), - sel.clone(), - state, - ), - Op::U8Sub(i, j) => { - // The sub lookup pins only the low byte `z = (x - y) mod 256`. Since - // `z + y = x (mod 256)`, the borrow is `c = (z + y - x) / 256`, a - // compound expression that needs no auxiliary column or lookup output. - let (x, x_deg) = state.map[*i].clone(); - let (y, y_deg) = state.map[*j].clone(); - let z = state.next_auxiliary(); - let lookup_args = vec![ - state.gate(sel, konst(u8_sub_channel())), - state.gate(sel, x.clone()), - state.gate(sel, y.clone()), - state.gate(sel, z.clone()), - ]; - let lookup = state.next_lookup(); - combine_lookup_args(lookup, lookup_args); - lookup.multiplicity = lookup.multiplicity.clone() + sel.clone(); - let borrow = (z.clone() + y - x) * konst(*INV_256); - state.map.push((z, 1)); - state.map.push((borrow, x_deg.max(y_deg).max(1))); - }, - Op::U8And(i, j) | Op::U8Or(i, j) | Op::U8LessThan(i, j) => { - let x = state.map[*i].0.clone(); - let y = state.map[*j].0.clone(); - let output = state.next_auxiliary(); - // The table binds x and y to bytes. Each affine result uniquely - // determines the original output over Goldilocks (2 and 256 are - // nonzero), without a new column or polynomial constraint. - let (channel, result) = match self { - Op::U8And(..) => ( - u8_xor_channel(), - x.clone() + y.clone() - konst(G::TWO) * output.clone(), - ), - Op::U8Or(..) => ( - u8_xor_channel(), - konst(G::TWO) * output.clone() - x.clone() - y.clone(), - ), - Op::U8LessThan(..) => ( - u8_sub_channel(), - x.clone() - y.clone() + konst(G::from_u16(256)) * output.clone(), - ), - _ => unreachable!(), - }; - let args = vec![ - state.gate(sel, konst(channel)), - state.gate(sel, x), - state.gate(sel, y), - state.gate(sel, result), - ]; - let lookup = state.next_lookup(); - combine_lookup_args(lookup, args); - lookup.multiplicity = lookup.multiplicity.clone() + sel.clone(); - state.map.push((output, 1)); - }, - Op::U8XorSplit7(i, j) => bytes2_constraints( - *i, - *j, - &Bytes2Op::XorSplit7, - u8_xor_split7_channel(), - sel.clone(), - state, - ), - Op::U8XorSplit4(i, j) => bytes2_constraints( - *i, - *j, - &Bytes2Op::XorSplit4, - u8_xor_split4_channel(), - sel.clone(), - state, - ), - Op::U8RangeCheck(i, j) => { - // Pure range-check lookup: no output columns (the `u8` results alias - // the inputs), just require `(i, j)` from the byte chip. - let x = state.map[*i].0.clone(); - let y = state.map[*j].0.clone(); - let lookup_args = vec![ - state.gate(sel, konst(u8_range_check_channel())), - state.gate(sel, x), - state.gate(sel, y), - ]; - let lookup = state.next_lookup(); - combine_lookup_args(lookup, lookup_args); - lookup.multiplicity = lookup.multiplicity.clone() + sel.clone(); - }, - Op::U32LessThan(x_idx, y_idx) => { - // Bound a, b and the witness c to u32 values with two u16 limbs each. - // The whole-word carry establishes the integer relation - // b + c = a + carry * 2^32. - // With c = (a - b) mod 2^32, a < b iff the carry is one; equality - // gives c = carry = 0. The bounded integer relation cannot wrap p. - // Six scalar range lookups use the shared table's u16 channel. - let a = state.map[*x_idx].0.clone(); - let b = state.map[*y_idx].0.clone(); - let a_limbs: [Expr; 2] = array::from_fn(|_| state.next_auxiliary()); - let c_limbs: [Expr; 2] = array::from_fn(|_| state.next_auxiliary()); - let b_limbs: [Expr; 2] = array::from_fn(|_| state.next_auxiliary()); - let recompose = |limbs: &[Expr; 2]| { - limbs[0].clone() + limbs[1].clone() * konst(G::from_u32(65536)) - }; - state - .constraints - .zeros - .push(sel.clone() * (a.clone() - recompose(&a_limbs))); - state - .constraints - .zeros - .push(sel.clone() * (b.clone() - recompose(&b_limbs))); - - // Inputs are affine after multiplication materialization. Use the - // whole words directly: this carry is an expression, not a column. - let carry = (b + recompose(&c_limbs) - a) * INV_2_POW_32_EXPR.clone(); - state - .constraints - .zeros - .push(sel.clone() * carry.clone() * (carry.clone() - konst(G::ONE))); - for limb in a_limbs.into_iter().chain(c_limbs).chain(b_limbs) { - state.range_u16(sel, limb); - } - state.map.push((carry, 1)); - }, - Op::IOSetInfo(..) | Op::IOWrite(..) | Op::Debug(..) => (), - Op::UnconstrainedBigUintDivMod(_, _) => { - // Unconstrained: outputs are two fresh witness columns holding the - // quotient/remainder list-head pointers. Mirrors `IORead`'s shape — - // no constraint relation, just two new auxiliary slots. Verification - // (`q*b + r == a`, `r < b`) is the caller's responsibility in - // constrained code. - for _ in 0..2 { - let col = state.next_auxiliary(); - state.map.push((col, 1)); - } - }, - Op::UnconstrainedGToBytes(_) => { - // Unconstrained hint bytes: 8 fresh auxiliary columns, no relation, - // no lookup. The caller pins them (range checks + recomposition + - // canonicality asserts) in constrained code. - for _ in 0..8 { - let col = state.next_auxiliary(); - state.map.push((col, 1)); - } - }, - Op::UnconstrainedGInverse(_) => { - // Unconstrained hint inverse: one fresh auxiliary column, no - // relation. The caller pins it via multiply-and-assert. - let col = state.next_auxiliary(); - state.map.push((col, 1)); - }, - } - } -} - -fn bytes1_constraints( - byte: usize, - op: &Bytes1Op, - channel: G, - sel: Expr, - state: &mut ConstraintState, -) { - let size = Bytes1.output_size(op); - - let mut lookup_args = vec![ - state.gate(&sel, konst(channel)), - state.gate(&sel, state.map[byte].0.clone()), - ]; - - let output: Vec = (0..size) - .map(|_| { - let col = state.next_auxiliary(); - state.map.push((col.clone(), 1)); - col - }) - .collect(); - lookup_args.extend(output.into_iter().map(|col| state.gate(&sel, col))); - - let lookup = state.next_lookup(); - combine_lookup_args(lookup, lookup_args); - lookup.multiplicity = lookup.multiplicity.clone() + sel; -} - -fn bytes2_constraints( - i: usize, - j: usize, - op: &Bytes2Op, - channel: G, - sel: Expr, - state: &mut ConstraintState, -) { - let size = Bytes2.output_size(op); - - let mut lookup_args = vec![ - state.gate(&sel, konst(channel)), - state.gate(&sel, state.map[i].0.clone()), - state.gate(&sel, state.map[j].0.clone()), - ]; - - let output: Vec = (0..size) - .map(|_| { - let col = state.next_auxiliary(); - state.map.push((col.clone(), 1)); - col - }) - .collect(); - lookup_args.extend(output.into_iter().map(|col| state.gate(&sel, col))); - - let lookup = state.next_lookup(); - combine_lookup_args(lookup, lookup_args); - lookup.multiplicity = lookup.multiplicity.clone() + sel; -} - -fn combine_lookup_args( - lookup: &mut Lookup, - args: impl IntoIterator, -) { - let mut args_iterator = args.into_iter(); - lookup.args.iter_mut().zip(args_iterator.by_ref()).for_each( - |(arg, value)| { - *arg = arg.clone() + value; - }, - ); - lookup.args.extend(args_iterator); -} diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs index 28773da34..24973bd0d 100644 --- a/crates/aiur/src/execute.rs +++ b/crates/aiur/src/execute.rs @@ -1,1509 +1,966 @@ -use multi_stark::p3_field::{Field, PrimeCharacteristicRing, PrimeField64}; -use rustc_hash::FxHashMap; -use std::collections::hash_map::Entry; - -use crate::{ - FxIndexMap, G, - bytecode::{Block, Ctrl, FunIdx, Function, Op, Toplevel}, - gadgets::{ - AiurGadget, - bytes1::{Bytes1, Bytes1Op, Bytes1Queries}, - bytes2::{Bytes2, Bytes2Op, Bytes2Queries}, - }, - querymap::QueryMap, - record_pool::{BudgetError, RecordReservation}, -}; - -fn u32_value(map: &[G], bytes: &[usize]) -> u64 { - assert_eq!(bytes.len(), 4, "u32 operation requires four bytes"); - bytes - .iter() - .enumerate() - .fold(0, |word, (i, idx)| word | (map[*idx].as_canonical_u64() << (8 * i))) -} - -fn u32_sum(values: &[u64]) -> ([G; 4], G) { - let sum: u128 = values.iter().map(|x| u128::from(*x)).sum(); - let word = u32::try_from(sum & 0xFFFF_FFFF).expect("masked to 32 bits"); - let carry = u64::try_from(sum >> 32).expect("sum of u32 words fits in u64"); - (word.to_le_bytes().map(|b| G::from_u64(b.into())), G::from_u64(carry)) -} - -pub struct QueryRecord { - pub function_queries: Vec, - pub memory_queries: FxIndexMap, - /// Admission and lifetime of this record's retained query storage. - pub budget: RecordBudget, - pub bytes1_queries: Bytes1Queries, - pub bytes2_queries: Bytes2Queries, - /// The pointer of every memory table's first entry: entry `i` of a table - /// has pointer `pointer_base + i`, whatever the table's width. Records - /// proven together in one batch take distinct bases so their pointers - /// never coincide, which is what lets a load in one record be served by - /// a memory row in another. The bases are a fixed split of the pointer - /// space ([`pointer_stride`] apart): no table's height enters, and a base - /// per width would gain nothing, since the width is part of every memory - /// message. - pub pointer_base: usize, - /// The calls this record leaves to other records, if any. - pub ownership: Option, - /// Deferred calls made so far: the callee's arguments and how many - /// times a caller in this record pushed them. Each is a push with no - /// row here; the owner's row absorbs the count - /// ([`Self::absorb_deferred`]). - pub deferred: FxHashMap, u64>, -} - -/// Which calls a record answers itself. A call to `callee` whose arguments -/// are not in `owned` is deferred: the caller's row pushes the call's -/// message as if the callee had run, and nothing runs. Some record whose -/// `owned` holds the arguments executes the call for real, and its row -/// pulls every record's pushes once their counts are absorbed. Ownership -/// is a prover hint, never constrained: a call no record answers leaves -/// the batch unbalanced, and a call two records answer is two balanced -/// rows. The callee must return nothing, since a deferring record has no -/// output to hand its caller. -pub struct Ownership { - pub callee: FunIdx, - pub owned: rustc_hash::FxHashSet>, -} - -impl QueryRecord { - /// Records a call to `callee` with `args` as deferred and returns `true`, - /// or returns `false` when this record answers it itself (no ownership, - /// another callee, or owned arguments). - pub fn defer_call( +//! Memoized evaluation. A query is (callable ID, flat arguments); its first +//! completed output is reused. Counts are integers, never field elements. +use crate::bytecode::{Binary as BinOp, CheckedProgram, Instruction, Type}; +use crate::field::{FieldBackend, PrimeField}; +use crate::hints::{BoundHints, HintEntry, HintSite, PreparedHints}; +use crate::memory::Memory; +use crate::query::QueryMap; +use crate::value::Value; +use serde::Serialize; +use std::fmt; + +pub(crate) mod dispatch; + +#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize)] +pub struct QueryInput { + pub function: usize, + pub args: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq, Serialize)] +pub struct QueryOutput { + pub output: Vec, + pub multiplicity: u64, +} +#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)] +pub struct Cell { + pub r#type: Type, + pub value: Vec, +} +#[derive(Clone, Debug, Serialize)] +pub struct MemoryEntry { + pub address: usize, + pub cell: Cell, + pub multiplicity: u64, +} +#[derive(Clone, Debug)] +pub struct Execution { + pub output: Vec, + pub queries: QueryMap, + /// Pointers are local to each payload width; record indices are separate. + pub memory: Memory, + pub instructions: u64, + pub(crate) hints: std::sync::Arc>, + pub(crate) deferred: Option>, +} + +/// Unit calls owned by another record remain lookup demands in the circuit. +/// The host may defer only this callable; no result or pointer is fabricated. +#[derive(Clone, Debug)] +pub struct Partition { + pub function: usize, + pub owned: Vec>, + pub memory_start: u64, + pub memory_end: u64, +} +#[derive(Clone, Debug)] +pub(crate) struct Deferred { + function: usize, + calls: rustc_hash::FxHashMap, u64>, + edges: rustc_hash::FxHashSet<(Vec, Vec)>, + // First owned calls reachable through a non-owned query. Cache hits must + // replay these dependencies even though they do not execute the query. + dependencies: + rustc_hash::FxHashMap<(usize, usize), rustc_hash::FxHashSet>>, +} +impl Deferred { + fn dependency( &mut self, - callee: FunIdx, - args: &[G], - ) -> Result { - let Some(ownership) = &self.ownership else { - return Ok(false); - }; - if ownership.callee != callee || ownership.owned.contains(args) { - return Ok(false); - } - let queries = &mut self.function_queries[callee]; - if queries.get_index_of(args).is_none() { - // The entry a caller's row reads its (empty) output from; no - // multiplicity, so no row. - queries.insert(args, &[], G::ZERO)?; - } - *self.deferred.entry(args.to_vec()).or_insert(0) += 1; - Ok(true) - } - - /// Adds another record's deferred calls to the multiplicities of the rows - /// of `callee` that answer them. Every deferred call must have been - /// executed here — a call this record deferred as well has no answer. - pub fn absorb_deferred( - &mut self, - callee: FunIdx, - deferred: &FxHashMap, u64>, - ) -> Result<(), String> { - let queries = &mut self.function_queries[callee]; - for (args, &count) in deferred { - if self.deferred.contains_key(args) { - return Err("deferred call was deferred by its owner too".into()); + function: usize, + row: usize, + source: &[F], + target: &[F], + budget: &crate::budget::Budget, + ) -> Result<(), crate::budget::BudgetError> { + if function == self.function { + let edge = (source.to_vec(), target.to_vec()); + if !self.edges.contains(&edge) { + budget.reserve( + (source.len() + target.len()) + .saturating_mul(std::mem::size_of::()) + + 192, + )?; + self.edges.insert(edge); + } + } else { + if !self.dependencies.contains_key(&(function, row)) { + budget.reserve(256)?; + } + let set = self.dependencies.entry((function, row)).or_default(); + if !set.contains(target) { + budget.reserve( + target.len().saturating_mul(std::mem::size_of::()) + 96, + )?; + set.insert(target.to_vec()); } - let Some(i) = queries.get_index_of(args) else { - return Err("deferred call has no row in the owning record".into()); - }; - let (_, multiplicity) = - queries.get_index_mut(i).expect("index just found"); - *multiplicity += G::from_u64(count); } Ok(()) } } - -/// Pointer distance between the memory namespaces of `workers` records -/// proven in one batch: record `r` stores its width-`w` table at -/// `[r · stride, r · stride + N_{r,w})`. Every pointer must stay below -/// 2^32, since the kernel's memoization compares interned pointers as -/// `u32`, so the stride is the largest power of two with `workers` strides -/// below 2^32; a record's tables must fit it. -pub fn pointer_stride(workers: usize) -> usize { - POINTER_LIMIT / workers.max(1).next_power_of_two() -} - -/// The entries a memory table can hold: the kernel compares pointers as -/// `u32`, so `Store` fails once a table would reach 2^32 entries instead -/// of allocating a pointer the comparison cannot order. -pub const POINTER_LIMIT: usize = 1 << 32; - -impl QueryRecord { - pub fn new(toplevel: &Toplevel) -> Self { - Self::with_pointer_base(toplevel, 0) - } - - /// A record whose memory pointers start at `pointer_base`. - pub fn with_pointer_base(toplevel: &Toplevel, pointer_base: usize) -> Self { - let budget = RecordBudget::for_this_thread(); - let function_queries = toplevel - .functions +impl Execution { + pub fn deferred_calls(&self) -> impl Iterator { + self + .deferred .iter() - .map(|f| QueryMap::with_budget(f.layout.input_size, budget.clone())) - .collect(); - let memory_queries = toplevel - .memory_sizes - .iter() - .map(|width| (*width, QueryMap::with_budget(*width, budget.clone()))) - .collect(); - let bytes1_queries = Bytes1Queries::new(); - let bytes2_queries = Bytes2Queries::new(); - Self { - function_queries, - memory_queries, - budget, - bytes1_queries, - bytes2_queries, - pointer_base, - ownership: None, - deferred: FxHashMap::default(), - } + .flat_map(|d| d.calls.iter().map(|(k, &n)| (k.as_slice(), n))) } -} - -thread_local! { - static RECORD_RESERVATION: std::cell::RefCell> = - const { std::cell::RefCell::new(None) }; - static RECORD_BYTE_CAP: std::cell::Cell> = - const { std::cell::Cell::new(None) }; - /// Retained bytes of the record being built on this thread, counted at - /// every query-map insertion ([`note_retained`]), so every path that - /// grows a record is covered and the total is exact at every check. - static RECORD_BYTES: std::cell::Cell = const { std::cell::Cell::new(0) }; -} - -/// Caps the retained bytes of every record created on this thread from -/// now on (`None`: no cap). A driver running several executions ahead of -/// a prover gives each an equal share of the host budget this way, so an -/// execution that would outgrow its share stops with -/// [`ExecError::RecordBudgetExceeded`] instead of exhausting the box. -pub fn set_record_byte_cap(cap: Option) { - RECORD_BYTE_CAP.with(|cell| cell.set(cap)); -} - -/// Binds admission to records constructed on the current thread. The -/// records and their maps retain ownership after the binding ends. -pub fn bind_record_reservation( - reservation: &RecordReservation, -) -> RecordBinding { - let previous = - RECORD_RESERVATION.with(|cell| cell.replace(Some(reservation.clone()))); - let cap = RECORD_BYTE_CAP.with(|cell| cell.replace(None)); - RECORD_BYTES.with(|cell| cell.set(0)); - RecordBinding { previous, cap, thread: std::marker::PhantomData } -} - -pub struct RecordBinding { - previous: Option, - cap: Option, - thread: std::marker::PhantomData>, -} - -impl Drop for RecordBinding { - fn drop(&mut self) { - RECORD_RESERVATION.with(|cell| cell.replace(self.previous.take())); - RECORD_BYTE_CAP.with(|cell| cell.set(self.cap)); + pub fn partition_edges( + &self, + ) -> impl Iterator { + self + .deferred + .iter() + .flat_map(|d| d.edges.iter().map(|(a, b)| (a.as_slice(), b.as_slice()))) } -} - -/// Counts a query-map entry of `elems` field elements toward the record -/// being built on this thread, as [`record_retained_bytes`] measures it. -#[inline] -pub fn note_retained( - elems: usize, - budget: &RecordBudget, -) -> Result<(), ExecError> { - let bytes = elems.saturating_mul(8).saturating_add(21); - if let Some(reservation) = &budget.reservation { - reservation.reserve(bytes)?; + pub(crate) fn is_deferred( + &self, + function: usize, + args: &[B::Element], + ) -> bool { + self + .deferred + .as_ref() + .is_some_and(|d| d.function == function && d.calls.contains_key(args)) } - RECORD_BYTES.with(|cell| { - let next = cell.get().saturating_add(bytes); - if let Some(cap) = budget.cap - && next > cap - { - return Err(ExecError::RecordBudgetExceeded { bytes: next, cap }); + /// Absorb callers' counts only after all owned calls have completed. Missing + /// owners, overflow and a deferred answer cannot become a completed query. + pub fn absorb_deferred( + &mut self, + function: usize, + args: &[B::Element], + count: u64, + ) -> Result<(), String> { + if self.is_deferred(function, args) { + return Err("owner deferred its own call".into()); } - cell.set(next); + let table = + self.queries.tables.get_mut(function).ok_or("unknown owner function")?; + if table.widths().1 != 0 { + return Err("deferred call has a non-unit result".into()); + } + let row = table.lookup(args).1.ok_or("deferred call has no owning row")?; + table + .adjust_count(row, count, true) + .ok_or("deferred multiplicity overflow")?; Ok(()) - }) -} - -/// Retained bytes of the record most recently built on this thread, as -/// the cap measures them ([`note_retained`]): what a driver reads after -/// an execution to report the record's size against its share. -pub fn record_bytes() -> usize { - RECORD_BYTES.with(std::cell::Cell::get) + } } - -/// Fixed-cap admission or a share of a process-wide pool. -#[derive(Clone, Debug, Default)] -pub struct RecordBudget { - pub cap: Option, - pub reservation: Option, +#[derive(Clone, Debug, PartialEq, Eq, Serialize)] +pub struct ExecutionError { + pub function: String, + pub instruction: usize, + pub message: String, + #[serde(skip)] + pub resource: Option, +} +impl fmt::Display for ExecutionError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!( + f, + "{} at instruction {}: {}", + self.function, self.instruction, self.message + ) + } } - -impl RecordBudget { - /// The cap set for this thread, and a fresh count for the new record. - fn for_this_thread() -> Self { - RECORD_BYTES.with(|cell| cell.set(0)); +impl std::error::Error for ExecutionError {} +impl From for ExecutionError { + fn from(error: crate::budget::BudgetError) -> Self { Self { - cap: RECORD_BYTE_CAP.with(std::cell::Cell::get), - reservation: RECORD_RESERVATION.with(|cell| cell.borrow().clone()), + function: "".into(), + instruction: 0, + message: error.to_string(), + resource: Some(error), } } } -/// Function-entry cancellation check, also enforcing fixed-cap admission. -/// Query insertion reserves capacity before allocating. -#[inline] -pub fn check_record_cap(budget: &RecordBudget) -> Result<(), ExecError> { - if let Some(reservation) = &budget.reservation { - reservation.check()?; - } - let Some(cap) = budget.cap else { - return Ok(()); - }; - let bytes = RECORD_BYTES.with(std::cell::Cell::get); - if bytes > cap { - return Err(ExecError::RecordBudgetExceeded { bytes, cap }); +struct Frame<'a, F> { + function: usize, + query: usize, + registers: Vec, + pc: usize, + cursor: usize, + destination: &'a [usize], +} +struct Machine<'a, 'p, B: FieldBackend> { + #[cfg(feature = "function-profile")] + profile: Option<&'p mut crate::function_profile::FunctionProfiler>, + _profile_lifetime: std::marker::PhantomData<&'p ()>, + program: &'a CheckedProgram, + frames: Vec>, + spare_registers: Vec>, + arguments: Vec, + output_buffer: Vec, + record: Execution, + hints: &'a [Vec>>], + dispatch: &'a [Vec>], + ownership: Option<(usize, rustc_hash::FxHashSet>)>, +} + +enum Request { + Started, + Cached(usize), + Deferred, +} +impl Frame<'_, F> { + #[inline] + fn write(&mut self, dest: &[usize], values: &[F]) { + debug_assert_eq!(dest.len(), values.len()); + if let ([reg], [value]) = (dest, values) { + self.registers[*reg] = *value; + return; + } + for (reg, value) in dest.iter().zip(values) { + self.registers[*reg] = *value; + } } - Ok(()) } - -/// Every memory store's admission check, in the interpreter and in the -/// generated kernel alike: the width's table must be under -/// [`POINTER_LIMIT`], and the record must be within its byte cap. Both -/// failures are clean [`ExecError`]s the execution returns. -#[inline] -pub fn check_store( - budget: &RecordBudget, - table: &QueryMap, - size: usize, -) -> Result<(), ExecError> { - if table.len() >= POINTER_LIMIT { - return Err(ExecError::MemoryTableFull(size)); +impl CheckedProgram { + /// A fresh execution session. No cache or pointer can leak across sessions. + pub fn execute( + &self, + entry: &str, + args: Vec, + ) -> Result, ExecutionError> { + self.execute_with_hints(entry, args, &[]) } - check_record_cap(budget) -} -pub struct IOKeyInfo { - pub idx: usize, - pub len: usize, -} - -pub struct IOBuffer { - /// Per-channel data arenas. `idx` slots into `data[&channel]`. - pub data: FxHashMap>, - /// Channel-keyed info map; same `key` on different channels resolves - /// to distinct `IOKeyInfo`. - pub map: FxHashMap<(G, Vec), IOKeyInfo>, -} - -impl IOBuffer { - #[inline] - pub fn get_info( + /// Witness data and query caches belong to this invocation alone. Supplied + /// data is validated before execution, including unused rows and conflicts. + pub fn execute_with_hints( &self, - channel: G, - key: &[G], - ) -> Result<&IOKeyInfo, ExecError> { - self.map.get(&(channel, key.to_vec())).ok_or(ExecError::InvalidIOKey) - } - fn set_info( - &mut self, - channel: G, - key: Vec, - idx: usize, - len: usize, - ) -> Result<(), ExecError> { - let Entry::Vacant(e) = self.map.entry((channel, key)) else { - return Err(ExecError::IOMappingAlreadySet); + entry: &str, + args: Vec, + hints: &[HintEntry], + ) -> Result, ExecutionError> { + let error = |message| ExecutionError { + function: entry.into(), + instruction: 0, + resource: None, + message, }; - e.insert(IOKeyInfo { idx, len }); - Ok(()) + let selected = self.entry(entry).map_err(error)?; + self.inputs[selected.function] + .validate(&args, self.field) + .map_err(error)?; + let hints = self.prepare_hints(hints).map_err(error)?; + hints.execute(entry, args) } - #[inline] - pub fn read( + + pub fn execute_values( &self, - channel: G, - idx: usize, - len: usize, - ) -> Result<&[G], ExecError> { - let empty: &[G] = &[]; - let arena = self.data.get(&channel).map_or(empty, |v| v.as_slice()); - arena - .get(idx..idx.saturating_add(len)) - .ok_or(ExecError::IOReadOutOfBounds { idx, len }) + entry: &str, + args: &[Value], + ) -> Result, ExecutionError> { + self.execute_values_with_hints(entry, args, &[]) } - fn write(&mut self, channel: G, data: impl Iterator) { - self.data.entry(channel).or_default().extend(data) - } -} - -/// Errors raised by Aiur bytecode execution. Mirrors the panic/assert sites -/// in `Function::execute` so callers (tests, kernel-arena runner) can -/// distinguish recoverable rejections (`AssertEq`, `MatchNoCase`) from -/// genuine bytecode bugs. -#[derive(Debug, Clone, PartialEq, Eq)] -pub enum ExecError { - NotEntryFunction(FunIdx), - InvalidMemorySize(usize), - /// A width's table reached [`POINTER_LIMIT`] entries. - MemoryTableFull(usize), - /// The next insertion would exceed the execution's record ceiling. - /// Shared-pool pressure below the ceiling waits for capacity instead. - RecordBudgetExceeded { - bytes: usize, - cap: usize, - }, - /// A paused execution releases its record so another can finish. - RecordMemoryContention, - RecordPoolShutdown, - UnboundPointer { - ptr: u64, - size: usize, - }, - PointerTooLarge(u64), - IndexTooLarge(u64), - U32OutOfRange(u64), - U8RangeCheckFailed(u64), - UnconstrainedBigUintDivModFailed(String), - AssertEqLengthMismatch { - lhs: usize, - rhs: usize, - }, - AssertEqMismatch { - lhs: u64, - rhs: u64, - /// Optional label from `assert_eq!(a, b, "…")`, surfaced in the error - /// so a failing assert identifies itself instead of reporting bare - /// operands that could have come from anywhere. - msg: Option, - }, - MatchNoCase(u64), - NoContinuation, - StackNotEmpty, - InvalidIOKey, - IOMappingAlreadySet, - IOReadOutOfBounds { - idx: usize, - len: usize, - }, - /// Dispatched a `fun_idx` that the codegen'd kernel doesn't know. - /// Generated by `execute_generated` in `crate::ix::aiur_ixvm`. - InvalidFunIdx(usize), -} -impl std::fmt::Display for ExecError { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - Self::NotEntryFunction(idx) => { - write!(f, "cannot execute non-entry function {idx}") - }, - Self::InvalidMemorySize(s) => write!(f, "invalid memory size {s}"), - Self::MemoryTableFull(s) => write!( - f, - "width-{s} memory table reached the pointer limit of {POINTER_LIMIT} entries" - ), - Self::RecordBudgetExceeded { bytes, cap } => write!( - f, - "record reached {bytes} B of retained queries, over its cap of {cap} B" - ), - Self::RecordMemoryContention => { - write!(f, "record cancelled to resolve memory contention") - }, - Self::RecordPoolShutdown => write!(f, "record pool shut down"), - Self::UnboundPointer { ptr, size } => { - write!(f, "unbound pointer {ptr} for memory size {size}") - }, - Self::PointerTooLarge(p) => write!(f, "pointer {p} too large for usize"), - Self::IndexTooLarge(i) => write!(f, "index {i} too large for usize"), - Self::U32OutOfRange(v) => write!(f, "value {v} out of u32 range"), - Self::U8RangeCheckFailed(v) => { - write!(f, "value {v} out of u8 range [0, 256)") - }, - Self::UnconstrainedBigUintDivModFailed(msg) => { - write!(f, "unconstrained_big_uint_div_mod failed: {msg}") - }, - Self::AssertEqLengthMismatch { lhs, rhs } => { - write!(f, "assert_eq length mismatch: lhs={lhs}, rhs={rhs}") - }, - Self::AssertEqMismatch { lhs, rhs, msg } => match msg { - Some(m) => write!(f, "assert_eq mismatch: {lhs} != {rhs} ({m})"), - None => write!(f, "assert_eq mismatch: {lhs} != {rhs}"), - }, - Self::MatchNoCase(v) => write!(f, "no match case for value {v}"), - Self::NoContinuation => write!(f, "yield without continuation"), - Self::StackNotEmpty => { - write!(f, "exec entries stack not empty at return") - }, - Self::InvalidIOKey => write!(f, "invalid IO key"), - Self::IOMappingAlreadySet => write!(f, "IO mapping already set for key"), - Self::IOReadOutOfBounds { idx, len } => { - write!(f, "IO read out of bounds: idx={idx}, len={len}") - }, - Self::InvalidFunIdx(idx) => write!(f, "invalid fun_idx {idx}"), + pub fn execute_values_with_hints( + &self, + entry: &str, + args: &[Value], + hints: &[HintEntry], + ) -> Result, ExecutionError> { + let error = |message| ExecutionError { + function: entry.into(), + instruction: 0, + resource: None, + message, + }; + let selected = self.entry(entry).map_err(error)?; + if args.len() != selected.inputs.len() { + return Err(error("entry argument count mismatch".into())); + } + let mut flat = vec![]; + for (value, ty) in args.iter().zip(&selected.inputs) { + flat.extend(ty.flatten(value, self.field).map_err(error)?); } + self.execute_with_hints(entry, flat, hints) } -} -impl std::error::Error for ExecError {} - -impl From for ExecError { - fn from(error: BudgetError) -> Self { - match error { - BudgetError::Exceeded { bytes, cap } => { - Self::RecordBudgetExceeded { bytes, cap } - }, - BudgetError::Cancelled => Self::RecordMemoryContention, - BudgetError::Shutdown => Self::RecordPoolShutdown, - } + pub fn output_value( + &self, + entry: &str, + result: &Execution, + ) -> Result { + let ty = self + .entry(entry)? + .output + .as_ref() + .ok_or("entry result contains opaque types or pointers")?; + ty.unflatten(&result.output, self.field) } } -/// Gated by `IX_AIUR_QUERY_STATS=1`: dump per-function query-map sizes -/// during/after execution so RAM blowups can be attributed to specific -/// Aiur functions (indices resolve to names via the Lean -/// `CompiledToplevel`). Heaviest maps first, by retained G elements. -static QUERY_STATS: std::sync::LazyLock = - std::sync::LazyLock::new(|| { - std::env::var_os("IX_AIUR_QUERY_STATS").is_some() - }); +impl PreparedHints<'_, B> { + /// Execute with previously validated hints and a fresh query record/ROM. + pub fn execute( + &self, + entry: &str, + args: Vec, + ) -> Result, ExecutionError> { + self.execute_inner( + entry, + args, + None, + None, + #[cfg(feature = "function-profile")] + None, + ) + } -fn dump_query_stats(record: &QueryRecord, tag: &str) { - let mut rows: Vec<(usize, usize, usize)> = record - .function_queries - .iter() - .enumerate() - .map(|(i, m)| (i, m.len(), m.retained_elems())) - .filter(|(_, n, _)| *n > 0) - .collect(); - rows.sort_by_key(|row| std::cmp::Reverse(row.2)); - let total_entries: usize = rows.iter().map(|r| r.1).sum(); - let total_elems: usize = rows.iter().map(|r| r.2).sum(); - eprintln!( - "[aiur-stats {tag}] function_queries: {total_entries} entries, \ - {total_elems} G-elems; top maps:" - ); - for (i, n, e) in rows.iter().take(30) { - eprintln!(" fn{i:<4} entries={n:<12} g_elems={e}"); + /// Execute under a shared record reservation. Its storage keeps the charge + /// alive after the worker hands the record to a prover on another thread. + pub fn execute_reserved( + &self, + entry: &str, + args: Vec, + reservation: &crate::budget::RecordReservation, + ) -> Result, ExecutionError> { + self.execute_inner( + entry, + args, + Some(reservation), + None, + #[cfg(feature = "function-profile")] + None, + ) } - let mem: Vec = record - .memory_queries - .iter() - .map(|(w, m)| format!("w{w}={}", m.len())) - .collect(); - eprintln!("[aiur-stats {tag}] memory entries: {}", mem.join(" ")); -} -impl Toplevel { - pub fn execute( + pub fn execute_partition( &self, - fun_idx: FunIdx, - args: Vec, - io_buffer: &mut IOBuffer, - ) -> Result<(QueryRecord, Vec), ExecError> { - self.execute_with_pointer_base(fun_idx, args, io_buffer, 0) + entry: Option<(&str, Vec)>, + partition: Partition, + reservation: Option<&crate::budget::RecordReservation>, + ) -> Result, ExecutionError> { + let (name, args) = entry.unwrap_or(("", vec![])); + self.execute_inner( + name, + args, + reservation, + Some(partition), + #[cfg(feature = "function-profile")] + None, + ) } - /// [`Self::execute`] into a record whose memory pointers start at - /// `pointer_base` (see [`QueryRecord::pointer_base`]). - pub fn execute_with_pointer_base( + #[cfg(feature = "function-profile")] + pub fn execute_profiled( &self, - fun_idx: FunIdx, - args: Vec, - io_buffer: &mut IOBuffer, - pointer_base: usize, - ) -> Result<(QueryRecord, Vec), ExecError> { - let mut record = QueryRecord::with_pointer_base(self, pointer_base); - let output = self.execute_in(fun_idx, args, io_buffer, &mut record)?; - Ok((record, output)) + entry: &str, + args: Vec, + profile: &mut crate::function_profile::FunctionProfiler, + ) -> Result, ExecutionError> { + self.execute_inner(entry, args, None, None, Some(profile)) } - /// Executes entry `fun_idx` into `record`, memoizing against whatever it - /// already holds. The entry query is registered with multiplicity one — - /// the pull a claim's push balances — so a record that runs an entry - /// nobody claims (a worker answering deferred calls) takes that one off - /// again. - pub fn execute_in( + fn execute_inner( &self, - fun_idx: FunIdx, - args: Vec, - io_buffer: &mut IOBuffer, - record: &mut QueryRecord, - ) -> Result, ExecError> { - if !self.functions[fun_idx].entry { - return Err(ExecError::NotEntryFunction(fun_idx)); + entry: &str, + args: Vec, + reservation: Option<&crate::budget::RecordReservation>, + partition: Option>, + #[cfg(feature = "function-profile")] profile: Option< + &mut crate::function_profile::FunctionProfiler, + >, + ) -> Result, ExecutionError> { + let error = |message| ExecutionError { + function: entry.into(), + instruction: 0, + resource: None, + message, + }; + let root = if partition.is_some() && entry.is_empty() { + None + } else { + let selected = self.program.entry(entry).map_err(error)?; + self.program.inputs[selected.function] + .validate(&args, self.program.field) + .map_err(error)?; + Some(QueryInput { function: selected.function, args }) + }; + if let Some(p) = &partition { + if p.function >= self.program.program.functions.len() + || self.program.outputs[p.function].width() != 0 + { + return Err(error( + "partition requires an ordinary unit-returning function".into(), + )); + } + if p.memory_end > self.program.field.modulus() { + return Err(error("partition exceeds field".into())); + } + for args in &p.owned { + self.program.inputs[p.function] + .validate(args, self.program.field) + .map_err(error)?; + } } - let function = &self.functions[fun_idx]; - let output = function.execute(fun_idx, args, self, record, io_buffer)?; - if *QUERY_STATS { - dump_query_stats(record, "final"); + let mut queries = QueryMap::new( + self + .program + .inputs + .iter() + .zip(&self.program.outputs) + .map(|(a, b)| (a.width(), b.width())), + self.program.field, + ); + queries.reserve_with(reservation); + for map in &self.maps { + queries + .budget + .reserve(map.rows().saturating_mul(std::mem::size_of::()))?; + } + queries.bind_maps(&self.maps); + let mut memory = Memory::new( + self + .program + .memory_types + .iter() + .map(|(ty, layout)| (ty.clone(), layout.width())), + ); + memory.budget = queries.budget.clone(); + if let Some(p) = &partition { + memory + .set_range(p.memory_start, p.memory_end) + .map_err(|e| error(e.into()))?; + } + let mut machine = Machine { + #[cfg(feature = "function-profile")] + profile, + _profile_lifetime: std::marker::PhantomData, + program: self.program, + frames: vec![], + spare_registers: vec![], + arguments: vec![], + output_buffer: vec![], + hints: &self.bindings.sites, + dispatch: &self.dispatch, + ownership: partition + .as_ref() + .map(|p| (p.function, p.owned.iter().cloned().collect())), + record: Execution { + hints: self.bindings.clone(), + output: vec![], + queries, + memory, + instructions: 0, + deferred: partition.as_ref().map(|p| Deferred { + function: p.function, + calls: Default::default(), + edges: Default::default(), + dependencies: Default::default(), + }), + }, + }; + if let Some(root) = root { + machine.run_query(root)?; + } + if let Some(partition) = partition { + let output = std::mem::take(&mut machine.record.output); + let mut artificial = Vec::new(); + for args in partition.owned { + if machine.record.queries.tables[partition.function] + .lookup(&args) + .1 + .is_some() + { + continue; + } + machine.run_query(QueryInput { + function: partition.function, + args: args.clone(), + })?; + artificial.push(args); + } + let table = &mut machine.record.queries.tables[partition.function]; + for args in artificial { + let row = table.lookup(&args).1.unwrap(); + table + .adjust_count(row, 1, false) + .ok_or_else(|| error("missing artificial root count".into()))?; + } + machine.record.output = output; } - Ok(output) + Ok(machine.record) } } +impl<'a, B: FieldBackend> Machine<'a, '_, B> { + #[inline(always)] + fn finish_return(&mut self) -> Result<(), ExecutionError> { + let frame = self.frames.last().unwrap(); + self.program.outputs[frame.function] + .validate_registers(&self.arguments, self.program.field) + .map_err(|e| self.error(e))?; + let frame = self.frames.pop().unwrap(); + if self.record.deferred.is_some() { + self.propagate_dependencies(frame.function, frame.query)?; + } + if let Some(parent) = self.frames.last_mut() { + parent.write(frame.destination, &self.arguments); + } else { + self.record.output = self.arguments.clone(); + } + self.record.queries.tables[frame.function] + .finish(frame.query, &self.arguments); + self.spare_registers.push(frame.registers); + #[cfg(feature = "function-profile")] + if let Some(profile) = &mut self.profile { + profile.exit(false); + } + Ok(()) + } -enum ExecEntry<'a> { - Op(&'a Op), - Ctrl(&'a Ctrl), -} + fn error(&self, message: impl Into) -> ExecutionError { + let (function, instruction) = self + .frames + .last() + .map(|f| { + ( + self + .program + .callable_name(f.function) + .unwrap_or("") + .to_owned(), + f.pc, + ) + }) + .unwrap_or(("".into(), 0)); + ExecutionError { + function, + instruction, + message: message.into(), + resource: None, + } + } -struct CallerState { - fun_idx: FunIdx, - map: Vec, - unconstrained: bool, - continuation_depth: usize, -} + fn propagate_dependencies( + &mut self, + function: usize, + row: usize, + ) -> Result<(), ExecutionError> { + let Some(deferred) = &mut self.record.deferred else { return Ok(()) }; + if function != deferred.function + && let Some(dependencies) = deferred.dependencies.remove(&(function, row)) + { + if let Some(parent) = self.frames.last() { + let source = + self.record.queries.tables[parent.function].input(parent.query); + for target in &dependencies { + deferred.dependency( + parent.function, + parent.query, + source, + target, + &self.record.queries.budget, + )?; + } + } + deferred.dependencies.insert((function, row), dependencies); + } + Ok(()) + } -struct ContinuationState<'a> { - block: &'a Block, - map_len: usize, -} + /// Hit: return the existing output and increment only this query's count. + /// Miss: reserve a stable query ID, then start a function frame. + /// Multiplicity zero marks an in-progress query, whose output cannot be used. + #[inline(always)] + fn request( + &mut self, + function_id: usize, + destination: &'a [usize], + ) -> Result { + debug_assert!(function_id < self.program.program.functions.len()); + #[cfg(feature = "function-profile")] + if let Some(profile) = &mut self.profile { + profile.enter(function_id); + } + if let Some(deferred) = &mut self.record.deferred + && deferred.function == function_id + && let Some(parent) = self.frames.last() + { + let source = + self.record.queries.tables[parent.function].input(parent.query); + deferred.dependency( + parent.function, + parent.query, + source, + &self.arguments, + &self.record.queries.budget, + )?; + } + if let Some((callee, owned)) = &self.ownership + && *callee == function_id + && !owned.contains(&self.arguments) + { + let calls = &mut self.record.deferred.as_mut().unwrap().calls; + if !calls.contains_key(&self.arguments) { + self.record.queries.budget.reserve( + self + .arguments + .len() + .saturating_mul(std::mem::size_of::()) + + 96, + )?; + } + let count = calls.entry(self.arguments.clone()).or_default(); + *count = count.checked_add(1).ok_or_else(|| ExecutionError { + function: "".into(), + instruction: 0, + resource: None, + message: "deferred count overflow".into(), + })?; + return Ok(Request::Deferred); + } + let budget = &self.record.queries.budget; + let table = &mut self.record.queries.tables[function_id]; + let (hash, found) = table.lookup(&self.arguments); + if let Some(id) = found { + if table.count(id) == 0 { + return Err(self.error("recursive query is already being evaluated")); + } + table.bump(id).ok_or_else(|| ExecutionError { + function: "".into(), + instruction: 0, + resource: None, + message: "query multiplicity overflow".into(), + })?; + if self.record.deferred.is_some() { + self.propagate_dependencies(function_id, id)?; + } + return Ok(Request::Cached(id)); + } + let function = &self.program.program.functions[function_id]; + let mut registers = self.spare_registers.pop().unwrap_or_default(); + // The checked bytecode initializes every register before reading it. + // Keep already initialized spare slots when reusing a larger buffer. + // Static definite-assignment checking prevents stale slots being read. + if registers.len() < function.registers { + budget.vector(®isters, function.registers - registers.len())?; + registers.resize(function.registers, self.program.field.zero()); + } + for &(reg, value) in &self.program.initial_registers[function_id] { + registers[reg] = value; + } + registers[..self.arguments.len()].copy_from_slice(&self.arguments); + let query = table.start(&self.arguments, hash)?; + budget.vector(&self.frames, 1)?; + self.frames.push(Frame { + function: function_id, + query, + registers, + pc: 0, + cursor: 0, + destination, + }); + Ok(Request::Started) + } -impl Function { - fn execute( - &self, - mut fun_idx: FunIdx, - mut map: Vec, - toplevel: &Toplevel, - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - ) -> Result, ExecError> { - let mut exec_entries_stack = vec![]; - let mut callers_states_stack: Vec = vec![]; - let mut continuation_stack: Vec> = vec![]; - macro_rules! push_block_exec_entries { - ($block:expr) => { - exec_entries_stack.push(ExecEntry::Ctrl(&$block.ctrl)); - exec_entries_stack.extend($block.ops.iter().rev().map(ExecEntry::Op)); - }; + fn run_query( + &mut self, + root: QueryInput, + ) -> Result<(), ExecutionError> { + if root.function >= self.program.program.functions.len() { + #[cfg(feature = "function-profile")] + if let Some(profile) = &mut self.profile { + profile.enter(root.function); + } + self.record.output.resize( + self.program.outputs[root.function].width(), + self.program.field.zero(), + ); + self.record.queries.tables[root.function] + .static_map + .as_mut() + .unwrap() + .call(&root.args, &mut self.record.output) + .map_err(|e| self.error(e))?; + #[cfg(feature = "function-profile")] + if let Some(profile) = &mut self.profile { + profile.exit(false); + } + return Ok(()); } - push_block_exec_entries!(&self.body); - let mut unconstrained = false; - let mut stats_ops: u64 = 0; - while let Some(exec_entry) = exec_entries_stack.pop() { - if *QUERY_STATS { - stats_ops += 1; - if stats_ops.is_multiple_of(1 << 31) { - dump_query_stats(record, &format!("ops={stats_ops}")); - let depth = callers_states_stack.len(); - let tail: Vec = callers_states_stack - .iter() - .rev() - .take(40) - .map(|cs| cs.fun_idx.to_string()) - .collect(); - eprintln!( - "[aiur-stats] call stack depth={depth}, top fns: {}", - tail.join(" ") - ); - } + self.arguments = root.args; + let request = self.request(root.function, &[])?; + if !matches!(request, Request::Started) { + self.record.output = if let Request::Cached(id) = request { + self.record.queries.tables[root.function].output(id).output.to_vec() + } else { + vec![] + }; + #[cfg(feature = "function-profile")] + if let Some(profile) = &mut self.profile { + profile.exit(true); } - match exec_entry { - ExecEntry::Op(Op::Const(c)) => map.push(*c), - ExecEntry::Op(Op::Add(a, b)) => { - let a = map[*a]; - let b = map[*b]; - map.push(a + b); - }, - ExecEntry::Op(Op::Sub(a, b)) => { - let a = map[*a]; - let b = map[*b]; - map.push(a - b); - }, - ExecEntry::Op(Op::Mul(a, b)) => { - let a = map[*a]; - let b = map[*b]; - map.push(a * b); - }, - ExecEntry::Op(Op::EqZero(a)) => { - let a = map[*a]; - map.push(G::from_bool(a == G::ZERO)); - }, - ExecEntry::Op(Op::Call(callee_idx, args, _, op_unconstrained)) => { - let args: Vec = args.iter().map(|i| map[*i]).collect(); - let callee_unconstrained = unconstrained || *op_unconstrained; - // A call another record answers: the caller's row pushes it and - // nothing runs here (the callee returns nothing). - if !callee_unconstrained && record.defer_call(*callee_idx, &args)? { - continue; - } - let mut cached_output = None; - if let Some(i) = - record.function_queries[*callee_idx].get_index_of(&args) - { - // A zero-multiplicity entry was computed only as an - // unconstrained hint. Promoting just this row would omit all - // of the callee's child lookups and unbalance their channels; - // replay the body constrained so promotion recurses through - // the whole dependency tree. - let mult = record.function_queries[*callee_idx].mult_at(i); - if callee_unconstrained || !mult.is_zero() { - if !callee_unconstrained { - record.function_queries[*callee_idx].bump_multiplicity(i); - } - cached_output = Some( - record.function_queries[*callee_idx].output_at(i).to_vec(), - ); - } - } - if let Some(output) = cached_output { - map.extend(output); - } else { - let saved_map = std::mem::replace(&mut map, args); - callers_states_stack.push(CallerState { - fun_idx, - map: saved_map, - unconstrained, - continuation_depth: continuation_stack.len(), - }); - fun_idx = *callee_idx; - unconstrained = callee_unconstrained; - check_record_cap(&record.budget)?; - push_block_exec_entries!(&toplevel.functions[fun_idx].body); - } - }, - ExecEntry::Op(Op::Store(values)) => { - let values = values.iter().map(|v| map[*v]).collect::>(); - let size = values.len(); - let pointer_base = record.pointer_base; - let memory_queries = record - .memory_queries - .get_mut(&size) - .ok_or(ExecError::InvalidMemorySize(size))?; - if let Some(i) = memory_queries.get_index_of(&values) { - if !unconstrained { - memory_queries.bump_multiplicity(i); - } - map.extend_from_slice(memory_queries.output_at(i)); - } else { - check_store(&record.budget, memory_queries, size)?; - let ptr = G::from_usize(pointer_base + memory_queries.len()); - memory_queries.insert( - &values, - &[ptr], - G::from_bool(!unconstrained), - )?; - map.push(ptr); - } - }, - ExecEntry::Op(Op::Load(size, ptr)) => { - let pointer_base = record.pointer_base; - let memory_queries = record - .memory_queries - .get_mut(size) - .ok_or(ExecError::InvalidMemorySize(*size))?; - let ptr = &map[*ptr]; - let ptr_u64 = ptr.as_canonical_u64(); - let index = usize::try_from(ptr_u64) - .ok() - .ok_or(ExecError::PointerTooLarge(ptr_u64))? - .checked_sub(pointer_base) - .filter(|&i| i < memory_queries.len()) - .ok_or(ExecError::UnboundPointer { ptr: ptr_u64, size: *size })?; - if !unconstrained { - memory_queries.bump_multiplicity(index); + return Ok(()); + } + while !self.frames.is_empty() { + let frame = self.frames.last().unwrap(); + let step = &self.dispatch[frame.function][frame.cursor]; + self.record.instructions = self + .record + .instructions + .checked_add(step.instructions) + .ok_or_else(|| self.error("instruction counter overflow"))?; + let frame = self.frames.last_mut().unwrap(); + frame.pc = step.pc; + let program = self.program; + let (memory_type, branch) = match &step.action { + dispatch::Action::Return { plan } => { + #[cfg(feature = "function-profile-ops")] + if let Some(profile) = &mut self.profile { + profile.operation("return"); } - let (args, _) = - memory_queries.get_index(index).expect("bounds checked above"); - map.extend_from_slice(args); - }, - ExecEntry::Op(Op::AssertEq(xs, ys, msg)) => { - if xs.len() != ys.len() { - return Err(ExecError::AssertEqLengthMismatch { - lhs: xs.len(), - rhs: ys.len(), - }); + let ret = program.returns[frame.function][*plan].as_ref().unwrap(); + self.arguments.clear(); + self.arguments.extend(ret.values.iter().map(|r| frame.registers[*r])); + self.finish_return()?; + continue; + }, + dispatch::Action::Map { function, call } => { + #[cfg(feature = "function-profile-ops")] + if let Some(profile) = &mut self.profile { + profile.operation("table"); } - for (x, y) in xs.iter().zip(ys) { - let lhs = map[*x]; - let rhs = map[*y]; - if lhs != rhs { - return Err(ExecError::AssertEqMismatch { - lhs: lhs.as_canonical_u64(), - rhs: rhs.as_canonical_u64(), - msg: msg.clone(), - }); + let map = + self.record.queries.tables[*function].static_map.as_mut().unwrap(); + call(&mut frame.registers, &mut map.counts).map_err(|message| { + ExecutionError { + function: program.callable_name(frame.function).unwrap().into(), + instruction: frame.pc, + resource: None, + message, } + })?; + frame.pc += 1; + frame.cursor = step.next; + continue; + }, + dispatch::Action::Hint { call } => { + #[cfg(feature = "function-profile-ops")] + if let Some(profile) = &mut self.profile { + profile.operation("hint"); } + call(&mut frame.registers).map_err(|message| ExecutionError { + function: program.callable_name(frame.function).unwrap().into(), + instruction: frame.pc, + resource: None, + message, + })?; + frame.pc += 1; + frame.cursor = step.next; + continue; + }, + dispatch::Action::Bytecode { memory_type, branch } => { + (*memory_type, *branch) }, - ExecEntry::Op(Op::IOGetInfo(channel, key)) => { - let channel = map[*channel]; - let key = key.iter().map(|v| map[*v]).collect::>(); - let IOKeyInfo { idx, len } = io_buffer.get_info(channel, &key)?; - map.push(G::from_usize(*idx)); - map.push(G::from_usize(*len)); - }, - ExecEntry::Op(Op::IOSetInfo(channel, key, idx, len)) => { - let channel = map[*channel]; - let key = key.iter().map(|v| map[*v]).collect::>(); - let get = |x: &usize| { - let v = map[*x].as_canonical_u64(); - usize::try_from(v).ok().ok_or(ExecError::IndexTooLarge(v)) + }; + let instruction = + &program.execution_functions[frame.function].code[frame.pc]; + use Instruction::*; + #[cfg(feature = "function-profile-ops")] + if let Some(profile) = &mut self.profile { + profile.operation(match instruction { + Literal { .. } => "literal", + Copy { .. } => "copy", + Neg { .. } => "neg", + Binary { operator, .. } => match operator { + BinOp::Add => "add", + BinOp::Sub => "sub", + BinOp::Mul => "mul", + BinOp::Div => "div", + }, + Guard { .. } => "guard", + Branch { .. } => "branch", + Jump { .. } => "jump", + Call { function, .. } + if *function >= program.program.functions.len() => + { + "table" + }, + Call { .. } => "call", + Store { .. } => "store", + Load { .. } => "load", + Hint { .. } => "hint", + AssertEq { .. } => "assert_eq", + Ret { .. } => "return", + Fail { .. } => "fail", + }); + } + match instruction { + Literal { dest, value } => frame.registers[*dest] = *value, + Copy { dest, source } => { + self.arguments.clear(); + self.arguments.extend(source.iter().map(|r| frame.registers[*r])); + frame.write(dest, &self.arguments); + }, + Neg { dest, source } => { + frame.registers[*dest] = program.field.neg(frame.registers[*source]) + }, + Binary { dest, operator, left, right } => { + let (a, b) = (frame.registers[*left], frame.registers[*right]); + let result = match operator { + BinOp::Add => program.field.add(a, b), + BinOp::Sub => program.field.sub(a, b), + BinOp::Mul => program.field.mul(a, b), + BinOp::Div => match program.division_inverses[frame.function] + [frame.pc] + .or_else(|| program.field.inverse(b)) + { + Some(inv) => program.field.mul(a, inv), + None => return Err(self.error("division by zero")), + }, }; - io_buffer.set_info(channel, key, get(idx)?, get(len)?)?; - }, - ExecEntry::Op(Op::IORead(channel, idx, len)) => { - let channel = map[*channel]; - let idx_val = map[*idx].as_canonical_u64(); - let idx = usize::try_from(idx_val) - .ok() - .ok_or(ExecError::IndexTooLarge(idx_val))?; - let data = io_buffer.read(channel, idx, *len)?.to_vec(); - map.extend(data); + frame.registers[*dest] = result; }, - ExecEntry::Op(Op::IOWrite(channel, data)) => { - let channel = map[*channel]; - io_buffer.write(channel, data.iter().map(|v| map[*v])) - }, - ExecEntry::Op(Op::U8BitDecomposition(byte)) => { - if unconstrained { - map.extend(Bytes1::bit_decompose(&map[*byte])); - } else { - bytes1_execute( - *byte, - &Bytes1Op::BitDecomposition, - &mut map, - record, - ); - } - }, - ExecEntry::Op(Op::U8ShiftLeft(byte)) => { - if unconstrained { - map.push(Bytes1::shift_left(&map[*byte])); - } else { - bytes1_execute(*byte, &Bytes1Op::ShiftLeft, &mut map, record); - } - }, - ExecEntry::Op(Op::U8ShiftRight(byte)) => { - if unconstrained { - map.push(Bytes1::shift_right(&map[*byte])); - } else { - bytes1_execute(*byte, &Bytes1Op::ShiftRight, &mut map, record); + Guard { tests, message } => { + if !tests.iter().all(|(reg, value)| frame.registers[*reg] == *value) { + return Err(self.error(message)); } }, - ExecEntry::Op(Op::U8Xor(i, j)) => { - if unconstrained { - map.push(Bytes2::xor(&map[*i], &map[*j])); - } else { - bytes2_execute(*i, *j, &Bytes2Op::Xor, &mut map, record); - } - }, - ExecEntry::Op(Op::U8Add(i, j)) => { - // The add gadget yields only the low byte; the carry is derived - // and pushed separately so the op still produces `(low, carry)`. - let (_r, o) = Bytes2::add(&map[*i], &map[*j]); - if unconstrained { - map.push(Bytes2::add(&map[*i], &map[*j]).0); - } else { - bytes2_execute(*i, *j, &Bytes2Op::Add, &mut map, record); - } - map.push(o); - }, - ExecEntry::Op(Op::UnconstrainedU32Add(a, b)) => { - let (bytes, carry) = - u32_sum(&[u32_value(&map, a), u32_value(&map, b)]); - map.extend(bytes); - map.push(carry); - }, - ExecEntry::Op(Op::UnconstrainedU32Add3(a, b, c)) => { - let (bytes, carry) = u32_sum(&[ - u32_value(&map, a), - u32_value(&map, b), - u32_value(&map, c), - ]); - map.extend(bytes); - map.push(carry); - }, - ExecEntry::Op(Op::U32ToField(bytes)) => { - map.push(G::from_u64(u32_value(&map, bytes))); - }, - ExecEntry::Op(Op::U8Mul(i, j)) => { - if unconstrained { - let (lo, hi) = Bytes2::mul(&map[*i], &map[*j]); - map.extend([lo, hi]); - } else { - bytes2_execute(*i, *j, &Bytes2Op::Mul, &mut map, record); - } - }, - ExecEntry::Op(Op::U8Sub(i, j)) => { - // The sub gadget yields only the low byte; the borrow is derived - // and pushed separately so the op still produces `(low, borrow)`. - let (_r, u) = Bytes2::sub(&map[*i], &map[*j]); - if unconstrained { - map.push(Bytes2::sub(&map[*i], &map[*j]).0); - } else { - bytes2_execute(*i, *j, &Bytes2Op::Sub, &mut map, record); - } - map.push(u); - }, - ExecEntry::Op(Op::U8And(i, j)) => { - if unconstrained { - map.push(Bytes2::and(&map[*i], &map[*j])); - } else { - bytes2_execute(*i, *j, &Bytes2Op::And, &mut map, record); - } - }, - ExecEntry::Op(Op::U8Or(i, j)) => { - if unconstrained { - map.push(Bytes2::or(&map[*i], &map[*j])); - } else { - bytes2_execute(*i, *j, &Bytes2Op::Or, &mut map, record); - } - }, - ExecEntry::Op(Op::U8LessThan(i, j)) => { - if unconstrained { - map.push(Bytes2::less_than(&map[*i], &map[*j])); - } else { - bytes2_execute(*i, *j, &Bytes2Op::LessThan, &mut map, record); - } - }, - ExecEntry::Op(Op::U32LessThan(x_idx, y_idx)) => { - let a_val = map[*x_idx].as_canonical_u64(); - let b_val = map[*y_idx].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); - map.push(result); - 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 & 0xffff) as u16); - record.bytes2_queries.bump_u16_range_check((word >> 16) as u16); - } + Branch { tests, otherwise } => { + if !tests.iter().all(|(reg, value)| frame.registers[*reg] == *value) { + frame.pc = *otherwise; + frame.cursor = branch; + continue; } }, - ExecEntry::Op(Op::U8XorSplit7(i, j)) => { - let (a, b) = Bytes2::xor_split7(&map[*i], &map[*j]); - if !unconstrained { - record.bytes2_queries.bump_xor_split7(&map[*i], &map[*j]); - } - map.extend([a, b]); + Jump { target } => { + frame.pc = *target; + frame.cursor = branch; + continue; }, - ExecEntry::Op(Op::U8XorSplit4(i, j)) => { - let (a, b) = Bytes2::xor_split4(&map[*i], &map[*j]); - if !unconstrained { - record.bytes2_queries.bump_xor_split4(&map[*i], &map[*j]); + Call { function, args, dest } => { + if let Some(map) = + &mut self.record.queries.tables[*function].static_map + { + self.arguments.clear(); + self.arguments.extend(args.iter().map(|r| frame.registers[*r])); + self.output_buffer.resize(dest.len(), program.field.zero()); + let result = + map.call(&self.arguments, &mut self.output_buffer).map(|()| { + frame.write(dest, &self.output_buffer); + }); + result.map_err(|message| ExecutionError { + function: program.callable_name(frame.function).unwrap().into(), + instruction: frame.pc, + resource: None, + message, + })?; + frame.pc += 1; + frame.cursor = step.next; + continue; } - map.extend([a, b]); - }, - ExecEntry::Op(Op::U8RangeCheck(i, j)) => { - // No `map.push`: the two `u8` outputs alias the inputs `i`, `j`. - // Records a range-check query so the byte-chip lookup is satisfied. - if !unconstrained { - let (vi, vj) = (map[*i], map[*j]); - let (bi, bj) = (vi.as_canonical_u64(), vj.as_canonical_u64()); - if bi >= 256 { - return Err(ExecError::U8RangeCheckFailed(bi)); + self.arguments.clear(); + self.arguments.extend(args.iter().map(|r| frame.registers[*r])); + let parent = self.frames.len() - 1; + let output = self.request(*function, dest)?; + self.frames[parent].pc += 1; + self.frames[parent].cursor = step.next; + if !matches!(output, Request::Started) { + if let Request::Cached(id) = output { + let output = + self.record.queries.tables[*function].output(id).output; + self.frames[parent].write(dest, output); } - if bj >= 256 { - return Err(ExecError::U8RangeCheckFailed(bj)); + #[cfg(feature = "function-profile")] + if let Some(profile) = &mut self.profile { + profile.exit(true); } - record.bytes2_queries.bump_range_check(&vi, &vj); } - }, - ExecEntry::Op(Op::UnconstrainedBigUintDivMod(a_idx, b_idx)) => { - // Unconstrained hint for klimbs-style LE byte division. Inputs are - // pointers to `List` (in memory[10]) values storing `a` and - // `b` as little-endian u64 limbs (each limb's 8 bytes are stored - // tag-then-bytes within memory[10] per the standard Aiur enum - // layout: `[tag, b0..b7, next_ptr]`). The op walks both lists, - // computes `q = a / b` and `r = a % b` via `num_bigint::BigUint`, - // and rebuilds the result lists in memory[10] with multiplicity 0 - // (unconstrained). Returns the two new head pointers. The caller - // is responsible for verifying `q * b + r == a` and `r < b` in - // constrained code. - // - // The `memory[10]` channel is chosen because the standard Aiur - // layout for a tagged enum with a `(U64, &Self)` constructor is - // `tag(1) + U64(8) + ptr(1) = 10` G values. - let a_ptr = map[*a_idx]; - let b_ptr = map[*b_idx]; - let a_limbs = - read_klimbs_u64(&record.memory_queries, record.pointer_base, a_ptr) - .map_err(ExecError::UnconstrainedBigUintDivModFailed)?; - let b_limbs = - read_klimbs_u64(&record.memory_queries, record.pointer_base, b_ptr) - .map_err(ExecError::UnconstrainedBigUintDivModFailed)?; - let a_big = klimbs_u64_to_biguint(&a_limbs); - let b_big = klimbs_u64_to_biguint(&b_limbs); - let (q_big, r_big) = if b_big == num_bigint::BigUint::ZERO { - (num_bigint::BigUint::ZERO, a_big.clone()) - } else { - (&a_big / &b_big, &a_big % &b_big) + continue; + }, + Store { value, dest, .. } => { + self.arguments.clear(); + self.arguments.extend(value.iter().map(|r| frame.registers[*r])); + program.memory_types[memory_type] + .1 + .validate_registers(&self.arguments, program.field) + .map_err(|e| self.error(e))?; + let index = self + .record + .memory + .intern(memory_type, &self.arguments, program.field.modulus()) + .map_err(|e| match e { + crate::budget::StorageError::Resource(e) => { + ExecutionError::from(e) + }, + crate::budget::StorageError::Invalid(e) => self.error(e), + })?; + let address = self.record.memory.address(index) as u64; + let count = self.record.memory.multiplicity_mut(index); + *count = count.checked_add(1).ok_or_else(|| ExecutionError { + function: "".into(), + instruction: 0, + resource: None, + message: "ROM multiplicity overflow".into(), + })?; + self.frames.last_mut().unwrap().registers[*dest] = + program.field.from_u64(address); + }, + Load { pointer, dest, .. } => { + let address = + usize::try_from(program.field.to_u64(frame.registers[*pointer])) + .map_err(|_| self.error("ROM address overflow"))?; + let Some(index) = + self.record.memory.index_for_type(memory_type, address) + else { + return Err(self.error("dangling pointer")); }; - let q_limbs = biguint_to_klimbs_u64(&q_big); - let r_limbs = biguint_to_klimbs_u64(&r_big); - let q_ptr = build_klimbs_u64( - &mut record.memory_queries, - record.pointer_base, - &q_limbs, - )?; - let r_ptr = build_klimbs_u64( - &mut record.memory_queries, - record.pointer_base, - &r_limbs, - )?; - map.push(q_ptr); - map.push(r_ptr); - }, - ExecEntry::Op(Op::UnconstrainedGToBytes(a_idx)) => { - // Unconstrained hint: the 8 LE bytes of the canonical u64 value. - // No record side effects — the caller pins the bytes with range - // checks + a recomposition assert + a canonicality assert. - let bytes = map[*a_idx].as_canonical_u64().to_le_bytes(); - map.extend(bytes.iter().map(|b| G::from_u8(*b))); - }, - ExecEntry::Op(Op::UnconstrainedGInverse(a_idx)) => { - // Unconstrained hint: the field inverse (`0 ↦ 0`). No record side - // effects — the caller pins it via multiply-and-assert. - map.push(g_inverse_value(map[*a_idx])); - }, - ExecEntry::Op(Op::Debug(label, idxs)) => match idxs { - None => println!("{label}"), - Some(idxs) => { - let parts: Vec<_> = - idxs.iter().map(|idx| map[*idx].to_string()).collect(); - let parts_joined = parts.join(", "); - println!("{label}: {parts_joined}"); - }, - }, - ExecEntry::Ctrl(Ctrl::Match(val_idx, cases, default)) => { - let val = &map[*val_idx]; - if let Some(block) = cases.get(val) { - push_block_exec_entries!(block); - } else { - let default = default - .as_ref() - .ok_or_else(|| ExecError::MatchNoCase(val.as_canonical_u64()))?; - push_block_exec_entries!(default); - } - }, - ExecEntry::Ctrl(Ctrl::MatchContinue( - val_idx, - cases, - default, - _output_size, - _shared_aux, - _shared_lookups, - continuation, - )) => { - continuation_stack.push(ContinuationState { - block: continuation, - map_len: map.len(), - }); - let val = &map[*val_idx]; - if let Some(block) = cases.get(val) { - push_block_exec_entries!(block); - } else { - let default = default - .as_ref() - .ok_or_else(|| ExecError::MatchNoCase(val.as_canonical_u64()))?; - push_block_exec_entries!(default); - } - }, - ExecEntry::Ctrl(Ctrl::Yield(_, output)) => { - let cont = - continuation_stack.pop().ok_or(ExecError::NoContinuation)?; - let yielded: Vec = output.iter().map(|&v| map[v]).collect(); - map.truncate(cont.map_len); - map.extend(yielded); - push_block_exec_entries!(cont.block); - }, - ExecEntry::Ctrl(Ctrl::Return(_, output)) => { - let input_size = toplevel.functions[fun_idx].layout.input_size; - let output = output.iter().map(|i| map[*i]).collect::>(); - record.function_queries[fun_idx].finish( - &map[..input_size], - &output, - !unconstrained, - )?; - if let Some(CallerState { - fun_idx: caller_idx, - map: caller_map, - unconstrained: caller_unconstrained, - continuation_depth, - }) = callers_states_stack.pop() + let count = self.record.memory.multiplicity_mut(index); + *count = count.checked_add(1).ok_or_else(|| ExecutionError { + function: "".into(), + instruction: 0, + resource: None, + message: "ROM multiplicity overflow".into(), + })?; + let entry = self.record.memory.get(index).unwrap(); + self.frames.last_mut().unwrap().write(dest, entry.cell.value); + }, + Hint { key, dest, .. } => { + let site = self.hints[frame.function][frame.pc].as_ref().unwrap(); + self.arguments.clear(); + self.arguments.extend(key.iter().map(|r| frame.registers[*r])); + self.output_buffer.resize(dest.len(), program.field.zero()); + let result = site + .evaluate(&self.arguments, &mut self.output_buffer, program.field) + .map(|()| { + frame.write(dest, &self.output_buffer); + }); + result.map_err(|message| ExecutionError { + function: self.program.program.functions[frame.function] + .name + .clone(), + instruction: frame.pc, + resource: None, + message, + })?; + }, + AssertEq { left, right, message, runtime_check } => { + if *runtime_check + && left + .iter() + .zip(right) + .any(|(a, b)| frame.registers[*a] != frame.registers[*b]) { - continuation_stack.truncate(continuation_depth); - fun_idx = caller_idx; - map = caller_map; - map.extend(output); - unconstrained = caller_unconstrained; - } else { - continuation_stack.clear(); - if !exec_entries_stack.is_empty() { - return Err(ExecError::StackNotEmpty); - } - map = output; - break; + return Err(self.error( + message.as_deref().unwrap_or("equality assertion failed"), + )); } }, + Ret { value } => { + self.arguments.clear(); + self.arguments.extend(value.iter().map(|r| frame.registers[*r])); + self.finish_return()?; + continue; + }, + Fail { message } => return Err(self.error(message)), } + let frame = self.frames.last_mut().unwrap(); + frame.pc += 1; + frame.cursor = step.next; } - Ok(map) - } -} - -pub fn bytes1_execute( - byte: usize, - op: &Bytes1Op, - map: &mut Vec, - record: &mut QueryRecord, -) { - map.extend(Bytes1.execute(op, &[map[byte]], record)); -} - -pub fn bytes2_execute( - i: usize, - j: usize, - op: &Bytes2Op, - map: &mut Vec, - record: &mut QueryRecord, -) { - map.extend(Bytes2.execute(op, &[map[i], map[j]], record)); -} - -// ============================================================================ -// Per-op value-returning helpers for the codegen'd kernel. -// -// The interpreter routes byte ops through `bytes{1,2}_execute(idx, op, -// &mut Vec, record)` which `extends` the Vec with the gadget's -// output. The codegen'd kernel doesn't keep a `Vec` value stack -// (every Aiur ValIdx is a real Rust local), so the wrappers below let -// it consume gadget outputs as fixed-size arrays / tuples / single Gs -// without an allocating Vec per op. -// -// Each helper bumps the same `bytes{1,2}_queries` channel as the -// interpreter's `Bytes{1,2}::execute` arm, so QueryRecord parity is -// preserved bit-for-bit. -// ============================================================================ - -#[inline] -pub fn bytes1_bit_decompose_value(byte: G, record: &mut QueryRecord) -> [G; 8] { - record.bytes1_queries.bump_bit_decomposition(&byte); - let byte_u64 = byte.as_canonical_u64(); - [ - G::from_bool(byte_u64 & 1 == 1), - G::from_bool(byte_u64 >> 1 & 1 == 1), - G::from_bool(byte_u64 >> 2 & 1 == 1), - G::from_bool(byte_u64 >> 3 & 1 == 1), - G::from_bool(byte_u64 >> 4 & 1 == 1), - G::from_bool(byte_u64 >> 5 & 1 == 1), - G::from_bool(byte_u64 >> 6 & 1 == 1), - G::from_bool(byte_u64 >> 7 & 1 == 1), - ] -} - -/// IxVM kernel doesn't emit `Op::U8ShiftLeft` today; kept for codegen -/// of other toplevels that might. -#[inline] -#[allow(dead_code)] -pub fn bytes1_shift_left_value(byte: G, record: &mut QueryRecord) -> G { - record.bytes1_queries.bump_shift_left(&byte); - Bytes1::shift_left(&byte) -} - -/// IxVM kernel doesn't emit `Op::U8ShiftRight` today; kept for -/// codegen of other toplevels. -#[inline] -#[allow(dead_code)] -pub fn bytes1_shift_right_value(byte: G, record: &mut QueryRecord) -> G { - record.bytes1_queries.bump_shift_right(&byte); - Bytes1::shift_right(&byte) -} - -#[inline] -pub fn bytes2_xor_value(a: G, b: G, record: &mut QueryRecord) -> G { - record.bytes2_queries.bump_xor(&a, &b); - Bytes2::xor(&a, &b) -} - -#[inline] -pub fn bytes2_and_value(a: G, b: G, record: &mut QueryRecord) -> G { - record.bytes2_queries.bump_and(&a, &b); - Bytes2::and(&a, &b) -} - -#[inline] -pub fn bytes2_or_value(a: G, b: G, record: &mut QueryRecord) -> G { - record.bytes2_queries.bump_or(&a, &b); - Bytes2::or(&a, &b) -} - -#[inline] -pub fn bytes2_less_than_value(a: G, b: G, record: &mut QueryRecord) -> G { - record.bytes2_queries.bump_less_than(&a, &b); - Bytes2::less_than(&a, &b) -} - -/// IxVM kernel doesn't emit `Op::U8Mul` today; kept for codegen of -/// other toplevels. -#[inline] -#[allow(dead_code)] -pub fn bytes2_mul_value(a: G, b: G, record: &mut QueryRecord) -> (G, G) { - record.bytes2_queries.bump_mul(&a, &b); - Bytes2::mul(&a, &b) -} - -#[inline] -pub fn bytes2_xor_split7_value(a: G, b: G, record: &mut QueryRecord) -> (G, G) { - record.bytes2_queries.bump_xor_split7(&a, &b); - Bytes2::xor_split7(&a, &b) -} - -#[inline] -pub fn bytes2_xor_split4_value(a: G, b: G, record: &mut QueryRecord) -> (G, G) { - record.bytes2_queries.bump_xor_split4(&a, &b); - Bytes2::xor_split4(&a, &b) -} - -/// Bumps `bytes2_queries.add` and returns the full `(low, carry)` -/// pair. The constrained-mode gadget only LOOKUPS `low` from the -/// chip; carry is derived natively. The codegen path uses this -/// helper so the add gadget runs exactly once. -#[inline] -pub fn bytes2_add_value(a: G, b: G, record: &mut QueryRecord) -> (G, G) { - record.bytes2_queries.bump_add(&a, &b); - Bytes2::add(&a, &b) -} - -#[inline] -pub fn bytes2_sub_value(a: G, b: G, record: &mut QueryRecord) -> (G, G) { - record.bytes2_queries.bump_sub(&a, &b); - Bytes2::sub(&a, &b) -} - -/// Re-exports for the codegen'd kernel (`ix::aiur_ixvm`). The generated -/// code names these as `aiur::execute::*`; we re-export them `pub` here -/// so an external `ix` crate can see them. `CodegenBytes1Op` and -/// `CodegenBytes2Op` aren't re-exported here because the generated -/// kernel no longer references them (per-op value helpers above -/// replaced the byte-op enum dispatch). -pub use crate::gadgets::bytes1::Bytes1 as CodegenBytes1; -pub use crate::gadgets::bytes2::Bytes2 as CodegenBytes2; - -/// The value of the `UnconstrainedGInverse` hint: the field inverse, with -/// `0 ↦ 0`. Shared by the interpreter, the codegen'd kernels, and trace -/// population so all three produce identical witness values. -#[inline] -pub fn g_inverse_value(x: G) -> G { - x.try_inverse().unwrap_or(G::ZERO) -} - -/// Helper extracted for the codegen'd kernel: compute the unconstrained -/// BigUint div-mod and return `(q_ptr, r_ptr)`. Same side effects on -/// `record.memory_queries` as the inlined `Op::UnconstrainedBigUintDivMod` -/// arm in the interpreter. -pub fn unconstrained_big_uint_div_mod_helper( - a_ptr: G, - b_ptr: G, - record: &mut QueryRecord, -) -> Result<(G, G), ExecError> { - let a_limbs = - read_klimbs_u64(&record.memory_queries, record.pointer_base, a_ptr) - .map_err(ExecError::UnconstrainedBigUintDivModFailed)?; - let b_limbs = - read_klimbs_u64(&record.memory_queries, record.pointer_base, b_ptr) - .map_err(ExecError::UnconstrainedBigUintDivModFailed)?; - let a_big = klimbs_u64_to_biguint(&a_limbs); - let b_big = klimbs_u64_to_biguint(&b_limbs); - let (q_big, r_big) = if b_big == num_bigint::BigUint::ZERO { - (num_bigint::BigUint::ZERO, a_big.clone()) - } else { - (&a_big / &b_big, &a_big % &b_big) - }; - let q_limbs = biguint_to_klimbs_u64(&q_big); - let r_limbs = biguint_to_klimbs_u64(&r_big); - let q_ptr = build_klimbs_u64( - &mut record.memory_queries, - record.pointer_base, - &q_limbs, - )?; - let r_ptr = build_klimbs_u64( - &mut record.memory_queries, - record.pointer_base, - &r_limbs, - )?; - Ok((q_ptr, r_ptr)) -} - -/// Read-only twin of `unconstrained_big_uint_div_mod_helper` for trace -/// population: recompute `(q, r)` and resolve the list-head pointers the -/// execution already recorded in `memory[10]` — every node was built there -/// during execution, so each key must be present. -pub fn find_unconstrained_big_uint_div_mod( - a_ptr: G, - b_ptr: G, - memory: &FxIndexMap, - pointer_base: usize, -) -> Result<(G, G), String> { - let a_limbs = read_klimbs_u64(memory, pointer_base, a_ptr)?; - let b_limbs = read_klimbs_u64(memory, pointer_base, b_ptr)?; - let a_big = klimbs_u64_to_biguint(&a_limbs); - let b_big = klimbs_u64_to_biguint(&b_limbs); - let (q_big, r_big) = if b_big == num_bigint::BigUint::ZERO { - (num_bigint::BigUint::ZERO, a_big.clone()) - } else { - (&a_big / &b_big, &a_big % &b_big) - }; - let q_ptr = find_klimbs_u64(memory, &biguint_to_klimbs_u64(&q_big))?; - let r_ptr = find_klimbs_u64(memory, &biguint_to_klimbs_u64(&r_big))?; - Ok((q_ptr, r_ptr)) -} - -/// Read-only twin of `build_klimbs_u64`: resolve the pointer of each -/// (already-recorded) list node without inserting. -fn find_klimbs_u64( - memory: &FxIndexMap, - limbs: &[u64], -) -> Result { - let queries = memory.get(&10).ok_or_else(|| { - "memory[10] channel not registered (no List in program?)".to_string() - })?; - let nil_key: Vec = - std::iter::once(G::ONE).chain((0..9).map(|_| G::ZERO)).collect(); - let mut tail_ptr = queries - .get(&nil_key) - .ok_or_else(|| "List Nil node not recorded".to_string())? - .output[0]; - for limb in limbs.iter().rev() { - let mut key: Vec = Vec::with_capacity(10); - key.push(G::ZERO); // Cons tag (first variant of ListNode‹U64›) - for b in &limb.to_le_bytes() { - key.push(G::from_u8(*b)); - } - key.push(tail_ptr); - tail_ptr = queries - .get(&key) - .ok_or_else(|| { - format!("List Cons node for limb {limb} not recorded") - })? - .output[0]; - } - Ok(tail_ptr) -} - -/// Walk a `List` chain from `head_ptr` in `memory[10]`, returning the -/// u64 limbs in head-first order. Each memory[10] entry is the standard Aiur -/// tagged-enum layout: `[tag, byte0..byte7, next_ptr]`. `tag == 0` = Nil -/// (terminator), `tag == 1` = Cons. Bytes are LE within the u64. -fn read_klimbs_u64( - memory: &FxIndexMap, - pointer_base: usize, - head_ptr: G, -) -> Result, String> { - let queries = memory.get(&10).ok_or_else(|| { - "memory[10] channel not registered (no List in program?)".to_string() - })?; - let mut limbs: Vec = Vec::new(); - let mut ptr = head_ptr; - loop { - let ptr_u64 = ptr.as_canonical_u64(); - let ptr_idx = usize::try_from(ptr_u64) - .map_err(|_e| format!("ptr {ptr_u64} too large for usize"))? - .checked_sub(pointer_base) - .ok_or_else(|| { - format!("ptr {ptr_u64} below the record's pointer base") - })?; - let (key, _) = queries.get_index(ptr_idx).ok_or_else(|| { - format!("unbound ptr {ptr_u64} in memory[10] (walking List)") - })?; - let tag = key[0].as_canonical_u64(); - // `enum ListNode { Cons, Nil }` in Ix/Aiur/Library/Core.lean — Cons is the - // first variant (tag 0), Nil the second (tag 1). - if tag == 1 { - return Ok(limbs); - } - if tag != 0 { - return Err(format!( - "List walk: unexpected tag {tag} (expected 0=Cons, 1=Nil)" - )); - } - let mut limb_bytes = [0u8; 8]; - for k in 0..8 { - let b = key[1 + k].as_canonical_u64(); - if b >= 256 { - return Err(format!("limb byte {b} out of u8 range")); - } - limb_bytes[k] = u8::try_from(b).expect("range-checked above"); - } - limbs.push(u64::from_le_bytes(limb_bytes)); - ptr = key[9]; - } -} - -/// Treat `limbs` as a little-endian sequence of 64-bit limbs and convert to -/// a `BigUint`. Aiur's `klimbs_normalize` strips trailing zero limbs but a -/// non-normalized input still produces the correct value via `from_bytes_le`. -fn klimbs_u64_to_biguint(limbs: &[u64]) -> num_bigint::BigUint { - let mut bytes: Vec = Vec::with_capacity(limbs.len() * 8); - for limb in limbs { - bytes.extend_from_slice(&limb.to_le_bytes()); - } - num_bigint::BigUint::from_bytes_le(&bytes) -} - -/// Convert a `BigUint` to LE-u64 limbs. The output is non-padded (trailing -/// limbs that would all be zero are omitted), matching `klimbs_normalize`'s -/// canonical form so the Aiur kernel's subsequent equality checks compare -/// equal forms without round-trip discrepancies. -fn biguint_to_klimbs_u64(n: &num_bigint::BigUint) -> Vec { - if n == &num_bigint::BigUint::ZERO { - return Vec::new(); - } - let mut bytes = n.to_bytes_le(); - while !bytes.len().is_multiple_of(8) { - bytes.push(0); - } - bytes.as_chunks::<8>().0.iter().map(|c| u64::from_le_bytes(*c)).collect() -} - -/// Build a `List` chain in `memory[10]` from `limbs` (head-first order) -/// and return the head pointer. Each entry is inserted with multiplicity 0 -/// (unconstrained); subsequent constrained `Load`s by the kernel will bump -/// the multiplicity. Content-addressed via `QueryMap::get_mut`, so repeated -/// identical sub-tails share storage. -fn build_klimbs_u64( - memory: &mut FxIndexMap, - pointer_base: usize, - limbs: &[u64], -) -> Result { - let queries = memory.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; - // Find or insert the Nil ptr (tag = 1, padded payload all zero). - let nil_key: Vec = - std::iter::once(G::ONE).chain((0..9).map(|_| G::ZERO)).collect(); - let mut tail_ptr = if let Some(out) = queries.get_mut(&nil_key) { - out.output[0] - } else { - if queries.len() >= POINTER_LIMIT { - return Err(ExecError::MemoryTableFull(10)); - } - let ptr = G::from_usize(pointer_base + queries.len()); - queries.insert(&nil_key, &[ptr], G::ZERO)?; - ptr - }; - // Walk limbs in REVERSE so each Cons points at the previously-built tail. - for limb in limbs.iter().rev() { - let bytes = limb.to_le_bytes(); - let mut key: Vec = Vec::with_capacity(10); - key.push(G::ZERO); // Cons tag (first variant of ListNode‹U64›) - for b in &bytes { - key.push(G::from_u8(*b)); - } - key.push(tail_ptr); - tail_ptr = if let Some(out) = queries.get_mut(&key) { - out.output[0] - } else { - if queries.len() >= POINTER_LIMIT { - return Err(ExecError::MemoryTableFull(10)); - } - let ptr = G::from_usize(pointer_base + queries.len()); - queries.insert(&key, &[ptr], G::ZERO)?; - ptr - }; - } - Ok(tail_ptr) -} - -/// Approximate retained bytes of a record's query maps: field elements -/// (keys + outputs) at 8 bytes plus ~21 bytes of per-entry index -/// overhead (hash-table slot, stored hash, multiplicity). Feeds the -/// witness phase of the prover RAM model -/// ([`crate::synthesis::AiurSystem::peak_prove_bytes`]). -pub fn record_retained_bytes(record: &QueryRecord) -> usize { - let mut elems = 0usize; - let mut entries = 0usize; - for m in &record.function_queries { - elems += m.retained_elems(); - entries += m.len(); - } - for (_, m) in &record.memory_queries { - elems += m.retained_elems(); - entries += m.len(); - } - elems * 8 + entries * 21 -} - -#[cfg(test)] -mod record_pool_tests { - use super::*; - use crate::{bytecode::FunctionLayout, record_pool::RecordPool}; - - #[test] - fn return_chain_reserves_before_insertion_and_returns_an_error() { - let toplevel = Toplevel { - functions: (0..80) - .map(|i| Function { - body: Block { - ops: if i < 79 { - vec![Op::Call(i + 1, Vec::new(), 0, false)] - } else { - Vec::new() - }, - ctrl: Ctrl::Return(0, Vec::new()), - }, - layout: FunctionLayout { - input_size: 0, - selectors: 1, - auxiliaries: 1, - lookups: 2, - }, - entry: i == 0, - constrained: true, - }) - .collect(), - memory_sizes: Vec::new(), - circuits: Vec::new(), - }; - let pool = RecordPool::new(1000, 100); - let reservation = pool.try_admit().unwrap().unwrap(); - let binding = bind_record_reservation(&reservation); - let mut io = IOBuffer { data: Default::default(), map: Default::default() }; - let error = toplevel.execute(0, Vec::new(), &mut io).err().unwrap(); - assert_eq!( - error, - ExecError::RecordBudgetExceeded { bytes: 1008, cap: 1000 } - ); - assert!(pool.stats().peak_reserved <= 1000); - drop(binding); - drop(reservation); - assert_eq!(pool.stats().reserved, 0); - } - - #[test] - fn bigint_growth_is_charged_and_maps_keep_reservations_across_threads() { - let pool = RecordPool::new(300, 109); - let reservation = pool.try_admit().unwrap().unwrap(); - let binding = bind_record_reservation(&reservation); - let mut record = QueryRecord::new(&Toplevel { - functions: Vec::new(), - memory_sizes: vec![10], - circuits: Vec::new(), - }); - let result = build_klimbs_u64(&mut record.memory_queries, 0, &[1, 2, 3]); - assert_eq!( - result, - Err(ExecError::RecordBudgetExceeded { bytes: 327, cap: 300 }) - ); - assert_eq!(record.memory_queries[&10].len(), 2); - assert_eq!(record_retained_bytes(&record), 218); - reservation.finish_execution(); - let table = record.memory_queries.swap_remove(&10).unwrap(); - drop(record); - drop(binding); - drop(reservation); - assert_eq!(pool.stats().reserved, 218); - std::thread::spawn(move || drop(table)).join().unwrap(); - assert_eq!(pool.stats().reserved, 0); + Ok(()) } } diff --git a/crates/aiur/src/execute/dispatch.rs b/crates/aiur/src/execute/dispatch.rs new file mode 100644 index 000000000..84a0e45e1 --- /dev/null +++ b/crates/aiur/src/execute/dispatch.rs @@ -0,0 +1,114 @@ +//! Prepare the interpreter's next action once, including skipped instructions +//! and fixed host calls. Original PCs remain the keys for errors and trace replay. +use crate::{ + bytecode::{CheckedProgram, Instruction}, + field::FieldBackend, + hints::HintSite, + host::{MapCalls, RegisterHint, RegisterMap}, +}; +use std::sync::Arc; + +pub(crate) struct Dispatch { + pub(crate) pc: usize, + pub(crate) next: usize, + pub(crate) instructions: u64, + pub(crate) action: Action, +} + +pub(crate) enum Action { + Bytecode { memory_type: usize, branch: usize }, + Return { plan: usize }, + Map { function: usize, call: Arc> }, + Hint { call: Arc> }, +} + +pub(crate) fn prepare( + program: &CheckedProgram, + hints: &[Vec>>], + maps: Option<&[MapCalls]>, +) -> Vec>> { + program + .steps + .iter() + .enumerate() + .map(|(function, steps)| { + // Different entries into a skipped prefix can have different + // instruction counts. Keep each reachable entry, not just each + // eventual operation, and resolve its successors to dense indices. + let code = &program.execution_functions[function].code; + let returns = &program.returns[function]; + let mut reachable = vec![false; steps.len()]; + let mut pending = vec![0]; + while let Some(pc) = pending.pop() { + if std::mem::replace(&mut reachable[pc], true) { + continue; + } + let step = &steps[pc]; + if returns[step.pc].is_some() { + continue; + } + match &code[step.pc] { + Instruction::Ret { .. } | Instruction::Fail { .. } => (), + Instruction::Jump { target } => pending.push(*target), + Instruction::Branch { tests, otherwise } => { + if !tests.is_empty() { + pending.push(*otherwise); + } + pending.push(step.pc + 1); + }, + _ => pending.push(step.pc + 1), + } + } + let pcs: Vec<_> = reachable + .iter() + .enumerate() + .filter_map(|(pc, &reachable)| reachable.then_some(pc)) + .collect(); + let mut entries = vec![usize::MAX; steps.len()]; + for (index, &pc) in pcs.iter().enumerate() { + entries[pc] = index; + } + pcs + .iter() + .map(|&pc| { + let step = &steps[pc]; + if let Some(ret) = &returns[step.pc] { + return Dispatch { + pc: ret.pc, + next: usize::MAX, + instructions: step.skipped + ret.instructions, + action: Action::Return { plan: step.pc }, + }; + } + let action = + match &program.execution_functions[function].code[step.pc] { + Instruction::Call { function: callee, .. } => { + maps.and_then(|maps| maps[function][step.pc].as_ref()).map( + |call| Action::Map { function: *callee, call: call.clone() }, + ) + }, + Instruction::Hint { .. } => hints[function][step.pc] + .as_ref() + .and_then(|site| site.registers.as_ref()) + .map(|call| Action::Hint { call: call.clone() }), + _ => None, + } + .unwrap_or(Action::Bytecode { + memory_type: step.memory_type, + branch: match &code[step.pc] { + Instruction::Branch { otherwise, .. } => entries[*otherwise], + Instruction::Jump { target } => entries[*target], + _ => usize::MAX, + }, + }); + Dispatch { + pc: step.pc, + next: entries.get(step.pc + 1).copied().unwrap_or(usize::MAX), + instructions: step.skipped + 1, + action, + } + }) + .collect() + }) + .collect() +} diff --git a/crates/aiur/src/ffi.rs b/crates/aiur/src/ffi.rs new file mode 100644 index 000000000..0c9784546 --- /dev/null +++ b/crates/aiur/src/ffi.rs @@ -0,0 +1,226 @@ +//! A small C ABI transports execution bytecode and optional companion trace plans. +//! Lean's object ABI is confined to c/execution.c; Rust owns execution and tracing. +use crate::bytecode::Program; +use crate::field::{FieldBackend, NativeField, PrimeField, PrimeField64}; +use crate::hints::HintEntry; +use serde::Deserialize; +use serde_json::{Value as Json, json}; +use std::ffi::{CString, c_char}; + +#[derive(Deserialize)] +struct Request { + program: Program, + entry: String, + args: Option>, + flat_args: Option>, + #[serde(default)] + hints: Vec, + /// Optional companion circuit metadata. Ordinary execution remains unchanged. + trace: Option, + #[serde(default)] + pad_trace: bool, + #[serde(default)] + compare_reference: bool, +} +fn execute_request(bytes: &[u8]) -> Result { + let request: Request = serde_json::from_slice(bytes) + .map_err(|e| format!("invalid execution request: {e}"))?; + // This embedding chooses multi-stark's reference field once, before + // preparation. Other runtime primes retain the generic integer fallback. + if request.program.modulus == multi_stark::types::Val::ORDER_U64 { + run_request(request, NativeField::::new()) + } else { + let field = PrimeField::new(request.program.modulus)?; + run_request(request, field) + } +} + +fn run_request( + request: Request, + field: B, +) -> Result { + let program = request.program.check_with(field)?; + let record = match (request.args, request.flat_args) { + (Some(args), None) => { + let entry = program.entry(&request.entry)?; + if args.len() != entry.inputs.len() { + return Err("entry argument count mismatch".into()); + } + let values = entry + .inputs + .iter() + .zip(&args) + .map(|(t, v)| t.read_json(v)) + .collect::, _>>()?; + program.execute_values_with_hints(&request.entry, &values, &request.hints) + }, + (None, Some(args)) => { + let args = field.decode(&args)?; + program.execute_with_hints(&request.entry, args, &request.hints) + }, + _ => return Err("supply exactly one of args and flat_args".into()), + } + .map_err(|e| e.to_string())?; + let entry = program.entry(&request.entry)?; + let trace = if let Some(artifact) = request.trace { + let plan = crate::trace::TracePlan::new(&program, artifact)?; + // Recover the flat root input from the execution record. Public callers + // needing to reuse one record should use TracePlan directly. + let root = record + .queries + .iter() + .find(|(input, _)| input.function == entry.function) + .ok_or("missing root query")? + .0; + let trace = + plan.generate(&record, &request.entry, root.args, request.pad_trace)?; + if request.compare_reference + && trace + != plan.generate_reference( + &record, + &request.entry, + root.args, + request.pad_trace, + )? + { + return Err("compiled population differs from reference writer".into()); + } + plan.check(&record, &trace, &request.entry, root.args)?; + Some(trace) + } else { + None + }; + let pretty_output = if entry.output.is_some() { + Some(program.output_value(&request.entry, &record)?.to_string()) + } else { + None + }; + let mut queries = record.queries.iter().collect::>(); + queries.sort_by(|(a, _), (b, _)| { + a.function.cmp(&b.function).then_with(|| { + a.args + .iter() + .map(|&x| field.to_u64(x)) + .cmp(b.args.iter().map(|&x| field.to_u64(x))) + }) + }); + let queries = queries + .into_iter() + .map(|(input, output)| { + json!({ + "function": input.function, "name": program.callable_name(input.function), + "args": input.args, "output": output.output, "multiplicity": output.multiplicity, + }) + }) + .collect::>(); + Ok( + json!({ "output": record.output, "pretty_output": pretty_output, "queries": queries, + "memory": record.memory, "memory_types": program.memory_types.iter() + .map(|(ty, layout)| (ty, layout.width())).collect::>(), + "instructions": record.instructions, "trace": trace }), + ) +} + +/// # Safety +/// `data` must address `length` readable bytes for the duration of this call. +/// The returned allocation must be released exactly once with `aiur_free_string`. +#[unsafe(no_mangle)] +pub unsafe extern "C" fn aiur_execute_json( + data: *const u8, + length: usize, +) -> *mut c_char { + let response = std::panic::catch_unwind(|| { + if data.is_null() { + return Err("null execution request".into()); + } + // SAFETY: the caller guarantees the buffer's validity; it is only borrowed. + execute_request(unsafe { std::slice::from_raw_parts(data, length) }) + }); + let value = match response { + Ok(Ok(value)) => json!({"ok": value}), + Ok(Err(error)) => json!({"error": error}), + Err(panic) => { + let message = panic + .downcast_ref::() + .map(String::as_str) + .or_else(|| panic.downcast_ref::<&str>().copied()) + .unwrap_or("Rust execution panic"); + json!({"error": message}) + }, + }; + // JSON escapes all embedded NULs. No unwind may cross the C boundary. + CString::new(value.to_string()) + .expect("JSON cannot contain a NUL byte") + .into_raw() +} + +/// # Safety +/// `string` must be null or a live pointer returned by `aiur_execute_json`. +#[unsafe(no_mangle)] +pub unsafe extern "C" fn aiur_free_string(string: *mut c_char) { + if !string.is_null() { + // SAFETY: ownership of precisely this CString allocation is returned. + drop(unsafe { CString::from_raw(string) }); + } +} + +#[cfg(test)] +mod tests { + use super::*; + use std::ffi::CStr; + + fn call(request: &Json) -> Json { + let bytes = request.to_string().into_bytes(); + // SAFETY: the input buffer outlives the call. The returned string is + // read before it is released once with the matching allocator. + unsafe { + let response = aiur_execute_json(bytes.as_ptr(), bytes.len()); + let json = + serde_json::from_slice(CStr::from_ptr(response).to_bytes()).unwrap(); + aiur_free_string(response); + json + } + } + + #[test] + fn missing_hint_is_an_error_at_the_ffi_boundary() { + let field = json!({"kind":"field"}); + let response = call(&json!({ + "program": { + "version":1, "modulus":97, "enums":[], "maps":[], "tables":[], + "functions":[{"name":"hinted", "params":[field], "result":field, "registers":2, + "code":[{"op":"hint", "type":field, "key_type":field, "key":[0], "dest":[1]}, + {"op":"ret", "value":[1]}]}], + "entries":[{"name":"main", "function":0, "inputs":[field], "output":field}] + }, + "entry":"main", "args":[7] + })); + assert!(response["error"].as_str().unwrap().contains("missing hint")); + } + + #[test] + fn malformed_request_returns_owned_error_text() { + let response = call(&json!({"entry":"missing"})); + assert!( + response["error"].as_str().unwrap().contains("invalid execution request") + ); + } + + #[test] + fn native_ffi_preserves_integer_encoding_and_rejects_noncanonical_inputs() { + let p = multi_stark::types::Val::ORDER_U64; + let f = json!({"kind":"field"}); + let mut request = json!({ + "program": { + "version":2, "modulus":p, "enums":[], "maps":[], "tables":[], + "functions":[{"name":"identity", "params":[f], "result":f, "registers":1, + "code":[{"op":"ret", "value":[0]}]}], + "entries":[{"name":"main", "function":0, "inputs":[f], "output":f}] + }, + "entry":"main", "flat_args":[p-1] + }); + assert_eq!(call(&request)["ok"]["output"], json!([p - 1])); + request["flat_args"] = json!([p]); + assert!(call(&request)["error"].as_str().unwrap().contains("noncanonical")); + } +} diff --git a/crates/aiur/src/field.rs b/crates/aiur/src/field.rs new file mode 100644 index 000000000..290f5c250 --- /dev/null +++ b/crates/aiur/src/field.rs @@ -0,0 +1,306 @@ +//! Field backends for execution and witness population. Native backends retain +//! field elements in registers, records and callbacks. Canonical integers are +//! used only at interchange boundaries and when an operation needs an index. +use serde::Serialize; +use std::{ + fmt::{Debug, Display}, + hash::Hash, + marker::PhantomData, +}; + +// Use the same field contract as our maintained proving library. No concrete +// field is selected by the interpreter, and no direct Plonky3 dependency is +// needed here. +pub use multi_stark::p3_field::{Field, PrimeCharacteristicRing, PrimeField64}; + +/// Arithmetic and integer-boundary conversions. The associated element is the +/// actual value stored by the VM, not an encoding chosen by the VM. This small +/// adapter also lets the Lean FFI retain its runtime-selected prime backend. +/// Implementations must preserve arithmetic modulo `modulus()`, use field-value +/// equality/hash, and make `from_u64` reduce integers while `to_u64` returns the +/// canonical representative. `decode` rejects noncanonical wire integers before +/// conversion. All valid native representations may be accepted by `valid`. +pub trait FieldBackend: Copy + Debug + Send + Sync + 'static { + type Element: Copy + + Eq + + Hash + + Debug + + Display + + Serialize + + Send + + Sync + + 'static; + /// Every value of Element passes `valid`. This permits omitting redundant + /// host-output checks for native field types, but never enum/tag checks. + const ALL_ELEMENTS_VALID: bool = false; + fn modulus(self) -> u64; + #[allow( + clippy::wrong_self_convention, + reason = "conversion needs the selected runtime backend" + )] + fn from_u64(self, value: u64) -> Self::Element; + fn to_u64(self, value: Self::Element) -> u64; + fn add(self, a: Self::Element, b: Self::Element) -> Self::Element; + fn sub(self, a: Self::Element, b: Self::Element) -> Self::Element; + fn neg(self, a: Self::Element) -> Self::Element; + fn mul(self, a: Self::Element, b: Self::Element) -> Self::Element; + fn inverse(self, a: Self::Element) -> Option; + fn valid(self, _value: Self::Element) -> bool { + true + } + fn zero(self) -> Self::Element { + self.from_u64(0) + } + fn one(self) -> Self::Element { + self.from_u64(1) + } + fn contains(self, word: u64) -> bool { + word < self.modulus() + } + fn decode(self, words: &[u64]) -> Result, String> { + words + .iter() + .map(|&word| { + if self.contains(word) { + Ok(self.from_u64(word)) + } else { + Err("noncanonical field element".into()) + } + }) + .collect() + } +} + +/// Zero-sized, statically dispatched adapter for any field implementing +/// multi-stark's prime-field traits. Its values are F itself, including in host +/// hint/table closures. The wire format currently supports 64-bit prime fields. +#[derive(Clone, Copy, Debug, Default)] +pub struct NativeField(PhantomData); +impl NativeField { + pub const fn new() -> Self { + Self(PhantomData) + } +} +impl FieldBackend for NativeField { + type Element = F; + const ALL_ELEMENTS_VALID: bool = true; + #[inline] + fn modulus(self) -> u64 { + F::ORDER_U64 + } + #[inline] + fn from_u64(self, value: u64) -> F { + F::from_u64(value) + } + #[inline] + fn to_u64(self, value: F) -> u64 { + value.as_canonical_u64() + } + #[inline] + fn add(self, a: F, b: F) -> F { + a + b + } + #[inline] + fn sub(self, a: F, b: F) -> F { + a - b + } + #[inline] + fn neg(self, a: F) -> F { + -a + } + #[inline] + fn mul(self, a: F, b: F) -> F { + a * b + } + #[inline] + fn inverse(self, a: F) -> Option { + a.try_inverse() + } +} + +#[derive(Clone, Copy, Debug)] +pub struct PrimeField { + modulus: u64, +} + +impl PrimeField { + pub fn new(modulus: u64) -> Result { + if !is_prime(modulus) { + return Err(format!("field modulus {modulus} is not prime")); + } + Ok(Self { modulus }) + } + + pub fn modulus(self) -> u64 { + self.modulus + } + pub fn contains(self, value: u64) -> bool { + value < self.modulus + } + #[inline] + pub fn add(self, a: u64, b: u64) -> u64 { + ((u128::from(a) + u128::from(b)) % u128::from(self.modulus)) as u64 + } + pub fn sub(self, a: u64, b: u64) -> u64 { + if a >= b { a - b } else { self.modulus - (b - a) } + } + pub fn neg(self, a: u64) -> u64 { + if a == 0 { 0 } else { self.modulus - a } + } + #[inline] + pub fn mul(self, a: u64, b: u64) -> u64 { + ((u128::from(a) * u128::from(b)) % u128::from(self.modulus)) as u64 + } + pub fn inverse(self, a: u64) -> Option { + (a != 0).then(|| self.pow(a, self.modulus - 2)) + } + fn pow(self, mut base: u64, mut power: u64) -> u64 { + let mut result = 1; + while power != 0 { + if power & 1 != 0 { + result = self.mul(result, base); + } + base = self.mul(base, base); + power >>= 1; + } + result + } +} + +impl FieldBackend for PrimeField { + type Element = u64; + fn modulus(self) -> u64 { + self.modulus + } + fn from_u64(self, value: u64) -> u64 { + value % self.modulus + } + fn to_u64(self, value: u64) -> u64 { + value + } + fn add(self, a: u64, b: u64) -> u64 { + self.add(a, b) + } + fn sub(self, a: u64, b: u64) -> u64 { + self.sub(a, b) + } + fn neg(self, a: u64) -> u64 { + self.neg(a) + } + fn mul(self, a: u64, b: u64) -> u64 { + self.mul(a, b) + } + fn inverse(self, a: u64) -> Option { + self.inverse(a) + } + fn valid(self, value: u64) -> bool { + self.contains(value) + } +} + +fn is_prime(n: u64) -> bool { + for p in [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37] { + if n == p { + return true; + } + if n < 2 || n.is_multiple_of(p) { + return false; + } + } + // These Miller–Rabin bases cover the entire u64 range. + let field = PrimeField { modulus: n }; + let shifts = (n - 1).trailing_zeros(); + let odd = (n - 1) >> shifts; + for base in [2, 325, 9_375, 28_178, 450_775, 9_780_504, 1_795_265_022] { + let base = base % n; + if base == 0 { + continue; + } + let mut x = field.pow(base, odd); + if x == 1 || x == n - 1 { + continue; + } + let mut passed = false; + for _ in 1..shifts { + x = field.mul(x, x); + if x == n - 1 { + passed = true; + break; + } + } + if !passed { + return false; + } + } + true +} + +#[cfg(test)] +mod tests { + use super::*; + const GOLDILOCKS: u64 = 0xffff_ffff_0000_0001; + #[test] + fn specialized_arithmetic_matches_integer_reduction() { + for p in [2, 97, 65_537, GOLDILOCKS, 18_446_744_073_709_551_557] { + let field = PrimeField::new(p).unwrap(); + let mut state = 0x1234_5678_9abc_def0u64; + let edges = [0, 1, 2, p / 2, p - 2, p - 1]; + let check = |a: u64, b: u64| { + let (a, b) = (a % p, b % p); + let modulus = u128::from(p); + assert_eq!( + field.add(a, b), + ((u128::from(a) + u128::from(b)) % modulus) as u64 + ); + assert_eq!( + field.sub(a, b), + ((u128::from(a) + modulus - u128::from(b)) % modulus) as u64 + ); + assert_eq!( + field.mul(a, b), + ((u128::from(a) * u128::from(b)) % modulus) as u64 + ); + if let Some(inverse) = field.inverse(a) { + assert!(inverse < p); + assert_eq!((u128::from(a) * u128::from(inverse)) % modulus, 1); + } else { + assert_eq!(a, 0); + } + }; + for a in edges { + for b in edges { + check(a, b); + } + } + for _ in 0..4096 { + state ^= state << 13; + state ^= state >> 7; + state ^= state << 17; + let a = state; + state = state.wrapping_mul(0xd134_2543_de82_ef95).wrapping_add(1); + check(a, state); + } + } + } + #[test] + fn arithmetic_at_word_boundary() { + let p = 18_446_744_069_414_584_321; + let f = PrimeField::new(p).unwrap(); + assert_eq!(f.add(p - 1, p - 1), p - 2); + assert_eq!(f.mul(p - 1, p - 1), 1); + assert_eq!(f.sub(0, p - 1), 1); + assert_eq!(f.inverse(0), None); + for a in [1, 2, 7, p - 2, p - 1] { + assert_eq!(f.mul(a, f.inverse(a).unwrap()), 1); + } + } + #[test] + fn rejects_composites_including_pseudoprimes() { + for n in [0, 1, 4, 561, 3_215_031_751, 341_550_071_728_321, u64::MAX] { + assert!(PrimeField::new(n).is_err(), "{n}"); + } + for n in [2, 3, 7, 97, 65_537, 18_446_744_073_709_551_557] { + assert!(PrimeField::new(n).is_ok(), "{n}"); + } + } +} diff --git a/crates/aiur/src/function_profile.rs b/crates/aiur/src/function_profile.rs new file mode 100644 index 000000000..711dded97 --- /dev/null +++ b/crates/aiur/src/function_profile.rs @@ -0,0 +1,89 @@ +//! Optional bytecode-function timing, independent of the host call stack. +//! +//! Arguments are marshalled by the caller. Callee time includes the memo +//! lookup, frame setup, body, query insertion and copying results back. Native +//! operations, static maps and hints stay in their enclosing function's time. +//! Profiler bookkeeping is outside timed spans; clock calls and perturbations +//! to caches/code layout still affect measurements. Compare an uninstrumented +//! build before interpreting small differences. Inclusive totals double-count +//! nested calls (including recursion); self totals do not. +use std::time::Instant; + +#[derive(Clone, Debug, Default)] +pub struct FunctionTiming { + pub calls: u64, + pub cache_hits: u64, + pub self_ns: u64, + pub inclusive_ns: u64, + pub cached_ns: u64, +} + +struct Active { + function: usize, + self_ns: u64, + children_ns: u64, +} + +pub struct FunctionProfiler { + pub functions: Vec, + /// Count actual interpreter dispatches in a separate diagnostic build. + /// These counters perturb execution; do not use that build for timings. + #[cfg(feature = "function-profile-ops")] + pub operations: Vec>, + stack: Vec, + resumed: Option, +} + +impl FunctionProfiler { + pub fn new(functions: usize) -> Self { + Self { + functions: vec![FunctionTiming::default(); functions], + #[cfg(feature = "function-profile-ops")] + operations: vec![std::collections::BTreeMap::new(); functions], + stack: Vec::new(), + resumed: None, + } + } + + fn pause(&mut self, now: Instant) { + if let Some(resumed) = self.resumed.take() { + self.stack.last_mut().unwrap().self_ns += + now.duration_since(resumed).as_nanos() as u64; + } + } + + pub(crate) fn enter(&mut self, function: usize) { + self.pause(Instant::now()); + self.functions[function].calls += 1; + self.stack.push(Active { function, self_ns: 0, children_ns: 0 }); + self.resumed = Some(Instant::now()); + } + + pub(crate) fn exit(&mut self, cache_hit: bool) { + self.pause(Instant::now()); + let frame = self.stack.pop().unwrap(); + let inclusive = frame.self_ns + frame.children_ns; + let timing = &mut self.functions[frame.function]; + timing.self_ns += frame.self_ns; + timing.inclusive_ns += inclusive; + if cache_hit { + timing.cache_hits += 1; + timing.cached_ns += frame.self_ns; + } + if let Some(parent) = self.stack.last_mut() { + parent.children_ns += inclusive; + self.resumed = Some(Instant::now()); + } + } + + #[cfg(feature = "function-profile-ops")] + pub(crate) fn operation(&mut self, name: &'static str) { + let function = self.stack.last().unwrap().function; + *self.operations[function].entry(name).or_default() += 1; + } + + /// Whether all entered calls returned. Discard timings if execution failed. + pub fn is_complete(&self) -> bool { + self.stack.is_empty() + } +} diff --git a/crates/aiur/src/gadgets.rs b/crates/aiur/src/gadgets.rs deleted file mode 100644 index 8e556f7e9..000000000 --- a/crates/aiur/src/gadgets.rs +++ /dev/null @@ -1,56 +0,0 @@ -pub(crate) mod bytes1; -pub(crate) mod bytes2; - -use multi_stark::{ - expr::Expr, - lookup::{Lookup, LookupValues}, - p3_matrix::dense::RowMajorMatrix, -}; - -use crate::{G, execute::QueryRecord}; - -/// A trait representing a generic Aiur gadget. -/// -/// Gadgets define small, reusable components for Aiur. Implementing this trait -/// requires a gadget to define: -/// -/// - How many outputs it produces for a given operation. -/// - How to execute its computation on concrete inputs. -/// - Which symbolic lookups it requires during circuit synthesis. -/// - How to provide witness data for the prover. -pub(crate) trait AiurGadget { - /// The type representing the gadget's operation. - type Op; - - /// Returns the number of output values this gadget produces for the given operation. - fn output_size(&self, op: &Self::Op) -> usize; - - /// Main-trace width of the gadget circuit. - fn main_width(&self) -> usize; - - /// The gadget's preprocessed trace, if any. - fn preprocessed(&self) -> Option>; - - /// Executes the gadget on concrete inputs, returning the resulting output values. - fn execute( - &self, - op: &Self::Op, - input: &[G], - record: &mut QueryRecord, - ) -> Vec; - - /// Returns the lookups associated with this gadget. - fn lookups(&self) -> Vec>>; - - /// Returns the witness data for the prover, including a row-major trace matrix and - /// the flat lookup values. - /// - /// `slot_arg_widths[j]` must be the maximum number of arguments of lookup slot `j`, - /// derived from the symbolic lookups returned by the `lookups` method so the witness - /// layout always matches the AIR. - fn witness_data( - &self, - record: &QueryRecord, - slot_arg_widths: &[usize], - ) -> (RowMajorMatrix, LookupValues); -} diff --git a/crates/aiur/src/gadgets/blake3.rs b/crates/aiur/src/gadgets/blake3.rs deleted file mode 100644 index 9fd508f9e..000000000 --- a/crates/aiur/src/gadgets/blake3.rs +++ /dev/null @@ -1,181 +0,0 @@ -//! THIS MODULE IS CURRENTLY NOT BEING USED -//! -//! It contains a Rust implementation of the "G function" used in blake3, using -//! Aiur API. -//! -//! This code can be useful in the future in case we want to use it to speed up -//! execution (instead of interpreting Aiur code). - -use multi_stark::{ - builder::symbolic::SymbolicExpression, - lookup::Lookup, - p3_air::{Air, AirBuilder, BaseAir}, - p3_field::PrimeCharacteristicRing, - p3_matrix::dense::RowMajorMatrix, -}; - -use crate::{ - G, - execute::QueryRecord, - gadgets::{ - AiurGadget, - bytes1::{Bytes1, Bytes1Op}, - bytes2::{Bytes2, Bytes2Op}, - }, -}; - -const TRACE_WIDTH: usize = 0; // TODO - -pub(crate) struct Blake3; - -impl BaseAir for Blake3 { - fn width(&self) -> usize { - TRACE_WIDTH - } -} - -impl> Air for Blake3 { - /// A no-op, since all constraints are enforced through lookups. - fn eval(&self, _builder: &mut AB) {} -} - -pub(crate) enum Blake3Op { - GFunction, -} - -impl AiurGadget for Blake3 { - type Op = Blake3Op; - - fn output_size(&self, op: &Self::Op) -> usize { - match op { - Blake3Op::GFunction => 16, // four 4-byte words - } - } - - fn execute(&self, op: &Self::Op, input: &[G], record: &mut QueryRecord) -> Vec { - match op { - Blake3Op::GFunction => { - if let Some(result) = record.blake3_g_function.get_mut(input) { - result.multiplicity += G::ONE; - return result.output.to_vec(); - } - - let u8_bits = |x, record: &mut QueryRecord| -> [G; 8] { - Bytes1 - .execute(&Bytes1Op::BitDecomposition, &[x], record) - .try_into() - .expect("Wrong output size") - }; - let u8_add = |a, b, record: &mut QueryRecord| -> [G; 2] { - Bytes2 - .execute(&Bytes2Op::Add, &[a, b], record) - .try_into() - .expect("Wrong output size") - }; - let u8_xor = |a, b, record: &mut QueryRecord| { - Bytes2 - .execute(&Bytes2Op::Xor, &[a, b], record) - .pop() - .expect("Missing output") - }; - let u32_add = |a: [G; 4], b: [G; 4], record: &mut QueryRecord| { - let [a0, a1, a2, a3] = a; - let [b0, b1, b2, b3] = b; - - // Byte 0 addition (no initial carry) - let [sum0, carry1] = u8_add(a0, b0, record); - - // Byte 1 addition - let [sum1, overflow1] = u8_add(a1, b1, record); - let [sum1_with_carry, carry1a] = u8_add(sum1, carry1, record); - let carry2 = u8_xor(overflow1, carry1a, record); - - // Byte 2 addition - let [sum2, overflow2] = u8_add(a2, b2, record); - let [sum2_with_carry, carry2a] = u8_add(sum2, carry2, record); - let carry3 = u8_xor(overflow2, carry2a, record); - - // Byte 3 addition - let [sum3, _] = u8_add(a3, b3, record); - let [sum3_with_carry, _] = u8_add(sum3, carry3, record); - - [sum0, sum1_with_carry, sum2_with_carry, sum3_with_carry] - }; - let u32_xor = |a: [G; 4], b: [G; 4], record: &mut QueryRecord| { - let [a0, a1, a2, a3] = a; - let [b0, b1, b2, b3] = b; - let c0 = u8_xor(a0, b0, record); - let c1 = u8_xor(a1, b1, record); - let c2 = u8_xor(a2, b2, record); - let c3 = u8_xor(a3, b3, record); - [c0, c1, c2, c3] - }; - let u8_recompose = |bits: [G; 8]| { - let [b0, b1, b2, b3, b4, b5, b6, b7] = bits; - b0 + G::TWO * b1 - + G::from_u8(4) * b2 - + G::from_u8(8) * b3 - + G::from_u8(16) * b4 - + G::from_u8(32) * b5 - + G::from_u8(64) * b6 - + G::from_u8(128) * b7 - }; - - let extract_u32 = |idx: usize| [idx, idx + 1, idx + 2, idx + 3].map(|i| input[i]); - let a = extract_u32(0); - let b = extract_u32(4); - let c = extract_u32(8); - let d = extract_u32(12); - let x = extract_u32(16); - let y = extract_u32(20); - - let a = u32_add(u32_add(a, b, record), x, record); - let [d0, d1, d2, d3] = u32_xor(d, a, record); - let d = [d2, d3, d0, d1]; // Right-rotated 16 - - let c = u32_add(c, d, record); - let [b0, b1, b2, b3] = u32_xor(b, c, record); - let [b00, b01, b02, b03, b04, b05, b06, b07] = u8_bits(b0, record); - let [b10, b11, b12, b13, b14, b15, b16, b17] = u8_bits(b1, record); - let [b20, b21, b22, b23, b24, b25, b26, b27] = u8_bits(b2, record); - let [b30, b31, b32, b33, b34, b35, b36, b37] = u8_bits(b3, record); - let b0 = u8_recompose([b14, b15, b16, b17, b20, b21, b22, b23]); - let b1 = u8_recompose([b24, b25, b26, b27, b30, b31, b32, b33]); - let b2 = u8_recompose([b34, b35, b36, b37, b00, b01, b02, b03]); - let b3 = u8_recompose([b04, b05, b06, b07, b10, b11, b12, b13]); - let b = [b0, b1, b2, b3]; // Right-rotated 12 - - let a = u32_add(u32_add(a, b, record), y, record); - let [d0, d1, d2, d3] = u32_xor(d, a, record); - let d = [d1, d2, d3, d0]; // Right-rotated 8 - - let c = u32_add(c, d, record); - let [b0, b1, b2, b3] = u32_xor(b, c, record); - let [b00, b01, b02, b03, b04, b05, b06, b07] = u8_bits(b0, record); - let [b10, b11, b12, b13, b14, b15, b16, b17] = u8_bits(b1, record); - let [b20, b21, b22, b23, b24, b25, b26, b27] = u8_bits(b2, record); - let [b30, b31, b32, b33, b34, b35, b36, b37] = u8_bits(b3, record); - let b0 = u8_recompose([b07, b10, b11, b12, b13, b14, b15, b16]); - let b1 = u8_recompose([b17, b20, b21, b22, b23, b24, b25, b26]); - let b2 = u8_recompose([b27, b30, b31, b32, b33, b34, b35, b36]); - let b3 = u8_recompose([b37, b00, b01, b02, b03, b04, b05, b06]); - let b = [b0, b1, b2, b3]; // Right-rotated 7 - - let mut output = Vec::with_capacity(16); - output.extend(a); - output.extend(b); - output.extend(c); - output.extend(d); - output - } - } - } - - fn lookups(&self) -> Vec>> { - todo!() - } - - fn witness_data(&self, record: &QueryRecord) -> (RowMajorMatrix, Vec>>) { - todo!() - } -} diff --git a/crates/aiur/src/gadgets/bytes1.rs b/crates/aiur/src/gadgets/bytes1.rs deleted file mode 100644 index 79b907498..000000000 --- a/crates/aiur/src/gadgets/bytes1.rs +++ /dev/null @@ -1,264 +0,0 @@ -use multi_stark::{ - expr::Expr, - lookup::{Lookup, LookupValues}, - p3_field::{PrimeCharacteristicRing, PrimeField64}, - p3_matrix::dense::RowMajorMatrix, -}; - -use crate::{ - G, execute::QueryRecord, gadgets::AiurGadget, u8_bit_decomposition_channel, - u8_shift_left_channel, u8_shift_right_channel, -}; - -/// Number of columns in the trace with multiplicities for -/// - bit decomposition -/// - shift-left -/// - shift-right -const TRACE_WIDTH: usize = 3; - -/// Number of columns in the preprocessed trace: -/// - raw byte value -/// - 8 bits in LE -/// - value shifted left -/// - value shifted right -const PREPROCESSED_TRACE_WIDTH: usize = 11; - -/// AIR implementer for arity 1 byte-related lookups. -pub struct Bytes1; - -pub enum Bytes1Op { - BitDecomposition, - ShiftLeft, - ShiftRight, -} - -impl AiurGadget for Bytes1 { - type Op = Bytes1Op; - - fn output_size(&self, op: &Bytes1Op) -> usize { - match op { - Bytes1Op::BitDecomposition => 8, - Bytes1Op::ShiftLeft | Bytes1Op::ShiftRight => 1, - } - } - - fn main_width(&self) -> usize { - TRACE_WIDTH - } - - /// Builds the preprocessed trace over all 256 byte values. - fn preprocessed(&self) -> Option> { - let mut values = vec![G::ZERO; 256 * PREPROCESSED_TRACE_WIDTH]; - values - .as_chunks_mut::() - .0 - .iter_mut() - .enumerate() - .for_each(|(i, row)| { - let byte = G::from_usize(i); - - // Raw byte value - row[0] = byte; - - // 8 bits in LE - for (row_elt, bit) in - row[1..].iter_mut().zip(Self::bit_decompose(&byte)) - { - *row_elt = bit; - } - - // Byte shifted left - row[9] = Self::shift_left(&byte); - - // Byte shifted right - row[10] = Self::shift_right(&byte); - }); - Some(RowMajorMatrix::new(values, PREPROCESSED_TRACE_WIDTH)) - } - - fn execute( - &self, - op: &Bytes1Op, - input: &[G], - record: &mut QueryRecord, - ) -> Vec { - let byte = &input[0]; - match op { - Bytes1Op::BitDecomposition => { - record.bytes1_queries.bump_bit_decomposition(byte); - Self::bit_decompose(byte) - }, - Bytes1Op::ShiftLeft => { - record.bytes1_queries.bump_shift_left(byte); - vec![Self::shift_left(byte)] - }, - Bytes1Op::ShiftRight => { - record.bytes1_queries.bump_shift_right(byte); - vec![Self::shift_right(byte)] - }, - } - } - - fn lookups(&self) -> Vec>> { - // Channels - let bit_decomposition_channel = - Expr::constant(u8_bit_decomposition_channel()); - let shift_left_channel = Expr::constant(u8_shift_left_channel()); - let shift_right_channel = Expr::constant(u8_shift_right_channel()); - - // Multiplicity columns - let bit_decomposition_multiplicity = Expr::main(0); - let shift_left_multiplicity = Expr::main(1); - let shift_right_multiplicity = Expr::main(2); - - // Preprocessed columns - let byte = Expr::preprocessed(0); - let byte_bit0 = Expr::preprocessed(1); - let byte_bit1 = Expr::preprocessed(2); - let byte_bit2 = Expr::preprocessed(3); - let byte_bit3 = Expr::preprocessed(4); - let byte_bit4 = Expr::preprocessed(5); - let byte_bit5 = Expr::preprocessed(6); - let byte_bit6 = Expr::preprocessed(7); - let byte_bit7 = Expr::preprocessed(8); - let byte_left_shifted = Expr::preprocessed(9); - let byte_right_shifted = Expr::preprocessed(10); - - // pull = negated multiplicity. - let pull_bit_decomposition = Lookup { - multiplicity: -bit_decomposition_multiplicity, - args: vec![ - bit_decomposition_channel, - byte.clone(), - byte_bit0, - byte_bit1, - byte_bit2, - byte_bit3, - byte_bit4, - byte_bit5, - byte_bit6, - byte_bit7, - ], - }; - - let pull_shift_left = Lookup { - multiplicity: -shift_left_multiplicity, - args: vec![shift_left_channel, byte.clone(), byte_left_shifted], - }; - - let pull_shift_right = Lookup { - multiplicity: -shift_right_multiplicity, - args: vec![shift_right_channel, byte, byte_right_shifted], - }; - - vec![pull_bit_decomposition, pull_shift_left, pull_shift_right] - } - - fn witness_data( - &self, - record: &QueryRecord, - slot_arg_widths: &[usize], - ) -> (RowMajorMatrix, LookupValues) { - let mut rows = G::zero_vec(256 * TRACE_WIDTH); - for (row, multiplicities) in rows - .as_chunks_mut::() - .0 - .iter_mut() - .zip(&record.bytes1_queries.0) - { - *row = *multiplicities; - } - if crate::trace::trace_only_lookups() { - return ( - RowMajorMatrix::new(rows, TRACE_WIDTH), - LookupValues::shape_only(256, slot_arg_widths), - ); - } - - // There are `TRACE_WIDTH` lookups per row, one for each multiplicity. - let mut builder = LookupValues::builder(256, slot_arg_widths); - let mut row_writers = builder.rows_mut(); - - let bit_decomposition_channel = u8_bit_decomposition_channel(); - let shift_left_channel = u8_shift_left_channel(); - let shift_right_channel = u8_shift_right_channel(); - - // There are at most 256 rows so parallelism is not necessay. - rows - .as_chunks::() - .0 - .iter() - .enumerate() - .zip(row_writers.iter_mut()) - .for_each(|((byte, &[bd, shl, shr]), row_lookups)| { - let byte = G::from_usize(byte); - - // Pull bit decomposition. - let mut bit_decomposition_args = Vec::with_capacity(10); - bit_decomposition_args.extend([bit_decomposition_channel, byte]); - bit_decomposition_args.extend(Self::bit_decompose(&byte)); - row_lookups.pull(0, bd, &bit_decomposition_args); - - // Pull shift left. - row_lookups.pull( - 1, - shl, - &[shift_left_channel, byte, Self::shift_left(&byte)], - ); - - // Pull shift right. - row_lookups.pull( - 2, - shr, - &[shift_right_channel, byte, Self::shift_right(&byte)], - ); - }); - drop(row_writers); - (RowMajorMatrix::new(rows, TRACE_WIDTH), builder.finish()) - } -} - -/// Accumulator of queries performed against `Bytes1`. -pub struct Bytes1Queries([[G; TRACE_WIDTH]; 256]); - -impl Bytes1Queries { - #[inline] - pub(crate) fn new() -> Self { - Self([[G::ZERO; TRACE_WIDTH]; 256]) - } - - pub(crate) fn bump_bit_decomposition(&mut self, byte: &G) { - self.bump_multiplicity_for(byte, 0) - } - - pub(crate) fn bump_shift_left(&mut self, byte: &G) { - self.bump_multiplicity_for(byte, 1) - } - - pub(crate) fn bump_shift_right(&mut self, byte: &G) { - self.bump_multiplicity_for(byte, 2) - } - - pub(crate) fn bump_multiplicity_for(&mut self, byte: &G, col: usize) { - let row = usize::try_from(byte.as_canonical_u64()).unwrap(); - self.0[row][col] += G::ONE; - } -} - -impl Bytes1 { - #[inline] - pub fn bit_decompose(byte: &G) -> Vec { - let byte_u64 = byte.as_canonical_u64(); - (0..8).map(|i| G::from_bool((byte_u64 >> i) & 1 == 1)).collect() - } - - #[inline] - pub fn shift_left(byte: &G) -> G { - G::from_u64((byte.as_canonical_u64() << 1) & 255) - } - - #[inline] - pub fn shift_right(byte: &G) -> G { - G::from_u64(byte.as_canonical_u64() >> 1) - } -} diff --git a/crates/aiur/src/gadgets/bytes2.rs b/crates/aiur/src/gadgets/bytes2.rs deleted file mode 100644 index 1525e96e5..000000000 --- a/crates/aiur/src/gadgets/bytes2.rs +++ /dev/null @@ -1,482 +0,0 @@ -use multi_stark::{ - expr::Expr, - lookup::{Lookup, LookupValues}, - p3_field::{PrimeCharacteristicRing, PrimeField64}, - p3_matrix::dense::RowMajorMatrix, -}; - -use crate::{ - G, execute::QueryRecord, gadgets::AiurGadget, u8_add_channel, u8_mul_channel, - u8_range_check_channel, u8_sub_channel, u8_xor_channel, - u8_xor_split4_channel, u8_xor_split7_channel, u16_range_check_channel, -}; - -/// Number of columns in the trace with multiplicities for -/// - xor -/// - overflowing add -/// - overflowing sub -/// - range_check -/// - mul -/// - xor_split7 -/// - xor_split4 -/// - scalar u16 range_check -const TRACE_WIDTH: usize = 8; - -/// Number of columns in the preprocessed trace: -/// - first raw byte value -/// - second raw byte value -/// - xor result -/// - add result (low byte only; the carry is derived in-circuit as -/// `(x + y - z) / 256`, so it needs no column or lookup) -/// - sub result (low byte only; the borrow is derived in-circuit as -/// `(z + y - x) / 256`, so it needs no column or lookup) -/// - mul low byte -/// - mul high byte -/// - xor_split7 high and shifted-low outputs -/// - xor_split4 high and shifted-low outputs -const PREPROCESSED_TRACE_WIDTH: usize = 11; - -/// AIR implementer for arity 2 byte-related lookups. -/// -/// AND and OR reuse XOR through `a + b - 2*and` and `2*or - a - b`. -/// Comparison reuses subtraction through `a - b + 256*less_than`. -/// The caller keeps its original output column; these derived arguments -/// need neither additional witnesses nor separate table multiplicities. -pub struct Bytes2; - -pub enum Bytes2Op { - Xor, - Add, - Mul, - Sub, - And, - Or, - LessThan, - XorSplit7, - XorSplit4, -} - -impl AiurGadget for Bytes2 { - type Op = Bytes2Op; - - fn output_size(&self, op: &Bytes2Op) -> usize { - match op { - Bytes2Op::Xor - | Bytes2Op::And - | Bytes2Op::Or - | Bytes2Op::LessThan - | Bytes2Op::Add - | Bytes2Op::Sub => 1, - Bytes2Op::Mul | Bytes2Op::XorSplit7 | Bytes2Op::XorSplit4 => 2, - } - } - - fn main_width(&self) -> usize { - TRACE_WIDTH - } - - /// Builds the preprocessed trace over all 256 byte values. - fn preprocessed(&self) -> Option> { - let mut trace_values = - Vec::with_capacity(256 * 256 * PREPROCESSED_TRACE_WIDTH); - for i in 0..=u8::MAX { - for j in 0..=u8::MAX { - // Raw bytes - trace_values.push(G::from_u8(i)); - trace_values.push(G::from_u8(j)); - - // Xor - trace_values.push(G::from_u8(i ^ j)); - - // Add low byte (carry derived in-circuit, no column) - trace_values.push(G::from_u8(i.wrapping_add(j))); - - // Sub low byte (borrow derived in-circuit, no column) - trace_values.push(G::from_u8(i.wrapping_sub(j))); - - // Mul (low byte, high byte) - let p = u16::from(i) * u16::from(j); - trace_values.push(G::from_u8((p & 0xff) as u8)); - trace_values.push(G::from_u8((p >> 8) as u8)); - - let (hi, lo) = Self::xor_split7_u8(i, j); - trace_values.extend([G::from_u8(hi), G::from_u8(lo)]); - let (hi, lo) = Self::xor_split4_u8(i, j); - trace_values.extend([G::from_u8(hi), G::from_u8(lo)]); - } - } - Some(RowMajorMatrix::new(trace_values, PREPROCESSED_TRACE_WIDTH)) - } - - fn execute( - &self, - op: &Bytes2Op, - input: &[G], - record: &mut QueryRecord, - ) -> Vec { - let i = &input[0]; - let j = &input[1]; - match op { - Bytes2Op::Xor => { - record.bytes2_queries.bump_xor(i, j); - vec![Self::xor(i, j)] - }, - Bytes2Op::Add => { - record.bytes2_queries.bump_add(i, j); - let (r, _o) = Self::add(i, j); - vec![r] - }, - Bytes2Op::Mul => { - record.bytes2_queries.bump_mul(i, j); - let (lo, hi) = Self::mul(i, j); - vec![lo, hi] - }, - Bytes2Op::Sub => { - record.bytes2_queries.bump_sub(i, j); - let (r, _u) = Self::sub(i, j); - vec![r] - }, - Bytes2Op::And => { - record.bytes2_queries.bump_and(i, j); - vec![Self::and(i, j)] - }, - Bytes2Op::Or => { - record.bytes2_queries.bump_or(i, j); - vec![Self::or(i, j)] - }, - Bytes2Op::LessThan => { - record.bytes2_queries.bump_less_than(i, j); - vec![Self::less_than(i, j)] - }, - Bytes2Op::XorSplit7 => { - record.bytes2_queries.bump_xor_split7(i, j); - let (hi, lo) = Self::xor_split7(i, j); - vec![hi, lo] - }, - Bytes2Op::XorSplit4 => { - record.bytes2_queries.bump_xor_split4(i, j); - let (hi, lo) = Self::xor_split4(i, j); - vec![hi, lo] - }, - } - } - - fn lookups(&self) -> Vec>> { - // Channels - let xor_channel = Expr::constant(u8_xor_channel()); - let add_channel = Expr::constant(u8_add_channel()); - let sub_channel = Expr::constant(u8_sub_channel()); - let range_check_channel = Expr::constant(u8_range_check_channel()); - let mul_channel = Expr::constant(u8_mul_channel()); - let xor_split7_channel = Expr::constant(u8_xor_split7_channel()); - let xor_split4_channel = Expr::constant(u8_xor_split4_channel()); - let u16_range_channel = Expr::constant(u16_range_check_channel()); - - // Multiplicity columns - let xor_multiplicity = Expr::main(0); - let add_multiplicity = Expr::main(1); - let sub_multiplicity = Expr::main(2); - let range_check_multiplicity = Expr::main(3); - let mul_multiplicity = Expr::main(4); - let xor_split7_multiplicity = Expr::main(5); - let xor_split4_multiplicity = Expr::main(6); - let u16_range_multiplicity = Expr::main(7); - - // Preprocessed columns - let i = Expr::preprocessed(0); - let j = Expr::preprocessed(1); - let xor = Expr::preprocessed(2); - let add_r = Expr::preprocessed(3); - let sub_r = Expr::preprocessed(4); - let mul_lo = Expr::preprocessed(5); - let mul_hi = Expr::preprocessed(6); - let xor_split7_hi = Expr::preprocessed(7); - let xor_split7_lo = Expr::preprocessed(8); - let xor_split4_hi = Expr::preprocessed(9); - let xor_split4_lo = Expr::preprocessed(10); - - // pull = negated multiplicity. - let pull_xor = Lookup { - multiplicity: -xor_multiplicity, - args: vec![xor_channel, i.clone(), j.clone(), xor], - }; - - let pull_add = Lookup { - multiplicity: -add_multiplicity, - args: vec![add_channel, i.clone(), j.clone(), add_r], - }; - - let pull_sub = Lookup { - multiplicity: -sub_multiplicity, - args: vec![sub_channel, i.clone(), j.clone(), sub_r], - }; - - let pull_mul = Lookup { - multiplicity: -mul_multiplicity, - args: vec![mul_channel, i.clone(), j.clone(), mul_lo, mul_hi], - }; - - let pull_range_check = Lookup { - multiplicity: -range_check_multiplicity, - args: vec![range_check_channel, i.clone(), j.clone()], - }; - - let pull_xor_split7 = Lookup { - multiplicity: -xor_split7_multiplicity, - args: vec![ - xor_split7_channel, - i.clone(), - j.clone(), - xor_split7_hi, - xor_split7_lo, - ], - }; - let pull_xor_split4 = Lookup { - multiplicity: -xor_split4_multiplicity, - args: vec![ - xor_split4_channel, - i.clone(), - j.clone(), - xor_split4_hi, - xor_split4_lo, - ], - }; - - // The preprocessed row enumerates exactly one integer in 0..2^16. - // Keep this separate from the two independent byte-range arguments. - let pull_u16_range = Lookup { - multiplicity: -u16_range_multiplicity, - args: vec![u16_range_channel, i * Expr::constant(G::from_u16(256)) + j], - }; - - vec![ - pull_xor, - pull_add, - pull_sub, - pull_range_check, - pull_mul, - pull_xor_split7, - pull_xor_split4, - pull_u16_range, - ] - } - - fn witness_data( - &self, - record: &QueryRecord, - slot_arg_widths: &[usize], - ) -> (RowMajorMatrix, LookupValues) { - let mut rows = G::zero_vec(256 * 256 * TRACE_WIDTH); - for (row, multiplicities) in rows - .as_chunks_mut::() - .0 - .iter_mut() - .zip(&record.bytes2_queries.0) - { - *row = *multiplicities; - } - if crate::trace::trace_only_lookups() { - return ( - RowMajorMatrix::new(rows, TRACE_WIDTH), - LookupValues::shape_only(256 * 256, slot_arg_widths), - ); - } - - // There are `TRACE_WIDTH` lookups per row, one for each multiplicity. - let mut builder = LookupValues::builder(256 * 256, slot_arg_widths); - let mut row_writers = builder.rows_mut(); - for ((row_idx, counts), row_lookups) in rows - .as_chunks::() - .0 - .iter() - .enumerate() - .zip(row_writers.iter_mut()) - { - let [xor, add, sub, range_check, mul, xor_split7, xor_split4, u16_range] = - *counts; - let i = G::from_usize(row_idx / 256); - let j = G::from_usize(row_idx % 256); - - // AND and OR queries also pull XOR; comparisons also pull subtraction. - row_lookups.pull(0, xor, &[u8_xor_channel(), i, j, Self::xor(&i, &j)]); - let (r, _) = Self::add(&i, &j); - row_lookups.pull(1, add, &[u8_add_channel(), i, j, r]); - let (r, _) = Self::sub(&i, &j); - row_lookups.pull(2, sub, &[u8_sub_channel(), i, j, r]); - row_lookups.pull( - Self::RANGE_CHECK_COLUMN, - range_check, - &[u8_range_check_channel(), i, j], - ); - let (lo, hi) = Self::mul(&i, &j); - row_lookups.pull(4, mul, &[u8_mul_channel(), i, j, lo, hi]); - let (hi, lo) = Self::xor_split7(&i, &j); - row_lookups.pull(5, xor_split7, &[u8_xor_split7_channel(), i, j, hi, lo]); - let (hi, lo) = Self::xor_split4(&i, &j); - row_lookups.pull(6, xor_split4, &[u8_xor_split4_channel(), i, j, hi, lo]); - row_lookups.pull( - Self::U16_RANGE_CHECK_COLUMN, - u16_range, - &[u16_range_check_channel(), G::from_usize(row_idx)], - ); - } - drop(row_writers); - (RowMajorMatrix::new(rows, TRACE_WIDTH), builder.finish()) - } -} - -/// Accumulator of queries performed against `Bytes2`. -pub struct Bytes2Queries(Box<[[G; TRACE_WIDTH]]>); - -impl Bytes2Queries { - #[inline] - pub(crate) fn new() -> Self { - Self(vec![[G::ZERO; TRACE_WIDTH]; 256 * 256].into_boxed_slice()) - } - - pub(crate) fn bump_xor(&mut self, i: &G, j: &G) { - self.bump_multiplicity_for(i, j, 0) - } - - pub(crate) fn bump_add(&mut self, i: &G, j: &G) { - self.bump_multiplicity_for(i, j, 1) - } - - pub(crate) fn bump_sub(&mut self, i: &G, j: &G) { - self.bump_multiplicity_for(i, j, 2) - } - - pub(crate) fn bump_and(&mut self, i: &G, j: &G) { - self.bump_xor(i, j) - } - - pub(crate) fn bump_or(&mut self, i: &G, j: &G) { - self.bump_xor(i, j) - } - - pub(crate) fn bump_less_than(&mut self, i: &G, j: &G) { - self.bump_sub(i, j) - } - - pub fn bump_range_check(&mut self, i: &G, j: &G) { - self.bump_multiplicity_for(i, j, Bytes2::RANGE_CHECK_COLUMN) - } - - /// Record a scalar u16 query on its distinct range channel. - pub fn bump_u16_range_check(&mut self, limb: u16) { - self.0[usize::from(limb)][Bytes2::U16_RANGE_CHECK_COLUMN] += G::ONE; - } - - pub(crate) fn bump_mul(&mut self, i: &G, j: &G) { - self.bump_multiplicity_for(i, j, 4) - } - - pub(crate) fn bump_xor_split7(&mut self, i: &G, j: &G) { - self.bump_multiplicity_for(i, j, 5) - } - - pub(crate) fn bump_xor_split4(&mut self, i: &G, j: &G) { - self.bump_multiplicity_for(i, j, 6) - } - - pub(crate) fn bump_multiplicity_for(&mut self, i: &G, j: &G, col: usize) { - let i = usize::try_from(i.as_canonical_u64()).unwrap(); - let j = usize::try_from(j.as_canonical_u64()).unwrap(); - let row = 256 * i + j; - self.0[row][col] += G::ONE; - } -} - -impl Bytes2 { - /// Shared row and lookup-slot index of the byte-pair range channel. - pub(crate) const RANGE_CHECK_COLUMN: usize = 3; - /// Shared row and lookup-slot index of the scalar u16 range channel. - pub(crate) const U16_RANGE_CHECK_COLUMN: usize = 7; - - #[inline] - pub fn xor(i: &G, j: &G) -> G { - let i: u8 = i.as_canonical_u64().try_into().unwrap(); - let j: u8 = j.as_canonical_u64().try_into().unwrap(); - G::from_u8(i ^ j) - } - - #[inline] - pub fn add(i: &G, j: &G) -> (G, G) { - let i: u8 = i.as_canonical_u64().try_into().unwrap(); - let j: u8 = j.as_canonical_u64().try_into().unwrap(); - let (r, o) = i.overflowing_add(j); - (G::from_u8(r), G::from_bool(o)) - } - - #[inline] - pub fn and(i: &G, j: &G) -> G { - let i: u8 = i.as_canonical_u64().try_into().unwrap(); - let j: u8 = j.as_canonical_u64().try_into().unwrap(); - G::from_u8(i & j) - } - - #[inline] - pub fn or(i: &G, j: &G) -> G { - let i: u8 = i.as_canonical_u64().try_into().unwrap(); - let j: u8 = j.as_canonical_u64().try_into().unwrap(); - G::from_u8(i | j) - } - - #[inline] - pub fn sub(i: &G, j: &G) -> (G, G) { - let i: u8 = i.as_canonical_u64().try_into().unwrap(); - let j: u8 = j.as_canonical_u64().try_into().unwrap(); - let (r, u) = i.overflowing_sub(j); - (G::from_u8(r), G::from_bool(u)) - } - - #[inline] - pub fn less_than(i: &G, j: &G) -> G { - let i: u8 = i.as_canonical_u64().try_into().unwrap(); - let j: u8 = j.as_canonical_u64().try_into().unwrap(); - G::from_bool(i < j) - } - - /// `u8 * u8 -> (low byte, high byte)`. The product fits in 16 bits. - #[inline] - pub fn mul(i: &G, j: &G) -> (G, G) { - let i: u8 = i.as_canonical_u64().try_into().unwrap(); - let j: u8 = j.as_canonical_u64().try_into().unwrap(); - let p = u16::from(i) * u16::from(j); - (G::from_u8((p & 0xff) as u8), G::from_u8((p >> 8) as u8)) - } - - /// Building block for a right-rotation by 7 bits over little-endian bytes: - /// the xor `x = i ^ j` split as `(x >> 7, x << 1)` (shift mod 256). - #[inline] - pub fn xor_split7_u8(i: u8, j: u8) -> (u8, u8) { - let x = i ^ j; - (x >> 7, x << 1) - } - - /// Building block for a right-rotation by 4 bits over little-endian bytes: - /// the xor `x = i ^ j` split as `(x >> 4, x << 4)` (shifts mod 256). - #[inline] - pub fn xor_split4_u8(i: u8, j: u8) -> (u8, u8) { - let x = i ^ j; - (x >> 4, x << 4) - } - - #[inline] - pub fn xor_split7(i: &G, j: &G) -> (G, G) { - let (hi, lo) = Self::xor_split7_u8( - u8::try_from(i.as_canonical_u64()).expect("byte-table input"), - u8::try_from(j.as_canonical_u64()).expect("byte-table input"), - ); - (G::from_u8(hi), G::from_u8(lo)) - } - - #[inline] - pub fn xor_split4(i: &G, j: &G) -> (G, G) { - let (hi, lo) = Self::xor_split4_u8( - u8::try_from(i.as_canonical_u64()).expect("byte-table input"), - u8::try_from(j.as_canonical_u64()).expect("byte-table input"), - ); - (G::from_u8(hi), G::from_u8(lo)) - } -} diff --git a/crates/aiur/src/gpu_trace/mod.rs b/crates/aiur/src/gpu_trace/mod.rs deleted file mode 100644 index 74c169ca3..000000000 --- a/crates/aiur/src/gpu_trace/mod.rs +++ /dev/null @@ -1,149 +0,0 @@ -//! 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::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, - _retain_device_seeds, - ) { - Ok(prepared) => Some(prepared), - Err(error) => { - tracing::warn!( - circuit = _circuit, - rows = _row_count, - %error, - "CPU trace: generated seed preparation failed" - ); - None - }, - } - }, - } - } -} diff --git a/crates/aiur/src/hints.rs b/crates/aiur/src/hints.rs new file mode 100644 index 000000000..d3beaf23e --- /dev/null +++ b/crates/aiur/src/hints.rs @@ -0,0 +1,334 @@ +//! Host advice has a static channel and constant input/output types. Preparation +//! resolves channel names once; execution calls the bound closure at each site. +use crate::bytecode::{CheckedProgram, Instruction, Layout, Program, Type}; +use crate::field::{FieldBackend, PrimeField}; +use crate::host::{self, HintBinder, RegisterHint}; +use serde::{Deserialize, Serialize}; +use std::collections::HashMap; +use std::sync::Arc; + +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub struct HintEntry { + #[serde(default)] + pub channel: String, + pub r#type: Type, + pub key_type: Type, + pub key: Vec, + pub output: Vec, +} + +/// Flat encodings of constants, with their nominal types fixed at registration. +/// The output buffer has the declared width and starts zeroed. The runtime +/// validates every returned word, enum tag and padding slot before consuming it. +/// Closures may capture configuration; no addresses or VM internals are exposed. +/// Providers must return the same answer for the same key throughout execution +/// and trace generation, independently of call order and concurrent invocations. +/// Trace generation calls the provider again instead of retaining its answers. +/// Rust's `Fn + Send + Sync` bounds do not enforce this repeatability contract. +pub type HintFunction = + dyn Fn(&[F], &mut [F]) -> Result<(), String> + Send + Sync; + +struct Channel { + key_type: Type, + output_type: Type, + function: Arc>, + fixed: Option<(usize, usize, Arc>)>, +} + +/// Host-defined code providers. Names are resolved only by `prepare_hint_channels`. +/// Data-only channels remain available through `HintEntry`. +pub struct HintChannels { + channels: HashMap>, +} +impl Default for HintChannels { + fn default() -> Self { + Self { channels: HashMap::new() } + } +} +impl HintChannels { + pub fn new() -> Self { + Self::default() + } + + pub fn insert( + &mut self, + name: impl Into, + key_type: Type, + output_type: Type, + function: impl Fn(&[F], &mut [F]) -> Result<(), String> + Send + Sync + 'static, + ) -> Result<(), String> { + let name = name.into(); + if self.channels.contains_key(&name) { + return Err(format!("duplicate hint channel {name:?}")); + } + self.channels.insert( + name, + Channel { + key_type, + output_type, + function: Arc::new(function), + fixed: None, + }, + ); + Ok(()) + } + + /// Fixed-width counterpart of `insert`. The complete register handler is + /// specialized around this concrete closure before its type is erased. + /// The nominal types are still checked, and output canonicality/tag checks + /// are retained. All outputs must be returned, rather than partially filled. + pub fn insert_fixed( + &mut self, + name: impl Into, + key_type: Type, + output_type: Type, + function: impl Fn([F; INPUTS]) -> Result<[F; OUTPUTS], String> + + Send + + Sync + + 'static, + ) -> Result<(), String> + where + F: Copy + Send + Sync + 'static, + { + let name = name.into(); + if self.channels.contains_key(&name) { + return Err(format!("duplicate hint channel {name:?}")); + } + let function = Arc::new(function); + let binder = host::hint_binder(function.clone()); + self.channels.insert( + name, + Channel { + key_type, + output_type, + function: Arc::new(move |key, output| { + let input = + key.try_into().map_err(|_| "hint input width mismatch")?; + output.copy_from_slice(&function(input)?); + Ok(()) + }), + fixed: Some((INPUTS, OUTPUTS, binder)), + }, + ); + Ok(()) + } +} + +pub(crate) struct HintSite { + pub(crate) function: Arc>, + // Data answers have already passed validation; code answers have not. + pub(crate) output_layout: Option, + pub(crate) registers: Option>>, +} + +impl HintSite { + #[inline] + pub(crate) fn evaluate>( + &self, + key: &[F], + output: &mut [F], + field: B, + ) -> Result<(), String> { + output.fill(field.zero()); + (self.function)(key, output)?; + if let Some(layout) = &self.output_layout { + layout.validate(output, field)?; + } + Ok(()) + } +} + +/// Shared once per prepared session, including the immutable data captured by +/// data-backed providers. Records keep this alive for later or parallel replay. +pub(crate) struct BoundHints { + pub(crate) program: Arc, + pub(crate) sites: Vec>>>, +} + +impl std::fmt::Debug for BoundHints { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("BoundHints") + .field("functions", &self.sites.len()) + .finish_non_exhaustive() + } +} + +/// Providers bound to bytecode sites. Reusing this object does not reuse query +/// caches or ROM pointers. It owns the closures and their captured environment. +pub struct PreparedHints<'a, B: FieldBackend = PrimeField> { + pub(crate) program: &'a CheckedProgram, + pub(crate) bindings: Arc>, + pub(crate) maps: Vec>>, + pub(crate) dispatch: Vec>>, +} + +impl PreparedHints<'_, B> { + /// Bind optional static-map implementations once. The resulting execution + /// records retain these same closures for witness population. No source + /// syntax, function implementation, or certifying table is replaced. + pub fn with_map_overrides( + mut self, + overrides: &crate::maps::MapOverrides, + ) -> Result { + self.maps = overrides.bind(self.program)?; + let maps = overrides.bind_registers(self.program); + self.dispatch = crate::execute::dispatch::prepare( + self.program, + &self.bindings.sites, + Some(&maps), + ); + Ok(self) + } +} + +type DataIndex = + HashMap<(String, Type), Arc, (Type, Vec)>>>; + +impl CheckedProgram { + pub fn prepare_hints( + &self, + entries: &[HintEntry], + ) -> Result, String> { + self.prepare_hint_channels(entries, &HintChannels::new()) + } + + /// Code providers override data for their channel. All supplied data is + /// still checked, including unused rows. Unbound channels fail only when + /// executed, so an inactive hint requires no provider. + pub fn prepare_hint_channels( + &self, + entries: &[HintEntry], + channels: &HintChannels, + ) -> Result, String> { + let data = prepare_data(self, entries)?; + // Validate registrations even when there are no sites for them. + for (name, channel) in &channels.channels { + let key = channel.key_type.layout(&self.program.enums, &mut vec![])?; + let output = + channel.output_type.layout(&self.program.enums, &mut vec![])?; + if !key.pointer_free() || !output.pointer_free() { + return Err(format!("hint channel {name:?} cannot contain pointers")); + } + if let Some((inputs, outputs, _)) = &channel.fixed + && (key.width() != *inputs || output.width() != *outputs) + { + return Err(format!("hint channel {name:?} fixed arity mismatch")); + } + } + let sites = self + .program + .functions + .iter() + .enumerate() + .map(|(function_id, function)| { + function + .code + .iter() + .enumerate() + .map(|(pc, op)| { + let Instruction::Hint { channel, key_type, r#type, .. } = op else { + return Ok(None); + }; + let site = if let Some(provider) = channels.channels.get(channel) { + if &provider.key_type != key_type + || &provider.output_type != r#type + { + return Err(format!( + "hint channel {channel:?} signature mismatch" + )); + } + let layout = r#type.layout(&self.program.enums, &mut vec![])?; + let registers = + provider.fixed.as_ref().and_then(|(_, _, binder)| { + let Instruction::Hint { key, dest, .. } = + &self.execution_functions[function_id].code[pc] + else { + return None; + }; + binder(key, dest, host::output_check(&layout, self.field)) + }); + HintSite { + function: provider.function.clone(), + output_layout: Some(layout), + registers, + } + } else if let Some(rows) = + data.get(&(channel.clone(), key_type.clone())) + { + let rows = rows.clone(); + let expected = r#type.clone(); + HintSite { + function: Arc::new(move |key, output| { + let (actual, answer) = + rows.get(key).ok_or("missing hint data")?; + if actual != &expected { + return Err("hint output type mismatch".into()); + } + output.copy_from_slice(answer); + Ok(()) + }), + output_layout: None, + registers: None, + } + } else { + HintSite { + function: Arc::new(|_, _| Err("missing hint provider".into())), + output_layout: None, + registers: None, + } + }; + Ok(Some(site)) + }) + .collect::, String>>() + }) + .collect::, String>>()?; + let dispatch = crate::execute::dispatch::prepare(self, &sites, None); + Ok(PreparedHints { + program: self, + bindings: Arc::new(BoundHints { program: self.program.clone(), sites }), + maps: crate::maps::MapOverrides::new().bind(self)?, + dispatch, + }) + } +} + +fn prepare_data( + program: &CheckedProgram, + entries: &[HintEntry], +) -> Result, String> { + let mut layouts = HashMap::new(); + let mut index: DataIndex = HashMap::new(); + for (row, entry) in entries.iter().enumerate() { + let check = |ty: &Type, words: &[u64], layouts: &mut HashMap<_, _>| { + if !layouts.contains_key(ty) { + let layout = ty.layout(&program.program.enums, &mut vec![])?; + if !layout.pointer_free() { + return Err("supplied hint data cannot contain pointers".to_owned()); + } + layouts.insert(ty.clone(), layout); + } + let words = program.field.decode(words)?; + layouts[ty].validate(&words, program.field)?; + Ok::<_, String>(words) + }; + let key = check(&entry.key_type, &entry.key, &mut layouts) + .map_err(|e| format!("hint entry {row} key: {e}"))?; + let output = check(&entry.r#type, &entry.output, &mut layouts) + .map_err(|e| format!("hint entry {row} output: {e}"))?; + let rows = + index.entry((entry.channel.clone(), entry.key_type.clone())).or_default(); + let rows = Arc::get_mut(rows).unwrap(); + match rows.entry(key) { + std::collections::hash_map::Entry::Vacant(slot) => { + slot.insert((entry.r#type.clone(), output)); + }, + std::collections::hash_map::Entry::Occupied(slot) => { + let (ty, existing) = slot.get(); + if ty != &entry.r#type || existing != &output { + return Err(format!("conflicting hint entries at row {row}")); + } + }, + } + } + Ok(index) +} diff --git a/crates/aiur/src/host.rs b/crates/aiur/src/host.rs new file mode 100644 index 000000000..b912e52dc --- /dev/null +++ b/crates/aiur/src/host.rs @@ -0,0 +1,165 @@ +//! Fixed-arity host calls. Erase the type of the complete register handler, +//! after specializing argument gathering, the provider, and result writes. +use crate::{bytecode::Layout, field::FieldBackend}; +use std::sync::Arc; + +type Validator = dyn Fn(&[F]) -> Result<(), String> + Send + Sync; +pub(crate) type OutputCheck = Option>>; +pub(crate) type RegisterMap = + dyn Fn(&mut [F], &mut [u64]) -> Result<(), String> + Send + Sync; +pub(crate) type MapCalls = Vec>>>; +pub(crate) type RegisterHint = + dyn Fn(&mut [F]) -> Result<(), String> + Send + Sync; +pub(crate) type MapBinder = dyn Fn(&[usize], &[usize], OutputCheck) -> Option>> + + Send + + Sync; +pub(crate) type HintBinder = dyn Fn(&[usize], &[usize], OutputCheck) -> Option>> + + Send + + Sync; + +pub(crate) fn output_check( + layout: &Layout, + field: B, +) -> OutputCheck { + if B::ALL_ELEMENTS_VALID && !layout.has_shape_checks() { + None + } else { + let layout = layout.clone(); + Some(Arc::new(move |output| layout.validate(output, field))) + } +} + +#[inline] +pub(crate) fn bump(counts: &mut [u64], row: usize) -> Result<(), String> { + let count = + counts.get_mut(row).ok_or("map override row index out of bounds")?; + *count = count.checked_add(1).ok_or("map multiplicity overflow")?; + Ok(()) +} + +pub(crate) fn map_binder( + function: Arc, +) -> Arc> +where + F: Copy + Send + Sync + 'static, + C: Fn([F; INPUTS]) -> Result<(usize, [F; OUTPUTS]), String> + + Send + + Sync + + 'static, +{ + Arc::new(move |args, dest, check| { + // Unreachable bytecode may have arbitrary operand widths. Leave those + // sites on the generic path instead of rejecting an otherwise valid program. + let args: [usize; INPUTS] = args.try_into().ok()?; + let dest: [usize; OUTPUTS] = dest.try_into().ok()?; + let function = function.clone(); + Some(Arc::new(move |registers, counts| { + // Gather all inputs before writing any output, including aliased + // operands and destinations. C is still concrete at this point. + let input = std::array::from_fn(|i| registers[args[i]]); + let (row, output) = function(input)?; + if let Some(check) = &check { + check(&output)?; + } + bump(counts, row)?; + for i in 0..OUTPUTS { + registers[dest[i]] = output[i]; + } + Ok(()) + })) + }) +} + +pub(crate) fn hint_binder( + function: Arc, +) -> Arc> +where + F: Copy + Send + Sync + 'static, + C: Fn([F; INPUTS]) -> Result<[F; OUTPUTS], String> + Send + Sync + 'static, +{ + Arc::new(move |args, dest, check| { + let args: [usize; INPUTS] = args.try_into().ok()?; + let dest: [usize; OUTPUTS] = dest.try_into().ok()?; + let function = function.clone(); + Some(Arc::new(move |registers| { + let input = std::array::from_fn(|i| registers[args[i]]); + let output = function(input)?; + if let Some(check) = &check { + check(&output)?; + } + for i in 0..OUTPUTS { + registers[dest[i]] = output[i]; + } + Ok(()) + })) + }) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn register_handlers_gather_before_writes_and_check_count_errors() { + let binder = + map_binder(Arc::new(|[a, b]: [u64; 2]| Ok(((a + b) as usize, [b, a])))); + let call = binder(&[0, 1], &[0, 1], None).unwrap(); + let mut registers = [2, 5]; + let mut counts = [0; 8]; + call(&mut registers, &mut counts).unwrap(); + assert_eq!(registers, [5, 2]); + assert_eq!(counts[7], 1); + counts[7] = u64::MAX; + assert!( + call(&mut registers, &mut counts).unwrap_err().contains("overflow") + ); + assert_eq!(registers, [5, 2]); + assert_eq!(counts[7], u64::MAX); + assert!( + call(&mut registers, &mut []).unwrap_err().contains("out of bounds") + ); + assert_eq!(registers, [5, 2]); + + let binder = hint_binder(Arc::new(|[a, b]: [u64; 2]| Ok([b, a]))); + let call = binder(&[0, 1], &[0, 1], None).unwrap(); + call(&mut registers).unwrap(); + assert_eq!(registers, [2, 5]); + } + + #[test] + fn native_fields_keep_enum_validation() { + use crate::{ + bytecode::{Constructor, Enum, Type}, + field::{NativeField, PrimeField}, + }; + use multi_stark::p3_goldilocks::Goldilocks; + let field = NativeField::::new(); + assert!(output_check(&Layout::Field, field).is_none()); + let scalar_check = + output_check(&Layout::Field, PrimeField::new(97).unwrap()).unwrap(); + assert!(scalar_check(&[97]).is_err()); + let layout = Type::Enum { name: "Choice".into() } + .layout( + &[Enum { + name: "Choice".into(), + constructors: vec![ + Constructor { name: "None".into(), fields: vec![] }, + Constructor { name: "Some".into(), fields: vec![Type::Field] }, + ], + }], + &mut vec![], + ) + .unwrap(); + for (words, message) in + [([2, 0], "invalid enum tag"), ([0, 1], "nonzero enum padding")] + { + let binder = hint_binder(Arc::new(move |[]: [Goldilocks; 0]| { + Ok(words.map(|x| field.from_u64(x))) + })); + let call = binder(&[], &[0, 1], output_check(&layout, field)).unwrap(); + let mut registers = [field.one(); 2]; + assert!(call(&mut registers).unwrap_err().contains(message)); + assert_eq!(registers, [field.one(); 2]); + } + } +} diff --git a/crates/aiur/src/lib.rs b/crates/aiur/src/lib.rs index 8e654ecc1..0cd8b0b7f 100644 --- a/crates/aiur/src/lib.rs +++ b/crates/aiur/src/lib.rs @@ -1,122 +1,34 @@ +//! Aiur's untrusted execution engine. Lean supplies execution bytecode; Rust +//! evaluates it and records memoized queries. Companion population plans fill +//! the final optimized circuit rows from these records. + +pub mod budget; pub mod bytecode; -pub mod constraints; pub mod execute; -pub mod gadgets; -mod lookup_budget; -mod lookup_groups; -mod lookup_shapes; +mod ffi; +pub mod field; +#[cfg(feature = "function-profile")] +pub mod function_profile; +pub mod hints; +mod host; +pub mod library; +pub mod maps; pub mod memory; -pub mod querymap; -pub mod range; -pub mod record_pool; -mod row_counts; -pub mod shard; -pub mod synthesis; +pub mod query; +mod table; pub mod trace; -pub mod trace_codegen; -mod trace_heights; -pub mod vk_codec; - -use indexmap::IndexMap; -use multi_stark::p3_field::PrimeCharacteristicRing; -use rustc_hash::FxBuildHasher; - -pub type G = multi_stark::p3_goldilocks::Goldilocks; -pub type FxIndexMap = IndexMap; - -#[inline] -pub const fn function_channel() -> G { - G::ZERO -} - -#[inline] -pub const fn memory_channel() -> G { - G::ONE -} - -#[inline] -pub const fn u8_bit_decomposition_channel() -> G { - G::TWO -} - -#[inline] -pub fn u8_shift_left_channel() -> G { - G::from_u8(3) +pub mod value; + +pub use bytecode::Program; +pub use execute::{Execution, ExecutionError, QueryInput, QueryOutput}; +/// Decode a trusted compiler artifact. Wide constraint polynomials can exceed +/// serde_json's default nesting limit; witness/proof input retains normal bounds. +pub fn decode_artifact( + bytes: &[u8], +) -> Result { + let mut decoder = serde_json::Deserializer::from_slice(bytes); + decoder.disable_recursion_limit(); + let artifact = T::deserialize(&mut decoder)?; + decoder.end()?; + Ok(artifact) } - -#[inline] -pub fn u8_shift_right_channel() -> G { - G::from_u8(4) -} - -#[inline] -pub fn u8_xor_channel() -> G { - G::from_u8(5) -} - -#[inline] -pub fn u8_add_channel() -> G { - G::from_u8(6) -} - -#[inline] -pub fn u8_sub_channel() -> G { - G::from_u8(7) -} - -// Legacy AND/OR/comparison channel IDs remain reserved. Their operations -// now use affine arguments on the XOR/subtraction channels; Bytes2 does not -// provide these three channels. Keep later channel IDs unchanged. -#[inline] -pub fn u8_and_channel() -> G { - G::from_u8(8) -} - -#[inline] -pub fn u8_or_channel() -> G { - G::from_u8(9) -} - -#[inline] -pub fn u8_less_than_channel() -> G { - G::from_u8(10) -} - -#[inline] -pub fn u8_range_check_channel() -> G { - G::from_u8(11) -} - -#[inline] -pub fn u8_mul_channel() -> G { - G::from_u8(12) -} - -#[inline] -pub fn u8_xor_split7_channel() -> G { - G::from_u8(13) -} - -#[inline] -pub fn u8_xor_split4_channel() -> G { - G::from_u8(14) -} - -/// Scalar u16 range checks have a distinct channel from byte pairs. -#[inline] -pub fn u16_range_check_channel() -> G { - G::from_u8(15) -} - -/// Memory segment boundaries. Every real memory row pushes its own pointer -/// and pulls its successor on this channel, so a contiguous pointer run -/// `[a, b)` contributes exactly one push of `a` and one pull of `b`; the -/// batch verifier closes the channel with one pull of `0` and one push of the -/// table's total length per memory width (see `shard.rs`). -#[inline] -pub fn memseg_channel() -> G { - G::from_u8(16) -} - -#[cfg(feature = "cuda")] -pub mod gpu_trace; diff --git a/crates/aiur/src/library/io.rs b/crates/aiur/src/library/io.rs new file mode 100644 index 000000000..a87c11875 --- /dev/null +++ b/crates/aiur/src/library/io.rs @@ -0,0 +1,148 @@ +//! Immutable stream advice shared by applications. These are ordinary hint +//! closures: they do not add operations to Aiur or trust the supplied bytes. +use crate::{ + bytecode::Type, + field::FieldBackend, + hints::{HintChannels, HintEntry}, +}; +use serde::{Deserialize, Serialize}; +use std::sync::Arc; + +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct Stream { + pub channel: u64, + pub key: Vec, + pub values: Vec, +} + +/// Compact interchange format. One entry per stream, rather than per byte. +#[derive(Clone, Debug, Default, Serialize, Deserialize)] +pub struct Streams(pub Vec); + +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct Invocation { + pub entry: String, + pub args: Vec, + #[serde(default)] + pub streams: Streams, +} + +pub struct Arenas<'s, B: FieldBackend> { + field: B, + values: Arc>>, + entries: Vec<(&'s Stream, usize)>, +} + +impl Streams { + pub fn prepare( + &self, + field: B, + ) -> Result, String> { + let mut values = Vec::new(); + let mut entries = Vec::new(); + let mut keys = std::collections::HashSet::new(); + for stream in &self.0 { + // This host adapter supports small numbered stream channels. The hint + // mechanism itself has no such restriction; another closure may be used. + let channel = + usize::try_from(stream.channel).map_err(|_| "IO channel overflow")?; + if channel >= 256 { + return Err("IO arena channel must be below 256".into()); + } + field.decode(&stream.key)?; + if !keys.insert((stream.channel, &stream.key)) { + return Err("duplicate IO stream key".into()); + } + values.resize_with(values.len().max(channel + 1), Vec::new); + let offset = values[channel].len(); + values[channel].extend(field.decode(&stream.values)?); + entries.push((stream, offset)); + } + Ok(Arenas { field, values: Arc::new(values), entries }) + } +} + +impl Arenas<'_, B> { + /// Bind a fixed-size array read. Array elements are raw fields; the Aiur + /// program must range-check them before constructing opaque bytes. + pub fn register_read( + &self, + name: &str, + scalar: bool, + channels: &mut HintChannels, + ) -> Result<(), String> { + if scalar && N != 1 { + return Err("scalar IO read must have width one".into()); + } + let values = self.values.clone(); + let field = self.field; + channels.insert_fixed::<2, N>( + name, + Type::Tuple { items: vec![Type::Field; 2] }, + if scalar { + Type::Field + } else { + Type::Tuple { items: vec![Type::Field; N] } + }, + move |[channel, offset]| { + let channel = usize::try_from(field.to_u64(channel)) + .map_err(|_| "IO channel overflow")?; + let offset = usize::try_from(field.to_u64(offset)) + .map_err(|_| "IO offset overflow")?; + let end = offset.checked_add(N).ok_or("IO offset overflow")?; + let row = values + .get(channel) + .and_then(|a| a.get(offset..end)) + .ok_or("missing hint data: IO read out of bounds")?; + Ok(std::array::from_fn(|i| row[i])) + }, + ) + } + + /// Metadata and tag hints retain ordinary data semantics. Reads use the + /// shared vectors above, including when hints are replayed during tracing. + pub fn metadata( + &self, + name: &str, + key_type: Type, + fixed_channel: Option, + accepts: impl Fn(&Stream) -> bool, + value: bool, + ) -> Result, String> { + let mut result = Vec::new(); + for (stream, offset) in &self.entries { + if !accepts(stream) { + continue; + } + let mut key = if let Some(channel) = fixed_channel { + if stream.channel != channel { + continue; + } + vec![] + } else { + vec![stream.channel] + }; + key.extend(&stream.key); + let output = if value { + if stream.values.len() != 1 { + return Err("IO value hint must contain one field".into()); + } + stream.values.clone() + } else { + vec![*offset as u64, stream.values.len() as u64] + }; + result.push(HintEntry { + channel: name.to_owned(), + key_type: key_type.clone(), + key, + r#type: if value { + Type::Field + } else { + Type::Tuple { items: vec![Type::Field; 2] } + }, + output, + }); + } + Ok(result) + } +} diff --git a/crates/aiur/src/library/mod.rs b/crates/aiur/src/library/mod.rs new file mode 100644 index 000000000..b65b9368a --- /dev/null +++ b/crates/aiur/src/library/mod.rs @@ -0,0 +1,6 @@ +//! Optional host advice for ordinary Aiur library programs. These providers have +//! no special status in the evaluator, bytecode, circuits, or proof semantics. +pub mod io; +pub mod u32; +pub mod u64; +pub mod u8; diff --git a/crates/aiur/src/library/u32.rs b/crates/aiur/src/library/u32.rs new file mode 100644 index 000000000..7d93aa074 --- /dev/null +++ b/crates/aiur/src/library/u32.rs @@ -0,0 +1,90 @@ +//! Advice for `Aiur.Library.U32`. All answers are raw fields; the source library +//! constrains them before constructing opaque bytes or words. No Goldilocks +//! arithmetic is needed here. +use crate::{bytecode::Type, field::FieldBackend, hints::HintChannels}; + +pub const MIN_MODULUS: u64 = 3 * (1_u64 << 32); + +pub fn register( + channels: &mut HintChannels, + field: B, +) -> Result<(), String> { + if field.modulus() < MIN_MODULUS { + return Err(format!( + "u32 arithmetic requires a field modulus >= {MIN_MODULUS}" + )); + } + let bytes = Type::Tuple { items: vec![Type::Field; 4] }; + channels.insert_fixed::<1, 4>( + "u32.bytes", + Type::Field, + bytes.clone(), + #[inline(always)] + move |input| Ok(bytes_of(field.to_u64(input[0]) as u32, field)), + )?; + channels.insert_fixed::<2, 4>( + "u32.sub", + Type::Tuple { items: vec![Type::Field; 2] }, + bytes.clone(), + #[inline(always)] + move |input| { + Ok(bytes_of( + (field.to_u64(input[0]) as u32) + .wrapping_sub(field.to_u64(input[1]) as u32), + field, + )) + }, + )?; + register_sum::<8, _>(channels, field, "u32.add", &bytes)?; + register_sum::<12, _>(channels, field, "u32.add3", &bytes)?; + let pair = Type::Tuple { items: vec![Type::Field; 2] }; + channels.insert_fixed::<2, 12>( + "u32.lt", + pair, + Type::Tuple { items: vec![bytes; 3] }, + #[inline(always)] + move |input| { + let (a, b) = + (field.to_u64(input[0]) as u32, field.to_u64(input[1]) as u32); + let a_bytes = bytes_of(a, field); + let delta = bytes_of(a.wrapping_sub(b), field); + let b_bytes = bytes_of(b, field); + Ok(std::array::from_fn(|i| match i / 4 { + 0 => a_bytes[i], + 1 => delta[i - 4], + _ => b_bytes[i - 8], + })) + }, + ) +} + +fn register_sum( + channels: &mut HintChannels, + field: B, + name: &str, + bytes: &Type, +) -> Result<(), String> { + channels.insert_fixed::( + name, + Type::Tuple { items: vec![bytes.clone(); INPUTS / 4] }, + bytes.clone(), + #[inline(always)] + move |input| { + let mut sum = 0u32; + for word in input.as_chunks::<4>().0 { + let mut bytes = [0u8; 4]; + for (byte, &value) in bytes.iter_mut().zip(word) { + *byte = u8::try_from(field.to_u64(value)) + .map_err(|_| "non-byte u32 sum operand")?; + } + sum = sum.wrapping_add(u32::from_le_bytes(bytes)); + } + Ok(sum.to_le_bytes().map(|byte| field.from_u64(u64::from(byte)))) + }, + ) +} + +#[inline(always)] +fn bytes_of(word: u32, field: B) -> [B::Element; 4] { + word.to_le_bytes().map(|byte| field.from_u64(u64::from(byte))) +} diff --git a/crates/aiur/src/library/u64.rs b/crates/aiur/src/library/u64.rs new file mode 100644 index 000000000..b6dae0d0b --- /dev/null +++ b/crates/aiur/src/library/u64.rs @@ -0,0 +1,23 @@ +//! Raw byte-decomposition advice shared by word arithmetic and IxVM conversion. +//! Aiur range lookups and recomposition constraints validate the answer. +use crate::{bytecode::Type, field::FieldBackend, hints::HintChannels}; + +pub fn register( + channels: &mut HintChannels, + field: B, +) -> Result<(), String> { + channels.insert_fixed::<1, 8>( + "bytes_le", + Type::Field, + Type::Tuple { items: vec![Type::Field; 8] }, + #[inline(always)] + move |input| { + Ok( + field + .to_u64(input[0]) + .to_le_bytes() + .map(|byte| field.from_u64(u64::from(byte))), + ) + }, + ) +} diff --git a/crates/aiur/src/library/u8.rs b/crates/aiur/src/library/u8.rs new file mode 100644 index 000000000..4f968a6a8 --- /dev/null +++ b/crates/aiur/src/library/u8.rs @@ -0,0 +1,135 @@ +//! Accelerators for the shared checked byte tables. +use crate::{ + bytecode::CheckedProgram, field::FieldBackend, maps::MapOverrides, +}; + +#[cfg(test)] +mod tests; + +/// Optional host implementations for maps retained from `Aiur.Library.U8`. +/// Only present maps are registered, so this also works with tree-shaken +/// programs. The immutable Aiur tables still certify their byte domains and +/// answers. The fast row numbers require the library's input order; tables +/// with another domain or order retain the ordinary table implementation. +pub fn register_maps( + program: &CheckedProgram, + overrides: &mut MapOverrides, +) -> Result<(), String> { + let field = program.field(); + for map in &program.program().maps { + macro_rules! bind { + ($inputs:expr, $outputs:expr, $rows:expr, $body:expr) => { + if standard_order( + &program.program().tables[map.input].rows, + $inputs, + $rows, + ) { + overrides + .insert_fixed::<$inputs, $outputs>(map.name.clone(), $body)?; + } + }; + } + match map.name.as_str() { + "UInt8::from_field" => bind!(1, 1, 256, move |input| { + let row = unary::<256, _>(field, &input)?; + Ok((row, input)) + }), + "UInt8::raw_bit_decomposition" => bind!(1, 8, 256, move |input| { + let row = unary::<256, _>(field, &input)?; + Ok(( + row, + std::array::from_fn(|i| field.from_u64(((row >> i) & 1) as u64)), + )) + }), + "UInt8::range_pair" => { + bind!(2, 0, 65536, move |input| { Ok((pair(field, &input)?.2, [])) }) + }, + "UInt8::raw_xor" => bind!(2, 1, 65536, move |input| { + let (a, b, row) = pair(field, &input)?; + Ok((row, [field.from_u64(a ^ b)])) + }), + "UInt8::raw_and" => bind!(2, 1, 65536, move |input| { + let (a, b, row) = pair(field, &input)?; + Ok((row, [field.from_u64(a & b)])) + }), + "UInt8::raw_or" => bind!(2, 1, 65536, move |input| { + let (a, b, row) = pair(field, &input)?; + Ok((row, [field.from_u64(a | b)])) + }), + "UInt8::raw_lt" => bind!(2, 1, 65536, move |input| { + let (a, b, row) = pair(field, &input)?; + Ok((row, [field.from_u64(u64::from(a < b))])) + }), + "UInt8::raw_add" => bind!(2, 2, 65536, move |input| { + let (a, b, row) = pair(field, &input)?; + let sum = a + b; + Ok((row, [field.from_u64(sum & 255), field.from_u64(sum >> 8)])) + }), + "UInt8::raw_sub" => bind!(2, 2, 65536, move |input| { + let (a, b, row) = pair(field, &input)?; + Ok(( + row, + [ + field.from_u64(a.wrapping_sub(b) & 255), + field.from_u64(u64::from(a < b)), + ], + )) + }), + "UInt8::raw_mul" => bind!(2, 2, 65536, move |input| { + let (a, b, row) = pair(field, &input)?; + let product = a * b; + Ok((row, [field.from_u64(product & 255), field.from_u64(product >> 8)])) + }), + "UInt8::raw_xor_split4" => bind!(2, 2, 65536, move |input| { + let (a, b, row) = pair(field, &input)?; + let xor = a ^ b; + Ok((row, [field.from_u64(xor >> 4), field.from_u64((xor & 15) << 4)])) + }), + "UInt8::raw_xor_split7" => bind!(2, 2, 65536, move |input| { + let (a, b, row) = pair(field, &input)?; + let xor = a ^ b; + Ok((row, [field.from_u64(xor >> 7), field.from_u64((xor & 127) << 1)])) + }), + "UInt8::raw_sum_byte" => bind!(1, 1, 768, move |input| { + let row = unary::<768, _>(field, &input)?; + Ok((row, [field.from_u64((row & 255) as u64)])) + }), + _ => (), + } + } + Ok(()) +} + +fn standard_order(rows: &[Vec], width: usize, count: usize) -> bool { + rows.len() == count + && rows.iter().enumerate().all(|(i, row)| match width { + 1 => row.as_slice() == [i as u64], + 2 => row.as_slice() == [(i >> 8) as u64, (i & 255) as u64], + _ => false, + }) +} + +#[inline] +fn unary( + field: B, + input: &[B::Element], +) -> Result { + let value = field.to_u64(input[0]); + if value >= LIMIT { + return Err("no table entry for map input".into()); + } + Ok(value as usize) +} + +#[inline] +fn pair( + field: B, + input: &[B::Element], +) -> Result<(u64, u64, usize), String> { + let a = field.to_u64(input[0]); + let b = field.to_u64(input[1]); + if (a | b) > 255 { + return Err("no table entry for map input".into()); + } + Ok((a, b, ((a << 8) | b) as usize)) +} diff --git a/crates/aiur/src/library/u8/tests.rs b/crates/aiur/src/library/u8/tests.rs new file mode 100644 index 000000000..6d30780e2 --- /dev/null +++ b/crates/aiur/src/library/u8/tests.rs @@ -0,0 +1,103 @@ +use super::*; +use crate::{ + bytecode::{Map, Program, Table, Type, VERSION}, + field::{NativeField, PrimeField}, + maps::MapRecord, +}; +use multi_stark::p3_goldilocks::Goldilocks; + +fn pairs(field: B, permuted: bool) -> CheckedProgram { + let mut rows: Vec<_> = + (0..256).flat_map(|a| (0..256).map(move |b| vec![a, b])).collect(); + if permuted { + rows.swap(0, 256); + } + let params = vec![Type::Field; 2]; + let result = Type::Tuple { items: vec![] }; + Program { + version: VERSION, + modulus: field.modulus(), + functions: vec![], + enums: vec![], + entries: vec![], + maps: vec![Map { + name: "UInt8::range_pair".into(), + params: params.clone(), + result: result.clone(), + input: 0, + output: 1, + }], + tables: vec![ + Table { + name: "inputs".into(), + r#type: Type::Tuple { items: params }, + rows, + }, + Table { + name: "outputs".into(), + r#type: result, + rows: vec![vec![]; 65536], + }, + ], + } + .check_with(field) + .unwrap() +} + +fn all_pairs(field: B) { + let program = pairs(field, false); + let mut overrides = MapOverrides::new(); + register_maps(&program, &mut overrides).unwrap(); + let binding = overrides.bind(&program).unwrap().remove(0); + let mut record = MapRecord::new(binding); + for _ in 0..2 { + for args in &program.tables[0] { + record.call(args, &mut []).unwrap(); + } + } + assert_eq!(&*record.counts, &vec![2; 65536]); + // In particular (0, 256) must not alias (1, 0) when packing the key. + for (a, b) in + [(0, 256), (256, 0), (0, field.modulus() - 1), (field.modulus() - 1, 0)] + { + let args = [field.from_u64(a), field.from_u64(b)]; + assert!( + record.call(&args, &mut []).unwrap_err().contains("no table entry") + ); + } + assert_eq!(&*record.counts, &vec![2; 65536]); + record.counts[0] = u64::MAX; + assert!( + record + .call(&[field.zero(), field.zero()], &mut []) + .unwrap_err() + .contains("multiplicity overflow") + ); + assert_eq!(record.counts[0], u64::MAX); +} + +#[test] +fn byte_indices_cover_every_pair_and_keep_integer_multiplicities() { + all_pairs(PrimeField::new(65537).unwrap()); + all_pairs(NativeField::::new()); +} + +#[test] +fn reordered_byte_tables_fall_back_and_native_representations_compare_by_value() +{ + let field = NativeField::::new(); + for permuted in [false, true] { + let program = pairs(field, permuted); + let mut overrides = MapOverrides::new(); + register_maps(&program, &mut overrides).unwrap(); + let mut record = + MapRecord::new(overrides.bind(&program).unwrap().remove(0)); + for one in [field.one(), Goldilocks::new(field.modulus() + 1)] { + record.call(&[one, field.zero()], &mut []).unwrap(); + } + let row = if permuted { 0 } else { 256 }; + assert_eq!(record.counts.iter().filter(|&&count| count != 0).count(), 1); + assert_eq!(record.counts[row], 2); + assert_eq!(record.binding.input(row), [field.one(), field.zero()]); + } +} diff --git a/crates/aiur/src/lookup_budget.rs b/crates/aiur/src/lookup_budget.rs deleted file mode 100644 index 023d466c1..000000000 --- a/crates/aiur/src/lookup_budget.rs +++ /dev/null @@ -1,34 +0,0 @@ -// Copyright (c) 2026 Argument Computer Corporation. -// SPDX-License-Identifier: MIT OR Apache-2.0 - -use multi_stark::p3_field::PrimeField64; - -use crate::G; - -/// Upper bound on unit lookup consumers: one public claim plus every -/// lookup slot of every active trace row. Provider slots also count, making -/// this conservative without relying on witness multiplicities. Degrees -/// are indexed by active position; slot counts use canonical circuit order. -/// Reject malformed alignment and any bound reaching the characteristic. -pub(crate) fn lookup_query_bound( - slot_counts: impl ExactSizeIterator, - active: &[bool], - log_degrees: &[u8], -) -> Option { - if slot_counts.len() != active.len() || !active.contains(&true) { - return None; - } - let mut degrees = log_degrees.iter(); - let mut total = 1_u64; - for (slots, &is_active) in slot_counts.zip(active) { - if is_active { - let height = 1_u64.checked_shl(u32::from(*degrees.next()?))?; - let count = height.checked_mul(u64::try_from(slots).ok()?)?; - total = total.checked_add(count)?; - if total >= G::ORDER_U64 { - return None; - } - } - } - degrees.next().is_none().then_some(total) -} diff --git a/crates/aiur/src/lookup_groups.rs b/crates/aiur/src/lookup_groups.rs deleted file mode 100644 index a26d29328..000000000 --- a/crates/aiur/src/lookup_groups.rs +++ /dev/null @@ -1,184 +0,0 @@ -// Copyright (c) 2026 Argument Computer Corporation. -// SPDX-License-Identifier: MIT OR Apache-2.0 - -//! Choose lookup groups from the compiled degrees and the FFT tradeoff. -//! This runs before exposing the system or constructing its transcript. - -use multi_stark::{ - expr::Source, - graph::Node, - lookup::{ - MAX_LOOKUP_GROUP, logup_constraint_count, logup_max_degree, stage2_width, - }, - system::Circuit, -}; - -use crate::G; - -/// The group-dependent part of `Aiur.fftCost`, divided by row height. -/// For h >= 2 it is `slope * log2(h) + intercept`; h = 1 uses the -/// repository model's clamped transform cost. Main-trace work cancels. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -struct FftCost { - one: u128, - two: u128, - slope: u128, - intercept: u128, -} - -impl FftCost { - fn new( - stage2: usize, - quotient: usize, - blowup: usize, - degree: usize, - ) -> Option { - if !quotient.is_power_of_two() || !blowup.is_power_of_two() { - return None; - } - let log_q = u128::from(quotient.ilog2()); - let log_b = u128::from(blowup.ilog2()); - let qd = (quotient as u128).checked_mul(degree as u128)?; - let b = blowup as u128; - let trace = (b + 1).checked_mul(stage2 as u128)?; - let slope = (b + 1).checked_mul((stage2 as u128).checked_add(qd)?)?; - let intercept = - qd.checked_mul(log_q.checked_add(b.checked_mul(log_b)?)?)?; - let one = trace.checked_add(qd.checked_mul( - log_q.max(1).checked_add(b.checked_mul(log_b.max(1))?)?, - )?)?; - let two = slope.checked_add(intercept)?; - Some(Self { one, two, slope, intercept }) - } - - /// These three comparisons imply no larger FFT cost for every integer - /// height h >= 1, including both padded and raw-height statistics. - fn no_worse_than(self, other: Self) -> bool { - self.one <= other.one && self.two <= other.two && self.slope <= other.slope - } - - fn score(self) -> (u128, u128, u128) { - (self.slope, self.intercept, self.one) - } -} - -fn max_degree(circuit: &Circuit, group: usize) -> usize { - circuit - .graph - .max_constraint_degree - .max(logup_max_degree(&circuit.graph, group)) as usize -} - -fn quotient_degree(circuit: &Circuit, group: usize) -> Option { - (max_degree(circuit, group).max(2) - 1).checked_next_power_of_two() -} - -/// The pinned backend compiles user constraints and lookup expressions only; -/// its logUp constraints are evaluated directly from this circuit metadata. -/// Its prover key contains only preprocessed PCS data, which grouping does -/// not change. Keep all derived metadata synchronized before either is used. -pub(crate) fn set_group(circuit: &mut Circuit, group: usize, degree: usize) { - circuit.lookup_group_size = group; - circuit.stage_2_width = stage2_width(circuit.num_lookups, group, degree); - circuit.constraint_count = circuit.graph.zeros.len() - + logup_constraint_count(circuit.num_lookups, group, degree); - circuit.max_constraint_degree = max_degree(circuit, group); -} - -pub(crate) fn retune(circuit: &mut Circuit, blowup: usize, degree: usize) { - // Aiur's authored constraints never refer to stage 2. Retain the layout - // if a future circuit does: changing its column count would need a - // separate proof that those references still have the intended meaning. - if circuit - .graph - .nodes - .iter() - .any(|node| matches!(node, Node::Var(col) if col.source == Source::Stage2)) - { - return; - } - let Some(baseline) = FftCost::new( - circuit.stage_2_width, - circuit.quotient_degree(), - blowup, - degree, - ) else { - return; - }; - let mut best_group = circuit.lookup_group_size; - let mut best_cost = baseline; - for group in 1..=circuit.num_lookups.clamp(1, MAX_LOOKUP_GROUP) { - let Some(quotient) = quotient_degree(circuit, group) else { continue }; - if quotient > blowup { - continue; - } - let Some(cost) = FftCost::new( - stage2_width(circuit.num_lookups, group, degree), - quotient, - blowup, - degree, - ) else { - continue; - }; - if cost.no_worse_than(baseline) && cost.score() < best_cost.score() { - best_group = group; - best_cost = cost; - } - } - set_group(circuit, best_group, degree); -} - -#[cfg(test)] -mod tests { - use super::*; - - fn cost_at(stage2: usize, quotient: usize, blowup: usize, h: usize) -> f64 { - let [stage2, quotient, blowup, h] = [stage2, quotient, blowup, h] - .map(|n| f64::from(u32::try_from(n).unwrap())); - let transform = |n: f64| n * n.max(2.0).log2(); - (blowup + 1.0) * stage2 * transform(h) - + 2.0 * transform(quotient * h) - + 2.0 * quotient * transform(blowup * h) - } - - #[test] - fn fft_dominance_preserves_cost_at_small_and_large_heights() { - for blowup in [1, 2, 4, 8] { - for before_q in [1, 2, 4, 8] { - for after_q in [1, 2, 4, 8] { - for before_s2 in [2, 4, 8, 16, 32, 128] { - for after_s2 in [2, 4, 8, 16, 32, 128] { - let before = - FftCost::new(before_s2, before_q, blowup, 2).unwrap(); - let after = FftCost::new(after_s2, after_q, blowup, 2).unwrap(); - if after.no_worse_than(before) { - for h in [1, 2, 3, 7, 16, 255, 1_024, 65_536, 1 << 30] { - assert!( - cost_at(after_s2, after_q, blowup, h) - <= cost_at(before_s2, before_q, blowup, h) - ); - } - } - } - } - } - } - } - } - - #[test] - fn fft_cost_rejects_invalid_dimensions_and_overflow() { - assert!(FftCost::new(1, 0, 4, 2).is_none()); - assert!(FftCost::new(1, 3, 4, 2).is_none()); - assert!(FftCost::new(1, 2, 3, 2).is_none()); - assert!( - FftCost::new( - usize::MAX, - 1 << (usize::BITS - 1), - 1 << (usize::BITS - 1), - usize::MAX - ) - .is_none() - ); - } -} diff --git a/crates/aiur/src/lookup_shapes.rs b/crates/aiur/src/lookup_shapes.rs deleted file mode 100644 index 170ed5bcc..000000000 --- a/crates/aiur/src/lookup_shapes.rs +++ /dev/null @@ -1,229 +0,0 @@ -// Copyright (c) 2026 Argument Computer Corporation. -// SPDX-License-Identifier: MIT OR Apache-2.0 - -//! Structural checks required by zero-padded function lookup messages. -//! Inputs and outputs have no separators in the message. -//! Their boundaries must agree at every constrained call and public claim. - -use multi_stark::p3_field::PrimeField64; - -use crate::{ - G, - bytecode::{Block, Ctrl, Op, Toplevel}, - function_channel, -}; - -fn canonical_size(size: usize) -> bool { - u64::try_from(size).is_ok_and(|size| size < G::ORDER_U64) -} - -#[derive(Clone, Copy)] -enum ReturnArity { - NoReturns, - Exact(usize), - Inconsistent, -} - -impl ReturnArity { - fn merge(self, other: Self) -> Self { - match (self, other) { - (Self::NoReturns, arity) | (arity, Self::NoReturns) => arity, - (Self::Exact(a), Self::Exact(b)) if a == b => Self::Exact(a), - _ => Self::Inconsistent, - } - } - - fn accepts(self, size: usize) -> bool { - match self { - Self::NoReturns => true, - Self::Exact(arity) => arity == size, - Self::Inconsistent => false, - } - } -} - -/// Cached for public constrained entries in the system's immutable program. -pub(crate) struct ClaimShape { - inputs: usize, - outputs: ReturnArity, -} - -impl Block { - fn return_arity(&self) -> ReturnArity { - match &self.ctrl { - Ctrl::Return(_, values) => ReturnArity::Exact(values.len()), - Ctrl::Yield(..) => ReturnArity::NoReturns, - Ctrl::Match(_, branches, fallback) => branches - .values() - .chain(fallback.iter().map(Box::as_ref)) - .fold(ReturnArity::NoReturns, |arity, block| { - arity.merge(block.return_arity()) - }), - Ctrl::MatchContinue(_, branches, fallback, _, _, _, continuation) => { - branches - .values() - .chain(fallback.iter().map(Box::as_ref)) - .fold(continuation.return_arity(), |arity, block| { - arity.merge(block.return_arity()) - }) - }, - } - } - - /// Every function return, including an early return from a continuation - /// arm, has this output arity. Yields return to their own continuation. - /// Kept as an independent recursive reference for the cached summary. - #[cfg(test)] - pub(crate) fn returns_have_size(&self, size: usize) -> bool { - match &self.ctrl { - Ctrl::Return(_, values) => values.len() == size, - Ctrl::Yield(..) => true, - Ctrl::Match(_, branches, fallback) => { - branches.values().all(|block| block.returns_have_size(size)) - && fallback.as_ref().is_none_or(|block| block.returns_have_size(size)) - }, - Ctrl::MatchContinue(_, branches, fallback, _, _, _, continuation) => { - branches.values().all(|block| block.returns_have_size(size)) - && fallback.as_ref().is_none_or(|block| block.returns_have_size(size)) - && continuation.returns_have_size(size) - }, - } - } - - fn check_lookup_shapes( - &self, - program: &Toplevel, - return_arities: &[ReturnArity], - yield_size: Option, - ) -> Result<(), &'static str> { - for op in &self.ops { - match op { - Op::Call(index, inputs, outputs, false) => { - let Some(callee) = program.functions.get(*index) else { - return Err("constrained call refers to a missing function"); - }; - if !callee.constrained { - return Err("constrained call refers to an unconstrained function"); - } - if callee.layout.input_size != inputs.len() { - return Err("constrained call input arity differs from its callee"); - } - if !return_arities[*index].accepts(*outputs) { - return Err( - "constrained call output arity differs from its callee", - ); - } - }, - Op::Store(values) if !canonical_size(values.len()) => { - return Err("memory width is not a canonical field element"); - }, - Op::Load(size, _) if !canonical_size(*size) => { - return Err("memory width is not a canonical field element"); - }, - _ => {}, - } - } - match &self.ctrl { - Ctrl::Return(..) => {}, - Ctrl::Yield(_, values) => { - if yield_size != Some(values.len()) { - return Err("yield arity differs from its enclosing continuation"); - } - }, - Ctrl::Match(_, branches, fallback) => { - for block in branches.values() { - block.check_lookup_shapes(program, return_arities, yield_size)?; - } - if let Some(block) = fallback { - block.check_lookup_shapes(program, return_arities, yield_size)?; - } - }, - Ctrl::MatchContinue(_, branches, fallback, size, _, _, continuation) => { - for block in branches.values() { - block.check_lookup_shapes(program, return_arities, Some(*size))?; - } - if let Some(block) = fallback { - block.check_lookup_shapes(program, return_arities, Some(*size))?; - } - continuation.check_lookup_shapes( - program, - return_arities, - yield_size, - )?; - }, - } - Ok(()) - } -} - -impl Toplevel { - /// Check the static boundaries of all constrained function messages. - /// This does not check value indices, layouts or arithmetic constraints. - pub fn validate_lookup_shapes(&self) -> Result<(), &'static str> { - self.checked_claim_shapes().map(|_| ()) - } - - pub(crate) fn checked_claim_shapes( - &self, - ) -> Result>, &'static str> { - if !canonical_size(self.functions.len()) { - return Err("function index domain exceeds the field characteristic"); - } - if self.memory_sizes.iter().any(|&size| !canonical_size(size)) { - return Err("memory width is not a canonical field element"); - } - // Summarize each constrained body once, then reuse the result at every - // call site and public verification. Yields do not return from functions. - let return_arities: Vec<_> = self - .functions - .iter() - .map(|function| { - if function.constrained { - function.body.return_arity() - } else { - ReturnArity::NoReturns - } - }) - .collect(); - for function in &self.functions { - if function.constrained { - function.body.check_lookup_shapes(self, &return_arities, None)?; - } - } - Ok( - self - .functions - .iter() - .zip(return_arities) - .map(|(function, outputs)| { - (function.entry && function.constrained).then_some(ClaimShape { - inputs: function.layout.input_size, - outputs, - }) - }) - .collect(), - ) - } -} - -pub(crate) fn valid_claim_shape( - shapes: &[Option], - claim: &[G], -) -> bool { - let [channel, index, arguments @ ..] = claim else { - return false; - }; - if *channel != function_channel() { - return false; - } - let Ok(index) = usize::try_from(index.as_canonical_u64()) else { - return false; - }; - let Some(Some(shape)) = shapes.get(index) else { - return false; - }; - arguments - .len() - .checked_sub(shape.inputs) - .is_some_and(|outputs| shape.outputs.accepts(outputs)) -} diff --git a/crates/aiur/src/maps.rs b/crates/aiur/src/maps.rs new file mode 100644 index 000000000..85dd6e905 --- /dev/null +++ b/crates/aiur/src/maps.rs @@ -0,0 +1,274 @@ +//! Optional host implementations of static maps. Bindings affect candidate +//! execution/witness generation only; the original tables certify every result. +use crate::bytecode::{CheckedProgram, Instruction, Layout, Program}; +use crate::field::{FieldBackend, PrimeField}; +use crate::host::{self, MapBinder, MapCalls}; +use crate::table::TableIndex; +use std::{collections::HashMap, fmt, sync::Arc}; + +/// Flat inputs and a zeroed, fixed-width output buffer. Returns the row index +/// in the map's original tables. Providers must reject inputs outside their +/// domain, be deterministic, and may capture configuration. They never define +/// table data. Inputs and outputs use the executor's field elements directly. +pub type MapFunction = + dyn Fn(&[F], &mut [F]) -> Result + Send + Sync; + +struct Override { + inputs: usize, + outputs: usize, + function: Arc>, + bind_registers: Option>>, +} + +/// Names, flat arities, and row numbering are checked once when preparing an +/// executor. Maps without an override use their immutable input/output tables. +pub struct MapOverrides { + entries: HashMap>, +} + +impl Default for MapOverrides { + fn default() -> Self { + Self { entries: HashMap::new() } + } +} +impl MapOverrides { + pub fn new() -> Self { + Self::default() + } + + pub fn insert( + &mut self, + name: impl Into, + inputs: usize, + outputs: usize, + function: impl Fn(&[F], &mut [F]) -> Result + + Send + + Sync + + 'static, + ) -> Result<(), String> { + let name = name.into(); + if self.entries.contains_key(&name) { + return Err(format!("duplicate map override {name:?}")); + } + self.entries.insert( + name, + Override { + inputs, + outputs, + function: Arc::new(function), + bind_registers: None, + }, + ); + Ok(()) + } + + /// Register a fixed-arity provider returning every output by value. The + /// executor specializes a complete register/counter handler around C, + /// retaining one indirect call per invocation. Trace replay uses the same C. + /// This has the same domain, row-index and determinism contract as `insert`. + pub fn insert_fixed( + &mut self, + name: impl Into, + function: impl Fn([F; INPUTS]) -> Result<(usize, [F; OUTPUTS]), String> + + Send + + Sync + + 'static, + ) -> Result<(), String> + where + F: Copy + Send + Sync + 'static, + { + let name = name.into(); + if self.entries.contains_key(&name) { + return Err(format!("duplicate map override {name:?}")); + } + let function = Arc::new(function); + let bind_registers = host::map_binder(function.clone()); + self.entries.insert( + name, + Override { + inputs: INPUTS, + outputs: OUTPUTS, + function: Arc::new(move |args, output| { + let input = + args.try_into().map_err(|_| "map input width mismatch")?; + let (row, answer) = function(input)?; + output.copy_from_slice(&answer); + Ok(row) + }), + bind_registers: Some(bind_registers), + }, + ); + Ok(()) + } + + pub(crate) fn bind_registers>( + &self, + checked: &CheckedProgram, + ) -> Vec> { + checked + .execution_functions + .iter() + .map(|f| { + f.code + .iter() + .map(|instruction| { + let Instruction::Call { function, args, dest } = instruction else { + return None; + }; + let id = function.checked_sub(checked.program.functions.len())?; + let map = checked.program.maps.get(id)?; + let binder = + self.entries.get(&map.name)?.bind_registers.as_ref()?; + binder( + args, + dest, + host::output_check(&checked.outputs[*function], checked.field), + ) + }) + .collect() + }) + .collect() + } + + pub(crate) fn bind>( + &self, + checked: &CheckedProgram, + ) -> Result>>, String> + where + F: Copy, + { + for name in self.entries.keys() { + if !checked.program.maps.iter().any(|map| &map.name == name) { + return Err(format!("unknown map override {name:?}")); + } + } + checked + .program + .maps + .iter() + .enumerate() + .map(|(i, map)| { + let callable = checked.program.functions.len() + i; + let provider = self.entries.get(&map.name); + if provider.is_some_and(|p| { + p.inputs != checked.inputs[callable].width() + || p.outputs != checked.outputs[callable].width() + }) { + return Err(format!("map override {:?} signature mismatch", map.name)); + } + if let Some(provider) = provider { + // Verify the numbering once, outside execution/population. + // Answers remain untrusted witnesses certified by the tables. + let mut output = vec![checked.field.zero(); provider.outputs]; + for (row, args) in checked.tables[map.input].iter().enumerate() { + output.fill(checked.field.zero()); + let actual = (provider.function)(args, &mut output).map_err(|e| { + format!("map override {:?} at row {row}: {e}", map.name) + })?; + if actual != row { + return Err(format!( + "map override {:?} row index mismatch: expected {row}, got {actual}", + map.name + )); + } + } + } + Ok(Arc::new(PreparedMap { + program: checked.program.clone(), + tables: checked.tables.clone(), + id: i, + input_width: checked.inputs[callable].width(), + input: map.input, + output: map.output, + index: checked.map_indexes[map.input].as_ref().unwrap().clone(), + output_layout: checked.outputs[callable].clone(), + field: checked.field, + function: provider.map(|p| p.function.clone()), + })) + }) + .collect() + } +} + +pub(crate) struct PreparedMap { + pub(crate) program: Arc, + tables: Arc>>>, + pub(crate) id: usize, + input_width: usize, + input: usize, + output: usize, + index: Arc>, + output_layout: Layout, + field: B, + function: Option>>, +} + +impl fmt::Debug for PreparedMap { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("PreparedMap") + .field("input", &self.input) + .field("output", &self.output) + .field("overridden", &self.function.is_some()) + .finish() + } +} + +impl PreparedMap { + pub(crate) fn rows(&self) -> usize { + self.tables[self.input].len() + } + pub(crate) fn input(&self, row: usize) -> &[B::Element] { + &self.tables[self.input][row] + } + pub(crate) fn output(&self, row: usize) -> &[B::Element] { + &self.tables[self.output][row] + } + pub(crate) fn row(&self, args: &[B::Element]) -> Result { + self.index.get(args).ok_or_else(|| "no table entry for map input".into()) + } + pub(crate) fn evaluate( + &self, + args: &[B::Element], + output: &mut [B::Element], + ) -> Result { + if args.len() != self.input_width + || output.len() != self.output_layout.width() + { + return Err("map argument/output width mismatch".into()); + } + if let Some(function) = &self.function { + output.fill(self.field.zero()); + let row = function(args, output)?; + // Representation checks are not table membership checks. In + // particular, a canonical field word need not be a valid byte. + self.output_layout.validate(output, self.field)?; + Ok(row) + } else { + let row = self.row(args)?; + output.copy_from_slice(self.output(row)); + Ok(row) + } + } +} + +/// Fixed-size multiplicities are the only per-execution table state. Inputs, +/// outputs, indexes, and closures are shared with the prepared executor. +#[derive(Clone, Debug)] +pub(crate) struct MapRecord { + pub(crate) binding: Arc>, + pub(crate) counts: Box<[u64]>, +} + +impl MapRecord { + pub(crate) fn new(binding: Arc>) -> Self { + Self { counts: vec![0; binding.rows()].into_boxed_slice(), binding } + } + pub(crate) fn call( + &mut self, + args: &[B::Element], + output: &mut [B::Element], + ) -> Result<(), String> { + let row = self.binding.evaluate(args, output)?; + host::bump(&mut self.counts, row) + } +} diff --git a/crates/aiur/src/memory.rs b/crates/aiur/src/memory.rs index 06aa6b72c..81b3ab478 100644 --- a/crates/aiur/src/memory.rs +++ b/crates/aiur/src/memory.rs @@ -1,186 +1,300 @@ -use std::ops::Range; - -use multi_stark::{ - expr::Expr, - lookup::{Lookup, LookupRowMut, LookupValues}, - p3_field::PrimeCharacteristicRing, - p3_matrix::dense::RowMajorMatrix, -}; -use rayon::{ - iter::{ - IndexedParallelIterator, IntoParallelRefMutIterator, ParallelIterator, - }, - slice::ParallelSliceMut, -}; - -use crate::{G, execute::QueryRecord, memory_channel, memseg_channel}; - -pub struct Memory { - pub(crate) width: usize, +//! Width-local, interned ROM. The record has stable indices for accounting; +//! pointers are indices within a width bucket. A representative store type is +//! retained only for host diagnostics, never for interning or circuit lookups. +use crate::bytecode::Type; +use hashbrown::HashTable; +use serde::{Serialize, Serializer}; +use std::hash::{Hash, Hasher}; + +#[derive(Clone, Copy, Debug, Serialize)] +pub struct CellRef<'a, F = u64> { + pub r#type: &'a Type, + pub value: &'a [F], +} + +#[derive(Clone, Copy, Debug, Serialize)] +pub struct MemoryEntryRef<'a, F = u64> { + pub address: usize, + pub cell: CellRef<'a, F>, + pub multiplicity: u64, +} + +#[derive(Clone, Debug)] +struct Slot { + address: usize, + type_id: usize, + offset: usize, + multiplicity: u64, +} + +#[derive(Clone, Debug)] +pub struct Memory { + pub(crate) budget: crate::budget::Budget, + base: usize, + end: u64, + types: Vec<(Type, usize)>, + words: Vec, + slots: Vec, + widths: Vec, + buckets: Vec>, + type_buckets: Vec, + // Stable record indices and cached hashes, with no second payload copy. + // Retained after execution so trace population can resolve stores directly. + index: HashTable<(u64, usize)>, } -impl Memory { - pub(super) fn lookup_args(size: G, ptr: G, values: &[G]) -> Vec { - let mut args = Vec::with_capacity(3 + values.len()); - args.extend([memory_channel(), size, ptr]); - args.extend(values); - args - } - - /// The segment-boundary message for pointer `ptr` of the width-`size` table. - pub fn memseg_args(size: G, ptr: G) -> [G; 3] { - [memseg_channel(), size, ptr] - } - - fn width(size: usize) -> usize { - // Multiplicity, selector, pointer and values. - 3 + size - } - - /// Returns the memory circuit together with its base-field constraints and - /// its lookups: the value pull on the memory channel, and the two - /// segment-boundary lookups on the `memseg` channel. - pub fn build(size: usize) -> (Self, Vec>, Vec>>) { - let multiplicity = Expr::main(0); - let selector = Expr::main(1); - let pointer = Expr::main(2); - let mut args = Vec::with_capacity(3 + size); - args.push(selector.clone() * Expr::constant(memory_channel())); - args.push(selector.clone() * Expr::constant(G::from_usize(size))); - args.push(selector.clone() * pointer.clone()); - for val_idx in 0..size { - let col = u32::try_from(3 + val_idx).expect("column index exceeds u32"); - args.push(selector.clone() * Expr::main(col)); +impl Memory { + pub(crate) fn new(types: impl Iterator) -> Self { + let types: Vec<_> = types.collect(); + let mut widths: Vec<_> = types.iter().map(|(_, width)| *width).collect(); + widths.sort_unstable(); + widths.dedup(); + let type_buckets = + types.iter().map(|(_, w)| widths.binary_search(w).unwrap()).collect(); + let buckets = vec![vec![]; widths.len()]; + Self { + budget: Default::default(), + base: 0, + end: u64::MAX, + types, + words: vec![], + slots: vec![], + widths, + buckets, + type_buckets, + index: HashTable::new(), } - let width = Self::width(size); - // The pull's multiplicity stays linear; the `multiplicity * (1 - is_real)` - // constraint below keeps a padding row from contributing even the zero - // message with a multiplicity of its own. - let value_pull = Lookup { multiplicity: -multiplicity.clone(), args }; - - // Segment boundaries. Every real row pushes `(memseg, size, ptr)` and - // pulls `(memseg, size, ptr + 1)`, both with multiplicity `sel`. With - // pointers incrementing across real rows, the interior terms telescope - // and the circuit contributes exactly one push of its first pointer and - // one pull of one past its last: the two end points of the table - // segment this trace holds, without any boundary column. The selector - // gates the multiplicities (not the Lagrange selectors, which are - // unnormalized and would weight the end points by the trace height). - let memseg = |ptr: Expr| { - vec![ - selector.clone() * Expr::constant(memseg_channel()), - selector.clone() * Expr::constant(G::from_usize(size)), - selector.clone() * ptr, - ] - }; - let one = || Expr::constant(G::ONE); - let segment_start = - Lookup { multiplicity: selector.clone(), args: memseg(pointer.clone()) }; - let segment_end = - Lookup { multiplicity: -selector.clone(), args: memseg(pointer + one()) }; - let lookups = vec![value_pull, segment_start, segment_end]; - - // Transition constraints (formerly the `Air::eval` body): the selector is - // boolean; a real next row implies a real current row; and the pointer - // increments by one across a real transition. - let is_real = Expr::main(1); - let is_real_next = Expr::main_next(1); - let ptr = Expr::main(2); - let ptr_next = Expr::main_next(2); - let is_real_transition = is_real_next * Expr::IsTransition; - let constraints = vec![ - is_real.clone() * (is_real.clone() - one()), - // Padding cannot supply a memory lookup with nonzero multiplicity. - multiplicity * (one() - is_real.clone()), - is_real_transition.clone() * (is_real - one()), - is_real_transition * (ptr + one() - ptr_next), - ]; + } - (Self { width }, constraints, lookups) - } - - /// The whole width-`size` table as one trace: [`Self::witness_data_range`] - /// over every pointer. - pub fn witness_data( - size: usize, - record: &QueryRecord, - slot_arg_widths: &[usize], - ) -> (RowMajorMatrix, LookupValues) { - let len = record.memory_queries.get(&size).map_or(0, |m| m.len()); - Self::witness_data_range(size, record, slot_arg_widths, 0..len) - } - - /// The rows of the width-`size` table at table indices `range`, as a trace - /// whose row `i` carries pointer `record.pointer_base + range.start + i`. - /// An empty range yields an EMPTY trace: the prover deactivates the - /// circuit, so it is neither committed nor opened. - pub fn witness_data_range( - size: usize, - record: &QueryRecord, - slot_arg_widths: &[usize], - range: Range, - ) -> (RowMajorMatrix, LookupValues) { - let width = Self::width(size); - let height_no_padding = range.len(); - let height = if height_no_padding == 0 { - 0 - } else { - height_no_padding.next_power_of_two() - }; - - let mut rows = G::zero_vec(height * width); - let rows_no_padding = &mut rows[0..height_no_padding * width]; - - if height_no_padding > 0 { - let queries = record.memory_queries.get(&size).expect("Invalid size"); - let size_g = G::from_usize(size); - let populate = - |i: usize, - row: &mut [G], - row_lookups: Option<&mut LookupRowMut<'_, G>>| { - let index = range.start + i; - let (values, result) = - queries.get_index(index).expect("pointer in range"); - row[0] = result.multiplicity; - row[1] = G::ONE; - row[2] = G::from_usize(record.pointer_base + index); - row[3..].copy_from_slice(values); - - let Some(row_lookups) = row_lookups else { return }; - let args = Self::lookup_args(size_g, row[2], &row[3..]); - row_lookups.pull(0, row[0], &args); - row_lookups.push(1, G::ONE, &Self::memseg_args(size_g, row[2])); - row_lookups.pull( - 2, - G::ONE, - &Self::memseg_args(size_g, row[2] + G::ONE), - ); - }; - if crate::trace::trace_only_lookups() || slot_arg_widths.is_empty() { - rows_no_padding - .par_chunks_mut(width) - .enumerate() - .for_each(|(i, row)| populate(i, row, None)); - let trace = RowMajorMatrix::new(rows, width); - return (trace, LookupValues::shape_only(height, slot_arg_widths)); + pub fn len(&self) -> usize { + self.slots.len() + } + pub fn is_empty(&self) -> bool { + self.slots.is_empty() + } + + pub(crate) fn set_range( + &mut self, + start: u64, + end: u64, + ) -> Result<(), &'static str> { + if !self.is_empty() || start >= end { + return Err("invalid empty ROM range"); + } + self.base = usize::try_from(start).map_err(|_| "ROM base overflow")?; + self.end = end; + Ok(()) + } + + #[inline] + pub fn get(&self, index: usize) -> Option> { + let slot = self.slots.get(index)?; + let (ty, width) = &self.types[slot.type_id]; + Some(MemoryEntryRef { + address: slot.address, + cell: CellRef { + r#type: ty, + value: &self.words[slot.offset..slot.offset + width], + }, + multiplicity: slot.multiplicity, + }) + } + + pub fn iter(&self) -> impl ExactSizeIterator> { + (0..self.len()).map(|i| self.get(i).unwrap()) + } + + #[cfg(feature = "parallel")] + pub(crate) fn par_iter( + &self, + ) -> impl rayon::iter::IndexedParallelIterator> + { + use rayon::prelude::*; + (0..self.len()).into_par_iter().map(|i| self.get(i).unwrap()) + } + + #[inline] + pub(crate) fn index_for_type( + &self, + type_id: usize, + address: usize, + ) -> Option { + self.buckets[self.type_buckets[type_id]] + .get(address.checked_sub(self.base)?) + .copied() + } + + pub fn get_by_width( + &self, + width: usize, + address: usize, + ) -> Option> { + let bucket = self.widths.binary_search(&width).ok()?; + self.get(*self.buckets[bucket].get(address.checked_sub(self.base)?)?) + } + + /// Record indices in consecutive width-local address order. The caller may + /// have an unused circuit width absent from this execution's type layouts. + #[cfg(feature = "stark")] + pub(crate) fn indices_for_width(&self, width: usize) -> &[usize] { + self.widths.binary_search(&width).map_or(&[], |i| &self.buckets[i]) + } + + #[inline] + pub(crate) fn address(&self, index: usize) -> usize { + self.slots[index].address + } + + #[inline] + fn matches(&self, index: usize, words: &[F]) -> bool { + let slot = &self.slots[index]; + self.words[slot.offset..slot.offset + self.types[slot.type_id].1] == *words + } + + // Keep this in the store/population hot loops, as QueryTable::lookup does. + // Otherwise returning the hash plus an optional index spills to the stack. + #[inline(always)] + fn lookup(&self, words: &[F]) -> (u64, Option) { + let mut hasher = rustc_hash::FxHasher::default(); + hasher.write_usize(words.len()); + for word in words { + word.hash(&mut hasher); + } + let hash = hasher.finish(); + let index = self + .index + .find(hash, |&(cached, i)| cached == hash && self.matches(i, words)); + (hash, index.map(|&(_, i)| i)) + } + + #[inline] + pub(crate) fn address_of(&self, words: &[F]) -> Option { + self.lookup(words).1.map(|i| self.address(i)) + } + + /// The only insertion path: equal encodings share one cell, regardless of + /// nominal type, and each width's addresses form a consecutive prefix. + #[inline] + pub(crate) fn intern( + &mut self, + type_id: usize, + words: &[F], + modulus: u64, + ) -> Result { + debug_assert_eq!(words.len(), self.types[type_id].1); + let (hash, found) = self.lookup(words); + if let Some(index) = found { + return Ok(index); + } + self.budget.vector(&self.words, words.len())?; + self.budget.vector(&self.slots, 1)?; + self + .budget + .hash::<(u64, usize)>(self.index.len(), self.index.capacity())?; + let bucket = &mut self.buckets[self.type_buckets[type_id]]; + self.budget.vector(bucket, 1)?; + let address = + self.base.checked_add(bucket.len()).ok_or("ROM address overflow")?; + if u64::try_from(address).map_err(|_| "ROM address overflow")? + >= modulus.min(self.end) + { + return Err("ROM exceeds field capacity".into()); + } + let index = self.slots.len(); + self.index.insert_unique(hash, (hash, index), |&(hash, _)| hash); + let offset = self.words.len(); + self.words.extend_from_slice(words); + bucket.push(index); + self.slots.push(Slot { address, type_id, offset, multiplicity: 0 }); + Ok(index) + } + + #[inline] + pub(crate) fn multiplicity_mut(&mut self, address: usize) -> &mut u64 { + &mut self.slots[address].multiplicity + } +} + +impl Serialize for Memory { + fn serialize(&self, serializer: S) -> Result { + serializer.collect_seq(self.iter()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::execute::{Cell, MemoryEntry}; + + #[test] + fn retained_index_survives_growth_cloning_and_width_aliases() { + let mut memory = Memory::new( + [ + (Type::Field, 1), + (Type::Tuple { items: vec![Type::Field] }, 1), + (Type::Tuple { items: vec![Type::Field; 2] }, 2), + (Type::Tuple { items: vec![] }, 0), + ] + .into_iter(), + ); + for value in 0..1024 { + memory.intern(2, &[value, 0], 65537).unwrap(); + memory.intern(3, &[], 65537).unwrap(); + let index = memory.intern(0, &[1023 - value], 65537).unwrap(); + assert_eq!(memory.intern(1, &[1023 - value], 65537).unwrap(), index); + } + assert_eq!(memory.len(), 2049); + let mut copy = memory.clone(); + for value in 1024..4096 { + copy.intern(0, &[value], 65537).unwrap(); + } + // Independently scan the record: indices refer to cells, not allocations + // or the other width's local address, even after clone/arena/hash growth. + for record in [&memory, ©] { + for entry in record.iter() { + assert_eq!(record.address_of(entry.cell.value), Some(entry.address)); } - // Builder rows start zeroed (`Lookup::empty()`), so padding rows need - // no writes at all. - let mut builder = LookupValues::builder(height, slot_arg_widths); - let mut row_writers = builder.rows_mut(); - rows_no_padding - .par_chunks_mut(width) - .zip(row_writers[..height_no_padding].par_iter_mut()) - .enumerate() - .for_each(|(i, (row, row_lookups))| { - populate(i, row, Some(row_lookups)) - }); - drop(row_writers); - let trace = RowMajorMatrix::new(rows, width); - return (trace, builder.finish()); + assert_eq!(record.address_of(&[7]), Some(1016)); + assert_eq!(record.address_of(&[7, 0]), Some(7)); + assert_eq!(record.address_of(&[]), Some(0)); + assert_eq!(record.address_of(&[7, 0, 0]), None); } + assert_eq!(memory.address_of(&[1024]), None); + assert_eq!(copy.address_of(&[1024]), Some(1024)); + } - let trace = RowMajorMatrix::new(rows, width); - (trace, LookupValues::shape_only(height, slot_arg_widths)) + #[test] + fn borrowed_cells_preserve_wire_format_and_zero_width_addresses() { + let unit = Type::Tuple { items: vec![] }; + let mut memory = + Memory::new([(Type::Field, 1), (unit.clone(), 0)].into_iter()); + memory.intern(0, &[7], 17).unwrap(); + memory.intern(1, &[], 17).unwrap(); + *memory.multiplicity_mut(0) = 3; + *memory.multiplicity_mut(1) = 1; + assert!(memory.get(2).is_none()); + assert!(memory.matches(1, &[])); + assert!(!memory.matches(1, &[7])); + assert_eq!(memory.get_by_width(1, 0).unwrap().cell.value, &[7]); + assert!(memory.get_by_width(0, 0).unwrap().cell.value.is_empty()); + let expected = vec![ + MemoryEntry { + address: 0, + cell: Cell { r#type: Type::Field, value: vec![7] }, + multiplicity: 3, + }, + MemoryEntry { + address: 0, + cell: Cell { r#type: unit, value: vec![] }, + multiplicity: 1, + }, + ]; + assert_eq!( + serde_json::to_value(&memory).unwrap(), + serde_json::to_value(expected).unwrap() + ); + let mut copy = memory.clone(); + *copy.multiplicity_mut(0) = 8; + assert_eq!(memory.get(0).unwrap().multiplicity, 3); } } diff --git a/crates/aiur/src/query.rs b/crates/aiur/src/query.rs new file mode 100644 index 000000000..02a770b59 --- /dev/null +++ b/crates/aiur/src/query.rs @@ -0,0 +1,448 @@ +//! Fixed-width query storage, indexed independently for each callable. Keys and +//! outputs live in flat arenas; hash buckets contain stable row numbers. No +//! pointer into a hash table is held while recursive calls can grow it. +use crate::execute::QueryInput; +use crate::field::{FieldBackend, PrimeField}; +use hashbrown::HashTable; +use serde::Serialize; +use std::hash::{Hash, Hasher}; + +// Arity belongs to the table. Hash field elements rather than their raw memory +// so equal field values always share a key, even with redundant representations. +#[inline] +pub(crate) fn hash_words(words: &[F]) -> u64 { + let mut hash = rustc_hash::FxHasher::default(); + for word in words { + word.hash(&mut hash); + } + hash.finish() +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize)] +pub struct QueryInputRef<'a, F = u64> { + pub function: usize, + pub args: &'a [F], +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)] +pub struct QueryOutputRef<'a, F = u64> { + pub output: &'a [F], + pub multiplicity: u64, +} + +#[derive(Clone, Debug)] +pub(crate) struct QueryTable { + budget: crate::budget::Budget, + field: B, + pub(crate) static_map: Option>, + input_width: usize, + output_width: usize, + stride: usize, + rows: Vec>, + counts: Vec, + chunk_shift: u32, + chunk_mask: usize, + hashes: Vec, + index: HashTable, + // A bounded front index for dense unary keys (especially ROM addresses). + // Sparse or large keys still use the exact hash index. Entries are row IDs, + // including pending rows, so this cannot bypass cycle detection. + dense_index: Vec, +} + +impl QueryTable { + fn new(input_width: usize, output_width: usize, field: B) -> Self { + let stride = input_width + output_width; + // At most 4096 rows / 512 KiB per chunk (one full row if wider). + let chunk_shift = + (524288 / std::mem::size_of::().max(1) / stride.max(1)) + .max(1) + .ilog2() + .min(12); + Self { + budget: Default::default(), + field, + counts: vec![], + static_map: None, + input_width, + output_width, + stride, + chunk_shift, + chunk_mask: (1 << chunk_shift) - 1, + rows: vec![], + hashes: vec![], + index: HashTable::new(), + dense_index: vec![], + } + } + + #[inline(always)] + fn row(&self, row: usize) -> &[B::Element] { + let start = (row & self.chunk_mask) * self.stride; + &self.rows[row >> self.chunk_shift][start..start + self.stride] + } + + #[inline(always)] + fn row_mut(&mut self, row: usize) -> &mut [B::Element] { + let start = (row & self.chunk_mask) * self.stride; + &mut self.rows[row >> self.chunk_shift][start..start + self.stride] + } + + /// Recorded rows in storage order for bulk transfer: chunks of + /// `rows_per_chunk` rows of `stride` words (inputs, then outputs). Static + /// maps keep their rows elsewhere and have none here. + #[cfg(feature = "cuda")] + pub(crate) fn row_chunks(&self) -> (&[Vec], usize, usize) { + (&self.rows, self.stride, 1 << self.chunk_shift) + } + + /// Each recorded row's multiplicity; zero marks a pending query. + #[cfg(feature = "cuda")] + pub(crate) fn counts(&self) -> &[u64] { + &self.counts + } + + #[inline(always)] + pub(crate) fn input(&self, row: usize) -> &[B::Element] { + if let Some(map) = &self.static_map { + return map.binding.input(row); + } + &self.row(row)[..self.input_width] + } + + #[inline(always)] + pub(crate) fn output(&self, row: usize) -> QueryOutputRef<'_, B::Element> { + if let Some(map) = &self.static_map { + return QueryOutputRef { + output: map.binding.output(row), + multiplicity: map.counts[row], + }; + } + let values = self.row(row); + QueryOutputRef { + output: &values[self.input_width..self.input_width + self.output_width], + multiplicity: self.counts[row], + } + } + + #[inline(always)] + pub(crate) fn lookup(&self, args: &[B::Element]) -> (u64, Option) { + debug_assert!( + self.static_map.is_none(), + "static maps use their prepared row index" + ); + let hash = hash_words(args); + if let [key] = args + && self.input_width == 1 + && let Ok(key) = usize::try_from(self.field.to_u64(*key)) + && let Some(&row) = self.dense_index.get(key) + && row != usize::MAX + { + return (hash, Some(row)); + } + (hash, self.index.find(hash, |&row| self.input(row) == args).copied()) + } + + /// A zero count marks a pending query, which must never supply an output. + #[inline(always)] + pub(crate) fn start( + &mut self, + args: &[B::Element], + hash: u64, + ) -> Result { + debug_assert!(self.static_map.is_none()); + debug_assert_eq!(args.len(), self.input_width); + let row = self.len(); + if row & self.chunk_mask == 0 { + self.budget.vector(&self.rows, 1)?; + self.budget.reserve( + self + .stride + .saturating_mul(self.chunk_mask + 1) + .saturating_mul(std::mem::size_of::()), + )?; + self.rows.push(Vec::with_capacity(self.stride * (self.chunk_mask + 1))); + } + let values = self.rows.last_mut().unwrap(); + values.extend_from_slice(args); + values.resize(values.len() + self.output_width, self.field.zero()); + self.budget.vector(&self.counts, 1)?; + self.budget.vector(&self.hashes, 1)?; + self.budget.hash::(self.index.len(), self.index.capacity())?; + self.counts.push(0); + self.hashes.push(hash); + let hashes = &self.hashes; + self.index.insert_unique(hash, row, |&row| hashes[row]); + if let [key] = args + && let Ok(key) = usize::try_from(self.field.to_u64(*key)) + { + // Bound space by observed table size, with a small startup allowance + // and an absolute 8 MiB ceiling on 64-bit hosts. Never allocate in + // proportion to an arbitrary field element supplied as a key. + let limit = row.saturating_mul(2).clamp(64, 1 << 20); + if key < limit { + if key >= self.dense_index.len() { + let extra = + (key + 1).next_power_of_two().min(limit) - self.dense_index.len(); + self.budget.vector(&self.dense_index, extra)?; + self + .dense_index + .resize((key + 1).next_power_of_two().min(limit), usize::MAX); + } + self.dense_index[key] = row; + } + } + Ok(row) + } + + #[inline(always)] + pub(crate) fn finish(&mut self, row: usize, output: &[B::Element]) { + debug_assert_eq!(self.count(row), 0); + let start = self.input_width; + let end = start + self.output_width; + let values = self.row_mut(row); + values[start..end].copy_from_slice(output); + self.counts[row] = 1; + } + + #[inline(always)] + pub(crate) fn count(&self, row: usize) -> u64 { + if let Some(map) = &self.static_map { + return map.counts[row]; + } + self.counts[row] + } + + pub(crate) fn adjust_count( + &mut self, + row: usize, + count: u64, + add: bool, + ) -> Option<()> { + let value = &mut self.counts[row]; + *value = + if add { value.checked_add(count)? } else { value.checked_sub(count)? }; + Some(()) + } + + /// Number of stored slots. Fixed tables include rows with zero uses. + pub(crate) fn len(&self) -> usize { + if let Some(map) = &self.static_map { + return map.counts.len(); + } + self.hashes.len() + } + + pub(crate) fn widths(&self) -> (usize, usize) { + (self.input_width, self.output_width) + } + + #[inline(always)] + pub(crate) fn bump(&mut self, row: usize) -> Option<()> { + if let Some(map) = &mut self.static_map { + let count = &mut map.counts[row]; + *count = count.checked_add(1)?; + return Some(()); + } + let count = &mut self.counts[row]; + *count = count.checked_add(1)?; + Some(()) + } +} + +/// Read-only views of completed function queries and fixed-table row counts. +/// Map views borrow canonical inputs/results from the original tables; native +/// candidate results are checked by the caller circuits, not retained here. +/// Iteration allocates nothing and omits unused fixed-table rows. Query order +/// is unspecified for both functions and tables; it has no semantic meaning. +#[derive(Clone, Debug)] +pub struct QueryMap { + pub(crate) tables: Vec>, + pub(crate) budget: crate::budget::Budget, +} + +impl QueryMap { + pub(crate) fn new( + widths: impl Iterator, + field: B, + ) -> Self { + Self { + tables: widths.map(|(a, b)| QueryTable::new(a, b, field)).collect(), + budget: Default::default(), + } + } + pub(crate) fn reserve_with( + &mut self, + reservation: Option<&crate::budget::RecordReservation>, + ) { + self.budget = crate::budget::Budget(reservation.cloned()); + for table in &mut self.tables { + table.budget = self.budget.clone(); + } + } + pub fn len(&self) -> usize { + self + .tables + .iter() + .map(|table| match &table.static_map { + Some(map) => map.counts.iter().filter(|&&count| count != 0).count(), + None => table.len(), + }) + .sum() + } + pub fn is_empty(&self) -> bool { + self.tables.iter().all(|table| match &table.static_map { + Some(map) => map.counts.iter().all(|&count| count == 0), + None => table.len() == 0, + }) + } + pub fn get( + &self, + key: &QueryInput, + ) -> Option> { + self.get_ref(key.function, &key.args) + } + fn get_ref( + &self, + function: usize, + args: &[B::Element], + ) -> Option> { + let table = self.tables.get(function)?; + if let Some(map) = &table.static_map { + let row = map.binding.row(args).ok()?; + let multiplicity = *map.counts.get(row)?; + return (multiplicity != 0).then(|| QueryOutputRef { + output: map.binding.output(row), + multiplicity, + }); + } + table.lookup(args).1.map(|row| table.output(row)) + } + pub(crate) fn bind_maps( + &mut self, + maps: &[std::sync::Arc>], + ) { + let offset = self.tables.len() - maps.len(); + for (table, binding) in self.tables[offset..].iter_mut().zip(maps) { + table.static_map = Some(crate::maps::MapRecord::new(binding.clone())); + } + } + pub fn iter( + &self, + ) -> impl Iterator< + Item = (QueryInputRef<'_, B::Element>, QueryOutputRef<'_, B::Element>), + > { + self.tables.iter().enumerate().flat_map(|(function, table)| { + (0..table.len()) + .filter(move |&row| table.static_map.is_none() || table.count(row) != 0) + .map(move |row| { + ( + QueryInputRef { function, args: table.input(row) }, + table.output(row), + ) + }) + }) + } + pub fn keys(&self) -> impl Iterator> { + self.iter().map(|(key, _)| key) + } + pub fn values(&self) -> impl Iterator> { + self.iter().map(|(_, output)| output) + } +} + +impl PartialEq for QueryMap { + fn eq(&self, other: &Self) -> bool { + self.len() == other.len() + && self.iter().all(|(key, value)| { + other.get_ref(key.function, key.args) == Some(value) + }) + } +} +impl Eq for QueryMap {} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn fixed_tables_skip_unused_rows_and_compare_without_query_order() { + let field = PrimeField::new(97).unwrap(); + let program: crate::Program = serde_json::from_value(serde_json::json!({ + "version": 1, "modulus": 97, "enums": [], "functions": [], "entries": [], + "maps": [{"name": "id", "params": [{"kind": "field"}], + "result": {"kind": "tuple", "items": [{"kind": "field"}]}, + "input": 0, "output": 0}], + "tables": [{"name": "values", "type": {"kind": "tuple", "items": [{"kind": "field"}]}, + "rows": [[2], [0], [1]]}] + })) + .unwrap(); + let program = program.check().unwrap(); + let bindings = crate::maps::MapOverrides::new().bind(&program).unwrap(); + let mut queries = QueryMap::new([(1, 1)].into_iter(), field); + queries.bind_maps(&bindings); + assert!(queries.is_empty()); + assert_eq!(queries.len(), 0); + assert_eq!(queries.iter().count(), 0); + let mut reordered = queries.clone(); + for (record, order) in + [(&mut queries, [1, 2, 1]), (&mut reordered, [2, 1, 1])] + { + for input in order { + record.tables[0] + .static_map + .as_mut() + .unwrap() + .call(&[input], &mut [0]) + .unwrap(); + } + } + assert_eq!(queries, reordered); + assert!(!queries.is_empty()); + assert_eq!(queries.len(), 2); + assert_eq!(queries.iter().count(), 2); + assert!(queries.get_ref(0, &[0]).is_none()); + assert_eq!(queries.get_ref(0, &[1]).unwrap().multiplicity, 2); + assert_eq!(queries.get_ref(0, &[2]).unwrap().multiplicity, 1); + assert!(queries.values().all(|value| value.multiplicity != 0)); + } + + #[test] + fn dense_front_index_keeps_sparse_keys_and_arity_checks() { + let mut table = QueryTable::new(1, 1, PrimeField::new(97).unwrap()); + let early = table.start(&[80], table.lookup(&[80]).0).unwrap(); + table.finish(early, &[5]); + let large = table.start(&[u64::MAX], table.lookup(&[u64::MAX]).0).unwrap(); + table.finish(large, &[6]); + for key in 0..200 { + if key != 80 { + let row = table.start(&[key], table.lookup(&[key]).0).unwrap(); + table.finish(row, &[key]); + } + } + assert_eq!(table.lookup(&[80]).1, Some(early)); + assert_eq!(table.lookup(&[u64::MAX]).1, Some(large)); + assert!(table.lookup(&[0, 1]).1.is_none()); + assert!(table.lookup(&[]).1.is_none()); + assert!(table.dense_index.len() <= 2 * table.len()); + } + + #[test] + fn pending_rows_survive_growth_and_counts_do_not_wrap() { + let mut table = QueryTable::new(1, 1, PrimeField::new(97).unwrap()); + let first = table.start(&[0], table.lookup(&[0]).0).unwrap(); + for i in 1..10_000 { + let (hash, found) = table.lookup(&[i]); + assert!(found.is_none()); + let row = table.start(&[i], hash).unwrap(); + table.finish(row, &[i + 1]); + } + assert_eq!(table.lookup(&[0]).1, Some(first)); + assert_eq!(table.count(first), 0); + table.finish(first, &[42]); + assert_eq!(table.output(first).output, [42]); + table.counts[first] = u64::MAX; + assert_eq!(table.bump(first), None); + assert_eq!(table.count(first), u64::MAX); + } +} diff --git a/crates/aiur/src/querymap.rs b/crates/aiur/src/querymap.rs deleted file mode 100644 index 23d4141af..000000000 --- a/crates/aiur/src/querymap.rs +++ /dev/null @@ -1,456 +0,0 @@ -use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; - -use crate::{ - G, - execute::{ExecError, RecordBudget}, -}; - -/// Immutable view of one query entry. -#[derive(Clone, Copy)] -pub struct QueryRef<'a> { - pub(crate) output: &'a [G], - pub multiplicity: G, -} - -/// Mutable view of one query entry: the output is fixed at insertion, -/// only the multiplicity is bumped on memo hits. -pub struct QueryRefMut<'a> { - pub output: &'a [G], - pub multiplicity: &'a mut G, -} - -/// Hash an immutable query key for reuse across lookup and registration. -#[inline] -pub fn hash_g_slice(key: &[G]) -> u64 { - use std::hash::Hasher; - let mut h = rustc_hash::FxHasher::default(); - for g in key { - h.write_u64(g.as_canonical_u64()); - } - h.finish() -} - -/// Entries per storage segment (2^20). Segments are fixed-size, so growth -/// never reallocates or copies: appending past a segment boundary just -/// allocates the next segment. This removes the O(len) memmove of a growing -/// `Vec` AND its transient 2x memory spike — on kernel-heavy executions the -/// arenas reach tens of GB, where a doubling copy is both seconds of pure -/// memmove and the difference between fitting in RAM and OOM. Capacity is -/// only reserved virtual address space; physical pages are committed on -/// first touch, so idle circuits stay tiny. -const SEG_BITS: usize = 20; -const SEG_ENTRIES: usize = 1 << SEG_BITS; -const SEG_MASK: usize = SEG_ENTRIES - 1; - -/// A fixed-capacity append-only buffer mmap'd straight from the kernel, -/// with `MADV_HUGEPAGE` applied BEFORE any page is touched. At billions of -/// entries the query maps are walked by random probes; with 4K pages nearly -/// every probe pays a 4-level page walk on top of the DRAM miss, and 2M -/// pages cut TLB reach pressure by 512x. Going through the global allocator -/// doesn't work here: mimalloc (the process allocator) commits its segments -/// itself, so pages are already faulted at 4K before any post-hoc madvise. -/// Capacity is virtual reservation only — physical pages are committed on -/// first touch, so idle circuits stay tiny. Off Linux this degrades to a -/// plain `Vec`. -struct HugeVec { - #[cfg(target_os = "linux")] - ptr: *mut T, - #[cfg(target_os = "linux")] - cap: usize, - #[cfg(target_os = "linux")] - len: usize, - #[cfg(not(target_os = "linux"))] - inner: Vec, -} - -#[cfg(target_os = "linux")] -unsafe impl Send for HugeVec {} -#[cfg(target_os = "linux")] -unsafe impl Sync for HugeVec {} - -impl HugeVec { - #[cfg(target_os = "linux")] - fn with_capacity(cap: usize) -> Self { - assert!(cap > 0, "HugeVec capacity must be positive"); - let bytes = cap * size_of::(); - let ptr = unsafe { - let p = libc::mmap( - std::ptr::null_mut(), - bytes, - libc::PROT_READ | libc::PROT_WRITE, - libc::MAP_PRIVATE | libc::MAP_ANONYMOUS, - -1, - 0, - ); - assert!(p != libc::MAP_FAILED, "HugeVec mmap failed"); - // Advisory only: failure (old kernel, THP disabled) is harmless. - libc::madvise(p, bytes, libc::MADV_HUGEPAGE); - p.cast::() - }; - Self { ptr, cap, len: 0 } - } - - #[cfg(not(target_os = "linux"))] - fn with_capacity(cap: usize) -> Self { - Self { inner: Vec::with_capacity(cap) } - } - - #[cfg(target_os = "linux")] - #[inline] - fn extend_from_slice(&mut self, vals: &[T]) { - debug_assert!(self.len + vals.len() <= self.cap); - unsafe { - std::ptr::copy_nonoverlapping( - vals.as_ptr(), - self.ptr.add(self.len), - vals.len(), - ); - } - self.len += vals.len(); - } - - #[cfg(not(target_os = "linux"))] - #[inline] - fn extend_from_slice(&mut self, vals: &[T]) { - self.inner.extend_from_slice(vals); - } - - #[cfg(target_os = "linux")] - #[inline] - fn slice(&self, start: usize, len: usize) -> &[T] { - debug_assert!(start + len <= self.len); - unsafe { std::slice::from_raw_parts(self.ptr.add(start), len) } - } - - #[cfg(not(target_os = "linux"))] - #[inline] - fn slice(&self, start: usize, len: usize) -> &[T] { - &self.inner[start..start + len] - } - - #[cfg(target_os = "linux")] - #[inline] - fn slice_mut(&mut self, start: usize, len: usize) -> &mut [T] { - debug_assert!(start + len <= self.len); - unsafe { std::slice::from_raw_parts_mut(self.ptr.add(start), len) } - } - - #[cfg(not(target_os = "linux"))] - #[inline] - fn slice_mut(&mut self, start: usize, len: usize) -> &mut [T] { - &mut self.inner[start..start + len] - } -} - -#[cfg(target_os = "linux")] -impl Drop for HugeVec { - fn drop(&mut self) { - unsafe { - libc::munmap(self.ptr.cast(), self.cap * size_of::()); - } - } -} - -/// Append-only segmented arena of fixed-stride `G` entries. Entry `i` lives -/// at segment `i >> SEG_BITS`, offset `(i & SEG_MASK) * stride` — no entry -/// ever straddles a segment. -struct SegStore { - stride: usize, - segs: Vec>, - entries: usize, -} - -impl SegStore { - fn new(stride: usize) -> Self { - Self { stride, segs: Vec::new(), entries: 0 } - } - - #[inline] - fn at(&self, i: usize) -> &[G] { - if self.stride == 0 { - return &[]; - } - let base = (i & SEG_MASK) * self.stride; - self.segs[i >> SEG_BITS].slice(base, self.stride) - } - - #[inline] - fn at_mut(&mut self, i: usize) -> &mut [G] { - if self.stride == 0 { - return &mut []; - } - let base = (i & SEG_MASK) * self.stride; - self.segs[i >> SEG_BITS].slice_mut(base, self.stride) - } - - #[inline] - fn push(&mut self, vals: &[G]) { - debug_assert_eq!(vals.len(), self.stride); - if self.stride != 0 { - let seg = self.entries >> SEG_BITS; - if seg == self.segs.len() { - self.segs.push(HugeVec::with_capacity(SEG_ENTRIES * self.stride)); - } - self.segs[seg].extend_from_slice(vals); - } - self.entries += 1; - } - - fn retained_elems(&self) -> usize { - self.entries * self.stride - } -} - -/// Segmented store of per-entry `u64` key hashes. Keeping the hashes lets -/// hash-table growth re-insert entries without re-hashing every key from the -/// keys arena; table doubling on a multi-GB map used to be a full sequential -/// re-hash pass over the arena, log-many times. -struct SegU64s { - segs: Vec>, - entries: usize, -} - -impl SegU64s { - fn new() -> Self { - Self { segs: Vec::new(), entries: 0 } - } - - #[inline] - fn at(&self, i: usize) -> u64 { - self.segs[i >> SEG_BITS].slice(i & SEG_MASK, 1)[0] - } - - #[inline] - fn push(&mut self, h: u64) { - let seg = self.entries >> SEG_BITS; - if seg == self.segs.len() { - self.segs.push(HugeVec::with_capacity(SEG_ENTRIES)); - } - self.segs[seg].extend_from_slice(&[h]); - self.entries += 1; - } -} - -/// Append-only query store with a hash index. -/// -/// Functionally the insertion-ordered map `args -> (output, multiplicity)` -/// it replaces (`FxIndexMap, QueryResult>`) — but every circuit has -/// a FIXED key arity and output width, so keys and outputs live in flat -/// segmented `G` arenas addressed by entry index, and the hash table holds -/// only `u32` indices. This cuts per-entry overhead from ~130 B (two heap -/// `Vec`s + IndexMap bucket + allocator metadata) to the raw field -/// elements plus ~21 B of index + stored hash. The record IS the proof -/// witness, so entries cannot be dropped — only stored compactly; on -/// kernel-heavy executions it is the dominant RAM consumer (billions of -/// entries). Segmented storage keeps growth copy-free (no doubling -/// memmove, no transient 2x RSS), stored hashes make table growth a cheap -/// sequential pass, and segments are hugepage-advised (see `advise_huge`). -/// -/// Entry index == insertion order; memory circuits use it as the pointer -/// value, mirroring the old `IndexMap::get_index_of` semantics. -pub struct QueryMap { - /// Output width; inferred on first insert (not statically available in - /// `FunctionLayout`). - out_stride_set: bool, - keys: SegStore, - outs: SegStore, - mults: SegStore, - hashes: SegU64s, - table: hashbrown::HashTable, - // Fields drop in declaration order; release the charge after storage. - budget: RecordBudget, -} - -impl QueryMap { - pub fn new(key_stride: usize) -> Self { - Self::with_budget(key_stride, RecordBudget::default()) - } - - pub(crate) fn with_budget(key_stride: usize, budget: RecordBudget) -> Self { - Self { - out_stride_set: false, - keys: SegStore::new(key_stride), - outs: SegStore::new(0), - mults: SegStore::new(1), - hashes: SegU64s::new(), - table: hashbrown::HashTable::new(), - budget, - } - } - - #[inline] - pub fn len(&self) -> usize { - self.mults.entries - } - - #[inline] - pub fn is_empty(&self) -> bool { - self.mults.entries == 0 - } - - /// Total retained field elements (keys + outputs); used by the - /// `IX_AIUR_QUERY_STATS` RAM-attribution dump. - pub fn retained_elems(&self) -> usize { - self.keys.retained_elems() + self.outs.retained_elems() - } - - pub fn get_index_of(&self, key: &[G]) -> Option { - self.lookup(key).1 - } - - /// Look up a key, retaining its hash for a subsequent insert or finish. - /// The hash is independent of the table's capacity and remains valid if - /// nested calls grow the table before the caller registers its result. - #[inline] - pub fn lookup(&self, key: &[G]) -> (u64, Option) { - let hash = hash_g_slice(key); - (hash, self.get_index_of_hashed(key, hash)) - } - - fn get_index_of_hashed(&self, key: &[G], hash: u64) -> Option { - debug_assert_eq!(key.len(), self.keys.stride); - self - .table - .find(hash, |&i| self.keys.at(i as usize) == key) - .map(|&i| i as usize) - } - - pub fn get(&self, key: &[G]) -> Option> { - let i = self.get_index_of(key)?; - Some(QueryRef { - output: self.outs.at(i), - multiplicity: self.mults.at(i)[0], - }) - } - - pub fn get_mut(&mut self, key: &[G]) -> Option> { - let i = self.get_index_of(key)?; - Some(QueryRefMut { - output: self.outs.at(i), - multiplicity: &mut self.mults.at_mut(i)[0], - }) - } - - /// Multiplicity of entry `i`. - #[inline] - pub fn mult_at(&self, i: usize) -> G { - self.mults.at(i)[0] - } - - /// Output slice of entry `i`. - #[inline] - pub fn output_at(&self, i: usize) -> &[G] { - self.outs.at(i) - } - - /// Record a constrained memo hit on entry `i`. - #[inline] - pub fn bump_multiplicity(&mut self, i: usize) { - self.mults.at_mut(i)[0] += G::ONE; - } - - /// Register a function query at `Ctrl::Return`: insert on first - /// registration and bump on constrained promotion of a cached hint row. - pub fn finish( - &mut self, - key: &[G], - output: &[G], - constrained: bool, - ) -> Result<(), ExecError> { - self.finish_hashed(key, output, constrained, hash_g_slice(key)) - } - - /// Register using a hash previously obtained from `lookup` or - /// `hash_g_slice` for this exact key. Recheck presence after the body: - /// nested execution may have inserted rows, including this key. - pub fn finish_hashed( - &mut self, - key: &[G], - output: &[G], - constrained: bool, - hash: u64, - ) -> Result<(), ExecError> { - debug_assert_eq!(hash, hash_g_slice(key)); - if let Some(i) = self.get_index_of_hashed(key, hash) { - // The only ordinary way to execute an already cached function is - // constrained promotion of an unconstrained hint entry. - debug_assert_eq!(self.outs.at(i), output); - if constrained { - self.bump_multiplicity(i); - } - } else { - self.insert_hashed(key, output, G::from_bool(constrained), hash)?; - } - Ok(()) - } - - /// Append a new entry. The key must not already be present: call sites - /// only insert on a confirmed miss, and a same-key re-entrant call - /// would loop forever before reaching its own insert. - pub fn insert( - &mut self, - key: &[G], - output: &[G], - multiplicity: G, - ) -> Result<(), ExecError> { - self.insert_hashed(key, output, multiplicity, hash_g_slice(key)) - } - - /// Append on a confirmed miss using the hash of this exact key. As with - /// `insert`, the key must not already exist. Hash-table growth is safe; - /// no bucket pointer or vacant-entry handle is retained across calls. - pub fn insert_hashed( - &mut self, - key: &[G], - output: &[G], - multiplicity: G, - hash: u64, - ) -> Result<(), ExecError> { - debug_assert_eq!(key.len(), self.keys.stride); - debug_assert_eq!(hash, hash_g_slice(key)); - debug_assert!(self.get_index_of_hashed(key, hash).is_none()); - crate::execute::note_retained(key.len() + output.len(), &self.budget)?; - if !self.out_stride_set { - self.outs.stride = output.len(); - self.out_stride_set = true; - } else { - debug_assert_eq!(output.len(), self.outs.stride); - } - let i = u32::try_from(self.mults.entries).expect("query map overflow"); - self.keys.push(key); - self.outs.push(output); - self.mults.push(&[multiplicity]); - self.hashes.push(hash); - let hashes = &self.hashes; - self.table.insert_unique(hash, i, |&j| hashes.at(j as usize)); - Ok(()) - } - - /// Entry at insertion index `i`: the key slice plus a mutable handle on - /// the multiplicity (memory `Load` bumps the pointed-to row's count). - pub fn get_index_mut(&mut self, i: usize) -> Option<(&[G], &mut G)> { - if i >= self.mults.entries { - return None; - } - Some((self.keys.at(i), &mut self.mults.at_mut(i)[0])) - } - - pub fn get_index(&self, i: usize) -> Option<(&[G], QueryRef<'_>)> { - if i >= self.len() { - return None; - } - Some(( - self.keys.at(i), - QueryRef { output: self.outs.at(i), multiplicity: self.mults.at(i)[0] }, - )) - } - - pub fn iter(&self) -> impl Iterator)> { - (0..self.len()).map(|i| { - ( - self.keys.at(i), - QueryRef { output: self.outs.at(i), multiplicity: self.mults.at(i)[0] }, - ) - }) - } -} diff --git a/crates/aiur/src/row_counts.rs b/crates/aiur/src/row_counts.rs deleted file mode 100644 index ead83afa1..000000000 --- a/crates/aiur/src/row_counts.rs +++ /dev/null @@ -1,210 +0,0 @@ -// Copyright (c) 2026 Argument Computer Corporation. -// SPDX-License-Identifier: MIT OR Apache-2.0 - -//! Witness-independent bounds for branch selection and terminal counts. -//! Every return/yield allocates a selector, including consumed yields. - -use multi_stark::p3_field::PrimeField64; - -use crate::{ - G, - bytecode::{Block, Circuit, Ctrl, Toplevel}, -}; - -#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] -pub(crate) struct ControlCounts { - pub(crate) nodes: usize, - pub(crate) leaves: usize, - pub(crate) returns: usize, - pub(crate) yields: usize, -} - -impl ControlCounts { - fn checked_add(self, other: Self) -> Option { - Some(Self { - nodes: self.nodes.checked_add(other.nodes)?, - leaves: self.leaves.checked_add(other.leaves)?, - returns: self.returns.checked_add(other.returns)?, - yields: self.yields.checked_add(other.yields)?, - }) - } - - fn branches<'a>(blocks: impl Iterator) -> Option { - let mut counts = Self::default(); - for block in blocks { - counts = counts.checked_add(block.control_counts()?)?; - } - counts.nodes = counts.nodes.checked_add(1)?; - Some(counts) - } - - fn continued(self, continuation: Self) -> Option { - Some(Self { - nodes: self.nodes.checked_add(continuation.nodes)?, - leaves: self.leaves.checked_add(continuation.leaves)?, - returns: self.returns.checked_add(continuation.returns)?, - yields: continuation.yields, - }) - } -} - -impl Block { - pub(crate) fn control_counts(&self) -> Option { - match &self.ctrl { - Ctrl::Return(..) => { - Some(ControlCounts { nodes: 1, leaves: 1, returns: 1, yields: 0 }) - }, - Ctrl::Yield(..) => { - Some(ControlCounts { nodes: 1, leaves: 1, returns: 0, yields: 1 }) - }, - Ctrl::Match(_, branches, fallback) => { - ControlCounts::branches(branches.values().chain(fallback.as_deref())) - }, - Ctrl::MatchContinue(_, branches, fallback, _, _, _, continuation) => { - ControlCounts::branches(branches.values().chain(fallback.as_deref()))? - .continued(continuation.control_counts()?) - }, - } - } -} - -fn canonical_count(count: usize) -> bool { - u64::try_from(count).is_ok_and(|count| count < G::ORDER_U64) -} - -impl Circuit { - pub(crate) fn validate_row_counts( - &self, - program: &Toplevel, - ) -> Result<(), &'static str> { - if !canonical_count(self.members.len()) { - return Err("circuit member count exceeds the field characteristic"); - } - let mut leaves = 0usize; - for &index in &self.members { - let Some(function) = program.functions.get(index) else { - return Err("circuit refers to a missing function"); - }; - let Some(counts) = function.body.control_counts() else { - return Err("function control count overflows"); - }; - if !canonical_count(counts.nodes) { - return Err("function control count exceeds the field characteristic"); - } - leaves = leaves - .checked_add(counts.leaves) - .ok_or("circuit leaf count overflows")?; - } - if leaves > self.layout.selectors { - return Err("circuit has fewer selectors than return/yield leaves"); - } - Ok(()) - } -} - -impl Toplevel { - pub fn validate_row_counts(&self) -> Result<(), &'static str> { - for circuit in &self.circuits { - circuit.validate_row_counts(self)?; - } - Ok(()) - } -} - -#[cfg(test)] -mod tests { - use multi_stark::{ - p3_field::PrimeCharacteristicRing, - types::{CommitmentParameters, FriParameters}, - }; - - use super::*; - use crate::{ - FxIndexMap, - bytecode::{Function, FunctionLayout}, - synthesis::AiurSystem, - }; - - fn continued_body() -> Block { - let mut branches = FxIndexMap::default(); - branches - .insert(G::ZERO, Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }); - branches - .insert(G::ONE, Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![]) }); - Block { - ops: vec![], - ctrl: Ctrl::MatchContinue( - 0, - branches, - None, - 0, - 0, - 0, - Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![]) }), - ), - } - } - - fn continued_program(selectors: usize) -> Toplevel { - let layout = - FunctionLayout { input_size: 1, selectors, auxiliaries: 1, lookups: 1 }; - Toplevel { - functions: vec![Function { - body: continued_body(), - layout, - entry: true, - constrained: true, - }], - memory_sizes: vec![], - circuits: vec![Circuit { members: vec![0], layout }], - } - } - - #[test] - fn counts_include_consumed_yields_and_empty_matches() { - assert_eq!( - continued_body().control_counts(), - Some(ControlCounts { nodes: 4, leaves: 3, returns: 2, yields: 0 }) - ); - let empty = - Block { ops: vec![], ctrl: Ctrl::Match(0, FxIndexMap::default(), None) }; - assert_eq!( - empty.control_counts(), - Some(ControlCounts { nodes: 1, ..ControlCounts::default() }) - ); - assert!(continued_program(3).validate_row_counts().is_ok()); - assert!(continued_program(2).validate_row_counts().is_err()); - assert!(continued_program(1).validate_row_counts().is_err()); - } - - #[test] - fn count_bounds_reject_machine_overflow_and_field_wrap() { - let maximal = ControlCounts { nodes: usize::MAX, ..Default::default() }; - let one = ControlCounts { nodes: 1, ..Default::default() }; - assert!(maximal.checked_add(one).is_none()); - assert!(maximal.continued(one).is_none()); - if let Ok(order) = usize::try_from(G::ORDER_U64) { - assert!(canonical_count(order - 1)); - assert!(!canonical_count(order)); - assert!(!canonical_count(usize::MAX)); - } - } - - #[test] - #[should_panic(expected = "invalid Aiur control counts")] - fn system_construction_rejects_missing_leaf_selectors() { - let top = continued_program(1); - top.validate_lookup_shapes().unwrap(); - AiurSystem::build( - top, - CommitmentParameters { log_blowup: 1, cap_height: 0 }, - 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, - }, - ); - } -} diff --git a/crates/aiur/src/shard.rs b/crates/aiur/src/shard.rs deleted file mode 100644 index 495138b46..000000000 --- a/crates/aiur/src/shard.rs +++ /dev/null @@ -1,1112 +0,0 @@ -//! Trace shards: row partitions of one execution's traces, proven as a batch -//! of multi-stark proofs under shared lookup challenges. -//! -//! Aiur's soundness is one LogUp identity over every row of every circuit, -//! and the only cross-row constraint in the system is the memory table's -//! pointer increment. So the rows of a record may be dealt out to several -//! proofs — each small enough for a given prover budget — provided all of -//! them evaluate the lookup argument under the same challenges and their -//! residuals sum to zero, which is exactly what [`multi_stark::batch`] -//! provides. This module decides the partition ([`ShardPlan`]), builds each -//! shard's witness, and states the verifier-side policy that makes a batch -//! mean what a single proof means. -//! -//! # Partition rules -//! -//! - **Function circuits**: any row partition. Rows are the queries with a -//! nonzero multiplicity, in record order. -//! - **Memory circuits**: contiguous pointer ranges, one per shard, in -//! pointer order. Contiguity keeps the `ptr + 1` transition satisfiable -//! inside a shard; the two `memseg` lookups every memory row carries make -//! the ranges' end points visible to the lookup argument, and the batch -//! messages of [`boundary_messages`] close them so that only a partition -//! tiling `[0, N)` balances (see the tiling argument below). -//! - **Byte tables**: present in every shard — the plan's `0..height` range -//! marks the shard whose copy carries the record's multiplicities (shard -//! 0), and an empty range a copy with zero multiplicities, which adds -//! nothing to the lookup sum. Deactivating the tables instead would save -//! their (small, fixed) commitment per shard, but the in-circuit PCS -//! verifier only handles preprocessed matrices of active circuits, so the -//! tables stay active until that changes. -//! - **The entry claim** is carried by shard 0. Balance is global, so any -//! shard could carry it; one fixed place keeps the policy simple. -//! -//! # Why the memory ranges must tile -//! -//! Every real memory row pushes `(memseg, w, ptr)` and pulls -//! `(memseg, w, ptr + 1)`. Over a shard's contiguous run `[a, b)` the -//! interior terms cancel, leaving one push of `a` and one pull of `b`. The -//! verifier pulls `A_j` and pushes `B_j` once per memory interval -//! `[A_j, B_j)` a record holds (a record's width-`w` table sits at its -//! pointer base, see `QueryRecord::pointer_base`). Balance on the channel -//! is then, as multisets, `{a_k} ∪ {B_j} = {b_k} ∪ {A_j}`. Viewing each -//! shard as an edge `a_k → b_k` of length `b_k − a_k ≥ 1` on the residues -//! mod `p`, that says every residue has equal in- and out-degree except a -//! unit source at each `A_j` and a unit sink at each `B_j`; the edges -//! decompose into source-to-sink paths plus directed cycles, and a directed -//! cycle on `Z_p` has total length at least `p`. [`AiurSystem::verify`] -//! checks that the shards' padded heights sum below `p`, which rules the -//! cycles out, and requires the intervals sorted and disjoint, so a path -//! from `A_j` can only end at `B_j` (reaching any other sink would wrap -//! around `Z_p`): the ranges tile each interval exactly. Hence `(w, ptr)` is -//! unique across the batch, and the memory channel means what it means in -//! a single proof. -//! -//! Two conditions carry that argument and are checked by the verifier, not -//! assumed: the intervals are inside the preamble the challenges are -//! derived from (two end points chosen after the challenges could solve -//! the two coordinates of any target imbalance), and no two intervals of -//! one width overlap (overlap would admit two paths through the same -//! pointers, i.e. two shards claiming them). The verifier does not need to -//! know which widths or intervals the records use: a missing pair leaves -//! the batch unbalanced, and a pair no shard fills balances only as the -//! zero contribution `A_j = B_j` (see [`check_batch_policy`]). - -use std::ops::Range; - -use multi_stark::{ - batch::{BatchMessage, BatchPreamble, BatchProof, Retention}, - p3_field::{Field, PrimeCharacteristicRing, PrimeField64}, - system::SystemWitness, -}; -use rayon::iter::{ - IndexedParallelIterator, IntoParallelIterator, ParallelIterator, -}; - -use crate::{ - G, - execute::{IOBuffer, QueryRecord, record_retained_bytes}, - gadgets::{AiurGadget, bytes1::Bytes1, bytes2::Bytes2}, - memory::Memory, - memseg_channel, - synthesis::{ - AiurConfig, AiurSystem, CircuitType, EXTENSION_DEGREE, PeakProveBytes, - calibrate_prover_rss, - }, - trace::QueryPosition, -}; - -/// Upper bound on the shards of one batch, so the verifier's per-shard work -/// is bounded by a constant it knows. -pub const MAX_SHARDS: usize = 1 << 16; - -/// Goldilocks characteristic, for the height-sum bound. -const GOLDILOCKS_ORDER: u128 = 0xffff_ffff_0000_0001; - -/// Which rows of each circuit one shard carries, indexed by system circuit -/// order (see [`AiurSystem::circuit_types`]). Function and memory circuits -/// hold a row range; a byte-table circuit holds either its whole table -/// (`0..height`) or nothing (`0..0`). -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct ShardRows { - pub rows: Vec>, -} - -/// A row partition of one record across K shards. -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct ShardPlan { - pub shards: Vec, - /// `(width, first pointer, rows)` for every memory interval the batch's - /// records hold, ascending by width then pointer: the intervals the batch - /// messages close the `memseg` channel with. - pub memory_totals: Vec<(usize, usize, usize)>, -} - -impl ShardPlan { - pub fn num_shards(&self) -> usize { - self.shards.len() - } -} - -/// Positions in the record of a plan's function-circuit row boundaries -/// ([`AiurSystem::row_index`]): per circuit, ascending `(row, position)` -/// pairs for every range start and end the plan uses; empty for -/// non-function circuits, whose ranges index their tables directly. -pub struct RowIndex { - spans: Vec>, -} - -impl RowIndex { - /// The query span of function circuit `circuit`'s rows `rows`. - fn queries( - &self, - circuit: usize, - rows: &Range, - ) -> (QueryPosition, QueryPosition) { - let spans = &self.spans[circuit]; - let position = |row: usize| { - let i = spans - .binary_search_by_key(&row, |&(r, _)| r) - .expect("row boundary is in the index"); - spans[i].1 - }; - (position(rows.start), position(rows.end)) - } -} - -/// Per-circuit row counts of a record, in system circuit order. -fn circuit_rows(system: &AiurSystem, record: &QueryRecord) -> Vec { - system - .circuit_types() - .iter() - .map(|ct| match ct { - CircuitType::Function { idx } => { - system.toplevel().function_rows(*idx, record) - }, - CircuitType::Memory { width } => { - record.memory_queries.get(width).map_or(0, |m| m.len()) - }, - CircuitType::Bytes1 => 256, - CircuitType::Bytes2 => 65536, - }) - .collect() -} - -/// Committed cells a circuit with `rows` real rows occupies: its padded -/// height times its committed width (main + stage 2 + quotient). Zero for an -/// empty circuit, which is deactivated. -fn committed_cells(rows: usize, committed_width: usize) -> usize { - if rows == 0 { 0 } else { rows.next_power_of_two() * committed_width } -} - -/// The batch round a prepared witness feeds. Round one only commits stage -/// one. Round two commits it again and then evaluates the lookups on the -/// device, so a generated source built for it keeps its seeds resident -/// between the commitment and the lookup pass. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum BatchRound { - One, - Two, -} - -impl AiurSystem { - /// The single-shard plan: every row in shard 0. - pub fn single_shard_plan(&self, record: &QueryRecord) -> ShardPlan { - let rows = circuit_rows(self, record); - ShardPlan { - shards: vec![ShardRows { rows: rows.iter().map(|&r| 0..r).collect() }], - memory_totals: self.memory_totals(record), - } - } - - /// `(width, first pointer, rows)` for each memory width with rows, - /// ascending by width: the record's table of width `w` holds pointers - /// `[base, base + rows)`. - fn memory_totals(&self, record: &QueryRecord) -> Vec<(usize, usize, usize)> { - let mut totals: Vec<(usize, usize, usize)> = self - .toplevel() - .memory_sizes - .iter() - .filter_map(|&w| { - let rows = record.memory_queries.get(&w).map_or(0, |m| m.len()); - (rows > 0).then_some((w, record.pointer_base, rows)) - }) - .collect(); - totals.sort_unstable(); - totals - } - - /// Partitions the record's rows into the fewest shards whose committed - /// cells each fit `max_cells`, or the single-shard plan when `max_cells` - /// is `None`. When no shard count meets the budget, the plan with the - /// lightest heaviest shard found is returned. - /// - /// See [`plan_rows`] for the placement rules. The plan is a pure function - /// of the record and the budget, so any prover derives the same shards, - /// commitments and preamble. - pub fn plan_shards( - &self, - record: &QueryRecord, - max_cells: Option, - ) -> ShardPlan { - let Some(max_cells) = max_cells else { - return self.single_shard_plan(record); - }; - let rows = circuit_rows(self, record); - self.plan_shards_from_rows(record, &rows, max_cells) - } - - /// [`Self::plan_shards`] with the record's per-circuit row counts already - /// taken, for callers that plan the same record repeatedly. - fn plan_shards_from_rows( - &self, - record: &QueryRecord, - rows: &[usize], - max_cells: usize, - ) -> ShardPlan { - let widths = self.committed_widths(); - let shards = plan_rows(rows, &widths, &self.circuit_types(), max_cells); - ShardPlan { shards, memory_totals: self.memory_totals(record) } - } - - /// Committed cells of each shard of `plan`, the byte tables charged to - /// every shard. - pub(crate) fn shard_committed_cells(&self, plan: &ShardPlan) -> Vec { - let widths = self.committed_widths(); - let types = self.circuit_types(); - plan - .shards - .iter() - .map(|shard| { - shard - .rows - .iter() - .zip(&widths) - .zip(&types) - .map(|((range, &width), circuit_type)| { - let rows = match circuit_type { - CircuitType::Bytes1 => 256, - CircuitType::Bytes2 => 65536, - _ => range.len(), - }; - committed_cells(rows, width) - }) - .sum() - }) - .collect() - } - - /// Per-circuit committed width: main, stage 2 and quotient columns. - pub(crate) fn committed_widths(&self) -> Vec { - self - .circuit_shapes() - .iter() - .map(|shape| { - shape.main_width - + shape.stage2_width - + shape.quotient_degree * EXTENSION_DEGREE - }) - .collect() - } - - /// Where each function circuit's row ranges of `plan` sit in the record: - /// one pass over each function's queries, so that building a shard's - /// witness indexes its queries directly rather than counting rows from - /// the start of the function (which, over K shards built twice, would - /// visit every query 2K times). - #[tracing::instrument(level = "info", skip_all, name = "aiur/row_index")] - pub fn row_index(&self, record: &QueryRecord, plan: &ShardPlan) -> RowIndex { - let circuit_types = self.circuit_types(); - let spans = circuit_types - .into_par_iter() - .enumerate() - .map(|(ci, ct)| { - let CircuitType::Function { idx } = ct else { - return Vec::new(); - }; - // The logical boundaries every shard's range for this circuit - // needs, ascending; then their positions in the query map. - let mut bounds: Vec = plan - .shards - .iter() - .flat_map(|s| [s.rows[ci].start, s.rows[ci].end]) - .collect(); - bounds.sort_unstable(); - bounds.dedup(); - let members = &self.toplevel().circuits[idx].members; - let mut positions = Vec::with_capacity(bounds.len()); - let mut next = bounds.iter().peekable(); - let mut row = 0usize; - for (m, &member) in members.iter().enumerate() { - let queries = &record.function_queries[member]; - for (pos, (_, res)) in queries.iter().enumerate() { - while next.peek().is_some_and(|&&b| b == row) { - positions.push((row, (m, pos))); - next.next(); - } - if !res.multiplicity.is_zero() { - row += 1; - } - } - } - // Boundaries at or past the last row map to one past the last - // member's last query (an empty tail of zero-multiplicity queries - // is skipped). - for &b in next { - assert_eq!(b, row, "plan range exceeds the circuit's rows"); - positions.push((row, (members.len(), 0))); - } - positions - }) - .collect(); - RowIndex { spans } - } - - /// The witness of shard `shard` of `plan`: each circuit's rows in the - /// plan's ranges, built in parallel across circuits. `index` is - /// [`Self::row_index`] of the same record and plan. - pub fn shard_witness( - &self, - record: &QueryRecord, - io_buffer: &IOBuffer, - plan: &ShardPlan, - 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"); - // A record with no queries: the source of a zero-multiplicity byte table. - let zero_record = QueryRecord::new(self.toplevel()); - let witness_span = tracing::Span::current(); - let witness_data = circuit_types - .into_par_iter() - .enumerate() - .map(|(circuit_idx, circuit_type)| { - 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, - ) { - 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(), - ) { - return prepared; - } - }, - _ => {}, - } - } - let kind = match circuit_type { - CircuitType::Function { .. } => "function", - CircuitType::Memory { .. } => "memory", - CircuitType::Bytes1 => "bytes1", - CircuitType::Bytes2 => "bytes2", - }; - let _g = tracing::info_span!( - "aiur/cpu_circuit", - circuit = circuit_idx, - kind, - rows = range.len() - ) - .entered(); - let (trace, lookups) = match circuit_type { - CircuitType::Function { idx } => { - let (start, end) = index.queries(circuit_idx, &range); - self.toplevel().witness_data_range( - idx, - record, - io_buffer, - &slot_arg_widths, - start, - end, - range.len(), - ) - }, - CircuitType::Memory { width } => { - Memory::witness_data_range(width, record, &slot_arg_widths, range) - }, - // The byte tables are present in every shard; the shard the plan - // assigns them carries the record's multiplicities, every other - // shard a copy with zero multiplicities (see the module docs). - CircuitType::Bytes1 => { - let source = if range.is_empty() { &zero_record } else { record }; - Bytes1.witness_data(source, &slot_arg_widths) - }, - CircuitType::Bytes2 => { - let source = if range.is_empty() { &zero_record } else { record }; - Bytes2.witness_data(source, &slot_arg_widths) - }, - }; - (multi_stark::witness::TraceSource::Host(trace), lookups) - }) - .collect::>(); - let (traces, lookups) = witness_data.into_iter().unzip(); - multi_stark::witness::PreparedWitness { traces, lookups } - } - - /// The projected prover peak of shard `shard` of `plan` with the record - /// (`record_bytes` retained) resident for the shard's whole proof, as it - /// is under `Retention::Regenerate`: the phase model over the shard's - /// rows, the byte tables at full height, plus the record in every phase. - pub fn shard_peak_bytes( - &self, - plan: &ShardPlan, - shard: usize, - record_bytes: usize, - ) -> usize { - let phases = self.shard_phases(plan, shard); - let analytic = - phases.phase_witness.max(phases.phase_stage2).max(phases.phase_open) - + phases.preprocessed - + record_bytes; - calibrate_prover_rss(analytic) - } - - /// Host workspace beside a separately charged record. CUDA keeps the - /// commitment phases on the device; reserve two host witnesses plus - /// upload staging. The CPU backend keeps every phase on the host. - pub(crate) fn shard_host_workspace( - &self, - plan: &ShardPlan, - shard: usize, - materialize_lookups: bool, - ) -> usize { - #[cfg(feature = "cuda")] - { - let phases = self.shard_phases(plan, shard); - let witness = if materialize_lookups { - phases.phase_witness - } else { - self - .circuit_types() - .iter() - .enumerate() - .map(|(i, circuit)| { - let rows = match circuit { - CircuitType::Bytes1 => 256, - CircuitType::Bytes2 => 65536, - _ => plan.shards[shard].rows[i].len(), - }; - if rows == 0 { - 0 - } else { - 8 * rows.next_power_of_two() * self.system.circuits[i].main_width - } - }) - .sum() - }; - calibrate_prover_rss( - witness - .saturating_mul(2) - .saturating_add(phases.preprocessed) - .saturating_add(256 << 20), - ) - } - #[cfg(not(feature = "cuda"))] - { - let _ = materialize_lookups; - self.shard_peak_bytes(plan, shard, 0) - } - } - - /// The plan with the fewest shards whose projected peaks - /// ([`Self::shard_peak_bytes`]) all fit `max_bytes`, with the heaviest - /// shard's projected peak. When no shard count fits — the record plus - /// the smallest shard the planner can cut already exceeds the budget — - /// the error carries the lowest heaviest-shard peak any plan reached, - /// the floor a budget would have to clear. - /// - /// The cell budget handed to [`Self::plan_shards`] is halved until a plan - /// fits, then the largest fitting cell budget is found by bisection: a - /// larger budget means fewer shards, and every shard is a fixed price in - /// proof size and verification. - pub fn plan_shards_within( - &self, - record: &QueryRecord, - max_bytes: usize, - ) -> Result<(ShardPlan, usize), usize> { - let record_bytes = record_retained_bytes(record); - let peak_of = |plan: &ShardPlan| { - (0..plan.num_shards()) - .map(|shard| self.shard_peak_bytes(plan, shard, record_bytes)) - .max() - .unwrap_or(0) - }; - let single = self.single_shard_plan(record); - let single_peak = peak_of(&single); - if single_peak <= max_bytes { - return Ok((single, single_peak)); - } - - // Every shard carries the record and the byte tables at full height; - // a budget under that alone fits no plan, however finely it cuts. - let tables = self.peak_prove_bytes_by( - |_, ct| match ct { - CircuitType::Bytes1 => 256, - CircuitType::Bytes2 => 65536, - _ => 0, - }, - 0, - ); - let floor = calibrate_prover_rss( - tables.phase_witness.max(tables.phase_stage2).max(tables.phase_open) - + tables.preprocessed - + record_bytes, - ); - if floor > max_bytes { - return Err(floor); - } - - let rows = circuit_rows(self, record); - let widths = self.committed_widths(); - let total: usize = - rows.iter().zip(&widths).map(|(&r, &w)| committed_cells(r, w)).sum(); - // No shard can be narrower than the widest circuit's smallest piece, - // so a budget below that cuts the same plan as one at it. - let widest = widths.iter().copied().max().unwrap_or(1).max(1); - - // Halve the cell budget until a plan fits. The shard count need not - // grow with every halving (a piece-height cap can pin it at one - // circuit's piece count while the room still shrinks), so the search - // runs the budget down to zero before giving up; planning is cheap. - let mut hi = total; - let mut cells = total / 2; - let mut floor = single_peak; - let (mut lo, mut best, mut best_peak) = loop { - if cells < 2 * widest { - return Err(floor); - } - let plan = self.plan_shards_from_rows(record, &rows, cells); - let peak = peak_of(&plan); - floor = floor.min(peak); - if peak <= max_bytes { - break (cells, plan, peak); - } - hi = cells; - cells /= 2; - }; - - // Bisect for the largest fitting cell budget, to one part in sixteen. - while hi - lo > lo / 16 + 1 { - let mid = lo + (hi - lo) / 2; - let plan = self.plan_shards_from_rows(record, &rows, mid); - let peak = peak_of(&plan); - if peak <= max_bytes { - lo = mid; - if plan.num_shards() <= best.num_shards() { - best = plan; - best_peak = peak; - } - } else { - hi = mid; - } - } - Ok((best, best_peak)) - } - - /// The retention policy for proving `plan` under `max_bytes`: retain - /// every shard's stage 1 across the batch barrier when the model says the - /// whole retained batch fits beside the heaviest shard's proving - /// workspace, since retaining recomputes nothing; regenerate otherwise. - /// A one-shard plan has nothing to save by regenerating and always - /// retains. - pub fn retention_for( - &self, - plan: &ShardPlan, - record_bytes: usize, - max_bytes: usize, - ) -> Retention { - if plan.num_shards() == 1 { - return Retention::Retain; - } - let phases: Vec<_> = (0..plan.num_shards()) - .map(|shard| self.shard_phases(plan, shard)) - .collect(); - // Round one builds every witness with the record alive; round two holds - // every shard's stage 1 while the heaviest shard proves. - let witnesses = - record_bytes + phases.iter().map(|p| p.phase_witness).sum::(); - let retained = phases.iter().map(|p| p.retained_stage_1).sum::() - + phases - .iter() - .map(|p| p.phase_stage2.max(p.phase_open)) - .max() - .unwrap_or(0); - let preprocessed = phases.first().map_or(0, |p| p.preprocessed); - let peak = calibrate_prover_rss(witnesses.max(retained) + preprocessed); - if peak <= max_bytes { Retention::Retain } else { Retention::Regenerate } - } - - /// The phase model over shard `shard` of `plan` alone: its rows, the byte - /// tables at full height, and no record term. - fn shard_phases(&self, plan: &ShardPlan, shard: usize) -> PeakProveBytes { - let ranges = &plan.shards[shard].rows; - self.peak_prove_bytes_by( - |ci, ct| match ct { - CircuitType::Bytes1 => 256, - CircuitType::Bytes2 => 65536, - _ => ranges[ci].len(), - }, - 0, - ) - } - - /// The batch messages closing the `memseg` channel for `plan`: per memory - /// interval, one pull of its first pointer and one push of one past its - /// last. - pub fn boundary_messages(plan: &ShardPlan) -> Vec> { - let mut messages = Vec::with_capacity(2 * plan.memory_totals.len()); - for &(width, base, total) in &plan.memory_totals { - let w = G::from_usize(width); - messages.push(BatchMessage::pull( - Memory::memseg_args(w, G::from_usize(base)).to_vec(), - )); - messages.push(BatchMessage::push( - Memory::memseg_args(w, G::from_usize(base + total)).to_vec(), - )); - } - messages - } -} - -/// Checks the batch-level policy that makes a [`BatchProof`] the proof of -/// one execution of a system with `num_circuits` circuits. Besides the claim, it constrains the batch messages to -/// the shape of the `memseg` closure and bounds the batch's rows: -/// -/// - exactly one claim across all shards, equal to `claim`; -/// - the messages are consecutive pairs `pull (memseg, w, a)`, -/// `push (memseg, w, b)` with `a ≤ b` — nothing else — sorted by width -/// and, within a width, by disjoint intervals (`b` of one pair at most -/// `a` of the next), all compared as the integers the canonical field -/// elements are; -/// - the padded heights of every active circuit of every shard sum to -/// less than the field characteristic. -/// -/// The verifier need not know which widths or intervals the records use: -/// a missing pair leaves an interval's end points unmatched and the batch -/// unbalanced, and a pair no shard fills balances only at `a = b`, where -/// it is the zero contribution. What must be excluded is two pairs whose -/// intervals overlap (two paths through the same pointers, i.e. two -/// shards claiming them), a pair of any other shape, and a message on -/// any other channel; the height bound is what lets the tiling argument -/// treat `ptr + 1` as an integer increment (see the module docs). -pub(crate) fn check_batch_policy( - num_circuits: usize, - claim: &[G], - preamble: &BatchPreamble, -) -> Result<(), String> { - let num_shards = preamble.headers.len(); - if num_shards == 0 || num_shards > MAX_SHARDS { - return Err(format!("batch has {num_shards} shards")); - } - let mut claims = preamble.headers.iter().flat_map(|h| h.claims.iter()); - match (claims.next(), claims.next()) { - (Some(only), None) if only.as_slice() == claim => {}, - (Some(_), None) => return Err("batch carries a different claim".into()), - (None, _) => return Err("batch carries no claim".into()), - (Some(_), Some(_)) => { - return Err("batch carries more than one claim".into()); - }, - } - - let mut height_sum: u128 = 0; - for header in &preamble.headers { - if header.active.len() != num_circuits { - return Err("shard activation bitmap has the wrong length".into()); - } - let active = header.active.iter().filter(|&&a| a).count(); - if header.log_degrees.len() != active { - return Err("shard header heights do not match its activation".into()); - } - for &log_degree in &header.log_degrees { - height_sum += 1u128 << log_degree.min(127); - } - } - if height_sum >= GOLDILOCKS_ORDER { - return Err("batch rows exceed the field characteristic".into()); - } - - if !preamble.messages.len().is_multiple_of(2) { - return Err("batch messages do not pair up".into()); - } - let memseg = memseg_channel(); - // The previous pair's width and end; every width is at least one, so - // `(0, 0)` precedes any first pair. - let mut previous = (0u64, 0u64); - for [pull, push] in preamble.messages.as_chunks::<2>().0 { - let well_formed = pull.multiplicity == G::NEG_ONE - && push.multiplicity == G::ONE - && pull.args.len() == 3 - && push.args.len() == 3 - && pull.args[0] == memseg - && push.args[0] == memseg - && pull.args[1] == push.args[1]; - if !well_formed { - return Err("batch messages are not memseg closure pairs".into()); - } - let width = pull.args[1].as_canonical_u64(); - let start = pull.args[2].as_canonical_u64(); - let end = push.args[2].as_canonical_u64(); - if start > end { - return Err("memseg closure interval ends before it starts".into()); - } - let (previous_width, previous_end) = previous; - let ordered = previous_width < width - || (previous_width == width && previous_end <= start); - if !ordered { - return Err( - "memseg closure intervals are not sorted and disjoint".into(), - ); - } - previous = (width, end); - } - Ok(()) -} - -/// The `memseg` channel identifier, exposed for hosts that assemble or audit -/// batch messages. -pub fn memseg_channel_value() -> G { - memseg_channel() -} - -/// Convenience: the number of shards of a proof. -pub fn num_shards(proof: &BatchProof) -> usize { - proof.proofs.len() -} - -fn is_byte_table(circuit_type: &CircuitType) -> bool { - matches!(circuit_type, CircuitType::Bytes1 | CircuitType::Bytes2) -} - -/// Committed cells of one shard of a plan. Every shard commits the byte -/// tables whole, whether or not its copy carries multiplicities, so their -/// cells are charged regardless of the shard's (marker) range for them. -#[cfg(test)] -fn shard_cells( - shard: &ShardRows, - rows: &[usize], - widths: &[usize], - circuit_types: &[CircuitType], -) -> usize { - shard - .rows - .iter() - .zip(rows) - .zip(widths) - .zip(circuit_types) - .map(|(((range, &rows), &width), circuit_type)| { - let rows = if is_byte_table(circuit_type) { rows } else { range.len() }; - committed_cells(rows, width) - }) - .sum() -} - -/// Partitions per-circuit row counts into shards whose committed cells -/// ([`shard_cells`]) each fit `max_cells`, opening as few shards as the -/// packing needs. -/// -/// Every circuit is cut into the fewest pieces that each fit the room a -/// shard has beside the byte tables ([`piece_rows`]): a circuit that fits -/// whole is one piece, a larger one is cut into full pieces of the largest -/// fitting power of two, which pad nothing, and a remainder. The pieces are -/// packed first-fit in decreasing size, a new shard opening only when no -/// shard has room; two pieces of one circuit never share a shard, since a -/// shard holds one row range per circuit. A circuit's width is charged to -/// proof size and verification once per shard it appears in, so the fewest -/// pieces and the fewest shards are what the packing minimizes, and padding -/// costs at most one doubling per piece. Byte tables are marked whole in -/// shard 0 and charged to every shard. Memory circuits are cut in pointer -/// order, so every piece is a contiguous pointer range. -/// -/// A room no piece can meet (a single row wider than it) still yields a -/// plan: every such row is a piece of its own, and the shards those open -/// exceed the budget by exactly that row. -fn plan_rows( - rows: &[usize], - widths: &[usize], - circuit_types: &[CircuitType], - max_cells: usize, -) -> Vec { - let num_circuits = rows.len(); - let table_cells: usize = (0..num_circuits) - .filter(|&ci| is_byte_table(&circuit_types[ci])) - .map(|ci| committed_cells(rows[ci], widths[ci])) - .sum(); - // What a shard can hold besides the tables it commits in any case. - let room = max_cells.saturating_sub(table_cells); - - // Every circuit's pieces: (cells, circuit, rows). - let mut pieces: Vec<(usize, usize, Range)> = Vec::new(); - for ci in 0..num_circuits { - if is_byte_table(&circuit_types[ci]) || rows[ci] == 0 { - continue; - } - // Full pieces of the largest fitting power of two pad nothing; only the - // remainder pads, so this is the least padded cut with this many - // pieces. - let per_piece = piece_rows(rows[ci], widths[ci], room); - let mut start = 0; - while start < rows[ci] { - let end = (start + per_piece).min(rows[ci]); - pieces.push((committed_cells(end - start, widths[ci]), ci, start..end)); - start = end; - } - } - pieces.sort_by_key(|(cells, ci, range)| { - (std::cmp::Reverse(*cells), *ci, range.start) - }); - - let mut shards: Vec = Vec::new(); - let mut loads: Vec = Vec::new(); - for (cells, ci, range) in pieces { - let k = (0..shards.len()) - .find(|&k| loads[k] + cells <= room && shards[k].rows[ci].is_empty()) - .unwrap_or_else(|| { - shards.push(ShardRows { rows: vec![0..0; num_circuits] }); - loads.push(0); - shards.len() - 1 - }); - shards[k].rows[ci] = range; - loads[k] += cells; - } - if shards.is_empty() { - shards.push(ShardRows { rows: vec![0..0; num_circuits] }); - } - for ci in 0..num_circuits { - if is_byte_table(&circuit_types[ci]) { - shards[0].rows[ci] = 0..rows[ci]; - } - } - shards -} - -/// Log2 of the tallest piece the planner cuts. The prover's cost per -/// committed cell rises with a shard's tallest matrix once its FFTs leave -/// cache (2026-09-09, Init at 200 GiB on the 64-core Xeon 6975P-C: ~21 ns -/// per cell at 2^22 rows, ~30 ns at 2^24, ~40 ns at 2^25), so a tall circuit -/// is cut shorter than the room alone would require, at the price of one -/// activation per extra piece. `AIUR_MAX_PIECE_LOG_HEIGHT` overrides it. -const MAX_PIECE_LOG_HEIGHT: u32 = 22; - -fn max_piece_rows() -> usize { - let log_height = std::env::var("AIUR_MAX_PIECE_LOG_HEIGHT") - .ok() - .and_then(|v| v.parse().ok()) - .unwrap_or(MAX_PIECE_LOG_HEIGHT); - 1 << log_height -} - -/// The most rows of a width-`width` circuit with `rows` rows one piece may -/// hold: within `room` committed cells and at most [`max_piece_rows`], the -/// largest power of two meeting both, at least one row; all of the rows when -/// the circuit meets both whole. -fn piece_rows(rows: usize, width: usize, room: usize) -> usize { - let cap = max_piece_rows(); - if rows <= cap && committed_cells(rows, width) <= room { - return rows; - } - let fit = (room / width.max(1)).min(cap); - if fit == 0 { 1 } else { 1 << (usize::BITS - 1 - fit.leading_zeros()) } -} - -#[cfg(test)] -mod tests { - use super::*; - - const WIDTHS: [usize; 5] = [24, 6, 5, 3, 4]; - - fn circuit_types() -> Vec { - vec![ - CircuitType::Function { idx: 0 }, - CircuitType::Function { idx: 1 }, - CircuitType::Memory { width: 1 }, - CircuitType::Bytes1, - CircuitType::Bytes2, - ] - } - - fn heaviest(shards: &[ShardRows], rows: &[usize]) -> usize { - shards - .iter() - .map(|s| shard_cells(s, rows, &WIDTHS, &circuit_types())) - .max() - .unwrap() - } - - fn covers(shards: &[ShardRows], rows: &[usize]) { - for (ci, &r) in rows.iter().enumerate() { - let covered: usize = shards.iter().map(|s| s.rows[ci].len()).sum(); - assert_eq!(covered, r, "circuit {ci}"); - } - } - - #[test] - fn oversize_circuit_is_cut_into_the_fewest_fitting_pieces() { - let rows = [100_000, 0, 0, 256, 65_536]; - let tables = - committed_cells(256, WIDTHS[3]) + committed_cells(65_536, WIDTHS[4]); - // Room for 32,768 padded rows: three full pieces of 32,768 rows, which - // pad nothing, and a remainder of 1,696, one per shard. - let budget = tables + committed_cells(25_000, WIDTHS[0]); - let shards = plan_rows(&rows, &WIDTHS, &circuit_types(), budget); - assert_eq!(shards.len(), 4); - let mut lengths: Vec = - shards.iter().map(|s| s.rows[0].len()).collect(); - lengths.sort_unstable(); - assert_eq!(lengths, vec![1_696, 32_768, 32_768, 32_768]); - assert!(heaviest(&shards, &rows) <= budget); - covers(&shards, &rows); - } - - #[test] - fn cold_circuit_appears_once() { - // The widest circuit needs four pieces (three full, one remainder); the - // second fits whole, shares the remainder's shard, and must not be - // spread across the shards the first opens. - let rows = [100_000, 40_000, 3_000, 256, 65_536]; - let tables = - committed_cells(256, WIDTHS[3]) + committed_cells(65_536, WIDTHS[4]); - let budget = tables + committed_cells(32_768, WIDTHS[0]); - let shards = plan_rows(&rows, &WIDTHS, &circuit_types(), budget); - assert_eq!(shards.len(), 4); - assert_eq!(shards.iter().filter(|s| !s.rows[1].is_empty()).count(), 1); - assert_eq!(shards.iter().filter(|s| !s.rows[2].is_empty()).count(), 1); - assert!(heaviest(&shards, &rows) <= budget); - covers(&shards, &rows); - } - - #[test] - fn byte_tables_are_charged_to_every_shard() { - let rows = [3, 2, 1, 256, 65_536]; - let tables = - committed_cells(256, WIDTHS[3]) + committed_cells(65_536, WIDTHS[4]); - // Room for the tables plus one row of the widest circuit, and nothing - // more: each of its three rows takes a shard of its own, and the next - // circuit and the memory row share a fourth. - let budget = tables + committed_cells(1, WIDTHS[0]); - let shards = plan_rows(&rows, &WIDTHS, &circuit_types(), budget); - assert_eq!(shards.len(), 4); - assert!(heaviest(&shards, &rows) <= budget); - covers(&shards, &rows); - // The marker range for the tables is shard 0's alone. - assert_eq!(shards[0].rows[4], 0..65_536); - assert!(shards[1..].iter().all(|s| s.rows[4].is_empty())); - } - - #[test] - fn unattainable_budget_still_covers_every_row() { - let rows = [3, 2, 1, 256, 65_536]; - let shards = plan_rows(&rows, &WIDTHS, &circuit_types(), 1); - assert_eq!(shards.len(), 6); - covers(&shards, &rows); - } - - /// Plans a measured system offline. `AIUR_PLAN_FILE` holds one `rows - /// width` pair per circuit in system order, the last two being the byte - /// tables; `AIUR_PLAN_CELLS` the per-shard cell budgets to sweep. Prints, - /// per budget and piece-height cap, the shard count, activations, summed - /// active width, padded cells and the tallest-piece histogram. - #[test] - #[ignore] - fn plan_file() { - let file = std::env::var("AIUR_PLAN_FILE").expect("AIUR_PLAN_FILE"); - let (rows, widths): (Vec, Vec) = - std::fs::read_to_string(file) - .expect("readable plan file") - .lines() - .map(|l| { - let mut it = - l.split_whitespace().map(|x| x.parse::().unwrap()); - (it.next().unwrap(), it.next().unwrap()) - }) - .unzip(); - let n = rows.len(); - let types: Vec = (0..n) - .map(|ci| match n - ci { - 1 => CircuitType::Bytes2, - 2 => CircuitType::Bytes1, - _ => CircuitType::Function { idx: ci }, - }) - .collect(); - let budgets: Vec = std::env::var("AIUR_PLAN_CELLS") - .expect("AIUR_PLAN_CELLS") - .split(',') - .map(|x| x.parse().unwrap()) - .collect(); - let real: usize = rows.iter().zip(&widths).map(|(&r, &w)| r * w).sum(); - println!("{n} circuits, real cells {real}"); - for &cells in &budgets { - for cap in 20..=26 { - // SAFETY: single-threaded test; the planner reads the override. - unsafe { - std::env::set_var("AIUR_MAX_PIECE_LOG_HEIGHT", cap.to_string()) - }; - let shards = plan_rows(&rows, &widths, &types, cells); - let mut activations = 0; - let mut width = 0; - let mut padded = 0; - let mut tallest = std::collections::BTreeMap::new(); - for s in &shards { - let mut tall = 0; - for (ci, r) in s.rows.iter().enumerate() { - let rr = if is_byte_table(&types[ci]) { rows[ci] } else { r.len() }; - if rr == 0 { - continue; - } - activations += 1; - width += widths[ci]; - padded += committed_cells(rr, widths[ci]); - tall = tall.max(rr.next_power_of_two()); - } - *tallest.entry(tall.trailing_zeros()).or_insert(0) += 1; - } - // Padding over the real cells, in tenths of a percent. - let pad_permille = padded.saturating_sub(real) * 1000 / real.max(1); - println!( - "cells {cells} cap 2^{cap}: K {} act {activations} width {width} \ - padded {padded} pad {}.{}% tallest {:?}", - shards.len(), - pad_permille / 10, - pad_permille % 10, - tallest - ); - } - } - } -} diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs deleted file mode 100644 index a162e6287..000000000 --- a/crates/aiur/src/synthesis.rs +++ /dev/null @@ -1,2786 +0,0 @@ -use multi_stark::{ - batch::{BatchProof, Retention}, - config::StarkGenericConfig, - expr::Expr, - lookup::{Lookup, LookupRowMut}, - p3_field::{BasedVectorSpace, PrimeCharacteristicRing}, - p3_matrix::dense::RowMajorMatrix, - system::{CircuitInputs, ProverKey, System}, - types::{ - CommitmentParameters, ExtVal, FriParameters, GoldilocksBlake3Config, - PcsError, - }, - verifier::VerificationError, -}; - -mod normalization; - -use crate::{ - G, - bytecode::{FunIdx, Toplevel}, - execute::{ExecError, IOBuffer, QueryRecord}, - function_channel, - gadgets::{AiurGadget, bytes1::Bytes1, bytes2::Bytes2}, - lookup_budget::lookup_query_bound, - lookup_shapes::{ClaimShape, valid_claim_shape}, - memory::Memory, - shard::{BatchRound, RowIndex, ShardPlan, check_batch_policy}, - trace_heights::{fixed_trace_heights, trace_cap_coverage}, -}; - -/// The concrete STARK configuration Aiur instantiates multi-stark with. -pub type AiurConfig = GoldilocksBlake3Config; -/// A proof under [`AiurConfig`]: a batch of one or more trace shards proven -/// under shared lookup challenges (see [`crate::shard`]). A proof of an -/// unsharded execution is the one-shard batch. -pub type AiurProof = BatchProof; -/// What a batch prover keeps of each shard across its barrier. -pub use multi_stark::batch::Retention as ShardRetention; - -/// Why an [`AiurProof`] was rejected. -#[derive(Debug)] -pub enum AiurVerificationError { - /// The batch violates Aiur's policy over multi-stark's batch protocol: - /// the claim, or the `memseg` closure messages, are not what one - /// execution's proof carries (see [`crate::shard::check_batch_policy`]). - Policy(String), - /// The multi-stark batch itself failed to verify. - Stark(VerificationError), -} - -impl From> for AiurVerificationError { - fn from(error: VerificationError) -> Self { - Self::Stark(error) - } -} - -/// Verifies `proof` of `claim` with nothing but the verifying key: every -/// shard header must describe a proof `system` could have produced (fixed -/// circuits at their exact heights, every trace matrix under the Merkle cap, -/// the lookup query count within bound), the batch must satisfy Aiur's -/// policy (one claim, canonical `memseg` closure — see [`crate::shard`]), -/// and the multi-stark batch must verify. [`AiurSystem::verify`] adds the -/// claim-shape check against the bytecode; a decoded -/// [`crate::vk_codec::AiurVerifyingKey`] carries no bytecode and verifies -/// exactly this. -pub(crate) fn verify_against( - system: &System, - commitment_parameters: CommitmentParameters, - claim: &[G], - proof: &AiurProof, -) -> Result<(), AiurVerificationError> { - validate_preamble(system, commitment_parameters, claim, &proof.preamble)?; - system.verify_batch(proof)?; - Ok(()) -} - -pub(crate) fn validate_preamble( - system: &System, - commitment_parameters: CommitmentParameters, - claim: &[G], - preamble: &multi_stark::batch::BatchPreamble, -) -> Result<(), AiurVerificationError> { - for header in &preamble.headers { - let well_shaped = fixed_trace_heights( - system.circuits.iter().map(|circuit| circuit.preprocessed_height), - &header.active, - &header.log_degrees, - ) && trace_cap_coverage( - commitment_parameters.log_blowup, - commitment_parameters.cap_height, - &header.log_degrees, - ) && lookup_query_bound( - system.circuits.iter().map(|circuit| circuit.num_lookups), - &header.active, - &header.log_degrees, - ) - .is_some(); - if !well_shaped { - return Err(AiurVerificationError::Stark( - VerificationError::InvalidProofShape, - )); - } - } - check_batch_policy(system.circuits.len(), claim, preamble) - .map_err(AiurVerificationError::Policy)?; - Ok(()) -} - -/// The prover RAM model's phase breakdown; `peak` is the number the -/// budget gate compares (see [`AiurSystem::peak_prove_bytes`]). -pub struct PeakProveBytes { - pub phase_witness: usize, - pub phase_stage2: usize, - pub phase_open: usize, - pub preprocessed: usize, - /// What a proof holds of its stage 1 once committed: the stage-1 LDEs, - /// their Merkle tree and the lookup witness — the state a batch prover - /// retains per shard across its barrier under `Retention::Retain`. - pub retained_stage_1: usize, - pub peak: usize, -} - -// The allocation-schedule model below is deliberately structural, but the -// process RSS also contains allocator/runtime residency that it does not name. -// Across the 168 completed Mathlib shard proofs at multi-stark 2892243e, -// measured RSS / analytic peak had median 1.0678 and maximum under-prediction -// 1.0714. A 7.5% envelope covers the full sample with a small margin. The -// workspace now pins 9a906122; retain this historical guard, but re-calibrate -// before treating it as a full-scale safety bound for the new prover. -const PROVER_RSS_CALIBRATION_NUMERATOR: usize = 43; -const PROVER_RSS_CALIBRATION_DENOMINATOR: usize = 40; - -/// Extension degree of the lookup argument's challenge field: the number of -/// base-field columns behind every stage-2 accumulator and quotient column. -pub(crate) const EXTENSION_DEGREE: usize = - >::DIMENSION; - -pub(crate) fn calibrate_prover_rss(analytic_peak: usize) -> usize { - analytic_peak - .checked_mul(PROVER_RSS_CALIBRATION_NUMERATOR) - .map_or(usize::MAX, |scaled| { - scaled.div_ceil(PROVER_RSS_CALIBRATION_DENOMINATOR) - }) -} - -/// Outcome of a budget-gated prove -/// ([`AiurSystem::prove_ixvm_within_budget`]). Only the case that ran a -/// STARK carries a proof; the other two report the measured peak the -/// caller decides with. -// One short-lived value per prove; the variant size gap is irrelevant. -#[allow(clippy::large_enum_variant)] -pub enum GatedProve { - /// Fit the budget; proven from the gating record. - Proved { claim: Vec, proof: AiurProof, peak: usize }, - /// Over budget: the record was dropped, and `parts` is the count - /// [`AiurSystem::suggested_split_parts`] projects will fit. - Split { peak: usize, parts: usize }, - /// `exec_only` with a fitting peak: measured, nothing left to do. - Measured { peak: usize }, - /// The execution itself failed; no record exists. Includes - /// [`ExecError::RecordBudgetExceeded`], which a driver may answer by - /// rerunning the execution with a larger cap. - Failed(ExecError), -} - -/// An execution gated and planned within a budget, ready to prove -/// ([`AiurSystem::prepare_ixvm_within_budget`] → [`AiurSystem::prove_prepared`]). -pub struct PreparedProve { - pub fun_idx: FunIdx, - pub input: Vec, - pub io: IOBuffer, - pub record: QueryRecord, - pub output: Vec, - pub plan: ShardPlan, - pub retention: Retention, - /// The projected prover peak the plan was gated on. - pub peak: usize, -} - -pub struct AiurSystem { - /// 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 - /// verifying-key codec (the config itself doesn't expose them back). - pub(crate) commitment_parameters: CommitmentParameters, - pub(crate) fri_parameters: FriParameters, - pub(crate) system: System, - /// Per-circuit lookup-slot argument widths (in system order), retained so - /// the witness builder can size its `LookupValues` without reading them - /// back off the (now AIR-free) compiled circuits. - slot_widths: Vec>, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub(crate) enum CircuitType { - Function { idx: usize }, - Memory { width: usize }, - Bytes1, - Bytes2, -} - -/// Shape of one compiled circuit, as needed by the Lean-side FFT cost model -/// (`Ix/Aiur/Statistics.lean`). Heights of function and memory circuits are -/// execution-dependent and are NOT part of the shape; `preprocessed_height` -/// doubles as the fixed trace height of the byte-gadget circuits (256 and -/// 65536), whose witness builders always emit the full table. -pub struct CircuitShape { - pub main_width: usize, - pub stage2_width: usize, - pub quotient_degree: usize, - pub preprocessed_width: usize, - pub preprocessed_height: usize, -} - -/// Conservative row count of a circuit under `record`, ceil-divided into -/// `parts` even shares. Sum member-function rows before dividing; circuit -/// indices are not function indices. Unlike witness generation, this count -/// includes zero-multiplicity hint rows. The byte gadgets keep their fixed -/// heights: they are the same size in every -/// shard and are most of the peak model's floor, which dividing cannot -/// shrink. -fn raw_of<'a>( - toplevel: &'a Toplevel, - record: &'a QueryRecord, - parts: usize, -) -> impl Fn(usize, &CircuitType) -> usize + 'a { - move |_, ct| match ct { - CircuitType::Function { idx } => toplevel.circuits[*idx] - .members - .iter() - .fold(0usize, |rows, &member| { - rows.saturating_add(record.function_queries[member].len()) - }) - .div_ceil(parts), - CircuitType::Memory { width } => { - record.memory_queries.get(width).map_or(0, |m| m.len().div_ceil(parts)) - }, - CircuitType::Bytes1 => 256, - CircuitType::Bytes2 => 65536, - } -} - -/// A record and its IO buffer as a supplier hands them to the batch prover -/// ([`AiurSystem::prove_record_supplier`]): borrowed from the caller, or -/// owned by the prover until it moves on to the next record. -pub enum Supplied<'a> { - Borrowed(&'a QueryRecord, &'a IOBuffer), - Owned(Box, Box), - /// A record the supplier keeps a reference to as well, e.g. one it - /// retains for the second round. - Shared(std::sync::Arc<(Box, Box)>), -} - -impl Supplied<'_> { - pub fn record(&self) -> &QueryRecord { - match self { - Self::Borrowed(record, _) => record, - Self::Owned(record, _) => record, - Self::Shared(shared) => &shared.0, - } - } - - pub fn io(&self) -> &IOBuffer { - match self { - Self::Borrowed(_, io) => io, - Self::Owned(_, io) => io, - Self::Shared(shared) => &shared.1, - } - } -} - -impl AiurSystem { - pub fn build( - 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(); - - let mut push_circuit = - |main_width: usize, - preprocessed: Option>, - constraints: Vec>, - lookups: Vec>>, - lookup_group_size: usize| { - slot_widths.push(lookups.iter().map(|l| l.args.len()).collect()); - circuit_inputs.push(CircuitInputs { - main_width, - preprocessed, - constraints, - ext_constraints: vec![], - lookups, - lookup_group_size, - }); - }; - - // Function circuits, in partition order (singletons unless grouped). - for i in 0..toplevel.circuits.len() { - let (constraints, lookups) = toplevel.build_constraints(i); - // A branchless circuit's lookup arguments are sent raw (degree 1; - // see `ConstraintState::gate`), so two lookups fit in one chained - // accumulator step at degree 3 — within the degree the selector-gated - // constraints already pay for. This is the conservative baseline; - // after compilation, retune against actual message degrees and the - // configured quotient budget, including the FFT cost of raising it. - let group_size = - if toplevel.circuit_is_branchless(i) && lookups.len() >= 2 { - 2 - } else { - 1 - }; - push_circuit( - constraints.width, - None, - constraints.zeros, - lookups, - group_size, - ); - } - // Memories. - for &size in &toplevel.memory_sizes { - let (memory, constraints, lookups) = Memory::build(size); - push_circuit(memory.width, None, constraints, lookups, 1); - } - // Gadgets. The byte chips' lookup arguments are preprocessed columns - // and their multiplicities main columns (all degree 1), so their - // lookups also group 2 per chained step at degree 3 — halving the - // stage-2 accumulators (Bytes2: 8 → 4 at height 65536). - push_circuit( - Bytes1.main_width(), - Bytes1.preprocessed(), - vec![], - Bytes1.lookups(), - 2, - ); - push_circuit( - Bytes2.main_width(), - Bytes2.preprocessed(), - vec![], - Bytes2.lookups(), - 2, - ); - - 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 { - crate::lookup_groups::retune( - circuit, - blowup, - >::DIMENSION, - ); - } - debug_assert!( - slot_widths - .iter() - .zip(&system.circuits) - .all(|(slots, circuit)| { slots.len() == circuit.num_lookups }), - "a circuit's lookup slots are its compiled lookups" - ); - AiurSystem { - system, - key, - toplevel, - claim_shapes, - #[cfg(feature = "cuda")] - trace_provider, - commitment_parameters, - fri_parameters, - slot_widths, - } - } - - /// The circuit list in system order: constrained functions (ascending - /// index), then memories, then `Bytes1`, then `Bytes2`. This matches the - /// order the circuits were chained in [`AiurSystem::build`], so index `i` - /// of the returned `Vec` corresponds to `self.system.circuits[i]`. - pub fn toplevel(&self) -> &Toplevel { - &self.toplevel - } - - pub(crate) fn circuit_types(&self) -> Vec { - let functions = (0..self.toplevel.circuits.len()) - .map(|idx| CircuitType::Function { idx }); - let memories = self - .toplevel - .memory_sizes - .iter() - .map(|&width| CircuitType::Memory { width }); - let gadgets = [CircuitType::Bytes1, CircuitType::Bytes2]; - functions.chain(memories).chain(gadgets).collect() - } - - /// The argument width of each lookup slot of circuit `circuit_idx`, taken - /// from the lookups built at construction so the witness layout always - /// matches the compiled circuit. - pub(crate) fn slot_arg_widths(&self, circuit_idx: usize) -> Vec { - self.slot_widths[circuit_idx].clone() - } - - /// Per-circuit shape data for the FFT cost model, read straight off the - /// compiled [`System`] circuits (same order as [`Self::circuit_types`]: - /// constrained functions ascending, memories, `Bytes1`, `Bytes2`). - pub fn circuit_shapes(&self) -> Vec { - self - .system - .circuits - .iter() - .map(|circuit| CircuitShape { - main_width: circuit.main_width, - stage2_width: circuit.stage_2_width, - quotient_degree: circuit.quotient_degree(), - preprocessed_width: circuit.preprocessed_width, - preprocessed_height: circuit.preprocessed_height, - }) - .collect() - } - - /// Predicted peak prover resident bytes for a record, from circuit - /// shapes alone — the analytic counterpart of an empirical GiB-per-fft - /// line. The terms mirror the allocation schedule originally calibrated at - /// multi-stark rev `2892243e`. The workspace now pins `9a906122`, so the - /// model remains useful for relative shard sizing but needs a measured - /// full-scale re-calibration before its absolute bound is relied upon: - /// - /// 1. WITNESS phase: the `QueryRecord` plus every circuit's padded main - /// trace and base-field lookup witness, built in parallel and all - /// alive at once. - /// 2. STAGE-2 transition: stage-1 LDEs and their Merkle tree, the - /// still-alive lookup witness, the logUp message array plus its - /// batch-inverse copy, and the new extension traces. - /// 3. FRI OPEN: all committed LDEs (main + stage-2 + quotient, at - /// `8·2^log_blowup` bytes per trace cell) and their trees, the - /// retained FRI fold layers (geometric in `max_log_arity`), and the - /// open-phase buffers — all proportional to `H = blowup · tallest`. - /// - /// The analytic peak is the max of the three plus the - /// preprocessed-gadget residency committed at setup. The returned `peak` - /// additionally applies [`calibrate_prover_rss`] to cover measured - /// allocator/runtime residency. Heights are `next_power_of_two` of the - /// record's unique queries — the padding the trace actually commits, - /// which per-fft models blur. - pub fn peak_prove_bytes(&self, record: &QueryRecord) -> PeakProveBytes { - self.peak_prove_bytes_by( - raw_of(&self.toplevel, record, 1), - crate::execute::record_retained_bytes(record), - ) - } - - pub(crate) fn peak_prove_bytes_by( - &self, - raw_of: impl Fn(usize, &CircuitType) -> usize, - record_bytes: usize, - ) -> PeakProveBytes { - const S: usize = 8; // bytes per base field element (Goldilocks) - const DG: usize = 32; // blake3 digest bytes (Merkle nodes, arity 2) - let b = 1usize << self.commitment_parameters.log_blowup; - let fold = 1usize << self.fri_parameters.max_log_arity; - let circuit_types = self.circuit_types(); - let ncirc = self.system.circuits.len(); - let mut tallest = 0usize; - for (i, ct) in circuit_types.iter().enumerate().take(ncirc) { - let raw = raw_of(i, ct); - if raw != 0 { - tallest = tallest.max(raw.next_power_of_two()); - } - } - let mut witness = 0usize; - let mut s1_lde = 0usize; // stage-1 LDEs - let mut lookup_w = 0usize; // base-field lookup witness - let mut msgs = 0usize; // logUp messages (+ inverse copy) - let mut s2_trace = 0usize; // stage-2 extension traces - let mut committed = 0usize; // all committed LDE bytes - let mut prep = 0usize; - for (i, ct) in circuit_types.iter().enumerate().take(ncirc) { - let raw = raw_of(i, ct); - if raw == 0 { - continue; - } - let n = raw.next_power_of_two(); - let c = &self.system.circuits[i]; - let d = EXTENSION_DEGREE; - let args: usize = self.slot_widths[i].iter().sum(); - let q = c.quotient_degree(); - let metadata = match ct { - CircuitType::Function { idx } => crate::trace::witness_metadata_bytes( - self.toplevel.circuits[*idx].members.len(), - raw, - ), - _ => 0, - }; - witness += S * n * c.main_width - + S * n * (c.num_lookups + args) - + size_of::>() * n - + metadata; - s1_lde += S * b * n * c.main_width; - lookup_w += S * n * (c.num_lookups + args); - msgs += 2 * S * d * n * c.num_lookups; - s2_trace += S * n * c.stage_2_width; - committed += S * b * n * (c.main_width + c.stage_2_width + q * d); - prep += S * (1 + b) * c.preprocessed_width * c.preprocessed_height - + 2 * DG * b * c.preprocessed_height; - } - let h = b * tallest; - let phase_witness = record_bytes + witness; - let phase_stage2 = s1_lde + 2 * DG * h + lookup_w + msgs + s2_trace; - // Trees (3 rounds) + retained FRI fold layers + open buffers, all ∝ H. - let fri_layers = (2 * S + 2 * DG) * h * fold / (fold - 1).max(1); - let phase_open = committed + 3 * 2 * DG * h + fri_layers + 11 * S * h; - let analytic_peak = phase_witness.max(phase_stage2).max(phase_open) + prep; - PeakProveBytes { - phase_witness, - phase_stage2, - phase_open, - preprocessed: prep, - retained_stage_1: s1_lde + 2 * DG * h + lookup_w, - peak: calibrate_prover_rss(analytic_peak), - } - } - - /// Smallest power-of-two part count whose projected per-part peak - /// fits `max_bytes`, assuming the record's rows divide evenly across - /// parts. The gadget circuits keep their constant heights — they are - /// the same size in every shard and are most of the model's fixed - /// floor, which dividing cannot shrink. - /// - /// The estimate is optimistic: a part re-executes dependencies shared - /// across the cut, so its real rows exceed its 1/n share. A caller - /// splitting on this number must still gate each part on its own - /// executed record and re-split the ones that miss. Optimism is the - /// right bias — an under-split costs one cheap re-execution, while an - /// over-split pays the per-proof floor on every extra part forever. - /// - /// Returns 1 when the record already fits. - pub fn suggested_split_parts( - &self, - record: &QueryRecord, - max_bytes: usize, - ) -> usize { - let record_bytes = crate::execute::record_retained_bytes(record); - let mut parts = 1usize; - // A shard still over budget at 2^20 parts is not splittable by row - // count; stop rather than search forever. - while parts < (1 << 20) { - let peak = self - .peak_prove_bytes_by( - raw_of(&self.toplevel, record, parts), - record_bytes / parts, - ) - .peak; - if peak <= max_bytes { - break; - } - parts *= 2; - } - parts - } - - /// Prove an execution that has ALREADY happened: everything from the - /// witness phase on, over a record the caller hands across. - /// - /// Taking `query_record` by value is the point. The record is the - /// witness phase's dominant residency, and it is dropped here the - /// instant the traces exist — before the LDE/commit/FRI phases that - /// actually set the prover's peak (see [`Self::peak_prove_bytes`]). - /// A caller that keeps its own copy alive past this call pays that - /// peak *on top of* the record, which at shard scale is the - /// difference between fitting in RAM and not. - /// - /// `input`, `io_buffer` and `output` must be the ones the execution - /// ran on: they reconstruct the claim the proof commits to, and the - /// witness reads the buffer the execution left behind. - /// - /// Deliberately not `#[tracing::instrument]`ed — the `aiur/witness` - /// span below stays directly under the caller's `aiur/prove*` span, - /// so the stage-scoped measurements keep their existing shape. - pub fn prove_from_execution( - &self, - fun_idx: FunIdx, - input: &[G], - io_buffer: &IOBuffer, - query_record: QueryRecord, - output: &[G], - ) -> (Vec, AiurProof) { - let plan = self.single_shard_plan(&query_record); - self.prove_from_execution_planned( - fun_idx, - input, - io_buffer, - query_record, - output, - &plan, - Retention::Retain, - ) - } - - /// Proves several records as one batch under one claim: the executions of - /// one statement split across records by deferred calls - /// ([`crate::execute::Ownership`]), each with its own pointer base. Each - /// record is planned on its own to `max_cells` and its shards join the - /// batch in record order; the claim rides on the first shard, and the - /// closure messages cover every record's memory intervals. The records' - /// deferred multiplicities must already be absorbed by their owners - /// ([`QueryRecord::absorb_deferred`]); the witness of every shard is - /// rebuilt from its record for round two. Fails when a shard exceeds - /// `max_cells` (a row wider than the budget) or the batch exceeds - /// [`crate::shard::MAX_SHARDS`], rather than proving what cannot verify. - pub fn prove_records( - &self, - fun_idx: FunIdx, - input: &[G], - output: &[G], - records: &[(QueryRecord, &IOBuffer)], - max_cells: Option, - ) -> Result<(Vec, AiurProof), String> { - self.prove_record_supplier( - fun_idx, - input, - || output.to_vec(), - records.len(), - |r| Ok(Supplied::Borrowed(&records[r].0, records[r].1)), - max_cells, - ) - } - - /// [`Self::prove_records`] with the records handed over one at a time: - /// `supply(r)` is called when record `r` is next in batch order — once - /// for round one, once for round two — and what it hands over is dropped - /// when the batch moves on to the next record. A supplier may therefore - /// execute a record at its first call, keep or recompute it for the - /// second, and hold at most one record with the prover. The records are - /// planned as they arrive (nothing about a later record is needed before - /// an earlier one is committed) and the closure messages are formed once - /// every record's memory totals are known. The claim's `output` is asked - /// for when the first shard is committed, after the first record was - /// supplied, so the execution that produces it need not precede the - /// batch. - #[tracing::instrument(level = "info", skip_all, name = "aiur/prove_records")] - pub fn prove_record_supplier<'a, O, S>( - &self, - fun_idx: FunIdx, - input: &[G], - output: O, - count: usize, - mut supply: S, - max_cells: Option, - ) -> Result<(Vec, AiurProof), String> - where - 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()); - } - let mut output = Some(output); - let mut claim: Option> = None; - // Filled by round one as records arrive, read by round two. - let mut plans: Vec = Vec::with_capacity(count); - let mut indexes: Vec = Vec::with_capacity(count); - // Batch shard `k` is local shard `s` of record `r`. - let mut locate: Vec<(usize, usize)> = Vec::new(); - let mut failure: Option = None; - - // Round one: record by record, shard by shard. The record at hand - // stays only until its last shard is committed. The stream borrows the - // state above until the round is over. - let mut current: Option<(usize, Supplied<'a>, usize)> = None; - let mut next_record = 0usize; - let round_one = std::iter::from_fn(|| { - loop { - if let Some((r, supplied, shard)) = &mut current { - let plan = &plans[*r]; - if *shard < plan.num_shards() { - let s = *shard; - *shard += 1; - let claims = if locate.is_empty() { - let mut formed = vec![function_channel(), G::from_usize(fun_idx)]; - formed.extend(input); - let output = output.take().expect("the output is asked once"); - formed.extend(output()); - claim = Some(formed.clone()); - vec![formed] - } else { - vec![] - }; - locate.push((*r, s)); - let _g = tracing::info_span!( - "aiur/witness", - shard = locate.len() - 1, - record = *r, - record_shard = s, - round = 1 - ) - .entered(); - let witness = self.prepared_shard_witness( - supplied.record(), - supplied.io(), - plan, - &indexes[*r], - s, - BatchRound::One, - ); - return Some((claims, witness)); - } - current = None; - } - if next_record == count { - return None; - } - let r = next_record; - next_record += 1; - let supplied = match supply(r) { - Ok(supplied) => supplied, - Err(error) => { - failure = Some(format!("record {r}: {error}")); - return None; - }, - }; - let plan = self.plan_shards(supplied.record(), max_cells); - if locate.len() + plan.num_shards() > crate::shard::MAX_SHARDS { - failure = - Some(format!("record {r}: the batch exceeds the shard limit")); - return None; - } - if let Some(max_cells) = max_cells { - let heaviest = self.shard_committed_cells(&plan).into_iter().max(); - if let Some(cells) = heaviest.filter(|&cells| cells > max_cells) { - failure = Some(format!( - "record {r}: a shard of {cells} committed cells exceeds the \ - budget of {max_cells}" - )); - return None; - } - } - eprintln!("[distributed] record {r}: {} shards", plan.num_shards()); - indexes.push(self.row_index(supplied.record(), &plan)); - plans.push(plan); - current = Some((r, supplied, 0)); - } - }); - let barrier = self - .system - .batch_round_one(round_one, trace_retention(Retention::Regenerate)); - if let Some(error) = failure { - return Err(error); - } - let claim = claim.ok_or("no shards to prove")?; - let mut memory_totals: Vec<(usize, usize, usize)> = plans - .iter() - .flat_map(|plan| plan.memory_totals.iter().copied()) - .collect(); - memory_totals.sort_unstable(); - let messages = - Self::boundary_messages(&ShardPlan { shards: vec![], memory_totals }); - - // Round two: the record is asked for again when the batch order - // reaches it and dropped when the order moves on. - let mut loaded: Option<(usize, Supplied<'a>)> = None; - let proof = - self.system.batch_round_two(&self.key, barrier, messages, |k| { - let (r, s) = locate[k]; - if loaded.as_ref().is_none_or(|(at, _)| *at != r) { - loaded = None; - let supplied = - supply(r).unwrap_or_else(|error| panic!("record {r}: {error}")); - loaded = Some((r, supplied)); - } - let supplied = &loaded.as_ref().expect("loaded above").1; - let _g = tracing::info_span!( - "aiur/witness", - shard = k, - record = r, - record_shard = s, - round = 2 - ) - .entered(); - self.prepared_shard_witness( - supplied.record(), - supplied.io(), - &plans[r], - &indexes[r], - s, - BatchRound::Two, - ) - }); - Ok((claim, proof)) - } - - /// [`Self::prove_from_execution`] with the record's rows dealt out to the - /// fewest shards whose committed cells each fit `max_cells` - /// ([`Self::plan_shards`]). With more than one shard, only the headers - /// survive the batch barrier and each shard is rebuilt from the record - /// for round two ([`Retention::Regenerate`]), so the peak is the record - /// plus one shard rather than the stage-1 state of every shard. A plan - /// of one shard has nothing to save and is proven as the unsharded - /// execution is ([`Retention::Retain`]). - pub fn prove_from_execution_sharded( - &self, - fun_idx: FunIdx, - input: &[G], - io_buffer: &IOBuffer, - query_record: QueryRecord, - output: &[G], - max_cells: usize, - ) -> (Vec, AiurProof) { - let plan = self.plan_shards(&query_record, Some(max_cells)); - let retention = if plan.num_shards() == 1 { - Retention::Retain - } else { - Retention::Regenerate - }; - self.prove_from_execution_planned( - fun_idx, - input, - io_buffer, - query_record, - output, - &plan, - retention, - ) - } - - /// Proves an execution as the batch of trace shards `plan` describes: one - /// witness per shard, the claim in shard 0, and the `memseg` closure - /// messages for the plan's memory totals. - /// - /// Under [`Retention::Retain`] every shard's witness is built first and - /// the record is released before proving starts, so the record and the - /// proving state never coexist, but the whole batch's stage 1 does. Under - /// [`Retention::Regenerate`] the record stays until the last shard is - /// proven and each shard's witness is built from it when needed, twice. - #[tracing::instrument(level = "info", skip_all, name = "aiur/prove_planned", fields(pieces = plan.num_shards()))] - pub fn prove_from_execution_planned( - &self, - fun_idx: FunIdx, - input: &[G], - io_buffer: &IOBuffer, - query_record: QueryRecord, - output: &[G], - plan: &ShardPlan, - retention: Retention, - ) -> (Vec, AiurProof) { - // A shape-only lookup witness (trace-only lookups) has no payload for - // the backend's retained-stage-1 path to read, so every shard is - // rebuilt for round two, where the lookups are evaluated on the device. - let retention = trace_retention(retention); - // Construct the claim. - let mut claim = vec![function_channel(), G::from_usize(fun_idx)]; - claim.extend(input); - claim.extend(output); - - let claims: Vec>> = (0..plan.num_shards()) - .map(|shard| if shard == 0 { vec![claim.clone()] } else { vec![] }) - .collect(); - let messages = Self::boundary_messages(plan); - let index = self.row_index(&query_record, plan); - let build = |shard: usize, round: BatchRound| { - let round_number = match round { - BatchRound::One => 1, - BatchRound::Two => 2, - }; - let _g = tracing::info_span!("aiur/witness", shard, round = round_number) - .entered(); - 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. - Retention::Retain => { - let mut witnesses: Vec<_> = (0..plan.num_shards()) - .map(|shard| Some(build(shard, BatchRound::Two))) - .collect(); - drop(query_record); - self.system.prove_batch_with( - &self.key, - &claims, - messages, - Retention::Retain, - |shard| witnesses[shard].take().expect("each shard is built once"), - ) - }, - Retention::Regenerate => { - let barrier = self.system.batch_round_one( - (0..plan.num_shards()).map(|shard| { - (claims[shard].clone(), build(shard, BatchRound::One)) - }), - Retention::Regenerate, - ); - self.system.batch_round_two(&self.key, barrier, messages, |shard| { - build(shard, BatchRound::Two) - }) - }, - }; - (claim, proof) - } - - #[tracing::instrument(level = "info", skip_all, name = "aiur/prove")] - pub fn prove( - &self, - fun_idx: FunIdx, - input: &[G], - io_buffer: &mut IOBuffer, - ) -> (Vec, AiurProof) { - #[cfg(feature = "texray")] - tracing_texray::examine_current(); - - // Execute the Aiur bytecode. - let _g = tracing::info_span!("aiur/execute").entered(); - // Execute the Aiur bytecode. The prover assumes inputs are valid; any - // execution error here is a programmer bug, so we unwrap. - let (query_record, output) = self - .toplevel - .execute(fun_idx, input.to_vec(), io_buffer) - .expect("Aiur execution failed during prove"); - drop(_g); - - self.prove_from_execution(fun_idx, input, io_buffer, query_record, &output) - } - - /// IxVM-native prove: identical to `prove` except the execute step - /// is provided by the caller as `executor` (a closure that runs - /// the codegen'd Rust kernel `ix::aiur_ixvm_runner::execute_ixvm` - /// instead of the bytecode interpreter). Avoids a circular crate - /// dependency: `aiur` doesn't know about `ix`; `ix` (or its - /// downstream `ffi`) injects the executor. - /// - /// QueryRecord shape + witness construction + claim layout + proof - /// generation are all unchanged — the proof produced here is - /// verification-compatible with one produced by `prove`. - #[tracing::instrument(level = "info", skip_all, name = "aiur/prove_ixvm")] - pub fn prove_ixvm( - &self, - fun_idx: FunIdx, - input: &[G], - io_buffer: &mut IOBuffer, - executor: F, - ) -> (Vec, AiurProof) - where - F: FnOnce( - &Toplevel, - FunIdx, - Vec, - &mut IOBuffer, - ) -> Result<(QueryRecord, Vec), ExecError>, - { - match self.prove_ixvm_within_budget( - fun_idx, input, io_buffer, executor, None, false, false, None, - ) { - GatedProve::Proved { claim, proof, .. } => (claim, proof), - _ => unreachable!("an unbudgeted prove always proves"), - } - } - - /// `prove_ixvm`, but the record's projected prover peak has to fit - /// `max_bytes` before any proving starts (`None` skips the check), - /// and `exec_only` stops after execution + measurement — the split - /// loop runs on executions alone, no STARK started. - /// - /// The peak is measured on the REAL record ([`Self::peak_prove_bytes`]), - /// not estimated from serialized bytes, so an over-budget shard is - /// caught in the gap between execution and the witness phase — before - /// the LDE/commit/FRI phases that would actually exhaust the box. With - /// `trace_shards`, an over-budget record is first planned as trace - /// shards ([`Self::plan_shards_within`]) and, if some shard count fits, - /// proven as that batch with the record resident throughout; the peak - /// reported is then the heaviest shard's projection. Otherwise — or - /// without `trace_shards` — the record is dropped and - /// [`GatedProve::Split`] carries the part count - /// [`Self::suggested_split_parts`] projects will fit, computed here - /// because this is the last moment the record exists to read counts - /// from. Every outcome carries the measured peak: proving a shard - /// measures it for free, so a prove run yields the same split/merge - /// signal a check run does without a second execution. - #[tracing::instrument( - level = "info", - skip_all, - name = "aiur/prove_ixvm_within_budget" - )] - pub fn prove_ixvm_within_budget( - &self, - fun_idx: FunIdx, - input: &[G], - io_buffer: &mut IOBuffer, - executor: F, - max_bytes: Option, - exec_only: bool, - trace_shards: bool, - retention: Option, - ) -> GatedProve - where - F: FnOnce( - &Toplevel, - FunIdx, - Vec, - &mut IOBuffer, - ) -> Result<(QueryRecord, Vec), ExecError>, - { - #[cfg(feature = "texray")] - tracing_texray::examine_current(); - let prepared = match self.prepare_ixvm_within_budget( - fun_idx, - input, - io_buffer, - executor, - max_bytes, - trace_shards, - retention, - ) { - Ok(prepared) => prepared, - Err(gated) => return gated, - }; - if exec_only { - return GatedProve::Measured { peak: prepared.peak }; - } - let (claim, proof, peak) = self.prove_prepared(prepared); - GatedProve::Proved { claim, proof, peak } - } - - /// The execution half of [`Self::prove_ixvm_within_budget`]: executes, - /// gates the record against `max_bytes` and plans its trace shards, - /// returning everything [`Self::prove_prepared`] needs, so that the - /// execution of one proof can run while another proves. `io_buffer` is - /// taken (left empty) for the prepared proof. `Err` is the over-budget - /// outcome ([`GatedProve::Split`]). - pub fn prepare_ixvm_within_budget( - &self, - fun_idx: FunIdx, - input: &[G], - io_buffer: &mut IOBuffer, - executor: F, - max_bytes: Option, - trace_shards: bool, - retention: Option, - ) -> Result - where - F: FnOnce( - &Toplevel, - FunIdx, - Vec, - &mut IOBuffer, - ) -> Result<(QueryRecord, Vec), ExecError>, - { - let _g = tracing::info_span!("aiur/execute_ixvm").entered(); - let (query_record, output) = - executor(&self.toplevel, fun_idx, input.to_vec(), io_buffer) - .map_err(GatedProve::Failed)?; - if let Some(reservation) = &query_record.budget.reservation { - reservation.finish_execution(); - } - drop(_g); - let io = std::mem::replace( - io_buffer, - IOBuffer { data: Default::default(), map: Default::default() }, - ); - - let peak = self.peak_prove_bytes(&query_record).peak; - if let Some(budget) = query_record - .budget - .reservation - .as_ref() - .and_then(|reservation| reservation.prover_budget()) - { - let record_bytes = crate::execute::record_retained_bytes(&query_record); - let mut cells = budget.trace_cells; - loop { - let plan = self.plan_shards(&query_record, Some(cells)); - let workspace = (0..plan.num_shards()) - .map(|shard| { - self.shard_host_workspace( - &plan, - shard, - !crate::trace::trace_only_lookups(), - ) - }) - .max() - .unwrap_or(0); - if workspace <= budget.host_workspace { - let shard_peak = (0..plan.num_shards()) - .map(|shard| self.shard_peak_bytes(&plan, shard, record_bytes)) - .max() - .unwrap_or(0); - eprintln!( - "[trace-shards] {} shards, {cells} committed cells: record {record_bytes} B in shared pool, host workspace {workspace} B of {} B reserved per prover; regenerating round 2", - plan.num_shards(), - budget.host_workspace, - ); - return Ok(PreparedProve { - fun_idx, - input: input.to_vec(), - io, - record: query_record, - output, - plan, - retention: Retention::Regenerate, - peak: shard_peak, - }); - } - if cells == 1 { - return Err(GatedProve::Split { peak: workspace, parts: 1 }); - } - cells = (cells / 2).max(1); - } - } - // `AIUR_TRACE_SHARD_MAX_CELLS` is a device-residency bound (VRAM) in - // committed cells: with it every trace-sharded proof is planned to - // cells, whatever the host peak, and the plan is then held to the host - // budget separately. - let device_cells = trace_shards - .then(|| { - std::env::var("AIUR_TRACE_SHARD_MAX_CELLS") - .ok() - .and_then(|v| v.parse::().ok()) - }) - .flatten(); - let max = max_bytes.unwrap_or(usize::MAX); - if device_cells.is_some() || peak > max { - if trace_shards { - let record_bytes = crate::execute::record_retained_bytes(&query_record); - let planned = match device_cells { - Some(cells) => { - let plan = self.plan_shards(&query_record, Some(cells)); - let shard_peak = (0..plan.num_shards()) - .map(|s| self.shard_peak_bytes(&plan, s, record_bytes)) - .max() - .unwrap_or(0); - if shard_peak > max { - eprintln!( - "[trace-shards] the {}-shard plan for {cells} committed cells projects a {shard_peak} B host peak over the {max} B budget", - plan.num_shards() - ); - Err(shard_peak) - } else { - Ok((plan, shard_peak)) - } - }, - None => self.plan_shards_within(&query_record, max), - }; - match planned { - Ok((plan, shard_peak)) => { - let retention = - trace_retention(retention.unwrap_or_else(|| { - self.retention_for(&plan, record_bytes, max) - })); - eprintln!( - "[trace-shards] {} shards for a {} B budget: record {} B, \ - whole-execution peak {} B, heaviest shard peak {} B, {}", - plan.num_shards(), - max, - record_bytes, - peak, - shard_peak, - match retention { - Retention::Retain => "retaining every shard's stage 1", - Retention::Regenerate => "regenerating each shard for round 2", - } - ); - // Per-circuit committed widths, so a plan's padded cells and - // active width can be computed from the row ranges below. - let widths: Vec = - self.committed_widths().iter().map(usize::to_string).collect(); - eprintln!("[trace-shards] committed widths: {}", widths.join(" ")); - for (shard, rows) in plan.shards.iter().enumerate() { - let ranges: Vec = rows - .rows - .iter() - .enumerate() - .filter(|(_, r)| !r.is_empty()) - .map(|(ci, r)| format!("{ci}:{}..{}", r.start, r.end)) - .collect(); - eprintln!( - "[trace-shards] shard {shard}: projected peak {} B, rows {}", - self.shard_peak_bytes(&plan, shard, record_bytes), - ranges.join(" ") - ); - } - return Ok(PreparedProve { - fun_idx, - input: input.to_vec(), - io, - record: query_record, - output, - plan, - retention, - peak: shard_peak, - }); - }, - Err(floor) => eprintln!( - "[trace-shards] no shard count fits a {} B budget: record {} B, \ - whole-execution peak {} B, lowest heaviest-shard peak {} B", - max, record_bytes, peak, floor - ), - } - } - let parts = self.suggested_split_parts(&query_record, max); - return Err(GatedProve::Split { peak, parts }); - } - let plan = self.single_shard_plan(&query_record); - Ok(PreparedProve { - fun_idx, - input: input.to_vec(), - io, - record: query_record, - output, - plan, - retention: Retention::Retain, - peak, - }) - } - - /// The proving half of [`Self::prove_ixvm_within_budget`]: proves the - /// prepared execution as the batch its plan describes. Returns the claim, - /// the proof and the peak the preparation measured. - pub fn prove_prepared( - &self, - prepared: PreparedProve, - ) -> (Vec, AiurProof, usize) { - let PreparedProve { - fun_idx, - input, - io, - record, - output, - plan, - retention, - peak, - } = prepared; - let (claim, proof) = self.prove_from_execution_planned( - fun_idx, &input, &io, record, &output, &plan, retention, - ); - (claim, proof, peak) - } - - /// Verifies a proof of `claim`: the claim's shape against the bytecode, - /// then everything [`verify_against`] checks from the verifying key alone. - pub fn verify( - &self, - claim: &[G], - proof: &AiurProof, - ) -> Result<(), AiurVerificationError> { - if !valid_claim_shape(&self.claim_shapes, claim) { - return Err(AiurVerificationError::Stark( - VerificationError::InvalidClaim, - )); - } - verify_against(&self.system, self.commitment_parameters, claim, proof) - } - - /// Verify and serialize the native Plonky3 multiproof for the in-circuit - /// recursive verifier. - pub fn proof_to_advice_bytes( - &self, - claim: &[G], - proof: &AiurProof, - ) -> Result, String> { - self.verify(claim, proof).map_err(|e| format!("{e:?}"))?; - proof.to_bytes().map_err(|e| format!("{e:?}")) - } -} - -/// Proofs over supplied witnesses, and per-shard verdicts, for tests that -/// forge what an honest execution never produces. -#[cfg(test)] -impl AiurSystem { - /// A one-shard batch over `witness`, claiming `claim`. - pub(crate) fn prove_witness( - &self, - claim: &[G], - witness: multi_stark::system::SystemWitness, - ) -> AiurProof { - let shard = - multi_stark::batch::ShardInput { claims: vec![claim.to_vec()], witness }; - self.prove_witnesses(vec![shard], vec![]) - } - - /// A batch over supplied shards and public messages. - pub(crate) fn prove_witnesses( - &self, - shards: Vec>, - messages: Vec>, - ) -> AiurProof { - self.system.prove_batch(&self.key, shards, messages) - } - - /// Shard `shard` of `proof` against its preamble alone: the verdict - /// before the batch's residuals are summed, so a failure here is the - /// shard's own and not a balance the rest of the batch might supply. - pub(crate) fn verify_shard( - &self, - proof: &AiurProof, - shard: usize, - ) -> Result<(), VerificationError> { - self - .system - .verify_batch_shard(&proof.preamble, shard, &proof.proofs[shard]) - .map(|_| ()) - } -} - -fn trace_retention(requested: Retention) -> Retention { - if crate::trace::trace_only_lookups() && requested == Retention::Retain { - Retention::Regenerate - } else { - requested - } -} - -#[cfg(test)] -mod tests { - mod acceptance; - mod branchless; - mod byte_consolidation; - mod byte_shapes; - mod host_timings; - mod lookup_budget; - mod lookup_groups; - mod lookup_shapes; - mod mmcs; - mod peak; - mod u32_compare; - - use super::*; - use crate::{ - bytecode::{Block, Ctrl, Function, FunctionLayout, Op, Toplevel}, - execute::{IOBuffer, Ownership, pointer_stride}, - shard::ShardRows, - }; - use multi_stark::{ - lookup::LookupValues, - p3_field::PrimeCharacteristicRing, - system::SystemWitness, - types::{CommitmentParameters, FriParameters}, - }; - use rustc_hash::FxHashMap; - - /// A grouped circuit's raw rows are the sum over its members — the peak - /// model must not read one function's entries by circuit index. - #[test] - fn grouped_circuit_rows_sum_their_members() { - let mut toplevel = call_and_memory_toplevel(); - let layout = toplevel.circuits[0].layout; - toplevel.circuits = - vec![crate::bytecode::Circuit { members: vec![0, 1], layout }]; - let mut io_buffer = empty_io_buffer(); - let (record, _) = toplevel - .execute(0, vec![G::from_u64(3), G::from_u64(5)], &mut io_buffer) - .expect("f(3, 5) executes"); - let f_rows = record.function_queries[0].len(); - let g_rows = record.function_queries[1].len(); - assert!(f_rows > 0 && g_rows > 0); - let grouped = CircuitType::Function { idx: 0 }; - assert_eq!(raw_of(&toplevel, &record, 1)(0, &grouped), f_rows + g_rows); - assert_eq!( - raw_of(&toplevel, &record, 2)(0, &grouped), - (f_rows + g_rows).div_ceil(2) - ); - } - - #[test] - fn prover_rss_calibration_rounds_up_and_saturates() { - assert_eq!(calibrate_prover_rss(40), 43); - assert_eq!(calibrate_prover_rss(1_000), 1_075); - 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). - fn test_parameters() -> (CommitmentParameters, FriParameters) { - let cp = CommitmentParameters { log_blowup: 1, 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, - }; - (cp, fp) - } - - fn empty_io_buffer() -> IOBuffer { - IOBuffer { data: FxHashMap::default(), map: FxHashMap::default() } - } - - #[test] - fn fixed_normalization_pads_unused_tables_and_checks_bounds() { - let (cp, fp) = test_parameters(); - let mut toplevel = call_and_memory_toplevel(); - toplevel.memory_sizes.push(2); // An unused memory table must also be active. - let system = AiurSystem::build(toplevel, cp, fp); - let mut heights = vec![4; system.system.circuits.len()]; - let n = heights.len(); - heights[n - 3] = 1; // Unused memory has its own small bound. - heights[n - 2] = 8; - heights[n - 1] = 16; - let mut previous = None; - for input in [ - vec![G::from_u64(3), G::from_u64(5)], - vec![G::from_u64(7), G::from_u64(11)], - ] { - let mut io = empty_io_buffer(); - let (record, output) = - system.toplevel().execute(0, input.clone(), &mut io).unwrap(); - let (claim, proof) = system - .prove_from_execution_normalized( - 0, &input, &io, record, &output, &heights, - ) - .unwrap(); - system.verify(&claim, &proof).unwrap(); - assert!(proof.preamble.headers[0].active.iter().all(|&v| v)); - let logs = &proof.preamble.headers[0].log_degrees; - assert_eq!(logs, &heights); - if let Some(old) = &previous { - assert_eq!(old, logs); - } - previous = Some(logs.clone()); - assert_eq!( - proof.preamble.messages.len(), - 2 * system.toplevel().memory_sizes.len() - ); - let mut invalid = - vec![vec![], vec![0; heights.len()], vec![27; heights.len()]]; - let mut wrong_fixed = heights.clone(); - wrong_fixed[n - 1] = 15; - invalid.push(wrong_fixed); - for wrong in invalid { - let (record, output) = - system.toplevel().execute(0, input.clone(), &mut io).unwrap(); - assert!( - system - .prove_from_execution_normalized( - 0, &input, &io, record, &output, &wrong - ) - .is_err() - ); - } - } - let mut io = empty_io_buffer(); - let mut record = QueryRecord::new(system.toplevel()); - for i in 0..3 { - system - .toplevel() - .execute_in(0, vec![G::from_usize(i), G::ONE], &mut io, &mut record) - .unwrap(); - } - heights[0] = 1; - let err = system - .prove_from_execution_normalized(0, &[], &io, record, &[], &heights) - .err() - .expect("oversized execution"); - assert!(err.contains("needs 3 rows; configured bound is 2"), "{err}"); - } - - /// Hand-build the toplevel for a single constrained function `f(a, b) = a*b`. - /// - /// Body: `Mul(0, 1)` (multiplies the two inputs, which live at value indices - /// 0 and 1, producing value index 2), then `Return(0, [2])`. - /// - /// Layout — matched against how `constraints.rs`/`trace.rs` walk the block: - /// - `input_size = 2`: the two inputs `a`, `b`. - /// - `selectors = 1`: the single `Return` (selector index 0). - /// - `auxiliaries = 2`: the multiplicity column (allocated first for every - /// function) plus one auxiliary for the `Mul` — `a` and `b` each have - /// degree 1, so `a*b` has degree 2 and `constraints.rs` spills it into a - /// fresh auxiliary column pinned by `sel * (col - a*b)`. - /// - `lookups = 1`: the function-provide (return) lookup in slot 0, which - /// pulls the claim `[function_channel, fun_idx, a, b, a*b]`. - /// - /// Test-side singleton partition (production circuits come pre-built from - /// the Lean compiler). - fn with_singleton_circuits( - functions: Vec, - memory_sizes: Vec, - ) -> Toplevel { - let circuits = functions - .iter() - .enumerate() - .filter(|(_, f)| f.constrained) - .map(|(i, f)| crate::bytecode::Circuit { - members: vec![i], - layout: f.layout, - }) - .collect(); - Toplevel { functions, memory_sizes, circuits } - } - - fn mul_toplevel() -> Toplevel { - let body = - Block { ops: vec![Op::Mul(0, 1)], ctrl: Ctrl::Return(0, vec![2]) }; - let function = Function { - body, - layout: FunctionLayout { - input_size: 2, - selectors: 1, - auxiliaries: 2, - lookups: 1, - }, - entry: true, - constrained: true, - }; - with_singleton_circuits(vec![function], vec![]) - } - - fn xor_splits_toplevel() -> Toplevel { - let body = Block { - ops: vec![Op::U8XorSplit7(0, 1), Op::U8XorSplit4(0, 1)], - ctrl: Ctrl::Return(0, vec![2, 3, 4, 5]), - }; - let function = Function { - body, - layout: FunctionLayout { - input_size: 2, - selectors: 1, - auxiliaries: 5, - lookups: 3, - }, - entry: true, - constrained: true, - }; - with_singleton_circuits(vec![function], vec![]) - } - - #[test] - fn prove_verify_xor_splits() { - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(xor_splits_toplevel(), cp, fp); - let input = [G::from_u8(0xd3), G::from_u8(0x69)]; - let mut io_buffer = empty_io_buffer(); - - let (claim, proof) = system.prove(0, &input, &mut io_buffer); - let (s7_hi, s7_lo) = Bytes2::xor_split7(&input[0], &input[1]); - let (s4_hi, s4_lo) = Bytes2::xor_split4(&input[0], &input[1]); - assert_eq!( - claim, - vec![ - function_channel(), - G::ZERO, - input[0], - input[1], - s7_hi, - s7_lo, - s4_hi, - s4_lo, - ] - ); - system.verify(&claim, &proof).expect("xor split outputs must verify"); - - // The compression verifier receives only the serialized verifier key, not the - // prover-side `AiurSystem`. Exercise that exact path against a real proof - // so codec round trips alone cannot mask a transcript/config mismatch. - let vk_bytes = crate::vk_codec::aiur_system_to_bytes(&system) - .expect("encode verifier key"); - let vk = crate::vk_codec::AiurVerifyingKey::from_bytes(&vk_bytes) - .expect("decode verifier key"); - assert_eq!(vk.to_bytes(), vk_bytes, "verifier key is canonical"); - vk.verify(&claim, &proof).expect("decoded verifier key must verify"); - - let mut tampered_claim = claim.clone(); - tampered_claim[2] += G::ONE; - assert!( - vk.verify(&tampered_claim, &proof).is_err(), - "decoded verifier key must bind the outer claim" - ); - } - - /// Hand-build a toplevel exercising the two migrated integration paths that - /// the `Mul` test does not: the cross-circuit **function-channel** lookup (a - /// function calling another) and the **memory circuit** (a `Store` followed - /// by a `Load`, which adds a `Memory` circuit and proves its migrated - /// transition + memory-channel-lookup constraints). - /// - /// Functions: - /// - `f` (idx 0, entry): `f(a, b) = g(a) * b`, but routing `b` through - /// memory so the memory path is live: - /// - `Call(1, [a], 1, false)` → `g(a)` at value idx 2, allocating one - /// output auxiliary + one function-channel lookup slot. - /// - `Store([b])` → pointer at value idx 3, allocating one pointer - /// auxiliary + one memory-channel lookup slot (multiplicity pushed). - /// - `Load(1, 3)` → the loaded `b` at value idx 4, allocating one value - /// auxiliary + one memory-channel lookup slot. - /// - `Mul(2, 4)` → `g(a) * b` (both degree 1 ⇒ degree 2 ⇒ spilled into a - /// fresh auxiliary at value idx 5). - /// - `Return(0, [5])`. - /// - /// Layout for `f` — matched against how `constraints.rs`/`trace.rs` walk - /// the block: - /// - `input_size = 2` (`a`, `b`). - /// - `selectors = 1` (the single `Return`). - /// - `auxiliaries = 5`: multiplicity(1) + call output(1) + store ptr(1) + - /// load value(1) + mul spill(1). - /// - `lookups = 4`: return(slot 0) + call(1) + store(1) + load(1). - /// - /// - `g` (idx 1): `g(x) = x + 1`: - /// - `Const(1)` at value idx 1, `Add(0, 1)` at value idx 2, - /// `Return(0, [2])`. `Const`/`Add` allocate no auxiliaries. - /// - Layout: `input_size = 1`, `selectors = 1`, `auxiliaries = 1` - /// (multiplicity only), `lookups = 1` (return only). - /// - /// `memory_sizes = [1]`: a memory of size-1 values, which materializes one - /// `Memory` circuit. The single `Store` inserts the entry (memory - /// multiplicity 1); the `Load` bumps it to 2. The function circuit pushes - /// `+1` for the store lookup and `+1` for the load lookup; the memory circuit - /// pulls `-2`. The whole system balances across the function↔function and - /// function↔memory channels. - fn call_and_memory_toplevel() -> Toplevel { - let f_body = Block { - ops: vec![ - Op::Call(1, vec![0], 1, false), - Op::Store(vec![1]), - Op::Load(1, 3), - Op::Mul(2, 4), - ], - ctrl: Ctrl::Return(0, vec![5]), - }; - let f = Function { - body: f_body, - layout: FunctionLayout { - input_size: 2, - selectors: 1, - auxiliaries: 5, - lookups: 4, - }, - entry: true, - constrained: true, - }; - - let g_body = Block { - ops: vec![Op::Const(G::ONE), Op::Add(0, 1)], - ctrl: Ctrl::Return(0, vec![2]), - }; - let g = Function { - body: g_body, - layout: FunctionLayout { - input_size: 1, - selectors: 1, - auxiliaries: 1, - lookups: 1, - }, - entry: false, - constrained: true, - }; - - with_singleton_circuits(vec![f, g], vec![1]) - } - - #[test] - fn prove_verify_call_and_memory_roundtrip() { - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(call_and_memory_toplevel(), cp, fp); - - let a = G::from_u64(3); - let b = G::from_u64(5); - let input = [a, b]; - let mut io_buffer = empty_io_buffer(); - - // f(a, b) = g(a) * b = (a + 1) * b, with b routed through a Store/Load. - let expected = (a + G::ONE) * b; - let (claim, proof) = system.prove(0, &input, &mut io_buffer); - - // Claim layout is [function_channel(), fun_idx, input.., output..]. - assert_eq!( - claim, - vec![function_channel(), G::from_usize(0), a, b, expected], - "unexpected claim layout / computed output" - ); - - system - .verify(&claim, &proof) - .expect("valid proof over Call + Store/Load must verify"); - - // Negative check: tampering with the output element must make the claim - // inconsistent with the (honest) proof, so verification must fail. - let mut bad_claim = claim.clone(); - let last = bad_claim.len() - 1; - bad_claim[last] += G::ONE; - assert!( - system.verify(&bad_claim, &proof).is_err(), - "verification must reject a tampered claim" - ); - } - - #[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)` - /// constrained. Since `g` calls `h`, promoting the cached `g` query must - /// replay its body and promote the cached `h` query as well. Merely bumping - /// `g`'s multiplicity leaves the `g -> h` function channel unbalanced. - fn unconstrained_call_promotion_toplevel() -> Toplevel { - let f = Function { - body: Block { - ops: vec![ - Op::Call(1, vec![0], 1, true), - Op::Call(1, vec![0], 1, false), - ], - ctrl: Ctrl::Return(0, vec![2]), - }, - layout: FunctionLayout { - input_size: 1, - selectors: 1, - auxiliaries: 3, - lookups: 2, - }, - entry: true, - constrained: true, - }; - - let g = Function { - body: Block { - ops: vec![Op::Call(2, vec![0], 1, false)], - ctrl: Ctrl::Return(0, vec![1]), - }, - layout: FunctionLayout { - input_size: 1, - selectors: 1, - auxiliaries: 2, - lookups: 2, - }, - entry: false, - constrained: true, - }; - - let h = Function { - body: Block { - ops: vec![Op::Const(G::ONE), Op::Add(0, 1)], - ctrl: Ctrl::Return(0, vec![2]), - }, - layout: FunctionLayout { - input_size: 1, - selectors: 1, - auxiliaries: 1, - lookups: 1, - }, - entry: false, - constrained: true, - }; - - with_singleton_circuits(vec![f, g, h], vec![]) - } - - #[test] - fn prove_verify_promotes_nested_unconstrained_call() { - let (cp, fp) = test_parameters(); - let system = - AiurSystem::build(unconstrained_call_promotion_toplevel(), cp, fp); - let input = [G::from_u64(3)]; - let mut io_buffer = empty_io_buffer(); - - let (claim, proof) = system.prove(0, &input, &mut io_buffer); - assert_eq!( - claim, - vec![function_channel(), G::ZERO, input[0], input[0] + G::ONE] - ); - system - .verify(&claim, &proof) - .expect("nested constrained promotion must balance function channels"); - } - - #[test] - fn prove_verify_mul_roundtrip() { - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(mul_toplevel(), cp, fp); - - let a = G::from_u64(3); - let b = G::from_u64(5); - let input = [a, b]; - let mut io_buffer = empty_io_buffer(); - - let (claim, proof) = system.prove(0, &input, &mut io_buffer); - - // Claim layout is [function_channel(), fun_idx, input.., output..]. - assert_eq!( - claim, - vec![function_channel(), G::from_usize(0), a, b, a * b], - "unexpected claim layout / computed output" - ); - - system.verify(&claim, &proof).expect("valid proof must verify"); - - // Negative check: tampering with the output element must make the claim - // inconsistent with the (honest) proof, so verification must fail. - let mut bad_claim = claim.clone(); - let last = bad_claim.len() - 1; - bad_claim[last] += G::ONE; - assert!( - system.verify(&bad_claim, &proof).is_err(), - "verification must reject a tampered claim" - ); - } - - #[test] - fn circuit_shapes_match_system() { - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(call_and_memory_toplevel(), cp, fp); - let shapes = system.circuit_shapes(); - - // Canonical order and count: 2 constrained functions, 1 memory, Bytes1, - // Bytes2. - assert_eq!(shapes.len(), 5); - assert_eq!(shapes.len(), system.system.circuits.len()); - - for (shape, circuit) in shapes.iter().zip(&system.system.circuits) { - assert_eq!(shape.main_width, circuit.main_width); - assert_eq!(shape.stage2_width, circuit.stage_2_width); - assert_eq!(shape.quotient_degree, circuit.quotient_degree()); - assert_eq!(shape.preprocessed_width, circuit.preprocessed_width); - assert_eq!(shape.preprocessed_height, circuit.preprocessed_height); - } - - // Function circuits: main width = inputs + selectors + auxiliaries, no - // preprocessed matrix. - assert_eq!(shapes[0].main_width, 2 + 1 + 5); - assert_eq!(shapes[1].main_width, 1 + 1 + 1); - // Memory of size 1: multiplicity + selector + pointer + 1 value. - assert_eq!(shapes[2].main_width, 3 + 1); - for shape in &shapes[..3] { - assert_eq!(shape.preprocessed_width, 0); - assert_eq!(shape.preprocessed_height, 0); - } - - // Byte gadgets: always-active fixed-height tables whose preprocessed - // height doubles as the committed trace height. - assert_eq!(shapes[3].preprocessed_width, 11); - assert_eq!(shapes[3].preprocessed_height, 256); - assert_eq!(shapes[4].preprocessed_width, 11); - assert_eq!(shapes[4].preprocessed_height, 65536); - } - - // -- Trace shards -- - // - // `call_and_memory_toplevel`'s system order: f, g, memory[1], Bytes1, - // Bytes2. Its record has one row of f, one of g, and one memory row. - const F: usize = 0; - const G_FN: usize = 1; - const MEM: usize = 2; - const BYTES1: usize = 3; - const BYTES2: usize = 4; - - fn executed_call_and_memory() - -> (AiurSystem, Vec, QueryRecord, Vec, IOBuffer) { - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(call_and_memory_toplevel(), cp, fp); - let input = vec![G::from_u64(3), G::from_u64(5)]; - let mut io_buffer = empty_io_buffer(); - let (record, output) = system - .toplevel() - .execute(0, input.clone(), &mut io_buffer) - .expect("execution succeeds"); - (system, input, record, output, io_buffer) - } - - /// Two shards: `f` and the byte tables in shard 0, `g` in shard 1, and the - /// memory row wherever `memory_ranges` puts it (one range per shard). - fn two_shard_plan(memory_ranges: [std::ops::Range; 2]) -> ShardPlan { - let mut shard_0 = vec![0..0; 5]; - let mut shard_1 = vec![0..0; 5]; - shard_0[F] = 0..1; - shard_0[BYTES1] = 0..256; - shard_0[BYTES2] = 0..65536; - shard_1[G_FN] = 0..1; - let [range_0, range_1] = memory_ranges; - shard_0[MEM] = range_0; - shard_1[MEM] = range_1; - ShardPlan { - shards: vec![ShardRows { rows: shard_0 }, ShardRows { rows: shard_1 }], - memory_totals: vec![(1, 0, 1)], - } - } - - #[test] - fn sharded_prove_verify_across_two_shards() { - let (system, input, record, output, io_buffer) = executed_call_and_memory(); - // The memory table lives in the shard WITHOUT the claim and WITHOUT the - // caller's store/load rows: every memory message crosses the cut. - let plan = two_shard_plan([0..0, 0..1]); - let (claim, proof) = system.prove_from_execution_planned( - 0, - &input, - &io_buffer, - record, - &output, - &plan, - Retention::Regenerate, - ); - assert_eq!(proof.proofs.len(), 2); - // The byte tables are present in both shards; only shard 0's copy - // carries multiplicities. - assert!(proof.proofs[0].active[BYTES1] && proof.proofs[0].active[BYTES2]); - assert!(proof.proofs[1].active[BYTES1] && proof.proofs[1].active[BYTES2]); - assert!(!proof.proofs[0].active[MEM] && proof.proofs[1].active[MEM]); - assert_eq!(proof.preamble.headers[0].claims.len(), 1); - assert!(proof.preamble.headers[1].claims.is_empty()); - system.verify(&claim, &proof).expect("two-shard proof verifies"); - - let mut bad_claim = claim.clone(); - let last = bad_claim.len() - 1; - bad_claim[last] += G::ONE; - assert!(matches!( - system.verify(&bad_claim, &proof), - Err(AiurVerificationError::Policy(_)) - )); - } - - #[test] - fn sharded_proof_bytes_round_trip() { - let (system, input, record, output, io_buffer) = executed_call_and_memory(); - let plan = two_shard_plan([0..1, 0..0]); - let (claim, proof) = system.prove_from_execution_planned( - 0, - &input, - &io_buffer, - record, - &output, - &plan, - Retention::Retain, - ); - let bytes = proof.to_bytes().expect("serialize"); - let decoded = AiurProof::from_bytes(&bytes).expect("deserialize"); - system.verify(&claim, &decoded).expect("decoded proof verifies"); - } - - #[test] - fn plan_shards_respects_budget_and_covers_every_row() { - let (system, input, record, output, io_buffer) = executed_call_and_memory(); - let single = system.single_shard_plan(&record); - assert_eq!(single.num_shards(), 1); - assert_eq!(single.memory_totals, vec![(1, 0, 1)]); - - // Every committed cell of the single shard, less one, forces a second - // shard; the byte tables stay in shard 0 and everything else moves. - let widths: Vec = system - .circuit_shapes() - .iter() - .map(|s| { - s.main_width + s.stage2_width + s.quotient_degree * EXTENSION_DEGREE - }) - .collect(); - // Every shard commits the byte tables, so they are charged to each. - let cells = |plan: &ShardPlan, shard: usize| -> usize { - plan.shards[shard] - .rows - .iter() - .zip(&widths) - .zip(&single.shards[0].rows) - .enumerate() - .map(|(ci, ((r, &w), whole))| { - let r = if ci == BYTES1 || ci == BYTES2 { whole } else { r }; - if r.is_empty() { 0 } else { r.len().next_power_of_two() * w } - }) - .sum() - }; - let total = cells(&single, 0); - let plan = system.plan_shards(&record, Some(total - 1)); - assert_eq!(plan.num_shards(), 2); - assert!(cells(&plan, 0) < total && cells(&plan, 1) < total); - for ci in 0..5 { - let covered: usize = plan.shards.iter().map(|s| s.rows[ci].len()).sum(); - assert_eq!(covered, single.shards[0].rows[ci].len(), "circuit {ci}"); - } - assert_eq!(plan.shards[0].rows[BYTES2], 0..65536); - assert!(plan.shards[1].rows[BYTES2].is_empty()); - - // A budget nothing can meet still yields a plan (the byte tables floor - // shard 0), without searching further than the three placeable rows - // allow. - let floored = system.plan_shards(&record, Some(1)); - assert!((1..=3).contains(&floored.num_shards())); - for ci in 0..5 { - let covered: usize = - floored.shards.iter().map(|s| s.rows[ci].len()).sum(); - assert_eq!(covered, single.shards[0].rows[ci].len(), "circuit {ci}"); - } - - let (claim, proof) = system.prove_from_execution_planned( - 0, - &input, - &io_buffer, - record, - &output, - &plan, - Retention::Retain, - ); - system.verify(&claim, &proof).expect("planned two-shard proof verifies"); - } - - #[test] - fn rejects_duplicated_memory_range() { - let (system, input, record, output, io_buffer) = executed_call_and_memory(); - // Both shards claim pointer 0: two `0 → 1` edges against one boot and - // one terminal term. - let plan = two_shard_plan([0..1, 0..1]); - let (claim, proof) = system.prove_from_execution_planned( - 0, - &input, - &io_buffer, - record, - &output, - &plan, - Retention::Retain, - ); - assert!(matches!( - system.verify(&claim, &proof), - Err(AiurVerificationError::Stark(VerificationError::UnbalancedBatch)) - )); - } - - #[test] - fn rejects_memory_row_missing_from_every_shard() { - let (system, input, record, output, io_buffer) = executed_call_and_memory(); - // No shard carries the memory table, yet the plan still closes it: the - // closure's end points (0 and 1) then match no rows, and the caller's - // store/load pushes match no pull. - let plan = two_shard_plan([0..0, 0..0]); - let (claim, proof) = system.prove_from_execution_planned( - 0, - &input, - &io_buffer, - record, - &output, - &plan, - Retention::Retain, - ); - assert!(matches!( - system.verify(&claim, &proof), - Err(AiurVerificationError::Stark(VerificationError::UnbalancedBatch)) - )); - } - - #[test] - fn rejects_overlapping_closure_intervals() { - let (system, input, record, output, io_buffer) = executed_call_and_memory(); - // Both shards hold pointer 0 of width 1, and the plan closes `[0, 1)` - // twice: balanced as a sum, rejected as a policy violation. - let mut plan = two_shard_plan([0..1, 0..1]); - plan.memory_totals.push((1, 0, 1)); - let (claim, proof) = system.prove_from_execution_planned( - 0, - &input, - &io_buffer, - record, - &output, - &plan, - Retention::Retain, - ); - assert!(matches!( - system.verify(&claim, &proof), - Err(AiurVerificationError::Policy(_)) - )); - } - - /// `f(a)` (entry) calls `h(a)`, which returns nothing: it stores `a`, - /// loads it back and asserts the round trip. `h` is an entry too, so a - /// record that owns it can run it directly. - fn deferral_toplevel() -> Toplevel { - let f = Function { - body: Block { - ops: vec![Op::Call(1, vec![0], 0, false)], - ctrl: Ctrl::Return(0, vec![0]), - }, - layout: FunctionLayout { - input_size: 1, - selectors: 1, - auxiliaries: 1, - lookups: 2, - }, - entry: true, - constrained: true, - }; - let h = Function { - body: Block { - ops: vec![ - Op::Store(vec![0]), - Op::Load(1, 1), - Op::AssertEq(vec![0], vec![2], None), - ], - ctrl: Ctrl::Return(0, vec![]), - }, - layout: FunctionLayout { - input_size: 1, - selectors: 1, - auxiliaries: 3, - lookups: 3, - }, - entry: true, - constrained: true, - }; - with_singleton_circuits(vec![f, h], vec![1]) - } - - #[test] - fn deferred_call_is_answered_by_another_record() { - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(deferral_toplevel(), cp, fp); - let seven = G::from_u64(7); - // Record 0 runs the claimed entry and owns nothing of `h`: its call is - // pushed by `f`'s row and answered nowhere in the record. - let deferring = || { - let mut io0 = empty_io_buffer(); - let mut worker0 = QueryRecord::with_pointer_base(system.toplevel(), 0); - worker0.ownership = - Some(Ownership { callee: 1, owned: rustc_hash::FxHashSet::default() }); - let output = system - .toplevel() - .execute_in(0, vec![seven], &mut io0, &mut worker0) - .expect("entry executes"); - (worker0, io0, output) - }; - let (worker0, io0, output) = deferring(); - assert_eq!(worker0.deferred.get(&vec![seven]), Some(&1)); - let deferred = worker0.function_queries[1] - .get_index_of(&[seven]) - .expect("the deferred call has an entry"); - assert_eq!(worker0.function_queries[1].mult_at(deferred), G::ZERO); - assert!(worker0.memory_queries[&1].is_empty(), "nothing ran"); - - // Record 1 owns `h`: runs it as an entry in its own pointer namespace, - // drops the entry multiplicity no claim pulls, and absorbs record 0's - // push. - let owner = |deferred: &FxHashMap, u64>, absorb: bool| { - let mut io1 = empty_io_buffer(); - let mut worker1 = - QueryRecord::with_pointer_base(system.toplevel(), pointer_stride(2)); - system - .toplevel() - .execute_in(1, vec![seven], &mut io1, &mut worker1) - .expect("owner executes"); - let i = worker1.function_queries[1].get_index_of(&[seven]).unwrap(); - *worker1.function_queries[1].get_index_mut(i).unwrap().1 -= G::ONE; - if absorb { - worker1.absorb_deferred(1, deferred).expect("absorbed"); - } - (worker1, io1) - }; - let (worker1, io1) = owner(&worker0.deferred, true); - let (claim, proof) = system - .prove_records( - 0, - &[seven], - &output, - &[(worker0, &io0), (worker1, &io1)], - None, - ) - .expect("two records plan within an unbounded budget"); - assert_eq!(proof.proofs.len(), 2); - assert_eq!(proof.preamble.messages.len(), 2, "one interval, the owner's"); - system.verify(&claim, &proof).expect("two records prove one claim"); - - // Unabsorbed, the owner's row pulls nothing and record 0's push hangs. - let (worker0, io0, output) = deferring(); - let (worker1, io1) = owner(&worker0.deferred, false); - let (claim, proof) = system - .prove_records( - 0, - &[seven], - &output, - &[(worker0, &io0), (worker1, &io1)], - None, - ) - .expect("two records plan within an unbounded budget"); - assert!(matches!( - system.verify(&claim, &proof), - Err(AiurVerificationError::Stark(VerificationError::UnbalancedBatch)) - )); - } - - /// A record regenerated by re-execution proves exactly as a resident one: - /// the supplier executes the owner afresh each time the batch asks for - /// it (once per round), absorbing the deferred call each time, and the - /// batch verifies — its round-two headers reproduce round one's. - #[test] - fn regenerated_record_proves_in_the_batch() { - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(deferral_toplevel(), cp, fp); - let seven = G::from_u64(7); - let mut io0 = empty_io_buffer(); - let mut worker0 = QueryRecord::with_pointer_base(system.toplevel(), 0); - worker0.ownership = - Some(Ownership { callee: 1, owned: rustc_hash::FxHashSet::default() }); - let output = system - .toplevel() - .execute_in(0, vec![seven], &mut io0, &mut worker0) - .expect("entry executes"); - let deferred = worker0.deferred.clone(); - let executions = std::cell::Cell::new(0usize); - let owner = || { - executions.set(executions.get() + 1); - let mut io1 = empty_io_buffer(); - let mut worker1 = - QueryRecord::with_pointer_base(system.toplevel(), pointer_stride(2)); - system - .toplevel() - .execute_in(1, vec![seven], &mut io1, &mut worker1) - .expect("owner executes"); - let i = worker1.function_queries[1].get_index_of(&[seven]).unwrap(); - *worker1.function_queries[1].get_index_mut(i).unwrap().1 -= G::ONE; - worker1.absorb_deferred(1, &deferred).expect("absorbed"); - Supplied::Owned(Box::new(worker1), Box::new(io1)) - }; - let (claim, proof) = system - .prove_record_supplier( - 0, - &[seven], - || output.clone(), - 2, - |r| { - Ok(if r == 0 { Supplied::Borrowed(&worker0, &io0) } else { owner() }) - }, - None, - ) - .expect("two records plan within an unbounded budget"); - assert_eq!(executions.get(), 2, "the owner ran once per round"); - system - .verify(&claim, &proof) - .expect("a regenerated record proves the claim"); - } - - #[test] - fn nonzero_pointer_base_proves_and_closes_its_interval() { - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(call_and_memory_toplevel(), cp, fp); - let input = vec![G::from_u64(3), G::from_u64(5)]; - let mut io_buffer = empty_io_buffer(); - let (record, output) = system - .toplevel() - .execute_with_pointer_base( - 0, - input.clone(), - &mut io_buffer, - pointer_stride(2), - ) - .expect("execution succeeds"); - let plan = system.single_shard_plan(&record); - assert_eq!(plan.memory_totals, vec![(1, pointer_stride(2), 1)]); - let (claim, proof) = system.prove_from_execution_planned( - 0, - &input, - &io_buffer, - record, - &output, - &plan, - Retention::Retain, - ); - system.verify(&claim, &proof).expect("shifted pointer namespace verifies"); - } - - #[test] - fn closure_interval_policy() { - let (system, input, record, output, io_buffer) = executed_call_and_memory(); - let plan = two_shard_plan([0..1, 0..0]); - let (claim, proof) = system.prove_from_execution_planned( - 0, - &input, - &io_buffer, - record, - &output, - &plan, - Retention::Retain, - ); - let pair = |width: u64, start: u64, end: u64| { - let w = G::from_u64(width); - [ - multi_stark::batch::BatchMessage::pull( - Memory::memseg_args(w, G::from_u64(start)).to_vec(), - ), - multi_stark::batch::BatchMessage::push( - Memory::memseg_args(w, G::from_u64(end)).to_vec(), - ), - ] - }; - let with = - |extra: Vec<[multi_stark::batch::BatchMessage; 2]>| { - let mut preamble = proof.preamble.clone(); - for [pull, push] in extra { - preamble.messages.push(pull); - preamble.messages.push(push); - } - check_batch_policy(system.system.circuits.len(), &claim, &preamble) - }; - // The proof closes width 1 over `[0, 1)`. A later disjoint interval of - // the same width, an empty one, and a wider width are all canonical. - assert!(with(vec![pair(1, 1, 5)]).is_ok()); - assert!(with(vec![pair(1, 1, 1)]).is_ok()); - assert!(with(vec![pair(1, 7, 9), pair(2, 0, 3)]).is_ok()); - // Overlap, reversed order, an interval ending before it starts, and a - // width out of order are not. - assert!(with(vec![pair(1, 0, 2)]).is_err()); - assert!(with(vec![pair(1, 5, 9), pair(1, 2, 4)]).is_err()); - assert!(with(vec![pair(1, 9, 8)]).is_err()); - assert!(with(vec![pair(2, 0, 3), pair(1, 7, 9)]).is_err()); - } - - #[test] - fn rejects_noncanonical_messages_and_extra_claims() { - let (system, input, record, output, io_buffer) = executed_call_and_memory(); - let plan = two_shard_plan([0..1, 0..0]); - let (claim, proof) = system.prove_from_execution_planned( - 0, - &input, - &io_buffer, - record, - &output, - &plan, - Retention::Retain, - ); - - let mut extra_message = proof.clone(); - extra_message.preamble.messages.push( - multi_stark::batch::BatchMessage::push(vec![G::ZERO, G::ONE, G::TWO]), - ); - assert!(matches!( - system.verify(&claim, &extra_message), - Err(AiurVerificationError::Policy(_)) - )); - - let mut swapped_polarity = proof.clone(); - swapped_polarity.preamble.messages.swap(0, 1); - assert!(matches!( - system.verify(&claim, &swapped_polarity), - Err(AiurVerificationError::Policy(_)) - )); - - let mut second_claim = proof.clone(); - second_claim.preamble.headers[1].claims.push(claim.clone()); - assert!(matches!( - system.verify(&claim, &second_claim), - Err(AiurVerificationError::Policy(_)) - )); - - let mut no_claim = proof; - no_claim.preamble.headers[0].claims.clear(); - assert!(matches!( - system.verify(&claim, &no_claim), - Err(AiurVerificationError::Policy(_)) - )); - } - /// A witness whose only real work is one row of `f` with its selector OFF: - /// no constraint of `f` applies to the row, yet it still pulls a return - /// message for the entry claim. `g` and the memory table carry no rows, so - /// the only message in the batch is that forged return, matched by the - /// verifier's claim. - fn forged_entry_witness( - system: &AiurSystem, - io_buffer: &IOBuffer, - output: G, - ) -> (Vec, SystemWitness) { - let record = QueryRecord::new(system.toplevel()); - let plan = ShardPlan { - shards: vec![ShardRows { rows: vec![0..0; 5] }], - memory_totals: vec![], - }; - let index = system.row_index(&record, &plan); - let mut witness = - system.shard_witness(&record, io_buffer, &plan, &index, 0); - - let shape = &system.circuit_shapes()[F]; - let input = [G::from_u64(3), G::from_u64(5)]; - let mut claim = vec![function_channel(), G::from_usize(F)]; - claim.extend(input); - claim.push(output); - - // `f`'s columns: inputs (2), selector (1), auxiliaries (5): multiplicity, - // call output, store pointer, loaded value, product. The selector stays - // zero; the multiplicity and the returned product are set freely. - let mut row = vec![G::ZERO; shape.main_width]; - row[0] = input[0]; - row[1] = input[1]; - row[3] = G::ONE; - row[7] = output; - witness.traces[F] = RowMajorMatrix::new(row, shape.main_width); - let mut builder = LookupValues::builder(1, &system.slot_arg_widths(F)); - builder.rows_mut()[0].pull(0, G::ONE, &claim); - witness.lookups[F] = builder.finish(); - (claim, witness) - } - - #[test] - fn padding_row_cannot_pull_a_return_message() { - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(call_and_memory_toplevel(), cp, fp); - let io_buffer = empty_io_buffer(); - let (claim, witness) = - forged_entry_witness(&system, &io_buffer, G::from_u64(999)); - let proof = system.prove_witness(&claim, witness); - // The selector gates the pull, so the shard's own constraints reject - // the row before the batch balance is consulted. - assert!( - matches!( - system.verify_shard(&proof, 0), - Err(VerificationError::OodEvaluationMismatch) - ), - "forged claim verified" - ); - assert!(matches!( - system.verify(&claim, &proof), - Err(AiurVerificationError::Stark( - VerificationError::OodEvaluationMismatch - )) - )); - } - - // The CUDA backend derives lookup messages from the committed trace - // through the constraint graph and never reads the forged host lookup - // witness this test plants, so on that backend the proof is of the trace - // alone (whose padding rows are gated) and verifies. - #[cfg(not(feature = "cuda"))] - #[test] - fn padding_memory_rows_cannot_carry_multiplicities() { - let (system, input, record, output, io_buffer) = executed_call_and_memory(); - let plan = system.single_shard_plan(&record); - let index = system.row_index(&record, &plan); - let mut witness = - system.shard_witness(&record, &io_buffer, &plan, &index, 0); - - // The honest memory table has one row; pad it to four, and let the - // padding rows pull the all-zero message with multiplicities that - // cancel among themselves (`1 + 1 - 2`), so the batch stays balanced. - let width = system.circuit_shapes()[MEM].main_width; - let real = witness.traces[MEM].values[..width].to_vec(); - let mut rows = vec![G::ZERO; 4 * width]; - rows[..width].copy_from_slice(&real); - for (i, m) in [G::ONE, G::ONE, -G::TWO].into_iter().enumerate() { - rows[(i + 1) * width] = m; - } - witness.traces[MEM] = RowMajorMatrix::new(rows, width); - - let slot_arg_widths = system.slot_arg_widths(MEM); - let mut builder = LookupValues::builder(4, &slot_arg_widths); - let mut writers = builder.rows_mut(); - let size = G::ONE; - writers[0].pull( - 0, - real[0], - &Memory::lookup_args(size, real[2], &real[3..]), - ); - writers[0].push(1, G::ONE, &Memory::memseg_args(size, real[2])); - writers[0].pull(2, G::ONE, &Memory::memseg_args(size, real[2] + G::ONE)); - let zero = vec![G::ZERO; slot_arg_widths[0]]; - for (i, m) in [G::ONE, G::ONE, -G::TWO].into_iter().enumerate() { - writers[i + 1].pull(0, m, &zero); - } - drop(writers); - witness.lookups[MEM] = builder.finish(); - - let mut claim = vec![function_channel(), G::ZERO]; - claim.extend(&input); - claim.extend(&output); - let shards = vec![multi_stark::batch::ShardInput { - claims: vec![claim.clone()], - witness, - }]; - let messages = AiurSystem::boundary_messages(&plan); - let proof = system.prove_witnesses(shards, messages); - // The padding rows' multiplicities cancel, so the batch would balance; - // the shard's own constraints are what reject them. - assert!( - matches!( - system.verify_shard(&proof, 0), - Err(VerificationError::OodEvaluationMismatch) - ), - "padding rows carried multiplicities" - ); - assert!(matches!( - system.verify(&claim, &proof), - Err(AiurVerificationError::Stark( - VerificationError::OodEvaluationMismatch - )) - )); - } - - #[test] - fn plan_shards_within_budget_bounds_every_shard() { - let (system, _input, record, _output, _io_buffer) = - executed_call_and_memory(); - let record_bytes = crate::execute::record_retained_bytes(&record); - let single = system.single_shard_plan(&record); - let single_peak = system.shard_peak_bytes(&single, 0, record_bytes); - - // Enough for the whole execution: the single-shard plan, unchanged. - let (plan, peak) = system - .plan_shards_within(&record, single_peak) - .expect("the single shard fits its own peak"); - assert_eq!(plan.num_shards(), 1); - assert_eq!(peak, single_peak); - - // Just below it: a batch whose every shard is projected to fit. - let (plan, peak) = system - .plan_shards_within(&record, single_peak - 1) - .expect("a smaller budget still admits a plan"); - assert!(plan.num_shards() > 1); - assert!(peak < single_peak); - for shard in 0..plan.num_shards() { - assert!(system.shard_peak_bytes(&plan, shard, record_bytes) <= peak); - } - for ci in 0..5 { - let covered: usize = plan.shards.iter().map(|s| s.rows[ci].len()).sum(); - assert_eq!(covered, single.shards[0].rows[ci].len(), "circuit {ci}"); - } - - // Below the record plus the byte tables nothing can fit. - assert!(system.plan_shards_within(&record, record_bytes).is_err()); - } - - #[test] - fn sharded_proofs_are_reproducible() { - let plan = two_shard_plan([0..0, 0..1]); - // Execution is deterministic, so each prove starts from an equal record. - let prove = |retention| { - let (system, input, record, output, io_buffer) = - executed_call_and_memory(); - system - .prove_from_execution_planned( - 0, &input, &io_buffer, record, &output, &plan, retention, - ) - .1 - .to_bytes() - .expect("serialize") - }; - let first = prove(Retention::Regenerate); - let second = prove(Retention::Regenerate); - let retained = prove(Retention::Retain); - assert_eq!(first, second, "two regenerating proves differ"); - assert_eq!(first, retained, "retain and regenerate differ"); - } -} diff --git a/crates/aiur/src/synthesis/normalization.rs b/crates/aiur/src/synthesis/normalization.rs deleted file mode 100644 index c25f3b44e..000000000 --- a/crates/aiur/src/synthesis/normalization.rs +++ /dev/null @@ -1,163 +0,0 @@ -//! Fixed-layout proving of an already executed invocation. Used after a -//! recursive wrap to normalize arbitrary child proofs for compression. -use super::*; -use multi_stark::{batch::ShardInput, system::SystemWitness}; - -impl AiurSystem { - /// Rows each circuit needs to hold `record` in one shard, in system order. - pub fn execution_rows(&self, record: &QueryRecord) -> Vec { - let plan = self.single_shard_plan(record); - plan.shards[0].rows.iter().map(|rows| rows.len()).collect() - } - - /// The smallest normalization log-heights holding `rows` in each circuit, - /// raised by `headroom` doublings and capped at `2^26`. Fixed byte tables - /// keep their native heights. - pub fn normalized_log_heights( - &self, - rows: &[usize], - headroom: u8, - ) -> Result, String> { - if rows.len() != self.system.circuits.len() { - return Err("normalization needs one row count per circuit".into()); - } - self - .system - .circuits - .iter() - .zip(rows) - .enumerate() - .map(|(i, (circuit, &rows))| { - if circuit.preprocessed_height != 0 { - return Ok(u8::try_from(circuit.preprocessed_height.ilog2()) - .expect("log of a usize fits in u8")); - } - let log = rows.max(2).next_power_of_two().ilog2() + u32::from(headroom); - if log > 26 { - return Err(format!( - "normalization circuit {i} needs 2^{log} rows; at most 2^26 is supported" - )); - } - Ok(u8::try_from(log).expect("log is at most 26")) - }) - .collect() - } - - /// `(width, circuit index)` of every memory circuit, ascending by width. - pub fn memory_circuits(&self) -> Vec<(usize, usize)> { - let mut memories: Vec<_> = self - .circuit_types() - .iter() - .enumerate() - .filter_map(|(i, ct)| match ct { - CircuitType::Memory { width } => Some((*width, i)), - _ => None, - }) - .collect(); - memories.sort_unstable(); - memories - } - - /// Prove one invocation in a fixed, all-active trace layout. Function and - /// memory tables have their configured power-of-two heights; fixed byte - /// tables retain their native heights. Empty tables are zero-padded. Memory - /// closures have one pair per statically declared width, including empty intervals. - /// Heights are in system order: function circuits, memories, then byte tables. - /// Returns an error before trace allocation if any execution table exceeds - /// its bound. The caller supplies the matching execution record and output. - pub fn prove_from_execution_normalized( - &self, - fun_idx: FunIdx, - input: &[G], - io: &IOBuffer, - record: QueryRecord, - output: &[G], - log_heights: &[u8], - ) -> Result<(Vec, AiurProof), String> { - if record.pointer_base != 0 { - return Err("normalization requires pointer base zero".into()); - } - if log_heights.len() != self.system.circuits.len() - || log_heights.iter().any(|log| !(1..=26).contains(log)) - { - return Err( - "normalization requires one log-height in 1–26 per circuit".into(), - ); - } - for (i, (circuit, &log)) in - self.system.circuits.iter().zip(log_heights).enumerate() - { - if circuit.preprocessed_height != 0 - && circuit.preprocessed_height != 1usize << log - { - return Err(format!( - "normalization circuit {i} must retain its preprocessed height" - )); - } - } - let mut plan = self.single_shard_plan(&record); - for (i, (rows, &log)) in - plan.shards[0].rows.iter().zip(log_heights).enumerate() - { - let target = 1usize << log; - if rows.len() > target { - return Err(format!( - "normalization circuit {i} needs {} rows; configured bound is {target}", - rows.len() - )); - } - } - let active = vec![true; log_heights.len()]; - if lookup_query_bound( - self.system.circuits.iter().map(|c| c.num_lookups), - &active, - log_heights, - ) - .is_none() - || !trace_cap_coverage( - self.commitment_parameters.log_blowup, - self.commitment_parameters.cap_height, - log_heights, - ) - { - return Err("normalized layout exceeds the Aiur proof bounds".into()); - } - plan.memory_totals = self - .toplevel - .memory_sizes - .iter() - .map(|&width| { - ( - width, - 0, - record.memory_queries.get(&width).map_or(0, |rows| rows.len()), - ) - }) - .collect(); - plan.memory_totals.sort_unstable(); - let messages = Self::boundary_messages(&plan); - let index = self.row_index(&record, &plan); - let mut traces = self.shard_witness(&record, io, &plan, &index, 0).traces; - drop(record); - for (trace, &log) in traces.iter_mut().zip(log_heights) { - let size = trace - .width - .checked_mul(1usize << log) - .ok_or("normalized trace size overflow")?; - trace.values.resize(size, G::ZERO); - } - let witness = SystemWitness::from_stage_1(traces, &self.system); - let mut claim = vec![function_channel(), G::from_usize(fun_idx)]; - claim.extend(input); - claim.extend(output); - let proof = self.system.prove_batch( - &self.key, - vec![ShardInput { claims: vec![claim.clone()], witness }], - messages, - ); - self - .verify(&claim, &proof) - .map_err(|e| format!("normalized proof: {e:?}"))?; - Ok((claim, proof)) - } -} diff --git a/crates/aiur/src/synthesis/tests/acceptance.rs b/crates/aiur/src/synthesis/tests/acceptance.rs deleted file mode 100644 index 997887bde..000000000 --- a/crates/aiur/src/synthesis/tests/acceptance.rs +++ /dev/null @@ -1,175 +0,0 @@ -// Copyright (c) 2026 Argument Computer Corporation. -// SPDX-License-Identifier: MIT OR Apache-2.0 - -use super::*; -use multi_stark::eval::{VarValues, eval_expr}; - -fn values<'a>(row: &'a [G], next: &'a [G]) -> VarValues<'a, G> { - VarValues { - preprocessed: [&[], &[]], - main: [row, next], - stage2: [&[], &[]], - publics: &[], - is_first_row: G::ONE, - is_last_row: G::ZERO, - is_transition: G::ONE, - } -} - -/// Retain the entry singleton and group the nested callees, whose auxiliary -/// and lookup widths differ and whose selectors occupy separate columns. -fn grouped_promotion_toplevel() -> Toplevel { - let mut top = unconstrained_call_promotion_toplevel(); - top.circuits.truncate(1); - top.circuits.push(crate::bytecode::Circuit { - members: vec![1, 2], - layout: FunctionLayout { - input_size: 1, - selectors: 2, - auxiliaries: 2, - lookups: 2, - }, - }); - top -} - -#[test] -fn inactive_function_multiplicity_is_constrained_in_every_partition() { - for mut top in [mul_toplevel(), grouped_promotion_toplevel()] { - // Generate a concrete active row for each member. Entry visibility is - // only an executor guard and does not alter these AIR constraints. - for function in &mut top.functions { - function.entry = true; - } - for (idx, circuit) in top.circuits.iter().enumerate() { - let (constraints, lookups) = top.build_constraints(idx); - let mut row = vec![G::ZERO; constraints.width]; - let multiplicity = circuit.layout.input_size + circuit.layout.selectors; - for nonzero in [G::ONE, -G::ONE, G::from_u8(7)] { - row[multiplicity] = nonzero; - assert!( - constraints - .zeros - .iter() - .any(|c| eval_expr(c, &values(&row, &row)) != G::ZERO), - "inactive circuit {idx} accepted multiplicity {nonzero}" - ); - // Every fixture member has one return selector. Activating any - // member must permit the multiplicity, including the later members - // of a group. These are local constraint checks; the roundtrip - // below also checks global lookup balance for an honest execution. - for &member in &circuit.members { - assert_eq!(top.functions[member].layout.selectors, 1); - let mut io_buffer = empty_io_buffer(); - let input = vec![G::ZERO; top.functions[member].layout.input_size]; - let (record, _) = top.execute(member, input, &mut io_buffer).unwrap(); - let widths = - lookups.iter().map(|lookup| lookup.args.len()).collect::>(); - let (trace, _) = top.witness_data(idx, &record, &io_buffer, &widths); - let mut active = trace.values[..constraints.width].to_vec(); - active[multiplicity] = nonzero; - assert!( - constraints - .zeros - .iter() - .all(|c| eval_expr(c, &values(&active, &active)) == G::ZERO), - "active member {member} rejected multiplicity {nonzero}" - ); - } - } - row[multiplicity] = G::ZERO; - assert!( - constraints - .zeros - .iter() - .all(|c| eval_expr(c, &values(&row, &row)) == G::ZERO) - ); - } - } -} - -#[test] -fn inactive_memory_multiplicity_is_constrained() { - for width in [1, 4, 8] { - let (memory, constraints, _) = Memory::build(width); - let mut row = vec![G::ZERO; memory.width]; - let next = row.clone(); - for nonzero in [G::ONE, -G::ONE, G::from_u8(7)] { - row[0] = nonzero; - assert!( - constraints - .iter() - .any(|c| eval_expr(c, &values(&row, &next)) != G::ZERO) - ); - row[1] = G::ONE; - assert!( - constraints - .iter() - .all(|c| eval_expr(c, &values(&row, &next)) == G::ZERO) - ); - row[1] = G::ZERO; - } - row[0] = G::ZERO; - assert!( - constraints.iter().all(|c| eval_expr(c, &values(&row, &next)) == G::ZERO) - ); - } -} - -#[test] -fn active_grouped_returns_verify() { - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(grouped_promotion_toplevel(), cp, fp); - let input = [G::from_u8(3)]; - let (claim, proof) = system.prove(0, &input, &mut empty_io_buffer()); - assert_eq!( - claim, - vec![function_channel(), G::ZERO, input[0], input[0] + G::ONE] - ); - system.verify(&claim, &proof).expect("active grouped returns must verify"); -} - -/// Exercise the public verifier with supplied trace rows, independently of -/// the execution record. A successful honest execution alone cannot check -/// whether inactive rows are permitted to provide a function result. -#[test] -fn inactive_return_cannot_supply_claim() { - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(mul_toplevel(), cp, fp); - let a = G::from_u8(3); - let b = G::from_u8(5); - let wrong_result = G::from_u8(16); - assert_ne!(a * b, wrong_result); - let claim = vec![function_channel(), G::ZERO, a, b, wrong_result]; - let traces = system - .circuit_shapes() - .iter() - .enumerate() - .map(|(i, shape)| { - let height = if i == 0 { 4 } else { shape.preprocessed_height }; - let mut rows = vec![G::ZERO; height * shape.main_width]; - if i == 0 { - // Inputs, inactive selector, return multiplicity, then - // unconstrained product advice. - rows[..4].copy_from_slice(&[a, b, G::ZERO, G::ONE]); - rows[4] = wrong_result; - } - RowMajorMatrix::new(rows, shape.main_width) - }) - .collect(); - let witness = SystemWitness::from_stage_1(traces, &system.system); - let proof = system.prove_witness(&claim, witness); - // The shard's own constraints reject the row; the rejection does not - // rest on the rest of the batch failing to balance it. - assert!( - matches!( - system.verify_shard(&proof, 0), - Err(VerificationError::OodEvaluationMismatch) - ), - "an inactive function row supplied an incorrect public result" - ); - assert!(matches!( - system.verify(&claim, &proof), - Err(AiurVerificationError::Stark(VerificationError::OodEvaluationMismatch)) - )); -} diff --git a/crates/aiur/src/synthesis/tests/branchless.rs b/crates/aiur/src/synthesis/tests/branchless.rs deleted file mode 100644 index a985dca77..000000000 --- a/crates/aiur/src/synthesis/tests/branchless.rs +++ /dev/null @@ -1,122 +0,0 @@ -// Copyright (c) 2026 Argument Computer Corporation. -// SPDX-License-Identifier: MIT OR Apache-2.0 - -use super::*; -use crate::FxIndexMap; -use multi_stark::eval::{VarValues, eval_expr}; - -fn empty_branch_toplevel() -> Toplevel { - let dead = Block { - ops: vec![Op::Store(vec![])], - ctrl: Ctrl::Match(0, FxIndexMap::default(), None), - }; - let called = Block { - ops: vec![Op::Call(1, vec![], 1, false)], - ctrl: Ctrl::Return(0, vec![1]), - }; - let caller = Function { - body: Block { - ops: vec![], - ctrl: Ctrl::Match( - 0, - [(G::ZERO, dead), (G::ONE, called)].into_iter().collect(), - None, - ), - }, - layout: FunctionLayout { - input_size: 1, - selectors: 1, - auxiliaries: 2, - lookups: 2, - }, - entry: true, - constrained: true, - }; - let callee = Function { - body: Block { - ops: vec![Op::Const(G::ONE)], - ctrl: Ctrl::Return(0, vec![0]), - }, - layout: FunctionLayout { - input_size: 0, - selectors: 1, - auxiliaries: 1, - lookups: 1, - }, - entry: false, - constrained: true, - }; - with_singleton_circuits(vec![caller, callee], vec![0, 1]) -} - -#[test] -fn empty_branch_preserves_honest_execution() { - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(empty_branch_toplevel(), cp, fp); - let (claim, proof) = system.prove(0, &[G::ONE], &mut empty_io_buffer()); - assert_eq!(claim, vec![function_channel(), G::ZERO, G::ONE, G::ONE]); - system.verify(&claim, &proof).unwrap(); -} - -/// A zero-leaf branch can still emit a lookup. Its inactive store must not -/// turn the selected call's function channel into a memory channel merely -/// because the entire circuit has one return selector. -#[test] -fn empty_branch_cannot_redirect_a_call_to_memory() { - let top = empty_branch_toplevel(); - let (_, expected) = - top.execute(0, vec![G::ONE], &mut empty_io_buffer()).unwrap(); - assert_eq!(expected, vec![G::ONE]); - let forged = G::from_u8(7); - assert_ne!(expected, vec![forged]); - let (constraints, lookups) = top.build_constraints(0); - let mut row = vec![G::ZERO; constraints.width]; - row[0] = G::ONE; - row[1] = G::ONE; - row[2] = G::ONE; - row[3] = forged; - let values = VarValues { - preprocessed: [&[], &[]], - main: [&row, &row], - stage2: [&[], &[]], - publics: &[], - is_first_row: G::ONE, - is_last_row: G::ZERO, - is_transition: G::ONE, - }; - assert!(constraints.zeros.iter().all(|c| eval_expr(c, &values) == G::ZERO)); - let combined: Vec<_> = - lookups[1].args.iter().map(|arg| eval_expr(arg, &values)).collect(); - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(top, cp, fp); - let claim = vec![function_channel(), G::ZERO, G::ONE, forged]; - let traces = system - .circuit_shapes() - .iter() - .enumerate() - .map(|(index, shape)| { - let height = if index < 4 { 4 } else { shape.preprocessed_height }; - let mut rows = vec![G::ZERO; height * shape.main_width]; - if index == 0 { - rows[..shape.main_width].copy_from_slice(&row); - } else if index == 3 { - // Supply the redirected memory lookup, with no callee row. - rows[..4].copy_from_slice(&[G::ONE, G::ONE, forged + forged, G::ZERO]); - } - RowMajorMatrix::new(rows, shape.main_width) - }) - .collect(); - let witness = SystemWitness::from_stage_1(traces, &system.system); - let proof = system.prove_witness(&claim, witness); - // The forged row satisfies every constraint on its own; what rejects it - // is the redirected memory message that no callee row answers. - system.verify_shard(&proof, 0).unwrap(); - assert!( - matches!( - system.verify(&claim, &proof), - Err(AiurVerificationError::Stark(VerificationError::UnbalancedBatch)) - ), - "an inactive empty branch redirected a call to memory and supplied a false public result" - ); - assert_eq!(combined, vec![function_channel(), G::ONE, forged]); -} diff --git a/crates/aiur/src/synthesis/tests/byte_consolidation.rs b/crates/aiur/src/synthesis/tests/byte_consolidation.rs deleted file mode 100644 index 4a48a370c..000000000 --- a/crates/aiur/src/synthesis/tests/byte_consolidation.rs +++ /dev/null @@ -1,337 +0,0 @@ -// Copyright (c) 2026 Argument Computer Corporation. -// SPDX-License-Identifier: MIT OR Apache-2.0 - -use super::*; -use crate::{ - execute::{ - QueryRecord, bytes2_and_value, bytes2_less_than_value, bytes2_or_value, - }, - gadgets::bytes2::Bytes2Op, -}; -use multi_stark::eval::{VarValues, eval_expr}; - -fn byte_toplevel(grouped: bool) -> Toplevel { - let functions = [Op::U8And(0, 1), Op::U8Or(0, 1), Op::U8LessThan(0, 1)] - .into_iter() - .map(|op| Function { - body: Block { ops: vec![op], ctrl: Ctrl::Return(0, vec![2]) }, - layout: FunctionLayout { - input_size: 2, - selectors: 1, - auxiliaries: 2, - lookups: 2, - }, - entry: true, - constrained: true, - }) - .collect(); - let mut top = with_singleton_circuits(functions, vec![]); - if grouped { - top.circuits = vec![crate::bytecode::Circuit { - members: vec![0, 1, 2], - layout: FunctionLayout { - input_size: 2, - selectors: 3, - auxiliaries: 2, - lookups: 2, - }, - }]; - } - top -} - -fn values<'a>(row: &'a [G], preprocessed: &'a [G]) -> VarValues<'a, G> { - VarValues { - preprocessed: [preprocessed, preprocessed], - main: [row, row], - stage2: [&[], &[]], - publics: &[], - is_first_row: G::ONE, - is_last_row: G::ZERO, - is_transition: G::ONE, - } -} - -fn message(lookup: &Lookup>, row: &[G], preprocessed: &[G]) -> Vec { - let vars = values(row, preprocessed); - lookup.args.iter().map(|arg| eval_expr(arg, &vars)).collect() -} - -#[test] -fn every_byte_pair_matches_the_consolidated_compiled_lookup() { - let table = Bytes2.preprocessed().unwrap(); - let pulls = Bytes2.lookups(); - let table_row = [G::ZERO; 8]; - assert_eq!(table.width, 11); - assert_eq!(pulls.len(), 8); - - for grouped in [false, true] { - let top = byte_toplevel(grouped); - for member in 0..3 { - let circuit = if grouped { 0 } else { member }; - let layout = top.circuits[circuit].layout; - let (constraints, lookups) = top.build_constraints(circuit); - let pull = if member == 2 { 2 } else { 0 }; - assert_eq!(lookups.len(), 2); - assert_eq!(constraints.width, 2 + layout.selectors + 2); - let mut row = vec![G::ZERO; constraints.width]; - row[2 + if grouped { member } else { 0 }] = G::ONE; - row[2 + layout.selectors] = G::ONE; - let output_column = 3 + layout.selectors; - for a in 0..=u8::MAX { - for b in 0..=u8::MAX { - let expected = match member { - 0 => G::from_u8(a & b), - 1 => G::from_u8(a | b), - _ => G::from_bool(a < b), - }; - row[0] = G::from_u8(a); - row[1] = G::from_u8(b); - row[output_column] = expected; - let preprocessed = &table.values - [(usize::from(a) * 256 + usize::from(b)) * table.width..] - [..table.width]; - let provider = message(&pulls[pull], &table_row, preprocessed); - assert_eq!(message(&lookups[1], &row, &[]), provider); - assert!( - constraints - .zeros - .iter() - .all(|c| { eval_expr(c, &values(&row, &[])) == G::ZERO }) - ); - // Test the actual field equations against out-of-range and wrong - // results, not just host-byte arithmetic. Nonzero coefficients - // make the correct result the unique solution in the field. - for wrong in [-G::ONE, G::from_u16(256), expected + G::ONE] { - row[output_column] = wrong; - assert_ne!(message(&lookups[1], &row, &[]), provider); - } - } - } - // Inactive rows, including grouped members, send no requests even - // when their unused inputs/output contain arbitrary field values. - row.fill(-G::ONE); - row[2..3 + layout.selectors].fill(G::ZERO); - assert!( - constraints - .zeros - .iter() - .all(|c| { eval_expr(c, &values(&row, &[])) == G::ZERO }) - ); - assert!(lookups.iter().all(|lookup| { - eval_expr(&lookup.multiplicity, &values(&row, &[])) == G::ZERO - })); - } - } -} - -#[test] -fn interpreter_and_generated_helpers_share_table_multiplicities() { - let top = byte_toplevel(false); - let mut interpreted = QueryRecord::new(&top); - let mut generated = QueryRecord::new(&top); - for a in 0..=u8::MAX { - for b in 0..=u8::MAX { - let x = G::from_u8(a); - let y = G::from_u8(b); - let expected = - [G::from_u8(a & b), G::from_u8(a | b), G::from_bool(a < b)]; - let got = [ - bytes2_and_value(x, y, &mut generated), - bytes2_or_value(x, y, &mut generated), - bytes2_less_than_value(x, y, &mut generated), - ]; - assert_eq!(got, expected); - for (op, expected) in - [Bytes2Op::And, Bytes2Op::Or, Bytes2Op::LessThan].iter().zip(expected) - { - assert_eq!(Bytes2.execute(op, &[x, y], &mut interpreted), [expected]); - } - } - } - let widths: Vec<_> = Bytes2.lookups().iter().map(|l| l.args.len()).collect(); - let (a, _) = Bytes2.witness_data(&interpreted, &widths); - let (b, _) = Bytes2.witness_data(&generated, &widths); - assert_eq!(a.values, b.values); - for row in a.values.chunks_exact(a.width) { - assert_eq!( - row, - [G::TWO, G::ZERO, G::ONE, G::ZERO, G::ZERO, G::ZERO, G::ZERO, G::ZERO] - ); - } -} - -#[test] -fn consolidated_byte_proofs_verify_in_both_partitions_and_key_codec() { - for grouped in [false, true] { - let (mut cp, fp) = test_parameters(); - cp.log_blowup = 2; - let system = AiurSystem::build(byte_toplevel(grouped), cp, fp); - let shape = system.circuit_shapes().pop().unwrap(); - assert_eq!( - ( - shape.main_width, - shape.stage2_width, - shape.quotient_degree, - shape.preprocessed_width, - shape.preprocessed_height - ), - (8, 8, 2, 11, 65_536) - ); - let bytes = crate::vk_codec::aiur_system_to_bytes(&system).unwrap(); - let decoded = - crate::vk_codec::AiurVerifyingKey::from_bytes(&bytes).unwrap(); - for member in 0..3 { - for (a, b) in [(0xd3_u8, 0x69_u8), (0, 255)] { - let input = [G::from_u8(a), G::from_u8(b)]; - let expected = match member { - 0 => G::from_u8(a & b), - 1 => G::from_u8(a | b), - _ => G::from_bool(a < b), - }; - let (claim, proof) = - system.prove(member, &input, &mut empty_io_buffer()); - assert_eq!(claim.last(), Some(&expected)); - system.verify(&claim, &proof).unwrap(); - decoded.verify(&claim, &proof).unwrap(); - } - } - } -} - -/// Supply the stage-one trace directly after changing the claimed output -/// or a byte input. Local constraints still hold; the fixed lookup table -/// must reject the false relation, including through grouped selectors. -#[test] -fn forged_consolidated_outputs_and_nonbyte_inputs_fail_lookup_verification() { - for grouped in [false, true] { - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(byte_toplevel(grouped), cp, fp); - let input = [G::from_u8(3), G::from_u8(5)]; - for member in 0..3 { - let circuit = if grouped { 0 } else { member }; - let layout = system.toplevel.circuits[circuit].layout; - let (record, output) = system - .toplevel - .execute(member, input.to_vec(), &mut empty_io_buffer()) - .unwrap(); - let mut original = Vec::new(); - for i in 0..system.toplevel.circuits.len() { - let (trace, _) = system.toplevel.witness_data( - i, - &record, - &empty_io_buffer(), - &system.slot_arg_widths(i), - ); - original.push(trace); - } - original.push( - Bytes1.witness_data(&record, &system.slot_arg_widths(original.len())).0, - ); - original.push( - Bytes2.witness_data(&record, &system.slot_arg_widths(original.len())).0, - ); - let (constraints, _) = system.toplevel.build_constraints(circuit); - for (column, claimed_input, claimed_output) in [ - (3 + layout.selectors, input, -G::ONE), - (0, [G::from_u16(256), input[1]], output[0]), - ] { - let mut traces = original.clone(); - traces[circuit].values[column] = - if column == 0 { claimed_input[0] } else { claimed_output }; - let row = &traces[circuit].values[..layout.width()]; - assert!( - constraints - .zeros - .iter() - .all(|c| { eval_expr(c, &values(row, &[])) == G::ZERO }) - ); - let claim = vec![ - function_channel(), - G::from_usize(member), - claimed_input[0], - claimed_input[1], - claimed_output, - ]; - let witness = SystemWitness::from_stage_1(traces, &system.system); - let proof = system.prove_witness(&claim, witness); - // The row is well-formed; only the byte table disagrees with it, - // so the rejection is the unanswered lookup, not a constraint. - system.verify_shard(&proof, 0).unwrap(); - assert!( - matches!( - system.verify(&claim, &proof), - Err(AiurVerificationError::Stark( - VerificationError::UnbalancedBatch - )) - ), - "a byte table balanced a wrong output" - ); - } - } - } -} - -#[test] -fn original_and_consolidated_operations_share_multiplicities_in_one_proof() { - let function = Function { - body: Block { - ops: vec![ - Op::U8And(0, 1), - Op::U8Or(0, 1), - Op::U8LessThan(0, 1), - Op::U8Xor(0, 1), - Op::U8Sub(0, 1), - ], - ctrl: Ctrl::Return(0, vec![2, 3, 4, 5, 6, 7]), - }, - layout: FunctionLayout { - input_size: 2, - selectors: 1, - auxiliaries: 6, - lookups: 6, - }, - entry: true, - constrained: true, - }; - let top = with_singleton_circuits(vec![function], vec![]); - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(top, cp, fp); - for (a, b) in [(0_u8, 255_u8), (255, 0), (0xd3, 0x69), (255, 255)] { - let input = [G::from_u8(a), G::from_u8(b)]; - let mut io = empty_io_buffer(); - let (record, output) = - system.toplevel.execute(0, input.to_vec(), &mut io).unwrap(); - let (sub, borrow) = a.overflowing_sub(b); - assert_eq!( - output, - [ - G::from_u8(a & b), - G::from_u8(a | b), - G::from_bool(a < b), - G::from_u8(a ^ b), - G::from_u8(sub), - G::from_bool(borrow), - ] - ); - let (table, _) = Bytes2.witness_data(&record, &system.slot_arg_widths(2)); - let row = &table.values - [(usize::from(a) * 256 + usize::from(b)) * table.width..][..table.width]; - assert_eq!( - row, - [ - G::from_u8(3), - G::ZERO, - G::TWO, - G::ZERO, - G::ZERO, - G::ZERO, - G::ZERO, - G::ZERO - ] - ); - let (claim, proof) = - system.prove_from_execution(0, &input, &io, record, &output); - system.verify(&claim, &proof).unwrap(); - } -} diff --git a/crates/aiur/src/synthesis/tests/byte_shapes.rs b/crates/aiur/src/synthesis/tests/byte_shapes.rs deleted file mode 100644 index f0ee43f0a..000000000 --- a/crates/aiur/src/synthesis/tests/byte_shapes.rs +++ /dev/null @@ -1,103 +0,0 @@ -// Copyright (c) 2026 Argument Computer Corporation. -// SPDX-License-Identifier: MIT OR Apache-2.0 - -use super::*; - -fn fixed(heights: &[usize], active: &[bool], degrees: &[u8]) -> bool { - fixed_trace_heights(heights.iter().copied(), active, degrees) -} - -#[test] -fn fixed_heights_follow_active_positions_and_require_fixed_tables() { - assert!(fixed(&[], &[], &[])); - assert!(fixed(&[0, 0], &[false, false], &[])); - assert!(fixed(&[0, 256, 0, 65536], &[true, true, false, true], &[3, 8, 16])); - assert!(fixed(&[0, 256, 0, 65536], &[false, true, false, true], &[8, 16])); - // The separate global budget guard bounds unfixed circuit degrees. - assert!(fixed(&[0], &[true], &[255])); - for (heights, active, degrees) in [ - (vec![256, 65536], vec![false, false], vec![]), - (vec![], vec![false], vec![]), - (vec![256], vec![], vec![]), - (vec![256], vec![true], vec![]), - (vec![256], vec![false], vec![8]), - (vec![256], vec![true], vec![7]), - (vec![256], vec![true], vec![9]), - (vec![65536], vec![true], vec![15]), - (vec![65536], vec![true], vec![17]), - (vec![256, 65536], vec![true, true], vec![16, 8]), - (vec![256, 65536], vec![false, true], vec![8, 16]), - (vec![usize::MAX], vec![true], vec![255]), - ] { - assert!(!fixed(&heights, &active, °rees)); - } -} - -#[test] -fn public_verify_checks_fixed_byte_heights_before_openings() { - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(mul_toplevel(), cp, fp); - let (claim, mut proof) = - system.prove(0, &[G::ONE, G::ONE], &mut empty_io_buffer()); - system.verify(&claim, &proof).unwrap(); - let mut position = 0; - let active_map = proof.preamble.headers[0].active.clone(); - for (circuit, &active) in system.system.circuits.iter().zip(&active_map) { - if active { - let original = proof.preamble.headers[0].log_degrees[position]; - if circuit.preprocessed_height != 0 { - for changed in [original - 1, original + 1] { - proof.preamble.headers[0].log_degrees[position] = changed; - // The generic shape check has no direct fixed-height condition. - // Aiur must establish it before relying on fixed byte-table rows. - system.system.verify_shape(&proof.proofs[0]).unwrap(); - assert!(matches!( - system.verify(&claim, &proof), - Err(AiurVerificationError::Stark( - VerificationError::InvalidProofShape - )) - )); - } - } - proof.preamble.headers[0].log_degrees[position] = original; - position += 1; - } - } - system.verify(&claim, &proof).unwrap(); -} - -#[test] -fn public_verify_checks_fixed_byte_activity_before_openings() { - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(mul_toplevel(), cp, fp); - let claim = [function_channel(), G::ZERO, G::ONE, G::ONE, G::ONE]; - let traces = system - .circuit_shapes() - .iter() - .enumerate() - .map(|(index, shape)| { - let height = if index == 0 { 4 } else { shape.preprocessed_height }; - let mut rows = vec![G::ZERO; height * shape.main_width]; - if index == 0 { - rows[..4].fill(G::ONE); - rows[4] = G::ONE; - } - RowMajorMatrix::new(rows, shape.main_width) - }) - .collect(); - let mut witness = SystemWitness::from_stage_1(traces, &system.system); - // There are no unary-byte queries. The generic shape check permits - // omission, but the PCS rejects a matrix without opening points. Aiur - // makes the required activity explicit before entering that verifier. - witness.traces[1].values.clear(); - witness.lookups[1] = - LookupValues::builder(0, &system.slot_arg_widths(1)).finish(); - let proof = system.prove_witness(&claim, witness); - assert_eq!(proof.preamble.headers[0].active, vec![true, false, true]); - assert_eq!(proof.preamble.headers[0].log_degrees, vec![2, 16]); - system.system.verify_shape(&proof.proofs[0]).unwrap(); - assert!(matches!( - system.verify(&claim, &proof), - Err(AiurVerificationError::Stark(VerificationError::InvalidProofShape)) - )); -} diff --git a/crates/aiur/src/synthesis/tests/host_timings.rs b/crates/aiur/src/synthesis/tests/host_timings.rs deleted file mode 100644 index 274b20fe2..000000000 --- a/crates/aiur/src/synthesis/tests/host_timings.rs +++ /dev/null @@ -1,55 +0,0 @@ -// Copyright (c) 2026 Argument Computer Corporation. -// SPDX-License-Identifier: MIT OR Apache-2.0 - -use super::*; - -/// Run the same fixture in separate processes at the old and new revisions -/// to compare peak RSS. Construction and record allocation are outside the -/// timer; no proof is needed to measure witness generation. No timing pin. -#[test] -#[ignore = "manual witness construction memory and timing measurement"] -fn witness_construction_timings() { - use std::{hint::black_box, time::Instant}; - - let n: usize = std::env::var("AIUR_WITNESS_ROWS") - .unwrap_or_else(|_| "1048576".into()) - .parse() - .expect("positive row count"); - assert!(n > 0); - let 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, - }; - let top = with_singleton_circuits(vec![function], vec![]); - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(top, cp, fp); - let mut record = QueryRecord::new(&system.toplevel); - for value in 0..n { - let value = G::from_usize(value); - record.function_queries[0].insert(&[value], &[value], G::ONE).unwrap(); - } - let start = Instant::now(); - let (trace, lookups) = system.toplevel.witness_data( - 0, - &record, - &empty_io_buffer(), - &system.slot_widths[0], - ); - let elapsed = start.elapsed(); - assert_eq!(trace.values.len(), n.next_power_of_two() * 3); - assert_eq!(&trace.values[..3], &[G::ZERO, G::ONE, G::ONE]); - assert_eq!(trace.values[(n - 1) * 3], G::from_usize(n - 1)); - black_box((&trace, &lookups)); - eprintln!( - "rows={n} metadata_bytes={} witness_ms={:.3}", - crate::trace::witness_metadata_bytes(1, n), - elapsed.as_secs_f64() * 1_000.0 - ); -} diff --git a/crates/aiur/src/synthesis/tests/lookup_budget.rs b/crates/aiur/src/synthesis/tests/lookup_budget.rs deleted file mode 100644 index 548039fb0..000000000 --- a/crates/aiur/src/synthesis/tests/lookup_budget.rs +++ /dev/null @@ -1,115 +0,0 @@ -// Copyright (c) 2026 Argument Computer Corporation. -// SPDX-License-Identifier: MIT OR Apache-2.0 - -use super::*; - -fn bound(slots: &[usize], active: &[bool], degrees: &[u8]) -> Option { - lookup_query_bound(slots.iter().copied(), active, degrees) -} - -#[test] -fn query_budget_uses_canonical_slots_and_active_heights() { - assert_eq!( - bound(&[2, 999, 3, 999], &[true, false, true, false], &[4, 5]), - Some(129) - ); - assert_eq!( - bound(&[999, 3, 999, 2], &[false, true, false, true], &[5, 4]), - Some(129) - ); - assert_eq!(bound(&[0], &[true], &[0]), Some(1)); - assert_eq!(bound(&[1], &[true], &[63]), Some((1_u64 << 63) + 1)); -} - -#[test] -fn query_budget_rejects_malformed_alignment_and_shifts() { - for (slots, active, degrees) in [ - (vec![], vec![], vec![]), - (vec![1], vec![false], vec![]), - (vec![1], vec![], vec![]), - (vec![], vec![true], vec![0]), - (vec![1, 2], vec![true], vec![0]), - (vec![1], vec![true, false], vec![0]), - (vec![1], vec![true], vec![]), - (vec![1], vec![true], vec![0, 0]), - (vec![1, 2], vec![false, true], vec![0, 0]), - ] { - assert_eq!(bound(&slots, &active, °rees), None); - } - for degree in 64..=255 { - for slots in [0, 1, usize::MAX] { - assert_eq!(bound(&[slots], &[true], &[degree]), None); - } - } -} - -#[cfg(target_pointer_width = "64")] -#[test] -fn query_budget_checks_the_global_sum_and_both_overflows() { - use multi_stark::p3_field::PrimeField64; - let p = usize::try_from(G::ORDER_U64).unwrap(); - assert_eq!(bound(&[p - 2], &[true], &[0]), Some(G::ORDER_U64 - 1)); - assert_eq!(bound(&[p - 1], &[true], &[0]), None); - assert_eq!( - bound(&[p - 3, 1], &[true, true], &[0, 0]), - Some(G::ORDER_U64 - 1) - ); - assert_eq!(bound(&[p - 3, 2], &[true, true], &[0, 0]), None); - assert_eq!(bound(&[usize::MAX], &[true], &[1]), None); - assert_eq!(bound(&[usize::MAX], &[true], &[0]), None); - assert_eq!(bound(&[1, usize::MAX], &[true, false], &[0]), Some(2)); - let slots = (p - 2) >> 31; - assert!(bound(&[slots], &[true], &[31]).is_some()); - assert_eq!(bound(&[slots + 1], &[true], &[31]), None); -} - -#[test] -fn public_verify_checks_lookup_metadata() { - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(mul_toplevel(), cp, fp); - let (claim, mut proof) = - system.prove(0, &[G::ONE, G::ONE], &mut empty_io_buffer()); - system.verify(&claim, &proof).unwrap(); - assert!( - lookup_query_bound( - system.slot_widths.iter().map(Vec::len), - &proof.preamble.headers[0].active, - &proof.preamble.headers[0].log_degrees - ) - .is_some() - ); - let degrees = proof.preamble.headers[0].log_degrees.clone(); - for malformed in - [vec![], vec![0; degrees.len() + 1], vec![255; degrees.len()]] - { - proof.preamble.headers[0].log_degrees = malformed; - assert!(matches!( - system.verify(&claim, &proof), - Err(AiurVerificationError::Stark(VerificationError::InvalidProofShape)) - )); - } - proof.preamble.headers[0].log_degrees = degrees; - let active = proof.preamble.headers[0].active.clone(); - for malformed in - [vec![], vec![false; active.len()], vec![true; active.len() + 1]] - { - proof.preamble.headers[0].active = malformed; - assert!(matches!( - system.verify(&claim, &proof), - Err(AiurVerificationError::Stark(VerificationError::InvalidProofShape)) - )); - } - proof.preamble.headers[0].active = active; - system.verify(&claim, &proof).unwrap(); -} - -#[test] -fn serialized_key_maximum_lookup_budget_fits_characteristic() { - use multi_stark::p3_field::PrimeField64; - let slots = vec![65535; 65535]; - let active = vec![true; 65535]; - let degrees = vec![32; 65535]; - let maximum = 1 + 65535_u64.pow(2) * (1_u64 << 32); - assert!(maximum < G::ORDER_U64); - assert_eq!(bound(&slots, &active, °rees), Some(maximum)); -} diff --git a/crates/aiur/src/synthesis/tests/lookup_groups.rs b/crates/aiur/src/synthesis/tests/lookup_groups.rs deleted file mode 100644 index d64853e9c..000000000 --- a/crates/aiur/src/synthesis/tests/lookup_groups.rs +++ /dev/null @@ -1,141 +0,0 @@ -// Copyright (c) 2026 Argument Computer Corporation. -// SPDX-License-Identifier: MIT OR Apache-2.0 - -use super::*; - -/// f(n) = 16*n*n + f(n-1), with sixteen shared calls to g(n) = n*n. -/// Its gated lookup messages benefit from k = 2 at quotient degree 4. -fn wide_recursive_toplevel() -> Toplevel { - let mut ops: Vec<_> = - (0..16).map(|_| Op::Call(1, vec![0], 1, false)).collect(); - ops.extend([ - Op::Const(G::ONE), - Op::Sub(0, 17), - Op::Call(0, vec![18], 1, false), - ]); - let mut sum = 1; - for value in 2..=16 { - ops.push(Op::Add(sum, value)); - sum = ops.len(); - } - ops.push(Op::Add(sum, 19)); - let root = Function { - body: Block { - ops: vec![], - ctrl: Ctrl::Match( - 0, - [( - G::ZERO, - Block { - ops: vec![Op::Const(G::ZERO)], - ctrl: Ctrl::Return(0, vec![1]), - }, - )] - .into_iter() - .collect(), - Some(Box::new(Block { ops, ctrl: Ctrl::Return(1, vec![35]) })), - ), - }, - layout: FunctionLayout { - input_size: 1, - selectors: 2, - auxiliaries: 19, - lookups: 18, - }, - entry: true, - constrained: true, - }; - let leaf = Function { - body: Block { ops: vec![Op::Mul(0, 0)], ctrl: Ctrl::Return(0, vec![1]) }, - layout: FunctionLayout { - input_size: 1, - selectors: 1, - auxiliaries: 2, - lookups: 1, - }, - entry: false, - constrained: true, - }; - with_singleton_circuits(vec![root, leaf], vec![]) -} - -fn wide_system(log_blowup: usize) -> AiurSystem { - let (mut cp, fp) = test_parameters(); - cp.log_blowup = log_blowup; - AiurSystem::build(wide_recursive_toplevel(), cp, fp) -} - -#[test] -fn larger_lookup_groups_verify_and_roundtrip_with_the_degree_budget() { - for (log_blowup, group, quotient, stage2) in [(1, 1, 2, 36), (2, 2, 4, 18)] { - let system = wide_system(log_blowup); - let circuit = &system.system.circuits[0]; - assert_eq!(circuit.lookup_group_size, group); - assert_eq!(circuit.quotient_degree(), quotient); - assert_eq!(circuit.stage_2_width, stage2); - assert!(system.system.circuits.iter().all(|c| { - c.quotient_degree() <= system.system.config.max_quotient_degree() - })); - // Grouping changes accumulator count, never the logical message count - // used by the characteristic bound on lookup consumers. - assert_eq!(system.slot_widths[0].len(), 18); - assert_eq!( - lookup_query_bound( - system.slot_widths.iter().map(Vec::len), - &[true, false, false, false], - &[3], - ), - Some(1 + 18 * 8) - ); - let bytes = crate::vk_codec::aiur_system_to_bytes(&system).unwrap(); - let (decoded, cp, fp) = crate::vk_codec::from_bytes(&bytes).unwrap(); - let vk = crate::vk_codec::AiurVerifyingKey::from_bytes(&bytes).unwrap(); - assert_eq!(crate::vk_codec::to_bytes(&decoded, cp, fp), bytes); - let back = &decoded.circuits[0]; - assert_eq!(back.lookup_group_size, group); - assert_eq!(back.max_constraint_degree, circuit.max_constraint_degree); - assert_eq!(back.constraint_count, circuit.constraint_count); - assert_eq!(back.stage_2_width, circuit.stage_2_width); - for n in [0_u8, 7] { - let (mut claim, proof) = - system.prove(0, &[G::from_u8(n)], &mut empty_io_buffer()); - let expected: u64 = (1..=u64::from(n)).map(|i| 16 * i * i).sum(); - assert_eq!(claim.last(), Some(&G::from_u64(expected))); - system.verify(&claim, &proof).unwrap(); - vk.verify(&claim, &proof).unwrap(); - *claim.last_mut().unwrap() += G::ONE; - assert!(system.verify(&claim, &proof).is_err()); - assert!(vk.verify(&claim, &proof).is_err()); - } - } -} - -/// An opt-in wall-clock check for the quotient-work/FFT tradeoff. Timings -/// exclude construction and verification; both configurations use identical -/// bytecode, commitment parameters and query workloads. No timing assertion. -#[test] -#[ignore = "manual lookup grouping performance comparison"] -fn lookup_group_proving_timings() { - use std::time::Instant; - - let grouped = wide_system(2); - let mut legacy = wide_system(2); - crate::lookup_groups::set_group(&mut legacy.system.circuits[0], 1, 2); - for n in [7, 32_768, 131_072] { - for round in 0..3 { - for pick in 0..2 { - let (name, system) = if (round + pick) % 2 == 0 { - ("legacy", &legacy) - } else { - ("grouped", &grouped) - }; - let start = Instant::now(); - let (claim, proof) = - system.prove(0, &[G::from_u32(n)], &mut empty_io_buffer()); - let elapsed = start.elapsed(); - system.verify(&claim, &proof).unwrap(); - println!("lookup timing: n={n} round={round} {name} {elapsed:?}"); - } - } - } -} diff --git a/crates/aiur/src/synthesis/tests/lookup_shapes.rs b/crates/aiur/src/synthesis/tests/lookup_shapes.rs deleted file mode 100644 index 52546c167..000000000 --- a/crates/aiur/src/synthesis/tests/lookup_shapes.rs +++ /dev/null @@ -1,236 +0,0 @@ -// Copyright (c) 2026 Argument Computer Corporation. -// SPDX-License-Identifier: MIT OR Apache-2.0 - -use super::*; - -/// Lookup compression zero-pads messages. An empty return must not become -/// an output of zero just because both messages have the same fingerprint. -#[test] -fn public_output_cannot_be_supplied_by_zero_padding() { - let 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, - }; - let (cp, fp) = test_parameters(); - let system = - AiurSystem::build(with_singleton_circuits(vec![function], vec![]), cp, fp); - let claim = [function_channel(), G::ZERO, G::ZERO]; - let traces = system - .circuit_shapes() - .iter() - .enumerate() - .map(|(index, shape)| { - let height = if index == 0 { 4 } else { shape.preprocessed_height }; - let mut rows = vec![G::ZERO; height * shape.main_width]; - if index == 0 { - // Active empty return, multiplicity one. - rows[..2].copy_from_slice(&[G::ONE, G::ONE]); - } - RowMajorMatrix::new(rows, shape.main_width) - }) - .collect(); - let witness = SystemWitness::from_stage_1(traces, &system.system); - let proof = system.prove_witness(&claim, witness); - system.system.verify_batch(&proof).unwrap(); - assert!( - matches!( - system.verify(&claim, &proof), - Err(AiurVerificationError::Stark(VerificationError::InvalidClaim)) - ), - "zero padding was accepted as a function output" - ); - let (claim, proof) = system.prove(0, &[], &mut empty_io_buffer()); - system.verify(&claim, &proof).unwrap(); -} - -#[test] -#[should_panic(expected = "invalid Aiur lookup shapes")] -fn system_construction_rejects_mismatched_call_outputs() { - let mut top = call_and_memory_toplevel(); - top.functions[0].body.ops[0] = Op::Call(1, vec![0], 2, false); - // Reserve the extra output column so a layout error cannot mask the - // mismatched function-message boundary. - top.functions[0].layout.auxiliaries += 1; - top.circuits[0].layout = top.functions[0].layout; - let (cp, fp) = test_parameters(); - AiurSystem::build(top, cp, fp); -} - -#[test] -fn public_claim_shape_checks_channel_visibility_and_arity() { - let top = mul_toplevel(); - let shapes = top.checked_claim_shapes().unwrap(); - assert!(valid_claim_shape( - &shapes, - &[G::ZERO, G::ZERO, G::ONE, G::ONE, G::ONE] - )); - for claim in [ - vec![], - vec![G::ZERO], - vec![G::ONE, G::ZERO, G::ONE, G::ONE, G::ONE], - vec![G::ZERO, G::ONE, G::ONE, G::ONE, G::ONE], - vec![G::ZERO, G::ZERO, G::ONE], - vec![G::ZERO, G::ZERO, G::ONE, G::ONE], - vec![G::ZERO, G::ZERO, G::ONE, G::ONE, G::ONE, G::ZERO], - ] { - assert!(!valid_claim_shape(&shapes, &claim)); - } - for constrained in [true, false] { - let mut top = mul_toplevel(); - top.functions[0].entry = !constrained; - top.functions[0].constrained = constrained; - assert!(!valid_claim_shape( - &top.checked_claim_shapes().unwrap(), - &[G::ZERO; 5] - )); - } -} - -#[test] -fn constrained_calls_check_both_message_boundaries() { - let top = call_and_memory_toplevel(); - top.validate_lookup_shapes().unwrap(); - for malformed in [ - Op::Call(1, vec![], 1, false), - Op::Call(1, vec![0], 0, false), - Op::Call(1, vec![0], 2, false), - Op::Call(99, vec![0], 1, false), - ] { - let mut top = call_and_memory_toplevel(); - top.functions[0].body.ops.push(malformed); - assert!(top.validate_lookup_shapes().is_err()); - } - let mut top = call_and_memory_toplevel(); - top.functions[1].constrained = false; - assert!(top.validate_lookup_shapes().is_err()); - // An unconstrained call supplies advice and emits no function lookup. - let mut top = mul_toplevel(); - top.functions[0].body.ops.push(Op::Call(99, vec![], 17, true)); - top.validate_lookup_shapes().unwrap(); -} - -#[test] -fn cached_arities_match_recursive_checks_for_nested_control_flow() { - fn returning(size: usize) -> Block { - Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0; size]) } - } - fn yielding() -> Block { - Block { ops: vec![], ctrl: Ctrl::Yield(0, vec![0; 2]) } - } - fn matching(arms: Vec, fallback: Option) -> Block { - Block { - ops: vec![], - ctrl: Ctrl::Match( - 0, - arms - .into_iter() - .enumerate() - .map(|(i, b)| (G::from_usize(i), b)) - .collect(), - fallback.map(Box::new), - ), - } - } - fn continued(arm: Block, continuation: Block) -> Block { - Block { - ops: vec![], - ctrl: Ctrl::MatchContinue( - 0, - [(G::ZERO, arm)].into_iter().collect(), - Some(Box::new(yielding())), - 2, - 0, - 0, - Box::new(continuation), - ), - } - } - let mut bodies = vec![ - matching(vec![], None), - matching(vec![], Some(returning(0))), - continued(yielding(), matching(vec![], None)), - ]; - for a in 0..3 { - bodies.push(returning(a)); - bodies.push(continued(yielding(), returning(a))); - bodies.push(continued(continued(returning(a), yielding()), returning(a))); - for b in 0..3 { - bodies.push(matching(vec![returning(a), returning(b)], None)); - bodies.push(matching(vec![returning(a)], Some(returning(b)))); - bodies.push(continued(returning(a), returning(b))); - bodies.push(continued(continued(returning(a), yielding()), returning(b))); - } - } - for body in bodies { - let mut top = call_and_memory_toplevel(); - // Test the cached public boundary and each call-site boundary against - // the original recursive predicate, including vacuous and mixed returns. - top.functions[0].body.ops.clear(); - top.functions[1].entry = true; - top.functions[1].body = body; - let shapes = top.checked_claim_shapes().unwrap(); - for outputs in 0..4 { - let expected = top.functions[1].body.returns_have_size(outputs); - let mut claim = vec![function_channel(), G::ONE, G::ZERO]; - claim.resize(3 + outputs, G::ZERO); - assert_eq!(valid_claim_shape(&shapes, &claim), expected); - top.functions[0].body.ops = vec![Op::Call(1, vec![0], outputs, false)]; - assert_eq!(top.validate_lookup_shapes().is_ok(), expected); - } - } -} - -#[test] -fn nested_continuations_check_returns_and_yields() { - fn returning(size: usize) -> Block { - Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0; size]) } - } - fn yielding(size: usize) -> Block { - Block { ops: vec![], ctrl: Ctrl::Yield(0, vec![0; size]) } - } - fn continuation(arm: Block, continued: Block) -> Block { - Block { - ops: vec![], - ctrl: Ctrl::MatchContinue( - 0, - [(G::ZERO, arm)].into_iter().collect(), - Some(Box::new(yielding(2))), - 2, - 0, - 0, - Box::new(continued), - ), - } - } - for arm in [returning(1), yielding(2)] { - let body = continuation(arm, returning(1)); - assert!(body.returns_have_size(1)); - assert!(!body.returns_have_size(0)); - let mut top = mul_toplevel(); - top.functions[0].body = body; - top.validate_lookup_shapes().unwrap(); - } - assert!(!continuation(returning(0), returning(1)).returns_have_size(1)); - assert!(!continuation(yielding(2), returning(0)).returns_have_size(1)); - for body in [ - yielding(2), - continuation(yielding(1), returning(1)), - continuation(yielding(2), yielding(2)), - continuation(continuation(yielding(2), yielding(1)), returning(1)), - ] { - let mut top = mul_toplevel(); - top.functions[0].body = body; - assert!(top.validate_lookup_shapes().is_err()); - } - let mut top = mul_toplevel(); - top.functions[0].body = - continuation(continuation(returning(1), yielding(2)), returning(1)); - top.validate_lookup_shapes().unwrap(); -} diff --git a/crates/aiur/src/synthesis/tests/mmcs.rs b/crates/aiur/src/synthesis/tests/mmcs.rs deleted file mode 100644 index 4d6f0fa28..000000000 --- a/crates/aiur/src/synthesis/tests/mmcs.rs +++ /dev/null @@ -1,141 +0,0 @@ -// Copyright (c) 2026 Argument Computer Corporation. -// SPDX-License-Identifier: MIT OR Apache-2.0 - -//! Native binary Merkle authentication and the cap coverage boundary. - -use super::*; - -#[cfg(not(feature = "cuda"))] -#[test] -fn native_cap_can_omit_a_shorter_matrix() { - use multi_stark::p3_matrix::Matrix; - use multi_stark::types::Mmcs; - use p3_blake3::Blake3; - use p3_commit::Mmcs as _; - use p3_symmetric::{CompressionFunctionFromHasher, SerializingHasher}; - - for cap_height in 0..=4 { - let mmcs = Mmcs::new( - SerializingHasher::new(Blake3), - CompressionFunctionFromHasher::new(Blake3), - cap_height, - ); - let tall = RowMajorMatrix::new((1..=8).map(G::from_u32).collect(), 1); - let short = RowMajorMatrix::new(vec![G::from_u32(21), G::from_u32(22)], 1); - let dimensions = vec![tall.dimensions(), short.dimensions()]; - let (commitment, data) = mmcs.commit(vec![tall.clone(), short]); - let mut changed = mmcs.open_batch(5, &data); - mmcs.verify_batch(&commitment, &dimensions, 5, (&changed).into()).unwrap(); - changed.opened_values[1][0] += G::ONE; - let accepted = - mmcs.verify_batch(&commitment, &dimensions, 5, (&changed).into()).is_ok(); - assert_eq!(accepted, cap_height > 1); - - let indices = [5, 0, 5, 7]; - let (mut rows, proof) = mmcs.open_multi_batch(&indices, &data); - mmcs - .verify_multi_batch(&commitment, &dimensions, &indices, &rows, &proof) - .unwrap(); - for query in &mut rows { - query[1][0] += G::ONE; - } - let accepted = mmcs - .verify_multi_batch(&commitment, &dimensions, &indices, &rows, &proof) - .is_ok(); - assert_eq!(accepted, cap_height > 1); - - let different = - RowMajorMatrix::new(vec![G::from_u32(31), G::from_u32(32)], 1); - let (other_commitment, _) = mmcs.commit(vec![tall, different]); - assert_eq!(commitment == other_commitment, cap_height > 1); - } -} - -#[cfg(not(feature = "cuda"))] -#[test] -fn public_verify_rejects_a_cap_above_the_shortest_trace_lde() { - let (mut cp, fp) = test_parameters(); - cp.cap_height = 2; - let system = AiurSystem::build(mul_toplevel(), cp, fp); - let (claim, proof) = - system.prove(0, &[G::ONE, G::ONE], &mut empty_io_buffer()); - assert_eq!(proof.preamble.headers[0].log_degrees[0], 0); - system.system.verify_batch(&proof).unwrap(); - assert!(matches!( - system.verify(&claim, &proof), - Err(AiurVerificationError::Stark(VerificationError::InvalidProofShape)) - )); -} - -#[test] -fn public_verify_accepts_a_cap_at_the_shortest_trace_lde() { - let (mut cp, fp) = test_parameters(); - #[cfg(not(feature = "cuda"))] - { - cp.cap_height = 1; - } - #[cfg(feature = "cuda")] - { - cp.cap_height = 0; - } - let system = AiurSystem::build(mul_toplevel(), cp, fp); - let (claim, proof) = - system.prove(0, &[G::from_u32(3), G::from_u32(5)], &mut empty_io_buffer()); - assert_eq!(proof.preamble.headers[0].log_degrees[0], 0); - system.verify(&claim, &proof).unwrap(); - let mut changed = claim.clone(); - *changed.last_mut().unwrap() += G::ONE; - assert!(system.verify(&changed, &proof).is_err()); -} - -#[test] -fn cap_coverage_matches_injection_geometry_at_integer_boundaries() { - let parameters = [ - 0, - 1, - 2, - 3, - 8, - 16, - 31, - 32, - 63, - 64, - 255, - 256, - 65535, - usize::MAX - 255, - usize::MAX, - ]; - let mut total = 0; - for blowup in parameters { - for cap in parameters { - assert!(trace_cap_coverage(blowup, cap, &[])); - total += 1; - for degree in 0..=255 { - for degrees in [ - vec![degree], - vec![degree, 0], - vec![degree, 8, 16], - vec![degree, degree], - vec![255, degree], - ] { - // Check the direct tree-height condition with wide arithmetic, - // independently of the production guard's saturating subtraction. - let tallest = u128::from(*degrees.iter().max().unwrap()); - let effective_cap = (cap as u128).min(blowup as u128 + tallest); - let expected = degrees.iter().all(|&height| { - effective_cap <= blowup as u128 + u128::from(height) - }); - assert_eq!( - trace_cap_coverage(blowup, cap, °rees), - expected, - "blowup={blowup}, cap={cap}, degrees={degrees:?}" - ); - total += 1; - } - } - } - } - assert_eq!(total, 288225); -} diff --git a/crates/aiur/src/synthesis/tests/peak.rs b/crates/aiur/src/synthesis/tests/peak.rs deleted file mode 100644 index 661198ecf..000000000 --- a/crates/aiur/src/synthesis/tests/peak.rs +++ /dev/null @@ -1,138 +0,0 @@ -// Copyright (c) 2026 Argument Computer Corporation. -// SPDX-License-Identifier: MIT OR Apache-2.0 - -use super::*; -use crate::bytecode::Circuit; - -fn grouped_system() -> AiurSystem { - let layout = - FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 1, lookups: 1 }; - let functions = (0..3) - .map(|_| Function { - body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }, - layout, - entry: true, - constrained: true, - }) - .collect(); - let top = Toplevel { - functions, - memory_sizes: vec![1], - circuits: vec![ - Circuit { - members: vec![2, 0], - layout: FunctionLayout { selectors: 2, ..layout }, - }, - Circuit { members: vec![1], layout }, - ], - }; - let (cp, fp) = test_parameters(); - AiurSystem::build(top, cp, fp) -} - -fn grouped_record(top: &Toplevel) -> QueryRecord { - let mut record = QueryRecord::new(top); - for (i, rows) in [2, 3, 5].into_iter().enumerate() { - for row in 0..rows { - let value = G::from_usize(10 * i + row); - // An advice-only entry in the middle must not shift query indices - // or selectors of the surrounding active rows. - let mult = G::from_bool(i != 2 || row != 1); - record.function_queries[i].insert(&[value], &[value], mult).unwrap(); - } - } - record - .memory_queries - .get_mut(&1) - .unwrap() - .insert(&[G::ONE], &[G::ZERO], G::ONE) - .unwrap(); - record -} - -#[test] -fn grouped_peak_counts_members_before_splitting_and_keeps_gadget_heights() { - let system = grouped_system(); - let record = grouped_record(&system.toplevel); - let types = system.circuit_types(); - for (parts, expected) in - [(1, vec![7, 3, 1, 256, 65_536]), (4, vec![2, 1, 1, 256, 65_536])] - { - let counts: Vec<_> = types - .iter() - .enumerate() - .map(|(i, ct)| raw_of(&system.toplevel, &record, parts)(i, ct)) - .collect(); - assert_eq!(counts, expected); - } - let expected = system.peak_prove_bytes_by( - |i, _| [7, 3, 1, 256, 65_536][i], - crate::execute::record_retained_bytes(&record), - ); - assert_eq!(system.peak_prove_bytes(&record).peak, expected.peak); - assert_eq!(system.suggested_split_parts(&record, expected.peak), 1); - let half_peak = system.peak_prove_bytes_by( - |i, _| [4, 2, 1, 256, 65_536][i], - crate::execute::record_retained_bytes(&record) / 2, - ); - assert!(half_peak.peak < expected.peak); - assert_eq!(system.suggested_split_parts(&record, half_peak.peak), 2); -} - -#[test] -fn peak_uses_extension_storage_even_when_accumulators_are_grouped() { - let system = grouped_system(); - let peak = system.peak_prove_bytes_by(|_, _| 8, 0); - let circuits = &system.system.circuits; - assert!(circuits.iter().any(|c| c.lookup_group_size > 1)); - // Sum actual payload types: messages and their inverse copy are extension - // values regardless of how many accumulator columns are committed. - let expected: usize = circuits - .iter() - .zip(&system.slot_widths) - .map(|(c, widths)| { - 2 * 8 * c.main_width * size_of::() - + 8 * (c.num_lookups + widths.iter().sum::()) * size_of::() - + 2 * 8 * c.num_lookups * size_of::() - + 8 * c.stage_2_width * size_of::() - }) - .sum(); - assert_eq!(peak.phase_stage2, expected + 2 * 32 * 16); - // FRI retains base-coordinate LDEs plus extension-valued quotients. - let committed: usize = circuits - .iter() - .map(|c| { - 16 * ((c.main_width + c.stage_2_width) * size_of::() - + c.quotient_degree() * size_of::()) - }) - .sum(); - assert_eq!( - peak.phase_open, - committed + 3 * 2 * 32 * 16 + (2 * 8 + 2 * 32) * 16 * 2 + 11 * 8 * 16 - ); -} - -#[test] -fn grouped_witness_skips_advice_without_shifting_members() { - let system = grouped_system(); - let record = grouped_record(&system.toplevel); - let (trace, _) = system.toplevel.witness_data( - 0, - &record, - &empty_io_buffer(), - &system.slot_widths[0], - ); - assert_eq!(trace.values.len(), 8 * trace.width); - for (row, (member, query)) in - [(2, 0), (2, 2), (2, 3), (2, 4), (0, 0), (0, 1)].into_iter().enumerate() - { - let values = &trace.values[row * trace.width..(row + 1) * trace.width]; - assert_eq!(values[0], G::from_usize(10 * member + query)); - assert_eq!( - &values[1..3], - &[G::from_bool(member == 2), G::from_bool(member == 0)] - ); - assert_eq!(values[3], G::ONE); - } - assert!(trace.values[6 * trace.width..].iter().all(|&v| v == G::ZERO)); -} diff --git a/crates/aiur/src/synthesis/tests/u32_compare.rs b/crates/aiur/src/synthesis/tests/u32_compare.rs deleted file mode 100644 index 14f265f0e..000000000 --- a/crates/aiur/src/synthesis/tests/u32_compare.rs +++ /dev/null @@ -1,387 +0,0 @@ -// Copyright (c) 2026 Argument Computer Corporation. -// SPDX-License-Identifier: MIT OR Apache-2.0 - -use super::*; -use crate::bytecode::Circuit; -use multi_stark::{ - eval::{VarValues, eval_expr}, - p3_field::PrimeField64, -}; - -fn comparison_toplevel(grouped: bool) -> Toplevel { - let layout = - FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 7, lookups: 7 }; - let functions = (0..2) - .map(|_| Function { - body: Block { - ops: vec![Op::U32LessThan(0, 1)], - ctrl: Ctrl::Return(0, vec![2]), - }, - layout, - entry: true, - constrained: true, - }) - .collect(); - let mut top = with_singleton_circuits(functions, vec![]); - if grouped { - top.circuits = vec![Circuit { - members: vec![0, 1], - layout: FunctionLayout { selectors: 2, ..layout }, - }]; - } - top -} - -fn values<'a>(row: &'a [G], preprocessed: &'a [G]) -> VarValues<'a, G> { - VarValues { - preprocessed: [preprocessed, preprocessed], - main: [row, row], - stage2: [&[], &[]], - publics: &[], - is_first_row: G::ONE, - is_last_row: G::ZERO, - is_transition: G::ONE, - } -} - -fn message(lookup: &Lookup>, row: &[G], pre: &[G]) -> Vec { - let vars = values(row, pre); - lookup.args.iter().map(|arg| eval_expr(arg, &vars)).collect() -} - -fn honest_row( - layout: FunctionLayout, - selector: usize, - a: u32, - b: u32, -) -> Vec { - let mut row = vec![G::ZERO; layout.width()]; - row[0] = G::from_u32(a); - row[1] = G::from_u32(b); - row[2 + selector] = G::ONE; - let aux = 2 + layout.selectors; - row[aux] = G::ONE; - let start = aux + 1; - let c = a.wrapping_sub(b); - for (i, word) in [a, c, b].into_iter().enumerate() { - row[start + 2 * i] = G::from_u16((word & 0xffff) as u16); - row[start + 2 * i + 1] = G::from_u16((word >> 16) as u16); - } - row -} - -#[test] -fn u32_compare_all_six_limbs_match_the_scalar_table_in_both_partitions() { - let table = Bytes2.preprocessed().unwrap(); - let providers = Bytes2.lookups(); - let table_row = [G::ZERO; 8]; - for grouped in [false, true] { - let top = comparison_toplevel(grouped); - for member in 0..2 { - let circuit = if grouped { 0 } else { member }; - let layout = top.circuits[circuit].layout; - let (constraints, requests) = top.build_constraints(circuit); - assert_eq!(requests.len(), 7); - assert_eq!(constraints.width, 9 + layout.selectors); - let start = 3 + layout.selectors; - let mut row = honest_row(layout, if grouped { member } else { 0 }, 0, 0); - for value in 0..=u16::MAX { - let field = G::from_u16(value); - row[start..start + 6].fill(field); - let pre = - &table.values[usize::from(value) * table.width..][..table.width]; - let provider = - message(&providers[Bytes2::U16_RANGE_CHECK_COLUMN], &table_row, pre); - assert_eq!(provider, [crate::u16_range_check_channel(), field]); - for request in &requests[1..] { - assert_eq!(message(request, &row, &[]), provider); - assert_eq!( - eval_expr(&request.multiplicity, &values(&row, &[])), - G::ONE - ); - } - } - for limb in 0..6 { - for bad in [-G::ONE, G::from_u32(65536), G::from_u64(1 << 32)] { - row[start + limb] = bad; - assert_eq!( - message(&requests[1 + limb], &row, &[]), - [crate::u16_range_check_channel(), bad] - ); - assert!(bad.as_canonical_u64() > u64::from(u16::MAX)); - } - } - } - } -} - -#[test] -fn u32_compare_constraints_preserve_strictness_bounds_and_inactive_gates() { - let boundary = [ - 0_u32, - 1, - 255, - 256, - 65535, - 65536, - 65537, - 0x7fff_ffff, - 0x8000_0000, - 0xffff_0000, - 0xffff_fffe, - u32::MAX, - ]; - for grouped in [false, true] { - let top = comparison_toplevel(grouped); - for member in 0..2 { - let circuit = if grouped { 0 } else { member }; - let layout = top.circuits[circuit].layout; - let (constraints, requests) = top.build_constraints(circuit); - for a in boundary { - for b in boundary { - let row = honest_row(layout, if grouped { member } else { 0 }, a, b); - assert!( - constraints - .zeros - .iter() - .all(|c| eval_expr(c, &values(&row, &[])) == G::ZERO) - ); - assert_eq!(message(&requests[0], &row, &[])[4], G::from_bool(a < b)); - // Every decomposition column participates in the compiled - // equations; wrong in-range advice cannot change the result. - let start = 3 + layout.selectors; - for limb in 0..6 { - let mut changed = row.clone(); - changed[start + limb] += G::ONE; - assert!( - constraints - .zeros - .iter() - .any(|c| eval_expr(c, &values(&changed, &[])) != G::ZERO) - ); - } - for input in 0..2 { - let mut changed = row.clone(); - changed[input] += G::from_u64(1 << 32); - assert!( - constraints - .zeros - .iter() - .any(|c| eval_expr(c, &values(&changed, &[])) != G::ZERO) - ); - } - } - } - let mut inactive = vec![-G::ONE; layout.width()]; - inactive[2..3 + layout.selectors].fill(G::ZERO); - assert!( - constraints - .zeros - .iter() - .all(|c| eval_expr(c, &values(&inactive, &[])) == G::ZERO) - ); - assert!(requests.iter().all(|request| eval_expr( - &request.multiplicity, - &values(&inactive, &[]) - ) == G::ZERO)); - } - } -} - -#[test] -fn u32_compare_proofs_and_decoded_keys_cover_boundaries_and_partitions() { - for grouped in [false, true] { - let (mut cp, fp) = test_parameters(); - cp.log_blowup = 2; - let system = AiurSystem::build(comparison_toplevel(grouped), cp, fp); - let encoded = crate::vk_codec::aiur_system_to_bytes(&system).unwrap(); - let decoded = - crate::vk_codec::AiurVerifyingKey::from_bytes(&encoded).unwrap(); - for member in 0..2 { - for (a, b) in - [(0, u32::MAX), (u32::MAX, 0), (65535, 65536), (u32::MAX, u32::MAX)] - { - let input = [G::from_u32(a), G::from_u32(b)]; - let (record, output) = system - .toplevel - .execute(member, input.to_vec(), &mut empty_io_buffer()) - .unwrap(); - assert_eq!(output, [G::from_bool(a < b)]); - let byte_circuit = system.toplevel.circuits.len() + 1; - let (table, _) = - Bytes2.witness_data(&record, &system.slot_arg_widths(byte_circuit)); - let mut expected = vec![G::ZERO; 65_536]; - for word in [a, a.wrapping_sub(b), b] { - expected[usize::from((word & 0xffff) as u16)] += G::ONE; - expected[usize::from((word >> 16) as u16)] += G::ONE; - } - for (row, count) in table.values.chunks_exact(table.width).zip(expected) - { - assert_eq!(row[Bytes2::U16_RANGE_CHECK_COLUMN], count); - assert!( - row[..Bytes2::U16_RANGE_CHECK_COLUMN].iter().all(|x| *x == G::ZERO) - ); - } - let (claim, proof) = - system.prove(member, &input, &mut empty_io_buffer()); - assert_eq!(claim.last(), Some(&G::from_bool(a < b))); - system.verify(&claim, &proof).unwrap(); - decoded.verify(&claim, &proof).unwrap(); - let mut false_claim = claim.clone(); - *false_claim.last_mut().unwrap() = G::from_bool(a >= b); - assert!(system.verify(&false_claim, &proof).is_err()); - } - for bad in [G::from_u64(1 << 32), -G::ONE] { - for input in [[bad, G::ZERO], [G::ZERO, bad]] { - assert!(matches!( - system.toplevel.execute( - member, - input.to_vec(), - &mut empty_io_buffer() - ), - Err(ExecError::U32OutOfRange(_)) - )); - } - } - } - } -} - -#[test] -fn u32_compare_supplied_out_of_range_limbs_fail_lookup_verification() { - // These witnesses satisfy every local polynomial, including the whole-word - // carry bit. Each missing u16 bound would admit an invalid input or a false - // comparison of valid inputs. Supply them directly to bypass execution. - let cases = [ - (1_u64 << 32, 1_u64, [0_i64, 65536, 65535, 65535, 1, 0], false), - (0, 1_u64 << 32, [0, 0, 0, 0, 0, 65536], true), - (1, 2, [1, 0, -1, 0, 2, 0], false), - (0, 0, [0, 0, 0, 65536, 0, 0], true), - // Field wraparound also satisfies the carry equation unless the - // input limbs are range-checked. This literal is Goldilocks p - 1. - (0xffff_ffff_0000_0000, 0, [-1, 0, 65535, 65535, 0, 0], true), - (0, 0xffff_ffff_0000_0000, [0, 0, 1, 0, -1, 0], false), - ]; - for grouped in [false, true] { - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(comparison_toplevel(grouped), cp, fp); - let member = 1; - let selected = if grouped { 0 } else { member }; - let layout = system.toplevel.circuits[selected].layout; - let (constraints, requests) = system.toplevel.build_constraints(selected); - for (a, b, limbs, output) in cases { - let mut traces = Vec::new(); - for (index, shape) in system.circuit_shapes().iter().enumerate() { - let height = if shape.preprocessed_height == 0 { - 4 - } else { - shape.preprocessed_height - }; - let mut rows = vec![G::ZERO; height * shape.main_width]; - if index == selected { - rows[0] = G::from_u64(a); - rows[1] = G::from_u64(b); - rows[2 + if grouped { member } else { 0 }] = G::ONE; - rows[2 + layout.selectors] = G::ONE; - for (i, limb) in limbs.into_iter().enumerate() { - rows[3 + layout.selectors + i] = if limb < 0 { - -G::ONE - } else { - G::from_u64(u64::try_from(limb).unwrap()) - }; - } - let row = &rows[..shape.main_width]; - assert!( - constraints - .zeros - .iter() - .all(|c| eval_expr(c, &values(row, &[])) == G::ZERO) - ); - assert_eq!(message(&requests[0], row, &[])[4], G::from_bool(output)); - } else if index == system.toplevel.circuits.len() + 1 { - for limb in limbs { - if let Ok(value) = u16::try_from(limb) { - rows[usize::from(value) * shape.main_width - + Bytes2::U16_RANGE_CHECK_COLUMN] += G::ONE; - } - } - } - traces.push(RowMajorMatrix::new(rows, shape.main_width)); - } - let claim = [ - function_channel(), - G::from_usize(member), - G::from_u64(a), - G::from_u64(b), - G::from_bool(output), - ]; - let witness = SystemWitness::from_stage_1(traces, &system.system); - let proof = system.prove_witness(&claim, witness); - // The row is well-formed; only the range table disagrees with it, - // so the rejection is the unanswered lookup, not a constraint. - system.verify_shard(&proof, 0).unwrap(); - assert!( - matches!( - system.verify(&claim, &proof), - Err(AiurVerificationError::Stark(VerificationError::UnbalancedBatch)) - ), - "a range table balanced a wrong comparison" - ); - } - } -} - -#[test] -fn u32_compare_advice_promotion_records_scalar_queries_once() { - for grouped in [false, true] { - let mut top = comparison_toplevel(grouped); - top.functions[0].body = Block { - ops: vec![ - Op::Call(1, vec![0, 1], 1, true), - Op::Call(1, vec![0, 1], 1, false), - Op::AssertEq(vec![2], vec![3], None), - ], - ctrl: Ctrl::Return(0, vec![3]), - }; - top.functions[0].layout.auxiliaries = 3; - top.functions[0].layout.lookups = 2; - if !grouped { - top.circuits[0].layout = top.functions[0].layout; - } - let (cp, fp) = test_parameters(); - let system = AiurSystem::build(top, cp, fp); - for input in [[G::from_u32(65535), G::from_u32(65536)], [G::ZERO, G::ZERO]] - { - let (record, output) = system - .toplevel - .execute(0, input.to_vec(), &mut empty_io_buffer()) - .unwrap(); - assert_eq!( - output, - [G::from_bool( - input[0].as_canonical_u64() < input[1].as_canonical_u64() - )] - ); - assert_eq!(record.function_queries[1].len(), 1); - let table_circuit = system.toplevel.circuits.len() + 1; - let (table, _) = - Bytes2.witness_data(&record, &system.slot_arg_widths(table_circuit)); - let count: G = table - .values - .chunks_exact(table.width) - .map(|row| row[Bytes2::U16_RANGE_CHECK_COLUMN]) - .sum(); - assert_eq!(count, G::from_u8(6)); - for row in table.values.chunks_exact(table.width) { - assert!( - row[..Bytes2::U16_RANGE_CHECK_COLUMN] - .iter() - .all(|value| *value == G::ZERO) - ); - } - let (claim, proof) = system.prove(0, &input, &mut empty_io_buffer()); - assert_eq!(claim.last(), output.first()); - system.verify(&claim, &proof).unwrap(); - } - } -} diff --git a/crates/aiur/src/table.rs b/crates/aiur/src/table.rs new file mode 100644 index 000000000..c8e85f337 --- /dev/null +++ b/crates/aiur/src/table.rs @@ -0,0 +1,104 @@ +//! Immutable table indexes. Complete Cartesian domains use direct addressing; +//! arbitrary tables retain a hash index. Row order is never assumed. +use crate::field::{FieldBackend, PrimeField}; +use rustc_hash::FxHashMap; + +#[derive(Clone, Debug)] +pub(crate) enum TableIndex { + Dense { bounds: Vec, rows: Vec, field: B }, + Sparse(FxHashMap, usize>), +} + +fn position( + bounds: &[u64], + key: &[B::Element], + field: B, +) -> Option { + if bounds.len() != key.len() { + return None; + } + let mut index = 0; + for (&bound, &word) in bounds.iter().zip(key) { + let word = field.to_u64(word); + if word >= bound { + return None; + } + // The product of bounds was checked to equal the table length. + index = index * bound as usize + word as usize; + } + Some(index) +} + +impl TableIndex { + pub(crate) fn new( + rows: &[Vec], + field: B, + ) -> Result { + let mut bounds = vec![0; rows.first().map_or(0, Vec::len)]; + for row in rows { + for (bound, word) in bounds.iter_mut().zip(row) { + *bound = (*bound).max(field.to_u64(*word).saturating_add(1)); + } + } + let size = bounds.iter().try_fold(1usize, |n, &bound| { + n.checked_mul(usize::try_from(bound).ok()?) + }); + if size == Some(rows.len()) && !rows.is_empty() { + let mut positions = vec![usize::MAX; rows.len()]; + for (row, key) in rows.iter().enumerate() { + let index = + position(&bounds, key, field).ok_or("invalid dense table key")?; + if positions[index] != usize::MAX { + return Err("duplicate map input row".into()); + } + positions[index] = row; + } + Ok(Self::Dense { bounds, rows: positions, field }) + } else { + let mut index = FxHashMap::default(); + for (i, row) in rows.iter().enumerate() { + if index.insert(row.clone(), i).is_some() { + return Err("duplicate map input row".into()); + } + } + Ok(Self::Sparse(index)) + } + } + + pub(crate) fn get(&self, key: &[B::Element]) -> Option { + match self { + Self::Dense { bounds, rows, field } => { + position(bounds, key, *field).map(|i| rows[i]) + }, + Self::Sparse(index) => index.get(key).copied(), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn preserves_row_order_domains_and_uniqueness() { + for rows in [ + vec![vec![1, 1], vec![0, 1], vec![1, 0], vec![0, 0]], + vec![vec![4], vec![0], vec![2]], + vec![vec![]], + vec![], + ] { + let index = TableIndex::new(&rows, PrimeField::new(97).unwrap()).unwrap(); + for (i, row) in rows.iter().enumerate() { + assert_eq!(index.get(row), Some(i)); + } + for key in [vec![2, 0], vec![0, 2], vec![3], vec![u64::MAX]] { + assert_eq!(index.get(&key), rows.iter().position(|row| row == &key)); + } + } + for rows in + [vec![vec![0], vec![0]], vec![vec![1], vec![1]], vec![vec![], vec![]]] + { + assert!(TableIndex::new(&rows, PrimeField::new(97).unwrap()).is_err()); + } + } +} diff --git a/crates/aiur/src/trace.rs b/crates/aiur/src/trace.rs index 9035f280c..81c57db22 100644 --- a/crates/aiur/src/trace.rs +++ b/crates/aiur/src/trace.rs @@ -1,878 +1,991 @@ -use multi_stark::{ - lookup::{LookupRowMut, LookupValues}, - p3_field::{Field, PrimeCharacteristicRing, PrimeField64}, - p3_matrix::dense::RowMajorMatrix, -}; -use rayon::{ - iter::{ - IndexedParallelIterator, IntoParallelRefMutIterator, ParallelIterator, - }, - slice::ParallelSliceMut, -}; +//! Witness population plans for the final, certified circuit layout. +//! +//! This is an untrusted witness generator. Plans are exported by Lean alongside +//! the certified circuits. Population never executes a callee or obtains fresh +//! hints. Constraints and exact integer message balance can be checked separately. +use crate::bytecode::{CheckedProgram, Instruction, Type}; +use crate::execute::Execution; +use crate::field::{FieldBackend, PrimeField}; +#[cfg(feature = "parallel")] +use rayon::prelude::*; +use rustc_hash::{FxHashMap, FxHashSet}; +use serde::{Deserialize, Serialize}; -use crate::{ - FxIndexMap, G, - bytecode::{Block, Ctrl, Function, FunctionLayout, Op, Toplevel}, - execute::{ - IOBuffer, IOKeyInfo, QueryRecord, find_unconstrained_big_uint_div_mod, - g_inverse_value, - }, - function_channel, - gadgets::{bytes1::Bytes1, bytes2::Bytes2}, - memory::Memory, - querymap::QueryMap, - u8_add_channel, u8_bit_decomposition_channel, u8_mul_channel, - u8_range_check_channel, u8_shift_left_channel, u8_shift_right_channel, - u8_sub_channel, u8_xor_channel, u8_xor_split4_channel, u8_xor_split7_channel, - u16_range_check_channel, -}; +mod plan; +#[cfg(feature = "stark")] +pub mod stark; +#[cfg(test)] +mod tests; -struct ColumnIndex { - auxiliary: usize, - lookup: usize, +#[derive(Clone, Debug, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum Polynomial { + Const(u64), + Var(usize), + Add(Box<[Polynomial; 2]>), + Sub(Box<[Polynomial; 2]>), + Mul(Box<[Polynomial; 2]>), } -struct ColumnMutSlice<'a, 'b> { - inputs: &'a mut [G], - selectors: &'a mut [G], - auxiliaries: &'a mut [G], - /// `None` builds the trace alone (see [`trace_only_lookups`]). - lookups: Option<&'a mut LookupRowMut<'b, G>>, +impl Polynomial { + fn visit(&self, f: &mut impl FnMut(usize)) { + match self { + Self::Var(v) => f(*v), + Self::Const(_) => (), + Self::Add(xs) | Self::Sub(xs) | Self::Mul(xs) => { + xs[0].visit(f); + xs[1].visit(f); + }, + } + } + fn validate( + &self, + width: usize, + field: B, + ) -> Result<(), String> { + match self { + Self::Var(v) if *v >= width => { + Err(format!("out-of-bounds witness {v}/{width}")) + }, + Self::Const(v) if !field.contains(*v) => { + Err("noncanonical plan constant".into()) + }, + Self::Add(xs) | Self::Sub(xs) | Self::Mul(xs) => { + xs[0].validate(width, field)?; + xs[1].validate(width, field) + }, + _ => Ok(()), + } + } + fn eval(&self, row: &[B::Element], field: B) -> B::Element { + match self { + Self::Const(v) => field.from_u64(*v), + Self::Var(v) => row[*v], + Self::Add(xs) => { + field.add(xs[0].eval(row, field), xs[1].eval(row, field)) + }, + Self::Sub(xs) => { + field.sub(xs[0].eval(row, field), xs[1].eval(row, field)) + }, + Self::Mul(xs) => { + field.mul(xs[0].eval(row, field), xs[1].eval(row, field)) + }, + } + } } -/// Whether witness builders skip the lookup witness and hand the prover a -/// shape-only lookup witness (`LookupValues::shape_only`), which any -/// prover path that would read the payload refuses. The CUDA backend derives -/// every lookup message from the committed trace through the constraint -/// graph and never reads the host lookup witness, so building it is wasted -/// work there. Enabled by `AIUR_TRACE_ONLY_LOOKUPS=1`; a prover that reads -/// the host lookup witness (the CPU backend, or the CUDA backend's host -/// fallback for a circuit it cannot evaluate on the device) fails instead of -/// proving. -pub fn trace_only_lookups() -> bool { - static FLAG: std::sync::OnceLock = std::sync::OnceLock::new(); - *FLAG.get_or_init(|| { - std::env::var("AIUR_TRACE_ONLY_LOOKUPS").is_ok_and(|v| v == "1") - }) +#[derive(Clone, Debug, Deserialize)] +#[serde(tag = "op", rename_all = "snake_case")] +pub enum Action { + Assign { + dest: Vec, + values: Vec, + }, + Inverse { + dest: usize, + value: Polynomial, + }, + Choose { + dest: Vec, + tests: Vec>, + }, + Failure { + dest: Vec, + differences: Vec, + }, + Call { + name: String, + args: Vec, + dest: Vec, + }, + Store { + r#type: Type, + values: Vec, + dest: usize, + }, + Load { + r#type: Type, + address: Polynomial, + dest: Vec, + }, + Hint { + #[serde(default)] + channel: String, + instruction: usize, + r#type: Type, + key_type: Type, + key: Vec, + dest: Vec, + }, } -type Degree = u8; - -fn u32_value(map: &[(G, Degree)], bytes: &[usize]) -> u64 { - assert_eq!(bytes.len(), 4, "u32 operation requires four bytes"); - bytes.iter().enumerate().fold(0, |word, (i, idx)| { - word | (map[*idx].0.as_canonical_u64() << (8 * i)) - }) +impl Action { + fn dest(&self) -> &[usize] { + match self { + Self::Assign { dest, .. } + | Self::Choose { dest, .. } + | Self::Failure { dest, .. } + | Self::Call { dest, .. } + | Self::Load { dest, .. } + | Self::Hint { dest, .. } => dest, + Self::Inverse { dest, .. } | Self::Store { dest, .. } => { + std::slice::from_ref(dest) + }, + } + } + fn expressions(&self) -> Vec<&Polynomial> { + match self { + Self::Assign { values, .. } | Self::Store { values, .. } => { + values.iter().collect() + }, + Self::Inverse { value, .. } => vec![value], + Self::Choose { tests, .. } => tests.iter().flatten().collect(), + Self::Failure { differences, .. } => differences.iter().collect(), + Self::Call { args, .. } => args.iter().collect(), + Self::Load { address, .. } => vec![address], + Self::Hint { key, .. } => key.iter().collect(), + } + } } -fn u32_sum(values: &[u64]) -> ([G; 4], G) { - let sum: u128 = values.iter().map(|x| u128::from(*x)).sum(); - let word = u32::try_from(sum & 0xFFFF_FFFF).expect("masked to 32 bits"); - let carry = u64::try_from(sum >> 32).expect("sum of u32 words fits in u64"); - (word.to_le_bytes().map(|b| G::from_u64(b.into())), G::from_u64(carry)) +#[derive(Clone, Debug, Deserialize)] +pub struct PopulationStep { + pub guard: Polynomial, + pub action: Action, +} +#[derive(Clone, Debug, Deserialize)] +pub struct ColumnWrite { + pub column: usize, + pub source: usize, + pub guard: Polynomial, +} +#[derive(Clone, Debug, Deserialize)] +pub struct FunctionPlan { + pub name: String, + pub chip: String, + pub witnesses: usize, + pub inputs: Vec, + pub output: Vec, + pub steps: Vec, + pub writes: Vec, +} +#[derive(Clone, Debug, Deserialize)] +pub struct Send { + pub channel: String, + pub args: Vec, + pub result: Vec, + pub enable: Polynomial, +} +#[derive(Clone, Debug, Deserialize)] +pub struct MemoryLookup { + pub r#type: Type, + pub address: Polynomial, + pub values: Vec, + pub enable: Polynomial, +} +#[derive(Clone, Debug, Deserialize)] +pub struct Chip { + pub name: String, + pub width: usize, + /// The last physical column is the proved row-activation selector. + pub activation: usize, + pub inputs: Vec, + pub output: Vec, + pub constraints: Vec, + pub sends: Vec, + pub memory: Vec, +} +#[derive(Clone, Debug, Deserialize)] +pub struct TraceArtifact { + pub version: u32, + pub modulus: u64, + pub functions: Vec, + pub chips: Vec, + /// Physical function groups emitted by the Lean layout pass. Clearing this + /// list selects the identical logical program with singleton circuits. + #[serde(default)] + pub groups: Vec, } -impl<'a, 'b> ColumnMutSlice<'a, 'b> { - /// Slice a circuit row into the regions of one member function: the - /// member's inputs are a prefix of the circuit's input block, its - /// selectors a sub-range of the circuit's selector block at `sel_offset`, - /// and the auxiliary block is shared by all members. - fn from_slice( - function: &Function, - circuit_layout: &FunctionLayout, - sel_offset: usize, - slice: &'a mut [G], - lookups: Option<&'a mut LookupRowMut<'b, G>>, - ) -> Self { - let (inputs, slice) = slice.split_at_mut(circuit_layout.input_size); - let (selectors, auxiliaries) = slice.split_at_mut(circuit_layout.selectors); - assert_eq!(auxiliaries.len(), circuit_layout.auxiliaries); - let inputs = &mut inputs[..function.layout.input_size]; - let selectors = - &mut selectors[sel_offset..sel_offset + function.layout.selectors]; - Self { inputs, selectors, auxiliaries, lookups } - } +#[derive(Clone, Debug, Deserialize)] +pub struct GroupWrite { + pub column: usize, + pub value: Polynomial, +} - fn push_auxiliary(&mut self, index: &mut ColumnIndex, t: G) { - self.auxiliaries[index.auxiliary] = t; - index.auxiliary += 1; - } +#[derive(Clone, Debug, Deserialize)] +pub struct GroupMember { + pub name: String, + pub columns: Vec, + pub selector: usize, + pub writes: Vec, +} - fn push_lookup( - &mut self, - index: &mut ColumnIndex, - multiplicity: G, - args: &[G], - ) { - if let Some(lookups) = self.lookups.as_deref_mut() { - lookups.push(index.lookup, multiplicity, args); - } - index.lookup += 1; - } +#[derive(Clone, Debug, Deserialize)] +pub struct GroupLookup { + pub enable: Polynomial, + pub args: Vec, } -#[derive(Clone, Copy)] -struct TraceContext<'a> { - function_index: G, - multiplicity: G, - inputs: &'a [G], - output: &'a [G], - query_record: &'a QueryRecord, +#[derive(Clone, Debug, Deserialize)] +pub struct FunctionGroup { + pub name: String, + pub width: usize, + pub activation: Polynomial, + pub constraints: Vec, + pub receive: Vec, + pub sends: Vec, + pub members: Vec, } -/// Shared by all queried rows of one member of a circuit. -struct MemberMeta<'a> { - function: &'a Function, - sel_offset: usize, - function_index: G, - queries: &'a QueryMap, +/// Height is explicit: a zero-column circuit can still provide a claim. +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub struct Matrix { + pub chip: String, + pub width: usize, + pub height: usize, + pub unpadded_height: usize, + pub values: Vec, + pub multiplicities: Vec, +} +impl Matrix { + pub fn row(&self, index: usize) -> &[F] { + &self.values[index * self.width..(index + 1) * self.width] + } +} +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub struct Trace { + pub matrices: Vec>, } -/// Query slices and function metadata stay in their original storage. -/// Only these two indices are repeated per active row. -struct RowMeta { - member: usize, - query: usize, +#[derive(Clone, Debug, Default, Serialize)] +pub struct PopulationTimings { + pub validate_seconds: f64, + pub bind_seconds: f64, + pub fill_seconds: f64, + pub padding_seconds: f64, + pub count_seconds: f64, } -/// Function witness metadata, excluding the lookup row writers shared by -/// every circuit type. The estimator may conservatively include advice rows. -pub(crate) fn witness_metadata_bytes(members: usize, rows: usize) -> usize { - members * size_of::>() + rows * size_of::() +/// A checked plan is tied to the immutable checked execution program. +pub struct TracePlan<'a, B: FieldBackend = PrimeField> { + program: &'a CheckedProgram, + artifact: TraceArtifact, + callables: FxHashMap, + members: Vec, + fills: Vec>, } -/// A position in a function circuit's concatenated query maps: the member -/// (its index within the circuit's member list) and the position within that -/// member's query map. `(members, 0)` is one past the last query. -pub type QueryPosition = (usize, usize); +fn indices(xs: &[usize], width: usize) -> Result<(), String> { + if xs.iter().any(|x| *x >= width) { + Err("plan index out of bounds".into()) + } else { + Ok(()) + } +} -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 +impl<'a, B: FieldBackend> TracePlan<'a, B> { + pub fn new( + program: &'a CheckedProgram, + mut artifact: TraceArtifact, + ) -> Result { + if artifact.version != 2 || artifact.modulus != program.field.modulus() { + return Err("trace version or field mismatch".into()); + } + if artifact.functions.len() != program.program.functions.len() { + return Err("trace function count mismatch".into()); + } + let mut chips = FxHashMap::default(); + for (i, chip) in artifact.chips.iter().enumerate() { + if chips.insert(chip.name.clone(), i).is_some() { + return Err("duplicate trace chip".into()); + } + } + let callables: FxHashMap<_, _> = (0..program.inputs.len()) + .map(|id| (program.callable_name(id).unwrap().to_owned(), id)) + .collect(); + let field = program.field; + let mut members = vec![]; + for (id, function) in artifact.functions.iter_mut().enumerate() { + if function.name != program.program.functions[id].name { + return Err("trace function order mismatch".into()); + } + let chip = + *chips.get(&function.chip).ok_or("unknown representative chip")?; + members.push(chip); + if function.inputs.len() != program.inputs[id].width() + || function.output.len() != program.outputs[id].width() + { + return Err("trace function interface width mismatch".into()); + } + indices(&function.inputs, function.witnesses)?; + indices(&function.output, function.witnesses)?; + for step in &function.steps { + step.guard.validate(function.witnesses, field)?; + indices(step.action.dest(), function.witnesses)?; + for expr in step.action.expressions() { + expr.validate(function.witnesses, field)?; + } + match &step.action { + Action::Assign { dest, values } if dest.len() != values.len() => { + return Err("assignment shape mismatch".into()); + }, + Action::Choose { dest, tests } if dest.len() != tests.len() => { + return Err("choice shape mismatch".into()); + }, + Action::Failure { dest, differences } + if dest.len() != differences.len() => + { + return Err("failure shape mismatch".into()); + }, + Action::Call { name, args, dest } => { + let id = *callables.get(name).ok_or("unknown trace callable")?; + if args.len() != program.inputs[id].width() + || dest.len() != program.outputs[id].width() + { + return Err("trace call shape mismatch".into()); + } + }, + Action::Store { r#type, values, .. } => { + if r#type.layout(&program.program.enums, &mut vec![])?.width() + != values.len() + { + return Err("trace store shape mismatch".into()); + } + }, + Action::Load { r#type, dest, .. } => { + if r#type.layout(&program.program.enums, &mut vec![])?.width() + != dest.len() + { + return Err("trace load shape mismatch".into()); + } + }, + Action::Hint { + channel, + instruction, + r#type, + key_type, + key, + dest, + } => match program.program.functions[id].code.get(*instruction) { + Some(Instruction::Hint { + channel: c, + r#type: t, + key_type: k, + key: ks, + dest: ds, + }) if c == channel + && t == r#type + && k == key_type + && ks.len() == key.len() + && ds.len() == dest.len() => {}, + _ => return Err("trace hint site mismatch".into()), + }, + _ => (), + } + } + for write in &function.writes { + indices(&[write.source], function.witnesses)?; + // The row writer owns the activation column, never a recipe. + indices(&[write.column], artifact.chips[chip].activation)?; + write.guard.validate(function.witnesses, field)?; + } + // Conservative dependency closure. Guarded assignments do not kill + // alternative branch definitions of the same logical destination. + let mut live = FxHashSet::default(); + for write in &function.writes { + live.insert(write.source); + write.guard.visit(&mut |v| { + live.insert(v); + }); + } + loop { + let before = live.len(); + for step in function.steps.iter().rev() { + if step.action.dest().iter().any(|v| live.contains(v)) { + step.guard.visit(&mut |v| { + live.insert(v); + }); + for p in step.action.expressions() { + p.visit(&mut |v| { + live.insert(v); + }); + } + } + } + if live.len() == before { + break; + } + } + function + .steps + .retain(|s| s.action.dest().iter().any(|v| live.contains(v))); + } + for chip in &artifact.chips { + if chip.activation.checked_add(1) != Some(chip.width) { + return Err("invalid activation column".into()); + } + let callable = + *callables.get(&chip.name).ok_or("unknown chip callable")?; + if chip.inputs.len() != program.inputs[callable].width() + || chip.output.len() != program.outputs[callable].width() + { + return Err("circuit interface width mismatch".into()); + } + indices(&chip.inputs, chip.width)?; + for p in chip.constraints.iter().chain(&chip.output) { + p.validate(chip.width, field)?; + } + for send in &chip.sends { + send.enable.validate(chip.width, field)?; + for p in &send.args { + p.validate(chip.width, field)?; + } + indices(&send.result, chip.width)?; + let id = + *callables.get(&send.channel).ok_or("unknown circuit channel")?; + if send.args.len() != program.inputs[id].width() + || send.result.len() != program.outputs[id].width() + { + return Err("circuit send shape mismatch".into()); + } + } + for cell in &chip.memory { + cell.enable.validate(chip.width, field)?; + cell.address.validate(chip.width, field)?; + for p in &cell.values { + p.validate(chip.width, field)?; + } + if cell.r#type.layout(&program.program.enums, &mut vec![])?.width() + != cell.values.len() + { + return Err("circuit memory shape mismatch".into()); + } + } + } + let fills = artifact + .functions .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 + .map(|f| plan::FillPlan::compile(f, &callables, program)) + .collect(); + Ok(Self { program, artifact, callables, members, fills }) } - /// 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. - pub fn function_rows( + /// Populate each original query once. Power-of-two padding remains all + /// zero, with no activation, provides, or outgoing requirements. + pub fn generate( &self, - circuit_index: usize, - query_record: &QueryRecord, - ) -> usize { - self.circuits[circuit_index] - .members - .iter() - .map(|&member| { - query_record.function_queries[member] - .iter() - .filter(|(_, res)| !res.multiplicity.is_zero()) - .count() - }) - .sum() + record: &Execution, + entry: &str, + args: &[B::Element], + pad: bool, + ) -> Result, String> { + self.generate_impl( + record, + entry, + args, + pad, + false, + &mut PopulationTimings::default(), + ) } - /// All of function circuit `circuit_index`'s rows as one trace: - /// [`Self::witness_data_range`] over every member's every query. - pub fn witness_data( + /// Slow logical recipe interpreter for differential checks and benchmarks. + pub fn generate_reference( &self, - circuit_index: usize, - query_record: &QueryRecord, - io_buffer: &IOBuffer, - slot_arg_widths: &[usize], - ) -> (RowMajorMatrix, LookupValues) { - let members = self.circuits[circuit_index].members.len(); - let rows = self.function_rows(circuit_index, query_record); - self.witness_data_range( - circuit_index, - query_record, - io_buffer, - slot_arg_widths, - (0, 0), - (members, 0), - rows, + record: &Execution, + entry: &str, + args: &[B::Element], + pad: bool, + ) -> Result, String> { + self.generate_impl( + record, + entry, + args, + pad, + true, + &mut PopulationTimings::default(), ) } - /// The rows among the queries from `start` to `end` (positions in the - /// concatenated query maps of circuit `circuit_index`'s members) as a - /// trace: the queries in that span with a nonzero multiplicity, of which - /// there must be exactly `row_count`. An empty span yields an EMPTY trace - /// (not a padded height-1 one): the prover deactivates the circuit, so it - /// is neither committed nor opened. - #[tracing::instrument(level = "info", skip_all, name = "aiur/cpu_witness", fields(circuit = circuit_index, rows = row_count))] - pub fn witness_data_range( + pub fn generate_profiled( &self, - circuit_index: usize, - query_record: &QueryRecord, - io_buffer: &IOBuffer, - slot_arg_widths: &[usize], - start: QueryPosition, - end: QueryPosition, - row_count: usize, - ) -> (RowMajorMatrix, LookupValues) { - let circuit = &self.circuits[circuit_index]; - let layout = &circuit.layout; - let width = layout.width(); - // Concatenate the members' queried rows in the span, in member order. - let mut members_meta = Vec::with_capacity(circuit.members.len()); - let mut sel_offset = 0; - for &member in &circuit.members { - let function = &self.functions[member]; - members_meta.push(MemberMeta { - function, - sel_offset, - function_index: G::from_usize(member), - queries: &query_record.function_queries[member], - }); - sel_offset += function.layout.selectors; - } - // A member's share of the span: the positions of its query map the - // span covers, empty for a member outside it. - let span = |m: usize, queries: &QueryMap| -> std::ops::Range { - if !(start.0..=end.0).contains(&m) { - return 0..0; - } - let lo = if m == start.0 { start.1 } else { 0 }; - let hi = if m == end.0 { end.1 } else { queries.len() }; - lo..hi - }; - // Count before allocating: no geometric growth or metadata for advice. - fn active_queries( - queries: &QueryMap, - span: std::ops::Range, - ) -> impl Iterator + '_ { - span.filter(move |&i| !queries.mult_at(i).is_zero()) - } - let height_no_padding: usize = members_meta + record: &Execution, + entry: &str, + args: &[B::Element], + pad: bool, + reference: bool, + ) -> Result<(Trace, PopulationTimings), String> { + let mut timings = PopulationTimings::default(); + let trace = + self.generate_impl(record, entry, args, pad, reference, &mut timings)?; + Ok((trace, timings)) + } + + fn generate_impl( + &self, + record: &Execution, + entry: &str, + args: &[B::Element], + pad: bool, + reference: bool, + timings: &mut PopulationTimings, + ) -> Result, String> { + let start = std::time::Instant::now(); + self.validate_record(record)?; + self.root(record, entry, args)?; + timings.validate_seconds = start.elapsed().as_secs_f64(); + let start = std::time::Instant::now(); + let mut matrices: Vec<_> = self + .artifact + .chips .iter() - .enumerate() - .map(|(m, meta)| { - active_queries(meta.queries, span(m, meta.queries)).count() + .map(|chip| Matrix { + chip: chip.name.clone(), + width: chip.width, + height: 0, + unpadded_height: 0, + values: vec![], + multiplicities: vec![], }) - .sum(); - assert_eq!( - height_no_padding, row_count, - "query span holds a different row count" - ); - let mut rows_meta = Vec::with_capacity(height_no_padding); - for (member, meta) in members_meta.iter().enumerate() { - rows_meta.extend( - active_queries(meta.queries, span(member, meta.queries)) - .map(|query| RowMeta { member, query }), - ); + .collect(); + for (function, &chip) in self.members.iter().enumerate() { + matrices[chip].unpadded_height = matrices[chip] + .unpadded_height + .checked_add(record.queries.tables[function].len()) + .ok_or("trace height overflow")?; + } + for matrix in &mut matrices { + matrix.height = if pad && matrix.unpadded_height > 0 { + matrix + .unpadded_height + .checked_next_power_of_two() + .ok_or("padded height overflow")? + } else { + matrix.unpadded_height + }; + let size = + matrix.height.checked_mul(matrix.width).ok_or("trace size overflow")?; + matrix.values.try_reserve_exact(size).map_err(|e| e.to_string())?; + matrix.values.resize(size, self.program.field.zero()); + matrix.multiplicities.resize(matrix.height, 0); } - // An unqueried circuit yields an EMPTY trace (not a padded height-1 one): - // the prover deactivates it, so it is neither committed nor opened. - let height = if height_no_padding == 0 { - 0 + // Keep reference population independent of the retained interning index. + // Production population resolves stores from the immutable record itself. + let memory: Option> = if reference { + let memory: FxHashMap<_, _> = + record.memory.iter().map(|m| (m.cell.value, m.address)).collect(); + if memory.len() != record.memory.len() { + return Err("duplicate interned ROM payload".into()); + } + Some(memory) } else { - height_no_padding.next_power_of_two() - }; - // A zeroed allocation: pages materialize when rows are written, so the - // padding rows cost nothing and no fill pass touches the whole matrix. - let mut rows = { - let _g = - tracing::info_span!("aiur/witness_zero", height, width).entered(); - G::zero_vec(height * width) + None }; - let rows_no_padding = &mut rows[0..height_no_padding * width]; - let populate = - |i: usize, row: &mut [G], lookups: Option<&mut LookupRowMut<'_, G>>| { - let row_meta = &rows_meta[i]; - let meta = &members_meta[row_meta.member]; - let (inputs, result) = - meta.queries.get_index(row_meta.query).expect("recorded query"); - let index = &mut ColumnIndex { - auxiliary: 0, - // we skip the first lookup, which is reserved for return - lookup: 1, - }; - let slice = &mut ColumnMutSlice::from_slice( - meta.function, - layout, - meta.sel_offset, - row, - lookups, - ); - let context = TraceContext { - function_index: meta.function_index, - inputs, - multiplicity: result.multiplicity, - output: result.output, - query_record, - }; - meta.function.populate_row(index, slice, context, io_buffer); - }; - if trace_only_lookups() { - rows_no_padding - .par_chunks_mut(width) - .enumerate() - .for_each(|(i, row)| populate(i, row, None)); - let trace = RowMajorMatrix::new(rows, width); - return (trace, LookupValues::shape_only(height, slot_arg_widths)); + let mut offsets = vec![0usize; matrices.len()]; + let mut scratch = vec![]; + let mut buffer = vec![]; + let mut hint_output = vec![]; + let field = self.program.field; + timings.bind_seconds = start.elapsed().as_secs_f64(); + let start = std::time::Instant::now(); + for (function, plan) in self.artifact.functions.iter().enumerate() { + let table = &record.queries.tables[function]; + let matrix = &mut matrices[self.members[function]]; + scratch.resize(plan.witnesses, field.zero()); + for query in 0..table.len() { + let offset = offsets[self.members[function]]; + matrix.values[offset * matrix.width + + self.artifact.chips[self.members[function]].activation] = + field.one(); + matrix.multiplicities[offset] = table.output(query).multiplicity; + if !reference { + let row = &mut matrix.values + [offset * matrix.width..(offset + 1) * matrix.width]; + self.fills[function] + .fill( + record, + (table.input(query), table.output(query)), + &mut scratch, + &mut buffer, + row, + ) + .map_err(|e| format!("{} query {query}: {e}", plan.name))?; + offsets[self.members[function]] += 1; + continue; + } + scratch.fill(field.zero()); + let input = table.input(query); + let output = table.output(query); + for (&dest, &v) in plan.inputs.iter().zip(input) { + scratch[dest] = v; + } + for (&dest, &v) in plan.output.iter().zip(output.output) { + scratch[dest] = v; + } + for (step_id, step) in plan.steps.iter().enumerate() { + if step.guard.eval(&scratch, field) != field.one() { + continue; + } + let mut fill = || -> Result<(), String> { + match &step.action { + Action::Assign { dest, values } => { + buffer.clear(); + buffer.extend(values.iter().map(|p| p.eval(&scratch, field))); + for (&d, &v) in dest.iter().zip(&buffer) { + scratch[d] = v; + } + }, + Action::Inverse { dest, value } => { + scratch[*dest] = field + .inverse(value.eval(&scratch, field)) + .ok_or("active zero denominator")?; + }, + Action::Choose { dest, tests } => { + let selected = tests + .iter() + .position(|xs| { + xs.iter().all(|p| p.eval(&scratch, field) == field.zero()) + }) + .ok_or("no matching trace arm")?; + for (i, &d) in dest.iter().enumerate() { + scratch[d] = field.from_u64(u64::from(i == selected)); + } + }, + Action::Failure { dest, differences } => { + let (selected, v) = differences + .iter() + .enumerate() + .find_map(|(i, p)| { + let v = p.eval(&scratch, field); + (v != field.zero()).then_some((i, v)) + }) + .ok_or("rejected pattern actually matches")?; + for &d in dest { + scratch[d] = field.zero(); + } + scratch[dest[selected]] = + field.inverse(v).ok_or("zero failure witness")?; + }, + Action::Call { name, args, dest } => { + buffer.clear(); + buffer.extend(args.iter().map(|p| p.eval(&scratch, field))); + let table = &record.queries.tables[self.callables[name]]; + // Independent reference population always uses + // the original table, never a host override. + let values = if let Some(map) = &table.static_map { + map.binding.output(map.binding.row(&buffer)?) + } else { + if let Some(id) = table.lookup(&buffer).1 { + let answer = table.output(id); + if answer.multiplicity == 0 { + return Err("pending recorded callee".into()); + } + answer.output + } else if dest.is_empty() + && record.is_deferred(self.callables[name], &buffer) + { + &[] + } else { + return Err("missing recorded callee".into()); + } + }; + for (&d, &v) in dest.iter().zip(values) { + scratch[d] = v; + } + }, + Action::Store { values, dest, .. } => { + buffer.clear(); + buffer.extend(values.iter().map(|p| p.eval(&scratch, field))); + let address = *memory + .as_ref() + .unwrap() + .get(buffer.as_slice()) + .ok_or("missing recorded store")?; + scratch[*dest] = field.from_u64( + u64::try_from(address).map_err(|_| "ROM address overflow")?, + ); + }, + Action::Load { address, dest, .. } => { + let address = + usize::try_from(field.to_u64(address.eval(&scratch, field))) + .map_err(|_| "ROM address overflow")?; + let cell = &record + .memory + .get_by_width(dest.len(), address) + .ok_or("missing recorded load")? + .cell; + if cell.value.len() != dest.len() { + return Err("ROM load shape mismatch".into()); + } + for (&d, &v) in dest.iter().zip(cell.value) { + scratch[d] = v; + } + }, + Action::Hint { instruction, key, dest, .. } => { + buffer.clear(); + buffer.extend(key.iter().map(|p| p.eval(&scratch, field))); + hint_output.resize(dest.len(), field.zero()); + record.hints.sites[function][*instruction] + .as_ref() + .ok_or("missing hint site")? + .evaluate(&buffer, &mut hint_output, field)?; + for (&d, &v) in dest.iter().zip(&hint_output) { + scratch[d] = v; + } + }, + } + Ok(()) + }; + fill().map_err(|e| { + format!( + "{} query {query}, population step {step_id}: {e}", + plan.name + ) + })?; + } + let offset = offsets[self.members[function]]; + let row = &mut matrix.values + [offset * matrix.width..(offset + 1) * matrix.width]; + for write in &plan.writes { + if write.guard.eval(&scratch, field) == field.one() { + row[write.column] = scratch[write.source]; + } + } + offsets[self.members[function]] += 1; + } } - // Builder rows start zeroed (`Lookup::empty()` in every slot), so padding - // rows need no writes at all. - let mut builder = LookupValues::builder(height, slot_arg_widths); - let mut row_writers = builder.rows_mut(); - rows_no_padding - .par_chunks_mut(width) - .zip(row_writers[..height_no_padding].par_iter_mut()) - .enumerate() - .for_each(|(i, (row, lookups))| populate(i, row, Some(lookups))); - drop(row_writers); - let trace = RowMajorMatrix::new(rows, width); - (trace, builder.finish()) - } -} - -impl Function { - pub fn width(&self) -> usize { - self.layout.input_size + self.layout.auxiliaries + self.layout.selectors + timings.fill_seconds = start.elapsed().as_secs_f64(); + // Allocation already zeroed the inactive padding rows. Their lookup + // multiplicities are zero, so execution counts require no repair. + Ok(Trace { matrices }) } - fn populate_row( - &self, - index: &mut ColumnIndex, - slice: &mut ColumnMutSlice<'_, '_>, - context: TraceContext<'_>, - io_buffer: &IOBuffer, - ) { - debug_assert_eq!( - self.layout.input_size, - context.inputs.len(), - "Argument mismatch" - ); - // Variable to value map - let map = &mut context.inputs.iter().map(|arg| (*arg, 1)).collect(); - // One column per input - context - .inputs - .iter() + fn validate_record(&self, record: &Execution) -> Result<(), String> { + if !std::sync::Arc::ptr_eq(&record.hints.program, &self.program.program) { + return Err("hint providers belong to another program".into()); + } + if record.queries.tables.len() != self.program.inputs.len() { + return Err("query record callable count mismatch".into()); + } + let validate_table = |(i, table): (usize, &crate::query::QueryTable)| { + if table.widths() + != (self.program.inputs[i].width(), self.program.outputs[i].width()) + { + return Err("query record width mismatch".into()); + } + if i >= self.program.program.functions.len() { + let map = + table.static_map.as_ref().ok_or("missing static map record")?; + if !std::sync::Arc::ptr_eq(&map.binding.program, &self.program.program) + || map.binding.id != i - self.program.program.functions.len() + { + return Err( + "static map record belongs to another program/map".into(), + ); + } + if map.counts.len() != map.binding.rows() { + return Err("malformed static map counts".into()); + } + // Inputs/results are borrowed from already validated tables. + return Ok(()); + } + if table.static_map.is_some() { + return Err("function record contains a static map".into()); + } + for row in 0..table.len() { + let output = table.output(row); + if output.multiplicity == 0 { + return Err("incomplete query record".into()); + } + self.program.inputs[i] + .validate(table.input(row), self.program.field)?; + self.program.outputs[i].validate(output.output, self.program.field)?; + } + Ok::<_, String>(()) + }; + #[cfg(feature = "parallel")] + record + .queries + .tables + .par_iter() .enumerate() - .for_each(|(i, arg)| slice.inputs[i] = *arg); - // Push the multiplicity - slice.push_auxiliary(index, context.multiplicity); - let _ = self.body.populate_row(map, index, slice, context, io_buffer); - } -} - -/// `Some(values)` means the block ended with `Yield` (values for the merge). -/// `None` means the block ended with `Return` (function exited). -type PopulateResult = Option>; - -impl Block { - fn populate_row( - &self, - map: &mut Vec<(G, Degree)>, - index: &mut ColumnIndex, - slice: &mut ColumnMutSlice<'_, '_>, - context: TraceContext<'_>, - io_buffer: &IOBuffer, - ) -> PopulateResult { - self - .ops + .try_for_each(validate_table)?; + #[cfg(not(feature = "parallel"))] + record.queries.tables.iter().enumerate().try_for_each(validate_table)?; + if record + .memory .iter() - .for_each(|op| op.populate_row(map, index, slice, context, io_buffer)); - self.ctrl.populate_row(map, index, slice, context, io_buffer) + .any(|m| m.address as u128 >= self.program.field.modulus() as u128) + { + return Err("ROM exceeds field capacity".into()); + } + let validate_memory = |m: crate::memory::MemoryEntryRef<'_, B::Element>| { + self + .program + .memory_layouts + .get(m.cell.r#type) + .ok_or("unknown recorded ROM type")? + .validate(m.cell.value, self.program.field) + }; + #[cfg(feature = "parallel")] + record.memory.par_iter().try_for_each(validate_memory)?; + #[cfg(not(feature = "parallel"))] + record.memory.iter().try_for_each(validate_memory)?; + Ok(()) } -} - -/// Dispatch a match: look up the value in the cases map, or fall through to the -/// default (pushing inverse witnesses for each case to prove inequality). -fn dispatch_branch<'a>( - val: G, - cases: &'a FxIndexMap, - def: &'a Option>, - index: &mut ColumnIndex, - slice: &mut ColumnMutSlice<'_, '_>, -) -> &'a Block { - cases - .get(&val) - .or_else(|| { - for &case in cases.keys() { - let witness = (val - case).inverse(); - slice.push_auxiliary(index, witness); - } - def.as_deref() - }) - .expect("No match") -} -impl Ctrl { - fn populate_row( + fn root( &self, - map: &mut Vec<(G, Degree)>, - index: &mut ColumnIndex, - slice: &mut ColumnMutSlice<'_, '_>, - context: TraceContext<'_>, - io_buffer: &IOBuffer, - ) -> PopulateResult { - match self { - Ctrl::Return(sel, _) => { - slice.selectors[*sel] = G::ONE; - let args = function_lookup_args( - context.function_index, - context.inputs, - context.output, - ); - // The first lookup slot is reserved for the function return, which - // pulls the query claim with the query's multiplicity. - if let Some(lookups) = slice.lookups.as_deref_mut() { - lookups.pull(0, context.multiplicity, &args); - } - None - }, - Ctrl::Yield(sel, vals) => { - slice.selectors[*sel] = G::ONE; - Some(vals.iter().map(|&v| map[v].0).collect()) - }, - Ctrl::Match(var, cases, def) => { - let branch = dispatch_branch(map[*var].0, cases, def, index, slice); - branch.populate_row(map, index, slice, context, io_buffer) - }, - Ctrl::MatchContinue( - var, - cases, - def, - _output_size, - shared_aux, - shared_lookups, - continuation, - ) => { - let map_len = map.len(); - let init_aux = index.auxiliary; - let init_lookup = index.lookup; - - let branch = dispatch_branch(map[*var].0, cases, def, index, slice); - let result = branch.populate_row(map, index, slice, context, io_buffer); - match result { - Some(yielded) => { - // Advance past the shared branch region. The taken branch may - // use fewer auxiliaries/lookups than the max across all branches. - index.auxiliary = init_aux + shared_aux; - index.lookup = init_lookup + shared_lookups; + record: &Execution, + entry: &str, + args: &[B::Element], + ) -> Result, String> { + let id = self.program.entry(entry)?.function; + self.program.inputs[id].validate(args, self.program.field)?; + let query = + record.queries.tables[id].lookup(args).1.ok_or("missing entry query")?; + if record.queries.tables[id].output(query).output != record.output { + return Err("root output mismatch".into()); + } + let chip = self.members[id]; + Ok(Claim { + channel: self.callables[&self.artifact.chips[chip].name], + args: args.to_vec(), + output: record.output.clone(), + }) + } - map.truncate(map_len); - for &val in &yielded { - slice.push_auxiliary(index, val); - map.push((val, 1)); - } - continuation.populate_row(map, index, slice, context, io_buffer) - }, - None => None, - } - }, + fn claim(&self, chip: &Chip, row: &[B::Element]) -> Claim { + Claim { + channel: self.callables[&chip.name], + args: chip.inputs.iter().map(|&i| row[i]).collect(), + output: chip + .output + .iter() + .map(|p| p.eval(row, self.program.field)) + .collect(), } } -} + fn send_claim(&self, send: &Send, row: &[B::Element]) -> Claim { + Claim { + channel: self.callables[&send.channel], + args: send.args.iter().map(|p| p.eval(row, self.program.field)).collect(), + output: send.result.iter().map(|&i| row[i]).collect(), + } + } + fn static_claim(&self, claim: &Claim) -> Result { + let Some(map) = self + .program + .program + .maps + .get(claim.channel.wrapping_sub(self.program.program.functions.len())) + else { + return Ok(false); + }; + let index = self.program.map_indexes[map.input] + .as_ref() + .ok_or("missing static map index")?; + let row = index.get(&claim.args).ok_or("unavailable static map claim")?; + if self.program.tables[map.output][row] != claim.output { + return Err("wrong static map result".into()); + } + Ok(true) + } -impl Op { - fn populate_row( + /// Independent diagnostic validation of every physical row, typed ROM + /// lookup, static map membership and exact integer message balance. + pub fn check( &self, - map: &mut Vec<(G, Degree)>, - index: &mut ColumnIndex, - slice: &mut ColumnMutSlice<'_, '_>, - context: TraceContext<'_>, - io_buffer: &IOBuffer, - ) { - match self { - Op::Const(f) => map.push((*f, 0)), - Op::Add(a, b) => { - let (a, a_deg) = map[*a]; - let (b, b_deg) = map[*b]; - let deg = a_deg.max(b_deg); - map.push((a + b, deg)); - }, - Op::Sub(a, b) => { - let (a, a_deg) = map[*a]; - let (b, b_deg) = map[*b]; - let deg = a_deg.max(b_deg); - map.push((a - b, deg)); - }, - Op::Mul(a, b) => { - let (a, a_deg) = map[*a]; - let (b, b_deg) = map[*b]; - let deg = a_deg + b_deg; - let f = a * b; - if deg < 2 { - map.push((f, deg)); - } else { - map.push((f, 1)); - slice.push_auxiliary(index, f); - } - }, - Op::EqZero(a) => { - let (a, deg) = map[*a]; - let is_zero = a == G::ZERO; - let is_zero_g = G::from_bool(is_zero); - if deg == 0 { - map.push((is_zero_g, 0)); - } else { - let (d, x) = - if is_zero { (G::ZERO, G::ONE) } else { (a.inverse(), G::ZERO) }; - slice.push_auxiliary(index, d); - slice.push_auxiliary(index, x); - map.push((is_zero_g, 1)); - } - }, - Op::Call(function_index, inputs, _, op_unconstrained) => { - let inputs = inputs.iter().map(|a| map[*a].0).collect::>(); - let queries = &context.query_record.function_queries[*function_index]; - let result = queries.get(&inputs).expect("Cannot find query result"); - for f in result.output.iter() { - map.push((*f, 1)); - slice.push_auxiliary(index, *f); - } - if !op_unconstrained { - let args = function_lookup_args( - G::from_usize(*function_index), - &inputs, - result.output, - ); - slice.push_lookup(index, G::ONE, &args); - } - }, - Op::Store(values) => { - let size = values.len(); - let memory_queries = context - .query_record - .memory_queries - .get(&size) - .expect("Invalid memory size"); - let values = values.iter().map(|a| map[*a].0).collect::>(); - let ptr = G::from_usize( - context.query_record.pointer_base - + memory_queries.get_index_of(&values).expect("Unbound pointer"), - ); - map.push((ptr, 1)); - slice.push_auxiliary(index, ptr); - let args = Memory::lookup_args(G::from_usize(size), ptr, &values); - slice.push_lookup(index, G::ONE, &args); - }, - Op::Load(size, ptr) => { - let memory_queries = context - .query_record - .memory_queries - .get(size) - .expect("Invalid memory size"); - let (ptr, _) = map[*ptr]; - let ptr_u64 = ptr.as_canonical_u64(); - let table_index = usize::try_from(ptr_u64) - .expect("Pointer is too big") - .checked_sub(context.query_record.pointer_base) - .expect("Pointer below the record's base"); - let (values, _) = - memory_queries.get_index(table_index).expect("Unbound pointer"); - for f in values.iter() { - map.push((*f, 1)); - slice.push_auxiliary(index, *f); - } - let args = Memory::lookup_args(G::from_usize(*size), ptr, values); - slice.push_lookup(index, G::ONE, &args); - }, - Op::IOGetInfo(channel, key) => { - let channel = map[*channel].0; - let key = key.iter().map(|a| map[*a].0).collect::>(); - let IOKeyInfo { idx, len } = - io_buffer.get_info(channel, &key).expect("Invalid IO key"); - for f in [G::from_usize(*idx), G::from_usize(*len)] { - map.push((f, 1)); - slice.push_auxiliary(index, f); - } - }, - Op::IORead(channel, idx, len) => { - let channel = map[*channel].0; - let idx = map[*idx] - .0 - .as_canonical_u64() - .try_into() - .expect("Index is too big for an usize"); - let data = io_buffer - .read(channel, idx, *len) - .expect("IO read out of bounds") - .to_vec(); - for f in data { - map.push((f, 1)); - slice.push_auxiliary(index, f); - } - }, - Op::U8BitDecomposition(byte) => { - let (byte, _) = map[*byte]; - let bits = Bytes1::bit_decompose(&byte); - for &b in &bits { - map.push((b, 1)); - slice.push_auxiliary(index, b); - } - let mut lookup_args = vec![u8_bit_decomposition_channel(), byte]; - lookup_args.extend(bits); - slice.push_lookup(index, G::ONE, &lookup_args); - }, - Op::U8ShiftLeft(byte) => { - let (byte, _) = map[*byte]; - let byte_shifted = Bytes1::shift_left(&byte); - map.push((byte_shifted, 1)); - slice.push_auxiliary(index, byte_shifted); - slice.push_lookup( - index, - G::ONE, - &[u8_shift_left_channel(), byte, byte_shifted], - ); - }, - Op::U8ShiftRight(byte) => { - let (byte, _) = map[*byte]; - let byte_shifted = Bytes1::shift_right(&byte); - map.push((byte_shifted, 1)); - slice.push_auxiliary(index, byte_shifted); - slice.push_lookup( - index, - G::ONE, - &[u8_shift_right_channel(), byte, byte_shifted], - ); - }, - Op::U8Xor(i, j) => { - let (i, _) = map[*i]; - let (j, _) = map[*j]; - let xor = Bytes2::xor(&i, &j); - map.push((xor, 1)); - slice.push_auxiliary(index, xor); - slice.push_lookup(index, G::ONE, &[u8_xor_channel(), i, j, xor]); - }, - Op::U8Add(i, j) => { - let (i, _) = map[*i]; - let (j, _) = map[*j]; - // Only the low byte `r` is witnessed (one auxiliary + the add lookup). - // The carry `o` is a derived value, pushed to the map for downstream - // ops but not materialized as a column. - let (r, o) = Bytes2::add(&i, &j); - map.push((r, 1)); - map.push((o, 1)); - slice.push_auxiliary(index, r); - slice.push_lookup(index, G::ONE, &[u8_add_channel(), i, j, r]); - }, - Op::UnconstrainedU32Add(a, b) => { - let (bytes, carry) = u32_sum(&[u32_value(map, a), u32_value(map, b)]); - for byte in bytes { - map.push((byte, 1)); - slice.push_auxiliary(index, byte); - } - map.push((carry, 1)); - }, - Op::UnconstrainedU32Add3(a, b, c) => { - let (bytes, carry) = - u32_sum(&[u32_value(map, a), u32_value(map, b), u32_value(map, c)]); - for byte in bytes { - map.push((byte, 1)); - slice.push_auxiliary(index, byte); + record: &Execution, + trace: &Trace, + entry: &str, + args: &[B::Element], + ) -> Result<(), String> { + self.validate_record(record)?; + if trace.matrices.len() != self.artifact.chips.len() { + return Err("trace matrix count mismatch".into()); + } + let field = self.program.field; + let mut ledger: FxHashMap, i128> = FxHashMap::default(); + ledger.insert(self.root(record, entry, args)?, -1); + for (chip, matrix) in self.artifact.chips.iter().zip(&trace.matrices) { + if matrix.chip != chip.name + || matrix.width != chip.width + || matrix.unpadded_height > matrix.height + || matrix.height.checked_mul(matrix.width) != Some(matrix.values.len()) + || matrix.multiplicities.len() != matrix.height + || matrix.values.iter().any(|v| !field.valid(*v)) + { + return Err("malformed trace matrix".into()); + } + for row_id in 0..matrix.height { + let row = matrix.row(row_id); + if (row[chip.activation] != field.zero() + && row[chip.activation] != field.one()) + || (row[chip.activation] == field.zero() + && matrix.multiplicities[row_id] != 0) + { + return Err("invalid inactive row multiplicity or activation".into()); } - map.push((carry, 1)); - }, - Op::U32ToField(bytes) => { - let word = u32_value(map, bytes); - let degree = bytes.iter().map(|idx| map[*idx].1).max().unwrap_or(0); - map.push((G::from_u64(word), degree)); - }, - Op::U8Mul(i, j) => { - let (i, _) = map[*i]; - let (j, _) = map[*j]; - let (lo, hi) = Bytes2::mul(&i, &j); - map.push((lo, 1)); - map.push((hi, 1)); - slice.push_auxiliary(index, lo); - slice.push_auxiliary(index, hi); - slice.push_lookup(index, G::ONE, &[u8_mul_channel(), i, j, lo, hi]); - }, - Op::U8Sub(i, j) => { - let (i, _) = map[*i]; - let (j, _) = map[*j]; - // Only the low byte `r` is witnessed (one auxiliary + the sub lookup). - // The borrow `u` is derived, pushed to the map for downstream ops but - // not materialized as a column. - let (r, u) = Bytes2::sub(&i, &j); - map.push((r, 1)); - map.push((u, 1)); - slice.push_auxiliary(index, r); - slice.push_lookup(index, G::ONE, &[u8_sub_channel(), i, j, r]); - }, - Op::U8And(i, j) => { - let (i, _) = map[*i]; - let (j, _) = map[*j]; - let and = Bytes2::and(&i, &j); - map.push((and, 1)); - slice.push_auxiliary(index, and); - slice.push_lookup( - index, - G::ONE, - &[u8_xor_channel(), i, j, i + j - G::TWO * and], - ); - }, - Op::U8Or(i, j) => { - let (i, _) = map[*i]; - let (j, _) = map[*j]; - let or = Bytes2::or(&i, &j); - map.push((or, 1)); - slice.push_auxiliary(index, or); - slice.push_lookup( - index, - G::ONE, - &[u8_xor_channel(), i, j, G::TWO * or - i - j], - ); - }, - Op::U8LessThan(i, j) => { - let (i, _) = map[*i]; - let (j, _) = map[*j]; - let less_than = Bytes2::less_than(&i, &j); - map.push((less_than, 1)); - slice.push_auxiliary(index, less_than); - slice.push_lookup( - index, - G::ONE, - &[u8_sub_channel(), i, j, i - j + G::from_u16(256) * less_than], - ); - }, - Op::U8XorSplit7(i, j) => { - let (i, _) = map[*i]; - let (j, _) = map[*j]; - let (hi, lo) = Bytes2::xor_split7(&i, &j); - map.extend([(hi, 1), (lo, 1)]); - slice.push_auxiliary(index, hi); - slice.push_auxiliary(index, lo); - slice.push_lookup( - index, - G::ONE, - &[u8_xor_split7_channel(), i, j, hi, lo], - ); - }, - Op::U8XorSplit4(i, j) => { - let (i, _) = map[*i]; - let (j, _) = map[*j]; - let (hi, lo) = Bytes2::xor_split4(&i, &j); - map.extend([(hi, 1), (lo, 1)]); - slice.push_auxiliary(index, hi); - slice.push_auxiliary(index, lo); - slice.push_lookup( - index, - G::ONE, - &[u8_xor_split4_channel(), i, j, hi, lo], - ); - }, - Op::U32LessThan(x_idx, y_idx) => { - let (a, _) = map[*x_idx]; - let (b, _) = map[*y_idx]; - let a_u32 = u32::try_from(a.as_canonical_u64()).unwrap(); - let b_u32 = u32::try_from(b.as_canonical_u64()).unwrap(); - let c_u32 = a_u32.wrapping_sub(b_u32); - // Six auxiliaries and scalar queries, ordered as a, c, b, low first. - // Execution already recorded these multiplicities. - for word in [a_u32, c_u32, b_u32] { - for shift in [0, 16] { - let limb = G::from_u16(((word >> shift) & 0xffff) as u16); - slice.push_auxiliary(index, limb); - slice.push_lookup( - index, - G::ONE, - &[u16_range_check_channel(), limb], - ); + for (i, p) in chip.constraints.iter().enumerate() { + if p.eval(row, field) != field.zero() { + return Err(format!( + "{} row {row_id}: constraint {i} is nonzero", + chip.name + )); } } - map.push((G::from_bool(a_u32 < b_u32), 1)); - }, - Op::U8RangeCheck(i, j) => { - // No `map.push`: the `u8` outputs alias the inputs. Just require the - // `(i, j)` pair from the byte-chip range-check table. - slice.push_lookup( - index, - G::ONE, - &[u8_range_check_channel(), map[*i].0, map[*j].0], - ); - }, - Op::UnconstrainedBigUintDivMod(a, b) => { - // Mirrors the execute arm and the two auxiliary columns the - // constraints allocate: recompute `(q, r)` and resolve the head - // pointers execution recorded in memory[10]. Skipping the two map - // pushes would shift every later `ValIdx` (and witness column) in - // the block. - let (q_ptr, r_ptr) = find_unconstrained_big_uint_div_mod( - map[*a].0, - map[*b].0, - &context.query_record.memory_queries, - context.query_record.pointer_base, - ) - .expect("BigUint div-mod result not recorded"); - for f in [q_ptr, r_ptr] { - map.push((f, 1)); - slice.push_auxiliary(index, f); + for (i, cell) in chip.memory.iter().enumerate() { + if cell.enable.eval(row, field) != field.one() { + continue; + } + let address = + usize::try_from(field.to_u64(cell.address.eval(row, field))) + .map_err(|_| "ROM address overflow")?; + let value = &record + .memory + .get_by_width(cell.values.len(), address) + .ok_or("missing circuit ROM cell")? + .cell; + if value.value.len() != cell.values.len() + || value + .value + .iter() + .zip(&cell.values) + .any(|(&v, p)| v != p.eval(row, field)) + { + return Err(format!( + "{} row {row_id}: memory lookup {i} mismatch", + chip.name + )); + } } - }, - Op::UnconstrainedGToBytes(a) => { - // Recompute the deterministic hint (canonical LE bytes) and fill - // the 8 auxiliary columns the constraints allocate. - let bytes = map[*a].0.as_canonical_u64().to_le_bytes(); - for b in bytes { - let f = G::from_u8(b); - map.push((f, 1)); - slice.push_auxiliary(index, f); + let balance = ledger.entry(self.claim(chip, row)).or_default(); + *balance = balance + .checked_add(i128::from(matrix.multiplicities[row_id])) + .ok_or("ledger overflow")?; + for send in &chip.sends { + if send.enable.eval(row, field) == field.one() { + let claim = self.send_claim(send, row); + if !self.static_claim(&claim)? { + let balance = ledger.entry(claim).or_default(); + *balance = balance.checked_sub(1).ok_or("ledger overflow")?; + } + } } - }, - Op::UnconstrainedGInverse(a) => { - let f = g_inverse_value(map[*a].0); - map.push((f, 1)); - slice.push_auxiliary(index, f); - }, - Op::AssertEq(..) - | Op::IOSetInfo(..) - | Op::IOWrite(..) - | Op::Debug(..) => {}, + } + } + if ledger.values().any(|&count| count != 0) { + return Err("unbalanced trace messages".into()); } + Ok(()) } } -fn function_lookup_args( - function_index: G, - inputs: &[G], - output: &[G], -) -> Vec { - let mut args = vec![function_channel(), function_index]; - args.extend(inputs); - args.extend(output); - args +#[derive(Debug, PartialEq, Eq, Hash)] +struct Claim { + channel: usize, + args: Vec, + output: Vec, } diff --git a/crates/aiur/src/trace/plan.rs b/crates/aiur/src/trace/plan.rs new file mode 100644 index 000000000..92002e1ac --- /dev/null +++ b/crates/aiur/src/trace/plan.rs @@ -0,0 +1,561 @@ +//! Compile logical recipes into a live dataflow graph with fixed destinations. +//! Logical witness overwrites become selections; record inputs/outputs are +//! immutable sources. Pure arithmetic is shared across recipes. Runtime code +//! has no polynomial trees, degree tracking, or column allocation decisions. +use super::*; + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +enum Value { + Constant(F), + Slot(usize), +} +impl Value { + #[inline] + fn get(self, scratch: &[F]) -> F { + match self { + Self::Constant(v) => v, + Self::Slot(i) => scratch[i], + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +enum Arithmetic { + Add(Value, Value), + Sub(Value, Value), + Mul(Value, Value), + Select(Value, Value, Value), +} +impl Arithmetic { + fn sources(self) -> Vec> { + match self { + Self::Add(a, b) | Self::Sub(a, b) | Self::Mul(a, b) => vec![a, b], + Self::Select(g, a, b) => vec![g, a, b], + } + } + #[inline] + fn eval>(self, s: &[F], f: B) -> F { + match self { + Self::Add(a, b) => f.add(a.get(s), b.get(s)), + Self::Sub(a, b) => f.sub(a.get(s), b.get(s)), + Self::Mul(a, b) => f.mul(a.get(s), b.get(s)), + Self::Select(g, a, b) => { + if g.get(s) == f.one() { + a.get(s) + } else { + b.get(s) + } + }, + } + } +} + +enum Node { + Arithmetic(Arithmetic), + Inverse(Value), + Choice(Vec>>), + Failure(Vec>), + Call { callable: usize, args: Vec> }, + Store { values: Vec> }, + Load { address: Value }, + Hint { instruction: usize, key: Vec> }, +} +impl Node { + fn sources(&self) -> Vec> { + match self { + Self::Arithmetic(a) => a.sources(), + Self::Inverse(a) => vec![*a], + Self::Choice(xs) => xs.iter().flatten().copied().collect(), + Self::Failure(xs) + | Self::Call { args: xs, .. } + | Self::Store { values: xs, .. } + | Self::Hint { key: xs, .. } => xs.clone(), + Self::Load { address, .. } => vec![*address], + } + } +} +struct Kernel { + guard: Value, + start: usize, + width: usize, + node: Node, +} +struct Write { + guard: Value, + column: usize, + value: Value, +} + +pub(super) struct FillPlan { + function: usize, + field: B, + inputs: usize, + output: usize, + scratch: usize, + kernels: Vec>, + writes: Vec>, +} + +struct Builder { + logical: Vec>, + immutable: FxHashSet, + shared: FxHashMap, Value>, + plan: FillPlan, + field: B, +} + +impl Builder { + fn emit( + &mut self, + guard: Value, + width: usize, + node: Node, + ) -> Vec> { + let start = self.plan.scratch; + self.plan.scratch += width; + self.plan.kernels.push(Kernel { guard, start, width, node }); + (start..start + width).map(Value::Slot).collect() + } + fn arithmetic(&mut self, op: Arithmetic) -> Value { + use Arithmetic::*; + use Value::Constant as C; + let zero = Value::Constant(self.field.zero()); + let one = Value::Constant(self.field.one()); + match op { + Add(C(a), C(b)) => return C(self.field.add(a, b)), + Sub(C(a), C(b)) => return C(self.field.sub(a, b)), + Mul(C(a), C(b)) => return C(self.field.mul(a, b)), + Add(a, b) if a == zero => return b, + Add(b, a) | Sub(b, a) if a == zero => return b, + Mul(a, b) if a == one => return b, + Mul(b, a) if a == one => return b, + Sub(a, b) if a == b => return zero, + Mul(a, b) if a == zero || b == zero => return zero, + Select(C(g), a, b) => return if g == self.field.one() { a } else { b }, + Select(_, a, b) if a == b => return a, + _ => (), + } + if let Some(v) = self.shared.get(&op) { + return *v; + } + let value = self.emit(one, 1, Node::Arithmetic(op))[0]; + self.shared.insert(op, value); + value + } + fn expr(&mut self, p: &Polynomial) -> Value { + match p { + Polynomial::Const(v) => Value::Constant(self.field.from_u64(*v)), + Polynomial::Var(i) => self.logical[*i], + Polynomial::Add(xs) | Polynomial::Sub(xs) | Polynomial::Mul(xs) => { + let a = self.expr(&xs[0]); + let b = self.expr(&xs[1]); + self.arithmetic(match p { + Polynomial::Add(_) => Arithmetic::Add(a, b), + Polynomial::Sub(_) => Arithmetic::Sub(a, b), + _ => Arithmetic::Mul(a, b), + }) + }, + } + } + fn exprs(&mut self, ps: &[Polynomial]) -> Vec> { + ps.iter().map(|p| self.expr(p)).collect() + } + fn assign( + &mut self, + guard: Value, + dest: &[usize], + values: Vec>, + ) { + for (&d, v) in dest.iter().zip(values) { + if !self.immutable.contains(&d) { + self.logical[d] = + self.arithmetic(Arithmetic::Select(guard, v, self.logical[d])); + } + } + } +} + +impl FillPlan { + pub(super) fn compile( + plan: &FunctionPlan, + callables: &FxHashMap, + program: &CheckedProgram, + ) -> Self { + let field = program.field; + let zero = Value::Constant(field.zero()); + let initial = plan.inputs.len() + plan.output.len(); + let mut b = Builder { + logical: vec![zero; plan.witnesses], + immutable: plan.inputs.iter().chain(&plan.output).copied().collect(), + shared: FxHashMap::default(), + field, + plan: Self { + function: callables[&plan.name], + field, + inputs: plan.inputs.len(), + output: plan.output.len(), + scratch: initial, + kernels: vec![], + writes: vec![], + }, + }; + for (i, &logical) in plan.inputs.iter().chain(&plan.output).enumerate() { + b.logical[logical] = Value::Slot(i); + } + for step in &plan.steps { + if step.action.dest().iter().all(|d| b.immutable.contains(d)) { + continue; + } + let guard = b.expr(&step.guard); + if guard == zero { + continue; + } + let width = step.action.dest().len(); + let values = match &step.action { + Action::Assign { values, .. } => b.exprs(values), + Action::Inverse { value, .. } => { + let value = b.expr(value); + b.emit(guard, width, Node::Inverse(value)) + }, + Action::Choose { tests, .. } => { + let tests = tests.iter().map(|ps| b.exprs(ps)).collect(); + b.emit(guard, width, Node::Choice(tests)) + }, + Action::Failure { differences, .. } => { + let values = b.exprs(differences); + b.emit(guard, width, Node::Failure(values)) + }, + Action::Call { name, args, .. } => { + let args = b.exprs(args); + b.emit(guard, width, Node::Call { callable: callables[name], args }) + }, + Action::Store { values, .. } => { + let values = b.exprs(values); + b.emit(guard, width, Node::Store { values }) + }, + Action::Load { address, .. } => { + let address = b.expr(address); + b.emit(guard, width, Node::Load { address }) + }, + Action::Hint { instruction, key, .. } => { + let key = b.exprs(key); + b.emit(guard, width, Node::Hint { instruction: *instruction, key }) + }, + }; + b.assign(guard, step.action.dest(), values); + } + for write in &plan.writes { + let guard = b.expr(&write.guard); + b.plan.writes.push(Write { + guard, + column: write.column, + value: b.logical[write.source], + }); + } + // Every node refers only to earlier slots: one reverse pass suffices. + let mut live = vec![false; b.plan.scratch]; + for w in &b.plan.writes { + for v in [w.guard, w.value] { + if let Value::Slot(i) = v { + live[i] = true; + } + } + } + for k in b.plan.kernels.iter().rev() { + if live[k.start..k.start + k.width].iter().any(|v| *v) { + for v in k.node.sources().into_iter().chain([k.guard]) { + if let Value::Slot(i) = v { + live[i] = true; + } + } + } + } + b.plan + .kernels + .retain(|k| live[k.start..k.start + k.width].iter().any(|v| *v)); + b.plan + } + + pub(super) fn fill( + &self, + record: &Execution, + query: (&[B::Element], crate::query::QueryOutputRef<'_, B::Element>), + scratch: &mut Vec, + buffer: &mut Vec, + row: &mut [B::Element], + ) -> Result<(), String> { + self.fill_into(record, query, scratch, buffer, |column, value| { + row[column] = value; + }) + } + + /// The same population graph can write either generic field words or the + /// backend's field matrix directly, without an intermediate whole trace. + pub(super) fn fill_into( + &self, + record: &Execution, + query: (&[B::Element], crate::query::QueryOutputRef<'_, B::Element>), + scratch: &mut Vec, + buffer: &mut Vec, + mut write: impl FnMut(usize, B::Element), + ) -> Result<(), String> { + let field = self.field; + scratch.resize(self.scratch, self.field.zero()); + // Every retained slot is an input/output or has one earlier producer. + // Producers overwrite their spans; only inactive/partial producers + // need zeroing. Unused scratch slots are never read by the live graph. + let (input, output) = query; + scratch[..self.inputs].copy_from_slice(input); + scratch[self.inputs..self.inputs + self.output] + .copy_from_slice(output.output); + for k in &self.kernels { + if k.guard.get(scratch) != field.one() { + scratch[k.start..k.start + k.width].fill(field.zero()); + continue; + } + match &k.node { + Node::Arithmetic(op) => scratch[k.start] = op.eval(scratch, field), + Node::Inverse(v) => { + scratch[k.start] = + field.inverse(v.get(scratch)).ok_or("active zero denominator")? + }, + Node::Choice(tests) => { + scratch[k.start..k.start + k.width].fill(field.zero()); + let selected = tests + .iter() + .position(|xs| xs.iter().all(|v| v.get(scratch) == field.zero())) + .ok_or("no matching trace arm")?; + scratch[k.start + selected] = field.one(); + }, + Node::Failure(xs) => { + scratch[k.start..k.start + k.width].fill(field.zero()); + let (i, v) = xs + .iter() + .enumerate() + .find_map(|(i, v)| { + let x = v.get(scratch); + (x != field.zero()).then_some((i, x)) + }) + .ok_or("rejected pattern actually matches")?; + scratch[k.start + i] = + field.inverse(v).ok_or("zero failure witness")?; + }, + Node::Call { callable, args } => { + buffer.clear(); + buffer.extend(args.iter().map(|v| v.get(scratch))); + let table = &record.queries.tables[*callable]; + if let Some(map) = &table.static_map { + map + .binding + .evaluate(buffer, &mut scratch[k.start..k.start + k.width])?; + } else { + if let Some(id) = table.lookup(buffer).1 { + scratch[k.start..k.start + k.width] + .copy_from_slice(table.output(id).output); + } else if k.width != 0 || !record.is_deferred(*callable, buffer) { + return Err("missing recorded callee".into()); + } + } + }, + Node::Store { values, .. } => { + buffer.clear(); + buffer.extend(values.iter().map(|v| v.get(scratch))); + scratch[k.start] = field.from_u64( + record.memory.address_of(buffer).ok_or("missing recorded store")? + as u64, + ); + }, + Node::Load { address, .. } => { + let address = usize::try_from(field.to_u64(address.get(scratch))) + .map_err(|_| "ROM address overflow")?; + let cell = &record + .memory + .get_by_width(k.width, address) + .ok_or("missing recorded load")? + .cell; + if cell.value.len() != k.width { + return Err("ROM load shape mismatch".into()); + } + scratch[k.start..k.start + k.width].copy_from_slice(cell.value); + }, + Node::Hint { instruction, key } => { + buffer.clear(); + buffer.extend(key.iter().map(|v| v.get(scratch))); + record.hints.sites[self.function][*instruction] + .as_ref() + .ok_or("missing hint site")? + .evaluate( + buffer, + &mut scratch[k.start..k.start + k.width], + field, + )?; + }, + } + } + for w in &self.writes { + if w.guard.get(scratch) == field.one() { + write(w.column, w.value.get(scratch)); + } + } + Ok(()) + } +} + +/// Device encoding of population plans for `stark::gpu`, whose CUDA +/// interpreter (`cuda/population.cu`) mirrors [`FillPlan::fill_into`]. +#[cfg(feature = "cuda")] +pub(super) mod device { + use super::*; + + pub const OP_ADD: u32 = 0; + pub const OP_SUB: u32 = 1; + pub const OP_MUL: u32 = 2; + pub const OP_SELECT: u32 = 3; + pub const OP_INVERSE: u32 = 4; + pub const OP_CHOICE: u32 = 5; + pub const OP_FAILURE: u32 = 6; + pub const OP_MAP: u32 = 7; + pub const OP_CALL: u32 = 8; + pub const OP_HINT: u32 = 9; + const CONSTANT: u32 = 0x8000_0000; + + /// Canonical field constants shared by every encoded plan of a program. + #[derive(Default)] + pub struct Constants { + pub values: Vec, + index: FxHashMap, + } + impl Constants { + pub fn word(&mut self, value: u64) -> Option { + if let Some(&i) = self.index.get(&value) { + return Some(i | CONSTANT); + } + let i = + u32::try_from(self.values.len()).ok().filter(|i| i & CONSTANT == 0)?; + self.values.push(value); + self.index.insert(value, i); + Some(i | CONSTANT) + } + } + + /// How a callable or hint site runs on the device. + #[derive(Clone, Copy)] + pub enum Target { + Map(u32), + Call(u32), + } + + pub struct Encoded { + pub code: Vec, + pub scratch: u32, + pub inputs: u32, + pub outputs: u32, + } + + impl FillPlan { + /// The plan's kernels and column writes, writing physical `column`s, or + /// `None` when a kernel needs host-only state: memory, or a callable or + /// hint site without a device implementation. + pub fn encode( + &self, + call: &mut impl FnMut(usize) -> Option, + hint: &mut impl FnMut(usize) -> Option, + column: &impl Fn(usize) -> usize, + constants: &mut Constants, + ) -> Option { + let field = self.field; + let mut word = |v: &Value| -> Option { + match v { + Value::Constant(c) => constants.word(field.to_u64(*c)), + Value::Slot(i) => { + u32::try_from(*i).ok().filter(|i| i & CONSTANT == 0) + }, + } + }; + let mut code = vec![u32::try_from(self.kernels.len()).ok()?]; + for k in &self.kernels { + let mut body = vec![]; + let op = match &k.node { + Node::Arithmetic(a) => match a { + Arithmetic::Add(x, y) + | Arithmetic::Sub(x, y) + | Arithmetic::Mul(x, y) => { + body.extend([word(x)?, word(y)?]); + match a { + Arithmetic::Add(..) => OP_ADD, + Arithmetic::Sub(..) => OP_SUB, + _ => OP_MUL, + } + }, + Arithmetic::Select(g, x, y) => { + body.extend([word(g)?, word(x)?, word(y)?]); + OP_SELECT + }, + }, + Node::Inverse(x) => { + body.push(word(x)?); + OP_INVERSE + }, + Node::Choice(tests) => { + body.push(u32::try_from(tests.len()).ok()?); + for test in tests { + body.push(u32::try_from(test.len()).ok()?); + for v in test { + body.push(word(v)?); + } + } + OP_CHOICE + }, + Node::Failure(xs) => { + body.push(u32::try_from(xs.len()).ok()?); + for v in xs { + body.push(word(v)?); + } + OP_FAILURE + }, + Node::Call { callable, args } => { + let (op, target) = match call(*callable)? { + Target::Map(kind) => (OP_MAP, kind), + Target::Call(slot) => (OP_CALL, slot), + }; + body.extend([target, u32::try_from(args.len()).ok()?]); + for v in args { + body.push(word(v)?); + } + op + }, + Node::Hint { instruction, key } => { + body.extend([hint(*instruction)?, u32::try_from(key.len()).ok()?]); + for v in key { + body.push(word(v)?); + } + OP_HINT + }, + Node::Store { .. } | Node::Load { .. } => return None, + }; + code.extend([ + op, + word(&k.guard)?, + u32::try_from(k.start).ok()?, + u32::try_from(k.width).ok()?, + u32::try_from(body.len()).ok()?, + ]); + code.extend(body); + } + code.push(u32::try_from(self.writes.len()).ok()?); + for w in &self.writes { + code.extend([ + word(&w.guard)?, + u32::try_from(column(w.column)).ok()?, + word(&w.value)?, + ]); + } + Some(Encoded { + code, + scratch: u32::try_from(self.scratch).ok()?, + inputs: u32::try_from(self.inputs).ok()?, + outputs: u32::try_from(self.output).ok()?, + }) + } + } +} diff --git a/crates/aiur/src/trace/stark.rs b/crates/aiur/src/trace/stark.rs new file mode 100644 index 000000000..d84cc0d93 --- /dev/null +++ b/crates/aiur/src/trace/stark.rs @@ -0,0 +1,711 @@ +//! Experimental multi-stark adapter for the certified circuit export. +//! +//! The verifier's program, artifact and fixed tables must come from the trusted +//! compilation, not from the proof supplier. This Rust adapter and multi-stark +//! are outside the Lean proof. In particular, the memoized semantics' acyclicity +//! hypothesis is not discharged by a lookup argument. +use super::{Polynomial, Trace, TracePlan}; +use crate::{ + Execution, + field::{FieldBackend, NativeField, PrimeField}, +}; +use multi_stark::{ + expr::Expr, + lookup::{Lookup, logup_constraint_count, logup_max_degree, stage2_width}, + p3_field::{PrimeCharacteristicRing, PrimeField64}, + p3_matrix::{Matrix, dense::RowMajorMatrix}, + system::{CircuitInputs, ProverKey, System, SystemWitness}, + types::{CommitmentParameters, FriParameters, GoldilocksBlake3Config, Val}, +}; +#[cfg(feature = "parallel")] +use rayon::prelude::*; +use rustc_hash::FxHashMap; +use serde::Serialize; + +pub mod batch; +#[cfg(feature = "cuda")] +mod gpu; +mod grouping; +pub mod planning; +#[cfg(feature = "trace-profile")] +mod profile; +mod rom; +mod tables; +#[cfg(test)] +mod tests; +mod witness; +pub use batch::{StageOne, StreamPlan, VerifyingKey}; + +/// Conversion at this concrete proving adapter only. The native configuration +/// writes its existing field values directly into multi-stark's matrices. +pub trait WitnessField: FieldBackend { + fn into_stark(value: Self::Element) -> Val; + /// The elements as Goldilocks words, not necessarily canonical; borrowed + /// when the representation already is one. + fn words(values: &[Self::Element]) -> std::borrow::Cow<'_, [u64]> { + values.iter().map(|&v| Self::into_stark(v).as_canonical_u64()).collect() + } +} +impl WitnessField for PrimeField { + fn into_stark(value: u64) -> Val { + Val::from_u64(value) + } + fn words(values: &[u64]) -> std::borrow::Cow<'_, [u64]> { + std::borrow::Cow::Borrowed(values) + } +} +impl WitnessField for NativeField { + #[inline] + fn into_stark(value: Val) -> Val { + value + } + fn words(values: &[Val]) -> std::borrow::Cow<'_, [u64]> { + // SAFETY: `Goldilocks` is `#[repr(transparent)]` over `u64`. + std::borrow::Cow::Borrowed(unsafe { + std::slice::from_raw_parts(values.as_ptr().cast::(), values.len()) + }) + } +} + +pub type Proof = multi_stark::prover::Proof; +pub type BatchProof = multi_stark::batch::BatchProof; + +// Separate message namespaces; callable/type IDs fix the shape within each. +const CALL: u64 = 1; +const ROM: u64 = 2; +pub const MEMSEG: u64 = 16; + +/// CPU FRI configuration. Root Merkle caps also cover height-one circuits. +/// These are explicit protocol parameters, not a claimed security-bit estimate. +#[derive(Clone, Copy, Debug, Serialize)] +pub struct Parameters { + pub log_blowup: usize, + pub num_queries: usize, +} +impl Default for Parameters { + fn default() -> Self { + Self { log_blowup: 1, num_queries: 64 } + } +} + +#[derive(Clone, Debug, Serialize)] +pub struct CircuitStatistics { + pub name: String, + pub stage1_width: usize, + pub stage2_width: usize, + pub preprocessed_width: usize, + pub preprocessed_height: usize, + pub lookups: usize, + pub lookup_group_size: usize, + pub quotient_degree: usize, +} + +/// Set up once, then prove many records. Only this adapter selects Goldilocks; +/// the compiler, circuit export and ordinary execution remain field generic. +pub struct Backend<'p, 'a, B: WitnessField = PrimeField> { + plan: &'p TracePlan<'a, B>, + system: System, + key: ProverKey, + names: Vec, + tables: Vec, + rom: rom::Rom, + lookup_plans: Vec, + members: Vec>, + placements: Vec, + parameters: Parameters, + segmented_memory: bool, + gpu_lookup_only: bool, + /// The device a CUDA backend proves on, and its device population plans + /// when `AIUR_GPU_TRACE=generated`. + #[cfg(feature = "cuda")] + device: i32, + #[cfg(feature = "cuda")] + device_plans: Option, +} + +/// Whether lookup witnesses are shape-only, leaving the CUDA prover to +/// derive every lookup message from the committed trace. This is the CUDA +/// default: multi-stark rebuilds the values from the commitment on the rare +/// paths that need them on the host, so it changes no proof byte. Set +/// `AIUR_TRACE_ONLY_LOOKUPS=0` to build host lookup buffers anyway; CPU +/// builds always build them and reject `AIUR_TRACE_ONLY_LOOKUPS=1`. +fn device_lookups() -> Result { + match std::env::var("AIUR_TRACE_ONLY_LOOKUPS") { + Ok(value) if value == "1" => Ok(true), + Ok(value) if value == "0" => Ok(false), + Ok(value) if value.is_empty() => Ok(cfg!(feature = "cuda")), + Ok(value) => { + Err(format!("AIUR_TRACE_ONLY_LOOKUPS must be 0 or 1, not {value:?}")) + }, + Err(_) => Ok(cfg!(feature = "cuda")), + } +} + +fn constant(x: u64) -> Expr { + Expr::constant(Val::from_u64(x)) +} +fn main_var(i: usize) -> Expr { + Expr::main(u32::try_from(i).expect("checked column width")) +} + +fn lower(p: &Polynomial) -> Expr { + match p { + Polynomial::Const(x) => constant(*x), + Polynomial::Var(i) => main_var(*i), + Polynomial::Add(p) => lower(&p[0]) + lower(&p[1]), + Polynomial::Sub(p) => lower(&p[0]) - lower(&p[1]), + Polynomial::Mul(p) => lower(&p[0]) * lower(&p[1]), + } +} + +fn degree(e: &Expr) -> usize { + match e { + Expr::Const(_) | Expr::Public(_) | Expr::IsTransition => 0, + Expr::Var(_) | Expr::IsFirstRow | Expr::IsLastRow => 1, + Expr::Add(a, b) | Expr::Sub(a, b) => degree(a).max(degree(b)), + Expr::Mul(a, b) => degree(a) + degree(b), + Expr::Neg(a) => degree(a), + } +} + +impl<'p, 'a, B: WitnessField> Backend<'p, 'a, B> { + pub fn new( + plan: &'p TracePlan<'a, B>, + parameters: Parameters, + ) -> Result { + Self::with_memory_policy(plan, parameters, false) + } + + /// Batch proofs close contiguous memory ranges through authenticated + /// boundary messages. A standalone proof uses the original first-row rule. + pub fn for_batch( + plan: &'p TracePlan<'a, B>, + parameters: Parameters, + ) -> Result { + Self::with_memory_policy(plan, parameters, true) + } + + /// Reconstruct the trusted batch system for verification or key export. + /// Prover-only lookup settings must not affect these operations. Use the CPU + /// host binary when verification must not initialize the CUDA backend. + pub fn for_batch_verification( + plan: &'p TracePlan<'a, B>, + parameters: Parameters, + ) -> Result { + Self::build_with_lookup_policy(plan, parameters, true, None, false) + } + + /// Explicit CUDA placement. CPU builds reject a requested device instead of + /// silently running a different backend. Device placement does not change keys. + pub fn for_batch_on_device( + plan: &'p TracePlan<'a, B>, + parameters: Parameters, + device: Option, + ) -> Result { + Self::build(plan, parameters, true, device) + } + + fn with_memory_policy( + plan: &'p TracePlan<'a, B>, + parameters: Parameters, + segmented_memory: bool, + ) -> Result { + Self::build(plan, parameters, segmented_memory, None) + } + + fn build( + plan: &'p TracePlan<'a, B>, + parameters: Parameters, + segmented_memory: bool, + device: Option, + ) -> Result { + let gpu_lookup_only = device_lookups()?; + #[allow(unused_mut)] + let mut backend = Self::build_with_lookup_policy( + plan, + parameters, + segmented_memory, + device, + gpu_lookup_only, + )?; + // Only proving backends populate traces; verification ignores this. + #[cfg(feature = "cuda")] + { + backend.device_plans = gpu::DevicePlans::from_env(&backend)?; + } + Ok(backend) + } + + fn build_with_lookup_policy( + plan: &'p TracePlan<'a, B>, + parameters: Parameters, + segmented_memory: bool, + device: Option, + gpu_lookup_only: bool, + ) -> Result { + if gpu_lookup_only && !cfg!(feature = "cuda") { + return Err("AIUR_TRACE_ONLY_LOOKUPS=1 requires a CUDA build".into()); + } + if device.is_some_and(|d| d < 0) { + return Err("negative CUDA device".into()); + } + #[cfg(not(feature = "cuda"))] + if device.is_some() { + return Err( + "GPU device requested from a CPU build; build with the cuda feature" + .into(), + ); + } + if plan.program.field.modulus() != Val::ORDER_U64 { + return Err("multi-stark adapter requires the Goldilocks field".into()); + } + if !(1..=4).contains(¶meters.log_blowup) || parameters.num_queries == 0 + { + return Err( + "expected log_blowup in 1..=4 and positive num_queries".into(), + ); + } + let rom = rom::Rom::new(plan); + let mut inputs = vec![]; + let mut names = vec![]; + let placements = grouping::build(plan, &rom, &mut inputs, &mut names)?; + let function_circuits = inputs.len(); + let tables = tables::fixed_tables( + plan, + &mut inputs, + &mut names, + parameters.log_blowup, + )?; + rom.append_circuits(&mut inputs, &mut names, segmented_memory)?; + // Fail with an error before System::new's degree assertion. Grouping + // is tuned below using the backend's compiled (constant-folded) degrees. + let max_degree = (1 << parameters.log_blowup) + 1; + for (input, name) in inputs.iter().zip(&names) { + let user_degree = input.constraints.iter().map(degree).max().unwrap_or(0); + let lookup_degree = input + .lookups + .iter() + .map(|l| { + (l.args.iter().map(degree).max().unwrap_or(0) + 1) + .max(degree(&l.multiplicity)) + }) + .max() + .unwrap_or(1); + if user_degree.max(lookup_degree) > max_degree { + return Err(format!( + "{name}: increase log_blowup for constraint degree {}", + user_degree.max(lookup_degree) + )); + } + } + let config = GoldilocksBlake3Config::with_device( + CommitmentParameters { log_blowup: parameters.log_blowup, cap_height: 0 }, + FriParameters { + log_final_poly_len: 0, + max_log_arity: 1, + num_queries: parameters.num_queries, + commit_proof_of_work_bits: 0, + query_proof_of_work_bits: 0, + }, + device, + ); + let (mut system, key) = System::new(config, inputs); + // Group messages only if the existing quotient degree suffices. This + // reduces stage 2 without making its FFTs or the quotient FFT larger. + for circuit in &mut system.circuits { + let quotient = circuit.quotient_degree(); + for group in (2..=multi_stark::lookup::MAX_LOOKUP_GROUP + .min(circuit.num_lookups)) + .rev() + { + let max_degree = circuit + .graph + .max_constraint_degree + .max(logup_max_degree(&circuit.graph, group)) + as usize; + if (max_degree.max(2) - 1).next_power_of_two() <= quotient { + circuit.lookup_group_size = group; + circuit.stage_2_width = stage2_width(circuit.num_lookups, group, 2); + circuit.constraint_count = circuit.graph.zeros.len() + + logup_constraint_count(circuit.num_lookups, group, 2); + circuit.max_constraint_degree = max_degree; + break; + } + } + } + let lookup_plans = system + .circuits + .iter() + .map(|circuit| witness::LookupPlan::compile(&circuit.graph)) + .collect::>()?; + let mut members = vec![vec![]; function_circuits]; + for (function, &chip) in plan.members.iter().enumerate() { + members[placements[chip].circuit].push(function); + } + let backend = Self { + plan, + system, + key, + names, + tables, + rom, + lookup_plans, + members, + placements, + parameters, + segmented_memory, + gpu_lookup_only, + #[cfg(feature = "cuda")] + device: device.unwrap_or_else(|| { + std::env::var("MULTI_STARK_CUDA_DEVICE") + .ok() + .and_then(|v| v.parse().ok()) + .unwrap_or(0) + }), + #[cfg(feature = "cuda")] + device_plans: None, + }; + Ok(backend) + } + + pub fn statistics(&self) -> Vec { + self + .system + .circuits + .iter() + .zip(&self.names) + .map(|(c, name)| CircuitStatistics { + name: name.clone(), + stage1_width: c.main_width, + stage2_width: c.stage_2_width, + preprocessed_width: c.preprocessed_width, + preprocessed_height: c.preprocessed_height, + lookups: c.num_lookups, + lookup_group_size: c.lookup_group_size, + quotient_degree: c.quotient_degree(), + }) + .collect() + } + + pub fn claim( + &self, + entry: &str, + args: &[B::Element], + output: &[B::Element], + ) -> Result, String> { + let id = self.plan.program.entry(entry)?.function; + self.plan.program.inputs[id].validate(args, self.plan.program.field)?; + self.plan.program.outputs[id].validate(output, self.plan.program.field)?; + let chip = &self.plan.artifact.chips[self.plan.members[id]]; + Ok( + [CALL, self.plan.callables[&chip.name] as u64] + .into_iter() + .map(Val::from_u64) + .chain(args.iter().copied().map(B::into_stark)) + .chain(output.iter().copied().map(B::into_stark)) + .collect(), + ) + } + + /// Convert populated function rows, copy fixed-table/ROM counts from the + /// execution record, then evaluate the lookup prefix. Zero padding emits + /// no demands, so the recorded counts need no adjustment. + /// This validates shapes and recorded counts. Use TracePlan::check + /// for row diagnostics; the proof enforces equations and lookup balance. + pub fn witness( + &self, + record: &Execution, + trace: &Trace, + ) -> Result, String> { + self.plan.validate_record(record)?; + if trace.matrices.len() != self.plan.artifact.chips.len() { + return Err("trace matrix count mismatch".into()); + } + let table_counts = self.auxiliary_counts(record)?; + let traces = self.convert_traces(record, trace, &table_counts)?; + let (active, degrees) = self.trace_shape(&traces)?; + self.check_shape(&active, °rees)?; + Ok(self.witness_from_main(traces)) + } + + /// CUDA's graph evaluator derives lookup messages from committed rows. + /// Shape-only buffers deliberately fail closed if a CPU fallback tries to + /// consume them. Full host buffers remain the default for fallback support. + fn witness_from_main( + &self, + traces: Vec>, + ) -> SystemWitness { + #[cfg(feature = "trace-profile")] + let _profile = profile::Span::new( + "shard_lookups", + traces.iter().map(|t| t.values.len()).sum(), + ); + if self.gpu_lookup_only { + let lookups = traces + .iter() + .zip(&self.system.circuits) + .map(|(trace, circuit)| { + let widths: Vec<_> = + circuit.graph.lookups.iter().map(|l| l.args.len()).collect(); + multi_stark::lookup::LookupValues::shape_only(trace.height(), &widths) + }) + .collect(); + SystemWitness { traces, lookups } + } else { + // The certified adapter accepts only row-local lookup expressions. + // Reuse its compiled writer after slicing, just as in fused generation, + // instead of serially interpreting the full graph for every padded row. + #[cfg(feature = "parallel")] + let lookups = traces + .par_iter() + .enumerate() + .map(|(ci, trace)| self.auxiliary_lookups(ci, trace)) + .collect(); + #[cfg(not(feature = "parallel"))] + let lookups = traces + .iter() + .enumerate() + .map(|(ci, trace)| self.auxiliary_lookups(ci, trace)) + .collect(); + SystemWitness { traces, lookups } + } + } + + fn auxiliary_counts( + &self, + record: &Execution, + ) -> Result>, String> { + let program = &self.plan.program.program; + let counts = |mi: usize| { + let map = record.queries.tables[program.functions.len() + mi] + .static_map + .as_ref() + .ok_or("missing fixed-table record")?; + if map.counts.iter().any(|&count| count >= Val::ORDER_U64) { + return Err("table count reaches field characteristic".into()); + } + Ok::<_, String>(map.counts.to_vec()) + }; + #[cfg(feature = "parallel")] + let table_counts = (0..program.maps.len()) + .into_par_iter() + .map(counts) + .collect::>()?; + #[cfg(not(feature = "parallel"))] + let table_counts = + (0..program.maps.len()).map(counts).collect::>()?; + if record.memory.iter().any(|entry| entry.multiplicity >= Val::ORDER_U64) { + return Err("ROM count reaches field characteristic".into()); + } + Ok(table_counts) + } + + fn convert_traces( + &self, + record: &Execution, + trace: &Trace, + table_counts: &[Vec], + ) -> Result>, String> { + let mut heights = vec![0usize; self.members.len()]; + for (ci, matrix) in trace.matrices.iter().enumerate() { + let placement = &self.placements[ci]; + let n = &mut heights[placement.circuit]; + let height = + if placement.grouped { matrix.unpadded_height } else { matrix.height }; + *n = n.checked_add(height).ok_or("group height overflow")?; + } + let mut traces = heights + .iter() + .enumerate() + .map(|(ci, &height)| { + let padded = if height == 0 { + 0 + } else { + height.checked_next_power_of_two().ok_or("group height overflow")? + }; + let width = self.system.circuits[ci].main_width; + Ok(RowMajorMatrix::new( + Val::zero_vec( + padded.checked_mul(width).ok_or("group trace size overflow")?, + ), + width, + )) + }) + .collect::, String>>()?; + let mut cursors = vec![0usize; self.members.len()]; + for (ci, (chip, matrix)) in + self.plan.artifact.chips.iter().zip(&trace.matrices).enumerate() + { + if matrix.chip != chip.name + || matrix.width != chip.width + || matrix.unpadded_height > matrix.height + || matrix.height.checked_mul(matrix.width) != Some(matrix.values.len()) + || matrix.multiplicities.len() != matrix.height + || (matrix.height != 0 && !matrix.height.is_power_of_two()) + || matrix.values.iter().any(|&x| !self.plan.program.field.valid(x)) + || matrix.multiplicities.iter().any(|&x| x >= Val::ORDER_U64) + { + return Err(format!("{}: malformed STARK trace", chip.name)); + } + let placement = &self.placements[ci]; + let output = &mut traces[placement.circuit]; + let width = output.width; + for r in 0..matrix.height { + let row = matrix.row(r); + let active = row[chip.activation]; + if active != self.plan.program.field.zero() + && active != self.plan.program.field.one() + { + return Err("non-boolean row activation".into()); + } + if active == self.plan.program.field.zero() + && matrix.multiplicities[r] != 0 + { + return Err("inactive row provides a claim".into()); + } + if r >= matrix.unpadded_height { + if row.iter().any(|&x| x != self.plan.program.field.zero()) + || matrix.multiplicities[r] != 0 + { + return Err("nonzero trace padding".into()); + } + continue; + } + if active != self.plan.program.field.one() { + return Err("inactive real row".into()); + } + let cursor = &mut cursors[placement.circuit]; + let dest = &mut output.values[*cursor * width..(*cursor + 1) * width]; + for (&column, &value) in placement.columns.iter().zip(row) { + dest[column] = B::into_stark(value); + } + placement.finish(dest, matrix.multiplicities[r]); + *cursor += 1; + } + } + for table in &self.tables { + traces.push(table.witness(table_counts)); + } + for i in 0..self.rom.circuit_count() { + traces.push(self.rom.witness(record, i)?); + } + Ok(traces) + } + + fn trace_shape( + &self, + traces: &[RowMajorMatrix], + ) -> Result<(Vec, Vec), String> { + self.trace_shape_with(traces, &[]) + } + + /// `device` gives the heights of circuits populated on the GPU, whose host + /// matrices are empty placeholders. + fn trace_shape_with( + &self, + traces: &[RowMajorMatrix], + device: &[Option], + ) -> Result<(Vec, Vec), String> { + if traces.len() != self.system.circuits.len() { + return Err("wrong circuit count".into()); + } + let mut active = vec![]; + let mut degrees = vec![]; + for (ci, (trace, circuit)) in + traces.iter().zip(&self.system.circuits).enumerate() + { + let height = + device.get(ci).copied().flatten().unwrap_or_else(|| trace.height()); + if trace.width != circuit.main_width + || !trace.values.len().is_multiple_of(trace.width) + || (height != 0 && !height.is_power_of_two()) + { + return Err("invalid main trace shape".into()); + } + active.push(height != 0); + if height != 0 { + degrees.push(height.ilog2() as u8); + } + } + Ok((active, degrees)) + } + + /// Match fixed domains and bound total unit lookup consumers below the + /// characteristic. Root caps cover every active matrix, including height 1. + fn check_shape(&self, active: &[bool], degrees: &[u8]) -> Result<(), String> { + if active.len() != self.system.circuits.len() || !active.contains(&true) { + return Err("invalid circuit activation".into()); + } + let mut degrees = degrees.iter(); + let mut budget = 1u64; // one public root + for (circuit, &on) in self.system.circuits.iter().zip(active) { + if !on { + if circuit.preprocessed_height != 0 { + return Err("inactive fixed table".into()); + } + continue; + } + let log = *degrees.next().ok_or("missing trace height")?; + // Goldilocks has 2-adicity 32. Include the commitment blowup. + if usize::from(log) + self.parameters.log_blowup > 32 { + return Err("trace domain exceeds Goldilocks capacity".into()); + } + let height = 1u64 << log; + if circuit.preprocessed_height != 0 + && circuit.preprocessed_height as u64 != height + { + return Err("fixed table height mismatch".into()); + } + budget = height + .checked_mul(circuit.num_lookups as u64) + .and_then(|n| budget.checked_add(n)) + .filter(|&n| n < Val::ORDER_U64) + .ok_or("lookup count reaches field characteristic")?; + } + if degrees.next().is_some() { + return Err("extra trace heights".into()); + } + Ok(()) + } + + /// Prove an already prepared witness. A malformed witness may produce an + /// invalid proof; verification, not the witness generator, is authoritative. + pub fn prove( + &self, + entry: &str, + args: &[B::Element], + output: &[B::Element], + witness: SystemWitness, + ) -> Result { + if self.segmented_memory { + return Err("segmented memory requires a batch proof".into()); + } + let claim = self.claim(entry, args, output)?; + let (active, degrees) = self.trace_shape(&witness.traces)?; + self.check_shape(&active, °rees)?; + if witness.lookups.len() != self.system.circuits.len() { + return Err("wrong lookup witness count".into()); + } + Ok(self.system.prove(&self.key, &claim, witness)) + } + + /// Verify using trusted compilation and the public call alone. No execution + /// record, hints, witness matrices or prover-supplied table data are read. + pub fn verify( + &self, + entry: &str, + args: &[B::Element], + output: &[B::Element], + proof: &Proof, + ) -> Result<(), String> { + if self.segmented_memory { + return Err("segmented memory requires a batch proof".into()); + } + let claim = self.claim(entry, args, output)?; + self.check_shape(&proof.active, &proof.log_degrees)?; + self + .system + .verify(&claim, proof) + .map_err(|e| format!("STARK verification failed: {e:?}")) + } +} diff --git a/crates/aiur/src/trace/stark/batch.rs b/crates/aiur/src/trace/stark/batch.rs new file mode 100644 index 000000000..3447a9d9a --- /dev/null +++ b/crates/aiur/src/trace/stark/batch.rs @@ -0,0 +1,850 @@ +//! Bounded trace shards and verifier-only keys. Function rows may be partitioned +//! freely; memory rows remain consecutive and are closed by the batch preamble. +use super::*; +#[cfg(feature = "cuda")] +use multi_stark::witness::TraceSource; +use multi_stark::{ + batch::{BatchMessage, Retention}, + system::Circuit, + witness::PreparedWitness, +}; +#[cfg(feature = "cuda")] +use std::sync::Arc; + +/// A streamed batch authenticates one public claim across independently +/// executed records. Memory intervals are half-open and width-separated. +pub struct StreamPlan { + pub shards: usize, + pub memory_intervals: Vec<(u64, u64, u64)>, + pub retention: Retention, +} + +/// Copy a run of rows. One shard of a large trace is gigabytes, so a serial +/// `to_vec` cost more than committing the shard on a GPU. +fn copy_rows(values: &[Val]) -> Vec { + #[cfg(feature = "parallel")] + { + const CHUNK: usize = 1 << 16; + if values.len() > 4 * CHUNK { + let mut copy = Val::zero_vec(values.len()); + copy + .par_chunks_mut(CHUNK) + .zip(values.par_chunks(CHUNK)) + .for_each(|(to, from)| to.copy_from_slice(from)); + return copy; + } + } + values.to_vec() +} + +fn commitment_parameters(p: Parameters) -> CommitmentParameters { + CommitmentParameters { log_blowup: p.log_blowup, cap_height: 0 } +} +fn fri_parameters(p: Parameters) -> FriParameters { + FriParameters { + log_final_poly_len: 0, + max_log_arity: 1, + num_queries: p.num_queries, + commit_proof_of_work_bits: 0, + query_proof_of_work_bits: 0, + } +} + +/// Stage-one traces ready for batch proving: host rows, plus the device +/// record of the function circuits the GPU fills +/// (`AIUR_GPU_TRACE=generated`), whose host matrices are empty placeholders. +pub struct StageOne { + pub traces: Vec>, + #[cfg(feature = "cuda")] + device: Option>, +} + +impl StageOne { + pub fn host(traces: Vec>) -> Self { + Self { + traces, + #[cfg(feature = "cuda")] + device: None, + } + } + + /// Heights of device-populated circuits, by circuit; empty without any. + fn device_heights(&self) -> Vec> { + #[cfg(feature = "cuda")] + if let Some(device) = &self.device { + return (0..self.traces.len()).map(|ci| device.height(ci)).collect(); + } + vec![] + } + + fn height(&self, ci: usize, device: &[Option]) -> usize { + device + .get(ci) + .copied() + .flatten() + .unwrap_or_else(|| self.traces[ci].height()) + } + + /// Stage-one cells, on the host and the device, for resource plans. + pub fn cells(&self) -> u64 { + let device = self.device_heights(); + (0..self.traces.len()) + .map(|ci| (self.height(ci, &device) * self.traces[ci].width) as u64) + .sum() + } +} + +/// Arguments for a memory-segment boundary message (`[MEMSEG, width, ptr]`). +pub fn memseg_args(width: usize, ptr: Val) -> [Val; 3] { + [Val::from_u64(MEMSEG), Val::from_usize(width), ptr] +} + +/// Decode only trusted compiler output (or compare its digest with a trusted +/// key). A key is a statement, not evidence that its program is the intended one. +pub struct VerifyingKey { + system: System, + cp: CommitmentParameters, + fp: FriParameters, +} +impl Clone for VerifyingKey { + fn clone(&self) -> Self { + Self::from_bytes(&self.to_bytes()).expect("valid VerifyingKey") + } +} +impl std::fmt::Debug for VerifyingKey { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("VerifyingKey") + .field("num_circuits", &self.num_circuits()) + .finish() + } +} +impl VerifyingKey { + pub fn from_bytes(bytes: &[u8]) -> Result { + let (system, cp, fp) = stark_key::from_bytes(bytes)?; + if cp.cap_height != 0 + || !(1..=4).contains(&cp.log_blowup) + || fp.log_final_poly_len != 0 + || fp.max_log_arity != 1 + || fp.num_queries == 0 + { + return Err("unsupported Aiur proving parameters".into()); + } + Ok(Self { system, cp, fp }) + } + pub fn to_bytes(&self) -> Vec { + stark_key::to_bytes(&self.system, self.cp, self.fp) + } + pub const fn commitment_parameters(&self) -> CommitmentParameters { + self.cp + } + pub const fn fri_parameters(&self) -> FriParameters { + self.fp + } + pub const fn system(&self) -> &System { + &self.system + } + pub fn num_circuits(&self) -> usize { + self.system.circuits.len() + } + pub fn validate_preamble( + &self, + claim: &[Val], + preamble: &multi_stark::batch::BatchPreamble, + ) -> Result<(), String> { + validate_preamble(&self.system, self.cp.log_blowup, &[claim], preamble) + } + pub fn verify( + &self, + claims: &[Vec], + proof: &BatchProof, + ) -> Result<(), String> { + verify(&self.system, self.cp.log_blowup, claims, proof) + } +} + +fn validate_preamble>( + system: &System, + log_blowup: usize, + claims: &[C], + preamble: &multi_stark::batch::BatchPreamble, +) -> Result<(), String> { + let headers = &preamble.headers; + if headers.is_empty() || headers.len() > 65536 { + return Err("invalid batch shard count".into()); + } + if !headers + .iter() + .flat_map(|h| h.claims.iter().map(Vec::as_slice)) + .eq(claims.iter().map(C::as_ref)) + { + return Err("batch public claims mismatch".into()); + } + let mut budget = claims.len() as u128; + for header in headers { + if header.active.len() != system.circuits.len() + || !header.active.contains(&true) + { + return Err("invalid circuit activation".into()); + } + let mut degrees = header.log_degrees.iter(); + for (circuit, &on) in system.circuits.iter().zip(&header.active) { + if !on { + if circuit.preprocessed_height != 0 { + return Err("inactive fixed table".into()); + } + continue; + } + let log = *degrees.next().ok_or("missing trace height")?; + if usize::from(log) + log_blowup > 32 { + return Err("trace domain exceeds Goldilocks capacity".into()); + } + let height = 1u128 << log; + if circuit.preprocessed_height != 0 + && circuit.preprocessed_height as u128 != height + { + return Err("fixed table height mismatch".into()); + } + budget = budget + .checked_add(height * circuit.num_lookups.max(1) as u128) + .filter(|&n| n < u128::from(Val::ORDER_U64)) + .ok_or("batch height/lookup budget exceeds field")?; + } + if degrees.next().is_some() { + return Err("extra trace heights".into()); + } + } + let messages = &preamble.messages; + if !messages.len().is_multiple_of(2) { + return Err("unpaired memory boundaries".into()); + } + let mut previous = None; + for pair in messages.as_chunks::<2>().0 { + let (pull, push) = (&pair[0], &pair[1]); + if pull.multiplicity != -Val::ONE + || push.multiplicity != Val::ONE + || pull.args.len() != 3 + || push.args.len() != 3 + || pull.args[0] != Val::from_u64(MEMSEG) + || push.args[0] != pull.args[0] + || push.args[1] != pull.args[1] + { + return Err("invalid memory boundary message".into()); + } + let width = pull.args[1].as_canonical_u64(); + let a = pull.args[2].as_canonical_u64(); + let b = push.args[2].as_canonical_u64(); + if a > b + || previous.is_some_and(|(w, end)| width < w || (width == w && a < end)) + { + return Err("overlapping or unordered memory intervals".into()); + } + previous = Some((width, b)); + } + Ok(()) +} + +fn verify( + system: &System, + log_blowup: usize, + claims: &[Vec], + proof: &BatchProof, +) -> Result<(), String> { + if proof.preamble.headers.len() != proof.proofs.len() { + return Err("invalid batch shard count".into()); + } + validate_preamble(system, log_blowup, claims, &proof.preamble)?; + system + .verify_batch(proof) + .map_err(|e| format!("STARK batch verification failed: {e:?}")) +} + +impl<'p, 'a, B: WitnessField> Backend<'p, 'a, B> { + /// Multiple GPU shards still regenerate to bound device residency. A single + /// shard needs the same committed state in round two either way: discarding + /// it only repeats the upload, LDE and Merkle commitment, without saving peak + /// memory. Lookup storage and commitment retention are independent choices. + pub(super) fn requires_regeneration(&self, shards: usize) -> bool { + self.gpu_lookup_only && shards > 1 + } + + /// Fallible two-round streaming. The supplier may replay a record and keep + /// only its current trace matrices; no whole-environment trace is retained. + pub fn prove_streamed_stage_1( + &self, + entry: &str, + args: &[B::Element], + output: &[B::Element], + mut plan: StreamPlan, + mut supply: impl FnMut(usize) -> Result>, String>, + ) -> Result { + if !self.segmented_memory || !(1..=65536).contains(&plan.shards) { + return Err("invalid streamed batch".into()); + } + let claim = self.claim(entry, args, output)?; + plan.memory_intervals.sort_unstable(); + let mut previous = None; + let mut messages = Vec::new(); + for (width, start, end) in plan.memory_intervals { + if start >= end + || end >= Val::ORDER_U64 + || previous.is_some_and(|(w, e)| w == width && start < e) + || !self.system.circuits[self.members.len() + self.tables.len()..] + .iter() + .any(|c| (c.main_width - 3) as u64 == width) + { + return Err("invalid streamed memory intervals".into()); + } + previous = Some((width, end)); + messages.push(BatchMessage::pull(vec![ + Val::from_u64(MEMSEG), + Val::from_u64(width), + Val::from_u64(start), + ])); + messages.push(BatchMessage::push(vec![ + Val::from_u64(MEMSEG), + Val::from_u64(width), + Val::from_u64(end), + ])); + } + let mut headers = Vec::new(); + let mut retained = Vec::new(); + let retain = !self.requires_regeneration(plan.shards) + && matches!(plan.retention, Retention::Retain); + for shard in 0..plan.shards { + let traces = supply(shard)?; + let (active, degrees) = self.trace_shape(&traces)?; + self.check_shape(&active, °rees)?; + let stage = self.system.prove_stage_1(self.witness_from_main(traces)); + let claims = if shard == 0 { vec![claim.as_slice()] } else { vec![] }; + headers.push(stage.header(&claims)); + retained.push(if retain { Some(stage) } else { None }); + } + let preamble = multi_stark::batch::BatchPreamble { headers, messages }; + let mut proofs = Vec::new(); + for (shard, cached) in retained.into_iter().enumerate() { + let claims = if shard == 0 { vec![claim.as_slice()] } else { vec![] }; + let stage = if let Some(stage) = cached { + stage + } else { + let traces = supply(shard)?; + let (active, degrees) = self.trace_shape(&traces)?; + self.check_shape(&active, °rees)?; + let stage = self.system.prove_stage_1(self.witness_from_main(traces)); + if stage.header(&claims) != preamble.headers[shard] { + return Err(format!("streamed shard {shard} changed between rounds")); + } + stage + }; + proofs.push( + self + .system + .prove_batch_shard(&self.key, stage, &claims, &preamble, shard), + ); + } + let proof = BatchProof { preamble, proofs }; + self.verify_batch(entry, args, output, &proof)?; + Ok(proof) + } + + pub fn slice_stage_1( + &self, + traces: &[RowMajorMatrix], + shard: usize, + max_rows: usize, + ) -> Result>, String> { + if max_rows == 0 + || !max_rows.is_power_of_two() + || traces.len() != self.system.circuits.len() + { + return Err("invalid stage-one slice".into()); + } + let begin = shard.checked_mul(max_rows).ok_or("shard offset overflow")?; + let slice = |(trace, circuit): (&RowMajorMatrix, &Circuit)| { + Self::slice_matrix(trace, circuit, shard, begin, max_rows) + }; + #[cfg(feature = "parallel")] + let sliced = + traces.par_iter().zip(&self.system.circuits).map(slice).collect(); + #[cfg(not(feature = "parallel"))] + let sliced = traces.iter().zip(&self.system.circuits).map(slice).collect(); + Ok(sliced) + } + + fn slice_matrix( + trace: &RowMajorMatrix, + circuit: &Circuit, + shard: usize, + begin: usize, + max_rows: usize, + ) -> RowMajorMatrix { + if circuit.preprocessed_height != 0 { + return if shard == 0 { + RowMajorMatrix::new(copy_rows(&trace.values), trace.width) + } else { + RowMajorMatrix::new(Val::zero_vec(trace.values.len()), trace.width) + }; + } + let begin = begin.min(trace.height()); + let end = begin.saturating_add(max_rows).min(trace.height()); + RowMajorMatrix::new( + copy_rows(&trace.values[begin * trace.width..end * trace.width]), + trace.width, + ) + } + + /// The supplier's slice for `shard`. On the shard's last supply, a matrix + /// that no other shard reads (shard zero's fixed tables and every circuit + /// no taller than one shard) moves out of the source instead of being + /// copied; later shards only need its dimensions. With one retained shard + /// this moves the whole witness. + fn take_stage_1( + &self, + source: &mut [RowMajorMatrix], + fixed_cells: &[usize], + shard: usize, + max_rows: usize, + last: bool, + ) -> Vec> { + let begin = shard * max_rows; + let mut taken: Vec<_> = (0..source.len()).map(|_| None).collect(); + if last && shard == 0 { + for ((trace, circuit), slot) in + source.iter_mut().zip(&self.system.circuits).zip(&mut taken) + { + if circuit.preprocessed_height != 0 || trace.height() <= max_rows { + let width = trace.width; + *slot = Some(std::mem::replace( + trace, + RowMajorMatrix::new(Vec::new(), width), + )); + } + } + } + let source = &*source; + let slice = |(i, taken): (usize, Option>)| { + taken.unwrap_or_else(|| { + let (trace, circuit) = (&source[i], &self.system.circuits[i]); + if circuit.preprocessed_height != 0 && shard != 0 { + RowMajorMatrix::new(Val::zero_vec(fixed_cells[i]), trace.width) + } else { + Self::slice_matrix(trace, circuit, shard, begin, max_rows) + } + }) + }; + #[cfg(feature = "parallel")] + let sliced = taken.into_par_iter().enumerate().map(slice).collect(); + #[cfg(not(feature = "parallel"))] + let sliced = taken.into_iter().enumerate().map(slice).collect(); + sliced + } + + pub fn verifying_key_bytes(&self) -> Result, String> { + if !self.segmented_memory { + return Err("export a batch backend key for recursion".into()); + } + Ok(stark_key::to_bytes( + &self.system, + commitment_parameters(self.parameters), + fri_parameters(self.parameters), + )) + } + + /// Partition stage-one matrices into at most `max_rows` rows per function + /// or memory chip. Fixed tables retain their exact domain in every shard. + /// Regenerate keeps only headers at the barrier, bounding committed state + /// by one shard. The execution record and source stage-one matrices remain. + pub fn prove_batch( + &self, + entry: &str, + args: &[B::Element], + output: &[B::Element], + witness: SystemWitness, + max_rows: usize, + retention: Retention, + ) -> Result { + let SystemWitness { traces, lookups } = witness; + // Whole-trace lookup rows are invalid at the new shard boundaries and + // would otherwise remain resident through both proving rounds. + drop(lookups); + self.prove_batch_stage_1(entry, args, output, traces, max_rows, retention) + } + + /// Prove directly from stage-one matrices, computing lookup buffers only + /// for the shard currently being committed. Pair with `generate_stage_1`. + pub fn prove_batch_stage_1( + &self, + entry: &str, + args: &[B::Element], + output: &[B::Element], + traces: Vec>, + max_rows: usize, + retention: Retention, + ) -> Result { + self.prove_stage_one( + entry, + args, + output, + StageOne::host(traces), + max_rows, + retention, + ) + } + + /// Stage one for [`Self::prove_stage_one`]: like + /// [`Self::generate_stage_1`], except that with `AIUR_GPU_TRACE=generated` + /// the function circuits the GPU can fill are left to the device, which + /// receives the record tables they read. The record can then be dropped. + pub fn prepare_stage_1( + &self, + record: &Execution, + entry: &str, + args: &[B::Element], + ) -> Result { + #[cfg(feature = "cuda")] + if let Some(plans) = &self.device_plans { + let device = gpu::DeviceRecord::upload(self, plans, record, self.device)?; + let heights: Vec<_> = + (0..self.system.circuits.len()).map(|ci| device.height(ci)).collect(); + let traces = self + .generate_with::(record, Some((entry, args)), &heights)? + .traces; + return Ok(StageOne { traces, device: Some(Arc::new(device)) }); + } + Ok(StageOne::host(self.generate_stage_1(record, entry, args)?)) + } + + pub fn prove_stage_one( + &self, + entry: &str, + args: &[B::Element], + output: &[B::Element], + stage: StageOne, + max_rows: usize, + retention: Retention, + ) -> Result { + if !self.segmented_memory { + return Err("batch proving requires Backend::for_batch".into()); + } + if max_rows == 0 || !max_rows.is_power_of_two() { + return Err("shard rows must be a positive power of two".into()); + } + let claim = self.claim(entry, args, output)?; + let device_heights = stage.device_heights(); + let (active, degrees) = + self.trace_shape_with(&stage.traces, &device_heights)?; + self.check_shape(&active, °rees)?; + let shards = (0..stage.traces.len()) + .filter(|&ci| self.system.circuits[ci].preprocessed_height == 0) + .map(|ci| stage.height(ci, &device_heights).div_ceil(max_rows)) + .max() + .unwrap_or(1) + .max(1); + #[cfg(feature = "cuda")] + let StageOne { traces, device } = stage; + #[cfg(not(feature = "cuda"))] + let StageOne { traces } = stage; + if shards > 65536 { + return Err("too many trace shards".into()); + } + let memory_start = self.members.len() + self.tables.len(); + let mut messages = Vec::new(); + for trace in &traces[memory_start..] { + let total = trace + .values + .chunks_exact(trace.width) + .take_while(|row| row[1] == Val::ONE) + .count(); + if total != 0 { + let width = Val::from_usize(trace.width - 3); + messages.push(BatchMessage::pull(vec![ + Val::from_u64(MEMSEG), + width, + Val::ZERO, + ])); + messages.push(BatchMessage::push(vec![ + Val::from_u64(MEMSEG), + width, + Val::from_usize(total), + ])); + } + } + let mut claims = vec![vec![]; shards]; + claims[0].push(claim); + // Build lookup buffers from the sliced rows. LookupPlan::compile rejects + // nonlocal lookup expressions; boundary selectors belong to constraints. + let retention = if self.requires_regeneration(shards) { + Retention::Regenerate + } else { + retention + }; + // Shards are supplied in order, once per round: twice when regenerated. + // The source matrices remain resident until their last supply. + let supplies = if matches!(retention, Retention::Retain) { 1 } else { 2 }; + let mut supplied = vec![0u8; shards]; + let fixed_cells: Vec<_> = traces.iter().map(|t| t.values.len()).collect(); + let mut traces = traces; + let proof = self.system.prove_batch_with( + &self.key, + &claims, + messages, + retention, + |shard| { + #[cfg(feature = "trace-profile")] + let profile = super::profile::Span::new("shard_copy", 0); + supplied[shard] += 1; + let last = supplied[shard] == supplies; + let sliced = + self.take_stage_1(&mut traces, &fixed_cells, shard, max_rows, last); + #[cfg(feature = "trace-profile")] + drop(profile); + #[cfg(feature = "cuda")] + if let Some(device) = &device { + return self.device_witness(sliced, device, shard, max_rows); + } + PreparedWitness::from(self.witness_from_main(sliced)) + }, + ); + self.verify_batch(entry, args, output, &proof)?; + Ok(proof) + } + + /// A shard's witness with the device circuits as generated traces over + /// their rows of this shard and every lookup derived on the device. + #[cfg(feature = "cuda")] + fn device_witness( + &self, + sliced: Vec>, + device: &Arc, + shard: usize, + max_rows: usize, + ) -> PreparedWitness { + let begin = shard * max_rows; + let traces: Vec<_> = sliced + .into_iter() + .enumerate() + .map(|(ci, matrix)| match device.height(ci) { + Some(height) if begin < height => { + TraceSource::Generated(Arc::new(gpu::DeviceTrace { + record: Arc::clone(device), + circuit: ci, + base: begin, + height: max_rows.min(height - begin), + })) + }, + _ => TraceSource::Host(matrix), + }) + .collect(); + let lookups = traces + .iter() + .zip(&self.system.circuits) + .map(|(trace, circuit)| { + let widths: Vec<_> = + circuit.graph.lookups.iter().map(|l| l.args.len()).collect(); + multi_stark::lookup::LookupValues::shape_only(trace.height(), &widths) + }) + .collect(); + PreparedWitness { traces, lookups } + } + + pub fn verify_batch( + &self, + entry: &str, + args: &[B::Element], + output: &[B::Element], + proof: &BatchProof, + ) -> Result<(), String> { + if !self.segmented_memory { + return Err("batch verification requires Backend::for_batch".into()); + } + verify( + &self.system, + self.parameters.log_blowup, + &[self.claim(entry, args, output)?], + proof, + ) + } + + /// Unpadded row count for every circuit in `self.system.circuits` order: + /// function circuits (`0 .. self.members.len()`), fixed tables + /// (`self.members.len() .. self.members.len() + self.tables.len()`), and + /// ROM circuits (`self.members.len() + self.tables.len() ..`). + pub fn execution_rows(&self, record: &Execution) -> Vec { + let mut rows = Vec::with_capacity(self.system.circuits.len()); + for members in &self.members { + rows.push(members.iter().map(|&f| record.queries.tables[f].len()).sum()); + } + for ci in self.members.len()..self.members.len() + self.tables.len() { + rows.push(self.system.circuits[ci].preprocessed_height); + } + for &width in &self.rom.widths { + rows.push(record.memory.indices_for_width(width).len()); + } + rows + } + + /// Target power-of-two log heights for a fixed-shape root proof. + pub fn normalized_log_heights( + &self, + rows: &[usize], + headroom: u8, + ) -> Result, String> { + if rows.len() != self.system.circuits.len() { + return Err(format!( + "expected {} circuit row counts, got {}", + self.system.circuits.len(), + rows.len() + )); + } + rows + .iter() + .zip(&self.system.circuits) + .enumerate() + .map(|(index, (&count, circuit))| { + if circuit.preprocessed_height != 0 { + if count != circuit.preprocessed_height { + return Err(format!( + "fixed circuit {index} has {count} rows, expected {}", + circuit.preprocessed_height + )); + } + return u8::try_from(circuit.preprocessed_height.ilog2()) + .map_err(|_| format!("fixed circuit {index} log height overflow")); + } + let base = count + .max(2) + .checked_next_power_of_two() + .ok_or_else(|| { + format!("circuit {index} row count {count} overflows power of two") + })? + .ilog2(); + let log = base + .checked_add(u32::from(headroom)) + .and_then(|log| u8::try_from(log).ok()) + .filter(|&log| log <= 26) + .ok_or_else(|| { + format!( + "circuit {index} normalized log height exceeds the 2^26 KZG limit (rows={count}, headroom={headroom})" + ) + })?; + Ok(log) + }) + .collect() + } + + /// `(payload_width, circuit_index)` for every ROM circuit in ascending width + /// order. + pub fn memory_circuits(&self) -> Vec<(usize, usize)> { + let base = self.members.len() + self.tables.len(); + self + .rom + .widths + .iter() + .enumerate() + .map(|(i, &width)| (width, base + i)) + .collect() + } + + /// Prove a single-shard root execution padded to `log_heights`, emitting + /// `[0, unpadded)` `MEMSEG` boundary messages for every ROM circuit (including + /// empty `0..0` intervals) to match the fixed-shape outer verifier. + pub fn prove_normalized( + &self, + entry: &str, + args: &[B::Element], + output: &[B::Element], + record: Execution, + log_heights: &[u8], + ) -> Result<(Vec, BatchProof), String> { + if !self.segmented_memory { + return Err("normalized proving requires Backend::for_batch".into()); + } + if log_heights.len() != self.system.circuits.len() { + return Err(format!( + "expected {} normalized circuit log heights, got {}", + self.system.circuits.len(), + log_heights.len() + )); + } + for (index, (&log, circuit)) in + log_heights.iter().zip(&self.system.circuits).enumerate() + { + if !(1..=26).contains(&log) { + return Err(format!( + "circuit {index} normalized log height {log} must be in 1..=26" + )); + } + if circuit.preprocessed_height != 0 + && circuit.preprocessed_height != (1usize << log) + { + return Err(format!( + "fixed circuit {index} requires height {}, got 2^{log}", + circuit.preprocessed_height + )); + } + } + let unpadded_rows = self.execution_rows(&record); + for (index, (&rows, &log)) in + unpadded_rows.iter().zip(log_heights).enumerate() + { + let capacity = 1usize << log; + if rows > capacity { + return Err(format!( + "circuit {index} has {rows} unpadded rows, exceeding normalized height 2^{log} ({capacity})" + )); + } + } + let active = vec![true; log_heights.len()]; + self.check_shape(&active, log_heights)?; + let claim = self.claim(entry, args, output)?; + let mut traces = self.generate_stage_1(&record, entry, args)?; + drop(record); + for (index, (trace, &log)) in traces.iter_mut().zip(log_heights).enumerate() + { + let target_height = 1usize << log; + if trace.height() > target_height { + return Err(format!( + "circuit {index} trace height {} exceeds normalized height {target_height}", + trace.height() + )); + } + let target_values = trace + .width + .checked_mul(target_height) + .ok_or_else(|| format!("circuit {index} padded trace size overflow"))?; + trace.values.resize(target_values, Val::ZERO); + } + let rom_base = self.members.len() + self.tables.len(); + let mut messages = Vec::with_capacity(self.rom.widths.len() * 2); + for (i, &width) in self.rom.widths.iter().enumerate() { + let unpadded = unpadded_rows[rom_base + i]; + messages.push(BatchMessage::pull(memseg_args(width, Val::ZERO).to_vec())); + messages.push(BatchMessage::push( + memseg_args(width, Val::from_usize(unpadded)).to_vec(), + )); + } + let witness = self.witness_from_main(traces); + let proof = self.system.prove_batch( + &self.key, + vec![multi_stark::batch::ShardInput { + claims: vec![claim.clone()], + witness, + }], + messages, + ); + self.verify_batch(entry, args, output, &proof)?; + Ok((claim, proof)) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn copy_rows_matches_a_serial_copy() { + for len in [0, 1, 4 << 16, (4 << 16) + 1, (9 << 16) + 12345] { + let values: Vec = (0..len as u64).map(Val::from_u64).collect(); + assert_eq!(copy_rows(&values), values); + } + } +} diff --git a/crates/aiur/src/trace/stark/gpu.rs b/crates/aiur/src/trace/stark/gpu.rs new file mode 100644 index 000000000..848e1198f --- /dev/null +++ b/crates/aiur/src/trace/stark/gpu.rs @@ -0,0 +1,661 @@ +//! Stage-one population on the GPU (`AIUR_GPU_TRACE=generated`). +//! +//! Function circuits whose population plans need no host-only state are +//! filled on the device by `cuda/population.cu`, which interprets the same +//! compiled plans as the host writer ([`crate::trace::plan`]) and applies the +//! same placement. They reach multi-stark as generated traces: the host +//! neither builds nor uploads their rows, and graph lookups regenerate tiles +//! on the device. The record tables those rows read are uploaded once per +//! proof, so the execution record can be dropped before proving. Other +//! circuits (memory, fixed tables, plans with stores, loads or stream hints) +//! keep host rows. Proof bytes are identical to host population. +use super::*; +use crate::{ + Execution, + trace::{ + Action, + plan::device::{Constants, Encoded, Target}, + }, +}; +use multi_stark::{cuda::DeviceTraceView, witness::TraceGenerator}; +use std::{ffi::c_void, sync::Arc}; + +const POLY_CONST: u32 = 0; +const POLY_VAR: u32 = 1; +const POLY_ADD: u32 = 2; +const POLY_SUB: u32 = 3; +const POLY_MUL: u32 = 4; + +#[repr(C)] +#[derive(Clone, Copy)] +struct AiurFunction { + code: *const u32, + constants: *const u64, + rows: *const u64, + multiplicities: *const u64, + count: u64, + first: u64, + code_len: u32, + scratch: u32, + inputs: u32, + outputs: u32, + stride: u32, + pad: u32, +} + +#[repr(C)] +#[derive(Clone, Copy)] +struct AiurCallee { + rows: *const u64, + index: *const u32, + count: u64, + mask: u32, + inputs: u32, + outputs: u32, + stride: u32, +} + +#[repr(C)] +#[derive(Clone, Copy)] +struct AiurCircuit { + members: *const AiurFunction, + callees: *const AiurCallee, + real: u64, + member_count: u32, + width: u32, + scratch: u32, + pad: u32, +} + +#[repr(C)] +#[derive(Clone, Copy, Default)] +struct AiurPopulationError { + code: i32, + op: u32, + row: u64, +} + +unsafe extern "C" { + fn aiur_gpu_population_threads() -> u64; + fn aiur_gpu_malloc( + device: i32, + bytes: usize, + output: *mut *mut c_void, + ) -> i32; + fn aiur_gpu_free(device: i32, pointer: *mut c_void) -> i32; + fn aiur_gpu_upload( + device: i32, + destination: *mut c_void, + source: *const c_void, + bytes: usize, + ) -> i32; + fn aiur_gpu_download( + device: i32, + destination: *mut c_void, + source: *const c_void, + bytes: usize, + ) -> i32; + fn aiur_gpu_canonicalize(device: i32, words: *mut u64, count: u64) -> i32; + fn aiur_gpu_build_index( + device: i32, + rows: *const u64, + count: u64, + inputs: u32, + row_stride: u32, + index: *mut u32, + mask: u32, + ) -> i32; + fn aiur_gpu_populate( + device: i32, + circuit: *const AiurCircuit, + output: *mut u64, + base: u64, + first: u64, + rows: u64, + height: u64, + scratch: *mut u64, + error: *mut AiurPopulationError, + ) -> i32; + fn aiur_gpu_error_string(status: i32) -> *const std::ffi::c_char; +} + +fn check(status: i32, what: &str) -> Result<(), String> { + if status == 0 { + return Ok(()); + } + // SAFETY: the CUDA runtime returns a static NUL-terminated string. + let message = + unsafe { std::ffi::CStr::from_ptr(aiur_gpu_error_string(status)) }; + Err(format!("{what}: CUDA error {status} ({})", message.to_string_lossy())) +} + +/// A device allocation, freed on drop. +struct Buffer { + device: i32, + pointer: *mut c_void, +} +// SAFETY: the allocation is plain device memory owned by this value. +unsafe impl Send for Buffer {} +unsafe impl Sync for Buffer {} +impl Buffer { + fn new(device: i32, bytes: usize) -> Result { + let mut pointer = std::ptr::null_mut(); + // SAFETY: the out-pointer is valid for writing. + check( + unsafe { aiur_gpu_malloc(device, bytes, &raw mut pointer) }, + "GPU population allocation", + )?; + Ok(Self { device, pointer }) + } + fn upload(device: i32, data: &[T]) -> Result { + let buffer = Self::new(device, std::mem::size_of_val(data))?; + buffer.write(0, data)?; + Ok(buffer) + } + /// Copies `data` to byte offset `offset`. + fn write(&self, offset: usize, data: &[T]) -> Result<(), String> { + // SAFETY: callers stay within the allocation; `data` is host memory. + check( + unsafe { + aiur_gpu_upload( + self.device, + self.pointer.cast::().add(offset).cast(), + data.as_ptr().cast(), + std::mem::size_of_val(data), + ) + }, + "GPU population upload", + ) + } + fn as_ptr(&self) -> *mut T { + self.pointer.cast() + } +} +impl Drop for Buffer { + fn drop(&mut self) { + // SAFETY: allocated by `aiur_gpu_malloc` on this device, freed once. + unsafe { aiur_gpu_free(self.device, self.pointer) }; + } +} + +/// A function's encoded plan with its placement, ready to upload. +struct Program { + code: Vec, + scratch: u32, + inputs: u32, + outputs: u32, +} + +/// Device encodings of a backend's population plans, built once. Functions +/// the device cannot fill are `None`; a circuit is filled on the device only +/// when all of its members are encoded. +pub(super) struct DevicePlans { + programs: Vec>, + constants: Vec, + /// Call targets: callee slot to function index. + callees: Vec, + pub(super) circuits: Vec, +} + +fn map_kind(name: &str) -> Option { + Some(match name { + "UInt8::from_field" => 0, + "UInt8::raw_bit_decomposition" => 1, + "UInt8::range_pair" => 2, + "UInt8::raw_xor" => 3, + "UInt8::raw_and" => 4, + "UInt8::raw_or" => 5, + "UInt8::raw_lt" => 6, + "UInt8::raw_add" => 7, + "UInt8::raw_sub" => 8, + "UInt8::raw_mul" => 9, + "UInt8::raw_xor_split4" => 10, + "UInt8::raw_xor_split7" => 11, + "UInt8::raw_sum_byte" => 12, + _ => return None, + }) +} + +fn hint_kind(channel: &str) -> Option { + Some(match channel { + "u32.bytes" => 0, + "u32.sub" => 1, + "u32.add" => 2, + "u32.add3" => 3, + "u32.lt" => 4, + "bytes_le" => 5, + _ => return None, + }) +} + +fn polynomial( + p: &Polynomial, + constants: &mut Constants, + out: &mut Vec, +) -> Option<()> { + match p { + Polynomial::Const(value) => { + out.extend([POLY_CONST, constants.word(*value)? & 0x7fff_ffff]); + }, + Polynomial::Var(column) => { + out.extend([POLY_VAR, u32::try_from(*column).ok()?]); + }, + Polynomial::Add(xs) | Polynomial::Sub(xs) | Polynomial::Mul(xs) => { + polynomial(&xs[0], constants, out)?; + polynomial(&xs[1], constants, out)?; + out.extend([ + match p { + Polynomial::Add(_) => POLY_ADD, + Polynomial::Sub(_) => POLY_SUB, + _ => POLY_MUL, + }, + 0, + ]); + }, + } + Some(()) +} + +impl DevicePlans { + /// `None` unless `AIUR_GPU_TRACE=generated`, which requires device lookups. + pub(super) fn from_env( + backend: &Backend<'_, '_, B>, + ) -> Result, String> { + match std::env::var("AIUR_GPU_TRACE").as_deref() { + Ok("generated") => { + if !backend.gpu_lookup_only { + return Err( + "AIUR_GPU_TRACE=generated requires device lookups (unset AIUR_TRACE_ONLY_LOOKUPS=0)" + .into(), + ); + } + Ok(Some(Self::new(backend))) + }, + Ok("cpu") | Ok("") | Err(_) => Ok(None), + Ok(other) => { + Err(format!("AIUR_GPU_TRACE must be cpu or generated, not {other:?}")) + }, + } + } + + pub(super) fn new(backend: &Backend<'_, '_, B>) -> Self { + let plan = backend.plan; + let program = plan.program.program(); + let functions = program.functions.len(); + let mut constants = Constants::default(); + let mut callees = Vec::new(); + let mut slots = FxHashMap::default(); + let programs: Vec<_> = plan + .fills + .iter() + .enumerate() + .map(|(f, fill)| { + let placement = &backend.placements[plan.members[f]]; + let steps = &plan.artifact.functions[f].steps; + let mut call = |callable: usize| { + if callable >= functions { + map_kind(&program.maps.get(callable - functions)?.name) + .map(Target::Map) + } else { + let next = u32::try_from(callees.len()).ok()?; + let slot = *slots.entry(callable).or_insert_with(|| { + callees.push(callable); + next + }); + Some(Target::Call(slot)) + } + }; + let mut hint = |instruction: usize| { + steps.iter().find_map(|step| match &step.action { + Action::Hint { instruction: i, channel, .. } + if *i == instruction => + { + hint_kind(channel) + }, + _ => None, + }) + }; + let column = |c: usize| placement.columns[c]; + let Encoded { mut code, scratch, inputs, outputs } = + fill.encode(&mut call, &mut hint, &column, &mut constants)?; + code.push(u32::try_from(placement.selector).ok()?); + code.push(u32::try_from(placement.writes.len()).ok()?); + for write in &placement.writes { + let mut tokens = vec![]; + polynomial(&write.value, &mut constants, &mut tokens)?; + code.push(u32::try_from(write.column).ok()?); + code.push(u32::try_from(tokens.len() / 2).ok()?); + code.extend(tokens); + } + Some(Program { code, scratch, inputs, outputs }) + }) + .collect(); + let circuits: Vec = backend + .members + .iter() + .map(|members| { + !members.is_empty() && members.iter().all(|&f| programs[f].is_some()) + }) + .collect(); + Self { programs, constants: constants.values, callees, circuits } + } +} + +/// One proof's device-resident record tables and circuit descriptors. +pub(super) struct DeviceRecord { + device: i32, + circuits: Vec>, + heights: Vec, + widths: Vec, + _buffers: Vec, +} +// SAFETY: the raw pointers address device memory owned by `_buffers`. +unsafe impl Send for DeviceRecord {} +unsafe impl Sync for DeviceRecord {} + +impl DeviceRecord { + /// Uploads what the device circuits read from `record`: their member + /// queries and every callee's queries with an input index. + pub(super) fn upload( + backend: &Backend<'_, '_, B>, + plans: &DevicePlans, + record: &Execution, + device: i32, + ) -> Result { + let tables = &record.queries.tables; + let mut buffers = vec![]; + // Programs: every encoded plan back to back, and the constant pool. + let mut code: Vec = vec![]; + let mut offsets = vec![0; plans.programs.len()]; + for (f, program) in plans.programs.iter().enumerate() { + if let Some(program) = program { + offsets[f] = code.len(); + code.extend(&program.code); + } + } + let code_buffer = Buffer::upload(device, &code)?; + let constants = Buffer::upload(device, &plans.constants)?; + // Query tables, uploaded once per function from their storage chunks. + let mut rows = FxHashMap::default(); + let mut needed: Vec = plans.callees.clone(); + for (ci, &on) in plans.circuits.iter().enumerate() { + if on { + needed.extend(&backend.members[ci]); + } + } + needed.sort_unstable(); + needed.dedup(); + for &f in &needed { + let table = &tables[f]; + if table.static_map.is_some() { + return Err("GPU population cannot read a map's table".into()); + } + let (chunks, stride, per_chunk) = table.row_chunks(); + let count = table.len(); + let words = count.checked_mul(stride).ok_or("table size overflow")?; + let buffer = Buffer::new(device, words.max(1) * 8)?; + let mut done = 0; + for chunk in chunks { + let take = per_chunk.min(count - done); + if take == 0 { + break; + } + let values = B::words(&chunk[..take * stride]); + buffer.write(done * stride * 8, &values)?; + done += take; + } + if done != count { + return Err("query table storage ended early".into()); + } + // SAFETY: the buffer holds `words` words. + check( + unsafe { aiur_gpu_canonicalize(device, buffer.as_ptr(), words as u64) }, + "GPU population canonicalization", + )?; + let counts = &table.counts()[..count]; + if counts.iter().any(|&c| c >= Val::ORDER_U64) { + return Err("function count reaches field characteristic".into()); + } + let multiplicities = Buffer::upload(device, counts)?; + rows.insert(f, (buffer, multiplicities, stride)); + } + // Callee input indexes. + let mut callees = vec![]; + let mut indexes = vec![]; + for &f in &plans.callees { + let (inputs, outputs) = tables[f].widths(); + let (buffer, _, stride) = &rows[&f]; + let count = tables[f].len(); + let size = (count.max(1) * 2).next_power_of_two(); + let mask = + u32::try_from(size - 1).map_err(|_| "callee index overflow")?; + let index = Buffer::new(device, size * 4)?; + // SAFETY: `index` holds `size` words; `buffer` holds the table rows. + check( + unsafe { + aiur_gpu_build_index( + device, + buffer.as_ptr(), + count as u64, + inputs as u32, + *stride as u32, + index.as_ptr(), + mask, + ) + }, + "GPU population callee index", + )?; + callees.push(AiurCallee { + rows: buffer.as_ptr(), + index: index.as_ptr(), + count: count as u64, + mask, + inputs: inputs as u32, + outputs: outputs as u32, + stride: *stride as u32, + }); + indexes.push(index); + } + let callee_buffer = Buffer::upload(device, &callees)?; + // Circuit descriptors. + let mut circuits = vec![None; backend.system.circuits.len()]; + let mut heights = vec![0; backend.system.circuits.len()]; + let mut widths = vec![0; backend.system.circuits.len()]; + let mut descriptors = vec![]; + for (ci, &on) in plans.circuits.iter().enumerate() { + if !on { + continue; + } + let mut members = vec![]; + let mut first = 0u64; + let mut circuit_scratch = 0; + for &f in &backend.members[ci] { + let program = plans.programs[f].as_ref().expect("encoded member"); + let (buffer, multiplicities, stride) = &rows[&f]; + let count = tables[f].len() as u64; + members.push(AiurFunction { + // SAFETY: offsets index the uploaded code. + code: unsafe { code_buffer.as_ptr::().add(offsets[f]) }, + constants: constants.as_ptr(), + rows: buffer.as_ptr(), + multiplicities: multiplicities.as_ptr(), + count, + first, + code_len: program.code.len() as u32, + scratch: program.scratch, + inputs: program.inputs, + outputs: program.outputs, + stride: *stride as u32, + pad: 0, + }); + first += count; + circuit_scratch = circuit_scratch.max(program.scratch); + } + let real = usize::try_from(first).map_err(|_| "row count overflow")?; + let height = if real == 0 { + 0 + } else { + real.checked_next_power_of_two().ok_or("trace height overflow")? + }; + let width = backend.system.circuits[ci].main_width; + let member_buffer = Buffer::upload(device, &members)?; + circuits[ci] = Some(AiurCircuit { + members: member_buffer.as_ptr(), + callees: callee_buffer.as_ptr(), + real: first, + member_count: members.len() as u32, + width: width as u32, + scratch: circuit_scratch, + pad: 0, + }); + heights[ci] = height; + widths[ci] = width; + descriptors.push(member_buffer); + } + buffers.push(code_buffer); + buffers.push(constants); + for (_, (rows, multiplicities, _)) in rows { + buffers.push(rows); + buffers.push(multiplicities); + } + buffers.extend(indexes); + buffers.push(callee_buffer); + buffers.extend(descriptors); + Ok(Self { device, circuits, heights, widths, _buffers: buffers }) + } + + /// The padded height of a device circuit, if `ci` is one. + pub(super) fn height(&self, ci: usize) -> Option { + self.circuits[ci].map(|_| self.heights[ci]) + } + + /// Fills `rows` rows of circuit `ci`'s shard (`base`, `height`) from shard + /// row `first` into device memory at `output`. + fn populate( + &self, + ci: usize, + output: *mut u64, + base: usize, + first: usize, + rows: usize, + height: usize, + ) -> Result<(), String> { + let circuit = self.circuits[ci].as_ref().ok_or("not a device circuit")?; + // SAFETY: plain query of the launch configuration. + let threads = unsafe { aiur_gpu_population_threads() }; + let scratch = Buffer::new( + self.device, + (threads * u64::from(circuit.scratch).max(1) * 8) as usize, + )?; + let error = Buffer::upload(self.device, &[AiurPopulationError::default()])?; + // SAFETY: device pointers come from this record's live buffers; the + // caller owns `rows * width` words at `output` on this device. + check( + unsafe { + aiur_gpu_populate( + self.device, + circuit, + output, + base as u64, + first as u64, + rows as u64, + height as u64, + scratch.as_ptr(), + error.as_ptr(), + ) + }, + "GPU population", + )?; + let mut status = [AiurPopulationError::default()]; + // SAFETY: `error` holds one value. + check( + unsafe { + aiur_gpu_download( + self.device, + status.as_mut_ptr().cast(), + error.as_ptr(), + std::mem::size_of::(), + ) + }, + "GPU population status", + )?; + let status = status[0]; + if status.code != 0 { + return Err(format!( + "GPU population of circuit {ci} failed at row {} (kernel {}): {}", + status.row, + status.op, + match status.code { + 1 => "active zero denominator", + 2 => "no matching trace arm", + 3 => "rejected pattern actually matches", + 4 => "no table entry for map input", + 5 => "missing recorded callee", + 6 => "invalid hint input", + _ => "invalid device plan encoding", + } + )); + } + Ok(()) + } +} + +/// Rows `base..base + height` of a device circuit: one batch shard. +pub(super) struct DeviceTrace { + pub(super) record: Arc, + pub(super) circuit: usize, + pub(super) base: usize, + pub(super) height: usize, +} + +impl TraceGenerator for DeviceTrace { + fn height(&self) -> usize { + self.height + } + fn width(&self) -> usize { + self.record.widths[self.circuit] + } + fn write_rows(&self, first: usize, output: &mut [Val]) { + let width = self.width(); + assert_eq!(output.len() % width, 0, "partial generated row"); + let rows = output.len() / width; + let mut run = || -> Result<(), String> { + let tile = Buffer::new(self.record.device, output.len().max(1) * 8)?; + self.record.populate( + self.circuit, + tile.as_ptr(), + self.base, + first % self.height, + rows, + self.height, + )?; + // SAFETY: `Goldilocks` is `#[repr(transparent)]` over `u64`; the tile + // holds `output.len()` canonical words. + check( + unsafe { + aiur_gpu_download( + self.record.device, + output.as_mut_ptr().cast(), + tile.as_ptr(), + output.len() * 8, + ) + }, + "GPU population download", + ) + }; + run().unwrap_or_else(|error| panic!("{error}")); + } + fn write_device_rows(&self, view: DeviceTraceView<'_>) -> Result<(), String> { + if view.width() != self.width() || view.device_id() != self.record.device { + return Err("generated trace tile mismatch".into()); + } + self.record.populate( + self.circuit, + view.as_mut_ptr(), + self.base, + view.first_row() % self.height, + view.rows(), + self.height, + ) + } +} diff --git a/crates/aiur/src/trace/stark/grouping.rs b/crates/aiur/src/trace/stark/grouping.rs new file mode 100644 index 000000000..b3b08bb49 --- /dev/null +++ b/crates/aiur/src/trace/stark/grouping.rs @@ -0,0 +1,178 @@ +//! Physical groups are compiled by Lean; execution and memo keys retain the +//! original callable identities. Only row placement and lookup superposition +//! change. See Aiur.Optimized.Grouping for the selector and silence arguments. +use super::*; +use crate::trace::{GroupMember, GroupWrite}; + +pub(super) struct Placement { + pub grouped: bool, + pub circuit: usize, + pub columns: Vec, + pub selector: usize, + pub writes: Vec, +} + +impl Placement { + pub fn finish(&self, row: &mut [Val], count: u64) { + row[self.selector] = Val::ONE; + for write in &self.writes { + row[write.column] = write.value.eval(row, NativeField::::default()); + } + *row.last_mut().unwrap() = Val::from_u64(count); + } +} + +pub(super) fn build( + plan: &TracePlan<'_, B>, + rom: &rom::Rom, + inputs: &mut Vec>, + names: &mut Vec, +) -> Result, String> { + let mut grouped = FxHashMap::default(); + let mut placements: Vec> = + (0..plan.artifact.chips.len()).map(|_| None).collect(); + for (gi, group) in plan.artifact.groups.iter().enumerate() { + if group.members.len() < 2 || group.width >= u32::MAX as usize { + return Err("invalid function group size".into()); + } + for member in &group.members { + if grouped.insert(member.name.as_str(), gi).is_some() { + return Err("function appears in multiple groups".into()); + } + } + } + let mut emitted = vec![false; plan.artifact.groups.len()]; + for (ci, chip) in plan.artifact.chips.iter().enumerate() { + if let Some(&gi) = grouped.get(chip.name.as_str()) { + if emitted[gi] { + continue; + } + emitted[gi] = true; + let group = &plan.artifact.groups[gi]; + for member in &group.members { + let original = plan + .artifact + .chips + .iter() + .position(|c| c.name == member.name) + .ok_or("unknown grouped function chip")?; + let source = &plan.artifact.chips[original]; + validate_member(plan, group.width, member, source)?; + placements[original] = Some(Placement { + grouped: true, + circuit: inputs.len(), + columns: member.columns.clone(), + selector: member.selector, + writes: member.writes.clone(), + }); + } + for p in group + .constraints + .iter() + .chain(&group.receive) + .chain(std::iter::once(&group.activation)) + .chain( + group + .sends + .iter() + .flat_map(|s| std::iter::once(&s.enable).chain(&s.args)), + ) + { + p.validate(group.width, plan.program.field)?; + } + let mut constraints: Vec<_> = + group.constraints.iter().map(lower).collect(); + constraints + .push((constant(1) - lower(&group.activation)) * main_var(group.width)); + let mut lookups = vec![Lookup::pull( + main_var(group.width), + group.receive.iter().map(lower).collect(), + )]; + lookups.extend(group.sends.iter().map(|s| { + Lookup::push(lower(&s.enable), s.args.iter().map(lower).collect()) + })); + inputs.push(CircuitInputs { + main_width: group.width + 1, + constraints, + lookups, + ..Default::default() + }); + names.push(group.name.clone()); + continue; + } + if chip.width >= u32::MAX as usize { + return Err("too many circuit columns".into()); + } + placements[ci] = Some(Placement { + grouped: false, + circuit: inputs.len(), + columns: (0..chip.width).collect(), + selector: chip.activation, + writes: vec![], + }); + let mut args = + vec![constant(CALL), constant(plan.callables[&chip.name] as u64)]; + args.extend(chip.inputs.iter().map(|&i| main_var(i))); + args.extend(chip.output.iter().map(lower)); + let mut lookups = vec![Lookup::pull(main_var(chip.width), args)]; + for send in &chip.sends { + let mut args = + vec![constant(CALL), constant(plan.callables[&send.channel] as u64)]; + args.extend(send.args.iter().map(lower)); + args.extend(send.result.iter().map(|&i| main_var(i))); + lookups.push(Lookup::push(lower(&send.enable), args)); + } + for cell in &chip.memory { + lookups.push(rom.access(cell)?); + } + inputs.push(CircuitInputs { + main_width: chip.width + 1, + constraints: chip + .constraints + .iter() + .map(lower) + .chain([ + (constant(1) - main_var(chip.activation)) * main_var(chip.width) + ]) + .collect(), + lookups, + ..Default::default() + }); + names.push(chip.name.clone()); + } + if emitted.contains(&false) { + return Err("unknown function group members".into()); + } + placements + .into_iter() + .map(|p| p.ok_or_else(|| "missing function placement".into())) + .collect() +} + +fn validate_member( + plan: &TracePlan<'_, B>, + width: usize, + member: &GroupMember, + source: &crate::trace::Chip, +) -> Result<(), String> { + if member.columns.len() != source.width + || member.selector >= width + || member.columns[source.activation] != member.selector + { + return Err("invalid grouped member layout".into()); + } + let mut used = member.columns.clone(); + used.sort_unstable(); + used.dedup(); + if used.len() != member.columns.len() || used.iter().any(|&c| c >= width) { + return Err("non-injective group column mapping".into()); + } + for write in &member.writes { + if write.column >= width || used.contains(&write.column) { + return Err("group message column aliases a source column".into()); + } + write.value.validate(width, plan.program.field)?; + used.push(write.column); + } + Ok(()) +} diff --git a/crates/aiur/src/trace/stark/planning.rs b/crates/aiur/src/trace/stark/planning.rs new file mode 100644 index 000000000..a0e330307 --- /dev/null +++ b/crates/aiur/src/trace/stark/planning.rs @@ -0,0 +1,553 @@ +//! Shared resource planning for IxVM and recursive proofs. The model follows +//! multi-stark's allocation phases; it is an estimate, not an allocator limit. +use super::*; +use multi_stark::batch::Retention; +use serde::{Deserialize, Serialize}; + +#[derive( + Clone, Copy, Debug, Default, Deserialize, Serialize, PartialEq, Eq, +)] +#[serde(rename_all = "lowercase")] +pub enum RetentionPolicy { + Retain, + Regenerate, + #[default] + Auto, +} + +/// Committed cells (stage-one, stage-two and quotient columns over padded +/// rows) per trace shard that a CUDA prover plans to unless told otherwise. +/// This is the legacy lanes' `AIUR_TRACE_SHARD_MAX_CELLS` default, sized for +/// a 96 GB device: one such shard of the recursive verifier peaks near 33 GB. +pub const DEFAULT_DEVICE_CELLS: u64 = 1_500_000_000; + +#[derive(Clone, Debug, Default, Deserialize, Serialize)] +#[serde(default, deny_unknown_fields)] +pub struct Options { + pub max_rows: Option, + pub max_ram_bytes: Option, + pub retention: RetentionPolicy, + pub device: Option, + /// Device-residency bound in committed cells per shard. CUDA builds + /// default to `AIUR_TRACE_SHARD_MAX_CELLS`, then [`DEFAULT_DEVICE_CELLS`]; + /// CPU builds apply it only when given. + pub max_cells: Option, +} +impl Options { + pub fn read( + path: Option<&String>, + rows: Option<&String>, + retention: Option<&String>, + ) -> Result { + let mut result = if let Some(path) = path { + serde_json::from_slice(&std::fs::read(path).map_err(|e| e.to_string())?) + .map_err(|e| e.to_string())? + } else { + Self::default() + }; + if path.is_none() { + result.max_rows = rows + .map(|s| s.parse::().map_err(|e| e.to_string())) + .transpose()? + .filter(|&n| n != 0); + result.retention = match retention.map(String::as_str).unwrap_or("auto") { + "auto" => RetentionPolicy::Auto, + "retain" => RetentionPolicy::Retain, + "regenerate" => RetentionPolicy::Regenerate, + _ => return Err("retention must be auto, retain or regenerate".into()), + }; + } + result.validate()?; + Ok(result) + } + pub fn validate(&self) -> Result<(), String> { + if self.max_rows.is_some_and(|n| n == 0 || !n.is_power_of_two()) { + return Err("shard rows must be a positive power of two".into()); + } + if self.max_ram_bytes == Some(0) { + return Err("RAM budget must be positive".into()); + } + if self.device.is_some_and(|d| d < 0) { + return Err("negative CUDA device".into()); + } + if self.max_cells == Some(0) { + return Err("device cell budget must be positive".into()); + } + #[cfg(not(feature = "cuda"))] + if self.device.is_some() { + return Err("CUDA device requested from a CPU build".into()); + } + Ok(()) + } + + /// The committed-cell bound each shard is planned to, if any. A CUDA + /// prover always runs on a device, so it is bounded even without an + /// explicit device index; CPU proving is bounded only on request. + pub fn device_cells(&self) -> Result, String> { + if self.max_cells.is_some() || !cfg!(feature = "cuda") { + return Ok(self.max_cells); + } + match std::env::var("AIUR_TRACE_SHARD_MAX_CELLS") { + Ok(value) => { + value.parse::().ok().filter(|&n| n > 0).map(Some).ok_or_else( + || "AIUR_TRACE_SHARD_MAX_CELLS must be a positive integer".into(), + ) + }, + Err(std::env::VarError::NotPresent) => Ok(Some(DEFAULT_DEVICE_CELLS)), + Err(error) => Err(format!("AIUR_TRACE_SHARD_MAX_CELLS: {error}")), + } + } +} + +pub fn available_memory() -> Option { + let text = std::fs::read_to_string("/proc/meminfo").ok()?; + let host = text + .lines() + .find_map(|l| { + l.strip_prefix("MemAvailable:") + .and_then(|s| s.split_whitespace().next()?.parse::().ok()) + })? + .checked_mul(1024)?; + // Respect a container limit when cgroup v2 is mounted at its namespace root. + let container = std::fs::read_to_string("/sys/fs/cgroup/memory.max") + .ok() + .and_then(|s| s.trim().parse::().ok()) + .zip( + std::fs::read_to_string("/sys/fs/cgroup/memory.current") + .ok() + .and_then(|s| s.trim().parse::().ok()), + ) + .map(|(limit, used)| limit.saturating_sub(used)); + Some(container.map_or(host, |n| n.min(host))) +} +pub fn resident_memory() -> u64 { + std::fs::read_to_string("/proc/self/status") + .ok() + .and_then(|s| { + s.lines().find_map(|l| { + l.strip_prefix("VmRSS:") + .and_then(|v| v.split_whitespace().next()?.parse::().ok()) + }) + }) + .unwrap_or(0) + .saturating_mul(1024) +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct BatchPlan { + pub max_rows: usize, + pub shards: usize, + pub retention: RetentionPolicy, + pub budget_bytes: u64, + pub stage1_cells: u64, + pub generation_peak_bytes: u64, + pub proving_peak_bytes: u64, + pub fits: bool, + pub suggested_parts: usize, + /// Committed cells of the largest shard, and the device bound it was + /// planned against. + #[serde(default)] + pub shard_cells: u64, + #[serde(default)] + pub device_cells: Option, +} + +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)] +pub struct RecordShape { + pub heights: Vec, + pub memory_intervals: Vec<(u64, u64, u64)>, +} + +#[derive(Clone, Debug, Serialize)] +pub struct StreamResources { + pub retention: RetentionPolicy, + pub peak_bytes: u64, + pub budget_bytes: u64, + pub fits: bool, +} +impl BatchPlan { + pub fn retention(&self) -> Retention { + match self.retention { + RetentionPolicy::Retain => Retention::Retain, + _ => Retention::Regenerate, + } + } +} + +fn padded(n: usize) -> Result { + if n == 0 { + Ok(0) + } else { + n.checked_next_power_of_two().ok_or_else(|| "trace height overflow".into()) + } +} +fn bounded(n: u128) -> u64 { + n.min(u128::from(u64::MAX)) as u64 +} +fn margin(n: u128) -> u128 { + n.saturating_mul(5).div_ceil(4) +} + +impl Backend<'_, '_, B> { + /// Multiple records share a batch transcript, but only one record's input + /// matrices are resident at a time. Retained commitments accumulate across + /// *all* records, so per-record retention decisions would undercount RAM. + /// Shared artifacts and execution storage are charged by the controller. + pub fn plan_stream( + &self, + records: &[(&[usize], usize)], + options: &Options, + ) -> Result { + options.validate()?; + if records.is_empty() { + return Err("stream has no records".into()); + } + let budget = options.max_ram_bytes.unwrap_or(8 << 30); + let mut regenerated_peak = 0; + let mut retained_total = 0; + let mut shards = 0usize; + for &(heights, rows) in records { + let plan = self.plan_heights( + heights, + &Options { + max_rows: Some(rows), + retention: RetentionPolicy::Regenerate, + ..options.clone() + }, + 0, + )?; + if plan.max_rows != rows { + return Err("stream rows changed during planning".into()); + } + shards = + shards.checked_add(plan.shards).ok_or("stream shard overflow")?; + regenerated_peak = regenerated_peak + .max(u128::from(plan.proving_peak_bytes)) + .max(u128::from(plan.generation_peak_bytes)); + let (_, retained, _) = self.prove_allocation(heights, rows); + retained_total += retained * plan.shards as u128; + } + // For several shards, conservatively include the current commitment in + // both terms. For one shard, round two needs exactly the same workspace + // whether its commitment is retained or rebuilt. + let retained_peak = if shards == 1 { + regenerated_peak + } else { + regenerated_peak + margin(retained_total) + }; + let retention = match options.retention { + _ if self.requires_regeneration(shards) => RetentionPolicy::Regenerate, + RetentionPolicy::Auto if retained_peak <= u128::from(budget) => { + RetentionPolicy::Retain + }, + RetentionPolicy::Auto => RetentionPolicy::Regenerate, + policy => policy, + }; + let peak = if retention == RetentionPolicy::Retain { + retained_peak + } else { + regenerated_peak + }; + Ok(StreamResources { + retention, + peak_bytes: bounded(peak), + budget_bytes: budget, + fits: peak <= u128::from(budget) && shards <= 65536, + }) + } + + /// The fixed-table floor plus the caller's artifact/setup residency. An + /// environment split cannot shrink these allocations. + pub fn plan_fixed( + &self, + options: &Options, + resident: u64, + ) -> Result { + let heights: Vec<_> = + self.system.circuits.iter().map(|c| c.preprocessed_height).collect(); + self.plan_heights(&heights, options, resident) + } + + /// Plan from the record before allocating the stage-one matrices. The RSS + /// term includes the caller's advice/program residency and execution record. + pub fn plan_batch( + &self, + record: &Execution, + options: &Options, + ) -> Result { + self.plan_record(record, options, resident_memory()) + } + + /// Resident controllers charge shared artifacts and execution records to + /// their pool; the workspace plan receives only residency not charged there. + pub fn plan_record( + &self, + record: &Execution, + options: &Options, + resident: u64, + ) -> Result { + options.validate()?; + self.plan_heights(&self.record_shape(record)?.heights, options, resident) + } + + pub fn record_shape( + &self, + record: &Execution, + ) -> Result { + let mut heights = Vec::new(); + for members in &self.members { + heights.push(padded( + members.iter().map(|&i| record.queries.tables[i].len()).sum(), + )?); + } + heights.extend( + self + .system + .circuits + .iter() + .skip(heights.len()) + .take(self.tables.len()) + .map(|c| c.preprocessed_height), + ); + let memory_start = heights.len(); + let mut counts = std::collections::BTreeMap::::new(); + for entry in record.memory.iter() { + *counts.entry(entry.cell.value.len()).or_default() += 1; + } + let mut memory_intervals = Vec::new(); + for c in &self.system.circuits[memory_start..] { + let width = c.main_width - 3; + let indices = record.memory.indices_for_width(width); + if let Some(&first) = indices.first() { + let start = record.memory.get(first).unwrap().address as u64; + let end = start + .checked_add(indices.len() as u64) + .ok_or("ROM boundary overflow")?; + memory_intervals.push((width as u64, start, end)); + } + heights + .push(padded(counts.get(&(c.main_width - 3)).copied().unwrap_or(0))?); + } + Ok(RecordShape { heights, memory_intervals }) + } + + pub fn plan_heights( + &self, + heights: &[usize], + options: &Options, + resident: u64, + ) -> Result { + options.validate()?; + if heights.len() != self.system.circuits.len() + || heights.iter().any(|&h| h != 0 && !h.is_power_of_two()) + { + return Err("invalid planning heights".into()); + } + let budget = options + .max_ram_bytes + .or_else(|| available_memory().map(|n| n / 100 * 85)) + .unwrap_or(8 << 30) + .max(1); + if heights + .iter() + .zip(&self.system.circuits) + .any(|(&h, c)| c.preprocessed_height != 0 && h != c.preprocessed_height) + { + return Err("planning changed a fixed table's height".into()); + } + let tallest = heights + .iter() + .zip(&self.system.circuits) + .filter(|(_, c)| c.preprocessed_height == 0) + .map(|(&h, _)| h) + .max() + .unwrap_or(1) + .max(1); + let cells: u128 = heights + .iter() + .zip(&self.system.circuits) + .map(|(&h, c)| h as u128 * c.main_width as u128) + .sum(); + // Row descriptors and the ROM inverse index are temporary population data. + let descriptors: u128 = heights.iter().map(|&h| h as u128 * 32).sum(); + let generation = margin(u128::from(resident) + cells * 8 + descriptors); + let device_cells = options.device_cells()?; + let mut rows = options.max_rows.unwrap_or(tallest).min(tallest); + loop { + let shards = tallest.div_ceil(rows); + let shard_cells = self.shard_committed_cells(heights, rows); + let (mut single, retained, prep) = self.prove_allocation(heights, rows); + if cfg!(feature = "cuda") { + single = self.device_host_allocation( + heights, + rows, + shards, + options.retention == RetentionPolicy::Regenerate, + ); + } + // Keep the observed RSS in this estimate even though the caller drops + // its record. This conservatively covers artifact/advice residency and + // allocator pages that are not returned to the operating system. + let base = u128::from(resident) + cells * 8 + prep; + let regenerated_peak = margin(base + single); + let retained_peak = + margin(base + single + retained * shards.saturating_sub(1) as u128); + let retention = match options.retention { + _ if self.requires_regeneration(shards) => RetentionPolicy::Regenerate, + RetentionPolicy::Auto if retained_peak <= u128::from(budget) => { + RetentionPolicy::Retain + }, + RetentionPolicy::Auto => RetentionPolicy::Regenerate, + x => x, + }; + let peak = if retention == RetentionPolicy::Retain { + retained_peak + } else { + regenerated_peak + }; + // Halving rows also bounds what one shard keeps on the device. + let fits = generation.max(peak) <= u128::from(budget) + && shards <= 65536 + && device_cells.is_none_or(|limit| shard_cells <= u128::from(limit)); + if fits || rows == 1 || shards >= 65536 || generation > u128::from(budget) + { + return Ok(BatchPlan { + max_rows: rows, + shards, + retention, + budget_bytes: budget, + stage1_cells: bounded(cells), + generation_peak_bytes: bounded(generation), + proving_peak_bytes: bounded(peak), + fits, + suggested_parts: usize::try_from( + generation.max(peak).div_ceil(u128::from(budget)), + ) + .unwrap_or(usize::MAX) + .max(1), + shard_cells: bounded(shard_cells), + device_cells, + }); + } + rows /= 2; + } + } + + /// Committed cells of the first (largest) shard: every function or memory + /// circuit contributes at most `rows` padded rows, fixed tables their full + /// domain. Counts stage-one, stage-two and quotient (extension) columns. + fn shard_committed_cells(&self, heights: &[usize], rows: usize) -> u128 { + heights + .iter() + .zip(&self.system.circuits) + .map(|(&height, c)| { + let n = + if c.preprocessed_height == 0 { height.min(rows) } else { height }; + n as u128 + * (c.main_width + c.stage_2_width + 2 * c.quotient_degree()) as u128 + }) + .sum() + } + + pub(super) fn prove_allocation( + &self, + heights: &[usize], + rows: usize, + ) -> (u128, u128, u128) { + let b = 1u128 << self.parameters.log_blowup; + let ( + mut witness, + mut lde, + mut lookups, + mut messages, + mut stage2, + mut committed, + mut prep, + mut tallest, + ) = (0u128, 0, 0, 0, 0, 0, 0, 0); + for (&height, c) in heights.iter().zip(&self.system.circuits) { + let n = if c.preprocessed_height == 0 { height.min(rows) } else { height } + as u128; + if n == 0 { + continue; + } + tallest = tallest.max(n); + let count = c.num_lookups as u128; + let args: u128 = + c.graph.lookups.iter().map(|l| l.args.len() as u128).sum(); + let main = c.main_width as u128; + witness += 8 * n * (main + count + args) + + n + * std::mem::size_of::>() + as u128; + lde += 8 * b * n * main; + lookups += 8 * n * (count + args); + messages += 32 * n * count; + stage2 += 8 * n * c.stage_2_width as u128; + committed += 8 + * b + * n + * (main + c.stage_2_width as u128 + 2 * c.quotient_degree() as u128); + prep += 8 + * (1 + b) + * c.preprocessed_width as u128 + * c.preprocessed_height as u128 + + 64 * b * c.preprocessed_height as u128; + } + let h = b * tallest; + let retained = lde + 64 * h + lookups; + let phase2 = retained + messages + stage2; + let open = committed + 192 * h + 160 * h + 88 * h; + (witness.max(phase2).max(open), retained, prep) + } + + /// Host workspace when the CUDA prover commits, builds stage two and opens + /// on the device; the CPU phases of [`Self::prove_allocation`] would + /// overstate it several times. The host holds witnesses: shard traces and, + /// unless the device derives them, their lookup buffers. A retained single + /// shard takes its trace from the source matrices the caller already + /// counts; otherwise the supplier copies it. With several shards, at most + /// the shard being committed or proven and the next one are held, and + /// shards after the first contain only the rows of taller circuits beyond + /// the earlier shards. Upload staging is a constant. Retained multi-shard + /// commitments keep the CPU model, since device pressure can spill them to + /// the host. The large recursive verifier measured 25.0 GiB (host lookups) + /// and 10.5 GiB (device lookups) peak RSS for one shard. + pub(super) fn device_host_allocation( + &self, + heights: &[usize], + rows: usize, + shards: usize, + regenerate: bool, + ) -> u128 { + // Witness bytes of the first two shards: (trace, lookups) for each. + let mut witness = [(0u128, 0u128); 2]; + for (&height, c) in heights.iter().zip(&self.system.circuits) { + let args: u128 = + c.graph.lookups.iter().map(|l| l.args.len() as u128).sum(); + let lookup_row = if self.gpu_lookup_only { + 0 + } else { + 8 * (c.num_lookups as u128 + args) + + std::mem::size_of::>() + as u128 + }; + for (shard, (trace, lookups)) in witness.iter_mut().enumerate() { + let n = if c.preprocessed_height == 0 { + height.saturating_sub(shard * rows).min(rows) + } else { + height + } as u128; + *trace += 8 * n * c.main_width as u128; + *lookups += n * lookup_row; + } + } + let staging = 256 << 20; + let [(trace, lookups), (next_trace, next_lookups)] = witness; + match (shards, regenerate) { + (1, false) => lookups + staging, + (1, true) => trace + lookups + staging, + _ => trace + lookups + next_trace + next_lookups + staging, + } + } +} diff --git a/crates/aiur/src/trace/stark/profile.rs b/crates/aiur/src/trace/stark/profile.rs new file mode 100644 index 000000000..838af83be --- /dev/null +++ b/crates/aiur/src/trace/stark/profile.rs @@ -0,0 +1,68 @@ +//! Optional wall-clock diagnostics, compiled out of ordinary trace generation. +//! Circuit spans overlap under Rayon and must not be summed as wall time. +use std::{ + sync::Mutex, + time::{Duration, Instant}, +}; + +/// Time adapter work around the cryptographic prover separately from row +/// generation. In particular, batch lookup reconstruction is not part of the +/// fused `generate` measurement. +pub(super) struct Span { + phase: &'static str, + start: Instant, + cells: usize, +} + +impl Span { + pub(super) fn new(phase: &'static str, cells: usize) -> Self { + Self { phase, start: Instant::now(), cells } + } +} + +impl Drop for Span { + fn drop(&mut self) { + eprintln!( + "{}", + serde_json::json!({"event": "aiur_prover_profile", "phase": self.phase, + "elapsed_seconds": self.start.elapsed().as_secs_f64(), "cells": self.cells}) + ); + } +} + +pub(super) struct Phases { + start: Instant, + last: Instant, + phases: Vec<(&'static str, f64)>, + circuits: Mutex>, +} + +impl Phases { + pub(super) fn new() -> Self { + let start = Instant::now(); + Self { start, last: start, phases: vec![], circuits: Mutex::new(vec![]) } + } + + pub(super) fn mark(&mut self, name: &'static str) { + let now = Instant::now(); + self.phases.push((name, (now - self.last).as_secs_f64())); + self.last = now; + } + + pub(super) fn circuit(&self, index: usize, elapsed: Duration) { + self.circuits.lock().unwrap().push((index, elapsed.as_secs_f64())); + } + + pub(super) fn finish(self, names: &[String], lookups: bool) { + let elapsed = self.start.elapsed().as_secs_f64(); + let mut circuits = self.circuits.into_inner().unwrap(); + circuits.sort_unstable_by_key(|(i, _)| *i); + let circuits: Vec<_> = + circuits.into_iter().map(|(i, seconds)| (&names[i], seconds)).collect(); + eprintln!( + "{}", + serde_json::json!({"event": "aiur_trace_profile", "host_lookups": lookups, + "elapsed_seconds": elapsed, "phases": self.phases, "circuits": circuits}) + ); + } +} diff --git a/crates/aiur/src/trace/stark/rom.rs b/crates/aiur/src/trace/stark/rom.rs new file mode 100644 index 000000000..cd502b4fd --- /dev/null +++ b/crates/aiur/src/trace/stark/rom.rs @@ -0,0 +1,145 @@ +//! One untyped payload chip per width, with local consecutive addresses. +//! The type-directed provenance proof interprets the words through the static +//! target type of each load. See Aiur/Memory/Partition.lean. +use super::*; +use crate::trace::MemoryLookup; + +pub(super) struct Rom { + pub(super) widths: Vec, +} + +impl Rom { + pub(super) fn new(plan: &TracePlan<'_, B>) -> Self { + if !plan.artifact.chips.iter().any(|c| !c.memory.is_empty()) { + return Self { widths: vec![] }; + } + let mut widths: Vec<_> = plan + .program + .memory_layouts + .values() + .map(|layout| layout.width()) + .collect(); + widths.sort_unstable(); + widths.dedup(); + Self { widths } + } + + pub(super) fn circuit_count(&self) -> usize { + self.widths.len() + } + + pub(super) fn access( + &self, + cell: &MemoryLookup, + ) -> Result>, String> { + // TracePlan already checks the static type's layout. After physical + // type erasure this view need not occur in the bytecode's type map. + let width = cell.values.len(); + if self.widths.binary_search(&width).is_err() { + return Err("unknown circuit ROM width".into()); + } + // Width explicitly separates messages whose payloads differ only by + // trailing zeros. Nominal types are static views of these same raw words. + let mut args = + vec![constant(ROM), constant(width as u64), lower(&cell.address)]; + args.extend(cell.values.iter().map(lower)); + Ok(Lookup::push(lower(&cell.enable), args)) + } + + pub(super) fn append_circuits( + &self, + circuits: &mut Vec>, + names: &mut Vec, + segmented: bool, + ) -> Result<(), String> { + for &payload_width in &self.widths { + // [multiplicity, is_real, width-local address, payload...]. + // Consecutive addresses in an active prefix prove functionality. + let width = payload_width + .checked_add(3) + .filter(|&w| w <= u32::MAX as usize) + .ok_or("ROM too wide")?; + let count = main_var(0); + let active = main_var(1); + let address = main_var(2); + let mut args = + vec![constant(ROM), constant(payload_width as u64), address.clone()]; + args.extend((3..width).map(main_var)); + let transition = Expr::IsTransition * Expr::main_next(1); + let mut constraints = vec![ + active.clone() * (active.clone() - constant(1)), + count.clone() * (constant(1) - active.clone()), + transition.clone() * (active.clone() - constant(1)), + transition * (Expr::main_next(2) - address.clone() - constant(1)), + ]; + let mut lookups = vec![Lookup::pull(count, args)]; + if segmented { + // Each contiguous run leaves its start/end in the batch balance. + // Authenticated closure messages and the height bound tile [0, N). + lookups.push(Lookup::push( + active.clone(), + vec![ + constant(MEMSEG), + constant(payload_width as u64), + address.clone(), + ], + )); + lookups.push(Lookup::pull( + active, + vec![ + constant(MEMSEG), + constant(payload_width as u64), + address + constant(1), + ], + )); + } else { + constraints.push(Expr::IsFirstRow * address); + } + circuits.push(CircuitInputs { + main_width: width, + constraints, + lookups, + ..Default::default() + }); + names.push(format!("")); + } + Ok(()) + } + + /// Memory's private interning path already guarantees unique payloads and + /// consecutive addresses in each width bucket. The backend validates the + /// recorded types and counts before reading these immutable rows directly. + pub(super) fn witness( + &self, + record: &Execution, + index: usize, + ) -> Result, String> { + let bucket = record.memory.indices_for_width(self.widths[index]); + let width = self.widths[index] + 3; + let mut trace = empty_trace(bucket.len(), width)?; + for (&index, row) in bucket.iter().zip(trace.values.chunks_mut(width)) { + let cell = record.memory.get(index).unwrap(); + row[0] = Val::from_u64(cell.multiplicity); + row[1] = Val::ONE; + row[2] = Val::from_usize(cell.address); + for (dest, &value) in row[3..].iter_mut().zip(cell.cell.value) { + *dest = B::into_stark(value); + } + } + Ok(trace) + } +} + +fn empty_trace( + rows: usize, + width: usize, +) -> Result, String> { + let height = if rows == 0 { + 0 + } else { + rows.checked_next_power_of_two().ok_or("ROM height overflow")? + }; + let values = + Val::zero_vec(height.checked_mul(width).ok_or("ROM size overflow")?); + Ok(RowMajorMatrix::new(values, width)) +} diff --git a/crates/aiur/src/trace/stark/tables.rs b/crates/aiur/src/trace/stark/tables.rs new file mode 100644 index 000000000..e49cfb250 --- /dev/null +++ b/crates/aiur/src/trace/stark/tables.rs @@ -0,0 +1,146 @@ +//! Fixed maps of equal row count share a chip. Each original input/output +//! table has its own immutable column span and each map its own multiplicity. +use super::*; + +pub(super) struct FixedTable { + maps: Vec, + height: usize, +} + +pub(super) fn fixed_tables( + plan: &TracePlan<'_, B>, + circuits: &mut Vec>, + names: &mut Vec, + log_blowup: usize, +) -> Result, String> { + let program = &plan.program.program; + let mut groups: Vec<(usize, Vec)> = vec![]; + for (id, map) in program.maps.iter().enumerate() { + if let Some((_, maps)) = groups.iter_mut().find(|(input, _)| { + program.tables[*input].rows.len() == program.tables[map.input].rows.len() + }) { + maps.push(id); + } else { + groups.push((map.input, vec![id])); + } + } + let mut result = vec![]; + for (input_id, maps) in groups { + let input = &program.tables[input_id]; + let real_height = input.rows.len(); + let height = + if real_height == 0 { 0 } else { real_height.next_power_of_two() }; + // Always keep a preprocessed column, even for a unit -> unit table. + let mut width = 1usize; + let mut columns: Vec<(usize, usize, usize)> = vec![]; + let mut lookups = vec![]; + let mut constraints = vec![]; + for (column, &mi) in maps.iter().enumerate() { + let map = &program.maps[mi]; + let input_width = + plan.program.inputs[program.functions.len() + mi].width(); + let output_width = + plan.program.outputs[program.functions.len() + mi].width(); + let mut offsets = [0; 2]; + for ((table, size), offset) in + [(map.input, input_width), (map.output, output_width)] + .into_iter() + .zip(&mut offsets) + { + *offset = if let Some((_, start, _)) = + columns.iter().find(|(id, _, _)| *id == table) + { + *start + } else { + let start = width; + width = + width.checked_add(size).ok_or("fixed table width overflow")?; + columns.push((table, start, size)); + start + }; + } + if width > u32::MAX as usize { + return Err("fixed table too wide".into()); + } + let mut args = + vec![constant(CALL), constant((program.functions.len() + mi) as u64)]; + // Empty maps cannot provide anything, including the zero message. + if height == 0 { + args.resize(2 + input_width + output_width, constant(0)); + constraints.push(main_var(column)); + } else { + args.extend( + (offsets[0]..offsets[0] + input_width) + .map(|i| Expr::preprocessed(i as u32)), + ); + args.extend( + (offsets[1]..offsets[1] + output_width) + .map(|i| Expr::preprocessed(i as u32)), + ); + } + lookups.push(Lookup::pull(main_var(column), args)); + } + let preprocessed = if height == 0 { + None + } else { + let mut values = Vec::with_capacity( + height.checked_mul(width).ok_or("fixed table size overflow")?, + ); + for row in 0..height { + // Duplicating a valid row preserves table membership. Only the + // original rows receive witness multiplicities. + let row = if row < real_height { row } else { 0 }; + values.push(Val::ONE); + for &(id, _, _) in &columns { + values.extend( + program.tables[id].rows[row].iter().copied().map(Val::from_u64), + ); + } + } + Some(RowMajorMatrix::new(values, width)) + }; + circuits.push(CircuitInputs { + main_width: maps.len(), + preprocessed, + constraints, + lookups, + // Linear fixed-table messages can share a cubic logUp step. Unlike + // function rows, their height is known here: trade an extra quotient + // column for fewer accumulators only when the FFT work decreases. + lookup_group_size: if pair_lookups(maps.len(), height, log_blowup) { + 2 + } else { + 1 + }, + ..Default::default() + }); + names.push(format!("", input.name)); + result.push(FixedTable { maps, height }); + } + Ok(result) +} + +fn pair_lookups(count: usize, height: usize, log_blowup: usize) -> bool { + if log_blowup == 0 || count < 2 || height == 0 { + return false; + } + let fft = |n: u128| n * u128::from(n.max(2).ilog2()); + let height = height as u128; + let blowup = 1u128 << log_blowup; + let saved_columns = 2 * (count - count.div_ceil(2)) as u128; + let savings = (blowup + 1) * saved_columns * fft(height); + let extra = 2 * (fft(2 * height) - fft(height)) + 2 * fft(blowup * height); + savings > extra +} + +impl FixedTable { + pub(super) fn witness(&self, counts: &[Vec]) -> RowMajorMatrix { + let mut values = Vec::with_capacity(self.maps.len() * self.height); + for row in 0..self.height { + for &map in &self.maps { + values.push(Val::from_u64(counts[map].get(row).copied().unwrap_or(0))); + } + } + RowMajorMatrix::new(values, self.maps.len()) + } +} diff --git a/crates/aiur/src/trace/stark/tests.rs b/crates/aiur/src/trace/stark/tests.rs new file mode 100644 index 000000000..035ec0c7f --- /dev/null +++ b/crates/aiur/src/trace/stark/tests.rs @@ -0,0 +1,1469 @@ +use super::*; +use crate::trace::tests::{activate, raw_artifact}; +use crate::{ + Program, + bytecode::{CheckedProgram, Type}, + trace::TraceArtifact, +}; +use serde_json::{Value as Json, json}; +mod partition; + +fn f() -> Json { + json!({"kind":"field"}) +} +fn v(i: usize) -> Json { + json!({"var":i}) +} +fn k(x: u64) -> Json { + json!({"const":x}) +} +fn step(action: Json) -> Json { + json!({"guard":k(1), "action":action}) +} +fn writes(n: usize) -> Vec { + (0..n).map(|i| json!({"column":i,"source":i,"guard":k(1)})).collect() +} +fn parameters() -> Parameters { + Parameters { log_blowup: 1, num_queries: 32 } +} + +#[cfg(not(feature = "cuda"))] +#[test] +fn cpu_verification_ignores_gpu_prover_environment() { + // Exercise the real environment path in an isolated process. Mutating the + // parent environment would race the other tests and is unsafe in Rust 2024. + if std::env::var("AIUR_TEST_GPU_ENV_CHILD").as_deref() != Ok("1") { + let child = std::process::Command::new(std::env::current_exe().unwrap()) + .args([ + "--exact", + "trace::stark::tests::cpu_verification_ignores_gpu_prover_environment", + "--nocapture", + ]) + .env("AIUR_TEST_GPU_ENV_CHILD", "1") + .env("AIUR_TRACE_ONLY_LOOKUPS", "1") + .output() + .unwrap(); + assert!( + child.status.success(), + "{}", + String::from_utf8_lossy(&child.stderr) + ); + return; + } + let (program, artifact) = fixture(); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + // A CPU prover must still reject a request for device-derived lookups. + assert!(Backend::for_batch(&plan, parameters()).is_err()); + let backend = Backend::for_batch_verification(&plan, parameters()).unwrap(); + assert!(!backend.gpu_lookup_only); + let record = program.execute("root", vec![3]).unwrap(); + let witness = backend.generate(&record, "root", &[3]).unwrap(); + let proof = backend + .prove_batch( + "root", + &[3], + &[9], + witness, + 1, + multi_stark::batch::Retention::Regenerate, + ) + .unwrap(); + let key = + VerifyingKey::from_bytes(&backend.verifying_key_bytes().unwrap()).unwrap(); + key.verify(&[backend.claim("root", &[3], &[9]).unwrap()], &proof).unwrap(); + assert!( + key.verify(&[backend.claim("root", &[3], &[8]).unwrap()], &proof).is_err() + ); +} + +#[test] +fn batch_memory_partition_and_persisted_key() { + use multi_stark::batch::Retention; + let (program, artifact) = fixture(); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let backend = Backend::for_batch(&plan, parameters()).unwrap(); + let record = program.execute("root", vec![3]).unwrap(); + let mut witness = backend.generate(&record, "root", &[3]).unwrap(); + let memory = witness.traces.last_mut().unwrap(); + assert_eq!(memory.width, 4); + // Two unused but consecutive cells force a memory boundary across shards. + memory + .values + .extend([0, 1, 1, 42, 0, 1, 2, 43, 0, 0, 0, 0].map(Val::from_u64)); + let retained = backend + .prove_batch_stage_1( + "root", + &[3], + &[9], + witness.traces.clone(), + 2, + Retention::Retain, + ) + .unwrap(); + let proof = backend + .prove_batch("root", &[3], &[9], witness, 2, Retention::Regenerate) + .unwrap(); + assert_eq!(proof.proofs.len(), 2); + assert_eq!(proof.to_bytes().unwrap(), retained.to_bytes().unwrap()); + let bytes = backend.verifying_key_bytes().unwrap(); + let key = VerifyingKey::from_bytes(&bytes).unwrap(); + assert_eq!(key.to_bytes(), bytes); + let claim = backend.claim("root", &[3], &[9]).unwrap(); + key.verify(&[claim], &proof).unwrap(); + assert!(backend.verify_batch("root", &[3], &[8], &proof).is_err()); + let mut bad = proof.clone(); + bad.preamble.messages[1].args[2] += Val::ONE; + assert!(backend.verify_batch("root", &[3], &[9], &bad).is_err()); + let mut bad = proof.clone(); + bad.preamble.messages.extend(proof.preamble.messages.clone()); + assert!(backend.verify_batch("root", &[3], &[9], &bad).is_err()); + let mut bad = proof.clone(); + bad.preamble.headers[1].claims = bad.preamble.headers[0].claims.clone(); + assert!(backend.verify_batch("root", &[3], &[9], &bad).is_err()); +} + +#[test] +fn sliced_lookup_writer_matches_graph_and_retained_proof() { + use multi_stark::{batch::Retention, lookup::LookupValues, types::ExtVal}; + let (program, artifact) = fixture(); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let backend = host_lookups(&plan); + let record = program.execute("root", vec![3]).unwrap(); + let mut traces = backend.generate_stage_1(&record, "root", &[3]).unwrap(); + // Exercise a ROM run spanning two shards, fixed-table padding, zero + // multiplicities and circuits inactive in the second shard. + traces + .last_mut() + .unwrap() + .values + .extend([0, 1, 1, 42, 0, 1, 2, 43, 0, 0, 0, 0].map(Val::from_u64)); + for shard in 0..2 { + let sliced = backend.slice_stage_1(&traces, shard, 2).unwrap(); + let reference = + SystemWitness::from_stage_1(sliced.clone(), &backend.system); + let generated = backend.witness_from_main(sliced); + let stage2 = |witness: SystemWitness| { + let (lookups, groups): (Vec<_>, Vec<_>) = witness + .traces + .into_iter() + .zip(witness.lookups) + .zip(&backend.system.circuits) + .filter(|((trace, _), _)| trace.height() != 0) + .map(|((_, lookups), circuit)| (lookups, circuit.lookup_group_size)) + .unzip(); + LookupValues::stage_2_traces( + &lookups, + &groups, + ExtVal::from_u64(1000000007), + &ExtVal::from_u64(1000000009), + ExtVal::ZERO, + ) + }; + let (expected, expected_acc) = stage2(reference); + let (actual, actual_acc) = stage2(generated); + assert_eq!(actual_acc, expected_acc); + for (a, b) in actual.iter().zip(expected) { + assert_eq!(a.width, b.width); + assert_eq!(a.values, b.values); + } + } + // The move-only supplier for a single retained shard must produce exactly + // the same proof as the independent graph evaluator and a replayed shard. + let claim = backend.claim("root", &[3], &[9]).unwrap(); + let messages = vec![ + multi_stark::batch::BatchMessage::pull( + [MEMSEG, 1, 0].map(Val::from_u64).to_vec(), + ), + multi_stark::batch::BatchMessage::push( + [MEMSEG, 1, 3].map(Val::from_u64).to_vec(), + ), + ]; + let reference = backend.system.prove_batch_with( + &backend.key, + &[vec![claim]], + messages, + Retention::Retain, + |_| SystemWitness::from_stage_1(traces.clone(), &backend.system), + ); + for retention in [Retention::Retain, Retention::Regenerate] { + let proof = backend + .prove_batch_stage_1("root", &[3], &[9], traces.clone(), 4, retention) + .unwrap(); + assert_eq!(proof.to_bytes().unwrap(), reference.to_bytes().unwrap()); + } +} + +#[test] +fn gpu_lookup_policy_retains_single_shards_without_growing_multi_shard_residency() + { + use super::planning::{Options, RetentionPolicy}; + let (program, artifact) = fixture(); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let mut backend = Backend::for_batch(&plan, parameters()).unwrap(); + // Planning is host-only: exercise the GPU policy without needing a device + // or asking the CPU prover to consume shape-only lookup buffers. + backend.gpu_lookup_only = true; + let record = program.execute("root", vec![3]).unwrap(); + let heights = backend.record_shape(&record).unwrap().heights; + let options = Options { max_ram_bytes: Some(u64::MAX), ..Default::default() }; + let single = backend.plan_heights(&heights, &options, 0).unwrap(); + assert_eq!(single.shards, 1); + assert_eq!(single.retention, RetentionPolicy::Retain); + let streamed = backend.plan_stream(&[(&heights, 1)], &options).unwrap(); + assert_eq!(streamed.retention, RetentionPolicy::Retain); + let regenerated = backend + .plan_stream( + &[(&heights, 1)], + &Options { retention: RetentionPolicy::Regenerate, ..options.clone() }, + ) + .unwrap(); + assert_eq!(streamed.peak_bytes, regenerated.peak_bytes); + let mut many = heights; + many[0] = 8; + let options = Options { max_rows: Some(2), ..options }; + let batch = backend.plan_heights(&many, &options, 0).unwrap(); + assert_eq!(batch.shards, 4); + assert_eq!(batch.retention, RetentionPolicy::Regenerate); + let streamed = backend.plan_stream(&[(&many, 2)], &options).unwrap(); + assert_eq!(streamed.retention, RetentionPolicy::Regenerate); + assert!(!backend.requires_regeneration(1)); + assert!(backend.requires_regeneration(2)); +} + +fn compare_generated( + backend: &Backend<'_, '_, B>, + record: &Execution, + entry: &str, + args: &[B::Element], +) { + let trace = + backend.plan.generate_reference(record, entry, args, true).unwrap(); + let expected = backend.witness(record, &trace).unwrap(); + let got = backend.generate(record, entry, args).unwrap(); + let stage_1 = backend.generate_stage_1(record, entry, args).unwrap(); + for (full, main) in got.traces.iter().zip(&stage_1) { + assert_eq!(full.width, main.width); + assert_eq!(full.values, main.values); + } + assert_eq!(expected.traces.len(), got.traces.len()); + for (a, b) in expected.traces.iter().zip(&got.traces) { + assert_eq!(a.width, b.width); + assert_eq!(a.values, b.values); + } + // Reconstruct ROM rows by independently filtering the flat record. This + // checks the borrowed width buckets, including counts, empty widths and + // padding, without sharing the production bucket/index access path. + let rom_start = backend.members.len() + backend.tables.len(); + for matrix in &got.traces[rom_start..] { + let width = matrix.width - 3; + let mut expected = vec![]; + for entry in record.memory.iter().filter(|m| m.cell.value.len() == width) { + expected.extend([ + Val::from_u64(entry.multiplicity), + Val::ONE, + Val::from_usize(entry.address), + ]); + expected.extend(entry.cell.value.iter().copied().map(B::into_stark)); + } + let rows = expected.len() / matrix.width; + assert_eq!( + matrix.height(), + if rows == 0 { 0 } else { rows.next_power_of_two() } + ); + expected.resize(matrix.values.len(), Val::ZERO); + assert_eq!(matrix.values, expected); + } + // Compare every nonzero message directly to the independent dense graph + // evaluator, including constants, shared expressions and fixed columns. + use multi_stark::eval::VarValues; + for (ci, (circuit, matrix)) in + backend.system.circuits.iter().zip(&got.traces).enumerate() + { + for r in 0..matrix.height() { + let row = &matrix.values[r * matrix.width..(r + 1) * matrix.width]; + let fixed = circuit + .preprocessed + .as_ref() + .map_or(&[][..], |f| &f.values[r * f.width..(r + 1) * f.width]); + let view = VarValues { + main: [row, row], + preprocessed: [fixed, fixed], + stage2: [&[], &[]], + publics: &[], + is_first_row: Val::ZERO, + is_last_row: Val::ZERO, + is_transition: Val::ONE, + }; + let mut buf = vec![]; + circuit.graph.sweep_lookup_prefix(&view, &mut buf); + let expected = circuit.graph.lookup_values(&buf); + let mut emitted = vec![false; expected.len()]; + backend.lookup_plans[ci].evaluate(row, fixed, |slot, count, args| { + assert_eq!(count, expected[slot].multiplicity); + assert_eq!(args, &expected[slot].args[..args.len()]); + assert!( + expected[slot].args[args.len()..].iter().all(|v| *v == Val::ZERO) + ); + emitted[slot] = true; + }); + for (emitted, expected) in emitted.into_iter().zip(expected) { + assert_eq!(emitted, expected.multiplicity != Val::ZERO); + } + } + } + let proof = backend.prove(entry, args, &record.output, got).unwrap(); + backend.verify(entry, args, &record.output, &proof).unwrap(); +} + +#[test] +fn fused_rows_and_lookups_match_reference_and_verify() { + let (mut program, artifact) = fixture(); + // An unused wide type gets an empty bucket and never widens scalar rows. + let wide: Type = + serde_json::from_value(json!({"kind":"tuple","items":[f(),f(),f(),f()]})) + .unwrap(); + let layout = wide.layout(&program.program.enums, &mut vec![]).unwrap(); + program.memory_layouts.insert(wide, layout); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let backend = Backend::new(&plan, parameters()).unwrap(); + let shapes = backend.statistics(); + assert_eq!( + shapes.iter().find(|s| s.name == "").unwrap().stage1_width, + 4 + ); + assert_eq!( + shapes.iter().find(|s| s.name == "").unwrap().stage1_width, + 7 + ); + for arg in [2, 3, 4] { + let record = program.execute("root", vec![arg]).unwrap(); + compare_generated(&backend, &record, "root", &[arg]); + } + for unit in [false, true] { + let (program, artifact) = identity(unit); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let backend = Backend::new(&plan, parameters()).unwrap(); + let args = if unit { vec![] } else { vec![7] }; + let record = program.execute("id", args.clone()).unwrap(); + compare_generated(&backend, &record, "id", &args); + } +} + +#[test] +fn erased_rom_views_use_existing_width_buckets() { + let (program, mut artifact) = fixture(); + for chip in &mut artifact.chips { + for cell in &mut chip.memory { + cell.r#type = Type::Tuple { items: vec![Type::Field; cell.values.len()] }; + assert!(!program.memory_layouts.contains_key(&cell.r#type)); + } + } + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let backend = Backend::new(&plan, parameters()).unwrap(); + let record = program.execute("root", vec![3]).unwrap(); + compare_generated(&backend, &record, "root", &[3]); +} + +/// root(x) = load(store(leaf(x))); leaf(x) = fixed_square_table[x]. +/// The table has three rows, so its preprocessed domain also tests padding. +/// A batch backend with host lookup buffers, whatever the build's default +/// (CUDA builds derive lookups on the device unless told otherwise). Tests of +/// host lookup values and of retention choices use it. +pub(super) fn host_lookups<'p, 'a>( + plan: &'p TracePlan<'a, PrimeField>, +) -> Backend<'p, 'a, PrimeField> { + Backend::build_with_lookup_policy(plan, parameters(), true, None, false) + .unwrap() +} + +fn fixture() -> (CheckedProgram, TraceArtifact) { + let program: Program = serde_json::from_value(json!({ + "version":1,"modulus":Val::ORDER_U64,"enums":[], + "functions":[ + {"name":"root","params":[f()],"result":f(),"registers":4,"code":[ + {"op":"call","function":1,"args":[0],"dest":[1]}, + {"op":"store","type":f(),"value":[1],"dest":2}, + {"op":"load","type":f(),"pointer":2,"dest":[3]}, + {"op":"ret","value":[3]}]}, + {"name":"leaf","params":[f()],"result":f(),"registers":2,"code":[ + {"op":"call","function":2,"args":[0],"dest":[1]}, + {"op":"ret","value":[1]}]} + ], + "maps":[{"name":"square","params":[f()],"result":f(),"input":0,"output":1}], + "tables":[ + {"name":"xs","type":{"kind":"tuple","items":[f()]},"rows":[[2],[3],[4]]}, + {"name":"ys","type":f(),"rows":[[4],[9],[16]]} + ], + "entries":[{"name":"root","function":0,"inputs":[f()],"output":f()}] + })) + .unwrap(); + let artifact = raw_artifact(json!({ + "version":1,"modulus":Val::ORDER_U64, + "functions":[ + {"name":"root","chip":"root","witnesses":4,"inputs":[0],"output":[3], + "steps":[ + step(json!({"op":"call","name":"leaf","args":[v(0)],"dest":[1]})), + step(json!({"op":"store","type":f(),"values":[v(1)],"dest":2})), + step(json!({"op":"load","type":f(),"address":v(2),"dest":[3]}))], + "writes":writes(4)}, + {"name":"leaf","chip":"leaf","witnesses":2,"inputs":[0],"output":[1], + "steps":[step(json!({"op":"call","name":"square","args":[v(0)],"dest":[1]}))],"writes":writes(2)} + ], + "chips":[ + {"name":"root","width":4,"inputs":[0],"output":[v(3)],"constraints":[], + "sends":[{"channel":"leaf","args":[v(0)],"result":[1],"enable":k(1)}], + "memory":[ + {"type":f(),"address":v(2),"values":[v(1)],"enable":k(1)}, + {"type":f(),"address":v(2),"values":[v(3)],"enable":k(1)}]}, + {"name":"leaf","width":2,"inputs":[0],"output":[v(1)],"constraints":[],"memory":[], + "sends":[{"channel":"square","args":[v(0)],"result":[1],"enable":k(1)}]} + ] + })); + (program.check().unwrap(), artifact) +} + +#[test] +fn proves_calls_fixed_maps_and_rom_and_verifies_without_record() { + let (program, artifact) = fixture(); + let plan = TracePlan::new(&program, activate(artifact.clone())).unwrap(); + let backend = Backend::new(&plan, parameters()).unwrap(); + let record = program.execute("root", vec![3]).unwrap(); + let trace = plan.generate(&record, "root", &[3], true).unwrap(); + let witness = backend.witness(&record, &trace).unwrap(); + assert_eq!(witness.traces[2].height(), 4); + assert_eq!( + witness.traces[3].values, + [Val::from_u64(2), Val::ONE, Val::ZERO, Val::from_u64(9)] + ); + let proof = backend.prove("root", &[3], &[9], witness).unwrap(); + drop(trace); + drop(record); + drop(backend); + let bytes = proof.to_bytes().unwrap(); + let proof = Proof::from_bytes(&bytes).unwrap(); + // Independent verifier setup reads only the trusted program/circuits/tables. + let backend = Backend::new(&plan, parameters()).unwrap(); + backend.verify("root", &[3], &[9], &proof).unwrap(); + for (entry, args, output) in [ + ("root", vec![4], vec![9]), + ("root", vec![3], vec![8]), + ("missing", vec![3], vec![9]), + ("root", vec![], vec![9]), + ("root", vec![Val::ORDER_U64], vec![9]), + ] { + assert!(backend.verify(entry, &args, &output, &proof).is_err()); + } + // A fixed-table commitment belongs to verification, not to the witness. + let mut different = program.program().clone(); + different.tables[1].rows[1][0] = 10; + let different = different.check().unwrap(); + let different_plan = TracePlan::new(&different, activate(artifact)).unwrap(); + let different_backend = Backend::new(&different_plan, parameters()).unwrap(); + assert!(different_backend.verify("root", &[3], &[9], &proof).is_err()); + let mut wrong_height = proof.clone(); + wrong_height.log_degrees[2] = 1; + assert!( + backend + .verify("root", &[3], &[9], &wrong_height) + .unwrap_err() + .contains("fixed table height") + ); + let mut inactive = proof; + inactive.active[2] = false; + inactive.log_degrees.remove(2); + assert!( + backend + .verify("root", &[3], &[9], &inactive) + .unwrap_err() + .contains("inactive fixed table") + ); +} + +#[test] +fn map_overrides_populate_witnesses_but_cannot_replace_certifying_tables() { + use crate::maps::MapOverrides; + use std::sync::{ + Arc, + atomic::{AtomicUsize, Ordering}, + }; + + let (program, mut artifact) = fixture(); + // Retain the square result as an intermediate: population must call the + // binding rather than simply copying the recorded function return value. + artifact.functions[1].witnesses = 3; + artifact.functions[1].output = vec![2]; + artifact.functions[1].steps.push( + serde_json::from_value(step(json!({ + "op":"assign","dest":[2],"values":[v(1)] + }))) + .unwrap(), + ); + artifact.functions[1].writes = + serde_json::from_value(json!(writes(3))).unwrap(); + artifact.chips[1].width = 3; + artifact.chips[1].output = vec![Polynomial::Var(2)]; + artifact.chips[1] + .constraints + .push(Polynomial::Sub(Box::new([Polynomial::Var(1), Polynomial::Var(2)]))); + let plan = TracePlan::new(&program, activate(artifact.clone())).unwrap(); + let backend = Backend::new(&plan, parameters()).unwrap(); + let original = program.execute("root", vec![3]).unwrap(); + let reference = + plan.generate_reference(&original, "root", &[3], true).unwrap(); + for (correct, fixed) in + [(true, false), (false, false), (true, true), (false, true)] + { + let calls = Arc::new(AtomicUsize::new(0)); + let captured = calls.clone(); + let mut maps = MapOverrides::new(); + let provider = move |x: u64| { + captured.fetch_add(1, Ordering::Relaxed); + let row = x + .checked_sub(2) + .filter(|&row| row < 3) + .map(|row| row as usize) + .ok_or_else(|| "no table entry for map input".to_owned())?; + Ok((row, [x * x + u64::from(!correct)])) + }; + if fixed { + maps.insert_fixed::<1, 1>("square", move |[x]| provider(x)).unwrap(); + } else { + maps + .insert("square", 1, 1, move |args, out| { + let (row, output) = provider(args[0])?; + out.copy_from_slice(&output); + Ok(row) + }) + .unwrap(); + } + let prepared = + program.prepare_hints(&[]).unwrap().with_map_overrides(&maps).unwrap(); + // Binding checks row numbers for every immutable table input once. + calls.store(0, Ordering::Relaxed); + let record = prepared.execute("root", vec![3]).unwrap(); + assert_eq!(record.output, [if correct { 9 } else { 10 }]); + assert_eq!(calls.load(Ordering::Relaxed), 1); + drop(prepared); + drop(maps); + let trace = plan.generate(&record, "root", &[3], true).unwrap(); + assert_eq!(calls.load(Ordering::Relaxed), 2); + assert_eq!(plan.check(&record, &trace, "root", &[3]).is_ok(), correct); + if correct { + assert_eq!(record.queries, original.queries); + assert_eq!(trace, reference); + } + let witness = backend.generate(&record, "root", &[3]).unwrap(); + assert_eq!(calls.load(Ordering::Relaxed), 3); + let proof = backend.prove("root", &[3], &record.output, witness).unwrap(); + // Construct a verifier from the program/artifact alone, with no overrides. + let verifier_program = program.program().clone().check().unwrap(); + let verifier_plan = + TracePlan::new(&verifier_program, activate(artifact.clone())).unwrap(); + let verifier = Backend::new(&verifier_plan, parameters()).unwrap(); + assert_eq!( + verifier.verify("root", &[3], &record.output, &proof).is_ok(), + correct + ); + // A different prepared program must not donate its static map bindings. + assert!(verifier_plan.generate(&record, "root", &[3], true).is_err()); + } +} + +#[test] +fn an_accelerator_cannot_certify_a_missing_input_by_returning_a_valid_row() { + let (program, artifact) = fixture(); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let backend = Backend::new(&plan, parameters()).unwrap(); + let mut maps = crate::maps::MapOverrides::::new(); + maps + .insert_fixed::<1, 1>("square", |[x]| { + // Correct numbering on all three table rows (2, 3, 4), so binding + // succeeds. Deliberately aliases the missing input 5 to the row for 2. + let row = if x == 5 { 0 } else { x as usize - 2 }; + Ok((row, [x * x])) + }) + .unwrap(); + let record = program + .prepare_hints(&[]) + .unwrap() + .with_map_overrides(&maps) + .unwrap() + .execute("root", vec![5]) + .unwrap(); + assert_eq!(record.output, [25]); + let trace = plan.generate(&record, "root", &[5], true).unwrap(); + assert!(plan.check(&record, &trace, "root", &[5]).is_err()); + let witness = backend.generate(&record, "root", &[5]).unwrap(); + let proof = backend.prove("root", &[5], &[25], witness).unwrap(); + assert!(backend.verify("root", &[5], &[25], &proof).is_err()); +} + +#[test] +fn proof_rejects_corrupt_counts_memory_and_fixed_lookup() { + let (program, artifact) = fixture(); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let backend = Backend::new(&plan, parameters()).unwrap(); + let record = program.execute("root", vec![3]).unwrap(); + let trace = plan.generate(&record, "root", &[3], true).unwrap(); + let witness = backend.witness(&record, &trace).unwrap(); + let reject = |traces: Vec>| { + // Recompute every lookup from the malicious main trace and actually + // run the STARK, without relying on witness-construction diagnostics. + let witness = SystemWitness::from_stage_1(traces, &backend.system); + let proof = backend.prove("root", &[3], &[9], witness).unwrap(); + assert!(backend.verify("root", &[3], &[9], &proof).is_err()); + }; + let mut bad = witness.traces.clone(); + bad[0].values[5] += Val::ONE; // excess root provide count + reject(bad); + let mut bad = witness.traces.clone(); + bad[2].values[1] = Val::ZERO; // missing fixed square(3) provider + reject(bad); + let mut bad = witness.traces.clone(); + bad[3].values[3] += Val::ONE; // wrong ROM payload + reject(bad); + let mut bad = witness.traces.clone(); + let mut rom_row = bad[3].values.clone(); + rom_row[0] = Val::ONE; + bad[3].values = [rom_row.clone(), rom_row.clone()].concat(); + reject(bad); // balanced value lookups, but duplicate local addresses + let mut bad = witness.traces.clone(); + let mut padding = rom_row.clone(); + padding[1] = Val::ZERO; + bad[3].values = [rom_row, padding].concat(); + reject(bad); // balanced lookups, but padding illegally supplies a cell +} + +#[test] +fn recorded_lookup_counts_are_checked_by_the_proof() { + let (program, artifact) = fixture(); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let backend = Backend::new(&plan, parameters()).unwrap(); + let record = program.execute("root", vec![3]).unwrap(); + let trace = plan.generate(&record, "root", &[3], true).unwrap(); + for corrupt_memory in [false, true] { + let mut bad = record.clone(); + if corrupt_memory { + *bad.memory.multiplicity_mut(0) += 1; + } else { + bad.queries.tables[2].bump(0).unwrap(); + } + let witness = backend.witness(&bad, &trace).unwrap(); + let proof = backend.prove("root", &[3], &[9], witness).unwrap(); + assert!(backend.verify("root", &[3], &[9], &proof).is_err()); + } + let mut bad = record.clone(); + // A fixed row that was never queried must still be checked before its + // integer multiplicity is converted to a field element. + bad.queries.tables[2].static_map.as_mut().unwrap().counts[0] = Val::ORDER_U64; + assert!(backend.witness(&bad, &trace).is_err()); + let mut bad = record; + *bad.memory.multiplicity_mut(0) = Val::ORDER_U64; + assert!(backend.witness(&bad, &trace).is_err()); +} + +/// Interleave widths 0, 1 and 2, including different types of width 1. +/// The final scalar may share an interned cell with an earlier store. +fn mixed_memory() -> (CheckedProgram, TraceArtifact) { + let unit = json!({"kind":"tuple","items":[]}); + let pair = json!({"kind":"tuple","items":[f(),f()]}); + let singleton = json!({"kind":"tuple","items":[f()]}); + let mut code = vec![]; + let mut steps = vec![]; + let mut memory = vec![]; + for (ty, values, pointer, dest) in [ + (f(), vec![0], 3, vec![9]), + (pair, vec![0, 1], 4, vec![10, 11]), + (unit, vec![], 5, vec![]), + (singleton, vec![1], 6, vec![12]), + (f(), vec![1], 7, vec![13]), + (f(), vec![2], 8, vec![14]), + ] { + code.push(json!({"op":"store","type":ty,"value":values,"dest":pointer})); + code.push(json!({"op":"load","type":ty,"pointer":pointer,"dest":dest})); + let values: Vec<_> = values.into_iter().map(v).collect(); + steps.push(step( + json!({"op":"store","type":ty,"values":values,"dest":pointer}), + )); + steps.push(step( + json!({"op":"load","type":ty,"address":v(pointer),"dest":dest}), + )); + memory.push( + json!({"type":ty,"address":v(pointer),"values":values,"enable":k(1)}), + ); + let loaded: Vec<_> = dest.into_iter().map(v).collect(); + memory.push( + json!({"type":ty,"address":v(pointer),"values":loaded,"enable":k(1)}), + ); + } + code.push(json!({"op":"ret","value":[14]})); + let program: Program = serde_json::from_value(json!({ + "version":1,"modulus":Val::ORDER_U64,"enums":[],"maps":[],"tables":[], + "functions":[{"name":"root","params":[f(),f(),f()],"result":f(),"registers":15,"code":code}], + "entries":[{"name":"root","function":0,"inputs":[f(),f(),f()],"output":f()}] + })).unwrap(); + let artifact = raw_artifact(json!({ + "version":1,"modulus":Val::ORDER_U64, + "functions":[{"name":"root","chip":"root","witnesses":15,"inputs":[0,1,2], + "output":[14],"steps":steps,"writes":writes(15)}], + "chips":[{"name":"root","width":15,"inputs":[0,1,2],"output":[v(14)], + "constraints":[],"sends":[],"memory":memory}] + })); + let mut program = program.check().unwrap(); + let unused: Type = + serde_json::from_value(json!({"kind":"tuple","items":[f(),f(),f(),f()]})) + .unwrap(); + program.memory_layouts.insert( + unused.clone(), + unused.layout(&program.program.enums, &mut vec![]).unwrap(), + ); + (program, artifact) +} + +#[test] +fn width_local_rom_shares_types_and_preserves_functionality() { + let (program, artifact) = mixed_memory(); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let backend = Backend::new(&plan, parameters()).unwrap(); + let index = + |name: &str| backend.names.iter().position(|n| n == name).unwrap(); + assert!(!backend.names.iter().any(|n| n == "")); + for args in [[3, 0, 7], [3, 0, 3], [3, 3, 3]] { + let record = program.execute("root", args.to_vec()).unwrap(); + compare_generated(&backend, &record, "root", &args); + let witness = backend.generate(&record, "root", &args).unwrap(); + let scalar = &witness.traces[index("")]; + assert_eq!(witness.traces[index("")].values[2], Val::ZERO); + assert_eq!(scalar.width, 4); + assert_eq!(witness.traces[index("")].width, 5); + assert_eq!(witness.traces[index("")].values[2], Val::ZERO); + assert_eq!(witness.traces[index("")].height(), 0); + // Field and singleton tuple stores of the same words share a row. + let distinct = args.iter().collect::>().len(); + assert_eq!(record.memory.len(), distinct + 2); + assert_eq!(scalar.height(), distinct.next_power_of_two()); + if args == [3, 3, 3] { + assert_eq!(scalar.values[0], Val::from_u64(8)); + } + } + + let args = [3, 0, 7]; + let record = program.execute("root", args.to_vec()).unwrap(); + let witness = backend.generate(&record, "root", &args).unwrap(); + let reject = |traces: Vec>| { + let forged = SystemWitness::from_stage_1(traces, &backend.system); + let proof = backend.prove("root", &args, &[7], forged).unwrap(); + assert!(backend.verify("root", &args, &[7], &proof).is_err()); + }; + let scalar = index(""); + let pair = index(""); + + // The two widths already reuse address zero. Neither can supply the + // other's message, even when the longer payload only adds a zero suffix. + let mut bad = witness.traces.clone(); + bad[pair].values[0] = Val::ZERO; + bad[scalar].values[0] += Val::from_u64(2); + reject(bad); + + // Conflicting payloads at one width-local address are forbidden even + // when every lookup balances: redirect both the store and load together. + let mut bad = witness.traces.clone(); + bad[0].values[6] = Val::ZERO; + bad[0].values[7] = Val::ZERO; + bad[scalar].values[6] = Val::ZERO; + reject(bad); + + let mut bad = witness.traces.clone(); + bad[pair].values.clear(); + reject(bad); + // Zero-use rows still cannot duplicate an existing local address. + let mut bad = witness.traces.clone(); + let mut duplicate = bad[scalar].values[..4].to_vec(); + duplicate[0] = Val::ZERO; + bad[scalar].values[12..16].copy_from_slice(&duplicate); + reject(bad); + + // An unreachable cell in an otherwise unused width is harmless. Its + // nominal interpretations need not be canonical until a stored pointer + // with the appropriate type reaches it. + let mut extra = witness.traces.clone(); + let unused = index(""); + extra[unused].values = vec![Val::ZERO; 7]; + extra[unused].values[1] = Val::ONE; + let extra = SystemWitness::from_stage_1(extra, &backend.system); + let proof = backend.prove("root", &args, &[7], extra).unwrap(); + backend.verify("root", &args, &[7], &proof).unwrap(); +} + +fn identity(unit: bool) -> (CheckedProgram, TraceArtifact) { + let ty = if unit { json!({"kind":"tuple","items":[]}) } else { f() }; + let n = usize::from(!unit); + let program: Program = serde_json::from_value(json!({ + "version":1,"modulus":Val::ORDER_U64,"enums":[],"maps":[],"tables":[], + "functions":[{"name":"id","params":[ty],"result":ty,"registers":n, + "code":[{"op":"ret","value":(0..n).collect::>()}]}], + "entries":[{"name":"id","function":0,"inputs":[ty],"output":ty}] + })) + .unwrap(); + let artifact = raw_artifact(json!({ + "version":1,"modulus":Val::ORDER_U64, + "functions":[{"name":"id","chip":"id","witnesses":n,"inputs":(0..n).collect::>(), + "output":(0..n).collect::>(),"steps":[],"writes":writes(n)}], + "chips":[{"name":"id","width":n,"inputs":(0..n).collect::>(), + "output":(0..n).map(v).collect::>(),"constraints":[],"sends":[],"memory":[]}] + })); + (program.check().unwrap(), artifact) +} + +#[test] +fn proves_zero_width_and_height_one_without_auxiliary_tables() { + for unit in [true, false] { + let (program, artifact) = identity(unit); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let backend = Backend::new(&plan, parameters()).unwrap(); + let args: Vec<_> = if unit { vec![] } else { vec![7] }; + let record = program.execute("id", args.clone()).unwrap(); + let trace = plan.generate(&record, "id", &args, true).unwrap(); + let witness = backend.witness(&record, &trace).unwrap(); + assert_eq!(witness.traces[0].height(), 1); + assert_eq!(witness.traces[0].width, if unit { 2 } else { 3 }); + let proof = backend.prove("id", &args, &args, witness).unwrap(); + backend.verify("id", &args, &args, &proof).unwrap(); + } +} + +#[test] +fn zero_padding_verifies_but_inactive_providers_and_nonboolean_rows_do_not() { + let (program, artifact) = identity(false); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let backend = Backend::new(&plan, parameters()).unwrap(); + let record = program.execute("id", vec![7]).unwrap(); + let mut trace = plan.generate(&record, "id", &[7], true).unwrap(); + let matrix = &mut trace.matrices[0]; + matrix.height = 2; + matrix.values.extend([0, 0]); + matrix.multiplicities.push(0); + plan.check(&record, &trace, "id", &[7]).unwrap(); + let witness = backend.witness(&record, &trace).unwrap(); + assert_eq!( + witness.traces[0].values, + [Val::from_u64(7), Val::ONE, Val::ONE, Val::ZERO, Val::ZERO, Val::ZERO] + ); + let proof = backend.prove("id", &[7], &[7], witness.clone()).unwrap(); + backend.verify("id", &[7], &[7], &proof).unwrap(); + + // These forgeries keep the public lookup balance exactly correct. Only + // the selector/count constraints prevent the inactive row from proving it. + for rows in [[7, 1, 0, 7, 0, 1], [7, 2, 1, 0, 0, 0]] { + let mut bad = witness.traces.clone(); + bad[0].values = rows.into_iter().map(Val::from_u64).collect(); + let forged = SystemWitness::from_stage_1(bad, &backend.system); + let proof = backend.prove("id", &[7], &[7], forged).unwrap(); + assert!(backend.verify("id", &[7], &[7], &proof).is_err()); + } + + trace.matrices[0].multiplicities = vec![0, 1]; + trace.matrices[0].values[2] = 7; + assert!(plan.check(&record, &trace, "id", &[7]).is_err()); + assert!(backend.witness(&record, &trace).is_err()); +} + +#[test] +fn checks_field_parameters_domains_and_shapes_before_proving() { + let (program, artifact) = identity(false); + let plan = TracePlan::new(&program, activate(artifact.clone())).unwrap(); + assert!( + Backend::new(&plan, Parameters { log_blowup: 0, num_queries: 32 }).is_err() + ); + assert!( + Backend::new(&plan, Parameters { log_blowup: 1, num_queries: 0 }).is_err() + ); + let backend = Backend::new(&plan, parameters()).unwrap(); + assert!(backend.check_shape(&[true], &[32]).is_err()); + assert!(backend.check_shape(&[true], &[]).is_err()); + assert!(backend.check_shape(&[true], &[0, 0]).is_err()); + assert!(backend.check_shape(&[false], &[]).is_err()); + let record = program.execute("id", vec![7]).unwrap(); + let mut trace = plan.generate(&record, "id", &[7], true).unwrap(); + trace.matrices[0].multiplicities[0] = Val::ORDER_U64; + assert!(backend.witness(&record, &trace).is_err()); + let mut small = program.program().clone(); + small.modulus = 97; + let small = small.check().unwrap(); + let mut artifact = artifact; + artifact.modulus = 97; + let plan = TracePlan::new(&small, activate(artifact)).unwrap(); + assert!(Backend::new(&plan, parameters()).is_err()); +} + +#[test] +fn arithmetic_constraints_are_enforced_even_when_lookups_balance() { + let (program, mut artifact) = identity(false); + let mut program = program.program().clone(); + program.functions[0].registers = 2; + program.functions[0].code = serde_json::from_value(json!([ + {"op":"binary","operator":"mul","left":0,"right":0,"dest":1}, + {"op":"ret","value":[1]} + ])) + .unwrap(); + let program = program.check().unwrap(); + artifact.functions[0].witnesses = 2; + artifact.functions[0].output = vec![1]; + artifact.functions[0].writes = + serde_json::from_value(json!(writes(2))).unwrap(); + artifact.chips[0].width = 2; + artifact.chips[0].output = vec![Polynomial::Var(1)]; + artifact.chips[0].constraints = serde_json::from_value(json!([ + {"sub":[v(1),{"mul":[v(0),v(0)]}]} + ])) + .unwrap(); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let backend = Backend::new(&plan, parameters()).unwrap(); + let record = program.execute("id", vec![7]).unwrap(); + let trace = plan.generate(&record, "id", &[7], true).unwrap(); + let witness = backend.witness(&record, &trace).unwrap(); + let proof = backend.prove("id", &[7], &[49], witness.clone()).unwrap(); + backend.verify("id", &[7], &[49], &proof).unwrap(); + let mut bad = witness.traces; + bad[0].values[1] = Val::from_u64(48); + let witness = SystemWitness::from_stage_1(bad, &backend.system); + let proof = backend.prove("id", &[7], &[48], witness).unwrap(); + assert!(backend.verify("id", &[7], &[48], &proof).is_err()); +} + +#[test] +fn shares_fixed_columns_and_handles_empty_maps_and_inactive_chips() { + let (program, mut artifact) = identity(true); + let mut program = program.program().clone(); + let mut unused = program.functions[0].clone(); + unused.name = "unused".into(); + program.functions.push(unused); + let mut unused = artifact.functions[0].clone(); + unused.name = "unused".into(); + unused.chip = "unused".into(); + artifact.functions.push(unused); + let mut unused = artifact.chips[0].clone(); + unused.name = "unused".into(); + artifact.chips.push(unused); + let unit = json!({"kind":"tuple","items":[]}); + let input = json!({"kind":"tuple","items":[unit]}); + program.tables = serde_json::from_value(json!([ + {"name":"unit_input","type":input,"rows":[[]]}, + {"name":"unit_output","type":unit,"rows":[[]]}, + {"name":"empty_input","type":input,"rows":[]}, + {"name":"empty_output","type":unit,"rows":[]} + ])) + .unwrap(); + program.maps = serde_json::from_value(json!([ + {"name":"a","params":[unit],"result":unit,"input":0,"output":1}, + {"name":"b","params":[unit],"result":unit,"input":0,"output":1}, + {"name":"empty","params":[unit],"result":unit,"input":2,"output":3} + ])) + .unwrap(); + let program = program.check().unwrap(); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let backend = Backend::new(&plan, parameters()).unwrap(); + assert_eq!(backend.statistics()[2].stage1_width, 2); + assert_eq!(backend.statistics()[2].preprocessed_width, 1); + let record = program.execute("id", vec![]).unwrap(); + compare_generated(&backend, &record, "id", &[]); + let trace = plan.generate(&record, "id", &[], true).unwrap(); + let witness = backend.witness(&record, &trace).unwrap(); + let proof = backend.prove("id", &[], &[], witness).unwrap(); + assert_eq!(proof.active, [true, false, true, false]); + backend.verify("id", &[], &[], &proof).unwrap(); +} + +#[test] +fn fixed_tables_share_height_without_sharing_domains_or_row_order() { + let (program, mut artifact) = fixture(); + let mut program = program.program().clone(); + program.tables.extend( + serde_json::from_value::>(json!([ + {"name":"pairs","type":{"kind":"tuple","items":[f(),f()]},"rows":[[4,4],[2,2],[3,3]]}, + {"name":"sums","type":f(),"rows":[[8],[4],[6]]} + ])) + .unwrap(), + ); + program.maps.push( + serde_json::from_value(json!({ + "name":"sum","params":[f(),f()],"result":f(),"input":2,"output":3 + })) + .unwrap(), + ); + program.functions[1].registers = 4; + program.functions[1].code = serde_json::from_value(json!([ + {"op":"call","function":2,"args":[0],"dest":[1]}, + {"op":"call","function":3,"args":[0,0],"dest":[2]}, + {"op":"binary","operator":"add","left":1,"right":2,"dest":3}, + {"op":"ret","value":[3]} + ])) + .unwrap(); + artifact.functions[1].witnesses = 4; + artifact.functions[1].output = vec![3]; + artifact.functions[1].writes = + serde_json::from_value(json!(writes(4))).unwrap(); + artifact.functions[1].steps.extend( + serde_json::from_value::>(json!([ + step(json!({"op":"call","name":"sum","args":[v(0),v(0)],"dest":[2]})), + step(json!({"op":"assign","dest":[3],"values":[{"add":[v(1),v(2)]}]})) + ])) + .unwrap(), + ); + artifact.chips[1].width = 4; + artifact.chips[1].output = vec![Polynomial::Var(3)]; + artifact.chips[1].constraints = serde_json::from_value(json!([ + {"sub":[v(3),{"add":[v(1),v(2)]}]} + ])) + .unwrap(); + artifact.chips[1].sends.push( + serde_json::from_value(json!({ + "channel":"sum","args":[v(0),v(0)],"result":[2],"enable":k(1) + })) + .unwrap(), + ); + let program = program.check().unwrap(); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let backend = Backend::new(&plan, parameters()).unwrap(); + assert_eq!(backend.tables.len(), 1); + assert_eq!(backend.statistics()[2].stage1_width, 2); + assert_eq!(backend.statistics()[2].preprocessed_width, 6); + let record = program.execute("root", vec![3]).unwrap(); + assert_eq!(record.output, [15]); + compare_generated(&backend, &record, "root", &[3]); + let witness = backend.generate(&record, "root", &[3]).unwrap(); + // square(3) is row 1; sum(3,3) is row 2, in the same physical chip. + assert_eq!( + witness.traces[2].values, + [ + Val::ZERO, + Val::ZERO, + Val::ONE, + Val::ZERO, + Val::ZERO, + Val::ONE, + Val::ZERO, + Val::ZERO + ] + ); + let proof = backend.prove("root", &[3], &[15], witness.clone()).unwrap(); + backend.verify("root", &[3], &[15], &proof).unwrap(); + let mut bad = witness.traces; + bad[2].values[3] = Val::ONE; + bad[2].values[5] = Val::ZERO; + let proof = backend + .prove( + "root", + &[3], + &[15], + SystemWitness::from_stage_1(bad, &backend.system), + ) + .unwrap(); + assert!(backend.verify("root", &[3], &[15], &proof).is_err()); +} + +#[test] +fn native_field_witnesses_and_proofs_match_the_integer_backend() { + let (raw, artifact) = fixture(); + let native = raw.program().clone().check_field::().unwrap(); + let raw_plan = TracePlan::new(&raw, activate(artifact.clone())).unwrap(); + let plan = TracePlan::new(&native, activate(artifact)).unwrap(); + let raw_record = raw.execute("root", vec![3]).unwrap(); + let args = [Val::from_u64(3)]; + let mut overrides = crate::maps::MapOverrides::::new(); + overrides + .insert("square", 1, 1, |input, output| { + // Only the row index needs an integer; the answer uses field arithmetic. + output[0] = input[0] * input[0]; + input[0] + .as_canonical_u64() + .checked_sub(2) + .filter(|&row| row < 3) + .map(|row| row as usize) + .ok_or_else(|| "no table entry for map input".into()) + }) + .unwrap(); + let record = native + .prepare_hints(&[]) + .unwrap() + .with_map_overrides(&overrides) + .unwrap() + .execute("root", args.to_vec()) + .unwrap(); + let trace = plan.generate(&record, "root", &args, true).unwrap(); + assert_eq!( + trace, + plan.generate_reference(&record, "root", &args, true).unwrap() + ); + plan.check(&record, &trace, "root", &args).unwrap(); + assert_eq!( + serde_json::to_value(&trace).unwrap(), + serde_json::to_value( + raw_plan.generate(&raw_record, "root", &[3], true).unwrap() + ) + .unwrap() + ); + let raw_backend = Backend::new(&raw_plan, parameters()).unwrap(); + let backend = Backend::new(&plan, parameters()).unwrap(); + let expected = raw_backend.generate(&raw_record, "root", &[3]).unwrap(); + let witness = backend.generate(&record, "root", &args).unwrap(); + for (a, b) in expected.traces.iter().zip(&witness.traces) { + assert_eq!(a.width, b.width); + assert_eq!(a.values, b.values); + } + let proof = backend.prove("root", &args, &record.output, witness).unwrap(); + backend.verify("root", &args, &record.output, &proof).unwrap(); + raw_backend.verify("root", &[3], &[9], &proof).unwrap(); + assert!(backend.verify("root", &args, &[Val::from_u64(10)], &proof).is_err()); + compare_generated(&backend, &record, "root", &args); +} + +#[test] +fn resource_plan_matches_generated_trace_and_selects_retention() { + use super::planning::{Options, RetentionPolicy}; + let (program, artifact) = fixture(); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let backend = host_lookups(&plan); + let record = program.execute("root", vec![3]).unwrap(); + let actual = backend.generate_stage_1(&record, "root", &[3]).unwrap(); + let generous = + Options { max_ram_bytes: Some(u64::MAX), ..Default::default() }; + let measured = backend.plan_batch(&record, &generous).unwrap(); + assert_eq!( + measured.stage1_cells, + actual.iter().map(|m| m.values.len() as u64).sum::() + ); + assert!(measured.fits); + let heights: Vec<_> = + backend + .system + .circuits + .iter() + .map(|c| { + if c.preprocessed_height == 0 { 32768 } else { c.preprocessed_height } + }) + .collect(); + let retained = backend + .plan_heights( + &heights, + &Options { max_rows: Some(256), ..generous.clone() }, + 0, + ) + .unwrap(); + let regenerated = backend + .plan_heights( + &heights, + &Options { + max_rows: Some(256), + retention: RetentionPolicy::Regenerate, + ..generous.clone() + }, + 0, + ) + .unwrap(); + assert_eq!(retained.shards, 128); + assert_eq!(retained.retention, RetentionPolicy::Retain); + assert!(retained.proving_peak_bytes > regenerated.proving_peak_bytes); + let automatic = backend + .plan_heights( + &heights, + &Options { + max_rows: Some(256), + max_ram_bytes: Some( + regenerated.proving_peak_bytes.max(regenerated.generation_peak_bytes), + ), + ..Default::default() + }, + 0, + ) + .unwrap(); + assert!(automatic.fits); + assert_eq!(automatic.retention, RetentionPolicy::Regenerate); + let impossible = backend + .plan_heights( + &heights, + &Options { max_ram_bytes: Some(1), ..Default::default() }, + 0, + ) + .unwrap(); + assert!(!impossible.fits); + assert!(impossible.suggested_parts > 1); + let floor = backend.plan_fixed(&generous, 0).unwrap(); + assert_eq!(floor.shards, 1); + assert!(floor.stage1_cells < regenerated.stage1_cells); + assert!( + !backend + .plan_fixed( + &Options { + max_ram_bytes: Some(floor.proving_peak_bytes - 1), + ..Default::default() + }, + 0 + ) + .unwrap() + .fits + ); + let mut wrong = heights; + let table = backend + .system + .circuits + .iter() + .position(|c| c.preprocessed_height > 0) + .unwrap(); + wrong[table] *= 2; + assert!(backend.plan_heights(&wrong, &generous, 0).is_err()); + #[cfg(not(feature = "cuda"))] + assert!( + Options { device: Some(0), ..Default::default() }.validate().is_err() + ); +} + +#[test] +fn device_cell_budget_bounds_every_shard() { + use super::planning::Options; + let (program, artifact) = fixture(); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let backend = Backend::for_batch(&plan, parameters()).unwrap(); + let heights: Vec<_> = + backend + .system + .circuits + .iter() + .map(|c| { + if c.preprocessed_height == 0 { 32768 } else { c.preprocessed_height } + }) + .collect(); + let generous = + Options { max_ram_bytes: Some(u64::MAX), ..Default::default() }; + let with = |cells, rows| Options { + max_cells: Some(cells), + max_rows: rows, + ..generous.clone() + }; + let whole = backend.plan_heights(&heights, &with(u64::MAX, None), 0).unwrap(); + assert_eq!((whole.shards, whole.max_rows), (1, 32768)); + assert_eq!(whole.device_cells, Some(u64::MAX)); + // One row per circuit plus the full fixed tables cannot be split further. + let floor = + backend.plan_heights(&heights, &with(u64::MAX, Some(1)), 0).unwrap(); + assert!(floor.shard_cells < whole.shard_cells); + let limit = (whole.shard_cells + floor.shard_cells) / 2; + let bounded = backend.plan_heights(&heights, &with(limit, None), 0).unwrap(); + assert!(bounded.fits); + assert!(bounded.shards > 1 && bounded.shard_cells <= limit); + assert_eq!(bounded.shards, 32768 / bounded.max_rows); + // The bound only lowers an explicit row cap; it never raises it. + let capped = + backend.plan_heights(&heights, &with(u64::MAX, Some(1024)), 0).unwrap(); + assert_eq!(capped.max_rows, 1024); + let impossible = backend + .plan_heights(&heights, &with(floor.shard_cells - 1, None), 0) + .unwrap(); + assert!(!impossible.fits); + assert!( + Options { max_cells: Some(0), ..Default::default() }.validate().is_err() + ); +} +#[cfg(feature = "cuda")] +#[test] +fn cuda_host_plan_omits_device_phases() { + use super::planning::{Options, RetentionPolicy}; + let (program, artifact) = fixture(); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let backend = Backend::for_batch(&plan, parameters()).unwrap(); + let rows = 32768; + let heights: Vec<_> = backend + .system + .circuits + .iter() + .map( + |c| if c.preprocessed_height == 0 { rows } else { c.preprocessed_height }, + ) + .collect(); + let (cpu, _, prep) = backend.prove_allocation(&heights, rows); + let retained = backend.device_host_allocation(&heights, rows, 1, false); + let regenerated = backend.device_host_allocation(&heights, rows, 1, true); + // Without the constant upload staging, a copied witness is still below the + // CPU commitment phases. + assert!(retained < regenerated && regenerated - (256 << 20) < cpu); + // Several shards keep a second witness prepared ahead of the prover. + let half = rows / 2; + assert!( + backend.device_host_allocation(&heights, half, 2, true) + > backend.device_host_allocation(&heights, half, 1, true) + ); + // A single retained shard is charged its lookups and staging beside the + // source matrices, not the CPU commitment phases. + let options = Options { + max_ram_bytes: Some(u64::MAX), + max_cells: Some(u64::MAX), + ..Default::default() + }; + let whole = backend.plan_heights(&heights, &options, 0).unwrap(); + assert_eq!((whole.shards, whole.retention), (1, RetentionPolicy::Retain)); + let cells: u128 = heights + .iter() + .zip(&backend.system.circuits) + .map(|(&h, c)| h as u128 * c.main_width as u128) + .sum(); + assert_eq!( + u128::from(whole.proving_peak_bytes), + ((cells * 8 + prep + retained) * 5).div_ceil(4) + ); +} +#[test] +fn lean_grouped_layout_shares_rows_and_preserves_proofs() { + #[derive(serde::Deserialize)] + struct Package { + program: crate::Program, + trace: crate::trace::TraceArtifact, + } + let package: Package = serde_json::from_str(include_str!(concat!( + env!("CARGO_MANIFEST_DIR"), + "/tests/fixtures/grouping.json" + ))) + .unwrap(); + assert_eq!(package.trace.groups.len(), 1); + let group = &package.trace.groups[0]; + assert_eq!(group.members.len(), 3); + let selectors: Vec<_> = group.members.iter().map(|m| m.selector).collect(); + let program = package.program.check().unwrap(); + let mut plain = package.trace.clone(); + plain.groups.clear(); + let ungrouped = TracePlan::new(&program, plain).unwrap(); + let plan = TracePlan::new(&program, package.trace).unwrap(); + let backend = Backend::for_batch(&plan, parameters()).unwrap(); + let plain_backend = Backend::for_batch(&ungrouped, parameters()).unwrap(); + assert_eq!(plain_backend.statistics().len(), backend.statistics().len() + 2); + assert!(backend.statistics().iter().all(|c| c.quotient_degree <= 2)); + let entry = "Grouped::run"; + let record = program.execute(entry, vec![3]).unwrap(); + assert_eq!(record.output, vec![140]); + let reference = ungrouped.generate(&record, entry, &[3], true).unwrap(); + ungrouped.check(&record, &reference, entry, &[3]).unwrap(); + let converted = backend.witness(&record, &reference).unwrap(); + let direct = backend.generate(&record, entry, &[3]).unwrap(); + for (a, b) in converted.traces.iter().zip(&direct.traces) { + assert_eq!(a.width, b.width); + assert_eq!(a.values, b.values); + } + let ci = + backend.names.iter().position(|n| n == "arithmetic_and_memory").unwrap(); + assert_eq!(direct.traces[ci].height(), 8); + assert!( + direct.traces[ci].values[5 * direct.traces[ci].width..] + .iter() + .all(|&v| v == Val::ZERO) + ); + let expected_cells: u64 = + direct.traces.iter().map(|t| t.values.len() as u64).sum(); + let budget = + backend.plan_batch(&record, &planning::Options::default()).unwrap(); + assert_eq!(budget.stage1_cells, expected_cells); + let proof = backend + .prove_batch( + entry, + &[3], + &record.output, + direct.clone(), + 2, + multi_stark::batch::Retention::Retain, + ) + .unwrap(); + backend.verify_batch(entry, &[3], &record.output, &proof).unwrap(); + for attack in 0..3 { + let mut forged = direct.traces.clone(); + let width = forged[ci].width; + let row = &mut forged[ci].values[..width]; + let active = selectors.iter().position(|&s| row[s] == Val::ONE).unwrap(); + match attack { + 0 => row[selectors[active]] = Val::TWO, + 1 => row[selectors[(active + 1) % selectors.len()]] = Val::ONE, + _ => { + // An inactive padding row cannot impersonate a provider. + forged[ci].values[5 * width + width - 1] = Val::ONE; + }, + } + assert!( + backend + .prove_batch_stage_1( + entry, + &[3], + &record.output, + forged, + 8, + multi_stark::batch::Retention::Retain + ) + .is_err() + ); + } +} + +/// GPU population (`AIUR_GPU_TRACE=generated`) proves the same bytes as host +/// population, for whole and sharded batches under both retention policies, +/// including a grouped circuit's placement on the device. +#[cfg(feature = "cuda")] +#[test] +fn gpu_population_proves_identically() { + use multi_stark::batch::Retention; + #[derive(serde::Deserialize)] + struct Package { + program: crate::Program, + trace: crate::trace::TraceArtifact, + } + let package: Package = serde_json::from_str(include_str!(concat!( + env!("CARGO_MANIFEST_DIR"), + "/tests/fixtures/grouping.json" + ))) + .unwrap(); + let program = package.program.check().unwrap(); + let plan = TracePlan::new(&program, package.trace).unwrap(); + let mut backend = + Backend::build_with_lookup_policy(&plan, parameters(), true, None, true) + .unwrap(); + let plans = super::gpu::DevicePlans::new(&backend); + let device_circuits: Vec<_> = plans + .circuits + .iter() + .enumerate() + .filter(|(_, on)| **on) + .map(|(ci, _)| backend.names[ci].clone()) + .collect(); + assert!(!device_circuits.is_empty(), "fixture has no device circuit"); + let entry = "Grouped::run"; + let record = program.execute(entry, vec![3]).unwrap(); + for rows in [2, 8] { + for retention in [Retention::Retain, Retention::Regenerate] { + backend.device_plans = None; + let host = backend + .prove_batch_stage_1( + entry, + &[3], + &record.output, + backend.generate_stage_1(&record, entry, &[3]).unwrap(), + rows, + retention, + ) + .unwrap(); + backend.device_plans = Some(super::gpu::DevicePlans::new(&backend)); + let stage = backend.prepare_stage_1(&record, entry, &[3]).unwrap(); + assert_eq!( + stage.cells(), + backend + .generate_stage_1(&record, entry, &[3]) + .unwrap() + .iter() + .map(|t| t.values.len() as u64) + .sum::() + ); + let device = backend + .prove_stage_one(entry, &[3], &record.output, stage, rows, retention) + .unwrap(); + assert_eq!( + device.to_bytes().unwrap(), + host.to_bytes().unwrap(), + "{device_circuits:?} with {rows} rows, {retention:?}" + ); + } + } +} diff --git a/crates/aiur/src/trace/stark/tests/partition.rs b/crates/aiur/src/trace/stark/tests/partition.rs new file mode 100644 index 000000000..d7d2587b3 --- /dev/null +++ b/crates/aiur/src/trace/stark/tests/partition.rs @@ -0,0 +1,244 @@ +use super::*; +use crate::{ + budget::{BudgetError, RecordPool}, + execute::Partition, +}; +use multi_stark::batch::Retention; + +#[test] +fn cached_helpers_preserve_cross_record_cycle_edges() { + let unit = json!({"kind":"tuple", "items":[]}); + let program = serde_json::from_value::(json!({ + "version":1,"modulus":Val::ORDER_U64,"enums":[],"maps":[],"tables":[], + "functions":[ + {"name":"owned","params":[f()],"result":unit,"registers":1,"code":[ + {"op":"call","function":1,"args":[],"dest":[]}, + {"op":"ret","value":[]}]}, + {"name":"helper","params":[],"result":unit,"registers":1,"code":[ + {"op":"literal","dest":0,"value":2}, + {"op":"call","function":0,"args":[0],"dest":[]}, + {"op":"ret","value":[]}]} + ],"entries":[] + })) + .unwrap() + .check() + .unwrap(); + let record = program + .prepare_hints(&[]) + .unwrap() + .execute_partition( + None, + Partition { + function: 0, + owned: vec![vec![0], vec![1]], + memory_start: 0, + memory_end: 100, + }, + None, + ) + .unwrap(); + // owned(1) hits the helper memoized by owned(0). Omitting its edge would + // hide a cycle if the other record's owned(2) depends on owned(1). + let edges: std::collections::HashSet<_> = record.partition_edges().collect(); + assert_eq!( + edges, + [(&[0][..], &[2][..]), (&[1][..], &[2][..])].into_iter().collect() + ); + assert_eq!(record.deferred_calls().collect::>(), [(&[2][..], 1)]); +} + +#[test] +fn reservation_limits_growth_and_follows_record_storage() { + let (program, _) = fixture(); + let hints = program.prepare_hints(&[]).unwrap(); + let pool = RecordPool::new(1 << 20, 128).with_record_limit(256); + let reservation = pool.try_admit().unwrap().unwrap(); + let error = + hints.execute_reserved("root", vec![3], &reservation).unwrap_err(); + assert!(matches!(error.resource, Some(BudgetError::Exceeded { .. }))); + drop(reservation); + assert_eq!(pool.stats().reserved, 0); + + let pool = RecordPool::new(8 << 20, 1 << 20); + let reservation = pool.try_admit().unwrap().unwrap(); + let record = hints.execute_reserved("root", vec![3], &reservation).unwrap(); + reservation.finish_execution(); + let charged = reservation.bytes(); + assert!(charged > 0); + let memory = record.memory; + drop(record.queries); + drop(reservation); + assert_eq!(pool.stats().reserved, charged); + drop(memory); + assert_eq!(pool.stats().reserved, 0); +} + +#[test] +fn unit_call_partitions_balance_one_claim_with_disjoint_roms() { + let unit = json!({"kind":"tuple", "items":[]}); + let program: Program = serde_json::from_value(json!({ + "version":1,"modulus":Val::ORDER_U64,"enums":[], "maps":[],"tables":[], + "functions":[ + {"name":"root","params":[f()],"result":f(),"registers":3,"code":[ + {"op":"call","function":1,"args":[0],"dest":[]}, + {"op":"store","type":f(),"value":[0],"dest":1}, + {"op":"load","type":f(),"pointer":1,"dest":[2]}, + {"op":"ret","value":[2]}]}, + {"name":"leaf","params":[f()],"result":unit,"registers":3,"code":[ + {"op":"store","type":f(),"value":[0],"dest":1}, + {"op":"load","type":f(),"pointer":1,"dest":[2]}, + {"op":"assert_eq","left":[0],"right":[2]}, + {"op":"ret","value":[]}]} + ], "entries":[{"name":"root","function":0,"inputs":[f()],"output":f()}] + })) + .unwrap(); + let functions: Vec<_> = ["root","leaf"].iter().map(|&name| { + let mut steps = vec![]; + if name == "root" { steps.push(step(json!({"op":"call","name":"leaf","args":[v(0)],"dest":[]}))); } + steps.extend([ + step(json!({"op":"store","type":f(),"values":[v(0)],"dest":1})), + step(json!({"op":"load","type":f(),"address":v(1),"dest":[2]}))]); + json!({"name":name,"chip":name,"witnesses":3,"inputs":[0], + "output":if name == "root" {vec![2]} else {vec![]},"steps":steps,"writes":writes(3)}) + }).collect(); + let chips: Vec<_> = ["root","leaf"].iter().map(|&name| json!({ + "name":name,"width":3,"inputs":[0],"output":if name == "root" {vec![v(2)]} else {vec![]}, + "constraints":[{"sub":[v(0),v(2)]}], + "sends":if name == "root" {vec![json!({"channel":"leaf","args":[v(0)],"result":[],"enable":k(1)})]} else {vec![]}, + "memory":[{"type":f(),"address":v(1),"values":[v(0)],"enable":k(1)}, + {"type":f(),"address":v(1),"values":[v(2)],"enable":k(1)}] + })).collect(); + let artifact = activate(raw_artifact( + json!({"version":1,"modulus":Val::ORDER_U64,"functions":functions,"chips":chips}), + )); + let program = program.check().unwrap(); + let plan = TracePlan::new(&program, artifact).unwrap(); + let backend = super::host_lookups(&plan); + let hints = program.prepare_hints(&[]).unwrap(); + let caller = hints + .execute_partition( + Some(("root", vec![3])), + Partition { + function: 1, + owned: vec![], + memory_start: 0, + memory_end: 100, + }, + None, + ) + .unwrap(); + assert_eq!(caller.output, [3]); + assert_eq!(caller.deferred_calls().collect::>(), [(&[3][..], 1)]); + let mut owner = hints + .execute_partition( + None, + Partition { + function: 1, + owned: vec![vec![3]], + memory_start: 100, + memory_end: 200, + }, + None, + ) + .unwrap(); + assert!(backend.generate_record_stage_1(&owner).is_err()); + assert!(owner.absorb_deferred(1, &[4], 1).is_err()); + owner.absorb_deferred(1, &[3], 1).unwrap(); + assert_eq!(owner.memory.get(0).unwrap().address, 100); + let intervals = [ + backend.record_shape(&caller).unwrap(), + backend.record_shape(&owner).unwrap(), + ] + .into_iter() + .flat_map(|s| s.memory_intervals) + .collect::>(); + assert_eq!(intervals, [(1, 0, 1), (1, 100, 101)]); + let shapes = [ + backend.record_shape(&caller).unwrap(), + backend.record_shape(&owner).unwrap(), + ]; + let records: Vec<_> = + shapes.iter().map(|s| (s.heights.as_slice(), 1)).collect(); + let regen_options = planning::Options { + max_ram_bytes: Some(1 << 30), + retention: planning::RetentionPolicy::Regenerate, + ..Default::default() + }; + let regen_plan = backend.plan_stream(&records, ®en_options).unwrap(); + let retain_options = planning::Options { + retention: planning::RetentionPolicy::Retain, + ..regen_options.clone() + }; + let retain_plan = backend.plan_stream(&records, &retain_options).unwrap(); + assert!(retain_plan.peak_bytes > regen_plan.peak_bytes); + let tight = planning::Options { + max_ram_bytes: Some(regen_plan.peak_bytes), + retention: planning::RetentionPolicy::Auto, + ..Default::default() + }; + let auto = backend.plan_stream(&records, &tight).unwrap(); + assert!(auto.fits); + assert_eq!(auto.retention, planning::RetentionPolicy::Regenerate); + assert!( + !backend + .plan_stream( + &records, + &planning::Options { + retention: planning::RetentionPolicy::Retain, + ..tight + } + ) + .unwrap() + .fits + ); + let traces = [ + backend.generate_stage_1(&caller, "root", &[3]).unwrap(), + backend.generate_record_stage_1(&owner).unwrap(), + ]; + let prove = |retention| { + backend.prove_streamed_stage_1( + "root", + &[3], + &[3], + StreamPlan { shards: 2, memory_intervals: intervals.clone(), retention }, + |i| Ok(traces[i].clone()), + ) + }; + let retained = prove(Retention::Retain).unwrap(); + let regenerated = prove(Retention::Regenerate).unwrap(); + assert_eq!(retained.to_bytes().unwrap(), regenerated.to_bytes().unwrap()); + backend.verify_batch("root", &[3], &[3], ®enerated).unwrap(); + assert!(backend.verify_batch("root", &[4], &[3], ®enerated).is_err()); + let mut bad = regenerated.clone(); + bad.preamble.messages[2].args[2] = Val::ZERO; + assert!(backend.verify_batch("root", &[3], &[3], &bad).is_err()); + assert!( + backend + .prove_streamed_stage_1( + "root", + &[3], + &[3], + StreamPlan { + shards: 2, + memory_intervals: intervals, + retention: Retention::Regenerate + }, + |_| Err("replay failed".into()) + ) + .is_err() + ); + assert!( + hints + .execute_partition( + Some(("root", vec![3])), + Partition { + function: 0, + owned: vec![], + memory_start: 0, + memory_end: 100 + }, + None + ) + .is_err() + ); +} diff --git a/crates/aiur/src/trace/stark/witness.rs b/crates/aiur/src/trace/stark/witness.rs new file mode 100644 index 000000000..396d2b2c4 --- /dev/null +++ b/crates/aiur/src/trace/stark/witness.rs @@ -0,0 +1,515 @@ +//! Populate main rows and lookup messages together, directly in backend storage. +//! The lookup writer is compiled from the backend's actual constraint graph; +//! it introduces no alternate message encoding or changes to the circuits. +use super::*; +use multi_stark::{ + expr::{RowOffset, Source}, + graph::{ConstraintGraph, Node}, + lookup::{LookupRowMut, LookupValues}, +}; +#[derive(Clone, Copy)] +enum Value { + Constant(Val), + Main(usize), + Preprocessed(usize), + Scratch(usize), +} +impl Value { + #[inline] + fn get(self, row: &[Val], fixed: &[Val], scratch: &[Val]) -> Val { + match self { + Self::Constant(value) => value, + Self::Main(i) => row[i], + Self::Preprocessed(i) => fixed[i], + Self::Scratch(i) => scratch[i], + } + } +} + +enum Arithmetic { + Add(Value, Value), + Sub(Value, Value), + Mul(Value, Value), + Neg(Value), +} +struct Slot { + multiplicity: Value, + args: Arguments, +} + +struct CopySpan { + source: usize, + destination: usize, + len: usize, +} + +#[derive(Default)] +/// Partition argument sources once and coalesce adjacent copies. Filling a +/// lookup then needs no per-argument source dispatch or temporary argument Vec. +struct Arguments { + width: usize, + constants: Vec<(usize, Val)>, + main: Vec, + fixed: Vec, + scratch: Vec, +} + +impl Arguments { + fn compile(values: &[Value]) -> Self { + let mut plan = Self { width: values.len(), ..Self::default() }; + for (destination, value) in values.iter().copied().enumerate() { + let (spans, source) = match value { + Value::Constant(v) => { + // Lookup builder storage starts at zero. + if v != Val::ZERO { + plan.constants.push((destination, v)); + } + continue; + }, + Value::Main(i) => (&mut plan.main, i), + Value::Preprocessed(i) => (&mut plan.fixed, i), + Value::Scratch(i) => (&mut plan.scratch, i), + }; + if let Some(last) = spans.last_mut() + && last.source + last.len == source + && last.destination + last.len == destination + { + last.len += 1; + } else { + spans.push(CopySpan { source, destination, len: 1 }); + } + } + plan + } + + /// Populate a fresh, zeroed slot exactly once. Constant-zero arguments are + /// intentionally left untouched, as are all inactive lookup slots. + #[inline] + fn fill( + &self, + row: &[Val], + fixed: &[Val], + scratch: &[Val], + args: &mut [Val], + ) { + for &(destination, value) in &self.constants { + args[destination] = value; + } + for (spans, source) in + [(&self.main, row), (&self.fixed, fixed), (&self.scratch, scratch)] + { + for span in spans { + if span.len == 1 { + args[span.destination] = source[span.source]; + } else { + args[span.destination..span.destination + span.len] + .copy_from_slice(&source[span.source..span.source + span.len]); + } + } + } + } +} + +/// Leaf references read directly from the completed row. Only arithmetic needs +/// scratch slots; constants and column copies require no graph instructions. +pub(super) struct LookupPlan { + arithmetic: Vec, + slots: Vec, + widths: Vec, +} +impl LookupPlan { + pub(super) fn compile(graph: &ConstraintGraph) -> Result { + let mut values = Vec::with_capacity(graph.lookup_prefix_len); + let mut arithmetic = vec![]; + for node in &graph.nodes[..graph.lookup_prefix_len] { + let op = match *node { + Node::Const(value) => { + values.push(Value::Constant(value)); + continue; + }, + Node::Var(col) if col.offset == RowOffset::Current => { + values.push(match col.source { + Source::Main => Value::Main(col.index as usize), + Source::Preprocessed => Value::Preprocessed(col.index as usize), + Source::Stage2 => return Err("stage-two lookup input".into()), + }); + continue; + }, + Node::Add(a, b) => { + Arithmetic::Add(values[a.index()], values[b.index()]) + }, + Node::Sub(a, b) => { + Arithmetic::Sub(values[a.index()], values[b.index()]) + }, + Node::Mul(a, b) => { + Arithmetic::Mul(values[a.index()], values[b.index()]) + }, + Node::Neg(a) => Arithmetic::Neg(values[a.index()]), + _ => return Err("lookup requires a nonlocal row input".into()), + }; + values.push(Value::Scratch(arithmetic.len())); + arithmetic.push(op); + } + let slots: Vec<_> = graph + .lookups + .iter() + .map(|lookup| { + let mut args: Vec<_> = + lookup.args.iter().map(|id| values[id.index()]).collect(); + // The protocol fingerprints sum(args[i] * gamma^i), so a + // suffix of compile-time zeros contributes nothing. Message + // namespaces and callable/type/width IDs still fix its shape. + while matches!(args.last(), Some(Value::Constant(v)) if *v == Val::ZERO) + { + args.pop(); + } + Slot { + multiplicity: values[lookup.multiplicity.index()], + args: Arguments::compile(&args), + } + }) + .collect(); + let widths = slots.iter().map(|slot| slot.args.width).collect(); + Ok(Self { arithmetic, slots, widths }) + } + + fn fill( + &self, + row: &[Val], + fixed: &[Val], + worker: &mut Worker, + lookup: &mut LookupRowMut<'_, Val>, + ) { + let scratch = &mut worker.lookup_scratch; + scratch.clear(); + for op in &self.arithmetic { + let get = |value: Value| value.get(row, fixed, scratch); + let value = match *op { + Arithmetic::Add(a, b) => get(a) + get(b), + Arithmetic::Sub(a, b) => get(a) - get(b), + Arithmetic::Mul(a, b) => get(a) * get(b), + Arithmetic::Neg(a) => -get(a), + }; + scratch.push(value); + } + for (slot, plan) in self.slots.iter().enumerate() { + let multiplicity = plan.multiplicity.get(row, fixed, scratch); + // Zero-multiplicity messages do not affect the lookup argument. + // Fresh builder storage already contains the empty lookup. + if multiplicity == Val::ZERO { + continue; + } + worker.lookup_args.clear(); + worker.lookup_args.resize(plan.args.width, Val::ZERO); + plan.args.fill(row, fixed, scratch, &mut worker.lookup_args); + lookup.push(slot, multiplicity, &worker.lookup_args); + } + } + + /// Exercise the production writer and expose its stored messages to the + /// independent constraint-graph evaluator in tests. + #[cfg(test)] + pub(super) fn evaluate( + &self, + row: &[Val], + fixed: &[Val], + mut emit: impl FnMut(usize, Val, &[Val]), + ) { + let mut scratch = Vec::with_capacity(self.arithmetic.len()); + for op in &self.arithmetic { + let get = |value: Value| value.get(row, fixed, &scratch); + let value = match *op { + Arithmetic::Add(a, b) => get(a) + get(b), + Arithmetic::Sub(a, b) => get(a) - get(b), + Arithmetic::Mul(a, b) => get(a) * get(b), + Arithmetic::Neg(a) => -get(a), + }; + scratch.push(value); + } + let mut args = Vec::new(); + for (slot, plan) in self.slots.iter().enumerate() { + let multiplicity = plan.multiplicity.get(row, fixed, &scratch); + if multiplicity != Val::ZERO { + args.clear(); + args.resize(plan.args.width, Val::ZERO); + plan.args.fill(row, fixed, &scratch, &mut args); + emit(slot, multiplicity, &args); + } + } + } +} + +struct Worker { + scratch: Vec, + buffer: Vec, + lookup_scratch: Vec, + lookup_args: Vec, +} + +impl Default for Worker { + fn default() -> Self { + Self { + scratch: Default::default(), + buffer: Default::default(), + lookup_scratch: Default::default(), + lookup_args: Default::default(), + } + } +} + +/// A few rows per task amortize scheduling and scratch allocation while letting +/// a large circuit use the whole pool alongside the many small circuits. +const ROW_BATCH: usize = 32; + +impl Backend<'_, '_, B> { + /// Generate a complete stage-one witness from the immutable query record. + /// Main rows and their lookup messages are populated together. With the + /// `parallel` feature, circuits and real-row batches share the Rayon pool. + pub fn generate( + &self, + record: &Execution, + entry: &str, + args: &[B::Element], + ) -> Result, String> { + if self.gpu_lookup_only { + Ok(self.witness_from_main(self.generate_stage_1(record, entry, args)?)) + } else { + self.generate_with::(record, Some((entry, args)), &[]) + } + } + + /// Batch proving creates lookup buffers per shard. Avoid allocating their + /// whole-trace counterparts during the initial row population. + pub fn generate_stage_1( + &self, + record: &Execution, + entry: &str, + args: &[B::Element], + ) -> Result>, String> { + Ok(self.generate_with::(record, Some((entry, args)), &[])?.traces) + } + + /// A worker record may have no public entrypoint of its own. Its unresolved + /// calls are checked by the combined batch, never by a separate claim. + pub fn generate_record_stage_1( + &self, + record: &Execution, + ) -> Result>, String> { + Ok(self.generate_with::(record, None, &[])?.traces) + } + + /// Circuits with a `device` height are populated on the GPU; their host + /// matrices are left empty. + pub(super) fn generate_with( + &self, + record: &Execution, + root: Option<(&str, &[B::Element])>, + device: &[Option], + ) -> Result, String> { + #[cfg(feature = "trace-profile")] + let mut profile = super::profile::Phases::new(); + self.plan.validate_record(record)?; + if let Some((entry, args)) = root { + self.plan.root(record, entry, args)?; + } + #[cfg(feature = "trace-profile")] + profile.mark("validate_and_root"); + let table_counts = self.auxiliary_counts(record)?; + #[cfg(feature = "trace-profile")] + profile.mark("auxiliary_counts"); + let generate = |ci: usize| { + #[cfg(feature = "trace-profile")] + let start = std::time::Instant::now(); + let result = if device.get(ci).copied().flatten().is_some() { + Ok(( + RowMajorMatrix::new(vec![], self.system.circuits[ci].main_width), + LookupValues::builder(0, &self.lookup_plans[ci].widths).finish(), + )) + } else if ci < self.members.len() { + self.function_witness::(ci, record) + } else { + let table = ci - self.members.len(); + let trace = if let Some(table) = self.tables.get(table) { + table.witness(&table_counts) + } else { + self.rom.witness(record, table - self.tables.len())? + }; + let lookups = if LOOKUPS { + self.auxiliary_lookups(ci, &trace) + } else { + LookupValues::builder(0, &self.lookup_plans[ci].widths).finish() + }; + Ok((trace, lookups)) + }; + #[cfg(feature = "trace-profile")] + profile.circuit(ci, start.elapsed()); + result + }; + #[cfg(feature = "parallel")] + let results = (0..self.system.circuits.len()) + .into_par_iter() + .map(generate) + .collect::, String>>()?; + #[cfg(not(feature = "parallel"))] + let results = (0..self.system.circuits.len()) + .map(generate) + .collect::, String>>()?; + let (traces, lookups): (Vec<_>, Vec<_>) = results.into_iter().unzip(); + #[cfg(feature = "trace-profile")] + profile.mark("populate_circuits"); + let (active, degrees) = self.trace_shape_with(&traces, device)?; + self.check_shape(&active, °rees)?; + #[cfg(feature = "trace-profile")] + { + profile.mark("check_shape"); + drop(table_counts); + profile.mark("cleanup"); + profile.finish(&self.names, LOOKUPS); + } + Ok(SystemWitness { traces, lookups }) + } + + fn function_witness( + &self, + ci: usize, + record: &Execution, + ) -> Result<(RowMajorMatrix, LookupValues), String> { + let mut rows = vec![]; + for &function in &self.members[ci] { + rows.extend( + (0..record.queries.tables[function].len()) + .map(|query| (function, query)), + ); + } + let height = if rows.is_empty() { + 0 + } else { + rows.len().checked_next_power_of_two().ok_or("trace height overflow")? + }; + let width = self.system.circuits[ci].main_width; + let mut values = + Val::zero_vec(height.checked_mul(width).ok_or("trace size overflow")?); + let lookup_plan = &self.lookup_plans[ci]; + let mut builder = LookupValues::builder( + if LOOKUPS { height } else { 0 }, + &lookup_plan.widths, + ); + let mut writers = builder.rows_mut(); + let populate = |worker: &mut Worker, + batch: usize, + cells: &mut [Val], + lookups: &mut [LookupRowMut<'_, Val>]| { + for (i, row) in cells.chunks_mut(width).enumerate() { + let (function, query) = rows[batch * ROW_BATCH + i]; + let table = &record.queries.tables[function]; + let output = table.output(query); + if output.multiplicity >= Val::ORDER_U64 { + return Err("function count reaches field characteristic".into()); + } + let placement = &self.placements[self.plan.members[function]]; + self.plan.fills[function] + .fill_into( + record, + (table.input(query), output), + &mut worker.scratch, + &mut worker.buffer, + |column, value| { + row[placement.columns[column]] = B::into_stark(value) + }, + ) + .map_err(|e| { + format!( + "{} query {query}: {e}", + self.plan.artifact.functions[function].name + ) + })?; + placement.finish(row, output.multiplicity); + if LOOKUPS { + lookup_plan.fill(row, &[], worker, &mut lookups[i]); + } + } + Ok::<_, String>(()) + }; + let real_values = &mut values[..rows.len() * width]; + let real_writers = + if LOOKUPS { &mut writers[..rows.len()] } else { &mut [] }; + #[cfg(feature = "parallel")] + if LOOKUPS { + real_values + .par_chunks_mut(width * ROW_BATCH) + .zip(real_writers.par_chunks_mut(ROW_BATCH)) + .enumerate() + .try_for_each_init( + Worker::::default, + |worker, (batch, (cells, lookups))| { + populate(worker, batch, cells, lookups) + }, + )?; + } else { + real_values + .par_chunks_mut(width * ROW_BATCH) + .enumerate() + .try_for_each_init( + Worker::::default, + |worker, (batch, cells)| populate(worker, batch, cells, &mut []), + )?; + } + #[cfg(not(feature = "parallel"))] + { + let mut worker = Worker::::default(); + if LOOKUPS { + for (batch, (cells, lookups)) in real_values + .chunks_mut(width * ROW_BATCH) + .zip(real_writers.chunks_mut(ROW_BATCH)) + .enumerate() + { + populate(&mut worker, batch, cells, lookups)?; + } + } else { + for (batch, cells) in + real_values.chunks_mut(width * ROW_BATCH).enumerate() + { + populate(&mut worker, batch, cells, &mut [])?; + } + } + } + drop(writers); + Ok((RowMajorMatrix::new(values, width), builder.finish())) + } + + pub(super) fn auxiliary_lookups( + &self, + ci: usize, + trace: &RowMajorMatrix, + ) -> LookupValues { + let plan = &self.lookup_plans[ci]; + let mut builder = LookupValues::builder(trace.height(), &plan.widths); + let mut writers = builder.rows_mut(); + let fixed = self.system.circuits[ci].preprocessed.as_ref(); + let populate = |worker: &mut Worker, + batch: usize, + lookups: &mut [LookupRowMut<'_, Val>]| { + for (i, lookup) in lookups.iter_mut().enumerate() { + let r = batch * ROW_BATCH + i; + let row = &trace.values[r * trace.width..(r + 1) * trace.width]; + let fixed_row = + fixed.map_or(&[][..], |f| &f.values[r * f.width..(r + 1) * f.width]); + plan.fill(row, fixed_row, worker, lookup); + } + }; + #[cfg(feature = "parallel")] + writers.par_chunks_mut(ROW_BATCH).enumerate().for_each_init( + Worker::::default, + |worker, (batch, lookups)| populate(worker, batch, lookups), + ); + #[cfg(not(feature = "parallel"))] + { + let mut worker = Worker::::default(); + for (batch, lookups) in writers.chunks_mut(ROW_BATCH).enumerate() { + populate(&mut worker, batch, lookups); + } + } + drop(writers); + builder.finish() + } +} diff --git a/crates/aiur/src/trace/tests.rs b/crates/aiur/src/trace/tests.rs new file mode 100644 index 000000000..215bef06e --- /dev/null +++ b/crates/aiur/src/trace/tests.rs @@ -0,0 +1,380 @@ +use super::*; +use serde_json::{Value as Json, json}; + +/// Small raw fixtures remain readable in their original column layout. The +/// integration tests also exercise the actual, proved Lean activation export. +pub(crate) fn raw_artifact(mut value: Json) -> TraceArtifact { + for chip in value["chips"].as_array_mut().unwrap() { + chip["activation"] = chip["width"].clone(); + } + serde_json::from_value(value).unwrap() +} + +pub(crate) fn activate(mut artifact: TraceArtifact) -> TraceArtifact { + let field = PrimeField::new(artifact.modulus).unwrap(); + for chip in &mut artifact.chips { + let id = chip.width; + chip.activation = id; + chip.width += 1; + let zero = vec![0; id]; + let active = Polynomial::Var(id); + let inactive = + Polynomial::Sub(Box::new([Polynomial::Const(1), active.clone()])); + let lift = |p: Polynomial| { + let constant = p.eval(&zero, field); + Polynomial::Sub(Box::new([ + p, + Polynomial::Mul(Box::new([ + Polynomial::Const(constant), + inactive.clone(), + ])), + ])) + }; + chip.constraints = + std::mem::take(&mut chip.constraints).into_iter().map(lift).collect(); + chip + .constraints + .push(Polynomial::Mul(Box::new([active, inactive.clone()]))); + for send in &mut chip.sends { + send.enable = lift(send.enable.clone()); + chip.constraints.push(Polynomial::Mul(Box::new([ + inactive.clone(), + send.enable.clone(), + ]))); + } + for cell in &mut chip.memory { + cell.enable = lift(cell.enable.clone()); + chip.constraints.push(Polynomial::Mul(Box::new([ + inactive.clone(), + cell.enable.clone(), + ]))); + } + } + artifact.version = 2; + artifact +} + +fn field() -> Json { + json!({"kind":"field"}) +} +fn var(id: usize) -> Json { + json!({"var":id}) +} +fn constant(value: u64) -> Json { + json!({"const":value}) +} +fn step(action: Json) -> Json { + json!({"guard":constant(1),"action":action}) +} +fn write(column: usize) -> Json { + json!({"column":column,"source":column,"guard":constant(1)}) +} +fn setup( + functions: Json, + plans: Json, + chips: Json, + params: Json, + output: Json, +) -> (CheckedProgram, TraceArtifact) { + let program: crate::Program = serde_json::from_value(json!({ + "version":1,"modulus":97,"functions":functions,"enums":[],"maps":[],"tables":[], + "entries":[{"name":"main","function":0,"inputs":params,"output":output}] + })) + .unwrap(); + let artifact = raw_artifact( + json!({"version":1,"modulus":97,"functions":plans,"chips":chips}), + ); + (program.check().unwrap(), artifact) +} +fn square() -> (CheckedProgram, TraceArtifact) { + setup( + json!([{"name":"main","params":[field()],"result":field(),"registers":2, + "code":[{"op":"binary","operator":"mul","left":0,"right":0,"dest":1},{"op":"ret","value":[1]}]}]), + json!([{"name":"main","chip":"main","witnesses":2,"inputs":[0],"output":[1], + "steps":[step(json!({"op":"assign","dest":[1],"values":[{"mul":[var(0),var(0)]}]}))],"writes":[write(0),write(1)]}]), + json!([{"name":"main","width":2,"inputs":[0],"output":[var(1)], + "constraints":[{"sub":[var(1),{"mul":[var(0),var(0)]}]}],"sends":[],"memory":[]}]), + json!([field()]), + field(), + ) +} + +#[test] +fn detects_corrupt_rows_counts_shapes_and_plan_indices() { + let (program, artifact) = square(); + let record = program.execute("main", vec![7]).unwrap(); + let plan = TracePlan::new(&program, activate(artifact.clone())).unwrap(); + let trace = plan.generate(&record, "main", &[7], true).unwrap(); + assert_eq!( + trace, + plan.generate_reference(&record, "main", &[7], true).unwrap() + ); + assert_eq!(trace.matrices[0].values, [7, 49, 1]); + plan.check(&record, &trace, "main", &[7]).unwrap(); + let mut bad = trace.clone(); + bad.matrices[0].values[1] = 48; + assert!( + plan.check(&record, &bad, "main", &[7]).unwrap_err().contains("constraint") + ); + let mut bad = trace.clone(); + bad.matrices[0].multiplicities[0] += 1; + assert!( + plan.check(&record, &bad, "main", &[7]).unwrap_err().contains("unbalanced") + ); + let mut bad = trace.clone(); + bad.matrices[0].height = usize::MAX; + assert!(plan.check(&record, &bad, "main", &[7]).is_err()); + let mut bad = trace.clone(); + bad.matrices[0].values[0] = 97; + assert!(plan.check(&record, &bad, "main", &[7]).is_err()); + let mut bad = artifact.clone(); + bad.functions[0].writes[0].column = 2; + assert!(TracePlan::new(&program, activate(bad)).is_err()); + let mut bad = artifact; + bad.functions[0].writes[0].guard = Polynomial::Const(97); + assert!(TracePlan::new(&program, activate(bad)).is_err()); + let mut bad = record; + bad.output[0] = 48; + assert!(plan.generate(&bad, "main", &[7], true).is_err()); + + // A record from another field can have identical callable widths. It must + // still be rejected before its words reach field arithmetic. + let mut foreign = program.program().clone(); + foreign.modulus = 101; + let foreign = foreign.check().unwrap().execute("main", vec![100]).unwrap(); + assert!(plan.generate(&foreign, "main", &[100], true).is_err()); +} + +#[test] +fn zero_width_rows_keep_their_height_and_root_count() { + let unit = json!({"kind":"tuple","items":[]}); + let (program, artifact) = setup( + json!([{"name":"main","params":[],"result":unit,"registers":0, + "code":[{"op":"ret","value":[]}]}]), + json!([{"name":"main","chip":"main","witnesses":0,"inputs":[],"output":[],"steps":[],"writes":[]}]), + json!([{"name":"main","width":0,"inputs":[],"output":[],"constraints":[],"sends":[],"memory":[]}]), + json!([]), + unit, + ); + let record = program.execute("main", vec![]).unwrap(); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let trace = plan.generate(&record, "main", &[], true).unwrap(); + assert_eq!(trace.matrices[0].height, 1); + assert_eq!(trace.matrices[0].values, [1]); + assert_eq!(trace.matrices[0].multiplicities, [1]); + plan.check(&record, &trace, "main", &[]).unwrap(); +} + +#[test] +fn hint_providers_survive_preparation_and_replay_for_each_trace() { + let mut code = vec![ + json!({"op":"hint","channel":"square","type":field(), + "key_type":field(),"key":[0],"dest":[1]}); + 10 + ]; + code.extend([ + json!({"op":"binary","operator":"mul","left":1,"right":1,"dest":2}), + json!({"op":"ret","value":[2]}), + ]); + let (program, artifact) = setup( + json!([{"name":"main","params":[field()],"result":field(),"registers":3, + "code":code}]), + json!([{"name":"main","chip":"main","witnesses":3,"inputs":[0],"output":[2], + "steps":[step(json!({"op":"hint","channel":"square","instruction":9,"type":field(),"key_type":field(),"key":[var(0)],"dest":[1]}))], + "writes":[write(0),write(1)]}]), + json!([{"name":"main","width":2,"inputs":[0],"output":[{"mul":[var(1),var(1)]}], + "constraints":[],"sends":[],"memory":[]}]), + json!([field()]), + field(), + ); + let hints = serde_json::from_value::>(json!([ + {"channel":"square","type":field(),"key_type":field(),"key":[7],"output":[7]}])) + .unwrap(); + let record = program.execute_with_hints("main", vec![7], &hints).unwrap(); + let mut mismatched = artifact.clone(); + let Action::Hint { channel, .. } = + &mut mismatched.functions[0].steps[0].action + else { + panic!() + }; + *channel = "other".into(); + assert!( + TracePlan::new(&program, activate(mismatched)) + .err() + .unwrap() + .contains("hint site mismatch") + ); + let invoked = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0)); + let mut channels = crate::hints::HintChannels::new(); + let calls = invoked.clone(); + channels + .insert_fixed::<1, 1>( + "square", + crate::bytecode::Type::Field, + crate::bytecode::Type::Field, + move |key| { + calls.fetch_add(1, std::sync::atomic::Ordering::Relaxed); + Ok(key) + }, + ) + .unwrap(); + let from_code = program + .prepare_hint_channels(&[], &channels) + .unwrap() + .execute("main", vec![7]) + .unwrap(); + assert_eq!(from_code.queries, record.queries); + drop(channels); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let good = plan.generate(&record, "main", &[7], true).unwrap(); + plan.check(&record, &good, "main", &[7]).unwrap(); + for replay in [ + plan.generate(&from_code, "main", &[7], true), + plan.generate_reference(&from_code, "main", &[7], true), + ] { + plan.check(&from_code, &replay.unwrap(), "main", &[7]).unwrap(); + } + // Execution consumed ten hints; the live trace recipe needs only the last. + assert_eq!(invoked.load(std::sync::atomic::Ordering::Relaxed), 12); + assert_eq!(plan.generate(&from_code, "main", &[7], true).unwrap(), good); + assert_eq!(invoked.load(std::sync::atomic::Ordering::Relaxed), 13); + // Repeated/parallel row generation may reorder calls. The same captured + // provider must work after its registry and PreparedHints have been dropped. + std::thread::scope(|scope| { + let workers: Vec<_> = (0..4) + .map(|_| { + scope.spawn(|| plan.generate(&from_code, "main", &[7], true).unwrap()) + }) + .collect(); + for worker in workers { + assert_eq!(worker.join().unwrap(), good); + } + }); + assert_eq!(invoked.load(std::sync::atomic::Ordering::Relaxed), 17); + // A record cannot substitute providers bound to another checked program, + // even if its function signatures and instruction sites happen to match. + let foreign = program.program().clone().check().unwrap(); + let foreign_record = + foreign.execute_with_hints("main", vec![7], &hints).unwrap(); + assert!( + plan + .generate(&foreign_record, "main", &[7], true) + .unwrap_err() + .contains("another program") + ); +} + +#[test] +fn replay_validates_provider_answers_and_propagates_errors() { + use crate::hints::HintChannels; + use std::sync::{ + Arc, + atomic::{AtomicUsize, Ordering}, + }; + let (program, artifact) = setup( + json!([{"name":"main","params":[field()],"result":field(),"registers":3, + "code":[ + {"op":"hint","channel":"identity","type":field(),"key_type":field(),"key":[0],"dest":[1]}, + {"op":"binary","operator":"mul","left":1,"right":1,"dest":2}, + {"op":"ret","value":[2]}]}]), + json!([{"name":"main","chip":"main","witnesses":3,"inputs":[0],"output":[2], + "steps":[step(json!({"op":"hint","channel":"identity","instruction":0,"type":field(),"key_type":field(),"key":[var(0)],"dest":[1]}))], + "writes":[write(0),write(1)]}]), + json!([{"name":"main","width":2,"inputs":[0],"output":[{"mul":[var(1),var(1)]}], + "constraints":[],"sends":[],"memory":[]}]), + json!([field()]), + field(), + ); + // Deliberately break repeatability after execution to exercise the checks + // on newly generated advice. A provider contract is not a trust boundary. + let mode = Arc::new(AtomicUsize::new(0)); + let mut channels = HintChannels::new(); + let state = mode.clone(); + channels + .insert("identity", Type::Field, Type::Field, move |key, output| { + assert_eq!(output, [0]); + match state.load(Ordering::Relaxed) { + 0 => output.copy_from_slice(key), + 1 => return Err("provider unavailable".into()), + _ => output[0] = 97, // noncanonical in the runtime-prime backend + } + Ok(()) + }) + .unwrap(); + let prepared = program.prepare_hint_channels(&[], &channels).unwrap(); + let record = prepared.execute("main", vec![7]).unwrap(); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + for state in [1, 2] { + mode.store(state, Ordering::Relaxed); + for result in [ + plan.generate(&record, "main", &[7], true), + plan.generate_reference(&record, "main", &[7], true), + ] { + let error = result.unwrap_err(); + if state == 1 { + assert!(error.contains("provider unavailable")); + } + } + } + mode.store(0, Ordering::Relaxed); + let trace = plan.generate(&record, "main", &[7], true).unwrap(); + plan.check(&record, &trace, "main", &[7]).unwrap(); + assert_eq!( + trace, + plan.generate_reference(&record, "main", &[7], true).unwrap() + ); +} + +#[test] +fn zero_padding_emits_no_requirements_and_preserves_execution_counts() { + let call = |name: &str, arg: Json, dest: usize| { + step(json!({"op":"call","name":name,"args":[arg],"dest":[dest]})) + }; + let send = |name: &str, arg: Json, dest: usize| json!({"channel":name,"args":[arg],"result":[dest],"enable":constant(1)}); + let (program, artifact) = setup( + json!([ + {"name":"main","params":[field()],"result":field(),"registers":6,"code":[ + {"op":"call","function":1,"args":[0],"dest":[1]}, + {"op":"literal","dest":2,"value":1},{"op":"call","function":1,"args":[2],"dest":[3]}, + {"op":"literal","dest":4,"value":2},{"op":"call","function":1,"args":[4],"dest":[5]}, + {"op":"ret","value":[5]}]}, + {"name":"middle","params":[field()],"result":field(),"registers":2,"code":[ + {"op":"call","function":2,"args":[0],"dest":[1]},{"op":"ret","value":[1]}]}, + {"name":"leaf","params":[field()],"result":field(),"registers":1,"code":[{"op":"ret","value":[0]}]} + ]), + json!([ + {"name":"main","chip":"main","witnesses":4,"inputs":[0],"output":[3], + "steps":[call("middle",var(0),1),call("middle",constant(1),2),call("middle",constant(2),3)], + "writes":[write(0),write(1),write(2),write(3)]}, + {"name":"middle","chip":"middle","witnesses":2,"inputs":[0],"output":[1], + "steps":[call("leaf",var(0),1)],"writes":[write(0),write(1)]}, + {"name":"leaf","chip":"leaf","witnesses":2,"inputs":[0],"output":[1],"steps":[],"writes":[write(0)]} + ]), + json!([ + {"name":"main","width":4,"inputs":[0],"output":[var(3)],"constraints":[],"memory":[], + "sends":[send("middle",var(0),1),send("middle",constant(1),2),send("middle",constant(2),3)]}, + {"name":"middle","width":2,"inputs":[0],"output":[var(1)],"constraints":[],"memory":[],"sends":[send("leaf",var(0),1)]}, + {"name":"leaf","width":1,"inputs":[0],"output":[var(0)],"constraints":[],"memory":[],"sends":[]} + ]), + json!([field()]), + field(), + ); + let record = program.execute("main", vec![0]).unwrap(); + let plan = TracePlan::new(&program, activate(artifact)).unwrap(); + let plain = plan.generate(&record, "main", &[0], false).unwrap(); + let padded = plan.generate(&record, "main", &[0], true).unwrap(); + assert_eq!(plain.matrices[2].multiplicities, [1, 1, 1]); + assert_eq!(padded.matrices[1].multiplicities, [1, 1, 1, 0]); + assert_eq!(padded.matrices[2].multiplicities, [1, 1, 1, 0]); + for matrix in &padded.matrices[1..] { + assert!(matrix.row(3).iter().all(|&word| word == 0)); + } + assert_eq!( + padded, + plan.generate_reference(&record, "main", &[0], true).unwrap() + ); + plan.check(&record, &padded, "main", &[0]).unwrap(); + let mut wrong = padded; + wrong.matrices[2].multiplicities[0] = 2; + assert!(plan.check(&record, &wrong, "main", &[0]).is_err()); +} diff --git a/crates/aiur/src/trace_codegen.rs b/crates/aiur/src/trace_codegen.rs deleted file mode 100644 index 7adc4d158..000000000 --- a/crates/aiur/src/trace_codegen.rs +++ /dev/null @@ -1,798 +0,0 @@ -//! 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 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 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, - 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, - }; - (self.writer.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 deleted file mode 100644 index ff0fd1181..000000000 --- a/crates/aiur/src/trace_codegen/contract.rs +++ /dev/null @@ -1,225 +0,0 @@ -//! 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 deleted file mode 100644 index d4618d37e..000000000 --- a/crates/aiur/src/trace_codegen/cuda.rs +++ /dev/null @@ -1,1030 +0,0 @@ -//! 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(&[ - u8::try_from(width.bytes()).expect("seed widths fit a byte") - ]); - } - 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, - retain_device_seeds: bool, - ) -> TraceResult<(TraceSource, LookupValues)> { - let (source, lookups) = self.prepare_trace( - circuit, - record, - io, - slots, - start, - end, - row_count, - retain_device_seeds, - )?; - Ok((TraceSource::Generated(Arc::new(source)), lookups)) - } - - /// [`Self::prepare`] before the source is erased behind the trait, so the - /// packed seeds can be inspected. - pub(crate) fn prepare_trace( - &self, - circuit: usize, - record: &QueryRecord, - io: &IOBuffer, - slots: &[usize], - start: QueryPosition, - end: QueryPosition, - row_count: usize, - retain_device_seeds: bool, - ) -> TraceResult<(CudaTrace, 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 = !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)) - .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)); - } - 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((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, -) -> 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, &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, -} - -// 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]; - -/// 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) - { - 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"); - 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"); - return None; - } - tracing::debug!( - device, - bytes, - spans = pointers.len(), - "seed cache uploaded" - ); - #[cfg(test)] - SEED_CACHE_UPLOADS.fetch_add(1, Ordering::AcqRel); - cached.push(DeviceSeeds { device, base }); - 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); - } - false - }); - } -} - -impl Drop for CudaTrace { - fn drop(&mut self) { - self.free_device_seeds(|_| false); - } -} - -#[cfg(test)] -impl CudaTrace { - /// Host memory the packed seeds occupy, reservations included. - pub(crate) fn host_bytes(&self) -> usize { - self.spans.capacity() * size_of::() - + self.spans.iter().map(|s| s.bytes.capacity()).sum::() - } -} - -impl TraceGenerator for CudaTrace { - fn height(&self) -> usize { - self.height - } - fn width(&self) -> usize { - self.width - } - 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, view: DeviceTraceView<'_>) -> Result<(), String> { - if view.width() != self.width { - return Err("CUDA trace width mismatch".into()); - } - self.write_tile( - view.device_id(), - view.first_row(), - view.rows(), - view.as_mut_ptr(), - ) - } - fn release_device(&self, device_id: i32) { - self.free_device_seeds(|device| device != device_id); - } -} - -impl CudaTrace { - /// Rows `[first_row, first_row + tile_rows)` of the padded trace, wrapping at - /// its height, written to `output` on `device`: the writer behind - /// [`TraceGenerator::write_device_rows`], reachable without a view. - fn write_tile( - &self, - device: i32, - first_row: usize, - tile_rows: usize, - output: *mut u64, - ) -> Result<(), String> { - let _span = tracing::info_span!( - "aiur/codegen_device_rows", - device, - first = first_row, - rows = tile_rows, - width = self.width - ) - .entered(); - let resident = self.resident_seeds(device); - let mut done = 0; - let mut first = first_row % self.height; - while done < tile_rows { - let index = self.span_index(first.min(self.real - 1)); - let span = &self.spans[index]; - let remaining = (tile_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)( - device, - seeds, - encoding, - real, - rows, - self.width, - span.offsets.selectors, - span.offsets.auxiliaries, - output.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(()) - } - - /// The tile [`Self::write_tile`] writes on `device`, read back as raw - /// words. - #[cfg(test)] - pub(crate) fn download_tile( - &self, - device: i32, - first_row: usize, - tile_rows: usize, - ) -> Vec { - let words = tile_rows * self.width; - let mut tile = std::ptr::null_mut(); - let status = unsafe { aiur_trace_tile_alloc(device, words, &mut tile) }; - assert_eq!(status, 0, "device tile allocation"); - let written = self.write_tile(device, first_row, tile_rows, tile); - let mut host = vec![0u64; words]; - let status = unsafe { - aiur_trace_tile_download(device, tile, words, host.as_mut_ptr()) - }; - written.expect("device writer"); - assert_eq!(status, 0, "device tile download"); - host - } -} - -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; - #[cfg(test)] - fn aiur_trace_tile_alloc( - device: i32, - words: usize, - tile: *mut *mut u64, - ) -> i32; - #[cfg(test)] - fn aiur_trace_tile_download( - device: i32, - tile: *mut u64, - words: usize, - host: *mut u64, - ) -> 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 (source, lookups) = prepare_memory_trace(record, size, slots, range)?; - Ok((TraceSource::Generated(Arc::new(source)), lookups)) -} - -/// [`prepare_memory`] before the source is erased behind the trait. -pub(crate) fn prepare_memory_trace( - record: &QueryRecord, - size: usize, - slots: &[usize], - range: std::ops::Range, -) -> TraceResult<(MemoryTrace, 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()); - let (words, _) = seed[16..].as_chunks_mut::<8>(); - for (dst, value) in words.iter_mut().zip(values) { - *dst = 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(( - 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 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, view: DeviceTraceView<'_>) -> Result<(), String> { - if view.width() != self.width() { - return Err("memory trace width mismatch".into()); - } - self.write_tile( - view.device_id(), - view.first_row(), - view.rows(), - view.as_mut_ptr(), - ) - } -} - -impl MemoryTrace { - /// Rows `[first_row, first_row + tile_rows)` of the padded trace, wrapping at - /// its height, written to `output` on `device`: the writer behind - /// [`TraceGenerator::write_device_rows`], reachable without a view. - fn write_tile( - &self, - device: i32, - first_row: usize, - tile_rows: usize, - output: *mut u64, - ) -> Result<(), String> { - let _span = tracing::info_span!( - "aiur/codegen_memory_rows", - device, - first = first_row, - rows = tile_rows, - width = self.width() - ) - .entered(); - let stride = self.stride(); - let mut done = 0; - let mut first = first_row % self.height; - while done < tile_rows { - let span = self.span(first.min(self.real - 1)); - let remaining = (tile_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( - device, - seeds, - self.values, - real, - rows, - output.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(()) - } - - /// The tile [`Self::write_tile`] writes on `device`, read back as raw - /// words. - #[cfg(test)] - pub(crate) fn download_tile( - &self, - device: i32, - first_row: usize, - tile_rows: usize, - ) -> Vec { - let words = tile_rows * self.width(); - let mut tile = std::ptr::null_mut(); - let status = unsafe { aiur_trace_tile_alloc(device, words, &mut tile) }; - assert_eq!(status, 0, "device tile allocation"); - let written = self.write_tile(device, first_row, tile_rows, tile); - let mut host = vec![0u64; words]; - let status = unsafe { - aiur_trace_tile_download(device, tile, words, host.as_mut_ptr()) - }; - written.expect("device writer"); - assert_eq!(status, 0, "device tile download"); - host - } -} diff --git a/crates/aiur/src/trace_codegen/programs/ix_aggr.rs b/crates/aiur/src/trace_codegen/programs/ix_aggr.rs deleted file mode 100644 index 0d6d2925d..000000000 --- a/crates/aiur/src/trace_codegen/programs/ix_aggr.rs +++ /dev/null @@ -1,2045 +0,0 @@ -// 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_89(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_89_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 write_89(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] = [v_165 * v_167]; row[offsets.auxiliaries + 6] = v_168.as_canonical_u64(); let [v_169]: [G; 1] = [G::from_u64(2)]; let [v_170]: [G; 1] = [v_165 - v_169]; let [v_171]: [G; 1] = [v_168 * 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_200]; row[offsets.auxiliaries + 29] = v_201.as_canonical_u64(); let [v_202]: [G; 1] = [v_199 - v_169]; let [v_203]: [G; 1] = [v_201 * 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_231]; row[offsets.auxiliaries + 52] = v_232.as_canonical_u64(); let [v_233]: [G; 1] = [v_230 - v_169]; let [v_234]: [G; 1] = [v_232 * 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_262]; row[offsets.auxiliaries + 75] = v_263.as_canonical_u64(); let [v_264]: [G; 1] = [v_261 - v_169]; let [v_265]: [G; 1] = [v_263 * 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_293]; row[offsets.auxiliaries + 98] = v_294.as_canonical_u64(); let [v_295]: [G; 1] = [v_292 - v_169]; let [v_296]: [G; 1] = [v_294 * 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_324]; row[offsets.auxiliaries + 121] = v_325.as_canonical_u64(); let [v_326]: [G; 1] = [v_323 - v_169]; let [v_327]: [G; 1] = [v_325 * 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_355]; row[offsets.auxiliaries + 144] = v_356.as_canonical_u64(); let [v_357]: [G; 1] = [v_354 - v_169]; let [v_358]: [G; 1] = [v_356 * 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_386]; row[offsets.auxiliaries + 167] = v_387.as_canonical_u64(); let [v_388]: [G; 1] = [v_385 - v_169]; let [v_389]: [G; 1] = [v_387 * 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_417]; row[offsets.auxiliaries + 190] = v_418.as_canonical_u64(); let [v_419]: [G; 1] = [v_416 - v_169]; let [v_420]: [G; 1] = [v_418 * 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_448]; row[offsets.auxiliaries + 213] = v_449.as_canonical_u64(); let [v_450]: [G; 1] = [v_447 - v_169]; let [v_451]: [G; 1] = [v_449 * 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_479]; row[offsets.auxiliaries + 236] = v_480.as_canonical_u64(); let [v_481]: [G; 1] = [v_478 - v_169]; let [v_482]: [G; 1] = [v_480 * 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_510]; row[offsets.auxiliaries + 259] = v_511.as_canonical_u64(); let [v_512]: [G; 1] = [v_509 - v_169]; let [v_513]: [G; 1] = [v_511 * 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_541]; row[offsets.auxiliaries + 282] = v_542.as_canonical_u64(); let [v_543]: [G; 1] = [v_540 - v_169]; let [v_544]: [G; 1] = [v_542 * 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_572]; row[offsets.auxiliaries + 305] = v_573.as_canonical_u64(); let [v_574]: [G; 1] = [v_571 - v_169]; let [v_575]: [G; 1] = [v_573 * 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_603]; row[offsets.auxiliaries + 328] = v_604.as_canonical_u64(); let [v_605]: [G; 1] = [v_602 - v_169]; let [v_606]: [G; 1] = [v_604 * 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_634]; row[offsets.auxiliaries + 351] = v_635.as_canonical_u64(); let [v_636]: [G; 1] = [v_633 - v_169]; let [v_637]: [G; 1] = [v_635 * 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_89: 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_120(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, 119, &[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, 89, &[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, 119, &[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, 119, &[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, 119, &[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, 119, &[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, 119, &[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, 119, &[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, 119, &[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_16 + v_125]; let [v_194]: [G; 1] = [v_193 + v_136]; let [v_195]: [G; 1] = [v_194 + v_147]; let [v_196]: [G; 1] = [v_195 + v_158]; let [v_197]: [G; 1] = [v_196 + v_169]; let [v_198]: [G; 1] = [v_197 + v_180]; let [v_199]: [G; 1] = [v_198 + v_191]; 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_217 * v_220]; let [v_224]: [G; 1] = [v_222 - 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] = [v_221 + v_236]; let [v_238]: [G; 1] = [G::from_u64(8)]; let [v_239]: [G; 1] = [v_238 * v_234]; let [v_240]: [G; 1] = [v_237 + 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, 89, &[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_120_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, 119, &[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, 89, &[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, 119, &[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, 119, &[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, 119, &[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, 119, &[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, 119, &[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, 119, &[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, 119, &[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_16 + v_125]; let [v_194]: [G; 1] = [v_193 + v_136]; let [v_195]: [G; 1] = [v_194 + v_147]; let [v_196]: [G; 1] = [v_195 + v_158]; let [v_197]: [G; 1] = [v_196 + v_169]; let [v_198]: [G; 1] = [v_197 + v_180]; let [v_199]: [G; 1] = [v_198 + v_191]; 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_217 * v_220]; let [v_224]: [G; 1] = [v_222 - 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] = [v_221 + v_236]; let [v_238]: [G; 1] = [G::from_u64(8)]; let [v_239]: [G; 1] = [v_238 * v_234]; let [v_240]: [G; 1] = [v_237 + 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, 89, &[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 write_120(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_223]: [G; 1] = [v_217 * v_220]; row[offsets.auxiliaries + 109] = v_223.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_120: 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_223(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, 222, &[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(223, v_9)) }, } }, _ => { Err(no_match(223, v_2)) }, } } - -fn pack_223_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, 222, &[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(223, v_9)) }, } }, _ => { Err(no_match(223, v_2)) }, } } - -fn write_223(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(223, v_9)) }, } }, _ => { Err(no_match(223, v_2)) }, } } - -static SCHEMA_223: 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_233(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, 232, &[v_0, v_8, v_16])?; seed[17] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = context.call::<1>(2, 232, &[v_1, v_9, v_17])?; seed[18] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = context.call::<1>(3, 232, &[v_2, v_10, v_18])?; seed[19] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = context.call::<1>(4, 232, &[v_3, v_11, v_19])?; seed[20] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = context.call::<1>(5, 232, &[v_4, v_12, v_20])?; seed[21] = v_21.as_canonical_u64(); let [v_22]: [G; 1] = context.call::<1>(6, 232, &[v_5, v_13, v_21])?; seed[22] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = context.call::<1>(7, 232, &[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_233_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, 232, &[v_0, v_8, v_16])?; seed.full(8, v_17); let [v_18]: [G; 1] = context.call::<1>(2, 232, &[v_1, v_9, v_17])?; seed.full(16, v_18); let [v_19]: [G; 1] = context.call::<1>(3, 232, &[v_2, v_10, v_18])?; seed.full(24, v_19); let [v_20]: [G; 1] = context.call::<1>(4, 232, &[v_3, v_11, v_19])?; seed.full(32, v_20); let [v_21]: [G; 1] = context.call::<1>(5, 232, &[v_4, v_12, v_20])?; seed.full(40, v_21); let [v_22]: [G; 1] = context.call::<1>(6, 232, &[v_5, v_13, v_21])?; seed.full(48, v_22); let [v_23]: [G; 1] = context.call::<1>(7, 232, &[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 write_233(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_233: 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 }; - -fn pack_261(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(); let [v_6, v_7, v_8]: [G; 3] = context.load::<3>(1, v_1)?; seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); seed[9] = v_8.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { match v_6.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_9, v_10, v_11]: [G; 3] = context.load::<3>(4, v_2)?; seed[10] = v_9.as_canonical_u64(); seed[11] = v_10.as_canonical_u64(); seed[12] = v_11.as_canonical_u64(); match v_9.as_canonical_u64() { 0u64 => { let [v_12]: [G; 1] = context.call::<1>(5, 250, &[v_4, v_7])?; seed[13] = v_12.as_canonical_u64(); match v_12.as_canonical_u64() { 0u64 => { let [v_13]: [G; 1] = context.call::<1>(6, 2, &[v_4, v_10])?; seed[14] = v_13.as_canonical_u64(); Ok(()) }, 1u64 => { Ok(()) }, _ => { let [v_17]: [G; 1] = context.call::<1>(13, 2, &[v_7, v_10])?; seed[14] = v_17.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(261, v_9)) }, } }, _ => { Err(no_match(261, v_6)) }, } }, _ => { Err(no_match(261, v_3)) }, } } - -fn pack_261_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(44, v_3); seed.u32(20, v_4); seed.u32(24, v_5); let [v_6, v_7, v_8]: [G; 3] = context.load::<3>(1, v_1)?; seed.u8(45, v_6); seed.u32(28, v_7); seed.u32(32, v_8); match v_3.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { match v_6.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_9, v_10, v_11]: [G; 3] = context.load::<3>(4, v_2)?; seed.u8(46, v_9); seed.u32(36, v_10); seed.u32(40, v_11); match v_9.as_canonical_u64() { 0u64 => { let [v_12]: [G; 1] = context.call::<1>(5, 250, &[v_4, v_7])?; seed.u8(47, v_12); match v_12.as_canonical_u64() { 0u64 => { let [v_13]: [G; 1] = context.call::<1>(6, 2, &[v_4, v_10])?; seed.u8(48, v_13); Ok(()) }, 1u64 => { Ok(()) }, _ => { let [v_17]: [G; 1] = context.call::<1>(13, 2, &[v_7, v_10])?; seed.u8(48, v_17); Ok(()) }, } }, _ => { Err(no_match(261, v_9)) }, } }, _ => { Err(no_match(261, v_6)) }, } }, _ => { Err(no_match(261, v_3)) }, } } - -fn write_261(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(); let [v_6, v_7, v_8]: [G; 3] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9])]; 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(); match v_3.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { match v_6.as_canonical_u64() { 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_9, v_10, v_11]: [G; 3] = [G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12])]; 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(); match v_9.as_canonical_u64() { 0u64 => { let [v_12]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 10] = v_12.as_canonical_u64(); match v_12.as_canonical_u64() { 0u64 => { let [v_13]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 11] = v_13.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 11] = (v_12 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.auxiliaries + 12] = (v_12 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 13] = v_17.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(261, v_9)) }, } }, _ => { Err(no_match(261, v_6)) }, } }, _ => { Err(no_match(261, v_3)) }, } } - -static SCHEMA_261: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 12, 16, 44, 20, 24, 45, 28, 32, 46, 36, 40, 47, 48], bytes: 56 }; - -fn pack_262(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(); 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(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_8]: [G; 1] = context.call::<1>(2, 250, &[v_3, v_6])?; seed[9] = v_8.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(262, v_5)) }, } }, _ => { Err(no_match(262, v_2)) }, } } - -fn pack_262_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); 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); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_8]: [G; 1] = context.call::<1>(2, 250, &[v_3, v_6])?; seed.u8(34, v_8); Ok(()) }, _ => { Err(no_match(262, v_5)) }, } }, _ => { Err(no_match(262, v_2)) }, } } - -fn write_262(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(); 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(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { match v_5.as_canonical_u64() { 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_8]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 7] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 0u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 8] = (v_8 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.auxiliaries + 9] = (v_8 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(262, v_5)) }, } }, _ => { Err(no_match(262, v_2)) }, } } - -static SCHEMA_262: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8], offsets: &[0, 8, 12, 32, 16, 20, 33, 24, 28, 34], bytes: 40 }; - -#[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]) }), (G::from_u64(1), Block { ops: vec![Op::IORead(0, 1, 1), Op::U8RangeCheck(3, 3), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![4, 3, 6])], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::IORead(0, 1, 2), Op::U8RangeCheck(3, 4), Op::Const(G::from_u64(2)), Op::Add(1, 5), Op::Sub(2, 5), Op::Call(3, vec![0, 6, 7], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![9, 4, 8]), Op::Store(vec![9, 3, 10])], ctrl: Ctrl::Return(2, vec![11]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } -} - -#[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::Mul(16, 18), Op::Const(G::from_u64(2)), Op::Sub(16, 20), Op::Mul(19, 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::Add(0, 10), Op::Const(G::from_u64(65536)), Op::Mul(12, 2), Op::Add(11, 13), Op::Const(G::from_u64(16777216)), Op::Mul(15, 3), Op::Add(14, 16), Op::Const(G::from_u64(4294967296)), Op::Mul(18, 4), Op::Add(17, 19), Op::Const(G::from_u64(1099511627776)), Op::Mul(21, 5), Op::Add(20, 22), Op::Const(G::from_u64(281474976710656)), Op::Mul(24, 6), Op::Add(23, 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::Add(0, 9), Op::Const(G::from_u64(65536)), Op::Mul(11, 2), Op::Add(10, 12), Op::Const(G::from_u64(16777216)), Op::Mul(14, 3), Op::Add(13, 15), Op::Const(G::from_u64(4294967296)), Op::Mul(17, 4), Op::Add(16, 18), Op::Const(G::from_u64(1099511627776)), Op::Mul(20, 5), Op::Add(19, 21), Op::Const(G::from_u64(281474976710656)), Op::Mul(23, 6), Op::Add(22, 24), Op::Const(G::from_u64(72057594037927936)), Op::Mul(26, 7), Op::Add(25, 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::Add(4, 5), Op::Add(8, 6), Op::Add(9, 7), Op::Const(G::from_u64(1020)), Op::Sub(10, 11), Op::EqZero(12), Op::Add(0, 1), Op::Add(14, 2), Op::Add(15, 3), 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::Add(1, 10), Op::Const(G::from_u64(65536)), Op::Mul(12, 3), Op::Add(11, 13), Op::Const(G::from_u64(16777216)), Op::Mul(15, 4), Op::Add(14, 16), Op::Const(G::from_u64(4294967296)), Op::Mul(18, 5), Op::Add(17, 19), Op::Const(G::from_u64(1099511627776)), Op::Mul(21, 6), Op::Add(20, 22), Op::Const(G::from_u64(281474976710656)), Op::Mul(24, 7), Op::Add(23, 25), Op::Const(G::from_u64(72057594037927936)), Op::Mul(27, 8), Op::Add(26, 28), Op::AssertEq(vec![29], vec![0], None), Op::Add(5, 6), Op::Add(30, 7), Op::Add(31, 8), Op::Const(G::from_u64(1020)), Op::Sub(32, 33), Op::EqZero(34), Op::Add(1, 2), Op::Add(36, 3), Op::Add(37, 4), 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::Add(1, 20), Op::Const(G::from_u64(65536)), Op::Mul(22, 3), Op::Add(21, 23), Op::Const(G::from_u64(16777216)), Op::Mul(25, 4), Op::Add(24, 26), Op::Const(G::from_u64(4294967296)), Op::Mul(28, 5), Op::Add(27, 29), Op::Const(G::from_u64(1099511627776)), Op::Mul(31, 6), Op::Add(30, 32), Op::Const(G::from_u64(281474976710656)), Op::Mul(34, 7), Op::Add(33, 35), Op::Const(G::from_u64(72057594037927936)), Op::Mul(37, 8), Op::Add(36, 38), Op::Mul(19, 11), Op::Add(10, 40), Op::Mul(22, 12), Op::Add(41, 42), Op::Mul(25, 13), Op::Add(43, 44), Op::Mul(28, 14), Op::Add(45, 46), Op::Mul(31, 15), Op::Add(47, 48), Op::Mul(34, 16), Op::Add(49, 50), Op::Mul(37, 17), Op::Add(51, 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::Add(2, 21), Op::Const(G::from_u64(65536)), Op::Mul(23, 4), Op::Add(22, 24), Op::Const(G::from_u64(16777216)), Op::Mul(26, 5), Op::Add(25, 27), Op::Const(G::from_u64(4294967296)), Op::Mul(29, 6), Op::Add(28, 30), Op::Const(G::from_u64(1099511627776)), Op::Mul(32, 7), Op::Add(31, 33), Op::Const(G::from_u64(281474976710656)), Op::Mul(35, 8), Op::Add(34, 36), Op::Const(G::from_u64(72057594037927936)), Op::Mul(38, 9), Op::Add(37, 39), Op::Mul(20, 12), Op::Add(11, 41), Op::Mul(23, 13), Op::Add(42, 43), Op::Mul(26, 14), Op::Add(44, 45), Op::Mul(29, 15), Op::Add(46, 47), Op::Mul(32, 16), Op::Add(48, 49), Op::Mul(35, 17), Op::Add(50, 51), Op::Mul(38, 18), Op::Add(52, 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::Add(0, 5), Op::Const(G::from_u64(65536)), Op::Mul(7, 2), Op::Add(6, 8), Op::Const(G::from_u64(16777216)), Op::Mul(10, 3), Op::Add(9, 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::Add(0, 33), Op::Const(G::from_u64(65536)), Op::Mul(35, 2), Op::Add(34, 36), Op::Const(G::from_u64(16777216)), Op::Mul(38, 3), Op::Add(37, 39), Op::Mul(32, 5), Op::Add(4, 41), Op::Mul(35, 6), Op::Add(42, 43), Op::Mul(38, 7), Op::Add(44, 45), Op::Mul(32, 9), Op::Add(8, 47), Op::Mul(35, 10), Op::Add(48, 49), Op::Mul(38, 11), Op::Add(50, 51), Op::Mul(32, 13), Op::Add(12, 53), Op::Mul(35, 14), Op::Add(54, 55), Op::Mul(38, 15), Op::Add(56, 57), Op::Mul(32, 17), Op::Add(16, 59), Op::Mul(35, 18), Op::Add(60, 61), Op::Mul(38, 19), Op::Add(62, 63), Op::Mul(32, 21), Op::Add(20, 65), Op::Mul(35, 22), Op::Add(66, 67), Op::Mul(38, 23), Op::Add(68, 69), Op::Mul(32, 25), Op::Add(24, 71), Op::Mul(35, 26), Op::Add(72, 73), Op::Mul(38, 27), Op::Add(74, 75), Op::Mul(32, 29), Op::Add(28, 77), Op::Mul(35, 30), Op::Add(78, 79), Op::Mul(38, 31), Op::Add(80, 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(89, 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(89, 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(84, 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(85, 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::Load(3, 9)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Call(84, vec![11, 13, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(2, vec![18]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![18, 16, 11])], ctrl: Ctrl::Match(13, [(G::from_u64(63), Block { ops: vec![Op::Call(85, vec![17, 19, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(3, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(13, 20), Op::Add(14, 20), Op::Load(3, 17)], ctrl: Ctrl::Match(23, [(G::from_u64(1), Block { ops: vec![Op::Call(84, vec![19, 21, 22, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(4, vec![26]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![26, 24, 19])], ctrl: Ctrl::Match(21, [(G::from_u64(63), Block { ops: vec![Op::Call(85, vec![25, 27, 22, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(5, vec![28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(21, 28), Op::Add(22, 28), Op::Load(3, 25)], ctrl: Ctrl::Match(31, [(G::from_u64(1), Block { ops: vec![Op::Call(84, vec![27, 29, 30, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(6, vec![34]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![34, 32, 27])], ctrl: Ctrl::Match(29, [(G::from_u64(63), Block { ops: vec![Op::Call(85, vec![33, 35, 30, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(7, vec![36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(29, 36), Op::Add(30, 36), Op::Call(78, vec![33, 35, 37, 38, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(8, vec![39]) }))) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 9, auxiliaries: 22, lookups: 10 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_79() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(84, 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(85, 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::Load(3, 9)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Call(84, vec![11, 13, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(2, vec![18]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![18, 16, 11])], ctrl: Ctrl::Match(13, [(G::from_u64(63), Block { ops: vec![Op::Call(85, vec![17, 19, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(3, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(13, 20), Op::Add(14, 20), Op::Load(3, 17)], ctrl: Ctrl::Match(23, [(G::from_u64(1), Block { ops: vec![Op::Call(84, vec![19, 21, 22, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(4, vec![26]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![26, 24, 19])], ctrl: Ctrl::Match(21, [(G::from_u64(63), Block { ops: vec![Op::Call(85, vec![25, 27, 22, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(5, vec![28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(21, 28), Op::Add(22, 28), Op::Call(78, vec![25, 27, 29, 30, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(6, vec![31]) }))) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 7, auxiliaries: 17, lookups: 8 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_80() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(84, 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(85, 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::Load(3, 9)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Call(84, vec![11, 13, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(2, vec![18]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![18, 16, 11])], ctrl: Ctrl::Match(13, [(G::from_u64(63), Block { ops: vec![Op::Call(85, vec![17, 19, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(3, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(13, 20), Op::Add(14, 20), Op::Call(78, vec![17, 19, 21, 22, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(4, vec![23]) }))) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 5, auxiliaries: 12, lookups: 6 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_81() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(84, 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(85, 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: false } -} - -#[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::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_83() -> 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(83, 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_84() -> 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(8, 6), Op::Add(17, 7), 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(89, 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::Add(7, 18), Op::Sub(2, 1), Op::EqZero(20), Op::Mul(21, 6), Op::Add(19, 22), Op::Const(G::from_u64(64)), Op::Sub(24, 1), Op::Call(83, vec![0, 25], 1, false), Op::Call(82, 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(89, 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_85() -> 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(82, vec![1], 64, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1023), Block { ops: vec![Op::Call(322, vec![0], 1, false), Op::Mul(8, 73), Op::Load(8, 3), Op::Call(4, vec![75, 76, 77, 78, 79, 80, 81, 82], 1, false), Op::Mul(74, 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(89, 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, 75, 76, 77, 78, 79, 80, 81, 82, 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![75, 76, 77, 78, 79, 80, 81, 82], 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(322, vec![0], 1, false), Op::Mul(73, 7), Op::Call(322, vec![0], 1, false), Op::Load(8, 3), Op::Call(4, vec![76, 77, 78, 79, 80, 81, 82, 83], 1, false), Op::Mul(75, 84), Op::Mul(85, 8), Op::Const(G::from_u64(63)), Op::Sub(2, 87), Op::EqZero(88), Op::Mul(89, 6), Op::Add(74, 86), Op::Add(91, 90), 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(89, 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_86() -> 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::Mul(28, 30), Op::Const(G::from_u64(2)), Op::Sub(28, 32), Op::Mul(31, 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::Mul(62, 63), Op::Sub(62, 32), Op::Mul(64, 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_87() -> 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::Mul(132, 134), Op::Const(G::from_u64(2)), Op::Sub(132, 136), Op::Mul(135, 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::Mul(166, 167), Op::Sub(166, 136), Op::Mul(168, 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::Mul(197, 198), Op::Sub(197, 136), Op::Mul(199, 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::Mul(228, 229), Op::Sub(228, 136), Op::Mul(230, 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::Mul(259, 260), Op::Sub(259, 136), Op::Mul(261, 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::Mul(290, 291), Op::Sub(290, 136), Op::Mul(292, 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::Mul(321, 322), Op::Sub(321, 136), Op::Mul(323, 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::Mul(352, 353), Op::Sub(352, 136), Op::Mul(354, 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::Mul(383, 384), Op::Sub(383, 136), Op::Mul(385, 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::Mul(414, 415), Op::Sub(414, 136), Op::Mul(416, 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::Mul(445, 446), Op::Sub(445, 136), Op::Mul(447, 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::Mul(476, 477), Op::Sub(476, 136), Op::Mul(478, 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::Mul(507, 508), Op::Sub(507, 136), Op::Mul(509, 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::Mul(538, 539), Op::Sub(538, 136), Op::Mul(540, 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::Mul(569, 570), Op::Sub(569, 136), Op::Mul(571, 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::Mul(600, 601), Op::Sub(600, 136), Op::Mul(602, 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_88() -> 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(89, 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_89() -> 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::Mul(133, 135), Op::Const(G::from_u64(2)), Op::Sub(133, 137), Op::Mul(136, 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::Mul(167, 168), Op::Sub(167, 137), Op::Mul(169, 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::Mul(198, 199), Op::Sub(198, 137), Op::Mul(200, 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::Mul(229, 230), Op::Sub(229, 137), Op::Mul(231, 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::Mul(260, 261), Op::Sub(260, 137), Op::Mul(262, 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::Mul(291, 292), Op::Sub(291, 137), Op::Mul(293, 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::Mul(322, 323), Op::Sub(322, 137), Op::Mul(324, 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::Mul(353, 354), Op::Sub(353, 137), Op::Mul(355, 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::Mul(384, 385), Op::Sub(384, 137), Op::Mul(386, 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::Mul(415, 416), Op::Sub(415, 137), Op::Mul(417, 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::Mul(446, 447), Op::Sub(446, 137), Op::Mul(448, 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::Mul(477, 478), Op::Sub(477, 137), Op::Mul(479, 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::Mul(508, 509), Op::Sub(508, 137), Op::Mul(510, 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::Mul(539, 540), Op::Sub(539, 137), Op::Mul(541, 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::Mul(570, 571), Op::Sub(570, 137), Op::Mul(572, 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::Mul(601, 602), Op::Sub(601, 137), Op::Mul(603, 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(89, 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_90() -> 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_91() -> Function { - Function { body: Block { ops: vec![Op::Call(90, 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_92() -> Function { - Function { body: Block { ops: vec![Op::Call(90, vec![0], 2, false), Op::Call(90, 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_93() -> Function { - Function { body: Block { ops: vec![Op::Call(90, vec![0], 2, false), Op::Call(90, 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_94() -> Function { - Function { body: Block { ops: vec![Op::Call(90, vec![0], 2, false), Op::Call(90, vec![2], 2, false), Op::Call(90, vec![4], 2, false), Op::Call(90, vec![6], 2, false), Op::Const(G::from_u64(256)), Op::Mul(9, 3), Op::Add(1, 10), Op::Const(G::from_u64(65536)), Op::Mul(12, 5), Op::Add(11, 13), Op::Const(G::from_u64(16777216)), Op::Mul(15, 7), Op::Add(14, 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_95() -> Function { - Function { body: Block { ops: vec![Op::Call(90, vec![0], 2, false), Op::Call(90, vec![2], 2, false), Op::Call(90, vec![4], 2, false), Op::Call(90, vec![6], 2, false), Op::Call(90, vec![8], 2, false), Op::Call(90, vec![10], 2, false), Op::Call(90, vec![12], 2, false), Op::Call(90, 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_96() -> Function { - Function { body: Block { ops: vec![Op::Call(95, vec![0], 9, false), Op::Const(G::from_u64(256)), Op::Mul(10, 2), Op::Add(1, 11), Op::Const(G::from_u64(65536)), Op::Mul(13, 3), Op::Add(12, 14), Op::Const(G::from_u64(16777216)), Op::Mul(16, 4), Op::Add(15, 17), Op::Const(G::from_u64(4294967296)), Op::Mul(19, 5), Op::Add(18, 20), Op::Const(G::from_u64(1099511627776)), Op::Mul(22, 6), Op::Add(21, 23), Op::Const(G::from_u64(281474976710656)), Op::Mul(25, 7), Op::Add(24, 26), Op::Const(G::from_u64(72057594037927936)), Op::Mul(28, 8), Op::Add(27, 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_97() -> Function { - Function { body: Block { ops: vec![Op::Call(95, vec![0], 9, false), Op::Call(95, vec![9], 9, false), Op::Call(95, vec![18], 9, false), Op::Call(95, 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_98() -> 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(95, vec![0], 9, false), Op::Call(95, vec![10], 9, false), Op::Call(95, vec![19], 9, false), Op::Call(95, vec![28], 9, false), Op::Const(G::from_u64(1)), Op::Sub(1, 38), Op::Call(98, 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_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![3, 3, 3, 3, 3, 3])], ctrl: Ctrl::Return(0, vec![4, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(91, vec![0], 2, false)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(92, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(99, 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(96, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(99, 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(91, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(99, 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(99, 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(99, 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(99, 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(92, vec![4], 2, false), Op::Call(92, 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(99, 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(92, vec![4], 2, false), Op::Call(92, 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(99, 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(92, vec![4], 2, false), Op::Call(92, 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(99, 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(92, 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(99, 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(92, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(99, 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(92, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(99, 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(92, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(99, 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(92, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(99, 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(92, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(99, 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(92, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Add(2, 7), Op::Call(99, 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_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])], ctrl: Ctrl::Return(0, vec![3, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(92, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(100, 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_101() -> Function { - Function { body: Block { ops: vec![Op::Call(92, vec![0], 2, false), Op::Call(92, vec![2], 2, false), Op::Call(100, 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_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(92, vec![0], 2, false), Op::Call(92, vec![3], 2, false), Op::Call(100, vec![5, 4], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 8), Op::Call(102, 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_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![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(103, 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(103, 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_104() -> Function { - Function { body: Block { ops: vec![Op::Call(93, vec![0], 10, false), Op::Call(93, vec![10], 10, false), Op::Call(94, vec![20], 10, false), Op::Call(93, vec![30], 10, false), Op::Call(91, vec![40], 2, false), Op::Call(92, vec![42], 2, false), Op::Const(G::from_u64(0)), Op::Call(99, vec![44, 43, 45], 2, false), Op::Call(92, vec![47], 2, false), Op::Call(100, vec![49, 48], 2, false), Op::Call(92, vec![51], 2, false), Op::Call(102, vec![53, 52], 2, false), Op::Call(103, 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::Add(61, 70), Op::Const(G::from_u64(65536)), Op::Mul(72, 63), Op::Add(71, 73), Op::Const(G::from_u64(16777216)), Op::Mul(75, 64), Op::Add(74, 76), Op::Const(G::from_u64(4294967296)), Op::Mul(78, 65), Op::Add(77, 79), Op::Const(G::from_u64(1099511627776)), Op::Mul(81, 66), Op::Add(80, 82), Op::Const(G::from_u64(281474976710656)), Op::Mul(84, 67), Op::Add(83, 85), Op::Const(G::from_u64(72057594037927936)), Op::Mul(87, 68), Op::Add(86, 88), Op::AssertEq(vec![89], vec![60], None), Op::Add(65, 66), Op::Add(90, 67), Op::Add(91, 68), Op::Const(G::from_u64(1020)), Op::Sub(92, 93), Op::EqZero(94), Op::Add(61, 62), Op::Add(96, 63), Op::Add(97, 64), 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::Add(104, 112), Op::Mul(72, 106), Op::Add(113, 114), Op::Mul(75, 107), Op::Add(115, 116), Op::Mul(78, 108), Op::Add(117, 118), Op::Mul(81, 109), Op::Add(119, 120), Op::Mul(84, 110), Op::Add(121, 122), Op::Mul(87, 111), Op::Add(123, 124), Op::AssertEq(vec![125], vec![59], None), Op::Add(108, 109), Op::Add(126, 110), Op::Add(127, 111), Op::Sub(128, 93), Op::EqZero(129), Op::Add(104, 105), Op::Add(131, 106), Op::Add(132, 107), 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::Add(138, 146), Op::Mul(72, 140), Op::Add(147, 148), Op::Mul(75, 141), Op::Add(149, 150), Op::Mul(78, 142), Op::Add(151, 152), Op::Mul(81, 143), Op::Add(153, 154), Op::Mul(84, 144), Op::Add(155, 156), Op::Mul(87, 145), Op::Add(157, 158), Op::AssertEq(vec![159], vec![41], None), Op::Add(142, 143), Op::Add(160, 144), Op::Add(161, 145), Op::Sub(162, 93), Op::EqZero(163), Op::Add(138, 139), Op::Add(165, 140), Op::Add(166, 141), 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_105() -> 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_106() -> 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(93, vec![0], 10, false), Op::Call(93, vec![11], 10, false), Op::Call(94, vec![21], 10, false), Op::Call(93, vec![31], 10, false), Op::Call(91, vec![41], 2, false), Op::Call(92, vec![43], 2, false), Op::Const(G::from_u64(0)), Op::Call(99, vec![45, 44, 46], 2, false), Op::Call(92, vec![48], 2, false), Op::Call(100, vec![50, 49], 2, false), Op::Call(92, vec![52], 2, false), Op::Call(102, vec![54, 53], 2, false), Op::Call(103, 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::Add(62, 71), Op::Const(G::from_u64(65536)), Op::Mul(73, 64), Op::Add(72, 74), Op::Const(G::from_u64(16777216)), Op::Mul(76, 65), Op::Add(75, 77), Op::Const(G::from_u64(4294967296)), Op::Mul(79, 66), Op::Add(78, 80), Op::Const(G::from_u64(1099511627776)), Op::Mul(82, 67), Op::Add(81, 83), Op::Const(G::from_u64(281474976710656)), Op::Mul(85, 68), Op::Add(84, 86), Op::Const(G::from_u64(72057594037927936)), Op::Mul(88, 69), Op::Add(87, 89), Op::AssertEq(vec![90], vec![61], None), Op::Add(66, 67), Op::Add(91, 68), Op::Add(92, 69), Op::Const(G::from_u64(1020)), Op::Sub(93, 94), Op::EqZero(95), Op::Add(62, 63), Op::Add(97, 64), Op::Add(98, 65), 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::Add(105, 113), Op::Mul(73, 107), Op::Add(114, 115), Op::Mul(76, 108), Op::Add(116, 117), Op::Mul(79, 109), Op::Add(118, 119), Op::Mul(82, 110), Op::Add(120, 121), Op::Mul(85, 111), Op::Add(122, 123), Op::Mul(88, 112), Op::Add(124, 125), Op::AssertEq(vec![126], vec![60], None), Op::Add(109, 110), Op::Add(127, 111), Op::Add(128, 112), Op::Sub(129, 94), Op::EqZero(130), Op::Add(105, 106), Op::Add(132, 107), Op::Add(133, 108), 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::Add(139, 147), Op::Mul(73, 141), Op::Add(148, 149), Op::Mul(76, 142), Op::Add(150, 151), Op::Mul(79, 143), Op::Add(152, 153), Op::Mul(82, 144), Op::Add(154, 155), Op::Mul(85, 145), Op::Add(156, 157), Op::Mul(88, 146), Op::Add(158, 159), Op::AssertEq(vec![160], vec![42], None), Op::Add(143, 144), Op::Add(161, 145), Op::Add(162, 146), Op::Sub(163, 94), Op::EqZero(164), Op::Add(139, 140), Op::Add(166, 141), Op::Add(167, 142), 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(106, 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_107() -> Function { - Function { body: Block { ops: vec![Op::Call(90, 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(92, vec![2], 2, false), Op::Call(98, 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_108() -> 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(92, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(108, 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_109() -> Function { - Function { body: Block { ops: vec![Op::Call(93, vec![0], 10, false), Op::Call(93, vec![10], 10, false), Op::Call(93, vec![20], 10, false), Op::Call(93, vec![30], 10, false), Op::Call(93, vec![40], 10, false), Op::Call(93, vec![50], 10, false), Op::Call(93, 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_110() -> Function { - Function { body: Block { ops: vec![Op::Call(93, vec![0], 10, false), Op::Call(93, vec![10], 10, false), Op::Call(93, vec![20], 10, false), Op::Call(93, vec![30], 10, false), Op::Call(93, vec![40], 10, false), Op::Call(93, vec![50], 10, false), Op::Call(93, 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(93, vec![70], 10, false), Op::Call(106, vec![90, 81], 3, false), Op::Call(107, vec![93], 3, false), Op::Call(108, vec![96, 81], 2, false), Op::Store(vec![71, 82, 83, 84, 85, 86, 87, 88, 89, 92]), Op::Call(324, 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_111() -> 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_112() -> Function { - Function { body: Block { ops: vec![Op::Call(111, vec![28, 29, 30, 31, 32], 1, false), Op::Call(111, vec![24, 25, 26, 27, 33], 1, false), Op::Call(111, vec![20, 21, 22, 23, 34], 1, false), Op::Call(111, vec![16, 17, 18, 19, 35], 1, false), Op::Call(111, vec![12, 13, 14, 15, 36], 1, false), Op::Call(111, vec![8, 9, 10, 11, 37], 1, false), Op::Call(111, vec![4, 5, 6, 7, 38], 1, false), Op::Call(111, 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_113() -> 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_114() -> 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(89, 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_115() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Call(114, vec![1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(114, 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_116() -> 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(116, 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_117() -> 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(117, 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(117, 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(117, 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_118() -> 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(118, 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(118, 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(118, 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_119() -> 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::Add(3, 13), Op::Const(G::from_u64(65536)), Op::Mul(15, 5), Op::Add(14, 16), Op::Const(G::from_u64(16777216)), Op::Mul(18, 6), Op::Add(17, 19), Op::Const(G::from_u64(4294967296)), Op::Mul(21, 7), Op::Add(20, 22), Op::Const(G::from_u64(1099511627776)), Op::Mul(24, 8), Op::Add(23, 25), Op::Const(G::from_u64(281474976710656)), Op::Mul(27, 9), Op::Add(26, 28), Op::Const(G::from_u64(72057594037927936)), Op::Mul(30, 10), Op::Add(29, 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::Add(33, 41), Op::Mul(15, 35), Op::Add(42, 43), Op::Mul(18, 36), Op::Add(44, 45), Op::Mul(21, 37), Op::Add(46, 47), Op::Mul(24, 38), Op::Add(48, 49), Op::Mul(27, 39), Op::Add(50, 51), Op::Mul(30, 40), Op::Add(52, 53), Op::AssertEq(vec![54], vec![32], None), Op::Add(37, 38), Op::Add(55, 39), Op::Add(56, 40), Op::Const(G::from_u64(1020)), Op::Sub(57, 58), Op::EqZero(59), Op::Add(33, 34), Op::Add(61, 35), Op::Add(62, 36), 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(119, 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_120() -> Function { - Function { body: Block { ops: vec![Op::Call(119, 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(89, 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(119, vec![14, 15], 11, false), Op::Call(119, vec![25, 26], 11, false), Op::Call(119, vec![36, 37], 11, false), Op::Call(119, vec![47, 48], 11, false), Op::Call(119, vec![58, 59], 11, false), Op::Call(119, vec![69, 70], 11, false), Op::Call(119, vec![80, 81], 11, false), Op::Const(G::from_u64(8)), Op::Add(16, 27), Op::Add(95, 38), Op::Add(96, 49), Op::Add(97, 60), Op::Add(98, 71), Op::Add(99, 82), Op::Add(100, 93), 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::Add(113, 116), Op::Mul(113, 116), Op::Sub(118, 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::Add(117, 132), Op::Const(G::from_u64(8)), Op::Mul(134, 130), Op::Add(133, 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(89, 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(120, 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(120, 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_121() -> 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(120, 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_122() -> Function { - Function { body: Block { ops: vec![Op::Call(117, 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(120, 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_123() -> Function { - Function { body: Block { ops: vec![Op::Call(116, 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(122, vec![0, 1, 2], 1, false), Op::Call(114, 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_124() -> 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(124, 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_125() -> 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(125, 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(125, 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(125, 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_126() -> 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(126, 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_127() -> 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(126, vec![0], 2, false), Op::Call(127, vec![13], 1, false), Op::Call(127, vec![14], 1, false), Op::Call(125, 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_128() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(314, 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(122, vec![8, 2, 3], 1, false), Op::Const(G::from_u64(0)), Op::Call(124, vec![5], 1, false), Op::Call(128, 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_129() -> 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(124, 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(124, vec![22], 1, false), Op::Sub(13, 23), Op::EqZero(24)], ctrl: Ctrl::Match(25, [(G::from_u64(1), Block { ops: vec![Op::Call(118, vec![7, 2, 3], 1, false), Op::Call(118, vec![17, 2, 3], 1, false), Op::AssertEq(vec![26], vec![27], None), Op::Call(114, vec![8, 18], 1, false), Op::Call(123, vec![7, 2, 3, 28], 1, false), Op::Call(129, 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(115, vec![11, 8, 27], 1, false), Op::Call(123, vec![7, 2, 3, 29], 1, false), Op::Call(129, 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(115, vec![11, 8, 21], 1, false), Op::Call(123, 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_130() -> 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(129, vec![0, 1, 2, 5], 2, false), Op::Call(130, 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_131() -> Function { - Function { body: Block { ops: vec![Op::Call(314, vec![1], 1, false), Op::Call(314, 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(128, vec![3, 1, 2, 5], 1, false), Op::Call(127, vec![11], 1, false), Op::Call(130, vec![12, 4, 2, 5], 2, false), Op::Call(314, 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(317, 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(312, 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_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::Const(G::from_u64(0)), Op::Store(vec![5, 3, 1]), Op::Call(132, 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_133() -> 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(133, 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_134() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(1, 8), Op::Call(189, vec![9], 1, false), Op::Store(vec![8, 8, 8]), Op::Call(132, vec![0, 11], 1, false), Op::Call(133, 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_135() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(7)), Op::Call(189, vec![1], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Call(132, vec![0, 5], 1, false), Op::Call(133, 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_136() -> Function { - Function { body: Block { ops: vec![Op::Load(10, 0)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(18, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4, 5, 6, 7]) })].into_iter().collect(), None) }), (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::Add(9, 23), Op::Const(G::from_u64(65536)), Op::Mul(25, 11), Op::Add(24, 26), Op::Const(G::from_u64(16777216)), Op::Mul(28, 12), Op::Add(27, 29), Op::Const(G::from_u64(4294967296)), Op::Mul(31, 13), Op::Add(30, 32), Op::Const(G::from_u64(1099511627776)), Op::Mul(34, 14), Op::Add(33, 35), Op::Const(G::from_u64(281474976710656)), Op::Mul(37, 15), Op::Add(36, 38), Op::Const(G::from_u64(72057594037927936)), Op::Mul(40, 16), Op::Add(39, 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(136, 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_137() -> 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::Add(6, 15), Op::Const(G::from_u64(65536)), Op::Mul(17, 8), Op::Add(16, 18), Op::Const(G::from_u64(16777216)), Op::Mul(20, 9), Op::Add(19, 21), Op::Const(G::from_u64(4294967296)), Op::Mul(23, 10), Op::Add(22, 24), Op::Const(G::from_u64(1099511627776)), Op::Mul(26, 11), Op::Add(25, 27), Op::Const(G::from_u64(281474976710656)), Op::Mul(29, 12), Op::Add(28, 30), Op::Const(G::from_u64(72057594037927936)), Op::Mul(32, 13), Op::Add(31, 33), Op::AssertEq(vec![34], vec![3], None), Op::Add(10, 11), Op::Add(35, 12), Op::Add(36, 13), Op::Const(G::from_u64(1020)), Op::Sub(37, 38), Op::EqZero(39), Op::Add(6, 7), Op::Add(41, 8), Op::Add(42, 9), 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::Add(49, 57), Op::Mul(17, 51), Op::Add(58, 59), Op::Mul(20, 52), Op::Add(60, 61), Op::Mul(23, 53), Op::Add(62, 63), Op::Mul(26, 54), Op::Add(64, 65), Op::Mul(29, 55), Op::Add(66, 67), Op::Mul(32, 56), Op::Add(68, 69), Op::AssertEq(vec![70], vec![4], None), Op::Add(53, 54), Op::Add(71, 55), Op::Add(72, 56), Op::Sub(73, 38), Op::EqZero(74), Op::Add(49, 50), Op::Add(76, 51), Op::Add(77, 52), Op::EqZero(78), Op::Sub(45, 79), Op::Mul(75, 80), Op::Sub(45, 81), Op::AssertEq(vec![82], vec![45], None), Op::Call(137, vec![5, 1], 1, false), Op::Call(174, vec![49, 50, 51, 52, 53, 54, 55, 56, 83], 1, false), Op::Call(174, 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_138() -> 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(138, vec![4, 1], 1, false), Op::Call(137, 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_139() -> 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(139, vec![4, 1], 1, false), Op::Call(138, 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_140() -> 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(139, 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_141() -> 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(183, vec![0, 5, 6, 6, 6, 6, 6, 6, 6], 1, false), Op::Call(141, 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_142() -> 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(183, 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(182, vec![10, 12, 9], 3, false), Op::Call(124, 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_143() -> 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(184, vec![0, 5], 1, false), Op::Call(142, vec![17, 8, 9, 10, 11, 12, 13, 14, 15, 3], 2, false), Op::Call(180, vec![18, 19], 18, false), Op::Call(143, vec![36, 6, 16, 3], 2, false), Op::Const(G::from_u64(256)), Op::Mul(40, 21), Op::Add(20, 41), Op::Const(G::from_u64(65536)), Op::Mul(43, 22), Op::Add(42, 44), Op::Const(G::from_u64(16777216)), Op::Mul(46, 23), Op::Add(45, 47), Op::Const(G::from_u64(4294967296)), Op::Mul(49, 24), Op::Add(48, 50), Op::Const(G::from_u64(1099511627776)), Op::Mul(52, 25), Op::Add(51, 53), Op::Const(G::from_u64(281474976710656)), Op::Mul(55, 26), Op::Add(54, 56), Op::Const(G::from_u64(72057594037927936)), Op::Mul(58, 27), Op::Add(57, 59), Op::Const(G::from_u64(0)), Op::Mul(40, 29), Op::Add(28, 62), Op::Mul(43, 30), Op::Add(63, 64), Op::Mul(46, 31), Op::Add(65, 66), Op::Mul(49, 32), Op::Add(67, 68), Op::Mul(52, 33), Op::Add(69, 70), Op::Mul(55, 34), Op::Add(71, 72), Op::Mul(58, 35), Op::Add(73, 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_144() -> 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(312, vec![0, 3], 1, false), Op::Add(5, 1), Op::Sub(6, 4), 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(144, 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_145() -> 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(144, 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(145, 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(145, 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_146() -> Function { - Function { body: Block { ops: vec![Op::Load(7, 0)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(319, vec![2], 1, false), Op::Call(315, vec![3], 1, false), Op::Sub(15, 16), Op::EqZero(17), Op::Const(G::from_u64(1)), Op::AssertEq(vec![18], vec![19], None), Op::Store(vec![19, 19, 19, 19, 19, 19, 19])], ctrl: Ctrl::Return(0, vec![20]) }), (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(136, 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(146, 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: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_147() -> 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(147, 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_148() -> 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_149() -> Function { - Function { body: Block { ops: vec![Op::Sub(3, 1), Op::Call(326, vec![2, 10], 1, false), Op::Const(G::from_u64(7)), Op::Call(189, vec![1], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![14, 14, 14]), Op::Call(132, vec![11, 15], 1, false), Op::Call(133, vec![13, 16], 1, false), Op::Mul(12, 17), Op::Const(G::from_u64(0)), Op::Sub(4, 18), Op::Sub(5, 19), Op::Mul(20, 20), Op::Mul(21, 21), Op::Mul(12, 23), Op::Sub(22, 24), Op::UnconstrainedGInverse(25), Op::Mul(25, 26), Op::Sub(27, 14), Op::Mul(25, 28), Op::AssertEq(vec![29], vec![19], None), Op::Mul(26, 28), Op::AssertEq(vec![30], vec![19], None), Op::Mul(20, 26), Op::Sub(19, 21), Op::Mul(32, 26), Op::Call(146, vec![0, 1, 6, 7, 31, 33, 8, 9], 1, false)], ctrl: Ctrl::Return(0, vec![34]) }, layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 15, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_150() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(312, vec![8, 11], 1, false), Op::Const(G::from_u64(1)), Op::Call(312, vec![8, 13], 1, false), Op::Call(189, 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(149, vec![0, 3, 1, 2, 5, 6, 7, 12, 9, 10], 1, false), Op::Call(149, 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_151() -> 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(312, vec![6, 4], 1, false), Op::Add(13, 3), Op::Call(312, vec![9, 4], 1, false), Op::Call(312, vec![10, 4], 1, false), Op::Call(150, 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(151, 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_152() -> 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(312, vec![6, 4], 1, false), Op::Add(13, 3), Op::Call(312, vec![9, 4], 1, false), Op::Call(312, vec![10, 4], 1, false), Op::Const(G::from_u64(0)), Op::Call(312, vec![16, 17], 1, false), Op::Call(149, 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(152, 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_153() -> 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(323, 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(153, 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(312, vec![7, 4], 1, false), Op::Add(17, 3), Op::Call(312, vec![11, 6], 1, false), Op::Call(312, vec![12, 6], 1, false), Op::Call(150, 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(153, 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_154() -> 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(312, vec![1, 15], 1, false)], ctrl: Ctrl::Match(16, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(314, vec![16], 1, false), Op::Call(314, 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(157, vec![6, 10, 5, 7, 22], 1, false), Op::Call(156, vec![23], 1, false), Op::Call(153, 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_155() -> 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(312, 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(155, 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_156() -> 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(156, 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_157() -> 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(323, 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(157, 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(312, 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(157, 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_158() -> 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_159() -> 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::Add(4, 13), Op::Const(G::from_u64(65536)), Op::Mul(15, 6), Op::Add(14, 16), Op::Const(G::from_u64(16777216)), Op::Mul(18, 7), Op::Add(17, 19), Op::Const(G::from_u64(4294967296)), Op::Mul(21, 8), Op::Add(20, 22), Op::Const(G::from_u64(1099511627776)), Op::Mul(24, 9), Op::Add(23, 25), Op::Const(G::from_u64(281474976710656)), Op::Mul(27, 10), Op::Add(26, 28), Op::Const(G::from_u64(72057594037927936)), Op::Mul(30, 11), Op::Add(29, 31), Op::AssertEq(vec![32], vec![0], None), Op::Add(8, 9), Op::Add(33, 10), Op::Add(34, 11), Op::Const(G::from_u64(1020)), Op::Sub(35, 36), Op::EqZero(37), Op::Add(4, 5), Op::Add(39, 6), Op::Add(40, 7), 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::Add(47, 55), Op::Mul(15, 49), Op::Add(56, 57), Op::Mul(18, 50), Op::Add(58, 59), Op::Mul(21, 51), Op::Add(60, 61), Op::Mul(24, 52), Op::Add(62, 63), Op::Mul(27, 53), Op::Add(64, 65), Op::Mul(30, 54), Op::Add(66, 67), Op::AssertEq(vec![68], vec![1], None), Op::Add(51, 52), Op::Add(69, 53), Op::Add(70, 54), Op::Sub(71, 36), Op::EqZero(72), Op::Add(47, 48), Op::Add(74, 49), Op::Add(75, 50), 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::Add(81, 89), Op::Mul(15, 83), Op::Add(90, 91), Op::Mul(18, 84), Op::Add(92, 93), Op::Mul(21, 85), Op::Add(94, 95), Op::Mul(24, 86), Op::Add(96, 97), Op::Mul(27, 87), Op::Add(98, 99), Op::Mul(30, 88), Op::Add(100, 101), Op::AssertEq(vec![102], vec![2], None), Op::Add(85, 86), Op::Add(103, 87), Op::Add(104, 88), Op::Sub(105, 36), Op::EqZero(106), Op::Add(81, 82), Op::Add(108, 83), Op::Add(109, 84), 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::Add(115, 123), Op::Mul(15, 117), Op::Add(124, 125), Op::Mul(18, 118), Op::Add(126, 127), Op::Mul(21, 119), Op::Add(128, 129), Op::Mul(24, 120), Op::Add(130, 131), Op::Mul(27, 121), Op::Add(132, 133), Op::Mul(30, 122), Op::Add(134, 135), Op::AssertEq(vec![136], vec![3], None), Op::Add(119, 120), Op::Add(137, 121), Op::Add(138, 122), Op::Sub(139, 36), Op::EqZero(140), Op::Add(115, 116), Op::Add(142, 117), Op::Add(143, 118), 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_160() -> 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(188, 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_161() -> 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(318, 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(315, 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(323, 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(134, vec![24, 26, 14, 15, 30, 31, 32, 33], 2, false), Op::Call(160, vec![34, 35, 26, 14, 15, 7], 3, false), Op::Call(161, 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::Add(42, 51), Op::Const(G::from_u64(65536)), Op::Mul(53, 44), Op::Add(52, 54), Op::Const(G::from_u64(16777216)), Op::Mul(56, 45), Op::Add(55, 57), Op::Const(G::from_u64(4294967296)), Op::Mul(59, 46), Op::Add(58, 60), Op::Const(G::from_u64(1099511627776)), Op::Mul(62, 47), Op::Add(61, 63), Op::Const(G::from_u64(281474976710656)), Op::Mul(65, 48), Op::Add(64, 66), Op::Const(G::from_u64(72057594037927936)), Op::Mul(68, 49), Op::Add(67, 69), Op::AssertEq(vec![70], vec![30], None), Op::Add(46, 47), Op::Add(71, 48), Op::Add(72, 49), Op::Const(G::from_u64(1020)), Op::Sub(73, 74), Op::EqZero(75), Op::Add(42, 43), Op::Add(77, 44), Op::Add(78, 45), 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::Add(85, 93), Op::Mul(53, 87), Op::Add(94, 95), Op::Mul(56, 88), Op::Add(96, 97), Op::Mul(59, 89), Op::Add(98, 99), Op::Mul(62, 90), Op::Add(100, 101), Op::Mul(65, 91), Op::Add(102, 103), Op::Mul(68, 92), Op::Add(104, 105), Op::AssertEq(vec![106], vec![31], None), Op::Add(89, 90), Op::Add(107, 91), Op::Add(108, 92), Op::Sub(109, 74), Op::EqZero(110), Op::Add(85, 86), Op::Add(112, 87), Op::Add(113, 88), 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::Add(119, 127), Op::Mul(53, 121), Op::Add(128, 129), Op::Mul(56, 122), Op::Add(130, 131), Op::Mul(59, 123), Op::Add(132, 133), Op::Mul(62, 124), Op::Add(134, 135), Op::Mul(65, 125), Op::Add(136, 137), Op::Mul(68, 126), Op::Add(138, 139), Op::AssertEq(vec![140], vec![32], None), Op::Add(123, 124), Op::Add(141, 125), Op::Add(142, 126), Op::Sub(143, 74), Op::EqZero(144), Op::Add(119, 120), Op::Add(146, 121), Op::Add(147, 122), 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::Add(153, 161), Op::Mul(53, 155), Op::Add(162, 163), Op::Mul(56, 156), Op::Add(164, 165), Op::Mul(59, 157), Op::Add(166, 167), Op::Mul(62, 158), Op::Add(168, 169), Op::Mul(65, 159), Op::Add(170, 171), Op::Mul(68, 160), Op::Add(172, 173), Op::AssertEq(vec![174], vec![33], None), Op::Add(157, 158), Op::Add(175, 159), Op::Add(176, 160), Op::Sub(177, 74), Op::EqZero(178), Op::Add(153, 154), Op::Add(180, 155), Op::Add(181, 156), 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_162() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(315, 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(314, vec![1], 1, false), Op::Const(G::from_u64(3)), Op::Call(148, 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(145, vec![15, 19, 18, 20], 1, false), Op::Const(G::from_u64(0)), Op::Call(155, vec![15, 19, 18, 36], 1, false), Op::Call(312, vec![1, 36], 1, false)], ctrl: Ctrl::Match(38, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(314, 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(151, vec![35, 0, 20, 19, 43, 18, 15, 16, 17, 38, 5, 3, 4], 1, false), Op::Call(312, vec![1, 42], 1, false)], ctrl: Ctrl::Match(45, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(314, 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(151, vec![44, 0, 20, 19, 50, 18, 15, 16, 17, 45, 6, 3, 4], 1, false), Op::Const(G::from_u64(2)), Op::Call(312, vec![1, 52], 1, false)], ctrl: Ctrl::Match(53, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(314, 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(152, vec![51, 0, 20, 19, 58, 18, 15, 16, 17, 53, 7, 3, 4], 1, false), Op::Call(154, vec![59, 1, 13, 8, 9, 14, 15, 18, 0, 20, 19, 16, 17, 3, 4], 1, false), Op::Call(147, 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(161, vec![66, 67, 21, 22, 2, 0, 20, 68, 19], 3, false), Op::Const(G::from_u64(0)), Op::Call(323, 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_163() -> 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(182, vec![0, 1, 20], 3, false), Op::Call(162, 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(163, 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_164() -> 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(182, vec![0, 1, 3], 3, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(2, 8), Op::Call(164, 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_165() -> 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(312, vec![3, 1], 1, false), Op::Call(165, 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_166() -> 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(312, vec![4, 1], 1, false), Op::Call(166, 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_167() -> 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(165, vec![0, 2], 1, false), Op::Call(166, vec![1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 7), Op::Sub(3, 7), Op::Call(167, 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_168() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(155, vec![9, 11, 10, 13], 1, false), Op::Call(323, 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(323, 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(323, vec![0, 20], 2, false)], ctrl: Ctrl::Match(21, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(131, vec![2, 15, 14, 1, 16, 12], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![23], vec![24], None), Op::Call(131, vec![3, 18, 14, 1, 19, 12], 1, false), Op::AssertEq(vec![25], vec![24], None), Op::Call(131, 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(323, 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(157, vec![9, 11, 8, 10, 30], 1, false), Op::Call(156, vec![31], 1, false), Op::Sub(12, 32), Op::Call(169, vec![1, 33], 1, false), Op::Call(131, 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_169() -> 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(326, vec![3, 1], 1, false), Op::Call(169, 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_170() -> 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(312, 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(170, 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_171() -> Function { - Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(314, 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(314, vec![8], 1, false), Op::Call(314, vec![3], 1, false), Op::AssertEq(vec![15], vec![16], None), Op::Call(169, vec![3, 14], 1, false), Op::Sub(5, 14), Op::Call(170, 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(131, vec![12, 19, 22, 17, 9, 18], 1, false), Op::AssertEq(vec![23], vec![14], None), Op::Add(4, 14), Op::Call(171, 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_172() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(6, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(314, vec![6], 1, false), Op::Call(319, 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(315, vec![8], 1, false), Op::Const(G::from_u64(3)), Op::Call(148, vec![4, 5], 1, false), Op::Add(38, 39), Op::AssertEq(vec![37], vec![40], None), Op::Call(325, vec![9], 1, false), Op::Sub(41, 32), Op::EqZero(42), Op::AssertEq(vec![43], vec![36], None), Op::Call(315, 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(139, 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(139, vec![3, 46], 1, false), Op::Call(139, vec![2, 47], 1, false), Op::Call(139, vec![1, 48], 1, false), Op::Call(316, vec![0, 49], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![51, 51, 51]), Op::Call(180, vec![50, 52], 18, false), Op::Const(G::from_u64(256)), Op::Mul(71, 54), Op::Add(53, 72), Op::Const(G::from_u64(65536)), Op::Mul(74, 55), Op::Add(73, 75), Op::Const(G::from_u64(16777216)), Op::Mul(77, 56), Op::Add(76, 78), Op::Const(G::from_u64(4294967296)), Op::Mul(80, 57), Op::Add(79, 81), Op::Const(G::from_u64(1099511627776)), Op::Mul(83, 58), Op::Add(82, 84), Op::Const(G::from_u64(281474976710656)), Op::Mul(86, 59), Op::Add(85, 87), Op::Const(G::from_u64(72057594037927936)), Op::Mul(89, 60), Op::Add(88, 90), Op::Mul(71, 62), Op::Add(61, 92), Op::Mul(74, 63), Op::Add(93, 94), Op::Mul(77, 64), Op::Add(95, 96), Op::Mul(80, 65), Op::Add(97, 98), Op::Mul(83, 66), Op::Add(99, 100), Op::Mul(86, 67), Op::Add(101, 102), Op::Mul(89, 68), Op::Add(103, 104), Op::Call(143, vec![69, 6, 7, 30], 2, false), Op::Call(137, vec![10, 52], 1, false), Op::Call(316, vec![107, 108], 1, false), Op::Call(141, vec![109, 6], 1, false), Op::Call(142, 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(164, vec![111, 112, 29, 113], 1, false), Op::Call(168, 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(167, vec![8, 9, 118, 29], 1, false), Op::Call(163, 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(171, 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_173() -> 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_174() -> 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_175() -> Function { - Function { body: Block { ops: vec![Op::Call(174, vec![24, 25, 26, 27, 28, 29, 30, 31, 32], 1, false), Op::Call(174, vec![16, 17, 18, 19, 20, 21, 22, 23, 33], 1, false), Op::Call(174, vec![8, 9, 10, 11, 12, 13, 14, 15, 34], 1, false), Op::Call(174, 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_176() -> 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(176, vec![4, 1], 1, false), Op::Call(174, vec![29, 30, 31, 32, 33, 34, 35, 36, 37], 1, false), Op::Call(174, vec![21, 22, 23, 24, 25, 26, 27, 28, 38], 1, false), Op::Call(174, vec![13, 14, 15, 16, 17, 18, 19, 20, 39], 1, false), Op::Call(174, 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_177() -> 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(177, vec![4, 1], 1, false), Op::Call(174, 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_178() -> 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(111, vec![71, 72, 73, 74, 37], 1, false), Op::Call(111, vec![67, 68, 69, 70, 75], 1, false), Op::Call(111, vec![63, 64, 65, 66, 76], 1, false), Op::Call(111, vec![59, 60, 61, 62, 77], 1, false), Op::Call(111, vec![55, 56, 57, 58, 78], 1, false), Op::Call(111, vec![51, 52, 53, 54, 79], 1, false), Op::Call(111, vec![47, 48, 49, 50, 80], 1, false), Op::Call(111, vec![43, 44, 45, 46, 81], 1, false), Op::Call(132, 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_179() -> Function { - Function { body: Block { ops: vec![Op::Call(178, vec![0, 1], 10, false), Op::Add(6, 7), Op::Add(12, 8), Op::Add(13, 9), Op::Const(G::from_u64(1020)), Op::Sub(14, 15), Op::EqZero(16), Op::Add(2, 3), Op::Add(18, 4), Op::Add(19, 5), 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(179, 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_180() -> Function { - Function { body: Block { ops: vec![Op::Call(179, vec![0, 1], 10, false), Op::Call(179, 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_181() -> 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(181, 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_182() -> Function { - Function { body: Block { ops: vec![Op::Call(178, 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(174, vec![37, 38, 39, 40, 41, 42, 43, 44, 46], 1, false), Op::Call(174, vec![29, 30, 31, 32, 33, 34, 35, 36, 47], 1, false), Op::Call(174, vec![21, 22, 23, 24, 25, 26, 27, 28, 48], 1, false), Op::Call(174, vec![13, 14, 15, 16, 17, 18, 19, 20, 49], 1, false), Op::Call(181, 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_183() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Call(174, vec![1, 2, 3, 4, 5, 6, 7, 8, 10], 1, false), Op::Call(316, 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_184() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Call(176, vec![1, 3], 1, false), Op::Call(316, 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_185() -> 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_186() -> 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(186, vec![11, 1], 1, false), Op::Call(174, 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_187() -> 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_188() -> 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(188, 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_189() -> 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(189, 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_190() -> Function { - Function { body: Block { ops: vec![Op::Call(188, 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_191() -> 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(191, 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_192() -> Function { - Function { body: Block { ops: vec![Op::Call(188, 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(189, 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_193() -> 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_194() -> 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_195() -> 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(194, vec![2, 3, 6, 7], 2, false), Op::Call(195, 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_196() -> Function { - Function { body: Block { ops: vec![Op::Call(321, 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, 16), Op::Add(19, 17)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Call(323, vec![4, 18], 2, false)], ctrl: Ctrl::Return(1, vec![21, 22]) }), (G::from_u64(1), Block { ops: vec![Op::Call(323, vec![5, 18], 2, false)], ctrl: Ctrl::Return(2, vec![21, 22]) }), (G::from_u64(2), Block { ops: vec![Op::Call(323, vec![2, 18], 2, false)], ctrl: Ctrl::Return(3, vec![21, 22]) }), (G::from_u64(3), Block { ops: vec![Op::Call(323, vec![3, 18], 2, false)], ctrl: Ctrl::Return(4, vec![21, 22]) }), (G::from_u64(4), Block { ops: vec![Op::Call(323, vec![6, 18], 2, false)], ctrl: Ctrl::Return(5, vec![21, 22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(323, vec![7, 18], 2, false)], ctrl: Ctrl::Return(6, vec![21, 22]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Call(323, 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(196, vec![0, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Call(196, 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(196, vec![0, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Call(196, 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(196, vec![0, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 2, false), Op::Call(196, 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(196, 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_197() -> 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(196, vec![5, 20, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 2, false), Op::Call(193, vec![0, 1, 2, 3, 22, 23], 2, false), Op::Call(197, 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_198() -> 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_199() -> 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(199, vec![21, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], 4, false), Op::Call(198, vec![22, 23, 24, 25, 1, 2, 3, 4], 4, false), Op::Call(196, 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_200() -> 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(199, 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(196, vec![30, 45, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43], 2, false), Op::Call(198, 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(198, vec![10, 11, 12, 13, 52, 53, 54, 55], 4, false), Op::Const(G::from_u64(1)), Op::Add(5, 85), Op::Sub(86, 6)], ctrl: Ctrl::Match(87, [(G::from_u64(0), Block { ops: vec![Op::Add(7, 7), Op::Call(323, vec![35, 88], 2, false), Op::Const(G::from_u64(1)), Op::Add(88, 91), Op::Call(323, vec![35, 92], 2, false), Op::Const(G::from_u64(0)), Op::Call(323, vec![36, 95], 2, false), Op::Add(96, 18), Op::Add(97, 19), Op::Call(323, vec![36, 91], 2, false), Op::Add(100, 20), Op::Add(101, 21), Op::Sub(98, 89), Op::Sub(99, 90), Op::Sub(102, 93), Op::Sub(103, 94), Op::Call(198, vec![81, 82, 83, 84, 104, 105, 106, 107], 4, false), Op::Sub(108, 70), Op::Sub(109, 71), Op::Call(193, vec![0, 1, 2, 3, 112, 113], 2, false), Op::Sub(110, 79), Op::Sub(111, 80), Op::Call(193, vec![114, 115, 2, 3, 116, 117], 2, false)], ctrl: Ctrl::Return(1, vec![118, 119]) })].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(323, vec![35, 90], 2, false), Op::Const(G::from_u64(1)), Op::Add(90, 93), Op::Call(323, vec![35, 94], 2, false), Op::Const(G::from_u64(2)), Op::Add(90, 97), Op::Call(323, vec![35, 98], 2, false), Op::Const(G::from_u64(3)), Op::Add(90, 101), Op::Call(323, vec![35, 102], 2, false), Op::Sub(99, 91), Op::Sub(100, 92), Op::Sub(103, 95), Op::Sub(104, 96), Op::Call(198, vec![81, 82, 83, 84, 105, 106, 107, 108], 4, false), Op::Sub(109, 70), Op::Sub(110, 71), Op::Call(193, vec![0, 1, 2, 3, 113, 114], 2, false), Op::Sub(111, 79), Op::Sub(112, 80), Op::Call(193, vec![115, 116, 2, 3, 117, 118], 2, false), Op::Add(5, 93), Op::Add(7, 93), Op::Const(G::from_u64(0)), Op::Call(200, vec![119, 120, 2, 3, 47, 121, 6, 122, 9, 9, 93, 123, 123, 123, 123, 123, 123, 123, 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![124, 125]) })].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(200, 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_201() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(197, 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(323, vec![9, 64], 2, false), Op::Call(323, vec![8, 64], 2, false), Op::Sub(65, 67), Op::Sub(66, 68), Op::Add(69, 44), Op::Add(70, 47), Op::Call(193, vec![29, 30, 25, 26, 71, 72], 2, false), Op::Const(G::from_u64(1)), Op::Call(323, vec![9, 75], 2, false), Op::Call(323, vec![8, 75], 2, false), Op::Sub(76, 78), Op::Sub(77, 79), Op::Add(80, 56), Op::Add(81, 59), Op::Call(193, 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(315, vec![2], 1, false), Op::Const(G::from_u64(1)), Op::Call(200, 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_202() -> 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_203() -> 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(203, 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_204() -> 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_205() -> 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(312, vec![1, 3], 1, false), Op::Const(G::from_u64(0)), Op::Call(312, vec![4, 5], 1, false), Op::Const(G::from_u64(1)), Op::Call(312, 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_206() -> 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(312, 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(204, vec![24], 1, false), Op::Call(323, vec![3, 9], 2, false), Op::Call(312, vec![4, 9], 1, false), Op::Const(G::from_u64(0)), Op::Call(312, vec![38, 39], 1, false), Op::Call(312, vec![38, 34], 1, false), Op::Call(312, vec![5, 9], 1, false), Op::Call(312, vec![42, 39], 1, false), Op::Call(312, vec![42, 34], 1, false), Op::Call(323, 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(312, vec![7, 46], 1, false), Op::Const(G::from_u64(0)), Op::Call(312, vec![47, 48], 1, false), Op::Const(G::from_u64(1)), Op::Call(312, 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(315, 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(315, vec![41], 1, false), Op::Sub(53, 27), Op::EqZero(54), Op::AssertEq(vec![55], vec![52], None), Op::Call(315, vec![43], 1, false), Op::Sub(56, 29), Op::EqZero(57), Op::AssertEq(vec![58], vec![52], None), Op::Call(315, vec![44], 1, false), Op::Sub(59, 29), Op::EqZero(60), Op::AssertEq(vec![61], vec![52], None), Op::Call(315, vec![47], 1, false), Op::Sub(62, 28), Op::EqZero(63), Op::AssertEq(vec![64], vec![52], None), Op::Call(315, vec![48], 1, false), Op::Sub(65, 28), Op::EqZero(66), Op::AssertEq(vec![67], vec![52], None), Op::Call(188, vec![18, 19, 31], 2, false), Op::Const(G::from_u64(0)), Op::Sub(68, 52), Op::Sub(69, 70), Op::Call(189, 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(191, vec![31], 1, false), Op::Call(189, 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(197, 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(323, vec![44, 181], 2, false), Op::Call(323, vec![43, 181], 2, false), Op::Sub(182, 184), Op::Sub(183, 185), Op::Add(186, 161), Op::Add(187, 164), Op::Call(193, vec![147, 148, 16, 17, 188, 189], 2, false), Op::Const(G::from_u64(1)), Op::Call(323, vec![44, 192], 2, false), Op::Call(323, vec![43, 192], 2, false), Op::Sub(193, 195), Op::Sub(194, 196), Op::Add(197, 173), Op::Add(198, 176), Op::Call(193, 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(315, vec![25], 1, false), Op::Const(G::from_u64(1)), Op::Call(200, 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(312, vec![8, 9], 1, false), Op::Const(G::from_u64(0)), Op::Call(312, vec![183, 184], 1, false), Op::Call(195, vec![185], 1, false), Op::Call(315, 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(188, vec![18, 19, 31], 2, false), Op::Call(203, 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(206, 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_207() -> 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::Add(4, 14), Op::Const(G::from_u64(65536)), Op::Mul(16, 6), Op::Add(15, 17), Op::Const(G::from_u64(16777216)), Op::Mul(19, 7), Op::Add(18, 20), Op::Const(G::from_u64(4294967296)), Op::Mul(22, 8), Op::Add(21, 23), Op::Const(G::from_u64(1099511627776)), Op::Mul(25, 9), Op::Add(24, 26), Op::Const(G::from_u64(281474976710656)), Op::Mul(28, 10), Op::Add(27, 29), Op::Const(G::from_u64(72057594037927936)), Op::Mul(31, 11), Op::Add(30, 32), Op::Const(G::from_u64(0)), Op::Call(207, 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_208() -> 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(207, 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(208, 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_209() -> 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(209, 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_210() -> 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(210, 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(210, 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_211() -> 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(211, 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(211, 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_212() -> 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::Add(2, 11), Op::Const(G::from_u64(65536)), Op::Mul(13, 4), Op::Add(12, 14), Op::Const(G::from_u64(16777216)), Op::Mul(16, 5), Op::Add(15, 17), Op::Const(G::from_u64(4294967296)), Op::Mul(19, 6), Op::Add(18, 20), Op::Const(G::from_u64(1099511627776)), Op::Mul(22, 7), Op::Add(21, 23), Op::Const(G::from_u64(281474976710656)), Op::Mul(25, 8), Op::Add(24, 26), Op::Const(G::from_u64(72057594037927936)), Op::Mul(28, 9), Op::Add(27, 29), Op::AssertEq(vec![30], vec![0], None), Op::Add(6, 7), Op::Add(31, 8), Op::Add(32, 9), Op::Const(G::from_u64(1020)), Op::Sub(33, 34), Op::EqZero(35), Op::Add(2, 3), Op::Add(37, 4), Op::Add(38, 5), 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(174, 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_213() -> Function { - Function { body: Block { ops: vec![Op::Call(314, vec![0], 1, false), Op::Call(214, vec![0, 1], 1, false), Op::Call(212, 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_214() -> 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(319, vec![3], 1, false), Op::Call(214, vec![4, 1], 1, false), Op::Call(186, vec![3, 6], 1, false), Op::Call(212, 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_215() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(314, vec![2], 1, false), Op::Call(213, vec![3, 4], 1, false), Op::Call(177, vec![2, 6], 1, false), Op::Call(212, vec![5, 7], 1, false), Op::Call(176, vec![1, 8], 1, false), Op::Call(177, 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_216() -> 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(216, vec![7, 1], 1, false), Op::Call(215, 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_217() -> Function { - Function { body: Block { ops: vec![Op::Call(320, vec![0], 1, false), Op::Call(218, vec![0, 1], 1, false), Op::Call(212, 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_218() -> 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(319, vec![3], 1, false), Op::Call(218, vec![12, 1], 1, false), Op::Call(174, vec![4, 5, 6, 7, 8, 9, 10, 11, 14], 1, false), Op::Call(186, vec![3, 15], 1, false), Op::Call(212, 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_219() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Call(217, vec![3, 5], 1, false), Op::Call(216, vec![2, 6], 1, false), Op::Call(317, vec![2], 1, false), Op::Call(212, vec![8, 7], 1, false), Op::Call(176, vec![1, 9], 1, false), Op::Call(186, 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(180, vec![39, 5], 18, false), Op::Call(174, vec![48, 49, 50, 51, 52, 53, 54, 55, 5], 1, false), Op::Call(174, vec![40, 41, 42, 43, 44, 45, 46, 47, 58], 1, false), Op::Call(316, vec![56, 59], 1, false), Op::Call(180, vec![60, 5], 18, false), Op::Call(174, vec![69, 70, 71, 72, 73, 74, 75, 76, 5], 1, false), Op::Call(174, vec![61, 62, 63, 64, 65, 66, 67, 68, 79], 1, false), Op::Call(316, vec![77, 80], 1, false), Op::Const(G::from_u64(256)), Op::Mul(82, 41), Op::Add(40, 83), Op::Const(G::from_u64(65536)), Op::Mul(85, 42), Op::Add(84, 86), Op::Const(G::from_u64(16777216)), Op::Mul(88, 43), Op::Add(87, 89), Op::Const(G::from_u64(4294967296)), Op::Mul(91, 44), Op::Add(90, 92), Op::Const(G::from_u64(1099511627776)), Op::Mul(94, 45), Op::Add(93, 95), Op::Const(G::from_u64(281474976710656)), Op::Mul(97, 46), Op::Add(96, 98), Op::Const(G::from_u64(72057594037927936)), Op::Mul(100, 47), Op::Add(99, 101), Op::Mul(82, 49), Op::Add(48, 103), Op::Mul(85, 50), Op::Add(104, 105), Op::Mul(88, 51), Op::Add(106, 107), Op::Mul(91, 52), Op::Add(108, 109), Op::Mul(94, 53), Op::Add(110, 111), Op::Mul(97, 54), Op::Add(112, 113), Op::Mul(100, 55), Op::Add(114, 115), Op::Mul(82, 62), Op::Add(61, 117), Op::Mul(85, 63), Op::Add(118, 119), Op::Mul(88, 64), Op::Add(120, 121), Op::Mul(91, 65), Op::Add(122, 123), Op::Mul(94, 66), Op::Add(124, 125), Op::Mul(97, 67), Op::Add(126, 127), Op::Mul(100, 68), Op::Add(128, 129), Op::Mul(82, 70), Op::Add(69, 131), Op::Mul(85, 71), Op::Add(132, 133), Op::Mul(88, 72), Op::Add(134, 135), Op::Mul(91, 73), Op::Add(136, 137), Op::Mul(94, 74), Op::Add(138, 139), Op::Mul(97, 75), Op::Add(140, 141), Op::Mul(100, 76), Op::Add(142, 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_220() -> 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::Add(5, 14), Op::Const(G::from_u64(65536)), Op::Mul(16, 7), Op::Add(15, 17), Op::Const(G::from_u64(16777216)), Op::Mul(19, 8), Op::Add(18, 20), Op::Const(G::from_u64(4294967296)), Op::Mul(22, 9), Op::Add(21, 23), Op::Const(G::from_u64(1099511627776)), Op::Mul(25, 10), Op::Add(24, 26), Op::Const(G::from_u64(281474976710656)), Op::Mul(28, 11), Op::Add(27, 29), Op::Const(G::from_u64(72057594037927936)), Op::Mul(31, 12), Op::Add(30, 32), Op::AssertEq(vec![33], vec![1], None), Op::Add(9, 10), Op::Add(34, 11), Op::Add(35, 12), Op::Const(G::from_u64(1020)), Op::Sub(36, 37), Op::EqZero(38), Op::Add(5, 6), Op::Add(40, 7), Op::Add(41, 8), 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(183, vec![0, 5, 6, 7, 8, 9, 10, 11, 12], 1, false), Op::Call(184, vec![48, 2], 1, false), Op::Store(vec![44, 44, 44]), Op::Call(137, vec![4, 50], 1, false), Op::Call(316, vec![49, 51], 1, false), Op::Call(180, vec![52, 50], 18, false), Op::Call(184, vec![69, 3], 1, false), Op::Call(180, vec![71, 50], 18, false), Op::Mul(13, 54), Op::Add(53, 90), Op::Mul(16, 55), Op::Add(91, 92), Op::Mul(19, 56), Op::Add(93, 94), Op::Mul(22, 57), Op::Add(95, 96), Op::Mul(25, 58), Op::Add(97, 98), Op::Mul(28, 59), Op::Add(99, 100), Op::Mul(31, 60), Op::Add(101, 102), Op::Mul(13, 62), Op::Add(61, 104), Op::Mul(16, 63), Op::Add(105, 106), Op::Mul(19, 64), Op::Add(107, 108), Op::Mul(22, 65), Op::Add(109, 110), Op::Mul(25, 66), Op::Add(111, 112), Op::Mul(28, 67), Op::Add(113, 114), Op::Mul(31, 68), Op::Add(115, 116), Op::Mul(13, 73), Op::Add(72, 118), Op::Mul(16, 74), Op::Add(119, 120), Op::Mul(19, 75), Op::Add(121, 122), Op::Mul(22, 76), Op::Add(123, 124), Op::Mul(25, 77), Op::Add(125, 126), Op::Mul(28, 78), Op::Add(127, 128), Op::Mul(31, 79), Op::Add(129, 130), Op::Mul(13, 81), Op::Add(80, 132), Op::Mul(16, 82), Op::Add(133, 134), Op::Mul(19, 83), Op::Add(135, 136), Op::Mul(22, 84), Op::Add(137, 138), Op::Mul(25, 85), Op::Add(139, 140), Op::Mul(28, 86), Op::Add(141, 142), Op::Mul(31, 87), Op::Add(143, 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_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::AssertEq(vec![3], vec![6], None), Op::Call(221, 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_222() -> 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(222, 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_223() -> 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(222, vec![3, 6], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![8], vec![9], None), Op::Call(223, 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_224() -> 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(224, 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_225() -> 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(225, 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_226() -> 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(207, 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::Add(9, 38), Op::Const(G::from_u64(65536)), Op::Mul(40, 11), Op::Add(39, 41), Op::Const(G::from_u64(16777216)), Op::Mul(43, 12), Op::Add(42, 44), Op::Const(G::from_u64(4294967296)), Op::Mul(46, 13), Op::Add(45, 47), Op::Const(G::from_u64(1099511627776)), Op::Mul(49, 14), Op::Add(48, 50), Op::Const(G::from_u64(281474976710656)), Op::Mul(52, 15), Op::Add(51, 53), Op::Const(G::from_u64(72057594037927936)), Op::Mul(55, 16), Op::Add(54, 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(226, 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_227() -> 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_228() -> 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(227, vec![2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![4], vec![5], None), Op::Call(228, 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_229() -> 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(229, 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_230() -> 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::Add(3, 12), Op::Const(G::from_u64(65536)), Op::Mul(14, 5), Op::Add(13, 15), Op::Const(G::from_u64(16777216)), Op::Mul(17, 6), Op::Add(16, 18), Op::Const(G::from_u64(4294967296)), Op::Mul(20, 7), Op::Add(19, 21), Op::Const(G::from_u64(1099511627776)), Op::Mul(23, 8), Op::Add(22, 24), Op::Const(G::from_u64(281474976710656)), Op::Mul(26, 9), Op::Add(25, 27), Op::Const(G::from_u64(72057594037927936)), Op::Mul(29, 10), Op::Add(28, 30), Op::AssertEq(vec![31], vec![0], None), Op::Add(7, 8), Op::Add(32, 9), Op::Add(33, 10), Op::Const(G::from_u64(1020)), Op::Sub(34, 35), Op::EqZero(36), Op::Add(3, 4), Op::Add(38, 5), Op::Add(39, 6), 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(6, 7), Op::Add(46, 8), Op::Add(47, 9), Op::Add(48, 10), Op::AssertEq(vec![49], vec![2], None), Op::Sub(5, 42), Op::Mul(5, 50), Op::AssertEq(vec![51], vec![2], None), Op::Mul(5, 38), Op::AssertEq(vec![52], 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_231() -> 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_232() -> 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_233() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(232, vec![0, 8, 16], 1, false), Op::Call(232, vec![1, 9, 17], 1, false), Op::Call(232, vec![2, 10, 18], 1, false), Op::Call(232, vec![3, 11, 19], 1, false), Op::Call(232, vec![4, 12, 20], 1, false), Op::Call(232, vec![5, 13, 21], 1, false), Op::Call(232, vec![6, 14, 22], 1, false), Op::Call(232, 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_234() -> 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::Add(5, 26), Op::Const(G::from_u64(65536)), Op::Mul(28, 7), Op::Add(27, 29), Op::Const(G::from_u64(16777216)), Op::Mul(31, 8), Op::Add(30, 32), Op::Const(G::from_u64(4294967296)), Op::Mul(34, 9), Op::Add(33, 35), Op::Const(G::from_u64(1099511627776)), Op::Mul(37, 10), Op::Add(36, 38), Op::Const(G::from_u64(281474976710656)), Op::Mul(40, 11), Op::Add(39, 41), Op::Const(G::from_u64(72057594037927936)), Op::Mul(43, 12), Op::Add(42, 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::Add(16, 49), Op::Mul(28, 18), Op::Add(50, 51), Op::Mul(31, 19), Op::Add(52, 53), Op::Mul(34, 20), Op::Add(54, 55), Op::Mul(37, 21), Op::Add(56, 57), Op::Mul(40, 22), Op::Add(58, 59), Op::Mul(43, 23), Op::Add(60, 61), Op::AssertEq(vec![62], vec![46], None), Op::Call(231, vec![4], 24, false), Op::Call(231, vec![15], 24, false), Op::Mul(25, 64), Op::Add(63, 111), Op::Mul(28, 65), Op::Add(112, 113), Op::Mul(31, 66), Op::Add(114, 115), Op::Mul(34, 67), Op::Add(116, 117), Op::Mul(37, 68), Op::Add(118, 119), Op::Mul(40, 69), Op::Add(120, 121), Op::Mul(43, 70), Op::Add(122, 123), Op::Const(G::from_u64(16)), Op::AssertEq(vec![124], vec![125], None), Op::Mul(25, 88), Op::Add(87, 126), Op::Mul(28, 89), Op::Add(127, 128), Op::Mul(31, 90), Op::Add(129, 130), Op::Mul(34, 91), Op::Add(131, 132), Op::Mul(37, 92), Op::Add(133, 134), Op::Mul(40, 93), Op::Add(135, 136), Op::Mul(43, 94), Op::Add(137, 138), Op::AssertEq(vec![139], vec![125], None), Op::Mul(25, 72), Op::Add(71, 140), Op::Mul(28, 73), Op::Add(141, 142), Op::Mul(31, 74), Op::Add(143, 144), Op::Mul(34, 75), Op::Add(145, 146), Op::Mul(37, 76), Op::Add(147, 148), Op::Mul(40, 77), Op::Add(149, 150), Op::Mul(43, 78), Op::Add(151, 152), Op::Mul(25, 96), Op::Add(95, 154), Op::Mul(28, 97), Op::Add(155, 156), Op::Mul(31, 98), Op::Add(157, 158), Op::Mul(34, 99), Op::Add(159, 160), Op::Mul(37, 100), Op::Add(161, 162), Op::Mul(40, 101), Op::Add(163, 164), Op::Mul(43, 102), Op::Add(165, 166), Op::AssertEq(vec![167], vec![153], None), Op::Mul(25, 80), Op::Add(79, 168), Op::Mul(28, 81), Op::Add(169, 170), Op::Mul(31, 82), Op::Add(171, 172), Op::Mul(34, 83), Op::Add(173, 174), Op::Mul(37, 84), Op::Add(175, 176), Op::Mul(40, 85), Op::Add(177, 178), Op::Mul(43, 86), Op::Add(179, 180), Op::Mul(25, 104), Op::Add(103, 182), Op::Mul(28, 105), Op::Add(183, 184), Op::Mul(31, 106), Op::Add(185, 186), Op::Mul(34, 107), Op::Add(187, 188), Op::Mul(37, 108), Op::Add(189, 190), Op::Mul(40, 109), Op::Add(191, 192), Op::Mul(43, 110), Op::Add(193, 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::Add(196, 204), Op::Mul(28, 198), Op::Add(205, 206), Op::Mul(31, 199), Op::Add(207, 208), Op::Mul(34, 200), Op::Add(209, 210), Op::Mul(37, 201), Op::Add(211, 212), Op::Mul(40, 202), Op::Add(213, 214), Op::Mul(43, 203), Op::Add(215, 216), Op::AssertEq(vec![217], vec![181], None), Op::Add(200, 201), Op::Add(218, 202), Op::Add(219, 203), Op::Const(G::from_u64(1020)), Op::Sub(220, 221), Op::EqZero(222), Op::Add(196, 197), Op::Add(224, 198), Op::Add(225, 199), 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::Add(231, 239), Op::Mul(28, 233), Op::Add(240, 241), Op::Mul(31, 234), Op::Add(242, 243), Op::Mul(34, 235), Op::Add(244, 245), Op::Mul(37, 236), Op::Add(246, 247), Op::Mul(40, 237), Op::Add(248, 249), Op::Mul(43, 238), Op::Add(250, 251), Op::AssertEq(vec![252], vec![195], None), Op::Add(235, 236), Op::Add(253, 237), Op::Add(254, 238), Op::Sub(255, 221), Op::EqZero(256), Op::Add(231, 232), Op::Add(258, 233), Op::Add(259, 234), Op::EqZero(260), Op::Sub(46, 261), Op::Mul(257, 262), Op::Sub(46, 263), Op::AssertEq(vec![264], vec![46], None), Op::Call(233, 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::Add(268, 276), Op::Mul(28, 270), Op::Add(277, 278), Op::Mul(31, 271), Op::Add(279, 280), Op::Mul(34, 272), Op::Add(281, 282), Op::Mul(37, 273), Op::Add(283, 284), Op::Mul(40, 274), Op::Add(285, 286), Op::Mul(43, 275), Op::Add(287, 288), Op::AssertEq(vec![289], vec![153], None), Op::Add(272, 273), Op::Add(290, 274), Op::Add(291, 275), Op::Sub(292, 221), Op::EqZero(293), Op::Add(268, 269), Op::Add(295, 270), Op::Add(296, 271), 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::Add(302, 310), Op::Mul(28, 304), Op::Add(311, 312), Op::Mul(31, 305), Op::Add(313, 314), Op::Mul(34, 306), Op::Add(315, 316), Op::Mul(37, 307), Op::Add(317, 318), Op::Mul(40, 308), Op::Add(319, 320), Op::Mul(43, 309), Op::Add(321, 322), Op::AssertEq(vec![323], vec![1], None), Op::Add(306, 307), Op::Add(324, 308), Op::Add(325, 309), Op::Sub(326, 221), Op::EqZero(327), Op::Add(302, 303), Op::Add(329, 304), Op::Add(330, 305), Op::EqZero(331), Op::Sub(46, 332), Op::Mul(328, 333), Op::Sub(46, 334), Op::AssertEq(vec![335], vec![46], None), Op::Call(233, 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::Add(338, 346), Op::Mul(28, 340), Op::Add(347, 348), Op::Mul(31, 341), Op::Add(349, 350), Op::Mul(34, 342), Op::Add(351, 352), Op::Mul(37, 343), Op::Add(353, 354), Op::Mul(40, 344), Op::Add(355, 356), Op::Mul(43, 345), Op::Add(357, 358), Op::AssertEq(vec![359], vec![2], None), Op::Add(342, 343), Op::Add(360, 344), Op::Add(361, 345), Op::Sub(362, 221), Op::EqZero(363), Op::Add(338, 339), Op::Add(365, 340), Op::Add(366, 341), 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::Add(372, 380), Op::Mul(28, 374), Op::Add(381, 382), Op::Mul(31, 375), Op::Add(383, 384), Op::Mul(34, 376), Op::Add(385, 386), Op::Mul(37, 377), Op::Add(387, 388), Op::Mul(40, 378), Op::Add(389, 390), Op::Mul(43, 379), Op::Add(391, 392), Op::AssertEq(vec![393], vec![181], None), Op::Add(376, 377), Op::Add(394, 378), Op::Add(395, 379), Op::Sub(396, 221), Op::EqZero(397), Op::Add(372, 373), Op::Add(399, 374), Op::Add(400, 375), Op::EqZero(401), Op::Sub(46, 402), Op::Mul(398, 403), Op::Sub(46, 404), Op::AssertEq(vec![405], vec![46], None), Op::Call(233, 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(234, 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_235() -> 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(315, vec![21], 1, false), Op::EqZero(48), Op::Const(G::from_u64(0)), Op::AssertEq(vec![49], vec![50], None), Op::Call(314, vec![39], 1, false), Op::AssertEq(vec![51], vec![48], None), Op::Call(314, vec![40], 1, false), Op::AssertEq(vec![52], vec![48], None), Op::Call(314, vec![36], 1, false), Op::AssertEq(vec![53], vec![48], None), Op::Call(209, vec![17], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![54], vec![55], None), Op::Call(314, vec![17], 1, false), Op::Call(320, vec![8], 1, false), Op::Sub(56, 57), Op::EqZero(58), Op::AssertEq(vec![59], vec![55], None), Op::Call(210, vec![8, 17], 1, false), Op::Call(211, vec![11, 17], 1, false), Op::Call(320, vec![60], 1, false), Op::Call(315, 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(221, vec![12, 17], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![66], vec![67], None), Op::Call(224, vec![13, 18], 1, false), Op::AssertEq(vec![68], vec![67], None), Op::Call(221, vec![14, 22], 1, false), Op::AssertEq(vec![69], vec![67], None), Op::Call(228, vec![22], 1, false), Op::AssertEq(vec![70], vec![67], None), Op::Call(229, vec![17], 1, false), Op::Call(314, 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(220, vec![41, 16, 19, 20, 21], 5, false), Op::Const(G::from_u64(0)), Op::Call(208, vec![79, 79, 15, 42, 43, 44, 45], 2, false), Op::Call(206, 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(320, vec![60], 1, false)], ctrl: Ctrl::Match(23, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(314, vec![23], 1, false), Op::Call(319, 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(315, vec![25], 1, false), Op::Const(G::from_u64(3)), Op::Call(148, vec![37, 38], 1, false), Op::Add(90, 91), Op::AssertEq(vec![89], vec![92], None), Op::Call(325, vec![26], 1, false), Op::Sub(93, 84), Op::EqZero(94), Op::AssertEq(vec![95], vec![88], None), Op::Call(315, 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(139, 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(139, vec![36, 98], 1, false), Op::Call(139, vec![40, 99], 1, false), Op::Call(139, vec![39, 100], 1, false), Op::Call(316, vec![78, 101], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![103, 103, 103]), Op::Call(180, vec![102, 104], 18, false), Op::Const(G::from_u64(256)), Op::Mul(123, 106), Op::Add(105, 124), Op::Const(G::from_u64(65536)), Op::Mul(126, 107), Op::Add(125, 127), Op::Const(G::from_u64(16777216)), Op::Mul(129, 108), Op::Add(128, 130), Op::Const(G::from_u64(4294967296)), Op::Mul(132, 109), Op::Add(131, 133), Op::Const(G::from_u64(1099511627776)), Op::Mul(135, 110), Op::Add(134, 136), Op::Const(G::from_u64(281474976710656)), Op::Mul(138, 111), Op::Add(137, 139), Op::Const(G::from_u64(72057594037927936)), Op::Mul(141, 112), Op::Add(140, 142), Op::Mul(123, 114), Op::Add(113, 144), Op::Mul(126, 115), Op::Add(145, 146), Op::Mul(129, 116), Op::Add(147, 148), Op::Mul(132, 117), Op::Add(149, 150), Op::Mul(135, 118), Op::Add(151, 152), Op::Mul(138, 119), Op::Add(153, 154), Op::Mul(141, 120), Op::Add(155, 156), Op::Call(143, vec![121, 23, 24, 5], 2, false), Op::Call(137, vec![27, 104], 1, false), Op::Call(316, vec![159, 160], 1, false), Op::Call(141, vec![161, 23], 1, false), Op::Call(142, 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(164, vec![163, 164, 4, 165], 1, false), Op::Call(168, 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(167, vec![25, 26, 170, 4], 1, false), Op::Call(163, 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(171, vec![26, 23, 172, 168, 170, 165], 1, false), Op::AssertEq(vec![173], vec![103], None), Op::Call(225, 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_236() -> 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(235, 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(236, 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_237() -> 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(237, vec![6], 1, false), Op::Call(316, 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_238() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(12, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(317, vec![12], 1, false), Op::Call(230, vec![15], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![16], vec![17], None), Op::Call(313, vec![14], 1, false), Op::Call(317, vec![12], 1, false), Op::AssertEq(vec![18], vec![19], None), Op::Const(G::from_u64(0)), Op::Call(234, 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(219, vec![7, 22, 12, 13], 5, false), Op::Const(G::from_u64(0)), Op::Call(226, vec![28, 28, 13, 23, 24, 25, 26], 2, false), Op::Call(236, 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(237, 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_239() -> 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(238, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 17, 21, 25], 1, false), Op::Call(223, 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_240() -> Function { - Function { body: Block { ops: vec![Op::Call(28, vec![0], 2, false), Op::Call(241, 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_241() -> 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(243, vec![3, 2], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(241, 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_242() -> Function { - Function { body: Block { ops: vec![Op::Call(28, vec![0], 2, false), Op::Call(243, 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_243() -> 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(243, 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_244() -> 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_245() -> 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_246() -> Function { - Function { body: Block { ops: vec![Op::Load(32, 0), Op::Const(G::from_u64(256)), Op::Mul(33, 2), Op::Add(1, 34), Op::Const(G::from_u64(65536)), Op::Mul(36, 3), Op::Add(35, 37), Op::Const(G::from_u64(16777216)), Op::Mul(39, 4), Op::Add(38, 40), Op::Mul(33, 6), Op::Add(5, 42), Op::Mul(36, 7), Op::Add(43, 44), Op::Mul(39, 8), Op::Add(45, 46), Op::Mul(33, 10), Op::Add(9, 48), Op::Mul(36, 11), Op::Add(49, 50), Op::Mul(39, 12), Op::Add(51, 52), Op::Mul(33, 14), Op::Add(13, 54), Op::Mul(36, 15), Op::Add(55, 56), Op::Mul(39, 16), Op::Add(57, 58), Op::Mul(33, 18), Op::Add(17, 60), Op::Mul(36, 19), Op::Add(61, 62), Op::Mul(39, 20), Op::Add(63, 64), Op::Mul(33, 22), Op::Add(21, 66), Op::Mul(36, 23), Op::Add(67, 68), Op::Mul(39, 24), Op::Add(69, 70), Op::Mul(33, 26), Op::Add(25, 72), Op::Mul(36, 27), Op::Add(73, 74), Op::Mul(39, 28), Op::Add(75, 76), Op::Mul(33, 30), Op::Add(29, 78), Op::Mul(36, 31), Op::Add(79, 80), Op::Mul(39, 32), Op::Add(81, 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_247() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Call(245, vec![1, 3], 1, false), Op::Call(245, 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_248() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![1, 1, 1]), Op::Call(245, 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_249() -> 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_250() -> 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_251() -> 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(250, 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(251, 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_252() -> Function { - Function { body: Block { ops: vec![Op::Call(90, vec![0], 2, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(244, 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(252, vec![2], 2, false), Op::Call(252, vec![4], 2, false), Op::Call(316, 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_253() -> 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(248, vec![2], 1, false), Op::Call(253, 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_254() -> 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(247, 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(247, vec![2, 5], 1, false), Op::Call(254, 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_255() -> 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(254, vec![0], 1, false), Op::Call(255, 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_256() -> Function { - Function { body: Block { ops: vec![Op::Call(253, vec![0], 1, false), Op::Call(255, 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_257() -> 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, false), Op::Call(90, 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(252, 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(322, 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(251, vec![40], 0, false), Op::Call(256, 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: 10 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_258() -> 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(257, 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_259() -> 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(259, 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_260() -> 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(259, 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(259, 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(250, 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(260, 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(260, 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(260, 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_261() -> 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(259, 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(259, 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(250, 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(261, vec![5, 1, 11], 0, false)], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::AssertEq(vec![13], vec![14], Some("aggr: child subject sets overlap".into()))], 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(261, 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_262() -> 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::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(250, vec![3, 6], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Call(262, vec![4, 1], 0, false)], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::AssertEq(vec![9], vec![10], Some("aggr: subject set overlaps assumption set".into()))], ctrl: Ctrl::Return(3, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(262, vec![0, 7], 0, false)], ctrl: Ctrl::Return(4, vec![]) }))) })].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_263() -> 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, 8]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(1, vec![8, 6, 9, 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)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![8, 3, 9, 4, 1]) }), (G::from_u64(0), Block { ops: vec![Op::Call(250, vec![3, 6], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![9, 3, 10, 4, 1]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![9, 3, 9, 4, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(5, vec![9, 6, 10, 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_264() -> 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(250, vec![3, 0], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(264, 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_265() -> Function { - Function { body: Block { ops: vec![Op::Call(263, vec![0, 1], 5, 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![9, 10, 11], vec![12, 12, 12], Some("aggr: output has an extra assumption".into()))], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Call(264, vec![5, 2], 2, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(265, vec![7, 8, 10, 3], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 3)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Call(2, vec![5, 12], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![14], vec![15], Some("aggr: outstanding assumption mismatch".into())), Op::Call(265, vec![7, 8, 10, 13], 0, false)], ctrl: Ctrl::Return(2, vec![]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 13, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_266() -> 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(90, 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(244, vec![4], 2, false)], ctrl: Ctrl::MatchContinue(3, [(G::from_u64(0), Block { ops: vec![Op::Call(247, vec![8, 0], 1, false)], ctrl: Ctrl::Yield(1, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(247, 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(266, 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_267() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(6)), Op::Load(32, 0), Op::IOGetInfo(4, vec![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]), Op::Call(3, vec![4, 37, 38], 1, false), Op::Call(90, vec![39], 2, false), Op::Const(G::from_u64(2)), Op::U8LessThan(40, 42), Op::Const(G::from_u64(1)), Op::AssertEq(vec![43], vec![44], Some("aggr structural: discharge choice must be 0 or 1".into()))], ctrl: Ctrl::Match(40, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 41), Op::Const(G::from_u64(1)), Op::AssertEq(vec![45, 46, 47], vec![48, 48, 48], Some("aggr structural: carried choice has trailing bytes".into())), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![49]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(90, vec![41], 2, false), Op::Const(G::from_u64(0)), Op::U8LessThan(47, 45), Op::Const(G::from_u64(1)), Op::AssertEq(vec![48], vec![49], Some("aggr structural: Merkle path must have at least 1 step".into())), Op::Const(G::from_u64(65)), Op::U8LessThan(45, 50), Op::AssertEq(vec![51], vec![49], Some("aggr structural: Merkle path exceeds 64 steps".into())), Op::Call(248, vec![0], 1, false), Op::Sub(45, 49), Op::Call(266, vec![52, 53, 46], 2, false), Op::Call(90, vec![55], 2, false), Op::Call(244, vec![57], 2, false), Op::Load(3, 59), Op::AssertEq(vec![60, 61, 62], vec![49, 49, 49], Some("aggr structural: trailing bytes after Merkle path".into()))], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::AssertEq(vec![56], vec![63], Some("aggr structural: left assumption must be discharged by right child".into())), Op::Call(2, vec![58, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![64], vec![65], Some("aggr structural: final step sibling is not left subject root".into())), Op::Call(2, vec![54, 3], 1, false), Op::AssertEq(vec![66], vec![65], Some("aggr structural: assumption path does not reach right subject root".into()))], ctrl: Ctrl::Return(1, vec![65]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1)), Op::AssertEq(vec![56], vec![63], Some("aggr structural: right assumption must be discharged by left child".into())), Op::Call(2, vec![58, 3], 1, false), Op::AssertEq(vec![64], vec![63], Some("aggr structural: final step sibling is not right subject root".into())), Op::Call(2, vec![54, 2], 1, false), Op::AssertEq(vec![65], vec![63], Some("aggr structural: assumption path does not reach left subject root".into()))], ctrl: Ctrl::Return(2, vec![63]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::AssertEq(vec![63], vec![64], Some("aggr structural: shared assumption cannot be discharged".into()))], ctrl: Ctrl::Return(3, vec![63]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 56, lookups: 15 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_268() -> Function { - Function { body: Block { ops: vec![Op::Call(263, vec![0, 1], 5, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Load(3, 4), Op::Const(G::from_u64(1)), Op::AssertEq(vec![10, 11, 12], vec![13, 13, 13], Some("aggr structural: output has an extra assumption".into()))], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Call(267, vec![6, 7, 2, 3], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Call(268, vec![8, 9, 2, 3, 4], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(3, 4)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Call(2, vec![6, 12], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![14], vec![15], Some("aggr structural: outstanding assumption mismatch".into())), Op::Call(268, vec![8, 9, 2, 3, 13], 0, false)], ctrl: Ctrl::Return(2, vec![]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 12, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_269() -> Function { - Function { body: Block { ops: vec![Op::Call(90, 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(244, 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_270() -> Function { - Function { body: Block { ops: vec![Op::Call(90, 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(90, vec![2], 2, false), Op::Const(G::from_u64(4)), Op::AssertEq(vec![4], vec![6], Some("aggr: unsupported object format".into())), Op::Call(90, vec![5], 2, false), Op::Const(G::from_u64(3)), Op::Sub(7, 9), Op::Sub(7, 6), Op::Mul(10, 11), Op::Const(G::from_u64(5)), Op::Sub(7, 13), Op::Mul(12, 14), Op::Const(G::from_u64(0)), Op::AssertEq(vec![15], vec![16], Some("aggr: wrong validator identity".into())), Op::Call(244, vec![8], 2, false), Op::Call(244, vec![18], 2, false), Op::Call(269, vec![20], 3, false), Op::Call(244, vec![23], 2, false), Op::Call(269, vec![25], 3, false), Op::Load(3, 28), Op::Const(G::from_u64(1)), Op::AssertEq(vec![29, 30, 31], vec![32, 32, 32], Some("aggr: trailing bytes after CheckEnv claim".into()))], ctrl: Ctrl::Return(0, vec![17, 19, 21, 22, 7, 24, 26, 27]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 24, lookups: 10 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_271() -> Function { - Function { body: Block { ops: vec![Op::Call(90, vec![0], 2, false), Op::Const(G::from_u64(232)), Op::AssertEq(vec![1], vec![3], Some("aggr: claim is not Binding".into())), Op::Call(90, vec![2], 2, false), Op::Const(G::from_u64(2)), Op::AssertEq(vec![4], vec![6], Some("aggr: claim is not Binding".into())), Op::Call(90, vec![5], 2, false), Op::Const(G::from_u64(4)), Op::AssertEq(vec![7], vec![9], Some("aggr: unsupported object format".into())), Op::Call(90, vec![8], 2, false), Op::Const(G::from_u64(3)), Op::AssertEq(vec![10], vec![12], Some("aggr: wrong validator identity".into())), Op::Call(244, vec![11], 2, false), Op::Call(244, vec![14], 2, false), Op::Load(3, 16), Op::Const(G::from_u64(1)), Op::AssertEq(vec![17, 18, 19], vec![20, 20, 20], Some("aggr: trailing bytes after Binding claim".into()))], ctrl: Ctrl::Return(0, vec![13, 15]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 16, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_272() -> Function { - Function { body: Block { ops: vec![Op::Call(90, vec![0], 2, false), Op::Const(G::from_u64(232)), Op::AssertEq(vec![1], vec![3], Some("aggr: claim is not Catalog".into())), Op::Call(90, vec![2], 2, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![4], vec![6], Some("aggr: claim is not Catalog".into())), Op::Call(90, vec![5], 2, false), Op::Const(G::from_u64(4)), Op::AssertEq(vec![7], vec![9], Some("aggr: unsupported object format".into())), Op::Call(90, vec![8], 2, false), Op::Const(G::from_u64(3)), Op::AssertEq(vec![10], vec![12], Some("aggr: wrong validator identity".into())), Op::Call(244, vec![11], 2, false), Op::Load(3, 14), Op::Const(G::from_u64(1)), Op::AssertEq(vec![15, 16, 17], vec![18, 18, 18], Some("aggr: trailing bytes after Catalog claim".into()))], ctrl: Ctrl::Return(0, vec![13]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 14, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_273() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(2, [(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) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::Call(2, 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_274() -> Function { - Function { body: Block { ops: vec![Op::Call(2, vec![0, 5], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![10], vec![11], Some("aggr: claims differ in specification digest".into())), Op::Call(2, vec![1, 6], 1, false), Op::AssertEq(vec![12], vec![11], Some("aggr: claims differ in binding hash".into())), Op::Call(273, vec![2, 3, 7, 8], 1, false), Op::AssertEq(vec![13], vec![11], Some("aggr: claims differ in axioms".into())), Op::AssertEq(vec![4], vec![9], Some("aggr: claims differ in whether they assume their binding".into()))], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_275() -> 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, 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::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::Add(50, 83), Op::Const(G::from_u64(65536)), Op::Mul(85, 52), Op::Add(84, 86), Op::Const(G::from_u64(16777216)), Op::Mul(88, 53), Op::Add(87, 89), Op::Mul(82, 55), Op::Add(54, 91), Op::Mul(85, 56), Op::Add(92, 93), Op::Mul(88, 57), Op::Add(94, 95), Op::Mul(82, 59), Op::Add(58, 97), Op::Mul(85, 60), Op::Add(98, 99), Op::Mul(88, 61), Op::Add(100, 101), Op::Mul(82, 63), Op::Add(62, 103), Op::Mul(85, 64), Op::Add(104, 105), Op::Mul(88, 65), Op::Add(106, 107), Op::Mul(82, 67), Op::Add(66, 109), Op::Mul(85, 68), Op::Add(110, 111), Op::Mul(88, 69), Op::Add(112, 113), Op::Mul(82, 71), Op::Add(70, 115), Op::Mul(85, 72), Op::Add(116, 117), Op::Mul(88, 73), Op::Add(118, 119), Op::Mul(82, 75), Op::Add(74, 121), Op::Mul(85, 76), Op::Add(122, 123), Op::Mul(88, 77), Op::Add(124, 125), Op::Mul(82, 79), Op::Add(78, 127), Op::Mul(85, 80), Op::Add(128, 129), Op::Mul(88, 81), Op::Add(130, 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: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_276() -> Function { - Function { body: Block { ops: vec![Op::Call(328, vec![0, 1], 8, false), Op::Const(G::from_u64(256)), Op::Mul(10, 3), Op::Add(2, 11), Op::Const(G::from_u64(65536)), Op::Mul(13, 4), Op::Add(12, 14), Op::Const(G::from_u64(16777216)), Op::Mul(16, 5), Op::Add(15, 17), Op::Const(G::from_u64(4294967296)), Op::Mul(19, 6), Op::Add(18, 20), Op::Const(G::from_u64(1099511627776)), Op::Mul(22, 7), Op::Add(21, 23), Op::Const(G::from_u64(281474976710656)), Op::Mul(25, 8), Op::Add(24, 26), Op::Const(G::from_u64(72057594037927936)), Op::Mul(28, 9), Op::Add(27, 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_277() -> Function { - Function { body: Block { ops: vec![Op::Call(276, vec![0, 1], 1, false), Op::Const(G::from_u64(1)), Op::Add(1, 3), Op::Call(276, vec![0, 4], 1, false), Op::Const(G::from_u64(2)), Op::Add(1, 6), Op::Call(276, vec![0, 7], 1, false), Op::Const(G::from_u64(3)), Op::Add(1, 9), Op::Call(276, vec![0, 10], 1, false), Op::Const(G::from_u64(4)), Op::Add(1, 12), Op::Call(276, vec![0, 13], 1, false), Op::Const(G::from_u64(5)), Op::Add(1, 15), Op::Call(276, vec![0, 16], 1, false), Op::Const(G::from_u64(6)), Op::Add(1, 18), Op::Call(276, vec![0, 19], 1, false), Op::Const(G::from_u64(7)), Op::Add(1, 21), Op::Call(276, 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_278() -> 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_279() -> 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_280() -> 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, 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::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::Add(58, 91), Op::Const(G::from_u64(65536)), Op::Mul(93, 60), Op::Add(92, 94), Op::Const(G::from_u64(16777216)), Op::Mul(96, 61), Op::Add(95, 97), Op::Mul(90, 63), Op::Add(62, 99), Op::Mul(93, 64), Op::Add(100, 101), Op::Mul(96, 65), Op::Add(102, 103), Op::Mul(90, 67), Op::Add(66, 105), Op::Mul(93, 68), Op::Add(106, 107), Op::Mul(96, 69), Op::Add(108, 109), Op::Mul(90, 71), Op::Add(70, 111), Op::Mul(93, 72), Op::Add(112, 113), Op::Mul(96, 73), Op::Add(114, 115), Op::Mul(90, 75), Op::Add(74, 117), Op::Mul(93, 76), Op::Add(118, 119), Op::Mul(96, 77), Op::Add(120, 121), Op::Mul(90, 79), Op::Add(78, 123), Op::Mul(93, 80), Op::Add(124, 125), Op::Mul(96, 81), Op::Add(126, 127), Op::Mul(90, 83), Op::Add(82, 129), Op::Mul(93, 84), Op::Add(130, 131), Op::Mul(96, 85), Op::Add(132, 133), Op::Mul(90, 87), Op::Add(86, 135), Op::Mul(93, 88), Op::Add(136, 137), Op::Mul(96, 89), Op::Add(138, 139)], ctrl: Ctrl::MatchContinue(0, [(G::from_u64(0), Block { ops: vec![Op::Call(278, 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(278, 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(93, vec![20], 10, false), Op::Call(93, vec![150], 10, false), Op::Call(93, vec![160], 10, false), Op::Call(93, vec![170], 10, false), Op::Call(93, vec![180], 10, false), Op::Call(93, vec![190], 10, false), Op::Call(93, 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(93, vec![210], 10, false), Op::Call(106, vec![230, 221], 3, false), Op::Call(107, vec![233], 3, false), Op::Call(108, vec![236, 221], 2, false), Op::Store(vec![211, 222, 223, 224, 225, 226, 227, 228, 229, 232]), Op::Call(324, 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: 31 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_281() -> 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, false), Op::Call(28, vec![19], 2, false), Op::Call(241, 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(238, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 30, 34, 38], 1, false), Op::Call(223, 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: 13 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_282() -> Function { - Function { body: Block { ops: vec![Op::Call(280, vec![0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], 12, false), Op::Call(281, vec![28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 1], 1, false), Op::Call(279, vec![40], 1, false), Op::Const(G::from_u64(0)), Op::Call(276, 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(319, 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(276, 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(277, 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(319, 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(276, 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(277, vec![41, 48], 8, false), Op::Call(278, 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(277, 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_283() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(282, 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(278, 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_284() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(282, 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(282, 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(275, vec![37, 38, 39, 40, 41, 42, 43, 44], 1, false), Op::Call(270, vec![54], 8, false), Op::Call(275, vec![46, 47, 48, 49, 50, 51, 52, 53], 1, false), Op::Call(270, vec![63], 8, false), Op::Const(G::from_u64(2)), Op::IOGetInfo(72, vec![72]), Op::Call(3, vec![72, 73, 74], 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::Store(vec![45, 45, 45]), Op::Store(vec![36, 36, 36, 36, 36, 36, 36, 36]), Op::Store(vec![76, 77, 78, 79, 80, 81, 76, 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]), 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![75, 107, 36, 36, 108, 109, 110], 1, false), Op::Call(77, vec![111], 32, false), Op::Const(G::from_u64(256)), Op::Mul(144, 113), Op::Add(112, 145), Op::Const(G::from_u64(65536)), Op::Mul(147, 114), Op::Add(146, 148), Op::Const(G::from_u64(16777216)), Op::Mul(150, 115), Op::Add(149, 151), Op::Mul(144, 117), Op::Add(116, 153), Op::Mul(147, 118), Op::Add(154, 155), Op::Mul(150, 119), Op::Add(156, 157), Op::Mul(144, 121), Op::Add(120, 159), Op::Mul(147, 122), Op::Add(160, 161), Op::Mul(150, 123), Op::Add(162, 163), Op::Mul(144, 125), Op::Add(124, 165), Op::Mul(147, 126), Op::Add(166, 167), Op::Mul(150, 127), Op::Add(168, 169), Op::Mul(144, 129), Op::Add(128, 171), Op::Mul(147, 130), Op::Add(172, 173), Op::Mul(150, 131), Op::Add(174, 175), Op::Mul(144, 133), Op::Add(132, 177), Op::Mul(147, 134), Op::Add(178, 179), Op::Mul(150, 135), Op::Add(180, 181), Op::Mul(144, 137), Op::Add(136, 183), Op::Mul(147, 138), Op::Add(184, 185), Op::Mul(150, 139), Op::Add(186, 187), Op::Mul(144, 141), Op::Add(140, 189), Op::Mul(147, 142), Op::Add(190, 191), Op::Mul(150, 143), Op::Add(192, 193), Op::AssertEq(vec![152, 158, 164, 170, 176, 182, 188, 194], vec![28, 29, 30, 31, 32, 33, 34, 35], Some("aggr: output claim digest mismatch".into())), Op::Call(270, vec![75], 8, false), Op::Call(274, vec![55, 56, 57, 58, 59, 64, 65, 66, 67, 68], 0, false), Op::Call(274, vec![55, 56, 57, 58, 59, 195, 196, 197, 198, 199], 0, false), Op::Call(257, vec![60], 1, false), Op::Call(257, vec![69], 1, false), Op::Call(258, vec![61, 62], 1, false), Op::Call(258, vec![70, 71], 1, false), Op::Call(257, vec![200], 1, false), Op::Call(258, vec![201, 202], 1, false), Op::Call(262, vec![203, 205], 0, false), Op::Call(262, vec![204, 206], 0, false), Op::Call(261, vec![203, 204, 207], 0, false), Op::Call(265, vec![205, 206, 207, 208], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 36, selectors: 1, auxiliaries: 89, lookups: 27 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_285() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(282, 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(282, 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(275, vec![37, 38, 39, 40, 41, 42, 43, 44], 1, false), Op::Call(270, vec![54], 8, false), Op::Call(275, vec![46, 47, 48, 49, 50, 51, 52, 53], 1, false), Op::Call(270, vec![63], 8, false), Op::Const(G::from_u64(2)), Op::IOGetInfo(72, vec![72]), Op::Call(3, vec![72, 73, 74], 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::Store(vec![45, 45, 45]), Op::Store(vec![36, 36, 36, 36, 36, 36, 36, 36]), Op::Store(vec![76, 77, 78, 79, 80, 81, 76, 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]), 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![75, 107, 36, 36, 108, 109, 110], 1, false), Op::Call(77, vec![111], 32, false), Op::Const(G::from_u64(256)), Op::Mul(144, 113), Op::Add(112, 145), Op::Const(G::from_u64(65536)), Op::Mul(147, 114), Op::Add(146, 148), Op::Const(G::from_u64(16777216)), Op::Mul(150, 115), Op::Add(149, 151), Op::Mul(144, 117), Op::Add(116, 153), Op::Mul(147, 118), Op::Add(154, 155), Op::Mul(150, 119), Op::Add(156, 157), Op::Mul(144, 121), Op::Add(120, 159), Op::Mul(147, 122), Op::Add(160, 161), Op::Mul(150, 123), Op::Add(162, 163), Op::Mul(144, 125), Op::Add(124, 165), Op::Mul(147, 126), Op::Add(166, 167), Op::Mul(150, 127), Op::Add(168, 169), Op::Mul(144, 129), Op::Add(128, 171), Op::Mul(147, 130), Op::Add(172, 173), Op::Mul(150, 131), Op::Add(174, 175), Op::Mul(144, 133), Op::Add(132, 177), Op::Mul(147, 134), Op::Add(178, 179), Op::Mul(150, 135), Op::Add(180, 181), Op::Mul(144, 137), Op::Add(136, 183), Op::Mul(147, 138), Op::Add(184, 185), Op::Mul(150, 139), Op::Add(186, 187), Op::Mul(144, 141), Op::Add(140, 189), Op::Mul(147, 142), Op::Add(190, 191), Op::Mul(150, 143), Op::Add(192, 193), Op::AssertEq(vec![152, 158, 164, 170, 176, 182, 188, 194], vec![28, 29, 30, 31, 32, 33, 34, 35], Some("aggr structural: output claim digest mismatch".into())), Op::Call(270, vec![75], 8, false), Op::Call(274, vec![55, 56, 57, 58, 59, 64, 65, 66, 67, 68], 0, false), Op::Call(274, vec![55, 56, 57, 58, 59, 195, 196, 197, 198, 199], 0, false), Op::Call(2, vec![60, 69], 1, false), Op::AssertEq(vec![203], vec![36], Some("aggr structural: child subject roots must be distinct".into())), Op::Call(247, vec![60, 69], 1, false), Op::Call(2, vec![200, 204], 1, false), Op::AssertEq(vec![205], vec![45], Some("aggr structural: output subject root is not nodeHash(left, right)".into())), Op::Call(258, vec![61, 62], 1, false), Op::Call(258, vec![70, 71], 1, false), Op::Call(258, vec![201, 202], 1, false), Op::Call(268, vec![206, 207, 60, 69, 208], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 36, selectors: 1, auxiliaries: 89, lookups: 24 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_286() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(282, 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::Const(G::from_u64(1)), Op::Call(282, vec![35, 44, 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(275, vec![36, 37, 38, 39, 40, 41, 42, 43], 1, false), Op::Call(270, vec![53], 8, false), Op::Const(G::from_u64(4)), Op::AssertEq(vec![58], vec![62], Some("aggr discharge: the claim does not assume its binding".into())), Op::Call(275, vec![45, 46, 47, 48, 49, 50, 51, 52], 1, false), Op::Call(271, vec![63], 2, false), Op::Call(2, vec![54, 64], 1, false), Op::AssertEq(vec![66], vec![44], Some("aggr discharge: the binding claim is for another specification digest".into())), Op::Call(2, vec![55, 65], 1, false), Op::AssertEq(vec![67], vec![44], Some("aggr discharge: the binding claim is for another binding".into())), Op::Const(G::from_u64(2)), Op::IOGetInfo(68, vec![68]), Op::Call(3, vec![68, 69, 70], 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::Store(vec![44, 44, 44]), Op::Store(vec![35, 35, 35, 35, 35, 35, 35, 35]), Op::Store(vec![72, 73, 74, 75, 76, 77, 72, 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::Store(vec![44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44]), Op::Call(78, vec![71, 103, 35, 35, 104, 105, 106], 1, false), Op::Call(77, vec![107], 32, false), Op::Const(G::from_u64(256)), Op::Mul(140, 109), Op::Add(108, 141), Op::Const(G::from_u64(65536)), Op::Mul(143, 110), Op::Add(142, 144), Op::Const(G::from_u64(16777216)), Op::Mul(146, 111), Op::Add(145, 147), Op::Mul(140, 113), Op::Add(112, 149), Op::Mul(143, 114), Op::Add(150, 151), Op::Mul(146, 115), Op::Add(152, 153), Op::Mul(140, 117), Op::Add(116, 155), Op::Mul(143, 118), Op::Add(156, 157), Op::Mul(146, 119), Op::Add(158, 159), Op::Mul(140, 121), Op::Add(120, 161), Op::Mul(143, 122), Op::Add(162, 163), Op::Mul(146, 123), Op::Add(164, 165), Op::Mul(140, 125), Op::Add(124, 167), Op::Mul(143, 126), Op::Add(168, 169), Op::Mul(146, 127), Op::Add(170, 171), Op::Mul(140, 129), Op::Add(128, 173), Op::Mul(143, 130), Op::Add(174, 175), Op::Mul(146, 131), Op::Add(176, 177), Op::Mul(140, 133), Op::Add(132, 179), Op::Mul(143, 134), Op::Add(180, 181), Op::Mul(146, 135), Op::Add(182, 183), Op::Mul(140, 137), Op::Add(136, 185), Op::Mul(143, 138), Op::Add(186, 187), Op::Mul(146, 139), Op::Add(188, 189), Op::AssertEq(vec![148, 154, 160, 166, 172, 178, 184, 190], vec![27, 28, 29, 30, 31, 32, 33, 34], Some("aggr discharge: output claim digest mismatch".into())), Op::Call(270, vec![71], 8, false), Op::Const(G::from_u64(3)), Op::Call(274, vec![54, 55, 56, 57, 199, 191, 192, 193, 194, 195], 0, false), Op::Call(2, vec![59, 196], 1, false), Op::AssertEq(vec![200], vec![44], Some("aggr discharge: output subject root differs from the child's".into())), Op::Call(273, vec![60, 61, 197, 198], 1, false), Op::AssertEq(vec![201], vec![44], Some("aggr discharge: output assumptions differ from the child's".into()))], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 35, selectors: 1, auxiliaries: 81, lookups: 20 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_287() -> 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(29), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(30), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![1]) }), (G::from_u64(31), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![1]) }), (G::from_u64(37), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(6, vec![1]) }), (G::from_u64(38), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(7, vec![1]) }), (G::from_u64(39), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(8, vec![1]) }), (G::from_u64(40), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(9, vec![1]) }), (G::from_u64(56), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(10, vec![1]) }), (G::from_u64(57), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(11, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(12, vec![1]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 13, auxiliaries: 13, lookups: 1 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_288() -> 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::Call(90, vec![0], 2, false), Op::AssertEq(vec![3], vec![1], Some("aggr cross-binding: the binding does not bind every role in order".into())), Op::Call(244, vec![4], 2, false), Op::Const(G::from_u64(1)), Op::Add(1, 7), Op::Sub(2, 7), Op::Call(288, vec![6, 8, 9], 1, false), Op::Call(287, vec![1], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![12, 5, 10])], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![10]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_289() -> 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(289, vec![4, 1], 1, false), Op::Call(245, 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_290() -> Function { - Function { body: Block { ops: vec![Op::Call(246, vec![0], 8, false), Op::Call(275, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false), Op::Call(90, vec![9], 2, false), Op::Const(G::from_u64(232)), Op::AssertEq(vec![10], vec![12], Some("aggr cross-binding: not a role binding section".into())), Op::Call(90, vec![11], 2, false), Op::Const(G::from_u64(3)), Op::AssertEq(vec![13], vec![15], Some("aggr cross-binding: not a role binding section".into())), Op::Call(90, vec![14], 2, false), Op::Call(90, vec![17], 2, false), Op::Const(G::from_u64(103)), Op::AssertEq(vec![18], vec![20], Some("aggr cross-binding: the binding does not bind every role".into())), Op::Const(G::from_u64(0)), Op::Call(288, vec![19, 21, 20], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![23, 23, 23]), Op::Call(289, vec![22, 24], 1, false), Op::Const(G::from_u64(4)), Op::Store(vec![21, 26, 25]), Op::Store(vec![21, 12, 27]), Op::Call(75, vec![28], 1, false)], ctrl: Ctrl::Return(0, vec![29]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 24, lookups: 13 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_291() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(3)), Op::Sub(4, 5), Op::Const(G::from_u64(5)), Op::Sub(4, 7), Op::Mul(6, 8), Op::Const(G::from_u64(0)), Op::AssertEq(vec![9], vec![10], Some("aggr cross-binding: the claim assumes its binding".into()))], ctrl: Ctrl::Match(4, [(G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(290, vec![1], 1, false)], ctrl: Ctrl::Return(1, vec![11]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_292() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(282, vec![34, 35, 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], 8, false), Op::Call(282, vec![34, 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], 8, false), Op::Call(275, vec![36, 37, 38, 39, 40, 41, 42, 43], 1, false), Op::Call(270, vec![52], 8, false), Op::Call(275, vec![44, 45, 46, 47, 48, 49, 50, 51], 1, false), Op::Call(270, vec![61], 8, false), Op::Call(291, vec![53, 54, 55, 56, 57], 1, false), Op::Call(291, vec![62, 63, 64, 65, 66], 1, false), Op::Call(2, vec![70, 71], 1, false), Op::AssertEq(vec![72], vec![34], Some("aggr cross-binding: the bindings' literal classes differ".into())), Op::Const(G::from_u64(2)), Op::IOGetInfo(73, vec![73]), Op::Call(3, vec![73, 74, 75], 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::Store(vec![34, 34, 34]), Op::Store(vec![35, 35, 35, 35, 35, 35, 35, 35]), Op::Store(vec![77, 78, 79, 80, 81, 82, 77, 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]), Op::Store(vec![34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34]), Op::Call(78, vec![76, 108, 35, 35, 109, 110, 111], 1, false), Op::Call(77, vec![112], 32, false), Op::Const(G::from_u64(256)), Op::Mul(145, 114), Op::Add(113, 146), Op::Const(G::from_u64(65536)), Op::Mul(148, 115), Op::Add(147, 149), Op::Const(G::from_u64(16777216)), Op::Mul(151, 116), Op::Add(150, 152), Op::Mul(145, 118), Op::Add(117, 154), Op::Mul(148, 119), Op::Add(155, 156), Op::Mul(151, 120), Op::Add(157, 158), Op::Mul(145, 122), Op::Add(121, 160), Op::Mul(148, 123), Op::Add(161, 162), Op::Mul(151, 124), Op::Add(163, 164), Op::Mul(145, 126), Op::Add(125, 166), Op::Mul(148, 127), Op::Add(167, 168), Op::Mul(151, 128), Op::Add(169, 170), Op::Mul(145, 130), Op::Add(129, 172), Op::Mul(148, 131), Op::Add(173, 174), Op::Mul(151, 132), Op::Add(175, 176), Op::Mul(145, 134), Op::Add(133, 178), Op::Mul(148, 135), Op::Add(179, 180), Op::Mul(151, 136), Op::Add(181, 182), Op::Mul(145, 138), Op::Add(137, 184), Op::Mul(148, 139), Op::Add(185, 186), Op::Mul(151, 140), Op::Add(187, 188), Op::Mul(145, 142), Op::Add(141, 190), Op::Mul(148, 143), Op::Add(191, 192), Op::Mul(151, 144), Op::Add(193, 194), Op::AssertEq(vec![153, 159, 165, 171, 177, 183, 189, 195], vec![26, 27, 28, 29, 30, 31, 32, 33], Some("aggr cross-binding: output claim digest mismatch".into())), Op::Call(270, vec![76], 8, false), Op::Call(274, vec![53, 70, 55, 56, 98, 196, 197, 198, 199, 200], 0, false), Op::Call(274, vec![62, 71, 64, 65, 98, 196, 197, 198, 199, 200], 0, false), Op::Call(2, vec![58, 67], 1, false), Op::AssertEq(vec![204], vec![35], Some("aggr cross-binding: child subject roots must be distinct".into())), Op::Call(247, vec![58, 67], 1, false), Op::Call(2, vec![201, 205], 1, false), Op::AssertEq(vec![206], vec![34], Some("aggr cross-binding: output subject root is not nodeHash(left, right)".into())), Op::Call(258, vec![59, 60], 1, false), Op::Call(258, vec![68, 69], 1, false), Op::Call(258, vec![202, 203], 1, false), Op::Call(268, vec![207, 208, 58, 67, 209], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 34, selectors: 1, auxiliaries: 92, lookups: 27 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_293() -> Function { - Function { body: Block { ops: vec![Op::Call(275, vec![0, 1, 2, 3, 4, 5, 6, 7], 1, false), Op::Call(90, vec![8], 2, false)], ctrl: Ctrl::Match(9, [(G::from_u64(229), Block { ops: vec![Op::Call(270, vec![8], 8, false), Op::Const(G::from_u64(3)), Op::Sub(15, 19), Op::Const(G::from_u64(5)), Op::Sub(15, 21), Op::Mul(20, 22), Op::Const(G::from_u64(0)), Op::AssertEq(vec![23], vec![24], Some("aggr catalog: a member claim assumes its binding".into())), Op::Const(G::from_u64(1)), Op::Call(273, vec![17, 18, 25, 25], 1, false), Op::AssertEq(vec![26], vec![25], Some("aggr catalog: a member claim has assumptions".into())), Op::Call(75, vec![8], 1, false), Op::Store(vec![25, 25, 25]), Op::Store(vec![24, 27, 28])], ctrl: Ctrl::Return(0, vec![29]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(272, vec![8], 1, false), Op::Call(257, vec![11], 1, false)], ctrl: Ctrl::Return(1, vec![12]) }))) }, layout: FunctionLayout { input_size: 8, selectors: 2, auxiliaries: 17, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_294() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(282, vec![34, 35, 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], 8, false), Op::Call(282, vec![34, 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], 8, false), Op::Call(293, vec![36, 37, 38, 39, 40, 41, 42, 43], 1, false), Op::Call(293, vec![44, 45, 46, 47, 48, 49, 50, 51], 1, false), Op::Const(G::from_u64(2)), Op::IOGetInfo(54, vec![54]), Op::Call(3, vec![54, 55, 56], 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::Store(vec![34, 34, 34]), Op::Store(vec![35, 35, 35, 35, 35, 35, 35, 35]), Op::Store(vec![58, 59, 60, 61, 62, 63, 58, 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]), Op::Store(vec![34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34]), Op::Call(78, vec![57, 89, 35, 35, 90, 91, 92], 1, false), Op::Call(77, vec![93], 32, false), Op::Const(G::from_u64(256)), Op::Mul(126, 95), Op::Add(94, 127), Op::Const(G::from_u64(65536)), Op::Mul(129, 96), Op::Add(128, 130), Op::Const(G::from_u64(16777216)), Op::Mul(132, 97), Op::Add(131, 133), Op::Mul(126, 99), Op::Add(98, 135), Op::Mul(129, 100), Op::Add(136, 137), Op::Mul(132, 101), Op::Add(138, 139), Op::Mul(126, 103), Op::Add(102, 141), Op::Mul(129, 104), Op::Add(142, 143), Op::Mul(132, 105), Op::Add(144, 145), Op::Mul(126, 107), Op::Add(106, 147), Op::Mul(129, 108), Op::Add(148, 149), Op::Mul(132, 109), Op::Add(150, 151), Op::Mul(126, 111), Op::Add(110, 153), Op::Mul(129, 112), Op::Add(154, 155), Op::Mul(132, 113), Op::Add(156, 157), Op::Mul(126, 115), Op::Add(114, 159), Op::Mul(129, 116), Op::Add(160, 161), Op::Mul(132, 117), Op::Add(162, 163), Op::Mul(126, 119), Op::Add(118, 165), Op::Mul(129, 120), Op::Add(166, 167), Op::Mul(132, 121), Op::Add(168, 169), Op::Mul(126, 123), Op::Add(122, 171), Op::Mul(129, 124), Op::Add(172, 173), Op::Mul(132, 125), Op::Add(174, 175), Op::AssertEq(vec![134, 140, 146, 152, 158, 164, 170, 176], vec![26, 27, 28, 29, 30, 31, 32, 33], Some("aggr catalog: output claim digest mismatch".into())), Op::Call(272, vec![57], 1, false), Op::Call(257, vec![177], 1, false), Op::Call(260, vec![52, 53, 178], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 34, selectors: 1, auxiliaries: 61, lookups: 15 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_295() -> Function { - Function { body: Block { ops: vec![Op::Call(90, 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(244, 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::Add(38, 75), Op::Const(G::from_u64(65536)), Op::Mul(77, 42), Op::Add(76, 78), Op::Const(G::from_u64(16777216)), Op::Mul(80, 44), Op::Add(79, 81), Op::Const(G::from_u64(4294967296)), Op::Mul(83, 46), Op::Add(82, 84), Op::Const(G::from_u64(1099511627776)), Op::Mul(86, 48), Op::Add(85, 87), Op::Const(G::from_u64(281474976710656)), Op::Mul(89, 50), Op::Add(88, 90), Op::Const(G::from_u64(72057594037927936)), Op::Mul(92, 52), Op::Add(91, 93), Op::Mul(74, 56), Op::Add(54, 95), Op::Mul(77, 58), Op::Add(96, 97), Op::Mul(80, 60), Op::Add(98, 99), Op::Mul(83, 62), Op::Add(100, 101), Op::Mul(86, 64), Op::Add(102, 103), Op::Mul(89, 66), Op::Add(104, 105), Op::Mul(92, 68), Op::Add(106, 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_296() -> 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_297() -> 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(296, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(297, 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_298() -> 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(90, vec![0], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(298, 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_299() -> 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(298, 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(297, 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(298, vec![33, 34], 2, false), Op::Call(28, vec![36], 2, false), Op::Call(241, 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_300() -> 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(299, vec![0], 5, false), Op::Const(G::from_u64(1)), Op::Sub(1, 7), Op::Call(300, 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_301() -> Function { - Function { body: Block { ops: vec![Op::Call(28, vec![0], 2, false), Op::Call(243, 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_302() -> 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(301, vec![0], 10, false), Op::Const(G::from_u64(1)), Op::Sub(1, 12), Op::Call(302, 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_303() -> 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, false), 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(300, 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(302, 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: 11 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_304() -> 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(219, 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_305() -> 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(235, 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(305, 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_306() -> 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, 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::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::Add(50, 83), Op::Const(G::from_u64(65536)), Op::Mul(85, 52), Op::Add(84, 86), Op::Const(G::from_u64(16777216)), Op::Mul(88, 53), Op::Add(87, 89), Op::Mul(82, 55), Op::Add(54, 91), Op::Mul(85, 56), Op::Add(92, 93), Op::Mul(88, 57), Op::Add(94, 95), Op::Mul(82, 59), Op::Add(58, 97), Op::Mul(85, 60), Op::Add(98, 99), Op::Mul(88, 61), Op::Add(100, 101), Op::Mul(82, 63), Op::Add(62, 103), Op::Mul(85, 64), Op::Add(104, 105), Op::Mul(88, 65), Op::Add(106, 107), Op::Mul(82, 67), Op::Add(66, 109), Op::Mul(85, 68), Op::Add(110, 111), Op::Mul(88, 69), Op::Add(112, 113), Op::Mul(82, 71), Op::Add(70, 115), Op::Mul(85, 72), Op::Add(116, 117), Op::Mul(88, 73), Op::Add(118, 119), Op::Mul(82, 75), Op::Add(74, 121), Op::Mul(85, 76), Op::Add(122, 123), Op::Mul(88, 77), Op::Add(124, 125), Op::Mul(82, 79), Op::Add(78, 127), Op::Mul(85, 80), Op::Add(128, 129), Op::Mul(88, 81), Op::Add(130, 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(295, 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: 9 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_307() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(282, 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(275, vec![28, 29, 30, 31, 32, 33, 34, 35], 1, false), Op::Call(295, 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_308() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(280, vec![24, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 12, false), Op::Call(306, vec![16, 17, 18, 19, 20, 21, 22, 23], 19, false), Op::Call(303, vec![24, 37], 2, false), Op::Call(304, vec![25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 56, 57], 5, false), Op::Call(233, 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(327, vec![56, 65], 1, false), Op::Call(305, 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_309() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(307, 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(307, 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(306, 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_310() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(307, 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(280, 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(303, vec![66, 35], 2, false), Op::Call(317, vec![67], 1, false), Op::Call(230, 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(234, vec![68, 34, 34], 1, false), Op::AssertEq(vec![73], vec![66], None), Op::Call(304, vec![54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 67, 68], 5, false), Op::Call(226, 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(237, vec![67], 1, false), Op::Call(279, vec![84], 1, false), Op::Call(319, 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(276, vec![85, 34], 1, false), Op::AssertEq(vec![88], vec![34], Some("aggr range: batch claim has the wrong channel".into())), Op::Call(276, 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(277, vec![85, 90], 8, false), Op::Call(278, 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_311() -> 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, 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![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::Add(59, 92), Op::Const(G::from_u64(65536)), Op::Mul(94, 61), Op::Add(93, 95), Op::Const(G::from_u64(16777216)), Op::Mul(97, 62), Op::Add(96, 98), Op::Mul(91, 64), Op::Add(63, 100), Op::Mul(94, 65), Op::Add(101, 102), Op::Mul(97, 66), Op::Add(103, 104), Op::Mul(91, 68), Op::Add(67, 106), Op::Mul(94, 69), Op::Add(107, 108), Op::Mul(97, 70), Op::Add(109, 110), Op::Mul(91, 72), Op::Add(71, 112), Op::Mul(94, 73), Op::Add(113, 114), Op::Mul(97, 74), Op::Add(115, 116), Op::Mul(91, 76), Op::Add(75, 118), Op::Mul(94, 77), Op::Add(119, 120), Op::Mul(97, 78), Op::Add(121, 122), Op::Mul(91, 80), Op::Add(79, 124), Op::Mul(94, 81), Op::Add(125, 126), Op::Mul(97, 82), Op::Add(127, 128), Op::Mul(91, 84), Op::Add(83, 130), Op::Mul(94, 85), Op::Add(131, 132), Op::Mul(97, 86), Op::Add(133, 134), Op::Mul(91, 88), Op::Add(87, 136), Op::Mul(94, 89), Op::Add(137, 138), Op::Mul(97, 90), Op::Add(139, 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(244, 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(244, 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(246, vec![142], 8, false), Op::Call(246, 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, false), Op::Call(90, 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(283, 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(283, 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(284, 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(284, 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(284, 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(284, 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(285, 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(285, 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(285, 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(285, 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(308, 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(309, 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(310, 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![]) }), (G::from_u64(13), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(286, 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(13, vec![]) }), (G::from_u64(14), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(286, 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(14, vec![]) }), (G::from_u64(15), 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(15, vec![]) }), (G::from_u64(16), Block { ops: vec![Op::Call(294, 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(16, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 16, selectors: 17, auxiliaries: 106, lookups: 35 }, entry: true, constrained: true } -} - -#[inline(never)] -fn expected_function_312() -> Function { - Function { body: Block { ops: vec![Op::Call(326, 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_313() -> 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(313, 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_314() -> 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(314, 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_315() -> 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(315, 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_316() -> 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(316, 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_317() -> 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(317, 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_318() -> 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(318, 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_319() -> 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(319, 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_320() -> 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(320, 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_321() -> Function { - Function { body: Block { ops: vec![Op::Call(327, 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_322() -> 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_323() -> Function { - Function { body: Block { ops: vec![Op::Call(329, 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_324() -> 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(324, 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_325() -> 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(325, 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_326() -> 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(326, 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_327() -> 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(327, 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_328() -> Function { - Function { body: Block { ops: vec![Op::Call(330, 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_329() -> 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(329, 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_330() -> 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(330, 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(), 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()], memory_sizes: vec![3, 4, 5, 6, 7, 8, 10, 11, 26, 32, 34], circuits: vec![Circuit { members: vec![0, 4, 13, 14, 102, 125, 126, 127, 128, 170, 186, 194], layout: FunctionLayout { input_size: 8, selectors: 40, auxiliaries: 20, lookups: 7 } }, Circuit { members: vec![1, 2, 250, 257, 259, 260, 270, 275, 277, 278, 279, 282], layout: FunctionLayout { input_size: 28, selectors: 40, auxiliaries: 73, lookups: 10 } }, Circuit { members: vec![3], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 8, lookups: 5 } }, Circuit { members: vec![12], layout: FunctionLayout { input_size: 16, selectors: 9, auxiliaries: 2, lookups: 1 } }, Circuit { members: vec![26, 40, 94, 96, 103, 147, 188, 195, 209, 210, 211, 320], layout: FunctionLayout { input_size: 3, selectors: 25, auxiliaries: 18, lookups: 6 } }, Circuit { members: vec![27, 76, 77, 95, 131, 142, 154, 163, 171, 179, 180, 183, 200], layout: FunctionLayout { input_size: 44, selectors: 26, auxiliaries: 137, lookups: 14 } }, Circuit { members: vec![28, 48, 56, 59, 61, 75, 114, 143, 161, 176, 182, 207, 243, 318, 324], layout: FunctionLayout { input_size: 9, selectors: 27, auxiliaries: 98, lookups: 32 } }, Circuit { members: vec![31, 327], layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 11, lookups: 3 } }, Circuit { members: vec![35, 45, 49, 111, 130, 144, 155, 157, 165, 166, 169, 181], layout: FunctionLayout { input_size: 5, selectors: 25, auxiliaries: 9, lookups: 5 } }, Circuit { members: vec![36, 314], 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, 83, 93, 116, 124, 133, 138, 139, 177, 316], layout: FunctionLayout { input_size: 2, selectors: 23, auxiliaries: 8, lookups: 4 } }, Circuit { members: vec![39, 198], layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 23, lookups: 3 } }, Circuit { members: vec![41, 52, 108, 122, 134, 141, 145, 160, 164, 167, 184, 189, 191, 203, 325], layout: FunctionLayout { input_size: 8, selectors: 31, auxiliaries: 42, lookups: 9 } }, Circuit { members: vec![43, 100], 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: 9, auxiliaries: 22, lookups: 10 } }, Circuit { members: vec![82, 84, 85, 106, 178, 206, 244, 245, 295, 296], layout: FunctionLayout { input_size: 20, selectors: 29, auxiliaries: 193, lookups: 65 } }, Circuit { members: vec![89], layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 } }, Circuit { members: vec![90], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 4, lookups: 2 } }, Circuit { members: vec![91], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 3, lookups: 2 } }, Circuit { members: vec![92], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 5, lookups: 3 } }, Circuit { members: vec![98, 107, 148, 156, 162, 168, 204, 208, 241, 246, 317], layout: FunctionLayout { input_size: 25, selectors: 38, auxiliaries: 46, lookups: 20 } }, Circuit { members: vec![99], layout: FunctionLayout { input_size: 3, selectors: 17, auxiliaries: 24, lookups: 8 } }, Circuit { members: vec![115, 193, 322], layout: FunctionLayout { input_size: 6, selectors: 5, auxiliaries: 5, lookups: 2 } }, Circuit { members: vec![117], layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 23, lookups: 6 } }, Circuit { members: vec![118, 129, 137], layout: FunctionLayout { input_size: 4, selectors: 10, auxiliaries: 34, lookups: 13 } }, Circuit { members: vec![119], layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 25, lookups: 6 } }, Circuit { members: vec![120], layout: FunctionLayout { input_size: 6, selectors: 15, auxiliaries: 205, lookups: 21 } }, Circuit { members: vec![123, 132, 323, 329], layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![136], layout: FunctionLayout { input_size: 8, selectors: 2, auxiliaries: 27, lookups: 4 } }, Circuit { members: vec![146], layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 19, lookups: 5 } }, Circuit { members: vec![149], layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 15, lookups: 7 } }, Circuit { members: vec![150, 151, 152, 153, 197, 199], layout: FunctionLayout { input_size: 19, selectors: 12, auxiliaries: 14, lookups: 7 } }, Circuit { members: vec![174], layout: FunctionLayout { input_size: 9, selectors: 1, auxiliaries: 9, lookups: 9 } }, Circuit { members: vec![196], layout: FunctionLayout { input_size: 15, selectors: 15, auxiliaries: 13, lookups: 4 } }, Circuit { members: vec![212], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 15, lookups: 6 } }, Circuit { members: vec![213], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 } }, Circuit { members: vec![214], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 6 } }, Circuit { members: vec![215], layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 7, lookups: 7 } }, Circuit { members: vec![216], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 4 } }, Circuit { members: vec![217], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 4, lookups: 4 } }, Circuit { members: vec![218], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 17, lookups: 7 } }, Circuit { members: vec![219], layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 64, lookups: 30 } }, Circuit { members: vec![220], layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 56, lookups: 13 } }, Circuit { members: vec![221], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 8, lookups: 4 } }, Circuit { members: vec![222], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 23, lookups: 5 } }, Circuit { members: vec![223], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 9, lookups: 5 } }, Circuit { members: vec![224], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 76, lookups: 10 } }, Circuit { members: vec![225], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 4 } }, Circuit { members: vec![226], layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 26, lookups: 4 } }, Circuit { members: vec![227], layout: FunctionLayout { input_size: 1, selectors: 34, auxiliaries: 34, lookups: 1 } }, Circuit { members: vec![228], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![229], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 } }, Circuit { members: vec![230], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 18, lookups: 5 } }, Circuit { members: vec![231], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 41, lookups: 5 } }, Circuit { members: vec![232], layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 5, lookups: 2 } }, Circuit { members: vec![233], layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 } }, Circuit { members: vec![234], layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 156, lookups: 33 } }, Circuit { members: vec![235], layout: FunctionLayout { input_size: 46, selectors: 5, auxiliaries: 91, lookups: 54 } }, Circuit { members: vec![236], layout: FunctionLayout { input_size: 22, selectors: 2, auxiliaries: 37, lookups: 5 } }, Circuit { members: vec![237], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 9, lookups: 4 } }, Circuit { members: vec![238], layout: FunctionLayout { input_size: 15, selectors: 3, auxiliaries: 23, lookups: 11 } }, Circuit { members: vec![247, 248, 251, 252, 253, 254, 255, 256, 258, 263, 264, 265, 269, 276, 328, 330, 288, 289, 297, 298, 300], layout: FunctionLayout { input_size: 4, selectors: 48, auxiliaries: 13, lookups: 7 } }, Circuit { members: vec![261], layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 14, lookups: 7 } }, Circuit { members: vec![262], layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 10, lookups: 5 } }, Circuit { members: vec![266, 267, 268, 280, 281, 283, 284, 285, 286, 292, 294, 308, 309, 310, 306, 307, 273, 291, 299, 305, 303, 290, 271, 272, 274, 293, 301, 302, 304, 287], layout: FunctionLayout { input_size: 36, selectors: 61, auxiliaries: 143, lookups: 31 } }, Circuit { members: vec![311], layout: FunctionLayout { input_size: 16, selectors: 17, auxiliaries: 106, lookups: 35 } }, Circuit { members: vec![312, 315, 326], layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 6, lookups: 3 } }, Circuit { members: vec![313], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 28, lookups: 3 } }, Circuit { members: vec![319], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 3 } }, Circuit { members: vec![321], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 8, lookups: 3 } }] } -} -pub static PROGRAM: GeneratedProgram = GeneratedProgram { fingerprint: [16, 192, 139, 155, 202, 145, 36, 243, 93, 246, 216, 189, 250, 221, 54, 36, 149, 240, 11, 40, 210, 134, 183, 238, 67, 74, 234, 134, 107, 96, 246, 23], 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, -None, -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 }, output_size: 32, seed_words: 162, schema: &SCHEMA_89, pack: pack_89, pack_typed: pack_89_typed, write: |seed, offsets, row| { write_89(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_120, pack: pack_120, pack_typed: pack_120_typed, write: |seed, offsets, row| { write_120(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_223, pack: pack_223, pack_typed: pack_223_typed, write: write_223 }), -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_233, pack: pack_233, pack_typed: pack_233_typed, write: |seed, offsets, row| { write_233(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, -Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 14, lookups: 7 }, output_size: 0, seed_words: 15, schema: &SCHEMA_261, pack: pack_261, pack_typed: pack_261_typed, write: write_261 }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 10, lookups: 5 }, output_size: 0, seed_words: 10, schema: &SCHEMA_262, pack: pack_262, pack_typed: pack_262_typed, write: write_262 }), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -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 deleted file mode 100644 index cb07c9241..000000000 --- a/crates/aiur/src/trace_codegen/programs/ix_aggr_cuda.rs +++ /dev/null @@ -1,345 +0,0 @@ -// 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_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_ix_aggr_120(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_223(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_233(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_261(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_262(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([16, 192, 139, 155, 202, 145, 36, 243, 93, 246, 216, 189, 250, 221, 54, 36, 149, 240, 11, 40, 210, 134, 183, 238, 67, 74, 234, 134, 107, 96, 246, 23], 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, -None, -None, -None, -Some(aiur_trace_ix_aggr_89), -None, -None, -None, -None, -None, -None, -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_120), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -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_223), -None, -None, -None, -None, -None, -None, -None, -None, -None, -Some(aiur_trace_ix_aggr_233), -None, -None, -None, -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_261), -Some(aiur_trace_ix_aggr_262), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -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, 9, 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, 25, 0, 0, 0, 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, 17, 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, 15, 10, 10, 9, 16, 11, 56, 16, 6, 23, 17, 15, 6, 14, 49, 11, 11, 17, 8, 159, 40, 62, 44, 125, 125, 116, 2, 11, 8, 25, 7, 126, 24, 95, 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, 48, 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, 160, 0, 0, 0, 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, 112, 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, 56, 40, 48, 40, 56, 64, 336, 56, 32, 80, 56, 48, 24, 56, 360, 88, 88, 136, 32, 784, 200, 432, 352, 840, 832, 784, 16, 64, 48, 136, 48, 824, 144, 712, 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 deleted file mode 100644 index 5136beabd..000000000 --- a/crates/aiur/src/trace_codegen/programs/ixvm.rs +++ /dev/null @@ -1,5537 +0,0 @@ -// 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_24(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, v_35, 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]: [G; 34] = context.load::<34>(0, v_0)?; 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(); seed[58] = v_57.as_canonical_u64(); seed[59] = v_58.as_canonical_u64(); seed[60] = v_59.as_canonical_u64(); seed[61] = v_60.as_canonical_u64(); seed[62] = v_61.as_canonical_u64(); seed[63] = v_62.as_canonical_u64(); seed[64] = v_63.as_canonical_u64(); seed[65] = v_64.as_canonical_u64(); seed[66] = v_65.as_canonical_u64(); seed[67] = v_66.as_canonical_u64(); seed[68] = v_67.as_canonical_u64(); match v_34.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_69]: [G; 1] = [G::from_u64(0)]; let [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]: [G; 34] = context.call::<34>(3, 24, &[v_35, 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_69])?; seed[69] = v_70.as_canonical_u64(); seed[70] = v_71.as_canonical_u64(); seed[71] = v_72.as_canonical_u64(); seed[72] = v_73.as_canonical_u64(); seed[73] = v_74.as_canonical_u64(); seed[74] = v_75.as_canonical_u64(); seed[75] = v_76.as_canonical_u64(); seed[76] = v_77.as_canonical_u64(); seed[77] = v_78.as_canonical_u64(); seed[78] = v_79.as_canonical_u64(); seed[79] = v_80.as_canonical_u64(); seed[80] = v_81.as_canonical_u64(); seed[81] = v_82.as_canonical_u64(); seed[82] = v_83.as_canonical_u64(); seed[83] = v_84.as_canonical_u64(); seed[84] = v_85.as_canonical_u64(); seed[85] = v_86.as_canonical_u64(); seed[86] = v_87.as_canonical_u64(); seed[87] = v_88.as_canonical_u64(); seed[88] = v_89.as_canonical_u64(); seed[89] = v_90.as_canonical_u64(); seed[90] = v_91.as_canonical_u64(); seed[91] = v_92.as_canonical_u64(); seed[92] = v_93.as_canonical_u64(); seed[93] = v_94.as_canonical_u64(); seed[94] = v_95.as_canonical_u64(); seed[95] = v_96.as_canonical_u64(); seed[96] = v_97.as_canonical_u64(); seed[97] = v_98.as_canonical_u64(); seed[98] = v_99.as_canonical_u64(); seed[99] = v_100.as_canonical_u64(); seed[100] = v_101.as_canonical_u64(); seed[101] = v_102.as_canonical_u64(); seed[102] = v_103.as_canonical_u64(); match v_70.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { let [v_105]: [G; 1] = [G::from_u64(4)]; let [v_106]: [G; 1] = [G::from_u64(8)]; let [v_107]: [G; 1] = [G::from_u64(103)]; let [v_108]: [G; 1] = [G::from_u64(230)]; let [v_109]: [G; 1] = [G::from_u64(9)]; let [v_110]: [G; 1] = [G::from_u64(106)]; let [v_111]: [G; 1] = [G::from_u64(133)]; let [v_112]: [G; 1] = [G::from_u64(174)]; let [v_113]: [G; 1] = [G::from_u64(187)]; let [v_114]: [G; 1] = [G::from_u64(114)]; let [v_115]: [G; 1] = [G::from_u64(243)]; let [v_116]: [G; 1] = [G::from_u64(110)]; let [v_117]: [G; 1] = [G::from_u64(60)]; let [v_118]: [G; 1] = [G::from_u64(58)]; let [v_119]: [G; 1] = [G::from_u64(245)]; let [v_120]: [G; 1] = [G::from_u64(79)]; let [v_121]: [G; 1] = [G::from_u64(165)]; let [v_122]: [G; 1] = [G::from_u64(127)]; let [v_123]: [G; 1] = [G::from_u64(82)]; let [v_124]: [G; 1] = [G::from_u64(14)]; let [v_125]: [G; 1] = [G::from_u64(81)]; let [v_126]: [G; 1] = [G::from_u64(140)]; let [v_127]: [G; 1] = [G::from_u64(104)]; let [v_128]: [G; 1] = [G::from_u64(5)]; let [v_129]: [G; 1] = [G::from_u64(155)]; let [v_130]: [G; 1] = [G::from_u64(171)]; let [v_131]: [G; 1] = [G::from_u64(217)]; let [v_132]: [G; 1] = [G::from_u64(131)]; let [v_133]: [G; 1] = [G::from_u64(31)]; let [v_134]: [G; 1] = [G::from_u64(25)]; let [v_135]: [G; 1] = [G::from_u64(205)]; let [v_136]: [G; 1] = [G::from_u64(224)]; let [v_137]: [G; 1] = [G::from_u64(91)]; let [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]: [G; 34] = context.load::<34>(38, v_103)?; seed[103] = v_138.as_canonical_u64(); seed[104] = v_139.as_canonical_u64(); seed[105] = v_140.as_canonical_u64(); seed[106] = v_141.as_canonical_u64(); seed[107] = v_142.as_canonical_u64(); seed[108] = v_143.as_canonical_u64(); seed[109] = v_144.as_canonical_u64(); seed[110] = v_145.as_canonical_u64(); seed[111] = v_146.as_canonical_u64(); seed[112] = v_147.as_canonical_u64(); seed[113] = v_148.as_canonical_u64(); seed[114] = v_149.as_canonical_u64(); seed[115] = v_150.as_canonical_u64(); seed[116] = v_151.as_canonical_u64(); seed[117] = v_152.as_canonical_u64(); seed[118] = v_153.as_canonical_u64(); seed[119] = v_154.as_canonical_u64(); seed[120] = v_155.as_canonical_u64(); seed[121] = v_156.as_canonical_u64(); seed[122] = v_157.as_canonical_u64(); seed[123] = v_158.as_canonical_u64(); seed[124] = v_159.as_canonical_u64(); seed[125] = v_160.as_canonical_u64(); seed[126] = v_161.as_canonical_u64(); seed[127] = v_162.as_canonical_u64(); seed[128] = v_163.as_canonical_u64(); seed[129] = v_164.as_canonical_u64(); seed[130] = v_165.as_canonical_u64(); seed[131] = v_166.as_canonical_u64(); seed[132] = v_167.as_canonical_u64(); seed[133] = v_168.as_canonical_u64(); seed[134] = v_169.as_canonical_u64(); seed[135] = v_170.as_canonical_u64(); seed[136] = v_171.as_canonical_u64(); match v_138.as_canonical_u64() { 1u64 => { let [v_172]: [G; 1] = [v_106 * v_33]; let [v_173]: [G; 1] = [v_105 + v_172]; let [v_174]: [G; 1] = [G::from_u64(0)]; let [v_175]: [G; 1] = [G::from_u64(64)]; let [v_176]: [G; 1] = [G::from_u64(103)]; let [v_177]: [G; 1] = [G::from_u64(230)]; let [v_178]: [G; 1] = [G::from_u64(9)]; let [v_179]: [G; 1] = [G::from_u64(106)]; let [v_180]: [G; 1] = [G::from_u64(133)]; let [v_181]: [G; 1] = [G::from_u64(174)]; let [v_182]: [G; 1] = [G::from_u64(187)]; let [v_183]: [G; 1] = [G::from_u64(114)]; let [v_184]: [G; 1] = [G::from_u64(243)]; let [v_185]: [G; 1] = [G::from_u64(110)]; let [v_186]: [G; 1] = [G::from_u64(60)]; let [v_187]: [G; 1] = [G::from_u64(58)]; let [v_188]: [G; 1] = [G::from_u64(245)]; let [v_189]: [G; 1] = [G::from_u64(79)]; let [v_190]: [G; 1] = [G::from_u64(165)]; let [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]: [G; 32] = context.call::<32>(58, 37, &[v_174, v_107, v_108, v_109, v_110, v_111, v_112, v_107, 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_176, v_177, v_178, v_179, v_180, v_181, v_176, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_174, v_174, v_174, v_174, v_174, v_174, v_174, v_174, v_175, v_174, v_174, v_174, v_173, v_174, v_174, v_174, 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_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32])?; seed[137] = v_191.as_canonical_u64(); seed[138] = v_192.as_canonical_u64(); seed[139] = v_193.as_canonical_u64(); seed[140] = v_194.as_canonical_u64(); seed[141] = v_195.as_canonical_u64(); seed[142] = v_196.as_canonical_u64(); seed[143] = v_197.as_canonical_u64(); seed[144] = v_198.as_canonical_u64(); seed[145] = v_199.as_canonical_u64(); seed[146] = v_200.as_canonical_u64(); seed[147] = v_201.as_canonical_u64(); seed[148] = v_202.as_canonical_u64(); seed[149] = v_203.as_canonical_u64(); seed[150] = v_204.as_canonical_u64(); seed[151] = v_205.as_canonical_u64(); seed[152] = v_206.as_canonical_u64(); seed[153] = v_207.as_canonical_u64(); seed[154] = v_208.as_canonical_u64(); seed[155] = v_209.as_canonical_u64(); seed[156] = v_210.as_canonical_u64(); seed[157] = v_211.as_canonical_u64(); seed[158] = v_212.as_canonical_u64(); seed[159] = v_213.as_canonical_u64(); seed[160] = v_214.as_canonical_u64(); seed[161] = v_215.as_canonical_u64(); seed[162] = v_216.as_canonical_u64(); seed[163] = v_217.as_canonical_u64(); seed[164] = v_218.as_canonical_u64(); seed[165] = v_219.as_canonical_u64(); seed[166] = v_220.as_canonical_u64(); seed[167] = v_221.as_canonical_u64(); seed[168] = v_222.as_canonical_u64(); let [v_223]: [G; 1] = context.store(59, &[v_174, v_103, 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])?; seed[169] = v_223.as_canonical_u64(); Ok(()) }, _ => { let [v_224]: [G; 1] = [G::from_u64(0)]; let [v_225]: [G; 1] = [G::from_u64(64)]; let [v_226]: [G; 1] = [G::from_u64(103)]; let [v_227]: [G; 1] = [G::from_u64(230)]; let [v_228]: [G; 1] = [G::from_u64(9)]; let [v_229]: [G; 1] = [G::from_u64(106)]; let [v_230]: [G; 1] = [G::from_u64(133)]; let [v_231]: [G; 1] = [G::from_u64(174)]; let [v_232]: [G; 1] = [G::from_u64(187)]; let [v_233]: [G; 1] = [G::from_u64(114)]; let [v_234]: [G; 1] = [G::from_u64(243)]; let [v_235]: [G; 1] = [G::from_u64(110)]; let [v_236]: [G; 1] = [G::from_u64(60)]; let [v_237]: [G; 1] = [G::from_u64(58)]; let [v_238]: [G; 1] = [G::from_u64(245)]; let [v_239]: [G; 1] = [G::from_u64(79)]; let [v_240]: [G; 1] = [G::from_u64(165)]; 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.call::<32>(77, 37, &[v_224, v_107, v_108, v_109, v_110, v_111, v_112, v_107, 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_226, v_227, v_228, v_229, v_230, v_231, v_226, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_224, v_224, v_224, v_224, v_224, v_224, v_224, v_224, v_225, v_224, v_224, v_224, v_105, v_224, v_224, v_224, 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_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32])?; seed[137] = v_241.as_canonical_u64(); seed[138] = v_242.as_canonical_u64(); seed[139] = v_243.as_canonical_u64(); seed[140] = v_244.as_canonical_u64(); seed[141] = v_245.as_canonical_u64(); seed[142] = v_246.as_canonical_u64(); seed[143] = v_247.as_canonical_u64(); seed[144] = v_248.as_canonical_u64(); seed[145] = v_249.as_canonical_u64(); seed[146] = v_250.as_canonical_u64(); seed[147] = v_251.as_canonical_u64(); seed[148] = v_252.as_canonical_u64(); seed[149] = v_253.as_canonical_u64(); seed[150] = v_254.as_canonical_u64(); seed[151] = v_255.as_canonical_u64(); seed[152] = v_256.as_canonical_u64(); seed[153] = v_257.as_canonical_u64(); seed[154] = v_258.as_canonical_u64(); seed[155] = v_259.as_canonical_u64(); seed[156] = v_260.as_canonical_u64(); seed[157] = v_261.as_canonical_u64(); seed[158] = v_262.as_canonical_u64(); seed[159] = v_263.as_canonical_u64(); seed[160] = v_264.as_canonical_u64(); seed[161] = v_265.as_canonical_u64(); seed[162] = v_266.as_canonical_u64(); seed[163] = v_267.as_canonical_u64(); seed[164] = v_268.as_canonical_u64(); seed[165] = v_269.as_canonical_u64(); seed[166] = v_270.as_canonical_u64(); seed[167] = v_271.as_canonical_u64(); seed[168] = v_272.as_canonical_u64(); let [v_273]: [G; 1] = context.store(78, &[v_224, v_103, 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])?; seed[169] = v_273.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(24, v_70)) }, } }, _ => { Err(no_match(24, v_34)) }, } } - -fn pack_24_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, v_35, 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]: [G; 34] = context.load::<34>(0, v_0)?; seed.u8(328, v_34); seed.u32(284, v_35); seed.u8(329, v_36); seed.u8(330, v_37); seed.u8(331, v_38); seed.u8(332, v_39); seed.u8(333, v_40); seed.u8(334, v_41); seed.u8(335, v_42); seed.u8(336, v_43); seed.u8(337, v_44); seed.u8(338, v_45); seed.u8(339, v_46); seed.u8(340, v_47); seed.u8(341, v_48); seed.u8(342, v_49); seed.u8(343, v_50); seed.u8(344, v_51); seed.u8(345, v_52); seed.u8(346, v_53); seed.u8(347, v_54); seed.u8(348, v_55); seed.u8(349, v_56); seed.u8(350, v_57); seed.u8(351, v_58); seed.u8(352, v_59); seed.u8(353, v_60); seed.u8(354, v_61); seed.u8(355, v_62); seed.u8(356, v_63); seed.u8(357, v_64); seed.u8(358, v_65); seed.u8(359, v_66); seed.u8(360, v_67); match v_34.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_69]: [G; 1] = [G::from_u64(0)]; let [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]: [G; 34] = context.call::<34>(3, 24, &[v_35, 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_69])?; seed.u8(361, v_70); seed.u8(362, v_71); seed.u8(363, v_72); seed.u8(364, v_73); seed.u8(365, v_74); seed.u8(366, v_75); seed.u8(367, v_76); seed.u8(368, v_77); seed.u8(369, v_78); seed.u8(370, v_79); seed.u8(371, v_80); seed.u8(372, v_81); seed.u8(373, v_82); seed.u8(374, v_83); seed.u8(375, v_84); seed.u8(376, v_85); seed.u8(377, v_86); seed.u8(378, v_87); seed.u8(379, v_88); seed.u8(380, v_89); seed.u8(381, v_90); seed.u8(382, v_91); seed.u8(383, v_92); seed.u8(384, v_93); seed.u8(385, v_94); seed.u8(386, v_95); seed.u8(387, v_96); seed.u8(388, v_97); seed.u8(389, v_98); seed.u8(390, v_99); seed.u8(391, v_100); seed.u8(392, v_101); seed.u8(393, v_102); seed.u32(288, v_103); match v_70.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { let [v_105]: [G; 1] = [G::from_u64(4)]; let [v_106]: [G; 1] = [G::from_u64(8)]; let [v_107]: [G; 1] = [G::from_u64(103)]; let [v_108]: [G; 1] = [G::from_u64(230)]; let [v_109]: [G; 1] = [G::from_u64(9)]; let [v_110]: [G; 1] = [G::from_u64(106)]; let [v_111]: [G; 1] = [G::from_u64(133)]; let [v_112]: [G; 1] = [G::from_u64(174)]; let [v_113]: [G; 1] = [G::from_u64(187)]; let [v_114]: [G; 1] = [G::from_u64(114)]; let [v_115]: [G; 1] = [G::from_u64(243)]; let [v_116]: [G; 1] = [G::from_u64(110)]; let [v_117]: [G; 1] = [G::from_u64(60)]; let [v_118]: [G; 1] = [G::from_u64(58)]; let [v_119]: [G; 1] = [G::from_u64(245)]; let [v_120]: [G; 1] = [G::from_u64(79)]; let [v_121]: [G; 1] = [G::from_u64(165)]; let [v_122]: [G; 1] = [G::from_u64(127)]; let [v_123]: [G; 1] = [G::from_u64(82)]; let [v_124]: [G; 1] = [G::from_u64(14)]; let [v_125]: [G; 1] = [G::from_u64(81)]; let [v_126]: [G; 1] = [G::from_u64(140)]; let [v_127]: [G; 1] = [G::from_u64(104)]; let [v_128]: [G; 1] = [G::from_u64(5)]; let [v_129]: [G; 1] = [G::from_u64(155)]; let [v_130]: [G; 1] = [G::from_u64(171)]; let [v_131]: [G; 1] = [G::from_u64(217)]; let [v_132]: [G; 1] = [G::from_u64(131)]; let [v_133]: [G; 1] = [G::from_u64(31)]; let [v_134]: [G; 1] = [G::from_u64(25)]; let [v_135]: [G; 1] = [G::from_u64(205)]; let [v_136]: [G; 1] = [G::from_u64(224)]; let [v_137]: [G; 1] = [G::from_u64(91)]; let [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]: [G; 34] = context.load::<34>(38, v_103)?; seed.u8(394, v_138); seed.full(16, v_139); seed.full(24, v_140); seed.full(32, v_141); seed.full(40, v_142); seed.full(48, v_143); seed.full(56, v_144); seed.full(64, v_145); seed.full(72, v_146); seed.full(80, v_147); seed.full(88, v_148); seed.full(96, v_149); seed.full(104, v_150); seed.full(112, v_151); seed.full(120, v_152); seed.full(128, v_153); seed.full(136, v_154); seed.full(144, v_155); seed.full(152, v_156); seed.full(160, v_157); seed.full(168, v_158); seed.full(176, v_159); seed.full(184, v_160); seed.full(192, v_161); seed.full(200, v_162); seed.full(208, v_163); seed.full(216, v_164); seed.full(224, v_165); seed.full(232, v_166); seed.full(240, v_167); seed.full(248, v_168); seed.full(256, v_169); seed.full(264, v_170); seed.full(272, v_171); match v_138.as_canonical_u64() { 1u64 => { let [v_172]: [G; 1] = [v_106 * v_33]; let [v_173]: [G; 1] = [v_105 + v_172]; let [v_174]: [G; 1] = [G::from_u64(0)]; let [v_175]: [G; 1] = [G::from_u64(64)]; let [v_176]: [G; 1] = [G::from_u64(103)]; let [v_177]: [G; 1] = [G::from_u64(230)]; let [v_178]: [G; 1] = [G::from_u64(9)]; let [v_179]: [G; 1] = [G::from_u64(106)]; let [v_180]: [G; 1] = [G::from_u64(133)]; let [v_181]: [G; 1] = [G::from_u64(174)]; let [v_182]: [G; 1] = [G::from_u64(187)]; let [v_183]: [G; 1] = [G::from_u64(114)]; let [v_184]: [G; 1] = [G::from_u64(243)]; let [v_185]: [G; 1] = [G::from_u64(110)]; let [v_186]: [G; 1] = [G::from_u64(60)]; let [v_187]: [G; 1] = [G::from_u64(58)]; let [v_188]: [G; 1] = [G::from_u64(245)]; let [v_189]: [G; 1] = [G::from_u64(79)]; let [v_190]: [G; 1] = [G::from_u64(165)]; let [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]: [G; 32] = context.call::<32>(58, 37, &[v_174, v_107, v_108, v_109, v_110, v_111, v_112, v_107, 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_176, v_177, v_178, v_179, v_180, v_181, v_176, v_182, v_183, v_184, v_185, v_186, v_187, v_188, v_189, v_190, v_174, v_174, v_174, v_174, v_174, v_174, v_174, v_174, v_175, v_174, v_174, v_174, v_173, v_174, v_174, v_174, 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_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32])?; seed.u8(395, v_191); seed.u8(396, v_192); seed.u8(397, v_193); seed.u8(398, v_194); seed.u8(399, v_195); seed.u8(400, v_196); seed.u8(401, v_197); seed.u8(402, v_198); seed.u8(403, v_199); seed.u8(404, v_200); seed.u8(405, v_201); seed.u8(406, v_202); seed.u8(407, v_203); seed.u8(408, v_204); seed.u8(409, v_205); seed.u8(410, v_206); seed.u8(411, v_207); seed.u8(412, v_208); seed.u8(413, v_209); seed.u8(414, v_210); seed.u8(415, v_211); seed.u8(416, v_212); seed.u8(417, v_213); seed.u8(418, v_214); seed.u8(419, v_215); seed.u8(420, v_216); seed.u8(421, v_217); seed.u8(422, v_218); seed.u8(423, v_219); seed.u8(424, v_220); seed.u8(425, v_221); seed.u8(426, v_222); let [v_223]: [G; 1] = context.store(59, &[v_174, v_103, 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])?; seed.u32(292, v_223); Ok(()) }, _ => { let [v_224]: [G; 1] = [G::from_u64(0)]; let [v_225]: [G; 1] = [G::from_u64(64)]; let [v_226]: [G; 1] = [G::from_u64(103)]; let [v_227]: [G; 1] = [G::from_u64(230)]; let [v_228]: [G; 1] = [G::from_u64(9)]; let [v_229]: [G; 1] = [G::from_u64(106)]; let [v_230]: [G; 1] = [G::from_u64(133)]; let [v_231]: [G; 1] = [G::from_u64(174)]; let [v_232]: [G; 1] = [G::from_u64(187)]; let [v_233]: [G; 1] = [G::from_u64(114)]; let [v_234]: [G; 1] = [G::from_u64(243)]; let [v_235]: [G; 1] = [G::from_u64(110)]; let [v_236]: [G; 1] = [G::from_u64(60)]; let [v_237]: [G; 1] = [G::from_u64(58)]; let [v_238]: [G; 1] = [G::from_u64(245)]; let [v_239]: [G; 1] = [G::from_u64(79)]; let [v_240]: [G; 1] = [G::from_u64(165)]; 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.call::<32>(77, 37, &[v_224, v_107, v_108, v_109, v_110, v_111, v_112, v_107, 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_226, v_227, v_228, v_229, v_230, v_231, v_226, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, v_224, v_224, v_224, v_224, v_224, v_224, v_224, v_224, v_225, v_224, v_224, v_224, v_105, v_224, v_224, v_224, 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_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32])?; seed.u8(395, v_241); seed.u8(396, v_242); seed.u8(397, v_243); seed.u8(398, v_244); seed.u8(399, v_245); seed.u8(400, v_246); seed.u8(401, v_247); seed.u8(402, v_248); seed.u8(403, v_249); seed.u8(404, v_250); seed.u8(405, v_251); seed.u8(406, v_252); seed.u8(407, v_253); seed.u8(408, v_254); seed.u8(409, v_255); seed.u8(410, v_256); seed.u8(411, v_257); seed.u8(412, v_258); seed.u8(413, v_259); seed.u8(414, v_260); seed.u8(415, v_261); seed.u8(416, v_262); seed.u8(417, v_263); seed.u8(418, v_264); seed.u8(419, v_265); seed.u8(420, v_266); seed.u8(421, v_267); seed.u8(422, v_268); seed.u8(423, v_269); seed.u8(424, v_270); seed.u8(425, v_271); seed.u8(426, v_272); let [v_273]: [G; 1] = context.store(78, &[v_224, v_103, 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])?; seed.u32(292, v_273); Ok(()) }, } }, _ => { Err(no_match(24, v_70)) }, } }, _ => { Err(no_match(24, v_34)) }, } } - -fn write_24(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 = 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, v_35, 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]: [G; 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])]; row[offsets.auxiliaries + 1] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_43.as_canonical_u64(); 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(); row[offsets.auxiliaries + 20] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_67.as_canonical_u64(); match v_34.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [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]: [G; 34] = [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]), 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])]; row[offsets.auxiliaries + 35] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_95.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_96.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_101.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_102.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_103.as_canonical_u64(); match v_70.as_canonical_u64() { 0u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [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]: [G; 34] = [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]), 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])]; row[offsets.auxiliaries + 69] = v_138.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_140.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_141.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_142.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_143.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_144.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_145.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_146.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_147.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_148.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_149.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_150.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_151.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_152.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_153.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_154.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_155.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_156.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_157.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_158.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_159.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_160.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_162.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_164.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_165.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_166.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_167.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_168.as_canonical_u64(); row[offsets.auxiliaries + 100] = v_169.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_170.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_171.as_canonical_u64(); match v_138.as_canonical_u64() { 1u64 => { let [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]: [G; 32] = [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]), 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])]; row[offsets.auxiliaries + 103] = v_191.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_192.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_193.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_194.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_195.as_canonical_u64(); row[offsets.auxiliaries + 108] = v_196.as_canonical_u64(); row[offsets.auxiliaries + 109] = v_197.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_198.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_199.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_200.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_201.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_202.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_203.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_204.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_205.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_206.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_207.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_208.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_209.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_210.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_211.as_canonical_u64(); row[offsets.auxiliaries + 124] = v_212.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_213.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_214.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_215.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_216.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_217.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_219.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_220.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_221.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_222.as_canonical_u64(); let [v_223]: [G; 1] = [G::from_u64(seed[169])]; row[offsets.auxiliaries + 135] = v_223.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 103] = (v_138 - G::from_u64(1)).inverse().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[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]), 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])]; 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(); row[offsets.auxiliaries + 112] = v_249.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_250.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_251.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_252.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_253.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_254.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_255.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_256.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_257.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_258.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_259.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_260.as_canonical_u64(); row[offsets.auxiliaries + 124] = v_261.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_262.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_263.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_264.as_canonical_u64(); row[offsets.auxiliaries + 128] = v_265.as_canonical_u64(); row[offsets.auxiliaries + 129] = v_266.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_267.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_268.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_269.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_271.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_272.as_canonical_u64(); let [v_273]: [G; 1] = [G::from_u64(seed[169])]; row[offsets.auxiliaries + 136] = v_273.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(24, v_70)) }, } }, _ => { Err(no_match(24, v_34)) }, } } - -static SCHEMA_24: 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::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::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::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::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, 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::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::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::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, 280, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 8, 328, 284, 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, 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, 288, 394, 16, 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, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 292], bytes: 432 }; - -fn pack_26(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_14]: [G; 1] = [G::from_u64(1)]; let [v_15]: [G; 1] = [v_2 + v_14]; let [v_17, v_18, v_19]: [G; 3] = context.load::<3>(8, v_9)?; seed[12] = v_17.as_canonical_u64(); seed[13] = v_18.as_canonical_u64(); seed[14] = v_19.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { let [v_20]: [G; 1] = context.returned::<1>(9)?; seed[15] = v_20.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_21]: [G; 1] = [G::from_u64(0)]; let [v_22]: [G; 1] = context.store(11, &[v_21, v_18, v_12])?; seed[15] = v_22.as_canonical_u64(); match v_15.as_canonical_u64() { 63u64 => { let [v_23]: [G; 1] = context.returned::<1>(12)?; seed[16] = v_23.as_canonical_u64(); Ok(()) }, _ => { let [v_24]: [G; 1] = [G::from_u64(1)]; let [v_25]: [G; 1] = [v_15 + v_24]; let [v_27, v_28, v_29]: [G; 3] = context.load::<3>(16, v_19)?; seed[16] = v_27.as_canonical_u64(); seed[17] = v_28.as_canonical_u64(); seed[18] = v_29.as_canonical_u64(); match v_27.as_canonical_u64() { 1u64 => { let [v_30]: [G; 1] = context.returned::<1>(17)?; seed[19] = v_30.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_31]: [G; 1] = [G::from_u64(0)]; let [v_32]: [G; 1] = context.store(19, &[v_31, v_28, v_22])?; seed[19] = v_32.as_canonical_u64(); match v_25.as_canonical_u64() { 63u64 => { let [v_33]: [G; 1] = context.returned::<1>(20)?; seed[20] = v_33.as_canonical_u64(); Ok(()) }, _ => { let [v_34]: [G; 1] = [G::from_u64(1)]; let [v_35]: [G; 1] = [v_25 + v_34]; let [v_37, v_38, v_39]: [G; 3] = context.load::<3>(24, v_29)?; seed[20] = v_37.as_canonical_u64(); seed[21] = v_38.as_canonical_u64(); seed[22] = v_39.as_canonical_u64(); match v_37.as_canonical_u64() { 1u64 => { let [v_40]: [G; 1] = context.returned::<1>(25)?; seed[23] = v_40.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_41]: [G; 1] = [G::from_u64(0)]; let [v_42]: [G; 1] = context.store(27, &[v_41, v_38, v_32])?; seed[23] = v_42.as_canonical_u64(); match v_35.as_canonical_u64() { 63u64 => { let [v_43]: [G; 1] = context.returned::<1>(28)?; seed[24] = v_43.as_canonical_u64(); Ok(()) }, _ => { let [v_47]: [G; 1] = context.returned::<1>(32)?; seed[24] = v_47.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(26, v_37)) }, } }, } }, _ => { Err(no_match(26, v_27)) }, } }, } }, _ => { Err(no_match(26, v_17)) }, } }, } }, _ => { Err(no_match(26, v_7)) }, } } - -fn pack_26_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(157, v_7); seed.full(32, v_8); seed.u32(140, 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_14]: [G; 1] = [G::from_u64(1)]; let [v_15]: [G; 1] = [v_2 + v_14]; let [v_17, v_18, v_19]: [G; 3] = context.load::<3>(8, v_9)?; seed.full(48, v_17); seed.full(56, v_18); seed.u32(144, v_19); match v_17.as_canonical_u64() { 1u64 => { let [v_20]: [G; 1] = context.returned::<1>(9)?; seed.full(64, v_20); Ok(()) }, 0u64 => { let [v_21]: [G; 1] = [G::from_u64(0)]; let [v_22]: [G; 1] = context.store(11, &[v_21, v_18, v_12])?; seed.full(64, v_22); match v_15.as_canonical_u64() { 63u64 => { let [v_23]: [G; 1] = context.returned::<1>(12)?; seed.full(72, v_23); Ok(()) }, _ => { let [v_24]: [G; 1] = [G::from_u64(1)]; let [v_25]: [G; 1] = [v_15 + v_24]; let [v_27, v_28, v_29]: [G; 3] = context.load::<3>(16, v_19)?; seed.full(72, v_27); seed.full(80, v_28); seed.u32(148, v_29); match v_27.as_canonical_u64() { 1u64 => { let [v_30]: [G; 1] = context.returned::<1>(17)?; seed.full(88, v_30); Ok(()) }, 0u64 => { let [v_31]: [G; 1] = [G::from_u64(0)]; let [v_32]: [G; 1] = context.store(19, &[v_31, v_28, v_22])?; seed.full(88, v_32); match v_25.as_canonical_u64() { 63u64 => { let [v_33]: [G; 1] = context.returned::<1>(20)?; seed.full(96, v_33); Ok(()) }, _ => { let [v_34]: [G; 1] = [G::from_u64(1)]; let [v_35]: [G; 1] = [v_25 + v_34]; let [v_37, v_38, v_39]: [G; 3] = context.load::<3>(24, v_29)?; seed.full(96, v_37); seed.full(104, v_38); seed.u32(152, v_39); match v_37.as_canonical_u64() { 1u64 => { let [v_40]: [G; 1] = context.returned::<1>(25)?; seed.full(112, v_40); Ok(()) }, 0u64 => { let [v_41]: [G; 1] = [G::from_u64(0)]; let [v_42]: [G; 1] = context.store(27, &[v_41, v_38, v_32])?; seed.full(112, v_42); match v_35.as_canonical_u64() { 63u64 => { let [v_43]: [G; 1] = context.returned::<1>(28)?; seed.full(120, v_43); Ok(()) }, _ => { let [v_47]: [G; 1] = context.returned::<1>(32)?; seed.full(120, v_47); Ok(()) }, } }, _ => { Err(no_match(26, v_37)) }, } }, } }, _ => { Err(no_match(26, v_27)) }, } }, } }, _ => { Err(no_match(26, v_17)) }, } }, } }, _ => { Err(no_match(26, v_7)) }, } } - -fn write_26(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_14]: [G; 1] = [G::from_u64(1)]; let [v_15]: [G; 1] = [v_2 + v_14]; let [v_17, v_18, v_19]: [G; 3] = [G::from_u64(seed[12]), G::from_u64(seed[13]), G::from_u64(seed[14])]; 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(); match v_17.as_canonical_u64() { 1u64 => { let [v_20]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 9] = v_20.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_22]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 9] = v_22.as_canonical_u64(); match v_15.as_canonical_u64() { 63u64 => { let [v_23]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 10] = v_23.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 10] = (v_15 - G::from_u64(63)).inverse().as_canonical_u64(); let [v_24]: [G; 1] = [G::from_u64(1)]; let [v_25]: [G; 1] = [v_15 + v_24]; let [v_27, v_28, v_29]: [G; 3] = [G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18])]; row[offsets.auxiliaries + 11] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_29.as_canonical_u64(); match v_27.as_canonical_u64() { 1u64 => { let [v_30]: [G; 1] = [G::from_u64(seed[19])]; row[offsets.auxiliaries + 14] = v_30.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_32]: [G; 1] = [G::from_u64(seed[19])]; row[offsets.auxiliaries + 14] = v_32.as_canonical_u64(); match v_25.as_canonical_u64() { 63u64 => { let [v_33]: [G; 1] = [G::from_u64(seed[20])]; row[offsets.auxiliaries + 15] = v_33.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 15] = (v_25 - G::from_u64(63)).inverse().as_canonical_u64(); let [v_34]: [G; 1] = [G::from_u64(1)]; let [v_35]: [G; 1] = [v_25 + v_34]; let [v_37, v_38, v_39]: [G; 3] = [G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22])]; row[offsets.auxiliaries + 16] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_39.as_canonical_u64(); match v_37.as_canonical_u64() { 1u64 => { let [v_40]: [G; 1] = [G::from_u64(seed[23])]; row[offsets.auxiliaries + 19] = v_40.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_42]: [G; 1] = [G::from_u64(seed[23])]; row[offsets.auxiliaries + 19] = v_42.as_canonical_u64(); match v_35.as_canonical_u64() { 63u64 => { let [v_43]: [G; 1] = [G::from_u64(seed[24])]; row[offsets.auxiliaries + 20] = v_43.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 20] = (v_35 - G::from_u64(63)).inverse().as_canonical_u64(); let [v_47]: [G; 1] = [G::from_u64(seed[24])]; row[offsets.auxiliaries + 21] = v_47.as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(26, v_37)) }, } }, } }, _ => { Err(no_match(26, v_27)) }, } }, } }, _ => { Err(no_match(26, v_17)) }, } }, } }, _ => { Err(no_match(26, v_7)) }, } } - -static SCHEMA_26: 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, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 128, 8, 156, 16, 132, 136, 24, 157, 32, 140, 40, 48, 56, 144, 64, 72, 80, 148, 88, 96, 104, 152, 112, 120], bytes: 160 }; - -fn pack_30(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(30, v_187)) }, } }, _ => { Err(no_match(30, v_184)) }, } }, _ => { Err(no_match(30, v_181)) }, } }, _ => { Err(no_match(30, v_178)) }, } }, _ => { Err(no_match(30, v_175)) }, } }, _ => { Err(no_match(30, v_172)) }, } }, _ => { Err(no_match(30, v_169)) }, } }, _ => { Err(no_match(30, v_166)) }, } }, _ => { Err(no_match(30, v_163)) }, } }, _ => { Err(no_match(30, v_160)) }, } }, _ => { Err(no_match(30, v_157)) }, } }, _ => { Err(no_match(30, v_154)) }, } }, _ => { Err(no_match(30, v_151)) }, } }, _ => { Err(no_match(30, v_148)) }, } }, _ => { Err(no_match(30, v_145)) }, } }, _ => { Err(no_match(30, v_142)) }, } }, _ => { Err(no_match(30, v_139)) }, } }, _ => { Err(no_match(30, v_136)) }, } }, _ => { Err(no_match(30, v_133)) }, } }, _ => { Err(no_match(30, v_130)) }, } }, _ => { Err(no_match(30, v_127)) }, } }, _ => { Err(no_match(30, v_124)) }, } }, _ => { Err(no_match(30, v_121)) }, } }, _ => { Err(no_match(30, v_118)) }, } }, _ => { Err(no_match(30, v_115)) }, } }, _ => { Err(no_match(30, v_112)) }, } }, _ => { Err(no_match(30, v_109)) }, } }, _ => { Err(no_match(30, v_106)) }, } }, _ => { Err(no_match(30, v_103)) }, } }, _ => { Err(no_match(30, v_100)) }, } }, _ => { Err(no_match(30, v_97)) }, } }, _ => { Err(no_match(30, v_94)) }, } }, _ => { Err(no_match(30, v_91)) }, } }, _ => { Err(no_match(30, v_88)) }, } }, _ => { Err(no_match(30, v_85)) }, } }, _ => { Err(no_match(30, v_82)) }, } }, _ => { Err(no_match(30, v_79)) }, } }, _ => { Err(no_match(30, v_76)) }, } }, _ => { Err(no_match(30, v_73)) }, } }, _ => { Err(no_match(30, v_70)) }, } }, _ => { Err(no_match(30, v_67)) }, } }, _ => { Err(no_match(30, v_64)) }, } }, _ => { Err(no_match(30, v_61)) }, } }, _ => { Err(no_match(30, v_58)) }, } }, _ => { Err(no_match(30, v_55)) }, } }, _ => { Err(no_match(30, v_52)) }, } }, _ => { Err(no_match(30, v_49)) }, } }, _ => { Err(no_match(30, v_46)) }, } }, _ => { Err(no_match(30, v_43)) }, } }, _ => { Err(no_match(30, v_40)) }, } }, _ => { Err(no_match(30, v_37)) }, } }, _ => { Err(no_match(30, v_34)) }, } }, _ => { Err(no_match(30, v_31)) }, } }, _ => { Err(no_match(30, v_28)) }, } }, _ => { Err(no_match(30, v_25)) }, } }, _ => { Err(no_match(30, v_22)) }, } }, _ => { Err(no_match(30, v_19)) }, } }, _ => { Err(no_match(30, v_16)) }, } }, _ => { Err(no_match(30, v_13)) }, } }, _ => { Err(no_match(30, v_10)) }, } }, _ => { Err(no_match(30, v_7)) }, } }, _ => { Err(no_match(30, v_4)) }, } }, _ => { Err(no_match(30, v_1)) }, } } - -fn pack_30_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(30, v_187)) }, } }, _ => { Err(no_match(30, v_184)) }, } }, _ => { Err(no_match(30, v_181)) }, } }, _ => { Err(no_match(30, v_178)) }, } }, _ => { Err(no_match(30, v_175)) }, } }, _ => { Err(no_match(30, v_172)) }, } }, _ => { Err(no_match(30, v_169)) }, } }, _ => { Err(no_match(30, v_166)) }, } }, _ => { Err(no_match(30, v_163)) }, } }, _ => { Err(no_match(30, v_160)) }, } }, _ => { Err(no_match(30, v_157)) }, } }, _ => { Err(no_match(30, v_154)) }, } }, _ => { Err(no_match(30, v_151)) }, } }, _ => { Err(no_match(30, v_148)) }, } }, _ => { Err(no_match(30, v_145)) }, } }, _ => { Err(no_match(30, v_142)) }, } }, _ => { Err(no_match(30, v_139)) }, } }, _ => { Err(no_match(30, v_136)) }, } }, _ => { Err(no_match(30, v_133)) }, } }, _ => { Err(no_match(30, v_130)) }, } }, _ => { Err(no_match(30, v_127)) }, } }, _ => { Err(no_match(30, v_124)) }, } }, _ => { Err(no_match(30, v_121)) }, } }, _ => { Err(no_match(30, v_118)) }, } }, _ => { Err(no_match(30, v_115)) }, } }, _ => { Err(no_match(30, v_112)) }, } }, _ => { Err(no_match(30, v_109)) }, } }, _ => { Err(no_match(30, v_106)) }, } }, _ => { Err(no_match(30, v_103)) }, } }, _ => { Err(no_match(30, v_100)) }, } }, _ => { Err(no_match(30, v_97)) }, } }, _ => { Err(no_match(30, v_94)) }, } }, _ => { Err(no_match(30, v_91)) }, } }, _ => { Err(no_match(30, v_88)) }, } }, _ => { Err(no_match(30, v_85)) }, } }, _ => { Err(no_match(30, v_82)) }, } }, _ => { Err(no_match(30, v_79)) }, } }, _ => { Err(no_match(30, v_76)) }, } }, _ => { Err(no_match(30, v_73)) }, } }, _ => { Err(no_match(30, v_70)) }, } }, _ => { Err(no_match(30, v_67)) }, } }, _ => { Err(no_match(30, v_64)) }, } }, _ => { Err(no_match(30, v_61)) }, } }, _ => { Err(no_match(30, v_58)) }, } }, _ => { Err(no_match(30, v_55)) }, } }, _ => { Err(no_match(30, v_52)) }, } }, _ => { Err(no_match(30, v_49)) }, } }, _ => { Err(no_match(30, v_46)) }, } }, _ => { Err(no_match(30, v_43)) }, } }, _ => { Err(no_match(30, v_40)) }, } }, _ => { Err(no_match(30, v_37)) }, } }, _ => { Err(no_match(30, v_34)) }, } }, _ => { Err(no_match(30, v_31)) }, } }, _ => { Err(no_match(30, v_28)) }, } }, _ => { Err(no_match(30, v_25)) }, } }, _ => { Err(no_match(30, v_22)) }, } }, _ => { Err(no_match(30, v_19)) }, } }, _ => { Err(no_match(30, v_16)) }, } }, _ => { Err(no_match(30, v_13)) }, } }, _ => { Err(no_match(30, v_10)) }, } }, _ => { Err(no_match(30, v_7)) }, } }, _ => { Err(no_match(30, v_4)) }, } }, _ => { Err(no_match(30, v_1)) }, } } - -fn write_30(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(30, v_190)) }, } }, _ => { Err(no_match(30, v_187)) }, } }, _ => { Err(no_match(30, v_184)) }, } }, _ => { Err(no_match(30, v_181)) }, } }, _ => { Err(no_match(30, v_178)) }, } }, _ => { Err(no_match(30, v_175)) }, } }, _ => { Err(no_match(30, v_172)) }, } }, _ => { Err(no_match(30, v_169)) }, } }, _ => { Err(no_match(30, v_166)) }, } }, _ => { Err(no_match(30, v_163)) }, } }, _ => { Err(no_match(30, v_160)) }, } }, _ => { Err(no_match(30, v_157)) }, } }, _ => { Err(no_match(30, v_154)) }, } }, _ => { Err(no_match(30, v_151)) }, } }, _ => { Err(no_match(30, v_148)) }, } }, _ => { Err(no_match(30, v_145)) }, } }, _ => { Err(no_match(30, v_142)) }, } }, _ => { Err(no_match(30, v_139)) }, } }, _ => { Err(no_match(30, v_136)) }, } }, _ => { Err(no_match(30, v_133)) }, } }, _ => { Err(no_match(30, v_130)) }, } }, _ => { Err(no_match(30, v_127)) }, } }, _ => { Err(no_match(30, v_124)) }, } }, _ => { Err(no_match(30, v_121)) }, } }, _ => { Err(no_match(30, v_118)) }, } }, _ => { Err(no_match(30, v_115)) }, } }, _ => { Err(no_match(30, v_112)) }, } }, _ => { Err(no_match(30, v_109)) }, } }, _ => { Err(no_match(30, v_106)) }, } }, _ => { Err(no_match(30, v_103)) }, } }, _ => { Err(no_match(30, v_100)) }, } }, _ => { Err(no_match(30, v_97)) }, } }, _ => { Err(no_match(30, v_94)) }, } }, _ => { Err(no_match(30, v_91)) }, } }, _ => { Err(no_match(30, v_88)) }, } }, _ => { Err(no_match(30, v_85)) }, } }, _ => { Err(no_match(30, v_82)) }, } }, _ => { Err(no_match(30, v_79)) }, } }, _ => { Err(no_match(30, v_76)) }, } }, _ => { Err(no_match(30, v_73)) }, } }, _ => { Err(no_match(30, v_70)) }, } }, _ => { Err(no_match(30, v_67)) }, } }, _ => { Err(no_match(30, v_64)) }, } }, _ => { Err(no_match(30, v_61)) }, } }, _ => { Err(no_match(30, v_58)) }, } }, _ => { Err(no_match(30, v_55)) }, } }, _ => { Err(no_match(30, v_52)) }, } }, _ => { Err(no_match(30, v_49)) }, } }, _ => { Err(no_match(30, v_46)) }, } }, _ => { Err(no_match(30, v_43)) }, } }, _ => { Err(no_match(30, v_40)) }, } }, _ => { Err(no_match(30, v_37)) }, } }, _ => { Err(no_match(30, v_34)) }, } }, _ => { Err(no_match(30, v_31)) }, } }, _ => { Err(no_match(30, v_28)) }, } }, _ => { Err(no_match(30, v_25)) }, } }, _ => { Err(no_match(30, v_22)) }, } }, _ => { Err(no_match(30, v_19)) }, } }, _ => { Err(no_match(30, v_16)) }, } }, _ => { Err(no_match(30, v_13)) }, } }, _ => { Err(no_match(30, v_10)) }, } }, _ => { Err(no_match(30, v_7)) }, } }, _ => { Err(no_match(30, v_4)) }, } }, _ => { Err(no_match(30, v_1)) }, } } - -static SCHEMA_30: 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_33(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, 30, &[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, 773, &[v_0])?; seed[71] = v_73.as_canonical_u64(); let [v_74]: [G; 1] = [v_8 * v_73]; let [v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82]: [G; 8] = context.load::<8>(6, v_3)?; seed[72] = v_75.as_canonical_u64(); seed[73] = v_76.as_canonical_u64(); seed[74] = v_77.as_canonical_u64(); seed[75] = v_78.as_canonical_u64(); seed[76] = v_79.as_canonical_u64(); seed[77] = v_80.as_canonical_u64(); seed[78] = v_81.as_canonical_u64(); seed[79] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = context.call::<1>(7, 6, &[v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82])?; seed[80] = v_83.as_canonical_u64(); let [v_84]: [G; 1] = [v_74 * 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, 37, &[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_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, 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, 16, &[v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82])?; 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, 773, &[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, 773, &[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, 6, &[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_199 * v_208]; let [v_210]: [G; 1] = [v_209 * v_8]; 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_198 + v_210]; let [v_216]: [G; 1] = [v_215 + v_214]; 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, 37, &[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_33_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, 30, &[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, 773, &[v_0])?; seed.u8(192, v_73); let [v_74]: [G; 1] = [v_8 * v_73]; let [v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82]: [G; 8] = context.load::<8>(6, v_3)?; seed.u8(193, v_75); seed.u8(194, v_76); seed.u8(195, v_77); seed.u8(196, v_78); seed.u8(197, v_79); seed.u8(198, v_80); seed.u8(199, v_81); seed.u8(200, v_82); let [v_83]: [G; 1] = context.call::<1>(7, 6, &[v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82])?; seed.u8(201, v_83); let [v_84]: [G; 1] = [v_74 * 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, 37, &[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_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, 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, 16, &[v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82])?; 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, 773, &[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, 773, &[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, 6, &[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_199 * v_208]; let [v_210]: [G; 1] = [v_209 * v_8]; 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_198 + v_210]; let [v_216]: [G; 1] = [v_215 + v_214]; 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, 37, &[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 write_33(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]: [G; 1] = [v_8 * v_73]; let [v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82]: [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_75.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = [G::from_u64(seed[80])]; row[offsets.auxiliaries + 74] = v_83.as_canonical_u64(); let [v_84]: [G; 1] = [v_74 * v_83]; row[offsets.auxiliaries + 75] = v_84.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_199 * v_208]; row[offsets.auxiliaries + 77] = v_209.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_33: 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_37(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_37_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 write_37(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] = [v_165 * v_167]; row[offsets.auxiliaries + 6] = v_168.as_canonical_u64(); let [v_169]: [G; 1] = [G::from_u64(2)]; let [v_170]: [G; 1] = [v_165 - v_169]; let [v_171]: [G; 1] = [v_168 * 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_200]; row[offsets.auxiliaries + 29] = v_201.as_canonical_u64(); let [v_202]: [G; 1] = [v_199 - v_169]; let [v_203]: [G; 1] = [v_201 * 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_231]; row[offsets.auxiliaries + 52] = v_232.as_canonical_u64(); let [v_233]: [G; 1] = [v_230 - v_169]; let [v_234]: [G; 1] = [v_232 * 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_262]; row[offsets.auxiliaries + 75] = v_263.as_canonical_u64(); let [v_264]: [G; 1] = [v_261 - v_169]; let [v_265]: [G; 1] = [v_263 * 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_293]; row[offsets.auxiliaries + 98] = v_294.as_canonical_u64(); let [v_295]: [G; 1] = [v_292 - v_169]; let [v_296]: [G; 1] = [v_294 * 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_324]; row[offsets.auxiliaries + 121] = v_325.as_canonical_u64(); let [v_326]: [G; 1] = [v_323 - v_169]; let [v_327]: [G; 1] = [v_325 * 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_355]; row[offsets.auxiliaries + 144] = v_356.as_canonical_u64(); let [v_357]: [G; 1] = [v_354 - v_169]; let [v_358]: [G; 1] = [v_356 * 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_386]; row[offsets.auxiliaries + 167] = v_387.as_canonical_u64(); let [v_388]: [G; 1] = [v_385 - v_169]; let [v_389]: [G; 1] = [v_387 * 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_417]; row[offsets.auxiliaries + 190] = v_418.as_canonical_u64(); let [v_419]: [G; 1] = [v_416 - v_169]; let [v_420]: [G; 1] = [v_418 * 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_448]; row[offsets.auxiliaries + 213] = v_449.as_canonical_u64(); let [v_450]: [G; 1] = [v_447 - v_169]; let [v_451]: [G; 1] = [v_449 * 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_479]; row[offsets.auxiliaries + 236] = v_480.as_canonical_u64(); let [v_481]: [G; 1] = [v_478 - v_169]; let [v_482]: [G; 1] = [v_480 * 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_510]; row[offsets.auxiliaries + 259] = v_511.as_canonical_u64(); let [v_512]: [G; 1] = [v_509 - v_169]; let [v_513]: [G; 1] = [v_511 * 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_541]; row[offsets.auxiliaries + 282] = v_542.as_canonical_u64(); let [v_543]: [G; 1] = [v_540 - v_169]; let [v_544]: [G; 1] = [v_542 * 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_572]; row[offsets.auxiliaries + 305] = v_573.as_canonical_u64(); let [v_574]: [G; 1] = [v_571 - v_169]; let [v_575]: [G; 1] = [v_573 * 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_603]; row[offsets.auxiliaries + 328] = v_604.as_canonical_u64(); let [v_605]: [G; 1] = [v_602 - v_169]; let [v_606]: [G; 1] = [v_604 * 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_634]; row[offsets.auxiliaries + 351] = v_635.as_canonical_u64(); let [v_636]: [G; 1] = [v_633 - v_169]; let [v_637]: [G; 1] = [v_635 * 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_37: 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_41(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] = [v_2 + v_3]; let [v_11]: [G; 1] = [v_10 + v_4]; let [v_12]: [G; 1] = [v_11 + v_5]; let [v_13]: [G; 1] = [v_12 + v_6]; let [v_14]: [G; 1] = [v_13 + v_7]; let [v_15]: [G; 1] = [v_14 + v_8]; match v_15.as_canonical_u64() { 0u64 => { let [v_16]: [G; 1] = [G::from_u64(32)]; let [v_17]: [G; 1] = [Bytes2::less_than(&v_1, &v_16)]; match v_17.as_canonical_u64() { 1u64 => { let [v_18]: [G; 1] = [G::from_u64(0)]; let [v_19]: [G; 1] = [G::from_u64(64)]; let [v_20]: [G; 1] = [v_19 * v_0]; let [v_21]: [G; 1] = [v_20 + v_1]; let [v_22]: [G; 1] = context.store(12, &[v_18, v_21, v_9])?; seed[11] = v_22.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_26]: [G; 1] = context.returned::<1>(16)?; seed[11] = v_26.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(41, v_17)) }, } }, _ => { let [v_30]: [G; 1] = context.returned::<1>(20)?; seed[11] = v_30.as_canonical_u64(); Ok(()) }, } } - -fn pack_41_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] = [v_2 + v_3]; let [v_11]: [G; 1] = [v_10 + v_4]; let [v_12]: [G; 1] = [v_11 + v_5]; let [v_13]: [G; 1] = [v_12 + v_6]; let [v_14]: [G; 1] = [v_13 + v_7]; let [v_15]: [G; 1] = [v_14 + v_8]; match v_15.as_canonical_u64() { 0u64 => { let [v_16]: [G; 1] = [G::from_u64(32)]; let [v_17]: [G; 1] = [Bytes2::less_than(&v_1, &v_16)]; match v_17.as_canonical_u64() { 1u64 => { let [v_18]: [G; 1] = [G::from_u64(0)]; let [v_19]: [G; 1] = [G::from_u64(64)]; let [v_20]: [G; 1] = [v_19 * v_0]; let [v_21]: [G; 1] = [v_20 + v_1]; let [v_22]: [G; 1] = context.store(12, &[v_18, v_21, v_9])?; seed.u32(24, v_22); Ok(()) }, 0u64 => { let [v_26]: [G; 1] = context.returned::<1>(16)?; seed.u32(24, v_26); Ok(()) }, _ => { Err(no_match(41, v_17)) }, } }, _ => { let [v_30]: [G; 1] = context.returned::<1>(20)?; seed.u32(24, v_30); Ok(()) }, } } - -fn write_41(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] = [v_2 + v_3]; let [v_11]: [G; 1] = [v_10 + v_4]; let [v_12]: [G; 1] = [v_11 + v_5]; let [v_13]: [G; 1] = [v_12 + v_6]; let [v_14]: [G; 1] = [v_13 + v_7]; let [v_15]: [G; 1] = [v_14 + v_8]; match v_15.as_canonical_u64() { 0u64 => { let [v_16]: [G; 1] = [G::from_u64(32)]; let [v_17]: [G; 1] = [Bytes2::less_than(&v_1, &v_16)]; row[offsets.auxiliaries + 1] = v_17.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { let [v_22]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 2] = v_22.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_26]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 2] = v_26.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(41, v_17)) }, } }, _ => { row[offsets.auxiliaries + 1] = (v_15 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_30]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 2] = v_30.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, } } - -static SCHEMA_41: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 8, 28, 29, 30, 31, 32, 33, 34, 35, 16, 24], bytes: 40 }; - -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]; 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]: [G; 1] = [G::from_u64(256)]; let [v_12]: [G; 1] = [G::from_u64(2)]; let [v_13]: [G; 1] = [v_12 * v_1]; let [v_14]: [G; 1] = [v_11 - v_13]; let [v_15]: [G; 1] = [G::from_u64(255)]; let [v_16]: [G; 1] = [v_15 - v_1]; let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25]: [G; 9] = context.call::<9>(6, 15, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_14, v_16, v_15, v_15, v_15, v_15, v_15, v_15])?; seed[12] = v_17.as_canonical_u64(); seed[13] = v_18.as_canonical_u64(); seed[14] = v_19.as_canonical_u64(); seed[15] = v_20.as_canonical_u64(); seed[16] = v_21.as_canonical_u64(); seed[17] = v_22.as_canonical_u64(); seed[18] = v_23.as_canonical_u64(); seed[19] = v_24.as_canonical_u64(); seed[20] = v_25.as_canonical_u64(); match v_25.as_canonical_u64() { 0u64 => { let [v_26]: [G; 1] = [G::from_u64(256)]; let [v_27]: [G; 1] = [G::from_u64(2)]; let [v_28]: [G; 1] = [v_27 * v_1]; let [v_29]: [G; 1] = [v_26 - v_28]; let op_11 = Bytes2::add(&v_2, &v_29); let [v_30, v_31]: [G; 2] = [op_11.0, op_11.1]; let [v_32]: [G; 1] = [v_3 + v_31]; let [v_33]: [G; 1] = [G::from_u64(1)]; let [v_34]: [G; 1] = [v_32 - v_33]; let [v_35]: [G; 1] = [G::from_u64(0)]; let [v_36]: [G; 1] = [v_0 + v_28]; let [v_37]: [G; 1] = [v_36 + v_34]; let [v_38]: [G; 1] = context.store(18, &[v_35, v_30, v_10])?; seed[21] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = context.store(19, &[v_35, v_37, v_38])?; seed[22] = v_39.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_44]: [G; 1] = context.returned::<1>(24)?; seed[21] = v_44.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(43, v_25)) }, } } - -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]; 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]: [G; 1] = [G::from_u64(256)]; let [v_12]: [G; 1] = [G::from_u64(2)]; let [v_13]: [G; 1] = [v_12 * v_1]; let [v_14]: [G; 1] = [v_11 - v_13]; let [v_15]: [G; 1] = [G::from_u64(255)]; let [v_16]: [G; 1] = [v_15 - v_1]; let [v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25]: [G; 9] = context.call::<9>(6, 15, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_14, v_16, v_15, v_15, v_15, v_15, v_15, v_15])?; seed.u8(48, v_17); seed.u8(49, v_18); seed.u8(50, v_19); seed.u8(51, v_20); seed.u8(52, v_21); seed.u8(53, v_22); seed.u8(54, v_23); seed.u8(55, v_24); seed.u8(56, v_25); match v_25.as_canonical_u64() { 0u64 => { let [v_26]: [G; 1] = [G::from_u64(256)]; let [v_27]: [G; 1] = [G::from_u64(2)]; let [v_28]: [G; 1] = [v_27 * v_1]; let [v_29]: [G; 1] = [v_26 - v_28]; let op_11 = Bytes2::add(&v_2, &v_29); let [v_30, v_31]: [G; 2] = [op_11.0, op_11.1]; let [v_32]: [G; 1] = [v_3 + v_31]; let [v_33]: [G; 1] = [G::from_u64(1)]; let [v_34]: [G; 1] = [v_32 - v_33]; let [v_35]: [G; 1] = [G::from_u64(0)]; let [v_36]: [G; 1] = [v_0 + v_28]; let [v_37]: [G; 1] = [v_36 + v_34]; let [v_38]: [G; 1] = context.store(18, &[v_35, v_30, v_10])?; seed.u32(32, v_38); let [v_39]: [G; 1] = context.store(19, &[v_35, v_37, v_38])?; seed.u32(36, v_39); Ok(()) }, 1u64 => { let [v_44]: [G; 1] = context.returned::<1>(24)?; seed.u32(32, v_44); Ok(()) }, _ => { Err(no_match(43, v_25)) }, } } - -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]); 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_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25]: [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 + 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(); match v_25.as_canonical_u64() { 0u64 => { let [v_26]: [G; 1] = [G::from_u64(256)]; let [v_27]: [G; 1] = [G::from_u64(2)]; let [v_28]: [G; 1] = [v_27 * v_1]; let [v_29]: [G; 1] = [v_26 - v_28]; let op_11 = Bytes2::add(&v_2, &v_29); let [v_30, v_31]: [G; 2] = [op_11.0, op_11.1]; row[offsets.auxiliaries + 10] = v_30.as_canonical_u64(); let [v_38]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 11] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = [G::from_u64(seed[22])]; row[offsets.auxiliaries + 12] = v_39.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_44]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 10] = v_44.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(43, v_25)) }, } } - -static SCHEMA_43: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 8, 16, 40, 41, 42, 43, 44, 45, 46, 47, 24, 48, 49, 50, 51, 52, 53, 54, 55, 56, 32, 36], bytes: 64 }; - -fn pack_44(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]; match v_1.as_canonical_u64() { 0u64 => { let [v_11]: [G; 1] = [v_4 + v_5]; let [v_12]: [G; 1] = [v_11 + v_6]; let [v_13]: [G; 1] = [v_12 + v_7]; let [v_14]: [G; 1] = [v_13 + v_8]; let [v_15]: [G; 1] = [v_14 + v_9]; match v_15.as_canonical_u64() { 0u64 => { let [v_16]: [G; 1] = [G::from_u64(0)]; let [v_17]: [G; 1] = [G::from_u64(2)]; let [v_18]: [G; 1] = context.call::<1>(7, 39, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_17, v_10])?; seed[12] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = context.store(8, &[v_16, v_0, v_18])?; seed[13] = v_19.as_canonical_u64(); Ok(()) }, _ => { let [v_20]: [G; 1] = [G::from_u64(0)]; let [v_21]: [G; 1] = [G::from_u64(255)]; let [v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 9] = context.call::<9>(11, 15, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_20, v_20, v_21, v_21, v_21, v_21, v_21, v_21])?; seed[12] = v_22.as_canonical_u64(); seed[13] = v_23.as_canonical_u64(); seed[14] = v_24.as_canonical_u64(); seed[15] = v_25.as_canonical_u64(); seed[16] = v_26.as_canonical_u64(); seed[17] = v_27.as_canonical_u64(); seed[18] = v_28.as_canonical_u64(); seed[19] = v_29.as_canonical_u64(); seed[20] = v_30.as_canonical_u64(); let [v_32]: [G; 1] = context.returned::<1>(13)?; seed[21] = v_32.as_canonical_u64(); Ok(()) }, } }, 1u64 => { let [v_33]: [G; 1] = [v_5 + v_6]; let [v_34]: [G; 1] = [v_33 + v_7]; let [v_35]: [G; 1] = [v_34 + v_8]; let [v_36]: [G; 1] = [v_35 + v_9]; match v_36.as_canonical_u64() { 0u64 => { let [v_37]: [G; 1] = [G::from_u64(0)]; let [v_38]: [G; 1] = [G::from_u64(1)]; let [v_39]: [G; 1] = [v_0 + v_38]; let [v_40]: [G; 1] = [G::from_u64(3)]; let [v_41]: [G; 1] = context.call::<1>(22, 39, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_40, v_10])?; seed[12] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = context.store(23, &[v_37, v_39, v_41])?; seed[13] = v_42.as_canonical_u64(); Ok(()) }, _ => { let [v_43]: [G; 1] = [G::from_u64(0)]; let [v_44]: [G; 1] = [G::from_u64(255)]; let [v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53]: [G; 9] = context.call::<9>(26, 15, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_43, v_43, v_43, v_44, v_44, v_44, v_44, v_44])?; seed[12] = v_45.as_canonical_u64(); seed[13] = v_46.as_canonical_u64(); seed[14] = v_47.as_canonical_u64(); seed[15] = v_48.as_canonical_u64(); seed[16] = v_49.as_canonical_u64(); seed[17] = v_50.as_canonical_u64(); seed[18] = v_51.as_canonical_u64(); seed[19] = v_52.as_canonical_u64(); seed[20] = v_53.as_canonical_u64(); let [v_55]: [G; 1] = context.returned::<1>(28)?; seed[21] = v_55.as_canonical_u64(); Ok(()) }, } }, 2u64 => { let [v_56]: [G; 1] = [v_6 + v_7]; let [v_57]: [G; 1] = [v_56 + v_8]; let [v_58]: [G; 1] = [v_57 + v_9]; match v_58.as_canonical_u64() { 0u64 => { let [v_59]: [G; 1] = [G::from_u64(0)]; let [v_60]: [G; 1] = [G::from_u64(2)]; let [v_61]: [G; 1] = [v_0 + v_60]; let [v_62]: [G; 1] = [G::from_u64(4)]; let [v_63]: [G; 1] = context.call::<1>(36, 39, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_62, v_10])?; seed[12] = v_63.as_canonical_u64(); let [v_64]: [G; 1] = context.store(37, &[v_59, v_61, v_63])?; seed[13] = v_64.as_canonical_u64(); Ok(()) }, _ => { let [v_65]: [G; 1] = [G::from_u64(0)]; let [v_66]: [G; 1] = [G::from_u64(255)]; let [v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75]: [G; 9] = context.call::<9>(40, 15, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_65, v_65, v_65, v_65, v_66, v_66, v_66, v_66])?; seed[12] = v_67.as_canonical_u64(); seed[13] = v_68.as_canonical_u64(); seed[14] = v_69.as_canonical_u64(); seed[15] = v_70.as_canonical_u64(); seed[16] = v_71.as_canonical_u64(); seed[17] = v_72.as_canonical_u64(); seed[18] = v_73.as_canonical_u64(); seed[19] = v_74.as_canonical_u64(); seed[20] = v_75.as_canonical_u64(); let [v_77]: [G; 1] = context.returned::<1>(42)?; seed[21] = v_77.as_canonical_u64(); Ok(()) }, } }, 3u64 => { let [v_78]: [G; 1] = [G::from_u64(0)]; let [v_79]: [G; 1] = [G::from_u64(3)]; let [v_80]: [G; 1] = [v_0 + v_79]; let [v_81]: [G; 1] = [G::from_u64(8)]; let [v_82]: [G; 1] = context.call::<1>(47, 39, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_81, v_10])?; seed[12] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = context.store(48, &[v_78, v_80, v_82])?; seed[13] = v_83.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(44, v_1)) }, } } - -fn pack_44_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]; match v_1.as_canonical_u64() { 0u64 => { let [v_11]: [G; 1] = [v_4 + v_5]; let [v_12]: [G; 1] = [v_11 + v_6]; let [v_13]: [G; 1] = [v_12 + v_7]; let [v_14]: [G; 1] = [v_13 + v_8]; let [v_15]: [G; 1] = [v_14 + v_9]; match v_15.as_canonical_u64() { 0u64 => { let [v_16]: [G; 1] = [G::from_u64(0)]; let [v_17]: [G; 1] = [G::from_u64(2)]; let [v_18]: [G; 1] = context.call::<1>(7, 39, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_17, v_10])?; seed.full(24, v_18); let [v_19]: [G; 1] = context.store(8, &[v_16, v_0, v_18])?; seed.u32(32, v_19); Ok(()) }, _ => { let [v_20]: [G; 1] = [G::from_u64(0)]; let [v_21]: [G; 1] = [G::from_u64(255)]; let [v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 9] = context.call::<9>(11, 15, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_20, v_20, v_21, v_21, v_21, v_21, v_21, v_21])?; seed.full(24, v_22); seed.u32(32, v_23); seed.u8(49, v_24); seed.u8(50, v_25); seed.u8(51, v_26); seed.u8(52, v_27); seed.u8(53, v_28); seed.u8(54, v_29); seed.u8(55, v_30); let [v_32]: [G; 1] = context.returned::<1>(13)?; seed.u32(36, v_32); Ok(()) }, } }, 1u64 => { let [v_33]: [G; 1] = [v_5 + v_6]; let [v_34]: [G; 1] = [v_33 + v_7]; let [v_35]: [G; 1] = [v_34 + v_8]; let [v_36]: [G; 1] = [v_35 + v_9]; match v_36.as_canonical_u64() { 0u64 => { let [v_37]: [G; 1] = [G::from_u64(0)]; let [v_38]: [G; 1] = [G::from_u64(1)]; let [v_39]: [G; 1] = [v_0 + v_38]; let [v_40]: [G; 1] = [G::from_u64(3)]; let [v_41]: [G; 1] = context.call::<1>(22, 39, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_40, v_10])?; seed.full(24, v_41); let [v_42]: [G; 1] = context.store(23, &[v_37, v_39, v_41])?; seed.u32(32, v_42); Ok(()) }, _ => { let [v_43]: [G; 1] = [G::from_u64(0)]; let [v_44]: [G; 1] = [G::from_u64(255)]; let [v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53]: [G; 9] = context.call::<9>(26, 15, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_43, v_43, v_43, v_44, v_44, v_44, v_44, v_44])?; seed.full(24, v_45); seed.u32(32, v_46); seed.u8(49, v_47); seed.u8(50, v_48); seed.u8(51, v_49); seed.u8(52, v_50); seed.u8(53, v_51); seed.u8(54, v_52); seed.u8(55, v_53); let [v_55]: [G; 1] = context.returned::<1>(28)?; seed.u32(36, v_55); Ok(()) }, } }, 2u64 => { let [v_56]: [G; 1] = [v_6 + v_7]; let [v_57]: [G; 1] = [v_56 + v_8]; let [v_58]: [G; 1] = [v_57 + v_9]; match v_58.as_canonical_u64() { 0u64 => { let [v_59]: [G; 1] = [G::from_u64(0)]; let [v_60]: [G; 1] = [G::from_u64(2)]; let [v_61]: [G; 1] = [v_0 + v_60]; let [v_62]: [G; 1] = [G::from_u64(4)]; let [v_63]: [G; 1] = context.call::<1>(36, 39, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_62, v_10])?; seed.full(24, v_63); let [v_64]: [G; 1] = context.store(37, &[v_59, v_61, v_63])?; seed.u32(32, v_64); Ok(()) }, _ => { let [v_65]: [G; 1] = [G::from_u64(0)]; let [v_66]: [G; 1] = [G::from_u64(255)]; let [v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75]: [G; 9] = context.call::<9>(40, 15, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_65, v_65, v_65, v_65, v_66, v_66, v_66, v_66])?; seed.full(24, v_67); seed.u32(32, v_68); seed.u8(49, v_69); seed.u8(50, v_70); seed.u8(51, v_71); seed.u8(52, v_72); seed.u8(53, v_73); seed.u8(54, v_74); seed.u8(55, v_75); let [v_77]: [G; 1] = context.returned::<1>(42)?; seed.u32(36, v_77); Ok(()) }, } }, 3u64 => { let [v_78]: [G; 1] = [G::from_u64(0)]; let [v_79]: [G; 1] = [G::from_u64(3)]; let [v_80]: [G; 1] = [v_0 + v_79]; let [v_81]: [G; 1] = [G::from_u64(8)]; let [v_82]: [G; 1] = context.call::<1>(47, 39, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_81, v_10])?; seed.full(24, v_82); let [v_83]: [G; 1] = context.store(48, &[v_78, v_80, v_82])?; seed.u32(32, v_83); Ok(()) }, _ => { Err(no_match(44, v_1)) }, } } - -fn write_44(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]); match v_1.as_canonical_u64() { 0u64 => { let [v_11]: [G; 1] = [v_4 + v_5]; let [v_12]: [G; 1] = [v_11 + v_6]; let [v_13]: [G; 1] = [v_12 + v_7]; let [v_14]: [G; 1] = [v_13 + v_8]; let [v_15]: [G; 1] = [v_14 + v_9]; match v_15.as_canonical_u64() { 0u64 => { let [v_18]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 1] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 2] = v_19.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 1] = (v_15 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [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 + 2] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_30.as_canonical_u64(); let [v_32]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 11] = v_32.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, } }, 1u64 => { let [v_33]: [G; 1] = [v_5 + v_6]; let [v_34]: [G; 1] = [v_33 + v_7]; let [v_35]: [G; 1] = [v_34 + v_8]; let [v_36]: [G; 1] = [v_35 + v_9]; match v_36.as_canonical_u64() { 0u64 => { let [v_41]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 1] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 2] = v_42.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 1] = (v_36 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53]: [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 + 2] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_53.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 11] = v_55.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, } }, 2u64 => { let [v_56]: [G; 1] = [v_6 + v_7]; let [v_57]: [G; 1] = [v_56 + v_8]; let [v_58]: [G; 1] = [v_57 + v_9]; match v_58.as_canonical_u64() { 0u64 => { let [v_63]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 1] = v_63.as_canonical_u64(); let [v_64]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 2] = v_64.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 1] = (v_58 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75]: [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 + 2] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_75.as_canonical_u64(); let [v_77]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 11] = v_77.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, } }, 3u64 => { let [v_82]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 1] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 2] = v_83.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(44, v_1)) }, } } - -static SCHEMA_44: 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::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32], offsets: &[0, 8, 40, 41, 42, 43, 44, 45, 46, 47, 48, 16, 24, 32, 49, 50, 51, 52, 53, 54, 55, 36], bytes: 56 }; - -fn pack_47(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(47, v_0)); }, } }; let [v_9]: [G; 1] = context.call::<1>(5, 46, &[v_1, v_2])?; seed[4] = v_9.as_canonical_u64(); Ok(()) }, } } - -fn pack_47_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(47, v_0)); }, } }; let [v_9]: [G; 1] = context.call::<1>(5, 46, &[v_1, v_2])?; seed.u8(11, v_9); Ok(()) }, } } - -fn write_47(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(47, 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_47: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 9, 10, 11], bytes: 16 }; - -fn pack_50(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]; match v_0.as_canonical_u64() { 7u64 => { let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 18] = context.load::<18>(0, v_1)?; 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(); 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(); let [v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 8] = context.call::<8>(1, 50, &[v_18, v_19, v_20, v_21, v_22, v_23, 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[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(); let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 8] = context.returned::<8>(2)?; 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(); Ok(()) }, _ => { Ok(()) }, } } - -fn pack_50_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]; match v_0.as_canonical_u64() { 7u64 => { let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 18] = context.load::<18>(0, v_1)?; seed.u8(348, v_18); seed.u32(340, v_19); seed.full(144, v_20); seed.u8(349, v_21); seed.full(152, v_22); seed.full(160, v_23); seed.full(168, v_24); seed.full(176, v_25); seed.full(184, v_26); seed.u32(344, v_27); seed.full(192, v_28); seed.u8(350, v_29); seed.u8(351, v_30); seed.u8(352, v_31); seed.u8(353, v_32); seed.u8(354, v_33); seed.u8(355, v_34); seed.full(200, v_35); let [v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 8] = context.call::<8>(1, 50, &[v_18, v_19, v_20, v_21, v_22, v_23, 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.full(208, v_36); seed.full(216, v_37); seed.full(224, v_38); seed.full(232, v_39); seed.full(240, v_40); seed.full(248, v_41); seed.full(256, v_42); seed.full(264, v_43); let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 8] = context.returned::<8>(2)?; seed.full(272, v_44); seed.full(280, v_45); seed.full(288, v_46); seed.full(296, v_47); seed.full(304, v_48); seed.full(312, v_49); seed.full(320, v_50); seed.full(328, v_51); Ok(()) }, _ => { Ok(()) }, } } - -fn write_50(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]); match v_0.as_canonical_u64() { 7u64 => { let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 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])]; row[offsets.auxiliaries + 1] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_35.as_canonical_u64(); let [v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 8] = [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])]; row[offsets.auxiliaries + 19] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_43.as_canonical_u64(); let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 8] = [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_44.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_51.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(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_50: 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::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, 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::Full], offsets: &[0, 8, 336, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 348, 340, 144, 349, 152, 160, 168, 176, 184, 344, 192, 350, 351, 352, 353, 354, 355, 200, 208, 216, 224, 232, 240, 248, 256, 264, 272, 280, 288, 296, 304, 312, 320, 328], bytes: 360 }; - -fn pack_51(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]; match v_0.as_canonical_u64() { 8u64 => { let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 18] = context.load::<18>(0, v_5)?; 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(); 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(); let [v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 8] = context.call::<8>(1, 51, &[v_18, v_19, v_20, v_21, v_22, v_23, 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[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(); let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 8] = context.returned::<8>(2)?; 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(); Ok(()) }, _ => { Ok(()) }, } } - -fn pack_51_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]; match v_0.as_canonical_u64() { 8u64 => { let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 18] = context.load::<18>(0, v_5)?; seed.u8(348, v_18); seed.full(144, v_19); seed.full(152, v_20); seed.u8(349, v_21); seed.full(160, v_22); seed.u32(340, v_23); seed.full(168, v_24); seed.full(176, v_25); seed.full(184, v_26); seed.u32(344, v_27); seed.full(192, v_28); seed.u8(350, v_29); seed.u8(351, v_30); seed.u8(352, v_31); seed.u8(353, v_32); seed.u8(354, v_33); seed.u8(355, v_34); seed.full(200, v_35); let [v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 8] = context.call::<8>(1, 51, &[v_18, v_19, v_20, v_21, v_22, v_23, 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.full(208, v_36); seed.full(216, v_37); seed.full(224, v_38); seed.full(232, v_39); seed.full(240, v_40); seed.full(248, v_41); seed.full(256, v_42); seed.full(264, v_43); let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 8] = context.returned::<8>(2)?; seed.full(272, v_44); seed.full(280, v_45); seed.full(288, v_46); seed.full(296, v_47); seed.full(304, v_48); seed.full(312, v_49); seed.full(320, v_50); seed.full(328, v_51); Ok(()) }, _ => { Ok(()) }, } } - -fn write_51(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]); match v_0.as_canonical_u64() { 8u64 => { let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 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])]; row[offsets.auxiliaries + 1] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_35.as_canonical_u64(); let [v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 8] = [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])]; row[offsets.auxiliaries + 19] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_43.as_canonical_u64(); let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 8] = [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_44.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_51.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(8)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_51: SeedSchema = SeedSchema { widths: &[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::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, 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::Full], offsets: &[0, 8, 16, 24, 32, 40, 336, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 348, 144, 152, 349, 160, 340, 168, 176, 184, 344, 192, 350, 351, 352, 353, 354, 355, 200, 208, 216, 224, 232, 240, 248, 256, 264, 272, 280, 288, 296, 304, 312, 320, 328], bytes: 360 }; - -fn pack_52(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]; match v_0.as_canonical_u64() { 9u64 => { let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 18] = context.load::<18>(0, v_7)?; 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(); 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(); let [v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 8] = context.call::<8>(1, 52, &[v_18, v_19, v_20, v_21, v_22, v_23, 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[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(); let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 8] = context.returned::<8>(2)?; 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(); Ok(()) }, _ => { Ok(()) }, } } - -fn pack_52_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]; match v_0.as_canonical_u64() { 9u64 => { let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 18] = context.load::<18>(0, v_7)?; seed.u8(348, v_18); seed.full(144, v_19); seed.full(152, v_20); seed.u8(349, v_21); seed.full(160, v_22); seed.full(168, v_23); seed.full(176, v_24); seed.u32(340, v_25); seed.full(184, v_26); seed.u32(344, v_27); seed.full(192, v_28); seed.u8(350, v_29); seed.u8(351, v_30); seed.u8(352, v_31); seed.u8(353, v_32); seed.u8(354, v_33); seed.u8(355, v_34); seed.full(200, v_35); let [v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 8] = context.call::<8>(1, 52, &[v_18, v_19, v_20, v_21, v_22, v_23, 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.full(208, v_36); seed.full(216, v_37); seed.full(224, v_38); seed.full(232, v_39); seed.full(240, v_40); seed.full(248, v_41); seed.full(256, v_42); seed.full(264, v_43); let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 8] = context.returned::<8>(2)?; seed.full(272, v_44); seed.full(280, v_45); seed.full(288, v_46); seed.full(296, v_47); seed.full(304, v_48); seed.full(312, v_49); seed.full(320, v_50); seed.full(328, v_51); Ok(()) }, _ => { Ok(()) }, } } - -fn write_52(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]); match v_0.as_canonical_u64() { 9u64 => { let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 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])]; row[offsets.auxiliaries + 1] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_35.as_canonical_u64(); let [v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43]: [G; 8] = [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])]; row[offsets.auxiliaries + 19] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_43.as_canonical_u64(); let [v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51]: [G; 8] = [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_44.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_51.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(9)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_52: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, 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::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, 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::Full], offsets: &[0, 8, 16, 24, 32, 40, 48, 56, 336, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 348, 144, 152, 349, 160, 168, 176, 340, 184, 344, 192, 350, 351, 352, 353, 354, 355, 200, 208, 216, 224, 232, 240, 248, 256, 264, 272, 280, 288, 296, 304, 312, 320, 328], bytes: 360 }; - -fn pack_53(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]; match v_0.as_canonical_u64() { 7u64 => { 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]: [G; 18] = context.load::<18>(0, v_1)?; 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(); 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(); let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54]: [G; 18] = context.load::<18>(1, v_2)?; 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(); let [v_55]: [G; 1] = context.call::<1>(2, 38, &[v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_18])?; seed[56] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = context.returned::<1>(3)?; seed[57] = v_56.as_canonical_u64(); Ok(()) }, _ => { let [v_57]: [G; 1] = context.returned::<1>(4)?; seed[20] = v_57.as_canonical_u64(); Ok(()) }, } } - -fn pack_53_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]; match v_0.as_canonical_u64() { 7u64 => { 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]: [G; 18] = context.load::<18>(0, v_1)?; seed.u32(20, v_19); seed.u8(57, v_20); seed.u8(58, v_21); seed.u8(59, v_22); seed.u8(60, v_23); seed.u8(61, v_24); seed.u8(62, v_25); seed.u8(63, v_26); seed.u8(64, v_27); seed.u8(65, v_28); seed.u8(66, v_29); seed.u8(67, v_30); seed.u8(68, v_31); seed.u8(69, v_32); seed.u8(70, v_33); seed.u8(71, v_34); seed.u8(72, v_35); seed.u32(24, v_36); let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54]: [G; 18] = context.load::<18>(1, v_2)?; seed.u8(73, v_37); seed.u8(74, v_38); seed.u8(75, v_39); seed.u8(76, v_40); seed.u8(77, v_41); seed.u8(78, v_42); seed.u8(79, v_43); seed.u8(80, v_44); seed.u8(81, v_45); seed.u8(82, v_46); seed.u8(83, v_47); seed.u8(84, v_48); seed.u8(85, v_49); seed.u8(86, v_50); seed.u8(87, v_51); seed.u8(88, v_52); seed.u8(89, v_53); seed.u32(28, v_54); let [v_55]: [G; 1] = context.call::<1>(2, 38, &[v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_18])?; seed.u32(32, v_55); let [v_56]: [G; 1] = context.returned::<1>(3)?; seed.u32(36, v_56); Ok(()) }, _ => { let [v_57]: [G; 1] = context.returned::<1>(4)?; seed.u32(20, v_57); Ok(()) }, } } - -fn write_53(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]); match v_0.as_canonical_u64() { 7u64 => { 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]: [G; 18] = [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])]; row[offsets.auxiliaries + 1] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_36.as_canonical_u64(); let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54]: [G; 18] = [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])]; row[offsets.auxiliaries + 19] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(seed[56])]; row[offsets.auxiliaries + 37] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[57])]; row[offsets.auxiliaries + 38] = v_56.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_57]: [G; 1] = [G::from_u64(seed[20])]; row[offsets.auxiliaries + 2] = v_57.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_53: 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::U8, SeedWidth::U32, 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::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::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 16, 8, 20, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 24, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 28, 32, 36], bytes: 96 }; - -fn pack_54(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]; match v_0.as_canonical_u64() { 8u64 => { 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]: [G; 18] = context.load::<18>(0, v_4)?; 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(); 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(); let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54]: [G; 18] = context.load::<18>(1, v_5)?; 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(); let [v_55]: [G; 1] = context.call::<1>(2, 54, &[v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_18])?; seed[56] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = context.call::<1>(3, 38, &[v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_55])?; seed[57] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = context.returned::<1>(4)?; seed[58] = v_57.as_canonical_u64(); Ok(()) }, _ => { let [v_58]: [G; 1] = context.returned::<1>(5)?; seed[20] = v_58.as_canonical_u64(); Ok(()) }, } } - -fn pack_54_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]; match v_0.as_canonical_u64() { 8u64 => { 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]: [G; 18] = context.load::<18>(0, v_4)?; seed.u32(20, v_19); seed.u8(61, v_20); seed.u8(62, v_21); seed.u8(63, v_22); seed.u8(64, v_23); seed.u8(65, v_24); seed.u8(66, v_25); seed.u8(67, v_26); seed.u8(68, v_27); seed.u8(69, v_28); seed.u8(70, v_29); seed.u8(71, v_30); seed.u8(72, v_31); seed.u8(73, v_32); seed.u8(74, v_33); seed.u8(75, v_34); seed.u8(76, v_35); seed.u32(24, v_36); let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54]: [G; 18] = context.load::<18>(1, v_5)?; seed.u8(77, v_37); seed.u8(78, v_38); seed.u8(79, v_39); seed.u8(80, v_40); seed.u8(81, v_41); seed.u8(82, v_42); seed.u8(83, v_43); seed.u8(84, v_44); seed.u8(85, v_45); seed.u8(86, v_46); seed.u8(87, v_47); seed.u8(88, v_48); seed.u8(89, v_49); seed.u8(90, v_50); seed.u8(91, v_51); seed.u8(92, v_52); seed.u8(93, v_53); seed.u32(28, v_54); let [v_55]: [G; 1] = context.call::<1>(2, 54, &[v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_18])?; seed.u32(32, v_55); let [v_56]: [G; 1] = context.call::<1>(3, 38, &[v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_55])?; seed.u32(36, v_56); let [v_57]: [G; 1] = context.returned::<1>(4)?; seed.u32(40, v_57); Ok(()) }, _ => { let [v_58]: [G; 1] = context.returned::<1>(5)?; seed.u32(20, v_58); Ok(()) }, } } - -fn write_54(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]); match v_0.as_canonical_u64() { 8u64 => { 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]: [G; 18] = [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])]; row[offsets.auxiliaries + 1] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_36.as_canonical_u64(); let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54]: [G; 18] = [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])]; row[offsets.auxiliaries + 19] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(seed[56])]; row[offsets.auxiliaries + 37] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[57])]; row[offsets.auxiliaries + 38] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = [G::from_u64(seed[58])]; row[offsets.auxiliaries + 39] = v_57.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(8)).inverse().as_canonical_u64(); let [v_58]: [G; 1] = [G::from_u64(seed[20])]; row[offsets.auxiliaries + 2] = v_58.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_54: 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::U8, SeedWidth::U32, 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::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::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 16, 8, 20, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 24, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 28, 32, 36, 40], bytes: 96 }; - -fn pack_55(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]; match v_0.as_canonical_u64() { 9u64 => { 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]: [G; 18] = context.load::<18>(0, v_6)?; 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(); 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(); let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54]: [G; 18] = context.load::<18>(1, v_7)?; 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(); let [v_55]: [G; 1] = context.call::<1>(2, 55, &[v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_18])?; seed[56] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = context.call::<1>(3, 38, &[v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_55])?; seed[57] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = context.returned::<1>(4)?; seed[58] = v_57.as_canonical_u64(); Ok(()) }, _ => { let [v_58]: [G; 1] = context.returned::<1>(5)?; seed[20] = v_58.as_canonical_u64(); Ok(()) }, } } - -fn pack_55_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]; match v_0.as_canonical_u64() { 9u64 => { 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]: [G; 18] = context.load::<18>(0, v_6)?; seed.u32(20, v_19); seed.u8(61, v_20); seed.u8(62, v_21); seed.u8(63, v_22); seed.u8(64, v_23); seed.u8(65, v_24); seed.u8(66, v_25); seed.u8(67, v_26); seed.u8(68, v_27); seed.u8(69, v_28); seed.u8(70, v_29); seed.u8(71, v_30); seed.u8(72, v_31); seed.u8(73, v_32); seed.u8(74, v_33); seed.u8(75, v_34); seed.u8(76, v_35); seed.u32(24, v_36); let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54]: [G; 18] = context.load::<18>(1, v_7)?; seed.u8(77, v_37); seed.u8(78, v_38); seed.u8(79, v_39); seed.u8(80, v_40); seed.u8(81, v_41); seed.u8(82, v_42); seed.u8(83, v_43); seed.u8(84, v_44); seed.u8(85, v_45); seed.u8(86, v_46); seed.u8(87, v_47); seed.u8(88, v_48); seed.u8(89, v_49); seed.u8(90, v_50); seed.u8(91, v_51); seed.u8(92, v_52); seed.u8(93, v_53); seed.u32(28, v_54); let [v_55]: [G; 1] = context.call::<1>(2, 55, &[v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_18])?; seed.u32(32, v_55); let [v_56]: [G; 1] = context.call::<1>(3, 38, &[v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_55])?; seed.u32(36, v_56); let [v_57]: [G; 1] = context.returned::<1>(4)?; seed.u32(40, v_57); Ok(()) }, _ => { let [v_58]: [G; 1] = context.returned::<1>(5)?; seed.u32(20, v_58); Ok(()) }, } } - -fn write_55(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]); match v_0.as_canonical_u64() { 9u64 => { 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]: [G; 18] = [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])]; row[offsets.auxiliaries + 1] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_36.as_canonical_u64(); let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54]: [G; 18] = [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])]; row[offsets.auxiliaries + 19] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(seed[56])]; row[offsets.auxiliaries + 37] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[57])]; row[offsets.auxiliaries + 38] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = [G::from_u64(seed[58])]; row[offsets.auxiliaries + 39] = v_57.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(9)).inverse().as_canonical_u64(); let [v_58]: [G; 1] = [G::from_u64(seed[20])]; row[offsets.auxiliaries + 2] = v_58.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_55: 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::U8, SeedWidth::U32, 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::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::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 16, 8, 20, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 24, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 28, 32, 36, 40], bytes: 96 }; - -fn pack_58(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]; match v_0.as_canonical_u64() { 1u64 => { let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17]: [G; 9] = context.load::<9>(0, v_1)?; 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(); seed[18] = v_17.as_canonical_u64(); let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25]: [G; 8] = context.call::<8>(1, 58, &[v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17])?; 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(); let [v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33]: [G; 8] = context.returned::<8>(2)?; 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(); Ok(()) }, _ => { Ok(()) }, } } - -fn pack_58_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]; match v_0.as_canonical_u64() { 1u64 => { let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17]: [G; 9] = context.load::<9>(0, v_1)?; seed.full(72, v_9); seed.u32(268, v_10); seed.full(80, v_11); seed.full(88, v_12); seed.full(96, v_13); seed.full(104, v_14); seed.full(112, v_15); seed.full(120, v_16); seed.full(128, v_17); let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25]: [G; 8] = context.call::<8>(1, 58, &[v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17])?; seed.full(136, v_18); seed.full(144, v_19); seed.full(152, v_20); seed.full(160, v_21); seed.full(168, v_22); seed.full(176, v_23); seed.full(184, v_24); seed.full(192, v_25); let [v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33]: [G; 8] = context.returned::<8>(2)?; seed.full(200, v_26); seed.full(208, v_27); seed.full(216, v_28); seed.full(224, v_29); seed.full(232, v_30); seed.full(240, v_31); seed.full(248, v_32); seed.full(256, v_33); Ok(()) }, _ => { Ok(()) }, } } - -fn write_58(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]); match v_0.as_canonical_u64() { 1u64 => { let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17]: [G; 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])]; 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(); let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25]: [G; 8] = [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])]; 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(); let [v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33]: [G; 8] = [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])]; 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.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_58: 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::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, 8, 264, 16, 24, 32, 40, 48, 56, 64, 72, 268, 80, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192, 200, 208, 216, 224, 232, 240, 248, 256], bytes: 272 }; - -fn pack_59(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]; match v_0.as_canonical_u64() { 1u64 => { let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17]: [G; 9] = context.load::<9>(0, v_1)?; 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(); seed[18] = v_17.as_canonical_u64(); let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26]: [G; 9] = context.returned::<9>(1)?; 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(); Ok(()) }, _ => { Ok(()) }, } } - -fn pack_59_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]; match v_0.as_canonical_u64() { 1u64 => { let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17]: [G; 9] = context.load::<9>(0, v_1)?; seed.full(72, v_9); seed.u32(212, v_10); seed.full(80, v_11); seed.full(88, v_12); seed.full(96, v_13); seed.full(104, v_14); seed.full(112, v_15); seed.full(120, v_16); seed.full(128, v_17); let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26]: [G; 9] = context.returned::<9>(1)?; seed.full(136, v_18); seed.full(144, v_19); seed.full(152, v_20); seed.full(160, v_21); seed.full(168, v_22); seed.full(176, v_23); seed.full(184, v_24); seed.full(192, v_25); seed.full(200, v_26); Ok(()) }, _ => { Ok(()) }, } } - -fn write_59(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]); match v_0.as_canonical_u64() { 1u64 => { let [v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17]: [G; 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])]; 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(); let [v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26]: [G; 9] = [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 + 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.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_59: 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::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], offsets: &[0, 8, 208, 16, 24, 32, 40, 48, 56, 64, 72, 212, 80, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192, 200], bytes: 216 }; - -fn pack_60(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]; match v_0.as_canonical_u64() { 0u64 => { let [v_10]: [G; 1] = [G::from_u64(0)]; let [v_11]: [G; 1] = context.store(1, &[v_10, v_10, v_9])?; seed[11] = v_11.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19]: [G; 8] = context.call::<8>(2, 58, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed[11] = v_12.as_canonical_u64(); seed[12] = v_13.as_canonical_u64(); 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(); let [v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 9] = context.call::<9>(3, 59, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; 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(); seed[23] = v_24.as_canonical_u64(); 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(); let [v_30]: [G; 1] = context.call::<1>(5, 60, &[v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_9])?; seed[28] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = context.returned::<1>(6)?; seed[29] = v_31.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40]: [G; 9] = context.load::<9>(7, v_1)?; seed[11] = v_32.as_canonical_u64(); seed[12] = v_33.as_canonical_u64(); seed[13] = v_34.as_canonical_u64(); seed[14] = v_35.as_canonical_u64(); seed[15] = v_36.as_canonical_u64(); seed[16] = v_37.as_canonical_u64(); seed[17] = v_38.as_canonical_u64(); seed[18] = v_39.as_canonical_u64(); seed[19] = v_40.as_canonical_u64(); let [v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49]: [G; 9] = context.load::<9>(8, v_2)?; seed[20] = v_41.as_canonical_u64(); seed[21] = v_42.as_canonical_u64(); seed[22] = v_43.as_canonical_u64(); seed[23] = v_44.as_canonical_u64(); seed[24] = v_45.as_canonical_u64(); seed[25] = v_46.as_canonical_u64(); seed[26] = v_47.as_canonical_u64(); seed[27] = v_48.as_canonical_u64(); seed[28] = v_49.as_canonical_u64(); let [v_52]: [G; 1] = context.call::<1>(11, 60, &[v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_9])?; seed[29] = v_52.as_canonical_u64(); let [v_53]: [G; 1] = context.call::<1>(12, 60, &[v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_52])?; seed[30] = v_53.as_canonical_u64(); let [v_54]: [G; 1] = context.returned::<1>(13)?; seed[31] = v_54.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63]: [G; 9] = context.load::<9>(14, v_1)?; seed[11] = v_55.as_canonical_u64(); seed[12] = v_56.as_canonical_u64(); seed[13] = v_57.as_canonical_u64(); seed[14] = v_58.as_canonical_u64(); seed[15] = v_59.as_canonical_u64(); seed[16] = v_60.as_canonical_u64(); seed[17] = v_61.as_canonical_u64(); seed[18] = v_62.as_canonical_u64(); seed[19] = v_63.as_canonical_u64(); let [v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 9] = context.load::<9>(15, v_2)?; seed[20] = v_64.as_canonical_u64(); seed[21] = v_65.as_canonical_u64(); seed[22] = v_66.as_canonical_u64(); seed[23] = v_67.as_canonical_u64(); seed[24] = v_68.as_canonical_u64(); seed[25] = v_69.as_canonical_u64(); seed[26] = v_70.as_canonical_u64(); seed[27] = v_71.as_canonical_u64(); seed[28] = v_72.as_canonical_u64(); let [v_75]: [G; 1] = context.call::<1>(18, 60, &[v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_9])?; seed[29] = v_75.as_canonical_u64(); let [v_76]: [G; 1] = context.call::<1>(19, 60, &[v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_75])?; seed[30] = v_76.as_canonical_u64(); let [v_77]: [G; 1] = context.returned::<1>(20)?; seed[31] = v_77.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_79]: [G; 1] = context.returned::<1>(22)?; seed[11] = v_79.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(60, v_0)) }, } } - -fn pack_60_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]; match v_0.as_canonical_u64() { 0u64 => { let [v_10]: [G; 1] = [G::from_u64(0)]; let [v_11]: [G; 1] = context.store(1, &[v_10, v_10, v_9])?; seed.u32(16, v_11); Ok(()) }, 1u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19]: [G; 8] = context.call::<8>(2, 58, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed.u32(16, v_12); seed.u8(45, v_13); seed.u8(46, v_14); seed.u8(47, v_15); seed.u8(48, v_16); seed.u8(49, v_17); seed.u8(50, v_18); seed.u8(51, v_19); let [v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 9] = context.call::<9>(3, 59, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed.u8(52, v_20); seed.u8(53, v_21); seed.u8(54, v_22); seed.u8(55, v_23); seed.u8(56, v_24); seed.u8(57, v_25); seed.u8(58, v_26); seed.u8(59, v_27); seed.u8(60, v_28); let [v_30]: [G; 1] = context.call::<1>(5, 60, &[v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_9])?; seed.u32(20, v_30); let [v_31]: [G; 1] = context.returned::<1>(6)?; seed.u32(24, v_31); Ok(()) }, 2u64 => { let [v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40]: [G; 9] = context.load::<9>(7, v_1)?; seed.u32(16, v_32); seed.u8(45, v_33); seed.u8(46, v_34); seed.u8(47, v_35); seed.u8(48, v_36); seed.u8(49, v_37); seed.u8(50, v_38); seed.u8(51, v_39); seed.u8(52, v_40); let [v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49]: [G; 9] = context.load::<9>(8, v_2)?; seed.u8(53, v_41); seed.u8(54, v_42); seed.u8(55, v_43); seed.u8(56, v_44); seed.u8(57, v_45); seed.u8(58, v_46); seed.u8(59, v_47); seed.u8(60, v_48); seed.u32(20, v_49); let [v_52]: [G; 1] = context.call::<1>(11, 60, &[v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_9])?; seed.u32(24, v_52); let [v_53]: [G; 1] = context.call::<1>(12, 60, &[v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_52])?; seed.u32(28, v_53); let [v_54]: [G; 1] = context.returned::<1>(13)?; seed.u32(32, v_54); Ok(()) }, 3u64 => { let [v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63]: [G; 9] = context.load::<9>(14, v_1)?; seed.u32(16, v_55); seed.u8(45, v_56); seed.u8(46, v_57); seed.u8(47, v_58); seed.u8(48, v_59); seed.u8(49, v_60); seed.u8(50, v_61); seed.u8(51, v_62); seed.u8(52, v_63); let [v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 9] = context.load::<9>(15, v_2)?; seed.u8(53, v_64); seed.u8(54, v_65); seed.u8(55, v_66); seed.u8(56, v_67); seed.u8(57, v_68); seed.u8(58, v_69); seed.u8(59, v_70); seed.u8(60, v_71); seed.u32(20, v_72); let [v_75]: [G; 1] = context.call::<1>(18, 60, &[v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_9])?; seed.u32(24, v_75); let [v_76]: [G; 1] = context.call::<1>(19, 60, &[v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_75])?; seed.u32(28, v_76); let [v_77]: [G; 1] = context.returned::<1>(20)?; seed.u32(32, v_77); Ok(()) }, 4u64 => { let [v_79]: [G; 1] = context.returned::<1>(22)?; seed.u32(16, v_79); Ok(()) }, _ => { Err(no_match(60, v_0)) }, } } - -fn write_60(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]); match v_0.as_canonical_u64() { 0u64 => { let [v_11]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 1] = v_11.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19]: [G; 8] = [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])]; 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(); 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(); let [v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 9] = [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 + 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(); row[offsets.auxiliaries + 13] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_28.as_canonical_u64(); let [v_30]: [G; 1] = [G::from_u64(seed[28])]; row[offsets.auxiliaries + 18] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(seed[29])]; row[offsets.auxiliaries + 19] = v_31.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40]: [G; 9] = [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])]; row[offsets.auxiliaries + 1] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_40.as_canonical_u64(); let [v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49]: [G; 9] = [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 + 10] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_49.as_canonical_u64(); let [v_52]: [G; 1] = [G::from_u64(seed[29])]; row[offsets.auxiliaries + 19] = v_52.as_canonical_u64(); let [v_53]: [G; 1] = [G::from_u64(seed[30])]; row[offsets.auxiliaries + 20] = v_53.as_canonical_u64(); let [v_54]: [G; 1] = [G::from_u64(seed[31])]; row[offsets.auxiliaries + 21] = v_54.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63]: [G; 9] = [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])]; row[offsets.auxiliaries + 1] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_63.as_canonical_u64(); let [v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 9] = [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 + 10] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_72.as_canonical_u64(); let [v_75]: [G; 1] = [G::from_u64(seed[29])]; row[offsets.auxiliaries + 19] = v_75.as_canonical_u64(); let [v_76]: [G; 1] = [G::from_u64(seed[30])]; row[offsets.auxiliaries + 20] = v_76.as_canonical_u64(); let [v_77]: [G; 1] = [G::from_u64(seed[31])]; row[offsets.auxiliaries + 21] = v_77.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_79]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 1] = v_79.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(60, v_0)) }, } } - -static SCHEMA_60: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, 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::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 36, 37, 38, 39, 40, 41, 42, 43, 44, 8, 16, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 20, 24, 28, 32], bytes: 64 }; - -fn pack_65(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]; match v_0.as_canonical_u64() { _ => { let [v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 18] = context.load::<18>(0, v_10)?; 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(); 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(); 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(); let [v_31, v_32, v_33, v_34, v_35, 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]: [G; 18] = context.load::<18>(1, v_11)?; 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(); let [v_49]: [G; 1] = context.call::<1>(2, 57, &[v_0, v_1])?; seed[50] = v_49.as_canonical_u64(); let [v_50]: [G; 1] = [G::from_u64(0)]; let [v_51]: [G; 1] = context.call::<1>(4, 38, &[v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_12])?; seed[51] = v_51.as_canonical_u64(); let [v_52]: [G; 1] = context.call::<1>(5, 38, &[v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_51])?; seed[52] = v_52.as_canonical_u64(); let [v_53]: [G; 1] = context.call::<1>(6, 42, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_52])?; seed[53] = v_53.as_canonical_u64(); let [v_54]: [G; 1] = context.store(7, &[v_50, v_49, v_53])?; seed[54] = v_54.as_canonical_u64(); Ok(()) }, } } - -fn pack_65_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]; match v_0.as_canonical_u64() { _ => { let [v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 18] = context.load::<18>(0, v_10)?; seed.u8(58, v_13); seed.u8(59, v_14); seed.u8(60, v_15); seed.u8(61, v_16); seed.u8(62, v_17); seed.u8(63, v_18); seed.u8(64, v_19); seed.u8(65, v_20); seed.u8(66, v_21); seed.u8(67, v_22); seed.u8(68, v_23); seed.u8(69, v_24); seed.u8(70, v_25); seed.u8(71, v_26); seed.u8(72, v_27); seed.u8(73, v_28); seed.u8(74, v_29); seed.u32(24, v_30); let [v_31, v_32, v_33, v_34, v_35, 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]: [G; 18] = context.load::<18>(1, v_11)?; seed.u8(75, v_31); seed.u8(76, v_32); seed.u8(77, v_33); seed.u8(78, v_34); seed.u8(79, v_35); seed.u8(80, v_36); seed.u8(81, v_37); seed.u8(82, v_38); seed.u8(83, v_39); seed.u8(84, v_40); seed.u8(85, v_41); seed.u8(86, v_42); seed.u8(87, v_43); seed.u8(88, v_44); seed.u8(89, v_45); seed.u8(90, v_46); seed.u8(91, v_47); seed.u32(28, v_48); let [v_49]: [G; 1] = context.call::<1>(2, 57, &[v_0, v_1])?; seed.u8(92, v_49); let [v_50]: [G; 1] = [G::from_u64(0)]; let [v_51]: [G; 1] = context.call::<1>(4, 38, &[v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_12])?; seed.u32(32, v_51); let [v_52]: [G; 1] = context.call::<1>(5, 38, &[v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_51])?; seed.u32(36, v_52); let [v_53]: [G; 1] = context.call::<1>(6, 42, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_52])?; seed.u32(40, v_53); let [v_54]: [G; 1] = context.store(7, &[v_50, v_49, v_53])?; seed.u32(44, v_54); Ok(()) }, } } - -fn write_65(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]); match v_0.as_canonical_u64() { _ => { let [v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 18] = [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])]; row[offsets.auxiliaries + 1] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_16.as_canonical_u64(); 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(); row[offsets.auxiliaries + 9] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_25.as_canonical_u64(); 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(); row[offsets.auxiliaries + 18] = v_30.as_canonical_u64(); let [v_31, v_32, v_33, v_34, v_35, 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]: [G; 18] = [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])]; row[offsets.auxiliaries + 19] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_48.as_canonical_u64(); let [v_49]: [G; 1] = [G::from_u64(seed[50])]; row[offsets.auxiliaries + 37] = v_49.as_canonical_u64(); let [v_51]: [G; 1] = [G::from_u64(seed[51])]; row[offsets.auxiliaries + 38] = v_51.as_canonical_u64(); let [v_52]: [G; 1] = [G::from_u64(seed[52])]; row[offsets.auxiliaries + 39] = v_52.as_canonical_u64(); let [v_53]: [G; 1] = [G::from_u64(seed[53])]; row[offsets.auxiliaries + 40] = v_53.as_canonical_u64(); let [v_54]: [G; 1] = [G::from_u64(seed[54])]; row[offsets.auxiliaries + 41] = v_54.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_65: 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::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::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::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 16, 20, 8, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 24, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 28, 92, 32, 36, 40, 44], bytes: 96 }; - -fn pack_66(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]; match v_0.as_canonical_u64() { _ => { let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27]: [G; 18] = context.load::<18>(0, v_8)?; 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(); 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(); seed[28] = v_27.as_canonical_u64(); let [v_28]: [G; 1] = context.call::<1>(1, 38, &[v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_9])?; seed[29] = v_28.as_canonical_u64(); let [v_29]: [G; 1] = context.returned::<1>(2)?; seed[30] = v_29.as_canonical_u64(); Ok(()) }, } } - -fn pack_66_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]; match v_0.as_canonical_u64() { _ => { let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27]: [G; 18] = context.load::<18>(0, v_8)?; seed.u8(40, v_10); seed.u8(41, v_11); seed.u8(42, v_12); seed.u8(43, v_13); seed.u8(44, v_14); seed.u8(45, v_15); seed.u8(46, v_16); seed.u8(47, v_17); seed.u8(48, v_18); seed.u8(49, v_19); seed.u8(50, v_20); seed.u8(51, v_21); seed.u8(52, v_22); seed.u8(53, v_23); seed.u8(54, v_24); seed.u8(55, v_25); seed.u8(56, v_26); seed.u32(20, v_27); let [v_28]: [G; 1] = context.call::<1>(1, 38, &[v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_9])?; seed.u32(24, v_28); let [v_29]: [G; 1] = context.returned::<1>(2)?; seed.u32(28, v_29); Ok(()) }, } } - -fn write_66(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]); match v_0.as_canonical_u64() { _ => { let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27]: [G; 18] = [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])]; row[offsets.auxiliaries + 1] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_19.as_canonical_u64(); 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(); row[offsets.auxiliaries + 15] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_27.as_canonical_u64(); let [v_28]: [G; 1] = [G::from_u64(seed[29])]; row[offsets.auxiliaries + 19] = v_28.as_canonical_u64(); let [v_29]: [G; 1] = [G::from_u64(seed[30])]; row[offsets.auxiliaries + 20] = v_29.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_66: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, 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::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 32, 33, 34, 35, 36, 37, 38, 39, 16, 8, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 20, 24, 28], bytes: 64 }; - -fn pack_69(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]; match v_0.as_canonical_u64() { _ => { let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 18] = context.load::<18>(0, v_9)?; 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(); 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(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); let [v_29]: [G; 1] = [G::from_u64(0)]; let [v_30]: [G; 1] = context.call::<1>(2, 38, &[v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_10])?; seed[30] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = context.call::<1>(3, 42, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_30])?; seed[31] = v_31.as_canonical_u64(); let [v_32]: [G; 1] = context.store(4, &[v_29, v_0, v_31])?; seed[32] = v_32.as_canonical_u64(); Ok(()) }, } } - -fn pack_69_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]; match v_0.as_canonical_u64() { _ => { let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 18] = context.load::<18>(0, v_9)?; seed.u8(52, v_11); seed.u8(53, v_12); seed.u8(54, v_13); seed.u8(55, v_14); seed.u8(56, v_15); seed.u8(57, v_16); seed.u8(58, v_17); seed.u8(59, v_18); seed.u8(60, v_19); seed.u8(61, v_20); seed.u8(62, v_21); seed.u8(63, v_22); seed.u8(64, v_23); seed.u8(65, v_24); seed.u8(66, v_25); seed.u8(67, v_26); seed.u8(68, v_27); seed.u32(28, v_28); let [v_29]: [G; 1] = [G::from_u64(0)]; let [v_30]: [G; 1] = context.call::<1>(2, 38, &[v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_10])?; seed.u32(32, v_30); let [v_31]: [G; 1] = context.call::<1>(3, 42, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_30])?; seed.u32(36, v_31); let [v_32]: [G; 1] = context.store(4, &[v_29, v_0, v_31])?; seed.u32(40, v_32); Ok(()) }, } } - -fn write_69(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]); match v_0.as_canonical_u64() { _ => { let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 18] = [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])]; row[offsets.auxiliaries + 1] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_13.as_canonical_u64(); 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(); 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(); let [v_30]: [G; 1] = [G::from_u64(seed[30])]; row[offsets.auxiliaries + 19] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(seed[31])]; row[offsets.auxiliaries + 20] = v_31.as_canonical_u64(); let [v_32]: [G; 1] = [G::from_u64(seed[32])]; row[offsets.auxiliaries + 21] = v_32.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_69: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, 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::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 8, 44, 45, 46, 47, 48, 49, 50, 51, 24, 16, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 28, 32, 36, 40], bytes: 72 }; - -fn pack_70(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]; match v_0.as_canonical_u64() { _ => { let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 18] = context.load::<18>(0, v_9)?; 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(); 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(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); let [v_29]: [G; 1] = context.call::<1>(1, 38, &[v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_10])?; seed[30] = v_29.as_canonical_u64(); let [v_30]: [G; 1] = context.call::<1>(2, 42, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_29])?; seed[31] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = context.returned::<1>(3)?; seed[32] = v_31.as_canonical_u64(); Ok(()) }, } } - -fn pack_70_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]; match v_0.as_canonical_u64() { _ => { let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 18] = context.load::<18>(0, v_9)?; seed.u8(45, v_11); seed.u8(46, v_12); seed.u8(47, v_13); seed.u8(48, v_14); seed.u8(49, v_15); seed.u8(50, v_16); seed.u8(51, v_17); seed.u8(52, v_18); seed.u8(53, v_19); seed.u8(54, v_20); seed.u8(55, v_21); seed.u8(56, v_22); seed.u8(57, v_23); seed.u8(58, v_24); seed.u8(59, v_25); seed.u8(60, v_26); seed.u8(61, v_27); seed.u32(20, v_28); let [v_29]: [G; 1] = context.call::<1>(1, 38, &[v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_10])?; seed.u32(24, v_29); let [v_30]: [G; 1] = context.call::<1>(2, 42, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_29])?; seed.u32(28, v_30); let [v_31]: [G; 1] = context.returned::<1>(3)?; seed.u32(32, v_31); Ok(()) }, } } - -fn write_70(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]); match v_0.as_canonical_u64() { _ => { let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 18] = [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])]; row[offsets.auxiliaries + 1] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_13.as_canonical_u64(); 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(); 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(); let [v_29]: [G; 1] = [G::from_u64(seed[30])]; row[offsets.auxiliaries + 19] = v_29.as_canonical_u64(); let [v_30]: [G; 1] = [G::from_u64(seed[31])]; row[offsets.auxiliaries + 20] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(seed[32])]; row[offsets.auxiliaries + 21] = v_31.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_70: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, 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::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 36, 37, 38, 39, 40, 41, 42, 43, 44, 16, 8, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 20, 24, 28, 32], bytes: 64 }; - -fn pack_71(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]; match v_0.as_canonical_u64() { _ => { let [v_35, 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]: [G; 18] = context.load::<18>(0, v_33)?; 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(); let [v_53]: [G; 1] = [G::from_u64(0)]; let [v_54]: [G; 1] = context.call::<1>(2, 38, &[v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_34])?; seed[54] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = context.call::<1>(3, 42, &[v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_54])?; seed[55] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = context.call::<1>(4, 42, &[v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_55])?; seed[56] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = context.call::<1>(5, 42, &[v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_56])?; seed[57] = v_57.as_canonical_u64(); let [v_58]: [G; 1] = context.call::<1>(6, 42, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_57])?; seed[58] = v_58.as_canonical_u64(); let [v_59]: [G; 1] = context.store(7, &[v_53, v_0, v_58])?; seed[59] = v_59.as_canonical_u64(); Ok(()) }, } } - -fn pack_71_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]; match v_0.as_canonical_u64() { _ => { let [v_35, 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]: [G; 18] = context.load::<18>(0, v_33)?; seed.u8(88, v_35); seed.u8(89, v_36); seed.u8(90, v_37); seed.u8(91, v_38); seed.u8(92, v_39); seed.u8(93, v_40); seed.u8(94, v_41); seed.u8(95, v_42); seed.u8(96, v_43); seed.u8(97, v_44); seed.u8(98, v_45); seed.u8(99, v_46); seed.u8(100, v_47); seed.u8(101, v_48); seed.u8(102, v_49); seed.u8(103, v_50); seed.u8(104, v_51); seed.u32(28, v_52); let [v_53]: [G; 1] = [G::from_u64(0)]; let [v_54]: [G; 1] = context.call::<1>(2, 38, &[v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_34])?; seed.u32(32, v_54); let [v_55]: [G; 1] = context.call::<1>(3, 42, &[v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_54])?; seed.u32(36, v_55); let [v_56]: [G; 1] = context.call::<1>(4, 42, &[v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_55])?; seed.u32(40, v_56); let [v_57]: [G; 1] = context.call::<1>(5, 42, &[v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_56])?; seed.u32(44, v_57); let [v_58]: [G; 1] = context.call::<1>(6, 42, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_57])?; seed.u32(48, v_58); let [v_59]: [G; 1] = context.store(7, &[v_53, v_0, v_58])?; seed.u32(52, v_59); Ok(()) }, } } - -fn write_71(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]); match v_0.as_canonical_u64() { _ => { let [v_35, 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]: [G; 18] = [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])]; row[offsets.auxiliaries + 1] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_42.as_canonical_u64(); 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(); let [v_54]: [G; 1] = [G::from_u64(seed[54])]; row[offsets.auxiliaries + 19] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(seed[55])]; row[offsets.auxiliaries + 20] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[56])]; row[offsets.auxiliaries + 21] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = [G::from_u64(seed[57])]; row[offsets.auxiliaries + 22] = v_57.as_canonical_u64(); let [v_58]: [G; 1] = [G::from_u64(seed[58])]; row[offsets.auxiliaries + 23] = v_58.as_canonical_u64(); let [v_59]: [G; 1] = [G::from_u64(seed[59])]; row[offsets.auxiliaries + 24] = v_59.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_71: 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::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::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 8, 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, 24, 16, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 28, 32, 36, 40, 44, 48, 52], bytes: 112 }; - -fn pack_72(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, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37]: [G; 36] = context.load::<36>(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(); 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(); 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(); 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(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_38]: [G; 1] = context.call::<1>(1, 72, &[v_37, v_1])?; seed[39] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = context.returned::<1>(2)?; seed[40] = v_39.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(72, v_2)) }, } } - -fn pack_72_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, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37]: [G; 36] = context.load::<36>(0, v_0)?; seed.u8(48, v_2); seed.full(16, v_3); seed.u8(49, v_4); seed.u8(50, v_5); seed.u8(51, v_6); seed.u8(52, v_7); seed.u8(53, v_8); seed.u8(54, v_9); seed.u8(55, v_10); seed.u8(56, v_11); seed.u8(57, v_12); seed.u8(58, v_13); seed.u8(59, v_14); seed.u8(60, v_15); seed.u8(61, v_16); seed.u8(62, v_17); seed.u8(63, v_18); seed.u8(64, v_19); seed.u8(65, v_20); seed.u8(66, v_21); seed.u8(67, v_22); seed.u8(68, v_23); seed.u8(69, v_24); seed.u8(70, v_25); seed.u8(71, v_26); seed.u8(72, v_27); seed.u8(73, v_28); seed.u8(74, v_29); seed.u8(75, v_30); seed.u8(76, v_31); seed.u8(77, v_32); seed.u8(78, v_33); seed.u8(79, v_34); seed.u8(80, v_35); seed.u32(36, v_36); seed.u32(40, v_37); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_38]: [G; 1] = context.call::<1>(1, 72, &[v_37, v_1])?; seed.full(24, v_38); let [v_39]: [G; 1] = context.returned::<1>(2)?; seed.u32(44, v_39); Ok(()) }, _ => { Err(no_match(72, v_2)) }, } } - -fn write_72(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, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37]: [G; 36] = [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]), 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 + 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(); 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.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_37.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_38]: [G; 1] = [G::from_u64(seed[39])]; row[offsets.auxiliaries + 37] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = [G::from_u64(seed[40])]; row[offsets.auxiliaries + 38] = v_39.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(72, v_2)) }, } } - -static SCHEMA_72: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, 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::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 32, 8, 48, 16, 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, 36, 40, 24, 44], bytes: 88 }; - -fn pack_73(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]; match v_0.as_canonical_u64() { _ => { let [v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45]: [G; 18] = context.load::<18>(0, v_25)?; 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(); let [v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53]: [G; 8] = context.call::<8>(1, 766, &[v_26])?; 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(); let [v_54]: [G; 1] = [G::from_u64(0)]; let [v_55]: [G; 1] = context.call::<1>(3, 72, &[v_26, v_27])?; seed[55] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = context.call::<1>(4, 42, &[v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_55])?; seed[56] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = context.call::<1>(5, 38, &[v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_56])?; seed[57] = v_57.as_canonical_u64(); let [v_58]: [G; 1] = context.call::<1>(6, 42, &[v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_57])?; seed[58] = v_58.as_canonical_u64(); let [v_59]: [G; 1] = context.call::<1>(7, 42, &[v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_58])?; seed[59] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = context.call::<1>(8, 42, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_59])?; seed[60] = v_60.as_canonical_u64(); let [v_61]: [G; 1] = context.store(9, &[v_54, v_0, v_60])?; seed[61] = v_61.as_canonical_u64(); Ok(()) }, } } - -fn pack_73_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]; match v_0.as_canonical_u64() { _ => { let [v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45]: [G; 18] = context.load::<18>(0, v_25)?; seed.u8(92, v_28); seed.u8(93, v_29); seed.u8(94, v_30); seed.u8(95, v_31); seed.u8(96, v_32); seed.u8(97, v_33); seed.u8(98, v_34); seed.u8(99, v_35); seed.u8(100, v_36); seed.u8(101, v_37); seed.u8(102, v_38); seed.u8(103, v_39); seed.u8(104, v_40); seed.u8(105, v_41); seed.u8(106, v_42); seed.u8(107, v_43); seed.u8(108, v_44); seed.u32(40, v_45); let [v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53]: [G; 8] = context.call::<8>(1, 766, &[v_26])?; seed.u8(109, v_46); seed.u8(110, v_47); seed.u8(111, v_48); seed.u8(112, v_49); seed.u8(113, v_50); seed.u8(114, v_51); seed.u8(115, v_52); seed.u8(116, v_53); let [v_54]: [G; 1] = [G::from_u64(0)]; let [v_55]: [G; 1] = context.call::<1>(3, 72, &[v_26, v_27])?; seed.full(24, v_55); let [v_56]: [G; 1] = context.call::<1>(4, 42, &[v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_55])?; seed.u32(44, v_56); let [v_57]: [G; 1] = context.call::<1>(5, 38, &[v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_56])?; seed.u32(48, v_57); let [v_58]: [G; 1] = context.call::<1>(6, 42, &[v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_57])?; seed.u32(52, v_58); let [v_59]: [G; 1] = context.call::<1>(7, 42, &[v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_58])?; seed.u32(56, v_59); let [v_60]: [G; 1] = context.call::<1>(8, 42, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_59])?; seed.u32(60, v_60); let [v_61]: [G; 1] = context.store(9, &[v_54, v_0, v_60])?; seed.u32(64, v_61); Ok(()) }, } } - -fn write_73(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]); match v_0.as_canonical_u64() { _ => { let [v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45]: [G; 18] = [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 + 1] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_45.as_canonical_u64(); let [v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53]: [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 + 19] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_53.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(seed[55])]; row[offsets.auxiliaries + 27] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[56])]; row[offsets.auxiliaries + 28] = v_56.as_canonical_u64(); let [v_57]: [G; 1] = [G::from_u64(seed[57])]; row[offsets.auxiliaries + 29] = v_57.as_canonical_u64(); let [v_58]: [G; 1] = [G::from_u64(seed[58])]; row[offsets.auxiliaries + 30] = v_58.as_canonical_u64(); let [v_59]: [G; 1] = [G::from_u64(seed[59])]; row[offsets.auxiliaries + 31] = v_59.as_canonical_u64(); let [v_60]: [G; 1] = [G::from_u64(seed[60])]; row[offsets.auxiliaries + 32] = v_60.as_canonical_u64(); let [v_61]: [G; 1] = [G::from_u64(seed[61])]; row[offsets.auxiliaries + 33] = v_61.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_73: 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::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::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 8, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 32, 36, 16, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 40, 109, 110, 111, 112, 113, 114, 115, 116, 24, 44, 48, 52, 56, 60, 64], bytes: 120 }; - -fn pack_76(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]; match v_0.as_canonical_u64() { 0u64 => { let [v_46]: [G; 1] = [G::from_u64(0)]; let [v_47]: [G; 1] = context.call::<1>(1, 65, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_45])?; seed[47] = v_47.as_canonical_u64(); let [v_48]: [G; 1] = context.store(2, &[v_46, v_46, v_47])?; seed[48] = v_48.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_49]: [G; 1] = [G::from_u64(0)]; let [v_50]: [G; 1] = [G::from_u64(1)]; let [v_51]: [G; 1] = context.call::<1>(5, 73, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_45])?; seed[47] = v_51.as_canonical_u64(); let [v_52]: [G; 1] = context.store(6, &[v_49, v_50, v_51])?; seed[48] = v_52.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_53]: [G; 1] = [G::from_u64(0)]; let [v_54]: [G; 1] = [G::from_u64(2)]; let [v_55]: [G; 1] = context.call::<1>(9, 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_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45])?; seed[47] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = context.store(10, &[v_53, v_54, v_55])?; seed[48] = v_56.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(76, v_0)) }, } } - -fn pack_76_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]; match v_0.as_canonical_u64() { 0u64 => { let [v_46]: [G; 1] = [G::from_u64(0)]; let [v_47]: [G; 1] = context.call::<1>(1, 65, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_45])?; seed.u32(24, v_47); let [v_48]: [G; 1] = context.store(2, &[v_46, v_46, v_47])?; seed.u32(28, v_48); Ok(()) }, 1u64 => { let [v_49]: [G; 1] = [G::from_u64(0)]; let [v_50]: [G; 1] = [G::from_u64(1)]; let [v_51]: [G; 1] = context.call::<1>(5, 73, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_45])?; seed.u32(24, v_51); let [v_52]: [G; 1] = context.store(6, &[v_49, v_50, v_51])?; seed.u32(28, v_52); Ok(()) }, 2u64 => { let [v_53]: [G; 1] = [G::from_u64(0)]; let [v_54]: [G; 1] = [G::from_u64(2)]; let [v_55]: [G; 1] = context.call::<1>(9, 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_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45])?; seed.u32(24, v_55); let [v_56]: [G; 1] = context.store(10, &[v_53, v_54, v_55])?; seed.u32(28, v_56); Ok(()) }, _ => { Err(no_match(76, v_0)) }, } } - -fn write_76(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 = 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]); match v_0.as_canonical_u64() { 0u64 => { let [v_47]: [G; 1] = [G::from_u64(seed[47])]; row[offsets.auxiliaries + 1] = v_47.as_canonical_u64(); let [v_48]: [G; 1] = [G::from_u64(seed[48])]; row[offsets.auxiliaries + 2] = v_48.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_51]: [G; 1] = [G::from_u64(seed[47])]; row[offsets.auxiliaries + 1] = v_51.as_canonical_u64(); let [v_52]: [G; 1] = [G::from_u64(seed[48])]; row[offsets.auxiliaries + 2] = v_52.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_55]: [G; 1] = [G::from_u64(seed[47])]; row[offsets.auxiliaries + 1] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[48])]; row[offsets.auxiliaries + 2] = v_56.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(76, v_0)) }, } } - -static SCHEMA_76: 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::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::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::U32, SeedWidth::U32], offsets: &[0, 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, 16, 20, 8, 24, 28], bytes: 80 }; - -fn pack_77(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, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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]: [G; 47] = context.load::<47>(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(); 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(); 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(); 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(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_49]: [G; 1] = context.call::<1>(1, 77, &[v_48, v_1])?; seed[50] = v_49.as_canonical_u64(); let [v_50]: [G; 1] = context.returned::<1>(2)?; seed[51] = v_50.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(77, v_2)) }, } } - -fn pack_77_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, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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]: [G; 47] = context.load::<47>(0, v_0)?; seed.u8(44, v_2); 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.u8(54, v_12); seed.u8(55, v_13); seed.u8(56, v_14); seed.u8(57, v_15); seed.u8(58, v_16); seed.u8(59, v_17); seed.u8(60, v_18); seed.u8(61, v_19); seed.u8(62, v_20); seed.u8(63, v_21); seed.u8(64, v_22); seed.u8(65, v_23); seed.u8(66, v_24); seed.u8(67, v_25); seed.u8(68, v_26); seed.u8(69, v_27); seed.u8(70, v_28); seed.u8(71, v_29); seed.u8(72, v_30); seed.u8(73, v_31); seed.u8(74, v_32); seed.u8(75, v_33); seed.u8(76, v_34); seed.u8(77, v_35); seed.u8(78, v_36); seed.u8(79, v_37); seed.u8(80, v_38); seed.u8(81, v_39); seed.u8(82, v_40); seed.u8(83, v_41); seed.u8(84, v_42); seed.u8(85, v_43); seed.u8(86, v_44); seed.u8(87, v_45); seed.u32(28, v_46); seed.u32(32, v_47); seed.u32(36, v_48); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_49]: [G; 1] = context.call::<1>(1, 77, &[v_48, v_1])?; seed.full(16, v_49); let [v_50]: [G; 1] = context.returned::<1>(2)?; seed.u32(40, v_50); Ok(()) }, _ => { Err(no_match(77, v_2)) }, } } - -fn write_77(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, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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]: [G; 47] = [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]), 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])]; 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(); 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.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_48.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_49]: [G; 1] = [G::from_u64(seed[50])]; row[offsets.auxiliaries + 48] = v_49.as_canonical_u64(); let [v_50]: [G; 1] = [G::from_u64(seed[51])]; row[offsets.auxiliaries + 49] = v_50.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(77, v_2)) }, } } - -static SCHEMA_77: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, 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::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 24, 8, 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, 28, 32, 36, 16, 40], bytes: 88 }; - -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(); Ok(()) } - -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(28, v_1); seed.full(8, v_2); seed.full(16, v_3); Ok(()) } - -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 => { row[offsets.selectors] = 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::Full, SeedWidth::Full], offsets: &[0, 24, 28, 8, 16], bytes: 32 }; - -fn pack_84(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, 84, &[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(84, v_3)) }, } }, } } - -fn pack_84_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, 84, &[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(84, v_3)) }, } }, } } - -fn write_84(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(84, v_3)) }, } }, } } - -static SCHEMA_84: 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_85(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_15]: [G; 1] = [G::from_u64(4)]; let [v_21]: [G; 1] = [v_12 * v_5]; let [v_22]: [G; 1] = [v_4 + v_21]; let [v_23]: [G; 1] = [v_15 * v_6]; let [v_24]: [G; 1] = [v_22 + v_23]; match v_7.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { let [v_26]: [G; 1] = [G::from_u64(4)]; let [v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 9] = context.call::<9>(17, 88, &[v_24, v_26, v_3])?; seed[5] = v_27.as_canonical_u64(); seed[6] = v_28.as_canonical_u64(); seed[7] = v_29.as_canonical_u64(); seed[8] = v_30.as_canonical_u64(); seed[9] = v_31.as_canonical_u64(); seed[10] = v_32.as_canonical_u64(); seed[11] = v_33.as_canonical_u64(); seed[12] = v_34.as_canonical_u64(); seed[13] = v_35.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(85, v_7)) }, } }, _ => { Err(no_match(85, v_1)) }, } } - -fn pack_85_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(32, v_1); seed.u8(33, v_2); seed.u32(28, 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_15]: [G; 1] = [G::from_u64(4)]; let [v_21]: [G; 1] = [v_12 * v_5]; let [v_22]: [G; 1] = [v_4 + v_21]; let [v_23]: [G; 1] = [v_15 * v_6]; let [v_24]: [G; 1] = [v_22 + v_23]; match v_7.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { let [v_26]: [G; 1] = [G::from_u64(4)]; let [v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [G; 9] = context.call::<9>(17, 88, &[v_24, v_26, v_3])?; seed.u8(34, v_27); seed.full(8, v_28); seed.u8(35, v_29); seed.u8(36, v_30); seed.u8(37, v_31); seed.u8(38, v_32); seed.u8(39, v_33); seed.u8(40, v_34); seed.full(16, v_35); Ok(()) }, _ => { Err(no_match(85, v_7)) }, } }, _ => { Err(no_match(85, v_1)) }, } } - -fn write_85(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(); match v_7.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35]: [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 + 12] = v_27.as_canonical_u64(); 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.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(85, v_7)) }, } }, _ => { Err(no_match(85, v_1)) }, } } - -static SCHEMA_85: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full], offsets: &[0, 24, 32, 33, 28, 34, 8, 35, 36, 37, 38, 39, 40, 16], bytes: 48 }; - -fn pack_87(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]: [G; 1] = [G::from_u64(128)]; let [v_5]: [G; 1] = [Bytes2::less_than(&v_2, &v_4)]; match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18]: [G; 9] = context.returned::<9>(7)?; seed[5] = v_10.as_canonical_u64(); seed[6] = v_11.as_canonical_u64(); seed[7] = v_12.as_canonical_u64(); seed[8] = v_13.as_canonical_u64(); seed[9] = v_14.as_canonical_u64(); seed[10] = v_15.as_canonical_u64(); seed[11] = v_16.as_canonical_u64(); seed[12] = v_17.as_canonical_u64(); seed[13] = v_18.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(87, v_5)) }, } }, _ => { Err(no_match(87, v_1)) }, } } - -fn pack_87_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(32, v_1); seed.u8(33, v_2); seed.u32(28, v_3); match v_1.as_canonical_u64() { 0u64 => { let [v_4]: [G; 1] = [G::from_u64(128)]; let [v_5]: [G; 1] = [Bytes2::less_than(&v_2, &v_4)]; match v_5.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18]: [G; 9] = context.returned::<9>(7)?; seed.u8(34, v_10); seed.full(8, v_11); seed.u8(35, v_12); seed.u8(36, v_13); seed.u8(37, v_14); seed.u8(38, v_15); seed.u8(39, v_16); seed.u8(40, v_17); seed.full(16, v_18); Ok(()) }, _ => { Err(no_match(87, v_5)) }, } }, _ => { Err(no_match(87, v_1)) }, } } - -fn write_87(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]: [G; 1] = [G::from_u64(128)]; let [v_5]: [G; 1] = [Bytes2::less_than(&v_2, &v_4)]; row[offsets.auxiliaries + 4] = v_5.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18]: [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 + 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(); row[offsets.auxiliaries + 12] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_18.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(87, v_5)) }, } }, _ => { Err(no_match(87, v_1)) }, } } - -static SCHEMA_87: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full], offsets: &[0, 24, 32, 33, 28, 34, 8, 35, 36, 37, 38, 39, 40, 16], bytes: 48 }; - -fn pack_88(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] = [Bytes2::less_than(&v_0, &v_1)]; match v_3.as_canonical_u64() { 1u64 => { let [v_4, v_5, v_6]: [G; 3] = context.load::<3>(1, v_2)?; seed[4] = v_4.as_canonical_u64(); seed[5] = v_5.as_canonical_u64(); seed[6] = v_6.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22]: [G; 9] = context.returned::<9>(8)?; seed[4] = v_14.as_canonical_u64(); seed[5] = v_15.as_canonical_u64(); seed[6] = v_16.as_canonical_u64(); seed[7] = v_17.as_canonical_u64(); seed[8] = v_18.as_canonical_u64(); seed[9] = v_19.as_canonical_u64(); seed[10] = v_20.as_canonical_u64(); seed[11] = v_21.as_canonical_u64(); seed[12] = v_22.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(88, v_3)) }, } } - -fn pack_88_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] = [Bytes2::less_than(&v_0, &v_1)]; match v_3.as_canonical_u64() { 1u64 => { let [v_4, v_5, v_6]: [G; 3] = context.load::<3>(1, v_2)?; seed.u8(30, v_4); seed.u8(31, v_5); seed.full(8, v_6); Ok(()) }, 0u64 => { let [v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22]: [G; 9] = context.returned::<9>(8)?; seed.u8(30, v_14); seed.u8(31, v_15); seed.full(8, v_16); seed.u8(32, v_17); seed.u8(33, v_18); seed.u8(34, v_19); seed.u8(35, v_20); seed.u8(36, v_21); seed.full(16, v_22); Ok(()) }, _ => { Err(no_match(88, v_3)) }, } } - -fn write_88(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] = [Bytes2::less_than(&v_0, &v_1)]; row[offsets.auxiliaries + 1] = v_3.as_canonical_u64(); match v_3.as_canonical_u64() { 1u64 => { let [v_4, v_5, v_6]: [G; 3] = [G::from_u64(seed[4]), G::from_u64(seed[5]), G::from_u64(seed[6])]; 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_4.as_canonical_u64() { 0u64 => { let [v_7]: [G; 1] = [G::from_u64(2)]; let [v_8]: [G; 1] = [v_7 * v_1]; let op_4 = Bytes2::add(&v_5, &v_8); let [v_9, v_10]: [G; 2] = [op_4.0, op_4.1]; row[offsets.auxiliaries + 5] = v_9.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(88, v_4)) }, } }, 0u64 => { let [v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22]: [G; 9] = [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_14.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_16.as_canonical_u64(); 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(); row[offsets.auxiliaries + 9] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_22.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(88, v_3)) }, } } - -static SCHEMA_88: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full], offsets: &[0, 28, 29, 24, 30, 31, 8, 32, 33, 34, 35, 36, 16], bytes: 40 }; - -fn pack_89(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] = [G::from_u64(2)]; let [v_4]: [G; 1] = [v_3 * v_1]; match v_0.as_canonical_u64() { 0u64 => { let [v_5]: [G; 1] = [G::from_u64(2)]; let [v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14]: [G; 9] = context.call::<9>(3, 84, &[v_2, v_5])?; 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]: [G; 1] = [G::from_u64(0)]; let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 9] = context.call::<9>(5, 15, &[v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_4, v_1, v_15, v_15, v_15, v_15, v_15, v_15])?; seed[13] = v_16.as_canonical_u64(); seed[14] = v_17.as_canonical_u64(); seed[15] = v_18.as_canonical_u64(); seed[16] = v_19.as_canonical_u64(); seed[17] = v_20.as_canonical_u64(); seed[18] = v_21.as_canonical_u64(); seed[19] = v_22.as_canonical_u64(); seed[20] = v_23.as_canonical_u64(); seed[21] = v_24.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_25]: [G; 1] = [G::from_u64(3)]; let [v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34]: [G; 9] = context.call::<9>(7, 84, &[v_2, v_25])?; seed[4] = v_26.as_canonical_u64(); seed[5] = v_27.as_canonical_u64(); seed[6] = v_28.as_canonical_u64(); seed[7] = v_29.as_canonical_u64(); seed[8] = v_30.as_canonical_u64(); seed[9] = v_31.as_canonical_u64(); seed[10] = v_32.as_canonical_u64(); seed[11] = v_33.as_canonical_u64(); seed[12] = v_34.as_canonical_u64(); let [v_35]: [G; 1] = [G::from_u64(1)]; let [v_36]: [G; 1] = [G::from_u64(0)]; let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45]: [G; 9] = context.call::<9>(10, 15, &[v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_4, v_1, v_35, v_36, v_36, v_36, v_36, v_36])?; seed[13] = v_37.as_canonical_u64(); seed[14] = v_38.as_canonical_u64(); seed[15] = v_39.as_canonical_u64(); seed[16] = v_40.as_canonical_u64(); seed[17] = v_41.as_canonical_u64(); seed[18] = v_42.as_canonical_u64(); seed[19] = v_43.as_canonical_u64(); seed[20] = v_44.as_canonical_u64(); seed[21] = v_45.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_46]: [G; 1] = [G::from_u64(4)]; let [v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55]: [G; 9] = context.call::<9>(12, 84, &[v_2, v_46])?; seed[4] = v_47.as_canonical_u64(); seed[5] = v_48.as_canonical_u64(); seed[6] = v_49.as_canonical_u64(); seed[7] = v_50.as_canonical_u64(); seed[8] = v_51.as_canonical_u64(); seed[9] = v_52.as_canonical_u64(); seed[10] = v_53.as_canonical_u64(); seed[11] = v_54.as_canonical_u64(); seed[12] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(1)]; 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, v_66]: [G; 9] = context.call::<9>(15, 15, &[v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_4, v_1, v_56, v_56, v_57, v_57, v_57, v_57])?; seed[13] = v_58.as_canonical_u64(); seed[14] = v_59.as_canonical_u64(); seed[15] = v_60.as_canonical_u64(); seed[16] = v_61.as_canonical_u64(); seed[17] = v_62.as_canonical_u64(); seed[18] = v_63.as_canonical_u64(); seed[19] = v_64.as_canonical_u64(); seed[20] = v_65.as_canonical_u64(); seed[21] = v_66.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_67]: [G; 1] = [G::from_u64(8)]; let [v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76]: [G; 9] = context.call::<9>(17, 84, &[v_2, v_67])?; seed[4] = v_68.as_canonical_u64(); seed[5] = v_69.as_canonical_u64(); seed[6] = v_70.as_canonical_u64(); seed[7] = v_71.as_canonical_u64(); seed[8] = v_72.as_canonical_u64(); seed[9] = v_73.as_canonical_u64(); seed[10] = v_74.as_canonical_u64(); seed[11] = v_75.as_canonical_u64(); seed[12] = v_76.as_canonical_u64(); let [v_77]: [G; 1] = [G::from_u64(1)]; let [v_78]: [G; 1] = [G::from_u64(0)]; let [v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87]: [G; 9] = context.call::<9>(20, 15, &[v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_4, v_1, v_77, v_77, v_77, v_78, v_78, v_78])?; seed[13] = v_79.as_canonical_u64(); seed[14] = v_80.as_canonical_u64(); seed[15] = v_81.as_canonical_u64(); seed[16] = v_82.as_canonical_u64(); seed[17] = v_83.as_canonical_u64(); seed[18] = v_84.as_canonical_u64(); seed[19] = v_85.as_canonical_u64(); seed[20] = v_86.as_canonical_u64(); seed[21] = v_87.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(89, v_0)) }, } } - -fn pack_89_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] = [G::from_u64(2)]; let [v_4]: [G; 1] = [v_3 * v_1]; match v_0.as_canonical_u64() { 0u64 => { let [v_5]: [G; 1] = [G::from_u64(2)]; let [v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14]: [G; 9] = context.call::<9>(3, 84, &[v_2, v_5])?; seed.u8(22, v_6); seed.u8(23, v_7); seed.u8(24, v_8); seed.u8(25, v_9); seed.u8(26, v_10); seed.u8(27, v_11); seed.u8(28, v_12); seed.u8(29, v_13); seed.full(8, v_14); let [v_15]: [G; 1] = [G::from_u64(0)]; let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 9] = context.call::<9>(5, 15, &[v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_4, v_1, v_15, v_15, v_15, v_15, v_15, v_15])?; seed.u8(30, v_16); seed.u8(31, v_17); seed.u8(32, v_18); seed.u8(33, v_19); seed.u8(34, v_20); seed.u8(35, v_21); seed.u8(36, v_22); seed.u8(37, v_23); seed.u8(38, v_24); Ok(()) }, 1u64 => { let [v_25]: [G; 1] = [G::from_u64(3)]; let [v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34]: [G; 9] = context.call::<9>(7, 84, &[v_2, v_25])?; seed.u8(22, v_26); seed.u8(23, v_27); seed.u8(24, v_28); seed.u8(25, v_29); seed.u8(26, v_30); seed.u8(27, v_31); seed.u8(28, v_32); seed.u8(29, v_33); seed.full(8, v_34); let [v_35]: [G; 1] = [G::from_u64(1)]; let [v_36]: [G; 1] = [G::from_u64(0)]; let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45]: [G; 9] = context.call::<9>(10, 15, &[v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_4, v_1, v_35, v_36, v_36, v_36, v_36, v_36])?; seed.u8(30, v_37); seed.u8(31, v_38); seed.u8(32, v_39); seed.u8(33, v_40); seed.u8(34, v_41); seed.u8(35, v_42); seed.u8(36, v_43); seed.u8(37, v_44); seed.u8(38, v_45); Ok(()) }, 2u64 => { let [v_46]: [G; 1] = [G::from_u64(4)]; let [v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55]: [G; 9] = context.call::<9>(12, 84, &[v_2, v_46])?; seed.u8(22, v_47); seed.u8(23, v_48); seed.u8(24, v_49); seed.u8(25, v_50); seed.u8(26, v_51); seed.u8(27, v_52); seed.u8(28, v_53); seed.u8(29, v_54); seed.full(8, v_55); let [v_56]: [G; 1] = [G::from_u64(1)]; 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, v_66]: [G; 9] = context.call::<9>(15, 15, &[v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_4, v_1, v_56, v_56, v_57, v_57, v_57, v_57])?; seed.u8(30, v_58); seed.u8(31, v_59); seed.u8(32, v_60); seed.u8(33, v_61); seed.u8(34, v_62); seed.u8(35, v_63); seed.u8(36, v_64); seed.u8(37, v_65); seed.u8(38, v_66); Ok(()) }, 3u64 => { let [v_67]: [G; 1] = [G::from_u64(8)]; let [v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76]: [G; 9] = context.call::<9>(17, 84, &[v_2, v_67])?; seed.u8(22, v_68); seed.u8(23, v_69); seed.u8(24, v_70); seed.u8(25, v_71); seed.u8(26, v_72); seed.u8(27, v_73); seed.u8(28, v_74); seed.u8(29, v_75); seed.full(8, v_76); let [v_77]: [G; 1] = [G::from_u64(1)]; let [v_78]: [G; 1] = [G::from_u64(0)]; let [v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87]: [G; 9] = context.call::<9>(20, 15, &[v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_4, v_1, v_77, v_77, v_77, v_78, v_78, v_78])?; seed.u8(30, v_79); seed.u8(31, v_80); seed.u8(32, v_81); seed.u8(33, v_82); seed.u8(34, v_83); seed.u8(35, v_84); seed.u8(36, v_85); seed.u8(37, v_86); seed.u8(38, v_87); Ok(()) }, _ => { Err(no_match(89, v_0)) }, } } - -fn write_89(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() { 0u64 => { let [v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14]: [G; 9] = [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 + 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(); 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[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])]; row[offsets.auxiliaries + 10] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_24.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34]: [G; 9] = [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 + 1] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_34.as_canonical_u64(); let [v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45]: [G; 9] = [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])]; row[offsets.auxiliaries + 10] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_45.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_47, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55]: [G; 9] = [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 + 1] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_55.as_canonical_u64(); let [v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66]: [G; 9] = [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])]; row[offsets.auxiliaries + 10] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_66.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76]: [G; 9] = [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 + 1] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_76.as_canonical_u64(); let [v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87]: [G; 9] = [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])]; row[offsets.auxiliaries + 10] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_87.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(89, v_0)) }, } } - -static SCHEMA_89: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 20, 21, 16, 22, 23, 24, 25, 26, 27, 28, 29, 8, 30, 31, 32, 33, 34, 35, 36, 37, 38], bytes: 40 }; - -fn pack_91(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, 6, &[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, 98, &[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, 17, &[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(91, v_10)) }, } } - -fn pack_91_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, 6, &[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, 98, &[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, 17, &[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(91, v_10)) }, } } - -fn write_91(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(91, v_10)) }, } } - -static SCHEMA_91: 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_94(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2]: [G; 2] = context.call::<2>(0, 83, &[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, 93, &[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_94_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2]: [G; 2] = context.call::<2>(0, 83, &[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, 93, &[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 write_94(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_94: 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_95(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2]: [G; 2] = context.call::<2>(0, 83, &[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, 93, &[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, 92, &[v_7, v_8])?; seed[7] = v_16.as_canonical_u64(); seed[8] = v_17.as_canonical_u64(); Ok(()) } - -fn pack_95_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let [v_1, v_2]: [G; 2] = context.call::<2>(0, 83, &[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, 93, &[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, 92, &[v_7, v_8])?; seed.u8(24, v_16); seed.u8(25, v_17); Ok(()) } - -fn write_95(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_95: 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_98(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, 85, &[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, 87, &[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, 90, &[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, 87, &[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, 90, &[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, 87, &[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, 98, &[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, 6, &[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, 98, &[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, 6, &[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, 6, &[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(98, v_1)) }, } } - -fn pack_98_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, 85, &[v_0])?; seed.u8(140, v_1); seed.u8(141, v_2); seed.full(8, v_3); seed.u8(142, v_4); seed.u8(143, v_5); seed.u8(144, v_6); seed.u8(145, v_7); seed.u8(146, v_8); seed.u8(147, v_9); seed.u32(132, 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(16, 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(16, 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, 87, &[v_10])?; seed.full(16, v_16); seed.full(24, v_17); seed.full(32, v_18); seed.u8(148, v_19); seed.full(40, v_20); seed.full(48, v_21); seed.u8(149, v_22); seed.full(56, v_23); seed.full(64, v_24); let [v_25, v_26]: [G; 2] = context.call::<2>(7, 90, &[v_24, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.full(72, v_25); seed.full(80, 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(88, 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, 87, &[v_10])?; seed.full(16, v_30); seed.full(24, v_31); seed.full(32, v_32); seed.u8(148, v_33); seed.full(40, v_34); seed.full(48, v_35); seed.u8(149, v_36); seed.full(56, v_37); seed.full(64, v_38); let [v_39, v_40]: [G; 2] = context.call::<2>(12, 90, &[v_38, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.full(72, v_39); seed.full(80, 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(88, 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, 87, &[v_10])?; seed.full(16, v_44); seed.full(24, v_45); seed.full(32, v_46); seed.u8(148, v_47); seed.full(40, v_48); seed.full(48, v_49); seed.u8(149, v_50); seed.full(56, v_51); seed.full(64, v_52); let [v_53, v_54]: [G; 2] = context.call::<2>(17, 98, &[v_52])?; seed.full(72, v_53); seed.full(80, 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(88, 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(16, 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(16, v_62); Ok(()) }, 7u64 => { let [v_63]: [G; 1] = context.call::<1>(26, 6, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.full(16, v_63); let [v_65, v_66]: [G; 2] = context.call::<2>(29, 98, &[v_10])?; seed.full(24, v_65); seed.full(32, 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.u8(148, v_67); seed.full(40, v_68); seed.full(48, v_69); seed.u8(149, v_70); seed.full(56, v_71); seed.full(64, v_72); seed.full(72, v_73); seed.full(80, v_74); seed.full(88, v_75); seed.u32(136, v_76); seed.full(96, v_77); seed.u8(150, v_78); seed.u8(151, v_79); seed.u8(152, v_80); seed.u8(153, v_81); seed.u8(154, v_82); seed.u8(155, v_83); seed.full(104, v_84); match v_67.as_canonical_u64() { 7u64 => { let [v_87, v_88]: [G; 2] = context.returned::<2>(34)?; seed.full(112, v_87); seed.full(120, v_88); Ok(()) }, _ => { let [v_89, v_90]: [G; 2] = context.returned::<2>(35)?; seed.full(112, v_89); seed.full(120, v_90); Ok(()) }, } }, 8u64 => { let [v_91]: [G; 1] = context.call::<1>(36, 6, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.full(16, v_91); let [v_93, v_94]: [G; 2] = context.returned::<2>(39)?; seed.full(24, v_93); seed.full(32, v_94); Ok(()) }, 9u64 => { let [v_95]: [G; 1] = context.call::<1>(40, 6, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.full(16, v_95); let [v_97, v_98]: [G; 2] = context.returned::<2>(43)?; seed.full(24, v_97); seed.full(32, v_98); Ok(()) }, 10u64 => { let [v_99, v_100]: [G; 2] = context.returned::<2>(44)?; seed.full(16, v_99); seed.full(24, 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(16, v_103); Ok(()) }, _ => { Err(no_match(98, v_1)) }, } } - -fn write_98(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(98, v_1)) }, } } - -static SCHEMA_98: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, 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::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 128, 140, 141, 8, 142, 143, 144, 145, 146, 147, 132, 16, 24, 32, 148, 40, 48, 149, 56, 64, 72, 80, 88, 136, 96, 150, 151, 152, 153, 154, 155, 104, 112, 120], bytes: 160 }; - -fn pack_103(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, 6, &[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, 98, &[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, 17, &[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, 103, &[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(103, v_9)) }, } } - -fn pack_103_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, 6, &[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, 98, &[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, 17, &[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, 103, &[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(103, v_9)) }, } } - -fn write_103(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(103, v_9)) }, } } - -static SCHEMA_103: 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_125(context: &SeedContext<'_>, seed: &mut [u64],) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_0.as_canonical_u64() { 0u64 => { let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14]: [G; 13] = context.call::<13>(0, 110, &[v_1])?; 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(); 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(); Ok(()) }, 1u64 => { let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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]: [G; 45] = context.call::<45>(2, 113, &[v_1])?; seed[3] = v_16.as_canonical_u64(); seed[4] = v_17.as_canonical_u64(); seed[5] = v_18.as_canonical_u64(); seed[6] = v_19.as_canonical_u64(); seed[7] = v_20.as_canonical_u64(); seed[8] = v_21.as_canonical_u64(); seed[9] = v_22.as_canonical_u64(); seed[10] = v_23.as_canonical_u64(); seed[11] = v_24.as_canonical_u64(); seed[12] = v_25.as_canonical_u64(); seed[13] = v_26.as_canonical_u64(); seed[14] = v_27.as_canonical_u64(); seed[15] = v_28.as_canonical_u64(); seed[16] = v_29.as_canonical_u64(); seed[17] = v_30.as_canonical_u64(); seed[18] = v_31.as_canonical_u64(); seed[19] = v_32.as_canonical_u64(); seed[20] = v_33.as_canonical_u64(); seed[21] = v_34.as_canonical_u64(); seed[22] = v_35.as_canonical_u64(); seed[23] = v_36.as_canonical_u64(); seed[24] = v_37.as_canonical_u64(); seed[25] = v_38.as_canonical_u64(); seed[26] = v_39.as_canonical_u64(); seed[27] = v_40.as_canonical_u64(); seed[28] = v_41.as_canonical_u64(); seed[29] = v_42.as_canonical_u64(); seed[30] = v_43.as_canonical_u64(); seed[31] = v_44.as_canonical_u64(); seed[32] = v_45.as_canonical_u64(); seed[33] = v_46.as_canonical_u64(); seed[34] = v_47.as_canonical_u64(); seed[35] = v_48.as_canonical_u64(); seed[36] = v_49.as_canonical_u64(); seed[37] = v_50.as_canonical_u64(); seed[38] = v_51.as_canonical_u64(); seed[39] = v_52.as_canonical_u64(); seed[40] = v_53.as_canonical_u64(); seed[41] = v_54.as_canonical_u64(); seed[42] = v_55.as_canonical_u64(); seed[43] = v_56.as_canonical_u64(); seed[44] = v_57.as_canonical_u64(); seed[45] = v_58.as_canonical_u64(); seed[46] = v_59.as_canonical_u64(); seed[47] = v_60.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 11] = context.call::<11>(4, 115, &[v_1])?; seed[3] = v_62.as_canonical_u64(); seed[4] = v_63.as_canonical_u64(); seed[5] = v_64.as_canonical_u64(); seed[6] = v_65.as_canonical_u64(); seed[7] = v_66.as_canonical_u64(); seed[8] = v_67.as_canonical_u64(); seed[9] = v_68.as_canonical_u64(); seed[10] = v_69.as_canonical_u64(); seed[11] = v_70.as_canonical_u64(); seed[12] = v_71.as_canonical_u64(); seed[13] = v_72.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85]: [G; 11] = context.call::<11>(7, 117, &[v_1])?; seed[3] = v_75.as_canonical_u64(); seed[4] = v_76.as_canonical_u64(); seed[5] = v_77.as_canonical_u64(); seed[6] = v_78.as_canonical_u64(); seed[7] = v_79.as_canonical_u64(); seed[8] = v_80.as_canonical_u64(); seed[9] = v_81.as_canonical_u64(); seed[10] = v_82.as_canonical_u64(); seed[11] = v_83.as_canonical_u64(); seed[12] = v_84.as_canonical_u64(); seed[13] = v_85.as_canonical_u64(); Ok(()) }, 4u64 => { let [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]: [G; 18] = context.call::<18>(10, 122, &[v_1])?; seed[3] = v_88.as_canonical_u64(); seed[4] = v_89.as_canonical_u64(); seed[5] = v_90.as_canonical_u64(); seed[6] = v_91.as_canonical_u64(); seed[7] = v_92.as_canonical_u64(); seed[8] = v_93.as_canonical_u64(); seed[9] = v_94.as_canonical_u64(); seed[10] = v_95.as_canonical_u64(); seed[11] = v_96.as_canonical_u64(); seed[12] = v_97.as_canonical_u64(); seed[13] = v_98.as_canonical_u64(); seed[14] = v_99.as_canonical_u64(); seed[15] = v_100.as_canonical_u64(); seed[16] = v_101.as_canonical_u64(); seed[17] = v_102.as_canonical_u64(); seed[18] = v_103.as_canonical_u64(); seed[19] = v_104.as_canonical_u64(); seed[20] = v_105.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117]: [G; 10] = context.call::<10>(13, 121, &[v_1])?; seed[3] = v_108.as_canonical_u64(); seed[4] = v_109.as_canonical_u64(); seed[5] = v_110.as_canonical_u64(); seed[6] = v_111.as_canonical_u64(); seed[7] = v_112.as_canonical_u64(); seed[8] = v_113.as_canonical_u64(); seed[9] = v_114.as_canonical_u64(); seed[10] = v_115.as_canonical_u64(); seed[11] = v_116.as_canonical_u64(); seed[12] = v_117.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129]: [G; 10] = context.call::<10>(16, 121, &[v_1])?; seed[3] = v_120.as_canonical_u64(); seed[4] = v_121.as_canonical_u64(); seed[5] = v_122.as_canonical_u64(); seed[6] = v_123.as_canonical_u64(); seed[7] = v_124.as_canonical_u64(); seed[8] = v_125.as_canonical_u64(); seed[9] = v_126.as_canonical_u64(); seed[10] = v_127.as_canonical_u64(); seed[11] = v_128.as_canonical_u64(); seed[12] = v_129.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141]: [G; 10] = context.call::<10>(19, 121, &[v_1])?; seed[3] = v_132.as_canonical_u64(); seed[4] = v_133.as_canonical_u64(); seed[5] = v_134.as_canonical_u64(); seed[6] = v_135.as_canonical_u64(); seed[7] = v_136.as_canonical_u64(); seed[8] = v_137.as_canonical_u64(); seed[9] = v_138.as_canonical_u64(); seed[10] = v_139.as_canonical_u64(); seed[11] = v_140.as_canonical_u64(); seed[12] = v_141.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(125, v_0)) }, } } - -fn pack_125_typed(context: &SeedContext<'_>, seed: &mut TypedSeed<'_>,) -> TraceResult<()> { let v_0 = context.inputs[0]; let v_1 = context.inputs[1]; match v_0.as_canonical_u64() { 0u64 => { let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14]: [G; 13] = context.call::<13>(0, 110, &[v_1])?; seed.full(8, v_2); seed.full(16, v_3); seed.full(24, v_4); seed.full(32, v_5); seed.u8(165, v_6); seed.u8(166, v_7); seed.u8(167, v_8); seed.u8(168, 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); Ok(()) }, 1u64 => { let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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]: [G; 45] = context.call::<45>(2, 113, &[v_1])?; seed.full(8, v_16); seed.full(16, v_17); seed.full(24, v_18); seed.full(32, v_19); seed.u8(165, v_20); seed.u8(166, v_21); seed.u8(167, v_22); seed.u8(168, v_23); seed.full(40, v_24); seed.full(48, v_25); seed.full(56, v_26); seed.full(64, v_27); seed.full(72, v_28); seed.u8(169, v_29); seed.u8(170, v_30); seed.u8(171, v_31); seed.u32(156, v_32); seed.full(80, v_33); seed.full(88, v_34); seed.full(96, v_35); seed.u8(172, v_36); seed.u8(173, v_37); seed.u8(174, v_38); seed.u8(175, v_39); seed.u8(176, v_40); seed.u8(177, v_41); seed.full(104, v_42); seed.full(112, v_43); seed.u8(178, v_44); seed.u8(179, v_45); seed.u8(180, v_46); seed.u8(181, v_47); seed.u8(182, v_48); seed.u8(183, v_49); seed.full(120, v_50); seed.full(128, v_51); seed.u8(184, v_52); seed.u8(185, v_53); seed.u8(186, v_54); seed.u8(187, v_55); seed.u8(188, v_56); seed.u8(189, v_57); seed.full(136, v_58); seed.u32(160, v_59); seed.full(144, v_60); Ok(()) }, 2u64 => { let [v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 11] = context.call::<11>(4, 115, &[v_1])?; seed.full(8, v_62); seed.full(16, v_63); seed.full(24, v_64); seed.full(32, v_65); seed.u8(165, v_66); seed.u8(166, v_67); seed.u8(167, v_68); seed.u8(168, v_69); seed.full(40, v_70); seed.full(48, v_71); seed.full(56, v_72); Ok(()) }, 3u64 => { let [v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85]: [G; 11] = context.call::<11>(7, 117, &[v_1])?; seed.full(8, v_75); seed.full(16, v_76); seed.full(24, v_77); seed.full(32, v_78); seed.u8(165, v_79); seed.u8(166, v_80); seed.u8(167, v_81); seed.u8(168, v_82); seed.full(40, v_83); seed.full(48, v_84); seed.full(56, v_85); Ok(()) }, 4u64 => { let [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]: [G; 18] = context.call::<18>(10, 122, &[v_1])?; seed.full(8, v_88); seed.full(16, v_89); seed.full(24, v_90); seed.full(32, v_91); seed.u8(165, v_92); seed.u8(166, v_93); seed.u8(167, v_94); seed.u8(168, v_95); seed.full(40, v_96); seed.full(48, v_97); seed.full(56, v_98); seed.full(64, v_99); seed.full(72, v_100); seed.u8(169, v_101); seed.u8(170, v_102); seed.u8(171, v_103); seed.u32(156, v_104); seed.full(80, v_105); Ok(()) }, 5u64 => { let [v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117]: [G; 10] = context.call::<10>(13, 121, &[v_1])?; seed.full(8, v_108); seed.full(16, v_109); seed.full(24, v_110); seed.full(32, v_111); seed.u8(165, v_112); seed.u8(166, v_113); seed.u8(167, v_114); seed.u8(168, v_115); seed.full(40, v_116); seed.full(48, v_117); Ok(()) }, 6u64 => { let [v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129]: [G; 10] = context.call::<10>(16, 121, &[v_1])?; seed.full(8, v_120); seed.full(16, v_121); seed.full(24, v_122); seed.full(32, v_123); seed.u8(165, v_124); seed.u8(166, v_125); seed.u8(167, v_126); seed.u8(168, v_127); seed.full(40, v_128); seed.full(48, v_129); Ok(()) }, 7u64 => { let [v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141]: [G; 10] = context.call::<10>(19, 121, &[v_1])?; seed.full(8, v_132); seed.full(16, v_133); seed.full(24, v_134); seed.full(32, v_135); seed.u8(165, v_136); seed.u8(166, v_137); seed.u8(167, v_138); seed.u8(168, v_139); seed.full(40, v_140); seed.full(48, v_141); Ok(()) }, _ => { Err(no_match(125, v_0)) }, } } - -fn write_125(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_0.as_canonical_u64() { 0u64 => { let [v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14]: [G; 13] = [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]), G::from_u64(seed[13]), G::from_u64(seed[14]), G::from_u64(seed[15])]; 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(); 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.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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]: [G; 45] = [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]), 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])]; row[offsets.auxiliaries + 1] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_27.as_canonical_u64(); 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(); row[offsets.auxiliaries + 22] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_60.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 11] = [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]), G::from_u64(seed[13])]; row[offsets.auxiliaries + 1] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_72.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85]: [G; 11] = [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]), G::from_u64(seed[13])]; row[offsets.auxiliaries + 1] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_85.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 4u64 => { let [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]: [G; 18] = [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]), 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 + 1] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_95.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_96.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_101.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_102.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_104.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_105.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117]: [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 + 1] = v_108.as_canonical_u64(); 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.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129]: [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 + 1] = v_120.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_121.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_122.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_123.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_125.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_126.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_128.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_129.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141]: [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 + 1] = v_132.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_135.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_136.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_138.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_140.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_141.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(125, v_0)) }, } } - -static SCHEMA_125: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, 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::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 164, 152, 8, 16, 24, 32, 165, 166, 167, 168, 40, 48, 56, 64, 72, 169, 170, 171, 156, 80, 88, 96, 172, 173, 174, 175, 176, 177, 104, 112, 178, 179, 180, 181, 182, 183, 120, 128, 184, 185, 186, 187, 188, 189, 136, 160, 144], bytes: 192 }; - -fn pack_128(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, 128, &[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, 760, &[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_128_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, 128, &[v_2])?; seed.full(24, v_5); seed.u32(40, v_6); let [v_7]: [G; 1] = context.call::<1>(2, 760, &[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 write_128(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_128: 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_130(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, 15, &[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, 15, &[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, 130, &[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(130, v_14)) }, } }, _ => { Err(no_match(130, v_3)) }, } } - -fn pack_130_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, 15, &[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, 15, &[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, 130, &[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(130, v_14)) }, } }, _ => { Err(no_match(130, v_3)) }, } } - -fn write_130(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(130, v_14)) }, } }, _ => { Err(no_match(130, v_3)) }, } } - -static SCHEMA_130: 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_135(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, 135, &[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(135, v_1)) }, } } - -fn pack_135_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, 135, &[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(135, v_1)) }, } } - -fn write_135(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(135, v_1)) }, } } - -static SCHEMA_135: 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_143(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_143_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 write_143(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_143: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 16, 20, 24, 8], bytes: 32 }; - -fn pack_145(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, 6, &[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(145, 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, 141, &[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, 15, &[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, 145, &[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, 16, &[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, 145, &[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(145, v_17)) }, } } - -fn pack_145_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, 6, &[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(145, 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, 141, &[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, 15, &[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, 145, &[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, 16, &[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, 145, &[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(145, v_17)) }, } } - -fn write_145(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(145, 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(145, v_17)) }, } } - -static SCHEMA_145: 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_154(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_154_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 write_154(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] = [Bytes2::or(&v_0, &v_8)]; row[offsets.auxiliaries + 1] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [Bytes2::or(&v_1, &v_9)]; row[offsets.auxiliaries + 2] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = [Bytes2::or(&v_2, &v_10)]; row[offsets.auxiliaries + 3] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = [Bytes2::or(&v_3, &v_11)]; row[offsets.auxiliaries + 4] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [Bytes2::or(&v_4, &v_12)]; row[offsets.auxiliaries + 5] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = [Bytes2::or(&v_5, &v_13)]; row[offsets.auxiliaries + 6] = v_21.as_canonical_u64(); let [v_22]: [G; 1] = [Bytes2::or(&v_6, &v_14)]; row[offsets.auxiliaries + 7] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = [Bytes2::or(&v_7, &v_15)]; row[offsets.auxiliaries + 8] = v_23.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } - -static SCHEMA_154: 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_155(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_155_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 write_155(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] = [Bytes2::xor(&v_0, &v_8)]; row[offsets.auxiliaries + 1] = v_16.as_canonical_u64(); let [v_17]: [G; 1] = [Bytes2::xor(&v_1, &v_9)]; row[offsets.auxiliaries + 2] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = [Bytes2::xor(&v_2, &v_10)]; row[offsets.auxiliaries + 3] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = [Bytes2::xor(&v_3, &v_11)]; row[offsets.auxiliaries + 4] = v_19.as_canonical_u64(); let [v_20]: [G; 1] = [Bytes2::xor(&v_4, &v_12)]; row[offsets.auxiliaries + 5] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = [Bytes2::xor(&v_5, &v_13)]; row[offsets.auxiliaries + 6] = v_21.as_canonical_u64(); let [v_22]: [G; 1] = [Bytes2::xor(&v_6, &v_14)]; row[offsets.auxiliaries + 7] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = [Bytes2::xor(&v_7, &v_15)]; row[offsets.auxiliaries + 8] = v_23.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } - -static SCHEMA_155: 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_157(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, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 10] = context.load::<10>(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(); 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(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21]: [G; 10] = context.load::<10>(1, v_1)?; 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(); 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(); match v_12.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_22]: [G; 1] = [G::from_u64(0)]; let [v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 8] = context.call::<8>(3, 154, &[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])?; seed[23] = v_23.as_canonical_u64(); seed[24] = v_24.as_canonical_u64(); seed[25] = v_25.as_canonical_u64(); seed[26] = v_26.as_canonical_u64(); seed[27] = v_27.as_canonical_u64(); seed[28] = v_28.as_canonical_u64(); seed[29] = v_29.as_canonical_u64(); seed[30] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = context.call::<1>(4, 157, &[v_11, v_21])?; seed[31] = v_31.as_canonical_u64(); let [v_32]: [G; 1] = context.store(5, &[v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31])?; seed[32] = v_32.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(157, v_12)) }, } }, _ => { Err(no_match(157, v_2)) }, } } - -fn pack_157_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, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 10] = context.load::<10>(0, v_0)?; seed.u8(36, v_2); seed.u8(37, v_3); seed.u8(38, v_4); seed.u8(39, v_5); seed.u8(40, v_6); seed.u8(41, v_7); seed.u8(42, v_8); seed.u8(43, v_9); seed.u8(44, v_10); seed.u32(24, v_11); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21]: [G; 10] = context.load::<10>(1, v_1)?; seed.u8(45, v_12); seed.u8(46, v_13); seed.u8(47, v_14); seed.u8(48, v_15); seed.u8(49, v_16); seed.u8(50, v_17); seed.u8(51, v_18); seed.u8(52, v_19); seed.u8(53, v_20); seed.u32(28, v_21); match v_12.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_22]: [G; 1] = [G::from_u64(0)]; let [v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 8] = context.call::<8>(3, 154, &[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])?; seed.u8(54, v_23); seed.u8(55, v_24); seed.u8(56, v_25); seed.u8(57, v_26); seed.u8(58, v_27); seed.u8(59, v_28); seed.u8(60, v_29); seed.u8(61, v_30); let [v_31]: [G; 1] = context.call::<1>(4, 157, &[v_11, v_21])?; seed.full(8, v_31); let [v_32]: [G; 1] = context.store(5, &[v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31])?; seed.u32(32, v_32); Ok(()) }, _ => { Err(no_match(157, v_12)) }, } }, _ => { Err(no_match(157, v_2)) }, } } - -fn write_157(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, v_6, v_7, v_8, v_9, v_10, v_11]: [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 + 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(); row[offsets.auxiliaries + 9] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_11.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21]: [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 + 11] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); match v_12.as_canonical_u64() { 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 8] = [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])]; row[offsets.auxiliaries + 21] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(seed[31])]; row[offsets.auxiliaries + 29] = v_31.as_canonical_u64(); let [v_32]: [G; 1] = [G::from_u64(seed[32])]; row[offsets.auxiliaries + 30] = v_32.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(157, v_12)) }, } }, _ => { Err(no_match(157, v_2)) }, } } - -static SCHEMA_157: 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::U32, 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::Full, SeedWidth::U32], offsets: &[0, 16, 20, 36, 37, 38, 39, 40, 41, 42, 43, 44, 24, 45, 46, 47, 48, 49, 50, 51, 52, 53, 28, 54, 55, 56, 57, 58, 59, 60, 61, 8, 32], bytes: 64 }; - -fn pack_158(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, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 10] = context.load::<10>(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(); 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(); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21]: [G; 10] = context.load::<10>(1, v_1)?; 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(); 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(); match v_12.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_22]: [G; 1] = [G::from_u64(0)]; let [v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 8] = context.call::<8>(3, 155, &[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])?; seed[23] = v_23.as_canonical_u64(); seed[24] = v_24.as_canonical_u64(); seed[25] = v_25.as_canonical_u64(); seed[26] = v_26.as_canonical_u64(); seed[27] = v_27.as_canonical_u64(); seed[28] = v_28.as_canonical_u64(); seed[29] = v_29.as_canonical_u64(); seed[30] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = context.call::<1>(4, 158, &[v_11, v_21])?; seed[31] = v_31.as_canonical_u64(); let [v_32]: [G; 1] = context.store(5, &[v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31])?; seed[32] = v_32.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(158, v_12)) }, } }, _ => { Err(no_match(158, v_2)) }, } } - -fn pack_158_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, v_6, v_7, v_8, v_9, v_10, v_11]: [G; 10] = context.load::<10>(0, v_0)?; seed.u8(36, v_2); seed.u8(37, v_3); seed.u8(38, v_4); seed.u8(39, v_5); seed.u8(40, v_6); seed.u8(41, v_7); seed.u8(42, v_8); seed.u8(43, v_9); seed.u8(44, v_10); seed.u32(24, v_11); match v_2.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21]: [G; 10] = context.load::<10>(1, v_1)?; seed.u8(45, v_12); seed.u8(46, v_13); seed.u8(47, v_14); seed.u8(48, v_15); seed.u8(49, v_16); seed.u8(50, v_17); seed.u8(51, v_18); seed.u8(52, v_19); seed.u8(53, v_20); seed.u32(28, v_21); match v_12.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_22]: [G; 1] = [G::from_u64(0)]; let [v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 8] = context.call::<8>(3, 155, &[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])?; seed.u8(54, v_23); seed.u8(55, v_24); seed.u8(56, v_25); seed.u8(57, v_26); seed.u8(58, v_27); seed.u8(59, v_28); seed.u8(60, v_29); seed.u8(61, v_30); let [v_31]: [G; 1] = context.call::<1>(4, 158, &[v_11, v_21])?; seed.full(8, v_31); let [v_32]: [G; 1] = context.store(5, &[v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31])?; seed.u32(32, v_32); Ok(()) }, _ => { Err(no_match(158, v_12)) }, } }, _ => { Err(no_match(158, v_2)) }, } } - -fn write_158(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, v_6, v_7, v_8, v_9, v_10, v_11]: [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 + 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(); row[offsets.auxiliaries + 9] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_11.as_canonical_u64(); match v_2.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21]: [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 + 11] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); match v_12.as_canonical_u64() { 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30]: [G; 8] = [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])]; row[offsets.auxiliaries + 21] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_30.as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(seed[31])]; row[offsets.auxiliaries + 29] = v_31.as_canonical_u64(); let [v_32]: [G; 1] = [G::from_u64(seed[32])]; row[offsets.auxiliaries + 30] = v_32.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(158, v_12)) }, } }, _ => { Err(no_match(158, v_2)) }, } } - -static SCHEMA_158: 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::U32, 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::Full, SeedWidth::U32], offsets: &[0, 16, 20, 36, 37, 38, 39, 40, 41, 42, 43, 44, 24, 45, 46, 47, 48, 49, 50, 51, 52, 53, 28, 54, 55, 56, 57, 58, 59, 60, 61, 8, 32], bytes: 64 }; - -fn pack_178(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_1)?; 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() { 3u64 => { let [v_7, v_8, v_9, v_10]: [G; 4] = context.load::<4>(1, v_4)?; 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_7.as_canonical_u64() { 2u64 => { let [v_11]: [G; 1] = context.call::<1>(2, 234, &[v_8])?; seed[12] = v_11.as_canonical_u64(); let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23]: [G; 12] = context.load::<12>(3, v_11)?; 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(); 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(); match v_12.as_canonical_u64() { 1u64 => { let [v_24]: [G; 1] = [G::from_u64(1)]; let [v_25]: [G; 1] = context.store(5, &[v_24, v_24, v_24])?; seed[25] = v_25.as_canonical_u64(); let [v_26]: [G; 1] = context.call::<1>(6, 283, &[v_15, v_25])?; seed[26] = v_26.as_canonical_u64(); let [v_27, v_28, v_29, v_30]: [G; 4] = context.load::<4>(7, v_26)?; seed[27] = v_27.as_canonical_u64(); seed[28] = v_28.as_canonical_u64(); seed[29] = v_29.as_canonical_u64(); seed[30] = v_30.as_canonical_u64(); match v_27.as_canonical_u64() { 4u64 => { let [v_31]: [G; 1] = [G::from_u64(0)]; let [v_32]: [G; 1] = context.call::<1>(9, 316, &[v_29, v_5, v_31])?; seed[31] = v_32.as_canonical_u64(); let [v_33]: [G; 1] = context.returned::<1>(10)?; seed[32] = v_33.as_canonical_u64(); Ok(()) }, _ => { let [v_34]: [G; 1] = [G::from_u64(3)]; let [v_35]: [G; 1] = [G::from_u64(0)]; let [v_36]: [G; 1] = context.store(13, &[v_34, v_26, v_5, v_35])?; seed[31] = v_36.as_canonical_u64(); let [v_37]: [G; 1] = context.returned::<1>(14)?; seed[32] = v_37.as_canonical_u64(); Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } } - -fn pack_178_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_1)?; seed.u8(180, v_3); seed.u32(140, v_4); seed.u32(144, v_5); seed.full(8, v_6); match v_3.as_canonical_u64() { 3u64 => { let [v_7, v_8, v_9, v_10]: [G; 4] = context.load::<4>(1, v_4)?; seed.u8(181, v_7); seed.u32(148, v_8); seed.full(16, v_9); seed.full(24, v_10); match v_7.as_canonical_u64() { 2u64 => { let [v_11]: [G; 1] = context.call::<1>(2, 234, &[v_8])?; seed.u32(152, v_11); let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23]: [G; 12] = context.load::<12>(3, v_11)?; seed.u8(182, v_12); seed.full(32, v_13); seed.u32(156, v_14); seed.u32(160, v_15); seed.full(40, v_16); seed.full(48, v_17); seed.full(56, v_18); seed.full(64, v_19); seed.full(72, v_20); seed.full(80, v_21); seed.full(88, v_22); seed.full(96, v_23); match v_12.as_canonical_u64() { 1u64 => { let [v_24]: [G; 1] = [G::from_u64(1)]; let [v_25]: [G; 1] = context.store(5, &[v_24, v_24, v_24])?; seed.u32(164, v_25); let [v_26]: [G; 1] = context.call::<1>(6, 283, &[v_15, v_25])?; seed.u32(168, v_26); let [v_27, v_28, v_29, v_30]: [G; 4] = context.load::<4>(7, v_26)?; seed.u8(183, v_27); seed.full(104, v_28); seed.u32(172, v_29); seed.full(112, v_30); match v_27.as_canonical_u64() { 4u64 => { let [v_31]: [G; 1] = [G::from_u64(0)]; let [v_32]: [G; 1] = context.call::<1>(9, 316, &[v_29, v_5, v_31])?; seed.u32(176, v_32); let [v_33]: [G; 1] = context.returned::<1>(10)?; seed.full(120, v_33); Ok(()) }, _ => { let [v_34]: [G; 1] = [G::from_u64(3)]; let [v_35]: [G; 1] = [G::from_u64(0)]; let [v_36]: [G; 1] = context.store(13, &[v_34, v_26, v_5, v_35])?; seed.u32(176, v_36); let [v_37]: [G; 1] = context.returned::<1>(14)?; seed.full(120, v_37); Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } }, _ => { Ok(()) }, } } - -fn write_178(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, 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() { 3u64 => { let [v_7, v_8, v_9, v_10]: [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 + 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(); match v_7.as_canonical_u64() { 2u64 => { let [v_11]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 9] = v_11.as_canonical_u64(); let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23]: [G; 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])]; row[offsets.auxiliaries + 10] = v_12.as_canonical_u64(); 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(); row[offsets.auxiliaries + 14] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_23.as_canonical_u64(); match v_12.as_canonical_u64() { 1u64 => { let [v_25]: [G; 1] = [G::from_u64(seed[25])]; row[offsets.auxiliaries + 22] = v_25.as_canonical_u64(); let [v_26]: [G; 1] = [G::from_u64(seed[26])]; row[offsets.auxiliaries + 23] = v_26.as_canonical_u64(); let [v_27, v_28, v_29, v_30]: [G; 4] = [G::from_u64(seed[27]), G::from_u64(seed[28]), G::from_u64(seed[29]), G::from_u64(seed[30])]; 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(); match v_27.as_canonical_u64() { 4u64 => { let [v_32]: [G; 1] = [G::from_u64(seed[31])]; row[offsets.auxiliaries + 28] = v_32.as_canonical_u64(); let [v_33]: [G; 1] = [G::from_u64(seed[32])]; row[offsets.auxiliaries + 29] = v_33.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 28] = (v_27 - G::from_u64(4)).inverse().as_canonical_u64(); let [v_36]: [G; 1] = [G::from_u64(seed[31])]; row[offsets.auxiliaries + 29] = v_36.as_canonical_u64(); let [v_37]: [G; 1] = [G::from_u64(seed[32])]; row[offsets.auxiliaries + 30] = v_37.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 22] = (v_12 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 9] = (v_7 - G::from_u64(2)).inverse().as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 5] = (v_3 - G::from_u64(3)).inverse().as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_178: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, 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::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 128, 132, 136, 180, 140, 144, 8, 181, 148, 16, 24, 152, 182, 32, 156, 160, 40, 48, 56, 64, 72, 80, 88, 96, 164, 168, 183, 104, 172, 112, 176, 120], bytes: 184 }; - -fn pack_201(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(201, v_2)) }, } } - -fn pack_201_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(201, v_2)) }, } } - -fn write_201(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(201, v_2)) }, } } - -static SCHEMA_201: 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_233(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]; match v_0.as_canonical_u64() { _ => { let [v_14]: [G; 1] = context.call::<1>(0, 232, &[v_0, v_1])?; seed[15] = v_14.as_canonical_u64(); match v_14.as_canonical_u64() { 0u64 => { let [v_15]: [G; 1] = [G::from_u64(1)]; let [v_16]: [G; 1] = context.store(2, &[v_15, v_15, v_15])?; seed[16] = v_16.as_canonical_u64(); Ok(()) }, _ => { let [v_17]: [G; 1] = context.returned::<1>(3)?; seed[16] = v_17.as_canonical_u64(); Ok(()) }, } }, } } - -fn pack_233_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]; match v_0.as_canonical_u64() { _ => { let [v_14]: [G; 1] = context.call::<1>(0, 232, &[v_0, v_1])?; seed.u8(106, v_14); match v_14.as_canonical_u64() { 0u64 => { let [v_15]: [G; 1] = [G::from_u64(1)]; let [v_16]: [G; 1] = context.store(2, &[v_15, v_15, v_15])?; seed.u32(100, v_16); Ok(()) }, _ => { let [v_17]: [G; 1] = context.returned::<1>(3)?; seed.u32(100, v_17); Ok(()) }, } }, } } - -fn write_233(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]); match v_0.as_canonical_u64() { _ => { let [v_14]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 1] = v_14.as_canonical_u64(); match v_14.as_canonical_u64() { 0u64 => { let [v_16]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 2] = v_16.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 2] = (v_14 - G::from_u64(0)).inverse().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 + 1] = G::ONE.as_canonical_u64(); }, } }, } } - -static SCHEMA_233: SeedSchema = SeedSchema { widths: &[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::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32], offsets: &[0, 104, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 105, 106, 100], bytes: 112 }; - -fn pack_236(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, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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; 48] = context.call::<48>(0, 228, &[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(); 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(); 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(); 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(); match v_2.as_canonical_u64() { _ => { match v_2.as_canonical_u64() { 8u64 => { let [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]: [G; 45] = context.call::<45>(1, 239, &[v_3, v_1])?; 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(); seed[58] = v_57.as_canonical_u64(); seed[59] = v_58.as_canonical_u64(); seed[60] = v_59.as_canonical_u64(); seed[61] = v_60.as_canonical_u64(); seed[62] = v_61.as_canonical_u64(); seed[63] = v_62.as_canonical_u64(); seed[64] = v_63.as_canonical_u64(); seed[65] = v_64.as_canonical_u64(); seed[66] = v_65.as_canonical_u64(); seed[67] = v_66.as_canonical_u64(); seed[68] = v_67.as_canonical_u64(); seed[69] = v_68.as_canonical_u64(); seed[70] = v_69.as_canonical_u64(); seed[71] = v_70.as_canonical_u64(); seed[72] = v_71.as_canonical_u64(); seed[73] = v_72.as_canonical_u64(); seed[74] = v_73.as_canonical_u64(); seed[75] = v_74.as_canonical_u64(); seed[76] = v_75.as_canonical_u64(); seed[77] = v_76.as_canonical_u64(); seed[78] = v_77.as_canonical_u64(); seed[79] = v_78.as_canonical_u64(); seed[80] = v_79.as_canonical_u64(); seed[81] = v_80.as_canonical_u64(); seed[82] = v_81.as_canonical_u64(); seed[83] = v_82.as_canonical_u64(); seed[84] = v_83.as_canonical_u64(); seed[85] = v_84.as_canonical_u64(); seed[86] = v_85.as_canonical_u64(); seed[87] = v_86.as_canonical_u64(); seed[88] = v_87.as_canonical_u64(); seed[89] = v_88.as_canonical_u64(); seed[90] = v_89.as_canonical_u64(); seed[91] = v_90.as_canonical_u64(); seed[92] = v_91.as_canonical_u64(); seed[93] = v_92.as_canonical_u64(); seed[94] = v_93.as_canonical_u64(); seed[95] = v_94.as_canonical_u64(); match v_50.as_canonical_u64() { 1u64 => { let [v_95]: [G; 1] = context.call::<1>(2, 242, &[v_3, v_0])?; seed[96] = v_95.as_canonical_u64(); let [v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107]: [G; 12] = context.call::<12>(3, 224, &[v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_0, v_1, v_47, v_48, v_95, v_49])?; seed[97] = v_96.as_canonical_u64(); seed[98] = v_97.as_canonical_u64(); seed[99] = v_98.as_canonical_u64(); seed[100] = v_99.as_canonical_u64(); seed[101] = v_100.as_canonical_u64(); seed[102] = v_101.as_canonical_u64(); seed[103] = v_102.as_canonical_u64(); seed[104] = v_103.as_canonical_u64(); seed[105] = v_104.as_canonical_u64(); seed[106] = v_105.as_canonical_u64(); seed[107] = v_106.as_canonical_u64(); seed[108] = v_107.as_canonical_u64(); let [v_108]: [G; 1] = context.store(4, &[v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107])?; seed[109] = v_108.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(236, v_50)) }, } }, _ => { Err(no_match(236, v_2)) }, } }, } } - -fn pack_236_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, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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; 48] = context.call::<48>(0, 228, &[v_0])?; seed.u8(337, v_2); seed.u32(288, v_3); seed.full(16, v_4); seed.full(24, v_5); seed.full(32, v_6); seed.u8(338, v_7); seed.u8(339, v_8); seed.u8(340, v_9); seed.u8(341, v_10); seed.full(40, v_11); seed.full(48, v_12); seed.full(56, v_13); seed.full(64, v_14); seed.u8(342, v_15); seed.u8(343, v_16); seed.u8(344, v_17); seed.u8(345, v_18); seed.u32(292, v_19); seed.u8(346, v_20); seed.full(72, v_21); seed.full(80, v_22); seed.u8(347, v_23); seed.u8(348, v_24); seed.u8(349, v_25); seed.u8(350, v_26); seed.u8(351, v_27); seed.u8(352, v_28); seed.full(88, v_29); seed.full(96, v_30); seed.u8(353, v_31); seed.u8(354, v_32); seed.u8(355, v_33); seed.u8(356, v_34); seed.u8(357, v_35); seed.u8(358, v_36); seed.full(104, v_37); seed.full(112, v_38); seed.u8(359, v_39); seed.u8(360, v_40); seed.u8(361, v_41); seed.u8(362, v_42); seed.u8(363, v_43); seed.u8(364, v_44); seed.full(120, v_45); seed.u32(296, v_46); seed.u32(300, v_47); seed.u32(304, v_48); seed.u32(308, v_49); match v_2.as_canonical_u64() { _ => { match v_2.as_canonical_u64() { 8u64 => { let [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]: [G; 45] = context.call::<45>(1, 239, &[v_3, v_1])?; seed.u8(365, v_50); seed.u8(366, v_51); seed.full(128, v_52); seed.full(136, v_53); seed.full(144, v_54); seed.u8(367, v_55); seed.u8(368, v_56); seed.u8(369, v_57); seed.u8(370, v_58); seed.u8(371, v_59); seed.full(152, v_60); seed.full(160, v_61); seed.full(168, v_62); seed.u8(372, v_63); seed.u8(373, v_64); seed.u8(374, v_65); seed.u8(375, v_66); seed.u8(376, v_67); seed.full(176, v_68); seed.full(184, v_69); seed.full(192, v_70); seed.u8(377, v_71); seed.u8(378, v_72); seed.u8(379, v_73); seed.u8(380, v_74); seed.u8(381, v_75); seed.u32(312, v_76); seed.u32(316, v_77); seed.full(200, v_78); seed.u8(382, v_79); seed.u8(383, v_80); seed.u8(384, v_81); seed.u8(385, v_82); seed.u8(386, v_83); seed.u8(387, v_84); seed.full(208, v_85); seed.full(216, v_86); seed.u8(388, v_87); seed.u8(389, v_88); seed.u8(390, v_89); seed.u8(391, v_90); seed.u8(392, v_91); seed.u8(393, v_92); seed.full(224, v_93); seed.u32(320, v_94); match v_50.as_canonical_u64() { 1u64 => { let [v_95]: [G; 1] = context.call::<1>(2, 242, &[v_3, v_0])?; seed.u32(324, v_95); let [v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107]: [G; 12] = context.call::<12>(3, 224, &[v_51, v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_0, v_1, v_47, v_48, v_95, v_49])?; seed.u8(394, v_96); seed.full(232, v_97); seed.u32(328, v_98); seed.full(240, v_99); seed.full(248, v_100); seed.full(256, v_101); seed.full(264, v_102); seed.full(272, v_103); seed.full(280, v_104); seed.u8(395, v_105); seed.u8(396, v_106); seed.u8(397, v_107); let [v_108]: [G; 1] = context.store(4, &[v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107])?; seed.u32(332, v_108); Ok(()) }, _ => { Err(no_match(236, v_50)) }, } }, _ => { Err(no_match(236, v_2)) }, } }, } } - -fn write_236(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, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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; 48] = [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]), 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])]; 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(); 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.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_49.as_canonical_u64(); match v_2.as_canonical_u64() { _ => { match v_2.as_canonical_u64() { 8u64 => { let [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]: [G; 45] = [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]), 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])]; row[offsets.auxiliaries + 49] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_94.as_canonical_u64(); match v_50.as_canonical_u64() { 1u64 => { let [v_95]: [G; 1] = [G::from_u64(seed[96])]; row[offsets.auxiliaries + 94] = v_95.as_canonical_u64(); let [v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107]: [G; 12] = [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])]; row[offsets.auxiliaries + 95] = v_96.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 100] = v_101.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_102.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 103] = v_104.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_105.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_106.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_107.as_canonical_u64(); let [v_108]: [G; 1] = [G::from_u64(seed[109])]; row[offsets.auxiliaries + 107] = v_108.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(236, v_50)) }, } }, _ => { Err(no_match(236, v_2)) }, } }, } } - -static SCHEMA_236: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32], offsets: &[0, 336, 8, 337, 288, 16, 24, 32, 338, 339, 340, 341, 40, 48, 56, 64, 342, 343, 344, 345, 292, 346, 72, 80, 347, 348, 349, 350, 351, 352, 88, 96, 353, 354, 355, 356, 357, 358, 104, 112, 359, 360, 361, 362, 363, 364, 120, 296, 300, 304, 308, 365, 366, 128, 136, 144, 367, 368, 369, 370, 371, 152, 160, 168, 372, 373, 374, 375, 376, 176, 184, 192, 377, 378, 379, 380, 381, 312, 316, 200, 382, 383, 384, 385, 386, 387, 208, 216, 388, 389, 390, 391, 392, 393, 224, 320, 324, 394, 232, 328, 240, 248, 256, 264, 272, 280, 395, 396, 397, 332], bytes: 400 }; - -fn pack_237(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, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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; 48] = context.call::<48>(0, 228, &[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(); 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(); 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(); 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(); match v_3.as_canonical_u64() { _ => { match v_3.as_canonical_u64() { 8u64 => { let [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]: [G; 45] = context.call::<45>(1, 239, &[v_4, v_1])?; 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(); seed[58] = v_57.as_canonical_u64(); seed[59] = v_58.as_canonical_u64(); seed[60] = v_59.as_canonical_u64(); seed[61] = v_60.as_canonical_u64(); seed[62] = v_61.as_canonical_u64(); seed[63] = v_62.as_canonical_u64(); seed[64] = v_63.as_canonical_u64(); seed[65] = v_64.as_canonical_u64(); seed[66] = v_65.as_canonical_u64(); seed[67] = v_66.as_canonical_u64(); seed[68] = v_67.as_canonical_u64(); seed[69] = v_68.as_canonical_u64(); seed[70] = v_69.as_canonical_u64(); seed[71] = v_70.as_canonical_u64(); seed[72] = v_71.as_canonical_u64(); seed[73] = v_72.as_canonical_u64(); seed[74] = v_73.as_canonical_u64(); seed[75] = v_74.as_canonical_u64(); seed[76] = v_75.as_canonical_u64(); seed[77] = v_76.as_canonical_u64(); seed[78] = v_77.as_canonical_u64(); seed[79] = v_78.as_canonical_u64(); seed[80] = v_79.as_canonical_u64(); seed[81] = v_80.as_canonical_u64(); seed[82] = v_81.as_canonical_u64(); seed[83] = v_82.as_canonical_u64(); seed[84] = v_83.as_canonical_u64(); seed[85] = v_84.as_canonical_u64(); seed[86] = v_85.as_canonical_u64(); seed[87] = v_86.as_canonical_u64(); seed[88] = v_87.as_canonical_u64(); seed[89] = v_88.as_canonical_u64(); seed[90] = v_89.as_canonical_u64(); seed[91] = v_90.as_canonical_u64(); seed[92] = v_91.as_canonical_u64(); seed[93] = v_92.as_canonical_u64(); seed[94] = v_93.as_canonical_u64(); seed[95] = v_94.as_canonical_u64(); seed[96] = v_95.as_canonical_u64(); match v_51.as_canonical_u64() { 1u64 => { match v_52.as_canonical_u64() { _ => { let [v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129]: [G; 34] = context.call::<34>(2, 223, &[v_78, v_2])?; seed[97] = v_96.as_canonical_u64(); seed[98] = v_97.as_canonical_u64(); seed[99] = v_98.as_canonical_u64(); seed[100] = v_99.as_canonical_u64(); seed[101] = v_100.as_canonical_u64(); seed[102] = v_101.as_canonical_u64(); seed[103] = v_102.as_canonical_u64(); seed[104] = v_103.as_canonical_u64(); seed[105] = v_104.as_canonical_u64(); seed[106] = v_105.as_canonical_u64(); seed[107] = v_106.as_canonical_u64(); seed[108] = v_107.as_canonical_u64(); seed[109] = v_108.as_canonical_u64(); seed[110] = v_109.as_canonical_u64(); seed[111] = v_110.as_canonical_u64(); seed[112] = v_111.as_canonical_u64(); seed[113] = v_112.as_canonical_u64(); seed[114] = v_113.as_canonical_u64(); seed[115] = v_114.as_canonical_u64(); seed[116] = v_115.as_canonical_u64(); seed[117] = v_116.as_canonical_u64(); seed[118] = v_117.as_canonical_u64(); seed[119] = v_118.as_canonical_u64(); seed[120] = v_119.as_canonical_u64(); seed[121] = v_120.as_canonical_u64(); seed[122] = v_121.as_canonical_u64(); seed[123] = v_122.as_canonical_u64(); seed[124] = v_123.as_canonical_u64(); seed[125] = v_124.as_canonical_u64(); seed[126] = v_125.as_canonical_u64(); seed[127] = v_126.as_canonical_u64(); seed[128] = v_127.as_canonical_u64(); seed[129] = v_128.as_canonical_u64(); seed[130] = v_129.as_canonical_u64(); let [v_130]: [G; 1] = context.call::<1>(3, 242, &[v_4, v_0])?; seed[131] = v_130.as_canonical_u64(); let [v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142]: [G; 12] = context.call::<12>(4, 225, &[v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_0, v_1, v_48, v_49, v_130, v_50])?; seed[132] = v_131.as_canonical_u64(); seed[133] = v_132.as_canonical_u64(); seed[134] = v_133.as_canonical_u64(); seed[135] = v_134.as_canonical_u64(); seed[136] = v_135.as_canonical_u64(); seed[137] = v_136.as_canonical_u64(); seed[138] = v_137.as_canonical_u64(); seed[139] = v_138.as_canonical_u64(); seed[140] = v_139.as_canonical_u64(); seed[141] = v_140.as_canonical_u64(); seed[142] = v_141.as_canonical_u64(); seed[143] = v_142.as_canonical_u64(); let [v_143]: [G; 1] = context.store(5, &[v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142])?; seed[144] = v_143.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(237, v_51)) }, } }, _ => { Err(no_match(237, v_3)) }, } }, } } - -fn pack_237_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, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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; 48] = context.call::<48>(0, 228, &[v_0])?; seed.u8(425, v_3); seed.u32(376, v_4); seed.full(24, v_5); seed.full(32, v_6); seed.full(40, v_7); seed.u8(426, v_8); seed.u8(427, v_9); seed.u8(428, v_10); seed.u8(429, v_11); seed.full(48, v_12); seed.full(56, v_13); seed.full(64, v_14); seed.full(72, v_15); seed.u8(430, v_16); seed.u8(431, v_17); seed.u8(432, v_18); seed.u8(433, v_19); seed.u32(380, v_20); seed.u8(434, v_21); seed.full(80, v_22); seed.full(88, v_23); seed.u8(435, v_24); seed.u8(436, v_25); seed.u8(437, v_26); seed.u8(438, v_27); seed.u8(439, v_28); seed.u8(440, v_29); seed.full(96, v_30); seed.full(104, v_31); seed.u8(441, v_32); seed.u8(442, v_33); seed.u8(443, v_34); seed.u8(444, v_35); seed.u8(445, v_36); seed.u8(446, v_37); seed.full(112, v_38); seed.full(120, v_39); seed.u8(447, v_40); seed.u8(448, v_41); seed.u8(449, v_42); seed.u8(450, v_43); seed.u8(451, v_44); seed.u8(452, v_45); seed.full(128, v_46); seed.u32(384, v_47); seed.u32(388, v_48); seed.u32(392, v_49); seed.u32(396, v_50); match v_3.as_canonical_u64() { _ => { match v_3.as_canonical_u64() { 8u64 => { let [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]: [G; 45] = context.call::<45>(1, 239, &[v_4, v_1])?; seed.u8(453, v_51); seed.u8(454, v_52); seed.full(136, v_53); seed.full(144, v_54); seed.full(152, v_55); seed.u8(455, v_56); seed.u8(456, v_57); seed.u8(457, v_58); seed.u8(458, v_59); seed.u8(459, v_60); seed.full(160, v_61); seed.full(168, v_62); seed.full(176, v_63); seed.u8(460, v_64); seed.u8(461, v_65); seed.u8(462, v_66); seed.u8(463, v_67); seed.u8(464, v_68); seed.full(184, v_69); seed.full(192, v_70); seed.full(200, v_71); seed.u8(465, v_72); seed.u8(466, v_73); seed.u8(467, v_74); seed.u8(468, v_75); seed.u8(469, v_76); seed.full(208, v_77); seed.u32(400, v_78); seed.full(216, v_79); seed.u8(470, v_80); seed.u8(471, v_81); seed.u8(472, v_82); seed.u8(473, v_83); seed.u8(474, v_84); seed.u8(475, v_85); seed.full(224, v_86); seed.full(232, v_87); seed.u8(476, v_88); seed.u8(477, v_89); seed.u8(478, v_90); seed.u8(479, v_91); seed.u8(480, v_92); seed.u8(481, v_93); seed.full(240, v_94); seed.u32(404, v_95); match v_51.as_canonical_u64() { 1u64 => { match v_52.as_canonical_u64() { _ => { let [v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129]: [G; 34] = context.call::<34>(2, 223, &[v_78, v_2])?; seed.full(248, v_96); seed.full(256, v_97); seed.full(264, v_98); seed.u8(482, v_99); seed.u8(483, v_100); seed.u8(484, v_101); seed.u8(485, v_102); seed.u8(486, v_103); seed.u8(487, v_104); seed.full(272, v_105); seed.full(280, v_106); seed.u8(488, v_107); seed.u8(489, v_108); seed.u8(490, v_109); seed.u8(491, v_110); seed.u8(492, v_111); seed.u8(493, v_112); seed.full(288, v_113); seed.full(296, v_114); seed.u8(494, v_115); seed.u8(495, v_116); seed.u8(496, v_117); seed.u8(497, v_118); seed.u8(498, v_119); seed.u8(499, v_120); seed.full(304, v_121); seed.full(312, v_122); seed.u8(500, v_123); seed.u8(501, v_124); seed.u8(502, v_125); seed.u8(503, v_126); seed.u8(504, v_127); seed.u8(505, v_128); seed.u32(408, v_129); let [v_130]: [G; 1] = context.call::<1>(3, 242, &[v_4, v_0])?; seed.u32(412, v_130); let [v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142]: [G; 12] = context.call::<12>(4, 225, &[v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129, v_0, v_1, v_48, v_49, v_130, v_50])?; seed.u8(506, v_131); seed.full(320, v_132); seed.u32(416, v_133); seed.full(328, v_134); seed.full(336, v_135); seed.full(344, v_136); seed.full(352, v_137); seed.full(360, v_138); seed.full(368, v_139); seed.u8(507, v_140); seed.u8(508, v_141); seed.u8(509, v_142); let [v_143]: [G; 1] = context.store(5, &[v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142])?; seed.u32(420, v_143); Ok(()) }, } }, _ => { Err(no_match(237, v_51)) }, } }, _ => { Err(no_match(237, v_3)) }, } }, } } - -fn write_237(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, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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; 48] = [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]), 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])]; 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(); 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(); row[offsets.auxiliaries + 14] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_50.as_canonical_u64(); match v_3.as_canonical_u64() { _ => { match v_3.as_canonical_u64() { 8u64 => { let [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]: [G; 45] = [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]), 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])]; row[offsets.auxiliaries + 49] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_95.as_canonical_u64(); match v_51.as_canonical_u64() { 1u64 => { match v_52.as_canonical_u64() { _ => { let [v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116, v_117, v_118, v_119, v_120, v_121, v_122, v_123, v_124, v_125, v_126, v_127, v_128, v_129]: [G; 34] = [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]), 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])]; row[offsets.auxiliaries + 94] = v_96.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_101.as_canonical_u64(); row[offsets.auxiliaries + 100] = v_102.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_104.as_canonical_u64(); row[offsets.auxiliaries + 103] = v_105.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_106.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_107.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_108.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_109.as_canonical_u64(); row[offsets.auxiliaries + 108] = v_110.as_canonical_u64(); row[offsets.auxiliaries + 109] = v_111.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_112.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_113.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_114.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_115.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_116.as_canonical_u64(); row[offsets.auxiliaries + 115] = v_117.as_canonical_u64(); row[offsets.auxiliaries + 116] = v_118.as_canonical_u64(); row[offsets.auxiliaries + 117] = v_119.as_canonical_u64(); row[offsets.auxiliaries + 118] = v_120.as_canonical_u64(); row[offsets.auxiliaries + 119] = v_121.as_canonical_u64(); row[offsets.auxiliaries + 120] = v_122.as_canonical_u64(); row[offsets.auxiliaries + 121] = v_123.as_canonical_u64(); row[offsets.auxiliaries + 122] = v_124.as_canonical_u64(); row[offsets.auxiliaries + 123] = v_125.as_canonical_u64(); row[offsets.auxiliaries + 124] = v_126.as_canonical_u64(); row[offsets.auxiliaries + 125] = v_127.as_canonical_u64(); row[offsets.auxiliaries + 126] = v_128.as_canonical_u64(); row[offsets.auxiliaries + 127] = v_129.as_canonical_u64(); let [v_130]: [G; 1] = [G::from_u64(seed[131])]; row[offsets.auxiliaries + 128] = v_130.as_canonical_u64(); let [v_131, v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141, v_142]: [G; 12] = [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])]; row[offsets.auxiliaries + 129] = v_131.as_canonical_u64(); row[offsets.auxiliaries + 130] = v_132.as_canonical_u64(); row[offsets.auxiliaries + 131] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 132] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 133] = v_135.as_canonical_u64(); row[offsets.auxiliaries + 134] = v_136.as_canonical_u64(); row[offsets.auxiliaries + 135] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 136] = v_138.as_canonical_u64(); row[offsets.auxiliaries + 137] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 138] = v_140.as_canonical_u64(); row[offsets.auxiliaries + 139] = v_141.as_canonical_u64(); row[offsets.auxiliaries + 140] = v_142.as_canonical_u64(); let [v_143]: [G; 1] = [G::from_u64(seed[144])]; row[offsets.auxiliaries + 141] = v_143.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(237, v_51)) }, } }, _ => { Err(no_match(237, v_3)) }, } }, } } - -static SCHEMA_237: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32], offsets: &[0, 424, 8, 16, 425, 376, 24, 32, 40, 426, 427, 428, 429, 48, 56, 64, 72, 430, 431, 432, 433, 380, 434, 80, 88, 435, 436, 437, 438, 439, 440, 96, 104, 441, 442, 443, 444, 445, 446, 112, 120, 447, 448, 449, 450, 451, 452, 128, 384, 388, 392, 396, 453, 454, 136, 144, 152, 455, 456, 457, 458, 459, 160, 168, 176, 460, 461, 462, 463, 464, 184, 192, 200, 465, 466, 467, 468, 469, 208, 400, 216, 470, 471, 472, 473, 474, 475, 224, 232, 476, 477, 478, 479, 480, 481, 240, 404, 248, 256, 264, 482, 483, 484, 485, 486, 487, 272, 280, 488, 489, 490, 491, 492, 493, 288, 296, 494, 495, 496, 497, 498, 499, 304, 312, 500, 501, 502, 503, 504, 505, 408, 412, 506, 320, 416, 328, 336, 344, 352, 360, 368, 507, 508, 509, 420], bytes: 512 }; - -fn pack_239(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, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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]: [G; 47] = context.load::<47>(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(); 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(); 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(); 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(); match v_2.as_canonical_u64() { 0u64 => { match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [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]: [G; 45] = context.returned::<45>(3)?; seed[50] = v_51.as_canonical_u64(); seed[51] = v_52.as_canonical_u64(); seed[52] = v_53.as_canonical_u64(); seed[53] = v_54.as_canonical_u64(); seed[54] = v_55.as_canonical_u64(); seed[55] = v_56.as_canonical_u64(); seed[56] = v_57.as_canonical_u64(); seed[57] = v_58.as_canonical_u64(); seed[58] = v_59.as_canonical_u64(); seed[59] = v_60.as_canonical_u64(); seed[60] = v_61.as_canonical_u64(); seed[61] = v_62.as_canonical_u64(); seed[62] = v_63.as_canonical_u64(); seed[63] = v_64.as_canonical_u64(); seed[64] = v_65.as_canonical_u64(); seed[65] = v_66.as_canonical_u64(); seed[66] = v_67.as_canonical_u64(); seed[67] = v_68.as_canonical_u64(); seed[68] = v_69.as_canonical_u64(); seed[69] = v_70.as_canonical_u64(); seed[70] = v_71.as_canonical_u64(); seed[71] = v_72.as_canonical_u64(); seed[72] = v_73.as_canonical_u64(); seed[73] = v_74.as_canonical_u64(); seed[74] = v_75.as_canonical_u64(); seed[75] = v_76.as_canonical_u64(); seed[76] = v_77.as_canonical_u64(); seed[77] = v_78.as_canonical_u64(); seed[78] = v_79.as_canonical_u64(); seed[79] = v_80.as_canonical_u64(); seed[80] = v_81.as_canonical_u64(); seed[81] = v_82.as_canonical_u64(); seed[82] = v_83.as_canonical_u64(); seed[83] = v_84.as_canonical_u64(); seed[84] = v_85.as_canonical_u64(); seed[85] = v_86.as_canonical_u64(); seed[86] = v_87.as_canonical_u64(); seed[87] = v_88.as_canonical_u64(); seed[88] = v_89.as_canonical_u64(); seed[89] = v_90.as_canonical_u64(); seed[90] = v_91.as_canonical_u64(); seed[91] = v_92.as_canonical_u64(); seed[92] = v_93.as_canonical_u64(); seed[93] = v_94.as_canonical_u64(); seed[94] = v_95.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(239, v_2)) }, } } - -fn pack_239_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, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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]: [G; 47] = context.load::<47>(0, v_0)?; seed.u8(272, v_2); seed.u8(273, v_3); seed.u8(274, v_4); seed.full(16, v_5); seed.full(24, v_6); seed.full(32, v_7); seed.u8(275, v_8); seed.u8(276, v_9); seed.u8(277, v_10); seed.u8(278, v_11); seed.u8(279, v_12); seed.full(40, v_13); seed.full(48, v_14); seed.full(56, v_15); seed.u8(280, v_16); seed.u8(281, v_17); seed.u8(282, v_18); seed.u8(283, v_19); seed.u8(284, v_20); seed.full(64, v_21); seed.full(72, v_22); seed.full(80, v_23); seed.u8(285, v_24); seed.u8(286, v_25); seed.u8(287, v_26); seed.u8(288, v_27); seed.u8(289, v_28); seed.full(88, v_29); seed.full(96, v_30); seed.full(104, v_31); seed.u8(290, v_32); seed.u8(291, v_33); seed.u8(292, v_34); seed.u8(293, v_35); seed.u8(294, v_36); seed.u8(295, v_37); seed.full(112, v_38); seed.full(120, v_39); seed.u8(296, v_40); seed.u8(297, v_41); seed.u8(298, v_42); seed.u8(299, v_43); seed.u8(300, v_44); seed.u8(301, v_45); seed.full(128, v_46); seed.u32(260, v_47); seed.u32(264, v_48); match v_2.as_canonical_u64() { 0u64 => { match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [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]: [G; 45] = context.returned::<45>(3)?; seed.u8(302, v_51); seed.u8(303, v_52); seed.full(136, v_53); seed.full(144, v_54); seed.full(152, v_55); seed.u8(304, v_56); seed.u8(305, v_57); seed.u8(306, v_58); seed.u8(307, v_59); seed.u8(308, v_60); seed.full(160, v_61); seed.full(168, v_62); seed.full(176, v_63); seed.u8(309, v_64); seed.u8(310, v_65); seed.u8(311, v_66); seed.u8(312, v_67); seed.u8(313, v_68); seed.full(184, v_69); seed.full(192, v_70); seed.full(200, v_71); seed.u8(314, v_72); seed.u8(315, v_73); seed.u8(316, v_74); seed.u8(317, v_75); seed.u8(318, v_76); seed.full(208, v_77); seed.full(216, v_78); seed.full(224, v_79); seed.u8(319, v_80); seed.u8(320, v_81); seed.u8(321, v_82); seed.u8(322, v_83); seed.u8(323, v_84); seed.u8(324, v_85); seed.full(232, v_86); seed.full(240, v_87); seed.u8(325, v_88); seed.u8(326, v_89); seed.u8(327, v_90); seed.u8(328, v_91); seed.u8(329, v_92); seed.u8(330, v_93); seed.full(248, v_94); seed.u32(268, v_95); Ok(()) }, } }, _ => { Err(no_match(239, v_2)) }, } } - -fn write_239(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, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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]: [G; 47] = [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]), 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])]; 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(); 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.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_48.as_canonical_u64(); match v_2.as_canonical_u64() { 0u64 => { match v_1.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 48] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); let [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]: [G; 45] = [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]), 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])]; row[offsets.auxiliaries + 49] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_95.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(239, v_2)) }, } } - -static SCHEMA_239: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 256, 8, 272, 273, 274, 16, 24, 32, 275, 276, 277, 278, 279, 40, 48, 56, 280, 281, 282, 283, 284, 64, 72, 80, 285, 286, 287, 288, 289, 88, 96, 104, 290, 291, 292, 293, 294, 295, 112, 120, 296, 297, 298, 299, 300, 301, 128, 260, 264, 302, 303, 136, 144, 152, 304, 305, 306, 307, 308, 160, 168, 176, 309, 310, 311, 312, 313, 184, 192, 200, 314, 315, 316, 317, 318, 208, 216, 224, 319, 320, 321, 322, 323, 324, 232, 240, 325, 326, 327, 328, 329, 330, 248, 268], bytes: 336 }; - -fn pack_241(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, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47]: [G; 45] = context.call::<45>(0, 239, &[v_0, v_2])?; 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(); 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(); 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(); 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(); let [v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55]: [G; 8] = context.call::<8>(1, 240, &[v_2])?; 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(); let [v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106]: [G; 45] = 'yield_0: { match v_3.as_canonical_u64() { 0u64 => { let [v_56]: [G; 1] = [G::from_u64(7)]; let [v_57]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_56, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_1, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57]; }, 1u64 => { let [v_58]: [G; 1] = [G::from_u64(6)]; let [v_59]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_58, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_1, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59]; }, 2u64 => { let [v_60]: [G; 1] = [G::from_u64(5)]; let [v_61]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_60, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_1, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61]; }, _ => { return Err(no_match(241, v_3)); }, } }; let [v_107]: [G; 1] = [G::from_u64(1)]; let [v_108]: [G; 1] = context.store(9, &[v_107, v_107, v_107])?; seed[57] = v_108.as_canonical_u64(); let [v_109]: [G; 1] = context.call::<1>(10, 82, &[v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_108, v_108, v_108, v_108])?; seed[58] = v_109.as_canonical_u64(); let [v_110]: [G; 1] = context.returned::<1>(11)?; seed[59] = v_110.as_canonical_u64(); Ok(()) } - -fn pack_241_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, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47]: [G; 45] = context.call::<45>(0, 239, &[v_0, v_2])?; seed.u8(157, v_3); seed.u8(158, v_4); seed.full(16, v_5); seed.full(24, v_6); seed.full(32, v_7); seed.u8(159, v_8); seed.u8(160, v_9); seed.u8(161, v_10); seed.u8(162, v_11); seed.u8(163, v_12); seed.full(40, v_13); seed.full(48, v_14); seed.full(56, v_15); seed.u8(164, v_16); seed.u8(165, v_17); seed.u8(166, v_18); seed.u8(167, v_19); seed.u8(168, v_20); seed.full(64, v_21); seed.full(72, v_22); seed.full(80, v_23); seed.u8(169, v_24); seed.u8(170, v_25); seed.u8(171, v_26); seed.u8(172, v_27); seed.u8(173, v_28); seed.full(88, v_29); seed.full(96, v_30); seed.full(104, v_31); seed.u8(174, v_32); seed.u8(175, v_33); seed.u8(176, v_34); seed.u8(177, v_35); seed.u8(178, v_36); seed.u8(179, v_37); seed.full(112, v_38); seed.full(120, v_39); seed.u8(180, v_40); seed.u8(181, v_41); seed.u8(182, v_42); seed.u8(183, v_43); seed.u8(184, v_44); seed.u8(185, v_45); seed.full(128, v_46); seed.u32(140, v_47); let [v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55]: [G; 8] = context.call::<8>(1, 240, &[v_2])?; seed.u8(186, v_48); seed.u8(187, v_49); seed.u8(188, v_50); seed.u8(189, v_51); seed.u8(190, v_52); seed.u8(191, v_53); seed.u8(192, v_54); seed.u8(193, v_55); let [v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106]: [G; 45] = 'yield_0: { match v_3.as_canonical_u64() { 0u64 => { let [v_56]: [G; 1] = [G::from_u64(7)]; let [v_57]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_56, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_1, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57]; }, 1u64 => { let [v_58]: [G; 1] = [G::from_u64(6)]; let [v_59]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_58, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_1, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59]; }, 2u64 => { let [v_60]: [G; 1] = [G::from_u64(5)]; let [v_61]: [G; 1] = [G::from_u64(0)]; break 'yield_0 [v_60, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_1, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61]; }, _ => { return Err(no_match(241, v_3)); }, } }; let [v_107]: [G; 1] = [G::from_u64(1)]; let [v_108]: [G; 1] = context.store(9, &[v_107, v_107, v_107])?; seed.u32(144, v_108); let [v_109]: [G; 1] = context.call::<1>(10, 82, &[v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106, v_108, v_108, v_108, v_108])?; seed.u32(148, v_109); let [v_110]: [G; 1] = context.returned::<1>(11)?; seed.u32(152, v_110); Ok(()) } - -fn write_241(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, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47]: [G; 45] = [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]), 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])]; 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(); 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(); row[offsets.auxiliaries + 14] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_47.as_canonical_u64(); let [v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55]: [G; 8] = [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])]; row[offsets.auxiliaries + 46] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_55.as_canonical_u64(); let [v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101, v_102, v_103, v_104, v_105, v_106]: [G; 45] = 'yield_0: { match v_3.as_canonical_u64() { 0u64 => { let [v_56]: [G; 1] = [G::from_u64(7)]; let [v_57]: [G; 1] = [G::from_u64(0)]; row[offsets.selectors] = G::ONE.as_canonical_u64(); break 'yield_0 [v_56, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_1, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57, v_57]; }, 1u64 => { let [v_58]: [G; 1] = [G::from_u64(6)]; let [v_59]: [G; 1] = [G::from_u64(0)]; row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 [v_58, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_1, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59, v_59]; }, 2u64 => { let [v_60]: [G; 1] = [G::from_u64(5)]; let [v_61]: [G; 1] = [G::from_u64(0)]; row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 [v_60, v_48, v_49, v_50, v_51, v_52, v_53, v_54, v_55, v_1, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61, v_61]; }, _ => { return Err(no_match(241, v_3)); }, } }; 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(); row[offsets.auxiliaries + 65] = v_73.as_canonical_u64(); 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(); row[offsets.auxiliaries + 74] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_95.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_96.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_101.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_102.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_103.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_104.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_105.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_106.as_canonical_u64(); let [v_108]: [G; 1] = [G::from_u64(seed[57])]; row[offsets.auxiliaries + 99] = v_108.as_canonical_u64(); let [v_109]: [G; 1] = [G::from_u64(seed[58])]; row[offsets.auxiliaries + 100] = v_109.as_canonical_u64(); let [v_110]: [G; 1] = [G::from_u64(seed[59])]; row[offsets.auxiliaries + 101] = v_110.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) } - -static SCHEMA_241: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 136, 156, 8, 157, 158, 16, 24, 32, 159, 160, 161, 162, 163, 40, 48, 56, 164, 165, 166, 167, 168, 64, 72, 80, 169, 170, 171, 172, 173, 88, 96, 104, 174, 175, 176, 177, 178, 179, 112, 120, 180, 181, 182, 183, 184, 185, 128, 140, 186, 187, 188, 189, 190, 191, 192, 193, 144, 148, 152], bytes: 200 }; - -fn pack_288(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, 288, &[v_2])?; seed[6] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = context.call::<1>(7, 288, &[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, 288, &[v_2])?; seed[6] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = context.call::<1>(10, 288, &[v_3])?; seed[7] = v_14.as_canonical_u64(); let [v_15]: [G; 1] = context.call::<1>(11, 291, &[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, 288, &[v_2])?; seed[6] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = context.call::<1>(14, 288, &[v_3])?; seed[7] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = context.call::<1>(15, 291, &[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(288, v_1)) }, } } - -fn pack_288_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, 288, &[v_2])?; seed.full(8, v_10); let [v_11]: [G; 1] = context.call::<1>(7, 288, &[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, 288, &[v_2])?; seed.full(8, v_13); let [v_14]: [G; 1] = context.call::<1>(10, 288, &[v_3])?; seed.full(16, v_14); let [v_15]: [G; 1] = context.call::<1>(11, 291, &[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, 288, &[v_2])?; seed.full(8, v_17); let [v_18]: [G; 1] = context.call::<1>(14, 288, &[v_3])?; seed.full(16, v_18); let [v_19]: [G; 1] = context.call::<1>(15, 291, &[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(288, v_1)) }, } } - -fn write_288(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(288, v_1)) }, } } - -static SCHEMA_288: 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_293(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 => { Ok(()) }, 2u64 => { Ok(()) }, 7u64 => { Ok(()) }, 3u64 => { let [v_11]: [G; 1] = context.call::<1>(5, 293, &[v_4, v_1, v_2])?; seed[8] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_13]: [G; 1] = context.returned::<1>(7)?; seed[9] = v_13.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(293, v_11)) }, } }, 4u64 => { let [v_14]: [G; 1] = context.returned::<1>(8)?; seed[8] = v_14.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_15]: [G; 1] = context.returned::<1>(9)?; seed[8] = v_15.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_16]: [G; 1] = context.returned::<1>(10)?; seed[8] = v_16.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_17]: [G; 1] = context.returned::<1>(11)?; seed[8] = v_17.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(293, v_3)) }, } } - -fn pack_293_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 => { let [v_7]: [G; 1] = context.returned::<1>(1)?; seed.u8(33, v_7); Ok(()) }, 1u64 => { Ok(()) }, 2u64 => { Ok(()) }, 7u64 => { Ok(()) }, 3u64 => { let [v_11]: [G; 1] = context.call::<1>(5, 293, &[v_4, v_1, v_2])?; seed.u8(33, v_11); match v_11.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_13]: [G; 1] = context.returned::<1>(7)?; seed.u8(34, v_13); Ok(()) }, _ => { Err(no_match(293, v_11)) }, } }, 4u64 => { let [v_14]: [G; 1] = context.returned::<1>(8)?; seed.u8(33, v_14); Ok(()) }, 5u64 => { let [v_15]: [G; 1] = context.returned::<1>(9)?; seed.u8(33, v_15); Ok(()) }, 6u64 => { let [v_16]: [G; 1] = context.returned::<1>(10)?; seed.u8(33, v_16); Ok(()) }, 8u64 => { let [v_17]: [G; 1] = context.returned::<1>(11)?; seed.u8(33, v_17); Ok(()) }, _ => { Err(no_match(293, v_3)) }, } } - -fn write_293(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 => { 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_11]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_13]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_13.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(293, v_11)) }, } }, 4u64 => { let [v_14]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_14.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_15]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_15.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_16]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_16.as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_17]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_17.as_canonical_u64(); row[offsets.selectors + 9] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(293, v_3)) }, } } - -static SCHEMA_293: 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_302(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, 288, &[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_302_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, 288, &[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 write_302(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_302: 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_303(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, 302, &[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, 302, &[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(303, v_2)) }, } } - -fn pack_303_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, 302, &[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, 302, &[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(303, v_2)) }, } } - -fn write_303(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(303, 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(303, v_2)) }, } } - -static SCHEMA_303: 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_310(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, 288, &[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(310, v_4)) }, } }, } } - -fn pack_310_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, 288, &[v_0])?; seed.u32(24, v_3); let [v_4]: [G; 1] = context.call::<1>(1, 0, &[v_2, v_3])?; seed.u8(32, v_4); match v_4.as_canonical_u64() { 0u64 => { Ok(()) }, 1u64 => { let [v_5]: [G; 1] = context.returned::<1>(2)?; seed.u32(28, v_5); Ok(()) }, _ => { Err(no_match(310, v_4)) }, } }, } } - -fn write_310(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(310, v_4)) }, } }, } } - -static SCHEMA_310: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32], offsets: &[0, 16, 8, 20, 24, 32, 28], bytes: 40 }; - -fn pack_311(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] = [G::from_u64(0)]; let [v_8]: [G; 1] = [v_4 - v_1]; let [v_9]: [G; 1] = context.store(3, &[v_7, v_8, v_7, v_7])?; seed[8] = v_9.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_10]: [G; 1] = [G::from_u64(1)]; let [v_11]: [G; 1] = [G::from_u64(0)]; let [v_12]: [G; 1] = context.store(6, &[v_10, v_4, v_11, v_11])?; seed[8] = v_12.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_13]: [G; 1] = [G::from_u64(2)]; let [v_14]: [G; 1] = [G::from_u64(0)]; let [v_15]: [G; 1] = context.store(9, &[v_13, v_4, v_5, v_14])?; seed[8] = v_15.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_16]: [G; 1] = [G::from_u64(3)]; let [v_17]: [G; 1] = context.call::<1>(11, 310, &[v_4, v_1, v_2])?; seed[8] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = context.call::<1>(12, 310, &[v_5, v_1, v_2])?; seed[9] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = [G::from_u64(0)]; let [v_20]: [G; 1] = context.store(14, &[v_16, v_17, v_18, v_19])?; seed[10] = v_20.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_21]: [G; 1] = [G::from_u64(4)]; let [v_22]: [G; 1] = context.call::<1>(16, 310, &[v_4, v_1, v_2])?; seed[8] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = [G::from_u64(1)]; let [v_24]: [G; 1] = [v_2 + v_23]; let [v_25]: [G; 1] = context.call::<1>(19, 310, &[v_5, v_1, v_24])?; seed[9] = v_25.as_canonical_u64(); let [v_26]: [G; 1] = [G::from_u64(0)]; let [v_27]: [G; 1] = context.store(21, &[v_21, v_22, v_25, v_26])?; seed[10] = v_27.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_28]: [G; 1] = [G::from_u64(5)]; let [v_29]: [G; 1] = context.call::<1>(23, 310, &[v_4, v_1, v_2])?; seed[8] = v_29.as_canonical_u64(); let [v_30]: [G; 1] = [G::from_u64(1)]; let [v_31]: [G; 1] = [v_2 + v_30]; let [v_32]: [G; 1] = context.call::<1>(26, 310, &[v_5, v_1, v_31])?; seed[9] = v_32.as_canonical_u64(); let [v_33]: [G; 1] = [G::from_u64(0)]; let [v_34]: [G; 1] = context.store(28, &[v_28, v_29, v_32, v_33])?; seed[10] = v_34.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_35]: [G; 1] = context.returned::<1>(29)?; seed[8] = v_35.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_36]: [G; 1] = [G::from_u64(7)]; let [v_37]: [G; 1] = [G::from_u64(0)]; let [v_38]: [G; 1] = context.store(32, &[v_36, v_4, v_5, v_37])?; seed[8] = v_38.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_39]: [G; 1] = [G::from_u64(8)]; let [v_40]: [G; 1] = context.call::<1>(34, 310, &[v_6, v_1, v_2])?; seed[8] = v_40.as_canonical_u64(); let [v_41]: [G; 1] = context.store(35, &[v_39, v_4, v_5, v_40])?; seed[9] = v_41.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(311, v_3)) }, } } - -fn pack_311_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(56, v_3); seed.u32(40, v_4); seed.u32(44, v_5); seed.u32(48, v_6); match v_3.as_canonical_u64() { 0u64 => { let [v_7]: [G; 1] = [G::from_u64(0)]; let [v_8]: [G; 1] = [v_4 - v_1]; let [v_9]: [G; 1] = context.store(3, &[v_7, v_8, v_7, v_7])?; seed.full(16, v_9); Ok(()) }, 1u64 => { let [v_10]: [G; 1] = [G::from_u64(1)]; let [v_11]: [G; 1] = [G::from_u64(0)]; let [v_12]: [G; 1] = context.store(6, &[v_10, v_4, v_11, v_11])?; seed.full(16, v_12); Ok(()) }, 2u64 => { let [v_13]: [G; 1] = [G::from_u64(2)]; let [v_14]: [G; 1] = [G::from_u64(0)]; let [v_15]: [G; 1] = context.store(9, &[v_13, v_4, v_5, v_14])?; seed.full(16, v_15); Ok(()) }, 3u64 => { let [v_16]: [G; 1] = [G::from_u64(3)]; let [v_17]: [G; 1] = context.call::<1>(11, 310, &[v_4, v_1, v_2])?; seed.full(16, v_17); let [v_18]: [G; 1] = context.call::<1>(12, 310, &[v_5, v_1, v_2])?; seed.full(24, v_18); let [v_19]: [G; 1] = [G::from_u64(0)]; let [v_20]: [G; 1] = context.store(14, &[v_16, v_17, v_18, v_19])?; seed.u32(52, v_20); Ok(()) }, 4u64 => { let [v_21]: [G; 1] = [G::from_u64(4)]; let [v_22]: [G; 1] = context.call::<1>(16, 310, &[v_4, v_1, v_2])?; seed.full(16, v_22); let [v_23]: [G; 1] = [G::from_u64(1)]; let [v_24]: [G; 1] = [v_2 + v_23]; let [v_25]: [G; 1] = context.call::<1>(19, 310, &[v_5, v_1, v_24])?; seed.full(24, v_25); let [v_26]: [G; 1] = [G::from_u64(0)]; let [v_27]: [G; 1] = context.store(21, &[v_21, v_22, v_25, v_26])?; seed.u32(52, v_27); Ok(()) }, 5u64 => { let [v_28]: [G; 1] = [G::from_u64(5)]; let [v_29]: [G; 1] = context.call::<1>(23, 310, &[v_4, v_1, v_2])?; seed.full(16, v_29); let [v_30]: [G; 1] = [G::from_u64(1)]; let [v_31]: [G; 1] = [v_2 + v_30]; let [v_32]: [G; 1] = context.call::<1>(26, 310, &[v_5, v_1, v_31])?; seed.full(24, v_32); let [v_33]: [G; 1] = [G::from_u64(0)]; let [v_34]: [G; 1] = context.store(28, &[v_28, v_29, v_32, v_33])?; seed.u32(52, v_34); Ok(()) }, 6u64 => { let [v_35]: [G; 1] = context.returned::<1>(29)?; seed.full(16, v_35); Ok(()) }, 7u64 => { let [v_36]: [G; 1] = [G::from_u64(7)]; let [v_37]: [G; 1] = [G::from_u64(0)]; let [v_38]: [G; 1] = context.store(32, &[v_36, v_4, v_5, v_37])?; seed.full(16, v_38); Ok(()) }, 8u64 => { let [v_39]: [G; 1] = [G::from_u64(8)]; let [v_40]: [G; 1] = context.call::<1>(34, 310, &[v_6, v_1, v_2])?; seed.full(16, v_40); let [v_41]: [G; 1] = context.store(35, &[v_39, v_4, v_5, v_40])?; seed.full(24, v_41); Ok(()) }, _ => { Err(no_match(311, v_3)) }, } } - -fn write_311(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_9]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_9.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 1u64 => { let [v_12]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_12.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 2u64 => { let [v_15]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_15.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, 3u64 => { let [v_17]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_17.as_canonical_u64(); let [v_18]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_18.as_canonical_u64(); let [v_20]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_20.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_22]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_22.as_canonical_u64(); let [v_25]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_25.as_canonical_u64(); let [v_27]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_27.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 5u64 => { let [v_29]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_29.as_canonical_u64(); let [v_32]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_32.as_canonical_u64(); let [v_34]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_34.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_35]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_35.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_38]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_38.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, 8u64 => { let [v_40]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 5] = v_40.as_canonical_u64(); let [v_41]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 6] = v_41.as_canonical_u64(); row[offsets.selectors + 8] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(311, v_3)) }, } } - -static SCHEMA_311: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 32, 8, 36, 56, 40, 44, 48, 16, 24, 52], bytes: 64 }; - -fn pack_318(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(318, v_3)) }, } } - -fn pack_318_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(318, v_3)) }, } } - -fn write_318(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(318, v_3)) }, } } - -static SCHEMA_318: 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_320(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, 775, &[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, 288, &[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, 293, &[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(320, v_5)) }, } }, } } - -fn pack_320_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, 775, &[v_1])?; seed.full(8, v_3); match v_3.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_4]: [G; 1] = context.call::<1>(1, 288, &[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, 293, &[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(320, v_5)) }, } }, } } - -fn write_320(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(320, v_5)) }, } }, } } - -static SCHEMA_320: 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_321(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, 775, &[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, 768, &[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(321, v_5)) }, } } - -fn pack_321_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, 775, &[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, 768, &[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(321, v_5)) }, } } - -fn write_321(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(321, v_5)) }, } } - -static SCHEMA_321: 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_322(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, 320, &[v_4, v_1, v_2])?; seed[8] = v_15.as_canonical_u64(); let [v_16]: [G; 1] = context.call::<1>(10, 320, &[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, 320, &[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, 320, &[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, 320, &[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, 320, &[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, 320, &[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(322, v_3)) }, } } - -fn pack_322_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, 320, &[v_4, v_1, v_2])?; seed.full(8, v_15); let [v_16]: [G; 1] = context.call::<1>(10, 320, &[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, 320, &[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, 320, &[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, 320, &[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, 320, &[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, 320, &[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(322, v_3)) }, } } - -fn write_322(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(322, v_3)) }, } } - -static SCHEMA_322: 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_382(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 op_0 = u32_less_than(v_1, v_2); let [v_4]: [G; 1] = [op_0.0]; match v_4.as_canonical_u64() { 1u64 => { let [v_5]: [G; 1] = context.returned::<1>(1)?; seed[5] = v_5.as_canonical_u64(); Ok(()) }, _ => { let [v_6]: [G; 1] = context.returned::<1>(2)?; seed[5] = v_6.as_canonical_u64(); Ok(()) }, } } - -fn pack_382_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 op_0 = u32_less_than(v_1, v_2); let [v_4]: [G; 1] = [op_0.0]; match v_4.as_canonical_u64() { 1u64 => { let [v_5]: [G; 1] = context.returned::<1>(1)?; seed.u8(24, v_5); Ok(()) }, _ => { let [v_6]: [G; 1] = context.returned::<1>(2)?; seed.u8(24, v_6); Ok(()) }, } } - -fn write_382(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 op_0 = u32_less_than(v_1, v_2); let [v_4]: [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_4.as_canonical_u64() { 1u64 => { let [v_5]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 7] = v_5.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 7] = (v_4 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_6]: [G; 1] = [G::from_u64(seed[5])]; row[offsets.auxiliaries + 8] = v_6.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_382: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8], offsets: &[0, 8, 12, 16, 20, 24], bytes: 32 }; - -fn pack_388(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, 386, &[v_0, v_1])?; seed[5] = v_4.as_canonical_u64(); let [v_5]: [G; 1] = context.call::<1>(1, 386, &[v_0, v_2])?; seed[6] = v_5.as_canonical_u64(); let [v_6]: [G; 1] = [v_4 * v_5]; match v_6.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_8, v_9, v_10]: [G; 3] = context.call::<3>(4, 387, &[v_0, v_1])?; seed[7] = v_8.as_canonical_u64(); seed[8] = v_9.as_canonical_u64(); seed[9] = v_10.as_canonical_u64(); let [v_11, v_12, v_13]: [G; 3] = context.call::<3>(5, 387, &[v_0, v_2])?; seed[10] = v_11.as_canonical_u64(); seed[11] = v_12.as_canonical_u64(); seed[12] = v_13.as_canonical_u64(); let [v_14]: [G; 1] = [v_8 * v_11]; match v_14.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_16]: [G; 1] = context.call::<1>(8, 285, &[v_10, v_13])?; seed[13] = v_16.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_19]: [G; 1] = context.call::<1>(11, 380, &[v_0, v_9, v_12, v_3])?; seed[14] = v_19.as_canonical_u64(); Ok(()) }, } }, } }, } } - -fn pack_388_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, 386, &[v_0, v_1])?; seed.u8(40, v_4); let [v_5]: [G; 1] = context.call::<1>(1, 386, &[v_0, v_2])?; seed.u8(41, v_5); let [v_6]: [G; 1] = [v_4 * v_5]; match v_6.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_8, v_9, v_10]: [G; 3] = context.call::<3>(4, 387, &[v_0, v_1])?; seed.u8(42, v_8); seed.u32(24, v_9); seed.u32(28, v_10); let [v_11, v_12, v_13]: [G; 3] = context.call::<3>(5, 387, &[v_0, v_2])?; seed.u8(43, v_11); seed.u32(32, v_12); seed.u32(36, v_13); let [v_14]: [G; 1] = [v_8 * v_11]; match v_14.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_16]: [G; 1] = context.call::<1>(8, 285, &[v_10, v_13])?; seed.u8(44, v_16); match v_16.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_19]: [G; 1] = context.call::<1>(11, 380, &[v_0, v_9, v_12, v_3])?; seed.u8(45, v_19); Ok(()) }, } }, } }, } } - -fn write_388(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(); let [v_6]: [G; 1] = [v_4 * v_5]; row[offsets.auxiliaries + 3] = v_6.as_canonical_u64(); match v_6.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 4] = (v_6 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_8, v_9, v_10]: [G; 3] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9])]; 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(); let [v_11, v_12, v_13]: [G; 3] = [G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12])]; 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(); let [v_14]: [G; 1] = [v_8 * v_11]; row[offsets.auxiliaries + 11] = v_14.as_canonical_u64(); match v_14.as_canonical_u64() { 0u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 12] = (v_14 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_16]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 13] = v_16.as_canonical_u64(); match v_16.as_canonical_u64() { 0u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 14] = (v_16 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_19]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 15] = v_19.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); }, } }, } }, } } - -static SCHEMA_388: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, 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, 20, 40, 41, 42, 24, 28, 43, 32, 36, 44, 45], bytes: 48 }; - -fn pack_418(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, v_6]: [G; 2] = context.call::<2>(0, 425, &[v_2])?; seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { let [v_7]: [G; 1] = context.call::<1>(1, 365, &[v_0, v_6, v_4])?; seed[8] = v_7.as_canonical_u64(); let [v_10, v_11, v_12]: [G; 3] = context.returned::<3>(4)?; seed[9] = v_10.as_canonical_u64(); seed[10] = v_11.as_canonical_u64(); seed[11] = v_12.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } } - -fn pack_418_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, v_6]: [G; 2] = context.call::<2>(0, 425, &[v_2])?; seed.u8(56, v_5); seed.u32(48, v_6); match v_5.as_canonical_u64() { 1u64 => { let [v_7]: [G; 1] = context.call::<1>(1, 365, &[v_0, v_6, v_4])?; seed.u32(52, v_7); let [v_10, v_11, v_12]: [G; 3] = context.returned::<3>(4)?; seed.u8(57, v_10); seed.full(16, v_11); seed.full(24, v_12); Ok(()) }, _ => { Ok(()) }, } } - -fn write_418(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, v_6]: [G; 2] = [G::from_u64(seed[6]), G::from_u64(seed[7])]; row[offsets.auxiliaries + 1] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_6.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { let [v_7]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 3] = v_7.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 + 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.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 3] = (v_5 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_418: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 32, 36, 40, 8, 44, 56, 48, 52, 57, 16, 24], bytes: 64 }; - -fn pack_443(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, v_6, v_7]: [G; 3] = context.load::<3>(0, v_2)?; seed[6] = v_5.as_canonical_u64(); seed[7] = v_6.as_canonical_u64(); seed[8] = v_7.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { let [v_8]: [G; 1] = context.call::<1>(1, 775, &[v_3])?; seed[9] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_10]: [G; 1] = context.returned::<1>(3)?; seed[10] = v_10.as_canonical_u64(); Ok(()) }, } }, 0u64 => { let [v_11, v_12, v_13, v_14]: [G; 4] = context.load::<4>(4, v_1)?; 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(); match v_11.as_canonical_u64() { 5u64 => { let [v_15]: [G; 1] = context.call::<1>(5, 775, &[v_3])?; seed[13] = v_15.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_15.as_canonical_u64() { 0u64 => { break 'yield_0 []; }, _ => { let [v_16]: [G; 1] = [G::from_u64(0)]; let [v_17]: [G; 1] = context.call::<1>(7, 320, &[v_12, v_3, v_16])?; seed[14] = v_17.as_canonical_u64(); break 'yield_0 []; }, } }; let [v_19]: [G; 1] = [G::from_u64(0)]; let [v_20]: [G; 1] = context.store(10, &[v_19, v_6, v_3])?; seed[15] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = context.returned::<1>(11)?; seed[16] = v_21.as_canonical_u64(); Ok(()) }, _ => { let [v_22]: [G; 1] = context.call::<1>(12, 775, &[v_3])?; seed[13] = v_22.as_canonical_u64(); let [v_25]: [G; 1] = 'yield_0: { match v_22.as_canonical_u64() { 0u64 => { break 'yield_0 [v_1]; }, _ => { let [v_23]: [G; 1] = [G::from_u64(0)]; let [v_24]: [G; 1] = context.call::<1>(14, 320, &[v_1, v_3, v_23])?; seed[14] = v_24.as_canonical_u64(); break 'yield_0 [v_24]; }, } }; let [v_26]: [G; 1] = context.call::<1>(15, 359, &[v_0, v_25, v_4])?; seed[15] = v_26.as_canonical_u64(); let [v_27, v_28, v_29, v_30]: [G; 4] = context.load::<4>(16, v_26)?; seed[16] = v_27.as_canonical_u64(); seed[17] = v_28.as_canonical_u64(); seed[18] = v_29.as_canonical_u64(); seed[19] = v_30.as_canonical_u64(); match v_27.as_canonical_u64() { 5u64 => { let [v_31]: [G; 1] = [G::from_u64(0)]; let [v_32]: [G; 1] = [G::from_u64(1)]; let [v_33]: [G; 1] = context.store(20, &[v_32, v_32, v_32])?; seed[20] = v_33.as_canonical_u64(); let [v_34]: [G; 1] = context.store(21, &[v_31, v_6, v_33])?; seed[21] = v_34.as_canonical_u64(); let [v_35]: [G; 1] = context.returned::<1>(22)?; seed[22] = v_35.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(443, v_27)) }, } }, } }, _ => { Err(no_match(443, v_5)) }, } } - -fn pack_443_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, v_6, v_7]: [G; 3] = context.load::<3>(0, v_2)?; seed.u8(120, v_5); seed.u32(84, v_6); seed.u32(88, v_7); match v_5.as_canonical_u64() { 1u64 => { let [v_8]: [G; 1] = context.call::<1>(1, 775, &[v_3])?; seed.full(8, v_8); match v_8.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_10]: [G; 1] = context.returned::<1>(3)?; seed.full(16, v_10); Ok(()) }, } }, 0u64 => { let [v_11, v_12, v_13, v_14]: [G; 4] = context.load::<4>(4, v_1)?; seed.full(8, v_11); seed.full(16, v_12); seed.u32(92, v_13); seed.full(24, v_14); match v_11.as_canonical_u64() { 5u64 => { let [v_15]: [G; 1] = context.call::<1>(5, 775, &[v_3])?; seed.full(32, v_15); let []: [G; 0] = 'yield_0: { match v_15.as_canonical_u64() { 0u64 => { break 'yield_0 []; }, _ => { let [v_16]: [G; 1] = [G::from_u64(0)]; let [v_17]: [G; 1] = context.call::<1>(7, 320, &[v_12, v_3, v_16])?; seed.u32(96, v_17); break 'yield_0 []; }, } }; let [v_19]: [G; 1] = [G::from_u64(0)]; let [v_20]: [G; 1] = context.store(10, &[v_19, v_6, v_3])?; seed.u32(100, v_20); let [v_21]: [G; 1] = context.returned::<1>(11)?; seed.full(40, v_21); Ok(()) }, _ => { let [v_22]: [G; 1] = context.call::<1>(12, 775, &[v_3])?; seed.full(32, v_22); let [v_25]: [G; 1] = 'yield_0: { match v_22.as_canonical_u64() { 0u64 => { break 'yield_0 [v_1]; }, _ => { let [v_23]: [G; 1] = [G::from_u64(0)]; let [v_24]: [G; 1] = context.call::<1>(14, 320, &[v_1, v_3, v_23])?; seed.u32(96, v_24); break 'yield_0 [v_24]; }, } }; let [v_26]: [G; 1] = context.call::<1>(15, 359, &[v_0, v_25, v_4])?; seed.u32(100, v_26); let [v_27, v_28, v_29, v_30]: [G; 4] = context.load::<4>(16, v_26)?; seed.full(40, v_27); seed.u32(104, v_28); seed.u32(108, v_29); seed.full(48, v_30); match v_27.as_canonical_u64() { 5u64 => { let [v_31]: [G; 1] = [G::from_u64(0)]; let [v_32]: [G; 1] = [G::from_u64(1)]; let [v_33]: [G; 1] = context.store(20, &[v_32, v_32, v_32])?; seed.u32(112, v_33); let [v_34]: [G; 1] = context.store(21, &[v_31, v_6, v_33])?; seed.u32(116, v_34); let [v_35]: [G; 1] = context.returned::<1>(22)?; seed.full(56, v_35); Ok(()) }, _ => { Err(no_match(443, v_27)) }, } }, } }, _ => { Err(no_match(443, v_5)) }, } } - -fn write_443(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, v_6, v_7]: [G; 3] = [G::from_u64(seed[6]), G::from_u64(seed[7]), G::from_u64(seed[8])]; row[offsets.auxiliaries + 1] = v_5.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_6.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_7.as_canonical_u64(); match v_5.as_canonical_u64() { 1u64 => { let [v_8]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 4] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 5] = (v_8 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_10]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 6] = v_10.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, } }, 0u64 => { let [v_11, v_12, v_13, v_14]: [G; 4] = [G::from_u64(seed[9]), G::from_u64(seed[10]), G::from_u64(seed[11]), G::from_u64(seed[12])]; row[offsets.auxiliaries + 4] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_14.as_canonical_u64(); match v_11.as_canonical_u64() { 5u64 => { let [v_15]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 8] = v_15.as_canonical_u64(); let [v_18]: [G; 1] = 'yield_0: { match v_15.as_canonical_u64() { 0u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 [v_12]; }, _ => { row[offsets.auxiliaries + 9] = (v_15 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 10] = v_17.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); break 'yield_0 [v_17]; }, } }; row[offsets.auxiliaries + 11] = v_18.as_canonical_u64(); let [v_20]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 12] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 13] = v_21.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 8] = (v_11 - G::from_u64(5)).inverse().as_canonical_u64(); let [v_22]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 9] = v_22.as_canonical_u64(); let [v_25]: [G; 1] = 'yield_0: { match v_22.as_canonical_u64() { 0u64 => { row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); break 'yield_0 [v_1]; }, _ => { row[offsets.auxiliaries + 10] = (v_22 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_24]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 11] = v_24.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); break 'yield_0 [v_24]; }, } }; row[offsets.auxiliaries + 12] = v_25.as_canonical_u64(); let [v_26]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 13] = v_26.as_canonical_u64(); let [v_27, v_28, v_29, v_30]: [G; 4] = [G::from_u64(seed[16]), G::from_u64(seed[17]), G::from_u64(seed[18]), G::from_u64(seed[19])]; row[offsets.auxiliaries + 14] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_30.as_canonical_u64(); match v_27.as_canonical_u64() { 5u64 => { let [v_33]: [G; 1] = [G::from_u64(seed[20])]; row[offsets.auxiliaries + 18] = v_33.as_canonical_u64(); let [v_34]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 19] = v_34.as_canonical_u64(); let [v_35]: [G; 1] = [G::from_u64(seed[22])]; row[offsets.auxiliaries + 20] = v_35.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(443, v_27)) }, } }, } }, _ => { Err(no_match(443, v_5)) }, } } - -static SCHEMA_443: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, 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, 80, 120, 84, 88, 8, 16, 92, 24, 32, 96, 100, 40, 104, 108, 48, 112, 116, 56], bytes: 128 }; - -fn pack_462(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, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32]: [G; 32] = context.load::<32>(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(); 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(); 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(); 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(); let [v_33]: [G; 1] = [G::from_u64(6)]; let [v_34, v_35]: [G; 2] = context.io_info(2, v_33, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32])?; seed[34] = v_34.as_canonical_u64(); seed[35] = v_35.as_canonical_u64(); let [v_36]: [G; 1] = context.call::<1>(3, 5, &[v_33, v_34, v_35])?; seed[36] = v_36.as_canonical_u64(); let [v_37, v_38]: [G; 2] = context.call::<2>(5, 83, &[v_36])?; seed[37] = v_37.as_canonical_u64(); seed[38] = v_38.as_canonical_u64(); let [v_40, v_41]: [G; 2] = context.call::<2>(8, 83, &[v_38])?; seed[39] = v_40.as_canonical_u64(); seed[40] = v_41.as_canonical_u64(); let [v_43, v_44]: [G; 2] = context.call::<2>(11, 83, &[v_41])?; seed[41] = v_43.as_canonical_u64(); seed[42] = v_44.as_canonical_u64(); let [v_45, v_46]: [G; 2] = context.call::<2>(13, 83, &[v_44])?; seed[43] = v_45.as_canonical_u64(); seed[44] = v_46.as_canonical_u64(); let [v_47]: [G; 1] = [G::from_u64(0)]; let [v_48]: [G; 1] = [G::from_u64(1)]; let [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]: [G; 14] = context.call::<14>(16, 463, &[v_46, v_45, v_47, v_48, v_48, v_48, v_48, v_48, v_48])?; seed[45] = v_49.as_canonical_u64(); seed[46] = v_50.as_canonical_u64(); seed[47] = v_51.as_canonical_u64(); seed[48] = v_52.as_canonical_u64(); seed[49] = v_53.as_canonical_u64(); seed[50] = v_54.as_canonical_u64(); seed[51] = v_55.as_canonical_u64(); seed[52] = v_56.as_canonical_u64(); seed[53] = v_57.as_canonical_u64(); seed[54] = v_58.as_canonical_u64(); seed[55] = v_59.as_canonical_u64(); seed[56] = v_60.as_canonical_u64(); seed[57] = v_61.as_canonical_u64(); seed[58] = v_62.as_canonical_u64(); let [v_63, v_64]: [G; 2] = context.call::<2>(17, 83, &[v_62])?; seed[59] = v_63.as_canonical_u64(); seed[60] = v_64.as_canonical_u64(); let [v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 8] = context.call::<8>(18, 464, &[v_64, v_63, v_47])?; seed[61] = v_65.as_canonical_u64(); seed[62] = v_66.as_canonical_u64(); seed[63] = v_67.as_canonical_u64(); seed[64] = v_68.as_canonical_u64(); seed[65] = v_69.as_canonical_u64(); seed[66] = v_70.as_canonical_u64(); seed[67] = v_71.as_canonical_u64(); seed[68] = v_72.as_canonical_u64(); let [v_73, v_74, v_75]: [G; 3] = context.load::<3>(19, v_72)?; seed[69] = v_73.as_canonical_u64(); seed[70] = v_74.as_canonical_u64(); seed[71] = v_75.as_canonical_u64(); let [v_76]: [G; 1] = context.store(21, &[v_0, 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_65, v_66, v_67, v_68, v_69, v_70])?; seed[72] = v_76.as_canonical_u64(); Ok(()) } - -fn pack_462_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, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32]: [G; 32] = context.load::<32>(0, v_0)?; seed.full(8, v_1); seed.full(16, v_2); seed.full(24, v_3); seed.full(32, v_4); seed.full(40, v_5); seed.full(48, v_6); seed.full(56, v_7); seed.full(64, v_8); seed.full(72, v_9); seed.full(80, v_10); seed.full(88, v_11); seed.full(96, v_12); seed.full(104, v_13); seed.full(112, v_14); seed.full(120, v_15); seed.full(128, v_16); seed.full(136, v_17); seed.full(144, v_18); seed.full(152, v_19); seed.full(160, v_20); seed.full(168, v_21); seed.full(176, v_22); seed.full(184, v_23); seed.full(192, v_24); seed.full(200, v_25); seed.full(208, v_26); seed.full(216, v_27); seed.full(224, v_28); seed.full(232, v_29); seed.full(240, v_30); seed.full(248, v_31); seed.full(256, v_32); let [v_33]: [G; 1] = [G::from_u64(6)]; let [v_34, v_35]: [G; 2] = context.io_info(2, v_33, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32])?; seed.u32(364, v_34); seed.u32(368, v_35); let [v_36]: [G; 1] = context.call::<1>(3, 5, &[v_33, v_34, v_35])?; seed.u32(372, v_36); let [v_37, v_38]: [G; 2] = context.call::<2>(5, 83, &[v_36])?; seed.u8(424, v_37); seed.u32(376, v_38); let [v_40, v_41]: [G; 2] = context.call::<2>(8, 83, &[v_38])?; seed.u8(425, v_40); seed.u32(380, v_41); let [v_43, v_44]: [G; 2] = context.call::<2>(11, 83, &[v_41])?; seed.u8(426, v_43); seed.u32(384, v_44); let [v_45, v_46]: [G; 2] = context.call::<2>(13, 83, &[v_44])?; seed.u8(427, v_45); seed.full(264, v_46); let [v_47]: [G; 1] = [G::from_u64(0)]; let [v_48]: [G; 1] = [G::from_u64(1)]; let [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]: [G; 14] = context.call::<14>(16, 463, &[v_46, v_45, v_47, v_48, v_48, v_48, v_48, v_48, v_48])?; seed.u8(428, v_49); seed.u8(429, v_50); seed.full(272, v_51); seed.u32(388, v_52); seed.u32(392, v_53); seed.u32(396, v_54); seed.full(280, v_55); seed.full(288, v_56); seed.full(296, v_57); seed.full(304, v_58); seed.full(312, v_59); seed.full(320, v_60); seed.full(328, v_61); seed.u32(400, v_62); let [v_63, v_64]: [G; 2] = context.call::<2>(17, 83, &[v_62])?; seed.u8(430, v_63); seed.full(336, v_64); let [v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 8] = context.call::<8>(18, 464, &[v_64, v_63, v_47])?; seed.u8(431, v_65); seed.u8(432, v_66); seed.full(344, v_67); seed.u32(404, v_68); seed.u32(408, v_69); seed.u32(412, v_70); seed.full(352, v_71); seed.u32(416, v_72); let [v_73, v_74, v_75]: [G; 3] = context.load::<3>(19, v_72)?; seed.u8(433, v_73); seed.u8(434, v_74); seed.u8(435, v_75); let [v_76]: [G; 1] = context.store(21, &[v_0, 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_65, v_66, v_67, v_68, v_69, v_70])?; seed.u32(420, v_76); Ok(()) } - -fn write_462(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { 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, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32]: [G; 32] = [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]), 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])]; 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(); row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_12.as_canonical_u64(); 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(); 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(); 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(); 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(); 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(); 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(); row[offsets.auxiliaries + 31] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_32.as_canonical_u64(); let [v_34, v_35]: [G; 2] = [G::from_u64(seed[34]), G::from_u64(seed[35])]; row[offsets.auxiliaries + 33] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_35.as_canonical_u64(); let [v_36]: [G; 1] = [G::from_u64(seed[36])]; row[offsets.auxiliaries + 35] = v_36.as_canonical_u64(); let [v_37, v_38]: [G; 2] = [G::from_u64(seed[37]), G::from_u64(seed[38])]; row[offsets.auxiliaries + 36] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_38.as_canonical_u64(); let [v_40, v_41]: [G; 2] = [G::from_u64(seed[39]), G::from_u64(seed[40])]; row[offsets.auxiliaries + 38] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_41.as_canonical_u64(); let [v_43, v_44]: [G; 2] = [G::from_u64(seed[41]), G::from_u64(seed[42])]; 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_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]: [G; 14] = [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])]; 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(); row[offsets.auxiliaries + 52] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_62.as_canonical_u64(); let [v_63, v_64]: [G; 2] = [G::from_u64(seed[59]), G::from_u64(seed[60])]; row[offsets.auxiliaries + 58] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_64.as_canonical_u64(); let [v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72]: [G; 8] = [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])]; row[offsets.auxiliaries + 60] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_72.as_canonical_u64(); let [v_73, v_74, v_75]: [G; 3] = [G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71])]; row[offsets.auxiliaries + 68] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_75.as_canonical_u64(); let [v_76]: [G; 1] = [G::from_u64(seed[72])]; row[offsets.auxiliaries + 71] = v_76.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } - -static SCHEMA_462: SeedSchema = SeedSchema { widths: &[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, 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::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32], offsets: &[0, 360, 8, 16, 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, 364, 368, 372, 424, 376, 425, 380, 426, 384, 427, 264, 428, 429, 272, 388, 392, 396, 280, 288, 296, 304, 312, 320, 328, 400, 430, 336, 431, 432, 344, 404, 408, 412, 352, 416, 433, 434, 435, 420], bytes: 440 }; - -fn pack_463(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]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_10]: [G; 1] = [Bytes1::shift_right(&v_1)]; let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 14] = context.call::<14>(2, 463, &[v_0, v_10, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed[10] = v_11.as_canonical_u64(); seed[11] = v_12.as_canonical_u64(); seed[12] = v_13.as_canonical_u64(); 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(); seed[21] = v_22.as_canonical_u64(); seed[22] = v_23.as_canonical_u64(); seed[23] = v_24.as_canonical_u64(); let [v_25, v_26]: [G; 2] = context.call::<2>(3, 83, &[v_24])?; seed[24] = v_25.as_canonical_u64(); seed[25] = v_26.as_canonical_u64(); let [v_29]: [G; 1] = [G::from_u64(1)]; let [v_31]: [G; 1] = [G::from_u64(0)]; let [v_32, v_33]: [G; 2] = context.call::<2>(11, 102, &[v_26])?; seed[26] = v_32.as_canonical_u64(); seed[27] = v_33.as_canonical_u64(); let [v_34]: [G; 1] = context.call::<1>(12, 763, &[v_32, v_17, v_18, v_19, v_20, v_21, v_22, v_31])?; seed[28] = v_34.as_canonical_u64(); let [v_35]: [G; 1] = [v_25 + v_29]; let [v_36, v_37, v_38, v_39, v_40, v_41]: [G; 6] = context.call::<6>(15, 779, &[v_32, v_35, v_17, v_18, v_19, v_20, v_21, v_22])?; seed[29] = v_36.as_canonical_u64(); seed[30] = v_37.as_canonical_u64(); seed[31] = v_38.as_canonical_u64(); seed[32] = v_39.as_canonical_u64(); seed[33] = v_40.as_canonical_u64(); seed[34] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = [v_10 + v_29]; let [v_43]: [G; 1] = [v_1 - v_42]; let [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]: [G; 14] = context.call::<14>(18, 463, &[v_33, v_43, v_35, v_36, v_37, v_38, v_39, v_40, v_41])?; seed[35] = v_44.as_canonical_u64(); seed[36] = v_45.as_canonical_u64(); seed[37] = v_46.as_canonical_u64(); seed[38] = v_47.as_canonical_u64(); seed[39] = v_48.as_canonical_u64(); seed[40] = v_49.as_canonical_u64(); seed[41] = v_50.as_canonical_u64(); seed[42] = v_51.as_canonical_u64(); seed[43] = v_52.as_canonical_u64(); seed[44] = v_53.as_canonical_u64(); seed[45] = v_54.as_canonical_u64(); seed[46] = v_55.as_canonical_u64(); seed[47] = v_56.as_canonical_u64(); seed[48] = v_57.as_canonical_u64(); let [v_58]: [G; 1] = context.store(19, &[v_11, v_12, v_13, v_14, v_15, v_16])?; seed[49] = v_58.as_canonical_u64(); let [v_59]: [G; 1] = context.store(20, &[v_44, v_45, v_46, v_47, v_48, v_49])?; seed[50] = v_59.as_canonical_u64(); Ok(()) }, } } - -fn pack_463_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]; match v_1.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_10]: [G; 1] = [Bytes1::shift_right(&v_1)]; let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 14] = context.call::<14>(2, 463, &[v_0, v_10, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed.u8(265, v_11); seed.u8(266, v_12); seed.full(72, v_13); seed.u32(192, v_14); seed.u32(196, v_15); seed.u32(200, v_16); seed.u8(267, v_17); seed.full(80, v_18); seed.u32(204, v_19); seed.full(88, v_20); seed.u32(208, v_21); seed.u32(212, v_22); seed.u32(216, v_23); seed.u32(220, v_24); let [v_25, v_26]: [G; 2] = context.call::<2>(3, 83, &[v_24])?; seed.u32(224, v_25); seed.u32(228, v_26); let [v_29]: [G; 1] = [G::from_u64(1)]; let [v_31]: [G; 1] = [G::from_u64(0)]; let [v_32, v_33]: [G; 2] = context.call::<2>(11, 102, &[v_26])?; seed.u32(232, v_32); seed.full(96, v_33); let [v_34]: [G; 1] = context.call::<1>(12, 763, &[v_32, v_17, v_18, v_19, v_20, v_21, v_22, v_31])?; seed.u8(268, v_34); let [v_35]: [G; 1] = [v_25 + v_29]; let [v_36, v_37, v_38, v_39, v_40, v_41]: [G; 6] = context.call::<6>(15, 779, &[v_32, v_35, v_17, v_18, v_19, v_20, v_21, v_22])?; seed.u8(269, v_36); seed.u8(270, v_37); seed.full(104, v_38); seed.full(112, v_39); seed.u32(236, v_40); seed.u32(240, v_41); let [v_42]: [G; 1] = [v_10 + v_29]; let [v_43]: [G; 1] = [v_1 - v_42]; let [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]: [G; 14] = context.call::<14>(18, 463, &[v_33, v_43, v_35, v_36, v_37, v_38, v_39, v_40, v_41])?; seed.u8(271, v_44); seed.u8(272, v_45); seed.full(120, v_46); seed.u32(244, v_47); seed.u32(248, v_48); seed.u32(252, v_49); seed.full(128, v_50); seed.full(136, v_51); seed.full(144, v_52); seed.full(152, v_53); seed.full(160, v_54); seed.full(168, v_55); seed.full(176, v_56); seed.full(184, v_57); let [v_58]: [G; 1] = context.store(19, &[v_11, v_12, v_13, v_14, v_15, v_16])?; seed.u32(256, v_58); let [v_59]: [G; 1] = context.store(20, &[v_44, v_45, v_46, v_47, v_48, v_49])?; seed.u32(260, v_59); Ok(()) }, } } - -fn write_463(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]); match v_1.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_10]: [G; 1] = [Bytes1::shift_right(&v_1)]; row[offsets.auxiliaries + 2] = v_10.as_canonical_u64(); let [v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24]: [G; 14] = [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])]; 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(); let [v_25, v_26]: [G; 2] = [G::from_u64(seed[24]), G::from_u64(seed[25])]; row[offsets.auxiliaries + 17] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_26.as_canonical_u64(); let [v_27]: [G; 1] = [G::from_u64(103)]; let op_5 = u32_less_than(v_25, v_27); let [v_28]: [G; 1] = [op_5.0]; row[offsets.auxiliaries + 19] = op_5.1[0].as_canonical_u64(); row[offsets.auxiliaries + 20] = op_5.1[1].as_canonical_u64(); row[offsets.auxiliaries + 21] = op_5.1[2].as_canonical_u64(); row[offsets.auxiliaries + 22] = op_5.1[3].as_canonical_u64(); row[offsets.auxiliaries + 23] = op_5.1[4].as_canonical_u64(); row[offsets.auxiliaries + 24] = op_5.1[5].as_canonical_u64(); let op_8 = u32_less_than(v_25, v_23); let [v_30]: [G; 1] = [op_8.0]; row[offsets.auxiliaries + 25] = op_8.1[0].as_canonical_u64(); row[offsets.auxiliaries + 26] = op_8.1[1].as_canonical_u64(); row[offsets.auxiliaries + 27] = op_8.1[2].as_canonical_u64(); row[offsets.auxiliaries + 28] = op_8.1[3].as_canonical_u64(); row[offsets.auxiliaries + 29] = op_8.1[4].as_canonical_u64(); row[offsets.auxiliaries + 30] = op_8.1[5].as_canonical_u64(); let [v_32, v_33]: [G; 2] = [G::from_u64(seed[26]), G::from_u64(seed[27])]; row[offsets.auxiliaries + 31] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_33.as_canonical_u64(); let [v_34]: [G; 1] = [G::from_u64(seed[28])]; row[offsets.auxiliaries + 33] = v_34.as_canonical_u64(); let [v_36, v_37, v_38, v_39, v_40, v_41]: [G; 6] = [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])]; row[offsets.auxiliaries + 34] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_41.as_canonical_u64(); let [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]: [G; 14] = [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])]; row[offsets.auxiliaries + 40] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_57.as_canonical_u64(); let [v_58]: [G; 1] = [G::from_u64(seed[49])]; row[offsets.auxiliaries + 54] = v_58.as_canonical_u64(); let [v_59]: [G; 1] = [G::from_u64(seed[50])]; row[offsets.auxiliaries + 55] = v_59.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_463: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 8, 264, 16, 24, 32, 40, 48, 56, 64, 265, 266, 72, 192, 196, 200, 267, 80, 204, 88, 208, 212, 216, 220, 224, 228, 232, 96, 268, 269, 270, 104, 112, 236, 240, 271, 272, 120, 244, 248, 252, 128, 136, 144, 152, 160, 168, 176, 184, 256, 260], bytes: 280 }; - -fn pack_464(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_4]: [G; 1] = [Bytes1::shift_right(&v_1)]; let [v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12]: [G; 8] = context.call::<8>(2, 464, &[v_0, v_4, v_2])?; seed[4] = v_5.as_canonical_u64(); seed[5] = v_6.as_canonical_u64(); seed[6] = v_7.as_canonical_u64(); 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(); seed[11] = v_12.as_canonical_u64(); let [v_13, v_14]: [G; 2] = context.call::<2>(3, 83, &[v_12])?; seed[12] = v_13.as_canonical_u64(); seed[13] = v_14.as_canonical_u64(); let [v_17]: [G; 1] = [G::from_u64(1)]; let [v_20, v_21]: [G; 2] = context.call::<2>(11, 83, &[v_14])?; seed[14] = v_20.as_canonical_u64(); seed[15] = v_21.as_canonical_u64(); let [v_22, v_23]: [G; 2] = context.call::<2>(12, 465, &[v_21, v_20])?; seed[16] = v_22.as_canonical_u64(); seed[17] = v_23.as_canonical_u64(); let [v_24]: [G; 1] = [v_4 + v_17]; let [v_25]: [G; 1] = [v_1 - v_24]; let [v_26]: [G; 1] = [v_13 + v_17]; let [v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34]: [G; 8] = context.call::<8>(16, 464, &[v_23, v_25, v_26])?; seed[18] = v_27.as_canonical_u64(); seed[19] = v_28.as_canonical_u64(); seed[20] = v_29.as_canonical_u64(); seed[21] = v_30.as_canonical_u64(); seed[22] = v_31.as_canonical_u64(); seed[23] = v_32.as_canonical_u64(); seed[24] = v_33.as_canonical_u64(); seed[25] = v_34.as_canonical_u64(); let [v_35]: [G; 1] = context.store(17, &[v_5, v_6, v_7, v_8, v_9, v_10])?; seed[26] = v_35.as_canonical_u64(); let [v_36]: [G; 1] = context.store(18, &[v_27, v_28, v_29, v_30, v_31, v_32])?; seed[27] = v_36.as_canonical_u64(); Ok(()) }, } } - -fn pack_464_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_4]: [G; 1] = [Bytes1::shift_right(&v_1)]; let [v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12]: [G; 8] = context.call::<8>(2, 464, &[v_0, v_4, v_2])?; seed.u8(129, v_5); seed.u8(130, v_6); seed.full(24, v_7); seed.u32(72, v_8); seed.u32(76, v_9); seed.u32(80, v_10); seed.u32(84, v_11); seed.u32(88, v_12); let [v_13, v_14]: [G; 2] = context.call::<2>(3, 83, &[v_12])?; seed.u32(92, v_13); seed.u32(96, v_14); let [v_17]: [G; 1] = [G::from_u64(1)]; let [v_20, v_21]: [G; 2] = context.call::<2>(11, 83, &[v_14])?; seed.full(32, v_20); seed.u32(100, v_21); let [v_22, v_23]: [G; 2] = context.call::<2>(12, 465, &[v_21, v_20])?; seed.u32(104, v_22); seed.full(40, v_23); let [v_24]: [G; 1] = [v_4 + v_17]; let [v_25]: [G; 1] = [v_1 - v_24]; let [v_26]: [G; 1] = [v_13 + v_17]; let [v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34]: [G; 8] = context.call::<8>(16, 464, &[v_23, v_25, v_26])?; seed.u8(131, v_27); seed.u8(132, v_28); seed.full(48, v_29); seed.u32(108, v_30); seed.u32(112, v_31); seed.u32(116, v_32); seed.full(56, v_33); seed.full(64, v_34); let [v_35]: [G; 1] = context.store(17, &[v_5, v_6, v_7, v_8, v_9, v_10])?; seed.u32(120, v_35); let [v_36]: [G; 1] = context.store(18, &[v_27, v_28, v_29, v_30, v_31, v_32])?; seed.u32(124, v_36); Ok(()) }, } } - -fn write_464(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]); match v_1.as_canonical_u64() { 0u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_1 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_4]: [G; 1] = [Bytes1::shift_right(&v_1)]; row[offsets.auxiliaries + 2] = v_4.as_canonical_u64(); let [v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12]: [G; 8] = [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 + 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(); let [v_13, v_14]: [G; 2] = [G::from_u64(seed[12]), G::from_u64(seed[13])]; row[offsets.auxiliaries + 11] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_14.as_canonical_u64(); let [v_15]: [G; 1] = [G::from_u64(103)]; let op_5 = u32_less_than(v_13, v_15); let [v_16]: [G; 1] = [op_5.0]; row[offsets.auxiliaries + 13] = op_5.1[0].as_canonical_u64(); row[offsets.auxiliaries + 14] = op_5.1[1].as_canonical_u64(); row[offsets.auxiliaries + 15] = op_5.1[2].as_canonical_u64(); row[offsets.auxiliaries + 16] = op_5.1[3].as_canonical_u64(); row[offsets.auxiliaries + 17] = op_5.1[4].as_canonical_u64(); row[offsets.auxiliaries + 18] = op_5.1[5].as_canonical_u64(); let op_8 = u32_less_than(v_13, v_11); let [v_18]: [G; 1] = [op_8.0]; row[offsets.auxiliaries + 19] = op_8.1[0].as_canonical_u64(); row[offsets.auxiliaries + 20] = op_8.1[1].as_canonical_u64(); row[offsets.auxiliaries + 21] = op_8.1[2].as_canonical_u64(); row[offsets.auxiliaries + 22] = op_8.1[3].as_canonical_u64(); row[offsets.auxiliaries + 23] = op_8.1[4].as_canonical_u64(); row[offsets.auxiliaries + 24] = op_8.1[5].as_canonical_u64(); let [v_20, v_21]: [G; 2] = [G::from_u64(seed[14]), G::from_u64(seed[15])]; row[offsets.auxiliaries + 25] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_21.as_canonical_u64(); let [v_22, v_23]: [G; 2] = [G::from_u64(seed[16]), G::from_u64(seed[17])]; row[offsets.auxiliaries + 27] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_23.as_canonical_u64(); let [v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34]: [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 + 29] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_34.as_canonical_u64(); let [v_35]: [G; 1] = [G::from_u64(seed[26])]; row[offsets.auxiliaries + 37] = v_35.as_canonical_u64(); let [v_36]: [G; 1] = [G::from_u64(seed[27])]; row[offsets.auxiliaries + 38] = v_36.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_464: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 8, 128, 16, 129, 130, 24, 72, 76, 80, 84, 88, 92, 96, 32, 100, 104, 40, 131, 132, 48, 108, 112, 116, 56, 64, 120, 124], bytes: 136 }; - -fn pack_477(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, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19]: [G; 19] = context.load::<19>(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(); 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(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); Ok(()) } - -fn pack_477_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, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19]: [G; 19] = context.load::<19>(0, v_0)?; seed.full(8, v_1); seed.full(16, v_2); seed.full(24, v_3); seed.full(32, v_4); seed.u32(100, v_5); seed.u32(104, v_6); seed.u32(108, v_7); seed.full(40, v_8); seed.full(48, v_9); seed.full(56, v_10); seed.full(64, v_11); seed.full(72, v_12); seed.full(80, v_13); seed.u8(124, v_14); seed.u8(125, v_15); seed.full(88, v_16); seed.u32(112, v_17); seed.u32(116, v_18); seed.u32(120, v_19); Ok(()) } - -fn write_477(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { 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, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19]: [G; 19] = [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]), 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 + 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(); row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_12.as_canonical_u64(); 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(); 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(); row[offsets.auxiliaries + 19] = v_19.as_canonical_u64(); match v_1.as_canonical_u64() { _ => { row[offsets.selectors] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_477: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 96, 8, 16, 24, 32, 100, 104, 108, 40, 48, 56, 64, 72, 80, 124, 125, 88, 112, 116, 120], bytes: 128 }; - -fn pack_576(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(576, v_2)) }, } }, } } - -fn pack_576_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(576, v_2)) }, } }, } } - -fn write_576(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(576, v_2)) }, } }, } } - -static SCHEMA_576: 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_614(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]; match v_0.as_canonical_u64() { 7u64 => { let [v_12]: [G; 1] = [v_3 + v_5]; let [v_13]: [G; 1] = [v_12 + v_6]; let [v_14]: [G; 1] = [v_13 + v_4]; let [v_15]: [G; 1] = context.call::<1>(3, 576, &[v_2, v_14])?; seed[13] = v_15.as_canonical_u64(); let [v_16, v_17, v_18, v_19]: [G; 4] = context.load::<4>(4, v_15)?; 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(); match v_16.as_canonical_u64() { 5u64 => { let [v_20, v_21]: [G; 2] = context.call::<2>(5, 128, &[v_17])?; seed[18] = v_20.as_canonical_u64(); seed[19] = v_21.as_canonical_u64(); let [v_22, v_23, v_24, v_25]: [G; 4] = context.load::<4>(6, v_20)?; 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(); match v_22.as_canonical_u64() { 2u64 => { Ok(()) }, _ => { let [v_26]: [G; 1] = [G::from_u64(1)]; let [v_27]: [G; 1] = context.store(8, &[v_26, v_26, v_26])?; seed[24] = v_27.as_canonical_u64(); Ok(()) }, } }, _ => { let [v_28]: [G; 1] = [G::from_u64(1)]; let [v_29]: [G; 1] = context.store(10, &[v_28, v_28, v_28])?; seed[18] = v_29.as_canonical_u64(); Ok(()) }, } }, _ => { let [v_30]: [G; 1] = [G::from_u64(1)]; let [v_31]: [G; 1] = context.store(12, &[v_30, v_30, v_30])?; seed[13] = v_31.as_canonical_u64(); Ok(()) }, } } - -fn pack_614_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]; match v_0.as_canonical_u64() { 7u64 => { let [v_12]: [G; 1] = [v_3 + v_5]; let [v_13]: [G; 1] = [v_12 + v_6]; let [v_14]: [G; 1] = [v_13 + v_4]; let [v_15]: [G; 1] = context.call::<1>(3, 576, &[v_2, v_14])?; seed.u32(140, v_15); let [v_16, v_17, v_18, v_19]: [G; 4] = context.load::<4>(4, v_15)?; seed.u8(160, v_16); seed.u32(144, v_17); seed.full(96, v_18); seed.full(104, v_19); match v_16.as_canonical_u64() { 5u64 => { let [v_20, v_21]: [G; 2] = context.call::<2>(5, 128, &[v_17])?; seed.u32(148, v_20); seed.u32(152, v_21); let [v_22, v_23, v_24, v_25]: [G; 4] = context.load::<4>(6, v_20)?; seed.u8(161, v_22); seed.full(112, v_23); seed.full(120, v_24); seed.full(128, v_25); match v_22.as_canonical_u64() { 2u64 => { Ok(()) }, _ => { let [v_26]: [G; 1] = [G::from_u64(1)]; let [v_27]: [G; 1] = context.store(8, &[v_26, v_26, v_26])?; seed.u32(156, v_27); Ok(()) }, } }, _ => { let [v_28]: [G; 1] = [G::from_u64(1)]; let [v_29]: [G; 1] = context.store(10, &[v_28, v_28, v_28])?; seed.u32(148, v_29); Ok(()) }, } }, _ => { let [v_30]: [G; 1] = [G::from_u64(1)]; let [v_31]: [G; 1] = context.store(12, &[v_30, v_30, v_30])?; seed.u32(140, v_31); Ok(()) }, } } - -fn write_614(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]); match v_0.as_canonical_u64() { 7u64 => { let [v_15]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 1] = v_15.as_canonical_u64(); let [v_16, v_17, v_18, v_19]: [G; 4] = [G::from_u64(seed[14]), G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17])]; row[offsets.auxiliaries + 2] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_19.as_canonical_u64(); match v_16.as_canonical_u64() { 5u64 => { let [v_20, v_21]: [G; 2] = [G::from_u64(seed[18]), G::from_u64(seed[19])]; row[offsets.auxiliaries + 6] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_21.as_canonical_u64(); let [v_22, v_23, v_24, v_25]: [G; 4] = [G::from_u64(seed[20]), G::from_u64(seed[21]), G::from_u64(seed[22]), G::from_u64(seed[23])]; row[offsets.auxiliaries + 8] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_25.as_canonical_u64(); match v_22.as_canonical_u64() { 2u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 12] = (v_22 - G::from_u64(2)).inverse().as_canonical_u64(); let [v_27]: [G; 1] = [G::from_u64(seed[24])]; row[offsets.auxiliaries + 13] = v_27.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 6] = (v_16 - G::from_u64(5)).inverse().as_canonical_u64(); let [v_29]: [G; 1] = [G::from_u64(seed[18])]; row[offsets.auxiliaries + 7] = v_29.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); }, } }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(7)).inverse().as_canonical_u64(); let [v_31]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 2] = v_31.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_614: SeedSchema = SeedSchema { widths: &[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::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32], offsets: &[0, 8, 16, 136, 24, 32, 40, 48, 56, 64, 72, 80, 88, 140, 160, 144, 96, 104, 148, 152, 161, 112, 120, 128, 156], bytes: 168 }; - -fn pack_620(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]: [G; 6] = context.load::<6>(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(); match v_3.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { match v_5.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = context.call::<1>(2, 2, &[v_4, v_1])?; seed[10] = v_10.as_canonical_u64(); match v_10.as_canonical_u64() { 1u64 => { let [v_11]: [G; 1] = context.call::<1>(3, 623, &[v_6, v_2])?; seed[11] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_13]: [G; 1] = context.returned::<1>(5)?; seed[12] = v_13.as_canonical_u64(); Ok(()) }, } }, _ => { let [v_14]: [G; 1] = context.returned::<1>(6)?; seed[11] = v_14.as_canonical_u64(); Ok(()) }, } }, _ => { let [v_15]: [G; 1] = context.returned::<1>(7)?; seed[10] = v_15.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(620, v_3)) }, } } - -fn pack_620_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]: [G; 6] = context.load::<6>(0, v_0)?; seed.u8(48, v_3); seed.u32(36, v_4); seed.full(8, v_5); seed.u32(40, v_6); seed.full(16, v_7); seed.u32(44, v_8); match v_3.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { match v_5.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = context.call::<1>(2, 2, &[v_4, v_1])?; seed.u8(49, v_10); match v_10.as_canonical_u64() { 1u64 => { let [v_11]: [G; 1] = context.call::<1>(3, 623, &[v_6, v_2])?; seed.u8(50, v_11); match v_11.as_canonical_u64() { 1u64 => { Ok(()) }, _ => { let [v_13]: [G; 1] = context.returned::<1>(5)?; seed.u8(51, v_13); Ok(()) }, } }, _ => { let [v_14]: [G; 1] = context.returned::<1>(6)?; seed.u8(50, v_14); Ok(()) }, } }, _ => { let [v_15]: [G; 1] = context.returned::<1>(7)?; seed.u8(49, v_15); Ok(()) }, } }, _ => { Err(no_match(620, v_3)) }, } } - -fn write_620(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]: [G; 6] = [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])]; 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(); match v_3.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { match v_5.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_10.as_canonical_u64(); match v_10.as_canonical_u64() { 1u64 => { let [v_11]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 8] = v_11.as_canonical_u64(); match v_11.as_canonical_u64() { 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 9] = (v_11 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_13]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 10] = v_13.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { row[offsets.auxiliaries + 8] = (v_10 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_14]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 9] = v_14.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { row[offsets.auxiliaries + 7] = (v_5 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_15]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 8] = v_15.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(620, v_3)) }, } } - -static SCHEMA_620: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 24, 28, 32, 48, 36, 8, 40, 16, 44, 49, 50, 51], bytes: 56 }; - -fn pack_627(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, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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; 48] = context.call::<48>(0, 228, &[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(); 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(); 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(); 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(); let [v_53]: [G; 1] = 'yield_0: { match v_3.as_canonical_u64() { _ => { match v_3.as_canonical_u64() { 8u64 => { let [v_51]: [G; 1] = [G::from_u64(0)]; let [v_52]: [G; 1] = context.call::<1>(2, 626, &[v_4, v_4, v_0, v_51, v_1])?; seed[52] = v_52.as_canonical_u64(); break 'yield_0 [v_52]; }, _ => { break 'yield_0 [v_1]; }, } }, } }; let [v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101]: [G; 48] = context.call::<48>(3, 228, &[v_53])?; seed[53] = v_54.as_canonical_u64(); seed[54] = v_55.as_canonical_u64(); seed[55] = v_56.as_canonical_u64(); seed[56] = v_57.as_canonical_u64(); seed[57] = v_58.as_canonical_u64(); seed[58] = v_59.as_canonical_u64(); seed[59] = v_60.as_canonical_u64(); seed[60] = v_61.as_canonical_u64(); seed[61] = v_62.as_canonical_u64(); seed[62] = v_63.as_canonical_u64(); seed[63] = v_64.as_canonical_u64(); seed[64] = v_65.as_canonical_u64(); seed[65] = v_66.as_canonical_u64(); seed[66] = v_67.as_canonical_u64(); seed[67] = v_68.as_canonical_u64(); seed[68] = v_69.as_canonical_u64(); seed[69] = v_70.as_canonical_u64(); seed[70] = v_71.as_canonical_u64(); seed[71] = v_72.as_canonical_u64(); seed[72] = v_73.as_canonical_u64(); seed[73] = v_74.as_canonical_u64(); seed[74] = v_75.as_canonical_u64(); seed[75] = v_76.as_canonical_u64(); seed[76] = v_77.as_canonical_u64(); seed[77] = v_78.as_canonical_u64(); seed[78] = v_79.as_canonical_u64(); seed[79] = v_80.as_canonical_u64(); seed[80] = v_81.as_canonical_u64(); seed[81] = v_82.as_canonical_u64(); seed[82] = v_83.as_canonical_u64(); seed[83] = v_84.as_canonical_u64(); seed[84] = v_85.as_canonical_u64(); seed[85] = v_86.as_canonical_u64(); seed[86] = v_87.as_canonical_u64(); seed[87] = v_88.as_canonical_u64(); seed[88] = v_89.as_canonical_u64(); seed[89] = v_90.as_canonical_u64(); seed[90] = v_91.as_canonical_u64(); seed[91] = v_92.as_canonical_u64(); seed[92] = v_93.as_canonical_u64(); seed[93] = v_94.as_canonical_u64(); seed[94] = v_95.as_canonical_u64(); seed[95] = v_96.as_canonical_u64(); seed[96] = v_97.as_canonical_u64(); seed[97] = v_98.as_canonical_u64(); seed[98] = v_99.as_canonical_u64(); seed[99] = v_100.as_canonical_u64(); seed[100] = v_101.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_54.as_canonical_u64() { _ => { match v_54.as_canonical_u64() { 8u64 => { let [v_102]: [G; 1] = [G::from_u64(0)]; let [v_103]: [G; 1] = context.call::<1>(5, 619, &[v_55, v_55, v_53, v_2, v_102])?; seed[101] = v_103.as_canonical_u64(); break 'yield_0 []; }, _ => { let [v_104]: [G; 1] = context.call::<1>(6, 234, &[v_53])?; seed[101] = v_104.as_canonical_u64(); let [v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116]: [G; 12] = context.load::<12>(7, v_104)?; seed[102] = v_105.as_canonical_u64(); seed[103] = v_106.as_canonical_u64(); seed[104] = v_107.as_canonical_u64(); seed[105] = v_108.as_canonical_u64(); seed[106] = v_109.as_canonical_u64(); seed[107] = v_110.as_canonical_u64(); seed[108] = v_111.as_canonical_u64(); seed[109] = v_112.as_canonical_u64(); seed[110] = v_113.as_canonical_u64(); seed[111] = v_114.as_canonical_u64(); seed[112] = v_115.as_canonical_u64(); seed[113] = v_116.as_canonical_u64(); match v_105.as_canonical_u64() { 5u64 => { let [v_117]: [G; 1] = [G::from_u64(0)]; let [v_118]: [G; 1] = context.call::<1>(9, 617, &[v_2, v_106, v_117])?; seed[114] = v_118.as_canonical_u64(); let [v_119]: [G; 1] = [G::from_u64(1)]; let [v_120]: [G; 1] = context.store(11, &[v_119, v_119, v_119])?; seed[115] = v_120.as_canonical_u64(); let [v_121]: [G; 1] = context.store(12, &[v_119, v_119, v_119, v_119, v_119, v_119])?; seed[116] = v_121.as_canonical_u64(); let [v_122]: [G; 1] = context.store(13, &[v_117, v_53, v_117, v_120, v_118, v_121])?; seed[117] = v_122.as_canonical_u64(); break 'yield_0 []; }, _ => { let [v_123]: [G; 1] = [G::from_u64(1)]; let [v_124]: [G; 1] = context.store(15, &[v_123, v_123, v_123, v_123, v_123, v_123])?; seed[114] = v_124.as_canonical_u64(); break 'yield_0 []; }, } }, } }, } }; let [v_126]: [G; 1] = context.call::<1>(16, 611, &[v_0])?; seed[118] = v_126.as_canonical_u64(); match v_126.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_127]: [G; 1] = context.returned::<1>(17)?; seed[119] = v_127.as_canonical_u64(); Ok(()) }, } } - -fn pack_627_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, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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; 48] = context.call::<48>(0, 228, &[v_0])?; seed.u8(402, v_3); seed.u32(328, v_4); seed.full(16, v_5); seed.full(24, v_6); seed.full(32, v_7); seed.u8(403, v_8); seed.u8(404, v_9); seed.u8(405, v_10); seed.u8(406, v_11); seed.full(40, v_12); seed.full(48, v_13); seed.full(56, v_14); seed.full(64, v_15); seed.u8(407, v_16); seed.u8(408, v_17); seed.u8(409, v_18); seed.u8(410, v_19); seed.u32(332, v_20); seed.u8(411, v_21); seed.full(72, v_22); seed.full(80, v_23); seed.u8(412, v_24); seed.u8(413, v_25); seed.u8(414, v_26); seed.u8(415, v_27); seed.u8(416, v_28); seed.u8(417, v_29); seed.full(88, v_30); seed.full(96, v_31); seed.u8(418, v_32); seed.u8(419, v_33); seed.u8(420, v_34); seed.u8(421, v_35); seed.u8(422, v_36); seed.u8(423, v_37); seed.full(104, v_38); seed.full(112, 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.full(120, v_46); seed.u32(336, v_47); seed.u32(340, v_48); seed.u32(344, v_49); seed.u32(348, v_50); let [v_53]: [G; 1] = 'yield_0: { match v_3.as_canonical_u64() { _ => { match v_3.as_canonical_u64() { 8u64 => { let [v_51]: [G; 1] = [G::from_u64(0)]; let [v_52]: [G; 1] = context.call::<1>(2, 626, &[v_4, v_4, v_0, v_51, v_1])?; seed.u8(430, v_52); break 'yield_0 [v_52]; }, _ => { break 'yield_0 [v_1]; }, } }, } }; let [v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101]: [G; 48] = context.call::<48>(3, 228, &[v_53])?; seed.u8(431, v_54); seed.u32(352, v_55); seed.full(128, v_56); seed.full(136, v_57); seed.full(144, v_58); seed.u8(432, v_59); seed.u8(433, v_60); seed.u8(434, v_61); seed.u8(435, v_62); seed.full(152, v_63); seed.full(160, v_64); seed.full(168, v_65); seed.full(176, v_66); seed.u8(436, v_67); seed.u8(437, v_68); seed.u8(438, v_69); seed.u8(439, v_70); seed.u32(356, v_71); seed.u8(440, v_72); seed.full(184, v_73); seed.full(192, v_74); seed.u8(441, v_75); seed.u8(442, v_76); seed.u8(443, v_77); seed.u8(444, v_78); seed.u8(445, v_79); seed.u8(446, v_80); seed.full(200, v_81); seed.full(208, v_82); seed.u8(447, v_83); seed.u8(448, v_84); seed.u8(449, v_85); seed.u8(450, v_86); seed.u8(451, v_87); seed.u8(452, v_88); seed.full(216, v_89); seed.full(224, v_90); seed.u8(453, v_91); seed.u8(454, v_92); seed.u8(455, v_93); seed.u8(456, v_94); seed.u8(457, v_95); seed.u8(458, v_96); seed.full(232, v_97); seed.u32(360, v_98); seed.u32(364, v_99); seed.u32(368, v_100); seed.u32(372, v_101); let []: [G; 0] = 'yield_0: { match v_54.as_canonical_u64() { _ => { match v_54.as_canonical_u64() { 8u64 => { let [v_102]: [G; 1] = [G::from_u64(0)]; let [v_103]: [G; 1] = context.call::<1>(5, 619, &[v_55, v_55, v_53, v_2, v_102])?; seed.u32(376, v_103); break 'yield_0 []; }, _ => { let [v_104]: [G; 1] = context.call::<1>(6, 234, &[v_53])?; seed.u32(376, v_104); let [v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116]: [G; 12] = context.load::<12>(7, v_104)?; seed.u8(459, v_105); seed.full(240, v_106); seed.u32(380, v_107); seed.full(248, v_108); seed.full(256, v_109); seed.full(264, v_110); seed.full(272, v_111); seed.full(280, v_112); seed.full(288, v_113); seed.full(296, v_114); seed.full(304, v_115); seed.full(312, v_116); match v_105.as_canonical_u64() { 5u64 => { let [v_117]: [G; 1] = [G::from_u64(0)]; let [v_118]: [G; 1] = context.call::<1>(9, 617, &[v_2, v_106, v_117])?; seed.u32(384, v_118); let [v_119]: [G; 1] = [G::from_u64(1)]; let [v_120]: [G; 1] = context.store(11, &[v_119, v_119, v_119])?; seed.u32(388, v_120); let [v_121]: [G; 1] = context.store(12, &[v_119, v_119, v_119, v_119, v_119, v_119])?; seed.u32(392, v_121); let [v_122]: [G; 1] = context.store(13, &[v_117, v_53, v_117, v_120, v_118, v_121])?; seed.u32(396, v_122); break 'yield_0 []; }, _ => { let [v_123]: [G; 1] = [G::from_u64(1)]; let [v_124]: [G; 1] = context.store(15, &[v_123, v_123, v_123, v_123, v_123, v_123])?; seed.u32(384, v_124); break 'yield_0 []; }, } }, } }, } }; let [v_126]: [G; 1] = context.call::<1>(16, 611, &[v_0])?; seed.u8(460, v_126); match v_126.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_127]: [G; 1] = context.returned::<1>(17)?; seed.full(320, v_127); Ok(()) }, } } - -fn write_627(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, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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; 48] = [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]), 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])]; 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(); 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(); row[offsets.auxiliaries + 14] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_50.as_canonical_u64(); let [v_53]: [G; 1] = 'yield_0: { match v_3.as_canonical_u64() { _ => { match v_3.as_canonical_u64() { 8u64 => { let [v_52]: [G; 1] = [G::from_u64(seed[52])]; row[offsets.auxiliaries + 49] = v_52.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); break 'yield_0 [v_52]; }, _ => { row[offsets.auxiliaries + 49] = (v_3 - G::from_u64(8)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 [v_1]; }, } }, } }; row[offsets.auxiliaries + 50] = v_53.as_canonical_u64(); let [v_54, v_55, v_56, v_57, v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65, v_66, v_67, v_68, v_69, v_70, v_71, v_72, v_73, v_74, v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89, v_90, v_91, v_92, v_93, v_94, v_95, v_96, v_97, v_98, v_99, v_100, v_101]: [G; 48] = [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]), 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])]; row[offsets.auxiliaries + 51] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 55] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_89.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_90.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_91.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_92.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_93.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_94.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_95.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_96.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_97.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_98.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_99.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_100.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_101.as_canonical_u64(); let [v_125]: [G; 1] = 'yield_0: { match v_54.as_canonical_u64() { _ => { match v_54.as_canonical_u64() { 8u64 => { let [v_103]: [G; 1] = [G::from_u64(seed[101])]; row[offsets.auxiliaries + 99] = v_103.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 [v_103]; }, _ => { row[offsets.auxiliaries + 99] = (v_54 - G::from_u64(8)).inverse().as_canonical_u64(); let [v_104]: [G; 1] = [G::from_u64(seed[101])]; row[offsets.auxiliaries + 100] = v_104.as_canonical_u64(); let [v_105, v_106, v_107, v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115, v_116]: [G; 12] = [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 + 101] = v_105.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_106.as_canonical_u64(); row[offsets.auxiliaries + 103] = v_107.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_108.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_109.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_110.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_111.as_canonical_u64(); row[offsets.auxiliaries + 108] = v_112.as_canonical_u64(); row[offsets.auxiliaries + 109] = v_113.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_114.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_115.as_canonical_u64(); row[offsets.auxiliaries + 112] = v_116.as_canonical_u64(); match v_105.as_canonical_u64() { 5u64 => { let [v_118]: [G; 1] = [G::from_u64(seed[114])]; row[offsets.auxiliaries + 113] = v_118.as_canonical_u64(); let [v_120]: [G; 1] = [G::from_u64(seed[115])]; row[offsets.auxiliaries + 114] = v_120.as_canonical_u64(); let [v_121]: [G; 1] = [G::from_u64(seed[116])]; row[offsets.auxiliaries + 115] = v_121.as_canonical_u64(); let [v_122]: [G; 1] = [G::from_u64(seed[117])]; row[offsets.auxiliaries + 116] = v_122.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); break 'yield_0 [v_122]; }, _ => { row[offsets.auxiliaries + 113] = (v_105 - G::from_u64(5)).inverse().as_canonical_u64(); let [v_124]: [G; 1] = [G::from_u64(seed[114])]; row[offsets.auxiliaries + 114] = v_124.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); break 'yield_0 [v_124]; }, } }, } }, } }; row[offsets.auxiliaries + 117] = v_125.as_canonical_u64(); let [v_126]: [G; 1] = [G::from_u64(seed[118])]; row[offsets.auxiliaries + 118] = v_126.as_canonical_u64(); match v_126.as_canonical_u64() { 0u64 => { row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 119] = (v_126 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_127]: [G; 1] = [G::from_u64(seed[119])]; row[offsets.auxiliaries + 120] = v_127.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_627: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, 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, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full], offsets: &[0, 400, 401, 8, 402, 328, 16, 24, 32, 403, 404, 405, 406, 40, 48, 56, 64, 407, 408, 409, 410, 332, 411, 72, 80, 412, 413, 414, 415, 416, 417, 88, 96, 418, 419, 420, 421, 422, 423, 104, 112, 424, 425, 426, 427, 428, 429, 120, 336, 340, 344, 348, 430, 431, 352, 128, 136, 144, 432, 433, 434, 435, 152, 160, 168, 176, 436, 437, 438, 439, 356, 440, 184, 192, 441, 442, 443, 444, 445, 446, 200, 208, 447, 448, 449, 450, 451, 452, 216, 224, 453, 454, 455, 456, 457, 458, 232, 360, 364, 368, 372, 376, 459, 240, 380, 248, 256, 264, 272, 280, 288, 296, 304, 312, 384, 388, 392, 396, 460, 320], bytes: 464 }; - -fn pack_628(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, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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]: [G; 48] = context.call::<48>(0, 228, &[v_0])?; 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(); seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); 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(); 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(); match v_4.as_canonical_u64() { _ => { match v_4.as_canonical_u64() { 8u64 => { let [v_53]: [G; 1] = context.returned::<1>(2)?; seed[53] = v_53.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } }, } } - -fn pack_628_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, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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]: [G; 48] = context.call::<48>(0, 228, &[v_0])?; seed.u8(169, v_4); seed.u32(144, v_5); seed.full(16, v_6); seed.full(24, v_7); seed.full(32, v_8); seed.u8(170, v_9); seed.u8(171, v_10); seed.u8(172, v_11); seed.u8(173, v_12); seed.full(40, v_13); seed.full(48, v_14); seed.full(56, v_15); seed.full(64, v_16); seed.u8(174, v_17); seed.u8(175, v_18); seed.u8(176, v_19); seed.u8(177, v_20); seed.u32(148, v_21); seed.u8(178, v_22); seed.full(72, v_23); seed.full(80, v_24); seed.u8(179, v_25); seed.u8(180, v_26); seed.u8(181, v_27); seed.u8(182, v_28); seed.u8(183, v_29); seed.u8(184, v_30); seed.full(88, v_31); seed.full(96, v_32); seed.u8(185, v_33); seed.u8(186, v_34); seed.u8(187, v_35); seed.u8(188, v_36); seed.u8(189, v_37); seed.u8(190, v_38); seed.full(104, v_39); seed.full(112, v_40); seed.u8(191, v_41); seed.u8(192, v_42); seed.u8(193, v_43); seed.u8(194, v_44); seed.u8(195, v_45); seed.u8(196, v_46); seed.full(120, v_47); seed.u32(152, v_48); seed.u32(156, v_49); seed.u32(160, v_50); seed.u32(164, v_51); match v_4.as_canonical_u64() { _ => { match v_4.as_canonical_u64() { 8u64 => { let [v_53]: [G; 1] = context.returned::<1>(2)?; seed.full(128, v_53); Ok(()) }, _ => { Ok(()) }, } }, } } - -fn write_628(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, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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]: [G; 48] = [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]), 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])]; 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(); 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(); 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(); 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(); 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(); row[offsets.auxiliaries + 42] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_51.as_canonical_u64(); match v_4.as_canonical_u64() { _ => { match v_4.as_canonical_u64() { 8u64 => { let [v_53]: [G; 1] = [G::from_u64(seed[53])]; row[offsets.auxiliaries + 49] = v_53.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 49] = (v_4 - G::from_u64(8)).inverse().as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } }, } } - -static SCHEMA_628: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 168, 136, 8, 140, 169, 144, 16, 24, 32, 170, 171, 172, 173, 40, 48, 56, 64, 174, 175, 176, 177, 148, 178, 72, 80, 179, 180, 181, 182, 183, 184, 88, 96, 185, 186, 187, 188, 189, 190, 104, 112, 191, 192, 193, 194, 195, 196, 120, 152, 156, 160, 164, 128], bytes: 200 }; - -fn pack_679(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_7, v_8, v_9]: [G; 3] = context.load::<3>(2, v_1)?; seed[7] = v_7.as_canonical_u64(); seed[8] = v_8.as_canonical_u64(); seed[9] = v_9.as_canonical_u64(); match v_7.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_11]: [G; 1] = [G::from_u64(0)]; let [v_12]: [G; 1] = context.call::<1>(5, 306, &[v_4, v_2, v_11])?; seed[10] = v_12.as_canonical_u64(); let [v_13]: [G; 1] = context.call::<1>(6, 621, &[v_12, v_8])?; seed[11] = v_13.as_canonical_u64(); match v_13.as_canonical_u64() { 1u64 => { let [v_14]: [G; 1] = context.returned::<1>(7)?; seed[12] = v_14.as_canonical_u64(); Ok(()) }, _ => { Ok(()) }, } }, _ => { Err(no_match(679, v_7)) }, } }, _ => { Err(no_match(679, v_3)) }, } } - -fn pack_679_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(52, v_3); seed.u32(32, v_4); seed.u32(36, v_5); match v_3.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_7, v_8, v_9]: [G; 3] = context.load::<3>(2, v_1)?; seed.u8(53, v_7); seed.u32(40, v_8); seed.u32(44, v_9); match v_7.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_11]: [G; 1] = [G::from_u64(0)]; let [v_12]: [G; 1] = context.call::<1>(5, 306, &[v_4, v_2, v_11])?; seed.u32(48, v_12); let [v_13]: [G; 1] = context.call::<1>(6, 621, &[v_12, v_8])?; seed.full(16, v_13); match v_13.as_canonical_u64() { 1u64 => { let [v_14]: [G; 1] = context.returned::<1>(7)?; seed.u8(54, v_14); Ok(()) }, _ => { Ok(()) }, } }, _ => { Err(no_match(679, v_7)) }, } }, _ => { Err(no_match(679, v_3)) }, } } - -fn write_679(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_7, v_8, v_9]: [G; 3] = [G::from_u64(seed[7]), G::from_u64(seed[8]), G::from_u64(seed[9])]; 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(); match v_7.as_canonical_u64() { 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_12]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 7] = v_12.as_canonical_u64(); let [v_13]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 8] = v_13.as_canonical_u64(); match v_13.as_canonical_u64() { 1u64 => { let [v_14]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 9] = v_14.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 9] = (v_13 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(679, v_7)) }, } }, _ => { Err(no_match(679, v_3)) }, } } - -static SCHEMA_679: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8], offsets: &[0, 24, 28, 8, 52, 32, 36, 53, 40, 44, 48, 16, 54], bytes: 56 }; - -fn pack_697(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(697, v_2)) }, } } - -fn pack_697_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(697, v_2)) }, } } - -fn write_697(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(697, v_2)) }, } } - -static SCHEMA_697: 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_698(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, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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; 48] = context.call::<48>(0, 228, &[v_1])?; 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(); 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(); 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(); 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(); match v_2.as_canonical_u64() { _ => { let []: [G; 0] = 'yield_0: { match v_2.as_canonical_u64() { 8u64 => { break 'yield_0 []; }, 7u64 => { match v_3.as_canonical_u64() { _ => { break 'yield_0 []; }, } }, 6u64 => { match v_3.as_canonical_u64() { _ => { break 'yield_0 []; }, } }, 4u64 => { match v_3.as_canonical_u64() { _ => { break 'yield_0 []; }, } }, 5u64 => { match v_3.as_canonical_u64() { _ => { break 'yield_0 []; }, } }, _ => { break 'yield_0 []; }, } }; let [v_51]: [G; 1] = context.call::<1>(12, 696, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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])?; seed[51] = v_51.as_canonical_u64(); Ok(()) }, } } - -fn pack_698_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, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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; 48] = context.call::<48>(0, 228, &[v_1])?; seed.u8(125, v_2); seed.u32(84, v_3); seed.full(8, v_4); seed.full(16, v_5); seed.full(24, v_6); seed.u8(126, v_7); seed.u8(127, v_8); seed.u8(128, v_9); seed.u8(129, v_10); seed.u8(130, v_11); seed.u32(88, v_12); seed.u32(92, v_13); seed.u32(96, v_14); seed.u8(131, v_15); seed.u8(132, v_16); seed.u8(133, v_17); seed.u8(134, v_18); seed.u8(135, v_19); seed.u8(136, v_20); seed.full(32, v_21); seed.full(40, v_22); seed.u8(137, v_23); seed.u8(138, v_24); seed.u8(139, v_25); seed.u8(140, v_26); seed.u8(141, v_27); seed.u8(142, v_28); seed.full(48, v_29); seed.full(56, v_30); seed.u8(143, v_31); seed.u8(144, v_32); seed.u8(145, v_33); seed.u8(146, v_34); seed.u8(147, v_35); seed.u8(148, v_36); seed.full(64, v_37); seed.full(72, v_38); seed.u8(149, v_39); seed.u8(150, v_40); seed.u8(151, v_41); seed.u8(152, v_42); seed.u8(153, v_43); seed.u8(154, v_44); seed.u32(100, v_45); seed.u32(104, v_46); seed.u32(108, v_47); seed.u32(112, v_48); seed.u32(116, v_49); match v_2.as_canonical_u64() { _ => { let []: [G; 0] = 'yield_0: { match v_2.as_canonical_u64() { 8u64 => { break 'yield_0 []; }, 7u64 => { match v_3.as_canonical_u64() { _ => { break 'yield_0 []; }, } }, 6u64 => { match v_3.as_canonical_u64() { _ => { break 'yield_0 []; }, } }, 4u64 => { match v_3.as_canonical_u64() { _ => { break 'yield_0 []; }, } }, 5u64 => { match v_3.as_canonical_u64() { _ => { break 'yield_0 []; }, } }, _ => { break 'yield_0 []; }, } }; let [v_51]: [G; 1] = context.call::<1>(12, 696, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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])?; seed.u32(120, v_51); Ok(()) }, } } - -fn write_698(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, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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; 48] = [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]), 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])]; 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(); 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.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_49.as_canonical_u64(); match v_2.as_canonical_u64() { _ => { let []: [G; 0] = 'yield_0: { match v_2.as_canonical_u64() { 8u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, 7u64 => { match v_3.as_canonical_u64() { _ => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }, 6u64 => { match v_3.as_canonical_u64() { _ => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }, 4u64 => { match v_3.as_canonical_u64() { _ => { row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }, 5u64 => { match v_3.as_canonical_u64() { _ => { row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }, _ => { row[offsets.auxiliaries + 49] = (v_2 - G::from_u64(8)).inverse().as_canonical_u64(); row[offsets.auxiliaries + 50] = (v_2 - G::from_u64(7)).inverse().as_canonical_u64(); row[offsets.auxiliaries + 51] = (v_2 - G::from_u64(6)).inverse().as_canonical_u64(); row[offsets.auxiliaries + 52] = (v_2 - G::from_u64(4)).inverse().as_canonical_u64(); row[offsets.auxiliaries + 53] = (v_2 - G::from_u64(5)).inverse().as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }; let [v_51]: [G; 1] = [G::from_u64(seed[51])]; row[offsets.auxiliaries + 54] = v_51.as_canonical_u64(); row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_698: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 80, 124, 125, 84, 8, 16, 24, 126, 127, 128, 129, 130, 88, 92, 96, 131, 132, 133, 134, 135, 136, 32, 40, 137, 138, 139, 140, 141, 142, 48, 56, 143, 144, 145, 146, 147, 148, 64, 72, 149, 150, 151, 152, 153, 154, 100, 104, 108, 112, 116, 120], bytes: 160 }; - -fn pack_699(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 => { Ok(()) }, 0u64 => { let [v_7]: [G; 1] = context.call::<1>(1, 697, &[v_2, v_3])?; seed[8] = v_7.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_7.as_canonical_u64() { 1u64 => { let [v_8]: [G; 1] = context.call::<1>(3, 487, &[v_0, v_5])?; seed[9] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 0u64 => { let [v_9]: [G; 1] = context.call::<1>(4, 486, &[v_0, v_5])?; seed[10] = v_9.as_canonical_u64(); break 'yield_0 []; }, _ => { break 'yield_0 []; }, } }, _ => { break 'yield_0 []; }, } }; Ok(()) }, _ => { Err(no_match(699, v_4)) }, } } - -fn pack_699_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(36, v_4); seed.u8(37, v_5); seed.u32(28, v_6); match v_4.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_7]: [G; 1] = context.call::<1>(1, 697, &[v_2, v_3])?; seed.u8(38, v_7); let []: [G; 0] = 'yield_0: { match v_7.as_canonical_u64() { 1u64 => { let [v_8]: [G; 1] = context.call::<1>(3, 487, &[v_0, v_5])?; seed.u8(39, v_8); match v_8.as_canonical_u64() { 0u64 => { let [v_9]: [G; 1] = context.call::<1>(4, 486, &[v_0, v_5])?; seed.u32(32, v_9); break 'yield_0 []; }, _ => { break 'yield_0 []; }, } }, _ => { break 'yield_0 []; }, } }; Ok(()) }, _ => { Err(no_match(699, v_4)) }, } } - -fn write_699(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 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_7]: [G; 1] = [G::from_u64(seed[8])]; row[offsets.auxiliaries + 4] = v_7.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_7.as_canonical_u64() { 1u64 => { let [v_8]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 5] = v_8.as_canonical_u64(); match v_8.as_canonical_u64() { 0u64 => { let [v_9]: [G; 1] = [G::from_u64(seed[10])]; row[offsets.auxiliaries + 6] = v_9.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, _ => { row[offsets.auxiliaries + 6] = (v_8 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }, _ => { row[offsets.auxiliaries + 5] = (v_7 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }; row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(699, v_4)) }, } } - -static SCHEMA_699: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32], offsets: &[0, 16, 20, 24, 8, 36, 37, 28, 38, 39, 32], bytes: 40 }; - -fn pack_706(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 => { Ok(()) }, 0u64 => { let [v_10]: [G; 1] = [G::from_u64(1)]; let [v_11, v_12, v_13, v_14, v_15, v_16]: [G; 6] = context.call::<6>(2, 779, &[v_8, v_10, v_1, v_2, v_3, v_4, v_5, v_6])?; seed[11] = v_11.as_canonical_u64(); seed[12] = v_12.as_canonical_u64(); seed[13] = v_13.as_canonical_u64(); seed[14] = v_14.as_canonical_u64(); seed[15] = v_15.as_canonical_u64(); seed[16] = v_16.as_canonical_u64(); let [v_17, v_18, v_19, v_20, v_21, v_22]: [G; 6] = context.returned::<6>(3)?; 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(); Ok(()) }, _ => { Err(no_match(706, v_7)) }, } } - -fn pack_706_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(117, v_7); seed.u32(96, v_8); seed.u32(100, v_9); match v_7.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_10]: [G; 1] = [G::from_u64(1)]; let [v_11, v_12, v_13, v_14, v_15, v_16]: [G; 6] = context.call::<6>(2, 779, &[v_8, v_10, v_1, v_2, v_3, v_4, v_5, v_6])?; seed.u8(118, v_11); seed.u8(119, v_12); seed.u32(104, v_13); seed.full(24, v_14); seed.u32(108, v_15); seed.u32(112, v_16); let [v_17, v_18, v_19, v_20, v_21, v_22]: [G; 6] = context.returned::<6>(3)?; seed.full(32, v_17); seed.full(40, v_18); seed.full(48, v_19); seed.full(56, v_20); seed.full(64, v_21); seed.full(72, v_22); Ok(()) }, _ => { Err(no_match(706, v_7)) }, } } - -fn write_706(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 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_11, v_12, v_13, v_14, v_15, v_16]: [G; 6] = [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])]; row[offsets.auxiliaries + 4] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_16.as_canonical_u64(); let [v_17, v_18, v_19, v_20, v_21, v_22]: [G; 6] = [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 + 10] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_22.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(706, v_7)) }, } } - -static SCHEMA_706: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 80, 116, 8, 84, 16, 88, 92, 117, 96, 100, 118, 119, 104, 24, 108, 112, 32, 40, 48, 56, 64, 72], bytes: 120 }; - -fn pack_709(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]: [G; 3] = context.load::<3>(0, v_1)?; seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); match v_17.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_20]: [G; 1] = context.call::<1>(1, 697, &[v_2, v_3])?; seed[21] = v_20.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_20.as_canonical_u64() { 1u64 => { let [v_21]: [G; 1] = context.call::<1>(3, 487, &[v_0, v_18])?; seed[22] = v_21.as_canonical_u64(); match v_21.as_canonical_u64() { 0u64 => { let [v_22]: [G; 1] = context.call::<1>(4, 486, &[v_0, v_18])?; seed[23] = v_22.as_canonical_u64(); break 'yield_0 []; }, _ => { break 'yield_0 []; }, } }, _ => { break 'yield_0 []; }, } }; Ok(()) }, _ => { Err(no_match(709, v_17)) }, } } - -fn pack_709_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]: [G; 3] = context.load::<3>(0, v_1)?; seed.u8(102, v_17); seed.u8(103, v_18); seed.u32(92, v_19); match v_17.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_20]: [G; 1] = context.call::<1>(1, 697, &[v_2, v_3])?; seed.u8(104, v_20); let []: [G; 0] = 'yield_0: { match v_20.as_canonical_u64() { 1u64 => { let [v_21]: [G; 1] = context.call::<1>(3, 487, &[v_0, v_18])?; seed.u8(105, v_21); match v_21.as_canonical_u64() { 0u64 => { let [v_22]: [G; 1] = context.call::<1>(4, 486, &[v_0, v_18])?; seed.u32(96, v_22); break 'yield_0 []; }, _ => { break 'yield_0 []; }, } }, _ => { break 'yield_0 []; }, } }; Ok(()) }, _ => { Err(no_match(709, v_17)) }, } } - -fn write_709(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]: [G; 3] = [G::from_u64(seed[18]), G::from_u64(seed[19]), G::from_u64(seed[20])]; 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(); match v_17.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_20]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 4] = v_20.as_canonical_u64(); let []: [G; 0] = 'yield_0: { match v_20.as_canonical_u64() { 1u64 => { let [v_21]: [G; 1] = [G::from_u64(seed[22])]; row[offsets.auxiliaries + 5] = v_21.as_canonical_u64(); match v_21.as_canonical_u64() { 0u64 => { let [v_22]: [G; 1] = [G::from_u64(seed[23])]; row[offsets.auxiliaries + 6] = v_22.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, _ => { row[offsets.auxiliaries + 6] = (v_21 - G::from_u64(0)).inverse().as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }, _ => { row[offsets.auxiliaries + 5] = (v_20 - G::from_u64(1)).inverse().as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); break 'yield_0 []; }, } }; row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(709, v_17)) }, } } - -static SCHEMA_709: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32], offsets: &[0, 56, 60, 64, 8, 100, 16, 68, 24, 72, 76, 101, 32, 80, 40, 84, 88, 48, 102, 103, 92, 104, 105, 96], bytes: 112 }; - -fn pack_710(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, v_15, v_16]: [G; 3] = context.load::<3>(0, v_1)?; seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_17]: [G; 1] = context.call::<1>(1, 707, &[v_15, v_8, v_9, v_10, v_11, v_12, v_13])?; seed[18] = v_17.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(710, v_14)) }, } } - -fn pack_710_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, v_15, v_16]: [G; 3] = context.load::<3>(0, v_1)?; seed.u8(78, v_14); seed.u8(79, v_15); seed.u32(72, v_16); match v_14.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_17]: [G; 1] = context.call::<1>(1, 707, &[v_15, v_8, v_9, v_10, v_11, v_12, v_13])?; seed.u8(80, v_17); Ok(()) }, _ => { Err(no_match(710, v_14)) }, } } - -fn write_710(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, v_15, v_16]: [G; 3] = [G::from_u64(seed[15]), G::from_u64(seed[16]), G::from_u64(seed[17])]; row[offsets.auxiliaries + 1] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_16.as_canonical_u64(); match v_14.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_17]: [G; 1] = [G::from_u64(seed[18])]; row[offsets.auxiliaries + 4] = v_17.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(710, v_14)) }, } } - -static SCHEMA_710: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8], offsets: &[0, 40, 44, 76, 8, 48, 16, 52, 56, 77, 24, 60, 32, 64, 68, 78, 79, 72, 80], bytes: 88 }; - -fn pack_712(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(); Ok(()) } - -fn pack_712_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(20, v_2); seed.u8(21, v_3); seed.u32(16, v_4); Ok(()) } - -fn write_712(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 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(712, v_2)) }, } } - -static SCHEMA_712: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32], offsets: &[0, 8, 12, 20, 21, 16], bytes: 24 }; - -fn pack_724(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, 6, &[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, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10])?; seed[11] = v_11.as_canonical_u64(); Ok(()) }, _ => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29]: [G; 18] = context.call::<18>(3, 122, &[v_0])?; seed[11] = v_12.as_canonical_u64(); seed[12] = v_13.as_canonical_u64(); 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(); seed[21] = v_22.as_canonical_u64(); seed[22] = v_23.as_canonical_u64(); seed[23] = v_24.as_canonical_u64(); 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(); let [v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37]: [G; 8] = context.call::<8>(4, 17, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; 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(); seed[33] = v_34.as_canonical_u64(); seed[34] = v_35.as_canonical_u64(); seed[35] = v_36.as_canonical_u64(); seed[36] = v_37.as_canonical_u64(); let [v_38, v_39]: [G; 2] = context.call::<2>(5, 724, &[v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37])?; seed[37] = v_38.as_canonical_u64(); seed[38] = v_39.as_canonical_u64(); let [v_40]: [G; 1] = [G::from_u64(0)]; let [v_41]: [G; 1] = context.store(7, &[v_40, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_38])?; seed[39] = v_41.as_canonical_u64(); Ok(()) }, } } - -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 = 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, 6, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed.u8(196, 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, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10, v_10])?; seed.full(72, v_11); Ok(()) }, _ => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29]: [G; 18] = context.call::<18>(3, 122, &[v_0])?; seed.full(72, v_12); seed.full(80, v_13); seed.u8(197, v_14); seed.u8(198, v_15); seed.u8(199, v_16); seed.u8(200, v_17); seed.u8(201, v_18); seed.u8(202, v_19); seed.full(88, v_20); seed.full(96, v_21); seed.u8(203, v_22); seed.u8(204, v_23); seed.u8(205, v_24); seed.u8(206, v_25); seed.u8(207, v_26); seed.u8(208, v_27); seed.u32(180, v_28); seed.u32(184, v_29); let [v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37]: [G; 8] = context.call::<8>(4, 17, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8])?; seed.full(104, v_30); seed.full(112, v_31); seed.full(120, v_32); seed.full(128, v_33); seed.full(136, v_34); seed.full(144, v_35); seed.full(152, v_36); seed.full(160, v_37); let [v_38, v_39]: [G; 2] = context.call::<2>(5, 724, &[v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37])?; seed.u32(188, v_38); seed.full(168, v_39); let [v_40]: [G; 1] = [G::from_u64(0)]; let [v_41]: [G; 1] = context.store(7, &[v_40, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_38])?; seed.u32(192, v_41); Ok(()) }, } } - -fn write_724(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; 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(); }, _ => { row[offsets.auxiliaries + 2] = (v_9 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29]: [G; 18] = [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])]; row[offsets.auxiliaries + 3] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_19.as_canonical_u64(); 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(); row[offsets.auxiliaries + 15] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_29.as_canonical_u64(); let [v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37]: [G; 8] = [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])]; row[offsets.auxiliaries + 21] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_37.as_canonical_u64(); let [v_38, v_39]: [G; 2] = [G::from_u64(seed[37]), G::from_u64(seed[38])]; row[offsets.auxiliaries + 29] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_39.as_canonical_u64(); let [v_41]: [G; 1] = [G::from_u64(seed[39])]; row[offsets.auxiliaries + 31] = v_41.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_724: 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::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, 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::Full, SeedWidth::U32], offsets: &[0, 176, 8, 16, 24, 32, 40, 48, 56, 64, 196, 72, 80, 197, 198, 199, 200, 201, 202, 88, 96, 203, 204, 205, 206, 207, 208, 180, 184, 104, 112, 120, 128, 136, 144, 152, 160, 188, 168, 192], bytes: 216 }; - -fn pack_727(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]: [G; 9] = context.call::<9>(0, 87, &[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(); let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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; 41] = context.call::<41>(1, 726, &[v_9])?; 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(); 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(); 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(); Ok(()) } - -fn pack_727_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]: [G; 9] = context.call::<9>(0, 87, &[v_0])?; seed.full(8, v_1); seed.full(16, v_2); seed.u8(116, v_3); seed.u8(117, v_4); seed.u8(118, v_5); seed.u8(119, v_6); seed.u8(120, v_7); seed.u8(121, v_8); seed.u32(108, v_9); let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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; 41] = context.call::<41>(1, 726, &[v_9])?; seed.u8(122, v_10); seed.full(24, v_11); seed.u8(123, v_12); seed.full(32, v_13); seed.full(40, v_14); seed.u8(124, v_15); seed.u8(125, v_16); seed.u8(126, v_17); seed.u8(127, v_18); seed.u8(128, v_19); seed.u8(129, v_20); seed.u8(130, v_21); seed.full(48, v_22); seed.full(56, v_23); seed.u8(131, v_24); seed.u8(132, v_25); seed.u8(133, v_26); seed.u8(134, v_27); seed.u8(135, v_28); seed.u8(136, v_29); seed.u8(137, v_30); seed.full(64, v_31); seed.full(72, v_32); seed.u8(138, v_33); seed.u8(139, v_34); seed.u8(140, v_35); seed.u8(141, v_36); seed.u8(142, v_37); seed.u8(143, v_38); seed.u8(144, v_39); seed.full(80, v_40); seed.full(88, v_41); seed.u8(145, v_42); seed.u8(146, v_43); seed.u8(147, v_44); seed.u8(148, v_45); seed.u8(149, v_46); seed.u8(150, v_47); seed.u8(151, v_48); seed.u32(112, v_49); seed.full(96, v_50); Ok(()) } - -fn write_727(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { 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]: [G; 9] = [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])]; 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(); let [v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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; 41] = [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])]; 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(); 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(); 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(); 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(); 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(); 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(); 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(); 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(); 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(); 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(); 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(); 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(); 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(); row[offsets.auxiliaries + 49] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_50.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } - -static SCHEMA_727: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 104, 8, 16, 116, 117, 118, 119, 120, 121, 108, 122, 24, 123, 32, 40, 124, 125, 126, 127, 128, 129, 130, 48, 56, 131, 132, 133, 134, 135, 136, 137, 64, 72, 138, 139, 140, 141, 142, 143, 144, 80, 88, 145, 146, 147, 148, 149, 150, 151, 112, 96], bytes: 152 }; - -fn pack_734(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, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18]: [G; 18] = context.load::<18>(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(); 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(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); let [v_19]: [G; 1] = [G::from_u64(1)]; let [v_20]: [G; 1] = context.store(2, &[v_19, v_19, v_19])?; seed[20] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = context.call::<1>(3, 38, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_20])?; seed[21] = v_21.as_canonical_u64(); let [v_22]: [G; 1] = context.returned::<1>(4)?; seed[22] = v_22.as_canonical_u64(); Ok(()) } - -fn pack_734_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, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18]: [G; 18] = context.load::<18>(0, v_0)?; seed.u8(28, v_1); seed.u8(29, v_2); seed.u8(30, v_3); seed.u8(31, v_4); seed.u8(32, v_5); seed.u8(33, v_6); seed.u8(34, v_7); seed.u8(35, v_8); seed.u8(36, v_9); seed.u8(37, v_10); seed.u8(38, v_11); seed.u8(39, v_12); seed.u8(40, v_13); seed.u8(41, v_14); seed.u8(42, v_15); seed.u8(43, v_16); seed.u8(44, v_17); seed.u32(12, v_18); let [v_19]: [G; 1] = [G::from_u64(1)]; let [v_20]: [G; 1] = context.store(2, &[v_19, v_19, v_19])?; seed.u32(16, v_20); let [v_21]: [G; 1] = context.call::<1>(3, 38, &[v_1, v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_20])?; seed.u32(20, v_21); let [v_22]: [G; 1] = context.returned::<1>(4)?; seed.u32(24, v_22); Ok(()) } - -fn write_734(seed: &[u64], offsets: RowOffsets, row: &mut [u64],) { 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, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18]: [G; 18] = [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]), 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])]; 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(); row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_12.as_canonical_u64(); 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(); 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(); let [v_20]: [G; 1] = [G::from_u64(seed[20])]; row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); let [v_21]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); let [v_22]: [G; 1] = [G::from_u64(seed[22])]; row[offsets.auxiliaries + 21] = v_22.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); } - -static SCHEMA_734: 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::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 8, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 12, 16, 20, 24], bytes: 48 }; - -fn pack_743(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, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 19] = context.load::<19>(0, v_1)?; 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(); 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(); seed[28] = v_27.as_canonical_u64(); seed[29] = v_28.as_canonical_u64(); match v_10.as_canonical_u64() { 1u64 => { let [v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39]: [G; 11] = context.load::<11>(1, v_0)?; 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(); Ok(()) }, 0u64 => { let [v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50]: [G; 11] = context.load::<11>(2, v_0)?; seed[30] = v_40.as_canonical_u64(); seed[31] = v_41.as_canonical_u64(); seed[32] = v_42.as_canonical_u64(); seed[33] = v_43.as_canonical_u64(); seed[34] = v_44.as_canonical_u64(); seed[35] = v_45.as_canonical_u64(); seed[36] = v_46.as_canonical_u64(); seed[37] = v_47.as_canonical_u64(); seed[38] = v_48.as_canonical_u64(); seed[39] = v_49.as_canonical_u64(); seed[40] = v_50.as_canonical_u64(); match v_40.as_canonical_u64() { 0u64 => { match v_11.as_canonical_u64() { _ => { match v_41.as_canonical_u64() { _ => { let [v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59]: [G; 8] = context.call::<8>(7, 16, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed[41] = v_52.as_canonical_u64(); seed[42] = v_53.as_canonical_u64(); seed[43] = v_54.as_canonical_u64(); seed[44] = v_55.as_canonical_u64(); seed[45] = v_56.as_canonical_u64(); seed[46] = v_57.as_canonical_u64(); seed[47] = v_58.as_canonical_u64(); seed[48] = v_59.as_canonical_u64(); Ok(()) }, } }, } }, _ => { Err(no_match(743, v_40)) }, } }, _ => { Err(no_match(743, v_10)) }, } } - -fn pack_743_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, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 19] = context.load::<19>(0, v_1)?; seed.u8(224, v_10); seed.full(48, v_11); seed.full(56, v_12); seed.full(64, v_13); seed.u32(188, v_14); seed.u32(192, v_15); seed.u32(196, v_16); seed.full(72, v_17); seed.full(80, v_18); seed.full(88, v_19); seed.full(96, v_20); seed.u8(225, v_21); seed.u8(226, v_22); seed.u8(227, v_23); seed.u8(228, v_24); seed.u8(229, v_25); seed.u8(230, v_26); seed.u32(200, v_27); seed.u32(204, v_28); match v_10.as_canonical_u64() { 1u64 => { let [v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39]: [G; 11] = context.load::<11>(1, v_0)?; seed.u8(231, v_29); seed.full(104, v_30); seed.full(112, v_31); seed.u8(232, v_32); seed.u8(233, v_33); seed.u8(234, v_34); seed.u8(235, v_35); seed.u8(236, v_36); seed.u8(237, v_37); seed.full(120, v_38); seed.u32(208, v_39); Ok(()) }, 0u64 => { let [v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50]: [G; 11] = context.load::<11>(2, v_0)?; seed.u8(231, v_40); seed.full(104, v_41); seed.full(112, v_42); seed.u8(232, v_43); seed.u8(233, v_44); seed.u8(234, v_45); seed.u8(235, v_46); seed.u8(236, v_47); seed.u8(237, v_48); seed.full(120, v_49); seed.u32(208, v_50); match v_40.as_canonical_u64() { 0u64 => { match v_11.as_canonical_u64() { _ => { match v_41.as_canonical_u64() { _ => { let [v_52, v_53, v_54, v_55, v_56, v_57, v_58, v_59]: [G; 8] = context.call::<8>(7, 16, &[v_2, v_3, v_4, v_5, v_6, v_7, v_8, v_9])?; seed.full(128, v_52); seed.full(136, v_53); seed.full(144, v_54); seed.u32(212, v_55); seed.u32(216, v_56); seed.u32(220, v_57); seed.full(152, v_58); seed.full(160, v_59); Ok(()) }, } }, } }, _ => { Err(no_match(743, v_40)) }, } }, _ => { Err(no_match(743, v_10)) }, } } - -fn write_743(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, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 19] = [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])]; row[offsets.auxiliaries + 1] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 7] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_19.as_canonical_u64(); 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(); row[offsets.auxiliaries + 15] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_28.as_canonical_u64(); match v_10.as_canonical_u64() { 1u64 => { let [v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39]: [G; 11] = [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])]; row[offsets.auxiliaries + 20] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_39.as_canonical_u64(); match v_29.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(743, v_29)) }, } }, 0u64 => { let [v_40, v_41, v_42, v_43, v_44, v_45, v_46, v_47, v_48, v_49, v_50]: [G; 11] = [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])]; row[offsets.auxiliaries + 20] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_50.as_canonical_u64(); match v_40.as_canonical_u64() { 0u64 => { match v_11.as_canonical_u64() { _ => { match v_41.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[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])]; row[offsets.auxiliaries + 31] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_53.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_54.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_55.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_56.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_59.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, } }, } }, _ => { Err(no_match(743, v_40)) }, } }, _ => { Err(no_match(743, v_10)) }, } } - -static SCHEMA_743: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, 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::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 168, 172, 8, 16, 24, 176, 180, 184, 32, 40, 224, 48, 56, 64, 188, 192, 196, 72, 80, 88, 96, 225, 226, 227, 228, 229, 230, 200, 204, 231, 104, 112, 232, 233, 234, 235, 236, 237, 120, 208, 128, 136, 144, 212, 216, 220, 152, 160], bytes: 240 }; - -fn pack_746(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, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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]: [G; 50] = context.load::<50>(0, v_1)?; 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(); 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(); 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(); 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(); Ok(()) } - -fn pack_746_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, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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]: [G; 50] = context.load::<50>(0, v_1)?; seed.u8(112, v_2); seed.full(8, v_3); seed.full(16, v_4); seed.u8(113, v_5); seed.u8(114, v_6); seed.u8(115, v_7); seed.u8(116, v_8); seed.u8(117, v_9); seed.u8(118, v_10); seed.u8(119, v_11); seed.full(24, v_12); seed.u8(120, v_13); seed.full(32, v_14); seed.full(40, v_15); seed.u8(121, v_16); seed.u8(122, v_17); seed.u8(123, v_18); seed.u8(124, v_19); seed.u8(125, v_20); seed.u8(126, v_21); seed.u8(127, v_22); seed.full(48, v_23); seed.full(56, v_24); seed.u8(128, v_25); seed.u8(129, v_26); seed.u8(130, v_27); seed.u8(131, v_28); seed.u8(132, v_29); seed.u8(133, v_30); seed.u8(134, v_31); seed.full(64, v_32); seed.full(72, v_33); seed.u8(135, v_34); seed.u8(136, v_35); seed.u8(137, v_36); seed.u8(138, v_37); seed.u8(139, v_38); seed.u8(140, v_39); seed.u8(141, v_40); seed.full(80, v_41); seed.full(88, v_42); seed.u8(142, v_43); seed.u8(143, v_44); seed.u8(144, v_45); seed.u8(145, v_46); seed.u8(146, v_47); seed.u8(147, v_48); seed.u8(148, v_49); seed.u32(104, v_50); seed.u32(108, v_51); Ok(()) } - -fn write_746(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, v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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]: [G; 50] = [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]), 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])]; 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(); 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.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_51.as_canonical_u64(); match v_2.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(746, v_2)) }, } } - -static SCHEMA_746: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 96, 100, 112, 8, 16, 113, 114, 115, 116, 117, 118, 119, 24, 120, 32, 40, 121, 122, 123, 124, 125, 126, 127, 48, 56, 128, 129, 130, 131, 132, 133, 134, 64, 72, 135, 136, 137, 138, 139, 140, 141, 80, 88, 142, 143, 144, 145, 146, 147, 148, 104, 108], bytes: 152 }; - -fn pack_752(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]: [G; 1] = [G::from_u64(0)]; let [v_9, v_10]: [G; 2] = context.io_info(1, v_8, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7])?; seed[9] = v_9.as_canonical_u64(); seed[10] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = context.call::<1>(2, 5, &[v_8, v_9, v_10])?; seed[11] = v_11.as_canonical_u64(); let [v_12]: [G; 1] = [G::from_u64(103)]; let [v_13]: [G; 1] = [G::from_u64(230)]; let [v_14]: [G; 1] = [G::from_u64(9)]; let [v_15]: [G; 1] = [G::from_u64(106)]; let [v_16]: [G; 1] = [G::from_u64(133)]; let [v_17]: [G; 1] = [G::from_u64(174)]; let [v_18]: [G; 1] = [G::from_u64(187)]; let [v_19]: [G; 1] = [G::from_u64(114)]; let [v_20]: [G; 1] = [G::from_u64(243)]; let [v_21]: [G; 1] = [G::from_u64(110)]; let [v_22]: [G; 1] = [G::from_u64(60)]; let [v_23]: [G; 1] = [G::from_u64(58)]; let [v_24]: [G; 1] = [G::from_u64(245)]; let [v_25]: [G; 1] = [G::from_u64(79)]; let [v_26]: [G; 1] = [G::from_u64(165)]; let [v_27]: [G; 1] = [G::from_u64(127)]; let [v_28]: [G; 1] = [G::from_u64(82)]; let [v_29]: [G; 1] = [G::from_u64(14)]; let [v_30]: [G; 1] = [G::from_u64(81)]; let [v_31]: [G; 1] = [G::from_u64(140)]; let [v_32]: [G; 1] = [G::from_u64(104)]; let [v_33]: [G; 1] = [G::from_u64(5)]; let [v_34]: [G; 1] = [G::from_u64(155)]; let [v_35]: [G; 1] = [G::from_u64(171)]; let [v_36]: [G; 1] = [G::from_u64(217)]; let [v_37]: [G; 1] = [G::from_u64(131)]; let [v_38]: [G; 1] = [G::from_u64(31)]; let [v_39]: [G; 1] = [G::from_u64(25)]; let [v_40]: [G; 1] = [G::from_u64(205)]; let [v_41]: [G; 1] = [G::from_u64(224)]; let [v_42]: [G; 1] = [G::from_u64(91)]; let [v_43]: [G; 1] = [G::from_u64(1)]; let [v_44]: [G; 1] = context.store(35, &[v_43, v_43, v_43])?; seed[12] = v_44.as_canonical_u64(); let [v_45]: [G; 1] = context.store(36, &[v_8, v_8, v_8, v_8, v_8, v_8, v_8, v_8])?; seed[13] = v_45.as_canonical_u64(); let [v_46]: [G; 1] = context.store(37, &[v_12, v_13, v_14, v_15, v_16, v_17, v_12, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42])?; seed[14] = v_46.as_canonical_u64(); let [v_47]: [G; 1] = context.store(38, &[v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43])?; seed[15] = v_47.as_canonical_u64(); let [v_48]: [G; 1] = context.call::<1>(39, 26, &[v_11, v_44, v_8, v_8, v_45, v_46, v_47])?; seed[16] = v_48.as_canonical_u64(); let [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]: [G; 32] = context.call::<32>(40, 25, &[v_48])?; 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(); seed[43] = v_75.as_canonical_u64(); seed[44] = v_76.as_canonical_u64(); seed[45] = v_77.as_canonical_u64(); seed[46] = v_78.as_canonical_u64(); seed[47] = v_79.as_canonical_u64(); seed[48] = v_80.as_canonical_u64(); let [v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141]: [G; 10] = context.call::<10>(93, 85, &[v_11])?; seed[49] = v_132.as_canonical_u64(); seed[50] = v_133.as_canonical_u64(); seed[51] = v_134.as_canonical_u64(); seed[52] = v_135.as_canonical_u64(); seed[53] = v_136.as_canonical_u64(); seed[54] = v_137.as_canonical_u64(); seed[55] = v_138.as_canonical_u64(); seed[56] = v_139.as_canonical_u64(); seed[57] = v_140.as_canonical_u64(); seed[58] = v_141.as_canonical_u64(); let [v_148, v_149]: [G; 2] = context.call::<2>(102, 83, &[v_141])?; seed[59] = v_148.as_canonical_u64(); seed[60] = v_149.as_canonical_u64(); let [v_151, v_152]: [G; 2] = context.call::<2>(105, 83, &[v_149])?; seed[61] = v_151.as_canonical_u64(); seed[62] = v_152.as_canonical_u64(); match v_133.as_canonical_u64() { 3u64 => { let [v_153]: [G; 1] = [G::from_u64(3)]; let [v_154, v_155, v_156, v_157]: [G; 4] = context.call::<4>(108, 718, &[v_152])?; seed[63] = v_154.as_canonical_u64(); seed[64] = v_155.as_canonical_u64(); seed[65] = v_156.as_canonical_u64(); seed[66] = v_157.as_canonical_u64(); let [v_158]: [G; 1] = context.call::<1>(109, 468, &[v_154, v_153, v_155, v_156])?; seed[67] = v_158.as_canonical_u64(); let [v_159, v_160]: [G; 2] = context.call::<2>(110, 102, &[v_157])?; seed[68] = v_159.as_canonical_u64(); seed[69] = v_160.as_canonical_u64(); let [v_161, v_162]: [G; 2] = context.call::<2>(111, 102, &[v_160])?; seed[70] = v_161.as_canonical_u64(); seed[71] = v_162.as_canonical_u64(); let [v_163, v_164, v_165]: [G; 3] = context.call::<3>(112, 717, &[v_162])?; seed[72] = v_163.as_canonical_u64(); seed[73] = v_164.as_canonical_u64(); seed[74] = v_165.as_canonical_u64(); let [v_166, v_167, v_168]: [G; 3] = context.load::<3>(113, v_165)?; seed[75] = v_166.as_canonical_u64(); seed[76] = v_167.as_canonical_u64(); seed[77] = v_168.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_170, v_171, v_172, v_173]: [G; 4] = context.call::<4>(117, 718, &[v_152])?; seed[63] = v_170.as_canonical_u64(); seed[64] = v_171.as_canonical_u64(); seed[65] = v_172.as_canonical_u64(); seed[66] = v_173.as_canonical_u64(); let [v_174]: [G; 1] = context.call::<1>(118, 468, &[v_170, v_151, v_171, v_172])?; seed[67] = v_174.as_canonical_u64(); let [v_175, v_176]: [G; 2] = context.call::<2>(119, 102, &[v_173])?; seed[68] = v_175.as_canonical_u64(); seed[69] = v_176.as_canonical_u64(); let [v_177, v_178, v_179]: [G; 3] = context.call::<3>(120, 717, &[v_176])?; seed[70] = v_177.as_canonical_u64(); seed[71] = v_178.as_canonical_u64(); seed[72] = v_179.as_canonical_u64(); let [v_180, v_181, v_182]: [G; 3] = context.load::<3>(121, v_179)?; seed[73] = v_180.as_canonical_u64(); seed[74] = v_181.as_canonical_u64(); seed[75] = v_182.as_canonical_u64(); match v_177.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_184]: [G; 1] = context.call::<1>(125, 705, &[v_178])?; seed[76] = v_184.as_canonical_u64(); let [v_185]: [G; 1] = [G::from_u64(1)]; let [v_186, v_187, v_188, v_189, v_190, v_191]: [G; 6] = context.call::<6>(127, 706, &[v_184, v_185, v_185, v_185, v_185, v_185, v_185])?; seed[77] = v_186.as_canonical_u64(); seed[78] = v_187.as_canonical_u64(); seed[79] = v_188.as_canonical_u64(); seed[80] = v_189.as_canonical_u64(); seed[81] = v_190.as_canonical_u64(); seed[82] = v_191.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(752, v_177)) }, } }, 5u64 => { let [v_193, v_194, v_195, v_196]: [G; 4] = context.call::<4>(130, 718, &[v_152])?; seed[63] = v_193.as_canonical_u64(); seed[64] = v_194.as_canonical_u64(); seed[65] = v_195.as_canonical_u64(); seed[66] = v_196.as_canonical_u64(); let [v_197]: [G; 1] = context.call::<1>(131, 468, &[v_193, v_151, v_194, v_195])?; seed[67] = v_197.as_canonical_u64(); let [v_198, v_199]: [G; 2] = context.call::<2>(132, 102, &[v_196])?; seed[68] = v_198.as_canonical_u64(); seed[69] = v_199.as_canonical_u64(); let [v_200, v_201, v_202]: [G; 3] = context.call::<3>(133, 717, &[v_199])?; seed[70] = v_200.as_canonical_u64(); seed[71] = v_201.as_canonical_u64(); seed[72] = v_202.as_canonical_u64(); let [v_203, v_204, v_205]: [G; 3] = context.load::<3>(134, v_202)?; seed[73] = v_203.as_canonical_u64(); seed[74] = v_204.as_canonical_u64(); seed[75] = v_205.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_208, v_209]: [G; 2] = context.call::<2>(140, 102, &[v_152])?; seed[63] = v_208.as_canonical_u64(); seed[64] = v_209.as_canonical_u64(); let [v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, 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]: [G; 55] = context.call::<55>(141, 733, &[v_209])?; seed[65] = v_210.as_canonical_u64(); seed[66] = v_211.as_canonical_u64(); seed[67] = v_212.as_canonical_u64(); seed[68] = v_213.as_canonical_u64(); seed[69] = v_214.as_canonical_u64(); seed[70] = v_215.as_canonical_u64(); seed[71] = v_216.as_canonical_u64(); seed[72] = v_217.as_canonical_u64(); seed[73] = v_218.as_canonical_u64(); seed[74] = v_219.as_canonical_u64(); seed[75] = v_220.as_canonical_u64(); seed[76] = v_221.as_canonical_u64(); seed[77] = v_222.as_canonical_u64(); seed[78] = v_223.as_canonical_u64(); seed[79] = v_224.as_canonical_u64(); seed[80] = v_225.as_canonical_u64(); seed[81] = v_226.as_canonical_u64(); seed[82] = v_227.as_canonical_u64(); seed[83] = v_228.as_canonical_u64(); seed[84] = v_229.as_canonical_u64(); seed[85] = v_230.as_canonical_u64(); seed[86] = v_231.as_canonical_u64(); seed[87] = v_232.as_canonical_u64(); seed[88] = v_233.as_canonical_u64(); seed[89] = v_234.as_canonical_u64(); seed[90] = v_235.as_canonical_u64(); seed[91] = v_236.as_canonical_u64(); seed[92] = v_237.as_canonical_u64(); seed[93] = v_238.as_canonical_u64(); seed[94] = v_239.as_canonical_u64(); seed[95] = v_240.as_canonical_u64(); seed[96] = v_241.as_canonical_u64(); seed[97] = v_242.as_canonical_u64(); seed[98] = v_243.as_canonical_u64(); seed[99] = v_244.as_canonical_u64(); seed[100] = v_245.as_canonical_u64(); seed[101] = v_246.as_canonical_u64(); seed[102] = v_247.as_canonical_u64(); seed[103] = v_248.as_canonical_u64(); seed[104] = v_249.as_canonical_u64(); seed[105] = v_250.as_canonical_u64(); seed[106] = v_251.as_canonical_u64(); seed[107] = v_252.as_canonical_u64(); seed[108] = v_253.as_canonical_u64(); seed[109] = v_254.as_canonical_u64(); seed[110] = v_255.as_canonical_u64(); seed[111] = v_256.as_canonical_u64(); seed[112] = v_257.as_canonical_u64(); seed[113] = v_258.as_canonical_u64(); seed[114] = v_259.as_canonical_u64(); seed[115] = v_260.as_canonical_u64(); seed[116] = v_261.as_canonical_u64(); seed[117] = v_262.as_canonical_u64(); seed[118] = v_263.as_canonical_u64(); seed[119] = v_264.as_canonical_u64(); let [v_265, v_266, v_267]: [G; 3] = context.load::<3>(142, v_264)?; seed[120] = v_265.as_canonical_u64(); seed[121] = v_266.as_canonical_u64(); seed[122] = v_267.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_270, v_271]: [G; 2] = context.call::<2>(148, 102, &[v_152])?; seed[63] = v_270.as_canonical_u64(); seed[64] = v_271.as_canonical_u64(); let [v_272, v_273]: [G; 2] = context.call::<2>(149, 102, &[v_271])?; seed[65] = v_272.as_canonical_u64(); seed[66] = v_273.as_canonical_u64(); let [v_274, v_275, v_276]: [G; 3] = context.load::<3>(150, v_273)?; seed[67] = v_274.as_canonical_u64(); seed[68] = v_275.as_canonical_u64(); seed[69] = v_276.as_canonical_u64(); Ok(()) }, 9u64 => { Ok(()) }, 10u64 => { let [v_282, v_283]: [G; 2] = context.call::<2>(161, 102, &[v_152])?; seed[63] = v_282.as_canonical_u64(); seed[64] = v_283.as_canonical_u64(); let [v_284]: [G; 1] = [G::from_u64(109)]; let [v_285]: [G; 1] = [G::from_u64(2)]; let [v_286]: [G; 1] = [G::from_u64(21)]; let [v_287]: [G; 1] = [G::from_u64(62)]; let [v_288]: [G; 1] = [G::from_u64(163)]; let [v_289]: [G; 1] = [G::from_u64(17)]; let [v_290]: [G; 1] = [G::from_u64(243)]; let [v_291]: [G; 1] = [G::from_u64(239)]; let [v_292]: [G; 1] = [G::from_u64(209)]; let [v_293]: [G; 1] = [G::from_u64(119)]; let [v_294]: [G; 1] = [G::from_u64(140)]; let [v_295]: [G; 1] = [G::from_u64(73)]; let [v_296]: [G; 1] = [G::from_u64(178)]; let [v_297]: [G; 1] = [G::from_u64(238)]; let [v_298]: [G; 1] = [G::from_u64(95)]; let [v_299]: [G; 1] = [G::from_u64(49)]; let [v_300]: [G; 1] = [G::from_u64(231)]; let [v_301]: [G; 1] = [G::from_u64(154)]; let [v_302]: [G; 1] = [G::from_u64(11)]; let [v_303]: [G; 1] = [G::from_u64(174)]; let [v_304]: [G; 1] = [G::from_u64(149)]; let [v_305]: [G; 1] = [G::from_u64(229)]; let [v_306]: [G; 1] = [G::from_u64(51)]; let [v_307]: [G; 1] = [G::from_u64(160)]; let [v_308]: [G; 1] = [G::from_u64(141)]; let [v_309]: [G; 1] = [G::from_u64(20)]; let [v_310]: [G; 1] = [G::from_u64(252)]; let [v_311]: [G; 1] = [G::from_u64(5)]; let [v_312]: [G; 1] = [G::from_u64(87)]; let [v_313]: [G; 1] = [G::from_u64(45)]; let [v_314]: [G; 1] = context.store(192, &[v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_295, v_309, v_310, v_311, v_312, v_313, v_306])?; seed[65] = v_314.as_canonical_u64(); let [v_315]: [G; 1] = context.call::<1>(193, 2, &[v_282, v_314])?; seed[66] = v_315.as_canonical_u64(); let [v_317, v_318]: [G; 2] = context.call::<2>(196, 102, &[v_283])?; seed[67] = v_317.as_canonical_u64(); seed[68] = v_318.as_canonical_u64(); let [v_319, v_320, v_321]: [G; 3] = context.load::<3>(197, v_318)?; seed[69] = v_319.as_canonical_u64(); seed[70] = v_320.as_canonical_u64(); seed[71] = v_321.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(752, v_133)) }, } } - -fn pack_752_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]: [G; 1] = [G::from_u64(0)]; let [v_9, v_10]: [G; 2] = context.io_info(1, v_8, &[v_0, v_1, v_2, v_3, v_4, v_5, v_6, v_7])?; seed.u32(416, v_9); seed.u32(420, v_10); let [v_11]: [G; 1] = context.call::<1>(2, 5, &[v_8, v_9, v_10])?; seed.u32(424, v_11); let [v_12]: [G; 1] = [G::from_u64(103)]; let [v_13]: [G; 1] = [G::from_u64(230)]; let [v_14]: [G; 1] = [G::from_u64(9)]; let [v_15]: [G; 1] = [G::from_u64(106)]; let [v_16]: [G; 1] = [G::from_u64(133)]; let [v_17]: [G; 1] = [G::from_u64(174)]; let [v_18]: [G; 1] = [G::from_u64(187)]; let [v_19]: [G; 1] = [G::from_u64(114)]; let [v_20]: [G; 1] = [G::from_u64(243)]; let [v_21]: [G; 1] = [G::from_u64(110)]; let [v_22]: [G; 1] = [G::from_u64(60)]; let [v_23]: [G; 1] = [G::from_u64(58)]; let [v_24]: [G; 1] = [G::from_u64(245)]; let [v_25]: [G; 1] = [G::from_u64(79)]; let [v_26]: [G; 1] = [G::from_u64(165)]; let [v_27]: [G; 1] = [G::from_u64(127)]; let [v_28]: [G; 1] = [G::from_u64(82)]; let [v_29]: [G; 1] = [G::from_u64(14)]; let [v_30]: [G; 1] = [G::from_u64(81)]; let [v_31]: [G; 1] = [G::from_u64(140)]; let [v_32]: [G; 1] = [G::from_u64(104)]; let [v_33]: [G; 1] = [G::from_u64(5)]; let [v_34]: [G; 1] = [G::from_u64(155)]; let [v_35]: [G; 1] = [G::from_u64(171)]; let [v_36]: [G; 1] = [G::from_u64(217)]; let [v_37]: [G; 1] = [G::from_u64(131)]; let [v_38]: [G; 1] = [G::from_u64(31)]; let [v_39]: [G; 1] = [G::from_u64(25)]; let [v_40]: [G; 1] = [G::from_u64(205)]; let [v_41]: [G; 1] = [G::from_u64(224)]; let [v_42]: [G; 1] = [G::from_u64(91)]; let [v_43]: [G; 1] = [G::from_u64(1)]; let [v_44]: [G; 1] = context.store(35, &[v_43, v_43, v_43])?; seed.u32(428, v_44); let [v_45]: [G; 1] = context.store(36, &[v_8, v_8, v_8, v_8, v_8, v_8, v_8, v_8])?; seed.u32(432, v_45); let [v_46]: [G; 1] = context.store(37, &[v_12, v_13, v_14, v_15, v_16, v_17, v_12, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36, v_37, v_38, v_39, v_40, v_41, v_42])?; seed.u32(436, v_46); let [v_47]: [G; 1] = context.store(38, &[v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43, v_43])?; seed.u32(440, v_47); let [v_48]: [G; 1] = context.call::<1>(39, 26, &[v_11, v_44, v_8, v_8, v_45, v_46, v_47])?; seed.u32(444, v_48); let [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]: [G; 32] = context.call::<32>(40, 25, &[v_48])?; seed.full(72, v_49); seed.full(80, v_50); seed.full(88, v_51); seed.full(96, v_52); seed.full(104, v_53); seed.full(112, v_54); seed.full(120, v_55); seed.full(128, v_56); seed.full(136, v_57); seed.full(144, v_58); seed.full(152, v_59); seed.full(160, v_60); seed.full(168, v_61); seed.full(176, v_62); seed.full(184, v_63); seed.full(192, v_64); seed.full(200, v_65); seed.full(208, v_66); seed.full(216, v_67); seed.full(224, v_68); seed.full(232, v_69); seed.full(240, v_70); seed.full(248, v_71); seed.full(256, v_72); seed.full(264, v_73); seed.full(272, v_74); seed.full(280, v_75); seed.full(288, v_76); seed.full(296, v_77); seed.full(304, v_78); seed.full(312, v_79); seed.full(320, v_80); let [v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141]: [G; 10] = context.call::<10>(93, 85, &[v_11])?; seed.u8(532, v_132); seed.u8(533, v_133); seed.full(328, v_134); seed.u8(534, v_135); seed.u8(535, v_136); seed.u8(536, v_137); seed.u8(537, v_138); seed.u8(538, v_139); seed.u8(539, v_140); seed.u32(448, v_141); let [v_148, v_149]: [G; 2] = context.call::<2>(102, 83, &[v_141])?; seed.u8(540, v_148); seed.u32(452, v_149); let [v_151, v_152]: [G; 2] = context.call::<2>(105, 83, &[v_149])?; seed.u8(541, v_151); seed.u32(456, v_152); match v_133.as_canonical_u64() { 3u64 => { let [v_153]: [G; 1] = [G::from_u64(3)]; let [v_154, v_155, v_156, v_157]: [G; 4] = context.call::<4>(108, 718, &[v_152])?; seed.u32(460, v_154); seed.u32(464, v_155); seed.u32(468, v_156); seed.u32(472, v_157); let [v_158]: [G; 1] = context.call::<1>(109, 468, &[v_154, v_153, v_155, v_156])?; seed.u32(476, v_158); let [v_159, v_160]: [G; 2] = context.call::<2>(110, 102, &[v_157])?; seed.u32(480, v_159); seed.u32(484, v_160); let [v_161, v_162]: [G; 2] = context.call::<2>(111, 102, &[v_160])?; seed.u32(488, v_161); seed.full(336, v_162); let [v_163, v_164, v_165]: [G; 3] = context.call::<3>(112, 717, &[v_162])?; seed.full(344, v_163); seed.u32(492, v_164); seed.u32(496, v_165); let [v_166, v_167, v_168]: [G; 3] = context.load::<3>(113, v_165)?; seed.u8(542, v_166); seed.u32(500, v_167); seed.u8(543, v_168); Ok(()) }, 4u64 => { let [v_170, v_171, v_172, v_173]: [G; 4] = context.call::<4>(117, 718, &[v_152])?; seed.u32(460, v_170); seed.u32(464, v_171); seed.u32(468, v_172); seed.u32(472, v_173); let [v_174]: [G; 1] = context.call::<1>(118, 468, &[v_170, v_151, v_171, v_172])?; seed.u32(476, v_174); let [v_175, v_176]: [G; 2] = context.call::<2>(119, 102, &[v_173])?; seed.u32(480, v_175); seed.u32(484, v_176); let [v_177, v_178, v_179]: [G; 3] = context.call::<3>(120, 717, &[v_176])?; seed.u32(488, v_177); seed.full(336, v_178); seed.full(344, v_179); let [v_180, v_181, v_182]: [G; 3] = context.load::<3>(121, v_179)?; seed.u32(492, v_180); seed.u32(496, v_181); seed.u8(542, v_182); match v_177.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_184]: [G; 1] = context.call::<1>(125, 705, &[v_178])?; seed.u32(500, v_184); let [v_185]: [G; 1] = [G::from_u64(1)]; let [v_186, v_187, v_188, v_189, v_190, v_191]: [G; 6] = context.call::<6>(127, 706, &[v_184, v_185, v_185, v_185, v_185, v_185, v_185])?; seed.u8(543, v_186); seed.full(352, v_187); seed.u32(504, v_188); seed.full(360, v_189); seed.u32(508, v_190); seed.u32(512, v_191); Ok(()) }, _ => { Err(no_match(752, v_177)) }, } }, 5u64 => { let [v_193, v_194, v_195, v_196]: [G; 4] = context.call::<4>(130, 718, &[v_152])?; seed.u32(460, v_193); seed.u32(464, v_194); seed.u32(468, v_195); seed.u32(472, v_196); let [v_197]: [G; 1] = context.call::<1>(131, 468, &[v_193, v_151, v_194, v_195])?; seed.u32(476, v_197); let [v_198, v_199]: [G; 2] = context.call::<2>(132, 102, &[v_196])?; seed.u32(480, v_198); seed.u32(484, v_199); let [v_200, v_201, v_202]: [G; 3] = context.call::<3>(133, 717, &[v_199])?; seed.u32(488, v_200); seed.full(336, v_201); seed.full(344, v_202); let [v_203, v_204, v_205]: [G; 3] = context.load::<3>(134, v_202)?; seed.u32(492, v_203); seed.u32(496, v_204); seed.u8(542, v_205); Ok(()) }, 6u64 => { let [v_208, v_209]: [G; 2] = context.call::<2>(140, 102, &[v_152])?; seed.u32(460, v_208); seed.u32(464, v_209); let [v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, 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]: [G; 55] = context.call::<55>(141, 733, &[v_209])?; seed.u32(468, v_210); seed.u32(472, v_211); seed.u32(476, v_212); seed.u32(480, v_213); seed.u32(484, v_214); seed.u32(488, v_215); seed.full(336, v_216); seed.full(344, v_217); seed.u32(492, v_218); seed.u32(496, v_219); seed.u8(542, v_220); seed.u32(500, v_221); seed.u8(543, v_222); seed.full(352, v_223); seed.u32(504, v_224); seed.full(360, v_225); seed.u32(508, v_226); seed.u32(512, v_227); seed.u8(544, v_228); seed.u8(545, v_229); seed.u32(516, v_230); seed.u8(546, v_231); seed.u8(547, v_232); seed.u8(548, v_233); seed.full(368, v_234); seed.full(376, v_235); seed.u8(549, v_236); seed.u8(550, v_237); seed.u8(551, v_238); seed.u8(552, v_239); seed.u8(553, v_240); seed.u8(554, v_241); seed.u8(555, v_242); seed.full(384, v_243); seed.full(392, v_244); seed.u8(556, v_245); seed.u8(557, v_246); seed.u8(558, v_247); seed.u8(559, v_248); seed.u8(560, v_249); seed.u8(561, v_250); seed.u8(562, v_251); seed.full(400, v_252); seed.full(408, v_253); seed.u8(563, v_254); seed.u8(564, v_255); seed.u8(565, v_256); seed.u8(566, v_257); seed.u8(567, v_258); seed.u8(568, v_259); seed.u8(569, v_260); seed.u32(520, v_261); seed.u8(570, v_262); seed.u32(524, v_263); seed.u32(528, v_264); let [v_265, v_266, v_267]: [G; 3] = context.load::<3>(142, v_264)?; seed.u8(571, v_265); seed.u8(572, v_266); seed.u8(573, v_267); Ok(()) }, 7u64 => { let [v_270, v_271]: [G; 2] = context.call::<2>(148, 102, &[v_152])?; seed.u32(460, v_270); seed.u32(464, v_271); let [v_272, v_273]: [G; 2] = context.call::<2>(149, 102, &[v_271])?; seed.u32(468, v_272); seed.u32(472, v_273); let [v_274, v_275, v_276]: [G; 3] = context.load::<3>(150, v_273)?; seed.u32(476, v_274); seed.u32(480, v_275); seed.u32(484, v_276); Ok(()) }, 9u64 => { Ok(()) }, 10u64 => { let [v_282, v_283]: [G; 2] = context.call::<2>(161, 102, &[v_152])?; seed.u32(460, v_282); seed.u32(464, v_283); let [v_284]: [G; 1] = [G::from_u64(109)]; let [v_285]: [G; 1] = [G::from_u64(2)]; let [v_286]: [G; 1] = [G::from_u64(21)]; let [v_287]: [G; 1] = [G::from_u64(62)]; let [v_288]: [G; 1] = [G::from_u64(163)]; let [v_289]: [G; 1] = [G::from_u64(17)]; let [v_290]: [G; 1] = [G::from_u64(243)]; let [v_291]: [G; 1] = [G::from_u64(239)]; let [v_292]: [G; 1] = [G::from_u64(209)]; let [v_293]: [G; 1] = [G::from_u64(119)]; let [v_294]: [G; 1] = [G::from_u64(140)]; let [v_295]: [G; 1] = [G::from_u64(73)]; let [v_296]: [G; 1] = [G::from_u64(178)]; let [v_297]: [G; 1] = [G::from_u64(238)]; let [v_298]: [G; 1] = [G::from_u64(95)]; let [v_299]: [G; 1] = [G::from_u64(49)]; let [v_300]: [G; 1] = [G::from_u64(231)]; let [v_301]: [G; 1] = [G::from_u64(154)]; let [v_302]: [G; 1] = [G::from_u64(11)]; let [v_303]: [G; 1] = [G::from_u64(174)]; let [v_304]: [G; 1] = [G::from_u64(149)]; let [v_305]: [G; 1] = [G::from_u64(229)]; let [v_306]: [G; 1] = [G::from_u64(51)]; let [v_307]: [G; 1] = [G::from_u64(160)]; let [v_308]: [G; 1] = [G::from_u64(141)]; let [v_309]: [G; 1] = [G::from_u64(20)]; let [v_310]: [G; 1] = [G::from_u64(252)]; let [v_311]: [G; 1] = [G::from_u64(5)]; let [v_312]: [G; 1] = [G::from_u64(87)]; let [v_313]: [G; 1] = [G::from_u64(45)]; let [v_314]: [G; 1] = context.store(192, &[v_284, v_285, v_286, v_287, v_288, v_289, v_290, v_291, v_292, v_293, v_294, v_295, v_296, v_297, v_298, v_299, v_300, v_301, v_302, v_303, v_304, v_305, v_306, v_307, v_308, v_295, v_309, v_310, v_311, v_312, v_313, v_306])?; seed.u32(468, v_314); let [v_315]: [G; 1] = context.call::<1>(193, 2, &[v_282, v_314])?; seed.u32(472, v_315); let [v_317, v_318]: [G; 2] = context.call::<2>(196, 102, &[v_283])?; seed.u32(476, v_317); seed.u32(480, v_318); let [v_319, v_320, v_321]: [G; 3] = context.load::<3>(197, v_318)?; seed.u32(484, v_319); seed.u32(488, v_320); seed.full(336, v_321); Ok(()) }, _ => { Err(no_match(752, v_133)) }, } } - -fn write_752(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_9, v_10]: [G; 2] = [G::from_u64(seed[9]), G::from_u64(seed[10])]; row[offsets.auxiliaries + 1] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_10.as_canonical_u64(); let [v_11]: [G; 1] = [G::from_u64(seed[11])]; row[offsets.auxiliaries + 3] = v_11.as_canonical_u64(); let [v_44]: [G; 1] = [G::from_u64(seed[12])]; row[offsets.auxiliaries + 4] = v_44.as_canonical_u64(); let [v_45]: [G; 1] = [G::from_u64(seed[13])]; row[offsets.auxiliaries + 5] = v_45.as_canonical_u64(); let [v_46]: [G; 1] = [G::from_u64(seed[14])]; row[offsets.auxiliaries + 6] = v_46.as_canonical_u64(); let [v_47]: [G; 1] = [G::from_u64(seed[15])]; row[offsets.auxiliaries + 7] = v_47.as_canonical_u64(); let [v_48]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 8] = v_48.as_canonical_u64(); let [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]: [G; 32] = [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])]; 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(); row[offsets.auxiliaries + 17] = v_57.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_65.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_66.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_67.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_68.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_69.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_70.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_71.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_72.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_73.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_74.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_75.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_80.as_canonical_u64(); let [v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139, v_140, v_141]: [G; 10] = [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])]; row[offsets.auxiliaries + 41] = v_132.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_135.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_136.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_138.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_139.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_140.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_141.as_canonical_u64(); let [v_148, v_149]: [G; 2] = [G::from_u64(seed[59]), G::from_u64(seed[60])]; row[offsets.auxiliaries + 51] = v_148.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_149.as_canonical_u64(); let [v_151, v_152]: [G; 2] = [G::from_u64(seed[61]), G::from_u64(seed[62])]; row[offsets.auxiliaries + 53] = v_151.as_canonical_u64(); row[offsets.auxiliaries + 54] = v_152.as_canonical_u64(); match v_133.as_canonical_u64() { 3u64 => { let [v_154, v_155, v_156, v_157]: [G; 4] = [G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66])]; row[offsets.auxiliaries + 55] = v_154.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_155.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_156.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_157.as_canonical_u64(); let [v_158]: [G; 1] = [G::from_u64(seed[67])]; row[offsets.auxiliaries + 59] = v_158.as_canonical_u64(); let [v_159, v_160]: [G; 2] = [G::from_u64(seed[68]), G::from_u64(seed[69])]; row[offsets.auxiliaries + 60] = v_159.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_160.as_canonical_u64(); let [v_161, v_162]: [G; 2] = [G::from_u64(seed[70]), G::from_u64(seed[71])]; row[offsets.auxiliaries + 62] = v_161.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_162.as_canonical_u64(); let [v_163, v_164, v_165]: [G; 3] = [G::from_u64(seed[72]), G::from_u64(seed[73]), G::from_u64(seed[74])]; row[offsets.auxiliaries + 64] = v_163.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_164.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_165.as_canonical_u64(); let [v_166, v_167, v_168]: [G; 3] = [G::from_u64(seed[75]), G::from_u64(seed[76]), G::from_u64(seed[77])]; row[offsets.auxiliaries + 67] = v_166.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_167.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_168.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 4u64 => { let [v_170, v_171, v_172, v_173]: [G; 4] = [G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66])]; row[offsets.auxiliaries + 55] = v_170.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_171.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_172.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_173.as_canonical_u64(); let [v_174]: [G; 1] = [G::from_u64(seed[67])]; row[offsets.auxiliaries + 59] = v_174.as_canonical_u64(); let [v_175, v_176]: [G; 2] = [G::from_u64(seed[68]), G::from_u64(seed[69])]; row[offsets.auxiliaries + 60] = v_175.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_176.as_canonical_u64(); let [v_177, v_178, v_179]: [G; 3] = [G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72])]; row[offsets.auxiliaries + 62] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_179.as_canonical_u64(); let [v_180, v_181, v_182]: [G; 3] = [G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75])]; row[offsets.auxiliaries + 65] = v_180.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_181.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_182.as_canonical_u64(); match v_177.as_canonical_u64() { 1u64 => { row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_184]: [G; 1] = [G::from_u64(seed[76])]; row[offsets.auxiliaries + 68] = v_184.as_canonical_u64(); let [v_186, v_187, v_188, v_189, v_190, v_191]: [G; 6] = [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])]; row[offsets.auxiliaries + 69] = v_186.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_187.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_188.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_189.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_190.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_191.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(752, v_177)) }, } }, 5u64 => { let [v_193, v_194, v_195, v_196]: [G; 4] = [G::from_u64(seed[63]), G::from_u64(seed[64]), G::from_u64(seed[65]), G::from_u64(seed[66])]; row[offsets.auxiliaries + 55] = v_193.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_194.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_195.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_196.as_canonical_u64(); let [v_197]: [G; 1] = [G::from_u64(seed[67])]; row[offsets.auxiliaries + 59] = v_197.as_canonical_u64(); let [v_198, v_199]: [G; 2] = [G::from_u64(seed[68]), G::from_u64(seed[69])]; row[offsets.auxiliaries + 60] = v_198.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_199.as_canonical_u64(); let [v_200, v_201, v_202]: [G; 3] = [G::from_u64(seed[70]), G::from_u64(seed[71]), G::from_u64(seed[72])]; row[offsets.auxiliaries + 62] = v_200.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_201.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_202.as_canonical_u64(); let [v_203, v_204, v_205]: [G; 3] = [G::from_u64(seed[73]), G::from_u64(seed[74]), G::from_u64(seed[75])]; row[offsets.auxiliaries + 65] = v_203.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_204.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_205.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, 6u64 => { let [v_208, v_209]: [G; 2] = [G::from_u64(seed[63]), G::from_u64(seed[64])]; row[offsets.auxiliaries + 55] = v_208.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_209.as_canonical_u64(); let [v_210, v_211, v_212, v_213, v_214, v_215, v_216, v_217, v_218, v_219, v_220, v_221, v_222, v_223, v_224, v_225, v_226, v_227, v_228, v_229, v_230, v_231, v_232, v_233, v_234, v_235, v_236, v_237, v_238, v_239, v_240, 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]: [G; 55] = [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]), 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]), 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])]; row[offsets.auxiliaries + 57] = v_210.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_211.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_212.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_213.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_214.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_215.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_216.as_canonical_u64(); row[offsets.auxiliaries + 64] = v_217.as_canonical_u64(); row[offsets.auxiliaries + 65] = v_218.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_219.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_220.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_221.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_222.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_223.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_224.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_225.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_226.as_canonical_u64(); row[offsets.auxiliaries + 74] = v_227.as_canonical_u64(); row[offsets.auxiliaries + 75] = v_228.as_canonical_u64(); row[offsets.auxiliaries + 76] = v_229.as_canonical_u64(); row[offsets.auxiliaries + 77] = v_230.as_canonical_u64(); row[offsets.auxiliaries + 78] = v_231.as_canonical_u64(); row[offsets.auxiliaries + 79] = v_232.as_canonical_u64(); row[offsets.auxiliaries + 80] = v_233.as_canonical_u64(); row[offsets.auxiliaries + 81] = v_234.as_canonical_u64(); row[offsets.auxiliaries + 82] = v_235.as_canonical_u64(); row[offsets.auxiliaries + 83] = v_236.as_canonical_u64(); row[offsets.auxiliaries + 84] = v_237.as_canonical_u64(); row[offsets.auxiliaries + 85] = v_238.as_canonical_u64(); row[offsets.auxiliaries + 86] = v_239.as_canonical_u64(); row[offsets.auxiliaries + 87] = v_240.as_canonical_u64(); row[offsets.auxiliaries + 88] = v_241.as_canonical_u64(); row[offsets.auxiliaries + 89] = v_242.as_canonical_u64(); row[offsets.auxiliaries + 90] = v_243.as_canonical_u64(); row[offsets.auxiliaries + 91] = v_244.as_canonical_u64(); row[offsets.auxiliaries + 92] = v_245.as_canonical_u64(); row[offsets.auxiliaries + 93] = v_246.as_canonical_u64(); row[offsets.auxiliaries + 94] = v_247.as_canonical_u64(); row[offsets.auxiliaries + 95] = v_248.as_canonical_u64(); row[offsets.auxiliaries + 96] = v_249.as_canonical_u64(); row[offsets.auxiliaries + 97] = v_250.as_canonical_u64(); row[offsets.auxiliaries + 98] = v_251.as_canonical_u64(); row[offsets.auxiliaries + 99] = v_252.as_canonical_u64(); row[offsets.auxiliaries + 100] = v_253.as_canonical_u64(); row[offsets.auxiliaries + 101] = v_254.as_canonical_u64(); row[offsets.auxiliaries + 102] = v_255.as_canonical_u64(); row[offsets.auxiliaries + 103] = v_256.as_canonical_u64(); row[offsets.auxiliaries + 104] = v_257.as_canonical_u64(); row[offsets.auxiliaries + 105] = v_258.as_canonical_u64(); row[offsets.auxiliaries + 106] = v_259.as_canonical_u64(); row[offsets.auxiliaries + 107] = v_260.as_canonical_u64(); row[offsets.auxiliaries + 108] = v_261.as_canonical_u64(); row[offsets.auxiliaries + 109] = v_262.as_canonical_u64(); row[offsets.auxiliaries + 110] = v_263.as_canonical_u64(); row[offsets.auxiliaries + 111] = v_264.as_canonical_u64(); let [v_265, v_266, v_267]: [G; 3] = [G::from_u64(seed[120]), G::from_u64(seed[121]), G::from_u64(seed[122])]; row[offsets.auxiliaries + 112] = v_265.as_canonical_u64(); row[offsets.auxiliaries + 113] = v_266.as_canonical_u64(); row[offsets.auxiliaries + 114] = v_267.as_canonical_u64(); row[offsets.selectors + 4] = G::ONE.as_canonical_u64(); Ok(()) }, 7u64 => { let [v_270, v_271]: [G; 2] = [G::from_u64(seed[63]), G::from_u64(seed[64])]; row[offsets.auxiliaries + 55] = v_270.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_271.as_canonical_u64(); let [v_272, v_273]: [G; 2] = [G::from_u64(seed[65]), G::from_u64(seed[66])]; row[offsets.auxiliaries + 57] = v_272.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_273.as_canonical_u64(); let [v_274, v_275, v_276]: [G; 3] = [G::from_u64(seed[67]), G::from_u64(seed[68]), G::from_u64(seed[69])]; row[offsets.auxiliaries + 59] = v_274.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_275.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_276.as_canonical_u64(); row[offsets.selectors + 5] = G::ONE.as_canonical_u64(); Ok(()) }, 9u64 => { row[offsets.selectors + 6] = G::ONE.as_canonical_u64(); Ok(()) }, 10u64 => { let [v_282, v_283]: [G; 2] = [G::from_u64(seed[63]), G::from_u64(seed[64])]; row[offsets.auxiliaries + 55] = v_282.as_canonical_u64(); row[offsets.auxiliaries + 56] = v_283.as_canonical_u64(); let [v_314]: [G; 1] = [G::from_u64(seed[65])]; row[offsets.auxiliaries + 57] = v_314.as_canonical_u64(); let [v_315]: [G; 1] = [G::from_u64(seed[66])]; row[offsets.auxiliaries + 58] = v_315.as_canonical_u64(); let [v_317, v_318]: [G; 2] = [G::from_u64(seed[67]), G::from_u64(seed[68])]; row[offsets.auxiliaries + 59] = v_317.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_318.as_canonical_u64(); let [v_319, v_320, v_321]: [G; 3] = [G::from_u64(seed[69]), G::from_u64(seed[70]), G::from_u64(seed[71])]; row[offsets.auxiliaries + 61] = v_319.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_320.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_321.as_canonical_u64(); row[offsets.selectors + 7] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(752, v_133)) }, } } - -static SCHEMA_752: SeedSchema = SeedSchema { widths: &[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::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::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8], offsets: &[0, 8, 16, 24, 32, 40, 48, 56, 64, 416, 420, 424, 428, 432, 436, 440, 444, 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, 288, 296, 304, 312, 320, 532, 533, 328, 534, 535, 536, 537, 538, 539, 448, 540, 452, 541, 456, 460, 464, 468, 472, 476, 480, 484, 488, 336, 344, 492, 496, 542, 500, 543, 352, 504, 360, 508, 512, 544, 545, 516, 546, 547, 548, 368, 376, 549, 550, 551, 552, 553, 554, 555, 384, 392, 556, 557, 558, 559, 560, 561, 562, 400, 408, 563, 564, 565, 566, 567, 568, 569, 520, 570, 524, 528, 571, 572, 573], bytes: 576 }; - -fn pack_756(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, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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; 48] = context.call::<48>(0, 228, &[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(); 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(); 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(); 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(); match v_3.as_canonical_u64() { _ => { match v_3.as_canonical_u64() { 0u64 => { match v_4.as_canonical_u64() { _ => { let [v_52]: [G; 1] = [G::from_u64(1)]; let [v_53]: [G; 1] = context.call::<1>(5, 18, &[v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13])?; seed[52] = v_53.as_canonical_u64(); let [v_54]: [G; 1] = context.store(7, &[v_52, v_52, v_52])?; seed[53] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = context.call::<1>(8, 218, &[v_14, v_48, v_49, v_54, v_50])?; seed[54] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = context.returned::<1>(10)?; seed[55] = v_56.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(756, v_3)) }, } }, } } - -fn pack_756_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, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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; 48] = context.call::<48>(0, 228, &[v_0])?; seed.u8(152, v_3); seed.u8(153, v_4); seed.u8(154, v_5); seed.full(16, v_6); seed.full(24, v_7); seed.u8(155, v_8); seed.u8(156, v_9); seed.u8(157, v_10); seed.u8(158, v_11); seed.full(32, v_12); seed.u8(159, v_13); seed.u32(112, v_14); seed.u32(116, v_15); seed.u8(160, v_16); seed.u8(161, v_17); seed.u8(162, v_18); seed.u8(163, v_19); seed.u32(120, v_20); seed.u8(164, v_21); seed.full(40, v_22); seed.full(48, v_23); seed.u8(165, v_24); seed.u8(166, v_25); seed.u8(167, v_26); seed.u8(168, v_27); seed.u8(169, v_28); seed.u8(170, v_29); seed.full(56, v_30); seed.full(64, v_31); seed.u8(171, v_32); seed.u8(172, v_33); seed.u8(173, v_34); seed.u8(174, v_35); seed.u8(175, v_36); seed.u8(176, v_37); seed.full(72, v_38); seed.full(80, v_39); seed.u8(177, v_40); seed.u8(178, v_41); seed.u8(179, v_42); seed.u8(180, v_43); seed.u8(181, v_44); seed.u8(182, v_45); seed.full(88, v_46); seed.u32(124, v_47); seed.u32(128, v_48); seed.u32(132, v_49); seed.u32(136, v_50); match v_3.as_canonical_u64() { _ => { match v_3.as_canonical_u64() { 0u64 => { match v_4.as_canonical_u64() { _ => { let [v_52]: [G; 1] = [G::from_u64(1)]; let [v_53]: [G; 1] = context.call::<1>(5, 18, &[v_6, v_7, v_8, v_9, v_10, v_11, v_12, v_13])?; seed.full(96, v_53); let [v_54]: [G; 1] = context.store(7, &[v_52, v_52, v_52])?; seed.u32(140, v_54); let [v_55]: [G; 1] = context.call::<1>(8, 218, &[v_14, v_48, v_49, v_54, v_50])?; seed.u32(144, v_55); let [v_56]: [G; 1] = context.returned::<1>(10)?; seed.u32(148, v_56); Ok(()) }, } }, _ => { Err(no_match(756, v_3)) }, } }, } } - -fn write_756(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, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, 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; 48] = [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]), 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])]; 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(); 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(); row[offsets.auxiliaries + 14] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_28.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_29.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_30.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_31.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_32.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_33.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_34.as_canonical_u64(); row[offsets.auxiliaries + 33] = v_35.as_canonical_u64(); row[offsets.auxiliaries + 34] = v_36.as_canonical_u64(); row[offsets.auxiliaries + 35] = v_37.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_45.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 45] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_50.as_canonical_u64(); match v_3.as_canonical_u64() { _ => { match v_3.as_canonical_u64() { 0u64 => { match v_4.as_canonical_u64() { _ => { let [v_53]: [G; 1] = [G::from_u64(seed[52])]; row[offsets.auxiliaries + 49] = v_53.as_canonical_u64(); let [v_54]: [G; 1] = [G::from_u64(seed[53])]; row[offsets.auxiliaries + 50] = v_54.as_canonical_u64(); let [v_55]: [G; 1] = [G::from_u64(seed[54])]; row[offsets.auxiliaries + 51] = v_55.as_canonical_u64(); let [v_56]: [G; 1] = [G::from_u64(seed[55])]; row[offsets.auxiliaries + 52] = v_56.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, } }, _ => { Err(no_match(756, v_3)) }, } }, } } - -static SCHEMA_756: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U8, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 104, 8, 108, 152, 153, 154, 16, 24, 155, 156, 157, 158, 32, 159, 112, 116, 160, 161, 162, 163, 120, 164, 40, 48, 165, 166, 167, 168, 169, 170, 56, 64, 171, 172, 173, 174, 175, 176, 72, 80, 177, 178, 179, 180, 181, 182, 88, 124, 128, 132, 136, 96, 140, 144, 148], bytes: 184 }; - -fn pack_761(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 => { Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19]: [G; 8] = context.call::<8>(2, 761, &[v_10])?; seed[12] = v_12.as_canonical_u64(); seed[13] = v_13.as_canonical_u64(); 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(); let [v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27]: [G; 8] = context.returned::<8>(3)?; 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(); seed[24] = v_24.as_canonical_u64(); seed[25] = v_25.as_canonical_u64(); seed[26] = v_26.as_canonical_u64(); seed[27] = v_27.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(761, v_1)) }, } } - -fn pack_761_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(208, v_1); seed.full(8, v_2); seed.full(16, v_3); 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.u32(204, v_10); match v_1.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19]: [G; 8] = context.call::<8>(2, 761, &[v_10])?; seed.full(72, v_12); seed.full(80, v_13); seed.full(88, v_14); seed.full(96, v_15); seed.full(104, v_16); seed.full(112, v_17); seed.full(120, v_18); seed.full(128, v_19); let [v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27]: [G; 8] = context.returned::<8>(3)?; seed.full(136, v_20); seed.full(144, v_21); seed.full(152, v_22); seed.full(160, v_23); seed.full(168, v_24); seed.full(176, v_25); seed.full(184, v_26); seed.full(192, v_27); Ok(()) }, _ => { Err(no_match(761, v_1)) }, } } - -fn write_761(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 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19]: [G; 8] = [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])]; row[offsets.auxiliaries + 11] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_19.as_canonical_u64(); let [v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27]: [G; 8] = [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 + 19] = v_20.as_canonical_u64(); row[offsets.auxiliaries + 20] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_27.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(761, v_1)) }, } } - -static SCHEMA_761: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, 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], offsets: &[0, 200, 208, 8, 16, 24, 32, 40, 48, 56, 64, 204, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192], bytes: 216 }; - -fn pack_763(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]; match v_1.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_8, v_9, v_10, v_11, v_12, v_13]: [G; 6] = context.load::<6>(0, v_5)?; 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(); let [v_14, v_15, v_16, v_17, v_18, v_19]: [G; 6] = context.load::<6>(1, v_6)?; seed[15] = v_14.as_canonical_u64(); seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); seed[18] = v_17.as_canonical_u64(); seed[19] = v_18.as_canonical_u64(); seed[20] = v_19.as_canonical_u64(); let op_2 = u32_less_than(v_0, v_3); let [v_20]: [G; 1] = [op_2.0]; match v_20.as_canonical_u64() { 1u64 => { let [v_21]: [G; 1] = context.returned::<1>(3)?; seed[21] = v_21.as_canonical_u64(); Ok(()) }, _ => { let [v_22]: [G; 1] = [v_0 - v_3]; match v_22.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_23]: [G; 1] = context.returned::<1>(5)?; seed[21] = v_23.as_canonical_u64(); Ok(()) }, } }, } }, _ => { Err(no_match(763, v_1)) }, } } - -fn pack_763_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]; match v_1.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_8, v_9, v_10, v_11, v_12, v_13]: [G; 6] = context.load::<6>(0, v_5)?; seed.u8(113, v_8); seed.full(32, v_9); seed.u32(88, v_10); seed.full(40, v_11); seed.u32(92, v_12); seed.u32(96, v_13); let [v_14, v_15, v_16, v_17, v_18, v_19]: [G; 6] = context.load::<6>(1, v_6)?; seed.u8(114, v_14); seed.full(48, v_15); seed.u32(100, v_16); seed.full(56, v_17); seed.u32(104, v_18); seed.u32(108, v_19); let op_2 = u32_less_than(v_0, v_3); let [v_20]: [G; 1] = [op_2.0]; match v_20.as_canonical_u64() { 1u64 => { let [v_21]: [G; 1] = context.returned::<1>(3)?; seed.full(64, v_21); Ok(()) }, _ => { let [v_22]: [G; 1] = [v_0 - v_3]; match v_22.as_canonical_u64() { 0u64 => { Ok(()) }, _ => { let [v_23]: [G; 1] = context.returned::<1>(5)?; seed.full(64, v_23); Ok(()) }, } }, } }, _ => { Err(no_match(763, v_1)) }, } } - -fn write_763(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]); match v_1.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_8, v_9, v_10, v_11, v_12, v_13]: [G; 6] = [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_8.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_9.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_10.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_13.as_canonical_u64(); let [v_14, v_15, v_16, v_17, v_18, v_19]: [G; 6] = [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 + 7] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 8] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 9] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 10] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 11] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_19.as_canonical_u64(); let op_2 = u32_less_than(v_0, v_3); let [v_20]: [G; 1] = [op_2.0]; row[offsets.auxiliaries + 13] = op_2.1[0].as_canonical_u64(); row[offsets.auxiliaries + 14] = op_2.1[1].as_canonical_u64(); row[offsets.auxiliaries + 15] = op_2.1[2].as_canonical_u64(); row[offsets.auxiliaries + 16] = op_2.1[3].as_canonical_u64(); row[offsets.auxiliaries + 17] = op_2.1[4].as_canonical_u64(); row[offsets.auxiliaries + 18] = op_2.1[5].as_canonical_u64(); match v_20.as_canonical_u64() { 1u64 => { let [v_21]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 19] = v_21.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 19] = (v_20 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_22]: [G; 1] = [v_0 - v_3]; match v_22.as_canonical_u64() { 0u64 => { row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 20] = (v_22 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_23]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 21] = v_23.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, } }, } }, _ => { Err(no_match(763, v_1)) }, } } - -static SCHEMA_763: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full], offsets: &[0, 72, 112, 8, 76, 16, 80, 84, 24, 113, 32, 88, 40, 92, 96, 114, 48, 100, 56, 104, 108, 64], bytes: 120 }; - -fn pack_765(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, 765, &[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(765, v_2)) }, } } - -fn pack_765_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, 765, &[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(765, v_2)) }, } } - -fn write_765(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(765, v_2)) }, } } - -static SCHEMA_765: 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_766(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, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36]: [G; 36] = context.load::<36>(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(); 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(); 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(); 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(); match v_1.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45]: [G; 8] = context.call::<8>(2, 766, &[v_36])?; seed[38] = v_38.as_canonical_u64(); seed[39] = v_39.as_canonical_u64(); seed[40] = v_40.as_canonical_u64(); seed[41] = v_41.as_canonical_u64(); seed[42] = v_42.as_canonical_u64(); seed[43] = v_43.as_canonical_u64(); seed[44] = v_44.as_canonical_u64(); seed[45] = v_45.as_canonical_u64(); let [v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53]: [G; 8] = context.returned::<8>(3)?; seed[46] = v_46.as_canonical_u64(); seed[47] = v_47.as_canonical_u64(); seed[48] = v_48.as_canonical_u64(); seed[49] = v_49.as_canonical_u64(); seed[50] = v_50.as_canonical_u64(); seed[51] = v_51.as_canonical_u64(); seed[52] = v_52.as_canonical_u64(); seed[53] = v_53.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(766, v_1)) }, } } - -fn pack_766_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, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36]: [G; 36] = context.load::<36>(0, v_0)?; seed.u8(224, v_1); seed.full(8, v_2); seed.full(16, v_3); seed.full(24, v_4); seed.u8(225, v_5); seed.u8(226, v_6); seed.u8(227, v_7); seed.u8(228, v_8); seed.u8(229, v_9); seed.u8(230, v_10); seed.full(32, v_11); seed.full(40, v_12); seed.u8(231, v_13); seed.u8(232, v_14); seed.u8(233, v_15); seed.u8(234, v_16); seed.u8(235, v_17); seed.u8(236, v_18); seed.full(48, v_19); seed.full(56, v_20); seed.u8(237, v_21); seed.u8(238, v_22); seed.u8(239, v_23); seed.u8(240, v_24); seed.u8(241, v_25); seed.u8(242, v_26); seed.full(64, v_27); seed.full(72, v_28); seed.u8(243, v_29); seed.u8(244, v_30); seed.u8(245, v_31); seed.u8(246, v_32); seed.u8(247, v_33); seed.u8(248, v_34); seed.full(80, v_35); seed.u32(220, v_36); match v_1.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45]: [G; 8] = context.call::<8>(2, 766, &[v_36])?; seed.full(88, v_38); seed.full(96, v_39); seed.full(104, v_40); seed.full(112, v_41); seed.full(120, v_42); seed.full(128, v_43); seed.full(136, v_44); seed.full(144, v_45); let [v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53]: [G; 8] = context.returned::<8>(3)?; seed.full(152, v_46); seed.full(160, v_47); seed.full(168, v_48); seed.full(176, v_49); seed.full(184, v_50); seed.full(192, v_51); seed.full(200, v_52); seed.full(208, v_53); Ok(()) }, _ => { Err(no_match(766, v_1)) }, } } - -fn write_766(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, v_11, v_12, v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20, v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28, v_29, v_30, v_31, v_32, v_33, v_34, v_35, v_36]: [G; 36] = [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]), 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])]; 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(); row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); row[offsets.auxiliaries + 12] = v_12.as_canonical_u64(); 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(); 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(); 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(); 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(); 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(); 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(); 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(); 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_1.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_38, v_39, v_40, v_41, v_42, v_43, v_44, v_45]: [G; 8] = [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])]; row[offsets.auxiliaries + 37] = v_38.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_39.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 43] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 44] = v_45.as_canonical_u64(); let [v_46, v_47, v_48, v_49, v_50, v_51, v_52, v_53]: [G; 8] = [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])]; row[offsets.auxiliaries + 45] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 46] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_51.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_52.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_53.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(766, v_1)) }, } } - -static SCHEMA_766: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, 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::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 216, 224, 8, 16, 24, 225, 226, 227, 228, 229, 230, 32, 40, 231, 232, 233, 234, 235, 236, 48, 56, 237, 238, 239, 240, 241, 242, 64, 72, 243, 244, 245, 246, 247, 248, 80, 220, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192, 200, 208], bytes: 256 }; - -fn pack_768(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, 777, &[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_768_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, 777, &[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 write_768(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(768, v_3)) }, } } - -static SCHEMA_768: 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_771(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, v_11]: [G; 11] = context.load::<11>(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(); seed[12] = v_11.as_canonical_u64(); match v_1.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20]: [G; 8] = context.call::<8>(2, 771, &[v_11])?; seed[13] = v_13.as_canonical_u64(); 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(); let [v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 8] = context.returned::<8>(3)?; seed[21] = v_21.as_canonical_u64(); seed[22] = v_22.as_canonical_u64(); seed[23] = v_23.as_canonical_u64(); seed[24] = v_24.as_canonical_u64(); seed[25] = v_25.as_canonical_u64(); seed[26] = v_26.as_canonical_u64(); seed[27] = v_27.as_canonical_u64(); seed[28] = v_28.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(771, v_1)) }, } } - -fn pack_771_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, v_11]: [G; 11] = context.load::<11>(0, v_0)?; seed.u8(168, v_1); seed.full(8, v_2); seed.full(16, v_3); seed.u8(169, v_4); seed.u8(170, v_5); seed.u8(171, v_6); seed.u8(172, v_7); seed.u8(173, v_8); seed.u8(174, v_9); seed.full(24, v_10); seed.u32(164, v_11); match v_1.as_canonical_u64() { 1u64 => { Ok(()) }, 0u64 => { let [v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20]: [G; 8] = context.call::<8>(2, 771, &[v_11])?; seed.full(32, v_13); seed.full(40, v_14); seed.full(48, v_15); seed.full(56, v_16); seed.full(64, v_17); seed.full(72, v_18); seed.full(80, v_19); seed.full(88, v_20); let [v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 8] = context.returned::<8>(3)?; 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.full(136, v_26); seed.full(144, v_27); seed.full(152, v_28); Ok(()) }, _ => { Err(no_match(771, v_1)) }, } } - -fn write_771(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, v_11]: [G; 11] = [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]), G::from_u64(seed[12])]; 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(); row[offsets.auxiliaries + 11] = v_11.as_canonical_u64(); match v_1.as_canonical_u64() { 1u64 => { row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_13, v_14, v_15, v_16, v_17, v_18, v_19, v_20]: [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 + 12] = v_13.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_14.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_20.as_canonical_u64(); let [v_21, v_22, v_23, v_24, v_25, v_26, v_27, v_28]: [G; 8] = [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 + 20] = v_21.as_canonical_u64(); row[offsets.auxiliaries + 21] = v_22.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_23.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_24.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_25.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_26.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_27.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_28.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { Err(no_match(771, v_1)) }, } } - -static SCHEMA_771: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, SeedWidth::U8, 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::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full], offsets: &[0, 160, 168, 8, 16, 169, 170, 171, 172, 173, 174, 24, 164, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144, 152], bytes: 176 }; - -fn pack_777(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, 777, &[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_777_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, 777, &[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 write_777(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(777, v_5)) }, } }, } } - -static SCHEMA_777: 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_782(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]; match v_2.as_canonical_u64() { 1u64 => { let [v_9]: [G; 1] = [G::from_u64(1)]; let [v_10]: [G; 1] = context.store(2, &[v_9, v_9, v_9, v_9, v_9, v_9])?; seed[9] = v_10.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_11, v_12, v_13, v_14, v_15, v_16]: [G; 6] = context.load::<6>(3, v_6)?; 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(); let [v_17, v_18, v_19, v_20, v_21, v_22]: [G; 6] = context.load::<6>(4, v_7)?; 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(); let op_5 = u32_less_than(v_0, v_4); let [v_23]: [G; 1] = [op_5.0]; match v_23.as_canonical_u64() { 1u64 => { let [v_24, v_25, v_26, v_27, v_28, v_29]: [G; 6] = context.call::<6>(6, 782, &[v_0, v_1, v_11, v_12, v_13, v_14, v_15, v_16])?; seed[21] = v_24.as_canonical_u64(); seed[22] = v_25.as_canonical_u64(); seed[23] = v_26.as_canonical_u64(); seed[24] = v_27.as_canonical_u64(); seed[25] = v_28.as_canonical_u64(); seed[26] = v_29.as_canonical_u64(); let [v_30, v_31, v_32, v_33, v_34, v_35]: [G; 6] = context.returned::<6>(7)?; seed[27] = v_30.as_canonical_u64(); seed[28] = v_31.as_canonical_u64(); seed[29] = v_32.as_canonical_u64(); seed[30] = v_33.as_canonical_u64(); seed[31] = v_34.as_canonical_u64(); seed[32] = v_35.as_canonical_u64(); Ok(()) }, _ => { let [v_36]: [G; 1] = [v_0 - v_4]; match v_36.as_canonical_u64() { 0u64 => { let [v_38]: [G; 1] = context.store(10, &[v_11, v_12, v_13, v_14, v_15, v_16])?; seed[21] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = context.store(11, &[v_17, v_18, v_19, v_20, v_21, v_22])?; seed[22] = v_39.as_canonical_u64(); Ok(()) }, _ => { let [v_40, v_41, v_42, v_43, v_44, v_45]: [G; 6] = context.call::<6>(12, 782, &[v_0, v_1, v_17, v_18, v_19, v_20, v_21, v_22])?; seed[21] = v_40.as_canonical_u64(); seed[22] = v_41.as_canonical_u64(); seed[23] = v_42.as_canonical_u64(); seed[24] = v_43.as_canonical_u64(); seed[25] = v_44.as_canonical_u64(); seed[26] = v_45.as_canonical_u64(); let [v_46, v_47, v_48, v_49, v_50, v_51]: [G; 6] = context.returned::<6>(13)?; seed[27] = v_46.as_canonical_u64(); seed[28] = v_47.as_canonical_u64(); seed[29] = v_48.as_canonical_u64(); seed[30] = v_49.as_canonical_u64(); seed[31] = v_50.as_canonical_u64(); seed[32] = v_51.as_canonical_u64(); Ok(()) }, } }, } }, _ => { Err(no_match(782, v_2)) }, } } - -fn pack_782_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]; match v_2.as_canonical_u64() { 1u64 => { let [v_9]: [G; 1] = [G::from_u64(1)]; let [v_10]: [G; 1] = context.store(2, &[v_9, v_9, v_9, v_9, v_9, v_9])?; seed.u32(128, v_10); Ok(()) }, 0u64 => { let [v_11, v_12, v_13, v_14, v_15, v_16]: [G; 6] = context.load::<6>(3, v_6)?; seed.u32(128, v_11); seed.full(32, v_12); seed.u32(132, v_13); seed.full(40, v_14); seed.u32(136, v_15); seed.u32(140, v_16); let [v_17, v_18, v_19, v_20, v_21, v_22]: [G; 6] = context.load::<6>(4, v_7)?; seed.u8(177, v_17); seed.full(48, v_18); seed.u32(144, v_19); seed.full(56, v_20); seed.u32(148, v_21); seed.u32(152, v_22); let op_5 = u32_less_than(v_0, v_4); let [v_23]: [G; 1] = [op_5.0]; match v_23.as_canonical_u64() { 1u64 => { let [v_24, v_25, v_26, v_27, v_28, v_29]: [G; 6] = context.call::<6>(6, 782, &[v_0, v_1, v_11, v_12, v_13, v_14, v_15, v_16])?; seed.u32(156, v_24); seed.full(64, v_25); seed.full(72, v_26); seed.full(80, v_27); seed.u32(160, v_28); seed.u32(164, v_29); let [v_30, v_31, v_32, v_33, v_34, v_35]: [G; 6] = context.returned::<6>(7)?; seed.u8(178, v_30); seed.full(88, v_31); seed.full(96, v_32); seed.full(104, v_33); seed.u32(168, v_34); seed.u32(172, v_35); Ok(()) }, _ => { let [v_36]: [G; 1] = [v_0 - v_4]; match v_36.as_canonical_u64() { 0u64 => { let [v_38]: [G; 1] = context.store(10, &[v_11, v_12, v_13, v_14, v_15, v_16])?; seed.u32(156, v_38); let [v_39]: [G; 1] = context.store(11, &[v_17, v_18, v_19, v_20, v_21, v_22])?; seed.full(64, v_39); Ok(()) }, _ => { let [v_40, v_41, v_42, v_43, v_44, v_45]: [G; 6] = context.call::<6>(12, 782, &[v_0, v_1, v_17, v_18, v_19, v_20, v_21, v_22])?; seed.u32(156, v_40); seed.full(64, v_41); seed.full(72, v_42); seed.full(80, v_43); seed.u32(160, v_44); seed.u32(164, v_45); let [v_46, v_47, v_48, v_49, v_50, v_51]: [G; 6] = context.returned::<6>(13)?; seed.u8(178, v_46); seed.full(88, v_47); seed.full(96, v_48); seed.full(104, v_49); seed.u32(168, v_50); seed.u32(172, v_51); Ok(()) }, } }, } }, _ => { Err(no_match(782, v_2)) }, } } - -fn write_782(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]); match v_2.as_canonical_u64() { 1u64 => { let [v_10]: [G; 1] = [G::from_u64(seed[9])]; row[offsets.auxiliaries + 1] = v_10.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); Ok(()) }, 0u64 => { let [v_11, v_12, v_13, v_14, v_15, v_16]: [G; 6] = [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_11.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_12.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_13.as_canonical_u64(); 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(); let [v_17, v_18, v_19, v_20, v_21, v_22]: [G; 6] = [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 + 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(); row[offsets.auxiliaries + 12] = v_22.as_canonical_u64(); let op_5 = u32_less_than(v_0, v_4); let [v_23]: [G; 1] = [op_5.0]; row[offsets.auxiliaries + 13] = op_5.1[0].as_canonical_u64(); row[offsets.auxiliaries + 14] = op_5.1[1].as_canonical_u64(); row[offsets.auxiliaries + 15] = op_5.1[2].as_canonical_u64(); row[offsets.auxiliaries + 16] = op_5.1[3].as_canonical_u64(); row[offsets.auxiliaries + 17] = op_5.1[4].as_canonical_u64(); row[offsets.auxiliaries + 18] = op_5.1[5].as_canonical_u64(); match v_23.as_canonical_u64() { 1u64 => { let [v_24, v_25, v_26, v_27, v_28, v_29]: [G; 6] = [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])]; row[offsets.auxiliaries + 19] = v_24.as_canonical_u64(); 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(); let [v_30, v_31, v_32, v_33, v_34, v_35]: [G; 6] = [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 + 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.selectors + 1] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 19] = (v_23 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_36]: [G; 1] = [v_0 - v_4]; match v_36.as_canonical_u64() { 0u64 => { let [v_38]: [G; 1] = [G::from_u64(seed[21])]; row[offsets.auxiliaries + 20] = v_38.as_canonical_u64(); let [v_39]: [G; 1] = [G::from_u64(seed[22])]; row[offsets.auxiliaries + 21] = v_39.as_canonical_u64(); row[offsets.selectors + 2] = G::ONE.as_canonical_u64(); Ok(()) }, _ => { row[offsets.auxiliaries + 20] = (v_36 - G::from_u64(0)).inverse().as_canonical_u64(); let [v_40, v_41, v_42, v_43, v_44, v_45]: [G; 6] = [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])]; row[offsets.auxiliaries + 21] = v_40.as_canonical_u64(); row[offsets.auxiliaries + 22] = v_41.as_canonical_u64(); row[offsets.auxiliaries + 23] = v_42.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_43.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_44.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_45.as_canonical_u64(); let [v_46, v_47, v_48, v_49, v_50, v_51]: [G; 6] = [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 + 27] = v_46.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_47.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_48.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_49.as_canonical_u64(); row[offsets.auxiliaries + 31] = v_50.as_canonical_u64(); row[offsets.auxiliaries + 32] = v_51.as_canonical_u64(); row[offsets.selectors + 3] = G::ONE.as_canonical_u64(); Ok(()) }, } }, } }, _ => { Err(no_match(782, v_2)) }, } } - -static SCHEMA_782: SeedSchema = SeedSchema { widths: &[SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::U32, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32, SeedWidth::U8, SeedWidth::Full, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 112, 8, 176, 16, 116, 24, 120, 124, 128, 32, 132, 40, 136, 140, 177, 48, 144, 56, 148, 152, 156, 64, 72, 80, 160, 164, 178, 88, 96, 104, 168, 172], bytes: 184 }; - -fn pack_783(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]; match v_0.as_canonical_u64() { 1u64 => { let [v_15, v_16, v_17, v_18, v_19, v_20]: [G; 6] = context.returned::<6>(0)?; seed[16] = v_15.as_canonical_u64(); seed[17] = v_16.as_canonical_u64(); 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(); Ok(()) }, _ => { let [v_22]: [G; 1] = context.store(2, &[v_3, v_4, v_5, v_6, v_7, v_8])?; seed[16] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = context.store(3, &[v_9, v_10, v_11, v_12, v_13, v_14])?; seed[17] = v_23.as_canonical_u64(); Ok(()) }, } } - -fn pack_783_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]; match v_0.as_canonical_u64() { 1u64 => { let [v_15, v_16, v_17, v_18, v_19, v_20]: [G; 6] = context.returned::<6>(0)?; seed.u32(128, v_15); seed.u32(132, v_16); seed.full(96, v_17); seed.full(104, v_18); seed.u32(136, v_19); seed.u32(140, v_20); Ok(()) }, _ => { let [v_22]: [G; 1] = context.store(2, &[v_3, v_4, v_5, v_6, v_7, v_8])?; seed.u32(128, v_22); let [v_23]: [G; 1] = context.store(3, &[v_9, v_10, v_11, v_12, v_13, v_14])?; seed.u32(132, v_23); Ok(()) }, } } - -fn write_783(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]); match v_0.as_canonical_u64() { 1u64 => { let [v_15, v_16, v_17, v_18, v_19, v_20]: [G; 6] = [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])]; row[offsets.auxiliaries + 1] = v_15.as_canonical_u64(); row[offsets.auxiliaries + 2] = v_16.as_canonical_u64(); row[offsets.auxiliaries + 3] = v_17.as_canonical_u64(); row[offsets.auxiliaries + 4] = v_18.as_canonical_u64(); row[offsets.auxiliaries + 5] = v_19.as_canonical_u64(); row[offsets.auxiliaries + 6] = v_20.as_canonical_u64(); row[offsets.selectors] = G::ONE.as_canonical_u64(); }, _ => { row[offsets.auxiliaries + 1] = (v_0 - G::from_u64(1)).inverse().as_canonical_u64(); let [v_22]: [G; 1] = [G::from_u64(seed[16])]; row[offsets.auxiliaries + 2] = v_22.as_canonical_u64(); let [v_23]: [G; 1] = [G::from_u64(seed[17])]; row[offsets.auxiliaries + 3] = v_23.as_canonical_u64(); row[offsets.selectors + 1] = G::ONE.as_canonical_u64(); }, } } - -static SCHEMA_783: SeedSchema = SeedSchema { widths: &[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::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::U32, SeedWidth::Full, SeedWidth::Full, SeedWidth::U32, SeedWidth::U32], offsets: &[0, 8, 16, 24, 32, 40, 48, 56, 112, 116, 64, 72, 80, 88, 120, 124, 128, 132, 96, 104, 136, 140], bytes: 144 }; - -#[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![], 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]) }), (G::from_u64(1), Block { ops: vec![Op::IORead(0, 1, 1), Op::U8RangeCheck(3, 3), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![4, 3, 6])], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::IORead(0, 1, 2), Op::U8RangeCheck(3, 4), Op::Const(G::from_u64(2)), Op::Add(1, 5), Op::Sub(2, 5), Op::Call(5, vec![0, 6, 7], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![9, 4, 8]), Op::Store(vec![9, 3, 10])], ctrl: Ctrl::Return(2, vec![11]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_6() -> 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_7() -> 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_8() -> 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::Mul(16, 18), Op::Const(G::from_u64(2)), Op::Sub(16, 20), Op::Mul(19, 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_9() -> 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_10() -> 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_11() -> 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_12() -> 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_13() -> 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_14() -> 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_15() -> 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_16() -> 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_17() -> 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_18() -> 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::Add(0, 10), Op::Const(G::from_u64(65536)), Op::Mul(12, 2), Op::Add(11, 13), Op::Const(G::from_u64(16777216)), Op::Mul(15, 3), Op::Add(14, 16), Op::Const(G::from_u64(4294967296)), Op::Mul(18, 4), Op::Add(17, 19), Op::Const(G::from_u64(1099511627776)), Op::Mul(21, 5), Op::Add(20, 22), Op::Const(G::from_u64(281474976710656)), Op::Mul(24, 6), Op::Add(23, 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_19() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(4, 1), Op::Add(0, 5), Op::Const(G::from_u64(65536)), Op::Mul(7, 2), Op::Add(6, 8), Op::Const(G::from_u64(16777216)), Op::Mul(10, 3), Op::Add(9, 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_20() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Mul(32, 1), Op::Add(0, 33), Op::Const(G::from_u64(65536)), Op::Mul(35, 2), Op::Add(34, 36), Op::Const(G::from_u64(16777216)), Op::Mul(38, 3), Op::Add(37, 39), Op::Mul(32, 5), Op::Add(4, 41), Op::Mul(35, 6), Op::Add(42, 43), Op::Mul(38, 7), Op::Add(44, 45), Op::Mul(32, 9), Op::Add(8, 47), Op::Mul(35, 10), Op::Add(48, 49), Op::Mul(38, 11), Op::Add(50, 51), Op::Mul(32, 13), Op::Add(12, 53), Op::Mul(35, 14), Op::Add(54, 55), Op::Mul(38, 15), Op::Add(56, 57), Op::Mul(32, 17), Op::Add(16, 59), Op::Mul(35, 18), Op::Add(60, 61), Op::Mul(38, 19), Op::Add(62, 63), Op::Mul(32, 21), Op::Add(20, 65), Op::Mul(35, 22), Op::Add(66, 67), Op::Mul(38, 23), Op::Add(68, 69), Op::Mul(32, 25), Op::Add(24, 71), Op::Mul(35, 26), Op::Add(72, 73), Op::Mul(38, 27), Op::Add(74, 75), Op::Mul(32, 29), Op::Add(28, 77), Op::Mul(35, 30), Op::Add(78, 79), Op::Mul(38, 31), Op::Add(80, 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_21() -> 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(26, vec![0, 33, 34, 34, 35, 36, 37], 1, false), Op::Call(25, 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_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![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(26, vec![0, 65, 66, 66, 67, 68, 69], 1, false), Op::Call(25, 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_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![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(26, vec![0, 33, 34, 34, 35, 36, 37], 1, false), Op::Call(25, 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_24() -> 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(24, 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(37, 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(37, 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_25() -> 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(24, 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(25, 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(25, 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_26() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(32, 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(33, 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::Load(3, 9)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Call(32, vec![11, 13, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(2, vec![18]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![18, 16, 11])], ctrl: Ctrl::Match(13, [(G::from_u64(63), Block { ops: vec![Op::Call(33, vec![17, 19, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(3, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(13, 20), Op::Add(14, 20), Op::Load(3, 17)], ctrl: Ctrl::Match(23, [(G::from_u64(1), Block { ops: vec![Op::Call(32, vec![19, 21, 22, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(4, vec![26]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![26, 24, 19])], ctrl: Ctrl::Match(21, [(G::from_u64(63), Block { ops: vec![Op::Call(33, vec![25, 27, 22, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(5, vec![28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(21, 28), Op::Add(22, 28), Op::Load(3, 25)], ctrl: Ctrl::Match(31, [(G::from_u64(1), Block { ops: vec![Op::Call(32, vec![27, 29, 30, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(6, vec![34]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![34, 32, 27])], ctrl: Ctrl::Match(29, [(G::from_u64(63), Block { ops: vec![Op::Call(33, vec![33, 35, 30, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(7, vec![36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(29, 36), Op::Add(30, 36), Op::Call(26, vec![33, 35, 37, 38, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(8, vec![39]) }))) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 9, auxiliaries: 22, lookups: 10 }, 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(32, 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(33, 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::Load(3, 9)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Call(32, vec![11, 13, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(2, vec![18]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![18, 16, 11])], ctrl: Ctrl::Match(13, [(G::from_u64(63), Block { ops: vec![Op::Call(33, vec![17, 19, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(3, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(13, 20), Op::Add(14, 20), Op::Load(3, 17)], ctrl: Ctrl::Match(23, [(G::from_u64(1), Block { ops: vec![Op::Call(32, vec![19, 21, 22, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(4, vec![26]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![26, 24, 19])], ctrl: Ctrl::Match(21, [(G::from_u64(63), Block { ops: vec![Op::Call(33, vec![25, 27, 22, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(5, vec![28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(21, 28), Op::Add(22, 28), Op::Call(26, vec![25, 27, 29, 30, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(6, vec![31]) }))) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 7, auxiliaries: 17, lookups: 8 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_28() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(32, 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(33, 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::Load(3, 9)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Call(32, vec![11, 13, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(2, vec![18]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![18, 16, 11])], ctrl: Ctrl::Match(13, [(G::from_u64(63), Block { ops: vec![Op::Call(33, vec![17, 19, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(3, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(13, 20), Op::Add(14, 20), Op::Call(26, vec![17, 19, 21, 22, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(4, vec![23]) }))) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 5, auxiliaries: 12, lookups: 6 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_29() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(32, 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(33, 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(26, 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: false } -} - -#[inline(never)] -fn expected_function_30() -> 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_31() -> 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(31, 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_32() -> 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(8, 6), Op::Add(17, 7), 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(37, 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(6, vec![9, 10, 11, 12, 13, 14, 15, 16], 1, false), Op::Mul(17, 8), Op::Add(7, 18), Op::Sub(2, 1), Op::EqZero(20), Op::Mul(21, 6), Op::Add(19, 22), Op::Const(G::from_u64(64)), Op::Sub(24, 1), Op::Call(31, vec![0, 25], 1, false), Op::Call(30, 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(37, 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_33() -> 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(30, vec![1], 64, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1023), Block { ops: vec![Op::Call(773, vec![0], 1, false), Op::Mul(8, 73), Op::Load(8, 3), Op::Call(6, vec![75, 76, 77, 78, 79, 80, 81, 82], 1, false), Op::Mul(74, 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(37, 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, 75, 76, 77, 78, 79, 80, 81, 82, 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(16, vec![75, 76, 77, 78, 79, 80, 81, 82], 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(26, 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(773, vec![0], 1, false), Op::Mul(73, 7), Op::Call(773, vec![0], 1, false), Op::Load(8, 3), Op::Call(6, vec![76, 77, 78, 79, 80, 81, 82, 83], 1, false), Op::Mul(75, 84), Op::Mul(85, 8), Op::Const(G::from_u64(63)), Op::Sub(2, 87), Op::EqZero(88), Op::Mul(89, 6), Op::Add(74, 86), Op::Add(91, 90), 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(37, 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(26, 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_34() -> 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::Mul(28, 30), Op::Const(G::from_u64(2)), Op::Sub(28, 32), Op::Mul(31, 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::Mul(62, 63), Op::Sub(62, 32), Op::Mul(64, 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_35() -> 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::Mul(132, 134), Op::Const(G::from_u64(2)), Op::Sub(132, 136), Op::Mul(135, 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::Mul(166, 167), Op::Sub(166, 136), Op::Mul(168, 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::Mul(197, 198), Op::Sub(197, 136), Op::Mul(199, 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::Mul(228, 229), Op::Sub(228, 136), Op::Mul(230, 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::Mul(259, 260), Op::Sub(259, 136), Op::Mul(261, 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::Mul(290, 291), Op::Sub(290, 136), Op::Mul(292, 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::Mul(321, 322), Op::Sub(321, 136), Op::Mul(323, 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::Mul(352, 353), Op::Sub(352, 136), Op::Mul(354, 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::Mul(383, 384), Op::Sub(383, 136), Op::Mul(385, 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::Mul(414, 415), Op::Sub(414, 136), Op::Mul(416, 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::Mul(445, 446), Op::Sub(445, 136), Op::Mul(447, 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::Mul(476, 477), Op::Sub(476, 136), Op::Mul(478, 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::Mul(507, 508), Op::Sub(507, 136), Op::Mul(509, 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::Mul(538, 539), Op::Sub(538, 136), Op::Mul(540, 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::Mul(569, 570), Op::Sub(569, 136), Op::Mul(571, 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::Mul(600, 601), Op::Sub(600, 136), Op::Mul(602, 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_36() -> 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(37, 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_37() -> 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::Mul(133, 135), Op::Const(G::from_u64(2)), Op::Sub(133, 137), Op::Mul(136, 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::Mul(167, 168), Op::Sub(167, 137), Op::Mul(169, 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::Mul(198, 199), Op::Sub(198, 137), Op::Mul(200, 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::Mul(229, 230), Op::Sub(229, 137), Op::Mul(231, 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::Mul(260, 261), Op::Sub(260, 137), Op::Mul(262, 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::Mul(291, 292), Op::Sub(291, 137), Op::Mul(293, 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::Mul(322, 323), Op::Sub(322, 137), Op::Mul(324, 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::Mul(353, 354), Op::Sub(353, 137), Op::Mul(355, 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::Mul(384, 385), Op::Sub(384, 137), Op::Mul(386, 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::Mul(415, 416), Op::Sub(415, 137), Op::Mul(417, 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::Mul(446, 447), Op::Sub(446, 137), Op::Mul(448, 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::Mul(477, 478), Op::Sub(477, 137), Op::Mul(479, 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::Mul(508, 509), Op::Sub(508, 137), Op::Mul(510, 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::Mul(539, 540), Op::Sub(539, 137), Op::Mul(541, 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::Mul(570, 571), Op::Sub(570, 137), Op::Mul(572, 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::Mul(601, 602), Op::Sub(601, 137), Op::Mul(603, 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(37, 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_38() -> 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(761, vec![9], 8, false), Op::Const(G::from_u64(2)), Op::Call(45, vec![9, 18], 1, false), Op::Call(42, 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(761, vec![9], 8, false), Op::Const(G::from_u64(3)), Op::Call(45, vec![9, 18], 1, false), Op::Call(42, 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(38, vec![19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 18], 1, false), Op::Call(42, 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(50, 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(53, 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(51, 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(54, 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(52, 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(55, 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(38, vec![55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 18], 1, false), Op::Call(38, vec![37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 79], 1, false), Op::Call(38, vec![19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 80], 1, false), Op::Call(48, 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_39() -> 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(39, 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_40() -> Function { - Function { body: 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)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(8)), Op::U8LessThan(1, 16)], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(16)), Op::Mul(19, 0), Op::Add(20, 1), Op::Store(vec![18, 21, 9])], ctrl: Ctrl::Return(0, vec![22]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(16)), Op::Mul(18, 0), Op::Const(G::from_u64(4)), Op::Call(43, vec![19, 20, 1, 2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Return(1, vec![21]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(16)), Op::Mul(16, 0), Op::Const(G::from_u64(4)), Op::Call(43, vec![17, 18, 1, 2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Return(2, vec![19]) }))) }, layout: FunctionLayout { input_size: 10, selectors: 3, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_41() -> Function { - Function { body: 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)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(32)), Op::U8LessThan(1, 16)], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Mul(19, 0), Op::Add(20, 1), Op::Store(vec![18, 21, 9])], ctrl: Ctrl::Return(0, vec![22]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(64)), Op::Mul(18, 0), Op::Const(G::from_u64(16)), Op::Call(43, vec![19, 20, 1, 2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Return(1, vec![21]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(64)), Op::Mul(16, 0), Op::Const(G::from_u64(16)), Op::Call(43, vec![17, 18, 1, 2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Return(2, vec![19]) }))) }, layout: FunctionLayout { input_size: 10, selectors: 3, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_42() -> Function { - Function { body: Block { ops: vec![Op::Add(1, 2), Op::Add(9, 3), Op::Add(10, 4), Op::Add(11, 5), Op::Add(12, 6), Op::Add(13, 7)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(128)), Op::U8LessThan(0, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![17, 0, 8])], ctrl: Ctrl::Return(0, vec![18]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Call(43, vec![17, 18, 0, 1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Return(1, vec![19]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Call(43, vec![15, 16, 0, 1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Return(2, vec![17]) }))) }, layout: FunctionLayout { input_size: 9, selectors: 3, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_43() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(256)), Op::Const(G::from_u64(2)), Op::Mul(12, 1), Op::Sub(11, 13), Op::Const(G::from_u64(255)), Op::Sub(15, 1), Op::Call(15, vec![2, 3, 4, 5, 6, 7, 8, 9, 14, 16, 15, 15, 15, 15, 15, 15], 9, false)], ctrl: Ctrl::Match(25, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(256)), Op::Const(G::from_u64(2)), Op::Mul(27, 1), Op::Sub(26, 28), Op::U8Add(2, 29), Op::Add(3, 31), Op::Const(G::from_u64(1)), Op::Sub(32, 33), Op::Const(G::from_u64(0)), Op::Add(0, 28), Op::Add(36, 34), Op::Store(vec![35, 30, 10]), Op::Store(vec![35, 37, 38])], ctrl: Ctrl::Return(0, vec![39]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Mul(26, 1), Op::Add(0, 27), Op::Const(G::from_u64(0)), Op::Call(44, vec![28, 29, 17, 18, 19, 20, 21, 22, 23, 24, 10], 1, false)], ctrl: Ctrl::Return(1, vec![30]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 11, selectors: 2, auxiliaries: 13, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_44() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Add(4, 5), Op::Add(11, 6), Op::Add(12, 7), Op::Add(13, 8), Op::Add(14, 9)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Call(39, vec![2, 3, 4, 5, 6, 7, 8, 9, 17, 10], 1, false), Op::Store(vec![16, 0, 18])], ctrl: Ctrl::Return(0, vec![19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(255)), Op::Call(15, vec![2, 3, 4, 5, 6, 7, 8, 9, 16, 16, 17, 17, 17, 17, 17, 17], 9, false), Op::Const(G::from_u64(1)), Op::Call(44, vec![0, 27, 18, 19, 20, 21, 22, 23, 24, 25, 10], 1, false)], ctrl: Ctrl::Return(1, vec![28]) }))) }), (G::from_u64(1), Block { ops: vec![Op::Add(5, 6), Op::Add(11, 7), Op::Add(12, 8), Op::Add(13, 9)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(0, 16), Op::Const(G::from_u64(3)), Op::Call(39, vec![2, 3, 4, 5, 6, 7, 8, 9, 18, 10], 1, false), Op::Store(vec![15, 17, 19])], ctrl: Ctrl::Return(2, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(255)), Op::Call(15, vec![2, 3, 4, 5, 6, 7, 8, 9, 15, 15, 15, 16, 16, 16, 16, 16], 9, false), Op::Const(G::from_u64(2)), Op::Call(44, vec![0, 26, 17, 18, 19, 20, 21, 22, 23, 24, 10], 1, false)], ctrl: Ctrl::Return(3, vec![27]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Add(6, 7), Op::Add(11, 8), Op::Add(12, 9)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Add(0, 15), Op::Const(G::from_u64(4)), Op::Call(39, vec![2, 3, 4, 5, 6, 7, 8, 9, 17, 10], 1, false), Op::Store(vec![14, 16, 18])], ctrl: Ctrl::Return(4, vec![19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(255)), Op::Call(15, vec![2, 3, 4, 5, 6, 7, 8, 9, 14, 14, 14, 14, 15, 15, 15, 15], 9, false), Op::Const(G::from_u64(3)), Op::Call(44, vec![0, 25, 16, 17, 18, 19, 20, 21, 22, 23, 10], 1, false)], ctrl: Ctrl::Return(5, vec![26]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(3)), Op::Add(0, 12), Op::Const(G::from_u64(8)), Op::Call(39, vec![2, 3, 4, 5, 6, 7, 8, 9, 14, 10], 1, false), Op::Store(vec![11, 13, 15])], ctrl: Ctrl::Return(6, vec![16]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 11, selectors: 7, auxiliaries: 12, lookups: 3 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_45() -> 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(45, vec![11, 1], 1, false), Op::Call(42, 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_46() -> 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_47() -> 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(46, 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_48() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(47, 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_49() -> Function { - Function { body: Block { ops: vec![Op::Call(47, vec![0, 1, 2], 1, false), Op::Const(G::from_u64(16)), Op::Call(46, 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_50() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::Load(18, 1), Op::Call(50, vec![18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35], 8, false), Op::Call(16, 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_51() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(8), Block { ops: vec![Op::Load(18, 5), Op::Call(51, vec![18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35], 8, false), Op::Call(16, 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_52() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(9), Block { ops: vec![Op::Load(18, 7), Op::Call(52, vec![18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35], 8, false), Op::Call(16, 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_53() -> 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(38, vec![37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 18], 1, false), Op::Call(53, 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(38, 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_54() -> 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(54, vec![37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 18], 1, false), Op::Call(38, vec![19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 55], 1, false), Op::Call(48, vec![1, 2, 3, 56], 1, false)], ctrl: Ctrl::Return(0, vec![57]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(38, 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_55() -> 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(55, vec![37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 18], 1, false), Op::Call(38, vec![19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 55], 1, false), Op::Call(49, 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(38, 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_56() -> 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_57() -> 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_58() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![Op::Load(9, 1), Op::Call(58, vec![9, 10, 11, 12, 13, 14, 15, 16, 17], 8, false), Op::Call(16, 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_59() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![Op::Load(9, 1), Op::Call(59, 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_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![10, 10, 9])], ctrl: Ctrl::Return(0, vec![11]) }), (G::from_u64(1), Block { ops: vec![Op::Call(58, vec![0, 1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(59, vec![0, 1, 2, 3, 4, 5, 6, 7, 8], 9, false), Op::Const(G::from_u64(0)), Op::Call(60, vec![18, 19, 20, 21, 22, 23, 24, 25, 26, 9], 1, false), Op::Call(41, 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(60, vec![19, 20, 21, 22, 23, 24, 25, 26, 27, 9], 1, false), Op::Call(60, vec![10, 11, 12, 13, 14, 15, 16, 17, 18, 30], 1, false), Op::Call(41, 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(60, vec![19, 20, 21, 22, 23, 24, 25, 26, 27, 9], 1, false), Op::Call(60, vec![10, 11, 12, 13, 14, 15, 16, 17, 18, 30], 1, false), Op::Call(41, 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(41, 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_61() -> 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(61, vec![4, 1], 1, false), Op::Call(38, 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_62() -> 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(62, vec![4, 1], 1, false), Op::Call(60, 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_63() -> 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(63, vec![4, 1], 1, false), Op::Call(56, 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_64() -> 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_65() -> 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(57, vec![0, 1], 1, false), Op::Const(G::from_u64(0)), Op::Call(38, vec![31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 12], 1, false), Op::Call(38, vec![13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 51], 1, false), Op::Call(42, 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_66() -> 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(38, vec![10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 9], 1, false), Op::Call(42, 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_67() -> 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(67, vec![12, 1], 1, false), Op::Call(66, 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_68() -> 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(771, vec![43], 8, false), Op::Const(G::from_u64(0)), Op::Call(67, vec![43, 44], 1, false), Op::Call(42, vec![66, 67, 68, 69, 70, 71, 72, 73, 75], 1, false), Op::Call(38, vec![45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 76], 1, false), Op::Call(42, vec![34, 35, 36, 37, 38, 39, 40, 41, 77], 1, false), Op::Call(42, vec![26, 27, 28, 29, 30, 31, 32, 33, 78], 1, false), Op::Call(42, vec![18, 19, 20, 21, 22, 23, 24, 25, 79], 1, false), Op::Call(42, vec![10, 11, 12, 13, 14, 15, 16, 17, 80], 1, false), Op::Call(42, 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_69() -> 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(38, vec![11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 10], 1, false), Op::Call(42, 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_70() -> 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(38, vec![11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 10], 1, false), Op::Call(42, vec![1, 2, 3, 4, 5, 6, 7, 8, 29], 1, false), Op::Call(64, 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_71() -> 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(38, vec![35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 34], 1, false), Op::Call(42, vec![25, 26, 27, 28, 29, 30, 31, 32, 54], 1, false), Op::Call(42, vec![17, 18, 19, 20, 21, 22, 23, 24, 55], 1, false), Op::Call(42, vec![9, 10, 11, 12, 13, 14, 15, 16, 56], 1, false), Op::Call(42, 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_72() -> 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(72, vec![37, 1], 1, false), Op::Call(71, 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_73() -> 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(766, vec![26], 8, false), Op::Const(G::from_u64(0)), Op::Call(72, vec![26, 27], 1, false), Op::Call(42, vec![46, 47, 48, 49, 50, 51, 52, 53, 55], 1, false), Op::Call(38, vec![28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 56], 1, false), Op::Call(42, vec![17, 18, 19, 20, 21, 22, 23, 24, 57], 1, false), Op::Call(42, vec![9, 10, 11, 12, 13, 14, 15, 16, 58], 1, false), Op::Call(42, 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_74() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(56, vec![8, 9], 1, false), Op::Call(42, 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_75() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(56, vec![16, 17], 1, false), Op::Call(42, vec![8, 9, 10, 11, 12, 13, 14, 15, 18], 1, false), Op::Call(42, 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_76() -> 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(65, 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(73, 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(68, 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_77() -> 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(77, vec![48, 1], 1, false), Op::Call(76, 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_78() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Call(65, 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(68, 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(69, 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(70, 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(75, 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(74, 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(74, 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(74, 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_79() -> Function { - Function { body: Block { ops: vec![Op::Call(762, vec![0], 8, false), Op::Call(61, vec![0, 1], 1, false), Op::Call(42, 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_80() -> Function { - Function { body: Block { ops: vec![Op::Call(762, vec![0], 8, false), Op::Call(63, vec![0, 1], 1, false), Op::Call(42, 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_81() -> Function { - Function { body: Block { ops: vec![Op::Call(762, vec![0], 8, false), Op::Call(62, vec![0, 1], 1, false), Op::Call(42, 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_82() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(81, vec![47, 48], 1, false), Op::Call(80, vec![46, 49], 1, false), Op::Call(79, vec![45, 50], 1, false)], ctrl: Ctrl::Match(0, [(G::from_u64(8), Block { ops: vec![Op::Call(770, vec![1], 8, false), Op::Const(G::from_u64(12)), Op::Call(77, 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(78, 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(78, 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(78, 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(78, 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(78, 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(78, 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(78, 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(78, 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_83() -> 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_84() -> 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(84, 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_85() -> 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::Add(8, 13), Op::Const(G::from_u64(4)), Op::Mul(15, 10), Op::Add(14, 16), Op::Const(G::from_u64(8)), Op::Mul(18, 11), Op::Add(17, 19), Op::Mul(12, 5), Op::Add(4, 21), Op::Mul(15, 6), Op::Add(22, 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]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(88, vec![24, 25, 3], 9, false)], ctrl: Ctrl::Return(1, vec![20, 26, 27, 28, 29, 30, 31, 32, 33, 34]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 21, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_86() -> 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::Add(4, 15), Op::Const(G::from_u64(4)), Op::Mul(17, 6), Op::Add(16, 18), Op::Const(G::from_u64(8)), Op::Mul(20, 7), Op::Add(19, 21), Op::Const(G::from_u64(16)), Op::Mul(23, 8), Op::Add(22, 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]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(16)), Op::Call(88, vec![25, 26, 3], 9, false)], ctrl: Ctrl::Return(1, vec![14, 27, 28, 29, 30, 31, 32, 33, 34, 35]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 21, lookups: 4 }, 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![Op::Const(G::from_u64(128)), Op::U8LessThan(2, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![2, 6, 6, 6, 6, 6, 6, 6, 3]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(128)), Op::Sub(2, 6), Op::Const(G::from_u64(64)), Op::Call(88, vec![7, 8, 3], 9, false)], ctrl: Ctrl::Return(1, vec![9, 10, 11, 12, 13, 14, 15, 16, 17]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 14, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_88() -> Function { - Function { body: Block { ops: vec![Op::U8LessThan(0, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 2)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Mul(7, 1), Op::U8Add(5, 8), Op::Add(0, 10), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![9, 11, 12, 12, 12, 12, 12, 12, 6]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Sub(0, 1), Op::Call(89, vec![4, 1, 2], 9, false)], ctrl: Ctrl::Return(1, vec![5, 6, 7, 8, 9, 10, 11, 12, 13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 11, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_89() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(2)), Op::Mul(3, 1)], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(84, vec![2, 5], 9, false), Op::Const(G::from_u64(0)), Op::Call(15, vec![6, 7, 8, 9, 10, 11, 12, 13, 4, 1, 15, 15, 15, 15, 15, 15], 9, false)], ctrl: Ctrl::Return(0, vec![16, 17, 18, 19, 20, 21, 22, 23, 14]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(84, vec![2, 5], 9, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(15, vec![6, 7, 8, 9, 10, 11, 12, 13, 4, 1, 15, 16, 16, 16, 16, 16], 9, false)], ctrl: Ctrl::Return(1, vec![17, 18, 19, 20, 21, 22, 23, 24, 14]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Call(84, vec![2, 5], 9, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(15, vec![6, 7, 8, 9, 10, 11, 12, 13, 4, 1, 15, 15, 16, 16, 16, 16], 9, false)], ctrl: Ctrl::Return(2, vec![17, 18, 19, 20, 21, 22, 23, 24, 14]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(84, vec![2, 5], 9, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(15, vec![6, 7, 8, 9, 10, 11, 12, 13, 4, 1, 15, 15, 15, 16, 16, 16], 9, false), Op::AssertEq(vec![25], vec![16], Some("TagN value exceeds UInt64".into()))], ctrl: Ctrl::Return(3, vec![17, 18, 19, 20, 21, 22, 23, 24, 14]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 19, lookups: 3 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_90() -> Function { - Function { body: Block { ops: vec![Op::Call(6, 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(87, vec![0], 9, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(90, 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_91() -> Function { - Function { body: Block { ops: vec![Op::Call(6, 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(98, 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(17, vec![2, 3, 4, 5, 6, 7, 8, 9], 8, false), Op::Call(91, 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_92() -> 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_93() -> 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(92, 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_94() -> Function { - Function { body: Block { ops: vec![Op::Call(83, vec![0], 2, false), Op::U8BitDecomposition(1), Op::Add(7, 8), Op::Add(11, 9), Op::Add(12, 10), Op::Const(G::from_u64(0)), Op::AssertEq(vec![13], vec![14], Some("reserved binder contract bits".into())), Op::Call(93, 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_95() -> Function { - Function { body: Block { ops: vec![Op::Call(83, 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(93, vec![3, 4, 5, 6], 3, false), Op::Call(92, 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_96() -> Function { - Function { body: Block { ops: vec![Op::Call(6, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(98, 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(94, vec![0], 4, false), Op::Call(98, vec![13], 2, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(96, 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_97() -> Function { - Function { body: Block { ops: vec![Op::Call(6, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(98, 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(95, vec![0], 6, false), Op::Call(98, vec![15], 2, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(97, 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_98() -> Function { - Function { body: Block { ops: vec![Op::Call(85, 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(87, vec![10], 9, false), Op::Call(90, 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(87, vec![10], 9, false), Op::Call(90, 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(87, vec![10], 9, false), Op::Call(98, 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(6, 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(98, 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(91, 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(91, 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(6, 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(96, 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(6, 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(97, 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(99, 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_99() -> Function { - Function { body: Block { ops: vec![Op::Add(2, 3), Op::Add(9, 4), Op::Add(10, 5), Op::Add(11, 6), Op::Add(12, 7), Op::Add(13, 8), 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(94, vec![0], 4, false), Op::Call(98, vec![31], 2, false), Op::Call(98, vec![33], 2, false), Op::Call(98, 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_100() -> Function { - Function { body: Block { ops: vec![Op::Call(6, 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(17, vec![9, 10, 11, 12, 13, 14, 15, 16], 8, false), Op::Call(100, 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_101() -> Function { - Function { body: Block { ops: vec![Op::Call(86, vec![0], 10, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(6, 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(101, vec![10], 10, false), Op::Call(100, 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(101, vec![10], 10, false), Op::Call(101, 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(101, vec![10], 10, false), Op::Call(101, 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_102() -> 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_103() -> Function { - Function { body: Block { ops: vec![Op::Call(6, 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(98, vec![0], 2, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(103, 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_104() -> Function { - Function { body: Block { ops: vec![Op::Call(6, 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(101, vec![0], 10, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(104, 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_105() -> Function { - Function { body: Block { ops: vec![Op::Call(6, 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(102, vec![0], 2, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(105, 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_106() -> Function { - Function { body: Block { ops: vec![Op::Call(87, vec![0], 9, false), Op::Call(103, 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_107() -> Function { - Function { body: Block { ops: vec![Op::Call(87, vec![0], 9, false), Op::Call(105, 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_108() -> Function { - Function { body: Block { ops: vec![Op::Call(87, vec![0], 9, false), Op::Call(104, 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_109() -> 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_110() -> Function { - Function { body: Block { ops: vec![Op::Call(83, vec![0], 2, false), Op::Call(109, vec![1], 2, false), Op::Call(87, vec![2], 9, false), Op::Call(98, vec![13], 2, false), Op::Call(98, 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_111() -> Function { - Function { body: Block { ops: vec![Op::Call(87, vec![0], 9, false), Op::Call(98, 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_112() -> Function { - Function { body: Block { ops: vec![Op::Call(6, 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(87, vec![0], 9, false), Op::Call(98, vec![18], 2, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(112, 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_113() -> Function { - Function { body: Block { ops: vec![Op::Call(83, 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(87, vec![2], 9, false), Op::Call(87, vec![22], 9, false), Op::Call(87, vec![31], 9, false), Op::Call(87, vec![40], 9, false), Op::Call(87, vec![49], 9, false), Op::Call(98, vec![58], 2, false), Op::Call(87, vec![60], 9, false), Op::Call(112, 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_114() -> 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_115() -> Function { - Function { body: Block { ops: vec![Op::Call(83, vec![0], 2, false), Op::Call(114, vec![1], 0, false), Op::Call(87, vec![2], 9, false), Op::Call(98, 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_116() -> 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_117() -> Function { - Function { body: Block { ops: vec![Op::Call(83, vec![0], 2, false), Op::Call(116, vec![1], 1, false), Op::Call(87, vec![2], 9, false), Op::Call(98, 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_118() -> Function { - Function { body: Block { ops: vec![Op::Call(83, vec![0], 2, false), Op::Call(114, vec![1], 0, false), Op::Call(87, vec![2], 9, false), Op::Call(87, vec![11], 9, false), Op::Call(87, vec![20], 9, false), Op::Call(87, vec![29], 9, false), Op::Call(98, 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_119() -> Function { - Function { body: Block { ops: vec![Op::Call(6, 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(118, vec![0], 35, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(119, 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_120() -> Function { - Function { body: Block { ops: vec![Op::Call(83, vec![0], 2, false), Op::Call(114, vec![1], 0, false), Op::U8BitDecomposition(1), Op::Call(87, vec![2], 9, false), Op::Call(87, vec![19], 9, false), Op::Call(87, vec![28], 9, false), Op::Call(98, vec![37], 2, false), Op::Call(87, vec![39], 9, false), Op::Call(119, 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_121() -> Function { - Function { body: Block { ops: vec![Op::Call(87, vec![0], 9, false), Op::Call(102, 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_122() -> Function { - Function { body: Block { ops: vec![Op::Call(87, vec![0], 9, false), Op::Call(87, vec![9], 9, false), Op::Call(102, 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_123() -> Function { - Function { body: Block { ops: vec![Op::Call(83, vec![0], 2, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(110, 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(120, 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(113, 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_124() -> Function { - Function { body: Block { ops: vec![Op::Call(6, 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(123, vec![0], 46, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(124, 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_125() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Call(110, 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(113, 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(115, 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(117, 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(122, 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(121, 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(121, 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(121, 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_126() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(12), Block { ops: vec![Op::Call(124, 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: TagN size exceeds a single byte".into())), Op::Call(125, 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_127() -> Function { - Function { body: Block { ops: vec![Op::Call(85, vec![0], 10, false)], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(12), Block { ops: vec![Op::Call(124, 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: TagN size exceeds a single byte".into())), Op::Call(125, 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(87, vec![56], 9, false), Op::Call(103, vec![65, 57, 58, 59, 60, 61, 62, 63, 64], 2, false), Op::Call(87, vec![67], 9, false), Op::Call(105, vec![76, 68, 69, 70, 71, 72, 73, 74, 75], 2, false), Op::Call(87, vec![78], 9, false), Op::Call(104, 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_128() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(3), Block { ops: vec![Op::Call(128, vec![2], 2, false), Op::Call(760, 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_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(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(15, 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(129, 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_130() -> 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(129, 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(129, vec![0], 1, false)], ctrl: Ctrl::Return(3, vec![23]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Call(15, 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(15, 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(130, 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_131() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(130, 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_132() -> 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_133() -> 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(147, 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(132, 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(133, 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(132, 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(132, 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(133, 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_134() -> Function { - Function { body: Block { ops: vec![Op::Call(135, 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_135() -> 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(135, 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_136() -> 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(136, vec![10], 1, false), Op::Load(10, 11)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Call(6, 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_137() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(133, 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(136, 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_138() -> Function { - Function { body: Block { ops: vec![Op::Call(137, 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_139() -> 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(137, 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_140() -> 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(140, 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_141() -> 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::Add(34, 43), Op::Const(G::from_u64(65536)), Op::Mul(16, 37), Op::Add(36, 46), Op::Mul(45, 38), Op::Add(47, 48), Op::Mul(45, 49), Op::Add(44, 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(52, 53), Op::Add(54, 36), Op::Add(55, 46), Op::Add(56, 48), Op::UnconstrainedGToBytes(57), Op::U8RangeCheck(58, 59), Op::U8RangeCheck(60, 61), Op::U8RangeCheck(62, 42), Op::Mul(16, 59), Op::Add(58, 66), Op::Mul(16, 61), Op::Add(60, 68), Op::Mul(45, 62), Op::Add(69, 70), Op::Mul(45, 71), Op::Add(67, 72), Op::AssertEq(vec![57], vec![73], Some("u64_mul: column hint does not recompose".into())), Op::Mul(18, 28), Op::Mul(22, 24), Op::Add(74, 75), Op::Mul(26, 20), Op::Add(76, 77), Op::Add(78, 60), Op::Add(79, 68), Op::Add(80, 70), Op::UnconstrainedGToBytes(81), Op::U8RangeCheck(82, 83), Op::U8RangeCheck(84, 85), Op::U8RangeCheck(86, 42), Op::Mul(16, 83), Op::Add(82, 90), Op::Mul(16, 85), Op::Add(84, 92), Op::Mul(45, 86), Op::Add(93, 94), Op::Mul(45, 95), Op::Add(91, 96), Op::AssertEq(vec![81], vec![97], Some("u64_mul: column hint does not recompose".into())), Op::Mul(18, 32), Op::Mul(22, 28), Op::Add(98, 99), Op::Mul(26, 24), Op::Add(100, 101), Op::Mul(30, 20), Op::Add(102, 103), Op::Add(104, 84), Op::Add(105, 92), Op::Add(106, 94), Op::UnconstrainedGToBytes(107), Op::U8RangeCheck(108, 109), Op::U8RangeCheck(110, 111), Op::U8RangeCheck(112, 42), Op::Mul(16, 109), Op::Add(108, 116), Op::Mul(16, 111), Op::Add(110, 118), Op::Mul(45, 112), Op::Add(119, 120), Op::Mul(45, 121), Op::Add(117, 122), Op::AssertEq(vec![107], vec![123], Some("u64_mul: column hint does not recompose".into())), Op::Mul(22, 32), Op::Mul(26, 28), Op::Add(124, 125), Op::Mul(30, 24), Op::Add(126, 127), Op::Add(128, 110), Op::Add(129, 118), Op::Add(130, 120), Op::UnconstrainedGToBytes(131), Op::U8RangeCheck(132, 133), Op::U8RangeCheck(134, 135), Op::U8RangeCheck(136, 42), Op::Mul(16, 133), Op::Add(132, 140), Op::Mul(16, 135), Op::Add(134, 142), Op::Mul(45, 136), Op::Add(143, 144), Op::Mul(45, 145), Op::Add(141, 146), Op::AssertEq(vec![131], vec![147], Some("u64_mul: column hint does not recompose".into())), Op::Mul(26, 32), Op::Mul(30, 28), Op::Add(148, 149), Op::Add(150, 134), Op::Add(151, 142), Op::Add(152, 144), Op::UnconstrainedGToBytes(153), Op::U8RangeCheck(154, 155), Op::U8RangeCheck(156, 157), Op::U8RangeCheck(158, 42), Op::Mul(16, 155), Op::Add(154, 162), Op::Mul(16, 157), Op::Add(156, 164), Op::Mul(45, 158), Op::Add(165, 166), Op::Mul(45, 167), Op::Add(163, 168), Op::AssertEq(vec![153], vec![169], Some("u64_mul: column hint does not recompose".into())), Op::Mul(30, 32), Op::Add(170, 156), Op::Add(171, 164), Op::Add(172, 166), Op::UnconstrainedGToBytes(173), Op::U8RangeCheck(174, 175), Op::U8RangeCheck(176, 177), Op::U8RangeCheck(178, 42), Op::Mul(16, 175), Op::Add(174, 182), Op::Mul(16, 177), Op::Add(176, 184), Op::Mul(45, 178), Op::Add(185, 186), Op::Mul(45, 187), Op::Add(183, 188), Op::AssertEq(vec![173], vec![189], Some("u64_mul: column hint does not recompose".into())), Op::AssertEq(vec![178], vec![42], Some("u64_mul: final carry exceeds one radix digit".into()))], ctrl: Ctrl::Return(0, vec![34, 35, 58, 59, 82, 83, 108, 109, 132, 133, 154, 155, 174, 175, 176, 177]) }, layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 73, lookups: 22 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_142() -> 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::Add(1, 11), Op::Const(G::from_u64(65536)), Op::Mul(10, 4), Op::Add(3, 14), Op::Mul(13, 5), Op::Add(15, 16), Op::Mul(13, 17), Op::Add(12, 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_143() -> 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(144, 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_144() -> 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(145, vec![5, 6, 7, 8, 9, 10, 11, 12, 1, 14, 14, 14, 14, 14, 14, 14, 14], 1, false), Op::Call(146, vec![15, 3], 1, false), Op::Call(131, vec![2, 16], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 18), Op::Call(144, 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_145() -> Function { - Function { body: Block { ops: vec![Op::Load(10, 8)], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![Op::Call(6, 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(141, vec![0, 1, 2, 3, 4, 5, 6, 7, 18, 19, 20, 21, 22, 23, 24, 25], 16, false), Op::Call(15, 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(145, 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(16, vec![35, 36, 37, 38, 39, 40, 41, 42], 8, false), Op::Call(145, 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_146() -> 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(146, 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_147() -> Function { - Function { body: Block { ops: vec![Op::Call(136, 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_148() -> Function { - Function { body: Block { ops: vec![Op::UnconstrainedBigUintDivMod(0, 1), Op::Call(134, vec![2], 1, false), Op::Call(136, vec![4], 1, false), Op::Call(134, vec![3], 1, false), Op::Call(136, vec![6], 1, false), Op::Call(143, vec![5, 1], 1, false), Op::Call(131, vec![8, 7], 1, false), Op::Call(136, vec![9], 1, false), Op::Call(136, vec![0], 1, false), Op::AssertEq(vec![10], vec![11], Some("div/mod hint: q*b + r != a".into())), Op::Call(147, vec![1], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Call(147, 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(129, vec![7], 1, false), Op::Call(138, 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_149() -> Function { - Function { body: Block { ops: vec![Op::Call(148, 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_150() -> Function { - Function { body: Block { ops: vec![Op::Call(148, 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_151() -> Function { - Function { body: Block { ops: vec![Op::Call(147, 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(150, vec![0, 1], 1, false), Op::Call(151, 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_152() -> Function { - Function { body: Block { ops: vec![Op::Call(147, 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(148, vec![1, 7], 2, false), Op::Call(143, vec![0, 0], 1, false), Op::Call(136, vec![10], 1, false), Op::Call(136, vec![8], 1, false), Op::Call(152, vec![11, 12], 1, false), Op::Call(147, 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(143, 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_153() -> 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_154() -> 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_155() -> 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_156() -> 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(153, vec![3, 4, 5, 6, 7, 8, 9, 10, 13, 14, 15, 16, 17, 18, 19, 20], 8, false), Op::Call(156, 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_157() -> 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(154, vec![3, 4, 5, 6, 7, 8, 9, 10, 13, 14, 15, 16, 17, 18, 19, 20], 8, false), Op::Call(157, 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_158() -> 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(155, vec![3, 4, 5, 6, 7, 8, 9, 10, 13, 14, 15, 16, 17, 18, 19, 20], 8, false), Op::Call(158, 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_159() -> 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(152, 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_160() -> 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(152, vec![6, 1], 1, false), Op::Call(149, 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_161() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(5)), Op::Call(481, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Const(G::from_u64(0)), Op::Store(vec![2, 4, 6, 7])], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(6)), Op::Call(481, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Const(G::from_u64(0)), Op::Store(vec![2, 4, 6, 7])], ctrl: Ctrl::Return(1, vec![8]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_162() -> Function { - Function { body: Block { ops: vec![Op::Call(164, vec![0, 2], 3, false)], ctrl: Ctrl::Match(3, [(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, 7, 7, 7, 7, 7, 7, 7])], ctrl: Ctrl::Return(0, vec![6, 8]) }), (G::from_u64(1), Block { ops: vec![Op::Call(189, vec![0, 5], 2, false)], ctrl: Ctrl::Match(6, [(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(1, vec![8, 10]) }), (G::from_u64(1), Block { ops: vec![Op::Call(189, vec![0, 4], 2, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), 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(2, vec![10, 12]) }), (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![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(152, vec![14, 9], 1, false), Op::Call(150, vec![7, 15], 1, false), Op::Call(136, vec![16], 1, false)], ctrl: Ctrl::Return(3, vec![12, 17]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 13, lookups: 9 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_163() -> Function { - Function { body: Block { ops: vec![Op::Call(775, vec![1], 1, false), Op::Const(G::from_u64(3)), 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(768, vec![1, 5], 1, false), Op::Const(G::from_u64(1)), Op::Call(768, vec![1, 7], 1, false), Op::Const(G::from_u64(2)), Op::Call(768, vec![1, 9], 1, false), Op::Call(162, vec![0, 6, 8], 2, false)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![13, 13, 13, 13])], ctrl: Ctrl::Return(1, vec![13, 14]) }), (G::from_u64(1), Block { ops: vec![Op::Call(162, vec![0, 6, 10], 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(2, vec![15, 16]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(138, vec![14, 12], 1, false), Op::Sub(15, 16), Op::Call(161, vec![0, 17], 1, false)], ctrl: Ctrl::Return(3, vec![15, 18]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 18, lookups: 15 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_164() -> Function { - Function { body: Block { ops: vec![Op::Call(128, vec![1], 2, false), Op::Load(4, 2)], ctrl: Ctrl::Match(4, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(84)), Op::Call(480, vec![0, 5, 8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(775, vec![3], 1, false), Op::Const(G::from_u64(2)), Op::Sub(10, 11)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(768, vec![3, 14], 1, false), Op::Call(768, vec![3, 13], 1, false)], ctrl: Ctrl::Return(0, vec![13, 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(1, vec![13, 14, 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(2, vec![10, 11, 11]) }))) })].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(3, vec![8, 9, 9]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 11, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_165() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Call(775, 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(331, vec![0, 2, 3], 1, false), Op::Const(G::from_u64(0)), Op::Call(768, vec![7, 8], 1, false), Op::Const(G::from_u64(1)), Op::Call(768, vec![7, 10], 1, false), Op::Call(162, vec![0, 9, 11], 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(1, vec![14, 15]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(191, vec![13], 1, false)], ctrl: Ctrl::Return(2, vec![14, 15]) })].into_iter().collect(), None) }))) }), (G::from_u64(2), Block { ops: vec![Op::Call(166, vec![0, 2, 3], 1, false), Op::Call(163, vec![0, 4], 2, false)], ctrl: Ctrl::Return(3, vec![5, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(4, vec![4, 5]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 15, lookups: 13 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_166() -> Function { - Function { body: Block { ops: vec![Op::Call(329, vec![0, 1, 2], 1, false), Op::Load(3, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![3]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![3]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![3]) }), (G::from_u64(0), Block { ops: vec![Op::Call(167, vec![0, 8, 2], 1, false), Op::Call(167, vec![0, 11, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![15, 14, 12]), Op::Store(vec![15, 13, 16]), Op::Store(vec![15, 5, 17])], ctrl: Ctrl::Return(3, vec![18]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 16, lookups: 10 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_167() -> Function { - Function { body: Block { ops: vec![Op::Call(128, vec![1], 2, false), Op::Call(329, vec![0, 4, 2], 1, false), Op::Call(201, vec![3, 5], 1, false)], ctrl: Ctrl::Return(0, vec![6]) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_168() -> Function { - Function { body: Block { ops: vec![Op::Call(775, vec![3], 1, false)], 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)), Op::Call(768, vec![3, 6], 1, false), Op::Call(182, vec![0, 7, 4], 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]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1)), 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(3, vec![8, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(768, vec![3, 8], 1, false), Op::Load(4, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(775, vec![12], 1, false), Op::Call(181, vec![14], 1, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![17, 18, 15, 18])], ctrl: Ctrl::Return(4, vec![16, 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]) }))) }))) }), (G::from_u64(3), Block { ops: vec![Op::Call(169, vec![0, 3], 2, false)], ctrl: Ctrl::Return(7, vec![6, 7]) }), (G::from_u64(4), Block { ops: vec![Op::Call(170, vec![0, 3], 2, false)], ctrl: Ctrl::Return(8, vec![6, 7]) }), (G::from_u64(5), Block { ops: vec![Op::Call(461, vec![0, 1, 3, 4], 2, false)], ctrl: Ctrl::Return(9, vec![6, 7]) }), (G::from_u64(6), Block { ops: vec![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(10, vec![8, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(768, vec![3, 8], 1, false), Op::Const(G::from_u64(1)), Op::Call(768, vec![3, 10], 1, false), Op::Load(4, 9)], ctrl: Ctrl::Match(12, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Load(4, 11)], ctrl: Ctrl::Match(16, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![Op::Call(765, vec![14, 18], 1, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![22, 21, 20, 23])], ctrl: Ctrl::Return(11, vec![21, 24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![20, 20, 20, 20])], ctrl: Ctrl::Return(12, vec![20, 21]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![20, 20, 20, 20])], ctrl: Ctrl::Return(13, vec![20, 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(14, 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(15, vec![16, 17]) }))) }))) })].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(16, vec![6, 7]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 17, auxiliaries: 21, lookups: 14 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_169() -> Function { - Function { body: Block { ops: vec![Op::Call(775, vec![1], 1, false), Op::Const(G::from_u64(1)), 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(768, vec![1, 5], 1, false), Op::Load(4, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(172, vec![9], 1, false), Op::Call(181, vec![11], 1, false), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![13, 14, 12, 14]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(40)), Op::Call(482, vec![0, 17], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![19, 19, 19]), Op::Store(vec![16, 18, 20, 14]), Op::Const(G::from_u64(3)), Op::Store(vec![22, 21, 15, 14])], ctrl: Ctrl::Return(1, vec![19, 23]) })].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![11, 11, 11, 11])], ctrl: Ctrl::Return(3, vec![11, 12]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 21, lookups: 17 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_170() -> Function { - Function { body: Block { ops: vec![Op::Call(775, vec![1], 1, false), Op::Const(G::from_u64(1)), 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(768, vec![1, 5], 1, false), Op::Load(4, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 9)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(89)), Op::Call(482, vec![0, 16], 1, false), Op::Store(vec![14, 14, 14]), Op::Const(G::from_u64(0)), Op::Store(vec![15, 17, 18, 19])], ctrl: Ctrl::Return(1, vec![14, 20]) })].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![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::Store(vec![11, 11, 11, 11])], ctrl: Ctrl::Return(4, vec![11, 12]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 20, lookups: 14 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_171() -> 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(175, vec![2, 3], 2, false), Op::Call(171, 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_172() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(65)), Op::Call(173, 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_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::Call(175, vec![3, 4], 2, false), Op::Call(173, 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_174() -> 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_175() -> 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(174, 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(174, vec![11], 1, false), Op::Const(G::from_u64(64)), Op::Mul(20, 21), Op::Add(19, 22), Op::Call(174, vec![14], 1, false), Op::Add(23, 24), Op::Const(G::from_u64(2048)), Op::U32LessThan(25, 26)], ctrl: Ctrl::Match(27, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(55296)), Op::U32LessThan(25, 28)], ctrl: Ctrl::Match(29, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![25, 15]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(57344)), Op::U32LessThan(25, 30)], ctrl: Ctrl::Match(31, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![25, 15]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].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(174, vec![11], 1, false), Op::Const(G::from_u64(4096)), Op::Mul(23, 24), Op::Add(22, 25), Op::Call(174, vec![14], 1, false), Op::Const(G::from_u64(64)), Op::Mul(27, 28), Op::Add(26, 29), Op::Call(174, vec![17], 1, false), Op::Add(30, 31), Op::Const(G::from_u64(65536)), Op::U32LessThan(32, 33)], ctrl: Ctrl::Match(34, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1114112)), Op::U32LessThan(32, 35)], ctrl: Ctrl::Match(36, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![32, 18]) })].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: 5, auxiliaries: 33, lookups: 27 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_176() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Store(vec![2, 3, 5]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(30)), Op::Call(482, vec![0, 8], 1, false), Op::Store(vec![7, 9, 6, 2]), Op::Const(G::from_u64(31)), Op::Call(482, vec![0, 11], 1, false), Op::Store(vec![7, 12, 6, 2]), Op::Const(G::from_u64(39)), Op::Call(482, vec![0, 14], 1, false), Op::Store(vec![7, 15, 5, 2]), Op::Const(G::from_u64(40)), Op::Call(482, vec![0, 17], 1, false), Op::Store(vec![7, 18, 5, 2]), Op::Const(G::from_u64(38)), Op::Call(482, vec![0, 20], 1, false), Op::Store(vec![7, 21, 5, 2]), Op::Const(G::from_u64(3)), Op::Store(vec![23, 10, 16, 2]), Op::Store(vec![23, 13, 16, 2]), Op::Call(177, vec![1, 24, 25, 19], 1, false), Op::Store(vec![23, 22, 26, 2])], ctrl: Ctrl::Return(0, vec![27]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 18, lookups: 18 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_177() -> 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(175, vec![5, 6], 2, false), Op::Call(181, 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(177, 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_178() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(3), Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(7, [(G::from_u64(2), Block { ops: vec![Op::Call(234, vec![8], 1, false), Op::Load(12, 11)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![24, 24, 24]), Op::Call(283, vec![15, 25], 1, false), Op::Load(4, 26)], ctrl: Ctrl::Match(27, [(G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(316, vec![29, 5, 31], 1, false), Op::Call(365, vec![0, 32, 2], 1, false)], ctrl: Ctrl::Return(0, vec![33]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::Store(vec![31, 26, 5, 32]), Op::Call(365, vec![0, 33, 2], 1, false)], ctrl: Ctrl::Return(1, vec![34]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![1]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![1]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(4, vec![1]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 31, lookups: 10 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_179() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(176, vec![0, 5], 1, false), Op::Call(178, vec![0, 7, 2], 1, false)], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![1]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_180() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(140, vec![0, 1], 2, false), Op::Call(140, vec![3, 1], 2, false), Op::Call(140, vec![5, 1], 2, false), Op::Call(140, 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_181() -> Function { - Function { body: Block { ops: vec![Op::Call(180, 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::Add(6, 11), Op::Const(G::from_u64(65536)), Op::Mul(13, 8), Op::Add(12, 14), Op::Const(G::from_u64(16777216)), Op::Mul(16, 9), Op::Add(15, 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(136, 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_182() -> Function { - Function { body: Block { ops: vec![Op::Call(359, vec![0, 1, 2], 1, false), Op::Call(128, vec![3], 2, false), Op::Load(4, 4)], ctrl: Ctrl::Match(6, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(30)), Op::Call(480, vec![0, 7, 10], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(775, vec![5], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![13, 13, 13])], ctrl: Ctrl::Return(0, vec![13, 14]) })].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])], ctrl: Ctrl::Return(1, vec![13, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(31)), Op::Call(480, vec![0, 7, 12], 1, false)], 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])], ctrl: Ctrl::Return(2, vec![14, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(775, vec![5], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(768, vec![5, 15], 1, false), Op::Call(183, vec![0, 16, 2], 2, false)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![20, 20, 20])], ctrl: Ctrl::Return(3, vec![19, 21]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(768, vec![5, 19], 1, false), Op::Call(182, vec![0, 20, 2], 2, false)], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![23, 22]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(188, vec![18, 22], 1, false)], ctrl: Ctrl::Return(5, vec![23, 24]) })].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![16, 16, 16])], ctrl: Ctrl::Return(6, vec![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![11, 11, 11])], ctrl: Ctrl::Return(7, vec![10, 12]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 8, auxiliaries: 20, lookups: 12 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_183() -> Function { - Function { body: Block { ops: vec![Op::Call(184, vec![0, 1], 2, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5, 4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(359, vec![0, 1, 2], 1, false), Op::Call(184, vec![0, 5], 2, false)], ctrl: Ctrl::Return(1, vec![6, 7]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_184() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], 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::Const(G::from_u64(40)), Op::Call(480, vec![0, 7, 10], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![12, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(12, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Call(185, vec![14], 2, false)], ctrl: Ctrl::Return(1, vec![16, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![16, 16]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![16, 16]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![10, 10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![6, 6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 17, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_185() -> 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(5, 6), Op::Add(21, 7), Op::Add(22, 8), Op::Add(23, 9), 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::Add(2, 27), Op::Const(G::from_u64(65536)), Op::Mul(4, 29), Op::Add(28, 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_186() -> 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(186, 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_187() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(186, vec![0, 1], 2, false), Op::Call(186, vec![3, 1], 2, false), Op::Call(186, 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_188() -> Function { - Function { body: Block { ops: vec![Op::Call(187, 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::Add(7, 17), Op::Const(G::from_u64(4096)), Op::Mul(9, 19), Op::Add(18, 20), Op::Const(G::from_u64(262144)), Op::Mul(10, 22), Op::Add(21, 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_189() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![6, 4]) })].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(1, vec![6, 8]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(480, vec![0, 3, 6], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8])], ctrl: Ctrl::Return(2, vec![8, 9]) })].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(3, vec![8, 10]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Call(190, vec![0, 3, 4], 2, false)], ctrl: Ctrl::Return(4, vec![6, 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![7, 7, 7, 7, 7, 7, 7, 7, 7, 7])], ctrl: Ctrl::Return(5, vec![6, 8]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_190() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(480, vec![0, 4, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(189, vec![0, 2], 2, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(129, vec![10], 1, false)], ctrl: Ctrl::Return(0, vec![11, 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![12, 12, 12, 12, 12, 12, 12, 12, 12, 12])], ctrl: Ctrl::Return(1, vec![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(2, vec![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![8, 8, 8, 8, 8, 8, 8, 8, 8, 8])], ctrl: Ctrl::Return(3, vec![7, 9]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 10, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_191() -> 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_192() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], 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(189, vec![0, 4], 2, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(71)), Op::Call(480, vec![0, 7, 12], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(136, vec![11], 1, false)], ctrl: Ctrl::Return(0, vec![14, 15, 16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(72)), Op::Call(480, vec![0, 7, 14], 1, false)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(129, vec![11], 1, false), Op::Call(136, vec![17], 1, false)], ctrl: Ctrl::Return(1, vec![16, 16, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![17, 17, 17, 17, 17, 17, 17, 17, 17, 17])], ctrl: Ctrl::Return(2, vec![16, 16, 18]) }))) }))) })].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, 13, 13, 13, 13, 13, 13, 13])], ctrl: Ctrl::Return(3, vec![12, 12, 14]) }))) })].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(4, vec![10, 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![7, 7, 7, 7, 7, 7, 7, 7, 7, 7])], ctrl: Ctrl::Return(5, vec![6, 6, 8]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 16, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_193() -> Function { - Function { body: Block { ops: vec![Op::Call(136, vec![2], 1, false), Op::Const(G::from_u64(1)), Op::Call(147, vec![3], 1, false), Op::Sub(4, 5), Op::Mul(1, 6)], ctrl: Ctrl::MatchContinue(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(71)), Op::Call(482, vec![0, 8], 1, false)], ctrl: Ctrl::Yield(0, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(72)), Op::Call(482, vec![0, 8], 1, false)], ctrl: Ctrl::Yield(1, vec![9]) })), 1, 2, 1, Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(7, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(139, vec![3], 1, false), Op::Call(136, vec![9], 1, false)], ctrl: Ctrl::Yield(3, vec![10]) })), 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![12, 12, 12]), Op::Const(G::from_u64(0)), Op::Store(vec![11, 8, 13, 14]), Op::Call(191, vec![9], 1, false), Op::Store(vec![10, 15, 16, 14])], ctrl: Ctrl::Return(4, vec![17]) })) })) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 15, lookups: 10 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_194() -> Function { - Function { body: Block { ops: vec![Op::Sub(1, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(131, vec![2, 4], 1, false), Op::Call(193, vec![0, 1, 6], 1, false)], ctrl: Ctrl::Return(0, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(138, vec![2, 4], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(137, vec![4, 2], 1, false), Op::Call(193, vec![0, 3, 7], 1, false)], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(137, vec![2, 4], 1, false), Op::Call(193, vec![0, 1, 7], 1, false)], ctrl: Ctrl::Return(2, vec![8]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_195() -> Function { - Function { body: Block { ops: vec![Op::Call(147, vec![3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(193, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(150, vec![2, 3], 1, false), Op::Const(G::from_u64(1)), Op::Call(147, vec![5], 1, false), Op::Sub(6, 7), Op::Mul(1, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(137, vec![3, 5], 1, false), Op::Call(193, vec![0, 10, 11], 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(193, vec![0, 10, 5], 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_196() -> Function { - Function { body: Block { ops: vec![Op::Call(147, vec![4], 1, false)], 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![7, 7, 7, 7, 7, 7, 7, 7, 7, 7]), Op::Call(193, vec![0, 6, 8], 1, false)], ctrl: Ctrl::Return(0, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(149, vec![2, 4], 1, false), Op::Call(150, vec![2, 4], 1, false), Op::Const(G::from_u64(1)), Op::Call(147, vec![7], 1, false), Op::Sub(8, 9), Op::Mul(1, 10)], ctrl: Ctrl::MatchContinue(11, [(G::from_u64(1), Block { ops: vec![Op::Call(129, vec![6], 1, false)], ctrl: Ctrl::Yield(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![6]) })), 1, 1, 1, Box::new(Block { ops: vec![Op::Add(1, 3), Op::Const(G::from_u64(2)), Op::Mul(14, 1), Op::Mul(15, 3), Op::Sub(13, 16), Op::Const(G::from_u64(1)), Op::Call(147, vec![12], 1, false), Op::Sub(18, 19), Op::Mul(17, 20), Op::Call(193, vec![0, 21, 12], 1, false)], ctrl: Ctrl::Return(3, vec![22]) })) }))) }, layout: FunctionLayout { input_size: 5, selectors: 4, auxiliaries: 13, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_197() -> Function { - Function { body: Block { ops: vec![Op::Call(147, vec![3], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(193, vec![0, 1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(150, vec![2, 3], 1, false), Op::Const(G::from_u64(1)), Op::Call(147, vec![5], 1, false), Op::Sub(6, 7), Op::Mul(1, 8)], ctrl: Ctrl::MatchContinue(9, [(G::from_u64(1), Block { ops: vec![Op::Call(137, vec![3, 5], 1, false)], ctrl: Ctrl::Yield(1, vec![10]) })].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(0)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Store(vec![13, 13, 13, 13, 13, 13, 13, 13, 13, 13]), Op::Store(vec![11, 12, 11, 11, 11, 11, 11, 11, 11, 14]), Op::Call(129, vec![3], 1, false), Op::Call(149, vec![16, 15], 1, false), Op::Call(138, vec![17, 10], 1, false)], ctrl: Ctrl::Match(18, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(137, vec![3, 10], 1, false), Op::Call(193, vec![0, 19, 20], 1, false)], ctrl: Ctrl::Return(3, vec![21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(193, vec![0, 19, 10], 1, false)], ctrl: Ctrl::Return(4, vec![20]) }))) })) }))) }, layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 15, lookups: 12 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_198() -> Function { - Function { body: Block { ops: vec![Op::Call(147, 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(193, vec![0, 5, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(150, vec![2, 3], 1, false), Op::Const(G::from_u64(1)), Op::Call(147, vec![5], 1, false), Op::Sub(6, 7), Op::Mul(1, 8)], ctrl: Ctrl::MatchContinue(9, [(G::from_u64(1), Block { ops: vec![Op::Call(137, vec![3, 5], 1, false)], ctrl: Ctrl::Yield(1, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![5]) })), 1, 1, 1, Box::new(Block { ops: vec![Op::Call(149, vec![2, 3], 1, false), Op::Const(G::from_u64(1)), Op::Call(147, vec![5], 1, false), Op::Sub(12, 13), Op::Mul(1, 14)], ctrl: Ctrl::MatchContinue(15, [(G::from_u64(1), Block { ops: vec![Op::Call(129, vec![11], 1, false)], ctrl: Ctrl::Yield(3, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(4, vec![11]) })), 1, 1, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(147, vec![16], 1, false), Op::Sub(17, 18), Op::Mul(1, 19), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2)), Op::Store(vec![17, 17, 17, 17, 17, 17, 17, 17, 17, 17]), Op::Store(vec![21, 22, 21, 21, 21, 21, 21, 21, 21, 23]), Op::Call(129, vec![3], 1, false), Op::Call(149, vec![25, 24], 1, false), Op::Call(138, vec![26, 10], 1, false)], ctrl: Ctrl::Match(27, [(G::from_u64(0), Block { ops: vec![Op::Call(193, vec![0, 20, 16], 1, false)], ctrl: Ctrl::Return(5, vec![28]) })].into_iter().collect(), Some(Box::new(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, 29, 28, 28, 28, 28, 28, 28, 28, 30]), Op::Call(194, vec![0, 20, 16, 28, 31], 1, false)], ctrl: Ctrl::Return(6, vec![32]) }))) })) })) }))) }, layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 24, lookups: 17 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_199() -> Function { - Function { body: Block { ops: vec![Op::Call(329, vec![0, 2, 3], 1, false), Op::Call(775, vec![4], 1, false)], ctrl: Ctrl::Match(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), 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::Const(G::from_u64(0)), Op::Call(768, vec![4, 8], 1, false), Op::Call(192, vec![0, 9], 3, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(2), Block { ops: vec![Op::Call(191, vec![12], 1, false)], ctrl: Ctrl::Yield(1, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(13, 11), Op::Call(147, vec![12], 1, false), Op::Sub(13, 15), Op::Mul(14, 16), Op::Call(193, vec![0, 17, 12], 1, false)], ctrl: Ctrl::Yield(2, vec![18]) })), 1, 4, 2, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(777, vec![4, 14], 1, false), Op::Call(201, vec![13, 15], 1, false)], ctrl: Ctrl::Return(3, vec![14, 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(4, vec![13, 14]) }))) }))) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1)), 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(5, vec![8, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(768, vec![4, 8], 1, false), Op::Call(192, vec![0, 9], 3, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(2), Block { ops: vec![Op::Call(191, vec![12], 1, false)], ctrl: Ctrl::Yield(6, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(13, 11), Op::Call(147, vec![12], 1, false), Op::Sub(13, 15), Op::Mul(14, 16), Op::Call(193, vec![0, 17, 12], 1, false)], ctrl: Ctrl::Yield(7, vec![18]) })), 1, 4, 2, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(777, vec![4, 14], 1, false), Op::Call(201, vec![13, 15], 1, false)], ctrl: Ctrl::Return(8, vec![14, 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(9, vec![13, 14]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![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(10, vec![8, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(768, vec![4, 8], 1, false), Op::Call(192, vec![0, 9], 3, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Call(200, vec![0, 1, 4, 11, 12], 2, false)], ctrl: Ctrl::Return(11, 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(12, vec![13, 14]) }))) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 13, auxiliaries: 21, lookups: 15 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_200() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(768, vec![2, 5], 1, false), Op::Call(189, vec![0, 6], 2, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(3), Block { ops: vec![Op::Call(197, vec![0, 3, 4, 8], 1, false)], ctrl: Ctrl::Yield(0, vec![9]) }), (G::from_u64(4), Block { ops: vec![Op::Call(198, vec![0, 3, 4, 8], 1, false)], ctrl: Ctrl::Yield(1, vec![9]) })].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![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(150, vec![8, 13], 1, false), Op::Call(147, vec![14], 1, false), Op::Sub(11, 15), Op::Mul(3, 16), Op::Call(152, vec![4, 8], 1, false), Op::Call(193, vec![0, 17, 18], 1, false)], ctrl: Ctrl::Yield(2, vec![19]) })), 1, 9, 6, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Call(777, vec![2, 11], 1, false), Op::Call(201, vec![9, 12], 1, false)], ctrl: Ctrl::Return(3, vec![10, 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(4, vec![9, 10]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(768, vec![2, 5], 1, false), Op::Call(189, vec![0, 6], 2, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(3), Block { ops: vec![Op::Call(197, vec![0, 3, 4, 8], 1, false)], ctrl: Ctrl::Yield(5, vec![9]) }), (G::from_u64(4), Block { ops: vec![Op::Call(198, vec![0, 3, 4, 8], 1, false)], ctrl: Ctrl::Yield(6, vec![9]) })].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![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(150, vec![8, 13], 1, false), Op::Call(147, vec![14], 1, false), Op::Sub(11, 15), Op::Mul(3, 16), Op::Call(152, vec![4, 8], 1, false), Op::Call(193, vec![0, 17, 18], 1, false)], ctrl: Ctrl::Yield(7, vec![19]) })), 1, 9, 6, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Call(777, vec![2, 11], 1, false), Op::Call(201, vec![9, 12], 1, false)], ctrl: Ctrl::Return(8, vec![10, 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(9, vec![9, 10]) }))) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(768, vec![2, 5], 1, false), Op::Call(189, vec![0, 6], 2, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(3), Block { ops: vec![Op::Call(197, vec![0, 3, 4, 8], 1, false)], ctrl: Ctrl::Yield(10, vec![9]) }), (G::from_u64(4), Block { ops: vec![Op::Call(198, vec![0, 3, 4, 8], 1, false)], ctrl: Ctrl::Yield(11, vec![9]) })].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![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(150, vec![8, 13], 1, false), Op::Call(147, vec![14], 1, false), Op::Sub(11, 15), Op::Mul(3, 16), Op::Call(152, vec![4, 8], 1, false), Op::Call(193, vec![0, 17, 18], 1, false)], ctrl: Ctrl::Yield(12, vec![19]) })), 1, 9, 6, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Call(777, vec![2, 11], 1, false), Op::Call(201, vec![9, 12], 1, false)], ctrl: Ctrl::Return(13, vec![10, 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(14, vec![9, 10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(768, vec![2, 5], 1, false), Op::Call(192, vec![0, 6], 3, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(6), Block { ops: vec![Op::Call(194, vec![0, 3, 4, 8, 9], 1, false)], ctrl: Ctrl::Yield(15, vec![10]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(10, 8), Op::Call(147, vec![9], 1, false), Op::Sub(10, 12), Op::Mul(11, 13), Op::Call(194, vec![0, 3, 4, 14, 9], 1, false)], ctrl: Ctrl::Yield(16, vec![15]) }), (G::from_u64(8), Block { ops: vec![Op::Add(3, 8), Op::Const(G::from_u64(2)), Op::Mul(11, 3), Op::Mul(12, 8), Op::Sub(10, 13), Op::Const(G::from_u64(1)), Op::Call(147, vec![4], 1, false), Op::Sub(15, 16), Op::Mul(14, 17), Op::Call(147, vec![9], 1, false), Op::Sub(15, 19), Op::Mul(18, 20), Op::Call(143, vec![4, 9], 1, false), Op::Call(193, vec![0, 21, 22], 1, false)], ctrl: Ctrl::Yield(17, vec![23]) }), (G::from_u64(9), Block { ops: vec![Op::Call(195, vec![0, 3, 4, 9], 1, false)], ctrl: Ctrl::Yield(18, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(196, vec![0, 3, 4, 8, 9], 1, false)], ctrl: Ctrl::Yield(19, vec![10]) })), 1, 7, 4, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Call(777, vec![2, 12], 1, false), Op::Call(201, vec![10, 13], 1, false)], ctrl: Ctrl::Return(20, vec![11, 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(21, vec![10, 11]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 22, auxiliaries: 18, lookups: 11 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_201() -> 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(201, 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_202() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(131, vec![2, 3], 1, false), Op::Call(136, vec![5], 1, false), Op::Call(191, vec![6], 1, false)], ctrl: Ctrl::Return(0, vec![4, 7]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(137, vec![2, 3], 1, false), Op::Call(136, vec![5], 1, false), Op::Call(191, vec![6], 1, false)], ctrl: Ctrl::Return(1, vec![4, 7]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(143, vec![2, 3], 1, false), Op::Call(136, vec![5], 1, false), Op::Call(191, vec![6], 1, false)], ctrl: Ctrl::Return(2, vec![4, 7]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(149, vec![2, 3], 1, false), Op::Call(136, vec![5], 1, false), Op::Call(191, vec![6], 1, false)], ctrl: Ctrl::Return(3, vec![4, 7]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(150, vec![2, 3], 1, false), Op::Call(136, vec![5], 1, false), Op::Call(191, vec![6], 1, false)], ctrl: Ctrl::Return(4, vec![4, 7]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(151, vec![2, 3], 1, false), Op::Call(136, vec![5], 1, false), Op::Call(191, vec![6], 1, false)], ctrl: Ctrl::Return(5, vec![4, 7]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(152, vec![2, 3], 1, false), Op::Call(136, vec![5], 1, false), Op::Call(191, vec![6], 1, false)], ctrl: Ctrl::Return(6, vec![4, 7]) }), (G::from_u64(10), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(156, vec![2, 3], 1, false), Op::Call(136, vec![5], 1, false), Op::Call(191, vec![6], 1, false)], ctrl: Ctrl::Return(7, vec![4, 7]) }), (G::from_u64(11), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(157, vec![2, 3], 1, false), Op::Call(136, vec![5], 1, false), Op::Call(191, vec![6], 1, false)], ctrl: Ctrl::Return(8, vec![4, 7]) }), (G::from_u64(12), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(158, vec![2, 3], 1, false), Op::Call(136, vec![5], 1, false), Op::Call(191, vec![6], 1, false)], ctrl: Ctrl::Return(9, vec![4, 7]) }), (G::from_u64(13), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(159, vec![2, 3], 1, false), Op::Call(136, vec![5], 1, false), Op::Call(191, vec![6], 1, false)], ctrl: Ctrl::Return(10, vec![4, 7]) }), (G::from_u64(14), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(160, vec![2, 3], 1, false), Op::Call(136, vec![5], 1, false), Op::Call(191, vec![6], 1, false)], ctrl: Ctrl::Return(11, vec![4, 7]) }), (G::from_u64(15), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(285, vec![2, 3], 1, false), Op::Call(161, vec![0, 5], 1, false)], ctrl: Ctrl::Return(12, vec![4, 6]) }), (G::from_u64(16), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(138, vec![2, 3], 1, false), Op::Call(161, vec![0, 5], 1, false)], ctrl: Ctrl::Return(13, vec![4, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 4, 4])], ctrl: Ctrl::Return(14, vec![4, 5]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 15, auxiliaries: 16, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_203() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(42)), Op::Call(480, vec![0, 4, 7], 1, false)], ctrl: Ctrl::Match(8, [(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(0, vec![9, 1, 11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(775, 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(0)), Op::Call(768, vec![2, 12], 1, false), Op::Const(G::from_u64(1)), Op::Call(768, vec![2, 14], 1, false), Op::Load(4, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![20, 13, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![21, 21, 21, 21, 21, 21, 21, 21, 21, 21])], ctrl: Ctrl::Return(2, vec![20, 1, 22]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![21, 21, 21, 21, 21, 21, 21, 21, 21, 21])], ctrl: Ctrl::Return(3, vec![20, 1, 22]) }))) })].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, 13, 13, 13, 13, 13, 13, 13])], ctrl: Ctrl::Return(4, vec![12, 1, 14]) }))) }))) })].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(5, vec![7, 1, 9]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 16, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_204() -> Function { - Function { body: 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]), Op::Call(137, vec![2, 6], 1, false), Op::Call(136, vec![7], 1, false), Op::Const(G::from_u64(2)), Op::Call(481, vec![0, 9], 1, false), Op::Store(vec![4, 4, 4]), Op::Store(vec![9, 10, 11, 3]), Op::Call(147, vec![8], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::Store(vec![14, 12, 1, 15])], ctrl: Ctrl::Return(0, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(42)), Op::Call(481, vec![0, 15], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![17, 17, 17]), Op::Const(G::from_u64(0)), Op::Store(vec![14, 16, 18, 19]), Op::Const(G::from_u64(7)), Op::Store(vec![21, 19, 8, 19]), Op::Const(G::from_u64(3)), Op::Store(vec![23, 20, 1, 19]), Op::Store(vec![23, 24, 22, 19]), Op::Store(vec![23, 12, 25, 19])], ctrl: Ctrl::Return(1, vec![26]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 17, lookups: 16 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_205() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(128, vec![1], 2, false), Op::Load(4, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(2), Block { ops: vec![Op::Call(203, vec![0, 6, 7], 3, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Call(136, vec![14], 1, false), Op::Call(147, vec![15], 1, false)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(204, vec![0, 13, 15], 1, false)], ctrl: Ctrl::Return(2, vec![17]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![1]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(4, vec![1]) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 19, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_206() -> Function { - Function { body: Block { ops: vec![Op::Call(147, vec![2], 1, false)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(201, vec![1, 3], 1, false)], ctrl: Ctrl::Return(0, vec![5, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(42)), Op::Call(481, vec![0, 6], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Const(G::from_u64(0)), Op::Store(vec![5, 7, 9, 10]), Op::Const(G::from_u64(3)), Op::Store(vec![12, 11, 1, 10]), Op::Call(191, vec![2], 1, false), Op::Store(vec![12, 13, 14, 10]), Op::Call(201, vec![15, 3], 1, false)], ctrl: Ctrl::Return(1, vec![8, 16]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 10, lookups: 9 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_207() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(4), Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(6, [(G::from_u64(4), Block { ops: vec![Op::Call(128, vec![8], 2, false), Op::Load(4, 10)], ctrl: Ctrl::Match(12, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(480, vec![0, 13, 16], 1, false)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(775, vec![11], 1, false), Op::Const(G::from_u64(1)), Op::Sub(18, 19)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(768, vec![11, 21], 1, false), Op::Load(4, 22)], ctrl: Ctrl::Match(23, [(G::from_u64(0), Block { ops: vec![Op::EqZero(24)], ctrl: Ctrl::Return(1, vec![27]) })].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![21]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![16]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 7, auxiliaries: 25, lookups: 9 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_208() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(2)), Op::U32LessThan(4, 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(768, vec![1, 5], 1, false), Op::Call(189, vec![0, 8], 2, false)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![11, 11, 11, 11])], ctrl: Ctrl::Return(1, vec![11, 12]) }), (G::from_u64(1), Block { ops: vec![Op::Add(2, 3), Op::Const(G::from_u64(1)), Op::Add(11, 12), Op::Call(768, vec![1, 13], 1, false), Op::Call(207, vec![0, 14], 1, false)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![16, 16, 16, 16])], ctrl: Ctrl::Return(2, vec![16, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(768, vec![1, 11], 1, false), Op::Const(G::from_u64(1)), Op::Add(5, 17), Op::Call(777, vec![1, 18], 1, false), Op::Call(189, vec![0, 16], 2, false)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(131, vec![21, 10], 1, false), Op::Call(191, vec![23], 1, false), Op::Call(201, vec![24, 19], 1, false)], ctrl: Ctrl::Return(3, vec![22, 25]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(206, vec![0, 16, 10, 19], 2, false)], ctrl: Ctrl::Return(4, vec![22, 23]) }))) }))) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 6, selectors: 5, auxiliaries: 21, lookups: 17 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_209() -> Function { - Function { body: Block { ops: vec![Op::Call(775, vec![3], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), 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::Const(G::from_u64(0)), Op::Call(768, vec![3, 8], 1, false), Op::Call(189, vec![0, 9], 2, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(777, vec![3, 12], 1, false), Op::Call(129, vec![11], 1, false), Op::Call(191, vec![14], 1, false), Op::Call(201, vec![15, 13], 1, false)], ctrl: Ctrl::Return(1, vec![12, 16]) })].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(2, vec![12, 13]) }))) }))) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1)), 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(3, vec![8, 9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(768, vec![3, 8], 1, false), Op::Call(189, vec![0, 9], 2, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(777, vec![3, 12], 1, false), Op::Call(139, vec![11], 1, false), Op::Call(136, vec![14], 1, false), Op::Call(191, vec![15], 1, false), Op::Call(201, vec![16, 13], 1, false)], ctrl: Ctrl::Return(4, vec![12, 17]) })].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(5, vec![12, 13]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(210, vec![0, 1, 2, 3, 5], 2, false)], ctrl: Ctrl::Return(6, vec![6, 7]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 7, auxiliaries: 17, lookups: 15 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_210() -> Function { - Function { body: Block { ops: vec![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(768, vec![3, 7], 1, false), Op::Const(G::from_u64(1)), Op::Call(768, vec![3, 9], 1, false), Op::Call(189, vec![0, 8], 2, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(189, vec![0, 10], 2, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Call(202, vec![0, 2, 12, 14], 2, false)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(777, vec![3, 17], 1, false), Op::Const(G::from_u64(1)), Op::Call(201, vec![16, 18], 1, false)], ctrl: Ctrl::Return(1, vec![19, 20]) })].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(2, 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(3, vec![15, 16]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(189, vec![0, 10], 2, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Call(211, vec![0, 1, 2, 8, 14, 3], 2, false)], ctrl: Ctrl::Return(4, vec![15, 16]) })].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]) }))) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 6, auxiliaries: 18, lookups: 14 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_211() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(777, vec![5, 6], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(3), Block { ops: vec![Op::Call(206, vec![0, 3, 4, 7], 2, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(0, vec![10, 9]) })].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(1, vec![10, 11]) }))) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(147, vec![4], 1, false), Op::Sub(8, 9), Op::Call(139, vec![4], 1, false), Op::Call(136, vec![11], 1, false), Op::Call(147, vec![12], 1, false), Op::Sub(8, 13), Op::Mul(10, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![16, 16, 16, 16])], ctrl: Ctrl::Return(2, vec![16, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(212, vec![1, 3, 4, 7], 1, false)], ctrl: Ctrl::Return(3, vec![16, 17]) }))) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(147, vec![4], 1, false), Op::Sub(8, 9), Op::Call(139, vec![4], 1, false), Op::Call(136, vec![11], 1, false), Op::Call(147, vec![12], 1, false), Op::Sub(8, 13), Op::Mul(10, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(0), 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(2)), Op::Call(212, vec![1, 3, 4, 7], 1, false)], 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![8, 8, 8, 8])], ctrl: Ctrl::Return(6, vec![8, 9]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 7, auxiliaries: 9, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_212() -> 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(191, vec![2], 1, false), Op::Store(vec![9, 10, 11, 7]), Op::Call(201, 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_213() -> 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(213, 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(213, 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(213, 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(213, 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(213, 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(213, 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(213, 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(213, 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_214() -> 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(214, 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_215() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(213, vec![0, 1, 1, 1, 1, 1, 1, 1, 1, 1], 8, false), Op::Const(G::from_u64(8)), Op::Call(214, 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(215, 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(6, 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_216() -> 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(216, 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(216, vec![2], 1, false), Op::Call(216, 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(216, vec![2], 1, false), Op::Call(216, 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(18, 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_217() -> 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(18, vec![3, 4, 5, 6, 7, 8, 9, 10], 1, false), Op::Call(768, vec![1, 12], 1, false), Op::Const(G::from_u64(0)), Op::Call(216, vec![13], 1, false), Op::Call(217, 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_218() -> Function { - Function { body: Block { ops: vec![Op::Load(18, 0)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(18, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(768, vec![4, 23], 1, false), Op::Const(G::from_u64(1)), Op::Call(216, 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(18, 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(18, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(768, vec![2, 23], 1, false), Op::Call(217, 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(18, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(768, vec![3, 23], 1, false), Op::Call(217, 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(18, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(768, vec![2, 23], 1, false), Op::Const(G::from_u64(8)), Op::Call(18, vec![14, 15, 16, 17, 18, 19, 20, 21], 1, false), Op::Call(218, 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(18, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(768, vec![2, 23], 1, false), Op::Call(231, vec![24], 1, false), Op::Call(171, 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(18, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(768, vec![2, 23], 1, false), Op::Call(231, vec![24], 1, false), Op::Call(215, 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(218, vec![6, 1, 2, 3, 4], 1, false), Op::Call(218, 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(218, vec![9, 1, 2, 3, 4], 1, false), Op::Call(218, 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(218, vec![11, 1, 2, 3, 4], 1, false), Op::Call(218, 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(218, vec![11, 1, 2, 3, 4], 1, false), Op::Call(218, vec![12, 1, 2, 3, 4], 1, false), Op::Call(218, 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(18, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Call(777, vec![1, 23], 1, false), Op::Load(3, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(0), Block { ops: vec![Op::Call(218, 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_219() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(218, vec![10, 12, 13, 14, 15], 1, false), Op::Call(218, vec![11, 12, 13, 14, 15], 1, false), Op::Call(18, 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_220() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(218, vec![9, 10, 11, 12, 13], 1, false), Op::Const(G::from_u64(0)), Op::Call(18, 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_221() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(218, vec![9, 10, 11, 12, 13], 1, false), Op::Const(G::from_u64(4)), Op::Call(18, 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_222() -> 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(222, 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_223() -> 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(223, 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_224() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(218, vec![25, 29, 30, 31, 32], 1, false), Op::Const(G::from_u64(5)), Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false), Op::Call(18, vec![9, 10, 11, 12, 13, 14, 15, 16], 1, false), Op::Call(18, vec![17, 18, 19, 20, 21, 22, 23, 24], 1, false), Op::Call(222, 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_225() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(218, vec![33, 36, 37, 38, 39], 1, false), Op::Const(G::from_u64(6)), Op::Call(18, vec![1, 2, 3, 4, 5, 6, 7, 8], 1, false), Op::Call(18, vec![9, 10, 11, 12, 13, 14, 15, 16], 1, false), Op::Call(18, vec![17, 18, 19, 20, 21, 22, 23, 24], 1, false), Op::Call(18, 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_226() -> 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(218, vec![15, 1, 2, 3, 4], 1, false), Op::Const(G::from_u64(0)), Op::Call(18, vec![7, 8, 9, 10, 11, 12, 13, 14], 1, false), Op::Const(G::from_u64(1)), Op::Add(5, 20), Op::Call(226, 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_227() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(218, vec![42, 46, 47, 48, 49], 1, false), Op::Const(G::from_u64(0)), Op::Call(226, vec![43, 46, 47, 48, 49, 51], 1, false), Op::Const(G::from_u64(7)), Op::Call(18, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Call(18, vec![10, 11, 12, 13, 14, 15, 16, 17], 1, false), Op::Call(18, vec![18, 19, 20, 21, 22, 23, 24, 25], 1, false), Op::Call(18, vec![26, 27, 28, 29, 30, 31, 32, 33], 1, false), Op::Call(18, 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_228() -> 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(22, 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(127, 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_229() -> Function { - Function { body: Block { ops: vec![], 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(230, vec![0], 1, true)], 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: 13, selectors: 2, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_230() -> 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_231() -> 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(22, 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_232() -> 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_233() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(232, 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(242, 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_234() -> Function { - Function { body: Block { ops: vec![Op::Call(228, 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(229, vec![0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], 1, false)], ctrl: Ctrl::MatchContinue(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(232, 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(219, 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(220, 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(221, 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(235, 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(18, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Call(236, 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(18, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Call(18, vec![10, 11, 12, 13, 14, 15, 16, 17], 1, false), Op::Call(237, 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(18, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Call(238, 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(227, 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: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_235() -> Function { - Function { body: Block { ops: vec![Op::Call(228, 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(769, 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(229, vec![0, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70], 1, false), Op::Call(233, vec![59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 11, 9], 1, false), Op::Call(219, 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: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_236() -> Function { - Function { body: Block { ops: vec![Op::Call(228, 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(239, vec![3, 1], 45, false)], ctrl: Ctrl::Match(50, [(G::from_u64(1), Block { ops: vec![Op::Call(242, vec![3, 0], 1, false), Op::Call(224, 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_237() -> Function { - Function { body: Block { ops: vec![Op::Call(228, 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(239, 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(223, vec![78, 2], 34, false), Op::Call(242, vec![4, 0], 1, false), Op::Call(225, 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_238() -> Function { - Function { body: Block { ops: vec![Op::Call(228, 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(239, vec![3, 1], 45, false)], ctrl: Ctrl::Match(50, [(G::from_u64(2), Block { ops: vec![Op::Call(242, vec![3, 0], 1, false), Op::Call(227, 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_239() -> 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(239, 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_240() -> 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(18, 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_241() -> Function { - Function { body: Block { ops: vec![Op::Call(239, vec![0, 2], 45, false), Op::Call(240, 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(82, 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(23, 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_242() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(243, 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_243() -> 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(241, vec![0, 1, 3], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 53), Op::Call(243, 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_244() -> 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(244, vec![2], 1, false), Op::Call(244, 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(244, 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_245() -> 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(245, 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(245, vec![3, 6], 1, false), Op::Call(245, 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(245, vec![3, 6], 1, false), Op::Call(245, 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_246() -> 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(246, 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_247() -> 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(247, vec![0, 7], 1, false)], ctrl: Ctrl::Return(3, vec![10]) }), (G::from_u64(0), Block { ops: vec![Op::Call(247, 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_248() -> 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(248, 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_249() -> 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(249, 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_250() -> 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(250, 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_251() -> 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(251, 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_252() -> 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(252, 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_253() -> 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(253, 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(253, 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(253, 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(253, 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_254() -> 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(255, 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(255, 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_255() -> 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(246, 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(255, 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_256() -> 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(246, vec![1, 7], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(250, 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(256, 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_257() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Call(254, 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(257, vec![5, 1, 8, 3], 1, false)], ctrl: Ctrl::Return(1, vec![9]) }), (G::from_u64(2), Block { ops: vec![Op::Call(257, vec![5, 1, 2, 3], 1, false), Op::Call(257, vec![6, 1, 2, 7], 1, false)], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(3), Block { ops: vec![Op::Call(258, vec![5, 6, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(3, vec![7]) }), (G::from_u64(4), Block { ops: vec![Op::Call(249, vec![5, 1], 2, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(254, vec![3, 1, 2], 1, false), Op::Call(256, 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(256, 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_258() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(254, 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(257, vec![0, 2, 3, 4], 1, false), Op::Call(257, vec![6, 2, 9, 10], 1, false)], ctrl: Ctrl::Return(1, vec![11]) }), (G::from_u64(2), Block { ops: vec![Op::Call(258, vec![0, 6, 2, 3, 4], 1, false), Op::Call(258, vec![0, 7, 2, 3, 8], 1, false)], ctrl: Ctrl::Return(2, vec![9]) }), (G::from_u64(3), Block { ops: vec![Op::Call(258, vec![0, 7, 2, 3, 4], 1, false), Op::Call(258, vec![6, 7, 2, 3, 8], 1, false)], ctrl: Ctrl::Return(3, vec![9]) }), (G::from_u64(4), Block { ops: vec![Op::Call(249, vec![6, 2], 2, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(254, vec![4, 2, 3], 1, false), Op::Call(256, vec![10, 9, 6, 3], 1, false), Op::Call(257, 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(256, vec![4, 2, 6, 3], 1, false)], ctrl: Ctrl::Yield(6, vec![10]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Call(257, 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_259() -> 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(260, vec![3, 1], 1, false), Op::Call(259, 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_260() -> 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(247, vec![8, 5], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Call(260, vec![0, 4], 1, false)], ctrl: Ctrl::Return(1, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(248, 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(252, 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(253, 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(260, 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_261() -> 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(261, 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_262() -> Function { - Function { body: Block { ops: vec![Op::Call(261, vec![0], 1, false), Op::Call(261, 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(246, 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(251, vec![12, 15], 1, false)], ctrl: Ctrl::Match(18, [(G::from_u64(1), Block { ops: vec![Op::Call(262, 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_263() -> 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(247, vec![6, 1], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Call(263, 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(264, 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(263, 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_264() -> 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(264, 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_265() -> 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(247, vec![7, 1], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Call(265, vec![6, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(1, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(266, 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(265, 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_266() -> 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(266, 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(266, 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_267() -> 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(263, 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(268, 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(267, 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_268() -> 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(265, 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(268, 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_269() -> 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(257, vec![0, 3, 1, 5], 1, false), Op::Call(259, 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_270() -> Function { - Function { body: Block { ops: vec![Op::Call(245, 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(269, vec![0], 1, false), Op::Call(269, vec![1], 1, false), Op::Call(267, 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_271() -> Function { - Function { body: Block { ops: vec![Op::Call(245, 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(269, vec![0], 1, false), Op::Call(269, vec![1], 1, false), Op::Call(262, 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_272() -> Function { - Function { body: Block { ops: vec![Op::Call(277, vec![0], 2, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Call(277, 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(273, vec![0, 1], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(273, 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_273() -> Function { - Function { body: Block { ops: vec![Op::Call(274, 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(275, 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(275, 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(276, 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_274() -> 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(274, 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(274, vec![4, 7], 1, false), Op::Call(274, 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(274, vec![4, 7], 1, false), Op::Call(274, 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_275() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(2), Block { ops: vec![Op::Call(274, 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(274, 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_276() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(278, vec![0, 2], 2, false), Op::Call(278, vec![1, 2], 2, false), Op::Call(274, 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_277() -> 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(277, 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_278() -> 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(278, 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_279() -> 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(272, vec![0, 1], 1, false)], ctrl: Ctrl::Return(1, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(244, vec![1], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(272, 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(245, 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_280() -> 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(280, 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(280, vec![2], 1, false), Op::Call(280, vec![3], 1, false), Op::Call(272, vec![4, 5], 1, false)], ctrl: Ctrl::Return(3, vec![6]) }), (G::from_u64(3), Block { ops: vec![Op::Call(280, vec![2], 1, false), Op::Call(280, vec![3], 1, false), Op::Call(279, 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_281() -> 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(281, 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(281, vec![3, 1], 1, false), Op::Call(281, vec![4, 1], 1, false), Op::Call(272, vec![5, 6], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }), (G::from_u64(3), Block { ops: vec![Op::Call(281, vec![3, 1], 1, false), Op::Call(281, vec![4, 1], 1, false), Op::Call(279, vec![5, 6], 1, false)], ctrl: Ctrl::Return(3, vec![7]) }), (G::from_u64(4), Block { ops: vec![Op::Call(768, 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_282() -> 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(281, vec![3, 1], 1, false), Op::Call(282, 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_283() -> 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(284, 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_284() -> 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(281, 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(282, 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(283, vec![3, 1], 1, false), Op::Call(283, 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(283, vec![3, 1], 1, false), Op::Call(283, 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(283, vec![3, 1], 1, false), Op::Call(283, 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(283, vec![3, 1], 1, false), Op::Call(283, vec![4, 1], 1, false), Op::Call(283, 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(283, 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_285() -> 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(14, 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(285, 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_286() -> 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(286, 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_287() -> 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(285, 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(286, 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_288() -> 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(288, vec![2], 1, false), Op::Call(288, vec![3], 1, false), Op::Call(290, vec![5, 6], 1, false)], ctrl: Ctrl::Return(4, vec![7]) }), (G::from_u64(4), Block { ops: vec![Op::Call(288, vec![2], 1, false), Op::Call(288, vec![3], 1, false), Op::Call(291, vec![6], 1, false), Op::Call(290, vec![5, 7], 1, false)], ctrl: Ctrl::Return(5, vec![8]) }), (G::from_u64(5), Block { ops: vec![Op::Call(288, vec![2], 1, false), Op::Call(288, vec![3], 1, false), Op::Call(291, vec![6], 1, false), Op::Call(290, vec![5, 7], 1, false)], ctrl: Ctrl::Return(6, vec![8]) }), (G::from_u64(6), Block { ops: vec![Op::Call(289, vec![2, 3, 4], 1, false)], ctrl: Ctrl::Return(7, vec![5]) }), (G::from_u64(8), Block { ops: vec![Op::Call(288, 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_289() -> Function { - Function { body: Block { ops: vec![Op::Call(288, vec![0], 1, false), Op::Call(288, vec![1], 1, false), Op::Call(290, vec![3, 4], 1, false), Op::Call(288, vec![2], 1, false), Op::Call(291, vec![6], 1, false), Op::Call(290, 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_290() -> 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_291() -> 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_292() -> 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_293() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(294, vec![4, 1, 2], 1, false)], ctrl: Ctrl::Return(0, vec![7]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![7]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![7]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![7]) }), (G::from_u64(3), Block { ops: vec![Op::Call(293, 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(4, vec![8]) }), (G::from_u64(0), Block { ops: vec![Op::Call(293, vec![5, 1, 2], 1, false)], ctrl: Ctrl::Return(5, vec![8]) })].into_iter().collect(), None) }), (G::from_u64(4), Block { ops: vec![Op::Call(295, vec![4, 5, 1, 2], 1, false)], ctrl: Ctrl::Return(6, vec![7]) }), (G::from_u64(5), Block { ops: vec![Op::Call(295, vec![4, 5, 1, 2], 1, false)], ctrl: Ctrl::Return(7, vec![7]) }), (G::from_u64(6), Block { ops: vec![Op::Call(296, vec![4, 5, 6, 1, 2], 1, false)], ctrl: Ctrl::Return(8, vec![7]) }), (G::from_u64(8), Block { ops: vec![Op::Call(293, vec![6, 1, 2], 1, false)], ctrl: Ctrl::Return(9, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 10, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_294() -> Function { - Function { body: 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(0, vec![4]) }), (G::from_u64(0), Block { ops: vec![Op::U32LessThan(0, 2)], ctrl: Ctrl::Return(1, vec![4]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 13, lookups: 13 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_295() -> Function { - Function { body: Block { ops: vec![Op::Call(293, 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(293, 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_296() -> Function { - Function { body: Block { ops: vec![Op::Call(293, 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(293, 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(293, 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_297() -> Function { - Function { body: Block { ops: vec![Op::Call(775, vec![0], 1, false), Op::Call(292, vec![1, 2], 1, false), Op::Call(298, 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_298() -> Function { - Function { body: Block { ops: vec![Op::Call(299, 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(777, vec![0, 2], 1, false), Op::Sub(1, 2), Op::Call(298, 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_299() -> 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(288, vec![2], 1, false), Op::Call(300, 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_300() -> 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(299, 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(777, vec![0, 2], 1, false), Op::Sub(1, 2), Op::Call(300, 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_301() -> 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(775, 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(775, vec![0], 1, false), Op::Call(292, vec![1, 4], 1, false), Op::Call(298, vec![0, 5], 1, false), Op::Call(776, 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_302() -> Function { - Function { body: Block { ops: vec![Op::Call(288, 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(303, 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_303() -> 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(302, 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(302, vec![4, 1], 1, false), Op::Call(292, vec![6, 7], 1, false)], ctrl: Ctrl::Return(6, vec![8]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Call(304, vec![3, 4, 1], 1, false)], ctrl: Ctrl::Return(7, vec![6]) }), (G::from_u64(5), Block { ops: vec![Op::Call(304, vec![3, 4, 1], 1, false)], ctrl: Ctrl::Return(8, vec![6]) }), (G::from_u64(6), Block { ops: vec![Op::Call(305, vec![3, 4, 5, 1], 1, false)], ctrl: Ctrl::Return(9, vec![6]) }), (G::from_u64(8), Block { ops: vec![Op::Call(302, 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_304() -> Function { - Function { body: Block { ops: vec![Op::Call(302, 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(302, vec![1, 5], 1, false), Op::Call(292, 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_305() -> Function { - Function { body: Block { ops: vec![Op::Call(302, 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(302, 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(292, vec![4, 5], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 7), Op::Call(302, vec![2, 8], 1, false), Op::Call(292, 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_306() -> 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(288, 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(307, 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_307() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(308, 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(306, vec![4, 1, 2], 1, false), Op::Call(306, 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(306, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(306, 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(306, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(306, 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(309, 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(306, 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_308() -> 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_309() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(306, vec![0, 3, 4], 1, false), Op::Call(306, vec![1, 3, 4], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 8), Op::Call(306, 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_310() -> 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(288, 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(311, 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_311() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Sub(4, 1), Op::Store(vec![7, 8, 7, 7])], ctrl: Ctrl::Return(0, vec![9]) }), (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(310, vec![4, 1, 2], 1, false), Op::Call(310, 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(310, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(310, 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(310, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(310, 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(312, 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(310, 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_312() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(310, vec![0, 3, 4], 1, false), Op::Call(310, vec![1, 3, 4], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 8), Op::Call(310, 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_313() -> 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(313, 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(313, vec![4, 1], 1, false)], ctrl: Ctrl::Return(3, vec![7]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Call(314, vec![3, 4, 1], 1, false)], ctrl: Ctrl::Return(4, vec![6]) }), (G::from_u64(5), Block { ops: vec![Op::Call(314, vec![3, 4, 1], 1, false)], ctrl: Ctrl::Return(5, vec![6]) }), (G::from_u64(6), Block { ops: vec![Op::Call(315, vec![3, 4, 5, 1], 1, false)], ctrl: Ctrl::Return(6, vec![6]) }), (G::from_u64(8), Block { ops: vec![Op::Call(313, 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_314() -> Function { - Function { body: Block { ops: vec![Op::Call(313, 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(313, 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_315() -> Function { - Function { body: Block { ops: vec![Op::Call(313, 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(313, 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(313, 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_316() -> Function { - Function { body: Block { ops: vec![Op::Call(288, 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(313, vec![0, 2], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(317, 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(310, 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_317() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(318, 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(316, vec![4, 1, 2], 1, false), Op::Call(316, 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(316, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(316, 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(316, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(316, 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(319, 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(316, 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_318() -> 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(306, 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_319() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(316, vec![0, 3, 4], 1, false), Op::Call(316, vec![1, 3, 4], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 8), Op::Call(316, 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_320() -> Function { - Function { body: Block { ops: vec![Op::Call(775, 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(288, 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(293, vec![0, 2, 6], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(322, 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(310, 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_321() -> Function { - Function { body: Block { ops: vec![Op::Call(775, 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(768, vec![1, 4], 1, false), Op::Const(G::from_u64(0)), Op::Call(306, 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_322() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(321, 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(320, vec![4, 1, 2], 1, false), Op::Call(320, 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(320, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(320, 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(320, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 9), Op::Call(320, 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(323, 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(320, 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_323() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(320, vec![0, 3, 4], 1, false), Op::Call(320, vec![1, 3, 4], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 8), Op::Call(320, 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_324() -> 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(324, 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_325() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Call(324, vec![2, 1, 5], 3, false), Op::Call(775, vec![7], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Call(201, vec![2, 1], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(768, vec![7, 10], 1, false), Op::Call(316, vec![6, 11, 10], 1, false), Op::Call(326, vec![0, 12, 8, 3], 1, false)], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(320, vec![6, 7, 10], 1, false), Op::Call(326, vec![0, 11, 8, 3], 1, false)], ctrl: Ctrl::Return(2, vec![12]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 10, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_326() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(3), Block { ops: vec![Op::Call(128, vec![1], 2, false), Op::Call(765, vec![9, 2], 1, false), Op::Call(326, vec![0, 8, 10, 3], 1, false)], ctrl: Ctrl::Return(0, vec![11]) }), (G::from_u64(4), Block { ops: vec![Op::Call(325, vec![0, 2, 1, 3], 1, false)], ctrl: Ctrl::Return(1, vec![8]) }), (G::from_u64(2), Block { ops: vec![Op::Call(338, vec![0, 5, 6, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(316, vec![7, 6, 8], 1, false), Op::Call(326, vec![0, 9, 2, 3], 1, false)], ctrl: Ctrl::Return(3, vec![10]) }), (G::from_u64(8), Block { ops: vec![Op::Call(327, vec![0, 5, 6, 7, 2, 3], 1, false)], ctrl: Ctrl::Return(4, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(201, vec![1, 2], 1, false)], ctrl: Ctrl::Return(5, vec![8]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 6, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_327() -> Function { - Function { body: Block { ops: vec![Op::Call(359, vec![0, 3, 5], 1, false), Op::Call(179, vec![0, 6, 5], 1, false), Op::Call(128, vec![7], 2, false), Op::Load(4, 8)], ctrl: Ctrl::Match(10, [(G::from_u64(2), Block { ops: vec![Op::Call(328, vec![8], 1, false), Op::Load(12, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(6), Block { ops: vec![Op::Add(21, 2), Op::Call(768, vec![9, 27], 1, false), Op::Call(326, vec![0, 28, 4, 5], 1, false)], ctrl: Ctrl::Return(0, vec![29]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![27, 1, 2, 6]), Op::Call(201, vec![28, 4], 1, false)], ctrl: Ctrl::Return(1, vec![29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![14, 1, 2, 6]), Op::Call(201, vec![15, 4], 1, false)], ctrl: Ctrl::Return(2, vec![16]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 3, auxiliaries: 25, lookups: 9 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_328() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(2), Block { ops: vec![Op::Call(234, 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_329() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 1)], 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(359, vec![0, 4, 2], 1, false), Op::Const(G::from_u64(0)), Op::Call(329, vec![0, 5, 2], 1, false), Op::Store(vec![7, 6, 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_330() -> Function { - Function { body: Block { ops: vec![Op::Call(329, vec![0, 3, 4], 1, false), Op::Call(775, vec![5], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::U32LessThan(6, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![9, 9, 9, 9])], ctrl: Ctrl::Return(0, vec![9, 10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(768, vec![5, 9], 1, false), Op::Call(189, vec![0, 10], 2, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(777, vec![5, 13], 1, false), Op::Call(129, vec![12], 1, false), Op::Call(191, vec![15], 1, false), Op::Call(201, vec![16, 14], 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![13, 13, 13, 13])], ctrl: Ctrl::Return(2, vec![13, 14]) }))) }))) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1)), Op::U32LessThan(6, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![9, 9, 9, 9])], ctrl: Ctrl::Return(3, vec![9, 10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(768, vec![5, 9], 1, false), Op::Call(189, vec![0, 10], 2, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(777, vec![5, 13], 1, false), Op::Call(139, vec![12], 1, false), Op::Call(136, vec![15], 1, false), Op::Call(191, vec![16], 1, false), Op::Call(201, vec![17, 14], 1, false)], ctrl: Ctrl::Return(4, 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(5, vec![13, 14]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(210, vec![0, 1, 2, 5, 6], 2, false)], ctrl: Ctrl::Return(6, vec![7, 8]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 7, auxiliaries: 18, lookups: 16 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_331() -> Function { - Function { body: Block { ops: vec![Op::Call(329, vec![0, 1, 2], 1, false), Op::Load(3, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![3]) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![3]) }), (G::from_u64(0), Block { ops: vec![Op::Call(128, vec![8], 2, false), Op::Call(329, vec![0, 11, 2], 1, false), Op::Call(201, vec![10, 12], 1, false), Op::Call(359, vec![0, 5, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![15, 13, 9]), Op::Store(vec![15, 14, 16])], ctrl: Ctrl::Return(2, vec![17]) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 15, lookups: 10 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_332() -> Function { - Function { body: Block { ops: vec![Op::Call(479, vec![0, 1], 1, false)], ctrl: Ctrl::MatchContinue(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(0, vec![3, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 3), Op::Call(568, vec![4], 2, false)], ctrl: Ctrl::Yield(1, vec![5, 6]) })), 2, 3, 1, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![5, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(478, vec![0, 1], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![6, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(4, vec![3, 4]) }))) }))) })) }, layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 10, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_333() -> Function { - Function { body: Block { ops: vec![Op::Call(332, vec![0, 1], 2, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(330, vec![0, 1, 6, 3, 4], 2, false)], ctrl: Ctrl::Return(0, vec![7, 8]) }), (G::from_u64(2), Block { ops: vec![Op::Call(329, vec![0, 3, 4], 1, false), Op::Call(168, vec![0, 1, 6, 7, 4], 2, false)], ctrl: Ctrl::Return(1, vec![8, 9]) }), (G::from_u64(3), Block { ops: vec![Op::Call(165, vec![0, 6, 3, 4], 2, false)], ctrl: Ctrl::Return(2, vec![7, 8]) }), (G::from_u64(5), Block { ops: vec![Op::Call(453, vec![0, 1, 6, 2, 3, 4], 2, false)], ctrl: Ctrl::Return(3, vec![7, 8]) }), (G::from_u64(6), Block { ops: vec![Op::Call(199, vec![0, 6, 3, 4], 2, false)], ctrl: Ctrl::Return(4, 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(5, vec![7, 8]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 6, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_334() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(34)), Op::Call(480, vec![0, 1, 4], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(335, vec![0, 2, 3], 2, false)], ctrl: Ctrl::Return(0, vec![6, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(35)), Op::Call(480, vec![0, 1, 6], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(336, vec![0, 2, 3], 2, false)], ctrl: Ctrl::Return(1, 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::Return(2, vec![8, 9]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_335() -> Function { - Function { body: Block { ops: vec![Op::Call(775, vec![1], 1, false), Op::Const(G::from_u64(6)), 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(3)), Op::Call(768, vec![1, 6], 1, false), Op::Const(G::from_u64(5)), Op::Call(768, vec![1, 8], 1, false), Op::Call(337, vec![0, 9, 2], 2, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Call(777, vec![1, 12], 1, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::Store(vec![15, 7, 11, 16]), Op::Call(201, vec![17, 13], 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![12, 12, 12, 12])], ctrl: Ctrl::Return(2, vec![12, 13]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 16, lookups: 14 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_336() -> Function { - Function { body: Block { ops: vec![Op::Call(775, vec![1], 1, false), Op::Const(G::from_u64(5)), 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(3)), Op::Call(768, vec![1, 6], 1, false), Op::Const(G::from_u64(4)), Op::Call(768, vec![1, 8], 1, false), Op::Call(337, vec![0, 9, 2], 2, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Call(777, vec![1, 12], 1, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(0)), Op::Store(vec![15, 7, 11, 16]), Op::Call(201, vec![17, 13], 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![12, 12, 12, 12])], ctrl: Ctrl::Return(2, vec![12, 13]) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 16, lookups: 14 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_337() -> Function { - Function { body: Block { ops: vec![Op::Call(359, vec![0, 1, 2], 1, false), Op::Call(128, vec![3], 2, false), Op::Load(4, 4)], ctrl: Ctrl::Match(6, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(33)), Op::Call(480, vec![0, 7, 10], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(775, vec![5], 1, false), Op::Const(G::from_u64(3)), Op::Sub(12, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Call(768, vec![5, 16], 1, false)], ctrl: Ctrl::Return(0, vec![15, 17]) })].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(1, vec![15, 16]) }))) })].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(2, vec![12, 13]) }))) })].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: 3, selectors: 4, auxiliaries: 12, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_338() -> Function { - Function { body: Block { ops: vec![Op::Call(333, vec![0, 1, 2, 4, 5], 2, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(359, vec![0, 7, 5], 1, false)], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(234, vec![1], 1, false), Op::Load(12, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Call(339, vec![12, 4], 2, false)], ctrl: Ctrl::Match(21, [(G::from_u64(1), Block { ops: vec![Op::Call(359, vec![0, 22, 5], 1, false)], ctrl: Ctrl::Return(2, vec![23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(283, vec![12, 2], 1, false), Op::Call(326, vec![0, 23, 4, 5], 1, false)], ctrl: Ctrl::Return(3, vec![24]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Call(201, vec![3, 4], 1, false)], ctrl: Ctrl::Return(4, vec![21]) }), (G::from_u64(4), Block { ops: vec![Op::Call(334, vec![0, 1, 4, 5], 2, false)], ctrl: Ctrl::Match(21, [(G::from_u64(1), Block { ops: vec![Op::Call(359, vec![0, 22, 5], 1, false)], ctrl: Ctrl::Return(5, vec![23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(201, vec![3, 4], 1, false)], ctrl: Ctrl::Return(6, 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(350, vec![11, 23], 2, false), Op::Call(342, vec![0, 2, 4, 12, 14, 15, 13, 16, 25, 5], 2, false)], ctrl: Ctrl::Yield(7, vec![26, 27]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(8, vec![24, 3]) })), 2, 4, 2, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(24, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(9, vec![25]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(613, vec![11, 12, 14, 15, 13], 1, false), Op::Call(346, vec![0, 2, 4, 12, 14, 15, 13, 16, 5, 3, 26], 2, false)], ctrl: Ctrl::Match(27, [(G::from_u64(1), Block { ops: vec![Op::Call(359, vec![0, 28, 5], 1, false)], ctrl: Ctrl::Return(10, vec![29]) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(11, vec![28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(349, vec![0, 11, 2, 4, 12, 14, 15, 13, 16, 5], 2, false)], ctrl: Ctrl::Match(29, [(G::from_u64(1), Block { ops: vec![Op::Call(359, vec![0, 30, 5], 1, false)], ctrl: Ctrl::Return(12, vec![31]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(13, vec![28]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(201, vec![3, 4], 1, false)], ctrl: Ctrl::Return(14, vec![29]) }))) }))) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(201, vec![3, 4], 1, false)], ctrl: Ctrl::Return(15, vec![21]) }))) }))) }, layout: FunctionLayout { input_size: 6, selectors: 16, auxiliaries: 32, lookups: 10 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_339() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(340, vec![0, 2], 5, false)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![Op::Call(775, 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(768, vec![1, 7], 1, false), Op::Const(G::from_u64(8)), Op::Store(vec![11, 5, 6, 10]), Op::Call(777, vec![1, 4], 1, false), Op::Const(G::from_u64(1)), Op::Call(201, 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_340() -> 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(340, 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_341() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(147, vec![4], 1, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Call(481, vec![0, 8], 1, false), Op::Store(vec![8, 8, 8]), Op::Const(G::from_u64(0)), Op::Store(vec![7, 9, 10, 11])], ctrl: Ctrl::Return(0, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(139, vec![4], 1, false), Op::Call(136, vec![7], 1, false), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(0)), Op::Store(vec![9, 10, 8, 10]), Op::Const(G::from_u64(2)), Op::Call(481, vec![0, 12], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![14, 14, 14]), Op::Store(vec![12, 13, 15, 10]), Op::Const(G::from_u64(3)), Op::Store(vec![17, 16, 11, 10])], ctrl: Ctrl::Return(1, vec![18]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![1]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![1]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 14, lookups: 10 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_342() -> Function { - Function { body: Block { ops: vec![Op::Load(5, 7)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(11, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Add(3, 4), Op::Add(15, 5), Op::Add(16, 6), Op::Call(775, vec![2], 1, false), Op::Call(0, vec![17, 18], 1, false)], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![20, 20, 20, 20])], ctrl: Ctrl::Return(0, vec![20, 21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(768, vec![2, 17], 1, false), Op::Call(343, vec![0, 20, 11, 3, 8, 9], 1, false)], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![22, 22, 22, 22])], ctrl: Ctrl::Return(1, vec![22, 23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(283, vec![13, 1], 1, false), Op::Add(3, 4), Op::Add(23, 5), Op::Call(776, vec![2, 24], 1, false), Op::Const(G::from_u64(1)), Op::Add(17, 26), Op::Call(777, vec![2, 27], 1, false), Op::Call(201, vec![22, 25], 1, false), Op::Call(201, vec![29, 28], 1, false), Op::Call(359, vec![0, 30, 9], 1, false)], ctrl: Ctrl::Return(2, vec![26, 31]) }))) }))) }))) })].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(3, vec![15, 16]) }))) }, layout: FunctionLayout { input_size: 10, selectors: 4, auxiliaries: 18, lookups: 12 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_343() -> Function { - Function { body: Block { ops: vec![Op::Call(429, vec![0, 1, 5], 1, false), Op::Call(359, vec![0, 6, 5], 1, false), Op::Call(128, vec![7], 2, false), Op::Load(4, 8)], ctrl: Ctrl::Match(10, [(G::from_u64(2), Block { ops: vec![Op::Call(2, vec![11, 4], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(234, vec![11], 1, false), Op::Load(12, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(5), Block { ops: vec![Op::Call(662, vec![24, 2, 23], 1, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![29, 28, 12, 30]), Op::Call(776, vec![9, 3], 1, false), Op::Call(201, vec![31, 32], 1, false), Op::Call(429, vec![0, 33, 5], 1, false), Op::Call(380, vec![0, 7, 34, 5], 1, false)], ctrl: Ctrl::Return(1, vec![35]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![28]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![14]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 4, auxiliaries: 30, lookups: 14 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_344() -> Function { - Function { body: Block { ops: vec![Op::Call(776, vec![0, 1], 1, false), Op::Const(G::from_u64(1)), Op::Add(1, 4), Op::Call(777, 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(765, vec![3, 9], 1, false), Op::Call(765, 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_345() -> Function { - Function { body: Block { ops: vec![Op::Call(359, vec![0, 1, 2], 1, false), Op::Call(128, vec![3], 2, false), Op::Load(4, 4)], ctrl: Ctrl::Match(6, [(G::from_u64(2), Block { ops: vec![Op::Call(234, vec![7], 1, false), Op::Load(12, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(2), Block { ops: vec![Op::Call(283, vec![14, 8], 1, false), Op::Call(326, vec![0, 23, 5, 2], 1, false), Op::Call(345, vec![0, 24, 2], 1, false)], ctrl: Ctrl::Return(0, vec![25]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![3]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![3]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 24, lookups: 9 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_346() -> Function { - Function { body: Block { ops: vec![Op::Add(3, 4), Op::Add(11, 5), Op::Add(12, 6), Op::Call(775, vec![2], 1, false), Op::U32LessThan(13, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![16, 16, 16, 16])], ctrl: Ctrl::Return(0, vec![16, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(208, vec![0, 2, 3, 4, 5, 13], 2, false)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![18, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(768, vec![2, 13], 1, false), Op::Call(205, vec![0, 18], 1, false), Op::Call(345, vec![0, 19, 8], 1, false), Op::Call(205, vec![0, 20], 1, false), Op::Call(341, vec![0, 21], 1, false), Op::Call(347, vec![22], 4, false)], ctrl: Ctrl::Match(23, [(G::from_u64(1), Block { ops: vec![Op::Call(2, vec![25, 10], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![27], vec![28], Some("iota: major's constructor belongs to a different inductive".into())), Op::Call(348, vec![7, 24], 3, false)], ctrl: Ctrl::Match(29, [(G::from_u64(0), Block { ops: vec![Op::Call(344, vec![2, 13, 20], 1, false), Op::Const(G::from_u64(2)), Op::Call(201, vec![9, 32], 1, false)], ctrl: Ctrl::Return(2, vec![33, 34]) }), (G::from_u64(1), Block { ops: vec![Op::Call(283, vec![31, 1], 1, false), Op::Add(3, 4), Op::Add(33, 5), Op::Call(776, vec![2, 34], 1, false), Op::Call(775, vec![26], 1, false), Op::Sub(36, 30), Op::Call(777, vec![26, 37], 1, false), Op::Const(G::from_u64(1)), Op::Add(13, 39), Op::Call(777, vec![2, 40], 1, false), Op::Call(201, vec![32, 35], 1, false), Op::Call(201, vec![42, 38], 1, false), Op::Call(201, vec![43, 41], 1, false)], ctrl: Ctrl::Return(3, vec![39, 44]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(344, vec![2, 13, 20], 1, false), Op::Const(G::from_u64(2)), Op::Call(201, vec![9, 27], 1, false)], ctrl: Ctrl::Return(4, vec![28, 29]) }))) }))) }))) }, layout: FunctionLayout { input_size: 11, selectors: 5, auxiliaries: 33, lookups: 25 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_347() -> Function { - Function { body: Block { ops: vec![Op::Call(128, vec![0], 2, false), Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(2), Block { ops: vec![Op::Call(234, 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(405, 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_348() -> 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(348, 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_349() -> Function { - Function { body: Block { ops: vec![Op::Load(5, 8)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![15, 15, 15, 15])], ctrl: Ctrl::Return(0, vec![15, 16]) }), (G::from_u64(0), Block { ops: vec![Op::Load(5, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![20, 20, 20, 20])], ctrl: Ctrl::Return(1, vec![20, 21]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(11, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Add(4, 5), Op::Add(20, 6), Op::Add(21, 7), Op::Call(350, vec![1, 22], 2, false)], ctrl: Ctrl::Match(23, [(G::from_u64(0), 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::Call(234, vec![24], 1, false), Op::Load(12, 25)], ctrl: Ctrl::Match(26, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(31, 38)], ctrl: Ctrl::Match(39, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(30, [(G::from_u64(0), Block { ops: vec![Op::Call(352, vec![24], 1, false)], ctrl: Ctrl::Match(40, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![41, 41, 41, 41])], ctrl: Ctrl::Return(3, vec![41, 42]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(768, vec![3, 22], 1, false), Op::Call(775, vec![9], 1, false), Op::Call(288, vec![41], 1, false), Op::Call(0, vec![42, 43], 1, false)], ctrl: Ctrl::Match(44, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![45, 45, 45, 45])], ctrl: Ctrl::Return(4, vec![45, 46]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(429, vec![0, 41, 9], 1, false), Op::Call(411, vec![0, 45, 9], 1, false)], ctrl: Ctrl::Match(46, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![47, 47, 47, 47])], ctrl: Ctrl::Return(5, vec![47, 48]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(283, vec![13, 2], 1, false), Op::Add(4, 5), Op::Add(48, 6), Op::Call(776, vec![3, 49], 1, false), Op::Call(201, vec![47, 50], 1, false), Op::Const(G::from_u64(0)), Op::Call(351, vec![51, 24, 41, 12, 52], 1, false), Op::Const(G::from_u64(1)), Op::Add(22, 54), Op::Call(777, vec![3, 55], 1, false), Op::Call(201, vec![53, 56], 1, false)], ctrl: Ctrl::Return(6, vec![54, 57]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![40, 40, 40, 40])], ctrl: Ctrl::Return(7, vec![40, 41]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![40, 40, 40, 40])], ctrl: Ctrl::Return(8, vec![40, 41]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![38, 38, 38, 38])], ctrl: Ctrl::Return(9, vec![38, 39]) }))) }))) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 10, selectors: 10, auxiliaries: 43, lookups: 19 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_350() -> 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(128, 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(350, 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_351() -> 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(351, 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_352() -> Function { - Function { body: Block { ops: vec![Op::Call(234, vec![0], 1, false), Op::Load(12, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Call(353, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Call(354, 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_353() -> Function { - Function { body: Block { ops: vec![Op::Call(228, 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(242, 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_354() -> 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(237, vec![0, 1, 5], 1, false), Op::Load(12, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(6), Block { ops: vec![Op::Call(355, vec![10, 3], 1, false), Op::Call(356, 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(354, 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_355() -> 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(355, 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_356() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(5), Block { ops: vec![Op::Call(357, 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(356, 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_357() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(2), Block { ops: vec![Op::Call(358, vec![3, 1], 1, false)], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(3), Block { ops: vec![Op::Call(357, 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(357, vec![4, 1], 1, false)], ctrl: Ctrl::Return(2, vec![7]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Call(357, 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(357, vec![4, 1], 1, false)], ctrl: Ctrl::Return(4, vec![7]) }))) }), (G::from_u64(5), Block { ops: vec![Op::Call(357, 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(357, vec![4, 1], 1, false)], ctrl: Ctrl::Return(6, vec![7]) }))) }), (G::from_u64(6), Block { ops: vec![Op::Call(357, 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(357, 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(357, vec![5, 1], 1, false)], ctrl: Ctrl::Return(9, vec![8]) }))) }))) }), (G::from_u64(8), Block { ops: vec![Op::Call(357, 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_358() -> 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(358, 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_359() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(288, vec![1], 1, false), Op::Call(301, vec![2, 7], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Call(326, vec![0, 1, 10, 8], 1, false)], ctrl: Ctrl::Return(5, vec![11]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 14, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_360() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Call(326, vec![0, 1, 4, 2], 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_361() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Call(288, vec![1], 1, false), Op::Call(301, vec![2, 9], 1, false), Op::Call(362, vec![0, 1, 8, 10], 1, false)], ctrl: Ctrl::Return(5, vec![11]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 14, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_362() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(3), Block { ops: vec![Op::Call(128, vec![1], 2, false), Op::Call(765, vec![9, 2], 1, false), Op::Call(362, vec![0, 8, 10, 3], 1, false)], ctrl: Ctrl::Return(0, vec![11]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Call(324, vec![1, 2, 9], 3, false), Op::Call(775, vec![11], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Call(201, vec![1, 2], 1, false)], ctrl: Ctrl::Return(1, vec![14]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(768, vec![11, 14], 1, false), Op::Call(316, vec![10, 15, 14], 1, false), Op::Call(362, vec![0, 16, 12, 3], 1, false)], ctrl: Ctrl::Return(2, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(320, vec![10, 11, 14], 1, false), Op::Call(362, vec![0, 15, 12, 3], 1, false)], ctrl: Ctrl::Return(3, vec![16]) }))) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(316, vec![7, 6, 8], 1, false), Op::Call(362, vec![0, 9, 2, 3], 1, false)], ctrl: Ctrl::Return(4, vec![10]) }), (G::from_u64(8), Block { ops: vec![Op::Call(363, vec![0, 5, 6, 7, 2, 3, 1], 1, false)], ctrl: Ctrl::Return(5, vec![8]) }), (G::from_u64(2), Block { ops: vec![Op::Call(364, vec![0, 5, 6, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(6, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(201, vec![1, 2], 1, false)], ctrl: Ctrl::Return(7, vec![8]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 8, auxiliaries: 14, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_363() -> Function { - Function { body: Block { ops: vec![Op::Call(361, vec![0, 3, 5], 1, false), Op::Call(128, vec![7], 2, false), Op::Load(4, 8)], ctrl: Ctrl::Match(10, [(G::from_u64(2), Block { ops: vec![Op::Call(328, vec![8], 1, false), Op::Load(12, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(6), Block { ops: vec![Op::Add(21, 2), Op::Call(768, vec![9, 27], 1, false), Op::Call(362, vec![0, 28, 4, 5], 1, false)], ctrl: Ctrl::Return(0, vec![29]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(201, vec![6, 4], 1, false)], ctrl: Ctrl::Return(1, vec![27]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(201, vec![6, 4], 1, false)], ctrl: Ctrl::Return(2, vec![14]) }))) }, layout: FunctionLayout { input_size: 7, selectors: 3, auxiliaries: 23, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_364() -> Function { - Function { body: Block { ops: vec![Op::Call(234, vec![1], 1, false), Op::Load(12, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(7), Block { ops: vec![Op::Call(613, vec![9, 10, 12, 13, 11], 1, false), Op::Call(346, vec![0, 2, 4, 10, 12, 13, 11, 14, 5, 3, 19], 2, false)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Call(361, vec![0, 21, 5], 1, false)], ctrl: Ctrl::Return(0, vec![22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(201, vec![3, 4], 1, false)], ctrl: Ctrl::Return(1, vec![22]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(201, vec![3, 4], 1, false)], ctrl: Ctrl::Return(2, vec![19]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 3, auxiliaries: 19, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_365() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(4, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(288, vec![1], 1, false), Op::Call(301, vec![2, 7], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Call(367, vec![0, 1, 10, 8], 1, false)], ctrl: Ctrl::Return(5, vec![11]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 14, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_366() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Call(367, vec![0, 1, 4, 2], 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_367() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(3), Block { ops: vec![Op::Call(128, vec![1], 2, false), Op::Call(765, vec![9, 2], 1, false), Op::Call(367, vec![0, 8, 10, 3], 1, false)], ctrl: Ctrl::Return(0, vec![11]) }), (G::from_u64(4), Block { ops: vec![Op::Call(368, vec![0, 2, 1, 3], 1, false)], ctrl: Ctrl::Return(1, vec![8]) }), (G::from_u64(2), Block { ops: vec![Op::Call(370, vec![0, 5, 6, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(2, vec![8]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(316, vec![7, 6, 8], 1, false), Op::Call(367, vec![0, 9, 2, 3], 1, false)], ctrl: Ctrl::Return(3, vec![10]) }), (G::from_u64(8), Block { ops: vec![Op::Call(369, vec![0, 5, 6, 7, 2, 3], 1, false)], ctrl: Ctrl::Return(4, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(201, vec![1, 2], 1, false)], ctrl: Ctrl::Return(5, vec![8]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 6, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_368() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Call(324, vec![2, 1, 5], 3, false), Op::Call(775, vec![7], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Call(201, vec![2, 1], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(768, vec![7, 10], 1, false), Op::Call(316, vec![6, 11, 10], 1, false), Op::Call(367, vec![0, 12, 8, 3], 1, false)], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(320, vec![6, 7, 10], 1, false), Op::Call(367, vec![0, 11, 8, 3], 1, false)], ctrl: Ctrl::Return(2, vec![12]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 10, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_369() -> Function { - Function { body: Block { ops: vec![Op::Call(365, vec![0, 3, 5], 1, false), Op::Call(179, vec![0, 6, 5], 1, false), Op::Call(128, vec![7], 2, false), Op::Load(4, 8)], ctrl: Ctrl::Match(10, [(G::from_u64(2), Block { ops: vec![Op::Call(328, vec![8], 1, false), Op::Load(12, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(6), Block { ops: vec![Op::Add(21, 2), Op::Call(768, vec![9, 27], 1, false), Op::Call(367, vec![0, 28, 4, 5], 1, false)], ctrl: Ctrl::Return(0, vec![29]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![27, 1, 2, 6]), Op::Call(201, vec![28, 4], 1, false)], ctrl: Ctrl::Return(1, vec![29]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![14, 1, 2, 6]), Op::Call(201, vec![15, 4], 1, false)], ctrl: Ctrl::Return(2, vec![16]) }))) }, layout: FunctionLayout { input_size: 6, selectors: 3, auxiliaries: 25, lookups: 9 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_370() -> Function { - Function { body: Block { ops: vec![Op::Call(332, vec![0, 1], 2, false)], ctrl: Ctrl::MatchContinue(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8, 8])], ctrl: Ctrl::Yield(0, vec![8, 9]) }), (G::from_u64(1), Block { ops: vec![Op::Call(201, vec![3, 4], 1, false), Op::Call(288, vec![8], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Call(333, vec![0, 1, 2, 4, 5], 2, false)], ctrl: Ctrl::Yield(1, 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::Yield(2, vec![10, 11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(333, vec![0, 1, 2, 4, 5], 2, false)], ctrl: Ctrl::Yield(3, vec![8, 9]) })), 2, 4, 3, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(365, vec![0, 9, 5], 1, false)], ctrl: Ctrl::Return(4, vec![10]) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Return(5, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(234, vec![1], 1, false), Op::Load(12, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(339, vec![14, 4], 2, false)], ctrl: Ctrl::Match(23, [(G::from_u64(1), Block { ops: vec![Op::Call(365, vec![0, 24, 5], 1, false)], ctrl: Ctrl::Return(6, vec![25]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(201, vec![3, 4], 1, false)], ctrl: Ctrl::Return(7, vec![25]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Call(334, vec![0, 1, 4, 5], 2, false)], ctrl: Ctrl::Match(23, [(G::from_u64(1), Block { ops: vec![Op::Call(365, vec![0, 24, 5], 1, false)], ctrl: Ctrl::Return(8, vec![25]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(201, vec![3, 4], 1, false)], ctrl: Ctrl::Return(9, vec![25]) }))) }), (G::from_u64(7), Block { ops: vec![Op::Add(14, 16), Op::Add(23, 17), Op::Add(24, 15)], ctrl: Ctrl::MatchContinue(19, [(G::from_u64(1), Block { ops: vec![Op::Call(350, vec![13, 25], 2, false), Op::Call(342, vec![0, 2, 4, 14, 16, 17, 15, 18, 27, 5], 2, false)], ctrl: Ctrl::Yield(10, vec![28, 29]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(11, vec![26, 3]) })), 2, 4, 2, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(26, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(12, vec![27]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(613, vec![13, 14, 16, 17, 15], 1, false), Op::Call(346, vec![0, 2, 4, 14, 16, 17, 15, 18, 5, 3, 28], 2, false)], ctrl: Ctrl::Match(29, [(G::from_u64(1), Block { ops: vec![Op::Call(365, vec![0, 30, 5], 1, false)], ctrl: Ctrl::Return(13, vec![31]) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(19, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(14, vec![30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(349, vec![0, 13, 2, 4, 14, 16, 17, 15, 18, 5], 2, false)], ctrl: Ctrl::Match(31, [(G::from_u64(1), Block { ops: vec![Op::Call(365, vec![0, 32, 5], 1, false)], ctrl: Ctrl::Return(15, vec![33]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(16, vec![30]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(201, vec![3, 4], 1, false)], ctrl: Ctrl::Return(17, vec![31]) }))) }))) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(201, vec![3, 4], 1, false)], ctrl: Ctrl::Return(18, vec![23]) }))) }))) })) }, layout: FunctionLayout { input_size: 6, selectors: 19, auxiliaries: 38, lookups: 13 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_371() -> Function { - Function { body: Block { ops: vec![Op::Call(768, vec![0, 1], 1, false), Op::Const(G::from_u64(1)), Op::Add(1, 3), Op::Const(G::from_u64(0)), Op::Call(306, 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_372() -> 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_373() -> 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_374() -> Function { - Function { body: Block { ops: vec![Op::Call(288, vec![1], 1, false), Op::Call(301, vec![2, 3], 1, false), Op::Load(4, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(768, vec![4, 6], 1, false), Op::Const(G::from_u64(1)), Op::Add(6, 10), Op::Const(G::from_u64(0)), Op::Call(306, vec![9, 11, 12], 1, false)], ctrl: Ctrl::Return(0, vec![13]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![9, 6, 10]), Op::Call(280, vec![11], 1, false), Op::Store(vec![9, 12, 10, 10])], ctrl: Ctrl::Return(1, vec![13]) }), (G::from_u64(2), Block { ops: vec![Op::Call(234, vec![6], 1, false), Op::Load(12, 9), Op::Call(372, vec![10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21], 1, false), Op::Call(775, vec![7], 1, false), Op::AssertEq(vec![23], vec![22], Some("Const applied to wrong number of universe levels".into())), Op::Call(373, vec![10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21], 1, false), Op::Call(283, vec![24, 7], 1, false)], ctrl: Ctrl::Return(2, vec![25]) }), (G::from_u64(3), Block { ops: vec![Op::Call(374, vec![0, 6, 4], 1, false), Op::Load(4, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(316, vec![12, 7, 14], 1, false)], ctrl: Ctrl::Return(3, vec![15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(359, vec![0, 9, 4], 1, false), Op::Load(4, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(316, vec![17, 7, 19], 1, false)], ctrl: Ctrl::Return(4, vec![20]) })].into_iter().collect(), None) }))) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![9, 6, 4]), Op::Call(374, vec![0, 7, 10], 1, false), Op::Const(G::from_u64(5)), Op::Store(vec![12, 6, 11, 9])], ctrl: Ctrl::Return(5, vec![13]) }), (G::from_u64(5), Block { ops: vec![Op::Call(376, vec![0, 6, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 6, 4]), Op::Call(376, vec![0, 7, 11], 1, false), Op::Const(G::from_u64(1)), Op::Call(279, vec![9, 12], 1, false), Op::Store(vec![13, 14, 10, 10])], ctrl: Ctrl::Return(6, vec![15]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(316, vec![8, 7, 9], 1, false), Op::Call(374, vec![0, 10, 4], 1, false)], ctrl: Ctrl::Return(7, vec![11]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(481, vec![0, 10], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12]), Op::Store(vec![9, 11, 13, 10])], ctrl: Ctrl::Return(8, vec![14]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(37)), Op::Call(482, vec![0, 10], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12]), Op::Const(G::from_u64(0)), Op::Store(vec![9, 11, 13, 14])], ctrl: Ctrl::Return(9, vec![15]) })].into_iter().collect(), None) }), (G::from_u64(8), Block { ops: vec![Op::Call(374, vec![0, 8, 4], 1, false), Op::Call(359, vec![0, 9, 4], 1, false), Op::Call(128, vec![10], 2, false), Op::Load(4, 11)], ctrl: Ctrl::Match(13, [(G::from_u64(2), Block { ops: vec![Op::AssertEq(vec![14], vec![6], Some("projection's structure type differs from the value's head".into())), Op::Call(234, vec![14], 1, false), Op::Load(12, 17)], ctrl: Ctrl::Match(18, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::AssertEq(vec![23], vec![30], Some("projection on an inductive with more than one constructor".into())), Op::Const(G::from_u64(0)), Op::Call(237, vec![25, 26, 31], 1, false), Op::Load(12, 32)], ctrl: Ctrl::Match(33, [(G::from_u64(6), Block { ops: vec![Op::Call(283, vec![35, 15], 1, false), Op::Call(377, vec![45, 12, 21], 1, false), Op::Const(G::from_u64(0)), Op::Call(378, vec![46, 7, 47, 6, 8], 1, false)], ctrl: Ctrl::Return(10, vec![48]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 11, auxiliaries: 44, lookups: 15 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_375() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(768, vec![2, 4], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 8), Op::Const(G::from_u64(0)), Op::Call(306, vec![7, 9, 10], 1, false)], ctrl: Ctrl::Return(0, vec![11]) }), (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]), Op::Call(280, vec![9], 1, false), Op::Store(vec![7, 10, 8, 8])], ctrl: Ctrl::Return(1, vec![11]) }), (G::from_u64(2), Block { ops: vec![Op::Call(234, vec![4], 1, false), Op::Load(12, 7), Op::Call(372, vec![8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], 1, false), Op::Call(775, vec![5], 1, false), Op::AssertEq(vec![21], vec![20], Some("Const applied to wrong number of universe levels".into())), Op::Call(373, vec![8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], 1, false), Op::Call(283, vec![22, 5], 1, false)], ctrl: Ctrl::Return(2, vec![23]) }), (G::from_u64(3), Block { ops: vec![Op::Call(374, vec![0, 4, 2], 1, false), Op::Load(4, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(316, vec![10, 5, 12], 1, false)], ctrl: Ctrl::Return(3, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(359, vec![0, 7, 2], 1, false), Op::Load(4, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(316, vec![15, 5, 17], 1, false)], ctrl: Ctrl::Return(4, vec![18]) })].into_iter().collect(), None) }))) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 2]), Op::Call(374, vec![0, 5, 8], 1, false), Op::Const(G::from_u64(5)), Op::Store(vec![10, 4, 9, 7])], ctrl: Ctrl::Return(5, vec![11]) }), (G::from_u64(5), Block { ops: vec![Op::Call(376, vec![0, 4, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 4, 2]), Op::Call(376, vec![0, 5, 9], 1, false), Op::Const(G::from_u64(1)), Op::Call(279, vec![7, 10], 1, false), Op::Store(vec![11, 12, 8, 8])], ctrl: Ctrl::Return(6, vec![13]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(316, vec![6, 5, 7], 1, false), Op::Call(374, vec![0, 8, 2], 1, false)], ctrl: Ctrl::Return(7, vec![9]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(481, vec![0, 8], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10]), Op::Store(vec![7, 9, 11, 8])], ctrl: Ctrl::Return(8, vec![12]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(37)), Op::Call(482, vec![0, 8], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10]), Op::Const(G::from_u64(0)), Op::Store(vec![7, 9, 11, 12])], ctrl: Ctrl::Return(9, vec![13]) })].into_iter().collect(), None) }), (G::from_u64(8), Block { ops: vec![Op::Call(374, vec![0, 6, 2], 1, false), Op::Call(359, vec![0, 7, 2], 1, false), Op::Call(128, vec![8], 2, false), Op::Load(4, 9)], ctrl: Ctrl::Match(11, [(G::from_u64(2), Block { ops: vec![Op::AssertEq(vec![12], vec![4], Some("projection's structure type differs from the value's head".into())), Op::Call(234, vec![12], 1, false), Op::Load(12, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::AssertEq(vec![21], vec![28], Some("projection on an inductive with more than one constructor".into())), Op::Const(G::from_u64(0)), Op::Call(237, vec![23, 24, 29], 1, false), Op::Load(12, 30)], ctrl: Ctrl::Match(31, [(G::from_u64(6), Block { ops: vec![Op::Call(283, vec![33, 13], 1, false), Op::Call(377, vec![43, 10, 19], 1, false), Op::Const(G::from_u64(0)), Op::Call(378, vec![44, 5, 45, 4, 6], 1, false)], ctrl: Ctrl::Return(10, vec![46]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 11, auxiliaries: 42, lookups: 13 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_376() -> Function { - Function { body: Block { ops: vec![Op::Call(374, vec![0, 1, 2], 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(), Some(Box::new(Block { ops: vec![Op::Call(359, vec![0, 3, 2], 1, false), Op::Load(4, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 12, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_377() -> 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(316, vec![5, 8, 10], 1, false), Op::Const(G::from_u64(1)), Op::Sub(2, 12), Op::Call(377, 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_378() -> 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(316, vec![7, 11, 12], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 14), Op::Call(378, 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_379() -> 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(271, 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(379, 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_380() -> Function { - Function { body: Block { ops: vec![Op::Sub(1, 2)], ctrl: Ctrl::Match(4, [(G::from_u64(0), 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(288, vec![1], 1, false), Op::Call(288, vec![2], 1, false), Op::Call(290, vec![5, 6], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Call(382, vec![0, 1, 2, 9], 1, false)], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(381, vec![0, 1, 2, 3, 7], 1, false)], ctrl: Ctrl::Return(2, vec![8]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 7, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_381() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(302, vec![1, 5], 1, false), Op::Call(302, vec![2, 5], 1, false), Op::Call(292, vec![6, 7], 1, false), Op::Call(775, vec![3], 1, false), Op::Call(292, vec![8, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Call(301, vec![3, 4], 1, false), Op::Call(382, vec![0, 1, 2, 11], 1, false)], ctrl: Ctrl::Return(0, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(310, vec![1, 10, 11], 1, false), Op::Call(310, vec![2, 10, 11], 1, false), Op::Call(777, vec![3, 10], 1, false), Op::Sub(4, 10), Op::Call(301, vec![14, 15], 1, false), Op::Call(382, vec![0, 12, 13, 16], 1, false)], ctrl: Ctrl::Return(1, vec![17]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 12, lookups: 11 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_382() -> Function { - Function { body: Block { ops: vec![Op::U32LessThan(1, 2)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(383, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(383, vec![0, 2, 1, 3], 1, false)], ctrl: Ctrl::Return(1, vec![5]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 9, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_383() -> Function { - Function { body: Block { ops: vec![Op::Call(384, vec![0, 1, 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]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(391, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(1, vec![5]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_384() -> Function { - Function { body: Block { ops: vec![Op::Call(128, vec![1], 2, false), Op::Call(128, vec![2], 2, false), Op::Load(4, 4)], ctrl: Ctrl::Match(8, [(G::from_u64(2), Block { ops: vec![Op::Load(4, 6)], ctrl: Ctrl::Match(12, [(G::from_u64(2), Block { ops: vec![Op::Sub(9, 13)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Call(379, vec![10, 14], 1, false)], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(775, vec![5], 1, false), Op::Call(775, vec![7], 1, false), Op::Sub(18, 19)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Call(385, vec![0, 5, 7, 3], 1, false)], ctrl: Ctrl::Return(1, vec![21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![21]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![17]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![16]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![12]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 6, auxiliaries: 18, lookups: 9 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_385() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Load(3, 2)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], 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![10]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(3, 2)], 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::Call(380, vec![0, 5, 8, 3], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(385, vec![0, 6, 9, 3], 1, false)], ctrl: Ctrl::Return(4, vec![11]) }))) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 10, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_386() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(147, vec![4], 1, false)], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![6]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(480, vec![0, 3, 6], 1, false)], 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![6]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 7, lookups: 3 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_387() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(2, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6, 6, 6, 6, 6, 6, 6, 6]), Op::Call(191, vec![7], 1, false)], ctrl: Ctrl::Return(0, vec![6, 8, 4]) })].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(1, vec![6, 1, 8]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(6, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(480, vec![0, 7, 10], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(387, vec![0, 4], 3, false), Op::Const(G::from_u64(1)), Op::Call(129, vec![14], 1, false)], ctrl: Ctrl::Return(2, vec![15, 13, 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![13, 13, 13, 13, 13, 13, 13, 13, 13, 13])], ctrl: Ctrl::Return(3, vec![12, 1, 14]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Load(4, 7)], ctrl: Ctrl::Match(10, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(42)), Op::Call(480, vec![0, 11, 14], 1, false)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(16, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(17, [(G::from_u64(0), Block { ops: vec![Op::Call(387, vec![0, 8], 3, false)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(131, vec![22, 18], 1, false)], ctrl: Ctrl::Return(4, vec![23, 21, 24]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![23, 8, 18]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![21, 21, 21, 21, 21, 21, 21, 21, 21, 21])], ctrl: Ctrl::Return(6, vec![20, 1, 22]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![21, 21, 21, 21, 21, 21, 21, 21, 21, 21])], ctrl: Ctrl::Return(7, vec![20, 1, 22]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![17, 17, 17, 17, 17, 17, 17, 17, 17, 17])], ctrl: Ctrl::Return(8, vec![16, 1, 18]) }))) })].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, 15, 15, 15, 15, 15, 15, 15])], ctrl: Ctrl::Return(9, vec![14, 1, 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![11, 11, 11, 11, 11, 11, 11, 11, 11, 11])], ctrl: Ctrl::Return(10, vec![10, 1, 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![7, 7, 7, 7, 7, 7, 7, 7, 7, 7])], ctrl: Ctrl::Return(11, vec![6, 1, 8]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 12, auxiliaries: 22, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_388() -> Function { - Function { body: Block { ops: vec![Op::Call(386, vec![0, 1], 1, false), Op::Call(386, vec![0, 2], 1, false), Op::Mul(4, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![7, 7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(387, vec![0, 1], 3, false), Op::Call(387, vec![0, 2], 3, false), Op::Mul(7, 10)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![14, 14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(285, vec![9, 12], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(0), 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(1)), Op::Call(380, vec![0, 8, 11, 3], 1, false)], ctrl: Ctrl::Return(3, vec![15, 16]) }))) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 16, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_389() -> Function { - Function { body: Block { ops: vec![Op::Call(390, vec![0, 1, 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]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(390, vec![0, 2, 1, 3], 1, false)], ctrl: Ctrl::Return(1, vec![5]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_390() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(176, vec![0, 6], 1, false), Op::Call(178, vec![0, 8, 3], 1, false), Op::Call(380, vec![0, 9, 2, 3], 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]) }))) })].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: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_391() -> Function { - Function { body: Block { ops: vec![Op::Call(390, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::MatchContinue(4, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(0, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(390, vec![0, 2, 1, 3], 1, false)], ctrl: Ctrl::Yield(1, vec![5]) })), 1, 2, 1, Box::new(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![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(392, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(3, vec![6]) }))) })) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_392() -> Function { - Function { body: Block { ops: vec![Op::Call(361, vec![0, 1, 3], 1, false), Op::Call(361, vec![0, 2, 3], 1, false), Op::Sub(4, 5)], 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::Call(394, vec![0, 4, 5, 3], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(384, vec![0, 4, 5, 3], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(393, vec![0, 1, 2, 4, 5, 3], 1, false)], ctrl: Ctrl::Return(3, vec![9]) }))) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_393() -> Function { - Function { body: Block { ops: vec![Op::Call(365, vec![0, 3, 5], 1, false), Op::Call(365, vec![0, 4, 5], 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(0, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(394, vec![0, 6, 7, 5], 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]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(384, vec![0, 6, 7, 5], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(395, vec![0, 1, 2, 6, 7, 5], 1, false)], ctrl: Ctrl::Return(3, vec![11]) }))) }))) }))) }, layout: FunctionLayout { input_size: 6, selectors: 4, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_394() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(271, vec![5, 9], 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]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(8, [(G::from_u64(4), Block { ops: vec![Op::Call(380, vec![0, 5, 9, 3], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![13, 5, 3]), Op::Call(380, vec![0, 6, 10, 14], 1, false)], ctrl: Ctrl::Return(2, vec![15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![13]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![12]) }))) }), (G::from_u64(5), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(8, [(G::from_u64(5), Block { ops: vec![Op::Call(380, vec![0, 5, 9, 3], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![13, 5, 3]), Op::Call(380, vec![0, 6, 10, 14], 1, false)], ctrl: Ctrl::Return(5, vec![15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![13]) }))) })].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![8]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 9, auxiliaries: 12, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_395() -> Function { - Function { body: Block { ops: vec![Op::Sub(3, 4)], 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::Call(409, vec![0, 3, 4, 5], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(407, vec![0, 3, 4, 5], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(403, vec![0, 3, 4, 5], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(403, vec![0, 4, 3, 5], 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(388, vec![0, 3, 4, 5], 2, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(5, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(16)), Op::Call(414, vec![0, 3, 4, 13, 5], 3, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(6, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(396, vec![0, 1, 2, 15, 16, 5], 1, false)], ctrl: Ctrl::Return(7, vec![17]) }))) }))) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 6, selectors: 8, auxiliaries: 18, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_396() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(400, vec![0, 3, 4, 6, 5], 2, false)], ctrl: Ctrl::Match(7, [(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::Call(398, vec![0, 3, 4, 5], 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]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(402, vec![0, 1, 2, 5], 1, false)], ctrl: Ctrl::Return(2, vec![10]) }))) }))) }, layout: FunctionLayout { input_size: 6, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_397() -> Function { - Function { body: Block { ops: vec![Op::Call(128, vec![1], 2, false), Op::Call(128, vec![2], 2, false), Op::Call(775, vec![5], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(775, vec![5], 1, false), Op::Call(775, vec![7], 1, false), Op::Sub(9, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(12, [(G::from_u64(8), Block { ops: vec![Op::Load(4, 6)], ctrl: Ctrl::Match(16, [(G::from_u64(8), Block { ops: vec![Op::Call(2, vec![13, 17], 1, false)], ctrl: Ctrl::Match(20, [(G::from_u64(1), Block { ops: vec![Op::Sub(14, 18)], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Call(380, vec![0, 15, 19, 3], 1, false)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Call(385, vec![0, 5, 7, 3], 1, false)], ctrl: Ctrl::Return(1, vec![23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![23]) }))) })].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![21]) }))) })].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![16]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![12]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 8, auxiliaries: 20, lookups: 11 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_398() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(400, vec![0, 1, 2, 4, 3], 2, false)], ctrl: Ctrl::Match(5, [(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(397, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(399, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(2, vec![8]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_399() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(3), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(8, [(G::from_u64(3), Block { ops: vec![Op::Call(398, vec![0, 5, 9, 3], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Call(398, vec![0, 6, 10, 3], 1, false)], 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]) }))) })].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![8]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 11, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_400() -> Function { - Function { body: Block { ops: vec![Op::Sub(1, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![6, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Sub(7, 11)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![15, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![15, 3]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(401, vec![0, 1, 2, 3, 4], 2, false)], ctrl: Ctrl::Return(3, vec![14, 15]) }))) }), (G::from_u64(1), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![Op::Call(271, vec![7, 11], 1, false)], ctrl: Ctrl::Return(4, vec![14, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(401, vec![0, 1, 2, 3, 4], 2, false)], ctrl: Ctrl::Return(5, vec![14, 15]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(10, [(G::from_u64(2), Block { ops: vec![Op::Call(2, vec![7, 11], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Call(379, vec![8, 12], 1, false)], ctrl: Ctrl::Return(6, vec![15, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(401, vec![0, 1, 2, 3, 4], 2, false)], ctrl: Ctrl::Return(7, vec![15, 16]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(401, vec![0, 1, 2, 3, 4], 2, false)], ctrl: Ctrl::Return(8, vec![14, 15]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(10, [(G::from_u64(3), Block { ops: vec![Op::Call(400, vec![0, 7, 11, 3, 4], 2, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Call(400, vec![0, 8, 12, 15, 4], 2, false)], ctrl: Ctrl::Return(9, vec![16, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(10, vec![16, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(401, vec![0, 1, 2, 3, 4], 2, false)], ctrl: Ctrl::Return(11, vec![14, 15]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(10, [(G::from_u64(4), Block { ops: vec![Op::Call(400, vec![0, 7, 11, 3, 4], 2, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![16, 7, 4]), Op::Call(400, vec![0, 8, 12, 15, 17], 2, false)], ctrl: Ctrl::Return(12, vec![18, 19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(13, vec![16, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(401, vec![0, 1, 2, 3, 4], 2, false)], ctrl: Ctrl::Return(14, vec![14, 15]) }))) }), (G::from_u64(5), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(10, [(G::from_u64(5), Block { ops: vec![Op::Call(400, vec![0, 7, 11, 3, 4], 2, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![16, 7, 4]), Op::Call(400, vec![0, 8, 12, 15, 17], 2, false)], ctrl: Ctrl::Return(15, vec![18, 19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(16, vec![16, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(401, vec![0, 1, 2, 3, 4], 2, false)], ctrl: Ctrl::Return(17, vec![14, 15]) }))) }), (G::from_u64(7), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(10, [(G::from_u64(7), Block { ops: vec![Op::Call(287, vec![7, 8, 11, 12], 1, false)], ctrl: Ctrl::Return(18, vec![14, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(401, vec![0, 1, 2, 3, 4], 2, false)], ctrl: Ctrl::Return(19, vec![14, 15]) }))) }), (G::from_u64(8), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(10, [(G::from_u64(8), Block { ops: vec![Op::Call(2, vec![7, 11], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![Op::Sub(8, 12)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Call(400, vec![0, 9, 13, 3, 4], 2, false)], ctrl: Ctrl::Return(20, vec![16, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(21, vec![16, 3]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(401, vec![0, 1, 2, 3, 4], 2, false)], ctrl: Ctrl::Return(22, vec![15, 16]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(401, vec![0, 1, 2, 3, 4], 2, false)], ctrl: Ctrl::Return(23, vec![14, 15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(401, vec![0, 1, 2, 3, 4], 2, false)], ctrl: Ctrl::Return(24, vec![10, 11]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 25, auxiliaries: 16, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_401() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5, 5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 5), Op::Call(365, vec![0, 1, 4], 1, false), Op::Call(365, vec![0, 2, 4], 1, false), Op::Sub(7, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![10, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(388, vec![0, 7, 8, 4], 2, false)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![11, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(414, vec![0, 7, 8, 12, 4], 3, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![16, 6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(400, vec![0, 14, 15, 6, 4], 2, false)], ctrl: Ctrl::Return(4, vec![16, 17]) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 5, auxiliaries: 14, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_402() -> Function { - Function { body: Block { ops: vec![Op::Call(359, vec![0, 1, 3], 1, false), Op::Call(359, vec![0, 2, 3], 1, false), Op::Sub(4, 5)], 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::Call(409, vec![0, 4, 5, 3], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(407, vec![0, 4, 5, 3], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(403, vec![0, 4, 5, 3], 1, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(403, vec![0, 5, 4, 3], 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(388, vec![0, 4, 5, 3], 2, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(5, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(406, vec![0, 4, 5, 3], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(6, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(412, vec![0, 4, 5, 3], 1, false)], ctrl: Ctrl::Return(7, vec![14]) }))) }))) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 8, auxiliaries: 18, lookups: 10 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_403() -> Function { - Function { body: Block { ops: vec![Op::Call(128, vec![2], 2, false), Op::Load(4, 4)], ctrl: Ctrl::Match(6, [(G::from_u64(2), Block { ops: vec![Op::Call(234, vec![7], 1, false), Op::Load(12, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(6), Block { ops: vec![Op::Call(775, vec![5], 1, false), Op::Add(17, 18), Op::Sub(23, 24)], ctrl: Ctrl::Match(25, [(G::from_u64(0), Block { ops: vec![Op::Call(236, vec![14, 15], 1, false), Op::Load(12, 26)], ctrl: Ctrl::Match(27, [(G::from_u64(5), Block { ops: vec![Op::EqZero(31), Op::Const(G::from_u64(1)), Op::Sub(32, 40), Op::EqZero(41), Op::Mul(39, 42)], ctrl: Ctrl::Match(43, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![44]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(405, vec![14, 15], 1, false), Op::Call(352, vec![44], 1, false)], ctrl: Ctrl::Match(45, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![46]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(374, vec![0, 1, 3], 1, false), Op::Call(374, vec![0, 2, 3], 1, false), Op::Call(380, vec![0, 46, 47, 3], 1, false)], ctrl: Ctrl::Match(48, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![49]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(404, vec![0, 44, 17, 18, 1, 5, 49, 3], 1, false)], ctrl: Ctrl::Return(3, vec![50]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![39]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![26]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![23]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![10]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 8, auxiliaries: 48, lookups: 14 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_404() -> Function { - Function { body: Block { ops: vec![Op::Sub(3, 6)], ctrl: Ctrl::Match(8, [(G::from_u64(0), 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(8)), Op::Store(vec![9, 1, 6, 4]), Op::Add(2, 6), Op::Call(768, vec![5, 11], 1, false), Op::Call(380, vec![0, 10, 12, 7], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(6, 14), Op::Call(404, vec![0, 1, 2, 3, 4, 5, 15, 7], 1, false)], ctrl: Ctrl::Return(2, vec![16]) }))) }))) }, layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_405() -> Function { - Function { body: Block { ops: vec![Op::Call(240, 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(82, 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(23, 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_406() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(4), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(8, [(G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(410, vec![0, 5, 6, 2, 3], 1, false)], ctrl: Ctrl::Return(1, vec![12]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(8, [(G::from_u64(4), Block { ops: vec![Op::Call(410, vec![0, 9, 10, 1, 3], 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]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 11, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_407() -> Function { - Function { body: Block { ops: vec![Op::Call(374, vec![0, 1, 3], 1, false), Op::Call(359, vec![0, 4, 3], 1, false), Op::Call(408, vec![5], 1, false)], 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(374, vec![0, 2, 3], 1, false), Op::Call(380, vec![0, 4, 7, 3], 1, false)], ctrl: Ctrl::Return(1, vec![8]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 7, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_408() -> Function { - Function { body: Block { ops: vec![Op::Call(128, vec![0], 2, false), Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(2), Block { ops: vec![Op::Call(234, 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(237, 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_409() -> Function { - Function { body: Block { ops: vec![Op::Call(374, vec![0, 1, 3], 1, false), Op::Call(411, vec![0, 4, 3], 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(374, vec![0, 2, 3], 1, false), Op::Call(380, vec![0, 4, 6, 3], 1, false)], ctrl: Ctrl::Return(1, vec![7]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_410() -> Function { - Function { body: Block { ops: vec![Op::Call(374, vec![0, 3, 4], 1, false), Op::Call(359, vec![0, 5, 4], 1, false), Op::Load(4, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(5), Block { ops: vec![Op::Call(380, vec![0, 1, 8, 4], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Call(306, vec![3, 12, 13], 1, false), Op::Store(vec![13, 13, 13, 13]), Op::Const(G::from_u64(3)), Op::Store(vec![16, 14, 15, 13]), Op::Store(vec![13, 1, 4]), Op::Call(380, vec![0, 2, 17, 18], 1, false)], ctrl: Ctrl::Return(1, vec![19]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![11]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 14, lookups: 10 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_411() -> Function { - Function { body: Block { ops: vec![Op::Call(374, vec![0, 1, 2], 1, false), Op::Call(359, vec![0, 3, 2], 1, false), Op::Load(4, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![9, 9, 9]), Op::Call(271, vec![6, 10], 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![9]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_412() -> Function { - Function { body: Block { ops: vec![Op::Call(413, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_413() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Sub(5, 9)], ctrl: Ctrl::Match(12, [(G::from_u64(0), 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]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![12]) }))) }), (G::from_u64(1), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(271, vec![5, 9], 1, false)], 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![12]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(8, [(G::from_u64(2), Block { ops: vec![Op::Call(2, vec![5, 9], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Call(379, vec![6, 10], 1, false)], ctrl: Ctrl::Return(5, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(426, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(6, vec![13]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(426, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(7, vec![12]) }))) }), (G::from_u64(3), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(8, [(G::from_u64(3), Block { ops: vec![Op::Call(380, vec![0, 5, 9, 3], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Call(426, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(8, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(380, vec![0, 6, 10, 3], 1, false)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Call(426, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(9, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(10, vec![14]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(426, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(11, vec![12]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(8, [(G::from_u64(4), Block { ops: vec![Op::Call(380, vec![0, 5, 9, 3], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(12, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![13, 5, 3]), Op::Call(380, vec![0, 6, 10, 14], 1, false)], ctrl: Ctrl::Return(13, vec![15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(410, vec![0, 5, 6, 2, 3], 1, false)], ctrl: Ctrl::Return(14, vec![12]) }))) }), (G::from_u64(5), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(8, [(G::from_u64(5), Block { ops: vec![Op::Call(380, vec![0, 5, 9, 3], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(15, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![13, 5, 3]), Op::Call(380, vec![0, 6, 10, 14], 1, false)], ctrl: Ctrl::Return(16, vec![15]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(17, vec![12]) }))) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(18, vec![8]) }), (G::from_u64(7), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(8, [(G::from_u64(7), Block { ops: vec![Op::Call(287, vec![5, 6, 9, 10], 1, false)], ctrl: Ctrl::Return(19, vec![12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(341, vec![0, 1], 1, false), Op::Sub(12, 1)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(20, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(413, vec![0, 12, 2, 3], 1, false)], ctrl: Ctrl::Return(21, vec![14]) }))) }))) }), (G::from_u64(8), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(8, [(G::from_u64(8), Block { ops: vec![Op::Call(2, vec![5, 9], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Sub(6, 10)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Call(380, vec![0, 7, 11, 3], 1, false)], ctrl: Ctrl::Return(22, vec![14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(23, vec![14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], 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![12]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 26, auxiliaries: 13, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_414() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![5, 1, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Sub(1, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![6, 1, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(388, vec![0, 1, 2, 4], 2, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![7, 1, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(427, vec![1], 2, false), Op::Call(427, vec![2], 2, false)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(416, vec![0, 8, 10, 1, 2, 3, 4], 3, false)], ctrl: Ctrl::Return(3, vec![12, 13, 14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(420, vec![0, 8, 1, 2, 3, 4], 3, false)], ctrl: Ctrl::Return(4, vec![12, 13, 14]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(421, vec![0, 10, 1, 2, 3, 4], 3, false)], ctrl: Ctrl::Return(5, vec![12, 13, 14]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(422, vec![0, 1, 2, 3, 4], 3, false)], ctrl: Ctrl::Return(6, vec![12, 13, 14]) }))) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 7, auxiliaries: 15, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_415() -> 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_416() -> Function { - Function { body: Block { ops: vec![Op::Call(234, vec![1], 1, false), Op::Load(12, 7), Op::Call(234, vec![2], 1, false), Op::Load(12, 20), Op::Call(423, vec![8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], 1, false), Op::Call(423, vec![21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], 1, false)], ctrl: Ctrl::Match(33, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(34, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![35, 3, 4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(418, vec![0, 3, 4, 5, 6], 3, false)], ctrl: Ctrl::Return(1, vec![35, 36, 37]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(34, [(G::from_u64(0), Block { ops: vec![Op::Call(417, vec![0, 3, 4, 5, 6], 3, false)], ctrl: Ctrl::Return(2, vec![35, 36, 37]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(415, vec![8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], 1, false), Op::Call(415, vec![21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], 1, false), Op::U32LessThan(36, 35)], ctrl: Ctrl::Match(37, [(G::from_u64(1), Block { ops: vec![Op::Call(417, vec![0, 3, 4, 5, 6], 3, false)], ctrl: Ctrl::Return(3, vec![38, 39, 40]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U32LessThan(35, 36)], ctrl: Ctrl::Match(38, [(G::from_u64(1), Block { ops: vec![Op::Call(418, vec![0, 3, 4, 5, 6], 3, false)], ctrl: Ctrl::Return(4, vec![39, 40, 41]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(419, vec![0, 3, 4, 5, 6], 3, false)], ctrl: Ctrl::Return(5, vec![39, 40, 41]) }))) }))) }))) }))) }, layout: FunctionLayout { input_size: 7, selectors: 6, auxiliaries: 50, lookups: 22 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_417() -> Function { - Function { body: Block { ops: vec![Op::Call(425, vec![1], 2, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(365, vec![0, 6, 4], 1, false), Op::Const(G::from_u64(1)), Op::Sub(3, 8), Op::Call(414, vec![0, 7, 2, 9, 4], 3, false)], ctrl: Ctrl::Return(0, vec![10, 11, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![7, 1, 2]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_418() -> Function { - Function { body: Block { ops: vec![Op::Call(425, vec![2], 2, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(365, vec![0, 6, 4], 1, false), Op::Const(G::from_u64(1)), Op::Sub(3, 8), Op::Call(414, vec![0, 1, 7, 9, 4], 3, false)], ctrl: Ctrl::Return(0, vec![10, 11, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![7, 1, 2]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_419() -> Function { - Function { body: Block { ops: vec![Op::Call(425, vec![1], 2, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(425, vec![2], 2, false)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Call(365, vec![0, 6, 4], 1, false), Op::Call(365, vec![0, 8, 4], 1, false), Op::Const(G::from_u64(1)), Op::Sub(3, 11), Op::Call(414, vec![0, 9, 10, 12, 4], 3, false)], ctrl: Ctrl::Return(0, vec![13, 14, 15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![9, 1, 2]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![7, 1, 2]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 10, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_420() -> Function { - Function { body: Block { ops: vec![Op::Call(424, vec![0, 3, 5], 2, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(4, 8), Op::Call(414, vec![0, 2, 7, 9, 5], 3, false)], ctrl: Ctrl::Return(0, vec![10, 11, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(234, vec![1], 1, false), Op::Load(12, 8), Op::Call(423, vec![9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], 1, false)], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![22, 2, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(428, vec![0, 2, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 5], 2, false)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(4, 24), Op::Call(414, vec![0, 23, 3, 25, 5], 3, false)], ctrl: Ctrl::Return(2, vec![26, 27, 28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![24, 2, 3]) }))) }))) }))) }, layout: FunctionLayout { input_size: 6, selectors: 4, auxiliaries: 24, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_421() -> Function { - Function { body: Block { ops: vec![Op::Call(424, vec![0, 2, 5], 2, false)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(4, 8), Op::Call(414, vec![0, 7, 3, 9, 5], 3, false)], ctrl: Ctrl::Return(0, vec![10, 11, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(234, vec![1], 1, false), Op::Load(12, 8), Op::Call(423, vec![9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], 1, false)], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![22, 2, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(428, vec![0, 3, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 5], 2, false)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(4, 24), Op::Call(414, vec![0, 2, 23, 25, 5], 3, false)], ctrl: Ctrl::Return(2, vec![26, 27, 28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![24, 2, 3]) }))) }))) }))) }, layout: FunctionLayout { input_size: 6, selectors: 4, auxiliaries: 24, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_422() -> Function { - Function { body: Block { ops: vec![Op::Call(424, vec![0, 1, 4], 2, false), Op::Call(424, vec![0, 2, 4], 2, false)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 9), Op::Call(414, vec![0, 6, 8, 10, 4], 3, false)], ctrl: Ctrl::Return(0, vec![11, 12, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 9), Op::Call(414, vec![0, 6, 2, 10, 4], 3, false)], ctrl: Ctrl::Return(1, vec![11, 12, 13]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(3, 9), Op::Call(414, vec![0, 1, 8, 10, 4], 3, false)], ctrl: Ctrl::Return(2, vec![11, 12, 13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![9, 1, 2]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 4, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_423() -> 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_424() -> Function { - Function { body: Block { ops: vec![Op::Call(128, vec![1], 2, false), Op::Load(4, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(8), Block { ops: vec![Op::Call(365, vec![0, 1, 2], 1, false), Op::Call(128, vec![9], 2, false), Op::Load(4, 10)], ctrl: Ctrl::Match(12, [(G::from_u64(8), Block { ops: vec![Op::Call(425, vec![8], 2, false)], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Store(vec![18, 6, 7, 17]), Op::Const(G::from_u64(1)), Op::Call(201, vec![19, 4], 1, false)], ctrl: Ctrl::Return(0, vec![20, 21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![18, 1]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![16, 9]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![9, 1]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 18, lookups: 9 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_425() -> Function { - Function { body: Block { ops: vec![Op::Call(128, vec![0], 2, false), Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(2), Block { ops: vec![Op::Call(234, vec![4], 1, false), Op::Load(12, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(283, vec![11, 5], 1, false), Op::Const(G::from_u64(1)), Op::Call(201, vec![20, 2], 1, false)], ctrl: Ctrl::Return(0, vec![21, 22]) }), (G::from_u64(2), Block { ops: vec![Op::Call(283, vec![11, 5], 1, false), Op::Const(G::from_u64(1)), Op::Call(201, 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_426() -> Function { - Function { body: Block { ops: vec![Op::Call(427, vec![1], 2, false), Op::Call(427, vec![2], 2, false)], ctrl: Ctrl::Match(5, [(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![], ctrl: Ctrl::Match(7, [(G::from_u64(0), 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::Call(234, vec![4], 1, false), Op::Load(12, 8), Op::Call(234, vec![6], 1, false), Op::Load(12, 21), Op::Call(428, vec![0, 1, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 3], 2, false), Op::Call(428, vec![0, 2, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 3], 2, false)], ctrl: Ctrl::Match(34, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(36, [(G::from_u64(1), Block { ops: vec![Op::Call(380, vec![0, 35, 37, 3], 1, false)], ctrl: Ctrl::Return(2, vec![38]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(380, vec![0, 35, 2, 3], 1, false)], ctrl: Ctrl::Return(3, vec![38]) }))) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(36, [(G::from_u64(1), Block { ops: vec![Op::Call(380, vec![0, 1, 37, 3], 1, false)], 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![38]) }))) })].into_iter().collect(), None) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 6, auxiliaries: 39, lookups: 10 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_427() -> Function { - Function { body: Block { ops: vec![Op::Call(128, 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_428() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Call(425, vec![1], 2, false)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(365, vec![0, 16, 14], 1, false)], ctrl: Ctrl::Return(0, vec![17, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![17, 1]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Call(425, vec![1], 2, false)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(365, vec![0, 16, 14], 1, false)], ctrl: Ctrl::Return(2, vec![17, 18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![17, 1]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![15, 1]) }))) }, layout: FunctionLayout { input_size: 15, selectors: 5, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_429() -> Function { - Function { body: Block { ops: vec![Op::Call(288, vec![1], 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]), Op::Call(431, vec![0, 1, 5], 1, false)], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(430, vec![0, 1, 2, 3], 1, false)], ctrl: Ctrl::Return(1, vec![4]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_430() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(302, vec![1, 4], 1, false), Op::Call(775, vec![2], 1, false), Op::Call(292, vec![5, 6], 1, false)], ctrl: Ctrl::Match(7, [(G::from_u64(0), Block { ops: vec![Op::Call(301, vec![2, 3], 1, false), Op::Call(431, vec![0, 1, 8], 1, false)], ctrl: Ctrl::Return(0, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(310, vec![1, 7, 8], 1, false), Op::Call(777, vec![2, 7], 1, false), Op::Sub(3, 7), Op::Call(301, vec![10, 11], 1, false), Op::Call(431, vec![0, 9, 12], 1, false), Op::Call(306, vec![13, 7, 8], 1, false)], ctrl: Ctrl::Return(1, vec![14]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 10, lookups: 9 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_431() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Call(768, vec![2, 4], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 8), Op::Const(G::from_u64(0)), Op::Call(306, vec![7, 9, 10], 1, false)], ctrl: Ctrl::Return(0, vec![11]) }), (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]), Op::Call(280, vec![9], 1, false), Op::Store(vec![7, 10, 8, 8])], ctrl: Ctrl::Return(1, vec![11]) }), (G::from_u64(2), Block { ops: vec![Op::Call(234, vec![4], 1, false), Op::Load(12, 7), Op::Call(372, vec![8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], 1, false), Op::Call(775, vec![5], 1, false), Op::AssertEq(vec![21], vec![20], Some("Const applied to wrong number of universe levels".into())), Op::Call(373, vec![8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], 1, false), Op::Call(283, vec![22, 5], 1, false)], ctrl: Ctrl::Return(2, vec![23]) }), (G::from_u64(3), Block { ops: vec![Op::Call(128, vec![1], 2, false), Op::Call(429, vec![0, 7, 2], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10]), Op::Call(443, vec![0, 9, 8, 11, 2], 1, false)], ctrl: Ctrl::Return(3, vec![12]) }), (G::from_u64(4), Block { ops: vec![Op::Call(451, vec![0, 4, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 4, 2]), Op::Call(429, vec![0, 5, 9], 1, false), Op::Const(G::from_u64(5)), Op::Store(vec![11, 4, 10, 8])], ctrl: Ctrl::Return(4, vec![12]) }), (G::from_u64(5), Block { ops: vec![Op::Call(451, vec![0, 4, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 4, 2]), Op::Call(451, vec![0, 5, 9], 1, false), Op::Const(G::from_u64(1)), Op::Call(279, vec![7, 10], 1, false), Op::Store(vec![11, 12, 8, 8])], ctrl: Ctrl::Return(5, vec![13]) }), (G::from_u64(6), Block { ops: vec![Op::Call(432, vec![0, 4, 5, 6, 2], 1, false)], ctrl: Ctrl::Return(6, vec![7]) }), (G::from_u64(7), Block { ops: vec![Op::Call(444, vec![0, 4, 5], 1, false)], ctrl: Ctrl::Return(7, vec![7]) }), (G::from_u64(8), Block { ops: vec![Op::Call(450, vec![0, 4, 5, 6, 2], 1, false)], ctrl: Ctrl::Return(8, vec![7]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 22, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_432() -> Function { - Function { body: Block { ops: vec![Op::Call(451, vec![0, 1, 4], 1, false), Op::Call(452, vec![0, 2, 1, 4], 0, false), Op::Call(775, vec![4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 4, 6, 7, 7]), Op::Const(G::from_u64(2)), Op::Store(vec![9, 1, 2, 8, 6]), Op::Call(438, vec![0, 3, 10, 4, 6], 1, false)], ctrl: Ctrl::Return(0, vec![11]) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 6, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_433() -> Function { - Function { body: Block { ops: vec![Op::Call(434, vec![0, 1], 2, false), Op::Sub(3, 5), Op::Const(G::from_u64(0)), Op::Call(306, 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_434() -> Function { - Function { body: Block { ops: vec![Op::Load(5, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(371, 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(434, 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(434, 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_435() -> Function { - Function { body: Block { ops: vec![Op::Call(436, vec![0, 1], 2, false), Op::Sub(2, 4), Op::Const(G::from_u64(0)), Op::Call(306, 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_436() -> 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(436, 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(437, 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(436, 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_437() -> Function { - Function { body: Block { ops: vec![Op::Call(288, 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(436, vec![1, 11], 2, false), Op::Sub(2, 13), Op::Const(G::from_u64(0)), Op::Call(306, vec![12, 14, 15], 1, false), Op::Call(306, 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(437, vec![7, 1, 2, 3], 1, false), Op::Call(437, 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(437, vec![7, 1, 2, 3], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 12), Op::Call(437, 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(437, vec![7, 1, 2, 3], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 12), Op::Call(437, 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(437, vec![7, 1, 2, 3], 1, false), Op::Call(437, vec![8, 1, 2, 3], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 13), Op::Call(437, 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(437, 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_438() -> Function { - Function { body: Block { ops: vec![Op::Call(288, vec![1], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Call(429, vec![0, 1, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(6, [(G::from_u64(3), Block { ops: vec![Op::Call(439, vec![2], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Call(442, vec![0, 1, 2, 3, 4], 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(293, vec![1, 11, 10], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Call(442, vec![0, 1, 2, 3, 4], 1, false)], ctrl: Ctrl::Return(2, vec![13]) }), (G::from_u64(0), Block { ops: vec![Op::Call(440, vec![0, 1, 2, 3, 4], 1, false)], ctrl: Ctrl::Return(3, vec![13]) })].into_iter().collect(), None) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(442, vec![0, 1, 2, 3, 4], 1, false)], ctrl: Ctrl::Return(4, vec![10]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 5, auxiliaries: 11, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_439() -> 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(439, 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_440() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(302, vec![1, 5], 1, false), Op::Call(441, vec![2, 6], 3, false), Op::Call(310, vec![1, 8, 5], 1, false), Op::Call(777, vec![3, 9], 1, false), Op::Sub(4, 9), Op::Call(442, vec![0, 10, 7, 11, 12], 1, false), Op::Call(306, vec![13, 9, 5], 1, false)], ctrl: Ctrl::Return(0, vec![14]) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 9, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_441() -> 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(441, 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(441, 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_442() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![Op::Call(434, vec![2, 6], 2, false), Op::Sub(4, 10), Op::Const(G::from_u64(0)), Op::Call(306, vec![9, 11, 12], 1, false)], ctrl: Ctrl::Return(0, vec![13]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(437, vec![6, 2, 4, 9], 1, false), Op::Call(451, vec![0, 10, 3], 1, false), Op::Store(vec![9, 10, 3]), Op::Const(G::from_u64(1)), Op::Add(4, 13), Op::Store(vec![13, 10, 14, 2, 9]), Op::Call(438, vec![0, 7, 15, 12, 14], 1, false), Op::Const(G::from_u64(5)), Op::Store(vec![17, 10, 16, 9])], ctrl: Ctrl::Return(1, vec![18]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(437, vec![6, 2, 4, 9], 1, false), Op::Call(451, vec![0, 10, 3], 1, false), Op::Store(vec![9, 10, 3]), Op::Const(G::from_u64(1)), Op::Add(4, 13), Op::Store(vec![13, 10, 14, 2, 9]), Op::Call(438, vec![0, 7, 15, 12, 14], 1, false), Op::Call(359, vec![0, 16, 12], 1, false), Op::Load(4, 17)], ctrl: Ctrl::Match(18, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(279, vec![11, 19], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![22, 23, 24, 24])], ctrl: Ctrl::Return(2, vec![25]) })].into_iter().collect(), None) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(437, vec![6, 2, 4, 9], 1, false), Op::Call(451, vec![0, 10, 3], 1, false), Op::Call(438, vec![0, 7, 2, 3, 4], 1, false), Op::Call(380, vec![0, 12, 10, 3], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![13], vec![14], Some("delayed let value type mismatch".into())), Op::Const(G::from_u64(2)), Op::Store(vec![15, 10, 7, 2, 4]), Op::Call(438, vec![0, 8, 16, 3, 4], 1, false)], ctrl: Ctrl::Return(3, vec![17]) }), (G::from_u64(3), Block { ops: vec![Op::Call(438, vec![0, 6, 2, 3, 4], 1, false), Op::Call(359, vec![0, 9, 3], 1, false), Op::Load(4, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(5), Block { ops: vec![Op::Call(438, vec![0, 7, 2, 3, 4], 1, false), Op::Call(380, vec![0, 15, 12, 3], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![16], vec![17], Some("delayed application type mismatch".into())), Op::Const(G::from_u64(0)), Op::Call(293, vec![13, 18, 17], 1, false)], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(310, vec![13, 20, 20], 1, false)], ctrl: Ctrl::Return(4, vec![21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(437, vec![7, 2, 4, 20], 1, false), Op::Call(316, vec![13, 21, 20], 1, false)], ctrl: Ctrl::Return(5, vec![22]) }))) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(437, vec![1, 2, 4, 9], 1, false), Op::Call(429, vec![0, 10, 3], 1, false)], ctrl: Ctrl::Return(6, vec![11]) }))) }, layout: FunctionLayout { input_size: 5, selectors: 7, auxiliaries: 17, lookups: 11 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_443() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(775, vec![3], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(320, vec![1, 3, 9], 1, false)], ctrl: Ctrl::Return(1, vec![10]) }))) }), (G::from_u64(0), Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(5), Block { ops: vec![Op::Call(775, vec![3], 1, false)], ctrl: Ctrl::MatchContinue(12, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(320, vec![9, 3, 13], 1, false)], ctrl: Ctrl::Yield(3, vec![14]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Call(452, vec![0, 6, 13, 4], 0, false), Op::Const(G::from_u64(0)), Op::Store(vec![14, 6, 3]), Op::Call(443, vec![0, 10, 7, 15, 4], 1, false)], ctrl: Ctrl::Return(4, vec![16]) })) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(775, vec![3], 1, false)], ctrl: Ctrl::MatchContinue(12, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(5, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(320, vec![1, 3, 13], 1, false)], ctrl: Ctrl::Yield(6, vec![14]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Call(359, vec![0, 13, 4], 1, false), Op::Load(4, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(5), Block { ops: vec![Op::Call(452, vec![0, 6, 16, 4], 0, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![20, 20, 20]), Op::Store(vec![19, 6, 21]), Op::Call(443, vec![0, 17, 7, 22, 4], 1, false)], ctrl: Ctrl::Return(7, vec![23]) })].into_iter().collect(), None) })) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 8, auxiliaries: 21, lookups: 11 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_444() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(481, vec![0, 4], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Store(vec![3, 5, 7, 4])], ctrl: Ctrl::Return(0, vec![8]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(37)), Op::Call(482, vec![0, 4], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(0)), Op::Store(vec![3, 5, 7, 8])], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_445() -> Function { - Function { body: Block { ops: vec![Op::Call(283, vec![1, 2], 1, false), Op::Call(446, vec![0, 5, 3, 4], 1, false), Op::Load(4, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![11, 11, 11]), Op::Call(271, vec![8, 12], 1, false)], ctrl: Ctrl::Return(0, vec![13]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_446() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(359, vec![0, 1, 3], 1, false)], ctrl: Ctrl::Return(0, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(359, vec![0, 1, 3], 1, false), Op::Load(4, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![9, 6, 3]), Op::Const(G::from_u64(1)), Op::Sub(2, 11), Op::Call(446, vec![0, 7, 12, 10], 1, false)], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![4]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_447() -> Function { - Function { body: Block { ops: vec![], 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![Op::Call(451, vec![0, 2, 3], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5]), Op::Call(271, vec![4, 6], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![7], vec![8], Some("projection on a Prop structure: field is not a Prop".into()))], ctrl: Ctrl::Return(1, vec![]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 5, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_448() -> Function { - Function { body: Block { ops: vec![], 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![Op::Call(451, vec![0, 2, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6]), Op::Call(271, vec![5, 7], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(288, vec![3], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![9], vec![10], Some("projection on a Prop structure: later fields depend on a data field".into()))], ctrl: Ctrl::Return(2, vec![]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 7, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_449() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(5), Block { ops: vec![Op::Sub(2, 3)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Call(447, vec![0, 6, 9, 7], 0, false)], ctrl: Ctrl::Return(0, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(448, vec![0, 6, 9, 10, 7], 0, false), Op::Const(G::from_u64(8)), Op::Store(vec![13, 4, 3, 5]), Op::Const(G::from_u64(0)), Op::Call(316, vec![10, 14, 15], 1, false), Op::Const(G::from_u64(1)), Op::Add(3, 17), Op::Call(449, vec![0, 16, 2, 18, 4, 5, 6, 7], 1, false)], ctrl: Ctrl::Return(1, vec![19]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 2, auxiliaries: 9, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_450() -> Function { - Function { body: Block { ops: vec![Op::Call(429, vec![0, 3, 4], 1, false), Op::Call(359, vec![0, 5, 4], 1, false), Op::Call(128, vec![6], 2, false), Op::Load(4, 7)], ctrl: Ctrl::Match(9, [(G::from_u64(2), Block { ops: vec![Op::AssertEq(vec![10], vec![1], Some("projection's structure type differs from the value's head".into())), Op::Call(234, vec![10], 1, false), Op::Load(12, 13)], ctrl: Ctrl::Match(14, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::AssertEq(vec![19], vec![26], Some("projection on an inductive with more than one constructor".into())), Op::Const(G::from_u64(0)), Op::Call(237, vec![21, 22, 27], 1, false), Op::Load(12, 28)], ctrl: Ctrl::Match(29, [(G::from_u64(6), Block { ops: vec![Op::Call(283, vec![31, 11], 1, false), Op::Call(377, vec![41, 8, 17], 1, false), Op::Add(17, 18), Op::Call(445, vec![0, 16, 11, 43, 4], 1, false), Op::Const(G::from_u64(0)), Op::Call(449, vec![0, 42, 2, 45, 1, 3, 44, 4], 1, false)], ctrl: Ctrl::Return(0, vec![46]) })].into_iter().collect(), None) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 39, lookups: 13 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_451() -> Function { - Function { body: Block { ops: vec![Op::Call(429, vec![0, 1, 2], 1, false), Op::Call(359, vec![0, 3, 2], 1, false), Op::Load(4, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_452() -> Function { - Function { body: Block { ops: vec![Op::Call(429, vec![0, 1, 3], 1, false), Op::Call(380, vec![0, 4, 2, 3], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5], vec![6], Some("inferred type is not def-eq to the expected type".into()))], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_453() -> Function { - Function { body: Block { ops: vec![Op::Call(775, vec![4], 1, false), Op::Const(G::from_u64(2)), Op::U32LessThan(6, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![9, 9, 9, 9])], ctrl: Ctrl::Return(0, vec![9, 10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Call(454, vec![0, 4, 5], 2, false)], ctrl: Ctrl::Return(1, vec![9, 10]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(455, vec![0, 9, 1, 3, 4, 5], 2, false)], ctrl: Ctrl::Return(2, vec![10, 11]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(455, vec![0, 9, 1, 3, 4, 5], 2, false)], ctrl: Ctrl::Return(3, vec![10, 11]) }), (G::from_u64(4), Block { ops: vec![Op::Call(456, vec![0, 4, 5], 2, false)], ctrl: Ctrl::Return(4, vec![9, 10]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(457, vec![0, 9, 1, 3, 4, 5], 2, false)], ctrl: Ctrl::Return(5, vec![10, 11]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(457, vec![0, 9, 1, 3, 4, 5], 2, false)], ctrl: Ctrl::Return(6, vec![10, 11]) })].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(7, vec![9, 10]) }))) }))) }, layout: FunctionLayout { input_size: 6, selectors: 8, auxiliaries: 16, lookups: 9 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_454() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(768, vec![1, 3], 1, false), Op::Const(G::from_u64(1)), Op::Call(768, vec![1, 5], 1, false), Op::Call(359, vec![0, 4, 2], 1, false), Op::Call(189, vec![0, 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(129, vec![9], 1, false), Op::Call(191, vec![10], 1, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(68)), Op::Call(481, vec![0, 13], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15]), Op::Const(G::from_u64(0)), Op::Store(vec![12, 14, 16, 17]), Op::Const(G::from_u64(3)), Op::Store(vec![19, 18, 11, 17]), Op::Store(vec![19, 20, 6, 17]), Op::Call(777, vec![1, 12], 1, false), Op::Call(201, vec![21, 22], 1, false)], ctrl: Ctrl::Return(1, vec![15, 23]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 15, lookups: 14 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_455() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(768, vec![4, 6], 1, false), Op::Const(G::from_u64(1)), Op::Call(768, vec![4, 8], 1, false), Op::Call(359, vec![0, 7, 5], 1, false), Op::Call(359, vec![0, 9, 5], 1, false), Op::Call(189, vec![0, 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(189, vec![0, 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(1, [(G::from_u64(1), Block { ops: vec![Op::Call(138, vec![13, 15], 1, false)], ctrl: Ctrl::Yield(2, vec![16]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(285, vec![13, 15], 1, false)], ctrl: Ctrl::Yield(3, vec![16]) })), 1, 2, 1, Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(66)), Op::Call(482, vec![0, 18], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![20, 20, 20]), Op::Const(G::from_u64(0)), Op::Store(vec![17, 19, 21, 22]), Op::Const(G::from_u64(3)), Op::Store(vec![24, 23, 7, 22]), Op::Store(vec![24, 25, 9, 22])], ctrl: Ctrl::Yield(4, vec![26]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(481, vec![0, 18], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![20, 20, 20]), Op::Store(vec![17, 19, 21, 18]), Op::Call(459, vec![0, 22, 7, 9], 1, false)], ctrl: Ctrl::Yield(5, vec![23]) })), 1, 5, 5, Box::new(Block { ops: vec![Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![19, 2, 3, 20]), Op::Store(vec![18, 21, 7, 20]), Op::Store(vec![18, 22, 9, 20]), Op::Const(G::from_u64(1)), Op::Call(460, vec![0, 16, 17, 23], 1, false), Op::Call(777, vec![4, 19], 1, false), Op::Call(201, vec![25, 26], 1, false)], ctrl: Ctrl::Return(6, vec![24, 27]) })) })) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 7, auxiliaries: 24, lookups: 19 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_456() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(768, vec![1, 3], 1, false), Op::Const(G::from_u64(1)), Op::Call(768, vec![1, 5], 1, false), Op::Call(359, vec![0, 4, 2], 1, false), Op::Call(192, vec![0, 7], 3, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![11, 11, 11, 11])], ctrl: Ctrl::Return(0, vec![11, 12]) }), (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]), Op::Call(194, vec![0, 9, 10, 11, 14], 1, false), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(96)), Op::Call(481, vec![0, 17], 1, false), Op::Store(vec![12, 12, 12]), Op::Store(vec![16, 18, 19, 11]), Op::Const(G::from_u64(3)), Op::Store(vec![21, 20, 15, 11]), Op::Store(vec![21, 22, 6, 11]), Op::Call(777, vec![1, 16], 1, false), Op::Call(201, vec![23, 24], 1, false)], ctrl: Ctrl::Return(1, vec![12, 25]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 17, lookups: 15 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_457() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(768, vec![4, 6], 1, false), Op::Const(G::from_u64(1)), Op::Call(768, vec![4, 8], 1, false), Op::Call(359, vec![0, 7, 5], 1, false), Op::Call(359, vec![0, 9, 5], 1, false), Op::Call(192, vec![0, 10], 3, false)], ctrl: Ctrl::Match(12, [(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]) }), (G::from_u64(1), Block { ops: vec![Op::Call(192, vec![0, 11], 3, false)], ctrl: Ctrl::Match(15, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![18, 18, 18, 18])], ctrl: Ctrl::Return(1, vec![18, 19]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(1), Block { ops: vec![Op::Call(458, vec![13, 14, 16, 17], 1, false)], ctrl: Ctrl::Yield(2, vec![18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(13, 16), Op::Mul(19, 19), Op::Sub(18, 20), Op::Call(285, vec![14, 17], 1, false), Op::Mul(21, 22)], ctrl: Ctrl::Yield(3, vec![23]) })), 1, 4, 1, Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(94)), Op::Call(482, vec![0, 20], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![22, 22, 22]), Op::Const(G::from_u64(0)), Op::Store(vec![19, 21, 23, 24]), Op::Const(G::from_u64(3)), Op::Store(vec![26, 25, 7, 24]), Op::Store(vec![26, 27, 9, 24])], ctrl: Ctrl::Yield(4, vec![28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(482, vec![0, 20], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![22, 22, 22]), Op::Const(G::from_u64(0)), Op::Store(vec![19, 21, 23, 24]), Op::Call(459, vec![0, 25, 7, 9], 1, false)], ctrl: Ctrl::Yield(5, vec![26]) })), 1, 5, 5, Box::new(Block { ops: vec![Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Store(vec![21, 2, 3, 22]), Op::Store(vec![20, 23, 7, 22]), Op::Store(vec![20, 24, 9, 22]), Op::Const(G::from_u64(1)), Op::Call(460, vec![0, 18, 19, 25], 1, false), Op::Call(777, vec![4, 21], 1, false), Op::Call(201, vec![27, 28], 1, false)], ctrl: Ctrl::Return(6, vec![26, 29]) })) })) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 6, selectors: 7, auxiliaries: 28, lookups: 19 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_458() -> 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(138, 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]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![4]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(138, vec![3, 1], 1, false)], ctrl: Ctrl::Return(3, vec![4]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 4, lookups: 2 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_459() -> 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::Const(G::from_u64(2)), Op::Const(G::from_u64(8)), Op::Call(481, vec![0, 9], 1, false), Op::Store(vec![4, 4, 4]), Op::Store(vec![5, 7, 11]), Op::Store(vec![8, 10, 12, 5]), Op::Const(G::from_u64(3)), Op::Store(vec![14, 13, 1, 5]), Op::Store(vec![14, 15, 2, 5]), Op::Store(vec![14, 16, 3, 5])], ctrl: Ctrl::Return(0, vec![17]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 10, lookups: 10 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_460() -> 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::Const(G::from_u64(2)), Op::Const(G::from_u64(9)), Op::Call(481, vec![0, 9], 1, false), Op::Store(vec![4, 4, 4]), Op::Store(vec![5, 7, 11]), Op::Store(vec![8, 10, 12, 5]), Op::Const(G::from_u64(4)), Op::Call(481, vec![0, 14], 1, false), Op::Store(vec![8, 15, 11, 5]), Op::Const(G::from_u64(3)), Op::Store(vec![17, 13, 16, 5]), Op::Call(161, vec![0, 1], 1, false), Op::Store(vec![17, 18, 19, 5])], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(63)), Op::Call(482, vec![0, 21], 1, false)], ctrl: Ctrl::Yield(0, vec![22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(64)), Op::Call(482, vec![0, 21], 1, false)], ctrl: Ctrl::Yield(1, vec![22]) })), 1, 2, 1, Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(1, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(60)), Op::Call(482, vec![0, 22], 1, false)], ctrl: Ctrl::Yield(2, vec![23]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(61)), Op::Call(482, vec![0, 22], 1, false)], ctrl: Ctrl::Yield(3, vec![23]) })), 1, 2, 1, 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![25, 25, 25]), Op::Const(G::from_u64(0)), Op::Store(vec![24, 21, 26, 27]), Op::Store(vec![23, 28, 2, 27]), Op::Store(vec![23, 29, 3, 27]), Op::Store(vec![23, 30, 20, 27]), Op::Store(vec![24, 22, 26, 27]), Op::Store(vec![23, 32, 2, 27]), Op::Store(vec![23, 33, 31, 27])], ctrl: Ctrl::Return(4, vec![34]) })) })) }, layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 26, lookups: 22 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_461() -> Function { - Function { body: Block { ops: vec![Op::Call(775, 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(768, vec![2, 7], 1, false), Op::Const(G::from_u64(1)), Op::Call(768, vec![2, 9], 1, false), Op::Load(4, 8)], ctrl: Ctrl::Match(11, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Load(4, 10)], ctrl: Ctrl::Match(15, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(16, [(G::from_u64(1), Block { ops: vec![Op::Call(286, vec![13, 17], 1, false)], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![20, 20, 20, 20])], ctrl: Ctrl::Return(1, vec![20, 21]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(37)), Op::Call(481, vec![0, 21], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![23, 23, 23]), Op::Const(G::from_u64(0)), Op::Store(vec![20, 22, 24, 25]), Op::Const(G::from_u64(3)), Op::Store(vec![20, 1, 24, 25]), Op::Store(vec![27, 28, 8, 25]), Op::Store(vec![27, 29, 10, 25]), Op::Call(459, vec![0, 26, 8, 10], 1, false), Op::Call(460, vec![0, 23, 31, 30], 1, false), Op::Call(777, vec![2, 20], 1, false), Op::Call(201, vec![32, 33], 1, false)], ctrl: Ctrl::Return(2, vec![23, 34]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![19, 19, 19, 19])], ctrl: Ctrl::Return(3, vec![19, 20]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![19, 19, 19, 19])], ctrl: Ctrl::Return(4, vec![19, 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::Const(G::from_u64(0)), Op::Store(vec![15, 15, 15, 15])], ctrl: Ctrl::Return(6, vec![15, 16]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 7, auxiliaries: 31, lookups: 23 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_462() -> Function { - Function { body: Block { ops: vec![Op::Load(32, 0), Op::Const(G::from_u64(6)), 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(22, 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(83, vec![36], 2, false), Op::Const(G::from_u64(232)), Op::AssertEq(vec![37], vec![39], Some("role table: not a binding section".into())), Op::Call(83, vec![38], 2, false), Op::Const(G::from_u64(3)), Op::AssertEq(vec![40], vec![42], Some("role table: not a binding section".into())), Op::Call(83, vec![41], 2, false), Op::AssertEq(vec![43], vec![42], Some("role table: made for another specification version".into())), Op::Call(83, vec![44], 2, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Call(463, vec![46, 45, 47, 48, 48, 48, 48, 48, 48], 14, false), Op::Call(83, vec![62], 2, false), Op::Call(464, vec![64, 63, 47], 8, false), Op::Load(3, 72), Op::AssertEq(vec![73, 74, 75], vec![48, 48, 48], Some("role table: trailing bytes".into())), Op::Store(vec![0, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 65, 66, 67, 68, 69, 70])], ctrl: Ctrl::Return(0, vec![76]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 72, lookups: 13 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_463() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![9, 9, 9, 9, 9, 9, 3, 4, 5, 6, 7, 8, 2, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U8ShiftRight(1), Op::Call(463, vec![0, 9, 2, 3, 4, 5, 6, 7, 8], 14, false), Op::Call(83, vec![23], 2, false), Op::Const(G::from_u64(103)), Op::U32LessThan(24, 26), Op::Const(G::from_u64(1)), Op::AssertEq(vec![27], vec![28], Some("role table: unknown role".into())), Op::U32LessThan(24, 22), Op::Const(G::from_u64(0)), Op::AssertEq(vec![29], vec![30], Some("role table: roles out of order".into())), Op::Call(102, vec![25], 2, false), Op::Call(763, vec![31, 16, 17, 18, 19, 20, 21, 30], 1, false), Op::AssertEq(vec![33], vec![30], Some("role table: an address is bound to two roles".into())), Op::Add(24, 28), Op::Call(779, vec![31, 34, 16, 17, 18, 19, 20, 21], 6, false), Op::Add(9, 28), Op::Sub(1, 41), Op::Call(463, vec![32, 42, 34, 35, 36, 37, 38, 39, 40], 14, false), Op::Store(vec![10, 11, 12, 13, 14, 15]), Op::Store(vec![43, 44, 45, 46, 47, 48])], ctrl: Ctrl::Return(1, vec![30, 28, 24, 31, 57, 58, 49, 50, 51, 52, 53, 54, 55, 56]) }))) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 56, lookups: 22 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_464() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3, 3, 3, 3, 3, 3, 2, 0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::U8ShiftRight(1), Op::Call(464, vec![0, 3, 2], 8, false), Op::Call(83, vec![11], 2, false), Op::Const(G::from_u64(103)), Op::U32LessThan(12, 14), Op::Const(G::from_u64(1)), Op::AssertEq(vec![15], vec![16], Some("role table: unknown role".into())), Op::U32LessThan(12, 10), Op::Const(G::from_u64(0)), Op::AssertEq(vec![17], vec![18], Some("role table: evidence out of order".into())), Op::Call(83, vec![13], 2, false), Op::Call(465, vec![20, 19], 2, false), Op::Add(3, 16), Op::Sub(1, 23), Op::Add(12, 16), Op::Call(464, vec![22, 24, 25], 8, false), Op::Store(vec![4, 5, 6, 7, 8, 9]), Op::Store(vec![26, 27, 28, 29, 30, 31])], ctrl: Ctrl::Return(1, vec![18, 16, 12, 21, 34, 35, 32, 33]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 39, lookups: 21 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_465() -> 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(83, vec![0], 2, false)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(1, 4), Op::Call(465, vec![3, 5], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8, 6])], ctrl: Ctrl::Return(1, vec![9, 7]) }), (G::from_u64(1), Block { ops: vec![Op::Call(102, vec![3], 2, false), Op::Const(G::from_u64(1)), Op::Sub(1, 6), Op::Call(465, vec![5, 7], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![10, 6, 4, 8])], ctrl: Ctrl::Return(2, vec![11, 9]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_466() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(468, vec![0, 1, 2, 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_467() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2, 3, 4, 5, 6, 7]) }), (G::from_u64(0), Block { ops: vec![Op::Call(477, vec![0], 6, false), Op::Const(G::from_u64(0)), Op::Call(763, vec![9, 11, 12, 13, 14, 15, 16, 17], 1, false), Op::AssertEq(vec![18], vec![17], Some("claim: user axiom is bound in the role table".into())), Op::Call(234, vec![9], 1, false), Op::Load(12, 19)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::AssertEq(vec![23], vec![32], Some("claim: user axiom is unsafe".into())), Op::Const(G::from_u64(1)), Op::Call(779, vec![9, 33, 2, 3, 4, 5, 6, 7], 6, false), Op::Call(467, vec![0, 10, 34, 35, 36, 37, 38, 39], 6, false)], ctrl: Ctrl::Return(1, vec![40, 41, 42, 43, 44, 45]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::AssertEq(vec![32], vec![33], Some("claim: axioms tree entry is not an axiom".into()))], ctrl: Ctrl::Return(2, vec![2, 3, 4, 5, 6, 7]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 36, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_468() -> Function { - Function { body: Block { ops: vec![Op::Call(462, vec![0], 1, false)], ctrl: Ctrl::MatchContinue(2, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(0, vec![5, 5, 5, 5, 5, 5]) }), (G::from_u64(0), Block { ops: vec![Op::Call(705, vec![3], 1, false), Op::Const(G::from_u64(1)), Op::Call(467, vec![4, 5, 6, 6, 6, 6, 6, 6], 6, false)], ctrl: Ctrl::Yield(1, vec![7, 8, 9, 10, 11, 12]) })].into_iter().collect(), None, 6, 7, 2, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(72)), Op::Store(vec![11, 4, 12, 5, 6, 7, 8, 9, 10])], ctrl: Ctrl::Return(2, vec![13]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![11, 4, 5, 6, 7, 8, 9, 10, 12])], ctrl: Ctrl::Return(3, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::AssertEq(vec![11], vec![12], Some("claim: wrong validator identity".into())), Op::Const(G::from_u64(72)), Op::Store(vec![11, 4, 13, 5, 6, 7, 8, 9, 10])], ctrl: Ctrl::Return(4, vec![14]) }))) })) }, layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 18, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_469() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(472, vec![0], 1, false), Op::Add(1, 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_470() -> Function { - Function { body: Block { ops: vec![Op::Load(9, 0)], ctrl: Ctrl::Match(1, [(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]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 10, lookups: 2 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_471() -> Function { - Function { body: Block { ops: vec![Op::Load(9, 0)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4, 5, 6, 7, 8, 9]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![3, 4, 5, 6, 7, 8]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 10, lookups: 2 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_472() -> 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))], ctrl: Ctrl::Return(0, vec![10]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![10]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 10, lookups: 2 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_473() -> Function { - Function { body: Block { ops: vec![Op::Call(470, vec![0], 1, false), Op::Load(19, 1)], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(0, vec![2]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 21, lookups: 3 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_474() -> Function { - Function { body: Block { ops: vec![Op::Load(19, 0)], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![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, 21, 21, 21, 21, 21]), Op::Call(763, vec![1, 3, 4, 5, 6, 7, 8, 22], 1, false)], ctrl: Ctrl::Return(0, vec![23]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 22, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_475() -> Function { - Function { body: Block { ops: vec![Op::Call(474, vec![0, 1], 1, false), Op::Call(477, vec![0], 6, false), Op::Const(G::from_u64(0)), Op::Call(763, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Const(G::from_u64(1)), Op::Add(1, 11), Op::Sub(10, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![14]) })].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: 10, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_476() -> Function { - Function { body: Block { ops: vec![Op::Call(475, vec![0, 1], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![2], vec![3], Some("role table does not bind a role the claim needs".into())), Op::Call(474, vec![0, 1], 1, false)], ctrl: Ctrl::Return(0, vec![4]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_477() -> Function { - Function { body: Block { ops: vec![Op::Load(19, 0)], ctrl: Ctrl::Match(1, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(0, vec![8, 9, 10, 11, 12, 13]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 20, lookups: 2 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_478() -> Function { - Function { body: Block { ops: vec![Op::Load(9, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(477, vec![3], 6, false), Op::Const(G::from_u64(0)), Op::Call(763, vec![1, 11, 12, 13, 14, 15, 16, 17], 1, false)], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(18, 19), Op::Call(549, vec![20], 1, false), Op::U32LessThan(21, 4)], ctrl: Ctrl::Match(22, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(18, 23), Op::Call(549, vec![24], 1, false), Op::Call(483, vec![3, 25], 0, 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![23]) }))) }))) }), (G::from_u64(1), Block { ops: vec![Op::Call(477, vec![3], 6, false), Op::Const(G::from_u64(0)), Op::Call(763, vec![1, 11, 12, 13, 14, 15, 16, 17], 1, false)], ctrl: Ctrl::Return(3, vec![18]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 26, lookups: 13 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_479() -> Function { - Function { body: Block { ops: vec![Op::Call(470, vec![0], 1, false), Op::Call(477, vec![2], 6, false), Op::Const(G::from_u64(0)), Op::Call(763, vec![1, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Return(0, vec![10]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 9, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_480() -> Function { - Function { body: Block { ops: vec![Op::Call(479, vec![0, 1], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 4), Op::Sub(3, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Call(478, vec![0, 1], 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::Const(G::from_u64(1))], 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![7]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_481() -> Function { - Function { body: Block { ops: vec![Op::Load(9, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(549, vec![1], 1, false), Op::U32LessThan(11, 4), Op::Const(G::from_u64(1)), Op::AssertEq(vec![12], vec![13], Some("a role is used before its group is admitted".into())), Op::Call(476, vec![3, 1], 1, false), Op::Call(549, vec![1], 1, false), Op::Call(483, vec![3, 15], 0, false)], ctrl: Ctrl::Return(0, vec![14]) }), (G::from_u64(1), Block { ops: vec![Op::Call(476, vec![3, 1], 1, false)], ctrl: Ctrl::Return(1, vec![11]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 19, lookups: 12 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_482() -> Function { - Function { body: Block { ops: vec![Op::Call(481, vec![0, 1], 1, false), Op::Call(698, vec![0, 2], 0, false)], ctrl: Ctrl::Return(0, vec![2]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 2, lookups: 3 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_483() -> Function { - Function { body: Block { ops: vec![Op::Call(551, vec![1], 1, false), Op::Call(491, vec![0, 2], 0, false), Op::Const(G::from_u64(0)), Op::Call(484, vec![1], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![3, 0, 4, 5, 5, 5, 5, 5, 5]), Op::Call(550, vec![1], 1, false), Op::Call(492, vec![6, 0, 7], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_484() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(33)), Op::U32LessThan(0, 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::Const(G::from_u64(41)), Op::U32LessThan(0, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![3]) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 15, lookups: 13 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_485() -> Function { - Function { body: Block { ops: vec![Op::Call(552, vec![0], 1, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(554, vec![0], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![3]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![3]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![3]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![2]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(6, vec![2]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 6, lookups: 3 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_486() -> Function { - Function { body: Block { ops: vec![Op::Load(9, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(477, vec![3], 6, false), Op::Const(G::from_u64(0)), Op::Call(763, vec![1, 11, 12, 13, 14, 15, 16, 17], 1, false)], ctrl: Ctrl::Match(18, [(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(18, 19), Op::Call(549, vec![20], 1, false), Op::U32LessThan(21, 4), Op::Call(485, vec![20], 1, false), Op::Mul(22, 23)], ctrl: Ctrl::Match(24, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![0]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(484, vec![21], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![25, 3, 26, 27, 27, 27, 27, 27, 27])], ctrl: Ctrl::Return(2, vec![28]) }))) }))) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(3, vec![0]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 30, lookups: 14 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_487() -> Function { - Function { body: Block { ops: vec![Op::Load(9, 0)], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![11]) }), (G::from_u64(1), Block { ops: vec![Op::Call(477, vec![3], 6, false), Op::Const(G::from_u64(0)), Op::Call(763, vec![1, 11, 12, 13, 14, 15, 16, 17], 1, false)], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(18, 19), Op::Call(485, vec![20], 1, false)], ctrl: Ctrl::Return(2, vec![21]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 19, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_488() -> Function { - Function { body: Block { ops: vec![Op::Call(462, vec![0], 1, false), Op::Const(G::from_u64(0)), Op::Call(489, vec![1, 2], 0, false), Op::Call(490, vec![1, 2], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 2, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_489() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(103)), Op::Sub(1, 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::Call(475, vec![0, 1], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![4], vec![5], Some("binding claim: a role is unbound".into())), Op::Add(1, 5), Op::Call(489, vec![0, 6], 0, false)], ctrl: Ctrl::Return(1, vec![]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 3, lookups: 3 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_490() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(72)), Op::Sub(1, 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::Call(483, vec![0, 1], 0, false), Op::Const(G::from_u64(1)), Op::Add(1, 4), Op::Call(490, vec![0, 5], 0, false)], ctrl: Ctrl::Return(1, vec![]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 2, lookups: 3 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_491() -> 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![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(549, vec![3], 1, false), Op::Call(483, vec![0, 5], 0, false), Op::Call(491, vec![0, 4], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_492() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 2)], 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(493, vec![0, 1, 4], 0, false), Op::Call(492, vec![0, 1, 5], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 4, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_493() -> Function { - Function { body: Block { ops: vec![Op::Call(476, vec![1, 2], 1, false), Op::Call(234, vec![3], 1, false), Op::Load(12, 4), Op::Call(372, vec![5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], 1, false), Op::Call(553, vec![2], 1, false), Op::AssertEq(vec![17], vec![18], Some("a bound role has the wrong number of universe parameters".into())), Op::Call(552, vec![2], 1, false)], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![Op::Call(496, vec![0, 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], 0, false)], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Call(498, vec![0, 1, 2, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], 0, false)], ctrl: Ctrl::Return(1, vec![]) }), (G::from_u64(2), Block { ops: vec![Op::Call(502, vec![0, 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], 0, false)], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(3), Block { ops: vec![Op::Call(499, vec![0, 1, 2, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], 0, false)], ctrl: Ctrl::Return(3, vec![]) }), (G::from_u64(4), Block { ops: vec![Op::Call(500, vec![0, 1, 2, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], 0, false)], ctrl: Ctrl::Return(4, vec![]) }), (G::from_u64(5), Block { ops: vec![Op::Call(504, vec![0, 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], 0, false)], ctrl: Ctrl::Return(5, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 18, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_494() -> 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![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Call(380, vec![0, 1, 2, 5], 1, false), Op::AssertEq(vec![6], vec![4], Some("a bound role's type does not meet its specification".into()))], ctrl: Ctrl::Return(1, vec![]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 4, lookups: 3 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_495() -> Function { - Function { body: Block { ops: vec![Op::Call(569, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![12], vec![13], Some("a bound role is unsafe".into()))], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 12, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_496() -> Function { - Function { body: Block { ops: vec![Op::Call(495, vec![4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 0, false), Op::Call(373, vec![4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 1, false), Op::Call(557, vec![1, 2], 1, false), Op::Call(494, vec![0, 16, 17], 0, false), Op::Call(554, vec![2], 1, false)], ctrl: Ctrl::Match(18, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(5), Block { ops: vec![Op::Call(556, vec![2], 1, false), Op::AssertEq(vec![9], vec![19], Some("a bound inductive has the wrong number of constructors".into())), Op::Call(698, vec![0, 3], 0, false)], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), None) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(6), Block { ops: vec![Op::Call(555, vec![2], 4, false), Op::Call(476, vec![1, 19], 1, false), Op::Call(234, vec![23], 1, false), Op::Load(12, 24)], ctrl: Ctrl::MatchContinue(25, [(G::from_u64(5), Block { ops: vec![Op::Call(2, vec![7, 32], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![37], vec![38], Some("a bound constructor is not its inductive's".into())), Op::AssertEq(vec![8], vec![33], Some("a bound constructor is not its inductive's".into()))], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), None, 0, 1, 1, Box::new(Block { ops: vec![Op::AssertEq(vec![9], vec![20], Some("a bound constructor has the wrong index".into())), Op::AssertEq(vec![10], vec![21], Some("a bound constructor has the wrong number of parameters".into())), Op::AssertEq(vec![11], vec![22], Some("a bound constructor has the wrong number of fields".into())), Op::Call(698, vec![0, 3], 0, false)], ctrl: Ctrl::Return(2, vec![]) })) })].into_iter().collect(), None) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(7), Block { ops: vec![Op::Call(698, vec![0, 3], 0, false)], ctrl: Ctrl::Return(3, vec![]) })].into_iter().collect(), None) }), (G::from_u64(3), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(553, vec![2], 1, false), Op::Call(574, vec![6, 19, 20], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![21, 21, 21]), Op::Call(451, vec![0, 6, 22], 1, false)], ctrl: Ctrl::Return(4, vec![]) })].into_iter().collect(), None) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(497, vec![4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 19], 0, false)], ctrl: Ctrl::Return(5, vec![]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(497, vec![4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 19], 0, false)], ctrl: Ctrl::Return(6, vec![]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Call(497, vec![4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 19], 0, false)], ctrl: Ctrl::Return(7, vec![]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(497, vec![4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 19], 0, false)], ctrl: Ctrl::Return(8, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 16, selectors: 9, auxiliaries: 23, lookups: 12 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_497() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::MatchContinue(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(0, vec![13]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(1, vec![13]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Yield(2, vec![13]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Yield(3, vec![13]) })].into_iter().collect(), None, 1, 0, 0, Box::new(Block { ops: vec![Op::AssertEq(vec![13], vec![12], Some("a bound quotient constant has the wrong kind".into()))], ctrl: Ctrl::Return(4, vec![]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 13, selectors: 5, auxiliaries: 2, lookups: 1 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_498() -> Function { - Function { body: Block { ops: vec![Op::Call(495, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 0, false), Op::Call(373, vec![3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 1, false), Op::Call(557, vec![1, 2], 1, false), Op::Call(494, vec![0, 15, 16], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 15, selectors: 1, auxiliaries: 3, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_499() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::AssertEq(vec![6], vec![15], Some("a bound standard axiom is unsafe".into())), Op::Call(574, vec![5, 15, 4], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![16, 16, 16]), Op::Call(451, vec![0, 5, 17], 1, false), Op::Call(557, vec![1, 2], 1, false), Op::Call(494, vec![0, 5, 19], 0, false)], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 15, selectors: 1, auxiliaries: 4, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_500() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::AssertEq(vec![6], vec![15], Some("a bound inert axiom is unsafe".into())), Op::Call(574, vec![5, 15, 4], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![16, 16, 16]), Op::Call(451, vec![0, 5, 17], 1, false), Op::Call(557, vec![1, 2], 1, false), Op::Call(494, vec![0, 5, 19], 0, false)], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 15, selectors: 1, auxiliaries: 4, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_501() -> Function { - Function { body: Block { ops: vec![Op::Load(19, 0)], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![21, 21, 21, 21]), Op::Call(763, vec![1, 15, 16, 17, 18, 19, 20, 22], 1, false)], ctrl: Ctrl::Return(0, vec![23]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 22, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_502() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::MatchContinue(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Yield(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::AssertEq(vec![16], vec![17], Some("a bound operation is not a safe definition".into()))], ctrl: Ctrl::Yield(1, vec![]) })), 0, 1, 0, Box::new(Block { ops: vec![Op::Call(557, vec![1, 2], 1, false), Op::Call(494, vec![0, 6, 16], 0, false), Op::Call(698, vec![0, 3], 0, false), Op::Call(501, vec![1, 2], 1, false), Op::Call(767, vec![17], 1, false), Op::Call(558, vec![2], 1, false), Op::AssertEq(vec![18], vec![19], Some("an operation's evidence does not match its equations".into())), Op::Const(G::from_u64(0)), Op::Call(503, vec![0, 1, 2, 17, 20], 0, false)], ctrl: Ctrl::Return(2, vec![]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 16, selectors: 3, auxiliaries: 6, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_503() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(559, vec![2], 1, false)], ctrl: Ctrl::MatchContinue(9, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Call(560, vec![1, 2, 4], 1, false), Op::Call(561, vec![1, 2, 4], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12]), Op::Call(380, vec![0, 10, 11, 13], 1, false), Op::AssertEq(vec![14], vec![12], Some("an operation's equation does not hold by definition".into()))], ctrl: Ctrl::Yield(1, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::AssertEq(vec![10], vec![11], Some("a structural operation's evidence must be definitional".into()))], ctrl: Ctrl::Yield(2, vec![]) })].into_iter().collect(), None) })].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)), Op::Const(G::from_u64(1)), Op::AssertEq(vec![10], vec![11], Some("a well-founded operation's evidence must be proofs".into()))], ctrl: Ctrl::Yield(3, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Call(234, vec![7], 1, false), Op::Load(12, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::AssertEq(vec![12], vec![23], Some("certificate theorem has universe parameters".into())), Op::Call(698, vec![0, 7], 0, false), Op::Call(562, vec![1, 2, 4], 1, false), Op::Call(494, vec![0, 13, 24], 0, false)], ctrl: Ctrl::Yield(4, vec![]) })].into_iter().collect(), None) })].into_iter().collect(), None) })), 0, 15, 5, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(4, 10), Op::Call(503, vec![0, 1, 2, 8, 11], 0, false)], ctrl: Ctrl::Return(5, vec![]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 6, auxiliaries: 21, lookups: 9 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_504() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::MatchContinue(8, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Yield(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::AssertEq(vec![16], vec![17], Some("a bound definition is not safe".into()))], ctrl: Ctrl::Yield(1, vec![]) })), 0, 1, 0, Box::new(Block { ops: vec![Op::Call(553, vec![2], 1, false), Op::AssertEq(vec![5], vec![16], Some("a bound definition has another number of universe parameters".into())), Op::Call(557, vec![1, 2], 1, false), Op::Call(494, vec![0, 6, 17], 0, false), Op::Call(698, vec![0, 3], 0, false), Op::Call(501, vec![1, 2], 1, false), Op::Call(767, vec![18], 1, false), Op::Call(563, vec![2], 1, false), Op::AssertEq(vec![19], vec![20], Some("a definition's evidence does not match its equations".into())), Op::Const(G::from_u64(0)), Op::Call(505, vec![0, 1, 2, 18, 21], 0, false)], ctrl: Ctrl::Return(2, vec![]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 16, selectors: 3, auxiliaries: 7, lookups: 9 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_505() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::MatchContinue(6, [(G::from_u64(0), Block { ops: vec![Op::Call(564, vec![2, 4], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![9], vec![10], Some("a conditional equation's evidence must be a proof".into())), Op::Call(565, vec![1, 2, 4], 1, false), Op::Call(566, vec![1, 2, 4], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![13, 13, 13]), Op::Call(380, vec![0, 11, 12, 14], 1, false), Op::AssertEq(vec![15], vec![13], Some("a definition's equation does not hold by definition".into()))], ctrl: Ctrl::Yield(1, vec![]) }), (G::from_u64(1), Block { ops: vec![Op::Call(234, vec![7], 1, false), Op::Load(12, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(2), Block { ops: vec![Op::Call(553, vec![2], 1, false), Op::AssertEq(vec![11], vec![22], Some("an equation's proof has another number of universe parameters".into())), Op::Call(698, vec![0, 7], 0, false), Op::Call(567, vec![1, 2, 4], 1, false), Op::Call(494, vec![0, 12, 23], 0, false)], ctrl: Ctrl::Yield(2, vec![]) })].into_iter().collect(), None) })].into_iter().collect(), None, 0, 15, 6, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(4, 9), Op::Call(505, vec![0, 1, 2, 8, 10], 0, false)], ctrl: Ctrl::Return(3, vec![]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 4, auxiliaries: 20, lookups: 9 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_506() -> Function { - Function { body: Block { ops: vec![Op::Call(470, vec![0], 1, false), Op::Call(477, vec![2], 6, false), Op::Const(G::from_u64(0)), Op::Call(763, vec![1, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Call(471, vec![0], 6, false), Op::Const(G::from_u64(0)), Op::Call(763, vec![1, 11, 12, 13, 14, 15, 16, 17], 1, false)], ctrl: Ctrl::Return(0, vec![18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(507, vec![10], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(0), 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::Call(478, vec![0, 1], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(3, vec![11]) }))) }))) }))) }, layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 16, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_507() -> 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), Op::Const(G::from_u64(56)), Op::Sub(2, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(0), 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::Const(G::from_u64(57)), Op::Sub(2, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(0), 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(36)), Op::Sub(2, 7)], ctrl: Ctrl::Match(8, [(G::from_u64(0), 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::Const(G::from_u64(58)), Op::Sub(2, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2))], 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: 6, lookups: 1 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_508() -> Function { - Function { body: Block { ops: vec![Op::Call(506, vec![0, 1], 1, false)], ctrl: Ctrl::Match(2, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::AssertEq(vec![3], vec![4], Some("a constant uses `sorryAx`".into()))], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], 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_509() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_510() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(109)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(163)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(119)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(178)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(95)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(149)), Op::Const(G::from_u64(229)), Op::Const(G::from_u64(51)), Op::Const(G::from_u64(160)), Op::Const(G::from_u64(141)), Op::Const(G::from_u64(20)), Op::Const(G::from_u64(252)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(45)), 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, 11, 25, 26, 27, 28, 29, 22])], ctrl: Ctrl::Return(0, vec![30]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_511() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(103))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_512() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(72))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_513() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(33))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_514() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(41))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_515() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_516() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_517() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_518() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_519() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_520() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_521() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_522() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(9))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_523() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(30))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_524() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(31))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_525() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(32))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_526() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(34))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_527() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(35))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_528() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(36))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_529() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(37))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_530() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(38))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_531() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(39))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_532() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(40))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_533() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(42))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_534() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(56))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_535() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(57))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_536() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(58))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_537() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(60))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_538() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(61))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_539() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(63))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_540() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(64))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_541() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(66))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_542() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(68))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_543() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(70))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_544() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(71))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_545() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(84))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_546() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(89))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_547() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(94))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_548() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(96))], ctrl: Ctrl::Return(0, vec![0]) }, layout: FunctionLayout { input_size: 0, selectors: 1, auxiliaries: 1, lookups: 1 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_549() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(11))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(11))], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(11))], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(11))], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![1]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![1]) }), (G::from_u64(10), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(6, vec![1]) }), (G::from_u64(11), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(7, vec![1]) }), (G::from_u64(12), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(8, vec![1]) }), (G::from_u64(13), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(9, vec![1]) }), (G::from_u64(14), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(10, vec![1]) }), (G::from_u64(15), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(11, vec![1]) }), (G::from_u64(16), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(12, vec![1]) }), (G::from_u64(17), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(13, vec![1]) }), (G::from_u64(18), Block { ops: vec![Op::Const(G::from_u64(19))], ctrl: Ctrl::Return(14, vec![1]) }), (G::from_u64(19), Block { ops: vec![Op::Const(G::from_u64(19))], ctrl: Ctrl::Return(15, vec![1]) }), (G::from_u64(20), Block { ops: vec![Op::Const(G::from_u64(20))], ctrl: Ctrl::Return(16, vec![1]) }), (G::from_u64(21), Block { ops: vec![Op::Const(G::from_u64(20))], ctrl: Ctrl::Return(17, vec![1]) }), (G::from_u64(22), Block { ops: vec![Op::Const(G::from_u64(20))], ctrl: Ctrl::Return(18, vec![1]) }), (G::from_u64(23), Block { ops: vec![Op::Const(G::from_u64(21))], ctrl: Ctrl::Return(19, vec![1]) }), (G::from_u64(24), Block { ops: vec![Op::Const(G::from_u64(21))], ctrl: Ctrl::Return(20, vec![1]) }), (G::from_u64(25), Block { ops: vec![Op::Const(G::from_u64(21))], ctrl: Ctrl::Return(21, vec![1]) }), (G::from_u64(26), Block { ops: vec![Op::Const(G::from_u64(22))], ctrl: Ctrl::Return(22, vec![1]) }), (G::from_u64(27), Block { ops: vec![Op::Const(G::from_u64(22))], ctrl: Ctrl::Return(23, vec![1]) }), (G::from_u64(28), Block { ops: vec![Op::Const(G::from_u64(22))], ctrl: Ctrl::Return(24, vec![1]) }), (G::from_u64(29), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(25, vec![1]) }), (G::from_u64(30), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(26, vec![1]) }), (G::from_u64(31), Block { ops: vec![Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(27, vec![1]) }), (G::from_u64(32), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(28, vec![1]) }), (G::from_u64(33), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(29, vec![1]) }), (G::from_u64(34), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(30, vec![1]) }), (G::from_u64(35), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(31, vec![1]) }), (G::from_u64(36), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(32, vec![1]) }), (G::from_u64(37), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(33, vec![1]) }), (G::from_u64(38), Block { ops: vec![Op::Const(G::from_u64(10))], ctrl: Ctrl::Return(34, vec![1]) }), (G::from_u64(39), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(35, vec![1]) }), (G::from_u64(40), Block { ops: vec![Op::Const(G::from_u64(9))], ctrl: Ctrl::Return(36, vec![1]) }), (G::from_u64(41), Block { ops: vec![Op::Const(G::from_u64(12))], ctrl: Ctrl::Return(37, vec![1]) }), (G::from_u64(42), Block { ops: vec![Op::Const(G::from_u64(13))], ctrl: Ctrl::Return(38, vec![1]) }), (G::from_u64(43), Block { ops: vec![Op::Const(G::from_u64(14))], ctrl: Ctrl::Return(39, vec![1]) }), (G::from_u64(44), Block { ops: vec![Op::Const(G::from_u64(15))], ctrl: Ctrl::Return(40, vec![1]) }), (G::from_u64(45), Block { ops: vec![Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(41, vec![1]) }), (G::from_u64(46), Block { ops: vec![Op::Const(G::from_u64(17))], ctrl: Ctrl::Return(42, vec![1]) }), (G::from_u64(47), Block { ops: vec![Op::Const(G::from_u64(18))], ctrl: Ctrl::Return(43, vec![1]) }), (G::from_u64(48), Block { ops: vec![Op::Const(G::from_u64(33))], ctrl: Ctrl::Return(44, vec![1]) }), (G::from_u64(49), Block { ops: vec![Op::Const(G::from_u64(34))], ctrl: Ctrl::Return(45, vec![1]) }), (G::from_u64(50), Block { ops: vec![Op::Const(G::from_u64(35))], ctrl: Ctrl::Return(46, vec![1]) }), (G::from_u64(51), Block { ops: vec![Op::Const(G::from_u64(36))], ctrl: Ctrl::Return(47, vec![1]) }), (G::from_u64(52), Block { ops: vec![Op::Const(G::from_u64(37))], ctrl: Ctrl::Return(48, vec![1]) }), (G::from_u64(53), Block { ops: vec![Op::Const(G::from_u64(38))], ctrl: Ctrl::Return(49, vec![1]) }), (G::from_u64(54), Block { ops: vec![Op::Const(G::from_u64(39))], ctrl: Ctrl::Return(50, vec![1]) }), (G::from_u64(55), Block { ops: vec![Op::Const(G::from_u64(40))], ctrl: Ctrl::Return(51, vec![1]) }), (G::from_u64(56), Block { ops: vec![Op::Const(G::from_u64(23))], ctrl: Ctrl::Return(52, vec![1]) }), (G::from_u64(57), Block { ops: vec![Op::Const(G::from_u64(24))], ctrl: Ctrl::Return(53, vec![1]) }), (G::from_u64(58), Block { ops: vec![Op::Const(G::from_u64(25))], ctrl: Ctrl::Return(54, vec![1]) }), (G::from_u64(59), Block { ops: vec![Op::Const(G::from_u64(27))], ctrl: Ctrl::Return(55, vec![1]) }), (G::from_u64(60), Block { ops: vec![Op::Const(G::from_u64(27))], ctrl: Ctrl::Return(56, vec![1]) }), (G::from_u64(61), Block { ops: vec![Op::Const(G::from_u64(27))], ctrl: Ctrl::Return(57, vec![1]) }), (G::from_u64(62), Block { ops: vec![Op::Const(G::from_u64(26))], ctrl: Ctrl::Return(58, vec![1]) }), (G::from_u64(63), Block { ops: vec![Op::Const(G::from_u64(42))], ctrl: Ctrl::Return(59, vec![1]) }), (G::from_u64(64), Block { ops: vec![Op::Const(G::from_u64(43))], ctrl: Ctrl::Return(60, vec![1]) }), (G::from_u64(65), Block { ops: vec![Op::Const(G::from_u64(41))], ctrl: Ctrl::Return(61, vec![1]) }), (G::from_u64(66), Block { ops: vec![Op::Const(G::from_u64(28))], ctrl: Ctrl::Return(62, vec![1]) }), (G::from_u64(67), Block { ops: vec![Op::Const(G::from_u64(44))], ctrl: Ctrl::Return(63, vec![1]) }), (G::from_u64(68), Block { ops: vec![Op::Const(G::from_u64(45))], ctrl: Ctrl::Return(64, vec![1]) }), (G::from_u64(69), Block { ops: vec![Op::Const(G::from_u64(46))], ctrl: Ctrl::Return(65, vec![1]) }), (G::from_u64(70), Block { ops: vec![Op::Const(G::from_u64(29))], ctrl: Ctrl::Return(66, vec![1]) }), (G::from_u64(71), Block { ops: vec![Op::Const(G::from_u64(29))], ctrl: Ctrl::Return(67, vec![1]) }), (G::from_u64(72), Block { ops: vec![Op::Const(G::from_u64(29))], ctrl: Ctrl::Return(68, vec![1]) }), (G::from_u64(73), Block { ops: vec![Op::Const(G::from_u64(47))], ctrl: Ctrl::Return(69, vec![1]) }), (G::from_u64(74), Block { ops: vec![Op::Const(G::from_u64(48))], ctrl: Ctrl::Return(70, vec![1]) }), (G::from_u64(75), Block { ops: vec![Op::Const(G::from_u64(49))], ctrl: Ctrl::Return(71, vec![1]) }), (G::from_u64(76), Block { ops: vec![Op::Const(G::from_u64(50))], ctrl: Ctrl::Return(72, vec![1]) }), (G::from_u64(77), Block { ops: vec![Op::Const(G::from_u64(51))], ctrl: Ctrl::Return(73, vec![1]) }), (G::from_u64(78), Block { ops: vec![Op::Const(G::from_u64(52))], ctrl: Ctrl::Return(74, vec![1]) }), (G::from_u64(79), Block { ops: vec![Op::Const(G::from_u64(53))], ctrl: Ctrl::Return(75, vec![1]) }), (G::from_u64(80), Block { ops: vec![Op::Const(G::from_u64(54))], ctrl: Ctrl::Return(76, vec![1]) }), (G::from_u64(81), Block { ops: vec![Op::Const(G::from_u64(55))], ctrl: Ctrl::Return(77, vec![1]) }), (G::from_u64(82), Block { ops: vec![Op::Const(G::from_u64(56))], ctrl: Ctrl::Return(78, vec![1]) }), (G::from_u64(83), Block { ops: vec![Op::Const(G::from_u64(31))], ctrl: Ctrl::Return(79, vec![1]) }), (G::from_u64(84), Block { ops: vec![Op::Const(G::from_u64(31))], ctrl: Ctrl::Return(80, vec![1]) }), (G::from_u64(85), Block { ops: vec![Op::Const(G::from_u64(57))], ctrl: Ctrl::Return(81, vec![1]) }), (G::from_u64(86), Block { ops: vec![Op::Const(G::from_u64(58))], ctrl: Ctrl::Return(82, vec![1]) }), (G::from_u64(87), Block { ops: vec![Op::Const(G::from_u64(59))], ctrl: Ctrl::Return(83, vec![1]) }), (G::from_u64(88), Block { ops: vec![Op::Const(G::from_u64(32))], ctrl: Ctrl::Return(84, vec![1]) }), (G::from_u64(89), Block { ops: vec![Op::Const(G::from_u64(32))], ctrl: Ctrl::Return(85, vec![1]) }), (G::from_u64(90), Block { ops: vec![Op::Const(G::from_u64(60))], ctrl: Ctrl::Return(86, vec![1]) }), (G::from_u64(91), Block { ops: vec![Op::Const(G::from_u64(61))], ctrl: Ctrl::Return(87, vec![1]) }), (G::from_u64(92), Block { ops: vec![Op::Const(G::from_u64(62))], ctrl: Ctrl::Return(88, vec![1]) }), (G::from_u64(93), Block { ops: vec![Op::Const(G::from_u64(63))], ctrl: Ctrl::Return(89, vec![1]) }), (G::from_u64(94), Block { ops: vec![Op::Const(G::from_u64(30))], ctrl: Ctrl::Return(90, vec![1]) }), (G::from_u64(95), Block { ops: vec![Op::Const(G::from_u64(64))], ctrl: Ctrl::Return(91, vec![1]) }), (G::from_u64(96), Block { ops: vec![Op::Const(G::from_u64(65))], ctrl: Ctrl::Return(92, vec![1]) }), (G::from_u64(97), Block { ops: vec![Op::Const(G::from_u64(66))], ctrl: Ctrl::Return(93, vec![1]) }), (G::from_u64(98), Block { ops: vec![Op::Const(G::from_u64(67))], ctrl: Ctrl::Return(94, vec![1]) }), (G::from_u64(99), Block { ops: vec![Op::Const(G::from_u64(68))], ctrl: Ctrl::Return(95, vec![1]) }), (G::from_u64(100), Block { ops: vec![Op::Const(G::from_u64(69))], ctrl: Ctrl::Return(96, vec![1]) }), (G::from_u64(101), Block { ops: vec![Op::Const(G::from_u64(70))], ctrl: Ctrl::Return(97, vec![1]) }), (G::from_u64(102), Block { ops: vec![Op::Const(G::from_u64(71))], ctrl: Ctrl::Return(98, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(99, vec![1]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 100, auxiliaries: 100, lookups: 1 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_550() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(3)), Op::Store(vec![2, 2, 2]), Op::Store(vec![1, 4, 5]), Op::Store(vec![1, 3, 6]), Op::Store(vec![1, 2, 7]), Op::Store(vec![1, 1, 8])], ctrl: Ctrl::Return(0, vec![9]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(9)), Op::Const(G::from_u64(10)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![1, 4, 6]), Op::Store(vec![1, 3, 7]), Op::Store(vec![1, 2, 8])], ctrl: Ctrl::Return(1, vec![9]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(12)), Op::Const(G::from_u64(13)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![1, 4, 6]), Op::Store(vec![1, 3, 7]), Op::Store(vec![1, 2, 8])], ctrl: Ctrl::Return(2, vec![9]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(14)), Op::Const(G::from_u64(15)), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Store(vec![1, 3, 5]), Op::Store(vec![1, 2, 6])], ctrl: Ctrl::Return(3, vec![7]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(16)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Store(vec![1, 3, 5]), Op::Store(vec![1, 2, 6])], ctrl: Ctrl::Return(4, vec![7]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(32)), Op::Const(G::from_u64(33)), Op::Const(G::from_u64(34)), Op::Const(G::from_u64(35)), Op::Const(G::from_u64(36)), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Store(vec![1, 6, 8]), Op::Store(vec![1, 5, 9]), Op::Store(vec![1, 4, 10]), Op::Store(vec![1, 3, 11]), Op::Store(vec![1, 2, 12])], ctrl: Ctrl::Return(5, vec![13]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(6, vec![5]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(7, vec![5]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(29)), Op::Const(G::from_u64(30)), Op::Const(G::from_u64(31)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![1, 4, 6]), Op::Store(vec![1, 3, 7]), Op::Store(vec![1, 2, 8])], ctrl: Ctrl::Return(8, vec![9]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(40)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(9, vec![5]) }), (G::from_u64(10), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(10, vec![5]) }), (G::from_u64(11), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(6)), Op::Const(G::from_u64(7)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Store(vec![1, 5, 7]), Op::Store(vec![1, 4, 8]), Op::Store(vec![1, 3, 9]), Op::Store(vec![1, 2, 10])], ctrl: Ctrl::Return(11, vec![11]) }), (G::from_u64(12), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(41)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(12, vec![5]) }), (G::from_u64(13), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(13, vec![5]) }), (G::from_u64(14), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(14, vec![5]) }), (G::from_u64(15), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(15, vec![5]) }), (G::from_u64(16), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(16, vec![5]) }), (G::from_u64(17), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(17, vec![5]) }), (G::from_u64(18), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(18, vec![5]) }), (G::from_u64(19), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(18)), Op::Const(G::from_u64(19)), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Store(vec![1, 3, 5]), Op::Store(vec![1, 2, 6])], ctrl: Ctrl::Return(19, vec![7]) }), (G::from_u64(20), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(20)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(22)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![1, 4, 6]), Op::Store(vec![1, 3, 7]), Op::Store(vec![1, 2, 8])], ctrl: Ctrl::Return(20, vec![9]) }), (G::from_u64(21), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(23)), Op::Const(G::from_u64(24)), Op::Const(G::from_u64(25)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![1, 4, 6]), Op::Store(vec![1, 3, 7]), Op::Store(vec![1, 2, 8])], ctrl: Ctrl::Return(21, vec![9]) }), (G::from_u64(22), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(27)), Op::Const(G::from_u64(28)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![1, 4, 6]), Op::Store(vec![1, 3, 7]), Op::Store(vec![1, 2, 8])], ctrl: Ctrl::Return(22, vec![9]) }), (G::from_u64(23), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(56)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(23, vec![5]) }), (G::from_u64(24), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(57)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(24, vec![5]) }), (G::from_u64(25), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(58)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(25, vec![5]) }), (G::from_u64(26), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(26, vec![5]) }), (G::from_u64(27), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(60)), Op::Const(G::from_u64(61)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![1, 4, 6]), Op::Store(vec![1, 3, 7]), Op::Store(vec![1, 2, 8])], ctrl: Ctrl::Return(27, vec![9]) }), (G::from_u64(28), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(66)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(28, vec![5]) }), (G::from_u64(29), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(71)), Op::Const(G::from_u64(72)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![1, 4, 6]), Op::Store(vec![1, 3, 7]), Op::Store(vec![1, 2, 8])], ctrl: Ctrl::Return(29, vec![9]) }), (G::from_u64(30), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(94)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(30, vec![5]) }), (G::from_u64(31), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(83)), Op::Const(G::from_u64(84)), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Store(vec![1, 3, 5]), Op::Store(vec![1, 2, 6])], ctrl: Ctrl::Return(31, vec![7]) }), (G::from_u64(32), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(89)), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Store(vec![1, 3, 5]), Op::Store(vec![1, 2, 6])], ctrl: Ctrl::Return(32, vec![7]) }), (G::from_u64(33), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(33, vec![5]) }), (G::from_u64(34), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(34, vec![5]) }), (G::from_u64(35), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(50)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(35, vec![5]) }), (G::from_u64(36), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(51)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(36, vec![5]) }), (G::from_u64(37), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(52)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(37, vec![5]) }), (G::from_u64(38), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(53)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(38, vec![5]) }), (G::from_u64(39), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(54)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(39, vec![5]) }), (G::from_u64(40), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(55)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(40, vec![5]) }), (G::from_u64(41), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(41, vec![5]) }), (G::from_u64(42), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(63)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(42, vec![5]) }), (G::from_u64(43), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(64)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(43, vec![5]) }), (G::from_u64(44), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(67)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(44, vec![5]) }), (G::from_u64(45), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(68)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(45, vec![5]) }), (G::from_u64(46), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(69)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(46, vec![5]) }), (G::from_u64(47), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(47, vec![5]) }), (G::from_u64(48), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(48, vec![5]) }), (G::from_u64(49), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(75)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(49, vec![5]) }), (G::from_u64(50), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(76)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(50, vec![5]) }), (G::from_u64(51), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(77)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(51, vec![5]) }), (G::from_u64(52), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(78)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(52, vec![5]) }), (G::from_u64(53), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(79)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(53, vec![5]) }), (G::from_u64(54), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(80)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(54, vec![5]) }), (G::from_u64(55), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(55, vec![5]) }), (G::from_u64(56), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(82)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(56, vec![5]) }), (G::from_u64(57), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(85)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(57, vec![5]) }), (G::from_u64(58), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(86)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(58, vec![5]) }), (G::from_u64(59), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(59, vec![5]) }), (G::from_u64(60), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(90)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(60, vec![5]) }), (G::from_u64(61), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(61, vec![5]) }), (G::from_u64(62), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(92)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(62, vec![5]) }), (G::from_u64(63), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(63, vec![5]) }), (G::from_u64(64), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(95)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(64, vec![5]) }), (G::from_u64(65), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(96)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(65, vec![5]) }), (G::from_u64(66), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(66, vec![5]) }), (G::from_u64(67), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(98)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(67, vec![5]) }), (G::from_u64(68), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(99)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(68, vec![5]) }), (G::from_u64(69), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(69, vec![5]) }), (G::from_u64(70), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(101)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(70, vec![5]) }), (G::from_u64(71), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(102)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(71, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![1, 1, 1])], ctrl: Ctrl::Return(72, vec![2]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 73, auxiliaries: 74, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_551() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4]), Op::Store(vec![1, 1, 5])], ctrl: Ctrl::Return(1, vec![6]) }), (G::from_u64(10), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(29)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![1, 4, 6]), Op::Store(vec![1, 3, 7]), Op::Store(vec![1, 2, 8])], ctrl: Ctrl::Return(2, vec![9]) }), (G::from_u64(12), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Store(vec![1, 1, 3])], ctrl: Ctrl::Return(3, vec![4]) }), (G::from_u64(13), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Store(vec![1, 1, 3])], ctrl: Ctrl::Return(4, vec![4]) }), (G::from_u64(14), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(41)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4]), Op::Store(vec![1, 1, 5])], ctrl: Ctrl::Return(5, vec![6]) }), (G::from_u64(15), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4]), Op::Store(vec![1, 1, 5])], ctrl: Ctrl::Return(6, vec![6]) }), (G::from_u64(16), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Store(vec![1, 3, 5]), Op::Store(vec![1, 2, 6]), Op::Store(vec![1, 1, 7])], ctrl: Ctrl::Return(7, vec![8]) }), (G::from_u64(17), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4]), Op::Store(vec![1, 1, 5])], ctrl: Ctrl::Return(8, vec![6]) }), (G::from_u64(18), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4]), Op::Store(vec![1, 1, 5])], ctrl: Ctrl::Return(9, vec![6]) }), (G::from_u64(23), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(23)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Store(vec![1, 3, 5]), Op::Store(vec![1, 2, 6])], ctrl: Ctrl::Return(10, vec![7]) }), (G::from_u64(24), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(26)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(11, vec![5]) }), (G::from_u64(25), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(12, vec![5]) }), (G::from_u64(27), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(13, vec![5]) }), (G::from_u64(28), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Store(vec![1, 1, 3])], ctrl: Ctrl::Return(14, vec![4]) }), (G::from_u64(29), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Store(vec![1, 1, 3])], ctrl: Ctrl::Return(15, vec![4]) }), (G::from_u64(30), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 3, 3]), Op::Store(vec![1, 2, 4])], ctrl: Ctrl::Return(16, vec![5]) }), (G::from_u64(31), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Store(vec![1, 1, 3])], ctrl: Ctrl::Return(17, vec![4]) }), (G::from_u64(33), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(41)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Store(vec![1, 6, 8]), Op::Store(vec![1, 5, 9]), Op::Store(vec![1, 4, 10]), Op::Store(vec![1, 3, 11]), Op::Store(vec![1, 2, 12]), Op::Store(vec![1, 1, 13])], ctrl: Ctrl::Return(18, vec![14]) }), (G::from_u64(34), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(41)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Store(vec![1, 6, 8]), Op::Store(vec![1, 5, 9]), Op::Store(vec![1, 4, 10]), Op::Store(vec![1, 3, 11]), Op::Store(vec![1, 2, 12]), Op::Store(vec![1, 1, 13])], ctrl: Ctrl::Return(19, vec![14]) }), (G::from_u64(35), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Store(vec![1, 5, 7]), Op::Store(vec![1, 4, 8]), Op::Store(vec![1, 3, 9]), Op::Store(vec![1, 2, 10]), Op::Store(vec![1, 1, 11])], ctrl: Ctrl::Return(20, vec![12]) }), (G::from_u64(36), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Store(vec![1, 8, 10]), Op::Store(vec![1, 7, 11]), Op::Store(vec![1, 6, 12]), Op::Store(vec![1, 5, 13]), Op::Store(vec![1, 4, 14]), Op::Store(vec![1, 3, 15]), Op::Store(vec![1, 2, 16]), Op::Store(vec![1, 1, 17])], ctrl: Ctrl::Return(21, vec![18]) }), (G::from_u64(37), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10]), Op::Store(vec![1, 9, 11]), Op::Store(vec![1, 8, 12]), Op::Store(vec![1, 7, 13]), Op::Store(vec![1, 6, 14]), Op::Store(vec![1, 5, 15]), Op::Store(vec![1, 4, 16]), Op::Store(vec![1, 3, 17]), Op::Store(vec![1, 2, 18]), Op::Store(vec![1, 1, 19])], ctrl: Ctrl::Return(22, vec![20]) }), (G::from_u64(38), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Store(vec![1, 8, 10]), Op::Store(vec![1, 7, 11]), Op::Store(vec![1, 6, 12]), Op::Store(vec![1, 5, 13]), Op::Store(vec![1, 4, 14]), Op::Store(vec![1, 3, 15]), Op::Store(vec![1, 2, 16]), Op::Store(vec![1, 1, 17])], ctrl: Ctrl::Return(23, vec![18]) }), (G::from_u64(39), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Store(vec![1, 6, 8]), Op::Store(vec![1, 5, 9]), Op::Store(vec![1, 4, 10]), Op::Store(vec![1, 3, 11]), Op::Store(vec![1, 2, 12]), Op::Store(vec![1, 1, 13])], ctrl: Ctrl::Return(24, vec![14]) }), (G::from_u64(40), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Store(vec![1, 6, 8]), Op::Store(vec![1, 5, 9]), Op::Store(vec![1, 4, 10]), Op::Store(vec![1, 3, 11]), Op::Store(vec![1, 2, 12]), Op::Store(vec![1, 1, 13])], ctrl: Ctrl::Return(25, vec![14]) }), (G::from_u64(41), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Store(vec![1, 5, 7]), Op::Store(vec![1, 4, 8]), Op::Store(vec![1, 3, 9]), Op::Store(vec![1, 2, 10])], ctrl: Ctrl::Return(26, vec![11]) }), (G::from_u64(42), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Store(vec![1, 5, 7]), Op::Store(vec![1, 4, 8]), Op::Store(vec![1, 3, 9]), Op::Store(vec![1, 2, 10])], ctrl: Ctrl::Return(27, vec![11]) }), (G::from_u64(43), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Store(vec![1, 6, 8]), Op::Store(vec![1, 5, 9]), Op::Store(vec![1, 4, 10]), Op::Store(vec![1, 3, 11]), Op::Store(vec![1, 2, 12])], ctrl: Ctrl::Return(28, vec![13]) }), (G::from_u64(44), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Store(vec![1, 6, 8]), Op::Store(vec![1, 5, 9]), Op::Store(vec![1, 4, 10]), Op::Store(vec![1, 3, 11]), Op::Store(vec![1, 2, 12]), Op::Store(vec![1, 1, 13])], ctrl: Ctrl::Return(29, vec![14]) }), (G::from_u64(45), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(66)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Store(vec![1, 7, 9]), Op::Store(vec![1, 6, 10]), Op::Store(vec![1, 5, 11]), Op::Store(vec![1, 4, 12]), Op::Store(vec![1, 3, 13]), Op::Store(vec![1, 2, 14]), Op::Store(vec![1, 1, 15])], ctrl: Ctrl::Return(30, vec![16]) }), (G::from_u64(46), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(66)), Op::Const(G::from_u64(68)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Store(vec![1, 5, 7]), Op::Store(vec![1, 4, 8]), Op::Store(vec![1, 3, 9]), Op::Store(vec![1, 2, 10]), Op::Store(vec![1, 1, 11])], ctrl: Ctrl::Return(31, vec![12]) }), (G::from_u64(47), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Store(vec![1, 3, 5]), Op::Store(vec![1, 2, 6]), Op::Store(vec![1, 1, 7])], ctrl: Ctrl::Return(32, vec![8]) }), (G::from_u64(48), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(41)), Op::Const(G::from_u64(43)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Store(vec![1, 7, 9]), Op::Store(vec![1, 6, 10]), Op::Store(vec![1, 5, 11]), Op::Store(vec![1, 4, 12]), Op::Store(vec![1, 3, 13]), Op::Store(vec![1, 2, 14]), Op::Store(vec![1, 1, 15])], ctrl: Ctrl::Return(33, vec![16]) }), (G::from_u64(49), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![1, 4, 6]), Op::Store(vec![1, 3, 7]), Op::Store(vec![1, 2, 8]), Op::Store(vec![1, 1, 9])], ctrl: Ctrl::Return(34, vec![10]) }), (G::from_u64(50), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Store(vec![1, 5, 7]), Op::Store(vec![1, 4, 8]), Op::Store(vec![1, 3, 9]), Op::Store(vec![1, 2, 10]), Op::Store(vec![1, 1, 11])], ctrl: Ctrl::Return(35, vec![12]) }), (G::from_u64(51), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(76)), Op::Const(G::from_u64(75)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Store(vec![1, 5, 7]), Op::Store(vec![1, 4, 8]), Op::Store(vec![1, 3, 9]), Op::Store(vec![1, 2, 10])], ctrl: Ctrl::Return(36, vec![11]) }), (G::from_u64(52), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Store(vec![1, 5, 7]), Op::Store(vec![1, 4, 8]), Op::Store(vec![1, 3, 9]), Op::Store(vec![1, 2, 10]), Op::Store(vec![1, 1, 11])], ctrl: Ctrl::Return(37, vec![12]) }), (G::from_u64(53), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Store(vec![1, 3, 5]), Op::Store(vec![1, 2, 6]), Op::Store(vec![1, 1, 7])], ctrl: Ctrl::Return(38, vec![8]) }), (G::from_u64(54), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(48)), Op::Const(G::from_u64(75)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Store(vec![1, 5, 7]), Op::Store(vec![1, 4, 8]), Op::Store(vec![1, 3, 9]), Op::Store(vec![1, 2, 10]), Op::Store(vec![1, 1, 11])], ctrl: Ctrl::Return(39, vec![12]) }), (G::from_u64(55), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(74)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Store(vec![1, 5, 7]), Op::Store(vec![1, 4, 8]), Op::Store(vec![1, 3, 9]), Op::Store(vec![1, 2, 10]), Op::Store(vec![1, 1, 11])], ctrl: Ctrl::Return(40, vec![12]) }), (G::from_u64(56), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(75)), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Store(vec![1, 8, 10]), Op::Store(vec![1, 7, 11]), Op::Store(vec![1, 6, 12]), Op::Store(vec![1, 5, 13]), Op::Store(vec![1, 4, 14]), Op::Store(vec![1, 3, 15]), Op::Store(vec![1, 2, 16]), Op::Store(vec![1, 1, 17])], ctrl: Ctrl::Return(41, vec![18]) }), (G::from_u64(57), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(83)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Store(vec![1, 5, 7]), Op::Store(vec![1, 4, 8]), Op::Store(vec![1, 3, 9]), Op::Store(vec![1, 2, 10]), Op::Store(vec![1, 1, 11])], ctrl: Ctrl::Return(42, vec![12]) }), (G::from_u64(58), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(83)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(45)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Store(vec![1, 7, 9]), Op::Store(vec![1, 6, 10]), Op::Store(vec![1, 5, 11]), Op::Store(vec![1, 4, 12]), Op::Store(vec![1, 3, 13]), Op::Store(vec![1, 2, 14]), Op::Store(vec![1, 1, 15])], ctrl: Ctrl::Return(43, vec![16]) }), (G::from_u64(59), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Store(vec![1, 6, 8]), Op::Store(vec![1, 5, 9]), Op::Store(vec![1, 4, 10]), Op::Store(vec![1, 3, 11]), Op::Store(vec![1, 2, 12])], ctrl: Ctrl::Return(44, vec![13]) }), (G::from_u64(60), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(29)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(88)), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Store(vec![1, 7, 9]), Op::Store(vec![1, 6, 10]), Op::Store(vec![1, 5, 11]), Op::Store(vec![1, 4, 12]), Op::Store(vec![1, 3, 13]), Op::Store(vec![1, 2, 14])], ctrl: Ctrl::Return(45, vec![15]) }), (G::from_u64(61), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(29)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Store(vec![1, 3, 5]), Op::Store(vec![1, 2, 6])], ctrl: Ctrl::Return(46, vec![7]) }), (G::from_u64(62), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(29)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(91)), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Store(vec![1, 7, 9]), Op::Store(vec![1, 6, 10]), Op::Store(vec![1, 5, 11]), Op::Store(vec![1, 4, 12]), Op::Store(vec![1, 3, 13]), Op::Store(vec![1, 2, 14])], ctrl: Ctrl::Return(47, vec![15]) }), (G::from_u64(63), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![1, 4, 6]), Op::Store(vec![1, 3, 7]), Op::Store(vec![1, 2, 8])], ctrl: Ctrl::Return(48, vec![9]) }), (G::from_u64(64), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(46)), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Store(vec![1, 7, 9]), Op::Store(vec![1, 6, 10]), Op::Store(vec![1, 5, 11]), Op::Store(vec![1, 4, 12]), Op::Store(vec![1, 3, 13]), Op::Store(vec![1, 2, 14]), Op::Store(vec![1, 1, 15])], ctrl: Ctrl::Return(49, vec![16]) }), (G::from_u64(65), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(65)), Op::Const(G::from_u64(94)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Store(vec![1, 8, 10]), Op::Store(vec![1, 7, 11]), Op::Store(vec![1, 6, 12]), Op::Store(vec![1, 5, 13]), Op::Store(vec![1, 4, 14]), Op::Store(vec![1, 3, 15]), Op::Store(vec![1, 2, 16]), Op::Store(vec![1, 1, 17])], ctrl: Ctrl::Return(50, vec![18]) }), (G::from_u64(66), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(59)), Op::Const(G::from_u64(94)), Op::Const(G::from_u64(76)), Op::Const(G::from_u64(96)), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Store(vec![1, 7, 9]), Op::Store(vec![1, 6, 10]), Op::Store(vec![1, 5, 11]), Op::Store(vec![1, 4, 12]), Op::Store(vec![1, 3, 13]), Op::Store(vec![1, 2, 14]), Op::Store(vec![1, 1, 15])], ctrl: Ctrl::Return(51, vec![16]) }), (G::from_u64(67), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(94)), Op::Const(G::from_u64(76)), Op::Const(G::from_u64(77)), Op::Const(G::from_u64(80)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11]), Op::Store(vec![1, 10, 12]), Op::Store(vec![1, 9, 13]), Op::Store(vec![1, 8, 14]), Op::Store(vec![1, 7, 15]), Op::Store(vec![1, 6, 16]), Op::Store(vec![1, 5, 17]), Op::Store(vec![1, 4, 18]), Op::Store(vec![1, 3, 19]), Op::Store(vec![1, 2, 20]), Op::Store(vec![1, 1, 21])], ctrl: Ctrl::Return(52, vec![22]) }), (G::from_u64(68), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(70)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(93)), Op::Const(G::from_u64(94)), Op::Const(G::from_u64(76)), Op::Const(G::from_u64(80)), Op::Const(G::from_u64(81)), Op::Const(G::from_u64(97)), Op::Const(G::from_u64(67)), Op::Const(G::from_u64(1)), Op::Store(vec![11, 11, 11]), Op::Store(vec![1, 10, 12]), Op::Store(vec![1, 9, 13]), Op::Store(vec![1, 8, 14]), Op::Store(vec![1, 7, 15]), Op::Store(vec![1, 6, 16]), Op::Store(vec![1, 5, 17]), Op::Store(vec![1, 4, 18]), Op::Store(vec![1, 3, 19]), Op::Store(vec![1, 2, 20]), Op::Store(vec![1, 1, 21])], ctrl: Ctrl::Return(53, vec![22]) }), (G::from_u64(69), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(40)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(47)), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Store(vec![1, 7, 9]), Op::Store(vec![1, 6, 10]), Op::Store(vec![1, 5, 11]), Op::Store(vec![1, 4, 12]), Op::Store(vec![1, 3, 13]), Op::Store(vec![1, 2, 14]), Op::Store(vec![1, 1, 15])], ctrl: Ctrl::Return(54, vec![16]) }), (G::from_u64(70), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(29)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(42)), Op::Const(G::from_u64(100)), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Store(vec![1, 8, 10]), Op::Store(vec![1, 7, 11]), Op::Store(vec![1, 6, 12]), Op::Store(vec![1, 5, 13]), Op::Store(vec![1, 4, 14]), Op::Store(vec![1, 3, 15]), Op::Store(vec![1, 2, 16]), Op::Store(vec![1, 1, 17])], ctrl: Ctrl::Return(55, vec![18]) }), (G::from_u64(71), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(37)), Op::Const(G::from_u64(29)), Op::Const(G::from_u64(39)), Op::Const(G::from_u64(40)), Op::Const(G::from_u64(38)), Op::Const(G::from_u64(8)), Op::Const(G::from_u64(44)), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Store(vec![1, 8, 10]), Op::Store(vec![1, 7, 11]), Op::Store(vec![1, 6, 12]), Op::Store(vec![1, 5, 13]), Op::Store(vec![1, 4, 14]), Op::Store(vec![1, 3, 15]), Op::Store(vec![1, 2, 16]), Op::Store(vec![1, 1, 17])], ctrl: Ctrl::Return(56, vec![18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![1, 1, 1])], ctrl: Ctrl::Return(57, vec![2]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 58, auxiliaries: 59, lookups: 12 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_552() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(18), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![1]) }), (G::from_u64(19), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![1]) }), (G::from_u64(20), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(6, vec![1]) }), (G::from_u64(21), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(7, vec![1]) }), (G::from_u64(22), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(8, vec![1]) }), (G::from_u64(29), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(9, vec![1]) }), (G::from_u64(30), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(10, vec![1]) }), (G::from_u64(31), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(11, vec![1]) }), (G::from_u64(37), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(12, vec![1]) }), (G::from_u64(38), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(13, vec![1]) }), (G::from_u64(39), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(14, vec![1]) }), (G::from_u64(40), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(15, vec![1]) }), (G::from_u64(41), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(16, vec![1]) }), (G::from_u64(42), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(17, vec![1]) }), (G::from_u64(43), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(18, vec![1]) }), (G::from_u64(44), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(19, vec![1]) }), (G::from_u64(45), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(20, vec![1]) }), (G::from_u64(46), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(21, vec![1]) }), (G::from_u64(47), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(22, vec![1]) }), (G::from_u64(48), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(23, vec![1]) }), (G::from_u64(49), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(24, vec![1]) }), (G::from_u64(50), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(25, vec![1]) }), (G::from_u64(51), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(26, vec![1]) }), (G::from_u64(52), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(27, vec![1]) }), (G::from_u64(53), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(28, vec![1]) }), (G::from_u64(54), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(29, vec![1]) }), (G::from_u64(55), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(30, vec![1]) }), (G::from_u64(56), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(31, vec![1]) }), (G::from_u64(57), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(32, vec![1]) }), (G::from_u64(58), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(33, vec![1]) }), (G::from_u64(59), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(34, vec![1]) }), (G::from_u64(60), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(35, vec![1]) }), (G::from_u64(61), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(36, vec![1]) }), (G::from_u64(62), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(37, vec![1]) }), (G::from_u64(63), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(38, vec![1]) }), (G::from_u64(64), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(39, vec![1]) }), (G::from_u64(65), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(40, vec![1]) }), (G::from_u64(66), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(41, vec![1]) }), (G::from_u64(67), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(42, vec![1]) }), (G::from_u64(68), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(43, vec![1]) }), (G::from_u64(69), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(44, vec![1]) }), (G::from_u64(70), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(45, vec![1]) }), (G::from_u64(71), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(46, vec![1]) }), (G::from_u64(72), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(47, vec![1]) }), (G::from_u64(73), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(48, vec![1]) }), (G::from_u64(74), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(49, vec![1]) }), (G::from_u64(75), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(50, vec![1]) }), (G::from_u64(76), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(51, vec![1]) }), (G::from_u64(77), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(52, vec![1]) }), (G::from_u64(78), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(53, vec![1]) }), (G::from_u64(79), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(54, vec![1]) }), (G::from_u64(80), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(55, vec![1]) }), (G::from_u64(81), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(56, vec![1]) }), (G::from_u64(82), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(57, vec![1]) }), (G::from_u64(83), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(58, vec![1]) }), (G::from_u64(84), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(59, vec![1]) }), (G::from_u64(85), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(60, vec![1]) }), (G::from_u64(86), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(61, vec![1]) }), (G::from_u64(87), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(62, vec![1]) }), (G::from_u64(88), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(63, vec![1]) }), (G::from_u64(89), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(64, vec![1]) }), (G::from_u64(90), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(65, vec![1]) }), (G::from_u64(91), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(66, vec![1]) }), (G::from_u64(92), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(67, vec![1]) }), (G::from_u64(93), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(68, vec![1]) }), (G::from_u64(94), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(69, vec![1]) }), (G::from_u64(95), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(70, vec![1]) }), (G::from_u64(96), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(71, vec![1]) }), (G::from_u64(97), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(72, vec![1]) }), (G::from_u64(98), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(73, vec![1]) }), (G::from_u64(99), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(74, vec![1]) }), (G::from_u64(100), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(75, vec![1]) }), (G::from_u64(101), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(76, vec![1]) }), (G::from_u64(102), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(77, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(78, vec![1]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 79, auxiliaries: 79, lookups: 1 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_553() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(10), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(4, vec![1]) }), (G::from_u64(11), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![1]) }), (G::from_u64(12), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(6, vec![1]) }), (G::from_u64(13), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(7, vec![1]) }), (G::from_u64(15), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(8, vec![1]) }), (G::from_u64(17), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(9, vec![1]) }), (G::from_u64(22), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(10, vec![1]) }), (G::from_u64(25), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(11, vec![1]) }), (G::from_u64(26), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(12, vec![1]) }), (G::from_u64(27), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(13, vec![1]) }), (G::from_u64(28), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(14, vec![1]) }), (G::from_u64(29), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(15, vec![1]) }), (G::from_u64(30), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(16, vec![1]) }), (G::from_u64(31), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(17, vec![1]) }), (G::from_u64(32), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(18, vec![1]) }), (G::from_u64(33), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(19, vec![1]) }), (G::from_u64(34), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(20, vec![1]) }), (G::from_u64(35), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(21, vec![1]) }), (G::from_u64(36), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(22, vec![1]) }), (G::from_u64(57), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(23, vec![1]) }), (G::from_u64(58), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(24, vec![1]) }), (G::from_u64(91), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(25, vec![1]) }), (G::from_u64(93), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(26, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(27, vec![1]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 28, auxiliaries: 28, lookups: 1 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_554() -> 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![1]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(10), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(4, vec![1]) }), (G::from_u64(12), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![1]) }), (G::from_u64(13), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(6, vec![1]) }), (G::from_u64(15), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(7, vec![1]) }), (G::from_u64(17), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(8, vec![1]) }), (G::from_u64(24), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(9, vec![1]) }), (G::from_u64(25), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(10, vec![1]) }), (G::from_u64(27), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(11, vec![1]) }), (G::from_u64(28), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(12, vec![1]) }), (G::from_u64(32), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(13, vec![1]) }), (G::from_u64(33), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(14, vec![1]) }), (G::from_u64(34), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(15, vec![1]) }), (G::from_u64(35), Block { ops: vec![Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(16, vec![1]) }), (G::from_u64(36), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(17, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], 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_555() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1, 2, 1, 2]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(1, vec![1, 2, 3, 2]) }), (G::from_u64(12), Block { ops: vec![Op::Const(G::from_u64(11)), Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![1, 2, 2, 2]) }), (G::from_u64(24), Block { ops: vec![Op::Const(G::from_u64(23)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(3, vec![1, 2, 3, 3]) }), (G::from_u64(27), Block { ops: vec![Op::Const(G::from_u64(26)), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![1, 2, 3, 3]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![1, 1, 1, 1]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 6, auxiliaries: 6, lookups: 1 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_556() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(11), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(23), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(26), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![1]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 6, auxiliaries: 6, lookups: 1 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_557() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![3, 3, 3]), Op::Store(vec![2, 4, 3]), Op::Store(vec![2, 5, 3, 3])], ctrl: Ctrl::Return(0, vec![6]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![2, 4, 6, 3])], ctrl: Ctrl::Return(1, vec![7]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![2, 4, 6, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![8, 7, 7, 3])], ctrl: Ctrl::Return(2, vec![9]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 5], 1, false), Op::Store(vec![4, 6, 3, 5]), Op::Store(vec![5, 5, 5, 5]), Op::Const(G::from_u64(3)), Op::Store(vec![5, 9, 5, 5]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(4)), Op::Store(vec![12, 5, 5]), Op::Store(vec![2, 13, 5, 5]), Op::Store(vec![11, 7, 14, 5]), Op::Call(476, vec![0, 2], 1, false), Op::Store(vec![4, 16, 3, 5]), Op::Store(vec![9, 8, 17, 5]), Op::Store(vec![5, 4, 5, 5]), Op::Store(vec![9, 19, 8, 5]), Op::Call(476, vec![0, 4], 1, false), Op::Store(vec![4, 21, 3, 5]), Op::Store(vec![5, 2, 5, 5]), Op::Store(vec![9, 22, 23, 5]), Op::Store(vec![9, 10, 24, 5]), Op::Store(vec![11, 20, 25, 5]), Op::Store(vec![11, 7, 26, 5]), Op::Store(vec![9, 10, 8, 5]), Op::Store(vec![11, 7, 28, 5]), Op::Store(vec![11, 27, 29, 5]), Op::Store(vec![11, 18, 30, 5]), Op::Store(vec![11, 15, 31, 5])], ctrl: Ctrl::Return(3, vec![32]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![3, 3, 3]), Op::Store(vec![2, 4, 3]), Op::Store(vec![2, 5, 3, 3])], ctrl: Ctrl::Return(4, vec![6]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Const(G::from_u64(0)), Op::Store(vec![2, 4, 6, 7])], ctrl: Ctrl::Return(5, vec![8]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Const(G::from_u64(0)), Op::Store(vec![2, 4, 6, 7])], ctrl: Ctrl::Return(6, vec![8]) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 5], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![4, 6, 3, 7]), Op::Store(vec![7, 7, 7, 7]), Op::Const(G::from_u64(5)), Op::Store(vec![5, 7, 7]), Op::Store(vec![2, 11, 7, 7]), Op::Store(vec![10, 8, 12, 7]), Op::Const(G::from_u64(3)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![4, 15, 3, 7]), Op::Store(vec![14, 9, 16, 7]), Op::Store(vec![7, 2, 7, 7]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![4, 20, 3, 7]), Op::Store(vec![14, 18, 21, 7]), Op::Store(vec![7, 14, 7, 7]), Op::Store(vec![14, 23, 9, 7]), Op::Store(vec![10, 8, 24, 7]), Op::Store(vec![10, 22, 25, 7]), Op::Store(vec![10, 17, 26, 7]), Op::Store(vec![10, 13, 27, 7])], ctrl: Ctrl::Return(7, vec![28]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![4, 5, 5]), Op::Store(vec![3, 6, 5, 5]), Op::Store(vec![5, 5, 5, 5]), Op::Store(vec![5, 3, 5, 5]), Op::Store(vec![5, 5, 5]), Op::Store(vec![3, 10, 5, 5]), Op::Store(vec![2, 9, 11, 5]), Op::Store(vec![2, 8, 12, 5]), Op::Store(vec![2, 7, 13, 5])], ctrl: Ctrl::Return(8, vec![14]) }), (G::from_u64(9), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 3]), Op::Store(vec![3, 3, 3, 3]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(1)), Op::Store(vec![7, 4, 3, 3]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 11], 1, false), Op::Store(vec![7, 7, 7]), Op::Store(vec![3, 4, 13]), Op::Store(vec![10, 12, 14, 3]), Op::Store(vec![3, 7, 3, 3]), Op::Store(vec![9, 15, 16, 3]), Op::Store(vec![9, 17, 5, 3]), Op::Store(vec![9, 18, 5, 3]), Op::Store(vec![6, 5, 19, 3]), Op::Store(vec![6, 8, 20, 3])], ctrl: Ctrl::Return(9, vec![21]) }), (G::from_u64(10), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 4]), Op::Store(vec![4, 4, 4, 4]), Op::Store(vec![4, 3, 4, 4]), Op::Store(vec![3, 3, 3]), Op::Store(vec![4, 5, 8]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 11], 1, false), Op::Store(vec![10, 12, 9, 4]), Op::Store(vec![4, 10, 4, 4]), Op::Const(G::from_u64(3)), Op::Store(vec![4, 15, 4, 4]), Op::Const(G::from_u64(5)), Op::Store(vec![3, 5, 4, 4]), Op::Store(vec![15, 13, 14, 4]), Op::Store(vec![15, 19, 7, 4]), Op::Store(vec![15, 20, 6, 4]), Op::Store(vec![2, 4, 4]), Op::Store(vec![3, 22, 4, 4]), Op::Store(vec![17, 21, 23, 4]), Op::Store(vec![17, 7, 24, 4]), Op::Store(vec![15, 6, 7, 4]), Op::Const(G::from_u64(9)), Op::Call(476, vec![0, 27], 1, false), Op::Store(vec![10, 28, 9, 4]), Op::Store(vec![15, 29, 14, 4]), Op::Store(vec![15, 30, 7, 4]), Op::Store(vec![15, 26, 31, 4]), Op::Store(vec![4, 2, 4, 4]), Op::Store(vec![15, 13, 33, 4]), Op::Store(vec![15, 34, 16, 4]), Op::Store(vec![15, 35, 6, 4]), Op::Store(vec![15, 16, 7, 4]), Op::Store(vec![15, 37, 6, 4]), Op::Store(vec![17, 36, 38, 4]), Op::Store(vec![17, 16, 39, 4]), Op::Store(vec![17, 32, 40, 4]), Op::Store(vec![17, 25, 41, 4]), Op::Store(vec![17, 6, 42, 4]), Op::Store(vec![17, 18, 43, 4])], ctrl: Ctrl::Return(10, vec![44]) }), (G::from_u64(11), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![3, 4, 4]), Op::Store(vec![2, 5, 4, 4])], ctrl: Ctrl::Return(11, vec![6]) }), (G::from_u64(12), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(11)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(4)), Op::Store(vec![6, 5, 5]), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Store(vec![5, 7, 9]), Op::Store(vec![2, 4, 10, 5])], ctrl: Ctrl::Return(12, vec![11]) }), (G::from_u64(13), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(1)), Op::Store(vec![3, 4, 2]), Op::Store(vec![4, 4, 4]), Op::Store(vec![2, 5, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(11)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 2]), Op::Store(vec![2, 2, 2, 2]), Op::Const(G::from_u64(5)), Op::Store(vec![3, 2, 2]), Op::Store(vec![4, 14, 2, 2]), Op::Store(vec![13, 11, 15, 2]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(12)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![8, 19, 7, 2]), Op::Store(vec![17, 12, 20, 2]), Op::Store(vec![2, 8, 2, 2]), Op::Store(vec![17, 22, 12, 2]), Op::Store(vec![13, 11, 23, 2]), Op::Store(vec![13, 21, 24, 2]), Op::Store(vec![13, 16, 25, 2])], ctrl: Ctrl::Return(13, vec![26]) }), (G::from_u64(14), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![3, 3, 3]), Op::Store(vec![2, 4, 3]), Op::Store(vec![2, 5, 3, 3])], ctrl: Ctrl::Return(14, vec![6]) }), (G::from_u64(15), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(14)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Const(G::from_u64(0)), Op::Store(vec![2, 4, 6, 7]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(4)), Op::Store(vec![10, 7, 7]), Op::Store(vec![5, 11, 7, 7]), Op::Store(vec![9, 8, 12, 7]), Op::Const(G::from_u64(3)), Op::Store(vec![7, 5, 7, 7]), Op::Store(vec![7, 7, 7, 7]), Op::Store(vec![14, 15, 16, 7]), Op::Store(vec![9, 8, 17, 7]), Op::Store(vec![9, 13, 18, 7])], ctrl: Ctrl::Return(15, vec![19]) }), (G::from_u64(17), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(16)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Const(G::from_u64(0)), Op::Store(vec![2, 4, 6, 7]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(4)), Op::Store(vec![10, 7, 7]), Op::Store(vec![5, 11, 7, 7]), Op::Store(vec![9, 8, 12, 7]), Op::Const(G::from_u64(3)), Op::Store(vec![7, 5, 7, 7]), Op::Store(vec![7, 7, 7, 7]), Op::Store(vec![14, 15, 16, 7]), Op::Store(vec![9, 8, 17, 7]), Op::Store(vec![9, 13, 18, 7])], ctrl: Ctrl::Return(16, vec![19]) }), (G::from_u64(19), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(18)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Const(G::from_u64(0)), Op::Store(vec![2, 4, 6, 7])], ctrl: Ctrl::Return(17, vec![8]) }), (G::from_u64(20), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![3, 3, 3]), Op::Store(vec![2, 4, 3, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![6, 5, 5, 3]), Op::Store(vec![6, 5, 7, 3])], ctrl: Ctrl::Return(18, vec![8]) }), (G::from_u64(21), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![3, 3, 3]), Op::Store(vec![2, 4, 3, 3]), Op::Store(vec![3, 2, 3, 3]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(20)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![2, 2, 2]), Op::Store(vec![9, 11, 12, 3]), Op::Store(vec![3, 8, 3, 3]), Op::Store(vec![8, 13, 14, 3]), Op::Store(vec![3, 9, 3, 3]), Op::Store(vec![8, 15, 16, 3]), Op::Store(vec![7, 6, 17, 3]), Op::Store(vec![7, 6, 18, 3]), Op::Store(vec![7, 5, 19, 3]), Op::Store(vec![7, 5, 20, 3])], ctrl: Ctrl::Return(19, vec![21]) }), (G::from_u64(22), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![3, 3, 3]), Op::Store(vec![2, 4, 3, 3]), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(20)), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![7, 9, 6, 3]), Op::Store(vec![3, 2, 3, 3]), Op::Store(vec![3, 3, 3, 3]), Op::Store(vec![3, 7, 3, 3]), Op::Const(G::from_u64(3)), Op::Store(vec![3, 14, 3, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![14, 10, 11, 3]), Op::Store(vec![14, 17, 12, 3]), Op::Const(G::from_u64(4)), Op::Store(vec![19, 3, 3]), Op::Store(vec![2, 20, 3, 3]), Op::Store(vec![16, 18, 21, 3]), Op::Const(G::from_u64(21)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![7, 24, 6, 3]), Op::Store(vec![3, 19, 3, 3]), Op::Store(vec![14, 25, 26, 3]), Op::Store(vec![14, 27, 15, 3]), Op::Store(vec![14, 28, 11, 3]), Op::Store(vec![14, 29, 12, 3]), Op::Store(vec![14, 13, 30, 3]), Op::Store(vec![16, 13, 31, 3]), Op::Store(vec![16, 13, 32, 3]), Op::Store(vec![14, 10, 15, 3]), Op::Store(vec![14, 34, 13, 3]), Op::Store(vec![14, 13, 12, 3]), Op::Store(vec![16, 35, 36, 3]), Op::Store(vec![16, 33, 37, 3]), Op::Store(vec![16, 22, 38, 3]), Op::Store(vec![16, 5, 39, 3]), Op::Store(vec![16, 5, 40, 3])], ctrl: Ctrl::Return(20, vec![41]) }), (G::from_u64(23), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![3, 3, 3]), Op::Store(vec![2, 4, 3, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![6, 5, 5, 3]), Op::Store(vec![6, 5, 7, 3])], ctrl: Ctrl::Return(21, vec![8]) }), (G::from_u64(24), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![3, 3, 3]), Op::Store(vec![2, 4, 3, 3]), Op::Store(vec![3, 2, 3, 3]), Op::Const(G::from_u64(3)), Op::Store(vec![3, 7, 3, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![9, 6, 6, 3]), Op::Store(vec![9, 6, 8, 3]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(23)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![2, 2, 2]), Op::Store(vec![12, 14, 15, 3]), Op::Store(vec![7, 16, 8, 3]), Op::Store(vec![3, 12, 3, 3]), Op::Store(vec![7, 17, 18, 3]), Op::Store(vec![9, 11, 19, 3]), Op::Store(vec![9, 10, 20, 3]), Op::Store(vec![9, 5, 21, 3]), Op::Store(vec![9, 5, 22, 3])], ctrl: Ctrl::Return(22, vec![23]) }), (G::from_u64(25), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![3, 3, 3]), Op::Store(vec![2, 4, 3, 3]), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(23)), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![7, 9, 6, 3]), Op::Store(vec![3, 2, 3, 3]), Op::Store(vec![3, 3, 3, 3]), Op::Store(vec![3, 7, 3, 3]), Op::Const(G::from_u64(4)), Op::Store(vec![3, 14, 3, 3]), Op::Const(G::from_u64(3)), Op::Store(vec![3, 16, 3, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![16, 10, 11, 3]), Op::Store(vec![16, 19, 12, 3]), Op::Store(vec![14, 3, 3]), Op::Store(vec![2, 21, 3, 3]), Op::Store(vec![18, 20, 22, 3]), Op::Store(vec![18, 13, 13, 3]), Op::Store(vec![18, 13, 15, 3]), Op::Const(G::from_u64(24)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![7, 27, 6, 3]), Op::Store(vec![16, 28, 15, 3]), Op::Store(vec![16, 29, 17, 3]), Op::Store(vec![16, 30, 11, 3]), Op::Store(vec![16, 31, 12, 3]), Op::Store(vec![16, 13, 32, 3]), Op::Store(vec![18, 25, 33, 3]), Op::Store(vec![18, 24, 34, 3]), Op::Store(vec![16, 10, 17, 3]), Op::Store(vec![16, 36, 13, 3]), Op::Store(vec![16, 13, 12, 3]), Op::Store(vec![18, 37, 38, 3]), Op::Store(vec![18, 35, 39, 3]), Op::Store(vec![18, 23, 40, 3]), Op::Store(vec![18, 5, 41, 3]), Op::Store(vec![18, 5, 42, 3])], ctrl: Ctrl::Return(23, vec![43]) }), (G::from_u64(26), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![4, 5, 5]), Op::Store(vec![3, 6, 5, 5]), Op::Store(vec![5, 5, 5]), Op::Store(vec![3, 8, 5, 5]), Op::Store(vec![2, 7, 9, 5])], ctrl: Ctrl::Return(24, vec![10]) }), (G::from_u64(27), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 3]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 4, 3, 3]), Op::Store(vec![3, 3, 3, 3]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(26)), Op::Call(476, vec![0, 11], 1, false), Op::Store(vec![6, 6, 6]), Op::Store(vec![3, 4, 13]), Op::Store(vec![10, 12, 14, 3]), Op::Store(vec![3, 6, 3, 3]), Op::Store(vec![9, 15, 16, 3]), Op::Store(vec![5, 8, 17, 3]), Op::Store(vec![5, 7, 18, 3])], ctrl: Ctrl::Return(25, vec![19]) }), (G::from_u64(28), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 3]), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![3, 4, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(26)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 3]), Op::Store(vec![3, 3, 3, 3]), Op::Store(vec![3, 5, 3, 3]), Op::Store(vec![3, 8, 3, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![5, 4, 3, 3]), Op::Const(G::from_u64(3)), Op::Store(vec![17, 11, 12, 3]), Op::Store(vec![3, 3, 3]), Op::Store(vec![5, 19, 3, 3]), Op::Store(vec![15, 18, 20, 3]), Op::Const(G::from_u64(27)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![8, 23, 7, 3]), Op::Store(vec![17, 24, 14, 3]), Op::Store(vec![17, 25, 12, 3]), Op::Store(vec![17, 13, 26, 3]), Op::Store(vec![15, 13, 27, 3]), Op::Store(vec![17, 11, 14, 3]), Op::Store(vec![17, 14, 12, 3]), Op::Store(vec![15, 29, 30, 3]), Op::Store(vec![15, 28, 31, 3]), Op::Store(vec![15, 21, 32, 3]), Op::Store(vec![15, 16, 33, 3])], ctrl: Ctrl::Return(26, vec![34]) }), (G::from_u64(29), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![3, 4, 4]), Op::Store(vec![2, 5, 4]), Op::Store(vec![2, 6, 4, 4]), Op::Const(G::from_u64(5)), Op::Store(vec![8, 7, 7, 4])], ctrl: Ctrl::Return(27, vec![9]) }), (G::from_u64(30), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 3]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 4, 3]), Op::Store(vec![6, 7, 3, 3]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(29)), Op::Call(476, vec![0, 11], 1, false), Op::Store(vec![6, 6, 6]), Op::Store(vec![3, 4, 13]), Op::Store(vec![10, 12, 14, 3]), Op::Store(vec![3, 3, 3, 3]), Op::Store(vec![9, 15, 16, 3]), Op::Store(vec![5, 8, 17, 3])], ctrl: Ctrl::Return(28, vec![18]) }), (G::from_u64(31), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 3]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(29)), Op::Call(476, vec![0, 6], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Store(vec![3, 4, 9]), Op::Store(vec![5, 7, 10, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![8, 4, 3]), Op::Store(vec![8, 13, 3, 3]), Op::Store(vec![3, 3, 3, 3]), Op::Const(G::from_u64(3)), Op::Store(vec![3, 8, 3, 3]), Op::Store(vec![16, 11, 17, 3]), Op::Store(vec![3, 5, 3, 3]), Op::Store(vec![16, 11, 19, 3]), Op::Store(vec![12, 18, 20, 3]), Op::Store(vec![12, 15, 21, 3]), Op::Store(vec![12, 14, 22, 3])], ctrl: Ctrl::Return(29, vec![23]) }), (G::from_u64(32), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![3, 4, 4]), Op::Store(vec![2, 5, 4, 4]), Op::Const(G::from_u64(5)), Op::Store(vec![4, 4, 4, 4]), Op::Store(vec![4, 2, 4, 4]), Op::Store(vec![4, 4, 4]), Op::Store(vec![2, 10, 4, 4]), Op::Store(vec![7, 9, 11, 4]), Op::Store(vec![7, 8, 12, 4]), Op::Store(vec![7, 13, 6, 4]), Op::Store(vec![7, 6, 14, 4])], ctrl: Ctrl::Return(30, vec![15]) }), (G::from_u64(33), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 3]), Op::Const(G::from_u64(1)), Op::Store(vec![3, 5, 3, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![5, 4, 3, 3]), Op::Store(vec![3, 3, 3, 3]), Op::Store(vec![3, 3, 3]), Op::Store(vec![5, 10, 3, 3]), Op::Store(vec![7, 6, 11, 3]), Op::Store(vec![7, 9, 12, 3]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(32)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![5, 5, 5]), Op::Store(vec![3, 4, 18]), Op::Store(vec![15, 17, 19, 3]), Op::Store(vec![3, 15, 3, 3]), Op::Store(vec![14, 20, 21, 3]), Op::Store(vec![14, 22, 6, 3]), Op::Store(vec![7, 6, 23, 3]), Op::Store(vec![7, 13, 24, 3]), Op::Store(vec![7, 8, 25, 3])], ctrl: Ctrl::Return(31, vec![26]) }), (G::from_u64(34), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 3]), Op::Store(vec![3, 3, 3, 3]), Op::Const(G::from_u64(1)), Op::Store(vec![3, 6, 3, 3]), Op::Store(vec![2, 6, 3]), Op::Const(G::from_u64(2)), Op::Store(vec![3, 9, 3, 3]), Op::Const(G::from_u64(3)), Op::Store(vec![3, 11, 3, 3]), Op::Store(vec![3, 2, 3, 3]), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(5)), Op::Store(vec![6, 4, 3, 3]), Op::Store(vec![3, 3, 3]), Op::Store(vec![6, 17, 3, 3]), Op::Store(vec![15, 7, 18, 3]), Op::Store(vec![15, 5, 19, 3]), Op::Store(vec![6, 8, 3, 3]), Op::Store(vec![15, 10, 7, 3]), Op::Store(vec![11, 13, 7, 3]), Op::Store(vec![11, 23, 5, 3]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![3, 8, 14]), Op::Store(vec![9, 26, 27, 3]), Op::Store(vec![11, 28, 13, 3]), Op::Store(vec![11, 12, 10, 3]), Op::Store(vec![11, 29, 30, 3]), Op::Store(vec![11, 12, 7, 3]), Op::Store(vec![11, 31, 32, 3]), Op::Store(vec![15, 24, 33, 3]), Op::Store(vec![15, 13, 34, 3]), Op::Store(vec![15, 12, 35, 3]), Op::Const(G::from_u64(32)), Op::Call(476, vec![0, 37], 1, false), Op::Store(vec![3, 4, 14]), Op::Store(vec![9, 38, 39, 3]), Op::Store(vec![11, 40, 13, 3]), Op::Store(vec![11, 41, 12, 3]), Op::Store(vec![15, 42, 12, 3]), Op::Store(vec![15, 36, 43, 3]), Op::Store(vec![15, 22, 44, 3]), Op::Store(vec![15, 21, 45, 3]), Op::Store(vec![15, 20, 46, 3]), Op::Store(vec![15, 16, 47, 3])], ctrl: Ctrl::Return(32, vec![48]) }), (G::from_u64(35), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 3]), Op::Store(vec![3, 3, 3, 3]), Op::Const(G::from_u64(1)), Op::Store(vec![3, 6, 3, 3]), Op::Store(vec![3, 3, 3]), Op::Store(vec![6, 8, 3, 3]), Op::Store(vec![6, 6, 6]), Op::Store(vec![3, 4, 10]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(32)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![12, 14, 11, 3]), Op::Store(vec![3, 12, 3, 3]), Op::Const(G::from_u64(3)), Op::Store(vec![3, 17, 3, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![6, 4, 3, 3]), Op::Store(vec![19, 7, 9, 3]), Op::Store(vec![19, 5, 21, 3]), Op::Store(vec![17, 15, 7, 3]), Op::Store(vec![17, 23, 5, 3]), Op::Store(vec![19, 24, 9, 3]), Op::Const(G::from_u64(33)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![12, 27, 11, 3]), Op::Store(vec![17, 28, 18, 3]), Op::Store(vec![17, 29, 16, 3]), Op::Store(vec![17, 30, 5, 3]), Op::Store(vec![17, 7, 31, 3]), Op::Store(vec![19, 16, 32, 3]), Op::Store(vec![17, 15, 18, 3]), Op::Store(vec![17, 34, 16, 3]), Op::Store(vec![17, 16, 5, 3]), Op::Store(vec![19, 35, 36, 3]), Op::Store(vec![19, 33, 37, 3]), Op::Store(vec![19, 25, 38, 3]), Op::Store(vec![19, 22, 39, 3]), Op::Store(vec![19, 20, 40, 3])], ctrl: Ctrl::Return(33, vec![41]) }), (G::from_u64(36), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 3]), Op::Store(vec![3, 3, 3, 3]), Op::Const(G::from_u64(1)), Op::Store(vec![3, 6, 3, 3]), Op::Const(G::from_u64(2)), Op::Store(vec![3, 8, 3, 3]), Op::Store(vec![6, 6, 6]), Op::Store(vec![3, 4, 10]), Op::Store(vec![3, 2, 3, 3]), Op::Const(G::from_u64(3)), Op::Store(vec![3, 13, 3, 3]), Op::Const(G::from_u64(33)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![8, 16, 11, 3]), Op::Store(vec![13, 17, 12, 3]), Op::Store(vec![13, 18, 14, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![6, 4, 3, 3]), Op::Store(vec![3, 3, 3]), Op::Store(vec![6, 22, 3, 3]), Op::Store(vec![20, 7, 23, 3]), Op::Store(vec![20, 5, 24, 3]), Op::Store(vec![13, 9, 7, 3]), Op::Store(vec![13, 26, 5, 3]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 28], 1, false), Op::Store(vec![8, 29, 11, 3]), Op::Const(G::from_u64(32)), Op::Call(476, vec![0, 31], 1, false), Op::Store(vec![8, 32, 11, 3]), Op::Store(vec![13, 33, 12, 3]), Op::Store(vec![13, 34, 14, 3]), Op::Store(vec![13, 30, 35, 3]), Op::Store(vec![13, 19, 9, 3]), Op::Store(vec![13, 36, 37, 3]), Op::Store(vec![13, 19, 7, 3]), Op::Store(vec![13, 38, 39, 3]), Op::Store(vec![20, 27, 40, 3]), Op::Store(vec![20, 9, 41, 3]), Op::Store(vec![20, 7, 42, 3]), Op::Store(vec![20, 25, 43, 3]), Op::Store(vec![20, 21, 44, 3])], ctrl: Ctrl::Return(34, vec![45]) }), (G::from_u64(37), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![3, 3, 3]), Op::Store(vec![2, 4, 3]), Op::Store(vec![2, 5, 3, 3])], ctrl: Ctrl::Return(35, vec![6]) }), (G::from_u64(38), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(29)), Op::Call(476, vec![0, 7], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![9, 9, 9]), Op::Store(vec![9, 10, 3]), Op::Store(vec![6, 8, 11, 9]), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![6, 14, 3, 9]), Op::Store(vec![5, 12, 15, 9]), Op::Const(G::from_u64(37)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![6, 18, 3, 9]), Op::Store(vec![4, 16, 19, 9])], ctrl: Ctrl::Return(36, vec![20]) }), (G::from_u64(39), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![3, 3, 3]), Op::Store(vec![2, 4, 3]), Op::Store(vec![2, 5, 3, 3])], ctrl: Ctrl::Return(37, vec![6]) }), (G::from_u64(40), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![5, 7, 3, 6]), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![5, 10, 3, 6]), Op::Store(vec![4, 8, 11, 6])], ctrl: Ctrl::Return(38, vec![12]) }), (G::from_u64(41), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![2, 4, 6, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![8, 7, 7, 3])], ctrl: Ctrl::Return(39, vec![9]) }), (G::from_u64(42), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![2, 4, 6, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![8, 7, 7, 3]), Op::Store(vec![8, 7, 9, 3])], ctrl: Ctrl::Return(40, vec![10]) }), (G::from_u64(43), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![2, 4, 6, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![8, 7, 7, 3]), Op::Store(vec![8, 7, 9, 3])], ctrl: Ctrl::Return(41, vec![10]) }), (G::from_u64(44), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![2, 4, 6, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![8, 7, 7, 3]), Op::Store(vec![8, 7, 9, 3])], ctrl: Ctrl::Return(42, vec![10]) }), (G::from_u64(45), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![2, 4, 6, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![8, 7, 7, 3]), Op::Store(vec![8, 7, 9, 3])], ctrl: Ctrl::Return(43, vec![10]) }), (G::from_u64(46), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 5], 1, false), Op::Store(vec![4, 6, 3, 5]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![4, 10, 3, 5]), Op::Store(vec![8, 7, 11, 5]), Op::Store(vec![8, 7, 12, 5])], ctrl: Ctrl::Return(44, vec![13]) }), (G::from_u64(47), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 5], 1, false), Op::Store(vec![4, 6, 3, 5]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![4, 10, 3, 5]), Op::Store(vec![8, 7, 11, 5]), Op::Store(vec![8, 7, 12, 5])], ctrl: Ctrl::Return(45, vec![13]) }), (G::from_u64(48), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![2, 4, 6, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![8, 7, 7, 3]), Op::Store(vec![8, 7, 9, 3])], ctrl: Ctrl::Return(46, vec![10]) }), (G::from_u64(49), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![2, 4, 6, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![8, 7, 7, 3]), Op::Store(vec![8, 7, 9, 3])], ctrl: Ctrl::Return(47, vec![10]) }), (G::from_u64(50), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![2, 4, 6, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![8, 7, 7, 3]), Op::Store(vec![8, 7, 9, 3])], ctrl: Ctrl::Return(48, vec![10]) }), (G::from_u64(51), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![2, 4, 6, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![8, 7, 7, 3]), Op::Store(vec![8, 7, 9, 3])], ctrl: Ctrl::Return(49, vec![10]) }), (G::from_u64(52), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![2, 4, 6, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![8, 7, 7, 3]), Op::Store(vec![8, 7, 9, 3])], ctrl: Ctrl::Return(50, vec![10]) }), (G::from_u64(53), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![2, 4, 6, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![8, 7, 7, 3]), Op::Store(vec![8, 7, 9, 3])], ctrl: Ctrl::Return(51, vec![10]) }), (G::from_u64(54), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![2, 4, 6, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![8, 7, 7, 3]), Op::Store(vec![8, 7, 9, 3])], ctrl: Ctrl::Return(52, vec![10]) }), (G::from_u64(55), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![2, 4, 6, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![8, 7, 7, 3]), Op::Store(vec![8, 7, 9, 3])], ctrl: Ctrl::Return(53, vec![10]) }), (G::from_u64(56), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(1)), Op::Store(vec![4, 3, 2, 2]), Op::Store(vec![4, 4, 4]), Op::Store(vec![2, 4, 2, 2]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(23)), Op::Call(476, vec![0, 11], 1, false), Op::Store(vec![10, 12, 6, 2]), Op::Store(vec![9, 13, 7, 2]), Op::Store(vec![2, 2, 2, 2]), Op::Store(vec![9, 14, 15, 2]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![4, 3, 2]), Op::Store(vec![2, 19, 6]), Op::Store(vec![10, 18, 20, 2]), Op::Store(vec![9, 21, 5, 2]), Op::Store(vec![2, 10, 2, 2]), Op::Store(vec![9, 22, 23, 2]), Op::Store(vec![9, 24, 7, 2]), Op::Store(vec![8, 16, 25, 2]), Op::Store(vec![8, 5, 26, 2]), Op::Store(vec![8, 5, 27, 2])], ctrl: Ctrl::Return(54, vec![28]) }), (G::from_u64(57), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 3]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(1)), Op::Store(vec![6, 4, 3, 3]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(26)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![6, 6, 6]), Op::Store(vec![3, 4, 12]), Op::Store(vec![9, 11, 13, 3]), Op::Store(vec![3, 3, 3, 3]), Op::Store(vec![8, 14, 15, 3]), Op::Store(vec![3, 6, 3, 3]), Op::Store(vec![5, 16, 17, 3]), Op::Store(vec![5, 7, 18, 3])], ctrl: Ctrl::Return(55, vec![19]) }), (G::from_u64(58), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![4, 5, 5]), Op::Store(vec![3, 6, 5, 5]), Op::Const(G::from_u64(2)), Op::Call(476, vec![0, 4], 1, false), Op::Store(vec![3, 3, 3]), Op::Store(vec![8, 9, 10, 5]), Op::Store(vec![5, 3, 5, 5]), Op::Store(vec![2, 11, 12, 5]), Op::Store(vec![2, 7, 13, 5])], ctrl: Ctrl::Return(56, vec![14]) }), (G::from_u64(59), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 3, 2, 2]), Op::Store(vec![5, 3, 2]), Op::Store(vec![5, 7, 2, 2]), Op::Store(vec![4, 6, 8, 2])], ctrl: Ctrl::Return(57, vec![9]) }), (G::from_u64(60), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 4]), Op::Store(vec![3, 5, 4, 4]), Op::Store(vec![4, 4, 4, 4]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(59)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![3, 3, 3]), Op::Store(vec![9, 11, 12, 4]), Op::Store(vec![4, 3, 4, 4]), Op::Store(vec![8, 13, 14, 4]), Op::Store(vec![2, 7, 15, 4]), Op::Store(vec![2, 6, 16, 4])], ctrl: Ctrl::Return(58, vec![17]) }), (G::from_u64(61), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5]), Op::Store(vec![2, 6, 5, 5]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(62)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![9, 11, 3, 5]), Op::Store(vec![5, 5, 5, 5]), Op::Store(vec![8, 12, 13, 5]), Op::Const(G::from_u64(59)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![9, 16, 3, 5]), Op::Store(vec![5, 2, 5, 5]), Op::Store(vec![8, 17, 18, 5]), Op::Store(vec![4, 14, 19, 5]), Op::Store(vec![4, 7, 20, 5])], ctrl: Ctrl::Return(59, vec![21]) }), (G::from_u64(62), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![3, 3, 3]), Op::Store(vec![2, 4, 3, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![6, 5, 5, 3])], ctrl: Ctrl::Return(60, vec![7]) }), (G::from_u64(63), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Store(vec![2, 2, 2, 2]), Op::Const(G::from_u64(5)), Op::Store(vec![4, 3, 2, 2]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(59)), Op::Call(476, vec![0, 11], 1, false), Op::Store(vec![10, 12, 5, 2]), Op::Store(vec![9, 13, 6, 2]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![4, 3, 2]), Op::Store(vec![2, 17, 5]), Op::Store(vec![10, 16, 18, 2]), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 20], 1, false), Op::Store(vec![10, 21, 5, 2]), Op::Store(vec![9, 19, 22, 2]), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![10, 25, 5, 2]), Op::Store(vec![2, 4, 2, 2]), Op::Store(vec![9, 26, 27, 2]), Op::Store(vec![9, 28, 6, 2]), Op::Store(vec![9, 23, 29, 2]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 31], 1, false), Op::Store(vec![10, 32, 5, 2]), Op::Store(vec![9, 30, 33, 2]), Op::Store(vec![2, 10, 2, 2]), Op::Store(vec![7, 34, 35, 2]), Op::Store(vec![7, 14, 36, 2]), Op::Store(vec![7, 8, 37, 2])], ctrl: Ctrl::Return(61, vec![38]) }), (G::from_u64(64), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Store(vec![2, 2, 2, 2]), Op::Const(G::from_u64(5)), Op::Store(vec![4, 3, 2, 2]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(59)), Op::Call(476, vec![0, 11], 1, false), Op::Store(vec![10, 12, 5, 2]), Op::Store(vec![9, 13, 6, 2]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![4, 3, 2]), Op::Store(vec![2, 17, 5]), Op::Store(vec![10, 16, 18, 2]), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 20], 1, false), Op::Store(vec![10, 21, 5, 2]), Op::Store(vec![9, 19, 22, 2]), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![10, 25, 5, 2]), Op::Store(vec![2, 4, 2, 2]), Op::Store(vec![9, 26, 27, 2]), Op::Store(vec![9, 28, 6, 2]), Op::Store(vec![9, 23, 29, 2]), Op::Call(476, vec![0, 7], 1, false), Op::Store(vec![10, 31, 5, 2]), Op::Store(vec![9, 30, 32, 2]), Op::Const(G::from_u64(62)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![10, 35, 5, 2]), Op::Store(vec![2, 10, 2, 2]), Op::Store(vec![9, 36, 37, 2]), Op::Store(vec![7, 33, 38, 2]), Op::Store(vec![7, 14, 39, 2]), Op::Store(vec![7, 8, 40, 2])], ctrl: Ctrl::Return(62, vec![41]) }), (G::from_u64(65), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(0)), Op::Store(vec![5, 5, 5]), Op::Store(vec![2, 6, 5, 5]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(59)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![9, 11, 3, 5]), Op::Store(vec![5, 5, 5, 5]), Op::Store(vec![8, 12, 13, 5]), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![9, 16, 3, 5]), Op::Store(vec![4, 14, 17, 5]), Op::Store(vec![4, 7, 18, 5])], ctrl: Ctrl::Return(63, vec![19]) }), (G::from_u64(66), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![2, 4, 6, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![3, 3, 3]), Op::Store(vec![5, 9, 3, 3]), Op::Store(vec![8, 7, 10, 3]), Op::Store(vec![8, 7, 11, 3])], ctrl: Ctrl::Return(64, vec![12]) }), (G::from_u64(67), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 5], 1, false), Op::Store(vec![4, 6, 3, 5]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(59)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![4, 11, 3, 5]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![5, 5, 5]), Op::Store(vec![2, 15, 5]), Op::Store(vec![5, 16, 3]), Op::Store(vec![4, 14, 17, 5]), Op::Store(vec![9, 18, 7, 5]), Op::Store(vec![5, 2, 5, 5]), Op::Store(vec![9, 19, 20, 5]), Op::Store(vec![5, 5, 5, 5]), Op::Store(vec![9, 21, 22, 5]), Op::Store(vec![9, 12, 23, 5]), Op::Store(vec![8, 7, 24, 5]), Op::Store(vec![8, 7, 25, 5])], ctrl: Ctrl::Return(65, vec![26]) }), (G::from_u64(68), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 5], 1, false), Op::Store(vec![4, 6, 3, 5]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(59)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![4, 11, 3, 5]), Op::Const(G::from_u64(66)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![4, 14, 3, 5]), Op::Store(vec![5, 2, 5, 5]), Op::Store(vec![9, 15, 16, 5]), Op::Store(vec![5, 5, 5, 5]), Op::Store(vec![9, 17, 18, 5]), Op::Store(vec![9, 12, 19, 5]), Op::Store(vec![8, 7, 20, 5]), Op::Store(vec![8, 7, 21, 5])], ctrl: Ctrl::Return(66, vec![22]) }), (G::from_u64(69), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 5], 1, false), Op::Store(vec![4, 6, 3, 5]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(59)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![4, 11, 3, 5]), Op::Const(G::from_u64(66)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![4, 14, 3, 5]), Op::Call(476, vec![0, 4], 1, false), Op::Store(vec![4, 16, 3, 5]), Op::Store(vec![5, 2, 5, 5]), Op::Store(vec![9, 17, 18, 5]), Op::Store(vec![9, 15, 19, 5]), Op::Store(vec![5, 5, 5, 5]), Op::Store(vec![9, 20, 21, 5]), Op::Store(vec![9, 12, 22, 5]), Op::Store(vec![8, 7, 23, 5]), Op::Store(vec![8, 7, 24, 5])], ctrl: Ctrl::Return(67, vec![25]) }), (G::from_u64(70), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![3, 3, 3]), Op::Store(vec![2, 4, 3]), Op::Store(vec![2, 5, 3, 3])], ctrl: Ctrl::Return(68, vec![6]) }), (G::from_u64(71), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![5, 7, 3, 6]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![5, 10, 3, 6]), Op::Store(vec![4, 8, 11, 6])], ctrl: Ctrl::Return(69, vec![12]) }), (G::from_u64(72), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![5, 7, 3, 6]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![5, 10, 3, 6]), Op::Store(vec![4, 8, 11, 6])], ctrl: Ctrl::Return(70, vec![12]) }), (G::from_u64(73), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![5, 7, 3, 6]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![5, 10, 3, 6]), Op::Store(vec![4, 8, 11, 6])], ctrl: Ctrl::Return(71, vec![12]) }), (G::from_u64(74), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 5], 1, false), Op::Store(vec![4, 6, 3, 5]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![4, 10, 3, 5]), Op::Store(vec![8, 7, 11, 5]), Op::Store(vec![8, 7, 12, 5])], ctrl: Ctrl::Return(72, vec![13]) }), (G::from_u64(75), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Const(G::from_u64(0)), Op::Store(vec![2, 4, 6, 7]), Op::Const(G::from_u64(5)), Op::Store(vec![9, 8, 8, 7])], ctrl: Ctrl::Return(73, vec![10]) }), (G::from_u64(76), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Const(G::from_u64(0)), Op::Store(vec![2, 4, 6, 7]), Op::Const(G::from_u64(5)), Op::Store(vec![9, 8, 8, 7]), Op::Store(vec![9, 8, 10, 7])], ctrl: Ctrl::Return(74, vec![11]) }), (G::from_u64(77), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Const(G::from_u64(0)), Op::Store(vec![2, 4, 6, 7]), Op::Const(G::from_u64(5)), Op::Store(vec![9, 8, 8, 7]), Op::Store(vec![9, 8, 10, 7])], ctrl: Ctrl::Return(75, vec![11]) }), (G::from_u64(78), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Const(G::from_u64(0)), Op::Store(vec![2, 4, 6, 7]), Op::Const(G::from_u64(5)), Op::Store(vec![9, 8, 8, 7]), Op::Store(vec![9, 8, 10, 7])], ctrl: Ctrl::Return(76, vec![11]) }), (G::from_u64(79), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 6], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![5, 7, 3, 8]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![5, 10, 3, 8]), Op::Store(vec![4, 9, 11, 8])], ctrl: Ctrl::Return(77, vec![12]) }), (G::from_u64(80), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Const(G::from_u64(0)), Op::Store(vec![2, 4, 6, 7]), Op::Const(G::from_u64(5)), Op::Store(vec![9, 8, 8, 7]), Op::Store(vec![9, 8, 10, 7])], ctrl: Ctrl::Return(78, vec![11]) }), (G::from_u64(81), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Const(G::from_u64(0)), Op::Store(vec![2, 4, 6, 7]), Op::Const(G::from_u64(5)), Op::Store(vec![9, 8, 8, 7]), Op::Store(vec![9, 8, 10, 7])], ctrl: Ctrl::Return(79, vec![11]) }), (G::from_u64(82), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 5], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![4, 6, 3, 7]), Op::Const(G::from_u64(5)), Op::Call(476, vec![0, 7], 1, false), Op::Store(vec![4, 10, 3, 7]), Op::Store(vec![9, 11, 8, 7]), Op::Store(vec![9, 8, 12, 7])], ctrl: Ctrl::Return(80, vec![13]) }), (G::from_u64(83), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 4], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Store(vec![3, 5, 7, 4]), Op::Store(vec![4, 4, 4]), Op::Store(vec![6, 9, 4]), Op::Store(vec![6, 10, 4, 4]), Op::Store(vec![2, 8, 11, 4])], ctrl: Ctrl::Return(81, vec![12]) }), (G::from_u64(84), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 5], 1, false), Op::Store(vec![4, 6, 3, 5]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(83)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![4, 11, 3, 5]), Op::Store(vec![5, 2, 5, 5]), Op::Store(vec![9, 12, 13, 5]), Op::Store(vec![8, 7, 14, 5]), Op::Store(vec![8, 7, 15, 5])], ctrl: Ctrl::Return(82, vec![16]) }), (G::from_u64(85), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 5], 1, false), Op::Store(vec![4, 6, 3, 5]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(83)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![4, 11, 3, 5]), Op::Store(vec![5, 5, 5, 5]), Op::Store(vec![9, 12, 13, 5]), Op::Store(vec![8, 14, 7, 5]), Op::Store(vec![8, 7, 15, 5])], ctrl: Ctrl::Return(83, vec![16]) }), (G::from_u64(86), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(83)), Op::Call(476, vec![0, 5], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![4, 6, 3, 7]), Op::Const(G::from_u64(5)), Op::Call(476, vec![0, 7], 1, false), Op::Store(vec![4, 10, 3, 7]), Op::Const(G::from_u64(3)), Op::Store(vec![7, 7, 7, 7]), Op::Store(vec![12, 8, 13, 7]), Op::Store(vec![7, 2, 7, 7]), Op::Store(vec![12, 8, 15, 7]), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![4, 18, 3, 7]), Op::Store(vec![9, 16, 19, 7]), Op::Store(vec![9, 14, 20, 7]), Op::Store(vec![9, 11, 21, 7])], ctrl: Ctrl::Return(84, vec![22]) }), (G::from_u64(87), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(37)), Op::Call(476, vec![0, 5], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![4, 6, 3, 7]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(59)), Op::Call(476, vec![0, 11], 1, false), Op::Store(vec![4, 12, 3, 7]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![7, 7, 7]), Op::Store(vec![2, 16, 7]), Op::Store(vec![7, 17, 3]), Op::Store(vec![4, 15, 18, 7]), Op::Store(vec![10, 19, 8, 7]), Op::Store(vec![7, 2, 7, 7]), Op::Store(vec![10, 20, 21, 7]), Op::Store(vec![7, 7, 7, 7]), Op::Store(vec![10, 22, 23, 7]), Op::Store(vec![10, 13, 24, 7]), Op::Store(vec![9, 8, 25, 7]), Op::Store(vec![9, 8, 26, 7])], ctrl: Ctrl::Return(85, vec![27]) }), (G::from_u64(88), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![3, 3, 3]), Op::Store(vec![2, 4, 3]), Op::Store(vec![2, 5, 3, 3])], ctrl: Ctrl::Return(86, vec![6]) }), (G::from_u64(89), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(88)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Const(G::from_u64(0)), Op::Store(vec![2, 4, 6, 7])], ctrl: Ctrl::Return(87, vec![8]) }), (G::from_u64(90), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(37)), Op::Call(476, vec![0, 6], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![5, 7, 3, 8]), Op::Const(G::from_u64(88)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![5, 11, 3, 8]), Op::Store(vec![4, 9, 12, 8])], ctrl: Ctrl::Return(88, vec![13]) }), (G::from_u64(91), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![2, 3, 3]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(29)), Op::Call(476, vec![0, 6], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Store(vec![3, 4, 9]), Op::Store(vec![5, 7, 10, 3]), Op::Const(G::from_u64(5)), Op::Store(vec![8, 4, 3]), Op::Store(vec![8, 13, 3, 3]), Op::Const(G::from_u64(3)), Op::Store(vec![3, 3, 3, 3]), Op::Store(vec![15, 11, 16, 3]), Op::Store(vec![3, 8, 3, 3]), Op::Store(vec![15, 11, 18, 3]), Op::Store(vec![3, 5, 3, 3]), Op::Store(vec![15, 11, 20, 3]), Op::Store(vec![12, 19, 21, 3]), Op::Store(vec![12, 17, 22, 3]), Op::Store(vec![12, 14, 23, 3])], ctrl: Ctrl::Return(89, vec![24]) }), (G::from_u64(92), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(37)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Const(G::from_u64(0)), Op::Store(vec![2, 4, 6, 7]), Op::Const(G::from_u64(5)), Op::Store(vec![9, 8, 8, 7]), Op::Store(vec![9, 8, 10, 7])], ctrl: Ctrl::Return(90, vec![11]) }), (G::from_u64(93), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![4, 5, 5]), Op::Store(vec![3, 6, 5, 5]), Op::Store(vec![5, 5, 5]), Op::Store(vec![3, 8, 5, 5]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(59)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![3, 3, 3]), Op::Store(vec![11, 13, 14, 5]), Op::Store(vec![5, 5, 5, 5]), Op::Store(vec![10, 15, 16, 5]), Op::Store(vec![5, 11, 5, 5]), Op::Store(vec![5, 10, 5, 5]), Op::Store(vec![5, 4, 5, 5]), Op::Store(vec![2, 19, 20, 5]), Op::Store(vec![2, 18, 21, 5]), Op::Store(vec![2, 17, 22, 5]), Op::Store(vec![2, 9, 23, 5]), Op::Store(vec![2, 7, 24, 5])], ctrl: Ctrl::Return(91, vec![25]) }), (G::from_u64(94), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 3], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Const(G::from_u64(0)), Op::Store(vec![2, 4, 6, 7]), Op::Const(G::from_u64(5)), Op::Store(vec![7, 7, 7]), Op::Store(vec![5, 10, 7, 7]), Op::Store(vec![9, 8, 11, 7]), Op::Store(vec![9, 8, 12, 7])], ctrl: Ctrl::Return(92, vec![13]) }), (G::from_u64(95), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 5], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![4, 6, 3, 7]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(59)), Op::Call(476, vec![0, 11], 1, false), Op::Store(vec![4, 12, 3, 7]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![7, 7, 7]), Op::Store(vec![2, 16, 7]), Op::Store(vec![7, 17, 3]), Op::Store(vec![4, 15, 18, 7]), Op::Store(vec![10, 19, 8, 7]), Op::Store(vec![7, 2, 7, 7]), Op::Store(vec![10, 20, 21, 7]), Op::Store(vec![7, 7, 7, 7]), Op::Store(vec![10, 22, 23, 7]), Op::Store(vec![10, 13, 24, 7]), Op::Store(vec![9, 8, 25, 7]), Op::Store(vec![9, 8, 26, 7])], ctrl: Ctrl::Return(93, vec![27]) }), (G::from_u64(96), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 5], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![4, 6, 3, 7]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(59)), Op::Call(476, vec![0, 11], 1, false), Op::Store(vec![4, 12, 3, 7]), Op::Const(G::from_u64(94)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![4, 15, 3, 7]), Op::Store(vec![7, 2, 7, 7]), Op::Store(vec![10, 16, 17, 7]), Op::Store(vec![7, 7, 7, 7]), Op::Store(vec![10, 18, 19, 7]), Op::Store(vec![10, 13, 20, 7]), Op::Store(vec![9, 8, 21, 7]), Op::Store(vec![9, 8, 22, 7])], ctrl: Ctrl::Return(94, vec![23]) }), (G::from_u64(97), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 5], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![4, 6, 3, 7]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(59)), Op::Call(476, vec![0, 11], 1, false), Op::Store(vec![4, 12, 3, 7]), Op::Const(G::from_u64(94)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![4, 15, 3, 7]), Op::Const(G::from_u64(76)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![4, 18, 3, 7]), Op::Store(vec![7, 2, 7, 7]), Op::Store(vec![10, 19, 20, 7]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![4, 23, 3, 7]), Op::Call(476, vec![0, 4], 1, false), Op::Store(vec![4, 25, 3, 7]), Op::Call(476, vec![0, 2], 1, false), Op::Store(vec![4, 27, 3, 7]), Op::Store(vec![10, 26, 28, 7]), Op::Store(vec![10, 24, 29, 7]), Op::Store(vec![10, 21, 30, 7]), Op::Store(vec![10, 16, 31, 7]), Op::Store(vec![7, 7, 7, 7]), Op::Store(vec![10, 32, 33, 7]), Op::Store(vec![10, 13, 34, 7]), Op::Store(vec![9, 8, 35, 7]), Op::Store(vec![9, 8, 36, 7])], ctrl: Ctrl::Return(95, vec![37]) }), (G::from_u64(98), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 5], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![4, 6, 3, 7]), Op::Const(G::from_u64(5)), Op::Call(476, vec![0, 7], 1, false), Op::Store(vec![4, 10, 3, 7]), Op::Store(vec![9, 11, 8, 7]), Op::Store(vec![9, 8, 12, 7])], ctrl: Ctrl::Return(96, vec![13]) }), (G::from_u64(99), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 5], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![4, 6, 3, 7]), Op::Const(G::from_u64(5)), Op::Call(476, vec![0, 7], 1, false), Op::Store(vec![4, 10, 3, 7]), Op::Store(vec![9, 11, 8, 7]), Op::Store(vec![9, 8, 12, 7])], ctrl: Ctrl::Return(97, vec![13]) }), (G::from_u64(100), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 6], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![5, 7, 3, 8]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![5, 10, 3, 8]), Op::Store(vec![4, 9, 11, 8])], ctrl: Ctrl::Return(98, vec![12]) }), (G::from_u64(101), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(37)), Op::Call(476, vec![0, 6], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![5, 7, 3, 8]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![5, 10, 3, 8]), Op::Store(vec![4, 9, 11, 8])], ctrl: Ctrl::Return(99, vec![12]) }), (G::from_u64(102), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(37)), Op::Call(476, vec![0, 6], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![5, 7, 3, 8]), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![5, 11, 3, 8]), Op::Store(vec![4, 9, 12, 8])], ctrl: Ctrl::Return(100, vec![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![3, 3, 3]), Op::Store(vec![2, 4, 3, 3])], ctrl: Ctrl::Return(101, vec![5]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 102, auxiliaries: 104, lookups: 40 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_558() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(41), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(42), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(43), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(44), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(45), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(4, vec![1]) }), (G::from_u64(46), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(5, vec![1]) }), (G::from_u64(47), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(6, vec![1]) }), (G::from_u64(48), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(7, vec![1]) }), (G::from_u64(49), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(8, vec![1]) }), (G::from_u64(50), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(9, vec![1]) }), (G::from_u64(51), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(10, vec![1]) }), (G::from_u64(52), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(11, vec![1]) }), (G::from_u64(53), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(12, vec![1]) }), (G::from_u64(54), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(13, vec![1]) }), (G::from_u64(55), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(14, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(15, vec![1]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 16, auxiliaries: 16, lookups: 1 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_559() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(48), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(49), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(50), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(51), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(52), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![1]) }), (G::from_u64(53), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![1]) }), (G::from_u64(54), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(6, vec![1]) }), (G::from_u64(55), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(7, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(8, vec![1]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 9, auxiliaries: 9, lookups: 1 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_560() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(64)), Op::Mul(3, 1), Op::Add(4, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(2624), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(41)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Store(vec![13, 16, 18, 9]), Op::Store(vec![12, 11, 19, 9]), Op::Store(vec![12, 11, 20, 9])], ctrl: Ctrl::Return(0, vec![21]) }), (G::from_u64(2625), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(41)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 18, 19, 9]), Op::Store(vec![13, 16, 20, 9]), Op::Store(vec![12, 11, 21, 9]), Op::Store(vec![12, 11, 22, 9])], ctrl: Ctrl::Return(1, vec![23]) }), (G::from_u64(2688), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(42)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 16, 17, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![13, 18, 20, 9]), Op::Store(vec![12, 11, 21, 9]), Op::Store(vec![12, 11, 22, 9])], ctrl: Ctrl::Return(2, vec![23]) }), (G::from_u64(2689), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(42)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 16, 17, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 20, 21, 9]), Op::Store(vec![13, 18, 22, 9]), Op::Store(vec![12, 11, 23, 9]), Op::Store(vec![12, 11, 24, 9])], ctrl: Ctrl::Return(3, vec![25]) }), (G::from_u64(2752), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(43)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 16, 17, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![13, 18, 20, 9]), Op::Store(vec![12, 11, 21, 9]), Op::Store(vec![12, 11, 22, 9])], ctrl: Ctrl::Return(4, vec![23]) }), (G::from_u64(2753), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(43)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 16, 17, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 20, 21, 9]), Op::Store(vec![13, 18, 22, 9]), Op::Store(vec![12, 11, 23, 9]), Op::Store(vec![12, 11, 24, 9])], ctrl: Ctrl::Return(5, vec![25]) }), (G::from_u64(2816), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 16, 17, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![13, 18, 20, 9]), Op::Store(vec![12, 11, 21, 9]), Op::Store(vec![12, 11, 22, 9])], ctrl: Ctrl::Return(6, vec![23]) }), (G::from_u64(2817), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 16, 17, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 20, 21, 9]), Op::Store(vec![13, 18, 22, 9]), Op::Store(vec![12, 11, 23, 9]), Op::Store(vec![12, 11, 24, 9])], ctrl: Ctrl::Return(7, vec![25]) }), (G::from_u64(2880), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(45)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 16, 17, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![13, 18, 20, 9]), Op::Store(vec![12, 11, 21, 9]), Op::Store(vec![12, 11, 22, 9])], ctrl: Ctrl::Return(8, vec![23]) }), (G::from_u64(2881), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(45)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 16, 17, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 20, 21, 9]), Op::Store(vec![13, 18, 22, 9]), Op::Store(vec![12, 11, 23, 9]), Op::Store(vec![12, 11, 24, 9])], ctrl: Ctrl::Return(9, vec![25]) }), (G::from_u64(2944), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 12, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(46)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Store(vec![15, 18, 13, 9]), Op::Store(vec![15, 19, 13, 9]), Op::Store(vec![14, 11, 20, 9]), Op::Store(vec![14, 11, 21, 9])], ctrl: Ctrl::Return(10, vec![22]) }), (G::from_u64(2945), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(46)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Store(vec![13, 16, 18, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 20, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 21, 22, 9]), Op::Store(vec![13, 19, 23, 9]), Op::Store(vec![12, 11, 24, 9]), Op::Store(vec![12, 11, 25, 9])], ctrl: Ctrl::Return(11, vec![26]) }), (G::from_u64(2946), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(46)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 18, 19, 9]), Op::Store(vec![13, 16, 20, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 22, 7, 9]), Op::Store(vec![13, 21, 23, 9]), Op::Store(vec![12, 11, 24, 9]), Op::Store(vec![12, 11, 25, 9])], ctrl: Ctrl::Return(12, vec![26]) }), (G::from_u64(2947), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 12, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(46)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![15, 13, 19, 9]), Op::Store(vec![15, 18, 20, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![15, 13, 22, 9]), Op::Store(vec![15, 21, 23, 9]), Op::Store(vec![14, 11, 24, 9]), Op::Store(vec![14, 11, 25, 9])], ctrl: Ctrl::Return(13, vec![26]) }), (G::from_u64(3008), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Store(vec![13, 16, 18, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 19, 20, 9]), Op::Store(vec![12, 11, 21, 9]), Op::Store(vec![12, 11, 22, 9])], ctrl: Ctrl::Return(14, vec![23]) }), (G::from_u64(3009), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 18, 19, 9]), Op::Store(vec![13, 16, 20, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 22, 7, 9]), Op::Store(vec![13, 21, 23, 9]), Op::Store(vec![12, 11, 24, 9]), Op::Store(vec![12, 11, 25, 9])], ctrl: Ctrl::Return(15, vec![26]) }), (G::from_u64(3010), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 12, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![15, 13, 19, 9]), Op::Store(vec![15, 18, 20, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![15, 13, 22, 9]), Op::Store(vec![15, 21, 23, 9]), Op::Store(vec![14, 11, 24, 9]), Op::Store(vec![14, 11, 25, 9])], ctrl: Ctrl::Return(16, vec![26]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7]), Op::Store(vec![6, 8, 7, 7])], ctrl: Ctrl::Return(17, vec![9]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 18, auxiliaries: 20, lookups: 16 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_561() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(64)), Op::Mul(3, 1), Op::Add(4, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(2624), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Store(vec![12, 11, 14, 9]), Op::Store(vec![12, 11, 15, 9])], ctrl: Ctrl::Return(0, vec![16]) }), (G::from_u64(2625), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 7], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 8, 10, 7]), Op::Const(G::from_u64(4)), Op::Store(vec![7, 9, 7, 7]), Op::Store(vec![12, 11, 13, 7]), Op::Store(vec![12, 11, 14, 7])], ctrl: Ctrl::Return(1, vec![15]) }), (G::from_u64(2688), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 7], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 8, 10, 7]), Op::Const(G::from_u64(4)), Op::Store(vec![7, 9, 7, 7]), Op::Store(vec![12, 11, 13, 7]), Op::Store(vec![12, 11, 14, 7])], ctrl: Ctrl::Return(2, vec![15]) }), (G::from_u64(2689), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 14, 7, 9]), Op::Const(G::from_u64(42)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 18, 19, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 20, 21, 9]), Op::Store(vec![13, 15, 22, 9]), Op::Store(vec![12, 11, 23, 9]), Op::Store(vec![12, 11, 24, 9])], ctrl: Ctrl::Return(3, vec![25]) }), (G::from_u64(2752), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 7], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 8, 10, 7]), Op::Const(G::from_u64(4)), Op::Store(vec![7, 9, 7, 7]), Op::Store(vec![12, 11, 13, 7]), Op::Store(vec![12, 11, 14, 7])], ctrl: Ctrl::Return(4, vec![15]) }), (G::from_u64(2753), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(41)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(43)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 19, 20, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 21, 22, 9]), Op::Store(vec![13, 16, 23, 9]), Op::Store(vec![12, 11, 24, 9]), Op::Store(vec![12, 11, 25, 9])], ctrl: Ctrl::Return(5, vec![26]) }), (G::from_u64(2816), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Store(vec![12, 11, 14, 9]), Op::Store(vec![12, 11, 15, 9])], ctrl: Ctrl::Return(6, vec![16]) }), (G::from_u64(2817), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(42)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![8, 16, 7, 9]), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![14, 20, 12, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![14, 21, 22, 9]), Op::Store(vec![14, 17, 23, 9]), Op::Store(vec![14, 24, 12, 9]), Op::Store(vec![13, 11, 25, 9]), Op::Store(vec![13, 11, 26, 9])], ctrl: Ctrl::Return(7, vec![27]) }), (G::from_u64(2880), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 14, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 16, 7, 9]), Op::Store(vec![13, 15, 17, 9]), Op::Store(vec![12, 11, 18, 9]), Op::Store(vec![12, 11, 19, 9])], ctrl: Ctrl::Return(8, vec![20]) }), (G::from_u64(2881), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![8, 16, 7, 9]), Op::Const(G::from_u64(45)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![14, 20, 12, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![14, 21, 22, 9]), Op::Store(vec![14, 17, 23, 9]), Op::Store(vec![14, 24, 12, 9]), Op::Store(vec![13, 11, 25, 9]), Op::Store(vec![13, 11, 26, 9])], ctrl: Ctrl::Return(9, vec![27]) }), (G::from_u64(2944), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![8, 14, 7, 9]), Op::Store(vec![12, 11, 15, 9]), Op::Store(vec![12, 11, 16, 9])], ctrl: Ctrl::Return(10, vec![17]) }), (G::from_u64(2945), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(5)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![8, 14, 7, 9]), Op::Store(vec![12, 11, 15, 9]), Op::Store(vec![12, 11, 16, 9])], ctrl: Ctrl::Return(11, vec![17]) }), (G::from_u64(2946), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(5)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![8, 14, 7, 9]), Op::Store(vec![12, 11, 15, 9]), Op::Store(vec![12, 11, 16, 9])], ctrl: Ctrl::Return(12, vec![17]) }), (G::from_u64(2947), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(46)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 16, 17, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 18, 19, 9]), Op::Store(vec![12, 11, 20, 9]), Op::Store(vec![12, 11, 21, 9])], ctrl: Ctrl::Return(13, vec![22]) }), (G::from_u64(3008), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![8, 14, 7, 9]), Op::Store(vec![12, 11, 15, 9]), Op::Store(vec![12, 11, 16, 9])], ctrl: Ctrl::Return(14, vec![17]) }), (G::from_u64(3009), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(5)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![8, 14, 7, 9]), Op::Store(vec![12, 11, 15, 9]), Op::Store(vec![12, 11, 16, 9])], ctrl: Ctrl::Return(15, vec![17]) }), (G::from_u64(3010), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 16, 17, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 18, 19, 9]), Op::Store(vec![12, 11, 20, 9]), Op::Store(vec![12, 11, 21, 9])], ctrl: Ctrl::Return(16, vec![22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7]), Op::Store(vec![6, 8, 7, 7])], ctrl: Ctrl::Return(17, vec![9]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 18, auxiliaries: 20, lookups: 16 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_562() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(64)), Op::Mul(3, 1), Op::Add(4, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(3072), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 20, 7, 9]), Op::Store(vec![18, 17, 21, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![8, 24, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 27], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Const(G::from_u64(48)), Op::Call(476, vec![0, 32], 1, false), Op::Store(vec![8, 33, 7, 9]), Op::Store(vec![9, 18, 9, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Const(G::from_u64(5)), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![18, 25, 38, 9]), Op::Store(vec![18, 39, 26, 9]), Op::Store(vec![18, 22, 40, 9]), Op::Store(vec![18, 41, 29, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 43, 7, 9]), Op::Store(vec![18, 31, 44, 9]), Op::Store(vec![18, 25, 45, 9]), Op::Store(vec![18, 46, 26, 9]), Op::Store(vec![18, 22, 47, 9]), Op::Store(vec![18, 48, 29, 9]), Op::Store(vec![18, 17, 11, 9]), Op::Store(vec![18, 34, 35, 9]), Op::Store(vec![18, 51, 36, 9]), Op::Store(vec![18, 50, 52, 9]), Op::Const(G::from_u64(43)), Op::Call(476, vec![0, 54], 1, false), Op::Store(vec![8, 55, 7, 9]), Op::Store(vec![18, 56, 35, 9]), Op::Store(vec![18, 57, 36, 9]), Op::Store(vec![18, 34, 58, 9]), Op::Store(vec![18, 59, 36, 9]), Op::Store(vec![18, 31, 60, 9]), Op::Store(vec![18, 53, 61, 9]), Op::Store(vec![37, 49, 62, 9]), Op::Store(vec![37, 42, 63, 9]), Op::Store(vec![37, 11, 64, 9]), Op::Store(vec![37, 11, 65, 9])], ctrl: Ctrl::Return(0, vec![66]) }), (G::from_u64(3073), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![8, 22, 7, 9]), Op::Store(vec![20, 17, 23, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![20, 27, 28, 9]), Op::Store(vec![20, 29, 18, 9]), Op::Store(vec![20, 24, 30, 9]), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 32, 7, 9]), Op::Store(vec![20, 31, 33, 9]), Op::Store(vec![20, 17, 11, 9]), Op::Const(G::from_u64(48)), Op::Call(476, vec![0, 36], 1, false), Op::Store(vec![8, 37, 7, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Store(vec![20, 38, 39, 9]), Op::Store(vec![20, 40, 18, 9]), Op::Store(vec![20, 35, 41, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 43, 7, 9]), Op::Store(vec![20, 42, 44, 9]), Op::Store(vec![19, 34, 45, 9]), Op::Store(vec![19, 11, 46, 9]), Op::Store(vec![19, 11, 47, 9])], ctrl: Ctrl::Return(1, vec![48]) }), (G::from_u64(3074), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![8, 23, 7, 9]), Op::Store(vec![21, 17, 24, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![8, 27, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 29, 7, 9]), Op::Store(vec![21, 30, 19, 9]), Op::Store(vec![21, 28, 31, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![21, 32, 33, 9]), Op::Store(vec![21, 25, 34, 9]), Op::Call(476, vec![0, 20], 1, false), Op::Store(vec![8, 36, 7, 9]), Op::Store(vec![21, 35, 37, 9]), Op::Store(vec![21, 17, 11, 9]), Op::Const(G::from_u64(48)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Store(vec![21, 42, 43, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![21, 44, 45, 9]), Op::Store(vec![21, 39, 46, 9]), Op::Store(vec![21, 47, 19, 9]), Op::Store(vec![20, 38, 48, 9]), Op::Store(vec![20, 11, 49, 9]), Op::Store(vec![20, 11, 50, 9])], ctrl: Ctrl::Return(2, vec![51]) }), (G::from_u64(3136), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 20, 7, 9]), Op::Store(vec![18, 17, 21, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![8, 24, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 27], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![8, 31, 7, 9]), Op::Store(vec![9, 18, 9, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Const(G::from_u64(5)), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![18, 25, 36, 9]), Op::Store(vec![18, 37, 26, 9]), Op::Store(vec![18, 22, 38, 9]), Op::Store(vec![18, 39, 29, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 43, 7, 9]), Op::Store(vec![18, 42, 44, 9]), Op::Store(vec![18, 25, 45, 9]), Op::Store(vec![18, 46, 26, 9]), Op::Store(vec![18, 22, 47, 9]), Op::Store(vec![18, 48, 29, 9]), Op::Store(vec![18, 17, 11, 9]), Op::Store(vec![18, 32, 33, 9]), Op::Store(vec![18, 51, 34, 9]), Op::Store(vec![18, 50, 52, 9]), Op::Const(G::from_u64(43)), Op::Call(476, vec![0, 54], 1, false), Op::Store(vec![8, 55, 7, 9]), Op::Store(vec![18, 56, 33, 9]), Op::Store(vec![18, 57, 34, 9]), Op::Store(vec![18, 32, 58, 9]), Op::Store(vec![18, 59, 34, 9]), Op::Store(vec![18, 53, 60, 9]), Op::Store(vec![35, 49, 61, 9]), Op::Store(vec![35, 40, 62, 9]), Op::Store(vec![35, 11, 63, 9]), Op::Store(vec![35, 11, 64, 9])], ctrl: Ctrl::Return(3, vec![65]) }), (G::from_u64(3137), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![8, 23, 7, 9]), Op::Store(vec![21, 17, 24, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![8, 27, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![21, 28, 29, 9]), Op::Store(vec![21, 30, 18, 9]), Op::Store(vec![21, 25, 31, 9]), Op::Call(476, vec![0, 20], 1, false), Op::Store(vec![8, 33, 7, 9]), Op::Store(vec![21, 32, 34, 9]), Op::Store(vec![21, 17, 11, 9]), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 37], 1, false), Op::Store(vec![8, 38, 7, 9]), Op::Store(vec![21, 39, 19, 9]), Op::Store(vec![21, 40, 18, 9]), Op::Store(vec![21, 36, 41, 9]), Op::Store(vec![21, 42, 19, 9]), Op::Store(vec![20, 35, 43, 9]), Op::Store(vec![20, 11, 44, 9]), Op::Store(vec![20, 11, 45, 9])], ctrl: Ctrl::Return(4, vec![46]) }), (G::from_u64(3138), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![8, 22, 7, 9]), Op::Store(vec![20, 17, 23, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![20, 29, 31, 9]), Op::Store(vec![20, 27, 32, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![20, 33, 34, 9]), Op::Store(vec![20, 24, 35, 9]), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 37, 7, 9]), Op::Store(vec![20, 36, 38, 9]), Op::Store(vec![20, 17, 11, 9]), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 41], 1, false), Op::Store(vec![8, 42, 7, 9]), Op::Store(vec![20, 43, 18, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![20, 44, 45, 9]), Op::Store(vec![20, 40, 46, 9]), Op::Store(vec![20, 47, 18, 9]), Op::Store(vec![19, 39, 48, 9]), Op::Store(vec![19, 11, 49, 9]), Op::Store(vec![19, 11, 50, 9])], ctrl: Ctrl::Return(5, vec![51]) }), (G::from_u64(3200), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(50)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 20, 7, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Store(vec![24, 17, 27, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 32, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 34, 7, 9]), Op::Store(vec![24, 33, 35, 9]), Op::Store(vec![24, 31, 36, 9]), Op::Store(vec![24, 37, 18, 9]), Op::Store(vec![24, 28, 38, 9]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Store(vec![24, 39, 42, 9]), Op::Store(vec![24, 17, 11, 9]), Op::Store(vec![24, 21, 22, 9]), Op::Store(vec![24, 45, 18, 9]), Op::Store(vec![24, 44, 46, 9]), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 48], 1, false), Op::Store(vec![8, 49, 7, 9]), Op::Store(vec![24, 50, 18, 9]), Op::Store(vec![24, 51, 22, 9]), Op::Store(vec![24, 21, 52, 9]), Op::Store(vec![24, 53, 22, 9]), Op::Store(vec![24, 47, 54, 9]), Op::Store(vec![23, 43, 55, 9]), Op::Store(vec![23, 11, 56, 9]), Op::Store(vec![23, 11, 57, 9])], ctrl: Ctrl::Return(6, vec![58]) }), (G::from_u64(3201), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![8, 22, 7, 9]), Op::Store(vec![20, 17, 23, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![20, 29, 31, 9]), Op::Store(vec![20, 27, 32, 9]), Op::Store(vec![20, 33, 18, 9]), Op::Store(vec![20, 24, 34, 9]), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 36, 7, 9]), Op::Store(vec![20, 35, 37, 9]), Op::Store(vec![20, 17, 11, 9]), Op::Const(G::from_u64(50)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Store(vec![20, 42, 43, 9]), Op::Store(vec![20, 44, 18, 9]), Op::Store(vec![20, 39, 45, 9]), Op::Store(vec![20, 46, 18, 9]), Op::Store(vec![19, 38, 47, 9]), Op::Store(vec![19, 11, 48, 9]), Op::Store(vec![19, 11, 49, 9])], ctrl: Ctrl::Return(7, vec![50]) }), (G::from_u64(3264), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Const(G::from_u64(3)), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 21, 7, 9]), Op::Store(vec![20, 19, 22, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(51)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![20, 19, 23, 9]), Op::Const(G::from_u64(48)), Op::Call(476, vec![0, 33], 1, false), Op::Store(vec![8, 34, 7, 9]), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 36], 1, false), Op::Store(vec![8, 37, 7, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Store(vec![20, 17, 42, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 44], 1, false), Op::Store(vec![8, 45, 7, 9]), Op::Store(vec![20, 46, 23, 9]), Op::Store(vec![20, 47, 24, 9]), Op::Store(vec![20, 43, 48, 9]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 50], 1, false), Op::Store(vec![8, 51, 7, 9]), Op::Store(vec![20, 49, 52, 9]), Op::Store(vec![20, 17, 11, 9]), Op::Store(vec![20, 27, 28, 9]), Op::Store(vec![20, 55, 24, 9]), Op::Store(vec![20, 54, 56, 9]), Op::Const(G::from_u64(42)), Op::Call(476, vec![0, 58], 1, false), Op::Store(vec![8, 59, 7, 9]), Op::Store(vec![20, 31, 32, 9]), Op::Store(vec![20, 35, 28, 9]), Op::Store(vec![20, 62, 32, 9]), Op::Store(vec![20, 27, 63, 9]), Op::Store(vec![20, 35, 24, 9]), Op::Store(vec![20, 65, 32, 9]), Op::Store(vec![20, 64, 66, 9]), Op::Store(vec![20, 61, 67, 9]), Op::Store(vec![20, 60, 68, 9]), Op::Store(vec![20, 38, 28, 9]), Op::Store(vec![20, 70, 32, 9]), Op::Store(vec![20, 31, 71, 9]), Op::Store(vec![20, 38, 24, 9]), Op::Store(vec![20, 73, 32, 9]), Op::Store(vec![20, 72, 74, 9]), Op::Store(vec![20, 69, 75, 9]), Op::Store(vec![20, 57, 76, 9]), Op::Store(vec![39, 53, 77, 9]), Op::Store(vec![39, 11, 78, 9]), Op::Store(vec![39, 11, 79, 9])], ctrl: Ctrl::Return(8, vec![80]) }), (G::from_u64(3265), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![8, 24, 7, 9]), Op::Store(vec![22, 17, 25, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 27], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![22, 31, 19, 9]), Op::Store(vec![22, 29, 32, 9]), Op::Store(vec![22, 33, 20, 9]), Op::Store(vec![22, 26, 34, 9]), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![8, 36, 7, 9]), Op::Store(vec![22, 35, 37, 9]), Op::Store(vec![22, 17, 11, 9]), Op::Const(G::from_u64(51)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Store(vec![22, 42, 43, 9]), Op::Store(vec![22, 44, 20, 9]), Op::Store(vec![22, 39, 45, 9]), Op::Store(vec![22, 46, 19, 9]), Op::Store(vec![21, 38, 47, 9]), Op::Store(vec![21, 11, 48, 9]), Op::Store(vec![21, 11, 49, 9])], ctrl: Ctrl::Return(9, vec![50]) }), (G::from_u64(3328), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Const(G::from_u64(3)), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 21, 7, 9]), Op::Store(vec![20, 19, 22, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(52)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Const(G::from_u64(42)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 32], 1, false), Op::Store(vec![8, 33, 7, 9]), Op::Store(vec![20, 19, 23, 9]), Op::Const(G::from_u64(48)), Op::Call(476, vec![0, 36], 1, false), Op::Store(vec![8, 37, 7, 9]), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 39], 1, false), Op::Store(vec![8, 40, 7, 9]), Op::Store(vec![20, 41, 28, 9]), Op::Store(vec![20, 42, 35, 9]), Op::Store(vec![20, 41, 24, 9]), Op::Store(vec![20, 44, 35, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 47], 1, false), Op::Store(vec![8, 48, 7, 9]), Op::Store(vec![20, 17, 49, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 51], 1, false), Op::Store(vec![8, 52, 7, 9]), Op::Store(vec![20, 53, 23, 9]), Op::Store(vec![20, 54, 24, 9]), Op::Store(vec![20, 50, 55, 9]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 57], 1, false), Op::Store(vec![8, 58, 7, 9]), Op::Store(vec![20, 56, 59, 9]), Op::Store(vec![20, 17, 11, 9]), Op::Store(vec![20, 27, 28, 9]), Op::Store(vec![20, 62, 24, 9]), Op::Store(vec![20, 61, 63, 9]), Op::Store(vec![20, 34, 35, 9]), Op::Store(vec![20, 38, 28, 9]), Op::Store(vec![20, 66, 35, 9]), Op::Store(vec![20, 27, 67, 9]), Op::Store(vec![20, 38, 24, 9]), Op::Store(vec![20, 69, 35, 9]), Op::Store(vec![20, 68, 70, 9]), Op::Store(vec![20, 65, 71, 9]), Op::Store(vec![20, 31, 72, 9]), Op::Const(G::from_u64(43)), Op::Call(476, vec![0, 74], 1, false), Op::Store(vec![8, 75, 7, 9]), Op::Store(vec![20, 31, 43, 9]), Op::Store(vec![20, 77, 45, 9]), Op::Store(vec![20, 76, 78, 9]), Op::Store(vec![20, 34, 43, 9]), Op::Store(vec![20, 80, 45, 9]), Op::Store(vec![20, 79, 81, 9]), Op::Store(vec![20, 73, 82, 9]), Op::Store(vec![20, 64, 83, 9]), Op::Store(vec![46, 60, 84, 9]), Op::Store(vec![46, 11, 85, 9]), Op::Store(vec![46, 11, 86, 9])], ctrl: Ctrl::Return(10, vec![87]) }), (G::from_u64(3329), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![8, 22, 7, 9]), Op::Store(vec![20, 17, 23, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![20, 29, 31, 9]), Op::Store(vec![20, 27, 32, 9]), Op::Store(vec![20, 33, 18, 9]), Op::Store(vec![20, 24, 34, 9]), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 36, 7, 9]), Op::Store(vec![20, 35, 37, 9]), Op::Store(vec![20, 17, 11, 9]), Op::Const(G::from_u64(52)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Store(vec![20, 42, 43, 9]), Op::Store(vec![20, 44, 18, 9]), Op::Store(vec![20, 39, 45, 9]), Op::Store(vec![20, 46, 18, 9]), Op::Store(vec![19, 38, 47, 9]), Op::Store(vec![19, 11, 48, 9]), Op::Store(vec![19, 11, 49, 9])], ctrl: Ctrl::Return(11, vec![50]) }), (G::from_u64(3392), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Const(G::from_u64(3)), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 21, 7, 9]), Op::Store(vec![20, 19, 22, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(53)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Const(G::from_u64(42)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![20, 19, 23, 9]), Op::Const(G::from_u64(48)), Op::Call(476, vec![0, 33], 1, false), Op::Store(vec![8, 34, 7, 9]), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 36], 1, false), Op::Store(vec![8, 37, 7, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Store(vec![20, 17, 42, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 44], 1, false), Op::Store(vec![8, 45, 7, 9]), Op::Store(vec![20, 46, 23, 9]), Op::Store(vec![20, 47, 24, 9]), Op::Store(vec![20, 43, 48, 9]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 50], 1, false), Op::Store(vec![8, 51, 7, 9]), Op::Store(vec![20, 49, 52, 9]), Op::Store(vec![20, 17, 11, 9]), Op::Store(vec![20, 27, 28, 9]), Op::Store(vec![20, 55, 24, 9]), Op::Store(vec![20, 54, 56, 9]), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 58], 1, false), Op::Store(vec![8, 59, 7, 9]), Op::Store(vec![20, 60, 32, 9]), Op::Store(vec![20, 35, 28, 9]), Op::Store(vec![20, 62, 32, 9]), Op::Store(vec![20, 27, 63, 9]), Op::Store(vec![20, 35, 24, 9]), Op::Store(vec![20, 65, 32, 9]), Op::Store(vec![20, 64, 66, 9]), Op::Store(vec![20, 61, 67, 9]), Op::Store(vec![20, 31, 68, 9]), Op::Store(vec![20, 38, 28, 9]), Op::Store(vec![20, 70, 32, 9]), Op::Store(vec![20, 31, 71, 9]), Op::Store(vec![20, 38, 24, 9]), Op::Store(vec![20, 73, 32, 9]), Op::Store(vec![20, 72, 74, 9]), Op::Store(vec![20, 38, 75, 9]), Op::Store(vec![20, 76, 32, 9]), Op::Store(vec![20, 69, 77, 9]), Op::Store(vec![20, 57, 78, 9]), Op::Store(vec![39, 53, 79, 9]), Op::Store(vec![39, 11, 80, 9]), Op::Store(vec![39, 11, 81, 9])], ctrl: Ctrl::Return(12, vec![82]) }), (G::from_u64(3393), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![8, 22, 7, 9]), Op::Store(vec![20, 17, 23, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![20, 29, 31, 9]), Op::Store(vec![20, 27, 32, 9]), Op::Store(vec![20, 33, 18, 9]), Op::Store(vec![20, 24, 34, 9]), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 36, 7, 9]), Op::Store(vec![20, 35, 37, 9]), Op::Store(vec![20, 17, 11, 9]), Op::Const(G::from_u64(53)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Store(vec![20, 42, 43, 9]), Op::Store(vec![20, 44, 18, 9]), Op::Store(vec![20, 39, 45, 9]), Op::Store(vec![20, 46, 18, 9]), Op::Store(vec![19, 38, 47, 9]), Op::Store(vec![19, 11, 48, 9]), Op::Store(vec![19, 11, 49, 9])], ctrl: Ctrl::Return(13, vec![50]) }), (G::from_u64(3456), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Const(G::from_u64(3)), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 21, 7, 9]), Op::Store(vec![20, 19, 22, 9]), Op::Const(G::from_u64(54)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![8, 25, 7, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![8, 31, 7, 9]), Op::Store(vec![20, 17, 32, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![8, 35, 7, 9]), Op::Store(vec![20, 36, 23, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![20, 37, 38, 9]), Op::Store(vec![20, 33, 39, 9]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 41], 1, false), Op::Store(vec![8, 42, 7, 9]), Op::Store(vec![20, 40, 43, 9]), Op::Store(vec![20, 17, 11, 9]), Op::Store(vec![20, 26, 27, 9]), Op::Store(vec![20, 46, 28, 9]), Op::Store(vec![20, 45, 47, 9]), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 49], 1, false), Op::Store(vec![8, 50, 7, 9]), Op::Store(vec![20, 19, 23, 9]), Op::Store(vec![20, 51, 52, 9]), Op::Store(vec![20, 53, 27, 9]), Op::Store(vec![20, 26, 54, 9]), Op::Const(G::from_u64(43)), Op::Call(476, vec![0, 56], 1, false), Op::Store(vec![8, 57, 7, 9]), Op::Store(vec![20, 58, 28, 9]), Op::Store(vec![20, 59, 23, 9]), Op::Store(vec![20, 55, 60, 9]), Op::Store(vec![20, 48, 61, 9]), Op::Store(vec![29, 44, 62, 9]), Op::Store(vec![29, 11, 63, 9]), Op::Store(vec![29, 11, 64, 9])], ctrl: Ctrl::Return(14, vec![65]) }), (G::from_u64(3457), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![8, 22, 7, 9]), Op::Store(vec![20, 17, 23, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![20, 29, 31, 9]), Op::Store(vec![20, 27, 32, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![20, 33, 34, 9]), Op::Store(vec![20, 24, 35, 9]), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 37, 7, 9]), Op::Store(vec![20, 36, 38, 9]), Op::Store(vec![20, 17, 11, 9]), Op::Const(G::from_u64(54)), Op::Call(476, vec![0, 41], 1, false), Op::Store(vec![8, 42, 7, 9]), Op::Store(vec![20, 43, 18, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![20, 44, 45, 9]), Op::Store(vec![20, 40, 46, 9]), Op::Store(vec![20, 47, 18, 9]), Op::Store(vec![19, 39, 48, 9]), Op::Store(vec![19, 11, 49, 9]), Op::Store(vec![19, 11, 50, 9])], ctrl: Ctrl::Return(15, vec![51]) }), (G::from_u64(3520), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Const(G::from_u64(3)), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 21, 7, 9]), Op::Store(vec![20, 19, 22, 9]), Op::Const(G::from_u64(55)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![8, 25, 7, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Store(vec![20, 26, 27, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 31], 1, false), Op::Store(vec![8, 32, 7, 9]), Op::Store(vec![20, 17, 33, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 35], 1, false), Op::Store(vec![8, 36, 7, 9]), Op::Store(vec![20, 37, 23, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![20, 38, 39, 9]), Op::Store(vec![20, 34, 40, 9]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 42], 1, false), Op::Store(vec![8, 43, 7, 9]), Op::Store(vec![20, 41, 44, 9]), Op::Store(vec![20, 17, 11, 9]), Op::Store(vec![20, 28, 29, 9]), Op::Store(vec![20, 46, 47, 9]), Op::Const(G::from_u64(48)), Op::Call(476, vec![0, 49], 1, false), Op::Store(vec![8, 50, 7, 9]), Op::Const(G::from_u64(43)), Op::Call(476, vec![0, 52], 1, false), Op::Store(vec![8, 53, 7, 9]), Op::Store(vec![20, 54, 29, 9]), Op::Store(vec![20, 55, 23, 9]), Op::Store(vec![20, 28, 56, 9]), Op::Store(vec![20, 51, 57, 9]), Op::Store(vec![20, 19, 23, 9]), Op::Store(vec![20, 58, 59, 9]), Op::Store(vec![20, 48, 60, 9]), Op::Store(vec![30, 45, 61, 9]), Op::Store(vec![30, 11, 62, 9]), Op::Store(vec![30, 11, 63, 9])], ctrl: Ctrl::Return(16, vec![64]) }), (G::from_u64(3521), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![8, 22, 7, 9]), Op::Store(vec![20, 17, 23, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![20, 29, 31, 9]), Op::Store(vec![20, 27, 32, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![20, 33, 34, 9]), Op::Store(vec![20, 24, 35, 9]), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 37, 7, 9]), Op::Store(vec![20, 36, 38, 9]), Op::Store(vec![20, 17, 11, 9]), Op::Const(G::from_u64(55)), Op::Call(476, vec![0, 41], 1, false), Op::Store(vec![8, 42, 7, 9]), Op::Store(vec![20, 43, 18, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![20, 44, 45, 9]), Op::Store(vec![20, 40, 46, 9]), Op::Store(vec![20, 47, 18, 9]), Op::Store(vec![19, 39, 48, 9]), Op::Store(vec![19, 11, 49, 9]), Op::Store(vec![19, 11, 50, 9])], ctrl: Ctrl::Return(17, vec![51]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7]), Op::Store(vec![6, 8, 7, 7])], ctrl: Ctrl::Return(18, vec![9]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 19, auxiliaries: 68, lookups: 68 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_563() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(65), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(0, vec![1]) }), (G::from_u64(67), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1]) }), (G::from_u64(68), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![1]) }), (G::from_u64(69), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![1]) }), (G::from_u64(73), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(4, vec![1]) }), (G::from_u64(74), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(5, vec![1]) }), (G::from_u64(75), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(6, vec![1]) }), (G::from_u64(76), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(7, vec![1]) }), (G::from_u64(77), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(8, vec![1]) }), (G::from_u64(78), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(9, vec![1]) }), (G::from_u64(79), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(10, vec![1]) }), (G::from_u64(80), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(11, vec![1]) }), (G::from_u64(81), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(12, vec![1]) }), (G::from_u64(82), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(13, vec![1]) }), (G::from_u64(85), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(14, vec![1]) }), (G::from_u64(86), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(15, vec![1]) }), (G::from_u64(87), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(16, vec![1]) }), (G::from_u64(90), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(17, vec![1]) }), (G::from_u64(91), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(18, vec![1]) }), (G::from_u64(92), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(19, vec![1]) }), (G::from_u64(93), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(20, vec![1]) }), (G::from_u64(95), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(21, vec![1]) }), (G::from_u64(96), Block { ops: vec![Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(22, vec![1]) }), (G::from_u64(97), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(23, vec![1]) }), (G::from_u64(98), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(24, vec![1]) }), (G::from_u64(99), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(25, vec![1]) }), (G::from_u64(100), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(26, vec![1]) }), (G::from_u64(101), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(27, vec![1]) }), (G::from_u64(102), Block { ops: vec![Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(28, vec![1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(29, vec![1]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 30, auxiliaries: 30, lookups: 1 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_564() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(64)), Op::Mul(2, 0), Op::Add(3, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(4162), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![5]) }), (G::from_u64(4736), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![5]) }), (G::from_u64(4737), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![5]) }), (G::from_u64(5249), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(3, vec![5]) }), (G::from_u64(5250), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![5]) }), (G::from_u64(6400), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(5, vec![5]) }), (G::from_u64(6401), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(6, vec![5]) }), (G::from_u64(6402), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(7, vec![5]) }), (G::from_u64(6403), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(8, vec![5]) }), (G::from_u64(6404), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(9, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(10, vec![5]) }))) }, layout: FunctionLayout { input_size: 2, selectors: 11, auxiliaries: 11, lookups: 1 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_565() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(64)), Op::Mul(3, 1), Op::Add(4, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(4160), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6, 6]), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Store(vec![6, 8, 6, 6]), Op::Const(G::from_u64(4)), Op::Store(vec![6, 6, 6]), Op::Store(vec![8, 12, 6, 6]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![15, 17, 9, 6]), Op::Store(vec![14, 18, 10, 6]), Op::Const(G::from_u64(60)), Op::Call(476, vec![0, 20], 1, false), Op::Store(vec![15, 21, 9, 6]), Op::Store(vec![14, 22, 10, 6]), Op::Store(vec![14, 23, 7, 6]), Op::Store(vec![14, 19, 24, 6]), Op::Store(vec![11, 7, 25, 6]), Op::Store(vec![11, 13, 26, 6])], ctrl: Ctrl::Return(0, vec![27]) }), (G::from_u64(4161), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8, 8]), Op::Store(vec![8, 6, 8, 8]), Op::Const(G::from_u64(4)), Op::Store(vec![8, 8, 8]), Op::Store(vec![6, 12, 8, 8]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(62)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![15, 17, 7, 8]), Op::Store(vec![14, 18, 9, 8]), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 20], 1, false), Op::Store(vec![15, 21, 7, 8]), Op::Store(vec![14, 22, 10, 8]), Op::Const(G::from_u64(61)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![15, 25, 7, 8]), Op::Store(vec![14, 26, 10, 8]), Op::Store(vec![14, 27, 9, 8]), Op::Store(vec![14, 23, 28, 8]), Op::Store(vec![11, 19, 29, 8]), Op::Store(vec![11, 13, 30, 8])], ctrl: Ctrl::Return(1, vec![31]) }), (G::from_u64(4288), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 21, 9]), Op::Store(vec![9, 22, 7]), Op::Store(vec![8, 20, 23, 9]), Op::Store(vec![15, 24, 11, 9]), Op::Store(vec![15, 25, 12, 9]), Op::Store(vec![15, 26, 13, 9]), Op::Store(vec![15, 18, 27, 9]), Op::Const(G::from_u64(67)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![15, 31, 12, 9]), Op::Store(vec![15, 32, 13, 9]), Op::Store(vec![15, 28, 33, 9]), Op::Store(vec![14, 11, 34, 9]), Op::Store(vec![14, 11, 35, 9])], ctrl: Ctrl::Return(2, vec![36]) }), (G::from_u64(4352), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Const(G::from_u64(66)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 20, 7, 9]), Op::Store(vec![15, 21, 12, 9]), Op::Store(vec![15, 22, 13, 9]), Op::Store(vec![15, 18, 23, 9]), Op::Const(G::from_u64(68)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Store(vec![15, 27, 12, 9]), Op::Store(vec![15, 28, 13, 9]), Op::Store(vec![15, 24, 29, 9]), Op::Store(vec![14, 11, 30, 9]), Op::Store(vec![14, 11, 31, 9])], ctrl: Ctrl::Return(3, vec![32]) }), (G::from_u64(4416), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(69)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 16, 17, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 18, 19, 9]), Op::Store(vec![12, 11, 20, 9]), Op::Store(vec![12, 11, 21, 9])], ctrl: Ctrl::Return(4, vec![22]) }), (G::from_u64(4672), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(73)), Op::Call(476, vec![0, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![9, 11, 7, 12]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![9, 14, 7, 12]), Op::Store(vec![8, 13, 15, 12])], ctrl: Ctrl::Return(5, vec![16]) }), (G::from_u64(4673), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![9, 11, 7, 10]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(73)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![9, 15, 7, 10]), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![9, 17, 7, 10]), Op::Store(vec![10, 10, 10, 10]), Op::Store(vec![13, 18, 19, 10]), Op::Store(vec![13, 16, 20, 10]), Op::Store(vec![8, 12, 21, 10])], ctrl: Ctrl::Return(6, vec![22]) }), (G::from_u64(4800), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![9, 11, 7, 10]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(75)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![9, 15, 7, 10]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![9, 18, 7, 10]), Op::Store(vec![10, 10, 10, 10]), Op::Store(vec![13, 19, 20, 10]), Op::Store(vec![13, 16, 21, 10]), Op::Store(vec![8, 12, 22, 10])], ctrl: Ctrl::Return(7, vec![23]) }), (G::from_u64(4801), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![9, 11, 7, 10]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(75)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![9, 15, 7, 10]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![9, 18, 7, 10]), Op::Store(vec![10, 10, 10, 10]), Op::Store(vec![13, 19, 20, 10]), Op::Store(vec![13, 16, 21, 10]), Op::Store(vec![8, 12, 22, 10])], ctrl: Ctrl::Return(8, vec![23]) }), (G::from_u64(4864), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(76)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![16, 14, 20, 9]), Op::Store(vec![16, 19, 21, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![16, 14, 23, 9]), Op::Store(vec![16, 22, 24, 9]), Op::Store(vec![15, 11, 25, 9]), Op::Store(vec![15, 11, 26, 9])], ctrl: Ctrl::Return(9, vec![27]) }), (G::from_u64(4865), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(76)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 19, 20, 9]), Op::Store(vec![13, 16, 21, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![8, 24, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 25, 26, 9]), Op::Store(vec![13, 22, 27, 9]), Op::Store(vec![12, 11, 28, 9]), Op::Store(vec![12, 11, 29, 9])], ctrl: Ctrl::Return(10, vec![30]) }), (G::from_u64(4866), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(76)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 19, 20, 9]), Op::Store(vec![13, 16, 21, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![8, 24, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 25, 26, 9]), Op::Store(vec![13, 22, 27, 9]), Op::Store(vec![12, 11, 28, 9]), Op::Store(vec![12, 11, 29, 9])], ctrl: Ctrl::Return(11, vec![30]) }), (G::from_u64(4867), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(76)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![16, 14, 20, 9]), Op::Store(vec![16, 19, 21, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![16, 14, 23, 9]), Op::Store(vec![16, 22, 24, 9]), Op::Store(vec![15, 11, 25, 9]), Op::Store(vec![15, 11, 26, 9])], ctrl: Ctrl::Return(12, vec![27]) }), (G::from_u64(4928), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 10, 7, 11]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(77)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![8, 16, 7, 11]), Op::Store(vec![11, 6, 11, 11]), Op::Store(vec![14, 17, 18, 11]), Op::Store(vec![11, 11, 11, 11]), Op::Store(vec![14, 19, 20, 11]), Op::Store(vec![13, 12, 21, 11]), Op::Store(vec![13, 12, 22, 11])], ctrl: Ctrl::Return(13, vec![23]) }), (G::from_u64(4992), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(78)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![16, 14, 20, 9]), Op::Store(vec![16, 19, 21, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![16, 14, 23, 9]), Op::Store(vec![16, 22, 24, 9]), Op::Store(vec![15, 11, 25, 9]), Op::Store(vec![15, 11, 26, 9])], ctrl: Ctrl::Return(14, vec![27]) }), (G::from_u64(4993), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(78)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 19, 20, 9]), Op::Store(vec![13, 16, 21, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![8, 24, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 25, 26, 9]), Op::Store(vec![13, 22, 27, 9]), Op::Store(vec![12, 11, 28, 9]), Op::Store(vec![12, 11, 29, 9])], ctrl: Ctrl::Return(15, vec![30]) }), (G::from_u64(4994), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(78)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 19, 20, 9]), Op::Store(vec![13, 16, 21, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![8, 24, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 25, 26, 9]), Op::Store(vec![13, 22, 27, 9]), Op::Store(vec![12, 11, 28, 9]), Op::Store(vec![12, 11, 29, 9])], ctrl: Ctrl::Return(16, vec![30]) }), (G::from_u64(4995), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(78)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![16, 14, 20, 9]), Op::Store(vec![16, 19, 21, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![16, 14, 23, 9]), Op::Store(vec![16, 22, 24, 9]), Op::Store(vec![15, 11, 25, 9]), Op::Store(vec![15, 11, 26, 9])], ctrl: Ctrl::Return(17, vec![27]) }), (G::from_u64(5056), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![9, 11, 7, 10]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(79)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![9, 15, 7, 10]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![9, 18, 7, 10]), Op::Store(vec![10, 10, 10, 10]), Op::Store(vec![13, 19, 20, 10]), Op::Store(vec![13, 16, 21, 10]), Op::Store(vec![8, 12, 22, 10])], ctrl: Ctrl::Return(18, vec![23]) }), (G::from_u64(5057), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![9, 11, 7, 10]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(79)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![9, 15, 7, 10]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![9, 18, 7, 10]), Op::Store(vec![10, 10, 10, 10]), Op::Store(vec![13, 19, 20, 10]), Op::Store(vec![13, 16, 21, 10]), Op::Store(vec![8, 12, 22, 10])], ctrl: Ctrl::Return(19, vec![23]) }), (G::from_u64(5120), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(80)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![16, 14, 20, 9]), Op::Store(vec![16, 19, 21, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![16, 14, 23, 9]), Op::Store(vec![16, 22, 24, 9]), Op::Store(vec![15, 11, 25, 9]), Op::Store(vec![15, 11, 26, 9])], ctrl: Ctrl::Return(20, vec![27]) }), (G::from_u64(5121), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(80)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 19, 20, 9]), Op::Store(vec![13, 16, 21, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![8, 24, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 25, 26, 9]), Op::Store(vec![13, 22, 27, 9]), Op::Store(vec![12, 11, 28, 9]), Op::Store(vec![12, 11, 29, 9])], ctrl: Ctrl::Return(21, vec![30]) }), (G::from_u64(5122), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![9, 11, 7, 10]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(80)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![9, 15, 7, 10]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![9, 18, 7, 10]), Op::Store(vec![10, 10, 10, 10]), Op::Store(vec![13, 19, 20, 10]), Op::Store(vec![13, 16, 21, 10]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![9, 24, 7, 10]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![9, 26, 7, 10]), Op::Store(vec![13, 25, 27, 10]), Op::Store(vec![13, 22, 28, 10]), Op::Store(vec![8, 12, 29, 10])], ctrl: Ctrl::Return(22, vec![30]) }), (G::from_u64(5123), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(80)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 19, 20, 9]), Op::Store(vec![13, 16, 21, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![8, 24, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 27, 28, 9]), Op::Store(vec![13, 25, 29, 9]), Op::Store(vec![13, 22, 30, 9]), Op::Store(vec![12, 11, 31, 9]), Op::Store(vec![12, 11, 32, 9])], ctrl: Ctrl::Return(23, vec![33]) }), (G::from_u64(5124), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(80)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![16, 14, 20, 9]), Op::Store(vec![16, 19, 21, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![16, 14, 23, 9]), Op::Store(vec![16, 22, 24, 9]), Op::Store(vec![15, 11, 25, 9]), Op::Store(vec![15, 11, 26, 9])], ctrl: Ctrl::Return(24, vec![27]) }), (G::from_u64(5184), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(81)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![16, 14, 20, 9]), Op::Store(vec![16, 19, 21, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![16, 14, 23, 9]), Op::Store(vec![16, 22, 24, 9]), Op::Store(vec![15, 11, 25, 9]), Op::Store(vec![15, 11, 26, 9])], ctrl: Ctrl::Return(25, vec![27]) }), (G::from_u64(5185), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(81)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 19, 20, 9]), Op::Store(vec![13, 16, 21, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![8, 24, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 25, 26, 9]), Op::Store(vec![13, 22, 27, 9]), Op::Store(vec![12, 11, 28, 9]), Op::Store(vec![12, 11, 29, 9])], ctrl: Ctrl::Return(26, vec![30]) }), (G::from_u64(5186), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(81)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 19, 20, 9]), Op::Store(vec![13, 16, 21, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![8, 24, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 25, 26, 9]), Op::Store(vec![13, 22, 27, 9]), Op::Store(vec![12, 11, 28, 9]), Op::Store(vec![12, 11, 29, 9])], ctrl: Ctrl::Return(27, vec![30]) }), (G::from_u64(5187), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(81)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![16, 14, 20, 9]), Op::Store(vec![16, 19, 21, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![16, 14, 23, 9]), Op::Store(vec![16, 22, 24, 9]), Op::Store(vec![15, 11, 25, 9]), Op::Store(vec![15, 11, 26, 9])], ctrl: Ctrl::Return(28, vec![27]) }), (G::from_u64(5248), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(82)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 19, 20, 9]), Op::Store(vec![13, 16, 21, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 22, 23, 9]), Op::Store(vec![12, 11, 24, 9]), Op::Store(vec![12, 11, 25, 9])], ctrl: Ctrl::Return(29, vec![26]) }), (G::from_u64(5440), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(85)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![8, 16, 7, 9]), Op::Store(vec![14, 17, 12, 9]), Op::Const(G::from_u64(84)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 20, 7, 9]), Op::Store(vec![14, 21, 12, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![14, 22, 23, 9]), Op::Store(vec![14, 18, 24, 9]), Op::Store(vec![13, 11, 25, 9]), Op::Store(vec![13, 11, 26, 9])], ctrl: Ctrl::Return(30, vec![27]) }), (G::from_u64(5504), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(84)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![13, 16, 12, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(86)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 20, 7, 9]), Op::Store(vec![13, 21, 12, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 17, 23, 9]), Op::Store(vec![13, 22, 24, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 17, 26, 9]), Op::Store(vec![13, 25, 27, 9]), Op::Store(vec![18, 11, 28, 9]), Op::Store(vec![18, 11, 29, 9]), Op::Store(vec![18, 11, 30, 9])], ctrl: Ctrl::Return(31, vec![31]) }), (G::from_u64(5568), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(37)), Op::Call(476, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 10, 7, 11]), Op::Store(vec![11, 11, 11, 11]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![8, 17, 7, 11]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![11, 11, 11]), Op::Store(vec![6, 21, 11]), Op::Store(vec![11, 22, 7]), Op::Store(vec![8, 20, 23, 11]), Op::Store(vec![15, 24, 12, 11]), Op::Store(vec![15, 25, 13, 11]), Op::Store(vec![15, 26, 13, 11]), Op::Store(vec![15, 18, 27, 11]), Op::Const(G::from_u64(87)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 11]), Op::Store(vec![15, 31, 13, 11]), Op::Store(vec![15, 32, 13, 11]), Op::Store(vec![15, 28, 33, 11]), Op::Store(vec![14, 12, 34, 11])], ctrl: Ctrl::Return(32, vec![35]) }), (G::from_u64(5760), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(90)), Op::Call(476, vec![0, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![9, 11, 7, 12]), Op::Const(G::from_u64(38)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![9, 15, 7, 12]), Op::Const(G::from_u64(30)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![12, 12, 12]), Op::Store(vec![12, 19, 7]), Op::Store(vec![9, 18, 20, 12]), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![9, 23, 7, 12]), Op::Store(vec![8, 21, 24, 12]), Op::Store(vec![8, 16, 25, 12]), Op::Store(vec![8, 13, 26, 12])], ctrl: Ctrl::Return(33, vec![27]) }), (G::from_u64(5824), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 7]), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Store(vec![7, 8, 10]), Op::Store(vec![7, 7, 7, 7]), Op::Store(vec![7, 9, 7, 7]), Op::Store(vec![9, 8, 7]), Op::Store(vec![9, 14, 7, 7]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(29)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![17, 19, 11, 7]), Op::Store(vec![16, 20, 12, 7]), Op::Const(G::from_u64(91)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![17, 23, 11, 7]), Op::Store(vec![16, 24, 13, 7]), Op::Const(G::from_u64(30)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![17, 27, 11, 7]), Op::Store(vec![16, 28, 13, 7]), Op::Store(vec![16, 25, 29, 7]), Op::Store(vec![16, 30, 12, 7]), Op::Store(vec![6, 21, 31, 7]), Op::Store(vec![6, 15, 32, 7])], ctrl: Ctrl::Return(34, vec![33]) }), (G::from_u64(5825), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 7]), Op::Store(vec![7, 7, 7, 7]), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10]), Op::Store(vec![7, 8, 11]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(29)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![13, 15, 12, 7]), Op::Store(vec![7, 10, 7, 7]), Op::Store(vec![7, 13, 7, 7]), Op::Const(G::from_u64(3)), Op::Store(vec![7, 19, 7, 7]), Op::Store(vec![10, 8, 7]), Op::Store(vec![10, 21, 7, 7]), Op::Store(vec![19, 16, 17, 7]), Op::Store(vec![19, 16, 18, 7]), Op::Const(G::from_u64(91)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![13, 26, 12, 7]), Op::Store(vec![19, 27, 20, 7]), Op::Const(G::from_u64(31)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![13, 30, 12, 7]), Op::Store(vec![19, 31, 20, 7]), Op::Store(vec![19, 32, 18, 7]), Op::Store(vec![19, 33, 17, 7]), Op::Store(vec![19, 28, 34, 7]), Op::Store(vec![19, 35, 9, 7]), Op::Store(vec![6, 24, 36, 7]), Op::Store(vec![6, 23, 37, 7]), Op::Store(vec![6, 9, 38, 7]), Op::Store(vec![6, 22, 39, 7])], ctrl: Ctrl::Return(35, vec![40]) }), (G::from_u64(5888), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(29)), Op::Call(476, vec![0, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![12, 12, 12]), Op::Store(vec![12, 13, 7]), Op::Store(vec![9, 11, 14, 12]), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![9, 17, 7, 12]), Op::Store(vec![8, 15, 18, 12]), Op::Const(G::from_u64(38)), Op::Call(476, vec![0, 20], 1, false), Op::Store(vec![9, 21, 7, 12]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(92)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![9, 25, 7, 12]), Op::Store(vec![12, 6, 12, 12]), Op::Store(vec![8, 22, 27, 12]), Op::Store(vec![8, 26, 28, 12]), Op::Store(vec![12, 12, 12, 12]), Op::Store(vec![8, 22, 30, 12]), Op::Store(vec![8, 29, 31, 12]), Op::Store(vec![23, 19, 32, 12]), Op::Store(vec![23, 19, 33, 12])], ctrl: Ctrl::Return(36, vec![34]) }), (G::from_u64(5952), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 7]), Op::Store(vec![7, 7, 7, 7]), Op::Const(G::from_u64(2)), Op::Store(vec![7, 10, 7, 7]), Op::Const(G::from_u64(3)), Op::Store(vec![7, 12, 7, 7]), Op::Const(G::from_u64(1)), Op::Store(vec![14, 14, 14]), Op::Store(vec![14, 8, 7, 7]), Op::Store(vec![7, 7, 7]), Op::Store(vec![14, 17, 7, 7]), Op::Const(G::from_u64(93)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![7, 8, 15]), Op::Store(vec![10, 20, 21, 7]), Op::Store(vec![7, 6, 7, 7]), Op::Store(vec![12, 22, 23, 7]), Op::Store(vec![12, 24, 13, 7]), Op::Const(G::from_u64(60)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![10, 27, 15, 7]), Op::Store(vec![12, 28, 13, 7]), Op::Store(vec![12, 29, 11, 7]), Op::Store(vec![12, 25, 30, 7]), Op::Store(vec![7, 14, 7, 7]), Op::Store(vec![12, 31, 32, 7]), Op::Store(vec![12, 33, 9, 7]), Op::Store(vec![6, 13, 34, 7]), Op::Store(vec![6, 11, 35, 7]), Op::Store(vec![6, 9, 36, 7]), Op::Store(vec![6, 18, 37, 7]), Op::Store(vec![6, 16, 38, 7])], ctrl: Ctrl::Return(37, vec![39]) }), (G::from_u64(5953), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 7]), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Store(vec![7, 7, 7, 7]), Op::Const(G::from_u64(2)), Op::Store(vec![7, 12, 7, 7]), Op::Const(G::from_u64(3)), Op::Store(vec![7, 14, 7, 7]), Op::Store(vec![9, 8, 7, 7]), Op::Store(vec![7, 7, 7]), Op::Store(vec![9, 17, 7, 7]), Op::Const(G::from_u64(62)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![12, 20, 10, 7]), Op::Store(vec![14, 21, 11, 7]), Op::Const(G::from_u64(93)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![7, 8, 10]), Op::Store(vec![12, 24, 25, 7]), Op::Store(vec![7, 6, 7, 7]), Op::Store(vec![14, 26, 27, 7]), Op::Store(vec![14, 28, 15, 7]), Op::Const(G::from_u64(61)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![12, 31, 10, 7]), Op::Store(vec![14, 32, 15, 7]), Op::Store(vec![14, 33, 13, 7]), Op::Store(vec![14, 29, 34, 7]), Op::Store(vec![7, 9, 7, 7]), Op::Store(vec![14, 35, 36, 7]), Op::Store(vec![14, 37, 11, 7]), Op::Store(vec![6, 15, 38, 7]), Op::Store(vec![6, 13, 39, 7]), Op::Store(vec![6, 22, 40, 7]), Op::Store(vec![6, 18, 41, 7]), Op::Store(vec![6, 16, 42, 7])], ctrl: Ctrl::Return(38, vec![43]) }), (G::from_u64(6080), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Const(G::from_u64(3)), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![15, 14, 16, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![15, 14, 18, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![8, 22, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 26, 9]), Op::Store(vec![9, 27, 7]), Op::Store(vec![8, 25, 28, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![8, 31, 7, 9]), Op::Store(vec![15, 29, 32, 9]), Op::Store(vec![15, 33, 17, 9]), Op::Store(vec![15, 34, 19, 9]), Op::Store(vec![15, 23, 35, 9]), Op::Const(G::from_u64(95)), Op::Call(476, vec![0, 37], 1, false), Op::Store(vec![8, 38, 7, 9]), Op::Store(vec![15, 39, 17, 9]), Op::Store(vec![15, 40, 19, 9]), Op::Store(vec![15, 36, 41, 9]), Op::Store(vec![20, 11, 42, 9]), Op::Store(vec![20, 11, 43, 9])], ctrl: Ctrl::Return(39, vec![44]) }), (G::from_u64(6081), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![8, 14, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![12, 15, 16, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![12, 20, 21, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![8, 25, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 27], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 29, 9]), Op::Store(vec![9, 30, 7]), Op::Store(vec![8, 28, 31, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 33], 1, false), Op::Store(vec![8, 34, 7, 9]), Op::Store(vec![12, 32, 35, 9]), Op::Store(vec![12, 36, 17, 9]), Op::Store(vec![12, 37, 22, 9]), Op::Store(vec![12, 26, 38, 9]), Op::Const(G::from_u64(95)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Store(vec![12, 42, 17, 9]), Op::Store(vec![12, 43, 22, 9]), Op::Store(vec![12, 39, 44, 9]), Op::Store(vec![23, 11, 45, 9]), Op::Store(vec![23, 11, 46, 9])], ctrl: Ctrl::Return(40, vec![47]) }), (G::from_u64(6082), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![8, 14, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![12, 15, 16, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![12, 20, 21, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![8, 25, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 27], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 29, 9]), Op::Store(vec![9, 30, 7]), Op::Store(vec![8, 28, 31, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 33], 1, false), Op::Store(vec![8, 34, 7, 9]), Op::Store(vec![12, 32, 35, 9]), Op::Store(vec![12, 36, 17, 9]), Op::Store(vec![12, 37, 22, 9]), Op::Store(vec![12, 26, 38, 9]), Op::Const(G::from_u64(95)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Store(vec![12, 42, 17, 9]), Op::Store(vec![12, 43, 22, 9]), Op::Store(vec![12, 39, 44, 9]), Op::Store(vec![23, 11, 45, 9]), Op::Store(vec![23, 11, 46, 9])], ctrl: Ctrl::Return(41, vec![47]) }), (G::from_u64(6083), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Const(G::from_u64(3)), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![15, 14, 16, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![15, 14, 18, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![8, 22, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 26, 9]), Op::Store(vec![9, 27, 7]), Op::Store(vec![8, 25, 28, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![8, 31, 7, 9]), Op::Store(vec![15, 29, 32, 9]), Op::Store(vec![15, 33, 17, 9]), Op::Store(vec![15, 34, 19, 9]), Op::Store(vec![15, 23, 35, 9]), Op::Const(G::from_u64(95)), Op::Call(476, vec![0, 37], 1, false), Op::Store(vec![8, 38, 7, 9]), Op::Store(vec![15, 39, 17, 9]), Op::Store(vec![15, 40, 19, 9]), Op::Store(vec![15, 36, 41, 9]), Op::Store(vec![20, 11, 42, 9]), Op::Store(vec![20, 11, 43, 9])], ctrl: Ctrl::Return(42, vec![44]) }), (G::from_u64(6144), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Const(G::from_u64(3)), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![15, 14, 16, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![15, 14, 18, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![8, 22, 7, 9]), Op::Const(G::from_u64(94)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![8, 25, 7, 9]), Op::Store(vec![15, 26, 17, 9]), Op::Store(vec![15, 27, 19, 9]), Op::Store(vec![15, 23, 28, 9]), Op::Const(G::from_u64(96)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![8, 31, 7, 9]), Op::Store(vec![15, 32, 17, 9]), Op::Store(vec![15, 33, 19, 9]), Op::Store(vec![15, 29, 34, 9]), Op::Store(vec![20, 11, 35, 9]), Op::Store(vec![20, 11, 36, 9])], ctrl: Ctrl::Return(43, vec![37]) }), (G::from_u64(6145), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![8, 14, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![12, 15, 16, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![12, 20, 21, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![8, 25, 7, 9]), Op::Const(G::from_u64(94)), Op::Call(476, vec![0, 27], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Store(vec![12, 29, 17, 9]), Op::Store(vec![12, 30, 22, 9]), Op::Store(vec![12, 26, 31, 9]), Op::Const(G::from_u64(96)), Op::Call(476, vec![0, 33], 1, false), Op::Store(vec![8, 34, 7, 9]), Op::Store(vec![12, 35, 17, 9]), Op::Store(vec![12, 36, 22, 9]), Op::Store(vec![12, 32, 37, 9]), Op::Store(vec![23, 11, 38, 9]), Op::Store(vec![23, 11, 39, 9])], ctrl: Ctrl::Return(44, vec![40]) }), (G::from_u64(6146), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![8, 14, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![12, 15, 16, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![12, 20, 21, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![8, 25, 7, 9]), Op::Const(G::from_u64(94)), Op::Call(476, vec![0, 27], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Store(vec![12, 29, 17, 9]), Op::Store(vec![12, 30, 22, 9]), Op::Store(vec![12, 26, 31, 9]), Op::Const(G::from_u64(96)), Op::Call(476, vec![0, 33], 1, false), Op::Store(vec![8, 34, 7, 9]), Op::Store(vec![12, 35, 17, 9]), Op::Store(vec![12, 36, 22, 9]), Op::Store(vec![12, 32, 37, 9]), Op::Store(vec![23, 11, 38, 9]), Op::Store(vec![23, 11, 39, 9])], ctrl: Ctrl::Return(45, vec![40]) }), (G::from_u64(6147), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Const(G::from_u64(3)), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![15, 14, 16, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![15, 14, 18, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![8, 22, 7, 9]), Op::Const(G::from_u64(94)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![8, 25, 7, 9]), Op::Store(vec![15, 26, 17, 9]), Op::Store(vec![15, 27, 19, 9]), Op::Store(vec![15, 23, 28, 9]), Op::Const(G::from_u64(96)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![8, 31, 7, 9]), Op::Store(vec![15, 32, 17, 9]), Op::Store(vec![15, 33, 19, 9]), Op::Store(vec![15, 29, 34, 9]), Op::Store(vec![20, 11, 35, 9]), Op::Store(vec![20, 11, 36, 9])], ctrl: Ctrl::Return(46, vec![37]) }), (G::from_u64(6208), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 10, 7, 11]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(97)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![8, 16, 7, 11]), Op::Store(vec![11, 6, 11, 11]), Op::Store(vec![14, 17, 18, 11]), Op::Store(vec![11, 11, 11, 11]), Op::Store(vec![14, 19, 20, 11]), Op::Store(vec![13, 12, 21, 11]), Op::Store(vec![13, 12, 22, 11])], ctrl: Ctrl::Return(47, vec![23]) }), (G::from_u64(6272), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![9, 11, 7, 12]), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 14, 7, 12]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(98)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![9, 18, 7, 12]), Op::Store(vec![12, 6, 12, 12]), Op::Store(vec![16, 19, 20, 12]), Op::Store(vec![12, 12, 12, 12]), Op::Store(vec![16, 21, 22, 12]), Op::Store(vec![8, 15, 23, 12]), Op::Store(vec![8, 13, 24, 12])], ctrl: Ctrl::Return(48, vec![25]) }), (G::from_u64(6336), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![9, 11, 7, 12]), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 14, 7, 12]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(99)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![9, 18, 7, 12]), Op::Store(vec![12, 6, 12, 12]), Op::Store(vec![16, 19, 20, 12]), Op::Store(vec![12, 12, 12, 12]), Op::Store(vec![16, 21, 22, 12]), Op::Store(vec![8, 15, 23, 12]), Op::Store(vec![8, 13, 24, 12])], ctrl: Ctrl::Return(49, vec![25]) }), (G::from_u64(6464), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(101)), Op::Call(476, vec![0, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![9, 11, 7, 12]), Op::Const(G::from_u64(38)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![9, 15, 7, 12]), Op::Const(G::from_u64(30)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![12, 12, 12]), Op::Store(vec![12, 19, 7]), Op::Store(vec![9, 18, 20, 12]), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![9, 23, 7, 12]), Op::Store(vec![8, 21, 24, 12]), Op::Store(vec![8, 16, 25, 12]), Op::Store(vec![8, 13, 26, 12])], ctrl: Ctrl::Return(50, vec![27]) }), (G::from_u64(6465), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 10, 7, 11]), Op::Store(vec![11, 11, 11]), Op::Store(vec![11, 13, 7]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(29)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 14, 11]), Op::Store(vec![16, 19, 12, 11]), Op::Const(G::from_u64(101)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![8, 22, 7, 11]), Op::Const(G::from_u64(38)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![8, 25, 7, 11]), Op::Const(G::from_u64(31)), Op::Call(476, vec![0, 27], 1, false), Op::Store(vec![8, 28, 14, 11]), Op::Store(vec![16, 29, 12, 11]), Op::Store(vec![11, 6, 11, 11]), Op::Store(vec![16, 30, 31, 11]), Op::Store(vec![11, 11, 11, 11]), Op::Store(vec![16, 32, 33, 11]), Op::Store(vec![16, 26, 34, 11]), Op::Store(vec![16, 23, 35, 11]), Op::Store(vec![15, 20, 36, 11]), Op::Store(vec![15, 12, 37, 11])], ctrl: Ctrl::Return(51, vec![38]) }), (G::from_u64(6528), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(102)), Op::Call(476, vec![0, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![9, 11, 7, 12]), Op::Const(G::from_u64(38)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![9, 15, 7, 12]), Op::Const(G::from_u64(30)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![12, 12, 12]), Op::Store(vec![12, 19, 7]), Op::Store(vec![9, 18, 20, 12]), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![9, 23, 7, 12]), Op::Store(vec![8, 21, 24, 12]), Op::Store(vec![8, 16, 25, 12]), Op::Store(vec![8, 13, 26, 12])], ctrl: Ctrl::Return(52, vec![27]) }), (G::from_u64(6529), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 10, 7, 11]), Op::Store(vec![11, 11, 11]), Op::Store(vec![11, 13, 7]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(102)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 11]), Op::Const(G::from_u64(38)), Op::Call(476, vec![0, 20], 1, false), Op::Store(vec![8, 21, 7, 11]), Op::Const(G::from_u64(31)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![8, 24, 14, 11]), Op::Store(vec![16, 25, 12, 11]), Op::Store(vec![11, 11, 11, 11]), Op::Store(vec![16, 26, 27, 11]), Op::Const(G::from_u64(30)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 14, 11]), Op::Store(vec![16, 31, 12, 11]), Op::Store(vec![16, 28, 32, 11]), Op::Store(vec![16, 22, 33, 11]), Op::Store(vec![16, 19, 34, 11]), Op::Store(vec![15, 12, 35, 11])], ctrl: Ctrl::Return(53, vec![36]) }), (G::from_u64(6530), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 10, 7, 11]), Op::Store(vec![11, 11, 11]), Op::Store(vec![11, 13, 7]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(31)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![8, 17, 14, 11]), Op::Store(vec![15, 18, 12, 11]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(29)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![8, 22, 14, 11]), Op::Store(vec![15, 23, 12, 11]), Op::Const(G::from_u64(102)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 11]), Op::Const(G::from_u64(38)), Op::Call(476, vec![0, 28], 1, false), Op::Store(vec![8, 29, 7, 11]), Op::Store(vec![11, 8, 11, 11]), Op::Store(vec![15, 19, 31, 11]), Op::Store(vec![11, 6, 11, 11]), Op::Store(vec![15, 19, 33, 11]), Op::Store(vec![11, 11, 11, 11]), Op::Store(vec![15, 34, 35, 11]), Op::Store(vec![15, 32, 36, 11]), Op::Store(vec![15, 30, 37, 11]), Op::Store(vec![15, 27, 38, 11]), Op::Store(vec![20, 24, 39, 11]), Op::Store(vec![20, 12, 40, 11]), Op::Store(vec![20, 12, 41, 11])], ctrl: Ctrl::Return(54, vec![42]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7]), Op::Store(vec![6, 8, 7, 7])], ctrl: Ctrl::Return(55, vec![9]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 56, auxiliaries: 58, lookups: 32 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_566() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(64)), Op::Mul(3, 1), Op::Add(4, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(4160), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8]), Op::Store(vec![7, 9, 8, 8]), Op::Store(vec![8, 8, 8, 8]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![7, 7, 7]), Op::Store(vec![12, 14, 15, 8]), Op::Store(vec![6, 11, 16, 8]), Op::Store(vec![6, 10, 17, 8])], ctrl: Ctrl::Return(0, vec![18]) }), (G::from_u64(4161), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 10, 9, 9]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(62)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![13, 15, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![12, 16, 17, 9]), Op::Const(G::from_u64(5)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![13, 20, 7, 9]), Op::Store(vec![8, 18, 21, 9]), Op::Store(vec![8, 11, 22, 9])], ctrl: Ctrl::Return(1, vec![23]) }), (G::from_u64(4288), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(46)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 16, 17, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 18, 19, 9]), Op::Store(vec![12, 11, 20, 9]), Op::Store(vec![12, 11, 21, 9])], ctrl: Ctrl::Return(2, vec![22]) }), (G::from_u64(4352), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 16, 17, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 18, 19, 9]), Op::Store(vec![12, 11, 20, 9]), Op::Store(vec![12, 11, 21, 9])], ctrl: Ctrl::Return(3, vec![22]) }), (G::from_u64(4416), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(68)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 18, 19, 9]), Op::Store(vec![13, 16, 20, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 21, 22, 9]), Op::Store(vec![12, 11, 23, 9]), Op::Store(vec![12, 11, 24, 9])], ctrl: Ctrl::Return(4, vec![25]) }), (G::from_u64(4672), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![9, 11, 7, 12]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![9, 14, 7, 12]), Op::Store(vec![8, 13, 15, 12])], ctrl: Ctrl::Return(5, vec![16]) }), (G::from_u64(4673), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![9, 11, 7, 10]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![9, 15, 7, 10]), Op::Store(vec![10, 10, 10, 10]), Op::Store(vec![13, 16, 17, 10]), Op::Store(vec![8, 12, 18, 10])], ctrl: Ctrl::Return(6, vec![19]) }), (G::from_u64(4800), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![9, 11, 7, 10]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(73)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![9, 15, 7, 10]), Op::Store(vec![10, 10, 10, 10]), Op::Store(vec![13, 16, 17, 10]), Op::Store(vec![8, 12, 18, 10])], ctrl: Ctrl::Return(7, vec![19]) }), (G::from_u64(4801), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![9, 11, 7, 10]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![9, 15, 7, 10]), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![9, 17, 7, 10]), Op::Store(vec![10, 10, 10, 10]), Op::Store(vec![13, 18, 19, 10]), Op::Store(vec![13, 16, 20, 10]), Op::Store(vec![8, 12, 21, 10])], ctrl: Ctrl::Return(8, vec![22]) }), (G::from_u64(4864), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(42)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 19, 20, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 21, 22, 9]), Op::Store(vec![13, 16, 23, 9]), Op::Store(vec![12, 11, 24, 9]), Op::Store(vec![12, 11, 25, 9])], ctrl: Ctrl::Return(9, vec![26]) }), (G::from_u64(4865), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(74)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 16, 17, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 20, 21, 9]), Op::Store(vec![13, 18, 22, 9]), Op::Store(vec![12, 11, 23, 9]), Op::Store(vec![12, 11, 24, 9])], ctrl: Ctrl::Return(10, vec![25]) }), (G::from_u64(4866), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(74)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 16, 17, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 20, 21, 9]), Op::Store(vec![13, 18, 22, 9]), Op::Store(vec![12, 11, 23, 9]), Op::Store(vec![12, 11, 24, 9])], ctrl: Ctrl::Return(11, vec![25]) }), (G::from_u64(4867), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Const(G::from_u64(42)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 20, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 21, 22, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 23, 24, 9]), Op::Store(vec![13, 18, 25, 9]), Op::Store(vec![13, 16, 26, 9]), Op::Store(vec![12, 11, 27, 9]), Op::Store(vec![12, 11, 28, 9])], ctrl: Ctrl::Return(12, vec![29]) }), (G::from_u64(4928), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 10, 7, 11]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(76)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![8, 16, 7, 11]), Op::Store(vec![11, 6, 11, 11]), Op::Store(vec![14, 17, 18, 11]), Op::Const(G::from_u64(75)), Op::Call(476, vec![0, 20], 1, false), Op::Store(vec![8, 21, 7, 11]), Op::Store(vec![11, 11, 11, 11]), Op::Store(vec![14, 22, 23, 11]), Op::Store(vec![14, 19, 24, 11]), Op::Store(vec![13, 12, 25, 11]), Op::Store(vec![13, 12, 26, 11])], ctrl: Ctrl::Return(13, vec![27]) }), (G::from_u64(4992), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 19, 20, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 21, 22, 9]), Op::Store(vec![13, 16, 23, 9]), Op::Store(vec![12, 11, 24, 9]), Op::Store(vec![12, 11, 25, 9])], ctrl: Ctrl::Return(14, vec![26]) }), (G::from_u64(4993), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(73)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 19, 20, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 22, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 23, 24, 9]), Op::Store(vec![13, 21, 25, 9]), Op::Store(vec![13, 16, 26, 9]), Op::Store(vec![12, 11, 27, 9]), Op::Store(vec![12, 11, 28, 9])], ctrl: Ctrl::Return(15, vec![29]) }), (G::from_u64(4994), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(73)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 20, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 21, 22, 9]), Op::Store(vec![13, 19, 23, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 24, 25, 9]), Op::Store(vec![13, 16, 26, 9]), Op::Store(vec![12, 11, 27, 9]), Op::Store(vec![12, 11, 28, 9])], ctrl: Ctrl::Return(16, vec![29]) }), (G::from_u64(4995), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 12, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 20, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![15, 13, 22, 9]), Op::Store(vec![15, 21, 23, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![15, 13, 25, 9]), Op::Store(vec![15, 24, 26, 9]), Op::Store(vec![15, 18, 27, 9]), Op::Store(vec![14, 11, 28, 9]), Op::Store(vec![14, 11, 29, 9])], ctrl: Ctrl::Return(17, vec![30]) }), (G::from_u64(5056), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 8], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10]), Op::Store(vec![7, 9, 11, 8]), Op::Store(vec![8, 8, 8, 8]), Op::Store(vec![6, 12, 13, 8])], ctrl: Ctrl::Return(18, vec![14]) }), (G::from_u64(5057), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![9, 11, 7, 10]), Op::Const(G::from_u64(3)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![9, 14, 7, 10]), Op::Store(vec![10, 10, 10, 10]), Op::Store(vec![13, 15, 16, 10]), Op::Store(vec![8, 12, 17, 10])], ctrl: Ctrl::Return(19, vec![18]) }), (G::from_u64(5120), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(48)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 19, 20, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 21, 22, 9]), Op::Store(vec![13, 16, 23, 9]), Op::Store(vec![12, 11, 24, 9]), Op::Store(vec![12, 11, 25, 9])], ctrl: Ctrl::Return(20, vec![26]) }), (G::from_u64(5121), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(75)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Const(G::from_u64(48)), Op::Call(476, vec![0, 20], 1, false), Op::Store(vec![8, 21, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 22, 23, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 25, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 26, 27, 9]), Op::Store(vec![13, 24, 28, 9]), Op::Store(vec![13, 19, 29, 9]), Op::Store(vec![13, 16, 30, 9]), Op::Store(vec![12, 11, 31, 9]), Op::Store(vec![12, 11, 32, 9])], ctrl: Ctrl::Return(21, vec![33]) }), (G::from_u64(5122), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![9, 11, 7, 10]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![9, 15, 7, 10]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![9, 17, 7, 10]), Op::Store(vec![13, 16, 18, 10]), Op::Store(vec![8, 12, 19, 10])], ctrl: Ctrl::Return(22, vec![20]) }), (G::from_u64(5123), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(48)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 19, 20, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 22, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 23, 24, 9]), Op::Store(vec![13, 21, 25, 9]), Op::Store(vec![13, 16, 26, 9]), Op::Store(vec![12, 11, 27, 9]), Op::Store(vec![12, 11, 28, 9])], ctrl: Ctrl::Return(23, vec![29]) }), (G::from_u64(5124), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 12, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Const(G::from_u64(48)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 20, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![15, 21, 22, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![15, 13, 24, 9]), Op::Store(vec![15, 23, 25, 9]), Op::Store(vec![15, 13, 26, 9]), Op::Store(vec![15, 18, 27, 9]), Op::Store(vec![14, 11, 28, 9]), Op::Store(vec![14, 11, 29, 9])], ctrl: Ctrl::Return(24, vec![30]) }), (G::from_u64(5184), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 19, 20, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 21, 22, 9]), Op::Store(vec![13, 16, 23, 9]), Op::Store(vec![12, 11, 24, 9]), Op::Store(vec![12, 11, 25, 9])], ctrl: Ctrl::Return(25, vec![26]) }), (G::from_u64(5185), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 19, 20, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 22, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 23, 24, 9]), Op::Store(vec![13, 21, 25, 9]), Op::Store(vec![13, 16, 26, 9]), Op::Store(vec![12, 11, 27, 9]), Op::Store(vec![12, 11, 28, 9])], ctrl: Ctrl::Return(26, vec![29]) }), (G::from_u64(5186), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(74)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![8, 16, 7, 9]), Op::Store(vec![14, 17, 12, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![8, 22, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![14, 23, 24, 9]), Op::Store(vec![14, 25, 12, 9]), Op::Store(vec![14, 20, 26, 9]), Op::Store(vec![14, 18, 27, 9]), Op::Store(vec![13, 11, 28, 9]), Op::Store(vec![13, 11, 29, 9])], ctrl: Ctrl::Return(27, vec![30]) }), (G::from_u64(5187), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 12, 7, 9]), Op::Const(G::from_u64(3)), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![14, 13, 15, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(74)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![14, 20, 16, 9]), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![8, 23, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![14, 24, 25, 9]), Op::Store(vec![14, 26, 16, 9]), Op::Store(vec![14, 13, 27, 9]), Op::Store(vec![14, 21, 28, 9]), Op::Store(vec![17, 11, 29, 9]), Op::Store(vec![17, 11, 30, 9])], ctrl: Ctrl::Return(28, vec![31]) }), (G::from_u64(5248), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(45)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 19, 20, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 21, 22, 9]), Op::Store(vec![13, 16, 23, 9]), Op::Store(vec![12, 11, 24, 9]), Op::Store(vec![12, 11, 25, 9])], ctrl: Ctrl::Return(29, vec![26]) }), (G::from_u64(5440), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 12, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![15, 18, 19, 9]), Op::Const(G::from_u64(45)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![8, 22, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 24, 7, 9]), Op::Store(vec![15, 13, 25, 9]), Op::Store(vec![15, 13, 26, 9]), Op::Store(vec![15, 23, 27, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![15, 28, 29, 9]), Op::Store(vec![15, 20, 30, 9]), Op::Store(vec![14, 11, 31, 9]), Op::Store(vec![14, 11, 32, 9])], ctrl: Ctrl::Return(30, vec![33]) }), (G::from_u64(5504), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 12, 7, 9]), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(45)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 21, 7, 9]), Op::Store(vec![17, 13, 22, 9]), Op::Store(vec![17, 13, 23, 9]), Op::Store(vec![17, 20, 24, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Store(vec![17, 25, 26, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![17, 16, 32, 9]), Op::Store(vec![17, 33, 27, 9]), Op::Store(vec![17, 13, 34, 9]), Op::Store(vec![17, 31, 35, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![17, 16, 37, 9]), Op::Store(vec![17, 38, 27, 9]), Op::Store(vec![17, 36, 39, 9]), Op::Store(vec![28, 11, 40, 9]), Op::Store(vec![28, 11, 41, 9]), Op::Store(vec![28, 11, 42, 9])], ctrl: Ctrl::Return(31, vec![43]) }), (G::from_u64(5568), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(37)), Op::Call(476, vec![0, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![9, 11, 7, 12]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![9, 15, 7, 12]), Op::Store(vec![8, 13, 16, 12])], ctrl: Ctrl::Return(32, vec![17]) }), (G::from_u64(5760), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(89)), Op::Call(476, vec![0, 7], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Const(G::from_u64(0)), Op::Store(vec![6, 8, 10, 11])], ctrl: Ctrl::Return(33, vec![12]) }), (G::from_u64(5824), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 7]), Op::Store(vec![7, 7, 7, 7]), Op::Const(G::from_u64(1)), Op::Store(vec![10, 8, 7]), Op::Store(vec![10, 11, 7, 7]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(29)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![10, 10, 10]), Op::Store(vec![7, 8, 17]), Op::Store(vec![14, 16, 18, 7]), Op::Store(vec![13, 19, 9, 7]), Op::Store(vec![6, 20, 9, 7]), Op::Store(vec![6, 12, 21, 7])], ctrl: Ctrl::Return(34, vec![22]) }), (G::from_u64(5825), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 7]), Op::Store(vec![7, 7, 7, 7]), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10]), Op::Store(vec![7, 8, 11]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(29)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![13, 15, 12, 7]), Op::Store(vec![7, 10, 7, 7]), Op::Store(vec![7, 13, 7, 7]), Op::Const(G::from_u64(3)), Op::Store(vec![7, 19, 7, 7]), Op::Store(vec![10, 8, 7]), Op::Store(vec![10, 21, 7, 7]), Op::Store(vec![19, 16, 17, 7]), Op::Store(vec![19, 16, 18, 7]), Op::Const(G::from_u64(31)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![13, 26, 12, 7]), Op::Store(vec![19, 27, 20, 7]), Op::Store(vec![19, 28, 18, 7]), Op::Const(G::from_u64(91)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![13, 31, 12, 7]), Op::Store(vec![19, 32, 20, 7]), Op::Store(vec![19, 33, 17, 7]), Op::Store(vec![19, 34, 9, 7]), Op::Store(vec![19, 29, 35, 7]), Op::Store(vec![6, 24, 36, 7]), Op::Store(vec![6, 23, 37, 7]), Op::Store(vec![6, 9, 38, 7]), Op::Store(vec![6, 22, 39, 7])], ctrl: Ctrl::Return(35, vec![40]) }), (G::from_u64(5888), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8]), Op::Store(vec![8, 9, 7]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![11, 13, 7, 8]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(29)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![11, 17, 10, 8]), Op::Store(vec![15, 18, 14, 8]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(38)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![11, 22, 7, 8]), Op::Const(G::from_u64(91)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![11, 25, 10, 8]), Op::Store(vec![15, 26, 14, 8]), Op::Store(vec![8, 6, 8, 8]), Op::Store(vec![15, 27, 28, 8]), Op::Store(vec![8, 8, 8, 8]), Op::Store(vec![15, 29, 30, 8]), Op::Store(vec![15, 23, 31, 8]), Op::Store(vec![20, 19, 32, 8]), Op::Store(vec![20, 19, 33, 8])], ctrl: Ctrl::Return(36, vec![34]) }), (G::from_u64(5952), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![6, 8, 8]), Op::Store(vec![7, 9, 8, 8]), Op::Store(vec![8, 8, 8]), Op::Store(vec![7, 11, 8, 8]), Op::Store(vec![8, 8, 8, 8]), Op::Const(G::from_u64(2)), Op::Store(vec![8, 14, 8, 8]), Op::Const(G::from_u64(3)), Op::Store(vec![8, 16, 8, 8]), Op::Store(vec![8, 7, 8, 8]), Op::Store(vec![6, 17, 18, 8]), Op::Store(vec![6, 15, 19, 8]), Op::Store(vec![6, 13, 20, 8]), Op::Store(vec![6, 12, 21, 8]), Op::Store(vec![6, 10, 22, 8])], ctrl: Ctrl::Return(37, vec![23]) }), (G::from_u64(5953), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6, 6]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(1)), Op::Store(vec![8, 6, 6]), Op::Store(vec![9, 10, 6, 6]), Op::Store(vec![6, 6, 6]), Op::Store(vec![9, 12, 6, 6]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(62)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![15, 17, 18, 6]), Op::Store(vec![14, 19, 7, 6]), Op::Store(vec![6, 15, 6, 6]), Op::Store(vec![6, 14, 6, 6]), Op::Store(vec![8, 22, 7, 6]), Op::Store(vec![8, 21, 23, 6]), Op::Store(vec![8, 20, 24, 6]), Op::Store(vec![8, 13, 25, 6]), Op::Store(vec![8, 11, 26, 6])], ctrl: Ctrl::Return(38, vec![27]) }), (G::from_u64(6080), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(46)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 16, 17, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 18, 19, 9]), Op::Store(vec![12, 11, 20, 9]), Op::Store(vec![12, 11, 21, 9])], ctrl: Ctrl::Return(39, vec![22]) }), (G::from_u64(6081), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(5)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![8, 14, 7, 9]), Op::Store(vec![12, 11, 15, 9]), Op::Store(vec![12, 11, 16, 9])], ctrl: Ctrl::Return(40, vec![17]) }), (G::from_u64(6082), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(5)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![8, 14, 7, 9]), Op::Store(vec![12, 11, 15, 9]), Op::Store(vec![12, 11, 16, 9])], ctrl: Ctrl::Return(41, vec![17]) }), (G::from_u64(6083), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(46)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 16, 17, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 18, 19, 9]), Op::Store(vec![12, 11, 20, 9]), Op::Store(vec![12, 11, 21, 9])], ctrl: Ctrl::Return(42, vec![22]) }), (G::from_u64(6144), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 16, 17, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 18, 19, 9]), Op::Store(vec![12, 11, 20, 9]), Op::Store(vec![12, 11, 21, 9])], ctrl: Ctrl::Return(43, vec![22]) }), (G::from_u64(6145), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(5)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![8, 14, 7, 9]), Op::Store(vec![12, 11, 15, 9]), Op::Store(vec![12, 11, 16, 9])], ctrl: Ctrl::Return(44, vec![17]) }), (G::from_u64(6146), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![8, 14, 7, 9]), Op::Store(vec![12, 11, 15, 9]), Op::Store(vec![12, 11, 16, 9])], ctrl: Ctrl::Return(45, vec![17]) }), (G::from_u64(6147), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![13, 16, 17, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![13, 18, 19, 9]), Op::Store(vec![12, 11, 20, 9]), Op::Store(vec![12, 11, 21, 9])], ctrl: Ctrl::Return(46, vec![22]) }), (G::from_u64(6208), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 10, 7, 11]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(96)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![8, 16, 7, 11]), Op::Const(G::from_u64(76)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![8, 19, 7, 11]), Op::Store(vec![11, 6, 11, 11]), Op::Store(vec![14, 20, 21, 11]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![8, 24, 7, 11]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 26, 7, 11]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 28, 7, 11]), Op::Store(vec![14, 27, 29, 11]), Op::Store(vec![14, 25, 30, 11]), Op::Store(vec![14, 22, 31, 11]), Op::Store(vec![14, 17, 32, 11]), Op::Store(vec![11, 11, 11, 11]), Op::Store(vec![14, 33, 34, 11]), Op::Store(vec![13, 12, 35, 11]), Op::Store(vec![13, 12, 36, 11])], ctrl: Ctrl::Return(47, vec![37]) }), (G::from_u64(6272), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 10, 7, 11]), Op::Const(G::from_u64(76)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![8, 14, 7, 11]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![8, 17, 7, 11]), Op::Const(G::from_u64(3)), Op::Store(vec![11, 11, 11, 11]), Op::Store(vec![19, 18, 20, 11]), Op::Const(G::from_u64(81)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![8, 23, 7, 11]), Op::Store(vec![11, 6, 11, 11]), Op::Store(vec![19, 24, 25, 11]), Op::Store(vec![19, 26, 21, 11]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 28, 7, 11]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 30, 7, 11]), Op::Store(vec![19, 29, 31, 11]), Op::Store(vec![19, 18, 32, 11]), Op::Const(G::from_u64(80)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![8, 35, 7, 11]), Op::Store(vec![19, 15, 21, 11]), Op::Store(vec![19, 37, 33, 11]), Op::Store(vec![19, 36, 38, 11]), Op::Store(vec![19, 29, 32, 11]), Op::Store(vec![19, 18, 40, 11]), Op::Store(vec![19, 39, 41, 11]), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 11], 1, false), Op::Store(vec![8, 44, 7, 11]), Op::Const(G::from_u64(93)), Op::Call(476, vec![0, 46], 1, false), Op::Store(vec![11, 11, 11]), Op::Store(vec![6, 48, 11]), Op::Store(vec![11, 49, 7]), Op::Store(vec![8, 47, 50, 11]), Op::Store(vec![19, 51, 12, 11]), Op::Const(G::from_u64(94)), Op::Call(476, vec![0, 53], 1, false), Op::Store(vec![8, 54, 7, 11]), Op::Store(vec![19, 15, 27, 11]), Op::Store(vec![19, 56, 33, 11]), Op::Store(vec![19, 55, 57, 11]), Op::Store(vec![19, 58, 42, 11]), Op::Store(vec![19, 52, 59, 11]), Op::Const(G::from_u64(97)), Op::Call(476, vec![0, 61], 1, false), Op::Store(vec![8, 62, 7, 11]), Op::Store(vec![19, 63, 27, 11]), Op::Store(vec![19, 64, 42, 11]), Op::Store(vec![19, 60, 65, 11]), Op::Store(vec![19, 66, 27, 11]), Op::Const(G::from_u64(77)), Op::Call(476, vec![0, 68], 1, false), Op::Store(vec![8, 69, 7, 11]), Op::Store(vec![19, 70, 27, 11]), Op::Store(vec![19, 71, 21, 11]), Op::Store(vec![19, 67, 72, 11]), Op::Store(vec![43, 45, 73, 11]), Op::Store(vec![43, 12, 74, 11])], ctrl: Ctrl::Return(48, vec![75]) }), (G::from_u64(6336), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 10, 7, 11]), Op::Call(476, vec![0, 11], 1, false), Op::Store(vec![8, 13, 7, 11]), Op::Store(vec![11, 11, 11]), Op::Store(vec![6, 15, 11]), Op::Store(vec![11, 16, 7]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(93)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 20, 17, 11]), Op::Store(vec![18, 21, 12, 11]), Op::Store(vec![11, 11, 11, 11]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 24, 7, 11]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![8, 27, 7, 11]), Op::Const(G::from_u64(76)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 11]), Op::Store(vec![11, 6, 11, 11]), Op::Store(vec![18, 28, 23, 11]), Op::Const(G::from_u64(81)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![8, 35, 7, 11]), Op::Store(vec![18, 36, 32, 11]), Op::Store(vec![18, 37, 33, 11]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 39, 7, 11]), Op::Store(vec![18, 40, 25, 11]), Op::Store(vec![18, 28, 41, 11]), Op::Const(G::from_u64(80)), Op::Call(476, vec![0, 43], 1, false), Op::Store(vec![8, 44, 7, 11]), Op::Store(vec![18, 31, 33, 11]), Op::Store(vec![18, 46, 42, 11]), Op::Store(vec![18, 45, 47, 11]), Op::Store(vec![18, 40, 41, 11]), Op::Store(vec![18, 28, 49, 11]), Op::Store(vec![18, 48, 50, 11]), Op::Store(vec![18, 45, 32, 11]), Op::Store(vec![18, 52, 33, 11]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 55], 1, false), Op::Store(vec![8, 56, 17, 11]), Op::Store(vec![18, 57, 14, 11]), Op::Store(vec![18, 58, 23, 11]), Op::Store(vec![18, 59, 25, 11]), Op::Store(vec![18, 22, 60, 11]), Op::Const(G::from_u64(67)), Op::Call(476, vec![0, 62], 1, false), Op::Store(vec![8, 63, 7, 11]), Op::Store(vec![18, 64, 23, 11]), Op::Store(vec![18, 65, 25, 11]), Op::Store(vec![18, 61, 66, 11]), Op::Store(vec![18, 28, 25, 11]), Op::Store(vec![18, 67, 68, 11]), Op::Const(G::from_u64(94)), Op::Call(476, vec![0, 70], 1, false), Op::Store(vec![8, 71, 7, 11]), Op::Store(vec![18, 31, 38, 11]), Op::Store(vec![18, 73, 42, 11]), Op::Store(vec![18, 72, 74, 11]), Op::Store(vec![18, 75, 51, 11]), Op::Store(vec![18, 22, 76, 11]), Op::Const(G::from_u64(97)), Op::Call(476, vec![0, 78], 1, false), Op::Store(vec![8, 79, 7, 11]), Op::Store(vec![18, 80, 38, 11]), Op::Store(vec![18, 81, 51, 11]), Op::Store(vec![18, 77, 82, 11]), Op::Store(vec![18, 83, 53, 11]), Op::Store(vec![18, 31, 53, 11]), Op::Store(vec![18, 85, 42, 11]), Op::Store(vec![18, 84, 86, 11]), Op::Store(vec![18, 69, 87, 11]), Op::Store(vec![54, 14, 88, 11]), Op::Store(vec![54, 12, 89, 11])], ctrl: Ctrl::Return(49, vec![90]) }), (G::from_u64(6464), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1)), Op::Call(476, vec![0, 7], 1, false), Op::Store(vec![7, 7, 7]), Op::Const(G::from_u64(0)), Op::Store(vec![6, 8, 9, 10])], ctrl: Ctrl::Return(50, vec![11]) }), (G::from_u64(6465), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 10, 7, 11]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(29)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![11, 11, 11]), Op::Store(vec![11, 17, 7]), Op::Store(vec![8, 16, 18, 11]), Op::Store(vec![14, 19, 12, 11]), Op::Const(G::from_u64(42)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![8, 22, 7, 11]), Op::Const(G::from_u64(100)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![8, 25, 7, 11]), Op::Store(vec![11, 6, 11, 11]), Op::Store(vec![14, 26, 27, 11]), Op::Store(vec![14, 23, 28, 11]), Op::Const(G::from_u64(101)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![8, 31, 7, 11]), Op::Const(G::from_u64(38)), Op::Call(476, vec![0, 33], 1, false), Op::Store(vec![8, 34, 7, 11]), Op::Store(vec![11, 11, 11, 11]), Op::Store(vec![14, 35, 36, 11]), Op::Store(vec![14, 32, 37, 11]), Op::Store(vec![14, 29, 38, 11]), Op::Store(vec![13, 20, 39, 11]), Op::Store(vec![13, 12, 40, 11])], ctrl: Ctrl::Return(51, vec![41]) }), (G::from_u64(6528), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Call(476, vec![0, 8], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 9, 7, 10]), Op::Const(G::from_u64(3)), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 13, 7, 10]), Op::Store(vec![12, 11, 14, 10]), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![8, 17, 7, 10]), Op::Store(vec![12, 11, 15, 10]), Op::Store(vec![12, 18, 19, 10]), Op::Const(G::from_u64(40)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![8, 22, 7, 10]), Op::Store(vec![12, 20, 15, 10]), Op::Store(vec![12, 20, 24, 10]), Op::Store(vec![12, 20, 25, 10]), Op::Store(vec![12, 20, 26, 10]), Op::Store(vec![12, 20, 27, 10]), Op::Store(vec![12, 20, 28, 10]), Op::Store(vec![12, 11, 29, 10]), Op::Store(vec![12, 23, 30, 10])], ctrl: Ctrl::Return(52, vec![31]) }), (G::from_u64(6529), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 8], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10]), Op::Const(G::from_u64(0)), Op::Store(vec![7, 9, 11, 12]), Op::Store(vec![12, 12, 12, 12]), Op::Store(vec![6, 13, 14, 12])], ctrl: Ctrl::Return(53, vec![15]) }), (G::from_u64(6530), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 10, 7, 11]), Op::Store(vec![11, 11, 11]), Op::Store(vec![11, 13, 7]), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(29)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![8, 18, 14, 11]), Op::Store(vec![16, 19, 12, 11]), Op::Const(G::from_u64(102)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![8, 22, 7, 11]), Op::Const(G::from_u64(38)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![8, 25, 7, 11]), Op::Const(G::from_u64(31)), Op::Call(476, vec![0, 27], 1, false), Op::Store(vec![8, 28, 14, 11]), Op::Store(vec![16, 29, 12, 11]), Op::Store(vec![11, 6, 11, 11]), Op::Store(vec![16, 30, 31, 11]), Op::Store(vec![11, 11, 11, 11]), Op::Store(vec![16, 32, 33, 11]), Op::Store(vec![16, 26, 34, 11]), Op::Store(vec![16, 23, 35, 11]), Op::Store(vec![15, 20, 36, 11]), Op::Store(vec![15, 12, 37, 11]), Op::Store(vec![15, 12, 38, 11])], ctrl: Ctrl::Return(54, vec![39]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7]), Op::Store(vec![6, 8, 7, 7])], ctrl: Ctrl::Return(55, vec![9]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 56, auxiliaries: 71, lookups: 71 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_567() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(64)), Op::Mul(3, 1), Op::Add(4, 2)], ctrl: Ctrl::Match(5, [(G::from_u64(4160), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6]), Op::Store(vec![6, 6, 6, 6]), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 9, 6, 6]), Op::Const(G::from_u64(5)), Op::Store(vec![9, 7, 6, 6]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![9, 7, 6]), Op::Store(vec![6, 18, 10]), Op::Store(vec![15, 17, 19, 6]), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![15, 22, 10, 6]), Op::Store(vec![14, 20, 23, 6]), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![15, 26, 10, 6]), Op::Store(vec![14, 27, 11, 6]), Op::Const(G::from_u64(60)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![15, 30, 10, 6]), Op::Store(vec![14, 31, 11, 6]), Op::Store(vec![14, 32, 8, 6]), Op::Store(vec![14, 28, 33, 6]), Op::Store(vec![14, 24, 34, 6]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 36], 1, false), Op::Store(vec![15, 37, 10, 6]), Op::Store(vec![14, 35, 38, 6]), Op::Store(vec![12, 8, 39, 6]), Op::Store(vec![12, 13, 40, 6])], ctrl: Ctrl::Return(0, vec![41]) }), (G::from_u64(4161), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Store(vec![6, 6, 6, 6]), Op::Store(vec![6, 8, 6, 6]), Op::Const(G::from_u64(5)), Op::Store(vec![8, 7, 6, 6]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(62)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![15, 17, 9, 6]), Op::Store(vec![14, 18, 10, 6]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 20], 1, false), Op::Store(vec![8, 7, 6]), Op::Store(vec![6, 22, 9]), Op::Store(vec![15, 21, 23, 6]), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![15, 26, 9, 6]), Op::Store(vec![14, 24, 27, 6]), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![15, 30, 9, 6]), Op::Store(vec![14, 31, 11, 6]), Op::Const(G::from_u64(61)), Op::Call(476, vec![0, 33], 1, false), Op::Store(vec![15, 34, 9, 6]), Op::Store(vec![14, 35, 11, 6]), Op::Store(vec![14, 36, 10, 6]), Op::Store(vec![14, 32, 37, 6]), Op::Store(vec![14, 28, 38, 6]), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![15, 40, 9, 6]), Op::Store(vec![14, 39, 41, 6]), Op::Store(vec![12, 19, 42, 6]), Op::Store(vec![12, 13, 43, 6])], ctrl: Ctrl::Return(1, vec![44]) }), (G::from_u64(4162), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(59)), Op::Call(476, vec![0, 11], 1, false), Op::Store(vec![10, 12, 9, 6]), Op::Store(vec![6, 6, 6, 6]), Op::Store(vec![6, 8, 6, 6]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![8, 7, 6]), Op::Store(vec![6, 18, 9]), Op::Store(vec![10, 17, 19, 6]), Op::Store(vec![6, 10, 6, 6]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![10, 24, 9, 6]), Op::Store(vec![22, 25, 21, 6]), Op::Const(G::from_u64(5)), Op::Store(vec![8, 7, 6, 6]), Op::Store(vec![22, 13, 14, 6]), Op::Store(vec![22, 13, 15, 6]), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 31], 1, false), Op::Store(vec![10, 32, 9, 6]), Op::Store(vec![22, 20, 33, 6]), Op::Store(vec![22, 26, 15, 6]), Op::Store(vec![22, 34, 35, 6]), Op::Store(vec![22, 26, 14, 6]), Op::Store(vec![22, 36, 37, 6]), Op::Store(vec![6, 22, 6, 6]), Op::Store(vec![22, 13, 39, 6]), Op::Store(vec![22, 20, 40, 6]), Op::Store(vec![22, 41, 21, 6]), Op::Store(vec![22, 42, 15, 6]), Op::Store(vec![27, 38, 43, 6]), Op::Store(vec![27, 30, 44, 6]), Op::Store(vec![27, 29, 45, 6]), Op::Store(vec![27, 28, 46, 6])], ctrl: Ctrl::Return(2, vec![47]) }), (G::from_u64(4288), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![8, 23, 7, 9]), Op::Store(vec![21, 17, 24, 9]), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![8, 27, 7, 9]), Op::Store(vec![21, 17, 11, 9]), Op::Store(vec![21, 29, 18, 9]), Op::Store(vec![21, 30, 19, 9]), Op::Store(vec![21, 28, 31, 9]), Op::Const(G::from_u64(67)), Op::Call(476, vec![0, 33], 1, false), Op::Store(vec![8, 34, 7, 9]), Op::Store(vec![21, 35, 18, 9]), Op::Store(vec![21, 36, 19, 9]), Op::Store(vec![21, 32, 37, 9]), Op::Store(vec![21, 25, 38, 9]), Op::Const(G::from_u64(46)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Store(vec![21, 42, 18, 9]), Op::Store(vec![21, 43, 19, 9]), Op::Store(vec![21, 39, 44, 9]), Op::Store(vec![20, 11, 45, 9]), Op::Store(vec![20, 11, 46, 9])], ctrl: Ctrl::Return(3, vec![47]) }), (G::from_u64(4352), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 18, 9]), Op::Store(vec![9, 19, 7]), Op::Store(vec![8, 17, 20, 9]), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![8, 23, 7, 9]), Op::Store(vec![15, 21, 24, 9]), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![8, 27, 7, 9]), Op::Const(G::from_u64(66)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![15, 31, 12, 9]), Op::Store(vec![15, 32, 13, 9]), Op::Store(vec![15, 28, 33, 9]), Op::Const(G::from_u64(68)), Op::Call(476, vec![0, 35], 1, false), Op::Store(vec![8, 36, 7, 9]), Op::Store(vec![15, 37, 12, 9]), Op::Store(vec![15, 38, 13, 9]), Op::Store(vec![15, 34, 39, 9]), Op::Store(vec![15, 25, 40, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 42], 1, false), Op::Store(vec![8, 43, 7, 9]), Op::Store(vec![15, 44, 12, 9]), Op::Store(vec![15, 45, 13, 9]), Op::Store(vec![15, 41, 46, 9]), Op::Store(vec![14, 11, 47, 9]), Op::Store(vec![14, 11, 48, 9])], ctrl: Ctrl::Return(4, vec![49]) }), (G::from_u64(4416), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(3)), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 14, 7, 9]), Op::Store(vec![13, 15, 12, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 21, 9]), Op::Store(vec![9, 22, 7]), Op::Store(vec![8, 20, 23, 9]), Op::Const(G::from_u64(59)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Const(G::from_u64(66)), Op::Call(476, vec![0, 28], 1, false), Op::Store(vec![8, 29, 7, 9]), Op::Store(vec![13, 30, 16, 9]), Op::Store(vec![13, 31, 17, 9]), Op::Store(vec![13, 27, 32, 9]), Op::Store(vec![13, 24, 33, 9]), Op::Const(G::from_u64(69)), Op::Call(476, vec![0, 35], 1, false), Op::Store(vec![8, 36, 7, 9]), Op::Store(vec![13, 37, 12, 9]), Op::Store(vec![13, 38, 17, 9]), Op::Store(vec![13, 34, 39, 9]), Op::Const(G::from_u64(68)), Op::Call(476, vec![0, 41], 1, false), Op::Store(vec![8, 42, 7, 9]), Op::Store(vec![13, 43, 16, 9]), Op::Store(vec![13, 44, 17, 9]), Op::Store(vec![13, 40, 45, 9]), Op::Store(vec![18, 11, 46, 9]), Op::Store(vec![18, 11, 47, 9])], ctrl: Ctrl::Return(5, vec![48]) }), (G::from_u64(4672), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Call(476, vec![0, 6], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 9, 7, 10]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![10, 10, 10]), Op::Store(vec![6, 15, 10]), Op::Store(vec![10, 16, 7]), Op::Store(vec![8, 14, 17, 10]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 20, 7, 10]), Op::Store(vec![12, 18, 21, 10]), Op::Const(G::from_u64(73)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![8, 24, 7, 10]), Op::Store(vec![12, 25, 11, 10]), Op::Store(vec![12, 22, 26, 10]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 28], 1, false), Op::Store(vec![8, 29, 7, 10]), Op::Store(vec![12, 30, 11, 10]), Op::Store(vec![12, 27, 31, 10])], ctrl: Ctrl::Return(6, vec![32]) }), (G::from_u64(4673), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8, 8]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(2)), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![11, 12, 7, 8]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![8, 8, 8]), Op::Store(vec![6, 17, 8]), Op::Store(vec![8, 18, 7]), Op::Store(vec![11, 16, 19, 8]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![11, 22, 7, 8]), Op::Store(vec![14, 20, 23, 8]), Op::Const(G::from_u64(73)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![11, 26, 7, 8]), Op::Call(476, vec![0, 11], 1, false), Op::Store(vec![11, 28, 7, 8]), Op::Store(vec![14, 29, 9, 8]), Op::Store(vec![14, 27, 30, 8]), Op::Store(vec![14, 24, 31, 8]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 33], 1, false), Op::Store(vec![11, 34, 7, 8]), Op::Store(vec![14, 35, 9, 8]), Op::Store(vec![14, 32, 36, 8]), Op::Store(vec![10, 13, 37, 8])], ctrl: Ctrl::Return(7, vec![38]) }), (G::from_u64(4736), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![8, 23, 7, 9]), Op::Store(vec![21, 17, 24, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![8, 27, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![21, 28, 29, 9]), Op::Store(vec![21, 30, 18, 9]), Op::Store(vec![21, 25, 31, 9]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 33], 1, false), Op::Store(vec![8, 34, 7, 9]), Op::Store(vec![21, 32, 35, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 37], 1, false), Op::Store(vec![8, 38, 7, 9]), Op::Store(vec![21, 17, 39, 9]), Op::Const(G::from_u64(74)), Op::Call(476, vec![0, 41], 1, false), Op::Store(vec![8, 42, 7, 9]), Op::Store(vec![21, 43, 19, 9]), Op::Store(vec![21, 44, 18, 9]), Op::Store(vec![21, 40, 45, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 47], 1, false), Op::Store(vec![8, 48, 7, 9]), Op::Const(G::from_u64(43)), Op::Call(476, vec![0, 50], 1, false), Op::Store(vec![8, 51, 7, 9]), Op::Store(vec![21, 52, 19, 9]), Op::Store(vec![21, 53, 18, 9]), Op::Store(vec![21, 49, 54, 9]), Op::Store(vec![21, 46, 55, 9]), Op::Store(vec![20, 36, 56, 9]), Op::Store(vec![20, 11, 57, 9]), Op::Store(vec![20, 11, 58, 9])], ctrl: Ctrl::Return(8, vec![59]) }), (G::from_u64(4737), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![8, 23, 7, 9]), Op::Store(vec![21, 17, 24, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![8, 27, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![21, 28, 29, 9]), Op::Store(vec![21, 30, 18, 9]), Op::Store(vec![21, 25, 31, 9]), Op::Call(476, vec![0, 20], 1, false), Op::Store(vec![8, 33, 7, 9]), Op::Store(vec![21, 32, 34, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 36], 1, false), Op::Store(vec![8, 37, 7, 9]), Op::Store(vec![21, 17, 38, 9]), Op::Const(G::from_u64(74)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Store(vec![21, 42, 19, 9]), Op::Store(vec![21, 43, 18, 9]), Op::Store(vec![21, 39, 44, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 46], 1, false), Op::Store(vec![8, 47, 7, 9]), Op::Const(G::from_u64(41)), Op::Call(476, vec![0, 49], 1, false), Op::Store(vec![8, 50, 7, 9]), Op::Const(G::from_u64(43)), Op::Call(476, vec![0, 52], 1, false), Op::Store(vec![8, 53, 7, 9]), Op::Store(vec![21, 54, 18, 9]), Op::Store(vec![21, 55, 19, 9]), Op::Store(vec![21, 51, 56, 9]), Op::Store(vec![21, 48, 57, 9]), Op::Store(vec![21, 45, 58, 9]), Op::Store(vec![20, 35, 59, 9]), Op::Store(vec![20, 11, 60, 9]), Op::Store(vec![20, 11, 61, 9])], ctrl: Ctrl::Return(9, vec![62]) }), (G::from_u64(4800), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8, 8]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(2)), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![11, 12, 7, 8]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![8, 8, 8]), Op::Store(vec![6, 17, 8]), Op::Store(vec![8, 18, 7]), Op::Store(vec![11, 16, 19, 8]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![11, 22, 7, 8]), Op::Store(vec![14, 20, 23, 8]), Op::Const(G::from_u64(75)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![11, 26, 7, 8]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 28], 1, false), Op::Store(vec![11, 29, 7, 8]), Op::Store(vec![14, 30, 9, 8]), Op::Store(vec![14, 27, 31, 8]), Op::Store(vec![14, 24, 32, 8]), Op::Const(G::from_u64(73)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![11, 35, 7, 8]), Op::Store(vec![14, 36, 9, 8]), Op::Store(vec![14, 33, 37, 8]), Op::Store(vec![10, 13, 38, 8])], ctrl: Ctrl::Return(10, vec![39]) }), (G::from_u64(4801), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(0)), Op::Store(vec![8, 8, 8, 8]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(2)), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![11, 12, 7, 8]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![8, 8, 8]), Op::Store(vec![6, 17, 8]), Op::Store(vec![8, 18, 7]), Op::Store(vec![11, 16, 19, 8]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![11, 22, 7, 8]), Op::Store(vec![14, 20, 23, 8]), Op::Const(G::from_u64(75)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![11, 26, 7, 8]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 28], 1, false), Op::Store(vec![11, 29, 7, 8]), Op::Store(vec![14, 30, 9, 8]), Op::Store(vec![14, 27, 31, 8]), Op::Store(vec![14, 24, 32, 8]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![11, 35, 7, 8]), Op::Call(476, vec![0, 11], 1, false), Op::Store(vec![11, 37, 7, 8]), Op::Store(vec![14, 38, 9, 8]), Op::Store(vec![14, 36, 39, 8]), Op::Store(vec![14, 33, 40, 8]), Op::Store(vec![10, 13, 41, 8])], ctrl: Ctrl::Return(11, vec![42]) }), (G::from_u64(4864), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 21, 9]), Op::Store(vec![9, 22, 7]), Op::Store(vec![8, 20, 23, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Store(vec![18, 24, 27, 9]), Op::Const(G::from_u64(76)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![18, 14, 15, 9]), Op::Store(vec![18, 31, 32, 9]), Op::Store(vec![18, 14, 16, 9]), Op::Store(vec![18, 33, 34, 9]), Op::Store(vec![18, 28, 35, 9]), Op::Const(G::from_u64(42)), Op::Call(476, vec![0, 37], 1, false), Op::Store(vec![8, 38, 7, 9]), Op::Store(vec![18, 39, 15, 9]), Op::Store(vec![18, 40, 16, 9]), Op::Store(vec![18, 14, 41, 9]), Op::Store(vec![18, 36, 42, 9]), Op::Store(vec![17, 11, 43, 9]), Op::Store(vec![17, 11, 44, 9])], ctrl: Ctrl::Return(12, vec![45]) }), (G::from_u64(4865), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 18, 9]), Op::Store(vec![9, 19, 7]), Op::Store(vec![8, 17, 20, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![8, 23, 7, 9]), Op::Store(vec![15, 21, 24, 9]), Op::Const(G::from_u64(76)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![8, 27, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![15, 31, 12, 9]), Op::Store(vec![15, 28, 32, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![8, 35, 7, 9]), Op::Store(vec![15, 36, 13, 9]), Op::Store(vec![15, 33, 37, 9]), Op::Store(vec![15, 25, 38, 9]), Op::Const(G::from_u64(74)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Store(vec![15, 42, 12, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 44, 7, 9]), Op::Store(vec![15, 45, 13, 9]), Op::Store(vec![15, 43, 46, 9]), Op::Store(vec![15, 39, 47, 9]), Op::Store(vec![14, 11, 48, 9]), Op::Store(vec![14, 11, 49, 9])], ctrl: Ctrl::Return(13, vec![50]) }), (G::from_u64(4866), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 18, 9]), Op::Store(vec![9, 19, 7]), Op::Store(vec![8, 17, 20, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![8, 23, 7, 9]), Op::Store(vec![15, 21, 24, 9]), Op::Const(G::from_u64(76)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![8, 27, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![15, 31, 12, 9]), Op::Store(vec![15, 28, 32, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![8, 35, 7, 9]), Op::Store(vec![15, 36, 13, 9]), Op::Store(vec![15, 33, 37, 9]), Op::Store(vec![15, 25, 38, 9]), Op::Const(G::from_u64(74)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Store(vec![15, 42, 13, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 44, 7, 9]), Op::Store(vec![15, 45, 12, 9]), Op::Store(vec![15, 43, 46, 9]), Op::Store(vec![15, 39, 47, 9]), Op::Store(vec![14, 11, 48, 9]), Op::Store(vec![14, 11, 49, 9])], ctrl: Ctrl::Return(14, vec![50]) }), (G::from_u64(4867), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 21, 9]), Op::Store(vec![9, 22, 7]), Op::Store(vec![8, 20, 23, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Store(vec![18, 24, 27, 9]), Op::Const(G::from_u64(76)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![18, 14, 15, 9]), Op::Store(vec![18, 31, 32, 9]), Op::Store(vec![18, 14, 16, 9]), Op::Store(vec![18, 33, 34, 9]), Op::Store(vec![18, 28, 35, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 37, 7, 9]), Op::Const(G::from_u64(42)), Op::Call(476, vec![0, 39], 1, false), Op::Store(vec![8, 40, 7, 9]), Op::Store(vec![18, 41, 15, 9]), Op::Store(vec![18, 42, 16, 9]), Op::Store(vec![18, 38, 43, 9]), Op::Store(vec![18, 14, 44, 9]), Op::Store(vec![18, 36, 45, 9]), Op::Store(vec![17, 11, 46, 9]), Op::Store(vec![17, 11, 47, 9])], ctrl: Ctrl::Return(15, vec![48]) }), (G::from_u64(4928), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 10, 7, 11]), Op::Store(vec![11, 6, 11, 11]), Op::Store(vec![11, 11, 11, 11]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![11, 11, 11]), Op::Store(vec![6, 19, 11]), Op::Store(vec![11, 20, 7]), Op::Store(vec![8, 18, 21, 11]), Op::Store(vec![16, 22, 12, 11]), Op::Const(G::from_u64(77)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![8, 25, 7, 11]), Op::Store(vec![16, 26, 13, 11]), Op::Store(vec![16, 27, 14, 11]), Op::Store(vec![16, 23, 28, 11]), Op::Const(G::from_u64(76)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![8, 31, 7, 11]), Op::Store(vec![16, 32, 13, 11]), Op::Const(G::from_u64(75)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![8, 35, 7, 11]), Op::Store(vec![16, 36, 14, 11]), Op::Store(vec![16, 33, 37, 11]), Op::Store(vec![16, 29, 38, 11]), Op::Store(vec![15, 12, 39, 11]), Op::Store(vec![15, 12, 40, 11])], ctrl: Ctrl::Return(16, vec![41]) }), (G::from_u64(4992), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 21, 9]), Op::Store(vec![9, 22, 7]), Op::Store(vec![8, 20, 23, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Store(vec![18, 24, 27, 9]), Op::Const(G::from_u64(78)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![18, 14, 15, 9]), Op::Store(vec![18, 31, 32, 9]), Op::Store(vec![18, 14, 16, 9]), Op::Store(vec![18, 33, 34, 9]), Op::Store(vec![18, 28, 35, 9]), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 37], 1, false), Op::Store(vec![8, 38, 7, 9]), Op::Store(vec![18, 39, 15, 9]), Op::Store(vec![18, 40, 16, 9]), Op::Store(vec![18, 14, 41, 9]), Op::Store(vec![18, 36, 42, 9]), Op::Store(vec![17, 11, 43, 9]), Op::Store(vec![17, 11, 44, 9])], ctrl: Ctrl::Return(17, vec![45]) }), (G::from_u64(4993), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 18, 9]), Op::Store(vec![9, 19, 7]), Op::Store(vec![8, 17, 20, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![8, 23, 7, 9]), Op::Store(vec![15, 21, 24, 9]), Op::Const(G::from_u64(78)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![8, 27, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![15, 31, 12, 9]), Op::Store(vec![15, 28, 32, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![8, 35, 7, 9]), Op::Store(vec![15, 36, 13, 9]), Op::Store(vec![15, 33, 37, 9]), Op::Store(vec![15, 25, 38, 9]), Op::Const(G::from_u64(73)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 43], 1, false), Op::Store(vec![8, 44, 7, 9]), Op::Store(vec![15, 45, 12, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 47, 7, 9]), Op::Store(vec![15, 48, 13, 9]), Op::Store(vec![15, 46, 49, 9]), Op::Store(vec![15, 42, 50, 9]), Op::Store(vec![15, 39, 51, 9]), Op::Store(vec![14, 11, 52, 9]), Op::Store(vec![14, 11, 53, 9])], ctrl: Ctrl::Return(18, vec![54]) }), (G::from_u64(4994), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 18, 9]), Op::Store(vec![9, 19, 7]), Op::Store(vec![8, 17, 20, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![8, 23, 7, 9]), Op::Store(vec![15, 21, 24, 9]), Op::Const(G::from_u64(78)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![8, 27, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![15, 31, 12, 9]), Op::Store(vec![15, 28, 32, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![8, 35, 7, 9]), Op::Store(vec![15, 36, 13, 9]), Op::Store(vec![15, 33, 37, 9]), Op::Store(vec![15, 25, 38, 9]), Op::Const(G::from_u64(73)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 43], 1, false), Op::Store(vec![8, 44, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 46, 7, 9]), Op::Store(vec![15, 47, 12, 9]), Op::Store(vec![15, 45, 48, 9]), Op::Store(vec![15, 49, 13, 9]), Op::Store(vec![15, 42, 50, 9]), Op::Store(vec![15, 39, 51, 9]), Op::Store(vec![14, 11, 52, 9]), Op::Store(vec![14, 11, 53, 9])], ctrl: Ctrl::Return(19, vec![54]) }), (G::from_u64(4995), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 23, 9]), Op::Store(vec![9, 24, 7]), Op::Store(vec![8, 22, 25, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 27], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Store(vec![20, 26, 29, 9]), Op::Const(G::from_u64(78)), Op::Call(476, vec![0, 31], 1, false), Op::Store(vec![8, 32, 7, 9]), Op::Store(vec![20, 14, 15, 9]), Op::Store(vec![20, 33, 34, 9]), Op::Store(vec![20, 14, 16, 9]), Op::Store(vec![20, 35, 36, 9]), Op::Store(vec![20, 30, 37, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 39], 1, false), Op::Store(vec![8, 40, 7, 9]), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 42], 1, false), Op::Store(vec![8, 43, 7, 9]), Op::Store(vec![20, 18, 15, 9]), Op::Store(vec![20, 44, 45, 9]), Op::Store(vec![20, 18, 16, 9]), Op::Store(vec![20, 46, 47, 9]), Op::Store(vec![20, 41, 48, 9]), Op::Store(vec![20, 38, 49, 9]), Op::Store(vec![19, 11, 50, 9]), Op::Store(vec![19, 11, 51, 9])], ctrl: Ctrl::Return(20, vec![52]) }), (G::from_u64(5056), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 17, 9]), Op::Store(vec![9, 18, 7]), Op::Store(vec![8, 16, 19, 9]), Op::Store(vec![14, 20, 11, 9]), Op::Const(G::from_u64(79)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![8, 23, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Store(vec![14, 27, 12, 9]), Op::Store(vec![14, 24, 28, 9]), Op::Store(vec![14, 21, 29, 9]), Op::Store(vec![14, 30, 12, 9]), Op::Store(vec![13, 11, 31, 9])], ctrl: Ctrl::Return(21, vec![32]) }), (G::from_u64(5057), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 17, 9]), Op::Store(vec![9, 18, 7]), Op::Store(vec![8, 16, 19, 9]), Op::Store(vec![14, 20, 11, 9]), Op::Const(G::from_u64(79)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![8, 23, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Store(vec![14, 27, 12, 9]), Op::Store(vec![14, 24, 28, 9]), Op::Store(vec![14, 21, 29, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 31, 7, 9]), Op::Store(vec![14, 32, 12, 9]), Op::Store(vec![14, 30, 33, 9]), Op::Store(vec![13, 11, 34, 9])], ctrl: Ctrl::Return(22, vec![35]) }), (G::from_u64(5120), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 21, 9]), Op::Store(vec![9, 22, 7]), Op::Store(vec![8, 20, 23, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Store(vec![18, 24, 27, 9]), Op::Const(G::from_u64(80)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![18, 14, 15, 9]), Op::Store(vec![18, 31, 32, 9]), Op::Store(vec![18, 14, 16, 9]), Op::Store(vec![18, 33, 34, 9]), Op::Store(vec![18, 28, 35, 9]), Op::Const(G::from_u64(48)), Op::Call(476, vec![0, 37], 1, false), Op::Store(vec![8, 38, 7, 9]), Op::Store(vec![18, 39, 15, 9]), Op::Store(vec![18, 40, 16, 9]), Op::Store(vec![18, 14, 41, 9]), Op::Store(vec![18, 36, 42, 9]), Op::Store(vec![17, 11, 43, 9]), Op::Store(vec![17, 11, 44, 9])], ctrl: Ctrl::Return(23, vec![45]) }), (G::from_u64(5121), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 21, 9]), Op::Store(vec![9, 22, 7]), Op::Store(vec![8, 20, 23, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Store(vec![18, 24, 27, 9]), Op::Const(G::from_u64(80)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![18, 14, 15, 9]), Op::Store(vec![18, 31, 32, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![8, 35, 7, 9]), Op::Store(vec![18, 36, 16, 9]), Op::Store(vec![18, 33, 37, 9]), Op::Store(vec![18, 28, 38, 9]), Op::Const(G::from_u64(75)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Const(G::from_u64(48)), Op::Call(476, vec![0, 43], 1, false), Op::Store(vec![8, 44, 7, 9]), Op::Store(vec![18, 45, 15, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 47, 7, 9]), Op::Store(vec![18, 48, 16, 9]), Op::Store(vec![18, 46, 49, 9]), Op::Store(vec![18, 14, 50, 9]), Op::Store(vec![18, 42, 51, 9]), Op::Store(vec![18, 39, 52, 9]), Op::Store(vec![17, 11, 53, 9]), Op::Store(vec![17, 11, 54, 9])], ctrl: Ctrl::Return(24, vec![55]) }), (G::from_u64(5122), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 10], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![9, 11, 7, 12]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![9, 14, 7, 12]), Op::Store(vec![8, 13, 15, 12]), Op::Const(G::from_u64(5)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 18, 7, 12]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 20], 1, false), Op::Store(vec![12, 12, 12]), Op::Store(vec![6, 22, 12]), Op::Store(vec![12, 23, 7]), Op::Store(vec![9, 21, 24, 12]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![9, 27, 7, 12]), Op::Store(vec![8, 25, 28, 12]), Op::Const(G::from_u64(80)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![9, 31, 7, 12]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 33], 1, false), Op::Store(vec![9, 34, 7, 12]), Op::Store(vec![12, 12, 12, 12]), Op::Store(vec![8, 35, 36, 12]), Op::Store(vec![8, 32, 37, 12]), Op::Store(vec![8, 38, 16, 12]), Op::Store(vec![8, 29, 39, 12]), Op::Store(vec![8, 40, 16, 12]), Op::Store(vec![17, 19, 41, 12])], ctrl: Ctrl::Return(25, vec![42]) }), (G::from_u64(5123), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(3)), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![16, 18, 19, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 24, 9]), Op::Store(vec![9, 25, 7]), Op::Store(vec![8, 23, 26, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 28], 1, false), Op::Store(vec![8, 29, 7, 9]), Op::Store(vec![16, 27, 30, 9]), Op::Const(G::from_u64(80)), Op::Call(476, vec![0, 32], 1, false), Op::Store(vec![8, 33, 7, 9]), Op::Store(vec![16, 14, 15, 9]), Op::Store(vec![16, 34, 35, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 37], 1, false), Op::Store(vec![8, 38, 7, 9]), Op::Store(vec![16, 39, 20, 9]), Op::Store(vec![16, 36, 40, 9]), Op::Store(vec![16, 31, 41, 9]), Op::Const(G::from_u64(48)), Op::Call(476, vec![0, 43], 1, false), Op::Store(vec![8, 44, 7, 9]), Op::Store(vec![16, 45, 15, 9]), Op::Store(vec![16, 46, 20, 9]), Op::Store(vec![16, 14, 47, 9]), Op::Store(vec![16, 42, 48, 9]), Op::Store(vec![21, 11, 49, 9]), Op::Store(vec![21, 11, 50, 9])], ctrl: Ctrl::Return(26, vec![51]) }), (G::from_u64(5124), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 23, 9]), Op::Store(vec![9, 24, 7]), Op::Store(vec![8, 22, 25, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 27], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Store(vec![20, 26, 29, 9]), Op::Const(G::from_u64(80)), Op::Call(476, vec![0, 31], 1, false), Op::Store(vec![8, 32, 7, 9]), Op::Store(vec![20, 14, 15, 9]), Op::Store(vec![20, 33, 34, 9]), Op::Store(vec![20, 14, 16, 9]), Op::Store(vec![20, 35, 36, 9]), Op::Store(vec![20, 30, 37, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 39], 1, false), Op::Store(vec![8, 40, 7, 9]), Op::Const(G::from_u64(48)), Op::Call(476, vec![0, 42], 1, false), Op::Store(vec![8, 43, 7, 9]), Op::Store(vec![20, 44, 15, 9]), Op::Store(vec![20, 18, 16, 9]), Op::Store(vec![20, 45, 46, 9]), Op::Store(vec![20, 18, 47, 9]), Op::Store(vec![20, 41, 48, 9]), Op::Store(vec![20, 38, 49, 9]), Op::Store(vec![19, 11, 50, 9]), Op::Store(vec![19, 11, 51, 9])], ctrl: Ctrl::Return(27, vec![52]) }), (G::from_u64(5184), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 21, 9]), Op::Store(vec![9, 22, 7]), Op::Store(vec![8, 20, 23, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Store(vec![18, 24, 27, 9]), Op::Const(G::from_u64(81)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![18, 14, 15, 9]), Op::Store(vec![18, 31, 32, 9]), Op::Store(vec![18, 14, 16, 9]), Op::Store(vec![18, 33, 34, 9]), Op::Store(vec![18, 28, 35, 9]), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 37], 1, false), Op::Store(vec![8, 38, 7, 9]), Op::Store(vec![18, 39, 15, 9]), Op::Store(vec![18, 40, 16, 9]), Op::Store(vec![18, 14, 41, 9]), Op::Store(vec![18, 36, 42, 9]), Op::Store(vec![17, 11, 43, 9]), Op::Store(vec![17, 11, 44, 9])], ctrl: Ctrl::Return(28, vec![45]) }), (G::from_u64(5185), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 21, 9]), Op::Store(vec![9, 22, 7]), Op::Store(vec![8, 20, 23, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Store(vec![18, 24, 27, 9]), Op::Const(G::from_u64(81)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![18, 14, 15, 9]), Op::Store(vec![18, 31, 32, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![8, 35, 7, 9]), Op::Store(vec![18, 36, 16, 9]), Op::Store(vec![18, 33, 37, 9]), Op::Store(vec![18, 28, 38, 9]), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Store(vec![18, 42, 15, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 44, 7, 9]), Op::Store(vec![18, 45, 16, 9]), Op::Store(vec![18, 43, 46, 9]), Op::Store(vec![18, 14, 47, 9]), Op::Store(vec![18, 39, 48, 9]), Op::Store(vec![17, 11, 49, 9]), Op::Store(vec![17, 11, 50, 9])], ctrl: Ctrl::Return(29, vec![51]) }), (G::from_u64(5186), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 18, 9]), Op::Store(vec![9, 19, 7]), Op::Store(vec![8, 17, 20, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![8, 23, 7, 9]), Op::Store(vec![15, 21, 24, 9]), Op::Const(G::from_u64(81)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![8, 27, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![15, 31, 12, 9]), Op::Store(vec![15, 28, 32, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![8, 35, 7, 9]), Op::Store(vec![15, 36, 13, 9]), Op::Store(vec![15, 33, 37, 9]), Op::Store(vec![15, 25, 38, 9]), Op::Const(G::from_u64(74)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Store(vec![15, 42, 13, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 44, 7, 9]), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 46], 1, false), Op::Store(vec![8, 47, 7, 9]), Op::Store(vec![15, 48, 12, 9]), Op::Store(vec![15, 49, 13, 9]), Op::Store(vec![15, 45, 50, 9]), Op::Store(vec![15, 43, 51, 9]), Op::Store(vec![15, 39, 52, 9]), Op::Store(vec![14, 11, 53, 9]), Op::Store(vec![14, 11, 54, 9])], ctrl: Ctrl::Return(30, vec![55]) }), (G::from_u64(5187), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 17, 7, 9]), Op::Const(G::from_u64(3)), Op::Store(vec![19, 18, 16, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 24, 9]), Op::Store(vec![9, 25, 7]), Op::Store(vec![8, 23, 26, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 28], 1, false), Op::Store(vec![8, 29, 7, 9]), Op::Store(vec![19, 27, 30, 9]), Op::Const(G::from_u64(81)), Op::Call(476, vec![0, 32], 1, false), Op::Store(vec![8, 33, 7, 9]), Op::Store(vec![19, 14, 15, 9]), Op::Store(vec![19, 34, 35, 9]), Op::Store(vec![19, 14, 16, 9]), Op::Store(vec![19, 36, 37, 9]), Op::Store(vec![19, 31, 38, 9]), Op::Const(G::from_u64(74)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Store(vec![19, 42, 20, 9]), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 44], 1, false), Op::Store(vec![8, 45, 7, 9]), Op::Store(vec![19, 46, 15, 9]), Op::Store(vec![19, 47, 20, 9]), Op::Store(vec![19, 18, 48, 9]), Op::Store(vec![19, 43, 49, 9]), Op::Store(vec![19, 39, 50, 9]), Op::Store(vec![21, 11, 51, 9]), Op::Store(vec![21, 11, 52, 9])], ctrl: Ctrl::Return(31, vec![53]) }), (G::from_u64(5248), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 21, 9]), Op::Store(vec![9, 22, 7]), Op::Store(vec![8, 20, 23, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Store(vec![18, 24, 27, 9]), Op::Const(G::from_u64(82)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![18, 14, 15, 9]), Op::Store(vec![18, 31, 32, 9]), Op::Store(vec![18, 33, 16, 9]), Op::Store(vec![18, 28, 34, 9]), Op::Const(G::from_u64(45)), Op::Call(476, vec![0, 36], 1, false), Op::Store(vec![8, 37, 7, 9]), Op::Store(vec![18, 38, 15, 9]), Op::Store(vec![18, 39, 16, 9]), Op::Store(vec![18, 14, 40, 9]), Op::Store(vec![18, 35, 41, 9]), Op::Store(vec![17, 11, 42, 9]), Op::Store(vec![17, 11, 43, 9])], ctrl: Ctrl::Return(32, vec![44]) }), (G::from_u64(5249), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 20, 7, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![8, 27, 7, 9]), Op::Store(vec![25, 17, 28, 9]), Op::Const(G::from_u64(46)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![8, 31, 7, 9]), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 33], 1, false), Op::Store(vec![8, 34, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![25, 35, 36, 9]), Op::Store(vec![25, 19, 21, 9]), Op::Store(vec![25, 19, 38, 9]), Op::Store(vec![25, 37, 39, 9]), Op::Store(vec![25, 32, 40, 9]), Op::Store(vec![25, 41, 21, 9]), Op::Store(vec![25, 29, 42, 9]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 44], 1, false), Op::Store(vec![8, 45, 7, 9]), Op::Store(vec![25, 43, 46, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 48], 1, false), Op::Store(vec![8, 49, 7, 9]), Op::Store(vec![25, 17, 50, 9]), Op::Const(G::from_u64(82)), Op::Call(476, vec![0, 52], 1, false), Op::Store(vec![8, 53, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 55], 1, false), Op::Store(vec![8, 56, 7, 9]), Op::Store(vec![25, 57, 22, 9]), Op::Store(vec![25, 54, 58, 9]), Op::Store(vec![25, 59, 23, 9]), Op::Store(vec![25, 51, 60, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 62], 1, false), Op::Store(vec![8, 63, 7, 9]), Op::Const(G::from_u64(45)), Op::Call(476, vec![0, 65], 1, false), Op::Store(vec![8, 66, 7, 9]), Op::Store(vec![25, 19, 22, 9]), Op::Store(vec![25, 67, 68, 9]), Op::Store(vec![25, 69, 23, 9]), Op::Store(vec![25, 64, 70, 9]), Op::Store(vec![25, 61, 71, 9]), Op::Store(vec![24, 47, 72, 9]), Op::Store(vec![24, 11, 73, 9]), Op::Store(vec![24, 11, 74, 9])], ctrl: Ctrl::Return(33, vec![75]) }), (G::from_u64(5250), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 20, 7, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![8, 27, 7, 9]), Op::Store(vec![25, 17, 28, 9]), Op::Const(G::from_u64(46)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![8, 31, 7, 9]), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 33], 1, false), Op::Store(vec![8, 34, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![25, 35, 36, 9]), Op::Store(vec![25, 19, 21, 9]), Op::Store(vec![25, 19, 38, 9]), Op::Store(vec![25, 37, 39, 9]), Op::Store(vec![25, 32, 40, 9]), Op::Store(vec![25, 41, 21, 9]), Op::Store(vec![25, 29, 42, 9]), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![8, 44, 7, 9]), Op::Store(vec![25, 43, 45, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 47], 1, false), Op::Store(vec![8, 48, 7, 9]), Op::Store(vec![25, 17, 49, 9]), Op::Const(G::from_u64(82)), Op::Call(476, vec![0, 51], 1, false), Op::Store(vec![8, 52, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 54], 1, false), Op::Store(vec![8, 55, 7, 9]), Op::Store(vec![25, 56, 22, 9]), Op::Store(vec![25, 53, 57, 9]), Op::Store(vec![25, 58, 23, 9]), Op::Store(vec![25, 50, 59, 9]), Op::Const(G::from_u64(75)), Op::Call(476, vec![0, 61], 1, false), Op::Store(vec![8, 62, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 64], 1, false), Op::Store(vec![8, 65, 7, 9]), Op::Const(G::from_u64(45)), Op::Call(476, vec![0, 67], 1, false), Op::Store(vec![8, 68, 7, 9]), Op::Store(vec![25, 19, 22, 9]), Op::Store(vec![25, 69, 70, 9]), Op::Store(vec![25, 71, 23, 9]), Op::Store(vec![25, 66, 72, 9]), Op::Store(vec![25, 63, 73, 9]), Op::Store(vec![25, 60, 74, 9]), Op::Store(vec![24, 46, 75, 9]), Op::Store(vec![24, 11, 76, 9]), Op::Store(vec![24, 11, 77, 9])], ctrl: Ctrl::Return(34, vec![78]) }), (G::from_u64(5440), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 14, 7, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 20, 9]), Op::Store(vec![9, 21, 7]), Op::Store(vec![8, 19, 22, 9]), Op::Store(vec![17, 23, 11, 9]), Op::Const(G::from_u64(85)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Store(vec![17, 27, 12, 9]), Op::Const(G::from_u64(84)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 30, 7, 9]), Op::Store(vec![17, 31, 12, 9]), Op::Store(vec![17, 32, 13, 9]), Op::Store(vec![17, 28, 33, 9]), Op::Store(vec![17, 24, 34, 9]), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 36], 1, false), Op::Store(vec![8, 37, 7, 9]), Op::Store(vec![17, 38, 13, 9]), Op::Const(G::from_u64(45)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 43, 7, 9]), Op::Store(vec![17, 15, 44, 9]), Op::Store(vec![17, 15, 45, 9]), Op::Store(vec![17, 42, 46, 9]), Op::Store(vec![17, 47, 12, 9]), Op::Store(vec![17, 39, 48, 9]), Op::Store(vec![17, 35, 49, 9]), Op::Store(vec![16, 11, 50, 9]), Op::Store(vec![16, 11, 51, 9])], ctrl: Ctrl::Return(35, vec![52]) }), (G::from_u64(5504), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(84)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![8, 15, 7, 9]), Op::Store(vec![13, 16, 12, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 20, 7, 9]), Op::Const(G::from_u64(49)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![8, 23, 7, 9]), Op::Const(G::from_u64(45)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Store(vec![13, 21, 29, 9]), Op::Store(vec![13, 21, 30, 9]), Op::Store(vec![13, 27, 31, 9]), Op::Store(vec![13, 32, 12, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 35], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 37, 9]), Op::Store(vec![9, 38, 7]), Op::Store(vec![8, 36, 39, 9]), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 41], 1, false), Op::Store(vec![8, 42, 7, 9]), Op::Store(vec![13, 40, 43, 9]), Op::Const(G::from_u64(86)), Op::Call(476, vec![0, 45], 1, false), Op::Store(vec![8, 46, 7, 9]), Op::Store(vec![13, 47, 12, 9]), Op::Store(vec![13, 17, 18, 9]), Op::Store(vec![13, 48, 49, 9]), Op::Store(vec![13, 17, 19, 9]), Op::Store(vec![13, 50, 51, 9]), Op::Store(vec![13, 44, 52, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 54], 1, false), Op::Store(vec![8, 55, 7, 9]), Op::Store(vec![13, 24, 18, 9]), Op::Store(vec![13, 57, 33, 9]), Op::Store(vec![13, 21, 58, 9]), Op::Store(vec![13, 56, 59, 9]), Op::Store(vec![13, 24, 19, 9]), Op::Store(vec![13, 61, 33, 9]), Op::Store(vec![13, 60, 62, 9]), Op::Store(vec![13, 53, 63, 9]), Op::Store(vec![34, 11, 64, 9]), Op::Store(vec![34, 11, 65, 9]), Op::Store(vec![34, 11, 66, 9])], ctrl: Ctrl::Return(36, vec![67]) }), (G::from_u64(5568), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(37)), Op::Call(476, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 10, 7, 11]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![11, 11, 11]), Op::Store(vec![6, 15, 11]), Op::Store(vec![11, 16, 7]), Op::Store(vec![8, 14, 17, 11]), Op::Store(vec![11, 11, 11, 11]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![8, 23, 7, 11]), Op::Store(vec![21, 18, 24, 11]), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![8, 27, 7, 11]), Op::Store(vec![21, 18, 12, 11]), Op::Store(vec![21, 29, 19, 11]), Op::Store(vec![21, 30, 19, 11]), Op::Store(vec![21, 28, 31, 11]), Op::Const(G::from_u64(87)), Op::Call(476, vec![0, 33], 1, false), Op::Store(vec![8, 34, 7, 11]), Op::Store(vec![21, 35, 19, 11]), Op::Store(vec![21, 36, 19, 11]), Op::Store(vec![21, 32, 37, 11]), Op::Store(vec![21, 25, 38, 11]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 11]), Op::Store(vec![21, 39, 42, 11]), Op::Store(vec![20, 12, 43, 11])], ctrl: Ctrl::Return(37, vec![44]) }), (G::from_u64(5760), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 7, 6]), Op::Store(vec![6, 14, 9]), Op::Store(vec![11, 13, 15, 6]), Op::Const(G::from_u64(88)), Op::Call(476, vec![0, 17], 1, false), Op::Store(vec![11, 18, 9, 6]), Op::Store(vec![10, 16, 19, 6]), Op::Const(G::from_u64(90)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![11, 22, 9, 6]), Op::Const(G::from_u64(38)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![11, 25, 9, 6]), Op::Const(G::from_u64(30)), Op::Call(476, vec![0, 27], 1, false), Op::Store(vec![6, 7, 9]), Op::Store(vec![11, 28, 29, 6]), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 31], 1, false), Op::Store(vec![11, 32, 9, 6]), Op::Store(vec![10, 30, 33, 6]), Op::Store(vec![10, 26, 34, 6]), Op::Store(vec![10, 23, 35, 6]), Op::Store(vec![10, 20, 36, 6]), Op::Const(G::from_u64(89)), Op::Call(476, vec![0, 38], 1, false), Op::Store(vec![11, 39, 9, 6]), Op::Store(vec![10, 37, 40, 6])], ctrl: Ctrl::Return(38, vec![41]) }), (G::from_u64(5824), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 7]), Op::Const(G::from_u64(1)), Op::Store(vec![9, 8, 7]), Op::Store(vec![9, 9, 9]), Op::Store(vec![7, 8, 11]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(29)), Op::Call(476, vec![0, 14], 1, false), Op::Store(vec![13, 15, 12, 7]), Op::Store(vec![7, 7, 7, 7]), Op::Store(vec![7, 9, 7, 7]), Op::Const(G::from_u64(5)), Op::Store(vec![9, 10, 7, 7]), Op::Const(G::from_u64(3)), Op::Store(vec![21, 16, 17, 7]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![7, 10, 11]), Op::Store(vec![13, 24, 25, 7]), Op::Store(vec![21, 16, 18, 7]), Op::Store(vec![21, 26, 27, 7]), Op::Const(G::from_u64(91)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![13, 30, 12, 7]), Op::Store(vec![21, 31, 18, 7]), Op::Const(G::from_u64(30)), Op::Call(476, vec![0, 33], 1, false), Op::Store(vec![13, 34, 12, 7]), Op::Store(vec![21, 35, 18, 7]), Op::Store(vec![21, 32, 36, 7]), Op::Store(vec![21, 37, 17, 7]), Op::Store(vec![21, 28, 38, 7]), Op::Store(vec![21, 39, 17, 7]), Op::Store(vec![19, 22, 40, 7]), Op::Store(vec![19, 20, 41, 7])], ctrl: Ctrl::Return(39, vec![42]) }), (G::from_u64(5825), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 7]), Op::Const(G::from_u64(1)), Op::Store(vec![9, 8, 7]), Op::Store(vec![7, 7, 7, 7]), Op::Store(vec![9, 9, 9]), Op::Store(vec![7, 8, 12]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(29)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![14, 16, 13, 7]), Op::Store(vec![7, 9, 7, 7]), Op::Store(vec![7, 14, 7, 7]), Op::Const(G::from_u64(3)), Op::Store(vec![7, 20, 7, 7]), Op::Const(G::from_u64(91)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![14, 23, 13, 7]), Op::Store(vec![20, 24, 21, 7]), Op::Const(G::from_u64(31)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![14, 27, 13, 7]), Op::Store(vec![20, 28, 21, 7]), Op::Store(vec![20, 29, 19, 7]), Op::Const(G::from_u64(5)), Op::Store(vec![9, 10, 7, 7]), Op::Store(vec![20, 17, 18, 7]), Op::Store(vec![20, 17, 19, 7]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 35], 1, false), Op::Store(vec![7, 10, 12]), Op::Store(vec![14, 36, 37, 7]), Op::Store(vec![20, 17, 21, 7]), Op::Store(vec![20, 38, 39, 7]), Op::Store(vec![20, 30, 18, 7]), Op::Store(vec![20, 25, 41, 7]), Op::Store(vec![20, 42, 11, 7]), Op::Store(vec![20, 40, 43, 7]), Op::Store(vec![20, 25, 18, 7]), Op::Store(vec![20, 45, 11, 7]), Op::Store(vec![20, 30, 46, 7]), Op::Store(vec![20, 44, 47, 7]), Op::Store(vec![31, 34, 48, 7]), Op::Store(vec![31, 33, 49, 7]), Op::Store(vec![31, 11, 50, 7]), Op::Store(vec![31, 32, 51, 7])], ctrl: Ctrl::Return(40, vec![52]) }), (G::from_u64(5888), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Store(vec![6, 7, 9]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![11, 13, 9, 6]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(29)), Op::Call(476, vec![0, 16], 1, false), Op::Store(vec![11, 17, 10, 6]), Op::Store(vec![15, 18, 14, 6]), Op::Const(G::from_u64(38)), Op::Call(476, vec![0, 20], 1, false), Op::Store(vec![11, 21, 9, 6]), Op::Store(vec![6, 8, 6, 6]), Op::Store(vec![6, 6, 6, 6]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![8, 7, 6]), Op::Store(vec![6, 28, 9]), Op::Store(vec![11, 27, 29, 6]), Op::Const(G::from_u64(37)), Op::Call(476, vec![0, 31], 1, false), Op::Store(vec![11, 32, 9, 6]), Op::Store(vec![15, 30, 33, 6]), Op::Const(G::from_u64(92)), Op::Call(476, vec![0, 35], 1, false), Op::Store(vec![11, 36, 9, 6]), Op::Store(vec![15, 22, 23, 6]), Op::Store(vec![15, 37, 38, 6]), Op::Store(vec![15, 22, 24, 6]), Op::Store(vec![15, 39, 40, 6]), Op::Store(vec![15, 34, 41, 6]), Op::Const(G::from_u64(91)), Op::Call(476, vec![0, 43], 1, false), Op::Store(vec![11, 44, 10, 6]), Op::Store(vec![15, 45, 14, 6]), Op::Store(vec![15, 46, 23, 6]), Op::Store(vec![15, 47, 24, 6]), Op::Store(vec![15, 22, 48, 6]), Op::Store(vec![15, 42, 49, 6]), Op::Store(vec![25, 19, 50, 6]), Op::Store(vec![25, 19, 51, 6])], ctrl: Ctrl::Return(41, vec![52]) }), (G::from_u64(5952), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 7]), Op::Store(vec![7, 7, 7, 7]), Op::Const(G::from_u64(2)), Op::Store(vec![7, 10, 7, 7]), Op::Const(G::from_u64(3)), Op::Store(vec![7, 12, 7, 7]), Op::Const(G::from_u64(1)), Op::Store(vec![14, 14, 14]), Op::Store(vec![7, 8, 15]), Op::Store(vec![7, 6, 7, 7]), Op::Store(vec![7, 14, 7, 7]), Op::Const(G::from_u64(5)), Op::Store(vec![14, 8, 7, 7]), Op::Store(vec![7, 7, 7]), Op::Store(vec![14, 21, 7, 7]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![10, 24, 16, 7]), Op::Store(vec![12, 25, 17, 7]), Op::Const(G::from_u64(93)), Op::Call(476, vec![0, 27], 1, false), Op::Store(vec![10, 28, 16, 7]), Op::Store(vec![12, 29, 17, 7]), Op::Store(vec![12, 30, 13, 7]), Op::Const(G::from_u64(60)), Op::Call(476, vec![0, 32], 1, false), Op::Store(vec![10, 33, 15, 7]), Op::Store(vec![12, 34, 13, 7]), Op::Store(vec![12, 35, 11, 7]), Op::Store(vec![12, 31, 36, 7]), Op::Store(vec![12, 37, 18, 7]), Op::Store(vec![12, 38, 9, 7]), Op::Store(vec![12, 26, 39, 7]), Op::Store(vec![12, 40, 18, 7]), Op::Store(vec![19, 13, 41, 7]), Op::Store(vec![19, 11, 42, 7]), Op::Store(vec![19, 9, 43, 7]), Op::Store(vec![19, 22, 44, 7]), Op::Store(vec![19, 20, 45, 7])], ctrl: Ctrl::Return(42, vec![46]) }), (G::from_u64(5953), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![6, 7, 7]), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Store(vec![7, 7, 7, 7]), Op::Const(G::from_u64(2)), Op::Store(vec![7, 12, 7, 7]), Op::Const(G::from_u64(3)), Op::Store(vec![7, 14, 7, 7]), Op::Store(vec![7, 8, 10]), Op::Store(vec![7, 6, 7, 7]), Op::Const(G::from_u64(5)), Op::Store(vec![9, 8, 7, 7]), Op::Store(vec![7, 7, 7]), Op::Store(vec![9, 20, 7, 7]), Op::Const(G::from_u64(62)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![12, 23, 10, 7]), Op::Store(vec![14, 24, 11, 7]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![12, 27, 16, 7]), Op::Store(vec![14, 28, 17, 7]), Op::Const(G::from_u64(93)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![12, 31, 16, 7]), Op::Store(vec![14, 32, 17, 7]), Op::Store(vec![14, 33, 15, 7]), Op::Const(G::from_u64(61)), Op::Call(476, vec![0, 35], 1, false), Op::Store(vec![12, 36, 10, 7]), Op::Store(vec![14, 37, 15, 7]), Op::Store(vec![14, 38, 13, 7]), Op::Store(vec![14, 34, 39, 7]), Op::Store(vec![7, 9, 7, 7]), Op::Store(vec![14, 40, 41, 7]), Op::Store(vec![14, 42, 11, 7]), Op::Store(vec![14, 29, 43, 7]), Op::Store(vec![14, 44, 11, 7]), Op::Store(vec![18, 15, 45, 7]), Op::Store(vec![18, 13, 46, 7]), Op::Store(vec![18, 25, 47, 7]), Op::Store(vec![18, 21, 48, 7]), Op::Store(vec![18, 19, 49, 7])], ctrl: Ctrl::Return(43, vec![50]) }), (G::from_u64(6080), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(3)), Op::Store(vec![22, 20, 21, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![22, 20, 24, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 27], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Store(vec![22, 17, 29, 9]), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 31], 1, false), Op::Store(vec![8, 32, 7, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![8, 35, 7, 9]), Op::Store(vec![22, 17, 36, 9]), Op::Store(vec![22, 37, 23, 9]), Op::Store(vec![22, 38, 25, 9]), Op::Store(vec![22, 33, 39, 9]), Op::Const(G::from_u64(95)), Op::Call(476, vec![0, 41], 1, false), Op::Store(vec![8, 42, 7, 9]), Op::Store(vec![22, 43, 23, 9]), Op::Store(vec![22, 44, 25, 9]), Op::Store(vec![22, 40, 45, 9]), Op::Store(vec![22, 30, 46, 9]), Op::Const(G::from_u64(46)), Op::Call(476, vec![0, 48], 1, false), Op::Store(vec![8, 49, 7, 9]), Op::Store(vec![22, 50, 21, 9]), Op::Store(vec![22, 51, 24, 9]), Op::Store(vec![22, 47, 52, 9]), Op::Store(vec![26, 11, 53, 9]), Op::Store(vec![26, 11, 54, 9])], ctrl: Ctrl::Return(44, vec![55]) }), (G::from_u64(6081), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 20, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![18, 21, 22, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![8, 25, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![18, 26, 27, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![8, 31, 7, 9]), Op::Store(vec![18, 17, 32, 9]), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![8, 35, 7, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 37], 1, false), Op::Store(vec![8, 38, 7, 9]), Op::Store(vec![18, 17, 39, 9]), Op::Store(vec![18, 40, 23, 9]), Op::Store(vec![18, 41, 28, 9]), Op::Store(vec![18, 36, 42, 9]), Op::Const(G::from_u64(95)), Op::Call(476, vec![0, 44], 1, false), Op::Store(vec![8, 45, 7, 9]), Op::Store(vec![18, 46, 23, 9]), Op::Store(vec![18, 47, 28, 9]), Op::Store(vec![18, 43, 48, 9]), Op::Store(vec![18, 33, 49, 9]), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 51, 7, 9]), Op::Store(vec![18, 50, 52, 9]), Op::Store(vec![29, 11, 53, 9]), Op::Store(vec![29, 11, 54, 9])], ctrl: Ctrl::Return(45, vec![55]) }), (G::from_u64(6082), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 20, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![18, 21, 22, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![8, 25, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![18, 26, 27, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![8, 31, 7, 9]), Op::Store(vec![18, 17, 32, 9]), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![8, 35, 7, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 37], 1, false), Op::Store(vec![8, 38, 7, 9]), Op::Store(vec![18, 17, 39, 9]), Op::Store(vec![18, 40, 23, 9]), Op::Store(vec![18, 41, 28, 9]), Op::Store(vec![18, 36, 42, 9]), Op::Const(G::from_u64(95)), Op::Call(476, vec![0, 44], 1, false), Op::Store(vec![8, 45, 7, 9]), Op::Store(vec![18, 46, 23, 9]), Op::Store(vec![18, 47, 28, 9]), Op::Store(vec![18, 43, 48, 9]), Op::Store(vec![18, 33, 49, 9]), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![8, 51, 7, 9]), Op::Store(vec![18, 50, 52, 9]), Op::Store(vec![29, 11, 53, 9]), Op::Store(vec![29, 11, 54, 9])], ctrl: Ctrl::Return(46, vec![55]) }), (G::from_u64(6083), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(3)), Op::Store(vec![22, 20, 21, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![22, 20, 24, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 27], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Store(vec![22, 17, 29, 9]), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 31], 1, false), Op::Store(vec![8, 32, 7, 9]), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![8, 35, 7, 9]), Op::Store(vec![22, 17, 36, 9]), Op::Store(vec![22, 37, 23, 9]), Op::Store(vec![22, 38, 25, 9]), Op::Store(vec![22, 33, 39, 9]), Op::Const(G::from_u64(95)), Op::Call(476, vec![0, 41], 1, false), Op::Store(vec![8, 42, 7, 9]), Op::Store(vec![22, 43, 23, 9]), Op::Store(vec![22, 44, 25, 9]), Op::Store(vec![22, 40, 45, 9]), Op::Store(vec![22, 30, 46, 9]), Op::Const(G::from_u64(46)), Op::Call(476, vec![0, 48], 1, false), Op::Store(vec![8, 49, 7, 9]), Op::Store(vec![22, 50, 21, 9]), Op::Store(vec![22, 51, 24, 9]), Op::Store(vec![22, 47, 52, 9]), Op::Store(vec![26, 11, 53, 9]), Op::Store(vec![26, 11, 54, 9])], ctrl: Ctrl::Return(47, vec![55]) }), (G::from_u64(6144), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(3)), Op::Store(vec![16, 14, 15, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![16, 14, 18, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 23, 9]), Op::Store(vec![9, 24, 7]), Op::Store(vec![8, 22, 25, 9]), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 27], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Store(vec![16, 26, 29, 9]), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 31], 1, false), Op::Store(vec![8, 32, 7, 9]), Op::Const(G::from_u64(94)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![8, 35, 7, 9]), Op::Store(vec![16, 36, 17, 9]), Op::Store(vec![16, 37, 19, 9]), Op::Store(vec![16, 33, 38, 9]), Op::Const(G::from_u64(96)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Store(vec![16, 42, 17, 9]), Op::Store(vec![16, 43, 19, 9]), Op::Store(vec![16, 39, 44, 9]), Op::Store(vec![16, 30, 45, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 47], 1, false), Op::Store(vec![8, 48, 7, 9]), Op::Store(vec![16, 49, 15, 9]), Op::Store(vec![16, 50, 18, 9]), Op::Store(vec![16, 46, 51, 9]), Op::Store(vec![20, 11, 52, 9]), Op::Store(vec![20, 11, 53, 9])], ctrl: Ctrl::Return(48, vec![54]) }), (G::from_u64(6145), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![8, 14, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![12, 15, 16, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![12, 20, 21, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 26, 9]), Op::Store(vec![9, 27, 7]), Op::Store(vec![8, 25, 28, 9]), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![8, 31, 7, 9]), Op::Store(vec![12, 29, 32, 9]), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![8, 35, 7, 9]), Op::Const(G::from_u64(94)), Op::Call(476, vec![0, 37], 1, false), Op::Store(vec![8, 38, 7, 9]), Op::Store(vec![12, 39, 17, 9]), Op::Store(vec![12, 40, 22, 9]), Op::Store(vec![12, 36, 41, 9]), Op::Const(G::from_u64(96)), Op::Call(476, vec![0, 43], 1, false), Op::Store(vec![8, 44, 7, 9]), Op::Store(vec![12, 45, 17, 9]), Op::Store(vec![12, 46, 22, 9]), Op::Store(vec![12, 42, 47, 9]), Op::Store(vec![12, 33, 48, 9]), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![8, 50, 7, 9]), Op::Store(vec![12, 49, 51, 9]), Op::Store(vec![23, 11, 52, 9]), Op::Store(vec![23, 11, 53, 9])], ctrl: Ctrl::Return(49, vec![54]) }), (G::from_u64(6146), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 13], 1, false), Op::Store(vec![8, 14, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![12, 15, 16, 9]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![8, 19, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![12, 20, 21, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 26, 9]), Op::Store(vec![9, 27, 7]), Op::Store(vec![8, 25, 28, 9]), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![8, 31, 7, 9]), Op::Store(vec![12, 29, 32, 9]), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![8, 35, 7, 9]), Op::Const(G::from_u64(94)), Op::Call(476, vec![0, 37], 1, false), Op::Store(vec![8, 38, 7, 9]), Op::Store(vec![12, 39, 17, 9]), Op::Store(vec![12, 40, 22, 9]), Op::Store(vec![12, 36, 41, 9]), Op::Const(G::from_u64(96)), Op::Call(476, vec![0, 43], 1, false), Op::Store(vec![8, 44, 7, 9]), Op::Store(vec![12, 45, 17, 9]), Op::Store(vec![12, 46, 22, 9]), Op::Store(vec![12, 42, 47, 9]), Op::Store(vec![12, 33, 48, 9]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 50], 1, false), Op::Store(vec![8, 51, 7, 9]), Op::Store(vec![12, 49, 52, 9]), Op::Store(vec![23, 11, 53, 9]), Op::Store(vec![23, 11, 54, 9])], ctrl: Ctrl::Return(50, vec![55]) }), (G::from_u64(6147), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(72)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 13, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Const(G::from_u64(3)), Op::Store(vec![16, 14, 15, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![16, 14, 18, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 23, 9]), Op::Store(vec![9, 24, 7]), Op::Store(vec![8, 22, 25, 9]), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 27], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Store(vec![16, 26, 29, 9]), Op::Const(G::from_u64(65)), Op::Call(476, vec![0, 31], 1, false), Op::Store(vec![8, 32, 7, 9]), Op::Const(G::from_u64(94)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![8, 35, 7, 9]), Op::Store(vec![16, 36, 17, 9]), Op::Store(vec![16, 37, 19, 9]), Op::Store(vec![16, 33, 38, 9]), Op::Const(G::from_u64(96)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Store(vec![16, 42, 17, 9]), Op::Store(vec![16, 43, 19, 9]), Op::Store(vec![16, 39, 44, 9]), Op::Store(vec![16, 30, 45, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 47], 1, false), Op::Store(vec![8, 48, 7, 9]), Op::Store(vec![16, 49, 18, 9]), Op::Store(vec![16, 50, 15, 9]), Op::Store(vec![16, 46, 51, 9]), Op::Store(vec![20, 11, 52, 9]), Op::Store(vec![20, 11, 53, 9])], ctrl: Ctrl::Return(51, vec![54]) }), (G::from_u64(6208), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 10, 7, 11]), Op::Store(vec![11, 6, 11, 11]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(76)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![8, 16, 7, 11]), Op::Store(vec![14, 17, 13, 11]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 20, 7, 11]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 22, 7, 11]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 24, 7, 11]), Op::Store(vec![14, 23, 25, 11]), Op::Store(vec![14, 21, 26, 11]), Op::Store(vec![14, 18, 27, 11]), Op::Store(vec![11, 11, 11, 11]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 31], 1, false), Op::Store(vec![11, 11, 11]), Op::Store(vec![6, 33, 11]), Op::Store(vec![11, 34, 7]), Op::Store(vec![8, 32, 35, 11]), Op::Const(G::from_u64(59)), Op::Call(476, vec![0, 37], 1, false), Op::Store(vec![8, 38, 7, 11]), Op::Const(G::from_u64(94)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 11]), Op::Store(vec![14, 42, 28, 11]), Op::Store(vec![14, 43, 29, 11]), Op::Store(vec![14, 39, 44, 11]), Op::Store(vec![14, 36, 45, 11]), Op::Const(G::from_u64(97)), Op::Call(476, vec![0, 47], 1, false), Op::Store(vec![8, 48, 7, 11]), Op::Store(vec![14, 49, 13, 11]), Op::Store(vec![14, 50, 29, 11]), Op::Store(vec![14, 46, 51, 11]), Op::Const(G::from_u64(96)), Op::Call(476, vec![0, 53], 1, false), Op::Store(vec![8, 54, 7, 11]), Op::Store(vec![14, 55, 28, 11]), Op::Store(vec![14, 56, 29, 11]), Op::Store(vec![14, 52, 57, 11]), Op::Store(vec![30, 12, 58, 11]), Op::Store(vec![30, 12, 59, 11])], ctrl: Ctrl::Return(52, vec![60]) }), (G::from_u64(6272), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 10, 7, 11]), Op::Store(vec![11, 11, 11]), Op::Store(vec![6, 13, 11]), Op::Store(vec![11, 14, 7]), Op::Store(vec![11, 6, 11, 11]), Op::Store(vec![11, 11, 11, 11]), Op::Const(G::from_u64(76)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![8, 19, 7, 11]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 21], 1, false), Op::Store(vec![8, 22, 7, 11]), Op::Const(G::from_u64(3)), Op::Store(vec![24, 23, 17, 11]), Op::Const(G::from_u64(81)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![8, 27, 7, 11]), Op::Store(vec![24, 28, 16, 11]), Op::Store(vec![24, 29, 25, 11]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 31, 7, 11]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 33, 7, 11]), Op::Store(vec![24, 32, 34, 11]), Op::Store(vec![24, 23, 35, 11]), Op::Const(G::from_u64(80)), Op::Call(476, vec![0, 37], 1, false), Op::Store(vec![8, 38, 7, 11]), Op::Store(vec![24, 20, 25, 11]), Op::Store(vec![24, 40, 36, 11]), Op::Store(vec![24, 39, 41, 11]), Op::Store(vec![24, 32, 35, 11]), Op::Store(vec![24, 23, 43, 11]), Op::Store(vec![24, 42, 44, 11]), Op::Const(G::from_u64(5)), Op::Call(476, vec![0, 11], 1, false), Op::Store(vec![8, 47, 7, 11]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 49], 1, false), Op::Store(vec![8, 50, 15, 11]), Op::Store(vec![24, 51, 12, 11]), Op::Const(G::from_u64(98)), Op::Call(476, vec![0, 53], 1, false), Op::Store(vec![8, 54, 7, 11]), Op::Store(vec![24, 55, 16, 11]), Op::Store(vec![24, 56, 17, 11]), Op::Store(vec![24, 52, 57, 11]), Op::Const(G::from_u64(93)), Op::Call(476, vec![0, 59], 1, false), Op::Store(vec![8, 60, 15, 11]), Op::Store(vec![24, 61, 12, 11]), Op::Const(G::from_u64(94)), Op::Call(476, vec![0, 63], 1, false), Op::Store(vec![8, 64, 7, 11]), Op::Store(vec![24, 20, 30, 11]), Op::Store(vec![24, 66, 36, 11]), Op::Store(vec![24, 65, 67, 11]), Op::Store(vec![24, 68, 45, 11]), Op::Store(vec![24, 62, 69, 11]), Op::Const(G::from_u64(97)), Op::Call(476, vec![0, 71], 1, false), Op::Store(vec![8, 72, 7, 11]), Op::Store(vec![24, 73, 30, 11]), Op::Store(vec![24, 74, 45, 11]), Op::Store(vec![24, 70, 75, 11]), Op::Store(vec![24, 76, 30, 11]), Op::Const(G::from_u64(77)), Op::Call(476, vec![0, 78], 1, false), Op::Store(vec![8, 79, 7, 11]), Op::Store(vec![24, 80, 30, 11]), Op::Store(vec![24, 81, 25, 11]), Op::Store(vec![24, 77, 82, 11]), Op::Store(vec![24, 58, 83, 11]), Op::Store(vec![46, 48, 84, 11]), Op::Store(vec![46, 12, 85, 11])], ctrl: Ctrl::Return(53, vec![86]) }), (G::from_u64(6336), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(70)), Op::Call(476, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 10, 7, 11]), Op::Call(476, vec![0, 11], 1, false), Op::Store(vec![8, 13, 7, 11]), Op::Store(vec![11, 11, 11]), Op::Store(vec![6, 15, 11]), Op::Store(vec![11, 16, 7]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![8, 19, 17, 11]), Op::Store(vec![11, 6, 11, 11]), Op::Store(vec![11, 11, 11, 11]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(93)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![8, 25, 17, 11]), Op::Store(vec![23, 26, 12, 11]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 28, 7, 11]), Op::Const(G::from_u64(71)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![8, 31, 7, 11]), Op::Const(G::from_u64(76)), Op::Call(476, vec![0, 33], 1, false), Op::Store(vec![8, 34, 7, 11]), Op::Store(vec![23, 32, 22, 11]), Op::Const(G::from_u64(81)), Op::Call(476, vec![0, 37], 1, false), Op::Store(vec![8, 38, 7, 11]), Op::Store(vec![23, 39, 21, 11]), Op::Store(vec![23, 40, 36, 11]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 42, 7, 11]), Op::Store(vec![23, 43, 29, 11]), Op::Store(vec![23, 32, 44, 11]), Op::Const(G::from_u64(80)), Op::Call(476, vec![0, 46], 1, false), Op::Store(vec![8, 47, 7, 11]), Op::Store(vec![23, 35, 36, 11]), Op::Store(vec![23, 49, 45, 11]), Op::Store(vec![23, 48, 50, 11]), Op::Store(vec![23, 43, 44, 11]), Op::Store(vec![23, 32, 52, 11]), Op::Store(vec![23, 51, 53, 11]), Op::Store(vec![23, 48, 21, 11]), Op::Store(vec![23, 55, 36, 11]), Op::Const(G::from_u64(5)), Op::Store(vec![23, 20, 12, 11]), Op::Const(G::from_u64(99)), Op::Call(476, vec![0, 59], 1, false), Op::Store(vec![8, 60, 7, 11]), Op::Store(vec![23, 61, 21, 11]), Op::Store(vec![23, 62, 22, 11]), Op::Store(vec![23, 58, 63, 11]), Op::Store(vec![23, 20, 14, 11]), Op::Store(vec![23, 65, 22, 11]), Op::Store(vec![23, 66, 29, 11]), Op::Store(vec![23, 27, 67, 11]), Op::Const(G::from_u64(67)), Op::Call(476, vec![0, 69], 1, false), Op::Store(vec![8, 70, 7, 11]), Op::Store(vec![23, 71, 22, 11]), Op::Store(vec![23, 72, 29, 11]), Op::Store(vec![23, 68, 73, 11]), Op::Store(vec![23, 32, 29, 11]), Op::Store(vec![23, 74, 75, 11]), Op::Const(G::from_u64(94)), Op::Call(476, vec![0, 77], 1, false), Op::Store(vec![8, 78, 7, 11]), Op::Store(vec![23, 35, 41, 11]), Op::Store(vec![23, 80, 45, 11]), Op::Store(vec![23, 79, 81, 11]), Op::Store(vec![23, 82, 54, 11]), Op::Store(vec![23, 27, 83, 11]), Op::Const(G::from_u64(97)), Op::Call(476, vec![0, 85], 1, false), Op::Store(vec![8, 86, 7, 11]), Op::Store(vec![23, 87, 41, 11]), Op::Store(vec![23, 88, 54, 11]), Op::Store(vec![23, 84, 89, 11]), Op::Store(vec![23, 90, 56, 11]), Op::Store(vec![23, 35, 56, 11]), Op::Store(vec![23, 92, 45, 11]), Op::Store(vec![23, 91, 93, 11]), Op::Store(vec![23, 76, 94, 11]), Op::Store(vec![23, 64, 95, 11]), Op::Store(vec![57, 14, 96, 11]), Op::Store(vec![57, 12, 97, 11])], ctrl: Ctrl::Return(54, vec![98]) }), (G::from_u64(6400), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 18, 7, 9]), Op::Const(G::from_u64(3)), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 21, 7, 9]), Op::Store(vec![20, 19, 22, 9]), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![8, 25, 7, 9]), Op::Store(vec![20, 19, 23, 9]), Op::Store(vec![20, 26, 27, 9]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![8, 31, 7, 9]), Op::Store(vec![20, 17, 32, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![8, 35, 7, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![20, 19, 37, 9]), Op::Store(vec![20, 36, 38, 9]), Op::Store(vec![20, 28, 23, 9]), Op::Store(vec![20, 28, 40, 9]), Op::Store(vec![20, 28, 41, 9]), Op::Store(vec![20, 28, 42, 9]), Op::Store(vec![20, 28, 43, 9]), Op::Store(vec![20, 28, 44, 9]), Op::Store(vec![20, 28, 45, 9]), Op::Store(vec![20, 39, 46, 9]), Op::Store(vec![20, 33, 47, 9]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 49], 1, false), Op::Store(vec![8, 50, 7, 9]), Op::Store(vec![20, 48, 51, 9]), Op::Store(vec![20, 17, 11, 9]), Op::Const(G::from_u64(100)), Op::Call(476, vec![0, 54], 1, false), Op::Store(vec![8, 55, 7, 9]), Op::Const(G::from_u64(40)), Op::Call(476, vec![0, 57], 1, false), Op::Store(vec![8, 58, 7, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![20, 59, 60, 9]), Op::Store(vec![20, 56, 61, 9]), Op::Store(vec![20, 53, 62, 9]), Op::Store(vec![20, 63, 23, 9]), Op::Store(vec![29, 52, 64, 9]), Op::Store(vec![29, 11, 65, 9])], ctrl: Ctrl::Return(55, vec![66]) }), (G::from_u64(6401), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 20, 7, 9]), Op::Store(vec![18, 17, 21, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![8, 24, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Store(vec![18, 27, 29, 9]), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 31], 1, false), Op::Store(vec![8, 32, 7, 9]), Op::Store(vec![18, 27, 30, 9]), Op::Store(vec![18, 33, 34, 9]), Op::Store(vec![18, 35, 30, 9]), Op::Store(vec![18, 35, 36, 9]), Op::Store(vec![18, 35, 37, 9]), Op::Store(vec![18, 35, 38, 9]), Op::Store(vec![18, 35, 39, 9]), Op::Store(vec![18, 35, 40, 9]), Op::Store(vec![18, 35, 41, 9]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 43], 1, false), Op::Store(vec![8, 44, 7, 9]), Op::Const(G::from_u64(5)), Op::Store(vec![18, 25, 42, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![18, 47, 48, 9]), Op::Store(vec![18, 22, 49, 9]), Op::Store(vec![18, 50, 45, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![18, 27, 52, 9]), Op::Store(vec![18, 25, 53, 9]), Op::Store(vec![18, 35, 42, 9]), Op::Store(vec![18, 35, 55, 9]), Op::Store(vec![18, 35, 56, 9]), Op::Store(vec![18, 35, 57, 9]), Op::Store(vec![18, 54, 58, 9]), Op::Store(vec![18, 22, 59, 9]), Op::Store(vec![18, 60, 45, 9]), Op::Store(vec![18, 17, 11, 9]), Op::Const(G::from_u64(100)), Op::Call(476, vec![0, 63], 1, false), Op::Store(vec![8, 64, 7, 9]), Op::Const(G::from_u64(40)), Op::Call(476, vec![0, 66], 1, false), Op::Store(vec![8, 67, 7, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Store(vec![18, 68, 69, 9]), Op::Store(vec![18, 65, 70, 9]), Op::Store(vec![18, 62, 71, 9]), Op::Store(vec![18, 72, 36, 9]), Op::Store(vec![46, 61, 73, 9]), Op::Store(vec![46, 51, 74, 9]), Op::Store(vec![46, 11, 75, 9])], ctrl: Ctrl::Return(56, vec![76]) }), (G::from_u64(6402), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 20, 7, 9]), Op::Store(vec![18, 17, 21, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![8, 24, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Store(vec![18, 27, 29, 9]), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 31], 1, false), Op::Store(vec![8, 32, 7, 9]), Op::Store(vec![18, 27, 30, 9]), Op::Store(vec![18, 33, 34, 9]), Op::Store(vec![18, 35, 30, 9]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 37], 1, false), Op::Store(vec![8, 38, 7, 9]), Op::Store(vec![18, 27, 36, 9]), Op::Const(G::from_u64(5)), Op::Store(vec![18, 35, 36, 9]), Op::Store(vec![18, 35, 42, 9]), Op::Store(vec![18, 35, 43, 9]), Op::Store(vec![18, 35, 44, 9]), Op::Store(vec![18, 35, 45, 9]), Op::Store(vec![18, 35, 46, 9]), Op::Store(vec![18, 35, 47, 9]), Op::Store(vec![18, 35, 48, 9]), Op::Store(vec![18, 35, 49, 9]), Op::Store(vec![18, 35, 50, 9]), Op::Store(vec![18, 25, 51, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![18, 52, 53, 9]), Op::Store(vec![18, 22, 54, 9]), Op::Store(vec![18, 55, 39, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![18, 27, 57, 9]), Op::Store(vec![18, 25, 58, 9]), Op::Store(vec![18, 35, 40, 9]), Op::Store(vec![18, 35, 60, 9]), Op::Store(vec![18, 27, 61, 9]), Op::Store(vec![18, 35, 62, 9]), Op::Store(vec![18, 27, 63, 9]), Op::Store(vec![18, 35, 64, 9]), Op::Store(vec![18, 35, 65, 9]), Op::Store(vec![18, 35, 66, 9]), Op::Store(vec![18, 35, 67, 9]), Op::Store(vec![18, 35, 68, 9]), Op::Store(vec![18, 35, 69, 9]), Op::Store(vec![18, 35, 70, 9]), Op::Store(vec![18, 35, 71, 9]), Op::Store(vec![18, 35, 72, 9]), Op::Store(vec![18, 35, 73, 9]), Op::Store(vec![18, 35, 74, 9]), Op::Store(vec![18, 59, 75, 9]), Op::Store(vec![18, 22, 76, 9]), Op::Store(vec![18, 77, 39, 9]), Op::Store(vec![18, 17, 11, 9]), Op::Const(G::from_u64(100)), Op::Call(476, vec![0, 80], 1, false), Op::Store(vec![8, 81, 7, 9]), Op::Const(G::from_u64(40)), Op::Call(476, vec![0, 83], 1, false), Op::Store(vec![8, 84, 7, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Store(vec![18, 85, 86, 9]), Op::Store(vec![18, 82, 87, 9]), Op::Store(vec![18, 79, 88, 9]), Op::Store(vec![18, 89, 40, 9]), Op::Store(vec![41, 78, 90, 9]), Op::Store(vec![41, 56, 91, 9]), Op::Store(vec![41, 11, 92, 9])], ctrl: Ctrl::Return(57, vec![93]) }), (G::from_u64(6403), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 20, 7, 9]), Op::Store(vec![18, 17, 21, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![8, 24, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Store(vec![18, 27, 29, 9]), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 31], 1, false), Op::Store(vec![8, 32, 7, 9]), Op::Store(vec![18, 27, 30, 9]), Op::Store(vec![18, 33, 34, 9]), Op::Store(vec![18, 35, 30, 9]), Op::Store(vec![18, 27, 36, 9]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 38], 1, false), Op::Store(vec![8, 39, 7, 9]), Op::Const(G::from_u64(5)), Op::Store(vec![18, 35, 37, 9]), Op::Store(vec![18, 27, 42, 9]), Op::Store(vec![18, 35, 43, 9]), Op::Store(vec![18, 35, 44, 9]), Op::Store(vec![18, 35, 45, 9]), Op::Store(vec![18, 35, 46, 9]), Op::Store(vec![18, 35, 47, 9]), Op::Store(vec![18, 35, 48, 9]), Op::Store(vec![18, 35, 49, 9]), Op::Store(vec![18, 35, 50, 9]), Op::Store(vec![18, 35, 51, 9]), Op::Store(vec![18, 35, 52, 9]), Op::Store(vec![18, 35, 53, 9]), Op::Store(vec![18, 35, 54, 9]), Op::Store(vec![18, 35, 55, 9]), Op::Store(vec![18, 25, 56, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![18, 57, 58, 9]), Op::Store(vec![18, 22, 59, 9]), Op::Store(vec![18, 60, 40, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![18, 27, 62, 9]), Op::Store(vec![18, 25, 63, 9]), Op::Store(vec![18, 35, 36, 9]), Op::Store(vec![18, 35, 65, 9]), Op::Store(vec![18, 35, 66, 9]), Op::Store(vec![18, 35, 67, 9]), Op::Store(vec![18, 35, 68, 9]), Op::Store(vec![18, 35, 69, 9]), Op::Store(vec![18, 35, 70, 9]), Op::Store(vec![18, 35, 71, 9]), Op::Store(vec![18, 35, 72, 9]), Op::Store(vec![18, 35, 73, 9]), Op::Store(vec![18, 35, 74, 9]), Op::Store(vec![18, 35, 75, 9]), Op::Store(vec![18, 35, 76, 9]), Op::Store(vec![18, 35, 77, 9]), Op::Store(vec![18, 35, 78, 9]), Op::Store(vec![18, 64, 79, 9]), Op::Store(vec![18, 22, 80, 9]), Op::Store(vec![18, 81, 40, 9]), Op::Store(vec![18, 17, 11, 9]), Op::Const(G::from_u64(100)), Op::Call(476, vec![0, 84], 1, false), Op::Store(vec![8, 85, 7, 9]), Op::Const(G::from_u64(40)), Op::Call(476, vec![0, 87], 1, false), Op::Store(vec![8, 88, 7, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Store(vec![18, 89, 90, 9]), Op::Store(vec![18, 86, 91, 9]), Op::Store(vec![18, 83, 92, 9]), Op::Store(vec![18, 93, 37, 9]), Op::Store(vec![41, 82, 94, 9]), Op::Store(vec![41, 61, 95, 9]), Op::Store(vec![41, 11, 96, 9])], ctrl: Ctrl::Return(58, vec![97]) }), (G::from_u64(6404), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(0)), Op::Call(476, vec![0, 9], 1, false), Op::Store(vec![8, 10, 7, 9]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![9, 9, 9]), Op::Store(vec![6, 14, 9]), Op::Store(vec![9, 15, 7]), Op::Store(vec![8, 13, 16, 9]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(4)), Op::Call(476, vec![0, 19], 1, false), Op::Store(vec![8, 20, 7, 9]), Op::Store(vec![18, 17, 21, 9]), Op::Const(G::from_u64(47)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![8, 24, 7, 9]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![8, 26, 7, 9]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![8, 28, 7, 9]), Op::Store(vec![18, 27, 29, 9]), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 31], 1, false), Op::Store(vec![8, 32, 7, 9]), Op::Store(vec![18, 27, 30, 9]), Op::Store(vec![18, 33, 34, 9]), Op::Store(vec![18, 35, 30, 9]), Op::Store(vec![18, 35, 36, 9]), Op::Store(vec![18, 35, 37, 9]), Op::Store(vec![18, 35, 38, 9]), Op::Const(G::from_u64(6)), Op::Call(476, vec![0, 40], 1, false), Op::Store(vec![8, 41, 7, 9]), Op::Const(G::from_u64(5)), Op::Store(vec![18, 35, 39, 9]), Op::Store(vec![18, 35, 44, 9]), Op::Store(vec![18, 35, 45, 9]), Op::Store(vec![18, 35, 46, 9]), Op::Store(vec![18, 35, 47, 9]), Op::Store(vec![18, 35, 48, 9]), Op::Store(vec![18, 35, 49, 9]), Op::Store(vec![18, 35, 50, 9]), Op::Store(vec![18, 35, 51, 9]), Op::Store(vec![18, 35, 52, 9]), Op::Store(vec![18, 35, 53, 9]), Op::Store(vec![18, 35, 54, 9]), Op::Store(vec![18, 25, 55, 9]), Op::Store(vec![9, 9, 9, 9]), Op::Store(vec![18, 56, 57, 9]), Op::Store(vec![18, 22, 58, 9]), Op::Store(vec![18, 59, 42, 9]), Op::Store(vec![9, 6, 9, 9]), Op::Store(vec![18, 27, 61, 9]), Op::Store(vec![18, 25, 62, 9]), Op::Store(vec![18, 27, 39, 9]), Op::Store(vec![18, 35, 64, 9]), Op::Store(vec![18, 35, 65, 9]), Op::Store(vec![18, 35, 66, 9]), Op::Store(vec![18, 35, 67, 9]), Op::Store(vec![18, 35, 68, 9]), Op::Store(vec![18, 35, 69, 9]), Op::Store(vec![18, 35, 70, 9]), Op::Store(vec![18, 35, 71, 9]), Op::Store(vec![18, 35, 72, 9]), Op::Store(vec![18, 35, 73, 9]), Op::Store(vec![18, 35, 74, 9]), Op::Store(vec![18, 35, 75, 9]), Op::Store(vec![18, 35, 76, 9]), Op::Store(vec![18, 35, 77, 9]), Op::Store(vec![18, 35, 78, 9]), Op::Store(vec![18, 35, 79, 9]), Op::Store(vec![18, 63, 80, 9]), Op::Store(vec![18, 22, 81, 9]), Op::Store(vec![18, 82, 42, 9]), Op::Store(vec![18, 17, 11, 9]), Op::Const(G::from_u64(100)), Op::Call(476, vec![0, 85], 1, false), Op::Store(vec![8, 86, 7, 9]), Op::Const(G::from_u64(40)), Op::Call(476, vec![0, 88], 1, false), Op::Store(vec![8, 89, 7, 9]), Op::Store(vec![9, 8, 9, 9]), Op::Store(vec![18, 90, 91, 9]), Op::Store(vec![18, 87, 92, 9]), Op::Store(vec![18, 84, 93, 9]), Op::Store(vec![18, 94, 37, 9]), Op::Store(vec![43, 83, 95, 9]), Op::Store(vec![43, 60, 96, 9]), Op::Store(vec![43, 11, 97, 9])], ctrl: Ctrl::Return(59, vec![98]) }), (G::from_u64(6464), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 12], 1, false), Op::Store(vec![8, 7, 6]), Op::Store(vec![6, 14, 9]), Op::Store(vec![11, 13, 15, 6]), Op::Call(476, vec![0, 6], 1, false), Op::Store(vec![11, 17, 9, 6]), Op::Store(vec![10, 16, 18, 6]), Op::Const(G::from_u64(101)), Op::Call(476, vec![0, 20], 1, false), Op::Store(vec![11, 21, 9, 6]), Op::Const(G::from_u64(38)), Op::Call(476, vec![0, 23], 1, false), Op::Store(vec![11, 24, 9, 6]), Op::Const(G::from_u64(30)), Op::Call(476, vec![0, 26], 1, false), Op::Store(vec![6, 7, 9]), Op::Store(vec![11, 27, 28, 6]), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![11, 31, 9, 6]), Op::Store(vec![10, 29, 32, 6]), Op::Store(vec![10, 25, 33, 6]), Op::Store(vec![10, 22, 34, 6]), Op::Store(vec![10, 19, 35, 6]), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![11, 37, 9, 6]), Op::Store(vec![10, 36, 38, 6])], ctrl: Ctrl::Return(60, vec![39]) }), (G::from_u64(6465), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 10, 7, 11]), Op::Store(vec![11, 11, 11]), Op::Store(vec![11, 13, 7]), Op::Const(G::from_u64(101)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![8, 16, 7, 11]), Op::Const(G::from_u64(38)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![8, 19, 7, 11]), Op::Store(vec![11, 6, 11, 11]), Op::Store(vec![11, 11, 11, 11]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(29)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 26, 14, 11]), Op::Store(vec![24, 27, 12, 11]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 29], 1, false), Op::Store(vec![6, 13, 11]), Op::Store(vec![11, 31, 7]), Op::Store(vec![8, 30, 32, 11]), Op::Call(476, vec![0, 11], 1, false), Op::Store(vec![8, 34, 7, 11]), Op::Store(vec![24, 33, 35, 11]), Op::Const(G::from_u64(31)), Op::Call(476, vec![0, 37], 1, false), Op::Store(vec![8, 38, 14, 11]), Op::Store(vec![24, 39, 12, 11]), Op::Store(vec![24, 40, 21, 11]), Op::Store(vec![24, 41, 22, 11]), Op::Store(vec![24, 20, 42, 11]), Op::Store(vec![24, 17, 43, 11]), Op::Store(vec![24, 36, 44, 11]), Op::Const(G::from_u64(42)), Op::Call(476, vec![0, 46], 1, false), Op::Store(vec![8, 47, 7, 11]), Op::Const(G::from_u64(100)), Op::Call(476, vec![0, 49], 1, false), Op::Store(vec![8, 50, 7, 11]), Op::Store(vec![24, 51, 21, 11]), Op::Store(vec![24, 48, 52, 11]), Op::Store(vec![24, 20, 22, 11]), Op::Store(vec![24, 17, 54, 11]), Op::Store(vec![24, 53, 55, 11]), Op::Store(vec![24, 45, 56, 11]), Op::Store(vec![23, 28, 57, 11]), Op::Store(vec![23, 12, 58, 11])], ctrl: Ctrl::Return(61, vec![59]) }), (G::from_u64(6528), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(1)), Op::Store(vec![8, 8, 8]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 11], 1, false), Op::Store(vec![10, 12, 9, 6]), Op::Call(476, vec![0, 10], 1, false), Op::Store(vec![10, 14, 9, 6]), Op::Const(G::from_u64(3)), Op::Call(476, vec![0, 8], 1, false), Op::Store(vec![10, 17, 9, 6]), Op::Store(vec![16, 15, 18, 6]), Op::Const(G::from_u64(44)), Op::Call(476, vec![0, 20], 1, false), Op::Store(vec![10, 21, 9, 6]), Op::Store(vec![16, 15, 19, 6]), Op::Store(vec![16, 22, 23, 6]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 25], 1, false), Op::Store(vec![8, 7, 6]), Op::Store(vec![6, 27, 9]), Op::Store(vec![10, 26, 28, 6]), Op::Store(vec![16, 29, 13, 6]), Op::Const(G::from_u64(102)), Op::Call(476, vec![0, 31], 1, false), Op::Store(vec![10, 32, 9, 6]), Op::Const(G::from_u64(38)), Op::Call(476, vec![0, 34], 1, false), Op::Store(vec![10, 35, 9, 6]), Op::Const(G::from_u64(30)), Op::Call(476, vec![0, 37], 1, false), Op::Store(vec![6, 7, 9]), Op::Store(vec![10, 38, 39, 6]), Op::Store(vec![16, 40, 13, 6]), Op::Store(vec![16, 36, 41, 6]), Op::Store(vec![16, 33, 42, 6]), Op::Store(vec![16, 30, 43, 6]), Op::Const(G::from_u64(40)), Op::Call(476, vec![0, 45], 1, false), Op::Store(vec![10, 46, 9, 6]), Op::Store(vec![16, 24, 19, 6]), Op::Store(vec![16, 24, 48, 6]), Op::Store(vec![16, 24, 49, 6]), Op::Store(vec![16, 24, 50, 6]), Op::Store(vec![16, 24, 51, 6]), Op::Store(vec![16, 24, 52, 6]), Op::Store(vec![16, 15, 53, 6]), Op::Store(vec![16, 47, 54, 6]), Op::Store(vec![16, 44, 55, 6])], ctrl: Ctrl::Return(62, vec![56]) }), (G::from_u64(6529), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 10, 7, 11]), Op::Store(vec![11, 11, 11]), Op::Store(vec![11, 13, 7]), Op::Store(vec![11, 11, 11, 11]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![6, 13, 11]), Op::Store(vec![11, 20, 7]), Op::Store(vec![8, 19, 21, 11]), Op::Store(vec![17, 22, 12, 11]), Op::Const(G::from_u64(102)), Op::Call(476, vec![0, 24], 1, false), Op::Store(vec![8, 25, 7, 11]), Op::Const(G::from_u64(38)), Op::Call(476, vec![0, 27], 1, false), Op::Store(vec![8, 28, 7, 11]), Op::Const(G::from_u64(31)), Op::Call(476, vec![0, 30], 1, false), Op::Store(vec![8, 31, 14, 11]), Op::Store(vec![17, 32, 12, 11]), Op::Store(vec![17, 33, 15, 11]), Op::Const(G::from_u64(30)), Op::Call(476, vec![0, 35], 1, false), Op::Store(vec![8, 36, 14, 11]), Op::Store(vec![17, 37, 12, 11]), Op::Store(vec![17, 34, 38, 11]), Op::Store(vec![17, 29, 39, 11]), Op::Store(vec![17, 26, 40, 11]), Op::Store(vec![17, 23, 41, 11]), Op::Store(vec![17, 42, 15, 11]), Op::Store(vec![16, 12, 43, 11])], ctrl: Ctrl::Return(63, vec![44]) }), (G::from_u64(6530), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![6, 6, 6]), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(39)), Op::Call(476, vec![0, 9], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![8, 10, 7, 11]), Op::Store(vec![11, 11, 11]), Op::Store(vec![11, 13, 7]), Op::Const(G::from_u64(102)), Op::Call(476, vec![0, 15], 1, false), Op::Store(vec![8, 16, 7, 11]), Op::Const(G::from_u64(38)), Op::Call(476, vec![0, 18], 1, false), Op::Store(vec![8, 19, 7, 11]), Op::Const(G::from_u64(3)), Op::Const(G::from_u64(31)), Op::Call(476, vec![0, 22], 1, false), Op::Store(vec![8, 23, 14, 11]), Op::Store(vec![21, 24, 12, 11]), Op::Store(vec![11, 6, 11, 11]), Op::Store(vec![21, 25, 26, 11]), Op::Store(vec![11, 11, 11, 11]), Op::Store(vec![21, 27, 28, 11]), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(29)), Op::Call(476, vec![0, 31], 1, false), Op::Store(vec![8, 32, 14, 11]), Op::Store(vec![21, 33, 12, 11]), Op::Const(G::from_u64(8)), Op::Call(476, vec![0, 35], 1, false), Op::Store(vec![6, 13, 11]), Op::Store(vec![11, 37, 7]), Op::Store(vec![8, 36, 38, 11]), Op::Store(vec![21, 39, 12, 11]), Op::Store(vec![11, 8, 11, 11]), Op::Store(vec![21, 25, 41, 11]), Op::Store(vec![21, 42, 29, 11]), Op::Store(vec![21, 20, 43, 11]), Op::Store(vec![21, 17, 44, 11]), Op::Store(vec![21, 40, 45, 11]), Op::Store(vec![21, 20, 29, 11]), Op::Store(vec![21, 17, 47, 11]), Op::Store(vec![21, 46, 48, 11]), Op::Store(vec![30, 34, 49, 11]), Op::Store(vec![30, 12, 50, 11]), Op::Store(vec![30, 12, 51, 11])], ctrl: Ctrl::Return(64, vec![52]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![7, 7, 7]), Op::Store(vec![6, 8, 7, 7])], ctrl: Ctrl::Return(65, vec![9]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 66, auxiliaries: 82, lookups: 82 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_568() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![1, 1]) }), (G::from_u64(38), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(1, vec![1, 2]) }), (G::from_u64(41), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(2, vec![1, 2]) }), (G::from_u64(42), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(3, vec![1, 2]) }), (G::from_u64(43), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(4, vec![1, 2]) }), (G::from_u64(44), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(5, vec![1, 2]) }), (G::from_u64(45), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(9))], ctrl: Ctrl::Return(6, vec![1, 2]) }), (G::from_u64(46), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(15))], ctrl: Ctrl::Return(7, vec![1, 2]) }), (G::from_u64(47), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(16))], ctrl: Ctrl::Return(8, vec![1, 2]) }), (G::from_u64(48), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(9, vec![1, 2]) }), (G::from_u64(49), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(10, vec![1, 2]) }), (G::from_u64(50), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(11, vec![1, 2]) }), (G::from_u64(51), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(10))], ctrl: Ctrl::Return(12, vec![1, 2]) }), (G::from_u64(52), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(11))], ctrl: Ctrl::Return(13, vec![1, 2]) }), (G::from_u64(53), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(12))], ctrl: Ctrl::Return(14, vec![1, 2]) }), (G::from_u64(54), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(13))], ctrl: Ctrl::Return(15, vec![1, 2]) }), (G::from_u64(55), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Const(G::from_u64(14))], ctrl: Ctrl::Return(16, vec![1, 2]) }), (G::from_u64(67), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(17, vec![1, 2]) }), (G::from_u64(68), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(18, vec![1, 2]) }), (G::from_u64(69), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(19, vec![1, 2]) }), (G::from_u64(75), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(20, vec![1, 2]) }), (G::from_u64(76), Block { ops: vec![Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(21, vec![1, 1]) }), (G::from_u64(77), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Const(G::from_u64(7))], ctrl: Ctrl::Return(22, vec![1, 2]) }), (G::from_u64(78), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Const(G::from_u64(8))], ctrl: Ctrl::Return(23, vec![1, 2]) }), (G::from_u64(79), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(24, vec![1, 2]) }), (G::from_u64(80), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Const(G::from_u64(10))], ctrl: Ctrl::Return(25, vec![1, 2]) }), (G::from_u64(81), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Const(G::from_u64(9))], ctrl: Ctrl::Return(26, vec![1, 2]) }), (G::from_u64(82), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(27, vec![1, 2]) }), (G::from_u64(85), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(28, vec![1, 2]) }), (G::from_u64(86), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(29, vec![1, 2]) }), (G::from_u64(87), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(30, vec![1, 2]) }), (G::from_u64(90), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(31, vec![1, 2]) }), (G::from_u64(92), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(32, vec![1, 2]) }), (G::from_u64(95), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Const(G::from_u64(6))], ctrl: Ctrl::Return(33, vec![1, 2]) }), (G::from_u64(96), Block { ops: vec![Op::Const(G::from_u64(5))], ctrl: Ctrl::Return(34, vec![1, 1]) }), (G::from_u64(97), Block { ops: vec![Op::Const(G::from_u64(5)), Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(35, vec![1, 2]) }), (G::from_u64(98), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(36, vec![1, 2]) }), (G::from_u64(99), Block { ops: vec![Op::Const(G::from_u64(6)), Op::Const(G::from_u64(4))], ctrl: Ctrl::Return(37, vec![1, 2]) }), (G::from_u64(101), Block { ops: vec![Op::Const(G::from_u64(2))], ctrl: Ctrl::Return(38, vec![1, 1]) }), (G::from_u64(102), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Const(G::from_u64(3))], ctrl: Ctrl::Return(39, vec![1, 2]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(40, vec![1, 1]) }))) }, layout: FunctionLayout { input_size: 1, selectors: 41, auxiliaries: 41, lookups: 1 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_569() -> 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_570() -> 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(234, vec![2], 1, false), Op::Load(12, 5), Op::Const(G::from_u64(1)), Op::Call(569, 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(570, vec![2], 1, false), Op::Call(570, vec![3], 1, false), Op::Mul(5, 6)], ctrl: Ctrl::Return(3, vec![7]) }), (G::from_u64(4), Block { ops: vec![Op::Call(570, vec![2], 1, false), Op::Call(570, vec![3], 1, false), Op::Mul(5, 6)], ctrl: Ctrl::Return(4, vec![7]) }), (G::from_u64(5), Block { ops: vec![Op::Call(570, vec![2], 1, false), Op::Call(570, vec![3], 1, false), Op::Mul(5, 6)], ctrl: Ctrl::Return(5, vec![7]) }), (G::from_u64(6), Block { ops: vec![Op::Call(570, vec![2], 1, false), Op::Call(570, vec![3], 1, false), Op::Mul(5, 6), Op::Call(570, vec![4], 1, false), Op::Mul(7, 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(570, 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_571() -> 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(570, 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_572() -> 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(572, vec![3, 1], 0, false)], ctrl: Ctrl::Return(1, vec![]) }), (G::from_u64(2), Block { ops: vec![Op::Call(572, vec![3, 1], 0, false), Op::Call(572, vec![4, 1], 0, false)], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(3), Block { ops: vec![Op::Call(572, vec![3, 1], 0, false), Op::Call(572, 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_573() -> 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(572, vec![3, 1], 0, false), Op::Call(573, 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_574() -> 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(572, vec![4, 2], 0, false)], ctrl: Ctrl::Return(1, vec![]) }), (G::from_u64(2), Block { ops: vec![Op::Call(234, vec![4], 1, false), Op::Load(12, 7), Op::Call(372, vec![8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], 1, false), Op::Call(775, vec![5], 1, false), Op::AssertEq(vec![21], vec![20], Some("Const applied to wrong number of universe levels".into())), Op::Call(573, vec![5, 2], 0, false)], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(3), Block { ops: vec![Op::Call(574, vec![4, 1, 2], 0, false), Op::Call(574, vec![5, 1, 2], 0, false)], ctrl: Ctrl::Return(3, vec![]) }), (G::from_u64(4), Block { ops: vec![Op::Call(574, vec![4, 1, 2], 0, false), Op::Const(G::from_u64(1)), Op::Add(1, 7), Op::Call(574, vec![5, 8, 2], 0, false)], ctrl: Ctrl::Return(4, vec![]) }), (G::from_u64(5), Block { ops: vec![Op::Call(574, vec![4, 1, 2], 0, false), Op::Const(G::from_u64(1)), Op::Add(1, 7), Op::Call(574, vec![5, 8, 2], 0, false)], ctrl: Ctrl::Return(5, vec![]) }), (G::from_u64(6), Block { ops: vec![Op::Call(574, vec![4, 1, 2], 0, false), Op::Call(574, vec![5, 1, 2], 0, false), Op::Const(G::from_u64(1)), Op::Add(1, 7), Op::Call(574, 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(574, 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_575() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::MatchContinue(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(32))], ctrl: Ctrl::Yield(0, vec![3]) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(33))], ctrl: Ctrl::Yield(1, vec![3]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(34))], ctrl: Ctrl::Yield(2, vec![3]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(35))], ctrl: Ctrl::Yield(3, vec![3]) })].into_iter().collect(), None, 1, 0, 0, Box::new(Block { ops: vec![Op::Call(480, vec![0, 1, 3], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![4], vec![5], Some("a quotient constant is not the binding's quotient role of its kind".into()))], ctrl: Ctrl::Return(4, vec![]) })) }, layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_576() -> 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(576, 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_577() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(775, 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(577, 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_578() -> 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(578, 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_579() -> Function { - Function { body: Block { ops: vec![Op::Call(234, 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_580() -> Function { - Function { body: Block { ops: vec![Op::Add(1, 3), Op::Call(576, vec![0, 7], 1, false), Op::Call(128, vec![8], 2, false), Op::Load(4, 9)], ctrl: Ctrl::Match(11, [(G::from_u64(2), Block { ops: vec![Op::Call(579, vec![12, 5, 6], 0, false), Op::Const(G::from_u64(0)), Op::Call(577, vec![13, 4, 15], 0, false), Op::Call(775, 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(578, vec![10, 1, 3, 15], 0, false), Op::Call(777, 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(591, 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_581() -> Function { - Function { body: Block { ops: vec![], 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::Load(4, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(5), Block { ops: vec![Op::Load(4, 2)], ctrl: Ctrl::Match(9, [(G::from_u64(5), Block { ops: vec![Op::Call(380, vec![0, 6, 10, 4], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![13], vec![14], Some("ctor parameter type disagrees with the inductive's".into())), Op::Const(G::from_u64(0)), Op::Store(vec![15, 6, 4]), Op::Sub(3, 14), Op::Call(581, vec![0, 7, 11, 17, 16], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 12, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_582() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Call(581, vec![0, 1, 2, 3, 5], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 2, lookups: 3 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_583() -> Function { - Function { body: Block { ops: vec![Op::Call(359, vec![0, 1, 3], 1, false)], ctrl: Ctrl::Match(2, [(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![6]) })].into_iter().collect(), None) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 9), Op::Const(G::from_u64(0)), Op::Store(vec![11, 6, 3]), Op::Call(583, vec![0, 7, 10, 12], 1, false)], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 9, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_584() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(4, [(G::from_u64(5), Block { ops: vec![Op::Call(451, vec![0, 5, 3], 1, false), Op::Call(270, vec![8, 2], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![9], vec![10], Some("ctor field lives in a universe above the inductive's".into())), Op::Const(G::from_u64(0)), Op::Store(vec![11, 5, 3]), Op::Call(584, vec![0, 6, 2, 12], 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: 8, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_585() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Call(584, vec![0, 1, 3, 4], 0, false)], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 9), Op::Const(G::from_u64(0)), Op::Store(vec![11, 6, 4]), Op::Call(585, vec![0, 7, 10, 3, 12], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 7, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_586() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 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::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Call(585, vec![0, 1, 2, 3, 8], 0, false)], ctrl: Ctrl::Return(1, vec![]) }))) }, layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 6, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_587() -> Function { - Function { body: Block { ops: vec![Op::Call(236, 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_588() -> 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(588, 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_589() -> Function { - Function { body: Block { ops: vec![Op::Call(234, vec![0], 1, false), Op::Load(12, 2)], ctrl: Ctrl::Match(3, [(G::from_u64(5), Block { ops: vec![Op::Call(588, 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_590() -> 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(589, vec![3, 1], 1, false)], ctrl: Ctrl::Return(2, vec![6]) }), (G::from_u64(3), Block { ops: vec![Op::Call(590, 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(590, vec![4, 1], 1, false)], ctrl: Ctrl::Return(4, vec![7]) }))) }), (G::from_u64(4), Block { ops: vec![Op::Call(590, 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(590, vec![4, 1], 1, false)], ctrl: Ctrl::Return(6, vec![7]) }))) }), (G::from_u64(5), Block { ops: vec![Op::Call(590, 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(590, vec![4, 1], 1, false)], ctrl: Ctrl::Return(8, vec![7]) }))) }), (G::from_u64(6), Block { ops: vec![Op::Call(590, 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(590, 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(590, 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(590, 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_591() -> 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(590, 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(591, 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_592() -> 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(592, 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_593() -> 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(593, 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_594() -> Function { - Function { body: Block { ops: vec![Op::Call(234, 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(577, vec![1, 7, 18], 0, false), Op::Call(775, vec![2], 1, false), Op::Add(9, 10), Op::AssertEq(vec![19], vec![20], Some("recursive occurrence is not fully applied".into())), Op::Call(593, vec![2, 9, 4, 18], 0, false), Op::Call(777, vec![2, 9], 1, false), Op::Call(591, 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_595() -> Function { - Function { body: Block { ops: vec![Op::Call(590, vec![1, 2], 1, false)], ctrl: Ctrl::Match(5, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(359, vec![0, 1, 3], 1, false), Op::Load(4, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(5), Block { ops: vec![Op::Call(590, vec![8, 2], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![11], vec![12], Some("strict positivity: block occurs left of an arrow".into())), Op::Store(vec![12, 8, 3]), Op::Call(595, vec![0, 9, 2, 13, 4], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(128, vec![6], 2, false), Op::Load(4, 11)], ctrl: Ctrl::Match(13, [(G::from_u64(2), Block { ops: vec![Op::Call(589, vec![14, 2], 1, false)], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(775, vec![3], 1, false), Op::Call(594, vec![14, 15, 12, 2, 18], 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(234, vec![14], 1, false), Op::Load(12, 18)], ctrl: Ctrl::Match(19, [(G::from_u64(5), Block { ops: vec![Op::Call(777, vec![12, 22], 1, false), Op::Call(591, vec![31, 2], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![32], vec![33], Some("strict positivity: block occurs in a nested inductive's index args".into())), Op::Store(vec![33, 26, 2]), Op::Call(776, vec![12, 22], 1, false), Op::Call(764, vec![35], 1, false), Op::Call(596, vec![0, 26, 27, 24, 34, 33, 22, 36], 0, false)], ctrl: Ctrl::Return(4, vec![]) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 5, auxiliaries: 35, lookups: 15 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_596() -> Function { - Function { body: Block { ops: vec![Op::Sub(3, 5)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(237, vec![1, 2, 5], 1, false), Op::Load(12, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![22, 22, 22]), Op::Call(592, vec![12, 6, 23], 2, false), Op::Const(G::from_u64(0)), Op::Call(320, vec![24, 7, 26], 1, false), Op::Call(597, vec![0, 27, 4, 23, 26], 0, false), Op::Add(5, 22), Op::Call(596, vec![0, 1, 2, 3, 4, 28, 6, 7], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 8, selectors: 2, auxiliaries: 19, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_597() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(5), Block { ops: vec![Op::Call(595, vec![0, 6, 2, 3, 4], 0, false), Op::Const(G::from_u64(0)), Op::Store(vec![9, 6, 3]), Op::Call(597, vec![0, 7, 2, 10, 4], 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: 5, selectors: 2, auxiliaries: 6, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_598() -> Function { - Function { body: 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, 3, 7]), Op::Call(592, vec![1, 2, 4], 2, false), Op::Call(597, vec![0, 9, 8, 10, 6], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 5, selectors: 1, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_599() -> Function { - Function { body: Block { ops: vec![Op::Add(2, 3), Op::Const(G::from_u64(1)), Op::Store(vec![10, 10, 10]), Op::Call(583, vec![0, 1, 9, 11], 1, false), Op::Const(G::from_u64(0)), Op::Call(600, vec![0, 1, 2, 3, 4, 5, 6, 7, 12, 8, 13], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 9, selectors: 1, auxiliaries: 3, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_600() -> Function { - Function { body: Block { ops: vec![Op::Sub(4, 10)], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(237, vec![6, 7, 10], 1, false), Op::Load(12, 12)], ctrl: Ctrl::Match(13, [(G::from_u64(6), Block { ops: vec![Op::Call(2, vec![16, 6], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![25], vec![26], Some("ctor belongs to a different block than its inductive".into())), Op::AssertEq(vec![17], vec![7], Some("ctor points at a different member of the block".into())), Op::AssertEq(vec![18], vec![10], Some("ctor's stored index differs from its position".into())), Op::AssertEq(vec![19], vec![2], Some("ctor parameter count differs from the inductive's".into())), Op::Call(582, vec![0, 1, 15, 2], 0, false), Op::Call(580, vec![15, 19, 3, 20, 5, 6, 7], 0, false), Op::Call(586, vec![0, 15, 19, 8], 0, false)], ctrl: Ctrl::MatchContinue(9, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![27, 27, 27]), Op::Call(598, vec![0, 15, 19, 6, 28], 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(10, 27), Op::Call(600, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 28], 0, false)], ctrl: Ctrl::Return(3, vec![]) })) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 11, selectors: 4, auxiliaries: 17, lookups: 10 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_601() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(5), Block { ops: vec![Op::Call(599, vec![0, 3, 4, 5, 6, 2, 8, 9, 7], 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: 13, selectors: 2, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_602() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(5), Block { ops: vec![Op::Call(2, vec![8, 13], 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![Op::Call(228, vec![8], 48, false)], ctrl: Ctrl::Match(15, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(15, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(603, vec![0, 16, 3, 4, 5, 9, 63, 8], 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: 14, selectors: 4, auxiliaries: 52, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_603() -> 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![]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Sub(6, 5), Op::EqZero(55)], ctrl: Ctrl::Match(56, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(6, 57), Op::Call(603, vec![0, 54, 2, 3, 4, 5, 58, 7], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(236, vec![7, 6], 1, false), Op::Load(12, 57)], ctrl: Ctrl::Match(58, [(G::from_u64(5), Block { ops: vec![Op::AssertEq(vec![61], vec![3], Some("mutual block peers disagree on parameter count".into())), Op::Call(582, vec![0, 2, 60, 3], 0, false), Op::Add(3, 4), Op::Const(G::from_u64(1)), Op::Store(vec![71, 71, 71]), Op::Call(583, vec![0, 2, 70, 72], 1, false), Op::Add(61, 62), Op::Call(583, vec![0, 60, 74, 72], 1, false), Op::Call(271, vec![73, 75], 1, false), Op::AssertEq(vec![76], vec![71], Some("mutual block peers land in different universes".into())), Op::Add(6, 71), Op::Call(603, vec![0, 54, 2, 3, 4, 5, 77, 7], 0, false)], ctrl: Ctrl::Return(2, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(6, 70), Op::Call(603, vec![0, 54, 2, 3, 4, 5, 71, 7], 0, false)], ctrl: Ctrl::Return(3, vec![]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(6, 55), Op::Call(603, vec![0, 54, 2, 3, 4, 5, 56, 7], 0, false)], ctrl: Ctrl::Return(4, vec![]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 5, auxiliaries: 68, lookups: 10 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_604() -> Function { - Function { body: Block { ops: vec![Op::Call(244, vec![1], 1, false)], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(0, vec![18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(2, vec![18]) }), (G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(3, vec![18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(11, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1))], ctrl: Ctrl::Return(4, vec![18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![18, 18, 18]), Op::Call(605, vec![0, 6, 10, 11, 19], 1, false)], 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![18]) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(7, vec![18]) }))) }))) }))) }, layout: FunctionLayout { input_size: 17, selectors: 8, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_605() -> 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::Store(vec![6, 6, 6]), Op::Call(606, vec![0, 1, 3, 5, 4, 7], 1, false)], ctrl: Ctrl::Return(0, vec![8]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(5, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![9, 6, 4]), Op::Const(G::from_u64(1)), Op::Sub(2, 11), Op::Call(605, vec![0, 7, 12, 3, 10], 1, false)], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![9]) }))) }))) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 8, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_606() -> Function { - Function { body: Block { ops: vec![Op::Sub(2, 3)], ctrl: Ctrl::Match(6, [(G::from_u64(0), Block { ops: vec![Op::Call(128, vec![1], 2, false), Op::Call(607, vec![5, 8], 1, false)], ctrl: Ctrl::Return(0, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(7, [(G::from_u64(5), Block { ops: vec![Op::Call(451, vec![0, 8, 4], 1, false), Op::Const(G::from_u64(1)), Op::Const(G::from_u64(0)), Op::Store(vec![13, 13, 13]), Op::Call(271, vec![11, 14], 1, false), Op::Sub(12, 15), Op::Sub(2, 12), Op::Sub(17, 3)], ctrl: Ctrl::MatchContinue(16, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![5]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![19, 18, 5])], ctrl: Ctrl::Yield(2, vec![20]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![20, 8, 4]), Op::Const(G::from_u64(1)), Op::Add(3, 22), Op::Call(606, vec![0, 9, 2, 23, 21, 19], 1, false)], 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![11]) }))) }))) }, layout: FunctionLayout { input_size: 6, selectors: 5, auxiliaries: 14, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_607() -> 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(608, 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(607, 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_608() -> 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(608, vec![4, 1], 1, false)], ctrl: Ctrl::Return(2, vec![10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(608, 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_609() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(5), Block { ops: vec![Op::Call(610, vec![8, 13], 1, false)], ctrl: Ctrl::Match(14, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(0, vec![15]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Add(4, 5), Op::Const(G::from_u64(1)), Op::Store(vec![16, 16, 16]), Op::Call(583, vec![0, 3, 15, 17], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![19, 19, 19]), Op::Call(271, vec![18, 20], 1, false)], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(1, vec![22]) })].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(0)), Op::Call(237, vec![8, 9, 22], 1, false), Op::Load(12, 23)], ctrl: Ctrl::Match(24, [(G::from_u64(6), Block { ops: vec![Op::EqZero(31)], 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![36]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(4, vec![22]) }))) }))) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(5, vec![14]) }))) }, layout: FunctionLayout { input_size: 14, selectors: 6, auxiliaries: 23, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_610() -> 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(228, 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(612, 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_611() -> Function { - Function { body: Block { ops: vec![Op::Call(228, 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_612() -> 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(612, vec![48, 50], 1, false)], ctrl: Ctrl::Return(2, vec![51]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(612, 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_613() -> Function { - Function { body: Block { ops: vec![Op::Add(1, 2), Op::Add(5, 3), Op::Add(6, 4), Op::Call(576, vec![0, 7], 1, false), Op::Load(4, 8)], ctrl: Ctrl::Match(9, [(G::from_u64(5), Block { ops: vec![Op::Call(128, 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_614() -> 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(576, vec![2, 14], 1, false), Op::Load(4, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(5), Block { ops: vec![Op::Call(128, 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_615() -> Function { - Function { body: Block { ops: vec![Op::Add(1, 2), Op::Add(6, 3), Op::Add(7, 4), Op::Call(576, vec![0, 8], 1, false), Op::Load(4, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(5), Block { ops: vec![Op::Call(128, vec![11], 2, false), Op::Call(776, vec![15, 5], 1, false), Op::Add(2, 3), Op::Add(17, 4), Op::Call(616, 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_616() -> 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(293, 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(310, vec![3, 1, 5], 1, false), Op::Call(616, 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_617() -> 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(617, 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_618() -> Function { - Function { body: Block { ops: vec![Op::Call(228, 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(619, 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(234, 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(617, 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_619() -> 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(241, vec![0, 2, 4], 1, false), Op::Call(236, 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(617, vec![3, 66, 67], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![69, 69, 69]), Op::Add(4, 69), Op::Call(619, 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(619, 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_620() -> 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(623, 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(620, vec![8, 1, 2], 1, false)], ctrl: Ctrl::Return(2, vec![11]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(620, vec![8, 1, 2], 1, false)], ctrl: Ctrl::Return(3, vec![10]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(620, 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_621() -> 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(274, 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(622, 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(621, vec![4, 8], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(621, 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(621, vec![4, 8], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(621, 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(621, vec![4, 8], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(621, 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(621, vec![4, 8], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(621, vec![5, 9], 1, false)], ctrl: Ctrl::Match(12, [(G::from_u64(1), Block { ops: vec![Op::Call(621, 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(287, 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(621, 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_622() -> 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(274, vec![3, 6], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(622, 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_623() -> 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(621, vec![3, 6], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(623, 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_624() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(7), Block { ops: vec![Op::Call(615, 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_625() -> Function { - Function { body: Block { ops: vec![Op::Call(228, 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(626, 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_626() -> 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(241, vec![0, 2, 3], 1, false), Op::Call(234, vec![52], 1, false), Op::Load(12, 53)], ctrl: Ctrl::Match(54, [(G::from_u64(7), Block { ops: vec![Op::Call(613, vec![56, 57, 59, 60, 58], 1, false), Op::Call(234, 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(626, 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_627() -> Function { - Function { body: Block { ops: vec![Op::Call(228, 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(626, 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(228, 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(619, 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(234, 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(617, 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(611, 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(628, 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_628() -> Function { - Function { body: Block { ops: vec![Op::Call(228, 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(629, 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_629() -> 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(241, vec![0, 2, 6], 1, false), Op::Call(234, vec![54], 1, false), Op::Load(12, 55)], ctrl: Ctrl::MatchContinue(56, [(G::from_u64(7), Block { ops: vec![Op::Call(613, vec![58, 59, 61, 62, 60], 1, false), Op::Call(234, 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(629, 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(624, vec![56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 71], 1, false), Op::Call(614, vec![56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67], 1, false), Op::Call(620, 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(629, 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(774, vec![5, 69, 76, 73, 74], 1, false), Op::Add(6, 76), Op::Call(629, 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(629, 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_630() -> 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(630, 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_631() -> 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(623, 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(631, 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_632() -> 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(632, 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_633() -> 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(775, vec![3], 1, false), Op::U32LessThan(0, 4)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![Op::Call(768, 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_634() -> 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(633, vec![5, 2, 3, 4], 1, false), Op::Const(G::from_u64(0)), Op::Call(316, vec![8, 10, 11], 1, false), Op::Const(G::from_u64(1)), Op::Sub(1, 13), Op::Add(5, 13), Op::Call(634, 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_635() -> 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::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(2, 8), Op::Call(635, vec![0, 5, 9], 1, false), Op::Store(vec![7, 4, 10])], ctrl: Ctrl::Return(1, vec![11]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Call(359, vec![0, 1, 8], 1, false), Op::Load(4, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Sub(2, 15), Op::Call(635, vec![0, 12, 16], 1, false), Op::Store(vec![14, 11, 17])], ctrl: Ctrl::Return(2, vec![18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![14, 14, 14])], ctrl: Ctrl::Return(3, vec![15]) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 15, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_636() -> 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(636, 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_637() -> 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(306, vec![4, 2, 6], 1, false), Op::Const(G::from_u64(3)), Op::Store(vec![8, 0, 7, 6]), Op::Call(637, 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_638() -> 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(636, vec![0, 1, 2, 5], 1, false)], ctrl: Ctrl::Return(0, vec![6]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(637, 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_639() -> 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(639, 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_640() -> 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(640, 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_641() -> 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, 1]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 7), Op::Call(641, vec![0, 5, 8], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![11, 4, 9])], ctrl: Ctrl::Return(1, vec![12, 10]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![7, 7, 7]), Op::Call(359, vec![0, 1, 8], 1, false), Op::Load(4, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Sub(2, 14), Op::Call(641, vec![0, 12, 15], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![18, 11, 16])], ctrl: Ctrl::Return(2, vec![19, 17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![14, 14, 14])], ctrl: Ctrl::Return(3, vec![15, 1]) }))) }))) }))) }, layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 16, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_642() -> 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(306, vec![4, 1, 2], 1, false), Op::Const(G::from_u64(1)), Op::Add(2, 8), Op::Call(642, 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_643() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(4, [(G::from_u64(1), Block { ops: vec![Op::Call(637, 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(647, 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_644() -> 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(644, 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_645() -> Function { - Function { body: Block { ops: vec![Op::Call(283, vec![2, 5], 1, false), Op::Const(G::from_u64(0)), Op::Call(634, vec![10, 3, 7, 8, 9, 11], 1, false), Op::Call(635, vec![0, 12, 4], 1, false), Op::Const(G::from_u64(2)), Op::Store(vec![14, 1, 5, 11])], ctrl: Ctrl::MatchContinue(8, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(636, vec![15, 7, 4, 16], 1, false)], ctrl: Ctrl::Yield(0, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(637, vec![15, 9, 4], 1, false)], ctrl: Ctrl::Yield(1, vec![16]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(639, vec![16, 4, 17], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![19, 6, 17, 17]), Op::Const(G::from_u64(5)), Op::Store(vec![21, 18, 20, 17]), Op::Call(640, vec![22, 13], 1, false)], ctrl: Ctrl::Return(2, vec![23]) })) }, layout: FunctionLayout { input_size: 10, selectors: 3, auxiliaries: 12, lookups: 10 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_646() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(681, vec![0, 1, 2, 3, 4], 1, false)], ctrl: Ctrl::Return(0, vec![5]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_647() -> 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(647, 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_648() -> 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(648, 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_649() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(632, vec![7, 10], 4, false), Op::Call(234, vec![11], 1, false), Op::Load(12, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(5), Block { ops: vec![Op::Call(650, vec![0, 18, 17, 1, 2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Return(0, vec![28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(650, vec![0, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9], 1, false)], ctrl: Ctrl::Return(1, vec![28]) }))) }, layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 20, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_650() -> Function { - Function { body: Block { ops: vec![Op::Call(780, vec![9], 1, false), Op::Const(G::from_u64(0)), Op::Call(617, vec![8, 2, 13], 1, false), Op::Call(283, vec![1, 14], 1, false), Op::Call(641, vec![0, 15, 5], 2, false), Op::Call(646, vec![0, 9, 7, 5], 1, false), Op::Call(664, vec![0, 9, 10, 5, 12, 5], 1, false), Op::Call(775, vec![19], 1, false), Op::Call(632, vec![9, 11], 4, false), Op::Call(234, vec![21], 1, false), Op::Load(12, 25)], ctrl: Ctrl::Match(26, [(G::from_u64(5), Block { ops: vec![Op::Call(283, vec![28, 24], 1, false), Op::Const(G::from_u64(0)), Op::Call(634, vec![38, 29, 5, 22, 23, 39], 1, false), Op::Call(635, vec![0, 40, 6], 1, false), Op::Add(12, 20), Op::Call(642, vec![41, 42, 39], 1, false), Op::Const(G::from_u64(2)), Op::Store(vec![44, 21, 24, 39]), Op::Add(5, 12), Op::Add(46, 20), Op::Add(47, 6), Op::Const(G::from_u64(1)), Op::Sub(48, 49), Op::Add(42, 6)], ctrl: Ctrl::MatchContinue(22, [(G::from_u64(1), Block { ops: vec![Op::Call(637, vec![45, 23, 51], 1, false)], ctrl: Ctrl::Yield(0, vec![52]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(647, vec![45, 5, 50, 52], 1, false)], ctrl: Ctrl::Yield(1, vec![53]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(639, vec![52, 6, 53], 1, false), Op::Const(G::from_u64(1)), Op::Add(48, 55), Op::Sub(56, 55), Op::Add(5, 11), Op::Sub(57, 58), Op::Store(vec![53, 59, 53, 53]), Op::Call(644, vec![60, 6, 53], 1, false), Op::Const(G::from_u64(3)), Op::Store(vec![53, 53, 53, 53]), Op::Store(vec![62, 61, 63, 53]), Op::Const(G::from_u64(5)), Op::Store(vec![65, 54, 64, 53]), Op::Call(640, vec![66, 43], 1, false), Op::Call(640, vec![67, 19], 1, false), Op::Call(640, vec![68, 18], 1, false), Op::Call(640, vec![69, 16], 1, false)], ctrl: Ctrl::Return(2, vec![70]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 12, selectors: 3, auxiliaries: 44, lookups: 27 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_651() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(14, [(G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::MatchContinue(19, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(237, vec![21, 22, 27], 1, false), Op::Load(12, 28), Op::Const(G::from_u64(1))], ctrl: Ctrl::Yield(0, vec![41, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![27, 27, 27]), Op::Store(vec![28, 29, 27, 27])], ctrl: Ctrl::Yield(1, vec![27, 27, 27, 30, 27, 27, 27, 27, 27, 27, 27, 27, 27]) })), 13, 13, 2, Box::new(Block { ops: vec![Op::Add(17, 18), Op::Const(G::from_u64(1)), Op::Store(vec![41, 41, 41]), Op::Call(583, vec![0, 16, 40, 42], 1, false), Op::Call(610, vec![21, 26], 1, false), Op::Call(604, vec![0, 43, 19, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 44], 1, false)], ctrl: Ctrl::MatchContinue(45, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![46, 47, 47])], ctrl: Ctrl::Yield(2, vec![48]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![46, 46, 46])], ctrl: Ctrl::Yield(3, vec![47]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(684, vec![2, 47], 1, false), Op::Call(627, vec![11, 21, 45], 1, false), Op::Call(658, vec![49, 11, 13], 1, false), Op::Call(661, vec![49], 1, false), Op::Call(611, vec![11], 1, false), Op::Call(611, vec![21], 1, false), Op::Mul(52, 53), Op::Const(G::from_u64(1)), Op::Call(2, vec![11, 21], 1, false), Op::Sub(55, 56), Op::Mul(54, 57)], ctrl: Ctrl::MatchContinue(58, [(G::from_u64(1), Block { ops: vec![Op::Call(624, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 17], 1, false)], ctrl: Ctrl::Yield(4, vec![59]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![59, 59, 59])], ctrl: Ctrl::Yield(5, vec![60]) })), 1, 2, 1, Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(631, vec![49, 26, 58, 59, 60], 2, false)], ctrl: Ctrl::Match(61, [(G::from_u64(1), Block { ops: vec![Op::Call(652, vec![0, 49, 62, 19, 21, 22, 4, 6, 7, 48, 50, 51, 8, 3, 16, 15, 18, 46, 45], 0, false)], ctrl: Ctrl::Return(6, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(630, vec![49, 26, 63], 2, false)], ctrl: Ctrl::Match(64, [(G::from_u64(1), Block { ops: vec![Op::Call(652, vec![0, 49, 65, 19, 21, 22, 4, 6, 7, 48, 50, 51, 8, 3, 16, 15, 18, 46, 45], 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: 27, selectors: 9, auxiliaries: 51, lookups: 19 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_652() -> Function { - Function { body: Block { ops: vec![Op::Call(632, vec![1, 2], 4, false), Op::Call(649, vec![0, 14, 15, 6, 16, 17, 18, 1, 11, 2], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![24, 24, 24]), Op::Call(380, vec![0, 13, 23, 25], 1, false), Op::AssertEq(vec![26], vec![24], Some("recursor's declared type is not def-eq to the canonical reconstruction".into())), Op::Call(780, vec![1], 1, false), Op::Call(664, vec![0, 1, 11, 6, 27, 6], 1, false), Op::Call(775, vec![28], 1, false), Op::AssertEq(vec![7], vec![27], Some("recursor motive count disagrees with the canonical reconstruction".into())), Op::AssertEq(vec![8], vec![29], Some("recursor minor count disagrees with the canonical reconstruction".into())), Op::Const(G::from_u64(0)), Op::Call(653, vec![1, 2, 30], 1, false), Op::Call(654, vec![0, 3, 31, 4, 5, 6, 7, 8, 22, 9, 1, 10, 11, 20, 21, 30], 1, false), Op::Call(655, vec![0, 12, 32, 6, 7, 8, 4, 5, 3, 30], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 19, selectors: 1, auxiliaries: 13, lookups: 11 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_653() -> 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(234, 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(653, 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_654() -> Function { - Function { body: Block { ops: vec![Op::Sub(1, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![17, 17, 17])], ctrl: Ctrl::Return(0, vec![18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(237, vec![3, 4, 15], 1, false), Op::Load(12, 17)], ctrl: Ctrl::Match(18, [(G::from_u64(6), Block { ops: vec![Op::Add(2, 15), Op::Call(657, vec![0, 20, 30, 5, 6, 7, 24, 8, 9, 10, 11, 12, 13, 14], 1, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(15, 33), Op::Call(654, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 34], 1, false), Op::Store(vec![32, 31, 35])], ctrl: Ctrl::Return(1, vec![36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![30, 30, 30])], ctrl: Ctrl::Return(2, vec![31]) }))) }))) }, layout: FunctionLayout { input_size: 16, selectors: 3, auxiliaries: 18, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_655() -> Function { - Function { body: Block { ops: vec![Op::Load(5, 1)], ctrl: Ctrl::Match(10, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(11, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::AssertEq(vec![11], vec![9], Some("recursor rule is out of ctor order".into())), Op::U32LessThan(11, 8), Op::Const(G::from_u64(1)), Op::AssertEq(vec![15], vec![16], Some("recursor rule names a ctor index out of range".into())), Op::Call(237, vec![6, 7, 11], 1, false), Op::Load(12, 17)], ctrl: Ctrl::MatchContinue(18, [(G::from_u64(6), Block { ops: vec![Op::AssertEq(vec![12], vec![25], 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, 2)], ctrl: Ctrl::Match(30, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Add(3, 4), Op::Add(33, 5), Op::Add(34, 12), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![37, 37, 37]), Op::Call(686, vec![13, 35, 36, 38], 3, false), Op::AssertEq(vec![40], vec![35], Some("recursor rule rhs has too few binders to peel".into())), Op::Call(380, vec![0, 39, 31, 38], 1, false), Op::AssertEq(vec![42], vec![37], Some("recursor rule rhs differs from canonical reconstruction".into())), Op::Add(9, 37), Op::Call(655, vec![0, 14, 32, 3, 4, 5, 6, 7, 8, 43], 0, false)], ctrl: Ctrl::Return(3, vec![]) })].into_iter().collect(), None) })) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 10, selectors: 4, auxiliaries: 33, lookups: 15 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_656() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 2)], ctrl: Ctrl::Match(13, [(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(759, vec![3, 12, 16], 1, false), Op::Store(vec![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]), Op::Call(759, vec![5, 17, 18], 1, false), Op::Call(759, vec![6, 17, 16], 1, false), Op::Add(7, 8), Op::Add(21, 9), Op::Add(22, 10), Op::Call(768, vec![4, 14], 1, false), Op::Sub(10, 14), Op::Call(306, vec![24, 25, 16], 1, false), Op::Add(8, 9), Op::Call(306, vec![26, 27, 10], 1, false), Op::Call(670, vec![28], 2, false), Op::Call(775, vec![29], 1, false), Op::Add(23, 31), Op::Const(G::from_u64(2)), Op::Store(vec![33, 19, 11, 16]), Op::Const(G::from_u64(1)), Op::Sub(32, 35), Op::Call(647, vec![34, 7, 36, 16], 1, false), Op::Sub(36, 7), Op::Call(647, vec![37, 8, 38, 16], 1, false), Op::Sub(38, 8), Op::Call(647, vec![39, 9, 40, 16], 1, false), Op::Store(vec![35, 35, 35]), Op::Call(359, vec![0, 30, 42], 1, false), Op::Call(128, vec![43], 2, false), Op::Call(777, vec![45, 20], 1, false), Op::Call(201, vec![41, 46], 1, false), Op::Sub(10, 35), Op::Sub(48, 14), Op::Add(49, 31), Op::Store(vec![16, 50, 16, 16]), Op::Call(639, vec![51, 31, 16], 1, false), Op::Const(G::from_u64(3)), Op::Store(vec![53, 47, 52, 16]), Op::Call(648, vec![54, 29], 1, false), Op::Store(vec![53, 1, 55, 16]), Op::Add(12, 35), Op::Call(656, vec![0, 56, 15, 3, 4, 5, 6, 7, 8, 9, 10, 11, 57], 1, false)], ctrl: Ctrl::Return(1, vec![58]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 13, selectors: 2, auxiliaries: 30, lookups: 26 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_657() -> Function { - Function { body: Block { ops: vec![Op::Call(283, vec![1, 7], 1, false), Op::Call(576, vec![14, 6], 1, false), Op::Const(G::from_u64(0)), Op::Call(667, vec![15, 16], 1, false), Op::Add(3, 4), Op::Add(18, 5), Op::Add(19, 17), Op::Call(668, vec![0, 14, 6, 6, 16, 12, 13, 16], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![22, 22, 22]), Op::Call(680, vec![0, 21, 9, 23, 23, 23, 16, 16], 4, false), Op::Sub(20, 22), Op::Add(18, 2), Op::Sub(28, 29), Op::Store(vec![16, 30, 16, 16]), Op::Call(674, vec![31, 17, 17, 16], 1, false), Op::Call(656, vec![0, 32, 25, 26, 24, 10, 11, 3, 4, 5, 17, 8, 16], 1, false)], ctrl: Ctrl::Return(0, vec![33]) }, layout: FunctionLayout { input_size: 14, selectors: 1, auxiliaries: 13, lookups: 10 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_658() -> 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(659, vec![1, 4, 6, 5, 2], 1, false), Op::Const(G::from_u64(0)), Op::Call(658, 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_659() -> Function { - Function { body: Block { ops: vec![Op::Call(228, 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(660, 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_660() -> 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(241, vec![0, 2, 7], 1, false), Op::Call(234, vec![55], 1, false), Op::Load(12, 56)], ctrl: Ctrl::MatchContinue(57, [(G::from_u64(7), Block { ops: vec![Op::Call(613, vec![59, 60, 62, 63, 61], 1, false), Op::Call(234, 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(615, vec![59, 60, 62, 63, 61, 83], 1, false), Op::Call(623, 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(660, 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(660, 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_661() -> 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(234, 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(661, 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_662() -> Function { - Function { body: Block { ops: vec![Op::Call(240, vec![0], 8, false), Op::Call(240, 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(82, 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(23, 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_663() -> Function { - Function { body: Block { ops: vec![Op::Sub(13, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![17, 17, 17])], ctrl: Ctrl::Return(0, vec![18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(237, vec![11, 12, 15], 1, false), Op::Load(12, 17)], ctrl: Ctrl::Match(18, [(G::from_u64(6), Block { ops: vec![Op::Call(662, vec![12, 15, 11], 1, false), Op::Call(669, vec![0, 30, 20, 24, 2, 3, 4, 5, 6, 7, 8, 14, 9, 10], 1, false), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Add(14, 33), Op::Add(15, 33), Op::Call(663, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 34, 35], 1, false), Op::Store(vec![32, 31, 36])], ctrl: Ctrl::Return(1, vec![37]) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 16, selectors: 2, auxiliaries: 19, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_664() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(665, vec![0, 1, 1, 2, 3, 4, 5, 6, 6], 1, false)], ctrl: Ctrl::Return(0, vec![7]) }, layout: FunctionLayout { input_size: 6, selectors: 1, auxiliaries: 2, lookups: 2 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_665() -> Function { - Function { body: Block { ops: vec![Op::Load(6, 1)], ctrl: Ctrl::Match(9, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![15, 15, 15])], ctrl: Ctrl::Return(0, vec![16]) }), (G::from_u64(0), Block { ops: vec![Op::Call(234, vec![10], 1, false), Op::Load(12, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(663, vec![0, 10, 11, 12, 13, 2, 3, 4, 5, 6, 8, 23, 24, 21, 7, 28], 1, false), Op::Call(775, vec![29], 1, false), Op::Add(7, 30), Op::Const(G::from_u64(1)), Op::Add(8, 32), Op::Call(665, vec![0, 14, 2, 3, 4, 5, 6, 31, 33], 1, false), Op::Call(765, vec![29, 34], 1, false)], ctrl: Ctrl::Return(1, vec![35]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(8, 28), Op::Call(665, vec![0, 14, 2, 3, 4, 5, 6, 7, 29], 1, false)], ctrl: Ctrl::Return(2, vec![30]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 3, auxiliaries: 24, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_666() -> 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(775, vec![4], 1, false), Op::U32LessThan(0, 5)], ctrl: Ctrl::Match(6, [(G::from_u64(1), Block { ops: vec![Op::Call(768, vec![4, 0], 1, false), Op::Const(G::from_u64(0)), Op::Call(306, 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_667() -> 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(667, 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_668() -> Function { - Function { body: 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::Load(4, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(5), Block { ops: vec![Op::Call(666, vec![7, 3, 4, 5, 6], 1, false), Op::Const(G::from_u64(0)), Op::Call(316, vec![10, 12, 13], 1, false), Op::Const(G::from_u64(1)), Op::Sub(2, 15), Op::Add(7, 15), Op::Call(668, vec![0, 14, 16, 3, 4, 5, 6, 17], 1, false)], ctrl: Ctrl::Return(1, vec![18]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![12, 12, 12]), Op::Call(359, vec![0, 1, 13], 1, false), Op::Load(4, 14)], ctrl: Ctrl::Match(15, [(G::from_u64(5), Block { ops: vec![Op::Call(666, vec![7, 3, 4, 5, 6], 1, false), Op::Const(G::from_u64(0)), Op::Call(316, vec![17, 19, 20], 1, false), Op::Const(G::from_u64(1)), Op::Sub(2, 22), Op::Add(7, 22), Op::Call(668, vec![0, 21, 23, 3, 4, 5, 6, 24], 1, false)], ctrl: Ctrl::Return(2, vec![25]) })].into_iter().collect(), None) }))) }))) }, layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 16, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_669() -> Function { - Function { body: Block { ops: vec![Op::Call(283, vec![2, 6], 1, false), Op::Add(9, 10), Op::Add(15, 11), Op::Add(10, 11), Op::Const(G::from_u64(0)), Op::Call(668, vec![0, 14, 3, 16, 17, 4, 5, 18], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![20, 20, 20]), Op::Call(680, vec![0, 19, 7, 21, 21, 21, 18, 17], 4, false), Op::Call(775, vec![22], 1, false), Op::Call(775, vec![23], 1, false), Op::Add(26, 27), Op::Add(16, 28), Op::Call(128, vec![25], 2, false), Op::Call(777, vec![31, 3], 1, false), Op::Call(673, vec![32, 27, 18], 1, false), Op::Sub(29, 20), Op::Add(12, 13), Op::Sub(34, 35), Op::Store(vec![18, 36, 18, 18]), Op::Call(201, vec![37, 33], 1, false), Op::Const(G::from_u64(2)), Op::Store(vec![39, 1, 6, 18]), Op::Call(675, vec![40, 3, 9, 29, 4, 5], 1, false), Op::Call(674, vec![41, 26, 28, 18], 1, false), Op::Const(G::from_u64(3)), Op::Store(vec![43, 38, 42, 18]), Op::Call(672, vec![0, 23, 24, 22, 8, 12, 26, 16, 18], 1, false), Op::Call(640, vec![44, 45], 1, false), Op::Call(640, vec![46, 22], 1, false)], ctrl: Ctrl::Return(0, vec![47]) }, layout: FunctionLayout { input_size: 14, selectors: 1, auxiliaries: 23, lookups: 19 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_670() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![1, 1, 1]), Op::Call(671, vec![0, 2], 2, false), Op::Call(764, 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_671() -> 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(671, 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_672() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(9, [(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::Const(G::from_u64(0)), Op::Call(759, vec![2, 8, 12], 1, false), Op::Call(759, vec![4, 13, 12], 1, false), Op::Add(7, 6), Op::Add(15, 8), Op::Call(768, vec![3, 10], 1, false), Op::Sub(6, 10), Op::Add(18, 8), Op::Call(306, vec![17, 19, 12], 1, false), Op::Call(670, vec![20], 2, false), Op::Call(775, vec![21], 1, false), Op::Add(16, 23), Op::Const(G::from_u64(1)), Op::Sub(24, 25), Op::Add(5, 13), Op::Sub(26, 27), Op::Add(7, 10), Op::Sub(26, 29), Op::Store(vec![25, 25, 25]), Op::Call(359, vec![0, 22, 31], 1, false), Op::Call(128, vec![32], 2, false), Op::Call(777, vec![34, 14], 1, false), Op::Store(vec![12, 28, 12, 12]), Op::Call(201, vec![36, 35], 1, false), Op::Store(vec![12, 30, 12, 12]), Op::Call(639, vec![38, 23, 12], 1, false), Op::Const(G::from_u64(3)), Op::Store(vec![40, 37, 39, 12]), Op::Call(640, vec![41, 21], 1, false), Op::Add(8, 25), Op::Call(672, vec![0, 11, 2, 3, 4, 5, 6, 7, 43], 1, false), Op::Store(vec![12, 42, 44])], ctrl: Ctrl::Return(1, vec![45]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 24, lookups: 20 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_673() -> 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(306, vec![4, 1, 2], 1, false), Op::Call(673, 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_674() -> 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(674, 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_675() -> 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(647, 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(637, 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_676() -> Function { - Function { body: Block { ops: vec![Op::Call(677, vec![0, 1, 2, 3], 2, false)], ctrl: Ctrl::Return(0, vec![4, 5]) }, layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 3, lookups: 2 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_677() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![4, 4, 4]), Op::Call(359, vec![0, 1, 5], 1, false), Op::Load(4, 6)], ctrl: Ctrl::Match(7, [(G::from_u64(5), Block { ops: vec![Op::Call(677, vec![0, 9, 2, 3], 2, false)], ctrl: Ctrl::Return(0, vec![11, 12]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(128, vec![6], 2, false), Op::Load(4, 11)], ctrl: Ctrl::Match(13, [(G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(678, vec![2, 14, 12, 3, 17], 2, false)], ctrl: Ctrl::Return(1, vec![18, 19]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Return(2, vec![17, 17]) }))) }))) }, layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 16, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_678() -> 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(679, 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(678, 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_679() -> 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(306, vec![4, 2, 9], 1, false), Op::Call(621, vec![10, 7], 1, false)], ctrl: Ctrl::Match(11, [(G::from_u64(1), Block { ops: vec![Op::Call(679, 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_680() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(8, [(G::from_u64(5), Block { ops: vec![Op::Add(7, 6), Op::Call(676, vec![0, 9, 2, 12], 2, false), Op::Const(G::from_u64(0)), Op::Store(vec![15, 9, 3])], ctrl: Ctrl::Match(13, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![17, 6, 4]), Op::Store(vec![17, 14, 5]), Op::Const(G::from_u64(1)), Op::Add(6, 20), Op::Call(680, vec![0, 10, 2, 16, 18, 19, 21, 7], 4, false)], ctrl: Ctrl::Return(0, vec![22, 23, 24, 25]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(6, 17), Op::Call(680, vec![0, 10, 2, 16, 4, 5, 18, 7], 4, false)], ctrl: Ctrl::Return(1, vec![19, 20, 21, 22]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(764, vec![3], 1, false), Op::Call(764, vec![4], 1, false), Op::Call(764, vec![5], 1, false)], ctrl: Ctrl::Return(2, vec![12, 13, 14, 1]) }))) }, layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 14, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_681() -> Function { - Function { body: Block { ops: vec![Op::Load(6, 1)], ctrl: Ctrl::Match(5, [(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::Call(234, vec![6], 1, false), Op::Load(12, 11)], ctrl: Ctrl::Match(12, [(G::from_u64(5), Block { ops: vec![Op::Call(645, vec![0, 6, 14, 15, 16, 9, 2, 3, 7, 8], 1, false), Op::Const(G::from_u64(0)), Op::Call(306, vec![24, 4, 25], 1, false), Op::Const(G::from_u64(1)), Op::Add(4, 27), Op::Call(681, vec![0, 10, 2, 3, 28], 1, false), Op::Store(vec![25, 26, 29])], ctrl: Ctrl::Return(1, vec![30]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(681, vec![0, 10, 2, 3, 4], 1, false)], ctrl: Ctrl::Return(2, vec![24]) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 24, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_682() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(1, [(G::from_u64(7), Block { ops: vec![Op::Call(613, vec![3, 4, 6, 7, 5], 1, false), Op::Call(234, vec![14], 1, false), Op::Load(12, 15)], ctrl: Ctrl::Match(16, [(G::from_u64(5), Block { ops: vec![Op::Call(611, vec![11], 1, false), Op::Call(611, vec![23], 1, false), Op::Mul(28, 29), Op::Const(G::from_u64(1)), Op::Call(2, vec![11, 23], 1, false), Op::Sub(31, 32), Op::Mul(30, 33), Op::Call(778, vec![8], 1, false), Op::AssertEq(vec![35], vec![21], Some("recursor rule count differs from the inductive's ctor count".into())), Op::Add(4, 6), Op::Add(36, 7), Op::Add(37, 5), Op::Add(38, 31), Op::Call(576, vec![3, 39], 1, false), Op::Call(685, vec![8, 37, 2], 0, false)], ctrl: Ctrl::MatchContinue(34, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Yield(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::AssertEq(vec![4], vec![19], Some("recursor parameter count differs from its inductive's".into())), Op::AssertEq(vec![5], vec![20], Some("recursor index count differs from its inductive's".into())), Op::Add(19, 20), Op::Call(683, vec![3, 4, 6, 7, 5, 41], 0, false)], ctrl: Ctrl::Yield(1, vec![]) })), 0, 1, 1, Box::new(Block { ops: vec![Op::Call(609, vec![0, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 14], 1, false), Op::AssertEq(vec![9], vec![41], Some("recursor k_flag disagrees with its inductive's K eligibility".into())), Op::Call(601, vec![0, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], 0, false), Op::Call(651, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 14], 0, false)], ctrl: Ctrl::Return(2, vec![]) })) })].into_iter().collect(), None) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 14, selectors: 3, auxiliaries: 24, lookups: 14 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_683() -> Function { - Function { body: Block { ops: vec![Op::Add(1, 2), Op::Add(6, 3), Op::Add(7, 4), Op::Call(576, vec![0, 8], 1, false), Op::Load(4, 9)], ctrl: Ctrl::Match(10, [(G::from_u64(5), Block { ops: vec![Op::Call(128, vec![11], 2, false), Op::Call(775, 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_684() -> 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(684, 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_685() -> 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(574, vec![6, 8, 2], 0, false), Op::Call(685, 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_686() -> 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(686, 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_687() -> 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(687, 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_688() -> Function { - Function { body: Block { ops: vec![Op::Call(228, 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(687, vec![2, 49], 1, false), Op::Const(G::from_u64(0)), Op::Call(687, 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()))], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(1, vec![]) }))) }))) }, layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 52, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_689() -> Function { - Function { body: Block { ops: vec![Op::Call(569, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], 1, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(574, vec![3, 15, 2], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![16, 16, 16]), Op::Call(451, vec![0, 3, 17], 1, false), Op::Call(571, vec![14, 3], 0, 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![Op::Call(506, vec![0, 13], 1, false)], ctrl: Ctrl::Match(19, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::AssertEq(vec![20], vec![21], Some("an axiom that is not one of Lean's standard axioms".into()))], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![]) }))) }))) }), (G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(574, vec![3, 15, 2], 0, false), Op::Call(574, vec![4, 15, 2], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![16, 16, 16]), Op::Call(451, vec![0, 3, 17], 1, false), Op::Call(571, vec![14, 3], 0, false), Op::Call(571, vec![14, 4], 0, false), Op::Call(452, vec![0, 4, 3, 17], 0, false)], ctrl: Ctrl::Return(3, vec![]) }), (G::from_u64(2), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(574, vec![3, 15, 2], 0, false), Op::Call(574, vec![4, 15, 2], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![16, 16, 16]), Op::Call(451, vec![0, 3, 17], 1, false), Op::Store(vec![15, 15, 15]), Op::Call(271, vec![18, 19], 1, false), Op::AssertEq(vec![20], vec![16], Some("theorem's type is not a Prop".into())), Op::Call(571, vec![14, 3], 0, false), Op::Call(571, vec![14, 4], 0, false), Op::Call(452, vec![0, 4, 3, 17], 0, false)], ctrl: Ctrl::Return(4, vec![]) }), (G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(574, vec![3, 15, 2], 0, false), Op::Call(574, vec![4, 15, 2], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![16, 16, 16]), Op::Call(451, vec![0, 3, 17], 1, false), Op::Call(571, vec![14, 3], 0, false), Op::Call(571, vec![14, 4], 0, false), Op::Call(452, vec![0, 4, 3, 17], 0, false)], ctrl: Ctrl::Return(5, vec![]) }), (G::from_u64(4), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(574, vec![3, 15, 2], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![16, 16, 16]), Op::Call(451, vec![0, 3, 17], 1, false), Op::Call(571, vec![14, 3], 0, false), Op::Call(575, vec![0, 13, 4], 0, false)], ctrl: Ctrl::Return(6, vec![]) }), (G::from_u64(5), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(574, vec![3, 15, 2], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![16, 16, 16]), Op::Call(451, vec![0, 3, 17], 1, false), Op::Call(571, vec![14, 3], 0, false), Op::Call(688, vec![8], 0, false), Op::Call(599, vec![0, 3, 4, 5, 6, 2, 8, 9, 7], 0, false), Op::Call(602, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], 0, false)], ctrl: Ctrl::Return(7, vec![]) }), (G::from_u64(6), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(574, vec![3, 15, 2], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![16, 16, 16]), Op::Call(451, vec![0, 3, 17], 1, false), Op::Call(571, vec![14, 3], 0, false), Op::Call(236, vec![4, 5], 1, false), Op::Load(12, 19)], ctrl: Ctrl::Match(20, [(G::from_u64(5), Block { ops: vec![Op::AssertEq(vec![7], vec![23], Some("ctor parameter count differs from its inductive's".into())), Op::Call(582, vec![0, 22, 3, 23], 0, false), Op::Call(580, vec![3, 7, 24, 8, 21, 4, 5], 0, false), Op::Add(23, 24), Op::Const(G::from_u64(1)), Op::Store(vec![33, 33, 33]), Op::Call(583, vec![0, 22, 32, 34], 1, false), Op::Call(586, vec![0, 3, 7, 35], 0, false)], ctrl: Ctrl::Match(26, [(G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![36, 36, 36]), Op::Call(598, vec![0, 3, 7, 4, 37], 0, false)], ctrl: Ctrl::Return(8, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(9, vec![]) }))) })].into_iter().collect(), None) }), (G::from_u64(7), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(574, vec![3, 15, 2], 0, false), Op::Const(G::from_u64(1)), Op::Store(vec![16, 16, 16]), Op::Call(451, vec![0, 3, 17], 1, false), Op::Call(571, vec![14, 3], 0, false), Op::Call(688, vec![11], 0, false), Op::Call(682, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], 0, false)], ctrl: Ctrl::Return(10, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 14, selectors: 11, auxiliaries: 20, lookups: 15 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_690() -> Function { - Function { body: Block { ops: vec![Op::Call(234, vec![1], 1, false), Op::Load(12, 2), Op::Call(689, vec![0, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 1], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 14, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_691() -> 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(18, 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(18, vec![2, 3, 4, 5, 6, 7, 8, 9], 1, false), Op::Call(691, 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(691, vec![2], 1, false), Op::Call(691, vec![3], 1, false), Op::Call(765, vec![19, 20], 1, false)], ctrl: Ctrl::Return(2, vec![21]) }), (G::from_u64(8), Block { ops: vec![Op::Call(691, vec![5], 1, false), Op::Call(691, vec![6], 1, false), Op::Call(765, vec![19, 20], 1, false)], ctrl: Ctrl::Return(3, vec![21]) }), (G::from_u64(9), Block { ops: vec![Op::Call(691, vec![7], 1, false), Op::Call(691, vec![8], 1, false), Op::Call(765, vec![19, 20], 1, false)], ctrl: Ctrl::Return(4, vec![21]) }), (G::from_u64(10), Block { ops: vec![Op::Call(691, vec![7], 1, false), Op::Call(691, vec![8], 1, false), Op::Call(691, vec![9], 1, false), Op::Call(765, vec![20, 21], 1, false), Op::Call(765, 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_692() -> 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(691, vec![2], 1, false), Op::Call(692, vec![3], 1, false), Op::Call(765, 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_693() -> 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(691, vec![10], 1, false), Op::Call(693, vec![11], 1, false), Op::Call(765, 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_694() -> 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(691, vec![35], 1, false), Op::Call(694, vec![36], 1, false), Op::Call(765, 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_695() -> 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(691, vec![13], 1, false), Op::Call(691, vec![14], 1, false), Op::Call(765, vec![48, 49], 1, false), Op::Call(695, vec![47], 1, false), Op::Call(765, 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(691, vec![28], 1, false), Op::Call(694, vec![29], 1, false), Op::Call(765, vec![48, 49], 1, false), Op::Call(695, vec![47], 1, false), Op::Call(765, 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(691, vec![45], 1, false), Op::Call(693, vec![46], 1, false), Op::Call(765, vec![48, 49], 1, false), Op::Call(695, vec![47], 1, false), Op::Call(765, 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_696() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(692, 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(691, vec![11], 1, false), Op::Call(691, vec![12], 1, false), Op::Call(765, vec![49, 50], 1, false), Op::Call(765, 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(691, vec![43], 1, false), Op::Call(693, vec![44], 1, false), Op::Call(765, vec![49, 50], 1, false), Op::Call(765, 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(691, vec![10], 1, false), Op::Call(765, 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(691, vec![10], 1, false), Op::Call(765, vec![48, 49], 1, false)], ctrl: Ctrl::Return(3, vec![50]) }))) }), (G::from_u64(8), Block { ops: vec![Op::Call(695, vec![1], 1, false), Op::Call(765, 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_697() -> 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(697, 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_698() -> Function { - Function { body: Block { ops: vec![Op::Call(228, vec![1], 48, false)], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(2, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(700, vec![0, 1, 3, 3, 50], 0, false)], ctrl: Ctrl::Yield(0, vec![]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(690, vec![0, 1], 0, false), Op::Call(698, vec![0, 11], 0, false)], ctrl: Ctrl::Yield(1, vec![]) }))) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(690, vec![0, 1], 0, false), Op::Call(698, vec![0, 11], 0, false)], ctrl: Ctrl::Yield(2, vec![]) }))) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(690, vec![0, 1], 0, false), Op::Call(698, vec![0, 19], 0, false)], ctrl: Ctrl::Yield(3, vec![]) }))) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(690, vec![0, 1], 0, false), Op::Call(698, vec![0, 11], 0, false)], ctrl: Ctrl::Yield(4, vec![]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(690, vec![0, 1], 0, false)], ctrl: Ctrl::Yield(5, vec![]) })), 0, 5, 2, Box::new(Block { ops: vec![Op::Call(696, 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, 46, 47, 48, 49], 1, false), Op::Const(G::from_u64(0)), Op::Call(699, vec![0, 48, 50, 51], 0, false)], ctrl: Ctrl::Return(6, vec![]) })) }))) }, layout: FunctionLayout { input_size: 2, selectors: 7, auxiliaries: 55, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_699() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 1)], 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(697, vec![2, 3], 1, false)], ctrl: Ctrl::MatchContinue(7, [(G::from_u64(1), Block { ops: vec![Op::Call(508, vec![0, 5], 0, false), Op::Call(487, vec![0, 5], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Call(486, vec![0, 5], 1, false), Op::Call(698, vec![9, 5], 0, false)], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(3, vec![]) })), 0, 2, 4, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(3, 8), Op::Call(699, vec![0, 6, 2, 9], 0, false)], ctrl: Ctrl::Return(4, vec![]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 7, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_700() -> Function { - Function { body: Block { ops: vec![Op::Load(47, 3)], ctrl: Ctrl::Match(5, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(701, vec![0, 1, 2, 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, 4], 0, false), Op::Const(G::from_u64(1)), Op::Add(4, 52), Op::Call(700, vec![0, 1, 2, 51, 53], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 48, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_701() -> Function { - Function { body: Block { ops: vec![Op::Call(241, vec![2, 1, 48], 1, false), Op::Call(234, vec![49], 1, false), Op::Load(12, 50), Op::Call(689, vec![0, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 49], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 49, selectors: 1, auxiliaries: 15, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_702() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![1, 1, 1]), Op::Call(56, vec![0, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![4, 4, 3]), Op::Call(23, 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_703() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![2, 2, 2]), Op::Call(56, vec![1, 3], 1, false), Op::Call(56, vec![0, 4], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![6, 2, 5]), Op::Call(23, 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_704() -> Function { - Function { body: Block { ops: vec![Op::Call(83, vec![0], 2, false)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(102, vec![2], 2, false), Op::Call(702, 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(704, vec![2], 3, false), Op::Call(704, vec![5], 3, false), Op::Call(703, vec![3, 6], 1, false), Op::Call(765, 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_705() -> 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], 2, false), Op::Const(G::from_u64(226)), Op::AssertEq(vec![37], vec![39], Some("assumption tree: wrong TagN header".into())), Op::Call(704, vec![38], 3, false), Op::Load(3, 42), Op::AssertEq(vec![43, 44, 45], vec![33, 33, 33], Some("assumption tree: trailing bytes after tree body".into())), Op::Load(32, 40), Op::AssertEq(vec![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], 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![41]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 76, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_706() -> 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(779, vec![8, 10, 1, 2, 3, 4, 5, 6], 6, false), Op::Call(706, 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_707() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(763, 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_708() -> Function { - Function { body: Block { ops: vec![Op::Call(707, vec![1, 8, 9, 10, 11, 12, 13], 1, false)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(2)), Op::Sub(14, 16), Op::EqZero(17), Op::Const(G::from_u64(0)), Op::AssertEq(vec![18], vec![19], Some("Check: target is in the assumption set".into()))], ctrl: Ctrl::Return(0, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(14, [(G::from_u64(1), Block { ops: vec![Op::Call(707, vec![1, 2, 3, 4, 5, 6, 7], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![16], vec![17], Some("CheckEnv: walk reached a constant outside the owned set".into()))], ctrl: Ctrl::Yield(1, vec![17]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0))], ctrl: Ctrl::Yield(2, vec![16]) })), 1, 1, 1, Box::new(Block { ops: vec![Op::Call(228, vec![1], 48, false)], ctrl: Ctrl::Match(17, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(17, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(700, vec![0, 1, 18, 18, 65], 0, false)], ctrl: Ctrl::Yield(3, vec![]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(18, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(690, vec![0, 1], 0, false), Op::Call(708, vec![0, 26, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 16], 0, false)], ctrl: Ctrl::Yield(4, vec![]) }))) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(18, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(690, vec![0, 1], 0, false), Op::Call(708, vec![0, 26, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 16], 0, false)], ctrl: Ctrl::Yield(5, vec![]) }))) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Match(18, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(690, vec![0, 1], 0, false), Op::Call(708, vec![0, 34, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 16], 0, false)], ctrl: Ctrl::Yield(6, vec![]) }))) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(18, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(690, vec![0, 1], 0, false), Op::Call(708, vec![0, 26, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 16], 0, false)], ctrl: Ctrl::Yield(7, vec![]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(690, vec![0, 1], 0, false)], ctrl: Ctrl::Yield(8, vec![]) })), 0, 5, 2, Box::new(Block { ops: vec![Op::Call(696, 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, 63, 64], 1, false), Op::Const(G::from_u64(0)), Op::Call(709, vec![0, 63, 65, 66, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 16], 0, false)], ctrl: Ctrl::Return(9, vec![]) })) }))) })) }))) }, layout: FunctionLayout { input_size: 15, selectors: 10, auxiliaries: 59, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_709() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(17, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(697, vec![2, 3], 1, false)], ctrl: Ctrl::MatchContinue(20, [(G::from_u64(1), Block { ops: vec![Op::Call(508, vec![0, 18], 0, false), Op::Call(487, vec![0, 18], 1, false)], ctrl: Ctrl::Match(21, [(G::from_u64(0), Block { ops: vec![Op::Call(486, vec![0, 18], 1, false), Op::Call(708, vec![22, 18, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], 0, false)], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(2, vec![]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(3, vec![]) })), 0, 2, 4, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(3, 21), Op::Call(709, vec![0, 19, 2, 22, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], 0, false)], ctrl: Ctrl::Return(4, vec![]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 17, selectors: 5, auxiliaries: 7, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_710() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 1)], ctrl: Ctrl::Match(14, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(707, vec![15, 8, 9, 10, 11, 12, 13], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![17], vec![18], Some("CheckEnv: owned constant is in the assumption set".into())), Op::Const(G::from_u64(1)), Op::Call(708, vec![0, 15, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 19], 0, false), Op::Call(710, vec![0, 16, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 14, selectors: 2, auxiliaries: 5, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_711() -> Function { - Function { body: Block { ops: vec![Op::Call(705, vec![1], 1, false), Op::Load(3, 4)], ctrl: Ctrl::MatchContinue(5, [(G::from_u64(1), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::AssertEq(vec![8], vec![9], Some("CheckEnv: owned tree has no leaves".into()))], ctrl: Ctrl::Yield(0, vec![]) }), (G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), None, 0, 0, 0, Box::new(Block { ops: vec![], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![Op::Call(471, vec![0], 6, false)], ctrl: Ctrl::Match(8, [(G::from_u64(1), Block { ops: vec![Op::Call(713, vec![0, 4], 0, false)], ctrl: Ctrl::Return(2, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(712, vec![0, 4], 0, false)], ctrl: Ctrl::Return(3, vec![]) })].into_iter().collect(), None) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(1)), Op::Call(706, vec![4, 8, 8, 8, 8, 8, 8], 6, false), Op::Call(705, vec![3], 1, false), Op::Call(706, vec![15, 8, 8, 8, 8, 8, 8], 6, false), Op::Call(710, vec![0, 4, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21], 0, false)], ctrl: Ctrl::Return(4, vec![]) })].into_iter().collect(), None) })) }, layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 18, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_712() -> 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![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(698, vec![0, 3], 0, false), Op::Call(712, vec![0, 4], 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_713() -> 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![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(473, vec![0], 1, false), Op::Load(32, 5), Op::Call(469, vec![0], 1, false), Op::Load(32, 3), Op::Call(714, vec![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, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70], 0, false), Op::Call(713, vec![0, 4], 0, false)], ctrl: Ctrl::Return(1, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 70, lookups: 8 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_714() -> 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(466, vec![65, 32], 1, false), Op::Store(vec![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]), Op::Call(715, vec![66, 67], 0, false)], ctrl: Ctrl::Return(0, vec![]) }, layout: FunctionLayout { input_size: 65, selectors: 1, auxiliaries: 4, lookups: 5 }, entry: true, constrained: true } -} - -#[inline(never)] -fn expected_function_715() -> Function { - Function { body: Block { ops: vec![Op::Call(228, vec![1], 48, false)], ctrl: Ctrl::Match(2, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::MatchContinue(2, [(G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(700, vec![0, 1, 3, 3, 50], 0, false)], ctrl: Ctrl::Yield(0, vec![]) }), (G::from_u64(7), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(690, vec![0, 1], 0, false), Op::Call(473, vec![0], 1, false), Op::Load(32, 50), Op::Call(469, vec![0], 1, false), Op::Load(32, 11), Op::Call(714, 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, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115], 0, false)], ctrl: Ctrl::Yield(1, vec![]) }))) }), (G::from_u64(6), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(690, vec![0, 1], 0, false), Op::Call(473, vec![0], 1, false), Op::Load(32, 50), Op::Call(469, vec![0], 1, false), Op::Load(32, 11), Op::Call(714, 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, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115], 0, false)], ctrl: Ctrl::Yield(2, vec![]) }))) }), (G::from_u64(4), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(690, vec![0, 1], 0, false), Op::Call(473, vec![0], 1, false), Op::Load(32, 50), Op::Call(469, vec![0], 1, false), Op::Load(32, 19), Op::Call(714, 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, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115], 0, false)], ctrl: Ctrl::Yield(3, vec![]) }))) }), (G::from_u64(5), Block { ops: vec![], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(690, vec![0, 1], 0, false), Op::Call(473, vec![0], 1, false), Op::Load(32, 50), Op::Call(469, vec![0], 1, false), Op::Load(32, 11), Op::Call(714, 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, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115], 0, false)], ctrl: Ctrl::Yield(4, vec![]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(690, vec![0, 1], 0, false)], ctrl: Ctrl::Yield(5, vec![]) })), 0, 66, 6, Box::new(Block { ops: vec![Op::Call(696, 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, 46, 47, 48, 49], 1, false), Op::Const(G::from_u64(0)), Op::Call(716, vec![0, 48, 50, 51], 0, false)], ctrl: Ctrl::Return(6, vec![]) })) }))) }, layout: FunctionLayout { input_size: 2, selectors: 7, auxiliaries: 116, lookups: 10 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_716() -> Function { - Function { body: Block { ops: vec![Op::Load(3, 1)], 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(697, vec![2, 3], 1, false)], ctrl: Ctrl::MatchContinue(7, [(G::from_u64(1), Block { ops: vec![Op::Call(508, vec![0, 5], 0, false), Op::Call(487, vec![0, 5], 1, false)], ctrl: Ctrl::Match(8, [(G::from_u64(0), Block { ops: vec![Op::Call(486, vec![0, 5], 1, false), Op::Sub(9, 0)], ctrl: Ctrl::Match(10, [(G::from_u64(0), Block { ops: vec![Op::Call(473, vec![0], 1, false), Op::Load(32, 11), Op::Call(469, vec![0], 1, false), Op::Load(32, 5), Op::Call(714, vec![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, 73, 74, 75, 76], 0, false)], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(698, vec![9, 5], 0, false)], ctrl: Ctrl::Yield(2, vec![]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(3, vec![]) }))) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Yield(4, vec![]) })), 0, 68, 8, Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(3, 8), Op::Call(716, vec![0, 6, 2, 9], 0, false)], ctrl: Ctrl::Return(5, vec![]) })) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 4, selectors: 6, auxiliaries: 73, lookups: 12 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_717() -> Function { - Function { body: Block { ops: vec![Op::Call(83, 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(102, 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_718() -> Function { - Function { body: Block { ops: vec![Op::Call(102, vec![0], 2, false), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(163)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(119)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(178)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(95)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(149)), Op::Const(G::from_u64(229)), Op::Const(G::from_u64(51)), Op::Const(G::from_u64(160)), Op::Const(G::from_u64(141)), Op::Const(G::from_u64(20)), Op::Const(G::from_u64(252)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(45)), Op::Store(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, 14, 28, 29, 30, 31, 32, 25]), Op::Call(2, vec![1, 33], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![34], vec![35], Some("claim: specification digest is not this circuit's".into())), Op::Call(102, vec![2], 2, false), Op::Call(717, vec![37], 3, false)], ctrl: Ctrl::Return(0, vec![36, 38, 39, 40]) }, layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 10, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_719() -> 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(87, 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_720() -> 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(102, 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_721() -> 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(83, 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_722() -> 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(83, 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_723() -> 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(83, 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_724() -> Function { - Function { body: Block { ops: vec![Op::Call(6, 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(122, vec![0], 18, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(724, 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_725() -> 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(87, vec![1], 9, false), Op::Call(724, 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_726() -> Function { - Function { body: Block { ops: vec![Op::Call(87, vec![0], 9, false), Op::U8BitDecomposition(1), Op::Call(721, vec![10, 9], 3, false), Op::Call(719, vec![11, 20], 10, false), Op::Call(719, vec![12, 30], 10, false), Op::Call(719, vec![13, 40], 10, false), Op::Call(719, vec![14, 50], 10, false), Op::Call(720, 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_727() -> Function { - Function { body: Block { ops: vec![Op::Call(87, vec![0], 9, false), Op::Call(726, 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_728() -> Function { - Function { body: Block { ops: vec![Op::Call(6, 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(727, vec![0], 49, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(728, 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_729() -> 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(87, vec![1], 9, false), Op::Call(728, 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_730() -> Function { - Function { body: Block { ops: vec![Op::Call(83, vec![0], 2, false), Op::Call(87, vec![2], 9, false), Op::U8BitDecomposition(3), Op::U8BitDecomposition(4)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(722, vec![12, 11], 3, false), Op::Call(722, vec![13, 30], 3, false), Op::Call(719, vec![14, 33], 10, false), Op::Call(720, vec![15, 43], 3, false), Op::Call(720, 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(721, vec![12, 11], 3, false), Op::Call(719, vec![13, 30], 10, false), Op::Call(719, vec![14, 40], 10, false), Op::Call(719, vec![15, 50], 10, false), Op::Call(720, vec![16, 60], 3, false), Op::Call(729, 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(721, vec![12, 11], 3, false), Op::Call(721, vec![13, 30], 3, false), Op::Call(719, vec![14, 33], 10, false), Op::Call(719, vec![15, 43], 10, false), Op::Call(719, vec![16, 53], 10, false), Op::Call(719, vec![17, 63], 10, false), Op::Call(719, vec![18, 73], 10, false), Op::Call(720, vec![19, 83], 3, false), Op::Call(725, 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_731() -> Function { - Function { body: Block { ops: vec![Op::Call(87, vec![0], 9, false), Op::Call(730, 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_732() -> Function { - Function { body: Block { ops: vec![Op::Call(6, 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(731, vec![0], 63, false), Op::Call(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(732, 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_733() -> Function { - Function { body: Block { ops: vec![Op::Call(83, vec![0], 2, false), Op::Call(87, vec![2], 9, false), Op::U8BitDecomposition(3), Op::U8BitDecomposition(4)], ctrl: Ctrl::Match(1, [(G::from_u64(0), Block { ops: vec![Op::Call(722, vec![12, 11], 3, false), Op::Call(722, vec![13, 30], 3, false), Op::Call(719, vec![14, 33], 10, false), Op::Call(720, vec![15, 43], 3, false), Op::Call(720, 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(721, vec![12, 11], 3, false), Op::Call(721, vec![13, 30], 3, false), Op::Call(719, vec![14, 33], 10, false), Op::Call(719, vec![15, 43], 10, false), Op::Call(719, vec![16, 53], 10, false), Op::Call(719, vec![17, 63], 10, false), Op::Call(719, vec![18, 73], 10, false), Op::Call(720, vec![19, 83], 3, false), Op::Call(725, 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(721, vec![12, 11], 3, false), Op::Call(719, vec![13, 30], 10, false), Op::Call(720, 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(723, vec![12, 11], 3, false), Op::Call(719, vec![13, 30], 10, false), Op::Call(720, 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(719, vec![12, 11], 10, false), Op::Call(719, vec![13, 37], 10, false), Op::Call(720, 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(719, vec![12, 11], 10, false), Op::Call(720, 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(719, vec![12, 11], 10, false), Op::Call(720, 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(719, vec![12, 11], 10, false), Op::Call(720, 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(87, vec![11], 9, false), Op::Call(732, 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_734() -> Function { - Function { body: Block { ops: vec![Op::Load(18, 0), Op::Const(G::from_u64(1)), Op::Store(vec![19, 19, 19]), Op::Call(38, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20], 1, false), Op::Call(23, 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_735() -> 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_736() -> 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(735, vec![0], 1, false), Op::Call(735, 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_737() -> 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(735, vec![0], 1, false), Op::Call(735, 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_738() -> 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(116, vec![0], 1, false), Op::Call(116, 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_739() -> 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_740() -> 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_741() -> 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_742() -> 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(734, 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_743() -> 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(742, vec![38, 40, 27], 0, false), Op::Call(16, vec![2, 3, 4, 5, 6, 7, 8, 9], 8, false), Op::Call(743, 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_744() -> 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(743, 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_745() -> Function { - Function { body: Block { ops: vec![Op::Call(772, 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(739, vec![49, 9, 10], 0, false), Op::Call(740, vec![50, 51, 52, 53, 54, 55, 56, 57, 11, 12, 13, 14, 15, 16, 17, 18, 19], 0, false), Op::Call(740, vec![58, 59, 60, 61, 62, 63, 64, 65, 20, 21, 22, 23, 24, 25, 26, 27, 28], 0, false), Op::Call(740, vec![66, 67, 68, 69, 70, 71, 72, 73, 29, 30, 31, 32, 33, 34, 35, 36, 37], 0, false), Op::Call(740, vec![74, 75, 76, 77, 78, 79, 80, 81, 38, 39, 40, 41, 42, 43, 44, 45, 46], 0, false), Op::Call(742, 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_746() -> 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(745, 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(746, 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_747() -> 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(746, 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_748() -> 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(736, vec![1, 46, 47], 0, false), Op::Call(737, vec![2, 48, 49], 0, false), Op::Call(740, vec![3, 4, 5, 6, 7, 8, 9, 10, 50, 51, 52, 53, 54, 55, 56, 57, 58], 0, false), Op::Call(742, vec![11, 59, 60], 0, false), Op::Call(742, 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(739, vec![1, 46, 47], 0, false), Op::Call(740, vec![2, 3, 4, 5, 6, 7, 8, 9, 48, 49, 50, 51, 52, 53, 54, 55, 56], 0, false), Op::Call(740, vec![10, 11, 12, 13, 14, 15, 16, 17, 57, 58, 59, 60, 61, 62, 63, 64, 65], 0, false), Op::Call(740, vec![18, 19, 20, 21, 22, 23, 24, 25, 66, 67, 68, 69, 70, 71, 72, 73, 74], 0, false), Op::Call(742, vec![26, 75, 76], 0, false), Op::Call(747, 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(739, vec![1, 46, 47], 0, false), Op::Call(739, vec![2, 48, 49], 0, false), Op::Call(740, vec![3, 4, 5, 6, 7, 8, 9, 10, 50, 51, 52, 53, 54, 55, 56, 57, 58], 0, false), Op::Call(740, vec![11, 12, 13, 14, 15, 16, 17, 18, 59, 60, 61, 62, 63, 64, 65, 66, 67], 0, false), Op::Call(740, vec![19, 20, 21, 22, 23, 24, 25, 26, 68, 69, 70, 71, 72, 73, 74, 75, 76], 0, false), Op::Call(740, vec![27, 28, 29, 30, 31, 32, 33, 34, 77, 78, 79, 80, 81, 82, 83, 84, 85], 0, false), Op::Call(740, vec![35, 36, 37, 38, 39, 40, 41, 42, 86, 87, 88, 89, 90, 91, 92, 93, 94], 0, false), Op::Call(742, vec![43, 95, 96], 0, false), Op::Call(744, 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_749() -> 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(769, vec![0, 3, 4, 5, 6, 7, 8, 9, 10], 45, false), Op::Call(748, 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(749, 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_750() -> Function { - Function { body: Block { ops: vec![Op::Call(228, 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(736, vec![56, 2, 3], 0, false), Op::Call(737, vec![57, 4, 5], 0, false), Op::Call(740, vec![58, 59, 60, 61, 62, 63, 64, 65, 6, 7, 8, 9, 10, 11, 12, 13, 14], 0, false), Op::Call(742, vec![66, 15, 16], 0, false), Op::Call(742, 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(739, vec![56, 2, 3], 0, false), Op::Call(739, vec![57, 4, 5], 0, false), Op::Call(740, vec![58, 59, 60, 61, 62, 63, 64, 65, 6, 7, 8, 9, 10, 11, 12, 13, 14], 0, false), Op::Call(740, vec![66, 67, 68, 69, 70, 71, 72, 73, 15, 16, 17, 18, 19, 20, 21, 22, 23], 0, false), Op::Call(740, vec![74, 75, 76, 77, 78, 79, 80, 81, 24, 25, 26, 27, 28, 29, 30, 31, 32], 0, false), Op::Call(740, vec![82, 83, 84, 85, 86, 87, 88, 89, 33, 34, 35, 36, 37, 38, 39, 40, 41], 0, false), Op::Call(740, vec![90, 91, 92, 93, 94, 95, 96, 97, 42, 43, 44, 45, 46, 47, 48, 49, 50], 0, false), Op::Call(742, vec![98, 51, 52], 0, false), Op::Call(744, 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(739, vec![56, 2, 3], 0, false), Op::Call(740, vec![57, 58, 59, 60, 61, 62, 63, 64, 4, 5, 6, 7, 8, 9, 10, 11, 12], 0, false), Op::Call(742, 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(738, vec![56, 2, 3], 0, false), Op::Call(740, vec![57, 58, 59, 60, 61, 62, 63, 64, 4, 5, 6, 7, 8, 9, 10, 11, 12], 0, false), Op::Call(742, 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(740, vec![56, 57, 58, 59, 60, 61, 62, 63, 2, 3, 4, 5, 6, 7, 8, 9, 10], 0, false), Op::Call(740, vec![64, 65, 66, 67, 68, 69, 70, 71, 11, 12, 13, 14, 15, 16, 17, 18, 19], 0, false), Op::Call(741, 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(740, vec![56, 57, 58, 59, 60, 61, 62, 63, 2, 3, 4, 5, 6, 7, 8, 9, 10], 0, false), Op::Call(741, 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(740, vec![56, 57, 58, 59, 60, 61, 62, 63, 2, 3, 4, 5, 6, 7, 8, 9, 10], 0, false), Op::Call(741, 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(740, vec![56, 57, 58, 59, 60, 61, 62, 63, 2, 3, 4, 5, 6, 7, 8, 9, 10], 0, false), Op::Call(741, 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(749, 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_751() -> Function { - Function { body: Block { ops: vec![Op::Call(705, vec![0], 1, false), Op::Call(358, 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_752() -> 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(26, vec![11, 44, 8, 8, 45, 46, 47], 1, false), Op::Call(25, vec![48], 32, false), Op::Const(G::from_u64(256)), Op::Mul(81, 50), Op::Add(49, 82), Op::Const(G::from_u64(65536)), Op::Mul(84, 51), Op::Add(83, 85), Op::Const(G::from_u64(16777216)), Op::Mul(87, 52), Op::Add(86, 88), Op::Mul(81, 54), Op::Add(53, 90), Op::Mul(84, 55), Op::Add(91, 92), Op::Mul(87, 56), Op::Add(93, 94), Op::Mul(81, 58), Op::Add(57, 96), Op::Mul(84, 59), Op::Add(97, 98), Op::Mul(87, 60), Op::Add(99, 100), Op::Mul(81, 62), Op::Add(61, 102), Op::Mul(84, 63), Op::Add(103, 104), Op::Mul(87, 64), Op::Add(105, 106), Op::Mul(81, 66), Op::Add(65, 108), Op::Mul(84, 67), Op::Add(109, 110), Op::Mul(87, 68), Op::Add(111, 112), Op::Mul(81, 70), Op::Add(69, 114), Op::Mul(84, 71), Op::Add(115, 116), Op::Mul(87, 72), Op::Add(117, 118), Op::Mul(81, 74), Op::Add(73, 120), Op::Mul(84, 75), Op::Add(121, 122), Op::Mul(87, 76), Op::Add(123, 124), Op::Mul(81, 78), Op::Add(77, 126), Op::Mul(84, 79), Op::Add(127, 128), Op::Mul(87, 80), Op::Add(129, 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(85, vec![11], 10, false), Op::AssertEq(vec![132], vec![29], Some("claim: wrong TagN 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: TagN size exceeds a single byte".into())), Op::Call(83, vec![141], 2, false), Op::Const(G::from_u64(4)), Op::AssertEq(vec![148], vec![150], Some("claim: unsupported object format".into())), Op::Call(83, vec![149], 2, false)], ctrl: Ctrl::Match(133, [(G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3)), Op::AssertEq(vec![151], vec![153], Some("claim: wrong validator identity".into())), Op::Call(718, vec![152], 4, false), Op::Call(468, vec![154, 153, 155, 156], 1, false), Op::Call(102, vec![157], 2, false), Op::Call(102, vec![160], 2, false), Op::Call(717, vec![162], 3, false), Op::Load(3, 165), Op::Const(G::from_u64(1)), Op::AssertEq(vec![166, 167, 168], vec![169, 169, 169], Some("claim: trailing bytes".into())), Op::Call(757, vec![158, 159, 161, 163, 164], 0, false)], ctrl: Ctrl::Return(0, vec![]) }), (G::from_u64(4), Block { ops: vec![Op::Call(718, vec![152], 4, false), Op::Call(468, vec![153, 151, 154, 155], 1, false), Op::Call(102, vec![156], 2, false), Op::Call(717, vec![159], 3, false), Op::Load(3, 162), Op::Const(G::from_u64(1)), Op::AssertEq(vec![163, 164, 165], vec![166, 166, 166], Some("claim: trailing bytes".into()))], ctrl: Ctrl::Match(160, [(G::from_u64(1), Block { ops: vec![Op::Call(698, vec![157, 158], 0, false)], ctrl: Ctrl::Return(1, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(705, vec![161], 1, false), Op::Const(G::from_u64(1)), Op::Call(706, vec![167, 168, 168, 168, 168, 168, 168], 6, false), Op::Const(G::from_u64(2)), Op::Call(708, vec![157, 158, 168, 168, 168, 168, 168, 168, 169, 170, 171, 172, 173, 174, 175], 0, false)], ctrl: Ctrl::Return(2, vec![]) })].into_iter().collect(), None) }), (G::from_u64(5), Block { ops: vec![Op::Call(718, vec![152], 4, false), Op::Call(468, vec![153, 151, 154, 155], 1, false), Op::Call(102, vec![156], 2, false), Op::Call(717, vec![159], 3, false), Op::Load(3, 162), Op::Const(G::from_u64(1)), Op::AssertEq(vec![163, 164, 165], vec![166, 166, 166], Some("claim: trailing bytes".into())), Op::Call(711, vec![157, 158, 160, 161], 0, false)], ctrl: Ctrl::Return(3, 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(102, vec![152], 2, false), Op::Call(733, 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(750, 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(4, 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(102, vec![152], 2, false), Op::Call(102, 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(751, vec![154, 156], 0, false)], ctrl: Ctrl::Return(5, 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(6, vec![]) }), (G::from_u64(10), Block { ops: vec![Op::Const(G::from_u64(3)), Op::AssertEq(vec![151], vec![153], Some("claim: wrong validator identity".into())), Op::Call(102, vec![152], 2, false), Op::Const(G::from_u64(109)), Op::Const(G::from_u64(2)), Op::Const(G::from_u64(21)), Op::Const(G::from_u64(62)), Op::Const(G::from_u64(163)), Op::Const(G::from_u64(17)), Op::Const(G::from_u64(243)), Op::Const(G::from_u64(239)), Op::Const(G::from_u64(209)), Op::Const(G::from_u64(119)), Op::Const(G::from_u64(140)), Op::Const(G::from_u64(73)), Op::Const(G::from_u64(178)), Op::Const(G::from_u64(238)), Op::Const(G::from_u64(95)), Op::Const(G::from_u64(49)), Op::Const(G::from_u64(231)), Op::Const(G::from_u64(154)), Op::Const(G::from_u64(11)), Op::Const(G::from_u64(174)), Op::Const(G::from_u64(149)), Op::Const(G::from_u64(229)), Op::Const(G::from_u64(51)), Op::Const(G::from_u64(160)), Op::Const(G::from_u64(141)), Op::Const(G::from_u64(20)), Op::Const(G::from_u64(252)), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(87)), Op::Const(G::from_u64(45)), Op::Store(vec![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, 167, 181, 182, 183, 184, 185, 178]), Op::Call(2, vec![154, 186], 1, false), Op::Const(G::from_u64(1)), Op::AssertEq(vec![187], vec![188], Some("claim: specification digest is not this circuit's".into())), Op::Call(102, vec![155], 2, false), Op::Load(3, 190), Op::AssertEq(vec![191, 192, 193], vec![188, 188, 188], Some("claim: trailing bytes".into())), Op::Call(488, vec![189], 0, false)], ctrl: Ctrl::Return(7, vec![]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 8, selectors: 8, auxiliaries: 115, lookups: 19 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_753() -> Function { - Function { body: Block { ops: vec![Op::Call(359, vec![0, 1, 2], 1, false), Op::Load(4, 3)], ctrl: Ctrl::Match(4, [(G::from_u64(4), Block { ops: vec![Op::Call(753, vec![0, 5, 2], 1, false), Op::Const(G::from_u64(4)), Op::Const(G::from_u64(0)), Op::Store(vec![10, 5, 2]), Op::Call(753, vec![0, 6, 11], 1, false), Op::Store(vec![9, 8, 12, 10])], ctrl: Ctrl::Return(0, vec![13]) }), (G::from_u64(5), Block { ops: vec![Op::Call(753, vec![0, 5, 2], 1, false), Op::Const(G::from_u64(5)), Op::Const(G::from_u64(0)), Op::Store(vec![10, 5, 2]), Op::Call(753, vec![0, 6, 11], 1, false), Op::Store(vec![9, 8, 12, 10])], ctrl: Ctrl::Return(1, vec![13]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(754, vec![0, 3, 2], 1, false)], ctrl: Ctrl::Return(2, vec![8]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 10, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_754() -> Function { - Function { body: Block { ops: vec![Op::Load(4, 1)], ctrl: Ctrl::Match(3, [(G::from_u64(3), Block { ops: vec![Op::Const(G::from_u64(3)), Op::Call(754, vec![0, 4, 2], 1, false), Op::Call(753, vec![0, 5, 2], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![7, 8, 9, 10])], ctrl: Ctrl::Return(0, vec![11]) }), (G::from_u64(8), Block { ops: vec![Op::Const(G::from_u64(8)), Op::Call(753, vec![0, 6, 2], 1, false), Op::Store(vec![7, 4, 5, 8])], ctrl: Ctrl::Return(1, vec![9]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Return(2, vec![1]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_755() -> Function { - Function { body: Block { ops: vec![Op::Call(234, vec![0], 1, false), Op::Load(12, 1), Op::Call(569, vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![14], vec![15], Some("Eval: unsafe or partial input".into()))], ctrl: Ctrl::Match(2, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![3, 4, 5]) }), (G::from_u64(2), Block { ops: vec![], ctrl: Ctrl::Return(1, vec![3, 4, 5]) }), (G::from_u64(3), Block { ops: vec![], ctrl: Ctrl::Return(2, vec![3, 4, 5]) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 15, lookups: 4 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_756() -> Function { - Function { body: Block { ops: vec![Op::Call(228, vec![0], 48, false)], ctrl: Ctrl::Match(3, [].into_iter().collect(), Some(Box::new(Block { ops: vec![], ctrl: Ctrl::Match(3, [(G::from_u64(0), Block { ops: vec![], ctrl: Ctrl::Match(4, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(0)), Op::AssertEq(vec![4], vec![51], Some("Eval: output must be a definition".into())), Op::Const(G::from_u64(1)), Op::AssertEq(vec![5], vec![52], Some("Eval: unsafe or partial output".into())), Op::Call(18, vec![6, 7, 8, 9, 10, 11, 12, 13], 1, false), Op::AssertEq(vec![53], vec![1], Some("Eval: universe parameter count mismatch".into())), Op::Store(vec![52, 52, 52]), Op::Call(218, vec![14, 48, 49, 54, 50], 1, false), Op::AssertEq(vec![55], vec![2], Some("Eval: output type does not match input".into())), Op::Call(218, vec![15, 48, 49, 54, 50], 1, false)], ctrl: Ctrl::Return(0, vec![56]) }))) })].into_iter().collect(), None) }))) }, layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 53, lookups: 6 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_757() -> Function { - Function { body: Block { ops: vec![Op::Call(690, vec![0, 1], 0, false)], ctrl: Ctrl::MatchContinue(3, [(G::from_u64(1), Block { ops: vec![Op::Call(698, vec![0, 1], 0, false)], ctrl: Ctrl::Yield(0, vec![]) }), (G::from_u64(0), Block { ops: vec![Op::Call(705, vec![4], 1, false), Op::Const(G::from_u64(1)), Op::Call(706, vec![5, 6, 6, 6, 6, 6, 6], 6, false), Op::Call(707, vec![1, 7, 8, 9, 10, 11, 12], 1, false), Op::Const(G::from_u64(0)), Op::AssertEq(vec![13], vec![14], Some("Eval: input is an assumption".into())), Op::Call(708, vec![0, 1, 6, 6, 6, 6, 6, 6, 7, 8, 9, 10, 11, 12, 14], 0, false)], ctrl: Ctrl::Yield(1, vec![]) })].into_iter().collect(), None, 0, 8, 4, Box::new(Block { ops: vec![Op::Call(755, vec![1], 3, false), Op::Call(756, vec![2, 5, 6], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![9, 9, 9]), Op::Call(753, vec![0, 7, 10], 1, false), Op::AssertEq(vec![11], vec![8], Some("Eval: result does not match output".into()))], ctrl: Ctrl::Return(2, vec![]) })) }, layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 15, lookups: 10 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_758() -> Function { - Function { body: Block { ops: vec![Op::Call(752, 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_759() -> Function { - Function { body: Block { ops: vec![Op::Call(777, 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_760() -> 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(760, 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_761() -> 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(761, vec![10], 8, false), Op::Call(16, 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_762() -> 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(762, vec![3], 8, false), Op::Call(16, 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_763() -> 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(763, 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(763, 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_764() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(1)), Op::Store(vec![1, 1, 1]), Op::Call(781, 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_765() -> 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(765, 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_766() -> 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(766, vec![36], 8, false), Op::Call(16, 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_767() -> 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(767, 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_768() -> Function { - Function { body: Block { ops: vec![Op::Call(777, 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_769() -> Function { - Function { body: Block { ops: vec![Op::Load(47, 0)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Call(6, 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(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(769, 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_770() -> 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(770, vec![47], 8, false), Op::Call(16, 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_771() -> 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(771, vec![11], 8, false), Op::Call(16, 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_772() -> Function { - Function { body: Block { ops: vec![Op::Load(36, 0)], ctrl: Ctrl::Match(9, [(G::from_u64(0), Block { ops: vec![Op::Call(6, 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(17, vec![1, 2, 3, 4, 5, 6, 7, 8], 8, false), Op::Call(772, 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_773() -> 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_774() -> 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(774, 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_775() -> 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(775, 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_776() -> 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(776, 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_777() -> 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(777, 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_778() -> 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(778, 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_779() -> Function { - Function { body: Block { ops: vec![Op::Call(782, 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_780() -> 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(780, 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_781() -> 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(781, 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_782() -> 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(782, vec![0, 1, 8, 9, 10, 11, 12, 13], 6, false), Op::Call(783, 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(782, vec![0, 1, 14, 15, 16, 17, 18, 19], 6, false), Op::Call(783, 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_783() -> Function { - Function { body: Block { ops: vec![], ctrl: Ctrl::Match(0, [(G::from_u64(1), Block { ops: vec![Op::Call(784, 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_784() -> 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()], 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, 290, 292, 425], layout: FunctionLayout { input_size: 2, selectors: 9, auxiliaries: 22, lookups: 7 } }, Circuit { members: vec![1, 113, 222, 223, 231, 234, 688, 603, 610, 619, 659], layout: FunctionLayout { input_size: 8, selectors: 39, auxiliaries: 72, lookups: 12 } }, 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: 3, auxiliaries: 8, lookups: 5 } }, Circuit { members: vec![6, 229], layout: FunctionLayout { input_size: 13, selectors: 11, auxiliaries: 2, lookups: 1 } }, Circuit { members: vec![14, 16, 116, 150, 220, 221], layout: FunctionLayout { input_size: 16, selectors: 25, auxiliaries: 3, lookups: 3 } }, Circuit { members: vec![15, 689], layout: FunctionLayout { input_size: 16, selectors: 12, auxiliaries: 20, lookups: 16 } }, Circuit { members: vec![17, 18], layout: FunctionLayout { input_size: 8, selectors: 10, auxiliaries: 2, lookups: 1 } }, Circuit { members: vec![22, 75, 99, 100, 213, 378, 593, 654, 663, 671, 678, 693], layout: FunctionLayout { input_size: 33, selectors: 35, auxiliaries: 38, lookups: 8 } }, Circuit { members: vec![23, 118, 123, 408, 687, 611, 612, 694], layout: FunctionLayout { input_size: 2, selectors: 26, auxiliaries: 51, lookups: 8 } }, Circuit { members: vec![24, 236, 237, 239, 241, 627, 752, 462, 463, 464], layout: FunctionLayout { input_size: 34, selectors: 32, auxiliaries: 142, lookups: 22 } }, Circuit { members: vec![25, 32, 127], layout: FunctionLayout { input_size: 6, selectors: 17, auxiliaries: 143, lookups: 9 } }, Circuit { members: vec![26], layout: FunctionLayout { input_size: 7, selectors: 9, auxiliaries: 22, lookups: 10 } }, Circuit { members: vec![30], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 193, lookups: 65 } }, Circuit { members: vec![31], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 3 } }, Circuit { members: vec![33], layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 153, lookups: 13 } }, Circuit { members: vec![37], layout: FunctionLayout { input_size: 129, selectors: 2, auxiliaries: 402, lookups: 194 } }, Circuit { members: vec![38, 238, 626, 705, 708, 731, 732, 741, 749, 770, 772], layout: FunctionLayout { input_size: 19, selectors: 42, auxiliaries: 110, lookups: 9 } }, Circuit { members: vec![39, 173, 183, 212, 624, 740, 779], layout: FunctionLayout { input_size: 17, selectors: 12, auxiliaries: 7, lookups: 7 } }, Circuit { members: vec![42, 40, 74, 219, 280, 404, 428, 444, 591, 599, 764], layout: FunctionLayout { input_size: 17, selectors: 32, auxiliaries: 7, lookups: 5 } }, Circuit { members: vec![41, 59, 66, 76, 154, 155, 233, 620, 679, 706, 709, 710, 734, 783], layout: FunctionLayout { input_size: 46, selectors: 34, auxiliaries: 22, lookups: 9 } }, Circuit { members: vec![43], layout: FunctionLayout { input_size: 11, selectors: 2, auxiliaries: 13, lookups: 5 } }, Circuit { members: vec![44], layout: FunctionLayout { input_size: 11, selectors: 7, auxiliaries: 12, lookups: 3 } }, Circuit { members: vec![45, 67, 622, 623, 630, 725, 729], layout: FunctionLayout { input_size: 3, selectors: 21, auxiliaries: 14, lookups: 5 } }, Circuit { members: vec![46], layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 3, lookups: 1 } }, Circuit { members: vec![47], layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 3, lookups: 2 } }, Circuit { members: vec![48], layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 3, lookups: 3 } }, Circuit { members: vec![49, 159, 167, 702, 703, 707, 719, 720, 721, 722, 723, 736, 737, 738], layout: FunctionLayout { input_size: 7, selectors: 27, auxiliaries: 11, lookups: 6 } }, Circuit { members: vec![50, 51, 52, 53, 54, 55, 65, 71, 73, 178, 724, 743, 763, 782], layout: FunctionLayout { input_size: 35, selectors: 32, auxiliaries: 42, lookups: 11 } }, Circuit { members: vec![56, 141, 202, 650, 651], layout: FunctionLayout { input_size: 27, selectors: 29, auxiliaries: 73, lookups: 34 } }, Circuit { members: vec![64, 57, 172, 174, 735, 739, 744, 747, 751], layout: FunctionLayout { input_size: 3, selectors: 25, auxiliaries: 3, lookups: 3 } }, Circuit { members: vec![58, 60, 69, 70, 72, 77, 157, 158, 614, 628, 727, 746, 761, 766, 771], layout: FunctionLayout { input_size: 12, selectors: 34, auxiliaries: 53, lookups: 6 } }, Circuit { members: vec![61, 112, 120, 602, 631, 649, 661, 665, 681, 695, 762], layout: FunctionLayout { input_size: 14, selectors: 34, auxiliaries: 53, lookups: 10 } }, Circuit { members: vec![62, 63, 79, 139, 206, 240, 251, 356, 358, 405, 632, 635, 641, 648, 677], layout: FunctionLayout { input_size: 4, selectors: 38, auxiliaries: 16, lookups: 9 } }, Circuit { members: vec![68, 185, 726, 728, 742, 745, 748, 750], layout: FunctionLayout { input_size: 99, selectors: 26, auxiliaries: 66, lookups: 21 } }, Circuit { members: vec![78, 82, 224, 225, 227, 696, 701], layout: FunctionLayout { input_size: 50, selectors: 27, auxiliaries: 15, lookups: 8 } }, Circuit { members: vec![80, 81, 138, 448, 579, 589, 613, 634, 642, 658, 673, 683, 717, 780], layout: FunctionLayout { input_size: 6, selectors: 24, auxiliaries: 15, lookups: 5 } }, Circuit { members: vec![83, 143, 318, 418, 576], layout: FunctionLayout { input_size: 5, selectors: 9, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![84], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 3 } }, Circuit { members: vec![85], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 21, lookups: 4 } }, Circuit { members: vec![86, 122, 272, 345, 347], layout: FunctionLayout { input_size: 3, selectors: 13, auxiliaries: 24, lookups: 9 } }, Circuit { members: vec![87], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 14, lookups: 4 } }, Circuit { members: vec![88], layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 11, lookups: 4 } }, Circuit { members: vec![89], layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 19, lookups: 3 } }, Circuit { members: vec![90], layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 22, lookups: 6 } }, Circuit { members: vec![91], layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 15, lookups: 6 } }, Circuit { members: vec![92, 93, 480], layout: FunctionLayout { input_size: 4, selectors: 13, auxiliaries: 4, lookups: 3 } }, Circuit { members: vec![94], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 14, lookups: 4 } }, Circuit { members: vec![95], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 16, lookups: 5 } }, Circuit { members: vec![96, 97], layout: FunctionLayout { input_size: 9, selectors: 6, auxiliaries: 23, lookups: 7 } }, Circuit { members: vec![98], layout: FunctionLayout { input_size: 1, selectors: 13, auxiliaries: 35, lookups: 6 } }, Circuit { members: vec![101, 133, 397], layout: FunctionLayout { input_size: 4, selectors: 19, auxiliaries: 42, lookups: 11 } }, Circuit { members: vec![102], layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 98, lookups: 34 } }, Circuit { members: vec![103], layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 15, lookups: 6 } }, Circuit { members: vec![104, 276, 340, 363, 402, 420, 421], layout: FunctionLayout { input_size: 9, selectors: 29, auxiliaries: 24, lookups: 10 } }, Circuit { members: vec![105], layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 15, lookups: 6 } }, Circuit { members: vec![109, 114, 232, 291, 415, 423, 569, 601, 646, 664, 675], layout: FunctionLayout { input_size: 13, selectors: 37, auxiliaries: 3, lookups: 2 } }, Circuit { members: vec![110, 205, 217, 395], layout: FunctionLayout { input_size: 6, selectors: 16, auxiliaries: 19, lookups: 8 } }, Circuit { members: vec![115, 117, 162, 164, 193, 285, 331, 337, 353, 410], layout: FunctionLayout { input_size: 5, selectors: 32, auxiliaries: 52, lookups: 10 } }, Circuit { members: vec![119, 124, 228, 243, 700], layout: FunctionLayout { input_size: 9, selectors: 9, auxiliaries: 88, lookups: 6 } }, Circuit { members: vec![121, 147, 394, 406, 690], layout: FunctionLayout { input_size: 4, selectors: 17, auxiliaries: 14, lookups: 6 } }, Circuit { members: vec![125, 698], layout: FunctionLayout { input_size: 2, selectors: 15, auxiliaries: 55, lookups: 6 } }, Circuit { members: vec![128], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 8, lookups: 4 } }, Circuit { members: vec![129, 207, 215, 226, 262, 266, 653, 662], layout: FunctionLayout { input_size: 6, selectors: 34, auxiliaries: 29, lookups: 10 } }, Circuit { members: vec![130, 477], layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 41, lookups: 7 } }, Circuit { members: vec![131], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 2, lookups: 2 } }, Circuit { members: vec![132, 211, 263, 594, 604, 609, 645, 652, 657, 682], layout: FunctionLayout { input_size: 19, selectors: 37, auxiliaries: 24, lookups: 16 } }, Circuit { members: vec![134, 203, 269, 273, 300, 341], layout: FunctionLayout { input_size: 3, selectors: 21, auxiliaries: 16, lookups: 10 } }, Circuit { members: vec![135], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 15, lookups: 9 } }, Circuit { members: vec![136], layout: FunctionLayout { input_size: 1, selectors: 4, auxiliaries: 25, lookups: 7 } }, Circuit { members: vec![137, 214, 277, 315, 617, 636, 639, 644, 667, 670, 684, 685, 759], layout: FunctionLayout { input_size: 4, selectors: 29, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![144], layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 15, lookups: 6 } }, Circuit { members: vec![145], layout: FunctionLayout { input_size: 17, selectors: 4, auxiliaries: 47, lookups: 7 } }, Circuit { members: vec![146], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 3 } }, Circuit { members: vec![148, 152, 208, 580, 600, 668, 680], layout: FunctionLayout { input_size: 11, selectors: 21, auxiliaries: 21, lookups: 17 } }, Circuit { members: vec![149, 151, 160, 161, 334, 350, 352, 354, 607, 608], layout: FunctionLayout { input_size: 6, selectors: 27, auxiliaries: 19, lookups: 6 } }, Circuit { members: vec![153, 156, 170, 200, 335, 343], layout: FunctionLayout { input_size: 16, selectors: 38, auxiliaries: 31, lookups: 14 } }, Circuit { members: vec![163, 169, 182, 198, 336, 461], layout: FunctionLayout { input_size: 4, selectors: 33, auxiliaries: 31, lookups: 23 } }, Circuit { members: vec![165, 210, 246, 255, 453], layout: FunctionLayout { input_size: 6, selectors: 30, auxiliaries: 20, lookups: 16 } }, Circuit { members: vec![166, 177, 184, 196, 197, 252, 264, 711], layout: FunctionLayout { input_size: 5, selectors: 32, auxiliaries: 18, lookups: 12 } }, Circuit { members: vec![168, 176, 250, 253], layout: FunctionLayout { input_size: 5, selectors: 29, auxiliaries: 31, lookups: 25 } }, Circuit { members: vec![171, 189, 248, 257, 577, 586, 588, 640, 781], layout: FunctionLayout { input_size: 4, selectors: 30, auxiliaries: 9, lookups: 5 } }, Circuit { members: vec![175, 199, 249, 346, 595], layout: FunctionLayout { input_size: 11, selectors: 32, auxiliaries: 35, lookups: 27 } }, Circuit { members: vec![179, 278, 299], layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![181, 621, 704], layout: FunctionLayout { input_size: 2, selectors: 32, auxiliaries: 13, lookups: 8 } }, Circuit { members: vec![188, 235, 629, 660, 730, 733, 769], layout: FunctionLayout { input_size: 10, selectors: 40, auxiliaries: 109, lookups: 51 } }, Circuit { members: vec![190, 261, 328, 411, 583], layout: FunctionLayout { input_size: 4, selectors: 14, auxiliaries: 11, lookups: 6 } }, Circuit { members: vec![191, 242, 245, 254, 447, 573, 582, 590, 647, 676], layout: FunctionLayout { input_size: 4, selectors: 38, auxiliaries: 10, lookups: 5 } }, Circuit { members: vec![192, 287, 575, 596, 606, 633, 666], layout: FunctionLayout { input_size: 8, selectors: 28, auxiliaries: 19, lookups: 10 } }, Circuit { members: vec![194, 258, 296, 309, 351, 355, 357, 605], layout: FunctionLayout { input_size: 5, selectors: 35, auxiliaries: 11, lookups: 6 } }, Circuit { members: vec![195, 615, 616, 637, 774], layout: FunctionLayout { input_size: 6, selectors: 10, auxiliaries: 10, lookups: 6 } }, Circuit { members: vec![201], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![204, 342, 416, 426, 454, 655, 656, 669, 672], layout: FunctionLayout { input_size: 14, selectors: 29, auxiliaries: 50, lookups: 26 } }, Circuit { members: vec![216, 268, 279, 305, 344, 393, 581, 584], layout: FunctionLayout { input_size: 6, selectors: 26, auxiliaries: 13, lookups: 7 } }, Circuit { members: vec![218], layout: FunctionLayout { input_size: 5, selectors: 12, auxiliaries: 25, lookups: 7 } }, Circuit { members: vec![244, 259, 281, 329, 409], layout: FunctionLayout { input_size: 4, selectors: 18, auxiliaries: 7, lookups: 5 } }, Circuit { members: vec![247, 260, 330, 349, 450], layout: FunctionLayout { input_size: 10, selectors: 36, auxiliaries: 43, lookups: 24 } }, Circuit { members: vec![256, 289, 308, 572], layout: FunctionLayout { input_size: 4, selectors: 12, auxiliaries: 13, lookups: 9 } }, Circuit { members: vec![265, 267, 270, 348, 376, 379, 419, 445, 449, 686, 778], layout: FunctionLayout { input_size: 8, selectors: 34, auxiliaries: 12, lookups: 6 } }, Circuit { members: vec![271, 319, 323, 413, 597, 598, 674], layout: FunctionLayout { input_size: 5, selectors: 35, auxiliaries: 13, lookups: 6 } }, Circuit { members: vec![274, 377, 399, 446], layout: FunctionLayout { input_size: 4, selectors: 21, auxiliaries: 11, lookups: 5 } }, Circuit { members: vec![275, 391, 398], layout: FunctionLayout { input_size: 4, selectors: 10, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![282, 392, 407], layout: FunctionLayout { input_size: 4, selectors: 8, auxiliaries: 9, lookups: 6 } }, Circuit { members: vec![283], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 3 } }, Circuit { members: vec![284], layout: FunctionLayout { input_size: 2, selectors: 9, auxiliaries: 9, lookups: 6 } }, Circuit { members: vec![286], layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 8, lookups: 4 } }, Circuit { members: vec![288], layout: FunctionLayout { input_size: 1, selectors: 9, auxiliaries: 9, lookups: 6 } }, Circuit { members: vec![293], layout: FunctionLayout { input_size: 3, selectors: 10, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![486, 487, 506, 508, 294], layout: FunctionLayout { input_size: 3, selectors: 15, auxiliaries: 30, lookups: 14 } }, Circuit { members: vec![295, 412, 571], layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 3, lookups: 3 } }, Circuit { members: vec![298, 424], layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 18, lookups: 10 } }, Circuit { members: vec![301, 339], layout: FunctionLayout { input_size: 2, selectors: 6, auxiliaries: 18, lookups: 13 } }, Circuit { members: vec![302], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 5, lookups: 4 } }, Circuit { members: vec![303], layout: FunctionLayout { input_size: 2, selectors: 11, auxiliaries: 9, lookups: 5 } }, Circuit { members: vec![304], layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 4 } }, Circuit { members: vec![306], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 5, lookups: 4 } }, Circuit { members: vec![307], layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 8, lookups: 5 } }, Circuit { members: vec![310], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 5, lookups: 4 } }, Circuit { members: vec![311], layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 8, lookups: 5 } }, Circuit { members: vec![371, 432, 440, 312], layout: FunctionLayout { input_size: 5, selectors: 4, auxiliaries: 9, lookups: 7 } }, Circuit { members: vec![313], layout: FunctionLayout { input_size: 2, selectors: 9, auxiliaries: 11, lookups: 4 } }, Circuit { members: vec![314, 383], layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 4, lookups: 3 } }, Circuit { members: vec![316], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 6, lookups: 5 } }, Circuit { members: vec![317], layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 8, lookups: 5 } }, Circuit { members: vec![320], layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 8, lookups: 6 } }, Circuit { members: vec![321], layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 5 } }, Circuit { members: vec![322], layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 8, lookups: 5 } }, Circuit { members: vec![324], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 12, lookups: 5 } }, Circuit { members: vec![325], layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 10, lookups: 7 } }, Circuit { members: vec![326], layout: FunctionLayout { input_size: 4, selectors: 6, auxiliaries: 11, lookups: 5 } }, Circuit { members: vec![327, 369], layout: FunctionLayout { input_size: 6, selectors: 6, auxiliaries: 25, lookups: 9 } }, Circuit { members: vec![332, 560, 561], layout: FunctionLayout { input_size: 3, selectors: 41, auxiliaries: 20, lookups: 16 } }, Circuit { members: vec![333], layout: FunctionLayout { input_size: 5, selectors: 6, auxiliaries: 9, lookups: 4 } }, Circuit { members: vec![338], layout: FunctionLayout { input_size: 6, selectors: 16, auxiliaries: 32, lookups: 10 } }, Circuit { members: vec![359], layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 14, lookups: 6 } }, Circuit { members: vec![361], layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 14, lookups: 6 } }, Circuit { members: vec![362], layout: FunctionLayout { input_size: 4, selectors: 8, auxiliaries: 14, lookups: 8 } }, Circuit { members: vec![364, 401, 558, 554], layout: FunctionLayout { input_size: 6, selectors: 43, auxiliaries: 19, lookups: 6 } }, Circuit { members: vec![365], layout: FunctionLayout { input_size: 3, selectors: 6, auxiliaries: 14, lookups: 6 } }, Circuit { members: vec![367], layout: FunctionLayout { input_size: 4, selectors: 6, auxiliaries: 11, lookups: 5 } }, Circuit { members: vec![368], layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 10, lookups: 7 } }, Circuit { members: vec![370], layout: FunctionLayout { input_size: 6, selectors: 19, auxiliaries: 38, lookups: 13 } }, Circuit { members: vec![372, 373], layout: FunctionLayout { input_size: 12, selectors: 16, auxiliaries: 1, lookups: 1 } }, Circuit { members: vec![374, 403], layout: FunctionLayout { input_size: 4, selectors: 19, auxiliaries: 48, lookups: 15 } }, Circuit { members: vec![380], layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 7, lookups: 6 } }, Circuit { members: vec![381], layout: FunctionLayout { input_size: 5, selectors: 2, auxiliaries: 12, lookups: 11 } }, Circuit { members: vec![382, 388], layout: FunctionLayout { input_size: 4, selectors: 6, auxiliaries: 16, lookups: 8 } }, Circuit { members: vec![384], layout: FunctionLayout { input_size: 4, selectors: 6, auxiliaries: 18, lookups: 9 } }, Circuit { members: vec![385], layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 10, lookups: 5 } }, Circuit { members: vec![386], layout: FunctionLayout { input_size: 2, selectors: 4, auxiliaries: 7, lookups: 3 } }, Circuit { members: vec![387], layout: FunctionLayout { input_size: 2, selectors: 12, auxiliaries: 22, lookups: 8 } }, Circuit { members: vec![390], layout: FunctionLayout { input_size: 4, selectors: 3, auxiliaries: 8, lookups: 5 } }, Circuit { members: vec![396, 417, 422, 578, 585, 592], layout: FunctionLayout { input_size: 6, selectors: 16, auxiliaries: 9, lookups: 4 } }, Circuit { members: vec![400], layout: FunctionLayout { input_size: 5, selectors: 25, auxiliaries: 16, lookups: 6 } }, Circuit { members: vec![414], layout: FunctionLayout { input_size: 5, selectors: 7, auxiliaries: 15, lookups: 5 } }, Circuit { members: vec![479, 427], layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 9, lookups: 4 } }, Circuit { members: vec![429], layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 4, lookups: 4 } }, Circuit { members: vec![430], layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 10, lookups: 9 } }, Circuit { members: vec![431], layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 22, lookups: 8 } }, Circuit { members: vec![434, 436, 439, 441], layout: FunctionLayout { input_size: 2, selectors: 18, auxiliaries: 10, lookups: 3 } }, Circuit { members: vec![438, 437, 442], layout: FunctionLayout { input_size: 5, selectors: 21, auxiliaries: 17, lookups: 11 } }, Circuit { members: vec![443], layout: FunctionLayout { input_size: 5, selectors: 8, auxiliaries: 21, lookups: 11 } }, Circuit { members: vec![451], layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![452], layout: FunctionLayout { input_size: 4, selectors: 1, auxiliaries: 3, lookups: 3 } }, Circuit { members: vec![455, 457, 460, 467, 478, 496], layout: FunctionLayout { input_size: 16, selectors: 35, auxiliaries: 36, lookups: 22 } }, Circuit { members: vec![468, 473, 474, 481, 484, 493, 501, 503, 505, 456], layout: FunctionLayout { input_size: 5, selectors: 31, auxiliaries: 22, lookups: 15 } }, Circuit { members: vec![466, 469, 476, 482, 488, 489, 490, 492, 494, 767, 773, 458], layout: FunctionLayout { input_size: 4, selectors: 21, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![459, 559, 564, 495, 497, 498, 499, 500, 502, 504], layout: FunctionLayout { input_size: 16, selectors: 36, auxiliaries: 11, lookups: 10 } }, Circuit { members: vec![485, 507, 555, 556, 465, 470, 471, 472, 475, 483, 491, 718], layout: FunctionLayout { input_size: 2, selectors: 40, auxiliaries: 10, lookups: 7 } }, Circuit { members: vec![549, 552, 553, 568], layout: FunctionLayout { input_size: 1, selectors: 248, auxiliaries: 100, lookups: 1 } }, Circuit { members: vec![550, 551], layout: FunctionLayout { input_size: 1, selectors: 131, auxiliaries: 74, lookups: 12 } }, Circuit { members: vec![557], layout: FunctionLayout { input_size: 2, selectors: 102, auxiliaries: 104, lookups: 40 } }, Circuit { members: vec![562], layout: FunctionLayout { input_size: 3, selectors: 19, auxiliaries: 68, lookups: 68 } }, Circuit { members: vec![563], layout: FunctionLayout { input_size: 1, selectors: 30, auxiliaries: 30, lookups: 1 } }, Circuit { members: vec![565], layout: FunctionLayout { input_size: 3, selectors: 56, auxiliaries: 58, lookups: 32 } }, Circuit { members: vec![566], layout: FunctionLayout { input_size: 3, selectors: 56, auxiliaries: 71, lookups: 71 } }, Circuit { members: vec![567], layout: FunctionLayout { input_size: 3, selectors: 66, auxiliaries: 82, lookups: 82 } }, Circuit { members: vec![570], layout: FunctionLayout { input_size: 1, selectors: 9, auxiliaries: 19, lookups: 5 } }, Circuit { members: vec![574], layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 20, lookups: 8 } }, Circuit { members: vec![691], layout: FunctionLayout { input_size: 1, selectors: 7, auxiliaries: 26, lookups: 7 } }, Circuit { members: vec![692], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 7, lookups: 5 } }, Circuit { members: vec![697], layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 6, lookups: 3 } }, Circuit { members: vec![699], layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 7, lookups: 8 } }, Circuit { members: vec![712], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 4 } }, Circuit { members: vec![713], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 70, lookups: 8 } }, Circuit { members: vec![714], layout: FunctionLayout { input_size: 65, selectors: 1, auxiliaries: 4, lookups: 5 } }, Circuit { members: vec![715], layout: FunctionLayout { input_size: 2, selectors: 7, auxiliaries: 116, lookups: 10 } }, Circuit { members: vec![716], layout: FunctionLayout { input_size: 4, selectors: 6, auxiliaries: 73, lookups: 12 } }, Circuit { members: vec![753], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 10, lookups: 7 } }, Circuit { members: vec![754], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 8, lookups: 5 } }, Circuit { members: vec![755], layout: FunctionLayout { input_size: 1, selectors: 3, auxiliaries: 15, lookups: 4 } }, Circuit { members: vec![756], layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 53, lookups: 6 } }, Circuit { members: vec![757], layout: FunctionLayout { input_size: 5, selectors: 3, auxiliaries: 15, lookups: 10 } }, Circuit { members: vec![758], layout: FunctionLayout { input_size: 8, selectors: 1, auxiliaries: 1, lookups: 2 } }, Circuit { members: vec![760], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![765], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![768], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 3 } }, Circuit { members: vec![775], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 5, lookups: 3 } }, Circuit { members: vec![776], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 4 } }, Circuit { members: vec![777], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 3 } }, Circuit { members: vec![784], layout: FunctionLayout { input_size: 14, selectors: 57, auxiliaries: 31, lookups: 8 } }] } -} -pub static PROGRAM: GeneratedProgram = GeneratedProgram { fingerprint: [134, 255, 142, 155, 247, 231, 0, 155, 156, 136, 201, 185, 23, 188, 13, 83, 187, 4, 113, 195, 47, 43, 101, 210, 29, 29, 27, 138, 47, 144, 112, 191], 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, -Some(FunctionWriter { layout: FunctionLayout { input_size: 34, selectors: 4, auxiliaries: 137, lookups: 6 }, output_size: 34, seed_words: 170, schema: &SCHEMA_24, pack: pack_24, pack_typed: pack_24_typed, write: write_24 }), -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 7, selectors: 9, auxiliaries: 22, lookups: 10 }, output_size: 1, seed_words: 25, schema: &SCHEMA_26, pack: pack_26, pack_typed: pack_26_typed, write: write_26 }), -None, -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 193, lookups: 65 }, output_size: 64, seed_words: 194, schema: &SCHEMA_30, pack: pack_30, pack_typed: pack_30_typed, write: write_30 }), -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 6, selectors: 2, auxiliaries: 153, lookups: 13 }, output_size: 1, seed_words: 158, schema: &SCHEMA_33, pack: pack_33, pack_typed: pack_33_typed, write: |seed, offsets, row| { write_33(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_37, pack: pack_37, pack_typed: pack_37_typed, write: |seed, offsets, row| { write_37(seed, offsets, row); Ok(()) } }), -None, -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 10, selectors: 3, auxiliaries: 3, lookups: 3 }, output_size: 1, seed_words: 12, schema: &SCHEMA_41, pack: pack_41, pack_typed: pack_41_typed, write: write_41 }), -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 11, selectors: 2, auxiliaries: 13, lookups: 5 }, output_size: 1, seed_words: 23, schema: &SCHEMA_43, pack: pack_43, pack_typed: pack_43_typed, write: write_43 }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 11, selectors: 7, auxiliaries: 12, lookups: 3 }, output_size: 1, seed_words: 22, schema: &SCHEMA_44, pack: pack_44, pack_typed: pack_44_typed, write: write_44 }), -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 3, lookups: 2 }, output_size: 1, seed_words: 5, schema: &SCHEMA_47, pack: pack_47, pack_typed: pack_47_typed, write: write_47 }), -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 18, selectors: 2, auxiliaries: 35, lookups: 4 }, output_size: 8, seed_words: 53, schema: &SCHEMA_50, pack: pack_50, pack_typed: pack_50_typed, write: |seed, offsets, row| { write_50(seed, offsets, row); Ok(()) } }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 18, selectors: 2, auxiliaries: 35, lookups: 4 }, output_size: 8, seed_words: 53, schema: &SCHEMA_51, pack: pack_51, pack_typed: pack_51_typed, write: |seed, offsets, row| { write_51(seed, offsets, row); Ok(()) } }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 18, selectors: 2, auxiliaries: 35, lookups: 4 }, output_size: 8, seed_words: 53, schema: &SCHEMA_52, pack: pack_52, pack_typed: pack_52_typed, write: |seed, offsets, row| { write_52(seed, offsets, row); Ok(()) } }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 19, selectors: 2, auxiliaries: 39, lookups: 5 }, output_size: 1, seed_words: 58, schema: &SCHEMA_53, pack: pack_53, pack_typed: pack_53_typed, write: |seed, offsets, row| { write_53(seed, offsets, row); Ok(()) } }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 19, selectors: 2, auxiliaries: 40, lookups: 6 }, output_size: 1, seed_words: 59, schema: &SCHEMA_54, pack: pack_54, pack_typed: pack_54_typed, write: |seed, offsets, row| { write_54(seed, offsets, row); Ok(()) } }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 19, selectors: 2, auxiliaries: 40, lookups: 6 }, output_size: 1, seed_words: 59, schema: &SCHEMA_55, pack: pack_55, pack_typed: pack_55_typed, write: |seed, offsets, row| { write_55(seed, offsets, row); Ok(()) } }), -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 26, lookups: 4 }, output_size: 8, seed_words: 35, schema: &SCHEMA_58, pack: pack_58, pack_typed: pack_58_typed, write: |seed, offsets, row| { write_58(seed, offsets, row); Ok(()) } }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 19, lookups: 3 }, output_size: 9, seed_words: 28, schema: &SCHEMA_59, pack: pack_59, pack_typed: pack_59_typed, write: |seed, offsets, row| { write_59(seed, offsets, row); Ok(()) } }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 10, selectors: 5, auxiliaries: 22, lookups: 6 }, output_size: 1, seed_words: 32, schema: &SCHEMA_60, pack: pack_60, pack_typed: pack_60_typed, write: write_60 }), -None, -None, -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 13, selectors: 1, auxiliaries: 42, lookups: 8 }, output_size: 1, seed_words: 55, schema: &SCHEMA_65, pack: pack_65, pack_typed: pack_65_typed, write: |seed, offsets, row| { write_65(seed, offsets, row); Ok(()) } }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 21, lookups: 4 }, output_size: 1, seed_words: 31, schema: &SCHEMA_66, pack: pack_66, pack_typed: pack_66_typed, write: |seed, offsets, row| { write_66(seed, offsets, row); Ok(()) } }), -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 11, selectors: 1, auxiliaries: 22, lookups: 5 }, output_size: 1, seed_words: 33, schema: &SCHEMA_69, pack: pack_69, pack_typed: pack_69_typed, write: |seed, offsets, row| { write_69(seed, offsets, row); Ok(()) } }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 11, selectors: 1, auxiliaries: 22, lookups: 5 }, output_size: 1, seed_words: 33, schema: &SCHEMA_70, pack: pack_70, pack_typed: pack_70_typed, write: |seed, offsets, row| { write_70(seed, offsets, row); Ok(()) } }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 35, selectors: 1, auxiliaries: 25, lookups: 8 }, output_size: 1, seed_words: 60, schema: &SCHEMA_71, pack: pack_71, pack_typed: pack_71_typed, write: |seed, offsets, row| { write_71(seed, offsets, row); Ok(()) } }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 39, lookups: 4 }, output_size: 1, seed_words: 41, schema: &SCHEMA_72, pack: pack_72, pack_typed: pack_72_typed, write: write_72 }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 28, selectors: 1, auxiliaries: 34, lookups: 10 }, output_size: 1, seed_words: 62, schema: &SCHEMA_73, pack: pack_73, pack_typed: pack_73_typed, write: |seed, offsets, row| { write_73(seed, offsets, row); Ok(()) } }), -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 46, selectors: 3, auxiliaries: 3, lookups: 3 }, output_size: 1, seed_words: 49, schema: &SCHEMA_76, pack: pack_76, pack_typed: pack_76_typed, write: write_76 }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 50, lookups: 4 }, output_size: 1, seed_words: 52, schema: &SCHEMA_77, pack: pack_77, pack_typed: pack_77_typed, write: write_77 }), -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_83, pack: pack_83, pack_typed: pack_83_typed, write: write_83 }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 14, lookups: 3 }, output_size: 9, seed_words: 15, schema: &SCHEMA_84, pack: pack_84, pack_typed: pack_84_typed, write: write_84 }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 21, lookups: 4 }, output_size: 10, seed_words: 14, schema: &SCHEMA_85, pack: pack_85, pack_typed: pack_85_typed, write: write_85 }), -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 14, lookups: 4 }, output_size: 9, seed_words: 14, schema: &SCHEMA_87, pack: pack_87, pack_typed: pack_87_typed, write: write_87 }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 11, lookups: 4 }, output_size: 9, seed_words: 13, schema: &SCHEMA_88, pack: pack_88, pack_typed: pack_88_typed, write: write_88 }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 19, lookups: 3 }, output_size: 9, seed_words: 22, schema: &SCHEMA_89, pack: pack_89, pack_typed: pack_89_typed, write: write_89 }), -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 15, lookups: 6 }, output_size: 2, seed_words: 25, schema: &SCHEMA_91, pack: pack_91, pack_typed: pack_91_typed, write: write_91 }), -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 14, lookups: 4 }, output_size: 4, seed_words: 7, schema: &SCHEMA_94, pack: pack_94, pack_typed: pack_94_typed, write: |seed, offsets, row| { write_94(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_95, pack: pack_95, pack_typed: pack_95_typed, write: |seed, offsets, row| { write_95(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_98, pack: pack_98, pack_typed: pack_98_typed, write: write_98 }), -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_103, pack: pack_103, pack_typed: pack_103_typed, write: write_103 }), -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: 8, auxiliaries: 46, lookups: 2 }, output_size: 46, seed_words: 48, schema: &SCHEMA_125, pack: pack_125, pack_typed: pack_125_typed, write: write_125 }), -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 8, lookups: 4 }, output_size: 2, seed_words: 9, schema: &SCHEMA_128, pack: pack_128, pack_typed: pack_128_typed, write: |seed, offsets, row| { write_128(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_130, pack: pack_130, pack_typed: pack_130_typed, write: write_130 }), -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_135, pack: pack_135, pack_typed: pack_135_typed, write: write_135 }), -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_143, pack: pack_143, pack_typed: pack_143_typed, write: |seed, offsets, row| { write_143(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_145, pack: pack_145, pack_typed: pack_145_typed, write: write_145 }), -None, -None, -None, -None, -None, -None, -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 }, output_size: 8, seed_words: 17, schema: &SCHEMA_154, pack: |context, seed| { pack_154(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_154_typed(context, seed); Ok(()) }, write: |seed, offsets, row| { write_154(seed, offsets, row); Ok(()) } }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 9, lookups: 9 }, output_size: 8, seed_words: 17, schema: &SCHEMA_155, pack: |context, seed| { pack_155(context, seed); Ok(()) }, pack_typed: |context, seed| { pack_155_typed(context, seed); Ok(()) }, write: |seed, offsets, row| { write_155(seed, offsets, row); Ok(()) } }), -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 31, lookups: 6 }, output_size: 1, seed_words: 33, schema: &SCHEMA_157, pack: pack_157, pack_typed: pack_157_typed, write: write_157 }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 31, lookups: 6 }, output_size: 1, seed_words: 33, schema: &SCHEMA_158, pack: pack_158, pack_typed: pack_158_typed, write: write_158 }), -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: 5, auxiliaries: 31, lookups: 10 }, output_size: 1, seed_words: 33, schema: &SCHEMA_178, pack: pack_178, pack_typed: pack_178_typed, write: |seed, offsets, row| { write_178(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, -Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, output_size: 1, seed_words: 8, schema: &SCHEMA_201, pack: pack_201, pack_typed: pack_201_typed, write: write_201 }), -None, -None, -None, -None, -None, -None, -None, -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: 14, selectors: 2, auxiliaries: 4, lookups: 3 }, output_size: 1, seed_words: 17, schema: &SCHEMA_233, pack: pack_233, pack_typed: pack_233_typed, write: |seed, offsets, row| { write_233(seed, offsets, row); Ok(()) } }), -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 108, lookups: 6 }, output_size: 1, seed_words: 110, schema: &SCHEMA_236, pack: pack_236, pack_typed: pack_236_typed, write: write_236 }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 142, lookups: 7 }, output_size: 1, seed_words: 145, schema: &SCHEMA_237, pack: pack_237, pack_typed: pack_237_typed, write: write_237 }), -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 94, lookups: 3 }, output_size: 45, seed_words: 95, schema: &SCHEMA_239, pack: pack_239, pack_typed: pack_239_typed, write: write_239 }), -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 102, lookups: 6 }, output_size: 1, seed_words: 60, schema: &SCHEMA_241, pack: pack_241, pack_typed: pack_241_typed, write: write_241 }), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -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_288, pack: pack_288, pack_typed: pack_288_typed, write: write_288 }), -None, -None, -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 10, auxiliaries: 7, lookups: 4 }, output_size: 1, seed_words: 10, schema: &SCHEMA_293, pack: pack_293, pack_typed: pack_293_typed, write: write_293 }), -None, -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_302, pack: pack_302, pack_typed: pack_302_typed, write: |seed, offsets, row| { write_302(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_303, pack: pack_303, pack_typed: pack_303_typed, write: write_303 }), -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_310, pack: pack_310, pack_typed: pack_310_typed, write: write_310 }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 8, lookups: 5 }, output_size: 1, seed_words: 11, schema: &SCHEMA_311, pack: pack_311, pack_typed: pack_311_typed, write: write_311 }), -None, -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_318, pack: pack_318, pack_typed: pack_318_typed, write: write_318 }), -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 8, lookups: 6 }, output_size: 1, seed_words: 9, schema: &SCHEMA_320, pack: pack_320, pack_typed: pack_320_typed, write: write_320 }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 5, lookups: 5 }, output_size: 1, seed_words: 8, schema: &SCHEMA_321, pack: pack_321, pack_typed: pack_321_typed, write: write_321 }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 9, auxiliaries: 8, lookups: 5 }, output_size: 1, seed_words: 11, schema: &SCHEMA_322, pack: pack_322, pack_typed: pack_322_typed, write: write_322 }), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -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: 9, lookups: 8 }, output_size: 1, seed_words: 6, schema: &SCHEMA_382, pack: pack_382, pack_typed: pack_382_typed, write: |seed, offsets, row| { write_382(seed, offsets, row); Ok(()) } }), -None, -None, -None, -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 4, selectors: 4, auxiliaries: 16, lookups: 7 }, output_size: 2, seed_words: 15, schema: &SCHEMA_388, pack: pack_388, pack_typed: pack_388_typed, write: |seed, offsets, row| { write_388(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: 5, selectors: 2, auxiliaries: 7, lookups: 4 }, output_size: 3, seed_words: 12, schema: &SCHEMA_418, pack: pack_418, pack_typed: pack_418_typed, write: |seed, offsets, row| { write_418(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: 5, selectors: 8, auxiliaries: 21, lookups: 11 }, output_size: 1, seed_words: 23, schema: &SCHEMA_443, pack: pack_443, pack_typed: pack_443_typed, write: write_443 }), -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: 72, lookups: 13 }, output_size: 1, seed_words: 73, schema: &SCHEMA_462, pack: pack_462, pack_typed: pack_462_typed, write: |seed, offsets, row| { write_462(seed, offsets, row); Ok(()) } }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 56, lookups: 22 }, output_size: 14, seed_words: 51, schema: &SCHEMA_463, pack: pack_463, pack_typed: pack_463_typed, write: |seed, offsets, row| { write_463(seed, offsets, row); Ok(()) } }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 2, auxiliaries: 39, lookups: 21 }, output_size: 8, seed_words: 28, schema: &SCHEMA_464, pack: pack_464, pack_typed: pack_464_typed, write: |seed, offsets, row| { write_464(seed, offsets, row); Ok(()) } }), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 20, lookups: 2 }, output_size: 6, seed_words: 21, schema: &SCHEMA_477, pack: pack_477, pack_typed: pack_477_typed, write: |seed, offsets, row| { write_477(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, -Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 7, lookups: 3 }, output_size: 1, seed_words: 8, schema: &SCHEMA_576, pack: pack_576, pack_typed: pack_576_typed, write: write_576 }), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -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: 12, selectors: 4, auxiliaries: 14, lookups: 6 }, output_size: 1, seed_words: 25, schema: &SCHEMA_614, pack: pack_614, pack_typed: pack_614_typed, write: |seed, offsets, row| { write_614(seed, offsets, row); Ok(()) } }), -None, -None, -None, -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 5, auxiliaries: 11, lookups: 5 }, output_size: 1, seed_words: 13, schema: &SCHEMA_620, pack: pack_620, pack_typed: pack_620_typed, write: write_620 }), -None, -None, -None, -None, -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 7, auxiliaries: 121, lookups: 12 }, output_size: 1, seed_words: 120, schema: &SCHEMA_627, pack: pack_627, pack_typed: pack_627_typed, write: |seed, offsets, row| { write_627(seed, offsets, row); Ok(()) } }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 4, selectors: 2, auxiliaries: 50, lookups: 3 }, output_size: 1, seed_words: 54, schema: &SCHEMA_628, pack: pack_628, pack_typed: pack_628_typed, write: |seed, offsets, row| { write_628(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, -Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 4, auxiliaries: 10, lookups: 6 }, output_size: 1, seed_words: 13, schema: &SCHEMA_679, pack: pack_679, pack_typed: pack_679_typed, write: write_679 }), -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: 3, auxiliaries: 6, lookups: 3 }, output_size: 1, seed_words: 7, schema: &SCHEMA_697, pack: pack_697, pack_typed: pack_697_typed, write: write_697 }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 7, auxiliaries: 55, lookups: 6 }, output_size: 0, seed_words: 52, schema: &SCHEMA_698, pack: pack_698, pack_typed: pack_698_typed, write: |seed, offsets, row| { write_698(seed, offsets, row); Ok(()) } }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 4, selectors: 5, auxiliaries: 7, lookups: 8 }, output_size: 0, seed_words: 11, schema: &SCHEMA_699, pack: pack_699, pack_typed: pack_699_typed, write: write_699 }), -None, -None, -None, -None, -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 7, selectors: 2, auxiliaries: 16, lookups: 4 }, output_size: 6, seed_words: 23, schema: &SCHEMA_706, pack: pack_706, pack_typed: pack_706_typed, write: write_706 }), -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 17, selectors: 5, auxiliaries: 7, lookups: 8 }, output_size: 0, seed_words: 24, schema: &SCHEMA_709, pack: pack_709, pack_typed: pack_709_typed, write: write_709 }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 14, selectors: 2, auxiliaries: 5, lookups: 5 }, output_size: 0, seed_words: 19, schema: &SCHEMA_710, pack: pack_710, pack_typed: pack_710_typed, write: write_710 }), -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 4, lookups: 4 }, output_size: 0, seed_words: 6, schema: &SCHEMA_712, pack: pack_712, pack_typed: pack_712_typed, write: write_712 }), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 9, selectors: 2, auxiliaries: 32, lookups: 6 }, output_size: 2, seed_words: 40, schema: &SCHEMA_724, pack: pack_724, pack_typed: pack_724_typed, write: |seed, offsets, row| { write_724(seed, offsets, row); Ok(()) } }), -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 51, lookups: 3 }, output_size: 49, seed_words: 52, schema: &SCHEMA_727, pack: pack_727, pack_typed: pack_727_typed, write: |seed, offsets, row| { write_727(seed, offsets, row); Ok(()) } }), -None, -None, -None, -None, -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 22, lookups: 5 }, output_size: 1, seed_words: 23, schema: &SCHEMA_734, pack: pack_734, pack_typed: pack_734_typed, write: |seed, offsets, row| { write_734(seed, offsets, row); Ok(()) } }), -None, -None, -None, -None, -None, -None, -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 10, selectors: 2, auxiliaries: 39, lookups: 6 }, output_size: 0, seed_words: 49, schema: &SCHEMA_743, pack: pack_743, pack_typed: pack_743_typed, write: write_743 }), -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 51, lookups: 4 }, output_size: 0, seed_words: 53, schema: &SCHEMA_746, pack: pack_746, pack_typed: pack_746_typed, write: write_746 }), -None, -None, -None, -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 8, selectors: 8, auxiliaries: 115, lookups: 19 }, output_size: 0, seed_words: 123, schema: &SCHEMA_752, pack: pack_752, pack_typed: pack_752_typed, write: write_752 }), -None, -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 3, selectors: 1, auxiliaries: 53, lookups: 6 }, output_size: 1, seed_words: 56, schema: &SCHEMA_756, pack: pack_756, pack_typed: pack_756_typed, write: write_756 }), -None, -None, -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 27, lookups: 4 }, output_size: 8, seed_words: 28, schema: &SCHEMA_761, pack: pack_761, pack_typed: pack_761_typed, write: write_761 }), -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 8, selectors: 4, auxiliaries: 22, lookups: 10 }, output_size: 1, seed_words: 22, schema: &SCHEMA_763, pack: pack_763, pack_typed: pack_763_typed, write: write_763 }), -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 }, output_size: 1, seed_words: 8, schema: &SCHEMA_765, pack: pack_765, pack_typed: pack_765_typed, write: write_765 }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 53, lookups: 4 }, output_size: 8, seed_words: 54, schema: &SCHEMA_766, pack: pack_766, pack_typed: pack_766_typed, write: write_766 }), -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 5, lookups: 3 }, output_size: 1, seed_words: 7, schema: &SCHEMA_768, pack: pack_768, pack_typed: pack_768_typed, write: write_768 }), -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 28, lookups: 4 }, output_size: 8, seed_words: 29, schema: &SCHEMA_771, pack: pack_771, pack_typed: pack_771_typed, write: write_771 }), -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_777, pack: pack_777, pack_typed: pack_777_typed, write: write_777 }), -None, -None, -None, -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 8, selectors: 4, auxiliaries: 33, lookups: 11 }, output_size: 6, seed_words: 33, schema: &SCHEMA_782, pack: pack_782, pack_typed: pack_782_typed, write: write_782 }), -Some(FunctionWriter { layout: FunctionLayout { input_size: 15, selectors: 2, auxiliaries: 7, lookups: 3 }, output_size: 6, seed_words: 22, schema: &SCHEMA_783, pack: pack_783, pack_typed: pack_783_typed, write: |seed, offsets, row| { write_783(seed, offsets, row); Ok(()) } }), -None -] }; diff --git a/crates/aiur/src/trace_codegen/programs/ixvm_cuda.rs b/crates/aiur/src/trace_codegen/programs/ixvm_cuda.rs deleted file mode 100644 index 6b6b8302a..000000000 --- a/crates/aiur/src/trace_codegen/programs/ixvm_cuda.rs +++ /dev/null @@ -1,895 +0,0 @@ -// 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_24(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_26(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_30(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_33(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_37(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_41(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_44(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_47(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_50(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_51(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_52(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_53(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_54(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_55(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_58(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_59(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_60(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_65(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_66(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_69(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_70(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_71(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_72(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_73(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_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_ixvm_77(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_84(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_87(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_91(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_94(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_95(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_98(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_103(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_125(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_128(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_130(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_135(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_143(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_145(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_154(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_155(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_157(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_158(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_178(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_201(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_233(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_236(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_237(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_239(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_241(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_288(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_293(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_302(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_303(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_310(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_311(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_318(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_320(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_321(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_322(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_382(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_388(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_418(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_443(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_462(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_463(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_464(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_477(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_576(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_614(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_620(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_627(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_628(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_679(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_697(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_698(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_699(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_706(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_709(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_710(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_712(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_727(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_734(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_743(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_746(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_752(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_756(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_761(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_763(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_765(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_766(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_768(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_771(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_777(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_782(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_783(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([134, 255, 142, 155, 247, 231, 0, 155, 156, 136, 201, 185, 23, 188, 13, 83, 187, 4, 113, 195, 47, 43, 101, 210, 29, 29, 27, 138, 47, 144, 112, 191], aiur_trace_ixvm_contract, aiur_trace_ixvm_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, -Some(aiur_trace_ixvm_24), -None, -Some(aiur_trace_ixvm_26), -None, -None, -None, -Some(aiur_trace_ixvm_30), -None, -None, -Some(aiur_trace_ixvm_33), -None, -None, -None, -Some(aiur_trace_ixvm_37), -None, -None, -None, -Some(aiur_trace_ixvm_41), -None, -Some(aiur_trace_ixvm_43), -Some(aiur_trace_ixvm_44), -None, -None, -Some(aiur_trace_ixvm_47), -None, -None, -Some(aiur_trace_ixvm_50), -Some(aiur_trace_ixvm_51), -Some(aiur_trace_ixvm_52), -Some(aiur_trace_ixvm_53), -Some(aiur_trace_ixvm_54), -Some(aiur_trace_ixvm_55), -None, -None, -Some(aiur_trace_ixvm_58), -Some(aiur_trace_ixvm_59), -Some(aiur_trace_ixvm_60), -None, -None, -None, -None, -Some(aiur_trace_ixvm_65), -Some(aiur_trace_ixvm_66), -None, -None, -Some(aiur_trace_ixvm_69), -Some(aiur_trace_ixvm_70), -Some(aiur_trace_ixvm_71), -Some(aiur_trace_ixvm_72), -Some(aiur_trace_ixvm_73), -None, -None, -Some(aiur_trace_ixvm_76), -Some(aiur_trace_ixvm_77), -None, -None, -None, -None, -None, -Some(aiur_trace_ixvm_83), -Some(aiur_trace_ixvm_84), -Some(aiur_trace_ixvm_85), -None, -Some(aiur_trace_ixvm_87), -Some(aiur_trace_ixvm_88), -Some(aiur_trace_ixvm_89), -None, -Some(aiur_trace_ixvm_91), -None, -None, -Some(aiur_trace_ixvm_94), -Some(aiur_trace_ixvm_95), -None, -None, -Some(aiur_trace_ixvm_98), -None, -None, -None, -None, -Some(aiur_trace_ixvm_103), -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_125), -None, -None, -Some(aiur_trace_ixvm_128), -None, -Some(aiur_trace_ixvm_130), -None, -None, -None, -None, -Some(aiur_trace_ixvm_135), -None, -None, -None, -None, -None, -None, -None, -Some(aiur_trace_ixvm_143), -None, -Some(aiur_trace_ixvm_145), -None, -None, -None, -None, -None, -None, -None, -None, -Some(aiur_trace_ixvm_154), -Some(aiur_trace_ixvm_155), -None, -Some(aiur_trace_ixvm_157), -Some(aiur_trace_ixvm_158), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -Some(aiur_trace_ixvm_178), -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_201), -None, -None, -None, -None, -None, -None, -None, -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_233), -None, -None, -Some(aiur_trace_ixvm_236), -Some(aiur_trace_ixvm_237), -None, -Some(aiur_trace_ixvm_239), -None, -Some(aiur_trace_ixvm_241), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -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_288), -None, -None, -None, -None, -Some(aiur_trace_ixvm_293), -None, -None, -None, -None, -None, -None, -None, -None, -Some(aiur_trace_ixvm_302), -Some(aiur_trace_ixvm_303), -None, -None, -None, -None, -None, -None, -Some(aiur_trace_ixvm_310), -Some(aiur_trace_ixvm_311), -None, -None, -None, -None, -None, -None, -Some(aiur_trace_ixvm_318), -None, -Some(aiur_trace_ixvm_320), -Some(aiur_trace_ixvm_321), -Some(aiur_trace_ixvm_322), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -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_382), -None, -None, -None, -None, -None, -Some(aiur_trace_ixvm_388), -None, -None, -None, -None, -None, -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_418), -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_443), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -Some(aiur_trace_ixvm_462), -Some(aiur_trace_ixvm_463), -Some(aiur_trace_ixvm_464), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -Some(aiur_trace_ixvm_477), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -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_576), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -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_614), -None, -None, -None, -None, -None, -Some(aiur_trace_ixvm_620), -None, -None, -None, -None, -None, -None, -Some(aiur_trace_ixvm_627), -Some(aiur_trace_ixvm_628), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -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_679), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -Some(aiur_trace_ixvm_697), -Some(aiur_trace_ixvm_698), -Some(aiur_trace_ixvm_699), -None, -None, -None, -None, -None, -None, -Some(aiur_trace_ixvm_706), -None, -None, -Some(aiur_trace_ixvm_709), -Some(aiur_trace_ixvm_710), -None, -Some(aiur_trace_ixvm_712), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -Some(aiur_trace_ixvm_724), -None, -None, -Some(aiur_trace_ixvm_727), -None, -None, -None, -None, -None, -None, -Some(aiur_trace_ixvm_734), -None, -None, -None, -None, -None, -None, -None, -None, -Some(aiur_trace_ixvm_743), -None, -None, -Some(aiur_trace_ixvm_746), -None, -None, -None, -None, -None, -Some(aiur_trace_ixvm_752), -None, -None, -None, -Some(aiur_trace_ixvm_756), -None, -None, -None, -None, -Some(aiur_trace_ixvm_761), -None, -Some(aiur_trace_ixvm_763), -None, -Some(aiur_trace_ixvm_765), -Some(aiur_trace_ixvm_766), -None, -Some(aiur_trace_ixvm_768), -None, -None, -Some(aiur_trace_ixvm_771), -None, -None, -None, -None, -None, -Some(aiur_trace_ixvm_777), -None, -None, -None, -None, -Some(aiur_trace_ixvm_782), -Some(aiur_trace_ixvm_783), -None -], &[3, 67, 68, 3, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 17, 17, 9, 9, 9, 0, 0, 0, 71, 40, 170, 137, 25, 0, 0, 0, 194, 5, 146, 158, 0, 0, 0, 162, 79, 13, 12, 12, 11, 23, 22, 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, 14, 14, 14, 13, 22, 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, 6, 16, 13, 13, 12, 19, 8, 19, 16, 15, 7, 3, 9, 2, 15, 20, 16, 33, 10, 0, 9, 21, 9, 18, 22, 0, 0, 11, 9, 12, 3, 17, 13, 9, 10, 13, 16, 21, 15, 17, 8, 8, 17, 19, 19, 13, 24, 19, 0, 16, 13, 11, 22, 7, 28, 14, 18, 30, 21, 17, 17, 39, 73, 39, 46, 22, 58, 89, 15, 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, 4, 7, 9, 0, 6, 7, 6, 8, 6, 10, 7, 10, 7, 11, 5, 10, 7, 11, 10, 9, 6, 8, 8, 11, 6, 10, 9, 8, 11, 10, 15, 13, 13, 30, 9, 10, 16, 18, 7, 11, 9, 12, 12, 14, 32, 13, 12, 15, 26, 35, 10, 27, 36, 23, 11, 49, 14, 9, 17, 53, 23, 8, 9, 10, 8, 12, 0, 12, 17, 30, 24, 12, 0, 13, 13, 30, 36, 5, 13, 13, 47, 0, 14, 13, 13, 11, 10, 16, 6, 7, 21, 13, 8, 24, 15, 0, 12, 8, 10, 12, 16, 17, 11, 23, 9, 15, 19, 15, 15, 44, 13, 14, 14, 10, 34, 9, 18, 12, 6, 16, 15, 13, 41, 12, 12, 15, 28, 28, 13, 13, 21, 23, 40, 9, 19, 7, 13, 25, 11, 0, 10, 0, 10, 16, 14, 8, 14, 11, 22, 23, 7, 14, 12, 8, 10, 16, 44, 10, 7, 10, 18, 27, 20, 29, 6, 14, 26, 27, 73, 51, 28, 10, 4, 44, 14, 3, 11, 11, 11, 22, 24, 11, 5, 21, 21, 11, 6, 15, 4, 7, 2, 4, 23, 20, 3, 4, 3, 7, 7, 21, 6, 14, 39, 14, 18, 19, 19, 24, 21, 25, 22, 25, 18, 2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 8, 13, 2, 2, 2, 2, 2, 42, 2, 2, 19, 19, 71, 2, 3, 35, 74, 85, 2, 13, 20, 4, 6, 6, 23, 5, 8, 10, 12, 18, 20, 16, 6, 12, 12, 11, 9, 0, 8, 17, 10, 8, 11, 12, 22, 37, 26, 11, 10, 12, 27, 14, 64, 73, 21, 12, 17, 8, 11, 33, 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, 16, 8, 10, 0, 7, 8, 17, 10, 0, 7, 20, 6, 8, 8, 29, 54, 58, 32, 24, 33, 37, 43, 27, 13, 55, 88, 23, 23, 34, 8, 33, 9, 8, 22, 37, 6, 10, 33, 10, 8, 8, 7, 19, 16, 13, 22, 29, 35, 15, 6, 9, 13, 51, 52, 34, 16, 25, 8, 16, 41, 54, 54, 7, 52, 11, 53, 64, 6, 8, 12, 77, 23, 9, 67, 24, 19, 22, 6, 72, 69, 118, 77, 6, 11, 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, 13, 11, 16, 56, 20, 9, 8, 8, 28, 21, 22, 4, 8, 54, 7, 7, 111, 65, 29, 89, 5, 14, 6, 8, 7, 8, 15, 9, 8, 33, 22, 42], &[16, 528, 536, 16, 0, 48, 72, 0, 0, 0, 0, 0, 0, 0, 136, 24, 72, 72, 72, 0, 0, 0, 544, 296, 432, 840, 160, 0, 0, 0, 848, 40, 416, 272, 0, 0, 0, 176, 152, 104, 40, 40, 32, 64, 56, 48, 16, 16, 32, 32, 360, 360, 360, 96, 96, 96, 408, 16, 272, 216, 64, 64, 56, 48, 24, 96, 64, 56, 152, 72, 64, 112, 88, 120, 40, 48, 80, 88, 72, 40, 40, 40, 120, 32, 112, 48, 48, 48, 40, 40, 184, 184, 16, 32, 24, 32, 208, 224, 160, 120, 288, 200, 440, 176, 240, 168, 0, 0, 0, 16, 80, 0, 200, 200, 16, 64, 16, 64, 144, 272, 152, 56, 80, 184, 320, 192, 0, 304, 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, 40, 72, 64, 80, 64, 88, 48, 128, 80, 88, 32, 24, 48, 16, 88, 112, 80, 184, 56, 0, 32, 96, 48, 88, 160, 0, 0, 40, 48, 64, 24, 88, 64, 48, 48, 56, 64, 80, 72, 96, 48, 40, 96, 96, 96, 72, 128, 104, 0, 88, 80, 64, 168, 48, 200, 80, 112, 136, 144, 128, 128, 136, 240, 280, 336, 104, 416, 456, 120, 0, 280, 24, 112, 272, 440, 400, 512, 400, 336, 24, 200, 24, 200, 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, 24, 32, 32, 0, 32, 40, 32, 40, 32, 56, 40, 48, 40, 64, 32, 64, 40, 64, 64, 40, 32, 32, 40, 56, 32, 56, 48, 48, 56, 56, 88, 72, 72, 192, 48, 48, 88, 88, 40, 56, 48, 64, 64, 80, 184, 80, 72, 80, 144, 184, 64, 152, 208, 136, 72, 288, 88, 64, 104, 192, 144, 56, 40, 32, 32, 72, 0, 72, 104, 200, 144, 72, 0, 72, 72, 192, 200, 40, 104, 104, 312, 0, 80, 72, 88, 56, 48, 72, 32, 32, 104, 64, 40, 136, 48, 0, 56, 32, 40, 48, 72, 48, 48, 104, 40, 64, 104, 64, 40, 248, 80, 40, 72, 40, 216, 40, 80, 56, 32, 72, 64, 104, 256, 64, 64, 72, 160, 160, 64, 104, 112, 144, 224, 56, 136, 40, 72, 168, 64, 0, 72, 0, 64, 88, 96, 56, 88, 80, 128, 128, 40, 72, 72, 40, 48, 96, 256, 56, 32, 64, 96, 136, 96, 136, 40, 80, 136, 144, 440, 280, 136, 56, 24, 240, 88, 16, 80, 80, 80, 136, 136, 64, 32, 128, 112, 64, 40, 96, 24, 40, 16, 24, 128, 120, 16, 24, 16, 32, 32, 80, 32, 104, 200, 96, 128, 120, 120, 144, 120, 136, 112, 136, 96, 16, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 40, 64, 16, 16, 16, 16, 16, 264, 16, 16, 112, 112, 416, 16, 24, 232, 424, 568, 16, 104, 136, 24, 32, 32, 144, 24, 56, 56, 72, 112, 112, 72, 32, 72, 56, 64, 56, 0, 32, 104, 32, 32, 72, 72, 136, 184, 168, 56, 56, 80, 168, 104, 272, 320, 144, 72, 88, 32, 56, 208, 184, 184, 184, 104, 168, 104, 48, 48, 0, 304, 56, 80, 64, 64, 112, 0, 384, 464, 200, 424, 72, 80, 96, 48, 88, 88, 56, 64, 0, 48, 48, 104, 56, 0, 48, 120, 40, 56, 48, 208, 344, 328, 200, 160, 224, 216, 272, 168, 72, 208, 416, 144, 56, 224, 56, 208, 56, 56, 136, 224, 40, 64, 200, 56, 56, 64, 40, 104, 80, 56, 144, 176, 192, 104, 40, 56, 88, 184, 184, 200, 80, 104, 48, 64, 144, 184, 400, 40, 160, 40, 192, 448, 32, 40, 72, 560, 120, 56, 232, 112, 88, 120, 24, 544, 544, 680, 560, 32, 48, 56, 32, 40, 32, 32, 216, 64, 168, 152, 296, 64, 264, 232, 368, 280, 48, 16, 16, 16, 16, 32, 144, 536, 536, 240, 24, 456, 152, 24, 624, 304, 440, 24, 576, 72, 56, 104, 184, 88, 72, 56, 48, 216, 160, 120, 24, 48, 256, 48, 48, 456, 304, 176, 360, 32, 96, 40, 48, 48, 56, 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 deleted file mode 100644 index 3b39ec7e2..000000000 --- a/crates/aiur/src/trace_codegen/programs/mod.rs +++ /dev/null @@ -1,170 +0,0 @@ -//! 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 function_circuits = bytecode.circuits.len(); - let constrained_functions = - bytecode.functions.iter().filter(|f| f.constrained).count(); - let registered = cuda - .register(generated, bytecode) - .map_err(|error| format!("{name}: {error}"))?; - let covered = - (0..function_circuits).filter(|&c| registered.bound().supports(c)).count(); - tracing::info!( - program = name, - generated_functions = - generated.functions.iter().filter(|f| f.is_some()).count(), - constrained_functions, - generated_circuits = covered, - function_circuits, - "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::p3_field::{PrimeCharacteristicRing, PrimeField64}; - - #[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 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, _) = registered - .bound() - .prepare_trace( - 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 raw = source.download_tile(0, height - 1, height + 1); - 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(); - let provider = TraceProvider::Generated(registered); - 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 deleted file mode 100644 index 60627cd3c..000000000 --- a/crates/aiur/src/trace_codegen/programs/multi_stark.rs +++ /dev/null @@ -1,1645 +0,0 @@ -// 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_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(); 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(79, v_187)) }, } }, _ => { Err(no_match(79, v_184)) }, } }, _ => { Err(no_match(79, v_181)) }, } }, _ => { Err(no_match(79, v_178)) }, } }, _ => { Err(no_match(79, v_175)) }, } }, _ => { Err(no_match(79, v_172)) }, } }, _ => { Err(no_match(79, v_169)) }, } }, _ => { Err(no_match(79, v_166)) }, } }, _ => { Err(no_match(79, v_163)) }, } }, _ => { Err(no_match(79, v_160)) }, } }, _ => { Err(no_match(79, v_157)) }, } }, _ => { Err(no_match(79, v_154)) }, } }, _ => { Err(no_match(79, v_151)) }, } }, _ => { Err(no_match(79, v_148)) }, } }, _ => { Err(no_match(79, v_145)) }, } }, _ => { Err(no_match(79, v_142)) }, } }, _ => { Err(no_match(79, v_139)) }, } }, _ => { Err(no_match(79, v_136)) }, } }, _ => { Err(no_match(79, v_133)) }, } }, _ => { Err(no_match(79, v_130)) }, } }, _ => { Err(no_match(79, v_127)) }, } }, _ => { Err(no_match(79, v_124)) }, } }, _ => { Err(no_match(79, v_121)) }, } }, _ => { Err(no_match(79, v_118)) }, } }, _ => { Err(no_match(79, v_115)) }, } }, _ => { Err(no_match(79, v_112)) }, } }, _ => { Err(no_match(79, v_109)) }, } }, _ => { Err(no_match(79, v_106)) }, } }, _ => { Err(no_match(79, v_103)) }, } }, _ => { Err(no_match(79, v_100)) }, } }, _ => { Err(no_match(79, v_97)) }, } }, _ => { Err(no_match(79, v_94)) }, } }, _ => { Err(no_match(79, v_91)) }, } }, _ => { Err(no_match(79, v_88)) }, } }, _ => { Err(no_match(79, v_85)) }, } }, _ => { Err(no_match(79, v_82)) }, } }, _ => { Err(no_match(79, v_79)) }, } }, _ => { Err(no_match(79, v_76)) }, } }, _ => { Err(no_match(79, v_73)) }, } }, _ => { Err(no_match(79, v_70)) }, } }, _ => { Err(no_match(79, v_67)) }, } }, _ => { Err(no_match(79, v_64)) }, } }, _ => { Err(no_match(79, v_61)) }, } }, _ => { Err(no_match(79, v_58)) }, } }, _ => { Err(no_match(79, v_55)) }, } }, _ => { Err(no_match(79, v_52)) }, } }, _ => { Err(no_match(79, v_49)) }, } }, _ => { Err(no_match(79, v_46)) }, } }, _ => { Err(no_match(79, v_43)) }, } }, _ => { Err(no_match(79, v_40)) }, } }, _ => { Err(no_match(79, v_37)) }, } }, _ => { Err(no_match(79, v_34)) }, } }, _ => { Err(no_match(79, v_31)) }, } }, _ => { Err(no_match(79, v_28)) }, } }, _ => { Err(no_match(79, v_25)) }, } }, _ => { Err(no_match(79, v_22)) }, } }, _ => { Err(no_match(79, v_19)) }, } }, _ => { Err(no_match(79, v_16)) }, } }, _ => { Err(no_match(79, v_13)) }, } }, _ => { Err(no_match(79, v_10)) }, } }, _ => { Err(no_match(79, v_7)) }, } }, _ => { Err(no_match(79, v_4)) }, } }, _ => { Err(no_match(79, v_1)) }, } } - -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(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(79, v_187)) }, } }, _ => { Err(no_match(79, v_184)) }, } }, _ => { Err(no_match(79, v_181)) }, } }, _ => { Err(no_match(79, v_178)) }, } }, _ => { Err(no_match(79, v_175)) }, } }, _ => { Err(no_match(79, v_172)) }, } }, _ => { Err(no_match(79, v_169)) }, } }, _ => { Err(no_match(79, v_166)) }, } }, _ => { Err(no_match(79, v_163)) }, } }, _ => { Err(no_match(79, v_160)) }, } }, _ => { Err(no_match(79, v_157)) }, } }, _ => { Err(no_match(79, v_154)) }, } }, _ => { Err(no_match(79, v_151)) }, } }, _ => { Err(no_match(79, v_148)) }, } }, _ => { Err(no_match(79, v_145)) }, } }, _ => { Err(no_match(79, v_142)) }, } }, _ => { Err(no_match(79, v_139)) }, } }, _ => { Err(no_match(79, v_136)) }, } }, _ => { Err(no_match(79, v_133)) }, } }, _ => { Err(no_match(79, v_130)) }, } }, _ => { Err(no_match(79, v_127)) }, } }, _ => { Err(no_match(79, v_124)) }, } }, _ => { Err(no_match(79, v_121)) }, } }, _ => { Err(no_match(79, v_118)) }, } }, _ => { Err(no_match(79, v_115)) }, } }, _ => { Err(no_match(79, v_112)) }, } }, _ => { Err(no_match(79, v_109)) }, } }, _ => { Err(no_match(79, v_106)) }, } }, _ => { Err(no_match(79, v_103)) }, } }, _ => { Err(no_match(79, v_100)) }, } }, _ => { Err(no_match(79, v_97)) }, } }, _ => { Err(no_match(79, v_94)) }, } }, _ => { Err(no_match(79, v_91)) }, } }, _ => { Err(no_match(79, v_88)) }, } }, _ => { Err(no_match(79, v_85)) }, } }, _ => { Err(no_match(79, v_82)) }, } }, _ => { Err(no_match(79, v_79)) }, } }, _ => { Err(no_match(79, v_76)) }, } }, _ => { Err(no_match(79, v_73)) }, } }, _ => { Err(no_match(79, v_70)) }, } }, _ => { Err(no_match(79, v_67)) }, } }, _ => { Err(no_match(79, v_64)) }, } }, _ => { Err(no_match(79, v_61)) }, } }, _ => { Err(no_match(79, v_58)) }, } }, _ => { Err(no_match(79, v_55)) }, } }, _ => { Err(no_match(79, v_52)) }, } }, _ => { Err(no_match(79, v_49)) }, } }, _ => { Err(no_match(79, v_46)) }, } }, _ => { Err(no_match(79, v_43)) }, } }, _ => { Err(no_match(79, v_40)) }, } }, _ => { Err(no_match(79, v_37)) }, } }, _ => { Err(no_match(79, v_34)) }, } }, _ => { Err(no_match(79, v_31)) }, } }, _ => { Err(no_match(79, v_28)) }, } }, _ => { Err(no_match(79, v_25)) }, } }, _ => { Err(no_match(79, v_22)) }, } }, _ => { Err(no_match(79, v_19)) }, } }, _ => { Err(no_match(79, v_16)) }, } }, _ => { Err(no_match(79, v_13)) }, } }, _ => { Err(no_match(79, v_10)) }, } }, _ => { Err(no_match(79, v_7)) }, } }, _ => { Err(no_match(79, v_4)) }, } }, _ => { Err(no_match(79, v_1)) }, } } - -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 => { 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(79, v_190)) }, } }, _ => { Err(no_match(79, v_187)) }, } }, _ => { Err(no_match(79, v_184)) }, } }, _ => { Err(no_match(79, v_181)) }, } }, _ => { Err(no_match(79, v_178)) }, } }, _ => { Err(no_match(79, v_175)) }, } }, _ => { Err(no_match(79, v_172)) }, } }, _ => { Err(no_match(79, v_169)) }, } }, _ => { Err(no_match(79, v_166)) }, } }, _ => { Err(no_match(79, v_163)) }, } }, _ => { Err(no_match(79, v_160)) }, } }, _ => { Err(no_match(79, v_157)) }, } }, _ => { Err(no_match(79, v_154)) }, } }, _ => { Err(no_match(79, v_151)) }, } }, _ => { Err(no_match(79, v_148)) }, } }, _ => { Err(no_match(79, v_145)) }, } }, _ => { Err(no_match(79, v_142)) }, } }, _ => { Err(no_match(79, v_139)) }, } }, _ => { Err(no_match(79, v_136)) }, } }, _ => { Err(no_match(79, v_133)) }, } }, _ => { Err(no_match(79, v_130)) }, } }, _ => { Err(no_match(79, v_127)) }, } }, _ => { Err(no_match(79, v_124)) }, } }, _ => { Err(no_match(79, v_121)) }, } }, _ => { Err(no_match(79, v_118)) }, } }, _ => { Err(no_match(79, v_115)) }, } }, _ => { Err(no_match(79, v_112)) }, } }, _ => { Err(no_match(79, v_109)) }, } }, _ => { Err(no_match(79, v_106)) }, } }, _ => { Err(no_match(79, v_103)) }, } }, _ => { Err(no_match(79, v_100)) }, } }, _ => { Err(no_match(79, v_97)) }, } }, _ => { Err(no_match(79, v_94)) }, } }, _ => { Err(no_match(79, v_91)) }, } }, _ => { Err(no_match(79, v_88)) }, } }, _ => { Err(no_match(79, v_85)) }, } }, _ => { Err(no_match(79, v_82)) }, } }, _ => { Err(no_match(79, v_79)) }, } }, _ => { Err(no_match(79, v_76)) }, } }, _ => { Err(no_match(79, v_73)) }, } }, _ => { Err(no_match(79, v_70)) }, } }, _ => { Err(no_match(79, v_67)) }, } }, _ => { Err(no_match(79, v_64)) }, } }, _ => { Err(no_match(79, v_61)) }, } }, _ => { Err(no_match(79, v_58)) }, } }, _ => { Err(no_match(79, v_55)) }, } }, _ => { Err(no_match(79, v_52)) }, } }, _ => { Err(no_match(79, v_49)) }, } }, _ => { Err(no_match(79, v_46)) }, } }, _ => { Err(no_match(79, v_43)) }, } }, _ => { Err(no_match(79, v_40)) }, } }, _ => { Err(no_match(79, v_37)) }, } }, _ => { Err(no_match(79, v_34)) }, } }, _ => { Err(no_match(79, v_31)) }, } }, _ => { Err(no_match(79, v_28)) }, } }, _ => { Err(no_match(79, v_25)) }, } }, _ => { Err(no_match(79, v_22)) }, } }, _ => { Err(no_match(79, v_19)) }, } }, _ => { Err(no_match(79, v_16)) }, } }, _ => { Err(no_match(79, v_13)) }, } }, _ => { Err(no_match(79, v_10)) }, } }, _ => { Err(no_match(79, v_7)) }, } }, _ => { Err(no_match(79, v_4)) }, } }, _ => { Err(no_match(79, v_1)) }, } } - -static SCHEMA_79: 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_81(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_8 + v_6]; let [v_18]: [G; 1] = [v_17 + v_7]; 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, 86, &[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_7 + v_151]; let [v_153]: [G; 1] = [v_2 - v_1]; let [v_154]: [G; 1] = [G::from_bool(v_153.is_zero())]; let [v_155]: [G; 1] = [v_154 * v_6]; let [v_156]: [G; 1] = [v_152 + 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, 80, &[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, 79, &[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, 86, &[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_81_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_8 + v_6]; let [v_18]: [G; 1] = [v_17 + v_7]; 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, 86, &[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_7 + v_151]; let [v_153]: [G; 1] = [v_2 - v_1]; let [v_154]: [G; 1] = [G::from_bool(v_153.is_zero())]; let [v_155]: [G; 1] = [v_154 * v_6]; let [v_156]: [G; 1] = [v_152 + 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, 80, &[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, 79, &[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, 86, &[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 write_81(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_153]: [G; 1] = [v_2 - v_1]; let [v_154]: [G; 1] = [G::from_bool(v_153.is_zero())]; row[offsets.auxiliaries + 11] = g_inverse_value(v_153).as_canonical_u64(); row[offsets.auxiliaries + 12] = v_154.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_81: 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_82(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, 79, &[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, 252, &[v_0])?; seed[71] = v_73.as_canonical_u64(); let [v_74]: [G; 1] = [v_8 * v_73]; let [v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82]: [G; 8] = context.load::<8>(6, v_3)?; seed[72] = v_75.as_canonical_u64(); seed[73] = v_76.as_canonical_u64(); seed[74] = v_77.as_canonical_u64(); seed[75] = v_78.as_canonical_u64(); seed[76] = v_79.as_canonical_u64(); seed[77] = v_80.as_canonical_u64(); seed[78] = v_81.as_canonical_u64(); seed[79] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = context.call::<1>(7, 2, &[v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82])?; seed[80] = v_83.as_canonical_u64(); let [v_84]: [G; 1] = [v_74 * 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, 86, &[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_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, 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_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82])?; 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, 252, &[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, 252, &[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_199 * v_208]; let [v_210]: [G; 1] = [v_209 * v_8]; 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_198 + v_210]; let [v_216]: [G; 1] = [v_215 + v_214]; 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, 86, &[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_82_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, 79, &[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, 252, &[v_0])?; seed.u8(192, v_73); let [v_74]: [G; 1] = [v_8 * v_73]; let [v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82]: [G; 8] = context.load::<8>(6, v_3)?; seed.u8(193, v_75); seed.u8(194, v_76); seed.u8(195, v_77); seed.u8(196, v_78); seed.u8(197, v_79); seed.u8(198, v_80); seed.u8(199, v_81); seed.u8(200, v_82); let [v_83]: [G; 1] = context.call::<1>(7, 2, &[v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82])?; seed.u8(201, v_83); let [v_84]: [G; 1] = [v_74 * 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, 86, &[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_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82, 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_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82])?; 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, 252, &[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, 252, &[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_199 * v_208]; let [v_210]: [G; 1] = [v_209 * v_8]; 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_198 + v_210]; let [v_216]: [G; 1] = [v_215 + v_214]; 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, 86, &[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 write_82(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]: [G; 1] = [v_8 * v_73]; let [v_75, v_76, v_77, v_78, v_79, v_80, v_81, v_82]: [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_75.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_76.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_77.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_78.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_79.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_80.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_81.as_canonical_u64(); row[offsets.auxiliaries + 73] = v_82.as_canonical_u64(); let [v_83]: [G; 1] = [G::from_u64(seed[80])]; row[offsets.auxiliaries + 74] = v_83.as_canonical_u64(); let [v_84]: [G; 1] = [v_74 * v_83]; row[offsets.auxiliaries + 75] = v_84.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_199 * v_208]; row[offsets.auxiliaries + 77] = v_209.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_82: 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_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 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] = [v_165 * v_167]; row[offsets.auxiliaries + 6] = v_168.as_canonical_u64(); let [v_169]: [G; 1] = [G::from_u64(2)]; let [v_170]: [G; 1] = [v_165 - v_169]; let [v_171]: [G; 1] = [v_168 * 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_200]; row[offsets.auxiliaries + 29] = v_201.as_canonical_u64(); let [v_202]: [G; 1] = [v_199 - v_169]; let [v_203]: [G; 1] = [v_201 * 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_231]; row[offsets.auxiliaries + 52] = v_232.as_canonical_u64(); let [v_233]: [G; 1] = [v_230 - v_169]; let [v_234]: [G; 1] = [v_232 * 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_262]; row[offsets.auxiliaries + 75] = v_263.as_canonical_u64(); let [v_264]: [G; 1] = [v_261 - v_169]; let [v_265]: [G; 1] = [v_263 * 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_293]; row[offsets.auxiliaries + 98] = v_294.as_canonical_u64(); let [v_295]: [G; 1] = [v_292 - v_169]; let [v_296]: [G; 1] = [v_294 * 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_324]; row[offsets.auxiliaries + 121] = v_325.as_canonical_u64(); let [v_326]: [G; 1] = [v_323 - v_169]; let [v_327]: [G; 1] = [v_325 * 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_355]; row[offsets.auxiliaries + 144] = v_356.as_canonical_u64(); let [v_357]: [G; 1] = [v_354 - v_169]; let [v_358]: [G; 1] = [v_356 * 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_386]; row[offsets.auxiliaries + 167] = v_387.as_canonical_u64(); let [v_388]: [G; 1] = [v_385 - v_169]; let [v_389]: [G; 1] = [v_387 * 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_417]; row[offsets.auxiliaries + 190] = v_418.as_canonical_u64(); let [v_419]: [G; 1] = [v_416 - v_169]; let [v_420]: [G; 1] = [v_418 * 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_448]; row[offsets.auxiliaries + 213] = v_449.as_canonical_u64(); let [v_450]: [G; 1] = [v_447 - v_169]; let [v_451]: [G; 1] = [v_449 * 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_479]; row[offsets.auxiliaries + 236] = v_480.as_canonical_u64(); let [v_481]: [G; 1] = [v_478 - v_169]; let [v_482]: [G; 1] = [v_480 * 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_510]; row[offsets.auxiliaries + 259] = v_511.as_canonical_u64(); let [v_512]: [G; 1] = [v_509 - v_169]; let [v_513]: [G; 1] = [v_511 * 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_541]; row[offsets.auxiliaries + 282] = v_542.as_canonical_u64(); let [v_543]: [G; 1] = [v_540 - v_169]; let [v_544]: [G; 1] = [v_542 * 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_572]; row[offsets.auxiliaries + 305] = v_573.as_canonical_u64(); let [v_574]: [G; 1] = [v_571 - v_169]; let [v_575]: [G; 1] = [v_573 * 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_603]; row[offsets.auxiliaries + 328] = v_604.as_canonical_u64(); let [v_605]: [G; 1] = [v_602 - v_169]; let [v_606]: [G; 1] = [v_604 * 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_634]; row[offsets.auxiliaries + 351] = v_635.as_canonical_u64(); let [v_636]: [G; 1] = [v_633 - v_169]; let [v_637]: [G; 1] = [v_635 * 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_103(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, 90, &[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, 90, &[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, 91, &[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, 90, &[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, 88, &[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, 89, &[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, 96, &[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, 89, &[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, 97, &[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, 89, &[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, 99, &[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, 100, &[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, 103, &[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_103_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, 90, &[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, 90, &[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, 91, &[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, 90, &[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, 88, &[v_44])?; seed.full(128, v_45); seed.u32(196, v_46); let [v_47, v_48]: [G; 2] = context.call::<2>(8, 89, &[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, 96, &[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, 89, &[v_51])?; seed.full(144, v_52); seed.u32(212, v_53); let [v_54, v_55]: [G; 2] = context.call::<2>(12, 97, &[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, 89, &[v_55])?; seed.full(152, v_56); seed.u32(224, v_57); let [v_58, v_59]: [G; 2] = context.call::<2>(14, 99, &[v_57, v_56])?; seed.u32(228, v_58); seed.u32(232, v_59); let [v_60]: [G; 1] = context.call::<1>(15, 100, &[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, 103, &[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 write_103(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] = [v_69 + v_70]; let [v_95]: [G; 1] = [v_94 + v_71]; let [v_96]: [G; 1] = [v_95 + v_72]; let [v_97]: [G; 1] = [G::from_u64(1020)]; let [v_98]: [G; 1] = [v_96 - 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_65 + v_66]; let [v_101]: [G; 1] = [v_100 + v_67]; let [v_102]: [G; 1] = [v_101 + v_68]; 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_112 + v_113]; let [v_131]: [G; 1] = [v_130 + v_114]; let [v_132]: [G; 1] = [v_131 + v_115]; let [v_133]: [G; 1] = [v_132 - v_97]; 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_108 + v_109]; let [v_136]: [G; 1] = [v_135 + v_110]; let [v_137]: [G; 1] = [v_136 + v_111]; 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_146 + v_147]; let [v_165]: [G; 1] = [v_164 + v_148]; let [v_166]: [G; 1] = [v_165 + v_149]; let [v_167]: [G; 1] = [v_166 - v_97]; 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_142 + v_143]; let [v_170]: [G; 1] = [v_169 + v_144]; let [v_171]: [G; 1] = [v_170 + v_145]; 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_103: 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_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_16 + v_125]; let [v_194]: [G; 1] = [v_193 + v_136]; let [v_195]: [G; 1] = [v_194 + v_147]; let [v_196]: [G; 1] = [v_195 + v_158]; let [v_197]: [G; 1] = [v_196 + v_169]; let [v_198]: [G; 1] = [v_197 + v_180]; let [v_199]: [G; 1] = [v_198 + v_191]; 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_217 * v_220]; let [v_224]: [G; 1] = [v_222 - 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] = [v_221 + v_236]; let [v_238]: [G; 1] = [G::from_u64(8)]; let [v_239]: [G; 1] = [v_238 * v_234]; let [v_240]: [G; 1] = [v_237 + 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, 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_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_16 + v_125]; let [v_194]: [G; 1] = [v_193 + v_136]; let [v_195]: [G; 1] = [v_194 + v_147]; let [v_196]: [G; 1] = [v_195 + v_158]; let [v_197]: [G; 1] = [v_196 + v_169]; let [v_198]: [G; 1] = [v_197 + v_180]; let [v_199]: [G; 1] = [v_198 + v_191]; 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_217 * v_220]; let [v_224]: [G; 1] = [v_222 - 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] = [v_221 + v_236]; let [v_238]: [G; 1] = [G::from_u64(8)]; let [v_239]: [G; 1] = [v_238 * v_234]; let [v_240]: [G; 1] = [v_237 + 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, 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 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_223]: [G; 1] = [v_217 * v_220]; row[offsets.auxiliaries + 109] = v_223.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_175(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, 108, &[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, 108, &[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, 108, &[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, 108, &[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, 108, &[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, 108, &[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, 108, &[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, 108, &[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, 129, &[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(175, v_102)) }, } }, _ => { Err(no_match(175, v_99)) }, } }, _ => { Err(no_match(175, v_96)) }, } }, _ => { Err(no_match(175, v_93)) }, } }, _ => { Err(no_match(175, v_90)) }, } }, _ => { Err(no_match(175, v_87)) }, } }, _ => { Err(no_match(175, 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(175, v_123)) }, } }, _ => { Err(no_match(175, v_120)) }, } }, _ => { Err(no_match(175, v_117)) }, } }, _ => { Err(no_match(175, v_114)) }, } }, _ => { Err(no_match(175, v_111)) }, } }, _ => { Err(no_match(175, v_108)) }, } }, _ => { Err(no_match(175, v_2)) }, } } - -fn pack_175_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, 108, &[v_71, v_72, v_73, v_74, v_37])?; seed.u32(384, v_75); let [v_76]: [G; 1] = context.call::<1>(41, 108, &[v_67, v_68, v_69, v_70, v_75])?; seed.u32(388, v_76); let [v_77]: [G; 1] = context.call::<1>(42, 108, &[v_63, v_64, v_65, v_66, v_76])?; seed.u32(392, v_77); let [v_78]: [G; 1] = context.call::<1>(43, 108, &[v_59, v_60, v_61, v_62, v_77])?; seed.u32(396, v_78); let [v_79]: [G; 1] = context.call::<1>(44, 108, &[v_55, v_56, v_57, v_58, v_78])?; seed.u32(400, v_79); let [v_80]: [G; 1] = context.call::<1>(45, 108, &[v_51, v_52, v_53, v_54, v_79])?; seed.u32(404, v_80); let [v_81]: [G; 1] = context.call::<1>(46, 108, &[v_47, v_48, v_49, v_50, v_80])?; seed.u32(408, v_81); let [v_82]: [G; 1] = context.call::<1>(47, 108, &[v_43, v_44, v_45, v_46, v_81])?; seed.u32(412, v_82); let [v_83]: [G; 1] = context.call::<1>(48, 129, &[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(175, v_102)) }, } }, _ => { Err(no_match(175, v_99)) }, } }, _ => { Err(no_match(175, v_96)) }, } }, _ => { Err(no_match(175, v_93)) }, } }, _ => { Err(no_match(175, v_90)) }, } }, _ => { Err(no_match(175, v_87)) }, } }, _ => { Err(no_match(175, 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(175, v_123)) }, } }, _ => { Err(no_match(175, v_120)) }, } }, _ => { Err(no_match(175, v_117)) }, } }, _ => { Err(no_match(175, v_114)) }, } }, _ => { Err(no_match(175, v_111)) }, } }, _ => { Err(no_match(175, v_108)) }, } }, _ => { Err(no_match(175, v_2)) }, } } - -fn write_175(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(175, v_105)) }, } }, _ => { Err(no_match(175, v_102)) }, } }, _ => { Err(no_match(175, v_99)) }, } }, _ => { Err(no_match(175, v_96)) }, } }, _ => { Err(no_match(175, v_93)) }, } }, _ => { Err(no_match(175, v_90)) }, } }, _ => { Err(no_match(175, v_87)) }, } }, _ => { Err(no_match(175, 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(175, v_126)) }, } }, _ => { Err(no_match(175, v_123)) }, } }, _ => { Err(no_match(175, v_120)) }, } }, _ => { Err(no_match(175, v_117)) }, } }, _ => { Err(no_match(175, v_114)) }, } }, _ => { Err(no_match(175, v_111)) }, } }, _ => { Err(no_match(175, v_108)) }, } }, _ => { Err(no_match(175, v_2)) }, } } - -static SCHEMA_175: 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_203(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, 242, &[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, 201, &[v_24])?; seed[33] = v_36.as_canonical_u64(); let [v_37, v_38]: [G; 2] = context.call::<2>(8, 253, &[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, 242, &[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, 242, &[v_39, v_40])?; seed[37] = v_41.as_canonical_u64(); let [v_42]: [G; 1] = context.call::<1>(12, 242, &[v_39, v_35])?; seed[38] = v_42.as_canonical_u64(); let [v_43]: [G; 1] = context.call::<1>(13, 242, &[v_5, v_9])?; seed[39] = v_43.as_canonical_u64(); let [v_44]: [G; 1] = context.call::<1>(14, 242, &[v_43, v_40])?; seed[40] = v_44.as_canonical_u64(); let [v_45]: [G; 1] = context.call::<1>(15, 242, &[v_43, v_35])?; seed[41] = v_45.as_canonical_u64(); let [v_46, v_47]: [G; 2] = context.call::<2>(16, 253, &[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, 242, &[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, 242, &[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, 242, &[v_52, v_55])?; seed[46] = v_56.as_canonical_u64(); break 'yield_0 [v_54, v_56]; }, _ => { return Err(no_match(203, v_6)); }, } }, _ => { return Err(no_match(203, v_46)); }, } }; let [v_59]: [G; 1] = context.call::<1>(26, 245, &[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, 245, &[v_42])?; seed[48] = v_63.as_canonical_u64(); let [v_66]: [G; 1] = context.call::<1>(35, 245, &[v_44])?; seed[49] = v_66.as_canonical_u64(); let [v_69]: [G; 1] = context.call::<1>(39, 245, &[v_45])?; seed[50] = v_69.as_canonical_u64(); let [v_72]: [G; 1] = context.call::<1>(43, 245, &[v_57])?; seed[51] = v_72.as_canonical_u64(); let [v_75]: [G; 1] = context.call::<1>(47, 245, &[v_58])?; seed[52] = v_75.as_canonical_u64(); let [v_78, v_79]: [G; 2] = context.call::<2>(51, 185, &[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, 186, &[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, 188, &[v_32])?; seed[65] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = context.call::<1>(130, 186, &[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, 194, &[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, 253, &[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, 253, &[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, 190, &[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, 253, &[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, 253, &[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, 190, &[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, 245, &[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, 197, &[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(203, v_187)); }, } }; let [v_220]: [G; 1] = context.call::<1>(189, 242, &[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, 242, &[v_220, v_221])?; seed[86] = v_222.as_canonical_u64(); let [v_223]: [G; 1] = context.call::<1>(192, 192, &[v_222])?; seed[87] = v_223.as_canonical_u64(); let [v_224]: [G; 1] = context.call::<1>(193, 245, &[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, 185, &[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, 200, &[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(203, v_20)) }, } } - -fn pack_203_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, 242, &[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, 201, &[v_24])?; seed.u8(607, v_36); let [v_37, v_38]: [G; 2] = context.call::<2>(8, 253, &[v_3, v_9])?; seed.full(200, v_37); seed.full(208, v_38); let [v_39]: [G; 1] = context.call::<1>(9, 242, &[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, 242, &[v_39, v_40])?; seed.u32(532, v_41); let [v_42]: [G; 1] = context.call::<1>(12, 242, &[v_39, v_35])?; seed.u32(536, v_42); let [v_43]: [G; 1] = context.call::<1>(13, 242, &[v_5, v_9])?; seed.full(224, v_43); let [v_44]: [G; 1] = context.call::<1>(14, 242, &[v_43, v_40])?; seed.u32(540, v_44); let [v_45]: [G; 1] = context.call::<1>(15, 242, &[v_43, v_35])?; seed.u32(544, v_45); let [v_46, v_47]: [G; 2] = context.call::<2>(16, 253, &[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, 242, &[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, 242, &[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, 242, &[v_52, v_55])?; seed.u32(552, v_56); break 'yield_0 [v_54, v_56]; }, _ => { return Err(no_match(203, v_6)); }, } }, _ => { return Err(no_match(203, v_46)); }, } }; let [v_59]: [G; 1] = context.call::<1>(26, 245, &[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, 245, &[v_42])?; seed.full(256, v_63); let [v_66]: [G; 1] = context.call::<1>(35, 245, &[v_44])?; seed.full(264, v_66); let [v_69]: [G; 1] = context.call::<1>(39, 245, &[v_45])?; seed.full(272, v_69); let [v_72]: [G; 1] = context.call::<1>(43, 245, &[v_57])?; seed.full(280, v_72); let [v_75]: [G; 1] = context.call::<1>(47, 245, &[v_58])?; seed.full(288, v_75); let [v_78, v_79]: [G; 2] = context.call::<2>(51, 185, &[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, 186, &[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, 188, &[v_32])?; seed.full(320, v_149); let [v_150]: [G; 1] = context.call::<1>(130, 186, &[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, 194, &[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, 253, &[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, 253, &[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, 190, &[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, 253, &[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, 253, &[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, 190, &[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, 245, &[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, 197, &[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(203, v_187)); }, } }; let [v_220]: [G; 1] = context.call::<1>(189, 242, &[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, 242, &[v_220, v_221])?; seed.u32(596, v_222); let [v_223]: [G; 1] = context.call::<1>(192, 192, &[v_222])?; seed.u32(600, v_223); let [v_224]: [G; 1] = context.call::<1>(193, 245, &[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, 185, &[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, 200, &[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(203, v_20)) }, } } - -fn write_203(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(203, v_6)); }, } }, _ => { return Err(no_match(203, 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(203, 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(203, v_20)) }, } } - -static SCHEMA_203: 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_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 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 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![], 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]) }), (G::from_u64(1), Block { ops: vec![Op::IORead(0, 1, 1), Op::U8RangeCheck(3, 3), Op::Const(G::from_u64(0)), Op::Const(G::from_u64(1)), Op::Store(vec![5, 5, 5]), Op::Store(vec![4, 3, 6])], ctrl: Ctrl::Return(1, vec![7]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::IORead(0, 1, 2), Op::U8RangeCheck(3, 4), Op::Const(G::from_u64(2)), Op::Add(1, 5), Op::Sub(2, 5), Op::Call(1, vec![0, 6, 7], 1, false), Op::Const(G::from_u64(0)), Op::Store(vec![9, 4, 8]), Op::Store(vec![9, 3, 10])], ctrl: Ctrl::Return(2, vec![11]) }))) }, layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 8, lookups: 5 }, entry: false, constrained: true } -} - -#[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::Mul(16, 18), Op::Const(G::from_u64(2)), Op::Sub(16, 20), Op::Mul(19, 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::Add(0, 10), Op::Const(G::from_u64(65536)), Op::Mul(12, 2), Op::Add(11, 13), Op::Const(G::from_u64(16777216)), Op::Mul(15, 3), Op::Add(14, 16), Op::Const(G::from_u64(4294967296)), Op::Mul(18, 4), Op::Add(17, 19), Op::Const(G::from_u64(1099511627776)), Op::Mul(21, 5), Op::Add(20, 22), Op::Const(G::from_u64(281474976710656)), Op::Mul(24, 6), Op::Add(23, 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::Add(0, 9), Op::Const(G::from_u64(65536)), Op::Mul(11, 2), Op::Add(10, 12), Op::Const(G::from_u64(16777216)), Op::Mul(14, 3), Op::Add(13, 15), Op::Const(G::from_u64(4294967296)), Op::Mul(17, 4), Op::Add(16, 18), Op::Const(G::from_u64(1099511627776)), Op::Mul(20, 5), Op::Add(19, 21), Op::Const(G::from_u64(281474976710656)), Op::Mul(23, 6), Op::Add(22, 24), Op::Const(G::from_u64(72057594037927936)), Op::Mul(26, 7), Op::Add(25, 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::Add(4, 5), Op::Add(8, 6), Op::Add(9, 7), Op::Const(G::from_u64(1020)), Op::Sub(10, 11), Op::EqZero(12), Op::Add(0, 1), Op::Add(14, 2), Op::Add(15, 3), 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::Add(1, 10), Op::Const(G::from_u64(65536)), Op::Mul(12, 3), Op::Add(11, 13), Op::Const(G::from_u64(16777216)), Op::Mul(15, 4), Op::Add(14, 16), Op::Const(G::from_u64(4294967296)), Op::Mul(18, 5), Op::Add(17, 19), Op::Const(G::from_u64(1099511627776)), Op::Mul(21, 6), Op::Add(20, 22), Op::Const(G::from_u64(281474976710656)), Op::Mul(24, 7), Op::Add(23, 25), Op::Const(G::from_u64(72057594037927936)), Op::Mul(27, 8), Op::Add(26, 28), Op::AssertEq(vec![29], vec![0], None), Op::Add(5, 6), Op::Add(30, 7), Op::Add(31, 8), Op::Const(G::from_u64(1020)), Op::Sub(32, 33), Op::EqZero(34), Op::Add(1, 2), Op::Add(36, 3), Op::Add(37, 4), 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::Add(1, 20), Op::Const(G::from_u64(65536)), Op::Mul(22, 3), Op::Add(21, 23), Op::Const(G::from_u64(16777216)), Op::Mul(25, 4), Op::Add(24, 26), Op::Const(G::from_u64(4294967296)), Op::Mul(28, 5), Op::Add(27, 29), Op::Const(G::from_u64(1099511627776)), Op::Mul(31, 6), Op::Add(30, 32), Op::Const(G::from_u64(281474976710656)), Op::Mul(34, 7), Op::Add(33, 35), Op::Const(G::from_u64(72057594037927936)), Op::Mul(37, 8), Op::Add(36, 38), Op::Mul(19, 11), Op::Add(10, 40), Op::Mul(22, 12), Op::Add(41, 42), Op::Mul(25, 13), Op::Add(43, 44), Op::Mul(28, 14), Op::Add(45, 46), Op::Mul(31, 15), Op::Add(47, 48), Op::Mul(34, 16), Op::Add(49, 50), Op::Mul(37, 17), Op::Add(51, 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::Add(2, 21), Op::Const(G::from_u64(65536)), Op::Mul(23, 4), Op::Add(22, 24), Op::Const(G::from_u64(16777216)), Op::Mul(26, 5), Op::Add(25, 27), Op::Const(G::from_u64(4294967296)), Op::Mul(29, 6), Op::Add(28, 30), Op::Const(G::from_u64(1099511627776)), Op::Mul(32, 7), Op::Add(31, 33), Op::Const(G::from_u64(281474976710656)), Op::Mul(35, 8), Op::Add(34, 36), Op::Const(G::from_u64(72057594037927936)), Op::Mul(38, 9), Op::Add(37, 39), Op::Mul(20, 12), Op::Add(11, 41), Op::Mul(23, 13), Op::Add(42, 43), Op::Mul(26, 14), Op::Add(44, 45), Op::Mul(29, 15), Op::Add(46, 47), Op::Mul(32, 16), Op::Add(48, 49), Op::Mul(35, 17), Op::Add(50, 51), Op::Mul(38, 18), Op::Add(52, 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::Add(0, 5), Op::Const(G::from_u64(65536)), Op::Mul(7, 2), Op::Add(6, 8), Op::Const(G::from_u64(16777216)), Op::Mul(10, 3), Op::Add(9, 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::Add(0, 33), Op::Const(G::from_u64(65536)), Op::Mul(35, 2), Op::Add(34, 36), Op::Const(G::from_u64(16777216)), Op::Mul(38, 3), Op::Add(37, 39), Op::Mul(32, 5), Op::Add(4, 41), Op::Mul(35, 6), Op::Add(42, 43), Op::Mul(38, 7), Op::Add(44, 45), Op::Mul(32, 9), Op::Add(8, 47), Op::Mul(35, 10), Op::Add(48, 49), Op::Mul(38, 11), Op::Add(50, 51), Op::Mul(32, 13), Op::Add(12, 53), Op::Mul(35, 14), Op::Add(54, 55), Op::Mul(38, 15), Op::Add(56, 57), Op::Mul(32, 17), Op::Add(16, 59), Op::Mul(35, 18), Op::Add(60, 61), Op::Mul(38, 19), Op::Add(62, 63), Op::Mul(32, 21), Op::Add(20, 65), Op::Mul(35, 22), Op::Add(66, 67), Op::Mul(38, 23), Op::Add(68, 69), Op::Mul(32, 25), Op::Add(24, 71), Op::Mul(35, 26), Op::Add(72, 73), Op::Mul(38, 27), Op::Add(74, 75), Op::Mul(32, 29), Op::Add(28, 77), Op::Mul(35, 30), Op::Add(78, 79), Op::Mul(38, 31), Op::Add(80, 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(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_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(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::Load(3, 9)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Call(81, vec![11, 13, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(2, vec![18]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![18, 16, 11])], ctrl: Ctrl::Match(13, [(G::from_u64(63), Block { ops: vec![Op::Call(82, vec![17, 19, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(3, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(13, 20), Op::Add(14, 20), Op::Load(3, 17)], ctrl: Ctrl::Match(23, [(G::from_u64(1), Block { ops: vec![Op::Call(81, vec![19, 21, 22, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(4, vec![26]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![26, 24, 19])], ctrl: Ctrl::Match(21, [(G::from_u64(63), Block { ops: vec![Op::Call(82, vec![25, 27, 22, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(5, vec![28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(21, 28), Op::Add(22, 28), Op::Load(3, 25)], ctrl: Ctrl::Match(31, [(G::from_u64(1), Block { ops: vec![Op::Call(81, vec![27, 29, 30, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(6, vec![34]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![34, 32, 27])], ctrl: Ctrl::Match(29, [(G::from_u64(63), Block { ops: vec![Op::Call(82, vec![33, 35, 30, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(7, vec![36]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(29, 36), Op::Add(30, 36), Op::Call(75, vec![33, 35, 37, 38, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(8, vec![39]) }))) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 9, auxiliaries: 22, lookups: 10 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_76() -> 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::Load(3, 9)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Call(81, vec![11, 13, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(2, vec![18]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![18, 16, 11])], ctrl: Ctrl::Match(13, [(G::from_u64(63), Block { ops: vec![Op::Call(82, vec![17, 19, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(3, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(13, 20), Op::Add(14, 20), Op::Load(3, 17)], ctrl: Ctrl::Match(23, [(G::from_u64(1), Block { ops: vec![Op::Call(81, vec![19, 21, 22, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(4, vec![26]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![26, 24, 19])], ctrl: Ctrl::Match(21, [(G::from_u64(63), Block { ops: vec![Op::Call(82, vec![25, 27, 22, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(5, vec![28]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(21, 28), Op::Add(22, 28), Op::Call(75, vec![25, 27, 29, 30, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(6, vec![31]) }))) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 7, auxiliaries: 17, lookups: 8 }, entry: false, constrained: false } -} - -#[inline(never)] -fn expected_function_77() -> 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::Load(3, 9)], ctrl: Ctrl::Match(15, [(G::from_u64(1), Block { ops: vec![Op::Call(81, vec![11, 13, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(2, vec![18]) }), (G::from_u64(0), Block { ops: vec![Op::Const(G::from_u64(0)), Op::Store(vec![18, 16, 11])], ctrl: Ctrl::Match(13, [(G::from_u64(63), Block { ops: vec![Op::Call(82, vec![17, 19, 14, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(3, vec![20]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Const(G::from_u64(1)), Op::Add(13, 20), Op::Add(14, 20), Op::Call(75, vec![17, 19, 21, 22, 4, 5, 6], 1, false)], ctrl: Ctrl::Return(4, vec![23]) }))) })].into_iter().collect(), None) }))) })].into_iter().collect(), None) }, layout: FunctionLayout { input_size: 7, selectors: 5, auxiliaries: 12, lookups: 6 }, entry: false, constrained: false } -} - -#[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(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: false } -} - -#[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(8, 6), Op::Add(17, 7), 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(2, vec![9, 10, 11, 12, 13, 14, 15, 16], 1, false), Op::Mul(17, 8), Op::Add(7, 18), Op::Sub(2, 1), Op::EqZero(20), Op::Mul(21, 6), Op::Add(19, 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(252, vec![0], 1, false), Op::Mul(8, 73), Op::Load(8, 3), Op::Call(2, vec![75, 76, 77, 78, 79, 80, 81, 82], 1, false), Op::Mul(74, 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, 75, 76, 77, 78, 79, 80, 81, 82, 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![75, 76, 77, 78, 79, 80, 81, 82], 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(252, vec![0], 1, false), Op::Mul(73, 7), Op::Call(252, vec![0], 1, false), Op::Load(8, 3), Op::Call(2, vec![76, 77, 78, 79, 80, 81, 82, 83], 1, false), Op::Mul(75, 84), Op::Mul(85, 8), Op::Const(G::from_u64(63)), Op::Sub(2, 87), Op::EqZero(88), Op::Mul(89, 6), Op::Add(74, 86), Op::Add(91, 90), 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(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_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::Mul(28, 30), Op::Const(G::from_u64(2)), Op::Sub(28, 32), Op::Mul(31, 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::Mul(62, 63), Op::Sub(62, 32), Op::Mul(64, 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::Mul(132, 134), Op::Const(G::from_u64(2)), Op::Sub(132, 136), Op::Mul(135, 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::Mul(166, 167), Op::Sub(166, 136), Op::Mul(168, 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::Mul(197, 198), Op::Sub(197, 136), Op::Mul(199, 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::Mul(228, 229), Op::Sub(228, 136), Op::Mul(230, 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::Mul(259, 260), Op::Sub(259, 136), Op::Mul(261, 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::Mul(290, 291), Op::Sub(290, 136), Op::Mul(292, 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::Mul(321, 322), Op::Sub(321, 136), Op::Mul(323, 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::Mul(352, 353), Op::Sub(352, 136), Op::Mul(354, 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::Mul(383, 384), Op::Sub(383, 136), Op::Mul(385, 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::Mul(414, 415), Op::Sub(414, 136), Op::Mul(416, 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::Mul(445, 446), Op::Sub(445, 136), Op::Mul(447, 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::Mul(476, 477), Op::Sub(476, 136), Op::Mul(478, 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::Mul(507, 508), Op::Sub(507, 136), Op::Mul(509, 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::Mul(538, 539), Op::Sub(538, 136), Op::Mul(540, 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::Mul(569, 570), Op::Sub(569, 136), Op::Mul(571, 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::Mul(600, 601), Op::Sub(600, 136), Op::Mul(602, 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::Mul(133, 135), Op::Const(G::from_u64(2)), Op::Sub(133, 137), Op::Mul(136, 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::Mul(167, 168), Op::Sub(167, 137), Op::Mul(169, 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::Mul(198, 199), Op::Sub(198, 137), Op::Mul(200, 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::Mul(229, 230), Op::Sub(229, 137), Op::Mul(231, 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::Mul(260, 261), Op::Sub(260, 137), Op::Mul(262, 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::Mul(291, 292), Op::Sub(291, 137), Op::Mul(293, 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::Mul(322, 323), Op::Sub(322, 137), Op::Mul(324, 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::Mul(353, 354), Op::Sub(353, 137), Op::Mul(355, 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::Mul(384, 385), Op::Sub(384, 137), Op::Mul(386, 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::Mul(415, 416), Op::Sub(415, 137), Op::Mul(417, 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::Mul(446, 447), Op::Sub(446, 137), Op::Mul(448, 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::Mul(477, 478), Op::Sub(477, 137), Op::Mul(479, 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::Mul(508, 509), Op::Sub(508, 137), Op::Mul(510, 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::Mul(539, 540), Op::Sub(539, 137), Op::Mul(541, 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::Mul(570, 571), Op::Sub(570, 137), Op::Mul(572, 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::Mul(601, 602), Op::Sub(601, 137), Op::Mul(603, 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::Add(1, 10), Op::Const(G::from_u64(65536)), Op::Mul(12, 5), Op::Add(11, 13), Op::Const(G::from_u64(16777216)), Op::Mul(15, 7), Op::Add(14, 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::Add(1, 11), Op::Const(G::from_u64(65536)), Op::Mul(13, 3), Op::Add(12, 14), Op::Const(G::from_u64(16777216)), Op::Mul(16, 4), Op::Add(15, 17), Op::Const(G::from_u64(4294967296)), Op::Mul(19, 5), Op::Add(18, 20), Op::Const(G::from_u64(1099511627776)), Op::Mul(22, 6), Op::Add(21, 23), Op::Const(G::from_u64(281474976710656)), Op::Mul(25, 7), Op::Add(24, 26), Op::Const(G::from_u64(72057594037927936)), Op::Mul(28, 8), Op::Add(27, 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::Add(61, 70), Op::Const(G::from_u64(65536)), Op::Mul(72, 63), Op::Add(71, 73), Op::Const(G::from_u64(16777216)), Op::Mul(75, 64), Op::Add(74, 76), Op::Const(G::from_u64(4294967296)), Op::Mul(78, 65), Op::Add(77, 79), Op::Const(G::from_u64(1099511627776)), Op::Mul(81, 66), Op::Add(80, 82), Op::Const(G::from_u64(281474976710656)), Op::Mul(84, 67), Op::Add(83, 85), Op::Const(G::from_u64(72057594037927936)), Op::Mul(87, 68), Op::Add(86, 88), Op::AssertEq(vec![89], vec![60], None), Op::Add(65, 66), Op::Add(90, 67), Op::Add(91, 68), Op::Const(G::from_u64(1020)), Op::Sub(92, 93), Op::EqZero(94), Op::Add(61, 62), Op::Add(96, 63), Op::Add(97, 64), 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::Add(104, 112), Op::Mul(72, 106), Op::Add(113, 114), Op::Mul(75, 107), Op::Add(115, 116), Op::Mul(78, 108), Op::Add(117, 118), Op::Mul(81, 109), Op::Add(119, 120), Op::Mul(84, 110), Op::Add(121, 122), Op::Mul(87, 111), Op::Add(123, 124), Op::AssertEq(vec![125], vec![59], None), Op::Add(108, 109), Op::Add(126, 110), Op::Add(127, 111), Op::Sub(128, 93), Op::EqZero(129), Op::Add(104, 105), Op::Add(131, 106), Op::Add(132, 107), 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::Add(138, 146), Op::Mul(72, 140), Op::Add(147, 148), Op::Mul(75, 141), Op::Add(149, 150), Op::Mul(78, 142), Op::Add(151, 152), Op::Mul(81, 143), Op::Add(153, 154), Op::Mul(84, 144), Op::Add(155, 156), Op::Mul(87, 145), Op::Add(157, 158), Op::AssertEq(vec![159], vec![41], None), Op::Add(142, 143), Op::Add(160, 144), Op::Add(161, 145), Op::Sub(162, 93), Op::EqZero(163), Op::Add(138, 139), Op::Add(165, 140), Op::Add(166, 141), 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::Add(62, 71), Op::Const(G::from_u64(65536)), Op::Mul(73, 64), Op::Add(72, 74), Op::Const(G::from_u64(16777216)), Op::Mul(76, 65), Op::Add(75, 77), Op::Const(G::from_u64(4294967296)), Op::Mul(79, 66), Op::Add(78, 80), Op::Const(G::from_u64(1099511627776)), Op::Mul(82, 67), Op::Add(81, 83), Op::Const(G::from_u64(281474976710656)), Op::Mul(85, 68), Op::Add(84, 86), Op::Const(G::from_u64(72057594037927936)), Op::Mul(88, 69), Op::Add(87, 89), Op::AssertEq(vec![90], vec![61], None), Op::Add(66, 67), Op::Add(91, 68), Op::Add(92, 69), Op::Const(G::from_u64(1020)), Op::Sub(93, 94), Op::EqZero(95), Op::Add(62, 63), Op::Add(97, 64), Op::Add(98, 65), 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::Add(105, 113), Op::Mul(73, 107), Op::Add(114, 115), Op::Mul(76, 108), Op::Add(116, 117), Op::Mul(79, 109), Op::Add(118, 119), Op::Mul(82, 110), Op::Add(120, 121), Op::Mul(85, 111), Op::Add(122, 123), Op::Mul(88, 112), Op::Add(124, 125), Op::AssertEq(vec![126], vec![60], None), Op::Add(109, 110), Op::Add(127, 111), Op::Add(128, 112), Op::Sub(129, 94), Op::EqZero(130), Op::Add(105, 106), Op::Add(132, 107), Op::Add(133, 108), 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::Add(139, 147), Op::Mul(73, 141), Op::Add(148, 149), Op::Mul(76, 142), Op::Add(150, 151), Op::Mul(79, 143), Op::Add(152, 153), Op::Mul(82, 144), Op::Add(154, 155), Op::Mul(85, 145), Op::Add(156, 157), Op::Mul(88, 146), Op::Add(158, 159), Op::AssertEq(vec![160], vec![42], None), Op::Add(143, 144), Op::Add(161, 145), Op::Add(162, 146), Op::Sub(163, 94), Op::EqZero(164), Op::Add(139, 140), Op::Add(166, 141), Op::Add(167, 142), 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(254, 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::Add(3, 13), Op::Const(G::from_u64(65536)), Op::Mul(15, 5), Op::Add(14, 16), Op::Const(G::from_u64(16777216)), Op::Mul(18, 6), Op::Add(17, 19), Op::Const(G::from_u64(4294967296)), Op::Mul(21, 7), Op::Add(20, 22), Op::Const(G::from_u64(1099511627776)), Op::Mul(24, 8), Op::Add(23, 25), Op::Const(G::from_u64(281474976710656)), Op::Mul(27, 9), Op::Add(26, 28), Op::Const(G::from_u64(72057594037927936)), Op::Mul(30, 10), Op::Add(29, 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::Add(33, 41), Op::Mul(15, 35), Op::Add(42, 43), Op::Mul(18, 36), Op::Add(44, 45), Op::Mul(21, 37), Op::Add(46, 47), Op::Mul(24, 38), Op::Add(48, 49), Op::Mul(27, 39), Op::Add(50, 51), Op::Mul(30, 40), Op::Add(52, 53), Op::AssertEq(vec![54], vec![32], None), Op::Add(37, 38), Op::Add(55, 39), Op::Add(56, 40), Op::Const(G::from_u64(1020)), Op::Sub(57, 58), Op::EqZero(59), Op::Add(33, 34), Op::Add(61, 35), Op::Add(62, 36), 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(16, 27), Op::Add(95, 38), Op::Add(96, 49), Op::Add(97, 60), Op::Add(98, 71), Op::Add(99, 82), Op::Add(100, 93), 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::Add(113, 116), Op::Mul(113, 116), Op::Sub(118, 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::Add(117, 132), Op::Const(G::from_u64(8)), Op::Mul(134, 130), Op::Add(133, 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(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(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(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_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(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_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(244, 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(244, vec![1], 1, false), Op::Call(244, 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(244, 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(247, 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(242, 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![Op::Load(4, 1)], ctrl: Ctrl::Match(18, [(G::from_u64(1), Block { ops: vec![], ctrl: Ctrl::Return(0, vec![4, 5, 6, 7]) })].into_iter().collect(), None) }), (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::Add(9, 23), Op::Const(G::from_u64(65536)), Op::Mul(25, 11), Op::Add(24, 26), Op::Const(G::from_u64(16777216)), Op::Mul(28, 12), Op::Add(27, 29), Op::Const(G::from_u64(4294967296)), Op::Mul(31, 13), Op::Add(30, 32), Op::Const(G::from_u64(1099511627776)), Op::Mul(34, 14), Op::Add(33, 35), Op::Const(G::from_u64(281474976710656)), Op::Mul(37, 15), Op::Add(36, 38), Op::Const(G::from_u64(72057594037927936)), Op::Mul(40, 16), Op::Add(39, 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::Add(6, 15), Op::Const(G::from_u64(65536)), Op::Mul(17, 8), Op::Add(16, 18), Op::Const(G::from_u64(16777216)), Op::Mul(20, 9), Op::Add(19, 21), Op::Const(G::from_u64(4294967296)), Op::Mul(23, 10), Op::Add(22, 24), Op::Const(G::from_u64(1099511627776)), Op::Mul(26, 11), Op::Add(25, 27), Op::Const(G::from_u64(281474976710656)), Op::Mul(29, 12), Op::Add(28, 30), Op::Const(G::from_u64(72057594037927936)), Op::Mul(32, 13), Op::Add(31, 33), Op::AssertEq(vec![34], vec![3], None), Op::Add(10, 11), Op::Add(35, 12), Op::Add(36, 13), Op::Const(G::from_u64(1020)), Op::Sub(37, 38), Op::EqZero(39), Op::Add(6, 7), Op::Add(41, 8), Op::Add(42, 9), 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::Add(49, 57), Op::Mul(17, 51), Op::Add(58, 59), Op::Mul(20, 52), Op::Add(60, 61), Op::Mul(23, 53), Op::Add(62, 63), Op::Mul(26, 54), Op::Add(64, 65), Op::Mul(29, 55), Op::Add(66, 67), Op::Mul(32, 56), Op::Add(68, 69), Op::AssertEq(vec![70], vec![4], None), Op::Add(53, 54), Op::Add(71, 55), Op::Add(72, 56), Op::Sub(73, 38), Op::EqZero(74), Op::Add(49, 50), Op::Add(76, 51), Op::Add(77, 52), 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::Add(20, 41), Op::Const(G::from_u64(65536)), Op::Mul(43, 22), Op::Add(42, 44), Op::Const(G::from_u64(16777216)), Op::Mul(46, 23), Op::Add(45, 47), Op::Const(G::from_u64(4294967296)), Op::Mul(49, 24), Op::Add(48, 50), Op::Const(G::from_u64(1099511627776)), Op::Mul(52, 25), Op::Add(51, 53), Op::Const(G::from_u64(281474976710656)), Op::Mul(55, 26), Op::Add(54, 56), Op::Const(G::from_u64(72057594037927936)), Op::Mul(58, 27), Op::Add(57, 59), Op::Const(G::from_u64(0)), Op::Mul(40, 29), Op::Add(28, 62), Op::Mul(43, 30), Op::Add(63, 64), Op::Mul(46, 31), Op::Add(65, 66), Op::Mul(49, 32), Op::Add(67, 68), Op::Mul(52, 33), Op::Add(69, 70), Op::Mul(55, 34), Op::Add(71, 72), Op::Mul(58, 35), Op::Add(73, 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(242, vec![0, 3], 1, false), Op::Add(5, 1), Op::Sub(6, 4), 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::Call(249, vec![2], 1, false), Op::Call(245, vec![3], 1, false), Op::Sub(15, 16), Op::EqZero(17), Op::Const(G::from_u64(1)), Op::AssertEq(vec![18], vec![19], None), Op::Store(vec![19, 19, 19, 19, 19, 19, 19])], ctrl: Ctrl::Return(0, vec![20]) }), (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: 5 }, 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::Sub(3, 1), Op::Call(256, vec![2, 10], 1, false), Op::Const(G::from_u64(7)), Op::Call(186, vec![1], 1, false), Op::Const(G::from_u64(1)), Op::Store(vec![14, 14, 14]), Op::Call(129, vec![11, 15], 1, false), Op::Call(130, vec![13, 16], 1, false), Op::Mul(12, 17), Op::Const(G::from_u64(0)), Op::Sub(4, 18), Op::Sub(5, 19), Op::Mul(20, 20), Op::Mul(21, 21), Op::Mul(12, 23), Op::Sub(22, 24), Op::UnconstrainedGInverse(25), Op::Mul(25, 26), Op::Sub(27, 14), Op::Mul(25, 28), Op::AssertEq(vec![29], vec![19], None), Op::Mul(26, 28), Op::AssertEq(vec![30], vec![19], None), Op::Mul(20, 26), Op::Sub(19, 21), Op::Mul(32, 26), Op::Call(143, vec![0, 1, 6, 7, 31, 33, 8, 9], 1, false)], ctrl: Ctrl::Return(0, vec![34]) }, layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 15, lookups: 7 }, entry: false, constrained: true } -} - -#[inline(never)] -fn expected_function_147() -> Function { - Function { body: Block { ops: vec![Op::Const(G::from_u64(0)), Op::Call(242, vec![8, 11], 1, false), Op::Const(G::from_u64(1)), Op::Call(242, 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(242, vec![6, 4], 1, false), Op::Add(13, 3), Op::Call(242, vec![9, 4], 1, false), Op::Call(242, 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(242, vec![6, 4], 1, false), Op::Add(13, 3), Op::Call(242, vec![9, 4], 1, false), Op::Call(242, vec![10, 4], 1, false), Op::Const(G::from_u64(0)), Op::Call(242, 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(253, 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(242, vec![7, 4], 1, false), Op::Add(17, 3), Op::Call(242, vec![11, 6], 1, false), Op::Call(242, 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(242, vec![1, 15], 1, false)], ctrl: Ctrl::Match(16, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(244, vec![16], 1, false), Op::Call(244, 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(242, 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(253, 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(242, 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::Add(4, 13), Op::Const(G::from_u64(65536)), Op::Mul(15, 6), Op::Add(14, 16), Op::Const(G::from_u64(16777216)), Op::Mul(18, 7), Op::Add(17, 19), Op::Const(G::from_u64(4294967296)), Op::Mul(21, 8), Op::Add(20, 22), Op::Const(G::from_u64(1099511627776)), Op::Mul(24, 9), Op::Add(23, 25), Op::Const(G::from_u64(281474976710656)), Op::Mul(27, 10), Op::Add(26, 28), Op::Const(G::from_u64(72057594037927936)), Op::Mul(30, 11), Op::Add(29, 31), Op::AssertEq(vec![32], vec![0], None), Op::Add(8, 9), Op::Add(33, 10), Op::Add(34, 11), Op::Const(G::from_u64(1020)), Op::Sub(35, 36), Op::EqZero(37), Op::Add(4, 5), Op::Add(39, 6), Op::Add(40, 7), 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::Add(47, 55), Op::Mul(15, 49), Op::Add(56, 57), Op::Mul(18, 50), Op::Add(58, 59), Op::Mul(21, 51), Op::Add(60, 61), Op::Mul(24, 52), Op::Add(62, 63), Op::Mul(27, 53), Op::Add(64, 65), Op::Mul(30, 54), Op::Add(66, 67), Op::AssertEq(vec![68], vec![1], None), Op::Add(51, 52), Op::Add(69, 53), Op::Add(70, 54), Op::Sub(71, 36), Op::EqZero(72), Op::Add(47, 48), Op::Add(74, 49), Op::Add(75, 50), 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::Add(81, 89), Op::Mul(15, 83), Op::Add(90, 91), Op::Mul(18, 84), Op::Add(92, 93), Op::Mul(21, 85), Op::Add(94, 95), Op::Mul(24, 86), Op::Add(96, 97), Op::Mul(27, 87), Op::Add(98, 99), Op::Mul(30, 88), Op::Add(100, 101), Op::AssertEq(vec![102], vec![2], None), Op::Add(85, 86), Op::Add(103, 87), Op::Add(104, 88), Op::Sub(105, 36), Op::EqZero(106), Op::Add(81, 82), Op::Add(108, 83), Op::Add(109, 84), 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::Add(115, 123), Op::Mul(15, 117), Op::Add(124, 125), Op::Mul(18, 118), Op::Add(126, 127), Op::Mul(21, 119), Op::Add(128, 129), Op::Mul(24, 120), Op::Add(130, 131), Op::Mul(27, 121), Op::Add(132, 133), Op::Mul(30, 122), Op::Add(134, 135), Op::AssertEq(vec![136], vec![3], None), Op::Add(119, 120), Op::Add(137, 121), Op::Add(138, 122), Op::Sub(139, 36), Op::EqZero(140), Op::Add(115, 116), Op::Add(142, 117), Op::Add(143, 118), 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(248, 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(245, 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(253, 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::Add(42, 51), Op::Const(G::from_u64(65536)), Op::Mul(53, 44), Op::Add(52, 54), Op::Const(G::from_u64(16777216)), Op::Mul(56, 45), Op::Add(55, 57), Op::Const(G::from_u64(4294967296)), Op::Mul(59, 46), Op::Add(58, 60), Op::Const(G::from_u64(1099511627776)), Op::Mul(62, 47), Op::Add(61, 63), Op::Const(G::from_u64(281474976710656)), Op::Mul(65, 48), Op::Add(64, 66), Op::Const(G::from_u64(72057594037927936)), Op::Mul(68, 49), Op::Add(67, 69), Op::AssertEq(vec![70], vec![30], None), Op::Add(46, 47), Op::Add(71, 48), Op::Add(72, 49), Op::Const(G::from_u64(1020)), Op::Sub(73, 74), Op::EqZero(75), Op::Add(42, 43), Op::Add(77, 44), Op::Add(78, 45), 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::Add(85, 93), Op::Mul(53, 87), Op::Add(94, 95), Op::Mul(56, 88), Op::Add(96, 97), Op::Mul(59, 89), Op::Add(98, 99), Op::Mul(62, 90), Op::Add(100, 101), Op::Mul(65, 91), Op::Add(102, 103), Op::Mul(68, 92), Op::Add(104, 105), Op::AssertEq(vec![106], vec![31], None), Op::Add(89, 90), Op::Add(107, 91), Op::Add(108, 92), Op::Sub(109, 74), Op::EqZero(110), Op::Add(85, 86), Op::Add(112, 87), Op::Add(113, 88), 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::Add(119, 127), Op::Mul(53, 121), Op::Add(128, 129), Op::Mul(56, 122), Op::Add(130, 131), Op::Mul(59, 123), Op::Add(132, 133), Op::Mul(62, 124), Op::Add(134, 135), Op::Mul(65, 125), Op::Add(136, 137), Op::Mul(68, 126), Op::Add(138, 139), Op::AssertEq(vec![140], vec![32], None), Op::Add(123, 124), Op::Add(141, 125), Op::Add(142, 126), Op::Sub(143, 74), Op::EqZero(144), Op::Add(119, 120), Op::Add(146, 121), Op::Add(147, 122), 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::Add(153, 161), Op::Mul(53, 155), Op::Add(162, 163), Op::Mul(56, 156), Op::Add(164, 165), Op::Mul(59, 157), Op::Add(166, 167), Op::Mul(62, 158), Op::Add(168, 169), Op::Mul(65, 159), Op::Add(170, 171), Op::Mul(68, 160), Op::Add(172, 173), Op::AssertEq(vec![174], vec![33], None), Op::Add(157, 158), Op::Add(175, 159), Op::Add(176, 160), Op::Sub(177, 74), Op::EqZero(178), Op::Add(153, 154), Op::Add(180, 155), Op::Add(181, 156), 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(245, 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(244, 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(242, vec![1, 36], 1, false)], ctrl: Ctrl::Match(38, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(244, 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(242, vec![1, 42], 1, false)], ctrl: Ctrl::Match(45, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(244, 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(242, vec![1, 52], 1, false)], ctrl: Ctrl::Match(53, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(244, 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(253, 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(242, 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(242, 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(253, 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(253, 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(253, 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(253, 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(256, 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(242, 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(244, 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(244, vec![8], 1, false), Op::Call(244, 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(244, vec![6], 1, false), Op::Call(249, 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(245, 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(255, vec![9], 1, false), Op::Sub(41, 32), Op::EqZero(42), Op::AssertEq(vec![43], vec![36], None), Op::Call(245, 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(246, 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::Add(53, 72), Op::Const(G::from_u64(65536)), Op::Mul(74, 55), Op::Add(73, 75), Op::Const(G::from_u64(16777216)), Op::Mul(77, 56), Op::Add(76, 78), Op::Const(G::from_u64(4294967296)), Op::Mul(80, 57), Op::Add(79, 81), Op::Const(G::from_u64(1099511627776)), Op::Mul(83, 58), Op::Add(82, 84), Op::Const(G::from_u64(281474976710656)), Op::Mul(86, 59), Op::Add(85, 87), Op::Const(G::from_u64(72057594037927936)), Op::Mul(89, 60), Op::Add(88, 90), Op::Mul(71, 62), Op::Add(61, 92), Op::Mul(74, 63), Op::Add(93, 94), Op::Mul(77, 64), Op::Add(95, 96), Op::Mul(80, 65), Op::Add(97, 98), Op::Mul(83, 66), Op::Add(99, 100), Op::Mul(86, 67), Op::Add(101, 102), Op::Mul(89, 68), Op::Add(103, 104), Op::Call(140, vec![69, 6, 7, 30], 2, false), Op::Call(134, vec![10, 52], 1, false), Op::Call(246, 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(75, vec![0, 37, 38, 38, 39, 40, 41], 1, false), Op::Call(74, 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::Add(6, 7), Op::Add(12, 8), Op::Add(13, 9), Op::Const(G::from_u64(1020)), Op::Sub(14, 15), Op::EqZero(16), Op::Add(2, 3), Op::Add(18, 4), Op::Add(19, 5), 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(246, 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(246, 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(251, 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, 16), Op::Add(19, 17)], ctrl: Ctrl::Match(20, [(G::from_u64(0), Block { ops: vec![Op::Call(253, vec![4, 18], 2, false)], ctrl: Ctrl::Return(1, vec![21, 22]) }), (G::from_u64(1), Block { ops: vec![Op::Call(253, vec![5, 18], 2, false)], ctrl: Ctrl::Return(2, vec![21, 22]) }), (G::from_u64(2), Block { ops: vec![Op::Call(253, vec![2, 18], 2, false)], ctrl: Ctrl::Return(3, vec![21, 22]) }), (G::from_u64(3), Block { ops: vec![Op::Call(253, vec![3, 18], 2, false)], ctrl: Ctrl::Return(4, vec![21, 22]) }), (G::from_u64(4), Block { ops: vec![Op::Call(253, vec![6, 18], 2, false)], ctrl: Ctrl::Return(5, vec![21, 22]) })].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(253, vec![7, 18], 2, false)], ctrl: Ctrl::Return(6, vec![21, 22]) }))) }), (G::from_u64(2), Block { ops: vec![Op::Call(253, 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::Add(5, 85), Op::Sub(86, 6)], ctrl: Ctrl::Match(87, [(G::from_u64(0), Block { ops: vec![Op::Add(7, 7), Op::Call(253, vec![35, 88], 2, false), Op::Const(G::from_u64(1)), Op::Add(88, 91), Op::Call(253, vec![35, 92], 2, false), Op::Const(G::from_u64(0)), Op::Call(253, vec![36, 95], 2, false), Op::Add(96, 18), Op::Add(97, 19), Op::Call(253, vec![36, 91], 2, false), Op::Add(100, 20), Op::Add(101, 21), Op::Sub(98, 89), Op::Sub(99, 90), Op::Sub(102, 93), Op::Sub(103, 94), Op::Call(195, vec![81, 82, 83, 84, 104, 105, 106, 107], 4, false), Op::Sub(108, 70), Op::Sub(109, 71), Op::Call(190, vec![0, 1, 2, 3, 112, 113], 2, false), Op::Sub(110, 79), Op::Sub(111, 80), Op::Call(190, vec![114, 115, 2, 3, 116, 117], 2, false)], ctrl: Ctrl::Return(1, vec![118, 119]) })].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(253, vec![35, 90], 2, false), Op::Const(G::from_u64(1)), Op::Add(90, 93), Op::Call(253, vec![35, 94], 2, false), Op::Const(G::from_u64(2)), Op::Add(90, 97), Op::Call(253, vec![35, 98], 2, false), Op::Const(G::from_u64(3)), Op::Add(90, 101), Op::Call(253, vec![35, 102], 2, false), Op::Sub(99, 91), Op::Sub(100, 92), Op::Sub(103, 95), Op::Sub(104, 96), 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), Op::Add(5, 93), Op::Add(7, 93), Op::Const(G::from_u64(0)), Op::Call(197, vec![119, 120, 2, 3, 47, 121, 6, 122, 9, 9, 93, 123, 123, 123, 123, 123, 123, 123, 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![124, 125]) })].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(253, vec![9, 64], 2, false), Op::Call(253, 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(253, vec![9, 75], 2, false), Op::Call(253, 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(245, 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(242, vec![1, 3], 1, false), Op::Const(G::from_u64(0)), Op::Call(242, vec![4, 5], 1, false), Op::Const(G::from_u64(1)), Op::Call(242, 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(242, 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(253, vec![3, 9], 2, false), Op::Call(242, vec![4, 9], 1, false), Op::Const(G::from_u64(0)), Op::Call(242, vec![38, 39], 1, false), Op::Call(242, vec![38, 34], 1, false), Op::Call(242, vec![5, 9], 1, false), Op::Call(242, vec![42, 39], 1, false), Op::Call(242, vec![42, 34], 1, false), Op::Call(253, 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(242, vec![7, 46], 1, false), Op::Const(G::from_u64(0)), Op::Call(242, vec![47, 48], 1, false), Op::Const(G::from_u64(1)), Op::Call(242, 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(245, 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(245, vec![41], 1, false), Op::Sub(53, 27), Op::EqZero(54), Op::AssertEq(vec![55], vec![52], None), Op::Call(245, vec![43], 1, false), Op::Sub(56, 29), Op::EqZero(57), Op::AssertEq(vec![58], vec![52], None), Op::Call(245, vec![44], 1, false), Op::Sub(59, 29), Op::EqZero(60), Op::AssertEq(vec![61], vec![52], None), Op::Call(245, vec![47], 1, false), Op::Sub(62, 28), Op::EqZero(63), Op::AssertEq(vec![64], vec![52], None), Op::Call(245, 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(253, vec![44, 181], 2, false), Op::Call(253, 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(253, vec![44, 192], 2, false), Op::Call(253, 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(245, 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(242, vec![8, 9], 1, false), Op::Const(G::from_u64(0)), Op::Call(242, vec![183, 184], 1, false), Op::Call(192, vec![185], 1, false), Op::Call(245, 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::Add(4, 14), Op::Const(G::from_u64(65536)), Op::Mul(16, 6), Op::Add(15, 17), Op::Const(G::from_u64(16777216)), Op::Mul(19, 7), Op::Add(18, 20), Op::Const(G::from_u64(4294967296)), Op::Mul(22, 8), Op::Add(21, 23), Op::Const(G::from_u64(1099511627776)), Op::Mul(25, 9), Op::Add(24, 26), Op::Const(G::from_u64(281474976710656)), Op::Mul(28, 10), Op::Add(27, 29), Op::Const(G::from_u64(72057594037927936)), Op::Mul(31, 11), Op::Add(30, 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::Add(2, 11), Op::Const(G::from_u64(65536)), Op::Mul(13, 4), Op::Add(12, 14), Op::Const(G::from_u64(16777216)), Op::Mul(16, 5), Op::Add(15, 17), Op::Const(G::from_u64(4294967296)), Op::Mul(19, 6), Op::Add(18, 20), Op::Const(G::from_u64(1099511627776)), Op::Mul(22, 7), Op::Add(21, 23), Op::Const(G::from_u64(281474976710656)), Op::Mul(25, 8), Op::Add(24, 26), Op::Const(G::from_u64(72057594037927936)), Op::Mul(28, 9), Op::Add(27, 29), Op::AssertEq(vec![30], vec![0], None), Op::Add(6, 7), Op::Add(31, 8), Op::Add(32, 9), Op::Const(G::from_u64(1020)), Op::Sub(33, 34), Op::EqZero(35), Op::Add(2, 3), Op::Add(37, 4), Op::Add(38, 5), 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(244, 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(249, 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(244, 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(250, 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(249, 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(247, 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(246, 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(246, vec![77, 80], 1, false), Op::Const(G::from_u64(256)), Op::Mul(82, 41), Op::Add(40, 83), Op::Const(G::from_u64(65536)), Op::Mul(85, 42), Op::Add(84, 86), Op::Const(G::from_u64(16777216)), Op::Mul(88, 43), Op::Add(87, 89), Op::Const(G::from_u64(4294967296)), Op::Mul(91, 44), Op::Add(90, 92), Op::Const(G::from_u64(1099511627776)), Op::Mul(94, 45), Op::Add(93, 95), Op::Const(G::from_u64(281474976710656)), Op::Mul(97, 46), Op::Add(96, 98), Op::Const(G::from_u64(72057594037927936)), Op::Mul(100, 47), Op::Add(99, 101), Op::Mul(82, 49), Op::Add(48, 103), Op::Mul(85, 50), Op::Add(104, 105), Op::Mul(88, 51), Op::Add(106, 107), Op::Mul(91, 52), Op::Add(108, 109), Op::Mul(94, 53), Op::Add(110, 111), Op::Mul(97, 54), Op::Add(112, 113), Op::Mul(100, 55), Op::Add(114, 115), Op::Mul(82, 62), Op::Add(61, 117), Op::Mul(85, 63), Op::Add(118, 119), Op::Mul(88, 64), Op::Add(120, 121), Op::Mul(91, 65), Op::Add(122, 123), Op::Mul(94, 66), Op::Add(124, 125), Op::Mul(97, 67), Op::Add(126, 127), Op::Mul(100, 68), Op::Add(128, 129), Op::Mul(82, 70), Op::Add(69, 131), Op::Mul(85, 71), Op::Add(132, 133), Op::Mul(88, 72), Op::Add(134, 135), Op::Mul(91, 73), Op::Add(136, 137), Op::Mul(94, 74), Op::Add(138, 139), Op::Mul(97, 75), Op::Add(140, 141), Op::Mul(100, 76), Op::Add(142, 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::Add(5, 14), Op::Const(G::from_u64(65536)), Op::Mul(16, 7), Op::Add(15, 17), Op::Const(G::from_u64(16777216)), Op::Mul(19, 8), Op::Add(18, 20), Op::Const(G::from_u64(4294967296)), Op::Mul(22, 9), Op::Add(21, 23), Op::Const(G::from_u64(1099511627776)), Op::Mul(25, 10), Op::Add(24, 26), Op::Const(G::from_u64(281474976710656)), Op::Mul(28, 11), Op::Add(27, 29), Op::Const(G::from_u64(72057594037927936)), Op::Mul(31, 12), Op::Add(30, 32), Op::AssertEq(vec![33], vec![1], None), Op::Add(9, 10), Op::Add(34, 11), Op::Add(35, 12), Op::Const(G::from_u64(1020)), Op::Sub(36, 37), Op::EqZero(38), Op::Add(5, 6), Op::Add(40, 7), Op::Add(41, 8), 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(246, 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::Add(53, 90), Op::Mul(16, 55), Op::Add(91, 92), Op::Mul(19, 56), Op::Add(93, 94), Op::Mul(22, 57), Op::Add(95, 96), Op::Mul(25, 58), Op::Add(97, 98), Op::Mul(28, 59), Op::Add(99, 100), Op::Mul(31, 60), Op::Add(101, 102), Op::Mul(13, 62), Op::Add(61, 104), Op::Mul(16, 63), Op::Add(105, 106), Op::Mul(19, 64), Op::Add(107, 108), Op::Mul(22, 65), Op::Add(109, 110), Op::Mul(25, 66), Op::Add(111, 112), Op::Mul(28, 67), Op::Add(113, 114), Op::Mul(31, 68), Op::Add(115, 116), Op::Mul(13, 73), Op::Add(72, 118), Op::Mul(16, 74), Op::Add(119, 120), Op::Mul(19, 75), Op::Add(121, 122), Op::Mul(22, 76), Op::Add(123, 124), Op::Mul(25, 77), Op::Add(125, 126), Op::Mul(28, 78), Op::Add(127, 128), Op::Mul(31, 79), Op::Add(129, 130), Op::Mul(13, 81), Op::Add(80, 132), Op::Mul(16, 82), Op::Add(133, 134), Op::Mul(19, 83), Op::Add(135, 136), Op::Mul(22, 84), Op::Add(137, 138), Op::Mul(25, 85), Op::Add(139, 140), Op::Mul(28, 86), Op::Add(141, 142), Op::Mul(31, 87), Op::Add(143, 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(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(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(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(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::Add(9, 38), Op::Const(G::from_u64(65536)), Op::Mul(40, 11), Op::Add(39, 41), Op::Const(G::from_u64(16777216)), Op::Mul(43, 12), Op::Add(42, 44), Op::Const(G::from_u64(4294967296)), Op::Mul(46, 13), Op::Add(45, 47), Op::Const(G::from_u64(1099511627776)), Op::Mul(49, 14), Op::Add(48, 50), Op::Const(G::from_u64(281474976710656)), Op::Mul(52, 15), Op::Add(51, 53), Op::Const(G::from_u64(72057594037927936)), Op::Mul(55, 16), Op::Add(54, 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::Add(3, 12), Op::Const(G::from_u64(65536)), Op::Mul(14, 5), Op::Add(13, 15), Op::Const(G::from_u64(16777216)), Op::Mul(17, 6), Op::Add(16, 18), Op::Const(G::from_u64(4294967296)), Op::Mul(20, 7), Op::Add(19, 21), Op::Const(G::from_u64(1099511627776)), Op::Mul(23, 8), Op::Add(22, 24), Op::Const(G::from_u64(281474976710656)), Op::Mul(26, 9), Op::Add(25, 27), Op::Const(G::from_u64(72057594037927936)), Op::Mul(29, 10), Op::Add(28, 30), Op::AssertEq(vec![31], vec![0], None), Op::Add(7, 8), Op::Add(32, 9), Op::Add(33, 10), Op::Const(G::from_u64(1020)), Op::Sub(34, 35), Op::EqZero(36), Op::Add(3, 4), Op::Add(38, 5), Op::Add(39, 6), 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(6, 7), Op::Add(46, 8), Op::Add(47, 9), Op::Add(48, 10), Op::AssertEq(vec![49], vec![2], None), Op::Sub(5, 42), Op::Mul(5, 50), Op::AssertEq(vec![51], vec![2], None), Op::Mul(5, 38), Op::AssertEq(vec![52], 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::Add(5, 26), Op::Const(G::from_u64(65536)), Op::Mul(28, 7), Op::Add(27, 29), Op::Const(G::from_u64(16777216)), Op::Mul(31, 8), Op::Add(30, 32), Op::Const(G::from_u64(4294967296)), Op::Mul(34, 9), Op::Add(33, 35), Op::Const(G::from_u64(1099511627776)), Op::Mul(37, 10), Op::Add(36, 38), Op::Const(G::from_u64(281474976710656)), Op::Mul(40, 11), Op::Add(39, 41), Op::Const(G::from_u64(72057594037927936)), Op::Mul(43, 12), Op::Add(42, 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::Add(16, 49), Op::Mul(28, 18), Op::Add(50, 51), Op::Mul(31, 19), Op::Add(52, 53), Op::Mul(34, 20), Op::Add(54, 55), Op::Mul(37, 21), Op::Add(56, 57), Op::Mul(40, 22), Op::Add(58, 59), Op::Mul(43, 23), Op::Add(60, 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::Add(63, 111), Op::Mul(28, 65), Op::Add(112, 113), Op::Mul(31, 66), Op::Add(114, 115), Op::Mul(34, 67), Op::Add(116, 117), Op::Mul(37, 68), Op::Add(118, 119), Op::Mul(40, 69), Op::Add(120, 121), Op::Mul(43, 70), Op::Add(122, 123), Op::Const(G::from_u64(16)), Op::AssertEq(vec![124], vec![125], None), Op::Mul(25, 88), Op::Add(87, 126), Op::Mul(28, 89), Op::Add(127, 128), Op::Mul(31, 90), Op::Add(129, 130), Op::Mul(34, 91), Op::Add(131, 132), Op::Mul(37, 92), Op::Add(133, 134), Op::Mul(40, 93), Op::Add(135, 136), Op::Mul(43, 94), Op::Add(137, 138), Op::AssertEq(vec![139], vec![125], None), Op::Mul(25, 72), Op::Add(71, 140), Op::Mul(28, 73), Op::Add(141, 142), Op::Mul(31, 74), Op::Add(143, 144), Op::Mul(34, 75), Op::Add(145, 146), Op::Mul(37, 76), Op::Add(147, 148), Op::Mul(40, 77), Op::Add(149, 150), Op::Mul(43, 78), Op::Add(151, 152), Op::Mul(25, 96), Op::Add(95, 154), Op::Mul(28, 97), Op::Add(155, 156), Op::Mul(31, 98), Op::Add(157, 158), Op::Mul(34, 99), Op::Add(159, 160), Op::Mul(37, 100), Op::Add(161, 162), Op::Mul(40, 101), Op::Add(163, 164), Op::Mul(43, 102), Op::Add(165, 166), Op::AssertEq(vec![167], vec![153], None), Op::Mul(25, 80), Op::Add(79, 168), Op::Mul(28, 81), Op::Add(169, 170), Op::Mul(31, 82), Op::Add(171, 172), Op::Mul(34, 83), Op::Add(173, 174), Op::Mul(37, 84), Op::Add(175, 176), Op::Mul(40, 85), Op::Add(177, 178), Op::Mul(43, 86), Op::Add(179, 180), Op::Mul(25, 104), Op::Add(103, 182), Op::Mul(28, 105), Op::Add(183, 184), Op::Mul(31, 106), Op::Add(185, 186), Op::Mul(34, 107), Op::Add(187, 188), Op::Mul(37, 108), Op::Add(189, 190), Op::Mul(40, 109), Op::Add(191, 192), Op::Mul(43, 110), Op::Add(193, 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::Add(196, 204), Op::Mul(28, 198), Op::Add(205, 206), Op::Mul(31, 199), Op::Add(207, 208), Op::Mul(34, 200), Op::Add(209, 210), Op::Mul(37, 201), Op::Add(211, 212), Op::Mul(40, 202), Op::Add(213, 214), Op::Mul(43, 203), Op::Add(215, 216), Op::AssertEq(vec![217], vec![181], None), Op::Add(200, 201), Op::Add(218, 202), Op::Add(219, 203), Op::Const(G::from_u64(1020)), Op::Sub(220, 221), Op::EqZero(222), Op::Add(196, 197), Op::Add(224, 198), Op::Add(225, 199), 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::Add(231, 239), Op::Mul(28, 233), Op::Add(240, 241), Op::Mul(31, 234), Op::Add(242, 243), Op::Mul(34, 235), Op::Add(244, 245), Op::Mul(37, 236), Op::Add(246, 247), Op::Mul(40, 237), Op::Add(248, 249), Op::Mul(43, 238), Op::Add(250, 251), Op::AssertEq(vec![252], vec![195], None), Op::Add(235, 236), Op::Add(253, 237), Op::Add(254, 238), Op::Sub(255, 221), Op::EqZero(256), Op::Add(231, 232), Op::Add(258, 233), Op::Add(259, 234), 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::Add(268, 276), Op::Mul(28, 270), Op::Add(277, 278), Op::Mul(31, 271), Op::Add(279, 280), Op::Mul(34, 272), Op::Add(281, 282), Op::Mul(37, 273), Op::Add(283, 284), Op::Mul(40, 274), Op::Add(285, 286), Op::Mul(43, 275), Op::Add(287, 288), Op::AssertEq(vec![289], vec![153], None), Op::Add(272, 273), Op::Add(290, 274), Op::Add(291, 275), Op::Sub(292, 221), Op::EqZero(293), Op::Add(268, 269), Op::Add(295, 270), Op::Add(296, 271), 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::Add(302, 310), Op::Mul(28, 304), Op::Add(311, 312), Op::Mul(31, 305), Op::Add(313, 314), Op::Mul(34, 306), Op::Add(315, 316), Op::Mul(37, 307), Op::Add(317, 318), Op::Mul(40, 308), Op::Add(319, 320), Op::Mul(43, 309), Op::Add(321, 322), Op::AssertEq(vec![323], vec![1], None), Op::Add(306, 307), Op::Add(324, 308), Op::Add(325, 309), Op::Sub(326, 221), Op::EqZero(327), Op::Add(302, 303), Op::Add(329, 304), Op::Add(330, 305), 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::Add(338, 346), Op::Mul(28, 340), Op::Add(347, 348), Op::Mul(31, 341), Op::Add(349, 350), Op::Mul(34, 342), Op::Add(351, 352), Op::Mul(37, 343), Op::Add(353, 354), Op::Mul(40, 344), Op::Add(355, 356), Op::Mul(43, 345), Op::Add(357, 358), Op::AssertEq(vec![359], vec![2], None), Op::Add(342, 343), Op::Add(360, 344), Op::Add(361, 345), Op::Sub(362, 221), Op::EqZero(363), Op::Add(338, 339), Op::Add(365, 340), Op::Add(366, 341), 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::Add(372, 380), Op::Mul(28, 374), Op::Add(381, 382), Op::Mul(31, 375), Op::Add(383, 384), Op::Mul(34, 376), Op::Add(385, 386), Op::Mul(37, 377), Op::Add(387, 388), Op::Mul(40, 378), Op::Add(389, 390), Op::Mul(43, 379), Op::Add(391, 392), Op::AssertEq(vec![393], vec![181], None), Op::Add(376, 377), Op::Add(394, 378), Op::Add(395, 379), Op::Sub(396, 221), Op::EqZero(397), Op::Add(372, 373), Op::Add(399, 374), Op::Add(400, 375), 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(245, vec![21], 1, false), Op::EqZero(48), Op::Const(G::from_u64(0)), Op::AssertEq(vec![49], vec![50], None), Op::Call(244, vec![39], 1, false), Op::AssertEq(vec![51], vec![48], None), Op::Call(244, vec![40], 1, false), Op::AssertEq(vec![52], vec![48], None), Op::Call(244, 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(244, vec![17], 1, false), Op::Call(250, 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(250, vec![60], 1, false), Op::Call(245, 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(244, 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(250, vec![60], 1, false)], ctrl: Ctrl::Match(23, [].into_iter().collect(), Some(Box::new(Block { ops: vec![Op::Call(244, vec![23], 1, false), Op::Call(249, 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(245, 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(255, vec![26], 1, false), Op::Sub(93, 84), Op::EqZero(94), Op::AssertEq(vec![95], vec![88], None), Op::Call(245, 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(246, 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::Add(105, 124), Op::Const(G::from_u64(65536)), Op::Mul(126, 107), Op::Add(125, 127), Op::Const(G::from_u64(16777216)), Op::Mul(129, 108), Op::Add(128, 130), Op::Const(G::from_u64(4294967296)), Op::Mul(132, 109), Op::Add(131, 133), Op::Const(G::from_u64(1099511627776)), Op::Mul(135, 110), Op::Add(134, 136), Op::Const(G::from_u64(281474976710656)), Op::Mul(138, 111), Op::Add(137, 139), Op::Const(G::from_u64(72057594037927936)), Op::Mul(141, 112), Op::Add(140, 142), Op::Mul(123, 114), Op::Add(113, 144), Op::Mul(126, 115), Op::Add(145, 146), Op::Mul(129, 116), Op::Add(147, 148), Op::Mul(132, 117), Op::Add(149, 150), Op::Mul(135, 118), Op::Add(151, 152), Op::Mul(138, 119), Op::Add(153, 154), Op::Mul(141, 120), Op::Add(155, 156), Op::Call(140, vec![121, 23, 24, 5], 2, false), Op::Call(134, vec![27, 104], 1, false), Op::Call(246, 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(246, 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(247, 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(243, vec![14], 1, false), Op::Call(247, 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(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(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(26, 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(26, 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(26, 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(25, 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::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, 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::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::Add(59, 92), Op::Const(G::from_u64(65536)), Op::Mul(94, 61), Op::Add(93, 95), Op::Const(G::from_u64(16777216)), Op::Mul(97, 62), Op::Add(96, 98), Op::Mul(91, 64), Op::Add(63, 100), Op::Mul(94, 65), Op::Add(101, 102), Op::Mul(97, 66), Op::Add(103, 104), Op::Mul(91, 68), Op::Add(67, 106), Op::Mul(94, 69), Op::Add(107, 108), Op::Mul(97, 70), Op::Add(109, 110), Op::Mul(91, 72), Op::Add(71, 112), Op::Mul(94, 73), Op::Add(113, 114), Op::Mul(97, 74), Op::Add(115, 116), Op::Mul(91, 76), Op::Add(75, 118), Op::Mul(94, 77), Op::Add(119, 120), Op::Mul(97, 78), Op::Add(121, 122), Op::Mul(91, 80), Op::Add(79, 124), Op::Mul(94, 81), Op::Add(125, 126), Op::Mul(97, 82), Op::Add(127, 128), Op::Mul(91, 84), Op::Add(83, 130), Op::Mul(94, 85), Op::Add(131, 132), Op::Mul(97, 86), Op::Add(133, 134), Op::Mul(91, 88), Op::Add(87, 136), Op::Mul(94, 89), Op::Add(137, 138), Op::Mul(97, 90), Op::Add(139, 140), Op::AssertEq(vec![99, 105, 111, 117, 123, 129, 135, 141], vec![0, 1, 2, 3, 4, 5, 6, 7], None), Op::Call(90, vec![22], 10, false), Op::Call(90, vec![151], 10, false), Op::Call(90, vec![161], 10, false), Op::Call(90, vec![171], 10, false), Op::Call(90, vec![181], 10, false), Op::Call(90, vec![191], 10, false), Op::Call(90, 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(90, vec![211], 10, false), Op::Call(103, vec![229, 220], 3, false), Op::Call(104, vec![232], 3, false), Op::Call(105, vec![235, 220], 2, false), Op::Store(vec![16, 221, 222, 223, 224, 225, 226, 227, 228, 231]), Op::Call(254, 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, false), 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::Add(248, 280), Op::Mul(94, 250), Op::Add(281, 282), Op::Mul(97, 251), Op::Add(283, 284), Op::Mul(91, 253), Op::Add(252, 286), Op::Mul(94, 254), Op::Add(287, 288), Op::Mul(97, 255), Op::Add(289, 290), Op::Mul(91, 257), Op::Add(256, 292), Op::Mul(94, 258), Op::Add(293, 294), Op::Mul(97, 259), Op::Add(295, 296), Op::Mul(91, 261), Op::Add(260, 298), Op::Mul(94, 262), Op::Add(299, 300), Op::Mul(97, 263), Op::Add(301, 302), Op::Mul(91, 265), Op::Add(264, 304), Op::Mul(94, 266), Op::Add(305, 306), Op::Mul(97, 267), Op::Add(307, 308), Op::Mul(91, 269), Op::Add(268, 310), Op::Mul(94, 270), Op::Add(311, 312), Op::Mul(97, 271), Op::Add(313, 314), Op::Mul(91, 273), Op::Add(272, 316), Op::Mul(94, 274), Op::Add(317, 318), Op::Mul(97, 275), Op::Add(319, 320), Op::Mul(91, 277), Op::Add(276, 322), Op::Mul(94, 278), Op::Add(323, 324), Op::Mul(97, 279), Op::Add(325, 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(238, 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(235, vec![142, 152, 162, 172, 182, 192, 202, 239, 230, 233, 234, 236, 337, 341, 345], 1, false), Op::Call(220, 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: 44 }, entry: true, constrained: true } -} - -#[inline(never)] -fn expected_function_242() -> Function { - Function { body: Block { ops: vec![Op::Call(256, 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_243() -> 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(243, 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_244() -> 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(244, 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_245() -> 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(245, 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_246() -> 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(246, 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_247() -> 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(247, 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_248() -> 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(248, 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_249() -> 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(249, 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_250() -> 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(250, 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_251() -> Function { - Function { body: Block { ops: vec![Op::Call(258, 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_252() -> 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_253() -> Function { - Function { body: Block { ops: vec![Op::Call(257, 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_254() -> 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(254, 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_255() -> 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(255, 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_256() -> 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(256, 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_257() -> 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(257, 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_258() -> 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(258, 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(), expected_function_256(), expected_function_257(), expected_function_258()], memory_sizes: vec![3, 4, 5, 6, 7, 8, 10, 11, 26, 32, 34], circuits: vec![Circuit { members: vec![0, 2, 11, 12, 99, 122, 123, 124, 125, 167, 183, 191], layout: FunctionLayout { input_size: 8, selectors: 40, auxiliaries: 20, lookups: 7 } }, Circuit { members: vec![1], layout: FunctionLayout { input_size: 3, selectors: 3, auxiliaries: 8, lookups: 5 } }, Circuit { members: vec![10], layout: FunctionLayout { input_size: 16, selectors: 9, auxiliaries: 2, lookups: 1 } }, Circuit { members: vec![24, 38, 91, 93, 100, 144, 185, 192, 206, 207, 208, 250], layout: FunctionLayout { input_size: 3, selectors: 25, auxiliaries: 18, lookups: 6 } }, Circuit { members: vec![25, 73, 74, 92, 128, 139, 151, 160, 168, 176, 177, 180, 197], layout: FunctionLayout { input_size: 44, selectors: 26, auxiliaries: 137, lookups: 14 } }, Circuit { members: vec![26, 46, 54, 57, 59, 111, 140, 158, 173, 179, 204, 240, 248, 254], layout: FunctionLayout { input_size: 9, selectors: 26, auxiliaries: 98, lookups: 32 } }, Circuit { members: vec![29, 258], layout: FunctionLayout { input_size: 2, selectors: 3, auxiliaries: 11, lookups: 3 } }, Circuit { members: vec![33, 43, 47, 108, 127, 141, 152, 154, 162, 163, 166, 178], layout: FunctionLayout { input_size: 5, selectors: 25, auxiliaries: 9, lookups: 5 } }, Circuit { members: vec![34, 244], 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, 80, 90, 113, 121, 130, 135, 136, 174], layout: FunctionLayout { input_size: 2, selectors: 21, auxiliaries: 8, lookups: 4 } }, Circuit { members: vec![37, 195], layout: FunctionLayout { input_size: 8, selectors: 3, auxiliaries: 23, lookups: 3 } }, Circuit { members: vec![39, 50, 105, 119, 131, 138, 142, 157, 161, 164, 181, 186, 188, 200, 255], layout: FunctionLayout { input_size: 8, selectors: 31, auxiliaries: 42, lookups: 9 } }, Circuit { members: vec![41, 97], 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: 9, auxiliaries: 22, lookups: 10 } }, Circuit { members: vec![79, 81, 82, 103, 175, 203], layout: FunctionLayout { input_size: 20, selectors: 25, 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, 247], layout: FunctionLayout { input_size: 25, selectors: 37, auxiliaries: 46, lookups: 20 } }, Circuit { members: vec![96], layout: FunctionLayout { input_size: 3, selectors: 17, auxiliaries: 24, lookups: 8 } }, Circuit { members: vec![112, 190], layout: FunctionLayout { input_size: 6, selectors: 3, 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, 253, 257], 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: 5 } }, Circuit { members: vec![146], layout: FunctionLayout { input_size: 10, selectors: 1, auxiliaries: 15, lookups: 7 } }, 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![241], layout: FunctionLayout { input_size: 16, selectors: 1, auxiliaries: 201, lookups: 44 } }, Circuit { members: vec![242, 245, 256], layout: FunctionLayout { input_size: 2, selectors: 5, auxiliaries: 6, lookups: 3 } }, Circuit { members: vec![243], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 28, lookups: 3 } }, Circuit { members: vec![246], layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 6, lookups: 4 } }, Circuit { members: vec![249], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 12, lookups: 3 } }, Circuit { members: vec![251], layout: FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 8, lookups: 3 } }, Circuit { members: vec![252], layout: FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 4, lookups: 2 } }] } -} -pub static PROGRAM: GeneratedProgram = GeneratedProgram { fingerprint: [87, 27, 221, 210, 4, 48, 191, 225, 86, 204, 54, 145, 96, 172, 15, 58, 83, 30, 136, 181, 161, 157, 101, 136, 23, 109, 212, 12, 145, 122, 135, 142], 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, -Some(FunctionWriter { layout: FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 193, lookups: 65 }, output_size: 64, seed_words: 194, schema: &SCHEMA_79, pack: pack_79, pack_typed: pack_79_typed, write: write_79 }), -None, -Some(FunctionWriter { layout: FunctionLayout { input_size: 6, selectors: 11, auxiliaries: 143, lookups: 8 }, output_size: 1, seed_words: 146, schema: &SCHEMA_81, pack: pack_81, pack_typed: pack_81_typed, write: |seed, offsets, row| { write_81(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_82, pack: pack_82, pack_typed: pack_82_typed, write: |seed, offsets, row| { write_82(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_86, pack: pack_86, pack_typed: pack_86_typed, 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, -Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 109, lookups: 34 }, output_size: 3, seed_words: 69, schema: &SCHEMA_103, pack: pack_103, pack_typed: pack_103_typed, write: |seed, offsets, row| { write_103(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_117, pack: pack_117, pack_typed: pack_117_typed, 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, -Some(FunctionWriter { layout: FunctionLayout { input_size: 2, selectors: 2, auxiliaries: 74, lookups: 25 }, output_size: 10, seed_words: 76, schema: &SCHEMA_175, pack: pack_175, pack_typed: pack_175_typed, write: write_175 }), -None, -None, -None, -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_203, pack: pack_203, pack_typed: pack_203_typed, write: write_203 }), -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, 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, 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 -] }; diff --git a/crates/aiur/src/trace_codegen/programs/multi_stark_cuda.rs b/crates/aiur/src/trace_codegen/programs/multi_stark_cuda.rs deleted file mode 100644 index b1d8281c8..000000000 --- a/crates/aiur/src/trace_codegen/programs/multi_stark_cuda.rs +++ /dev/null @@ -1,277 +0,0 @@ -// 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_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_81(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_82(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_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_multi_stark_103(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_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_multi_stark_175(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_203(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_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_multi_stark_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([87, 27, 221, 210, 4, 48, 191, 225, 86, 204, 54, 145, 96, 172, 15, 58, 83, 30, 136, 181, 161, 157, 101, 136, 23, 109, 212, 12, 145, 122, 135, 142], 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, -None, -None, -None, -Some(aiur_trace_multi_stark_79), -None, -Some(aiur_trace_multi_stark_81), -Some(aiur_trace_multi_stark_82), -None, -None, -None, -Some(aiur_trace_multi_stark_86), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -Some(aiur_trace_multi_stark_103), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -Some(aiur_trace_multi_stark_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, -Some(aiur_trace_multi_stark_175), -None, -None, -None, -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_203), -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -None, -Some(aiur_trace_multi_stark_220), -None, -None, -None, -None, -None, -None, -None, -None, -None, -Some(aiur_trace_multi_stark_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 -], &[3, 9, 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, 25, 0, 0, 0, 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, 17, 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, 48, 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, 160, 0, 0, 0, 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, 112, 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 deleted file mode 100644 index ee8cadbe9..000000000 --- a/crates/aiur/src/trace_codegen/tests.rs +++ /dev/null @@ -1,523 +0,0 @@ -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, &mut seed).unwrap(); - 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 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, &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, &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, &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, &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, &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 deleted file mode 100644 index 239d94746..000000000 --- a/crates/aiur/src/trace_codegen/tests/blake3.rs +++ /dev/null @@ -1,25 +0,0 @@ -// 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 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] = [v_165 * v_167]; row[offsets.auxiliaries + 6] = v_168.as_canonical_u64(); let [v_169]: [G; 1] = [G::from_u64(2)]; let [v_170]: [G; 1] = [v_165 - v_169]; let [v_171]: [G; 1] = [v_168 * 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_200]; row[offsets.auxiliaries + 29] = v_201.as_canonical_u64(); let [v_202]: [G; 1] = [v_199 - v_169]; let [v_203]: [G; 1] = [v_201 * 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_231]; row[offsets.auxiliaries + 52] = v_232.as_canonical_u64(); let [v_233]: [G; 1] = [v_230 - v_169]; let [v_234]: [G; 1] = [v_232 * 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_262]; row[offsets.auxiliaries + 75] = v_263.as_canonical_u64(); let [v_264]: [G; 1] = [v_261 - v_169]; let [v_265]: [G; 1] = [v_263 * 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_293]; row[offsets.auxiliaries + 98] = v_294.as_canonical_u64(); let [v_295]: [G; 1] = [v_292 - v_169]; let [v_296]: [G; 1] = [v_294 * 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_324]; row[offsets.auxiliaries + 121] = v_325.as_canonical_u64(); let [v_326]: [G; 1] = [v_323 - v_169]; let [v_327]: [G; 1] = [v_325 * 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_355]; row[offsets.auxiliaries + 144] = v_356.as_canonical_u64(); let [v_357]: [G; 1] = [v_354 - v_169]; let [v_358]: [G; 1] = [v_356 * 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_386]; row[offsets.auxiliaries + 167] = v_387.as_canonical_u64(); let [v_388]: [G; 1] = [v_385 - v_169]; let [v_389]: [G; 1] = [v_387 * 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_417]; row[offsets.auxiliaries + 190] = v_418.as_canonical_u64(); let [v_419]: [G; 1] = [v_416 - v_169]; let [v_420]: [G; 1] = [v_418 * 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_448]; row[offsets.auxiliaries + 213] = v_449.as_canonical_u64(); let [v_450]: [G; 1] = [v_447 - v_169]; let [v_451]: [G; 1] = [v_449 * 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_479]; row[offsets.auxiliaries + 236] = v_480.as_canonical_u64(); let [v_481]: [G; 1] = [v_478 - v_169]; let [v_482]: [G; 1] = [v_480 * 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_510]; row[offsets.auxiliaries + 259] = v_511.as_canonical_u64(); let [v_512]: [G; 1] = [v_509 - v_169]; let [v_513]: [G; 1] = [v_511 * 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_541]; row[offsets.auxiliaries + 282] = v_542.as_canonical_u64(); let [v_543]: [G; 1] = [v_540 - v_169]; let [v_544]: [G; 1] = [v_542 * 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_572]; row[offsets.auxiliaries + 305] = v_573.as_canonical_u64(); let [v_574]: [G; 1] = [v_571 - v_169]; let [v_575]: [G; 1] = [v_573 * 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_603]; row[offsets.auxiliaries + 328] = v_604.as_canonical_u64(); let [v_605]: [G; 1] = [v_602 - v_169]; let [v_606]: [G; 1] = [v_604 * 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_634]; row[offsets.auxiliaries + 351] = v_635.as_canonical_u64(); let [v_636]: [G; 1] = [v_633 - v_169]; let [v_637]: [G; 1] = [v_635 * 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::Mul(133, 135), Op::Const(G::from_u64(2)), Op::Sub(133, 137), Op::Mul(136, 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::Mul(167, 168), Op::Sub(167, 137), Op::Mul(169, 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::Mul(198, 199), Op::Sub(198, 137), Op::Mul(200, 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::Mul(229, 230), Op::Sub(229, 137), Op::Mul(231, 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::Mul(260, 261), Op::Sub(260, 137), Op::Mul(262, 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::Mul(291, 292), Op::Sub(291, 137), Op::Mul(293, 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::Mul(322, 323), Op::Sub(322, 137), Op::Mul(324, 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::Mul(353, 354), Op::Sub(353, 137), Op::Mul(355, 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::Mul(384, 385), Op::Sub(384, 137), Op::Mul(386, 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::Mul(415, 416), Op::Sub(415, 137), Op::Mul(417, 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::Mul(446, 447), Op::Sub(446, 137), Op::Mul(448, 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::Mul(477, 478), Op::Sub(477, 137), Op::Mul(479, 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::Mul(508, 509), Op::Sub(508, 137), Op::Mul(510, 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::Mul(539, 540), Op::Sub(539, 137), Op::Mul(541, 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::Mul(570, 571), Op::Sub(570, 137), Op::Mul(572, 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::Mul(601, 602), Op::Sub(601, 137), Op::Mul(603, 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: [58, 213, 204, 64, 57, 46, 134, 177, 30, 246, 254, 175, 75, 41, 50, 24, 114, 80, 186, 84, 61, 41, 13, 140, 14, 107, 159, 30, 218, 19, 75, 152], 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, 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 deleted file mode 100644 index aace61ff3..000000000 --- a/crates/aiur/src/trace_codegen/tests/blake3_cuda.rs +++ /dev/null @@ -1,10 +0,0 @@ -// 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([58, 213, 204, 64, 57, 46, 134, 177, 30, 246, 254, 175, 75, 41, 50, 24, 114, 80, 186, 84, 61, 41, 13, 140, 14, 107, 159, 30, 218, 19, 75, 152], 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 deleted file mode 100644 index a898ce4f3..000000000 --- a/crates/aiur/src/trace_codegen/tests/cuda.rs +++ /dev/null @@ -1,714 +0,0 @@ -use super::*; -use std::sync::Arc; - -use multi_stark::{ - p3_matrix::Matrix, - witness::{TraceGenerator, TraceSource}, -}; - -use crate::trace_codegen::cuda::{ - prepare_memory, prepare_memory_trace, seed_cache_bytes, -}; - -pub(super) fn parity(program: &Toplevel, record: &QueryRecord, io: &IOBuffer) { - let bound = generated_cuda::CUDA.bind(&generated::PROGRAM, program).unwrap(); - 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); - // The typed codec is used wherever the guards pass. It must reproduce - // the oracle from seeds staged per tile and from seeds kept resident on - // the device. - for retain in [false, true] { - let (source, _) = bound - .prepare_trace(index, record, io, &[], (0, 0), end, rows, retain) - .unwrap(); - 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}, retain {retain}: CPU mirror" - ); - for (first, rows) in [(0, height), (height - 1, height + 1)] { - let actual = source.download_tile(0, first, rows); - assert_eq!( - seed_cache_bytes(0) > 0, - retain, - "circuit {index}: seeds resident only when retained" - ); - // The tile comes back as raw words, so noncanonical device output is - // caught here rather than hidden by field equality. - for (i, &word) in actual.iter().enumerate() { - let row = (first + i / width) % height; - assert_eq!( - word, - expected[row * width + i % width], - "circuit {index}, retain {retain}, 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_trace(0, &record, &io, &[], (0, 0), (3, 0), 3, false) - .unwrap(); - drop(record); - drop(io); - let mut expected = vec![G::ZERO; source.height() * source.width()]; - source.write_rows(0, &mut expected); - assert_eq!( - source.download_tile(0, 0, 4), - expected.iter().map(|g| g.as_canonical_u64()).collect::>() - ); -} - -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; run with --release"] -fn blake3_generated_timing() { - 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, &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) - .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 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) - .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_trace(0, &record, &io, &[], (0, 0), (0, 65537), 65537, false) - .unwrap(); - for first in [0, 65536, 131070] { - let actual = source.download_tile(0, first, 65537); - let mut expected = vec![G::ZERO; actual.len()]; - source.write_rows(first, &mut expected); - for (i, (actual, expected)) in actual.iter().zip(&expected).enumerate() { - assert_eq!( - *actual, - expected.as_canonical_u64(), - "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_trace(0, &record, &io, &[], (0, 0), (0, ROWS), ROWS, retain) - .unwrap(); - source - }; - let staged = prepare(false); - let resident = prepare(true); - 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 = staged.download_tile(0, first, rows); - let actual = resident.download_tile(0, first, rows); - assert_eq!(actual, expected, "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 = staged.download_tile(0, 7, 9); - let actual = resident.download_tile(0, 7, 9); - assert_eq!(actual, expected, "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_trace(0, &record, &io, &[], (0, 0), (0, 33), 33, false) - .unwrap(); - let source = Arc::new(source); - 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 || { - barrier.wait(); - for first in [0, 32, 63] { - let actual = source.download_tile(device, first, 65); - let mut expected = vec![G::ZERO; actual.len()]; - source.write_rows(first, &mut expected); - assert_eq!( - actual, - expected.iter().map(|g| g.as_canonical_u64()).collect::>() - ); - } - }); - } - }); -} - -#[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_trace( - circuit, - &record, - &io, - &[], - (member, 0), - (member, 1024), - 1024, - false, - ) - .unwrap(); - 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); - assert_eq!( - source.download_tile(0, 0, 1024), - expected.iter().map(|g| g.as_canonical_u64()).collect::>() - ); -} - -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: usize = 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_usize(tag), G::from_usize(value)], - &mut io, - &mut record, - ) - .unwrap(); - } - assert_eq!(record.function_queries[3].len(), ROWS); - for dead in [0usize, 5, 4095, 4096, 9000, ROWS - 1] { - *record.function_queries[3].get_index_mut(dead).unwrap().1 = G::ZERO; - } - let live: Vec = (0..ROWS) - .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_trace( - circuit, - &record, - &io, - &[], - (member, 0), - (member, ROWS), - live.len(), - false, - ) - .unwrap(); - 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" - ); - assert_eq!(source.download_tile(0, 0, height), 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(); - } - } - 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_trace(&record, width, &[], range.clone()).unwrap(); - 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 = source.download_tile(0, first, rows); - let w = width + 3; - for (i, &cell) in actual.iter().enumerate() { - let row = (first + i / w) % height; - assert_eq!( - cell, - expected.values[row * w + i % w].as_canonical_u64(), - "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 deleted file mode 100644 index a53379098..000000000 --- a/crates/aiur/src/trace_codegen/tests/generated.rs +++ /dev/null @@ -1,311 +0,0 @@ -// 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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] = [v_165 * v_167]; row[offsets.auxiliaries + 6] = v_168.as_canonical_u64(); let [v_169]: [G; 1] = [G::from_u64(2)]; let [v_170]: [G; 1] = [v_165 - v_169]; let [v_171]: [G; 1] = [v_168 * 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_200]; row[offsets.auxiliaries + 29] = v_201.as_canonical_u64(); let [v_202]: [G; 1] = [v_199 - v_169]; let [v_203]: [G; 1] = [v_201 * 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_231]; row[offsets.auxiliaries + 52] = v_232.as_canonical_u64(); let [v_233]: [G; 1] = [v_230 - v_169]; let [v_234]: [G; 1] = [v_232 * 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_262]; row[offsets.auxiliaries + 75] = v_263.as_canonical_u64(); let [v_264]: [G; 1] = [v_261 - v_169]; let [v_265]: [G; 1] = [v_263 * 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_293]; row[offsets.auxiliaries + 98] = v_294.as_canonical_u64(); let [v_295]: [G; 1] = [v_292 - v_169]; let [v_296]: [G; 1] = [v_294 * 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_324]; row[offsets.auxiliaries + 121] = v_325.as_canonical_u64(); let [v_326]: [G; 1] = [v_323 - v_169]; let [v_327]: [G; 1] = [v_325 * 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_355]; row[offsets.auxiliaries + 144] = v_356.as_canonical_u64(); let [v_357]: [G; 1] = [v_354 - v_169]; let [v_358]: [G; 1] = [v_356 * 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_386]; row[offsets.auxiliaries + 167] = v_387.as_canonical_u64(); let [v_388]: [G; 1] = [v_385 - v_169]; let [v_389]: [G; 1] = [v_387 * 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_417]; row[offsets.auxiliaries + 190] = v_418.as_canonical_u64(); let [v_419]: [G; 1] = [v_416 - v_169]; let [v_420]: [G; 1] = [v_418 * 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_448]; row[offsets.auxiliaries + 213] = v_449.as_canonical_u64(); let [v_450]: [G; 1] = [v_447 - v_169]; let [v_451]: [G; 1] = [v_449 * 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_479]; row[offsets.auxiliaries + 236] = v_480.as_canonical_u64(); let [v_481]: [G; 1] = [v_478 - v_169]; let [v_482]: [G; 1] = [v_480 * 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_510]; row[offsets.auxiliaries + 259] = v_511.as_canonical_u64(); let [v_512]: [G; 1] = [v_509 - v_169]; let [v_513]: [G; 1] = [v_511 * 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_541]; row[offsets.auxiliaries + 282] = v_542.as_canonical_u64(); let [v_543]: [G; 1] = [v_540 - v_169]; let [v_544]: [G; 1] = [v_542 * 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_572]; row[offsets.auxiliaries + 305] = v_573.as_canonical_u64(); let [v_574]: [G; 1] = [v_571 - v_169]; let [v_575]: [G; 1] = [v_573 * 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_603]; row[offsets.auxiliaries + 328] = v_604.as_canonical_u64(); let [v_605]: [G; 1] = [v_602 - v_169]; let [v_606]: [G; 1] = [v_604 * 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_634]; row[offsets.auxiliaries + 351] = v_635.as_canonical_u64(); let [v_636]: [G; 1] = [v_633 - v_169]; let [v_637]: [G; 1] = [v_635 * 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 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 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 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 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_45]: [G; 1] = [G::from_u64(65536)]; let [v_46]: [G; 1] = [v_16 * v_37]; let [v_48]: [G; 1] = [v_45 * v_38]; 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_52 + v_53]; let [v_55]: [G; 1] = [v_54 + v_36]; let [v_56]: [G; 1] = [v_55 + v_46]; let [v_57]: [G; 1] = [v_56 + v_48]; let [v_58, v_59, v_60, v_61, v_62, v_63, v_64, v_65]: [G; 8] = v_57.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 12] = v_58.as_canonical_u64(); row[offsets.auxiliaries + 13] = v_59.as_canonical_u64(); row[offsets.auxiliaries + 14] = v_60.as_canonical_u64(); row[offsets.auxiliaries + 15] = v_61.as_canonical_u64(); row[offsets.auxiliaries + 16] = v_62.as_canonical_u64(); row[offsets.auxiliaries + 17] = v_63.as_canonical_u64(); row[offsets.auxiliaries + 18] = v_64.as_canonical_u64(); row[offsets.auxiliaries + 19] = v_65.as_canonical_u64(); let [v_68]: [G; 1] = [v_16 * v_61]; let [v_70]: [G; 1] = [v_45 * v_62]; let [v_74]: [G; 1] = [v_18 * v_28]; row[offsets.auxiliaries + 20] = v_74.as_canonical_u64(); let [v_75]: [G; 1] = [v_22 * v_24]; row[offsets.auxiliaries + 21] = v_75.as_canonical_u64(); let [v_76]: [G; 1] = [v_74 + v_75]; let [v_77]: [G; 1] = [v_26 * v_20]; row[offsets.auxiliaries + 22] = v_77.as_canonical_u64(); let [v_78]: [G; 1] = [v_76 + v_77]; let [v_79]: [G; 1] = [v_78 + v_60]; let [v_80]: [G; 1] = [v_79 + v_68]; let [v_81]: [G; 1] = [v_80 + v_70]; let [v_82, v_83, v_84, v_85, v_86, v_87, v_88, v_89]: [G; 8] = v_81.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 23] = v_82.as_canonical_u64(); row[offsets.auxiliaries + 24] = v_83.as_canonical_u64(); row[offsets.auxiliaries + 25] = v_84.as_canonical_u64(); row[offsets.auxiliaries + 26] = v_85.as_canonical_u64(); row[offsets.auxiliaries + 27] = v_86.as_canonical_u64(); row[offsets.auxiliaries + 28] = v_87.as_canonical_u64(); row[offsets.auxiliaries + 29] = v_88.as_canonical_u64(); row[offsets.auxiliaries + 30] = v_89.as_canonical_u64(); let [v_92]: [G; 1] = [v_16 * v_85]; let [v_94]: [G; 1] = [v_45 * v_86]; let [v_98]: [G; 1] = [v_18 * v_32]; row[offsets.auxiliaries + 31] = v_98.as_canonical_u64(); let [v_99]: [G; 1] = [v_22 * v_28]; row[offsets.auxiliaries + 32] = v_99.as_canonical_u64(); let [v_100]: [G; 1] = [v_98 + v_99]; let [v_101]: [G; 1] = [v_26 * v_24]; row[offsets.auxiliaries + 33] = v_101.as_canonical_u64(); let [v_102]: [G; 1] = [v_100 + v_101]; let [v_103]: [G; 1] = [v_30 * v_20]; row[offsets.auxiliaries + 34] = v_103.as_canonical_u64(); let [v_104]: [G; 1] = [v_102 + v_103]; let [v_105]: [G; 1] = [v_104 + v_84]; let [v_106]: [G; 1] = [v_105 + v_92]; let [v_107]: [G; 1] = [v_106 + v_94]; let [v_108, v_109, v_110, v_111, v_112, v_113, v_114, v_115]: [G; 8] = v_107.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 35] = v_108.as_canonical_u64(); row[offsets.auxiliaries + 36] = v_109.as_canonical_u64(); row[offsets.auxiliaries + 37] = v_110.as_canonical_u64(); row[offsets.auxiliaries + 38] = v_111.as_canonical_u64(); row[offsets.auxiliaries + 39] = v_112.as_canonical_u64(); row[offsets.auxiliaries + 40] = v_113.as_canonical_u64(); row[offsets.auxiliaries + 41] = v_114.as_canonical_u64(); row[offsets.auxiliaries + 42] = v_115.as_canonical_u64(); let [v_118]: [G; 1] = [v_16 * v_111]; let [v_120]: [G; 1] = [v_45 * v_112]; let [v_124]: [G; 1] = [v_22 * v_32]; row[offsets.auxiliaries + 43] = v_124.as_canonical_u64(); let [v_125]: [G; 1] = [v_26 * v_28]; row[offsets.auxiliaries + 44] = v_125.as_canonical_u64(); let [v_126]: [G; 1] = [v_124 + v_125]; let [v_127]: [G; 1] = [v_30 * v_24]; row[offsets.auxiliaries + 45] = v_127.as_canonical_u64(); let [v_128]: [G; 1] = [v_126 + v_127]; let [v_129]: [G; 1] = [v_128 + v_110]; let [v_130]: [G; 1] = [v_129 + v_118]; let [v_131]: [G; 1] = [v_130 + v_120]; let [v_132, v_133, v_134, v_135, v_136, v_137, v_138, v_139]: [G; 8] = v_131.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 46] = v_132.as_canonical_u64(); row[offsets.auxiliaries + 47] = v_133.as_canonical_u64(); row[offsets.auxiliaries + 48] = v_134.as_canonical_u64(); row[offsets.auxiliaries + 49] = v_135.as_canonical_u64(); row[offsets.auxiliaries + 50] = v_136.as_canonical_u64(); row[offsets.auxiliaries + 51] = v_137.as_canonical_u64(); row[offsets.auxiliaries + 52] = v_138.as_canonical_u64(); row[offsets.auxiliaries + 53] = v_139.as_canonical_u64(); let [v_142]: [G; 1] = [v_16 * v_135]; let [v_144]: [G; 1] = [v_45 * v_136]; let [v_148]: [G; 1] = [v_26 * v_32]; row[offsets.auxiliaries + 54] = v_148.as_canonical_u64(); let [v_149]: [G; 1] = [v_30 * v_28]; row[offsets.auxiliaries + 55] = v_149.as_canonical_u64(); let [v_150]: [G; 1] = [v_148 + v_149]; let [v_151]: [G; 1] = [v_150 + v_134]; let [v_152]: [G; 1] = [v_151 + v_142]; let [v_153]: [G; 1] = [v_152 + v_144]; let [v_154, v_155, v_156, v_157, v_158, v_159, v_160, v_161]: [G; 8] = v_153.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 56] = v_154.as_canonical_u64(); row[offsets.auxiliaries + 57] = v_155.as_canonical_u64(); row[offsets.auxiliaries + 58] = v_156.as_canonical_u64(); row[offsets.auxiliaries + 59] = v_157.as_canonical_u64(); row[offsets.auxiliaries + 60] = v_158.as_canonical_u64(); row[offsets.auxiliaries + 61] = v_159.as_canonical_u64(); row[offsets.auxiliaries + 62] = v_160.as_canonical_u64(); row[offsets.auxiliaries + 63] = v_161.as_canonical_u64(); let [v_164]: [G; 1] = [v_16 * v_157]; let [v_166]: [G; 1] = [v_45 * v_158]; let [v_170]: [G; 1] = [v_30 * v_32]; row[offsets.auxiliaries + 64] = v_170.as_canonical_u64(); let [v_171]: [G; 1] = [v_170 + v_156]; let [v_172]: [G; 1] = [v_171 + v_164]; let [v_173]: [G; 1] = [v_172 + v_166]; let [v_174, v_175, v_176, v_177, v_178, v_179, v_180, v_181]: [G; 8] = v_173.as_canonical_u64().to_le_bytes().map(G::from_u8); row[offsets.auxiliaries + 65] = v_174.as_canonical_u64(); row[offsets.auxiliaries + 66] = v_175.as_canonical_u64(); row[offsets.auxiliaries + 67] = v_176.as_canonical_u64(); row[offsets.auxiliaries + 68] = v_177.as_canonical_u64(); row[offsets.auxiliaries + 69] = v_178.as_canonical_u64(); row[offsets.auxiliaries + 70] = v_179.as_canonical_u64(); row[offsets.auxiliaries + 71] = v_180.as_canonical_u64(); row[offsets.auxiliaries + 72] = v_181.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::Mul(133, 135), Op::Const(G::from_u64(2)), Op::Sub(133, 137), Op::Mul(136, 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::Mul(167, 168), Op::Sub(167, 137), Op::Mul(169, 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::Mul(198, 199), Op::Sub(198, 137), Op::Mul(200, 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::Mul(229, 230), Op::Sub(229, 137), Op::Mul(231, 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::Mul(260, 261), Op::Sub(260, 137), Op::Mul(262, 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::Mul(291, 292), Op::Sub(291, 137), Op::Mul(293, 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::Mul(322, 323), Op::Sub(322, 137), Op::Mul(324, 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::Mul(353, 354), Op::Sub(353, 137), Op::Mul(355, 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::Mul(384, 385), Op::Sub(384, 137), Op::Mul(386, 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::Mul(415, 416), Op::Sub(415, 137), Op::Mul(417, 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::Mul(446, 447), Op::Sub(446, 137), Op::Mul(448, 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::Mul(477, 478), Op::Sub(477, 137), Op::Mul(479, 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::Mul(508, 509), Op::Sub(508, 137), Op::Mul(510, 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::Mul(539, 540), Op::Sub(539, 137), Op::Mul(541, 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::Mul(570, 571), Op::Sub(570, 137), Op::Mul(572, 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::Mul(601, 602), Op::Sub(601, 137), Op::Mul(603, 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::Add(34, 43), Op::Const(G::from_u64(65536)), Op::Mul(16, 37), Op::Add(36, 46), Op::Mul(45, 38), Op::Add(47, 48), Op::Mul(45, 49), Op::Add(44, 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(52, 53), Op::Add(54, 36), Op::Add(55, 46), Op::Add(56, 48), Op::UnconstrainedGToBytes(57), Op::U8RangeCheck(58, 59), Op::U8RangeCheck(60, 61), Op::U8RangeCheck(62, 42), Op::Mul(16, 59), Op::Add(58, 66), Op::Mul(16, 61), Op::Add(60, 68), Op::Mul(45, 62), Op::Add(69, 70), Op::Mul(45, 71), Op::Add(67, 72), Op::AssertEq(vec![57], vec![73], Some("u64_mul: column hint does not recompose".into())), Op::Mul(18, 28), Op::Mul(22, 24), Op::Add(74, 75), Op::Mul(26, 20), Op::Add(76, 77), Op::Add(78, 60), Op::Add(79, 68), Op::Add(80, 70), Op::UnconstrainedGToBytes(81), Op::U8RangeCheck(82, 83), Op::U8RangeCheck(84, 85), Op::U8RangeCheck(86, 42), Op::Mul(16, 83), Op::Add(82, 90), Op::Mul(16, 85), Op::Add(84, 92), Op::Mul(45, 86), Op::Add(93, 94), Op::Mul(45, 95), Op::Add(91, 96), Op::AssertEq(vec![81], vec![97], Some("u64_mul: column hint does not recompose".into())), Op::Mul(18, 32), Op::Mul(22, 28), Op::Add(98, 99), Op::Mul(26, 24), Op::Add(100, 101), Op::Mul(30, 20), Op::Add(102, 103), Op::Add(104, 84), Op::Add(105, 92), Op::Add(106, 94), Op::UnconstrainedGToBytes(107), Op::U8RangeCheck(108, 109), Op::U8RangeCheck(110, 111), Op::U8RangeCheck(112, 42), Op::Mul(16, 109), Op::Add(108, 116), Op::Mul(16, 111), Op::Add(110, 118), Op::Mul(45, 112), Op::Add(119, 120), Op::Mul(45, 121), Op::Add(117, 122), Op::AssertEq(vec![107], vec![123], Some("u64_mul: column hint does not recompose".into())), Op::Mul(22, 32), Op::Mul(26, 28), Op::Add(124, 125), Op::Mul(30, 24), Op::Add(126, 127), Op::Add(128, 110), Op::Add(129, 118), Op::Add(130, 120), Op::UnconstrainedGToBytes(131), Op::U8RangeCheck(132, 133), Op::U8RangeCheck(134, 135), Op::U8RangeCheck(136, 42), Op::Mul(16, 133), Op::Add(132, 140), Op::Mul(16, 135), Op::Add(134, 142), Op::Mul(45, 136), Op::Add(143, 144), Op::Mul(45, 145), Op::Add(141, 146), Op::AssertEq(vec![131], vec![147], Some("u64_mul: column hint does not recompose".into())), Op::Mul(26, 32), Op::Mul(30, 28), Op::Add(148, 149), Op::Add(150, 134), Op::Add(151, 142), Op::Add(152, 144), Op::UnconstrainedGToBytes(153), Op::U8RangeCheck(154, 155), Op::U8RangeCheck(156, 157), Op::U8RangeCheck(158, 42), Op::Mul(16, 155), Op::Add(154, 162), Op::Mul(16, 157), Op::Add(156, 164), Op::Mul(45, 158), Op::Add(165, 166), Op::Mul(45, 167), Op::Add(163, 168), Op::AssertEq(vec![153], vec![169], Some("u64_mul: column hint does not recompose".into())), Op::Mul(30, 32), Op::Add(170, 156), Op::Add(171, 164), Op::Add(172, 166), Op::UnconstrainedGToBytes(173), Op::U8RangeCheck(174, 175), Op::U8RangeCheck(176, 177), Op::U8RangeCheck(178, 42), Op::Mul(16, 175), Op::Add(174, 182), Op::Mul(16, 177), Op::Add(176, 184), Op::Mul(45, 178), Op::Add(185, 186), Op::Mul(45, 187), Op::Add(183, 188), Op::AssertEq(vec![173], vec![189], Some("u64_mul: column hint does not recompose".into())), Op::AssertEq(vec![178], vec![42], Some("u64_mul: final carry exceeds one radix digit".into()))], ctrl: Ctrl::Return(0, vec![34, 35, 58, 59, 82, 83, 108, 109, 132, 133, 154, 155, 174, 175, 176, 177]) }, 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: [205, 89, 45, 81, 115, 192, 43, 229, 178, 117, 203, 87, 188, 146, 231, 25, 106, 211, 41, 51, 208, 189, 121, 121, 56, 36, 50, 146, 157, 240, 103, 180], 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(()) }, 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(()) }, 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(()) }, 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(()) }, 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, 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(()) }, 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, 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, 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, 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, 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, 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, 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(()) }, 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, 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(()) }, 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(()) }, 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, 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, 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(()) }, 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(()) }, 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(()) }, 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 deleted file mode 100644 index 83e29d43d..000000000 --- a/crates/aiur/src/trace_codegen/tests/generated_cuda.rs +++ /dev/null @@ -1,51 +0,0 @@ -// 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([205, 89, 45, 81, 115, 192, 43, 229, 178, 117, 203, 87, 188, 146, 231, 25, 106, 211, 41, 51, 208, 189, 121, 121, 56, 36, 50, 146, 157, 240, 103, 180], 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/aiur/src/trace_heights.rs b/crates/aiur/src/trace_heights.rs deleted file mode 100644 index 35e5ffaf6..000000000 --- a/crates/aiur/src/trace_heights.rs +++ /dev/null @@ -1,57 +0,0 @@ -// Copyright (c) 2026 Argument Computer Corporation. -// SPDX-License-Identifier: MIT OR Apache-2.0 - -/// Match active-order degrees to canonical fixed preprocessed heights. -/// Zero denotes a circuit without a fixed height; inactive unfixed circuits -/// consume no degree. Fixed circuits must be active. This check precedes PCS -/// verification so fixed-table extraction -/// has an explicit height condition at the Aiur verifier boundary. -pub(crate) fn fixed_trace_heights( - heights: impl ExactSizeIterator, - active: &[bool], - log_degrees: &[u8], -) -> bool { - if heights.len() != active.len() { - return false; - } - let mut degrees = log_degrees.iter(); - for (height, &is_active) in heights.zip(active) { - if height != 0 && !is_active { - return false; - } - if is_active { - let Some(°ree) = degrees.next() else { - return false; - }; - if height != 0 { - let Some(actual) = 1_u64.checked_shl(u32::from(degree)) else { - return false; - }; - if u64::try_from(height) != Ok(actual) { - return false; - } - } - } - } - degrees.next().is_none() -} - -/// Every input matrix must be injected before the path reaches the cap. -/// The native MMCS clamps a cap to the tallest matrix's tree depth; that -/// still omits shorter matrices when the cap lies below their injection. -/// Subtract the shared blowup first, avoiding machine addition overflow. -pub(crate) fn trace_cap_coverage( - log_blowup: usize, - cap_height: usize, - log_degrees: &[u8], -) -> bool { - // Every nonempty trace's LDE has at least 2^log_blowup rows. The default - // root cap therefore needs no extra traversal of the circuit degrees. - if cap_height <= log_blowup { - return true; - } - let maximum = log_degrees.iter().copied().max().unwrap_or(0); - let effective = - cap_height.saturating_sub(log_blowup).min(usize::from(maximum)); - log_degrees.iter().all(|°ree| effective <= usize::from(degree)) -} diff --git a/crates/aiur/src/value.rs b/crates/aiur/src/value.rs new file mode 100644 index 000000000..89a52d4af --- /dev/null +++ b/crates/aiur/src/value.rs @@ -0,0 +1,330 @@ +//! Entry-only structured IO. No pointer or opaque-type variant is available. +use crate::field::FieldBackend; +use serde::{Deserialize, Serialize}; +use serde_json::Value as Json; +use std::fmt; + +#[derive(Clone, Debug, Serialize, Deserialize)] +#[serde(tag = "kind", rename_all = "snake_case")] +pub enum IoType { + Field, + Tuple { items: Vec }, + Array { element: Box, length: usize }, + Struct { name: String, fields: Vec<(String, IoType)> }, + Enum { name: String, constructors: Vec<(String, Vec)> }, +} +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(tag = "kind", rename_all = "snake_case")] +pub enum Value { + Field { value: u64 }, + Tuple { items: Vec }, + Array { items: Vec }, + Struct { name: String, fields: Vec<(String, Value)> }, + Enum { name: String, constructor: String, args: Vec }, +} +impl From for Value { + fn from(value: u64) -> Self { + Self::Field { value } + } +} +fn widths(items: &[IoType]) -> Result { + items.iter().try_fold(0usize, |n, t| { + n.checked_add(t.checked_width()?).ok_or("IO width overflow".into()) + }) +} +impl IoType { + pub fn checked_width(&self) -> Result { + match self { + Self::Field => Ok(1), + Self::Tuple { items } => widths(items), + Self::Array { element, length } => element + .checked_width()? + .checked_mul(*length) + .ok_or("IO width overflow".into()), + Self::Struct { fields, .. } => { + fields.iter().try_fold(0usize, |n, (_, t)| { + n.checked_add(t.checked_width()?).ok_or("IO width overflow".into()) + }) + }, + Self::Enum { constructors, .. } => { + let payload = constructors + .iter() + .map(|(_, fields)| widths(fields)) + .collect::, _>>()? + .into_iter() + .max() + .unwrap_or(0); + payload + .checked_add(usize::from(constructors.len() > 1)) + .ok_or("IO width overflow".into()) + }, + } + } + /// Type-directed JSON: numbers for fields, arrays for tuples/arrays, objects + /// for structs, and {"Constructor": [arguments]} for enum values. + pub fn read_json(&self, json: &Json) -> Result { + match self { + Self::Field => Ok(Value::from( + json.as_u64().ok_or("expected a nonnegative field integer")?, + )), + Self::Tuple { items } => { + Ok(Value::Tuple { items: read_list(items, json)? }) + }, + Self::Array { element, length } => { + let values = json.as_array().ok_or("expected an array")?; + if values.len() != *length { + return Err("array length mismatch".into()); + } + Ok(Value::Array { + items: values + .iter() + .map(|v| element.read_json(v)) + .collect::>()?, + }) + }, + Self::Struct { name, fields } => { + let values = json.as_object().ok_or("expected a struct object")?; + if values.len() != fields.len() { + return Err("struct field count mismatch".into()); + } + Ok(Value::Struct { + name: name.clone(), + fields: fields + .iter() + .map(|(n, t)| { + Ok(( + n.clone(), + t.read_json( + values + .get(n) + .ok_or_else(|| format!("missing struct field {n}"))?, + )?, + )) + }) + .collect::>()?, + }) + }, + Self::Enum { name, constructors } => { + let object = + json.as_object().ok_or("expected a single-constructor object")?; + if object.len() != 1 { + return Err("expected exactly one enum constructor".into()); + } + let (ctor, args) = object.iter().next().unwrap(); + let (_, types) = constructors + .iter() + .find(|(n, _)| n == ctor) + .ok_or_else(|| format!("unknown constructor {name}::{ctor}"))?; + Ok(Value::Enum { + name: name.clone(), + constructor: ctor.clone(), + args: read_list(types, args)?, + }) + }, + } + } + pub fn flatten( + &self, + value: &Value, + field: B, + ) -> Result, String> { + let mut output = vec![]; + match (self, value) { + (Self::Field, Value::Field { value }) if field.contains(*value) => { + output.push(field.from_u64(*value)) + }, + (Self::Tuple { items: types }, Value::Tuple { items }) => { + output = flatten_list(types, items, field)? + }, + (Self::Array { element, length }, Value::Array { items }) + if items.len() == *length => + { + for value in items { + output.extend(element.flatten(value, field)?); + } + }, + ( + Self::Struct { name, fields: types }, + Value::Struct { name: actual, fields }, + ) if name == actual && types.len() == fields.len() => { + for (n, t) in types { + if fields.iter().filter(|(k, _)| k == n).count() != 1 { + return Err(format!("missing or duplicate field {n}")); + } + output.extend( + t.flatten(&fields.iter().find(|(k, _)| k == n).unwrap().1, field)?, + ); + } + }, + ( + Self::Enum { name, constructors }, + Value::Enum { name: actual, constructor, args }, + ) if name == actual => { + let (index, (_, types)) = constructors + .iter() + .enumerate() + .find(|(_, (n, _))| n == constructor) + .ok_or("unknown enum constructor")?; + if constructors.len() as u128 > u128::from(field.modulus()) { + return Err("enum tags do not fit in field".into()); + } + if constructors.len() > 1 { + output.push(field.from_u64(index as u64)); + } + output.extend(flatten_list(types, args, field)?); + output.resize(self.checked_width()?, field.zero()); + }, + _ => { + return Err( + "value does not match entry IO type, or field element is noncanonical".into(), + ); + }, + } + Ok(output) + } + pub fn unflatten( + &self, + words: &[B::Element], + field: B, + ) -> Result { + if words.len() != self.checked_width()? + || words.iter().any(|w| !field.valid(*w)) + { + return Err("invalid flat entry value".into()); + } + match self { + Self::Field => Ok(field.to_u64(words[0]).into()), + Self::Tuple { items } => { + Ok(Value::Tuple { items: unflatten_list(items, words, field)? }) + }, + Self::Array { element, length } => { + let width = element.checked_width()?; + let items = (0..*length) + .map(|i| element.unflatten(&words[i * width..(i + 1) * width], field)) + .collect::>()?; + Ok(Value::Array { items }) + }, + Self::Struct { name, fields } => { + let mut offset = 0; + let mut values = vec![]; + for (n, t) in fields { + let width = t.checked_width()?; + values.push(( + n.clone(), + t.unflatten(&words[offset..offset + width], field)?, + )); + offset += width; + } + Ok(Value::Struct { name: name.clone(), fields: values }) + }, + Self::Enum { name, constructors } => { + let tagged = constructors.len() > 1; + if constructors.len() as u128 > u128::from(field.modulus()) { + return Err("enum tags do not fit in field".into()); + } + let tag = if tagged { + usize::try_from(field.to_u64(words[0])) + .map_err(|_| "invalid enum tag")? + } else { + 0 + }; + let (constructor, types) = + constructors.get(tag).ok_or("invalid enum tag")?; + let payload = &words[usize::from(tagged)..]; + let width = widths(types)?; + if payload[width..].iter().any(|w| *w != field.zero()) { + return Err("nonzero enum padding".into()); + } + let args = unflatten_list(types, &payload[..width], field)?; + Ok(Value::Enum { + name: name.clone(), + constructor: constructor.clone(), + args, + }) + }, + } + } +} +fn read_list(types: &[IoType], json: &Json) -> Result, String> { + let values = json.as_array().ok_or("expected an array of values")?; + if types.len() != values.len() { + return Err("value arity mismatch".into()); + } + types.iter().zip(values).map(|(t, v)| t.read_json(v)).collect() +} +fn flatten_list( + types: &[IoType], + values: &[Value], + field: B, +) -> Result, String> { + if types.len() != values.len() { + return Err("value arity mismatch".into()); + } + let mut result = vec![]; + for (t, v) in types.iter().zip(values) { + result.extend(t.flatten(v, field)?); + } + Ok(result) +} +fn unflatten_list( + types: &[IoType], + words: &[B::Element], + field: B, +) -> Result, String> { + let mut offset = 0; + let mut result = vec![]; + for ty in types { + let width = ty.checked_width()?; + result.push(ty.unflatten(&words[offset..offset + width], field)?); + offset += width; + } + Ok(result) +} +impl fmt::Display for Value { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fn list(f: &mut fmt::Formatter<'_>, values: &[Value]) -> fmt::Result { + for (i, value) in values.iter().enumerate() { + if i != 0 { + write!(f, ", ")?; + } + write!(f, "{value}")?; + } + Ok(()) + } + match self { + Self::Field { value } => write!(f, "{value}"), + Self::Tuple { items } => { + write!(f, "(")?; + list(f, items)?; + if items.len() == 1 { + write!(f, ",")?; + } + write!(f, ")") + }, + Self::Array { items } => { + write!(f, "[")?; + list(f, items)?; + write!(f, "]") + }, + Self::Struct { name, fields } => { + write!(f, "{name} {{")?; + for (i, (n, v)) in fields.iter().enumerate() { + if i != 0 { + write!(f, ",")?; + } + write!(f, " {n}: {v}")?; + } + write!(f, " }}") + }, + Self::Enum { name, constructor, args } => { + write!(f, "{name}::{constructor}")?; + if !args.is_empty() { + write!(f, "(")?; + list(f, args)?; + write!(f, ")")?; + } + Ok(()) + }, + } + } +} diff --git a/crates/aiur/tests/execution.rs b/crates/aiur/tests/execution.rs new file mode 100644 index 000000000..3f95d7f9e --- /dev/null +++ b/crates/aiur/tests/execution.rs @@ -0,0 +1,568 @@ +use aiur::bytecode::{ + Binary, Entry, Function, Instruction as Op, Program, Type, VERSION, +}; +use aiur::execute::QueryInput; +use aiur::field::PrimeField; +use aiur::value::{IoType, Value}; +use serde_json::json; + +fn function(name: &str, registers: usize, code: Vec) -> Function { + Function { + name: name.into(), + params: vec![Type::Field], + result: Type::Field, + registers, + code, + } +} +fn program(functions: Vec, root: usize) -> Program { + Program { + version: VERSION, + modulus: 65_537, + functions, + enums: vec![], + tables: vec![], + maps: vec![], + entries: vec![Entry { + name: "main".into(), + function: root, + inputs: vec![IoType::Field], + output: Some(IoType::Field), + }], + } +} +fn fib() -> Function { + function( + "fib", + 7, + vec![ + Op::Branch { tests: vec![(0, 0)], otherwise: 3 }, + Op::Literal { dest: 1, value: 0 }, + Op::Ret { value: vec![1] }, + Op::Branch { tests: vec![(0, 1)], otherwise: 6 }, + Op::Literal { dest: 1, value: 1 }, + Op::Ret { value: vec![1] }, + Op::Literal { dest: 1, value: 1 }, + Op::Binary { dest: 2, operator: Binary::Sub, left: 0, right: 1 }, + Op::Call { function: 0, args: vec![2], dest: vec![3] }, + Op::Binary { dest: 4, operator: Binary::Sub, left: 2, right: 1 }, + Op::Call { function: 0, args: vec![4], dest: vec![5] }, + Op::Binary { dest: 6, operator: Binary::Add, left: 3, right: 5 }, + Op::Ret { value: vec![6] }, + ], + ) +} + +#[test] +fn memoized_fibonacci_and_isolated_sessions() { + let p = program(vec![fib()], 0).check().unwrap(); + let result = p.execute("main", vec![20]).unwrap(); + assert_eq!(result.output, vec![6765]); + assert_eq!(result.queries.len(), 21); + assert!(result.instructions < 250); + assert_eq!( + result + .queries + .get(&QueryInput { function: 0, args: vec![18] }) + .unwrap() + .multiplicity, + 2 + ); + let again = p.execute("main", vec![20]).unwrap(); + assert_eq!(result.queries, again.queries); +} + +#[cfg(feature = "function-profile")] +#[test] +fn function_profile_tracks_recursive_misses_and_cached_calls_without_changing_records() + { + let root = function( + "root", + 4, + vec![ + Op::Call { function: 0, args: vec![0], dest: vec![1] }, + Op::Call { function: 0, args: vec![0], dest: vec![2] }, + Op::Binary { dest: 3, operator: Binary::Add, left: 1, right: 2 }, + Op::Ret { value: vec![3] }, + ], + ); + let p = program(vec![fib(), root], 1).check().unwrap(); + let hints = p.prepare_hints(&[]).unwrap(); + let normal = hints.execute("main", vec![20]).unwrap(); + let mut profile = aiur::function_profile::FunctionProfiler::new(2); + let measured = + hints.execute_profiled("main", vec![20], &mut profile).unwrap(); + assert_eq!(measured.output, normal.output); + assert_eq!(measured.queries, normal.queries); + assert_eq!(measured.instructions, normal.instructions); + assert!(profile.is_complete()); + let fib = &profile.functions[0]; + let root = &profile.functions[1]; + assert_eq!((fib.calls, fib.cache_hits), (40, 19)); + assert_eq!((root.calls, root.cache_hits), (1, 0)); + assert_eq!(root.inclusive_ns, root.self_ns + fib.self_ns); + assert!(fib.inclusive_ns >= fib.self_ns); + assert!(fib.cached_ns <= fib.self_ns); +} + +#[test] +fn constant_division_respects_joins_and_register_overwrites() { + let joined = function( + "joined", + 3, + vec![ + Op::Literal { dest: 1, value: 3 }, + Op::Branch { tests: vec![(0, 15)], otherwise: 4 }, + Op::Literal { dest: 1, value: 5 }, + Op::Jump { target: 4 }, + Op::Binary { dest: 2, operator: Binary::Div, left: 0, right: 1 }, + Op::Ret { value: vec![2] }, + ], + ); + let mut p = program(vec![joined], 0); + p.modulus = 97; + let p = p.check().unwrap(); + assert_eq!(p.execute("main", vec![15]).unwrap().output, [3]); + assert_eq!(p.execute("main", vec![9]).unwrap().output, [3]); + + let overwritten = function( + "overwritten", + 3, + vec![ + Op::Literal { dest: 1, value: 3 }, + Op::Binary { dest: 1, operator: Binary::Add, left: 0, right: 1 }, + Op::Binary { dest: 2, operator: Binary::Div, left: 0, right: 1 }, + Op::Ret { value: vec![2] }, + ], + ); + let mut p = program(vec![overwritten], 0); + p.modulus = 97; + assert_eq!(p.check().unwrap().execute("main", vec![3]).unwrap().output, [49]); +} + +#[test] +fn copies_read_all_sources_before_writing_destinations() { + let swap = function( + "swap", + 2, + vec![ + Op::Literal { dest: 1, value: 7 }, + Op::Copy { dest: vec![0, 1], source: vec![1, 0] }, + Op::Binary { dest: 0, operator: Binary::Sub, left: 0, right: 1 }, + Op::Ret { value: vec![0] }, + ], + ); + let mut p = program(vec![swap], 0); + p.modulus = 97; + assert_eq!( + p.check().unwrap().execute("main", vec![13]).unwrap().output, + [91] + ); +} + +#[test] +fn return_folding_preserves_simultaneous_copies_joins_and_instruction_counts() { + let mut f = function( + "tail", + 3, + vec![ + Op::Literal { dest: 1, value: 7 }, + Op::Branch { tests: vec![(0, 0)], otherwise: 4 }, + Op::Copy { dest: vec![0, 1], source: vec![1, 0] }, + Op::Jump { target: 5 }, + // Repeated destinations use the last source, read before any write. + Op::Copy { dest: vec![1, 1], source: vec![1, 0] }, + Op::Copy { dest: vec![2], source: vec![0] }, + Op::Copy { dest: vec![0, 1], source: vec![1, 2] }, + Op::Guard { tests: vec![], message: "unused".into() }, + Op::Ret { value: vec![0, 1] }, + // Unreachable malformed operations must not crash the linker. + Op::Store { + r#type: Type::Enum { name: "unknown".into() }, + value: vec![], + dest: 999, + }, + Op::Copy { dest: vec![0], source: vec![] }, + Op::Ret { value: vec![0] }, + ], + ); + f.result = Type::Tuple { items: vec![Type::Field, Type::Field] }; + let mut p = program(vec![f], 0); + p.entries[0].output = None; + let p = p.check().unwrap(); + let zero = p.execute("main", vec![0]).unwrap(); + assert_eq!(zero.output, [0, 7]); + assert_eq!(zero.instructions, 8); + let other = p.execute("main", vec![13]).unwrap(); + assert_eq!(other.output, [13, 13]); + assert_eq!(other.instructions, 7); +} + +#[test] +fn distinct_entries_into_a_skipped_prefix_keep_their_instruction_counts() { + let f = function( + "prefix", + 2, + vec![ + Op::Branch { tests: vec![(0, 0)], otherwise: 3 }, + Op::Guard { tests: vec![], message: "skipped".into() }, + Op::Guard { tests: vec![], message: "skipped".into() }, + Op::Neg { dest: 1, source: 0 }, + Op::Guard { tests: vec![], message: "return suffix".into() }, + Op::Ret { value: vec![1] }, + ], + ); + let p = program(vec![f], 0).check().unwrap(); + let zero = p.execute("main", vec![0]).unwrap(); + assert_eq!(zero.output, [0]); + assert_eq!(zero.instructions, 6); + let other = p.execute("main", vec![1]).unwrap(); + assert_eq!(other.output, [65_536]); + assert_eq!(other.instructions, 4); +} + +#[test] +fn folded_return_still_checks_enum_tags_and_padding_at_the_original_pc() { + use aiur::bytecode::{Constructor, Enum}; + let mut f = function( + "bad_result", + 4, + vec![ + Op::Literal { dest: 1, value: 7 }, + Op::Copy { dest: vec![2, 3], source: vec![0, 1] }, + Op::Jump { target: 3 }, + Op::Ret { value: vec![2, 3] }, + ], + ); + f.result = Type::Enum { name: "Maybe".into() }; + let mut p = program(vec![f], 0); + p.entries[0].output = None; + p.enums = vec![Enum { + name: "Maybe".into(), + constructors: vec![ + Constructor { name: "None".into(), fields: vec![] }, + Constructor { name: "Some".into(), fields: vec![Type::Field] }, + ], + }]; + let p = p.check().unwrap(); + for (tag, message) in [(2, "invalid enum tag"), (0, "nonzero enum padding")] { + let error = p.execute("main", vec![tag]).unwrap_err(); + assert_eq!(error.instruction, 3); + assert_eq!(error.message, message); + } + assert_eq!(p.execute("main", vec![1]).unwrap().output, [1, 7]); +} + +#[test] +fn hits_do_not_reexecute_callees_and_counts_do_not_wrap_in_the_field() { + let leaf = function("leaf", 1, vec![Op::Ret { value: vec![0] }]); + let parent = function( + "parent", + 2, + vec![ + Op::Call { function: 0, args: vec![0], dest: vec![1] }, + Op::Call { function: 0, args: vec![0], dest: vec![1] }, + Op::Ret { value: vec![1] }, + ], + ); + let mut calls = + vec![Op::Call { function: 1, args: vec![0], dest: vec![1] }; 5]; + calls.push(Op::Ret { value: vec![1] }); + let root = function("root", 2, calls); + let mut p = program(vec![leaf, parent, root], 2); + p.modulus = 2; + let result = p.check().unwrap().execute("main", vec![1]).unwrap(); + assert_eq!( + result + .queries + .get(&QueryInput { function: 2, args: vec![1] }) + .unwrap() + .multiplicity, + 1 + ); + assert_eq!( + result + .queries + .get(&QueryInput { function: 1, args: vec![1] }) + .unwrap() + .multiplicity, + 5 + ); + assert_eq!( + result + .queries + .get(&QueryInput { function: 0, args: vec![1] }) + .unwrap() + .multiplicity, + 2 + ); +} + +#[test] +fn mutual_recursion_uses_a_vm_stack() { + fn countdown(name: &str, next: usize) -> Function { + function( + name, + 3, + vec![ + Op::Branch { tests: vec![(0, 0)], otherwise: 2 }, + Op::Ret { value: vec![0] }, + Op::Literal { dest: 1, value: 1 }, + Op::Binary { dest: 2, operator: Binary::Sub, left: 0, right: 1 }, + Op::Call { function: next, args: vec![2], dest: vec![1] }, + Op::Ret { value: vec![1] }, + ], + ) + } + let p = + program(vec![countdown("a", 1), countdown("b", 0)], 0).check().unwrap(); + let result = p.execute("main", vec![20_000]).unwrap(); + assert_eq!(result.output, vec![0]); + assert_eq!(result.queries.len(), 20_001); +} + +#[test] +fn pending_cycle_is_an_error() { + let p = program( + vec![function( + "cycle", + 1, + vec![ + Op::Call { function: 0, args: vec![0], dest: vec![0] }, + Op::Ret { value: vec![0] }, + ], + )], + 0, + ) + .check() + .unwrap(); + assert!( + p.execute("main", vec![1]) + .unwrap_err() + .message + .contains("already being evaluated") + ); + assert!( + p.execute("hidden", vec![1]).unwrap_err().message.contains("unselected") + ); +} + +#[test] +fn invalid_control_flow_and_uninitialized_reads_are_rejected() { + for code in [ + vec![Op::Jump { target: 0 }], + vec![Op::Ret { value: vec![1] }], + vec![Op::Literal { dest: 2, value: 3 }, Op::Ret { value: vec![0] }], + vec![ + Op::Branch { tests: vec![(0, 0)], otherwise: 2 }, + Op::Literal { dest: 1, value: 0 }, + Op::Ret { value: vec![1] }, + ], + ] { + assert!(program(vec![function("bad", 2, code)], 0).check().is_err()); + } +} + +#[test] +fn inactive_failures_are_not_evaluated() { + let p = program( + vec![function( + "lazy", + 2, + vec![ + Op::Branch { tests: vec![(0, 0)], otherwise: 2 }, + Op::Ret { value: vec![0] }, + Op::Literal { dest: 1, value: 0 }, + Op::Binary { dest: 1, operator: Binary::Div, left: 0, right: 1 }, + Op::Ret { value: vec![1] }, + ], + )], + 0, + ) + .check() + .unwrap(); + assert_eq!(p.execute("main", vec![0]).unwrap().output, vec![0]); + assert!( + p.execute("main", vec![1]) + .unwrap_err() + .message + .contains("division by zero") + ); +} + +#[test] +fn missing_nondeterministic_data_is_an_error() { + let p = program( + vec![function( + "hint", + 2, + vec![ + Op::Hint { + channel: String::new(), + r#type: Type::Field, + key_type: Type::Field, + key: vec![0], + dest: vec![1], + }, + Op::Ret { value: vec![1] }, + ], + )], + 0, + ) + .check() + .unwrap(); + let error = p.execute("main", vec![1]).unwrap_err(); + assert_eq!(error.instruction, 0); + assert!(error.message.contains("missing hint")); +} + +#[test] +fn typed_rom_interning_and_capacity() { + let code = vec![ + Op::Store { r#type: Type::Field, value: vec![0], dest: 1 }, + Op::Store { r#type: Type::Field, value: vec![0], dest: 2 }, + Op::Load { r#type: Type::Field, pointer: 1, dest: vec![2] }, + Op::Ret { value: vec![2] }, + ]; + let p = program(vec![function("rom", 3, code)], 0).check().unwrap(); + let result = p.execute("main", vec![9]).unwrap(); + assert_eq!(result.output, vec![9]); + assert_eq!(result.memory.len(), 1); + assert_eq!(result.memory.get(0).unwrap().multiplicity, 3); + let code = vec![ + Op::Store { r#type: Type::Field, value: vec![0], dest: 1 }, + Op::Literal { dest: 2, value: 1 }, + Op::Store { r#type: Type::Field, value: vec![2], dest: 1 }, + Op::Store { r#type: Type::Tuple { items: vec![] }, value: vec![], dest: 1 }, + Op::Ret { value: vec![0] }, + ]; + let mut p = program(vec![function("full", 3, code)], 0); + p.modulus = 2; + // Capacity is per payload width: two width-one cells and one width-zero + // cell fit in characteristic two. + let record = p.check().unwrap().execute("main", vec![0]).unwrap(); + assert_eq!(record.memory.len(), 3); + let pair = Type::Tuple { items: vec![Type::Field; 2] }; + let mut p = program( + vec![function( + "full_width", + 3, + vec![ + Op::Literal { dest: 2, value: 1 }, + Op::Store { r#type: pair.clone(), value: vec![0, 0], dest: 1 }, + Op::Store { r#type: pair.clone(), value: vec![0, 2], dest: 1 }, + Op::Store { r#type: pair, value: vec![2, 0], dest: 1 }, + Op::Ret { value: vec![0] }, + ], + )], + 0, + ); + p.modulus = 2; + assert!( + p.check() + .unwrap() + .execute("main", vec![0]) + .unwrap_err() + .message + .contains("capacity") + ); +} + +#[test] +fn memory_index_survives_growth_and_shares_equal_width_encodings() { + let tuple = Type::Tuple { items: vec![Type::Field] }; + let mut code = vec![ + Op::Store { r#type: Type::Field, value: vec![0], dest: 2 }, + Op::Store { r#type: tuple.clone(), value: vec![0], dest: 3 }, + ]; + for value in 1..1024 { + code.push(Op::Literal { dest: 1, value }); + code.push(Op::Store { r#type: Type::Field, value: vec![1], dest: 4 }); + } + // Threading the jump must retain the destination store's linked type. + code.push(Op::Jump { target: code.len() + 1 }); + code.push(Op::Store { r#type: Type::Field, value: vec![0], dest: 4 }); + code.push(Op::AssertEq { + runtime_check: true, + left: vec![2], + right: vec![4], + message: None, + }); + code.push(Op::Load { r#type: Type::Field, pointer: 2, dest: vec![0] }); + code.push(Op::Ret { value: vec![0] }); + let checked = + program(vec![function("growth", 5, code.clone())], 0).check().unwrap(); + let record = checked.execute("main", vec![0]).unwrap(); + assert_eq!(record.output, [0]); + assert_eq!(record.memory.len(), 1024); + assert_eq!(record.memory.get(0).unwrap().multiplicity, 4); + assert_eq!(*record.memory.get(0).unwrap().cell.r#type, Type::Field); + let load = code.len() - 2; + code[load] = Op::Load { r#type: tuple, pointer: 2, dest: vec![0] }; + let checked = program(vec![function("same_encoding", 5, code.clone())], 0) + .check() + .unwrap(); + assert_eq!(checked.execute("main", vec![0]).unwrap().output, [0]); + code[load] = Op::Load { + r#type: Type::Tuple { items: vec![Type::Field; 2] }, + pointer: 2, + dest: vec![0, 1], + }; + let checked = + program(vec![function("absent_width", 5, code)], 0).check().unwrap(); + assert!( + checked + .execute("main", vec![0]) + .unwrap_err() + .message + .contains("dangling pointer") + ); +} + +#[test] +fn structured_io_roundtrips_and_validates_all_enum_padding() { + let f = PrimeField::new(97).unwrap(); + let unit = IoType::Enum { + name: "Unit".into(), + constructors: vec![("Unit".into(), vec![])], + }; + let ty = IoType::Struct { + name: "Packet".into(), + fields: vec![ + ("units".into(), IoType::Array { element: Box::new(unit), length: 3 }), + ( + "values".into(), + IoType::Enum { + name: "Choice".into(), + constructors: vec![ + ("None".into(), vec![]), + ( + "Some".into(), + vec![IoType::Array { + element: Box::new(IoType::Field), + length: 2, + }], + ), + ], + }, + ), + ("singleton".into(), IoType::Tuple { items: vec![IoType::Field] }), + ], + }; + let value = ty.read_json(&json!({"singleton":[4],"values":{"Some":[[7,8]]},"units":[{"Unit":[]},{"Unit":[]},{"Unit":[]}]})).unwrap(); + let flat = ty.flatten(&value, f).unwrap(); + assert_eq!(flat, vec![1, 7, 8, 4]); + assert_eq!(ty.unflatten(&flat, f).unwrap(), value); + assert_eq!( + value.to_string(), + "Packet { units: [Unit::Unit, Unit::Unit, Unit::Unit], values: Choice::Some([7, 8]), singleton: (4,) }" + ); + assert!(ty.unflatten(&[2, 0, 0, 4], f).is_err()); + assert!(ty.unflatten(&[0, 1, 0, 4], f).is_err()); + assert!(IoType::Field.flatten(&Value::from(97), f).is_err()); + assert!( + IoType::Tuple { items: vec![] } + .flatten(&Value::Array { items: vec![] }, f) + .is_err() + ); +} diff --git a/crates/aiur/tests/fields.rs b/crates/aiur/tests/fields.rs new file mode 100644 index 000000000..c85801ddc --- /dev/null +++ b/crates/aiur/tests/fields.rs @@ -0,0 +1,337 @@ +//! The interpreter must work with native elements, independently of their +//! storage size or arithmetic library, and preserve the integer wire contract. +use aiur::{ + Execution, Program, + field::{FieldBackend, NativeField, PrimeField64}, + hints::HintChannels, + maps::MapOverrides, +}; +use multi_stark::p3_goldilocks::Goldilocks; +use serde::Serialize; +use serde_json::{Value, json}; + +// An independent four-byte element/backend. This deliberately implements no +// Plonky3 traits: the execution core only needs the FieldBackend contract. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize)] +#[serde(transparent)] +struct Small(u32); +impl std::fmt::Display for Small { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + self.0.fmt(f) + } +} +#[derive(Clone, Copy, Debug)] +struct SmallField; +impl FieldBackend for SmallField { + type Element = Small; + fn modulus(self) -> u64 { + 97 + } + fn from_u64(self, x: u64) -> Small { + Small((x % 97) as u32) + } + fn to_u64(self, x: Small) -> u64 { + u64::from(x.0) + } + fn add(self, a: Small, b: Small) -> Small { + Small((a.0 + b.0) % 97) + } + fn sub(self, a: Small, b: Small) -> Small { + Small((a.0 + 97 - b.0) % 97) + } + fn neg(self, a: Small) -> Small { + Small((97 - a.0) % 97) + } + fn mul(self, a: Small, b: Small) -> Small { + Small(a.0 * b.0 % 97) + } + fn inverse(self, a: Small) -> Option { + (1..97).map(Small).find(|&b| self.mul(a, b) == Small(1)) + } +} + +fn snapshot(record: &Execution) -> Value { + json!({"output": record.output, + "queries": record.queries.iter().collect::>(), + "memory": record.memory, "instructions": record.instructions}) +} + +fn program( + modulus: u64, + functions: Value, + params: Value, + result: Value, +) -> Program { + serde_json::from_value(json!({ + "version": 2, "modulus": modulus, "enums": [], "tables": [], "maps": [], + "functions": functions, + "entries": [{"name": "main", "function": 0, "inputs": params, "output": result}] + })) + .unwrap() +} + +fn differential(field: B) { + let f = json!({"kind":"field"}); + let tuple = json!({"kind":"tuple", "items":[f,f,f,f]}); + let mut source = program( + field.modulus(), + json!([ + {"name":"main", "params":[f], "result":tuple, "registers":11, "code":[ + {"op":"call","function":1,"args":[0],"dest":[1]}, + {"op":"call","function":1,"args":[0],"dest":[2]}, + {"op":"store","type":f,"value":[1],"dest":3}, + {"op":"store","type":f,"value":[2],"dest":4}, + {"op":"load","type":f,"pointer":3,"dest":[5]}, + {"op":"literal","value":2,"dest":6}, + {"op":"binary","operator":"div","left":0,"right":6,"dest":7}, + {"op":"neg","source":7,"dest":8}, + {"op":"binary","operator":"add","left":7,"right":8,"dest":9}, + {"op":"hint","channel":"double","type":f,"key_type":f,"key":[0],"dest":[10]}, + {"op":"assert_eq","left":[1],"right":[5]}, + {"op":"ret","value":[2,7,9,10]}]}, + {"name":"leaf","params":[f],"result":f,"registers":2,"code":[ + {"op":"call","function":2,"args":[0],"dest":[1]}, + {"op":"ret","value":[1]}]} + ]), + json!([f]), + tuple, + ); + source.tables = serde_json::from_value(json!([ + {"name":"xs","type":{"kind":"tuple","items":[f]},"rows":[[2],[0],[1],[3]]}, + {"name":"squares","type":f,"rows":[[4],[0],[1],[9]]} + ])) + .unwrap(); + source.maps = serde_json::from_value(json!([ + {"name":"square","params":[f],"result":f,"input":0,"output":1} + ])) + .unwrap(); + let raw = source.clone().check().unwrap(); + let native = source.check_with(field).unwrap(); + let mut raw_channels = HintChannels::new(); + raw_channels + .insert( + "double", + aiur::bytecode::Type::Field, + aiur::bytecode::Type::Field, + |x, y| { + y[0] = 2 * x[0]; + Ok(()) + }, + ) + .unwrap(); + let mut channels = HintChannels::new(); + channels + .insert( + "double", + aiur::bytecode::Type::Field, + aiur::bytecode::Type::Field, + move |x: &[B::Element], y: &mut [B::Element]| { + y[0] = field.add(x[0], x[0]); + Ok(()) + }, + ) + .unwrap(); + let mut maps = MapOverrides::new(); + maps + .insert("square", 1, 1, move |x: &[B::Element], y: &mut [B::Element]| { + y[0] = field.mul(x[0], x[0]); + // The immutable input rows are [2, 0, 1, 3], in that order. + [2, 0, 1, 3] + .iter() + .position(|&v| x[0] == field.from_u64(v)) + .ok_or_else(|| "no table entry for map input".into()) + }) + .unwrap(); + let raw = raw.prepare_hint_channels(&[], &raw_channels).unwrap(); + let fallback = native.prepare_hint_channels(&[], &channels).unwrap(); + let accelerated = native + .prepare_hint_channels(&[], &channels) + .unwrap() + .with_map_overrides(&maps) + .unwrap(); + for x in 0..4 { + let expected = raw.execute("main", vec![x]).unwrap(); + for got in [&fallback, &accelerated] { + let got = got.execute("main", vec![field.from_u64(x)]).unwrap(); + assert_eq!(snapshot(&got), snapshot(&expected)); + assert_eq!(got.memory.len(), 1); + assert_eq!(got.memory.get(0).unwrap().multiplicity, 3); + } + } + assert!(field.decode(&[field.modulus()]).is_err()); +} + +#[test] +fn native_and_independent_fields_preserve_queries_memory_hints_and_tables() { + differential(NativeField::::new()); + differential(SmallField); + assert_eq!(std::mem::size_of::(), 4); +} + +#[test] +fn native_arithmetic_matches_integer_reduction_at_boundaries() { + let f = json!({"kind":"field"}); + let result = json!({"kind":"tuple", "items":[f,f,f,f,f]}); + let source = program( + Goldilocks::ORDER_U64, + json!([ + {"name":"arithmetic","params":[f,f],"result":result,"registers":7,"code":[ + {"op":"binary","operator":"add","left":0,"right":1,"dest":2}, + {"op":"binary","operator":"sub","left":0,"right":1,"dest":3}, + {"op":"binary","operator":"mul","left":0,"right":1,"dest":4}, + {"op":"binary","operator":"div","left":0,"right":1,"dest":5}, + {"op":"neg","source":0,"dest":6}, + {"op":"ret","value":[2,3,4,5,6]}]} + ]), + json!([f, f]), + result, + ); + let raw = source.clone().check().unwrap(); + let native = source.check_field::().unwrap(); + let p = Goldilocks::ORDER_U64; + for a in [0, 1, 2, p / 2, p - 2, p - 1] { + for b in [1, 2, 3, p / 2, p - 2, p - 1] { + let expected = raw.execute("main", vec![a, b]).unwrap(); + let got = native + .execute("main", native.field().decode(&[a, b]).unwrap()) + .unwrap(); + assert_eq!(snapshot(&got), snapshot(&expected)); + } + } + assert!( + native.execute("main", native.field().decode(&[1, 0]).unwrap()).is_err() + ); + assert!(raw.program().clone().check_with(SmallField).is_err()); +} + +#[test] +fn equal_native_representations_share_function_and_memory_rows() { + let f = json!({"kind":"field"}); + let source = program( + Goldilocks::ORDER_U64, + json!([ + {"name":"root","params":[f,f],"result":f,"registers":6,"code":[ + {"op":"call","function":1,"args":[0],"dest":[2]}, + {"op":"call","function":1,"args":[1],"dest":[3]}, + {"op":"store","type":f,"value":[0],"dest":4}, + {"op":"store","type":f,"value":[1],"dest":5}, + {"op":"assert_eq","left":[4],"right":[5]}, + {"op":"ret","value":[2]}]}, + {"name":"identity","params":[f],"result":f,"registers":1,"code":[ + {"op":"ret","value":[0]}]} + ]), + json!([f, f]), + f, + ); + let native = source.check_field::().unwrap(); + let record = native + .execute( + "main", + vec![Goldilocks::new(1), Goldilocks::new(Goldilocks::ORDER_U64 + 1)], + ) + .unwrap(); + assert_eq!(record.queries.len(), 2); + assert_eq!( + record + .queries + .iter() + .find(|(q, _)| q.function == 1) + .unwrap() + .1 + .multiplicity, + 2 + ); + assert_eq!(record.memory.len(), 1); + assert_eq!(record.memory.get(0).unwrap().multiplicity, 2); +} + +#[test] +fn multiplicities_remain_integers_above_the_field_order() { + let f = json!({"kind":"field"}); + let mut code = + vec![json!({"op":"call","function":1,"args":[0],"dest":[1]}); 100]; + code.push(json!({"op":"ret","value":[1]})); + let source = program( + 97, + json!([ + {"name":"root","params":[f],"result":f,"registers":2,"code":code}, + {"name":"leaf","params":[f],"result":f,"registers":1,"code":[{"op":"ret","value":[0]}]} + ]), + json!([f]), + f, + ); + let native = source.check_with(SmallField).unwrap(); + let record = native.execute("main", vec![Small(5)]).unwrap(); + assert_eq!( + record + .queries + .iter() + .find(|(q, _)| q.function == 1) + .unwrap() + .1 + .multiplicity, + 100 + ); + assert_eq!(record.output, [Small(5)]); +} + +#[test] +fn native_and_independent_fields_populate_the_same_trace() { + fn check(field: B) { + let f = json!({"kind":"field"}); + let source = program( + field.modulus(), + json!([ + {"name":"main","params":[f],"result":f,"registers":5,"code":[ + {"op":"literal","dest":1,"value":1}, + {"op":"binary","operator":"add","left":0,"right":1,"dest":2}, + {"op":"literal","dest":3,"value":2}, + {"op":"binary","operator":"div","left":2,"right":3,"dest":4}, + {"op":"ret","value":[4]}]} + ]), + json!([f]), + f, + ); + let artifact: aiur::trace::TraceArtifact = serde_json::from_value(json!({ + "version":2, "modulus":field.modulus(), + "functions":[{"name":"main","chip":"main","witnesses":4, + "inputs":[0],"output":[3], + "steps":[ + {"guard":{"const":1},"action":{"op":"assign","dest":[1], + "values":[{"add":[{"var":0},{"const":1}]}]}}, + {"guard":{"const":1},"action":{"op":"inverse","dest":2,"value":{"const":2}}}], + "writes":(0..4).map(|i| json!({"column":i,"source":i,"guard":{"const":1}})).collect::>() }], + "chips":[{"name":"main","width":5,"activation":4,"inputs":[0],"output":[{"var":3}], + "constraints":[ + {"mul":[{"var":4},{"sub":[{"var":3},{"mul":[{"var":1},{"var":2}]}]}]}, + {"mul":[{"var":4},{"sub":[{"var":1},{"add":[{"var":0},{"const":1}]}]}]}, + {"mul":[{"var":4},{"sub":[{"mul":[{"var":2},{"const":2}]},{"const":1}]}]}, + {"mul":[{"var":4},{"sub":[{"var":4},{"const":1}]}]}], + "sends":[],"memory":[]}] + })).unwrap(); + let raw = source.clone().check().unwrap(); + let native = source.check_with(field).unwrap(); + let plan = aiur::trace::TracePlan::new(&native, artifact.clone()).unwrap(); + let raw_plan = aiur::trace::TracePlan::new(&raw, artifact).unwrap(); + for x in [0, 1, 2, field.modulus() - 1] { + let args = [field.from_u64(x)]; + let record = native.execute("main", args.to_vec()).unwrap(); + let trace = plan.generate(&record, "main", &args, true).unwrap(); + assert_eq!( + trace, + plan.generate_reference(&record, "main", &args, true).unwrap() + ); + plan.check(&record, &trace, "main", &args).unwrap(); + let raw_record = raw.execute("main", vec![x]).unwrap(); + assert_eq!( + serde_json::to_value(trace).unwrap(), + serde_json::to_value( + raw_plan.generate(&raw_record, "main", &[x], true).unwrap() + ) + .unwrap() + ); + } + } + check(NativeField::::new()); + check(SmallField); +} diff --git a/crates/aiur/tests/fixtures/grouping.json b/crates/aiur/tests/fixtures/grouping.json new file mode 100644 index 000000000..8c6f04ca7 --- /dev/null +++ b/crates/aiur/tests/fixtures/grouping.json @@ -0,0 +1 @@ +{"program":{"entries":[{"function":0,"inputs":[{"kind":"field"}],"name":"Grouped::run","output":{"kind":"field"}}],"enums":[],"functions":[{"code":[{"dest":1,"op":"literal","value":0},{"args":[1],"dest":[2],"function":1,"op":"call"},{"message":"let pattern mismatch","op":"guard","tests":[]},{"args":[0],"dest":[3],"function":1,"op":"call"},{"message":"let pattern mismatch","op":"guard","tests":[]},{"dest":4,"op":"literal","value":1},{"dest":5,"left":0,"op":"binary","operator":"add","right":4},{"args":[5],"dest":[6],"function":1,"op":"call"},{"message":"let pattern mismatch","op":"guard","tests":[]},{"dest":7,"op":"literal","value":2},{"dest":8,"left":0,"op":"binary","operator":"add","right":7},{"args":[8],"dest":[9,10],"function":2,"op":"call"},{"message":"let pattern mismatch","op":"guard","tests":[]},{"dest":11,"left":2,"op":"binary","operator":"add","right":3},{"dest":12,"left":11,"op":"binary","operator":"add","right":9},{"dest":13,"left":12,"op":"binary","operator":"add","right":10},{"args":[0],"dest":[14],"function":3,"op":"call"},{"dest":15,"left":13,"op":"binary","operator":"add","right":14},{"dest":16,"left":15,"op":"binary","operator":"add","right":6},{"op":"ret","value":[16]}],"name":"Grouped::run","params":[{"kind":"field"}],"registers":17,"result":{"kind":"field"}},{"code":[{"op":"branch","otherwise":4,"tests":[[0,0]]},{"dest":2,"op":"literal","value":9},{"dest":[1],"op":"copy","source":[2]},{"op":"jump","target":10},{"op":"branch","otherwise":9,"tests":[]},{"dest":3,"left":0,"op":"binary","operator":"mul","right":0},{"dest":4,"left":3,"op":"binary","operator":"mul","right":0},{"dest":[1],"op":"copy","source":[4]},{"op":"jump","target":10},{"message":"no matching arm","op":"fail"},{"op":"ret","value":[1]}],"name":"Grouped::left","params":[{"kind":"field"}],"registers":5,"result":{"kind":"field"}},{"code":[{"dest":1,"op":"literal","value":3},{"dest":2,"left":0,"op":"binary","operator":"add","right":1},{"dest":3,"left":0,"op":"binary","operator":"mul","right":0},{"op":"ret","value":[2,3]}],"name":"Grouped::right","params":[{"kind":"field"}],"registers":4,"result":{"items":[{"kind":"field"},{"kind":"field"}],"kind":"tuple"}},{"code":[{"dest":1,"op":"literal","value":1},{"dest":2,"left":0,"op":"binary","operator":"add","right":1},{"dest":3,"op":"store","type":{"items":[{"kind":"field"},{"kind":"field"}],"kind":"tuple"},"value":[0,2]},{"message":"let pattern mismatch","op":"guard","tests":[]},{"dest":[4,5],"op":"load","pointer":3,"type":{"items":[{"kind":"field"},{"kind":"field"}],"kind":"tuple"}},{"message":"let pattern mismatch","op":"guard","tests":[]},{"dest":6,"left":4,"op":"binary","operator":"add","right":5},{"op":"ret","value":[6]}],"name":"Grouped::memory","params":[{"kind":"field"}],"registers":7,"result":{"kind":"field"}}],"maps":[],"modulus":18446744069414584321,"tables":[],"version":2},"trace":{"chips":[{"activation":7,"constraints":[{"mul":[{"var":7},{"sub":[{"var":7},{"const":1}]}]},{"mul":[{"sub":[{"const":1},{"var":7}]},{"sub":[{"const":1},{"sub":[{"const":1},{"var":7}]}]}]}],"inputs":[0],"memory":[],"name":"Grouped::run","output":[{"add":[{"var":1},{"add":[{"var":2},{"add":[{"var":3},{"add":[{"var":4},{"add":[{"var":5},{"var":6}]}]}]}]}]}],"sends":[{"args":[{"const":0}],"channel":"Grouped::left","enable":{"sub":[{"const":1},{"sub":[{"const":1},{"var":7}]}]},"result":[1]},{"args":[{"var":0}],"channel":"Grouped::left","enable":{"sub":[{"const":1},{"sub":[{"const":1},{"var":7}]}]},"result":[2]},{"args":[{"add":[{"var":0},{"const":1}]}],"channel":"Grouped::left","enable":{"sub":[{"const":1},{"sub":[{"const":1},{"var":7}]}]},"result":[3]},{"args":[{"add":[{"var":0},{"const":2}]}],"channel":"Grouped::right","enable":{"sub":[{"const":1},{"sub":[{"const":1},{"var":7}]}]},"result":[4,5]},{"args":[{"var":0}],"channel":"Grouped::memory","enable":{"sub":[{"const":1},{"sub":[{"const":1},{"var":7}]}]},"result":[6]}],"width":8},{"activation":5,"constraints":[{"mul":[{"var":5},{"sub":[{"var":5},{"const":1}]}]},{"mul":[{"add":[{"mul":[{"const":18446744069414584320},{"var":2}]},{"const":1}]},{"mul":[{"const":18446744069414584320},{"var":2}]}]},{"mul":[{"var":2},{"add":[{"var":2},{"const":18446744069414584320}]}]},{"mul":[{"var":2},{"add":[{"mul":[{"const":18446744069414584320},{"var":2}]},{"const":1}]}]},{"mul":[{"add":[{"mul":[{"const":18446744069414584320},{"var":2}]},{"const":1}]},{"var":0}]},{"sub":[{"mul":[{"add":[{"mul":[{"const":18446744069414584320},{"var":2}]},{"const":1}]},{"add":[{"var":1},{"const":18446744069414584312}]}]},{"mul":[{"const":18446744069414584312},{"sub":[{"const":1},{"var":5}]}]}]},{"mul":[{"var":2},{"sub":[{"mul":[{"var":0},{"var":3}]},{"const":1}]}]},{"mul":[{"var":2},{"sub":[{"var":4},{"mul":[{"var":0},{"var":0}]}]}]},{"mul":[{"var":2},{"sub":[{"var":1},{"mul":[{"var":4},{"var":0}]}]}]}],"inputs":[0],"memory":[],"name":"Grouped::left","output":[{"var":1}],"sends":[],"width":6},{"activation":2,"constraints":[{"mul":[{"var":2},{"sub":[{"var":2},{"const":1}]}]},{"sub":[{"var":1},{"mul":[{"var":0},{"var":0}]}]}],"inputs":[0],"memory":[],"name":"Grouped::right","output":[{"add":[{"var":0},{"const":3}]},{"var":1}],"sends":[],"width":3},{"activation":4,"constraints":[{"mul":[{"var":4},{"sub":[{"var":4},{"const":1}]}]},{"mul":[{"sub":[{"const":1},{"var":4}]},{"sub":[{"const":1},{"sub":[{"const":1},{"var":4}]}]}]}],"inputs":[0],"memory":[{"address":{"var":1},"enable":{"sub":[{"const":1},{"sub":[{"const":1},{"var":4}]}]},"type":{"items":[{"kind":"field"},{"kind":"field"}],"kind":"tuple"},"values":[{"var":0},{"add":[{"var":0},{"const":1}]}]},{"address":{"var":1},"enable":{"sub":[{"const":1},{"sub":[{"const":1},{"var":4}]}]},"type":{"items":[{"kind":"field"},{"kind":"field"}],"kind":"tuple"},"values":[{"var":2},{"var":3}]}],"name":"Grouped::memory","output":[{"add":[{"var":2},{"var":3}]}],"sends":[],"width":5}],"functions":[{"chip":"Grouped::run","inputs":[0],"name":"Grouped::run","output":[1],"steps":[{"action":{"args":[{"const":0}],"dest":[2],"name":"Grouped::left","op":"call"},"guard":{"const":1}},{"action":{"args":[{"var":0}],"dest":[3],"name":"Grouped::left","op":"call"},"guard":{"const":1}},{"action":{"args":[{"add":[{"var":0},{"const":1}]}],"dest":[4],"name":"Grouped::left","op":"call"},"guard":{"const":1}},{"action":{"args":[{"add":[{"var":0},{"const":2}]}],"dest":[5,6],"name":"Grouped::right","op":"call"},"guard":{"const":1}},{"action":{"args":[{"var":0}],"dest":[7],"name":"Grouped::memory","op":"call"},"guard":{"const":1}},{"action":{"dest":[1],"op":"assign","values":[{"add":[{"add":[{"add":[{"add":[{"add":[{"var":2},{"var":3}]},{"var":5}]},{"var":6}]},{"var":7}]},{"var":4}]}]},"guard":{"const":1}},{"action":{"dest":[1],"op":"assign","values":[{"var":1}]},"guard":{"const":1}},{"action":{"dest":[1],"op":"assign","values":[{"var":1}]},"guard":{"const":1}},{"action":{"dest":[1],"op":"assign","values":[{"var":1}]},"guard":{"const":1}},{"action":{"dest":[1],"op":"assign","values":[{"var":1}]},"guard":{"const":1}}],"witnesses":8,"writes":[{"column":0,"guard":{"const":1},"source":0},{"column":1,"guard":{"const":1},"source":2},{"column":2,"guard":{"const":1},"source":3},{"column":3,"guard":{"const":1},"source":4},{"column":4,"guard":{"const":1},"source":5},{"column":5,"guard":{"const":1},"source":6},{"column":6,"guard":{"const":1},"source":7}]},{"chip":"Grouped::left","inputs":[0],"name":"Grouped::left","output":[1],"steps":[{"action":{"dest":[2,3],"op":"choose","tests":[[{"sub":[{"var":0},{"const":0}]}],[]]},"guard":{"const":1}},{"action":{"dest":[1],"op":"assign","values":[{"const":9}]},"guard":{"var":2}},{"action":{"dest":[4],"differences":[{"sub":[{"var":0},{"const":0}]}],"op":"failure"},"guard":{"var":3}},{"action":{"dest":[1],"op":"assign","values":[{"mul":[{"mul":[{"var":0},{"var":0}]},{"var":0}]}]},"guard":{"var":3}},{"action":{"dest":[1],"op":"assign","values":[{"var":1}]},"guard":{"const":1}},{"action":{"dest":[5],"op":"assign","values":[{"mul":[{"var":0},{"var":0}]}]},"guard":{"var":3}}],"witnesses":6,"writes":[{"column":0,"guard":{"const":1},"source":0},{"column":1,"guard":{"const":1},"source":1},{"column":2,"guard":{"const":1},"source":3},{"column":3,"guard":{"var":3},"source":4},{"column":4,"guard":{"var":3},"source":5}]},{"chip":"Grouped::right","inputs":[0],"name":"Grouped::right","output":[1,2],"steps":[{"action":{"dest":[1,2],"op":"assign","values":[{"add":[{"var":0},{"const":3}]},{"mul":[{"var":0},{"var":0}]}]},"guard":{"const":1}}],"witnesses":3,"writes":[{"column":0,"guard":{"const":1},"source":0},{"column":1,"guard":{"const":1},"source":2}]},{"chip":"Grouped::memory","inputs":[0],"name":"Grouped::memory","output":[1],"steps":[{"action":{"dest":2,"op":"store","type":{"items":[{"kind":"field"},{"kind":"field"}],"kind":"tuple"},"values":[{"var":0},{"add":[{"var":0},{"const":1}]}]},"guard":{"const":1}},{"action":{"address":{"var":2},"dest":[3,4],"op":"load","type":{"items":[{"kind":"field"},{"kind":"field"}],"kind":"tuple"}},"guard":{"const":1}},{"action":{"dest":[1],"op":"assign","values":[{"add":[{"var":3},{"var":4}]}]},"guard":{"const":1}},{"action":{"dest":[1],"op":"assign","values":[{"var":1}]},"guard":{"const":1}},{"action":{"dest":[1],"op":"assign","values":[{"var":1}]},"guard":{"const":1}}],"witnesses":5,"writes":[{"column":0,"guard":{"const":1},"source":0},{"column":1,"guard":{"const":1},"source":2},{"column":2,"guard":{"const":1},"source":3},{"column":3,"guard":{"const":1},"source":4}]}],"groups":[{"activation":{"add":[{"add":[{"var":5},{"var":6}]},{"var":7}]},"constraints":[{"mul":[{"var":5},{"sub":[{"var":5},{"const":1}]}]},{"mul":[{"add":[{"mul":[{"const":18446744069414584320},{"var":4}]},{"const":1}]},{"mul":[{"const":18446744069414584320},{"var":4}]}]},{"mul":[{"var":4},{"add":[{"var":4},{"const":18446744069414584320}]}]},{"mul":[{"var":4},{"add":[{"mul":[{"const":18446744069414584320},{"var":4}]},{"const":1}]}]},{"mul":[{"var":5},{"mul":[{"add":[{"mul":[{"const":18446744069414584320},{"var":4}]},{"const":1}]},{"var":0}]}]},{"mul":[{"var":5},{"sub":[{"mul":[{"add":[{"mul":[{"const":18446744069414584320},{"var":4}]},{"const":1}]},{"add":[{"var":1},{"const":18446744069414584312}]}]},{"mul":[{"const":18446744069414584312},{"sub":[{"const":1},{"var":5}]}]}]}]},{"mul":[{"var":4},{"sub":[{"mul":[{"var":0},{"var":2}]},{"const":1}]}]},{"mul":[{"var":4},{"sub":[{"var":3},{"mul":[{"var":0},{"var":0}]}]}]},{"mul":[{"var":4},{"sub":[{"var":1},{"mul":[{"var":3},{"var":0}]}]}]},{"mul":[{"sub":[{"const":1},{"var":5}]},{"var":4}]},{"mul":[{"sub":[{"const":1},{"var":5}]},{"var":5}]},{"mul":[{"var":6},{"sub":[{"var":6},{"const":1}]}]},{"mul":[{"var":6},{"sub":[{"var":1},{"mul":[{"var":0},{"var":0}]}]}]},{"mul":[{"sub":[{"const":1},{"var":6}]},{"var":6}]},{"mul":[{"var":7},{"sub":[{"var":7},{"const":1}]}]},{"mul":[{"sub":[{"const":1},{"var":7}]},{"sub":[{"const":1},{"sub":[{"const":1},{"var":7}]}]}]},{"mul":[{"sub":[{"const":1},{"var":7}]},{"var":7}]},{"mul":[{"var":5},{"add":[{"var":6},{"var":7}]}]},{"mul":[{"var":6},{"var":7}]}],"members":[{"columns":[0,1,4,2,3,5],"name":"Grouped::left","selector":5,"writes":[]},{"columns":[0,1,6],"name":"Grouped::right","selector":6,"writes":[]},{"columns":[0,1,2,3,7],"name":"Grouped::memory","selector":7,"writes":[]}],"name":"arithmetic_and_memory","receive":[{"add":[{"add":[{"var":5},{"var":6}]},{"var":7}]},{"add":[{"add":[{"var":5},{"mul":[{"var":6},{"const":2}]}]},{"mul":[{"var":7},{"const":3}]}]},{"add":[{"add":[{"mul":[{"var":5},{"var":0}]},{"mul":[{"var":6},{"var":0}]}]},{"mul":[{"var":7},{"var":0}]}]},{"add":[{"add":[{"mul":[{"var":5},{"var":1}]},{"mul":[{"var":6},{"add":[{"var":0},{"const":3}]}]}]},{"mul":[{"var":7},{"add":[{"var":2},{"var":3}]}]}]},{"mul":[{"var":6},{"var":1}]}],"sends":[{"args":[{"mul":[{"var":7},{"const":2}]},{"mul":[{"var":7},{"const":2}]},{"mul":[{"var":7},{"var":1}]},{"mul":[{"var":7},{"var":0}]},{"mul":[{"var":7},{"add":[{"var":0},{"const":1}]}]}],"enable":{"sub":[{"const":1},{"sub":[{"const":1},{"var":7}]}]}},{"args":[{"mul":[{"var":7},{"const":2}]},{"mul":[{"var":7},{"const":2}]},{"mul":[{"var":7},{"var":1}]},{"mul":[{"var":7},{"var":2}]},{"mul":[{"var":7},{"var":3}]}],"enable":{"sub":[{"const":1},{"sub":[{"const":1},{"var":7}]}]}}],"width":8}],"modulus":18446744069414584321,"version":2}} diff --git a/crates/aiur/tests/hints.rs b/crates/aiur/tests/hints.rs new file mode 100644 index 000000000..b44013b8f --- /dev/null +++ b/crates/aiur/tests/hints.rs @@ -0,0 +1,636 @@ +use aiur::bytecode::{ + Constructor, Entry, Enum, Function, Instruction as Op, Program, Type, VERSION, +}; +use aiur::execute::QueryInput; +use aiur::hints::HintEntry; +use aiur::value::IoType; + +fn function(name: &str, registers: usize, code: Vec) -> Function { + Function { + name: name.into(), + params: vec![Type::Field], + result: Type::Field, + registers, + code, + } +} + +fn program(functions: Vec, entry: usize) -> Program { + Program { + version: VERSION, + modulus: 97, + functions, + enums: vec![], + tables: vec![], + maps: vec![], + entries: vec![Entry { + name: "main".into(), + function: entry, + inputs: vec![IoType::Field], + output: None, + }], + } +} + +fn hint(key: usize, dest: usize) -> Op { + Op::Hint { + channel: String::new(), + r#type: Type::Field, + key_type: Type::Field, + key: vec![key], + dest: vec![dest], + } +} + +fn row(key: u64, output: u64) -> HintEntry { + HintEntry { + channel: String::new(), + r#type: Type::Field, + key_type: Type::Field, + key: vec![key], + output: vec![output], + } +} + +#[test] +fn dynamic_keys_and_cached_queries() { + let child = function( + "child", + 2, + vec![hint(0, 1), hint(1, 1), Op::Ret { value: vec![1] }], + ); + let parent = function( + "parent", + 2, + vec![ + Op::Call { function: 0, args: vec![0], dest: vec![1] }, + Op::Call { function: 0, args: vec![0], dest: vec![1] }, + hint(1, 1), + Op::Ret { value: vec![1] }, + ], + ); + let p = program(vec![child, parent], 1).check().unwrap(); + let entries = [row(4, 5), row(5, 6), row(6, 7)]; + let result = p.execute_with_hints("main", vec![4], &entries).unwrap(); + assert_eq!(result.output, vec![7]); + // Reusing validated advice must not warm the query cache. Each invocation + // still executes the same instructions and records its own multiplicities. + let prepared = p.prepare_hints(&entries).unwrap(); + for _ in 0..2 { + let repeated = prepared.execute("main", vec![4]).unwrap(); + assert_eq!(repeated.output, result.output); + assert_eq!(repeated.queries, result.queries); + assert_eq!(repeated.instructions, result.instructions); + } + let child = + &result.queries.get(&QueryInput { function: 0, args: vec![4] }).unwrap(); + assert_eq!(child.multiplicity, 2); + assert_eq!(child.output, [6]); + let parent = + &result.queries.get(&QueryInput { function: 1, args: vec![4] }).unwrap(); + assert_eq!(parent.output, [7]); + // A fresh session can select different witnesses for the same root query. + let again = p + .execute_with_hints("main", vec![4], &[row(4, 5), row(5, 6), row(6, 8)]) + .unwrap(); + assert_eq!(again.output, vec![8]); + assert!( + p.execute("main", vec![4]).unwrap_err().message.contains("missing hint") + ); +} + +#[test] +fn types_disambiguate_identical_word_encodings() { + let nominal = |name: &str| Type::Enum { name: name.into() }; + let single = Type::Tuple { items: vec![Type::Field] }; + let signatures = [ + (Type::Field, Type::Field), + (Type::Field, single), + (Type::Field, nominal("A")), + (Type::Field, nominal("B")), + (nominal("A"), Type::Field), + (nominal("B"), Type::Field), + ]; + let mut instructions = signatures + .iter() + .enumerate() + .map(|(i, (result, key))| Op::Hint { + channel: if i >= 4 { format!("result{i}") } else { String::new() }, + r#type: result.clone(), + key_type: key.clone(), + key: vec![0], + dest: vec![i + 1], + }) + .collect::>(); + instructions.push(Op::Ret { value: (1..=6).collect() }); + let mut f = function("typed", 7, instructions); + f.result = Type::Tuple { + items: signatures.iter().map(|(result, _)| result.clone()).collect(), + }; + let mut p = program(vec![f], 0); + p.enums = ["A", "B"] + .map(|name| Enum { + name: name.into(), + constructors: vec![Constructor { + name: "Wrap".into(), + fields: vec![Type::Field], + }], + }) + .to_vec(); + let entries = signatures + .iter() + .enumerate() + .map(|(i, (result, key))| HintEntry { + channel: if i >= 4 { format!("result{i}") } else { String::new() }, + r#type: result.clone(), + key_type: key.clone(), + key: vec![7], + output: vec![i as u64 + 10], + }) + .collect::>(); + let result = + p.check().unwrap().execute_with_hints("main", vec![7], &entries).unwrap(); + assert_eq!(result.output, vec![10, 11, 12, 13, 14, 15]); +} + +#[test] +fn repeated_identical_data_is_allowed_but_conflicts_are_errors() { + let p = program( + vec![function("hinted", 2, vec![hint(0, 1), Op::Ret { value: vec![1] }])], + 0, + ) + .check() + .unwrap(); + let result = + p.execute_with_hints("main", vec![4], &[row(4, 5), row(4, 5)]).unwrap(); + assert_eq!(result.output, vec![5]); + assert!( + p.execute_with_hints("main", vec![4], &[row(4, 5), row(4, 6)]) + .unwrap_err() + .message + .contains("conflicting hint entries") + ); + // Conflict checking also covers data the execution would never request. + assert!( + p.execute_with_hints("main", vec![4], &[row(4, 5), row(9, 1), row(9, 2)]) + .unwrap_err() + .message + .contains("conflicting hint entries") + ); +} + +#[test] +fn inactive_sites_do_not_request_answers() { + let p = program( + vec![function( + "lazy", + 2, + vec![ + Op::Branch { tests: vec![(0, 0)], otherwise: 2 }, + Op::Ret { value: vec![0] }, + hint(0, 1), + Op::Ret { value: vec![1] }, + ], + )], + 0, + ) + .check() + .unwrap(); + let result = p.execute("main", vec![0]).unwrap(); + assert_eq!(result.output, [0]); + let error = p.execute("main", vec![1]).unwrap_err(); + assert_eq!(error.instruction, 2); + assert_eq!(error.function, "lazy"); +} + +#[test] +fn skipped_dispatch_preserves_logical_counts_and_hint_sites() { + let p = program( + vec![function( + "threaded", + 2, + vec![ + Op::Guard { tests: vec![], message: "unreachable".into() }, + Op::Copy { dest: vec![0], source: vec![0] }, + Op::AssertEq { + runtime_check: true, + left: vec![0], + right: vec![0], + message: None, + }, + Op::Branch { tests: vec![], otherwise: 6 }, + Op::Jump { target: 6 }, + // Validation permits arbitrary unreachable instructions. + Op::Literal { dest: usize::MAX, value: u64::MAX }, + hint(0, 1), + Op::Copy { dest: vec![], source: vec![] }, + Op::Ret { value: vec![1] }, + ], + )], + 0, + ) + .check() + .unwrap(); + let result = p.execute_with_hints("main", vec![4], &[row(4, 5)]).unwrap(); + assert_eq!(result.output, [5]); + assert_eq!(result.instructions, 8); + let error = p.execute("main", vec![4]).unwrap_err(); + assert_eq!(error.function, "threaded"); + assert_eq!(error.instruction, 6); +} + +#[test] +fn flat_data_validates_nested_tags_padding_fields_widths_and_pointers() { + let nominal = |name: &str| Type::Enum { name: name.into() }; + let mut p = + program(vec![function("identity", 1, vec![Op::Ret { value: vec![0] }])], 0); + p.enums = vec![ + Enum { + name: "Inner".into(), + constructors: vec![ + Constructor { name: "None".into(), fields: vec![] }, + Constructor { name: "Some".into(), fields: vec![Type::Field] }, + ], + }, + Enum { + name: "Outer".into(), + constructors: vec![ + Constructor { name: "Empty".into(), fields: vec![] }, + Constructor { name: "Wrap".into(), fields: vec![nominal("Inner")] }, + ], + }, + Enum { + name: "HiddenPointer".into(), + constructors: vec![ + Constructor { name: "Empty".into(), fields: vec![] }, + Constructor { + name: "Ptr".into(), + fields: vec![Type::Ptr { target: Box::new(Type::Field) }], + }, + ], + }, + ]; + let p = p.check().unwrap(); + let good = HintEntry { + channel: String::new(), + r#type: nominal("Outer"), + key_type: nominal("Outer"), + key: vec![1, 1, 7], + output: vec![1, 0, 0], + }; + p.execute_with_hints("main", vec![0], std::slice::from_ref(&good)).unwrap(); + for (words, expected) in [ + (vec![1, 2, 0], "invalid enum tag"), + (vec![1, 0, 1], "nonzero enum padding"), + (vec![0, 1, 0], "nonzero enum padding"), + (vec![1, 1, 97], "noncanonical"), + (vec![1, 1], "width"), + ] { + for key in [false, true] { + let mut bad = good.clone(); + if key { + bad.key = words.clone(); + } else { + bad.output = words.clone(); + } + let error = p.execute_with_hints("main", vec![0], &[bad]).unwrap_err(); + assert!(error.message.contains(expected), "{}", error.message); + } + } + let pointer = HintEntry { + channel: String::new(), + r#type: nominal("HiddenPointer"), + key_type: Type::Field, + key: vec![0], + output: vec![0, 0], + }; + assert!( + p.execute_with_hints("main", vec![0], &[pointer]) + .unwrap_err() + .message + .contains("pointers") + ); + let unknown = HintEntry { + channel: String::new(), + r#type: nominal("Unknown"), + ..row(0, 1) + }; + assert!( + p.execute_with_hints("main", vec![0], &[unknown]) + .unwrap_err() + .message + .contains("unknown enum") + ); +} + +#[test] +fn zero_width_answers_still_have_distinct_nominal_keys() { + let unit = Type::Enum { name: "Unit".into() }; + let mut f = function( + "unit", + 1, + vec![ + Op::Hint { + channel: String::new(), + r#type: unit.clone(), + key_type: unit.clone(), + key: vec![], + dest: vec![], + }, + Op::Ret { value: vec![] }, + ], + ); + f.result = unit.clone(); + let mut p = program(vec![f], 0); + p.enums.push(Enum { + name: "Unit".into(), + constructors: vec![Constructor { name: "Unit".into(), fields: vec![] }], + }); + let p = p.check().unwrap(); + let wrong_key = HintEntry { + channel: String::new(), + r#type: unit.clone(), + key_type: Type::Tuple { items: vec![] }, + key: vec![], + output: vec![], + }; + assert!( + p.execute_with_hints("main", vec![0], &[wrong_key]) + .unwrap_err() + .message + .contains("missing hint") + ); + let entry = HintEntry { + channel: String::new(), + r#type: unit.clone(), + key_type: unit, + key: vec![], + output: vec![], + }; + let result = p.execute_with_hints("main", vec![0], &[entry]).unwrap(); + assert!(result.output.is_empty()); + assert_eq!(result.instructions, 2); +} + +#[test] +fn code_channels_are_bound_once_and_capture_configuration() { + use aiur::hints::HintChannels; + use std::sync::{ + Arc, + atomic::{AtomicUsize, Ordering}, + }; + let named = |channel: &str, key, dest| Op::Hint { + channel: channel.into(), + r#type: Type::Field, + key_type: Type::Field, + key: vec![key], + dest: vec![dest], + }; + let child = function( + "child", + 3, + vec![named("plus", 0, 1), named("times", 1, 2), Op::Ret { value: vec![2] }], + ); + let parent = function( + "parent", + 2, + vec![ + Op::Call { function: 0, args: vec![0], dest: vec![1] }, + Op::Call { function: 0, args: vec![0], dest: vec![1] }, + Op::Ret { value: vec![1] }, + ], + ); + let program = program(vec![child, parent], 1).check().unwrap(); + let calls = Arc::new(AtomicUsize::new(0)); + let prepared = { + let mut channels = HintChannels::new(); + for (name, offset, scale) in [("plus", 3, 1), ("times", 0, 2)] { + let calls = calls.clone(); + channels + .insert(name, Type::Field, Type::Field, move |input, output| { + calls.fetch_add(1, Ordering::Relaxed); + output[0] = (input[0] + offset) * scale; + Ok(()) + }) + .unwrap(); + } + program.prepare_hint_channels(&[], &channels).unwrap() + // The registry is dropped: execution only has the bound closures. + }; + let code = prepared.execute("main", vec![4]).unwrap(); + assert_eq!(code.output, [14]); + assert_eq!(calls.load(Ordering::Relaxed), 2); // cached child is not called again + let data = program + .execute_with_hints( + "main", + vec![4], + &[ + HintEntry { channel: "plus".into(), ..row(4, 7) }, + HintEntry { channel: "times".into(), ..row(7, 14) }, + ], + ) + .unwrap(); + assert_eq!(code.queries, data.queries); + assert_eq!(code.instructions, data.instructions); + assert_eq!(prepared.execute("main", vec![5]).unwrap().output, [16]); + assert_eq!(calls.load(Ordering::Relaxed), 4); +} + +#[test] +fn channel_outputs_remain_untrusted_constants() { + use aiur::hints::HintChannels; + let result_type = Type::Enum { name: "Choice".into() }; + let mut function = function( + "choose", + 3, + vec![ + Op::Hint { + channel: "choice".into(), + r#type: result_type.clone(), + key_type: Type::Field, + key: vec![0], + dest: vec![1, 2], + }, + Op::Ret { value: vec![1, 2] }, + ], + ); + function.result = result_type.clone(); + let mut source = program(vec![function], 0); + source.enums.push(Enum { + name: "Choice".into(), + constructors: vec![ + Constructor { name: "None".into(), fields: vec![] }, + Constructor { name: "Some".into(), fields: vec![Type::Field] }, + ], + }); + let program = source.check().unwrap(); + for (words, error) in [ + ([2, 0], "invalid enum tag"), + ([0, 1], "nonzero enum padding"), + ([1, 97], "noncanonical"), + ] { + for fixed in [false, true] { + let mut channels = HintChannels::new(); + if fixed { + channels + .insert_fixed::<1, 2>( + "choice", + Type::Field, + result_type.clone(), + move |_| Ok(words), + ) + .unwrap(); + } else { + channels + .insert("choice", Type::Field, result_type.clone(), move |_, out| { + out.copy_from_slice(&words); + Ok(()) + }) + .unwrap(); + } + assert!( + program + .prepare_hint_channels(&[], &channels) + .unwrap() + .execute("main", vec![0]) + .unwrap_err() + .message + .contains(error) + ); + } + } + let mut wrong = HintChannels::new(); + wrong.insert("choice", Type::Field, Type::Field, |_, _| Ok(())).unwrap(); + assert!( + program + .prepare_hint_channels(&[], &wrong) + .err() + .unwrap() + .contains("signature mismatch") + ); + assert!( + wrong + .insert("choice", Type::Field, Type::Field, |_, _| Ok(())) + .unwrap_err() + .contains("duplicate") + ); + let mut pointer = HintChannels::new(); + pointer + .insert( + "unused", + Type::Ptr { target: Box::new(Type::Field) }, + Type::Field, + |_, _| Ok(()), + ) + .unwrap(); + assert!( + program + .prepare_hint_channels(&[], &pointer) + .err() + .unwrap() + .contains("pointers") + ); +} + +#[test] +fn data_channels_are_functions_of_the_constant_key() { + let p = program( + vec![function("hinted", 2, vec![hint(0, 1), Op::Ret { value: vec![1] }])], + 0, + ) + .check() + .unwrap(); + let entries = [row(4, 5), HintEntry { channel: "other".into(), ..row(4, 6) }]; + assert_eq!( + p.execute_with_hints("main", vec![4], &entries).unwrap().output, + [5] + ); + // The expected result type must not select a different answer to the same + // channel and Constant; use another channel for that operation instead. + let conflict = + HintEntry { r#type: Type::Tuple { items: vec![Type::Field] }, ..row(4, 5) }; + assert!( + p.prepare_hints(&[row(4, 5), conflict]) + .err() + .unwrap() + .contains("conflicting") + ); +} + +#[test] +fn fixed_hints_bind_linked_registers_and_preserve_nominal_signatures() { + use aiur::hints::HintChannels; + let pair = Type::Tuple { items: vec![Type::Field; 2] }; + let mut f = function( + "swap", + 4, + vec![ + Op::Copy { source: vec![0, 1], dest: vec![2, 3] }, + Op::Hint { + channel: "swap".into(), + key_type: pair.clone(), + r#type: pair.clone(), + key: vec![2, 3], + dest: vec![0, 1], + }, + Op::Ret { value: vec![0, 1] }, + ], + ); + f.params = vec![pair.clone()]; + f.result = pair.clone(); + let mut source = program(vec![f], 0); + source.entries[0].inputs = + vec![IoType::Tuple { items: vec![IoType::Field; 2] }]; + let program = source.check().unwrap(); + let mut channels = HintChannels::new(); + channels + .insert_fixed::<2, 2>("swap", pair.clone(), pair.clone(), |[a, b]| { + Ok([b, a]) + }) + .unwrap(); + let prepared = program.prepare_hint_channels(&[], &channels).unwrap(); + drop(channels); + let actual = prepared.execute("main", vec![2, 5]).unwrap(); + let expected = program + .execute_with_hints( + "main", + vec![2, 5], + &[HintEntry { + channel: "swap".into(), + key_type: pair.clone(), + r#type: pair.clone(), + key: vec![2, 5], + output: vec![5, 2], + }], + ) + .unwrap(); + assert_eq!(actual.output, [5, 2]); + assert_eq!(actual.queries, expected.queries); + assert_eq!(actual.instructions, expected.instructions); + let mut wrong = HintChannels::new(); + wrong + .insert_fixed::<1, 2>("swap", pair.clone(), pair.clone(), |[x]| Ok([x, x])) + .unwrap(); + assert!( + program + .prepare_hint_channels(&[], &wrong) + .err() + .unwrap() + .contains("fixed arity") + ); + let mut wrong = HintChannels::new(); + wrong + .insert_fixed::<2, 2>("swap", pair.clone(), pair, |_| { + Err("provider failure".into()) + }) + .unwrap(); + assert!( + program + .prepare_hint_channels(&[], &wrong) + .unwrap() + .execute("main", vec![2, 5]) + .unwrap_err() + .message + .contains("provider failure") + ); +} diff --git a/crates/aiur/tests/maps.rs b/crates/aiur/tests/maps.rs new file mode 100644 index 000000000..95daa5142 --- /dev/null +++ b/crates/aiur/tests/maps.rs @@ -0,0 +1,318 @@ +use aiur::{ + Program, bytecode::CheckedProgram, execute::QueryInput, maps::MapOverrides, +}; +use serde_json::json; +use std::sync::{ + Arc, + atomic::{AtomicUsize, Ordering}, +}; + +fn fixture(rows: &[u64]) -> CheckedProgram { + let f = json!({"kind":"field"}); + let unit = json!({"kind":"tuple","items":[]}); + serde_json::from_value::(json!({ + "version":1,"modulus":97,"enums":[], + "functions":[{"name":"main","params":[f],"result":f,"registers":5,"code":[ + {"op":"call","function":1,"args":[0],"dest":[1]}, + {"op":"call","function":1,"args":[0],"dest":[2]}, + {"op":"call","function":2,"args":[0],"dest":[3]}, + {"op":"call","function":3,"args":[],"dest":[]}, + {"op":"binary","operator":"add","left":1,"right":2,"dest":4}, + {"op":"binary","operator":"add","left":4,"right":3,"dest":4}, + {"op":"ret","value":[4]}]}], + "maps":[ + {"name":"square","params":[f],"result":f,"input":0,"output":1}, + {"name":"cube","params":[f],"result":f,"input":0,"output":2}, + {"name":"unit","params":[],"result":unit,"input":3,"output":3}], + "tables":[ + {"name":"xs","type":{"kind":"tuple","items":[f]},"rows":rows.iter().map(|&x| vec![x]).collect::>()}, + {"name":"squares","type":f,"rows":rows.iter().map(|&x| vec![x*x%97]).collect::>()}, + {"name":"cubes","type":f,"rows":rows.iter().map(|&x| vec![x*x*x%97]).collect::>()}, + {"name":"unit","type":unit,"rows":[[]]}], + "entries":[ + {"name":"main","function":0,"inputs":[f],"output":f}, + {"name":"square","function":1,"inputs":[f],"output":f}] + })).unwrap().check().unwrap() +} + +#[test] +fn rebinding_a_fixed_map_to_a_slice_provider_replaces_prepared_calls() { + let p = fixture(&[0, 1, 2]); + let fixed_calls = Arc::new(AtomicUsize::new(0)); + let slice_calls = Arc::new(AtomicUsize::new(0)); + let mut fixed = MapOverrides::new(); + let calls = fixed_calls.clone(); + fixed + .insert_fixed::<1, 1>("square", move |[x]| { + calls.fetch_add(1, Ordering::Relaxed); + Ok((x as usize, [x * x])) + }) + .unwrap(); + let prepared = + p.prepare_hints(&[]).unwrap().with_map_overrides(&fixed).unwrap(); + // Binding validates the provider against every immutable table row. + fixed_calls.store(0, Ordering::Relaxed); + let before = prepared.execute("main", vec![2]).unwrap(); + assert_eq!(fixed_calls.load(Ordering::Relaxed), 2); + let mut fallback = MapOverrides::new(); + let calls = slice_calls.clone(); + fallback + .insert("square", 1, 1, move |input, output| { + calls.fetch_add(1, Ordering::Relaxed); + output[0] = input[0] * input[0]; + Ok(input[0] as usize) + }) + .unwrap(); + let prepared = prepared.with_map_overrides(&fallback).unwrap(); + slice_calls.store(0, Ordering::Relaxed); + drop(fixed); + drop(fallback); + let after = prepared.execute("main", vec![2]).unwrap(); + assert_eq!(fixed_calls.load(Ordering::Relaxed), 2); + assert_eq!(slice_calls.load(Ordering::Relaxed), 2); + assert_eq!(before.output, after.output); + assert_eq!(before.queries, after.queries); + assert_eq!(before.instructions, after.instructions); +} + +#[test] +fn overrides_preserve_sparse_and_permuted_tables_counts_and_fresh_sessions() { + for rows in [&[2, 0, 1][..], &[9, 2, 5][..]] { + let program = fixture(rows); + let calls = Arc::new(AtomicUsize::new(0)); + let mut maps = MapOverrides::new(); + let captured = calls.clone(); + let row_order = rows.to_vec(); + maps + .insert("square", 1, 1, move |args, out| { + captured.fetch_add(1, Ordering::Relaxed); + assert_eq!(out, [0]); + out[0] = args[0] * args[0] % 97; + row_order + .iter() + .position(|&x| x == args[0]) + .ok_or_else(|| "no table entry for map input".into()) + }) + .unwrap(); + maps + .insert("unit", 0, 0, |args, out| { + assert!(args.is_empty() && out.is_empty()); + Ok(0) + }) + .unwrap(); + let prepared = + program.prepare_hints(&[]).unwrap().with_map_overrides(&maps).unwrap(); + drop(maps); + for _ in 0..2 { + for &x in rows { + let native = prepared.execute("main", vec![x]).unwrap(); + let fallback = program.execute("main", vec![x]).unwrap(); + assert_eq!(native.output, [(2 * x * x + x * x * x) % 97]); + assert_eq!(native.output, fallback.output); + assert_eq!(native.queries, fallback.queries); + assert_eq!(native.instructions, fallback.instructions); + assert_eq!(native.queries.len(), 4); + assert!(!native.queries.is_empty()); + assert_eq!(native.queries.iter().count(), 4); + let square = native + .queries + .get(&QueryInput { function: 1, args: vec![x] }) + .unwrap(); + assert_eq!(square.multiplicity, 2); + assert_eq!(square.output, [x * x % 97]); + assert_eq!( + native + .queries + .get(&QueryInput { function: 2, args: vec![x] }) + .unwrap() + .multiplicity, + 1 + ); + assert!( + native + .queries + .get(&QueryInput { function: 1, args: vec![90] }) + .is_none() + ); + for &unused in rows.iter().filter(|&&other| other != x) { + assert!( + native + .queries + .get(&QueryInput { function: 1, args: vec![unused] }) + .is_none() + ); + } + } + } + assert_eq!(calls.load(Ordering::Relaxed), 5 * rows.len()); + let square_only = prepared.execute("square", vec![2]).unwrap(); + assert_eq!(square_only.output, [4]); + // Preallocated rows in the unused cube/unit tables are not queries. + assert_eq!(square_only.queries.len(), 1); + assert_eq!(square_only.queries.iter().count(), 1); + assert_eq!(square_only.queries.keys().next().unwrap().function, 1); + assert!( + prepared + .execute("main", vec![90]) + .unwrap_err() + .message + .contains("no table entry") + ); + } +} + +#[test] +fn bindings_reject_unknown_functions_wrong_arities_and_duplicates() { + let program = fixture(&[0, 1, 2]); + for (name, inputs, outputs) in + [("missing", 1, 1), ("main", 1, 1), ("square", 2, 1), ("square", 1, 2)] + { + let mut maps = MapOverrides::new(); + maps.insert(name, inputs, outputs, |_, _| Ok(0)).unwrap(); + assert!( + program.prepare_hints(&[]).unwrap().with_map_overrides(&maps).is_err() + ); + assert!( + maps + .insert(name, inputs, outputs, |_, _| Ok(0)) + .unwrap_err() + .contains("duplicate") + ); + } +} + +#[test] +fn provider_errors_and_noncanonical_outputs_fail_execution() { + let program = fixture(&[0, 1, 2]); + let mut maps = MapOverrides::new(); + maps.insert("square", 1, 1, |_, _| Err("provider failure".into())).unwrap(); + let result = program.prepare_hints(&[]).unwrap().with_map_overrides(&maps); + assert!(result.err().unwrap().contains("provider failure")); + let mut maps = MapOverrides::new(); + maps + .insert("square", 1, 1, |args, out| { + out[0] = 97; + Ok(args[0] as usize) + }) + .unwrap(); + let prepared = + program.prepare_hints(&[]).unwrap().with_map_overrides(&maps).unwrap(); + assert!(prepared.execute("main", vec![2]).is_err()); +} + +#[test] +fn binding_checks_actual_row_order_and_runtime_rejects_invalid_indices() { + for bad_index in [0, 3, usize::MAX] { + let program = fixture(&[2, 0, 1]); + let mut maps = MapOverrides::new(); + maps.insert("square", 1, 1, move |_, _| Ok(bad_index)).unwrap(); + let result = program.prepare_hints(&[]).unwrap().with_map_overrides(&maps); + assert!(result.err().unwrap().contains("row index mismatch")); + } + let program = fixture(&[0, 1, 2]); + let mut maps = MapOverrides::new(); + maps + .insert("square", 1, 1, |args, out| { + if args[0] == 90 { + return Err("provider failure".into()); + } + out[0] = args[0] * args[0] % 97; + // Valid on table inputs, but deliberately returns invalid row indices + // outside its domain. The runtime must report an error without panicking. + Ok(if args[0] == 91 { usize::MAX } else { args[0] as usize }) + }) + .unwrap(); + let prepared = + program.prepare_hints(&[]).unwrap().with_map_overrides(&maps).unwrap(); + for x in [3, 91] { + assert!( + prepared + .execute("main", vec![x]) + .unwrap_err() + .message + .contains("out of bounds") + ); + } + assert!( + prepared + .execute("main", vec![90]) + .unwrap_err() + .message + .contains("provider failure") + ); +} + +#[test] +fn fixed_providers_match_tables_with_captured_order_and_empty_outputs() { + let rows = [9, 2, 5]; + let program = fixture(&rows); + let mut maps = MapOverrides::new(); + maps + .insert_fixed::<1, 1>("square", move |[x]| { + let row = rows.iter().position(|&v| v == x).ok_or("outside domain")?; + Ok((row, [x * x % 97])) + }) + .unwrap(); + maps.insert_fixed::<0, 0>("unit", |[]| Ok((0, []))).unwrap(); + let prepared = + program.prepare_hints(&[]).unwrap().with_map_overrides(&maps).unwrap(); + drop(maps); + for _ in 0..2 { + for x in rows { + for entry in ["main", "square"] { + let actual = prepared.execute(entry, vec![x]).unwrap(); + let expected = program.execute(entry, vec![x]).unwrap(); + assert_eq!(actual.output, expected.output); + assert_eq!(actual.queries, expected.queries); + assert_eq!(actual.instructions, expected.instructions); + } + } + } + assert!( + prepared + .execute("main", vec![90]) + .unwrap_err() + .message + .contains("outside domain") + ); +} + +#[test] +fn fixed_providers_preserve_runtime_validation_and_binding_errors() { + let program = fixture(&[0, 1, 2]); + let mut maps = MapOverrides::new(); + maps + .insert_fixed::<1, 1>("square", |[x]| { + Ok(( + if x == 90 { usize::MAX } else { x as usize }, + [if x == 2 { 97 } else { 0 }], + )) + }) + .unwrap(); + assert!( + maps + .insert_fixed::<1, 1>("square", |[x]| Ok((0, [x]))) + .unwrap_err() + .contains("duplicate") + ); + let prepared = + program.prepare_hints(&[]).unwrap().with_map_overrides(&maps).unwrap(); + for entry in ["main", "square"] { + for (x, error) in [(2, "noncanonical"), (90, "out of bounds")] { + assert!( + prepared.execute(entry, vec![x]).unwrap_err().message.contains(error) + ); + } + } + let mut maps = MapOverrides::new(); + maps.insert_fixed::<2, 1>("square", |[a, _]| Ok((0, [a]))).unwrap(); + assert!( + program + .prepare_hints(&[]) + .unwrap() + .with_map_overrides(&maps) + .err() + .unwrap() + .contains("signature mismatch") + ); +} diff --git a/crates/aiur/tests/querymap_hashed.rs b/crates/aiur/tests/querymap_hashed.rs deleted file mode 100644 index febe3527a..000000000 --- a/crates/aiur/tests/querymap_hashed.rs +++ /dev/null @@ -1,78 +0,0 @@ -use aiur::{G, querymap::QueryMap}; -use multi_stark::p3_field::PrimeCharacteristicRing; - -#[test] -fn retained_hash_survives_nested_insertions_and_table_growth() { - let mut map = QueryMap::new(1); - let key = [G::from_u32(65_535)]; - let output = [G::from_u32(42)]; - let (hash, hit) = map.lookup(&key); - assert_eq!(hit, None); - for i in 0..4096 { - let child = [G::from_usize(i)]; - map.insert(&child, &child, G::ONE).unwrap(); - } - map.finish_hashed(&key, &output, true, hash).unwrap(); - assert_eq!(map.len(), 4097); - assert_eq!(map.get_index_of(&key), Some(4096)); - assert_eq!(map.output_at(4096), output); - assert_eq!(map.mult_at(4096), G::ONE); - for i in 0..4096 { - assert_eq!(map.get_index_of(&[G::from_usize(i)]), Some(i)); - } -} - -#[test] -fn finish_rechecks_a_key_inserted_since_the_initial_miss() { - let mut map = QueryMap::new(1); - let key = [G::from_u32(7)]; - let output = [G::from_u32(11)]; - let (hash, hit) = map.lookup(&key); - assert_eq!(hit, None); - // A nested hint populated the key before its constrained caller finished. - map.insert(&key, &output, G::ZERO).unwrap(); - map.finish_hashed(&key, &output, true, hash).unwrap(); - assert_eq!(map.len(), 1); - assert_eq!(map.mult_at(0), G::ONE); - assert_eq!(map.output_at(0), output); - map.finish_hashed(&key, &output, false, hash).unwrap(); - assert_eq!(map.mult_at(0), G::ONE); - map.finish_hashed(&key, &output, true, hash).unwrap(); - assert_eq!(map.mult_at(0), G::TWO); -} - -#[test] -fn empty_keys_and_outputs_can_be_promoted() { - let mut map = QueryMap::new(0); - let (hash, hit) = map.lookup(&[]); - assert_eq!(hit, None); - map.insert_hashed(&[], &[], G::ZERO, hash).unwrap(); - assert_eq!(map.lookup(&[]), (hash, Some(0))); - map.finish_hashed(&[], &[], true, hash).unwrap(); - assert_eq!(map.len(), 1); - assert!(map.output_at(0).is_empty()); - assert_eq!(map.mult_at(0), G::ONE); -} - -#[test] -fn hashed_and_regular_registration_preserve_the_same_records() { - let mut regular = QueryMap::new(2); - let mut hashed = QueryMap::new(2); - for round in 0..3 { - for i in 0..128 { - let key = [G::from_usize(i), G::from_usize(i + 1)]; - let output = [G::from_usize(i * 2)]; - let (hash, hit) = hashed.lookup(&key); - assert_eq!(hit, regular.get_index_of(&key)); - regular.finish(&key, &output, round != 0).unwrap(); - hashed.finish_hashed(&key, &output, round != 0, hash).unwrap(); - } - } - assert_eq!(regular.len(), hashed.len()); - for i in 0..regular.len() { - assert_eq!(regular.get_index(i).unwrap().0, hashed.get_index(i).unwrap().0); - assert_eq!(regular.output_at(i), hashed.output_at(i)); - assert_eq!(regular.mult_at(i), hashed.mult_at(i)); - assert_eq!(hashed.mult_at(i), G::TWO); - } -} diff --git a/crates/aiur/tests/u32_hints.rs b/crates/aiur/tests/u32_hints.rs new file mode 100644 index 000000000..b6dcd35dc --- /dev/null +++ b/crates/aiur/tests/u32_hints.rs @@ -0,0 +1,83 @@ +use aiur::{ + bytecode::{Entry, Function, Instruction, Program, Type, VERSION}, + field::{FieldBackend, NativeField, PrimeField}, + hints::HintChannels, + value::IoType, +}; +use multi_stark::p3_goldilocks::Goldilocks; + +fn exercise(field: B) { + for (channel, words) in [("u32.add", 2), ("u32.add3", 3)] { + let width = words * 4; + let bytes = Type::Tuple { items: vec![Type::Field; 4] }; + let p = Program { + version: VERSION, + modulus: field.modulus(), + enums: vec![], + tables: vec![], + maps: vec![], + functions: vec![Function { + name: "sum".into(), + params: vec![Type::Field; width], + result: bytes.clone(), + registers: width + 4, + code: vec![ + Instruction::Hint { + channel: channel.into(), + key_type: Type::Tuple { items: vec![bytes; words] }, + r#type: Type::Tuple { items: vec![Type::Field; 4] }, + key: (0..width).collect(), + dest: (width..width + 4).collect(), + }, + Instruction::Ret { value: (width..width + 4).collect() }, + ], + }], + entries: vec![Entry { + name: "sum".into(), + function: 0, + inputs: vec![IoType::Field; width], + output: None, + }], + } + .check_with(field) + .unwrap(); + let mut channels = HintChannels::new(); + aiur::library::u32::register(&mut channels, field).unwrap(); + let prepared = p.prepare_hint_channels(&[], &channels).unwrap(); + // Overflow, carry propagation through each byte, and distinct limbs. + for operands in [ + [0, 0, 0], + [u32::MAX, 1, u32::MAX], + [0x00ff_ffff, 1, 0x0100_0000], + [0x0123_4567, 0x89ab_cdef, 0x7654_3210], + ] { + let input: Vec<_> = operands[..words] + .iter() + .flat_map(|word| word.to_le_bytes()) + .map(|b| field.from_u64(u64::from(b))) + .collect(); + let result = prepared.execute("sum", input).unwrap(); + let expected = + operands[..words].iter().fold(0u32, |a, b| a.wrapping_add(*b)); + assert_eq!( + result.output, + expected.to_le_bytes().map(|b| field.from_u64(u64::from(b))) + ); + } + for index in 0..width { + for invalid in [256, 1 << 32, field.modulus() - 1] { + let mut input = vec![field.zero(); width]; + input[index] = field.from_u64(invalid); + let error = prepared.execute("sum", input).unwrap_err(); + assert_eq!(error.instruction, 0); + assert_eq!(error.message, "non-byte u32 sum operand"); + } + } + } +} + +#[test] +fn sum_hints_wrap_correctly_and_reject_every_invalid_limb() { + exercise(PrimeField::new(0xffff_ffff_0000_0001).unwrap()); + exercise(NativeField::::new()); +} diff --git a/crates/ffi/Cargo.toml b/crates/ffi/Cargo.toml index 1f08db277..226c9b333 100644 --- a/crates/ffi/Cargo.toml +++ b/crates/ffi/Cargo.toml @@ -8,20 +8,21 @@ license.workspace = true crate-type = ["lib", "staticlib"] [dependencies] -aiur = { workspace = true } +aiur = { workspace = true, features = ["stark"] } blake3 = { workspace = true } -ixvm-codegen = { workspace = true } ix-common = { workspace = true } ixon = { workspace = true } ix-proof-compression = { path = "../proof-compression", default-features = false } lean-ffi = { workspace = true } memmap2 = { workspace = true } -multi-stark = { workspace = true } mimalloc = { workspace = true } +multi-stark = { workspace = true } rayon = { workspace = true } rustc-hash = { workspace = true } serde_json = { workspace = true } sha2 = { workspace = true } +stark-key = { workspace = true } +stark-verifier = { path = "../stark-verifier" } tiny-keccak = { workspace = true } tracing = { workspace = true } tracing-subscriber = { workspace = true } @@ -33,18 +34,18 @@ iroh = { version = "0.97", optional = true } n0-error = { version = "0.1", optional = true } getrandom = { version = "0.3", optional = true } bincode = { version = "2.0.1", optional = true } -serde = { version = "1.0.219", features = ["derive"], optional = true } +serde = { version = "1.0.219", features = ["derive"] } [features] default = [] parallel = ["aiur/parallel", "ix-proof-compression/parallel"] cuda = ["aiur/cuda", "ix-proof-compression/cuda"] -cuda-trace-codegen = ["cuda", "aiur/cuda-trace-codegen"] +cuda-trace-codegen = ["cuda"] # Final proof systems, which link the gnark Go archive. plonk = ["ix-proof-compression/plonk"] groth16 = ["ix-proof-compression/groth16"] test-ffi = [] -net = ["tokio", "iroh", "n0-error", "getrandom", "bincode", "serde"] +net = ["tokio", "iroh", "n0-error", "getrandom", "bincode"] [lints] workspace = true diff --git a/crates/ffi/src/aiur.rs b/crates/ffi/src/aiur.rs deleted file mode 100644 index 238064d34..000000000 --- a/crates/ffi/src/aiur.rs +++ /dev/null @@ -1,21 +0,0 @@ -use ::multi_stark::p3_field::integers::QuotientMap; - -pub mod aggregate; -mod multi_stark; -pub mod protocol; -pub mod toplevel; - -use aiur::G; -use lean_ffi::object::LeanRef; - -#[inline] -pub(super) fn lean_unbox_nat_as_usize(obj: &impl LeanRef) -> usize { - assert!(obj.is_scalar()); - obj.unbox_usize() -} - -#[inline] -pub(super) fn lean_unbox_g(obj: &impl LeanRef) -> G { - let u64 = obj.unbox_u64(); - unsafe { G::from_canonical_unchecked(u64) } -} diff --git a/crates/ffi/src/aiur/aggregate.rs b/crates/ffi/src/aiur/aggregate.rs deleted file mode 100644 index 00d2fe183..000000000 --- a/crates/ffi/src/aiur/aggregate.rs +++ /dev/null @@ -1,575 +0,0 @@ -//! Native Stage 2 orchestration for `ix aggregate`. -//! -//! Lean still constructs the two Aiur bytecode systems, because their source -//! programs are Lean-authored. Everything data-dependent after that point is -//! kept here: manifest/environment binding, shard-claim reconstruction, -//! statement folding, cache validation, dependency scheduling, recursive -//! advice construction, proving, and persistence. -//! -//! The host statements deliberately cache roots and sorted leaves. Structural -//! subject trees carry only their two children and a small shard-membership -//! bitset, so deciding whether an assumption is discharged is O(1), and a -//! Merkle path is O(log n). This avoids the eager recursive `root`/`leaves`/ -//! `contains` traversals that made the former Lean startup super-linear. - -use aiur::synthesis::{AiurProof, AiurSystem}; -use ixon::shard::ShardManifest; -use ixon::{ClaimContext, Proof as IxonProof}; -use ixvm_codegen::env_handle::EnvHandle; -use plan::{ - FoldPolicy, PlanIdentity, PlanOp, SlotSpec, build_specs, - build_statement_specs, plan_replay, subtree_plan, -}; -use prepare::{ - PreparedShard, prepare_run, prepare_run_with, validate_root_statement, -}; -use protocol::{ChildKind, allowed_blob, inner_claim}; -use prove::{ProveContext, discharge_root, run_replay, wrap_root}; -use rayon::prelude::*; -use scheduler::run_scheduler; -use statement::Statement; -use std::{ - fs, - path::{Path, PathBuf}, - sync::Arc, - time::Instant, -}; -pub(crate) use store::write_store; -use store::{load_input_proofs, persist_wrapper, wrapper_address}; - -mod ffi; -pub mod multi_gpu; -pub(crate) mod normalize; -mod plan; -mod prepare; -pub(crate) mod protocol; -mod prove; -mod scheduler; -mod statement; -mod store; - -const MIB: usize = 1024 * 1024; -const GIB: usize = 1024 * 1024 * 1024; - -pub(crate) fn format_gib(bytes: usize) -> String { - let tenths = bytes.saturating_mul(10) / GIB; - format!("{}.{:01}", tenths / 10, tenths % 10) -} - -fn format_mib(bytes: usize) -> String { - let tenths = bytes.saturating_mul(10) / MIB; - format!("{}.{:01}", tenths / 10, tenths % 10) -} - -#[derive(Clone, Copy)] -struct RunConfig<'a> { - ixvm_system: &'a AiurSystem, - aggr_system: &'a AiurSystem, - env_handle: &'a EnvHandle, - manifest_path: &'a Path, - proof_hexes: &'a str, - verify_idx: usize, - aggr_idx: usize, - jobs: usize, - ram_budget_bytes: usize, - structural_above: usize, - reprove_slot: Option, - direct_joins: bool, - plan_only: bool, - cache_fri_bytes: &'a [u8], - use_cache: bool, - fresh: bool, - write_outputs: bool, - trace_shards: bool, - range_width: usize, - /// Wrap the root proof (shape 1) until the final proof is a single - /// trace shard. - wrap_root: bool, - /// Slots preparing (executing) ahead of the provers; `0` fuses - /// preparation and proving on one worker per slot. - exec_ahead: usize, - /// `ix verify --ixes `: stop after the proof import — every - /// shard claim reconstructed natively, every supplied proof bound to its - /// shard by claim digest and verified in parallel, exactly one per shard - /// — and report that composed verdict instead of proving. - verify_only: bool, - /// Prove only the plan subtree rooted at this slot, from the proofs of - /// the leaves under it, and report that slot's proof; the root-only steps - /// (root validation, wrapping) are skipped. `None` proves the whole plan. - subtree: Option, - /// An IxVM proof of the `Binding` claim for the environment's binding. - /// When present, every claim of the run assumes its binding and the root - /// discharges that condition once, after any wrap. - binding_proof: Option<&'a IxonProof>, -} - -fn expected_from_manifest( - env: &ixon::Env, - manifest: &ShardManifest, - structural_above: usize, -) -> Result<(Arc, usize), String> { - let prepared = prepare_run(env, manifest)?; - let specs = build_statement_specs(&prepared, structural_above)?; - let root = specs - .last() - .ok_or("aggregate manifest produced no root statement")? - .statement - .clone(); - validate_root_statement(&prepared, &root)?; - Ok((root, prepared.env_count)) -} - -fn print_plan( - specs: &[SlotSpec], - prepared: &[PreparedShard], - threshold: usize, -) { - let leaves = - specs.iter().filter(|spec| matches!(spec.op, PlanOp::Leaf(_))).count(); - let wraps = specs - .iter() - .filter(|spec| { - matches!(spec.op, PlanOp::Leaf(_)) && spec.kind == ChildKind::Aggr - }) - .count(); - let structural = specs.iter().filter(|spec| spec.structural).count(); - let policy = if wraps == leaves { - format!("{wraps} wraps") - } else { - format!("{} direct IxVM leaves", leaves - wraps) - }; - eprintln!( - "[aggregate] plan: {policy} + {} binary joins ({structural} structural; threshold > {threshold} subject leaves)", - specs.len() - leaves - ); - for (index, spec) in specs.iter().enumerate() { - match spec.op { - PlanOp::Leaf(shard) => { - let mode = - if spec.kind == ChildKind::Ixvm { "raw shard" } else { "wrap shard" }; - eprintln!( - " slot {index}: {mode} {} ({} subjects)", - prepared[shard].original_id, spec.subject_count - ); - }, - PlanOp::Join(left, right) => { - let mode = if spec.structural { "structural" } else { "flat" }; - eprintln!( - " slot {index}: {mode} shape {} slots {left}, {right} ({} subjects)", - spec.shape.unwrap_or(u8::MAX), - spec.subject_count - ); - }, - } - } -} - -fn run(config: RunConfig<'_>) -> Result { - if config.cache_fri_bytes.len() != 40 { - return Err(format!( - "aggregate cache FRI serialization is {} bytes, expected 40", - config.cache_fri_bytes.len() - )); - } - if config.plan_only && config.reprove_slot.is_some() { - return Err("--plan-only cannot be combined with --reprove-slot".into()); - } - if config.reprove_slot.is_some() && (!config.use_cache || config.fresh) { - return Err("--reprove-slot requires aggregate cache reads".into()); - } - let started = Instant::now(); - let manifest_bytes = fs::read(config.manifest_path).map_err(|error| { - format!("read manifest {}: {error}", config.manifest_path.display()) - })?; - let manifest = ShardManifest::from_bytes(&manifest_bytes) - .map_err(|error| format!("manifest parse failed: {error}"))?; - let parsed_at = Instant::now(); - let prepared = prepare_run_with( - &config.env_handle.env, - &manifest, - config.binding_proof.is_some(), - )?; - let prepared_at = Instant::now(); - - let ixvm_vk = aiur::vk_codec::aiur_system_to_bytes(config.ixvm_system) - .map_err(|error| format!("IxVM VK serialization failed: {error}"))?; - let aggr_vk = aiur::vk_codec::aiur_system_to_bytes(config.aggr_system) - .map_err(|error| format!("ixAggr VK serialization failed: {error}"))?; - let allowed = - allowed_blob(&ixvm_vk, config.verify_idx, &aggr_vk, config.aggr_idx); - let specs = build_specs( - &prepared, - PlanIdentity { - verify_idx: config.verify_idx, - aggr_idx: config.aggr_idx, - aggr_vk: &aggr_vk, - allowed: &allowed, - cache_fri_bytes: config.cache_fri_bytes, - }, - FoldPolicy { - structural_above: config.structural_above, - direct_joins: config.direct_joins, - }, - )?; - let replay_plan = config - .reprove_slot - .map(|target| plan_replay(&specs, target)) - .transpose()?; - // The slots this run proves: the whole plan, or one subtree of it. - let active: Vec = match config.subtree { - None => vec![true; specs.len()], - Some(target) => { - if config.reprove_slot.is_some() { - return Err("--subtree cannot be combined with --reprove-slot".into()); - } - if config.verify_only { - return Err("--subtree has no meaning for a composed verdict".into()); - } - if config.wrap_root { - return Err( - "--wrap-root applies to the root; --subtree proves a subtree".into(), - ); - } - if !config.plan_only && !config.use_cache { - return Err( - "--subtree publishes its root through the aggregate cache; it cannot run with --no-cache" - .into(), - ); - } - let spec = specs.get(target).ok_or_else(|| { - format!( - "--subtree {target} is out of range; the plan has slots 0..{}", - specs.len().saturating_sub(1) - ) - })?; - if spec.kind == ChildKind::Ixvm { - return Err(format!( - "--subtree {target} selects a raw IxVM leaf, not a Stage 2 proof" - )); - } - let mut active = vec![false; specs.len()]; - let mut stack = vec![target]; - while let Some(index) = stack.pop() { - if active[index] { - continue; - } - active[index] = true; - if let PlanOp::Join(left, right) = specs[index].op { - stack.push(left); - stack.push(right); - } - } - active - }, - }; - // The manifest shards whose proofs this run takes as input. - let mut required = vec![false; prepared.shards.len()]; - for (index, spec) in specs.iter().enumerate() { - if let PlanOp::Leaf(shard) = spec.op { - required[shard] = active[index]; - } - } - let specs_at = Instant::now(); - if !config.verify_only { - print_plan(&specs, &prepared.shards, config.structural_above); - } - if let (true, Some(target)) = (config.plan_only, config.subtree) { - // The subtree run's `ix prove --shards` argument, on stdout as one line. - let mut ids: Vec = required - .iter() - .enumerate() - .filter(|(_, flag)| **flag) - .map(|(shard, _)| prepared.shards[shard].original_id) - .collect(); - ids.sort_unstable(); - let ids: Vec = ids.iter().map(u32::to_string).collect(); - println!("subtree {target} shards: {}", ids.join(",")); - } - if config.plan_only { - eprintln!( - "[aggregate] Rust plan startup: manifest {:.3}s, env/claims {:.3}s, plan/statements {:.3}s; total {:.3}s", - (parsed_at - started).as_secs_f64(), - (prepared_at - parsed_at).as_secs_f64(), - (specs_at - prepared_at).as_secs_f64(), - (specs_at - started).as_secs_f64(), - ); - return Ok(String::new()); - } - - 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_path = std::env::var_os("AIUR_AGGREGATE_CACHE_DIR") - .map_or_else(|| ix_root.join("cache").join("aggregate"), PathBuf::from); - let cache_dir = config.use_cache.then_some(cache_path.as_path()); - if let Some(dir) = cache_dir { - if config.write_outputs { - fs::create_dir_all(dir).map_err(|error| { - format!("create aggregate cache {}: {error}", dir.display()) - })?; - } else if config.reprove_slot.is_some() && !dir.is_dir() { - return Err(format!( - "aggregate replay cache {} does not exist", - dir.display() - )); - } - } else if !config.verify_only { - eprintln!("[aggregate] cache disabled (--no-cache)"); - } - if !config.write_outputs && !config.verify_only { - eprintln!("[aggregate] output writes disabled (--no-write)"); - } - let needs_input_proofs = - replay_plan.as_ref().is_none_or(|plan| plan.needs_input_proofs); - let proofs = if needs_input_proofs { - Some(load_input_proofs( - config.proof_hexes, - &store_dir, - &prepared.shards, - &required, - )?) - } else { - let supplied = - config.proof_hexes.lines().filter(|line| !line.is_empty()).count(); - eprintln!( - "[aggregate] replay uses cached aggregate children; skipping {supplied} supplied shard proof wrapper(s)" - ); - None - }; - let proofs_at = Instant::now(); - if config.verify_only { - let shards = prepared.shards.len(); - let proofs = proofs.as_deref().unwrap_or(&[]); - let bound = proofs.iter().flatten().count(); - if bound != shards { - return Err(format!( - "bound {bound} shard proofs but the manifest has {shards} shards" - )); - } - let failures: Vec = proofs - .par_iter() - .enumerate() - .filter_map(|(shard, wrapper)| { - let wrapper = wrapper.as_ref()?; - let statement = &prepared.shards[shard].statement; - let inner = inner_claim(config.verify_idx, &statement.claim_bytes); - let proof = match AiurProof::from_bytes(&wrapper.proof) { - Ok(proof) => proof, - Err(error) => { - return Some(format!( - "shard {shard}: proof does not decode: {error}" - )); - }, - }; - config.ixvm_system.verify(&inner, &proof).err().map(|error| { - format!("shard {shard}: proof fails verification: {error:?}") - }) - }) - .collect(); - if !failures.is_empty() { - return Err(failures.join("; ")); - } - // Shard claims that assume their binding hold once the binding claim for - // their context does: verify that proof too. - if let Some(binding) = config.binding_proof { - let ctx = &prepared.ctx; - let expected = ixon::proof::Claim::Binding { - spec: ctx.spec.clone(), - binding: ctx.binding.clone(), - }; - if binding.claim != expected { - return Err( - "the binding proof is not for the environment's binding".into(), - ); - } - let (_, binding_bytes) = binding.claim.commit(); - let inner = inner_claim(config.verify_idx, &binding_bytes); - let proof = AiurProof::from_bytes(&binding.proof) - .map_err(|error| format!("binding proof does not decode: {error}"))?; - config.ixvm_system.verify(&inner, &proof).map_err(|error| { - format!("binding proof fails verification: {error:?}") - })?; - eprintln!( - "[verify] binding proof verified: the shard claims' condition holds" - ); - } - eprintln!( - "[verify] OK: composed verdict — all {shards} shards proven + disjoint cover ({shards} proofs verified natively in {:.1}s; claims {:.1}s)", - proofs_at.elapsed().as_secs_f64(), - (prepared_at - parsed_at).as_secs_f64(), - ); - return Ok(String::new()); - } - eprintln!( - "[aggregate] Rust startup: manifest {:.3}s, env/claims {:.3}s, plan/statements {:.3}s, proofs {:.3}s; total {:.3}s", - (parsed_at - started).as_secs_f64(), - (prepared_at - parsed_at).as_secs_f64(), - (specs_at - prepared_at).as_secs_f64(), - (proofs_at - specs_at).as_secs_f64(), - (proofs_at - started).as_secs_f64(), - ); - let context = ProveContext { - specs: &specs, - prepared: &prepared.shards, - proofs: proofs.as_deref(), - owner_by_address: &prepared.owner_by_address, - ixvm_system: config.ixvm_system, - aggr_system: config.aggr_system, - ixvm_vk: &ixvm_vk, - aggr_vk: &aggr_vk, - allowed: &allowed, - verify_idx: config.verify_idx, - aggr_idx: config.aggr_idx, - store_dir: &store_dir, - cache_dir, - cache_read_dir: if config.fresh { None } else { cache_dir }, - reprove_slot: config.reprove_slot, - write_outputs: config.write_outputs, - // Slots share the run's budget evenly across the concurrent jobs; with - // every ready slot allowed at once, each gets the whole budget and the - // scheduler's per-slot weights alone bound concurrency. - wrap_budget: config - .trace_shards - .then(|| config.ram_budget_bytes / config.jobs.max(1)), - range_width: config.range_width, - range_jobs: config.jobs.max(1), - binding_proof: config.binding_proof, - }; - if let (Some(target), Some(plan)) = - (config.reprove_slot, replay_plan.as_ref()) - { - return run_replay(context, target, plan); - } - - let jobs_label = if config.jobs == 0 { - "all ready slots".to_string() - } else { - config.jobs.to_string() - }; - eprintln!( - "[aggregate] scheduler: jobs={jobs_label}, RAM budget {} GiB; wrap/self 195.0 GiB, direct 390.0 GiB, mixed 340.0 GiB, flat +1 MiB/subject", - format_gib(config.ram_budget_bytes) - ); - let mut slots = run_scheduler( - context, - config.jobs, - config.exec_ahead, - config.ram_budget_bytes, - &active, - )?; - if let Some(target) = config.subtree { - // A subtree run's success means its subtree root is proven, verified and - // published where the final run will look for it. - let slot = slots - .get_mut(target) - .and_then(Option::take) - .ok_or_else(|| format!("scheduler produced no slot {target}"))?; - config.aggr_system.verify(&slot.outer_claim, &slot.proof).map_err( - |error| { - format!("subtree {target} root proof failed verification: {error:?}") - }, - )?; - let (address, disposition) = match slot.proof_address.as_ref() { - Some(address) => (address.clone(), ""), - None if config.write_outputs => { - return Err(format!( - "subtree {target} root was proven but not published to the aggregate cache" - )); - }, - None => { - (wrapper_address(&slot.statement, &slot.proof)?, " (not persisted)") - }, - }; - eprintln!( - "[aggregate] subtree {target} root: {}{disposition}", - address.hex() - ); - return Ok(address.hex()); - } - let root = slots - .last() - .and_then(Option::as_ref) - .ok_or("aggregate plan produced no root slot")?; - if root.kind != ChildKind::Aggr { - return Err("aggregate plan produced a raw IxVM root".into()); - } - validate_root_statement(&prepared, &root.statement)?; - // Wrap until the final proof is a single trace shard: each wrap verifies - // the previous proof, so its own execution shrinks with that proof's - // shard count until one shard verifies it. - let mut wrapped: Option = None; - if config.wrap_root { - loop { - let current = wrapped.as_ref().unwrap_or(&root.proof); - let shards = current.preamble.headers.len(); - if shards <= 1 { - break; - } - let next = wrap_root(context, root, current)?; - if next.preamble.headers.len() >= shards { - eprintln!( - "[aggregate] root wrap did not shrink the proof ({shards} shards); keeping the previous one" - ); - break; - } - wrapped = Some(next); - } - } - let (proof, proof_address) = match &wrapped { - Some(proof) => (proof, None), - None => (&root.proof, root.proof_address.as_ref()), - }; - config.aggr_system.verify(&root.outer_claim, proof).map_err(|error| { - format!("aggregate root proof failed verification: {error:?}") - })?; - // Claims that assume their binding: discharge once, here. The discharged - // claim is the one a run that validates its binding states. - if let Some(binding) = config.binding_proof { - let (discharged, _) = discharge_root(context, root, proof, binding)?; - let statement = Statement::new( - ClaimContext { binding_assumed: false, ..root.statement.ctx.clone() }, - root.statement.subjects.clone(), - root.statement.assumptions.clone(), - ); - let outer = protocol::aggregate_outer_claim( - config.aggr_idx, - &allowed, - &statement.claim_bytes, - ); - config.aggr_system.verify(&outer, &discharged).map_err(|error| { - format!("binding discharge proof failed verification: {error:?}") - })?; - let (address, persisted) = if config.write_outputs { - (persist_wrapper(&store_dir, &statement, &discharged)?, true) - } else { - (wrapper_address(&statement, &discharged)?, false) - }; - let disposition = if persisted { "" } else { " (not persisted)" }; - eprintln!( - "[aggregate] root proof, binding discharged: {}{disposition}", - address.hex() - ); - return Ok(address.hex()); - } - let (address, persisted) = match proof_address { - Some(address) => (address.clone(), true), - None if config.write_outputs => { - (persist_wrapper(&store_dir, &root.statement, proof)?, true) - }, - None => (wrapper_address(&root.statement, proof)?, false), - }; - let disposition = if persisted { "" } else { " (not persisted)" }; - eprintln!("[aggregate] root proof: {}{disposition}", address.hex()); - Ok(address.hex()) -} - -fn panic_text(payload: &Box) -> &str { - payload - .downcast_ref::<&str>() - .copied() - .or_else(|| payload.downcast_ref::().map(String::as_str)) - .unwrap_or("unknown Rust panic") -} - -#[cfg(test)] -mod tests; diff --git a/crates/ffi/src/aiur/aggregate/ffi.rs b/crates/ffi/src/aiur/aggregate/ffi.rs deleted file mode 100644 index 63e7a4f46..000000000 --- a/crates/ffi/src/aiur/aggregate/ffi.rs +++ /dev/null @@ -1,461 +0,0 @@ -//! Aggregation FFI; keeps Lean marshalling outside the native controller. - -use crate::aiur::protocol::{ - AIUR_PROOF_CLASS, build_g_array, build_query_counts_array, -}; -use crate::aiur::{ - lean_unbox_g, lean_unbox_nat_as_usize, toplevel::decode_toplevel, -}; -use crate::lean::LeanAiurToplevel; -use aiur::synthesis::AiurSystem; -use lean_ffi::object::{ - LeanArray, LeanBorrowed, LeanByteArray, LeanExcept, LeanExternal, LeanNat, - LeanOwned, LeanProd, -}; - -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 ixon::shard::ShardManifest; -use ixvm_codegen::env_handle::EnvHandle; -use lean_ffi::object::LeanString; -use std::{fs, path::Path}; - -/// Native manifest/environment binding for `ix verify --aggregate --ixes`. -/// The returned claim comes from the exact statement builder used by Stage 2, -/// after a full constant/shard/assumption audit. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_aggregate_expected( - env_handle: LeanExternal>, - manifest_path: LeanString>, - structural_above: LeanNat>, -) -> LeanExcept { - let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { - 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}"))?; - expected_from_manifest( - &env_handle.get().env, - &manifest, - lean_unbox_nat_as_usize(structural_above.inner()), - ) - })); - match result { - Ok(Ok((statement, constant_count))) => { - let expected = LeanAiurAggregateExpected::alloc(0); - expected.set_obj(0, LeanByteArray::from_bytes(&statement.claim_bytes)); - expected.set_obj(1, LeanOwned::box_usize(constant_count)); - LeanExcept::ok(expected) - }, - Ok(Err(error)) => LeanExcept::error_string(&error), - Err(payload) => LeanExcept::error_string(&format!( - "native aggregate verification setup panicked: {}", - panic_text(&payload) - )), - } -} - -/// `AiurSystem.aggregateSubtreePlan`: the plan cut into `subtrees` for -/// `ix prove --ixe --ixes`. 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)] -extern "C" fn rs_aiur_stage2_aggregate( - ixvm_system: LeanExternal>, - aggr_system: LeanExternal>, - env_handle: LeanExternal>, - manifest_path: LeanString>, - proof_hexes: LeanString>, - verify_idx: LeanNat>, - aggr_idx: LeanNat>, - jobs: LeanNat>, - ram_budget_bytes: LeanNat>, - structural_above: LeanNat>, - reprove_slot_code: LeanNat>, - direct_joins: bool, - plan_only: bool, - cache_fri_bytes: LeanByteArray>, - use_cache: bool, - write_outputs: bool, - trace_shards: bool, - range_width: LeanNat>, - wrap_root: bool, - exec_ahead: LeanNat>, - verify_only: bool, - subtree_code: LeanNat>, - binding_proof_path: LeanString>, - fresh: bool, -) -> LeanExcept { - let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { - let reprove_slot = - lean_unbox_nat_as_usize(reprove_slot_code.inner()).checked_sub(1); - let subtree = lean_unbox_nat_as_usize(subtree_code.inner()).checked_sub(1); - let binding_proof = - super::multi_gpu::read_binding_proof(binding_proof_path.as_str())?; - run(RunConfig { - ixvm_system: ixvm_system.get(), - aggr_system: aggr_system.get(), - env_handle: env_handle.get(), - manifest_path: Path::new(manifest_path.as_str()), - proof_hexes: proof_hexes.as_str(), - verify_idx: lean_unbox_nat_as_usize(verify_idx.inner()), - aggr_idx: lean_unbox_nat_as_usize(aggr_idx.inner()), - jobs: lean_unbox_nat_as_usize(jobs.inner()), - ram_budget_bytes: lean_unbox_nat_as_usize(ram_budget_bytes.inner()), - structural_above: lean_unbox_nat_as_usize(structural_above.inner()), - reprove_slot, - direct_joins, - plan_only, - cache_fri_bytes: cache_fri_bytes.as_bytes(), - use_cache, - fresh, - write_outputs, - trace_shards, - range_width: lean_unbox_nat_as_usize(range_width.inner()), - wrap_root, - exec_ahead: lean_unbox_nat_as_usize(exec_ahead.inner()), - verify_only, - subtree, - binding_proof: binding_proof.as_ref(), - }) - })); - match result { - Ok(Ok(address)) => LeanExcept::ok(LeanString::new(&address)), - Ok(Err(error)) => LeanExcept::error_string(&error), - Err(payload) => LeanExcept::error_string(&format!( - "native Stage 2 orchestration panicked: {}", - panic_text(&payload) - )), - } -} - -fn build_ix_aggr_io_buffer( - shape: usize, - left_proof_advice: &[u8], - right_proof_advice: &[u8], - ixvm_vk: &[u8], - self_vk: &[u8], - left_claims: &[u8], - right_claims: &[u8], - output_claim: &[u8], - allowed: &[u8], - preimages_blob: &[u8], - trees_blob: &[u8], - paths_blob: &[u8], -) -> Result { - use ixvm_codegen::aiur_ix_aggr_runner::{ - AggrAdvice, aggr_io_buffer, decode_aggr_paths, decode_aggr_preimages, - decode_aggr_trees, - }; - - let shape = u8::try_from(shape) - .map_err(|err| format!("aggr shape {shape} out of range: {err}"))?; - let preimages = decode_aggr_preimages(preimages_blob)?; - let trees = decode_aggr_trees(trees_blob)?; - let paths = decode_aggr_paths(paths_blob)?; - Ok(aggr_io_buffer(&AggrAdvice { - shape, - proof_advice: [left_proof_advice, right_proof_advice], - ixvm_vk, - self_vk, - child_claims: [left_claims, right_claims], - output_claim, - allowed, - preimages: &preimages, - trees: &trees, - paths: &paths, - })) -} - -/// `Bytecode.Toplevel.executeIxAggr`: execute the `ix_aggr` entrypoint over -/// raw proof-advice/claim/tree blobs plus the shape hint. The native builder -/// expands the compact keyed framing directly into the circuit's -/// seven-channel IO buffer. As with `rs_aiur_multi_stark_execute`, callers -/// may select either generated execution or the generic bytecode -/// interpreter. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_ix_aggr_execute( - toplevel: LeanAiurToplevel>, - fun_idx: LeanNat>, - pub_input: LeanArray>, - shape: LeanNat>, - left_proof_advice_bytes: LeanByteArray>, - right_proof_advice_bytes: LeanByteArray>, - ixvm_vk_bytes: LeanByteArray>, - self_vk_bytes: LeanByteArray>, - left_claims_bytes: LeanByteArray>, - right_claims_bytes: LeanByteArray>, - output_claim_bytes: LeanByteArray>, - allowed_bytes: LeanByteArray>, - preimages_blob: LeanByteArray>, - trees_blob: LeanByteArray>, - paths_blob: LeanByteArray>, - use_bytecode: bool, -) -> LeanExcept { - let toplevel = decode_toplevel(&toplevel); - let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let mut io_buffer = match build_ix_aggr_io_buffer( - lean_unbox_nat_as_usize(shape.inner()), - left_proof_advice_bytes.as_bytes(), - right_proof_advice_bytes.as_bytes(), - ixvm_vk_bytes.as_bytes(), - self_vk_bytes.as_bytes(), - left_claims_bytes.as_bytes(), - right_claims_bytes.as_bytes(), - output_claim_bytes.as_bytes(), - allowed_bytes.as_bytes(), - preimages_blob.as_bytes(), - trees_blob.as_bytes(), - paths_blob.as_bytes(), - ) { - Ok(io) => io, - Err(err) => return LeanExcept::error_string(&err), - }; - let input = pub_input.map(|x| lean_unbox_g(&x)); - - let _g = tracing::info_span!("aiur/execute_ix_aggr").entered(); - let result = if use_bytecode { - toplevel.execute(fun_idx, input, &mut io_buffer) - } else { - ixvm_codegen::aiur_ix_aggr_runner::execute_ix_aggr( - &toplevel, - fun_idx, - input, - &mut io_buffer, - ) - }; - let (query_record, output) = match result { - Ok(pair) => pair, - Err(err) => return LeanExcept::error_string(&err.to_string()), - }; - - let lean_query_counts = build_query_counts_array(&query_record, &toplevel); - LeanExcept::ok(LeanProd::new(build_g_array(&output), lean_query_counts)) -} - -/// `AiurSystem.proveIxAggr`: prove one valid `ix_aggr` execution using the -/// same native advice builder and generated/interpreted executor selection -/// as `rs_aiur_ix_aggr_execute`. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_ix_aggr_prove( - aiur_system_obj: LeanExternal>, - fun_idx: LeanNat>, - pub_input: LeanArray>, - shape: LeanNat>, - left_proof_advice_bytes: LeanByteArray>, - right_proof_advice_bytes: LeanByteArray>, - ixvm_vk_bytes: LeanByteArray>, - self_vk_bytes: LeanByteArray>, - left_claims_bytes: LeanByteArray>, - right_claims_bytes: LeanByteArray>, - output_claim_bytes: LeanByteArray>, - allowed_bytes: LeanByteArray>, - preimages_blob: LeanByteArray>, - trees_blob: LeanByteArray>, - paths_blob: LeanByteArray>, - use_bytecode: bool, -) -> LeanExcept { - let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let mut io_buffer = match build_ix_aggr_io_buffer( - lean_unbox_nat_as_usize(shape.inner()), - left_proof_advice_bytes.as_bytes(), - right_proof_advice_bytes.as_bytes(), - ixvm_vk_bytes.as_bytes(), - self_vk_bytes.as_bytes(), - left_claims_bytes.as_bytes(), - right_claims_bytes.as_bytes(), - output_claim_bytes.as_bytes(), - allowed_bytes.as_bytes(), - preimages_blob.as_bytes(), - trees_blob.as_bytes(), - paths_blob.as_bytes(), - ) { - Ok(io) => io, - Err(err) => return LeanExcept::error_string(&err), - }; - let args = pub_input.map(|x| lean_unbox_g(&x)); - - let system = aiur_system_obj.get(); - let (claim, proof) = if use_bytecode { - system.prove(fun_idx, &args, &mut io_buffer) - } else { - system.prove_ixvm( - fun_idx, - &args, - &mut io_buffer, - ixvm_codegen::aiur_ix_aggr_runner::execute_ix_aggr, - ) - }; - - let lean_proof: LeanOwned = - LeanExternal::alloc(&AIUR_PROOF_CLASS, proof).into(); - LeanExcept::ok(LeanProd::new(build_g_array(&claim), lean_proof)) -} - -/// `AiurSystem.proveIxAggrWithin`: prove one valid `ix_aggr` execution, as -/// `rs_aiur_ix_aggr_prove` does with the generated executor, but planned as -/// trace shards whose projected host peak fits `max_bytes`. A driver that -/// proves single aggregation steps (`ix aggregate --ixc`) holds each one to -/// its RAM budget this way, as the Stage 2 controller holds its slots. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_ix_aggr_prove_within( - aiur_system_obj: LeanExternal>, - fun_idx: LeanNat>, - pub_input: LeanArray>, - shape: LeanNat>, - left_proof_advice_bytes: LeanByteArray>, - right_proof_advice_bytes: LeanByteArray>, - ixvm_vk_bytes: LeanByteArray>, - self_vk_bytes: LeanByteArray>, - left_claims_bytes: LeanByteArray>, - right_claims_bytes: LeanByteArray>, - output_claim_bytes: LeanByteArray>, - allowed_bytes: LeanByteArray>, - preimages_blob: LeanByteArray>, - trees_blob: LeanByteArray>, - paths_blob: LeanByteArray>, - max_bytes: LeanNat>, -) -> LeanExcept { - use aiur::synthesis::GatedProve; - let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let max_bytes = lean_unbox_nat_as_usize(max_bytes.inner()); - let mut io_buffer = match build_ix_aggr_io_buffer( - lean_unbox_nat_as_usize(shape.inner()), - left_proof_advice_bytes.as_bytes(), - right_proof_advice_bytes.as_bytes(), - ixvm_vk_bytes.as_bytes(), - self_vk_bytes.as_bytes(), - left_claims_bytes.as_bytes(), - right_claims_bytes.as_bytes(), - output_claim_bytes.as_bytes(), - allowed_bytes.as_bytes(), - preimages_blob.as_bytes(), - trees_blob.as_bytes(), - paths_blob.as_bytes(), - ) { - Ok(io) => io, - Err(err) => return LeanExcept::error_string(&err), - }; - let args = pub_input.map(|x| lean_unbox_g(&x)); - let system = aiur_system_obj.get(); - let gated = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { - system.prove_ixvm_within_budget( - fun_idx, - &args, - &mut io_buffer, - ixvm_codegen::aiur_ix_aggr_runner::execute_ix_aggr, - Some(max_bytes), - false, - true, - None, - ) - })); - match gated { - Ok(GatedProve::Proved { claim, proof, peak }) => { - eprintln!( - "[aggregate] proved within {max_bytes} B: projected peak {peak} B" - ); - let lean_proof: LeanOwned = - LeanExternal::alloc(&AIUR_PROOF_CLASS, proof).into(); - LeanExcept::ok(LeanProd::new(build_g_array(&claim), lean_proof)) - }, - Ok(GatedProve::Split { peak, .. }) => LeanExcept::error_string(&format!( - "ix_aggr: no trace-shard count fits the {max_bytes} B budget \ - (whole-execution peak {peak} B)" - )), - Ok(GatedProve::Failed(error)) => { - LeanExcept::error_string(&format!("ix_aggr: execution failed: {error}")) - }, - Ok(GatedProve::Measured { .. }) => { - LeanExcept::error_string("ix_aggr: the prove only measured") - }, - Err(payload) => LeanExcept::error_string(&format!( - "ix_aggr: prove panicked: {}", - panic_text(&payload) - )), - } -} diff --git a/crates/ffi/src/aiur/aggregate/multi_gpu.rs b/crates/ffi/src/aiur/aggregate/multi_gpu.rs deleted file mode 100644 index b1000cca3..000000000 --- a/crates/ffi/src/aiur/aggregate/multi_gpu.rs +++ /dev/null @@ -1,1376 +0,0 @@ -//! 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::{BTreeSet, 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_with; - -use super::prepare::PreparedRun; -use super::protocol::{aggregate_outer_claim, 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, ClaimContext, 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 gpus: usize, - /// Per-GPU host budget in bytes, multiplied by `gpus`; 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, - /// An IxVM proof of the `Binding` claim for the environment's binding. - /// When present, every claim of the run assumes its binding and the root - /// discharges that condition once. - pub binding_proof: Option, - pub fresh: bool, -} - -/// 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-GPU 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: Box, - 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_with( - env, - &owned[shard], - ctx.binding_proof.is_some(), - ) - .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: Box::new(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 _ = 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:?}") - }, - )?; - // Claims that assume their binding: discharge once, here. - if let Some(binding) = ctx.binding_proof { - let reservation = pool - .try_admit() - .map_err(|error| { - format!("binding discharge admission: {error:?}") - })? - .ok_or("binding discharge cannot acquire record capacity")?; - let record = bind_record_reservation(&reservation); - let (discharged, _) = discharge_root(ctx, &root, proof, binding)?; - drop(record); - drop(reservation); - let statement = Statement::new( - ClaimContext { - binding_assumed: false, - ..root.statement.ctx.clone() - }, - root.statement.subjects.clone(), - root.statement.assumptions.clone(), - ); - let outer = aggregate_outer_claim( - ctx.aggr_idx, - ctx.allowed, - &statement.claim_bytes, - ); - ctx.aggr_system.verify(&outer, &discharged).map_err(|error| { - format!("binding discharge proof failed verification: {error:?}") - })?; - let address = - persist_wrapper(ctx.store_dir, &statement, &discharged)?; - return Ok(address.hex()); - } - 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()) -} - -pub fn run( - cfg: &Config, - ixvm: &AiurSystem, - aggr: &AiurSystem, - env: &ixon::Env, - manifest_path: &Path, - verify_idx: usize, - aggr_idx: usize, -) -> Result { - 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_PROOF_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 = if cfg.fresh { - source - } else { - 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(|| ixon::shard::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; - }, - } - } -} - -/// One pass over a manifest: the plan, the host budget it runs under, and -/// a resident prover pair per device. -struct Pass { - prepared: PreparedRun, - specs: Vec, - ixvm_vk: Vec, - aggr_vk: Vec, - allowed: Vec, - verify_idx: usize, - aggr_idx: usize, - root_slot: usize, - root_left: usize, - root_right: usize, - /// The plan slot holding each manifest shard's claim. - leaf_slot: Vec, - /// The sorted leaves of each shard's statement. - owned: Vec>, - store_dir: PathBuf, - cache_dir: PathBuf, - index_dir: PathBuf, - fresh: bool, - /// CPU execution threads shared by every GPU. - executions: usize, - /// The process-wide host limit, the prover budget of every slot. - wrap_budget: Option, - pool: RecordPool, - systems: Vec<(AiurSystem, AiurSystem)>, - /// The run's binding proof, when its claims assume their binding. - binding_proof: Option, -} - -impl Pass { - fn shards(&self) -> usize { - self.prepared.shards.len() - } - - /// One proving context per device, all over the same plan and keys. - fn contexts(&self) -> Vec> { - self - .systems - .iter() - .map(|(ixvm_system, aggr_system)| ProveContext { - specs: &self.specs, - prepared: &self.prepared.shards, - proofs: None, - owner_by_address: &self.prepared.owner_by_address, - ixvm_system, - aggr_system, - ixvm_vk: &self.ixvm_vk, - aggr_vk: &self.aggr_vk, - allowed: &self.allowed, - verify_idx: self.verify_idx, - aggr_idx: self.aggr_idx, - store_dir: &self.store_dir, - cache_dir: Some(&self.cache_dir), - cache_read_dir: (!self.fresh).then_some(self.cache_dir.as_path()), - reprove_slot: None, - write_outputs: true, - wrap_budget: self.wrap_budget, - range_width: 0, - range_jobs: 1, - binding_proof: self.binding_proof.as_ref(), - }) - .collect() - } -} - -fn say(message: &str) { - eprintln!("[multi-gpu] {message}"); -} - -fn plan_pass( - cfg: &Config, - ixvm: &AiurSystem, - aggr: &AiurSystem, - env: &ixon::Env, - manifest: &ShardManifest, - verify_idx: usize, - aggr_idx: usize, - cache_root: &Path, - record_max_bytes: usize, -) -> Result { - let prepared = prepare_run_with(env, manifest, cfg.binding_proof.is_some())?; - 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 root_slot = specs.len().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 mut leaf_slot = vec![usize::MAX; prepared.shards.len()]; - 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.gpus == 0 { - return Err("at least one GPU is required".into()); - } - let exec_jobs = if cfg.exec_jobs == 0 { - let cores = thread::available_parallelism().map_or(1, usize::from); - (cores / cfg.gpus).max(1) - } else { - cfg.exec_jobs - }; - let executions = - exec_jobs.checked_mul(cfg.gpus).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.gpus, - executions, - cfg.max_ram_bytes, - super::super::protocol::detected_ram_budget(), - cgroup_limit, - cells, - )?; - 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.gpus, - 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.gpus)); - let systems: Vec<(AiurSystem, AiurSystem)> = (0..cfg.gpus) - .map(|g| { - let device = - i32::try_from(g).map_err(|error| format!("GPU {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" - )); - } - } - - Ok(Pass { - prepared, - specs, - ixvm_vk, - aggr_vk, - allowed, - verify_idx, - aggr_idx, - root_slot, - root_left, - root_right, - leaf_slot, - owned, - store_dir, - cache_dir, - index_dir, - fresh: cfg.fresh, - executions, - wrap_budget: Some(host.limit), - pool, - systems, - binding_proof: cfg.binding_proof.clone(), - }) -} - -/// What persisted state fills before a pass dispatches anything: cached -/// joins with the subtrees they retire, and claims the index still proves. -struct Resumed { - slots: Vec>>, - retired: Vec, - claim_done: Vec, -} - -fn resume_pass(pass: &Pass, ctx: ProveContext<'_>) -> Resumed { - let count = pass.specs.len(); - let shards = pass.shards(); - if pass.fresh { - say(&format!( - "{shards} claims: fresh proving, no indexed proofs or cached joins reused" - )); - return Resumed { - slots: vec![None; count], - retired: vec![false; count], - claim_done: vec![false; shards], - }; - } - // Cached joins from the root down retire their subtrees. - let mut slots: Vec>> = vec![None; count]; - let mut retired = vec![false; count]; - for index in (0..pass.root_slot).rev() { - let spec = &pass.specs[index]; - if retired[index] || spec.kind != ChildKind::Aggr { - continue; - } - let Some((proof, address)) = load_cached( - ctx.aggr_system, - ctx.store_dir, - ctx.cache_read_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) = pass.specs[slot].op { - stack.push(l); - stack.push(r); - } - } - } - // Indexed claim proofs stand in for their claims. A claim retired under - // a cached join is still loaded when the index holds its proof, so the - // composed verdict can verify it independently. - let mut claim_done = vec![false; shards]; - let resumed: Vec> = (0..shards) - .into_par_iter() - .map(|shard| { - resume_leaf(ctx, &pass.index_dir, pass.leaf_slot[shard], shard) - }) - .collect(); - let mut reused = 0usize; - for (shard, slot) in resumed.into_iter().enumerate() { - if let Some(slot) = slot { - slots[pass.leaf_slot[shard]] = Some(Arc::new(slot)); - claim_done[shard] = true; - reused += 1; - } else if retired[pass.leaf_slot[shard]] { - claim_done[shard] = true; - } - } - let cached_joins = slots - .iter() - .enumerate() - .filter(|(i, s)| { - s.is_some() - && *i != pass.root_slot - && !matches!(pass.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 - )); - Resumed { slots, retired, claim_done } -} - -/// The dispatch state of a running pass: which plan slots are proven, -/// queued, or executing, and how the pass ended. -struct Scheduler<'a> { - pass: &'a Pass, - manifest: &'a ShardManifest, - started: Instant, - slots: Vec>>, - retired: Vec, - claim_done: Vec, - claim_queue: VecDeque, - /// Joins queued or executing. - dispatched: FxHashSet, - root_dispatched: bool, - free_executors: usize, - in_flight: usize, - /// Claims whose records exceed the per-record ceiling, split once the - /// active work drains. - to_split: BTreeSet, - root_address: Option, - failure: Option, -} - -impl<'a> Scheduler<'a> { - fn new( - pass: &'a Pass, - manifest: &'a ShardManifest, - started: Instant, - resumed: Resumed, - ) -> Self { - let Resumed { slots, retired, claim_done } = resumed; - let claim_queue = (0..pass.shards()).filter(|&s| !claim_done[s]).collect(); - Self { - pass, - manifest, - started, - slots, - retired, - claim_done, - claim_queue, - dispatched: FxHashSet::default(), - root_dispatched: false, - free_executors: pass.executions, - in_flight: 0, - to_split: BTreeSet::new(), - root_address: None, - failure: None, - } - } - - fn work_name(&self, work: Work) -> String { - match work { - Work::Claim(shard) => { - format!("claim {}", self.pass.prepared.shards[shard].original_id) - }, - Work::Join(slot) => format!("join {slot}"), - Work::Root => "root".to_string(), - } - } - - fn elapsed(&self) -> u64 { - self.started.elapsed().as_secs() - } - - fn idle(&self) -> bool { - self.in_flight == 0 && self.free_executors == self.pass.executions - } - - fn finished(&self) -> bool { - self.failure.is_some() || self.root_address.is_some() - } - - /// The next unit an executor can take: a join whose inputs are proven, - /// then the root once every claim is done, then the oldest claim. - fn next_work(&self) -> Option { - let pass = self.pass; - let ready_join = (0..pass.root_slot).find(|&index| { - !self.retired[index] - && self.slots[index].is_none() - && !self.dispatched.contains(&index) - && match pass.specs[index].op { - PlanOp::Join(l, r) => { - self.slots[l].is_some() && self.slots[r].is_some() - }, - PlanOp::Leaf(_) => false, - } - }); - if let Some(slot) = ready_join { - Some(Work::Join(slot)) - } else if !self.root_dispatched - && self.claim_done.iter().all(|d| *d) - && self.slots[pass.root_left].is_some() - && self.slots[pass.root_right].is_some() - { - Some(Work::Root) - } else { - self.claim_queue.front().map(|&shard| Work::Claim(shard)) - } - } - - /// The proven inputs `work` joins. - fn children(&self, work: Work) -> Vec> { - let (l, r) = match work { - Work::Claim(_) => return Vec::new(), - Work::Join(slot) => { - let PlanOp::Join(l, r) = self.pass.specs[slot].op else { - unreachable!() - }; - (l, r) - }, - Work::Root => (self.pass.root_left, self.pass.root_right), - }; - vec![self.slots[l].clone().unwrap(), self.slots[r].clone().unwrap()] - } - - /// Accounts for `work` having left for an executor. - fn queued(&mut self, work: Work) { - self.free_executors -= 1; - self.in_flight += 1; - say(&format!( - "{} dispatched at +{}s", - self.work_name(work), - self.elapsed() - )); - match work { - Work::Claim(_) => { - self.claim_queue.pop_front(); - }, - Work::Join(slot) => { - self.dispatched.insert(slot); - }, - Work::Root => self.root_dispatched = true, - } - } - - /// Every claim's slot, in manifest shard order. - fn leaves(&self) -> Vec>> { - self.pass.leaf_slot.iter().map(|&slot| self.slots[slot].clone()).collect() - } - - fn handle(&mut self, event: Event) { - match event { - Event::ExecutionStarted { executor, work } => say(&format!( - "executor {executor}: {} execution started at +{}s", - self.work_name(work), - self.elapsed(), - )), - Event::Prepared { executor, work, record_bytes, secs } => say(&format!( - "executor {executor}: {} executed in {secs:.1}s, record {record_bytes} B ({} GiB) at +{}s", - self.work_name(work), - format_gib(record_bytes), - self.elapsed(), - )), - Event::PrepAvailable => { - self.free_executors += 1; - }, - Event::PrepFailed { executor, work, failure } => { - self.free_executors += 1; - self.in_flight -= 1; - self.prep_failed(executor, work, failure); - }, - Event::Proving { worker, work } => say(&format!( - "worker {worker}: {} proving started at +{}s", - self.work_name(work), - self.elapsed(), - )), - Event::Proven { worker, work, result } => { - self.in_flight -= 1; - match (work, result) { - (Work::Claim(shard), Ok(slot)) => { - self.slots[self.pass.leaf_slot[shard]] = Some(slot); - self.claim_done[shard] = true; - say(&format!( - "worker {worker}: claim {} proven at +{}s ({} left)", - self.pass.prepared.shards[shard].original_id, - self.elapsed(), - self.claim_done.iter().filter(|d| !**d).count() - )); - }, - (Work::Join(slot), Ok(proof)) => { - self.slots[slot] = Some(proof); - say(&format!( - "worker {worker}: join {slot} published at +{}s", - self.elapsed() - )); - }, - (_, Err(error)) => { - self.failure = Some(format!("{}: {error}", self.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", self.elapsed())); - self.root_address = Some(address); - }, - Err(error) => self.failure = Some(format!("root: {error}")), - }, - } - } - - /// A contended execution is requeued; one over the record ceiling marks - /// its claim for splitting, and anything else ends the pass. - fn prep_failed( - &mut self, - executor: usize, - work: Work, - failure: PrepareFailure, - ) { - match failure { - PrepareFailure::MemoryContention => { - say(&format!( - "executor {executor}: {} released for memory contention; requeued", - self.work_name(work) - )); - match work { - Work::Claim(shard) => self.claim_queue.push_back(shard), - Work::Join(slot) => { - self.dispatched.remove(&slot); - }, - Work::Root => self.root_dispatched = false, - } - }, - PrepareFailure::OverRecordCap { bytes, cap } => { - let Work::Claim(shard) = work else { - self.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", - self.work_name(work) - )); - return; - }; - let id = self.pass.prepared.shards[shard].original_id; - let source = self - .manifest - .shards - .iter() - .find(|s| s.id == id) - .expect("prepared claim belongs to the manifest"); - if source.blocks.len() > 1 { - self.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 { - self.failure = Some(format!( - "claim {id}: record needs {bytes} B, above the {cap} B per-record ceiling; its single atomic block cannot be split further" - )); - } - }, - PrepareFailure::Other(error) => { - self.failure = Some(format!("{}: {error}", self.work_name(work))); - }, - } - } -} - -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 pass = plan_pass( - cfg, - ixvm, - aggr, - env, - manifest, - verify_idx, - aggr_idx, - cache_root, - record_max_bytes, - )?; - let contexts = pass.contexts(); - let resumed = resume_pass(&pass, contexts[0]); - - let (events_tx, events_rx) = mpsc::channel::(); - let prep_queue = WorkQueue::::new(pass.executions); - let item_queue = WorkQueue::::new(cfg.gpus); - let outcome = thread::scope(|scope| -> Result { - let _shutdown = - ShutdownRun { pool: &pass.pool, prep: &prep_queue, items: &item_queue }; - for executor in 0..pass.executions { - let events = events_tx.clone(); - let (ctx, pass, prep, items) = - (contexts[0], &pass, &prep_queue, &item_queue); - scope.spawn(move || { - prepare_loop( - ctx, - executor, - env, - &pass.owned, - pass.wrap_budget, - prep, - items, - &events, - ) - }); - } - for (worker, &ctx) in contexts.iter().enumerate() { - let events = events_tx.clone(); - let (pass, items) = (&pass, &item_queue); - scope.spawn(move || { - prove_loop( - ctx, - worker, - &pass.prepared, - &pass.leaf_slot, - &pass.index_dir, - items, - &pass.pool, - &events, - ) - }); - } - drop(events_tx); - - let mut scheduler = Scheduler::new(&pass, manifest, started, resumed); - let mut verdict: Option< - thread::ScopedJoinHandle<'_, (Vec, usize)>, - > = None; - loop { - while scheduler.free_executors > 0 && scheduler.to_split.is_empty() { - let Some(work) = scheduler.next_work() else { - break; - }; - let Some(reservation) = pass - .pool - .try_admit() - .map_err(|e| format!("record admission: {e:?}"))? - else { - break; - }; - let children = scheduler.children(work); - 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") - })?; - scheduler.queued(work); - if work == Work::Root && verdict.is_none() { - let (leaves, pass) = (scheduler.leaves(), &pass); - verdict = Some(scope.spawn(move || { - composed_verdict(ixvm, verify_idx, &pass.prepared, &leaves) - })); - } - } - if scheduler.idle() { - if scheduler.to_split.is_empty() { - scheduler.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}"))?; - scheduler.handle(event); - if scheduler.finished() { - break; - } - } - drop(_shutdown); - if let Some(error) = scheduler.failure { - return Err(format!( - "{error}; rerun the same command to resume from what was persisted" - )); - } - if !scheduler.to_split.is_empty() { - return Ok(PassOutcome::Refine(scheduler.to_split.into_iter().collect())); - } - let root = scheduler.root_address.ok_or("no root proof")?; - 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 = pass.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 -} - -/// The `Binding` claim proof at `path`, or none for an empty path. -pub(super) fn read_binding_proof( - path: &str, -) -> Result, String> { - if path.is_empty() { - return Ok(None); - } - let bytes = - fs::read(path).map_err(|error| format!("binding proof {path}: {error}"))?; - let mut rest = bytes.as_slice(); - let proof = IxonProof::get(&mut rest) - .map_err(|error| format!("binding proof {path}: {error}"))?; - if !rest.is_empty() { - return Err(format!("binding proof {path}: trailing bytes")); - } - if !matches!(proof.claim, Claim::Binding { .. }) { - return Err(format!("{path} is not a proof of a Binding claim")); - } - Ok(Some(proof)) -} - -/// The GPUs this process may use: the entries of `CUDA_VISIBLE_DEVICES` when -/// it is set, else the devices the NVIDIA driver lists. A build without CUDA -/// proves on one CPU worker. -fn visible_gpus() -> usize { - if !cfg!(feature = "cuda") { - return 1; - } - if let Ok(devices) = std::env::var("CUDA_VISIBLE_DEVICES") { - return devices.split(',').filter(|d| !d.trim().is_empty()).count(); - } - fs::read_dir("/proc/driver/nvidia/gpus").map_or(0, |gpus| gpus.count()) -} - -/// `AiurSystem.proveMultiGpu`: the whole multi-device run; 0 GPUs uses every -/// visible GPU. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_prove_multi_gpu( - ixvm_system: LeanExternal>, - aggr_system: LeanExternal>, - env_handle: LeanExternal>, - manifest_path: LeanString>, - verify_idx: LeanNat>, - aggr_idx: LeanNat>, - gpus: LeanNat>, - max_ram_bytes: LeanNat>, - exec_jobs: LeanNat>, - structural_above: LeanNat>, - cache_fri_bytes: LeanByteArray>, - out_manifest: LeanString>, - binding_proof_path: LeanString>, - fresh: bool, -) -> LeanExcept { - let binding_proof = match read_binding_proof(binding_proof_path.as_str()) { - Ok(proof) => proof, - Err(error) => return LeanExcept::error_string(&error), - }; - let gpus = match lean_unbox_nat_as_usize(gpus.inner()) { - 0 => visible_gpus(), - n => n, - }; - let cfg = Config { - gpus, - 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())), - binding_proof, - fresh, - }; - if cfg.gpus == 0 { - return LeanExcept::error_string("no visible GPU to prove on"); - } - 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!( - "multi-GPU scheduler panicked: {}", - panic_text(&payload) - )), - } -} diff --git a/crates/ffi/src/aiur/aggregate/multi_gpu/checkpoint.rs b/crates/ffi/src/aiur/aggregate/multi_gpu/checkpoint.rs deleted file mode 100644 index 9b22aaf10..000000000 --- a/crates/ffi/src/aiur/aggregate/multi_gpu/checkpoint.rs +++ /dev/null @@ -1,65 +0,0 @@ -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/multi_gpu/limits.rs b/crates/ffi/src/aiur/aggregate/multi_gpu/limits.rs deleted file mode 100644 index 6718266eb..000000000 --- a/crates/ffi/src/aiur/aggregate/multi_gpu/limits.rs +++ /dev/null @@ -1,139 +0,0 @@ -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( - gpus: usize, - executions: usize, - per_gpu: usize, - detected: Option, - ceiling: Option, - cells: usize, - ) -> Result { - if gpus == 0 || executions == 0 || cells == 0 { - return Err( - "GPUs, execution threads and trace-cell budget must be positive".into(), - ); - } - let requested = if per_gpu == 0 { - detected.ok_or("cannot detect host memory; specify --max-ram per GPU")? - } else { - per_gpu.checked_mul(gpus).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(gpus) - .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 = gpus - .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_gpu_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/normalize.rs b/crates/ffi/src/aiur/aggregate/normalize.rs deleted file mode 100644 index 86200eb70..000000000 --- a/crates/ffi/src/aiur/aggregate/normalize.rs +++ /dev/null @@ -1,127 +0,0 @@ -//! Root normalization: one more `ix_aggr` wrap of an aggregate root, proved -//! in a fixed trace layout. Every root that fits the layout then compresses -//! under the same FRI verifier, whatever the shape of the original root. -use super::protocol::{ - ChildKind, aggregate_outer_claim, serialize_claims, shape_code, -}; -use aiur::{ - G, - execute::{IOBuffer, QueryRecord}, - synthesis::{AiurProof, AiurSystem}, - vk_codec::aiur_system_to_bytes, -}; -use ix_proof_compression::pipeline::FixedRoot; -use ixvm_codegen::aiur_ix_aggr_runner::{ - AggrAdvice, aggr_io_buffer, execute_ix_aggr, -}; - -/// The trusted aggregation backend and the root claim being wrapped. -pub(crate) struct RootWrap<'a> { - pub(crate) system: &'a AiurSystem, - pub(crate) aggr_idx: usize, - pub(crate) allowed: &'a [u8], - pub(crate) ixvm_vk: &'a [u8], - pub(crate) claim: &'a [u8], -} - -struct Executed { - expected: Vec, - io: IOBuffer, - record: QueryRecord, - output: Vec, -} - -impl RootWrap<'_> { - /// Execute a wrap of `proof`: shape 1 verifies one `ix_aggr` proof and - /// passes its claim through. The root proof is verified natively first. - fn execute(&self, proof: &AiurProof) -> Result { - let expected = - aggregate_outer_claim(self.aggr_idx, self.allowed, self.claim); - let advice = self - .system - .proof_to_advice_bytes(&expected, proof) - .map_err(|e| format!("aggregate root: {e}"))?; - let self_vk = aiur_system_to_bytes(self.system)?; - let claims = serialize_claims(&[&expected]); - let mut io = aggr_io_buffer(&AggrAdvice { - shape: shape_code(ChildKind::Aggr, None), - proof_advice: [&advice, &[]], - ixvm_vk: self.ixvm_vk, - self_vk: &self_vk, - child_claims: [&claims, &[]], - output_claim: self.claim, - allowed: self.allowed, - preimages: &[], - trees: &[], - paths: &[], - }); - drop(advice); - // The aggregate call is [channel, entrypoint, inputs…], with no outputs. - let (record, output) = execute_ix_aggr( - self.system.toplevel(), - self.aggr_idx, - expected[2..].to_vec(), - &mut io, - ) - .map_err(|e| format!("root wrap execution: {e}"))?; - if !output.is_empty() { - return Err("root wrap returned unexpected outputs".into()); - } - Ok(Executed { expected, io, record, output }) - } - - /// Rows each circuit of the wrap execution needs, in system order. - pub(crate) fn rows(&self, proof: &[u8]) -> Result, String> { - let proof = decode(proof)?; - let executed = self.execute(&proof)?; - Ok(self.system.execution_rows(&executed.record)) - } - - /// Prove the wrap in `layout`'s fixed shape and return the serialized proof. - pub(crate) fn normalize( - &self, - proof: &[u8], - layout: &FixedRoot, - ) -> Result, String> { - if layout.memory_traces() != self.system.memory_circuits() { - return Err("fixed root layout belongs to a different backend".into()); - } - let proof = decode(proof)?; - let executed = self.execute(&proof)?; - drop(proof); - let Executed { expected, io, record, output } = executed; - let (claim, normalized) = self.system.prove_from_execution_normalized( - self.aggr_idx, - &expected[2..], - &io, - record, - &output, - layout.log_heights(), - )?; - if claim != expected { - return Err("normalization changed the root claim".into()); - } - normalized.to_bytes().map_err(|e| e.to_string()) - } -} - -/// The fixed layout holding every execution in `rows` (elementwise maxima of -/// per-circuit rows), with `headroom` extra doublings per circuit. -pub(crate) fn layout( - system: &AiurSystem, - rows: &[usize], - headroom: u8, - claim_len: usize, -) -> Result { - let logs = system.normalized_log_heights(rows, headroom)?; - FixedRoot::new(logs, system.memory_circuits(), claim_len) - .map_err(|e| e.to_string()) -} - -fn decode(proof: &[u8]) -> Result { - let decoded = AiurProof::from_bytes(proof).map_err(|e| e.to_string())?; - if decoded.to_bytes().map_err(|e| e.to_string())? != proof { - return Err("noncanonical aggregate root proof".into()); - } - Ok(decoded) -} diff --git a/crates/ffi/src/aiur/aggregate/plan.rs b/crates/ffi/src/aiur/aggregate/plan.rs deleted file mode 100644 index 803616b7f..000000000 --- a/crates/ffi/src/aiur/aggregate/plan.rs +++ /dev/null @@ -1,340 +0,0 @@ -//! Aggregation plan. - -use super::{ - GIB, - prepare::PreparedRun, - protocol::{ - ChildKind, aggregate_outer_claim, cache_key, inner_claim, shape_code, - structural_shape_code, - }, - statement::Statement, -}; -use aiur::G; -use ix_common::address::Address; -use ixon::shard::AggNode; -use rustc_hash::FxHashMap; -use std::sync::Arc; - -pub(super) const WRAP_RAM_BYTES: usize = 195 * GIB; - -pub(super) const STRUCTURAL_RAM_BYTES: usize = 195 * GIB; - -pub(super) const RAW_SHARD_RAM_BYTES: usize = 4 * GIB; - -pub(super) const DIRECT_RAM_BYTES: usize = 390 * GIB; - -pub(super) const MIXED_RAM_BYTES: usize = 340 * GIB; - -pub(super) const FLAT_RAM_PER_SUBJECT: usize = 1024 * 1024; - -#[derive(Clone, Copy, Debug)] -pub(super) enum PlanOp { - Leaf(usize), - Join(usize, usize), -} - -#[derive(Debug)] -pub(super) struct StatementSpec { - pub(super) op: PlanOp, - pub(super) statement: Arc, - pub(super) subject_count: usize, - pub(super) structural: bool, -} - -#[derive(Debug)] -pub(super) struct SlotSpec { - pub(super) op: PlanOp, - pub(super) statement: Arc, - pub(super) subject_count: usize, - pub(super) structural: bool, - pub(super) kind: ChildKind, - pub(super) shape: Option, - pub(super) outer_claim: Vec, - pub(super) cache_key: Address, - pub(super) ram_bytes: usize, -} - -pub(super) fn build_plan( - tree: &AggNode, - shard_by_id: &FxHashMap, - out: &mut Vec, -) -> Result { - match tree { - AggNode::Leaf(id) => { - let shard = shard_by_id.get(id).copied().ok_or_else(|| { - format!("aggregate tree references missing shard {id}") - })?; - let index = out.len(); - out.push(PlanOp::Leaf(shard)); - Ok(index) - }, - AggNode::Internal(left, right) => { - let left_index = build_plan(left, shard_by_id, out)?; - let right_index = build_plan(right, shard_by_id, out)?; - let index = out.len(); - out.push(PlanOp::Join(left_index, right_index)); - Ok(index) - }, - } -} - -pub(super) fn shape_ram_bytes(shape: u8, subject_count: usize) -> usize { - match shape { - 0 | 1 => WRAP_RAM_BYTES, - 3 | 4 | 7 | 8 => MIXED_RAM_BYTES, - 5 => STRUCTURAL_RAM_BYTES - .saturating_add(subject_count.saturating_mul(FLAT_RAM_PER_SUBJECT)), - 9 => STRUCTURAL_RAM_BYTES, - // Shapes 2/6 are direct pairs; unknown shapes retain the conservative - // direct-pair fallback used by the Lean reference scheduler. - _ => DIRECT_RAM_BYTES, - } -} - -/// Build the claim-bearing statement at every aggregate slot. This is the -/// shared source of truth for proving and manifest-bound verification: the -/// verifier must not reconstruct the same DAG independently in Lean. -pub(super) fn build_statement_specs( - prepared: &PreparedRun, - structural_above: usize, -) -> Result, String> { - let shard_by_id: FxHashMap = prepared - .shards - .iter() - .enumerate() - .map(|(index, shard)| (shard.original_id, index)) - .collect(); - let mut ops = Vec::new(); - build_plan(&prepared.tree, &shard_by_id, &mut ops)?; - let mut specs: Vec = Vec::with_capacity(ops.len()); - for op in ops { - match op { - PlanOp::Leaf(shard) => { - let prepared_shard = &prepared.shards[shard]; - specs.push(StatementSpec { - op, - statement: prepared_shard.statement.clone(), - subject_count: prepared_shard.statement.subjects.count, - structural: false, - }); - }, - PlanOp::Join(left_index, right_index) => { - let left = specs - .get(left_index) - .ok_or("aggregate plan has a missing left child")?; - let right = specs - .get(right_index) - .ok_or("aggregate plan has a missing right child")?; - let subject_count = - left.subject_count.saturating_add(right.subject_count); - let structural = subject_count > structural_above; - let statement = Statement::join( - &left.statement, - &right.statement, - structural, - &prepared.owner_by_address, - )?; - if statement.subjects.count != subject_count { - return Err("aggregate plan has inconsistent subject counts".into()); - } - specs.push(StatementSpec { op, statement, subject_count, structural }); - }, - } - } - Ok(specs) -} - -/// Proof-system identities and cache framing shared by every slot. -#[derive(Clone, Copy)] -pub(super) struct PlanIdentity<'a> { - pub(super) verify_idx: usize, - pub(super) aggr_idx: usize, - pub(super) aggr_vk: &'a [u8], - pub(super) allowed: &'a [u8], - pub(super) cache_fri_bytes: &'a [u8], -} - -/// Host folding choices; neither changes the statement's public meaning. -#[derive(Clone, Copy)] -pub(super) struct FoldPolicy { - pub(super) structural_above: usize, - pub(super) direct_joins: bool, -} - -pub(super) fn build_specs( - prepared: &PreparedRun, - identity: PlanIdentity<'_>, - policy: FoldPolicy, -) -> Result, String> { - let PlanIdentity { verify_idx, aggr_idx, aggr_vk, allowed, cache_fri_bytes } = - identity; - let FoldPolicy { structural_above, direct_joins } = policy; - let statement_specs = build_statement_specs(prepared, structural_above)?; - let raw_leaves = direct_joins && statement_specs.len() > 1; - let mut specs: Vec = Vec::with_capacity(statement_specs.len()); - for statement_spec in statement_specs { - let StatementSpec { op, statement, subject_count, structural } = - statement_spec; - match op { - PlanOp::Leaf(_) => { - let kind = if raw_leaves { ChildKind::Ixvm } else { ChildKind::Aggr }; - let shape = (!raw_leaves).then_some(shape_code(ChildKind::Ixvm, None)); - let outer_claim = if raw_leaves { - inner_claim(verify_idx, &statement.claim_bytes) - } else { - aggregate_outer_claim(aggr_idx, allowed, &statement.claim_bytes) - }; - let key = cache_key(aggr_vk, cache_fri_bytes, &outer_claim); - specs.push(SlotSpec { - op, - statement, - subject_count, - structural, - kind, - shape, - outer_claim, - cache_key: key, - ram_bytes: shape.map_or(RAW_SHARD_RAM_BYTES, |value| { - shape_ram_bytes(value, subject_count) - }), - }); - }, - PlanOp::Join(left_index, right_index) => { - let left = specs - .get(left_index) - .ok_or("aggregate plan has a missing left child")?; - let right = specs - .get(right_index) - .ok_or("aggregate plan has a missing right child")?; - let shape = if structural { - structural_shape_code(left.kind, right.kind) - } else { - shape_code(left.kind, Some(right.kind)) - }; - let outer_claim = - aggregate_outer_claim(aggr_idx, allowed, &statement.claim_bytes); - let key = cache_key(aggr_vk, cache_fri_bytes, &outer_claim); - specs.push(SlotSpec { - op, - statement, - subject_count, - structural, - kind: ChildKind::Aggr, - shape: Some(shape), - outer_claim, - cache_key: key, - ram_bytes: shape_ram_bytes(shape, subject_count), - }); - }, - } - } - Ok(specs) -} - -#[derive(Debug, PartialEq, Eq)] -pub(super) struct ReplayPlan { - pub(super) children: Vec, - pub(super) needs_input_proofs: bool, -} - -pub(super) fn plan_replay( - specs: &[SlotSpec], - target: usize, -) -> Result { - let spec = specs.get(target).ok_or_else(|| { - format!( - "--reprove-slot {target} is out of range; the plan has slots 0..{}", - specs.len().saturating_sub(1) - ) - })?; - if spec.kind == ChildKind::Ixvm { - return Err(format!( - "--reprove-slot {target} selects a raw IxVM leaf, not a Stage 2 proof" - )); - } - let children = match spec.op { - PlanOp::Leaf(_) => Vec::new(), - PlanOp::Join(left, right) => vec![left, right], - }; - let needs_input_proofs = children.is_empty() - || 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/prepare.rs b/crates/ffi/src/aiur/aggregate/prepare.rs deleted file mode 100644 index 0ad6827f0..000000000 --- a/crates/ffi/src/aiur/aggregate/prepare.rs +++ /dev/null @@ -1,289 +0,0 @@ -//! Aggregation prepare. - -use super::statement::{CanonicalTree, ShardSet, Statement, SubjectTree}; -use ix_common::address::Address; -use ixon::shard::{AggNode, ShardManifest}; -use ixon::{ - Constant, ConstantInfo, merkle::merkle_root_canonical_sorted, - shard_claim::walk_edges, -}; -use rayon::prelude::*; -use rustc_hash::{FxHashMap, FxHashSet}; -use std::sync::Arc; - -#[derive(Debug)] -pub(super) struct PreparedShard { - pub(super) original_id: u32, - pub(super) statement: Arc, -} - -pub(super) struct PreparedRun { - /// The context every statement of the run is relative to: the environment's - /// role binding under this specification set. - pub(super) ctx: ixon::ClaimContext, - pub(super) shards: Vec, - pub(super) owner_by_address: FxHashMap, - pub(super) tree: AggNode, - pub(super) env_root: Address, - pub(super) env_count: usize, - pub(super) expected_shards: ShardSet, -} - -pub(super) fn projection_block(addr: &Address, constant: &Constant) -> Address { - match &constant.info { - ConstantInfo::IPrj(p) => p.block.clone(), - ConstantInfo::CPrj(p) => p.block.clone(), - ConstantInfo::RPrj(p) => p.block.clone(), - ConstantInfo::DPrj(p) => p.block.clone(), - _ => addr.clone(), - } -} - -/// The run's claims, each validating its binding. -pub(super) fn prepare_run( - env: &ixon::Env, - manifest: &ShardManifest, -) -> Result { - prepare_run_with(env, manifest, false) -} - -/// The run's claims, each assuming its binding meets the specifications -/// when `assume_binding` (to be discharged once at the root) and validating -/// it otherwise. -pub(super) fn prepare_run_with( - env: &ixon::Env, - manifest: &ShardManifest, - assume_binding: bool, -) -> Result { - if manifest.shards.is_empty() { - return Err("manifest contains no shards".into()); - } - let mut ctx = ixon::ClaimContext::for_env(env)?; - ctx.binding_assumed = assume_binding; - - let mut block_to_shard = FxHashMap::default(); - let mut id_to_index = FxHashMap::default(); - for (index, shard) in manifest.shards.iter().enumerate() { - if id_to_index.insert(shard.id, index).is_some() { - return Err(format!("manifest repeats shard id {}", shard.id)); - } - for block in &shard.blocks { - if let Some(previous) = block_to_shard.insert(block.clone(), index) { - return Err(format!( - "manifest block {} is owned by shards {} and {}", - block.hex(), - manifest.shards[previous].id, - shard.id - )); - } - } - } - - // DashMap iteration is deliberately unordered. Sort first so indexed Rayon - // collection and the later sequential fold retain deterministic errors and - // output independent of worker scheduling. - let mut all_addresses: Vec
= - env.consts.iter().map(|entry| entry.key().clone()).collect(); - all_addresses.par_sort_unstable(); - - // Materializing an .ixe constant parses its serialized representation, and - // lazy constants intentionally do not cache that representation. Classify - // ownership and extract the kernel walk edges in the same parallel pass so - // frontier construction does not parse all constants a second time. - let classified_results: Vec), String>> = - all_addresses - .par_iter() - .map(|addr| { - let constant = env - .try_get_const(addr) - .ok_or_else(|| { - format!("environment constant {} disappeared", addr.hex()) - })? - .map_err(|error| { - format!("cannot parse environment constant {}: {error}", addr.hex()) - })?; - let block = projection_block(addr, &constant); - let owner = block_to_shard.get(&block).copied().ok_or_else(|| { - format!( - "environment constant {} (block {}) has no owning manifest shard", - addr.hex(), - block.hex() - ) - })?; - let mut edges = Vec::new(); - walk_edges(&constant, &mut edges); - Ok((owner, edges)) - }) - .collect(); - // Resolve failures in canonical-address order rather than whichever Rayon - // worker happens to finish first. - let classified: Vec<(usize, Vec
)> = - classified_results.into_iter().collect::>()?; - - let mut owned = vec![Vec::new(); manifest.shards.len()]; - let mut walk_edges_by_shard = vec![Vec::new(); manifest.shards.len()]; - let mut owners_old = Vec::with_capacity(all_addresses.len()); - for (addr, (owner, edges)) in all_addresses.iter().zip(classified) { - owned[owner].push(addr.clone()); - walk_edges_by_shard[owner].extend(edges); - owners_old.push(owner); - } - if owners_old.len() != env.consts.len() { - return Err( - "manifest ownership did not cover every environment constant".into(), - ); - } - - let retained_old: Vec = owned - .iter() - .enumerate() - .filter_map(|(index, addresses)| (!addresses.is_empty()).then_some(index)) - .collect(); - if retained_old.is_empty() { - return Err("manifest has no shard owning an environment constant".into()); - } - let retained_ids: FxHashSet = - retained_old.iter().map(|index| manifest.shards[*index].id).collect(); - let source_tree = manifest.tree.clone().unwrap_or_else(|| { - let ids: Vec = manifest.shards.iter().map(|shard| shard.id).collect(); - AggNode::balanced(&ids).expect("a nonempty id list has a balanced tree") - }); - let tree = source_tree - .prune(&|id| retained_ids.contains(&id)) - .ok_or("pruning removed every aggregate-tree leaf")?; - - let mut old_to_retained = FxHashMap::default(); - for (retained, old) in retained_old.iter().copied().enumerate() { - old_to_retained.insert(old, retained); - } - let owner_by_address: FxHashMap = all_addresses - .iter() - .cloned() - .zip(owners_old) - .map(|(address, old)| (address, old_to_retained[&old])) - .collect(); - - let shard_inputs: Vec<(usize, u32, Vec
, Vec
)> = - retained_old - .iter() - .copied() - .enumerate() - .map(|(retained, old)| { - ( - retained, - manifest.shards[old].id, - std::mem::take(&mut owned[old]), - std::mem::take(&mut walk_edges_by_shard[old]), - ) - }) - .collect(); - let shard_results: Vec> = shard_inputs - .into_par_iter() - .map(|(retained, original_id, subjects, candidates)| { - // Every environment constant has exactly one retained owner. Thus this - // is the thin-frontier predicate without rebuilding a subject hash set: - // retain present walk edges owned by another shard, exclude local and - // absent (including blob-sentinel) edges. - let mut frontier_set = FxHashSet::default(); - for candidate in candidates { - if owner_by_address - .get(&candidate) - .is_some_and(|owner| *owner != retained) - { - frontier_set.insert(candidate); - } - } - let mut frontier: Vec
= frontier_set.into_iter().collect(); - frontier.sort_unstable(); - let subject_tree = SubjectTree::canonical( - subjects, - ShardSet::singleton(retained, retained_old.len()), - )?; - let assumptions = CanonicalTree::from_sorted(frontier)?; - let statement = Statement::new(ctx.clone(), subject_tree, assumptions); - Ok(PreparedShard { original_id, statement }) - }) - .collect(); - // Retained-shard order is stable because Vec's parallel iterator is indexed; - // resolve any errors in that same order for deterministic diagnostics. - let shards = shard_results.into_iter().collect::, _>>()?; - - let env_root = merkle_root_canonical_sorted(&all_addresses) - .ok_or("cannot aggregate an empty environment")?; - let expected_shards = ShardSet( - (0..retained_old.len().div_ceil(64)) - .map(|word| { - let remaining = retained_old.len().saturating_sub(word * 64); - if remaining >= 64 { u64::MAX } else { (1u64 << remaining) - 1 } - }) - .collect(), - ); - - Ok(PreparedRun { - ctx, - shards, - owner_by_address, - tree, - env_root, - env_count: all_addresses.len(), - expected_shards, - }) -} - -/// Check the semantic certificate attached to the root statement independently -/// of any proof: it is relative to the run's context, every environment -/// constant occurs exactly once, every retained -/// shard contributes, the canonicalized subject root is the environment root, -/// and no assumption survives. -pub(super) fn validate_root_statement( - prepared: &PreparedRun, - root: &Statement, -) -> Result<(), String> { - if root.ctx != prepared.ctx { - return Err("aggregate root is relative to another claim context".into()); - } - if root.subjects.count != prepared.env_count { - return Err(format!( - "aggregate root has {} subjects, environment has {}", - root.subjects.count, prepared.env_count - )); - } - if root.subjects.shards != prepared.expected_shards { - return Err("aggregate root does not contain every retained shard".into()); - } - let mut root_leaves = Vec::with_capacity(prepared.env_count); - root.subjects.collect_leaves(&mut root_leaves); - if root_leaves.len() != prepared.env_count { - return Err(format!( - "aggregate root tree contains {} subject occurrences, environment has {} constants", - root_leaves.len(), - prepared.env_count - )); - } - root_leaves.sort_unstable(); - if root_leaves.windows(2).any(|pair| pair[0] == pair[1]) { - return Err("aggregate root contains a duplicate subject".into()); - } - if let Some(foreign) = root_leaves - .iter() - .find(|addr| !prepared.owner_by_address.contains_key(*addr)) - { - return Err(format!( - "aggregate root contains foreign subject {}", - foreign.hex() - )); - } - let canonical_root = merkle_root_canonical_sorted(&root_leaves) - .ok_or("aggregate root has no subject leaves")?; - if canonical_root != prepared.env_root { - return Err(format!( - "aggregate root subjects canonicalize to {}, not environment root {}", - canonical_root.hex(), - prepared.env_root.hex() - )); - } - if root.assumptions.is_some() { - return Err("aggregate root retains undischarged assumptions".into()); - } - Ok(()) -} diff --git a/crates/ffi/src/aiur/aggregate/protocol.rs b/crates/ffi/src/aiur/aggregate/protocol.rs deleted file mode 100644 index ad310caa9..000000000 --- a/crates/ffi/src/aiur/aggregate/protocol.rs +++ /dev/null @@ -1,119 +0,0 @@ -//! Aggregation protocol. - -use aiur::{G, function_channel}; -use ix_common::address::Address; -use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; - -pub(super) const CACHE_VERSION: u64 = 2; - -/// The range-sum recursion shapes of `ix_aggr` (`Aggr.rangeLeafShape` and -/// friends in `Ix/Aggr/Protocol.lean`). -pub(super) const RANGE_LEAF_SHAPE: u8 = 10; -pub(super) const RANGE_JOIN_SHAPE: u8 = 11; -pub(super) const RANGE_ROOT_SHAPE: u8 = 12; - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub(super) enum ChildKind { - Ixvm, - Aggr, -} - -impl ChildKind { - pub(super) const fn code(self) -> u8 { - match self { - Self::Ixvm => 0, - Self::Aggr => 1, - } - } -} - -pub(super) fn packed_digest(bytes: &[u8]) -> Vec { - let digest = blake3::hash(bytes); - digest - .as_bytes() - .as_chunks::<4>() - .0 - .iter() - .map(|word| G::from_u32(u32::from_le_bytes(*word))) - .collect() -} - -pub(super) fn build_claim(fun_idx: usize, input: &[G], output: &[G]) -> Vec { - let mut claim = Vec::with_capacity(2 + input.len() + output.len()); - claim.push(function_channel()); - claim.push(G::from_usize(fun_idx)); - claim.extend_from_slice(input); - claim.extend_from_slice(output); - claim -} - -pub(crate) fn serialize_claims(claims: &[&[G]]) -> Vec { - let mut out = Vec::new(); - out.extend_from_slice(&(claims.len() as u64).to_le_bytes()); - for claim in claims { - out.extend_from_slice(&(claim.len() as u64).to_le_bytes()); - for value in *claim { - out.extend_from_slice(&value.as_canonical_u64().to_le_bytes()); - } - } - out -} - -pub(super) fn inner_claim(verify_idx: usize, claim_bytes: &[u8]) -> Vec { - build_claim(verify_idx, &packed_digest(claim_bytes), &[]) -} - -pub(crate) fn aggregate_outer_claim( - aggr_idx: usize, - allowed: &[u8], - claim_bytes: &[u8], -) -> Vec { - let mut input = packed_digest(allowed); - input.extend(packed_digest(claim_bytes)); - build_claim(aggr_idx, &input, &[]) -} - -pub(super) fn allowed_blob( - ixvm_vk: &[u8], - verify_idx: usize, - aggr_vk: &[u8], - aggr_idx: usize, -) -> Vec { - let mut out = Vec::with_capacity(80); - out.extend_from_slice(blake3::hash(ixvm_vk).as_bytes()); - out.extend_from_slice(&(verify_idx as u64).to_le_bytes()); - out.extend_from_slice(blake3::hash(aggr_vk).as_bytes()); - out.extend_from_slice(&(aggr_idx as u64).to_le_bytes()); - out -} - -pub(super) fn cache_key( - aggr_vk: &[u8], - cache_fri_bytes: &[u8], - outer_claim: &[G], -) -> Address { - let mut bytes = Vec::with_capacity(8 + 32 + cache_fri_bytes.len() + 256); - bytes.extend_from_slice(&CACHE_VERSION.to_le_bytes()); - bytes.extend_from_slice(blake3::hash(aggr_vk).as_bytes()); - bytes.extend_from_slice(cache_fri_bytes); - bytes.extend(serialize_claims(&[outer_claim])); - Address::hash(&bytes) -} - -pub(super) fn shape_code(left: ChildKind, right: Option) -> u8 { - match right { - None => left.code(), - Some(right) => 2 + 2 * left.code() + right.code(), - } -} - -pub(super) fn structural_shape_code(left: ChildKind, right: ChildKind) -> u8 { - 6 + 2 * left.code() + right.code() -} - -/// The binding-discharge shape for a child of kind `kind` -/// (`Aggr.dischargeShapeCode`): `13` for an IxVM child, `14` for an -/// `ix_aggr` child, each with an IxVM proof of the `Binding` claim. -pub(super) fn discharge_shape_code(kind: ChildKind) -> u8 { - 13 + kind.code() -} diff --git a/crates/ffi/src/aiur/aggregate/prove.rs b/crates/ffi/src/aiur/aggregate/prove.rs deleted file mode 100644 index 19f55def9..000000000 --- a/crates/ffi/src/aiur/aggregate/prove.rs +++ /dev/null @@ -1,1198 +0,0 @@ -//! Aggregation prove. - -use super::{ - format_gib, format_mib, panic_text, - plan::{PlanOp, ReplayPlan, SlotSpec}, - prepare::PreparedShard, - protocol::{ - ChildKind, RANGE_JOIN_SHAPE, RANGE_LEAF_SHAPE, RANGE_ROOT_SHAPE, - discharge_shape_code, inner_claim, packed_digest, serialize_claims, - shape_code, - }, - statement::{CanonicalTree, Statement, merge_optional_sets}, - store::{load_cached, persist_cached, wrapper_address}, -}; -use aiur::{ - G, - execute::IOBuffer, - range::{ - preamble_bytes, proofs_slice_bytes, range_residual, range_statement, - }, - synthesis::{AiurProof, AiurSystem, GatedProve, PreparedProve}, -}; -use ix_common::address::Address; -use ixon::{ - ClaimContext, Proof as IxonProof, merkle::MerklePath, proof::Claim, -}; -use ixvm_codegen::aiur_ix_aggr_runner::{ - AggrAdvice, AggrPath, AggrPreimage, AggrTree, aggr_io_buffer, execute_ix_aggr, -}; -use multi_stark::types::ExtVal; -use rustc_hash::FxHashMap; -use std::{ - path::Path, - sync::{Arc, mpsc}, - thread, - time::Instant, -}; - -pub(super) struct Slot { - pub(super) kind: ChildKind, - pub(super) statement: Arc, - pub(super) outer_claim: Vec, - pub(super) proof: AiurProof, - pub(super) proof_address: Option
, - pub(super) claims_bytes: Vec, -} - -#[derive(Clone, Copy)] -pub(super) struct ProveContext<'a> { - pub(super) specs: &'a [SlotSpec], - pub(super) prepared: &'a [PreparedShard], - /// One entry per manifest shard; `None` for shards outside the run's - /// selection (a subtree run) or when a replay needs no input proofs. - pub(super) proofs: Option<&'a [Option>]>, - pub(super) owner_by_address: &'a FxHashMap, - pub(super) ixvm_system: &'a AiurSystem, - pub(super) aggr_system: &'a AiurSystem, - pub(super) ixvm_vk: &'a [u8], - pub(super) aggr_vk: &'a [u8], - pub(super) allowed: &'a [u8], - pub(super) verify_idx: usize, - pub(super) aggr_idx: usize, - pub(super) store_dir: &'a Path, - pub(super) cache_dir: Option<&'a Path>, - pub(super) cache_read_dir: Option<&'a Path>, - pub(super) reprove_slot: Option, - pub(super) write_outputs: bool, - /// The prover budget of one slot when its execution is proven as trace - /// shards; `None` proves every slot unsharded and unbudgeted. - pub(super) wrap_budget: Option, - /// Wrap a shard proof of more than this many trace shards as a range-sum - /// tree whose leaves verify at most this many shards each; 0 always wraps - /// the whole batch in one proof. - pub(super) range_width: usize, - /// How many range-tree nodes prove at once, each under `wrap_budget`. - pub(super) range_jobs: usize, - /// An IxVM proof of the `Binding` claim for the run's context. When - /// present, the run's claims assume their binding and the root discharges - /// that condition once ([`discharge_root`]). - pub(super) binding_proof: Option<&'a IxonProof>, -} - -pub(super) struct OwnedTreeAdvice { - pub(super) root: [u8; 32], - pub(super) bytes: Vec, -} - -pub(super) fn push_canonical_tree( - out: &mut Vec, - tree: &CanonicalTree, -) { - out.push(OwnedTreeAdvice { - root: *tree.root.as_bytes(), - bytes: tree.serialized().to_vec(), - }); -} - -pub(super) fn path_payload( - path: Option<&MerklePath>, -) -> Result, String> { - let Some(path) = path else { - return Ok(vec![0]); - }; - let length = u8::try_from(path.len()).map_err(|_overflow| { - format!("aggregate Merkle path has {} steps", path.len()) - })?; - if length > 64 { - return Err(format!( - "aggregate Merkle path has {length} steps (maximum 64)" - )); - } - let mut out = Vec::with_capacity(2 + path.len() * 33); - out.extend([1, length]); - for (sibling, is_left) in path { - out.push(if *is_left { 0 } else { 1 }); - out.extend_from_slice(sibling.as_bytes()); - } - Ok(out) -} - -pub(super) fn tree_advice( - left: &Statement, - right: &Statement, - output: &Statement, - structural: bool, -) -> Result, String> { - let mut trees = Vec::new(); - if !structural { - let left_subjects = left - .subjects - .canonical_tree() - .ok_or("flat join has structural left subjects")?; - push_canonical_tree(&mut trees, left_subjects); - } - if let Some(tree) = &left.assumptions { - push_canonical_tree(&mut trees, tree); - } - if !structural { - let right_subjects = right - .subjects - .canonical_tree() - .ok_or("flat join has structural right subjects")?; - push_canonical_tree(&mut trees, right_subjects); - } - if let Some(tree) = &right.assumptions { - push_canonical_tree(&mut trees, tree); - } - if !structural { - let output_subjects = output - .subjects - .canonical_tree() - .ok_or("flat join produced structural subjects")?; - push_canonical_tree(&mut trees, output_subjects); - } - if let Some(tree) = &output.assumptions { - push_canonical_tree(&mut trees, tree); - } - Ok(trees) -} - -pub(super) fn structural_path_advice( - left: &Statement, - right: &Statement, - output: &Statement, - owner_by_address: &FxHashMap, -) -> Result)>, String> { - let candidates = merge_optional_sets( - left.assumptions.as_deref(), - right.assumptions.as_deref(), - ); - let mut paths = Vec::with_capacity(candidates.len()); - for candidate in candidates { - let owner = owner_by_address.get(&candidate).ok_or_else(|| { - format!("aggregate assumption {} has no owning shard", candidate.hex()) - })?; - let path = output.subjects.merkle_proof(&candidate, *owner); - paths.push((candidate, path_payload(path.as_ref())?)); - } - Ok(paths) -} - -pub(super) fn assumption_count(statement: &Statement) -> usize { - statement.assumptions.as_ref().map_or(0, |tree| tree.leaves.len()) -} - -/// A slot executed and planned, waiting for the prover. -pub(super) struct PreparedAggregate { - slot_index: usize, - prepared: PreparedProve, - started: Instant, - proving_started: Instant, - /// The replayed slot's advice diagnostics, printed once it is proven. - replay: Option, -} - -/// What preparing a slot yields: its proof straight from the cache, or its -/// execution waiting for the prover. -pub(super) enum Staged { - Cached(Box, Address), - Prepared(Box), -} - -/// The execution half of a slot's proof: the cache probe, both children's -/// advice, the trees and paths, then the `ix_aggr` execution planned within -/// the slot budget. CPU work only, so one slot can prepare while another -/// proves. -fn prepare_aggregate( - ctx: ProveContext<'_>, - spec: &SlotSpec, - left: &Slot, - right: Option<&Slot>, - slot_index: usize, -) -> Result { - let replaying = ctx.reprove_slot == Some(slot_index); - if !replaying { - if let Some((proof, address)) = load_cached( - ctx.aggr_system, - ctx.store_dir, - ctx.cache_read_dir, - slot_index, - spec, - ) { - return Ok(Staged::Cached(Box::new(proof), address)); - } - } else { - eprintln!( - "[aggregate] replay slot {slot_index}: bypassing its cache entry" - ); - } - let started = Instant::now(); - - let left_system = match left.kind { - ChildKind::Ixvm => ctx.ixvm_system, - ChildKind::Aggr => ctx.aggr_system, - }; - let left_advice = left_system - .proof_to_advice_bytes(&left.outer_claim, &left.proof) - .map_err(|error| format!("left child proof advice failed: {error:?}"))?; - let right_advice = if let Some(right) = right { - let system = match right.kind { - ChildKind::Ixvm => ctx.ixvm_system, - ChildKind::Aggr => ctx.aggr_system, - }; - system - .proof_to_advice_bytes(&right.outer_claim, &right.proof) - .map_err(|error| format!("right child proof advice failed: {error:?}"))? - } else { - Vec::new() - }; - - let mut preimage_storage = Vec::new(); - if let Some(right) = right { - preimage_storage.push(( - *blake3::hash(&left.statement.claim_bytes).as_bytes(), - left.statement.claim_bytes.as_slice(), - )); - preimage_storage.push(( - *blake3::hash(&right.statement.claim_bytes).as_bytes(), - right.statement.claim_bytes.as_slice(), - )); - } - let preimages: Vec> = preimage_storage - .iter() - .map(|(digest, bytes)| AggrPreimage { digest: *digest, bytes }) - .collect(); - - let (tree_storage, path_storage) = if let Some(right) = right { - ( - tree_advice( - &left.statement, - &right.statement, - &spec.statement, - spec.structural, - )?, - if spec.structural { - structural_path_advice( - &left.statement, - &right.statement, - &spec.statement, - ctx.owner_by_address, - )? - } else { - Vec::new() - }, - ) - } else { - (Vec::new(), Vec::new()) - }; - let trees: Vec> = tree_storage - .iter() - .map(|tree| AggrTree { root: tree.root, bytes: &tree.bytes }) - .collect(); - let paths: Vec> = path_storage - .iter() - .map(|(candidate, bytes)| AggrPath { - candidate: *candidate.as_bytes(), - bytes, - }) - .collect(); - let empty = Vec::new(); - let right_claims = - right.map_or(empty.as_slice(), |slot| slot.claims_bytes.as_slice()); - let shape = spec.shape.ok_or("aggregate proof slot has no shape")?; - let mut io = aggr_io_buffer(&AggrAdvice { - shape, - proof_advice: [&left_advice, &right_advice], - ixvm_vk: ctx.ixvm_vk, - self_vk: ctx.aggr_vk, - child_claims: [&left.claims_bytes, right_claims], - output_claim: &spec.statement.claim_bytes, - allowed: ctx.allowed, - preimages: &preimages, - trees: &trees, - paths: &paths, - }); - let mut public_input = packed_digest(ctx.allowed); - public_input.extend(packed_digest(&spec.statement.claim_bytes)); - let proving_started = Instant::now(); - let prepared = prepare_aggr_io( - ctx, - &mut io, - &public_input, - &format!("slot {slot_index}"), - )?; - let replay = replaying.then(|| { - let tree_bytes: usize = - tree_storage.iter().map(|tree| tree.bytes.len()).sum(); - let path_bytes: usize = - path_storage.iter().map(|(_, path)| path.len()).sum(); - let preimage_bytes: usize = - preimage_storage.iter().map(|(_, bytes)| bytes.len()).sum(); - let right_assumptions = - right.map_or(0, |slot| assumption_count(&slot.statement)); - format!( - "[aggregate] replay slot {slot_index}: shape {shape}, {} subjects, assumptions {}/{}/{}, proof advice {}+{} MiB, {} trees/{} MiB, {} paths/{} MiB, preimages {} MiB, query-record peak {} GiB ({} bytes)", - spec.subject_count, - assumption_count(&left.statement), - right_assumptions, - assumption_count(&spec.statement), - format_mib(left_advice.len()), - format_mib(right_advice.len()), - tree_storage.len(), - format_mib(tree_bytes), - path_storage.len(), - format_mib(path_bytes), - format_mib(preimage_bytes), - format_gib(prepared.peak), - prepared.peak, - ) - }); - Ok(Staged::Prepared(Box::new(PreparedAggregate { - slot_index, - prepared, - started, - proving_started, - replay, - }))) -} - -/// The proving half of a slot's proof: the STARK, the outer-claim check and -/// persistence. -fn finish_aggregate( - ctx: ProveContext<'_>, - staged: Staged, -) -> Result<(AiurProof, Option
), String> { - let PreparedAggregate { - slot_index, - prepared, - started, - proving_started, - replay, - } = match staged { - Staged::Cached(proof, address) => return Ok((*proof, Some(address))), - Staged::Prepared(prepared) => *prepared, - }; - let spec = ctx.specs.get(slot_index).ok_or("missing aggregate slot spec")?; - let (outer_claim, proof, _) = finish_aggr_io(ctx, prepared); - let proved_at = Instant::now(); - if outer_claim != spec.outer_claim { - return Err("aggregate prover returned an unexpected outer claim".into()); - } - let address = persist_cached( - ctx.store_dir, - ctx.cache_dir, - ctx.write_outputs, - slot_index, - spec, - &proof, - )?; - if let Some(line) = replay { - eprintln!("{line}"); - eprintln!( - "[aggregate] replay slot {slot_index}: advice {:.3}s, execute+prove {:.3}s, persistence {:.3}s, total {:.3}s", - (proving_started - started).as_secs_f64(), - (proved_at - proving_started).as_secs_f64(), - proved_at.elapsed().as_secs_f64(), - started.elapsed().as_secs_f64(), - ); - } - Ok((proof, address)) -} - -/// Execute and prove one `ix_aggr` invocation over its advice buffer, as -/// trace shards within the slot budget when the run has one. -fn prove_aggr_io( - ctx: ProveContext<'_>, - io: &mut IOBuffer, - public_input: &[G], - label: &str, -) -> Result<(Vec, AiurProof, usize), String> { - let prepared = prepare_aggr_io(ctx, io, public_input, label)?; - Ok(finish_aggr_io(ctx, prepared)) -} - -/// The execution half of [`prove_aggr_io`]: executes the invocation, gates -/// and plans it within the slot budget, and returns what -/// [`finish_aggr_io`] proves from, so one node can execute while another -/// proves. -fn prepare_aggr_io( - ctx: ProveContext<'_>, - io: &mut IOBuffer, - public_input: &[G], - label: &str, -) -> Result { - match ctx.aggr_system.prepare_ixvm_within_budget( - ctx.aggr_idx, - public_input, - io, - execute_ix_aggr, - ctx.wrap_budget, - ctx.wrap_budget.is_some(), - None, - ) { - Ok(prepared) => Ok(prepared), - Err(GatedProve::Split { peak, .. }) => Err( - format!( - "{OVER_SLOT_BUDGET}{label}: no trace-shard count fits the {} B budget \ - (whole-execution peak {peak} B) — raise --max-ram", - ctx.wrap_budget.unwrap_or(0) - ) - .into(), - ), - Err(GatedProve::Failed( - aiur::execute::ExecError::RecordBudgetExceeded { bytes, cap }, - )) => Err(PrepareFailure::OverRecordCap { bytes, cap }), - Err(GatedProve::Failed( - aiur::execute::ExecError::RecordMemoryContention, - )) => Err(PrepareFailure::MemoryContention), - Err(GatedProve::Failed(error)) => { - Err(format!("{label}: execution failed: {error}").into()) - }, - Err(_) => { - Err(format!("{label}: aggregate prove did not produce a proof").into()) - }, - } -} - -/// Why a node's preparation failed: its execution reached the record cap -/// it ran under (the thread-local cap of `aiur::execute`), which a -/// scheduler can answer by rerunning it alone, or anything else. -pub(super) enum PrepareFailure { - OverRecordCap { bytes: usize, cap: usize }, - MemoryContention, - Other(String), -} - -impl From for PrepareFailure { - fn from(message: String) -> Self { - Self::Other(message) - } -} - -impl From<&str> for PrepareFailure { - fn from(message: &str) -> Self { - Self::Other(message.to_string()) - } -} - -impl From for String { - fn from(failure: PrepareFailure) -> Self { - match failure { - PrepareFailure::OverRecordCap { bytes, cap } => { - format!("record reached {bytes} B, over the {cap} B record cap") - }, - PrepareFailure::MemoryContention => { - "record cancelled to resolve memory contention".into() - }, - PrepareFailure::Other(message) => message, - } - } -} - -/// Prefix of the error [`prepare_aggr_io`] returns when a node's execution -/// does not fit the slot budget, so callers can tell that outcome apart. -const OVER_SLOT_BUDGET: &str = "over the slot budget: "; - -/// The proving half of [`prove_aggr_io`]. -fn finish_aggr_io( - ctx: ProveContext<'_>, - prepared: PreparedProve, -) -> (Vec, AiurProof, usize) { - ctx.aggr_system.prove_prepared(prepared) -} - -/// One proven node of a range-sum tree: shards `[lo, hi)` of the batch and -/// their residual sum, stated by `statement` (`aiur::range::range_statement`). -struct RangeNode { - lo: usize, - hi: usize, - residual: ExtVal, - statement: Vec, - outer_claim: Vec, - proof: AiurProof, -} - -/// A range-tree node executed and planned, waiting for the prover. -struct PreparedNode { - lo: usize, - hi: usize, - residual: ExtVal, - statement: Vec, - kind: &'static str, - started: Instant, - prepared: PreparedProve, -} - -/// Prove every item of one tree level. With one job the level is a -/// pipeline: a producer thread executes and plans item `k + 1` while this -/// thread proves item `k`, at most one node ahead (a rendezvous channel), so -/// the prover never waits for an execution it could have overlapped. With -/// more jobs, that many items execute and prove at once. -fn prove_range_level( - items: Vec, - jobs: usize, - prepare: &P, - finish: &F, -) -> Result, String> -where - T: Send, - P: Fn(T) -> Result + Sync, - F: Fn(PreparedNode) -> Result + Sync, -{ - if jobs <= 1 { - let span = tracing::Span::current(); - return thread::scope(|scope| { - let (sender, receiver) = - mpsc::sync_channel::>(0); - let producer = scope.spawn(move || { - let _g = span.entered(); - for item in items { - let prepared = prepare(item); - let failed = prepared.is_err(); - if sender.send(prepared).is_err() || failed { - break; - } - } - }); - let mut nodes = Vec::new(); - let mut outcome = Ok(()); - for prepared in receiver { - match prepared.and_then(finish) { - Ok(node) => nodes.push(node), - Err(error) => { - outcome = Err(error); - break; - }, - } - } - // Dropping the receiver stops the producer at its next send. - producer.join().map_err(|payload| { - format!("range node preparation panicked: {}", panic_text(&payload)) - })?; - outcome.map(|()| nodes) - }); - } - let mut nodes = Vec::with_capacity(items.len()); - let mut pending = items.into_iter().peekable(); - while pending.peek().is_some() { - let batch: Vec = pending.by_ref().take(jobs).collect(); - let proven: Vec> = thread::scope(|scope| { - let handles: Vec<_> = batch - .into_iter() - .map(|item| scope.spawn(move || prepare(item).and_then(finish))) - .collect(); - handles - .into_iter() - .map(|handle| { - handle.join().unwrap_or_else(|payload| { - Err(format!("range node panicked: {}", panic_text(&payload))) - }) - }) - .collect() - }); - for node in proven { - nodes.push(node?); - } - } - Ok(nodes) -} - -/// Wrap a shard proof of many trace shards as a range-sum tree: leaves of at -/// most `range_width` shards, joins of adjacent ranges, and a root whose -/// statement is exactly the wrap's, so the slot's cache entry and every -/// consumer are unchanged. -fn prove_range_tree( - ctx: ProveContext<'_>, - spec: &SlotSpec, - batch: &AiurProof, - slot_index: usize, -) -> Result<(AiurProof, Option
), String> { - if ctx.reprove_slot != Some(slot_index) - && let Some((proof, address)) = load_cached( - ctx.aggr_system, - ctx.store_dir, - ctx.cache_read_dir, - slot_index, - spec, - ) - { - return Ok((proof, Some(address))); - } - let started = Instant::now(); - let shards = batch.preamble.headers.len(); - // No requested width: two leaves per node slot, so a slot's pipeline - // always has a next leaf to execute while it proves one, and each leaf - // is as large as that allows; a leaf over the slot budget fails its - // gate, and a derived width is halved until the leaves fit. - let mut width = if ctx.range_width > 0 { - ctx.range_width - } else { - shards.div_ceil(2 * ctx.range_jobs.max(1)).max(1) - }; - let preamble = preamble_bytes(batch)?; - let digest = *blake3::hash(&preamble).as_bytes(); - let leaves_of = |width: usize| -> Vec<(usize, usize)> { - (0..shards) - .step_by(width) - .map(|lo| (lo, (lo + width).min(shards))) - .collect() - }; - eprintln!( - "[aggregate] slot {slot_index}: range tree over {shards} shards: {} leaves of at most {width} shards, {} at a time", - leaves_of(width).len(), - ctx.range_jobs - ); - let self_claims = |node: &RangeNode| serialize_claims(&[&node.outer_claim]); - let child_advice = |node: &RangeNode| -> Result, String> { - ctx - .aggr_system - .proof_to_advice_bytes(&node.outer_claim, &node.proof) - .map_err(|error| { - format!( - "slot {slot_index}: range node {}..{} proof advice failed: {error}", - node.lo, node.hi - ) - }) - }; - let prepare_node = |shape: u8, - lo: usize, - hi: usize, - residual: ExtVal, - proof_advice: [&[u8]; 2], - child_claims: [&[u8]; 2], - preimages: &[AggrPreimage<'_>]| - -> Result { - let node_started = Instant::now(); - let statement = range_statement(&digest, lo, hi, residual); - let mut io = aggr_io_buffer(&AggrAdvice { - shape, - proof_advice, - ixvm_vk: ctx.ixvm_vk, - self_vk: ctx.aggr_vk, - child_claims, - output_claim: &statement, - allowed: ctx.allowed, - preimages, - trees: &[], - paths: &[], - }); - let mut public_input = packed_digest(ctx.allowed); - public_input.extend(packed_digest(&statement)); - let kind = if shape == RANGE_LEAF_SHAPE { "leaf" } else { "join" }; - let prepared = prepare_aggr_io( - ctx, - &mut io, - &public_input, - &format!("slot {slot_index} range {kind} {lo}..{hi}"), - )?; - eprintln!( - "[aggregate] slot {slot_index}: range {kind} {lo}..{hi} executed in {:.1}s", - node_started.elapsed().as_secs_f64() - ); - Ok(PreparedNode { - lo, - hi, - residual, - statement, - kind, - started: node_started, - prepared, - }) - }; - let finish_node = |node: PreparedNode| -> Result { - let PreparedNode { lo, hi, residual, statement, kind, started, prepared } = - node; - let (outer_claim, proof, peak) = finish_aggr_io(ctx, prepared); - eprintln!( - "[aggregate] slot {slot_index}: range {kind} {lo}..{hi} proven in {:.1}s (query-record peak {} GiB)", - started.elapsed().as_secs_f64(), - format_gib(peak) - ); - Ok(RangeNode { lo, hi, residual, statement, outer_claim, proof }) - }; - - let prove_leaves = |width: usize| { - prove_range_level( - leaves_of(width), - ctx.range_jobs, - &|(lo, hi)| { - let proofs = proofs_slice_bytes(batch, lo, hi)?; - prepare_node( - RANGE_LEAF_SHAPE, - lo, - hi, - range_residual(batch, lo, hi), - [&preamble, &proofs], - [&[], &[]], - &[], - ) - }, - &finish_node, - ) - }; - let mut nodes = loop { - match prove_leaves(width) { - Ok(nodes) => break nodes, - Err(error) - if ctx.range_width == 0 - && width > 1 - && error.starts_with(OVER_SLOT_BUDGET) => - { - width /= 2; - eprintln!( - "[aggregate] slot {slot_index}: a leaf did not fit the slot budget; retrying with leaves of at most {width} shards" - ); - }, - Err(error) => return Err(error), - } - }; - while nodes.len() > 1 { - let mut pairs = Vec::with_capacity(nodes.len().div_ceil(2)); - let mut carried = None; - let mut pending = nodes.into_iter(); - while let Some(left) = pending.next() { - match pending.next() { - Some(right) => pairs.push((left, right)), - None => carried = Some(left), - } - } - nodes = prove_range_level( - pairs, - ctx.range_jobs, - &|(left, right)| { - let advice = [child_advice(&left)?, child_advice(&right)?]; - let claims = [self_claims(&left), self_claims(&right)]; - let preimages = [ - AggrPreimage { - digest: *blake3::hash(&left.statement).as_bytes(), - bytes: &left.statement, - }, - AggrPreimage { - digest: *blake3::hash(&right.statement).as_bytes(), - bytes: &right.statement, - }, - ]; - prepare_node( - RANGE_JOIN_SHAPE, - left.lo, - right.hi, - left.residual + right.residual, - [&advice[0], &advice[1]], - [&claims[0], &claims[1]], - &preimages, - ) - }, - &finish_node, - )?; - // An unpaired last node joins at the next level, keeping ranges in - // shard order. - nodes.extend(carried); - } - let node = nodes.pop().ok_or("range tree has no root")?; - - let root_started = Instant::now(); - let advice = child_advice(&node)?; - let claims = self_claims(&node); - let preimages = [AggrPreimage { - digest: *blake3::hash(&node.statement).as_bytes(), - bytes: &node.statement, - }]; - let mut io = aggr_io_buffer(&AggrAdvice { - shape: RANGE_ROOT_SHAPE, - proof_advice: [&advice, &preamble], - ixvm_vk: ctx.ixvm_vk, - self_vk: ctx.aggr_vk, - child_claims: [&claims, &[]], - output_claim: &spec.statement.claim_bytes, - allowed: ctx.allowed, - preimages: &preimages, - trees: &[], - paths: &[], - }); - let mut public_input = packed_digest(ctx.allowed); - public_input.extend(packed_digest(&spec.statement.claim_bytes)); - let (outer_claim, proof, peak) = prove_aggr_io( - ctx, - &mut io, - &public_input, - &format!("slot {slot_index} range root"), - )?; - if outer_claim != spec.outer_claim { - return Err("range root returned an unexpected outer claim".into()); - } - eprintln!( - "[aggregate] slot {slot_index}: range root proven in {:.1}s (query-record peak {} GiB); range tree total {:.1}s", - root_started.elapsed().as_secs_f64(), - format_gib(peak), - started.elapsed().as_secs_f64() - ); - let address = persist_cached( - ctx.store_dir, - ctx.cache_dir, - ctx.write_outputs, - slot_index, - spec, - &proof, - )?; - Ok((proof, address)) -} - -/// Wraps `proof`, a proof of `root`'s claim, once more: shape 1 verifies -/// one `ix_aggr` proof and passes its statement through, so a root that is -/// a batch of trace shards (a direct join) ends as a smaller proof of the -/// same claim. -pub(super) fn wrap_root( - ctx: ProveContext<'_>, - root: &Slot, - proof: &AiurProof, -) -> Result { - let started = Instant::now(); - let advice_shards = proof.preamble.headers.len(); - let advice = ctx - .aggr_system - .proof_to_advice_bytes(&root.outer_claim, proof) - .map_err(|error| format!("root proof advice failed: {error}"))?; - let mut io = aggr_io_buffer(&AggrAdvice { - shape: shape_code(ChildKind::Aggr, None), - proof_advice: [&advice, &[]], - ixvm_vk: ctx.ixvm_vk, - self_vk: ctx.aggr_vk, - child_claims: [&root.claims_bytes, &[]], - output_claim: &root.statement.claim_bytes, - allowed: ctx.allowed, - preimages: &[], - trees: &[], - paths: &[], - }); - let mut public_input = packed_digest(ctx.allowed); - public_input.extend(packed_digest(&root.statement.claim_bytes)); - let (outer_claim, proof, peak) = - prove_aggr_io(ctx, &mut io, &public_input, "root wrap")?; - if outer_claim != root.outer_claim { - return Err("root wrap returned an unexpected outer claim".into()); - } - eprintln!( - "[aggregate] root wrap proven in {:.1}s (query-record peak {} GiB): {} shard(s) verified into {}", - started.elapsed().as_secs_f64(), - format_gib(peak), - advice_shards, - proof.preamble.headers.len() - ); - Ok(proof) -} - -/// Discharges the binding condition of `root`'s claim, a `CheckEnv` claim -/// that assumes its binding: one more `ix_aggr` proof (shape 13 or 14) -/// verifies `proof` and `binding`, an IxVM proof of the `Binding` claim for -/// the root's specification digest and binding hash, and states the root's -/// claim validating its binding. Returns that proof and its claim's bytes. -pub(super) fn discharge_root( - ctx: ProveContext<'_>, - root: &Slot, - proof: &AiurProof, - binding: &IxonProof, -) -> Result<(AiurProof, Vec), String> { - let started = Instant::now(); - let output_bytes = - discharged_claim_bytes(&root.statement.claim_bytes, &binding.claim)?; - let mut binding_bytes = Vec::new(); - binding.claim.put(&mut binding_bytes); - let binding_inner = inner_claim(ctx.verify_idx, &binding_bytes); - let binding_proof = AiurProof::from_bytes(&binding.proof) - .map_err(|error| format!("binding proof does not decode: {error}"))?; - ctx.ixvm_system.verify(&binding_inner, &binding_proof).map_err(|error| { - format!("binding proof fails native verification: {error:?}") - })?; - let binding_advice = ctx - .ixvm_system - .proof_to_advice_bytes(&binding_inner, &binding_proof) - .map_err(|error| format!("binding proof advice failed: {error:?}"))?; - let root_system = match root.kind { - ChildKind::Ixvm => ctx.ixvm_system, - ChildKind::Aggr => ctx.aggr_system, - }; - let root_advice = root_system - .proof_to_advice_bytes(&root.outer_claim, proof) - .map_err(|error| format!("root proof advice failed: {error:?}"))?; - let binding_claims = serialize_claims(&[&binding_inner]); - let preimages = [ - AggrPreimage { - digest: *blake3::hash(&root.statement.claim_bytes).as_bytes(), - bytes: &root.statement.claim_bytes, - }, - AggrPreimage { - digest: *blake3::hash(&binding_bytes).as_bytes(), - bytes: &binding_bytes, - }, - ]; - let mut io = aggr_io_buffer(&AggrAdvice { - shape: discharge_shape_code(root.kind), - proof_advice: [&root_advice, &binding_advice], - ixvm_vk: ctx.ixvm_vk, - self_vk: ctx.aggr_vk, - child_claims: [&root.claims_bytes, &binding_claims], - output_claim: &output_bytes, - allowed: ctx.allowed, - preimages: &preimages, - trees: &[], - paths: &[], - }); - let mut public_input = packed_digest(ctx.allowed); - public_input.extend(packed_digest(&output_bytes)); - let (_outer_claim, proof, peak) = - prove_aggr_io(ctx, &mut io, &public_input, "binding discharge")?; - eprintln!( - "[aggregate] binding discharge proven in {:.1}s (query-record peak {} GiB)", - started.elapsed().as_secs_f64(), - format_gib(peak), - ); - Ok((proof, output_bytes)) -} - -/// The bytes of the `CheckEnv` claim `claim_bytes`, which assumes its -/// binding, validating it instead, after checking that `binding` is the -/// `Binding` claim for its specification digest and binding hash. -pub(super) fn discharged_claim_bytes( - claim_bytes: &[u8], - binding: &Claim, -) -> Result, String> { - let claim = Claim::from_bytes(claim_bytes)?; - let Claim::CheckEnv { ctx, root, assumptions } = claim else { - return Err("only a CheckEnv claim's binding can be discharged".into()); - }; - if !ctx.binding_assumed { - return Err("the aggregate's claim already validates its binding".into()); - } - let Claim::Binding { spec, binding: bound } = binding else { - return Err("the binding proof is not a proof of a Binding claim".into()); - }; - if *spec != ctx.spec || *bound != ctx.binding { - return Err( - "the binding proof is for another specification digest or binding".into(), - ); - } - let discharged = Claim::CheckEnv { - ctx: ClaimContext { binding_assumed: false, ..ctx }, - root, - assumptions, - }; - let mut bytes = Vec::new(); - discharged.put(&mut bytes); - Ok(bytes) -} - -/// Verifies raw shard `shard` of slot `slot_index` natively and returns it -/// as a raw IxVM slot (the child a direct join takes, or what a wrap-first -/// leaf wraps). -fn verify_leaf( - ctx: ProveContext<'_>, - slot_index: usize, - shard: usize, -) -> Result { - let spec = ctx.specs.get(slot_index).ok_or("missing aggregate slot spec")?; - let prepared = &ctx.prepared[shard]; - let wrapper = ctx - .proofs - .and_then(|proofs| proofs.get(shard)) - .and_then(|proof| proof.as_ref()) - .ok_or_else(|| { - format!("shard {} proof was not loaded for replay", prepared.original_id) - })?; - let proof = AiurProof::from_bytes(&wrapper.proof).map_err(|error| { - format!("shard {} proof does not decode: {error}", prepared.original_id) - })?; - let inner = inner_claim(ctx.verify_idx, &prepared.statement.claim_bytes); - ctx.ixvm_system.verify(&inner, &proof).map_err(|error| { - format!( - "shard {} proof fails native verification: {error:?}", - prepared.original_id - ) - })?; - let inner_claims = serialize_claims(&[&inner]); - if spec.kind == ChildKind::Ixvm && spec.outer_claim != inner { - return Err("direct shard slot has an unexpected outer claim".into()); - } - Ok(Slot { - kind: ChildKind::Ixvm, - statement: spec.statement.clone(), - outer_claim: inner, - proof, - proof_address: None, - claims_bytes: inner_claims, - }) -} - -/// A slot prepared for the prover: complete already (a raw leaf verified, -/// a cached proof), a wrap-first leaf whose batch becomes a range tree -/// (executed and proven together), or an execution waiting for its STARK -/// (a wrap or a join). -pub(super) enum StagedSlot { - Done(Arc), - Range(Box), - Staged(Staged), -} - -/// The execution half of [`prove_slot`]: verification and, for a wrap or -/// a join, the `ix_aggr` execution planned within the slot budget. No -/// proving happens here, so it can run beside the prover. -#[tracing::instrument(level = "info", skip_all, name = "aiur/prepare_slot", fields(slot = slot_index))] -pub(super) fn prepare_slot( - ctx: ProveContext<'_>, - slot_index: usize, - children: &[Arc], -) -> Result { - let spec = ctx.specs.get(slot_index).ok_or("missing aggregate slot spec")?; - match spec.op { - PlanOp::Leaf(shard) => { - let raw = verify_leaf(ctx, slot_index, shard)?; - if spec.kind == ChildKind::Ixvm { - return Ok(StagedSlot::Done(Arc::new(raw))); - } - eprintln!( - "[aggregate] wrapping shard {} into slot {slot_index}", - ctx.prepared[shard].original_id - ); - // A batch of several shards becomes a range tree: leaves of the - // requested width, or of the derived width (as few leaves as there - // are node slots) when none was requested and slots are budgeted. - let shards = raw.proof.preamble.headers.len(); - let ranged = shards > 1 - && (ctx.range_width > 0 && shards > ctx.range_width - || ctx.range_width == 0 && ctx.wrap_budget.is_some()); - if ranged { - return Ok(StagedSlot::Range(Box::new(raw))); - } - let staged = prepare_aggregate(ctx, spec, &raw, None, slot_index)?; - Ok(StagedSlot::Staged(staged)) - }, - PlanOp::Join(left_index, right_index) => { - if children.len() != 2 { - return Err("aggregate join did not receive two children".into()); - } - let mode = if spec.structural { "structural" } else { "flat" }; - eprintln!( - "[aggregate] {mode}-joining slots {left_index}, {right_index} into {slot_index}" - ); - let staged = prepare_aggregate( - ctx, - spec, - &children[0], - Some(&children[1]), - slot_index, - )?; - Ok(StagedSlot::Staged(staged)) - }, - } -} - -/// The proving half of [`prove_slot`]. -#[tracing::instrument(level = "info", skip_all, name = "aiur/finish_slot", fields(slot = slot_index))] -pub(super) fn finish_slot( - ctx: ProveContext<'_>, - slot_index: usize, - staged: StagedSlot, -) -> Result, String> { - let spec = ctx.specs.get(slot_index).ok_or("missing aggregate slot spec")?; - let (proof, proof_address) = match staged { - StagedSlot::Done(slot) => return Ok(slot), - StagedSlot::Range(raw) => { - prove_range_tree(ctx, spec, &raw.proof, slot_index)? - }, - StagedSlot::Staged(staged) => finish_aggregate(ctx, staged)?, - }; - Ok(Arc::new(Slot { - kind: ChildKind::Aggr, - statement: spec.statement.clone(), - outer_claim: spec.outer_claim.clone(), - proof, - proof_address, - claims_bytes: serialize_claims(&[&spec.outer_claim]), - })) -} - -/// Prepares and proves one slot in place. -pub(super) fn prove_slot( - ctx: ProveContext<'_>, - slot_index: usize, - children: &[Arc], -) -> Result, String> { - let staged = prepare_slot(ctx, slot_index, children)?; - finish_slot(ctx, slot_index, staged) -} - -pub(super) fn load_replay_child( - ctx: ProveContext<'_>, - target: usize, - child_index: usize, -) -> Result, String> { - let spec = ctx - .specs - .get(child_index) - .ok_or("replay target has a missing child slot")?; - if spec.kind == ChildKind::Ixvm { - return prove_slot(ctx, child_index, &[]); - } - let (proof, proof_address) = load_cached( - ctx.aggr_system, - ctx.store_dir, - ctx.cache_read_dir, - child_index, - spec, - ) - .ok_or_else(|| { - format!( - "replay slot {target} requires cached child slot {child_index}; run Stage 2 through that child first" - ) - })?; - Ok(Arc::new(Slot { - kind: ChildKind::Aggr, - statement: spec.statement.clone(), - outer_claim: spec.outer_claim.clone(), - proof, - proof_address: Some(proof_address), - claims_bytes: serialize_claims(&[&spec.outer_claim]), - })) -} - -#[tracing::instrument(level = "info", skip_all, name = "aiur/replay", fields(slot = target))] -pub(super) fn run_replay( - ctx: ProveContext<'_>, - target: usize, - plan: &ReplayPlan, -) -> Result { - let started = Instant::now(); - eprintln!( - "[aggregate] replay slot {target}: loading {} immediate child proof(s)", - plan.children.len() - ); - let children: Vec> = plan - .children - .iter() - .map(|child| load_replay_child(ctx, target, *child)) - .collect::>()?; - let children_loaded_at = Instant::now(); - let slot = prove_slot(ctx, target, &children)?; - ctx.aggr_system.verify(&slot.outer_claim, &slot.proof).map_err(|error| { - format!("replayed slot {target} proof failed verification: {error:?}") - })?; - let verified_at = Instant::now(); - let persisted = slot.proof_address.is_some(); - let address = match slot.proof_address.as_ref() { - Some(address) => address.clone(), - None => wrapper_address(&slot.statement, &slot.proof)?, - }; - let disposition = if persisted { "persisted" } else { "not persisted" }; - eprintln!( - "[aggregate] replay slot {target}: proof {} ({disposition})", - address.hex() - ); - eprintln!( - "[aggregate] replay slot {target}: children {:.3}s, target+verify {:.3}s, address {:.3}s, end-to-end {:.3}s", - (children_loaded_at - started).as_secs_f64(), - (verified_at - children_loaded_at).as_secs_f64(), - verified_at.elapsed().as_secs_f64(), - started.elapsed().as_secs_f64(), - ); - Ok(address.hex()) -} diff --git a/crates/ffi/src/aiur/aggregate/scheduler.rs b/crates/ffi/src/aiur/aggregate/scheduler.rs deleted file mode 100644 index c969a033b..000000000 --- a/crates/ffi/src/aiur/aggregate/scheduler.rs +++ /dev/null @@ -1,425 +0,0 @@ -//! Aggregation scheduler. - -use super::{ - format_gib, panic_text, - plan::{PlanOp, SlotSpec}, - protocol::{ChildKind, serialize_claims}, - prove::{ProveContext, Slot, StagedSlot, finish_slot, prepare_slot}, - store::load_cached, -}; -use std::{ - collections::VecDeque, - sync::{Arc, mpsc}, - thread, -}; - -pub(super) fn dependencies_complete( - spec: &SlotSpec, - completed: &[bool], -) -> bool { - match spec.op { - PlanOp::Leaf(_) => true, - PlanOp::Join(left, right) => completed[left] && completed[right], - } -} - -/// What preparing a slot yields: a slot complete already, or work for the -/// prover. -pub(super) enum Prepared { - Done(Arc), - Staged(S), -} - -/// The per-slot work the scheduler drives. The production worker proves -/// aggregate slots; a test worker completes slots without recursive proofs. -pub(super) trait SlotWorker: Sync { - type Staged: Send; - type Done: Send + Sync; - fn specs(&self) -> &[SlotSpec]; - /// The RAM a slot holds from admission to completion. - fn weight(&self, index: usize) -> usize; - /// A slot that only verifies: no record, no prover. - fn verify_only(&self, index: usize) -> bool; - /// The slot's result if a cache already holds it, checked before any - /// slot is admitted. - fn cached(&self, index: usize) -> Option>; - fn prepare( - &self, - index: usize, - children: &[Arc], - ) -> Result, String>; - fn finish( - &self, - index: usize, - staged: Self::Staged, - ) -> Result, String>; -} - -struct ProveWorker<'a>(ProveContext<'a>); - -impl SlotWorker for ProveWorker<'_> { - type Staged = StagedSlot; - type Done = Slot; - - fn specs(&self) -> &[SlotSpec] { - self.0.specs - } - - /// With trace shards each slot is held to its share of the budget inside - /// its proof; the static per-shape weights describe whole CPU proofs and - /// would keep every slot alone, so they gate nothing on that path. - fn weight(&self, index: usize) -> usize { - if self.0.wrap_budget.is_some() { 0 } else { self.0.specs[index].ram_bytes } - } - - fn verify_only(&self, index: usize) -> bool { - matches!(self.0.specs[index].op, PlanOp::Leaf(_)) - && self.0.specs[index].kind == ChildKind::Ixvm - } - - fn cached(&self, index: usize) -> Option> { - let ctx = self.0; - if ctx.reprove_slot.is_some() { - return None; - } - let spec = &ctx.specs[index]; - if spec.kind != ChildKind::Aggr { - return None; - } - let (proof, address) = load_cached( - ctx.aggr_system, - ctx.store_dir, - ctx.cache_read_dir, - index, - spec, - )?; - 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]), - })) - } - - fn prepare( - &self, - index: usize, - children: &[Arc], - ) -> Result, String> { - match prepare_slot(self.0, index, children).map_err(String::from)? { - StagedSlot::Done(slot) => Ok(Prepared::Done(slot)), - staged => Ok(Prepared::Staged(staged)), - } - } - - fn finish( - &self, - index: usize, - staged: StagedSlot, - ) -> Result, String> { - finish_slot(self.0, index, staged) - } -} - -pub(super) fn run_scheduler( - ctx: ProveContext<'_>, - jobs: usize, - ahead: usize, - budget: usize, - active: &[bool], -) -> Result>>, String> { - run_scheduler_with(jobs, ahead, budget, active, &ProveWorker(ctx)) -} - -/// What a scheduler thread reports: a slot prepared (or found complete -/// while preparing), or a slot proven. -enum SchedulerEvent { - /// A slot prepared (the flag: it was a verify-only leaf). - Prepared(usize, bool, Result, String>), - Finished(usize, Result, String>), -} - -/// Runs the slot plan on two thread pools: `ahead` threads prepare ready slots -/// (children complete) — the CPU half: advice, execution, planning — -/// while `jobs` threads prove prepared slots — the GPU half — so a join -/// executes while the previous one proves. `ahead == 0` fuses the pools: -/// each admitted slot prepares and proves on one thread, `jobs` at a -/// time. Slots are admitted bottom level first, then by index, so parents -/// become ready as early as possible; the RAM weights gate admission, a -/// slot's weight held from admission to completion. `active` selects the -/// slots to run; a slot under a cached ancestor is retired without a -/// result of its own. -pub(super) fn run_scheduler_with( - jobs: usize, - ahead: usize, - budget: usize, - active: &[bool], - worker: &W, -) -> Result>>, String> { - if budget == 0 { - return Err("aggregate scheduler RAM budget must be positive".into()); - } - let specs = worker.specs(); - let count = specs.len(); - if active.len() != count { - return Err("aggregate scheduler selection does not match the plan".into()); - } - let target = active.iter().filter(|flag| **flag).count(); - let max_jobs = if jobs == 0 { count.max(1) } else { jobs.max(1) }; - let fused = ahead == 0; - let max_ahead = if fused { max_jobs } else { ahead }; - // Raw leaves only verify: they hold no record and take no prover, so - // they run beside both pools, a core each. - let max_verify = thread::available_parallelism().map_or(1, usize::from); - let mut level = vec![0usize; count]; - for (index, spec) in specs.iter().enumerate() { - if let PlanOp::Join(left, right) = spec.op { - level[index] = 1 + level[left].max(level[right]); - } - } - let (sender, receiver) = - mpsc::channel::>(); - thread::scope(|scope| -> Result>>, String> { - let mut slots: Vec>> = vec![None; count]; - let mut completed = vec![false; count]; - let mut admitted = vec![false; count]; - let mut retired = vec![false; count]; - let mut completed_count = 0usize; - // Cache check from the root down: a cached proof retires its whole - // subtree, so a resumed run, or the final run over the subtree runs' - // roots, loads and verifies only the highest cached proofs and never - // visits what is under them. Specs are in post-order, so walking them - // backwards meets every parent before its children. - for index in (0..count).rev() { - if !active[index] || completed[index] { - continue; - } - let Some(slot) = worker.cached(index) else { - continue; - }; - slots[index] = Some(slot); - let mut stack = vec![index]; - while let Some(slot) = stack.pop() { - if completed[slot] { - continue; - } - completed[slot] = true; - admitted[slot] = true; - retired[slot] = slot != index; - completed_count += 1; - if let PlanOp::Join(left, right) = specs[slot].op { - stack.push(left); - stack.push(right); - } - } - eprintln!("[aggregate] slot {index}: cached; its subtree is not visited"); - } - let mut verifying = 0usize; - let mut preparing = 0usize; - let mut proving = 0usize; - let mut reserved = 0usize; - let mut prepared: VecDeque<(usize, W::Staged)> = VecDeque::new(); - let mut failures: Vec<(usize, String)> = Vec::new(); - - while completed_count < target { - if failures.is_empty() { - // Provers first: prepared slots, in the order prepared. - while proving < max_jobs { - let Some((index, staged)) = prepared.pop_front() else { - break; - }; - proving += 1; - let sender = sender.clone(); - scope.spawn(move || { - let result = - std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { - worker.finish(index, staged) - })) - .unwrap_or_else(|payload| { - Err(format!( - "Rust proof worker panicked: {}", - panic_text(&payload) - )) - }); - let _ = sender.send(SchedulerEvent::Finished(index, result)); - }); - } - // Then preparation: ready slots, bottom level first; a prepared record - // waiting for the prover counts against the lookahead, and raw - // leaves have their own allowance. - let mut ready: Vec = (0..count) - .filter(|&index| { - active[index] - && !admitted[index] - && dependencies_complete(&specs[index], &completed) - }) - .collect(); - ready.sort_unstable_by_key(|&index| (level[index], index)); - for index in ready { - let verify = worker.verify_only(index); - if verify { - if verifying >= max_verify { - continue; - } - } else if preparing + prepared.len() >= max_ahead { - continue; - } - let weight = worker.weight(index); - let fits = reserved.saturating_add(weight) <= budget; - if !fits && verifying + preparing + proving + prepared.len() != 0 { - continue; - } - let children = match specs[index].op { - PlanOp::Leaf(_) => Vec::new(), - PlanOp::Join(left, right) => vec![ - slots[left].as_ref().expect("completed left slot").clone(), - slots[right].as_ref().expect("completed right slot").clone(), - ], - }; - admitted[index] = true; - if verify { - verifying += 1; - } else { - preparing += 1; - } - reserved = reserved.saturating_add(weight); - if !verify { - let over = if weight > budget { - "; over-budget slot runs alone" - } else { - "" - }; - eprintln!( - "[aggregate] slot {index}: admitted {} GiB; reserved {}/{} GiB; preparing {preparing}/{max_ahead} (queued {}), proving {proving}/{max_jobs}{over}", - format_gib(weight), - format_gib(reserved), - format_gib(budget), - prepared.len(), - ); - } - let sender = sender.clone(); - scope.spawn(move || { - let result = - std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { - let prepared = worker.prepare(index, &children)?; - match prepared { - Prepared::Staged(staged) if fused => { - worker.finish(index, staged).map(Prepared::Done) - }, - prepared => Ok(prepared), - } - })) - .unwrap_or_else(|payload| { - Err(format!( - "Rust proof worker panicked: {}", - panic_text(&payload) - )) - }); - let _ = - sender.send(SchedulerEvent::Prepared(index, verify, result)); - }); - } - } - - if verifying + preparing + proving == 0 { - if failures.is_empty() { - if !prepared.is_empty() { - continue; - } - failures.push((count, "aggregate scheduler deadlocked".into())); - } - break; - } - - let event = receiver.recv().map_err(|error| { - format!("aggregate scheduler channel closed: {error}") - })?; - let (index, outcome) = match event { - SchedulerEvent::Prepared(index, verify, result) => { - if verify { - verifying -= 1; - } else { - preparing -= 1; - } - match result { - Ok(Prepared::Done(slot)) => (index, Ok(slot)), - Ok(Prepared::Staged(staged)) => { - eprintln!( - "[aggregate] slot {index}: prepared, waiting for the prover ({} queued)", - prepared.len() + 1 - ); - prepared.push_back((index, staged)); - continue; - }, - Err(error) => (index, Err(error)), - } - }, - SchedulerEvent::Finished(index, result) => { - proving -= 1; - (index, result) - }, - }; - reserved = reserved.saturating_sub(worker.weight(index)); - match outcome { - Ok(slot) => { - slots[index] = Some(slot); - completed[index] = true; - completed_count += 1; - }, - Err(error) => failures.push((index, error)), - } - } - - // A failure stops admission; what is running finishes, what is - // prepared and unproven is dropped. - while verifying + preparing + proving > 0 { - let event = receiver.recv().map_err(|error| { - format!("aggregate scheduler drain failed: {error}") - })?; - let (index, outcome) = match event { - SchedulerEvent::Prepared(index, verify, result) => { - if verify { - verifying -= 1; - } else { - preparing -= 1; - } - match result { - Ok(Prepared::Done(slot)) => (index, Ok(slot)), - Ok(Prepared::Staged(_)) => continue, - Err(error) => (index, Err(error)), - } - }, - SchedulerEvent::Finished(index, result) => { - proving -= 1; - (index, result) - }, - }; - match outcome { - Ok(slot) => { - slots[index] = Some(slot); - completed[index] = true; - }, - Err(error) => failures.push((index, error)), - } - } - if !failures.is_empty() { - failures.sort_unstable_by_key(|(index, _)| *index); - let (index, error) = failures.remove(0); - return Err(if index < count { - format!("slot {index}: {error}") - } else { - error - }); - } - // Every selected slot has a result, except those retired under a - // cached ancestor, which have none of their own. - if let Some(index) = (0..count) - .find(|&index| active[index] && !retired[index] && slots[index].is_none()) - { - return Err(format!("scheduler completed without slot {index}")); - } - Ok(slots) - }) -} diff --git a/crates/ffi/src/aiur/aggregate/statement.rs b/crates/ffi/src/aiur/aggregate/statement.rs deleted file mode 100644 index 60ed1869c..000000000 --- a/crates/ffi/src/aiur/aggregate/statement.rs +++ /dev/null @@ -1,332 +0,0 @@ -//! Aggregation statement. - -use ix_common::address::Address; -use ixon::{ - Claim, ClaimContext, - assumption_tree::AssumptionTree, - merkle::{ - MerklePath, leaf_hash, merkle_root_canonical_sorted, node_hash, - zero_address, - }, -}; -use rustc_hash::FxHashMap; -use std::{ - cmp::Ordering, - sync::{Arc, OnceLock}, -}; - -#[derive(Clone, Debug, PartialEq, Eq)] -pub(super) struct ShardSet(pub(super) Vec); - -impl ShardSet { - pub(super) fn singleton(index: usize, shard_count: usize) -> Self { - let mut words = vec![0; shard_count.div_ceil(64)]; - words[index / 64] |= 1u64 << (index % 64); - Self(words) - } - - pub(super) fn union(&self, other: &Self) -> Self { - debug_assert_eq!(self.0.len(), other.0.len()); - Self(self.0.iter().zip(&other.0).map(|(a, b)| a | b).collect()) - } - - pub(super) fn contains(&self, index: usize) -> bool { - self - .0 - .get(index / 64) - .is_some_and(|word| word & (1u64 << (index % 64)) != 0) - } - - pub(super) fn is_disjoint(&self, other: &Self) -> bool { - debug_assert_eq!(self.0.len(), other.0.len()); - self.0.iter().zip(&other.0).all(|(a, b)| a & b == 0) - } -} - -/// Canonical sorted tree whose expensive derivative representations are built -/// once, on demand. The root is computed once at construction. -#[derive(Debug)] -pub(super) struct CanonicalTree { - pub(super) leaves: Arc<[Address]>, - pub(super) root: Address, - pub(super) serialized: OnceLock>, - pub(super) levels: OnceLock>>, -} - -impl CanonicalTree { - pub(super) fn from_sorted( - leaves: Vec
, - ) -> Result>, String> { - if leaves.is_empty() { - return Ok(None); - } - if !leaves.windows(2).all(|w| w[0] < w[1]) { - return Err("canonical tree leaves are not strictly sorted".into()); - } - let root = merkle_root_canonical_sorted(&leaves) - .ok_or("nonempty canonical tree did not produce a root")?; - Ok(Some(Arc::new(Self { - leaves: leaves.into(), - root, - serialized: OnceLock::new(), - levels: OnceLock::new(), - }))) - } - - pub(super) fn serialized(&self) -> &[u8] { - self.serialized.get_or_init(|| { - let tree = AssumptionTree::canonical(&self.leaves) - .expect("a nonempty canonical leaf list has a tree"); - debug_assert_eq!(tree.root(), self.root); - tree.ser() - }) - } - - pub(super) fn levels(&self) -> &[Vec
] { - self.levels.get_or_init(|| { - let mut levels: Vec> = - vec![self.leaves.iter().map(leaf_hash).collect()]; - let zero = zero_address(); - while levels.last().is_some_and(|level| level.len() > 1) { - let previous = levels.last().expect("one level exists"); - let mut next = Vec::with_capacity(previous.len().div_ceil(2)); - for pair in previous.chunks(2) { - next.push(node_hash(&pair[0], pair.get(1).unwrap_or(&zero))); - } - levels.push(next); - } - levels - }) - } - - pub(super) fn merkle_proof(&self, target: &Address) -> Option { - let mut position = self.leaves.binary_search(target).ok()?; - let levels = self.levels(); - let zero = zero_address(); - let mut path = Vec::with_capacity(levels.len().saturating_sub(1)); - for level in levels.iter().take(levels.len().saturating_sub(1)) { - let sibling = - level.get(position ^ 1).cloned().unwrap_or_else(|| zero.clone()); - path.push((sibling, position & 1 == 1)); - position /= 2; - } - Some(path) - } -} - -#[derive(Debug)] -pub(super) enum SubjectRepr { - Canonical(Arc), - Structural { left: Arc, right: Arc }, -} - -#[derive(Debug)] -pub(super) struct SubjectTree { - pub(super) root: Address, - pub(super) count: usize, - pub(super) shards: ShardSet, - pub(super) repr: SubjectRepr, -} - -impl SubjectTree { - pub(super) fn canonical( - leaves: Vec
, - shards: ShardSet, - ) -> Result, String> { - let count = leaves.len(); - let canonical = CanonicalTree::from_sorted(leaves)? - .ok_or("a shard cannot have an empty subject tree")?; - Ok(Arc::new(Self { - root: canonical.root.clone(), - count, - shards, - repr: SubjectRepr::Canonical(canonical), - })) - } - - pub(super) fn flat( - left: &Arc, - right: &Arc, - ) -> Result, String> { - let SubjectRepr::Canonical(left_tree) = &left.repr else { - return Err("flat aggregate has a structural left child".into()); - }; - let SubjectRepr::Canonical(right_tree) = &right.repr else { - return Err("flat aggregate has a structural right child".into()); - }; - let leaves = merge_sorted(&left_tree.leaves, &right_tree.leaves); - if leaves.len() != left.count.saturating_add(right.count) { - return Err("aggregate subject sets overlap".into()); - } - Self::canonical(leaves, left.shards.union(&right.shards)) - } - - pub(super) fn structural(left: Arc, right: Arc) -> Arc { - Arc::new(Self { - root: node_hash(&left.root, &right.root), - count: left.count.saturating_add(right.count), - shards: left.shards.union(&right.shards), - repr: SubjectRepr::Structural { left, right }, - }) - } - - pub(super) fn canonical_tree(&self) -> Option<&CanonicalTree> { - match &self.repr { - SubjectRepr::Canonical(tree) => Some(tree), - SubjectRepr::Structural { .. } => None, - } - } - - pub(super) fn merkle_proof( - &self, - target: &Address, - owner: usize, - ) -> Option { - if !self.shards.contains(owner) { - return None; - } - match &self.repr { - SubjectRepr::Canonical(tree) => tree.merkle_proof(target), - SubjectRepr::Structural { left, right } => { - if left.shards.contains(owner) { - let mut path = left.merkle_proof(target, owner)?; - path.push((right.root.clone(), false)); - Some(path) - } else { - let mut path = right.merkle_proof(target, owner)?; - path.push((left.root.clone(), true)); - Some(path) - } - }, - } - } - - pub(super) fn collect_leaves(&self, out: &mut Vec
) { - match &self.repr { - SubjectRepr::Canonical(tree) => out.extend_from_slice(&tree.leaves), - SubjectRepr::Structural { left, right } => { - left.collect_leaves(out); - right.collect_leaves(out); - }, - } - } -} - -#[derive(Debug)] -pub(super) struct Statement { - pub(super) ctx: ClaimContext, - pub(super) subjects: Arc, - pub(super) assumptions: Option>, - pub(super) claim: Claim, - pub(super) claim_bytes: Vec, -} - -impl Statement { - pub(super) fn new( - ctx: ClaimContext, - subjects: Arc, - assumptions: Option>, - ) -> Arc { - let claim = Claim::CheckEnv { - ctx: ctx.clone(), - root: subjects.root.clone(), - assumptions: assumptions.as_ref().map(|tree| tree.root.clone()), - }; - let mut claim_bytes = Vec::new(); - claim.put(&mut claim_bytes); - Arc::new(Self { ctx, subjects, assumptions, claim, claim_bytes }) - } - - pub(super) fn join( - left: &Arc, - right: &Arc, - structural: bool, - owner_by_address: &FxHashMap, - ) -> Result, String> { - // A join states both children's typing under one context; children - // under different contexts do not combine. - if left.ctx != right.ctx { - return Err("aggregate children differ in claim context".into()); - } - if !left.subjects.shards.is_disjoint(&right.subjects.shards) - || left.subjects.root == right.subjects.root - { - return Err("aggregate subject sets overlap".into()); - } - let subjects = if structural { - SubjectTree::structural(left.subjects.clone(), right.subjects.clone()) - } else { - SubjectTree::flat(&left.subjects, &right.subjects)? - }; - let candidates = merge_optional_sets( - left.assumptions.as_deref(), - right.assumptions.as_deref(), - ); - let mut remaining = Vec::with_capacity(candidates.len()); - for candidate in candidates { - let owner = owner_by_address.get(&candidate).ok_or_else(|| { - format!("aggregate assumption {} has no owning shard", candidate.hex()) - })?; - let in_left_asm = left - .assumptions - .as_ref() - .is_some_and(|tree| tree.leaves.binary_search(&candidate).is_ok()); - let in_right_asm = right - .assumptions - .as_ref() - .is_some_and(|tree| tree.leaves.binary_search(&candidate).is_ok()); - if (in_left_asm && left.subjects.shards.contains(*owner)) - || (in_right_asm && right.subjects.shards.contains(*owner)) - { - return Err(format!( - "aggregate child assumes its own subject {}", - candidate.hex() - )); - } - if !subjects.shards.contains(*owner) { - remaining.push(candidate); - } - } - let assumptions = CanonicalTree::from_sorted(remaining)?; - Ok(Self::new(left.ctx.clone(), subjects, assumptions)) - } -} - -pub(super) fn merge_sorted( - left: &[Address], - right: &[Address], -) -> Vec
{ - let mut out = Vec::with_capacity(left.len().saturating_add(right.len())); - let (mut i, mut j) = (0, 0); - while i < left.len() && j < right.len() { - match left[i].cmp(&right[j]) { - Ordering::Less => { - out.push(left[i].clone()); - i += 1; - }, - Ordering::Greater => { - out.push(right[j].clone()); - j += 1; - }, - Ordering::Equal => { - out.push(left[i].clone()); - i += 1; - j += 1; - }, - } - } - out.extend_from_slice(&left[i..]); - out.extend_from_slice(&right[j..]); - out -} - -pub(super) fn merge_optional_sets( - left: Option<&CanonicalTree>, - right: Option<&CanonicalTree>, -) -> Vec
{ - match (left, right) { - (None, None) => Vec::new(), - (Some(tree), None) | (None, Some(tree)) => tree.leaves.to_vec(), - (Some(left), Some(right)) => merge_sorted(&left.leaves, &right.leaves), - } -} diff --git a/crates/ffi/src/aiur/aggregate/store.rs b/crates/ffi/src/aiur/aggregate/store.rs deleted file mode 100644 index 9e50eca2c..000000000 --- a/crates/ffi/src/aiur/aggregate/store.rs +++ /dev/null @@ -1,289 +0,0 @@ -//! Aggregation store. - -use super::{plan::SlotSpec, prepare::PreparedShard, statement::Statement}; -use aiur::synthesis::{AiurProof, AiurSystem}; -use ix_common::address::Address; -use ixon::Proof as IxonProof; -use rustc_hash::FxHashMap; -use std::{ - fs, - path::{Path, PathBuf}, - sync::Arc, -}; - -pub(super) fn store_path(root: &Path, address: &Address) -> PathBuf { - let hex = address.hex(); - root.join(&hex[0..2]).join(&hex[2..4]).join(&hex[4..6]).join(&hex[6..]) -} - -pub(super) fn read_store( - root: &Path, - address: &Address, -) -> Result, String> { - let path = store_path(root, address); - fs::read(&path).map_err(|error| format!("read {}: {error}", path.display())) -} - -pub(crate) fn write_store( - root: &Path, - bytes: &[u8], -) -> Result { - let address = Address::hash(bytes); - let path = store_path(root, &address); - let parent = path.parent().ok_or("store path has no parent")?; - fs::create_dir_all(parent) - .map_err(|error| format!("create {}: {error}", parent.display()))?; - // Published by rename so a reader never sees a partial object, and - // several writers of one object (other threads, other processes) each - // rename their own complete copy into place. - static WRITES: std::sync::atomic::AtomicU64 = - std::sync::atomic::AtomicU64::new(0); - let temporary = parent.join(format!( - "{}.tmp.{}.{}", - address.hex(), - std::process::id(), - WRITES.fetch_add(1, std::sync::atomic::Ordering::Relaxed) - )); - fs::write(&temporary, bytes) - .map_err(|error| format!("write {}: {error}", temporary.display()))?; - fs::rename(&temporary, &path).map_err(|error| { - format!("publish {} -> {}: {error}", temporary.display(), path.display()) - })?; - Ok(address) -} - -pub(super) fn decode_wrapper(bytes: &[u8]) -> Result { - let mut cursor = bytes; - let proof = IxonProof::get(&mut cursor)?; - if !cursor.is_empty() { - return Err(format!("{} trailing bytes after proof wrapper", cursor.len())); - } - Ok(proof) -} - -/// Loads the shard proofs a run needs: exactly one for every shard whose -/// `required` flag is set (every shard of a full run; the leaves under -/// the selected subtree otherwise), each bound to its shard by claim -/// digest. Shards outside the selection stay `None`. -pub(super) fn load_input_proofs( - proof_hexes: &str, - store_dir: &Path, - prepared: &[PreparedShard], - required: &[bool], -) -> Result>>, String> { - if required.len() != prepared.len() { - return Err("shard requirement mask does not match the manifest".into()); - } - let expected = required.iter().filter(|flag| **flag).count(); - let values: Vec<&str> = - proof_hexes.lines().filter(|line| !line.is_empty()).collect(); - if values.len() < expected { - return Err(format!( - "aggregate requires {expected} shard proofs; got {}", - values.len() - )); - } - let by_digest: FxHashMap = prepared - .iter() - .enumerate() - .map(|(index, shard)| (Address::hash(&shard.statement.claim_bytes), index)) - .collect(); - if by_digest.len() != prepared.len() { - return Err("two reconstructed shard claims have the same digest".into()); - } - let mut proofs: Vec>> = vec![None; prepared.len()]; - for value in values { - let address = Address::from_hex(value).ok_or_else(|| { - format!("shard proof is not a 64-character address: {value}") - })?; - let bytes = read_store(store_dir, &address)?; - if Address::hash(&bytes) != address { - return Err(format!( - "shard proof store object {} has the wrong digest", - address.hex() - )); - } - let wrapper = decode_wrapper(&bytes).map_err(|error| { - format!("decode shard proof {}: {error}", address.hex()) - })?; - let mut claim_bytes = Vec::new(); - wrapper.claim.put(&mut claim_bytes); - let digest = Address::hash(&claim_bytes); - let shard = by_digest.get(&digest).copied().ok_or_else(|| { - format!("proof {} matches no manifest shard", address.hex()) - })?; - if !required[shard] { - // A run proving several subtrees passes all its claim proofs to - // each; one outside this selection is ignored, not rejected. - continue; - } - if wrapper.claim != prepared[shard].statement.claim { - return Err(format!( - "proof {} hit a claim-digest collision for shard {}", - address.hex(), - prepared[shard].original_id - )); - } - if proofs[shard].is_some() { - return Err(format!( - "more than one proof supplied for shard {}", - prepared[shard].original_id - )); - } - proofs[shard] = Some(Arc::new(wrapper)); - } - if let Some(missing) = (0..prepared.len()) - .find(|shard| required[*shard] && proofs[*shard].is_none()) - { - return Err(format!( - "no proof supplied for shard {}", - prepared[missing].original_id - )); - } - Ok(proofs) -} - -pub(super) fn cache_address( - cache_dir: &Path, - key: &Address, -) -> Option
{ - let path = cache_dir.join(key.hex()); - let raw = fs::read_to_string(path).ok()?; - Address::from_hex(raw.trim()) -} - -pub(super) fn load_cached( - system: &AiurSystem, - store_dir: &Path, - cache_dir: Option<&Path>, - slot_index: usize, - spec: &SlotSpec, -) -> Option<(AiurProof, Address)> { - let cache_dir = cache_dir?; - let address = cache_address(cache_dir, &spec.cache_key)?; - let reject = |reason: &str| { - eprintln!( - "[aggregate] slot {slot_index}: cache miss (wrapper {} rejected: {reason})", - address.hex() - ); - }; - let bytes = match read_store(store_dir, &address) { - Ok(bytes) => bytes, - Err(error) => { - reject(&error); - return None; - }, - }; - if Address::hash(&bytes) != address { - reject("store object has a different content digest"); - return None; - } - let wrapper = match decode_wrapper(&bytes) { - Ok(wrapper) => wrapper, - Err(error) => { - reject(&error); - return None; - }, - }; - if wrapper.claim != spec.statement.claim { - reject("bundled claim does not match the expected statement"); - return None; - } - let proof = match AiurProof::from_bytes(&wrapper.proof) { - Ok(proof) => proof, - Err(error) => { - reject(&format!("proof deserialization failed: {error}")); - return None; - }, - }; - if let Err(error) = system.verify(&spec.outer_claim, &proof) { - reject(&format!("native verification failed: {error:?}")); - return None; - } - eprintln!("[aggregate] slot {slot_index}: cache hit {}", address.hex()); - Some((proof, address)) -} - -pub(super) fn wrapper_bytes( - statement: &Statement, - proof: &AiurProof, -) -> Result, String> { - let proof_bytes = proof.to_bytes().map_err(|error| { - format!("aggregate proof serialization failed: {error}") - })?; - let wrapper = IxonProof::new(statement.claim.clone(), proof_bytes); - let mut bytes = Vec::new(); - wrapper.put(&mut bytes); - Ok(bytes) -} - -pub(super) fn wrapper_address( - statement: &Statement, - proof: &AiurProof, -) -> Result { - Ok(Address::hash(&wrapper_bytes(statement, proof)?)) -} - -pub(super) fn persist_wrapper( - store_dir: &Path, - statement: &Statement, - proof: &AiurProof, -) -> Result { - write_store(store_dir, &statement.claim_bytes)?; - write_store(store_dir, &wrapper_bytes(statement, proof)?) -} - -/// Persists a slot's proof and publishes its cache entry. `Ok(None)` when -/// the run writes nothing or has no cache; a failure is an error, since a -/// run's success promises that its proofs are where a later run (a resume, -/// or the final run after the subtree runs) will look for them. -pub(super) fn persist_cached( - store_dir: &Path, - cache_dir: Option<&Path>, - write_outputs: bool, - slot_index: usize, - spec: &SlotSpec, - proof: &AiurProof, -) -> Result, String> { - if !write_outputs { - return Ok(None); - } - let Some(cache_dir) = cache_dir else { - return Ok(None); - }; - match (|| -> Result { - let address = persist_wrapper(store_dir, &spec.statement, proof)?; - fs::create_dir_all(cache_dir).map_err(|error| { - format!("create aggregate cache {}: {error}", cache_dir.display()) - })?; - let destination = cache_dir.join(spec.cache_key.hex()); - let temporary = cache_dir.join(format!( - "{}.tmp.{}.{}", - spec.cache_key.hex(), - std::process::id(), - slot_index - )); - fs::write(&temporary, format!("{}\n", address.hex())).map_err(|error| { - format!("write cache index {}: {error}", temporary.display()) - })?; - fs::rename(&temporary, &destination).map_err(|error| { - format!( - "publish cache index {} -> {}: {error}", - temporary.display(), - destination.display() - ) - })?; - Ok(address) - })() { - Ok(address) => { - eprintln!( - "[aggregate] slot {slot_index}: cached proof {}", - address.hex() - ); - Ok(Some(address)) - }, - Err(error) => { - Err(format!("slot {slot_index}: could not persist its proof: {error}")) - }, - } -} diff --git a/crates/ffi/src/aiur/aggregate/tests.rs b/crates/ffi/src/aiur/aggregate/tests.rs deleted file mode 100644 index 88c869d20..000000000 --- a/crates/ffi/src/aiur/aggregate/tests.rs +++ /dev/null @@ -1,279 +0,0 @@ -use super::{ - expected_from_manifest, - plan::{FoldPolicy, PlanIdentity, ReplayPlan, build_specs, plan_replay}, - prepare::prepare_run, - protocol::cache_key, - prove::structural_path_advice, - statement::{CanonicalTree, ShardSet, SubjectTree, merge_sorted}, -}; -use aiur::G; -use ix_common::address::Address; -use ixon::shard::{AggNode, ShardInfo, ShardManifest}; -use ixon::{Constant, ConstantInfo}; -use multi_stark::p3_field::PrimeCharacteristicRing; -use std::sync::Arc; - -use ixon::{Axiom, Expr}; - -mod plan; -mod prepare; -mod scheduler; -mod store; - -fn addr(label: &str) -> Address { - Address::hash(label.as_bytes()) -} - -#[test] -fn sorted_merge_is_a_set_union() { - let a = addr("a"); - let b = addr("b"); - let c = addr("c"); - let mut left = vec![a.clone(), c.clone()]; - let mut right = vec![b.clone(), c.clone()]; - left.sort_unstable(); - right.sort_unstable(); - let merged = merge_sorted(&left, &right); - assert_eq!(merged.len(), 3); - assert!(merged.windows(2).all(|window| window[0] < window[1])); -} - -#[test] -fn cached_canonical_path_matches_root() { - let mut leaves: Vec
= - (0..17).map(|index| addr(&format!("leaf-{index}"))).collect(); - leaves.sort_unstable(); - let tree = CanonicalTree::from_sorted(leaves.clone()).unwrap().unwrap(); - for leaf in leaves { - let path = tree.merkle_proof(&leaf).expect("member path"); - assert!(ixon::merkle::verify_merkle_proof(&tree.root, &leaf, &path)); - } -} - -#[test] -fn structural_path_uses_cached_child_roots() { - let mut left_leaves = vec![addr("a"), addr("b")]; - let mut right_leaves = vec![addr("c"), addr("d")]; - left_leaves.sort_unstable(); - right_leaves.sort_unstable(); - let left = - SubjectTree::canonical(left_leaves.clone(), ShardSet::singleton(0, 2)) - .unwrap(); - let right = - SubjectTree::canonical(right_leaves.clone(), ShardSet::singleton(1, 2)) - .unwrap(); - let joined = SubjectTree::structural(left, right); - for leaf in left_leaves.iter().chain(&right_leaves) { - let owner = usize::from(right_leaves.contains(leaf)); - let path = joined.merkle_proof(leaf, owner).expect("member path"); - assert!(ixon::merkle::verify_merkle_proof(&joined.root, leaf, &path)); - } -} - -#[test] -fn cache_key_has_a_stable_test_vector() { - let claim = vec![G::from_u64(1), G::from_u64(2), G::from_u64(3)]; - let key = cache_key(b"vk", &[7; 40], &claim); - assert_eq!( - key.hex(), - "86ed059157e2915fe0a83f1afd58f31f7553659ad778669f6b795e1473e7afe0" - ); -} - -/// A stand-in claim context. -fn test_ctx() -> ixon::ClaimContext { - ixon::ClaimContext { - spec: ixon::proof::spec_digest(), - binding: addr("aggregate-test-binding"), - axioms: None, - binding_assumed: false, - literal_class: false, - } -} - -/// An empty environment carrying a stand-in role binding, as every -/// environment a claim is made over must. -fn bound_env() -> ixon::Env { - let mut env = ixon::Env::new(); - let section: Arc<[u8]> = Arc::from(&b"stand-in role binding section"[..]); - env.role_binding = Some(ixon::env::RoleBinding { - address: Address::hash(§ion), - bytes: section, - }); - env -} - -fn store_axiom(env: &ixon::Env, typ: Arc, refs: Vec
) -> Address { - let constant = Constant { - info: ConstantInfo::Axio(Axiom { is_unsafe: false, lvls: 0, typ }), - sharing: Vec::new(), - refs, - univs: Vec::new(), - }; - let mut bytes = Vec::new(); - constant.put(&mut bytes); - let address = Address::hash(&bytes); - env.store_const(address.clone(), constant); - address -} - -fn shard(id: u32, block: Address) -> ShardInfo { - ShardInfo { - id, - blocks: vec![block], - heartbeats: 0, - own_size: 0, - foreign_blocks: Vec::new(), - cross_ingress: 0, - assumption_root: None, - measured_peak_bytes: 0, - } -} - -#[test] -fn native_preparation_and_structural_fold_discharge_a_frontier() { - let env = bound_env(); - let dependency = store_axiom(&env, Expr::sort(0), Vec::new()); - let consumer = - store_axiom(&env, Expr::reference(0, Vec::new()), vec![dependency.clone()]); - let reference_frontier = - ixon::shard_claim::thin_frontier(&env, std::slice::from_ref(&consumer)); - let manifest = ShardManifest { - num_shards: 2, - shards: vec![shard(0, consumer.clone()), shard(1, dependency.clone())], - total_cross_ingress: 0, - tree: Some(AggNode::Internal( - Box::new(AggNode::Leaf(0)), - Box::new(AggNode::Leaf(1)), - )), - }; - let prepared = prepare_run(&env, &manifest).expect("native preparation"); - assert_eq!( - prepared.shards[0] - .statement - .assumptions - .as_ref() - .expect("cross-shard frontier") - .leaves - .as_ref(), - reference_frontier - ); - let specs = build_specs( - &prepared, - PlanIdentity { - verify_idx: 3, - aggr_idx: 5, - aggr_vk: b"aggregate-vk", - allowed: b"allowed", - cache_fri_bytes: &[0; 40], - }, - FoldPolicy { structural_above: 0, direct_joins: false }, - ) - .expect("native specs"); - assert_eq!(specs.len(), 3); - assert!(specs[2].structural); - assert_eq!(specs[2].subject_count, 2); - assert!(specs[2].statement.assumptions.is_none()); - let (expected, constant_count) = - expected_from_manifest(&env, &manifest, 0).expect("native expected root"); - assert_eq!(constant_count, 2); - assert_eq!(expected.claim, specs[2].statement.claim); - let (flat_expected, flat_count) = - expected_from_manifest(&env, &manifest, 8).expect("flat expected root"); - assert_eq!(flat_count, 2); - assert_ne!(flat_expected.claim, expected.claim); - assert_eq!( - plan_replay(&specs, 0).unwrap(), - ReplayPlan { children: Vec::new(), needs_input_proofs: true } - ); - assert_eq!( - plan_replay(&specs, 2).unwrap(), - ReplayPlan { children: vec![0, 1], needs_input_proofs: false } - ); - assert!(plan_replay(&specs, 3).unwrap_err().contains("out of range")); - - let direct_specs = build_specs( - &prepared, - PlanIdentity { - verify_idx: 3, - aggr_idx: 5, - aggr_vk: b"aggregate-vk", - allowed: b"allowed", - cache_fri_bytes: &[0; 40], - }, - FoldPolicy { structural_above: 0, direct_joins: true }, - ) - .expect("direct native specs"); - assert!(plan_replay(&direct_specs, 0).unwrap_err().contains("raw IxVM leaf")); - assert!(plan_replay(&direct_specs, 2).unwrap().needs_input_proofs); - let paths = structural_path_advice( - &specs[0].statement, - &specs[1].statement, - &specs[2].statement, - &prepared.owner_by_address, - ) - .expect("structural paths"); - assert_eq!(paths.len(), 1); - assert_eq!(paths[0].0, dependency); - assert_eq!(paths[0].1.first(), Some(&1)); -} - -/// One `Binding` claim discharges any claim set over its binding: two -/// conditional `CheckEnv` claims with different subjects and assumptions -/// both discharge against the same binding claim, each to its own claim -/// validating the binding. A claim that already validates it, or a binding -/// claim for another binding or specification, does not discharge. -#[test] -fn one_binding_claim_discharges_any_claim_set() { - use super::prove::discharged_claim_bytes; - use ixon::proof::Claim; - let assumed = test_ctx().assuming_binding(); - let binding = Claim::Binding { - spec: assumed.spec.clone(), - binding: assumed.binding.clone(), - }; - let claims = [ - Claim::CheckEnv { - ctx: assumed.clone(), - root: addr("subjects-a"), - assumptions: None, - }, - Claim::CheckEnv { - ctx: assumed.clone(), - root: addr("subjects-b"), - assumptions: Some(addr("assumptions-b")), - }, - ]; - for claim in &claims { - let (_, bytes) = claim.commit(); - let discharged = - discharged_claim_bytes(&bytes, &binding).expect("discharges"); - let Claim::CheckEnv { ctx, root, assumptions } = claim.clone() else { - unreachable!() - }; - let validating = Claim::CheckEnv { - ctx: ixon::ClaimContext { binding_assumed: false, ..ctx }, - root, - assumptions, - }; - assert_eq!(discharged, validating.commit().1); - } - let (_, validating_bytes) = Claim::CheckEnv { - ctx: test_ctx(), - root: addr("subjects-a"), - assumptions: None, - } - .commit(); - assert!(discharged_claim_bytes(&validating_bytes, &binding).is_err()); - let (_, assumed_bytes) = claims[0].commit(); - let other_binding = Claim::Binding { - spec: assumed.spec.clone(), - binding: addr("another binding"), - }; - assert!(discharged_claim_bytes(&assumed_bytes, &other_binding).is_err()); - let other_spec = Claim::Binding { - spec: addr("another spec"), - binding: assumed.binding.clone(), - }; - assert!(discharged_claim_bytes(&assumed_bytes, &other_spec).is_err()); -} diff --git a/crates/ffi/src/aiur/aggregate/tests/plan.rs b/crates/ffi/src/aiur/aggregate/tests/plan.rs deleted file mode 100644 index 5451abd54..000000000 --- a/crates/ffi/src/aiur/aggregate/tests/plan.rs +++ /dev/null @@ -1,93 +0,0 @@ -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/aggregate/tests/prepare.rs b/crates/ffi/src/aiur/aggregate/tests/prepare.rs deleted file mode 100644 index 2fb7fd0b4..000000000 --- a/crates/ffi/src/aiur/aggregate/tests/prepare.rs +++ /dev/null @@ -1,103 +0,0 @@ -use ixon::Expr; -use ixon::shard::{AggNode, ShardManifest}; - -use super::super::{ - expected_from_manifest, - prepare::{prepare_run, validate_root_statement}, - statement::{CanonicalTree, ShardSet, Statement, SubjectTree}, -}; -use super::{addr, bound_env, shard, store_axiom, test_ctx}; - -fn singleton() -> (ixon::Env, ShardManifest) { - let env = bound_env(); - let address = store_axiom(&env, Expr::sort(0), vec![]); - let manifest = ShardManifest { - num_shards: 1, - shards: vec![shard(7, address)], - total_cross_ingress: 0, - tree: Some(AggNode::Leaf(7)), - }; - (env, manifest) -} - -#[test] -fn pruning_preserves_the_singleton_statement_and_original_shard_id() { - let (env, mut manifest) = singleton(); - let (before, count) = expected_from_manifest(&env, &manifest, 0).unwrap(); - manifest.shards.insert(0, shard(3, addr("absent-block"))); - manifest.num_shards = 2; - manifest.tree = Some(AggNode::Internal( - Box::new(AggNode::Leaf(3)), - Box::new(AggNode::Leaf(7)), - )); - let prepared = prepare_run(&env, &manifest).unwrap(); - assert_eq!(prepared.shards.len(), 1); - assert_eq!(prepared.shards[0].original_id, 7); - let (after, after_count) = - expected_from_manifest(&env, &manifest, 0).unwrap(); - assert_eq!(count, 1); - assert_eq!(count, after_count); - assert_eq!(before.claim_bytes, after.claim_bytes); -} - -#[test] -fn preparation_rejects_duplicate_ownership_ids_and_coverage_gaps() { - let (env, mut manifest) = singleton(); - manifest.shards.push(shard(8, manifest.shards[0].blocks[0].clone())); - manifest.num_shards = 2; - assert!( - prepare_run(&env, &manifest).err().unwrap().contains("owned by shards") - ); - manifest.shards[1].blocks.clear(); - manifest.shards[1].id = 7; - assert!( - prepare_run(&env, &manifest).err().unwrap().contains("repeats shard id") - ); - manifest.shards.pop(); - manifest.shards[0].blocks.clear(); - assert!( - prepare_run(&env, &manifest) - .err() - .unwrap() - .contains("no owning manifest shard") - ); -} - -#[test] -fn root_validation_rejects_foreign_subjects_and_surviving_assumptions() { - let (env, manifest) = singleton(); - let prepared = prepare_run(&env, &manifest).unwrap(); - let valid = &prepared.shards[0].statement; - validate_root_statement(&prepared, valid).unwrap(); - let other_context = Statement::new( - test_ctx(), - valid.subjects.clone(), - valid.assumptions.clone(), - ); - assert!( - validate_root_statement(&prepared, &other_context) - .unwrap_err() - .contains("another claim context") - ); - let foreign = Statement::new( - prepared.ctx.clone(), - SubjectTree::canonical(vec![addr("foreign")], ShardSet::singleton(0, 1)) - .unwrap(), - None, - ); - assert!( - validate_root_statement(&prepared, &foreign) - .unwrap_err() - .contains("foreign subject") - ); - let residual = Statement::new( - prepared.ctx.clone(), - valid.subjects.clone(), - CanonicalTree::from_sorted(vec![addr("assumption")]).unwrap(), - ); - assert!( - validate_root_statement(&prepared, &residual) - .unwrap_err() - .contains("undischarged assumptions") - ); -} diff --git a/crates/ffi/src/aiur/aggregate/tests/scheduler.rs b/crates/ffi/src/aiur/aggregate/tests/scheduler.rs deleted file mode 100644 index 43c71e44f..000000000 --- a/crates/ffi/src/aiur/aggregate/tests/scheduler.rs +++ /dev/null @@ -1,230 +0,0 @@ -use std::sync::{Arc, Mutex, mpsc}; -use std::time::Duration; - -use super::super::{ - plan::{PlanOp, SlotSpec}, - protocol::ChildKind, - scheduler::{Prepared, SlotWorker, run_scheduler_with}, - statement::{ShardSet, Statement, SubjectTree}, -}; -use super::{addr, test_ctx}; - -const TIMEOUT: Duration = Duration::from_secs(30); - -fn specs(ops: &[(PlanOp, usize)]) -> Vec { - let subjects = - SubjectTree::canonical(vec![addr("scheduler")], ShardSet::singleton(0, 1)) - .unwrap(); - let statement = Statement::new(test_ctx(), subjects, None); - ops - .iter() - .map(|(op, ram_bytes)| SlotSpec { - op: *op, - statement: statement.clone(), - subject_count: 1, - structural: false, - kind: ChildKind::Aggr, - shape: Some(0), - outer_claim: vec![], - cache_key: addr("key"), - ram_bytes: *ram_bytes, - }) - .collect() -} - -fn plan() -> Vec { - specs(&[ - (PlanOp::Leaf(0), 2), - (PlanOp::Leaf(1), 9), - (PlanOp::Join(0, 1), 100), - (PlanOp::Leaf(2), 1), - (PlanOp::Join(2, 3), 4), - ]) -} - -fn check_children(spec: &SlotSpec, children: &[Arc]) { - let actual: Vec<_> = children.iter().map(|child| **child).collect(); - match spec.op { - PlanOp::Leaf(_) => assert!(actual.is_empty()), - PlanOp::Join(left, right) => assert_eq!(actual, vec![left, right]), - } -} - -/// A worker that completes every slot while preparing it, so the fused -/// pools run each slot on one thread as the production worker would. -struct TestWorker<'a, F> { - specs: &'a [SlotSpec], - run: F, -} - -impl SlotWorker for TestWorker<'_, F> -where - F: Fn(usize, &[Arc]) -> Result, String> + Sync, -{ - type Staged = (); - type Done = usize; - - fn specs(&self) -> &[SlotSpec] { - self.specs - } - - fn weight(&self, index: usize) -> usize { - self.specs[index].ram_bytes - } - - fn verify_only(&self, _index: usize) -> bool { - false - } - - fn cached(&self, _index: usize) -> Option> { - None - } - - fn prepare( - &self, - index: usize, - children: &[Arc], - ) -> Result, String> { - (self.run)(index, children).map(Prepared::Done) - } - - fn finish(&self, _index: usize, (): ()) -> Result, String> { - unreachable!("test slots complete while preparing") - } -} - -fn run( - plan: &[SlotSpec], - jobs: usize, - budget: usize, - run: F, -) -> Result, String> -where - F: Fn(usize, &[Arc]) -> Result, String> + Sync, -{ - let active = vec![true; plan.len()]; - let slots = run_scheduler_with( - jobs, - 0, - budget, - &active, - &TestWorker { specs: plan, run }, - )?; - Ok( - slots - .into_iter() - .map(|slot| *slot.expect("every active slot has a result")) - .collect(), - ) -} - -#[test] -fn serial_admission_is_bottom_level_first_and_dependencies_are_completed() { - let plan = plan(); - let order = Mutex::new(Vec::new()); - let result = run(&plan, 1, 10, |index, children| { - check_children(&plan[index], children); - order.lock().unwrap().push(index); - Ok(Arc::new(index)) - }) - .unwrap(); - // Leaves by index, then the joins as their children complete; the - // over-budget join runs alone once nothing else is in flight. - assert_eq!(*order.lock().unwrap(), vec![0, 1, 3, 2, 4]); - assert_eq!(result, vec![0, 1, 2, 3, 4]); -} - -#[test] -fn parallel_admission_respects_ram_and_runs_oversized_slots_alone() { - let plan = plan(); - let (started_tx, started_rx) = mpsc::channel(); - let channels: Vec<_> = (0..plan.len()).map(|_| mpsc::channel()).collect(); - let (releases, receivers): (Vec<_>, Vec<_>) = channels.into_iter().unzip(); - let receivers: Vec<_> = receivers.into_iter().map(Mutex::new).collect(); - let active = Mutex::new((0usize, 0usize, 0usize)); // workers, bytes, peak workers - std::thread::scope(|scope| { - let scheduler = scope.spawn(|| { - run(&plan, 2, 10, |index, children| { - check_children(&plan[index], children); - { - let mut active = active.lock().unwrap(); - active.0 += 1; - active.1 += plan[index].ram_bytes; - active.2 = active.2.max(active.0); - assert!(active.0 <= 2); - assert!(active.1 <= 10 || active.0 == 1); - } - started_tx.send(index).unwrap(); - receivers[index].lock().unwrap().recv_timeout(TIMEOUT).unwrap(); - { - let mut active = active.lock().unwrap(); - active.0 -= 1; - active.1 -= plan[index].ram_bytes; - } - Ok(Arc::new(index)) - }) - }); - // Drop release senders even when an assertion fails, so blocked workers - // terminate and the scoped scheduler can drain them. - let drive = std::panic::catch_unwind(|| { - let mut initial = vec![ - started_rx.recv_timeout(TIMEOUT).unwrap(), - started_rx.recv_timeout(TIMEOUT).unwrap(), - ]; - initial.sort_unstable(); - assert_eq!(initial, vec![0, 3]); // 2 + 9 does not fit; 2 + 1 does. - releases[0].send(()).unwrap(); - assert_eq!(started_rx.recv_timeout(TIMEOUT).unwrap(), 1); // 1 + 9 fits. - releases[3].send(()).unwrap(); - releases[1].send(()).unwrap(); - assert_eq!(started_rx.recv_timeout(TIMEOUT).unwrap(), 2); // alone - releases[2].send(()).unwrap(); - assert_eq!(started_rx.recv_timeout(TIMEOUT).unwrap(), 4); - releases[4].send(()).unwrap(); - }); - drop(releases); - let result = scheduler.join().unwrap(); - drive.unwrap(); - assert_eq!(result.unwrap(), vec![0, 1, 2, 3, 4]); - }); - assert_eq!(*active.lock().unwrap(), (0, 0, 2)); -} - -#[test] -fn failure_drains_admitted_workers_and_selects_the_lowest_slot_error() { - let plan = - specs(&[(PlanOp::Leaf(0), 5), (PlanOp::Leaf(1), 5), (PlanOp::Leaf(2), 1)]); - let (arrived_tx, arrived_rx) = mpsc::channel(); - let arrived_rx = Mutex::new(arrived_rx); - let (release_tx, release_rx) = mpsc::channel(); - let release_rx = Mutex::new(release_rx); - let finished = Mutex::new(Vec::new()); - let result = run(&plan, 2, 10, |index, _| { - assert!(index < 2, "failure must stop further admission"); - if index == 0 { - arrived_rx.lock().unwrap().recv_timeout(TIMEOUT).unwrap(); - release_tx.send(()).unwrap(); - } else { - arrived_tx.send(()).unwrap(); - release_rx.lock().unwrap().recv_timeout(TIMEOUT).unwrap(); - } - finished.lock().unwrap().push(index); - Err(format!("failure-{index}")) - }); - assert_eq!(result.unwrap_err(), "slot 0: failure-0"); - let mut finished = finished.into_inner().unwrap(); - finished.sort_unstable(); - assert_eq!(finished, vec![0, 1]); -} - -#[test] -fn worker_panics_become_errors_and_zero_budget_is_rejected() { - let plan = plan(); - assert!( - run(&plan, 1, 0, |_, _| panic!("must not start")) - .unwrap_err() - .contains("positive") - ); - let err = run(&plan, 1, 10, |_, _| panic!("test panic")).unwrap_err(); - assert!(err.contains("slot 0: Rust proof worker panicked: test panic")); -} diff --git a/crates/ffi/src/aiur/aggregate/tests/store.rs b/crates/ffi/src/aiur/aggregate/tests/store.rs deleted file mode 100644 index d8874421c..000000000 --- a/crates/ffi/src/aiur/aggregate/tests/store.rs +++ /dev/null @@ -1,237 +0,0 @@ -use std::{ - fs, - path::PathBuf, - sync::atomic::{AtomicUsize, Ordering}, -}; - -use aiur::{ - G, - bytecode::{Block, Circuit, Ctrl, Function, FunctionLayout, Toplevel}, - execute::IOBuffer, - synthesis::{AiurProof, AiurSystem}, -}; -use multi_stark::{ - p3_field::PrimeCharacteristicRing, - types::{CommitmentParameters, FriParameters}, -}; - -use super::super::{ - plan::{PlanOp, SlotSpec}, - protocol::{ChildKind, aggregate_outer_claim}, - statement::{ShardSet, Statement, SubjectTree}, - store::{load_cached, persist_cached, store_path, write_store}, -}; -use super::addr; - -struct Fixture { - root: PathBuf, - store: PathBuf, - cache: PathBuf, - system: AiurSystem, - spec: SlotSpec, - proof: AiurProof, -} - -impl Fixture { - fn new() -> Self { - static NEXT: AtomicUsize = AtomicUsize::new(0); - let root = std::env::temp_dir().join(format!( - "ix-aggregate-cache-{}-{}", - std::process::id(), - NEXT.fetch_add(1, Ordering::Relaxed) - )); - fs::create_dir(&root).unwrap(); - let store = root.join("store"); - let cache = root.join("cache"); - let layout = FunctionLayout { - input_size: 16, - selectors: 1, - auxiliaries: 1, - lookups: 1, - }; - let top = Toplevel { - functions: vec![Function { - body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![]) }, - layout, - entry: true, - constrained: true, - }], - circuits: vec![Circuit { members: vec![0], layout }], - memory_sizes: vec![], - }; - let system = AiurSystem::build( - top, - CommitmentParameters { log_blowup: 1, cap_height: 0 }, - FriParameters { - log_final_poly_len: 0, - max_log_arity: 1, - num_queries: 2, - commit_proof_of_work_bits: 0, - query_proof_of_work_bits: 0, - }, - ); - let subjects = SubjectTree::canonical( - vec![addr("cache-subject")], - ShardSet::singleton(0, 1), - ) - .unwrap(); - let statement = Statement::new(super::test_ctx(), subjects, None); - let outer_claim = - aggregate_outer_claim(0, b"test-identity", &statement.claim_bytes); - let spec = SlotSpec { - op: PlanOp::Leaf(0), - statement, - subject_count: 1, - structural: false, - kind: ChildKind::Aggr, - shape: Some(0), - outer_claim, - cache_key: addr("cache-key"), - ram_bytes: 1, - }; - let (claim, proof) = system.prove( - 0, - &spec.outer_claim[2..], - &mut IOBuffer { data: Default::default(), map: Default::default() }, - ); - assert_eq!(claim, spec.outer_claim); - system.verify(&claim, &proof).unwrap(); - Self { root, store, cache, system, spec, proof } - } - - fn load(&self) -> Option<(AiurProof, ix_common::address::Address)> { - load_cached(&self.system, &self.store, Some(&self.cache), 0, &self.spec) - } - - fn persist(&self) -> ix_common::address::Address { - persist_cached( - &self.store, - Some(&self.cache), - true, - 0, - &self.spec, - &self.proof, - ) - .unwrap() - .unwrap() - } - - fn replace_wrapper(&self, wrapper: &ixon::Proof) { - let mut bytes = Vec::new(); - wrapper.put(&mut bytes); - let address = write_store(&self.store, &bytes).unwrap(); - fs::create_dir_all(&self.cache).unwrap(); - fs::write(self.cache.join(self.spec.cache_key.hex()), address.hex()) - .unwrap(); - } -} - -impl Drop for Fixture { - fn drop(&mut self) { - fs::remove_dir_all(&self.root).unwrap(); - } -} - -#[test] -fn verified_cache_reuse_and_atomic_index_replacement() { - let fixture = Fixture::new(); - assert!(fixture.load().is_none()); - let address = fixture.persist(); - let (proof, loaded_address) = fixture.load().expect("verified hit"); - assert_eq!(address, loaded_address); - fixture.system.verify(&fixture.spec.outer_claim, &proof).unwrap(); - fs::write(fixture.cache.join(fixture.spec.cache_key.hex()), "corrupt") - .unwrap(); - assert!(fixture.load().is_none()); - assert_eq!(fixture.persist(), address); - assert!(fixture.load().is_some()); - assert_eq!(fs::read_dir(&fixture.cache).unwrap().count(), 1); -} - -#[test] -fn cache_rejects_missing_and_corrupt_content() { - let fixture = Fixture::new(); - let address = fixture.persist(); - let path = store_path(&fixture.store, &address); - fs::write(&path, b"wrong content address").unwrap(); - assert!(fixture.load().is_none()); - fs::remove_file(&path).unwrap(); - assert!(fixture.load().is_none()); -} - -#[test] -fn cache_rejects_wrong_statement_and_malformed_proof() { - let fixture = Fixture::new(); - let subjects = - SubjectTree::canonical(vec![addr("other")], ShardSet::singleton(0, 1)) - .unwrap(); - let other = Statement::new(super::test_ctx(), subjects, None); - fixture.replace_wrapper(&ixon::Proof::new( - other.claim.clone(), - fixture.proof.to_bytes().unwrap(), - )); - assert!(fixture.load().is_none()); - fixture.replace_wrapper(&ixon::Proof::new( - fixture.spec.statement.claim.clone(), - vec![0xff], - )); - assert!(fixture.load().is_none()); -} - -#[test] -fn cache_verifies_the_proof_even_when_wrapper_and_content_address_match() { - let fixture = Fixture::new(); - let mut input = fixture.spec.outer_claim[2..].to_vec(); - input[0] += G::ONE; - let (other_claim, other_proof) = fixture.system.prove( - 0, - &input, - &mut IOBuffer { data: Default::default(), map: Default::default() }, - ); - fixture.system.verify(&other_claim, &other_proof).unwrap(); - assert!( - fixture.system.verify(&fixture.spec.outer_claim, &other_proof).is_err() - ); - fixture.replace_wrapper(&ixon::Proof::new( - fixture.spec.statement.claim.clone(), - other_proof.to_bytes().unwrap(), - )); - assert!(fixture.load().is_none()); -} - -#[test] -fn no_write_and_disabled_cache_leave_no_artifacts() { - let fixture = Fixture::new(); - assert!( - persist_cached( - &fixture.store, - Some(&fixture.cache), - false, - 0, - &fixture.spec, - &fixture.proof - ) - .unwrap() - .is_none() - ); - assert!( - persist_cached( - &fixture.store, - None, - true, - 0, - &fixture.spec, - &fixture.proof - ) - .unwrap() - .is_none() - ); - assert!(!fixture.store.exists()); - assert!(!fixture.cache.exists()); - fixture.persist(); - assert!( - load_cached(&fixture.system, &fixture.store, None, 0, &fixture.spec) - .is_none() - ); - assert!(fixture.load().is_some()); -} diff --git a/crates/ffi/src/aiur/multi_stark.rs b/crates/ffi/src/aiur/multi_stark.rs deleted file mode 100644 index 260da5463..000000000 --- a/crates/ffi/src/aiur/multi_stark.rs +++ /dev/null @@ -1,113 +0,0 @@ -//! Generic Multi-STARK verifier FFI. - -use crate::aiur::protocol::{ - AIUR_PROOF_CLASS, build_g_array, build_query_counts_array, -}; -use crate::aiur::{ - lean_unbox_g, lean_unbox_nat_as_usize, toplevel::decode_toplevel, -}; -use crate::lean::LeanAiurToplevel; -use aiur::synthesis::AiurSystem; -use lean_ffi::object::{ - LeanArray, LeanBorrowed, LeanByteArray, LeanExcept, LeanExternal, LeanNat, - LeanOwned, LeanProd, -}; - -use super::protocol::ffi_catch_unwind; - -/// `Bytecode.Toplevel.executeMultiStark`: run the MultiStark recursive -/// verifier over proof-advice/vk/claims byte blobs. The proof blob is the -/// verified native transport produced by `proof_to_advice_bytes`. The IO advice buffer -/// (channel 0 = proof, 1 = vk, 2 = claims, key `[0]` each) is built -/// natively via `verifier_io_buffer` — no per-byte Lean boxing, no -/// buffer marshalling across FFI. `use_bytecode` selects the executor: -/// `false` = codegen'd verifier (`execute_multi_stark`), -/// `true` = generic Aiur bytecode interpreter. -/// Returns `(output, query_counts)`; the final buffer is not returned -/// (the verifier only reads its advice). -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_multi_stark_execute( - toplevel: LeanAiurToplevel>, - fun_idx: LeanNat>, - pub_input: LeanArray>, - proof_bytes: LeanByteArray>, - vk_bytes: LeanByteArray>, - claims_bytes: LeanByteArray>, - use_bytecode: bool, -) -> LeanExcept { - let toplevel = decode_toplevel(&toplevel); - let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let mut io_buffer = ixvm_codegen::aiur_multi_stark_runner::verifier_io_buffer( - proof_bytes.as_bytes(), - vk_bytes.as_bytes(), - claims_bytes.as_bytes(), - ); - let input = pub_input.map(|x| lean_unbox_g(&x)); - - // Same execution-phase span as the prove pipeline. - let _g = tracing::info_span!("aiur/execute_multi_stark").entered(); - let result = if use_bytecode { - toplevel.execute(fun_idx, input, &mut io_buffer) - } else { - ixvm_codegen::aiur_multi_stark_runner::execute_multi_stark( - &toplevel, - fun_idx, - input, - &mut io_buffer, - ) - }; - let (query_record, output) = match result { - Ok(pair) => pair, - Err(err) => return LeanExcept::error_string(&err.to_string()), - }; - - let lean_query_counts = build_query_counts_array(&query_record, &toplevel); - // (Array G, Array (Nat × Nat)) - let result = LeanProd::new(build_g_array(&output), lean_query_counts); - LeanExcept::ok(result) -} - -/// `AiurSystem.proveMultiStark`: prove the MultiStark recursive -/// verifier over proof-advice/vk/claims byte blobs. The proof blob uses the -/// native serialized transport returned by `proof_to_advice_bytes`. Buffer construction -/// and executor selection as in `rs_aiur_multi_stark_execute`; the -/// prove itself reuses the executor-generic `AiurSystem::prove_ixvm`. -/// Returns `(claim, proof)`; the final buffer is not returned. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_multi_stark_prove( - aiur_system_obj: LeanExternal>, - fun_idx: LeanNat>, - pub_input: LeanArray>, - proof_bytes: LeanByteArray>, - vk_bytes: LeanByteArray>, - claims_bytes: LeanByteArray>, - use_bytecode: bool, -) -> LeanExcept { - ffi_catch_unwind("AiurSystem.proveMultiStark", || { - let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let mut io_buffer = - ixvm_codegen::aiur_multi_stark_runner::verifier_io_buffer( - proof_bytes.as_bytes(), - vk_bytes.as_bytes(), - claims_bytes.as_bytes(), - ); - let args = pub_input.map(|x| lean_unbox_g(&x)); - - let system = aiur_system_obj.get(); - let (claim, proof) = if use_bytecode { - system.prove(fun_idx, &args, &mut io_buffer) - } else { - system.prove_ixvm( - fun_idx, - &args, - &mut io_buffer, - ixvm_codegen::aiur_multi_stark_runner::execute_multi_stark, - ) - }; - - let lean_proof: LeanOwned = - LeanExternal::alloc(&AIUR_PROOF_CLASS, proof).into(); - // Array G × Proof - LeanProd::new(build_g_array(&claim), lean_proof).into() - }) -} diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs deleted file mode 100644 index dae6226da..000000000 --- a/crates/ffi/src/aiur/protocol.rs +++ /dev/null @@ -1,2523 +0,0 @@ -use ix_common::address::Address; -use multi_stark::{ - p3_field::{PrimeCharacteristicRing, PrimeField64}, - types::{CommitmentParameters, FriParameters}, -}; -use rustc_hash::{FxBuildHasher, FxHashMap}; -use std::sync::LazyLock; - -use lean_ffi::object::{ - ExternalClass, LeanArray, LeanBorrowed, LeanByteArray, LeanExcept, - LeanExternal, LeanNat, LeanOption, LeanOwned, LeanProd, LeanRef, LeanString, -}; - -use crate::{ - aiur::{lean_unbox_g, lean_unbox_nat_as_usize, toplevel::decode_toplevel}, - lean::{ - LeanAiurCircuitShape, LeanAiurCommitmentParameters, LeanAiurExecuteResult, - LeanAiurFriParameters, LeanAiurIOKeyInfo, LeanAiurProveEnvResult, - LeanAiurProveResult, LeanAiurQueryCount, LeanAiurShardProveResult, - LeanAiurShardProvenAhead, LeanAiurShardResult, LeanAiurToplevel, - }, -}; -use aiur::{ - G, - execute::{IOBuffer, IOKeyInfo, QueryRecord}, - synthesis::{ - AiurProof, AiurSystem, CircuitShape, GatedProve, - ShardRetention as Retention, - }, -}; - -// ============================================================================= -// External class registration -// ============================================================================= - -pub(super) static AIUR_PROOF_CLASS: LazyLock = - LazyLock::new(ExternalClass::register_with_drop::); -static AIUR_SYSTEM_CLASS: LazyLock = - LazyLock::new(ExternalClass::register_with_drop::); -static IX_ENV_HANDLE_CLASS: LazyLock = LazyLock::new( - ExternalClass::register_with_drop::, -); - -// ============================================================================= -// Lean FFI functions -// ============================================================================= - -/// `Aiur.Proof.toBytes : @& Proof → ByteArray` -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_proof_to_bytes( - proof_obj: LeanExternal>, -) -> LeanByteArray { - let bytes = proof_obj.get().to_bytes().expect("Serialization error"); - LeanByteArray::from_bytes(&bytes) -} - -/// `Aiur.Proof.shardCount : @& Proof → Nat` -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_proof_shard_count( - proof_obj: LeanExternal>, -) -> LeanOwned { - LeanOwned::box_usize(proof_obj.get().preamble.headers.len()) -} - -/// `Aiur.Proof.ofBytes : @& ByteArray → Proof` -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_proof_of_bytes( - byte_array: LeanByteArray>, -) -> LeanExternal { - let proof = AiurProof::from_bytes(byte_array.as_bytes()) - .expect("Deserialization error"); - LeanExternal::alloc(&AIUR_PROOF_CLASS, proof) -} - -/// `Aiur.Proof.ofBytesChecked : @& ByteArray → Except String Proof` -/// -/// Unlike the legacy trusted-byte constructor above, this is safe at cache and -/// network boundaries: malformed bytes become a Lean error instead of a Rust -/// panic that aborts the process. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_proof_of_bytes_checked( - byte_array: LeanByteArray>, -) -> LeanExcept { - match AiurProof::from_bytes(byte_array.as_bytes()) { - Ok(proof) => { - let lean_proof: LeanOwned = - LeanExternal::alloc(&AIUR_PROOF_CLASS, proof).into(); - LeanExcept::ok(lean_proof) - }, - Err(err) => { - LeanExcept::error_string(&format!("proof deserialization failed: {err}")) - }, - } -} - -/// `Aiur.AiurSystem.vkBytes : @& AiurSystem → ByteArray` -/// -/// Serializes the verifying key (`System`) — see -/// `aiur::vk_codec`. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_system_vk_bytes( - system: LeanExternal>, -) -> LeanByteArray { - let bytes = aiur::vk_codec::aiur_system_to_bytes(system.get()) - .expect("VK serialization error"); - LeanByteArray::from_bytes(&bytes) -} - -/// `AiurSystem.build : @&Bytecode.Toplevel → @&CommitmentParameters → @&FriParameters → AiurSystem` -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_system_build( - toplevel: LeanAiurToplevel>, - commitment_parameters: LeanAiurCommitmentParameters>, - fri_parameters: LeanAiurFriParameters>, -) -> LeanExternal { - let system = AiurSystem::build( - decode_toplevel(&toplevel), - decode_commitment_parameters(&commitment_parameters), - decode_fri_parameters(&fri_parameters), - ); - LeanExternal::alloc(&AIUR_SYSTEM_CLASS, system) -} - -/// Helper: encode `CircuitShape`s as a Lean `Array CircuitShape`. Field -/// order must match `Aiur.CircuitShape` in `Ix/Aiur/Protocol.lean`. -fn build_circuit_shapes_array(shapes: &[CircuitShape]) -> LeanArray { - let arr = LeanArray::alloc(shapes.len()); - for (i, shape) in shapes.iter().enumerate() { - let s = LeanAiurCircuitShape::alloc(0); - s.set_obj(0, LeanOwned::box_usize(shape.main_width)); - s.set_obj(1, LeanOwned::box_usize(shape.stage2_width)); - s.set_obj(2, LeanOwned::box_usize(shape.quotient_degree)); - s.set_obj(3, LeanOwned::box_usize(shape.preprocessed_width)); - s.set_obj(4, LeanOwned::box_usize(shape.preprocessed_height)); - arr.set(i, s); - } - arr -} - -/// `AiurSystem.circuitShapes : @& AiurSystem → Array CircuitShape` -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_system_circuit_shapes( - system: LeanExternal>, -) -> LeanArray { - build_circuit_shapes_array(&system.get().circuit_shapes()) -} - -/// `Aiur.circuitShapes : @&Bytecode.Toplevel → @&CommitmentParameters → @&FriParameters → Array CircuitShape` -/// -/// One-shot variant for flows that never build an `AiurSystem` (`ix check` -/// statistics): builds the system, extracts the shapes, and drops it. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_circuit_shapes( - toplevel: LeanAiurToplevel>, - commitment_parameters: LeanAiurCommitmentParameters>, - fri_parameters: LeanAiurFriParameters>, -) -> LeanArray { - let system = AiurSystem::build( - decode_toplevel(&toplevel), - decode_commitment_parameters(&commitment_parameters), - decode_fri_parameters(&fri_parameters), - ); - build_circuit_shapes_array(&system.circuit_shapes()) -} - -/// `AiurSystem.verify : @& AiurSystem → @& Array G → @& Proof → Except String Unit` -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_system_verify( - aiur_system_obj: LeanExternal>, - claim: LeanArray>, - proof_obj: LeanExternal>, -) -> LeanExcept { - let claim = claim.map(|x| lean_unbox_g(&x)); - match aiur_system_obj.get().verify(&claim, proof_obj.get()) { - Ok(()) => LeanExcept::ok(LeanOwned::box_usize(0)), - Err(err) => LeanExcept::error_string(&format!("{err:?}")), - } -} - -/// `AiurSystem.proofToAdviceBytes : @& AiurSystem → @& Array G → @& Proof → Except String ByteArray` -/// -/// Verify and serialize the proof transport consumed by the in-circuit -/// recursive verifier. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_proof_to_advice_bytes( - aiur_system_obj: LeanExternal>, - claim: LeanArray>, - proof_obj: LeanExternal>, -) -> LeanExcept { - let claim = claim.map(|x| lean_unbox_g(&x)); - match aiur_system_obj.get().proof_to_advice_bytes(&claim, proof_obj.get()) { - Ok(bytes) => LeanExcept::ok(LeanByteArray::from_bytes(&bytes)), - Err(err) => LeanExcept::error_string(&err), - } -} - -/// `Aiur.Proof.rangeAdvice : @& Proof → @& Nat → @& Nat → -/// Except String (ByteArray × ByteArray × ByteArray)` -/// -/// The advice of a range-sum recursion node over shards `[lo, hi)`: the -/// batch preamble, the range's proofs, and the range's residual sum. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_proof_range_advice( - proof_obj: LeanExternal>, - lo: LeanNat>, - hi: LeanNat>, -) -> LeanExcept { - let proof = proof_obj.get(); - let lo = lean_unbox_nat_as_usize(lo.inner()); - let hi = lean_unbox_nat_as_usize(hi.inner()); - if lo > hi || hi > proof.proofs.len() { - return LeanExcept::error_string(&format!( - "shard range {lo}..{hi} is not within the batch's {} shards", - proof.proofs.len() - )); - } - let preamble = match aiur::range::preamble_bytes(proof) { - Ok(bytes) => bytes, - Err(err) => return LeanExcept::error_string(&err), - }; - let proofs = match aiur::range::proofs_slice_bytes(proof, lo, hi) { - Ok(bytes) => bytes, - Err(err) => return LeanExcept::error_string(&err), - }; - let residual = - aiur::range::ext_bytes(aiur::range::range_residual(proof, lo, hi)); - LeanExcept::ok(LeanProd::new( - LeanByteArray::from_bytes(&preamble), - LeanProd::new( - LeanByteArray::from_bytes(&proofs), - LeanByteArray::from_bytes(&residual), - ), - )) -} - -/// `Bytecode.Toplevel.execute`: runs execution only (no proof) and returns -/// `Except String ExecuteResult` (see `Ix/Aiur/Semantics/BytecodeFfi.lean`). -/// On execution failure (e.g. assertion mismatch from a typechecker -/// rejecting a constant), returns `Except.error msg` instead of panicking -/// — letting Lean test runners (`KernelArena.lean`) classify failures. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_toplevel_execute( - toplevel: LeanAiurToplevel>, - fun_idx: LeanNat>, - args: LeanArray>, - io_data_arr: LeanArray>, - io_map_arr: LeanArray>, -) -> LeanExcept { - let toplevel = decode_toplevel(&toplevel); - let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let mut io_buffer = decode_io_buffer(&io_data_arr, &io_map_arr); - - let (query_record, output) = match toplevel.execute( - fun_idx, - args.map(|x| lean_unbox_g(&x)), - &mut io_buffer, - ) { - Ok(pair) => pair, - Err(err) => return LeanExcept::error_string(&err.to_string()), - }; - - LeanExcept::ok(build_execute_result( - &output, - &io_buffer, - &query_record, - &toplevel, - )) -} - -/// `Bytecode.Toplevel.executeIxVM`: same shape as `rs_aiur_toplevel_execute`, -/// but routes execution through the codegen'd IxVM Rust kernel -/// (`ixvm_codegen::aiur_ixvm::execute_generated`) via the helper in -/// `ixvm_codegen::aiur_ixvm_runner::execute_ixvm`. The resulting -/// `QueryRecord` is byte-for-byte identical to the interpreter's -/// (modulo standing codegen parity invariant). -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_toplevel_execute_ixvm( - toplevel: LeanAiurToplevel>, - fun_idx: LeanNat>, - args: LeanArray>, - io_data_arr: LeanArray>, - io_map_arr: LeanArray>, -) -> LeanExcept { - let toplevel = decode_toplevel(&toplevel); - let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let mut io_buffer = decode_io_buffer(&io_data_arr, &io_map_arr); - - // Same execution-phase span as `dispatch_execute`/the prove pipeline. - let _g = tracing::info_span!("aiur/execute_ixvm").entered(); - let (query_record, output) = - match ixvm_codegen::aiur_ixvm_runner::execute_ixvm( - &toplevel, - fun_idx, - args.map(|x| lean_unbox_g(&x)), - &mut io_buffer, - ) { - Ok(pair) => pair, - Err(err) => return LeanExcept::error_string(&err.to_string()), - }; - - LeanExcept::ok(build_execute_result( - &output, - &io_buffer, - &query_record, - &toplevel, - )) -} - -/// `AiurSystem.prove`: runs the prover and returns a `ProveResult` -/// (see `Ix/Aiur/Protocol.lean`). -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_system_prove( - aiur_system_obj: LeanExternal>, - fun_idx: LeanNat>, - args: LeanArray>, - io_data_arr: LeanArray>, - io_map_arr: LeanArray>, -) -> LeanExcept { - ffi_catch_unwind("AiurSystem.prove", || { - let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let args = args.map(|x| lean_unbox_g(&x)); - let mut io_buffer = decode_io_buffer(&io_data_arr, &io_map_arr); - - let (claim, proof) = - aiur_system_obj.get().prove(fun_idx, &args, &mut io_buffer); - - build_prove_result(&claim, proof, &io_buffer).into() - }) -} - -// ============================================================================= -// EnvHandle constructors + with-env FFIs: the env is parsed once per CLI -// invocation into an opaque Rust-owned handle, and every per-target call -// borrows it, so no call re-parses the environment. -// ============================================================================= - -/// `Aiur.EnvHandle.fromIxe`: open and parse a `.ixe` file once, -/// return an opaque Rust-owned handle. The mmap stays alive inside -/// the handle (via per-constant `Arc` windows) for as long as -/// Lean retains the `LeanExternal` reference. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_env_handle_from_ixe( - path_bytes: LeanByteArray>, -) -> LeanExcept { - let path_str = String::from_utf8_lossy(path_bytes.as_bytes()).into_owned(); - match ixvm_codegen::env_handle::EnvHandle::from_ixe_path( - std::path::Path::new(&path_str), - ) { - Ok(h) => { - let lean_handle: LeanOwned = - LeanExternal::alloc(&IX_ENV_HANDLE_CLASS, h).into(); - LeanExcept::ok(lean_handle) - }, - Err(e) => LeanExcept::error_string(&format!("env handle from_ixe: {e}")), - } -} - -/// `Aiur.EnvHandle.fromBytes`: decode a serialized env blob -/// (`Ixon.serEnv` output) and harvest `anon_hints` post-decode. -/// Used by the compiled-Lean-env path (`ix check NAME` without -/// `--ixe`). -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_env_handle_from_bytes( - bytes: LeanByteArray>, -) -> LeanExcept { - match ixvm_codegen::env_handle::EnvHandle::from_bytes(bytes.as_bytes()) { - Ok(h) => { - let lean_handle: LeanOwned = - LeanExternal::alloc(&IX_ENV_HANDLE_CLASS, h).into(); - LeanExcept::ok(lean_handle) - }, - Err(e) => LeanExcept::error_string(&format!("env handle from_bytes: {e}")), - } -} - -/// Helper: summarise one execute's `QueryRecord` into a Lean -/// `Array QueryCount` of `(uniqueRows, totalHits)` structures, one per -/// function circuit followed by one per memory size. Used by every -/// check/prove FFI. -pub(super) fn build_query_counts_array( - query_record: &QueryRecord, - toplevel: &aiur::bytecode::Toplevel, -) -> LeanArray { - let mut query_counts: Vec<(usize, usize)> = Vec::with_capacity( - query_record.function_queries.len() + toplevel.memory_sizes.len(), - ); - let summarize = |q: &aiur::querymap::QueryMap| -> (usize, usize) { - let mut rows = 0usize; - let mut hits = 0usize; - for (_, res) in q.iter() { - let m = usize::try_from(res.multiplicity.as_canonical_u64()) - .expect("multiplicity exceeds usize"); - if m != 0 { - rows += 1; - hits += m; - } - } - (rows, hits) - }; - for queries in &query_record.function_queries { - query_counts.push(summarize(queries)); - } - for size in &toplevel.memory_sizes { - let pair = query_record.memory_queries.get(size).map_or((0, 0), summarize); - query_counts.push(pair); - } - let arr = LeanArray::alloc(query_counts.len()); - for (i, &(rows, hits)) in query_counts.iter().enumerate() { - let qc = LeanAiurQueryCount::alloc(0); - qc.set_obj(0, LeanOwned::box_usize(rows)); - qc.set_obj(1, LeanOwned::box_usize(hits)); - arr.set(i, qc); - } - arr -} - -/// Helper: build a Lean `ExecuteResult` (output, ioData, ioMap, -/// queryCounts) — the return shape shared by every execute/check FFI. -fn build_execute_result( - output: &[G], - io_buffer: &IOBuffer, - query_record: &QueryRecord, - toplevel: &aiur::bytecode::Toplevel, -) -> LeanAiurExecuteResult { - let result = LeanAiurExecuteResult::alloc(0); - result.set_obj(0, build_g_array(output)); - result.set_obj(1, build_lean_io_data(io_buffer)); - result.set_obj(2, build_lean_io_map(io_buffer)); - result.set_obj(3, build_query_counts_array(query_record, toplevel)); - result -} - -/// Helper: build a Lean `ProveResult` (claim, proof, ioData, ioMap). -fn build_prove_result( - claim: &[G], - proof: AiurProof, - io_buffer: &IOBuffer, -) -> LeanAiurProveResult { - let result = LeanAiurProveResult::alloc(0); - result.set_obj(0, build_g_array(claim)); - result.set_obj(1, LeanExternal::alloc(&AIUR_PROOF_CLASS, proof)); - result.set_obj(2, build_lean_io_data(io_buffer)); - result.set_obj(3, build_lean_io_map(io_buffer)); - result -} - -/// Helper: build a Lean `ProveEnvResult` (claimBytes, proof, ioData, -/// ioMap) — the claim's wire bytes are serialized via -/// `ixon::Claim::put` so Lean can deserialize directly. -fn build_prove_env_result( - claim: &ixon::proof::Claim, - proof: AiurProof, - io_buffer: &IOBuffer, -) -> LeanAiurProveEnvResult { - let mut claim_bytes: Vec = Vec::new(); - claim.put(&mut claim_bytes); - let result = LeanAiurProveEnvResult::alloc(0); - result.set_obj(0, LeanByteArray::from_bytes(&claim_bytes)); - result.set_obj(1, LeanExternal::alloc(&AIUR_PROOF_CLASS, proof)); - result.set_obj(2, build_lean_io_data(io_buffer)); - result.set_obj(3, build_lean_io_map(io_buffer)); - result -} - -/// Helper: decode a 32-byte address from a `LeanByteArray`. -fn decode_addr( - addr_bytes: &LeanByteArray>, -) -> Result { - let slice = addr_bytes.as_bytes(); - if slice.len() != 32 { - return Err(format!( - "addr_bytes: expected 32-byte address, got {} bytes", - slice.len() - )); - } - Ok(Address::from_slice(slice).expect("32-byte slice already length-checked")) -} - -/// Helper: decode a flat 32-byte-block owned blob into `Vec
`. -fn decode_owned_blob( - owned_blob: &LeanByteArray>, -) -> Result, String> { - let bytes = owned_blob.as_bytes(); - if !bytes.len().is_multiple_of(32) { - return Err(format!( - "owned_blob: length {} not a multiple of 32", - bytes.len() - )); - } - Ok( - bytes - .as_chunks::<32>() - .0 - .iter() - .map(|c| Address::from_slice(c).unwrap()) - .collect(), - ) -} - -/// Run `fun_idx` with `input` + `io_buffer`, routing through either -/// the codegen'd IxVM kernel (`use_bytecode = false`) or the -/// generic Aiur bytecode interpreter (`use_bytecode = true`). -/// The bytecode interpreter doesn't require regenerating the -/// codegen'd Rust kernel after Lean-side IxVM source changes — -/// useful for tight iteration loops on `Ix/IxVM/*.lean`. -#[inline] -fn dispatch_execute( - toplevel: &aiur::bytecode::Toplevel, - fun_idx: aiur::bytecode::FunIdx, - input: Vec, - io_buffer: &mut IOBuffer, - use_bytecode: bool, -) -> Result<(QueryRecord, Vec), String> { - // Same span name as the prove pipeline's execution phase - // (`synthesis.rs`), so a standalone execute renders/records through the - // one texray channel — timing and RAM come from the subscriber, not - // per-benchmark arithmetic. - let _g = tracing::info_span!("aiur/execute_ixvm").entered(); - if use_bytecode { - toplevel - .execute(fun_idx, input, io_buffer) - .map_err(|e| format!("execute (bytecode): {e}")) - } else { - ixvm_codegen::aiur_ixvm_runner::execute_ixvm( - toplevel, fun_idx, input, io_buffer, - ) - .map_err(|e| format!("execute_ixvm: {e}")) - } -} - -/// `Bytecode.Toplevel.checkAddrWithEnv`: per-claim check against a -/// Rust-owned `EnvHandle`. `use_bytecode` selects the executor: -/// `false` = codegen'd IxVM kernel (`execute_ixvm`), -/// `true` = generic Aiur bytecode interpreter -/// (`Toplevel::execute`). -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_toplevel_check_addr_with_env( - toplevel: LeanAiurToplevel>, - fun_idx: LeanNat>, - env_handle: LeanExternal< - ixvm_codegen::env_handle::EnvHandle, - LeanBorrowed<'_>, - >, - addr_bytes: LeanByteArray>, - use_bytecode: bool, - assume_binding: bool, -) -> LeanExcept { - let toplevel = decode_toplevel(&toplevel); - let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let addr = match decode_addr(&addr_bytes) { - Ok(a) => a, - Err(e) => return LeanExcept::error_string(&e), - }; - let env = &env_handle.get().env; - - let (_claim, input, mut io_buffer) = - match ixvm_codegen::aiur_ixvm_witness::build_claim_check_witness_with( - env, - &addr, - assume_binding, - ) { - Ok(t) => t, - Err(e) => { - return LeanExcept::error_string(&format!("witness build: {e}")); - }, - }; - - let (query_record, output) = match dispatch_execute( - &toplevel, - fun_idx, - input, - &mut io_buffer, - use_bytecode, - ) { - Ok(p) => p, - Err(e) => return LeanExcept::error_string(&e), - }; - - LeanExcept::ok(build_execute_result( - &output, - &io_buffer, - &query_record, - &toplevel, - )) -} - -/// `Bytecode.Toplevel.checkAddrsWithEnv`: check a BATCH of full-closure -/// claims (`Claim.check addr none`, one per address in `addrs_blob`) in -/// PARALLEL — rayon over the list, each task running exactly the -/// single-claim machinery above (`build_claim_check_witness` + -/// `dispatch_execute`) over entirely task-private data: its own -/// `IOBuffer`, its own `QueryRecord`, both dropped inside the task. -/// Parallel, not concurrent: nothing is shared between tasks except -/// the read-only `toplevel` and `env` (the compiler enforces this — -/// `par_iter` closures only capture `Sync` data). Each claim's record -/// is single-threaded and therefore bit-deterministic regardless of -/// `jobs` or scheduling. Peak RAM is bounded by `jobs` concurrent -/// claim cones (rayon keeps at most one in-flight task per pool -/// thread; records free at task end). -/// -/// Returns the FAILURES as an array of `(batch index, error)` pairs -/// (the index as a decimal string, resolving back to the caller's -/// label order) — -/// empty means every claim passed. Per-claim outputs and records are -/// deliberately not round-tripped to Lean; the single-claim entry -/// keeps the full result shape for that. `jobs = 0` uses rayon's -/// default pool width. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_toplevel_check_addrs_with_env( - toplevel: LeanAiurToplevel>, - fun_idx: LeanNat>, - env_handle: LeanExternal< - ixvm_codegen::env_handle::EnvHandle, - LeanBorrowed<'_>, - >, - addrs_blob: LeanByteArray>, - use_bytecode: bool, - jobs: LeanNat>, -) -> LeanExcept { - use rayon::prelude::*; - let toplevel = decode_toplevel(&toplevel); - let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let jobs = lean_unbox_nat_as_usize(jobs.inner()); - let addrs = match decode_owned_blob(&addrs_blob) { - Ok(v) => v, - Err(e) => return LeanExcept::error_string(&e), - }; - let env = &env_handle.get().env; - let check_batch = || -> Vec<(String, String)> { - addrs - .par_iter() - .enumerate() - .filter_map(|(i, addr)| { - let err = - match ixvm_codegen::aiur_ixvm_witness::build_claim_check_witness( - env, addr, - ) { - Err(e) => Some(format!("witness build: {e}")), - Ok((_claim, input, mut io_buffer)) => dispatch_execute( - &toplevel, - fun_idx, - input, - &mut io_buffer, - use_bytecode, - ) - .err(), - }; - err.map(|e| (i.to_string(), e)) - }) - .collect() - }; - let failures = if jobs == 0 { - check_batch() - } else { - let pool = match rayon::ThreadPoolBuilder::new().num_threads(jobs).build() { - Ok(p) => p, - Err(e) => { - return LeanExcept::error_string(&format!("rayon pool: {e}")); - }, - }; - pool.install(check_batch) - }; - let arr = LeanArray::alloc(failures.len()); - for (i, (idx, err)) in failures.iter().enumerate() { - arr.set(i, LeanProd::new(LeanString::new(idx), LeanString::new(err))); - } - LeanExcept::ok(arr) -} - -/// Decode a counted address-list blob (`Ix.Cli.CheckCmd.addrListsBlob`): -/// per list, a 4-byte LE count followed by that many 32-byte addresses. -/// The wire format of every partition crossing the FFI (the shard -/// batch, the manifest emit). -pub(crate) fn decode_addr_lists( - bytes: &[u8], -) -> Result>, String> { - let mut lists = Vec::new(); - let mut off = 0usize; - while off < bytes.len() { - if off + 4 > bytes.len() { - return Err("addr lists: truncated count".into()); - } - let n = - u32::from_le_bytes(bytes[off..off + 4].try_into().unwrap()) as usize; - off += 4; - if off + n * 32 > bytes.len() { - return Err("addr lists: truncated addresses".into()); - } - lists.push(Address::unpack(&bytes[off..off + n * 32]).collect()); - off += n * 32; - } - Ok(lists) -} - -/// Byte-weighted admission gate: a counting semaphore over estimated -/// execution RSS, expressed with the std Mutex+Condvar construction. -/// Bounds MEMORY in flight instead of shards in flight, so the rayon -/// pool can run at full width: cheap shards run many-wide while a -/// heavy one takes a proportional slice of the budget. Workers block -/// in `acquire` until reserving their estimate fits the budget. -struct RamGate { - reserved: std::sync::Mutex, - cv: std::sync::Condvar, - budget: usize, -} - -impl RamGate { - fn acquire(&self, bytes: usize) { - let mut used = self.reserved.lock().unwrap(); - // Admit-when-alone: a shard whose estimate alone exceeds the - // budget must still run (by itself) rather than deadlock. - while *used > 0 && *used + bytes > self.budget { - used = self.cv.wait(used).unwrap(); - } - *used += bytes; - } - - fn release(&self, bytes: usize) { - *self.reserved.lock().unwrap() -= bytes; - self.cv.notify_all(); - } -} - -/// Per-shard execution-RSS reserve for [`RamGate`], an AFFINE model: -/// `EXEC_RSS_FIXED_BYTES + EXEC_RSS_PER_OWNED_BYTE x owned bytes`. The -/// byte basis is the sum of the shard's owned constants' raw -/// serialized bytes (`Env::get_const_bytes`) — NOT the shard's share -/// of `.ixe` FILE bytes, which also carry blobs, names, and indices -/// and run ~2.6x larger. The fixed term is the closure/frontier -/// ingress every shard pays regardless of owned size; without it a -/// pure ratio calibrated on large shards under-reserves small ones -/// (measured: 151 ISLB shards at 1.1-4.8 GiB estimated ran to 175 GB -/// actual against a 110 GiB budget — an OOM on a real 128 GB box). -/// Fit on the two ISLB partitions (2026-08-22, measured in-flight -/// RSS): 5.7 MB owned -> ~9.6 GB and 1.4 MB -> ~5.5 GB, giving -/// ~4 GiB + ~1000x; both terms rounded up for cross-shard spread. -const EXEC_RSS_FIXED_BYTES: usize = 9 * (1 << 29); // 4.5 GiB -// Two calibrations, each accurate in its own regime, combined as a MAX -// in `exec_rss_estimate` because the per-owned-byte execution footprint -// is env-dependent and the gate's contract is NEVER OOM: -// - The affine fit (4.5 GiB + 1100x) measured on ISLB's small shards -// (1.4-5.7 MB owned; a pure ratio under-reserved them and OOM'd a -// 128 GB box). -// - The pure ratio (2500x, ~2300x measured + margin) validated on -// Mathlib's full-width 233-shard batch at +2% of estimate; the -// affine slope alone under-reserved Mathlib-class shards and -// over-admitted a 132-shard full-width batch to 486/495 GB -// (OOM, 2026-08-29 — the first Mathlib full-width run under the -// affine constant). -// The max reproduces each fit where it was measured: small shards take -// the affine branch (ISLB bench reservations unchanged), large shards -// the ratio branch. -const EXEC_RSS_PER_OWNED_BYTE: usize = 1100; -const EXEC_RSS_RATIO_PER_OWNED_BYTE: usize = 2500; - -/// Per-shard execution-RSS reserve: the max of the two measured fits -/// (see the constants above). -fn exec_rss_estimate(owned_bytes: usize) -> usize { - EXEC_RSS_FIXED_BYTES - .saturating_add(owned_bytes.saturating_mul(EXEC_RSS_PER_OWNED_BYTE)) - .max(owned_bytes.saturating_mul(EXEC_RSS_RATIO_PER_OWNED_BYTE)) -} - -/// FFI: the detected prover/execution RAM budget in bytes -/// ([`detected_ram_budget`]: [`ixon::shard::RAM_USABLE_FRAC`] of -/// `MemAvailable`), or `0` when `/proc/meminfo` is unreadable — the caller -/// decides whether to fail closed. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_detected_ram_budget() --> lean_ffi::object::LeanIOResult { - let bytes = detected_ram_budget().unwrap_or(0); - lean_ffi::object::LeanIOResult::ok(LeanOwned::box_u64(bytes as u64)) -} - -/// Detected prover/execution RAM budget: -/// [`ixon::shard::RAM_USABLE_FRAC`] of `MemAvailable`, reserving -/// the rest for the OS. `None` (no gate) when meminfo is unreadable — -/// disabling the check beats guessing at it. -/// The trace-shard cell budget the prover plans to, from -/// `AIUR_TRACE_SHARD_MAX_CELLS`; 0 when unset. -pub(crate) fn trace_shard_max_cells() -> usize { - std::env::var("AIUR_TRACE_SHARD_MAX_CELLS") - .ok() - .and_then(|v| v.parse::().ok()) - .unwrap_or(0) -} - -/// What records may occupy within one prover's host budget: the budget -/// less the prover's own working set (two shard witnesses at the cell -/// budget, one being proven and one prepared ahead, plus the upload -/// staging). -pub(crate) fn record_budget(max_ram_bytes: usize, cells: usize) -> usize { - max_ram_bytes.saturating_sub(2 * 8 * cells + (256 << 20)) -} - -/// One execution's equal share of [`record_budget`] when `in_flight` -/// executions and prepared items hold records at once: the hard cap each -/// execution runs under. -pub(crate) fn record_share( - max_ram_bytes: usize, - cells: usize, - in_flight: usize, -) -> usize { - record_budget(max_ram_bytes, cells) / in_flight.max(1) -} - -#[allow(clippy::cast_precision_loss, clippy::cast_possible_truncation)] -#[allow(clippy::cast_sign_loss)] // MemAvailable and the fraction are positive -pub(crate) fn detected_ram_budget() -> Option { - available_ram_bytes() - .map(|b| (b as f64 * ixon::shard::RAM_USABLE_FRAC) as usize) -} - -/// This process's resident set from `/proc/self/status`, in bytes; `None` -/// where it is unreadable. -fn process_rss_bytes() -> Option { - let s = std::fs::read_to_string("/proc/self/status").ok()?; - let rest = s.lines().find_map(|l| l.strip_prefix("VmRSS:"))?; - let kib: usize = rest.trim().trim_end_matches("kB").trim().parse().ok()?; - Some(kib * 1024) -} - -/// `MemAvailable` from `/proc/meminfo`, in bytes (Linux; includes -/// reclaimable page cache). `None` if unreadable — the caller then -/// disables the gate rather than guessing. -fn available_ram_bytes() -> Option { - let s = std::fs::read_to_string("/proc/meminfo").ok()?; - let rest = s.lines().find_map(|l| l.strip_prefix("MemAvailable:"))?; - let kib: usize = rest.trim().trim_end_matches("kB").trim().parse().ok()?; - Some(kib * 1024) -} - -// cast_precision_loss: the [ram-gate] line renders byte counts in GiB -// for humans; f64's 52-bit mantissa is exact far past any real budget. -#[allow(clippy::cast_precision_loss)] -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_toplevel_shard_check_batch( - toplevel_obj: LeanAiurToplevel>, - fun_idx: LeanNat>, - env_handle: LeanExternal< - ixvm_codegen::env_handle::EnvHandle, - LeanBorrowed<'_>, - >, - shards_blob: LeanByteArray>, - use_bytecode: bool, - jobs: LeanNat>, - commitment_parameters: LeanAiurCommitmentParameters>, - fri_parameters: LeanAiurFriParameters>, - max_ram_bytes: LeanNat>, -) -> LeanExcept { - use rayon::prelude::*; - let toplevel = decode_toplevel(&toplevel_obj); - let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let jobs = lean_unbox_nat_as_usize(jobs.inner()); - let max_ram_bytes = lean_unbox_nat_as_usize(max_ram_bytes.inner()); - let shards = match decode_addr_lists(shards_blob.as_bytes()) { - Ok(v) => v, - Err(e) => return LeanExcept::error_string(&e), - }; - let env = &env_handle.get().env; - // One system build for the whole batch: the RAM model reads circuit - // widths and lookup counts off the compiled circuits. - let system = AiurSystem::build( - decode_toplevel(&toplevel_obj), - decode_commitment_parameters(&commitment_parameters), - decode_fri_parameters(&fri_parameters), - ); - // RAM-gated admission: reserve each shard's estimated execution RSS - // (fixed ingress cost + owned serialized bytes x measured slope) - // against most of the RAM available at entry. Memory in flight — - // not `jobs` — is what bounds peak RSS; an unreadable meminfo - // disables the gate. - let estimates: Vec = shards - .iter() - .map(|owned| { - exec_rss_estimate( - owned - .iter() - .filter_map(|a| env.get_const_bytes(a).map(|b| b.len())) - .sum::(), - ) - }) - .collect(); - let gate = RamGate { - reserved: std::sync::Mutex::new(0), - cv: std::sync::Condvar::new(), - budget: detected_ram_budget().unwrap_or(usize::MAX), - }; - { - let gib = 1024.0 * 1024.0 * 1024.0; - let min = estimates.iter().min().copied().unwrap_or(0); - let max = estimates.iter().max().copied().unwrap_or(0); - eprintln!( - "[ram-gate] budget {:.1} GiB, {} shard estimates: min {:.1} / max {:.1} GiB", - gate.budget as f64 / gib, - estimates.len(), - min as f64 / gib, - max as f64 / gib, - ); - } - let check_batch = || -> Vec<(String, usize, usize)> { - let (binding_err, mut shard_results) = rayon::join( - || -> Option { - if shards.len() <= 1 { - return None; - } - let Ok((_claim, input, mut io_buffer)) = - ixvm_codegen::aiur_ixvm_witness::build_binding_witness(env) - else { - return None; - }; - dispatch_execute( - &toplevel, - fun_idx, - input, - &mut io_buffer, - use_bytecode, - ) - .err() - .map(|e| format!("binding check: {e}")) - }, - || -> Vec<(String, usize, usize)> { - shards - .par_iter() - .zip(estimates.par_iter()) - .map(|(owned, est)| { - gate.acquire(*est); - let result = match ixvm_codegen::aiur_ixvm_witness::build_shard_check_env_witness_with( - env, - owned, - shards.len() > 1, - ) { - Err(e) => (format!("witness build: {e}"), 0, 1), - Ok((_claim, input, mut io_buffer)) => match dispatch_execute( - &toplevel, - fun_idx, - input, - &mut io_buffer, - use_bytecode, - ) { - Err(e) => (e, 0, 1), - // Both reductions happen here, while the record is - // still owned by this task: it is dropped before - // `gate.release`, so admission keeps bounding peak RSS by - // the shards in flight rather than by the whole partition. - Ok((record, _output)) => { - let peak = system.peak_prove_bytes(&record).peak; - let parts = if max_ram_bytes > 0 && peak > max_ram_bytes { - system.suggested_split_parts(&record, max_ram_bytes) - } else { - 1 - }; - (String::new(), peak, parts) - }, - }, - }; - gate.release(*est); - result - }) - .collect() - }, - ); - if let Some(err) = binding_err - && let Some(first) = shard_results.first_mut() - && first.0.is_empty() - { - first.0 = err; - } - shard_results - }; - let results = if jobs == 0 { - check_batch() - } else { - let pool = match rayon::ThreadPoolBuilder::new().num_threads(jobs).build() { - Ok(p) => p, - Err(e) => { - return LeanExcept::error_string(&format!("rayon pool: {e}")); - }, - }; - pool.install(check_batch) - }; - let arr = LeanArray::alloc(results.len()); - for (i, (err, peak, parts)) in results.iter().enumerate() { - let row = LeanAiurShardResult::alloc(0); - row.set_obj(0, LeanString::new(err)); - row.set_obj(1, LeanOwned::box_usize(*peak)); - row.set_obj(2, LeanOwned::box_usize(*parts)); - arr.set(i, row); - } - LeanExcept::ok(arr) -} - -/// `Bytecode.Toplevel.shardCheckWithEnv`: per-shard check against a -/// Rust-owned `EnvHandle`. See `checkAddrWithEnv` for `use_bytecode` -/// semantics. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_toplevel_shard_check_with_env( - toplevel: LeanAiurToplevel>, - fun_idx: LeanNat>, - env_handle: LeanExternal< - ixvm_codegen::env_handle::EnvHandle, - LeanBorrowed<'_>, - >, - owned_blob: LeanByteArray>, - use_bytecode: bool, - assume_binding: bool, -) -> LeanExcept { - let toplevel = decode_toplevel(&toplevel); - let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let owned = match decode_owned_blob(&owned_blob) { - Ok(v) => v, - Err(e) => return LeanExcept::error_string(&e), - }; - let env = &env_handle.get().env; - - // Migration Phase 1: the generated kernel is the kernel, so the default - // shard entrypoint builds the the kernel witness (thin frontier + wrapper - // augmentation). - let (_claim, input, mut io_buffer) = - match ixvm_codegen::aiur_ixvm_witness::build_shard_check_env_witness_with( - env, - &owned, - assume_binding, - ) { - Ok(t) => t, - Err(e) => { - return LeanExcept::error_string(&format!("witness build: {e}")); - }, - }; - - let (query_record, output) = match dispatch_execute( - &toplevel, - fun_idx, - input, - &mut io_buffer, - use_bytecode, - ) { - Ok(p) => p, - Err(e) => return LeanExcept::error_string(&e), - }; - - LeanExcept::ok(build_execute_result( - &output, - &io_buffer, - &query_record, - &toplevel, - )) -} - -/// `AiurSystem.proveAddrWithEnv`: per-claim prove against a -/// Rust-owned `EnvHandle`. Returns a `ProveEnvResult` — the claim's -/// wire bytes are serialized via `ixon::Claim::put` so Lean can -/// deserialize directly into `Ix.Claim` without reconstructing it -/// from the target addr. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_system_prove_addr_with_env( - aiur_system_obj: LeanExternal>, - fun_idx: LeanNat>, - env_handle: LeanExternal< - ixvm_codegen::env_handle::EnvHandle, - LeanBorrowed<'_>, - >, - addr_bytes: LeanByteArray>, - use_bytecode: bool, - assume_binding: bool, -) -> LeanExcept { - ffi_catch_unwind_except("AiurSystem.proveAddrWithEnv", || { - let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let addr = match decode_addr(&addr_bytes) { - Ok(a) => a, - Err(e) => return LeanExcept::error_string(&e), - }; - let env = &env_handle.get().env; - - let (claim, input, mut io_buffer) = - match ixvm_codegen::aiur_ixvm_witness::build_claim_check_witness_with( - env, - &addr, - assume_binding, - ) { - Ok(t) => t, - Err(e) => { - return LeanExcept::error_string(&format!("witness build: {e}")); - }, - }; - - // `use_bytecode` selects the generic Aiur bytecode interpreter over the - // codegen'd IxVM kernel (same toggle as - // `rs_aiur_toplevel_check_addr_with_env`). - let (_aiur_claim_arr, proof) = if use_bytecode { - aiur_system_obj.get().prove_ixvm( - fun_idx, - &input, - &mut io_buffer, - |toplevel, fun_idx, input, io_buffer| { - toplevel.execute(fun_idx, input, io_buffer) - }, - ) - } else { - aiur_system_obj.get().prove_ixvm( - fun_idx, - &input, - &mut io_buffer, - |toplevel, fun_idx, input, io_buffer| { - ixvm_codegen::aiur_ixvm_runner::execute_ixvm( - toplevel, fun_idx, input, io_buffer, - ) - }, - ) - }; - - LeanExcept::ok(build_prove_env_result(&claim, proof, &io_buffer)) - }) -} - -/// `AiurSystem.shardProveWithEnv`: per-shard prove against a Rust-owned -/// `EnvHandle`, executing ONCE and proving from that record. -/// -/// `max_ram_bytes` is a per-shard prover-RAM budget checked against the -/// executed record's projected peak, in the gap between execution and -/// the witness phase. `0` means "detect": 85% of `MemAvailable`, the -/// same policy the check batch's RAM gate uses. An unreadable -/// `/proc/meminfo` disables the check rather than guessing at it. -/// -/// Over budget, the record is dropped and `proof` comes back as `none` -/// with the measured `peakBytes` and `suggestedParts` — the part count -/// the peak model projects will fit the budget -/// ([`AiurSystem::suggested_split_parts`], measured on the record while -/// it still exists). That is a RESULT, not an error: the caller's -/// answer is to cut the shard into that many parts and prove those. -/// Learning it here costs one execution instead of an OOM part-way -/// through an FFT. `suggestedParts` is `1` whenever the prove ran. -/// -/// `exec_only` stops after execution + measurement: `proof` is `none` -/// either way, and `suggestedParts` is 1 exactly when the peak fits — -/// the split loop runs on executions alone, no STARK ever starts. -/// -/// `trace_shards` lets an over-budget record be proven as a batch of -/// trace shards instead of being split into parts, whenever some shard -/// count fits the budget; `peakBytes` is then the heaviest shard's -/// projection and `suggestedParts` stays 1. `retention` overrides what the -/// batch keeps across its barrier: 1 retains every shard's stage 1, 2 -/// regenerates each shard for round two, anything else lets the RAM model -/// choose (retain when the retained batch fits the budget). -/// -/// Returns `(claimBytes, proof?, peakBytes, suggestedParts)`. The final IO buffer is -/// deliberately NOT returned: it is the shard's whole ingested byte -/// scope, both Lean callers discarded it, and marshalling it back is -/// pure cost on the largest buffers in the system. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_system_shard_prove_with_env( - aiur_system_obj: LeanExternal>, - fun_idx: LeanNat>, - env_handle: LeanExternal< - ixvm_codegen::env_handle::EnvHandle, - LeanBorrowed<'_>, - >, - owned_blob: LeanByteArray>, - max_ram_bytes: LeanNat>, - exec_only: bool, - trace_shards: bool, - retention: LeanNat>, - assume_binding: bool, -) -> LeanExcept { - ffi_catch_unwind_except("AiurSystem.shardProveWithEnv", || { - 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()) { - 1 => Some(Retention::Retain), - 2 => Some(Retention::Regenerate), - _ => None, - }; - let owned = match decode_owned_blob(&owned_blob) { - Ok(v) => v, - Err(e) => return LeanExcept::error_string(&e), - }; - let env = &env_handle.get().env; - - let (claim, input, mut io_buffer) = - match ixvm_codegen::aiur_ixvm_witness::build_shard_check_env_witness_with( - env, - &owned, - assume_binding, - ) { - Ok(t) => t, - Err(e) => { - return LeanExcept::error_string(&format!("witness build: {e}")); - }, - }; - - // 0 = detect. Matching the check batch's gate keeps one RAM policy in - // the system rather than two that can disagree. - let budget = if max_ram_bytes > 0 { - Some(max_ram_bytes) - } else { - detected_ram_budget() - }; - let proved = aiur_system_obj.get().prove_ixvm_within_budget( - fun_idx, - &input, - &mut io_buffer, - |toplevel, fun_idx, input, io_buffer| { - ixvm_codegen::aiur_ixvm_runner::execute_ixvm( - toplevel, fun_idx, input, io_buffer, - ) - }, - budget, - exec_only, - trace_shards, - retention, - ); - let (proof, peak, parts) = match proved { - GatedProve::Proved { proof, peak, .. } => ( - LeanOption::some(LeanExternal::alloc(&AIUR_PROOF_CLASS, proof)), - peak, - 1, - ), - GatedProve::Split { peak, parts } => (LeanOption::none(), peak, parts), - GatedProve::Measured { peak } => (LeanOption::none(), peak, 1), - GatedProve::Failed(error) => { - return LeanExcept::error_string(&format!("execution failed: {error}")); - }, - }; - drop(io_buffer); - - let mut claim_bytes: Vec = Vec::new(); - claim.put(&mut claim_bytes); - let result = LeanAiurShardProveResult::alloc(0); - result.set_obj(4, LeanByteArray::from_bytes(&[])); - result.set_obj(0, LeanByteArray::from_bytes(&claim_bytes)); - result.set_obj(1, proof); - result.set_obj(2, LeanOwned::box_usize(peak)); - result.set_obj(3, LeanOwned::box_usize(parts)); - LeanExcept::ok(result) - }) -} - -/// `AiurSystem.shardProveAheadWithEnv`: several shard claims proven in -/// manifest order, each from one execution, with the executions running -/// ahead of the prover on threads — `exec_jobs` at once (`0`: one per -/// core). `owners_blob` is the layout of [`decode_owners_blob`], one -/// owned set per shard; `labels_blob` holds each shard's manifest index -/// as a `u32`, for the lines it prints. Every proof is planned as trace -/// shards within `max_ram_bytes` (`0`: detect). A finished proof and its -/// claim are written to the store under `store_dir` and, unless -/// `index_dir` is empty, recorded in the shard-proof index under the -/// claim digest before the next shard is proven, so a killed run keeps -/// every proof it finished. Returns, per shard: the claim's wire bytes, -/// the proof wrapper's store address (hex) and the heaviest shard's -/// projected peak. Each claim assumes the environment's binding meets the -/// specifications (validator 4) when `assume_binding`, and validates it -/// otherwise. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_system_shard_prove_ahead_with_env( - aiur_system_obj: LeanExternal>, - fun_idx: LeanNat>, - env_handle: LeanExternal< - ixvm_codegen::env_handle::EnvHandle, - LeanBorrowed<'_>, - >, - owners_blob: LeanByteArray>, - labels_blob: LeanByteArray>, - max_ram_bytes: LeanNat>, - retention: LeanNat>, - exec_jobs: LeanNat>, - store_dir: LeanString>, - index_dir: LeanString>, - assume_binding: bool, -) -> LeanExcept { - ffi_catch_unwind_except("AiurSystem.shardProveAheadWithEnv", || { - 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 exec_jobs = lean_unbox_nat_as_usize(exec_jobs.inner()); - let retention = match lean_unbox_nat_as_usize(retention.inner()) { - 1 => Some(Retention::Retain), - 2 => Some(Retention::Regenerate), - _ => None, - }; - let owners = match decode_owners_blob(&owners_blob) { - Ok(owners) => owners, - Err(e) => return LeanExcept::error_string(&e), - }; - let labels: Vec = labels_blob - .as_bytes() - .as_chunks::<4>() - .0 - .iter() - .map(|c| u32::from_le_bytes(*c)) - .collect(); - if labels.len() != owners.len() { - return LeanExcept::error_string("one label per shard expected"); - } - let index_dir: String = index_dir.as_str().to_owned(); - let store_dir: String = store_dir.as_str().to_owned(); - let index_path = std::path::PathBuf::from(&index_dir); - let store_path = std::path::PathBuf::from(&store_dir); - let proven = prove_shards_ahead( - aiur_system_obj.get(), - &env_handle.get().env, - fun_idx, - &owners, - &labels, - max_ram_bytes, - retention, - exec_jobs, - &store_path, - (!index_dir.is_empty()).then_some(index_path.as_path()), - assume_binding, - ); - let proven = match proven { - Ok(proven) => proven, - Err(e) => return LeanExcept::error_string(&e), - }; - let arr = LeanArray::alloc(proven.len()); - for (i, (claim_bytes, address, peak)) in proven.iter().enumerate() { - let row = LeanAiurShardProvenAhead::alloc(0); - row.set_obj(0, LeanByteArray::from_bytes(claim_bytes)); - row.set_obj(1, LeanString::new(&address.hex())); - row.set_obj(2, LeanOwned::box_usize(*peak)); - arr.set(i, row); - } - LeanExcept::ok(arr) - }) -} - -/// One shard's execution, planned to trace shards within the budget and -/// ready to prove. -type Prepared = (ixon::Claim, Vec, aiur::synthesis::PreparedProve); - -/// Why a shard did not prepare: its record outgrew the byte cap it ran -/// under (answered by a rerun with a larger cap), or anything else. -enum PrepareFailure { - OverRecordBudget { bytes: usize, cap: usize }, - Other(String), -} - -/// Proves `owners`' shard claims in order with executions running ahead: -/// shard `k + 1..` execute on threads (`exec_jobs` at once) while shard -/// `k` proves, and each proof is persisted as soon as it exists. Peak host -/// memory is the prover's budget plus the records in flight, so -/// `exec_jobs` is the memory knob; the cgroup cap the run goes under is -/// the backstop. -#[allow(clippy::too_many_arguments)] -fn prove_shards_ahead( - system: &AiurSystem, - env: &ixon::env::Env, - fun_idx: usize, - owners: &[Vec
], - labels: &[u32], - max_ram_bytes: usize, - retention: Option, - exec_jobs: usize, - store_dir: &std::path::Path, - index_dir: Option<&std::path::Path>, - assume_binding: bool, -) -> Result, Address, usize)>, String> { - let count = owners.len(); - let cores = std::thread::available_parallelism().map_or(1, usize::from); - let jobs = - if exec_jobs == 0 { cores } else { exec_jobs }.clamp(1, count.max(1)); - let budget = - if max_ram_bytes > 0 { Some(max_ram_bytes) } else { detected_ram_budget() }; - eprintln!( - "[prove-ahead] {count} shards, {jobs} executing at a time ahead of the prover" - ); - // The record budget is the host budget less the prover's own working - // set (two shard witnesses at the cell budget, one proving and one - // prepared ahead, plus upload staging). Every execution ahead gets an - // equal share of it as a hard cap on its record, enforced as the record - // grows; one that reaches its share stops cleanly and reruns alone with - // the whole record budget once nothing else executes. Nothing about a - // record's size is predicted or remembered. - let cells = trace_shard_max_cells(); - let record_budget = budget.map(|b| record_budget(b, cells)); - let share = budget.map(|b| record_share(b, cells, jobs + 1)); - if let (Some(record_budget), Some(share)) = (record_budget, share) { - eprintln!( - "[prove-ahead] record budget {} GiB: {} GiB per execution with {jobs} ahead; an execution over its share reruns alone", - super::aggregate::format_gib(record_budget), - super::aggregate::format_gib(share) - ); - } - let run_started = std::time::Instant::now(); - let prepare = |k: usize| -> Result { - let label = labels[k]; - let started = std::time::Instant::now(); - let (claim, input, mut io) = - ixvm_codegen::aiur_ixvm_witness::build_shard_check_env_witness_with( - env, - &owners[k], - assume_binding, - ) - .map_err(|e| { - PrepareFailure::Other(format!("shard {label}: witness build: {e}")) - })?; - let prepared = system.prepare_ixvm_within_budget( - fun_idx, - &input, - &mut io, - |toplevel, fun_idx, input, io_buffer| { - ixvm_codegen::aiur_ixvm_runner::execute_ixvm( - toplevel, fun_idx, input, io_buffer, - ) - }, - budget, - true, - retention, - ); - let prepared = match prepared { - Ok(prepared) => prepared, - Err(GatedProve::Split { peak, .. }) => { - return Err(PrepareFailure::Other(format!( - "shard {label}: no trace-shard count fits the budget (whole-execution peak {} B) — raise --max-ram", - peak - ))); - }, - Err(GatedProve::Failed( - aiur::execute::ExecError::RecordBudgetExceeded { bytes, cap }, - )) => { - return Err(PrepareFailure::OverRecordBudget { bytes, cap }); - }, - Err(GatedProve::Failed(error)) => { - return Err(PrepareFailure::Other(format!( - "shard {label}: execution failed: {error}" - ))); - }, - Err(_) => { - return Err(PrepareFailure::Other(format!( - "shard {label}: execution did not prepare a proof" - ))); - }, - }; - let mut claim_bytes = Vec::new(); - claim.put(&mut claim_bytes); - eprintln!( - "[prove-ahead] shard {label}: executed in {:.1}s (at +{:.1}s), {} trace shards, {} B record", - started.elapsed().as_secs_f64(), - run_started.elapsed().as_secs_f64(), - prepared.plan.num_shards(), - aiur::execute::record_retained_bytes(&prepared.record) - ); - Ok((claim, claim_bytes, prepared)) - }; - // Executors report on a channel and the prover takes whichever record - // is ready, so a slow shard never holds the GPU while others wait. - let (done_tx, done_rx) = std::sync::mpsc::channel::<( - usize, - bool, - Result, - )>(); - let mut proven: Vec, Address, usize)>> = - (0..count).map(|_| None).collect(); - std::thread::scope(|scope| -> Result<(), String> { - let mut next = 0usize; - let mut in_flight = 0usize; - let mut done = 0usize; - // Shards that outgrew their share, to rerun alone once nothing else - // is executing; while one is pending, nothing new starts ahead, so the - // running executions drain for it. - let mut alone: std::collections::VecDeque = - std::collections::VecDeque::new(); - let mut alone_running = false; - let prepare = &prepare; - let done_tx = &done_tx; - let spawn = |k: usize, cap: Option, is_alone: bool| { - let done_tx = done_tx.clone(); - scope.spawn(move || { - aiur::execute::set_record_byte_cap(cap); - let result = prepare(k); - let _ = done_tx.send((k, is_alone, result)); - }); - }; - // Admission: an alone rerun waits until nothing else is executing and - // runs by itself; otherwise up to `jobs` executions run ahead at their - // share. - // Run before each proof as well as at the start, so a slot freed by a - // record the prover takes is refilled while that record proves. - macro_rules! admit { - () => { - if !alone_running { - if in_flight == 0 && !alone.is_empty() { - let k = alone.pop_front().expect("nonempty"); - eprintln!( - "[prove-ahead] shard {}: executing alone with the whole record budget", - labels[k] - ); - spawn(k, record_budget, true); - in_flight += 1; - alone_running = true; - } else if alone.is_empty() { - while next < count && in_flight < jobs { - spawn(next, share, false); - next += 1; - in_flight += 1; - } - } - } - }; - } - admit!(); - while done < count { - let (k, was_alone, prepared) = - done_rx.recv().map_err(|e| format!("execution channel closed: {e}"))?; - in_flight -= 1; - if was_alone { - alone_running = false; - } - let (claim, claim_bytes, prepared) = match prepared { - Ok(prepared) => prepared, - Err(PrepareFailure::OverRecordBudget { bytes, cap }) if !was_alone => { - eprintln!( - "[prove-ahead] shard {}: record reached {bytes} B, over its {cap} B share; queued to rerun alone", - labels[k] - ); - alone.push_back(k); - admit!(); - continue; - }, - Err(PrepareFailure::OverRecordBudget { bytes, cap }) => { - return Err(format!( - "shard {}: record reached {bytes} B, over the whole record budget of {cap} B even alone; cut this shard finer or raise --max-ram", - labels[k] - )); - }, - Err(PrepareFailure::Other(error)) => return Err(error), - }; - // The next execution starts before this proof does. - admit!(); - let label = labels[k]; - let started = std::time::Instant::now(); - let (_, proof, peak) = system.prove_prepared(prepared); - let proof_bytes = proof - .to_bytes() - .map_err(|e| format!("shard {label}: proof serialization: {e}"))?; - let wrapper = ixon::Proof::new(claim, proof_bytes); - let mut wrapper_bytes = Vec::new(); - wrapper.put(&mut wrapper_bytes); - super::aggregate::write_store(store_dir, &claim_bytes)?; - let address = super::aggregate::write_store(store_dir, &wrapper_bytes)?; - let digest = Address::hash(&claim_bytes); - if let Some(dir) = index_dir { - let temporary = - dir.join(format!("{}.tmp.{}", digest.hex(), std::process::id())); - std::fs::write(&temporary, format!("{}\n", address.hex())) - .and_then(|()| std::fs::rename(&temporary, dir.join(digest.hex()))) - .map_err(|e| format!("shard {label}: shard-proof index: {e}"))?; - } - eprintln!( - "[prove-ahead] shard {label}: proven in {:.1}s (at +{:.1}s), heaviest shard peak {} B", - started.elapsed().as_secs_f64(), - run_started.elapsed().as_secs_f64(), - peak - ); - println!("claim {}", digest.hex()); - println!("{}", address.hex()); - proven[k] = Some((claim_bytes, address, peak)); - done += 1; - } - Ok(()) - })?; - proven - .into_iter() - .enumerate() - .map(|(k, row)| { - row.ok_or_else(|| format!("shard {} was not proven", labels[k])) - }) - .collect() -} - -/// `AiurSystem.proveEnvDistributed`: the whole environment as ONE claim, -/// `CheckEnv(root, none)`, proven from several worker records -/// (trace-sharding design §13.3). `owners_blob` is a `u32` worker count, -/// then a `u32` address count per worker, then every worker's owned -/// addresses (32 bytes each) in worker order. Worker 0 runs `verify_claim` -/// and defers every `check_owned` call for a constant it does not own; -/// worker `r` runs `check_owned` over its chunk (the constants it owns), -/// in pointer namespace `r`. The workers execute in parallel, the deferred calls' -/// counts are absorbed by their owners, and the records are proven as one -/// batch, each planned to `max_cells` committed cells (`0`: one shard per -/// record). `plan_only` stops after the static caller graph and the commit -/// order, reporting each worker's owned constants, byte scope and callers -/// and the largest group of mutually calling workers, which is how many -/// records the first round holds at once; `exec_only` stops after execution -/// and the absorption of the deferred calls, reporting each record's size. -/// Both leave `proof` `none`. Same result shape as `shardProveWithEnv`, with -/// `peakBytes` 0 and `suggestedParts` 1. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_system_prove_env_distributed( - aiur_system_obj: LeanExternal>, - verify_idx: LeanNat>, - check_owned_idx: LeanNat>, - env_handle: LeanExternal< - ixvm_codegen::env_handle::EnvHandle, - LeanBorrowed<'_>, - >, - owners_blob: LeanByteArray>, - max_cells: LeanNat>, - plan_only: bool, - exec_only: bool, - exec_jobs: LeanNat>, - max_ram_bytes: LeanNat>, - measured_blob: LeanByteArray>, -) -> LeanExcept { - ffi_catch_unwind_except("AiurSystem.proveEnvDistributed", || { - let verify_idx = lean_unbox_nat_as_usize(verify_idx.inner()); - let check_owned_idx = lean_unbox_nat_as_usize(check_owned_idx.inner()); - let max_cells = lean_unbox_nat_as_usize(max_cells.inner()); - let exec_jobs = lean_unbox_nat_as_usize(exec_jobs.inner()); - let max_ram_bytes = lean_unbox_nat_as_usize(max_ram_bytes.inner()); - let measured: Vec = measured_blob - .as_bytes() - .as_chunks::<8>() - .0 - .iter() - .map(|c| { - usize::try_from(u64::from_le_bytes(*c)).expect("measured size fits") - }) - .collect(); - let owners = match decode_owners_blob(&owners_blob) { - Ok(owners) => owners, - Err(e) => return LeanExcept::error_string(&e), - }; - let proved = prove_env_distributed( - aiur_system_obj.get(), - &env_handle.get().env, - verify_idx, - check_owned_idx, - &owners, - max_cells, - plan_only, - exec_only, - exec_jobs, - max_ram_bytes, - &measured, - ); - let (claim_bytes, proof, worker_bytes) = match proved { - Ok(proved) => proved, - Err(e) => return LeanExcept::error_string(&e), - }; - let result = LeanAiurShardProveResult::alloc(0); - let mut blob = Vec::with_capacity(8 * worker_bytes.len()); - for bytes in &worker_bytes { - blob.extend_from_slice(&bytes.to_le_bytes()); - } - result.set_obj(4, LeanByteArray::from_bytes(&blob)); - result.set_obj(0, LeanByteArray::from_bytes(&claim_bytes)); - result.set_obj( - 1, - match proof { - Some(proof) => { - LeanOption::some(LeanExternal::alloc(&AIUR_PROOF_CLASS, proof)) - }, - None => LeanOption::none(), - }, - ); - result.set_obj(2, LeanOwned::box_usize(0)); - result.set_obj(3, LeanOwned::box_usize(1)); - LeanExcept::ok(result) - }) -} - -/// `u32 W`, `u32` counts, then the addresses (see -/// `rs_aiur_system_prove_env_distributed`). -fn decode_owners_blob( - blob: &LeanByteArray>, -) -> Result>, String> { - let bytes = blob.as_bytes(); - let word = |at: usize| -> Result { - let chunk: [u8; 4] = bytes - .get(at..at + 4) - .and_then(|c| c.try_into().ok()) - .ok_or_else(|| "owners_blob: truncated header".to_string())?; - Ok(u32::from_le_bytes(chunk) as usize) - }; - let workers = word(0)?; - let counts: Vec = - (0..workers).map(|w| word(4 + 4 * w)).collect::>()?; - let mut at = 4 + 4 * workers; - let mut owners = Vec::with_capacity(workers); - for count in counts { - let end = at + 32 * count; - let slice = bytes - .get(at..end) - .ok_or_else(|| "owners_blob: truncated addresses".to_string())?; - owners.push( - slice - .as_chunks::<32>() - .0 - .iter() - .map(|c| Address::from_slice(c).expect("32-byte chunk is an address")) - .collect(), - ); - at = end; - } - if at != bytes.len() { - return Err("owners_blob: trailing bytes".into()); - } - Ok(owners) -} - -/// What a worker's execution produced: its record and IO buffer while they -/// are kept, and always its deferred calls and its output. -struct Executed { - record: Option<(Box, Box)>, - /// Host bytes the record and its IO retain. - bytes: usize, - deferred: FxHashMap, u64>, - output: Vec, -} - -/// The order records are committed in, callers before callees: the workers -/// that may call into a worker (`callers`) must have executed before it -/// commits, so its rows carry the calls' multiplicities. Strongly connected -/// groups of mutually calling workers execute together and commit one after -/// the other; between groups one record at a time is in flight. -fn commit_order(callers: &[Vec]) -> Vec> { - // Tarjan's components over the edges `caller -> callee`. - let n = callers.len(); - let mut callees: Vec> = vec![Vec::new(); n]; - for (callee, cs) in callers.iter().enumerate() { - for &caller in cs { - callees[caller].push(callee); - } - } - struct Tarjan<'a> { - callees: &'a [Vec], - index: Vec>, - low: Vec, - on_stack: Vec, - stack: Vec, - next: usize, - components: Vec>, - } - impl Tarjan<'_> { - fn visit(&mut self, v: usize) { - self.index[v] = Some(self.next); - self.low[v] = self.next; - self.next += 1; - self.stack.push(v); - self.on_stack[v] = true; - for &w in &self.callees[v] { - match self.index[w] { - None => { - self.visit(w); - self.low[v] = self.low[v].min(self.low[w]); - }, - Some(index) if self.on_stack[w] => { - self.low[v] = self.low[v].min(index); - }, - Some(_) => {}, - } - } - if self.low[v] == self.index[v].expect("indexed") { - let mut component = Vec::new(); - loop { - let w = self.stack.pop().expect("stack holds v"); - self.on_stack[w] = false; - component.push(w); - if w == v { - break; - } - } - component.sort_unstable(); - self.components.push(component); - } - } - } - let mut tarjan = Tarjan { - callees: &callees, - index: vec![None; n], - low: vec![0; n], - on_stack: vec![false; n], - stack: Vec::new(), - next: 0, - components: Vec::new(), - }; - for v in 0..n { - if tarjan.index[v].is_none() { - tarjan.visit(v); - } - } - // Tarjan emits components in reverse topological order of `callees` - // edges: a callee's component before its callers'. Reverse for callers - // first. - tarjan.components.reverse(); - tarjan.components -} - -fn prove_env_distributed( - system: &AiurSystem, - env: &ixon::Env, - verify_idx: usize, - check_owned_idx: usize, - owners: &[Vec
], - max_cells: usize, - plan_only: bool, - exec_only: bool, - exec_jobs: usize, - max_ram_bytes: usize, - measured: &[usize], -) -> Result<(Vec, Option, Vec), String> { - use aiur::execute::{Ownership, pointer_stride}; - use ixvm_codegen::aiur_ixvm_runner::execute_ixvm_in; - use ixvm_codegen::aiur_ixvm_witness::{ - EnvCheckStatement, check_owned_key, worker_callers, worker_scopes, - }; - use rustc_hash::FxHashSet; - - if owners.is_empty() { - return Err("no workers".into()); - } - let statement = EnvCheckStatement::new(env)?; - let mut claim_bytes: Vec = Vec::new(); - statement.claim.put(&mut claim_bytes); - let input = statement.digest_key.clone(); - let toplevel = system.toplevel(); - let binding = statement.binding(); - let validator = statement.claim.validator(); - let owned_keys: Vec>> = owners - .iter() - .map(|owned| { - owned.iter().map(|a| check_owned_key(&binding, validator, a)).collect() - }) - .collect(); - let mut owner_of: FxHashMap, usize> = FxHashMap::default(); - for (worker, keys) in owned_keys.iter().enumerate() { - for key in keys { - if owner_of.insert(key.clone(), worker).is_some() { - return Err("a constant is owned by two workers".into()); - } - } - } - let workers = owners.len(); - let cores = std::thread::available_parallelism().map_or(1, usize::from); - let jobs = if exec_jobs == 0 { cores } else { exec_jobs }.min(workers); - let scopes = worker_scopes(env, owners); - let callers = worker_callers(owners, &scopes); - let groups = commit_order(&callers); - let order: Vec = groups.iter().flatten().copied().collect(); - eprintln!( - "[distributed] {workers} workers in {} groups, committed in order {order:?}, {jobs} executing at a time", - groups.len() - ); - if plan_only { - for worker in 0..workers { - eprintln!( - "[distributed] plan: worker {worker} owns {} constants, scope {} constants, callers {:?}", - owners[worker].len(), - scopes[worker].len(), - callers[worker] - ); - } - let largest = groups.iter().map(Vec::len).max().unwrap_or(0); - eprintln!( - "[distributed] plan: {} groups {:?}; the largest holds {largest} records at once in round one, plus one prefetched", - groups.len(), - groups.iter().map(Vec::len).collect::>() - ); - return Ok((claim_bytes, None, Vec::new())); - } - - // One execution of worker `worker`: worker 0 the claimed entry, the - // others their own chunk, each in its own pointer namespace, over a - // fresh IO buffer. Deterministic, so a record can be re-executed for - // its second round; the batch checks the headers agree. - let run_started = std::time::Instant::now(); - let execute = |worker: usize, round: &str| -> Result { - let started = std::time::Instant::now(); - let mut io = statement.worker_io(env, owners, worker); - let mut record = QueryRecord::with_pointer_base( - toplevel, - worker * pointer_stride(workers), - ); - record.ownership = Some(Ownership { - callee: check_owned_idx, - owned: owned_keys[worker].clone(), - }); - let mut output = Vec::new(); - if worker == 0 { - output = - execute_ixvm_in(toplevel, verify_idx, &input, &mut io, &mut record) - .map_err(|e| format!("worker 0: {e}"))?; - } else { - // The chunk's constants run as entries; each registers a - // multiplicity no claim pulls, taken off only once every one has - // run: a zeroed entry would read as a hint to a later constant's - // walk and be replayed, double-counting its callees. - let mut entries: Vec> = Vec::new(); - for addr in &owners[worker] { - let key = check_owned_key(&binding, validator, addr); - let queries = &record.function_queries[check_owned_idx]; - // Reached already through another owned constant's walk. - if queries - .get_index_of(&key) - .is_some_and(|i| queries.mult_at(i) != G::ZERO) - { - continue; - } - execute_ixvm_in(toplevel, check_owned_idx, &key, &mut io, &mut record) - .map_err(|e| format!("worker {worker}: {e}"))?; - entries.push(key); - } - let queries = &mut record.function_queries[check_owned_idx]; - for key in entries { - let i = queries.get_index_of(&key).expect("executed as an entry"); - let (_, multiplicity) = - queries.get_index_mut(i).expect("index just found"); - *multiplicity -= G::ONE; - } - } - // Every table must stay inside the worker's pointer namespace, or its - // pointers collide with the next worker's. - let stride = pointer_stride(workers); - for (width, table) in &record.memory_queries { - if table.len() > stride { - return Err(format!( - "worker {worker}: width-{width} table of {} entries exceeds the \ - pointer namespace of {stride}", - table.len() - )); - } - } - let function_rows: usize = - record.function_queries.iter().map(|q| q.len()).sum(); - let memory_rows: usize = - record.memory_queries.iter().map(|(_, m)| m.len()).sum(); - let io_bytes: usize = io.data.values().map(|arena| 8 * arena.len()).sum(); - eprintln!( - "[distributed] worker {worker}: executed for {round} in {:.1?} (done at +{:.1?}); {function_rows} function queries, {memory_rows} memory entries, {} B retained, {io_bytes} B of IO, {} deferred calls", - started.elapsed(), - run_started.elapsed(), - aiur::execute::record_retained_bytes(&record), - record.deferred.len() - ); - let deferred = record.deferred.clone(); - let bytes = aiur::execute::record_retained_bytes(&record) + io_bytes; - Ok(Executed { - record: Some((Box::new(record), Box::new(io))), - bytes, - deferred, - output, - }) - }; - // What records may occupy on the host: the budget less the prover's own - // working set (two shard witnesses at the cell budget, one being proven - // and one prepared ahead, plus the upload staging), or unbounded when no - // budget is known. - let budget = match max_ram_bytes { - 0 => detected_ram_budget(), - given => Some(given), - } - .map_or(usize::MAX, |budget| record_budget(budget, max_cells)); - let measured: Vec = if measured.len() == workers { - measured.to_vec() - } else { - vec![0; workers] - }; - let mut position = vec![0usize; workers]; - for (at, &worker) in order.iter().enumerate() { - position[worker] = at; - } - eprintln!( - "[distributed] record budget {:.1} GiB ({} executing at most)", - f64::from(u32::try_from(budget >> 20).unwrap_or(u32::MAX)) / 1024.0, - jobs - ); - std::thread::scope(|scope| { - let mut pool = Workers { - scope, - execute: &execute, - jobs, - order: &order, - position: &position, - callers: &callers, - owner_of: &owner_of, - check_owned_idx, - executed: (0..workers).map(|_| None).collect(), - resident: (0..workers).map(|_| None).collect(), - charged: vec![0; workers], - served: vec![0; workers], - in_flight: Vec::new(), - budget, - used: 0, - max_ram: match max_ram_bytes { - 0 => detected_ram_budget().unwrap_or(usize::MAX), - given => given, - }, - measured: &measured, - largest: 0, - }; - if exec_only { - let started = std::time::Instant::now(); - pool.fill(usize::MAX, None)?; - for (at, &worker) in order.iter().enumerate() { - drop(pool.supply(at)?); - // Executed and measured; nothing more is asked of it. - pool.served[worker] = 2; - pool.release(worker); - } - eprintln!( - "[distributed] {workers} workers executed and absorbed in {:.1?}", - started.elapsed() - ); - let sizes: Vec = (0..workers) - .map(|w| pool.executed[w].as_ref().map_or(0, |e| e.bytes as u64)) - .collect(); - return Ok((claim_bytes, None, sizes)); - } - - // Worker 0's output is the claim's; its walk calls into every worker, - // so it executes first, with the window open behind it. - pool.fill(usize::MAX, None)?; - pool.ensure(0, "round one")?; - let output = pool.output(); - let (_, proof) = system.prove_record_supplier( - verify_idx, - &input, - move || output, - workers, - |at| pool.supply(at), - (max_cells > 0).then_some(max_cells), - )?; - Ok((claim_bytes, Some(proof), Vec::new())) - }) -} - -/// A record the driver holds: as executed, or absorbed and shared with the -/// prover, retained for its second round. -enum Resident { - Raw(Box, Box), - Absorbed(std::sync::Arc<(Box, Box)>), -} - -/// The workers' executions, owned by the driver. Executions run ahead of -/// the prover in commit order, at most `jobs` at once and as far as a host -/// budget for records allows once their sizes are known, -/// each record is handed to the prover when its turn comes, and a record -/// stays resident for its second round while the budget has room — evicting -/// the one whose next use is furthest when an execution needs the space — -/// so a worker executes twice only when memory forces it. An execution the -/// prover needs is never refused: it runs even when the budget is spent, -/// which keeps the pipeline ordered and makes the budget a bound on what -/// runs *ahead*, not a guarantee. -struct Workers<'scope, 'env> { - scope: &'scope std::thread::Scope<'scope, 'env>, - execute: - &'env (dyn Fn(usize, &'static str) -> Result + Sync), - /// How many workers execute at once. - jobs: usize, - /// The commit order, and each worker's place in it. - order: &'env [usize], - position: &'env [usize], - /// The workers that may call into each worker. - callers: &'env [Vec], - owner_of: &'env FxHashMap, usize>, - check_owned_idx: usize, - /// Each worker's execution result (the record itself moves to - /// `resident`). - executed: Vec>, - /// Records held by the driver. - resident: Vec>, - /// Bytes charged against the budget for each in-flight or resident record. - charged: Vec, - /// How many times the prover has asked for each worker's record. - served: Vec, - /// Executions started ahead of their turn. - in_flight: Vec<( - usize, - std::thread::ScopedJoinHandle<'scope, Result>, - )>, - /// Host bytes records may occupy at once, and how many they do. - budget: usize, - used: usize, - /// The whole host budget, which the process's resident size must stay - /// under for an execution to run ahead. - max_ram: usize, - /// Each worker's record size as the manifest measured it (0 when it - /// has not been), and the largest record measured in this run, which - /// stands in for an unmeasured one once anything has been. - measured: &'env [usize], - largest: usize, -} - -impl Workers<'_, '_> { - /// The bytes to charge for `worker`'s record before this run measures - /// it: the manifest's measurement, else the largest record measured so - /// far, else nothing (until something is measured only the concurrency - /// ceiling bounds what runs ahead). - fn charge_for(&self, worker: usize) -> usize { - if self.measured[worker] > 0 { self.measured[worker] } else { self.largest } - } - - /// Which run `worker` needs next, if any: its first, or its second when - /// the first was handed over and the record not retained. - fn needs(&self, worker: usize) -> Option<&'static str> { - if self.resident[worker].is_some() - || self.in_flight.iter().any(|(w, _)| *w == worker) - { - return None; - } - match self.served[worker] { - 0 => self.executed[worker].is_none().then_some("round one"), - 1 => Some("round two"), - _ => None, - } - } - - /// Starts `worker`'s execution for `round`, charging its estimate. - fn start(&mut self, worker: usize, round: &'static str) { - let charge = self.charge_for(worker); - self.used += charge; - self.charged[worker] = charge; - let execute = self.execute; - self - .in_flight - .push((worker, self.scope.spawn(move || execute(worker, round)))); - } - - /// Waits for `worker`'s in-flight execution and keeps its record, - /// correcting the charge to the measured size. - fn settle(&mut self, worker: usize) -> Result<(), String> { - let Some(at) = self.in_flight.iter().position(|(w, _)| *w == worker) else { - return Ok(()); - }; - let (_, handle) = self.in_flight.remove(at); - let mut done = handle.join().expect("worker thread panicked")?; - let (record, io) = - done.record.take().expect("a fresh execution keeps its record"); - self.used = self.used - self.charged[worker] + done.bytes; - self.charged[worker] = done.bytes; - self.largest = self.largest.max(done.bytes); - if done.bytes > self.budget { - eprintln!( - "[distributed] worker {worker}: record of {} B exceeds the record budget of {} B on its own; use smaller chunks", - done.bytes, self.budget - ); - } - self.resident[worker] = Some(Resident::Raw(record, io)); - self.executed[worker] = Some(done); - Ok(()) - } - - /// Makes `worker`'s record resident for `round`: already there, or in - /// flight, or executed now. - fn ensure( - &mut self, - worker: usize, - round: &'static str, - ) -> Result<(), String> { - if self.resident[worker].is_none() { - if !self.in_flight.iter().any(|(w, _)| *w == worker) { - // A required execution runs regardless, but retained records - // used after it make room first. - let step = self.next_use(worker); - let charge = self.charge_for(worker); - self.make_room(charge, step, None); - self.start(worker, round); - } - self.settle(worker)?; - } - Ok(()) - } - - /// Drops `worker`'s resident record and its charge. - fn release(&mut self, worker: usize) { - if self.resident[worker].take().is_some() { - self.used -= self.charged[worker]; - self.charged[worker] = 0; - } - } - - /// The commit-order step at which a resident record is next used. - fn next_use(&self, worker: usize) -> usize { - match self.served[worker] { - 0 => self.position[worker], - _ => self.position[worker] + self.order.len(), - } - } - - /// Moves the records of executions that have finished in, so their - /// slots are free and their charges are their measured sizes. - fn harvest(&mut self) -> Result<(), String> { - let done: Vec = self - .in_flight - .iter() - .filter(|(_, handle)| handle.is_finished()) - .map(|(worker, _)| *worker) - .collect(); - for worker in done { - self.settle(worker)?; - } - Ok(()) - } - - /// Releases retained records, furthest next use first, until `charge` - /// more bytes fit both the record budget and the process's resident - /// size beside `--max-ram`; only records used after step `step` and - /// other than `handed` are released. False when nothing more can be. - fn make_room( - &mut self, - charge: usize, - step: usize, - handed: Option, - ) -> bool { - let count = self.order.len(); - loop { - let over_budget = self.used + charge > self.budget; - let over_rss = - process_rss_bytes().is_some_and(|rss| rss + charge > self.max_ram); - if !over_budget && !over_rss { - return true; - } - let evict = (0..count) - .filter(|&w| self.resident[w].is_some() && Some(w) != handed) - .filter(|&w| self.next_use(w) > step) - .max_by_key(|&w| self.next_use(w)); - match evict { - Some(w) => self.release(w), - None => return false, - } - } - } - - /// Starts executions for the workers after step `at` in commit order — - /// wrapping into the second round after the last — while at most `jobs` - /// run and the budget has room, releasing resident records used later - /// than the candidate when that makes room. `handed` is the worker whose - /// record the prover holds and must not be evicted; `at` is `usize::MAX` - /// before the first step. - fn fill(&mut self, at: usize, handed: Option) -> Result<(), String> { - self.harvest()?; - let count = self.order.len(); - let from = at.wrapping_add(1); - for step in from..2 * count { - if self.in_flight.len() >= self.jobs { - break; - } - let next = self.order[step % count]; - let round = if step < count { "round one" } else { "round two" }; - let Some(needed) = self.needs(next) else { continue }; - if needed != round { - continue; - } - let charge = self.charge_for(next); - if !self.make_room(charge, step, handed) { - return Ok(()); - } - self.start(next, round); - } - Ok(()) - } - - /// The record at step `at` of the commit order, as the prover needs it: - /// its callers executed (their deferred calls absorbed into it), resident - /// or executed now, then the window refilled behind it. The record is - /// retained for its second round while the budget allows. - fn supply( - &mut self, - at: usize, - ) -> Result, String> { - let worker = self.order[at]; - let first = self.served[worker] == 0; - let round = if first { "round one" } else { "round two" }; - if first { - for caller in self.callers[worker].clone() { - if self.executed[caller].is_none() { - self.ensure(caller, "round one")?; - } - } - } - self.ensure(worker, round)?; - self.served[worker] += 1; - let supplied = match self.resident[worker].take().expect("ensured above") { - Resident::Raw(mut record, io) => { - let mut into: FxHashMap, u64> = FxHashMap::default(); - for (caller, done) in self.executed.iter().enumerate() { - let Some(done) = done else { continue }; - for (args, &count) in &done.deferred { - let Some(&owner) = self.owner_of.get(args) else { - return Err(format!( - "worker {caller} deferred a constant no worker owns" - )); - }; - if owner == worker { - *into.entry(args.clone()).or_insert(0) += count; - } - } - } - record - .absorb_deferred(self.check_owned_idx, &into) - .map_err(|e| format!("worker {worker}: {e}"))?; - if first { - let shared = std::sync::Arc::new((record, io)); - self.resident[worker] = Some(Resident::Absorbed(shared.clone())); - aiur::synthesis::Supplied::Shared(shared) - } else { - self.used -= self.charged[worker]; - self.charged[worker] = 0; - aiur::synthesis::Supplied::Owned(record, io) - } - }, - Resident::Absorbed(shared) => { - if first { - self.resident[worker] = Some(Resident::Absorbed(shared.clone())); - } else { - self.used -= self.charged[worker]; - self.charged[worker] = 0; - } - aiur::synthesis::Supplied::Shared(shared) - }, - }; - self.fill(at, Some(worker))?; - Ok(supplied) - } - - /// Worker 0's output, the claim's. - fn output(&self) -> Vec { - self.executed[0].as_ref().expect("worker 0 executed first").output.clone() - } -} - -/// `AiurSystem.proveIxVM`: IxVM-native prove path. Same return shape -/// as `rs_aiur_system_prove`, but routes execution through the -/// codegen'd Rust kernel (`execute_generated`) via -/// `AiurSystem::prove_ixvm_within_budget`. The resulting `Proof` is -/// verification-compatible with `rs_aiur_system_prove`. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_system_prove_ixvm( - aiur_system_obj: LeanExternal>, - fun_idx: LeanNat>, - args: LeanArray>, - io_data_arr: LeanArray>, - io_map_arr: LeanArray>, - max_ram_bytes: LeanNat>, - trace_shards: bool, -) -> LeanExcept { - ffi_catch_unwind_except("AiurSystem.proveIxVM", || { - 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 args = args.map(|x| lean_unbox_g(&x)); - let mut io_buffer = decode_io_buffer(&io_data_arr, &io_map_arr); - - let budget = if max_ram_bytes > 0 { - Some(max_ram_bytes) - } else if trace_shards { - detected_ram_budget() - } else { - None - }; - let (claim, proof) = match aiur_system_obj.get().prove_ixvm_within_budget( - fun_idx, - &args, - &mut io_buffer, - |toplevel, fun_idx, input, io_buffer| { - ixvm_codegen::aiur_ixvm_runner::execute_ixvm( - toplevel, fun_idx, input, io_buffer, - ) - }, - budget, - false, - trace_shards, - None, - ) { - GatedProve::Proved { claim, proof, .. } => (claim, proof), - GatedProve::Split { peak, .. } => { - return LeanExcept::error_string(&format!( - "projected prover peak ({peak} B) exceeds RAM budget" - )); - }, - GatedProve::Measured { .. } => { - unreachable!("exec_only is false") - }, - GatedProve::Failed(error) => { - return LeanExcept::error_string(&format!("execution failed: {error}")); - }, - }; - - LeanExcept::ok(build_prove_result(&claim, proof, &io_buffer)) - }) -} - -// ============================================================================= -// Helpers -// ============================================================================= - -/// Prevent Rust panics (including CUDA runtime failures) from unwinding across -/// the Lean C ABI. Lean receives the failure as an ordinary `Except.error`. -pub(super) fn ffi_catch_unwind( - context: &str, - f: impl FnOnce() -> LeanOwned, -) -> LeanExcept { - match std::panic::catch_unwind(std::panic::AssertUnwindSafe(f)) { - Ok(value) => LeanExcept::ok(value), - Err(payload) => { - let message = payload - .downcast_ref::<&str>() - .copied() - .or_else(|| payload.downcast_ref::().map(String::as_str)) - .unwrap_or("unknown Rust panic"); - LeanExcept::error_string(&format!("{context}: {message}")) - }, - } -} - -fn ffi_catch_unwind_except( - context: &str, - f: impl FnOnce() -> LeanExcept, -) -> LeanExcept { - match std::panic::catch_unwind(std::panic::AssertUnwindSafe(f)) { - Ok(result) => result, - Err(payload) => { - let message = payload - .downcast_ref::<&str>() - .copied() - .or_else(|| payload.downcast_ref::().map(String::as_str)) - .unwrap_or("unknown Rust panic"); - LeanExcept::error_string(&format!("{context}: {message}")) - }, - } -} - -/// Build a Lean `Array G` from a slice of field elements. -pub(super) fn build_g_array(values: &[G]) -> LeanArray { - let arr = LeanArray::alloc(values.len()); - for (i, g) in values.iter().enumerate() { - arr.set(i, LeanOwned::box_u64(g.as_canonical_u64())); - } - arr -} - -fn decode_io_buffer( - io_data_arr: &LeanArray>, - io_map_arr: &LeanArray>, -) -> IOBuffer { - let data = decode_io_buffer_data(io_data_arr); - let map = decode_io_buffer_map(io_map_arr); - IOBuffer { data, map } -} - -/// Build a Lean `Array (G × Array G)` enumerating the per-channel -/// data arenas of an `IOBuffer`. -fn build_lean_io_data(io_buffer: &IOBuffer) -> LeanArray { - let arr = LeanArray::alloc(io_buffer.data.len()); - for (i, (channel, arena)) in io_buffer.data.iter().enumerate() { - let channel_box = LeanOwned::box_u64(channel.as_canonical_u64()); - let arena_arr = build_g_array(arena); - let elt = LeanProd::new(channel_box, arena_arr); - arr.set(i, elt); - } - arr -} - -/// Build a Lean `Array ((G × Array G) × IOKeyInfo)` enumerating the -/// channel-keyed info map of an `IOBuffer`. -fn build_lean_io_map(io_buffer: &IOBuffer) -> LeanArray { - let arr = LeanArray::alloc(io_buffer.map.len()); - for (i, ((channel, key), info)) in io_buffer.map.iter().enumerate() { - let channel_box = LeanOwned::box_u64(channel.as_canonical_u64()); - let key_arr = build_g_array(key); - let channel_key = LeanProd::new(channel_box, key_arr); - let key_info = LeanAiurIOKeyInfo::alloc(0); - key_info.set_obj(0, LeanOwned::box_usize(info.idx)); - key_info.set_obj(1, LeanOwned::box_usize(info.len)); - let map_elt = LeanProd::new(channel_key, key_info); - arr.set(i, map_elt); - } - arr -} - -fn decode_commitment_parameters( - obj: &LeanAiurCommitmentParameters, -) -> CommitmentParameters { - let ctor = obj.as_ctor(); - CommitmentParameters { - log_blowup: lean_unbox_nat_as_usize(&ctor.get(0)), - cap_height: lean_unbox_nat_as_usize(&ctor.get(1)), - } -} - -fn decode_fri_parameters( - obj: &LeanAiurFriParameters, -) -> FriParameters { - let ctor = obj.as_ctor(); - FriParameters { - log_final_poly_len: lean_unbox_nat_as_usize(&ctor.get(0)), - max_log_arity: lean_unbox_nat_as_usize(&ctor.get(1)), - num_queries: lean_unbox_nat_as_usize(&ctor.get(2)), - commit_proof_of_work_bits: lean_unbox_nat_as_usize(&ctor.get(3)), - query_proof_of_work_bits: lean_unbox_nat_as_usize(&ctor.get(4)), - } -} - -fn decode_io_buffer_data( - arr: &LeanArray>, -) -> FxHashMap> { - let mut data = FxHashMap::with_capacity_and_hasher(arr.len(), FxBuildHasher); - for elt in arr.iter() { - let pair = elt.as_ctor(); - let channel = lean_unbox_g(&pair.get(0)); - let arena = pair.get(1).as_array().map(|x| lean_unbox_g(&x)); - data.insert(channel, arena); - } - data -} - -fn decode_io_buffer_map( - arr: &LeanArray>, -) -> FxHashMap<(G, Vec), IOKeyInfo> { - let mut map = FxHashMap::with_capacity_and_hasher(arr.len(), FxBuildHasher); - for elt in arr.iter() { - let pair = elt.as_ctor(); - let channel_key = pair.get(0).as_ctor(); - let channel = lean_unbox_g(&channel_key.get(0)); - let key = channel_key.get(1).as_array().map(|x| lean_unbox_g(&x)); - let info_ctor = pair.get(1).as_ctor(); - let info = IOKeyInfo { - idx: lean_unbox_nat_as_usize(&info_ctor.get(0)), - len: lean_unbox_nat_as_usize(&info_ctor.get(1)), - }; - map.insert((channel, key), info); - } - map -} diff --git a/crates/ffi/src/aiur/toplevel.rs b/crates/ffi/src/aiur/toplevel.rs deleted file mode 100644 index fbead94f7..000000000 --- a/crates/ffi/src/aiur/toplevel.rs +++ /dev/null @@ -1,319 +0,0 @@ -use multi_stark::p3_field::PrimeCharacteristicRing; - -use lean_ffi::object::{LeanBorrowed, LeanCtor, LeanRef}; - -use crate::lean::LeanAiurCircuit; -use crate::lean::LeanAiurFunction; - -use crate::lean::LeanAiurToplevel; -use aiur::{ - FxIndexMap, G, - bytecode::{ - Block, Circuit, Ctrl, Function, FunctionLayout, Op, Toplevel, ValIdx, - }, -}; - -use crate::aiur::{lean_unbox_g, lean_unbox_nat_as_usize}; - -fn decode_vec_val_idx(obj: LeanBorrowed<'_>) -> Vec { - obj.as_array().map(|x| lean_unbox_nat_as_usize(&x)) -} - -fn decode_op(ctor: LeanCtor>) -> Op { - match ctor.tag() { - 0 => { - let [const_val] = ctor.objs::<1>(); - Op::Const(G::from_u64(const_val.as_enum_tag() as u64)) - }, - 1 => { - let [a, b] = ctor.objs::<2>(); - Op::Add(lean_unbox_nat_as_usize(&a), lean_unbox_nat_as_usize(&b)) - }, - 2 => { - let [a, b] = ctor.objs::<2>(); - Op::Sub(lean_unbox_nat_as_usize(&a), lean_unbox_nat_as_usize(&b)) - }, - 3 => { - let [a, b] = ctor.objs::<2>(); - Op::Mul(lean_unbox_nat_as_usize(&a), lean_unbox_nat_as_usize(&b)) - }, - 4 => { - let [a] = ctor.objs::<1>(); - Op::EqZero(lean_unbox_nat_as_usize(&a)) - }, - 5 => { - let [fun_idx, val_idxs, output_size, unconstrained_obj] = - ctor.objs::<4>(); - let fun_idx = lean_unbox_nat_as_usize(&fun_idx); - let val_idxs = decode_vec_val_idx(val_idxs); - let output_size = lean_unbox_nat_as_usize(&output_size); - let unconstrained = unconstrained_obj.as_enum_tag() != 0; - Op::Call(fun_idx, val_idxs, output_size, unconstrained) - }, - 6 => { - let [val_idxs] = ctor.objs::<1>(); - Op::Store(decode_vec_val_idx(val_idxs)) - }, - 7 => { - let [width, val_idx] = ctor.objs::<2>(); - Op::Load( - lean_unbox_nat_as_usize(&width), - lean_unbox_nat_as_usize(&val_idx), - ) - }, - 8 => { - let [a, b, msg_obj] = ctor.objs::<3>(); - // `Option String`: scalar encodes `none`, otherwise a ctor whose - // single field is the string (same shape as `Op::Debug`'s label). - let msg = if msg_obj.is_scalar() { - None - } else { - Some(msg_obj.as_ctor().get(0).as_string().to_string()) - }; - Op::AssertEq(decode_vec_val_idx(a), decode_vec_val_idx(b), msg) - }, - 9 => { - let [channel, key] = ctor.objs::<2>(); - Op::IOGetInfo(lean_unbox_nat_as_usize(&channel), decode_vec_val_idx(key)) - }, - 10 => { - let [channel, key, idx, len] = ctor.objs::<4>(); - Op::IOSetInfo( - lean_unbox_nat_as_usize(&channel), - decode_vec_val_idx(key), - lean_unbox_nat_as_usize(&idx), - lean_unbox_nat_as_usize(&len), - ) - }, - 11 => { - let [channel, idx, len] = ctor.objs::<3>(); - Op::IORead( - lean_unbox_nat_as_usize(&channel), - lean_unbox_nat_as_usize(&idx), - lean_unbox_nat_as_usize(&len), - ) - }, - 12 => { - let [channel, data] = ctor.objs::<2>(); - Op::IOWrite(lean_unbox_nat_as_usize(&channel), decode_vec_val_idx(data)) - }, - 13 => { - let [byte] = ctor.objs::<1>(); - Op::U8BitDecomposition(lean_unbox_nat_as_usize(&byte)) - }, - 14 => { - let [byte] = ctor.objs::<1>(); - Op::U8ShiftLeft(lean_unbox_nat_as_usize(&byte)) - }, - 15 => { - let [byte] = ctor.objs::<1>(); - Op::U8ShiftRight(lean_unbox_nat_as_usize(&byte)) - }, - 16 => { - let [i, j] = ctor.objs::<2>().map(|x| lean_unbox_nat_as_usize(&x)); - Op::U8Xor(i, j) - }, - 17 => { - let [i, j] = ctor.objs::<2>().map(|x| lean_unbox_nat_as_usize(&x)); - Op::U8Add(i, j) - }, - 18 => { - let [i, j] = ctor.objs::<2>().map(|x| lean_unbox_nat_as_usize(&x)); - Op::U8Mul(i, j) - }, - 19 => { - let [i, j] = ctor.objs::<2>().map(|x| lean_unbox_nat_as_usize(&x)); - Op::U8Sub(i, j) - }, - 20 => { - let [i, j] = ctor.objs::<2>().map(|x| lean_unbox_nat_as_usize(&x)); - Op::U8And(i, j) - }, - 21 => { - let [i, j] = ctor.objs::<2>().map(|x| lean_unbox_nat_as_usize(&x)); - Op::U8Or(i, j) - }, - 22 => { - let [i, j] = ctor.objs::<2>().map(|x| lean_unbox_nat_as_usize(&x)); - Op::U8LessThan(i, j) - }, - 23 => { - let [i, j] = ctor.objs::<2>().map(|x| lean_unbox_nat_as_usize(&x)); - Op::U32LessThan(i, j) - }, - 24 => { - let [i, j] = ctor.objs::<2>().map(|x| lean_unbox_nat_as_usize(&x)); - Op::U8XorSplit7(i, j) - }, - 25 => { - let [i, j] = ctor.objs::<2>().map(|x| lean_unbox_nat_as_usize(&x)); - Op::U8XorSplit4(i, j) - }, - 26 => { - let [label_obj, idxs_obj] = ctor.objs::<2>(); - let label = label_obj.as_string().to_string(); - let idxs = if idxs_obj.is_scalar() { - None - } else { - let inner_ctor = idxs_obj.as_ctor(); - Some(inner_ctor.get(0).as_array().map(|x| lean_unbox_nat_as_usize(&x))) - }; - Op::Debug(label, idxs) - }, - 27 => { - let [i, j] = ctor.objs::<2>().map(|x| lean_unbox_nat_as_usize(&x)); - Op::U8RangeCheck(i, j) - }, - 28 => { - let [i, j] = ctor.objs::<2>().map(|x| lean_unbox_nat_as_usize(&x)); - Op::UnconstrainedBigUintDivMod(i, j) - }, - 29 => { - let [a] = ctor.objs::<1>().map(|x| lean_unbox_nat_as_usize(&x)); - Op::UnconstrainedGToBytes(a) - }, - 30 => { - let [a] = ctor.objs::<1>().map(|x| lean_unbox_nat_as_usize(&x)); - Op::UnconstrainedGInverse(a) - }, - 31 => { - let [a, b] = ctor.objs::<2>(); - Op::UnconstrainedU32Add(decode_vec_val_idx(a), decode_vec_val_idx(b)) - }, - 32 => { - let [a, b, c] = ctor.objs::<3>(); - Op::UnconstrainedU32Add3( - decode_vec_val_idx(a), - decode_vec_val_idx(b), - decode_vec_val_idx(c), - ) - }, - 33 => { - let [a] = ctor.objs::<1>(); - Op::U32ToField(decode_vec_val_idx(a)) - }, - _ => unreachable!(), - } -} - -fn decode_g_block_pair(ctor: LeanCtor>) -> (G, Block) { - let [g_obj, block_obj] = ctor.objs::<2>(); - let g = lean_unbox_g(&g_obj); - let block = decode_block(block_obj.as_ctor()); - (g, block) -} - -fn decode_ctrl(ctor: LeanCtor>) -> Ctrl { - match ctor.tag() { - 0 => { - let [val_idx_obj, cases_obj, default_obj] = ctor.objs::<3>(); - let val_idx = lean_unbox_nat_as_usize(&val_idx_obj); - let vec_cases = - cases_obj.as_array().map(|o| decode_g_block_pair(o.as_ctor())); - let cases = FxIndexMap::from_iter(vec_cases); - let default = if default_obj.is_scalar() { - None - } else { - let inner_ctor = default_obj.as_ctor(); - let block = decode_block(inner_ctor.get(0).as_ctor()); - Some(Box::new(block)) - }; - Ctrl::Match(val_idx, cases, default) - }, - 1 => { - let [sel_idx_obj, val_idxs_obj] = ctor.objs::<2>(); - let sel_idx = lean_unbox_nat_as_usize(&sel_idx_obj); - let val_idxs = decode_vec_val_idx(val_idxs_obj); - Ctrl::Return(sel_idx, val_idxs) - }, - 2 => { - let [sel_idx_obj, val_idxs_obj] = ctor.objs::<2>(); - let sel_idx = lean_unbox_nat_as_usize(&sel_idx_obj); - let val_idxs = decode_vec_val_idx(val_idxs_obj); - Ctrl::Yield(sel_idx, val_idxs) - }, - 3 => { - let [ - val_idx_obj, - cases_obj, - default_obj, - output_size_obj, - shared_aux_obj, - shared_lookups_obj, - cont_obj, - ] = ctor.objs::<7>(); - let val_idx = lean_unbox_nat_as_usize(&val_idx_obj); - let vec_cases = - cases_obj.as_array().map(|o| decode_g_block_pair(o.as_ctor())); - let cases = FxIndexMap::from_iter(vec_cases); - let default = if default_obj.is_scalar() { - None - } else { - let inner_ctor = default_obj.as_ctor(); - let block = decode_block(inner_ctor.get(0).as_ctor()); - Some(Box::new(block)) - }; - let output_size = lean_unbox_nat_as_usize(&output_size_obj); - let shared_aux = lean_unbox_nat_as_usize(&shared_aux_obj); - let shared_lookups = lean_unbox_nat_as_usize(&shared_lookups_obj); - let continuation = Box::new(decode_block(cont_obj.as_ctor())); - Ctrl::MatchContinue( - val_idx, - cases, - default, - output_size, - shared_aux, - shared_lookups, - continuation, - ) - }, - _ => unreachable!(), - } -} - -fn decode_block(ctor: LeanCtor>) -> Block { - let [ops_obj, ctrl_obj] = ctor.objs::<2>(); - let ops = ops_obj.as_array().map(|o| decode_op(o.as_ctor())); - let ctrl = decode_ctrl(ctrl_obj.as_ctor()); - Block { ops, ctrl } -} - -fn decode_function_layout(ctor: LeanCtor>) -> FunctionLayout { - let [input_size, selectors, auxiliaries, lookups] = ctor.objs::<4>(); - FunctionLayout { - input_size: lean_unbox_nat_as_usize(&input_size), - selectors: lean_unbox_nat_as_usize(&selectors), - auxiliaries: lean_unbox_nat_as_usize(&auxiliaries), - lookups: lean_unbox_nat_as_usize(&lookups), - } -} - -fn decode_function(ctor: LeanCtor>) -> Function { - let ctor = LeanAiurFunction::from_ctor(ctor); - let body = decode_block(ctor.get_obj(0).as_ctor()); - let layout = decode_function_layout(ctor.get_obj(1).as_ctor()); - let entry = ctor.get_num_8(0) != 0; - let constrained = ctor.get_num_8(1) != 0; - Function { body, layout, entry, constrained } -} - -fn decode_circuit(ctor: LeanCtor>) -> Circuit { - let ctor = LeanAiurCircuit::from_ctor(ctor); - // Object field 0 is the circuit's display name (`String`), unused here. - let members = ctor.get_obj(1).as_array().map(|x| lean_unbox_nat_as_usize(&x)); - let layout = decode_function_layout(ctor.get_obj(2).as_ctor()); - Circuit { members, layout } -} - -pub(crate) fn decode_toplevel( - obj: &LeanAiurToplevel, -) -> Toplevel { - let ctor = obj.as_ctor(); - let [functions_obj, memory_sizes_obj, circuits_obj] = ctor.objs::<3>(); - let functions = - functions_obj.as_array().map(|o| decode_function(o.as_ctor())); - let memory_sizes = - memory_sizes_obj.as_array().map(|x| lean_unbox_nat_as_usize(&x)); - let circuits = circuits_obj.as_array().map(|o| decode_circuit(o.as_ctor())); - Toplevel { functions, memory_sizes, circuits } -} diff --git a/crates/ffi/src/compression.rs b/crates/ffi/src/compression.rs index 2e46312a9..9ebcf2353 100644 --- a/crates/ffi/src/compression.rs +++ b/crates/ffi/src/compression.rs @@ -1,12 +1,22 @@ //! Main CLI bridge; compression is linked into the ix executable. -use crate::aiur::aggregate::normalize::{self, RootWrap}; -use crate::aiur::lean_unbox_nat_as_usize; -use aiur::synthesis::AiurSystem; +use aiur::{ + field::FieldBackend, + trace::{ + TraceArtifact, TracePlan, + stark::{Backend, BatchProof, Parameters}, + }, +}; use ix_proof_compression::pipeline::{self, FixedRoot}; use lean_ffi::object::{ - LeanBorrowed, LeanByteArray, LeanExternal, LeanIOResult, LeanNat, LeanOwned, - LeanString, + LeanBorrowed, LeanByteArray, LeanIOResult, LeanOwned, LeanString, }; +use multi_stark::types::Val; + +#[derive(serde::Deserialize)] +struct Package { + program: aiur::Program, + trace: TraceArtifact, +} fn optional(text: &LeanString>) -> Option { let text = text.to_string(); @@ -136,22 +146,6 @@ extern "C" fn rs_compression_check_claim( } } -fn root_wrap<'a>( - system: &'a LeanExternal>, - aggr_idx: &LeanNat>, - allowed: &'a LeanByteArray>, - ixvm_vk: &'a LeanByteArray>, - claim: &'a LeanByteArray>, -) -> RootWrap<'a> { - RootWrap { - system: system.get(), - aggr_idx: lean_unbox_nat_as_usize(aggr_idx.inner()), - allowed: allowed.as_bytes(), - ixvm_vk: ixvm_vk.as_bytes(), - claim: claim.as_bytes(), - } -} - /// The versioned normalization layout for the selected aggregation backend. #[unsafe(no_mangle)] extern "C" fn rs_compression_release_root_layout( @@ -166,18 +160,41 @@ extern "C" fn rs_compression_release_root_layout( /// Per-circuit rows of one root wrap execution, as a JSON array. #[unsafe(no_mangle)] extern "C" fn rs_compression_root_rows( - system: LeanExternal>, - aggr_idx: LeanNat>, - allowed: LeanByteArray>, - ixvm_vk: LeanByteArray>, - claim: LeanByteArray>, - proof: LeanByteArray>, + aggr_artifact: LeanString>, + invocation_json: LeanString>, + raw_proof: LeanByteArray>, ) -> LeanIOResult { - let wrap = root_wrap(&system, &aggr_idx, &allowed, &ixvm_vk, &claim); - match wrap.rows(proof.as_bytes()) { - Ok(rows) => LeanIOResult::ok(LeanString::new( - &serde_json::to_string(&rows).expect("row counts serialize"), - )), + let result = (|| -> Result { + let bytes = + std::fs::read(aggr_artifact.to_string()).map_err(|e| e.to_string())?; + let package: Package = + aiur::decode_artifact(&bytes).map_err(|e| e.to_string())?; + let program = package.program.check_field::()?; + let plan = TracePlan::new(&program, package.trace)?; + let backend = + Backend::for_batch_verification(&plan, Parameters::default())?; + let invocation: stark_verifier::Invocation = + serde_json::from_str(&invocation_json.to_string()) + .map_err(|e| e.to_string())?; + let args = program.field().decode(&invocation.args)?; + let proof_bytes = raw_proof.as_bytes(); + let proof = BatchProof::from_bytes(proof_bytes) + .map_err(|e| format!("root proof decode failed: {e}"))?; + if proof.to_bytes().map_err(|e| e.to_string())? != proof_bytes { + return Err("noncanonical or trailing root proof bytes".into()); + } + backend.verify_batch(&invocation.entry, &args, &[], &proof)?; + let hints = stark_verifier::prepare(&program, &invocation.streams)?; + let record = + hints.execute(&invocation.entry, args).map_err(|e| e.to_string())?; + if !record.output.is_empty() { + return Err("verifier returned a non-unit value".into()); + } + let rows = backend.execution_rows(&record); + serde_json::to_string(&rows).map_err(|e| e.to_string()) + })(); + match result { + Ok(rows) => LeanIOResult::ok(LeanString::new(&rows)), Err(e) => LeanIOResult::error_string(&e), } } @@ -185,7 +202,7 @@ extern "C" fn rs_compression_root_rows( /// The fixed layout holding every row-count array in the JSON array `rows`. #[unsafe(no_mangle)] extern "C" fn rs_compression_root_layout( - system: LeanExternal>, + aggr_artifact: LeanString>, rows: LeanString>, headroom: u32, claim_len: u32, @@ -200,12 +217,24 @@ extern "C" fn rs_compression_root_layout( let maxima: Vec<_> = (0..first.len()) .map(|i| executions.iter().map(|rows| rows[i]).max().unwrap_or(0)) .collect(); - let layout = normalize::layout( - system.get(), + let bytes = + std::fs::read(aggr_artifact.to_string()).map_err(|e| e.to_string())?; + let package: Package = + aiur::decode_artifact(&bytes).map_err(|e| e.to_string())?; + let program = package.program.check_field::()?; + let plan = TracePlan::new(&program, package.trace)?; + let backend = + Backend::for_batch_verification(&plan, Parameters::default())?; + let log_heights = backend.normalized_log_heights( &maxima, u8::try_from(headroom).map_err(|e| e.to_string())?, - claim_len as usize, )?; + let layout = FixedRoot::new( + log_heights, + backend.memory_circuits(), + claim_len as usize, + ) + .map_err(|e| e.to_string())?; Ok(layout.to_json()) })(); match result { @@ -217,18 +246,54 @@ extern "C" fn rs_compression_root_layout( /// Wrap and prove the root in `layout`'s fixed shape. #[unsafe(no_mangle)] extern "C" fn rs_compression_normalize_root( - system: LeanExternal>, - aggr_idx: LeanNat>, - allowed: LeanByteArray>, - ixvm_vk: LeanByteArray>, - claim: LeanByteArray>, - proof: LeanByteArray>, + aggr_artifact: LeanString>, + invocation_json: LeanString>, + raw_proof: LeanByteArray>, layout: LeanString>, ) -> LeanIOResult { - let wrap = root_wrap(&system, &aggr_idx, &allowed, &ixvm_vk, &claim); - let result = FixedRoot::from_json(&layout.to_string()) - .map_err(|e| e.to_string()) - .and_then(|layout| wrap.normalize(proof.as_bytes(), &layout)); + let result = (|| -> Result, String> { + let layout = + FixedRoot::from_json(&layout.to_string()).map_err(|e| e.to_string())?; + let bytes = + std::fs::read(aggr_artifact.to_string()).map_err(|e| e.to_string())?; + let package: Package = + aiur::decode_artifact(&bytes).map_err(|e| e.to_string())?; + let program = package.program.check_field::()?; + let plan = TracePlan::new(&program, package.trace)?; + let backend = Backend::for_batch(&plan, Parameters::default())?; + let invocation: stark_verifier::Invocation = + serde_json::from_str(&invocation_json.to_string()) + .map_err(|e| e.to_string())?; + let args = program.field().decode(&invocation.args)?; + let proof_bytes = raw_proof.as_bytes(); + let proof = BatchProof::from_bytes(proof_bytes) + .map_err(|e| format!("root proof decode failed: {e}"))?; + if proof.to_bytes().map_err(|e| e.to_string())? != proof_bytes { + return Err("noncanonical or trailing root proof bytes".into()); + } + backend.verify_batch(&invocation.entry, &args, &[], &proof)?; + let hints = stark_verifier::prepare(&program, &invocation.streams)?; + let record = hints + .execute(&invocation.entry, args.clone()) + .map_err(|e| e.to_string())?; + if !record.output.is_empty() { + return Err("verifier returned a non-unit value".into()); + } + let (claim, normalized) = backend.prove_normalized( + &invocation.entry, + &args, + &[], + record, + layout.log_heights(), + )?; + let expected = backend.claim(&invocation.entry, &args, &[])?; + if claim != expected { + return Err( + "normalized root claim differs from expected outer claim".into(), + ); + } + normalized.to_bytes().map_err(|e| e.to_string()) + })(); match result { Ok(bytes) => LeanIOResult::ok(LeanByteArray::from_bytes(&bytes)), Err(e) => LeanIOResult::error_string(&e), diff --git a/crates/ffi/src/lean.rs b/crates/ffi/src/lean.rs index 1bc8dfe86..deb3c86d4 100644 --- a/crates/ffi/src/lean.rs +++ b/crates/ffi/src/lean.rs @@ -20,8 +20,6 @@ lean_ffi::lean_domain_type! { // Opaque types (passed through without field access) LeanIxonExprMetaArena; - LeanAiurCommitmentParameters; - LeanAiurFriParameters; } // ============================================================================= @@ -174,37 +172,6 @@ lean_ffi::lean_inductive! { { num_32: 1 }, // tag 2: regular ]; - // --- Aiur types --- - - LeanAiurToplevel [ { num_obj: 3 } ]; - LeanAiurFunction [ { num_obj: 2, num_8: 2 } ]; - LeanAiurCircuit [ { num_obj: 3 } ]; - - // Aiur FFI result structures (`Ix/Aiur/Semantics/BytecodeFfi.lean`, - // `Ix/Aiur/Protocol.lean`). `IOBuffer` hashmaps cross the boundary as - // flat `ioData`/`ioMap` arrays; Lean folds them back into hashmaps. - // idx, len - LeanAiurIOKeyInfo [ { num_obj: 2 } ]; - // uniqueRows, totalHits - LeanAiurQueryCount [ { num_obj: 2 } ]; - // mainWidth, stage2Width, quotientDegree, preprocessedWidth, - // preprocessedHeight - LeanAiurCircuitShape [ { num_obj: 5 } ]; - // output, ioData, ioMap, queryCounts - LeanAiurExecuteResult [ { num_obj: 4 } ]; - // claim, proof, ioData, ioMap - LeanAiurProveResult [ { num_obj: 4 } ]; - // claimBytes, proof, ioData, ioMap - LeanAiurProveEnvResult [ { num_obj: 4 } ]; - // error, peakBytes, suggestedParts - LeanAiurShardResult [ { num_obj: 3 } ]; - // claimBytes, proof, peakBytes, suggestedParts, workerBytes - LeanAiurShardProveResult [ { num_obj: 5 } ]; - // claimBytes, proofAddr, peakBytes - LeanAiurShardProvenAhead [ { num_obj: 3 } ]; - // claimBytes, constantCount - LeanAiurAggregateExpected [ { num_obj: 2 } ]; - // --- Iroh types --- LeanPutResponse [ { num_obj: 2 } ]; diff --git a/crates/ffi/src/lean_ixon.rs b/crates/ffi/src/lean_ixon.rs index ba31ae7e1..19e5244e1 100644 --- a/crates/ffi/src/lean_ixon.rs +++ b/crates/ffi/src/lean_ixon.rs @@ -15,17 +15,112 @@ pub mod pack; pub mod serialize; pub mod univ; +use std::sync::LazyLock; use std::time::Instant; use ix_common::address::Address; use ix_common::env::normalize_displayed_name; use ixon::env::Env as IxonEnv; use lean_ffi::object::{ - LeanArray, LeanBool, LeanBorrowed, LeanByteArray, LeanExternal, LeanIOResult, - LeanOwned, LeanString, + ExternalClass, LeanArray, LeanBool, LeanBorrowed, LeanByteArray, LeanExcept, + LeanExternal, LeanIOResult, LeanOwned, LeanString, }; use rustc_hash::FxHashMap; +/// A Rust-owned [`IxonEnv`] exposed to Lean as an opaque external handle. +pub struct EnvHandle { + pub env: IxonEnv, +} + +impl EnvHandle { + /// Load via [`IxonEnv::get_anon_mmap`] (zero-copy mmap of the `.ixe` file). + pub fn from_ixe_path(path: &std::path::Path) -> Result { + let env = IxonEnv::get_anon_mmap(path)?; + Ok(Self { env }) + } + + /// Decode a serialized env blob (`Ixon.serEnv` output) via [`IxonEnv::get`]. + pub fn from_bytes(bytes: &[u8]) -> Result { + let mut cursor: &[u8] = bytes; + let env = IxonEnv::get(&mut cursor)?; + Ok(Self { env }) + } +} + +static IX_ENV_HANDLE_CLASS: LazyLock = + LazyLock::new(ExternalClass::register_with_drop::); + +/// `Aiur.EnvHandle.fromIxe`: open and parse a `.ixe` file once, returning an +/// opaque Rust-owned handle. +#[unsafe(no_mangle)] +pub extern "C" fn rs_aiur_env_handle_from_ixe( + path_bytes: LeanByteArray>, +) -> LeanExcept { + let path_str = String::from_utf8_lossy(path_bytes.as_bytes()).into_owned(); + match EnvHandle::from_ixe_path(std::path::Path::new(&path_str)) { + Ok(h) => { + let lean_handle: LeanOwned = + LeanExternal::alloc(&IX_ENV_HANDLE_CLASS, h).into(); + LeanExcept::ok(lean_handle) + }, + Err(e) => LeanExcept::error_string(&format!("env handle from_ixe: {e}")), + } +} + +/// `Aiur.EnvHandle.fromBytes`: decode a serialized env blob (`Ixon.serEnv` +/// output) into an opaque Rust-owned handle. +#[unsafe(no_mangle)] +pub extern "C" fn rs_aiur_env_handle_from_bytes( + bytes: LeanByteArray>, +) -> LeanExcept { + match EnvHandle::from_bytes(bytes.as_bytes()) { + Ok(h) => { + let lean_handle: LeanOwned = + LeanExternal::alloc(&IX_ENV_HANDLE_CLASS, h).into(); + LeanExcept::ok(lean_handle) + }, + Err(e) => LeanExcept::error_string(&format!("env handle from_bytes: {e}")), + } +} + +/// FFI: the detected prover/execution RAM budget in bytes +/// ([`ixon::shard::RAM_USABLE_FRAC`] of `MemAvailable`), or `0` when +/// `/proc/meminfo` is unreadable. +#[unsafe(no_mangle)] +pub extern "C" fn rs_aiur_detected_ram_budget() -> LeanIOResult { + let bytes = detected_ram_budget().unwrap_or(0); + LeanIOResult::ok(LeanOwned::box_u64(bytes as u64)) +} + +fn trace_shard_max_cells() -> usize { + std::env::var("AIUR_TRACE_SHARD_MAX_CELLS") + .ok() + .and_then(|v| v.parse::().ok()) + .unwrap_or(0) +} + +fn record_budget(max_ram_bytes: usize, cells: usize) -> usize { + max_ram_bytes.saturating_sub(2 * 8 * cells + (256 << 20)) +} + +fn record_share(max_ram_bytes: usize, cells: usize, in_flight: usize) -> usize { + record_budget(max_ram_bytes, cells) / in_flight.max(1) +} + +#[allow(clippy::cast_precision_loss, clippy::cast_possible_truncation)] +#[allow(clippy::cast_sign_loss)] +fn detected_ram_budget() -> Option { + available_ram_bytes() + .map(|b| (b as f64 * ixon::shard::RAM_USABLE_FRAC) as usize) +} + +fn available_ram_bytes() -> Option { + let s = std::fs::read_to_string("/proc/meminfo").ok()?; + let rest = s.lines().find_map(|l| l.strip_prefix("MemAvailable:"))?; + let kib: usize = rest.trim().trim_end_matches("kB").trim().parse().ok()?; + Some(kib * 1024) +} + /// FFI: extract the named constants' dependency closure from a serialized /// env into a standalone `.ixe` — genuine constant bytes, blobs, and /// reducibility hints (via the anon view), plus every closure constant's @@ -215,10 +310,9 @@ pub extern "C" fn rs_shard_env_static( } else if cfg!(feature = "cuda") { // The trace-shard prover: seed against one execution's record share, // computed as `ix prove --lanes` computes it. - let cells = crate::aiur::protocol::trace_shard_max_cells(); + let cells = trace_shard_max_cells(); let budget = usize::try_from(ram_gib << 30).unwrap_or(usize::MAX); - let share = - crate::aiur::protocol::record_share(budget, cells, exec_ahead + 2); + let share = record_share(budget, cells, exec_ahead + 2); let tenths = u32::try_from(share.saturating_mul(10) >> 30).unwrap_or(u32::MAX); let share_gib = f64::from(tenths) / 10.0; @@ -338,10 +432,7 @@ fn decode_refinements( #[allow(clippy::cast_possible_truncation)] // ids and counts are u32 by construction #[unsafe(no_mangle)] pub extern "C" fn rs_shard_manifest_refine( - env_handle: LeanExternal< - ixvm_codegen::env_handle::EnvHandle, - LeanBorrowed<'_>, - >, + env_handle: LeanExternal>, source_path: LeanString>, refinements_blob: LeanByteArray>, measured_blob: LeanByteArray>, diff --git a/crates/ffi/src/lib.rs b/crates/ffi/src/lib.rs index 8b970dc59..915ddfb60 100644 --- a/crates/ffi/src/lib.rs +++ b/crates/ffi/src/lib.rs @@ -7,7 +7,6 @@ all(target_os = "macos", target_arch = "aarch64") ))] pub mod _iroh; -pub mod aiur; #[cfg(all( feature = "net", not(all(target_os = "macos", target_arch = "aarch64")) diff --git a/crates/ix-prover/Cargo.toml b/crates/ix-prover/Cargo.toml new file mode 100644 index 000000000..68b5f6266 --- /dev/null +++ b/crates/ix-prover/Cargo.toml @@ -0,0 +1,25 @@ +[package] +name = "ix-prover" +version.workspace = true +edition.workspace = true +license.workspace = true + +[dependencies] +aiur = { workspace = true, features = ["stark"] } +ixvm = { path = "../ixvm", features = ["stark"] } +stark-verifier = { path = "../stark-verifier" } +record-pool = { workspace = true } +multi-stark = { workspace = true } +rayon = { workspace = true } +serde = { version = "1", features = ["derive"] } +serde_json = { workspace = true } +blake3 = { workspace = true } +rustc-hash = { workspace = true } +tracing = { workspace = true } +tracing-subscriber = { workspace = true } +tracing-texray = { workspace = true } + +[features] +default = ["parallel"] +parallel = ["aiur/parallel", "ixvm/parallel", "stark-verifier/parallel"] +cuda = ["aiur/cuda", "ixvm/cuda", "stark-verifier/cuda"] diff --git a/crates/ix-prover/src/distributed.rs b/crates/ix-prover/src/distributed.rs new file mode 100644 index 000000000..16fef6e44 --- /dev/null +++ b/crates/ix-prover/src/distributed.rs @@ -0,0 +1,476 @@ +//! One claim, multiple execution records. Only unit calls are deferred. Each +//! record owns a disjoint ROM interval, and the batch balances calls across it. +use super::{ + Field, Package, Program, output, + protocol::{Job, Kind, read_json}, +}; +use aiur::{ + Execution, QueryInput, + execute::Partition, + field::FieldBackend, + library::io::Invocation, + trace::{ + TracePlan, + stark::{ + Backend, Parameters, StreamPlan, + planning::{self, Options, RecordShape}, + }, + }, +}; +use multi_stark::{batch::Retention, p3_field::PrimeField64, types::Val}; +use rayon::prelude::*; +use record_pool::{BudgetError, RecordPool}; +use rustc_hash::FxHashMap; +use serde::{Deserialize, Serialize}; +use serde_json::json; +use std::{ + path::{Path, PathBuf}, + time::{Duration, Instant}, +}; + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct Worker { + input: PathBuf, + owned: Vec>, +} +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct Spec { + invocation: Invocation, + workers: Vec, + exec_jobs: usize, + #[serde(default)] + cells: usize, + #[serde(default)] + exec_only: bool, + #[serde(default)] + texray: bool, +} +#[derive(Serialize)] +struct Measured { + shape: RecordShape, + queries: usize, + instructions: u64, + record_bytes: usize, + execution_seconds: f64, + #[serde(skip)] + deferred: Vec<(Vec, u64)>, + #[serde(skip)] + edges: Vec<(Vec, Vec)>, + #[serde(skip)] + own_counts: Vec, +} + +fn record( + program: &Program, + spec: &Spec, + worker: usize, + function: usize, + pool: &RecordPool, +) -> Result<(Execution, usize, f64), String> { + let _span = tracing_texray::examine(tracing::info_span!( + "aiur.distributed.execute", + worker + )) + .entered(); + loop { + let reservation = loop { + if let Some(r) = pool.try_admit().map_err(|e| e.to_string())? { + break r; + } + std::thread::sleep(Duration::from_millis(5)); + }; + let source = &spec.workers[worker]; + let stride = (program.field().modulus() - 1) / spec.workers.len() as u64; + let run = || -> Result, super::PrepFailure> { + let bytes = std::fs::metadata(&source.input) + .map_err(|e| super::PrepFailure::Other(e.to_string()))? + .len(); + reservation.reserve( + usize::try_from(bytes.saturating_mul(8)).unwrap_or(usize::MAX), + )?; + let input: Invocation = + read_json(&source.input).map_err(super::PrepFailure::Other)?; + let args = program + .field() + .decode(&spec.invocation.args) + .map_err(super::PrepFailure::Other)?; + let owned = source + .owned + .iter() + .map(|a| program.field().decode(a)) + .collect::, _>>() + .map_err(super::PrepFailure::Other)?; + let hints = ixvm::prepare_streams(program, &input.streams) + .map_err(super::PrepFailure::Other)?; + hints + .execute_partition( + (worker == 0).then_some((spec.invocation.entry.as_str(), args)), + Partition { + function, + owned, + memory_start: stride * worker as u64, + memory_end: stride * (worker as u64 + 1), + }, + Some(&reservation), + ) + .map_err(|e| { + e.resource.map_or_else( + || super::PrepFailure::Other(e.to_string()), + super::PrepFailure::Resource, + ) + }) + }; + let start = Instant::now(); + match run() { + Ok(record) => { + reservation.finish_execution(); + return Ok(( + record, + reservation.bytes(), + start.elapsed().as_secs_f64(), + )); + }, + Err(super::PrepFailure::Resource(BudgetError::Cancelled)) => continue, + Err(super::PrepFailure::Resource(e)) => return Err(e.to_string()), + Err(super::PrepFailure::Other(e)) => return Err(e), + } + } +} + +/// No deferred-call cycle may be hidden by splitting a record. Local cycles +/// are caught by the interpreter; this checks the combined owned-call graph. +fn acyclic( + nodes: usize, + edges: impl Iterator, +) -> Result<(), String> { + let mut graph = vec![Vec::new(); nodes]; + let mut incoming = vec![0usize; nodes]; + for (a, b) in edges { + graph[a].push(b); + incoming[b] += 1; + } + let mut ready: Vec<_> = (0..nodes).filter(|&i| incoming[i] == 0).collect(); + let mut count = 0; + while let Some(i) = ready.pop() { + count += 1; + for &j in &graph[i] { + incoming[j] -= 1; + if incoming[j] == 0 { + ready.push(j); + } + } + } + if count == nodes { + Ok(()) + } else { + Err("recursive owned-call cycle crosses worker records".into()) + } +} + +pub fn run( + artifact: &Path, + specification: &Path, + out: &Path, + options_path: &Path, +) -> Result<(), String> { + let spec: Spec = read_json(specification)?; + super::tracing(spec.texray)?; + let package: Package = + aiur::decode_artifact(&std::fs::read(artifact).map_err(|e| e.to_string())?) + .map_err(|e| e.to_string())?; + let program = package.program.check_field::()?; + let plan = TracePlan::new(&program, package.trace)?; + let options: Options = read_json(options_path)?; + options.validate()?; + let backend = + Backend::for_batch_on_device(&plan, Parameters::default(), options.device)?; + if spec.workers.is_empty() + || spec.exec_jobs == 0 + || spec.invocation.entry != "IxVM::verify_claim" + || spec.invocation.args.len() != 8 + { + return Err("invalid distributed IxVM specification".into()); + } + let function = program + .program() + .functions + .iter() + // Retain compatibility with cached artifacts from before the module split. + .position(|f| { + matches!(f.name.as_str(), "IxVMCompat::check_owned" | "IxVM::check_owned") + }) + .ok_or("IxVM artifact has no check_owned callable")?; + let mut owners = FxHashMap::default(); + let mut keys = Vec::new(); + for (worker, source) in spec.workers.iter().enumerate() { + for key in &source.owned { + let valid_key = match key.len() { + 32 => key.iter().all(|&x| x <= 255), + 65 => { + key[..32].iter().all(|&x| x <= 255) + && matches!(key[32], 3 | 4) + && key[33..].iter().all(|&x| x <= 255) + }, + _ => false, + }; + if !valid_key { + return Err("owned address must contain 32 or 65 elements".into()); + } + let key = program.field().decode(key)?; + if owners.insert(key.clone(), (worker, keys.len())).is_some() { + return Err("a constant has multiple owners".into()); + } + keys.push(key); + } + } + let budget = options + .max_ram_bytes + .or_else(planning::available_memory) + .unwrap_or(8 << 30); + let remaining = budget + .checked_sub(planning::resident_memory().saturating_mul(5) / 4) + .ok_or("distributed budget is below resident setup")?; + let records_bytes = + usize::try_from(remaining / 2).map_err(|_| "record pool overflow")?; + if records_bytes == 0 { + return Err("no record capacity remains".into()); + } + let limit = std::env::var("AIUR_RECORD_MAX_BYTES") + .ok() + .map(|s| s.parse::()) + .transpose() + .map_err(|e| e.to_string())? + .unwrap_or(128usize << 30) + .min(records_bytes); + if limit == 0 { + return Err("record limit must be positive".into()); + } + let pool = RecordPool::new( + records_bytes, + (records_bytes / spec.exec_jobs).clamp(1, 16 << 20), + ) + .with_record_limit(limit); + let executors = rayon::ThreadPoolBuilder::new() + .num_threads(spec.exec_jobs.min(spec.workers.len())) + .build() + .map_err(|e| e.to_string())?; + // The first pass retains only call counts, graph edges and trace shapes. + // Every worker's record is released before another needs its capacity. + let measured = executors.install(|| { + (0..spec.workers.len()) + .into_par_iter() + .map(|worker| { + let (record, bytes, seconds) = + record(&program, &spec, worker, function, &pool)?; + let own_counts = spec.workers[worker] + .owned + .iter() + .map(|key| { + let args = program.field().decode(key)?; + Ok( + record + .queries + .get(&QueryInput { function, args }) + .ok_or("missing owned query")? + .multiplicity, + ) + }) + .collect::, String>>()?; + Ok(Measured { + shape: backend.record_shape(&record)?, + queries: record.queries.len(), + instructions: record.instructions, + record_bytes: bytes, + execution_seconds: seconds, + own_counts, + deferred: record + .deferred_calls() + .map(|(k, n)| (k.to_vec(), n)) + .collect(), + edges: record + .partition_edges() + .map(|(a, b)| (a.to_vec(), b.to_vec())) + .collect(), + }) + }) + .collect::, String>>() + })?; + let mut incoming = + vec![FxHashMap::, u64>::default(); spec.workers.len()]; + let mut edges = Vec::new(); + for worker in &measured { + for (key, count) in &worker.deferred { + let &(owner, _) = owners.get(key).ok_or("deferred call has no owner")?; + let value = incoming[owner].entry(key.clone()).or_default(); + *value = value + .checked_add(*count) + .filter(|&n| n < Val::ORDER_U64) + .ok_or("deferred count overflow")?; + } + for (a, b) in &worker.edges { + edges.push(( + owners.get(a).ok_or("unknown caller owner")?.1, + owners.get(b).ok_or("unknown callee owner")?.1, + )); + } + } + acyclic(keys.len(), edges.into_iter())?; + for (i, worker) in spec.workers.iter().enumerate() { + for (key, count) in worker.owned.iter().zip(&measured[i].own_counts) { + let key = program.field().decode(key)?; + if count + .checked_add(incoming[i].get(&key).copied().unwrap_or(0)) + .is_none_or(|n| n == 0 || n >= Val::ORDER_U64) + { + return Err( + "owned query is unused or its count exceeds the field".into(), + ); + } + } + } + let mut local = options.clone(); + local.max_ram_bytes = Some(remaining / 2); + local.retention = planning::RetentionPolicy::Regenerate; + let widths: Vec<_> = backend + .statistics() + .iter() + .map(|s| s.stage1_width + s.stage2_width + s.preprocessed_width) + .collect(); + let fixed: Vec<_> = + backend.statistics().iter().map(|s| s.preprocessed_height != 0).collect(); + let mut plans = Vec::new(); + let mut pieces = Vec::new(); + for (worker, m) in measured.iter().enumerate() { + let mut batch = backend.plan_heights(&m.shape.heights, &local, 0)?; + if !batch.fits { + return Err(format!("worker {worker} does not fit its prover workspace")); + } + if spec.cells != 0 { + loop { + let cells: u128 = m + .shape + .heights + .iter() + .zip(&widths) + .zip(&fixed) + .map(|((&h, &w), &f)| { + (if f { h } else { h.min(batch.max_rows) }) as u128 * w as u128 + }) + .sum(); + if cells <= spec.cells as u128 { + break; + } + if batch.max_rows == 1 { + return Err("cell budget is below the fixed-table floor".into()); + } + let limited = + Options { max_rows: Some(batch.max_rows / 2), ..local.clone() }; + batch = backend.plan_heights(&m.shape.heights, &limited, 0)?; + } + } + pieces.extend((0..batch.shards).map(|shard| (worker, shard))); + plans.push(batch); + } + let job = Job { + id: "distributed".into(), + artifact: artifact.into(), + input: specification.into(), + output: out.into(), + options, + priority: false, + }; + let stream = backend.plan_stream( + &measured + .iter() + .zip(&plans) + .map(|(m, p)| (m.shape.heights.as_slice(), p.max_rows)) + .collect::>(), + &Options { max_ram_bytes: local.max_ram_bytes, ..job.options.clone() }, + )?; + if !stream.fits { + return Err("retained distributed batch exceeds the workspace budget; use --retention regenerate or increase RAM".into()); + } + let mut report = json!({"verified":false,"distributed":true,"workers":measured,"plans":plans, + "stream":stream,"exec_jobs":spec.exec_jobs,"shards":pieces.len(), + "cross_record_calls":incoming.iter().map(|m| m.values().map(|&n| u128::from(n)).sum::()).sum::()}); + output::report(&job, Kind::Ixvm, &report)?; + if spec.exec_only { + println!("{report}"); + return Ok(()); + } + let args = program.field().decode(&spec.invocation.args)?; + let mut cached = None; + let mut traces = Vec::new(); + let start = Instant::now(); + let _span = + tracing_texray::examine(tracing::info_span!("aiur.distributed.prove")) + .entered(); + let proof = backend.prove_streamed_stage_1( + &spec.invocation.entry, + &args, + &[], + StreamPlan { + shards: pieces.len(), + retention: if stream.retention == planning::RetentionPolicy::Retain { + Retention::Retain + } else { + Retention::Regenerate + }, + memory_intervals: measured + .iter() + .flat_map(|m| m.shape.memory_intervals.iter().copied()) + .collect(), + }, + |piece| { + let (worker, shard) = pieces[piece]; + if cached != Some(worker) { + // Release the previous record's matrices before replaying the next one. + traces.clear(); + let (mut record, _, _) = + record(&program, &spec, worker, function, &pool)?; + for (key, count) in &incoming[worker] { + record.absorb_deferred(function, key, *count)?; + } + if backend.record_shape(&record)? != measured[worker].shape { + return Err("worker trace shape changed on replay".into()); + } + traces = tracing::info_span!("aiur.distributed.trace", worker) + .in_scope(|| { + if worker == 0 { + backend.generate_stage_1(&record, &spec.invocation.entry, &args) + } else { + backend.generate_record_stage_1(&record) + } + })?; + cached = Some(worker); + } + backend.slice_stage_1(&traces, shard, plans[worker].max_rows) + }, + )?; + report["proving_seconds"] = start.elapsed().as_secs_f64().into(); + report["record_peak_bytes"] = pool.stats().peak_reserved.into(); + let report = output::proof( + &job, + Kind::Ixvm, + &backend, + &spec.invocation.entry, + &args, + &proof, + report, + )?; + println!("{report}"); + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn cross_record_cycles_and_shared_dags() { + assert!(acyclic(4, [(0, 1), (0, 2), (1, 3), (2, 3)].into_iter()).is_ok()); + assert!(acyclic(3, [(0, 1), (1, 2), (2, 1)].into_iter()).is_err()); + assert!(acyclic(1, [(0, 0)].into_iter()).is_err()); + } +} diff --git a/crates/ix-prover/src/main.rs b/crates/ix-prover/src/main.rs new file mode 100644 index 000000000..30f247272 --- /dev/null +++ b/crates/ix-prover/src/main.rs @@ -0,0 +1,731 @@ +//! Resident host for the formal IxVM and recursive verifier. The application +//! submits ready jobs; CPU execution is shared and each prover owns its backend. +//! Spool files transport control messages only. Execution records stay in memory. +mod distributed; +mod output; +mod protocol; + +use aiur::{ + Execution, + bytecode::CheckedProgram, + field::{FieldBackend, NativeField}, + library::io::Invocation, + trace::{ + TraceArtifact, TracePlan, + stark::{Backend, Parameters, planning}, + }, +}; +use multi_stark::types::Val; +use protocol::{Config, Job, Kind, atomic_json, read_json}; +use record_pool::{ + BudgetError, RecordPool, RecordReservation, queue::WorkQueue, +}; +use serde_json::{Value, json}; +use std::{ + collections::{HashSet, VecDeque}, + fs, + path::{Path, PathBuf}, + sync::{Condvar, Mutex, mpsc}, + time::{Duration, Instant}, +}; + +type Field = NativeField; +type Program = CheckedProgram; +type Prover<'a, 'p> = Backend<'a, 'p, Field>; + +#[derive(serde::Deserialize)] +struct Package { + program: aiur::Program, + trace: TraceArtifact, +} + +struct Prepared { + job: Job, + artifact: usize, + entry: String, + args: Vec, + record: Execution, + report: Value, +} +struct Prep { + job: Job, + artifact: usize, + reservation: RecordReservation, +} +enum Event { + Done(Job, u32, Value, bool), + Retry(Job), + Prepared, +} + +struct Log { + file: Mutex, + start: Instant, +} +impl Log { + fn event(&self, mut event: Value) { + use std::io::Write; + event["elapsed_seconds"] = self.start.elapsed().as_secs_f64().into(); + if let Ok(mut file) = self.file.lock() { + let _ = writeln!(file, "{event}"); + } + } +} + +fn fail(error: impl ToString) -> Value { + json!({"verified":false, "error":error.to_string()}) +} + +fn tracing(enabled: bool) -> Result<(), String> { + use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt}; + if enabled { + tracing_subscriber::Registry::default() + .with(tracing_texray::TeXRayLayer::new().track_ram().streaming()) + .try_init() + .map_err(|e| e.to_string())?; + } + Ok(()) +} + +fn prepare( + program: &Program, + kind: Kind, + task: Prep, +) -> Result> { + let Prep { job, artifact, reservation } = task; + let _span = + tracing_texray::examine(tracing::info_span!("aiur.execute", id = %job.id)) + .entered(); + let run = || -> Result { + job.options.validate().map_err(PrepFailure::Other)?; + // Reserve advice while parsing it, before either its decoded vectors or + // hint arenas are allocated. It remains charged alongside the record. + let bytes = fs::metadata(&job.input) + .map_err(|e| PrepFailure::Other(e.to_string()))? + .len(); + reservation.reserve( + usize::try_from(bytes.saturating_mul(8)).unwrap_or(usize::MAX), + )?; + let input: Invocation = + read_json(&job.input).map_err(PrepFailure::Other)?; + let valid = match kind { + Kind::Ixvm => { + input.entry == "IxVM::verify_claim" && input.args.len() == 8 + }, + Kind::Recursion => { + ["MultiStark::verify_multi_stark_proof", "MultiStark::ix_aggr"] + .contains(&input.entry.as_str()) + && input.args.len() == 16 + }, + }; + if !valid { + return Err(PrepFailure::Other("wrong application entrypoint".into())); + } + let args = + program.field().decode(&input.args).map_err(PrepFailure::Other)?; + let start = Instant::now(); + let hints = match kind { + Kind::Ixvm => ixvm::prepare_streams(program, &input.streams), + Kind::Recursion => stark_verifier::prepare(program, &input.streams), + } + .map_err(PrepFailure::Other)?; + let record = hints + .execute_reserved(&input.entry, args.clone(), &reservation) + .map_err(|e| { + e.resource.map_or_else( + || PrepFailure::Other(e.to_string()), + PrepFailure::Resource, + ) + })?; + if !record.output.is_empty() { + return Err(PrepFailure::Other("verifier returned a value".into())); + } + reservation.finish_execution(); + let report = json!({"verified":false, "execution_seconds":start.elapsed().as_secs_f64(), + "queries":record.queries.len(), "instructions":record.instructions, "record_bytes":reservation.bytes()}); + Ok(Prepared { + job: job.clone(), + artifact, + entry: input.entry, + args, + record, + report, + }) + }; + match run() { + Ok(prepared) => Ok(prepared), + Err(PrepFailure::Resource(BudgetError::Cancelled)) => { + Err(Box::new((job, 75, fail("record memory contention"), true))) + }, + Err(PrepFailure::Resource(error)) => Err(Box::new(( + job, + 75, + json!({"verified":false,"can_split":true, + "error":error.to_string(),"record_budget_exceeded":matches!(error, BudgetError::Exceeded{..})}), + false, + ))), + Err(PrepFailure::Other(error)) => { + Err(Box::new((job, 1, fail(error), false))) + }, + } +} +enum PrepFailure { + Resource(BudgetError), + Other(String), +} +impl From for PrepFailure { + fn from(e: BudgetError) -> Self { + Self::Resource(e) + } +} + +/// The prover workspace, shared by the lanes through reservations. Every +/// lane plans within an equal share, so ordinary jobs never wait for each +/// other. A recursive job that its share would split into more shards may +/// plan within the whole workspace instead: every further level of a proof +/// tree verifies each shard of its children, so splitting one near the root +/// makes the levels above it larger. Such a job waits until its reservation +/// is free. Reservations are granted in request order, so a waiting job is +/// not overtaken by later small ones. +struct Workspace { + total: u64, + share: u64, + state: Mutex, + released: Condvar, +} +struct WorkspaceState { + free: u64, + next: u64, + serving: u64, +} +struct WorkspaceReservation<'a> { + workspace: &'a Workspace, + bytes: u64, +} +impl Workspace { + fn new(total: u64, lanes: usize) -> Self { + Self { + total, + share: total / lanes.max(1) as u64, + state: Mutex::new(WorkspaceState { free: total, next: 0, serving: 0 }), + released: Condvar::new(), + } + } + fn reserve(&self, bytes: u64) -> WorkspaceReservation<'_> { + let bytes = bytes.min(self.total); + let mut state = self.state.lock().unwrap_or_else(|e| e.into_inner()); + let ticket = state.next; + state.next += 1; + while state.serving != ticket || state.free < bytes { + state = self.released.wait(state).unwrap_or_else(|e| e.into_inner()); + } + state.free -= bytes; + state.serving += 1; + self.released.notify_all(); + WorkspaceReservation { workspace: self, bytes } + } +} +impl Drop for WorkspaceReservation<'_> { + fn drop(&mut self) { + let mut state = + self.workspace.state.lock().unwrap_or_else(|e| e.into_inner()); + state.free += self.bytes; + self.workspace.released.notify_all(); + } +} + +/// Thread pools a lane proves on: its own, and for CPU controllers with +/// several lanes one spanning every lane's threads, for jobs that borrowed +/// the whole workspace and therefore run while the other lanes wait. +struct Pools<'a> { + lane: &'a rayon::ThreadPool, + wide: Option<&'a rayon::ThreadPool>, +} + +fn prove( + backend: &Prover<'_, '_>, + kind: Kind, + prepared: Prepared, + workspace: &Workspace, + pools: &Pools<'_>, + lane: usize, + device: Option, +) -> (Job, u32, Value) { + let Prepared { job, entry, args, record, mut report, .. } = prepared; + let effective_device = job.options.device.or(device); + let result = (|| -> Result<(), String> { + let plan = |budget: u64| { + let mut options = job.options.clone(); + options.device = effective_device; + options.max_ram_bytes = + Some(options.max_ram_bytes.unwrap_or(budget).min(budget)); + backend.plan_record(&record, &options, 0) + }; + let narrow = plan(workspace.share)?; + let wide = match kind { + Kind::Recursion if workspace.total > workspace.share => { + Some(plan(workspace.total)?).filter(|wide| { + wide.fits && (!narrow.fits || wide.shards < narrow.shards) + }) + }, + _ => None, + }; + let borrowed = wide.is_some(); + let batch = wide.unwrap_or(narrow); + report["plan"] = serde_json::to_value(&batch).map_err(|e| e.to_string())?; + report["lane"] = lane.into(); + report["device"] = effective_device.into(); + report["borrowed_workspace"] = borrowed.into(); + if !batch.fits { + return Ok(()); + } + let waited = Instant::now(); + let _reservation = workspace + .reserve(batch.generation_peak_bytes.max(batch.proving_peak_bytes)); + report["workspace_wait_seconds"] = waited.elapsed().as_secs_f64().into(); + let pool = + if borrowed { pools.wide.unwrap_or(pools.lane) } else { pools.lane }; + pool.install(|| { + let start = Instant::now(); + let traces = tracing_texray::examine( + tracing::info_span!("aiur.trace", id = %job.id), + ) + .in_scope(|| backend.prepare_stage_1(&record, &entry, &args))?; + if traces.cells() != batch.stage1_cells { + return Err("generated trace differs from resource plan".into()); + } + report["trace_seconds"] = start.elapsed().as_secs_f64().into(); + drop(record); + let start = Instant::now(); + let proof = tracing_texray::examine( + tracing::info_span!("aiur.prove", id = %job.id, lane), + ) + .in_scope(|| { + backend.prove_stage_one( + &entry, + &args, + &[], + traces, + batch.max_rows, + batch.retention(), + ) + })?; + report["proving_seconds"] = start.elapsed().as_secs_f64().into(); + report = output::proof( + &job, + kind, + backend, + &entry, + &args, + &proof, + report.take(), + )?; + Ok(()) + }) + })(); + match result { + Ok(()) if report["verified"] == true => (job, 0, report), + Ok(()) => { + let _ = output::report(&job, kind, &report); + (job, 75, report) + }, + Err(error) => { + report["error"] = error.into(); + let _ = output::report(&job, kind, &report); + (job, 1, report) + }, + } +} + +struct Shutdown<'a> { + pool: &'a RecordPool, + prep: &'a WorkQueue, + records: &'a WorkQueue, +} + +fn parent_gone(pid: Option) -> bool { + #[cfg(target_os = "linux")] + { + pid.is_some_and(|pid| !Path::new(&format!("/proc/{pid}")).exists()) + } + #[cfg(not(target_os = "linux"))] + { + let _ = pid; + false + } +} +impl Drop for Shutdown<'_> { + fn drop(&mut self) { + self.pool.shutdown(); + self.prep.close(); + self.records.close(); + } +} + +fn serve(config: Config, dir: &Path) -> Result<(), String> { + tracing(config.texray)?; + if config.artifacts.is_empty() + || config.devices.is_empty() + || config.exec_jobs == 0 + || config.threads_per_prover == 0 + || config.max_ram_bytes == 0 + || config.record_limit_bytes == Some(0) + { + return Err("artifacts, lanes, execution threads, prover threads and RAM must be positive".into()); + } + let mut seen_devices = HashSet::new(); + if config.devices.iter().any(Option::is_some) + && config.devices.iter().any(Option::is_none) + { + return Err("controller cannot mix CPU lanes and CUDA lanes".into()); + } + // Lanes own distinct devices. Tests on a single GPU may share one between + // lanes to exercise concurrent multi-lane proving in one process. + let shared = std::env::var("IX_PROVER_SHARED_DEVICES").as_deref() == Ok("1"); + for device in &config.devices { + planning::Options { device: *device, ..Default::default() }.validate()?; + if let Some(device) = device + && !seen_devices.insert(device) + && !shared + { + return Err("duplicate GPU lane".into()); + } + } + fs::create_dir_all(dir.join("pending")).map_err(|e| e.to_string())?; + fs::create_dir_all(dir.join("done")).map_err(|e| e.to_string())?; + let log = Log { + file: Mutex::new( + fs::File::create(dir.join("events.jsonl")).map_err(|e| e.to_string())?, + ), + start: Instant::now(), + }; + let packages = config + .artifacts + .iter() + .map(|artifact| { + aiur::decode_artifact::( + &fs::read(&artifact.path).map_err(|e| e.to_string())?, + ) + .map_err(|e| e.to_string()) + }) + .collect::, String>>()?; + let mut programs = Vec::new(); + let mut artifacts = Vec::new(); + for package in packages { + programs.push(package.program.check_field::()?); + artifacts.push(package.trace); + } + let plans = programs + .iter() + .zip(artifacts) + .map(|(p, a)| TracePlan::new(p, a)) + .collect::, _>>()?; + let paths = config + .artifacts + .iter() + .map(|a| fs::canonicalize(&a.path).map_err(|e| e.to_string())) + .collect::, _>>()?; + let mut lanes = Vec::new(); + for device in &config.devices { + lanes.push( + plans + .iter() + .map(|p| { + Backend::for_batch_on_device(p, Parameters::default(), *device) + }) + .collect::, _>>()?, + ); + } + let static_bytes = planning::resident_memory(); + let remaining = config + .max_ram_bytes + .checked_sub(static_bytes.saturating_mul(5) / 4) + .ok_or("RAM budget cannot hold resident artifacts and prover systems")?; + let records_bytes = + usize::try_from(remaining / 2).map_err(|_| "record pool overflow")?; + if records_bytes == 0 { + return Err("no record capacity remains".into()); + } + let workspace = Workspace::new(remaining / 2, config.devices.len()); + // CPU lanes borrowing the whole workspace also borrow the waiting lanes' + // threads. CUDA lanes keep their own: the device does the heavy work. + let wide = (config.devices.len() > 1 + && config.devices.iter().all(Option::is_none)) + .then(|| { + rayon::ThreadPoolBuilder::new() + .num_threads( + config.threads_per_prover.saturating_mul(config.devices.len()), + ) + .build() + .map_err(|e| e.to_string()) + }) + .transpose()?; + let capacity = + config.exec_jobs.saturating_add(config.devices.len().saturating_mul(2)); + let pool = RecordPool::new( + records_bytes, + (records_bytes / capacity).clamp(1, 16 << 20), + ) + .with_record_limit( + config + .record_limit_bytes + .unwrap_or(128usize << 30) + .min(records_bytes) + .max(1), + ); + let prep_queue = WorkQueue::::new(config.exec_jobs); + let records = WorkQueue::::new(capacity); + let (send, receive) = mpsc::channel(); + std::thread::scope(|scope| -> Result<(), String> { + // Drop before scoped joins even if a later worker setup fails. + let _shutdown = + Shutdown { pool: &pool, prep: &prep_queue, records: &records }; + for executor in 0..config.exec_jobs { + let (programs, kinds, log, send, prep_queue, records) = ( + &programs, + &config.artifacts, + &log, + send.clone(), + &prep_queue, + &records, + ); + scope.spawn(move || { + while let Some(task) = prep_queue.pop() { + log.event(json!({"phase":"execute", "id":task.job.id, "executor":executor})); + let id = task.artifact; + match prepare(&programs[id], kinds[id].kind, task) { + Ok(prepared) => { + log.event(json!({"phase":"prepared", "id":prepared.job.id, "record_bytes":prepared.report["record_bytes"]})); + let _ = send.send(Event::Prepared); + let priority = prepared.job.priority; + if records.push(prepared, priority).is_err() { break; } + }, + Err(failure) => { + let (job, code, report, retry) = *failure; + if retry { let _ = send.send(Event::Retry(job)); } + else { let _ = output::report(&job, kinds[id].kind, &report); let _ = send.send(Event::Done(job, code, report, true)); } + }, + } + } + }); + } + for (lane, backends) in lanes.into_iter().enumerate() { + let (kinds, log, records, send, threads, device, workspace, wide) = ( + &config.artifacts, + &log, + &records, + send.clone(), + config.threads_per_prover, + config.devices[lane], + &workspace, + wide.as_ref(), + ); + let rayon = rayon::ThreadPoolBuilder::new() + .num_threads(threads) + .build() + .map_err(|e| e.to_string())?; + scope.spawn(move || { + let pools = Pools { lane: &rayon, wide }; + while let Some(prepared) = records.pop_matching(|r| { + r.job.options.device.is_none() || r.job.options.device == device + }) { + log.event(json!({"phase":"prove", "id":prepared.job.id, "lane":lane, "device":device})); + let id = prepared.artifact; + let (job, code, report) = prove( + &backends[id], + kinds[id].kind, + prepared, + workspace, + &pools, + lane, + device, + ); + let _ = send.send(Event::Done(job, code, report, false)); + } + }); + } + atomic_json( + &dir.join("ready.json"), + &json!({"ready":true, "lanes":config.devices, "executors":config.exec_jobs, + "static_bytes":static_bytes, "record_budget_bytes":records_bytes, "workspace_per_lane_bytes":workspace.share, + "workspace_bytes":workspace.total}), + )?; + let mut pending = VecDeque::new(); + let mut seen = HashSet::new(); + let mut active = 0; + let mut preparing = 0; + loop { + if dir.join("stop").exists() || parent_gone(config.parent_pid) { + break; + } + for event in receive.try_iter() { + match event { + Event::Prepared => preparing -= 1, + Event::Retry(job) => { + active -= 1; + preparing -= 1; + log.event(json!({"phase":"retry", "id":job.id})); + pending.push_front(job); + }, + Event::Done(job, code, report, failed_preparation) => { + active -= 1; + if failed_preparation { + preparing -= 1; + } + log.event(json!({"phase":"done", "id":job.id, "status":code, "report":report})); + atomic_json( + &dir.join("done").join(format!("{}.json", job.id)), + &json!({"status":code,"report":report}), + )?; + }, + } + } + let mut files = fs::read_dir(dir.join("pending")) + .map_err(|e| e.to_string())? + .filter_map(Result::ok) + .map(|e| e.path()) + .filter(|p| p.extension().is_some_and(|s| s == "json")) + .collect::>(); + files.sort(); + for path in files { + let job: Job = read_json(&path)?; + if job.id.is_empty() + || job.id.len() > 128 + || !job + .id + .bytes() + .all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_') + || !seen.insert(job.id.clone()) + { + return Err("invalid or duplicate job ID".into()); + } + fs::remove_file(path).map_err(|e| e.to_string())?; + log.event( + json!({"phase":"queued", "id":job.id, "priority":job.priority}), + ); + if job.priority { + let index = pending + .iter() + .position(|p: &Job| !p.priority) + .unwrap_or(pending.len()); + pending.insert(index, job); + } else { + pending.push_back(job); + } + } + while active < capacity + && preparing < config.exec_jobs + && !pending.is_empty() + { + let Some(reservation) = pool.try_admit().map_err(|e| e.to_string())? + else { + break; + }; + let job = pending.pop_front().unwrap(); + if job.options.device.is_some() + && !config.devices.contains(&job.options.device) + { + atomic_json( + &dir.join("done").join(format!("{}.json", job.id)), + &json!({"status":1,"report":fail("requested CUDA device is not a controller lane")}), + )?; + continue; + } + let artifact = fs::canonicalize(&job.artifact) + .ok() + .and_then(|p| paths.iter().position(|a| *a == p)); + let Some(artifact) = artifact else { + atomic_json( + &dir.join("done").join(format!("{}.json", job.id)), + &json!({"status":1,"report":fail("artifact was not loaded by this controller")}), + )?; + continue; + }; + let priority = job.priority; + prep_queue + .push(Prep { job, artifact, reservation }, priority) + .map_err(|_| "execution queue closed")?; + active += 1; + preparing += 1; + } + std::thread::sleep(Duration::from_millis(10)); + } + Ok(()) + })?; + let stats = pool.stats(); + atomic_json( + &dir.join("summary.json"), + &json!({"record_peak_bytes":stats.peak_reserved, + "record_reserved_bytes":stats.reserved,"record_waits":stats.waits, + "record_wait_seconds":stats.wait_time.as_secs_f64(),"record_retries":stats.retries}), + )?; + Ok(()) +} + +fn main() { + let args: Vec<_> = std::env::args_os().collect(); + let result = if args.len() == 4 && args[1] == "serve" { + let dir = PathBuf::from(&args[3]); + read_json(Path::new(&args[2])) + .and_then(|config| serve(config, &dir)) + .inspect_err(|error| { + let _ = atomic_json(&dir.join("failed.json"), &fail(error)); + }) + } else if args.len() == 6 && args[1] == "distributed" { + distributed::run( + Path::new(&args[2]), + Path::new(&args[3]), + Path::new(&args[4]), + Path::new(&args[5]), + ) + } else { + Err("usage: ix-prover serve CONFIG.json SPOOL_DIRECTORY | distributed ARTIFACT SPEC OUTPUT OPTIONS".into()) + }; + if let Err(error) = result { + eprintln!("ix-prover: {error}"); + std::process::exit(1); + } +} + +#[cfg(test)] +mod tests { + use super::*; + + /// A request larger than what is free waits for a release, and a later + /// request that would fit does not overtake it. + #[test] + fn workspace_reservations_are_granted_in_order() { + let workspace = Workspace::new(100, 2); + assert_eq!(workspace.share, 50); + let queued = |count| { + while workspace.state.lock().unwrap().next < count { + std::thread::yield_now(); + } + }; + let first = workspace.reserve(60); + let (granted, receive) = mpsc::channel(); + std::thread::scope(|scope| { + let send = granted.clone(); + let workspace = &workspace; + scope.spawn(move || { + let _whole = workspace.reserve(100); + send.send("whole").unwrap(); + }); + queued(2); + let send = granted.clone(); + scope.spawn(move || { + let _small = workspace.reserve(10); + send.send("small").unwrap(); + }); + queued(3); + std::thread::sleep(Duration::from_millis(50)); + assert!(receive.try_recv().is_err(), "granted before the release"); + drop(first); + assert_eq!(receive.recv().unwrap(), "whole"); + assert_eq!(receive.recv().unwrap(), "small"); + }); + assert_eq!(workspace.state.lock().unwrap().free, 100); + // A request is never larger than the workspace. + assert_eq!(workspace.reserve(u64::MAX).bytes, 100); + } +} diff --git a/crates/ix-prover/src/output.rs b/crates/ix-prover/src/output.rs new file mode 100644 index 000000000..790036e6c --- /dev/null +++ b/crates/ix-prover/src/output.rs @@ -0,0 +1,65 @@ +use crate::protocol::{Job, Kind, atomic_json}; +use aiur::field::NativeField; +use aiur::trace::stark::{Backend, BatchProof}; +use multi_stark::{p3_field::PrimeField64, types::Val}; +use serde_json::{Value, json}; + +pub fn report(job: &Job, kind: Kind, report: &Value) -> Result<(), String> { + let path = match kind { + Kind::Ixvm => { + std::path::PathBuf::from(format!("{}.report.json", job.output.display())) + }, + Kind::Recursion => { + std::fs::create_dir_all(&job.output).map_err(|e| e.to_string())?; + job.output.join("report.json") + }, + }; + atomic_json(&path, report) +} + +pub fn proof( + job: &Job, + kind: Kind, + backend: &Backend<'_, '_, NativeField>, + entry: &str, + args: &[Val], + proof: &BatchProof, + mut result: Value, +) -> Result { + let key = backend.verifying_key_bytes()?; + let claims = + stark_verifier::claims_bytes(&[backend.claim(entry, args, &[])?]); + let raw = proof.to_bytes().map_err(|e| e.to_string())?; + let write = |path: std::path::PathBuf, bytes: &[u8]| { + std::fs::write(path, bytes).map_err(|e| e.to_string()) + }; + match kind { + Kind::Ixvm => { + let mut bytes = b"IXAIUR2\0".to_vec(); + bytes.extend_from_slice(&raw); + write(job.output.clone(), &bytes)?; + write(format!("{}.vk", job.output.display()).into(), &key)?; + write(format!("{}.claims", job.output.display()).into(), &claims)?; + }, + Kind::Recursion => { + std::fs::create_dir_all(&job.output).map_err(|e| e.to_string())?; + write(job.output.join("proof.bin"), &raw)?; + write(job.output.join("key.bin"), &key)?; + write(job.output.join("claims.bin"), &claims)?; + atomic_json( + &job.output.join("public.json"), + &json!({"entry":entry, "args":args.iter().map(Val::as_canonical_u64).collect::>()}), + )?; + atomic_json( + &job.output.join("input.json"), + &stark_verifier::invocation(&key, &claims, &raw), + )?; + }, + } + result["verified"] = true.into(); + result["shards"] = proof.proofs.len().into(); + result["proof_bytes"] = raw.len().into(); + result["key_digest"] = blake3::hash(&key).to_hex().to_string().into(); + report(job, kind, &result)?; + Ok(result) +} diff --git a/crates/ix-prover/src/protocol.rs b/crates/ix-prover/src/protocol.rs new file mode 100644 index 000000000..f98da4f38 --- /dev/null +++ b/crates/ix-prover/src/protocol.rs @@ -0,0 +1,69 @@ +use aiur::trace::stark::planning::Options; +use serde::{Deserialize, Serialize}; +use std::path::{Path, PathBuf}; + +#[derive(Clone, Copy, Debug, Deserialize, Serialize)] +#[serde(rename_all = "lowercase")] +pub enum Kind { + Ixvm, + Recursion, +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Artifact { + pub path: PathBuf, + pub kind: Kind, +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Config { + pub artifacts: Vec, + pub devices: Vec>, + pub exec_jobs: usize, + pub threads_per_prover: usize, + pub max_ram_bytes: u64, + #[serde(default)] + pub record_limit_bytes: Option, + #[serde(default)] + pub parent_pid: Option, + #[serde(default)] + pub texray: bool, +} + +#[derive(Clone, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Job { + pub id: String, + pub artifact: PathBuf, + pub input: PathBuf, + pub output: PathBuf, + #[serde(default)] + pub options: Options, + #[serde(default)] + pub priority: bool, +} + +pub fn atomic_json(path: &Path, value: &impl Serialize) -> Result<(), String> { + use std::io::Write; + let tmp = path.with_extension(format!("tmp.{}", std::process::id())); + // Recursive inputs encode each proof byte as a JSON number. Without a + // buffer every token is its own write syscall: seconds per proof. + let mut file = std::io::BufWriter::new( + std::fs::File::create(&tmp).map_err(|e| e.to_string())?, + ); + serde_json::to_writer(&mut file, value).map_err(|e| e.to_string())?; + file.flush().map_err(|e| e.to_string())?; + drop(file); + std::fs::rename(tmp, path).map_err(|e| e.to_string()) +} + +pub fn read_json( + path: &Path, +) -> Result { + let file = std::fs::File::open(path) + .map_err(|e| format!("{}: {e}", path.display()))?; + serde_json::from_reader(std::io::BufReader::new(file)) + .map_err(|e| format!("{}: {e}", path.display())) +} diff --git a/crates/ixon/src/shard_claim.rs b/crates/ixon/src/shard_claim.rs index fe9c35832..dc60d81ea 100644 --- a/crates/ixon/src/shard_claim.rs +++ b/crates/ixon/src/shard_claim.rs @@ -1,6 +1,5 @@ //! Shard `CheckEnv` claim convention — the single source of truth shared -//! by every builder (Lean `IxVM.ClaimHarness.shardCheckEnvClaim`, -//! `ixvm-codegen::aiur_ixvm_witness::build_shard_check_env_witness`, +//! by every builder (Lean `IxVM.ClaimHarness.shardCheckEnvClaim` and //! `ix-kernel::claim`). Any change here changes claim digests; keep the //! Lean mirror in lockstep. //! @@ -51,7 +50,7 @@ use ix_common::address::Address; /// itself an entry of `Constant.sharing`, which is walked separately, so /// coverage is complete and the traversal stays linear. /// -/// Mirror of `const_idxs_expr` in `Ix/IxVM/Kernel/Claim.lean`. +/// Mirror of `const_idxs_expr` in `IxVM/IxVM/Modules/KernelClaim.aiur`. fn const_idxs_expr(e: &Expr, out: &mut FxHashSet) { match e { Expr::Ref(i, _) => { @@ -77,7 +76,7 @@ fn const_idxs_expr(e: &Expr, out: &mut FxHashSet) { /// The `refs` indices a constant uses as constants, over its `sharing` /// table and every Expr its `ConstantInfo` carries. /// -/// Mirror of `const_idxs_of` in `Ix/IxVM/Kernel/Claim.lean`. +/// Mirror of `const_idxs_of` in `IxVM/IxVM/Modules/KernelClaim.aiur`. fn const_idxs_of(c: &Constant) -> FxHashSet { let mut out = FxHashSet::default(); for e in &c.sharing { diff --git a/crates/ixvm-codegen/Cargo.toml b/crates/ixvm-codegen/Cargo.toml deleted file mode 100644 index 42e1e5322..000000000 --- a/crates/ixvm-codegen/Cargo.toml +++ /dev/null @@ -1,17 +0,0 @@ -[package] -name = "ixvm-codegen" -version.workspace = true -edition.workspace = true -license.workspace = true - -[dependencies] -aiur = { workspace = true } -ix-common = { workspace = true } -ixon = { workspace = true } -multi-stark = { workspace = true } -rayon = { workspace = true } -rustc-hash = { workspace = true } -stacker = "0.1" - -[lints] -workspace = true diff --git a/crates/ixvm-codegen/src/aiur_ix_aggr.rs b/crates/ixvm-codegen/src/aiur_ix_aggr.rs deleted file mode 100644 index 0e7feceb4..000000000 --- a/crates/ixvm-codegen/src/aiur_ix_aggr.rs +++ /dev/null @@ -1,1336 +0,0 @@ -// Auto-generated by Aiur codegen. Do not edit. -// Mirrors crates/aiur/src/execute.rs QueryRecord side effects. -#![cfg_attr(rustfmt, rustfmt::skip)] -#![allow(unused_variables, unused_assignments, unused_mut, dead_code, -unused_parens, non_snake_case, clippy::all, -clippy::ptr_as_ptr, clippy::match_same_arms, -clippy::large_types_passed_by_value)] -use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; -use aiur::G; -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); }) } -const INPUT_SIZE_1: usize = 2; -const IN_1: usize = 2; -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 __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_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __loaded: [G; 32] = { let __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_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 = G::from_u64(256); let __v_67: G = __v_9 * __v_66; let __v_68: G = __v_67 + __v_8; let __v_69: G = __v_68 * __v_66; let __v_70: G = __v_69 + __v_7; let __v_71: G = __v_70 * __v_66; let __v_72: G = __v_71 + __v_6; let __v_73: G = __v_72 * __v_66; let __v_74: G = __v_73 + __v_5; let __v_75: G = __v_74 * __v_66; let __v_76: G = __v_75 + __v_4; let __v_77: G = __v_76 * __v_66; let __v_78: G = __v_77 + __v_3; let __v_79: G = __v_41 * __v_66; let __v_80: G = __v_79 + __v_40; let __v_81: G = __v_80 * __v_66; let __v_82: G = __v_81 + __v_39; let __v_83: G = __v_82 * __v_66; let __v_84: G = __v_83 + __v_38; let __v_85: G = __v_84 * __v_66; let __v_86: G = __v_85 + __v_37; let __v_87: G = __v_86 * __v_66; let __v_88: G = __v_87 + __v_36; let __v_89: G = __v_88 * __v_66; let __v_90: G = __v_89 + __v_35; let __v_91: G = __v_78 - __v_90; match __v_91.as_canonical_u64() { 0u64 => { let __v_92: G = G::from_u64(256); let __v_93: G = __v_16 * __v_92; let __v_94: G = __v_93 + __v_15; let __v_95: G = __v_94 * __v_92; let __v_96: G = __v_95 + __v_14; let __v_97: G = __v_96 * __v_92; let __v_98: G = __v_97 + __v_13; let __v_99: G = __v_98 * __v_92; let __v_100: G = __v_99 + __v_12; let __v_101: G = __v_100 * __v_92; let __v_102: G = __v_101 + __v_11; let __v_103: G = __v_102 * __v_92; let __v_104: G = __v_103 + __v_10; let __v_105: G = __v_48 * __v_92; let __v_106: G = __v_105 + __v_47; let __v_107: G = __v_106 * __v_92; let __v_108: G = __v_107 + __v_46; let __v_109: G = __v_108 * __v_92; let __v_110: G = __v_109 + __v_45; let __v_111: G = __v_110 * __v_92; let __v_112: G = __v_111 + __v_44; let __v_113: G = __v_112 * __v_92; let __v_114: G = __v_113 + __v_43; let __v_115: G = __v_114 * __v_92; let __v_116: G = __v_115 + __v_42; let __v_117: G = __v_104 - __v_116; match __v_117.as_canonical_u64() { 0u64 => { let __v_118: G = G::from_u64(256); let __v_119: G = __v_23 * __v_118; let __v_120: G = __v_119 + __v_22; let __v_121: G = __v_120 * __v_118; let __v_122: G = __v_121 + __v_21; let __v_123: G = __v_122 * __v_118; let __v_124: G = __v_123 + __v_20; let __v_125: G = __v_124 * __v_118; let __v_126: G = __v_125 + __v_19; let __v_127: G = __v_126 * __v_118; let __v_128: G = __v_127 + __v_18; let __v_129: G = __v_128 * __v_118; let __v_130: G = __v_129 + __v_17; let __v_131: G = __v_55 * __v_118; let __v_132: G = __v_131 + __v_54; let __v_133: G = __v_132 * __v_118; let __v_134: G = __v_133 + __v_53; let __v_135: G = __v_134 * __v_118; let __v_136: G = __v_135 + __v_52; let __v_137: G = __v_136 * __v_118; let __v_138: G = __v_137 + __v_51; let __v_139: G = __v_138 * __v_118; let __v_140: G = __v_139 + __v_50; let __v_141: G = __v_140 * __v_118; let __v_142: G = __v_141 + __v_49; let __v_143: G = __v_130 - __v_142; match __v_143.as_canonical_u64() { 0u64 => { let __v_144: G = G::from_u64(256); let __v_145: G = __v_30 * __v_144; let __v_146: G = __v_145 + __v_29; let __v_147: G = __v_146 * __v_144; let __v_148: G = __v_147 + __v_28; let __v_149: G = __v_148 * __v_144; let __v_150: G = __v_149 + __v_27; let __v_151: G = __v_150 * __v_144; let __v_152: G = __v_151 + __v_26; let __v_153: G = __v_152 * __v_144; let __v_154: G = __v_153 + __v_25; let __v_155: G = __v_154 * __v_144; let __v_156: G = __v_155 + __v_24; let __v_157: G = __v_62 * __v_144; let __v_158: G = __v_157 + __v_61; let __v_159: G = __v_158 * __v_144; let __v_160: G = __v_159 + __v_60; let __v_161: G = __v_160 * __v_144; let __v_162: G = __v_161 + __v_59; let __v_163: G = __v_162 * __v_144; let __v_164: G = __v_163 + __v_58; let __v_165: G = __v_164 * __v_144; let __v_166: G = __v_165 + __v_57; let __v_167: G = __v_166 * __v_144; let __v_168: G = __v_167 + __v_56; let __v_169: G = __v_156 - __v_168; match __v_169.as_canonical_u64() { 0u64 => { let __v_170: G = G::from_u64(256); let __v_171: G = __v_33 * __v_170; let __v_172: G = __v_171 + __v_32; let __v_173: G = __v_172 * __v_170; let __v_174: G = __v_173 + __v_31; let __v_175: G = __v_65 * __v_170; let __v_176: G = __v_175 + __v_64; let __v_177: G = __v_176 * __v_170; let __v_178: G = __v_177 + __v_63; let __v_179: G = __v_174 - __v_178; match __v_179.as_canonical_u64() { 0u64 => { let __v_180: G = G::from_u64(1); let __ret: [G; OUT_1] = [__v_180]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_180: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_180]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_170: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_170]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_144: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_144]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_118: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_118]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_92: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_92]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_2: usize = 2; -const IN_2: usize = 2; -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 __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_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __loaded: [G; 32] = { let __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_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; let __v_37: G = __loaded[3]; let __v_38: G = __loaded[4]; let __v_39: G = __loaded[5]; let __v_40: G = __loaded[6]; let __v_41: G = __loaded[7]; let __v_42: G = __loaded[8]; let __v_43: G = __loaded[9]; let __v_44: G = __loaded[10]; let __v_45: G = __loaded[11]; let __v_46: G = __loaded[12]; let __v_47: G = __loaded[13]; let __v_48: G = __loaded[14]; let __v_49: G = __loaded[15]; let __v_50: G = __loaded[16]; let __v_51: G = __loaded[17]; let __v_52: G = __loaded[18]; let __v_53: G = __loaded[19]; let __v_54: G = __loaded[20]; let __v_55: G = __loaded[21]; let __v_56: G = __loaded[22]; let __v_57: G = __loaded[23]; let __v_58: G = __loaded[24]; let __v_59: G = __loaded[25]; let __v_60: G = __loaded[26]; let __v_61: G = __loaded[27]; let __v_62: G = __loaded[28]; let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; let __v_66: G = __v_2 - __v_34; match __v_66.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; 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_67: G = __r_arr[0]; let __ret: [G; OUT_2] = [__v_67]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_67: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_67]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_3: usize = 3; -const IN_3: usize = 3; -const OUT_3: usize = 1; -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]; 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_3] = [__v_4]; record.function_queries[3].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { 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_3: G = __io_read[0]; if (!unconstrained) { let __vi = __v_3; 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); } 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 __v_7: G = { let __values: [G; 3] = [__v_4, __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_3] = [__v_7]; record.function_queries[3].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __io_read: [G; 2] = { 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, 2)?; let __arr: [G; 2] = __data[..2].try_into().unwrap(); __arr }; let __v_3: G = __io_read[0]; let __v_4: G = __io_read[1]; 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); } let __v_5: G = G::from_u64(2); let __v_6: G = __v_1 + __v_5; let __v_7: G = __v_2 - __v_5; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(3, &__args[..])?) { [G::ZERO; OUT_3] } else { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[3].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[3].bump_multiplicity(__i); } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_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 __v_11: G = { let __values: [G; 3] = [__v_9, __v_3, __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_3] = [__v_11]; record.function_queries[3].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_4: usize = 8; -const IN_4: usize = 8; -const OUT_4: usize = 1; -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]; 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_4] = [__v_8]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; 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 __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_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 = 12; -const IN_6: usize = 12; -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 __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 = __v_16 * __v_18; let __v_20: G = G::from_u64(2); let __v_21: G = __v_16 - __v_20; let __v_22: G = __v_19 * __v_21; let __v_23: G = G::from_u64(0); if (__v_22 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __ret: [G; OUT_6] = [__v_12, __v_13, __v_14, __v_15]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_7: usize = 8; -const IN_7: usize = 8; -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 __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_7] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[7].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_8: usize = 4; -const IN_8: usize = 4; -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 __ret: [G; OUT_8] = [__v_2, __v_3, __v_0, __v_1]; record.function_queries[8].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_9: usize = 4; -const IN_9: usize = 4; -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 __ret: [G; OUT_9] = [__v_1, __v_2, __v_3, __v_0]; record.function_queries[9].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_10: usize = 8; -const IN_10: usize = 8; -const OUT_10: usize = 4; -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 __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_10] = [__v_16, __v_17, __v_18, __v_19]; 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 = 4; -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]; 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_11] = [__v_16, __v_17, __v_18, __v_19]; record.function_queries[11].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_12: usize = 16; -const IN_12: usize = 16; -const OUT_12: usize = 1; -fn aiur_fn_12(inp: [G; IN_12], 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 = 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_12] = [__v_24]; record.function_queries[12].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; record.function_queries[12].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; 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 = 8; -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]; 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_13] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; record.function_queries[13].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_13] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10]; record.function_queries[13].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_13] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_7]; record.function_queries[13].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_13] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_6, __v_7]; record.function_queries[13].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_13] = [__v_8, __v_8, __v_8, __v_8, __v_10, __v_5, __v_6, __v_7]; record.function_queries[13].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_13] = [__v_8, __v_8, __v_8, __v_10, __v_4, __v_5, __v_6, __v_7]; record.function_queries[13].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_13] = [__v_8, __v_8, __v_10, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[13].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_13] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[13].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_13] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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(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 = __v_0 + __v_10; let __v_12: G = G::from_u64(65536); let __v_13: G = __v_12 * __v_2; let __v_14: G = __v_11 + __v_13; let __v_15: G = G::from_u64(16777216); let __v_16: G = __v_15 * __v_3; let __v_17: G = __v_14 + __v_16; let __v_18: G = G::from_u64(4294967296); let __v_19: G = __v_18 * __v_4; let __v_20: G = __v_17 + __v_19; let __v_21: G = G::from_u64(1099511627776); let __v_22: G = __v_21 * __v_5; let __v_23: G = __v_20 + __v_22; let __v_24: G = G::from_u64(281474976710656); let __v_25: G = __v_24 * __v_6; let __v_26: G = __v_23 + __v_25; let __ret: [G; OUT_14] = [__v_26]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_15: usize = 8; -const IN_15: usize = 8; -const OUT_15: usize = 1; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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 = __v_0 + __v_9; let __v_11: G = G::from_u64(65536); let __v_12: G = __v_11 * __v_2; let __v_13: G = __v_10 + __v_12; let __v_14: G = G::from_u64(16777216); let __v_15: G = __v_14 * __v_3; let __v_16: G = __v_13 + __v_15; let __v_17: G = G::from_u64(4294967296); let __v_18: G = __v_17 * __v_4; let __v_19: G = __v_16 + __v_18; let __v_20: G = G::from_u64(1099511627776); let __v_21: G = __v_20 * __v_5; let __v_22: G = __v_19 + __v_21; let __v_23: G = G::from_u64(281474976710656); let __v_24: G = __v_23 * __v_6; let __v_25: G = __v_22 + __v_24; let __v_26: G = G::from_u64(72057594037927936); let __v_27: G = __v_26 * __v_7; let __v_28: G = __v_25 + __v_27; let __ret: [G; OUT_15] = [__v_28]; record.function_queries[15].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_16: usize = 8; -const IN_16: usize = 8; -const OUT_16: usize = 1; -fn aiur_fn_16(inp: [G; IN_16], 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 = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_4 + __v_5; let __v_9: G = __v_8 + __v_6; let __v_10: G = __v_9 + __v_7; let __v_11: G = G::from_u64(1020); let __v_12: G = __v_10 - __v_11; let __v_13: G = G::from_bool(__v_12 == G::ZERO); let __v_14: G = __v_0 + __v_1; let __v_15: G = __v_14 + __v_2; let __v_16: G = __v_15 + __v_3; 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_16] = [__v_21]; record.function_queries[16].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_17: usize = 1; -const IN_17: usize = 1; -const OUT_17: usize = 8; -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 __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 = __v_1 + __v_10; let __v_12: G = G::from_u64(65536); let __v_13: G = __v_12 * __v_3; let __v_14: G = __v_11 + __v_13; let __v_15: G = G::from_u64(16777216); let __v_16: G = __v_15 * __v_4; let __v_17: G = __v_14 + __v_16; let __v_18: G = G::from_u64(4294967296); let __v_19: G = __v_18 * __v_5; let __v_20: G = __v_17 + __v_19; let __v_21: G = G::from_u64(1099511627776); let __v_22: G = __v_21 * __v_6; let __v_23: G = __v_20 + __v_22; let __v_24: G = G::from_u64(281474976710656); let __v_25: G = __v_24 * __v_7; let __v_26: G = __v_23 + __v_25; let __v_27: G = G::from_u64(72057594037927936); let __v_28: G = __v_27 * __v_8; let __v_29: G = __v_26 + __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 = __v_5 + __v_6; let __v_31: G = __v_30 + __v_7; let __v_32: G = __v_31 + __v_8; let __v_33: G = G::from_u64(1020); let __v_34: G = __v_32 - __v_33; let __v_35: G = G::from_bool(__v_34 == G::ZERO); let __v_36: G = __v_1 + __v_2; let __v_37: G = __v_36 + __v_3; let __v_38: G = __v_37 + __v_4; 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_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_18: usize = 1; -const IN_18: usize = 1; -const OUT_18: usize = 1; -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 = 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_18] = [__v_1]; record.function_queries[18].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_19: usize = 4; -const IN_19: usize = 4; -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 = 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_19] = [__v_4, __v_5]; 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 = __v_1 - __v_3; let __ret: [G; OUT_20] = [__v_4, __v_5]; 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 = G::from_u64(0); let __v_3: G = __v_2 - __v_0; let __v_4: G = __v_2 - __v_1; let __ret: [G; OUT_21] = [__v_3, __v_4]; 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_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_22] = [__v_8, __v_11]; record.function_queries[22].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_23: usize = 2; -const IN_23: usize = 2; -const OUT_23: usize = 2; -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 = __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_23] = [__v_14, __v_16]; record.function_queries[23].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_24: usize = 4; -const IN_24: usize = 4; -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 __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_24] = [__v_22, __v_25]; record.function_queries[24].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_25: usize = 4; -const IN_25: usize = 4; -const OUT_25: usize = 1; -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 __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_25] = [__v_8]; 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 __loaded: [G; 3] = { let __base = 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_26] = [__v_2, __v_3]; record.function_queries[26].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_26] = [__v_4, __v_6]; record.function_queries[26].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_27: usize = 1; -const IN_27: usize = 1; -const OUT_27: usize = 9; -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 __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_26] = { let __args: [G; IN_26] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_4]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_10]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_12]; let __cu = 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_14]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_27] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; 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 = 2; -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 __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(27, &__args[..])?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } 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 __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_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_28] = [__v_10, __v_9]; 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 __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_29] = [__v_2, __v_4]; 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 = 9; -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 __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_30] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; 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 = 2; -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_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__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_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_31] = [__v_10, __v_9]; 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 = 3; -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_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__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_30] = { let __args: [G; IN_30] = [__v_9]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__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 = __v_1 + __v_20; let __v_22: G = G::from_u64(65536); let __v_23: G = __v_22 * __v_3; let __v_24: G = __v_21 + __v_23; let __v_25: G = G::from_u64(16777216); let __v_26: G = __v_25 * __v_4; let __v_27: G = __v_24 + __v_26; let __v_28: G = G::from_u64(4294967296); let __v_29: G = __v_28 * __v_5; let __v_30: G = __v_27 + __v_29; let __v_31: G = G::from_u64(1099511627776); let __v_32: G = __v_31 * __v_6; let __v_33: G = __v_30 + __v_32; let __v_34: G = G::from_u64(281474976710656); let __v_35: G = __v_34 * __v_7; let __v_36: G = __v_33 + __v_35; let __v_37: G = G::from_u64(72057594037927936); let __v_38: G = __v_37 * __v_8; let __v_39: G = __v_36 + __v_38; let __v_40: G = __v_19 * __v_11; let __v_41: G = __v_10 + __v_40; let __v_42: G = __v_22 * __v_12; let __v_43: G = __v_41 + __v_42; let __v_44: G = __v_25 * __v_13; let __v_45: G = __v_43 + __v_44; let __v_46: G = __v_28 * __v_14; let __v_47: G = __v_45 + __v_46; let __v_48: G = __v_31 * __v_15; let __v_49: G = __v_47 + __v_48; let __v_50: G = __v_34 * __v_16; let __v_51: G = __v_49 + __v_50; let __v_52: G = __v_37 * __v_17; let __v_53: G = __v_51 + __v_52; let __ret: [G; OUT_32] = [__v_39, __v_53, __v_18]; record.function_queries[32].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_33: usize = 1; -const IN_33: usize = 1; -const OUT_33: usize = 33; -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 __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__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_30] = { let __args: [G; IN_30] = [__v_9]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__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_30] = { let __args: [G; IN_30] = [__v_18]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__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_30] = { let __args: [G; IN_30] = [__v_27]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__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_33] = [__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[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_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__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; 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_35] = [__v_3, __v_0]; record.function_queries[35].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 = true; { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if true => { 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 __v_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_3, __v_5]; 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_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_35] = [__v_9, __v_7]; 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_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__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; 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_37] = [__v_3, __v_0]; record.function_queries[37].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__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_37] = { let __args: [G; IN_37] = [__v_10, __v_12]; 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_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_37] = [__v_16, __v_14]; 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_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__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; 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_39] = [__v_3, __v_0]; record.function_queries[39].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__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_30] = { let __args: [G; IN_30] = [__v_10]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__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 = __v_2 + __v_21; let __v_23: G = G::from_u64(65536); let __v_24: G = __v_23 * __v_4; let __v_25: G = __v_22 + __v_24; let __v_26: G = G::from_u64(16777216); let __v_27: G = __v_26 * __v_5; let __v_28: G = __v_25 + __v_27; let __v_29: G = G::from_u64(4294967296); let __v_30: G = __v_29 * __v_6; let __v_31: G = __v_28 + __v_30; let __v_32: G = G::from_u64(1099511627776); let __v_33: G = __v_32 * __v_7; let __v_34: G = __v_31 + __v_33; let __v_35: G = G::from_u64(281474976710656); let __v_36: G = __v_35 * __v_8; let __v_37: G = __v_34 + __v_36; let __v_38: G = G::from_u64(72057594037927936); let __v_39: G = __v_38 * __v_9; let __v_40: G = __v_37 + __v_39; let __v_41: G = __v_20 * __v_12; let __v_42: G = __v_11 + __v_41; let __v_43: G = __v_23 * __v_13; let __v_44: G = __v_42 + __v_43; let __v_45: G = __v_26 * __v_14; let __v_46: G = __v_44 + __v_45; let __v_47: G = __v_29 * __v_15; let __v_48: G = __v_46 + __v_47; let __v_49: G = __v_32 * __v_16; let __v_50: G = __v_48 + __v_49; let __v_51: G = __v_35 * __v_17; let __v_52: G = __v_50 + __v_51; let __v_53: G = __v_38 * __v_18; let __v_54: G = __v_52 + __v_53; let __v_55: G = G::from_u64(1); let __v_56: G = __v_1 - __v_55; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_19, __v_56]; 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_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_39] = [__v_60, __v_58]; 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_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__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_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__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_30] = { let __args: [G; IN_30] = [__v_10]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__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_30] = { let __args: [G; IN_30] = [__v_19]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__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_30] = { let __args: [G; IN_30] = [__v_28]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__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_41] = { let __args: [G; IN_41] = [__v_37, __v_39]; 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_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_41] = [__v_44, __v_41]; 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_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__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_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_43] = { let __args: [G; IN_43] = [__v_3, __v_5]; 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_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_43] = [__v_9, __v_7]; 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_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__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_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__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 __v_6: G = G::from_u64(1); let __v_7: G = __v_1 - __v_6; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_5, __v_7]; 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_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_45] = [__v_11, __v_9]; 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_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__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_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_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_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(49, &__args[..])?) { [G::ZERO; OUT_49] } else { let (__hash, __hit) = record.function_queries[49].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[49].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[49].bump_multiplicity(__i); } let __ret: [G; OUT_49] = unsafe { *(record.function_queries[49].output_at(__i).as_ptr() as *const [G; OUT_49]) }; __ret }, _ => { aiur_fn_49::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_48] = [__v_3, __v_4]; record.function_queries[48].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_49: usize = 2; -const IN_49: usize = 2; -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 __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_49] = [__v_3, __v_0]; record.function_queries[49].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0]; 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_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_49] = { let __args: [G; IN_49] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(49, &__args[..])?) { [G::ZERO; OUT_49] } else { let (__hash, __hit) = record.function_queries[49].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[49].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[49].bump_multiplicity(__i); } let __ret: [G; OUT_49] = unsafe { *(record.function_queries[49].output_at(__i).as_ptr() as *const [G; OUT_49]) }; __ret }, _ => { aiur_fn_49::(__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_49] = [__v_9, __v_7]; record.function_queries[49].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_50: usize = 1; -const IN_50: usize = 1; -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 __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_50] = [__v_1, __v_2]; 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 = 2; -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_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(52, &__args[..])?) { [G::ZERO; OUT_52] } else { let (__hash, __hit) = record.function_queries[52].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[52].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => { aiur_fn_52::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_51] = [__v_3, __v_4]; record.function_queries[51].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_52: usize = 2; -const IN_52: usize = 2; -const OUT_52: usize = 2; -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 __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_52] = [__v_3, __v_0]; record.function_queries[52].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__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_52] = { let __args: [G; IN_52] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(52, &__args[..])?) { [G::ZERO; OUT_52] } else { let (__hash, __hit) = record.function_queries[52].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[52].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => { aiur_fn_52::(__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_52] = [__v_9, __v_7]; 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 = 4; -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_40] = { let __args: [G; IN_40] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_53] = [__v_1, __v_3, __v_5, __v_6]; record.function_queries[53].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_54: usize = 1; -const IN_54: usize = 1; -const OUT_54: usize = 3; -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 __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__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 __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_54] = [__v_3, __v_5, __v_6]; 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 = 2; -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_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(56, &__args[..])?) { [G::ZERO; OUT_56] } else { let (__hash, __hit) = record.function_queries[56].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[56].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => { aiur_fn_56::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_55] = [__v_3, __v_4]; record.function_queries[55].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_56: usize = 2; -const IN_56: usize = 2; -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 __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_56] = [__v_3, __v_0]; record.function_queries[56].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_3, __v_2]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__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_56] = { let __args: [G; IN_56] = [__v_7, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(56, &__args[..])?) { [G::ZERO; OUT_56] } else { let (__hash, __hit) = record.function_queries[56].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[56].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => { aiur_fn_56::(__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_56] = [__v_13, __v_11]; record.function_queries[56].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_57: usize = 1; -const IN_57: usize = 1; -const OUT_57: usize = 4; -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 __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if true => { 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_31] = { let __args: [G; IN_31] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_4, __v_3]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_57] = [__v_1, __v_5, __v_7, __v_8]; 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 = 2; -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_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_2, __v_1]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_58] = [__v_3, __v_4]; record.function_queries[58].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_59: usize = 2; -const IN_59: usize = 2; -const OUT_59: usize = 2; -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 __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_59] = [__v_3, __v_0]; record.function_queries[59].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 = true; { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if true => { 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_31] = { let __args: [G; IN_31] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_5, __v_4]; 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 __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__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_59] = { let __args: [G; IN_59] = [__v_9, __v_11]; 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_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_59] = [__v_15, __v_13]; 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 = 14; -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_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(52, &__args[..])?) { [G::ZERO; OUT_52] } else { let (__hash, __hit) = record.function_queries[52].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[52].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => { aiur_fn_52::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; if ((!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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_8, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(56, &__args[..])?) { [G::ZERO; OUT_56] } else { let (__hash, __hit) = record.function_queries[56].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[56].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => { aiur_fn_56::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_12, __v_11]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_14]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_16]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__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_60] = [__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[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 = 3; -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 = true; { let (__hash, __hit) = record.function_queries[29].lookup(&__args[..]); match __hit { Some(__i) if true => { 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]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_61] = [__v_3, __v_3, __v_2]; record.function_queries[61].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(48, &__args[..])?) { [G::ZERO; OUT_48] } else { let (__hash, __hit) = record.function_queries[48].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[48].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => { aiur_fn_48::(__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_61] = [__v_5, __v_3, __v_4]; 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 = 25; -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_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__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 __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_10]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_14, __v_13]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_18, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(52, &__args[..])?) { [G::ZERO; OUT_52] } else { let (__hash, __hit) = record.function_queries[52].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[52].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => { aiur_fn_52::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_20]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_24, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(56, &__args[..])?) { [G::ZERO; OUT_56] } else { let (__hash, __hit) = record.function_queries[56].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[56].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => { aiur_fn_56::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_28, __v_27]; 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_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_32]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__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_48] = { let __args: [G; IN_48] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(48, &__args[..])?) { [G::ZERO; OUT_48] } else { let (__hash, __hit) = record.function_queries[48].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[48].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => { aiur_fn_48::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(61, &__args[..])?) { [G::ZERO; OUT_61] } else { let (__hash, __hit) = record.function_queries[61].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[61].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[61].bump_multiplicity(__i); } let __ret: [G; OUT_61] = unsafe { *(record.function_queries[61].output_at(__i).as_ptr() as *const [G; OUT_61]) }; __ret }, _ => { aiur_fn_61::(__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_48] = { let __args: [G; IN_48] = [__v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(48, &__args[..])?) { [G::ZERO; OUT_48] } else { let (__hash, __hit) = record.function_queries[48].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[48].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => { aiur_fn_48::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(48, &__args[..])?) { [G::ZERO; OUT_48] } else { let (__hash, __hit) = record.function_queries[48].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[48].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => { aiur_fn_48::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __ret: [G; OUT_62] = [__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[62].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_63: usize = 1; -const IN_63: usize = 1; -const OUT_63: usize = 5; -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 __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__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 __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_8, __v_7]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_12, __v_11]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_63] = [__v_3, __v_5, __v_9, __v_13, __v_14]; 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 = 2; -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_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(65, &__args[..])?) { [G::ZERO; OUT_65] } else { let (__hash, __hit) = record.function_queries[65].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[65].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => { aiur_fn_65::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_64] = [__v_3, __v_4]; record.function_queries[64].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_65: usize = 2; -const IN_65: usize = 2; -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 __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_65] = [__v_3, __v_0]; record.function_queries[65].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_3, __v_2]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_9, __v_8]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_13, __v_12]; 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_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_65] = { let __args: [G; IN_65] = [__v_15, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(65, &__args[..])?) { [G::ZERO; OUT_65] } else { let (__hash, __hit) = record.function_queries[65].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[65].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => { aiur_fn_65::(__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_65] = [__v_21, __v_19]; record.function_queries[65].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_66: usize = 1; -const IN_66: usize = 1; -const OUT_66: usize = 10; -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 __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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_2]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__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_66] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; 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_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__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; 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_68] = [__v_3, __v_0]; record.function_queries[68].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 __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_3]; let __cu = true; { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__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_68] = { let __args: [G; IN_68] = [__v_12, __v_14]; 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_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_68] = [__v_18, __v_16]; 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 = 2; -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_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(70, &__args[..])?) { [G::ZERO; OUT_70] } else { let (__hash, __hit) = record.function_queries[70].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[70].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { *(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70]) }; __ret }, _ => { aiur_fn_70::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_69] = [__v_3, __v_4]; record.function_queries[69].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_70: usize = 2; -const IN_70: usize = 2; -const OUT_70: usize = 2; -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]; 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_70] = [__v_3, __v_0]; record.function_queries[70].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(62, &__args[..])?) { [G::ZERO; OUT_62] } else { let (__hash, __hit) = record.function_queries[62].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[62].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[62].bump_multiplicity(__i); } let __ret: [G; OUT_62] = unsafe { *(record.function_queries[62].output_at(__i).as_ptr() as *const [G; OUT_62]) }; __ret }, _ => { aiur_fn_62::(__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_70] = { let __args: [G; IN_70] = [__v_26, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(70, &__args[..])?) { [G::ZERO; OUT_70] } else { let (__hash, __hit) = record.function_queries[70].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[70].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { *(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70]) }; __ret }, _ => { aiur_fn_70::(__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_70] = [__v_32, __v_30]; record.function_queries[70].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_71: usize = 1; -const IN_71: usize = 1; -const OUT_71: usize = 4; -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 __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(65, &__args[..])?) { [G::ZERO; OUT_65] } else { let (__hash, __hit) = record.function_queries[65].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[65].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => { aiur_fn_65::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_6, __v_5]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_10, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(70, &__args[..])?) { [G::ZERO; OUT_70] } else { let (__hash, __hit) = record.function_queries[70].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[70].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { *(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70]) }; __ret }, _ => { aiur_fn_70::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_71] = [__v_3, __v_7, __v_11, __v_12]; record.function_queries[71].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_72: usize = 4; -const IN_72: usize = 4; -const OUT_72: usize = 1; -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 = 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 = __v_0 + __v_5; let __v_7: G = G::from_u64(65536); let __v_8: G = __v_7 * __v_2; let __v_9: G = __v_6 + __v_8; let __v_10: G = G::from_u64(16777216); let __v_11: G = __v_10 * __v_3; let __v_12: G = __v_9 + __v_11; let __ret: [G; OUT_72] = [__v_12]; record.function_queries[72].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_73: usize = 32; -const IN_73: usize = 32; -const OUT_73: usize = 8; -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 = G::from_u64(256); let __v_33: G = __v_32 * __v_1; let __v_34: G = __v_0 + __v_33; let __v_35: G = G::from_u64(65536); let __v_36: G = __v_35 * __v_2; let __v_37: G = __v_34 + __v_36; let __v_38: G = G::from_u64(16777216); let __v_39: G = __v_38 * __v_3; let __v_40: G = __v_37 + __v_39; let __v_41: G = __v_32 * __v_5; let __v_42: G = __v_4 + __v_41; let __v_43: G = __v_35 * __v_6; let __v_44: G = __v_42 + __v_43; let __v_45: G = __v_38 * __v_7; let __v_46: G = __v_44 + __v_45; let __v_47: G = __v_32 * __v_9; let __v_48: G = __v_8 + __v_47; let __v_49: G = __v_35 * __v_10; let __v_50: G = __v_48 + __v_49; let __v_51: G = __v_38 * __v_11; let __v_52: G = __v_50 + __v_51; let __v_53: G = __v_32 * __v_13; let __v_54: G = __v_12 + __v_53; let __v_55: G = __v_35 * __v_14; let __v_56: G = __v_54 + __v_55; let __v_57: G = __v_38 * __v_15; let __v_58: G = __v_56 + __v_57; let __v_59: G = __v_32 * __v_17; let __v_60: G = __v_16 + __v_59; let __v_61: G = __v_35 * __v_18; let __v_62: G = __v_60 + __v_61; let __v_63: G = __v_38 * __v_19; let __v_64: G = __v_62 + __v_63; let __v_65: G = __v_32 * __v_21; let __v_66: G = __v_20 + __v_65; let __v_67: G = __v_35 * __v_22; let __v_68: G = __v_66 + __v_67; let __v_69: G = __v_38 * __v_23; let __v_70: G = __v_68 + __v_69; let __v_71: G = __v_32 * __v_25; let __v_72: G = __v_24 + __v_71; let __v_73: G = __v_35 * __v_26; let __v_74: G = __v_72 + __v_73; let __v_75: G = __v_38 * __v_27; let __v_76: G = __v_74 + __v_75; let __v_77: G = __v_32 * __v_29; let __v_78: G = __v_28 + __v_77; let __v_79: G = __v_35 * __v_30; let __v_80: G = __v_78 + __v_79; let __v_81: G = __v_38 * __v_31; let __v_82: G = __v_80 + __v_81; let __ret: [G; OUT_73] = [__v_40, __v_46, __v_52, __v_58, __v_64, __v_70, __v_76, __v_82]; record.function_queries[73].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -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 __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_78] = { let __args: [G; IN_78] = [__v_0, __v_33, __v_34, __v_34, __v_35, __v_36, __v_37]; 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_38: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_38]; 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_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_74] = [__v_39, __v_40, __v_41, __v_42, __v_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[74].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_75: usize = 1; -const IN_75: usize = 1; -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 = 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_78] = { let __args: [G; IN_78] = [__v_0, __v_33, __v_34, __v_34, __v_35, __v_36, __v_37]; 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_38: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_38]; 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_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 __v_71: G = { let __values: [G; 32] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70]; let __mq = record.memory_queries.get_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_75] = [__v_71]; record.function_queries[75].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_76: usize = 34; -const IN_76: usize = 34; -const OUT_76: usize = 34; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_76] = [__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[76].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_68: G = G::from_u64(0); let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_35, __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(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_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_76] = [__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[76].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_89] = { let __args: [G; IN_89] = [__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(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_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_76] = [__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[76].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_89] = { let __args: [G; IN_89] = [__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(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_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_76] = [__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[76].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_77: usize = 1; -const IN_77: usize = 1; -const OUT_77: usize = 32; -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 __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_77] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __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[77].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_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(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_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_77] = { let __args: [G; IN_77] = [__v_103]; 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_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_77] = [__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[77].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_77] = { let __args: [G; IN_77] = [__v_105]; 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_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_77] = [__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[77].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_78: usize = 7; -const IN_78: usize = 7; -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 = 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_84] = { let __args: [G; IN_84] = [__v_1, __v_2, __v_3, __v_4, __v_5, __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_10: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_10]; record.function_queries[78].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_85] = { let __args: [G; IN_85] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_12]; record.function_queries[78].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 __loaded: [G; 3] = { let __base = 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_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; match __v_15.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_11, __v_13, __v_14, __v_4, __v_5, __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_18: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_18]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 3] = [__v_18, __v_16, __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 }, } }; match __v_13.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_17, __v_19, __v_14, __v_4, __v_5, __v_6]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_20]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(1); let __v_21: G = __v_13 + __v_20; let __v_22: G = __v_14 + __v_20; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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() { 1u64 => { let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_19, __v_21, __v_22, __v_4, __v_5, __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_26: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_26]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 3] = [__v_26, __v_24, __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 }, } }; match __v_21.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_25, __v_27, __v_22, __v_4, __v_5, __v_6]; 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_28: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_28]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(1); let __v_29: G = __v_21 + __v_28; let __v_30: G = __v_22 + __v_28; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; 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: 3 })?; if (!unconstrained) { __mq.bump_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() { 1u64 => { let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_27, __v_29, __v_30, __v_4, __v_5, __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_34: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_34]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 3] = [__v_34, __v_32, __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 }, } }; match __v_29.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_33, __v_35, __v_30, __v_4, __v_5, __v_6]; 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_36: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_36]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_36: G = G::from_u64(1); let __v_37: G = __v_29 + __v_36; let __v_38: G = __v_30 + __v_36; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_33, __v_35, __v_37, __v_38, __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_39: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_39]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_79: usize = 7; -const IN_79: usize = 7; -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 = 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_84] = { let __args: [G; IN_84] = [__v_1, __v_2, __v_3, __v_4, __v_5, __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_10: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_10]; record.function_queries[79].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_85] = { let __args: [G; IN_85] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_12]; record.function_queries[79].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 __loaded: [G; 3] = { let __base = 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_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; match __v_15.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_11, __v_13, __v_14, __v_4, __v_5, __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_18: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_18]; record.function_queries[79].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 3] = [__v_18, __v_16, __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 }, } }; match __v_13.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_17, __v_19, __v_14, __v_4, __v_5, __v_6]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_20]; record.function_queries[79].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(1); let __v_21: G = __v_13 + __v_20; let __v_22: G = __v_14 + __v_20; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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() { 1u64 => { let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_19, __v_21, __v_22, __v_4, __v_5, __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_26: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_26]; record.function_queries[79].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 3] = [__v_26, __v_24, __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 }, } }; match __v_21.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_25, __v_27, __v_22, __v_4, __v_5, __v_6]; 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_28: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_28]; record.function_queries[79].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(1); let __v_29: G = __v_21 + __v_28; let __v_30: G = __v_22 + __v_28; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_25, __v_27, __v_29, __v_30, __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_31: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_31]; record.function_queries[79].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_80: usize = 7; -const IN_80: usize = 7; -const OUT_80: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_84] = { let __args: [G; IN_84] = [__v_1, __v_2, __v_3, __v_4, __v_5, __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_10: G = __r_arr[0]; let __ret: [G; OUT_80] = [__v_10]; record.function_queries[80].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_85] = { let __args: [G; IN_85] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_80] = [__v_12]; record.function_queries[80].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 __loaded: [G; 3] = { let __base = 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_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; match __v_15.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_11, __v_13, __v_14, __v_4, __v_5, __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_18: G = __r_arr[0]; let __ret: [G; OUT_80] = [__v_18]; record.function_queries[80].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 3] = [__v_18, __v_16, __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 }, } }; match __v_13.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_17, __v_19, __v_14, __v_4, __v_5, __v_6]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_80] = [__v_20]; record.function_queries[80].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(1); let __v_21: G = __v_13 + __v_20; let __v_22: G = __v_14 + __v_20; let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_17, __v_19, __v_21, __v_22, __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_23: G = __r_arr[0]; let __ret: [G; OUT_80] = [__v_23]; record.function_queries[80].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_81: usize = 7; -const IN_81: usize = 7; -const OUT_81: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_84] = { let __args: [G; IN_84] = [__v_1, __v_2, __v_3, __v_4, __v_5, __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_10: G = __r_arr[0]; let __ret: [G; OUT_81] = [__v_10]; record.function_queries[81].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_85] = { let __args: [G; IN_85] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_81] = [__v_12]; record.function_queries[81].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_78] = { let __args: [G; IN_78] = [__v_9, __v_11, __v_13, __v_14, __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_15: G = __r_arr[0]; let __ret: [G; OUT_81] = [__v_15]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_82: usize = 1; -const IN_82: usize = 1; -const OUT_82: usize = 64; -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 __loaded: [G; 3] = { let __base = 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_82] = [__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[82].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_83: usize = 2; -const IN_83: usize = 2; -const OUT_83: usize = 1; -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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_83] = [__v_0]; record.function_queries[83].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_83] = { let __args: [G; IN_83] = [__v_3, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_83] = [__v_6]; record.function_queries[83].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_84: usize = 6; -const IN_84: usize = 6; -const OUT_84: usize = 1; -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 __v_1: G = inp[1]; let __v_2: G = 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_8 + __v_6; let __v_18: G = __v_17 + __v_7; 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_89] = { let __args: [G; IN_89] = [__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(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_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_84] = [__v_107]; record.function_queries[84].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_84] = [__v_5]; record.function_queries[84].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_84] = [__v_5]; record.function_queries[84].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_84] = [__v_5]; record.function_queries[84].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_84] = [__v_5]; record.function_queries[84].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_84] = [__v_5]; record.function_queries[84].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_84] = [__v_5]; record.function_queries[84].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_84] = [__v_5]; record.function_queries[84].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_84] = [__v_5]; record.function_queries[84].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_84] = [__v_42]; record.function_queries[84].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_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(4, &__args[..])?) { [G::ZERO; OUT_4] } else { let (__hash, __hit) = record.function_queries[4].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[4].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => { aiur_fn_4::(__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_7 + __v_18; let __v_20: G = __v_2 - __v_1; let __v_21: G = G::from_bool(__v_20 == G::ZERO); let __v_22: G = __v_21 * __v_6; let __v_23: G = __v_19 + __v_22; let __v_24: G = G::from_u64(64); let __v_25: G = __v_24 - __v_1; let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0, __v_25]; 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_26: G = __r_arr[0]; let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(82, &__args[..])?) { [G::ZERO; OUT_82] } else { let (__hash, __hit) = record.function_queries[82].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[82].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => { aiur_fn_82::(__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_89] = { let __args: [G; IN_89] = [__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(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_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_84] = [__v_171]; record.function_queries[84].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_85: usize = 6; -const IN_85: usize = 6; -const OUT_85: usize = 1; -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 __v_1: G = inp[1]; let __v_2: G = 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_82] = { let __args: [G; IN_82] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(82, &__args[..])?) { [G::ZERO; OUT_82] } else { let (__hash, __hit) = record.function_queries[82].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[82].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => { aiur_fn_82::(__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_322] = { let __args: [G; IN_322] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(322, &__args[..])?) { [G::ZERO; OUT_322] } else { let (__hash, __hit) = record.function_queries[322].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[322].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[322].bump_multiplicity(__i); } let __ret: [G; OUT_322] = unsafe { *(record.function_queries[322].output_at(__i).as_ptr() as *const [G; OUT_322]) }; __ret }, _ => { aiur_fn_322::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = __v_8 * __v_73; 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_75: G = __loaded[0]; let __v_76: G = __loaded[1]; let __v_77: G = __loaded[2]; let __v_78: G = __loaded[3]; let __v_79: G = __loaded[4]; let __v_80: G = __loaded[5]; let __v_81: G = __loaded[6]; let __v_82: G = __loaded[7]; let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(4, &__args[..])?) { [G::ZERO; OUT_4] } else { let (__hash, __hit) = record.function_queries[4].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[4].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => { aiur_fn_4::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __v_84: G = __v_74 * __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_89] = { let __args: [G; IN_89] = [__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_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __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(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_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_13] = { let __args: [G; IN_13] = [__v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(13, &__args[..])?) { [G::ZERO; OUT_13] } else { let (__hash, __hit) = record.function_queries[13].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[13].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => { aiur_fn_13::(__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_78] = { let __args: [G; IN_78] = [__v_0, __v_185, __v_150, __v_150, __v_194, __v_195, __v_183]; 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_196: G = __r_arr[0]; let __ret: [G; OUT_85] = [__v_196]; record.function_queries[85].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(322, &__args[..])?) { [G::ZERO; OUT_322] } else { let (__hash, __hit) = record.function_queries[322].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[322].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[322].bump_multiplicity(__i); } let __ret: [G; OUT_322] = unsafe { *(record.function_queries[322].output_at(__i).as_ptr() as *const [G; OUT_322]) }; __ret }, _ => { aiur_fn_322::(__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_322] = { let __args: [G; IN_322] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(322, &__args[..])?) { [G::ZERO; OUT_322] } else { let (__hash, __hit) = record.function_queries[322].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[322].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[322].bump_multiplicity(__i); } let __ret: [G; OUT_322] = unsafe { *(record.function_queries[322].output_at(__i).as_ptr() as *const [G; OUT_322]) }; __ret }, _ => { aiur_fn_322::(__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_4] = { let __args: [G; IN_4] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(4, &__args[..])?) { [G::ZERO; OUT_4] } else { let (__hash, __hit) = record.function_queries[4].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[4].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => { aiur_fn_4::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __v_85: G = __v_75 * __v_84; let __v_86: G = __v_85 * __v_8; 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_74 + __v_86; let __v_92: G = __v_91 + __v_90; 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_89] = { let __args: [G; IN_89] = [__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(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_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_78] = { let __args: [G; IN_78] = [__v_0, __v_175, __v_141, __v_176, __v_3, __v_177, __v_5]; 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_178: G = __r_arr[0]; let __ret: [G; OUT_85] = [__v_178]; record.function_queries[85].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_86: usize = 24; -const IN_86: usize = 24; -const OUT_86: usize = 16; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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 = __v_28 * __v_30; let __v_32: G = G::from_u64(2); let __v_33: G = __v_28 - __v_32; let __v_34: G = __v_31 * __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_63; let __v_65: G = __v_62 - __v_32; let __v_66: G = __v_64 * __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_86] = [__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[86].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_87: usize = 128; -const IN_87: usize = 128; -const OUT_87: usize = 128; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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 = __v_132 * __v_134; let __v_136: G = G::from_u64(2); let __v_137: G = __v_132 - __v_136; let __v_138: G = __v_135 * __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_167; let __v_169: G = __v_166 - __v_136; let __v_170: G = __v_168 * __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_198; let __v_200: G = __v_197 - __v_136; let __v_201: G = __v_199 * __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_229; let __v_231: G = __v_228 - __v_136; let __v_232: G = __v_230 * __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_260; let __v_262: G = __v_259 - __v_136; let __v_263: G = __v_261 * __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_291; let __v_293: G = __v_290 - __v_136; let __v_294: G = __v_292 * __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_322; let __v_324: G = __v_321 - __v_136; let __v_325: G = __v_323 * __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_353; let __v_355: G = __v_352 - __v_136; let __v_356: G = __v_354 * __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_384; let __v_386: G = __v_383 - __v_136; let __v_387: G = __v_385 * __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_415; let __v_417: G = __v_414 - __v_136; let __v_418: G = __v_416 * __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_446; let __v_448: G = __v_445 - __v_136; let __v_449: G = __v_447 * __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_477; let __v_479: G = __v_476 - __v_136; let __v_480: G = __v_478 * __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_508; let __v_510: G = __v_507 - __v_136; let __v_511: G = __v_509 * __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_539; let __v_541: G = __v_538 - __v_136; let __v_542: G = __v_540 * __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_570; let __v_572: G = __v_569 - __v_136; let __v_573: G = __v_571 * __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_601; let __v_603: G = __v_600 - __v_136; let __v_604: G = __v_602 * __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_87] = [__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[87].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_88: usize = 106; -const IN_88: usize = 106; -const OUT_88: usize = 32; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_89] = { let __args: [G; IN_89] = [__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(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_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_88] = [__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[88].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_89: usize = 129; -const IN_89: usize = 129; -const OUT_89: usize = 32; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_89] = [__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[89].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 = __v_133 * __v_135; let __v_137: G = G::from_u64(2); let __v_138: G = __v_133 - __v_137; let __v_139: G = __v_136 * __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_168; let __v_170: G = __v_167 - __v_137; let __v_171: G = __v_169 * __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_199; let __v_201: G = __v_198 - __v_137; let __v_202: G = __v_200 * __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_230; let __v_232: G = __v_229 - __v_137; let __v_233: G = __v_231 * __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_261; let __v_263: G = __v_260 - __v_137; let __v_264: G = __v_262 * __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_292; let __v_294: G = __v_291 - __v_137; let __v_295: G = __v_293 * __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_323; let __v_325: G = __v_322 - __v_137; let __v_326: G = __v_324 * __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_354; let __v_356: G = __v_353 - __v_137; let __v_357: G = __v_355 * __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_385; let __v_387: G = __v_384 - __v_137; let __v_388: G = __v_386 * __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_416; let __v_418: G = __v_415 - __v_137; let __v_419: G = __v_417 * __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_447; let __v_449: G = __v_446 - __v_137; let __v_450: G = __v_448 * __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_478; let __v_480: G = __v_477 - __v_137; let __v_481: G = __v_479 * __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_509; let __v_511: G = __v_508 - __v_137; let __v_512: G = __v_510 * __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_540; let __v_542: G = __v_539 - __v_137; let __v_543: G = __v_541 * __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_571; let __v_573: G = __v_570 - __v_137; let __v_574: G = __v_572 * __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_602; let __v_604: G = __v_601 - __v_137; let __v_605: G = __v_603 * __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_89] = { let __args: [G; IN_89] = [__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(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_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_89] = [__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[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 __loaded: [G; 3] = { let __base = 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_90] = [__v_2, __v_3]; record.function_queries[90].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_91: usize = 1; -const IN_91: usize = 1; -const OUT_91: usize = 2; -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_90] = { let __args: [G; IN_90] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_91] = [__v_1, __v_2]; record.function_queries[91].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_92: usize = 1; -const IN_92: usize = 1; -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 __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_2]; 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_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_92] = [__v_7, __v_4]; record.function_queries[92].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_93: usize = 1; -const IN_93: usize = 1; -const OUT_93: usize = 10; -fn aiur_fn_93(inp: [G; IN_93], 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 __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_2]; 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_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_93] = [__v_7, __v_1, __v_3, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_4]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_94: usize = 1; -const IN_94: usize = 1; -const OUT_94: usize = 10; -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 __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; 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 __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_6]; 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_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 = __v_1 + __v_10; let __v_12: G = G::from_u64(65536); let __v_13: G = __v_12 * __v_5; let __v_14: G = __v_11 + __v_13; let __v_15: G = G::from_u64(16777216); let __v_16: G = __v_15 * __v_7; let __v_17: G = __v_14 + __v_16; let __v_18: G = G::from_u64(0); let __ret: [G; OUT_94] = [__v_17, __v_1, __v_3, __v_5, __v_7, __v_18, __v_18, __v_18, __v_18, __v_8]; 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 = 9; -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_90] = { let __args: [G; IN_90] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; 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 __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_10]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_14]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_95] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; record.function_queries[95].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_96: usize = 1; -const IN_96: usize = 1; -const OUT_96: usize = 2; -fn aiur_fn_96(inp: [G; IN_96], 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 __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(95, &__args[..])?) { [G::ZERO; OUT_95] } else { let (__hash, __hit) = record.function_queries[95].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[95].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => { aiur_fn_95::(__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 = __v_1 + __v_11; let __v_13: G = G::from_u64(65536); let __v_14: G = __v_13 * __v_3; let __v_15: G = __v_12 + __v_14; let __v_16: G = G::from_u64(16777216); let __v_17: G = __v_16 * __v_4; let __v_18: G = __v_15 + __v_17; let __v_19: G = G::from_u64(4294967296); let __v_20: G = __v_19 * __v_5; let __v_21: G = __v_18 + __v_20; let __v_22: G = G::from_u64(1099511627776); let __v_23: G = __v_22 * __v_6; let __v_24: G = __v_21 + __v_23; let __v_25: G = G::from_u64(281474976710656); let __v_26: G = __v_25 * __v_7; let __v_27: G = __v_24 + __v_26; let __v_28: G = G::from_u64(72057594037927936); let __v_29: G = __v_28 * __v_8; let __v_30: G = __v_27 + __v_29; let __ret: [G; OUT_96] = [__v_30, __v_9]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_97: usize = 1; -const IN_97: usize = 1; -const OUT_97: usize = 33; -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 __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(95, &__args[..])?) { [G::ZERO; OUT_95] } else { let (__hash, __hit) = record.function_queries[95].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[95].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => { aiur_fn_95::(__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_95] = { let __args: [G; IN_95] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(95, &__args[..])?) { [G::ZERO; OUT_95] } else { let (__hash, __hit) = record.function_queries[95].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[95].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => { aiur_fn_95::(__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_95] = { let __args: [G; IN_95] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(95, &__args[..])?) { [G::ZERO; OUT_95] } else { let (__hash, __hit) = record.function_queries[95].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[95].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => { aiur_fn_95::(__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_95] = { let __args: [G; IN_95] = [__v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(95, &__args[..])?) { [G::ZERO; OUT_95] } else { let (__hash, __hit) = record.function_queries[95].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[95].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => { aiur_fn_95::(__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_97] = [__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[97].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_98: usize = 2; -const IN_98: usize = 2; -const OUT_98: usize = 2; -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 __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_98] = [__v_3, __v_0]; record.function_queries[98].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(95, &__args[..])?) { [G::ZERO; OUT_95] } else { let (__hash, __hit) = record.function_queries[95].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[95].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => { aiur_fn_95::(__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_95] = { let __args: [G; IN_95] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(95, &__args[..])?) { [G::ZERO; OUT_95] } else { let (__hash, __hit) = record.function_queries[95].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[95].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => { aiur_fn_95::(__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_95] = { let __args: [G; IN_95] = [__v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(95, &__args[..])?) { [G::ZERO; OUT_95] } else { let (__hash, __hit) = record.function_queries[95].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[95].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => { aiur_fn_95::(__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_95] = { let __args: [G; IN_95] = [__v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(95, &__args[..])?) { [G::ZERO; OUT_95] } else { let (__hash, __hit) = record.function_queries[95].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[95].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => { aiur_fn_95::(__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_98] = { let __args: [G; IN_98] = [__v_37, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__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_98] = [__v_44, __v_41]; record.function_queries[98].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_99: usize = 3; -const IN_99: usize = 3; -const OUT_99: usize = 2; -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]; 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_99] = [__v_4, __v_0]; record.function_queries[99].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(91, &__args[..])?) { [G::ZERO; OUT_91] } else { let (__hash, __hit) = record.function_queries[91].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[91].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[91].bump_multiplicity(__i); } let __ret: [G; OUT_91] = unsafe { *(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91]) }; __ret }, _ => { aiur_fn_91::(__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_92] = { let __args: [G; IN_92] = [__v_4]; 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 __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__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_99] = [__v_13, __v_11]; record.function_queries[99].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_4]; 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_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_99] = { let __args: [G; IN_99] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__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_99] = [__v_13, __v_11]; record.function_queries[99].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(91, &__args[..])?) { [G::ZERO; OUT_91] } else { let (__hash, __hit) = record.function_queries[91].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[91].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[91].bump_multiplicity(__i); } let __ret: [G; OUT_91] = unsafe { *(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91]) }; __ret }, _ => { aiur_fn_91::(__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_99] = { let __args: [G; IN_99] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__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_99] = [__v_14, __v_11]; record.function_queries[99].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_99] = { let __args: [G; IN_99] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__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_99] = [__v_12, __v_9]; record.function_queries[99].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_99] = { let __args: [G; IN_99] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__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_99] = [__v_12, __v_9]; record.function_queries[99].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_99] = { let __args: [G; IN_99] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__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_99] = [__v_12, __v_9]; record.function_queries[99].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_4]; 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 __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_6]; 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_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_99] = { let __args: [G; IN_99] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__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_99] = [__v_18, __v_15]; record.function_queries[99].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_4]; 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 __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_6]; 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_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_99] = { let __args: [G; IN_99] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__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_99] = [__v_18, __v_15]; record.function_queries[99].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_4]; 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 __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_6]; 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_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_99] = { let __args: [G; IN_99] = [__v_8, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__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_99] = [__v_18, __v_15]; record.function_queries[99].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_4]; 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 __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_99] = { let __args: [G; IN_99] = [__v_6, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__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_99] = [__v_15, __v_12]; record.function_queries[99].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_4]; 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 __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__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_99] = [__v_13, __v_11]; record.function_queries[99].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_4]; 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 __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__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_99] = [__v_13, __v_11]; record.function_queries[99].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_4]; 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 __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__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_99] = [__v_13, __v_11]; record.function_queries[99].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_4]; 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 __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__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_99] = [__v_13, __v_11]; record.function_queries[99].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_4]; 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 __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__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_99] = [__v_14, __v_11]; record.function_queries[99].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_4]; 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 __v_8: G = __v_1 - __v_7; let __v_9: G = __v_2 + __v_7; let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__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_99] = [__v_14, __v_11]; 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 = 2; -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; 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_100] = [__v_3, __v_0]; record.function_queries[100].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_0]; 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_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_100] = { let __args: [G; IN_100] = [__v_3, __v_5]; 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_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_100] = [__v_9, __v_7]; 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_92] = { let __args: [G; IN_92] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_4, __v_3]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_101] = [__v_1, __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_92] = { let __args: [G; IN_92] = [__v_0]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_5, __v_4]; 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_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_102] = { let __args: [G; IN_102] = [__v_7, __v_9]; 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_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_102] = [__v_13, __v_11]; record.function_queries[102].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_103: usize = 3; -const IN_103: usize = 3; -const OUT_103: usize = 1; -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 __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_103] = [__v_3]; record.function_queries[103].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_103] = { let __args: [G; IN_103] = [__v_4, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(103, &__args[..])?) { [G::ZERO; OUT_103] } else { let (__hash, __hit) = record.function_queries[103].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[103].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => { aiur_fn_103::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __v_3 + __v_6; let __ret: [G; OUT_103] = [__v_7]; record.function_queries[103].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_103] = { let __args: [G; IN_103] = [__v_4, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(103, &__args[..])?) { [G::ZERO; OUT_103] } else { let (__hash, __hit) = record.function_queries[103].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[103].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => { aiur_fn_103::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_103] = [__v_6]; 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 = 66; -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_93] = { let __args: [G; IN_93] = [__v_0]; 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_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_93] = { let __args: [G; IN_93] = [__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 = __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_94] = { let __args: [G; IN_94] = [__v_20]; 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_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_93] = { let __args: [G; IN_93] = [__v_30]; 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_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_91] = { let __args: [G; IN_91] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(91, &__args[..])?) { [G::ZERO; OUT_91] } else { let (__hash, __hit) = record.function_queries[91].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[91].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[91].bump_multiplicity(__i); } let __ret: [G; OUT_91] = unsafe { *(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91]) }; __ret }, _ => { aiur_fn_91::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_42]; 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_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_99] = { let __args: [G; IN_99] = [__v_44, __v_43, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_47]; 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_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_49, __v_48]; 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_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_51]; 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_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_53, __v_52]; 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_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_52, __v_45, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(103, &__args[..])?) { [G::ZERO; OUT_103] } else { let (__hash, __hit) = record.function_queries[103].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[103].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => { aiur_fn_103::(__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 = __v_61 + __v_70; let __v_72: G = G::from_u64(65536); let __v_73: G = __v_72 * __v_63; let __v_74: G = __v_71 + __v_73; let __v_75: G = G::from_u64(16777216); let __v_76: G = __v_75 * __v_64; let __v_77: G = __v_74 + __v_76; let __v_78: G = G::from_u64(4294967296); let __v_79: G = __v_78 * __v_65; let __v_80: G = __v_77 + __v_79; let __v_81: G = G::from_u64(1099511627776); let __v_82: G = __v_81 * __v_66; let __v_83: G = __v_80 + __v_82; let __v_84: G = G::from_u64(281474976710656); let __v_85: G = __v_84 * __v_67; let __v_86: G = __v_83 + __v_85; let __v_87: G = G::from_u64(72057594037927936); let __v_88: G = __v_87 * __v_68; let __v_89: G = __v_86 + __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 = __v_65 + __v_66; let __v_91: G = __v_90 + __v_67; let __v_92: G = __v_91 + __v_68; let __v_93: G = G::from_u64(1020); let __v_94: G = __v_92 - __v_93; let __v_95: G = G::from_bool(__v_94 == G::ZERO); let __v_96: G = __v_61 + __v_62; let __v_97: G = __v_96 + __v_63; let __v_98: G = __v_97 + __v_64; 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_104 + __v_112; let __v_114: G = __v_72 * __v_106; let __v_115: G = __v_113 + __v_114; let __v_116: G = __v_75 * __v_107; let __v_117: G = __v_115 + __v_116; let __v_118: G = __v_78 * __v_108; let __v_119: G = __v_117 + __v_118; let __v_120: G = __v_81 * __v_109; let __v_121: G = __v_119 + __v_120; let __v_122: G = __v_84 * __v_110; let __v_123: G = __v_121 + __v_122; let __v_124: G = __v_87 * __v_111; let __v_125: G = __v_123 + __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_108 + __v_109; let __v_127: G = __v_126 + __v_110; let __v_128: G = __v_127 + __v_111; let __v_129: G = __v_128 - __v_93; let __v_130: G = G::from_bool(__v_129 == G::ZERO); let __v_131: G = __v_104 + __v_105; let __v_132: G = __v_131 + __v_106; let __v_133: G = __v_132 + __v_107; 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_138 + __v_146; let __v_148: G = __v_72 * __v_140; let __v_149: G = __v_147 + __v_148; let __v_150: G = __v_75 * __v_141; let __v_151: G = __v_149 + __v_150; let __v_152: G = __v_78 * __v_142; let __v_153: G = __v_151 + __v_152; let __v_154: G = __v_81 * __v_143; let __v_155: G = __v_153 + __v_154; let __v_156: G = __v_84 * __v_144; let __v_157: G = __v_155 + __v_156; let __v_158: G = __v_87 * __v_145; let __v_159: G = __v_157 + __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_142 + __v_143; let __v_161: G = __v_160 + __v_144; let __v_162: G = __v_161 + __v_145; let __v_163: G = __v_162 - __v_93; let __v_164: G = G::from_bool(__v_163 == G::ZERO); let __v_165: G = __v_138 + __v_139; let __v_166: G = __v_165 + __v_140; let __v_167: G = __v_166 + __v_141; 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_104] = [__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[104].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_105: usize = 57; -const IN_105: usize = 57; -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 = 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_105] = [__v_64]; record.function_queries[105].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_106: usize = 2; -const IN_106: usize = 2; -const OUT_106: usize = 3; -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]; 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_106] = [__v_3, __v_4, __v_0]; record.function_queries[106].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_0]; 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_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_93] = { let __args: [G; IN_93] = [__v_11]; 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_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_94] = { let __args: [G; IN_94] = [__v_21]; 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_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_93] = { let __args: [G; IN_93] = [__v_31]; 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_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_91] = { let __args: [G; IN_91] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(91, &__args[..])?) { [G::ZERO; OUT_91] } else { let (__hash, __hit) = record.function_queries[91].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[91].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[91].bump_multiplicity(__i); } let __ret: [G; OUT_91] = unsafe { *(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91]) }; __ret }, _ => { aiur_fn_91::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_43]; 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_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_99] = { let __args: [G; IN_99] = [__v_45, __v_44, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_48]; 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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_50, __v_49]; 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_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_52]; 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_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_54, __v_53]; 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_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_53, __v_46, __v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(103, &__args[..])?) { [G::ZERO; OUT_103] } else { let (__hash, __hit) = record.function_queries[103].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[103].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => { aiur_fn_103::(__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 = __v_62 + __v_71; let __v_73: G = G::from_u64(65536); let __v_74: G = __v_73 * __v_64; let __v_75: G = __v_72 + __v_74; let __v_76: G = G::from_u64(16777216); let __v_77: G = __v_76 * __v_65; let __v_78: G = __v_75 + __v_77; let __v_79: G = G::from_u64(4294967296); let __v_80: G = __v_79 * __v_66; let __v_81: G = __v_78 + __v_80; let __v_82: G = G::from_u64(1099511627776); let __v_83: G = __v_82 * __v_67; let __v_84: G = __v_81 + __v_83; let __v_85: G = G::from_u64(281474976710656); let __v_86: G = __v_85 * __v_68; let __v_87: G = __v_84 + __v_86; let __v_88: G = G::from_u64(72057594037927936); let __v_89: G = __v_88 * __v_69; let __v_90: G = __v_87 + __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 = __v_66 + __v_67; let __v_92: G = __v_91 + __v_68; let __v_93: G = __v_92 + __v_69; let __v_94: G = G::from_u64(1020); let __v_95: G = __v_93 - __v_94; let __v_96: G = G::from_bool(__v_95 == G::ZERO); let __v_97: G = __v_62 + __v_63; let __v_98: G = __v_97 + __v_64; let __v_99: G = __v_98 + __v_65; 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_105 + __v_113; let __v_115: G = __v_73 * __v_107; let __v_116: G = __v_114 + __v_115; let __v_117: G = __v_76 * __v_108; let __v_118: G = __v_116 + __v_117; let __v_119: G = __v_79 * __v_109; let __v_120: G = __v_118 + __v_119; let __v_121: G = __v_82 * __v_110; let __v_122: G = __v_120 + __v_121; let __v_123: G = __v_85 * __v_111; let __v_124: G = __v_122 + __v_123; let __v_125: G = __v_88 * __v_112; let __v_126: G = __v_124 + __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_109 + __v_110; let __v_128: G = __v_127 + __v_111; let __v_129: G = __v_128 + __v_112; let __v_130: G = __v_129 - __v_94; let __v_131: G = G::from_bool(__v_130 == G::ZERO); let __v_132: G = __v_105 + __v_106; let __v_133: G = __v_132 + __v_107; let __v_134: G = __v_133 + __v_108; 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_139 + __v_147; let __v_149: G = __v_73 * __v_141; let __v_150: G = __v_148 + __v_149; let __v_151: G = __v_76 * __v_142; let __v_152: G = __v_150 + __v_151; let __v_153: G = __v_79 * __v_143; let __v_154: G = __v_152 + __v_153; let __v_155: G = __v_82 * __v_144; let __v_156: G = __v_154 + __v_155; let __v_157: G = __v_85 * __v_145; let __v_158: G = __v_156 + __v_157; let __v_159: G = __v_88 * __v_146; let __v_160: G = __v_158 + __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_143 + __v_144; let __v_162: G = __v_161 + __v_145; let __v_163: G = __v_162 + __v_146; let __v_164: G = __v_163 - __v_94; let __v_165: G = G::from_bool(__v_164 == G::ZERO); let __v_166: G = __v_139 + __v_140; let __v_167: G = __v_166 + __v_141; let __v_168: G = __v_167 + __v_142; 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_106] = { let __args: [G; IN_106] = [__v_56, __v_173]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(106, &__args[..])?) { [G::ZERO; OUT_106] } else { let (__hash, __hit) = record.function_queries[106].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[106].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => { aiur_fn_106::(__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_106] = [__v_177, __v_184, __v_176]; record.function_queries[106].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_107: usize = 1; -const IN_107: usize = 1; -const OUT_107: usize = 3; -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 __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; 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_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_107] = [__v_3, __v_3, __v_2]; record.function_queries[107].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__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_107] = [__v_7, __v_5, __v_6]; 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 = 2; -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]; 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_108] = [__v_3, __v_0]; record.function_queries[108].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_0]; 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_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_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 __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_108] = [__v_9, __v_7]; record.function_queries[108].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_108] = [__v_10, __v_7]; record.function_queries[108].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_109: usize = 1; -const IN_109: usize = 1; -const OUT_109: usize = 9; -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 __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_0]; 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_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_93] = { let __args: [G; IN_93] = [__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 = __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_93] = { let __args: [G; IN_93] = [__v_20]; 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_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_93] = { let __args: [G; IN_93] = [__v_30]; 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_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_93] = { let __args: [G; IN_93] = [__v_40]; 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_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_93] = { let __args: [G; IN_93] = [__v_50]; 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_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_93] = { let __args: [G; IN_93] = [__v_60]; 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_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_109] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_80, __v_70]; record.function_queries[109].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_110: usize = 1; -const IN_110: usize = 1; -const OUT_110: usize = 13; -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 __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_0]; 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_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_93] = { let __args: [G; IN_93] = [__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 = __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_93] = { let __args: [G; IN_93] = [__v_20]; 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_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_93] = { let __args: [G; IN_93] = [__v_30]; 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_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_93] = { let __args: [G; IN_93] = [__v_40]; 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_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_93] = { let __args: [G; IN_93] = [__v_50]; 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_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_93] = { let __args: [G; IN_93] = [__v_60]; 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_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_93] = { let __args: [G; IN_93] = [__v_70]; 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_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_106] = { let __args: [G; IN_106] = [__v_90, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(106, &__args[..])?) { [G::ZERO; OUT_106] } else { let (__hash, __hit) = record.function_queries[106].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[106].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => { aiur_fn_106::(__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_107] = { let __args: [G; IN_107] = [__v_93]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(107, &__args[..])?) { [G::ZERO; OUT_107] } else { let (__hash, __hit) = record.function_queries[107].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[107].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[107].bump_multiplicity(__i); } let __ret: [G; OUT_107] = unsafe { *(record.function_queries[107].output_at(__i).as_ptr() as *const [G; OUT_107]) }; __ret }, _ => { aiur_fn_107::(__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_108] = { let __args: [G; IN_108] = [__v_96, __v_81]; 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_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_324] = { let __args: [G; IN_324] = [__v_80, __v_99]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(324, &__args[..])?) { [G::ZERO; OUT_324] } else { let (__hash, __hit) = record.function_queries[324].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[324].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => { aiur_fn_324::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; let __ret: [G; OUT_110] = [__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[110].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_111: usize = 5; -const IN_111: usize = 5; -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 __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_111] = [__v_9]; record.function_queries[111].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_112: usize = 33; -const IN_112: usize = 33; -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 __v_3: G = inp[3]; let __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_111] = { let __args: [G; IN_111] = [__v_28, __v_29, __v_30, __v_31, __v_32]; 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_33: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_24, __v_25, __v_26, __v_27, __v_33]; 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_34: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_20, __v_21, __v_22, __v_23, __v_34]; 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_35: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_16, __v_17, __v_18, __v_19, __v_35]; 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_36: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_12, __v_13, __v_14, __v_15, __v_36]; 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_37: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_8, __v_9, __v_10, __v_11, __v_37]; 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_38: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_4, __v_5, __v_6, __v_7, __v_38]; 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_39: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0, __v_1, __v_2, __v_3, __v_39]; 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_40: G = __r_arr[0]; let __ret: [G; OUT_112] = [__v_40]; record.function_queries[112].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_113: usize = 32; -const IN_113: usize = 32; -const OUT_113: usize = 32; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_113] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __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[113].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_114: usize = 2; -const IN_114: usize = 2; -const OUT_114: usize = 1; -fn aiur_fn_114(inp: [G; IN_114], 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 = 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_89] = { let __args: [G; IN_89] = [__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(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_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_114] = [__v_132]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_115: usize = 3; -const IN_115: usize = 3; -const OUT_115: usize = 1; -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 = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1, __v_2]; 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_3: G = __r_arr[0]; let __ret: [G; OUT_115] = [__v_3]; record.function_queries[115].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_2, __v_1]; 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_3: G = __r_arr[0]; let __ret: [G; OUT_115] = [__v_3]; record.function_queries[115].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_116: usize = 2; -const IN_116: usize = 2; -const OUT_116: usize = 1; -fn aiur_fn_116(inp: [G; IN_116], 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 __loaded: [G; 3] = { let __base = 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_116] = [__v_5]; record.function_queries[116].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_116] = [__v_7]; record.function_queries[116].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_116] = [__v_7]; record.function_queries[116].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_117: usize = 3; -const IN_117: usize = 3; -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 __loaded: [G; 3] = { let __base = 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_117] = [__v_7]; record.function_queries[117].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_117] = { let __args: [G; IN_117] = [__v_5, __v_8, __v_2]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_117] = [__v_11]; record.function_queries[117].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_117] = { let __args: [G; IN_117] = [__v_5, __v_8, __v_2]; 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_21: G = __r_arr[0]; let __ret: [G; OUT_117] = [__v_21]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_21: G = G::from_u64(0); let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_5, __v_8, __v_2]; 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_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_117] = [__v_23]; record.function_queries[117].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_118: usize = 3; -const IN_118: usize = 3; -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 __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_118] = [__v_7]; record.function_queries[118].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_118] = { let __args: [G; IN_118] = [__v_5, __v_8, __v_2]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_118] = [__v_10]; record.function_queries[118].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_118] = { let __args: [G; IN_118] = [__v_5, __v_8, __v_2]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_118] = [__v_20]; record.function_queries[118].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_5, __v_8, __v_2]; 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_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_118] = [__v_22]; record.function_queries[118].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_119: usize = 2; -const IN_119: usize = 2; -const OUT_119: usize = 11; -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; 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 = __v_3 + __v_13; let __v_15: G = G::from_u64(65536); let __v_16: G = __v_15 * __v_5; let __v_17: G = __v_14 + __v_16; let __v_18: G = G::from_u64(16777216); let __v_19: G = __v_18 * __v_6; let __v_20: G = __v_17 + __v_19; let __v_21: G = G::from_u64(4294967296); let __v_22: G = __v_21 * __v_7; let __v_23: G = __v_20 + __v_22; let __v_24: G = G::from_u64(1099511627776); let __v_25: G = __v_24 * __v_8; let __v_26: G = __v_23 + __v_25; let __v_27: G = G::from_u64(281474976710656); let __v_28: G = __v_27 * __v_9; let __v_29: G = __v_26 + __v_28; let __v_30: G = G::from_u64(72057594037927936); let __v_31: G = __v_30 * __v_10; let __v_32: G = __v_29 + __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_33 + __v_41; let __v_43: G = __v_15 * __v_35; let __v_44: G = __v_42 + __v_43; let __v_45: G = __v_18 * __v_36; let __v_46: G = __v_44 + __v_45; let __v_47: G = __v_21 * __v_37; let __v_48: G = __v_46 + __v_47; let __v_49: G = __v_24 * __v_38; let __v_50: G = __v_48 + __v_49; let __v_51: G = __v_27 * __v_39; let __v_52: G = __v_50 + __v_51; let __v_53: G = __v_30 * __v_40; let __v_54: G = __v_52 + __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 = __v_37 + __v_38; let __v_56: G = __v_55 + __v_39; let __v_57: G = __v_56 + __v_40; let __v_58: G = G::from_u64(1020); let __v_59: G = __v_57 - __v_58; let __v_60: G = G::from_bool(__v_59 == G::ZERO); let __v_61: G = __v_33 + __v_34; let __v_62: G = __v_61 + __v_35; let __v_63: G = __v_62 + __v_36; 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_119] = [__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[119].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_119] = [__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[119].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_13, __v_14]; 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_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_119] = [__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[119].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_120: usize = 6; -const IN_120: usize = 6; -const OUT_120: usize = 1; -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 __v_1: G = inp[1]; let __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_119] = { let __args: [G; IN_119] = [__v_0, __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_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_89] = { let __args: [G; IN_89] = [__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(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_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_120] = [__v_114]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_120] = [__v_5]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_120] = [__v_5]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_120] = [__v_5]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_120] = [__v_5]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_120] = [__v_5]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_120] = [__v_5]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_120] = [__v_5]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_120] = [__v_5]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_14, __v_15]; 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 __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_119] = { let __args: [G; IN_119] = [__v_25, __v_26]; 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_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_119] = { let __args: [G; IN_119] = [__v_36, __v_37]; 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_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_119] = { let __args: [G; IN_119] = [__v_47, __v_48]; 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_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_119] = { let __args: [G; IN_119] = [__v_58, __v_59]; 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_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_119] = { let __args: [G; IN_119] = [__v_69, __v_70]; 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_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_119] = { let __args: [G; IN_119] = [__v_80, __v_81]; 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_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_16 + __v_27; let __v_96: G = __v_95 + __v_38; let __v_97: G = __v_96 + __v_49; let __v_98: G = __v_97 + __v_60; let __v_99: G = __v_98 + __v_71; let __v_100: G = __v_99 + __v_82; let __v_101: G = __v_100 + __v_93; 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_113 * __v_116; let __v_120: G = __v_118 - __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_4] = { let __args: [G; IN_4] = [__v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(4, &__args[..])?) { [G::ZERO; OUT_4] } else { let (__hash, __hit) = record.function_queries[4].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[4].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => { aiur_fn_4::(__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 = __v_117 + __v_132; let __v_134: G = G::from_u64(8); let __v_135: G = __v_134 * __v_130; let __v_136: G = __v_133 + __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_89] = { let __args: [G; IN_89] = [__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(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_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_120] = [__v_218]; record.function_queries[120].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_13] = { let __args: [G; IN_13] = [__v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(13, &__args[..])?) { [G::ZERO; OUT_13] } else { let (__hash, __hit) = record.function_queries[13].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[13].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => { aiur_fn_13::(__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_120] = { let __args: [G; IN_120] = [__v_91, __v_92, __v_248, __v_265, __v_266, __v_267]; 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_268: G = __r_arr[0]; let __ret: [G; OUT_120] = [__v_268]; record.function_queries[120].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_120] = { let __args: [G; IN_120] = [__v_91, __v_92, __v_218, __v_3, __v_219, __v_5]; 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_220: G = __r_arr[0]; let __ret: [G; OUT_120] = [__v_220]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_121: usize = 1; -const IN_121: usize = 1; -const OUT_121: usize = 32; -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 __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_120] = { let __args: [G; IN_120] = [__v_33, __v_0, __v_34, __v_35, __v_36, __v_37]; 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_38: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_38]; 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_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_121] = [__v_39, __v_40, __v_41, __v_42, __v_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[121].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_122: usize = 3; -const IN_122: usize = 3; -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 __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_0, __v_1, __v_2]; 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_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_120] = { let __args: [G; IN_120] = [__v_36, __v_3, __v_37, __v_38, __v_39, __v_40]; 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_41: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_41]; 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_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_122] = [__v_74]; record.function_queries[122].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_123: usize = 4; -const IN_123: usize = 4; -const OUT_123: usize = 1; -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 __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_123] = [__v_3]; record.function_queries[123].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1, __v_2]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_3, __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_6: G = __r_arr[0]; let __ret: [G; OUT_123] = [__v_6]; record.function_queries[123].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_124: usize = 1; -const IN_124: usize = 1; -const OUT_124: usize = 1; -fn aiur_fn_124(inp: [G; IN_124], 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 __loaded: [G; 3] = { let __base = 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_124] = [__v_4]; record.function_queries[124].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_3]; 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_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_124] = [__v_7]; record.function_queries[124].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_125: usize = 2; -const IN_125: usize = 2; -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 __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_125] = [__v_1]; record.function_queries[125].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_125] = [__v_0]; record.function_queries[125].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_125] = { let __args: [G; IN_125] = [__v_7, __v_1]; 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_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_125] = [__v_17]; record.function_queries[125].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_125] = { let __args: [G; IN_125] = [__v_7, __v_13]; 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_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_125] = [__v_19]; record.function_queries[125].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_13]; 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_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_125] = [__v_19]; record.function_queries[125].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_126: usize = 1; -const IN_126: usize = 1; -const OUT_126: usize = 2; -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 __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_126] = [__v_8, __v_8]; record.function_queries[126].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_126] = [__v_16, __v_15]; record.function_queries[126].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_12]; 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_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_126] = [__v_16, __v_17]; record.function_queries[126].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_127: usize = 1; -const IN_127: usize = 1; -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 __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_127] = [__v_0]; record.function_queries[127].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_127] = [__v_0]; record.function_queries[127].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_14]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_15, __v_16]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_127] = [__v_17]; record.function_queries[127].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_128: usize = 4; -const IN_128: usize = 4; -const OUT_128: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_314] = { let __args: [G; IN_314] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__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_128] = [__v_10]; record.function_queries[128].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_122] = { let __args: [G; IN_122] = [__v_8, __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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__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_12: G = __r_arr[0]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_6, __v_9, __v_2, __v_3]; 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_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_128] = [__v_14]; record.function_queries[128].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_129: usize = 4; -const IN_129: usize = 4; -const OUT_129: usize = 2; -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 = 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_129] = [__v_11, __v_1]; record.function_queries[129].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_124] = { let __args: [G; IN_124] = [__v_12]; 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 __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_124] = { let __args: [G; IN_124] = [__v_22]; 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_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_118] = { let __args: [G; IN_118] = [__v_7, __v_2, __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_26: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_17, __v_2, __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_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_114] = { let __args: [G; IN_114] = [__v_8, __v_18]; 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_28: G = __r_arr[0]; let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_7, __v_2, __v_3, __v_28]; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_19, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__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_129] = [__v_33, __v_31]; record.function_queries[129].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_115] = { let __args: [G; IN_115] = [__v_11, __v_8, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(115, &__args[..])?) { [G::ZERO; OUT_115] } else { let (__hash, __hit) = record.function_queries[115].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[115].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => { aiur_fn_115::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_7, __v_2, __v_3, __v_29]; 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 __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_9, __v_28, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__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_129] = [__v_34, __v_32]; record.function_queries[129].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_115] = { let __args: [G; IN_115] = [__v_11, __v_8, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(115, &__args[..])?) { [G::ZERO; OUT_115] } else { let (__hash, __hit) = record.function_queries[115].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[115].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => { aiur_fn_115::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_7, __v_2, __v_3, __v_23]; 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_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_129] = [__v_28, __v_22]; record.function_queries[129].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_130: usize = 4; -const IN_130: usize = 4; -const OUT_130: usize = 2; -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]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_130] = [__v_0, __v_1]; record.function_queries[130].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_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_6, __v_7, __v_2, __v_5]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_130] = [__v_8, __v_9]; record.function_queries[130].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_131: usize = 6; -const IN_131: usize = 6; -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 __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_314] = { let __args: [G; IN_314] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__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_128] = { let __args: [G; IN_128] = [__v_3, __v_1, __v_2, __v_5]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_11]; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_12, __v_4, __v_2, __v_5]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__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_317] = { let __args: [G; IN_317] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(317, &__args[..])?) { [G::ZERO; OUT_317] } else { let (__hash, __hit) = record.function_queries[317].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[317].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[317].bump_multiplicity(__i); } let __ret: [G; OUT_317] = unsafe { *(record.function_queries[317].output_at(__i).as_ptr() as *const [G; OUT_317]) }; __ret }, _ => { aiur_fn_317::(__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_312] = { let __args: [G; IN_312] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__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_131] = [__v_27]; record.function_queries[131].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.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 __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_132] = { let __args: [G; IN_132] = [__v_4, __v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_132] = [__v_7]; 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_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_133] = [__v_5]; record.function_queries[133].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = __v_0 * __v_0; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_5, __v_4]; 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_6: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_133] = [__v_6]; record.function_queries[133].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = __v_0 * __v_6; let __ret: [G; OUT_133] = [__v_7]; 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 = 8; -const IN_134: usize = 8; -const OUT_134: usize = 2; -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]; let __v_3: G = inp[3]; let __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_189] = { let __args: [G; IN_189] = [__v_9]; 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_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_132] = { let __args: [G; IN_132] = [__v_0, __v_11]; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_10, __v_12]; 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_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_134] = [__v_64, __v_65]; record.function_queries[134].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -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 __v_2: G = G::from_u64(7); let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_1]; 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_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_132] = { let __args: [G; IN_132] = [__v_0, __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 __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3, __v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __v_2 * __v_7; let __ret: [G; OUT_135] = [__v_8]; record.function_queries[135].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_136: usize = 8; -const IN_136: usize = 8; -const OUT_136: usize = 4; -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 __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 __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() { 1u64 => { let __ret: [G; OUT_136] = [__v_4, __v_5, __v_6, __v_7]; record.function_queries[136].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_18.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_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 = __v_9 + __v_23; let __v_25: G = G::from_u64(65536); let __v_26: G = __v_25 * __v_11; let __v_27: G = __v_24 + __v_26; let __v_28: G = G::from_u64(16777216); let __v_29: G = __v_28 * __v_12; let __v_30: G = __v_27 + __v_29; let __v_31: G = G::from_u64(4294967296); let __v_32: G = __v_31 * __v_13; let __v_33: G = __v_30 + __v_32; let __v_34: G = G::from_u64(1099511627776); let __v_35: G = __v_34 * __v_14; let __v_36: G = __v_33 + __v_35; let __v_37: G = G::from_u64(281474976710656); let __v_38: G = __v_37 * __v_15; let __v_39: G = __v_36 + __v_38; let __v_40: G = G::from_u64(72057594037927936); let __v_41: G = __v_40 * __v_16; let __v_42: G = __v_39 + __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_136] = { let __args: [G; IN_136] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_59, __v_62]; 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_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_136] = [__v_63, __v_64, __v_65, __v_66]; record.function_queries[136].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_137: usize = 2; -const IN_137: usize = 2; -const OUT_137: usize = 1; -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 __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_137] = [__v_1]; record.function_queries[137].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 = __v_6 + __v_15; let __v_17: G = G::from_u64(65536); let __v_18: G = __v_17 * __v_8; let __v_19: G = __v_16 + __v_18; let __v_20: G = G::from_u64(16777216); let __v_21: G = __v_20 * __v_9; let __v_22: G = __v_19 + __v_21; let __v_23: G = G::from_u64(4294967296); let __v_24: G = __v_23 * __v_10; let __v_25: G = __v_22 + __v_24; let __v_26: G = G::from_u64(1099511627776); let __v_27: G = __v_26 * __v_11; let __v_28: G = __v_25 + __v_27; let __v_29: G = G::from_u64(281474976710656); let __v_30: G = __v_29 * __v_12; let __v_31: G = __v_28 + __v_30; let __v_32: G = G::from_u64(72057594037927936); let __v_33: G = __v_32 * __v_13; let __v_34: G = __v_31 + __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 = __v_10 + __v_11; let __v_36: G = __v_35 + __v_12; let __v_37: G = __v_36 + __v_13; let __v_38: G = G::from_u64(1020); let __v_39: G = __v_37 - __v_38; let __v_40: G = G::from_bool(__v_39 == G::ZERO); let __v_41: G = __v_6 + __v_7; let __v_42: G = __v_41 + __v_8; let __v_43: G = __v_42 + __v_9; 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_49 + __v_57; let __v_59: G = __v_17 * __v_51; let __v_60: G = __v_58 + __v_59; let __v_61: G = __v_20 * __v_52; let __v_62: G = __v_60 + __v_61; let __v_63: G = __v_23 * __v_53; let __v_64: G = __v_62 + __v_63; let __v_65: G = __v_26 * __v_54; let __v_66: G = __v_64 + __v_65; let __v_67: G = __v_29 * __v_55; let __v_68: G = __v_66 + __v_67; let __v_69: G = __v_32 * __v_56; let __v_70: G = __v_68 + __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_53 + __v_54; let __v_72: G = __v_71 + __v_55; let __v_73: G = __v_72 + __v_56; let __v_74: G = __v_73 - __v_38; let __v_75: G = G::from_bool(__v_74 == G::ZERO); let __v_76: G = __v_49 + __v_50; let __v_77: G = __v_76 + __v_51; let __v_78: G = __v_77 + __v_52; 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_137] = { let __args: [G; IN_137] = [__v_5, __v_1]; 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_83: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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(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_84: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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(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_85: G = __r_arr[0]; let __ret: [G; OUT_137] = [__v_85]; record.function_queries[137].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_138: usize = 2; -const IN_138: usize = 2; -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 __loaded: [G; 3] = { let __base = 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_138] = [__v_1]; record.function_queries[138].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_4, __v_1]; 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]; let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_3, __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_6: G = __r_arr[0]; let __ret: [G; OUT_138] = [__v_6]; record.function_queries[138].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_139: usize = 2; -const IN_139: usize = 2; -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 __loaded: [G; 3] = { let __base = 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_139] = [__v_1]; record.function_queries[139].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_4, __v_1]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_3, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_139] = [__v_6]; record.function_queries[139].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_140: usize = 3; -const IN_140: usize = 3; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_140] = [__v_2]; record.function_queries[140].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_1, __v_2]; 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_3: G = __r_arr[0]; let __ret: [G; OUT_140] = [__v_3]; record.function_queries[140].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.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; 3] = { let __base = 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_141] = [__v_0]; record.function_queries[141].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_183] = { let __args: [G; IN_183] = [__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(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_7: G = __r_arr[0]; let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_7, __v_4]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_141] = [__v_8]; 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 = 10; -const IN_142: usize = 10; -const OUT_142: usize = 2; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_142] = [__v_0, __v_11]; record.function_queries[142].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__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(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 = 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_182] = { let __args: [G; IN_182] = [__v_10, __v_12, __v_9]; 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 __v_15: G = __r_arr[2]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13]; 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_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_142] = [__v_14, __v_15]; record.function_queries[142].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_143: usize = 4; -const IN_143: usize = 4; -const OUT_143: usize = 2; -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 __loaded: [G; 3] = { let __base = 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_143] = [__v_8, __v_0]; record.function_queries[143].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_184] = { let __args: [G; IN_184] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(184, &__args[..])?) { [G::ZERO; OUT_184] } else { let (__hash, __hit) = record.function_queries[184].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[184].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[184].bump_multiplicity(__i); } let __ret: [G; OUT_184] = unsafe { *(record.function_queries[184].output_at(__i).as_ptr() as *const [G; OUT_184]) }; __ret }, _ => { aiur_fn_184::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__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(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_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_18, __v_19]; 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_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_143] = { let __args: [G; IN_143] = [__v_36, __v_6, __v_16, __v_3]; 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_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 = __v_20 + __v_41; let __v_43: G = G::from_u64(65536); let __v_44: G = __v_43 * __v_22; let __v_45: G = __v_42 + __v_44; let __v_46: G = G::from_u64(16777216); let __v_47: G = __v_46 * __v_23; let __v_48: G = __v_45 + __v_47; let __v_49: G = G::from_u64(4294967296); let __v_50: G = __v_49 * __v_24; let __v_51: G = __v_48 + __v_50; let __v_52: G = G::from_u64(1099511627776); let __v_53: G = __v_52 * __v_25; let __v_54: G = __v_51 + __v_53; let __v_55: G = G::from_u64(281474976710656); let __v_56: G = __v_55 * __v_26; let __v_57: G = __v_54 + __v_56; let __v_58: G = G::from_u64(72057594037927936); let __v_59: G = __v_58 * __v_27; let __v_60: G = __v_57 + __v_59; let __v_61: G = G::from_u64(0); let __v_62: G = __v_40 * __v_29; let __v_63: G = __v_28 + __v_62; let __v_64: G = __v_43 * __v_30; let __v_65: G = __v_63 + __v_64; let __v_66: G = __v_46 * __v_31; let __v_67: G = __v_65 + __v_66; let __v_68: G = __v_49 * __v_32; let __v_69: G = __v_67 + __v_68; let __v_70: G = __v_52 * __v_33; let __v_71: G = __v_69 + __v_70; let __v_72: G = __v_55 * __v_34; let __v_73: G = __v_71 + __v_72; let __v_74: G = __v_58 * __v_35; let __v_75: G = __v_73 + __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_143] = [__v_76, __v_39]; record.function_queries[143].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_144: usize = 5; -const IN_144: usize = 5; -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]; match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_144] = [__v_5]; record.function_queries[144].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __v_5 + __v_1; let __v_7: G = __v_6 - __v_4; 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_144] = [__v_9]; record.function_queries[144].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_144] = { let __args: [G; IN_144] = [__v_0, __v_1, __v_10, __v_11, __v_4]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_144] = [__v_12]; record.function_queries[144].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_145: usize = 4; -const IN_145: usize = 4; -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]; 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_145] = [__v_5]; record.function_queries[145].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_0, __v_1, __v_2, __v_4, __v_3]; 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_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_145] = { let __args: [G; IN_145] = [__v_0, __v_1, __v_2, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_145] = [__v_8]; record.function_queries[145].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_145] = { let __args: [G; IN_145] = [__v_0, __v_1, __v_2, __v_8]; 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_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_145] = [__v_10]; record.function_queries[145].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_146: usize = 8; -const IN_146: usize = 8; -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 __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 __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(319, &__args[..])?) { [G::ZERO; OUT_319] } else { let (__hash, __hit) = record.function_queries[319].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[319].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[319].bump_multiplicity(__i); } let __ret: [G; OUT_319] = unsafe { *(record.function_queries[319].output_at(__i).as_ptr() as *const [G; OUT_319]) }; __ret }, _ => { aiur_fn_319::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(315, &__args[..])?) { [G::ZERO; OUT_315] } else { let (__hash, __hit) = record.function_queries[315].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[315].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => { aiur_fn_315::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __v_15 - __v_16; let __v_18: G = G::from_bool(__v_17 == G::ZERO); let __v_19: G = G::from_u64(1); 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 = { let __values: [G; 7] = [__v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; 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_146] = [__v_20]; record.function_queries[146].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_136] = { let __args: [G; IN_136] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_17, __v_10, __v_11]; 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 __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_146] = [__v_32]; record.function_queries[146].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_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_146] = [__v_19]; record.function_queries[146].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } -const INPUT_SIZE_147: usize = 2; -const IN_147: usize = 2; -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 __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_147] = [__v_9]; record.function_queries[147].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_147] = [__v_17]; record.function_queries[147].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_8, __v_1]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_147] = [__v_11]; record.function_queries[147].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_148: usize = 2; -const IN_148: usize = 2; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_148] = [__v_2]; record.function_queries[148].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_148] = [__v_2]; record.function_queries[148].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_149: usize = 10; -const IN_149: usize = 10; -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]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = __v_3 - __v_1; let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_2, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(326, &__args[..])?) { [G::ZERO; OUT_326] } else { let (__hash, __hit) = record.function_queries[326].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[326].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[326].bump_multiplicity(__i); } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => { aiur_fn_326::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(7); let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_1]; 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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: 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_132] = { let __args: [G; IN_132] = [__v_11, __v_15]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_13, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = __v_12 * __v_17; let __v_19: G = G::from_u64(0); let __v_20: G = __v_4 - __v_18; let __v_21: G = __v_5 - __v_19; let __v_22: G = __v_20 * __v_20; let __v_23: G = __v_21 * __v_21; let __v_24: G = __v_12 * __v_23; let __v_25: G = __v_22 - __v_24; let __v_26: G = aiur::execute::g_inverse_value(__v_25); let __v_27: G = __v_25 * __v_26; let __v_28: G = __v_27 - __v_14; let __v_29: G = __v_25 * __v_28; if (__v_29 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __v_30: G = __v_26 * __v_28; if (__v_30 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __v_31: G = __v_20 * __v_26; let __v_32: G = __v_19 - __v_21; let __v_33: G = __v_32 * __v_26; let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_0, __v_1, __v_6, __v_7, __v_31, __v_33, __v_8, __v_9]; 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_34: G = __r_arr[0]; let __ret: [G; OUT_149] = [__v_34]; record.function_queries[149].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_150: usize = 11; -const IN_150: usize = 11; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_312] = { let __args: [G; IN_312] = [__v_8, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__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_312] = { let __args: [G; IN_312] = [__v_8, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_4]; 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_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_149] = { let __args: [G; IN_149] = [__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(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_24: G = __r_arr[0]; let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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(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_25: G = __r_arr[0]; let __ret: [G; OUT_150] = [__v_25]; record.function_queries[150].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_151: usize = 13; -const IN_151: usize = 13; -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]; 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_151] = [__v_0]; record.function_queries[151].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_6, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__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_312] = { let __args: [G; IN_312] = [__v_9, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_10, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__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(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_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_151] = { let __args: [G; IN_151] = [__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(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_21: G = __r_arr[0]; let __ret: [G; OUT_151] = [__v_21]; record.function_queries[151].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_152: usize = 13; -const IN_152: usize = 13; -const OUT_152: usize = 1; -fn aiur_fn_152(inp: [G; IN_152], 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]; 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_152] = [__v_0]; record.function_queries[152].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_6, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__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_312] = { let __args: [G; IN_312] = [__v_9, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_10, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__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_312] = { let __args: [G; IN_312] = [__v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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(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_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_152] = { let __args: [G; IN_152] = [__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(152, &__args[..])?) { [G::ZERO; OUT_152] } else { let (__hash, __hit) = record.function_queries[152].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[152].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => { aiur_fn_152::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_152] = [__v_23]; record.function_queries[152].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_153: usize = 15; -const IN_153: usize = 15; -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 __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_153] = [__v_0]; record.function_queries[153].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_8, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__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_153] = { let __args: [G; IN_153] = [__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(153, &__args[..])?) { [G::ZERO; OUT_153] } else { let (__hash, __hit) = record.function_queries[153].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[153].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => { aiur_fn_153::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_153] = [__v_20]; record.function_queries[153].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_7, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__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_312] = { let __args: [G; IN_312] = [__v_11, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_12, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__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(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_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_153] = { let __args: [G; IN_153] = [__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(153, &__args[..])?) { [G::ZERO; OUT_153] } else { let (__hash, __hit) = record.function_queries[153].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[153].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => { aiur_fn_153::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_153] = [__v_26]; record.function_queries[153].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_154: usize = 15; -const IN_154: usize = 15; -const OUT_154: usize = 1; -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 __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_154] = [__v_0]; record.function_queries[154].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(3); let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { _ => { let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__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_157] = { let __args: [G; IN_157] = [__v_6, __v_10, __v_5, __v_7, __v_22]; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_23]; 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_24: G = __r_arr[0]; let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__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(153, &__args[..])?) { [G::ZERO; OUT_153] } else { let (__hash, __hit) = record.function_queries[153].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[153].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => { aiur_fn_153::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_154] = [__v_25]; record.function_queries[154].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_155: usize = 4; -const IN_155: usize = 4; -const OUT_155: usize = 1; -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]; 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_155] = [__v_5]; record.function_queries[155].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__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_155] = { let __args: [G; IN_155] = [__v_0, __v_1, __v_8, __v_9]; 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_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_155] = [__v_11]; record.function_queries[155].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_156: usize = 1; -const IN_156: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_156] = [__v_4]; record.function_queries[156].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_3]; 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_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_156] = [__v_4]; record.function_queries[156].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_156] = [__v_2]; record.function_queries[156].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_157: usize = 5; -const IN_157: usize = 5; -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]; 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_157] = [__v_6]; record.function_queries[157].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__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_157] = { let __args: [G; IN_157] = [__v_0, __v_1, __v_2, __v_8, __v_9]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_157] = [__v_10]; record.function_queries[157].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__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_157] = { let __args: [G; IN_157] = [__v_0, __v_1, __v_2, __v_11, __v_12]; 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_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_157] = [__v_14]; record.function_queries[157].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_158: usize = 5; -const IN_158: usize = 5; -const OUT_158: usize = 4; -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]; let __v_4: G = inp[4]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_158] = [__v_1, __v_2, __v_3, __v_4]; record.function_queries[158].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_158] = [__v_3, __v_4, __v_1, __v_2]; record.function_queries[158].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_159: usize = 4; -const IN_159: usize = 4; -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 __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 = __v_4 + __v_13; let __v_15: G = G::from_u64(65536); let __v_16: G = __v_15 * __v_6; let __v_17: G = __v_14 + __v_16; let __v_18: G = G::from_u64(16777216); let __v_19: G = __v_18 * __v_7; let __v_20: G = __v_17 + __v_19; let __v_21: G = G::from_u64(4294967296); let __v_22: G = __v_21 * __v_8; let __v_23: G = __v_20 + __v_22; let __v_24: G = G::from_u64(1099511627776); let __v_25: G = __v_24 * __v_9; let __v_26: G = __v_23 + __v_25; let __v_27: G = G::from_u64(281474976710656); let __v_28: G = __v_27 * __v_10; let __v_29: G = __v_26 + __v_28; let __v_30: G = G::from_u64(72057594037927936); let __v_31: G = __v_30 * __v_11; let __v_32: G = __v_29 + __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 = __v_8 + __v_9; let __v_34: G = __v_33 + __v_10; let __v_35: G = __v_34 + __v_11; let __v_36: G = G::from_u64(1020); let __v_37: G = __v_35 - __v_36; let __v_38: G = G::from_bool(__v_37 == G::ZERO); let __v_39: G = __v_4 + __v_5; let __v_40: G = __v_39 + __v_6; let __v_41: G = __v_40 + __v_7; 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_47 + __v_55; let __v_57: G = __v_15 * __v_49; let __v_58: G = __v_56 + __v_57; let __v_59: G = __v_18 * __v_50; let __v_60: G = __v_58 + __v_59; let __v_61: G = __v_21 * __v_51; let __v_62: G = __v_60 + __v_61; let __v_63: G = __v_24 * __v_52; let __v_64: G = __v_62 + __v_63; let __v_65: G = __v_27 * __v_53; let __v_66: G = __v_64 + __v_65; let __v_67: G = __v_30 * __v_54; let __v_68: G = __v_66 + __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_51 + __v_52; let __v_70: G = __v_69 + __v_53; let __v_71: G = __v_70 + __v_54; let __v_72: G = __v_71 - __v_36; let __v_73: G = G::from_bool(__v_72 == G::ZERO); let __v_74: G = __v_47 + __v_48; let __v_75: G = __v_74 + __v_49; let __v_76: G = __v_75 + __v_50; 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_81 + __v_89; let __v_91: G = __v_15 * __v_83; let __v_92: G = __v_90 + __v_91; let __v_93: G = __v_18 * __v_84; let __v_94: G = __v_92 + __v_93; let __v_95: G = __v_21 * __v_85; let __v_96: G = __v_94 + __v_95; let __v_97: G = __v_24 * __v_86; let __v_98: G = __v_96 + __v_97; let __v_99: G = __v_27 * __v_87; let __v_100: G = __v_98 + __v_99; let __v_101: G = __v_30 * __v_88; let __v_102: G = __v_100 + __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_85 + __v_86; let __v_104: G = __v_103 + __v_87; let __v_105: G = __v_104 + __v_88; let __v_106: G = __v_105 - __v_36; let __v_107: G = G::from_bool(__v_106 == G::ZERO); let __v_108: G = __v_81 + __v_82; let __v_109: G = __v_108 + __v_83; let __v_110: G = __v_109 + __v_84; 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_115 + __v_123; let __v_125: G = __v_15 * __v_117; let __v_126: G = __v_124 + __v_125; let __v_127: G = __v_18 * __v_118; let __v_128: G = __v_126 + __v_127; let __v_129: G = __v_21 * __v_119; let __v_130: G = __v_128 + __v_129; let __v_131: G = __v_24 * __v_120; let __v_132: G = __v_130 + __v_131; let __v_133: G = __v_27 * __v_121; let __v_134: G = __v_132 + __v_133; let __v_135: G = __v_30 * __v_122; let __v_136: G = __v_134 + __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_119 + __v_120; let __v_138: G = __v_137 + __v_121; let __v_139: G = __v_138 + __v_122; let __v_140: G = __v_139 - __v_36; let __v_141: G = G::from_bool(__v_140 == G::ZERO); let __v_142: G = __v_115 + __v_116; let __v_143: G = __v_142 + __v_117; let __v_144: G = __v_143 + __v_118; 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_159] = [__v_154]; record.function_queries[159].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_160: usize = 6; -const IN_160: usize = 6; -const OUT_160: usize = 3; -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 __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_160] = [__v_0, __v_1, __v_5]; record.function_queries[160].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_188] = { let __args: [G; IN_188] = [__v_3, __v_4, __v_15]; 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_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_160] = [__v_26, __v_27, __v_12]; record.function_queries[160].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_160] = [__v_0, __v_1, __v_5]; record.function_queries[160].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } -const INPUT_SIZE_161: usize = 9; -const IN_161: usize = 9; -const OUT_161: usize = 3; -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]; let __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_318] = { let __args: [G; IN_318] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(318, &__args[..])?) { [G::ZERO; OUT_318] } else { let (__hash, __hit) = record.function_queries[318].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[318].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[318].bump_multiplicity(__i); } let __ret: [G; OUT_318] = unsafe { *(record.function_queries[318].output_at(__i).as_ptr() as *const [G; OUT_318]) }; __ret }, _ => { aiur_fn_318::(__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_161] = [__v_0, __v_1, __v_18]; record.function_queries[161].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_315] = { let __args: [G; IN_315] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(315, &__args[..])?) { [G::ZERO; OUT_315] } else { let (__hash, __hit) = record.function_queries[315].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[315].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => { aiur_fn_315::(__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_323] = { let __args: [G; IN_323] = [__v_11, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__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_134] = { let __args: [G; IN_134] = [__v_24, __v_26, __v_14, __v_15, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(134, &__args[..])?) { [G::ZERO; OUT_134] } else { let (__hash, __hit) = record.function_queries[134].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[134].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => { aiur_fn_134::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_34, __v_35, __v_26, __v_14, __v_15, __v_7]; 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_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__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(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_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 = __v_42 + __v_51; let __v_53: G = G::from_u64(65536); let __v_54: G = __v_53 * __v_44; let __v_55: G = __v_52 + __v_54; let __v_56: G = G::from_u64(16777216); let __v_57: G = __v_56 * __v_45; let __v_58: G = __v_55 + __v_57; let __v_59: G = G::from_u64(4294967296); let __v_60: G = __v_59 * __v_46; let __v_61: G = __v_58 + __v_60; let __v_62: G = G::from_u64(1099511627776); let __v_63: G = __v_62 * __v_47; let __v_64: G = __v_61 + __v_63; let __v_65: G = G::from_u64(281474976710656); let __v_66: G = __v_65 * __v_48; let __v_67: G = __v_64 + __v_66; let __v_68: G = G::from_u64(72057594037927936); let __v_69: G = __v_68 * __v_49; let __v_70: G = __v_67 + __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 = __v_46 + __v_47; let __v_72: G = __v_71 + __v_48; let __v_73: G = __v_72 + __v_49; let __v_74: G = G::from_u64(1020); let __v_75: G = __v_73 - __v_74; let __v_76: G = G::from_bool(__v_75 == G::ZERO); let __v_77: G = __v_42 + __v_43; let __v_78: G = __v_77 + __v_44; let __v_79: G = __v_78 + __v_45; 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_85 + __v_93; let __v_95: G = __v_53 * __v_87; let __v_96: G = __v_94 + __v_95; let __v_97: G = __v_56 * __v_88; let __v_98: G = __v_96 + __v_97; let __v_99: G = __v_59 * __v_89; let __v_100: G = __v_98 + __v_99; let __v_101: G = __v_62 * __v_90; let __v_102: G = __v_100 + __v_101; let __v_103: G = __v_65 * __v_91; let __v_104: G = __v_102 + __v_103; let __v_105: G = __v_68 * __v_92; let __v_106: G = __v_104 + __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_89 + __v_90; let __v_108: G = __v_107 + __v_91; let __v_109: G = __v_108 + __v_92; let __v_110: G = __v_109 - __v_74; let __v_111: G = G::from_bool(__v_110 == G::ZERO); let __v_112: G = __v_85 + __v_86; let __v_113: G = __v_112 + __v_87; let __v_114: G = __v_113 + __v_88; 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_119 + __v_127; let __v_129: G = __v_53 * __v_121; let __v_130: G = __v_128 + __v_129; let __v_131: G = __v_56 * __v_122; let __v_132: G = __v_130 + __v_131; let __v_133: G = __v_59 * __v_123; let __v_134: G = __v_132 + __v_133; let __v_135: G = __v_62 * __v_124; let __v_136: G = __v_134 + __v_135; let __v_137: G = __v_65 * __v_125; let __v_138: G = __v_136 + __v_137; let __v_139: G = __v_68 * __v_126; let __v_140: G = __v_138 + __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_123 + __v_124; let __v_142: G = __v_141 + __v_125; let __v_143: G = __v_142 + __v_126; let __v_144: G = __v_143 - __v_74; let __v_145: G = G::from_bool(__v_144 == G::ZERO); let __v_146: G = __v_119 + __v_120; let __v_147: G = __v_146 + __v_121; let __v_148: G = __v_147 + __v_122; 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_153 + __v_161; let __v_163: G = __v_53 * __v_155; let __v_164: G = __v_162 + __v_163; let __v_165: G = __v_56 * __v_156; let __v_166: G = __v_164 + __v_165; let __v_167: G = __v_59 * __v_157; let __v_168: G = __v_166 + __v_167; let __v_169: G = __v_62 * __v_158; let __v_170: G = __v_168 + __v_169; let __v_171: G = __v_65 * __v_159; let __v_172: G = __v_170 + __v_171; let __v_173: G = __v_68 * __v_160; let __v_174: G = __v_172 + __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_157 + __v_158; let __v_176: G = __v_175 + __v_159; let __v_177: G = __v_176 + __v_160; let __v_178: G = __v_177 - __v_74; let __v_179: G = G::from_bool(__v_178 == G::ZERO); let __v_180: G = __v_153 + __v_154; let __v_181: G = __v_180 + __v_155; let __v_182: G = __v_181 + __v_156; 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_161] = [__v_39, __v_40, __v_193]; record.function_queries[161].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_162: usize = 25; -const IN_162: usize = 25; -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 = 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_315] = { let __args: [G; IN_315] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(315, &__args[..])?) { [G::ZERO; OUT_315] } else { let (__hash, __hit) = record.function_queries[315].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[315].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => { aiur_fn_315::(__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_314] = { let __args: [G; IN_314] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__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_148] = { let __args: [G; IN_148] = [__v_8, __v_9]; 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_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_145] = { let __args: [G; IN_145] = [__v_15, __v_19, __v_18, __v_20]; 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_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_15, __v_19, __v_18, __v_36]; 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_37: G = __r_arr[0]; let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; match __v_38.as_canonical_u64() { _ => { let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__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_151] = { let __args: [G; IN_151] = [__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(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_44: G = __r_arr[0]; let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1, __v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { _ => { let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__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_151] = { let __args: [G; IN_151] = [__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(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_51: G = __r_arr[0]; let __v_52: G = G::from_u64(2); let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; match __v_53.as_canonical_u64() { _ => { let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__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_152] = { let __args: [G; IN_152] = [__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(152, &__args[..])?) { [G::ZERO; OUT_152] } else { let (__hash, __hit) = record.function_queries[152].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[152].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => { aiur_fn_152::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__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(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_60: G = __r_arr[0]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_60, __v_19]; 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_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_161] = { let __args: [G; IN_161] = [__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(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_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_323] = { let __args: [G; IN_323] = [__v_23, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__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_162] = [__v_74]; record.function_queries[162].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_62.as_canonical_u64())); }, } }, } }, } }, } }, } }) } -const INPUT_SIZE_163: usize = 25; -const IN_163: usize = 25; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_163] = [__v_30]; record.function_queries[163].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_20]; 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_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__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(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_32: G = __r_arr[0]; let __v_33: G = G::from_u64(0); let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__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(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 __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_163] = [__v_35]; record.function_queries[163].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); }, } }) } -const INPUT_SIZE_164: usize = 4; -const IN_164: usize = 4; -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 __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_164] = [__v_5]; record.function_queries[164].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_3]; 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_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_164] = { let __args: [G; IN_164] = [__v_5, __v_6, __v_9, __v_3]; 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_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_164] = [__v_11]; record.function_queries[164].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_165: usize = 2; -const IN_165: usize = 2; -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 __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_165] = [__v_7]; record.function_queries[165].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_312] = { let __args: [G; IN_312] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_5, __v_1]; 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_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_165] = [__v_9]; record.function_queries[165].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_166: usize = 2; -const IN_166: usize = 2; -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 __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_166] = [__v_8]; record.function_queries[166].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_312] = { let __args: [G; IN_312] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_6, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(166, &__args[..])?) { [G::ZERO; OUT_166] } else { let (__hash, __hit) = record.function_queries[166].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[166].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => { aiur_fn_166::(__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_166] = [__v_10]; record.function_queries[166].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_167: usize = 4; -const IN_167: usize = 4; -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 = 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_167] = [__v_5]; record.function_queries[167].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_0, __v_2]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(166, &__args[..])?) { [G::ZERO; OUT_166] } else { let (__hash, __hit) = record.function_queries[166].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[166].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => { aiur_fn_166::(__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_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(167, &__args[..])?) { [G::ZERO; OUT_167] } else { let (__hash, __hit) = record.function_queries[167].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[167].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => { aiur_fn_167::(__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_167] = [__v_11]; record.function_queries[167].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_168: usize = 13; -const IN_168: usize = 13; -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 = 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_155] = { let __args: [G; IN_155] = [__v_9, __v_11, __v_10, __v_13]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__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_323] = { let __args: [G; IN_323] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__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_323] = { let __args: [G; IN_323] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__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_131] = { let __args: [G; IN_131] = [__v_2, __v_15, __v_14, __v_1, __v_16, __v_12]; 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_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_131] = { let __args: [G; IN_131] = [__v_3, __v_18, __v_14, __v_1, __v_19, __v_12]; 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_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_131] = { let __args: [G; IN_131] = [__v_4, __v_21, __v_14, __v_1, __v_22, __v_12]; 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_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_168] = [__v_27]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_27: G = G::from_u64(3); let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__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_157] = { let __args: [G; IN_157] = [__v_9, __v_11, __v_8, __v_10, __v_30]; 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_31: G = __r_arr[0]; let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_31]; 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 = __v_12 - __v_32; let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_1, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(169, &__args[..])?) { [G::ZERO; OUT_169] } else { let (__hash, __hit) = record.function_queries[169].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[169].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[169].bump_multiplicity(__i); } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => { aiur_fn_169::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_5, __v_28, __v_31, __v_34, __v_29, __v_32]; 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_35: G = __r_arr[0]; let __ret: [G; OUT_168] = [__v_35]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, } }, } }, } }) } -const INPUT_SIZE_169: usize = 2; -const IN_169: usize = 2; -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 __loaded: [G; 3] = { let __base = 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_169] = [__v_0]; record.function_queries[169].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(326, &__args[..])?) { [G::ZERO; OUT_326] } else { let (__hash, __hit) = record.function_queries[326].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[326].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[326].bump_multiplicity(__i); } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => { aiur_fn_326::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(169, &__args[..])?) { [G::ZERO; OUT_169] } else { let (__hash, __hit) = record.function_queries[169].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[169].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[169].bump_multiplicity(__i); } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => { aiur_fn_169::(__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_169] = [__v_8]; record.function_queries[169].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -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 __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_170] = [__v_6]; record.function_queries[170].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__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_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_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_170] = [__v_11]; 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 = 6; -const IN_171: usize = 6; -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 __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_314] = { let __args: [G; IN_314] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__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_171] = [__v_12]; record.function_queries[171].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_314] = { let __args: [G; IN_314] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__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_169] = { let __args: [G; IN_169] = [__v_3, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(169, &__args[..])?) { [G::ZERO; OUT_169] } else { let (__hash, __hit) = record.function_queries[169].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[169].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[169].bump_multiplicity(__i); } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => { aiur_fn_169::(__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_170] = { let __args: [G; IN_170] = [__v_2, __v_4]; 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_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_131] = { let __args: [G; IN_131] = [__v_12, __v_19, __v_22, __v_17, __v_9, __v_18]; 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_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_171] = { let __args: [G; IN_171] = [__v_10, __v_13, __v_2, __v_17, __v_24, __v_18]; 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_25: G = __r_arr[0]; let __ret: [G; OUT_171] = [__v_25]; record.function_queries[171].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_172: usize = 32; -const IN_172: usize = 32; -const OUT_172: usize = 1; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_314] = { let __args: [G; IN_314] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(319, &__args[..])?) { [G::ZERO; OUT_319] } else { let (__hash, __hit) = record.function_queries[319].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[319].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[319].bump_multiplicity(__i); } let __ret: [G; OUT_319] = unsafe { *(record.function_queries[319].output_at(__i).as_ptr() as *const [G; OUT_319]) }; __ret }, _ => { aiur_fn_319::(__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_315] = { let __args: [G; IN_315] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(315, &__args[..])?) { [G::ZERO; OUT_315] } else { let (__hash, __hit) = record.function_queries[315].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[315].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => { aiur_fn_315::(__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_148] = { let __args: [G; IN_148] = [__v_4, __v_5]; 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_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_325] = { let __args: [G; IN_325] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(325, &__args[..])?) { [G::ZERO; OUT_325] } else { let (__hash, __hit) = record.function_queries[325].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[325].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[325].bump_multiplicity(__i); } let __ret: [G; OUT_325] = unsafe { *(record.function_queries[325].output_at(__i).as_ptr() as *const [G; OUT_325]) }; __ret }, _ => { aiur_fn_325::(__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_315] = { let __args: [G; IN_315] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(315, &__args[..])?) { [G::ZERO; OUT_315] } else { let (__hash, __hit) = record.function_queries[315].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[315].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => { aiur_fn_315::(__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_139] = { let __args: [G; IN_139] = [__v_5, __v_45]; 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_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_139] = { let __args: [G; IN_139] = [__v_3, __v_46]; 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_47: G = __r_arr[0]; let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_2, __v_47]; 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_48: G = __r_arr[0]; let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_1, __v_48]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_0, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__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_180] = { let __args: [G; IN_180] = [__v_50, __v_52]; 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_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 = __v_53 + __v_72; let __v_74: G = G::from_u64(65536); let __v_75: G = __v_74 * __v_55; let __v_76: G = __v_73 + __v_75; let __v_77: G = G::from_u64(16777216); let __v_78: G = __v_77 * __v_56; let __v_79: G = __v_76 + __v_78; let __v_80: G = G::from_u64(4294967296); let __v_81: G = __v_80 * __v_57; let __v_82: G = __v_79 + __v_81; let __v_83: G = G::from_u64(1099511627776); let __v_84: G = __v_83 * __v_58; let __v_85: G = __v_82 + __v_84; let __v_86: G = G::from_u64(281474976710656); let __v_87: G = __v_86 * __v_59; let __v_88: G = __v_85 + __v_87; let __v_89: G = G::from_u64(72057594037927936); let __v_90: G = __v_89 * __v_60; let __v_91: G = __v_88 + __v_90; let __v_92: G = __v_71 * __v_62; let __v_93: G = __v_61 + __v_92; let __v_94: G = __v_74 * __v_63; let __v_95: G = __v_93 + __v_94; let __v_96: G = __v_77 * __v_64; let __v_97: G = __v_95 + __v_96; let __v_98: G = __v_80 * __v_65; let __v_99: G = __v_97 + __v_98; let __v_100: G = __v_83 * __v_66; let __v_101: G = __v_99 + __v_100; let __v_102: G = __v_86 * __v_67; let __v_103: G = __v_101 + __v_102; let __v_104: G = __v_89 * __v_68; let __v_105: G = __v_103 + __v_104; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_69, __v_6, __v_7, __v_30]; 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_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_10, __v_52]; 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_108: G = __r_arr[0]; let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_107, __v_108]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_109: G = __r_arr[0]; let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_109, __v_6]; 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_110: G = __r_arr[0]; let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__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(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_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_164] = { let __args: [G; IN_164] = [__v_111, __v_112, __v_29, __v_113]; 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_116: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__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(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_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_167] = { let __args: [G; IN_167] = [__v_8, __v_9, __v_118, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(167, &__args[..])?) { [G::ZERO; OUT_167] } else { let (__hash, __hit) = record.function_queries[167].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[167].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => { aiur_fn_167::(__args, __hash, record, io_buffer)? }, } } }; let __v_119: G = __r_arr[0]; let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__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(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_120: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_9, __v_6, __v_120, __v_116, __v_118, __v_113]; 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_121: G = __r_arr[0]; let __ret: [G; OUT_172] = [__v_121]; record.function_queries[172].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_173: usize = 2; -const IN_173: usize = 2; -const OUT_173: usize = 1; -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 __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_173] = [__v_4]; record.function_queries[173].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_174: usize = 9; -const IN_174: usize = 9; -const OUT_174: usize = 1; -fn aiur_fn_174(inp: [G; IN_174], 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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_174] = [__v_17]; record.function_queries[174].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_175: usize = 33; -const IN_175: usize = 33; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_174] = { let __args: [G; IN_174] = [__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(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_33: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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(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_34: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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(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_35: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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(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_36: G = __r_arr[0]; let __ret: [G; OUT_175] = [__v_36]; record.function_queries[175].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_176: usize = 2; -const IN_176: usize = 2; -const OUT_176: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_176] = [__v_1]; record.function_queries[176].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_176] = { let __args: [G; IN_176] = [__v_4, __v_1]; 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_37: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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(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_38: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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(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_39: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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(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 __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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(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_41: G = __r_arr[0]; let __ret: [G; OUT_176] = [__v_41]; record.function_queries[176].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_177: usize = 2; -const IN_177: usize = 2; -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 __loaded: [G; 3] = { let __base = 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_177] = [__v_1]; record.function_queries[177].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_4, __v_1]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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(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_7: G = __r_arr[0]; let __ret: [G; OUT_177] = [__v_7]; record.function_queries[177].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_178: usize = 2; -const IN_178: usize = 2; -const OUT_178: usize = 10; -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 __loaded: [G; 3] = { let __base = 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_78] = { let __args: [G; IN_78] = [__v_0, __v_37, __v_38, __v_38, __v_39, __v_40, __v_41]; 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_42: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_42]; 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_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_111] = { let __args: [G; IN_111] = [__v_71, __v_72, __v_73, __v_74, __v_37]; 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_75: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_67, __v_68, __v_69, __v_70, __v_75]; 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_76: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_63, __v_64, __v_65, __v_66, __v_76]; 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_77: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_59, __v_60, __v_61, __v_62, __v_77]; 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_78: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_55, __v_56, __v_57, __v_58, __v_78]; 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_79: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_51, __v_52, __v_53, __v_54, __v_79]; 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_80: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_47, __v_48, __v_49, __v_50, __v_80]; 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_81: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_43, __v_44, __v_45, __v_46, __v_81]; 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_82: G = __r_arr[0]; let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_82, __v_37]; 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_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_178] = [__v_85, __v_88, __v_91, __v_94, __v_97, __v_100, __v_103, __v_106, __v_82, __v_107]; record.function_queries[178].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_178] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25]; record.function_queries[178].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_179: usize = 2; -const IN_179: usize = 2; -const OUT_179: usize = 10; -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 = inp[1]; let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_0, __v_1]; 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_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 = __v_6 + __v_7; let __v_13: G = __v_12 + __v_8; let __v_14: G = __v_13 + __v_9; let __v_15: G = G::from_u64(1020); let __v_16: G = __v_14 - __v_15; let __v_17: G = G::from_bool(__v_16 == G::ZERO); let __v_18: G = __v_2 + __v_3; let __v_19: G = __v_18 + __v_4; let __v_20: G = __v_19 + __v_5; 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_179] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[179].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(179, &__args[..])?) { [G::ZERO; OUT_179] } else { let (__hash, __hit) = record.function_queries[179].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[179].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { *(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179]) }; __ret }, _ => { aiur_fn_179::(__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_179] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; 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 = 18; -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 __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(179, &__args[..])?) { [G::ZERO; OUT_179] } else { let (__hash, __hit) = record.function_queries[179].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[179].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { *(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179]) }; __ret }, _ => { aiur_fn_179::(__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_179] = { let __args: [G; IN_179] = [__v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(179, &__args[..])?) { [G::ZERO; OUT_179] } else { let (__hash, __hit) = record.function_queries[179].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[179].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { *(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179]) }; __ret }, _ => { aiur_fn_179::(__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_180] = [__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[180].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -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_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_181] = [__v_3]; record.function_queries[181].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_181] = { let __args: [G; IN_181] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(181, &__args[..])?) { [G::ZERO; OUT_181] } else { let (__hash, __hit) = record.function_queries[181].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[181].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => { aiur_fn_181::(__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_181] = [__v_9]; record.function_queries[181].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_182: usize = 3; -const IN_182: usize = 3; -const OUT_182: usize = 3; -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]; let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_0, __v_1]; 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_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_174] = { let __args: [G; IN_174] = [__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(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_47: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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(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_48: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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(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_49: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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(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_50: G = __r_arr[0]; let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_50, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(181, &__args[..])?) { [G::ZERO; OUT_181] } else { let (__hash, __hit) = record.function_queries[181].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[181].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => { aiur_fn_181::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __ret: [G; OUT_182] = [__v_51, __v_11, __v_12]; record.function_queries[182].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_183: usize = 9; -const IN_183: usize = 9; -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]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_174] = { let __args: [G; IN_174] = [__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(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_11: G = __r_arr[0]; let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_183] = [__v_12]; record.function_queries[183].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_184: usize = 2; -const IN_184: usize = 2; -const OUT_184: usize = 1; -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 = 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_176] = { let __args: [G; IN_176] = [__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 __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_184] = [__v_5]; 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]; 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_185] = [__v_28]; record.function_queries[185].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_186: usize = 2; -const IN_186: usize = 2; -const OUT_186: usize = 1; -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 __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_186] = [__v_1]; record.function_queries[186].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_11, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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(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_13: G = __r_arr[0]; let __ret: [G; OUT_186] = [__v_13]; record.function_queries[186].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_187: usize = 2; -const IN_187: usize = 2; -const OUT_187: usize = 1; -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]; 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_187] = [__v_3]; record.function_queries[187].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_187] = [__v_1]; record.function_queries[187].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_188: usize = 3; -const IN_188: usize = 3; -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]; match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_188] = [__v_0, __v_1]; record.function_queries[188].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_188] = { let __args: [G; IN_188] = [__v_7, __v_10, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_188] = [__v_13, __v_14]; 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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_189] = [__v_1]; record.function_queries[189].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1753635133440165772); let __ret: [G; OUT_189] = [__v_1]; record.function_queries[189].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_189] = { let __args: [G; IN_189] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __v_3 * __v_3; let __ret: [G; OUT_189] = [__v_4]; record.function_queries[189].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_190: usize = 3; -const IN_190: usize = 3; -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 __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_0, __v_1, __v_2]; 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_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_190] = [__v_7, __v_8]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_191: usize = 1; -const IN_191: usize = 1; -const OUT_191: usize = 1; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_191] = [__v_1]; record.function_queries[191].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_191] = { let __args: [G; IN_191] = [__v_3]; 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_4: G = __r_arr[0]; let __v_5: G = __v_1 * __v_4; let __ret: [G; OUT_191] = [__v_5]; record.function_queries[191].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_192: usize = 3; -const IN_192: usize = 3; -const OUT_192: usize = 8; -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 __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_0, __v_1, __v_2]; 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_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_189] = { let __args: [G; IN_189] = [__v_2]; 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_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_192] = [__v_33, __v_36, __v_50, __v_53, __v_37, __v_16, __v_63, __v_65]; record.function_queries[192].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_193: usize = 6; -const IN_193: usize = 6; -const OUT_193: usize = 2; -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 = __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_193] = [__v_14, __v_15]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_194: usize = 4; -const IN_194: usize = 4; -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 = 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_194] = [__v_14, __v_15]; record.function_queries[194].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_195: usize = 1; -const IN_195: usize = 1; -const OUT_195: usize = 1; -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 __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_195] = [__v_6]; record.function_queries[195].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_194] = { let __args: [G; IN_194] = [__v_2, __v_3, __v_6, __v_7]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(195, &__args[..])?) { [G::ZERO; OUT_195] } else { let (__hash, __hit) = record.function_queries[195].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[195].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => { aiur_fn_195::(__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_195] = [__v_13]; record.function_queries[195].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_196: usize = 15; -const IN_196: usize = 15; -const OUT_196: usize = 2; -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 = 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_321] = { let __args: [G; IN_321] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(321, &__args[..])?) { [G::ZERO; OUT_321] } else { let (__hash, __hit) = record.function_queries[321].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[321].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[321].bump_multiplicity(__i); } let __ret: [G; OUT_321] = unsafe { *(record.function_queries[321].output_at(__i).as_ptr() as *const [G; OUT_321]) }; __ret }, _ => { aiur_fn_321::(__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_196] = [__v_16, __v_19]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_19: G = __v_16 + __v_16; let __v_20: G = __v_19 + __v_17; match __v_20.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_196] = [__v_21, __v_22]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_5, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_196] = [__v_21, __v_22]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_2, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_196] = [__v_21, __v_22]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_196] = [__v_21, __v_22]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_6, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_196] = [__v_21, __v_22]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_7, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_196] = [__v_21, __v_22]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_8, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_196] = [__v_19, __v_20]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_196] = [__v_9, __v_10]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_196] = [__v_11, __v_12]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_196] = [__v_13, __v_14]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__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(196, &__args[..])?) { [G::ZERO; OUT_196] } else { let (__hash, __hit) = record.function_queries[196].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[196].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => { aiur_fn_196::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__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(196, &__args[..])?) { [G::ZERO; OUT_196] } else { let (__hash, __hit) = record.function_queries[196].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[196].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => { aiur_fn_196::(__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_196] = [__v_23, __v_24]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__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(196, &__args[..])?) { [G::ZERO; OUT_196] } else { let (__hash, __hit) = record.function_queries[196].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[196].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => { aiur_fn_196::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__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(196, &__args[..])?) { [G::ZERO; OUT_196] } else { let (__hash, __hit) = record.function_queries[196].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[196].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => { aiur_fn_196::(__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_196] = [__v_23, __v_24]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__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(196, &__args[..])?) { [G::ZERO; OUT_196] } else { let (__hash, __hit) = record.function_queries[196].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[196].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => { aiur_fn_196::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__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(196, &__args[..])?) { [G::ZERO; OUT_196] } else { let (__hash, __hit) = record.function_queries[196].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[196].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => { aiur_fn_196::(__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_196] = [__v_27, __v_30]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__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(196, &__args[..])?) { [G::ZERO; OUT_196] } else { let (__hash, __hit) = record.function_queries[196].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[196].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => { aiur_fn_196::(__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_196] = [__v_22, __v_23]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }) } -const INPUT_SIZE_197: usize = 19; -const IN_197: usize = 19; -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 __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_197] = [__v_0, __v_1]; record.function_queries[197].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__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(196, &__args[..])?) { [G::ZERO; OUT_196] } else { let (__hash, __hit) = record.function_queries[196].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[196].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => { aiur_fn_196::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__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(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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; 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_19.as_canonical_u64())); }, } }) } -const INPUT_SIZE_198: usize = 8; -const IN_198: usize = 8; -const OUT_198: usize = 4; -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]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_198] = [__v_31, __v_32, __v_47, __v_48]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_199: usize = 19; -const IN_199: usize = 19; -const OUT_199: usize = 4; -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]; let __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_199] = [__v_22, __v_22, __v_22, __v_22]; record.function_queries[199].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__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(199, &__args[..])?) { [G::ZERO; OUT_199] } else { let (__hash, __hit) = record.function_queries[199].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[199].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[199].bump_multiplicity(__i); } let __ret: [G; OUT_199] = unsafe { *(record.function_queries[199].output_at(__i).as_ptr() as *const [G; OUT_199]) }; __ret }, _ => { aiur_fn_199::(__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_198] = { let __args: [G; IN_198] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; 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_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_196] = { let __args: [G; IN_196] = [__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(196, &__args[..])?) { [G::ZERO; OUT_196] } else { let (__hash, __hit) = record.function_queries[196].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[196].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => { aiur_fn_196::(__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_199] = [__v_32, __v_33, __v_28, __v_29]; record.function_queries[199].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }) } -const INPUT_SIZE_200: usize = 44; -const IN_200: usize = 44; -const OUT_200: usize = 2; -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 __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_200] = [__v_0, __v_1]; record.function_queries[200].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_45.as_canonical_u64() { _ => { let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__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(199, &__args[..])?) { [G::ZERO; OUT_199] } else { let (__hash, __hit) = record.function_queries[199].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[199].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[199].bump_multiplicity(__i); } let __ret: [G; OUT_199] = unsafe { *(record.function_queries[199].output_at(__i).as_ptr() as *const [G; OUT_199]) }; __ret }, _ => { aiur_fn_199::(__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_196] = { let __args: [G; IN_196] = [__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(196, &__args[..])?) { [G::ZERO; OUT_196] } else { let (__hash, __hit) = record.function_queries[196].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[196].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => { aiur_fn_196::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; 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_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_198] = { let __args: [G; IN_198] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; 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_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_5 + __v_85; let __v_87: G = __v_86 - __v_6; match __v_87.as_canonical_u64() { 0u64 => { let __v_88: G = __v_7 + __v_7; let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_35, __v_88]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__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_88 + __v_91; let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_35, __v_92]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__args, __hash, record, io_buffer)? }, } } }; let __v_93: G = __r_arr[0]; let __v_94: G = __r_arr[1]; let __v_95: G = G::from_u64(0); let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_36, __v_95]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__args, __hash, record, io_buffer)? }, } } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __v_96 + __v_18; let __v_99: G = __v_97 + __v_19; let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_36, __v_91]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; let __v_101: G = __r_arr[1]; let __v_102: G = __v_100 + __v_20; let __v_103: G = __v_101 + __v_21; let __v_104: G = __v_98 - __v_89; let __v_105: G = __v_99 - __v_90; let __v_106: G = __v_102 - __v_93; let __v_107: G = __v_103 - __v_94; let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_81, __v_82, __v_83, __v_84, __v_104, __v_105, __v_106, __v_107]; 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_108: G = __r_arr[0]; let __v_109: G = __r_arr[1]; let __v_110: G = __r_arr[2]; let __v_111: G = __r_arr[3]; let __v_112: G = __v_108 - __v_70; let __v_113: G = __v_109 - __v_71; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_1, __v_2, __v_3, __v_112, __v_113]; 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_114: G = __r_arr[0]; let __v_115: G = __r_arr[1]; let __v_116: G = __v_110 - __v_79; let __v_117: G = __v_111 - __v_80; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_114, __v_115, __v_2, __v_3, __v_116, __v_117]; 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_118: G = __r_arr[0]; let __v_119: G = __r_arr[1]; let __ret: [G; OUT_200] = [__v_118, __v_119]; record.function_queries[200].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_323] = { let __args: [G; IN_323] = [__v_35, __v_90]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__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_90 + __v_93; let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_35, __v_94]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__args, __hash, record, io_buffer)? }, } } }; let __v_95: G = __r_arr[0]; let __v_96: G = __r_arr[1]; let __v_97: G = G::from_u64(2); let __v_98: G = __v_90 + __v_97; let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_35, __v_98]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__args, __hash, record, io_buffer)? }, } } }; let __v_99: G = __r_arr[0]; let __v_100: G = __r_arr[1]; let __v_101: G = G::from_u64(3); let __v_102: G = __v_90 + __v_101; let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_35, __v_102]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__args, __hash, record, io_buffer)? }, } } }; let __v_103: G = __r_arr[0]; let __v_104: G = __r_arr[1]; let __v_105: G = __v_99 - __v_91; let __v_106: G = __v_100 - __v_92; let __v_107: G = __v_103 - __v_95; let __v_108: G = __v_104 - __v_96; let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_81, __v_82, __v_83, __v_84, __v_105, __v_106, __v_107, __v_108]; 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_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_193] = { let __args: [G; IN_193] = [__v_0, __v_1, __v_2, __v_3, __v_113, __v_114]; 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_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_193] = { let __args: [G; IN_193] = [__v_115, __v_116, __v_2, __v_3, __v_117, __v_118]; 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_119: G = __r_arr[0]; let __v_120: G = __r_arr[1]; let __v_121: G = __v_5 + __v_93; let __v_122: G = __v_7 + __v_93; let __v_123: G = G::from_u64(0); let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_119, __v_120, __v_2, __v_3, __v_47, __v_121, __v_6, __v_122, __v_9, __v_9, __v_93, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __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(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_124: G = __r_arr[0]; let __v_125: G = __r_arr[1]; let __ret: [G; OUT_200] = [__v_124, __v_125]; record.function_queries[200].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_200] = { let __args: [G; IN_200] = [__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(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_93: G = __r_arr[0]; let __v_94: G = __r_arr[1]; let __ret: [G; OUT_200] = [__v_93, __v_94]; record.function_queries[200].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_44.as_canonical_u64())); }, } }) } -const INPUT_SIZE_201: usize = 28; -const IN_201: usize = 28; -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 __v_3: G = inp[3]; let __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_197] = { let __args: [G; IN_197] = [__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(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_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_323] = { let __args: [G; IN_323] = [__v_9, __v_64]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__args, __hash, record, io_buffer)? }, } } }; let __v_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_8, __v_64]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__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_193] = { let __args: [G; IN_193] = [__v_29, __v_30, __v_25, __v_26, __v_71, __v_72]; 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_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_323] = { let __args: [G; IN_323] = [__v_9, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; let __v_77: G = __r_arr[1]; let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_8, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__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_193] = { let __args: [G; IN_193] = [__v_73, __v_74, __v_25, __v_26, __v_82, __v_83]; 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_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __ret: [G; OUT_201] = [__v_84, __v_85]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_64: G = G::from_u64(0); let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(315, &__args[..])?) { [G::ZERO; OUT_315] } else { let (__hash, __hit) = record.function_queries[315].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[315].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => { aiur_fn_315::(__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_200] = { let __args: [G; IN_200] = [__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(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_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __ret: [G; OUT_201] = [__v_67, __v_68]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_60.as_canonical_u64())); }, } }) } -const INPUT_SIZE_202: usize = 8; -const IN_202: usize = 8; -const OUT_202: usize = 1; -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 __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_202] = [__v_18]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_203: usize = 5; -const IN_203: usize = 5; -const OUT_203: usize = 2; -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 __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_203] = [__v_9, __v_9]; record.function_queries[203].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_203] = { let __args: [G; IN_203] = [__v_8, __v_1, __v_2, __v_20, __v_23]; 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_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_203] = [__v_26, __v_27]; record.function_queries[203].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_204: usize = 1; -const IN_204: usize = 1; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_204] = [__v_1]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_204] = [__v_1]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_204] = [__v_1]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_204] = [__v_1]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_204] = [__v_1]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_204] = [__v_1]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_204] = [__v_1]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_204] = [__v_1]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_204] = [__v_1]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_204] = [__v_1]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_204] = [__v_1]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_204] = [__v_1]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_204] = [__v_1]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_204] = [__v_1]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_204] = [__v_1]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_204] = [__v_1]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_204] = [__v_1]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_204] = [__v_1]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(32); let __ret: [G; OUT_204] = [__v_1]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_205: usize = 4; -const IN_205: usize = 4; -const OUT_205: usize = 2; -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 __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_205] = [__v_5, __v_5]; record.function_queries[205].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_205] = [__v_5, __v_5]; record.function_queries[205].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__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_312] = { let __args: [G; IN_312] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__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_312] = { let __args: [G; IN_312] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_205] = [__v_6, __v_8]; record.function_queries[205].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_206: usize = 20; -const IN_206: usize = 20; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_206] = [__v_31]; record.function_queries[206].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_21.as_canonical_u64() { _ => { let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__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_204] = { let __args: [G; IN_204] = [__v_24]; 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_35: G = __r_arr[0]; let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_4, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__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_312] = { let __args: [G; IN_312] = [__v_38, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_38, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_5, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_42, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_42, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_1, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__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_312] = { let __args: [G; IN_312] = [__v_7, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__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_312] = { let __args: [G; IN_312] = [__v_47, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__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_312] = { let __args: [G; IN_312] = [__v_47, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__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_315] = { let __args: [G; IN_315] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(315, &__args[..])?) { [G::ZERO; OUT_315] } else { let (__hash, __hit) = record.function_queries[315].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[315].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => { aiur_fn_315::(__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_315] = { let __args: [G; IN_315] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(315, &__args[..])?) { [G::ZERO; OUT_315] } else { let (__hash, __hit) = record.function_queries[315].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[315].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => { aiur_fn_315::(__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_315] = { let __args: [G; IN_315] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(315, &__args[..])?) { [G::ZERO; OUT_315] } else { let (__hash, __hit) = record.function_queries[315].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[315].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => { aiur_fn_315::(__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_315] = { let __args: [G; IN_315] = [__v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(315, &__args[..])?) { [G::ZERO; OUT_315] } else { let (__hash, __hit) = record.function_queries[315].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[315].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => { aiur_fn_315::(__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_315] = { let __args: [G; IN_315] = [__v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(315, &__args[..])?) { [G::ZERO; OUT_315] } else { let (__hash, __hit) = record.function_queries[315].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[315].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => { aiur_fn_315::(__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_315] = { let __args: [G; IN_315] = [__v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(315, &__args[..])?) { [G::ZERO; OUT_315] } else { let (__hash, __hit) = record.function_queries[315].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[315].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => { aiur_fn_315::(__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_188] = { let __args: [G; IN_188] = [__v_18, __v_19, __v_31]; 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_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_189] = { let __args: [G; IN_189] = [__v_31]; 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_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_191] = { let __args: [G; IN_191] = [__v_31]; 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_139: G = __r_arr[0]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_31]; 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_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_197] = { let __args: [G; IN_197] = [__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(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_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_323] = { let __args: [G; IN_323] = [__v_44, __v_181]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__args, __hash, record, io_buffer)? }, } } }; let __v_182: G = __r_arr[0]; let __v_183: G = __r_arr[1]; let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_43, __v_181]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__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_193] = { let __args: [G; IN_193] = [__v_147, __v_148, __v_16, __v_17, __v_188, __v_189]; 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_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_323] = { let __args: [G; IN_323] = [__v_44, __v_192]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__args, __hash, record, io_buffer)? }, } } }; let __v_193: G = __r_arr[0]; let __v_194: G = __r_arr[1]; let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_43, __v_192]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__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_193] = { let __args: [G; IN_193] = [__v_190, __v_191, __v_16, __v_17, __v_199, __v_200]; 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_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_315] = { let __args: [G; IN_315] = [__v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(315, &__args[..])?) { [G::ZERO; OUT_315] } else { let (__hash, __hit) = record.function_queries[315].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[315].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => { aiur_fn_315::(__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_200] = { let __args: [G; IN_200] = [__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(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_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_312] = { let __args: [G; IN_312] = [__v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__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_312] = { let __args: [G; IN_312] = [__v_183, __v_184]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_185: G = __r_arr[0]; let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_185]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(195, &__args[..])?) { [G::ZERO; OUT_195] } else { let (__hash, __hit) = record.function_queries[195].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[195].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => { aiur_fn_195::(__args, __hash, record, io_buffer)? }, } } }; let __v_186: G = __r_arr[0]; let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_186]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(315, &__args[..])?) { [G::ZERO; OUT_315] } else { let (__hash, __hit) = record.function_queries[315].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[315].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => { aiur_fn_315::(__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_188] = { let __args: [G; IN_188] = [__v_18, __v_19, __v_31]; 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_191: G = __r_arr[0]; let __v_192: G = __r_arr[1]; let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_186, __v_191, __v_192, __v_190, __v_184]; 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_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_206] = { let __args: [G; IN_206] = [__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(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_209: G = __r_arr[0]; let __ret: [G; OUT_206] = [__v_209]; record.function_queries[206].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }) } -const INPUT_SIZE_207: usize = 3; -const IN_207: usize = 3; -const OUT_207: usize = 2; -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 __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_207] = [__v_13, __v_13]; record.function_queries[207].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 = __v_4 + __v_14; let __v_16: G = G::from_u64(65536); let __v_17: G = __v_16 * __v_6; let __v_18: G = __v_15 + __v_17; let __v_19: G = G::from_u64(16777216); let __v_20: G = __v_19 * __v_7; let __v_21: G = __v_18 + __v_20; let __v_22: G = G::from_u64(4294967296); let __v_23: G = __v_22 * __v_8; let __v_24: G = __v_21 + __v_23; let __v_25: G = G::from_u64(1099511627776); let __v_26: G = __v_25 * __v_9; let __v_27: G = __v_24 + __v_26; let __v_28: G = G::from_u64(281474976710656); let __v_29: G = __v_28 * __v_10; let __v_30: G = __v_27 + __v_29; let __v_31: G = G::from_u64(72057594037927936); let __v_32: G = __v_31 * __v_11; let __v_33: G = __v_30 + __v_32; let __v_34: G = G::from_u64(0); let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_0, __v_1, __v_12]; 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_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_207] = [__v_45, __v_46]; record.function_queries[207].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_208: usize = 7; -const IN_208: usize = 7; -const OUT_208: usize = 2; -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 __v_2: G = inp[2]; let __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_208] = [__v_0, __v_1]; record.function_queries[208].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_5, __v_6, __v_8]; 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_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_208] = { let __args: [G; IN_208] = [__v_29, __v_30, __v_9, __v_3, __v_4, __v_5, __v_6]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __ret: [G; OUT_208] = [__v_31, __v_32]; record.function_queries[208].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_209: usize = 1; -const IN_209: usize = 1; -const OUT_209: usize = 1; -fn aiur_fn_209(inp: [G; IN_209], 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 __loaded: [G; 3] = { let __base = 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_209] = [__v_4]; record.function_queries[209].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_209] = { let __args: [G; IN_209] = [__v_3]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_209] = [__v_8]; record.function_queries[209].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_210: usize = 2; -const IN_210: usize = 2; -const OUT_210: usize = 1; -fn aiur_fn_210(inp: [G; IN_210], 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; 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_210] = [__v_14]; record.function_queries[210].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_210] = { let __args: [G; IN_210] = [__v_12, __v_15]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_210] = [__v_16]; record.function_queries[210].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_12, __v_15]; 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_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_210] = [__v_18]; record.function_queries[210].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_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 __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_211] = [__v_7]; record.function_queries[211].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_211] = { let __args: [G; IN_211] = [__v_5, __v_8]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_211] = [__v_9]; record.function_queries[211].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_5, __v_8]; 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_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_211] = [__v_11]; record.function_queries[211].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_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 __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 = __v_2 + __v_11; let __v_13: G = G::from_u64(65536); let __v_14: G = __v_13 * __v_4; let __v_15: G = __v_12 + __v_14; let __v_16: G = G::from_u64(16777216); let __v_17: G = __v_16 * __v_5; let __v_18: G = __v_15 + __v_17; let __v_19: G = G::from_u64(4294967296); let __v_20: G = __v_19 * __v_6; let __v_21: G = __v_18 + __v_20; let __v_22: G = G::from_u64(1099511627776); let __v_23: G = __v_22 * __v_7; let __v_24: G = __v_21 + __v_23; let __v_25: G = G::from_u64(281474976710656); let __v_26: G = __v_25 * __v_8; let __v_27: G = __v_24 + __v_26; let __v_28: G = G::from_u64(72057594037927936); let __v_29: G = __v_28 * __v_9; let __v_30: G = __v_27 + __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 = __v_6 + __v_7; let __v_32: G = __v_31 + __v_8; let __v_33: G = __v_32 + __v_9; let __v_34: G = G::from_u64(1020); let __v_35: G = __v_33 - __v_34; let __v_36: G = G::from_bool(__v_35 == G::ZERO); let __v_37: G = __v_2 + __v_3; let __v_38: G = __v_37 + __v_4; let __v_39: G = __v_38 + __v_5; 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_174] = { let __args: [G; IN_174] = [__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(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_45: G = __r_arr[0]; let __ret: [G; OUT_212] = [__v_45]; record.function_queries[212].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_213: usize = 2; -const IN_213: usize = 2; -const OUT_213: usize = 1; -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 __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_1]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_2, __v_3]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_213] = [__v_4]; record.function_queries[213].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_214: usize = 2; -const IN_214: usize = 2; -const OUT_214: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_214] = [__v_1]; record.function_queries[214].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(319, &__args[..])?) { [G::ZERO; OUT_319] } else { let (__hash, __hit) = record.function_queries[319].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[319].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[319].bump_multiplicity(__i); } let __ret: [G; OUT_319] = unsafe { *(record.function_queries[319].output_at(__i).as_ptr() as *const [G; OUT_319]) }; __ret }, _ => { aiur_fn_319::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_4, __v_1]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_5, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_214] = [__v_8]; record.function_queries[214].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_215: usize = 5; -const IN_215: usize = 5; -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 __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_314] = { let __args: [G; IN_314] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_3, __v_4]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_2, __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_212] = { let __args: [G; IN_212] = [__v_5, __v_7]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_1, __v_8]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_9]; 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 __ret: [G; OUT_215] = [__v_10]; record.function_queries[215].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -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; 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_216] = [__v_1]; record.function_queries[216].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_7, __v_1]; 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 __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_3, __v_4, __v_5, __v_6, __v_8]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_216] = [__v_9]; record.function_queries[216].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_217: usize = 2; -const IN_217: usize = 2; -const OUT_217: usize = 1; -fn aiur_fn_217(inp: [G; IN_217], 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 __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_0, __v_1]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_2, __v_3]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_217] = [__v_4]; record.function_queries[217].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -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; 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_218] = [__v_1]; record.function_queries[218].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(319, &__args[..])?) { [G::ZERO; OUT_319] } else { let (__hash, __hit) = record.function_queries[319].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[319].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[319].bump_multiplicity(__i); } let __ret: [G; OUT_319] = unsafe { *(record.function_queries[319].output_at(__i).as_ptr() as *const [G; OUT_319]) }; __ret }, _ => { aiur_fn_319::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_12, __v_1]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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(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_15: G = __r_arr[0]; let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_3, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_13, __v_16]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_218] = [__v_17]; record.function_queries[218].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_219: usize = 4; -const IN_219: usize = 4; -const OUT_219: usize = 5; -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 __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_217] = { let __args: [G; IN_217] = [__v_3, __v_5]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_2, __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_7: G = __r_arr[0]; let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(317, &__args[..])?) { [G::ZERO; OUT_317] } else { let (__hash, __hit) = record.function_queries[317].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[317].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[317].bump_multiplicity(__i); } let __ret: [G; OUT_317] = unsafe { *(record.function_queries[317].output_at(__i).as_ptr() as *const [G; OUT_317]) }; __ret }, _ => { aiur_fn_317::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_8, __v_7]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_1, __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_10: G = __r_arr[0]; let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__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_180] = { let __args: [G; IN_180] = [__v_39, __v_5]; 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_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_174] = { let __args: [G; IN_174] = [__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(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_58: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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(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_59: G = __r_arr[0]; let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_56, __v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_60, __v_5]; 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_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_174] = { let __args: [G; IN_174] = [__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(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_79: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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(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_80: G = __r_arr[0]; let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_77, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__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 = __v_40 + __v_83; let __v_85: G = G::from_u64(65536); let __v_86: G = __v_85 * __v_42; let __v_87: G = __v_84 + __v_86; let __v_88: G = G::from_u64(16777216); let __v_89: G = __v_88 * __v_43; let __v_90: G = __v_87 + __v_89; let __v_91: G = G::from_u64(4294967296); let __v_92: G = __v_91 * __v_44; let __v_93: G = __v_90 + __v_92; let __v_94: G = G::from_u64(1099511627776); let __v_95: G = __v_94 * __v_45; let __v_96: G = __v_93 + __v_95; let __v_97: G = G::from_u64(281474976710656); let __v_98: G = __v_97 * __v_46; let __v_99: G = __v_96 + __v_98; let __v_100: G = G::from_u64(72057594037927936); let __v_101: G = __v_100 * __v_47; let __v_102: G = __v_99 + __v_101; let __v_103: G = __v_82 * __v_49; let __v_104: G = __v_48 + __v_103; let __v_105: G = __v_85 * __v_50; let __v_106: G = __v_104 + __v_105; let __v_107: G = __v_88 * __v_51; let __v_108: G = __v_106 + __v_107; let __v_109: G = __v_91 * __v_52; let __v_110: G = __v_108 + __v_109; let __v_111: G = __v_94 * __v_53; let __v_112: G = __v_110 + __v_111; let __v_113: G = __v_97 * __v_54; let __v_114: G = __v_112 + __v_113; let __v_115: G = __v_100 * __v_55; let __v_116: G = __v_114 + __v_115; let __v_117: G = __v_82 * __v_62; let __v_118: G = __v_61 + __v_117; let __v_119: G = __v_85 * __v_63; let __v_120: G = __v_118 + __v_119; let __v_121: G = __v_88 * __v_64; let __v_122: G = __v_120 + __v_121; let __v_123: G = __v_91 * __v_65; let __v_124: G = __v_122 + __v_123; let __v_125: G = __v_94 * __v_66; let __v_126: G = __v_124 + __v_125; let __v_127: G = __v_97 * __v_67; let __v_128: G = __v_126 + __v_127; let __v_129: G = __v_100 * __v_68; let __v_130: G = __v_128 + __v_129; let __v_131: G = __v_82 * __v_70; let __v_132: G = __v_69 + __v_131; let __v_133: G = __v_85 * __v_71; let __v_134: G = __v_132 + __v_133; let __v_135: G = __v_88 * __v_72; let __v_136: G = __v_134 + __v_135; let __v_137: G = __v_91 * __v_73; let __v_138: G = __v_136 + __v_137; let __v_139: G = __v_94 * __v_74; let __v_140: G = __v_138 + __v_139; let __v_141: G = __v_97 * __v_75; let __v_142: G = __v_140 + __v_141; let __v_143: G = __v_100 * __v_76; let __v_144: G = __v_142 + __v_143; let __ret: [G; OUT_219] = [__v_102, __v_116, __v_130, __v_144, __v_81]; record.function_queries[219].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_220: usize = 5; -const IN_220: usize = 5; -const OUT_220: usize = 5; -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 __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 = __v_5 + __v_14; let __v_16: G = G::from_u64(65536); let __v_17: G = __v_16 * __v_7; let __v_18: G = __v_15 + __v_17; let __v_19: G = G::from_u64(16777216); let __v_20: G = __v_19 * __v_8; let __v_21: G = __v_18 + __v_20; let __v_22: G = G::from_u64(4294967296); let __v_23: G = __v_22 * __v_9; let __v_24: G = __v_21 + __v_23; let __v_25: G = G::from_u64(1099511627776); let __v_26: G = __v_25 * __v_10; let __v_27: G = __v_24 + __v_26; let __v_28: G = G::from_u64(281474976710656); let __v_29: G = __v_28 * __v_11; let __v_30: G = __v_27 + __v_29; let __v_31: G = G::from_u64(72057594037927936); let __v_32: G = __v_31 * __v_12; let __v_33: G = __v_30 + __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 = __v_9 + __v_10; let __v_35: G = __v_34 + __v_11; let __v_36: G = __v_35 + __v_12; let __v_37: G = G::from_u64(1020); let __v_38: G = __v_36 - __v_37; let __v_39: G = G::from_bool(__v_38 == G::ZERO); let __v_40: G = __v_5 + __v_6; let __v_41: G = __v_40 + __v_7; let __v_42: G = __v_41 + __v_8; 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_183] = { let __args: [G; IN_183] = [__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(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_48: G = __r_arr[0]; let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_48, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(184, &__args[..])?) { [G::ZERO; OUT_184] } else { let (__hash, __hit) = record.function_queries[184].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[184].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[184].bump_multiplicity(__i); } let __ret: [G; OUT_184] = unsafe { *(record.function_queries[184].output_at(__i).as_ptr() as *const [G; OUT_184]) }; __ret }, _ => { aiur_fn_184::(__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_137] = { let __args: [G; IN_137] = [__v_4, __v_50]; 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_51: G = __r_arr[0]; let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_49, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_52, __v_50]; 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_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_184] = { let __args: [G; IN_184] = [__v_69, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(184, &__args[..])?) { [G::ZERO; OUT_184] } else { let (__hash, __hit) = record.function_queries[184].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[184].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[184].bump_multiplicity(__i); } let __ret: [G; OUT_184] = unsafe { *(record.function_queries[184].output_at(__i).as_ptr() as *const [G; OUT_184]) }; __ret }, _ => { aiur_fn_184::(__args, __hash, record, io_buffer)? }, } } }; let __v_71: G = __r_arr[0]; let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_71, __v_50]; 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_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_53 + __v_90; let __v_92: G = __v_16 * __v_55; let __v_93: G = __v_91 + __v_92; let __v_94: G = __v_19 * __v_56; let __v_95: G = __v_93 + __v_94; let __v_96: G = __v_22 * __v_57; let __v_97: G = __v_95 + __v_96; let __v_98: G = __v_25 * __v_58; let __v_99: G = __v_97 + __v_98; let __v_100: G = __v_28 * __v_59; let __v_101: G = __v_99 + __v_100; let __v_102: G = __v_31 * __v_60; let __v_103: G = __v_101 + __v_102; let __v_104: G = __v_13 * __v_62; let __v_105: G = __v_61 + __v_104; let __v_106: G = __v_16 * __v_63; let __v_107: G = __v_105 + __v_106; let __v_108: G = __v_19 * __v_64; let __v_109: G = __v_107 + __v_108; let __v_110: G = __v_22 * __v_65; let __v_111: G = __v_109 + __v_110; let __v_112: G = __v_25 * __v_66; let __v_113: G = __v_111 + __v_112; let __v_114: G = __v_28 * __v_67; let __v_115: G = __v_113 + __v_114; let __v_116: G = __v_31 * __v_68; let __v_117: G = __v_115 + __v_116; let __v_118: G = __v_13 * __v_73; let __v_119: G = __v_72 + __v_118; let __v_120: G = __v_16 * __v_74; let __v_121: G = __v_119 + __v_120; let __v_122: G = __v_19 * __v_75; let __v_123: G = __v_121 + __v_122; let __v_124: G = __v_22 * __v_76; let __v_125: G = __v_123 + __v_124; let __v_126: G = __v_25 * __v_77; let __v_127: G = __v_125 + __v_126; let __v_128: G = __v_28 * __v_78; let __v_129: G = __v_127 + __v_128; let __v_130: G = __v_31 * __v_79; let __v_131: G = __v_129 + __v_130; let __v_132: G = __v_13 * __v_81; let __v_133: G = __v_80 + __v_132; let __v_134: G = __v_16 * __v_82; let __v_135: G = __v_133 + __v_134; let __v_136: G = __v_19 * __v_83; let __v_137: G = __v_135 + __v_136; let __v_138: G = __v_22 * __v_84; let __v_139: G = __v_137 + __v_138; let __v_140: G = __v_25 * __v_85; let __v_141: G = __v_139 + __v_140; let __v_142: G = __v_28 * __v_86; let __v_143: G = __v_141 + __v_142; let __v_144: G = __v_31 * __v_87; let __v_145: G = __v_143 + __v_144; let __ret: [G; OUT_220] = [__v_103, __v_117, __v_131, __v_145, __v_88]; record.function_queries[220].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_221: usize = 2; -const IN_221: usize = 2; -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]; 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_221] = [__v_8]; record.function_queries[221].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_221] = { let __args: [G; IN_221] = [__v_4, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_221] = [__v_8]; record.function_queries[221].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_222: usize = 2; -const IN_222: usize = 2; -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 __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_222] = [__v_22]; record.function_queries[222].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_12] = { let __args: [G; IN_12] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if ((!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_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_222] = { let __args: [G; IN_222] = [__v_11, __v_21]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_222] = [__v_24]; record.function_queries[222].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_223: usize = 2; -const IN_223: usize = 2; -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 __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_223] = [__v_8]; record.function_queries[223].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_222] = { let __args: [G; IN_222] = [__v_3, __v_6]; 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_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_223] = { let __args: [G; IN_223] = [__v_4, __v_7]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_223] = [__v_10]; record.function_queries[223].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_224: usize = 2; -const IN_224: usize = 2; -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 = 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_224] = [__v_8]; record.function_queries[224].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_12] = { let __args: [G; IN_12] = [__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(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_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_12] = { let __args: [G; IN_12] = [__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(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_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_12] = { let __args: [G; IN_12] = [__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(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_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_12] = { let __args: [G; IN_12] = [__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(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_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_224] = { let __args: [G; IN_224] = [__v_4, __v_7]; 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_77: G = __r_arr[0]; let __ret: [G; OUT_224] = [__v_77]; record.function_queries[224].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_225: usize = 1; -const IN_225: usize = 1; -const OUT_225: usize = 2; -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; 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_225] = [__v_2, __v_3]; record.function_queries[225].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_225] = [__v_9, __v_10]; record.function_queries[225].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_226: usize = 7; -const IN_226: usize = 7; -const OUT_226: usize = 2; -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 = 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_226] = [__v_0, __v_1]; record.function_queries[226].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_8.as_canonical_u64() { _ => { let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_5, __v_6, __v_8]; 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_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 = __v_9 + __v_38; let __v_40: G = G::from_u64(65536); let __v_41: G = __v_40 * __v_11; let __v_42: G = __v_39 + __v_41; let __v_43: G = G::from_u64(16777216); let __v_44: G = __v_43 * __v_12; let __v_45: G = __v_42 + __v_44; let __v_46: G = G::from_u64(4294967296); let __v_47: G = __v_46 * __v_13; let __v_48: G = __v_45 + __v_47; let __v_49: G = G::from_u64(1099511627776); let __v_50: G = __v_49 * __v_14; let __v_51: G = __v_48 + __v_50; let __v_52: G = G::from_u64(281474976710656); let __v_53: G = __v_52 * __v_15; let __v_54: G = __v_51 + __v_53; let __v_55: G = G::from_u64(72057594037927936); let __v_56: G = __v_55 * __v_16; let __v_57: G = __v_54 + __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_226] = { let __args: [G; IN_226] = [__v_65, __v_66, __v_17, __v_3, __v_4, __v_5, __v_6]; 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_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __ret: [G; OUT_226] = [__v_67, __v_68]; record.function_queries[226].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_227: usize = 1; -const IN_227: usize = 1; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 18u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 19u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 20u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 21u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 22u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 23u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 24u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 25u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 26u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 27u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 28u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 29u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 30u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 31u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_227] = [__v_1]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_228: usize = 1; -const IN_228: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_228] = [__v_4]; record.function_queries[228].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_2]; 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_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_228] = { let __args: [G; IN_228] = [__v_3]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_228] = [__v_6]; record.function_queries[228].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_229: usize = 1; -const IN_229: usize = 1; -const OUT_229: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_229] = [__v_4]; record.function_queries[229].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_3]; 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_4: G = __r_arr[0]; let __v_5: G = __v_2 + __v_4; let __ret: [G; OUT_229] = [__v_5]; record.function_queries[229].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_230: usize = 1; -const IN_230: usize = 1; -const OUT_230: usize = 1; -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 = 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 = __v_3 + __v_12; let __v_14: G = G::from_u64(65536); let __v_15: G = __v_14 * __v_5; let __v_16: G = __v_13 + __v_15; let __v_17: G = G::from_u64(16777216); let __v_18: G = __v_17 * __v_6; let __v_19: G = __v_16 + __v_18; let __v_20: G = G::from_u64(4294967296); let __v_21: G = __v_20 * __v_7; let __v_22: G = __v_19 + __v_21; let __v_23: G = G::from_u64(1099511627776); let __v_24: G = __v_23 * __v_8; let __v_25: G = __v_22 + __v_24; let __v_26: G = G::from_u64(281474976710656); let __v_27: G = __v_26 * __v_9; let __v_28: G = __v_25 + __v_27; let __v_29: G = G::from_u64(72057594037927936); let __v_30: G = __v_29 * __v_10; let __v_31: G = __v_28 + __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 = __v_7 + __v_8; let __v_33: G = __v_32 + __v_9; let __v_34: G = __v_33 + __v_10; let __v_35: G = G::from_u64(1020); let __v_36: G = __v_34 - __v_35; let __v_37: G = G::from_bool(__v_36 == G::ZERO); let __v_38: G = __v_3 + __v_4; let __v_39: G = __v_38 + __v_5; let __v_40: G = __v_39 + __v_6; 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_6 + __v_7; let __v_47: G = __v_46 + __v_8; let __v_48: G = __v_47 + __v_9; let __v_49: G = __v_48 + __v_10; 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_5 * __v_38; if (__v_52 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_230] = [__v_42]; record.function_queries[230].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_231: usize = 1; -const IN_231: usize = 1; -const OUT_231: usize = 24; -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; 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_231] = [__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[231].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_232: usize = 3; -const IN_232: usize = 3; -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 = 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_232] = [__v_7]; record.function_queries[232].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_233: usize = 16; -const IN_233: usize = 16; -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 __v_15: G = inp[15]; let __v_16: G = G::from_u64(1); let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_8, __v_16]; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_1, __v_9, __v_17]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_2, __v_10, __v_18]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_3, __v_11, __v_19]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_4, __v_12, __v_20]; 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_21: G = __r_arr[0]; let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_5, __v_13, __v_21]; 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_22: G = __r_arr[0]; let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_6, __v_14, __v_22]; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_7, __v_15, __v_23]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_233] = [__v_24]; record.function_queries[233].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_234: usize = 3; -const IN_234: usize = 3; -const OUT_234: usize = 1; -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 __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_234] = [__v_14]; record.function_queries[234].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 = __v_5 + __v_26; let __v_28: G = G::from_u64(65536); let __v_29: G = __v_28 * __v_7; let __v_30: G = __v_27 + __v_29; let __v_31: G = G::from_u64(16777216); let __v_32: G = __v_31 * __v_8; let __v_33: G = __v_30 + __v_32; let __v_34: G = G::from_u64(4294967296); let __v_35: G = __v_34 * __v_9; let __v_36: G = __v_33 + __v_35; let __v_37: G = G::from_u64(1099511627776); let __v_38: G = __v_37 * __v_10; let __v_39: G = __v_36 + __v_38; let __v_40: G = G::from_u64(281474976710656); let __v_41: G = __v_40 * __v_11; let __v_42: G = __v_39 + __v_41; let __v_43: G = G::from_u64(72057594037927936); let __v_44: G = __v_43 * __v_12; let __v_45: G = __v_42 + __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_16 + __v_49; let __v_51: G = __v_28 * __v_18; let __v_52: G = __v_50 + __v_51; let __v_53: G = __v_31 * __v_19; let __v_54: G = __v_52 + __v_53; let __v_55: G = __v_34 * __v_20; let __v_56: G = __v_54 + __v_55; let __v_57: G = __v_37 * __v_21; let __v_58: G = __v_56 + __v_57; let __v_59: G = __v_40 * __v_22; let __v_60: G = __v_58 + __v_59; let __v_61: G = __v_43 * __v_23; let __v_62: G = __v_60 + __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_231] = { let __args: [G; IN_231] = [__v_4]; 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_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_231] = { let __args: [G; IN_231] = [__v_15]; 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_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_63 + __v_111; let __v_113: G = __v_28 * __v_65; let __v_114: G = __v_112 + __v_113; let __v_115: G = __v_31 * __v_66; let __v_116: G = __v_114 + __v_115; let __v_117: G = __v_34 * __v_67; let __v_118: G = __v_116 + __v_117; let __v_119: G = __v_37 * __v_68; let __v_120: G = __v_118 + __v_119; let __v_121: G = __v_40 * __v_69; let __v_122: G = __v_120 + __v_121; let __v_123: G = __v_43 * __v_70; let __v_124: G = __v_122 + __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_87 + __v_126; let __v_128: G = __v_28 * __v_89; let __v_129: G = __v_127 + __v_128; let __v_130: G = __v_31 * __v_90; let __v_131: G = __v_129 + __v_130; let __v_132: G = __v_34 * __v_91; let __v_133: G = __v_131 + __v_132; let __v_134: G = __v_37 * __v_92; let __v_135: G = __v_133 + __v_134; let __v_136: G = __v_40 * __v_93; let __v_137: G = __v_135 + __v_136; let __v_138: G = __v_43 * __v_94; let __v_139: G = __v_137 + __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_71 + __v_140; let __v_142: G = __v_28 * __v_73; let __v_143: G = __v_141 + __v_142; let __v_144: G = __v_31 * __v_74; let __v_145: G = __v_143 + __v_144; let __v_146: G = __v_34 * __v_75; let __v_147: G = __v_145 + __v_146; let __v_148: G = __v_37 * __v_76; let __v_149: G = __v_147 + __v_148; let __v_150: G = __v_40 * __v_77; let __v_151: G = __v_149 + __v_150; let __v_152: G = __v_43 * __v_78; let __v_153: G = __v_151 + __v_152; let __v_154: G = __v_25 * __v_96; let __v_155: G = __v_95 + __v_154; let __v_156: G = __v_28 * __v_97; let __v_157: G = __v_155 + __v_156; let __v_158: G = __v_31 * __v_98; let __v_159: G = __v_157 + __v_158; let __v_160: G = __v_34 * __v_99; let __v_161: G = __v_159 + __v_160; let __v_162: G = __v_37 * __v_100; let __v_163: G = __v_161 + __v_162; let __v_164: G = __v_40 * __v_101; let __v_165: G = __v_163 + __v_164; let __v_166: G = __v_43 * __v_102; let __v_167: G = __v_165 + __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_79 + __v_168; let __v_170: G = __v_28 * __v_81; let __v_171: G = __v_169 + __v_170; let __v_172: G = __v_31 * __v_82; let __v_173: G = __v_171 + __v_172; let __v_174: G = __v_34 * __v_83; let __v_175: G = __v_173 + __v_174; let __v_176: G = __v_37 * __v_84; let __v_177: G = __v_175 + __v_176; let __v_178: G = __v_40 * __v_85; let __v_179: G = __v_177 + __v_178; let __v_180: G = __v_43 * __v_86; let __v_181: G = __v_179 + __v_180; let __v_182: G = __v_25 * __v_104; let __v_183: G = __v_103 + __v_182; let __v_184: G = __v_28 * __v_105; let __v_185: G = __v_183 + __v_184; let __v_186: G = __v_31 * __v_106; let __v_187: G = __v_185 + __v_186; let __v_188: G = __v_34 * __v_107; let __v_189: G = __v_187 + __v_188; let __v_190: G = __v_37 * __v_108; let __v_191: G = __v_189 + __v_190; let __v_192: G = __v_40 * __v_109; let __v_193: G = __v_191 + __v_192; let __v_194: G = __v_43 * __v_110; let __v_195: G = __v_193 + __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_196 + __v_204; let __v_206: G = __v_28 * __v_198; let __v_207: G = __v_205 + __v_206; let __v_208: G = __v_31 * __v_199; let __v_209: G = __v_207 + __v_208; let __v_210: G = __v_34 * __v_200; let __v_211: G = __v_209 + __v_210; let __v_212: G = __v_37 * __v_201; let __v_213: G = __v_211 + __v_212; let __v_214: G = __v_40 * __v_202; let __v_215: G = __v_213 + __v_214; let __v_216: G = __v_43 * __v_203; let __v_217: G = __v_215 + __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 = __v_200 + __v_201; let __v_219: G = __v_218 + __v_202; let __v_220: G = __v_219 + __v_203; let __v_221: G = G::from_u64(1020); let __v_222: G = __v_220 - __v_221; let __v_223: G = G::from_bool(__v_222 == G::ZERO); let __v_224: G = __v_196 + __v_197; let __v_225: G = __v_224 + __v_198; let __v_226: G = __v_225 + __v_199; 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_231 + __v_239; let __v_241: G = __v_28 * __v_233; let __v_242: G = __v_240 + __v_241; let __v_243: G = __v_31 * __v_234; let __v_244: G = __v_242 + __v_243; let __v_245: G = __v_34 * __v_235; let __v_246: G = __v_244 + __v_245; let __v_247: G = __v_37 * __v_236; let __v_248: G = __v_246 + __v_247; let __v_249: G = __v_40 * __v_237; let __v_250: G = __v_248 + __v_249; let __v_251: G = __v_43 * __v_238; let __v_252: G = __v_250 + __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_235 + __v_236; let __v_254: G = __v_253 + __v_237; let __v_255: G = __v_254 + __v_238; let __v_256: G = __v_255 - __v_221; let __v_257: G = G::from_bool(__v_256 == G::ZERO); let __v_258: G = __v_231 + __v_232; let __v_259: G = __v_258 + __v_233; let __v_260: G = __v_259 + __v_234; 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_233] = { let __args: [G; IN_233] = [__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(233, &__args[..])?) { [G::ZERO; OUT_233] } else { let (__hash, __hit) = record.function_queries[233].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[233].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => { aiur_fn_233::(__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_268 + __v_276; let __v_278: G = __v_28 * __v_270; let __v_279: G = __v_277 + __v_278; let __v_280: G = __v_31 * __v_271; let __v_281: G = __v_279 + __v_280; let __v_282: G = __v_34 * __v_272; let __v_283: G = __v_281 + __v_282; let __v_284: G = __v_37 * __v_273; let __v_285: G = __v_283 + __v_284; let __v_286: G = __v_40 * __v_274; let __v_287: G = __v_285 + __v_286; let __v_288: G = __v_43 * __v_275; let __v_289: G = __v_287 + __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_272 + __v_273; let __v_291: G = __v_290 + __v_274; let __v_292: G = __v_291 + __v_275; let __v_293: G = __v_292 - __v_221; let __v_294: G = G::from_bool(__v_293 == G::ZERO); let __v_295: G = __v_268 + __v_269; let __v_296: G = __v_295 + __v_270; let __v_297: G = __v_296 + __v_271; 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_302 + __v_310; let __v_312: G = __v_28 * __v_304; let __v_313: G = __v_311 + __v_312; let __v_314: G = __v_31 * __v_305; let __v_315: G = __v_313 + __v_314; let __v_316: G = __v_34 * __v_306; let __v_317: G = __v_315 + __v_316; let __v_318: G = __v_37 * __v_307; let __v_319: G = __v_317 + __v_318; let __v_320: G = __v_40 * __v_308; let __v_321: G = __v_319 + __v_320; let __v_322: G = __v_43 * __v_309; let __v_323: G = __v_321 + __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_306 + __v_307; let __v_325: G = __v_324 + __v_308; let __v_326: G = __v_325 + __v_309; let __v_327: G = __v_326 - __v_221; let __v_328: G = G::from_bool(__v_327 == G::ZERO); let __v_329: G = __v_302 + __v_303; let __v_330: G = __v_329 + __v_304; let __v_331: G = __v_330 + __v_305; 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_233] = { let __args: [G; IN_233] = [__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(233, &__args[..])?) { [G::ZERO; OUT_233] } else { let (__hash, __hit) = record.function_queries[233].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[233].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => { aiur_fn_233::(__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_338 + __v_346; let __v_348: G = __v_28 * __v_340; let __v_349: G = __v_347 + __v_348; let __v_350: G = __v_31 * __v_341; let __v_351: G = __v_349 + __v_350; let __v_352: G = __v_34 * __v_342; let __v_353: G = __v_351 + __v_352; let __v_354: G = __v_37 * __v_343; let __v_355: G = __v_353 + __v_354; let __v_356: G = __v_40 * __v_344; let __v_357: G = __v_355 + __v_356; let __v_358: G = __v_43 * __v_345; let __v_359: G = __v_357 + __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_342 + __v_343; let __v_361: G = __v_360 + __v_344; let __v_362: G = __v_361 + __v_345; let __v_363: G = __v_362 - __v_221; let __v_364: G = G::from_bool(__v_363 == G::ZERO); let __v_365: G = __v_338 + __v_339; let __v_366: G = __v_365 + __v_340; let __v_367: G = __v_366 + __v_341; 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_372 + __v_380; let __v_382: G = __v_28 * __v_374; let __v_383: G = __v_381 + __v_382; let __v_384: G = __v_31 * __v_375; let __v_385: G = __v_383 + __v_384; let __v_386: G = __v_34 * __v_376; let __v_387: G = __v_385 + __v_386; let __v_388: G = __v_37 * __v_377; let __v_389: G = __v_387 + __v_388; let __v_390: G = __v_40 * __v_378; let __v_391: G = __v_389 + __v_390; let __v_392: G = __v_43 * __v_379; let __v_393: G = __v_391 + __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_376 + __v_377; let __v_395: G = __v_394 + __v_378; let __v_396: G = __v_395 + __v_379; let __v_397: G = __v_396 - __v_221; let __v_398: G = G::from_bool(__v_397 == G::ZERO); let __v_399: G = __v_372 + __v_373; let __v_400: G = __v_399 + __v_374; let __v_401: G = __v_400 + __v_375; 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_233] = { let __args: [G; IN_233] = [__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(233, &__args[..])?) { [G::ZERO; OUT_233] } else { let (__hash, __hit) = record.function_queries[233].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[233].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => { aiur_fn_233::(__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_234] = { let __args: [G; IN_234] = [__v_24, __v_153, __v_195]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_409: G = __r_arr[0]; let __ret: [G; OUT_234] = [__v_409]; record.function_queries[234].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_235: usize = 46; -const IN_235: usize = 46; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_315] = { let __args: [G; IN_315] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(315, &__args[..])?) { [G::ZERO; OUT_315] } else { let (__hash, __hit) = record.function_queries[315].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[315].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => { aiur_fn_315::(__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_314] = { let __args: [G; IN_314] = [__v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__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_314] = { let __args: [G; IN_314] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__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_314] = { let __args: [G; IN_314] = [__v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__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_209] = { let __args: [G; IN_209] = [__v_17]; 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_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_314] = { let __args: [G; IN_314] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__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_210] = { let __args: [G; IN_210] = [__v_8, __v_17]; 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_60: G = __r_arr[0]; let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_11, __v_17]; 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_61: G = __r_arr[0]; let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__args, __hash, record, io_buffer)? }, } } }; let __v_62: G = __r_arr[0]; let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(315, &__args[..])?) { [G::ZERO; OUT_315] } else { let (__hash, __hit) = record.function_queries[315].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[315].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => { aiur_fn_315::(__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_221] = { let __args: [G; IN_221] = [__v_12, __v_17]; 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_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_224] = { let __args: [G; IN_224] = [__v_13, __v_18]; 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_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_221] = { let __args: [G; IN_221] = [__v_14, __v_22]; 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_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_228] = { let __args: [G; IN_228] = [__v_22]; 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_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_229] = { let __args: [G; IN_229] = [__v_17]; 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_71: G = __r_arr[0]; let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__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_220] = { let __args: [G; IN_220] = [__v_41, __v_16, __v_19, __v_20, __v_21]; 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_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_208] = { let __args: [G; IN_208] = [__v_79, __v_79, __v_15, __v_42, __v_43, __v_44, __v_45]; 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_80: G = __r_arr[0]; let __v_81: G = __r_arr[1]; let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__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(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_82: G = __r_arr[0]; let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; match __v_23.as_canonical_u64() { _ => { let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(319, &__args[..])?) { [G::ZERO; OUT_319] } else { let (__hash, __hit) = record.function_queries[319].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[319].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[319].bump_multiplicity(__i); } let __ret: [G; OUT_319] = unsafe { *(record.function_queries[319].output_at(__i).as_ptr() as *const [G; OUT_319]) }; __ret }, _ => { aiur_fn_319::(__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_315] = { let __args: [G; IN_315] = [__v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(315, &__args[..])?) { [G::ZERO; OUT_315] } else { let (__hash, __hit) = record.function_queries[315].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[315].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => { aiur_fn_315::(__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_148] = { let __args: [G; IN_148] = [__v_37, __v_38]; 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_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_325] = { let __args: [G; IN_325] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(325, &__args[..])?) { [G::ZERO; OUT_325] } else { let (__hash, __hit) = record.function_queries[325].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[325].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[325].bump_multiplicity(__i); } let __ret: [G; OUT_325] = unsafe { *(record.function_queries[325].output_at(__i).as_ptr() as *const [G; OUT_325]) }; __ret }, _ => { aiur_fn_325::(__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_315] = { let __args: [G; IN_315] = [__v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(315, &__args[..])?) { [G::ZERO; OUT_315] } else { let (__hash, __hit) = record.function_queries[315].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[315].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => { aiur_fn_315::(__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_139] = { let __args: [G; IN_139] = [__v_38, __v_97]; 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_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_139] = { let __args: [G; IN_139] = [__v_36, __v_98]; 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_99: G = __r_arr[0]; let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_40, __v_99]; 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_100: G = __r_arr[0]; let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_39, __v_100]; 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_101: G = __r_arr[0]; let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_78, __v_101]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__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_180] = { let __args: [G; IN_180] = [__v_102, __v_104]; 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_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 = __v_105 + __v_124; let __v_126: G = G::from_u64(65536); let __v_127: G = __v_126 * __v_107; let __v_128: G = __v_125 + __v_127; let __v_129: G = G::from_u64(16777216); let __v_130: G = __v_129 * __v_108; let __v_131: G = __v_128 + __v_130; let __v_132: G = G::from_u64(4294967296); let __v_133: G = __v_132 * __v_109; let __v_134: G = __v_131 + __v_133; let __v_135: G = G::from_u64(1099511627776); let __v_136: G = __v_135 * __v_110; let __v_137: G = __v_134 + __v_136; let __v_138: G = G::from_u64(281474976710656); let __v_139: G = __v_138 * __v_111; let __v_140: G = __v_137 + __v_139; let __v_141: G = G::from_u64(72057594037927936); let __v_142: G = __v_141 * __v_112; let __v_143: G = __v_140 + __v_142; let __v_144: G = __v_123 * __v_114; let __v_145: G = __v_113 + __v_144; let __v_146: G = __v_126 * __v_115; let __v_147: G = __v_145 + __v_146; let __v_148: G = __v_129 * __v_116; let __v_149: G = __v_147 + __v_148; let __v_150: G = __v_132 * __v_117; let __v_151: G = __v_149 + __v_150; let __v_152: G = __v_135 * __v_118; let __v_153: G = __v_151 + __v_152; let __v_154: G = __v_138 * __v_119; let __v_155: G = __v_153 + __v_154; let __v_156: G = __v_141 * __v_120; let __v_157: G = __v_155 + __v_156; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_121, __v_23, __v_24, __v_5]; 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_158: G = __r_arr[0]; let __v_159: G = __r_arr[1]; let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_27, __v_104]; 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_160: G = __r_arr[0]; let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_159, __v_160]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_161: G = __r_arr[0]; let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_161, __v_23]; 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_162: G = __r_arr[0]; let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__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(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_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_164] = { let __args: [G; IN_164] = [__v_163, __v_164, __v_4, __v_165]; 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_168: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__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(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_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_167] = { let __args: [G; IN_167] = [__v_25, __v_26, __v_170, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(167, &__args[..])?) { [G::ZERO; OUT_167] } else { let (__hash, __hit) = record.function_queries[167].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[167].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => { aiur_fn_167::(__args, __hash, record, io_buffer)? }, } } }; let __v_171: G = __r_arr[0]; let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__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(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_172: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_26, __v_23, __v_172, __v_168, __v_170, __v_165]; 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_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_225] = { let __args: [G; IN_225] = [__v_21]; 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_174: G = __r_arr[0]; let __v_175: G = __r_arr[1]; let __ret: [G; OUT_235] = [__v_174, __v_175]; record.function_queries[235].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }) } -const INPUT_SIZE_236: usize = 22; -const IN_236: usize = 22; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_236] = [__v_20, __v_21]; record.function_queries[236].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_235] = { let __args: [G; IN_235] = [__v_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(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_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_236] = { let __args: [G; IN_236] = [__v_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(236, &__args[..])?) { [G::ZERO; OUT_236] } else { let (__hash, __hit) = record.function_queries[236].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[236].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[236].bump_multiplicity(__i); } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => { aiur_fn_236::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __v_61: G = __r_arr[1]; let __ret: [G; OUT_236] = [__v_60, __v_61]; record.function_queries[236].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_237: usize = 1; -const IN_237: usize = 1; -const OUT_237: usize = 1; -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 __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_237] = [__v_8]; record.function_queries[237].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_6]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_237] = [__v_8]; record.function_queries[237].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_238: usize = 15; -const IN_238: usize = 15; -const OUT_238: usize = 1; -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]; match __v_12.as_canonical_u64() { _ => { let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(317, &__args[..])?) { [G::ZERO; OUT_317] } else { let (__hash, __hit) = record.function_queries[317].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[317].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[317].bump_multiplicity(__i); } let __ret: [G; OUT_317] = unsafe { *(record.function_queries[317].output_at(__i).as_ptr() as *const [G; OUT_317]) }; __ret }, _ => { aiur_fn_317::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_15]; 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_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_313] = { let __args: [G; IN_313] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(313, &__args[..])?) { [G::ZERO; OUT_313] } else { let (__hash, __hit) = record.function_queries[313].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[313].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[313].bump_multiplicity(__i); } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => { aiur_fn_313::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(317, &__args[..])?) { [G::ZERO; OUT_317] } else { let (__hash, __hit) = record.function_queries[317].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[317].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[317].bump_multiplicity(__i); } let __ret: [G; OUT_317] = unsafe { *(record.function_queries[317].output_at(__i).as_ptr() as *const [G; OUT_317]) }; __ret }, _ => { aiur_fn_317::(__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_234] = { let __args: [G; IN_234] = [__v_13, __v_20, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__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_219] = { let __args: [G; IN_219] = [__v_7, __v_22, __v_12, __v_13]; 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_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_226] = { let __args: [G; IN_226] = [__v_28, __v_28, __v_13, __v_23, __v_24, __v_25, __v_26]; 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_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_0, __v_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(236, &__args[..])?) { [G::ZERO; OUT_236] } else { let (__hash, __hit) = record.function_queries[236].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[236].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[236].bump_multiplicity(__i); } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => { aiur_fn_236::(__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_237] = { let __args: [G; IN_237] = [__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_37: G = __r_arr[0]; let __ret: [G; OUT_238] = [__v_37]; record.function_queries[238].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_239: usize = 15; -const IN_239: usize = 15; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_31] = { let __args: [G; IN_31] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_16, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(65, &__args[..])?) { [G::ZERO; OUT_65] } else { let (__hash, __hit) = record.function_queries[65].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[65].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => { aiur_fn_65::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_20, __v_19]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_24, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(70, &__args[..])?) { [G::ZERO; OUT_70] } else { let (__hash, __hit) = record.function_queries[70].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[70].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { *(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70]) }; __ret }, _ => { aiur_fn_70::(__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_238] = { let __args: [G; IN_238] = [__v_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(238, &__args[..])?) { [G::ZERO; OUT_238] } else { let (__hash, __hit) = record.function_queries[238].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[238].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => { aiur_fn_238::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_28, __v_14]; 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_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_239] = [__v_30]; record.function_queries[239].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_240: usize = 1; -const IN_240: usize = 1; -const OUT_240: usize = 2; -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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(28, &__args[..])?) { [G::ZERO; OUT_28] } else { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[28].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[28].bump_multiplicity(__i); } 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 __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2, __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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_240] = [__v_3, __v_4]; record.function_queries[240].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_241: usize = 2; -const IN_241: usize = 2; -const OUT_241: usize = 2; -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 __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_241] = [__v_3, __v_0]; record.function_queries[241].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 = unconstrained; if ((!unconstrained) && record.defer_call(28, &__args[..])?) { [G::ZERO; OUT_28] } else { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[28].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[28].bump_multiplicity(__i); } 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 __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3, __v_2]; 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_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_241] = { let __args: [G; IN_241] = [__v_5, __v_7]; 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_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_241] = [__v_11, __v_9]; record.function_queries[241].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_242: usize = 1; -const IN_242: usize = 1; -const OUT_242: usize = 2; -fn aiur_fn_242(inp: [G; IN_242], 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(28, &__args[..])?) { [G::ZERO; OUT_28] } else { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[28].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[28].bump_multiplicity(__i); } 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 __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_2, __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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_242] = [__v_3, __v_4]; record.function_queries[242].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_243: usize = 2; -const IN_243: usize = 2; -const OUT_243: usize = 2; -fn aiur_fn_243(inp: [G; IN_243], 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]; 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_243] = [__v_3, __v_0]; record.function_queries[243].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 = unconstrained; if ((!unconstrained) && record.defer_call(27, &__args[..])?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } 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 = __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_243] = { let __args: [G; IN_243] = [__v_10, __v_12]; 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_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_243] = [__v_16, __v_14]; record.function_queries[243].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_244: usize = 1; -const IN_244: usize = 1; -const OUT_244: usize = 2; -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; 3] = { let __base = 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 __v_97: G = { let __values: [G; 32] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_26, __v_29, __v_32, __v_35, __v_38, __v_41, __v_44, __v_47, __v_50, __v_53, __v_56, __v_59, __v_62, __v_65, __v_68, __v_71, __v_74, __v_77, __v_80, __v_83, __v_86, __v_89, __v_92, __v_95]; let __mq = record.memory_queries.get_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_244] = [__v_97, __v_96]; record.function_queries[244].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { 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_245: usize = 2; -const IN_245: usize = 2; -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 __v_1: G = inp[1]; 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_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __mq = record.memory_queries.get_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_34, __v_32, __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_34, __v_31, __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_34, __v_30, __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_34, __v_29, __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 __v_40: G = { let __values: [G; 3] = [__v_34, __v_28, __v_39]; 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_41: G = { let __values: [G; 3] = [__v_34, __v_27, __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 __v_42: G = { let __values: [G; 3] = [__v_34, __v_26, __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 __v_43: G = { let __values: [G; 3] = [__v_34, __v_25, __v_42]; 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_44: G = { let __values: [G; 3] = [__v_34, __v_24, __v_43]; 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_45: G = { let __values: [G; 3] = [__v_34, __v_23, __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 __v_46: G = { let __values: [G; 3] = [__v_34, __v_22, __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 __v_47: G = { let __values: [G; 3] = [__v_34, __v_21, __v_46]; 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_48: G = { let __values: [G; 3] = [__v_34, __v_20, __v_47]; 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_49: G = { let __values: [G; 3] = [__v_34, __v_19, __v_48]; 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_50: G = { let __values: [G; 3] = [__v_34, __v_18, __v_49]; 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_51: G = { let __values: [G; 3] = [__v_34, __v_17, __v_50]; 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_52: G = { let __values: [G; 3] = [__v_34, __v_16, __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 __v_53: G = { let __values: [G; 3] = [__v_34, __v_15, __v_52]; 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_54: G = { let __values: [G; 3] = [__v_34, __v_14, __v_53]; 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; 3] = [__v_34, __v_13, __v_54]; 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_56: G = { let __values: [G; 3] = [__v_34, __v_12, __v_55]; 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_57: G = { let __values: [G; 3] = [__v_34, __v_11, __v_56]; 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_58: G = { let __values: [G; 3] = [__v_34, __v_10, __v_57]; 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_59: G = { let __values: [G; 3] = [__v_34, __v_9, __v_58]; 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_60: G = { let __values: [G; 3] = [__v_34, __v_8, __v_59]; 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_61: G = { let __values: [G; 3] = [__v_34, __v_7, __v_60]; 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_62: G = { let __values: [G; 3] = [__v_34, __v_6, __v_61]; 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_63: G = { let __values: [G; 3] = [__v_34, __v_5, __v_62]; 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_64: G = { let __values: [G; 3] = [__v_34, __v_4, __v_63]; 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_65: G = { let __values: [G; 3] = [__v_34, __v_3, __v_64]; 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_66: G = { let __values: [G; 3] = [__v_34, __v_2, __v_65]; 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_245] = [__v_66]; record.function_queries[245].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_246: usize = 1; -const IN_246: usize = 1; -const OUT_246: usize = 8; -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; 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_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = G::from_u64(256); let __v_34: G = __v_33 * __v_2; let __v_35: G = __v_1 + __v_34; let __v_36: G = G::from_u64(65536); let __v_37: G = __v_36 * __v_3; let __v_38: G = __v_35 + __v_37; let __v_39: G = G::from_u64(16777216); let __v_40: G = __v_39 * __v_4; let __v_41: G = __v_38 + __v_40; let __v_42: G = __v_33 * __v_6; let __v_43: G = __v_5 + __v_42; let __v_44: G = __v_36 * __v_7; let __v_45: G = __v_43 + __v_44; let __v_46: G = __v_39 * __v_8; let __v_47: G = __v_45 + __v_46; let __v_48: G = __v_33 * __v_10; let __v_49: G = __v_9 + __v_48; let __v_50: G = __v_36 * __v_11; let __v_51: G = __v_49 + __v_50; let __v_52: G = __v_39 * __v_12; let __v_53: G = __v_51 + __v_52; let __v_54: G = __v_33 * __v_14; let __v_55: G = __v_13 + __v_54; let __v_56: G = __v_36 * __v_15; let __v_57: G = __v_55 + __v_56; let __v_58: G = __v_39 * __v_16; let __v_59: G = __v_57 + __v_58; let __v_60: G = __v_33 * __v_18; let __v_61: G = __v_17 + __v_60; let __v_62: G = __v_36 * __v_19; let __v_63: G = __v_61 + __v_62; let __v_64: G = __v_39 * __v_20; let __v_65: G = __v_63 + __v_64; let __v_66: G = __v_33 * __v_22; let __v_67: G = __v_21 + __v_66; let __v_68: G = __v_36 * __v_23; let __v_69: G = __v_67 + __v_68; let __v_70: G = __v_39 * __v_24; let __v_71: G = __v_69 + __v_70; let __v_72: G = __v_33 * __v_26; let __v_73: G = __v_25 + __v_72; let __v_74: G = __v_36 * __v_27; let __v_75: G = __v_73 + __v_74; let __v_76: G = __v_39 * __v_28; let __v_77: G = __v_75 + __v_76; let __v_78: G = __v_33 * __v_30; let __v_79: G = __v_29 + __v_78; let __v_80: G = __v_36 * __v_31; let __v_81: G = __v_79 + __v_80; let __v_82: G = __v_39 * __v_32; let __v_83: G = __v_81 + __v_82; let __ret: [G; OUT_246] = [__v_41, __v_47, __v_53, __v_59, __v_65, __v_71, __v_77, __v_83]; record.function_queries[246].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_247: usize = 2; -const IN_247: usize = 2; -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 __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_245] = { let __args: [G; IN_245] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_0, __v_4]; 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_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_2, __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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_247] = [__v_8]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_248: usize = 1; -const IN_248: usize = 1; -const OUT_248: usize = 1; -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 = G::from_u64(1); let __v_2: G = { let __values: [G; 3] = [__v_1, __v_1, __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_245] = { let __args: [G; IN_245] = [__v_0, __v_2]; 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_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__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_6: G = __r_arr[0]; let __ret: [G; OUT_248] = [__v_6]; record.function_queries[248].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_249: usize = 4; -const IN_249: usize = 4; -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 __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_0 * __v_4; let __v_6: G = __v_5 + __v_1; let __v_7: G = __v_6 * __v_4; let __v_8: G = __v_7 + __v_2; let __v_9: G = __v_8 * __v_4; let __v_10: G = __v_9 + __v_3; let __ret: [G; OUT_249] = [__v_10]; record.function_queries[249].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_250: usize = 2; -const IN_250: usize = 2; -const OUT_250: usize = 1; -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 __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_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __loaded: [G; 32] = { let __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_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 = G::from_u64(256); let __v_67: G = __v_2 * __v_66; let __v_68: G = __v_67 + __v_3; let __v_69: G = __v_68 * __v_66; let __v_70: G = __v_69 + __v_4; let __v_71: G = __v_70 * __v_66; let __v_72: G = __v_71 + __v_5; let __v_73: G = __v_34 * __v_66; let __v_74: G = __v_73 + __v_35; let __v_75: G = __v_74 * __v_66; let __v_76: G = __v_75 + __v_36; let __v_77: G = __v_76 * __v_66; let __v_78: G = __v_77 + __v_37; let __v_79: G = __v_72 - __v_78; match __v_79.as_canonical_u64() { 0u64 => { let __v_80: G = G::from_u64(256); let __v_81: G = __v_6 * __v_80; let __v_82: G = __v_81 + __v_7; let __v_83: G = __v_82 * __v_80; let __v_84: G = __v_83 + __v_8; let __v_85: G = __v_84 * __v_80; let __v_86: G = __v_85 + __v_9; let __v_87: G = __v_38 * __v_80; let __v_88: G = __v_87 + __v_39; let __v_89: G = __v_88 * __v_80; let __v_90: G = __v_89 + __v_40; let __v_91: G = __v_90 * __v_80; let __v_92: G = __v_91 + __v_41; let __v_93: G = __v_86 - __v_92; match __v_93.as_canonical_u64() { 0u64 => { let __v_94: G = G::from_u64(256); let __v_95: G = __v_10 * __v_94; let __v_96: G = __v_95 + __v_11; let __v_97: G = __v_96 * __v_94; let __v_98: G = __v_97 + __v_12; let __v_99: G = __v_98 * __v_94; let __v_100: G = __v_99 + __v_13; let __v_101: G = __v_42 * __v_94; let __v_102: G = __v_101 + __v_43; let __v_103: G = __v_102 * __v_94; let __v_104: G = __v_103 + __v_44; let __v_105: G = __v_104 * __v_94; let __v_106: G = __v_105 + __v_45; let __v_107: G = __v_100 - __v_106; match __v_107.as_canonical_u64() { 0u64 => { let __v_108: G = G::from_u64(256); let __v_109: G = __v_14 * __v_108; let __v_110: G = __v_109 + __v_15; let __v_111: G = __v_110 * __v_108; let __v_112: G = __v_111 + __v_16; let __v_113: G = __v_112 * __v_108; let __v_114: G = __v_113 + __v_17; let __v_115: G = __v_46 * __v_108; let __v_116: G = __v_115 + __v_47; let __v_117: G = __v_116 * __v_108; let __v_118: G = __v_117 + __v_48; let __v_119: G = __v_118 * __v_108; let __v_120: G = __v_119 + __v_49; let __v_121: G = __v_114 - __v_120; match __v_121.as_canonical_u64() { 0u64 => { let __v_122: G = G::from_u64(256); let __v_123: G = __v_18 * __v_122; let __v_124: G = __v_123 + __v_19; let __v_125: G = __v_124 * __v_122; let __v_126: G = __v_125 + __v_20; let __v_127: G = __v_126 * __v_122; let __v_128: G = __v_127 + __v_21; let __v_129: G = __v_50 * __v_122; let __v_130: G = __v_129 + __v_51; let __v_131: G = __v_130 * __v_122; let __v_132: G = __v_131 + __v_52; let __v_133: G = __v_132 * __v_122; let __v_134: G = __v_133 + __v_53; let __v_135: G = __v_128 - __v_134; match __v_135.as_canonical_u64() { 0u64 => { let __v_136: G = G::from_u64(256); let __v_137: G = __v_22 * __v_136; let __v_138: G = __v_137 + __v_23; let __v_139: G = __v_138 * __v_136; let __v_140: G = __v_139 + __v_24; let __v_141: G = __v_140 * __v_136; let __v_142: G = __v_141 + __v_25; let __v_143: G = __v_54 * __v_136; let __v_144: G = __v_143 + __v_55; let __v_145: G = __v_144 * __v_136; let __v_146: G = __v_145 + __v_56; let __v_147: G = __v_146 * __v_136; let __v_148: G = __v_147 + __v_57; let __v_149: G = __v_142 - __v_148; match __v_149.as_canonical_u64() { 0u64 => { let __v_150: G = G::from_u64(256); let __v_151: G = __v_26 * __v_150; let __v_152: G = __v_151 + __v_27; let __v_153: G = __v_152 * __v_150; let __v_154: G = __v_153 + __v_28; let __v_155: G = __v_154 * __v_150; let __v_156: G = __v_155 + __v_29; let __v_157: G = __v_58 * __v_150; let __v_158: G = __v_157 + __v_59; let __v_159: G = __v_158 * __v_150; let __v_160: G = __v_159 + __v_60; let __v_161: G = __v_160 * __v_150; let __v_162: G = __v_161 + __v_61; let __v_163: G = __v_156 - __v_162; match __v_163.as_canonical_u64() { 0u64 => { let __v_164: G = G::from_u64(256); let __v_165: G = __v_30 * __v_164; let __v_166: G = __v_165 + __v_31; let __v_167: G = __v_166 * __v_164; let __v_168: G = __v_167 + __v_32; let __v_169: G = __v_168 * __v_164; let __v_170: G = __v_169 + __v_33; let __v_171: G = __v_62 * __v_164; let __v_172: G = __v_171 + __v_63; let __v_173: G = __v_172 * __v_164; let __v_174: G = __v_173 + __v_64; let __v_175: G = __v_174 * __v_164; let __v_176: G = __v_175 + __v_65; let __v_177: G = __v_170 - __v_176; match __v_177.as_canonical_u64() { 0u64 => { let __v_178: G = G::from_u64(1); let __ret: [G; OUT_250] = [__v_178]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_178: G = { let __a_val = __v_170.as_canonical_u64(); let __b_val = __v_176.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_178.as_canonical_u64() { 1u64 => { let __v_179: G = G::from_u64(0); let __ret: [G; OUT_250] = [__v_179]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_179: G = G::from_u64(2); let __ret: [G; OUT_250] = [__v_179]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_164: G = { let __a_val = __v_156.as_canonical_u64(); let __b_val = __v_162.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_164.as_canonical_u64() { 1u64 => { let __v_165: G = G::from_u64(0); let __ret: [G; OUT_250] = [__v_165]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_165: G = G::from_u64(2); let __ret: [G; OUT_250] = [__v_165]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_150: G = { let __a_val = __v_142.as_canonical_u64(); let __b_val = __v_148.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_150.as_canonical_u64() { 1u64 => { let __v_151: G = G::from_u64(0); let __ret: [G; OUT_250] = [__v_151]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_151: G = G::from_u64(2); let __ret: [G; OUT_250] = [__v_151]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_136: G = { let __a_val = __v_128.as_canonical_u64(); let __b_val = __v_134.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_136.as_canonical_u64() { 1u64 => { let __v_137: G = G::from_u64(0); let __ret: [G; OUT_250] = [__v_137]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_137: G = G::from_u64(2); let __ret: [G; OUT_250] = [__v_137]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_122: G = { let __a_val = __v_114.as_canonical_u64(); let __b_val = __v_120.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_122.as_canonical_u64() { 1u64 => { let __v_123: G = G::from_u64(0); let __ret: [G; OUT_250] = [__v_123]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_123: G = G::from_u64(2); let __ret: [G; OUT_250] = [__v_123]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_108: G = { let __a_val = __v_100.as_canonical_u64(); let __b_val = __v_106.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_108.as_canonical_u64() { 1u64 => { let __v_109: G = G::from_u64(0); let __ret: [G; OUT_250] = [__v_109]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_109: G = G::from_u64(2); let __ret: [G; OUT_250] = [__v_109]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_94: G = { let __a_val = __v_86.as_canonical_u64(); let __b_val = __v_92.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_94.as_canonical_u64() { 1u64 => { let __v_95: G = G::from_u64(0); let __ret: [G; OUT_250] = [__v_95]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_95: G = G::from_u64(2); let __ret: [G; OUT_250] = [__v_95]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_80: G = { let __a_val = __v_72.as_canonical_u64(); let __b_val = __v_78.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_80.as_canonical_u64() { 1u64 => { let __v_81: G = G::from_u64(0); let __ret: [G; OUT_250] = [__v_81]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_81: G = G::from_u64(2); let __ret: [G; OUT_250] = [__v_81]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_251: usize = 1; -const IN_251: usize = 1; -const OUT_251: usize = 0; -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 __loaded: [G; 3] = { let __base = 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 __ret: [G; OUT_251] = []; record.function_queries[251].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_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() { 1u64 => { let __ret: [G; OUT_251] = []; record.function_queries[251].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_2, __v_5]; 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_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: Some("aggr: tree leaves are not strictly sorted".to_string()) }); } let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_3]; 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 __ret: [G; OUT_251] = []; record.function_queries[251].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_252: usize = 1; -const IN_252: usize = 1; -const OUT_252: usize = 2; -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 __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); 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 __v_8: G = { let __values: [G; 3] = [__v_5, __v_3, __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_252] = [__v_8, __v_4]; record.function_queries[252].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { 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_252] = [__v_4, __v_2]; record.function_queries[252].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_4]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_252] = [__v_7, __v_6]; 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 = 1; -const IN_253: usize = 1; -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 __loaded: [G; 3] = { let __base = 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 __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_253] = [__v_5]; record.function_queries[253].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__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_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __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_253] = [__v_7]; record.function_queries[253].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_254: usize = 1; -const IN_254: usize = 1; -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 __loaded: [G; 3] = { let __base = 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 __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_254] = [__v_5]; record.function_queries[254].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_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() { 1u64 => { let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 32] = [__v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; 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_247] = { let __args: [G; IN_247] = [__v_2, __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_9: G = __r_arr[0]; 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 __v_12: G = { let __values: [G; 3] = [__v_7, __v_9, __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 __ret: [G; OUT_254] = [__v_12]; record.function_queries[254].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_5]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_6]; 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_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 3] = [__v_7, __v_8, __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 __ret: [G; OUT_254] = [__v_10]; record.function_queries[254].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_255: usize = 1; -const IN_255: usize = 1; -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 __loaded: [G; 3] = { let __base = 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() { 1u64 => { let __ret: [G; OUT_255] = [__v_2]; record.function_queries[255].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_255] = [__v_8]; record.function_queries[255].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_256: usize = 1; -const IN_256: usize = 1; -const OUT_256: usize = 1; -fn aiur_fn_256(inp: [G; IN_256], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_256], ExecError> { stacker::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_253] = { let __args: [G; IN_253] = [__v_0]; 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_1: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__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 __ret: [G; OUT_256] = [__v_2]; record.function_queries[256].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_257: usize = 1; -const IN_257: usize = 1; -const OUT_257: usize = 1; -fn aiur_fn_257(inp: [G; IN_257], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_257], ExecError> { stacker::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; 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_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = G::from_u64(5); let __io_pair: (G, G) = { let __key: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_33, __v_34, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(3, &__args[..])?) { [G::ZERO; OUT_3] } else { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[3].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[3].bump_multiplicity(__i); } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_36]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = G::from_u64(226); if (__v_37 != __v_39) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_39.as_canonical_u64(), msg: Some("aggr: tree has the wrong Ixon tag".to_string()) }); } let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_38]; 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_40: G = __r_arr[0]; let __v_41: 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_41.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_42: G = __loaded[0]; let __v_43: G = __loaded[1]; let __v_44: G = __loaded[2]; let __v_45: G = G::from_u64(1); if (__v_42 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr: trailing bytes after AssumptionTree".to_string()) }); } if (__v_43 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr: trailing bytes after AssumptionTree".to_string()) }); } if (__v_44 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr: trailing bytes after AssumptionTree".to_string()) }); } let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(322, &__args[..])?) { [G::ZERO; OUT_322] } else { let (__hash, __hit) = record.function_queries[322].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[322].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[322].bump_multiplicity(__i); } let __ret: [G; OUT_322] = unsafe { *(record.function_queries[322].output_at(__i).as_ptr() as *const [G; OUT_322]) }; __ret }, _ => { aiur_fn_322::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = G::from_u64(0); if (__v_46 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("aggr: a present tree must contain at least one leaf".to_string()) }); } let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_40]; 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 __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(256, &__args[..])?) { [G::ZERO; OUT_256] } else { let (__hash, __hit) = record.function_queries[256].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[256].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => { aiur_fn_256::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_48, __v_0]; 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_49: G = __r_arr[0]; if (__v_49 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr: tree leaves do not reproduce the canonical root".to_string()) }); } let __ret: [G; OUT_257] = [__v_40]; record.function_queries[257].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_258: usize = 2; -const IN_258: usize = 2; -const OUT_258: usize = 1; -fn aiur_fn_258(inp: [G; IN_258], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_258], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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() { 1u64 => { 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_258] = [__v_3]; record.function_queries[258].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, &__args[..])?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => { aiur_fn_257::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __ret: [G; OUT_258] = [__v_2]; record.function_queries[258].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_259: usize = 2; -const IN_259: usize = 2; -const OUT_259: usize = 0; -fn aiur_fn_259(inp: [G; IN_259], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_259], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; let __loaded: [G; 3] = { let __base = 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_2.as_canonical_u64() { 1u64 => { match __v_5.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_259] = []; record.function_queries[259].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; 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_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: Some("aggr: set element mismatch".to_string()) }); } let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(259, &__args[..])?) { [G::ZERO; OUT_259] } else { let (__hash, __hit) = record.function_queries[259].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[259].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[259].bump_multiplicity(__i); } let __ret: [G; OUT_259] = unsafe { *(record.function_queries[259].output_at(__i).as_ptr() as *const [G; OUT_259]) }; __ret }, _ => { aiur_fn_259::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_259] = []; record.function_queries[259].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_260: usize = 3; -const IN_260: usize = 3; -const OUT_260: usize = 0; -fn aiur_fn_260(inp: [G; IN_260], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_260], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; let __loaded: [G; 3] = { let __base = 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_3.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(259, &__args[..])?) { [G::ZERO; OUT_259] } else { let (__hash, __hit) = record.function_queries[259].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[259].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[259].bump_multiplicity(__i); } let __ret: [G; OUT_259] = unsafe { *(record.function_queries[259].output_at(__i).as_ptr() as *const [G; OUT_259]) }; __ret }, _ => { aiur_fn_259::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_260] = []; record.function_queries[260].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(259, &__args[..])?) { [G::ZERO; OUT_259] } else { let (__hash, __hit) = record.function_queries[259].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[259].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[259].bump_multiplicity(__i); } let __ret: [G; OUT_259] = unsafe { *(record.function_queries[259].output_at(__i).as_ptr() as *const [G; OUT_259]) }; __ret }, _ => { aiur_fn_259::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_260] = []; record.function_queries[260].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_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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_4, __v_7]; 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_10]; 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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("aggr: subject union mismatch".to_string()) }); } let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(260, &__args[..])?) { [G::ZERO; OUT_260] } else { let (__hash, __hit) = record.function_queries[260].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[260].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => { aiur_fn_260::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_260] = []; record.function_queries[260].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_10]; 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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("aggr: subject union mismatch".to_string()) }); } let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_5, __v_8, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(260, &__args[..])?) { [G::ZERO; OUT_260] } else { let (__hash, __hit) = record.function_queries[260].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[260].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => { aiur_fn_260::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_260] = []; record.function_queries[260].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_10]; 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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("aggr: subject union mismatch".to_string()) }); } let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_8, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(260, &__args[..])?) { [G::ZERO; OUT_260] } else { let (__hash, __hit) = record.function_queries[260].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[260].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => { aiur_fn_260::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_260] = []; record.function_queries[260].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_261: usize = 3; -const IN_261: usize = 3; -const OUT_261: usize = 0; -fn aiur_fn_261(inp: [G; IN_261], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_261], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; let __loaded: [G; 3] = { let __base = 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_3.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(259, &__args[..])?) { [G::ZERO; OUT_259] } else { let (__hash, __hit) = record.function_queries[259].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[259].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[259].bump_multiplicity(__i); } let __ret: [G; OUT_259] = unsafe { *(record.function_queries[259].output_at(__i).as_ptr() as *const [G; OUT_259]) }; __ret }, _ => { aiur_fn_259::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_261] = []; record.function_queries[261].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(259, &__args[..])?) { [G::ZERO; OUT_259] } else { let (__hash, __hit) = record.function_queries[259].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[259].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[259].bump_multiplicity(__i); } let __ret: [G; OUT_259] = unsafe { *(record.function_queries[259].output_at(__i).as_ptr() as *const [G; OUT_259]) }; __ret }, _ => { aiur_fn_259::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_261] = []; record.function_queries[261].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_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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_4, __v_7]; 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_10]; 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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("aggr: subject union mismatch".to_string()) }); } let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(261, &__args[..])?) { [G::ZERO; OUT_261] } else { let (__hash, __hit) = record.function_queries[261].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[261].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[261].bump_multiplicity(__i); } let __ret: [G; OUT_261] = unsafe { *(record.function_queries[261].output_at(__i).as_ptr() as *const [G; OUT_261]) }; __ret }, _ => { aiur_fn_261::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_261] = []; record.function_queries[261].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("aggr: child subject sets overlap".to_string()) }); } let __ret: [G; OUT_261] = []; record.function_queries[261].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_10]; 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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("aggr: subject union mismatch".to_string()) }); } let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_8, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(261, &__args[..])?) { [G::ZERO; OUT_261] } else { let (__hash, __hit) = record.function_queries[261].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[261].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[261].bump_multiplicity(__i); } let __ret: [G; OUT_261] = unsafe { *(record.function_queries[261].output_at(__i).as_ptr() as *const [G; OUT_261]) }; __ret }, _ => { aiur_fn_261::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_261] = []; record.function_queries[261].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_262: usize = 2; -const IN_262: usize = 2; -const OUT_262: usize = 0; -fn aiur_fn_262(inp: [G; IN_262], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_262], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; let __loaded: [G; 3] = { let __base = 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_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_262] = []; record.function_queries[262].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_5.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_262] = []; record.function_queries[262].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(262, &__args[..])?) { [G::ZERO; OUT_262] } else { let (__hash, __hit) = record.function_queries[262].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[262].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[262].bump_multiplicity(__i); } let __ret: [G; OUT_262] = unsafe { *(record.function_queries[262].output_at(__i).as_ptr() as *const [G; OUT_262]) }; __ret }, _ => { aiur_fn_262::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_262] = []; record.function_queries[262].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_9: G = G::from_u64(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("aggr: subject set overlaps assumption set".to_string()) }); } let __ret: [G; OUT_262] = []; record.function_queries[262].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(262, &__args[..])?) { [G::ZERO; OUT_262] } else { let (__hash, __hit) = record.function_queries[262].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[262].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[262].bump_multiplicity(__i); } let __ret: [G; OUT_262] = unsafe { *(record.function_queries[262].output_at(__i).as_ptr() as *const [G; OUT_262]) }; __ret }, _ => { aiur_fn_262::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_262] = []; record.function_queries[262].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_263: usize = 2; -const IN_263: usize = 2; -const OUT_263: usize = 5; -fn aiur_fn_263(inp: [G; IN_263], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_263], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; let __loaded: [G; 3] = { let __base = 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_2.as_canonical_u64() { 1u64 => { match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_263] = [__v_8, __v_8, __v_8, __v_8, __v_8]; record.function_queries[263].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(2); let __ret: [G; OUT_263] = [__v_8, __v_6, __v_9, __v_0, __v_7]; record.function_queries[263].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, 0u64 => { match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(0); let __ret: [G; OUT_263] = [__v_8, __v_3, __v_9, __v_4, __v_1]; record.function_queries[263].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(0); let __ret: [G; OUT_263] = [__v_9, __v_3, __v_10, __v_4, __v_1]; record.function_queries[263].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_263] = [__v_9, __v_3, __v_9, __v_4, __v_7]; record.function_queries[263].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(2); let __ret: [G; OUT_263] = [__v_9, __v_6, __v_10, __v_0, __v_7]; record.function_queries[263].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_264: usize = 2; -const IN_264: usize = 2; -const OUT_264: usize = 2; -fn aiur_fn_264(inp: [G; IN_264], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_264], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(0); let __ret: [G; OUT_264] = [__v_5, __v_1]; record.function_queries[264].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_3, __v_0]; 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]; match __v_5.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(264, &__args[..])?) { [G::ZERO; OUT_264] } else { let (__hash, __hit) = record.function_queries[264].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[264].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[264].bump_multiplicity(__i); } let __ret: [G; OUT_264] = unsafe { *(record.function_queries[264].output_at(__i).as_ptr() as *const [G; OUT_264]) }; __ret }, _ => { aiur_fn_264::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_264] = [__v_6, __v_7]; record.function_queries[264].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_264] = [__v_6, __v_4]; record.function_queries[264].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_264] = [__v_6, __v_1]; record.function_queries[264].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_265: usize = 4; -const IN_265: usize = 4; -const OUT_265: usize = 0; -fn aiur_fn_265(inp: [G; IN_265], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_265], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_263] = { let __args: [G; IN_263] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(263, &__args[..])?) { [G::ZERO; OUT_263] } else { let (__hash, __hit) = record.function_queries[263].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[263].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[263].bump_multiplicity(__i); } let __ret: [G; OUT_263] = unsafe { *(record.function_queries[263].output_at(__i).as_ptr() as *const [G; OUT_263]) }; __ret }, _ => { aiur_fn_263::(__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]; 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_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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = G::from_u64(1); if (__v_9 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("aggr: output has an extra assumption".to_string()) }); } if (__v_10 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("aggr: output has an extra assumption".to_string()) }); } if (__v_11 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("aggr: output has an extra assumption".to_string()) }); } let __ret: [G; OUT_265] = []; record.function_queries[265].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(264, &__args[..])?) { [G::ZERO; OUT_264] } else { let (__hash, __hit) = record.function_queries[264].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[264].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[264].bump_multiplicity(__i); } let __ret: [G; OUT_264] = unsafe { *(record.function_queries[264].output_at(__i).as_ptr() as *const [G; OUT_264]) }; __ret }, _ => { aiur_fn_264::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_7, __v_8, __v_10, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(265, &__args[..])?) { [G::ZERO; OUT_265] } else { let (__hash, __hit) = record.function_queries[265].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[265].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[265].bump_multiplicity(__i); } let __ret: [G; OUT_265] = unsafe { *(record.function_queries[265].output_at(__i).as_ptr() as *const [G; OUT_265]) }; __ret }, _ => { aiur_fn_265::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_265] = []; record.function_queries[265].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_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_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; match __v_11.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_5, __v_12]; 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_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); if (__v_14 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("aggr: outstanding assumption mismatch".to_string()) }); } let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_7, __v_8, __v_10, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(265, &__args[..])?) { [G::ZERO; OUT_265] } else { let (__hash, __hit) = record.function_queries[265].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[265].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[265].bump_multiplicity(__i); } let __ret: [G; OUT_265] = unsafe { *(record.function_queries[265].output_at(__i).as_ptr() as *const [G; OUT_265]) }; __ret }, _ => { aiur_fn_265::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_265] = []; record.function_queries[265].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_266: usize = 3; -const IN_266: usize = 3; -const OUT_266: usize = 2; -fn aiur_fn_266(inp: [G; IN_266], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_266], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __ret: [G; OUT_266] = [__v_0, __v_2]; record.function_queries[266].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(2); let __v_6: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_3, &__v_5) } else { aiur::execute::bytes2_less_than_value(__v_3, __v_5, record) }; let __v_7: G = G::from_u64(1); if (__v_6 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr structural: path side must be 0 or 1".to_string()) }); } let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_4]; 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 __v_9: G = __r_arr[1]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_8, __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_10: G = __r_arr[0]; break '__mc_0 [__v_10]; }, _ => { let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __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_10: G = __r_arr[0]; break '__mc_0 [__v_10]; }, } }; let __v_10: G = __mc_out___mc_0[0]; let __v_11: G = G::from_u64(1); let __v_12: G = __v_1 - __v_11; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_10, __v_12, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(266, &__args[..])?) { [G::ZERO; OUT_266] } else { let (__hash, __hit) = record.function_queries[266].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[266].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[266].bump_multiplicity(__i); } let __ret: [G; OUT_266] = unsafe { *(record.function_queries[266].output_at(__i).as_ptr() as *const [G; OUT_266]) }; __ret }, _ => { aiur_fn_266::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_266] = [__v_13, __v_14]; record.function_queries[266].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_267: usize = 4; -const IN_267: usize = 4; -const OUT_267: usize = 1; -fn aiur_fn_267(inp: [G; IN_267], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_267], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(6); 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_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 __io_pair: (G, G) = { let __key: [G; 32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __info = io_buffer.get_info(__v_4, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_37: G = __io_pair.0; let __v_38: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_4, __v_37, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(3, &__args[..])?) { [G::ZERO; OUT_3] } else { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[3].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[3].bump_multiplicity(__i); } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_39]; 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_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = G::from_u64(2); let __v_43: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_40, &__v_42) } else { aiur::execute::bytes2_less_than_value(__v_40, __v_42, record) }; let __v_44: G = G::from_u64(1); if (__v_43 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("aggr structural: discharge choice must be 0 or 1".to_string()) }); } 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_41.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_45: G = __loaded[0]; let __v_46: G = __loaded[1]; let __v_47: G = __loaded[2]; let __v_48: G = G::from_u64(1); if (__v_45 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("aggr structural: carried choice has trailing bytes".to_string()) }); } if (__v_46 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("aggr structural: carried choice has trailing bytes".to_string()) }); } if (__v_47 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("aggr structural: carried choice has trailing bytes".to_string()) }); } let __v_49: G = G::from_u64(0); let __ret: [G; OUT_267] = [__v_49]; record.function_queries[267].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_41]; 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_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __v_47: G = G::from_u64(0); let __v_48: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_47, &__v_45) } else { aiur::execute::bytes2_less_than_value(__v_47, __v_45, record) }; 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: Some("aggr structural: Merkle path must have at least 1 step".to_string()) }); } let __v_50: G = G::from_u64(65); let __v_51: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_45, &__v_50) } else { aiur::execute::bytes2_less_than_value(__v_45, __v_50, record) }; if (__v_51 != __v_49) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_49.as_canonical_u64(), msg: Some("aggr structural: Merkle path exceeds 64 steps".to_string()) }); } let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_0]; 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_52: G = __r_arr[0]; let __v_53: G = __v_45 - __v_49; let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_52, __v_53, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(266, &__args[..])?) { [G::ZERO; OUT_266] } else { let (__hash, __hit) = record.function_queries[266].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[266].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[266].bump_multiplicity(__i); } let __ret: [G; OUT_266] = unsafe { *(record.function_queries[266].output_at(__i).as_ptr() as *const [G; OUT_266]) }; __ret }, _ => { aiur_fn_266::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_55]; 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_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_57]; 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_58: G = __r_arr[0]; let __v_59: 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_59.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_60: G = __loaded[0]; let __v_61: G = __loaded[1]; let __v_62: G = __loaded[2]; if (__v_60 != __v_49) { return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_49.as_canonical_u64(), msg: Some("aggr structural: trailing bytes after Merkle path".to_string()) }); } if (__v_61 != __v_49) { return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_49.as_canonical_u64(), msg: Some("aggr structural: trailing bytes after Merkle path".to_string()) }); } if (__v_62 != __v_49) { return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_49.as_canonical_u64(), msg: Some("aggr structural: trailing bytes after Merkle path".to_string()) }); } match __v_1.as_canonical_u64() { 0u64 => { let __v_63: G = G::from_u64(0); if (__v_56 != __v_63) { return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_63.as_canonical_u64(), msg: Some("aggr structural: left assumption must be discharged by right child".to_string()) }); } let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_58, __v_2]; 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_64: G = __r_arr[0]; let __v_65: G = G::from_u64(1); if (__v_64 != __v_65) { return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: Some("aggr structural: final step sibling is not left subject root".to_string()) }); } let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_54, __v_3]; 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_66: G = __r_arr[0]; if (__v_66 != __v_65) { return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: Some("aggr structural: assumption path does not reach right subject root".to_string()) }); } let __ret: [G; OUT_267] = [__v_65]; record.function_queries[267].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_63: G = G::from_u64(1); if (__v_56 != __v_63) { return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_63.as_canonical_u64(), msg: Some("aggr structural: right assumption must be discharged by left child".to_string()) }); } let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_58, __v_3]; 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_64: G = __r_arr[0]; if (__v_64 != __v_63) { return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_63.as_canonical_u64(), msg: Some("aggr structural: final step sibling is not right subject root".to_string()) }); } let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_54, __v_2]; 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_65: G = __r_arr[0]; if (__v_65 != __v_63) { return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_63.as_canonical_u64(), msg: Some("aggr structural: assumption path does not reach left subject root".to_string()) }); } let __ret: [G; OUT_267] = [__v_63]; record.function_queries[267].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_63: G = G::from_u64(0); let __v_64: G = G::from_u64(1); if (__v_63 != __v_64) { return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_64.as_canonical_u64(), msg: Some("aggr structural: shared assumption cannot be discharged".to_string()) }); } let __ret: [G; OUT_267] = [__v_63]; record.function_queries[267].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_268: usize = 5; -const IN_268: usize = 5; -const OUT_268: usize = 0; -fn aiur_fn_268(inp: [G; IN_268], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_268], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(263, &__args[..])?) { [G::ZERO; OUT_263] } else { let (__hash, __hit) = record.function_queries[263].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[263].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[263].bump_multiplicity(__i); } let __ret: [G; OUT_263] = unsafe { *(record.function_queries[263].output_at(__i).as_ptr() as *const [G; OUT_263]) }; __ret }, _ => { aiur_fn_263::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; let __v_8: G = __r_arr[3]; let __v_9: G = __r_arr[4]; 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_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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = G::from_u64(1); if (__v_10 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("aggr structural: output has an extra assumption".to_string()) }); } if (__v_11 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("aggr structural: output has an extra assumption".to_string()) }); } if (__v_12 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("aggr structural: output has an extra assumption".to_string()) }); } let __ret: [G; OUT_268] = []; record.function_queries[268].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_6, __v_7, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(267, &__args[..])?) { [G::ZERO; OUT_267] } else { let (__hash, __hit) = record.function_queries[267].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[267].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => { aiur_fn_267::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_8, __v_9, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(268, &__args[..])?) { [G::ZERO; OUT_268] } else { let (__hash, __hit) = record.function_queries[268].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[268].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[268].bump_multiplicity(__i); } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => { aiur_fn_268::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_268] = []; record.function_queries[268].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_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_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; match __v_11.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_12]; 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_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); if (__v_14 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("aggr structural: outstanding assumption mismatch".to_string()) }); } let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_8, __v_9, __v_2, __v_3, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(268, &__args[..])?) { [G::ZERO; OUT_268] } else { let (__hash, __hit) = record.function_queries[268].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[268].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[268].bump_multiplicity(__i); } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => { aiur_fn_268::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_268] = []; record.function_queries[268].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_269: usize = 1; -const IN_269: usize = 1; -const OUT_269: usize = 3; -fn aiur_fn_269(inp: [G; IN_269], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_269], ExecError> { stacker::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_90] = { let __args: [G; IN_90] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_269] = [__v_3, __v_3, __v_2]; record.function_queries[269].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); let __ret: [G; OUT_269] = [__v_5, __v_3, __v_4]; record.function_queries[269].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_270: usize = 1; -const IN_270: usize = 1; -const OUT_270: usize = 8; -fn aiur_fn_270(inp: [G; IN_270], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_270], ExecError> { stacker::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_90] = { let __args: [G; IN_90] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = G::from_u64(229); if (__v_1 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("aggr: claim is not CheckEnv".to_string()) }); } let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_2]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(4); if (__v_4 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("aggr: unsupported object format".to_string()) }); } let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_5]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(3); let __v_10: G = __v_7 - __v_9; let __v_11: G = __v_7 - __v_6; let __v_12: G = __v_10 * __v_11; let __v_13: G = G::from_u64(5); let __v_14: G = __v_7 - __v_13; let __v_15: G = __v_12 * __v_14; 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: Some("aggr: wrong validator identity".to_string()) }); } let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_8]; 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_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_18]; 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]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(269, &__args[..])?) { [G::ZERO; OUT_269] } else { let (__hash, __hit) = record.function_queries[269].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[269].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[269].bump_multiplicity(__i); } let __ret: [G; OUT_269] = unsafe { *(record.function_queries[269].output_at(__i).as_ptr() as *const [G; OUT_269]) }; __ret }, _ => { aiur_fn_269::(__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 __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(269, &__args[..])?) { [G::ZERO; OUT_269] } else { let (__hash, __hit) = record.function_queries[269].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[269].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[269].bump_multiplicity(__i); } let __ret: [G; OUT_269] = unsafe { *(record.function_queries[269].output_at(__i).as_ptr() as *const [G; OUT_269]) }; __ret }, _ => { aiur_fn_269::(__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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_29: G = __loaded[0]; let __v_30: G = __loaded[1]; let __v_31: G = __loaded[2]; let __v_32: G = G::from_u64(1); if (__v_29 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("aggr: trailing bytes after CheckEnv claim".to_string()) }); } if (__v_30 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("aggr: trailing bytes after CheckEnv claim".to_string()) }); } if (__v_31 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("aggr: trailing bytes after CheckEnv claim".to_string()) }); } let __ret: [G; OUT_270] = [__v_17, __v_19, __v_21, __v_22, __v_7, __v_24, __v_26, __v_27]; record.function_queries[270].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_271: usize = 1; -const IN_271: usize = 1; -const OUT_271: usize = 2; -fn aiur_fn_271(inp: [G; IN_271], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_271], ExecError> { stacker::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_90] = { let __args: [G; IN_90] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = G::from_u64(232); if (__v_1 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("aggr: claim is not Binding".to_string()) }); } let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_2]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(2); if (__v_4 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("aggr: claim is not Binding".to_string()) }); } let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_5]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(4); if (__v_7 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("aggr: unsupported object format".to_string()) }); } let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_8]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(3); if (__v_10 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("aggr: wrong validator identity".to_string()) }); } let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_11]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_14]; 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 __v_16: 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_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]; let __v_20: G = G::from_u64(1); if (__v_17 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("aggr: trailing bytes after Binding claim".to_string()) }); } if (__v_18 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("aggr: trailing bytes after Binding claim".to_string()) }); } if (__v_19 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("aggr: trailing bytes after Binding claim".to_string()) }); } let __ret: [G; OUT_271] = [__v_13, __v_15]; record.function_queries[271].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_272: usize = 1; -const IN_272: usize = 1; -const OUT_272: usize = 1; -fn aiur_fn_272(inp: [G; IN_272], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_272], ExecError> { stacker::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_90] = { let __args: [G; IN_90] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = G::from_u64(232); if (__v_1 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("aggr: claim is not Catalog".to_string()) }); } let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_2]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(0); if (__v_4 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("aggr: claim is not Catalog".to_string()) }); } let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_5]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(4); if (__v_7 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("aggr: unsupported object format".to_string()) }); } let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_8]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(3); if (__v_10 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("aggr: wrong validator identity".to_string()) }); } let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_11]; 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_13: G = __r_arr[0]; let __v_14: 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_14.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; let __v_18: G = G::from_u64(1); if (__v_15 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("aggr: trailing bytes after Catalog claim".to_string()) }); } if (__v_16 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("aggr: trailing bytes after Catalog claim".to_string()) }); } if (__v_17 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("aggr: trailing bytes after Catalog claim".to_string()) }); } let __ret: [G; OUT_272] = [__v_13]; record.function_queries[272].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_273: usize = 4; -const IN_273: usize = 4; -const OUT_273: usize = 1; -fn aiur_fn_273(inp: [G; IN_273], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_273], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_0.as_canonical_u64() { 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_273] = [__v_4]; record.function_queries[273].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_273] = [__v_4]; record.function_queries[273].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, 0u64 => { match __v_2.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_273] = [__v_4]; record.function_queries[273].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_273] = [__v_4]; record.function_queries[273].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_274: usize = 10; -const IN_274: usize = 10; -const OUT_274: usize = 0; -fn aiur_fn_274(inp: [G; IN_274], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_274], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); if (__v_10 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("aggr: claims differ in specification digest".to_string()) }); } let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_6]; 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_12: G = __r_arr[0]; if (__v_12 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("aggr: claims differ in binding hash".to_string()) }); } let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_2, __v_3, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(273, &__args[..])?) { [G::ZERO; OUT_273] } else { let (__hash, __hit) = record.function_queries[273].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[273].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[273].bump_multiplicity(__i); } let __ret: [G; OUT_273] = unsafe { *(record.function_queries[273].output_at(__i).as_ptr() as *const [G; OUT_273]) }; __ret }, _ => { aiur_fn_273::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; if (__v_13 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("aggr: claims differ in axioms".to_string()) }); } if (__v_4 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("aggr: claims differ in whether they assume their binding".to_string()) }); } let __ret: [G; OUT_274] = []; record.function_queries[274].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_275: usize = 8; -const IN_275: usize = 8; -const OUT_275: usize = 1; -fn aiur_fn_275(inp: [G; IN_275], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_275], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(4); let __io_pair: (G, G) = { let __key: [G; 8] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __info = io_buffer.get_info(__v_8, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_9: G = __io_pair.0; let __v_10: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_8, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(3, &__args[..])?) { [G::ZERO; OUT_3] } else { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[3].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[3].bump_multiplicity(__i); } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(103); let __v_13: G = G::from_u64(230); let __v_14: G = G::from_u64(9); let __v_15: G = G::from_u64(106); let __v_16: G = G::from_u64(133); let __v_17: G = G::from_u64(174); let __v_18: G = G::from_u64(187); let __v_19: G = G::from_u64(114); let __v_20: G = G::from_u64(243); let __v_21: G = G::from_u64(110); let __v_22: G = G::from_u64(60); let __v_23: G = G::from_u64(58); let __v_24: G = G::from_u64(245); let __v_25: G = G::from_u64(79); let __v_26: G = G::from_u64(165); let __v_27: G = G::from_u64(127); let __v_28: G = G::from_u64(82); let __v_29: G = G::from_u64(14); let __v_30: G = G::from_u64(81); let __v_31: G = G::from_u64(140); let __v_32: G = G::from_u64(104); let __v_33: G = G::from_u64(5); let __v_34: G = G::from_u64(155); let __v_35: G = G::from_u64(171); let __v_36: G = G::from_u64(217); let __v_37: G = G::from_u64(131); let __v_38: G = G::from_u64(31); let __v_39: G = G::from_u64(25); let __v_40: G = G::from_u64(205); let __v_41: G = G::from_u64(224); let __v_42: G = G::from_u64(91); let __v_43: G = G::from_u64(1); let __v_44: G = { let __values: [G; 3] = [__v_43, __v_43, __v_43]; 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_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 8] = [__v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45]; 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_47: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_12, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42]; let __mq = record.memory_queries.get_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_48: G = { let __values: [G; 34] = [__v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __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(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_78] = { let __args: [G; IN_78] = [__v_11, __v_44, __v_45, __v_45, __v_46, __v_47, __v_48]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_49]; 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_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 __v_61: G = __r_arr[11]; let __v_62: G = __r_arr[12]; let __v_63: G = __r_arr[13]; let __v_64: G = __r_arr[14]; let __v_65: G = __r_arr[15]; let __v_66: G = __r_arr[16]; let __v_67: G = __r_arr[17]; let __v_68: G = __r_arr[18]; let __v_69: G = __r_arr[19]; let __v_70: G = __r_arr[20]; let __v_71: G = __r_arr[21]; let __v_72: G = __r_arr[22]; let __v_73: G = __r_arr[23]; let __v_74: G = __r_arr[24]; let __v_75: G = __r_arr[25]; let __v_76: G = __r_arr[26]; let __v_77: G = __r_arr[27]; let __v_78: G = __r_arr[28]; let __v_79: G = __r_arr[29]; let __v_80: G = __r_arr[30]; let __v_81: G = __r_arr[31]; let __v_82: G = G::from_u64(256); let __v_83: G = __v_82 * __v_51; let __v_84: G = __v_50 + __v_83; let __v_85: G = G::from_u64(65536); let __v_86: G = __v_85 * __v_52; let __v_87: G = __v_84 + __v_86; let __v_88: G = G::from_u64(16777216); let __v_89: G = __v_88 * __v_53; let __v_90: G = __v_87 + __v_89; let __v_91: G = __v_82 * __v_55; let __v_92: G = __v_54 + __v_91; let __v_93: G = __v_85 * __v_56; let __v_94: G = __v_92 + __v_93; let __v_95: G = __v_88 * __v_57; let __v_96: G = __v_94 + __v_95; let __v_97: G = __v_82 * __v_59; let __v_98: G = __v_58 + __v_97; let __v_99: G = __v_85 * __v_60; let __v_100: G = __v_98 + __v_99; let __v_101: G = __v_88 * __v_61; let __v_102: G = __v_100 + __v_101; let __v_103: G = __v_82 * __v_63; let __v_104: G = __v_62 + __v_103; let __v_105: G = __v_85 * __v_64; let __v_106: G = __v_104 + __v_105; let __v_107: G = __v_88 * __v_65; let __v_108: G = __v_106 + __v_107; let __v_109: G = __v_82 * __v_67; let __v_110: G = __v_66 + __v_109; let __v_111: G = __v_85 * __v_68; let __v_112: G = __v_110 + __v_111; let __v_113: G = __v_88 * __v_69; let __v_114: G = __v_112 + __v_113; let __v_115: G = __v_82 * __v_71; let __v_116: G = __v_70 + __v_115; let __v_117: G = __v_85 * __v_72; let __v_118: G = __v_116 + __v_117; let __v_119: G = __v_88 * __v_73; let __v_120: G = __v_118 + __v_119; let __v_121: G = __v_82 * __v_75; let __v_122: G = __v_74 + __v_121; let __v_123: G = __v_85 * __v_76; let __v_124: G = __v_122 + __v_123; let __v_125: G = __v_88 * __v_77; let __v_126: G = __v_124 + __v_125; let __v_127: G = __v_82 * __v_79; let __v_128: G = __v_78 + __v_127; let __v_129: G = __v_85 * __v_80; let __v_130: G = __v_128 + __v_129; let __v_131: G = __v_88 * __v_81; let __v_132: G = __v_130 + __v_131; if (__v_90 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_96 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_102 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_108 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_108.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_114 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_114.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_120 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_120.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_126 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_126.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } if (__v_132 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_132.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } let __ret: [G; OUT_275] = [__v_11]; record.function_queries[275].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_276: usize = 2; -const IN_276: usize = 2; -const OUT_276: usize = 1; -fn aiur_fn_276(inp: [G; IN_276], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_276], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_328] = { let __args: [G; IN_328] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(328, &__args[..])?) { [G::ZERO; OUT_328] } else { let (__hash, __hit) = record.function_queries[328].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[328].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[328].bump_multiplicity(__i); } let __ret: [G; OUT_328] = unsafe { *(record.function_queries[328].output_at(__i).as_ptr() as *const [G; OUT_328]) }; __ret }, _ => { aiur_fn_328::(__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 = G::from_u64(256); let __v_11: G = __v_10 * __v_3; let __v_12: G = __v_2 + __v_11; let __v_13: G = G::from_u64(65536); let __v_14: G = __v_13 * __v_4; let __v_15: G = __v_12 + __v_14; let __v_16: G = G::from_u64(16777216); let __v_17: G = __v_16 * __v_5; let __v_18: G = __v_15 + __v_17; let __v_19: G = G::from_u64(4294967296); let __v_20: G = __v_19 * __v_6; let __v_21: G = __v_18 + __v_20; let __v_22: G = G::from_u64(1099511627776); let __v_23: G = __v_22 * __v_7; let __v_24: G = __v_21 + __v_23; let __v_25: G = G::from_u64(281474976710656); let __v_26: G = __v_25 * __v_8; let __v_27: G = __v_24 + __v_26; let __v_28: G = G::from_u64(72057594037927936); let __v_29: G = __v_28 * __v_9; let __v_30: G = __v_27 + __v_29; let __ret: [G; OUT_276] = [__v_30]; record.function_queries[276].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_277: usize = 2; -const IN_277: usize = 2; -const OUT_277: usize = 8; -fn aiur_fn_277(inp: [G; IN_277], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_277], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_276] = { let __args: [G; IN_276] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(276, &__args[..])?) { [G::ZERO; OUT_276] } else { let (__hash, __hit) = record.function_queries[276].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[276].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => { aiur_fn_276::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = __v_1 + __v_3; let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(276, &__args[..])?) { [G::ZERO; OUT_276] } else { let (__hash, __hit) = record.function_queries[276].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[276].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => { aiur_fn_276::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(2); let __v_7: G = __v_1 + __v_6; let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(276, &__args[..])?) { [G::ZERO; OUT_276] } else { let (__hash, __hit) = record.function_queries[276].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[276].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => { aiur_fn_276::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(3); let __v_10: G = __v_1 + __v_9; let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(276, &__args[..])?) { [G::ZERO; OUT_276] } else { let (__hash, __hit) = record.function_queries[276].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[276].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => { aiur_fn_276::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(4); let __v_13: G = __v_1 + __v_12; let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(276, &__args[..])?) { [G::ZERO; OUT_276] } else { let (__hash, __hit) = record.function_queries[276].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[276].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => { aiur_fn_276::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(5); let __v_16: G = __v_1 + __v_15; let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(276, &__args[..])?) { [G::ZERO; OUT_276] } else { let (__hash, __hit) = record.function_queries[276].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[276].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => { aiur_fn_276::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(6); let __v_19: G = __v_1 + __v_18; let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(276, &__args[..])?) { [G::ZERO; OUT_276] } else { let (__hash, __hit) = record.function_queries[276].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[276].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => { aiur_fn_276::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(7); let __v_22: G = __v_1 + __v_21; let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(276, &__args[..])?) { [G::ZERO; OUT_276] } else { let (__hash, __hit) = record.function_queries[276].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[276].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => { aiur_fn_276::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_277] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23]; record.function_queries[277].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_278: usize = 16; -const IN_278: usize = 16; -const OUT_278: usize = 0; -fn aiur_fn_278(inp: [G; IN_278], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_278], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; if (__v_0 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } if (__v_1 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None }); } if (__v_2 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None }); } if (__v_3 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None }); } if (__v_4 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); } if (__v_5 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None }); } if (__v_6 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); } if (__v_7 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_278] = []; record.function_queries[278].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_279: usize = 1; -const IN_279: usize = 1; -const OUT_279: usize = 1; -fn aiur_fn_279(inp: [G; IN_279], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_279], ExecError> { stacker::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]; let __v_7: G = G::from_u64(1); if (__v_4 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr: child proof must expose exactly one claim".to_string()) }); } if (__v_5 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr: child proof must expose exactly one claim".to_string()) }); } if (__v_6 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr: child proof must expose exactly one claim".to_string()) }); } let __ret: [G; OUT_279] = [__v_2]; record.function_queries[279].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_280: usize = 17; -const IN_280: usize = 17; -const OUT_280: usize = 12; -fn aiur_fn_280(inp: [G; IN_280], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_280], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(1); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_0]; let __info = io_buffer.get_info(__v_17, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_18: G = __io_pair.0; let __v_19: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(3, &__args[..])?) { [G::ZERO; OUT_3] } else { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[3].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[3].bump_multiplicity(__i); } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(103); let __v_22: G = G::from_u64(230); let __v_23: G = G::from_u64(9); let __v_24: G = G::from_u64(106); let __v_25: G = G::from_u64(133); let __v_26: G = G::from_u64(174); let __v_27: G = G::from_u64(187); let __v_28: G = G::from_u64(114); let __v_29: G = G::from_u64(243); let __v_30: G = G::from_u64(110); let __v_31: G = G::from_u64(60); let __v_32: G = G::from_u64(58); let __v_33: G = G::from_u64(245); let __v_34: G = G::from_u64(79); let __v_35: G = G::from_u64(165); let __v_36: G = G::from_u64(127); let __v_37: G = G::from_u64(82); let __v_38: G = G::from_u64(14); let __v_39: G = G::from_u64(81); let __v_40: G = G::from_u64(140); let __v_41: G = G::from_u64(104); let __v_42: G = G::from_u64(5); let __v_43: G = G::from_u64(155); let __v_44: G = G::from_u64(171); let __v_45: G = G::from_u64(217); let __v_46: G = G::from_u64(131); let __v_47: G = G::from_u64(31); let __v_48: G = G::from_u64(25); let __v_49: G = G::from_u64(205); let __v_50: G = G::from_u64(224); let __v_51: G = G::from_u64(91); let __v_52: G = { let __values: [G; 3] = [__v_17, __v_17, __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_53: G = G::from_u64(0); let __v_54: G = { let __values: [G; 8] = [__v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53]; 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_55: G = { let __values: [G; 32] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_21, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __mq = record.memory_queries.get_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_56: G = { let __values: [G; 34] = [__v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; 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_78] = { let __args: [G; IN_78] = [__v_20, __v_52, __v_53, __v_53, __v_54, __v_55, __v_56]; 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_57: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_57]; 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_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; let __v_61: G = __r_arr[3]; let __v_62: G = __r_arr[4]; let __v_63: G = __r_arr[5]; let __v_64: G = __r_arr[6]; let __v_65: G = __r_arr[7]; let __v_66: G = __r_arr[8]; let __v_67: G = __r_arr[9]; let __v_68: G = __r_arr[10]; let __v_69: G = __r_arr[11]; let __v_70: G = __r_arr[12]; let __v_71: G = __r_arr[13]; let __v_72: G = __r_arr[14]; let __v_73: G = __r_arr[15]; let __v_74: G = __r_arr[16]; let __v_75: G = __r_arr[17]; let __v_76: G = __r_arr[18]; let __v_77: G = __r_arr[19]; let __v_78: G = __r_arr[20]; let __v_79: G = __r_arr[21]; let __v_80: G = __r_arr[22]; let __v_81: G = __r_arr[23]; let __v_82: G = __r_arr[24]; let __v_83: G = __r_arr[25]; let __v_84: G = __r_arr[26]; let __v_85: G = __r_arr[27]; let __v_86: G = __r_arr[28]; let __v_87: G = __r_arr[29]; let __v_88: G = __r_arr[30]; let __v_89: G = __r_arr[31]; let __v_90: G = G::from_u64(256); let __v_91: G = __v_90 * __v_59; let __v_92: G = __v_58 + __v_91; let __v_93: G = G::from_u64(65536); let __v_94: G = __v_93 * __v_60; let __v_95: G = __v_92 + __v_94; let __v_96: G = G::from_u64(16777216); let __v_97: G = __v_96 * __v_61; let __v_98: G = __v_95 + __v_97; let __v_99: G = __v_90 * __v_63; let __v_100: G = __v_62 + __v_99; let __v_101: G = __v_93 * __v_64; let __v_102: G = __v_100 + __v_101; let __v_103: G = __v_96 * __v_65; let __v_104: G = __v_102 + __v_103; let __v_105: G = __v_90 * __v_67; let __v_106: G = __v_66 + __v_105; let __v_107: G = __v_93 * __v_68; let __v_108: G = __v_106 + __v_107; let __v_109: G = __v_96 * __v_69; let __v_110: G = __v_108 + __v_109; let __v_111: G = __v_90 * __v_71; let __v_112: G = __v_70 + __v_111; let __v_113: G = __v_93 * __v_72; let __v_114: G = __v_112 + __v_113; let __v_115: G = __v_96 * __v_73; let __v_116: G = __v_114 + __v_115; let __v_117: G = __v_90 * __v_75; let __v_118: G = __v_74 + __v_117; let __v_119: G = __v_93 * __v_76; let __v_120: G = __v_118 + __v_119; let __v_121: G = __v_96 * __v_77; let __v_122: G = __v_120 + __v_121; let __v_123: G = __v_90 * __v_79; let __v_124: G = __v_78 + __v_123; let __v_125: G = __v_93 * __v_80; let __v_126: G = __v_124 + __v_125; let __v_127: G = __v_96 * __v_81; let __v_128: G = __v_126 + __v_127; let __v_129: G = __v_90 * __v_83; let __v_130: G = __v_82 + __v_129; let __v_131: G = __v_93 * __v_84; let __v_132: G = __v_130 + __v_131; let __v_133: G = __v_96 * __v_85; let __v_134: G = __v_132 + __v_133; let __v_135: G = __v_90 * __v_87; let __v_136: G = __v_86 + __v_135; let __v_137: G = __v_93 * __v_88; let __v_138: G = __v_136 + __v_137; let __v_139: G = __v_96 * __v_89; let __v_140: G = __v_138 + __v_139; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_0.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_98, __v_104, __v_110, __v_116, __v_122, __v_128, __v_134, __v_140, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(278, &__args[..])?) { [G::ZERO; OUT_278] } else { let (__hash, __hit) = record.function_queries[278].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[278].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[278].bump_multiplicity(__i); } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => { aiur_fn_278::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, _ => { let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_98, __v_104, __v_110, __v_116, __v_122, __v_128, __v_134, __v_140, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(278, &__args[..])?) { [G::ZERO; OUT_278] } else { let (__hash, __hit) = record.function_queries[278].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[278].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[278].bump_multiplicity(__i); } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => { aiur_fn_278::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, } }; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_20]; 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_141: G = __r_arr[0]; let __v_142: G = __r_arr[1]; let __v_143: G = __r_arr[2]; let __v_144: G = __r_arr[3]; let __v_145: G = __r_arr[4]; let __v_146: G = __r_arr[5]; let __v_147: G = __r_arr[6]; let __v_148: G = __r_arr[7]; let __v_149: G = __r_arr[8]; let __v_150: G = __r_arr[9]; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_150]; 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_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 __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_160]; 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_161: G = __r_arr[0]; let __v_162: G = __r_arr[1]; let __v_163: G = __r_arr[2]; let __v_164: G = __r_arr[3]; let __v_165: G = __r_arr[4]; let __v_166: G = __r_arr[5]; let __v_167: G = __r_arr[6]; let __v_168: G = __r_arr[7]; let __v_169: G = __r_arr[8]; let __v_170: G = __r_arr[9]; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_170]; 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_171: G = __r_arr[0]; let __v_172: G = __r_arr[1]; let __v_173: G = __r_arr[2]; let __v_174: G = __r_arr[3]; let __v_175: G = __r_arr[4]; let __v_176: G = __r_arr[5]; let __v_177: G = __r_arr[6]; let __v_178: G = __r_arr[7]; let __v_179: G = __r_arr[8]; let __v_180: G = __r_arr[9]; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_180]; 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_181: G = __r_arr[0]; let __v_182: G = __r_arr[1]; let __v_183: G = __r_arr[2]; let __v_184: G = __r_arr[3]; let __v_185: G = __r_arr[4]; let __v_186: G = __r_arr[5]; let __v_187: G = __r_arr[6]; let __v_188: G = __r_arr[7]; let __v_189: G = __r_arr[8]; let __v_190: G = __r_arr[9]; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_190]; 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_191: G = __r_arr[0]; let __v_192: G = __r_arr[1]; let __v_193: G = __r_arr[2]; let __v_194: G = __r_arr[3]; let __v_195: G = __r_arr[4]; let __v_196: G = __r_arr[5]; let __v_197: G = __r_arr[6]; let __v_198: G = __r_arr[7]; let __v_199: G = __r_arr[8]; let __v_200: G = __r_arr[9]; let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_200]; 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_201: G = __r_arr[0]; let __v_202: G = __r_arr[1]; let __v_203: G = __r_arr[2]; let __v_204: G = __r_arr[3]; let __v_205: G = __r_arr[4]; let __v_206: G = __r_arr[5]; let __v_207: G = __r_arr[6]; let __v_208: G = __r_arr[7]; let __v_209: G = __r_arr[8]; let __v_210: G = __r_arr[9]; let __v_211: G = G::from_u64(0); let __v_212: G = G::from_u64(1); let __v_213: G = { let __values: [G; 10] = [__v_212, __v_212, __v_212, __v_212, __v_212, __v_212, __v_212, __v_212, __v_212, __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_211, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __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_211, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __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_211, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __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_211, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __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_211, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __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_211, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __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 __v_220: G = { let __values: [G; 10] = [__v_211, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_219]; 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_93] = { let __args: [G; IN_93] = [__v_210]; 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_221: G = __r_arr[0]; let __v_222: G = __r_arr[1]; let __v_223: G = __r_arr[2]; let __v_224: G = __r_arr[3]; let __v_225: G = __r_arr[4]; let __v_226: G = __r_arr[5]; let __v_227: G = __r_arr[6]; let __v_228: G = __r_arr[7]; let __v_229: G = __r_arr[8]; let __v_230: G = __r_arr[9]; let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_230, __v_221]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(106, &__args[..])?) { [G::ZERO; OUT_106] } else { let (__hash, __hit) = record.function_queries[106].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[106].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => { aiur_fn_106::(__args, __hash, record, io_buffer)? }, } } }; let __v_231: G = __r_arr[0]; let __v_232: G = __r_arr[1]; let __v_233: G = __r_arr[2]; let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_233]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(107, &__args[..])?) { [G::ZERO; OUT_107] } else { let (__hash, __hit) = record.function_queries[107].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[107].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[107].bump_multiplicity(__i); } let __ret: [G; OUT_107] = unsafe { *(record.function_queries[107].output_at(__i).as_ptr() as *const [G; OUT_107]) }; __ret }, _ => { aiur_fn_107::(__args, __hash, record, io_buffer)? }, } } }; let __v_234: G = __r_arr[0]; let __v_235: G = __r_arr[1]; let __v_236: G = __r_arr[2]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_236, __v_221]; 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_237: G = __r_arr[0]; let __v_238: G = __r_arr[1]; let __v_239: G = { let __values: [G; 10] = [__v_211, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_232]; 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_324] = { let __args: [G; IN_324] = [__v_220, __v_239]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(324, &__args[..])?) { [G::ZERO; OUT_324] } else { let (__hash, __hit) = record.function_queries[324].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[324].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => { aiur_fn_324::(__args, __hash, record, io_buffer)? }, } } }; let __v_240: 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_238.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_241: G = __loaded[0]; let __v_242: G = __loaded[1]; let __v_243: G = __loaded[2]; if (__v_241 != __v_212) { return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_212.as_canonical_u64(), msg: None }); } if (__v_242 != __v_212) { return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_212.as_canonical_u64(), msg: None }); } if (__v_243 != __v_212) { return Err(ExecError::AssertEqMismatch { lhs: __v_243.as_canonical_u64(), rhs: __v_212.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_280] = [__v_141, __v_151, __v_161, __v_171, __v_181, __v_191, __v_201, __v_240, __v_231, __v_234, __v_235, __v_237]; record.function_queries[280].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_281: usize = 13; -const IN_281: usize = 13; -const OUT_281: usize = 1; -fn aiur_fn_281(inp: [G; IN_281], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_281], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __io_pair: (G, G) = { let __key: [G; 1] = [__v_12]; let __info = io_buffer.get_info(__v_13, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_14: G = __io_pair.0; let __v_15: G = __io_pair.1; let __v_16: G = G::from_u64(2); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_12]; 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 __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_16, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(3, &__args[..])?) { [G::ZERO; OUT_3] } else { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[3].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[3].bump_multiplicity(__i); } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(28, &__args[..])?) { [G::ZERO; OUT_28] } else { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[28].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[28].bump_multiplicity(__i); } 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 __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_21, __v_20]; 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_22: G = __r_arr[0]; let __v_23: 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_23.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; let __v_25: G = __loaded[1]; let __v_26: G = __loaded[2]; let __v_27: G = G::from_u64(1); if (__v_24 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } if (__v_25 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } 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_31] = { let __args: [G; IN_31] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_29, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(65, &__args[..])?) { [G::ZERO; OUT_65] } else { let (__hash, __hit) = record.function_queries[65].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[65].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => { aiur_fn_65::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_33, __v_32]; 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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_37, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(70, &__args[..])?) { [G::ZERO; OUT_70] } else { let (__hash, __hit) = record.function_queries[70].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[70].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { *(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70]) }; __ret }, _ => { aiur_fn_70::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __v_14 + __v_15; if (__v_39 != __v_40) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_30, __v_34, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(238, &__args[..])?) { [G::ZERO; OUT_238] } else { let (__hash, __hit) = record.function_queries[238].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[238].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => { aiur_fn_238::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_41, __v_22]; 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_42: G = __r_arr[0]; if (__v_42 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } if (__v_27 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_281] = [__v_22]; record.function_queries[281].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_282: usize = 28; -const IN_282: usize = 28; -const OUT_282: usize = 8; -fn aiur_fn_282(inp: [G; IN_282], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_282], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(280, &__args[..])?) { [G::ZERO; OUT_280] } else { let (__hash, __hit) = record.function_queries[280].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[280].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[280].bump_multiplicity(__i); } let __ret: [G; OUT_280] = unsafe { *(record.function_queries[280].output_at(__i).as_ptr() as *const [G; OUT_280]) }; __ret }, _ => { aiur_fn_280::(__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 __v_39: G = __r_arr[11]; let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(281, &__args[..])?) { [G::ZERO; OUT_281] } else { let (__hash, __hit) = record.function_queries[281].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[281].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[281].bump_multiplicity(__i); } let __ret: [G; OUT_281] = unsafe { *(record.function_queries[281].output_at(__i).as_ptr() as *const [G; OUT_281]) }; __ret }, _ => { aiur_fn_281::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(279, &__args[..])?) { [G::ZERO; OUT_279] } else { let (__hash, __hit) = record.function_queries[279].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[279].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[279].bump_multiplicity(__i); } let __ret: [G; OUT_279] = unsafe { *(record.function_queries[279].output_at(__i).as_ptr() as *const [G; OUT_279]) }; __ret }, _ => { aiur_fn_279::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(0); let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_41, __v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(276, &__args[..])?) { [G::ZERO; OUT_276] } else { let (__hash, __hit) = record.function_queries[276].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[276].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => { aiur_fn_276::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; if (__v_43 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("aggr: child has the wrong claim channel".to_string()) }); } match __v_0.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(319, &__args[..])?) { [G::ZERO; OUT_319] } else { let (__hash, __hit) = record.function_queries[319].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[319].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[319].bump_multiplicity(__i); } let __ret: [G; OUT_319] = unsafe { *(record.function_queries[319].output_at(__i).as_ptr() as *const [G; OUT_319]) }; __ret }, _ => { aiur_fn_319::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(10); if (__v_44 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr: IxVM child must expose a 10-word verify_claim claim".to_string()) }); } let __v_46: G = G::from_u64(1); let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_41, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(276, &__args[..])?) { [G::ZERO; OUT_276] } else { let (__hash, __hit) = record.function_queries[276].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[276].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => { aiur_fn_276::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; if (__v_47 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("aggr: IxVM child has the wrong entrypoint".to_string()) }); } let __v_48: G = G::from_u64(2); let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_41, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(277, &__args[..])?) { [G::ZERO; OUT_277] } else { let (__hash, __hit) = record.function_queries[277].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[277].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => { aiur_fn_277::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; let __v_52: G = __r_arr[3]; let __v_53: G = __r_arr[4]; let __v_54: G = __r_arr[5]; let __v_55: G = __r_arr[6]; let __v_56: G = __r_arr[7]; let __ret: [G; OUT_282] = [__v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; record.function_queries[282].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(319, &__args[..])?) { [G::ZERO; OUT_319] } else { let (__hash, __hit) = record.function_queries[319].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[319].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[319].bump_multiplicity(__i); } let __ret: [G; OUT_319] = unsafe { *(record.function_queries[319].output_at(__i).as_ptr() as *const [G; OUT_319]) }; __ret }, _ => { aiur_fn_319::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(18); if (__v_44 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr: recursive child must expose an 18-word ix_aggr claim".to_string()) }); } let __v_46: G = G::from_u64(1); let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_41, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(276, &__args[..])?) { [G::ZERO; OUT_276] } else { let (__hash, __hit) = record.function_queries[276].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[276].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => { aiur_fn_276::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; if (__v_47 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("aggr: recursive child has the wrong entrypoint".to_string()) }); } let __v_48: G = G::from_u64(2); let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_41, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(277, &__args[..])?) { [G::ZERO; OUT_277] } else { let (__hash, __hit) = record.function_queries[277].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[277].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => { aiur_fn_277::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; let __v_52: G = __r_arr[3]; let __v_53: G = __r_arr[4]; let __v_54: G = __r_arr[5]; let __v_55: G = __r_arr[6]; let __v_56: G = __r_arr[7]; let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(278, &__args[..])?) { [G::ZERO; OUT_278] } else { let (__hash, __hit) = record.function_queries[278].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[278].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[278].bump_multiplicity(__i); } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => { aiur_fn_278::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = G::from_u64(10); let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_41, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(277, &__args[..])?) { [G::ZERO; OUT_277] } else { let (__hash, __hit) = record.function_queries[277].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[277].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => { aiur_fn_277::(__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 = __r_arr[4]; let __v_63: G = __r_arr[5]; let __v_64: G = __r_arr[6]; let __v_65: G = __r_arr[7]; let __ret: [G; OUT_282] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; record.function_queries[282].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_283: usize = 35; -const IN_283: usize = 35; -const OUT_283: usize = 0; -fn aiur_fn_283(inp: [G; IN_283], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_283], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(0); let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0, __v_35, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(282, &__args[..])?) { [G::ZERO; OUT_282] } else { let (__hash, __hit) = record.function_queries[282].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[282].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => { aiur_fn_282::(__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 __v_39: G = __r_arr[3]; let __v_40: G = __r_arr[4]; let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(278, &__args[..])?) { [G::ZERO; OUT_278] } else { let (__hash, __hit) = record.function_queries[278].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[278].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[278].bump_multiplicity(__i); } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => { aiur_fn_278::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_283] = []; record.function_queries[283].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_284: usize = 36; -const IN_284: usize = 36; -const OUT_284: usize = 0; -fn aiur_fn_284(inp: [G; IN_284], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_284], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(0); let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0, __v_36, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(282, &__args[..])?) { [G::ZERO; OUT_282] } else { let (__hash, __hit) = record.function_queries[282].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[282].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => { aiur_fn_282::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; let __v_40: G = __r_arr[3]; let __v_41: G = __r_arr[4]; let __v_42: G = __r_arr[5]; let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; let __v_45: G = G::from_u64(1); let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_1, __v_45, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(282, &__args[..])?) { [G::ZERO; OUT_282] } else { let (__hash, __hit) = record.function_queries[282].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[282].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => { aiur_fn_282::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = __r_arr[2]; let __v_49: G = __r_arr[3]; let __v_50: G = __r_arr[4]; let __v_51: G = __r_arr[5]; let __v_52: G = __r_arr[6]; let __v_53: G = __r_arr[7]; let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(275, &__args[..])?) { [G::ZERO; OUT_275] } else { let (__hash, __hit) = record.function_queries[275].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[275].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => { aiur_fn_275::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_54]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(270, &__args[..])?) { [G::ZERO; OUT_270] } else { let (__hash, __hit) = record.function_queries[270].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[270].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => { aiur_fn_270::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; let __v_58: G = __r_arr[3]; let __v_59: G = __r_arr[4]; let __v_60: G = __r_arr[5]; let __v_61: G = __r_arr[6]; let __v_62: G = __r_arr[7]; let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(275, &__args[..])?) { [G::ZERO; OUT_275] } else { let (__hash, __hit) = record.function_queries[275].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[275].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => { aiur_fn_275::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(270, &__args[..])?) { [G::ZERO; OUT_270] } else { let (__hash, __hit) = record.function_queries[270].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[270].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => { aiur_fn_270::(__args, __hash, record, io_buffer)? }, } } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; let __v_67: G = __r_arr[3]; let __v_68: G = __r_arr[4]; let __v_69: G = __r_arr[5]; let __v_70: G = __r_arr[6]; let __v_71: G = __r_arr[7]; let __v_72: G = G::from_u64(2); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_72]; let __info = io_buffer.get_info(__v_72, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_73: G = __io_pair.0; let __v_74: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_72, __v_73, __v_74]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(3, &__args[..])?) { [G::ZERO; OUT_3] } else { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[3].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[3].bump_multiplicity(__i); } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __v_76: G = G::from_u64(103); let __v_77: G = G::from_u64(230); let __v_78: G = G::from_u64(9); let __v_79: G = G::from_u64(106); let __v_80: G = G::from_u64(133); let __v_81: G = G::from_u64(174); let __v_82: G = G::from_u64(187); let __v_83: G = G::from_u64(114); let __v_84: G = G::from_u64(243); let __v_85: G = G::from_u64(110); let __v_86: G = G::from_u64(60); let __v_87: G = G::from_u64(58); let __v_88: G = G::from_u64(245); let __v_89: G = G::from_u64(79); let __v_90: G = G::from_u64(165); let __v_91: G = G::from_u64(127); let __v_92: G = G::from_u64(82); let __v_93: G = G::from_u64(14); let __v_94: G = G::from_u64(81); let __v_95: G = G::from_u64(140); let __v_96: G = G::from_u64(104); let __v_97: G = G::from_u64(5); let __v_98: G = G::from_u64(155); let __v_99: G = G::from_u64(171); let __v_100: G = G::from_u64(217); let __v_101: G = G::from_u64(131); let __v_102: G = G::from_u64(31); let __v_103: G = G::from_u64(25); let __v_104: G = G::from_u64(205); let __v_105: G = G::from_u64(224); let __v_106: G = G::from_u64(91); let __v_107: 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 __v_108: G = { let __values: [G; 8] = [__v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; 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_109: G = { let __values: [G; 32] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_76, __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(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_110: G = { let __values: [G; 34] = [__v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45]; 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_78] = { let __args: [G; IN_78] = [__v_75, __v_107, __v_36, __v_36, __v_108, __v_109, __v_110]; 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_111: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_111]; 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_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 = __r_arr[4]; let __v_117: G = __r_arr[5]; let __v_118: G = __r_arr[6]; let __v_119: G = __r_arr[7]; let __v_120: G = __r_arr[8]; let __v_121: G = __r_arr[9]; let __v_122: G = __r_arr[10]; let __v_123: G = __r_arr[11]; let __v_124: G = __r_arr[12]; let __v_125: G = __r_arr[13]; let __v_126: G = __r_arr[14]; let __v_127: G = __r_arr[15]; let __v_128: G = __r_arr[16]; let __v_129: G = __r_arr[17]; let __v_130: G = __r_arr[18]; let __v_131: G = __r_arr[19]; let __v_132: G = __r_arr[20]; let __v_133: G = __r_arr[21]; let __v_134: G = __r_arr[22]; let __v_135: G = __r_arr[23]; let __v_136: G = __r_arr[24]; let __v_137: G = __r_arr[25]; let __v_138: G = __r_arr[26]; let __v_139: G = __r_arr[27]; let __v_140: G = __r_arr[28]; let __v_141: G = __r_arr[29]; let __v_142: G = __r_arr[30]; let __v_143: G = __r_arr[31]; let __v_144: G = G::from_u64(256); let __v_145: G = __v_144 * __v_113; let __v_146: G = __v_112 + __v_145; let __v_147: G = G::from_u64(65536); let __v_148: G = __v_147 * __v_114; let __v_149: G = __v_146 + __v_148; let __v_150: G = G::from_u64(16777216); let __v_151: G = __v_150 * __v_115; let __v_152: G = __v_149 + __v_151; let __v_153: G = __v_144 * __v_117; let __v_154: G = __v_116 + __v_153; let __v_155: G = __v_147 * __v_118; let __v_156: G = __v_154 + __v_155; let __v_157: G = __v_150 * __v_119; let __v_158: G = __v_156 + __v_157; let __v_159: G = __v_144 * __v_121; let __v_160: G = __v_120 + __v_159; let __v_161: G = __v_147 * __v_122; let __v_162: G = __v_160 + __v_161; let __v_163: G = __v_150 * __v_123; let __v_164: G = __v_162 + __v_163; let __v_165: G = __v_144 * __v_125; let __v_166: G = __v_124 + __v_165; let __v_167: G = __v_147 * __v_126; let __v_168: G = __v_166 + __v_167; let __v_169: G = __v_150 * __v_127; let __v_170: G = __v_168 + __v_169; let __v_171: G = __v_144 * __v_129; let __v_172: G = __v_128 + __v_171; let __v_173: G = __v_147 * __v_130; let __v_174: G = __v_172 + __v_173; let __v_175: G = __v_150 * __v_131; let __v_176: G = __v_174 + __v_175; let __v_177: G = __v_144 * __v_133; let __v_178: G = __v_132 + __v_177; let __v_179: G = __v_147 * __v_134; let __v_180: G = __v_178 + __v_179; let __v_181: G = __v_150 * __v_135; let __v_182: G = __v_180 + __v_181; let __v_183: G = __v_144 * __v_137; let __v_184: G = __v_136 + __v_183; let __v_185: G = __v_147 * __v_138; let __v_186: G = __v_184 + __v_185; let __v_187: G = __v_150 * __v_139; let __v_188: G = __v_186 + __v_187; let __v_189: G = __v_144 * __v_141; let __v_190: G = __v_140 + __v_189; let __v_191: G = __v_147 * __v_142; let __v_192: G = __v_190 + __v_191; let __v_193: G = __v_150 * __v_143; let __v_194: G = __v_192 + __v_193; if (__v_152 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_152.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_158 != __v_29) { return Err(ExecError::AssertEqMismatch { lhs: __v_158.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_164 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_164.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_170 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_170.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_176 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_176.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_182 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_182.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_188 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_188.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } if (__v_194 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_194.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(270, &__args[..])?) { [G::ZERO; OUT_270] } else { let (__hash, __hit) = record.function_queries[270].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[270].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => { aiur_fn_270::(__args, __hash, record, io_buffer)? }, } } }; let __v_195: G = __r_arr[0]; let __v_196: G = __r_arr[1]; let __v_197: G = __r_arr[2]; let __v_198: G = __r_arr[3]; let __v_199: G = __r_arr[4]; let __v_200: G = __r_arr[5]; let __v_201: G = __r_arr[6]; let __v_202: G = __r_arr[7]; let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(274, &__args[..])?) { [G::ZERO; OUT_274] } else { let (__hash, __hit) = record.function_queries[274].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[274].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => { aiur_fn_274::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_195, __v_196, __v_197, __v_198, __v_199]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(274, &__args[..])?) { [G::ZERO; OUT_274] } else { let (__hash, __hit) = record.function_queries[274].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[274].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => { aiur_fn_274::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, &__args[..])?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => { aiur_fn_257::(__args, __hash, record, io_buffer)? }, } } }; let __v_203: G = __r_arr[0]; let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_69]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, &__args[..])?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => { aiur_fn_257::(__args, __hash, record, io_buffer)? }, } } }; let __v_204: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_61, __v_62]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(258, &__args[..])?) { [G::ZERO; OUT_258] } else { let (__hash, __hit) = record.function_queries[258].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[258].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => { aiur_fn_258::(__args, __hash, record, io_buffer)? }, } } }; let __v_205: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_70, __v_71]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(258, &__args[..])?) { [G::ZERO; OUT_258] } else { let (__hash, __hit) = record.function_queries[258].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[258].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => { aiur_fn_258::(__args, __hash, record, io_buffer)? }, } } }; let __v_206: G = __r_arr[0]; let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_200]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, &__args[..])?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => { aiur_fn_257::(__args, __hash, record, io_buffer)? }, } } }; let __v_207: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_201, __v_202]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(258, &__args[..])?) { [G::ZERO; OUT_258] } else { let (__hash, __hit) = record.function_queries[258].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[258].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => { aiur_fn_258::(__args, __hash, record, io_buffer)? }, } } }; let __v_208: G = __r_arr[0]; let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_203, __v_205]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(262, &__args[..])?) { [G::ZERO; OUT_262] } else { let (__hash, __hit) = record.function_queries[262].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[262].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[262].bump_multiplicity(__i); } let __ret: [G; OUT_262] = unsafe { *(record.function_queries[262].output_at(__i).as_ptr() as *const [G; OUT_262]) }; __ret }, _ => { aiur_fn_262::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_204, __v_206]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(262, &__args[..])?) { [G::ZERO; OUT_262] } else { let (__hash, __hit) = record.function_queries[262].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[262].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[262].bump_multiplicity(__i); } let __ret: [G; OUT_262] = unsafe { *(record.function_queries[262].output_at(__i).as_ptr() as *const [G; OUT_262]) }; __ret }, _ => { aiur_fn_262::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_203, __v_204, __v_207]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(261, &__args[..])?) { [G::ZERO; OUT_261] } else { let (__hash, __hit) = record.function_queries[261].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[261].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[261].bump_multiplicity(__i); } let __ret: [G; OUT_261] = unsafe { *(record.function_queries[261].output_at(__i).as_ptr() as *const [G; OUT_261]) }; __ret }, _ => { aiur_fn_261::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_205, __v_206, __v_207, __v_208]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(265, &__args[..])?) { [G::ZERO; OUT_265] } else { let (__hash, __hit) = record.function_queries[265].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[265].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[265].bump_multiplicity(__i); } let __ret: [G; OUT_265] = unsafe { *(record.function_queries[265].output_at(__i).as_ptr() as *const [G; OUT_265]) }; __ret }, _ => { aiur_fn_265::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_284] = []; record.function_queries[284].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_285: usize = 36; -const IN_285: usize = 36; -const OUT_285: usize = 0; -fn aiur_fn_285(inp: [G; IN_285], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_285], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(0); let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0, __v_36, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(282, &__args[..])?) { [G::ZERO; OUT_282] } else { let (__hash, __hit) = record.function_queries[282].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[282].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => { aiur_fn_282::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; let __v_40: G = __r_arr[3]; let __v_41: G = __r_arr[4]; let __v_42: G = __r_arr[5]; let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; let __v_45: G = G::from_u64(1); let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_1, __v_45, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(282, &__args[..])?) { [G::ZERO; OUT_282] } else { let (__hash, __hit) = record.function_queries[282].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[282].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => { aiur_fn_282::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = __r_arr[2]; let __v_49: G = __r_arr[3]; let __v_50: G = __r_arr[4]; let __v_51: G = __r_arr[5]; let __v_52: G = __r_arr[6]; let __v_53: G = __r_arr[7]; let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(275, &__args[..])?) { [G::ZERO; OUT_275] } else { let (__hash, __hit) = record.function_queries[275].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[275].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => { aiur_fn_275::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_54]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(270, &__args[..])?) { [G::ZERO; OUT_270] } else { let (__hash, __hit) = record.function_queries[270].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[270].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => { aiur_fn_270::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; let __v_58: G = __r_arr[3]; let __v_59: G = __r_arr[4]; let __v_60: G = __r_arr[5]; let __v_61: G = __r_arr[6]; let __v_62: G = __r_arr[7]; let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(275, &__args[..])?) { [G::ZERO; OUT_275] } else { let (__hash, __hit) = record.function_queries[275].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[275].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => { aiur_fn_275::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(270, &__args[..])?) { [G::ZERO; OUT_270] } else { let (__hash, __hit) = record.function_queries[270].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[270].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => { aiur_fn_270::(__args, __hash, record, io_buffer)? }, } } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; let __v_67: G = __r_arr[3]; let __v_68: G = __r_arr[4]; let __v_69: G = __r_arr[5]; let __v_70: G = __r_arr[6]; let __v_71: G = __r_arr[7]; let __v_72: G = G::from_u64(2); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_72]; let __info = io_buffer.get_info(__v_72, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_73: G = __io_pair.0; let __v_74: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_72, __v_73, __v_74]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(3, &__args[..])?) { [G::ZERO; OUT_3] } else { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[3].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[3].bump_multiplicity(__i); } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __v_76: G = G::from_u64(103); let __v_77: G = G::from_u64(230); let __v_78: G = G::from_u64(9); let __v_79: G = G::from_u64(106); let __v_80: G = G::from_u64(133); let __v_81: G = G::from_u64(174); let __v_82: G = G::from_u64(187); let __v_83: G = G::from_u64(114); let __v_84: G = G::from_u64(243); let __v_85: G = G::from_u64(110); let __v_86: G = G::from_u64(60); let __v_87: G = G::from_u64(58); let __v_88: G = G::from_u64(245); let __v_89: G = G::from_u64(79); let __v_90: G = G::from_u64(165); let __v_91: G = G::from_u64(127); let __v_92: G = G::from_u64(82); let __v_93: G = G::from_u64(14); let __v_94: G = G::from_u64(81); let __v_95: G = G::from_u64(140); let __v_96: G = G::from_u64(104); let __v_97: G = G::from_u64(5); let __v_98: G = G::from_u64(155); let __v_99: G = G::from_u64(171); let __v_100: G = G::from_u64(217); let __v_101: G = G::from_u64(131); let __v_102: G = G::from_u64(31); let __v_103: G = G::from_u64(25); let __v_104: G = G::from_u64(205); let __v_105: G = G::from_u64(224); let __v_106: G = G::from_u64(91); let __v_107: 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 __v_108: G = { let __values: [G; 8] = [__v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; 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_109: G = { let __values: [G; 32] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_76, __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(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_110: G = { let __values: [G; 34] = [__v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45]; 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_78] = { let __args: [G; IN_78] = [__v_75, __v_107, __v_36, __v_36, __v_108, __v_109, __v_110]; 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_111: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_111]; 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_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 = __r_arr[4]; let __v_117: G = __r_arr[5]; let __v_118: G = __r_arr[6]; let __v_119: G = __r_arr[7]; let __v_120: G = __r_arr[8]; let __v_121: G = __r_arr[9]; let __v_122: G = __r_arr[10]; let __v_123: G = __r_arr[11]; let __v_124: G = __r_arr[12]; let __v_125: G = __r_arr[13]; let __v_126: G = __r_arr[14]; let __v_127: G = __r_arr[15]; let __v_128: G = __r_arr[16]; let __v_129: G = __r_arr[17]; let __v_130: G = __r_arr[18]; let __v_131: G = __r_arr[19]; let __v_132: G = __r_arr[20]; let __v_133: G = __r_arr[21]; let __v_134: G = __r_arr[22]; let __v_135: G = __r_arr[23]; let __v_136: G = __r_arr[24]; let __v_137: G = __r_arr[25]; let __v_138: G = __r_arr[26]; let __v_139: G = __r_arr[27]; let __v_140: G = __r_arr[28]; let __v_141: G = __r_arr[29]; let __v_142: G = __r_arr[30]; let __v_143: G = __r_arr[31]; let __v_144: G = G::from_u64(256); let __v_145: G = __v_144 * __v_113; let __v_146: G = __v_112 + __v_145; let __v_147: G = G::from_u64(65536); let __v_148: G = __v_147 * __v_114; let __v_149: G = __v_146 + __v_148; let __v_150: G = G::from_u64(16777216); let __v_151: G = __v_150 * __v_115; let __v_152: G = __v_149 + __v_151; let __v_153: G = __v_144 * __v_117; let __v_154: G = __v_116 + __v_153; let __v_155: G = __v_147 * __v_118; let __v_156: G = __v_154 + __v_155; let __v_157: G = __v_150 * __v_119; let __v_158: G = __v_156 + __v_157; let __v_159: G = __v_144 * __v_121; let __v_160: G = __v_120 + __v_159; let __v_161: G = __v_147 * __v_122; let __v_162: G = __v_160 + __v_161; let __v_163: G = __v_150 * __v_123; let __v_164: G = __v_162 + __v_163; let __v_165: G = __v_144 * __v_125; let __v_166: G = __v_124 + __v_165; let __v_167: G = __v_147 * __v_126; let __v_168: G = __v_166 + __v_167; let __v_169: G = __v_150 * __v_127; let __v_170: G = __v_168 + __v_169; let __v_171: G = __v_144 * __v_129; let __v_172: G = __v_128 + __v_171; let __v_173: G = __v_147 * __v_130; let __v_174: G = __v_172 + __v_173; let __v_175: G = __v_150 * __v_131; let __v_176: G = __v_174 + __v_175; let __v_177: G = __v_144 * __v_133; let __v_178: G = __v_132 + __v_177; let __v_179: G = __v_147 * __v_134; let __v_180: G = __v_178 + __v_179; let __v_181: G = __v_150 * __v_135; let __v_182: G = __v_180 + __v_181; let __v_183: G = __v_144 * __v_137; let __v_184: G = __v_136 + __v_183; let __v_185: G = __v_147 * __v_138; let __v_186: G = __v_184 + __v_185; let __v_187: G = __v_150 * __v_139; let __v_188: G = __v_186 + __v_187; let __v_189: G = __v_144 * __v_141; let __v_190: G = __v_140 + __v_189; let __v_191: G = __v_147 * __v_142; let __v_192: G = __v_190 + __v_191; let __v_193: G = __v_150 * __v_143; let __v_194: G = __v_192 + __v_193; if (__v_152 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_152.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_158 != __v_29) { return Err(ExecError::AssertEqMismatch { lhs: __v_158.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_164 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_164.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_170 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_170.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_176 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_176.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_182 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_182.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_188 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_188.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } if (__v_194 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_194.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(270, &__args[..])?) { [G::ZERO; OUT_270] } else { let (__hash, __hit) = record.function_queries[270].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[270].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => { aiur_fn_270::(__args, __hash, record, io_buffer)? }, } } }; let __v_195: G = __r_arr[0]; let __v_196: G = __r_arr[1]; let __v_197: G = __r_arr[2]; let __v_198: G = __r_arr[3]; let __v_199: G = __r_arr[4]; let __v_200: G = __r_arr[5]; let __v_201: G = __r_arr[6]; let __v_202: G = __r_arr[7]; let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(274, &__args[..])?) { [G::ZERO; OUT_274] } else { let (__hash, __hit) = record.function_queries[274].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[274].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => { aiur_fn_274::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_195, __v_196, __v_197, __v_198, __v_199]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(274, &__args[..])?) { [G::ZERO; OUT_274] } else { let (__hash, __hit) = record.function_queries[274].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[274].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => { aiur_fn_274::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_60, __v_69]; 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_203: G = __r_arr[0]; if (__v_203 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_203.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: Some("aggr structural: child subject roots must be distinct".to_string()) }); } let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_60, __v_69]; 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_204: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_200, __v_204]; 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_205: G = __r_arr[0]; if (__v_205 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_205.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("aggr structural: output subject root is not nodeHash(left, right)".to_string()) }); } let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_61, __v_62]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(258, &__args[..])?) { [G::ZERO; OUT_258] } else { let (__hash, __hit) = record.function_queries[258].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[258].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => { aiur_fn_258::(__args, __hash, record, io_buffer)? }, } } }; let __v_206: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_70, __v_71]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(258, &__args[..])?) { [G::ZERO; OUT_258] } else { let (__hash, __hit) = record.function_queries[258].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[258].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => { aiur_fn_258::(__args, __hash, record, io_buffer)? }, } } }; let __v_207: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_201, __v_202]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(258, &__args[..])?) { [G::ZERO; OUT_258] } else { let (__hash, __hit) = record.function_queries[258].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[258].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => { aiur_fn_258::(__args, __hash, record, io_buffer)? }, } } }; let __v_208: G = __r_arr[0]; let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_206, __v_207, __v_60, __v_69, __v_208]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(268, &__args[..])?) { [G::ZERO; OUT_268] } else { let (__hash, __hit) = record.function_queries[268].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[268].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[268].bump_multiplicity(__i); } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => { aiur_fn_268::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_285] = []; record.function_queries[285].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_286: usize = 35; -const IN_286: usize = 35; -const OUT_286: usize = 0; -fn aiur_fn_286(inp: [G; IN_286], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_286], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(0); let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0, __v_35, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(282, &__args[..])?) { [G::ZERO; OUT_282] } else { let (__hash, __hit) = record.function_queries[282].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[282].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => { aiur_fn_282::(__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 __v_39: G = __r_arr[3]; let __v_40: G = __r_arr[4]; let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; let __v_44: G = G::from_u64(1); let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_35, __v_44, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(282, &__args[..])?) { [G::ZERO; OUT_282] } else { let (__hash, __hit) = record.function_queries[282].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[282].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => { aiur_fn_282::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __v_47: G = __r_arr[2]; let __v_48: G = __r_arr[3]; let __v_49: G = __r_arr[4]; let __v_50: G = __r_arr[5]; let __v_51: G = __r_arr[6]; let __v_52: G = __r_arr[7]; let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(275, &__args[..])?) { [G::ZERO; OUT_275] } else { let (__hash, __hit) = record.function_queries[275].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[275].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => { aiur_fn_275::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(270, &__args[..])?) { [G::ZERO; OUT_270] } else { let (__hash, __hit) = record.function_queries[270].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[270].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => { aiur_fn_270::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; let __v_57: G = __r_arr[3]; let __v_58: G = __r_arr[4]; let __v_59: G = __r_arr[5]; let __v_60: G = __r_arr[6]; let __v_61: G = __r_arr[7]; let __v_62: G = G::from_u64(4); if (__v_58 != __v_62) { return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_62.as_canonical_u64(), msg: Some("aggr discharge: the claim does not assume its binding".to_string()) }); } let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(275, &__args[..])?) { [G::ZERO; OUT_275] } else { let (__hash, __hit) = record.function_queries[275].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[275].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => { aiur_fn_275::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(271, &__args[..])?) { [G::ZERO; OUT_271] } else { let (__hash, __hit) = record.function_queries[271].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[271].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[271].bump_multiplicity(__i); } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => { aiur_fn_271::(__args, __hash, record, io_buffer)? }, } } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_54, __v_64]; 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_66: G = __r_arr[0]; if (__v_66 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("aggr discharge: the binding claim is for another specification digest".to_string()) }); } let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_55, __v_65]; 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_67: G = __r_arr[0]; if (__v_67 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("aggr discharge: the binding claim is for another binding".to_string()) }); } let __v_68: G = G::from_u64(2); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_68]; let __info = io_buffer.get_info(__v_68, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_69: G = __io_pair.0; let __v_70: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_68, __v_69, __v_70]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(3, &__args[..])?) { [G::ZERO; OUT_3] } else { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[3].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[3].bump_multiplicity(__i); } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_71: G = __r_arr[0]; let __v_72: G = G::from_u64(103); let __v_73: G = G::from_u64(230); let __v_74: G = G::from_u64(9); let __v_75: G = G::from_u64(106); let __v_76: G = G::from_u64(133); let __v_77: G = G::from_u64(174); let __v_78: G = G::from_u64(187); let __v_79: G = G::from_u64(114); let __v_80: G = G::from_u64(243); let __v_81: G = G::from_u64(110); let __v_82: G = G::from_u64(60); let __v_83: G = G::from_u64(58); let __v_84: G = G::from_u64(245); let __v_85: G = G::from_u64(79); let __v_86: G = G::from_u64(165); let __v_87: G = G::from_u64(127); let __v_88: G = G::from_u64(82); let __v_89: G = G::from_u64(14); let __v_90: G = G::from_u64(81); let __v_91: G = G::from_u64(140); let __v_92: G = G::from_u64(104); let __v_93: G = G::from_u64(5); let __v_94: G = G::from_u64(155); let __v_95: G = G::from_u64(171); let __v_96: G = G::from_u64(217); let __v_97: G = G::from_u64(131); let __v_98: G = G::from_u64(31); let __v_99: G = G::from_u64(25); let __v_100: G = G::from_u64(205); let __v_101: G = G::from_u64(224); let __v_102: G = G::from_u64(91); let __v_103: 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 __v_104: G = { let __values: [G; 8] = [__v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35]; 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_105: G = { let __values: [G; 32] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_72, __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(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_106: G = { let __values: [G; 34] = [__v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44]; let __mq = record.memory_queries.get_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_78] = { let __args: [G; IN_78] = [__v_71, __v_103, __v_35, __v_35, __v_104, __v_105, __v_106]; 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_107: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_107]; 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_108: G = __r_arr[0]; let __v_109: G = __r_arr[1]; let __v_110: G = __r_arr[2]; let __v_111: G = __r_arr[3]; let __v_112: G = __r_arr[4]; let __v_113: G = __r_arr[5]; let __v_114: G = __r_arr[6]; let __v_115: G = __r_arr[7]; let __v_116: G = __r_arr[8]; let __v_117: G = __r_arr[9]; let __v_118: G = __r_arr[10]; let __v_119: G = __r_arr[11]; let __v_120: G = __r_arr[12]; let __v_121: G = __r_arr[13]; let __v_122: G = __r_arr[14]; let __v_123: G = __r_arr[15]; let __v_124: G = __r_arr[16]; let __v_125: G = __r_arr[17]; let __v_126: G = __r_arr[18]; let __v_127: G = __r_arr[19]; let __v_128: G = __r_arr[20]; let __v_129: G = __r_arr[21]; let __v_130: G = __r_arr[22]; let __v_131: G = __r_arr[23]; let __v_132: G = __r_arr[24]; let __v_133: G = __r_arr[25]; let __v_134: G = __r_arr[26]; let __v_135: G = __r_arr[27]; let __v_136: G = __r_arr[28]; let __v_137: G = __r_arr[29]; let __v_138: G = __r_arr[30]; let __v_139: G = __r_arr[31]; let __v_140: G = G::from_u64(256); let __v_141: G = __v_140 * __v_109; let __v_142: G = __v_108 + __v_141; let __v_143: G = G::from_u64(65536); let __v_144: G = __v_143 * __v_110; let __v_145: G = __v_142 + __v_144; let __v_146: G = G::from_u64(16777216); let __v_147: G = __v_146 * __v_111; let __v_148: G = __v_145 + __v_147; let __v_149: G = __v_140 * __v_113; let __v_150: G = __v_112 + __v_149; let __v_151: G = __v_143 * __v_114; let __v_152: G = __v_150 + __v_151; let __v_153: G = __v_146 * __v_115; let __v_154: G = __v_152 + __v_153; let __v_155: G = __v_140 * __v_117; let __v_156: G = __v_116 + __v_155; let __v_157: G = __v_143 * __v_118; let __v_158: G = __v_156 + __v_157; let __v_159: G = __v_146 * __v_119; let __v_160: G = __v_158 + __v_159; let __v_161: G = __v_140 * __v_121; let __v_162: G = __v_120 + __v_161; let __v_163: G = __v_143 * __v_122; let __v_164: G = __v_162 + __v_163; let __v_165: G = __v_146 * __v_123; let __v_166: G = __v_164 + __v_165; let __v_167: G = __v_140 * __v_125; let __v_168: G = __v_124 + __v_167; let __v_169: G = __v_143 * __v_126; let __v_170: G = __v_168 + __v_169; let __v_171: G = __v_146 * __v_127; let __v_172: G = __v_170 + __v_171; let __v_173: G = __v_140 * __v_129; let __v_174: G = __v_128 + __v_173; let __v_175: G = __v_143 * __v_130; let __v_176: G = __v_174 + __v_175; let __v_177: G = __v_146 * __v_131; let __v_178: G = __v_176 + __v_177; let __v_179: G = __v_140 * __v_133; let __v_180: G = __v_132 + __v_179; let __v_181: G = __v_143 * __v_134; let __v_182: G = __v_180 + __v_181; let __v_183: G = __v_146 * __v_135; let __v_184: G = __v_182 + __v_183; let __v_185: G = __v_140 * __v_137; let __v_186: G = __v_136 + __v_185; let __v_187: G = __v_143 * __v_138; let __v_188: G = __v_186 + __v_187; let __v_189: G = __v_146 * __v_139; let __v_190: G = __v_188 + __v_189; if (__v_148 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_148.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("aggr discharge: output claim digest mismatch".to_string()) }); } if (__v_154 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_154.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("aggr discharge: output claim digest mismatch".to_string()) }); } if (__v_160 != __v_29) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("aggr discharge: output claim digest mismatch".to_string()) }); } if (__v_166 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_166.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("aggr discharge: output claim digest mismatch".to_string()) }); } if (__v_172 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("aggr discharge: output claim digest mismatch".to_string()) }); } if (__v_178 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_178.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("aggr discharge: output claim digest mismatch".to_string()) }); } if (__v_184 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_184.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: Some("aggr discharge: output claim digest mismatch".to_string()) }); } if (__v_190 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_190.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("aggr discharge: output claim digest mismatch".to_string()) }); } let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_71]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(270, &__args[..])?) { [G::ZERO; OUT_270] } else { let (__hash, __hit) = record.function_queries[270].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[270].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => { aiur_fn_270::(__args, __hash, record, io_buffer)? }, } } }; let __v_191: G = __r_arr[0]; let __v_192: G = __r_arr[1]; let __v_193: G = __r_arr[2]; let __v_194: G = __r_arr[3]; let __v_195: G = __r_arr[4]; let __v_196: G = __r_arr[5]; let __v_197: G = __r_arr[6]; let __v_198: G = __r_arr[7]; let __v_199: G = G::from_u64(3); let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_54, __v_55, __v_56, __v_57, __v_199, __v_191, __v_192, __v_193, __v_194, __v_195]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(274, &__args[..])?) { [G::ZERO; OUT_274] } else { let (__hash, __hit) = record.function_queries[274].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[274].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => { aiur_fn_274::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_59, __v_196]; 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_200: G = __r_arr[0]; if (__v_200 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_200.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("aggr discharge: output subject root differs from the child's".to_string()) }); } let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_60, __v_61, __v_197, __v_198]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(273, &__args[..])?) { [G::ZERO; OUT_273] } else { let (__hash, __hit) = record.function_queries[273].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[273].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[273].bump_multiplicity(__i); } let __ret: [G; OUT_273] = unsafe { *(record.function_queries[273].output_at(__i).as_ptr() as *const [G; OUT_273]) }; __ret }, _ => { aiur_fn_273::(__args, __hash, record, io_buffer)? }, } } }; let __v_201: G = __r_arr[0]; if (__v_201 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_201.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("aggr discharge: output assumptions differ from the child's".to_string()) }); } let __ret: [G; OUT_286] = []; record.function_queries[286].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_287: usize = 1; -const IN_287: usize = 1; -const OUT_287: usize = 1; -fn aiur_fn_287(inp: [G; IN_287], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_287], ExecError> { 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_287] = [__v_1]; record.function_queries[287].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_287] = [__v_1]; record.function_queries[287].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_287] = [__v_1]; record.function_queries[287].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 29u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_287] = [__v_1]; record.function_queries[287].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 30u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_287] = [__v_1]; record.function_queries[287].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 31u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_287] = [__v_1]; record.function_queries[287].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 37u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_287] = [__v_1]; record.function_queries[287].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 38u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_287] = [__v_1]; record.function_queries[287].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 39u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_287] = [__v_1]; record.function_queries[287].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 40u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_287] = [__v_1]; record.function_queries[287].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 56u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_287] = [__v_1]; record.function_queries[287].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 57u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_287] = [__v_1]; record.function_queries[287].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_287] = [__v_1]; record.function_queries[287].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_288: usize = 3; -const IN_288: usize = 3; -const OUT_288: usize = 1; -fn aiur_fn_288(inp: [G; IN_288], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_288], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_288] = [__v_4]; record.function_queries[288].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; if (__v_3 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("aggr cross-binding: the binding does not bind every role in order".to_string()) }); } let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_4]; 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_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_288] = { let __args: [G; IN_288] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(287, &__args[..])?) { [G::ZERO; OUT_287] } else { let (__hash, __hit) = record.function_queries[287].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[287].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => { aiur_fn_287::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_5, __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_288] = [__v_13]; record.function_queries[288].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_288] = [__v_10]; record.function_queries[288].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_289: usize = 2; -const IN_289: usize = 2; -const OUT_289: usize = 1; -fn aiur_fn_289(inp: [G; IN_289], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_289], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_289] = [__v_1]; record.function_queries[289].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(289, &__args[..])?) { [G::ZERO; OUT_289] } else { let (__hash, __hit) = record.function_queries[289].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[289].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[289].bump_multiplicity(__i); } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => { aiur_fn_289::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_3, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_289] = [__v_6]; record.function_queries[289].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_290: usize = 1; -const IN_290: usize = 1; -const OUT_290: usize = 1; -fn aiur_fn_290(inp: [G; IN_290], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_290], ExecError> { stacker::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_246] = { let __args: [G; IN_246] = [__v_0]; 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_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 __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(275, &__args[..])?) { [G::ZERO; OUT_275] } else { let (__hash, __hit) = record.function_queries[275].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[275].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => { aiur_fn_275::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(232); if (__v_10 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("aggr cross-binding: not a role binding section".to_string()) }); } let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_11]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(3); if (__v_13 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("aggr cross-binding: not a role binding section".to_string()) }); } let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_14]; 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_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_17]; 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_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = G::from_u64(103); if (__v_18 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("aggr cross-binding: the binding does not bind every role".to_string()) }); } let __v_21: G = G::from_u64(0); let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_19, __v_21, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); let __v_24: G = { let __values: [G; 3] = [__v_23, __v_23, __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 __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_22, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(289, &__args[..])?) { [G::ZERO; OUT_289] } else { let (__hash, __hit) = record.function_queries[289].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[289].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[289].bump_multiplicity(__i); } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => { aiur_fn_289::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(4); let __v_27: G = { let __values: [G; 3] = [__v_21, __v_26, __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_28: G = { let __values: [G; 3] = [__v_21, __v_12, __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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_28]; 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_29: G = __r_arr[0]; let __ret: [G; OUT_290] = [__v_29]; record.function_queries[290].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_291: usize = 5; -const IN_291: usize = 5; -const OUT_291: usize = 1; -fn aiur_fn_291(inp: [G; IN_291], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_291], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(3); let __v_6: G = __v_4 - __v_5; let __v_7: G = G::from_u64(5); let __v_8: G = __v_4 - __v_7; let __v_9: G = __v_6 * __v_8; let __v_10: G = G::from_u64(0); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("aggr cross-binding: the claim assumes its binding".to_string()) }); } match __v_4.as_canonical_u64() { 5u64 => { let __ret: [G; OUT_291] = [__v_1]; record.function_queries[291].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(290, &__args[..])?) { [G::ZERO; OUT_290] } else { let (__hash, __hit) = record.function_queries[290].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[290].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => { aiur_fn_290::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_291] = [__v_11]; record.function_queries[291].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_292: usize = 34; -const IN_292: usize = 34; -const OUT_292: usize = 0; -fn aiur_fn_292(inp: [G; IN_292], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_292], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(1); let __v_35: G = G::from_u64(0); let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_34, __v_35, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(282, &__args[..])?) { [G::ZERO; OUT_282] } else { let (__hash, __hit) = record.function_queries[282].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[282].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => { aiur_fn_282::(__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 __v_39: G = __r_arr[3]; let __v_40: G = __r_arr[4]; let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_34, __v_34, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(282, &__args[..])?) { [G::ZERO; OUT_282] } else { let (__hash, __hit) = record.function_queries[282].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[282].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => { aiur_fn_282::(__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 __v_47: G = __r_arr[3]; let __v_48: G = __r_arr[4]; let __v_49: G = __r_arr[5]; let __v_50: G = __r_arr[6]; let __v_51: G = __r_arr[7]; let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(275, &__args[..])?) { [G::ZERO; OUT_275] } else { let (__hash, __hit) = record.function_queries[275].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[275].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => { aiur_fn_275::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(270, &__args[..])?) { [G::ZERO; OUT_270] } else { let (__hash, __hit) = record.function_queries[270].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[270].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => { aiur_fn_270::(__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 __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(275, &__args[..])?) { [G::ZERO; OUT_275] } else { let (__hash, __hit) = record.function_queries[275].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[275].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => { aiur_fn_275::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_61]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(270, &__args[..])?) { [G::ZERO; OUT_270] } else { let (__hash, __hit) = record.function_queries[270].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[270].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => { aiur_fn_270::(__args, __hash, record, io_buffer)? }, } } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; let __v_64: G = __r_arr[2]; let __v_65: G = __r_arr[3]; let __v_66: G = __r_arr[4]; let __v_67: G = __r_arr[5]; let __v_68: G = __r_arr[6]; let __v_69: G = __r_arr[7]; let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_53, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(291, &__args[..])?) { [G::ZERO; OUT_291] } else { let (__hash, __hit) = record.function_queries[291].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[291].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[291].bump_multiplicity(__i); } let __ret: [G; OUT_291] = unsafe { *(record.function_queries[291].output_at(__i).as_ptr() as *const [G; OUT_291]) }; __ret }, _ => { aiur_fn_291::(__args, __hash, record, io_buffer)? }, } } }; let __v_70: G = __r_arr[0]; let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(291, &__args[..])?) { [G::ZERO; OUT_291] } else { let (__hash, __hit) = record.function_queries[291].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[291].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[291].bump_multiplicity(__i); } let __ret: [G; OUT_291] = unsafe { *(record.function_queries[291].output_at(__i).as_ptr() as *const [G; OUT_291]) }; __ret }, _ => { aiur_fn_291::(__args, __hash, record, io_buffer)? }, } } }; let __v_71: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_70, __v_71]; 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_72: G = __r_arr[0]; if (__v_72 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("aggr cross-binding: the bindings' literal classes differ".to_string()) }); } let __v_73: G = G::from_u64(2); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_73]; let __info = io_buffer.get_info(__v_73, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_74: G = __io_pair.0; let __v_75: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_73, __v_74, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(3, &__args[..])?) { [G::ZERO; OUT_3] } else { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[3].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[3].bump_multiplicity(__i); } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; let __v_77: G = G::from_u64(103); let __v_78: G = G::from_u64(230); let __v_79: G = G::from_u64(9); let __v_80: G = G::from_u64(106); let __v_81: G = G::from_u64(133); let __v_82: G = G::from_u64(174); let __v_83: G = G::from_u64(187); let __v_84: G = G::from_u64(114); let __v_85: G = G::from_u64(243); let __v_86: G = G::from_u64(110); let __v_87: G = G::from_u64(60); let __v_88: G = G::from_u64(58); let __v_89: G = G::from_u64(245); let __v_90: G = G::from_u64(79); let __v_91: G = G::from_u64(165); let __v_92: G = G::from_u64(127); let __v_93: G = G::from_u64(82); let __v_94: G = G::from_u64(14); let __v_95: G = G::from_u64(81); let __v_96: G = G::from_u64(140); let __v_97: G = G::from_u64(104); let __v_98: G = G::from_u64(5); let __v_99: G = G::from_u64(155); let __v_100: G = G::from_u64(171); let __v_101: G = G::from_u64(217); let __v_102: G = G::from_u64(131); let __v_103: G = G::from_u64(31); let __v_104: G = G::from_u64(25); let __v_105: G = G::from_u64(205); let __v_106: G = G::from_u64(224); let __v_107: G = G::from_u64(91); let __v_108: G = { let __values: [G; 3] = [__v_34, __v_34, __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_109: G = { let __values: [G; 8] = [__v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35]; 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_110: G = { let __values: [G; 32] = [__v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_77, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_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_111: G = { let __values: [G; 34] = [__v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; 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_78] = { let __args: [G; IN_78] = [__v_76, __v_108, __v_35, __v_35, __v_109, __v_110, __v_111]; 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_112: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_112]; 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_113: G = __r_arr[0]; let __v_114: G = __r_arr[1]; let __v_115: G = __r_arr[2]; let __v_116: G = __r_arr[3]; let __v_117: G = __r_arr[4]; let __v_118: G = __r_arr[5]; let __v_119: G = __r_arr[6]; let __v_120: G = __r_arr[7]; let __v_121: G = __r_arr[8]; let __v_122: G = __r_arr[9]; let __v_123: G = __r_arr[10]; let __v_124: G = __r_arr[11]; let __v_125: G = __r_arr[12]; let __v_126: G = __r_arr[13]; let __v_127: G = __r_arr[14]; let __v_128: G = __r_arr[15]; let __v_129: G = __r_arr[16]; let __v_130: G = __r_arr[17]; let __v_131: G = __r_arr[18]; let __v_132: G = __r_arr[19]; let __v_133: G = __r_arr[20]; let __v_134: G = __r_arr[21]; let __v_135: G = __r_arr[22]; let __v_136: G = __r_arr[23]; let __v_137: G = __r_arr[24]; let __v_138: G = __r_arr[25]; let __v_139: G = __r_arr[26]; let __v_140: G = __r_arr[27]; let __v_141: G = __r_arr[28]; let __v_142: G = __r_arr[29]; let __v_143: G = __r_arr[30]; let __v_144: G = __r_arr[31]; let __v_145: G = G::from_u64(256); let __v_146: G = __v_145 * __v_114; let __v_147: G = __v_113 + __v_146; let __v_148: G = G::from_u64(65536); let __v_149: G = __v_148 * __v_115; let __v_150: G = __v_147 + __v_149; let __v_151: G = G::from_u64(16777216); let __v_152: G = __v_151 * __v_116; let __v_153: G = __v_150 + __v_152; let __v_154: G = __v_145 * __v_118; let __v_155: G = __v_117 + __v_154; let __v_156: G = __v_148 * __v_119; let __v_157: G = __v_155 + __v_156; let __v_158: G = __v_151 * __v_120; let __v_159: G = __v_157 + __v_158; let __v_160: G = __v_145 * __v_122; let __v_161: G = __v_121 + __v_160; let __v_162: G = __v_148 * __v_123; let __v_163: G = __v_161 + __v_162; let __v_164: G = __v_151 * __v_124; let __v_165: G = __v_163 + __v_164; let __v_166: G = __v_145 * __v_126; let __v_167: G = __v_125 + __v_166; let __v_168: G = __v_148 * __v_127; let __v_169: G = __v_167 + __v_168; let __v_170: G = __v_151 * __v_128; let __v_171: G = __v_169 + __v_170; let __v_172: G = __v_145 * __v_130; let __v_173: G = __v_129 + __v_172; let __v_174: G = __v_148 * __v_131; let __v_175: G = __v_173 + __v_174; let __v_176: G = __v_151 * __v_132; let __v_177: G = __v_175 + __v_176; let __v_178: G = __v_145 * __v_134; let __v_179: G = __v_133 + __v_178; let __v_180: G = __v_148 * __v_135; let __v_181: G = __v_179 + __v_180; let __v_182: G = __v_151 * __v_136; let __v_183: G = __v_181 + __v_182; let __v_184: G = __v_145 * __v_138; let __v_185: G = __v_137 + __v_184; let __v_186: G = __v_148 * __v_139; let __v_187: G = __v_185 + __v_186; let __v_188: G = __v_151 * __v_140; let __v_189: G = __v_187 + __v_188; let __v_190: G = __v_145 * __v_142; let __v_191: G = __v_141 + __v_190; let __v_192: G = __v_148 * __v_143; let __v_193: G = __v_191 + __v_192; let __v_194: G = __v_151 * __v_144; let __v_195: G = __v_193 + __v_194; if (__v_153 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_153.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("aggr cross-binding: output claim digest mismatch".to_string()) }); } if (__v_159 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_159.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("aggr cross-binding: output claim digest mismatch".to_string()) }); } if (__v_165 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_165.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("aggr cross-binding: output claim digest mismatch".to_string()) }); } if (__v_171 != __v_29) { return Err(ExecError::AssertEqMismatch { lhs: __v_171.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("aggr cross-binding: output claim digest mismatch".to_string()) }); } if (__v_177 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_177.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("aggr cross-binding: output claim digest mismatch".to_string()) }); } if (__v_183 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_183.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("aggr cross-binding: output claim digest mismatch".to_string()) }); } if (__v_189 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("aggr cross-binding: output claim digest mismatch".to_string()) }); } if (__v_195 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_195.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: Some("aggr cross-binding: output claim digest mismatch".to_string()) }); } let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_76]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(270, &__args[..])?) { [G::ZERO; OUT_270] } else { let (__hash, __hit) = record.function_queries[270].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[270].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => { aiur_fn_270::(__args, __hash, record, io_buffer)? }, } } }; let __v_196: G = __r_arr[0]; let __v_197: G = __r_arr[1]; let __v_198: G = __r_arr[2]; let __v_199: G = __r_arr[3]; let __v_200: G = __r_arr[4]; let __v_201: G = __r_arr[5]; let __v_202: G = __r_arr[6]; let __v_203: G = __r_arr[7]; let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_53, __v_70, __v_55, __v_56, __v_98, __v_196, __v_197, __v_198, __v_199, __v_200]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(274, &__args[..])?) { [G::ZERO; OUT_274] } else { let (__hash, __hit) = record.function_queries[274].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[274].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => { aiur_fn_274::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_62, __v_71, __v_64, __v_65, __v_98, __v_196, __v_197, __v_198, __v_199, __v_200]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(274, &__args[..])?) { [G::ZERO; OUT_274] } else { let (__hash, __hit) = record.function_queries[274].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[274].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => { aiur_fn_274::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_58, __v_67]; 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_204: G = __r_arr[0]; if (__v_204 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_204.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("aggr cross-binding: child subject roots must be distinct".to_string()) }); } let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_58, __v_67]; 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_205: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_201, __v_205]; 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_206: G = __r_arr[0]; if (__v_206 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_206.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("aggr cross-binding: output subject root is not nodeHash(left, right)".to_string()) }); } let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_59, __v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(258, &__args[..])?) { [G::ZERO; OUT_258] } else { let (__hash, __hit) = record.function_queries[258].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[258].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => { aiur_fn_258::(__args, __hash, record, io_buffer)? }, } } }; let __v_207: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_68, __v_69]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(258, &__args[..])?) { [G::ZERO; OUT_258] } else { let (__hash, __hit) = record.function_queries[258].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[258].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => { aiur_fn_258::(__args, __hash, record, io_buffer)? }, } } }; let __v_208: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_202, __v_203]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(258, &__args[..])?) { [G::ZERO; OUT_258] } else { let (__hash, __hit) = record.function_queries[258].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[258].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => { aiur_fn_258::(__args, __hash, record, io_buffer)? }, } } }; let __v_209: G = __r_arr[0]; let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_207, __v_208, __v_58, __v_67, __v_209]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(268, &__args[..])?) { [G::ZERO; OUT_268] } else { let (__hash, __hit) = record.function_queries[268].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[268].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[268].bump_multiplicity(__i); } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => { aiur_fn_268::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_292] = []; record.function_queries[292].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_293: usize = 8; -const IN_293: usize = 8; -const OUT_293: usize = 1; -fn aiur_fn_293(inp: [G; IN_293], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_293], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(275, &__args[..])?) { [G::ZERO; OUT_275] } else { let (__hash, __hit) = record.function_queries[275].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[275].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => { aiur_fn_275::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 229u64 => { let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(270, &__args[..])?) { [G::ZERO; OUT_270] } else { let (__hash, __hit) = record.function_queries[270].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[270].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => { aiur_fn_270::(__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 = G::from_u64(3); let __v_20: G = __v_15 - __v_19; let __v_21: G = G::from_u64(5); let __v_22: G = __v_15 - __v_21; let __v_23: G = __v_20 * __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: Some("aggr catalog: a member claim assumes its binding".to_string()) }); } let __v_25: G = G::from_u64(1); let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_17, __v_18, __v_25, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(273, &__args[..])?) { [G::ZERO; OUT_273] } else { let (__hash, __hit) = record.function_queries[273].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[273].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[273].bump_multiplicity(__i); } let __ret: [G; OUT_273] = unsafe { *(record.function_queries[273].output_at(__i).as_ptr() as *const [G; OUT_273]) }; __ret }, _ => { aiur_fn_273::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; if (__v_26 != __v_25) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("aggr catalog: a member claim has assumptions".to_string()) }); } let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_8]; 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_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 3] = [__v_25, __v_25, __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_29: G = { let __values: [G; 3] = [__v_24, __v_27, __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 __ret: [G; OUT_293] = [__v_29]; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(272, &__args[..])?) { [G::ZERO; OUT_272] } else { let (__hash, __hit) = record.function_queries[272].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[272].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => { aiur_fn_272::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, &__args[..])?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => { aiur_fn_257::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_293] = [__v_12]; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_294: usize = 34; -const IN_294: usize = 34; -const OUT_294: usize = 0; -fn aiur_fn_294(inp: [G; IN_294], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_294], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(1); let __v_35: G = G::from_u64(0); let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_34, __v_35, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(282, &__args[..])?) { [G::ZERO; OUT_282] } else { let (__hash, __hit) = record.function_queries[282].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[282].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => { aiur_fn_282::(__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 __v_39: G = __r_arr[3]; let __v_40: G = __r_arr[4]; let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_34, __v_34, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(282, &__args[..])?) { [G::ZERO; OUT_282] } else { let (__hash, __hit) = record.function_queries[282].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[282].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => { aiur_fn_282::(__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 __v_47: G = __r_arr[3]; let __v_48: G = __r_arr[4]; let __v_49: G = __r_arr[5]; let __v_50: G = __r_arr[6]; let __v_51: G = __r_arr[7]; let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(293, &__args[..])?) { [G::ZERO; OUT_293] } else { let (__hash, __hit) = record.function_queries[293].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[293].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => { aiur_fn_293::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(293, &__args[..])?) { [G::ZERO; OUT_293] } else { let (__hash, __hit) = record.function_queries[293].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[293].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => { aiur_fn_293::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(2); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_54]; let __info = io_buffer.get_info(__v_54, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_55: G = __io_pair.0; let __v_56: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_54, __v_55, __v_56]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(3, &__args[..])?) { [G::ZERO; OUT_3] } else { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[3].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[3].bump_multiplicity(__i); } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_u64(103); let __v_59: G = G::from_u64(230); let __v_60: G = G::from_u64(9); let __v_61: G = G::from_u64(106); let __v_62: G = G::from_u64(133); let __v_63: G = G::from_u64(174); let __v_64: G = G::from_u64(187); let __v_65: G = G::from_u64(114); let __v_66: G = G::from_u64(243); let __v_67: G = G::from_u64(110); let __v_68: G = G::from_u64(60); let __v_69: G = G::from_u64(58); let __v_70: G = G::from_u64(245); let __v_71: G = G::from_u64(79); let __v_72: G = G::from_u64(165); let __v_73: G = G::from_u64(127); let __v_74: G = G::from_u64(82); let __v_75: G = G::from_u64(14); let __v_76: G = G::from_u64(81); let __v_77: G = G::from_u64(140); let __v_78: G = G::from_u64(104); let __v_79: G = G::from_u64(5); let __v_80: G = G::from_u64(155); let __v_81: G = G::from_u64(171); let __v_82: G = G::from_u64(217); let __v_83: G = G::from_u64(131); let __v_84: G = G::from_u64(31); let __v_85: G = G::from_u64(25); let __v_86: G = G::from_u64(205); let __v_87: G = G::from_u64(224); let __v_88: G = G::from_u64(91); let __v_89: G = { let __values: [G; 3] = [__v_34, __v_34, __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_90: G = { let __values: [G; 8] = [__v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35]; 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_91: G = { let __values: [G; 32] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_58, __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]; 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_92: G = { let __values: [G; 34] = [__v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; 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_78] = { let __args: [G; IN_78] = [__v_57, __v_89, __v_35, __v_35, __v_90, __v_91, __v_92]; 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_93: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_93]; 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_94: G = __r_arr[0]; let __v_95: G = __r_arr[1]; let __v_96: G = __r_arr[2]; let __v_97: G = __r_arr[3]; let __v_98: G = __r_arr[4]; let __v_99: G = __r_arr[5]; let __v_100: G = __r_arr[6]; let __v_101: G = __r_arr[7]; let __v_102: G = __r_arr[8]; let __v_103: G = __r_arr[9]; let __v_104: G = __r_arr[10]; let __v_105: G = __r_arr[11]; let __v_106: G = __r_arr[12]; let __v_107: G = __r_arr[13]; let __v_108: G = __r_arr[14]; let __v_109: G = __r_arr[15]; let __v_110: G = __r_arr[16]; let __v_111: G = __r_arr[17]; let __v_112: G = __r_arr[18]; let __v_113: G = __r_arr[19]; let __v_114: G = __r_arr[20]; let __v_115: G = __r_arr[21]; let __v_116: G = __r_arr[22]; let __v_117: G = __r_arr[23]; let __v_118: G = __r_arr[24]; let __v_119: G = __r_arr[25]; let __v_120: G = __r_arr[26]; let __v_121: G = __r_arr[27]; let __v_122: G = __r_arr[28]; let __v_123: G = __r_arr[29]; let __v_124: G = __r_arr[30]; let __v_125: G = __r_arr[31]; let __v_126: G = G::from_u64(256); let __v_127: G = __v_126 * __v_95; let __v_128: G = __v_94 + __v_127; let __v_129: G = G::from_u64(65536); let __v_130: G = __v_129 * __v_96; let __v_131: G = __v_128 + __v_130; let __v_132: G = G::from_u64(16777216); let __v_133: G = __v_132 * __v_97; let __v_134: G = __v_131 + __v_133; let __v_135: G = __v_126 * __v_99; let __v_136: G = __v_98 + __v_135; let __v_137: G = __v_129 * __v_100; let __v_138: G = __v_136 + __v_137; let __v_139: G = __v_132 * __v_101; let __v_140: G = __v_138 + __v_139; let __v_141: G = __v_126 * __v_103; let __v_142: G = __v_102 + __v_141; let __v_143: G = __v_129 * __v_104; let __v_144: G = __v_142 + __v_143; let __v_145: G = __v_132 * __v_105; let __v_146: G = __v_144 + __v_145; let __v_147: G = __v_126 * __v_107; let __v_148: G = __v_106 + __v_147; let __v_149: G = __v_129 * __v_108; let __v_150: G = __v_148 + __v_149; let __v_151: G = __v_132 * __v_109; let __v_152: G = __v_150 + __v_151; let __v_153: G = __v_126 * __v_111; let __v_154: G = __v_110 + __v_153; let __v_155: G = __v_129 * __v_112; let __v_156: G = __v_154 + __v_155; let __v_157: G = __v_132 * __v_113; let __v_158: G = __v_156 + __v_157; let __v_159: G = __v_126 * __v_115; let __v_160: G = __v_114 + __v_159; let __v_161: G = __v_129 * __v_116; let __v_162: G = __v_160 + __v_161; let __v_163: G = __v_132 * __v_117; let __v_164: G = __v_162 + __v_163; let __v_165: G = __v_126 * __v_119; let __v_166: G = __v_118 + __v_165; let __v_167: G = __v_129 * __v_120; let __v_168: G = __v_166 + __v_167; let __v_169: G = __v_132 * __v_121; let __v_170: G = __v_168 + __v_169; let __v_171: G = __v_126 * __v_123; let __v_172: G = __v_122 + __v_171; let __v_173: G = __v_129 * __v_124; let __v_174: G = __v_172 + __v_173; let __v_175: G = __v_132 * __v_125; let __v_176: G = __v_174 + __v_175; if (__v_134 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_134.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("aggr catalog: output claim digest mismatch".to_string()) }); } if (__v_140 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_140.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("aggr catalog: output claim digest mismatch".to_string()) }); } if (__v_146 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_146.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("aggr catalog: output claim digest mismatch".to_string()) }); } if (__v_152 != __v_29) { return Err(ExecError::AssertEqMismatch { lhs: __v_152.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("aggr catalog: output claim digest mismatch".to_string()) }); } if (__v_158 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_158.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("aggr catalog: output claim digest mismatch".to_string()) }); } if (__v_164 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_164.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("aggr catalog: output claim digest mismatch".to_string()) }); } if (__v_170 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_170.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("aggr catalog: output claim digest mismatch".to_string()) }); } if (__v_176 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_176.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: Some("aggr catalog: output claim digest mismatch".to_string()) }); } let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(272, &__args[..])?) { [G::ZERO; OUT_272] } else { let (__hash, __hit) = record.function_queries[272].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[272].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => { aiur_fn_272::(__args, __hash, record, io_buffer)? }, } } }; let __v_177: G = __r_arr[0]; let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_177]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, &__args[..])?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => { aiur_fn_257::(__args, __hash, record, io_buffer)? }, } } }; let __v_178: G = __r_arr[0]; let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_52, __v_53, __v_178]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(260, &__args[..])?) { [G::ZERO; OUT_260] } else { let (__hash, __hit) = record.function_queries[260].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[260].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => { aiur_fn_260::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_294] = []; record.function_queries[294].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_295: usize = 1; -const IN_295: usize = 1; -const OUT_295: usize = 19; -fn aiur_fn_295(inp: [G; IN_295], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_295], ExecError> { stacker::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_90] = { let __args: [G; IN_90] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = G::from_u64(82); if (__v_1 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("aggr range: statement has the wrong tag".to_string()) }); } 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_5]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_15]; 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_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_17]; 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_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_19]; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_21]; 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_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_25]; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_27]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_29]; 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_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_31]; 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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_33]; 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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_35]; 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_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_37]; 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_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_39]; 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_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_41]; 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_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_43]; 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_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_45]; 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_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_47]; let __cu = 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_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_49]; 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_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_51]; 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_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_53]; 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_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_55]; 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_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_57]; 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_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_59]; 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_60: G = __r_arr[0]; let __v_61: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_61]; 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_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_63]; 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_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_65]; 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_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_67]; 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_68: G = __r_arr[0]; let __v_69: 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_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]; let __v_73: G = G::from_u64(1); if (__v_70 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the statement".to_string()) }); } if (__v_71 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the statement".to_string()) }); } if (__v_72 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the statement".to_string()) }); } let __v_74: G = G::from_u64(256); let __v_75: G = __v_74 * __v_40; let __v_76: G = __v_38 + __v_75; let __v_77: G = G::from_u64(65536); let __v_78: G = __v_77 * __v_42; let __v_79: G = __v_76 + __v_78; let __v_80: G = G::from_u64(16777216); let __v_81: G = __v_80 * __v_44; let __v_82: G = __v_79 + __v_81; let __v_83: G = G::from_u64(4294967296); let __v_84: G = __v_83 * __v_46; let __v_85: G = __v_82 + __v_84; let __v_86: G = G::from_u64(1099511627776); let __v_87: G = __v_86 * __v_48; let __v_88: G = __v_85 + __v_87; let __v_89: G = G::from_u64(281474976710656); let __v_90: G = __v_89 * __v_50; let __v_91: G = __v_88 + __v_90; let __v_92: G = G::from_u64(72057594037927936); let __v_93: G = __v_92 * __v_52; let __v_94: G = __v_91 + __v_93; let __v_95: G = __v_74 * __v_56; let __v_96: G = __v_54 + __v_95; let __v_97: G = __v_77 * __v_58; let __v_98: G = __v_96 + __v_97; let __v_99: G = __v_80 * __v_60; let __v_100: G = __v_98 + __v_99; let __v_101: G = __v_83 * __v_62; let __v_102: G = __v_100 + __v_101; let __v_103: G = __v_86 * __v_64; let __v_104: G = __v_102 + __v_103; let __v_105: G = __v_89 * __v_66; let __v_106: G = __v_104 + __v_105; let __v_107: G = __v_92 * __v_68; let __v_108: G = __v_106 + __v_107; let __ret: [G; OUT_295] = [__v_4, __v_6, __v_8, __v_10, __v_12, __v_14, __v_16, __v_18, __v_20, __v_22, __v_24, __v_26, __v_28, __v_30, __v_32, __v_34, __v_36, __v_94, __v_108]; record.function_queries[295].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_296: usize = 1; -const IN_296: usize = 1; -const OUT_296: usize = 2; -fn aiur_fn_296(inp: [G; IN_296], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_296], ExecError> { stacker::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_26] = { let __args: [G; IN_26] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_4]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_10]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_12]; let __cu = 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_14]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_16]; 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_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_18]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_20]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_22]; 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_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_24]; 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_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_26]; 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_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_28]; let __cu = 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_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_32]; 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_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_34]; 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_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_36]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_38]; 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_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_40]; 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_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_42]; 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_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_44]; 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_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_46]; 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_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_48]; 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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_50]; 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_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_52]; 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_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_54]; 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_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_56]; 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_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_58]; 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_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_60]; 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_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_62]; 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_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __v_65: G = { let __values: [G; 32] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_17, __v_19, __v_21, __v_23, __v_25, __v_27, __v_29, __v_31, __v_33, __v_35, __v_37, __v_39, __v_41, __v_43, __v_45, __v_47, __v_49, __v_51, __v_53, __v_55, __v_57, __v_59, __v_61, __v_63]; let __mq = record.memory_queries.get_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_296] = [__v_65, __v_64]; record.function_queries[296].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_297: usize = 2; -const IN_297: usize = 2; -const OUT_297: usize = 2; -fn aiur_fn_297(inp: [G; IN_297], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_297], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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_297] = [__v_3, __v_0]; record.function_queries[297].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(296, &__args[..])?) { [G::ZERO; OUT_296] } else { let (__hash, __hit) = record.function_queries[296].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[296].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[296].bump_multiplicity(__i); } let __ret: [G; OUT_296] = unsafe { *(record.function_queries[296].output_at(__i).as_ptr() as *const [G; OUT_296]) }; __ret }, _ => { aiur_fn_296::(__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_297] = { let __args: [G; IN_297] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(297, &__args[..])?) { [G::ZERO; OUT_297] } else { let (__hash, __hit) = record.function_queries[297].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[297].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[297].bump_multiplicity(__i); } let __ret: [G; OUT_297] = unsafe { *(record.function_queries[297].output_at(__i).as_ptr() as *const [G; OUT_297]) }; __ret }, _ => { aiur_fn_297::(__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_297] = [__v_9, __v_7]; record.function_queries[297].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_298: usize = 2; -const IN_298: usize = 2; -const OUT_298: usize = 2; -fn aiur_fn_298(inp: [G; IN_298], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_298], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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_298] = [__v_3, __v_0]; record.function_queries[298].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; 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_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_298] = { let __args: [G; IN_298] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(298, &__args[..])?) { [G::ZERO; OUT_298] } else { let (__hash, __hit) = record.function_queries[298].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[298].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => { aiur_fn_298::(__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_298] = [__v_9, __v_7]; record.function_queries[298].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_299: usize = 1; -const IN_299: usize = 1; -const OUT_299: usize = 5; -fn aiur_fn_299(inp: [G; IN_299], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_299], ExecError> { stacker::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 = unconstrained; if ((!unconstrained) && record.defer_call(27, &__args[..])?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } 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 __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_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(298, &__args[..])?) { [G::ZERO; OUT_298] } else { let (__hash, __hit) = record.function_queries[298].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[298].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => { aiur_fn_298::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(27, &__args[..])?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; let __v_16: G = __r_arr[3]; let __v_17: G = __r_arr[4]; let __v_18: G = __r_arr[5]; let __v_19: G = __r_arr[6]; let __v_20: G = __r_arr[7]; let __v_21: G = __r_arr[8]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_21, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(297, &__args[..])?) { [G::ZERO; OUT_297] } else { let (__hash, __hit) = record.function_queries[297].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[297].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[297].bump_multiplicity(__i); } let __ret: [G; OUT_297] = unsafe { *(record.function_queries[297].output_at(__i).as_ptr() as *const [G; OUT_297]) }; __ret }, _ => { aiur_fn_297::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(27, &__args[..])?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } 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_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; let __v_28: G = __r_arr[3]; let __v_29: G = __r_arr[4]; let __v_30: G = __r_arr[5]; let __v_31: G = __r_arr[6]; let __v_32: G = __r_arr[7]; let __v_33: G = __r_arr[8]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_33, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(298, &__args[..])?) { [G::ZERO; OUT_298] } else { let (__hash, __hit) = record.function_queries[298].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[298].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => { aiur_fn_298::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(28, &__args[..])?) { [G::ZERO; OUT_28] } else { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[28].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[28].bump_multiplicity(__i); } 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_38, __v_37]; 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 = __r_arr[1]; let __ret: [G; OUT_299] = [__v_11, __v_23, __v_35, __v_39, __v_40]; record.function_queries[299].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_300: usize = 2; -const IN_300: usize = 2; -const OUT_300: usize = 2; -fn aiur_fn_300(inp: [G; IN_300], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_300], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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_300] = [__v_3, __v_0]; record.function_queries[300].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(299, &__args[..])?) { [G::ZERO; OUT_299] } else { let (__hash, __hit) = record.function_queries[299].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[299].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[299].bump_multiplicity(__i); } let __ret: [G; OUT_299] = unsafe { *(record.function_queries[299].output_at(__i).as_ptr() as *const [G; OUT_299]) }; __ret }, _ => { aiur_fn_299::(__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 = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(300, &__args[..])?) { [G::ZERO; OUT_300] } else { let (__hash, __hit) = record.function_queries[300].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[300].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[300].bump_multiplicity(__i); } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => { aiur_fn_300::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 6] = [__v_11, __v_2, __v_3, __v_4, __v_5, __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_300] = [__v_12, __v_10]; record.function_queries[300].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_301: usize = 1; -const IN_301: usize = 1; -const OUT_301: usize = 10; -fn aiur_fn_301(inp: [G; IN_301], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_301], ExecError> { stacker::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 = unconstrained; if ((!unconstrained) && record.defer_call(28, &__args[..])?) { [G::ZERO; OUT_28] } else { let (__hash, __hit) = record.function_queries[28].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[28].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[28].bump_multiplicity(__i); } 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 __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_2, __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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_4]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_10]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_12]; let __cu = 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_14]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_16]; 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_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_18]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_301] = [__v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_17, __v_19, __v_20]; record.function_queries[301].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_302: usize = 2; -const IN_302: usize = 2; -const OUT_302: usize = 2; -fn aiur_fn_302(inp: [G; IN_302], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_302], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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_302] = [__v_3, __v_0]; record.function_queries[302].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(301, &__args[..])?) { [G::ZERO; OUT_301] } else { let (__hash, __hit) = record.function_queries[301].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[301].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { *(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301]) }; __ret }, _ => { aiur_fn_301::(__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(1); let __v_13: G = __v_1 - __v_12; let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_11, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(302, &__args[..])?) { [G::ZERO; OUT_302] } else { let (__hash, __hit) = record.function_queries[302].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[302].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => { aiur_fn_302::(__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 = { let __values: [G; 11] = [__v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_14]; 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_302] = [__v_17, __v_15]; record.function_queries[302].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_303: usize = 2; -const IN_303: usize = 2; -const OUT_303: usize = 2; -fn aiur_fn_303(inp: [G; IN_303], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_303], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __io_pair: (G, G) = { let __key: [G; 1] = [__v_0]; let __info = io_buffer.get_info(__v_2, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_3: G = __io_pair.0; let __v_4: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(3, &__args[..])?) { [G::ZERO; OUT_3] } else { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[3].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[3].bump_multiplicity(__i); } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__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_6: G = __r_arr[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_1]; 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_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("aggr range: preamble does not hash to the statement's batch digest".to_string()) }); } let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(27, &__args[..])?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } 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_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 __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(300, &__args[..])?) { [G::ZERO; OUT_300] } else { let (__hash, __hit) = record.function_queries[300].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[300].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[300].bump_multiplicity(__i); } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => { aiur_fn_300::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(27, &__args[..])?) { [G::ZERO; OUT_27] } else { let (__hash, __hit) = record.function_queries[27].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[27].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[27].bump_multiplicity(__i); } 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_29, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(302, &__args[..])?) { [G::ZERO; OUT_302] } else { let (__hash, __hit) = record.function_queries[302].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[302].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => { aiur_fn_302::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: 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_32.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_33: G = __loaded[0]; let __v_34: G = __loaded[1]; let __v_35: G = __loaded[2]; if (__v_33 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the preamble".to_string()) }); } if (__v_34 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the preamble".to_string()) }); } if (__v_35 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the preamble".to_string()) }); } let __ret: [G; OUT_303] = [__v_19, __v_31]; record.function_queries[303].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_304: usize = 14; -const IN_304: usize = 14; -const OUT_304: usize = 5; -fn aiur_fn_304(inp: [G; IN_304], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_304], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_0.as_canonical_u64() { _ => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(1); let __v_15: 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 }, } }; break '__mc_0 [__v_15]; }, 1u64 => { break '__mc_0 [__v_10]; }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }; let __v_14: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_7, __v_14, __v_12, __v_13]; 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_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 __ret: [G; OUT_304] = [__v_15, __v_16, __v_17, __v_18, __v_19]; record.function_queries[304].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_305: usize = 23; -const IN_305: usize = 23; -const OUT_305: usize = 3; -fn aiur_fn_305(inp: [G; IN_305], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_305], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_15.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_305] = [__v_21, __v_22, __v_13]; record.function_queries[305].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { 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_23: G = __loaded[0]; let __v_24: G = __loaded[1]; let __v_25: G = __loaded[2]; let __v_26: G = __loaded[3]; let __v_27: G = __loaded[4]; let __v_28: G = __loaded[5]; match __v_23.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(62, &__args[..])?) { [G::ZERO; OUT_62] } else { let (__hash, __hit) = record.function_queries[62].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[62].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[62].bump_multiplicity(__i); } let __ret: [G; OUT_62] = unsafe { *(record.function_queries[62].output_at(__i).as_ptr() as *const [G; OUT_62]) }; __ret }, _ => { aiur_fn_62::(__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 = __r_arr[9]; let __v_39: G = __r_arr[10]; let __v_40: G = __r_arr[11]; let __v_41: G = __r_arr[12]; let __v_42: G = __r_arr[13]; let __v_43: G = __r_arr[14]; let __v_44: G = __r_arr[15]; let __v_45: G = __r_arr[16]; let __v_46: G = __r_arr[17]; let __v_47: G = __r_arr[18]; let __v_48: G = __r_arr[19]; let __v_49: G = __r_arr[20]; let __v_50: G = __r_arr[21]; let __v_51: G = __r_arr[22]; let __v_52: G = __r_arr[23]; let __v_53: G = __r_arr[24]; let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_24, __v_25, __v_26, __v_27, __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_16, __v_17, __v_18, __v_19, __v_20]; 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_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_15 - __v_56; let __v_59: G = __v_21 + __v_54; let __v_60: G = __v_22 + __v_55; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_28, __v_53, __v_57, __v_58, __v_16, __v_17, __v_18, __v_19, __v_20, __v_59, __v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(305, &__args[..])?) { [G::ZERO; OUT_305] } else { let (__hash, __hit) = record.function_queries[305].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[305].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[305].bump_multiplicity(__i); } let __ret: [G; OUT_305] = unsafe { *(record.function_queries[305].output_at(__i).as_ptr() as *const [G; OUT_305]) }; __ret }, _ => { aiur_fn_305::(__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 __ret: [G; OUT_305] = [__v_61, __v_62, __v_63]; record.function_queries[305].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_306: usize = 8; -const IN_306: usize = 8; -const OUT_306: usize = 19; -fn aiur_fn_306(inp: [G; IN_306], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_306], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(2); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_8]; let __info = io_buffer.get_info(__v_8, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_9: G = __io_pair.0; let __v_10: G = __io_pair.1; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_8, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(3, &__args[..])?) { [G::ZERO; OUT_3] } else { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[3].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[3].bump_multiplicity(__i); } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(103); let __v_13: G = G::from_u64(230); let __v_14: G = G::from_u64(9); let __v_15: G = G::from_u64(106); let __v_16: G = G::from_u64(133); let __v_17: G = G::from_u64(174); let __v_18: G = G::from_u64(187); let __v_19: G = G::from_u64(114); let __v_20: G = G::from_u64(243); let __v_21: G = G::from_u64(110); let __v_22: G = G::from_u64(60); let __v_23: G = G::from_u64(58); let __v_24: G = G::from_u64(245); let __v_25: G = G::from_u64(79); let __v_26: G = G::from_u64(165); let __v_27: G = G::from_u64(127); let __v_28: G = G::from_u64(82); let __v_29: G = G::from_u64(14); let __v_30: G = G::from_u64(81); let __v_31: G = G::from_u64(140); let __v_32: G = G::from_u64(104); let __v_33: G = G::from_u64(5); let __v_34: G = G::from_u64(155); let __v_35: G = G::from_u64(171); let __v_36: G = G::from_u64(217); let __v_37: G = G::from_u64(131); let __v_38: G = G::from_u64(31); let __v_39: G = G::from_u64(25); let __v_40: G = G::from_u64(205); let __v_41: G = G::from_u64(224); let __v_42: G = G::from_u64(91); let __v_43: G = G::from_u64(1); let __v_44: G = { let __values: [G; 3] = [__v_43, __v_43, __v_43]; 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_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 8] = [__v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45]; 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_47: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_12, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42]; let __mq = record.memory_queries.get_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_48: G = { let __values: [G; 34] = [__v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __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(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_78] = { let __args: [G; IN_78] = [__v_11, __v_44, __v_45, __v_45, __v_46, __v_47, __v_48]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_49]; 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_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 __v_61: G = __r_arr[11]; let __v_62: G = __r_arr[12]; let __v_63: G = __r_arr[13]; let __v_64: G = __r_arr[14]; let __v_65: G = __r_arr[15]; let __v_66: G = __r_arr[16]; let __v_67: G = __r_arr[17]; let __v_68: G = __r_arr[18]; let __v_69: G = __r_arr[19]; let __v_70: G = __r_arr[20]; let __v_71: G = __r_arr[21]; let __v_72: G = __r_arr[22]; let __v_73: G = __r_arr[23]; let __v_74: G = __r_arr[24]; let __v_75: G = __r_arr[25]; let __v_76: G = __r_arr[26]; let __v_77: G = __r_arr[27]; let __v_78: G = __r_arr[28]; let __v_79: G = __r_arr[29]; let __v_80: G = __r_arr[30]; let __v_81: G = __r_arr[31]; let __v_82: G = G::from_u64(256); let __v_83: G = __v_82 * __v_51; let __v_84: G = __v_50 + __v_83; let __v_85: G = G::from_u64(65536); let __v_86: G = __v_85 * __v_52; let __v_87: G = __v_84 + __v_86; let __v_88: G = G::from_u64(16777216); let __v_89: G = __v_88 * __v_53; let __v_90: G = __v_87 + __v_89; let __v_91: G = __v_82 * __v_55; let __v_92: G = __v_54 + __v_91; let __v_93: G = __v_85 * __v_56; let __v_94: G = __v_92 + __v_93; let __v_95: G = __v_88 * __v_57; let __v_96: G = __v_94 + __v_95; let __v_97: G = __v_82 * __v_59; let __v_98: G = __v_58 + __v_97; let __v_99: G = __v_85 * __v_60; let __v_100: G = __v_98 + __v_99; let __v_101: G = __v_88 * __v_61; let __v_102: G = __v_100 + __v_101; let __v_103: G = __v_82 * __v_63; let __v_104: G = __v_62 + __v_103; let __v_105: G = __v_85 * __v_64; let __v_106: G = __v_104 + __v_105; let __v_107: G = __v_88 * __v_65; let __v_108: G = __v_106 + __v_107; let __v_109: G = __v_82 * __v_67; let __v_110: G = __v_66 + __v_109; let __v_111: G = __v_85 * __v_68; let __v_112: G = __v_110 + __v_111; let __v_113: G = __v_88 * __v_69; let __v_114: G = __v_112 + __v_113; let __v_115: G = __v_82 * __v_71; let __v_116: G = __v_70 + __v_115; let __v_117: G = __v_85 * __v_72; let __v_118: G = __v_116 + __v_117; let __v_119: G = __v_88 * __v_73; let __v_120: G = __v_118 + __v_119; let __v_121: G = __v_82 * __v_75; let __v_122: G = __v_74 + __v_121; let __v_123: G = __v_85 * __v_76; let __v_124: G = __v_122 + __v_123; let __v_125: G = __v_88 * __v_77; let __v_126: G = __v_124 + __v_125; let __v_127: G = __v_82 * __v_79; let __v_128: G = __v_78 + __v_127; let __v_129: G = __v_85 * __v_80; let __v_130: G = __v_128 + __v_129; let __v_131: G = __v_88 * __v_81; let __v_132: G = __v_130 + __v_131; if (__v_90 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_96 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_102 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_108 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_108.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_114 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_114.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_120 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_120.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_126 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_126.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } if (__v_132 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_132.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr range: output statement digest mismatch".to_string()) }); } let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(295, &__args[..])?) { [G::ZERO; OUT_295] } else { let (__hash, __hit) = record.function_queries[295].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[295].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => { aiur_fn_295::(__args, __hash, record, io_buffer)? }, } } }; let __v_133: G = __r_arr[0]; let __v_134: G = __r_arr[1]; let __v_135: G = __r_arr[2]; let __v_136: G = __r_arr[3]; let __v_137: G = __r_arr[4]; let __v_138: G = __r_arr[5]; let __v_139: G = __r_arr[6]; let __v_140: G = __r_arr[7]; let __v_141: G = __r_arr[8]; let __v_142: G = __r_arr[9]; let __v_143: G = __r_arr[10]; let __v_144: G = __r_arr[11]; let __v_145: G = __r_arr[12]; let __v_146: G = __r_arr[13]; let __v_147: G = __r_arr[14]; let __v_148: G = __r_arr[15]; let __v_149: G = __r_arr[16]; let __v_150: G = __r_arr[17]; let __v_151: G = __r_arr[18]; let __ret: [G; OUT_306] = [__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]; record.function_queries[306].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_307: usize = 27; -const IN_307: usize = 27; -const OUT_307: usize = 19; -fn aiur_fn_307(inp: [G; IN_307], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_307], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(1); let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_27, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(282, &__args[..])?) { [G::ZERO; OUT_282] } else { let (__hash, __hit) = record.function_queries[282].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[282].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => { aiur_fn_282::(__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 __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(275, &__args[..])?) { [G::ZERO; OUT_275] } else { let (__hash, __hit) = record.function_queries[275].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[275].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => { aiur_fn_275::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(295, &__args[..])?) { [G::ZERO; OUT_295] } else { let (__hash, __hit) = record.function_queries[295].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[295].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => { aiur_fn_295::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; let __v_40: G = __r_arr[3]; let __v_41: G = __r_arr[4]; let __v_42: G = __r_arr[5]; let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; let __v_45: G = __r_arr[8]; let __v_46: G = __r_arr[9]; let __v_47: G = __r_arr[10]; let __v_48: G = __r_arr[11]; let __v_49: G = __r_arr[12]; let __v_50: G = __r_arr[13]; let __v_51: G = __r_arr[14]; let __v_52: G = __r_arr[15]; let __v_53: G = __r_arr[16]; let __v_54: G = __r_arr[17]; let __v_55: G = __r_arr[18]; let __ret: [G; OUT_307] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; record.function_queries[307].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_308: usize = 24; -const IN_308: usize = 24; -const OUT_308: usize = 0; -fn aiur_fn_308(inp: [G; IN_308], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_308], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(0); let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_24, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(280, &__args[..])?) { [G::ZERO; OUT_280] } else { let (__hash, __hit) = record.function_queries[280].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[280].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[280].bump_multiplicity(__i); } let __ret: [G; OUT_280] = unsafe { *(record.function_queries[280].output_at(__i).as_ptr() as *const [G; OUT_280]) }; __ret }, _ => { aiur_fn_280::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; let __v_28: G = __r_arr[3]; let __v_29: G = __r_arr[4]; let __v_30: G = __r_arr[5]; let __v_31: G = __r_arr[6]; let __v_32: G = __r_arr[7]; let __v_33: G = __r_arr[8]; let __v_34: G = __r_arr[9]; let __v_35: G = __r_arr[10]; let __v_36: G = __r_arr[11]; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; let __v_40: G = __r_arr[3]; let __v_41: G = __r_arr[4]; let __v_42: G = __r_arr[5]; let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; let __v_45: G = __r_arr[8]; let __v_46: G = __r_arr[9]; let __v_47: G = __r_arr[10]; let __v_48: G = __r_arr[11]; let __v_49: G = __r_arr[12]; let __v_50: G = __r_arr[13]; let __v_51: G = __r_arr[14]; let __v_52: G = __r_arr[15]; let __v_53: G = __r_arr[16]; let __v_54: G = __r_arr[17]; let __v_55: G = __r_arr[18]; let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_24, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(303, &__args[..])?) { [G::ZERO; OUT_303] } else { let (__hash, __hit) = record.function_queries[303].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[303].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[303].bump_multiplicity(__i); } let __ret: [G; OUT_303] = unsafe { *(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303]) }; __ret }, _ => { aiur_fn_303::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_56, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(304, &__args[..])?) { [G::ZERO; OUT_304] } else { let (__hash, __hit) = record.function_queries[304].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[304].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[304].bump_multiplicity(__i); } let __ret: [G; OUT_304] = unsafe { *(record.function_queries[304].output_at(__i).as_ptr() as *const [G; OUT_304]) }; __ret }, _ => { aiur_fn_304::(__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 = __r_arr[4]; let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_38, __v_39, __v_40, __v_41, __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 __cu = unconstrained; if ((!unconstrained) && record.defer_call(233, &__args[..])?) { [G::ZERO; OUT_233] } else { let (__hash, __hit) = record.function_queries[233].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[233].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => { aiur_fn_233::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = G::from_u64(1); if (__v_63 != __v_64) { return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_64.as_canonical_u64(), msg: Some("aggr range: the range ends before it starts".to_string()) }); } let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_65: G = __r_arr[0]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_66: G = __r_arr[0]; let __v_67: G = __v_66 - __v_65; let __io_pair: (G, G) = { let __key: [G; 1] = [__v_64]; let __info = io_buffer.get_info(__v_24, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_68: G = __io_pair.0; let __v_69: G = __io_pair.1; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_68]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_70: G = __r_arr[0]; let __v_71: G = __r_arr[1]; if (__v_70 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: Some("aggr range: proof count differs from the range".to_string()) }); } let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_56, __v_65]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(327, &__args[..])?) { [G::ZERO; OUT_327] } else { let (__hash, __hit) = record.function_queries[327].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[327].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => { aiur_fn_327::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_72, __v_71, __v_65, __v_67, __v_62, __v_58, __v_59, __v_60, __v_61, __v_24, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(305, &__args[..])?) { [G::ZERO; OUT_305] } else { let (__hash, __hit) = record.function_queries[305].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[305].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[305].bump_multiplicity(__i); } let __ret: [G; OUT_305] = unsafe { *(record.function_queries[305].output_at(__i).as_ptr() as *const [G; OUT_305]) }; __ret }, _ => { aiur_fn_305::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = __r_arr[1]; let __v_75: G = __r_arr[2]; let __v_76: G = __v_68 + __v_69; if (__v_75 != __v_76) { return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_76.as_canonical_u64(), msg: Some("aggr range: trailing bytes after the proofs".to_string()) }); } let __v_77: G = __v_73 - __v_54; let __v_78: G = G::from_bool(__v_77 == G::ZERO); let __v_79: G = __v_74 - __v_55; let __v_80: G = G::from_bool(__v_79 == G::ZERO); let __v_81: G = __v_78 * __v_80; if (__v_81 != __v_64) { return Err(ExecError::AssertEqMismatch { lhs: __v_81.as_canonical_u64(), rhs: __v_64.as_canonical_u64(), msg: Some("aggr range: residual sum differs from the statement".to_string()) }); } let __ret: [G; OUT_308] = []; record.function_queries[308].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_309: usize = 34; -const IN_309: usize = 34; -const OUT_309: usize = 0; -fn aiur_fn_309(inp: [G; IN_309], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_309], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(0); let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_34, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(307, &__args[..])?) { [G::ZERO; OUT_307] } else { let (__hash, __hit) = record.function_queries[307].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[307].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[307].bump_multiplicity(__i); } let __ret: [G; OUT_307] = unsafe { *(record.function_queries[307].output_at(__i).as_ptr() as *const [G; OUT_307]) }; __ret }, _ => { aiur_fn_307::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = __r_arr[2]; let __v_38: G = __r_arr[3]; let __v_39: G = __r_arr[4]; let __v_40: G = __r_arr[5]; let __v_41: G = __r_arr[6]; let __v_42: G = __r_arr[7]; let __v_43: G = __r_arr[8]; let __v_44: G = __r_arr[9]; let __v_45: G = __r_arr[10]; let __v_46: G = __r_arr[11]; let __v_47: G = __r_arr[12]; let __v_48: G = __r_arr[13]; let __v_49: G = __r_arr[14]; let __v_50: G = __r_arr[15]; let __v_51: G = __r_arr[16]; let __v_52: G = __r_arr[17]; let __v_53: G = __r_arr[18]; let __v_54: G = G::from_u64(1); let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_54, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(307, &__args[..])?) { [G::ZERO; OUT_307] } else { let (__hash, __hit) = record.function_queries[307].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[307].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[307].bump_multiplicity(__i); } let __ret: [G; OUT_307] = unsafe { *(record.function_queries[307].output_at(__i).as_ptr() as *const [G; OUT_307]) }; __ret }, _ => { aiur_fn_307::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; let __v_58: G = __r_arr[3]; let __v_59: G = __r_arr[4]; let __v_60: G = __r_arr[5]; let __v_61: G = __r_arr[6]; let __v_62: G = __r_arr[7]; let __v_63: G = __r_arr[8]; let __v_64: G = __r_arr[9]; let __v_65: G = __r_arr[10]; let __v_66: G = __r_arr[11]; let __v_67: G = __r_arr[12]; let __v_68: G = __r_arr[13]; let __v_69: G = __r_arr[14]; let __v_70: G = __r_arr[15]; let __v_71: G = __r_arr[16]; let __v_72: G = __r_arr[17]; let __v_73: G = __r_arr[18]; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__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 = __r_arr[5]; let __v_80: G = __r_arr[6]; let __v_81: G = __r_arr[7]; let __v_82: G = __r_arr[8]; let __v_83: G = __r_arr[9]; let __v_84: G = __r_arr[10]; let __v_85: G = __r_arr[11]; let __v_86: G = __r_arr[12]; let __v_87: G = __r_arr[13]; let __v_88: G = __r_arr[14]; let __v_89: G = __r_arr[15]; let __v_90: G = __r_arr[16]; let __v_91: G = __r_arr[17]; let __v_92: G = __r_arr[18]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_35, __v_55]; 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_93: G = __r_arr[0]; if (__v_93 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_93.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: Some("aggr range: children verify different batches".to_string()) }); } let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_74, __v_35]; 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_94: G = __r_arr[0]; if (__v_94 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: Some("aggr range: output names a different batch than the children".to_string()) }); } let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_95: G = __r_arr[0]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_96: G = __r_arr[0]; if (__v_95 != __v_96) { return Err(ExecError::AssertEqMismatch { lhs: __v_95.as_canonical_u64(), rhs: __v_96.as_canonical_u64(), msg: Some("aggr range: children are not adjacent".to_string()) }); } let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_97: G = __r_arr[0]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_98: G = __r_arr[0]; if (__v_97 != __v_98) { return Err(ExecError::AssertEqMismatch { lhs: __v_97.as_canonical_u64(), rhs: __v_98.as_canonical_u64(), msg: Some("aggr range: output starts elsewhere than the left child".to_string()) }); } let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_99: G = __r_arr[0]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; if (__v_99 != __v_100) { return Err(ExecError::AssertEqMismatch { lhs: __v_99.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: Some("aggr range: output ends elsewhere than the right child".to_string()) }); } let __v_101: G = __v_52 + __v_72; let __v_102: G = __v_53 + __v_73; let __v_103: G = __v_101 - __v_91; let __v_104: G = G::from_bool(__v_103 == G::ZERO); let __v_105: G = __v_102 - __v_92; let __v_106: G = G::from_bool(__v_105 == G::ZERO); let __v_107: G = __v_104 * __v_106; if (__v_107 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_107.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: Some("aggr range: output residual is not the children's sum".to_string()) }); } let __ret: [G; OUT_309] = []; record.function_queries[309].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_310: usize = 34; -const IN_310: usize = 34; -const OUT_310: usize = 0; -fn aiur_fn_310(inp: [G; IN_310], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_310], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(0); let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_34, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(307, &__args[..])?) { [G::ZERO; OUT_307] } else { let (__hash, __hit) = record.function_queries[307].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[307].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[307].bump_multiplicity(__i); } let __ret: [G; OUT_307] = unsafe { *(record.function_queries[307].output_at(__i).as_ptr() as *const [G; OUT_307]) }; __ret }, _ => { aiur_fn_307::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = __r_arr[2]; let __v_38: G = __r_arr[3]; let __v_39: G = __r_arr[4]; let __v_40: G = __r_arr[5]; let __v_41: G = __r_arr[6]; let __v_42: G = __r_arr[7]; let __v_43: G = __r_arr[8]; let __v_44: G = __r_arr[9]; let __v_45: G = __r_arr[10]; let __v_46: G = __r_arr[11]; let __v_47: G = __r_arr[12]; let __v_48: G = __r_arr[13]; let __v_49: G = __r_arr[14]; let __v_50: G = __r_arr[15]; let __v_51: G = __r_arr[16]; let __v_52: G = __r_arr[17]; let __v_53: G = __r_arr[18]; let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_34, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(280, &__args[..])?) { [G::ZERO; OUT_280] } else { let (__hash, __hit) = record.function_queries[280].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[280].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[280].bump_multiplicity(__i); } let __ret: [G; OUT_280] = unsafe { *(record.function_queries[280].output_at(__i).as_ptr() as *const [G; OUT_280]) }; __ret }, _ => { aiur_fn_280::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; let __v_57: G = __r_arr[3]; let __v_58: G = __r_arr[4]; let __v_59: G = __r_arr[5]; let __v_60: G = __r_arr[6]; let __v_61: G = __r_arr[7]; let __v_62: G = __r_arr[8]; let __v_63: G = __r_arr[9]; let __v_64: G = __r_arr[10]; let __v_65: G = __r_arr[11]; let __v_66: G = G::from_u64(1); let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_66, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(303, &__args[..])?) { [G::ZERO; OUT_303] } else { let (__hash, __hit) = record.function_queries[303].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[303].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[303].bump_multiplicity(__i); } let __ret: [G; OUT_303] = unsafe { *(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303]) }; __ret }, _ => { aiur_fn_303::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_67]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(317, &__args[..])?) { [G::ZERO; OUT_317] } else { let (__hash, __hit) = record.function_queries[317].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[317].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[317].bump_multiplicity(__i); } let __ret: [G; OUT_317] = unsafe { *(record.function_queries[317].output_at(__i).as_ptr() as *const [G; OUT_317]) }; __ret }, _ => { aiur_fn_317::(__args, __hash, record, io_buffer)? }, } } }; let __v_69: G = __r_arr[0]; let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_69]; 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_70: G = __r_arr[0]; if (__v_70 != __v_66) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_71: G = __r_arr[0]; if (__v_71 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("aggr range: root range does not start at shard 0".to_string()) }); } let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; if (__v_72 != __v_69) { return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_69.as_canonical_u64(), msg: Some("aggr range: root range does not end at the last shard".to_string()) }); } let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_68, __v_34, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; if (__v_73 != __v_66) { return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__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_67, __v_68]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(304, &__args[..])?) { [G::ZERO; OUT_304] } else { let (__hash, __hit) = record.function_queries[304].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[304].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[304].bump_multiplicity(__i); } let __ret: [G; OUT_304] = unsafe { *(record.function_queries[304].output_at(__i).as_ptr() as *const [G; OUT_304]) }; __ret }, _ => { aiur_fn_304::(__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 __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_52, __v_53, __v_68, __v_74, __v_75, __v_76, __v_77]; 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_79: G = __r_arr[0]; let __v_80: G = __r_arr[1]; let __v_81: G = G::from_bool(__v_79 == G::ZERO); let __v_82: G = G::from_bool(__v_80 == G::ZERO); let __v_83: G = __v_81 * __v_82; if (__v_83 != __v_66) { return Err(ExecError::AssertEqMismatch { lhs: __v_83.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: Some("aggr range: the batch does not balance".to_string()) }); } let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_67]; 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_84: G = __r_arr[0]; let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_84]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(279, &__args[..])?) { [G::ZERO; OUT_279] } else { let (__hash, __hit) = record.function_queries[279].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[279].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[279].bump_multiplicity(__i); } let __ret: [G; OUT_279] = unsafe { *(record.function_queries[279].output_at(__i).as_ptr() as *const [G; OUT_279]) }; __ret }, _ => { aiur_fn_279::(__args, __hash, record, io_buffer)? }, } } }; let __v_85: G = __r_arr[0]; let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_85]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(319, &__args[..])?) { [G::ZERO; OUT_319] } else { let (__hash, __hit) = record.function_queries[319].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[319].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[319].bump_multiplicity(__i); } let __ret: [G; OUT_319] = unsafe { *(record.function_queries[319].output_at(__i).as_ptr() as *const [G; OUT_319]) }; __ret }, _ => { aiur_fn_319::(__args, __hash, record, io_buffer)? }, } } }; let __v_86: G = __r_arr[0]; let __v_87: G = G::from_u64(10); if (__v_86 != __v_87) { return Err(ExecError::AssertEqMismatch { lhs: __v_86.as_canonical_u64(), rhs: __v_87.as_canonical_u64(), msg: Some("aggr range: batch must carry a 10-word verify_claim claim".to_string()) }); } let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_85, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(276, &__args[..])?) { [G::ZERO; OUT_276] } else { let (__hash, __hit) = record.function_queries[276].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[276].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => { aiur_fn_276::(__args, __hash, record, io_buffer)? }, } } }; let __v_88: G = __r_arr[0]; if (__v_88 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("aggr range: batch claim has the wrong channel".to_string()) }); } let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_85, __v_66]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(276, &__args[..])?) { [G::ZERO; OUT_276] } else { let (__hash, __hit) = record.function_queries[276].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[276].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => { aiur_fn_276::(__args, __hash, record, io_buffer)? }, } } }; let __v_89: G = __r_arr[0]; if (__v_89 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("aggr range: batch claim has the wrong entrypoint".to_string()) }); } let __v_90: G = G::from_u64(2); let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_85, __v_90]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(277, &__args[..])?) { [G::ZERO; OUT_277] } else { let (__hash, __hit) = record.function_queries[277].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[277].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => { aiur_fn_277::(__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 __v_94: G = __r_arr[3]; let __v_95: G = __r_arr[4]; let __v_96: G = __r_arr[5]; let __v_97: G = __r_arr[6]; let __v_98: G = __r_arr[7]; let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(278, &__args[..])?) { [G::ZERO; OUT_278] } else { let (__hash, __hit) = record.function_queries[278].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[278].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[278].bump_multiplicity(__i); } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => { aiur_fn_278::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_310] = []; record.function_queries[310].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_311: usize = 16; -const IN_311: usize = 16; -const OUT_311: usize = 0; -fn aiur_fn_311(inp: [G; IN_311], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_311], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(3); let __v_17: G = G::from_u64(0); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_17]; let __info = io_buffer.get_info(__v_16, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_18: G = __io_pair.0; let __v_19: G = __io_pair.1; let __v_20: G = G::from_u64(80); if (__v_19 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("aggr: allowed blob must be exactly 80 bytes".to_string()) }); } let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_16, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(3, &__args[..])?) { [G::ZERO; OUT_3] } else { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[3].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[3].bump_multiplicity(__i); } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(103); let __v_23: G = G::from_u64(230); let __v_24: G = G::from_u64(9); let __v_25: G = G::from_u64(106); let __v_26: G = G::from_u64(133); let __v_27: G = G::from_u64(174); let __v_28: G = G::from_u64(187); let __v_29: G = G::from_u64(114); let __v_30: G = G::from_u64(243); let __v_31: G = G::from_u64(110); let __v_32: G = G::from_u64(60); let __v_33: G = G::from_u64(58); let __v_34: G = G::from_u64(245); let __v_35: G = G::from_u64(79); let __v_36: G = G::from_u64(165); let __v_37: G = G::from_u64(127); let __v_38: G = G::from_u64(82); let __v_39: G = G::from_u64(14); let __v_40: G = G::from_u64(81); let __v_41: G = G::from_u64(140); let __v_42: G = G::from_u64(104); let __v_43: G = G::from_u64(5); let __v_44: G = G::from_u64(155); let __v_45: G = G::from_u64(171); let __v_46: G = G::from_u64(217); let __v_47: G = G::from_u64(131); let __v_48: G = G::from_u64(31); let __v_49: G = G::from_u64(25); let __v_50: G = G::from_u64(205); let __v_51: G = G::from_u64(224); let __v_52: G = G::from_u64(91); let __v_53: G = G::from_u64(1); let __v_54: G = { let __values: [G; 3] = [__v_53, __v_53, __v_53]; 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_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; 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_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_22, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __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]; 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_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53]; 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_78] = { let __args: [G; IN_78] = [__v_21, __v_54, __v_17, __v_17, __v_55, __v_56, __v_57]; 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_58: G = __r_arr[0]; let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_58]; 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_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 = __v_59 + __v_92; let __v_94: G = G::from_u64(65536); let __v_95: G = __v_94 * __v_61; let __v_96: G = __v_93 + __v_95; let __v_97: G = G::from_u64(16777216); let __v_98: G = __v_97 * __v_62; let __v_99: G = __v_96 + __v_98; let __v_100: G = __v_91 * __v_64; let __v_101: G = __v_63 + __v_100; let __v_102: G = __v_94 * __v_65; let __v_103: G = __v_101 + __v_102; let __v_104: G = __v_97 * __v_66; let __v_105: G = __v_103 + __v_104; let __v_106: G = __v_91 * __v_68; let __v_107: G = __v_67 + __v_106; let __v_108: G = __v_94 * __v_69; let __v_109: G = __v_107 + __v_108; let __v_110: G = __v_97 * __v_70; let __v_111: G = __v_109 + __v_110; let __v_112: G = __v_91 * __v_72; let __v_113: G = __v_71 + __v_112; let __v_114: G = __v_94 * __v_73; let __v_115: G = __v_113 + __v_114; let __v_116: G = __v_97 * __v_74; let __v_117: G = __v_115 + __v_116; let __v_118: G = __v_91 * __v_76; let __v_119: G = __v_75 + __v_118; let __v_120: G = __v_94 * __v_77; let __v_121: G = __v_119 + __v_120; let __v_122: G = __v_97 * __v_78; let __v_123: G = __v_121 + __v_122; let __v_124: G = __v_91 * __v_80; let __v_125: G = __v_79 + __v_124; let __v_126: G = __v_94 * __v_81; let __v_127: G = __v_125 + __v_126; let __v_128: G = __v_97 * __v_82; let __v_129: G = __v_127 + __v_128; let __v_130: G = __v_91 * __v_84; let __v_131: G = __v_83 + __v_130; let __v_132: G = __v_94 * __v_85; let __v_133: G = __v_131 + __v_132; let __v_134: G = __v_97 * __v_86; let __v_135: G = __v_133 + __v_134; let __v_136: G = __v_91 * __v_88; let __v_137: G = __v_87 + __v_136; let __v_138: G = __v_94 * __v_89; let __v_139: G = __v_137 + __v_138; let __v_140: G = __v_97 * __v_90; let __v_141: G = __v_139 + __v_140; if (__v_99 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_99.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_105 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_105.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_111 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_111.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_117 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_117.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_123 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_129 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_129.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_135 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_135.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } if (__v_141 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_21]; 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_142: G = __r_arr[0]; let __v_143: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_143]; 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_144: G = __r_arr[0]; let __v_145: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_145]; 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_146: G = __r_arr[0]; let __v_147: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_147]; 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_148: G = __r_arr[0]; let __v_149: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_149]; 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_150: G = __r_arr[0]; let __v_151: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_151]; 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_152: G = __r_arr[0]; let __v_153: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_153]; 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_154: G = __r_arr[0]; let __v_155: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_155]; 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_156: G = __r_arr[0]; let __v_157: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_157]; 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_158: G = __r_arr[0]; let __v_159: G = __r_arr[1]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_159]; 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_160: G = __r_arr[0]; let __v_161: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_161]; 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_162: G = __r_arr[0]; let __v_163: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_163]; 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_164: G = __r_arr[0]; let __v_165: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_165]; 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_166: G = __r_arr[0]; let __v_167: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_167]; 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_168: G = __r_arr[0]; let __v_169: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_169]; 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_170: G = __r_arr[0]; let __v_171: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_171]; 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_172: G = __r_arr[0]; let __v_173: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_173]; 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_174: G = __r_arr[0]; let __v_175: G = __r_arr[1]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_175]; 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_176: G = __r_arr[0]; let __v_177: 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_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]; if (__v_178 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_178.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: allowed blob must be exactly 80 bytes".to_string()) }); } if (__v_179 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: allowed blob must be exactly 80 bytes".to_string()) }); } if (__v_180 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_180.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: allowed blob must be exactly 80 bytes".to_string()) }); } let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_142]; 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_181: G = __r_arr[0]; let __v_182: G = __r_arr[1]; let __v_183: G = __r_arr[2]; let __v_184: G = __r_arr[3]; let __v_185: G = __r_arr[4]; let __v_186: G = __r_arr[5]; let __v_187: G = __r_arr[6]; let __v_188: G = __r_arr[7]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_160]; 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_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 __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_144, __v_146, __v_148, __v_150, __v_152, __v_154, __v_156, __v_158]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_197: G = __r_arr[0]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_162, __v_164, __v_166, __v_168, __v_170, __v_172, __v_174, __v_176]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_198: G = __r_arr[0]; let __v_199: G = G::from_u64(6); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_17]; let __info = io_buffer.get_info(__v_199, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_200: G = __io_pair.0; let __v_201: G = __io_pair.1; if (__v_201 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_201.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: shape hint must be exactly one byte".to_string()) }); } let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_199, __v_200, __v_201]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(3, &__args[..])?) { [G::ZERO; OUT_3] } else { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[3].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[3].bump_multiplicity(__i); } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_202: G = __r_arr[0]; let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_202]; 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_203: G = __r_arr[0]; let __v_204: 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_204.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_205: G = __loaded[0]; let __v_206: G = __loaded[1]; let __v_207: G = __loaded[2]; if (__v_205 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_205.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: trailing bytes after shape hint".to_string()) }); } if (__v_206 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_206.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: trailing bytes after shape hint".to_string()) }); } if (__v_207 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_207.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("aggr: trailing bytes after shape hint".to_string()) }); } match __v_203.as_canonical_u64() { 0u64 => { let __v_208: G = G::from_u64(0); let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_208, __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_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_311] = []; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_208: G = G::from_u64(1); let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_208, __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_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_311] = []; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_208: G = G::from_u64(0); let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_208, __v_208, __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_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(284, &__args[..])?) { [G::ZERO; OUT_284] } else { let (__hash, __hit) = record.function_queries[284].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[284].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[284].bump_multiplicity(__i); } let __ret: [G; OUT_284] = unsafe { *(record.function_queries[284].output_at(__i).as_ptr() as *const [G; OUT_284]) }; __ret }, _ => { aiur_fn_284::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_311] = []; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_208: G = G::from_u64(0); let __v_209: G = G::from_u64(1); let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_208, __v_209, __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_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(284, &__args[..])?) { [G::ZERO; OUT_284] } else { let (__hash, __hit) = record.function_queries[284].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[284].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[284].bump_multiplicity(__i); } let __ret: [G; OUT_284] = unsafe { *(record.function_queries[284].output_at(__i).as_ptr() as *const [G; OUT_284]) }; __ret }, _ => { aiur_fn_284::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_311] = []; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_208: G = G::from_u64(1); let __v_209: G = G::from_u64(0); let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_208, __v_209, __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_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(284, &__args[..])?) { [G::ZERO; OUT_284] } else { let (__hash, __hit) = record.function_queries[284].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[284].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[284].bump_multiplicity(__i); } let __ret: [G; OUT_284] = unsafe { *(record.function_queries[284].output_at(__i).as_ptr() as *const [G; OUT_284]) }; __ret }, _ => { aiur_fn_284::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_311] = []; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_208: G = G::from_u64(1); let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_208, __v_208, __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_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(284, &__args[..])?) { [G::ZERO; OUT_284] } else { let (__hash, __hit) = record.function_queries[284].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[284].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[284].bump_multiplicity(__i); } let __ret: [G; OUT_284] = unsafe { *(record.function_queries[284].output_at(__i).as_ptr() as *const [G; OUT_284]) }; __ret }, _ => { aiur_fn_284::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_311] = []; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_208: G = G::from_u64(0); let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_208, __v_208, __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_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(285, &__args[..])?) { [G::ZERO; OUT_285] } else { let (__hash, __hit) = record.function_queries[285].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[285].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[285].bump_multiplicity(__i); } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => { aiur_fn_285::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_311] = []; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_208: G = G::from_u64(0); let __v_209: G = G::from_u64(1); let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_208, __v_209, __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_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(285, &__args[..])?) { [G::ZERO; OUT_285] } else { let (__hash, __hit) = record.function_queries[285].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[285].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[285].bump_multiplicity(__i); } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => { aiur_fn_285::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_311] = []; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_208: G = G::from_u64(1); let __v_209: G = G::from_u64(0); let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_208, __v_209, __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_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(285, &__args[..])?) { [G::ZERO; OUT_285] } else { let (__hash, __hit) = record.function_queries[285].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[285].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[285].bump_multiplicity(__i); } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => { aiur_fn_285::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_311] = []; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_208: G = G::from_u64(1); let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_208, __v_208, __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_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(285, &__args[..])?) { [G::ZERO; OUT_285] } else { let (__hash, __hit) = record.function_queries[285].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[285].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[285].bump_multiplicity(__i); } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => { aiur_fn_285::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_311] = []; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__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_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(308, &__args[..])?) { [G::ZERO; OUT_308] } else { let (__hash, __hit) = record.function_queries[308].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[308].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[308].bump_multiplicity(__i); } let __ret: [G; OUT_308] = unsafe { *(record.function_queries[308].output_at(__i).as_ptr() as *const [G; OUT_308]) }; __ret }, _ => { aiur_fn_308::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_311] = []; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__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_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(309, &__args[..])?) { [G::ZERO; OUT_309] } else { let (__hash, __hit) = record.function_queries[309].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[309].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[309].bump_multiplicity(__i); } let __ret: [G; OUT_309] = unsafe { *(record.function_queries[309].output_at(__i).as_ptr() as *const [G; OUT_309]) }; __ret }, _ => { aiur_fn_309::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_311] = []; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__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_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(310, &__args[..])?) { [G::ZERO; OUT_310] } else { let (__hash, __hit) = record.function_queries[310].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[310].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => { aiur_fn_310::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_311] = []; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __v_208: G = G::from_u64(0); let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_208, __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_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(286, &__args[..])?) { [G::ZERO; OUT_286] } else { let (__hash, __hit) = record.function_queries[286].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[286].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[286].bump_multiplicity(__i); } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => { aiur_fn_286::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_311] = []; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __v_208: G = G::from_u64(1); let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_208, __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_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(286, &__args[..])?) { [G::ZERO; OUT_286] } else { let (__hash, __hit) = record.function_queries[286].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[286].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[286].bump_multiplicity(__i); } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => { aiur_fn_286::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_311] = []; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 15u64 => { let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__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_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(292, &__args[..])?) { [G::ZERO; OUT_292] } else { let (__hash, __hit) = record.function_queries[292].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[292].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => { aiur_fn_292::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_311] = []; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 16u64 => { let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__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_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(294, &__args[..])?) { [G::ZERO; OUT_294] } else { let (__hash, __hit) = record.function_queries[294].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[294].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => { aiur_fn_294::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_311] = []; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_203.as_canonical_u64())); }, } }) } -const INPUT_SIZE_312: usize = 2; -const IN_312: usize = 2; -const OUT_312: usize = 1; -fn aiur_fn_312(inp: [G; IN_312], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_312], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(326, &__args[..])?) { [G::ZERO; OUT_326] } else { let (__hash, __hit) = record.function_queries[326].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[326].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[326].bump_multiplicity(__i); } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => { aiur_fn_326::(__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_312] = [__v_4]; record.function_queries[312].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_313: usize = 1; -const IN_313: usize = 1; -const OUT_313: usize = 1; -fn aiur_fn_313(inp: [G; IN_313], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_313], ExecError> { stacker::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_313] = [__v_27]; record.function_queries[313].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(313, &__args[..])?) { [G::ZERO; OUT_313] } else { let (__hash, __hit) = record.function_queries[313].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[313].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[313].bump_multiplicity(__i); } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => { aiur_fn_313::(__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_313] = [__v_29]; record.function_queries[313].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_314: usize = 1; -const IN_314: usize = 1; -const OUT_314: usize = 1; -fn aiur_fn_314(inp: [G; IN_314], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_314], ExecError> { stacker::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_314] = [__v_4]; record.function_queries[314].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__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_314] = [__v_6]; record.function_queries[314].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_315: usize = 1; -const IN_315: usize = 1; -const OUT_315: usize = 1; -fn aiur_fn_315(inp: [G; IN_315], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_315], ExecError> { stacker::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_315] = [__v_5]; record.function_queries[315].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(315, &__args[..])?) { [G::ZERO; OUT_315] } else { let (__hash, __hit) = record.function_queries[315].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[315].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => { aiur_fn_315::(__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_315] = [__v_7]; record.function_queries[315].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_316: usize = 2; -const IN_316: usize = 2; -const OUT_316: usize = 1; -fn aiur_fn_316(inp: [G; IN_316], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_316], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_316] = [__v_1]; record.function_queries[316].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__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_316] = [__v_7]; record.function_queries[316].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_317: usize = 1; -const IN_317: usize = 1; -const OUT_317: usize = 1; -fn aiur_fn_317(inp: [G; IN_317], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_317], ExecError> { stacker::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_317] = [__v_7]; record.function_queries[317].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(317, &__args[..])?) { [G::ZERO; OUT_317] } else { let (__hash, __hit) = record.function_queries[317].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[317].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[317].bump_multiplicity(__i); } let __ret: [G; OUT_317] = unsafe { *(record.function_queries[317].output_at(__i).as_ptr() as *const [G; OUT_317]) }; __ret }, _ => { aiur_fn_317::(__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_317] = [__v_9]; record.function_queries[317].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_318: usize = 1; -const IN_318: usize = 1; -const OUT_318: usize = 1; -fn aiur_fn_318(inp: [G; IN_318], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_318], ExecError> { stacker::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_318] = [__v_8]; record.function_queries[318].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(318, &__args[..])?) { [G::ZERO; OUT_318] } else { let (__hash, __hit) = record.function_queries[318].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[318].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[318].bump_multiplicity(__i); } let __ret: [G; OUT_318] = unsafe { *(record.function_queries[318].output_at(__i).as_ptr() as *const [G; OUT_318]) }; __ret }, _ => { aiur_fn_318::(__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_318] = [__v_10]; record.function_queries[318].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_319: usize = 1; -const IN_319: usize = 1; -const OUT_319: usize = 1; -fn aiur_fn_319(inp: [G; IN_319], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_319], ExecError> { stacker::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_319] = [__v_11]; record.function_queries[319].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(319, &__args[..])?) { [G::ZERO; OUT_319] } else { let (__hash, __hit) = record.function_queries[319].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[319].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[319].bump_multiplicity(__i); } let __ret: [G; OUT_319] = unsafe { *(record.function_queries[319].output_at(__i).as_ptr() as *const [G; OUT_319]) }; __ret }, _ => { aiur_fn_319::(__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_319] = [__v_13]; record.function_queries[319].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_320: usize = 1; -const IN_320: usize = 1; -const OUT_320: usize = 1; -fn aiur_fn_320(inp: [G; IN_320], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_320], ExecError> { stacker::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_320] = [__v_12]; record.function_queries[320].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__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_320] = [__v_14]; record.function_queries[320].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_321: usize = 2; -const IN_321: usize = 2; -const OUT_321: usize = 4; -fn aiur_fn_321(inp: [G; IN_321], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_321], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_327] = { let __args: [G; IN_327] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(327, &__args[..])?) { [G::ZERO; OUT_327] } else { let (__hash, __hit) = record.function_queries[327].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[327].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => { aiur_fn_327::(__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_321] = [__v_4, __v_5, __v_6, __v_7]; record.function_queries[321].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_322: usize = 1; -const IN_322: usize = 1; -const OUT_322: usize = 1; -fn aiur_fn_322(inp: [G; IN_322], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_322], ExecError> { stacker::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_322] = [__v_4]; record.function_queries[322].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_322] = [__v_4]; record.function_queries[322].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_323: usize = 2; -const IN_323: usize = 2; -const OUT_323: usize = 2; -fn aiur_fn_323(inp: [G; IN_323], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_323], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_329] = { let __args: [G; IN_329] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(329, &__args[..])?) { [G::ZERO; OUT_329] } else { let (__hash, __hit) = record.function_queries[329].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[329].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => { aiur_fn_329::(__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_323] = [__v_4, __v_5]; record.function_queries[323].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_324: usize = 2; -const IN_324: usize = 2; -const OUT_324: usize = 1; -fn aiur_fn_324(inp: [G; IN_324], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_324], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_324] = [__v_1]; record.function_queries[324].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_11, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(324, &__args[..])?) { [G::ZERO; OUT_324] } else { let (__hash, __hit) = record.function_queries[324].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[324].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => { aiur_fn_324::(__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_324] = [__v_14]; record.function_queries[324].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_325: usize = 1; -const IN_325: usize = 1; -const OUT_325: usize = 1; -fn aiur_fn_325(inp: [G; IN_325], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_325], ExecError> { stacker::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_325] = [__v_6]; record.function_queries[325].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(325, &__args[..])?) { [G::ZERO; OUT_325] } else { let (__hash, __hit) = record.function_queries[325].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[325].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[325].bump_multiplicity(__i); } let __ret: [G; OUT_325] = unsafe { *(record.function_queries[325].output_at(__i).as_ptr() as *const [G; OUT_325]) }; __ret }, _ => { aiur_fn_325::(__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_325] = [__v_8]; record.function_queries[325].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_326: usize = 2; -const IN_326: usize = 2; -const OUT_326: usize = 1; -fn aiur_fn_326(inp: [G; IN_326], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_326], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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_326] = [__v_0]; record.function_queries[326].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_326] = { let __args: [G; IN_326] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(326, &__args[..])?) { [G::ZERO; OUT_326] } else { let (__hash, __hit) = record.function_queries[326].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[326].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[326].bump_multiplicity(__i); } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => { aiur_fn_326::(__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_326] = [__v_7]; record.function_queries[326].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_327: usize = 2; -const IN_327: usize = 2; -const OUT_327: usize = 1; -fn aiur_fn_327(inp: [G; IN_327], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_327], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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_327] = [__v_0]; record.function_queries[327].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_327] = { let __args: [G; IN_327] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(327, &__args[..])?) { [G::ZERO; OUT_327] } else { let (__hash, __hit) = record.function_queries[327].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[327].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => { aiur_fn_327::(__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_327] = [__v_10]; record.function_queries[327].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_328: usize = 2; -const IN_328: usize = 2; -const OUT_328: usize = 8; -fn aiur_fn_328(inp: [G; IN_328], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_328], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_330] = { let __args: [G; IN_330] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(330, &__args[..])?) { [G::ZERO; OUT_330] } else { let (__hash, __hit) = record.function_queries[330].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[330].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[330].bump_multiplicity(__i); } let __ret: [G; OUT_330] = unsafe { *(record.function_queries[330].output_at(__i).as_ptr() as *const [G; OUT_330]) }; __ret }, _ => { aiur_fn_330::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[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_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() { 0u64 => { let __ret: [G; OUT_328] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[328].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_329: usize = 2; -const IN_329: usize = 2; -const OUT_329: usize = 1; -fn aiur_fn_329(inp: [G; IN_329], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_329], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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_329] = [__v_0]; record.function_queries[329].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_329] = { let __args: [G; IN_329] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(329, &__args[..])?) { [G::ZERO; OUT_329] } else { let (__hash, __hit) = record.function_queries[329].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[329].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => { aiur_fn_329::(__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_329] = [__v_8]; record.function_queries[329].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_330: usize = 2; -const IN_330: usize = 2; -const OUT_330: usize = 1; -fn aiur_fn_330(inp: [G; IN_330], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_330], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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_330] = [__v_0]; record.function_queries[330].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_330] = { let __args: [G; IN_330] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(330, &__args[..])?) { [G::ZERO; OUT_330] } else { let (__hash, __hit) = record.function_queries[330].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[330].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[330].bump_multiplicity(__i); } let __ret: [G; OUT_330] = unsafe { *(record.function_queries[330].output_at(__i).as_ptr() as *const [G; OUT_330]) }; __ret }, _ => { aiur_fn_330::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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_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_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]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_330] = [__v_14]; record.function_queries[330].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()); }, 256u64 => { let __inp: [G; IN_256] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_256::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 257u64 => { let __inp: [G; IN_257] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_257::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 258u64 => { let __inp: [G; IN_258] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_258::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 259u64 => { let __inp: [G; IN_259] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_259::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 260u64 => { let __inp: [G; IN_260] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_260::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 261u64 => { let __inp: [G; IN_261] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_261::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 262u64 => { let __inp: [G; IN_262] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_262::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 263u64 => { let __inp: [G; IN_263] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_263::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 264u64 => { let __inp: [G; IN_264] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_264::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 265u64 => { let __inp: [G; IN_265] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_265::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 266u64 => { let __inp: [G; IN_266] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_266::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 267u64 => { let __inp: [G; IN_267] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_267::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 268u64 => { let __inp: [G; IN_268] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_268::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 269u64 => { let __inp: [G; IN_269] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_269::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 270u64 => { let __inp: [G; IN_270] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_270::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 271u64 => { let __inp: [G; IN_271] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_271::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 272u64 => { let __inp: [G; IN_272] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_272::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 273u64 => { let __inp: [G; IN_273] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_273::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 274u64 => { let __inp: [G; IN_274] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_274::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 275u64 => { let __inp: [G; IN_275] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_275::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 276u64 => { let __inp: [G; IN_276] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_276::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 277u64 => { let __inp: [G; IN_277] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_277::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 278u64 => { let __inp: [G; IN_278] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_278::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 279u64 => { let __inp: [G; IN_279] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_279::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 280u64 => { let __inp: [G; IN_280] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_280::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 281u64 => { let __inp: [G; IN_281] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_281::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 282u64 => { let __inp: [G; IN_282] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_282::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 283u64 => { let __inp: [G; IN_283] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_283::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 284u64 => { let __inp: [G; IN_284] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_284::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 285u64 => { let __inp: [G; IN_285] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_285::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 286u64 => { let __inp: [G; IN_286] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_286::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 287u64 => { let __inp: [G; IN_287] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_287::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 288u64 => { let __inp: [G; IN_288] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_288::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 289u64 => { let __inp: [G; IN_289] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_289::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 290u64 => { let __inp: [G; IN_290] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_290::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 291u64 => { let __inp: [G; IN_291] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_291::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 292u64 => { let __inp: [G; IN_292] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_292::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 293u64 => { let __inp: [G; IN_293] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_293::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 294u64 => { let __inp: [G; IN_294] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_294::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 295u64 => { let __inp: [G; IN_295] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_295::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 296u64 => { let __inp: [G; IN_296] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_296::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 297u64 => { let __inp: [G; IN_297] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_297::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 298u64 => { let __inp: [G; IN_298] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_298::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 299u64 => { let __inp: [G; IN_299] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_299::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 300u64 => { let __inp: [G; IN_300] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_300::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 301u64 => { let __inp: [G; IN_301] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_301::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 302u64 => { let __inp: [G; IN_302] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_302::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 303u64 => { let __inp: [G; IN_303] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_303::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 304u64 => { let __inp: [G; IN_304] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_304::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 305u64 => { let __inp: [G; IN_305] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_305::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 306u64 => { let __inp: [G; IN_306] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_306::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 307u64 => { let __inp: [G; IN_307] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_307::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 308u64 => { let __inp: [G; IN_308] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_308::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 309u64 => { let __inp: [G; IN_309] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_309::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 310u64 => { let __inp: [G; IN_310] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_310::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 311u64 => { let __inp: [G; IN_311] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_311::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 312u64 => { let __inp: [G; IN_312] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_312::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 313u64 => { let __inp: [G; IN_313] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_313::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 314u64 => { let __inp: [G; IN_314] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_314::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 315u64 => { let __inp: [G; IN_315] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_315::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 316u64 => { let __inp: [G; IN_316] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_316::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 317u64 => { let __inp: [G; IN_317] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_317::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 318u64 => { let __inp: [G; IN_318] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_318::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 319u64 => { let __inp: [G; IN_319] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_319::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 320u64 => { let __inp: [G; IN_320] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_320::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 321u64 => { let __inp: [G; IN_321] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_321::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 322u64 => { let __inp: [G; IN_322] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_322::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 323u64 => { let __inp: [G; IN_323] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_323::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 324u64 => { let __inp: [G; IN_324] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_324::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 325u64 => { let __inp: [G; IN_325] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_325::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 326u64 => { let __inp: [G; IN_326] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_326::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 327u64 => { let __inp: [G; IN_327] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_327::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 328u64 => { let __inp: [G; IN_328] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_328::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 329u64 => { let __inp: [G; IN_329] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_329::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 330u64 => { let __inp: [G; IN_330] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_330::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, _ => { return Err(ExecError::InvalidFunIdx(fun_idx)); }, } } diff --git a/crates/ixvm-codegen/src/aiur_ix_aggr_runner.rs b/crates/ixvm-codegen/src/aiur_ix_aggr_runner.rs deleted file mode 100644 index 81ca667e9..000000000 --- a/crates/ixvm-codegen/src/aiur_ix_aggr_runner.rs +++ /dev/null @@ -1,368 +0,0 @@ -//! ixAggr-native execute path. -//! -//! Mirror of `aiur_multi_stark_runner` for the `ixAggr` toplevel: routes the -//! Aiur fn invocation through the codegen'd Rust aggregator -//! (`crate::aiur_ix_aggr::execute_generated`) instead of the interpreter, -//! with the same `QueryRecord` shape, multiplicity rules, and IO side -//! effects, so the trace produced here is byte-for-byte identical to the -//! interpreter's (modulo the codegen parity invariant). -//! -//! Also home to `aggr_io_buffer`, the native builder for `ix_aggr`'s -//! seven-channel IO advice, and the strict decoders for the compact keyed -//! blob framing the Lean host uses to hand preimages and trees across FFI. - -use multi_stark::p3_field::PrimeCharacteristicRing; -use rustc_hash::FxHashMap; - -use crate::aiur_ix_aggr::execute_generated; -use aiur::G; -use aiur::bytecode::{FunIdx, Toplevel}; -use aiur::execute::{ExecError, IOBuffer, IOKeyInfo, QueryRecord}; - -/// One content-addressed `CheckEnv` preimage consumed by `ix_aggr` on IO -/// channel 4. The digest is keyed in the packed-four-byte public-digest -/// form; the circuit re-hashes `bytes` before using the decoded claim. -#[derive(Clone, Copy, Debug)] -pub struct AggrPreimage<'a> { - pub digest: [u8; 32], - pub bytes: &'a [u8], -} - -/// One serialized canonical `AssumptionTree` consumed by `ix_aggr` on IO -/// channel 5. Tree roots use the raw-address key representation: one field -/// element per byte. -#[derive(Clone, Copy, Debug)] -pub struct AggrTree<'a> { - pub root: [u8; 32], - pub bytes: &'a [u8], -} - -/// One carried/discharged choice consumed by structural `ix_aggr` shapes on -/// IO channel 6. Candidates use the raw-address key representation; the -/// circuit strictly parses each payload and verifies every discharge path. -#[derive(Clone, Copy, Debug)] -pub struct AggrPath<'a> { - pub candidate: [u8; 32], - pub bytes: &'a [u8], -} - -/// Raw advice for one `ix_aggr` invocation, any shape. -/// -/// Borrowed view: real proofs are multi-megabyte blobs, so constructing an -/// IO buffer must not first clone the caller's byte arrays. `proof_advice` -/// contains the expanded per-query transport, never compact proof wire bytes. Wrap shapes -/// leave the right-child slots empty; the circuit never reads them. -#[derive(Clone, Copy, Debug)] -pub struct AggrAdvice<'a> { - pub shape: u8, - pub proof_advice: [&'a [u8]; 2], - pub ixvm_vk: &'a [u8], - pub self_vk: &'a [u8], - pub child_claims: [&'a [u8]; 2], - pub output_claim: &'a [u8], - pub allowed: &'a [u8], - pub preimages: &'a [AggrPreimage<'a>], - pub trees: &'a [AggrTree<'a>], - pub paths: &'a [AggrPath<'a>], -} - -/// Decode the compact host/FFI representation of digest-addressed -/// preimages. The wire format is a little-endian `u32` entry count followed -/// by `(32-byte key, u32 payload length, payload)` entries. -pub fn decode_aggr_preimages( - blob: &[u8], -) -> Result>, String> { - decode_keyed_blobs(blob, "aggr preimages").map(|entries| { - entries - .into_iter() - .map(|(digest, bytes)| AggrPreimage { digest, bytes }) - .collect() - }) -} - -/// Decode the compact host/FFI representation of root-addressed trees. Its -/// framing is identical to [`decode_aggr_preimages`]. -pub fn decode_aggr_trees(blob: &[u8]) -> Result>, String> { - decode_keyed_blobs(blob, "aggr trees").map(|entries| { - entries.into_iter().map(|(root, bytes)| AggrTree { root, bytes }).collect() - }) -} - -/// Decode compact candidate-addressed structural-discharge choices. Framing -/// is identical to [`decode_aggr_preimages`]; payload semantics are checked by -/// the circuit. -pub fn decode_aggr_paths(blob: &[u8]) -> Result>, String> { - decode_keyed_blobs(blob, "aggr paths").map(|entries| { - entries - .into_iter() - .map(|(candidate, bytes)| AggrPath { candidate, bytes }) - .collect() - }) -} - -fn decode_keyed_blobs<'a>( - blob: &'a [u8], - label: &str, -) -> Result, String> { - let mut cursor = 0usize; - let count = read_u32(blob, &mut cursor, label)? as usize; - let max_entries = blob.len().saturating_sub(cursor) / 36; - if count > max_entries { - return Err(format!( - "{label}: declares {count} entries, but the blob can contain at most \ - {max_entries} complete key/length headers" - )); - } - let mut entries = Vec::with_capacity(count); - for entry_index in 0..count { - let key_end = cursor.checked_add(32).ok_or_else(|| { - format!("{label}: entry {entry_index} key offset overflow") - })?; - let key_slice = blob.get(cursor..key_end).ok_or_else(|| { - format!("{label}: truncated 32-byte key for entry {entry_index}") - })?; - let key: [u8; 32] = - key_slice.try_into().expect("slice length was checked above"); - cursor = key_end; - - let payload_len = read_u32(blob, &mut cursor, label)? as usize; - let payload_end = cursor.checked_add(payload_len).ok_or_else(|| { - format!("{label}: entry {entry_index} payload offset overflow") - })?; - let payload = blob.get(cursor..payload_end).ok_or_else(|| { - format!( - "{label}: entry {entry_index} declares {payload_len} payload bytes, \ - but only {} remain", - blob.len().saturating_sub(cursor) - ) - })?; - cursor = payload_end; - entries.push((key, payload)); - } - if cursor != blob.len() { - return Err(format!( - "{label}: {} trailing bytes after {count} entries", - blob.len() - cursor - )); - } - Ok(entries) -} - -fn read_u32( - blob: &[u8], - cursor: &mut usize, - label: &str, -) -> Result { - let end = cursor - .checked_add(4) - .ok_or_else(|| format!("{label}: length offset overflow"))?; - let bytes: [u8; 4] = blob - .get(*cursor..end) - .ok_or_else(|| format!("{label}: truncated u32 length"))? - .try_into() - .expect("slice length was checked above"); - *cursor = end; - Ok(u32::from_le_bytes(bytes)) -} - -/// Append one keyed byte stream to an IO channel arena. -#[inline] -fn extend_bytes(io: &mut IOBuffer, channel: G, key: Vec, bytes: &[u8]) { - let arena = io.data.entry(channel).or_default(); - let idx = arena.len(); - let len = bytes.len(); - arena.extend(bytes.iter().map(|b| G::from_u8(*b))); - io.map.insert((channel, key), IOKeyInfo { idx, len }); -} - -/// An integer stream index (`[0]`, `[1]`, or `[2]`) as an Aiur IO key. -#[inline] -fn index_key(index: u8) -> Vec { - vec![G::from_u8(index)] -} - -/// A Blake3 digest as eight packed little-endian `u32` field elements. -/// Mirrors in-circuit `b3_pack` and Lean `Aggr.digestGs`. -#[inline] -fn packed_digest_key(digest: &[u8; 32]) -> Vec { - digest - .as_chunks::<4>() - .0 - .iter() - .map(|word| G::from_u32(u32::from_le_bytes(*word))) - .collect() -} - -/// A 32-byte address as 32 field elements, matching the tree-loader key. -#[inline] -fn address_key(address: &[u8; 32]) -> Vec { - address.iter().map(|b| G::from_u8(*b)).collect() -} - -/// Mirror of `Toplevel::execute` (same return shape, same `entry`-flag -/// gate), but routes execution through the codegen'd Rust aggregator. Deep -/// recursion is handled via per-fn `stacker::maybe_grow` checks in the -/// generated code. -// `args: Vec` mirrors `Toplevel::execute`'s signature so this fn can be -// used as an `impl Fn(&Toplevel, _, Vec, _) -> _` in -// `AiurSystem::prove_ixvm` — a `&[G]` here would break that bound. -#[allow(clippy::needless_pass_by_value)] -pub fn execute_ix_aggr( - toplevel: &Toplevel, - fun_idx: FunIdx, - args: Vec, - io_buffer: &mut IOBuffer, -) -> Result<(QueryRecord, Vec), ExecError> { - if !toplevel.functions[fun_idx].entry { - return Err(ExecError::NotEntryFunction(fun_idx)); - } - let mut record = QueryRecord::new(toplevel); - let output = execute_generated(fun_idx, &args, &mut record, io_buffer)?; - Ok((record, output)) -} - -/// Build `ix_aggr`'s seven-channel IO advice buffer. -/// -/// Layout (the circuit binds every digest-addressed blob before decoding): -/// -/// * ch 0 `[0]`, `[1]`: left/right expanded child proof advice; -/// * ch 1 `[0]`, `[1]`: the IxVM and self verifying keys, by child kind; -/// * ch 2 `[0]`, `[1]`, `[2]`: child claims and the output `CheckEnv` claim; -/// * ch 3 `[0]`: the digest-bound 80-byte allowed blob; -/// * ch 4 `packed(blake3)`: `CheckEnv` claim preimages; -/// * ch 5 `root bytes`: serialized canonical assumption trees; -/// * ch 6 `[0]`: the one-byte shape hint; -/// * ch 6 `candidate bytes`: structural carried/discharged choices and paths. -pub fn aggr_io_buffer(advice: &AggrAdvice<'_>) -> IOBuffer { - let mut io = - IOBuffer { data: FxHashMap::default(), map: FxHashMap::default() }; - - extend_bytes(&mut io, G::from_u8(0), index_key(0), advice.proof_advice[0]); - extend_bytes(&mut io, G::from_u8(0), index_key(1), advice.proof_advice[1]); - extend_bytes(&mut io, G::from_u8(1), index_key(0), advice.ixvm_vk); - extend_bytes(&mut io, G::from_u8(1), index_key(1), advice.self_vk); - extend_bytes(&mut io, G::from_u8(2), index_key(0), advice.child_claims[0]); - extend_bytes(&mut io, G::from_u8(2), index_key(1), advice.child_claims[1]); - extend_bytes(&mut io, G::from_u8(2), index_key(2), advice.output_claim); - extend_bytes(&mut io, G::from_u8(3), index_key(0), advice.allowed); - - for preimage in advice.preimages { - extend_bytes( - &mut io, - G::from_u8(4), - packed_digest_key(&preimage.digest), - preimage.bytes, - ); - } - for tree in advice.trees { - extend_bytes(&mut io, G::from_u8(5), address_key(&tree.root), tree.bytes); - } - extend_bytes(&mut io, G::from_u8(6), index_key(0), &[advice.shape]); - for path in advice.paths { - extend_bytes( - &mut io, - G::from_u8(6), - address_key(&path.candidate), - path.bytes, - ); - } - - io -} - -#[cfg(test)] -mod tests { - use super::*; - use multi_stark::p3_field::PrimeField64; - - fn info(io: &IOBuffer, channel: u8, key: Vec) -> (usize, usize) { - let info = - io.map.get(&(G::from_u8(channel), key)).expect("missing IO mapping"); - (info.idx, info.len) - } - - fn arena_bytes(io: &IOBuffer, channel: u8) -> Vec { - io.data[&G::from_u8(channel)] - .iter() - .map(|g| u8::try_from(g.as_canonical_u64()).expect("IO test byte")) - .collect() - } - - #[test] - fn aggr_layout_indexes_streams_and_uses_both_digest_key_encodings() { - let mut digest = [0u8; 32]; - for (i, byte) in digest.iter_mut().enumerate() { - *byte = u8::try_from(i).expect("32-byte index"); - } - let mut root = [0u8; 32]; - for (i, byte) in root.iter_mut().enumerate() { - *byte = u8::try_from(31 - i).expect("32-byte reverse index"); - } - let preimages = [AggrPreimage { digest, bytes: &[11, 12] }]; - let trees = [AggrTree { root, bytes: &[13, 14, 15] }]; - let paths = [AggrPath { candidate: root, bytes: &[1, 0] }]; - let advice = AggrAdvice { - shape: 3, - proof_advice: [&[1, 2], &[3]], - ixvm_vk: &[4, 5], - self_vk: &[16, 17, 18], - child_claims: [&[6], &[7, 8]], - output_claim: &[9], - allowed: &[10], - preimages: &preimages, - trees: &trees, - paths: &paths, - }; - - let io = aggr_io_buffer(&advice); - - assert_eq!(arena_bytes(&io, 0), vec![1, 2, 3]); - assert_eq!(info(&io, 0, index_key(0)), (0, 2)); - assert_eq!(info(&io, 0, index_key(1)), (2, 1)); - - assert_eq!(arena_bytes(&io, 1), vec![4, 5, 16, 17, 18]); - assert_eq!(info(&io, 1, index_key(0)), (0, 2)); - assert_eq!(info(&io, 1, index_key(1)), (2, 3)); - - assert_eq!(arena_bytes(&io, 2), vec![6, 7, 8, 9]); - assert_eq!(info(&io, 2, index_key(0)), (0, 1)); - assert_eq!(info(&io, 2, index_key(1)), (1, 2)); - assert_eq!(info(&io, 2, index_key(2)), (3, 1)); - - assert_eq!(info(&io, 3, index_key(0)), (0, 1)); - assert_eq!(info(&io, 4, packed_digest_key(&digest)), (0, 2)); - assert_eq!(info(&io, 5, address_key(&root)), (0, 3)); - assert_eq!(arena_bytes(&io, 6), vec![3, 1, 0]); - assert_eq!(info(&io, 6, index_key(0)), (0, 1)); - assert_eq!(info(&io, 6, address_key(&root)), (1, 2)); - assert_ne!(packed_digest_key(&digest), address_key(&digest)); - } - - #[test] - fn keyed_aggr_blobs_decode_strictly_without_copying_payloads() { - let key = [7u8; 32]; - let mut blob = Vec::new(); - blob.extend_from_slice(&1u32.to_le_bytes()); - blob.extend_from_slice(&key); - blob.extend_from_slice(&3u32.to_le_bytes()); - blob.extend_from_slice(&[8, 9, 10]); - - let preimages = decode_aggr_preimages(&blob).expect("valid preimage blob"); - assert_eq!(preimages.len(), 1); - assert_eq!(preimages[0].digest, key); - assert_eq!(preimages[0].bytes, &[8, 9, 10]); - - let trees = decode_aggr_trees(&blob).expect("valid tree blob"); - assert_eq!(trees[0].root, key); - assert_eq!(trees[0].bytes, &[8, 9, 10]); - - let paths = decode_aggr_paths(&blob).expect("valid path blob"); - assert_eq!(paths[0].candidate, key); - assert_eq!(paths[0].bytes, &[8, 9, 10]); - - blob.push(11); - assert!(decode_aggr_preimages(&blob).is_err()); - assert!(decode_aggr_trees(&[1, 0, 0]).is_err()); - assert!(decode_aggr_paths(&[1, 0, 0]).is_err()); - } -} diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs deleted file mode 100644 index 1b239a28d..000000000 --- a/crates/ixvm-codegen/src/aiur_ixvm.rs +++ /dev/null @@ -1,3152 +0,0 @@ -// Auto-generated by Aiur codegen. Do not edit. -// Mirrors crates/aiur/src/execute.rs QueryRecord side effects. -#![cfg_attr(rustfmt, rustfmt::skip)] -#![allow(unused_variables, unused_assignments, unused_mut, dead_code, -unused_parens, non_snake_case, clippy::all, -clippy::ptr_as_ptr, clippy::match_same_arms, -clippy::large_types_passed_by_value)] -use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; -use aiur::G; -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); }) } -const INPUT_SIZE_1: usize = 2; -const IN_1: usize = 2; -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 __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).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_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).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_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 = G::from_u64(256); let __v_67: G = __v_9 * __v_66; let __v_68: G = __v_67 + __v_8; let __v_69: G = __v_68 * __v_66; let __v_70: G = __v_69 + __v_7; let __v_71: G = __v_70 * __v_66; let __v_72: G = __v_71 + __v_6; let __v_73: G = __v_72 * __v_66; let __v_74: G = __v_73 + __v_5; let __v_75: G = __v_74 * __v_66; let __v_76: G = __v_75 + __v_4; let __v_77: G = __v_76 * __v_66; let __v_78: G = __v_77 + __v_3; let __v_79: G = __v_41 * __v_66; let __v_80: G = __v_79 + __v_40; let __v_81: G = __v_80 * __v_66; let __v_82: G = __v_81 + __v_39; let __v_83: G = __v_82 * __v_66; let __v_84: G = __v_83 + __v_38; let __v_85: G = __v_84 * __v_66; let __v_86: G = __v_85 + __v_37; let __v_87: G = __v_86 * __v_66; let __v_88: G = __v_87 + __v_36; let __v_89: G = __v_88 * __v_66; let __v_90: G = __v_89 + __v_35; let __v_91: G = __v_78 - __v_90; match __v_91.as_canonical_u64() { 0u64 => { let __v_92: G = G::from_u64(256); let __v_93: G = __v_16 * __v_92; let __v_94: G = __v_93 + __v_15; let __v_95: G = __v_94 * __v_92; let __v_96: G = __v_95 + __v_14; let __v_97: G = __v_96 * __v_92; let __v_98: G = __v_97 + __v_13; let __v_99: G = __v_98 * __v_92; let __v_100: G = __v_99 + __v_12; let __v_101: G = __v_100 * __v_92; let __v_102: G = __v_101 + __v_11; let __v_103: G = __v_102 * __v_92; let __v_104: G = __v_103 + __v_10; let __v_105: G = __v_48 * __v_92; let __v_106: G = __v_105 + __v_47; let __v_107: G = __v_106 * __v_92; let __v_108: G = __v_107 + __v_46; let __v_109: G = __v_108 * __v_92; let __v_110: G = __v_109 + __v_45; let __v_111: G = __v_110 * __v_92; let __v_112: G = __v_111 + __v_44; let __v_113: G = __v_112 * __v_92; let __v_114: G = __v_113 + __v_43; let __v_115: G = __v_114 * __v_92; let __v_116: G = __v_115 + __v_42; let __v_117: G = __v_104 - __v_116; match __v_117.as_canonical_u64() { 0u64 => { let __v_118: G = G::from_u64(256); let __v_119: G = __v_23 * __v_118; let __v_120: G = __v_119 + __v_22; let __v_121: G = __v_120 * __v_118; let __v_122: G = __v_121 + __v_21; let __v_123: G = __v_122 * __v_118; let __v_124: G = __v_123 + __v_20; let __v_125: G = __v_124 * __v_118; let __v_126: G = __v_125 + __v_19; let __v_127: G = __v_126 * __v_118; let __v_128: G = __v_127 + __v_18; let __v_129: G = __v_128 * __v_118; let __v_130: G = __v_129 + __v_17; let __v_131: G = __v_55 * __v_118; let __v_132: G = __v_131 + __v_54; let __v_133: G = __v_132 * __v_118; let __v_134: G = __v_133 + __v_53; let __v_135: G = __v_134 * __v_118; let __v_136: G = __v_135 + __v_52; let __v_137: G = __v_136 * __v_118; let __v_138: G = __v_137 + __v_51; let __v_139: G = __v_138 * __v_118; let __v_140: G = __v_139 + __v_50; let __v_141: G = __v_140 * __v_118; let __v_142: G = __v_141 + __v_49; let __v_143: G = __v_130 - __v_142; match __v_143.as_canonical_u64() { 0u64 => { let __v_144: G = G::from_u64(256); let __v_145: G = __v_30 * __v_144; let __v_146: G = __v_145 + __v_29; let __v_147: G = __v_146 * __v_144; let __v_148: G = __v_147 + __v_28; let __v_149: G = __v_148 * __v_144; let __v_150: G = __v_149 + __v_27; let __v_151: G = __v_150 * __v_144; let __v_152: G = __v_151 + __v_26; let __v_153: G = __v_152 * __v_144; let __v_154: G = __v_153 + __v_25; let __v_155: G = __v_154 * __v_144; let __v_156: G = __v_155 + __v_24; let __v_157: G = __v_62 * __v_144; let __v_158: G = __v_157 + __v_61; let __v_159: G = __v_158 * __v_144; let __v_160: G = __v_159 + __v_60; let __v_161: G = __v_160 * __v_144; let __v_162: G = __v_161 + __v_59; let __v_163: G = __v_162 * __v_144; let __v_164: G = __v_163 + __v_58; let __v_165: G = __v_164 * __v_144; let __v_166: G = __v_165 + __v_57; let __v_167: G = __v_166 * __v_144; let __v_168: G = __v_167 + __v_56; let __v_169: G = __v_156 - __v_168; match __v_169.as_canonical_u64() { 0u64 => { let __v_170: G = G::from_u64(256); let __v_171: G = __v_33 * __v_170; let __v_172: G = __v_171 + __v_32; let __v_173: G = __v_172 * __v_170; let __v_174: G = __v_173 + __v_31; let __v_175: G = __v_65 * __v_170; let __v_176: G = __v_175 + __v_64; let __v_177: G = __v_176 * __v_170; let __v_178: G = __v_177 + __v_63; let __v_179: G = __v_174 - __v_178; match __v_179.as_canonical_u64() { 0u64 => { let __v_180: G = G::from_u64(1); let __ret: [G; OUT_1] = [__v_180]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_180: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_180]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_170: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_170]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_144: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_144]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_118: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_118]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_92: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_92]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_2: usize = 2; -const IN_2: usize = 2; -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 __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).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_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).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_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; let __v_37: G = __loaded[3]; let __v_38: G = __loaded[4]; let __v_39: G = __loaded[5]; let __v_40: G = __loaded[6]; let __v_41: G = __loaded[7]; let __v_42: G = __loaded[8]; let __v_43: G = __loaded[9]; let __v_44: G = __loaded[10]; let __v_45: G = __loaded[11]; let __v_46: G = __loaded[12]; let __v_47: G = __loaded[13]; let __v_48: G = __loaded[14]; let __v_49: G = __loaded[15]; let __v_50: G = __loaded[16]; let __v_51: G = __loaded[17]; let __v_52: G = __loaded[18]; let __v_53: G = __loaded[19]; let __v_54: G = __loaded[20]; let __v_55: G = __loaded[21]; let __v_56: G = __loaded[22]; let __v_57: G = __loaded[23]; let __v_58: G = __loaded[24]; let __v_59: G = __loaded[25]; let __v_60: G = __loaded[26]; let __v_61: G = __loaded[27]; let __v_62: G = __loaded[28]; let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; let __v_66: G = __v_2 - __v_34; match __v_66.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; 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_67: G = __r_arr[0]; let __ret: [G; OUT_2] = [__v_67]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_67: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_67]; record.function_queries[2].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_3: usize = 1; -const IN_3: usize = 1; -const OUT_3: usize = 1; -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 = G::from_u64(4294967295); let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); if (__v_2 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("list depth exceeds u32".to_string()) }); } let __v_4: G = __v_0 + __v_3; let __ret: [G; OUT_3] = [__v_4]; record.function_queries[3].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_4: usize = 3; -const IN_4: usize = 3; -const OUT_4: usize = 1; -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]; 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(1).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_4] = [__v_4]; record.function_queries[4].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_4] = { let __args: [G; IN_4] = [__v_0, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(4, &__args[..])?) { [G::ZERO; OUT_4] } else { let (__hash, __hit) = record.function_queries[4].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[4].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => { aiur_fn_4::(__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(1).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_4] = [__v_9]; record.function_queries[4].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_5: usize = 3; -const IN_5: usize = 3; -const OUT_5: usize = 1; -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]; 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(1).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_5] = [__v_4]; record.function_queries[5].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { 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_3: G = __io_read[0]; if (!unconstrained) { let __vi = __v_3; 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); } 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(1).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_4, __v_3, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_5] = [__v_7]; record.function_queries[5].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __io_read: [G; 2] = { 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, 2)?; let __arr: [G; 2] = __data[..2].try_into().unwrap(); __arr }; let __v_3: G = __io_read[0]; let __v_4: G = __io_read[1]; 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); } let __v_5: G = G::from_u64(2); let __v_6: G = __v_1 + __v_5; let __v_7: G = __v_2 - __v_5; let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_0, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(5, &__args[..])?) { [G::ZERO; OUT_5] } else { let (__hash, __hit) = record.function_queries[5].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[5].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => { aiur_fn_5::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_3, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_5] = [__v_11]; record.function_queries[5].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_6: usize = 8; -const IN_6: usize = 8; -const OUT_6: usize = 1; -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 __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_6] = [__v_8]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_6] = [__v_8]; record.function_queries[6].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_7: usize = 8; -const IN_7: usize = 8; -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 __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_7] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[7].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_8: usize = 12; -const IN_8: usize = 12; -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 __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 = __v_16 * __v_18; let __v_20: G = G::from_u64(2); let __v_21: G = __v_16 - __v_20; let __v_22: G = __v_19 * __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_8] = [__v_12, __v_13, __v_14, __v_15]; 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 __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_9] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[9].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_10: usize = 4; -const IN_10: usize = 4; -const OUT_10: usize = 4; -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 __ret: [G; OUT_10] = [__v_2, __v_3, __v_0, __v_1]; record.function_queries[10].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_11: usize = 4; -const IN_11: usize = 4; -const OUT_11: usize = 4; -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 __ret: [G; OUT_11] = [__v_1, __v_2, __v_3, __v_0]; 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 = 4; -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 __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_12] = [__v_16, __v_17, __v_18, __v_19]; 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 = 4; -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 __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_13] = [__v_16, __v_17, __v_18, __v_19]; record.function_queries[13].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_14: usize = 16; -const IN_14: usize = 16; -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 = 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_14] = [__v_24]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_14] = [__v_24]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_14] = [__v_24]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_14] = [__v_24]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_14] = [__v_24]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_14] = [__v_24]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_14] = [__v_24]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_14] = [__v_24]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_14] = [__v_24]; record.function_queries[14].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_15: usize = 16; -const IN_15: usize = 16; -const OUT_15: usize = 9; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add(&__v_0, &__v_8) } else { aiur::execute::bytes2_add_value(__v_0, __v_8, record) }; let __v_16: G = __b2_out.0; let __v_17: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add(&__v_1, &__v_9) } else { aiur::execute::bytes2_add_value(__v_1, __v_9, record) }; let __v_18: G = __b2_out.0; let __v_19: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add(&__v_18, &__v_17) } else { aiur::execute::bytes2_add_value(__v_18, __v_17, record) }; let __v_20: G = __b2_out.0; let __v_21: G = __b2_out.1; let __v_22: G = __v_19 + __v_21; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add(&__v_2, &__v_10) } else { aiur::execute::bytes2_add_value(__v_2, __v_10, record) }; let __v_23: G = __b2_out.0; let __v_24: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add(&__v_23, &__v_22) } else { aiur::execute::bytes2_add_value(__v_23, __v_22, record) }; let __v_25: G = __b2_out.0; let __v_26: G = __b2_out.1; let __v_27: G = __v_24 + __v_26; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add(&__v_3, &__v_11) } else { aiur::execute::bytes2_add_value(__v_3, __v_11, record) }; let __v_28: G = __b2_out.0; let __v_29: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add(&__v_28, &__v_27) } else { aiur::execute::bytes2_add_value(__v_28, __v_27, record) }; let __v_30: G = __b2_out.0; let __v_31: G = __b2_out.1; let __v_32: G = __v_29 + __v_31; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add(&__v_4, &__v_12) } else { aiur::execute::bytes2_add_value(__v_4, __v_12, record) }; let __v_33: G = __b2_out.0; let __v_34: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add(&__v_33, &__v_32) } else { aiur::execute::bytes2_add_value(__v_33, __v_32, record) }; let __v_35: G = __b2_out.0; let __v_36: G = __b2_out.1; let __v_37: G = __v_34 + __v_36; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add(&__v_5, &__v_13) } else { aiur::execute::bytes2_add_value(__v_5, __v_13, record) }; let __v_38: G = __b2_out.0; let __v_39: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add(&__v_38, &__v_37) } else { aiur::execute::bytes2_add_value(__v_38, __v_37, record) }; let __v_40: G = __b2_out.0; let __v_41: G = __b2_out.1; let __v_42: G = __v_39 + __v_41; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add(&__v_6, &__v_14) } else { aiur::execute::bytes2_add_value(__v_6, __v_14, record) }; let __v_43: G = __b2_out.0; let __v_44: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add(&__v_43, &__v_42) } else { aiur::execute::bytes2_add_value(__v_43, __v_42, record) }; let __v_45: G = __b2_out.0; let __v_46: G = __b2_out.1; let __v_47: G = __v_44 + __v_46; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add(&__v_7, &__v_15) } else { aiur::execute::bytes2_add_value(__v_7, __v_15, 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::add(&__v_48, &__v_47) } else { aiur::execute::bytes2_add_value(__v_48, __v_47, record) }; let __v_50: G = __b2_out.0; let __v_51: G = __b2_out.1; let __v_52: G = __v_49 + __v_51; let __ret: [G; OUT_15] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; record.function_queries[15].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_16: usize = 8; -const IN_16: usize = 8; -const OUT_16: usize = 8; -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 = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; 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_16] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; record.function_queries[16].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_16] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10]; record.function_queries[16].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_16] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_7]; record.function_queries[16].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_16] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_6, __v_7]; record.function_queries[16].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_16] = [__v_8, __v_8, __v_8, __v_8, __v_10, __v_5, __v_6, __v_7]; record.function_queries[16].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_16] = [__v_8, __v_8, __v_8, __v_10, __v_4, __v_5, __v_6, __v_7]; record.function_queries[16].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_16] = [__v_8, __v_8, __v_10, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[16].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_16] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[16].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_16] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[16].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_17: usize = 8; -const IN_17: usize = 8; -const OUT_17: usize = 8; -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 = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { match __v_3.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_17] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = __v_7 - __v_9; let __ret: [G; OUT_17] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = __v_6 - __v_9; let __ret: [G; OUT_17] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_7]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = __v_5 - __v_9; let __ret: [G; OUT_17] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_10, __v_6, __v_7]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = __v_4 - __v_9; let __ret: [G; OUT_17] = [__v_8, __v_8, __v_8, __v_8, __v_10, __v_5, __v_6, __v_7]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = __v_3 - __v_9; let __ret: [G; OUT_17] = [__v_8, __v_8, __v_8, __v_10, __v_4, __v_5, __v_6, __v_7]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = __v_2 - __v_9; let __ret: [G; OUT_17] = [__v_8, __v_8, __v_10, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = __v_1 - __v_9; let __ret: [G; OUT_17] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[17].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_17] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[17].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_18: usize = 8; -const IN_18: usize = 8; -const OUT_18: usize = 1; -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 = 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 = __v_0 + __v_10; let __v_12: G = G::from_u64(65536); let __v_13: G = __v_12 * __v_2; let __v_14: G = __v_11 + __v_13; let __v_15: G = G::from_u64(16777216); let __v_16: G = __v_15 * __v_3; let __v_17: G = __v_14 + __v_16; let __v_18: G = G::from_u64(4294967296); let __v_19: G = __v_18 * __v_4; let __v_20: G = __v_17 + __v_19; let __v_21: G = G::from_u64(1099511627776); let __v_22: G = __v_21 * __v_5; let __v_23: G = __v_20 + __v_22; let __v_24: G = G::from_u64(281474976710656); let __v_25: G = __v_24 * __v_6; let __v_26: G = __v_23 + __v_25; let __ret: [G; OUT_18] = [__v_26]; record.function_queries[18].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_19: usize = 4; -const IN_19: usize = 4; -const OUT_19: usize = 1; -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 = 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 = __v_0 + __v_5; let __v_7: G = G::from_u64(65536); let __v_8: G = __v_7 * __v_2; let __v_9: G = __v_6 + __v_8; let __v_10: G = G::from_u64(16777216); let __v_11: G = __v_10 * __v_3; let __v_12: G = __v_9 + __v_11; let __ret: [G; OUT_19] = [__v_12]; record.function_queries[19].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_20: usize = 32; -const IN_20: usize = 32; -const OUT_20: usize = 8; -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 = 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 = __v_0 + __v_33; let __v_35: G = G::from_u64(65536); let __v_36: G = __v_35 * __v_2; let __v_37: G = __v_34 + __v_36; let __v_38: G = G::from_u64(16777216); let __v_39: G = __v_38 * __v_3; let __v_40: G = __v_37 + __v_39; let __v_41: G = __v_32 * __v_5; let __v_42: G = __v_4 + __v_41; let __v_43: G = __v_35 * __v_6; let __v_44: G = __v_42 + __v_43; let __v_45: G = __v_38 * __v_7; let __v_46: G = __v_44 + __v_45; let __v_47: G = __v_32 * __v_9; let __v_48: G = __v_8 + __v_47; let __v_49: G = __v_35 * __v_10; let __v_50: G = __v_48 + __v_49; let __v_51: G = __v_38 * __v_11; let __v_52: G = __v_50 + __v_51; let __v_53: G = __v_32 * __v_13; let __v_54: G = __v_12 + __v_53; let __v_55: G = __v_35 * __v_14; let __v_56: G = __v_54 + __v_55; let __v_57: G = __v_38 * __v_15; let __v_58: G = __v_56 + __v_57; let __v_59: G = __v_32 * __v_17; let __v_60: G = __v_16 + __v_59; let __v_61: G = __v_35 * __v_18; let __v_62: G = __v_60 + __v_61; let __v_63: G = __v_38 * __v_19; let __v_64: G = __v_62 + __v_63; let __v_65: G = __v_32 * __v_21; let __v_66: G = __v_20 + __v_65; let __v_67: G = __v_35 * __v_22; let __v_68: G = __v_66 + __v_67; let __v_69: G = __v_38 * __v_23; let __v_70: G = __v_68 + __v_69; let __v_71: G = __v_32 * __v_25; let __v_72: G = __v_24 + __v_71; let __v_73: G = __v_35 * __v_26; let __v_74: G = __v_72 + __v_73; let __v_75: G = __v_38 * __v_27; let __v_76: G = __v_74 + __v_75; let __v_77: G = __v_32 * __v_29; let __v_78: G = __v_28 + __v_77; let __v_79: G = __v_35 * __v_30; let __v_80: G = __v_78 + __v_79; let __v_81: G = __v_38 * __v_31; let __v_82: G = __v_80 + __v_81; let __ret: [G; OUT_20] = [__v_40, __v_46, __v_52, __v_58, __v_64, __v_70, __v_76, __v_82]; record.function_queries[20].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_21: usize = 1; -const IN_21: usize = 1; -const OUT_21: usize = 32; -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 = 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(1).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(12).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(13).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_26] = { let __args: [G; IN_26] = [__v_0, __v_33, __v_34, __v_34, __v_35, __v_36, __v_37]; 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_38: G = __r_arr[0]; let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_38]; 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_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_21] = [__v_39, __v_40, __v_41, __v_42, __v_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[21].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_22: usize = 33; -const IN_22: usize = 33; -const OUT_22: usize = 0; -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 = 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 = G::from_u64(103); let __v_34: G = G::from_u64(230); let __v_35: G = G::from_u64(9); let __v_36: G = G::from_u64(106); let __v_37: G = G::from_u64(133); let __v_38: G = G::from_u64(174); let __v_39: G = G::from_u64(187); let __v_40: G = G::from_u64(114); let __v_41: G = G::from_u64(243); let __v_42: G = G::from_u64(110); let __v_43: G = G::from_u64(60); let __v_44: G = G::from_u64(58); let __v_45: G = G::from_u64(245); let __v_46: G = G::from_u64(79); let __v_47: G = G::from_u64(165); let __v_48: G = G::from_u64(127); let __v_49: G = G::from_u64(82); let __v_50: G = G::from_u64(14); let __v_51: G = G::from_u64(81); let __v_52: G = G::from_u64(140); let __v_53: G = G::from_u64(104); let __v_54: G = G::from_u64(5); let __v_55: G = G::from_u64(155); let __v_56: G = G::from_u64(171); let __v_57: G = G::from_u64(217); let __v_58: G = G::from_u64(131); let __v_59: G = G::from_u64(31); let __v_60: G = G::from_u64(25); let __v_61: G = G::from_u64(205); let __v_62: G = G::from_u64(224); let __v_63: G = G::from_u64(91); let __v_64: G = G::from_u64(1); let __v_65: G = { let __values: [G; 3] = [__v_64, __v_64, __v_64]; let __mq = record.memory_queries.get_index_mut(1).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_66: G = G::from_u64(0); let __v_67: G = { let __values: [G; 8] = [__v_66, __v_66, __v_66, __v_66, __v_66, __v_66, __v_66, __v_66]; 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_68: G = { let __values: [G; 32] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_33, __v_39, __v_40, __v_41, __v_42, __v_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]; let __mq = record.memory_queries.get_index_mut(12).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_69: G = { let __values: [G; 34] = [__v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64, __v_64]; let __mq = record.memory_queries.get_index_mut(13).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_26] = { let __args: [G; IN_26] = [__v_0, __v_65, __v_66, __v_66, __v_67, __v_68, __v_69]; 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_70: G = __r_arr[0]; let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_70]; 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_71: G = __r_arr[0]; let __v_72: G = __r_arr[1]; let __v_73: G = __r_arr[2]; let __v_74: G = __r_arr[3]; let __v_75: G = __r_arr[4]; let __v_76: G = __r_arr[5]; let __v_77: G = __r_arr[6]; let __v_78: G = __r_arr[7]; let __v_79: G = __r_arr[8]; let __v_80: G = __r_arr[9]; let __v_81: G = __r_arr[10]; let __v_82: G = __r_arr[11]; let __v_83: G = __r_arr[12]; let __v_84: G = __r_arr[13]; let __v_85: G = __r_arr[14]; let __v_86: G = __r_arr[15]; let __v_87: G = __r_arr[16]; let __v_88: G = __r_arr[17]; let __v_89: G = __r_arr[18]; let __v_90: G = __r_arr[19]; let __v_91: G = __r_arr[20]; let __v_92: G = __r_arr[21]; let __v_93: G = __r_arr[22]; let __v_94: G = __r_arr[23]; let __v_95: G = __r_arr[24]; let __v_96: G = __r_arr[25]; let __v_97: G = __r_arr[26]; let __v_98: G = __r_arr[27]; let __v_99: G = __r_arr[28]; let __v_100: G = __r_arr[29]; let __v_101: G = __r_arr[30]; let __v_102: G = __r_arr[31]; if (__v_71 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_72 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_73 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_74 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_75 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_76 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_77 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_78 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_79 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_80 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_81 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_81.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_82 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_83 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_83.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_84 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_85 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_86 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_86.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_87 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_88 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_89 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_90 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_91 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_91.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_92 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_92.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_93 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_93.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_94 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_95 != __v_25) { return Err(ExecError::AssertEqMismatch { lhs: __v_95.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_96 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_97 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_97.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_98 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_98.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_99 != __v_29) { return Err(ExecError::AssertEqMismatch { lhs: __v_99.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_100 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_100.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_101 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_101.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } if (__v_102 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } let __ret: [G; OUT_22] = []; record.function_queries[22].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_23: usize = 1; -const IN_23: usize = 1; -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 = 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(1).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(12).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(13).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_26] = { let __args: [G; IN_26] = [__v_0, __v_33, __v_34, __v_34, __v_35, __v_36, __v_37]; 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_38: G = __r_arr[0]; let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_38]; 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_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 __v_71: G = { let __values: [G; 32] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70]; let __mq = record.memory_queries.get_index_mut(12).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_23] = [__v_71]; record.function_queries[23].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_24: usize = 34; -const IN_24: usize = 34; -const OUT_24: usize = 34; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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(13).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_24] = [__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[24].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_68: G = G::from_u64(0); let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_35, __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(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_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_24] = [__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[24].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(13).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_37] = { let __args: [G; IN_37] = [__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(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_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(13).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_24] = [__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[24].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_37] = { let __args: [G; IN_37] = [__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(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_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(13).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_24] = [__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[24].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_25: usize = 1; -const IN_25: usize = 1; -const OUT_25: usize = 32; -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 __loaded: [G; 34] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(13).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(13).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_25] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __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[25].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_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(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_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_25] = { let __args: [G; IN_25] = [__v_103]; 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_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_25] = [__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[25].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(13).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_25] = { let __args: [G; IN_25] = [__v_105]; 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_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_25] = [__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[25].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_26: usize = 7; -const IN_26: usize = 7; -const OUT_26: usize = 1; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __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(1).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_32] = { let __args: [G; IN_32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(32, &__args[..])?) { [G::ZERO; OUT_32] } else { let (__hash, __hit) = record.function_queries[32].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[32].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[32].bump_multiplicity(__i); } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => { aiur_fn_32::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_26] = [__v_10]; record.function_queries[26].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(1).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_33] = { let __args: [G; IN_33] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_26] = [__v_12]; record.function_queries[26].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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; match __v_15.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_11, __v_13, __v_14, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(32, &__args[..])?) { [G::ZERO; OUT_32] } else { let (__hash, __hit) = record.function_queries[32].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[32].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[32].bump_multiplicity(__i); } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => { aiur_fn_32::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_26] = [__v_18]; record.function_queries[26].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 3] = [__v_18, __v_16, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_13.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_17, __v_19, __v_14, __v_4, __v_5, __v_6]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_26] = [__v_20]; record.function_queries[26].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(1); let __v_21: G = __v_13 + __v_20; let __v_22: G = __v_14 + __v_20; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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() { 1u64 => { let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_19, __v_21, __v_22, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(32, &__args[..])?) { [G::ZERO; OUT_32] } else { let (__hash, __hit) = record.function_queries[32].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[32].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[32].bump_multiplicity(__i); } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => { aiur_fn_32::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_26] = [__v_26]; record.function_queries[26].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 3] = [__v_26, __v_24, __v_19]; let __mq = record.memory_queries.get_index_mut(1).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_21.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_25, __v_27, __v_22, __v_4, __v_5, __v_6]; 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_28: G = __r_arr[0]; let __ret: [G; OUT_26] = [__v_28]; record.function_queries[26].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(1); let __v_29: G = __v_21 + __v_28; let __v_30: G = __v_22 + __v_28; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; 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: 3 })?; if (!unconstrained) { __mq.bump_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() { 1u64 => { let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_27, __v_29, __v_30, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(32, &__args[..])?) { [G::ZERO; OUT_32] } else { let (__hash, __hit) = record.function_queries[32].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[32].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[32].bump_multiplicity(__i); } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => { aiur_fn_32::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __ret: [G; OUT_26] = [__v_34]; record.function_queries[26].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 3] = [__v_34, __v_32, __v_27]; let __mq = record.memory_queries.get_index_mut(1).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_29.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_33, __v_35, __v_30, __v_4, __v_5, __v_6]; 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_36: G = __r_arr[0]; let __ret: [G; OUT_26] = [__v_36]; record.function_queries[26].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_36: G = G::from_u64(1); let __v_37: G = __v_29 + __v_36; let __v_38: G = __v_30 + __v_36; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_33, __v_35, __v_37, __v_38, __v_4, __v_5, __v_6]; 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_39: G = __r_arr[0]; let __ret: [G; OUT_26] = [__v_39]; record.function_queries[26].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_27: usize = 7; -const IN_27: usize = 7; -const OUT_27: usize = 1; -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 = inp[1]; let __v_2: G = inp[2]; let __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(1).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_32] = { let __args: [G; IN_32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(32, &__args[..])?) { [G::ZERO; OUT_32] } else { let (__hash, __hit) = record.function_queries[32].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[32].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[32].bump_multiplicity(__i); } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => { aiur_fn_32::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_27] = [__v_10]; record.function_queries[27].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(1).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_33] = { let __args: [G; IN_33] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_27] = [__v_12]; record.function_queries[27].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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; match __v_15.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_11, __v_13, __v_14, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(32, &__args[..])?) { [G::ZERO; OUT_32] } else { let (__hash, __hit) = record.function_queries[32].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[32].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[32].bump_multiplicity(__i); } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => { aiur_fn_32::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_27] = [__v_18]; record.function_queries[27].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 3] = [__v_18, __v_16, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_13.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_17, __v_19, __v_14, __v_4, __v_5, __v_6]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_27] = [__v_20]; record.function_queries[27].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(1); let __v_21: G = __v_13 + __v_20; let __v_22: G = __v_14 + __v_20; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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() { 1u64 => { let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_19, __v_21, __v_22, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(32, &__args[..])?) { [G::ZERO; OUT_32] } else { let (__hash, __hit) = record.function_queries[32].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[32].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[32].bump_multiplicity(__i); } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => { aiur_fn_32::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_27] = [__v_26]; record.function_queries[27].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 3] = [__v_26, __v_24, __v_19]; let __mq = record.memory_queries.get_index_mut(1).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_21.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_25, __v_27, __v_22, __v_4, __v_5, __v_6]; 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_28: G = __r_arr[0]; let __ret: [G; OUT_27] = [__v_28]; record.function_queries[27].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(1); let __v_29: G = __v_21 + __v_28; let __v_30: G = __v_22 + __v_28; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_25, __v_27, __v_29, __v_30, __v_4, __v_5, __v_6]; 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_31: G = __r_arr[0]; let __ret: [G; OUT_27] = [__v_31]; record.function_queries[27].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_28: usize = 7; -const IN_28: usize = 7; -const OUT_28: usize = 1; -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 = inp[1]; let __v_2: G = inp[2]; let __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(1).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_32] = { let __args: [G; IN_32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(32, &__args[..])?) { [G::ZERO; OUT_32] } else { let (__hash, __hit) = record.function_queries[32].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[32].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[32].bump_multiplicity(__i); } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => { aiur_fn_32::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_28] = [__v_10]; record.function_queries[28].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(1).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_33] = { let __args: [G; IN_33] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_28] = [__v_12]; record.function_queries[28].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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; match __v_15.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_11, __v_13, __v_14, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(32, &__args[..])?) { [G::ZERO; OUT_32] } else { let (__hash, __hit) = record.function_queries[32].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[32].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[32].bump_multiplicity(__i); } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => { aiur_fn_32::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_28] = [__v_18]; record.function_queries[28].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 3] = [__v_18, __v_16, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_13.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_17, __v_19, __v_14, __v_4, __v_5, __v_6]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_28] = [__v_20]; record.function_queries[28].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(1); let __v_21: G = __v_13 + __v_20; let __v_22: G = __v_14 + __v_20; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_17, __v_19, __v_21, __v_22, __v_4, __v_5, __v_6]; 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_23: G = __r_arr[0]; let __ret: [G; OUT_28] = [__v_23]; record.function_queries[28].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_29: usize = 7; -const IN_29: usize = 7; -const OUT_29: usize = 1; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __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(1).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_32] = { let __args: [G; IN_32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(32, &__args[..])?) { [G::ZERO; OUT_32] } else { let (__hash, __hit) = record.function_queries[32].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[32].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[32].bump_multiplicity(__i); } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => { aiur_fn_32::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_10]; record.function_queries[29].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(1).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_33] = { let __args: [G; IN_33] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_12]; record.function_queries[29].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_26] = { let __args: [G; IN_26] = [__v_9, __v_11, __v_13, __v_14, __v_4, __v_5, __v_6]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_15]; record.function_queries[29].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_30: usize = 1; -const IN_30: usize = 1; -const OUT_30: usize = 64; -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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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_30] = [__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[30].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_31: usize = 2; -const IN_31: usize = 2; -const OUT_31: usize = 1; -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 __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_31] = [__v_0]; record.function_queries[31].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(1).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_31] = { let __args: [G; IN_31] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_31] = [__v_6]; record.function_queries[31].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_32: usize = 6; -const IN_32: usize = 6; -const OUT_32: usize = 1; -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 __v_1: G = inp[1]; let __v_2: G = 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_8 + __v_6; let __v_18: G = __v_17 + __v_7; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).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_37] = { let __args: [G; IN_37] = [__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(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_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(13).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_32] = [__v_107]; record.function_queries[32].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_32] = [__v_5]; record.function_queries[32].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_32] = [__v_5]; record.function_queries[32].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_32] = [__v_5]; record.function_queries[32].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_32] = [__v_5]; record.function_queries[32].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_32] = [__v_5]; record.function_queries[32].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_32] = [__v_5]; record.function_queries[32].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_32] = [__v_5]; record.function_queries[32].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_32] = [__v_5]; record.function_queries[32].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(12).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(13).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_32] = [__v_42]; record.function_queries[32].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_6] = { let __args: [G; IN_6] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__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_7 + __v_18; let __v_20: G = __v_2 - __v_1; let __v_21: G = G::from_bool(__v_20 == G::ZERO); let __v_22: G = __v_21 * __v_6; let __v_23: G = __v_19 + __v_22; let __v_24: G = G::from_u64(64); let __v_25: G = __v_24 - __v_1; let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(31, &__args[..])?) { [G::ZERO; OUT_31] } else { let (__hash, __hit) = record.function_queries[31].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[31].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[31].bump_multiplicity(__i); } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => { aiur_fn_31::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(30, &__args[..])?) { [G::ZERO; OUT_30] } else { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[30].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__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(12).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_37] = { let __args: [G; IN_37] = [__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(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_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(13).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_32] = [__v_171]; record.function_queries[32].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_33: usize = 6; -const IN_33: usize = 6; -const OUT_33: usize = 1; -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]; let __v_2: G = 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_30] = { let __args: [G; IN_30] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(30, &__args[..])?) { [G::ZERO; OUT_30] } else { let (__hash, __hit) = record.function_queries[30].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[30].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => { aiur_fn_30::(__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_773] = { let __args: [G; IN_773] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(773, &__args[..])?) { [G::ZERO; OUT_773] } else { let (__hash, __hit) = record.function_queries[773].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[773].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[773].bump_multiplicity(__i); } let __ret: [G; OUT_773] = unsafe { *(record.function_queries[773].output_at(__i).as_ptr() as *const [G; OUT_773]) }; __ret }, _ => { aiur_fn_773::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = __v_8 * __v_73; 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_75: G = __loaded[0]; let __v_76: G = __loaded[1]; let __v_77: G = __loaded[2]; let __v_78: G = __loaded[3]; let __v_79: G = __loaded[4]; let __v_80: G = __loaded[5]; let __v_81: G = __loaded[6]; let __v_82: G = __loaded[7]; let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __v_84: G = __v_74 * __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(12).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_37] = { let __args: [G; IN_37] = [__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_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __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(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_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(13).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(1).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_16] = { let __args: [G; IN_16] = [__v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(16, &__args[..])?) { [G::ZERO; OUT_16] } else { let (__hash, __hit) = record.function_queries[16].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[16].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => { aiur_fn_16::(__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(12).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_26] = { let __args: [G; IN_26] = [__v_0, __v_185, __v_150, __v_150, __v_194, __v_195, __v_183]; 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_196: G = __r_arr[0]; let __ret: [G; OUT_33] = [__v_196]; record.function_queries[33].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(773, &__args[..])?) { [G::ZERO; OUT_773] } else { let (__hash, __hit) = record.function_queries[773].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[773].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[773].bump_multiplicity(__i); } let __ret: [G; OUT_773] = unsafe { *(record.function_queries[773].output_at(__i).as_ptr() as *const [G; OUT_773]) }; __ret }, _ => { aiur_fn_773::(__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_773] = { let __args: [G; IN_773] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(773, &__args[..])?) { [G::ZERO; OUT_773] } else { let (__hash, __hit) = record.function_queries[773].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[773].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[773].bump_multiplicity(__i); } let __ret: [G; OUT_773] = unsafe { *(record.function_queries[773].output_at(__i).as_ptr() as *const [G; OUT_773]) }; __ret }, _ => { aiur_fn_773::(__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_6] = { let __args: [G; IN_6] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __v_85: G = __v_75 * __v_84; let __v_86: G = __v_85 * __v_8; 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_74 + __v_86; let __v_92: G = __v_91 + __v_90; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).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_37] = { let __args: [G; IN_37] = [__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(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_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(1).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(12).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_26] = { let __args: [G; IN_26] = [__v_0, __v_175, __v_141, __v_176, __v_3, __v_177, __v_5]; 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_178: G = __r_arr[0]; let __ret: [G; OUT_33] = [__v_178]; record.function_queries[33].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_34: usize = 24; -const IN_34: usize = 24; -const OUT_34: usize = 16; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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 = __v_28 * __v_30; let __v_32: G = G::from_u64(2); let __v_33: G = __v_28 - __v_32; let __v_34: G = __v_31 * __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_63; let __v_65: G = __v_62 - __v_32; let __v_66: G = __v_64 * __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_34] = [__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[34].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_35: usize = 128; -const IN_35: usize = 128; -const OUT_35: usize = 128; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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 = __v_132 * __v_134; let __v_136: G = G::from_u64(2); let __v_137: G = __v_132 - __v_136; let __v_138: G = __v_135 * __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_167; let __v_169: G = __v_166 - __v_136; let __v_170: G = __v_168 * __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_198; let __v_200: G = __v_197 - __v_136; let __v_201: G = __v_199 * __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_229; let __v_231: G = __v_228 - __v_136; let __v_232: G = __v_230 * __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_260; let __v_262: G = __v_259 - __v_136; let __v_263: G = __v_261 * __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_291; let __v_293: G = __v_290 - __v_136; let __v_294: G = __v_292 * __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_322; let __v_324: G = __v_321 - __v_136; let __v_325: G = __v_323 * __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_353; let __v_355: G = __v_352 - __v_136; let __v_356: G = __v_354 * __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_384; let __v_386: G = __v_383 - __v_136; let __v_387: G = __v_385 * __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_415; let __v_417: G = __v_414 - __v_136; let __v_418: G = __v_416 * __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_446; let __v_448: G = __v_445 - __v_136; let __v_449: G = __v_447 * __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_477; let __v_479: G = __v_476 - __v_136; let __v_480: G = __v_478 * __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_508; let __v_510: G = __v_507 - __v_136; let __v_511: G = __v_509 * __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_539; let __v_541: G = __v_538 - __v_136; let __v_542: G = __v_540 * __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_570; let __v_572: G = __v_569 - __v_136; let __v_573: G = __v_571 * __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_601; let __v_603: G = __v_600 - __v_136; let __v_604: G = __v_602 * __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_35] = [__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[35].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_36: usize = 106; -const IN_36: usize = 106; -const OUT_36: usize = 32; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_37] = { let __args: [G; IN_37] = [__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(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_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_36] = [__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[36].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_37: usize = 129; -const IN_37: usize = 129; -const OUT_37: usize = 32; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_37] = [__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[37].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 = __v_133 * __v_135; let __v_137: G = G::from_u64(2); let __v_138: G = __v_133 - __v_137; let __v_139: G = __v_136 * __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_168; let __v_170: G = __v_167 - __v_137; let __v_171: G = __v_169 * __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_199; let __v_201: G = __v_198 - __v_137; let __v_202: G = __v_200 * __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_230; let __v_232: G = __v_229 - __v_137; let __v_233: G = __v_231 * __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_261; let __v_263: G = __v_260 - __v_137; let __v_264: G = __v_262 * __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_292; let __v_294: G = __v_291 - __v_137; let __v_295: G = __v_293 * __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_323; let __v_325: G = __v_322 - __v_137; let __v_326: G = __v_324 * __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_354; let __v_356: G = __v_353 - __v_137; let __v_357: G = __v_355 * __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_385; let __v_387: G = __v_384 - __v_137; let __v_388: G = __v_386 * __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_416; let __v_418: G = __v_415 - __v_137; let __v_419: G = __v_417 * __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_447; let __v_449: G = __v_446 - __v_137; let __v_450: G = __v_448 * __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_478; let __v_480: G = __v_477 - __v_137; let __v_481: G = __v_479 * __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_509; let __v_511: G = __v_508 - __v_137; let __v_512: G = __v_510 * __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_540; let __v_542: G = __v_539 - __v_137; let __v_543: G = __v_541 * __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_571; let __v_573: G = __v_570 - __v_137; let __v_574: G = __v_572 * __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_602; let __v_604: G = __v_601 - __v_137; let __v_605: G = __v_603 * __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_37] = { let __args: [G; IN_37] = [__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(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_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_37] = [__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[37].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_38: usize = 19; -const IN_38: usize = 19; -const OUT_38: usize = 1; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; match __v_0.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_38] = [__v_20]; record.function_queries[38].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_19: G = G::from_u64(1); let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_38] = [__v_20]; record.function_queries[38].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(761, &__args[..])?) { [G::ZERO; OUT_761] } else { let (__hash, __hit) = record.function_queries[761].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[761].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[761].bump_multiplicity(__i); } let __ret: [G; OUT_761] = unsafe { *(record.function_queries[761].output_at(__i).as_ptr() as *const [G; OUT_761]) }; __ret }, _ => { aiur_fn_761::(__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 = G::from_u64(2); let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_9, __v_18]; 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_28: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_38] = [__v_30]; record.function_queries[38].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(761, &__args[..])?) { [G::ZERO; OUT_761] } else { let (__hash, __hit) = record.function_queries[761].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[761].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[761].bump_multiplicity(__i); } let __ret: [G; OUT_761] = unsafe { *(record.function_queries[761].output_at(__i).as_ptr() as *const [G; OUT_761]) }; __ret }, _ => { aiur_fn_761::(__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 = G::from_u64(3); let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_9, __v_18]; 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_28: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_38] = [__v_30]; record.function_queries[38].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; let __v_22: G = __loaded[3]; let __v_23: G = __loaded[4]; let __v_24: G = __loaded[5]; let __v_25: G = __loaded[6]; let __v_26: G = __loaded[7]; let __v_27: G = __loaded[8]; let __v_28: G = __loaded[9]; let __v_29: G = __loaded[10]; let __v_30: G = __loaded[11]; let __v_31: G = __loaded[12]; let __v_32: G = __loaded[13]; let __v_33: G = __loaded[14]; let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; let __v_37: G = G::from_u64(4); let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_18]; let __cu = unconstrained; if ((!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_38: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_37, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __ret: [G; OUT_38] = [__v_40]; record.function_queries[38].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_19: G = G::from_u64(5); let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_38] = [__v_20]; record.function_queries[38].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_19: G = G::from_u64(6); let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_38] = [__v_20]; record.function_queries[38].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __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 __v_21: G = __r_arr[2]; let __v_22: G = __r_arr[3]; let __v_23: G = __r_arr[4]; let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(7); let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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(53, &__args[..])?) { [G::ZERO; OUT_53] } else { let (__hash, __hit) = record.function_queries[53].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[53].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[53].bump_multiplicity(__i); } let __ret: [G; OUT_53] = unsafe { *(record.function_queries[53].output_at(__i).as_ptr() as *const [G; OUT_53]) }; __ret }, _ => { aiur_fn_53::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_38] = [__v_29]; record.function_queries[38].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(51, &__args[..])?) { [G::ZERO; OUT_51] } else { let (__hash, __hit) = record.function_queries[51].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[51].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[51].bump_multiplicity(__i); } let __ret: [G; OUT_51] = unsafe { *(record.function_queries[51].output_at(__i).as_ptr() as *const [G; OUT_51]) }; __ret }, _ => { aiur_fn_51::(__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 = G::from_u64(8); let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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(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_28: G = __r_arr[0]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_38] = [__v_29]; record.function_queries[38].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(52, &__args[..])?) { [G::ZERO; OUT_52] } else { let (__hash, __hit) = record.function_queries[52].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[52].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => { aiur_fn_52::(__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 = G::from_u64(9); let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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(55, &__args[..])?) { [G::ZERO; OUT_55] } else { let (__hash, __hit) = record.function_queries[55].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[55].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[55].bump_multiplicity(__i); } let __ret: [G; OUT_55] = unsafe { *(record.function_queries[55].output_at(__i).as_ptr() as *const [G; OUT_55]) }; __ret }, _ => { aiur_fn_55::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_38] = [__v_29]; record.function_queries[38].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { match __v_1.as_canonical_u64() { _ => { let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; let __v_22: G = __loaded[3]; let __v_23: G = __loaded[4]; let __v_24: G = __loaded[5]; let __v_25: G = __loaded[6]; let __v_26: G = __loaded[7]; let __v_27: G = __loaded[8]; let __v_28: G = __loaded[9]; let __v_29: G = __loaded[10]; let __v_30: G = __loaded[11]; let __v_31: G = __loaded[12]; let __v_32: G = __loaded[13]; let __v_33: G = __loaded[14]; let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; let __v_40: G = __loaded[3]; let __v_41: G = __loaded[4]; let __v_42: G = __loaded[5]; let __v_43: G = __loaded[6]; let __v_44: G = __loaded[7]; let __v_45: G = __loaded[8]; let __v_46: G = __loaded[9]; let __v_47: G = __loaded[10]; let __v_48: G = __loaded[11]; let __v_49: G = __loaded[12]; let __v_50: G = __loaded[13]; let __v_51: G = __loaded[14]; let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; let __v_58: G = __loaded[3]; let __v_59: G = __loaded[4]; let __v_60: G = __loaded[5]; let __v_61: G = __loaded[6]; let __v_62: G = __loaded[7]; let __v_63: G = __loaded[8]; let __v_64: G = __loaded[9]; let __v_65: G = __loaded[10]; let __v_66: G = __loaded[11]; let __v_67: G = __loaded[12]; let __v_68: G = __loaded[13]; let __v_69: G = __loaded[14]; let __v_70: G = __loaded[15]; let __v_71: G = __loaded[16]; let __v_72: G = __loaded[17]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { 0u64 => { let __v_73: G = G::from_u64(0); break '__mc_0 [__v_73]; }, 1u64 => { let __v_73: G = G::from_u64(1); break '__mc_0 [__v_73]; }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }; let __v_73: G = __mc_out___mc_0[0]; let __v_74: G = G::from_u64(2); let __v_75: G = __v_74 * __v_73; let __v_76: G = __v_1 + __v_75; let __v_77: G = G::from_u64(0); let __v_78: G = G::from_u64(10); let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_18]; let __cu = unconstrained; if ((!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_79: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_79]; 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_80: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_80]; 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_81: G = __r_arr[0]; let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_3, __v_4, __v_5, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(48, &__args[..])?) { [G::ZERO; OUT_48] } else { let (__hash, __hit) = record.function_queries[48].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[48].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => { aiur_fn_48::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_78, __v_76, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_82]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __ret: [G; OUT_38] = [__v_83]; record.function_queries[38].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 11u64 => { let __v_19: G = G::from_u64(11); let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_38] = [__v_20]; record.function_queries[38].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_39: usize = 10; -const IN_39: usize = 10; -const OUT_39: usize = 1; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; match __v_8.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_39] = [__v_9]; record.function_queries[39].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = __v_8 - __v_11; let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_12, __v_9]; 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_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_10, __v_0, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_14]; record.function_queries[39].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_40: usize = 10; -const IN_40: usize = 10; -const OUT_40: usize = 1; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = __v_2 + __v_3; let __v_11: G = __v_10 + __v_4; let __v_12: G = __v_11 + __v_5; let __v_13: G = __v_12 + __v_6; let __v_14: G = __v_13 + __v_7; let __v_15: G = __v_14 + __v_8; match __v_15.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(8); let __v_17: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_1, &__v_16) } else { aiur::execute::bytes2_less_than_value(__v_1, __v_16, record) }; match __v_17.as_canonical_u64() { 1u64 => { let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(16); let __v_20: G = __v_19 * __v_0; let __v_21: G = __v_20 + __v_1; let __v_22: G = { let __values: [G; 3] = [__v_18, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_40] = [__v_22]; record.function_queries[40].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_18: G = G::from_u64(16); let __v_19: G = __v_18 * __v_0; let __v_20: G = G::from_u64(4); let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_19, __v_20, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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_21: G = __r_arr[0]; let __ret: [G; OUT_40] = [__v_21]; record.function_queries[40].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }, _ => { let __v_16: G = G::from_u64(16); let __v_17: G = __v_16 * __v_0; let __v_18: G = G::from_u64(4); let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_17, __v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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_19: G = __r_arr[0]; let __ret: [G; OUT_40] = [__v_19]; record.function_queries[40].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_41: usize = 10; -const IN_41: usize = 10; -const OUT_41: usize = 1; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = __v_2 + __v_3; let __v_11: G = __v_10 + __v_4; let __v_12: G = __v_11 + __v_5; let __v_13: G = __v_12 + __v_6; let __v_14: G = __v_13 + __v_7; let __v_15: G = __v_14 + __v_8; match __v_15.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(32); let __v_17: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_1, &__v_16) } else { aiur::execute::bytes2_less_than_value(__v_1, __v_16, record) }; match __v_17.as_canonical_u64() { 1u64 => { let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(64); let __v_20: G = __v_19 * __v_0; let __v_21: G = __v_20 + __v_1; let __v_22: G = { let __values: [G; 3] = [__v_18, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_22]; record.function_queries[41].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_18: G = G::from_u64(64); let __v_19: G = __v_18 * __v_0; let __v_20: G = G::from_u64(16); let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_19, __v_20, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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_21: G = __r_arr[0]; let __ret: [G; OUT_41] = [__v_21]; record.function_queries[41].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }, _ => { let __v_16: G = G::from_u64(64); let __v_17: G = __v_16 * __v_0; let __v_18: G = G::from_u64(16); let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_17, __v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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_19: G = __r_arr[0]; let __ret: [G; OUT_41] = [__v_19]; record.function_queries[41].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_42: usize = 9; -const IN_42: usize = 9; -const OUT_42: usize = 1; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = __v_1 + __v_2; let __v_10: G = __v_9 + __v_3; let __v_11: G = __v_10 + __v_4; let __v_12: G = __v_11 + __v_5; let __v_13: G = __v_12 + __v_6; let __v_14: G = __v_13 + __v_7; match __v_14.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(128); let __v_16: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_0, &__v_15) } else { aiur::execute::bytes2_less_than_value(__v_0, __v_15, record) }; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 3] = [__v_17, __v_0, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_42] = [__v_18]; record.function_queries[42].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(64); let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_17, __v_18, __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(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_19: G = __r_arr[0]; let __ret: [G; OUT_42] = [__v_19]; record.function_queries[42].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); }, } }, _ => { let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(64); let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_15, __v_16, __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(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_17: G = __r_arr[0]; let __ret: [G; OUT_42] = [__v_17]; record.function_queries[42].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_43: usize = 11; -const IN_43: usize = 11; -const OUT_43: usize = 1; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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(256); let __v_12: G = G::from_u64(2); let __v_13: G = __v_12 * __v_1; let __v_14: G = __v_11 - __v_13; let __v_15: G = G::from_u64(255); let __v_16: G = __v_15 - __v_1; let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_14, __v_16, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(15, &__args[..])?) { [G::ZERO; OUT_15] } else { let (__hash, __hit) = record.function_queries[15].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[15].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => { aiur_fn_15::(__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]; match __v_25.as_canonical_u64() { 0u64 => { let __v_26: G = G::from_u64(256); let __v_27: G = G::from_u64(2); let __v_28: G = __v_27 * __v_1; let __v_29: G = __v_26 - __v_28; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add(&__v_2, &__v_29) } else { aiur::execute::bytes2_add_value(__v_2, __v_29, record) }; let __v_30: G = __b2_out.0; let __v_31: G = __b2_out.1; let __v_32: G = __v_3 + __v_31; let __v_33: G = G::from_u64(1); let __v_34: G = __v_32 - __v_33; let __v_35: G = G::from_u64(0); let __v_36: G = __v_0 + __v_28; let __v_37: G = __v_36 + __v_34; let __v_38: G = { let __values: [G; 3] = [__v_35, __v_30, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_35, __v_37, __v_38]; let __mq = record.memory_queries.get_index_mut(1).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_39]; record.function_queries[43].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_26: G = G::from_u64(3); let __v_27: G = __v_26 * __v_1; let __v_28: G = __v_0 + __v_27; let __v_29: G = G::from_u64(0); let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_28, __v_29, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_10]; 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_30: G = __r_arr[0]; let __ret: [G; OUT_43] = [__v_30]; record.function_queries[43].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); }, } }) } -const INPUT_SIZE_44: usize = 11; -const IN_44: usize = 11; -const OUT_44: usize = 1; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; match __v_1.as_canonical_u64() { 0u64 => { let __v_11: G = __v_4 + __v_5; let __v_12: G = __v_11 + __v_6; let __v_13: G = __v_12 + __v_7; let __v_14: G = __v_13 + __v_8; let __v_15: G = __v_14 + __v_9; match __v_15.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(2); let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_17, __v_10]; 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_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 3] = [__v_16, __v_0, __v_18]; let __mq = record.memory_queries.get_index_mut(1).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_44] = [__v_19]; record.function_queries[44].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(255); let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_16, __v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(15, &__args[..])?) { [G::ZERO; OUT_15] } else { let (__hash, __hit) = record.function_queries[15].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[15].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => { aiur_fn_15::(__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 = __r_arr[4]; let __v_23: G = __r_arr[5]; let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; let __v_26: G = __r_arr[8]; let __v_27: G = G::from_u64(1); let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_27, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_10]; 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_28: G = __r_arr[0]; let __ret: [G; OUT_44] = [__v_28]; record.function_queries[44].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 1u64 => { let __v_11: G = __v_5 + __v_6; let __v_12: G = __v_11 + __v_7; let __v_13: G = __v_12 + __v_8; let __v_14: G = __v_13 + __v_9; match __v_14.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(1); let __v_17: G = __v_0 + __v_16; let __v_18: G = G::from_u64(3); let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_18, __v_10]; 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_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 3] = [__v_15, __v_17, __v_19]; let __mq = record.memory_queries.get_index_mut(1).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_44] = [__v_20]; record.function_queries[44].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(255); let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_15, __v_15, __v_15, __v_16, __v_16, __v_16, __v_16, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(15, &__args[..])?) { [G::ZERO; OUT_15] } else { let (__hash, __hit) = record.function_queries[15].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[15].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => { aiur_fn_15::(__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 = G::from_u64(2); let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_26, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_10]; 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_27: G = __r_arr[0]; let __ret: [G; OUT_44] = [__v_27]; record.function_queries[44].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __v_11: G = __v_6 + __v_7; let __v_12: G = __v_11 + __v_8; let __v_13: G = __v_12 + __v_9; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(2); let __v_16: G = __v_0 + __v_15; let __v_17: G = G::from_u64(4); let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_17, __v_10]; 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_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 3] = [__v_14, __v_16, __v_18]; let __mq = record.memory_queries.get_index_mut(1).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_44] = [__v_19]; record.function_queries[44].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(255); let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_14, __v_14, __v_14, __v_14, __v_15, __v_15, __v_15, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(15, &__args[..])?) { [G::ZERO; OUT_15] } else { let (__hash, __hit) = record.function_queries[15].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[15].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => { aiur_fn_15::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; let __v_19: G = __r_arr[3]; let __v_20: G = __r_arr[4]; let __v_21: G = __r_arr[5]; let __v_22: G = __r_arr[6]; let __v_23: G = __r_arr[7]; let __v_24: G = __r_arr[8]; let __v_25: G = G::from_u64(3); let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_25, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_10]; 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_26: G = __r_arr[0]; let __ret: [G; OUT_44] = [__v_26]; record.function_queries[44].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 3u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(3); let __v_13: G = __v_0 + __v_12; let __v_14: G = G::from_u64(8); let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_14, __v_10]; 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_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 3] = [__v_11, __v_13, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_44] = [__v_16]; record.function_queries[44].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_45: usize = 2; -const IN_45: usize = 2; -const OUT_45: usize = 1; -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]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).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_45] = [__v_1]; record.function_queries[45].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_11, __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_12: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__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(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_45] = [__v_13]; record.function_queries[45].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_46: usize = 2; -const IN_46: usize = 2; -const OUT_46: usize = 1; -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 __v_1: G = inp[1]; match __v_0.as_canonical_u64() { _ => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); break '__mc_0 [__v_2]; }, 1u64 => { let __v_2: G = G::from_u64(1); break '__mc_0 [__v_2]; }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }; let __v_2: G = __mc_out___mc_0[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); break '__mc_1 [__v_3]; }, 1u64 => { let __v_3: G = G::from_u64(1); break '__mc_1 [__v_3]; }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }; let __v_3: G = __mc_out___mc_1[0]; let __v_4: G = G::from_u64(2); let __v_5: G = __v_4 * __v_3; let __v_6: G = __v_2 + __v_5; let __ret: [G; OUT_46] = [__v_6]; record.function_queries[46].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_47: usize = 3; -const IN_47: usize = 3; -const OUT_47: usize = 1; -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]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { _ => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); break '__mc_0 [__v_3]; }, 1u64 => { let __v_3: G = G::from_u64(1); break '__mc_0 [__v_3]; }, 2u64 => { let __v_3: G = G::from_u64(2); break '__mc_0 [__v_3]; }, 3u64 => { let __v_3: G = G::from_u64(3); break '__mc_0 [__v_3]; }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }; let __v_3: G = __mc_out___mc_0[0]; let __v_4: G = G::from_u64(4); let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_1, __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_5: G = __r_arr[0]; let __v_6: G = __v_4 * __v_5; let __v_7: G = __v_3 + __v_6; let __ret: [G; OUT_47] = [__v_7]; record.function_queries[47].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_48: usize = 4; -const IN_48: usize = 4; -const OUT_48: usize = 1; -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 __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 __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_1, __v_2]; 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_5: G = __r_arr[0]; let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_48] = [__v_6]; record.function_queries[48].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_49: usize = 6; -const IN_49: usize = 6; -const OUT_49: usize = 1; -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 __v_1: G = inp[1]; let __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_47] = { let __args: [G; IN_47] = [__v_0, __v_1, __v_2]; 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 = G::from_u64(16); let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_3, __v_4]; 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_8: G = __r_arr[0]; let __v_9: G = __v_7 * __v_8; let __v_10: G = __v_6 + __v_9; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_11, __v_10, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_49] = [__v_12]; record.function_queries[49].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_50: usize = 18; -const IN_50: usize = 18; -const OUT_50: usize = 8; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; match __v_0.as_canonical_u64() { 7u64 => { let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; let __v_21: G = __loaded[3]; let __v_22: G = __loaded[4]; let __v_23: G = __loaded[5]; let __v_24: G = __loaded[6]; let __v_25: G = __loaded[7]; let __v_26: G = __loaded[8]; let __v_27: G = __loaded[9]; let __v_28: G = __loaded[10]; let __v_29: G = __loaded[11]; let __v_30: G = __loaded[12]; let __v_31: G = __loaded[13]; let __v_32: G = __loaded[14]; let __v_33: G = __loaded[15]; let __v_34: G = __loaded[16]; let __v_35: G = __loaded[17]; let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; 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_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; let __v_39: G = __r_arr[3]; let __v_40: G = __r_arr[4]; let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(16, &__args[..])?) { [G::ZERO; OUT_16] } else { let (__hash, __hit) = record.function_queries[16].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[16].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => { aiur_fn_16::(__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 __v_47: G = __r_arr[3]; let __v_48: G = __r_arr[4]; let __v_49: G = __r_arr[5]; let __v_50: G = __r_arr[6]; let __v_51: G = __r_arr[7]; let __ret: [G; OUT_50] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; record.function_queries[50].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_18: G = G::from_u64(0); let __ret: [G; OUT_50] = [__v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; record.function_queries[50].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_51: usize = 18; -const IN_51: usize = 18; -const OUT_51: usize = 8; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; match __v_0.as_canonical_u64() { 8u64 => { let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; let __v_21: G = __loaded[3]; let __v_22: G = __loaded[4]; let __v_23: G = __loaded[5]; let __v_24: G = __loaded[6]; let __v_25: G = __loaded[7]; let __v_26: G = __loaded[8]; let __v_27: G = __loaded[9]; let __v_28: G = __loaded[10]; let __v_29: G = __loaded[11]; let __v_30: G = __loaded[12]; let __v_31: G = __loaded[13]; let __v_32: G = __loaded[14]; let __v_33: G = __loaded[15]; let __v_34: G = __loaded[16]; let __v_35: G = __loaded[17]; let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(51, &__args[..])?) { [G::ZERO; OUT_51] } else { let (__hash, __hit) = record.function_queries[51].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[51].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[51].bump_multiplicity(__i); } let __ret: [G; OUT_51] = unsafe { *(record.function_queries[51].output_at(__i).as_ptr() as *const [G; OUT_51]) }; __ret }, _ => { aiur_fn_51::(__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 __v_39: G = __r_arr[3]; let __v_40: G = __r_arr[4]; let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(16, &__args[..])?) { [G::ZERO; OUT_16] } else { let (__hash, __hit) = record.function_queries[16].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[16].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => { aiur_fn_16::(__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 __v_47: G = __r_arr[3]; let __v_48: G = __r_arr[4]; let __v_49: G = __r_arr[5]; let __v_50: G = __r_arr[6]; let __v_51: G = __r_arr[7]; let __ret: [G; OUT_51] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; record.function_queries[51].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_18: G = G::from_u64(0); let __ret: [G; OUT_51] = [__v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; record.function_queries[51].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_52: usize = 18; -const IN_52: usize = 18; -const OUT_52: usize = 8; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; match __v_0.as_canonical_u64() { 9u64 => { let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; let __v_21: G = __loaded[3]; let __v_22: G = __loaded[4]; let __v_23: G = __loaded[5]; let __v_24: G = __loaded[6]; let __v_25: G = __loaded[7]; let __v_26: G = __loaded[8]; let __v_27: G = __loaded[9]; let __v_28: G = __loaded[10]; let __v_29: G = __loaded[11]; let __v_30: G = __loaded[12]; let __v_31: G = __loaded[13]; let __v_32: G = __loaded[14]; let __v_33: G = __loaded[15]; let __v_34: G = __loaded[16]; let __v_35: G = __loaded[17]; let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(52, &__args[..])?) { [G::ZERO; OUT_52] } else { let (__hash, __hit) = record.function_queries[52].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[52].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => { aiur_fn_52::(__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 __v_39: G = __r_arr[3]; let __v_40: G = __r_arr[4]; let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(16, &__args[..])?) { [G::ZERO; OUT_16] } else { let (__hash, __hit) = record.function_queries[16].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[16].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => { aiur_fn_16::(__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 __v_47: G = __r_arr[3]; let __v_48: G = __r_arr[4]; let __v_49: G = __r_arr[5]; let __v_50: G = __r_arr[6]; let __v_51: G = __r_arr[7]; let __ret: [G; OUT_52] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; record.function_queries[52].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_18: G = G::from_u64(0); let __ret: [G; OUT_52] = [__v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; record.function_queries[52].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_53: usize = 19; -const IN_53: usize = 19; -const OUT_53: usize = 1; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; match __v_0.as_canonical_u64() { 7u64 => { let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; let __v_22: G = __loaded[3]; let __v_23: G = __loaded[4]; let __v_24: G = __loaded[5]; let __v_25: G = __loaded[6]; let __v_26: G = __loaded[7]; let __v_27: G = __loaded[8]; let __v_28: G = __loaded[9]; let __v_29: G = __loaded[10]; let __v_30: G = __loaded[11]; let __v_31: G = __loaded[12]; let __v_32: G = __loaded[13]; let __v_33: G = __loaded[14]; let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; let __v_40: G = __loaded[3]; let __v_41: G = __loaded[4]; let __v_42: G = __loaded[5]; let __v_43: G = __loaded[6]; let __v_44: G = __loaded[7]; let __v_45: G = __loaded[8]; let __v_46: G = __loaded[9]; let __v_47: G = __loaded[10]; let __v_48: G = __loaded[11]; let __v_49: G = __loaded[12]; let __v_50: G = __loaded[13]; let __v_51: G = __loaded[14]; let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if ((!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_55: G = __r_arr[0]; let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(53, &__args[..])?) { [G::ZERO; OUT_53] } else { let (__hash, __hit) = record.function_queries[53].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[53].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[53].bump_multiplicity(__i); } let __ret: [G; OUT_53] = unsafe { *(record.function_queries[53].output_at(__i).as_ptr() as *const [G; OUT_53]) }; __ret }, _ => { aiur_fn_53::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __ret: [G; OUT_53] = [__v_56]; record.function_queries[53].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; 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_19: G = __r_arr[0]; let __ret: [G; OUT_53] = [__v_19]; record.function_queries[53].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_54: usize = 19; -const IN_54: usize = 19; -const OUT_54: usize = 1; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; match __v_0.as_canonical_u64() { 8u64 => { let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; let __v_22: G = __loaded[3]; let __v_23: G = __loaded[4]; let __v_24: G = __loaded[5]; let __v_25: G = __loaded[6]; let __v_26: G = __loaded[7]; let __v_27: G = __loaded[8]; let __v_28: G = __loaded[9]; let __v_29: G = __loaded[10]; let __v_30: G = __loaded[11]; let __v_31: G = __loaded[12]; let __v_32: G = __loaded[13]; let __v_33: G = __loaded[14]; let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; let __v_40: G = __loaded[3]; let __v_41: G = __loaded[4]; let __v_42: G = __loaded[5]; let __v_43: G = __loaded[6]; let __v_44: G = __loaded[7]; let __v_45: G = __loaded[8]; let __v_46: G = __loaded[9]; let __v_47: G = __loaded[10]; let __v_48: G = __loaded[11]; let __v_49: G = __loaded[12]; let __v_50: G = __loaded[13]; let __v_51: G = __loaded[14]; let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if ((!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_55: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if ((!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_56: G = __r_arr[0]; let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_1, __v_2, __v_3, __v_56]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(48, &__args[..])?) { [G::ZERO; OUT_48] } else { let (__hash, __hit) = record.function_queries[48].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[48].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => { aiur_fn_48::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __ret: [G; OUT_54] = [__v_57]; record.function_queries[54].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; 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_19: G = __r_arr[0]; let __ret: [G; OUT_54] = [__v_19]; record.function_queries[54].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_55: usize = 19; -const IN_55: usize = 19; -const OUT_55: usize = 1; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; match __v_0.as_canonical_u64() { 9u64 => { let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; let __v_22: G = __loaded[3]; let __v_23: G = __loaded[4]; let __v_24: G = __loaded[5]; let __v_25: G = __loaded[6]; let __v_26: G = __loaded[7]; let __v_27: G = __loaded[8]; let __v_28: G = __loaded[9]; let __v_29: G = __loaded[10]; let __v_30: G = __loaded[11]; let __v_31: G = __loaded[12]; let __v_32: G = __loaded[13]; let __v_33: G = __loaded[14]; let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; let __v_40: G = __loaded[3]; let __v_41: G = __loaded[4]; let __v_42: G = __loaded[5]; let __v_43: G = __loaded[6]; let __v_44: G = __loaded[7]; let __v_45: G = __loaded[8]; let __v_46: G = __loaded[9]; let __v_47: G = __loaded[10]; let __v_48: G = __loaded[11]; let __v_49: G = __loaded[12]; let __v_50: G = __loaded[13]; let __v_51: G = __loaded[14]; let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(55, &__args[..])?) { [G::ZERO; OUT_55] } else { let (__hash, __hit) = record.function_queries[55].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[55].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[55].bump_multiplicity(__i); } let __ret: [G; OUT_55] = unsafe { *(record.function_queries[55].output_at(__i).as_ptr() as *const [G; OUT_55]) }; __ret }, _ => { aiur_fn_55::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if ((!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_56: G = __r_arr[0]; let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_56]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(49, &__args[..])?) { [G::ZERO; OUT_49] } else { let (__hash, __hit) = record.function_queries[49].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[49].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[49].bump_multiplicity(__i); } let __ret: [G; OUT_49] = unsafe { *(record.function_queries[49].output_at(__i).as_ptr() as *const [G; OUT_49]) }; __ret }, _ => { aiur_fn_49::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __ret: [G; OUT_55] = [__v_57]; record.function_queries[55].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; 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_19: G = __r_arr[0]; let __ret: [G; OUT_55] = [__v_19]; record.function_queries[55].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_56: usize = 2; -const IN_56: usize = 2; -const OUT_56: usize = 1; -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 __v_1: G = inp[1]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).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_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __mq = record.memory_queries.get_index_mut(1).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_34, __v_32, __v_35]; let __mq = record.memory_queries.get_index_mut(1).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_34, __v_31, __v_36]; let __mq = record.memory_queries.get_index_mut(1).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_34, __v_30, __v_37]; let __mq = record.memory_queries.get_index_mut(1).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_34, __v_29, __v_38]; let __mq = record.memory_queries.get_index_mut(1).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_40: G = { let __values: [G; 3] = [__v_34, __v_28, __v_39]; let __mq = record.memory_queries.get_index_mut(1).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_41: G = { let __values: [G; 3] = [__v_34, __v_27, __v_40]; let __mq = record.memory_queries.get_index_mut(1).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_42: G = { let __values: [G; 3] = [__v_34, __v_26, __v_41]; let __mq = record.memory_queries.get_index_mut(1).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_43: G = { let __values: [G; 3] = [__v_34, __v_25, __v_42]; let __mq = record.memory_queries.get_index_mut(1).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_44: G = { let __values: [G; 3] = [__v_34, __v_24, __v_43]; let __mq = record.memory_queries.get_index_mut(1).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_45: G = { let __values: [G; 3] = [__v_34, __v_23, __v_44]; let __mq = record.memory_queries.get_index_mut(1).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_46: G = { let __values: [G; 3] = [__v_34, __v_22, __v_45]; let __mq = record.memory_queries.get_index_mut(1).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_47: G = { let __values: [G; 3] = [__v_34, __v_21, __v_46]; let __mq = record.memory_queries.get_index_mut(1).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_48: G = { let __values: [G; 3] = [__v_34, __v_20, __v_47]; let __mq = record.memory_queries.get_index_mut(1).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_49: G = { let __values: [G; 3] = [__v_34, __v_19, __v_48]; let __mq = record.memory_queries.get_index_mut(1).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_50: G = { let __values: [G; 3] = [__v_34, __v_18, __v_49]; let __mq = record.memory_queries.get_index_mut(1).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_51: G = { let __values: [G; 3] = [__v_34, __v_17, __v_50]; let __mq = record.memory_queries.get_index_mut(1).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_52: G = { let __values: [G; 3] = [__v_34, __v_16, __v_51]; let __mq = record.memory_queries.get_index_mut(1).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_53: G = { let __values: [G; 3] = [__v_34, __v_15, __v_52]; let __mq = record.memory_queries.get_index_mut(1).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_54: G = { let __values: [G; 3] = [__v_34, __v_14, __v_53]; let __mq = record.memory_queries.get_index_mut(1).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; 3] = [__v_34, __v_13, __v_54]; let __mq = record.memory_queries.get_index_mut(1).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_56: G = { let __values: [G; 3] = [__v_34, __v_12, __v_55]; let __mq = record.memory_queries.get_index_mut(1).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_57: G = { let __values: [G; 3] = [__v_34, __v_11, __v_56]; let __mq = record.memory_queries.get_index_mut(1).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_58: G = { let __values: [G; 3] = [__v_34, __v_10, __v_57]; let __mq = record.memory_queries.get_index_mut(1).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_59: G = { let __values: [G; 3] = [__v_34, __v_9, __v_58]; let __mq = record.memory_queries.get_index_mut(1).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_60: G = { let __values: [G; 3] = [__v_34, __v_8, __v_59]; let __mq = record.memory_queries.get_index_mut(1).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_61: G = { let __values: [G; 3] = [__v_34, __v_7, __v_60]; let __mq = record.memory_queries.get_index_mut(1).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_62: G = { let __values: [G; 3] = [__v_34, __v_6, __v_61]; let __mq = record.memory_queries.get_index_mut(1).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_63: G = { let __values: [G; 3] = [__v_34, __v_5, __v_62]; let __mq = record.memory_queries.get_index_mut(1).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_64: G = { let __values: [G; 3] = [__v_34, __v_4, __v_63]; let __mq = record.memory_queries.get_index_mut(1).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_65: G = { let __values: [G; 3] = [__v_34, __v_3, __v_64]; let __mq = record.memory_queries.get_index_mut(1).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_66: G = { let __values: [G; 3] = [__v_34, __v_2, __v_65]; let __mq = record.memory_queries.get_index_mut(1).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_56] = [__v_66]; 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 = 1; -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_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_57] = [__v_2]; record.function_queries[57].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_57] = [__v_2]; record.function_queries[57].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(2); let __ret: [G; OUT_57] = [__v_2]; record.function_queries[57].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }, 1u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(4); let __ret: [G; OUT_57] = [__v_2]; record.function_queries[57].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(5); let __ret: [G; OUT_57] = [__v_2]; record.function_queries[57].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(6); let __ret: [G; OUT_57] = [__v_2]; record.function_queries[57].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }, 2u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(8); let __ret: [G; OUT_57] = [__v_2]; record.function_queries[57].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(9); let __ret: [G; OUT_57] = [__v_2]; record.function_queries[57].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(10); let __ret: [G; OUT_57] = [__v_2]; record.function_queries[57].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_58: usize = 9; -const IN_58: usize = 9; -const OUT_58: usize = 8; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; match __v_0.as_canonical_u64() { 1u64 => { let __loaded: [G; 9] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; 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: 9 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __v_17: G = __loaded[8]; let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(58, &__args[..])?) { [G::ZERO; OUT_58] } else { let (__hash, __hit) = record.function_queries[58].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[58].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[58].bump_multiplicity(__i); } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => { aiur_fn_58::(__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 = __r_arr[4]; let __v_23: G = __r_arr[5]; let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(16, &__args[..])?) { [G::ZERO; OUT_16] } else { let (__hash, __hit) = record.function_queries[16].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[16].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => { aiur_fn_16::(__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 __ret: [G; OUT_58] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; record.function_queries[58].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_58] = [__v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; record.function_queries[58].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_59: usize = 9; -const IN_59: usize = 9; -const OUT_59: usize = 9; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; match __v_0.as_canonical_u64() { 1u64 => { let __loaded: [G; 9] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; 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: 9 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __v_17: G = __loaded[8]; let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; 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_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; let __v_22: G = __r_arr[4]; let __v_23: G = __r_arr[5]; let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; let __v_26: G = __r_arr[8]; let __ret: [G; OUT_59] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; record.function_queries[59].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_59] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[59].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_60: usize = 10; -const IN_60: usize = 10; -const OUT_60: usize = 1; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; match __v_0.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_10, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_60] = [__v_11]; record.function_queries[60].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__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(58, &__args[..])?) { [G::ZERO; OUT_58] } else { let (__hash, __hit) = record.function_queries[58].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[58].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[58].bump_multiplicity(__i); } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => { aiur_fn_58::(__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 __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__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(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_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; let __v_22: G = __r_arr[4]; let __v_23: G = __r_arr[5]; let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; let __v_26: G = __r_arr[8]; let __v_27: G = G::from_u64(0); let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_9]; 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_28: G = __r_arr[0]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_27, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_28]; 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_29: G = __r_arr[0]; let __ret: [G; OUT_60] = [__v_29]; record.function_queries[60].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __loaded: [G; 9] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; 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: 9 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; let __v_14: G = __loaded[4]; let __v_15: G = __loaded[5]; let __v_16: G = __loaded[6]; let __v_17: G = __loaded[7]; let __v_18: G = __loaded[8]; let __loaded: [G; 9] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; 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: 9 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; let __v_22: G = __loaded[3]; let __v_23: G = __loaded[4]; let __v_24: G = __loaded[5]; let __v_25: G = __loaded[6]; let __v_26: G = __loaded[7]; let __v_27: G = __loaded[8]; let __v_28: G = G::from_u64(1); let __v_29: G = G::from_u64(0); let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; 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_30: G = __r_arr[0]; let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_30]; 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_31: G = __r_arr[0]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_28, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_31]; 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_32: G = __r_arr[0]; let __ret: [G; OUT_60] = [__v_32]; record.function_queries[60].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __loaded: [G; 9] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; 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: 9 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; let __v_14: G = __loaded[4]; let __v_15: G = __loaded[5]; let __v_16: G = __loaded[6]; let __v_17: G = __loaded[7]; let __v_18: G = __loaded[8]; let __loaded: [G; 9] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; 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: 9 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; let __v_22: G = __loaded[3]; let __v_23: G = __loaded[4]; let __v_24: G = __loaded[5]; let __v_25: G = __loaded[6]; let __v_26: G = __loaded[7]; let __v_27: G = __loaded[8]; let __v_28: G = G::from_u64(2); let __v_29: G = G::from_u64(0); let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; 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_30: G = __r_arr[0]; let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_30]; 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_31: G = __r_arr[0]; let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_28, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_31]; 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_32: G = __r_arr[0]; let __ret: [G; OUT_60] = [__v_32]; record.function_queries[60].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_10: G = G::from_u64(3); let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_60] = [__v_11]; record.function_queries[60].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_61: usize = 2; -const IN_61: usize = 2; -const OUT_61: usize = 1; -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 __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_61] = [__v_1]; record.function_queries[61].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; let __v_9: G = __loaded[4]; let __v_10: G = __loaded[5]; let __v_11: G = __loaded[6]; let __v_12: G = __loaded[7]; let __v_13: G = __loaded[8]; let __v_14: G = __loaded[9]; let __v_15: G = __loaded[10]; let __v_16: G = __loaded[11]; let __v_17: G = __loaded[12]; let __v_18: G = __loaded[13]; let __v_19: G = __loaded[14]; let __v_20: G = __loaded[15]; let __v_21: G = __loaded[16]; let __v_22: G = __loaded[17]; let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(61, &__args[..])?) { [G::ZERO; OUT_61] } else { let (__hash, __hit) = record.function_queries[61].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[61].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[61].bump_multiplicity(__i); } let __ret: [G; OUT_61] = unsafe { *(record.function_queries[61].output_at(__i).as_ptr() as *const [G; OUT_61]) }; __ret }, _ => { aiur_fn_61::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if ((!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_24: G = __r_arr[0]; let __ret: [G; OUT_61] = [__v_24]; record.function_queries[61].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_62: usize = 2; -const IN_62: usize = 2; -const OUT_62: usize = 1; -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 __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_62] = [__v_1]; record.function_queries[62].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 9] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; 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: 9 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; let __v_9: G = __loaded[4]; let __v_10: G = __loaded[5]; let __v_11: G = __loaded[6]; let __v_12: G = __loaded[7]; let __v_13: G = __loaded[8]; let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(62, &__args[..])?) { [G::ZERO; OUT_62] } else { let (__hash, __hit) = record.function_queries[62].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[62].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[62].bump_multiplicity(__i); } let __ret: [G; OUT_62] = unsafe { *(record.function_queries[62].output_at(__i).as_ptr() as *const [G; OUT_62]) }; __ret }, _ => { aiur_fn_62::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__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(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_15: G = __r_arr[0]; let __ret: [G; OUT_62] = [__v_15]; record.function_queries[62].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_63: usize = 2; -const IN_63: usize = 2; -const OUT_63: usize = 1; -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]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_63] = [__v_1]; record.function_queries[63].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_4, __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_5: G = __r_arr[0]; let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(56, &__args[..])?) { [G::ZERO; OUT_56] } else { let (__hash, __hit) = record.function_queries[56].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[56].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => { aiur_fn_56::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_6]; record.function_queries[63].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_64: usize = 2; -const IN_64: usize = 2; -const OUT_64: usize = 1; -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 __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_1]; let __mq = record.memory_queries.get_index_mut(1).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_64] = [__v_3]; record.function_queries[64].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_index_mut(1).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_64] = [__v_4]; record.function_queries[64].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(2); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_index_mut(1).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_64] = [__v_4]; record.function_queries[64].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(3); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_index_mut(1).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_64] = [__v_4]; record.function_queries[64].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_65: usize = 13; -const IN_65: usize = 13; -const OUT_65: usize = 1; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { _ => { let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; let __v_16: G = __loaded[3]; let __v_17: G = __loaded[4]; let __v_18: G = __loaded[5]; let __v_19: G = __loaded[6]; let __v_20: G = __loaded[7]; let __v_21: G = __loaded[8]; let __v_22: G = __loaded[9]; let __v_23: G = __loaded[10]; let __v_24: G = __loaded[11]; let __v_25: G = __loaded[12]; let __v_26: G = __loaded[13]; let __v_27: G = __loaded[14]; let __v_28: G = __loaded[15]; let __v_29: G = __loaded[16]; let __v_30: G = __loaded[17]; let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; let __v_34: G = __loaded[3]; let __v_35: G = __loaded[4]; let __v_36: G = __loaded[5]; let __v_37: G = __loaded[6]; let __v_38: G = __loaded[7]; let __v_39: G = __loaded[8]; let __v_40: G = __loaded[9]; let __v_41: G = __loaded[10]; let __v_42: G = __loaded[11]; let __v_43: G = __loaded[12]; let __v_44: G = __loaded[13]; let __v_45: G = __loaded[14]; let __v_46: G = __loaded[15]; let __v_47: G = __loaded[16]; let __v_48: G = __loaded[17]; let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_0, __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_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_12]; let __cu = unconstrained; if ((!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_51: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_51]; let __cu = unconstrained; if ((!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_52: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = { let __values: [G; 3] = [__v_50, __v_49, __v_53]; let __mq = record.memory_queries.get_index_mut(1).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_65] = [__v_54]; record.function_queries[65].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_66: usize = 10; -const IN_66: usize = 10; -const OUT_66: usize = 1; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; match __v_0.as_canonical_u64() { _ => { let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; let __v_14: G = __loaded[4]; let __v_15: G = __loaded[5]; let __v_16: G = __loaded[6]; let __v_17: G = __loaded[7]; let __v_18: G = __loaded[8]; let __v_19: G = __loaded[9]; let __v_20: G = __loaded[10]; let __v_21: G = __loaded[11]; let __v_22: G = __loaded[12]; let __v_23: G = __loaded[13]; let __v_24: G = __loaded[14]; let __v_25: G = __loaded[15]; let __v_26: G = __loaded[16]; let __v_27: G = __loaded[17]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; 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_28: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_66] = [__v_29]; record.function_queries[66].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_67: usize = 2; -const IN_67: usize = 2; -const OUT_67: usize = 1; -fn aiur_fn_67(inp: [G; IN_67], 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 __v_1: G = inp[1]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).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_67] = [__v_1]; record.function_queries[67].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_12, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(67, &__args[..])?) { [G::ZERO; OUT_67] } else { let (__hash, __hit) = record.function_queries[67].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[67].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => { aiur_fn_67::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_14]; record.function_queries[67].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_68: usize = 45; -const IN_68: usize = 45; -const OUT_68: usize = 1; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; match __v_0.as_canonical_u64() { _ => { let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_45: G = __loaded[0]; let __v_46: G = __loaded[1]; let __v_47: G = __loaded[2]; let __v_48: G = __loaded[3]; let __v_49: G = __loaded[4]; let __v_50: G = __loaded[5]; let __v_51: G = __loaded[6]; let __v_52: G = __loaded[7]; let __v_53: G = __loaded[8]; let __v_54: G = __loaded[9]; let __v_55: G = __loaded[10]; let __v_56: G = __loaded[11]; let __v_57: G = __loaded[12]; let __v_58: G = __loaded[13]; let __v_59: G = __loaded[14]; let __v_60: G = __loaded[15]; let __v_61: G = __loaded[16]; let __v_62: G = __loaded[17]; let __v_63: G = G::from_u64(2); let __v_64: G = __v_63 * __v_1; let __v_65: G = __v_0 + __v_64; let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(771, &__args[..])?) { [G::ZERO; OUT_771] } else { let (__hash, __hit) = record.function_queries[771].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[771].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[771].bump_multiplicity(__i); } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => { aiur_fn_771::(__args, __hash, record, io_buffer)? }, } } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; let __v_69: G = __r_arr[3]; let __v_70: G = __r_arr[4]; let __v_71: G = __r_arr[5]; let __v_72: G = __r_arr[6]; let __v_73: G = __r_arr[7]; let __v_74: G = G::from_u64(0); let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_43, __v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(67, &__args[..])?) { [G::ZERO; OUT_67] } else { let (__hash, __hit) = record.function_queries[67].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[67].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => { aiur_fn_67::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_76]; let __cu = unconstrained; if ((!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_77: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_77]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_78: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_78]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_79: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_79]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_80: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_82: G = __r_arr[0]; let __v_83: G = { let __values: [G; 3] = [__v_74, __v_65, __v_82]; let __mq = record.memory_queries.get_index_mut(1).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_68] = [__v_83]; record.function_queries[68].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_69: usize = 11; -const IN_69: usize = 11; -const OUT_69: usize = 1; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; match __v_0.as_canonical_u64() { _ => { let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; let __v_15: G = __loaded[4]; let __v_16: G = __loaded[5]; let __v_17: G = __loaded[6]; let __v_18: G = __loaded[7]; let __v_19: G = __loaded[8]; let __v_20: G = __loaded[9]; let __v_21: G = __loaded[10]; let __v_22: G = __loaded[11]; let __v_23: G = __loaded[12]; let __v_24: G = __loaded[13]; let __v_25: G = __loaded[14]; let __v_26: G = __loaded[15]; let __v_27: G = __loaded[16]; let __v_28: G = __loaded[17]; let __v_29: G = G::from_u64(0); let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; if ((!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_30: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 3] = [__v_29, __v_0, __v_31]; let __mq = record.memory_queries.get_index_mut(1).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_69] = [__v_32]; record.function_queries[69].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_70: usize = 11; -const IN_70: usize = 11; -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 = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; match __v_0.as_canonical_u64() { _ => { let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; let __v_15: G = __loaded[4]; let __v_16: G = __loaded[5]; let __v_17: G = __loaded[6]; let __v_18: G = __loaded[7]; let __v_19: G = __loaded[8]; let __v_20: G = __loaded[9]; let __v_21: G = __loaded[10]; let __v_22: G = __loaded[11]; let __v_23: G = __loaded[12]; let __v_24: G = __loaded[13]; let __v_25: G = __loaded[14]; let __v_26: G = __loaded[15]; let __v_27: G = __loaded[16]; let __v_28: G = __loaded[17]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; if ((!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_29: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(64, &__args[..])?) { [G::ZERO; OUT_64] } else { let (__hash, __hit) = record.function_queries[64].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[64].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[64].bump_multiplicity(__i); } let __ret: [G; OUT_64] = unsafe { *(record.function_queries[64].output_at(__i).as_ptr() as *const [G; OUT_64]) }; __ret }, _ => { aiur_fn_64::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __ret: [G; OUT_70] = [__v_31]; record.function_queries[70].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_71: usize = 35; -const IN_71: usize = 35; -const OUT_71: usize = 1; -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 = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; match __v_0.as_canonical_u64() { _ => { let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_35: G = __loaded[0]; let __v_36: G = __loaded[1]; let __v_37: G = __loaded[2]; let __v_38: G = __loaded[3]; let __v_39: G = __loaded[4]; let __v_40: G = __loaded[5]; let __v_41: G = __loaded[6]; let __v_42: G = __loaded[7]; let __v_43: G = __loaded[8]; let __v_44: G = __loaded[9]; let __v_45: G = __loaded[10]; let __v_46: G = __loaded[11]; let __v_47: G = __loaded[12]; let __v_48: G = __loaded[13]; let __v_49: G = __loaded[14]; let __v_50: G = __loaded[15]; let __v_51: G = __loaded[16]; let __v_52: G = __loaded[17]; let __v_53: G = G::from_u64(0); let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_34]; let __cu = unconstrained; if ((!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_54: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_54]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_56]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __v_59: G = { let __values: [G; 3] = [__v_53, __v_0, __v_58]; let __mq = record.memory_queries.get_index_mut(1).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_71] = [__v_59]; record.function_queries[71].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_72: usize = 2; -const IN_72: usize = 2; -const OUT_72: usize = 1; -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 = inp[1]; let __loaded: [G; 36] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(14).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(36))?; 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: 36 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __v_34: G = __loaded[32]; let __v_35: G = __loaded[33]; let __v_36: G = __loaded[34]; let __v_37: G = __loaded[35]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_72] = [__v_1]; record.function_queries[72].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_37, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(72, &__args[..])?) { [G::ZERO; OUT_72] } else { let (__hash, __hit) = record.function_queries[72].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[72].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[72].bump_multiplicity(__i); } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => { aiur_fn_72::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(71, &__args[..])?) { [G::ZERO; OUT_71] } else { let (__hash, __hit) = record.function_queries[71].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[71].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[71].bump_multiplicity(__i); } let __ret: [G; OUT_71] = unsafe { *(record.function_queries[71].output_at(__i).as_ptr() as *const [G; OUT_71]) }; __ret }, _ => { aiur_fn_71::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __ret: [G; OUT_72] = [__v_39]; record.function_queries[72].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_73: usize = 28; -const IN_73: usize = 28; -const OUT_73: usize = 1; -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]; match __v_0.as_canonical_u64() { _ => { let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].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 __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(766, &__args[..])?) { [G::ZERO; OUT_766] } else { let (__hash, __hit) = record.function_queries[766].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[766].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => { aiur_fn_766::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = __r_arr[2]; let __v_49: G = __r_arr[3]; let __v_50: G = __r_arr[4]; let __v_51: G = __r_arr[5]; let __v_52: G = __r_arr[6]; let __v_53: G = __r_arr[7]; let __v_54: G = G::from_u64(0); let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_26, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(72, &__args[..])?) { [G::ZERO; OUT_72] } else { let (__hash, __hit) = record.function_queries[72].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[72].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[72].bump_multiplicity(__i); } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => { aiur_fn_72::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_56]; let __cu = unconstrained; if ((!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_57: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __v_61: G = { let __values: [G; 3] = [__v_54, __v_0, __v_60]; let __mq = record.memory_queries.get_index_mut(1).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_73] = [__v_61]; record.function_queries[73].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_74: usize = 10; -const IN_74: usize = 10; -const OUT_74: usize = 1; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(56, &__args[..])?) { [G::ZERO; OUT_56] } else { let (__hash, __hit) = record.function_queries[56].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[56].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => { aiur_fn_56::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_74] = [__v_11]; record.function_queries[74].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_75: usize = 18; -const IN_75: usize = 18; -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 __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(56, &__args[..])?) { [G::ZERO; OUT_56] } else { let (__hash, __hit) = record.function_queries[56].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[56].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => { aiur_fn_56::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_20]; record.function_queries[75].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_76: usize = 46; -const IN_76: usize = 46; -const OUT_76: usize = 1; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; match __v_0.as_canonical_u64() { 0u64 => { let __v_46: G = G::from_u64(0); let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(65, &__args[..])?) { [G::ZERO; OUT_65] } else { let (__hash, __hit) = record.function_queries[65].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[65].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => { aiur_fn_65::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = { let __values: [G; 3] = [__v_46, __v_46, __v_47]; let __mq = record.memory_queries.get_index_mut(1).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_76] = [__v_48]; record.function_queries[76].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(1); let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_45]; let __cu = unconstrained; if ((!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_48: G = __r_arr[0]; let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_index_mut(1).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_76] = [__v_49]; record.function_queries[76].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(2); let __r_arr: [G; OUT_68] = { let __args: [G; IN_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_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if ((!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_48: G = __r_arr[0]; let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_index_mut(1).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_76] = [__v_49]; record.function_queries[76].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.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]; let __loaded: [G; 47] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(15).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __v_34: G = __loaded[32]; let __v_35: G = __loaded[33]; let __v_36: G = __loaded[34]; let __v_37: G = __loaded[35]; let __v_38: G = __loaded[36]; let __v_39: G = __loaded[37]; let __v_40: G = __loaded[38]; let __v_41: G = __loaded[39]; let __v_42: G = __loaded[40]; let __v_43: G = __loaded[41]; let __v_44: G = __loaded[42]; let __v_45: G = __loaded[43]; let __v_46: G = __loaded[44]; let __v_47: G = __loaded[45]; let __v_48: G = __loaded[46]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_77] = [__v_1]; record.function_queries[77].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_48, __v_1]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_49]; let __cu = unconstrained; if ((!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_50: G = __r_arr[0]; let __ret: [G; OUT_77] = [__v_50]; record.function_queries[77].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_78: usize = 46; -const IN_78: usize = 46; -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 = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; let __v_40: G = inp[40]; let __v_41: G = inp[41]; let __v_42: G = inp[42]; let __v_43: G = inp[43]; let __v_44: G = inp[44]; let __v_45: G = inp[45]; match __v_0.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(65, &__args[..])?) { [G::ZERO; OUT_65] } else { let (__hash, __hit) = record.function_queries[65].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[65].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => { aiur_fn_65::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_46]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_68] = { let __args: [G; IN_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_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if ((!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_46: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_46]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(69, &__args[..])?) { [G::ZERO; OUT_69] } else { let (__hash, __hit) = record.function_queries[69].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[69].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => { aiur_fn_69::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_46]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(70, &__args[..])?) { [G::ZERO; OUT_70] } else { let (__hash, __hit) = record.function_queries[70].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[70].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { *(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70]) }; __ret }, _ => { aiur_fn_70::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_46]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_45]; let __cu = unconstrained; if ((!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_46: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_46]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; 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_46: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_46]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; 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_46: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_46]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; 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_46: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_46]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_79: usize = 2; -const IN_79: usize = 2; -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 __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(762, &__args[..])?) { [G::ZERO; OUT_762] } else { let (__hash, __hit) = record.function_queries[762].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[762].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[762].bump_multiplicity(__i); } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => { aiur_fn_762::(__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 __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(61, &__args[..])?) { [G::ZERO; OUT_61] } else { let (__hash, __hit) = record.function_queries[61].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[61].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[61].bump_multiplicity(__i); } let __ret: [G; OUT_61] = unsafe { *(record.function_queries[61].output_at(__i).as_ptr() as *const [G; OUT_61]) }; __ret }, _ => { aiur_fn_61::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_79] = [__v_11]; record.function_queries[79].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_80: usize = 2; -const IN_80: usize = 2; -const OUT_80: usize = 1; -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 __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(762, &__args[..])?) { [G::ZERO; OUT_762] } else { let (__hash, __hit) = record.function_queries[762].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[762].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[762].bump_multiplicity(__i); } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => { aiur_fn_762::(__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 __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_0, __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_10: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_80] = [__v_11]; record.function_queries[80].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_81: usize = 2; -const IN_81: usize = 2; -const OUT_81: usize = 1; -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 __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(762, &__args[..])?) { [G::ZERO; OUT_762] } else { let (__hash, __hit) = record.function_queries[762].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[762].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[762].bump_multiplicity(__i); } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => { aiur_fn_762::(__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 __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(62, &__args[..])?) { [G::ZERO; OUT_62] } else { let (__hash, __hit) = record.function_queries[62].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[62].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[62].bump_multiplicity(__i); } let __ret: [G; OUT_62] = unsafe { *(record.function_queries[62].output_at(__i).as_ptr() as *const [G; OUT_62]) }; __ret }, _ => { aiur_fn_62::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(42, &__args[..])?) { [G::ZERO; OUT_42] } else { let (__hash, __hit) = record.function_queries[42].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[42].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => { aiur_fn_42::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_81] = [__v_11]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_82: usize = 49; -const IN_82: usize = 49; -const OUT_82: usize = 1; -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]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_47, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(81, &__args[..])?) { [G::ZERO; OUT_81] } else { let (__hash, __hit) = record.function_queries[81].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[81].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => { aiur_fn_81::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_46, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(80, &__args[..])?) { [G::ZERO; OUT_80] } else { let (__hash, __hit) = record.function_queries[80].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[80].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => { aiur_fn_80::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_45, __v_50]; 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_51: G = __r_arr[0]; match __v_0.as_canonical_u64() { 8u64 => { let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(770, &__args[..])?) { [G::ZERO; OUT_770] } else { let (__hash, __hit) = record.function_queries[770].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[770].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[770].bump_multiplicity(__i); } let __ret: [G; OUT_770] = unsafe { *(record.function_queries[770].output_at(__i).as_ptr() as *const [G; OUT_770]) }; __ret }, _ => { aiur_fn_770::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; let __v_55: G = __r_arr[3]; let __v_56: G = __r_arr[4]; let __v_57: G = __r_arr[5]; let __v_58: G = __r_arr[6]; let __v_59: G = __r_arr[7]; let __v_60: G = G::from_u64(12); let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_1, __v_51]; 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_61: G = __r_arr[0]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_60, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_82] = [__v_62]; record.function_queries[82].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_52: G = G::from_u64(13); let __v_53: G = G::from_u64(0); let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if ((!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_54: G = __r_arr[0]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_54]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __ret: [G; OUT_82] = [__v_55]; record.function_queries[82].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_52: G = G::from_u64(13); let __v_53: G = G::from_u64(1); let __v_54: G = G::from_u64(0); let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if ((!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_55: G = __r_arr[0]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_52, __v_53, __v_54, __v_54, __v_54, __v_54, __v_54, __v_54, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __ret: [G; OUT_82] = [__v_56]; record.function_queries[82].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_52: G = G::from_u64(13); let __v_53: G = G::from_u64(2); let __v_54: G = G::from_u64(0); let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if ((!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_55: G = __r_arr[0]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_52, __v_53, __v_54, __v_54, __v_54, __v_54, __v_54, __v_54, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __ret: [G; OUT_82] = [__v_56]; record.function_queries[82].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_52: G = G::from_u64(13); let __v_53: G = G::from_u64(3); let __v_54: G = G::from_u64(0); let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if ((!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_55: G = __r_arr[0]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_52, __v_53, __v_54, __v_54, __v_54, __v_54, __v_54, __v_54, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __ret: [G; OUT_82] = [__v_56]; record.function_queries[82].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_52: G = G::from_u64(13); let __v_53: G = G::from_u64(4); let __v_54: G = G::from_u64(0); let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if ((!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_55: G = __r_arr[0]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_52, __v_53, __v_54, __v_54, __v_54, __v_54, __v_54, __v_54, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __ret: [G; OUT_82] = [__v_56]; record.function_queries[82].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_52: G = G::from_u64(13); let __v_53: G = G::from_u64(5); let __v_54: G = G::from_u64(0); let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if ((!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_55: G = __r_arr[0]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_52, __v_53, __v_54, __v_54, __v_54, __v_54, __v_54, __v_54, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __ret: [G; OUT_82] = [__v_56]; record.function_queries[82].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_52: G = G::from_u64(13); let __v_53: G = G::from_u64(6); let __v_54: G = G::from_u64(0); let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if ((!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_55: G = __r_arr[0]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_52, __v_53, __v_54, __v_54, __v_54, __v_54, __v_54, __v_54, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __ret: [G; OUT_82] = [__v_56]; record.function_queries[82].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_52: G = G::from_u64(13); let __v_53: G = G::from_u64(7); let __v_54: G = G::from_u64(0); let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if ((!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_55: G = __r_arr[0]; let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_52, __v_53, __v_54, __v_54, __v_54, __v_54, __v_54, __v_54, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(40, &__args[..])?) { [G::ZERO; OUT_40] } else { let (__hash, __hit) = record.function_queries[40].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[40].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => { aiur_fn_40::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __ret: [G; OUT_82] = [__v_56]; record.function_queries[82].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_83: usize = 1; -const IN_83: usize = 1; -const OUT_83: usize = 2; -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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_83] = [__v_2, __v_3]; record.function_queries[83].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_84: usize = 2; -const IN_84: usize = 2; -const OUT_84: usize = 9; -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 __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_84] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_0]; record.function_queries[84].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(1).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(1); let __v_6: G = __v_1 - __v_5; let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_4, __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 = __r_arr[2]; let __v_10: G = __r_arr[3]; let __v_11: G = __r_arr[4]; let __v_12: G = __r_arr[5]; let __v_13: G = __r_arr[6]; let __v_14: G = __r_arr[7]; let __v_15: G = __r_arr[8]; let __ret: [G; OUT_84] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15]; record.function_queries[84].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_85: usize = 1; -const IN_85: usize = 1; -const OUT_85: usize = 10; -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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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 __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose(&__v_2); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_2, record) }; let __v_4: G = __b1_out[0]; let __v_5: G = __b1_out[1]; let __v_6: G = __b1_out[2]; let __v_7: G = __b1_out[3]; let __v_8: G = __b1_out[4]; let __v_9: G = __b1_out[5]; let __v_10: G = __b1_out[6]; let __v_11: G = __b1_out[7]; let __v_12: G = G::from_u64(2); let __v_13: G = __v_12 * __v_9; let __v_14: G = __v_8 + __v_13; let __v_15: G = G::from_u64(4); let __v_16: G = __v_15 * __v_10; let __v_17: G = __v_14 + __v_16; let __v_18: G = G::from_u64(8); let __v_19: G = __v_18 * __v_11; let __v_20: G = __v_17 + __v_19; let __v_21: G = __v_12 * __v_5; let __v_22: G = __v_4 + __v_21; let __v_23: G = __v_15 * __v_6; let __v_24: G = __v_22 + __v_23; match __v_7.as_canonical_u64() { 0u64 => { let __v_25: G = G::from_u64(0); let __ret: [G; OUT_85] = [__v_20, __v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_3]; record.function_queries[85].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_25: G = G::from_u64(4); let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_24, __v_25, __v_3]; 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_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 __ret: [G; OUT_85] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; record.function_queries[85].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_86: usize = 1; -const IN_86: usize = 1; -const OUT_86: usize = 10; -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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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 __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose(&__v_2); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_2, record) }; let __v_4: G = __b1_out[0]; let __v_5: G = __b1_out[1]; let __v_6: G = __b1_out[2]; let __v_7: G = __b1_out[3]; let __v_8: G = __b1_out[4]; let __v_9: G = __b1_out[5]; let __v_10: G = __b1_out[6]; let __v_11: G = __b1_out[7]; let __v_12: G = G::from_u64(2); let __v_13: G = __v_12 * __v_11; let __v_14: G = __v_10 + __v_13; let __v_15: G = __v_12 * __v_5; let __v_16: G = __v_4 + __v_15; let __v_17: G = G::from_u64(4); let __v_18: G = __v_17 * __v_6; let __v_19: G = __v_16 + __v_18; let __v_20: G = G::from_u64(8); let __v_21: G = __v_20 * __v_7; let __v_22: G = __v_19 + __v_21; let __v_23: G = G::from_u64(16); let __v_24: G = __v_23 * __v_8; let __v_25: G = __v_22 + __v_24; match __v_9.as_canonical_u64() { 0u64 => { let __v_26: G = G::from_u64(0); let __ret: [G; OUT_86] = [__v_14, __v_25, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_3]; record.function_queries[86].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_26: G = G::from_u64(16); let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_25, __v_26, __v_3]; 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_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 __ret: [G; OUT_86] = [__v_14, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; record.function_queries[86].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_87: usize = 1; -const IN_87: usize = 1; -const OUT_87: usize = 9; -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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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 __v_4: G = G::from_u64(128); let __v_5: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_2, &__v_4) } else { aiur::execute::bytes2_less_than_value(__v_2, __v_4, record) }; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_87] = [__v_2, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_3]; record.function_queries[87].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(128); let __v_7: G = __v_2 - __v_6; let __v_8: G = G::from_u64(64); let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_7, __v_8, __v_3]; 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_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 __ret: [G; OUT_87] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; record.function_queries[87].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_88: usize = 3; -const IN_88: usize = 3; -const OUT_88: usize = 9; -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 __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) }; match __v_3.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = __v_7 * __v_1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::add(&__v_5, &__v_8) } else { aiur::execute::bytes2_add_value(__v_5, __v_8, record) }; let __v_9: G = __b2_out.0; let __v_10: G = __b2_out.1; let __v_11: G = __v_0 + __v_10; let __v_12: G = G::from_u64(0); let __ret: [G; OUT_88] = [__v_9, __v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_6]; record.function_queries[88].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, 0u64 => { let __v_4: G = __v_0 - __v_1; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4, __v_1, __v_2]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; let __v_8: G = __r_arr[3]; let __v_9: G = __r_arr[4]; let __v_10: G = __r_arr[5]; let __v_11: G = __r_arr[6]; let __v_12: G = __r_arr[7]; let __v_13: G = __r_arr[8]; let __ret: [G; OUT_88] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; record.function_queries[88].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_89: usize = 3; -const IN_89: usize = 3; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(2); let __v_4: G = __v_3 * __v_1; match __v_0.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(2); let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2, __v_5]; 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_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 = G::from_u64(0); let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_4, __v_1, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(15, &__args[..])?) { [G::ZERO; OUT_15] } else { let (__hash, __hit) = record.function_queries[15].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[15].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => { aiur_fn_15::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; let __v_19: G = __r_arr[3]; let __v_20: G = __r_arr[4]; let __v_21: G = __r_arr[5]; let __v_22: G = __r_arr[6]; let __v_23: G = __r_arr[7]; let __v_24: G = __r_arr[8]; let __ret: [G; OUT_89] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_14]; record.function_queries[89].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(3); let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2, __v_5]; 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_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 = G::from_u64(1); let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_4, __v_1, __v_15, __v_16, __v_16, __v_16, __v_16, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(15, &__args[..])?) { [G::ZERO; OUT_15] } else { let (__hash, __hit) = record.function_queries[15].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[15].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => { aiur_fn_15::(__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_89] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_14]; record.function_queries[89].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_5: G = G::from_u64(4); let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2, __v_5]; 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_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 = G::from_u64(1); let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_4, __v_1, __v_15, __v_15, __v_16, __v_16, __v_16, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(15, &__args[..])?) { [G::ZERO; OUT_15] } else { let (__hash, __hit) = record.function_queries[15].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[15].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => { aiur_fn_15::(__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_89] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_14]; record.function_queries[89].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_5: G = G::from_u64(8); let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2, __v_5]; 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_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 = G::from_u64(1); let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_4, __v_1, __v_15, __v_15, __v_15, __v_16, __v_16, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(15, &__args[..])?) { [G::ZERO; OUT_15] } else { let (__hash, __hit) = record.function_queries[15].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[15].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => { aiur_fn_15::(__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]; if (__v_25 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("TagN value exceeds UInt64".to_string()) }); } let __ret: [G; OUT_89] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_14]; record.function_queries[89].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_90: usize = 9; -const IN_90: usize = 9; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 10] = [__v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(7).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_90] = [__v_11, __v_0]; record.function_queries[90].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { 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_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_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(17, &__args[..])?) { [G::ZERO; OUT_17] } else { let (__hash, __hit) = record.function_queries[17].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[17].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => { aiur_fn_17::(__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 __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; 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_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 10] = [__v_29, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_27]; let __mq = record.memory_queries.get_index_mut(7).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_90] = [__v_30, __v_28]; record.function_queries[90].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_91: usize = 10; -const IN_91: usize = 10; -const OUT_91: usize = 2; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_6] = { let __args: [G; IN_6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_91] = [__v_0, __v_1]; record.function_queries[91].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__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(7); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 18] = [__v_13, __v_0, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 18)?; 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_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(17, &__args[..])?) { [G::ZERO; OUT_17] } else { let (__hash, __hit) = record.function_queries[17].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[17].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => { aiur_fn_17::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; let __v_19: G = __r_arr[3]; let __v_20: G = __r_arr[4]; let __v_21: G = __r_arr[5]; let __v_22: G = __r_arr[6]; let __v_23: G = __r_arr[7]; let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_15, __v_12, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(91, &__args[..])?) { [G::ZERO; OUT_91] } else { let (__hash, __hit) = record.function_queries[91].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[91].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[91].bump_multiplicity(__i); } let __ret: [G; OUT_91] = unsafe { *(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91]) }; __ret }, _ => { aiur_fn_91::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __ret: [G; OUT_91] = [__v_24, __v_25]; record.function_queries[91].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }) } -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]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); break '__mc_0 [__v_2]; }, 1u64 => { let __v_2: G = G::from_u64(1); break '__mc_0 [__v_2]; }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }; let __v_2: G = __mc_out___mc_0[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); break '__mc_1 [__v_3]; }, 1u64 => { let __v_3: G = G::from_u64(1); break '__mc_1 [__v_3]; }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }; let __v_3: G = __mc_out___mc_1[0]; let __ret: [G; OUT_92] = [__v_2, __v_3]; record.function_queries[92].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_93: usize = 4; -const IN_93: usize = 4; -const OUT_93: usize = 3; -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]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(2); let __v_5: G = __v_4 * __v_1; let __v_6: G = __v_0 + __v_5; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); break '__mc_0 [__v_7]; }, 1u64 => { let __v_7: G = G::from_u64(1); break '__mc_0 [__v_7]; }, 2u64 => { let __v_7: G = G::from_u64(2); break '__mc_0 [__v_7]; }, 3u64 => { let __v_7: G = G::from_u64(3); break '__mc_0 [__v_7]; }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }; let __v_7: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_2, __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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_93] = [__v_7, __v_8, __v_9]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_94: usize = 1; -const IN_94: usize = 1; -const OUT_94: usize = 4; -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 __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_1, record) }; let __v_3: G = __b1_out[0]; let __v_4: G = __b1_out[1]; let __v_5: G = __b1_out[2]; let __v_6: G = __b1_out[3]; let __v_7: G = __b1_out[4]; let __v_8: G = __b1_out[5]; let __v_9: G = __b1_out[6]; let __v_10: G = __b1_out[7]; let __v_11: G = __v_7 + __v_8; let __v_12: G = __v_11 + __v_9; let __v_13: G = __v_12 + __v_10; 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: Some("reserved binder contract bits".to_string()) }); } let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_3, __v_4, __v_5, __v_6]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __ret: [G; OUT_94] = [__v_15, __v_16, __v_17, __v_2]; 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 = 6; -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_83] = { let __args: [G; IN_83] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_1, record) }; let __v_3: G = __b1_out[0]; let __v_4: G = __b1_out[1]; let __v_5: G = __b1_out[2]; let __v_6: G = __b1_out[3]; let __v_7: G = __b1_out[4]; let __v_8: G = __b1_out[5]; let __v_9: G = __b1_out[6]; let __v_10: G = __b1_out[7]; let __v_11: G = __v_9 + __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: Some("reserved forall contract bits".to_string()) }); } let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_3, __v_4, __v_5, __v_6]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_7, __v_8]; 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_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_95] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_2]; record.function_queries[95].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_96: usize = 9; -const IN_96: usize = 9; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; let __v_16: G = __loaded[4]; let __v_17: G = __loaded[5]; let __v_18: G = __loaded[6]; let __v_19: G = __loaded[7]; let __v_20: G = __loaded[8]; let __v_21: G = __loaded[9]; let __v_22: G = __loaded[10]; let __v_23: G = __loaded[11]; let __v_24: G = __loaded[12]; let __v_25: G = __loaded[13]; let __v_26: G = __loaded[14]; let __v_27: G = __loaded[15]; let __v_28: G = __loaded[16]; let __v_29: G = __loaded[17]; match __v_12.as_canonical_u64() { 8u64 => { let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(1); if (__v_30 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("non-canonical lambda telescope".to_string()) }); } let __ret: [G; OUT_96] = [__v_10, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_96] = [__v_10, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 0u64 => { let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_0]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(17, &__args[..])?) { [G::ZERO; OUT_17] } else { let (__hash, __hit) = record.function_queries[17].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[17].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => { aiur_fn_17::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; let __v_19: G = __r_arr[3]; let __v_20: G = __r_arr[4]; let __v_21: G = __r_arr[5]; let __v_22: G = __r_arr[6]; let __v_23: G = __r_arr[7]; let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = G::from_u64(8); let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 18] = [__v_26, __v_10, __v_11, __v_12, __v_14, __v_24, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 18)?; let __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_28, __v_25]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_97: usize = 9; -const IN_97: usize = 9; -const OUT_97: usize = 2; -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]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; let __v_16: G = __loaded[4]; let __v_17: G = __loaded[5]; let __v_18: G = __loaded[6]; let __v_19: G = __loaded[7]; let __v_20: G = __loaded[8]; let __v_21: G = __loaded[9]; let __v_22: G = __loaded[10]; let __v_23: G = __loaded[11]; let __v_24: G = __loaded[12]; let __v_25: G = __loaded[13]; let __v_26: G = __loaded[14]; let __v_27: G = __loaded[15]; let __v_28: G = __loaded[16]; let __v_29: G = __loaded[17]; match __v_12.as_canonical_u64() { 9u64 => { let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(1); if (__v_30 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("non-canonical forall telescope".to_string()) }); } let __ret: [G; OUT_97] = [__v_10, __v_11]; record.function_queries[97].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_97] = [__v_10, __v_11]; record.function_queries[97].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 0u64 => { let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(95, &__args[..])?) { [G::ZERO; OUT_95] } else { let (__hash, __hit) = record.function_queries[95].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[95].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => { aiur_fn_95::(__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 __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(17, &__args[..])?) { [G::ZERO; OUT_17] } else { let (__hash, __hit) = record.function_queries[17].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[17].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => { aiur_fn_17::(__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 = __r_arr[4]; let __v_23: G = __r_arr[5]; let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = G::from_u64(9); let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 18] = [__v_28, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16, __v_26, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 18)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_97] = [__v_30, __v_27]; record.function_queries[97].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_98: usize = 1; -const IN_98: usize = 1; -const OUT_98: usize = 2; -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_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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; match __v_1.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 18] = [__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]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 18)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_98] = [__v_12, __v_10]; record.function_queries[98].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 18)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_98] = [__v_13, __v_10]; record.function_queries[98].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { 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 __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(2); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 18)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_98] = [__v_24, __v_21]; record.function_queries[98].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { 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 __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(3); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 18)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_98] = [__v_24, __v_21]; record.function_queries[98].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { 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 __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(4); let __v_23: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_20]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 18)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_98] = [__v_23, __v_21]; record.function_queries[98].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_11: G = G::from_u64(5); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 18)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_98] = [__v_13, __v_10]; record.function_queries[98].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_11: G = G::from_u64(6); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 18)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_98] = [__v_13, __v_10]; record.function_queries[98].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); if (__v_11 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("App with zero arguments".to_string()) }); } let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; let __v_18: G = __loaded[3]; let __v_19: G = __loaded[4]; let __v_20: G = __loaded[5]; let __v_21: G = __loaded[6]; let __v_22: G = __loaded[7]; let __v_23: G = __loaded[8]; let __v_24: G = __loaded[9]; let __v_25: G = __loaded[10]; let __v_26: G = __loaded[11]; let __v_27: G = __loaded[12]; let __v_28: G = __loaded[13]; let __v_29: G = __loaded[14]; let __v_30: G = __loaded[15]; let __v_31: G = __loaded[16]; let __v_32: G = __loaded[17]; match __v_15.as_canonical_u64() { 7u64 => { let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(1); if (__v_33 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("non-canonical application telescope".to_string()) }); } let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_13, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(91, &__args[..])?) { [G::ZERO; OUT_91] } else { let (__hash, __hit) = record.function_queries[91].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[91].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[91].bump_multiplicity(__i); } let __ret: [G; OUT_91] = unsafe { *(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91]) }; __ret }, _ => { aiur_fn_91::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __ret: [G; OUT_98] = [__v_35, __v_36]; record.function_queries[98].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_13, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(91, &__args[..])?) { [G::ZERO; OUT_91] } else { let (__hash, __hit) = record.function_queries[91].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[91].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[91].bump_multiplicity(__i); } let __ret: [G; OUT_91] = unsafe { *(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91]) }; __ret }, _ => { aiur_fn_91::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __ret: [G; OUT_98] = [__v_33, __v_34]; record.function_queries[98].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 8u64 => { let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); if (__v_11 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("Lam with zero binders".to_string()) }); } let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_98] = [__v_13, __v_14]; record.function_queries[98].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); if (__v_11 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("All with zero binders".to_string()) }); } let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_98] = [__v_13, __v_14]; record.function_queries[98].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_98] = [__v_11, __v_12]; record.function_queries[98].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __v_11: G = G::from_u64(11); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 18)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_98] = [__v_13, __v_10]; record.function_queries[98].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_99: usize = 9; -const IN_99: usize = 9; -const OUT_99: usize = 2; -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 = __v_2 + __v_3; let __v_10: G = __v_9 + __v_4; let __v_11: G = __v_10 + __v_5; let __v_12: G = __v_11 + __v_6; let __v_13: G = __v_12 + __v_7; let __v_14: G = __v_13 + __v_8; let __v_15: G = G::from_u64(0); if (__v_14 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("oversized let flags".to_string()) }); } let __v_16: G = G::from_u64(4); let __v_17: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_1, &__v_16) } else { aiur::execute::bytes2_less_than_value(__v_1, __v_16, record) }; let __v_18: G = G::from_u64(1); if (__v_17 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("reserved let flags".to_string()) }); } let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_1, record) }; let __v_19: G = __b1_out[0]; let __v_20: G = __b1_out[1]; let __v_21: G = __b1_out[2]; let __v_22: G = __b1_out[3]; let __v_23: G = __b1_out[4]; let __v_24: G = __b1_out[5]; let __v_25: G = __b1_out[6]; let __v_26: G = __b1_out[7]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_20.as_canonical_u64() { 0u64 => { let __v_27: G = G::from_u64(0); break '__mc_0 [__v_27]; }, 1u64 => { let __v_27: G = G::from_u64(1); break '__mc_0 [__v_27]; }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }; let __v_27: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_0]; 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_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 __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = G::from_u64(10); let __v_39: G = G::from_u64(0); let __v_40: G = { let __values: [G; 18] = [__v_38, __v_19, __v_27, __v_28, __v_29, __v_30, __v_32, __v_34, __v_36, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39]; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 18)?; let __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_40, __v_37]; record.function_queries[99].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_100: usize = 17; -const IN_100: usize = 17; -const OUT_100: usize = 9; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_100] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[100].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(17, &__args[..])?) { [G::ZERO; OUT_17] } else { let (__hash, __hit) = record.function_queries[17].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[17].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => { aiur_fn_17::(__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 = __r_arr[4]; let __v_23: G = __r_arr[5]; let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if ((!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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; let __v_29: G = __r_arr[3]; let __v_30: G = __r_arr[4]; let __v_31: G = __r_arr[5]; let __v_32: G = __r_arr[6]; let __v_33: G = __r_arr[7]; let __v_34: G = __r_arr[8]; let __v_35: G = G::from_u64(1); let __v_36: G = { let __values: [G; 9] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 9)?; 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 __ret: [G; OUT_100] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; record.function_queries[100].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }) } -const INPUT_SIZE_101: usize = 1; -const IN_101: usize = 1; -const OUT_101: usize = 10; -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_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 __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; match __v_1.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_101] = [__v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_10]; record.function_queries[101].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_10]; 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_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_100] = { let __args: [G; IN_100] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!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_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; let __v_26: G = __r_arr[4]; let __v_27: G = __r_arr[5]; let __v_28: G = __r_arr[6]; let __v_29: G = __r_arr[7]; let __v_30: G = __r_arr[8]; let __ret: [G; OUT_101] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21]; record.function_queries[101].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, 1u64 => { let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_10]; 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_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_101] = { let __args: [G; IN_101] = [__v_20]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __v_31: G = G::from_u64(2); let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 9)?; 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; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 9)?; 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 __ret: [G; OUT_101] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; record.function_queries[101].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_10]; 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_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_101] = { let __args: [G; IN_101] = [__v_20]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __v_31: G = G::from_u64(3); let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 9)?; 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; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 9)?; 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 __ret: [G; OUT_101] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; record.function_queries[101].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_11: G = G::from_u64(4); let __ret: [G; OUT_101] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; record.function_queries[101].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_102: usize = 1; -const IN_102: usize = 1; -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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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(1).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 __v_97: G = { let __values: [G; 32] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_26, __v_29, __v_32, __v_35, __v_38, __v_41, __v_44, __v_47, __v_50, __v_53, __v_56, __v_59, __v_62, __v_65, __v_68, __v_71, __v_74, __v_77, __v_80, __v_83, __v_86, __v_89, __v_92, __v_95]; let __mq = record.memory_queries.get_index_mut(12).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_102] = [__v_97, __v_96]; record.function_queries[102].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { 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_103: usize = 9; -const IN_103: usize = 9; -const OUT_103: usize = 2; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_103] = [__v_11, __v_0]; record.function_queries[103].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(17, &__args[..])?) { [G::ZERO; OUT_17] } else { let (__hash, __hit) = record.function_queries[17].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[17].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => { aiur_fn_17::(__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 __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(103, &__args[..])?) { [G::ZERO; OUT_103] } else { let (__hash, __hit) = record.function_queries[103].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[103].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => { aiur_fn_103::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_index_mut(1).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_103] = [__v_23, __v_21]; record.function_queries[103].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_104: usize = 9; -const IN_104: usize = 9; -const OUT_104: usize = 2; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_104] = [__v_11, __v_0]; record.function_queries[104].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_0]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __v_19: G = __r_arr[9]; let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(17, &__args[..])?) { [G::ZERO; OUT_17] } else { let (__hash, __hit) = record.function_queries[17].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[17].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => { aiur_fn_17::(__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 __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(104, &__args[..])?) { [G::ZERO; OUT_104] } else { let (__hash, __hit) = record.function_queries[104].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[104].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[104].bump_multiplicity(__i); } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => { aiur_fn_104::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = G::from_u64(0); let __v_31: G = { let __values: [G; 9] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 9)?; 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_30, __v_31, __v_28]; let __mq = record.memory_queries.get_index_mut(1).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_104] = [__v_32, __v_29]; record.function_queries[104].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_105: usize = 9; -const IN_105: usize = 9; -const OUT_105: usize = 2; -fn aiur_fn_105(inp: [G; IN_105], 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 = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_0]; record.function_queries[105].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_0]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(17, &__args[..])?) { [G::ZERO; OUT_17] } else { let (__hash, __hit) = record.function_queries[17].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[17].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => { aiur_fn_17::(__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 __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_index_mut(1).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_23, __v_21]; record.function_queries[105].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_106: usize = 1; -const IN_106: usize = 1; -const OUT_106: usize = 2; -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 __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 __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(103, &__args[..])?) { [G::ZERO; OUT_103] } else { let (__hash, __hit) = record.function_queries[103].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[103].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => { aiur_fn_103::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_106] = [__v_10, __v_11]; record.function_queries[106].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_107: usize = 1; -const IN_107: usize = 1; -const OUT_107: usize = 2; -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 __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 __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_107] = [__v_10, __v_11]; record.function_queries[107].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_108: usize = 1; -const IN_108: usize = 1; -const OUT_108: usize = 2; -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 __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 __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(104, &__args[..])?) { [G::ZERO; OUT_104] } else { let (__hash, __hit) = record.function_queries[104].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[104].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[104].bump_multiplicity(__i); } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => { aiur_fn_104::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_108] = [__v_10, __v_11]; record.function_queries[108].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_109: usize = 1; -const IN_109: usize = 1; -const OUT_109: usize = 2; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_109] = [__v_1, __v_1]; record.function_queries[109].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(1); let __ret: [G; OUT_109] = [__v_1, __v_2]; record.function_queries[109].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(2); let __ret: [G; OUT_109] = [__v_1, __v_2]; record.function_queries[109].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(0); let __ret: [G; OUT_109] = [__v_1, __v_2]; record.function_queries[109].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_109] = [__v_1, __v_1]; record.function_queries[109].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(2); let __ret: [G; OUT_109] = [__v_1, __v_2]; record.function_queries[109].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(0); let __ret: [G; OUT_109] = [__v_1, __v_2]; record.function_queries[109].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(1); let __ret: [G; OUT_109] = [__v_1, __v_2]; record.function_queries[109].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_109] = [__v_1, __v_1]; record.function_queries[109].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_110: usize = 1; -const IN_110: usize = 1; -const OUT_110: usize = 13; -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 __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_1]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; let __v_8: G = __r_arr[3]; let __v_9: G = __r_arr[4]; let __v_10: G = __r_arr[5]; let __v_11: G = __r_arr[6]; let __v_12: G = __r_arr[7]; let __v_13: G = __r_arr[8]; let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_110] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_16, __v_17]; record.function_queries[110].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_111: usize = 1; -const IN_111: usize = 1; -const OUT_111: usize = 10; -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 __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 __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_111] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; record.function_queries[111].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_112: usize = 9; -const IN_112: usize = 9; -const OUT_112: usize = 2; -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 __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 11] = [__v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(8).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_112] = [__v_11, __v_0]; record.function_queries[112].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { 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_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_98] = { let __args: [G; IN_98] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(17, &__args[..])?) { [G::ZERO; OUT_17] } else { let (__hash, __hit) = record.function_queries[17].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[17].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => { aiur_fn_17::(__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 __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; 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_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 11] = [__v_31, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_29]; let __mq = record.memory_queries.get_index_mut(8).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_112] = [__v_32, __v_30]; record.function_queries[112].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_113: usize = 1; -const IN_113: usize = 1; -const OUT_113: usize = 45; -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 __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = G::from_u64(4); let __v_4: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_1, &__v_3) } else { aiur::execute::bytes2_less_than_value(__v_1, __v_3, record) }; 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: Some("invalid recursor flags".to_string()) }); } let __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_1, record) }; let __v_6: G = __b1_out[0]; let __v_7: G = __b1_out[1]; let __v_8: G = __b1_out[2]; let __v_9: G = __b1_out[3]; let __v_10: G = __b1_out[4]; let __v_11: G = __b1_out[5]; let __v_12: G = __b1_out[6]; let __v_13: G = __b1_out[7]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; let __v_17: G = __r_arr[3]; let __v_18: G = __r_arr[4]; let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; let __v_22: G = __r_arr[8]; let __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_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; let __v_26: G = __r_arr[3]; let __v_27: G = __r_arr[4]; let __v_28: G = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; let __v_31: G = __r_arr[8]; let __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 __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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_49]; 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_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 __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; 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 __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_69, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; 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_70: G = __r_arr[0]; let __v_71: G = __r_arr[1]; let __ret: [G; OUT_113] = [__v_6, __v_7, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_59, __v_70, __v_71]; record.function_queries[113].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_114: usize = 1; -const IN_114: usize = 1; -const OUT_114: usize = 0; -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 = G::from_u64(2); let __v_2: 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_3: G = G::from_u64(1); if (__v_2 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("Bool byte is not 0 or 1".to_string()) }); } let __ret: [G; OUT_114] = []; 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 = 11; -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 __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1]; 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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_115] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13]; record.function_queries[115].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_116: usize = 1; -const IN_116: usize = 1; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_116] = [__v_1]; record.function_queries[116].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_116] = [__v_1]; record.function_queries[116].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_116] = [__v_1]; record.function_queries[116].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(3); let __ret: [G; OUT_116] = [__v_1]; record.function_queries[116].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_117: usize = 1; -const IN_117: usize = 1; -const OUT_117: usize = 11; -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 __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_1]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = __r_arr[3]; let __v_8: G = __r_arr[4]; let __v_9: G = __r_arr[5]; let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; let __v_12: G = __r_arr[8]; let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_117] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13, __v_14]; 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 = 35; -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 __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1]; 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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __r_arr: [G; OUT_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 __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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_29]; 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_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = __r_arr[2]; let __v_33: G = __r_arr[3]; let __v_34: G = __r_arr[4]; let __v_35: G = __r_arr[5]; let __v_36: G = __r_arr[6]; let __v_37: G = __r_arr[7]; let __v_38: G = __r_arr[8]; let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __ret: [G; OUT_118] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_39, __v_40]; record.function_queries[118].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_119: usize = 9; -const IN_119: usize = 9; -const OUT_119: usize = 2; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 36] = [__v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(14).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(36))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 36)?; let __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_11, __v_0]; record.function_queries[119].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_0]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __v_19: G = __r_arr[9]; let __v_20: G = __r_arr[10]; let __v_21: G = __r_arr[11]; let __v_22: G = __r_arr[12]; let __v_23: G = __r_arr[13]; let __v_24: G = __r_arr[14]; let __v_25: G = __r_arr[15]; let __v_26: G = __r_arr[16]; let __v_27: G = __r_arr[17]; let __v_28: G = __r_arr[18]; let __v_29: G = __r_arr[19]; let __v_30: G = __r_arr[20]; let __v_31: G = __r_arr[21]; let __v_32: G = __r_arr[22]; let __v_33: G = __r_arr[23]; let __v_34: G = __r_arr[24]; let __v_35: G = __r_arr[25]; let __v_36: G = __r_arr[26]; let __v_37: G = __r_arr[27]; let __v_38: G = __r_arr[28]; let __v_39: G = __r_arr[29]; let __v_40: G = __r_arr[30]; let __v_41: G = __r_arr[31]; let __v_42: G = __r_arr[32]; let __v_43: G = __r_arr[33]; let __v_44: G = __r_arr[34]; let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(17, &__args[..])?) { [G::ZERO; OUT_17] } else { let (__hash, __hit) = record.function_queries[17].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[17].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => { aiur_fn_17::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __v_47: G = __r_arr[2]; let __v_48: G = __r_arr[3]; let __v_49: G = __r_arr[4]; let __v_50: G = __r_arr[5]; let __v_51: G = __r_arr[6]; let __v_52: G = __r_arr[7]; let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; 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_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = G::from_u64(0); let __v_56: G = { let __values: [G; 36] = [__v_55, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_53]; let __mq = record.memory_queries.get_index_mut(14).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(36))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 36)?; let __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_56, __v_54]; record.function_queries[119].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_120: usize = 1; -const IN_120: usize = 1; -const OUT_120: usize = 28; -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 __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1]; 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 __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_1, record) }; let __v_3: G = __b1_out[0]; let __v_4: G = __b1_out[1]; let __v_5: G = __b1_out[2]; let __v_6: G = __b1_out[3]; let __v_7: G = __b1_out[4]; let __v_8: G = __b1_out[5]; let __v_9: G = __b1_out[6]; let __v_10: G = __b1_out[7]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; 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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_19]; 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_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_87] = { let __args: [G; IN_87] = [__v_28]; 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_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __v_32: G = __r_arr[3]; let __v_33: G = __r_arr[4]; let __v_34: G = __r_arr[5]; let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(98, &__args[..])?) { [G::ZERO; OUT_98] } else { let (__hash, __hit) = record.function_queries[98].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[98].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => { aiur_fn_98::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_39]; 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_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 __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_48, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; 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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __ret: [G; OUT_120] = [__v_3, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_49, __v_50]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_121: usize = 1; -const IN_121: usize = 1; -const OUT_121: usize = 10; -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 __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 __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_121] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; record.function_queries[121].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_122: usize = 1; -const IN_122: usize = 1; -const OUT_122: usize = 18; -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 __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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_9]; 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_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_102] = { let __args: [G; IN_102] = [__v_18]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_122] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20]; record.function_queries[122].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_123: usize = 1; -const IN_123: usize = 1; -const OUT_123: usize = 46; -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 __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __v_12: G = __r_arr[9]; let __v_13: G = __r_arr[10]; let __v_14: G = __r_arr[11]; let __v_15: G = __r_arr[12]; let __v_16: G = G::from_u64(0); let __ret: [G; OUT_123] = [__v_16, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_15]; record.function_queries[123].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __v_12: G = __r_arr[9]; let __v_13: G = __r_arr[10]; let __v_14: G = __r_arr[11]; let __v_15: G = __r_arr[12]; let __v_16: G = __r_arr[13]; let __v_17: G = __r_arr[14]; let __v_18: G = __r_arr[15]; let __v_19: G = __r_arr[16]; let __v_20: G = __r_arr[17]; let __v_21: G = __r_arr[18]; let __v_22: G = __r_arr[19]; let __v_23: G = __r_arr[20]; let __v_24: G = __r_arr[21]; let __v_25: G = __r_arr[22]; let __v_26: G = __r_arr[23]; let __v_27: G = __r_arr[24]; let __v_28: G = __r_arr[25]; let __v_29: G = __r_arr[26]; let __v_30: G = __r_arr[27]; let __v_31: G = G::from_u64(1); let __v_32: G = G::from_u64(0); let __ret: [G; OUT_123] = [__v_31, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_30]; record.function_queries[123].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __v_12: G = __r_arr[9]; let __v_13: G = __r_arr[10]; let __v_14: G = __r_arr[11]; let __v_15: G = __r_arr[12]; let __v_16: G = __r_arr[13]; let __v_17: G = __r_arr[14]; let __v_18: G = __r_arr[15]; let __v_19: G = __r_arr[16]; let __v_20: G = __r_arr[17]; let __v_21: G = __r_arr[18]; let __v_22: G = __r_arr[19]; let __v_23: G = __r_arr[20]; let __v_24: G = __r_arr[21]; let __v_25: G = __r_arr[22]; let __v_26: G = __r_arr[23]; let __v_27: G = __r_arr[24]; let __v_28: G = __r_arr[25]; let __v_29: G = __r_arr[26]; let __v_30: G = __r_arr[27]; let __v_31: G = __r_arr[28]; let __v_32: G = __r_arr[29]; let __v_33: G = __r_arr[30]; let __v_34: G = __r_arr[31]; let __v_35: G = __r_arr[32]; let __v_36: G = __r_arr[33]; let __v_37: G = __r_arr[34]; let __v_38: G = __r_arr[35]; let __v_39: G = __r_arr[36]; let __v_40: G = __r_arr[37]; let __v_41: G = __r_arr[38]; let __v_42: G = __r_arr[39]; let __v_43: G = __r_arr[40]; let __v_44: G = __r_arr[41]; let __v_45: G = __r_arr[42]; let __v_46: G = __r_arr[43]; let __v_47: G = __r_arr[44]; let __v_48: G = G::from_u64(2); let __ret: [G; OUT_123] = [__v_48, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; record.function_queries[123].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_124: usize = 9; -const IN_124: usize = 9; -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]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 47] = [__v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(15).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(47))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 47)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_124] = [__v_11, __v_0]; record.function_queries[124].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __v_19: G = __r_arr[9]; let __v_20: G = __r_arr[10]; let __v_21: G = __r_arr[11]; let __v_22: G = __r_arr[12]; let __v_23: G = __r_arr[13]; let __v_24: G = __r_arr[14]; let __v_25: G = __r_arr[15]; let __v_26: G = __r_arr[16]; let __v_27: G = __r_arr[17]; let __v_28: G = __r_arr[18]; let __v_29: G = __r_arr[19]; let __v_30: G = __r_arr[20]; let __v_31: G = __r_arr[21]; let __v_32: G = __r_arr[22]; let __v_33: G = __r_arr[23]; let __v_34: G = __r_arr[24]; let __v_35: G = __r_arr[25]; let __v_36: G = __r_arr[26]; let __v_37: G = __r_arr[27]; let __v_38: G = __r_arr[28]; let __v_39: G = __r_arr[29]; let __v_40: G = __r_arr[30]; let __v_41: G = __r_arr[31]; let __v_42: G = __r_arr[32]; let __v_43: G = __r_arr[33]; let __v_44: G = __r_arr[34]; let __v_45: G = __r_arr[35]; let __v_46: G = __r_arr[36]; let __v_47: G = __r_arr[37]; let __v_48: G = __r_arr[38]; let __v_49: G = __r_arr[39]; let __v_50: G = __r_arr[40]; let __v_51: G = __r_arr[41]; let __v_52: G = __r_arr[42]; let __v_53: G = __r_arr[43]; let __v_54: G = __r_arr[44]; let __v_55: G = __r_arr[45]; let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(17, &__args[..])?) { [G::ZERO; OUT_17] } else { let (__hash, __hit) = record.function_queries[17].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[17].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => { aiur_fn_17::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __v_58: G = __r_arr[2]; let __v_59: G = __r_arr[3]; let __v_60: G = __r_arr[4]; let __v_61: G = __r_arr[5]; let __v_62: G = __r_arr[6]; let __v_63: G = __r_arr[7]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; 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_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = G::from_u64(0); let __v_67: G = { let __values: [G; 47] = [__v_66, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_64]; let __mq = record.memory_queries.get_index_mut(15).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(47))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 47)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_124] = [__v_67, __v_65]; record.function_queries[124].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_125: usize = 2; -const IN_125: usize = 2; -const OUT_125: usize = 46; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = __r_arr[10]; let __v_13: G = __r_arr[11]; let __v_14: G = __r_arr[12]; let __v_15: G = G::from_u64(0); let __ret: [G; OUT_125] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_14]; record.function_queries[125].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = __r_arr[10]; let __v_13: G = __r_arr[11]; let __v_14: G = __r_arr[12]; let __v_15: G = __r_arr[13]; let __v_16: G = __r_arr[14]; let __v_17: G = __r_arr[15]; let __v_18: G = __r_arr[16]; let __v_19: G = __r_arr[17]; let __v_20: G = __r_arr[18]; let __v_21: G = __r_arr[19]; let __v_22: G = __r_arr[20]; let __v_23: G = __r_arr[21]; let __v_24: G = __r_arr[22]; let __v_25: G = __r_arr[23]; let __v_26: G = __r_arr[24]; let __v_27: G = __r_arr[25]; let __v_28: G = __r_arr[26]; let __v_29: G = __r_arr[27]; let __v_30: G = __r_arr[28]; let __v_31: G = __r_arr[29]; let __v_32: G = __r_arr[30]; let __v_33: G = __r_arr[31]; let __v_34: G = __r_arr[32]; let __v_35: G = __r_arr[33]; let __v_36: G = __r_arr[34]; let __v_37: G = __r_arr[35]; let __v_38: G = __r_arr[36]; let __v_39: G = __r_arr[37]; let __v_40: G = __r_arr[38]; let __v_41: G = __r_arr[39]; let __v_42: G = __r_arr[40]; let __v_43: G = __r_arr[41]; let __v_44: G = __r_arr[42]; let __v_45: G = __r_arr[43]; let __v_46: G = __r_arr[44]; let __v_47: G = G::from_u64(1); let __ret: [G; OUT_125] = [__v_47, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; record.function_queries[125].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(115, &__args[..])?) { [G::ZERO; OUT_115] } else { let (__hash, __hit) = record.function_queries[115].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[115].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => { aiur_fn_115::(__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 = G::from_u64(2); let __v_14: G = G::from_u64(0); let __ret: [G; OUT_125] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; record.function_queries[125].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = __r_arr[10]; let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(0); let __ret: [G; OUT_125] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; record.function_queries[125].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = __r_arr[10]; let __v_13: G = __r_arr[11]; let __v_14: G = __r_arr[12]; let __v_15: G = __r_arr[13]; let __v_16: G = __r_arr[14]; let __v_17: G = __r_arr[15]; let __v_18: G = __r_arr[16]; let __v_19: G = __r_arr[17]; let __v_20: G = G::from_u64(4); let __v_21: G = G::from_u64(0); let __ret: [G; OUT_125] = [__v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_19]; record.function_queries[125].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = G::from_u64(5); let __v_13: G = G::from_u64(0); let __ret: [G; OUT_125] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; record.function_queries[125].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = G::from_u64(6); let __v_13: G = G::from_u64(0); let __ret: [G; OUT_125] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; record.function_queries[125].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = G::from_u64(7); let __v_13: G = G::from_u64(0); let __ret: [G; OUT_125] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; record.function_queries[125].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_126: usize = 10; -const IN_126: usize = 10; -const OUT_126: usize = 46; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; match __v_0.as_canonical_u64() { 12u64 => { let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(8); let __v_13: G = G::from_u64(0); let __ret: [G; OUT_126] = [__v_12, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; record.function_queries[126].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __v_10: G = __v_2 + __v_3; let __v_11: G = __v_10 + __v_4; let __v_12: G = __v_11 + __v_5; let __v_13: G = __v_12 + __v_6; let __v_14: G = __v_13 + __v_7; let __v_15: G = __v_14 + __v_8; 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: Some("constant info: TagN size exceeds a single byte".to_string()) }); } let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_1, __v_9]; 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_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 __v_28: G = __r_arr[11]; let __v_29: G = __r_arr[12]; let __v_30: G = __r_arr[13]; let __v_31: G = __r_arr[14]; let __v_32: G = __r_arr[15]; let __v_33: G = __r_arr[16]; let __v_34: G = __r_arr[17]; let __v_35: G = __r_arr[18]; let __v_36: G = __r_arr[19]; let __v_37: G = __r_arr[20]; let __v_38: G = __r_arr[21]; let __v_39: G = __r_arr[22]; let __v_40: G = __r_arr[23]; let __v_41: G = __r_arr[24]; let __v_42: G = __r_arr[25]; let __v_43: G = __r_arr[26]; let __v_44: G = __r_arr[27]; let __v_45: G = __r_arr[28]; let __v_46: G = __r_arr[29]; let __v_47: G = __r_arr[30]; let __v_48: G = __r_arr[31]; let __v_49: G = __r_arr[32]; let __v_50: G = __r_arr[33]; let __v_51: G = __r_arr[34]; let __v_52: G = __r_arr[35]; let __v_53: G = __r_arr[36]; let __v_54: G = __r_arr[37]; let __v_55: G = __r_arr[38]; let __v_56: G = __r_arr[39]; let __v_57: G = __r_arr[40]; let __v_58: G = __r_arr[41]; let __v_59: G = __r_arr[42]; let __v_60: G = __r_arr[43]; let __v_61: G = __r_arr[44]; let __v_62: G = __r_arr[45]; let __ret: [G; OUT_126] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __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]; record.function_queries[126].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_127: usize = 1; -const IN_127: usize = 1; -const OUT_127: usize = 49; -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 __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_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 __mc_out___mc_0: [G; 46] = '__mc_0: { match __v_1.as_canonical_u64() { 12u64 => { let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(8); let __v_14: G = G::from_u64(0); break '__mc_0 [__v_13, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; }, 13u64 => { let __v_11: G = __v_3 + __v_4; let __v_12: G = __v_11 + __v_5; let __v_13: G = __v_12 + __v_6; let __v_14: G = __v_13 + __v_7; let __v_15: G = __v_14 + __v_8; let __v_16: G = __v_15 + __v_9; 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: Some("constant info: TagN size exceeds a single byte".to_string()) }); } let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2, __v_10]; 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_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; let __v_22: G = __r_arr[4]; let __v_23: G = __r_arr[5]; let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; let __v_26: G = __r_arr[8]; let __v_27: G = __r_arr[9]; let __v_28: G = __r_arr[10]; let __v_29: G = __r_arr[11]; let __v_30: G = __r_arr[12]; let __v_31: G = __r_arr[13]; let __v_32: G = __r_arr[14]; let __v_33: G = __r_arr[15]; let __v_34: G = __r_arr[16]; let __v_35: G = __r_arr[17]; let __v_36: G = __r_arr[18]; let __v_37: G = __r_arr[19]; let __v_38: G = __r_arr[20]; let __v_39: G = __r_arr[21]; let __v_40: G = __r_arr[22]; let __v_41: G = __r_arr[23]; let __v_42: G = __r_arr[24]; let __v_43: G = __r_arr[25]; let __v_44: G = __r_arr[26]; let __v_45: G = __r_arr[27]; let __v_46: G = __r_arr[28]; let __v_47: G = __r_arr[29]; let __v_48: G = __r_arr[30]; let __v_49: G = __r_arr[31]; let __v_50: G = __r_arr[32]; let __v_51: G = __r_arr[33]; let __v_52: G = __r_arr[34]; let __v_53: G = __r_arr[35]; let __v_54: G = __r_arr[36]; let __v_55: G = __r_arr[37]; let __v_56: G = __r_arr[38]; let __v_57: G = __r_arr[39]; let __v_58: G = __r_arr[40]; let __v_59: G = __r_arr[41]; let __v_60: G = __r_arr[42]; let __v_61: G = __r_arr[43]; let __v_62: G = __r_arr[44]; let __v_63: G = __r_arr[45]; break '__mc_0 [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __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]; }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }; let __v_11: G = __mc_out___mc_0[0]; let __v_12: G = __mc_out___mc_0[1]; let __v_13: G = __mc_out___mc_0[2]; let __v_14: G = __mc_out___mc_0[3]; let __v_15: G = __mc_out___mc_0[4]; let __v_16: G = __mc_out___mc_0[5]; let __v_17: G = __mc_out___mc_0[6]; let __v_18: G = __mc_out___mc_0[7]; let __v_19: G = __mc_out___mc_0[8]; let __v_20: G = __mc_out___mc_0[9]; let __v_21: G = __mc_out___mc_0[10]; let __v_22: G = __mc_out___mc_0[11]; let __v_23: G = __mc_out___mc_0[12]; let __v_24: G = __mc_out___mc_0[13]; let __v_25: G = __mc_out___mc_0[14]; let __v_26: G = __mc_out___mc_0[15]; let __v_27: G = __mc_out___mc_0[16]; let __v_28: G = __mc_out___mc_0[17]; let __v_29: G = __mc_out___mc_0[18]; let __v_30: G = __mc_out___mc_0[19]; let __v_31: G = __mc_out___mc_0[20]; let __v_32: G = __mc_out___mc_0[21]; let __v_33: G = __mc_out___mc_0[22]; let __v_34: G = __mc_out___mc_0[23]; let __v_35: G = __mc_out___mc_0[24]; let __v_36: G = __mc_out___mc_0[25]; let __v_37: G = __mc_out___mc_0[26]; let __v_38: G = __mc_out___mc_0[27]; let __v_39: G = __mc_out___mc_0[28]; let __v_40: G = __mc_out___mc_0[29]; let __v_41: G = __mc_out___mc_0[30]; let __v_42: G = __mc_out___mc_0[31]; let __v_43: G = __mc_out___mc_0[32]; let __v_44: G = __mc_out___mc_0[33]; let __v_45: G = __mc_out___mc_0[34]; let __v_46: G = __mc_out___mc_0[35]; let __v_47: G = __mc_out___mc_0[36]; let __v_48: G = __mc_out___mc_0[37]; let __v_49: G = __mc_out___mc_0[38]; let __v_50: G = __mc_out___mc_0[39]; let __v_51: G = __mc_out___mc_0[40]; let __v_52: G = __mc_out___mc_0[41]; let __v_53: G = __mc_out___mc_0[42]; let __v_54: G = __mc_out___mc_0[43]; let __v_55: G = __mc_out___mc_0[44]; let __v_56: G = __mc_out___mc_0[45]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_56]; 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_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = __r_arr[2]; let __v_60: G = __r_arr[3]; let __v_61: G = __r_arr[4]; let __v_62: G = __r_arr[5]; let __v_63: G = __r_arr[6]; let __v_64: G = __r_arr[7]; let __v_65: G = __r_arr[8]; let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_65, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(103, &__args[..])?) { [G::ZERO; OUT_103] } else { let (__hash, __hit) = record.function_queries[103].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[103].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => { aiur_fn_103::(__args, __hash, record, io_buffer)? }, } } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_67]; 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_68: G = __r_arr[0]; let __v_69: G = __r_arr[1]; let __v_70: G = __r_arr[2]; let __v_71: G = __r_arr[3]; let __v_72: G = __r_arr[4]; let __v_73: G = __r_arr[5]; let __v_74: G = __r_arr[6]; let __v_75: G = __r_arr[7]; let __v_76: G = __r_arr[8]; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_76, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __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_77: G = __r_arr[0]; let __v_78: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_78]; 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_79: G = __r_arr[0]; let __v_80: G = __r_arr[1]; let __v_81: G = __r_arr[2]; let __v_82: G = __r_arr[3]; let __v_83: G = __r_arr[4]; let __v_84: G = __r_arr[5]; let __v_85: G = __r_arr[6]; let __v_86: G = __r_arr[7]; let __v_87: G = __r_arr[8]; let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_87, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(104, &__args[..])?) { [G::ZERO; OUT_104] } else { let (__hash, __hit) = record.function_queries[104].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[104].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[104].bump_multiplicity(__i); } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => { aiur_fn_104::(__args, __hash, record, io_buffer)? }, } } }; let __v_88: G = __r_arr[0]; let __v_89: G = __r_arr[1]; let __ret: [G; OUT_127] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_66, __v_77, __v_88, __v_89]; record.function_queries[127].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_128: usize = 1; -const IN_128: usize = 1; -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 __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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() { 3u64 => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_2]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(760, &__args[..])?) { [G::ZERO; OUT_760] } else { let (__hash, __hit) = record.function_queries[760].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[760].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[760].bump_multiplicity(__i); } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => { aiur_fn_760::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_128] = [__v_5, __v_7]; record.function_queries[128].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { 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(1).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_128] = [__v_0, __v_6]; record.function_queries[128].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_129: usize = 1; -const IN_129: usize = 1; -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 __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).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 __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(7).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_14: G = { let __values: [G; 10] = [__v_11, __v_12, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_13]; let __mq = record.memory_queries.get_index_mut(7).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_129] = [__v_14]; record.function_queries[129].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(15, &__args[..])?) { [G::ZERO; OUT_15] } else { let (__hash, __hit) = record.function_queries[15].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[15].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => { aiur_fn_15::(__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 __v_16: G = __r_arr[3]; let __v_17: G = __r_arr[4]; let __v_18: G = __r_arr[5]; let __v_19: G = __r_arr[6]; let __v_20: G = __r_arr[7]; let __v_21: G = __r_arr[8]; match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 10] = [__v_22, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_10]; let __mq = record.memory_queries.get_index_mut(7).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_129] = [__v_23]; record.function_queries[129].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(0); let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 10] = [__v_22, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_23]; let __mq = record.memory_queries.get_index_mut(7).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_129] = [__v_24]; record.function_queries[129].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_130: usize = 3; -const IN_130: usize = 3; -const OUT_130: usize = 1; -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 __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; let __v_9: G = __loaded[6]; let __v_10: G = __loaded[7]; let __v_11: G = __loaded[8]; let __v_12: G = __loaded[9]; match __v_3.as_canonical_u64() { 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_130] = [__v_1]; record.function_queries[130].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_130] = [__v_13]; record.function_queries[130].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(7).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_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; let __v_16: G = __loaded[3]; let __v_17: G = __loaded[4]; let __v_18: G = __loaded[5]; let __v_19: G = __loaded[6]; let __v_20: G = __loaded[7]; let __v_21: G = __loaded[8]; let __v_22: G = __loaded[9]; match __v_13.as_canonical_u64() { 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_130] = [__v_0]; record.function_queries[130].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_130] = [__v_23]; record.function_queries[130].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 0u64 => { let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(15, &__args[..])?) { [G::ZERO; OUT_15] } else { let (__hash, __hit) = record.function_queries[15].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[15].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => { aiur_fn_15::(__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 = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; let __v_31: G = __r_arr[8]; let __v_32: G = G::from_u64(0); let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(15, &__args[..])?) { [G::ZERO; OUT_15] } else { let (__hash, __hit) = record.function_queries[15].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[15].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => { aiur_fn_15::(__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 __v_42: G = __v_31 + __v_41; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_12, __v_22, __v_42]; 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_43: G = __r_arr[0]; let __v_44: G = { let __values: [G; 10] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_43]; let __mq = record.memory_queries.get_index_mut(7).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_130] = [__v_44]; record.function_queries[130].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.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 __v_2: G = G::from_u64(0); let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_1, __v_2]; 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_3: G = __r_arr[0]; let __ret: [G; OUT_131] = [__v_3]; record.function_queries[131].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_132: usize = 16; -const IN_132: usize = 16; -const OUT_132: usize = 9; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::sub(&__v_0, &__v_8) } else { aiur::execute::bytes2_sub_value(__v_0, __v_8, record) }; let __v_16: G = __b2_out.0; let __v_17: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::sub(&__v_1, &__v_9) } else { aiur::execute::bytes2_sub_value(__v_1, __v_9, record) }; let __v_18: G = __b2_out.0; let __v_19: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::sub(&__v_18, &__v_17) } else { aiur::execute::bytes2_sub_value(__v_18, __v_17, record) }; let __v_20: G = __b2_out.0; let __v_21: G = __b2_out.1; let __v_22: G = __v_19 + __v_21; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::sub(&__v_2, &__v_10) } else { aiur::execute::bytes2_sub_value(__v_2, __v_10, record) }; let __v_23: G = __b2_out.0; let __v_24: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::sub(&__v_23, &__v_22) } else { aiur::execute::bytes2_sub_value(__v_23, __v_22, record) }; let __v_25: G = __b2_out.0; let __v_26: G = __b2_out.1; let __v_27: G = __v_24 + __v_26; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::sub(&__v_3, &__v_11) } else { aiur::execute::bytes2_sub_value(__v_3, __v_11, record) }; let __v_28: G = __b2_out.0; let __v_29: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::sub(&__v_28, &__v_27) } else { aiur::execute::bytes2_sub_value(__v_28, __v_27, record) }; let __v_30: G = __b2_out.0; let __v_31: G = __b2_out.1; let __v_32: G = __v_29 + __v_31; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::sub(&__v_4, &__v_12) } else { aiur::execute::bytes2_sub_value(__v_4, __v_12, record) }; let __v_33: G = __b2_out.0; let __v_34: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::sub(&__v_33, &__v_32) } else { aiur::execute::bytes2_sub_value(__v_33, __v_32, record) }; let __v_35: G = __b2_out.0; let __v_36: G = __b2_out.1; let __v_37: G = __v_34 + __v_36; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::sub(&__v_5, &__v_13) } else { aiur::execute::bytes2_sub_value(__v_5, __v_13, record) }; let __v_38: G = __b2_out.0; let __v_39: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::sub(&__v_38, &__v_37) } else { aiur::execute::bytes2_sub_value(__v_38, __v_37, record) }; let __v_40: G = __b2_out.0; let __v_41: G = __b2_out.1; let __v_42: G = __v_39 + __v_41; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::sub(&__v_6, &__v_14) } else { aiur::execute::bytes2_sub_value(__v_6, __v_14, record) }; let __v_43: G = __b2_out.0; let __v_44: G = __b2_out.1; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::sub(&__v_43, &__v_42) } else { aiur::execute::bytes2_sub_value(__v_43, __v_42, record) }; let __v_45: G = __b2_out.0; let __v_46: G = __b2_out.1; let __v_47: G = __v_44 + __v_46; let __b2_out: (G, G) = if unconstrained { aiur::execute::CodegenBytes2::sub(&__v_7, &__v_15) } else { aiur::execute::bytes2_sub_value(__v_7, __v_15, 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::sub(&__v_48, &__v_47) } else { aiur::execute::bytes2_sub_value(__v_48, __v_47, record) }; let __v_50: G = __b2_out.0; let __v_51: G = __b2_out.1; let __v_52: G = __v_49 + __v_51; let __ret: [G; OUT_132] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; record.function_queries[132].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_133: usize = 3; -const IN_133: usize = 3; -const OUT_133: usize = 2; -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 __v_2: G = inp[2]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; let __v_9: G = __loaded[6]; let __v_10: G = __loaded[7]; let __v_11: G = __loaded[8]; let __v_12: G = __loaded[9]; match __v_3.as_canonical_u64() { 1u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).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_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; let __v_16: G = __loaded[3]; let __v_17: G = __loaded[4]; let __v_18: G = __loaded[5]; let __v_19: G = __loaded[6]; let __v_20: G = __loaded[7]; let __v_21: G = __loaded[8]; let __v_22: G = __loaded[9]; match __v_13.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = { let __values: [G; 10] = [__v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_index_mut(7).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_133] = [__v_24, __v_2]; record.function_queries[133].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_1]; 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_23: G = __r_arr[0]; match __v_23.as_canonical_u64() { 1u64 => { let __v_24: G = G::from_u64(1); let __v_25: G = { let __values: [G; 10] = [__v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_index_mut(7).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_133] = [__v_25, __v_2]; record.function_queries[133].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(1); let __v_25: G = { let __values: [G; 10] = [__v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_index_mut(7).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_133] = [__v_25, __v_24]; record.function_queries[133].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, 0u64 => { let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).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_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; let __v_16: G = __loaded[3]; let __v_17: G = __loaded[4]; let __v_18: G = __loaded[5]; let __v_19: G = __loaded[6]; let __v_20: G = __loaded[7]; let __v_21: G = __loaded[8]; let __v_22: G = __loaded[9]; match __v_13.as_canonical_u64() { 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __v_23: G = G::from_u64(0); let __ret: [G; OUT_133] = [__v_0, __v_23]; record.function_queries[133].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(0); let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; 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_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; let __v_28: G = __r_arr[3]; let __v_29: G = __r_arr[4]; let __v_30: G = __r_arr[5]; let __v_31: G = __r_arr[6]; let __v_32: G = __r_arr[7]; let __v_33: G = __r_arr[8]; let __v_34: G = { let __values: [G; 10] = [__v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_index_mut(7).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_133] = { let __args: [G; IN_133] = [__v_12, __v_34, __v_33]; 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_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = { let __values: [G; 10] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_35]; let __mq = record.memory_queries.get_index_mut(7).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_133] = [__v_37, __v_36]; record.function_queries[133].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_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if ((!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_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; let __v_26: G = __r_arr[3]; let __v_27: G = __r_arr[4]; let __v_28: G = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; let __v_31: G = __r_arr[8]; let __v_32: G = G::from_u64(0); let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; 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_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __v_35: G = __r_arr[2]; let __v_36: G = __r_arr[3]; let __v_37: G = __r_arr[4]; let __v_38: G = __r_arr[5]; let __v_39: G = __r_arr[6]; let __v_40: G = __r_arr[7]; let __v_41: G = __r_arr[8]; let __v_42: G = __v_31 + __v_41; let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_12, __v_22, __v_42]; 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_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = { let __values: [G; 10] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_43]; let __mq = record.memory_queries.get_index_mut(7).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_133] = [__v_45, __v_44]; record.function_queries[133].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_134: usize = 1; -const IN_134: usize = 1; -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 __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_134] = [__v_1]; record.function_queries[134].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_135: usize = 1; -const IN_135: usize = 1; -const OUT_135: usize = 2; -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 __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).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(1); let __v_12: G = { let __values: [G; 10] = [__v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(7).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_13: G = G::from_u64(0); let __ret: [G; OUT_135] = [__v_12, __v_13]; record.function_queries[135].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { 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 __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_10]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(3, &__args[..])?) { [G::ZERO; OUT_3] } else { let (__hash, __hit) = record.function_queries[3].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[3].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[3].bump_multiplicity(__i); } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => { aiur_fn_3::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 10] = [__v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; let __mq = record.memory_queries.get_index_mut(7).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_135] = [__v_15, __v_13]; record.function_queries[135].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_136: usize = 1; -const IN_136: usize = 1; -const OUT_136: usize = 1; -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 __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).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(1); let __v_12: G = { let __values: [G; 10] = [__v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(7).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_136] = [__v_12]; record.function_queries[136].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_10]; 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_11: G = __r_arr[0]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __idx = usize::try_from(__ptr_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() { 1u64 => { let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = { let __values: [G; 10] = [__v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_index_mut(7).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_136] = [__v_24]; record.function_queries[136].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(1); let __v_25: G = { let __values: [G; 10] = [__v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_index_mut(7).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_26: G = { let __values: [G; 10] = [__v_23, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_25]; let __mq = record.memory_queries.get_index_mut(7).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_136] = [__v_26]; record.function_queries[136].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); }, } }, _ => { let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 10] = [__v_22, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; let __mq = record.memory_queries.get_index_mut(7).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_136] = [__v_23]; record.function_queries[136].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_137: usize = 2; -const IN_137: usize = 2; -const OUT_137: usize = 1; -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 = G::from_u64(0); let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __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 __v_4: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 10] = [__v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(7).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_137] = [__v_6]; record.function_queries[137].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__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_5: G = __r_arr[0]; let __ret: [G; OUT_137] = [__v_5]; record.function_queries[137].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_138: usize = 2; -const IN_138: usize = 2; -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 __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).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(1); let __ret: [G; OUT_138] = [__v_13]; record.function_queries[138].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_138] = [__v_13]; record.function_queries[138].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_139: usize = 1; -const IN_139: usize = 1; -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 = G::from_u64(0); 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(7).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_4: G = { let __values: [G; 10] = [__v_1, __v_2, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_3]; let __mq = record.memory_queries.get_index_mut(7).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_137] = { let __args: [G; IN_137] = [__v_0, __v_4]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_139] = [__v_5]; record.function_queries[139].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_140: usize = 2; -const IN_140: usize = 2; -const OUT_140: usize = 2; -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 = G::from_u64(256); let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_3.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_140] = [__v_0, __v_1]; record.function_queries[140].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(256); let __v_5: G = __v_0 - __v_4; let __v_6: G = G::from_u64(1); let __v_7: G = __v_1 + __v_6; let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_5, __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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_140] = [__v_8, __v_9]; record.function_queries[140].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_141: usize = 16; -const IN_141: usize = 16; -const OUT_141: usize = 16; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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(256); let __v_17: G = __v_16 * __v_1; let __v_18: G = __v_0 + __v_17; let __v_19: G = __v_16 * __v_9; let __v_20: G = __v_8 + __v_19; let __v_21: G = __v_16 * __v_3; let __v_22: G = __v_2 + __v_21; let __v_23: G = __v_16 * __v_11; let __v_24: G = __v_10 + __v_23; let __v_25: G = __v_16 * __v_5; let __v_26: G = __v_4 + __v_25; let __v_27: G = __v_16 * __v_13; let __v_28: G = __v_12 + __v_27; let __v_29: G = __v_16 * __v_7; let __v_30: G = __v_6 + __v_29; let __v_31: G = __v_16 * __v_15; let __v_32: G = __v_14 + __v_31; let __v_33: G = __v_18 * __v_20; let __gb: [u8; 8] = __v_33.as_canonical_u64().to_le_bytes(); let __v_34: G = G::from_u8(__gb[0]); let __v_35: G = G::from_u8(__gb[1]); let __v_36: G = G::from_u8(__gb[2]); let __v_37: G = G::from_u8(__gb[3]); let __v_38: G = G::from_u8(__gb[4]); let __v_39: G = G::from_u8(__gb[5]); let __v_40: G = G::from_u8(__gb[6]); let __v_41: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_34; let __vj = __v_35; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_36; let __vj = __v_37; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); 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_42: G = G::from_u64(0); if (!unconstrained) { let __vi = __v_38; let __vj = __v_42; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); 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_43: G = __v_16 * __v_35; let __v_44: G = __v_34 + __v_43; let __v_45: G = G::from_u64(65536); let __v_46: G = __v_16 * __v_37; let __v_47: G = __v_36 + __v_46; let __v_48: G = __v_45 * __v_38; let __v_49: G = __v_47 + __v_48; let __v_50: G = __v_45 * __v_49; let __v_51: G = __v_44 + __v_50; if (__v_33 != __v_51) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) }); } let __v_52: G = __v_18 * __v_24; let __v_53: G = __v_22 * __v_20; let __v_54: G = __v_52 + __v_53; let __v_55: G = __v_54 + __v_36; let __v_56: G = __v_55 + __v_46; let __v_57: G = __v_56 + __v_48; let __gb: [u8; 8] = __v_57.as_canonical_u64().to_le_bytes(); let __v_58: G = G::from_u8(__gb[0]); let __v_59: G = G::from_u8(__gb[1]); let __v_60: G = G::from_u8(__gb[2]); let __v_61: G = G::from_u8(__gb[3]); let __v_62: G = G::from_u8(__gb[4]); let __v_63: G = G::from_u8(__gb[5]); let __v_64: G = G::from_u8(__gb[6]); let __v_65: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_58; let __vj = __v_59; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_60; let __vj = __v_61; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_62; let __vj = __v_42; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } let __v_66: G = __v_16 * __v_59; let __v_67: G = __v_58 + __v_66; let __v_68: G = __v_16 * __v_61; let __v_69: G = __v_60 + __v_68; let __v_70: G = __v_45 * __v_62; let __v_71: G = __v_69 + __v_70; let __v_72: G = __v_45 * __v_71; let __v_73: G = __v_67 + __v_72; if (__v_57 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) }); } let __v_74: G = __v_18 * __v_28; let __v_75: G = __v_22 * __v_24; let __v_76: G = __v_74 + __v_75; let __v_77: G = __v_26 * __v_20; let __v_78: G = __v_76 + __v_77; let __v_79: G = __v_78 + __v_60; let __v_80: G = __v_79 + __v_68; let __v_81: G = __v_80 + __v_70; let __gb: [u8; 8] = __v_81.as_canonical_u64().to_le_bytes(); let __v_82: G = G::from_u8(__gb[0]); let __v_83: G = G::from_u8(__gb[1]); let __v_84: G = G::from_u8(__gb[2]); let __v_85: G = G::from_u8(__gb[3]); let __v_86: G = G::from_u8(__gb[4]); let __v_87: G = G::from_u8(__gb[5]); let __v_88: G = G::from_u8(__gb[6]); let __v_89: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_82; let __vj = __v_83; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_84; let __vj = __v_85; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_86; let __vj = __v_42; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); 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_90: G = __v_16 * __v_83; let __v_91: G = __v_82 + __v_90; let __v_92: G = __v_16 * __v_85; let __v_93: G = __v_84 + __v_92; let __v_94: G = __v_45 * __v_86; let __v_95: G = __v_93 + __v_94; let __v_96: G = __v_45 * __v_95; let __v_97: G = __v_91 + __v_96; if (__v_81 != __v_97) { return Err(ExecError::AssertEqMismatch { lhs: __v_81.as_canonical_u64(), rhs: __v_97.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) }); } let __v_98: G = __v_18 * __v_32; let __v_99: G = __v_22 * __v_28; let __v_100: G = __v_98 + __v_99; let __v_101: G = __v_26 * __v_24; let __v_102: G = __v_100 + __v_101; let __v_103: G = __v_30 * __v_20; let __v_104: G = __v_102 + __v_103; let __v_105: G = __v_104 + __v_84; let __v_106: G = __v_105 + __v_92; let __v_107: G = __v_106 + __v_94; let __gb: [u8; 8] = __v_107.as_canonical_u64().to_le_bytes(); let __v_108: G = G::from_u8(__gb[0]); let __v_109: G = G::from_u8(__gb[1]); let __v_110: G = G::from_u8(__gb[2]); let __v_111: G = G::from_u8(__gb[3]); let __v_112: G = G::from_u8(__gb[4]); let __v_113: G = G::from_u8(__gb[5]); let __v_114: G = G::from_u8(__gb[6]); let __v_115: G = G::from_u8(__gb[7]); 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); } if (!unconstrained) { let __vi = __v_112; let __vj = __v_42; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); 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_116: G = __v_16 * __v_109; let __v_117: G = __v_108 + __v_116; let __v_118: G = __v_16 * __v_111; let __v_119: G = __v_110 + __v_118; let __v_120: G = __v_45 * __v_112; let __v_121: G = __v_119 + __v_120; let __v_122: G = __v_45 * __v_121; let __v_123: G = __v_117 + __v_122; if (__v_107 != __v_123) { return Err(ExecError::AssertEqMismatch { lhs: __v_107.as_canonical_u64(), rhs: __v_123.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) }); } let __v_124: G = __v_22 * __v_32; let __v_125: G = __v_26 * __v_28; let __v_126: G = __v_124 + __v_125; let __v_127: G = __v_30 * __v_24; let __v_128: G = __v_126 + __v_127; let __v_129: G = __v_128 + __v_110; let __v_130: G = __v_129 + __v_118; let __v_131: G = __v_130 + __v_120; let __gb: [u8; 8] = __v_131.as_canonical_u64().to_le_bytes(); let __v_132: G = G::from_u8(__gb[0]); let __v_133: G = G::from_u8(__gb[1]); let __v_134: G = G::from_u8(__gb[2]); let __v_135: G = G::from_u8(__gb[3]); let __v_136: G = G::from_u8(__gb[4]); let __v_137: G = G::from_u8(__gb[5]); let __v_138: G = G::from_u8(__gb[6]); let __v_139: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_132; let __vj = __v_133; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_134; let __vj = __v_135; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_136; let __vj = __v_42; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); 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_140: G = __v_16 * __v_133; let __v_141: G = __v_132 + __v_140; let __v_142: G = __v_16 * __v_135; let __v_143: G = __v_134 + __v_142; let __v_144: G = __v_45 * __v_136; let __v_145: G = __v_143 + __v_144; let __v_146: G = __v_45 * __v_145; let __v_147: G = __v_141 + __v_146; if (__v_131 != __v_147) { return Err(ExecError::AssertEqMismatch { lhs: __v_131.as_canonical_u64(), rhs: __v_147.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) }); } let __v_148: G = __v_26 * __v_32; let __v_149: G = __v_30 * __v_28; let __v_150: G = __v_148 + __v_149; let __v_151: G = __v_150 + __v_134; let __v_152: G = __v_151 + __v_142; let __v_153: G = __v_152 + __v_144; let __gb: [u8; 8] = __v_153.as_canonical_u64().to_le_bytes(); let __v_154: G = G::from_u8(__gb[0]); let __v_155: G = G::from_u8(__gb[1]); let __v_156: G = G::from_u8(__gb[2]); let __v_157: G = G::from_u8(__gb[3]); let __v_158: G = G::from_u8(__gb[4]); let __v_159: G = G::from_u8(__gb[5]); let __v_160: G = G::from_u8(__gb[6]); let __v_161: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_154; let __vj = __v_155; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_156; let __vj = __v_157; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } if (!unconstrained) { let __vi = __v_158; let __vj = __v_42; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); 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_162: G = __v_16 * __v_155; let __v_163: G = __v_154 + __v_162; let __v_164: G = __v_16 * __v_157; let __v_165: G = __v_156 + __v_164; let __v_166: G = __v_45 * __v_158; let __v_167: G = __v_165 + __v_166; let __v_168: G = __v_45 * __v_167; let __v_169: G = __v_163 + __v_168; if (__v_153 != __v_169) { return Err(ExecError::AssertEqMismatch { lhs: __v_153.as_canonical_u64(), rhs: __v_169.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) }); } let __v_170: G = __v_30 * __v_32; let __v_171: G = __v_170 + __v_156; let __v_172: G = __v_171 + __v_164; let __v_173: G = __v_172 + __v_166; let __gb: [u8; 8] = __v_173.as_canonical_u64().to_le_bytes(); let __v_174: G = G::from_u8(__gb[0]); let __v_175: G = G::from_u8(__gb[1]); let __v_176: G = G::from_u8(__gb[2]); let __v_177: G = G::from_u8(__gb[3]); let __v_178: G = G::from_u8(__gb[4]); let __v_179: G = G::from_u8(__gb[5]); let __v_180: G = G::from_u8(__gb[6]); let __v_181: G = G::from_u8(__gb[7]); if (!unconstrained) { let __vi = __v_174; let __vj = __v_175; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if (__bi >= 256) { return Err(ExecError::U8RangeCheckFailed(__bi)); } if (__bj >= 256) { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); } 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_42; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); 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_182: G = __v_16 * __v_175; let __v_183: G = __v_174 + __v_182; let __v_184: G = __v_16 * __v_177; let __v_185: G = __v_176 + __v_184; let __v_186: G = __v_45 * __v_178; let __v_187: G = __v_185 + __v_186; let __v_188: G = __v_45 * __v_187; let __v_189: G = __v_183 + __v_188; if (__v_173 != __v_189) { return Err(ExecError::AssertEqMismatch { lhs: __v_173.as_canonical_u64(), rhs: __v_189.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) }); } if (__v_178 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_178.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("u64_mul: final carry exceeds one radix digit".to_string()) }); } let __ret: [G; OUT_141] = [__v_34, __v_35, __v_58, __v_59, __v_82, __v_83, __v_108, __v_109, __v_132, __v_133, __v_154, __v_155, __v_174, __v_175, __v_176, __v_177]; record.function_queries[141].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_142: usize = 1; -const IN_142: usize = 1; -const OUT_142: usize = 5; -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 __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); } let __v_9: G = G::from_u64(0); if (!unconstrained) { let __vi = __v_5; 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_2; let __v_12: G = __v_1 + __v_11; let __v_13: G = G::from_u64(65536); let __v_14: G = __v_10 * __v_4; let __v_15: G = __v_3 + __v_14; let __v_16: G = __v_13 * __v_5; let __v_17: G = __v_15 + __v_16; let __v_18: G = __v_13 * __v_17; let __v_19: G = __v_12 + __v_18; if (__v_0 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) }); } let __ret: [G; OUT_142] = [__v_1, __v_2, __v_3, __v_4, __v_5]; record.function_queries[142].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_143: usize = 2; -const IN_143: usize = 2; -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 = 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(7).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_4: G = G::from_u64(0); let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_0, __v_1, __v_3, __v_4]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_143] = [__v_5]; record.function_queries[143].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_144: usize = 4; -const IN_144: usize = 4; -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 __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).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_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; let __v_8: G = __loaded[4]; let __v_9: G = __loaded[5]; let __v_10: G = __loaded[6]; let __v_11: G = __loaded[7]; let __v_12: G = __loaded[8]; let __v_13: G = __loaded[9]; match __v_4.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_144] = [__v_2]; record.function_queries[144].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_1, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_15, __v_3]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_2, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = __v_3 + __v_18; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_13, __v_1, __v_17, __v_19]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_144] = [__v_20]; record.function_queries[144].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_145: usize = 17; -const IN_145: usize = 17; -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]; 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 __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; let __v_20: G = __loaded[3]; let __v_21: G = __loaded[4]; let __v_22: G = __loaded[5]; let __v_23: G = __loaded[6]; let __v_24: G = __loaded[7]; let __v_25: G = __loaded[8]; let __v_26: G = __loaded[9]; match __v_17.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; match __v_27.as_canonical_u64() { 1u64 => { let __v_28: G = G::from_u64(1); let __v_29: G = { let __values: [G; 10] = [__v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; let __mq = record.memory_queries.get_index_mut(7).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_145] = [__v_29]; record.function_queries[145].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); let __v_30: G = { let __values: [G; 10] = [__v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_index_mut(7).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_31: G = { let __values: [G; 10] = [__v_28, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_30]; let __mq = record.memory_queries.get_index_mut(7).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_145] = [__v_31]; record.function_queries[145].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_27.as_canonical_u64())); }, } }, 0u64 => { let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__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]; 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_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 __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(15, &__args[..])?) { [G::ZERO; OUT_15] } else { let (__hash, __hit) = record.function_queries[15].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[15].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => { aiur_fn_15::(__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]; match __v_51.as_canonical_u64() { 0u64 => { let __v_52: G = G::from_u64(0); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_26, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42]; 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_53: G = __r_arr[0]; let __v_54: G = { let __values: [G; 10] = [__v_52, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_53]; let __mq = record.memory_queries.get_index_mut(7).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_145] = [__v_54]; record.function_queries[145].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_52: G = G::from_u64(0); let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(16, &__args[..])?) { [G::ZERO; OUT_16] } else { let (__hash, __hit) = record.function_queries[16].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[16].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => { aiur_fn_16::(__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 __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_26, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60]; 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_61: G = __r_arr[0]; let __v_62: G = { let __values: [G; 10] = [__v_52, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_61]; let __mq = record.memory_queries.get_index_mut(7).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_145] = [__v_62]; record.function_queries[145].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }) } -const INPUT_SIZE_146: usize = 2; -const IN_146: usize = 2; -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]; match __v_1.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 __v_2: G = G::from_u64(0); 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_0]; let __mq = record.memory_queries.get_index_mut(7).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_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_3, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_146] = [__v_6]; record.function_queries[146].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_147: usize = 1; -const IN_147: usize = 1; -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 __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0]; 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_1: G = __r_arr[0]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).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_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_147] = [__v_12]; record.function_queries[147].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_147] = [__v_12]; record.function_queries[147].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_148: usize = 2; -const IN_148: usize = 2; -const OUT_148: usize = 2; -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 __bu_qr: (G, G) = aiur::execute::unconstrained_big_uint_div_mod_helper(__v_0, __v_1, record)?; let __v_2: G = __bu_qr.0; let __v_3: G = __bu_qr.1; let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(134, &__args[..])?) { [G::ZERO; OUT_134] } else { let (__hash, __hit) = record.function_queries[134].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[134].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => { aiur_fn_134::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_4]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(134, &__args[..])?) { [G::ZERO; OUT_134] } else { let (__hash, __hit) = record.function_queries[134].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[134].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => { aiur_fn_134::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__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_7: G = __r_arr[0]; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_5, __v_1]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_8, __v_7]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_9]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0]; 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_11: G = __r_arr[0]; if (__v_10 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("div/mod hint: q*b + r != a".to_string()) }); } let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_1]; 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_5]; 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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("div/mod hint: division by zero must yield a zero quotient".to_string()) }); } let __ret: [G; OUT_148] = [__v_5, __v_7]; record.function_queries[148].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_13, __v_1]; 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_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); if (__v_14 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("div/mod hint: remainder is not less than the divisor".to_string()) }); } let __ret: [G; OUT_148] = [__v_5, __v_7]; record.function_queries[148].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }) } -const INPUT_SIZE_149: usize = 2; -const IN_149: usize = 2; -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 __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __ret: [G; OUT_149] = [__v_2]; record.function_queries[149].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_150: usize = 2; -const IN_150: usize = 2; -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 __v_1: G = inp[1]; let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __ret: [G; OUT_150] = [__v_3]; record.function_queries[150].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_151: usize = 2; -const IN_151: usize = 2; -const OUT_151: usize = 1; -fn aiur_fn_151(inp: [G; IN_151], 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 __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_1]; 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_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_151] = [__v_0]; record.function_queries[151].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_0, __v_1]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_151] = [__v_4]; record.function_queries[151].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_152: usize = 2; -const IN_152: usize = 2; -const OUT_152: usize = 1; -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 __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_1]; 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_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 10] = [__v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(7).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_6: G = { let __values: [G; 10] = [__v_3, __v_4, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(7).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_152] = [__v_6]; record.function_queries[152].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(2); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 10] = [__v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(7).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_7: G = { let __values: [G; 10] = [__v_3, __v_4, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_6]; let __mq = record.memory_queries.get_index_mut(7).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_148] = { let __args: [G; IN_148] = [__v_1, __v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_0]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_10]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_8]; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(152, &__args[..])?) { [G::ZERO; OUT_152] } else { let (__hash, __hit) = record.function_queries[152].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[152].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => { aiur_fn_152::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_9]; 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_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_152] = [__v_13]; record.function_queries[152].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_13]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_152] = [__v_15]; record.function_queries[152].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_153: usize = 16; -const IN_153: usize = 16; -const OUT_153: usize = 8; -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 __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 = if unconstrained { aiur::execute::CodegenBytes2::and(&__v_0, &__v_8) } else { aiur::execute::bytes2_and_value(__v_0, __v_8, record) }; let __v_17: G = if unconstrained { aiur::execute::CodegenBytes2::and(&__v_1, &__v_9) } else { aiur::execute::bytes2_and_value(__v_1, __v_9, record) }; let __v_18: G = if unconstrained { aiur::execute::CodegenBytes2::and(&__v_2, &__v_10) } else { aiur::execute::bytes2_and_value(__v_2, __v_10, record) }; let __v_19: G = if unconstrained { aiur::execute::CodegenBytes2::and(&__v_3, &__v_11) } else { aiur::execute::bytes2_and_value(__v_3, __v_11, record) }; let __v_20: G = if unconstrained { aiur::execute::CodegenBytes2::and(&__v_4, &__v_12) } else { aiur::execute::bytes2_and_value(__v_4, __v_12, record) }; let __v_21: G = if unconstrained { aiur::execute::CodegenBytes2::and(&__v_5, &__v_13) } else { aiur::execute::bytes2_and_value(__v_5, __v_13, record) }; let __v_22: G = if unconstrained { aiur::execute::CodegenBytes2::and(&__v_6, &__v_14) } else { aiur::execute::bytes2_and_value(__v_6, __v_14, record) }; let __v_23: G = if unconstrained { aiur::execute::CodegenBytes2::and(&__v_7, &__v_15) } else { aiur::execute::bytes2_and_value(__v_7, __v_15, record) }; let __ret: [G; OUT_153] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; record.function_queries[153].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_154: usize = 16; -const IN_154: usize = 16; -const OUT_154: usize = 8; -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 __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 = if unconstrained { aiur::execute::CodegenBytes2::or(&__v_0, &__v_8) } else { aiur::execute::bytes2_or_value(__v_0, __v_8, record) }; let __v_17: G = if unconstrained { aiur::execute::CodegenBytes2::or(&__v_1, &__v_9) } else { aiur::execute::bytes2_or_value(__v_1, __v_9, record) }; let __v_18: G = if unconstrained { aiur::execute::CodegenBytes2::or(&__v_2, &__v_10) } else { aiur::execute::bytes2_or_value(__v_2, __v_10, record) }; let __v_19: G = if unconstrained { aiur::execute::CodegenBytes2::or(&__v_3, &__v_11) } else { aiur::execute::bytes2_or_value(__v_3, __v_11, record) }; let __v_20: G = if unconstrained { aiur::execute::CodegenBytes2::or(&__v_4, &__v_12) } else { aiur::execute::bytes2_or_value(__v_4, __v_12, record) }; let __v_21: G = if unconstrained { aiur::execute::CodegenBytes2::or(&__v_5, &__v_13) } else { aiur::execute::bytes2_or_value(__v_5, __v_13, record) }; let __v_22: G = if unconstrained { aiur::execute::CodegenBytes2::or(&__v_6, &__v_14) } else { aiur::execute::bytes2_or_value(__v_6, __v_14, record) }; let __v_23: G = if unconstrained { aiur::execute::CodegenBytes2::or(&__v_7, &__v_15) } else { aiur::execute::bytes2_or_value(__v_7, __v_15, record) }; let __ret: [G; OUT_154] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; record.function_queries[154].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_155: usize = 16; -const IN_155: usize = 16; -const OUT_155: usize = 8; -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 __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 = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_0, &__v_8) } else { aiur::execute::bytes2_xor_value(__v_0, __v_8, record) }; let __v_17: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_1, &__v_9) } else { aiur::execute::bytes2_xor_value(__v_1, __v_9, record) }; let __v_18: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_2, &__v_10) } else { aiur::execute::bytes2_xor_value(__v_2, __v_10, record) }; let __v_19: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_3, &__v_11) } else { aiur::execute::bytes2_xor_value(__v_3, __v_11, record) }; let __v_20: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_4, &__v_12) } else { aiur::execute::bytes2_xor_value(__v_4, __v_12, record) }; let __v_21: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_5, &__v_13) } else { aiur::execute::bytes2_xor_value(__v_5, __v_13, record) }; let __v_22: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_6, &__v_14) } else { aiur::execute::bytes2_xor_value(__v_6, __v_14, record) }; let __v_23: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_7, &__v_15) } else { aiur::execute::bytes2_xor_value(__v_7, __v_15, record) }; let __ret: [G; OUT_155] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; record.function_queries[155].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_156: usize = 2; -const IN_156: usize = 2; -const OUT_156: usize = 1; -fn aiur_fn_156(inp: [G; IN_156], 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 __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).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 __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(7).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_156] = [__v_13]; record.function_queries[156].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(7).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() { 1u64 => { let __v_22: G = G::from_u64(1); let __v_23: G = { let __values: [G; 10] = [__v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22]; let __mq = record.memory_queries.get_index_mut(7).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_156] = [__v_23]; record.function_queries[156].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__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(153, &__args[..])?) { [G::ZERO; OUT_153] } else { let (__hash, __hit) = record.function_queries[153].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[153].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => { aiur_fn_153::(__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 = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_11, __v_21]; 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_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(7).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_156] = [__v_32]; record.function_queries[156].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_157: usize = 2; -const IN_157: usize = 2; -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 __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).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_157] = [__v_1]; record.function_queries[157].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(7).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() { 1u64 => { let __ret: [G; OUT_157] = [__v_0]; record.function_queries[157].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__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(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_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; let __v_26: G = __r_arr[3]; let __v_27: G = __r_arr[4]; let __v_28: G = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_11, __v_21]; 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_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(7).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_157] = [__v_32]; record.function_queries[157].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_158: usize = 2; -const IN_158: usize = 2; -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 __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).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_158] = [__v_1]; record.function_queries[158].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(7).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() { 1u64 => { let __ret: [G; OUT_158] = [__v_0]; record.function_queries[158].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__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(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_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; let __v_26: G = __r_arr[3]; let __v_27: G = __r_arr[4]; let __v_28: G = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_11, __v_21]; 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_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(7).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_158] = [__v_32]; record.function_queries[158].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_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 __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(2); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 10] = [__v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(7).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_6: G = { let __values: [G; 10] = [__v_2, __v_3, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_5]; let __mq = record.memory_queries.get_index_mut(7).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_152] = { let __args: [G; IN_152] = [__v_6, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(152, &__args[..])?) { [G::ZERO; OUT_152] } else { let (__hash, __hit) = record.function_queries[152].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[152].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => { aiur_fn_152::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_159] = [__v_8]; record.function_queries[159].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_160: usize = 2; -const IN_160: usize = 2; -const OUT_160: usize = 1; -fn aiur_fn_160(inp: [G; IN_160], 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 __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(2); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 10] = [__v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(7).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_6: G = { let __values: [G; 10] = [__v_2, __v_3, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_5]; let __mq = record.memory_queries.get_index_mut(7).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_152] = { let __args: [G; IN_152] = [__v_6, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(152, &__args[..])?) { [G::ZERO; OUT_152] } else { let (__hash, __hit) = record.function_queries[152].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[152].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => { aiur_fn_152::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_0, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_160] = [__v_8]; record.function_queries[160].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_161: usize = 2; -const IN_161: usize = 2; -const OUT_161: usize = 1; -fn aiur_fn_161(inp: [G; IN_161], 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]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(5); let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(481, &__args[..])?) { [G::ZERO; OUT_481] } else { let (__hash, __hit) = record.function_queries[481].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[481].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => { aiur_fn_481::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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 = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_4, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_8]; record.function_queries[161].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(6); let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(481, &__args[..])?) { [G::ZERO; OUT_481] } else { let (__hash, __hit) = record.function_queries[481].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[481].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => { aiur_fn_481::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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 = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_4, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_8]; record.function_queries[161].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_162: usize = 3; -const IN_162: usize = 3; -const OUT_162: usize = 2; -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 __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; match __v_3.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(7).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_162] = [__v_6, __v_8]; record.function_queries[162].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_5]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 10] = [__v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(7).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_162] = [__v_8, __v_10]; record.function_queries[162].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_4]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 10] = [__v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(7).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_162] = [__v_10, __v_12]; record.function_queries[162].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(2); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(7).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_14: G = { let __values: [G; 10] = [__v_10, __v_11, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_13]; let __mq = record.memory_queries.get_index_mut(7).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_152] = { let __args: [G; IN_152] = [__v_14, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(152, &__args[..])?) { [G::ZERO; OUT_152] } else { let (__hash, __hit) = record.function_queries[152].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[152].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => { aiur_fn_152::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_7, __v_15]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_16]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_162] = [__v_12, __v_17]; record.function_queries[162].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_163: usize = 2; -const IN_163: usize = 2; -const OUT_163: usize = 2; -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 __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(3); let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 4] = [__v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_163] = [__v_5, __v_6]; record.function_queries[163].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__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_768] = { let __args: [G; IN_768] = [__v_1, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(2); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_1, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_6, __v_8]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_index_mut(2).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_163] = [__v_13, __v_14]; record.function_queries[163].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_6, __v_10]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(2).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_163] = [__v_15, __v_16]; record.function_queries[163].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_14, __v_12]; 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_16: G = __r_arr[0]; let __v_17: G = __v_15 - __v_16; let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __v_17]; 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_18: G = __r_arr[0]; let __ret: [G; OUT_163] = [__v_15, __v_18]; record.function_queries[163].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_164: usize = 2; -const IN_164: usize = 2; -const OUT_164: usize = 3; -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 __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 2u64 => { let __v_8: G = G::from_u64(84); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(480, &__args[..])?) { [G::ZERO; OUT_480] } else { let (__hash, __hit) = record.function_queries[480].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[480].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => { aiur_fn_480::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(2); let __v_12: G = __v_10 - __v_11; match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_3, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_3, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_164] = [__v_13, __v_15, __v_16]; record.function_queries[164].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_index_mut(2).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_164] = [__v_13, __v_14, __v_14]; record.function_queries[164].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_164] = [__v_10, __v_11, __v_11]; record.function_queries[164].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_164] = [__v_8, __v_9, __v_9]; record.function_queries[164].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_165: usize = 4; -const IN_165: usize = 4; -const OUT_165: usize = 2; -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]; match __v_1.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(2); let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_165] = [__v_7, __v_8]; record.function_queries[165].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(331, &__args[..])?) { [G::ZERO; OUT_331] } else { let (__hash, __hit) = record.function_queries[331].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[331].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[331].bump_multiplicity(__i); } let __ret: [G; OUT_331] = unsafe { *(record.function_queries[331].output_at(__i).as_ptr() as *const [G; OUT_331]) }; __ret }, _ => { aiur_fn_331::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_7, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_9, __v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(2).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_165] = [__v_14, __v_15]; record.function_queries[165].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_13]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_165] = [__v_14, __v_15]; record.function_queries[165].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, } }, 2u64 => { let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(166, &__args[..])?) { [G::ZERO; OUT_166] } else { let (__hash, __hit) = record.function_queries[166].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[166].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => { aiur_fn_166::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_0, __v_4]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_165] = [__v_5, __v_6]; record.function_queries[165].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __v_5: G = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_165] = [__v_4, __v_5]; record.function_queries[165].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_166: usize = 3; -const IN_166: usize = 3; -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 __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(329, &__args[..])?) { [G::ZERO; OUT_329] } else { let (__hash, __hit) = record.function_queries[329].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[329].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => { aiur_fn_329::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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() { 1u64 => { let __ret: [G; OUT_166] = [__v_3]; record.function_queries[166].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(1).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() { 1u64 => { let __ret: [G; OUT_166] = [__v_3]; record.function_queries[166].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(1).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() { 1u64 => { let __ret: [G; OUT_166] = [__v_3]; record.function_queries[166].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(167, &__args[..])?) { [G::ZERO; OUT_167] } else { let (__hash, __hit) = record.function_queries[167].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[167].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => { aiur_fn_167::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_11, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(167, &__args[..])?) { [G::ZERO; OUT_167] } else { let (__hash, __hit) = record.function_queries[167].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[167].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => { aiur_fn_167::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_14, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_13, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_5, __v_17]; let __mq = record.memory_queries.get_index_mut(1).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_166] = [__v_18]; record.function_queries[166].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_167: usize = 3; -const IN_167: usize = 3; -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 = inp[2]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_1]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(329, &__args[..])?) { [G::ZERO; OUT_329] } else { let (__hash, __hit) = record.function_queries[329].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[329].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => { aiur_fn_329::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_167] = [__v_6]; record.function_queries[167].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_168: usize = 5; -const IN_168: usize = 5; -const OUT_168: usize = 2; -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 __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_7, __v_4]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(7); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_11, __v_10, __v_9, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_168] = [__v_10, __v_13]; record.function_queries[168].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; 4] = [__v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_168] = [__v_10, __v_11]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_168] = [__v_6, __v_7]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_168] = [__v_8, __v_9]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_3, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 7u64 => { match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(181, &__args[..])?) { [G::ZERO; OUT_181] } else { let (__hash, __hit) = record.function_queries[181].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[181].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => { aiur_fn_181::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(7); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_17, __v_18, __v_15, __v_18]; let __mq = record.memory_queries.get_index_mut(2).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_168] = [__v_16, __v_19]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(2).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_168] = [__v_14, __v_15]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(2).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_168] = [__v_14, __v_15]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, 3u64 => { let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(169, &__args[..])?) { [G::ZERO; OUT_169] } else { let (__hash, __hit) = record.function_queries[169].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[169].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[169].bump_multiplicity(__i); } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => { aiur_fn_169::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_168] = [__v_6, __v_7]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_168] = [__v_6, __v_7]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(461, &__args[..])?) { [G::ZERO; OUT_461] } else { let (__hash, __hit) = record.function_queries[461].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[461].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[461].bump_multiplicity(__i); } let __ret: [G; OUT_461] = unsafe { *(record.function_queries[461].output_at(__i).as_ptr() as *const [G; OUT_461]) }; __ret }, _ => { aiur_fn_461::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_168] = [__v_6, __v_7]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(2); let __v_7: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_168] = [__v_8, __v_9]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_3, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_3, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 7u64 => { match __v_13.as_canonical_u64() { 1u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; let __v_19: G = __loaded[3]; match __v_16.as_canonical_u64() { 7u64 => { match __v_17.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_14, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(7); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_22, __v_21, __v_20, __v_23]; let __mq = record.memory_queries.get_index_mut(2).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_168] = [__v_21, __v_24]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_20, __v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_index_mut(2).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_168] = [__v_20, __v_21]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_20, __v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_index_mut(2).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_168] = [__v_20, __v_21]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(2).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_168] = [__v_16, __v_17]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(2).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_168] = [__v_16, __v_17]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_168] = [__v_6, __v_7]; record.function_queries[168].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_169: usize = 2; -const IN_169: usize = 2; -const OUT_169: usize = 2; -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 __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 4] = [__v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_169] = [__v_5, __v_6]; record.function_queries[169].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_9]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(181, &__args[..])?) { [G::ZERO; OUT_181] } else { let (__hash, __hit) = record.function_queries[181].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[181].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => { aiur_fn_181::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(7); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_14]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(2); let __v_17: G = G::from_u64(40); let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(482, &__args[..])?) { [G::ZERO; OUT_482] } else { let (__hash, __hit) = record.function_queries[482].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[482].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => { aiur_fn_482::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = { let __values: [G; 3] = [__v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_16, __v_18, __v_20, __v_14]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(3); let __v_23: G = { let __values: [G; 4] = [__v_22, __v_21, __v_15, __v_14]; let __mq = record.memory_queries.get_index_mut(2).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_169] = [__v_19, __v_23]; record.function_queries[169].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_169] = [__v_11, __v_12]; record.function_queries[169].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_169] = [__v_11, __v_12]; 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 = 2; -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 __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 4] = [__v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_170] = [__v_5, __v_6]; record.function_queries[170].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { match __v_8.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; match __v_11.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(2); let __v_16: G = G::from_u64(89); let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(482, &__args[..])?) { [G::ZERO; OUT_482] } else { let (__hash, __hit) = record.function_queries[482].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[482].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => { aiur_fn_482::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_15, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_index_mut(2).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_170] = [__v_14, __v_20]; record.function_queries[170].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(2).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_170] = [__v_14, __v_15]; record.function_queries[170].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_170] = [__v_11, __v_12]; record.function_queries[170].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_170] = [__v_11, __v_12]; record.function_queries[170].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_171: usize = 1; -const IN_171: usize = 1; -const OUT_171: usize = 0; -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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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 __ret: [G; OUT_171] = []; record.function_queries[171].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_2, __v_3]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_5]; 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 __ret: [G; OUT_171] = []; record.function_queries[171].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_172: usize = 1; -const IN_172: usize = 1; -const OUT_172: usize = 1; -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 = G::from_u64(65); 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 __ret: [G; OUT_172] = [__v_2]; record.function_queries[172].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_173: usize = 2; -const IN_173: usize = 2; -const OUT_173: usize = 1; -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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_173] = [__v_1]; record.function_queries[173].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_3, __v_4]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_6, __v_5]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_173] = [__v_7]; record.function_queries[173].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_174: usize = 1; -const IN_174: usize = 1; -const OUT_174: usize = 1; -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 = G::from_u64(128); let __v_2: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_0, &__v_1) } else { aiur::execute::bytes2_less_than_value(__v_0, __v_1, record) }; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(192); let __v_4: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_0, &__v_3) } else { aiur::execute::bytes2_less_than_value(__v_0, __v_3, record) }; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(128); let __v_6: G = __v_0 - __v_5; let __ret: [G; OUT_174] = [__v_6]; record.function_queries[174].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_175: usize = 2; -const IN_175: usize = 2; -const OUT_175: usize = 2; -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]; let __v_2: G = G::from_u64(128); let __v_3: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_0, &__v_2) } else { aiur::execute::bytes2_less_than_value(__v_0, __v_2, record) }; match __v_3.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_175] = [__v_0, __v_1]; record.function_queries[175].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(194); let __v_5: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_0, &__v_4) } else { aiur::execute::bytes2_less_than_value(__v_0, __v_4, record) }; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(224); let __v_7: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_0, &__v_6) } else { aiur::execute::bytes2_less_than_value(__v_0, __v_6, record) }; match __v_7.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(192); let __v_12: G = __v_0 - __v_11; let __v_13: G = G::from_u64(64); let __v_14: G = __v_12 * __v_13; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_9]; 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_15: G = __r_arr[0]; let __v_16: G = __v_14 + __v_15; let __ret: [G; OUT_175] = [__v_16, __v_10]; record.function_queries[175].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { let __v_8: G = G::from_u64(240); let __v_9: G = if unconstrained { aiur::execute::CodegenBytes2::less_than(&__v_0, &__v_8) } else { aiur::execute::bytes2_less_than_value(__v_0, __v_8, record) }; match __v_9.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_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(1).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 __v_16: G = G::from_u64(224); let __v_17: G = __v_0 - __v_16; let __v_18: G = G::from_u64(4096); let __v_19: G = __v_17 * __v_18; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_11]; 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 = G::from_u64(64); let __v_22: G = __v_20 * __v_21; let __v_23: G = __v_19 + __v_22; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_14]; 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_24: G = __r_arr[0]; let __v_25: G = __v_23 + __v_24; let __v_26: G = G::from_u64(2048); let __v_27: G = { let __a_val = __v_25.as_canonical_u64(); let __b_val = __v_26.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_27.as_canonical_u64() { 0u64 => { let __v_28: G = G::from_u64(55296); let __v_29: G = { let __a_val = __v_25.as_canonical_u64(); let __b_val = __v_28.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_29.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_175] = [__v_25, __v_15]; record.function_queries[175].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_30: G = G::from_u64(57344); let __v_31: G = { let __a_val = __v_25.as_canonical_u64(); let __b_val = __v_30.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_31.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_175] = [__v_25, __v_15]; record.function_queries[175].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_29.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_27.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_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(1).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(1).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 __v_19: G = G::from_u64(240); let __v_20: G = __v_0 - __v_19; let __v_21: G = G::from_u64(262144); let __v_22: G = __v_20 * __v_21; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_11]; 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_23: G = __r_arr[0]; let __v_24: G = G::from_u64(4096); let __v_25: G = __v_23 * __v_24; let __v_26: G = __v_22 + __v_25; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_14]; 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_27: G = __r_arr[0]; let __v_28: G = G::from_u64(64); let __v_29: G = __v_27 * __v_28; let __v_30: G = __v_26 + __v_29; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_17]; 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_31: G = __r_arr[0]; let __v_32: G = __v_30 + __v_31; let __v_33: G = G::from_u64(65536); let __v_34: G = { let __a_val = __v_32.as_canonical_u64(); let __b_val = __v_33.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_34.as_canonical_u64() { 0u64 => { let __v_35: G = G::from_u64(1114112); let __v_36: G = { let __a_val = __v_32.as_canonical_u64(); let __b_val = __v_35.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_36.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_175] = [__v_32, __v_18]; record.function_queries[175].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_36.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_34.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_5.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_176: usize = 2; -const IN_176: usize = 2; -const OUT_176: usize = 1; -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 = G::from_u64(0); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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 = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 3] = [__v_2, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(2); let __v_8: G = G::from_u64(30); let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(482, &__args[..])?) { [G::ZERO; OUT_482] } else { let (__hash, __hit) = record.function_queries[482].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[482].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => { aiur_fn_482::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_7, __v_9, __v_6, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(31); let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(482, &__args[..])?) { [G::ZERO; OUT_482] } else { let (__hash, __hit) = record.function_queries[482].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[482].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => { aiur_fn_482::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_7, __v_12, __v_6, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(39); let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(482, &__args[..])?) { [G::ZERO; OUT_482] } else { let (__hash, __hit) = record.function_queries[482].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[482].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => { aiur_fn_482::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_7, __v_15, __v_5, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(40); let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(482, &__args[..])?) { [G::ZERO; OUT_482] } else { let (__hash, __hit) = record.function_queries[482].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[482].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => { aiur_fn_482::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_7, __v_18, __v_5, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(38); let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(482, &__args[..])?) { [G::ZERO; OUT_482] } else { let (__hash, __hit) = record.function_queries[482].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[482].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => { aiur_fn_482::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_7, __v_21, __v_5, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(3); let __v_24: G = { let __values: [G; 4] = [__v_23, __v_10, __v_16, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_23, __v_13, __v_16, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_177] = { let __args: [G; IN_177] = [__v_1, __v_24, __v_25, __v_19]; 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_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_23, __v_22, __v_26, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_176] = [__v_27]; record.function_queries[176].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_177: usize = 4; -const IN_177: usize = 4; -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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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 __ret: [G; OUT_177] = [__v_1]; record.function_queries[177].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_5, __v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(181, &__args[..])?) { [G::ZERO; OUT_181] } else { let (__hash, __hit) = record.function_queries[181].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[181].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => { aiur_fn_181::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(7); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_10, __v_11, __v_9, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_14: G = { let __values: [G; 4] = [__v_13, __v_3, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_2, __v_14, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_177] = { let __args: [G; IN_177] = [__v_8, __v_1, __v_2, __v_3]; 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_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 4] = [__v_13, __v_15, __v_16, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_177] = [__v_17]; record.function_queries[177].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_178: usize = 3; -const IN_178: usize = 3; -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 = inp[2]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_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() { 3u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; let __v_16: G = __loaded[4]; let __v_17: G = __loaded[5]; let __v_18: G = __loaded[6]; let __v_19: G = __loaded[7]; let __v_20: G = __loaded[8]; let __v_21: G = __loaded[9]; let __v_22: G = __loaded[10]; let __v_23: G = __loaded[11]; match __v_12.as_canonical_u64() { 1u64 => { let __v_24: G = G::from_u64(1); let __v_25: G = { let __values: [G; 3] = [__v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_index_mut(1).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_283] = { let __args: [G; IN_283] = [__v_15, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_27: G = __loaded[0]; let __v_28: G = __loaded[1]; let __v_29: G = __loaded[2]; let __v_30: G = __loaded[3]; match __v_27.as_canonical_u64() { 4u64 => { let __v_31: G = G::from_u64(0); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_29, __v_5, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_32, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(365, &__args[..])?) { [G::ZERO; OUT_365] } else { let (__hash, __hit) = record.function_queries[365].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[365].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => { aiur_fn_365::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __ret: [G; OUT_178] = [__v_33]; record.function_queries[178].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_31: G = G::from_u64(3); let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 4] = [__v_31, __v_26, __v_5, __v_32]; let __mq = record.memory_queries.get_index_mut(2).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_365] = { let __args: [G; IN_365] = [__v_0, __v_33, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(365, &__args[..])?) { [G::ZERO; OUT_365] } else { let (__hash, __hit) = record.function_queries[365].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[365].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => { aiur_fn_365::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __ret: [G; OUT_178] = [__v_34]; record.function_queries[178].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_178] = [__v_1]; record.function_queries[178].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_178] = [__v_1]; record.function_queries[178].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_178] = [__v_1]; record.function_queries[178].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_179: usize = 3; -const IN_179: usize = 3; -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 = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_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() { 7u64 => { match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_5]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_0, __v_7, __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_8: G = __r_arr[0]; let __ret: [G; OUT_179] = [__v_8]; record.function_queries[179].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_179] = [__v_1]; record.function_queries[179].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_179] = [__v_1]; record.function_queries[179].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_180: usize = 1; -const IN_180: usize = 1; -const OUT_180: usize = 4; -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 = G::from_u64(0); let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_3, __v_1]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_5, __v_1]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_7, __v_1]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_180] = [__v_2, __v_4, __v_6, __v_8]; record.function_queries[180].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_181: usize = 1; -const IN_181: usize = 1; -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 __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[180].lookup(&__args[..]); match __hit { Some(__i) if true => { 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = G::from_u64(0); let __v_6: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_1, &__v_5) } else { aiur::execute::bytes2_xor_value(__v_1, __v_5, record) }; let __v_7: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_2, &__v_5) } else { aiur::execute::bytes2_xor_value(__v_2, __v_5, record) }; let __v_8: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_3, &__v_5) } else { aiur::execute::bytes2_xor_value(__v_3, __v_5, record) }; let __v_9: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_4, &__v_5) } else { aiur::execute::bytes2_xor_value(__v_4, __v_5, record) }; let __v_10: G = G::from_u64(256); let __v_11: G = __v_10 * __v_7; let __v_12: G = __v_6 + __v_11; let __v_13: G = G::from_u64(65536); let __v_14: G = __v_13 * __v_8; let __v_15: G = __v_12 + __v_14; let __v_16: G = G::from_u64(16777216); let __v_17: G = __v_16 * __v_9; let __v_18: G = __v_15 + __v_17; if (__v_0 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("u32 byte split does not recompose to the original value".to_string()) }); } let __v_19: G = G::from_u64(1); let __v_20: 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(7).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_21: G = { let __values: [G; 10] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_5, __v_5, __v_5, __v_5, __v_20]; let __mq = record.memory_queries.get_index_mut(7).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_136] = { let __args: [G; IN_136] = [__v_21]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_181] = [__v_22]; record.function_queries[181].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -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]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_3]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { let __v_10: G = G::from_u64(30); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_7, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(480, &__args[..])?) { [G::ZERO; OUT_480] } else { let (__hash, __hit) = record.function_queries[480].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[480].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => { aiur_fn_480::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 3] = [__v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_182] = [__v_13, __v_14]; record.function_queries[182].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_182] = [__v_13, __v_15]; record.function_queries[182].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(31); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_7, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(480, &__args[..])?) { [G::ZERO; OUT_480] } else { let (__hash, __hit) = record.function_queries[480].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[480].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => { aiur_fn_480::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_182] = [__v_14, __v_16]; record.function_queries[182].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 3u64 => { let __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_5, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_16, __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_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; match __v_17.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_index_mut(1).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_182] = [__v_19, __v_21]; record.function_queries[182].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_19: G = G::from_u64(2); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_5, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_20, __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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 0u64 => { let __v_23: G = G::from_u64(0); let __ret: [G; OUT_182] = [__v_23, __v_22]; record.function_queries[182].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_23: G = G::from_u64(1); let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_18, __v_22]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_182] = [__v_23, __v_24]; record.function_queries[182].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }, _ => { let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_182] = [__v_15, __v_17]; record.function_queries[182].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { let __v_10: G = G::from_u64(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(1).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_182] = [__v_10, __v_12]; record.function_queries[182].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_183: usize = 3; -const IN_183: usize = 3; -const OUT_183: usize = 2; -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]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(184, &__args[..])?) { [G::ZERO; OUT_184] } else { let (__hash, __hit) = record.function_queries[184].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[184].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[184].bump_multiplicity(__i); } let __ret: [G; OUT_184] = unsafe { *(record.function_queries[184].output_at(__i).as_ptr() as *const [G; OUT_184]) }; __ret }, _ => { aiur_fn_184::(__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() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_183] = [__v_5, __v_4]; record.function_queries[183].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(184, &__args[..])?) { [G::ZERO; OUT_184] } else { let (__hash, __hit) = record.function_queries[184].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[184].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[184].bump_multiplicity(__i); } let __ret: [G; OUT_184] = unsafe { *(record.function_queries[184].output_at(__i).as_ptr() as *const [G; OUT_184]) }; __ret }, _ => { aiur_fn_184::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_183] = [__v_6, __v_7]; record.function_queries[183].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_184: usize = 2; -const IN_184: usize = 2; -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 __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 3u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { let __v_10: G = G::from_u64(40); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_7, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(480, &__args[..])?) { [G::ZERO; OUT_480] } else { let (__hash, __hit) = record.function_queries[480].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[480].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => { aiur_fn_480::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_184] = [__v_12, __v_12]; record.function_queries[184].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 7u64 => { match __v_13.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_14]; 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_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_184] = [__v_16, __v_17]; record.function_queries[184].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_184] = [__v_16, __v_16]; record.function_queries[184].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_184] = [__v_16, __v_16]; record.function_queries[184].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_184] = [__v_10, __v_10]; record.function_queries[184].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_184] = [__v_6, __v_6]; 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 = 2; -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]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).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(7).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() { 1u64 => { let __v_21: G = __v_5 + __v_6; let __v_22: G = __v_21 + __v_7; let __v_23: G = __v_22 + __v_8; let __v_24: G = __v_23 + __v_9; let __v_25: G = G::from_bool(__v_24 == G::ZERO); match __v_25.as_canonical_u64() { 0u64 => { let __v_26: G = G::from_u64(0); let __ret: [G; OUT_185] = [__v_26, __v_26]; record.function_queries[185].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(256); let __v_27: G = __v_3 * __v_26; let __v_28: G = __v_2 + __v_27; let __v_29: G = G::from_u64(65536); let __v_30: G = __v_4 * __v_29; let __v_31: G = __v_28 + __v_30; let __v_32: G = G::from_u64(55296); let __v_33: G = { let __a_val = __v_31.as_canonical_u64(); let __b_val = __v_32.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_33.as_canonical_u64() { 1u64 => { let __v_34: G = G::from_u64(1); let __ret: [G; OUT_185] = [__v_34, __v_31]; record.function_queries[185].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_34: G = G::from_u64(57343); let __v_35: G = { let __a_val = __v_34.as_canonical_u64(); let __b_val = __v_31.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_35.as_canonical_u64() { 0u64 => { let __v_36: G = G::from_u64(0); let __ret: [G; OUT_185] = [__v_36, __v_36]; record.function_queries[185].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_36: G = G::from_u64(1114112); let __v_37: G = { let __a_val = __v_31.as_canonical_u64(); let __b_val = __v_36.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_37.as_canonical_u64() { 1u64 => { let __v_38: G = G::from_u64(1); let __ret: [G; OUT_185] = [__v_38, __v_31]; record.function_queries[185].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __ret: [G; OUT_185] = [__v_38, __v_38]; record.function_queries[185].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, _ => { let __v_21: G = G::from_u64(0); let __ret: [G; OUT_185] = [__v_21, __v_21]; record.function_queries[185].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_185] = [__v_11, __v_11]; record.function_queries[185].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_186: usize = 2; -const IN_186: usize = 2; -const OUT_186: usize = 2; -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 = G::from_u64(64); let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_3.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_186] = [__v_0, __v_1]; record.function_queries[186].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(64); let __v_5: G = __v_0 - __v_4; let __v_6: G = G::from_u64(1); let __v_7: G = __v_1 + __v_6; let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_186] = [__v_8, __v_9]; record.function_queries[186].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_187: usize = 1; -const IN_187: usize = 1; -const OUT_187: usize = 4; -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 = G::from_u64(0); let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_187] = [__v_2, __v_4, __v_6, __v_7]; record.function_queries[187].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_188: usize = 2; -const IN_188: usize = 2; -const OUT_188: usize = 1; -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 __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[187].lookup(&__args[..]); match __hit { Some(__i) if true => { 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_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 = G::from_u64(0); let __v_7: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_2, &__v_6) } else { aiur::execute::bytes2_xor_value(__v_2, __v_6, record) }; let __v_8: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_3, &__v_6) } else { aiur::execute::bytes2_xor_value(__v_3, __v_6, record) }; let __v_9: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_4, &__v_6) } else { aiur::execute::bytes2_xor_value(__v_4, __v_6, record) }; let __v_10: G = if unconstrained { aiur::execute::CodegenBytes2::xor(&__v_5, &__v_6) } else { aiur::execute::bytes2_xor_value(__v_5, __v_6, record) }; let __v_11: G = G::from_u64(64); let __v_12: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_11.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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 __v_13: G = G::from_u64(1); if (__v_12 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("utf8 group 0 is not a 6-bit value".to_string()) }); } let __v_14: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_11.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_14 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("utf8 group 1 is not a 6-bit value".to_string()) }); } let __v_15: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_11.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_15 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("utf8 group 2 is not a 6-bit value".to_string()) }); } let __v_16: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_11.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_16 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("utf8 group 3 is not a 6-bit value".to_string()) }); } let __v_17: G = __v_8 * __v_11; let __v_18: G = __v_7 + __v_17; let __v_19: G = G::from_u64(4096); let __v_20: G = __v_9 * __v_19; let __v_21: G = __v_18 + __v_20; let __v_22: G = G::from_u64(262144); let __v_23: G = __v_10 * __v_22; let __v_24: G = __v_21 + __v_23; if (__v_0 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("utf8 groups do not recompose to the codepoint".to_string()) }); } let __v_25: G = G::from_u64(128); let __v_26: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_25.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_26.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 3] = [__v_27, __v_0, __v_1]; let __mq = record.memory_queries.get_index_mut(1).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_188] = [__v_28]; record.function_queries[188].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(2048); let __v_28: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_27.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_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(128); let __v_30: G = __v_7 + __v_29; let __v_31: G = G::from_u64(192); let __v_32: G = __v_8 + __v_31; let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 3] = [__v_33, __v_30, __v_1]; let __mq = record.memory_queries.get_index_mut(1).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_33, __v_32, __v_34]; let __mq = record.memory_queries.get_index_mut(1).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_188] = [__v_35]; record.function_queries[188].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_29: G = G::from_u64(65536); let __v_30: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_29.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_30.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(128); let __v_32: G = __v_7 + __v_31; let __v_33: G = __v_8 + __v_31; let __v_34: G = G::from_u64(224); let __v_35: G = __v_9 + __v_34; let __v_36: G = G::from_u64(0); let __v_37: G = { let __values: [G; 3] = [__v_36, __v_32, __v_1]; let __mq = record.memory_queries.get_index_mut(1).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_36, __v_33, __v_37]; let __mq = record.memory_queries.get_index_mut(1).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_36, __v_35, __v_38]; let __mq = record.memory_queries.get_index_mut(1).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_188] = [__v_39]; record.function_queries[188].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_31: G = G::from_u64(128); let __v_32: G = __v_7 + __v_31; let __v_33: G = __v_8 + __v_31; let __v_34: G = __v_9 + __v_31; let __v_35: G = G::from_u64(240); let __v_36: G = __v_10 + __v_35; let __v_37: G = G::from_u64(0); let __v_38: G = { let __values: [G; 3] = [__v_37, __v_32, __v_1]; let __mq = record.memory_queries.get_index_mut(1).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_37, __v_33, __v_38]; let __mq = record.memory_queries.get_index_mut(1).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_40: G = { let __values: [G; 3] = [__v_37, __v_34, __v_39]; let __mq = record.memory_queries.get_index_mut(1).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_41: G = { let __values: [G; 3] = [__v_37, __v_36, __v_40]; let __mq = record.memory_queries.get_index_mut(1).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_188] = [__v_41]; record.function_queries[188].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_189: usize = 2; -const IN_189: usize = 2; -const OUT_189: usize = 2; -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 __v_1: G = inp[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 7u64 => { match __v_3.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_189] = [__v_6, __v_4]; record.function_queries[189].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 = { let __values: [G; 10] = [__v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(7).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_189] = [__v_6, __v_8]; record.function_queries[189].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __v_6: G = G::from_u64(1); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(480, &__args[..])?) { [G::ZERO; OUT_480] } else { let (__hash, __hit) = record.function_queries[480].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[480].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => { aiur_fn_480::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 10] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(7).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_189] = [__v_8, __v_9]; record.function_queries[189].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; 10] = [__v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(7).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_189] = [__v_8, __v_10]; record.function_queries[189].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 3u64 => { let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_3, __v_4]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_189] = [__v_6, __v_7]; record.function_queries[189].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 = { let __values: [G; 10] = [__v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(7).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_189] = [__v_6, __v_8]; record.function_queries[189].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_190: usize = 3; -const IN_190: usize = 3; -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 __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { let __v_7: G = G::from_u64(2); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(480, &__args[..])?) { [G::ZERO; OUT_480] } else { let (__hash, __hit) = record.function_queries[480].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[480].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => { aiur_fn_480::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_2]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_190] = [__v_11, __v_12]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(7).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_190] = [__v_11, __v_13]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 10] = [__v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(7).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_190] = [__v_9, __v_11]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 10] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(7).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_190] = [__v_7, __v_9]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_191: usize = 1; -const IN_191: usize = 1; -const OUT_191: usize = 1; -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 = G::from_u64(7); let __v_2: G = G::from_u64(0); let __v_3: G = { let __values: [G; 4] = [__v_1, __v_2, __v_0, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_191] = [__v_3]; record.function_queries[191].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_192: usize = 2; -const IN_192: usize = 2; -const OUT_192: usize = 3; -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 __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 3u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_4]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(71); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_7, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(480, &__args[..])?) { [G::ZERO; OUT_480] } else { let (__hash, __hit) = record.function_queries[480].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[480].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => { aiur_fn_480::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_11]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_192] = [__v_14, __v_15, __v_16]; record.function_queries[192].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(72); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_7, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(480, &__args[..])?) { [G::ZERO; OUT_480] } else { let (__hash, __hit) = record.function_queries[480].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[480].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => { aiur_fn_480::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__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]; 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 __ret: [G; OUT_192] = [__v_16, __v_16, __v_18]; record.function_queries[192].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 10] = [__v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_index_mut(7).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_192] = [__v_16, __v_16, __v_18]; record.function_queries[192].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__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(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_192] = [__v_12, __v_12, __v_14]; record.function_queries[192].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 10] = [__v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(7).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_192] = [__v_10, __v_10, __v_12]; record.function_queries[192].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 = { let __values: [G; 10] = [__v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(7).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_192] = [__v_6, __v_6, __v_8]; record.function_queries[192].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_193: usize = 3; -const IN_193: usize = 3; -const OUT_193: usize = 1; -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 __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_3]; 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_5: G = __r_arr[0]; let __v_6: G = __v_4 - __v_5; let __v_7: G = __v_1 * __v_6; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(71); let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(482, &__args[..])?) { [G::ZERO; OUT_482] } else { let (__hash, __hit) = record.function_queries[482].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[482].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => { aiur_fn_482::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; break '__mc_0 [__v_9]; }, _ => { let __v_8: G = G::from_u64(72); let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(482, &__args[..])?) { [G::ZERO; OUT_482] } else { let (__hash, __hit) = record.function_queries[482].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[482].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => { aiur_fn_482::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; break '__mc_0 [__v_9]; }, } }; let __v_8: G = __mc_out___mc_0[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_7.as_canonical_u64() { 0u64 => { break '__mc_1 [__v_3]; }, _ => { let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_3]; 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 __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_9]; 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_10: G = __r_arr[0]; break '__mc_1 [__v_10]; }, } }; let __v_9: G = __mc_out___mc_1[0]; let __v_10: G = G::from_u64(3); let __v_11: G = G::from_u64(2); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_11, __v_8, __v_13, __v_14]; let __mq = record.memory_queries.get_index_mut(2).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_191] = { let __args: [G; IN_191] = [__v_9]; 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_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 4] = [__v_10, __v_15, __v_16, __v_14]; let __mq = record.memory_queries.get_index_mut(2).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_193] = [__v_17]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_194: usize = 5; -const IN_194: usize = 5; -const OUT_194: usize = 1; -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 = __v_1 - __v_3; match __v_5.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_2, __v_4]; 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 __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_1, __v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_194] = [__v_7]; record.function_queries[194].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_2, __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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_4, __v_2]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_3, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_194] = [__v_8]; record.function_queries[194].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_2, __v_4]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_1, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_194] = [__v_8]; record.function_queries[194].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_195: usize = 4; -const IN_195: usize = 4; -const OUT_195: usize = 1; -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 __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_3]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_1, __v_2]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_195] = [__v_5]; record.function_queries[195].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_2, __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_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_5]; 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_7: G = __r_arr[0]; let __v_8: G = __v_6 - __v_7; let __v_9: G = __v_1 * __v_8; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_3, __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_11: G = __r_arr[0]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_10, __v_11]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_195] = [__v_12]; record.function_queries[195].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_10, __v_5]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_195] = [__v_11]; record.function_queries[195].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_196: usize = 5; -const IN_196: usize = 5; -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 __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_4]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(7).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_193] = { let __args: [G; IN_193] = [__v_0, __v_6, __v_8]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_196] = [__v_9]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_2, __v_4]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_2, __v_4]; 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_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7]; 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_9: G = __r_arr[0]; let __v_10: G = __v_8 - __v_9; let __v_11: G = __v_1 * __v_10; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; break '__mc_0 [__v_12]; }, _ => { break '__mc_0 [__v_6]; }, } }; let __v_12: G = __mc_out___mc_0[0]; let __v_13: G = __v_1 + __v_3; let __v_14: G = G::from_u64(2); let __v_15: G = __v_14 * __v_1; let __v_16: G = __v_15 * __v_3; let __v_17: G = __v_13 - __v_16; let __v_18: G = G::from_u64(1); let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_12]; 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_19: G = __r_arr[0]; let __v_20: G = __v_18 - __v_19; let __v_21: G = __v_17 * __v_20; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_21, __v_12]; 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 __ret: [G; OUT_196] = [__v_22]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_197: usize = 4; -const IN_197: usize = 4; -const OUT_197: usize = 1; -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 __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_3]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_1, __v_2]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_197] = [__v_5]; record.function_queries[197].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_2, __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_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_5]; 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_7: G = __r_arr[0]; let __v_8: G = __v_6 - __v_7; let __v_9: G = __v_1 * __v_8; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_3, __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_10: G = __r_arr[0]; break '__mc_0 [__v_10]; }, _ => { break '__mc_0 [__v_5]; }, } }; let __v_10: G = __mc_out___mc_0[0]; let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(2); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__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(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_15: G = { let __values: [G; 10] = [__v_11, __v_12, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_14]; let __mq = record.memory_queries.get_index_mut(7).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_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_16, __v_15]; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_17, __v_10]; 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_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { let __v_19: G = G::from_u64(1); let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_3, __v_10]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_19, __v_20]; 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_21: G = __r_arr[0]; let __ret: [G; OUT_197] = [__v_21]; record.function_queries[197].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_19, __v_10]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_197] = [__v_20]; record.function_queries[197].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_198: usize = 4; -const IN_198: usize = 4; -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]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_3]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 10] = [__v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(7).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_193] = { let __args: [G; IN_193] = [__v_0, __v_5, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_198] = [__v_8]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_2, __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_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_5]; 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_7: G = __r_arr[0]; let __v_8: G = __v_6 - __v_7; let __v_9: G = __v_1 * __v_8; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_3, __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_10: G = __r_arr[0]; break '__mc_0 [__v_10]; }, _ => { break '__mc_0 [__v_5]; }, } }; let __v_10: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_2, __v_3]; 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_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_5]; 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_13: G = __r_arr[0]; let __v_14: G = __v_12 - __v_13; let __v_15: G = __v_1 * __v_14; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_15.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; break '__mc_1 [__v_16]; }, _ => { break '__mc_1 [__v_11]; }, } }; let __v_16: G = __mc_out___mc_1[0]; let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_16]; 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_18: G = __r_arr[0]; let __v_19: G = __v_17 - __v_18; let __v_20: G = __v_1 * __v_19; let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(2); let __v_23: G = { let __values: [G; 10] = [__v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_index_mut(7).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_24: G = { let __values: [G; 10] = [__v_21, __v_22, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_23]; let __mq = record.memory_queries.get_index_mut(7).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_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_25, __v_24]; 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_26: G = __r_arr[0]; let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_26, __v_10]; 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_27: G = __r_arr[0]; match __v_27.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_20, __v_16]; 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_28: G = __r_arr[0]; let __ret: [G; OUT_198] = [__v_28]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); let __v_30: G = { let __values: [G; 10] = [__v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_index_mut(7).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_31: G = { let __values: [G; 10] = [__v_28, __v_29, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_30]; let __mq = record.memory_queries.get_index_mut(7).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_194] = { let __args: [G; IN_194] = [__v_0, __v_20, __v_16, __v_28, __v_31]; 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_32: G = __r_arr[0]; let __ret: [G; OUT_198] = [__v_32]; 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]; let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(329, &__args[..])?) { [G::ZERO; OUT_329] } else { let (__hash, __hit) = record.function_queries[329].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[329].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => { aiur_fn_329::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; match __v_1.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_8, __v_9]; record.function_queries[199].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_4, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; match __v_10.as_canonical_u64() { 1u64 => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_1.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_12]; 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_13: G = __r_arr[0]; break '__mc_0 [__v_13]; }, _ => { let __v_13: G = G::from_u64(1); let __v_14: G = __v_13 - __v_11; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_12]; 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_15: G = __r_arr[0]; let __v_16: G = __v_13 - __v_15; let __v_17: G = __v_14 * __v_16; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_17, __v_12]; 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_18: G = __r_arr[0]; break '__mc_0 [__v_18]; }, } }; let __v_13: G = __mc_out___mc_0[0]; let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_4, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_13, __v_15]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_199] = [__v_14, __v_16]; record.function_queries[199].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_14]; record.function_queries[199].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, 2u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_8, __v_9]; record.function_queries[199].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_4, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; match __v_10.as_canonical_u64() { 1u64 => { let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_1.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_12]; 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_13: G = __r_arr[0]; break '__mc_1 [__v_13]; }, _ => { let __v_13: G = G::from_u64(1); let __v_14: G = __v_13 - __v_11; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_12]; 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_15: G = __r_arr[0]; let __v_16: G = __v_13 - __v_15; let __v_17: G = __v_14 * __v_16; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_17, __v_12]; 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_18: G = __r_arr[0]; break '__mc_1 [__v_18]; }, } }; let __v_13: G = __mc_out___mc_1[0]; let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_4, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_13, __v_15]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_199] = [__v_14, __v_16]; record.function_queries[199].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_14]; record.function_queries[199].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_6: G = G::from_u64(2); let __v_7: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_8, __v_9]; record.function_queries[199].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_4, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0, __v_1, __v_4, __v_11, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_199] = [__v_13, __v_14]; record.function_queries[199].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_14]; record.function_queries[199].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_200: usize = 5; -const IN_200: usize = 5; -const OUT_200: usize = 2; -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]; match __v_1.as_canonical_u64() { 3u64 => { let __v_5: G = G::from_u64(1); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { 1u64 => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_1.as_canonical_u64() { 3u64 => { let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_0, __v_3, __v_4, __v_8]; 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_9: G = __r_arr[0]; break '__mc_0 [__v_9]; }, 4u64 => { let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0, __v_3, __v_4, __v_8]; 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_9: G = __r_arr[0]; break '__mc_0 [__v_9]; }, _ => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(2); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 10] = [__v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(7).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_13: G = { let __values: [G; 10] = [__v_9, __v_10, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_12]; let __mq = record.memory_queries.get_index_mut(7).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_150] = { let __args: [G; IN_150] = [__v_8, __v_13]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__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_15: G = __r_arr[0]; let __v_16: G = __v_11 - __v_15; let __v_17: G = __v_3 * __v_16; let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_4, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(152, &__args[..])?) { [G::ZERO; OUT_152] } else { let (__hash, __hit) = record.function_queries[152].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[152].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => { aiur_fn_152::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __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_19: G = __r_arr[0]; break '__mc_0 [__v_19]; }, } }; let __v_9: G = __mc_out___mc_0[0]; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(2); let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __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_13: G = __r_arr[0]; let __ret: [G; OUT_200] = [__v_10, __v_13]; record.function_queries[200].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_200] = [__v_9, __v_10]; record.function_queries[200].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __v_5: G = G::from_u64(1); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { 1u64 => { let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_1.as_canonical_u64() { 3u64 => { let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_0, __v_3, __v_4, __v_8]; 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_9: G = __r_arr[0]; break '__mc_1 [__v_9]; }, 4u64 => { let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0, __v_3, __v_4, __v_8]; 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_9: G = __r_arr[0]; break '__mc_1 [__v_9]; }, _ => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(2); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 10] = [__v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(7).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_13: G = { let __values: [G; 10] = [__v_9, __v_10, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_12]; let __mq = record.memory_queries.get_index_mut(7).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_150] = { let __args: [G; IN_150] = [__v_8, __v_13]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__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_15: G = __r_arr[0]; let __v_16: G = __v_11 - __v_15; let __v_17: G = __v_3 * __v_16; let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_4, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(152, &__args[..])?) { [G::ZERO; OUT_152] } else { let (__hash, __hit) = record.function_queries[152].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[152].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => { aiur_fn_152::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __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_19: G = __r_arr[0]; break '__mc_1 [__v_19]; }, } }; let __v_9: G = __mc_out___mc_1[0]; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(2); let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __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_13: G = __r_arr[0]; let __ret: [G; OUT_200] = [__v_10, __v_13]; record.function_queries[200].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_200] = [__v_9, __v_10]; record.function_queries[200].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 5u64 => { let __v_5: G = G::from_u64(1); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { 1u64 => { let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_1.as_canonical_u64() { 3u64 => { let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_0, __v_3, __v_4, __v_8]; 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_9: G = __r_arr[0]; break '__mc_2 [__v_9]; }, 4u64 => { let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0, __v_3, __v_4, __v_8]; 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_9: G = __r_arr[0]; break '__mc_2 [__v_9]; }, _ => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(2); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 10] = [__v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(7).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_13: G = { let __values: [G; 10] = [__v_9, __v_10, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_12]; let __mq = record.memory_queries.get_index_mut(7).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_150] = { let __args: [G; IN_150] = [__v_8, __v_13]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__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_15: G = __r_arr[0]; let __v_16: G = __v_11 - __v_15; let __v_17: G = __v_3 * __v_16; let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_4, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(152, &__args[..])?) { [G::ZERO; OUT_152] } else { let (__hash, __hit) = record.function_queries[152].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[152].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => { aiur_fn_152::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __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_19: G = __r_arr[0]; break '__mc_2 [__v_19]; }, } }; let __v_9: G = __mc_out___mc_2[0]; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(2); let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __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_13: G = __r_arr[0]; let __ret: [G; OUT_200] = [__v_10, __v_13]; record.function_queries[200].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_200] = [__v_9, __v_10]; record.function_queries[200].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_5: G = G::from_u64(1); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; match __v_7.as_canonical_u64() { 1u64 => { let __mc_out___mc_3: [G; 1] = '__mc_3: { match __v_1.as_canonical_u64() { 6u64 => { let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_0, __v_3, __v_4, __v_8, __v_9]; 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_10: G = __r_arr[0]; break '__mc_3 [__v_10]; }, 7u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = __v_10 - __v_8; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_9]; 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_12: G = __r_arr[0]; let __v_13: G = __v_10 - __v_12; let __v_14: G = __v_11 * __v_13; let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_0, __v_3, __v_4, __v_14, __v_9]; 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_15: G = __r_arr[0]; break '__mc_3 [__v_15]; }, 8u64 => { let __v_10: G = __v_3 + __v_8; let __v_11: G = G::from_u64(2); let __v_12: G = __v_11 * __v_3; let __v_13: G = __v_12 * __v_8; let __v_14: G = __v_10 - __v_13; let __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_4]; 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_16: G = __r_arr[0]; let __v_17: G = __v_15 - __v_16; let __v_18: G = __v_14 * __v_17; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_9]; 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_19: G = __r_arr[0]; let __v_20: G = __v_15 - __v_19; let __v_21: G = __v_18 * __v_20; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_4, __v_9]; 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_22: G = __r_arr[0]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_21, __v_22]; 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_23: G = __r_arr[0]; break '__mc_3 [__v_23]; }, 9u64 => { let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_0, __v_3, __v_4, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(195, &__args[..])?) { [G::ZERO; OUT_195] } else { let (__hash, __hit) = record.function_queries[195].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[195].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => { aiur_fn_195::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; break '__mc_3 [__v_10]; }, _ => { let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0, __v_3, __v_4, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(196, &__args[..])?) { [G::ZERO; OUT_196] } else { let (__hash, __hit) = record.function_queries[196].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[196].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => { aiur_fn_196::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; break '__mc_3 [__v_10]; }, } }; let __v_10: G = __mc_out___mc_3[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(2); let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_10, __v_13]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_200] = [__v_11, __v_14]; record.function_queries[200].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_200] = [__v_10, __v_11]; record.function_queries[200].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_201: usize = 2; -const IN_201: usize = 2; -const OUT_201: usize = 1; -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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_201] = [__v_0]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(3); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_5, __v_0, __v_3, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_201] = { let __args: [G; IN_201] = [__v_7, __v_4]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_201] = [__v_8]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_202: usize = 4; -const IN_202: usize = 4; -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]; match __v_1.as_canonical_u64() { 3u64 => { let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_2, __v_3]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_5]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_202] = [__v_4, __v_7]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_2, __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_5: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_5]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_202] = [__v_4, __v_7]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_2, __v_3]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_5]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_202] = [__v_4, __v_7]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_2, __v_3]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_5]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_202] = [__v_4, __v_7]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_2, __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_5: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_5]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_202] = [__v_4, __v_7]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_2, __v_3]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_5]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_202] = [__v_4, __v_7]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(152, &__args[..])?) { [G::ZERO; OUT_152] } else { let (__hash, __hit) = record.function_queries[152].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[152].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => { aiur_fn_152::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_5]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_202] = [__v_4, __v_7]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_2, __v_3]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_5]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_202] = [__v_4, __v_7]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_2, __v_3]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_5]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_202] = [__v_4, __v_7]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_2, __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_5: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_5]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_202] = [__v_4, __v_7]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_2, __v_3]; 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_136] = { let __args: [G; IN_136] = [__v_5]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_202] = [__v_4, __v_7]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_2, __v_3]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_5]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_202] = [__v_4, __v_7]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 15u64 => { let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(285, &__args[..])?) { [G::ZERO; OUT_285] } else { let (__hash, __hit) = record.function_queries[285].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[285].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[285].bump_multiplicity(__i); } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => { aiur_fn_285::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_202] = [__v_4, __v_6]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 16u64 => { let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_2, __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]; let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_202] = [__v_4, __v_6]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __v_5: G = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_202] = [__v_4, __v_5]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_203: usize = 3; -const IN_203: usize = 3; -const OUT_203: usize = 3; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { let __v_7: G = G::from_u64(42); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(480, &__args[..])?) { [G::ZERO; OUT_480] } else { let (__hash, __hit) = record.function_queries[480].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[480].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => { aiur_fn_480::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 10] = [__v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(7).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_203] = [__v_9, __v_1, __v_11]; record.function_queries[203].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(2); let __v_11: G = __v_9 - __v_10; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_2, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_2, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; let __v_19: G = __loaded[3]; match __v_16.as_canonical_u64() { 7u64 => { match __v_17.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(1); let __ret: [G; OUT_203] = [__v_20, __v_13, __v_18]; record.function_queries[203].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_index_mut(7).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_203] = [__v_20, __v_1, __v_22]; record.function_queries[203].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_index_mut(7).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_203] = [__v_20, __v_1, __v_22]; record.function_queries[203].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__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(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_203] = [__v_12, __v_1, __v_14]; record.function_queries[203].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 10] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(7).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_203] = [__v_7, __v_1, __v_9]; record.function_queries[203].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_204: usize = 3; -const IN_204: usize = 3; -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 __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 10] = [__v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(7).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_6: G = { let __values: [G; 10] = [__v_3, __v_4, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(7).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_137] = { let __args: [G; IN_137] = [__v_2, __v_6]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_7]; 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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(2); let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(481, &__args[..])?) { [G::ZERO; OUT_481] } else { let (__hash, __hit) = record.function_queries[481].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[481].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => { aiur_fn_481::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_9, __v_10, __v_11, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_147] = { let __args: [G; IN_147] = [__v_8]; 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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_14, __v_12, __v_1, __v_15]; let __mq = record.memory_queries.get_index_mut(2).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_204] = [__v_16]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(2); let __v_15: G = G::from_u64(42); let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(481, &__args[..])?) { [G::ZERO; OUT_481] } else { let (__hash, __hit) = record.function_queries[481].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[481].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => { aiur_fn_481::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_14, __v_16, __v_18, __v_19]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = G::from_u64(7); let __v_22: G = { let __values: [G; 4] = [__v_21, __v_19, __v_8, __v_19]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(3); let __v_24: G = { let __values: [G; 4] = [__v_23, __v_20, __v_1, __v_19]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_23, __v_24, __v_22, __v_19]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_23, __v_12, __v_25, __v_19]; let __mq = record.memory_queries.get_index_mut(2).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_204] = [__v_26]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -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(2).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_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 7u64 => { let __ret: [G; OUT_205] = [__v_1]; record.function_queries[205].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_1]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0, __v_6, __v_7]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; match __v_12.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_14]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_15]; 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_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_205] = [__v_1]; record.function_queries[205].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_13, __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 __ret: [G; OUT_205] = [__v_17]; record.function_queries[205].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_205] = [__v_1]; record.function_queries[205].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_205] = [__v_1]; record.function_queries[205].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_206: usize = 4; -const IN_206: usize = 4; -const OUT_206: usize = 2; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_2]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1, __v_3]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_206] = [__v_5, __v_6]; record.function_queries[206].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(2); let __v_6: G = G::from_u64(42); let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(481, &__args[..])?) { [G::ZERO; OUT_481] } else { let (__hash, __hit) = record.function_queries[481].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[481].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => { aiur_fn_481::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_5, __v_7, __v_9, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_13: G = { let __values: [G; 4] = [__v_12, __v_11, __v_1, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_191] = { let __args: [G; IN_191] = [__v_2]; 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_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_201] = { let __args: [G; IN_201] = [__v_15, __v_3]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_206] = [__v_8, __v_16]; 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 __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 4u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 4u64 => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_8]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { let __v_16: G = G::from_u64(2); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_13, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(480, &__args[..])?) { [G::ZERO; OUT_480] } else { let (__hash, __hit) = record.function_queries[480].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[480].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => { aiur_fn_480::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 0u64 => { let __v_18: G = G::from_u64(0); let __ret: [G; OUT_207] = [__v_18]; record.function_queries[207].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = __v_18 - __v_19; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_11, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_23: G = __loaded[0]; let __v_24: G = __loaded[1]; let __v_25: G = __loaded[2]; let __v_26: G = __loaded[3]; match __v_23.as_canonical_u64() { 0u64 => { let __v_27: G = G::from_bool(__v_24 == G::ZERO); let __ret: [G; OUT_207] = [__v_27]; record.function_queries[207].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(0); let __ret: [G; OUT_207] = [__v_27]; record.function_queries[207].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_21: G = G::from_u64(0); let __ret: [G; OUT_207] = [__v_21]; record.function_queries[207].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_207] = [__v_16]; record.function_queries[207].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_207] = [__v_10]; record.function_queries[207].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_207] = [__v_6]; record.function_queries[207].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_208: usize = 6; -const IN_208: usize = 6; -const OUT_208: usize = 2; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(2); let __v_7: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_208] = [__v_8, __v_9]; record.function_queries[208].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_208] = [__v_11, __v_12]; record.function_queries[208].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_11: G = __v_2 + __v_3; let __v_12: G = G::from_u64(1); let __v_13: G = __v_11 + __v_12; let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_1, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_0, __v_14]; 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_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(2).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_208] = [__v_16, __v_17]; record.function_queries[208].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_1, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); let __v_18: G = __v_5 + __v_17; let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_16]; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_21, __v_10]; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_23]; 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_24: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_24, __v_19]; 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_25: G = __r_arr[0]; let __ret: [G; OUT_208] = [__v_22, __v_25]; record.function_queries[208].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0, __v_16, __v_10, __v_19]; 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_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __ret: [G; OUT_208] = [__v_22, __v_23]; record.function_queries[208].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_209: usize = 5; -const IN_209: usize = 5; -const OUT_209: usize = 2; -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]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_209] = [__v_8, __v_9]; record.function_queries[209].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_3, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_14]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_15, __v_13]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_209] = [__v_12, __v_16]; record.function_queries[209].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_209] = [__v_12, __v_13]; record.function_queries[209].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, 2u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_209] = [__v_8, __v_9]; record.function_queries[209].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_3, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_11]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_14]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_15]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_16, __v_13]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_209] = [__v_12, __v_17]; record.function_queries[209].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_209] = [__v_12, __v_13]; record.function_queries[209].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_0, __v_1, __v_2, __v_3, __v_5]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_209] = [__v_6, __v_7]; record.function_queries[209].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_210: usize = 5; -const IN_210: usize = 5; -const OUT_210: usize = 2; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(2); let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_210] = [__v_7, __v_8]; record.function_queries[210].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_3, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_10]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_2, __v_12, __v_14]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(2); let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_16, __v_18]; 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_20: G = __r_arr[0]; let __ret: [G; OUT_210] = [__v_19, __v_20]; record.function_queries[210].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_index_mut(2).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_210] = [__v_17, __v_18]; record.function_queries[210].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(2).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_210] = [__v_15, __v_16]; record.function_queries[210].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_10]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_0, __v_1, __v_2, __v_8, __v_14, __v_3]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_210] = [__v_15, __v_16]; record.function_queries[210].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(2).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_210] = [__v_15, __v_16]; record.function_queries[210].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_211: usize = 6; -const IN_211: usize = 6; -const OUT_211: usize = 2; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(2); let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; match __v_2.as_canonical_u64() { 3u64 => { let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0, __v_3, __v_4, __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 __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(2); let __ret: [G; OUT_211] = [__v_10, __v_9]; record.function_queries[211].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_211] = [__v_10, __v_11]; record.function_queries[211].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 6u64 => { let __v_8: G = G::from_u64(1); let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_4]; 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_9: G = __r_arr[0]; let __v_10: G = __v_8 - __v_9; let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_4]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_11]; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __v_8 - __v_13; let __v_15: G = __v_10 * __v_14; match __v_15.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(2).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_211] = [__v_16, __v_17]; record.function_queries[211].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(2); let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_1, __v_3, __v_4, __v_7]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_211] = [__v_16, __v_17]; record.function_queries[211].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 7u64 => { let __v_8: G = G::from_u64(1); let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_4]; 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_9: G = __r_arr[0]; let __v_10: G = __v_8 - __v_9; let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_4]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_11]; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __v_8 - __v_13; let __v_15: G = __v_10 * __v_14; match __v_15.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(2).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_211] = [__v_16, __v_17]; record.function_queries[211].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(2); let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_1, __v_3, __v_4, __v_7]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_211] = [__v_16, __v_17]; record.function_queries[211].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_211] = [__v_8, __v_9]; record.function_queries[211].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_212: usize = 4; -const IN_212: usize = 4; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(2); 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(1).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 = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_4, __v_0, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(3); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_8, __v_1, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_191] = { let __args: [G; IN_191] = [__v_2]; 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_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_201] = { let __args: [G; IN_201] = [__v_12, __v_3]; 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_13: G = __r_arr[0]; let __ret: [G; OUT_212] = [__v_13]; record.function_queries[212].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_213: usize = 10; -const IN_213: usize = 10; -const OUT_213: usize = 8; -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 = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; match __v_9.as_canonical_u64() { 8u64 => { let __ret: [G; OUT_213] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[213].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(1).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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_213] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[213].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(1); let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; let __v_17: G = __r_arr[3]; let __v_18: G = __r_arr[4]; let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; let __ret: [G; OUT_213] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[213].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_13: G = G::from_u64(2); let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; let __v_17: G = __r_arr[3]; let __v_18: G = __r_arr[4]; let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; let __ret: [G; OUT_213] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[213].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_13: G = G::from_u64(3); let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; let __v_17: G = __r_arr[3]; let __v_18: G = __r_arr[4]; let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; let __ret: [G; OUT_213] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[213].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_13: G = G::from_u64(4); let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; let __v_17: G = __r_arr[3]; let __v_18: G = __r_arr[4]; let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; let __ret: [G; OUT_213] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[213].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_13: G = G::from_u64(5); let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; let __v_17: G = __r_arr[3]; let __v_18: G = __r_arr[4]; let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; let __ret: [G; OUT_213] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[213].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_13: G = G::from_u64(6); let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; let __v_17: G = __r_arr[3]; let __v_18: G = __r_arr[4]; let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; let __ret: [G; OUT_213] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[213].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_13: G = G::from_u64(7); let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; let __v_17: G = __r_arr[3]; let __v_18: G = __r_arr[4]; let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; let __ret: [G; OUT_213] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[213].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(8); let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; let __v_17: G = __r_arr[3]; let __v_18: G = __r_arr[4]; let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; let __ret: [G; OUT_213] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; record.function_queries[213].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_214: usize = 2; -const IN_214: usize = 2; -const OUT_214: usize = 1; -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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_214] = [__v_0]; record.function_queries[214].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(1).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(1).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_214] = [__v_6]; record.function_queries[214].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = __v_1 - __v_5; let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_4, __v_6]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_214] = [__v_7]; record.function_queries[214].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_215: usize = 1; -const IN_215: usize = 1; -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 = G::from_u64(0); let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1]; 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_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 = G::from_u64(8); let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_10]; 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_11: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_12.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 10] = [__v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(7).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 }, } }; break '__mc_0 [__v_16]; }, _ => { let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_11]; 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_15: G = __r_arr[0]; break '__mc_0 [__v_15]; }, } }; let __v_15: G = __mc_out___mc_0[0]; let __loaded: [G; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(10))?; 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: 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_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; let __v_19: G = __loaded[3]; let __v_20: G = __loaded[4]; let __v_21: G = __loaded[5]; let __v_22: G = __loaded[6]; let __v_23: G = __loaded[7]; let __v_24: G = __loaded[8]; let __v_25: G = __loaded[9]; match __v_16.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 10] = [__v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27]; let __mq = record.memory_queries.get_index_mut(7).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_215] = [__v_28]; record.function_queries[215].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(1); let __v_29: G = { let __values: [G; 10] = [__v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; let __mq = record.memory_queries.get_index_mut(7).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_30: G = { let __values: [G; 10] = [__v_27, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_29]; let __mq = record.memory_queries.get_index_mut(7).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_215] = [__v_30]; record.function_queries[215].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_26.as_canonical_u64())); }, } }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 10] = [__v_26, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_15]; let __mq = record.memory_queries.get_index_mut(7).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_215] = [__v_27]; record.function_queries[215].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_216: usize = 1; -const IN_216: usize = 1; -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 __loaded: [G; 9] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; 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: 9 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; match __v_1.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_216] = [__v_11]; record.function_queries[216].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(1); let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_2]; 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_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_216] = [__v_13]; record.function_queries[216].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_10: G = G::from_u64(2); let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_2]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_3]; 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_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_216] = [__v_13]; record.function_queries[216].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_10: G = G::from_u64(3); let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_2]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_3]; 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_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_216] = [__v_13]; record.function_queries[216].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_10: G = G::from_u64(4); let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_216] = [__v_13]; record.function_queries[216].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.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; 10] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(7).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 __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_217] = [__v_13]; record.function_queries[217].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_1, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_13]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_11, __v_1]; 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_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_217] = [__v_17]; record.function_queries[217].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_218: usize = 5; -const IN_218: usize = 5; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __loaded: [G; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; let __v_9: G = __loaded[4]; let __v_10: G = __loaded[5]; let __v_11: G = __loaded[6]; let __v_12: G = __loaded[7]; let __v_13: G = __loaded[8]; let __v_14: G = __loaded[9]; let __v_15: G = __loaded[10]; let __v_16: G = __loaded[11]; let __v_17: G = __loaded[12]; let __v_18: G = __loaded[13]; let __v_19: G = __loaded[14]; let __v_20: G = __loaded[15]; let __v_21: G = __loaded[16]; let __v_22: G = __loaded[17]; match __v_5.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_4, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_24]; 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_26: G = __r_arr[0]; let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_index_mut(2).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_218] = [__v_28]; record.function_queries[218].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_23: G = G::from_u64(0); let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_23, __v_24, __v_23, __v_23]; let __mq = record.memory_queries.get_index_mut(2).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_218] = [__v_25]; record.function_queries[218].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_2, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_14, __v_4]; 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_25: G = __r_arr[0]; let __v_26: G = G::from_u64(2); let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_index_mut(2).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_218] = [__v_28]; record.function_queries[218].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_3, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_14, __v_4]; 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_25: G = __r_arr[0]; let __v_26: G = G::from_u64(2); let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_index_mut(2).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_218] = [__v_28]; record.function_queries[218].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_2, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(8); let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_22, __v_1, __v_2, __v_3, __v_4]; 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_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_25, __v_24, __v_26, __v_27]; let __mq = record.memory_queries.get_index_mut(2).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_218] = [__v_28]; record.function_queries[218].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_2, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_24]; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_25]; 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_26: G = G::from_u64(7); let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(0); let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; let __mq = record.memory_queries.get_index_mut(2).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_218] = [__v_29]; record.function_queries[218].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_2, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_24]; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_25]; 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_26: G = __r_arr[0]; let __v_27: G = G::from_u64(7); let __v_28: G = G::from_u64(0); let __v_29: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __v_28]; let __mq = record.memory_queries.get_index_mut(2).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_218] = [__v_29]; record.function_queries[218].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_23: G = G::from_u64(3); let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_6, __v_1, __v_2, __v_3, __v_4]; 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_24: G = __r_arr[0]; let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_index_mut(2).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_218] = [__v_27]; record.function_queries[218].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_23: G = G::from_u64(4); let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_9, __v_1, __v_2, __v_3, __v_4]; 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_24: G = __r_arr[0]; let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_10, __v_1, __v_2, __v_3, __v_4]; 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_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_index_mut(2).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_218] = [__v_27]; record.function_queries[218].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_23: G = G::from_u64(5); let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_11, __v_1, __v_2, __v_3, __v_4]; 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_24: G = __r_arr[0]; let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_12, __v_1, __v_2, __v_3, __v_4]; 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_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_index_mut(2).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_218] = [__v_27]; record.function_queries[218].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __v_23: G = G::from_u64(6); let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_11, __v_1, __v_2, __v_3, __v_4]; 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_24: G = __r_arr[0]; let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_12, __v_1, __v_2, __v_3, __v_4]; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_13, __v_1, __v_2, __v_3, __v_4]; 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_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_index_mut(2).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_218] = [__v_27]; record.function_queries[218].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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 __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_26, __v_1, __v_2, __v_3, __v_4]; 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_28: G = __r_arr[0]; let __ret: [G; OUT_218] = [__v_28]; record.function_queries[218].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_219: usize = 17; -const IN_219: usize = 17; -const OUT_219: usize = 12; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_10, __v_12, __v_13, __v_14, __v_15]; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_11, __v_12, __v_13, __v_14, __v_15]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(0); let __ret: [G; OUT_219] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; record.function_queries[219].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_1.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(1); break '__mc_0 [__v_20]; }, _ => { let __v_20: G = G::from_u64(0); break '__mc_0 [__v_20]; }, } }; let __v_20: G = __mc_out___mc_0[0]; let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(0); let __ret: [G; OUT_219] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22]; record.function_queries[219].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_20: G = G::from_u64(2); let __v_21: G = G::from_u64(0); let __ret: [G; OUT_219] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; record.function_queries[219].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_220: usize = 14; -const IN_220: usize = 14; -const OUT_220: usize = 12; -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 __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_9, __v_10, __v_11, __v_12, __v_13]; 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_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_220] = [__v_15, __v_16, __v_14, __v_0, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; record.function_queries[220].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_221: usize = 14; -const IN_221: usize = 14; -const OUT_221: usize = 12; -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]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_9, __v_10, __v_11, __v_12, __v_13]; 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_14: G = __r_arr[0]; let __v_15: G = G::from_u64(4); let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __ret: [G; OUT_221] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; 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; 36] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(14).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(36))?; 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: 36 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = __loaded[32]; let __v_34: G = __loaded[33]; let __v_35: G = __loaded[34]; let __v_36: G = __loaded[35]; match __v_1.as_canonical_u64() { 1u64 => { let __v_37: G = G::from_u64(0); let __ret: [G; OUT_222] = [__v_37]; record.function_queries[222].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_36]; 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_37: G = __r_arr[0]; let __v_38: G = G::from_u64(1); let __v_39: G = __v_37 + __v_38; let __ret: [G; OUT_222] = [__v_39]; 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 = 2; -const IN_223: usize = 2; -const OUT_223: usize = 34; -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 __v_1: G = inp[1]; let __loaded: [G; 36] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(14).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(36))?; 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: 36 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __v_34: G = __loaded[32]; let __v_35: G = __loaded[33]; let __v_36: G = __loaded[34]; let __v_37: G = __loaded[35]; match __v_2.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_223] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; record.function_queries[223].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(1); let __v_39: G = __v_1 - __v_38; let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_37, __v_39]; 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_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 __v_58: G = __r_arr[18]; let __v_59: G = __r_arr[19]; let __v_60: G = __r_arr[20]; let __v_61: G = __r_arr[21]; let __v_62: G = __r_arr[22]; let __v_63: G = __r_arr[23]; let __v_64: G = __r_arr[24]; let __v_65: G = __r_arr[25]; let __v_66: G = __r_arr[26]; let __v_67: G = __r_arr[27]; let __v_68: G = __r_arr[28]; let __v_69: G = __r_arr[29]; let __v_70: G = __r_arr[30]; let __v_71: G = __r_arr[31]; let __v_72: G = __r_arr[32]; let __v_73: G = __r_arr[33]; let __ret: [G; OUT_223] = [__v_40, __v_41, __v_42, __v_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]; record.function_queries[223].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_224: usize = 33; -const IN_224: usize = 33; -const OUT_224: usize = 12; -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 = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_25, __v_29, __v_30, __v_31, __v_32]; 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_33: G = __r_arr[0]; let __v_34: G = G::from_u64(5); let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_26]; 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_38: G = __r_arr[0]; let __v_39: G = G::from_u64(0); let __ret: [G; OUT_224] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_225: usize = 40; -const IN_225: usize = 40; -const OUT_225: usize = 12; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; let __v_37: G = inp[37]; let __v_38: G = inp[38]; let __v_39: G = inp[39]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_33, __v_36, __v_37, __v_38, __v_39]; 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_40: G = __r_arr[0]; let __v_41: G = G::from_u64(6); let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); let __ret: [G; OUT_225] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46]; record.function_queries[225].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_226: usize = 6; -const IN_226: usize = 6; -const OUT_226: usize = 1; -fn aiur_fn_226(inp: [G; IN_226], 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 = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; let __v_10: G = __loaded[4]; let __v_11: G = __loaded[5]; let __v_12: G = __loaded[6]; let __v_13: G = __loaded[7]; let __v_14: G = __loaded[8]; let __v_15: G = __loaded[9]; let __v_16: G = __loaded[10]; match __v_6.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 5] = [__v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_index_mut(3).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_226] = [__v_18]; record.function_queries[226].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_7.as_canonical_u64() { _ => { let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_15, __v_1, __v_2, __v_3, __v_4]; 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_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__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_5 + __v_20; let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_16, __v_1, __v_2, __v_3, __v_4, __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 __v_23: G = { let __values: [G; 5] = [__v_18, __v_5, __v_19, __v_17, __v_22]; let __mq = record.memory_queries.get_index_mut(3).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_226] = [__v_23]; record.function_queries[226].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } -const INPUT_SIZE_227: usize = 50; -const IN_227: usize = 50; -const OUT_227: usize = 12; -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 = 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]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_42, __v_46, __v_47, __v_48, __v_49]; 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_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; 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_52: G = __r_arr[0]; let __v_53: G = G::from_u64(7); let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __ret: [G; OUT_227] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_228: usize = 1; -const IN_228: usize = 1; -const OUT_228: usize = 48; -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 __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).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_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = G::from_u64(2); let __io_pair: (G, G) = { let __key: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_33, __v_34, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(5, &__args[..])?) { [G::ZERO; OUT_5] } else { let (__hash, __hit) = record.function_queries[5].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[5].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => { aiur_fn_5::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_36, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __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(22, &__args[..])?) { [G::ZERO; OUT_22] } else { let (__hash, __hit) = record.function_queries[22].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[22].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[22].bump_multiplicity(__i); } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => { aiur_fn_22::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_36]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; let __v_40: G = __r_arr[3]; let __v_41: G = __r_arr[4]; let __v_42: G = __r_arr[5]; let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; let __v_45: G = __r_arr[8]; let __v_46: G = __r_arr[9]; let __v_47: G = __r_arr[10]; let __v_48: G = __r_arr[11]; let __v_49: G = __r_arr[12]; let __v_50: G = __r_arr[13]; let __v_51: G = __r_arr[14]; let __v_52: G = __r_arr[15]; let __v_53: G = __r_arr[16]; let __v_54: G = __r_arr[17]; let __v_55: G = __r_arr[18]; let __v_56: G = __r_arr[19]; let __v_57: G = __r_arr[20]; let __v_58: G = __r_arr[21]; let __v_59: G = __r_arr[22]; let __v_60: G = __r_arr[23]; let __v_61: G = __r_arr[24]; let __v_62: G = __r_arr[25]; let __v_63: G = __r_arr[26]; let __v_64: G = __r_arr[27]; let __v_65: G = __r_arr[28]; let __v_66: G = __r_arr[29]; let __v_67: G = __r_arr[30]; let __v_68: G = __r_arr[31]; let __v_69: G = __r_arr[32]; let __v_70: G = __r_arr[33]; let __v_71: G = __r_arr[34]; let __v_72: G = __r_arr[35]; let __v_73: G = __r_arr[36]; let __v_74: G = __r_arr[37]; let __v_75: G = __r_arr[38]; let __v_76: G = __r_arr[39]; let __v_77: G = __r_arr[40]; let __v_78: G = __r_arr[41]; let __v_79: G = __r_arr[42]; let __v_80: G = __r_arr[43]; let __v_81: G = __r_arr[44]; let __v_82: G = __r_arr[45]; let __v_83: G = __r_arr[46]; let __v_84: G = __r_arr[47]; let __v_85: G = __r_arr[48]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_85.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_86: G = __loaded[0]; let __v_87: G = __loaded[1]; let __v_88: G = __loaded[2]; let __v_89: G = G::from_u64(1); if (__v_86 != __v_89) { return Err(ExecError::AssertEqMismatch { lhs: __v_86.as_canonical_u64(), rhs: __v_89.as_canonical_u64(), msg: Some("trailing bytes after constant on ch 2".to_string()) }); } if (__v_87 != __v_89) { return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_89.as_canonical_u64(), msg: Some("trailing bytes after constant on ch 2".to_string()) }); } if (__v_88 != __v_89) { return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_89.as_canonical_u64(), msg: Some("trailing bytes after constant on ch 2".to_string()) }); } let __ret: [G; OUT_228] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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]; record.function_queries[228].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_229: usize = 13; -const IN_229: usize = 13; -const OUT_229: usize = 1; -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]; match __v_1.as_canonical_u64() { _ => { match __v_1.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_0]; let __cu = true; { let (__hash, __hit) = record.function_queries[230].lookup(&__args[..]); match __hit { Some(__i) if true => { 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_13: G = __r_arr[0]; let __ret: [G; OUT_229] = [__v_13]; record.function_queries[229].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_229] = [__v_13]; record.function_queries[229].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_230: usize = 1; -const IN_230: usize = 1; -const OUT_230: usize = 1; -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 __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).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_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = G::from_u64(3); let __io_pair: (G, G) = { let __key: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_33, __v_34, __v_35]; let __cu = true; { let (__hash, __hit) = record.function_queries[4].lookup(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => { aiur_fn_4::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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 __ret: [G; OUT_230] = [__v_38]; record.function_queries[230].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_37.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; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).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_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = G::from_u64(4); let __io_pair: (G, G) = { let __key: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_33, __v_34, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(5, &__args[..])?) { [G::ZERO; OUT_5] } else { let (__hash, __hit) = record.function_queries[5].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[5].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => { aiur_fn_5::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_36, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __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(22, &__args[..])?) { [G::ZERO; OUT_22] } else { let (__hash, __hit) = record.function_queries[22].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[22].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[22].bump_multiplicity(__i); } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => { aiur_fn_22::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_231] = [__v_36]; record.function_queries[231].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_232: usize = 2; -const IN_232: usize = 2; -const OUT_232: usize = 1; -fn aiur_fn_232(inp: [G; IN_232], 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]; match __v_0.as_canonical_u64() { 2u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_232] = [__v_2]; record.function_queries[232].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_232] = [__v_2]; record.function_queries[232].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_232] = [__v_2]; record.function_queries[232].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 0u64 => { match __v_1.as_canonical_u64() { 1u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_232] = [__v_2]; record.function_queries[232].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_232] = [__v_2]; record.function_queries[232].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_233: usize = 14; -const IN_233: usize = 14; -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]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_1]; 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_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_233] = [__v_16]; record.function_queries[233].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_12, __v_13]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_233] = [__v_15]; 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 = 1; -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_228] = { let __args: [G; IN_228] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __v_11: G = __r_arr[10]; let __v_12: G = __r_arr[11]; let __v_13: G = __r_arr[12]; let __v_14: G = __r_arr[13]; let __v_15: G = __r_arr[14]; let __v_16: G = __r_arr[15]; let __v_17: G = __r_arr[16]; let __v_18: G = __r_arr[17]; let __v_19: G = __r_arr[18]; let __v_20: G = __r_arr[19]; let __v_21: G = __r_arr[20]; let __v_22: G = __r_arr[21]; let __v_23: G = __r_arr[22]; let __v_24: G = __r_arr[23]; let __v_25: G = __r_arr[24]; let __v_26: G = __r_arr[25]; let __v_27: G = __r_arr[26]; let __v_28: G = __r_arr[27]; let __v_29: G = __r_arr[28]; let __v_30: G = __r_arr[29]; let __v_31: G = __r_arr[30]; let __v_32: G = __r_arr[31]; let __v_33: G = __r_arr[32]; let __v_34: G = __r_arr[33]; let __v_35: G = __r_arr[34]; let __v_36: G = __r_arr[35]; let __v_37: G = __r_arr[36]; let __v_38: G = __r_arr[37]; let __v_39: G = __r_arr[38]; let __v_40: G = __r_arr[39]; let __v_41: G = __r_arr[40]; let __v_42: G = __r_arr[41]; let __v_43: G = __r_arr[42]; let __v_44: G = __r_arr[43]; let __v_45: G = __r_arr[44]; let __v_46: G = __r_arr[45]; let __v_47: G = __r_arr[46]; let __v_48: G = __r_arr[47]; match __v_1.as_canonical_u64() { _ => { match __v_1.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_49: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_2, __v_3]; 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_50: G = __r_arr[0]; match __v_50.as_canonical_u64() { 0u64 => { 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(1).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_52]; }, _ => { let __v_51: G = G::from_u64(0); let __v_52: G = G::from_u64(1); let __v_53: G = { let __values: [G; 3] = [__v_52, __v_52, __v_52]; let __mq = record.memory_queries.get_index_mut(1).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_54: G = { let __values: [G; 3] = [__v_51, __v_0, __v_53]; let __mq = record.memory_queries.get_index_mut(1).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_54]; }, } }, } }; let __v_50: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_46, __v_47, __v_50, __v_48, __v_49]; let __cu = unconstrained; if ((!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_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 __v_61: G = __r_arr[10]; let __v_62: G = __r_arr[11]; let __v_63: G = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 12)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_234] = [__v_63]; record.function_queries[234].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = { let __values: [G; 3] = [__v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_index_mut(1).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_220] = { let __args: [G; IN_220] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_50, __v_48]; 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_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 __v_61: G = __r_arr[10]; let __v_62: G = __r_arr[11]; let __v_63: G = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 12)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_234] = [__v_63]; record.function_queries[234].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = { let __values: [G; 3] = [__v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_index_mut(1).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_221] = { let __args: [G; IN_221] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_50, __v_48]; 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_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 __v_61: G = __r_arr[10]; let __v_62: G = __r_arr[11]; let __v_63: G = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 12)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_234] = [__v_63]; record.function_queries[234].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; 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_49: G = __r_arr[0]; let __ret: [G; OUT_234] = [__v_49]; record.function_queries[234].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 6u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_10, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(236, &__args[..])?) { [G::ZERO; OUT_236] } else { let (__hash, __hit) = record.function_queries[236].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[236].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[236].bump_multiplicity(__i); } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => { aiur_fn_236::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_234] = [__v_50]; record.function_queries[234].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 4u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_18, __v_49, __v_50]; 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_51: G = __r_arr[0]; let __ret: [G; OUT_234] = [__v_51]; record.function_queries[234].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 5u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_10, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(238, &__args[..])?) { [G::ZERO; OUT_238] } else { let (__hash, __hit) = record.function_queries[238].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[238].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => { aiur_fn_238::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_234] = [__v_50]; record.function_queries[234].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 1u64 => { let __v_49: G = G::from_u64(0); let __v_50: G = G::from_u64(1); let __v_51: G = { let __values: [G; 3] = [__v_50, __v_50, __v_50]; let __mq = record.memory_queries.get_index_mut(1).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_52: G = { let __values: [G; 3] = [__v_49, __v_0, __v_51]; let __mq = record.memory_queries.get_index_mut(1).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_227] = { let __args: [G; IN_227] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_49, __v_46, __v_47, __v_52, __v_48]; 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_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 = { let __values: [G; 12] = [__v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 12)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_234] = [__v_65]; record.function_queries[234].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_235: usize = 10; -const IN_235: usize = 10; -const OUT_235: usize = 1; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_228] = { let __args: [G; IN_228] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __v_19: G = __r_arr[9]; let __v_20: G = __r_arr[10]; let __v_21: G = __r_arr[11]; let __v_22: G = __r_arr[12]; let __v_23: G = __r_arr[13]; let __v_24: G = __r_arr[14]; let __v_25: G = __r_arr[15]; let __v_26: G = __r_arr[16]; let __v_27: G = __r_arr[17]; let __v_28: G = __r_arr[18]; let __v_29: G = __r_arr[19]; let __v_30: G = __r_arr[20]; let __v_31: G = __r_arr[21]; let __v_32: G = __r_arr[22]; let __v_33: G = __r_arr[23]; let __v_34: G = __r_arr[24]; let __v_35: G = __r_arr[25]; let __v_36: G = __r_arr[26]; let __v_37: G = __r_arr[27]; let __v_38: G = __r_arr[28]; let __v_39: G = __r_arr[29]; let __v_40: G = __r_arr[30]; let __v_41: G = __r_arr[31]; let __v_42: G = __r_arr[32]; let __v_43: G = __r_arr[33]; let __v_44: G = __r_arr[34]; let __v_45: G = __r_arr[35]; let __v_46: G = __r_arr[36]; let __v_47: G = __r_arr[37]; let __v_48: G = __r_arr[38]; let __v_49: G = __r_arr[39]; let __v_50: G = __r_arr[40]; let __v_51: G = __r_arr[41]; let __v_52: G = __r_arr[42]; let __v_53: G = __r_arr[43]; let __v_54: G = __r_arr[44]; let __v_55: G = __r_arr[45]; let __v_56: G = __r_arr[46]; let __v_57: G = __r_arr[47]; match __v_10.as_canonical_u64() { _ => { match __v_10.as_canonical_u64() { 8u64 => { let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(769, &__args[..])?) { [G::ZERO; OUT_769] } else { let (__hash, __hit) = record.function_queries[769].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[769].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[769].bump_multiplicity(__i); } let __ret: [G; OUT_769] = unsafe { *(record.function_queries[769].output_at(__i).as_ptr() as *const [G; OUT_769]) }; __ret }, _ => { aiur_fn_769::(__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 = __r_arr[4]; let __v_63: G = __r_arr[5]; let __v_64: G = __r_arr[6]; let __v_65: G = __r_arr[7]; let __v_66: G = __r_arr[8]; let __v_67: G = __r_arr[9]; let __v_68: G = __r_arr[10]; let __v_69: G = __r_arr[11]; let __v_70: G = __r_arr[12]; let __v_71: G = __r_arr[13]; let __v_72: G = __r_arr[14]; let __v_73: G = __r_arr[15]; let __v_74: G = __r_arr[16]; let __v_75: G = __r_arr[17]; let __v_76: G = __r_arr[18]; let __v_77: G = __r_arr[19]; let __v_78: G = __r_arr[20]; let __v_79: G = __r_arr[21]; let __v_80: G = __r_arr[22]; let __v_81: G = __r_arr[23]; let __v_82: G = __r_arr[24]; let __v_83: G = __r_arr[25]; let __v_84: G = __r_arr[26]; let __v_85: G = __r_arr[27]; let __v_86: G = __r_arr[28]; let __v_87: G = __r_arr[29]; let __v_88: G = __r_arr[30]; let __v_89: G = __r_arr[31]; let __v_90: G = __r_arr[32]; let __v_91: G = __r_arr[33]; let __v_92: G = __r_arr[34]; let __v_93: G = __r_arr[35]; let __v_94: G = __r_arr[36]; let __v_95: G = __r_arr[37]; let __v_96: G = __r_arr[38]; let __v_97: G = __r_arr[39]; let __v_98: G = __r_arr[40]; let __v_99: G = __r_arr[41]; let __v_100: G = __r_arr[42]; let __v_101: G = __r_arr[43]; let __v_102: G = __r_arr[44]; match __v_58.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70]; let __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_103: G = __r_arr[0]; let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_11, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(233, &__args[..])?) { [G::ZERO; OUT_233] } else { let (__hash, __hit) = record.function_queries[233].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[233].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => { aiur_fn_233::(__args, __hash, record, io_buffer)? }, } } }; let __v_104: G = __r_arr[0]; let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_55, __v_56, __v_104, __v_57, __v_103]; let __cu = unconstrained; if ((!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_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 = { let __values: [G; 12] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 12)?; let __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_117]; record.function_queries[235].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_236: usize = 2; -const IN_236: usize = 2; -const OUT_236: usize = 1; -fn aiur_fn_236(inp: [G; IN_236], 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 __v_1: G = inp[1]; let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = __r_arr[10]; let __v_13: G = __r_arr[11]; let __v_14: G = __r_arr[12]; let __v_15: G = __r_arr[13]; let __v_16: G = __r_arr[14]; let __v_17: G = __r_arr[15]; let __v_18: G = __r_arr[16]; let __v_19: G = __r_arr[17]; let __v_20: G = __r_arr[18]; let __v_21: G = __r_arr[19]; let __v_22: G = __r_arr[20]; let __v_23: G = __r_arr[21]; let __v_24: G = __r_arr[22]; let __v_25: G = __r_arr[23]; let __v_26: G = __r_arr[24]; let __v_27: G = __r_arr[25]; let __v_28: G = __r_arr[26]; let __v_29: G = __r_arr[27]; let __v_30: G = __r_arr[28]; let __v_31: G = __r_arr[29]; let __v_32: G = __r_arr[30]; let __v_33: G = __r_arr[31]; let __v_34: G = __r_arr[32]; let __v_35: G = __r_arr[33]; let __v_36: G = __r_arr[34]; let __v_37: G = __r_arr[35]; let __v_38: G = __r_arr[36]; let __v_39: G = __r_arr[37]; let __v_40: G = __r_arr[38]; let __v_41: G = __r_arr[39]; let __v_42: G = __r_arr[40]; let __v_43: G = __r_arr[41]; let __v_44: G = __r_arr[42]; let __v_45: G = __r_arr[43]; let __v_46: G = __r_arr[44]; let __v_47: G = __r_arr[45]; let __v_48: G = __r_arr[46]; let __v_49: G = __r_arr[47]; match __v_2.as_canonical_u64() { _ => { match __v_2.as_canonical_u64() { 8u64 => { 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_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 __v_61: G = __r_arr[11]; let __v_62: G = __r_arr[12]; let __v_63: G = __r_arr[13]; let __v_64: G = __r_arr[14]; let __v_65: G = __r_arr[15]; let __v_66: G = __r_arr[16]; let __v_67: G = __r_arr[17]; let __v_68: G = __r_arr[18]; let __v_69: G = __r_arr[19]; let __v_70: G = __r_arr[20]; let __v_71: G = __r_arr[21]; let __v_72: G = __r_arr[22]; let __v_73: G = __r_arr[23]; let __v_74: G = __r_arr[24]; let __v_75: G = __r_arr[25]; let __v_76: G = __r_arr[26]; let __v_77: G = __r_arr[27]; let __v_78: G = __r_arr[28]; let __v_79: G = __r_arr[29]; let __v_80: G = __r_arr[30]; let __v_81: G = __r_arr[31]; let __v_82: G = __r_arr[32]; let __v_83: G = __r_arr[33]; let __v_84: G = __r_arr[34]; let __v_85: G = __r_arr[35]; let __v_86: G = __r_arr[36]; let __v_87: G = __r_arr[37]; let __v_88: G = __r_arr[38]; let __v_89: G = __r_arr[39]; let __v_90: G = __r_arr[40]; let __v_91: G = __r_arr[41]; let __v_92: G = __r_arr[42]; let __v_93: G = __r_arr[43]; let __v_94: G = __r_arr[44]; match __v_50.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_3, __v_0]; 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_95: G = __r_arr[0]; let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if ((!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_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; let __v_99: G = __r_arr[3]; let __v_100: G = __r_arr[4]; let __v_101: G = __r_arr[5]; let __v_102: G = __r_arr[6]; let __v_103: G = __r_arr[7]; let __v_104: G = __r_arr[8]; let __v_105: G = __r_arr[9]; let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 12)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_236] = [__v_108]; record.function_queries[236].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_50.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_237: usize = 3; -const IN_237: usize = 3; -const OUT_237: usize = 1; -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]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __v_12: G = __r_arr[9]; let __v_13: G = __r_arr[10]; let __v_14: G = __r_arr[11]; let __v_15: G = __r_arr[12]; let __v_16: G = __r_arr[13]; let __v_17: G = __r_arr[14]; let __v_18: G = __r_arr[15]; let __v_19: G = __r_arr[16]; let __v_20: G = __r_arr[17]; let __v_21: G = __r_arr[18]; let __v_22: G = __r_arr[19]; let __v_23: G = __r_arr[20]; let __v_24: G = __r_arr[21]; let __v_25: G = __r_arr[22]; let __v_26: G = __r_arr[23]; let __v_27: G = __r_arr[24]; let __v_28: G = __r_arr[25]; let __v_29: G = __r_arr[26]; let __v_30: G = __r_arr[27]; let __v_31: G = __r_arr[28]; let __v_32: G = __r_arr[29]; let __v_33: G = __r_arr[30]; let __v_34: G = __r_arr[31]; let __v_35: G = __r_arr[32]; let __v_36: G = __r_arr[33]; let __v_37: G = __r_arr[34]; let __v_38: G = __r_arr[35]; let __v_39: G = __r_arr[36]; let __v_40: G = __r_arr[37]; let __v_41: G = __r_arr[38]; let __v_42: G = __r_arr[39]; let __v_43: G = __r_arr[40]; let __v_44: G = __r_arr[41]; let __v_45: G = __r_arr[42]; let __v_46: G = __r_arr[43]; let __v_47: G = __r_arr[44]; let __v_48: G = __r_arr[45]; let __v_49: G = __r_arr[46]; let __v_50: G = __r_arr[47]; match __v_3.as_canonical_u64() { _ => { match __v_3.as_canonical_u64() { 8u64 => { 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_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 __v_61: G = __r_arr[10]; let __v_62: G = __r_arr[11]; let __v_63: G = __r_arr[12]; let __v_64: G = __r_arr[13]; let __v_65: G = __r_arr[14]; let __v_66: G = __r_arr[15]; let __v_67: G = __r_arr[16]; let __v_68: G = __r_arr[17]; let __v_69: G = __r_arr[18]; let __v_70: G = __r_arr[19]; let __v_71: G = __r_arr[20]; let __v_72: G = __r_arr[21]; let __v_73: G = __r_arr[22]; let __v_74: G = __r_arr[23]; let __v_75: G = __r_arr[24]; let __v_76: G = __r_arr[25]; let __v_77: G = __r_arr[26]; let __v_78: G = __r_arr[27]; let __v_79: G = __r_arr[28]; let __v_80: G = __r_arr[29]; let __v_81: G = __r_arr[30]; let __v_82: G = __r_arr[31]; let __v_83: G = __r_arr[32]; let __v_84: G = __r_arr[33]; let __v_85: G = __r_arr[34]; let __v_86: G = __r_arr[35]; let __v_87: G = __r_arr[36]; let __v_88: G = __r_arr[37]; let __v_89: G = __r_arr[38]; let __v_90: G = __r_arr[39]; let __v_91: G = __r_arr[40]; let __v_92: G = __r_arr[41]; let __v_93: G = __r_arr[42]; let __v_94: G = __r_arr[43]; let __v_95: G = __r_arr[44]; match __v_51.as_canonical_u64() { 1u64 => { match __v_52.as_canonical_u64() { _ => { let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_78, __v_2]; 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_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; let __v_99: G = __r_arr[3]; let __v_100: G = __r_arr[4]; let __v_101: G = __r_arr[5]; let __v_102: G = __r_arr[6]; let __v_103: G = __r_arr[7]; let __v_104: G = __r_arr[8]; let __v_105: G = __r_arr[9]; let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; let __v_108: G = __r_arr[12]; let __v_109: G = __r_arr[13]; let __v_110: G = __r_arr[14]; let __v_111: G = __r_arr[15]; let __v_112: G = __r_arr[16]; let __v_113: G = __r_arr[17]; let __v_114: G = __r_arr[18]; let __v_115: G = __r_arr[19]; let __v_116: G = __r_arr[20]; let __v_117: G = __r_arr[21]; let __v_118: G = __r_arr[22]; let __v_119: G = __r_arr[23]; let __v_120: G = __r_arr[24]; let __v_121: G = __r_arr[25]; let __v_122: G = __r_arr[26]; let __v_123: G = __r_arr[27]; let __v_124: G = __r_arr[28]; let __v_125: G = __r_arr[29]; let __v_126: G = __r_arr[30]; let __v_127: G = __r_arr[31]; let __v_128: G = __r_arr[32]; let __v_129: G = __r_arr[33]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_4, __v_0]; 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_130: G = __r_arr[0]; let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_0, __v_1, __v_48, __v_49, __v_130, __v_50]; let __cu = unconstrained; if ((!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_131: G = __r_arr[0]; let __v_132: G = __r_arr[1]; let __v_133: G = __r_arr[2]; let __v_134: G = __r_arr[3]; let __v_135: G = __r_arr[4]; let __v_136: G = __r_arr[5]; let __v_137: G = __r_arr[6]; let __v_138: G = __r_arr[7]; let __v_139: G = __r_arr[8]; let __v_140: G = __r_arr[9]; let __v_141: G = __r_arr[10]; let __v_142: G = __r_arr[11]; let __v_143: G = { let __values: [G; 12] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 12)?; let __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_143]; record.function_queries[237].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_51.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_238: usize = 2; -const IN_238: usize = 2; -const OUT_238: usize = 1; -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 __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = __r_arr[10]; let __v_13: G = __r_arr[11]; let __v_14: G = __r_arr[12]; let __v_15: G = __r_arr[13]; let __v_16: G = __r_arr[14]; let __v_17: G = __r_arr[15]; let __v_18: G = __r_arr[16]; let __v_19: G = __r_arr[17]; let __v_20: G = __r_arr[18]; let __v_21: G = __r_arr[19]; let __v_22: G = __r_arr[20]; let __v_23: G = __r_arr[21]; let __v_24: G = __r_arr[22]; let __v_25: G = __r_arr[23]; let __v_26: G = __r_arr[24]; let __v_27: G = __r_arr[25]; let __v_28: G = __r_arr[26]; let __v_29: G = __r_arr[27]; let __v_30: G = __r_arr[28]; let __v_31: G = __r_arr[29]; let __v_32: G = __r_arr[30]; let __v_33: G = __r_arr[31]; let __v_34: G = __r_arr[32]; let __v_35: G = __r_arr[33]; let __v_36: G = __r_arr[34]; let __v_37: G = __r_arr[35]; let __v_38: G = __r_arr[36]; let __v_39: G = __r_arr[37]; let __v_40: G = __r_arr[38]; let __v_41: G = __r_arr[39]; let __v_42: G = __r_arr[40]; let __v_43: G = __r_arr[41]; let __v_44: G = __r_arr[42]; let __v_45: G = __r_arr[43]; let __v_46: G = __r_arr[44]; let __v_47: G = __r_arr[45]; let __v_48: G = __r_arr[46]; let __v_49: G = __r_arr[47]; match __v_2.as_canonical_u64() { _ => { match __v_2.as_canonical_u64() { 8u64 => { 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_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 __v_61: G = __r_arr[11]; let __v_62: G = __r_arr[12]; let __v_63: G = __r_arr[13]; let __v_64: G = __r_arr[14]; let __v_65: G = __r_arr[15]; let __v_66: G = __r_arr[16]; let __v_67: G = __r_arr[17]; let __v_68: G = __r_arr[18]; let __v_69: G = __r_arr[19]; let __v_70: G = __r_arr[20]; let __v_71: G = __r_arr[21]; let __v_72: G = __r_arr[22]; let __v_73: G = __r_arr[23]; let __v_74: G = __r_arr[24]; let __v_75: G = __r_arr[25]; let __v_76: G = __r_arr[26]; let __v_77: G = __r_arr[27]; let __v_78: G = __r_arr[28]; let __v_79: G = __r_arr[29]; let __v_80: G = __r_arr[30]; let __v_81: G = __r_arr[31]; let __v_82: G = __r_arr[32]; let __v_83: G = __r_arr[33]; let __v_84: G = __r_arr[34]; let __v_85: G = __r_arr[35]; let __v_86: G = __r_arr[36]; let __v_87: G = __r_arr[37]; let __v_88: G = __r_arr[38]; let __v_89: G = __r_arr[39]; let __v_90: G = __r_arr[40]; let __v_91: G = __r_arr[41]; let __v_92: G = __r_arr[42]; let __v_93: G = __r_arr[43]; let __v_94: G = __r_arr[44]; match __v_50.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_3, __v_0]; 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_95: G = __r_arr[0]; let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if ((!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_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; let __v_99: G = __r_arr[3]; let __v_100: G = __r_arr[4]; let __v_101: G = __r_arr[5]; let __v_102: G = __r_arr[6]; let __v_103: G = __r_arr[7]; let __v_104: G = __r_arr[8]; let __v_105: G = __r_arr[9]; let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 12)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_238] = [__v_108]; record.function_queries[238].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_50.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_239: usize = 2; -const IN_239: usize = 2; -const OUT_239: usize = 45; -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 __loaded: [G; 47] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(15).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __v_34: G = __loaded[32]; let __v_35: G = __loaded[33]; let __v_36: G = __loaded[34]; let __v_37: G = __loaded[35]; let __v_38: G = __loaded[36]; let __v_39: G = __loaded[37]; let __v_40: G = __loaded[38]; let __v_41: G = __loaded[39]; let __v_42: G = __loaded[40]; let __v_43: G = __loaded[41]; let __v_44: G = __loaded[42]; let __v_45: G = __loaded[43]; let __v_46: G = __loaded[44]; let __v_47: G = __loaded[45]; let __v_48: G = __loaded[46]; match __v_2.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_239] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; record.function_queries[239].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(1); let __v_50: G = __v_1 - __v_49; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_48, __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]; 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 __v_61: G = __r_arr[10]; let __v_62: G = __r_arr[11]; let __v_63: G = __r_arr[12]; let __v_64: G = __r_arr[13]; let __v_65: G = __r_arr[14]; let __v_66: G = __r_arr[15]; let __v_67: G = __r_arr[16]; let __v_68: G = __r_arr[17]; let __v_69: G = __r_arr[18]; let __v_70: G = __r_arr[19]; let __v_71: G = __r_arr[20]; let __v_72: G = __r_arr[21]; let __v_73: G = __r_arr[22]; let __v_74: G = __r_arr[23]; let __v_75: G = __r_arr[24]; let __v_76: G = __r_arr[25]; let __v_77: G = __r_arr[26]; let __v_78: G = __r_arr[27]; let __v_79: G = __r_arr[28]; let __v_80: G = __r_arr[29]; let __v_81: G = __r_arr[30]; let __v_82: G = __r_arr[31]; let __v_83: G = __r_arr[32]; let __v_84: G = __r_arr[33]; let __v_85: G = __r_arr[34]; let __v_86: G = __r_arr[35]; let __v_87: G = __r_arr[36]; let __v_88: G = __r_arr[37]; let __v_89: G = __r_arr[38]; let __v_90: G = __r_arr[39]; let __v_91: G = __r_arr[40]; let __v_92: G = __r_arr[41]; let __v_93: G = __r_arr[42]; let __v_94: G = __r_arr[43]; let __v_95: G = __r_arr[44]; let __ret: [G; OUT_239] = [__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]; record.function_queries[239].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_240: usize = 1; -const IN_240: usize = 1; -const OUT_240: usize = 8; -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 __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 __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; if (__v_9 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("projection index bytes do not recompose to the index".to_string()) }); } let __ret: [G; OUT_240] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[240].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_241: usize = 3; -const IN_241: usize = 3; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __v_12: G = __r_arr[9]; let __v_13: G = __r_arr[10]; let __v_14: G = __r_arr[11]; let __v_15: G = __r_arr[12]; let __v_16: G = __r_arr[13]; let __v_17: G = __r_arr[14]; let __v_18: G = __r_arr[15]; let __v_19: G = __r_arr[16]; let __v_20: G = __r_arr[17]; let __v_21: G = __r_arr[18]; let __v_22: G = __r_arr[19]; let __v_23: G = __r_arr[20]; let __v_24: G = __r_arr[21]; let __v_25: G = __r_arr[22]; let __v_26: G = __r_arr[23]; let __v_27: G = __r_arr[24]; let __v_28: G = __r_arr[25]; let __v_29: G = __r_arr[26]; let __v_30: G = __r_arr[27]; let __v_31: G = __r_arr[28]; let __v_32: G = __r_arr[29]; let __v_33: G = __r_arr[30]; let __v_34: G = __r_arr[31]; let __v_35: G = __r_arr[32]; let __v_36: G = __r_arr[33]; let __v_37: G = __r_arr[34]; let __v_38: G = __r_arr[35]; let __v_39: G = __r_arr[36]; let __v_40: G = __r_arr[37]; let __v_41: G = __r_arr[38]; let __v_42: G = __r_arr[39]; let __v_43: G = __r_arr[40]; let __v_44: G = __r_arr[41]; let __v_45: G = __r_arr[42]; let __v_46: G = __r_arr[43]; let __v_47: G = __r_arr[44]; let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_2]; 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_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; let __v_51: G = __r_arr[3]; let __v_52: G = __r_arr[4]; let __v_53: G = __r_arr[5]; let __v_54: G = __r_arr[6]; let __v_55: G = __r_arr[7]; let __mc_out___mc_0: [G; 45] = '__mc_0: { match __v_3.as_canonical_u64() { 0u64 => { let __v_56: G = G::from_u64(7); let __v_57: G = G::from_u64(0); break '__mc_0 [__v_56, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_1, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57]; }, 1u64 => { let __v_56: G = G::from_u64(6); let __v_57: G = G::from_u64(0); break '__mc_0 [__v_56, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_1, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57]; }, 2u64 => { let __v_56: G = G::from_u64(5); let __v_57: G = G::from_u64(0); break '__mc_0 [__v_56, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_1, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57]; }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }; let __v_56: G = __mc_out___mc_0[0]; let __v_57: G = __mc_out___mc_0[1]; let __v_58: G = __mc_out___mc_0[2]; let __v_59: G = __mc_out___mc_0[3]; let __v_60: G = __mc_out___mc_0[4]; let __v_61: G = __mc_out___mc_0[5]; let __v_62: G = __mc_out___mc_0[6]; let __v_63: G = __mc_out___mc_0[7]; let __v_64: G = __mc_out___mc_0[8]; let __v_65: G = __mc_out___mc_0[9]; let __v_66: G = __mc_out___mc_0[10]; let __v_67: G = __mc_out___mc_0[11]; let __v_68: G = __mc_out___mc_0[12]; let __v_69: G = __mc_out___mc_0[13]; let __v_70: G = __mc_out___mc_0[14]; let __v_71: G = __mc_out___mc_0[15]; let __v_72: G = __mc_out___mc_0[16]; let __v_73: G = __mc_out___mc_0[17]; let __v_74: G = __mc_out___mc_0[18]; let __v_75: G = __mc_out___mc_0[19]; let __v_76: G = __mc_out___mc_0[20]; let __v_77: G = __mc_out___mc_0[21]; let __v_78: G = __mc_out___mc_0[22]; let __v_79: G = __mc_out___mc_0[23]; let __v_80: G = __mc_out___mc_0[24]; let __v_81: G = __mc_out___mc_0[25]; let __v_82: G = __mc_out___mc_0[26]; let __v_83: G = __mc_out___mc_0[27]; let __v_84: G = __mc_out___mc_0[28]; let __v_85: G = __mc_out___mc_0[29]; let __v_86: G = __mc_out___mc_0[30]; let __v_87: G = __mc_out___mc_0[31]; let __v_88: G = __mc_out___mc_0[32]; let __v_89: G = __mc_out___mc_0[33]; let __v_90: G = __mc_out___mc_0[34]; let __v_91: G = __mc_out___mc_0[35]; let __v_92: G = __mc_out___mc_0[36]; let __v_93: G = __mc_out___mc_0[37]; let __v_94: G = __mc_out___mc_0[38]; let __v_95: G = __mc_out___mc_0[39]; let __v_96: G = __mc_out___mc_0[40]; let __v_97: G = __mc_out___mc_0[41]; let __v_98: G = __mc_out___mc_0[42]; let __v_99: G = __mc_out___mc_0[43]; let __v_100: G = __mc_out___mc_0[44]; let __v_101: G = G::from_u64(1); let __v_102: G = { let __values: [G; 3] = [__v_101, __v_101, __v_101]; let __mq = record.memory_queries.get_index_mut(1).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_82] = { let __args: [G; IN_82] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_102, __v_102, __v_102, __v_102]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(82, &__args[..])?) { [G::ZERO; OUT_82] } else { let (__hash, __hit) = record.function_queries[82].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[82].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => { aiur_fn_82::(__args, __hash, record, io_buffer)? }, } } }; let __v_103: G = __r_arr[0]; let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_103]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(23, &__args[..])?) { [G::ZERO; OUT_23] } else { let (__hash, __hit) = record.function_queries[23].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[23].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[23].bump_multiplicity(__i); } let __ret: [G; OUT_23] = unsafe { *(record.function_queries[23].output_at(__i).as_ptr() as *const [G; OUT_23]) }; __ret }, _ => { aiur_fn_23::(__args, __hash, record, io_buffer)? }, } } }; let __v_104: G = __r_arr[0]; let __ret: [G; OUT_241] = [__v_104]; record.function_queries[241].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_242: usize = 2; -const IN_242: usize = 2; -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 __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_1, __v_0, __v_2]; 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_3: G = __r_arr[0]; let __ret: [G; OUT_242] = [__v_3]; record.function_queries[242].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_243: usize = 4; -const IN_243: usize = 4; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __loaded: [G; 47] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(15).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; let __v_8: G = __loaded[4]; let __v_9: G = __loaded[5]; let __v_10: G = __loaded[6]; let __v_11: G = __loaded[7]; let __v_12: G = __loaded[8]; let __v_13: G = __loaded[9]; let __v_14: G = __loaded[10]; let __v_15: G = __loaded[11]; let __v_16: G = __loaded[12]; let __v_17: G = __loaded[13]; let __v_18: G = __loaded[14]; let __v_19: G = __loaded[15]; let __v_20: G = __loaded[16]; let __v_21: G = __loaded[17]; let __v_22: G = __loaded[18]; let __v_23: G = __loaded[19]; let __v_24: G = __loaded[20]; let __v_25: G = __loaded[21]; let __v_26: G = __loaded[22]; let __v_27: G = __loaded[23]; let __v_28: G = __loaded[24]; let __v_29: G = __loaded[25]; let __v_30: G = __loaded[26]; let __v_31: G = __loaded[27]; let __v_32: G = __loaded[28]; let __v_33: G = __loaded[29]; let __v_34: G = __loaded[30]; let __v_35: G = __loaded[31]; let __v_36: G = __loaded[32]; let __v_37: G = __loaded[33]; let __v_38: G = __loaded[34]; let __v_39: G = __loaded[35]; let __v_40: G = __loaded[36]; let __v_41: G = __loaded[37]; let __v_42: G = __loaded[38]; let __v_43: G = __loaded[39]; let __v_44: G = __loaded[40]; let __v_45: G = __loaded[41]; let __v_46: G = __loaded[42]; let __v_47: G = __loaded[43]; let __v_48: G = __loaded[44]; let __v_49: G = __loaded[45]; let __v_50: G = __loaded[46]; match __v_4.as_canonical_u64() { 1u64 => { let __v_51: G = G::from_u64(1); let __v_52: G = { let __values: [G; 3] = [__v_51, __v_51, __v_51]; let __mq = record.memory_queries.get_index_mut(1).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_52]; record.function_queries[243].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_51: G = G::from_u64(0); let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_0, __v_1, __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_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __v_54: G = __v_3 + __v_53; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_1, __v_50, __v_54]; 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_55: G = __r_arr[0]; let __v_56: G = { let __values: [G; 3] = [__v_51, __v_52, __v_55]; let __mq = record.memory_queries.get_index_mut(1).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_56]; record.function_queries[243].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.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; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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 __v_4: G = G::from_u64(0); let __ret: [G; OUT_244] = [__v_4]; record.function_queries[244].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_244] = [__v_4]; record.function_queries[244].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_244] = [__v_4]; record.function_queries[244].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_3]; 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_5: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_244] = [__v_6]; record.function_queries[244].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_244] = [__v_6]; record.function_queries[244].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_244] = [__v_6]; record.function_queries[244].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 3u64 => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_3]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_244] = [__v_4]; 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 = 2; -const IN_245: usize = 2; -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 __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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 __v_8: G = G::from_u64(1); let __ret: [G; OUT_245] = [__v_8]; record.function_queries[245].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { 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); }, } }, 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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() { 1u64 => { let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_3, __v_6]; 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 __ret: [G; OUT_245] = [__v_8]; record.function_queries[245].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { 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); }, } }, 2u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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() { 2u64 => { let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_3, __v_6]; 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 __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_4, __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_9: G = __r_arr[0]; 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); }, _ => { 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); }, } }, 3u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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() { 3u64 => { let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_3, __v_6]; 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 __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_4, __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_9: G = __r_arr[0]; 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); }, _ => { 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); }, } }, 4u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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() { 4u64 => { let __v_8: G = __v_3 - __v_6; let __v_9: G = G::from_bool(__v_8 == G::ZERO); let __ret: [G; OUT_245] = [__v_9]; record.function_queries[245].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { 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); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_246: usize = 2; -const IN_246: usize = 2; -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 __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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(1).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() { 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_246] = [__v_8]; record.function_queries[246].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_246] = [__v_8]; record.function_queries[246].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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() { 1u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_246] = [__v_8]; record.function_queries[246].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_8: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_246] = [__v_9]; record.function_queries[246].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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 __v_10: G = G::from_u64(2); let __ret: [G; OUT_246] = [__v_10]; 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_4, __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_10: G = __r_arr[0]; let __ret: [G; OUT_246] = [__v_10]; record.function_queries[246].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_247: usize = 2; -const IN_247: usize = 2; -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 __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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 __ret: [G; OUT_247] = [__v_5]; record.function_queries[247].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(1).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() { 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_8]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_8: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_9]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_247] = { let __args: [G; IN_247] = [__v_0, __v_7]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_247] = [__v_10]; 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_4, __v_7]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_247] = [__v_10]; record.function_queries[247].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_248: usize = 2; -const IN_248: usize = 2; -const OUT_248: usize = 1; -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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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(1).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() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_248] = [__v_8]; record.function_queries[248].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_248] = [__v_8]; record.function_queries[248].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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() { 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_248] = [__v_8]; record.function_queries[248].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_4, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_248] = [__v_8]; record.function_queries[248].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_249: usize = 2; -const IN_249: usize = 2; -const OUT_249: usize = 2; -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 __v_1: G = inp[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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 __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_0, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_249] = [__v_5, __v_8]; record.function_queries[249].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_0, __v_1]; let __mq = record.memory_queries.get_index_mut(1).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_249] = [__v_6, __v_8]; record.function_queries[249].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_0.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_249] = [__v_7, __v_1]; record.function_queries[249].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0, __v_4]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_3, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_249] = [__v_7, __v_10]; record.function_queries[249].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_250: usize = 3; -const IN_250: usize = 3; -const OUT_250: usize = 1; -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 __v_2: G = inp[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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(0); let __v_7: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(2))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 2)?; 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 = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_6, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_250] = [__v_10]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 2] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; match __v_6.as_canonical_u64() { _ => { let __v_8: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(2))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 2)?; 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_10, __v_0]; let __mq = record.memory_queries.get_index_mut(1).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_250] = [__v_11]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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 __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_5, __v_1, __v_2]; 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_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_250] = [__v_12]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 2] = [__v_6, __v_2]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(2))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 2)?; 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_11, __v_12, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_250] = [__v_13]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_250] = [__v_0]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_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; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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(1).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() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_251] = [__v_8]; record.function_queries[251].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_251] = [__v_8]; record.function_queries[251].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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() { 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_251] = [__v_8]; record.function_queries[251].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 2] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; match __v_8.as_canonical_u64() { _ => { let __loaded: [G; 2] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; match __v_10.as_canonical_u64() { _ => { let __v_12: G = __v_8 - __v_10; match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = __v_9 - __v_11; match __v_13.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_4, __v_7]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_251] = [__v_14]; record.function_queries[251].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_251] = [__v_14]; record.function_queries[251].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_251] = [__v_13]; record.function_queries[251].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_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; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_252] = [__v_4]; record.function_queries[252].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 2] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; match __v_4.as_canonical_u64() { _ => { let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_3]; 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 = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_252] = [__v_5]; record.function_queries[252].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_252] = [__v_6]; record.function_queries[252].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_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]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_253] = [__v_0]; record.function_queries[253].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(1).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() { 1u64 => { let __ret: [G; OUT_253] = [__v_0]; record.function_queries[253].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 2] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; match __v_8.as_canonical_u64() { _ => { let __loaded: [G; 2] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; match __v_10.as_canonical_u64() { _ => { let __v_12: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_4, __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_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_253] = [__v_15]; record.function_queries[253].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_13: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_13.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_7]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_253] = [__v_14]; record.function_queries[253].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_14: G = { let __a_val = __v_11.as_canonical_u64(); let __b_val = __v_9.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_4, __v_7]; 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 = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_253] = [__v_17]; record.function_queries[253].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_4, __v_7]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_253] = [__v_15]; record.function_queries[253].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_254: usize = 3; -const IN_254: usize = 3; -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]; let __v_2: G = inp[2]; match __v_2.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); }, 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1, __v_2]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_254] = [__v_6]; record.function_queries[254].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_254] = [__v_0]; record.function_queries[254].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, _ => { let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1, __v_2]; 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_3: G = __r_arr[0]; let __ret: [G; OUT_254] = [__v_3]; record.function_queries[254].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_255: usize = 3; -const IN_255: usize = 3; -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]; let __v_2: G = inp[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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(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(1).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_1, __v_2, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_6, __v_9, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_255] = [__v_10]; record.function_queries[255].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(1).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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { _ => { let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_1, __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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_6, __v_2, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_12, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_255] = [__v_13]; record.function_queries[255].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_255] = [__v_0]; record.function_queries[255].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, 1u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_10, __v_13, __v_0]; let __mq = record.memory_queries.get_index_mut(1).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_255] = [__v_14]; record.function_queries[255].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_5, __v_1, __v_2]; 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_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_255] = [__v_12]; record.function_queries[255].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_256: usize = 4; -const IN_256: usize = 4; -const OUT_256: usize = 1; -fn aiur_fn_256(inp: [G; IN_256], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_256], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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 __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(2))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 2)?; 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 = 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(1).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_7, __v_8, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_7, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_256] = [__v_13]; record.function_queries[256].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(1).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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { _ => { let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_1, __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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_9, __v_2, __v_3]; 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_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_7, __v_8, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_13, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_256] = [__v_14]; record.function_queries[256].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(2))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 2)?; 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 = G::from_u64(1); let __v_14: G = { let __values: [G; 3] = [__v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_12, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_16, __v_0]; let __mq = record.memory_queries.get_index_mut(1).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_256] = [__v_17]; record.function_queries[256].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(256, &__args[..])?) { [G::ZERO; OUT_256] } else { let (__hash, __hit) = record.function_queries[256].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[256].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => { aiur_fn_256::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_11, __v_5, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_256] = [__v_13]; record.function_queries[256].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_257: usize = 4; -const IN_257: usize = 4; -const OUT_257: usize = 1; -fn aiur_fn_257(inp: [G; IN_257], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_257], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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() { 0u64 => { let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_3, __v_1, __v_2]; 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_7: G = __r_arr[0]; let __ret: [G; OUT_257] = [__v_7]; record.function_queries[257].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = __v_2 + __v_7; let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, &__args[..])?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => { aiur_fn_257::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_257] = [__v_9]; record.function_queries[257].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, &__args[..])?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => { aiur_fn_257::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, &__args[..])?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => { aiur_fn_257::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_257] = [__v_8]; record.function_queries[257].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(258, &__args[..])?) { [G::ZERO; OUT_258] } else { let (__hash, __hit) = record.function_queries[258].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[258].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => { aiur_fn_258::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_257] = [__v_7]; record.function_queries[257].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_5, __v_1]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_3, __v_1, __v_2]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(256, &__args[..])?) { [G::ZERO; OUT_256] } else { let (__hash, __hit) = record.function_queries[256].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[256].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => { aiur_fn_256::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_257] = [__v_10]; record.function_queries[257].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_257] = [__v_3]; record.function_queries[257].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(256, &__args[..])?) { [G::ZERO; OUT_256] } else { let (__hash, __hit) = record.function_queries[256].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[256].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => { aiur_fn_256::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_257] = [__v_9]; record.function_queries[257].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_258: usize = 5; -const IN_258: usize = 5; -const OUT_258: usize = 1; -fn aiur_fn_258(inp: [G; IN_258], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_258], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_254] = { let __args: [G; IN_254] = [__v_4, __v_2, __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_8: G = __r_arr[0]; let __ret: [G; OUT_258] = [__v_8]; record.function_queries[258].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = __v_3 + __v_8; let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, &__args[..])?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => { aiur_fn_257::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, &__args[..])?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => { aiur_fn_257::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_258] = [__v_11]; record.function_queries[258].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(258, &__args[..])?) { [G::ZERO; OUT_258] } else { let (__hash, __hit) = record.function_queries[258].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[258].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => { aiur_fn_258::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(258, &__args[..])?) { [G::ZERO; OUT_258] } else { let (__hash, __hit) = record.function_queries[258].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[258].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => { aiur_fn_258::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_258] = [__v_9]; record.function_queries[258].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(258, &__args[..])?) { [G::ZERO; OUT_258] } else { let (__hash, __hit) = record.function_queries[258].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[258].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => { aiur_fn_258::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(258, &__args[..])?) { [G::ZERO; OUT_258] } else { let (__hash, __hit) = record.function_queries[258].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[258].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => { aiur_fn_258::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_258] = [__v_9]; record.function_queries[258].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_6, __v_2]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_4, __v_2, __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_10: G = __r_arr[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(256, &__args[..])?) { [G::ZERO; OUT_256] } else { let (__hash, __hit) = record.function_queries[256].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[256].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => { aiur_fn_256::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, &__args[..])?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => { aiur_fn_257::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_258] = [__v_12]; record.function_queries[258].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_4]; }, _ => { let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(256, &__args[..])?) { [G::ZERO; OUT_256] } else { let (__hash, __hit) = record.function_queries[256].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[256].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => { aiur_fn_256::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; break '__mc_0 [__v_10]; }, } }; let __v_10: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, &__args[..])?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => { aiur_fn_257::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_258] = [__v_11]; record.function_queries[258].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_259: usize = 2; -const IN_259: usize = 2; -const OUT_259: usize = 1; -fn aiur_fn_259(inp: [G; IN_259], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_259], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_259] = [__v_0]; record.function_queries[259].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(260, &__args[..])?) { [G::ZERO; OUT_260] } else { let (__hash, __hit) = record.function_queries[260].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[260].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => { aiur_fn_260::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(259, &__args[..])?) { [G::ZERO; OUT_259] } else { let (__hash, __hit) = record.function_queries[259].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[259].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[259].bump_multiplicity(__i); } let __ret: [G; OUT_259] = unsafe { *(record.function_queries[259].output_at(__i).as_ptr() as *const [G; OUT_259]) }; __ret }, _ => { aiur_fn_259::(__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(1).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_259] = [__v_8]; record.function_queries[259].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_260: usize = 2; -const IN_260: usize = 2; -const OUT_260: usize = 1; -fn aiur_fn_260(inp: [G; IN_260], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_260], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_260] = [__v_0]; record.function_queries[260].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(1).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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { _ => { let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_8, __v_5]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(260, &__args[..])?) { [G::ZERO; OUT_260] } else { let (__hash, __hit) = record.function_queries[260].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[260].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => { aiur_fn_260::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_260] = [__v_12]; record.function_queries[260].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_5, __v_8]; 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_12: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); break '__mc_0 [__v_13]; }, _ => { let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); break '__mc_1 [__v_13]; }, 0u64 => { let __v_13: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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 }; break '__mc_1 [__v_13]; }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }; let __v_13: G = __mc_out___mc_1[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_14.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); break '__mc_2 [__v_17]; }, 0u64 => { let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_7]; 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_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = __v_17 + __v_18; let __v_20: G = { let __a_val = __v_19.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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 }; break '__mc_2 [__v_20]; }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }; let __v_17: G = __mc_out___mc_2[0]; let __v_18: G = __v_13 * __v_17; match __v_18.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); break '__mc_0 [__v_19]; }, _ => { break '__mc_0 [__v_6]; }, } }, } }; let __v_13: G = __mc_out___mc_0[0]; let __mc_out___mc_3: [G; 1] = '__mc_3: { match __v_12.as_canonical_u64() { 1u64 => { break '__mc_3 [__v_7]; }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; match __v_14.as_canonical_u64() { 1u64 => { break '__mc_3 [__v_7]; }, 0u64 => { let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_7, __v_10]; 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_17: G = __r_arr[0]; break '__mc_3 [__v_17]; }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }; let __v_14: G = __mc_out___mc_3[0]; let __v_15: G = { let __values: [G; 3] = [__v_5, __v_13, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_260] = { let __args: [G; IN_260] = [__v_15, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(260, &__args[..])?) { [G::ZERO; OUT_260] } else { let (__hash, __hit) = record.function_queries[260].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[260].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => { aiur_fn_260::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_260] = [__v_16]; record.function_queries[260].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_261: usize = 1; -const IN_261: usize = 1; -const OUT_261: usize = 1; -fn aiur_fn_261(inp: [G; IN_261], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_261], ExecError> { stacker::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(1).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 __ret: [G; OUT_261] = [__v_0]; record.function_queries[261].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(1).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_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { _ => { match __v_5.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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() { 1u64 => { let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(261, &__args[..])?) { [G::ZERO; OUT_261] } else { let (__hash, __hit) = record.function_queries[261].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[261].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[261].bump_multiplicity(__i); } let __ret: [G; OUT_261] = unsafe { *(record.function_queries[261].output_at(__i).as_ptr() as *const [G; OUT_261]) }; __ret }, _ => { aiur_fn_261::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_261] = [__v_10]; record.function_queries[261].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_261] = [__v_0]; record.function_queries[261].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { let __ret: [G; OUT_261] = [__v_0]; record.function_queries[261].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_262: usize = 2; -const IN_262: usize = 2; -const OUT_262: usize = 1; -fn aiur_fn_262(inp: [G; IN_262], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_262], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_261] = { let __args: [G; IN_261] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(261, &__args[..])?) { [G::ZERO; OUT_261] } else { let (__hash, __hit) = record.function_queries[261].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[261].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[261].bump_multiplicity(__i); } let __ret: [G; OUT_261] = unsafe { *(record.function_queries[261].output_at(__i).as_ptr() as *const [G; OUT_261]) }; __ret }, _ => { aiur_fn_261::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(261, &__args[..])?) { [G::ZERO; OUT_261] } else { let (__hash, __hit) = record.function_queries[261].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[261].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[261].bump_multiplicity(__i); } let __ret: [G; OUT_261] = unsafe { *(record.function_queries[261].output_at(__i).as_ptr() as *const [G; OUT_261]) }; __ret }, _ => { aiur_fn_261::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_262] = [__v_10]; record.function_queries[262].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_262] = [__v_10]; record.function_queries[262].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_262] = [__v_10]; record.function_queries[262].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(1).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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { _ => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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() { _ => { let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_10, __v_13]; 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_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = __v_11 - __v_14; match __v_17.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_12, __v_15]; 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_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_6, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(262, &__args[..])?) { [G::ZERO; OUT_262] } else { let (__hash, __hit) = record.function_queries[262].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[262].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[262].bump_multiplicity(__i); } let __ret: [G; OUT_262] = unsafe { *(record.function_queries[262].output_at(__i).as_ptr() as *const [G; OUT_262]) }; __ret }, _ => { aiur_fn_262::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_262] = [__v_19]; record.function_queries[262].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_19: G = G::from_u64(0); let __ret: [G; OUT_262] = [__v_19]; record.function_queries[262].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); }, } }, _ => { let __v_18: G = G::from_u64(0); let __ret: [G; OUT_262] = [__v_18]; record.function_queries[262].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_262] = [__v_17]; record.function_queries[262].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_263: usize = 3; -const IN_263: usize = 3; -const OUT_263: usize = 1; -fn aiur_fn_263(inp: [G; IN_263], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_263], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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(0); let __ret: [G; OUT_263] = [__v_6]; record.function_queries[263].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(1).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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { _ => { let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_6, __v_1]; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(263, &__args[..])?) { [G::ZERO; OUT_263] } else { let (__hash, __hit) = record.function_queries[263].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[263].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[263].bump_multiplicity(__i); } let __ret: [G; OUT_263] = unsafe { *(record.function_queries[263].output_at(__i).as_ptr() as *const [G; OUT_263]) }; __ret }, _ => { aiur_fn_263::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_263] = [__v_10]; record.function_queries[263].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(1); break '__mc_0 [__v_11]; }, 1u64 => { let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(264, &__args[..])?) { [G::ZERO; OUT_264] } else { let (__hash, __hit) = record.function_queries[264].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[264].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[264].bump_multiplicity(__i); } let __ret: [G; OUT_264] = unsafe { *(record.function_queries[264].output_at(__i).as_ptr() as *const [G; OUT_264]) }; __ret }, _ => { aiur_fn_264::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; break '__mc_0 [__v_11]; }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }; let __v_11: G = __mc_out___mc_0[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_263] = [__v_12]; record.function_queries[263].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(263, &__args[..])?) { [G::ZERO; OUT_263] } else { let (__hash, __hit) = record.function_queries[263].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[263].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[263].bump_multiplicity(__i); } let __ret: [G; OUT_263] = unsafe { *(record.function_queries[263].output_at(__i).as_ptr() as *const [G; OUT_263]) }; __ret }, _ => { aiur_fn_263::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_263] = [__v_12]; record.function_queries[263].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_264: usize = 2; -const IN_264: usize = 2; -const OUT_264: usize = 1; -fn aiur_fn_264(inp: [G; IN_264], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_264], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_264] = [__v_5]; record.function_queries[264].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 2] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; match __v_5.as_canonical_u64() { _ => { let __v_7: G = G::from_u64(1); let __v_8: G = __v_6 + __v_7; let __v_9: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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() { 0u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_264] = [__v_10]; record.function_queries[264].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(264, &__args[..])?) { [G::ZERO; OUT_264] } else { let (__hash, __hit) = record.function_queries[264].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[264].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[264].bump_multiplicity(__i); } let __ret: [G; OUT_264] = unsafe { *(record.function_queries[264].output_at(__i).as_ptr() as *const [G; OUT_264]) }; __ret }, _ => { aiur_fn_264::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_264] = [__v_10]; record.function_queries[264].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_265: usize = 4; -const IN_265: usize = 4; -const OUT_265: usize = 1; -fn aiur_fn_265(inp: [G; IN_265], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_265], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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 __v_7: G = G::from_u64(0); let __ret: [G; OUT_265] = [__v_7]; record.function_queries[265].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(1).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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { _ => { let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_7, __v_1]; 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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(265, &__args[..])?) { [G::ZERO; OUT_265] } else { let (__hash, __hit) = record.function_queries[265].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[265].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[265].bump_multiplicity(__i); } let __ret: [G; OUT_265] = unsafe { *(record.function_queries[265].output_at(__i).as_ptr() as *const [G; OUT_265]) }; __ret }, _ => { aiur_fn_265::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_265] = [__v_11]; record.function_queries[265].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(266, &__args[..])?) { [G::ZERO; OUT_266] } else { let (__hash, __hit) = record.function_queries[266].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[266].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[266].bump_multiplicity(__i); } let __ret: [G; OUT_266] = unsafe { *(record.function_queries[266].output_at(__i).as_ptr() as *const [G; OUT_266]) }; __ret }, _ => { aiur_fn_266::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_265] = [__v_12]; record.function_queries[265].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(265, &__args[..])?) { [G::ZERO; OUT_265] } else { let (__hash, __hit) = record.function_queries[265].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[265].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[265].bump_multiplicity(__i); } let __ret: [G; OUT_265] = unsafe { *(record.function_queries[265].output_at(__i).as_ptr() as *const [G; OUT_265]) }; __ret }, _ => { aiur_fn_265::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_265] = [__v_12]; record.function_queries[265].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_266: usize = 3; -const IN_266: usize = 3; -const OUT_266: usize = 1; -fn aiur_fn_266(inp: [G; IN_266], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_266], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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(0); let __ret: [G; OUT_266] = [__v_6]; record.function_queries[266].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 2] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; match __v_6.as_canonical_u64() { _ => { let __v_8: G = __v_6 - __v_1; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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() { 0u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_266] = [__v_10]; record.function_queries[266].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(266, &__args[..])?) { [G::ZERO; OUT_266] } else { let (__hash, __hit) = record.function_queries[266].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[266].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[266].bump_multiplicity(__i); } let __ret: [G; OUT_266] = unsafe { *(record.function_queries[266].output_at(__i).as_ptr() as *const [G; OUT_266]) }; __ret }, _ => { aiur_fn_266::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_266] = [__v_10]; record.function_queries[266].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }, _ => { let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(266, &__args[..])?) { [G::ZERO; OUT_266] } else { let (__hash, __hit) = record.function_queries[266].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[266].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[266].bump_multiplicity(__i); } let __ret: [G; OUT_266] = unsafe { *(record.function_queries[266].output_at(__i).as_ptr() as *const [G; OUT_266]) }; __ret }, _ => { aiur_fn_266::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_266] = [__v_9]; record.function_queries[266].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_267: usize = 2; -const IN_267: usize = 2; -const OUT_267: usize = 1; -fn aiur_fn_267(inp: [G; IN_267], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_267], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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 __ret: [G; OUT_267] = [__v_5]; record.function_queries[267].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(1).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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { _ => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); break '__mc_0 [__v_8]; }, _ => { let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(263, &__args[..])?) { [G::ZERO; OUT_263] } else { let (__hash, __hit) = record.function_queries[263].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[263].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[263].bump_multiplicity(__i); } let __ret: [G; OUT_263] = unsafe { *(record.function_queries[263].output_at(__i).as_ptr() as *const [G; OUT_263]) }; __ret }, _ => { aiur_fn_263::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; break '__mc_0 [__v_8]; }, } }; let __v_8: G = __mc_out___mc_0[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_267] = [__v_9]; record.function_queries[267].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(268, &__args[..])?) { [G::ZERO; OUT_268] } else { let (__hash, __hit) = record.function_queries[268].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[268].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[268].bump_multiplicity(__i); } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => { aiur_fn_268::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_267] = [__v_10]; record.function_queries[267].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(267, &__args[..])?) { [G::ZERO; OUT_267] } else { let (__hash, __hit) = record.function_queries[267].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[267].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => { aiur_fn_267::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_267] = [__v_10]; record.function_queries[267].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_268: usize = 3; -const IN_268: usize = 3; -const OUT_268: usize = 1; -fn aiur_fn_268(inp: [G; IN_268], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_268], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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 __ret: [G; OUT_268] = [__v_6]; record.function_queries[268].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 2] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; match __v_6.as_canonical_u64() { _ => { let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(265, &__args[..])?) { [G::ZERO; OUT_265] } else { let (__hash, __hit) = record.function_queries[265].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[265].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[265].bump_multiplicity(__i); } let __ret: [G; OUT_265] = unsafe { *(record.function_queries[265].output_at(__i).as_ptr() as *const [G; OUT_265]) }; __ret }, _ => { aiur_fn_265::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_268] = [__v_9]; record.function_queries[268].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(268, &__args[..])?) { [G::ZERO; OUT_268] } else { let (__hash, __hit) = record.function_queries[268].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[268].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[268].bump_multiplicity(__i); } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => { aiur_fn_268::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_268] = [__v_9]; record.function_queries[268].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_269: usize = 1; -const IN_269: usize = 1; -const OUT_269: usize = 1; -fn aiur_fn_269(inp: [G; IN_269], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_269], ExecError> { stacker::maybe_grow(64 * 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(1); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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 = { let __values: [G; 3] = [__v_3, __v_1, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_4, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_257] = { let __args: [G; IN_257] = [__v_0, __v_3, __v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, &__args[..])?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => { aiur_fn_257::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_6, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(259, &__args[..])?) { [G::ZERO; OUT_259] } else { let (__hash, __hit) = record.function_queries[259].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[259].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[259].bump_multiplicity(__i); } let __ret: [G; OUT_259] = unsafe { *(record.function_queries[259].output_at(__i).as_ptr() as *const [G; OUT_259]) }; __ret }, _ => { aiur_fn_259::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_269] = [__v_7]; record.function_queries[269].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_270: usize = 2; -const IN_270: usize = 2; -const OUT_270: usize = 1; -fn aiur_fn_270(inp: [G; IN_270], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_270], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_245] = { let __args: [G; IN_245] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_270] = [__v_3]; record.function_queries[270].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(1).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() { 0u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_270] = [__v_6]; record.function_queries[270].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(269, &__args[..])?) { [G::ZERO; OUT_269] } else { let (__hash, __hit) = record.function_queries[269].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[269].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[269].bump_multiplicity(__i); } let __ret: [G; OUT_269] = unsafe { *(record.function_queries[269].output_at(__i).as_ptr() as *const [G; OUT_269]) }; __ret }, _ => { aiur_fn_269::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(269, &__args[..])?) { [G::ZERO; OUT_269] } else { let (__hash, __hit) = record.function_queries[269].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[269].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[269].bump_multiplicity(__i); } let __ret: [G; OUT_269] = unsafe { *(record.function_queries[269].output_at(__i).as_ptr() as *const [G; OUT_269]) }; __ret }, _ => { aiur_fn_269::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(267, &__args[..])?) { [G::ZERO; OUT_267] } else { let (__hash, __hit) = record.function_queries[267].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[267].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => { aiur_fn_267::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_270] = [__v_8]; record.function_queries[270].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_271: usize = 2; -const IN_271: usize = 2; -const OUT_271: usize = 1; -fn aiur_fn_271(inp: [G; IN_271], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_271], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_245] = { let __args: [G; IN_245] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_271] = [__v_3]; record.function_queries[271].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(269, &__args[..])?) { [G::ZERO; OUT_269] } else { let (__hash, __hit) = record.function_queries[269].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[269].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[269].bump_multiplicity(__i); } let __ret: [G; OUT_269] = unsafe { *(record.function_queries[269].output_at(__i).as_ptr() as *const [G; OUT_269]) }; __ret }, _ => { aiur_fn_269::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(269, &__args[..])?) { [G::ZERO; OUT_269] } else { let (__hash, __hit) = record.function_queries[269].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[269].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[269].bump_multiplicity(__i); } let __ret: [G; OUT_269] = unsafe { *(record.function_queries[269].output_at(__i).as_ptr() as *const [G; OUT_269]) }; __ret }, _ => { aiur_fn_269::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(262, &__args[..])?) { [G::ZERO; OUT_262] } else { let (__hash, __hit) = record.function_queries[262].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[262].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[262].bump_multiplicity(__i); } let __ret: [G; OUT_262] = unsafe { *(record.function_queries[262].output_at(__i).as_ptr() as *const [G; OUT_262]) }; __ret }, _ => { aiur_fn_262::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_271] = [__v_5]; record.function_queries[271].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_272: usize = 2; -const IN_272: usize = 2; -const OUT_272: usize = 1; -fn aiur_fn_272(inp: [G; IN_272], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_272], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_277] = { let __args: [G; IN_277] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(277, &__args[..])?) { [G::ZERO; OUT_277] } else { let (__hash, __hit) = record.function_queries[277].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[277].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => { aiur_fn_277::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(277, &__args[..])?) { [G::ZERO; OUT_277] } else { let (__hash, __hit) = record.function_queries[277].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[277].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => { aiur_fn_277::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_6.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_272] = [__v_1]; record.function_queries[272].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_272] = [__v_0]; record.function_queries[272].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(273, &__args[..])?) { [G::ZERO; OUT_273] } else { let (__hash, __hit) = record.function_queries[273].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[273].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[273].bump_multiplicity(__i); } let __ret: [G; OUT_273] = unsafe { *(record.function_queries[273].output_at(__i).as_ptr() as *const [G; OUT_273]) }; __ret }, _ => { aiur_fn_273::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_272] = [__v_6]; record.function_queries[272].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(273, &__args[..])?) { [G::ZERO; OUT_273] } else { let (__hash, __hit) = record.function_queries[273].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[273].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[273].bump_multiplicity(__i); } let __ret: [G; OUT_273] = unsafe { *(record.function_queries[273].output_at(__i).as_ptr() as *const [G; OUT_273]) }; __ret }, _ => { aiur_fn_273::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_272] = [__v_4]; record.function_queries[272].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_273: usize = 2; -const IN_273: usize = 2; -const OUT_273: usize = 1; -fn aiur_fn_273(inp: [G; IN_273], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_273], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_274] = { let __args: [G; IN_274] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(274, &__args[..])?) { [G::ZERO; OUT_274] } else { let (__hash, __hit) = record.function_queries[274].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[274].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => { aiur_fn_274::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_273] = [__v_0]; record.function_queries[273].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(1).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() { 0u64 => { let __ret: [G; OUT_273] = [__v_1]; record.function_queries[273].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(1).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 __ret: [G; OUT_273] = [__v_0]; record.function_queries[273].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_1, __v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(275, &__args[..])?) { [G::ZERO; OUT_275] } else { let (__hash, __hit) = record.function_queries[275].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[275].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => { aiur_fn_275::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_273] = [__v_1]; record.function_queries[273].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(275, &__args[..])?) { [G::ZERO; OUT_275] } else { let (__hash, __hit) = record.function_queries[275].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[275].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => { aiur_fn_275::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_273] = [__v_0]; record.function_queries[273].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(276, &__args[..])?) { [G::ZERO; OUT_276] } else { let (__hash, __hit) = record.function_queries[276].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[276].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => { aiur_fn_276::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_273] = [__v_11]; record.function_queries[273].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_274: usize = 2; -const IN_274: usize = 2; -const OUT_274: usize = 1; -fn aiur_fn_274(inp: [G; IN_274], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_274], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_1; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_274] = [__v_3]; record.function_queries[274].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(1).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() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(1); let __ret: [G; OUT_274] = [__v_9]; record.function_queries[274].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_274] = [__v_9]; record.function_queries[274].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(1).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() { 1u64 => { let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(274, &__args[..])?) { [G::ZERO; OUT_274] } else { let (__hash, __hit) = record.function_queries[274].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[274].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => { aiur_fn_274::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_274] = [__v_9]; record.function_queries[274].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_274] = [__v_9]; record.function_queries[274].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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() { 2u64 => { let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(274, &__args[..])?) { [G::ZERO; OUT_274] } else { let (__hash, __hit) = record.function_queries[274].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[274].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => { aiur_fn_274::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(274, &__args[..])?) { [G::ZERO; OUT_274] } else { let (__hash, __hit) = record.function_queries[274].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[274].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => { aiur_fn_274::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __v_9 * __v_10; let __ret: [G; OUT_274] = [__v_11]; record.function_queries[274].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_274] = [__v_9]; record.function_queries[274].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 3u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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() { 3u64 => { let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(274, &__args[..])?) { [G::ZERO; OUT_274] } else { let (__hash, __hit) = record.function_queries[274].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[274].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => { aiur_fn_274::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(274, &__args[..])?) { [G::ZERO; OUT_274] } else { let (__hash, __hit) = record.function_queries[274].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[274].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => { aiur_fn_274::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __v_9 * __v_10; let __ret: [G; OUT_274] = [__v_11]; record.function_queries[274].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_274] = [__v_9]; record.function_queries[274].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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() { 4u64 => { let __v_9: G = __v_4 - __v_7; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_274] = [__v_10]; record.function_queries[274].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_274] = [__v_10]; record.function_queries[274].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_274] = [__v_9]; record.function_queries[274].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_275: usize = 2; -const IN_275: usize = 2; -const OUT_275: usize = 1; -fn aiur_fn_275(inp: [G; IN_275], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_275], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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() { 2u64 => { let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(274, &__args[..])?) { [G::ZERO; OUT_274] } else { let (__hash, __hit) = record.function_queries[274].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[274].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => { aiur_fn_274::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_275] = [__v_6]; record.function_queries[275].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(274, &__args[..])?) { [G::ZERO; OUT_274] } else { let (__hash, __hit) = record.function_queries[274].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[274].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => { aiur_fn_274::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_275] = [__v_6]; record.function_queries[275].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_275] = [__v_5]; record.function_queries[275].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_276: usize = 2; -const IN_276: usize = 2; -const OUT_276: usize = 1; -fn aiur_fn_276(inp: [G; IN_276], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_276], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(278, &__args[..])?) { [G::ZERO; OUT_278] } else { let (__hash, __hit) = record.function_queries[278].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[278].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[278].bump_multiplicity(__i); } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => { aiur_fn_278::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(278, &__args[..])?) { [G::ZERO; OUT_278] } else { let (__hash, __hit) = record.function_queries[278].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[278].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[278].bump_multiplicity(__i); } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => { aiur_fn_278::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(274, &__args[..])?) { [G::ZERO; OUT_274] } else { let (__hash, __hit) = record.function_queries[274].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[274].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => { aiur_fn_274::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_276] = [__v_1]; record.function_queries[276].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_276] = [__v_0]; record.function_queries[276].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, 0u64 => { let __v_8: G = G::from_u64(2); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_0, __v_1]; let __mq = record.memory_queries.get_index_mut(1).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_276] = [__v_9]; record.function_queries[276].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_277: usize = 1; -const IN_277: usize = 1; -const OUT_277: usize = 2; -fn aiur_fn_277(inp: [G; IN_277], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_277], ExecError> { stacker::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(1).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 __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(0); let __ret: [G; OUT_277] = [__v_4, __v_5]; record.function_queries[277].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(277, &__args[..])?) { [G::ZERO; OUT_277] } else { let (__hash, __hit) = record.function_queries[277].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[277].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => { aiur_fn_277::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = __v_5 + __v_6; let __ret: [G; OUT_277] = [__v_6, __v_7]; record.function_queries[277].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_277] = [__v_6, __v_6]; record.function_queries[277].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_277] = [__v_4, __v_4]; record.function_queries[277].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_278: usize = 2; -const IN_278: usize = 2; -const OUT_278: usize = 2; -fn aiur_fn_278(inp: [G; IN_278], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_278], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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 = __v_1 + __v_5; let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(278, &__args[..])?) { [G::ZERO; OUT_278] } else { let (__hash, __hit) = record.function_queries[278].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[278].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[278].bump_multiplicity(__i); } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => { aiur_fn_278::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_278] = [__v_7, __v_8]; record.function_queries[278].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_278] = [__v_0, __v_1]; record.function_queries[278].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_279: usize = 2; -const IN_279: usize = 2; -const OUT_279: usize = 1; -fn aiur_fn_279(inp: [G; IN_279], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_279], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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() { 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_279] = [__v_6]; record.function_queries[279].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(272, &__args[..])?) { [G::ZERO; OUT_272] } else { let (__hash, __hit) = record.function_queries[272].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[272].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => { aiur_fn_272::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_279] = [__v_5]; record.function_queries[279].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(272, &__args[..])?) { [G::ZERO; OUT_272] } else { let (__hash, __hit) = record.function_queries[272].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[272].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => { aiur_fn_272::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_279] = [__v_6]; record.function_queries[279].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(1).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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_279] = [__v_1]; record.function_queries[279].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_0, __v_1]; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_279] = [__v_0]; record.function_queries[279].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(3); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __v_1]; let __mq = record.memory_queries.get_index_mut(1).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_279] = [__v_11]; record.function_queries[279].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_280: usize = 1; -const IN_280: usize = 1; -const OUT_280: usize = 1; -fn aiur_fn_280(inp: [G; IN_280], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_280], ExecError> { stacker::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(1).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 __v_4: G = G::from_u64(0); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_280] = [__v_5]; record.function_queries[280].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_280] = [__v_6]; record.function_queries[280].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(280, &__args[..])?) { [G::ZERO; OUT_280] } else { let (__hash, __hit) = record.function_queries[280].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[280].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[280].bump_multiplicity(__i); } let __ret: [G; OUT_280] = unsafe { *(record.function_queries[280].output_at(__i).as_ptr() as *const [G; OUT_280]) }; __ret }, _ => { aiur_fn_280::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_280] = [__v_7]; record.function_queries[280].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(280, &__args[..])?) { [G::ZERO; OUT_280] } else { let (__hash, __hit) = record.function_queries[280].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[280].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[280].bump_multiplicity(__i); } let __ret: [G; OUT_280] = unsafe { *(record.function_queries[280].output_at(__i).as_ptr() as *const [G; OUT_280]) }; __ret }, _ => { aiur_fn_280::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(280, &__args[..])?) { [G::ZERO; OUT_280] } else { let (__hash, __hit) = record.function_queries[280].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[280].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[280].bump_multiplicity(__i); } let __ret: [G; OUT_280] = unsafe { *(record.function_queries[280].output_at(__i).as_ptr() as *const [G; OUT_280]) }; __ret }, _ => { aiur_fn_280::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(272, &__args[..])?) { [G::ZERO; OUT_272] } else { let (__hash, __hit) = record.function_queries[272].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[272].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => { aiur_fn_272::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_280] = [__v_6]; record.function_queries[280].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(280, &__args[..])?) { [G::ZERO; OUT_280] } else { let (__hash, __hit) = record.function_queries[280].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[280].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[280].bump_multiplicity(__i); } let __ret: [G; OUT_280] = unsafe { *(record.function_queries[280].output_at(__i).as_ptr() as *const [G; OUT_280]) }; __ret }, _ => { aiur_fn_280::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(280, &__args[..])?) { [G::ZERO; OUT_280] } else { let (__hash, __hit) = record.function_queries[280].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[280].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[280].bump_multiplicity(__i); } let __ret: [G; OUT_280] = unsafe { *(record.function_queries[280].output_at(__i).as_ptr() as *const [G; OUT_280]) }; __ret }, _ => { aiur_fn_280::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(279, &__args[..])?) { [G::ZERO; OUT_279] } else { let (__hash, __hit) = record.function_queries[279].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[279].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[279].bump_multiplicity(__i); } let __ret: [G; OUT_279] = unsafe { *(record.function_queries[279].output_at(__i).as_ptr() as *const [G; OUT_279]) }; __ret }, _ => { aiur_fn_279::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_280] = [__v_6]; record.function_queries[280].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_281: usize = 2; -const IN_281: usize = 2; -const OUT_281: usize = 1; -fn aiur_fn_281(inp: [G; IN_281], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_281], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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 = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_281] = [__v_6]; record.function_queries[281].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(281, &__args[..])?) { [G::ZERO; OUT_281] } else { let (__hash, __hit) = record.function_queries[281].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[281].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[281].bump_multiplicity(__i); } let __ret: [G; OUT_281] = unsafe { *(record.function_queries[281].output_at(__i).as_ptr() as *const [G; OUT_281]) }; __ret }, _ => { aiur_fn_281::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_281] = [__v_8]; record.function_queries[281].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(281, &__args[..])?) { [G::ZERO; OUT_281] } else { let (__hash, __hit) = record.function_queries[281].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[281].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[281].bump_multiplicity(__i); } let __ret: [G; OUT_281] = unsafe { *(record.function_queries[281].output_at(__i).as_ptr() as *const [G; OUT_281]) }; __ret }, _ => { aiur_fn_281::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(281, &__args[..])?) { [G::ZERO; OUT_281] } else { let (__hash, __hit) = record.function_queries[281].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[281].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[281].bump_multiplicity(__i); } let __ret: [G; OUT_281] = unsafe { *(record.function_queries[281].output_at(__i).as_ptr() as *const [G; OUT_281]) }; __ret }, _ => { aiur_fn_281::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(272, &__args[..])?) { [G::ZERO; OUT_272] } else { let (__hash, __hit) = record.function_queries[272].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[272].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => { aiur_fn_272::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_281] = [__v_7]; record.function_queries[281].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(281, &__args[..])?) { [G::ZERO; OUT_281] } else { let (__hash, __hit) = record.function_queries[281].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[281].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[281].bump_multiplicity(__i); } let __ret: [G; OUT_281] = unsafe { *(record.function_queries[281].output_at(__i).as_ptr() as *const [G; OUT_281]) }; __ret }, _ => { aiur_fn_281::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(281, &__args[..])?) { [G::ZERO; OUT_281] } else { let (__hash, __hit) = record.function_queries[281].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[281].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[281].bump_multiplicity(__i); } let __ret: [G; OUT_281] = unsafe { *(record.function_queries[281].output_at(__i).as_ptr() as *const [G; OUT_281]) }; __ret }, _ => { aiur_fn_281::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(279, &__args[..])?) { [G::ZERO; OUT_279] } else { let (__hash, __hit) = record.function_queries[279].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[279].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[279].bump_multiplicity(__i); } let __ret: [G; OUT_279] = unsafe { *(record.function_queries[279].output_at(__i).as_ptr() as *const [G; OUT_279]) }; __ret }, _ => { aiur_fn_279::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_281] = [__v_7]; record.function_queries[281].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_281] = [__v_5]; record.function_queries[281].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_282: usize = 2; -const IN_282: usize = 2; -const OUT_282: usize = 1; -fn aiur_fn_282(inp: [G; IN_282], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_282], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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(1).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_282] = [__v_6]; record.function_queries[282].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(281, &__args[..])?) { [G::ZERO; OUT_281] } else { let (__hash, __hit) = record.function_queries[281].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[281].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[281].bump_multiplicity(__i); } let __ret: [G; OUT_281] = unsafe { *(record.function_queries[281].output_at(__i).as_ptr() as *const [G; OUT_281]) }; __ret }, _ => { aiur_fn_281::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(282, &__args[..])?) { [G::ZERO; OUT_282] } else { let (__hash, __hit) = record.function_queries[282].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[282].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => { aiur_fn_282::(__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(1).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_282] = [__v_8]; record.function_queries[282].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_283: usize = 2; -const IN_283: usize = 2; -const OUT_283: usize = 1; -fn aiur_fn_283(inp: [G; IN_283], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_283], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_283] = [__v_0]; record.function_queries[283].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(284, &__args[..])?) { [G::ZERO; OUT_284] } else { let (__hash, __hit) = record.function_queries[284].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[284].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[284].bump_multiplicity(__i); } let __ret: [G; OUT_284] = unsafe { *(record.function_queries[284].output_at(__i).as_ptr() as *const [G; OUT_284]) }; __ret }, _ => { aiur_fn_284::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_283] = [__v_5]; record.function_queries[283].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_284: usize = 2; -const IN_284: usize = 2; -const OUT_284: usize = 1; -fn aiur_fn_284(inp: [G; IN_284], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_284], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(2).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() { 0u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_6, __v_3, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_284] = [__v_7]; record.function_queries[284].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(281, &__args[..])?) { [G::ZERO; OUT_281] } else { let (__hash, __hit) = record.function_queries[281].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[281].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[281].bump_multiplicity(__i); } let __ret: [G; OUT_281] = unsafe { *(record.function_queries[281].output_at(__i).as_ptr() as *const [G; OUT_281]) }; __ret }, _ => { aiur_fn_281::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_284] = [__v_9]; record.function_queries[284].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(2); let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(282, &__args[..])?) { [G::ZERO; OUT_282] } else { let (__hash, __hit) = record.function_queries[282].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[282].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => { aiur_fn_282::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_284] = [__v_9]; record.function_queries[284].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_6: G = G::from_u64(3); let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_284] = [__v_10]; record.function_queries[284].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_6: G = G::from_u64(4); let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_284] = [__v_10]; record.function_queries[284].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_6: G = G::from_u64(5); let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_284] = [__v_10]; record.function_queries[284].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(6); let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_284] = [__v_10]; record.function_queries[284].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(7); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_284] = [__v_8]; record.function_queries[284].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_6: G = G::from_u64(8); let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_284] = [__v_8]; record.function_queries[284].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_285: usize = 2; -const IN_285: usize = 2; -const OUT_285: usize = 1; -fn aiur_fn_285(inp: [G; IN_285], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_285], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(7).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(7).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() { 1u64 => { let __v_22: G = G::from_u64(1); let __ret: [G; OUT_285] = [__v_22]; record.function_queries[285].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_285] = [__v_22]; record.function_queries[285].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(7).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() { 1u64 => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_285] = [__v_22]; record.function_queries[285].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(14, &__args[..])?) { [G::ZERO; OUT_14] } else { let (__hash, __hit) = record.function_queries[14].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[14].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => { aiur_fn_14::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_11, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(285, &__args[..])?) { [G::ZERO; OUT_285] } else { let (__hash, __hit) = record.function_queries[285].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[285].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[285].bump_multiplicity(__i); } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => { aiur_fn_285::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_285] = [__v_23]; record.function_queries[285].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_23: G = G::from_u64(0); let __ret: [G; OUT_285] = [__v_23]; record.function_queries[285].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_286: usize = 2; -const IN_286: usize = 2; -const OUT_286: usize = 1; -fn aiur_fn_286(inp: [G; IN_286], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_286], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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(1).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() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_286] = [__v_8]; record.function_queries[286].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_286] = [__v_8]; record.function_queries[286].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(1).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() { 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_286] = [__v_8]; record.function_queries[286].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_8: G = __v_3 - __v_6; match __v_8.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(286, &__args[..])?) { [G::ZERO; OUT_286] } else { let (__hash, __hit) = record.function_queries[286].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[286].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[286].bump_multiplicity(__i); } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => { aiur_fn_286::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_286] = [__v_9]; record.function_queries[286].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_286] = [__v_9]; record.function_queries[286].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_287: usize = 4; -const IN_287: usize = 4; -const OUT_287: usize = 1; -fn aiur_fn_287(inp: [G; IN_287], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_287], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_0.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(285, &__args[..])?) { [G::ZERO; OUT_285] } else { let (__hash, __hit) = record.function_queries[285].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[285].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[285].bump_multiplicity(__i); } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => { aiur_fn_285::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_287] = [__v_4]; record.function_queries[287].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_287] = [__v_4]; record.function_queries[287].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(286, &__args[..])?) { [G::ZERO; OUT_286] } else { let (__hash, __hit) = record.function_queries[286].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[286].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[286].bump_multiplicity(__i); } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => { aiur_fn_286::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_287] = [__v_4]; record.function_queries[287].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_287] = [__v_4]; record.function_queries[287].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_288: usize = 1; -const IN_288: usize = 1; -const OUT_288: usize = 1; -fn aiur_fn_288(inp: [G; IN_288], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_288], ExecError> { stacker::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(2).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 __v_5: G = G::from_u64(1); let __v_6: G = __v_2 + __v_5; let __ret: [G; OUT_288] = [__v_6]; record.function_queries[288].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_288] = [__v_5]; record.function_queries[288].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_288] = [__v_5]; record.function_queries[288].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_288] = [__v_5]; record.function_queries[288].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(290, &__args[..])?) { [G::ZERO; OUT_290] } else { let (__hash, __hit) = record.function_queries[290].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[290].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => { aiur_fn_290::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_288] = [__v_7]; record.function_queries[288].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(291, &__args[..])?) { [G::ZERO; OUT_291] } else { let (__hash, __hit) = record.function_queries[291].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[291].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[291].bump_multiplicity(__i); } let __ret: [G; OUT_291] = unsafe { *(record.function_queries[291].output_at(__i).as_ptr() as *const [G; OUT_291]) }; __ret }, _ => { aiur_fn_291::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(290, &__args[..])?) { [G::ZERO; OUT_290] } else { let (__hash, __hit) = record.function_queries[290].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[290].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => { aiur_fn_290::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_288] = [__v_8]; record.function_queries[288].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(291, &__args[..])?) { [G::ZERO; OUT_291] } else { let (__hash, __hit) = record.function_queries[291].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[291].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[291].bump_multiplicity(__i); } let __ret: [G; OUT_291] = unsafe { *(record.function_queries[291].output_at(__i).as_ptr() as *const [G; OUT_291]) }; __ret }, _ => { aiur_fn_291::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(290, &__args[..])?) { [G::ZERO; OUT_290] } else { let (__hash, __hit) = record.function_queries[290].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[290].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => { aiur_fn_290::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_288] = [__v_8]; record.function_queries[288].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(289, &__args[..])?) { [G::ZERO; OUT_289] } else { let (__hash, __hit) = record.function_queries[289].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[289].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[289].bump_multiplicity(__i); } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => { aiur_fn_289::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_288] = [__v_5]; record.function_queries[288].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_288] = [__v_5]; record.function_queries[288].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_289: usize = 3; -const IN_289: usize = 3; -const OUT_289: usize = 1; -fn aiur_fn_289(inp: [G; IN_289], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_289], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_288] = { let __args: [G; IN_288] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(290, &__args[..])?) { [G::ZERO; OUT_290] } else { let (__hash, __hit) = record.function_queries[290].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[290].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => { aiur_fn_290::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(291, &__args[..])?) { [G::ZERO; OUT_291] } else { let (__hash, __hit) = record.function_queries[291].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[291].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[291].bump_multiplicity(__i); } let __ret: [G; OUT_291] = unsafe { *(record.function_queries[291].output_at(__i).as_ptr() as *const [G; OUT_291]) }; __ret }, _ => { aiur_fn_291::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(290, &__args[..])?) { [G::ZERO; OUT_290] } else { let (__hash, __hit) = record.function_queries[290].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[290].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => { aiur_fn_290::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_289] = [__v_8]; record.function_queries[289].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_290: usize = 2; -const IN_290: usize = 2; -const OUT_290: usize = 1; -fn aiur_fn_290(inp: [G; IN_290], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_290], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 }; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_290] = [__v_1]; record.function_queries[290].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_290] = [__v_0]; record.function_queries[290].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_291: usize = 1; -const IN_291: usize = 1; -const OUT_291: usize = 1; -fn aiur_fn_291(inp: [G; IN_291], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_291], ExecError> { 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(0); let __ret: [G; OUT_291] = [__v_1]; record.function_queries[291].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 __ret: [G; OUT_291] = [__v_2]; record.function_queries[291].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_292: usize = 2; -const IN_292: usize = 2; -const OUT_292: usize = 1; -fn aiur_fn_292(inp: [G; IN_292], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_292], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 }; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_292] = [__v_0]; record.function_queries[292].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_292] = [__v_1]; record.function_queries[292].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_293: usize = 3; -const IN_293: usize = 3; -const OUT_293: usize = 1; -fn aiur_fn_293(inp: [G; IN_293], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_293], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(294, &__args[..])?) { [G::ZERO; OUT_294] } else { let (__hash, __hit) = record.function_queries[294].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[294].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => { aiur_fn_294::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_293] = [__v_7]; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_293] = [__v_7]; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_293] = [__v_7]; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_293] = [__v_7]; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(293, &__args[..])?) { [G::ZERO; OUT_293] } else { let (__hash, __hit) = record.function_queries[293].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[293].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => { aiur_fn_293::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_293] = [__v_8]; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(293, &__args[..])?) { [G::ZERO; OUT_293] } else { let (__hash, __hit) = record.function_queries[293].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[293].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => { aiur_fn_293::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_293] = [__v_8]; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, 4u64 => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(295, &__args[..])?) { [G::ZERO; OUT_295] } else { let (__hash, __hit) = record.function_queries[295].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[295].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => { aiur_fn_295::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_293] = [__v_7]; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(295, &__args[..])?) { [G::ZERO; OUT_295] } else { let (__hash, __hit) = record.function_queries[295].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[295].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => { aiur_fn_295::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_293] = [__v_7]; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(296, &__args[..])?) { [G::ZERO; OUT_296] } else { let (__hash, __hit) = record.function_queries[296].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[296].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[296].bump_multiplicity(__i); } let __ret: [G; OUT_296] = unsafe { *(record.function_queries[296].output_at(__i).as_ptr() as *const [G; OUT_296]) }; __ret }, _ => { aiur_fn_296::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_293] = [__v_7]; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(293, &__args[..])?) { [G::ZERO; OUT_293] } else { let (__hash, __hit) = record.function_queries[293].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[293].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => { aiur_fn_293::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_293] = [__v_7]; record.function_queries[293].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_294: usize = 3; -const IN_294: usize = 3; -const OUT_294: usize = 1; -fn aiur_fn_294(inp: [G; IN_294], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_294], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = { 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 }; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_294] = [__v_4]; record.function_queries[294].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_294] = [__v_4]; record.function_queries[294].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_295: usize = 4; -const IN_295: usize = 4; -const OUT_295: usize = 1; -fn aiur_fn_295(inp: [G; IN_295], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_295], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_293] = { let __args: [G; IN_293] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(293, &__args[..])?) { [G::ZERO; OUT_293] } else { let (__hash, __hit) = record.function_queries[293].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[293].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => { aiur_fn_293::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_295] = [__v_5]; record.function_queries[295].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = __v_2 + __v_5; let __v_7: G = __v_3 + __v_5; let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(293, &__args[..])?) { [G::ZERO; OUT_293] } else { let (__hash, __hit) = record.function_queries[293].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[293].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => { aiur_fn_293::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_295] = [__v_8]; record.function_queries[295].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_296: usize = 5; -const IN_296: usize = 5; -const OUT_296: usize = 1; -fn aiur_fn_296(inp: [G; IN_296], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_296], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(293, &__args[..])?) { [G::ZERO; OUT_293] } else { let (__hash, __hit) = record.function_queries[293].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[293].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => { aiur_fn_293::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_296] = [__v_6]; record.function_queries[296].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(293, &__args[..])?) { [G::ZERO; OUT_293] } else { let (__hash, __hit) = record.function_queries[293].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[293].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => { aiur_fn_293::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_296] = [__v_7]; record.function_queries[296].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 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_293] = { let __args: [G; IN_293] = [__v_2, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(293, &__args[..])?) { [G::ZERO; OUT_293] } else { let (__hash, __hit) = record.function_queries[293].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[293].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => { aiur_fn_293::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_296] = [__v_10]; record.function_queries[296].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_297: usize = 2; -const IN_297: usize = 2; -const OUT_297: usize = 1; -fn aiur_fn_297(inp: [G; IN_297], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_297], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(292, &__args[..])?) { [G::ZERO; OUT_292] } else { let (__hash, __hit) = record.function_queries[292].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[292].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => { aiur_fn_292::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(298, &__args[..])?) { [G::ZERO; OUT_298] } else { let (__hash, __hit) = record.function_queries[298].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[298].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => { aiur_fn_298::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_297] = [__v_4]; record.function_queries[297].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_298: usize = 2; -const IN_298: usize = 2; -const OUT_298: usize = 1; -fn aiur_fn_298(inp: [G; IN_298], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_298], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_299] = { let __args: [G; IN_299] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(299, &__args[..])?) { [G::ZERO; OUT_299] } else { let (__hash, __hit) = record.function_queries[299].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[299].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[299].bump_multiplicity(__i); } let __ret: [G; OUT_299] = unsafe { *(record.function_queries[299].output_at(__i).as_ptr() as *const [G; OUT_299]) }; __ret }, _ => { aiur_fn_299::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_298] = [__v_2]; record.function_queries[298].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __v_1 - __v_2; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(298, &__args[..])?) { [G::ZERO; OUT_298] } else { let (__hash, __hit) = record.function_queries[298].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[298].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => { aiur_fn_298::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __v_2 + __v_6; let __ret: [G; OUT_298] = [__v_7]; record.function_queries[298].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_299: usize = 1; -const IN_299: usize = 1; -const OUT_299: usize = 1; -fn aiur_fn_299(inp: [G; IN_299], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_299], ExecError> { stacker::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(1).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 __v_4: G = G::from_u64(1); let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(300, &__args[..])?) { [G::ZERO; OUT_300] } else { let (__hash, __hit) = record.function_queries[300].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[300].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[300].bump_multiplicity(__i); } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => { aiur_fn_300::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __v_4 + __v_6; let __ret: [G; OUT_299] = [__v_7]; record.function_queries[299].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_300: usize = 2; -const IN_300: usize = 2; -const OUT_300: usize = 1; -fn aiur_fn_300(inp: [G; IN_300], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_300], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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(0); let __ret: [G; OUT_300] = [__v_2]; record.function_queries[300].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(299, &__args[..])?) { [G::ZERO; OUT_299] } else { let (__hash, __hit) = record.function_queries[299].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[299].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[299].bump_multiplicity(__i); } let __ret: [G; OUT_299] = unsafe { *(record.function_queries[299].output_at(__i).as_ptr() as *const [G; OUT_299]) }; __ret }, _ => { aiur_fn_299::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_300] = [__v_2]; record.function_queries[300].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __v_1 - __v_2; let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(300, &__args[..])?) { [G::ZERO; OUT_300] } else { let (__hash, __hit) = record.function_queries[300].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[300].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[300].bump_multiplicity(__i); } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => { aiur_fn_300::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __v_2 + __v_6; let __ret: [G; OUT_300] = [__v_7]; record.function_queries[300].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_301: usize = 2; -const IN_301: usize = 2; -const OUT_301: usize = 1; -fn aiur_fn_301(inp: [G; IN_301], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_301], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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(1).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_301] = [__v_3]; record.function_queries[301].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_301] = [__v_0]; record.function_queries[301].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_1, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(292, &__args[..])?) { [G::ZERO; OUT_292] } else { let (__hash, __hit) = record.function_queries[292].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[292].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => { aiur_fn_292::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(298, &__args[..])?) { [G::ZERO; OUT_298] } else { let (__hash, __hit) = record.function_queries[298].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[298].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => { aiur_fn_298::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(776, &__args[..])?) { [G::ZERO; OUT_776] } else { let (__hash, __hit) = record.function_queries[776].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[776].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[776].bump_multiplicity(__i); } let __ret: [G; OUT_776] = unsafe { *(record.function_queries[776].output_at(__i).as_ptr() as *const [G; OUT_776]) }; __ret }, _ => { aiur_fn_776::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_301] = [__v_7]; record.function_queries[301].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_302: usize = 2; -const IN_302: usize = 2; -const OUT_302: usize = 1; -fn aiur_fn_302(inp: [G; IN_302], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_302], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_288] = { let __args: [G; IN_288] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = __v_1 + __v_3; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_4]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(4294967295); let __ret: [G; OUT_302] = [__v_6]; record.function_queries[302].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(303, &__args[..])?) { [G::ZERO; OUT_303] } else { let (__hash, __hit) = record.function_queries[303].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[303].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[303].bump_multiplicity(__i); } let __ret: [G; OUT_303] = unsafe { *(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303]) }; __ret }, _ => { aiur_fn_303::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_302] = [__v_6]; record.function_queries[302].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_303: usize = 2; -const IN_303: usize = 2; -const OUT_303: usize = 1; -fn aiur_fn_303(inp: [G; IN_303], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_303], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(2).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() { 0u64 => { let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(4294967295); let __ret: [G; OUT_303] = [__v_7]; record.function_queries[303].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_7: G = __v_3 - __v_1; let __ret: [G; OUT_303] = [__v_7]; record.function_queries[303].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, 1u64 => { let __v_6: G = G::from_u64(4294967295); let __ret: [G; OUT_303] = [__v_6]; record.function_queries[303].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(4294967295); let __ret: [G; OUT_303] = [__v_6]; record.function_queries[303].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(4294967295); let __ret: [G; OUT_303] = [__v_6]; record.function_queries[303].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(302, &__args[..])?) { [G::ZERO; OUT_302] } else { let (__hash, __hit) = record.function_queries[302].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[302].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => { aiur_fn_302::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_303] = [__v_7]; record.function_queries[303].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(302, &__args[..])?) { [G::ZERO; OUT_302] } else { let (__hash, __hit) = record.function_queries[302].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[302].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => { aiur_fn_302::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(292, &__args[..])?) { [G::ZERO; OUT_292] } else { let (__hash, __hit) = record.function_queries[292].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[292].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => { aiur_fn_292::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_303] = [__v_8]; record.function_queries[303].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(304, &__args[..])?) { [G::ZERO; OUT_304] } else { let (__hash, __hit) = record.function_queries[304].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[304].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[304].bump_multiplicity(__i); } let __ret: [G; OUT_304] = unsafe { *(record.function_queries[304].output_at(__i).as_ptr() as *const [G; OUT_304]) }; __ret }, _ => { aiur_fn_304::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_303] = [__v_6]; record.function_queries[303].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(304, &__args[..])?) { [G::ZERO; OUT_304] } else { let (__hash, __hit) = record.function_queries[304].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[304].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[304].bump_multiplicity(__i); } let __ret: [G; OUT_304] = unsafe { *(record.function_queries[304].output_at(__i).as_ptr() as *const [G; OUT_304]) }; __ret }, _ => { aiur_fn_304::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_303] = [__v_6]; record.function_queries[303].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(305, &__args[..])?) { [G::ZERO; OUT_305] } else { let (__hash, __hit) = record.function_queries[305].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[305].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[305].bump_multiplicity(__i); } let __ret: [G; OUT_305] = unsafe { *(record.function_queries[305].output_at(__i).as_ptr() as *const [G; OUT_305]) }; __ret }, _ => { aiur_fn_305::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_303] = [__v_6]; record.function_queries[303].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(302, &__args[..])?) { [G::ZERO; OUT_302] } else { let (__hash, __hit) = record.function_queries[302].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[302].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => { aiur_fn_302::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_303] = [__v_6]; record.function_queries[303].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_304: usize = 3; -const IN_304: usize = 3; -const OUT_304: usize = 1; -fn aiur_fn_304(inp: [G; IN_304], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_304], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_302] = { let __args: [G; IN_302] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(302, &__args[..])?) { [G::ZERO; OUT_302] } else { let (__hash, __hit) = record.function_queries[302].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[302].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => { aiur_fn_302::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_304] = [__v_4]; record.function_queries[304].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = __v_2 + __v_4; let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(302, &__args[..])?) { [G::ZERO; OUT_302] } else { let (__hash, __hit) = record.function_queries[302].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[302].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => { aiur_fn_302::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(292, &__args[..])?) { [G::ZERO; OUT_292] } else { let (__hash, __hit) = record.function_queries[292].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[292].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => { aiur_fn_292::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_304] = [__v_7]; record.function_queries[304].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_305: usize = 4; -const IN_305: usize = 4; -const OUT_305: usize = 1; -fn aiur_fn_305(inp: [G; IN_305], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_305], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_302] = { let __args: [G; IN_302] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(302, &__args[..])?) { [G::ZERO; OUT_302] } else { let (__hash, __hit) = record.function_queries[302].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[302].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => { aiur_fn_302::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_305] = [__v_5]; record.function_queries[305].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(302, &__args[..])?) { [G::ZERO; OUT_302] } else { let (__hash, __hit) = record.function_queries[302].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[302].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => { aiur_fn_302::(__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(0); let __ret: [G; OUT_305] = [__v_6]; record.function_queries[305].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(292, &__args[..])?) { [G::ZERO; OUT_292] } else { let (__hash, __hit) = record.function_queries[292].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[292].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => { aiur_fn_292::(__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_3 + __v_7; let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_2, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(302, &__args[..])?) { [G::ZERO; OUT_302] } else { let (__hash, __hit) = record.function_queries[302].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[302].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => { aiur_fn_302::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_6, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(292, &__args[..])?) { [G::ZERO; OUT_292] } else { let (__hash, __hit) = record.function_queries[292].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[292].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => { aiur_fn_292::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_305] = [__v_10]; record.function_queries[305].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_306: usize = 3; -const IN_306: usize = 3; -const OUT_306: usize = 1; -fn aiur_fn_306(inp: [G; IN_306], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_306], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __ret: [G; OUT_306] = [__v_0]; record.function_queries[306].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_306] = [__v_0]; record.function_queries[306].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(307, &__args[..])?) { [G::ZERO; OUT_307] } else { let (__hash, __hit) = record.function_queries[307].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[307].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[307].bump_multiplicity(__i); } let __ret: [G; OUT_307] = unsafe { *(record.function_queries[307].output_at(__i).as_ptr() as *const [G; OUT_307]) }; __ret }, _ => { aiur_fn_307::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_306] = [__v_5]; record.function_queries[306].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_307: usize = 3; -const IN_307: usize = 3; -const OUT_307: usize = 1; -fn aiur_fn_307(inp: [G; IN_307], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_307], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(308, &__args[..])?) { [G::ZERO; OUT_308] } else { let (__hash, __hit) = record.function_queries[308].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[308].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[308].bump_multiplicity(__i); } let __ret: [G; OUT_308] = unsafe { *(record.function_queries[308].output_at(__i).as_ptr() as *const [G; OUT_308]) }; __ret }, _ => { aiur_fn_308::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_307] = [__v_7]; record.function_queries[307].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_307] = [__v_9]; record.function_queries[307].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_307] = [__v_9]; record.function_queries[307].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_307] = [__v_11]; record.function_queries[307].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__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_2 + __v_9; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_307] = [__v_13]; record.function_queries[307].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__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_2 + __v_9; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_307] = [__v_13]; record.function_queries[307].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(309, &__args[..])?) { [G::ZERO; OUT_309] } else { let (__hash, __hit) = record.function_queries[309].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[309].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[309].bump_multiplicity(__i); } let __ret: [G; OUT_309] = unsafe { *(record.function_queries[309].output_at(__i).as_ptr() as *const [G; OUT_309]) }; __ret }, _ => { aiur_fn_309::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_307] = [__v_7]; record.function_queries[307].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_307] = [__v_9]; record.function_queries[307].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_307] = [__v_9]; record.function_queries[307].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_308: usize = 3; -const IN_308: usize = 3; -const OUT_308: usize = 1; -fn aiur_fn_308(inp: [G; IN_308], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_308], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = { let __values: [G; 4] = [__v_4, __v_0, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_308] = [__v_5]; record.function_queries[308].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = __v_0 + __v_1; let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_308] = [__v_6]; record.function_queries[308].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_309: usize = 5; -const IN_309: usize = 5; -const OUT_309: usize = 1; -fn aiur_fn_309(inp: [G; IN_309], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_309], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(6); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__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_4 + __v_8; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_309] = [__v_11]; record.function_queries[309].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_310: usize = 3; -const IN_310: usize = 3; -const OUT_310: usize = 1; -fn aiur_fn_310(inp: [G; IN_310], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_310], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __ret: [G; OUT_310] = [__v_0]; record.function_queries[310].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_310] = [__v_0]; record.function_queries[310].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(311, &__args[..])?) { [G::ZERO; OUT_311] } else { let (__hash, __hit) = record.function_queries[311].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[311].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[311].bump_multiplicity(__i); } let __ret: [G; OUT_311] = unsafe { *(record.function_queries[311].output_at(__i).as_ptr() as *const [G; OUT_311]) }; __ret }, _ => { aiur_fn_311::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_310] = [__v_5]; record.function_queries[310].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_311: usize = 3; -const IN_311: usize = 3; -const OUT_311: usize = 1; -fn aiur_fn_311(inp: [G; IN_311], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_311], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); let __v_8: G = __v_4 - __v_1; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_311] = [__v_9]; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_311] = [__v_9]; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_311] = [__v_9]; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(310, &__args[..])?) { [G::ZERO; OUT_310] } else { let (__hash, __hit) = record.function_queries[310].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[310].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => { aiur_fn_310::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(310, &__args[..])?) { [G::ZERO; OUT_310] } else { let (__hash, __hit) = record.function_queries[310].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[310].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => { aiur_fn_310::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_311] = [__v_11]; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(310, &__args[..])?) { [G::ZERO; OUT_310] } else { let (__hash, __hit) = record.function_queries[310].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[310].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => { aiur_fn_310::(__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_2 + __v_9; let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(310, &__args[..])?) { [G::ZERO; OUT_310] } else { let (__hash, __hit) = record.function_queries[310].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[310].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => { aiur_fn_310::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_311] = [__v_13]; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(310, &__args[..])?) { [G::ZERO; OUT_310] } else { let (__hash, __hit) = record.function_queries[310].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[310].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => { aiur_fn_310::(__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_2 + __v_9; let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(310, &__args[..])?) { [G::ZERO; OUT_310] } else { let (__hash, __hit) = record.function_queries[310].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[310].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => { aiur_fn_310::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_311] = [__v_13]; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(312, &__args[..])?) { [G::ZERO; OUT_312] } else { let (__hash, __hit) = record.function_queries[312].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[312].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => { aiur_fn_312::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_311] = [__v_7]; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_311] = [__v_9]; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(310, &__args[..])?) { [G::ZERO; OUT_310] } else { let (__hash, __hit) = record.function_queries[310].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[310].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => { aiur_fn_310::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_311] = [__v_9]; record.function_queries[311].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_312: usize = 5; -const IN_312: usize = 5; -const OUT_312: usize = 1; -fn aiur_fn_312(inp: [G; IN_312], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_312], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(6); let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(310, &__args[..])?) { [G::ZERO; OUT_310] } else { let (__hash, __hit) = record.function_queries[310].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[310].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => { aiur_fn_310::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(310, &__args[..])?) { [G::ZERO; OUT_310] } else { let (__hash, __hit) = record.function_queries[310].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[310].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => { aiur_fn_310::(__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_4 + __v_8; let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(310, &__args[..])?) { [G::ZERO; OUT_310] } else { let (__hash, __hit) = record.function_queries[310].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[310].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => { aiur_fn_310::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_312] = [__v_11]; record.function_queries[312].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_313: usize = 2; -const IN_313: usize = 2; -const OUT_313: usize = 1; -fn aiur_fn_313(inp: [G; IN_313], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_313], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(2).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() { 0u64 => { let __v_6: G = __v_3 - __v_1; match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_313] = [__v_7]; record.function_queries[313].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_313] = [__v_7]; record.function_queries[313].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 3u64 => { let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(313, &__args[..])?) { [G::ZERO; OUT_313] } else { let (__hash, __hit) = record.function_queries[313].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[313].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[313].bump_multiplicity(__i); } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => { aiur_fn_313::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_313] = [__v_7]; record.function_queries[313].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(313, &__args[..])?) { [G::ZERO; OUT_313] } else { let (__hash, __hit) = record.function_queries[313].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[313].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[313].bump_multiplicity(__i); } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => { aiur_fn_313::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_313] = [__v_7]; record.function_queries[313].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_313] = [__v_6]; record.function_queries[313].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(314, &__args[..])?) { [G::ZERO; OUT_314] } else { let (__hash, __hit) = record.function_queries[314].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[314].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => { aiur_fn_314::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_313] = [__v_6]; record.function_queries[313].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(315, &__args[..])?) { [G::ZERO; OUT_315] } else { let (__hash, __hit) = record.function_queries[315].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[315].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => { aiur_fn_315::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_313] = [__v_6]; record.function_queries[313].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(313, &__args[..])?) { [G::ZERO; OUT_313] } else { let (__hash, __hit) = record.function_queries[313].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[313].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[313].bump_multiplicity(__i); } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => { aiur_fn_313::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_313] = [__v_6]; record.function_queries[313].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_313] = [__v_6]; record.function_queries[313].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_314: usize = 3; -const IN_314: usize = 3; -const OUT_314: usize = 1; -fn aiur_fn_314(inp: [G; IN_314], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_314], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_313] = { let __args: [G; IN_313] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(313, &__args[..])?) { [G::ZERO; OUT_313] } else { let (__hash, __hit) = record.function_queries[313].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[313].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[313].bump_multiplicity(__i); } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => { aiur_fn_313::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_314] = [__v_4]; record.function_queries[314].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = __v_2 + __v_4; let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(313, &__args[..])?) { [G::ZERO; OUT_313] } else { let (__hash, __hit) = record.function_queries[313].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[313].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[313].bump_multiplicity(__i); } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => { aiur_fn_313::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_314] = [__v_6]; record.function_queries[314].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_315: usize = 4; -const IN_315: usize = 4; -const OUT_315: usize = 1; -fn aiur_fn_315(inp: [G; IN_315], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_315], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_313] = { let __args: [G; IN_313] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(313, &__args[..])?) { [G::ZERO; OUT_313] } else { let (__hash, __hit) = record.function_queries[313].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[313].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[313].bump_multiplicity(__i); } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => { aiur_fn_313::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_315] = [__v_5]; record.function_queries[315].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(313, &__args[..])?) { [G::ZERO; OUT_313] } else { let (__hash, __hit) = record.function_queries[313].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[313].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[313].bump_multiplicity(__i); } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => { aiur_fn_313::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_315] = [__v_6]; record.function_queries[315].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = __v_3 + __v_6; let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_2, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(313, &__args[..])?) { [G::ZERO; OUT_313] } else { let (__hash, __hit) = record.function_queries[313].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[313].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[313].bump_multiplicity(__i); } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => { aiur_fn_313::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_315] = [__v_8]; record.function_queries[315].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_316: usize = 3; -const IN_316: usize = 3; -const OUT_316: usize = 1; -fn aiur_fn_316(inp: [G; IN_316], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_316], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_288] = { let __args: [G; IN_288] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_316] = [__v_0]; record.function_queries[316].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(313, &__args[..])?) { [G::ZERO; OUT_313] } else { let (__hash, __hit) = record.function_queries[313].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[313].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[313].bump_multiplicity(__i); } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => { aiur_fn_313::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(317, &__args[..])?) { [G::ZERO; OUT_317] } else { let (__hash, __hit) = record.function_queries[317].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[317].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[317].bump_multiplicity(__i); } let __ret: [G; OUT_317] = unsafe { *(record.function_queries[317].output_at(__i).as_ptr() as *const [G; OUT_317]) }; __ret }, _ => { aiur_fn_317::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_316] = [__v_6]; record.function_queries[316].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = __v_2 + __v_6; let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(310, &__args[..])?) { [G::ZERO; OUT_310] } else { let (__hash, __hit) = record.function_queries[310].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[310].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => { aiur_fn_310::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_316] = [__v_8]; record.function_queries[316].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_317: usize = 3; -const IN_317: usize = 3; -const OUT_317: usize = 1; -fn aiur_fn_317(inp: [G; IN_317], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_317], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(318, &__args[..])?) { [G::ZERO; OUT_318] } else { let (__hash, __hit) = record.function_queries[318].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[318].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[318].bump_multiplicity(__i); } let __ret: [G; OUT_318] = unsafe { *(record.function_queries[318].output_at(__i).as_ptr() as *const [G; OUT_318]) }; __ret }, _ => { aiur_fn_318::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_317] = [__v_7]; record.function_queries[317].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_317] = [__v_9]; record.function_queries[317].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_317] = [__v_9]; record.function_queries[317].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_317] = [__v_11]; record.function_queries[317].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__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_2 + __v_9; let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_317] = [__v_13]; record.function_queries[317].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__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_2 + __v_9; let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_317] = [__v_13]; record.function_queries[317].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(319, &__args[..])?) { [G::ZERO; OUT_319] } else { let (__hash, __hit) = record.function_queries[319].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[319].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[319].bump_multiplicity(__i); } let __ret: [G; OUT_319] = unsafe { *(record.function_queries[319].output_at(__i).as_ptr() as *const [G; OUT_319]) }; __ret }, _ => { aiur_fn_319::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_317] = [__v_7]; record.function_queries[317].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_317] = [__v_9]; record.function_queries[317].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_317] = [__v_9]; record.function_queries[317].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_318: usize = 3; -const IN_318: usize = 3; -const OUT_318: usize = 1; -fn aiur_fn_318(inp: [G; IN_318], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_318], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_0] = { let __args: [G; IN_0] = [__v_0, __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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = { let __values: [G; 4] = [__v_4, __v_0, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_318] = [__v_5]; record.function_queries[318].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = __v_0 - __v_2; match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_318] = [__v_6]; record.function_queries[318].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = __v_0 - __v_6; let __v_8: G = { let __values: [G; 4] = [__v_5, __v_7, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_318] = [__v_8]; record.function_queries[318].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_319: usize = 5; -const IN_319: usize = 5; -const OUT_319: usize = 1; -fn aiur_fn_319(inp: [G; IN_319], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_319], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(6); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__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_4 + __v_8; let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_319] = [__v_11]; record.function_queries[319].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_320: usize = 3; -const IN_320: usize = 3; -const OUT_320: usize = 1; -fn aiur_fn_320(inp: [G; IN_320], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_320], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_775] = { let __args: [G; IN_775] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_320] = [__v_0]; record.function_queries[320].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_4]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_320] = [__v_0]; record.function_queries[320].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_6: G = __v_2 + __v_3; let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(293, &__args[..])?) { [G::ZERO; OUT_293] } else { let (__hash, __hit) = record.function_queries[293].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[293].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => { aiur_fn_293::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(322, &__args[..])?) { [G::ZERO; OUT_322] } else { let (__hash, __hit) = record.function_queries[322].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[322].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[322].bump_multiplicity(__i); } let __ret: [G; OUT_322] = unsafe { *(record.function_queries[322].output_at(__i).as_ptr() as *const [G; OUT_322]) }; __ret }, _ => { aiur_fn_322::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_320] = [__v_8]; record.function_queries[320].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = __v_2 + __v_3; let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_3, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(310, &__args[..])?) { [G::ZERO; OUT_310] } else { let (__hash, __hit) = record.function_queries[310].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[310].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => { aiur_fn_310::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_320] = [__v_9]; record.function_queries[320].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_321: usize = 3; -const IN_321: usize = 3; -const OUT_321: usize = 1; -fn aiur_fn_321(inp: [G; IN_321], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_321], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_775] = { let __args: [G; IN_775] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __v_0 - __v_2; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_4, __v_3]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_1, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_321] = [__v_8]; record.function_queries[321].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = __v_0 - __v_3; let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_321] = [__v_8]; record.function_queries[321].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_322: usize = 3; -const IN_322: usize = 3; -const OUT_322: usize = 1; -fn aiur_fn_322(inp: [G; IN_322], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_322], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(321, &__args[..])?) { [G::ZERO; OUT_321] } else { let (__hash, __hit) = record.function_queries[321].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[321].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[321].bump_multiplicity(__i); } let __ret: [G; OUT_321] = unsafe { *(record.function_queries[321].output_at(__i).as_ptr() as *const [G; OUT_321]) }; __ret }, _ => { aiur_fn_321::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_322] = [__v_7]; record.function_queries[322].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_322] = [__v_9]; record.function_queries[322].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_322] = [__v_9]; record.function_queries[322].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_322] = [__v_11]; record.function_queries[322].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__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_2 + __v_9; let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_322] = [__v_13]; record.function_queries[322].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__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_2 + __v_9; let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_322] = [__v_13]; record.function_queries[322].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(323, &__args[..])?) { [G::ZERO; OUT_323] } else { let (__hash, __hit) = record.function_queries[323].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[323].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => { aiur_fn_323::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_322] = [__v_7]; record.function_queries[322].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_322] = [__v_9]; record.function_queries[322].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_322] = [__v_9]; record.function_queries[322].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_323: usize = 5; -const IN_323: usize = 5; -const OUT_323: usize = 1; -fn aiur_fn_323(inp: [G; IN_323], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_323], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(6); let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__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_4 + __v_8; let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_323] = [__v_11]; record.function_queries[323].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_324: usize = 3; -const IN_324: usize = 3; -const OUT_324: usize = 3; -fn aiur_fn_324(inp: [G; IN_324], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_324], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 4u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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 __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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_324] = { let __args: [G; IN_324] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(324, &__args[..])?) { [G::ZERO; OUT_324] } else { let (__hash, __hit) = record.function_queries[324].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[324].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => { aiur_fn_324::(__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 __ret: [G; OUT_324] = [__v_12, __v_13, __v_14]; record.function_queries[324].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_324] = [__v_0, __v_2, __v_1]; record.function_queries[324].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { let __ret: [G; OUT_324] = [__v_0, __v_2, __v_1]; record.function_queries[324].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_325: usize = 4; -const IN_325: usize = 4; -const OUT_325: usize = 1; -fn aiur_fn_325(inp: [G; IN_325], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_325], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_324] = { let __args: [G; IN_324] = [__v_2, __v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(324, &__args[..])?) { [G::ZERO; OUT_324] } else { let (__hash, __hit) = record.function_queries[324].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[324].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => { aiur_fn_324::(__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 __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_2, __v_1]; 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 __ret: [G; OUT_325] = [__v_10]; record.function_queries[325].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_7, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_6, __v_11, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_12, __v_8, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(326, &__args[..])?) { [G::ZERO; OUT_326] } else { let (__hash, __hit) = record.function_queries[326].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[326].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[326].bump_multiplicity(__i); } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => { aiur_fn_326::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_325] = [__v_13]; record.function_queries[325].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_11, __v_8, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(326, &__args[..])?) { [G::ZERO; OUT_326] } else { let (__hash, __hit) = record.function_queries[326].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[326].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[326].bump_multiplicity(__i); } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => { aiur_fn_326::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_325] = [__v_12]; record.function_queries[325].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_326: usize = 4; -const IN_326: usize = 4; -const OUT_326: usize = 1; -fn aiur_fn_326(inp: [G; IN_326], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_326], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 3u64 => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_1]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_9, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_8, __v_10, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(326, &__args[..])?) { [G::ZERO; OUT_326] } else { let (__hash, __hit) = record.function_queries[326].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[326].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[326].bump_multiplicity(__i); } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => { aiur_fn_326::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_326] = [__v_11]; record.function_queries[326].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_2, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(325, &__args[..])?) { [G::ZERO; OUT_325] } else { let (__hash, __hit) = record.function_queries[325].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[325].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[325].bump_multiplicity(__i); } let __ret: [G; OUT_325] = unsafe { *(record.function_queries[325].output_at(__i).as_ptr() as *const [G; OUT_325]) }; __ret }, _ => { aiur_fn_325::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_326] = [__v_8]; record.function_queries[326].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0, __v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(338, &__args[..])?) { [G::ZERO; OUT_338] } else { let (__hash, __hit) = record.function_queries[338].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[338].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[338].bump_multiplicity(__i); } let __ret: [G; OUT_338] = unsafe { *(record.function_queries[338].output_at(__i).as_ptr() as *const [G; OUT_338]) }; __ret }, _ => { aiur_fn_338::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_326] = [__v_8]; record.function_queries[326].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_9, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(326, &__args[..])?) { [G::ZERO; OUT_326] } else { let (__hash, __hit) = record.function_queries[326].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[326].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[326].bump_multiplicity(__i); } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => { aiur_fn_326::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_326] = [__v_10]; record.function_queries[326].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0, __v_5, __v_6, __v_7, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(327, &__args[..])?) { [G::ZERO; OUT_327] } else { let (__hash, __hit) = record.function_queries[327].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[327].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => { aiur_fn_327::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_326] = [__v_8]; record.function_queries[326].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1, __v_2]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_326] = [__v_8]; record.function_queries[326].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_327: usize = 6; -const IN_327: usize = 6; -const OUT_327: usize = 1; -fn aiur_fn_327(inp: [G; IN_327], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_327], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_359] = { let __args: [G; IN_359] = [__v_0, __v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_0, __v_6, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(179, &__args[..])?) { [G::ZERO; OUT_179] } else { let (__hash, __hit) = record.function_queries[179].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[179].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { *(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179]) }; __ret }, _ => { aiur_fn_179::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(328, &__args[..])?) { [G::ZERO; OUT_328] } else { let (__hash, __hit) = record.function_queries[328].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[328].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[328].bump_multiplicity(__i); } let __ret: [G; OUT_328] = unsafe { *(record.function_queries[328].output_at(__i).as_ptr() as *const [G; OUT_328]) }; __ret }, _ => { aiur_fn_328::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; let __v_18: G = __loaded[3]; let __v_19: G = __loaded[4]; let __v_20: G = __loaded[5]; let __v_21: G = __loaded[6]; let __v_22: G = __loaded[7]; let __v_23: G = __loaded[8]; let __v_24: G = __loaded[9]; let __v_25: G = __loaded[10]; let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 6u64 => { let __v_27: G = __v_21 + __v_2; let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_9, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_28, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(326, &__args[..])?) { [G::ZERO; OUT_326] } else { let (__hash, __hit) = record.function_queries[326].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[326].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[326].bump_multiplicity(__i); } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => { aiur_fn_326::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_327] = [__v_29]; record.function_queries[327].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(8); let __v_28: G = { let __values: [G; 4] = [__v_27, __v_1, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_201] = { let __args: [G; IN_201] = [__v_28, __v_4]; 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_29: G = __r_arr[0]; let __ret: [G; OUT_327] = [__v_29]; record.function_queries[327].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_14: G = G::from_u64(8); let __v_15: G = { let __values: [G; 4] = [__v_14, __v_1, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_201] = { let __args: [G; IN_201] = [__v_15, __v_4]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_327] = [__v_16]; record.function_queries[327].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_328: usize = 1; -const IN_328: usize = 1; -const OUT_328: usize = 1; -fn aiur_fn_328(inp: [G; IN_328], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_328], ExecError> { stacker::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(2).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() { 2u64 => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_328] = [__v_5]; record.function_queries[328].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_6, __v_7, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = { let __values: [G; 12] = [__v_5, __v_5, __v_8, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 12)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_328] = [__v_9]; record.function_queries[328].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_329: usize = 3; -const IN_329: usize = 3; -const OUT_329: usize = 1; -fn aiur_fn_329(inp: [G; IN_329], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_329], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_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(1).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_329] = [__v_7]; record.function_queries[329].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_0, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(329, &__args[..])?) { [G::ZERO; OUT_329] } else { let (__hash, __hit) = record.function_queries[329].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[329].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => { aiur_fn_329::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_7, __v_6, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_329] = [__v_9]; record.function_queries[329].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_330: usize = 5; -const IN_330: usize = 5; -const OUT_330: usize = 2; -fn aiur_fn_330(inp: [G; IN_330], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_330], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(329, &__args[..])?) { [G::ZERO; OUT_329] } else { let (__hash, __hit) = record.function_queries[329].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[329].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => { aiur_fn_329::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_330] = [__v_9, __v_10]; record.function_queries[330].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_5, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_10]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_5, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_15]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_16, __v_14]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_330] = [__v_13, __v_17]; record.function_queries[330].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_index_mut(2).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_330] = [__v_13, __v_14]; record.function_queries[330].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, 2u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_330] = [__v_9, __v_10]; record.function_queries[330].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_5, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_10]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_5, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_12]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_15]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_16]; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_17, __v_14]; 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 __ret: [G; OUT_330] = [__v_13, __v_18]; record.function_queries[330].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_index_mut(2).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_330] = [__v_13, __v_14]; record.function_queries[330].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_0, __v_1, __v_2, __v_5, __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 __v_8: G = __r_arr[1]; let __ret: [G; OUT_330] = [__v_7, __v_8]; record.function_queries[330].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_331: usize = 3; -const IN_331: usize = 3; -const OUT_331: usize = 1; -fn aiur_fn_331(inp: [G; IN_331], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_331], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_329] = { let __args: [G; IN_329] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(329, &__args[..])?) { [G::ZERO; OUT_329] } else { let (__hash, __hit) = record.function_queries[329].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[329].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => { aiur_fn_329::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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() { 1u64 => { let __ret: [G; OUT_331] = [__v_3]; record.function_queries[331].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(1).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() { 1u64 => { let __ret: [G; OUT_331] = [__v_3]; record.function_queries[331].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_8]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_0, __v_11, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(329, &__args[..])?) { [G::ZERO; OUT_329] } else { let (__hash, __hit) = record.function_queries[329].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[329].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => { aiur_fn_329::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_10, __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_13: G = __r_arr[0]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_14, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_331] = [__v_17]; record.function_queries[331].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_332: usize = 2; -const IN_332: usize = 2; -const OUT_332: usize = 2; -fn aiur_fn_332(inp: [G; IN_332], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_332], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_479] = { let __args: [G; IN_479] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(479, &__args[..])?) { [G::ZERO; OUT_479] } else { let (__hash, __hit) = record.function_queries[479].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[479].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[479].bump_multiplicity(__i); } let __ret: [G; OUT_479] = unsafe { *(record.function_queries[479].output_at(__i).as_ptr() as *const [G; OUT_479]) }; __ret }, _ => { aiur_fn_479::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); break '__mc_0 [__v_3, __v_3]; }, _ => { let __v_3: G = G::from_u64(1); let __v_4: G = __v_2 - __v_3; let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(568, &__args[..])?) { [G::ZERO; OUT_568] } else { let (__hash, __hit) = record.function_queries[568].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[568].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[568].bump_multiplicity(__i); } let __ret: [G; OUT_568] = unsafe { *(record.function_queries[568].output_at(__i).as_ptr() as *const [G; OUT_568]) }; __ret }, _ => { aiur_fn_568::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; break '__mc_0 [__v_5, __v_6]; }, } }; let __v_3: G = __mc_out___mc_0[0]; let __v_4: G = __mc_out___mc_0[1]; match __v_3.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_332] = [__v_5, __v_5]; record.function_queries[332].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(478, &__args[..])?) { [G::ZERO; OUT_478] } else { let (__hash, __hit) = record.function_queries[478].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[478].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[478].bump_multiplicity(__i); } let __ret: [G; OUT_478] = unsafe { *(record.function_queries[478].output_at(__i).as_ptr() as *const [G; OUT_478]) }; __ret }, _ => { aiur_fn_478::(__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(0); let __ret: [G; OUT_332] = [__v_6, __v_6]; record.function_queries[332].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_332] = [__v_3, __v_4]; record.function_queries[332].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_333: usize = 5; -const IN_333: usize = 5; -const OUT_333: usize = 2; -fn aiur_fn_333(inp: [G; IN_333], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_333], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(332, &__args[..])?) { [G::ZERO; OUT_332] } else { let (__hash, __hit) = record.function_queries[332].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[332].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => { aiur_fn_332::(__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() { 1u64 => { let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_0, __v_1, __v_6, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(330, &__args[..])?) { [G::ZERO; OUT_330] } else { let (__hash, __hit) = record.function_queries[330].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[330].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[330].bump_multiplicity(__i); } let __ret: [G; OUT_330] = unsafe { *(record.function_queries[330].output_at(__i).as_ptr() as *const [G; OUT_330]) }; __ret }, _ => { aiur_fn_330::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_333] = [__v_7, __v_8]; record.function_queries[333].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(329, &__args[..])?) { [G::ZERO; OUT_329] } else { let (__hash, __hit) = record.function_queries[329].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[329].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => { aiur_fn_329::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_0, __v_1, __v_6, __v_7, __v_4]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_333] = [__v_8, __v_9]; record.function_queries[333].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_0, __v_6, __v_3, __v_4]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_333] = [__v_7, __v_8]; record.function_queries[333].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_0, __v_1, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(453, &__args[..])?) { [G::ZERO; OUT_453] } else { let (__hash, __hit) = record.function_queries[453].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[453].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[453].bump_multiplicity(__i); } let __ret: [G; OUT_453] = unsafe { *(record.function_queries[453].output_at(__i).as_ptr() as *const [G; OUT_453]) }; __ret }, _ => { aiur_fn_453::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_333] = [__v_7, __v_8]; record.function_queries[333].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_6, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(199, &__args[..])?) { [G::ZERO; OUT_199] } else { let (__hash, __hit) = record.function_queries[199].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[199].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[199].bump_multiplicity(__i); } let __ret: [G; OUT_199] = unsafe { *(record.function_queries[199].output_at(__i).as_ptr() as *const [G; OUT_199]) }; __ret }, _ => { aiur_fn_199::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_333] = [__v_7, __v_8]; record.function_queries[333].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_333] = [__v_7, __v_8]; record.function_queries[333].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_334: usize = 4; -const IN_334: usize = 4; -const OUT_334: usize = 2; -fn aiur_fn_334(inp: [G; IN_334], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_334], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(34); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(480, &__args[..])?) { [G::ZERO; OUT_480] } else { let (__hash, __hit) = record.function_queries[480].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[480].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => { aiur_fn_480::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(335, &__args[..])?) { [G::ZERO; OUT_335] } else { let (__hash, __hit) = record.function_queries[335].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[335].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[335].bump_multiplicity(__i); } let __ret: [G; OUT_335] = unsafe { *(record.function_queries[335].output_at(__i).as_ptr() as *const [G; OUT_335]) }; __ret }, _ => { aiur_fn_335::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_334] = [__v_6, __v_7]; record.function_queries[334].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(35); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_1, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(480, &__args[..])?) { [G::ZERO; OUT_480] } else { let (__hash, __hit) = record.function_queries[480].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[480].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => { aiur_fn_480::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(336, &__args[..])?) { [G::ZERO; OUT_336] } else { let (__hash, __hit) = record.function_queries[336].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[336].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => { aiur_fn_336::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_334] = [__v_8, __v_9]; record.function_queries[334].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_334] = [__v_8, __v_9]; record.function_queries[334].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_335: usize = 3; -const IN_335: usize = 3; -const OUT_335: usize = 2; -fn aiur_fn_335(inp: [G; IN_335], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_335], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_775] = { let __args: [G; IN_775] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(6); let __v_5: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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() { 1u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_335] = [__v_6, __v_7]; record.function_queries[335].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(3); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_1, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(5); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_1, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0, __v_9, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(337, &__args[..])?) { [G::ZERO; OUT_337] } else { let (__hash, __hit) = record.function_queries[337].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[337].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[337].bump_multiplicity(__i); } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => { aiur_fn_337::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(6); let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_15, __v_7, __v_11, __v_16]; let __mq = record.memory_queries.get_index_mut(2).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_201] = { let __args: [G; IN_201] = [__v_17, __v_13]; 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 __ret: [G; OUT_335] = [__v_14, __v_18]; record.function_queries[335].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_335] = [__v_12, __v_13]; record.function_queries[335].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_336: usize = 3; -const IN_336: usize = 3; -const OUT_336: usize = 2; -fn aiur_fn_336(inp: [G; IN_336], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_336], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_775] = { let __args: [G; IN_775] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(5); let __v_5: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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() { 1u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_336] = [__v_6, __v_7]; record.function_queries[336].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(3); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_1, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(4); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_1, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0, __v_9, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(337, &__args[..])?) { [G::ZERO; OUT_337] } else { let (__hash, __hit) = record.function_queries[337].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[337].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[337].bump_multiplicity(__i); } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => { aiur_fn_337::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(5); let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_15, __v_7, __v_11, __v_16]; let __mq = record.memory_queries.get_index_mut(2).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_201] = { let __args: [G; IN_201] = [__v_17, __v_13]; 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 __ret: [G; OUT_336] = [__v_14, __v_18]; record.function_queries[336].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_336] = [__v_12, __v_13]; record.function_queries[336].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_337: usize = 3; -const IN_337: usize = 3; -const OUT_337: usize = 2; -fn aiur_fn_337(inp: [G; IN_337], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_337], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_3]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { let __v_10: G = G::from_u64(33); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_7, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(480, &__args[..])?) { [G::ZERO; OUT_480] } else { let (__hash, __hit) = record.function_queries[480].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[480].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => { aiur_fn_480::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(3); let __v_14: G = __v_12 - __v_13; match __v_14.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(2); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_5, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_337] = [__v_15, __v_17]; record.function_queries[337].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(2).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_337] = [__v_15, __v_16]; record.function_queries[337].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_337] = [__v_12, __v_13]; record.function_queries[337].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_337] = [__v_10, __v_11]; record.function_queries[337].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_338: usize = 6; -const IN_338: usize = 6; -const OUT_338: usize = 1; -fn aiur_fn_338(inp: [G; IN_338], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_338], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_333] = { let __args: [G; IN_333] = [__v_0, __v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(333, &__args[..])?) { [G::ZERO; OUT_333] } else { let (__hash, __hit) = record.function_queries[333].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[333].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => { aiur_fn_333::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_7, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_338] = [__v_8]; record.function_queries[338].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_338] = [__v_7]; record.function_queries[338].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __v_17: G = __loaded[8]; let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; let __v_20: G = __loaded[11]; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_12, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(339, &__args[..])?) { [G::ZERO; OUT_339] } else { let (__hash, __hit) = record.function_queries[339].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[339].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[339].bump_multiplicity(__i); } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => { aiur_fn_339::(__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() { 1u64 => { let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_22, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_338] = [__v_23]; record.function_queries[338].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_12, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_23, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(326, &__args[..])?) { [G::ZERO; OUT_326] } else { let (__hash, __hit) = record.function_queries[326].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[326].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[326].bump_multiplicity(__i); } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => { aiur_fn_326::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_338] = [__v_24]; record.function_queries[338].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4]; 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_21: G = __r_arr[0]; let __ret: [G; OUT_338] = [__v_21]; record.function_queries[338].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(334, &__args[..])?) { [G::ZERO; OUT_334] } else { let (__hash, __hit) = record.function_queries[334].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[334].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[334].bump_multiplicity(__i); } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => { aiur_fn_334::(__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() { 1u64 => { let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_22, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_338] = [__v_23]; record.function_queries[338].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4]; 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_23: G = __r_arr[0]; let __ret: [G; OUT_338] = [__v_23]; record.function_queries[338].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 7u64 => { let __v_21: G = __v_12 + __v_14; let __v_22: G = __v_21 + __v_15; let __v_23: G = __v_22 + __v_13; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_17.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_11, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(350, &__args[..])?) { [G::ZERO; OUT_350] } else { let (__hash, __hit) = record.function_queries[350].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[350].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[350].bump_multiplicity(__i); } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => { aiur_fn_350::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_0, __v_2, __v_4, __v_12, __v_14, __v_15, __v_13, __v_16, __v_25, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(342, &__args[..])?) { [G::ZERO; OUT_342] } else { let (__hash, __hit) = record.function_queries[342].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[342].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[342].bump_multiplicity(__i); } let __ret: [G; OUT_342] = unsafe { *(record.function_queries[342].output_at(__i).as_ptr() as *const [G; OUT_342]) }; __ret }, _ => { aiur_fn_342::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; break '__mc_0 [__v_26, __v_27]; }, _ => { let __v_24: G = G::from_u64(0); break '__mc_0 [__v_24, __v_3]; }, } }; let __v_24: G = __mc_out___mc_0[0]; let __v_25: G = __mc_out___mc_0[1]; match __v_24.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_338] = [__v_25]; record.function_queries[338].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_11, __v_12, __v_14, __v_15, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(613, &__args[..])?) { [G::ZERO; OUT_613] } else { let (__hash, __hit) = record.function_queries[613].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[613].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[613].bump_multiplicity(__i); } let __ret: [G; OUT_613] = unsafe { *(record.function_queries[613].output_at(__i).as_ptr() as *const [G; OUT_613]) }; __ret }, _ => { aiur_fn_613::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_2, __v_4, __v_12, __v_14, __v_15, __v_13, __v_16, __v_5, __v_3, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(346, &__args[..])?) { [G::ZERO; OUT_346] } else { let (__hash, __hit) = record.function_queries[346].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[346].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => { aiur_fn_346::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; match __v_27.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_28, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_338] = [__v_29]; record.function_queries[338].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { match __v_17.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_338] = [__v_28]; record.function_queries[338].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_0, __v_11, __v_2, __v_4, __v_12, __v_14, __v_15, __v_13, __v_16, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(349, &__args[..])?) { [G::ZERO; OUT_349] } else { let (__hash, __hit) = record.function_queries[349].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[349].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[349].bump_multiplicity(__i); } let __ret: [G; OUT_349] = unsafe { *(record.function_queries[349].output_at(__i).as_ptr() as *const [G; OUT_349]) }; __ret }, _ => { aiur_fn_349::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; match __v_29.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_30, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __ret: [G; OUT_338] = [__v_31]; record.function_queries[338].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_338] = [__v_28]; record.function_queries[338].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4]; 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_29: G = __r_arr[0]; let __ret: [G; OUT_338] = [__v_29]; record.function_queries[338].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4]; 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_21: G = __r_arr[0]; let __ret: [G; OUT_338] = [__v_21]; record.function_queries[338].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_339: usize = 2; -const IN_339: usize = 2; -const OUT_339: usize = 2; -fn aiur_fn_339(inp: [G; IN_339], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_339], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(340, &__args[..])?) { [G::ZERO; OUT_340] } else { let (__hash, __hit) = record.function_queries[340].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[340].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[340].bump_multiplicity(__i); } let __ret: [G; OUT_340] = unsafe { *(record.function_queries[340].output_at(__i).as_ptr() as *const [G; OUT_340]) }; __ret }, _ => { aiur_fn_340::(__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]; match __v_3.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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 __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_339] = [__v_10, __v_11]; record.function_queries[339].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_1, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(8); let __v_12: G = { let __values: [G; 4] = [__v_11, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_777] = { let __args: [G; IN_777] = [__v_1, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_12, __v_13]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_339] = [__v_14, __v_15]; record.function_queries[339].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_339] = [__v_8, __v_9]; record.function_queries[339].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_340: usize = 2; -const IN_340: usize = 2; -const OUT_340: usize = 5; -fn aiur_fn_340(inp: [G; IN_340], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_340], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(2).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() { 4u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = __v_1 + __v_6; let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(340, &__args[..])?) { [G::ZERO; OUT_340] } else { let (__hash, __hit) = record.function_queries[340].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[340].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[340].bump_multiplicity(__i); } let __ret: [G; OUT_340] = unsafe { *(record.function_queries[340].output_at(__i).as_ptr() as *const [G; OUT_340]) }; __ret }, _ => { aiur_fn_340::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; let __v_11: G = __r_arr[3]; let __v_12: G = __r_arr[4]; let __ret: [G; OUT_340] = [__v_8, __v_9, __v_10, __v_11, __v_12]; record.function_queries[340].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 0u64 => { let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = __v_1 - __v_11; let __v_13: G = __v_12 - __v_7; let __ret: [G; OUT_340] = [__v_11, __v_1, __v_3, __v_4, __v_13]; record.function_queries[340].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 32] = [__v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(12).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_340] = [__v_11, __v_11, __v_12, __v_11, __v_11]; record.function_queries[340].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 32] = [__v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(12).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_340] = [__v_10, __v_10, __v_11, __v_10, __v_10]; record.function_queries[340].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 32] = [__v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(12).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_340] = [__v_6, __v_6, __v_7, __v_6, __v_6]; record.function_queries[340].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_341: usize = 2; -const IN_341: usize = 2; -const OUT_341: usize = 1; -fn aiur_fn_341(inp: [G; IN_341], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_341], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(2).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_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 7u64 => { match __v_3.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_4]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(1); let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(481, &__args[..])?) { [G::ZERO; OUT_481] } else { let (__hash, __hit) = record.function_queries[481].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[481].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => { aiur_fn_481::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_7, __v_9, __v_10, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_341] = [__v_12]; record.function_queries[341].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_4]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_7]; 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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(7); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_9, __v_10, __v_8, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(2); let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(481, &__args[..])?) { [G::ZERO; OUT_481] } else { let (__hash, __hit) = record.function_queries[481].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[481].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => { aiur_fn_481::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_12, __v_13, __v_15, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_18: G = { let __values: [G; 4] = [__v_17, __v_16, __v_11, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_341] = [__v_18]; record.function_queries[341].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_341] = [__v_1]; record.function_queries[341].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_341] = [__v_1]; record.function_queries[341].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_342: usize = 10; -const IN_342: usize = 10; -const OUT_342: usize = 2; -fn aiur_fn_342(inp: [G; IN_342], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_342], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; 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: 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_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]; match __v_10.as_canonical_u64() { 0u64 => { match __v_11.as_canonical_u64() { _ => { let __v_15: G = __v_3 + __v_4; let __v_16: G = __v_15 + __v_5; let __v_17: G = __v_16 + __v_6; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_17, __v_18]; 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_19: G = __r_arr[0]; match __v_19.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_20, __v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_index_mut(2).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_342] = [__v_20, __v_21]; record.function_queries[342].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_2, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_20, __v_11, __v_3, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(343, &__args[..])?) { [G::ZERO; OUT_343] } else { let (__hash, __hit) = record.function_queries[343].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[343].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[343].bump_multiplicity(__i); } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => { aiur_fn_343::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_22, __v_22, __v_22, __v_22]; let __mq = record.memory_queries.get_index_mut(2).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_342] = [__v_22, __v_23]; record.function_queries[342].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_13, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __v_3 + __v_4; let __v_24: G = __v_23 + __v_5; let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_2, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(776, &__args[..])?) { [G::ZERO; OUT_776] } else { let (__hash, __hit) = record.function_queries[776].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[776].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[776].bump_multiplicity(__i); } let __ret: [G; OUT_776] = unsafe { *(record.function_queries[776].output_at(__i).as_ptr() as *const [G; OUT_776]) }; __ret }, _ => { aiur_fn_776::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(1); let __v_27: G = __v_17 + __v_26; let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_22, __v_25]; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_29, __v_28]; 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_30: G = __r_arr[0]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_30, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __ret: [G; OUT_342] = [__v_26, __v_31]; record.function_queries[342].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(2).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_342] = [__v_15, __v_16]; record.function_queries[342].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_343: usize = 6; -const IN_343: usize = 6; -const OUT_343: usize = 1; -fn aiur_fn_343(inp: [G; IN_343], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_343], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_429] = { let __args: [G; IN_429] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(429, &__args[..])?) { [G::ZERO; OUT_429] } else { let (__hash, __hit) = record.function_queries[429].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[429].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[429].bump_multiplicity(__i); } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => { aiur_fn_429::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_6, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_11, __v_4]; 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_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_343] = [__v_15]; record.function_queries[343].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; let __v_19: G = __loaded[3]; let __v_20: G = __loaded[4]; let __v_21: G = __loaded[5]; let __v_22: G = __loaded[6]; let __v_23: G = __loaded[7]; let __v_24: G = __loaded[8]; let __v_25: G = __loaded[9]; let __v_26: G = __loaded[10]; let __v_27: G = __loaded[11]; match __v_16.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_24, __v_2, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(662, &__args[..])?) { [G::ZERO; OUT_662] } else { let (__hash, __hit) = record.function_queries[662].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[662].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[662].bump_multiplicity(__i); } let __ret: [G; OUT_662] = unsafe { *(record.function_queries[662].output_at(__i).as_ptr() as *const [G; OUT_662]) }; __ret }, _ => { aiur_fn_662::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(2); let __v_30: G = G::from_u64(0); let __v_31: G = { let __values: [G; 4] = [__v_29, __v_28, __v_12, __v_30]; let __mq = record.memory_queries.get_index_mut(2).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_776] = { let __args: [G; IN_776] = [__v_9, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(776, &__args[..])?) { [G::ZERO; OUT_776] } else { let (__hash, __hit) = record.function_queries[776].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[776].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[776].bump_multiplicity(__i); } let __ret: [G; OUT_776] = unsafe { *(record.function_queries[776].output_at(__i).as_ptr() as *const [G; OUT_776]) }; __ret }, _ => { aiur_fn_776::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_31, __v_32]; 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_33: G = __r_arr[0]; let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_33, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(429, &__args[..])?) { [G::ZERO; OUT_429] } else { let (__hash, __hit) = record.function_queries[429].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[429].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[429].bump_multiplicity(__i); } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => { aiur_fn_429::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_7, __v_34, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __ret: [G; OUT_343] = [__v_35]; record.function_queries[343].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(0); let __ret: [G; OUT_343] = [__v_28]; record.function_queries[343].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_343] = [__v_14]; record.function_queries[343].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_344: usize = 3; -const IN_344: usize = 3; -const OUT_344: usize = 1; -fn aiur_fn_344(inp: [G; IN_344], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_344], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_776] = { let __args: [G; IN_776] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(776, &__args[..])?) { [G::ZERO; OUT_776] } else { let (__hash, __hit) = record.function_queries[776].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[776].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[776].bump_multiplicity(__i); } let __ret: [G; OUT_776] = unsafe { *(record.function_queries[776].output_at(__i).as_ptr() as *const [G; OUT_776]) }; __ret }, _ => { aiur_fn_776::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 + __v_4; let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_7, __v_2, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_765] = { let __args: [G; IN_765] = [__v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_10, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_344] = [__v_11]; record.function_queries[344].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_345: usize = 3; -const IN_345: usize = 3; -const OUT_345: usize = 1; -fn aiur_fn_345(inp: [G; IN_345], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_345], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_3]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; let __v_15: G = __loaded[4]; let __v_16: G = __loaded[5]; let __v_17: G = __loaded[6]; let __v_18: G = __loaded[7]; let __v_19: G = __loaded[8]; let __v_20: G = __loaded[9]; let __v_21: G = __loaded[10]; let __v_22: G = __loaded[11]; match __v_11.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_14, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_23, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(326, &__args[..])?) { [G::ZERO; OUT_326] } else { let (__hash, __hit) = record.function_queries[326].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[326].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[326].bump_multiplicity(__i); } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => { aiur_fn_326::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_0, __v_24, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(345, &__args[..])?) { [G::ZERO; OUT_345] } else { let (__hash, __hit) = record.function_queries[345].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[345].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => { aiur_fn_345::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_345] = [__v_25]; record.function_queries[345].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_345] = [__v_3]; record.function_queries[345].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_345] = [__v_3]; record.function_queries[345].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_346: usize = 11; -const IN_346: usize = 11; -const OUT_346: usize = 2; -fn aiur_fn_346(inp: [G; IN_346], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_346], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = __v_3 + __v_4; let __v_12: G = __v_11 + __v_5; let __v_13: G = __v_12 + __v_6; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __a_val = __v_13.as_canonical_u64(); let __b_val = __v_14.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_15.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(2).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_346] = [__v_16, __v_17]; record.function_queries[346].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_13]; 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_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; match __v_16.as_canonical_u64() { 1u64 => { let __v_18: G = G::from_u64(1); let __ret: [G; OUT_346] = [__v_18, __v_17]; record.function_queries[346].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_2, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_18]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_0, __v_19, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(345, &__args[..])?) { [G::ZERO; OUT_345] } else { let (__hash, __hit) = record.function_queries[345].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[345].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => { aiur_fn_345::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_20]; 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_21: G = __r_arr[0]; let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(341, &__args[..])?) { [G::ZERO; OUT_341] } else { let (__hash, __hit) = record.function_queries[341].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[341].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => { aiur_fn_341::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(347, &__args[..])?) { [G::ZERO; OUT_347] } else { let (__hash, __hit) = record.function_queries[347].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[347].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[347].bump_multiplicity(__i); } let __ret: [G; OUT_347] = unsafe { *(record.function_queries[347].output_at(__i).as_ptr() as *const [G; OUT_347]) }; __ret }, _ => { aiur_fn_347::(__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]; match __v_23.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_25, __v_10]; 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_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); if (__v_27 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("iota: major's constructor belongs to a different inductive".to_string()) }); } let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_7, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(348, &__args[..])?) { [G::ZERO; OUT_348] } else { let (__hash, __hit) = record.function_queries[348].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[348].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[348].bump_multiplicity(__i); } let __ret: [G; OUT_348] = unsafe { *(record.function_queries[348].output_at(__i).as_ptr() as *const [G; OUT_348]) }; __ret }, _ => { aiur_fn_348::(__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]; match __v_29.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_2, __v_13, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(344, &__args[..])?) { [G::ZERO; OUT_344] } else { let (__hash, __hit) = record.function_queries[344].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[344].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[344].bump_multiplicity(__i); } let __ret: [G; OUT_344] = unsafe { *(record.function_queries[344].output_at(__i).as_ptr() as *const [G; OUT_344]) }; __ret }, _ => { aiur_fn_344::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(2); let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __v_32]; 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_34: G = __r_arr[0]; let __ret: [G; OUT_346] = [__v_33, __v_34]; record.function_queries[346].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_31, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = __v_3 + __v_4; let __v_34: G = __v_33 + __v_5; let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_2, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(776, &__args[..])?) { [G::ZERO; OUT_776] } else { let (__hash, __hit) = record.function_queries[776].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[776].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[776].bump_multiplicity(__i); } let __ret: [G; OUT_776] = unsafe { *(record.function_queries[776].output_at(__i).as_ptr() as *const [G; OUT_776]) }; __ret }, _ => { aiur_fn_776::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = __v_36 - __v_30; let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_26, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = G::from_u64(1); let __v_40: G = __v_13 + __v_39; let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_32, __v_35]; 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_42: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_42, __v_38]; 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_43: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_43, __v_41]; 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_44: G = __r_arr[0]; let __ret: [G; OUT_346] = [__v_39, __v_44]; record.function_queries[346].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_29.as_canonical_u64())); }, } }, _ => { let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_2, __v_13, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(344, &__args[..])?) { [G::ZERO; OUT_344] } else { let (__hash, __hit) = record.function_queries[344].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[344].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[344].bump_multiplicity(__i); } let __ret: [G; OUT_344] = unsafe { *(record.function_queries[344].output_at(__i).as_ptr() as *const [G; OUT_344]) }; __ret }, _ => { aiur_fn_344::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(2); let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __v_27]; 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_29: G = __r_arr[0]; let __ret: [G; OUT_346] = [__v_28, __v_29]; record.function_queries[346].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_347: usize = 1; -const IN_347: usize = 1; -const OUT_347: usize = 4; -fn aiur_fn_347(inp: [G; IN_347], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_347], ExecError> { stacker::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_128] = { let __args: [G; IN_128] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].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]; match __v_8.as_canonical_u64() { 6u64 => { let __v_20: G = G::from_u64(1); let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(405, &__args[..])?) { [G::ZERO; OUT_405] } else { let (__hash, __hit) = record.function_queries[405].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[405].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[405].bump_multiplicity(__i); } let __ret: [G; OUT_405] = unsafe { *(record.function_queries[405].output_at(__i).as_ptr() as *const [G; OUT_405]) }; __ret }, _ => { aiur_fn_405::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_347] = [__v_20, __v_13, __v_21, __v_2]; record.function_queries[347].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 32] = [__v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_index_mut(12).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_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(1).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_347] = [__v_20, __v_20, __v_21, __v_23]; record.function_queries[347].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 32] = [__v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(12).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_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(1).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_347] = [__v_7, __v_7, __v_8, __v_10]; record.function_queries[347].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_348: usize = 2; -const IN_348: usize = 2; -const OUT_348: usize = 3; -fn aiur_fn_348(inp: [G; IN_348], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_348], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(3).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(0); let __v_8: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_348] = [__v_7, __v_7, __v_8]; record.function_queries[348].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_7: G = __v_3 - __v_1; match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_348] = [__v_8, __v_4, __v_5]; record.function_queries[348].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_6, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(348, &__args[..])?) { [G::ZERO; OUT_348] } else { let (__hash, __hit) = record.function_queries[348].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[348].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[348].bump_multiplicity(__i); } let __ret: [G; OUT_348] = unsafe { *(record.function_queries[348].output_at(__i).as_ptr() as *const [G; OUT_348]) }; __ret }, _ => { aiur_fn_348::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; let __ret: [G; OUT_348] = [__v_8, __v_9, __v_10]; record.function_queries[348].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_349: usize = 10; -const IN_349: usize = 10; -const OUT_349: usize = 2; -fn aiur_fn_349(inp: [G; IN_349], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_349], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_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]; match __v_10.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(2).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_349] = [__v_15, __v_16]; record.function_queries[349].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; let __v_18: G = __loaded[3]; let __v_19: G = __loaded[4]; match __v_15.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_20, __v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_index_mut(2).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_349] = [__v_20, __v_21]; record.function_queries[349].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { match __v_11.as_canonical_u64() { _ => { let __v_20: G = __v_4 + __v_5; let __v_21: G = __v_20 + __v_6; let __v_22: G = __v_21 + __v_7; let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(350, &__args[..])?) { [G::ZERO; OUT_350] } else { let (__hash, __hit) = record.function_queries[350].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[350].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[350].bump_multiplicity(__i); } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => { aiur_fn_350::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; match __v_23.as_canonical_u64() { 0u64 => { let __v_25: G = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_index_mut(2).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_349] = [__v_25, __v_26]; record.function_queries[349].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; let __v_29: G = __loaded[3]; let __v_30: G = __loaded[4]; let __v_31: G = __loaded[5]; let __v_32: G = __loaded[6]; let __v_33: G = __loaded[7]; let __v_34: G = __loaded[8]; let __v_35: G = __loaded[9]; let __v_36: G = __loaded[10]; let __v_37: G = __loaded[11]; match __v_26.as_canonical_u64() { 5u64 => { let __v_38: G = G::from_u64(1); let __v_39: G = __v_31 - __v_38; match __v_39.as_canonical_u64() { 0u64 => { match __v_30.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(352, &__args[..])?) { [G::ZERO; OUT_352] } else { let (__hash, __hit) = record.function_queries[352].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[352].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[352].bump_multiplicity(__i); } let __ret: [G; OUT_352] = unsafe { *(record.function_queries[352].output_at(__i).as_ptr() as *const [G; OUT_352]) }; __ret }, _ => { aiur_fn_352::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; match __v_40.as_canonical_u64() { 1u64 => { let __v_41: G = G::from_u64(0); let __v_42: G = { let __values: [G; 4] = [__v_41, __v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_index_mut(2).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_349] = [__v_41, __v_42]; record.function_queries[349].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_3, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_42, __v_43]; 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_44: G = __r_arr[0]; match __v_44.as_canonical_u64() { 1u64 => { let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 4] = [__v_45, __v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_index_mut(2).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_349] = [__v_45, __v_46]; record.function_queries[349].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_41, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(429, &__args[..])?) { [G::ZERO; OUT_429] } else { let (__hash, __hit) = record.function_queries[429].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[429].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[429].bump_multiplicity(__i); } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => { aiur_fn_429::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_0, __v_45, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(411, &__args[..])?) { [G::ZERO; OUT_411] } else { let (__hash, __hit) = record.function_queries[411].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[411].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[411].bump_multiplicity(__i); } let __ret: [G; OUT_411] = unsafe { *(record.function_queries[411].output_at(__i).as_ptr() as *const [G; OUT_411]) }; __ret }, _ => { aiur_fn_411::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; match __v_46.as_canonical_u64() { 1u64 => { let __v_47: G = G::from_u64(0); let __v_48: G = { let __values: [G; 4] = [__v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_index_mut(2).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_349] = [__v_47, __v_48]; record.function_queries[349].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_13, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = __v_4 + __v_5; let __v_49: G = __v_48 + __v_6; let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_3, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(776, &__args[..])?) { [G::ZERO; OUT_776] } else { let (__hash, __hit) = record.function_queries[776].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[776].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[776].bump_multiplicity(__i); } let __ret: [G; OUT_776] = unsafe { *(record.function_queries[776].output_at(__i).as_ptr() as *const [G; OUT_776]) }; __ret }, _ => { aiur_fn_776::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_47, __v_50]; 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_51: G = __r_arr[0]; let __v_52: G = G::from_u64(0); let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_51, __v_24, __v_41, __v_12, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(351, &__args[..])?) { [G::ZERO; OUT_351] } else { let (__hash, __hit) = record.function_queries[351].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[351].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[351].bump_multiplicity(__i); } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => { aiur_fn_351::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(1); let __v_55: G = __v_22 + __v_54; let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_53, __v_56]; 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_57: G = __r_arr[0]; let __ret: [G; OUT_349] = [__v_54, __v_57]; record.function_queries[349].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { let __v_40: G = G::from_u64(0); let __v_41: G = { let __values: [G; 4] = [__v_40, __v_40, __v_40, __v_40]; let __mq = record.memory_queries.get_index_mut(2).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_349] = [__v_40, __v_41]; record.function_queries[349].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_40: G = G::from_u64(0); let __v_41: G = { let __values: [G; 4] = [__v_40, __v_40, __v_40, __v_40]; let __mq = record.memory_queries.get_index_mut(2).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_349] = [__v_40, __v_41]; record.function_queries[349].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 4] = [__v_38, __v_38, __v_38, __v_38]; let __mq = record.memory_queries.get_index_mut(2).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_349] = [__v_38, __v_39]; record.function_queries[349].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }) } -const INPUT_SIZE_350: usize = 2; -const IN_350: usize = 2; -const OUT_350: usize = 2; -fn aiur_fn_350(inp: [G; IN_350], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_350], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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 __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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() { 5u64 => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_3]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_350] = [__v_12, __v_9]; record.function_queries[350].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 32] = [__v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(12).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_350] = [__v_12, __v_13]; record.function_queries[350].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 32] = [__v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(12).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_350] = [__v_6, __v_7]; record.function_queries[350].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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() { 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = __v_1 - __v_6; let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(350, &__args[..])?) { [G::ZERO; OUT_350] } else { let (__hash, __hit) = record.function_queries[350].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[350].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[350].bump_multiplicity(__i); } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => { aiur_fn_350::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_350] = [__v_8, __v_9]; record.function_queries[350].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 32] = [__v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(12).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_350] = [__v_6, __v_7]; record.function_queries[350].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_351: usize = 5; -const IN_351: usize = 5; -const OUT_351: usize = 1; -fn aiur_fn_351(inp: [G; IN_351], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_351], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = __v_3 - __v_4; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_351] = [__v_0]; record.function_queries[351].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(8); let __v_7: G = { let __values: [G; 4] = [__v_6, __v_1, __v_4, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(3); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(1); let __v_12: G = __v_4 + __v_11; let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(351, &__args[..])?) { [G::ZERO; OUT_351] } else { let (__hash, __hit) = record.function_queries[351].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[351].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[351].bump_multiplicity(__i); } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => { aiur_fn_351::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_351] = [__v_13]; record.function_queries[351].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_352: usize = 1; -const IN_352: usize = 1; -const OUT_352: usize = 1; -fn aiur_fn_352(inp: [G; IN_352], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_352], ExecError> { stacker::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_234] = { let __args: [G; IN_234] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; match __v_2.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(353, &__args[..])?) { [G::ZERO; OUT_353] } else { let (__hash, __hit) = record.function_queries[353].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[353].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[353].bump_multiplicity(__i); } let __ret: [G; OUT_353] = unsafe { *(record.function_queries[353].output_at(__i).as_ptr() as *const [G; OUT_353]) }; __ret }, _ => { aiur_fn_353::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(354, &__args[..])?) { [G::ZERO; OUT_354] } else { let (__hash, __hit) = record.function_queries[354].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[354].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => { aiur_fn_354::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_352] = [__v_16]; record.function_queries[352].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __ret: [G; OUT_352] = [__v_14]; record.function_queries[352].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_353: usize = 2; -const IN_353: usize = 2; -const OUT_353: usize = 1; -fn aiur_fn_353(inp: [G; IN_353], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_353], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_228] = { let __args: [G; IN_228] = [__v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = __r_arr[10]; let __v_13: G = __r_arr[11]; let __v_14: G = __r_arr[12]; let __v_15: G = __r_arr[13]; let __v_16: G = __r_arr[14]; let __v_17: G = __r_arr[15]; let __v_18: G = __r_arr[16]; let __v_19: G = __r_arr[17]; let __v_20: G = __r_arr[18]; let __v_21: G = __r_arr[19]; let __v_22: G = __r_arr[20]; let __v_23: G = __r_arr[21]; let __v_24: G = __r_arr[22]; let __v_25: G = __r_arr[23]; let __v_26: G = __r_arr[24]; let __v_27: G = __r_arr[25]; let __v_28: G = __r_arr[26]; let __v_29: G = __r_arr[27]; let __v_30: G = __r_arr[28]; let __v_31: G = __r_arr[29]; let __v_32: G = __r_arr[30]; let __v_33: G = __r_arr[31]; let __v_34: G = __r_arr[32]; let __v_35: G = __r_arr[33]; let __v_36: G = __r_arr[34]; let __v_37: G = __r_arr[35]; let __v_38: G = __r_arr[36]; let __v_39: G = __r_arr[37]; let __v_40: G = __r_arr[38]; let __v_41: G = __r_arr[39]; let __v_42: G = __r_arr[40]; let __v_43: G = __r_arr[41]; let __v_44: G = __r_arr[42]; let __v_45: G = __r_arr[43]; let __v_46: G = __r_arr[44]; let __v_47: G = __r_arr[45]; let __v_48: G = __r_arr[46]; let __v_49: G = __r_arr[47]; match __v_2.as_canonical_u64() { _ => { match __v_2.as_canonical_u64() { 8u64 => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_3, __v_1]; 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_50: G = __r_arr[0]; let __ret: [G; OUT_353] = [__v_50]; record.function_queries[353].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_50: G = G::from_u64(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(1).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_53: G = { let __values: [G; 3] = [__v_50, __v_0, __v_52]; let __mq = record.memory_queries.get_index_mut(1).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_353] = [__v_53]; record.function_queries[353].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_354: usize = 6; -const IN_354: usize = 6; -const OUT_354: usize = 1; -fn aiur_fn_354(inp: [G; IN_354], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_354], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_2 - __v_5; match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_354] = [__v_7]; record.function_queries[354].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_0, __v_1, __v_5]; 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_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].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]; match __v_8.as_canonical_u64() { 6u64 => { let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_10, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(355, &__args[..])?) { [G::ZERO; OUT_355] } else { let (__hash, __hit) = record.function_queries[355].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[355].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[355].bump_multiplicity(__i); } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => { aiur_fn_355::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_20, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(356, &__args[..])?) { [G::ZERO; OUT_356] } else { let (__hash, __hit) = record.function_queries[356].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[356].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[356].bump_multiplicity(__i); } let __ret: [G; OUT_356] = unsafe { *(record.function_queries[356].output_at(__i).as_ptr() as *const [G; OUT_356]) }; __ret }, _ => { aiur_fn_356::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; match __v_21.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); let __ret: [G; OUT_354] = [__v_22]; record.function_queries[354].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(1); let __v_23: G = __v_5 + __v_22; let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(354, &__args[..])?) { [G::ZERO; OUT_354] } else { let (__hash, __hit) = record.function_queries[354].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[354].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => { aiur_fn_354::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_354] = [__v_24]; record.function_queries[354].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(1); let __ret: [G; OUT_354] = [__v_20]; record.function_queries[354].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_355: usize = 2; -const IN_355: usize = 2; -const OUT_355: usize = 1; -fn aiur_fn_355(inp: [G; IN_355], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_355], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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_355] = [__v_0]; record.function_queries[355].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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() { 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = __v_1 - __v_6; let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(355, &__args[..])?) { [G::ZERO; OUT_355] } else { let (__hash, __hit) = record.function_queries[355].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[355].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[355].bump_multiplicity(__i); } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => { aiur_fn_355::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_355] = [__v_8]; record.function_queries[355].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_355] = [__v_0]; record.function_queries[355].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_356: usize = 2; -const IN_356: usize = 2; -const OUT_356: usize = 1; -fn aiur_fn_356(inp: [G; IN_356], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_356], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(2).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() { 5u64 => { let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(357, &__args[..])?) { [G::ZERO; OUT_357] } else { let (__hash, __hit) = record.function_queries[357].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[357].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[357].bump_multiplicity(__i); } let __ret: [G; OUT_357] = unsafe { *(record.function_queries[357].output_at(__i).as_ptr() as *const [G; OUT_357]) }; __ret }, _ => { aiur_fn_357::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_356] = [__v_7]; record.function_queries[356].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(356, &__args[..])?) { [G::ZERO; OUT_356] } else { let (__hash, __hit) = record.function_queries[356].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[356].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[356].bump_multiplicity(__i); } let __ret: [G; OUT_356] = unsafe { *(record.function_queries[356].output_at(__i).as_ptr() as *const [G; OUT_356]) }; __ret }, _ => { aiur_fn_356::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_356] = [__v_7]; record.function_queries[356].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_356] = [__v_6]; record.function_queries[356].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_357: usize = 2; -const IN_357: usize = 2; -const OUT_357: usize = 1; -fn aiur_fn_357(inp: [G; IN_357], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_357], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(2).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() { 2u64 => { let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(358, &__args[..])?) { [G::ZERO; OUT_358] } else { let (__hash, __hit) = record.function_queries[358].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[358].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => { aiur_fn_358::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_357] = [__v_6]; record.function_queries[357].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(357, &__args[..])?) { [G::ZERO; OUT_357] } else { let (__hash, __hit) = record.function_queries[357].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[357].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[357].bump_multiplicity(__i); } let __ret: [G; OUT_357] = unsafe { *(record.function_queries[357].output_at(__i).as_ptr() as *const [G; OUT_357]) }; __ret }, _ => { aiur_fn_357::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_357] = [__v_7]; record.function_queries[357].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(357, &__args[..])?) { [G::ZERO; OUT_357] } else { let (__hash, __hit) = record.function_queries[357].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[357].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[357].bump_multiplicity(__i); } let __ret: [G; OUT_357] = unsafe { *(record.function_queries[357].output_at(__i).as_ptr() as *const [G; OUT_357]) }; __ret }, _ => { aiur_fn_357::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_357] = [__v_7]; record.function_queries[357].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(357, &__args[..])?) { [G::ZERO; OUT_357] } else { let (__hash, __hit) = record.function_queries[357].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[357].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[357].bump_multiplicity(__i); } let __ret: [G; OUT_357] = unsafe { *(record.function_queries[357].output_at(__i).as_ptr() as *const [G; OUT_357]) }; __ret }, _ => { aiur_fn_357::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_357] = [__v_7]; record.function_queries[357].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(357, &__args[..])?) { [G::ZERO; OUT_357] } else { let (__hash, __hit) = record.function_queries[357].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[357].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[357].bump_multiplicity(__i); } let __ret: [G; OUT_357] = unsafe { *(record.function_queries[357].output_at(__i).as_ptr() as *const [G; OUT_357]) }; __ret }, _ => { aiur_fn_357::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_357] = [__v_7]; record.function_queries[357].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 5u64 => { let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(357, &__args[..])?) { [G::ZERO; OUT_357] } else { let (__hash, __hit) = record.function_queries[357].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[357].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[357].bump_multiplicity(__i); } let __ret: [G; OUT_357] = unsafe { *(record.function_queries[357].output_at(__i).as_ptr() as *const [G; OUT_357]) }; __ret }, _ => { aiur_fn_357::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_357] = [__v_7]; record.function_queries[357].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(357, &__args[..])?) { [G::ZERO; OUT_357] } else { let (__hash, __hit) = record.function_queries[357].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[357].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[357].bump_multiplicity(__i); } let __ret: [G; OUT_357] = unsafe { *(record.function_queries[357].output_at(__i).as_ptr() as *const [G; OUT_357]) }; __ret }, _ => { aiur_fn_357::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_357] = [__v_7]; record.function_queries[357].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 6u64 => { let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(357, &__args[..])?) { [G::ZERO; OUT_357] } else { let (__hash, __hit) = record.function_queries[357].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[357].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[357].bump_multiplicity(__i); } let __ret: [G; OUT_357] = unsafe { *(record.function_queries[357].output_at(__i).as_ptr() as *const [G; OUT_357]) }; __ret }, _ => { aiur_fn_357::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_357] = [__v_7]; record.function_queries[357].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(357, &__args[..])?) { [G::ZERO; OUT_357] } else { let (__hash, __hit) = record.function_queries[357].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[357].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[357].bump_multiplicity(__i); } let __ret: [G; OUT_357] = unsafe { *(record.function_queries[357].output_at(__i).as_ptr() as *const [G; OUT_357]) }; __ret }, _ => { aiur_fn_357::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_357] = [__v_8]; record.function_queries[357].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(357, &__args[..])?) { [G::ZERO; OUT_357] } else { let (__hash, __hit) = record.function_queries[357].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[357].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[357].bump_multiplicity(__i); } let __ret: [G; OUT_357] = unsafe { *(record.function_queries[357].output_at(__i).as_ptr() as *const [G; OUT_357]) }; __ret }, _ => { aiur_fn_357::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_357] = [__v_8]; record.function_queries[357].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, 8u64 => { let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(357, &__args[..])?) { [G::ZERO; OUT_357] } else { let (__hash, __hit) = record.function_queries[357].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[357].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[357].bump_multiplicity(__i); } let __ret: [G; OUT_357] = unsafe { *(record.function_queries[357].output_at(__i).as_ptr() as *const [G; OUT_357]) }; __ret }, _ => { aiur_fn_357::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_357] = [__v_6]; record.function_queries[357].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_357] = [__v_6]; record.function_queries[357].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_358: usize = 2; -const IN_358: usize = 2; -const OUT_358: usize = 1; -fn aiur_fn_358(inp: [G; IN_358], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_358], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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(0); let __ret: [G; OUT_358] = [__v_5]; record.function_queries[358].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_358] = [__v_6]; record.function_queries[358].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(358, &__args[..])?) { [G::ZERO; OUT_358] } else { let (__hash, __hit) = record.function_queries[358].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[358].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => { aiur_fn_358::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_358] = [__v_6]; record.function_queries[358].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_359: usize = 3; -const IN_359: usize = 3; -const OUT_359: usize = 1; -fn aiur_fn_359(inp: [G; IN_359], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_359], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_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() { 1u64 => { let __ret: [G; OUT_359] = [__v_1]; record.function_queries[359].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_359] = [__v_1]; record.function_queries[359].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_359] = [__v_1]; record.function_queries[359].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_359] = [__v_1]; record.function_queries[359].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_359] = [__v_1]; record.function_queries[359].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_2, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(301, &__args[..])?) { [G::ZERO; OUT_301] } else { let (__hash, __hit) = record.function_queries[301].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[301].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { *(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301]) }; __ret }, _ => { aiur_fn_301::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; 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(1).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_326] = { let __args: [G; IN_326] = [__v_0, __v_1, __v_10, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(326, &__args[..])?) { [G::ZERO; OUT_326] } else { let (__hash, __hit) = record.function_queries[326].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[326].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[326].bump_multiplicity(__i); } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => { aiur_fn_326::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_359] = [__v_11]; record.function_queries[359].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_360: usize = 3; -const IN_360: usize = 3; -const OUT_360: usize = 1; -fn aiur_fn_360(inp: [G; IN_360], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_360], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = 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(1).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_326] = { let __args: [G; IN_326] = [__v_0, __v_1, __v_4, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(326, &__args[..])?) { [G::ZERO; OUT_326] } else { let (__hash, __hit) = record.function_queries[326].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[326].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[326].bump_multiplicity(__i); } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => { aiur_fn_326::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_360] = [__v_5]; record.function_queries[360].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_361: usize = 3; -const IN_361: usize = 3; -const OUT_361: usize = 1; -fn aiur_fn_361(inp: [G; IN_361], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_361], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_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() { 1u64 => { let __ret: [G; OUT_361] = [__v_1]; record.function_queries[361].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_361] = [__v_1]; record.function_queries[361].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_361] = [__v_1]; record.function_queries[361].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_361] = [__v_1]; record.function_queries[361].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_361] = [__v_1]; record.function_queries[361].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { 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(1).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_288] = { let __args: [G; IN_288] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(301, &__args[..])?) { [G::ZERO; OUT_301] } else { let (__hash, __hit) = record.function_queries[301].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[301].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { *(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301]) }; __ret }, _ => { aiur_fn_301::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(362, &__args[..])?) { [G::ZERO; OUT_362] } else { let (__hash, __hit) = record.function_queries[362].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[362].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => { aiur_fn_362::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_361] = [__v_11]; record.function_queries[361].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_362: usize = 4; -const IN_362: usize = 4; -const OUT_362: usize = 1; -fn aiur_fn_362(inp: [G; IN_362], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_362], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 3u64 => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_1]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_9, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_8, __v_10, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(362, &__args[..])?) { [G::ZERO; OUT_362] } else { let (__hash, __hit) = record.function_queries[362].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[362].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => { aiur_fn_362::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_362] = [__v_11]; record.function_queries[362].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_324] = { let __args: [G; IN_324] = [__v_1, __v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(324, &__args[..])?) { [G::ZERO; OUT_324] } else { let (__hash, __hit) = record.function_queries[324].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[324].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => { aiur_fn_324::(__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 __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1, __v_2]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_362] = [__v_14]; record.function_queries[362].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_11, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_10, __v_15, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_16, __v_12, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(362, &__args[..])?) { [G::ZERO; OUT_362] } else { let (__hash, __hit) = record.function_queries[362].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[362].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => { aiur_fn_362::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_362] = [__v_17]; record.function_queries[362].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_15, __v_12, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(362, &__args[..])?) { [G::ZERO; OUT_362] } else { let (__hash, __hit) = record.function_queries[362].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[362].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => { aiur_fn_362::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_362] = [__v_16]; record.function_queries[362].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 6u64 => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_9, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(362, &__args[..])?) { [G::ZERO; OUT_362] } else { let (__hash, __hit) = record.function_queries[362].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[362].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => { aiur_fn_362::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_362] = [__v_10]; record.function_queries[362].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_0, __v_5, __v_6, __v_7, __v_2, __v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(363, &__args[..])?) { [G::ZERO; OUT_363] } else { let (__hash, __hit) = record.function_queries[363].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[363].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => { aiur_fn_363::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_362] = [__v_8]; record.function_queries[362].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(364, &__args[..])?) { [G::ZERO; OUT_364] } else { let (__hash, __hit) = record.function_queries[364].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[364].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[364].bump_multiplicity(__i); } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => { aiur_fn_364::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_362] = [__v_8]; record.function_queries[362].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1, __v_2]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_362] = [__v_8]; record.function_queries[362].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_363: usize = 7; -const IN_363: usize = 7; -const OUT_363: usize = 1; -fn aiur_fn_363(inp: [G; IN_363], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_363], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(361, &__args[..])?) { [G::ZERO; OUT_361] } else { let (__hash, __hit) = record.function_queries[361].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[361].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[361].bump_multiplicity(__i); } let __ret: [G; OUT_361] = unsafe { *(record.function_queries[361].output_at(__i).as_ptr() as *const [G; OUT_361]) }; __ret }, _ => { aiur_fn_361::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(328, &__args[..])?) { [G::ZERO; OUT_328] } else { let (__hash, __hit) = record.function_queries[328].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[328].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[328].bump_multiplicity(__i); } let __ret: [G; OUT_328] = unsafe { *(record.function_queries[328].output_at(__i).as_ptr() as *const [G; OUT_328]) }; __ret }, _ => { aiur_fn_328::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; let __v_18: G = __loaded[3]; let __v_19: G = __loaded[4]; let __v_20: G = __loaded[5]; let __v_21: G = __loaded[6]; let __v_22: G = __loaded[7]; let __v_23: G = __loaded[8]; let __v_24: G = __loaded[9]; let __v_25: G = __loaded[10]; let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 6u64 => { let __v_27: G = __v_21 + __v_2; let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_9, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_28, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(362, &__args[..])?) { [G::ZERO; OUT_362] } else { let (__hash, __hit) = record.function_queries[362].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[362].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => { aiur_fn_362::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_363] = [__v_29]; record.function_queries[363].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_6, __v_4]; 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_27: G = __r_arr[0]; let __ret: [G; OUT_363] = [__v_27]; record.function_queries[363].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_6, __v_4]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_363] = [__v_14]; record.function_queries[363].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_364: usize = 6; -const IN_364: usize = 6; -const OUT_364: usize = 1; -fn aiur_fn_364(inp: [G; IN_364], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_364], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_234] = { let __args: [G; IN_234] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; let __v_13: G = __loaded[6]; let __v_14: G = __loaded[7]; let __v_15: G = __loaded[8]; let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; match __v_7.as_canonical_u64() { 7u64 => { let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_9, __v_10, __v_12, __v_13, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(613, &__args[..])?) { [G::ZERO; OUT_613] } else { let (__hash, __hit) = record.function_queries[613].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[613].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[613].bump_multiplicity(__i); } let __ret: [G; OUT_613] = unsafe { *(record.function_queries[613].output_at(__i).as_ptr() as *const [G; OUT_613]) }; __ret }, _ => { aiur_fn_613::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_2, __v_4, __v_10, __v_12, __v_13, __v_11, __v_14, __v_5, __v_3, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(346, &__args[..])?) { [G::ZERO; OUT_346] } else { let (__hash, __hit) = record.function_queries[346].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[346].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => { aiur_fn_346::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_21, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(361, &__args[..])?) { [G::ZERO; OUT_361] } else { let (__hash, __hit) = record.function_queries[361].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[361].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[361].bump_multiplicity(__i); } let __ret: [G; OUT_361] = unsafe { *(record.function_queries[361].output_at(__i).as_ptr() as *const [G; OUT_361]) }; __ret }, _ => { aiur_fn_361::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_364] = [__v_22]; record.function_queries[364].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_364] = [__v_22]; record.function_queries[364].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4]; 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_19: G = __r_arr[0]; let __ret: [G; OUT_364] = [__v_19]; record.function_queries[364].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_365: usize = 3; -const IN_365: usize = 3; -const OUT_365: usize = 1; -fn aiur_fn_365(inp: [G; IN_365], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_365], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_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() { 1u64 => { let __ret: [G; OUT_365] = [__v_1]; record.function_queries[365].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_365] = [__v_1]; record.function_queries[365].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_365] = [__v_1]; record.function_queries[365].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_365] = [__v_1]; record.function_queries[365].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_365] = [__v_1]; record.function_queries[365].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_2, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(301, &__args[..])?) { [G::ZERO; OUT_301] } else { let (__hash, __hit) = record.function_queries[301].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[301].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { *(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301]) }; __ret }, _ => { aiur_fn_301::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; 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(1).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_367] = { let __args: [G; IN_367] = [__v_0, __v_1, __v_10, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(367, &__args[..])?) { [G::ZERO; OUT_367] } else { let (__hash, __hit) = record.function_queries[367].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[367].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => { aiur_fn_367::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_365] = [__v_11]; record.function_queries[365].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_366: usize = 3; -const IN_366: usize = 3; -const OUT_366: usize = 1; -fn aiur_fn_366(inp: [G; IN_366], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_366], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = 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(1).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_367] = { let __args: [G; IN_367] = [__v_0, __v_1, __v_4, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(367, &__args[..])?) { [G::ZERO; OUT_367] } else { let (__hash, __hit) = record.function_queries[367].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[367].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => { aiur_fn_367::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_366] = [__v_5]; record.function_queries[366].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_367: usize = 4; -const IN_367: usize = 4; -const OUT_367: usize = 1; -fn aiur_fn_367(inp: [G; IN_367], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_367], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 3u64 => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_1]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_9, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_0, __v_8, __v_10, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(367, &__args[..])?) { [G::ZERO; OUT_367] } else { let (__hash, __hit) = record.function_queries[367].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[367].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => { aiur_fn_367::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_367] = [__v_11]; record.function_queries[367].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_2, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(368, &__args[..])?) { [G::ZERO; OUT_368] } else { let (__hash, __hit) = record.function_queries[368].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[368].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[368].bump_multiplicity(__i); } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => { aiur_fn_368::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_367] = [__v_8]; record.function_queries[367].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_0, __v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(370, &__args[..])?) { [G::ZERO; OUT_370] } else { let (__hash, __hit) = record.function_queries[370].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[370].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[370].bump_multiplicity(__i); } let __ret: [G; OUT_370] = unsafe { *(record.function_queries[370].output_at(__i).as_ptr() as *const [G; OUT_370]) }; __ret }, _ => { aiur_fn_370::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_367] = [__v_8]; record.function_queries[367].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_0, __v_9, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(367, &__args[..])?) { [G::ZERO; OUT_367] } else { let (__hash, __hit) = record.function_queries[367].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[367].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => { aiur_fn_367::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_367] = [__v_10]; record.function_queries[367].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_0, __v_5, __v_6, __v_7, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(369, &__args[..])?) { [G::ZERO; OUT_369] } else { let (__hash, __hit) = record.function_queries[369].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[369].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[369].bump_multiplicity(__i); } let __ret: [G; OUT_369] = unsafe { *(record.function_queries[369].output_at(__i).as_ptr() as *const [G; OUT_369]) }; __ret }, _ => { aiur_fn_369::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_367] = [__v_8]; record.function_queries[367].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1, __v_2]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_367] = [__v_8]; record.function_queries[367].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_368: usize = 4; -const IN_368: usize = 4; -const OUT_368: usize = 1; -fn aiur_fn_368(inp: [G; IN_368], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_368], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_324] = { let __args: [G; IN_324] = [__v_2, __v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(324, &__args[..])?) { [G::ZERO; OUT_324] } else { let (__hash, __hit) = record.function_queries[324].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[324].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => { aiur_fn_324::(__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 __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_2, __v_1]; 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 __ret: [G; OUT_368] = [__v_10]; record.function_queries[368].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_7, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_6, __v_11, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_0, __v_12, __v_8, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(367, &__args[..])?) { [G::ZERO; OUT_367] } else { let (__hash, __hit) = record.function_queries[367].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[367].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => { aiur_fn_367::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_368] = [__v_13]; record.function_queries[368].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_0, __v_11, __v_8, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(367, &__args[..])?) { [G::ZERO; OUT_367] } else { let (__hash, __hit) = record.function_queries[367].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[367].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => { aiur_fn_367::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_368] = [__v_12]; record.function_queries[368].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_369: usize = 6; -const IN_369: usize = 6; -const OUT_369: usize = 1; -fn aiur_fn_369(inp: [G; IN_369], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_369], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_365] = { let __args: [G; IN_365] = [__v_0, __v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(365, &__args[..])?) { [G::ZERO; OUT_365] } else { let (__hash, __hit) = record.function_queries[365].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[365].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => { aiur_fn_365::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_0, __v_6, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(179, &__args[..])?) { [G::ZERO; OUT_179] } else { let (__hash, __hit) = record.function_queries[179].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[179].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { *(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179]) }; __ret }, _ => { aiur_fn_179::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(328, &__args[..])?) { [G::ZERO; OUT_328] } else { let (__hash, __hit) = record.function_queries[328].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[328].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[328].bump_multiplicity(__i); } let __ret: [G; OUT_328] = unsafe { *(record.function_queries[328].output_at(__i).as_ptr() as *const [G; OUT_328]) }; __ret }, _ => { aiur_fn_328::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; let __v_18: G = __loaded[3]; let __v_19: G = __loaded[4]; let __v_20: G = __loaded[5]; let __v_21: G = __loaded[6]; let __v_22: G = __loaded[7]; let __v_23: G = __loaded[8]; let __v_24: G = __loaded[9]; let __v_25: G = __loaded[10]; let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 6u64 => { let __v_27: G = __v_21 + __v_2; let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_9, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_0, __v_28, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(367, &__args[..])?) { [G::ZERO; OUT_367] } else { let (__hash, __hit) = record.function_queries[367].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[367].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => { aiur_fn_367::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_369] = [__v_29]; record.function_queries[369].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(8); let __v_28: G = { let __values: [G; 4] = [__v_27, __v_1, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_201] = { let __args: [G; IN_201] = [__v_28, __v_4]; 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_29: G = __r_arr[0]; let __ret: [G; OUT_369] = [__v_29]; record.function_queries[369].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_14: G = G::from_u64(8); let __v_15: G = { let __values: [G; 4] = [__v_14, __v_1, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_201] = { let __args: [G; IN_201] = [__v_15, __v_4]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_369] = [__v_16]; record.function_queries[369].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_370: usize = 6; -const IN_370: usize = 6; -const OUT_370: usize = 1; -fn aiur_fn_370(inp: [G; IN_370], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_370], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_332] = { let __args: [G; IN_332] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(332, &__args[..])?) { [G::ZERO; OUT_332] } else { let (__hash, __hit) = record.function_queries[332].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[332].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => { aiur_fn_332::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_6.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_8, __v_9]; }, 1u64 => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(333, &__args[..])?) { [G::ZERO; OUT_333] } else { let (__hash, __hit) = record.function_queries[333].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[333].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => { aiur_fn_333::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; break '__mc_0 [__v_10, __v_11]; }, _ => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_10, __v_11]; }, } }, _ => { let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(333, &__args[..])?) { [G::ZERO; OUT_333] } else { let (__hash, __hit) = record.function_queries[333].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[333].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => { aiur_fn_333::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; break '__mc_0 [__v_8, __v_9]; }, } }; let __v_8: G = __mc_out___mc_0[0]; let __v_9: G = __mc_out___mc_0[1]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_9, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(365, &__args[..])?) { [G::ZERO; OUT_365] } else { let (__hash, __hit) = record.function_queries[365].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[365].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => { aiur_fn_365::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_370] = [__v_10]; record.function_queries[370].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_370] = [__v_9]; record.function_queries[370].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; let __v_15: G = __loaded[4]; let __v_16: G = __loaded[5]; let __v_17: G = __loaded[6]; let __v_18: G = __loaded[7]; let __v_19: G = __loaded[8]; let __v_20: G = __loaded[9]; let __v_21: G = __loaded[10]; let __v_22: G = __loaded[11]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_14, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(339, &__args[..])?) { [G::ZERO; OUT_339] } else { let (__hash, __hit) = record.function_queries[339].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[339].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[339].bump_multiplicity(__i); } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => { aiur_fn_339::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; match __v_23.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_24, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(365, &__args[..])?) { [G::ZERO; OUT_365] } else { let (__hash, __hit) = record.function_queries[365].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[365].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => { aiur_fn_365::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_370] = [__v_25]; record.function_queries[370].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4]; 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_25: G = __r_arr[0]; let __ret: [G; OUT_370] = [__v_25]; record.function_queries[370].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(334, &__args[..])?) { [G::ZERO; OUT_334] } else { let (__hash, __hit) = record.function_queries[334].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[334].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[334].bump_multiplicity(__i); } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => { aiur_fn_334::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; match __v_23.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_24, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(365, &__args[..])?) { [G::ZERO; OUT_365] } else { let (__hash, __hit) = record.function_queries[365].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[365].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => { aiur_fn_365::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_370] = [__v_25]; record.function_queries[370].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4]; 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_25: G = __r_arr[0]; let __ret: [G; OUT_370] = [__v_25]; record.function_queries[370].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 7u64 => { let __v_23: G = __v_14 + __v_16; let __v_24: G = __v_23 + __v_17; let __v_25: G = __v_24 + __v_15; let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_19.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_13, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(350, &__args[..])?) { [G::ZERO; OUT_350] } else { let (__hash, __hit) = record.function_queries[350].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[350].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[350].bump_multiplicity(__i); } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => { aiur_fn_350::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_0, __v_2, __v_4, __v_14, __v_16, __v_17, __v_15, __v_18, __v_27, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(342, &__args[..])?) { [G::ZERO; OUT_342] } else { let (__hash, __hit) = record.function_queries[342].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[342].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[342].bump_multiplicity(__i); } let __ret: [G; OUT_342] = unsafe { *(record.function_queries[342].output_at(__i).as_ptr() as *const [G; OUT_342]) }; __ret }, _ => { aiur_fn_342::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; break '__mc_1 [__v_28, __v_29]; }, _ => { let __v_26: G = G::from_u64(0); break '__mc_1 [__v_26, __v_3]; }, } }; let __v_26: G = __mc_out___mc_1[0]; let __v_27: G = __mc_out___mc_1[1]; match __v_26.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_370] = [__v_27]; record.function_queries[370].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_13, __v_14, __v_16, __v_17, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(613, &__args[..])?) { [G::ZERO; OUT_613] } else { let (__hash, __hit) = record.function_queries[613].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[613].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[613].bump_multiplicity(__i); } let __ret: [G; OUT_613] = unsafe { *(record.function_queries[613].output_at(__i).as_ptr() as *const [G; OUT_613]) }; __ret }, _ => { aiur_fn_613::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_2, __v_4, __v_14, __v_16, __v_17, __v_15, __v_18, __v_5, __v_3, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(346, &__args[..])?) { [G::ZERO; OUT_346] } else { let (__hash, __hit) = record.function_queries[346].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[346].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => { aiur_fn_346::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; match __v_29.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_30, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(365, &__args[..])?) { [G::ZERO; OUT_365] } else { let (__hash, __hit) = record.function_queries[365].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[365].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => { aiur_fn_365::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __ret: [G; OUT_370] = [__v_31]; record.function_queries[370].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { match __v_19.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_370] = [__v_30]; record.function_queries[370].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_0, __v_13, __v_2, __v_4, __v_14, __v_16, __v_17, __v_15, __v_18, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(349, &__args[..])?) { [G::ZERO; OUT_349] } else { let (__hash, __hit) = record.function_queries[349].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[349].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[349].bump_multiplicity(__i); } let __ret: [G; OUT_349] = unsafe { *(record.function_queries[349].output_at(__i).as_ptr() as *const [G; OUT_349]) }; __ret }, _ => { aiur_fn_349::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; match __v_31.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_32, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(365, &__args[..])?) { [G::ZERO; OUT_365] } else { let (__hash, __hit) = record.function_queries[365].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[365].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => { aiur_fn_365::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __ret: [G; OUT_370] = [__v_33]; record.function_queries[370].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_370] = [__v_30]; record.function_queries[370].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4]; 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_31: G = __r_arr[0]; let __ret: [G; OUT_370] = [__v_31]; record.function_queries[370].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4]; 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_23: G = __r_arr[0]; let __ret: [G; OUT_370] = [__v_23]; record.function_queries[370].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_371: usize = 2; -const IN_371: usize = 2; -const OUT_371: usize = 1; -fn aiur_fn_371(inp: [G; IN_371], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_371], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_768] = { let __args: [G; IN_768] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = __v_1 + __v_3; let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_371] = [__v_6]; record.function_queries[371].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_372: usize = 12; -const IN_372: usize = 12; -const OUT_372: usize = 1; -fn aiur_fn_372(inp: [G; IN_372], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_372], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_372] = [__v_1]; record.function_queries[372].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_372] = [__v_1]; record.function_queries[372].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_372] = [__v_1]; record.function_queries[372].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_372] = [__v_1]; record.function_queries[372].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_372] = [__v_1]; record.function_queries[372].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_372] = [__v_1]; record.function_queries[372].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __ret: [G; OUT_372] = [__v_1]; record.function_queries[372].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_372] = [__v_1]; record.function_queries[372].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_373: usize = 12; -const IN_373: usize = 12; -const OUT_373: usize = 1; -fn aiur_fn_373(inp: [G; IN_373], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_373], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_373] = [__v_2]; record.function_queries[373].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_373] = [__v_2]; record.function_queries[373].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_373] = [__v_2]; record.function_queries[373].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_373] = [__v_2]; record.function_queries[373].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_373] = [__v_2]; record.function_queries[373].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_373] = [__v_2]; record.function_queries[373].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __ret: [G; OUT_373] = [__v_2]; record.function_queries[373].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_373] = [__v_2]; record.function_queries[373].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_374: usize = 3; -const IN_374: usize = 3; -const OUT_374: usize = 1; -fn aiur_fn_374(inp: [G; IN_374], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_374], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_288] = { let __args: [G; IN_288] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(301, &__args[..])?) { [G::ZERO; OUT_301] } else { let (__hash, __hit) = record.function_queries[301].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[301].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { *(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301]) }; __ret }, _ => { aiur_fn_301::(__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(2).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_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 __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_4, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = __v_6 + __v_10; let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_374] = [__v_13]; record.function_queries[374].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_280] = { let __args: [G; IN_280] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(280, &__args[..])?) { [G::ZERO; OUT_280] } else { let (__hash, __hit) = record.function_queries[280].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[280].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[280].bump_multiplicity(__i); } let __ret: [G; OUT_280] = unsafe { *(record.function_queries[280].output_at(__i).as_ptr() as *const [G; OUT_280]) }; __ret }, _ => { aiur_fn_280::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_9, __v_12, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_374] = [__v_13]; record.function_queries[374].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].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 __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(372, &__args[..])?) { [G::ZERO; OUT_372] } else { let (__hash, __hit) = record.function_queries[372].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[372].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => { aiur_fn_372::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; if (__v_23 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(373, &__args[..])?) { [G::ZERO; OUT_373] } else { let (__hash, __hit) = record.function_queries[373].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[373].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[373].bump_multiplicity(__i); } let __ret: [G; OUT_373] = unsafe { *(record.function_queries[373].output_at(__i).as_ptr() as *const [G; OUT_373]) }; __ret }, _ => { aiur_fn_373::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_24, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_374] = [__v_25]; record.function_queries[374].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_6, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(374, &__args[..])?) { [G::ZERO; OUT_374] } else { let (__hash, __hit) = record.function_queries[374].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[374].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[374].bump_multiplicity(__i); } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => { aiur_fn_374::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 5u64 => { let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_12, __v_7, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_374] = [__v_15]; record.function_queries[374].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_9, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 5u64 => { let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_17, __v_7, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_374] = [__v_20]; record.function_queries[374].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, } }, 4u64 => { let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_6, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_374] = { let __args: [G; IN_374] = [__v_0, __v_7, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(374, &__args[..])?) { [G::ZERO; OUT_374] } else { let (__hash, __hit) = record.function_queries[374].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[374].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[374].bump_multiplicity(__i); } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => { aiur_fn_374::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(5); let __v_13: G = { let __values: [G; 4] = [__v_12, __v_6, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_374] = [__v_13]; record.function_queries[374].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_0, __v_6, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(376, &__args[..])?) { [G::ZERO; OUT_376] } else { let (__hash, __hit) = record.function_queries[376].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[376].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => { aiur_fn_376::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_6, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_376] = { let __args: [G; IN_376] = [__v_0, __v_7, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(376, &__args[..])?) { [G::ZERO; OUT_376] } else { let (__hash, __hit) = record.function_queries[376].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[376].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => { aiur_fn_376::(__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_279] = { let __args: [G; IN_279] = [__v_9, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(279, &__args[..])?) { [G::ZERO; OUT_279] } else { let (__hash, __hit) = record.function_queries[279].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[279].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[279].bump_multiplicity(__i); } let __ret: [G; OUT_279] = unsafe { *(record.function_queries[279].output_at(__i).as_ptr() as *const [G; OUT_279]) }; __ret }, _ => { aiur_fn_279::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_13, __v_14, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_374] = [__v_15]; record.function_queries[374].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_8, __v_7, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_10, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(374, &__args[..])?) { [G::ZERO; OUT_374] } else { let (__hash, __hit) = record.function_queries[374].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[374].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[374].bump_multiplicity(__i); } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => { aiur_fn_374::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_374] = [__v_11]; record.function_queries[374].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { match __v_6.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(481, &__args[..])?) { [G::ZERO; OUT_481] } else { let (__hash, __hit) = record.function_queries[481].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[481].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => { aiur_fn_481::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_9, __v_11, __v_13, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_374] = [__v_14]; record.function_queries[374].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(37); let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(482, &__args[..])?) { [G::ZERO; OUT_482] } else { let (__hash, __hit) = record.function_queries[482].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[482].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => { aiur_fn_482::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_9, __v_11, __v_13, __v_14]; let __mq = record.memory_queries.get_index_mut(2).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_374] = [__v_15]; record.function_queries[374].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, 8u64 => { let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_8, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(374, &__args[..])?) { [G::ZERO; OUT_374] } else { let (__hash, __hit) = record.function_queries[374].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[374].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[374].bump_multiplicity(__i); } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => { aiur_fn_374::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_9, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_10]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __idx = usize::try_from(__ptr_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() { 2u64 => { if (__v_14 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("projection's structure type differs from the value's head".to_string()) }); } let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; let __v_21: G = __loaded[3]; let __v_22: G = __loaded[4]; let __v_23: G = __loaded[5]; let __v_24: G = __loaded[6]; let __v_25: G = __loaded[7]; let __v_26: G = __loaded[8]; let __v_27: G = __loaded[9]; let __v_28: G = __loaded[10]; let __v_29: G = __loaded[11]; match __v_18.as_canonical_u64() { 5u64 => { let __v_30: G = G::from_u64(1); if (__v_23 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("projection on an inductive with more than one constructor".to_string()) }); } let __v_31: G = G::from_u64(0); let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_25, __v_26, __v_31]; 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_32: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_32.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].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]; match __v_33.as_canonical_u64() { 6u64 => { let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_35, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_45, __v_12, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(377, &__args[..])?) { [G::ZERO; OUT_377] } else { let (__hash, __hit) = record.function_queries[377].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[377].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => { aiur_fn_377::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = G::from_u64(0); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_46, __v_7, __v_47, __v_6, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(378, &__args[..])?) { [G::ZERO; OUT_378] } else { let (__hash, __hit) = record.function_queries[378].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[378].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[378].bump_multiplicity(__i); } let __ret: [G; OUT_378] = unsafe { *(record.function_queries[378].output_at(__i).as_ptr() as *const [G; OUT_378]) }; __ret }, _ => { aiur_fn_378::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __ret: [G; OUT_374] = [__v_48]; record.function_queries[374].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_33.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_375: usize = 3; -const IN_375: usize = 3; -const OUT_375: usize = 1; -fn aiur_fn_375(inp: [G; IN_375], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_375], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__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_4 + __v_8; let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_7, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_375] = [__v_11]; record.function_queries[375].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_280] = { let __args: [G; IN_280] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(280, &__args[..])?) { [G::ZERO; OUT_280] } else { let (__hash, __hit) = record.function_queries[280].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[280].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[280].bump_multiplicity(__i); } let __ret: [G; OUT_280] = unsafe { *(record.function_queries[280].output_at(__i).as_ptr() as *const [G; OUT_280]) }; __ret }, _ => { aiur_fn_280::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_7, __v_10, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_375] = [__v_11]; record.function_queries[375].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].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 __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(372, &__args[..])?) { [G::ZERO; OUT_372] } else { let (__hash, __hit) = record.function_queries[372].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[372].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => { aiur_fn_372::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(373, &__args[..])?) { [G::ZERO; OUT_373] } else { let (__hash, __hit) = record.function_queries[373].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[373].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[373].bump_multiplicity(__i); } let __ret: [G; OUT_373] = unsafe { *(record.function_queries[373].output_at(__i).as_ptr() as *const [G; OUT_373]) }; __ret }, _ => { aiur_fn_373::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_22, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_375] = [__v_23]; record.function_queries[375].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(374, &__args[..])?) { [G::ZERO; OUT_374] } else { let (__hash, __hit) = record.function_queries[374].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[374].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[374].bump_multiplicity(__i); } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => { aiur_fn_374::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 5u64 => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_10, __v_5, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_375] = [__v_13]; record.function_queries[375].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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() { 5u64 => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_15, __v_5, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_375] = [__v_18]; record.function_queries[375].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, } }, 4u64 => { let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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_374] = { let __args: [G; IN_374] = [__v_0, __v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(374, &__args[..])?) { [G::ZERO; OUT_374] } else { let (__hash, __hit) = record.function_queries[374].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[374].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[374].bump_multiplicity(__i); } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => { aiur_fn_374::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(5); let __v_11: G = { let __values: [G; 4] = [__v_10, __v_4, __v_9, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_375] = [__v_11]; record.function_queries[375].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(376, &__args[..])?) { [G::ZERO; OUT_376] } else { let (__hash, __hit) = record.function_queries[376].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[376].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => { aiur_fn_376::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_4, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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_376] = { let __args: [G; IN_376] = [__v_0, __v_5, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(376, &__args[..])?) { [G::ZERO; OUT_376] } else { let (__hash, __hit) = record.function_queries[376].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[376].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => { aiur_fn_376::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_7, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(279, &__args[..])?) { [G::ZERO; OUT_279] } else { let (__hash, __hit) = record.function_queries[279].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[279].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[279].bump_multiplicity(__i); } let __ret: [G; OUT_279] = unsafe { *(record.function_queries[279].output_at(__i).as_ptr() as *const [G; OUT_279]) }; __ret }, _ => { aiur_fn_279::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_11, __v_12, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_375] = [__v_13]; record.function_queries[375].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(374, &__args[..])?) { [G::ZERO; OUT_374] } else { let (__hash, __hit) = record.function_queries[374].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[374].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[374].bump_multiplicity(__i); } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => { aiur_fn_374::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_375] = [__v_9]; record.function_queries[375].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { match __v_4.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(481, &__args[..])?) { [G::ZERO; OUT_481] } else { let (__hash, __hit) = record.function_queries[481].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[481].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => { aiur_fn_481::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; 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(1).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; 4] = [__v_7, __v_9, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_375] = [__v_12]; record.function_queries[375].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(37); let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(482, &__args[..])?) { [G::ZERO; OUT_482] } else { let (__hash, __hit) = record.function_queries[482].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[482].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => { aiur_fn_482::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; 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(1).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 = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_9, __v_11, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_375] = [__v_13]; record.function_queries[375].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, 8u64 => { let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_6, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(374, &__args[..])?) { [G::ZERO; OUT_374] } else { let (__hash, __hit) = record.function_queries[374].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[374].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[374].bump_multiplicity(__i); } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => { aiur_fn_374::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { if (__v_12 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("projection's structure type differs from the value's head".to_string()) }); } let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; let __v_19: G = __loaded[3]; let __v_20: G = __loaded[4]; let __v_21: G = __loaded[5]; let __v_22: G = __loaded[6]; let __v_23: G = __loaded[7]; let __v_24: G = __loaded[8]; let __v_25: G = __loaded[9]; let __v_26: G = __loaded[10]; let __v_27: G = __loaded[11]; match __v_16.as_canonical_u64() { 5u64 => { let __v_28: G = G::from_u64(1); if (__v_21 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("projection on an inductive with more than one constructor".to_string()) }); } let __v_29: G = G::from_u64(0); let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_23, __v_24, __v_29]; 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_30: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; let __v_34: G = __loaded[3]; let __v_35: G = __loaded[4]; let __v_36: G = __loaded[5]; let __v_37: G = __loaded[6]; let __v_38: G = __loaded[7]; let __v_39: G = __loaded[8]; let __v_40: G = __loaded[9]; let __v_41: G = __loaded[10]; let __v_42: G = __loaded[11]; match __v_31.as_canonical_u64() { 6u64 => { let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_33, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_43, __v_10, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(377, &__args[..])?) { [G::ZERO; OUT_377] } else { let (__hash, __hit) = record.function_queries[377].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[377].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => { aiur_fn_377::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(0); let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_44, __v_5, __v_45, __v_4, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(378, &__args[..])?) { [G::ZERO; OUT_378] } else { let (__hash, __hit) = record.function_queries[378].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[378].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[378].bump_multiplicity(__i); } let __ret: [G; OUT_378] = unsafe { *(record.function_queries[378].output_at(__i).as_ptr() as *const [G; OUT_378]) }; __ret }, _ => { aiur_fn_378::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_375] = [__v_46]; record.function_queries[375].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_376: usize = 3; -const IN_376: usize = 3; -const OUT_376: usize = 1; -fn aiur_fn_376(inp: [G; IN_376], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_376], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_374] = { let __args: [G; IN_374] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(374, &__args[..])?) { [G::ZERO; OUT_374] } else { let (__hash, __hit) = record.function_queries[374].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[374].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[374].bump_multiplicity(__i); } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => { aiur_fn_374::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_376] = [__v_5]; record.function_queries[376].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __idx = usize::try_from(__ptr_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 __ret: [G; OUT_376] = [__v_10]; record.function_queries[376].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_377: usize = 3; -const IN_377: usize = 3; -const OUT_377: usize = 1; -fn aiur_fn_377(inp: [G; IN_377], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_377], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_377] = [__v_0]; record.function_queries[377].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 5u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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 __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__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_2 - __v_12; let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(377, &__args[..])?) { [G::ZERO; OUT_377] } else { let (__hash, __hit) = record.function_queries[377].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[377].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => { aiur_fn_377::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_377] = [__v_14]; record.function_queries[377].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_378: usize = 5; -const IN_378: usize = 5; -const OUT_378: usize = 1; -fn aiur_fn_378(inp: [G; IN_378], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_378], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(2).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() { 5u64 => { let __v_9: G = __v_1 - __v_2; match __v_9.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_378] = [__v_6]; record.function_queries[378].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(8); let __v_11: G = { let __values: [G; 4] = [__v_10, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(0); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = __v_2 + __v_14; let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(378, &__args[..])?) { [G::ZERO; OUT_378] } else { let (__hash, __hit) = record.function_queries[378].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[378].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[378].bump_multiplicity(__i); } let __ret: [G; OUT_378] = unsafe { *(record.function_queries[378].output_at(__i).as_ptr() as *const [G; OUT_378]) }; __ret }, _ => { aiur_fn_378::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_378] = [__v_16]; record.function_queries[378].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_379: usize = 2; -const IN_379: usize = 2; -const OUT_379: usize = 1; -fn aiur_fn_379(inp: [G; IN_379], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_379], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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(1).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() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_379] = [__v_8]; record.function_queries[379].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_379] = [__v_8]; record.function_queries[379].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(1).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() { 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_379] = [__v_8]; record.function_queries[379].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(271, &__args[..])?) { [G::ZERO; OUT_271] } else { let (__hash, __hit) = record.function_queries[271].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[271].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[271].bump_multiplicity(__i); } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => { aiur_fn_271::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_379] = [__v_9]; record.function_queries[379].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(379, &__args[..])?) { [G::ZERO; OUT_379] } else { let (__hash, __hit) = record.function_queries[379].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[379].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[379].bump_multiplicity(__i); } let __ret: [G; OUT_379] = unsafe { *(record.function_queries[379].output_at(__i).as_ptr() as *const [G; OUT_379]) }; __ret }, _ => { aiur_fn_379::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_379] = [__v_9]; record.function_queries[379].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_380: usize = 4; -const IN_380: usize = 4; -const OUT_380: usize = 1; -fn aiur_fn_380(inp: [G; IN_380], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_380], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_1 - __v_2; match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_380] = [__v_5]; record.function_queries[380].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(290, &__args[..])?) { [G::ZERO; OUT_290] } else { let (__hash, __hit) = record.function_queries[290].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[290].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => { aiur_fn_290::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_382] = { let __args: [G; IN_382] = [__v_0, __v_1, __v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(382, &__args[..])?) { [G::ZERO; OUT_382] } else { let (__hash, __hit) = record.function_queries[382].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[382].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[382].bump_multiplicity(__i); } let __ret: [G; OUT_382] = unsafe { *(record.function_queries[382].output_at(__i).as_ptr() as *const [G; OUT_382]) }; __ret }, _ => { aiur_fn_382::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_380] = [__v_10]; record.function_queries[380].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_0, __v_1, __v_2, __v_3, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(381, &__args[..])?) { [G::ZERO; OUT_381] } else { let (__hash, __hit) = record.function_queries[381].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[381].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[381].bump_multiplicity(__i); } let __ret: [G; OUT_381] = unsafe { *(record.function_queries[381].output_at(__i).as_ptr() as *const [G; OUT_381]) }; __ret }, _ => { aiur_fn_381::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_380] = [__v_8]; record.function_queries[380].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_381: usize = 5; -const IN_381: usize = 5; -const OUT_381: usize = 1; -fn aiur_fn_381(inp: [G; IN_381], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_381], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(302, &__args[..])?) { [G::ZERO; OUT_302] } else { let (__hash, __hit) = record.function_queries[302].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[302].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => { aiur_fn_302::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(302, &__args[..])?) { [G::ZERO; OUT_302] } else { let (__hash, __hit) = record.function_queries[302].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[302].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => { aiur_fn_302::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(292, &__args[..])?) { [G::ZERO; OUT_292] } else { let (__hash, __hit) = record.function_queries[292].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[292].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => { aiur_fn_292::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(292, &__args[..])?) { [G::ZERO; OUT_292] } else { let (__hash, __hit) = record.function_queries[292].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[292].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => { aiur_fn_292::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(301, &__args[..])?) { [G::ZERO; OUT_301] } else { let (__hash, __hit) = record.function_queries[301].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[301].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { *(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301]) }; __ret }, _ => { aiur_fn_301::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_1, __v_2, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(382, &__args[..])?) { [G::ZERO; OUT_382] } else { let (__hash, __hit) = record.function_queries[382].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[382].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[382].bump_multiplicity(__i); } let __ret: [G; OUT_382] = unsafe { *(record.function_queries[382].output_at(__i).as_ptr() as *const [G; OUT_382]) }; __ret }, _ => { aiur_fn_382::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_381] = [__v_12]; record.function_queries[381].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_1, __v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(310, &__args[..])?) { [G::ZERO; OUT_310] } else { let (__hash, __hit) = record.function_queries[310].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[310].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => { aiur_fn_310::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_2, __v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(310, &__args[..])?) { [G::ZERO; OUT_310] } else { let (__hash, __hit) = record.function_queries[310].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[310].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => { aiur_fn_310::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __v_4 - __v_10; let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(301, &__args[..])?) { [G::ZERO; OUT_301] } else { let (__hash, __hit) = record.function_queries[301].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[301].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { *(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301]) }; __ret }, _ => { aiur_fn_301::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_12, __v_13, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(382, &__args[..])?) { [G::ZERO; OUT_382] } else { let (__hash, __hit) = record.function_queries[382].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[382].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[382].bump_multiplicity(__i); } let __ret: [G; OUT_382] = unsafe { *(record.function_queries[382].output_at(__i).as_ptr() as *const [G; OUT_382]) }; __ret }, _ => { aiur_fn_382::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_381] = [__v_17]; record.function_queries[381].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_382: usize = 4; -const IN_382: usize = 4; -const OUT_382: usize = 1; -fn aiur_fn_382(inp: [G; IN_382], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_382], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(383, &__args[..])?) { [G::ZERO; OUT_383] } else { let (__hash, __hit) = record.function_queries[383].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[383].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[383].bump_multiplicity(__i); } let __ret: [G; OUT_383] = unsafe { *(record.function_queries[383].output_at(__i).as_ptr() as *const [G; OUT_383]) }; __ret }, _ => { aiur_fn_383::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_382] = [__v_5]; record.function_queries[382].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_2, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(383, &__args[..])?) { [G::ZERO; OUT_383] } else { let (__hash, __hit) = record.function_queries[383].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[383].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[383].bump_multiplicity(__i); } let __ret: [G; OUT_383] = unsafe { *(record.function_queries[383].output_at(__i).as_ptr() as *const [G; OUT_383]) }; __ret }, _ => { aiur_fn_383::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_382] = [__v_5]; record.function_queries[382].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_383: usize = 4; -const IN_383: usize = 4; -const OUT_383: usize = 1; -fn aiur_fn_383(inp: [G; IN_383], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_383], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_384] = { let __args: [G; IN_384] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(384, &__args[..])?) { [G::ZERO; OUT_384] } else { let (__hash, __hit) = record.function_queries[384].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[384].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[384].bump_multiplicity(__i); } let __ret: [G; OUT_384] = unsafe { *(record.function_queries[384].output_at(__i).as_ptr() as *const [G; OUT_384]) }; __ret }, _ => { aiur_fn_384::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_383] = [__v_5]; record.function_queries[383].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(391, &__args[..])?) { [G::ZERO; OUT_391] } else { let (__hash, __hit) = record.function_queries[391].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[391].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[391].bump_multiplicity(__i); } let __ret: [G; OUT_391] = unsafe { *(record.function_queries[391].output_at(__i).as_ptr() as *const [G; OUT_391]) }; __ret }, _ => { aiur_fn_391::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_383] = [__v_5]; record.function_queries[383].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_384: usize = 4; -const IN_384: usize = 4; -const OUT_384: usize = 1; -fn aiur_fn_384(inp: [G; IN_384], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_384], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_128] = { let __args: [G; IN_128] = [__v_1]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_2]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { let __v_16: G = __v_9 - __v_13; match __v_16.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_10, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(379, &__args[..])?) { [G::ZERO; OUT_379] } else { let (__hash, __hit) = record.function_queries[379].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[379].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[379].bump_multiplicity(__i); } let __ret: [G; OUT_379] = unsafe { *(record.function_queries[379].output_at(__i).as_ptr() as *const [G; OUT_379]) }; __ret }, _ => { aiur_fn_379::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 0u64 => { let __v_18: G = G::from_u64(0); let __ret: [G; OUT_384] = [__v_18]; record.function_queries[384].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __v_18 - __v_19; match __v_20.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_5, __v_7, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(385, &__args[..])?) { [G::ZERO; OUT_385] } else { let (__hash, __hit) = record.function_queries[385].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[385].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[385].bump_multiplicity(__i); } let __ret: [G; OUT_385] = unsafe { *(record.function_queries[385].output_at(__i).as_ptr() as *const [G; OUT_385]) }; __ret }, _ => { aiur_fn_385::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_384] = [__v_21]; record.function_queries[384].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_21: G = G::from_u64(0); let __ret: [G; OUT_384] = [__v_21]; record.function_queries[384].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_384] = [__v_17]; record.function_queries[384].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_384] = [__v_16]; record.function_queries[384].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_384] = [__v_12]; record.function_queries[384].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_385: usize = 4; -const IN_385: usize = 4; -const OUT_385: usize = 1; -fn aiur_fn_385(inp: [G; IN_385], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_385], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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 __v_10: G = G::from_u64(1); let __ret: [G; OUT_385] = [__v_10]; record.function_queries[385].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_385] = [__v_10]; record.function_queries[385].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(1).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 __v_10: G = G::from_u64(0); let __ret: [G; OUT_385] = [__v_10]; record.function_queries[385].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_5, __v_8, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_385] = [__v_11]; record.function_queries[385].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_6, __v_9, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(385, &__args[..])?) { [G::ZERO; OUT_385] } else { let (__hash, __hit) = record.function_queries[385].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[385].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[385].bump_multiplicity(__i); } let __ret: [G; OUT_385] = unsafe { *(record.function_queries[385].output_at(__i).as_ptr() as *const [G; OUT_385]) }; __ret }, _ => { aiur_fn_385::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_385] = [__v_11]; record.function_queries[385].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_386: usize = 2; -const IN_386: usize = 2; -const OUT_386: usize = 1; -fn aiur_fn_386(inp: [G; IN_386], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_386], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(2).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_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 7u64 => { match __v_3.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_4]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_386] = [__v_6]; record.function_queries[386].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_386] = [__v_6]; record.function_queries[386].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __v_6: G = G::from_u64(1); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(480, &__args[..])?) { [G::ZERO; OUT_480] } else { let (__hash, __hit) = record.function_queries[480].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[480].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => { aiur_fn_480::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_386] = [__v_7]; record.function_queries[386].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_386] = [__v_6]; record.function_queries[386].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_387: usize = 2; -const IN_387: usize = 2; -const OUT_387: usize = 3; -fn aiur_fn_387(inp: [G; IN_387], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_387], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(2).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_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 7u64 => { match __v_3.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 10] = [__v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(7).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_191] = { let __args: [G; IN_191] = [__v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_387] = [__v_6, __v_8, __v_4]; record.function_queries[387].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 = { let __values: [G; 10] = [__v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(7).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_387] = [__v_6, __v_1, __v_8]; record.function_queries[387].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 3u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { let __v_10: G = G::from_u64(2); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_7, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(480, &__args[..])?) { [G::ZERO; OUT_480] } else { let (__hash, __hit) = record.function_queries[480].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[480].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => { aiur_fn_480::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(387, &__args[..])?) { [G::ZERO; OUT_387] } else { let (__hash, __hit) = record.function_queries[387].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[387].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => { aiur_fn_387::(__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 = G::from_u64(1); let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_387] = [__v_15, __v_13, __v_16]; record.function_queries[387].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__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(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_387] = [__v_12, __v_1, __v_14]; record.function_queries[387].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 3u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 2u64 => { let __v_14: G = G::from_u64(42); let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_11, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(480, &__args[..])?) { [G::ZERO; OUT_480] } else { let (__hash, __hit) = record.function_queries[480].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[480].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => { aiur_fn_480::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; let __v_19: G = __loaded[3]; match __v_16.as_canonical_u64() { 7u64 => { match __v_17.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(387, &__args[..])?) { [G::ZERO; OUT_387] } else { let (__hash, __hit) = record.function_queries[387].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[387].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => { aiur_fn_387::(__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]; match __v_20.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_22, __v_18]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_387] = [__v_23, __v_21, __v_24]; record.function_queries[387].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(1); let __ret: [G; OUT_387] = [__v_23, __v_8, __v_18]; record.function_queries[387].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_index_mut(7).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_387] = [__v_20, __v_1, __v_22]; record.function_queries[387].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_index_mut(7).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_387] = [__v_20, __v_1, __v_22]; record.function_queries[387].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 10] = [__v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_index_mut(7).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_387] = [__v_16, __v_1, __v_18]; record.function_queries[387].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 10] = [__v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(7).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_387] = [__v_14, __v_1, __v_16]; record.function_queries[387].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 10] = [__v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(7).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_387] = [__v_10, __v_1, __v_12]; record.function_queries[387].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 = { let __values: [G; 10] = [__v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(7).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_387] = [__v_6, __v_1, __v_8]; record.function_queries[387].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_388: usize = 4; -const IN_388: usize = 4; -const OUT_388: usize = 2; -fn aiur_fn_388(inp: [G; IN_388], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_388], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_386] = { let __args: [G; IN_386] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(386, &__args[..])?) { [G::ZERO; OUT_386] } else { let (__hash, __hit) = record.function_queries[386].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[386].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[386].bump_multiplicity(__i); } let __ret: [G; OUT_386] = unsafe { *(record.function_queries[386].output_at(__i).as_ptr() as *const [G; OUT_386]) }; __ret }, _ => { aiur_fn_386::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(386, &__args[..])?) { [G::ZERO; OUT_386] } else { let (__hash, __hit) = record.function_queries[386].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[386].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[386].bump_multiplicity(__i); } let __ret: [G; OUT_386] = unsafe { *(record.function_queries[386].output_at(__i).as_ptr() as *const [G; OUT_386]) }; __ret }, _ => { aiur_fn_386::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __v_4 * __v_5; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_388] = [__v_7, __v_7]; record.function_queries[388].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(387, &__args[..])?) { [G::ZERO; OUT_387] } else { let (__hash, __hit) = record.function_queries[387].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[387].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => { aiur_fn_387::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(387, &__args[..])?) { [G::ZERO; OUT_387] } else { let (__hash, __hit) = record.function_queries[387].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[387].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => { aiur_fn_387::(__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 = __v_7 * __v_10; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_388] = [__v_14, __v_14]; record.function_queries[388].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_9, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(285, &__args[..])?) { [G::ZERO; OUT_285] } else { let (__hash, __hit) = record.function_queries[285].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[285].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[285].bump_multiplicity(__i); } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => { aiur_fn_285::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_388] = [__v_15, __v_15]; record.function_queries[388].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_8, __v_11, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_388] = [__v_15, __v_16]; record.function_queries[388].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_389: usize = 4; -const IN_389: usize = 4; -const OUT_389: usize = 1; -fn aiur_fn_389(inp: [G; IN_389], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_389], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_390] = { let __args: [G; IN_390] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(390, &__args[..])?) { [G::ZERO; OUT_390] } else { let (__hash, __hit) = record.function_queries[390].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[390].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[390].bump_multiplicity(__i); } let __ret: [G; OUT_390] = unsafe { *(record.function_queries[390].output_at(__i).as_ptr() as *const [G; OUT_390]) }; __ret }, _ => { aiur_fn_390::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_389] = [__v_5]; record.function_queries[389].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_0, __v_2, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(390, &__args[..])?) { [G::ZERO; OUT_390] } else { let (__hash, __hit) = record.function_queries[390].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[390].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[390].bump_multiplicity(__i); } let __ret: [G; OUT_390] = unsafe { *(record.function_queries[390].output_at(__i).as_ptr() as *const [G; OUT_390]) }; __ret }, _ => { aiur_fn_390::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_389] = [__v_5]; record.function_queries[389].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_390: usize = 4; -const IN_390: usize = 4; -const OUT_390: usize = 1; -fn aiur_fn_390(inp: [G; IN_390], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_390], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 7u64 => { match __v_5.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_6]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_0, __v_8, __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_9: G = __r_arr[0]; let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_9, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_390] = [__v_10]; record.function_queries[390].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_390] = [__v_8]; record.function_queries[390].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_390] = [__v_8]; record.function_queries[390].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_391: usize = 4; -const IN_391: usize = 4; -const OUT_391: usize = 1; -fn aiur_fn_391(inp: [G; IN_391], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_391], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_390] = { let __args: [G; IN_390] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(390, &__args[..])?) { [G::ZERO; OUT_390] } else { let (__hash, __hit) = record.function_queries[390].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[390].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[390].bump_multiplicity(__i); } let __ret: [G; OUT_390] = unsafe { *(record.function_queries[390].output_at(__i).as_ptr() as *const [G; OUT_390]) }; __ret }, _ => { aiur_fn_390::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); break '__mc_0 [__v_5]; }, _ => { let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_0, __v_2, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(390, &__args[..])?) { [G::ZERO; OUT_390] } else { let (__hash, __hit) = record.function_queries[390].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[390].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[390].bump_multiplicity(__i); } let __ret: [G; OUT_390] = unsafe { *(record.function_queries[390].output_at(__i).as_ptr() as *const [G; OUT_390]) }; __ret }, _ => { aiur_fn_390::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; break '__mc_0 [__v_5]; }, } }; let __v_5: G = __mc_out___mc_0[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_391] = [__v_6]; record.function_queries[391].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(392, &__args[..])?) { [G::ZERO; OUT_392] } else { let (__hash, __hit) = record.function_queries[392].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[392].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[392].bump_multiplicity(__i); } let __ret: [G; OUT_392] = unsafe { *(record.function_queries[392].output_at(__i).as_ptr() as *const [G; OUT_392]) }; __ret }, _ => { aiur_fn_392::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_391] = [__v_6]; record.function_queries[391].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_392: usize = 4; -const IN_392: usize = 4; -const OUT_392: usize = 1; -fn aiur_fn_392(inp: [G; IN_392], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_392], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_361] = { let __args: [G; IN_361] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(361, &__args[..])?) { [G::ZERO; OUT_361] } else { let (__hash, __hit) = record.function_queries[361].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[361].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[361].bump_multiplicity(__i); } let __ret: [G; OUT_361] = unsafe { *(record.function_queries[361].output_at(__i).as_ptr() as *const [G; OUT_361]) }; __ret }, _ => { aiur_fn_361::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(361, &__args[..])?) { [G::ZERO; OUT_361] } else { let (__hash, __hit) = record.function_queries[361].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[361].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[361].bump_multiplicity(__i); } let __ret: [G; OUT_361] = unsafe { *(record.function_queries[361].output_at(__i).as_ptr() as *const [G; OUT_361]) }; __ret }, _ => { aiur_fn_361::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __v_4 - __v_5; match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_392] = [__v_7]; record.function_queries[392].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_0, __v_4, __v_5, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(394, &__args[..])?) { [G::ZERO; OUT_394] } else { let (__hash, __hit) = record.function_queries[394].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[394].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[394].bump_multiplicity(__i); } let __ret: [G; OUT_394] = unsafe { *(record.function_queries[394].output_at(__i).as_ptr() as *const [G; OUT_394]) }; __ret }, _ => { aiur_fn_394::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_392] = [__v_8]; record.function_queries[392].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_4, __v_5, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(384, &__args[..])?) { [G::ZERO; OUT_384] } else { let (__hash, __hit) = record.function_queries[384].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[384].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[384].bump_multiplicity(__i); } let __ret: [G; OUT_384] = unsafe { *(record.function_queries[384].output_at(__i).as_ptr() as *const [G; OUT_384]) }; __ret }, _ => { aiur_fn_384::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_392] = [__v_9]; record.function_queries[392].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_1, __v_2, __v_4, __v_5, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(393, &__args[..])?) { [G::ZERO; OUT_393] } else { let (__hash, __hit) = record.function_queries[393].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[393].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[393].bump_multiplicity(__i); } let __ret: [G; OUT_393] = unsafe { *(record.function_queries[393].output_at(__i).as_ptr() as *const [G; OUT_393]) }; __ret }, _ => { aiur_fn_393::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_392] = [__v_9]; record.function_queries[392].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_393: usize = 6; -const IN_393: usize = 6; -const OUT_393: usize = 1; -fn aiur_fn_393(inp: [G; IN_393], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_393], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_365] = { let __args: [G; IN_365] = [__v_0, __v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(365, &__args[..])?) { [G::ZERO; OUT_365] } else { let (__hash, __hit) = record.function_queries[365].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[365].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => { aiur_fn_365::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(365, &__args[..])?) { [G::ZERO; OUT_365] } else { let (__hash, __hit) = record.function_queries[365].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[365].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => { aiur_fn_365::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __v_6 - __v_7; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_393] = [__v_9]; record.function_queries[393].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_0, __v_6, __v_7, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(394, &__args[..])?) { [G::ZERO; OUT_394] } else { let (__hash, __hit) = record.function_queries[394].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[394].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[394].bump_multiplicity(__i); } let __ret: [G; OUT_394] = unsafe { *(record.function_queries[394].output_at(__i).as_ptr() as *const [G; OUT_394]) }; __ret }, _ => { aiur_fn_394::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_393] = [__v_10]; record.function_queries[393].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_6, __v_7, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(384, &__args[..])?) { [G::ZERO; OUT_384] } else { let (__hash, __hit) = record.function_queries[384].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[384].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[384].bump_multiplicity(__i); } let __ret: [G; OUT_384] = unsafe { *(record.function_queries[384].output_at(__i).as_ptr() as *const [G; OUT_384]) }; __ret }, _ => { aiur_fn_384::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __ret: [G; OUT_393] = [__v_11]; record.function_queries[393].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(395, &__args[..])?) { [G::ZERO; OUT_395] } else { let (__hash, __hit) = record.function_queries[395].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[395].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[395].bump_multiplicity(__i); } let __ret: [G; OUT_395] = unsafe { *(record.function_queries[395].output_at(__i).as_ptr() as *const [G; OUT_395]) }; __ret }, _ => { aiur_fn_395::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_393] = [__v_11]; record.function_queries[393].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_394: usize = 4; -const IN_394: usize = 4; -const OUT_394: usize = 1; -fn aiur_fn_394(inp: [G; IN_394], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_394], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 1u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_5, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(271, &__args[..])?) { [G::ZERO; OUT_271] } else { let (__hash, __hit) = record.function_queries[271].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[271].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[271].bump_multiplicity(__i); } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => { aiur_fn_271::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_394] = [__v_12]; record.function_queries[394].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_394] = [__v_12]; record.function_queries[394].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 4u64 => { let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_5, __v_9, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_380] = { let __args: [G; IN_380] = [__v_0, __v_6, __v_10, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_394] = [__v_15]; record.function_queries[394].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_394] = [__v_13]; record.function_queries[394].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_394] = [__v_12]; record.function_queries[394].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 5u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_5, __v_9, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_380] = { let __args: [G; IN_380] = [__v_0, __v_6, __v_10, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_394] = [__v_15]; record.function_queries[394].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_394] = [__v_13]; record.function_queries[394].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_394] = [__v_12]; record.function_queries[394].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_394] = [__v_8]; record.function_queries[394].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_395: usize = 6; -const IN_395: usize = 6; -const OUT_395: usize = 1; -fn aiur_fn_395(inp: [G; IN_395], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_395], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_3 - __v_4; match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_395] = [__v_7]; record.function_queries[395].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_3, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(409, &__args[..])?) { [G::ZERO; OUT_409] } else { let (__hash, __hit) = record.function_queries[409].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[409].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[409].bump_multiplicity(__i); } let __ret: [G; OUT_409] = unsafe { *(record.function_queries[409].output_at(__i).as_ptr() as *const [G; OUT_409]) }; __ret }, _ => { aiur_fn_409::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_395] = [__v_8]; record.function_queries[395].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_0, __v_3, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(407, &__args[..])?) { [G::ZERO; OUT_407] } else { let (__hash, __hit) = record.function_queries[407].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[407].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[407].bump_multiplicity(__i); } let __ret: [G; OUT_407] = unsafe { *(record.function_queries[407].output_at(__i).as_ptr() as *const [G; OUT_407]) }; __ret }, _ => { aiur_fn_407::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_395] = [__v_9]; record.function_queries[395].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_0, __v_3, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(403, &__args[..])?) { [G::ZERO; OUT_403] } else { let (__hash, __hit) = record.function_queries[403].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[403].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[403].bump_multiplicity(__i); } let __ret: [G; OUT_403] = unsafe { *(record.function_queries[403].output_at(__i).as_ptr() as *const [G; OUT_403]) }; __ret }, _ => { aiur_fn_403::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_395] = [__v_10]; record.function_queries[395].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_0, __v_4, __v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(403, &__args[..])?) { [G::ZERO; OUT_403] } else { let (__hash, __hit) = record.function_queries[403].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[403].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[403].bump_multiplicity(__i); } let __ret: [G; OUT_403] = unsafe { *(record.function_queries[403].output_at(__i).as_ptr() as *const [G; OUT_403]) }; __ret }, _ => { aiur_fn_403::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __ret: [G; OUT_395] = [__v_11]; record.function_queries[395].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_3, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(388, &__args[..])?) { [G::ZERO; OUT_388] } else { let (__hash, __hit) = record.function_queries[388].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[388].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[388].bump_multiplicity(__i); } let __ret: [G; OUT_388] = unsafe { *(record.function_queries[388].output_at(__i).as_ptr() as *const [G; OUT_388]) }; __ret }, _ => { aiur_fn_388::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_395] = [__v_12]; record.function_queries[395].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(16); let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_3, __v_4, __v_13, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(414, &__args[..])?) { [G::ZERO; OUT_414] } else { let (__hash, __hit) = record.function_queries[414].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[414].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[414].bump_multiplicity(__i); } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => { aiur_fn_414::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); let __ret: [G; OUT_395] = [__v_17]; record.function_queries[395].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0, __v_1, __v_2, __v_15, __v_16, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(396, &__args[..])?) { [G::ZERO; OUT_396] } else { let (__hash, __hit) = record.function_queries[396].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[396].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[396].bump_multiplicity(__i); } let __ret: [G; OUT_396] = unsafe { *(record.function_queries[396].output_at(__i).as_ptr() as *const [G; OUT_396]) }; __ret }, _ => { aiur_fn_396::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_395] = [__v_17]; record.function_queries[395].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }, } }) } -const INPUT_SIZE_396: usize = 6; -const IN_396: usize = 6; -const OUT_396: usize = 1; -fn aiur_fn_396(inp: [G; IN_396], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_396], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(8); let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __v_3, __v_4, __v_6, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(400, &__args[..])?) { [G::ZERO; OUT_400] } else { let (__hash, __hit) = record.function_queries[400].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[400].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[400].bump_multiplicity(__i); } let __ret: [G; OUT_400] = unsafe { *(record.function_queries[400].output_at(__i).as_ptr() as *const [G; OUT_400]) }; __ret }, _ => { aiur_fn_400::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_396] = [__v_9]; record.function_queries[396].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_3, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(398, &__args[..])?) { [G::ZERO; OUT_398] } else { let (__hash, __hit) = record.function_queries[398].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[398].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[398].bump_multiplicity(__i); } let __ret: [G; OUT_398] = unsafe { *(record.function_queries[398].output_at(__i).as_ptr() as *const [G; OUT_398]) }; __ret }, _ => { aiur_fn_398::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_396] = [__v_10]; record.function_queries[396].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(402, &__args[..])?) { [G::ZERO; OUT_402] } else { let (__hash, __hit) = record.function_queries[402].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[402].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[402].bump_multiplicity(__i); } let __ret: [G; OUT_402] = unsafe { *(record.function_queries[402].output_at(__i).as_ptr() as *const [G; OUT_402]) }; __ret }, _ => { aiur_fn_402::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_396] = [__v_10]; record.function_queries[396].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_397: usize = 4; -const IN_397: usize = 4; -const OUT_397: usize = 1; -fn aiur_fn_397(inp: [G; IN_397], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_397], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_128] = { let __args: [G; IN_128] = [__v_1]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_2]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_397] = [__v_9]; record.function_queries[397].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __v_9 - __v_10; match __v_11.as_canonical_u64() { 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 8u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; let __v_19: G = __loaded[3]; match __v_16.as_canonical_u64() { 8u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_13, __v_17]; 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_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { let __v_21: G = __v_14 - __v_18; match __v_21.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_15, __v_19, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_5, __v_7, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(385, &__args[..])?) { [G::ZERO; OUT_385] } else { let (__hash, __hit) = record.function_queries[385].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[385].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[385].bump_multiplicity(__i); } let __ret: [G; OUT_385] = unsafe { *(record.function_queries[385].output_at(__i).as_ptr() as *const [G; OUT_385]) }; __ret }, _ => { aiur_fn_385::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_397] = [__v_23]; record.function_queries[397].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(0); let __ret: [G; OUT_397] = [__v_23]; record.function_queries[397].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_397] = [__v_22]; record.function_queries[397].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_21: G = G::from_u64(0); let __ret: [G; OUT_397] = [__v_21]; record.function_queries[397].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_397] = [__v_20]; record.function_queries[397].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_397] = [__v_16]; record.function_queries[397].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_397] = [__v_12]; record.function_queries[397].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_398: usize = 4; -const IN_398: usize = 4; -const OUT_398: usize = 1; -fn aiur_fn_398(inp: [G; IN_398], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_398], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(8); let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(400, &__args[..])?) { [G::ZERO; OUT_400] } else { let (__hash, __hit) = record.function_queries[400].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[400].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[400].bump_multiplicity(__i); } let __ret: [G; OUT_400] = unsafe { *(record.function_queries[400].output_at(__i).as_ptr() as *const [G; OUT_400]) }; __ret }, _ => { aiur_fn_400::(__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() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_398] = [__v_7]; record.function_queries[398].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(397, &__args[..])?) { [G::ZERO; OUT_397] } else { let (__hash, __hit) = record.function_queries[397].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[397].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[397].bump_multiplicity(__i); } let __ret: [G; OUT_397] = unsafe { *(record.function_queries[397].output_at(__i).as_ptr() as *const [G; OUT_397]) }; __ret }, _ => { aiur_fn_397::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_398] = [__v_8]; record.function_queries[398].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(399, &__args[..])?) { [G::ZERO; OUT_399] } else { let (__hash, __hit) = record.function_queries[399].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[399].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[399].bump_multiplicity(__i); } let __ret: [G; OUT_399] = unsafe { *(record.function_queries[399].output_at(__i).as_ptr() as *const [G; OUT_399]) }; __ret }, _ => { aiur_fn_399::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_398] = [__v_8]; record.function_queries[398].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_399: usize = 4; -const IN_399: usize = 4; -const OUT_399: usize = 1; -fn aiur_fn_399(inp: [G; IN_399], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_399], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 3u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 3u64 => { let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_5, __v_9, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(398, &__args[..])?) { [G::ZERO; OUT_398] } else { let (__hash, __hit) = record.function_queries[398].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[398].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[398].bump_multiplicity(__i); } let __ret: [G; OUT_398] = unsafe { *(record.function_queries[398].output_at(__i).as_ptr() as *const [G; OUT_398]) }; __ret }, _ => { aiur_fn_398::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_6, __v_10, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(398, &__args[..])?) { [G::ZERO; OUT_398] } else { let (__hash, __hit) = record.function_queries[398].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[398].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[398].bump_multiplicity(__i); } let __ret: [G; OUT_398] = unsafe { *(record.function_queries[398].output_at(__i).as_ptr() as *const [G; OUT_398]) }; __ret }, _ => { aiur_fn_398::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_399] = [__v_13]; record.function_queries[399].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_399] = [__v_13]; record.function_queries[399].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_399] = [__v_12]; record.function_queries[399].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_399] = [__v_8]; record.function_queries[399].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_400: usize = 5; -const IN_400: usize = 5; -const OUT_400: usize = 2; -fn aiur_fn_400(inp: [G; IN_400], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_400], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = __v_1 - __v_2; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_400] = [__v_6, __v_3]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 0u64 => { let __v_14: G = __v_7 - __v_11; match __v_14.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(1); let __ret: [G; OUT_400] = [__v_15, __v_3]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_400] = [__v_15, __v_3]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(401, &__args[..])?) { [G::ZERO; OUT_401] } else { let (__hash, __hit) = record.function_queries[401].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[401].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[401].bump_multiplicity(__i); } let __ret: [G; OUT_401] = unsafe { *(record.function_queries[401].output_at(__i).as_ptr() as *const [G; OUT_401]) }; __ret }, _ => { aiur_fn_401::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_400] = [__v_14, __v_15]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 1u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_7, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(271, &__args[..])?) { [G::ZERO; OUT_271] } else { let (__hash, __hit) = record.function_queries[271].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[271].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[271].bump_multiplicity(__i); } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => { aiur_fn_271::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_400] = [__v_14, __v_3]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(401, &__args[..])?) { [G::ZERO; OUT_401] } else { let (__hash, __hit) = record.function_queries[401].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[401].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[401].bump_multiplicity(__i); } let __ret: [G; OUT_401] = unsafe { *(record.function_queries[401].output_at(__i).as_ptr() as *const [G; OUT_401]) }; __ret }, _ => { aiur_fn_401::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_400] = [__v_14, __v_15]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_11]; 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_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_8, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(379, &__args[..])?) { [G::ZERO; OUT_379] } else { let (__hash, __hit) = record.function_queries[379].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[379].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[379].bump_multiplicity(__i); } let __ret: [G; OUT_379] = unsafe { *(record.function_queries[379].output_at(__i).as_ptr() as *const [G; OUT_379]) }; __ret }, _ => { aiur_fn_379::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_400] = [__v_15, __v_3]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(401, &__args[..])?) { [G::ZERO; OUT_401] } else { let (__hash, __hit) = record.function_queries[401].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[401].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[401].bump_multiplicity(__i); } let __ret: [G; OUT_401] = unsafe { *(record.function_queries[401].output_at(__i).as_ptr() as *const [G; OUT_401]) }; __ret }, _ => { aiur_fn_401::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_400] = [__v_15, __v_16]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(401, &__args[..])?) { [G::ZERO; OUT_401] } else { let (__hash, __hit) = record.function_queries[401].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[401].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[401].bump_multiplicity(__i); } let __ret: [G; OUT_401] = unsafe { *(record.function_queries[401].output_at(__i).as_ptr() as *const [G; OUT_401]) }; __ret }, _ => { aiur_fn_401::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_400] = [__v_14, __v_15]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 3u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 3u64 => { let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __v_7, __v_11, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(400, &__args[..])?) { [G::ZERO; OUT_400] } else { let (__hash, __hit) = record.function_queries[400].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[400].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[400].bump_multiplicity(__i); } let __ret: [G; OUT_400] = unsafe { *(record.function_queries[400].output_at(__i).as_ptr() as *const [G; OUT_400]) }; __ret }, _ => { aiur_fn_400::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __v_8, __v_12, __v_15, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(400, &__args[..])?) { [G::ZERO; OUT_400] } else { let (__hash, __hit) = record.function_queries[400].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[400].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[400].bump_multiplicity(__i); } let __ret: [G; OUT_400] = unsafe { *(record.function_queries[400].output_at(__i).as_ptr() as *const [G; OUT_400]) }; __ret }, _ => { aiur_fn_400::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_400] = [__v_16, __v_17]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_400] = [__v_16, __v_15]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(401, &__args[..])?) { [G::ZERO; OUT_401] } else { let (__hash, __hit) = record.function_queries[401].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[401].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[401].bump_multiplicity(__i); } let __ret: [G; OUT_401] = unsafe { *(record.function_queries[401].output_at(__i).as_ptr() as *const [G; OUT_401]) }; __ret }, _ => { aiur_fn_401::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_400] = [__v_14, __v_15]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 4u64 => { let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __v_7, __v_11, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(400, &__args[..])?) { [G::ZERO; OUT_400] } else { let (__hash, __hit) = record.function_queries[400].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[400].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[400].bump_multiplicity(__i); } let __ret: [G; OUT_400] = unsafe { *(record.function_queries[400].output_at(__i).as_ptr() as *const [G; OUT_400]) }; __ret }, _ => { aiur_fn_400::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_400] = { let __args: [G; IN_400] = [__v_0, __v_8, __v_12, __v_15, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(400, &__args[..])?) { [G::ZERO; OUT_400] } else { let (__hash, __hit) = record.function_queries[400].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[400].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[400].bump_multiplicity(__i); } let __ret: [G; OUT_400] = unsafe { *(record.function_queries[400].output_at(__i).as_ptr() as *const [G; OUT_400]) }; __ret }, _ => { aiur_fn_400::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __ret: [G; OUT_400] = [__v_18, __v_19]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_400] = [__v_16, __v_15]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(401, &__args[..])?) { [G::ZERO; OUT_401] } else { let (__hash, __hit) = record.function_queries[401].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[401].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[401].bump_multiplicity(__i); } let __ret: [G; OUT_401] = unsafe { *(record.function_queries[401].output_at(__i).as_ptr() as *const [G; OUT_401]) }; __ret }, _ => { aiur_fn_401::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_400] = [__v_14, __v_15]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 5u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __v_7, __v_11, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(400, &__args[..])?) { [G::ZERO; OUT_400] } else { let (__hash, __hit) = record.function_queries[400].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[400].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[400].bump_multiplicity(__i); } let __ret: [G; OUT_400] = unsafe { *(record.function_queries[400].output_at(__i).as_ptr() as *const [G; OUT_400]) }; __ret }, _ => { aiur_fn_400::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_400] = { let __args: [G; IN_400] = [__v_0, __v_8, __v_12, __v_15, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(400, &__args[..])?) { [G::ZERO; OUT_400] } else { let (__hash, __hit) = record.function_queries[400].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[400].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[400].bump_multiplicity(__i); } let __ret: [G; OUT_400] = unsafe { *(record.function_queries[400].output_at(__i).as_ptr() as *const [G; OUT_400]) }; __ret }, _ => { aiur_fn_400::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __ret: [G; OUT_400] = [__v_18, __v_19]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_400] = [__v_16, __v_15]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(401, &__args[..])?) { [G::ZERO; OUT_401] } else { let (__hash, __hit) = record.function_queries[401].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[401].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[401].bump_multiplicity(__i); } let __ret: [G; OUT_401] = unsafe { *(record.function_queries[401].output_at(__i).as_ptr() as *const [G; OUT_401]) }; __ret }, _ => { aiur_fn_401::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_400] = [__v_14, __v_15]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 7u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 7u64 => { let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_7, __v_8, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(287, &__args[..])?) { [G::ZERO; OUT_287] } else { let (__hash, __hit) = record.function_queries[287].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[287].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => { aiur_fn_287::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_400] = [__v_14, __v_3]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(401, &__args[..])?) { [G::ZERO; OUT_401] } else { let (__hash, __hit) = record.function_queries[401].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[401].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[401].bump_multiplicity(__i); } let __ret: [G; OUT_401] = unsafe { *(record.function_queries[401].output_at(__i).as_ptr() as *const [G; OUT_401]) }; __ret }, _ => { aiur_fn_401::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_400] = [__v_14, __v_15]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 8u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 8u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_11]; 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_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = __v_8 - __v_12; match __v_15.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __v_9, __v_13, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(400, &__args[..])?) { [G::ZERO; OUT_400] } else { let (__hash, __hit) = record.function_queries[400].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[400].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[400].bump_multiplicity(__i); } let __ret: [G; OUT_400] = unsafe { *(record.function_queries[400].output_at(__i).as_ptr() as *const [G; OUT_400]) }; __ret }, _ => { aiur_fn_400::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_400] = [__v_16, __v_17]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_400] = [__v_16, __v_3]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(401, &__args[..])?) { [G::ZERO; OUT_401] } else { let (__hash, __hit) = record.function_queries[401].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[401].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[401].bump_multiplicity(__i); } let __ret: [G; OUT_401] = unsafe { *(record.function_queries[401].output_at(__i).as_ptr() as *const [G; OUT_401]) }; __ret }, _ => { aiur_fn_401::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_400] = [__v_15, __v_16]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(401, &__args[..])?) { [G::ZERO; OUT_401] } else { let (__hash, __hit) = record.function_queries[401].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[401].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[401].bump_multiplicity(__i); } let __ret: [G; OUT_401] = unsafe { *(record.function_queries[401].output_at(__i).as_ptr() as *const [G; OUT_401]) }; __ret }, _ => { aiur_fn_401::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_400] = [__v_14, __v_15]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(401, &__args[..])?) { [G::ZERO; OUT_401] } else { let (__hash, __hit) = record.function_queries[401].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[401].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[401].bump_multiplicity(__i); } let __ret: [G; OUT_401] = unsafe { *(record.function_queries[401].output_at(__i).as_ptr() as *const [G; OUT_401]) }; __ret }, _ => { aiur_fn_401::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_400] = [__v_10, __v_11]; record.function_queries[400].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_401: usize = 5; -const IN_401: usize = 5; -const OUT_401: usize = 2; -fn aiur_fn_401(inp: [G; IN_401], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_401], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(0); let __ret: [G; OUT_401] = [__v_5, __v_5]; record.function_queries[401].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(1); let __v_6: G = __v_3 - __v_5; let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(365, &__args[..])?) { [G::ZERO; OUT_365] } else { let (__hash, __hit) = record.function_queries[365].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[365].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => { aiur_fn_365::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(365, &__args[..])?) { [G::ZERO; OUT_365] } else { let (__hash, __hit) = record.function_queries[365].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[365].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => { aiur_fn_365::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __v_7 - __v_8; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_401] = [__v_10, __v_6]; record.function_queries[401].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_7, __v_8, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(388, &__args[..])?) { [G::ZERO; OUT_388] } else { let (__hash, __hit) = record.function_queries[388].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[388].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[388].bump_multiplicity(__i); } let __ret: [G; OUT_388] = unsafe { *(record.function_queries[388].output_at(__i).as_ptr() as *const [G; OUT_388]) }; __ret }, _ => { aiur_fn_388::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_401] = [__v_11, __v_6]; record.function_queries[401].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(8); let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_7, __v_8, __v_12, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(414, &__args[..])?) { [G::ZERO; OUT_414] } else { let (__hash, __hit) = record.function_queries[414].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[414].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[414].bump_multiplicity(__i); } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => { aiur_fn_414::(__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]; match __v_13.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); let __ret: [G; OUT_401] = [__v_16, __v_6]; record.function_queries[401].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __v_14, __v_15, __v_6, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(400, &__args[..])?) { [G::ZERO; OUT_400] } else { let (__hash, __hit) = record.function_queries[400].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[400].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[400].bump_multiplicity(__i); } let __ret: [G; OUT_400] = unsafe { *(record.function_queries[400].output_at(__i).as_ptr() as *const [G; OUT_400]) }; __ret }, _ => { aiur_fn_400::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_401] = [__v_16, __v_17]; record.function_queries[401].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, } }) } -const INPUT_SIZE_402: usize = 4; -const IN_402: usize = 4; -const OUT_402: usize = 1; -fn aiur_fn_402(inp: [G; IN_402], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_402], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __v_4 - __v_5; match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_402] = [__v_7]; record.function_queries[402].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_4, __v_5, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(409, &__args[..])?) { [G::ZERO; OUT_409] } else { let (__hash, __hit) = record.function_queries[409].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[409].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[409].bump_multiplicity(__i); } let __ret: [G; OUT_409] = unsafe { *(record.function_queries[409].output_at(__i).as_ptr() as *const [G; OUT_409]) }; __ret }, _ => { aiur_fn_409::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_402] = [__v_8]; record.function_queries[402].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_0, __v_4, __v_5, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(407, &__args[..])?) { [G::ZERO; OUT_407] } else { let (__hash, __hit) = record.function_queries[407].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[407].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[407].bump_multiplicity(__i); } let __ret: [G; OUT_407] = unsafe { *(record.function_queries[407].output_at(__i).as_ptr() as *const [G; OUT_407]) }; __ret }, _ => { aiur_fn_407::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_402] = [__v_9]; record.function_queries[402].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_0, __v_4, __v_5, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(403, &__args[..])?) { [G::ZERO; OUT_403] } else { let (__hash, __hit) = record.function_queries[403].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[403].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[403].bump_multiplicity(__i); } let __ret: [G; OUT_403] = unsafe { *(record.function_queries[403].output_at(__i).as_ptr() as *const [G; OUT_403]) }; __ret }, _ => { aiur_fn_403::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_402] = [__v_10]; record.function_queries[402].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_0, __v_5, __v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(403, &__args[..])?) { [G::ZERO; OUT_403] } else { let (__hash, __hit) = record.function_queries[403].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[403].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[403].bump_multiplicity(__i); } let __ret: [G; OUT_403] = unsafe { *(record.function_queries[403].output_at(__i).as_ptr() as *const [G; OUT_403]) }; __ret }, _ => { aiur_fn_403::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __ret: [G; OUT_402] = [__v_11]; record.function_queries[402].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_4, __v_5, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(388, &__args[..])?) { [G::ZERO; OUT_388] } else { let (__hash, __hit) = record.function_queries[388].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[388].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[388].bump_multiplicity(__i); } let __ret: [G; OUT_388] = unsafe { *(record.function_queries[388].output_at(__i).as_ptr() as *const [G; OUT_388]) }; __ret }, _ => { aiur_fn_388::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_402] = [__v_12]; record.function_queries[402].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_0, __v_4, __v_5, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(406, &__args[..])?) { [G::ZERO; OUT_406] } else { let (__hash, __hit) = record.function_queries[406].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[406].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[406].bump_multiplicity(__i); } let __ret: [G; OUT_406] = unsafe { *(record.function_queries[406].output_at(__i).as_ptr() as *const [G; OUT_406]) }; __ret }, _ => { aiur_fn_406::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); let __ret: [G; OUT_402] = [__v_14]; record.function_queries[402].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_0, __v_4, __v_5, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(412, &__args[..])?) { [G::ZERO; OUT_412] } else { let (__hash, __hit) = record.function_queries[412].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[412].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[412].bump_multiplicity(__i); } let __ret: [G; OUT_412] = unsafe { *(record.function_queries[412].output_at(__i).as_ptr() as *const [G; OUT_412]) }; __ret }, _ => { aiur_fn_412::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_402] = [__v_14]; record.function_queries[402].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }, } }) } -const INPUT_SIZE_403: usize = 4; -const IN_403: usize = 4; -const OUT_403: usize = 1; -fn aiur_fn_403(inp: [G; IN_403], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_403], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_128] = { let __args: [G; IN_128] = [__v_2]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; let __v_15: G = __loaded[4]; let __v_16: G = __loaded[5]; let __v_17: G = __loaded[6]; let __v_18: G = __loaded[7]; let __v_19: G = __loaded[8]; let __v_20: G = __loaded[9]; let __v_21: G = __loaded[10]; let __v_22: G = __loaded[11]; match __v_11.as_canonical_u64() { 6u64 => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __v_17 + __v_18; let __v_25: G = __v_23 - __v_24; match __v_25.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(236, &__args[..])?) { [G::ZERO; OUT_236] } else { let (__hash, __hit) = record.function_queries[236].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[236].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[236].bump_multiplicity(__i); } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => { aiur_fn_236::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; let __v_28: G = __loaded[1]; let __v_29: G = __loaded[2]; let __v_30: G = __loaded[3]; let __v_31: G = __loaded[4]; let __v_32: G = __loaded[5]; let __v_33: G = __loaded[6]; let __v_34: G = __loaded[7]; let __v_35: G = __loaded[8]; let __v_36: G = __loaded[9]; let __v_37: G = __loaded[10]; let __v_38: G = __loaded[11]; match __v_27.as_canonical_u64() { 5u64 => { let __v_39: G = G::from_bool(__v_31 == G::ZERO); let __v_40: G = G::from_u64(1); let __v_41: G = __v_32 - __v_40; let __v_42: G = G::from_bool(__v_41 == G::ZERO); let __v_43: G = __v_39 * __v_42; match __v_43.as_canonical_u64() { 0u64 => { let __v_44: G = G::from_u64(0); let __ret: [G; OUT_403] = [__v_44]; record.function_queries[403].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(405, &__args[..])?) { [G::ZERO; OUT_405] } else { let (__hash, __hit) = record.function_queries[405].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[405].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[405].bump_multiplicity(__i); } let __ret: [G; OUT_405] = unsafe { *(record.function_queries[405].output_at(__i).as_ptr() as *const [G; OUT_405]) }; __ret }, _ => { aiur_fn_405::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(352, &__args[..])?) { [G::ZERO; OUT_352] } else { let (__hash, __hit) = record.function_queries[352].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[352].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[352].bump_multiplicity(__i); } let __ret: [G; OUT_352] = unsafe { *(record.function_queries[352].output_at(__i).as_ptr() as *const [G; OUT_352]) }; __ret }, _ => { aiur_fn_352::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { let __v_46: G = G::from_u64(0); let __ret: [G; OUT_403] = [__v_46]; record.function_queries[403].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(374, &__args[..])?) { [G::ZERO; OUT_374] } else { let (__hash, __hit) = record.function_queries[374].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[374].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[374].bump_multiplicity(__i); } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => { aiur_fn_374::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(374, &__args[..])?) { [G::ZERO; OUT_374] } else { let (__hash, __hit) = record.function_queries[374].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[374].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[374].bump_multiplicity(__i); } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => { aiur_fn_374::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_46, __v_47, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; match __v_48.as_canonical_u64() { 0u64 => { let __v_49: G = G::from_u64(0); let __ret: [G; OUT_403] = [__v_49]; record.function_queries[403].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_0, __v_44, __v_17, __v_18, __v_1, __v_5, __v_49, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(404, &__args[..])?) { [G::ZERO; OUT_404] } else { let (__hash, __hit) = record.function_queries[404].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[404].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[404].bump_multiplicity(__i); } let __ret: [G; OUT_404] = unsafe { *(record.function_queries[404].output_at(__i).as_ptr() as *const [G; OUT_404]) }; __ret }, _ => { aiur_fn_404::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_403] = [__v_50]; record.function_queries[403].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { let __v_39: G = G::from_u64(0); let __ret: [G; OUT_403] = [__v_39]; record.function_queries[403].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_26: G = G::from_u64(0); let __ret: [G; OUT_403] = [__v_26]; record.function_queries[403].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_23: G = G::from_u64(0); let __ret: [G; OUT_403] = [__v_23]; record.function_queries[403].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_403] = [__v_10]; record.function_queries[403].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_404: usize = 8; -const IN_404: usize = 8; -const OUT_404: usize = 1; -fn aiur_fn_404(inp: [G; IN_404], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_404], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_3 - __v_6; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_404] = [__v_9]; record.function_queries[404].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(8); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_1, __v_6, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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 = __v_2 + __v_6; let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_5, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_10, __v_12, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_404] = [__v_14]; record.function_queries[404].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = __v_6 + __v_14; let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_15, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(404, &__args[..])?) { [G::ZERO; OUT_404] } else { let (__hash, __hit) = record.function_queries[404].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[404].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[404].bump_multiplicity(__i); } let __ret: [G; OUT_404] = unsafe { *(record.function_queries[404].output_at(__i).as_ptr() as *const [G; OUT_404]) }; __ret }, _ => { aiur_fn_404::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_404] = [__v_16]; record.function_queries[404].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_405: usize = 2; -const IN_405: usize = 2; -const OUT_405: usize = 1; -fn aiur_fn_405(inp: [G; IN_405], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_405], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_240] = { let __args: [G; IN_240] = [__v_1]; 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_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 = G::from_u64(6); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_82] = { let __args: [G; IN_82] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_13, __v_13, __v_13, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(82, &__args[..])?) { [G::ZERO; OUT_82] } else { let (__hash, __hit) = record.function_queries[82].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[82].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => { aiur_fn_82::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(23, &__args[..])?) { [G::ZERO; OUT_23] } else { let (__hash, __hit) = record.function_queries[23].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[23].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[23].bump_multiplicity(__i); } let __ret: [G; OUT_23] = unsafe { *(record.function_queries[23].output_at(__i).as_ptr() as *const [G; OUT_23]) }; __ret }, _ => { aiur_fn_23::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_405] = [__v_15]; record.function_queries[405].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_406: usize = 4; -const IN_406: usize = 4; -const OUT_406: usize = 1; -fn aiur_fn_406(inp: [G; IN_406], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_406], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 4u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 4u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_406] = [__v_12]; record.function_queries[406].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_0, __v_5, __v_6, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(410, &__args[..])?) { [G::ZERO; OUT_410] } else { let (__hash, __hit) = record.function_queries[410].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[410].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[410].bump_multiplicity(__i); } let __ret: [G; OUT_410] = unsafe { *(record.function_queries[410].output_at(__i).as_ptr() as *const [G; OUT_410]) }; __ret }, _ => { aiur_fn_410::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_406] = [__v_12]; record.function_queries[406].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 4u64 => { let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_0, __v_9, __v_10, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(410, &__args[..])?) { [G::ZERO; OUT_410] } else { let (__hash, __hit) = record.function_queries[410].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[410].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[410].bump_multiplicity(__i); } let __ret: [G; OUT_410] = unsafe { *(record.function_queries[410].output_at(__i).as_ptr() as *const [G; OUT_410]) }; __ret }, _ => { aiur_fn_410::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_406] = [__v_12]; record.function_queries[406].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_406] = [__v_12]; record.function_queries[406].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_407: usize = 4; -const IN_407: usize = 4; -const OUT_407: usize = 1; -fn aiur_fn_407(inp: [G; IN_407], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_407], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_374] = { let __args: [G; IN_374] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(374, &__args[..])?) { [G::ZERO; OUT_374] } else { let (__hash, __hit) = record.function_queries[374].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[374].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[374].bump_multiplicity(__i); } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => { aiur_fn_374::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(408, &__args[..])?) { [G::ZERO; OUT_408] } else { let (__hash, __hit) = record.function_queries[408].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[408].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[408].bump_multiplicity(__i); } let __ret: [G; OUT_408] = unsafe { *(record.function_queries[408].output_at(__i).as_ptr() as *const [G; OUT_408]) }; __ret }, _ => { aiur_fn_408::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_407] = [__v_7]; record.function_queries[407].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(374, &__args[..])?) { [G::ZERO; OUT_374] } else { let (__hash, __hit) = record.function_queries[374].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[374].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[374].bump_multiplicity(__i); } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => { aiur_fn_374::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_4, __v_7, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_407] = [__v_8]; record.function_queries[407].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_408: usize = 1; -const IN_408: usize = 1; -const OUT_408: usize = 1; -fn aiur_fn_408(inp: [G; IN_408], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_408], ExecError> { stacker::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_128] = { let __args: [G; IN_128] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].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]; match __v_8.as_canonical_u64() { 5u64 => { match __v_12.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(1); let __v_21: G = __v_13 - __v_20; match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_15, __v_16, __v_22]; 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_23: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; let __v_25: G = __loaded[1]; let __v_26: G = __loaded[2]; let __v_27: G = __loaded[3]; let __v_28: G = __loaded[4]; let __v_29: G = __loaded[5]; let __v_30: G = __loaded[6]; let __v_31: G = __loaded[7]; let __v_32: G = __loaded[8]; let __v_33: G = __loaded[9]; let __v_34: G = __loaded[10]; let __v_35: G = __loaded[11]; match __v_24.as_canonical_u64() { 6u64 => { match __v_31.as_canonical_u64() { 0u64 => { let __v_36: G = G::from_u64(1); let __ret: [G; OUT_408] = [__v_36]; record.function_queries[408].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_36: G = G::from_u64(0); let __ret: [G; OUT_408] = [__v_36]; record.function_queries[408].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_36: G = G::from_u64(0); let __ret: [G; OUT_408] = [__v_36]; record.function_queries[408].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_408] = [__v_22]; record.function_queries[408].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_408] = [__v_20]; record.function_queries[408].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_408] = [__v_20]; record.function_queries[408].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_408] = [__v_7]; record.function_queries[408].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_409: usize = 4; -const IN_409: usize = 4; -const OUT_409: usize = 1; -fn aiur_fn_409(inp: [G; IN_409], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_409], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_374] = { let __args: [G; IN_374] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(374, &__args[..])?) { [G::ZERO; OUT_374] } else { let (__hash, __hit) = record.function_queries[374].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[374].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[374].bump_multiplicity(__i); } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => { aiur_fn_374::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_0, __v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(411, &__args[..])?) { [G::ZERO; OUT_411] } else { let (__hash, __hit) = record.function_queries[411].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[411].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[411].bump_multiplicity(__i); } let __ret: [G; OUT_411] = unsafe { *(record.function_queries[411].output_at(__i).as_ptr() as *const [G; OUT_411]) }; __ret }, _ => { aiur_fn_411::(__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(0); let __ret: [G; OUT_409] = [__v_6]; record.function_queries[409].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(374, &__args[..])?) { [G::ZERO; OUT_374] } else { let (__hash, __hit) = record.function_queries[374].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[374].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[374].bump_multiplicity(__i); } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => { aiur_fn_374::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_4, __v_6, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_409] = [__v_7]; record.function_queries[409].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_410: usize = 5; -const IN_410: usize = 5; -const OUT_410: usize = 1; -fn aiur_fn_410(inp: [G; IN_410], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_410], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(374, &__args[..])?) { [G::ZERO; OUT_374] } else { let (__hash, __hit) = record.function_queries[374].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[374].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[374].bump_multiplicity(__i); } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => { aiur_fn_374::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_1, __v_8, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_410] = [__v_12]; record.function_queries[410].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_3, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_17: G = { let __values: [G; 4] = [__v_16, __v_14, __v_15, __v_13]; let __mq = record.memory_queries.get_index_mut(2).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; 3] = [__v_13, __v_1, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_380] = { let __args: [G; IN_380] = [__v_0, __v_2, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_410] = [__v_19]; record.function_queries[410].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_410] = [__v_11]; record.function_queries[410].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_411: usize = 3; -const IN_411: usize = 3; -const OUT_411: usize = 1; -fn aiur_fn_411(inp: [G; IN_411], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_411], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_374] = { let __args: [G; IN_374] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(374, &__args[..])?) { [G::ZERO; OUT_374] } else { let (__hash, __hit) = record.function_queries[374].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[374].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[374].bump_multiplicity(__i); } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => { aiur_fn_374::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__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(2).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 __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_271] = { let __args: [G; IN_271] = [__v_6, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(271, &__args[..])?) { [G::ZERO; OUT_271] } else { let (__hash, __hit) = record.function_queries[271].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[271].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[271].bump_multiplicity(__i); } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => { aiur_fn_271::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_411] = [__v_11]; record.function_queries[411].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_411] = [__v_9]; record.function_queries[411].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_412: usize = 4; -const IN_412: usize = 4; -const OUT_412: usize = 1; -fn aiur_fn_412(inp: [G; IN_412], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_412], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_413] = { let __args: [G; IN_413] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(413, &__args[..])?) { [G::ZERO; OUT_413] } else { let (__hash, __hit) = record.function_queries[413].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[413].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[413].bump_multiplicity(__i); } let __ret: [G; OUT_413] = unsafe { *(record.function_queries[413].output_at(__i).as_ptr() as *const [G; OUT_413]) }; __ret }, _ => { aiur_fn_413::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_412] = [__v_4]; record.function_queries[412].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_413: usize = 4; -const IN_413: usize = 4; -const OUT_413: usize = 1; -fn aiur_fn_413(inp: [G; IN_413], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_413], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 0u64 => { let __v_12: G = __v_5 - __v_9; match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(1); let __ret: [G; OUT_413] = [__v_13]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_413] = [__v_13]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_413] = [__v_12]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 1u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_5, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(271, &__args[..])?) { [G::ZERO; OUT_271] } else { let (__hash, __hit) = record.function_queries[271].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[271].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[271].bump_multiplicity(__i); } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => { aiur_fn_271::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_12]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_413] = [__v_12]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_5, __v_9]; 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_6, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(379, &__args[..])?) { [G::ZERO; OUT_379] } else { let (__hash, __hit) = record.function_queries[379].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[379].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[379].bump_multiplicity(__i); } let __ret: [G; OUT_379] = unsafe { *(record.function_queries[379].output_at(__i).as_ptr() as *const [G; OUT_379]) }; __ret }, _ => { aiur_fn_379::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_13]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(426, &__args[..])?) { [G::ZERO; OUT_426] } else { let (__hash, __hit) = record.function_queries[426].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[426].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[426].bump_multiplicity(__i); } let __ret: [G; OUT_426] = unsafe { *(record.function_queries[426].output_at(__i).as_ptr() as *const [G; OUT_426]) }; __ret }, _ => { aiur_fn_426::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_13]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(426, &__args[..])?) { [G::ZERO; OUT_426] } else { let (__hash, __hit) = record.function_queries[426].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[426].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[426].bump_multiplicity(__i); } let __ret: [G; OUT_426] = unsafe { *(record.function_queries[426].output_at(__i).as_ptr() as *const [G; OUT_426]) }; __ret }, _ => { aiur_fn_426::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_12]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 3u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 3u64 => { let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_5, __v_9, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(426, &__args[..])?) { [G::ZERO; OUT_426] } else { let (__hash, __hit) = record.function_queries[426].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[426].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[426].bump_multiplicity(__i); } let __ret: [G; OUT_426] = unsafe { *(record.function_queries[426].output_at(__i).as_ptr() as *const [G; OUT_426]) }; __ret }, _ => { aiur_fn_426::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_13]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_6, __v_10, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(426, &__args[..])?) { [G::ZERO; OUT_426] } else { let (__hash, __hit) = record.function_queries[426].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[426].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[426].bump_multiplicity(__i); } let __ret: [G; OUT_426] = unsafe { *(record.function_queries[426].output_at(__i).as_ptr() as *const [G; OUT_426]) }; __ret }, _ => { aiur_fn_426::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_14]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __ret: [G; OUT_413] = [__v_14]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(426, &__args[..])?) { [G::ZERO; OUT_426] } else { let (__hash, __hit) = record.function_queries[426].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[426].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[426].bump_multiplicity(__i); } let __ret: [G; OUT_426] = unsafe { *(record.function_queries[426].output_at(__i).as_ptr() as *const [G; OUT_426]) }; __ret }, _ => { aiur_fn_426::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_12]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 4u64 => { let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_5, __v_9, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_413] = [__v_13]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_380] = { let __args: [G; IN_380] = [__v_0, __v_6, __v_10, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_15]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_0, __v_5, __v_6, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(410, &__args[..])?) { [G::ZERO; OUT_410] } else { let (__hash, __hit) = record.function_queries[410].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[410].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[410].bump_multiplicity(__i); } let __ret: [G; OUT_410] = unsafe { *(record.function_queries[410].output_at(__i).as_ptr() as *const [G; OUT_410]) }; __ret }, _ => { aiur_fn_410::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_12]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 5u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_5, __v_9, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_413] = [__v_13]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_380] = { let __args: [G; IN_380] = [__v_0, __v_6, __v_10, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_15]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_413] = [__v_12]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 6u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_413] = [__v_8]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 7u64 => { let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5, __v_6, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(287, &__args[..])?) { [G::ZERO; OUT_287] } else { let (__hash, __hit) = record.function_queries[287].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[287].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => { aiur_fn_287::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_12]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(341, &__args[..])?) { [G::ZERO; OUT_341] } else { let (__hash, __hit) = record.function_queries[341].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[341].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => { aiur_fn_341::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __v_12 - __v_1; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_413] = [__v_14]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_0, __v_12, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(413, &__args[..])?) { [G::ZERO; OUT_413] } else { let (__hash, __hit) = record.function_queries[413].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[413].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[413].bump_multiplicity(__i); } let __ret: [G; OUT_413] = unsafe { *(record.function_queries[413].output_at(__i).as_ptr() as *const [G; OUT_413]) }; __ret }, _ => { aiur_fn_413::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_14]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, 8u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 8u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_5, __v_9]; 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = __v_6 - __v_10; match __v_13.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_7, __v_11, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_14]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_413] = [__v_14]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_413] = [__v_13]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_413] = [__v_12]; record.function_queries[413].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_414: usize = 5; -const IN_414: usize = 5; -const OUT_414: usize = 3; -fn aiur_fn_414(inp: [G; IN_414], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_414], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(0); let __ret: [G; OUT_414] = [__v_5, __v_1, __v_2]; record.function_queries[414].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = __v_1 - __v_2; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_414] = [__v_6, __v_1, __v_2]; record.function_queries[414].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(388, &__args[..])?) { [G::ZERO; OUT_388] } else { let (__hash, __hit) = record.function_queries[388].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[388].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[388].bump_multiplicity(__i); } let __ret: [G; OUT_388] = unsafe { *(record.function_queries[388].output_at(__i).as_ptr() as *const [G; OUT_388]) }; __ret }, _ => { aiur_fn_388::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_414] = [__v_7, __v_1, __v_2]; record.function_queries[414].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(427, &__args[..])?) { [G::ZERO; OUT_427] } else { let (__hash, __hit) = record.function_queries[427].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[427].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[427].bump_multiplicity(__i); } let __ret: [G; OUT_427] = unsafe { *(record.function_queries[427].output_at(__i).as_ptr() as *const [G; OUT_427]) }; __ret }, _ => { aiur_fn_427::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(427, &__args[..])?) { [G::ZERO; OUT_427] } else { let (__hash, __hit) = record.function_queries[427].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[427].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[427].bump_multiplicity(__i); } let __ret: [G; OUT_427] = unsafe { *(record.function_queries[427].output_at(__i).as_ptr() as *const [G; OUT_427]) }; __ret }, _ => { aiur_fn_427::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_8, __v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(416, &__args[..])?) { [G::ZERO; OUT_416] } else { let (__hash, __hit) = record.function_queries[416].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[416].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[416].bump_multiplicity(__i); } let __ret: [G; OUT_416] = unsafe { *(record.function_queries[416].output_at(__i).as_ptr() as *const [G; OUT_416]) }; __ret }, _ => { aiur_fn_416::(__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 __ret: [G; OUT_414] = [__v_12, __v_13, __v_14]; record.function_queries[414].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(420, &__args[..])?) { [G::ZERO; OUT_420] } else { let (__hash, __hit) = record.function_queries[420].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[420].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => { aiur_fn_420::(__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 __ret: [G; OUT_414] = [__v_12, __v_13, __v_14]; record.function_queries[414].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_0, __v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(421, &__args[..])?) { [G::ZERO; OUT_421] } else { let (__hash, __hit) = record.function_queries[421].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[421].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[421].bump_multiplicity(__i); } let __ret: [G; OUT_421] = unsafe { *(record.function_queries[421].output_at(__i).as_ptr() as *const [G; OUT_421]) }; __ret }, _ => { aiur_fn_421::(__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 __ret: [G; OUT_414] = [__v_12, __v_13, __v_14]; record.function_queries[414].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(422, &__args[..])?) { [G::ZERO; OUT_422] } else { let (__hash, __hit) = record.function_queries[422].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[422].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => { aiur_fn_422::(__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 __ret: [G; OUT_414] = [__v_12, __v_13, __v_14]; record.function_queries[414].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }) } -const INPUT_SIZE_415: usize = 12; -const IN_415: usize = 12; -const OUT_415: usize = 1; -fn aiur_fn_415(inp: [G; IN_415], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_415], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_0.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_415] = [__v_5]; record.function_queries[415].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_415] = [__v_12]; record.function_queries[415].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_416: usize = 7; -const IN_416: usize = 7; -const OUT_416: usize = 3; -fn aiur_fn_416(inp: [G; IN_416], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_416], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; let __v_22: G = __loaded[1]; let __v_23: G = __loaded[2]; let __v_24: G = __loaded[3]; let __v_25: G = __loaded[4]; let __v_26: G = __loaded[5]; let __v_27: G = __loaded[6]; let __v_28: G = __loaded[7]; let __v_29: G = __loaded[8]; let __v_30: G = __loaded[9]; let __v_31: G = __loaded[10]; let __v_32: G = __loaded[11]; let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(423, &__args[..])?) { [G::ZERO; OUT_423] } else { let (__hash, __hit) = record.function_queries[423].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[423].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => { aiur_fn_423::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__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(423, &__args[..])?) { [G::ZERO; OUT_423] } else { let (__hash, __hit) = record.function_queries[423].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[423].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => { aiur_fn_423::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; match __v_33.as_canonical_u64() { 0u64 => { match __v_34.as_canonical_u64() { 0u64 => { let __v_35: G = G::from_u64(0); let __ret: [G; OUT_416] = [__v_35, __v_3, __v_4]; record.function_queries[416].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(418, &__args[..])?) { [G::ZERO; OUT_418] } else { let (__hash, __hit) = record.function_queries[418].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[418].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[418].bump_multiplicity(__i); } let __ret: [G; OUT_418] = unsafe { *(record.function_queries[418].output_at(__i).as_ptr() as *const [G; OUT_418]) }; __ret }, _ => { aiur_fn_418::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = __r_arr[2]; let __ret: [G; OUT_416] = [__v_35, __v_36, __v_37]; record.function_queries[416].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { match __v_34.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(417, &__args[..])?) { [G::ZERO; OUT_417] } else { let (__hash, __hit) = record.function_queries[417].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[417].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => { aiur_fn_417::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = __r_arr[2]; let __ret: [G; OUT_416] = [__v_35, __v_36, __v_37]; record.function_queries[416].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(415, &__args[..])?) { [G::ZERO; OUT_415] } else { let (__hash, __hit) = record.function_queries[415].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[415].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => { aiur_fn_415::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__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(415, &__args[..])?) { [G::ZERO; OUT_415] } else { let (__hash, __hit) = record.function_queries[415].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[415].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => { aiur_fn_415::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __a_val = __v_36.as_canonical_u64(); let __b_val = __v_35.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_37.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(417, &__args[..])?) { [G::ZERO; OUT_417] } else { let (__hash, __hit) = record.function_queries[417].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[417].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => { aiur_fn_417::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __ret: [G; OUT_416] = [__v_38, __v_39, __v_40]; record.function_queries[416].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_38: G = { let __a_val = __v_35.as_canonical_u64(); let __b_val = __v_36.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_38.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(418, &__args[..])?) { [G::ZERO; OUT_418] } else { let (__hash, __hit) = record.function_queries[418].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[418].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[418].bump_multiplicity(__i); } let __ret: [G; OUT_418] = unsafe { *(record.function_queries[418].output_at(__i).as_ptr() as *const [G; OUT_418]) }; __ret }, _ => { aiur_fn_418::(__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 __ret: [G; OUT_416] = [__v_39, __v_40, __v_41]; record.function_queries[416].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_0, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(419, &__args[..])?) { [G::ZERO; OUT_419] } else { let (__hash, __hit) = record.function_queries[419].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[419].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[419].bump_multiplicity(__i); } let __ret: [G; OUT_419] = unsafe { *(record.function_queries[419].output_at(__i).as_ptr() as *const [G; OUT_419]) }; __ret }, _ => { aiur_fn_419::(__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 __ret: [G; OUT_416] = [__v_39, __v_40, __v_41]; record.function_queries[416].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, } }) } -const INPUT_SIZE_417: usize = 5; -const IN_417: usize = 5; -const OUT_417: usize = 3; -fn aiur_fn_417(inp: [G; IN_417], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_417], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(425, &__args[..])?) { [G::ZERO; OUT_425] } else { let (__hash, __hit) = record.function_queries[425].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[425].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => { aiur_fn_425::(__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() { 1u64 => { let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_6, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(365, &__args[..])?) { [G::ZERO; OUT_365] } else { let (__hash, __hit) = record.function_queries[365].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[365].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => { aiur_fn_365::(__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_3 - __v_8; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_7, __v_2, __v_9, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(414, &__args[..])?) { [G::ZERO; OUT_414] } else { let (__hash, __hit) = record.function_queries[414].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[414].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[414].bump_multiplicity(__i); } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => { aiur_fn_414::(__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 __ret: [G; OUT_417] = [__v_10, __v_11, __v_12]; record.function_queries[417].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_417] = [__v_7, __v_1, __v_2]; record.function_queries[417].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_418: usize = 5; -const IN_418: usize = 5; -const OUT_418: usize = 3; -fn aiur_fn_418(inp: [G; IN_418], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_418], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(425, &__args[..])?) { [G::ZERO; OUT_425] } else { let (__hash, __hit) = record.function_queries[425].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[425].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => { aiur_fn_425::(__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() { 1u64 => { let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_6, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(365, &__args[..])?) { [G::ZERO; OUT_365] } else { let (__hash, __hit) = record.function_queries[365].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[365].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => { aiur_fn_365::(__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_3 - __v_8; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1, __v_7, __v_9, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(414, &__args[..])?) { [G::ZERO; OUT_414] } else { let (__hash, __hit) = record.function_queries[414].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[414].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[414].bump_multiplicity(__i); } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => { aiur_fn_414::(__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 __ret: [G; OUT_418] = [__v_10, __v_11, __v_12]; record.function_queries[418].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_418] = [__v_7, __v_1, __v_2]; record.function_queries[418].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_419: usize = 5; -const IN_419: usize = 5; -const OUT_419: usize = 3; -fn aiur_fn_419(inp: [G; IN_419], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_419], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(425, &__args[..])?) { [G::ZERO; OUT_425] } else { let (__hash, __hit) = record.function_queries[425].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[425].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => { aiur_fn_425::(__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() { 1u64 => { let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(425, &__args[..])?) { [G::ZERO; OUT_425] } else { let (__hash, __hit) = record.function_queries[425].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[425].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => { aiur_fn_425::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_6, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(365, &__args[..])?) { [G::ZERO; OUT_365] } else { let (__hash, __hit) = record.function_queries[365].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[365].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => { aiur_fn_365::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_8, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(365, &__args[..])?) { [G::ZERO; OUT_365] } else { let (__hash, __hit) = record.function_queries[365].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[365].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => { aiur_fn_365::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = __v_3 - __v_11; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_9, __v_10, __v_12, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(414, &__args[..])?) { [G::ZERO; OUT_414] } else { let (__hash, __hit) = record.function_queries[414].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[414].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[414].bump_multiplicity(__i); } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => { aiur_fn_414::(__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 __ret: [G; OUT_419] = [__v_13, __v_14, __v_15]; record.function_queries[419].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_419] = [__v_9, __v_1, __v_2]; record.function_queries[419].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_419] = [__v_7, __v_1, __v_2]; record.function_queries[419].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_420: usize = 6; -const IN_420: usize = 6; -const OUT_420: usize = 3; -fn aiur_fn_420(inp: [G; IN_420], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_420], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_424] = { let __args: [G; IN_424] = [__v_0, __v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(424, &__args[..])?) { [G::ZERO; OUT_424] } else { let (__hash, __hit) = record.function_queries[424].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[424].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[424].bump_multiplicity(__i); } let __ret: [G; OUT_424] = unsafe { *(record.function_queries[424].output_at(__i).as_ptr() as *const [G; OUT_424]) }; __ret }, _ => { aiur_fn_424::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = __v_4 - __v_8; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2, __v_7, __v_9, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(414, &__args[..])?) { [G::ZERO; OUT_414] } else { let (__hash, __hit) = record.function_queries[414].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[414].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[414].bump_multiplicity(__i); } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => { aiur_fn_414::(__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 __ret: [G; OUT_420] = [__v_10, __v_11, __v_12]; record.function_queries[420].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __v_17: G = __loaded[8]; let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; let __v_20: G = __loaded[11]; let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(423, &__args[..])?) { [G::ZERO; OUT_423] } else { let (__hash, __hit) = record.function_queries[423].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[423].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => { aiur_fn_423::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_420] = [__v_22, __v_2, __v_3]; record.function_queries[420].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_0, __v_2, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(428, &__args[..])?) { [G::ZERO; OUT_428] } else { let (__hash, __hit) = record.function_queries[428].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[428].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => { aiur_fn_428::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; match __v_22.as_canonical_u64() { 1u64 => { let __v_24: G = G::from_u64(1); let __v_25: G = __v_4 - __v_24; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_23, __v_3, __v_25, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(414, &__args[..])?) { [G::ZERO; OUT_414] } else { let (__hash, __hit) = record.function_queries[414].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[414].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[414].bump_multiplicity(__i); } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => { aiur_fn_414::(__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 __ret: [G; OUT_420] = [__v_26, __v_27, __v_28]; record.function_queries[420].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_420] = [__v_24, __v_2, __v_3]; record.function_queries[420].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_421: usize = 6; -const IN_421: usize = 6; -const OUT_421: usize = 3; -fn aiur_fn_421(inp: [G; IN_421], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_421], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_424] = { let __args: [G; IN_424] = [__v_0, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(424, &__args[..])?) { [G::ZERO; OUT_424] } else { let (__hash, __hit) = record.function_queries[424].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[424].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[424].bump_multiplicity(__i); } let __ret: [G; OUT_424] = unsafe { *(record.function_queries[424].output_at(__i).as_ptr() as *const [G; OUT_424]) }; __ret }, _ => { aiur_fn_424::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = __v_4 - __v_8; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_7, __v_3, __v_9, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(414, &__args[..])?) { [G::ZERO; OUT_414] } else { let (__hash, __hit) = record.function_queries[414].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[414].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[414].bump_multiplicity(__i); } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => { aiur_fn_414::(__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 __ret: [G; OUT_421] = [__v_10, __v_11, __v_12]; record.function_queries[421].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __v_17: G = __loaded[8]; let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; let __v_20: G = __loaded[11]; let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(423, &__args[..])?) { [G::ZERO; OUT_423] } else { let (__hash, __hit) = record.function_queries[423].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[423].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => { aiur_fn_423::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_421] = [__v_22, __v_2, __v_3]; record.function_queries[421].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_0, __v_3, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(428, &__args[..])?) { [G::ZERO; OUT_428] } else { let (__hash, __hit) = record.function_queries[428].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[428].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => { aiur_fn_428::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; match __v_22.as_canonical_u64() { 1u64 => { let __v_24: G = G::from_u64(1); let __v_25: G = __v_4 - __v_24; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2, __v_23, __v_25, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(414, &__args[..])?) { [G::ZERO; OUT_414] } else { let (__hash, __hit) = record.function_queries[414].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[414].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[414].bump_multiplicity(__i); } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => { aiur_fn_414::(__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 __ret: [G; OUT_421] = [__v_26, __v_27, __v_28]; record.function_queries[421].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_421] = [__v_24, __v_2, __v_3]; record.function_queries[421].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_422: usize = 5; -const IN_422: usize = 5; -const OUT_422: usize = 3; -fn aiur_fn_422(inp: [G; IN_422], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_422], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(424, &__args[..])?) { [G::ZERO; OUT_424] } else { let (__hash, __hit) = record.function_queries[424].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[424].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[424].bump_multiplicity(__i); } let __ret: [G; OUT_424] = unsafe { *(record.function_queries[424].output_at(__i).as_ptr() as *const [G; OUT_424]) }; __ret }, _ => { aiur_fn_424::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(424, &__args[..])?) { [G::ZERO; OUT_424] } else { let (__hash, __hit) = record.function_queries[424].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[424].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[424].bump_multiplicity(__i); } let __ret: [G; OUT_424] = unsafe { *(record.function_queries[424].output_at(__i).as_ptr() as *const [G; OUT_424]) }; __ret }, _ => { aiur_fn_424::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { match __v_7.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __v_10: G = __v_3 - __v_9; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_6, __v_8, __v_10, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(414, &__args[..])?) { [G::ZERO; OUT_414] } else { let (__hash, __hit) = record.function_queries[414].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[414].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[414].bump_multiplicity(__i); } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => { aiur_fn_414::(__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 __ret: [G; OUT_422] = [__v_11, __v_12, __v_13]; record.function_queries[422].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(1); let __v_10: G = __v_3 - __v_9; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_6, __v_2, __v_10, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(414, &__args[..])?) { [G::ZERO; OUT_414] } else { let (__hash, __hit) = record.function_queries[414].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[414].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[414].bump_multiplicity(__i); } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => { aiur_fn_414::(__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 __ret: [G; OUT_422] = [__v_11, __v_12, __v_13]; record.function_queries[422].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { match __v_7.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __v_10: G = __v_3 - __v_9; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1, __v_8, __v_10, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(414, &__args[..])?) { [G::ZERO; OUT_414] } else { let (__hash, __hit) = record.function_queries[414].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[414].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[414].bump_multiplicity(__i); } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => { aiur_fn_414::(__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 __ret: [G; OUT_422] = [__v_11, __v_12, __v_13]; record.function_queries[422].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_422] = [__v_9, __v_1, __v_2]; record.function_queries[422].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_423: usize = 12; -const IN_423: usize = 12; -const OUT_423: usize = 1; -fn aiur_fn_423(inp: [G; IN_423], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_423], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_0.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_423] = [__v_12]; record.function_queries[423].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_423] = [__v_12]; record.function_queries[423].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_423] = [__v_12]; record.function_queries[423].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_424: usize = 3; -const IN_424: usize = 3; -const OUT_424: usize = 2; -fn aiur_fn_424(inp: [G; IN_424], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_424], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_128] = { let __args: [G; IN_128] = [__v_1]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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() { 8u64 => { let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(365, &__args[..])?) { [G::ZERO; OUT_365] } else { let (__hash, __hit) = record.function_queries[365].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[365].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => { aiur_fn_365::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 8u64 => { let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(425, &__args[..])?) { [G::ZERO; OUT_425] } else { let (__hash, __hit) = record.function_queries[425].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[425].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => { aiur_fn_425::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; match __v_16.as_canonical_u64() { 1u64 => { let __v_18: G = G::from_u64(8); let __v_19: G = { let __values: [G; 4] = [__v_18, __v_6, __v_7, __v_17]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(1); let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_19, __v_4]; 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_21: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_20, __v_21]; record.function_queries[424].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_18: G = G::from_u64(0); let __ret: [G; OUT_424] = [__v_18, __v_1]; record.function_queries[424].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_16: G = G::from_u64(1); let __ret: [G; OUT_424] = [__v_16, __v_9]; record.function_queries[424].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_424] = [__v_9, __v_1]; record.function_queries[424].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_425: usize = 1; -const IN_425: usize = 1; -const OUT_425: usize = 2; -fn aiur_fn_425(inp: [G; IN_425], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_425], ExecError> { stacker::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_128] = { let __args: [G; IN_128] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].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]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_11, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_20, __v_2]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_21, __v_22]; record.function_queries[425].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_11, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_20, __v_2]; 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_22: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_21, __v_22]; record.function_queries[425].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_425] = [__v_20, __v_0]; record.function_queries[425].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_425] = [__v_7, __v_0]; record.function_queries[425].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_426: usize = 4; -const IN_426: usize = 4; -const OUT_426: usize = 1; -fn aiur_fn_426(inp: [G; IN_426], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_426], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_427] = { let __args: [G; IN_427] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(427, &__args[..])?) { [G::ZERO; OUT_427] } else { let (__hash, __hit) = record.function_queries[427].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[427].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[427].bump_multiplicity(__i); } let __ret: [G; OUT_427] = unsafe { *(record.function_queries[427].output_at(__i).as_ptr() as *const [G; OUT_427]) }; __ret }, _ => { aiur_fn_427::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(427, &__args[..])?) { [G::ZERO; OUT_427] } else { let (__hash, __hit) = record.function_queries[427].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[427].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[427].bump_multiplicity(__i); } let __ret: [G; OUT_427] = unsafe { *(record.function_queries[427].output_at(__i).as_ptr() as *const [G; OUT_427]) }; __ret }, _ => { aiur_fn_427::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_426] = [__v_8]; record.function_queries[426].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_426] = [__v_8]; record.function_queries[426].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __v_17: G = __loaded[8]; let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; let __v_20: G = __loaded[11]; let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].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]; let __v_28: G = __loaded[6]; let __v_29: G = __loaded[7]; let __v_30: G = __loaded[8]; let __v_31: G = __loaded[9]; let __v_32: G = __loaded[10]; let __v_33: G = __loaded[11]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_0, __v_1, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(428, &__args[..])?) { [G::ZERO; OUT_428] } else { let (__hash, __hit) = record.function_queries[428].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[428].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => { aiur_fn_428::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_0, __v_2, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(428, &__args[..])?) { [G::ZERO; OUT_428] } else { let (__hash, __hit) = record.function_queries[428].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[428].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => { aiur_fn_428::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; match __v_34.as_canonical_u64() { 1u64 => { match __v_36.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_35, __v_37, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __ret: [G; OUT_426] = [__v_38]; record.function_queries[426].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_35, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __ret: [G; OUT_426] = [__v_38]; record.function_queries[426].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 0u64 => { match __v_36.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_1, __v_37, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __ret: [G; OUT_426] = [__v_38]; record.function_queries[426].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __ret: [G; OUT_426] = [__v_38]; record.function_queries[426].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64())); }, } }, } }, } }) } -const INPUT_SIZE_427: usize = 1; -const IN_427: usize = 1; -const OUT_427: usize = 2; -fn aiur_fn_427(inp: [G; IN_427], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_427], ExecError> { stacker::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_128] = { let __args: [G; IN_128] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_427] = [__v_4, __v_7]; record.function_queries[427].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 32] = [__v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(12).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_427] = [__v_8, __v_7]; record.function_queries[427].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_428: usize = 15; -const IN_428: usize = 15; -const OUT_428: usize = 2; -fn aiur_fn_428(inp: [G; IN_428], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_428], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_2.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(425, &__args[..])?) { [G::ZERO; OUT_425] } else { let (__hash, __hit) = record.function_queries[425].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[425].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => { aiur_fn_425::(__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() { 1u64 => { let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_16, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(365, &__args[..])?) { [G::ZERO; OUT_365] } else { let (__hash, __hit) = record.function_queries[365].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[365].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => { aiur_fn_365::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_428] = [__v_17, __v_18]; record.function_queries[428].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_428] = [__v_17, __v_1]; record.function_queries[428].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(425, &__args[..])?) { [G::ZERO; OUT_425] } else { let (__hash, __hit) = record.function_queries[425].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[425].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => { aiur_fn_425::(__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() { 1u64 => { let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_16, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(365, &__args[..])?) { [G::ZERO; OUT_365] } else { let (__hash, __hit) = record.function_queries[365].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[365].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => { aiur_fn_365::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_428] = [__v_17, __v_18]; record.function_queries[428].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_428] = [__v_17, __v_1]; record.function_queries[428].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_428] = [__v_15, __v_1]; record.function_queries[428].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_429: usize = 3; -const IN_429: usize = 3; -const OUT_429: usize = 1; -fn aiur_fn_429(inp: [G; IN_429], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_429], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_288] = { let __args: [G; IN_288] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_431] = { let __args: [G; IN_431] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(431, &__args[..])?) { [G::ZERO; OUT_431] } else { let (__hash, __hit) = record.function_queries[431].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[431].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[431].bump_multiplicity(__i); } let __ret: [G; OUT_431] = unsafe { *(record.function_queries[431].output_at(__i).as_ptr() as *const [G; OUT_431]) }; __ret }, _ => { aiur_fn_431::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_429] = [__v_6]; record.function_queries[429].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(430, &__args[..])?) { [G::ZERO; OUT_430] } else { let (__hash, __hit) = record.function_queries[430].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[430].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[430].bump_multiplicity(__i); } let __ret: [G; OUT_430] = unsafe { *(record.function_queries[430].output_at(__i).as_ptr() as *const [G; OUT_430]) }; __ret }, _ => { aiur_fn_430::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_429] = [__v_4]; record.function_queries[429].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_430: usize = 4; -const IN_430: usize = 4; -const OUT_430: usize = 1; -fn aiur_fn_430(inp: [G; IN_430], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_430], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_1, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(302, &__args[..])?) { [G::ZERO; OUT_302] } else { let (__hash, __hit) = record.function_queries[302].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[302].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => { aiur_fn_302::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(292, &__args[..])?) { [G::ZERO; OUT_292] } else { let (__hash, __hit) = record.function_queries[292].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[292].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => { aiur_fn_292::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(301, &__args[..])?) { [G::ZERO; OUT_301] } else { let (__hash, __hit) = record.function_queries[301].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[301].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { *(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301]) }; __ret }, _ => { aiur_fn_301::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_0, __v_1, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(431, &__args[..])?) { [G::ZERO; OUT_431] } else { let (__hash, __hit) = record.function_queries[431].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[431].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[431].bump_multiplicity(__i); } let __ret: [G; OUT_431] = unsafe { *(record.function_queries[431].output_at(__i).as_ptr() as *const [G; OUT_431]) }; __ret }, _ => { aiur_fn_431::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_430] = [__v_9]; record.function_queries[430].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_1, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(310, &__args[..])?) { [G::ZERO; OUT_310] } else { let (__hash, __hit) = record.function_queries[310].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[310].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => { aiur_fn_310::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __v_3 - __v_7; let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(301, &__args[..])?) { [G::ZERO; OUT_301] } else { let (__hash, __hit) = record.function_queries[301].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[301].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { *(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301]) }; __ret }, _ => { aiur_fn_301::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_0, __v_9, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(431, &__args[..])?) { [G::ZERO; OUT_431] } else { let (__hash, __hit) = record.function_queries[431].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[431].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[431].bump_multiplicity(__i); } let __ret: [G; OUT_431] = unsafe { *(record.function_queries[431].output_at(__i).as_ptr() as *const [G; OUT_431]) }; __ret }, _ => { aiur_fn_431::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_13, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_430] = [__v_14]; record.function_queries[430].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_431: usize = 3; -const IN_431: usize = 3; -const OUT_431: usize = 1; -fn aiur_fn_431(inp: [G; IN_431], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_431], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__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_4 + __v_8; let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_7, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_431] = [__v_11]; record.function_queries[431].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_280] = { let __args: [G; IN_280] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(280, &__args[..])?) { [G::ZERO; OUT_280] } else { let (__hash, __hit) = record.function_queries[280].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[280].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[280].bump_multiplicity(__i); } let __ret: [G; OUT_280] = unsafe { *(record.function_queries[280].output_at(__i).as_ptr() as *const [G; OUT_280]) }; __ret }, _ => { aiur_fn_280::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_7, __v_10, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_431] = [__v_11]; record.function_queries[431].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].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 __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(372, &__args[..])?) { [G::ZERO; OUT_372] } else { let (__hash, __hit) = record.function_queries[372].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[372].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => { aiur_fn_372::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(373, &__args[..])?) { [G::ZERO; OUT_373] } else { let (__hash, __hit) = record.function_queries[373].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[373].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[373].bump_multiplicity(__i); } let __ret: [G; OUT_373] = unsafe { *(record.function_queries[373].output_at(__i).as_ptr() as *const [G; OUT_373]) }; __ret }, _ => { aiur_fn_373::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_22, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_431] = [__v_23]; record.function_queries[431].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_1]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_7, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(429, &__args[..])?) { [G::ZERO; OUT_429] } else { let (__hash, __hit) = record.function_queries[429].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[429].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[429].bump_multiplicity(__i); } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => { aiur_fn_429::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; 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(1).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_443] = { let __args: [G; IN_443] = [__v_0, __v_9, __v_8, __v_11, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(443, &__args[..])?) { [G::ZERO; OUT_443] } else { let (__hash, __hit) = record.function_queries[443].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[443].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => { aiur_fn_443::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_431] = [__v_12]; record.function_queries[431].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_4, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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_429] = { let __args: [G; IN_429] = [__v_0, __v_5, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(429, &__args[..])?) { [G::ZERO; OUT_429] } else { let (__hash, __hit) = record.function_queries[429].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[429].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[429].bump_multiplicity(__i); } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => { aiur_fn_429::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(5); let __v_12: G = { let __values: [G; 4] = [__v_11, __v_4, __v_10, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_431] = [__v_12]; record.function_queries[431].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_4, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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_451] = { let __args: [G; IN_451] = [__v_0, __v_5, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_7, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(279, &__args[..])?) { [G::ZERO; OUT_279] } else { let (__hash, __hit) = record.function_queries[279].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[279].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[279].bump_multiplicity(__i); } let __ret: [G; OUT_279] = unsafe { *(record.function_queries[279].output_at(__i).as_ptr() as *const [G; OUT_279]) }; __ret }, _ => { aiur_fn_279::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_11, __v_12, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_431] = [__v_13]; record.function_queries[431].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_4, __v_5, __v_6, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(432, &__args[..])?) { [G::ZERO; OUT_432] } else { let (__hash, __hit) = record.function_queries[432].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[432].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => { aiur_fn_432::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_431] = [__v_7]; record.function_queries[431].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_0, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(444, &__args[..])?) { [G::ZERO; OUT_444] } else { let (__hash, __hit) = record.function_queries[444].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[444].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[444].bump_multiplicity(__i); } let __ret: [G; OUT_444] = unsafe { *(record.function_queries[444].output_at(__i).as_ptr() as *const [G; OUT_444]) }; __ret }, _ => { aiur_fn_444::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_431] = [__v_7]; record.function_queries[431].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_0, __v_4, __v_5, __v_6, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(450, &__args[..])?) { [G::ZERO; OUT_450] } else { let (__hash, __hit) = record.function_queries[450].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[450].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[450].bump_multiplicity(__i); } let __ret: [G; OUT_450] = unsafe { *(record.function_queries[450].output_at(__i).as_ptr() as *const [G; OUT_450]) }; __ret }, _ => { aiur_fn_450::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_431] = [__v_7]; record.function_queries[431].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_432: usize = 5; -const IN_432: usize = 5; -const OUT_432: usize = 1; -fn aiur_fn_432(inp: [G; IN_432], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_432], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0, __v_2, __v_1, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(452, &__args[..])?) { [G::ZERO; OUT_452] } else { let (__hash, __hit) = record.function_queries[452].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[452].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[452].bump_multiplicity(__i); } let __ret: [G; OUT_452] = unsafe { *(record.function_queries[452].output_at(__i).as_ptr() as *const [G; OUT_452]) }; __ret }, _ => { aiur_fn_452::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 5] = [__v_7, __v_4, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(3).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 __v_9: G = G::from_u64(2); let __v_10: G = { let __values: [G; 5] = [__v_9, __v_1, __v_2, __v_8, __v_6]; let __mq = record.memory_queries.get_index_mut(3).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 __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_3, __v_10, __v_4, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(438, &__args[..])?) { [G::ZERO; OUT_438] } else { let (__hash, __hit) = record.function_queries[438].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[438].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => { aiur_fn_438::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_432] = [__v_11]; record.function_queries[432].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_433: usize = 4; -const IN_433: usize = 4; -const OUT_433: usize = 1; -fn aiur_fn_433(inp: [G; IN_433], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_433], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_434] = { let __args: [G; IN_434] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(434, &__args[..])?) { [G::ZERO; OUT_434] } else { let (__hash, __hit) = record.function_queries[434].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[434].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[434].bump_multiplicity(__i); } let __ret: [G; OUT_434] = unsafe { *(record.function_queries[434].output_at(__i).as_ptr() as *const [G; OUT_434]) }; __ret }, _ => { aiur_fn_434::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __v_3 - __v_5; let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_433] = [__v_8]; record.function_queries[433].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_434: usize = 2; -const IN_434: usize = 2; -const OUT_434: usize = 2; -fn aiur_fn_434(inp: [G; IN_434], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_434], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(3).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() { 0u64 => { let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(371, &__args[..])?) { [G::ZERO; OUT_371] } else { let (__hash, __hit) = record.function_queries[371].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[371].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => { aiur_fn_371::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_434] = [__v_7, __v_4]; record.function_queries[434].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = __v_4 - __v_7; let __ret: [G; OUT_434] = [__v_3, __v_8]; record.function_queries[434].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(434, &__args[..])?) { [G::ZERO; OUT_434] } else { let (__hash, __hit) = record.function_queries[434].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[434].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[434].bump_multiplicity(__i); } let __ret: [G; OUT_434] = unsafe { *(record.function_queries[434].output_at(__i).as_ptr() as *const [G; OUT_434]) }; __ret }, _ => { aiur_fn_434::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_434] = [__v_9, __v_10]; record.function_queries[434].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_434] = [__v_3, __v_6]; record.function_queries[434].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(434, &__args[..])?) { [G::ZERO; OUT_434] } else { let (__hash, __hit) = record.function_queries[434].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[434].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[434].bump_multiplicity(__i); } let __ret: [G; OUT_434] = unsafe { *(record.function_queries[434].output_at(__i).as_ptr() as *const [G; OUT_434]) }; __ret }, _ => { aiur_fn_434::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_434] = [__v_9, __v_10]; record.function_queries[434].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_435: usize = 3; -const IN_435: usize = 3; -const OUT_435: usize = 1; -fn aiur_fn_435(inp: [G; IN_435], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_435], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_436] = { let __args: [G; IN_436] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(436, &__args[..])?) { [G::ZERO; OUT_436] } else { let (__hash, __hit) = record.function_queries[436].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[436].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[436].bump_multiplicity(__i); } let __ret: [G; OUT_436] = unsafe { *(record.function_queries[436].output_at(__i).as_ptr() as *const [G; OUT_436]) }; __ret }, _ => { aiur_fn_436::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __v_2 - __v_4; let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_435] = [__v_7]; record.function_queries[435].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_436: usize = 2; -const IN_436: usize = 2; -const OUT_436: usize = 2; -fn aiur_fn_436(inp: [G; IN_436], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_436], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(3).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() { 0u64 => { let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_7, __v_1, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_436] = [__v_8, __v_4]; record.function_queries[436].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_436] = [__v_8, __v_4]; record.function_queries[436].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(436, &__args[..])?) { [G::ZERO; OUT_436] } else { let (__hash, __hit) = record.function_queries[436].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[436].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[436].bump_multiplicity(__i); } let __ret: [G; OUT_436] = unsafe { *(record.function_queries[436].output_at(__i).as_ptr() as *const [G; OUT_436]) }; __ret }, _ => { aiur_fn_436::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_436] = [__v_9, __v_10]; record.function_queries[436].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(437, &__args[..])?) { [G::ZERO; OUT_437] } else { let (__hash, __hit) = record.function_queries[437].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[437].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => { aiur_fn_437::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_8, __v_6]; record.function_queries[436].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(436, &__args[..])?) { [G::ZERO; OUT_436] } else { let (__hash, __hit) = record.function_queries[436].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[436].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[436].bump_multiplicity(__i); } let __ret: [G; OUT_436] = unsafe { *(record.function_queries[436].output_at(__i).as_ptr() as *const [G; OUT_436]) }; __ret }, _ => { aiur_fn_436::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_436] = [__v_9, __v_10]; record.function_queries[436].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_437: usize = 4; -const IN_437: usize = 4; -const OUT_437: usize = 1; -fn aiur_fn_437(inp: [G; IN_437], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_437], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_288] = { let __args: [G; IN_288] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_4]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_437] = [__v_0]; record.function_queries[437].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_7, __v_3]; 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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_437] = [__v_0]; record.function_queries[437].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = __v_7 - __v_3; let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_1, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(436, &__args[..])?) { [G::ZERO; OUT_436] } else { let (__hash, __hit) = record.function_queries[436].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[436].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[436].bump_multiplicity(__i); } let __ret: [G; OUT_436] = unsafe { *(record.function_queries[436].output_at(__i).as_ptr() as *const [G; OUT_436]) }; __ret }, _ => { aiur_fn_436::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __v_2 - __v_13; let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_12, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_16, __v_3, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_437] = [__v_17]; record.function_queries[437].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 3u64 => { let __v_10: G = G::from_u64(3); let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(437, &__args[..])?) { [G::ZERO; OUT_437] } else { let (__hash, __hit) = record.function_queries[437].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[437].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => { aiur_fn_437::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(437, &__args[..])?) { [G::ZERO; OUT_437] } else { let (__hash, __hit) = record.function_queries[437].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[437].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => { aiur_fn_437::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(2).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_437] = [__v_14]; record.function_queries[437].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_10: G = G::from_u64(4); let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(437, &__args[..])?) { [G::ZERO; OUT_437] } else { let (__hash, __hit) = record.function_queries[437].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[437].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => { aiur_fn_437::(__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_3 + __v_12; let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_8, __v_1, __v_2, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(437, &__args[..])?) { [G::ZERO; OUT_437] } else { let (__hash, __hit) = record.function_queries[437].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[437].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => { aiur_fn_437::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_10, __v_11, __v_14, __v_15]; let __mq = record.memory_queries.get_index_mut(2).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_437] = [__v_16]; record.function_queries[437].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_10: G = G::from_u64(5); let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(437, &__args[..])?) { [G::ZERO; OUT_437] } else { let (__hash, __hit) = record.function_queries[437].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[437].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => { aiur_fn_437::(__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_3 + __v_12; let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_8, __v_1, __v_2, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(437, &__args[..])?) { [G::ZERO; OUT_437] } else { let (__hash, __hit) = record.function_queries[437].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[437].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => { aiur_fn_437::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_10, __v_11, __v_14, __v_15]; let __mq = record.memory_queries.get_index_mut(2).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_437] = [__v_16]; record.function_queries[437].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_10: G = G::from_u64(6); let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(437, &__args[..])?) { [G::ZERO; OUT_437] } else { let (__hash, __hit) = record.function_queries[437].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[437].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => { aiur_fn_437::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(437, &__args[..])?) { [G::ZERO; OUT_437] } else { let (__hash, __hit) = record.function_queries[437].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[437].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => { aiur_fn_437::(__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_3 + __v_13; let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_9, __v_1, __v_2, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(437, &__args[..])?) { [G::ZERO; OUT_437] } else { let (__hash, __hit) = record.function_queries[437].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[437].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => { aiur_fn_437::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_15]; let __mq = record.memory_queries.get_index_mut(2).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_437] = [__v_16]; record.function_queries[437].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_10: G = G::from_u64(8); let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(437, &__args[..])?) { [G::ZERO; OUT_437] } else { let (__hash, __hit) = record.function_queries[437].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[437].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => { aiur_fn_437::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_10, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_437] = [__v_12]; record.function_queries[437].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_437] = [__v_0]; record.function_queries[437].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_438: usize = 5; -const IN_438: usize = 5; -const OUT_438: usize = 1; -fn aiur_fn_438(inp: [G; IN_438], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_438], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__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 = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_429] = { let __args: [G; IN_429] = [__v_0, __v_1, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(429, &__args[..])?) { [G::ZERO; OUT_429] } else { let (__hash, __hit) = record.function_queries[429].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[429].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[429].bump_multiplicity(__i); } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => { aiur_fn_429::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_438] = [__v_8]; record.function_queries[438].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 3u64 => { let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(439, &__args[..])?) { [G::ZERO; OUT_439] } else { let (__hash, __hit) = record.function_queries[439].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[439].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[439].bump_multiplicity(__i); } let __ret: [G; OUT_439] = unsafe { *(record.function_queries[439].output_at(__i).as_ptr() as *const [G; OUT_439]) }; __ret }, _ => { aiur_fn_439::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(442, &__args[..])?) { [G::ZERO; OUT_442] } else { let (__hash, __hit) = record.function_queries[442].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[442].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[442].bump_multiplicity(__i); } let __ret: [G; OUT_442] = unsafe { *(record.function_queries[442].output_at(__i).as_ptr() as *const [G; OUT_442]) }; __ret }, _ => { aiur_fn_442::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_438] = [__v_11]; record.function_queries[438].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1, __v_11, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(293, &__args[..])?) { [G::ZERO; OUT_293] } else { let (__hash, __hit) = record.function_queries[293].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[293].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => { aiur_fn_293::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(442, &__args[..])?) { [G::ZERO; OUT_442] } else { let (__hash, __hit) = record.function_queries[442].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[442].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[442].bump_multiplicity(__i); } let __ret: [G; OUT_442] = unsafe { *(record.function_queries[442].output_at(__i).as_ptr() as *const [G; OUT_442]) }; __ret }, _ => { aiur_fn_442::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_438] = [__v_13]; record.function_queries[438].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(440, &__args[..])?) { [G::ZERO; OUT_440] } else { let (__hash, __hit) = record.function_queries[440].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[440].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[440].bump_multiplicity(__i); } let __ret: [G; OUT_440] = unsafe { *(record.function_queries[440].output_at(__i).as_ptr() as *const [G; OUT_440]) }; __ret }, _ => { aiur_fn_440::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_438] = [__v_13]; record.function_queries[438].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }, } }, _ => { let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(442, &__args[..])?) { [G::ZERO; OUT_442] } else { let (__hash, __hit) = record.function_queries[442].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[442].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[442].bump_multiplicity(__i); } let __ret: [G; OUT_442] = unsafe { *(record.function_queries[442].output_at(__i).as_ptr() as *const [G; OUT_442]) }; __ret }, _ => { aiur_fn_442::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_438] = [__v_10]; record.function_queries[438].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_439: usize = 1; -const IN_439: usize = 1; -const OUT_439: usize = 1; -fn aiur_fn_439(inp: [G; IN_439], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_439], ExecError> { stacker::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(3).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() { 0u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_439] = [__v_6]; record.function_queries[439].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_439] = [__v_6]; record.function_queries[439].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(439, &__args[..])?) { [G::ZERO; OUT_439] } else { let (__hash, __hit) = record.function_queries[439].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[439].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[439].bump_multiplicity(__i); } let __ret: [G; OUT_439] = unsafe { *(record.function_queries[439].output_at(__i).as_ptr() as *const [G; OUT_439]) }; __ret }, _ => { aiur_fn_439::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_439] = [__v_7]; record.function_queries[439].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(1); let __v_8: G = __v_6 + __v_7; let __ret: [G; OUT_439] = [__v_8]; record.function_queries[439].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_440: usize = 5; -const IN_440: usize = 5; -const OUT_440: usize = 1; -fn aiur_fn_440(inp: [G; IN_440], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_440], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(302, &__args[..])?) { [G::ZERO; OUT_302] } else { let (__hash, __hit) = record.function_queries[302].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[302].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => { aiur_fn_302::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_2, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(441, &__args[..])?) { [G::ZERO; OUT_441] } else { let (__hash, __hit) = record.function_queries[441].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[441].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[441].bump_multiplicity(__i); } let __ret: [G; OUT_441] = unsafe { *(record.function_queries[441].output_at(__i).as_ptr() as *const [G; OUT_441]) }; __ret }, _ => { aiur_fn_441::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_1, __v_8, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(310, &__args[..])?) { [G::ZERO; OUT_310] } else { let (__hash, __hit) = record.function_queries[310].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[310].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => { aiur_fn_310::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __v_4 - __v_9; let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0, __v_10, __v_7, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(442, &__args[..])?) { [G::ZERO; OUT_442] } else { let (__hash, __hit) = record.function_queries[442].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[442].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[442].bump_multiplicity(__i); } let __ret: [G; OUT_442] = unsafe { *(record.function_queries[442].output_at(__i).as_ptr() as *const [G; OUT_442]) }; __ret }, _ => { aiur_fn_442::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_13, __v_9, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_440] = [__v_14]; record.function_queries[440].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_441: usize = 2; -const IN_441: usize = 2; -const OUT_441: usize = 3; -fn aiur_fn_441(inp: [G; IN_441], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_441], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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(0); let __ret: [G; OUT_441] = [__v_0, __v_2, __v_2]; record.function_queries[441].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).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() { 2u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(441, &__args[..])?) { [G::ZERO; OUT_441] } else { let (__hash, __hit) = record.function_queries[441].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[441].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[441].bump_multiplicity(__i); } let __ret: [G; OUT_441] = unsafe { *(record.function_queries[441].output_at(__i).as_ptr() as *const [G; OUT_441]) }; __ret }, _ => { aiur_fn_441::(__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 = __v_10 + __v_7; let __ret: [G; OUT_441] = [__v_9, __v_12, __v_11]; record.function_queries[441].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 - __v_7; let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(441, &__args[..])?) { [G::ZERO; OUT_441] } else { let (__hash, __hit) = record.function_queries[441].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[441].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[441].bump_multiplicity(__i); } let __ret: [G; OUT_441] = unsafe { *(record.function_queries[441].output_at(__i).as_ptr() as *const [G; OUT_441]) }; __ret }, _ => { aiur_fn_441::(__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 = __v_10 + __v_7; let __v_13: G = __v_11 + __v_7; let __ret: [G; OUT_441] = [__v_9, __v_12, __v_13]; record.function_queries[441].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_441] = [__v_0, __v_7, __v_7]; record.function_queries[441].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_442: usize = 5; -const IN_442: usize = 5; -const OUT_442: usize = 1; -fn aiur_fn_442(inp: [G; IN_442], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_442], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(2).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_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 __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_2, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(434, &__args[..])?) { [G::ZERO; OUT_434] } else { let (__hash, __hit) = record.function_queries[434].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[434].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[434].bump_multiplicity(__i); } let __ret: [G; OUT_434] = unsafe { *(record.function_queries[434].output_at(__i).as_ptr() as *const [G; OUT_434]) }; __ret }, _ => { aiur_fn_434::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __v_4 - __v_10; let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_442] = [__v_13]; record.function_queries[442].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_6, __v_2, __v_4, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(437, &__args[..])?) { [G::ZERO; OUT_437] } else { let (__hash, __hit) = record.function_queries[437].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[437].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => { aiur_fn_437::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_10, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_9, __v_10, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(1); let __v_14: G = __v_4 + __v_13; let __v_15: G = { let __values: [G; 5] = [__v_13, __v_10, __v_14, __v_2, __v_9]; let __mq = record.memory_queries.get_index_mut(3).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 __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_7, __v_15, __v_12, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(438, &__args[..])?) { [G::ZERO; OUT_438] } else { let (__hash, __hit) = record.function_queries[438].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[438].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => { aiur_fn_438::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(5); let __v_18: G = { let __values: [G; 4] = [__v_17, __v_10, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_442] = [__v_18]; record.function_queries[442].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_6, __v_2, __v_4, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(437, &__args[..])?) { [G::ZERO; OUT_437] } else { let (__hash, __hit) = record.function_queries[437].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[437].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => { aiur_fn_437::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_10, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_9, __v_10, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(1); let __v_14: G = __v_4 + __v_13; let __v_15: G = { let __values: [G; 5] = [__v_13, __v_10, __v_14, __v_2, __v_9]; let __mq = record.memory_queries.get_index_mut(3).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 __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_7, __v_15, __v_12, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(438, &__args[..])?) { [G::ZERO; OUT_438] } else { let (__hash, __hit) = record.function_queries[438].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[438].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => { aiur_fn_438::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_16, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __idx = usize::try_from(__ptr_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() { 1u64 => { let __v_22: G = G::from_u64(1); let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_11, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(279, &__args[..])?) { [G::ZERO; OUT_279] } else { let (__hash, __hit) = record.function_queries[279].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[279].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[279].bump_multiplicity(__i); } let __ret: [G; OUT_279] = unsafe { *(record.function_queries[279].output_at(__i).as_ptr() as *const [G; OUT_279]) }; __ret }, _ => { aiur_fn_279::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_index_mut(2).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_442] = [__v_25]; record.function_queries[442].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); }, } }, 6u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_6, __v_2, __v_4, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(437, &__args[..])?) { [G::ZERO; OUT_437] } else { let (__hash, __hit) = record.function_queries[437].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[437].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => { aiur_fn_437::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_10, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(438, &__args[..])?) { [G::ZERO; OUT_438] } else { let (__hash, __hit) = record.function_queries[438].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[438].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => { aiur_fn_438::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_12, __v_10, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("delayed let value type mismatch".to_string()) }); } let __v_15: G = G::from_u64(2); let __v_16: G = { let __values: [G; 5] = [__v_15, __v_10, __v_7, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(3).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 __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_8, __v_16, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(438, &__args[..])?) { [G::ZERO; OUT_438] } else { let (__hash, __hit) = record.function_queries[438].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[438].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => { aiur_fn_438::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_442] = [__v_17]; record.function_queries[442].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(438, &__args[..])?) { [G::ZERO; OUT_438] } else { let (__hash, __hit) = record.function_queries[438].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[438].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => { aiur_fn_438::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_9, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(438, &__args[..])?) { [G::ZERO; OUT_438] } else { let (__hash, __hit) = record.function_queries[438].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[438].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => { aiur_fn_438::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_15, __v_12, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__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: Some("delayed application type mismatch".to_string()) }); } let __v_18: G = G::from_u64(0); let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_13, __v_18, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(293, &__args[..])?) { [G::ZERO; OUT_293] } else { let (__hash, __hit) = record.function_queries[293].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[293].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => { aiur_fn_293::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; match __v_19.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(1); let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_13, __v_20, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(310, &__args[..])?) { [G::ZERO; OUT_310] } else { let (__hash, __hit) = record.function_queries[310].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[310].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => { aiur_fn_310::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_442] = [__v_21]; record.function_queries[442].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_7, __v_2, __v_4, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(437, &__args[..])?) { [G::ZERO; OUT_437] } else { let (__hash, __hit) = record.function_queries[437].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[437].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => { aiur_fn_437::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_13, __v_21, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_442] = [__v_22]; record.function_queries[442].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, _ => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_1, __v_2, __v_4, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(437, &__args[..])?) { [G::ZERO; OUT_437] } else { let (__hash, __hit) = record.function_queries[437].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[437].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => { aiur_fn_437::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_10, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(429, &__args[..])?) { [G::ZERO; OUT_429] } else { let (__hash, __hit) = record.function_queries[429].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[429].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[429].bump_multiplicity(__i); } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => { aiur_fn_429::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_442] = [__v_11]; record.function_queries[442].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_443: usize = 5; -const IN_443: usize = 5; -const OUT_443: usize = 1; -fn aiur_fn_443(inp: [G; IN_443], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_443], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_443] = [__v_1]; record.function_queries[443].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_1, __v_3, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_443] = [__v_10]; record.function_queries[443].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(2).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_12.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_9]; }, _ => { let __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_9, __v_3, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; break '__mc_0 [__v_14]; }, } }; let __v_13: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0, __v_6, __v_13, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(452, &__args[..])?) { [G::ZERO; OUT_452] } else { let (__hash, __hit) = record.function_queries[452].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[452].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[452].bump_multiplicity(__i); } let __ret: [G; OUT_452] = unsafe { *(record.function_queries[452].output_at(__i).as_ptr() as *const [G; OUT_452]) }; __ret }, _ => { aiur_fn_452::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 3] = [__v_14, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_443] = { let __args: [G; IN_443] = [__v_0, __v_10, __v_7, __v_15, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(443, &__args[..])?) { [G::ZERO; OUT_443] } else { let (__hash, __hit) = record.function_queries[443].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[443].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => { aiur_fn_443::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_443] = [__v_16]; record.function_queries[443].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_12.as_canonical_u64() { 0u64 => { break '__mc_1 [__v_1]; }, _ => { let __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_1, __v_3, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; break '__mc_1 [__v_14]; }, } }; let __v_13: G = __mc_out___mc_1[0]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_13, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0, __v_6, __v_16, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(452, &__args[..])?) { [G::ZERO; OUT_452] } else { let (__hash, __hit) = record.function_queries[452].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[452].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[452].bump_multiplicity(__i); } let __ret: [G; OUT_452] = unsafe { *(record.function_queries[452].output_at(__i).as_ptr() as *const [G; OUT_452]) }; __ret }, _ => { aiur_fn_452::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_index_mut(1).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_19, __v_6, __v_21]; let __mq = record.memory_queries.get_index_mut(1).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_443] = { let __args: [G; IN_443] = [__v_0, __v_17, __v_7, __v_22, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(443, &__args[..])?) { [G::ZERO; OUT_443] } else { let (__hash, __hit) = record.function_queries[443].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[443].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => { aiur_fn_443::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_443] = [__v_23]; record.function_queries[443].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_444: usize = 3; -const IN_444: usize = 3; -const OUT_444: usize = 1; -fn aiur_fn_444(inp: [G; IN_444], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_444], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(2); let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(481, &__args[..])?) { [G::ZERO; OUT_481] } else { let (__hash, __hit) = record.function_queries[481].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[481].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => { aiur_fn_481::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; 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(1).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; 4] = [__v_3, __v_5, __v_7, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_444] = [__v_8]; record.function_queries[444].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_3: G = G::from_u64(2); let __v_4: G = G::from_u64(37); let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(482, &__args[..])?) { [G::ZERO; OUT_482] } else { let (__hash, __hit) = record.function_queries[482].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[482].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => { aiur_fn_482::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; 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(1).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 = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_3, __v_5, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_444] = [__v_9]; record.function_queries[444].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_445: usize = 5; -const IN_445: usize = 5; -const OUT_445: usize = 1; -fn aiur_fn_445(inp: [G; IN_445], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_445], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __v_5, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(446, &__args[..])?) { [G::ZERO; OUT_446] } else { let (__hash, __hit) = record.function_queries[446].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[446].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[446].bump_multiplicity(__i); } let __ret: [G; OUT_446] = unsafe { *(record.function_queries[446].output_at(__i).as_ptr() as *const [G; OUT_446]) }; __ret }, _ => { aiur_fn_446::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_271] = { let __args: [G; IN_271] = [__v_8, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(271, &__args[..])?) { [G::ZERO; OUT_271] } else { let (__hash, __hit) = record.function_queries[271].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[271].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[271].bump_multiplicity(__i); } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => { aiur_fn_271::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_445] = [__v_13]; record.function_queries[445].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_446: usize = 4; -const IN_446: usize = 4; -const OUT_446: usize = 1; -fn aiur_fn_446(inp: [G; IN_446], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_446], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_446] = [__v_4]; record.function_queries[446].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__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(2).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() { 5u64 => { let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(1); let __v_12: G = __v_2 - __v_11; let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __v_7, __v_12, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(446, &__args[..])?) { [G::ZERO; OUT_446] } else { let (__hash, __hit) = record.function_queries[446].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[446].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[446].bump_multiplicity(__i); } let __ret: [G; OUT_446] = unsafe { *(record.function_queries[446].output_at(__i).as_ptr() as *const [G; OUT_446]) }; __ret }, _ => { aiur_fn_446::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_446] = [__v_13]; record.function_queries[446].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_446] = [__v_4]; record.function_queries[446].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_447: usize = 4; -const IN_447: usize = 4; -const OUT_447: usize = 0; -fn aiur_fn_447(inp: [G; IN_447], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_447], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_447] = []; record.function_queries[447].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_271] = { let __args: [G; IN_271] = [__v_4, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(271, &__args[..])?) { [G::ZERO; OUT_271] } else { let (__hash, __hit) = record.function_queries[271].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[271].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[271].bump_multiplicity(__i); } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => { aiur_fn_271::(__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("projection on a Prop structure: field is not a Prop".to_string()) }); } let __ret: [G; OUT_447] = []; record.function_queries[447].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_448: usize = 5; -const IN_448: usize = 5; -const OUT_448: usize = 0; -fn aiur_fn_448(inp: [G; IN_448], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_448], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_448] = []; record.function_queries[448].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_271] = { let __args: [G; IN_271] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(271, &__args[..])?) { [G::ZERO; OUT_271] } else { let (__hash, __hit) = record.function_queries[271].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[271].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[271].bump_multiplicity(__i); } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => { aiur_fn_271::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_448] = []; record.function_queries[448].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(288, &__args[..])?) { [G::ZERO; OUT_288] } else { let (__hash, __hit) = record.function_queries[288].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[288].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => { aiur_fn_288::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("projection on a Prop structure: later fields depend on a data field".to_string()) }); } let __ret: [G; OUT_448] = []; record.function_queries[448].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_449: usize = 8; -const IN_449: usize = 8; -const OUT_449: usize = 1; -fn aiur_fn_449(inp: [G; IN_449], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_449], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 5u64 => { let __v_12: G = __v_2 - __v_3; match __v_12.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_0, __v_6, __v_9, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(447, &__args[..])?) { [G::ZERO; OUT_447] } else { let (__hash, __hit) = record.function_queries[447].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[447].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[447].bump_multiplicity(__i); } let __ret: [G; OUT_447] = unsafe { *(record.function_queries[447].output_at(__i).as_ptr() as *const [G; OUT_447]) }; __ret }, _ => { aiur_fn_447::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_449] = [__v_9]; record.function_queries[449].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_6, __v_9, __v_10, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(448, &__args[..])?) { [G::ZERO; OUT_448] } else { let (__hash, __hit) = record.function_queries[448].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[448].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[448].bump_multiplicity(__i); } let __ret: [G; OUT_448] = unsafe { *(record.function_queries[448].output_at(__i).as_ptr() as *const [G; OUT_448]) }; __ret }, _ => { aiur_fn_448::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = G::from_u64(8); let __v_14: G = { let __values: [G; 4] = [__v_13, __v_4, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(0); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_10, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); let __v_18: G = __v_3 + __v_17; let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_0, __v_16, __v_2, __v_18, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(449, &__args[..])?) { [G::ZERO; OUT_449] } else { let (__hash, __hit) = record.function_queries[449].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[449].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[449].bump_multiplicity(__i); } let __ret: [G; OUT_449] = unsafe { *(record.function_queries[449].output_at(__i).as_ptr() as *const [G; OUT_449]) }; __ret }, _ => { aiur_fn_449::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_449] = [__v_19]; record.function_queries[449].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } -const INPUT_SIZE_450: usize = 5; -const IN_450: usize = 5; -const OUT_450: usize = 1; -fn aiur_fn_450(inp: [G; IN_450], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_450], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(429, &__args[..])?) { [G::ZERO; OUT_429] } else { let (__hash, __hit) = record.function_queries[429].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[429].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[429].bump_multiplicity(__i); } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => { aiur_fn_429::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_5, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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() { 2u64 => { if (__v_10 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("projection's structure type differs from the value's head".to_string()) }); } let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].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]; let __v_25: G = __loaded[11]; match __v_14.as_canonical_u64() { 5u64 => { let __v_26: G = G::from_u64(1); if (__v_19 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("projection on an inductive with more than one constructor".to_string()) }); } let __v_27: G = G::from_u64(0); let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_21, __v_22, __v_27]; 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_28: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_29: G = __loaded[0]; let __v_30: G = __loaded[1]; let __v_31: G = __loaded[2]; let __v_32: G = __loaded[3]; let __v_33: G = __loaded[4]; let __v_34: G = __loaded[5]; let __v_35: G = __loaded[6]; let __v_36: G = __loaded[7]; let __v_37: G = __loaded[8]; let __v_38: G = __loaded[9]; let __v_39: G = __loaded[10]; let __v_40: G = __loaded[11]; match __v_29.as_canonical_u64() { 6u64 => { let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_31, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_41, __v_8, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(377, &__args[..])?) { [G::ZERO; OUT_377] } else { let (__hash, __hit) = record.function_queries[377].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[377].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => { aiur_fn_377::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __v_17 + __v_18; let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_16, __v_11, __v_43, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(445, &__args[..])?) { [G::ZERO; OUT_445] } else { let (__hash, __hit) = record.function_queries[445].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[445].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[445].bump_multiplicity(__i); } let __ret: [G; OUT_445] = unsafe { *(record.function_queries[445].output_at(__i).as_ptr() as *const [G; OUT_445]) }; __ret }, _ => { aiur_fn_445::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(0); let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_0, __v_42, __v_2, __v_45, __v_1, __v_3, __v_44, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(449, &__args[..])?) { [G::ZERO; OUT_449] } else { let (__hash, __hit) = record.function_queries[449].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[449].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[449].bump_multiplicity(__i); } let __ret: [G; OUT_449] = unsafe { *(record.function_queries[449].output_at(__i).as_ptr() as *const [G; OUT_449]) }; __ret }, _ => { aiur_fn_449::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_450] = [__v_46]; record.function_queries[450].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_29.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_451: usize = 3; -const IN_451: usize = 3; -const OUT_451: usize = 1; -fn aiur_fn_451(inp: [G; IN_451], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_451], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_429] = { let __args: [G; IN_429] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(429, &__args[..])?) { [G::ZERO; OUT_429] } else { let (__hash, __hit) = record.function_queries[429].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[429].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[429].bump_multiplicity(__i); } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => { aiur_fn_429::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__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(2).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_451] = [__v_6]; record.function_queries[451].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_452: usize = 4; -const IN_452: usize = 4; -const OUT_452: usize = 0; -fn aiur_fn_452(inp: [G; IN_452], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_452], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_429] = { let __args: [G; IN_429] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(429, &__args[..])?) { [G::ZERO; OUT_429] } else { let (__hash, __hit) = record.function_queries[429].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[429].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[429].bump_multiplicity(__i); } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => { aiur_fn_429::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_4, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("inferred type is not def-eq to the expected type".to_string()) }); } let __ret: [G; OUT_452] = []; record.function_queries[452].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_453: usize = 6; -const IN_453: usize = 6; -const OUT_453: usize = 2; -fn aiur_fn_453(inp: [G; IN_453], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_453], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_775] = { let __args: [G; IN_775] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(2); let __v_8: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_453] = [__v_9, __v_10]; record.function_queries[453].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { match __v_2.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_0, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(454, &__args[..])?) { [G::ZERO; OUT_454] } else { let (__hash, __hit) = record.function_queries[454].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[454].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[454].bump_multiplicity(__i); } let __ret: [G; OUT_454] = unsafe { *(record.function_queries[454].output_at(__i).as_ptr() as *const [G; OUT_454]) }; __ret }, _ => { aiur_fn_454::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_453] = [__v_9, __v_10]; record.function_queries[453].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_9: G = G::from_u64(1); let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_9, __v_1, __v_3, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(455, &__args[..])?) { [G::ZERO; OUT_455] } else { let (__hash, __hit) = record.function_queries[455].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[455].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[455].bump_multiplicity(__i); } let __ret: [G; OUT_455] = unsafe { *(record.function_queries[455].output_at(__i).as_ptr() as *const [G; OUT_455]) }; __ret }, _ => { aiur_fn_455::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_453] = [__v_10, __v_11]; record.function_queries[453].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_9, __v_1, __v_3, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(455, &__args[..])?) { [G::ZERO; OUT_455] } else { let (__hash, __hit) = record.function_queries[455].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[455].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[455].bump_multiplicity(__i); } let __ret: [G; OUT_455] = unsafe { *(record.function_queries[455].output_at(__i).as_ptr() as *const [G; OUT_455]) }; __ret }, _ => { aiur_fn_455::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_453] = [__v_10, __v_11]; record.function_queries[453].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(456, &__args[..])?) { [G::ZERO; OUT_456] } else { let (__hash, __hit) = record.function_queries[456].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[456].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[456].bump_multiplicity(__i); } let __ret: [G; OUT_456] = unsafe { *(record.function_queries[456].output_at(__i).as_ptr() as *const [G; OUT_456]) }; __ret }, _ => { aiur_fn_456::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_453] = [__v_9, __v_10]; record.function_queries[453].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_9: G = G::from_u64(1); let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_9, __v_1, __v_3, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(457, &__args[..])?) { [G::ZERO; OUT_457] } else { let (__hash, __hit) = record.function_queries[457].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[457].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[457].bump_multiplicity(__i); } let __ret: [G; OUT_457] = unsafe { *(record.function_queries[457].output_at(__i).as_ptr() as *const [G; OUT_457]) }; __ret }, _ => { aiur_fn_457::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_453] = [__v_10, __v_11]; record.function_queries[453].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_9, __v_1, __v_3, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(457, &__args[..])?) { [G::ZERO; OUT_457] } else { let (__hash, __hit) = record.function_queries[457].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[457].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[457].bump_multiplicity(__i); } let __ret: [G; OUT_457] = unsafe { *(record.function_queries[457].output_at(__i).as_ptr() as *const [G; OUT_457]) }; __ret }, _ => { aiur_fn_457::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_453] = [__v_10, __v_11]; record.function_queries[453].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_453] = [__v_9, __v_10]; record.function_queries[453].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_454: usize = 3; -const IN_454: usize = 3; -const OUT_454: usize = 2; -fn aiur_fn_454(inp: [G; IN_454], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_454], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_454] = [__v_10, __v_11]; record.function_queries[454].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_10]; 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_11: G = __r_arr[0]; let __v_12: G = G::from_u64(2); let __v_13: G = G::from_u64(68); let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(481, &__args[..])?) { [G::ZERO; OUT_481] } else { let (__hash, __hit) = record.function_queries[481].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[481].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => { aiur_fn_481::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_12, __v_14, __v_16, __v_17]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(3); let __v_20: G = { let __values: [G; 4] = [__v_19, __v_18, __v_11, __v_17]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_19, __v_20, __v_6, __v_17]; let __mq = record.memory_queries.get_index_mut(2).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_777] = { let __args: [G; IN_777] = [__v_1, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_21, __v_22]; 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_23: G = __r_arr[0]; let __ret: [G; OUT_454] = [__v_15, __v_23]; record.function_queries[454].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } -const INPUT_SIZE_455: usize = 6; -const IN_455: usize = 6; -const OUT_455: usize = 2; -fn aiur_fn_455(inp: [G; IN_455], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_455], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_4, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_4, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_7, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_9, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_10]; 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 = __r_arr[1]; match __v_12.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(2).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_455] = [__v_14, __v_15]; record.function_queries[455].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_11]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(2).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_455] = [__v_16, __v_17]; record.function_queries[455].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_1.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_13, __v_15]; 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_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, _ => { let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_13, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(285, &__args[..])?) { [G::ZERO; OUT_285] } else { let (__hash, __hit) = record.function_queries[285].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[285].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[285].bump_multiplicity(__i); } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => { aiur_fn_285::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, } }; let __v_16: G = __mc_out___mc_0[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_1.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(2); let __v_18: G = G::from_u64(66); let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(482, &__args[..])?) { [G::ZERO; OUT_482] } else { let (__hash, __hit) = record.function_queries[482].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[482].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => { aiur_fn_482::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_17, __v_19, __v_21, __v_22]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(3); let __v_25: G = { let __values: [G; 4] = [__v_24, __v_23, __v_7, __v_22]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_24, __v_25, __v_9, __v_22]; let __mq = record.memory_queries.get_index_mut(2).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_1 [__v_26]; }, _ => { let __v_17: G = G::from_u64(2); let __v_18: G = G::from_u64(0); let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(481, &__args[..])?) { [G::ZERO; OUT_481] } else { let (__hash, __hit) = record.function_queries[481].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[481].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => { aiur_fn_481::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_17, __v_19, __v_21, __v_18]; let __mq = record.memory_queries.get_index_mut(2).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_459] = { let __args: [G; IN_459] = [__v_0, __v_22, __v_7, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(459, &__args[..])?) { [G::ZERO; OUT_459] } else { let (__hash, __hit) = record.function_queries[459].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[459].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => { aiur_fn_459::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; break '__mc_1 [__v_23]; }, } }; let __v_17: G = __mc_out___mc_1[0]; let __v_18: G = G::from_u64(3); let __v_19: G = G::from_u64(2); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_19, __v_2, __v_3, __v_20]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_18, __v_21, __v_7, __v_20]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_18, __v_22, __v_9, __v_20]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(1); let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_16, __v_17, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(460, &__args[..])?) { [G::ZERO; OUT_460] } else { let (__hash, __hit) = record.function_queries[460].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[460].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[460].bump_multiplicity(__i); } let __ret: [G; OUT_460] = unsafe { *(record.function_queries[460].output_at(__i).as_ptr() as *const [G; OUT_460]) }; __ret }, _ => { aiur_fn_460::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_4, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_25, __v_26]; 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_27: G = __r_arr[0]; let __ret: [G; OUT_455] = [__v_24, __v_27]; record.function_queries[455].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }) } -const INPUT_SIZE_456: usize = 3; -const IN_456: usize = 3; -const OUT_456: usize = 2; -fn aiur_fn_456(inp: [G; IN_456], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_456], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; match __v_8.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_456] = [__v_11, __v_12]; record.function_queries[456].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(7).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_14: G = { let __values: [G; 10] = [__v_11, __v_12, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_13]; let __mq = record.memory_queries.get_index_mut(7).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_194] = { let __args: [G; IN_194] = [__v_0, __v_9, __v_10, __v_11, __v_14]; 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_15: G = __r_arr[0]; let __v_16: G = G::from_u64(2); let __v_17: G = G::from_u64(96); let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(481, &__args[..])?) { [G::ZERO; OUT_481] } else { let (__hash, __hit) = record.function_queries[481].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[481].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => { aiur_fn_481::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 3] = [__v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_16, __v_18, __v_19, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = G::from_u64(3); let __v_22: G = { let __values: [G; 4] = [__v_21, __v_20, __v_15, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_21, __v_22, __v_6, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_777] = { let __args: [G; IN_777] = [__v_1, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_23, __v_24]; 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_25: G = __r_arr[0]; let __ret: [G; OUT_456] = [__v_12, __v_25]; record.function_queries[456].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } -const INPUT_SIZE_457: usize = 6; -const IN_457: usize = 6; -const OUT_457: usize = 2; -fn aiur_fn_457(inp: [G; IN_457], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_457], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_4, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_4, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_7, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_9, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_10]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; match __v_12.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(2).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_457] = [__v_15, __v_16]; record.function_queries[457].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_11]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; match __v_15.as_canonical_u64() { 0u64 => { let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_index_mut(2).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_457] = [__v_18, __v_19]; record.function_queries[457].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_1.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_13, __v_14, __v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(458, &__args[..])?) { [G::ZERO; OUT_458] } else { let (__hash, __hit) = record.function_queries[458].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[458].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => { aiur_fn_458::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; break '__mc_0 [__v_18]; }, _ => { let __v_18: G = G::from_u64(1); let __v_19: G = __v_13 - __v_16; let __v_20: G = __v_19 * __v_19; let __v_21: G = __v_18 - __v_20; let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_14, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(285, &__args[..])?) { [G::ZERO; OUT_285] } else { let (__hash, __hit) = record.function_queries[285].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[285].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[285].bump_multiplicity(__i); } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => { aiur_fn_285::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = __v_21 * __v_22; break '__mc_0 [__v_23]; }, } }; let __v_18: G = __mc_out___mc_0[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_1.as_canonical_u64() { 1u64 => { let __v_19: G = G::from_u64(2); let __v_20: G = G::from_u64(94); let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(482, &__args[..])?) { [G::ZERO; OUT_482] } else { let (__hash, __hit) = record.function_queries[482].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[482].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => { aiur_fn_482::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; 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(1).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 = G::from_u64(0); let __v_25: G = { let __values: [G; 4] = [__v_19, __v_21, __v_23, __v_24]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(3); let __v_27: G = { let __values: [G; 4] = [__v_26, __v_25, __v_7, __v_24]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_26, __v_27, __v_9, __v_24]; let __mq = record.memory_queries.get_index_mut(2).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_1 [__v_28]; }, _ => { let __v_19: G = G::from_u64(2); let __v_20: G = G::from_u64(70); let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(482, &__args[..])?) { [G::ZERO; OUT_482] } else { let (__hash, __hit) = record.function_queries[482].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[482].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => { aiur_fn_482::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; 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(1).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 = G::from_u64(0); let __v_25: G = { let __values: [G; 4] = [__v_19, __v_21, __v_23, __v_24]; let __mq = record.memory_queries.get_index_mut(2).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_459] = { let __args: [G; IN_459] = [__v_0, __v_25, __v_7, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(459, &__args[..])?) { [G::ZERO; OUT_459] } else { let (__hash, __hit) = record.function_queries[459].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[459].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => { aiur_fn_459::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; break '__mc_1 [__v_26]; }, } }; let __v_19: G = __mc_out___mc_1[0]; let __v_20: G = G::from_u64(3); let __v_21: G = G::from_u64(2); let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_21, __v_2, __v_3, __v_22]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_20, __v_23, __v_7, __v_22]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_20, __v_24, __v_9, __v_22]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(1); let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_18, __v_19, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(460, &__args[..])?) { [G::ZERO; OUT_460] } else { let (__hash, __hit) = record.function_queries[460].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[460].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[460].bump_multiplicity(__i); } let __ret: [G; OUT_460] = unsafe { *(record.function_queries[460].output_at(__i).as_ptr() as *const [G; OUT_460]) }; __ret }, _ => { aiur_fn_460::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_4, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_27, __v_28]; 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_29: G = __r_arr[0]; let __ret: [G; OUT_457] = [__v_26, __v_29]; record.function_queries[457].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }) } -const INPUT_SIZE_458: usize = 4; -const IN_458: usize = 4; -const OUT_458: usize = 1; -fn aiur_fn_458(inp: [G; IN_458], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_458], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_0.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_1, __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_4: G = __r_arr[0]; let __ret: [G; OUT_458] = [__v_4]; record.function_queries[458].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_458] = [__v_4]; record.function_queries[458].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_458] = [__v_4]; record.function_queries[458].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_3, __v_1]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_458] = [__v_4]; record.function_queries[458].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_459: usize = 4; -const IN_459: usize = 4; -const OUT_459: usize = 1; -fn aiur_fn_459(inp: [G; IN_459], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_459], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_4, __v_6, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(8); let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(481, &__args[..])?) { [G::ZERO; OUT_481] } else { let (__hash, __hit) = record.function_queries[481].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[481].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => { aiur_fn_481::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_5, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_10, __v_12, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_15: G = { let __values: [G; 4] = [__v_14, __v_13, __v_1, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_14, __v_15, __v_2, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_14, __v_16, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_459] = [__v_17]; record.function_queries[459].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_460: usize = 4; -const IN_460: usize = 4; -const OUT_460: usize = 1; -fn aiur_fn_460(inp: [G; IN_460], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_460], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_4, __v_6, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(9); let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(481, &__args[..])?) { [G::ZERO; OUT_481] } else { let (__hash, __hit) = record.function_queries[481].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[481].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => { aiur_fn_481::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_5, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_10, __v_12, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(481, &__args[..])?) { [G::ZERO; OUT_481] } else { let (__hash, __hit) = record.function_queries[481].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[481].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => { aiur_fn_481::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_11, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_18: G = { let __values: [G; 4] = [__v_17, __v_13, __v_16, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_161] = { let __args: [G; IN_161] = [__v_0, __v_1]; 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_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_1.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(63); let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(482, &__args[..])?) { [G::ZERO; OUT_482] } else { let (__hash, __hit) = record.function_queries[482].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[482].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => { aiur_fn_482::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; break '__mc_0 [__v_22]; }, _ => { let __v_21: G = G::from_u64(64); let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(482, &__args[..])?) { [G::ZERO; OUT_482] } else { let (__hash, __hit) = record.function_queries[482].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[482].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => { aiur_fn_482::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; break '__mc_0 [__v_22]; }, } }; let __v_21: G = __mc_out___mc_0[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_1.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(60); let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(482, &__args[..])?) { [G::ZERO; OUT_482] } else { let (__hash, __hit) = record.function_queries[482].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[482].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => { aiur_fn_482::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; break '__mc_1 [__v_23]; }, _ => { let __v_22: G = G::from_u64(61); let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(482, &__args[..])?) { [G::ZERO; OUT_482] } else { let (__hash, __hit) = record.function_queries[482].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[482].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => { aiur_fn_482::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; break '__mc_1 [__v_23]; }, } }; let __v_22: G = __mc_out___mc_1[0]; let __v_23: G = G::from_u64(3); let __v_24: G = G::from_u64(2); let __v_25: G = G::from_u64(1); let __v_26: G = { let __values: [G; 3] = [__v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_24, __v_21, __v_26, __v_27]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_23, __v_28, __v_2, __v_27]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_23, __v_29, __v_3, __v_27]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_23, __v_30, __v_20, __v_27]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_24, __v_22, __v_26, __v_27]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_23, __v_32, __v_2, __v_27]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_23, __v_33, __v_31, __v_27]; let __mq = record.memory_queries.get_index_mut(2).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_460] = [__v_34]; record.function_queries[460].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_461: usize = 4; -const IN_461: usize = 4; -const OUT_461: usize = 2; -fn aiur_fn_461(inp: [G; IN_461], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_461], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_775] = { let __args: [G; IN_775] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(2); let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_461] = [__v_7, __v_8]; record.function_queries[461].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_2, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 7u64 => { match __v_12.as_canonical_u64() { 1u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 7u64 => { match __v_16.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_13, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(286, &__args[..])?) { [G::ZERO; OUT_286] } else { let (__hash, __hit) = record.function_queries[286].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[286].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[286].bump_multiplicity(__i); } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => { aiur_fn_286::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; match __v_19.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_20, __v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_index_mut(2).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_461] = [__v_20, __v_21]; record.function_queries[461].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(2); let __v_21: G = G::from_u64(37); let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(481, &__args[..])?) { [G::ZERO; OUT_481] } else { let (__hash, __hit) = record.function_queries[481].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[481].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => { aiur_fn_481::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); let __v_24: G = { let __values: [G; 3] = [__v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_20, __v_22, __v_24, __v_25]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = G::from_u64(3); let __v_28: G = { let __values: [G; 4] = [__v_20, __v_1, __v_24, __v_25]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_27, __v_28, __v_8, __v_25]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_27, __v_29, __v_10, __v_25]; let __mq = record.memory_queries.get_index_mut(2).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_459] = { let __args: [G; IN_459] = [__v_0, __v_26, __v_8, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(459, &__args[..])?) { [G::ZERO; OUT_459] } else { let (__hash, __hit) = record.function_queries[459].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[459].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => { aiur_fn_459::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_23, __v_31, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(460, &__args[..])?) { [G::ZERO; OUT_460] } else { let (__hash, __hit) = record.function_queries[460].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[460].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[460].bump_multiplicity(__i); } let __ret: [G; OUT_460] = unsafe { *(record.function_queries[460].output_at(__i).as_ptr() as *const [G; OUT_460]) }; __ret }, _ => { aiur_fn_460::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_32, __v_33]; 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_34: G = __r_arr[0]; let __ret: [G; OUT_461] = [__v_23, __v_34]; record.function_queries[461].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_index_mut(2).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_461] = [__v_19, __v_20]; record.function_queries[461].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_index_mut(2).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_461] = [__v_19, __v_20]; record.function_queries[461].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(2).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_461] = [__v_15, __v_16]; record.function_queries[461].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(2).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_461] = [__v_15, __v_16]; record.function_queries[461].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_462: usize = 1; -const IN_462: usize = 1; -const OUT_462: usize = 1; -fn aiur_fn_462(inp: [G; IN_462], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_462], ExecError> { stacker::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; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).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_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = G::from_u64(6); let __io_pair: (G, G) = { let __key: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_33, __v_34, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(5, &__args[..])?) { [G::ZERO; OUT_5] } else { let (__hash, __hit) = record.function_queries[5].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[5].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => { aiur_fn_5::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_36, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __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(22, &__args[..])?) { [G::ZERO; OUT_22] } else { let (__hash, __hit) = record.function_queries[22].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[22].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[22].bump_multiplicity(__i); } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => { aiur_fn_22::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_36]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = G::from_u64(232); if (__v_37 != __v_39) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_39.as_canonical_u64(), msg: Some("role table: not a binding section".to_string()) }); } let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_38]; 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_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = G::from_u64(3); if (__v_40 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("role table: not a binding section".to_string()) }); } let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_41]; 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_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; if (__v_43 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("role table: made for another specification version".to_string()) }); } let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_44]; 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_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(1); let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_46, __v_45, __v_47, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(463, &__args[..])?) { [G::ZERO; OUT_463] } else { let (__hash, __hit) = record.function_queries[463].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[463].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[463].bump_multiplicity(__i); } let __ret: [G; OUT_463] = unsafe { *(record.function_queries[463].output_at(__i).as_ptr() as *const [G; OUT_463]) }; __ret }, _ => { aiur_fn_463::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; let __v_52: G = __r_arr[3]; let __v_53: G = __r_arr[4]; let __v_54: G = __r_arr[5]; let __v_55: G = __r_arr[6]; let __v_56: G = __r_arr[7]; let __v_57: G = __r_arr[8]; let __v_58: G = __r_arr[9]; let __v_59: G = __r_arr[10]; let __v_60: G = __r_arr[11]; let __v_61: G = __r_arr[12]; let __v_62: G = __r_arr[13]; let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_62]; 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_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_64, __v_63, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(464, &__args[..])?) { [G::ZERO; OUT_464] } else { let (__hash, __hit) = record.function_queries[464].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[464].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[464].bump_multiplicity(__i); } let __ret: [G; OUT_464] = unsafe { *(record.function_queries[464].output_at(__i).as_ptr() as *const [G; OUT_464]) }; __ret }, _ => { aiur_fn_464::(__args, __hash, record, io_buffer)? }, } } }; let __v_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __v_67: G = __r_arr[2]; let __v_68: G = __r_arr[3]; let __v_69: G = __r_arr[4]; let __v_70: G = __r_arr[5]; let __v_71: G = __r_arr[6]; let __v_72: G = __r_arr[7]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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]; if (__v_73 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("role table: trailing bytes".to_string()) }); } if (__v_74 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("role table: trailing bytes".to_string()) }); } if (__v_75 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("role table: trailing bytes".to_string()) }); } let __v_76: G = { let __values: [G; 19] = [__v_0, __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_65, __v_66, __v_67, __v_68, __v_69, __v_70]; let __mq = record.memory_queries.get_index_mut(11).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(19))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 19)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_462] = [__v_76]; record.function_queries[462].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_463: usize = 9; -const IN_463: usize = 9; -const OUT_463: usize = 14; -fn aiur_fn_463(inp: [G; IN_463], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_463], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_1.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_463] = [__v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_2, __v_0]; record.function_queries[463].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = if unconstrained { aiur::execute::CodegenBytes1::shift_right(&__v_1) } else { aiur::execute::bytes1_shift_right_value(__v_1, record) }; let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_0, __v_9, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(463, &__args[..])?) { [G::ZERO; OUT_463] } else { let (__hash, __hit) = record.function_queries[463].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[463].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[463].bump_multiplicity(__i); } let __ret: [G; OUT_463] = unsafe { *(record.function_queries[463].output_at(__i).as_ptr() as *const [G; OUT_463]) }; __ret }, _ => { aiur_fn_463::(__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 = __r_arr[9]; let __v_20: G = __r_arr[10]; let __v_21: G = __r_arr[11]; let __v_22: G = __r_arr[12]; let __v_23: G = __r_arr[13]; let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = G::from_u64(103); let __v_27: G = { let __a_val = __v_24.as_canonical_u64(); let __b_val = __v_26.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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 __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: Some("role table: unknown role".to_string()) }); } let __v_29: G = { let __a_val = __v_24.as_canonical_u64(); let __b_val = __v_22.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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 __v_30: G = G::from_u64(0); if (__v_29 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("role table: roles out of order".to_string()) }); } let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_25]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_31, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(763, &__args[..])?) { [G::ZERO; OUT_763] } else { let (__hash, __hit) = record.function_queries[763].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[763].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => { aiur_fn_763::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; if (__v_33 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("role table: an address is bound to two roles".to_string()) }); } let __v_34: G = __v_24 + __v_28; let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_31, __v_34, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(779, &__args[..])?) { [G::ZERO; OUT_779] } else { let (__hash, __hit) = record.function_queries[779].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[779].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => { aiur_fn_779::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = __r_arr[2]; let __v_38: G = __r_arr[3]; let __v_39: G = __r_arr[4]; let __v_40: G = __r_arr[5]; let __v_41: G = __v_9 + __v_28; let __v_42: G = __v_1 - __v_41; let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_32, __v_42, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(463, &__args[..])?) { [G::ZERO; OUT_463] } else { let (__hash, __hit) = record.function_queries[463].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[463].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[463].bump_multiplicity(__i); } let __ret: [G; OUT_463] = unsafe { *(record.function_queries[463].output_at(__i).as_ptr() as *const [G; OUT_463]) }; __ret }, _ => { aiur_fn_463::(__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 = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __mq = record.memory_queries.get_index_mut(4).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_58: G = { let __values: [G; 6] = [__v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_index_mut(4).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_463] = [__v_30, __v_28, __v_24, __v_31, __v_57, __v_58, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; record.function_queries[463].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_464: usize = 3; -const IN_464: usize = 3; -const OUT_464: usize = 8; -fn aiur_fn_464(inp: [G; IN_464], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_464], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __ret: [G; OUT_464] = [__v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_2, __v_0]; record.function_queries[464].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = if unconstrained { aiur::execute::CodegenBytes1::shift_right(&__v_1) } else { aiur::execute::bytes1_shift_right_value(__v_1, record) }; let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_0, __v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(464, &__args[..])?) { [G::ZERO; OUT_464] } else { let (__hash, __hit) = record.function_queries[464].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[464].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[464].bump_multiplicity(__i); } let __ret: [G; OUT_464] = unsafe { *(record.function_queries[464].output_at(__i).as_ptr() as *const [G; OUT_464]) }; __ret }, _ => { aiur_fn_464::(__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 __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = G::from_u64(103); let __v_15: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_14.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 __v_16: G = G::from_u64(1); if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("role table: unknown role".to_string()) }); } let __v_17: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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 __v_18: G = G::from_u64(0); if (__v_17 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("role table: evidence out of order".to_string()) }); } let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_13]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_20, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(465, &__args[..])?) { [G::ZERO; OUT_465] } else { let (__hash, __hit) = record.function_queries[465].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[465].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[465].bump_multiplicity(__i); } let __ret: [G; OUT_465] = unsafe { *(record.function_queries[465].output_at(__i).as_ptr() as *const [G; OUT_465]) }; __ret }, _ => { aiur_fn_465::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __v_3 + __v_16; let __v_24: G = __v_1 - __v_23; let __v_25: G = __v_12 + __v_16; let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_22, __v_24, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(464, &__args[..])?) { [G::ZERO; OUT_464] } else { let (__hash, __hit) = record.function_queries[464].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[464].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[464].bump_multiplicity(__i); } let __ret: [G; OUT_464] = unsafe { *(record.function_queries[464].output_at(__i).as_ptr() as *const [G; OUT_464]) }; __ret }, _ => { aiur_fn_464::(__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 = { let __values: [G; 6] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_index_mut(4).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_35: G = { let __values: [G; 6] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(4).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_464] = [__v_18, __v_16, __v_12, __v_21, __v_34, __v_35, __v_32, __v_33]; record.function_queries[464].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_465: usize = 2; -const IN_465: usize = 2; -const OUT_465: usize = 2; -fn aiur_fn_465(inp: [G; IN_465], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_465], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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(2).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_465] = [__v_3, __v_0]; record.function_queries[465].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(465, &__args[..])?) { [G::ZERO; OUT_465] } else { let (__hash, __hit) = record.function_queries[465].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[465].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[465].bump_multiplicity(__i); } let __ret: [G; OUT_465] = unsafe { *(record.function_queries[465].output_at(__i).as_ptr() as *const [G; OUT_465]) }; __ret }, _ => { aiur_fn_465::(__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; 4] = [__v_8, __v_8, __v_8, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_465] = [__v_9, __v_7]; record.function_queries[465].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_3]; 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_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_465] = { let __args: [G; IN_465] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(465, &__args[..])?) { [G::ZERO; OUT_465] } else { let (__hash, __hit) = record.function_queries[465].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[465].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[465].bump_multiplicity(__i); } let __ret: [G; OUT_465] = unsafe { *(record.function_queries[465].output_at(__i).as_ptr() as *const [G; OUT_465]) }; __ret }, _ => { aiur_fn_465::(__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; 4] = [__v_10, __v_6, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_465] = [__v_11, __v_9]; record.function_queries[465].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_466: usize = 2; -const IN_466: usize = 2; -const OUT_466: usize = 1; -fn aiur_fn_466(inp: [G; IN_466], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_466], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_0, __v_1, __v_2, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(468, &__args[..])?) { [G::ZERO; OUT_468] } else { let (__hash, __hit) = record.function_queries[468].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[468].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[468].bump_multiplicity(__i); } let __ret: [G; OUT_468] = unsafe { *(record.function_queries[468].output_at(__i).as_ptr() as *const [G; OUT_468]) }; __ret }, _ => { aiur_fn_468::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_466] = [__v_3]; record.function_queries[466].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_467: usize = 8; -const IN_467: usize = 8; -const OUT_467: usize = 6; -fn aiur_fn_467(inp: [G; IN_467], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_467], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_467] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[467].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(477, &__args[..])?) { [G::ZERO; OUT_477] } else { let (__hash, __hit) = record.function_queries[477].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[477].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => { aiur_fn_477::(__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 = G::from_u64(0); let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(763, &__args[..])?) { [G::ZERO; OUT_763] } else { let (__hash, __hit) = record.function_queries[763].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[763].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => { aiur_fn_763::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; if (__v_18 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("claim: user axiom is bound in the role table".to_string()) }); } let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; let __v_23: G = __loaded[3]; let __v_24: G = __loaded[4]; let __v_25: G = __loaded[5]; let __v_26: G = __loaded[6]; let __v_27: G = __loaded[7]; let __v_28: G = __loaded[8]; let __v_29: G = __loaded[9]; let __v_30: G = __loaded[10]; let __v_31: G = __loaded[11]; match __v_20.as_canonical_u64() { 0u64 => { let __v_32: G = G::from_u64(0); if (__v_23 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("claim: user axiom is unsafe".to_string()) }); } let __v_33: G = G::from_u64(1); let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_9, __v_33, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(779, &__args[..])?) { [G::ZERO; OUT_779] } else { let (__hash, __hit) = record.function_queries[779].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[779].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => { aiur_fn_779::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; let __v_37: G = __r_arr[3]; let __v_38: G = __r_arr[4]; let __v_39: G = __r_arr[5]; let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_10, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(467, &__args[..])?) { [G::ZERO; OUT_467] } else { let (__hash, __hit) = record.function_queries[467].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[467].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[467].bump_multiplicity(__i); } let __ret: [G; OUT_467] = unsafe { *(record.function_queries[467].output_at(__i).as_ptr() as *const [G; OUT_467]) }; __ret }, _ => { aiur_fn_467::(__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 __ret: [G; OUT_467] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; record.function_queries[467].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); if (__v_32 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: Some("claim: axioms tree entry is not an axiom".to_string()) }); } let __ret: [G; OUT_467] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; record.function_queries[467].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } -const INPUT_SIZE_468: usize = 4; -const IN_468: usize = 4; -const OUT_468: usize = 1; -fn aiur_fn_468(inp: [G; IN_468], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_468], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_462] = { let __args: [G; IN_462] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(462, &__args[..])?) { [G::ZERO; OUT_462] } else { let (__hash, __hit) = record.function_queries[462].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[462].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[462].bump_multiplicity(__i); } let __ret: [G; OUT_462] = unsafe { *(record.function_queries[462].output_at(__i).as_ptr() as *const [G; OUT_462]) }; __ret }, _ => { aiur_fn_462::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __mc_out___mc_0: [G; 6] = '__mc_0: { match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); break '__mc_0 [__v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; }, 0u64 => { let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(705, &__args[..])?) { [G::ZERO; OUT_705] } else { let (__hash, __hit) = record.function_queries[705].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[705].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[705].bump_multiplicity(__i); } let __ret: [G; OUT_705] = unsafe { *(record.function_queries[705].output_at(__i).as_ptr() as *const [G; OUT_705]) }; __ret }, _ => { aiur_fn_705::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_4, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(467, &__args[..])?) { [G::ZERO; OUT_467] } else { let (__hash, __hit) = record.function_queries[467].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[467].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[467].bump_multiplicity(__i); } let __ret: [G; OUT_467] = unsafe { *(record.function_queries[467].output_at(__i).as_ptr() as *const [G; OUT_467]) }; __ret }, _ => { aiur_fn_467::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; let __v_10: G = __r_arr[3]; let __v_11: G = __r_arr[4]; let __v_12: G = __r_arr[5]; break '__mc_0 [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }; let __v_5: G = __mc_out___mc_0[0]; let __v_6: G = __mc_out___mc_0[1]; let __v_7: G = __mc_out___mc_0[2]; let __v_8: G = __mc_out___mc_0[3]; let __v_9: G = __mc_out___mc_0[4]; let __v_10: G = __mc_out___mc_0[5]; match __v_1.as_canonical_u64() { 3u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(72); let __v_13: G = { let __values: [G; 9] = [__v_11, __v_4, __v_12, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 9)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_468] = [__v_13]; record.function_queries[468].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 9] = [__v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 9)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_468] = [__v_13]; record.function_queries[468].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); if (__v_11 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("claim: wrong validator identity".to_string()) }); } let __v_13: G = G::from_u64(72); let __v_14: G = { let __values: [G; 9] = [__v_11, __v_4, __v_13, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 9)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_468] = [__v_14]; record.function_queries[468].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_469: usize = 1; -const IN_469: usize = 1; -const OUT_469: usize = 1; -fn aiur_fn_469(inp: [G; IN_469], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_469], ExecError> { stacker::maybe_grow(64 * 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(3); let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(472, &__args[..])?) { [G::ZERO; OUT_472] } else { let (__hash, __hit) = record.function_queries[472].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[472].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => { aiur_fn_472::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = __v_1 + __v_2; let __ret: [G; OUT_469] = [__v_3]; record.function_queries[469].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_470: usize = 1; -const IN_470: usize = 1; -const OUT_470: usize = 1; -fn aiur_fn_470(inp: [G; IN_470], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_470], ExecError> { stacker::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; 9] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; 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: 9 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_470] = [__v_2]; record.function_queries[470].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_470] = [__v_2]; record.function_queries[470].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_471: usize = 1; -const IN_471: usize = 1; -const OUT_471: usize = 6; -fn aiur_fn_471(inp: [G; IN_471], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_471], ExecError> { stacker::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; 9] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; 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: 9 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_471] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; record.function_queries[471].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_471] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; record.function_queries[471].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_472: usize = 1; -const IN_472: usize = 1; -const OUT_472: usize = 1; -fn aiur_fn_472(inp: [G; IN_472], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_472], ExecError> { stacker::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; 9] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; 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: 9 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; match __v_1.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_472] = [__v_10]; record.function_queries[472].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_472] = [__v_10]; record.function_queries[472].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_473: usize = 1; -const IN_473: usize = 1; -const OUT_473: usize = 1; -fn aiur_fn_473(inp: [G; IN_473], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_473], ExecError> { stacker::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_470] = { let __args: [G; IN_470] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(470, &__args[..])?) { [G::ZERO; OUT_470] } else { let (__hash, __hit) = record.function_queries[470].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[470].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[470].bump_multiplicity(__i); } let __ret: [G; OUT_470] = unsafe { *(record.function_queries[470].output_at(__i).as_ptr() as *const [G; OUT_470]) }; __ret }, _ => { aiur_fn_470::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __loaded: [G; 19] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(11).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(19))?; 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: 19 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 19] = __args[..19].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; match __v_2.as_canonical_u64() { _ => { let __ret: [G; OUT_473] = [__v_2]; record.function_queries[473].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_474: usize = 2; -const IN_474: usize = 2; -const OUT_474: usize = 1; -fn aiur_fn_474(inp: [G; IN_474], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_474], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 19] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(11).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(19))?; 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: 19 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 19] = __args[..19].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; match __v_2.as_canonical_u64() { _ => { let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 32] = [__v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_index_mut(12).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_763] = { let __args: [G; IN_763] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(763, &__args[..])?) { [G::ZERO; OUT_763] } else { let (__hash, __hit) = record.function_queries[763].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[763].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => { aiur_fn_763::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_474] = [__v_23]; record.function_queries[474].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_475: usize = 2; -const IN_475: usize = 2; -const OUT_475: usize = 1; -fn aiur_fn_475(inp: [G; IN_475], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_475], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_474] = { let __args: [G; IN_474] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(474, &__args[..])?) { [G::ZERO; OUT_474] } else { let (__hash, __hit) = record.function_queries[474].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[474].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[474].bump_multiplicity(__i); } let __ret: [G; OUT_474] = unsafe { *(record.function_queries[474].output_at(__i).as_ptr() as *const [G; OUT_474]) }; __ret }, _ => { aiur_fn_474::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(477, &__args[..])?) { [G::ZERO; OUT_477] } else { let (__hash, __hit) = record.function_queries[477].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[477].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => { aiur_fn_477::(__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 = G::from_u64(0); let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(763, &__args[..])?) { [G::ZERO; OUT_763] } else { let (__hash, __hit) = record.function_queries[763].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[763].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => { aiur_fn_763::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = __v_1 + __v_11; let __v_13: G = __v_10 - __v_12; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(1); let __ret: [G; OUT_475] = [__v_14]; record.function_queries[475].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_475] = [__v_14]; record.function_queries[475].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_476: usize = 2; -const IN_476: usize = 2; -const OUT_476: usize = 1; -fn aiur_fn_476(inp: [G; IN_476], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_476], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_475] = { let __args: [G; IN_475] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(475, &__args[..])?) { [G::ZERO; OUT_475] } else { let (__hash, __hit) = record.function_queries[475].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[475].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[475].bump_multiplicity(__i); } let __ret: [G; OUT_475] = unsafe { *(record.function_queries[475].output_at(__i).as_ptr() as *const [G; OUT_475]) }; __ret }, _ => { aiur_fn_475::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); if (__v_2 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("role table does not bind a role the claim needs".to_string()) }); } let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(474, &__args[..])?) { [G::ZERO; OUT_474] } else { let (__hash, __hit) = record.function_queries[474].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[474].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[474].bump_multiplicity(__i); } let __ret: [G; OUT_474] = unsafe { *(record.function_queries[474].output_at(__i).as_ptr() as *const [G; OUT_474]) }; __ret }, _ => { aiur_fn_474::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_476] = [__v_4]; record.function_queries[476].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_477: usize = 1; -const IN_477: usize = 1; -const OUT_477: usize = 6; -fn aiur_fn_477(inp: [G; IN_477], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_477], ExecError> { stacker::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; 19] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(11).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(19))?; 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: 19 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 19] = __args[..19].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]; match __v_1.as_canonical_u64() { _ => { let __ret: [G; OUT_477] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; record.function_queries[477].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_478: usize = 2; -const IN_478: usize = 2; -const OUT_478: usize = 1; -fn aiur_fn_478(inp: [G; IN_478], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_478], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 9] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; 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: 9 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].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]; match __v_2.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(477, &__args[..])?) { [G::ZERO; OUT_477] } else { let (__hash, __hit) = record.function_queries[477].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[477].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => { aiur_fn_477::(__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 = G::from_u64(0); let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_1, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(763, &__args[..])?) { [G::ZERO; OUT_763] } else { let (__hash, __hit) = record.function_queries[763].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[763].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => { aiur_fn_763::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); let __ret: [G; OUT_478] = [__v_19]; record.function_queries[478].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(1); let __v_20: G = __v_18 - __v_19; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(549, &__args[..])?) { [G::ZERO; OUT_549] } else { let (__hash, __hit) = record.function_queries[549].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[549].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => { aiur_fn_549::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __a_val = __v_21.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = __v_18 - __v_23; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(549, &__args[..])?) { [G::ZERO; OUT_549] } else { let (__hash, __hit) = record.function_queries[549].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[549].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => { aiur_fn_549::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_3, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(483, &__args[..])?) { [G::ZERO; OUT_483] } else { let (__hash, __hit) = record.function_queries[483].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[483].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[483].bump_multiplicity(__i); } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => { aiur_fn_483::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_478] = [__v_18]; record.function_queries[478].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(0); let __ret: [G; OUT_478] = [__v_23]; record.function_queries[478].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, 1u64 => { let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(477, &__args[..])?) { [G::ZERO; OUT_477] } else { let (__hash, __hit) = record.function_queries[477].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[477].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => { aiur_fn_477::(__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 = G::from_u64(0); let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_1, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(763, &__args[..])?) { [G::ZERO; OUT_763] } else { let (__hash, __hit) = record.function_queries[763].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[763].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => { aiur_fn_763::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_478] = [__v_18]; record.function_queries[478].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_479: usize = 2; -const IN_479: usize = 2; -const OUT_479: usize = 1; -fn aiur_fn_479(inp: [G; IN_479], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_479], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_470] = { let __args: [G; IN_470] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(470, &__args[..])?) { [G::ZERO; OUT_470] } else { let (__hash, __hit) = record.function_queries[470].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[470].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[470].bump_multiplicity(__i); } let __ret: [G; OUT_470] = unsafe { *(record.function_queries[470].output_at(__i).as_ptr() as *const [G; OUT_470]) }; __ret }, _ => { aiur_fn_470::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(477, &__args[..])?) { [G::ZERO; OUT_477] } else { let (__hash, __hit) = record.function_queries[477].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[477].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => { aiur_fn_477::(__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 = G::from_u64(0); let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(763, &__args[..])?) { [G::ZERO; OUT_763] } else { let (__hash, __hit) = record.function_queries[763].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[763].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => { aiur_fn_763::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_479] = [__v_10]; record.function_queries[479].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_480: usize = 3; -const IN_480: usize = 3; -const OUT_480: usize = 1; -fn aiur_fn_480(inp: [G; IN_480], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_480], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_479] = { let __args: [G; IN_479] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(479, &__args[..])?) { [G::ZERO; OUT_479] } else { let (__hash, __hit) = record.function_queries[479].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[479].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[479].bump_multiplicity(__i); } let __ret: [G; OUT_479] = unsafe { *(record.function_queries[479].output_at(__i).as_ptr() as *const [G; OUT_479]) }; __ret }, _ => { aiur_fn_479::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = __v_2 + __v_4; let __v_6: G = __v_3 - __v_5; match __v_6.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(478, &__args[..])?) { [G::ZERO; OUT_478] } else { let (__hash, __hit) = record.function_queries[478].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[478].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[478].bump_multiplicity(__i); } let __ret: [G; OUT_478] = unsafe { *(record.function_queries[478].output_at(__i).as_ptr() as *const [G; OUT_478]) }; __ret }, _ => { aiur_fn_478::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_480] = [__v_8]; record.function_queries[480].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_480] = [__v_8]; record.function_queries[480].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_480] = [__v_7]; record.function_queries[480].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_481: usize = 2; -const IN_481: usize = 2; -const OUT_481: usize = 1; -fn aiur_fn_481(inp: [G; IN_481], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_481], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 9] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; 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: 9 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].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]; match __v_2.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(549, &__args[..])?) { [G::ZERO; OUT_549] } else { let (__hash, __hit) = record.function_queries[549].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[549].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => { aiur_fn_549::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __a_val = __v_11.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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 __v_13: G = G::from_u64(1); if (__v_12 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("a role is used before its group is admitted".to_string()) }); } let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(549, &__args[..])?) { [G::ZERO; OUT_549] } else { let (__hash, __hit) = record.function_queries[549].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[549].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => { aiur_fn_549::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_3, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(483, &__args[..])?) { [G::ZERO; OUT_483] } else { let (__hash, __hit) = record.function_queries[483].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[483].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[483].bump_multiplicity(__i); } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => { aiur_fn_483::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_481] = [__v_14]; record.function_queries[481].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_481] = [__v_11]; record.function_queries[481].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_482: usize = 2; -const IN_482: usize = 2; -const OUT_482: usize = 1; -fn aiur_fn_482(inp: [G; IN_482], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_482], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_481] = { let __args: [G; IN_481] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(481, &__args[..])?) { [G::ZERO; OUT_481] } else { let (__hash, __hit) = record.function_queries[481].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[481].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => { aiur_fn_481::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(698, &__args[..])?) { [G::ZERO; OUT_698] } else { let (__hash, __hit) = record.function_queries[698].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[698].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => { aiur_fn_698::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_482] = [__v_2]; record.function_queries[482].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_483: usize = 2; -const IN_483: usize = 2; -const OUT_483: usize = 0; -fn aiur_fn_483(inp: [G; IN_483], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_483], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_551] = { let __args: [G; IN_551] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(551, &__args[..])?) { [G::ZERO; OUT_551] } else { let (__hash, __hit) = record.function_queries[551].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[551].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[551].bump_multiplicity(__i); } let __ret: [G; OUT_551] = unsafe { *(record.function_queries[551].output_at(__i).as_ptr() as *const [G; OUT_551]) }; __ret }, _ => { aiur_fn_551::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(491, &__args[..])?) { [G::ZERO; OUT_491] } else { let (__hash, __hit) = record.function_queries[491].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[491].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[491].bump_multiplicity(__i); } let __ret: [G; OUT_491] = unsafe { *(record.function_queries[491].output_at(__i).as_ptr() as *const [G; OUT_491]) }; __ret }, _ => { aiur_fn_491::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(484, &__args[..])?) { [G::ZERO; OUT_484] } else { let (__hash, __hit) = record.function_queries[484].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[484].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[484].bump_multiplicity(__i); } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => { aiur_fn_484::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 9] = [__v_3, __v_0, __v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 9)?; 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_550] = { let __args: [G; IN_550] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(550, &__args[..])?) { [G::ZERO; OUT_550] } else { let (__hash, __hit) = record.function_queries[550].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[550].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[550].bump_multiplicity(__i); } let __ret: [G; OUT_550] = unsafe { *(record.function_queries[550].output_at(__i).as_ptr() as *const [G; OUT_550]) }; __ret }, _ => { aiur_fn_550::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_6, __v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(492, &__args[..])?) { [G::ZERO; OUT_492] } else { let (__hash, __hit) = record.function_queries[492].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[492].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[492].bump_multiplicity(__i); } let __ret: [G; OUT_492] = unsafe { *(record.function_queries[492].output_at(__i).as_ptr() as *const [G; OUT_492]) }; __ret }, _ => { aiur_fn_492::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_483] = []; record.function_queries[483].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_484: usize = 1; -const IN_484: usize = 1; -const OUT_484: usize = 1; -fn aiur_fn_484(inp: [G; IN_484], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_484], ExecError> { stacker::maybe_grow(64 * 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(33); 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 }; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_484] = [__v_0]; record.function_queries[484].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(41); let __v_4: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_4.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_484] = [__v_1]; record.function_queries[484].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_484] = [__v_3]; record.function_queries[484].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_485: usize = 1; -const IN_485: usize = 1; -const OUT_485: usize = 1; -fn aiur_fn_485(inp: [G; IN_485], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_485], ExecError> { stacker::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_552] = { let __args: [G; IN_552] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(552, &__args[..])?) { [G::ZERO; OUT_552] } else { let (__hash, __hit) = record.function_queries[552].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[552].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[552].bump_multiplicity(__i); } let __ret: [G; OUT_552] = unsafe { *(record.function_queries[552].output_at(__i).as_ptr() as *const [G; OUT_552]) }; __ret }, _ => { aiur_fn_552::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; match __v_1.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(554, &__args[..])?) { [G::ZERO; OUT_554] } else { let (__hash, __hit) = record.function_queries[554].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[554].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[554].bump_multiplicity(__i); } let __ret: [G; OUT_554] = unsafe { *(record.function_queries[554].output_at(__i).as_ptr() as *const [G; OUT_554]) }; __ret }, _ => { aiur_fn_554::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_485] = [__v_3]; record.function_queries[485].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_485] = [__v_3]; record.function_queries[485].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_485] = [__v_3]; record.function_queries[485].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_485] = [__v_3]; record.function_queries[485].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_485] = [__v_2]; record.function_queries[485].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_485] = [__v_2]; record.function_queries[485].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_485] = [__v_2]; record.function_queries[485].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_486: usize = 2; -const IN_486: usize = 2; -const OUT_486: usize = 1; -fn aiur_fn_486(inp: [G; IN_486], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_486], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 9] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; 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: 9 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].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]; match __v_2.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(477, &__args[..])?) { [G::ZERO; OUT_477] } else { let (__hash, __hit) = record.function_queries[477].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[477].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => { aiur_fn_477::(__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 = G::from_u64(0); let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_1, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(763, &__args[..])?) { [G::ZERO; OUT_763] } else { let (__hash, __hit) = record.function_queries[763].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[763].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => { aiur_fn_763::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_486] = [__v_0]; record.function_queries[486].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(1); let __v_20: G = __v_18 - __v_19; let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(549, &__args[..])?) { [G::ZERO; OUT_549] } else { let (__hash, __hit) = record.function_queries[549].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[549].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => { aiur_fn_549::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __a_val = __v_21.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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 __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(485, &__args[..])?) { [G::ZERO; OUT_485] } else { let (__hash, __hit) = record.function_queries[485].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[485].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[485].bump_multiplicity(__i); } let __ret: [G; OUT_485] = unsafe { *(record.function_queries[485].output_at(__i).as_ptr() as *const [G; OUT_485]) }; __ret }, _ => { aiur_fn_485::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __v_22 * __v_23; match __v_24.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_486] = [__v_0]; record.function_queries[486].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_25: G = G::from_u64(0); let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(484, &__args[..])?) { [G::ZERO; OUT_484] } else { let (__hash, __hit) = record.function_queries[484].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[484].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[484].bump_multiplicity(__i); } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => { aiur_fn_484::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 9] = [__v_25, __v_3, __v_26, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27]; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 9)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_486] = [__v_28]; record.function_queries[486].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, 1u64 => { let __ret: [G; OUT_486] = [__v_0]; record.function_queries[486].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_487: usize = 2; -const IN_487: usize = 2; -const OUT_487: usize = 1; -fn aiur_fn_487(inp: [G; IN_487], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_487], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 9] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(6).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(9))?; 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: 9 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].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]; match __v_2.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_487] = [__v_11]; record.function_queries[487].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(477, &__args[..])?) { [G::ZERO; OUT_477] } else { let (__hash, __hit) = record.function_queries[477].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[477].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => { aiur_fn_477::(__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 = G::from_u64(0); let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_1, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(763, &__args[..])?) { [G::ZERO; OUT_763] } else { let (__hash, __hit) = record.function_queries[763].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[763].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => { aiur_fn_763::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); let __ret: [G; OUT_487] = [__v_19]; record.function_queries[487].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(1); let __v_20: G = __v_18 - __v_19; let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(485, &__args[..])?) { [G::ZERO; OUT_485] } else { let (__hash, __hit) = record.function_queries[485].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[485].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[485].bump_multiplicity(__i); } let __ret: [G; OUT_485] = unsafe { *(record.function_queries[485].output_at(__i).as_ptr() as *const [G; OUT_485]) }; __ret }, _ => { aiur_fn_485::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_487] = [__v_21]; record.function_queries[487].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_488: usize = 1; -const IN_488: usize = 1; -const OUT_488: usize = 0; -fn aiur_fn_488(inp: [G; IN_488], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_488], ExecError> { stacker::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_462] = { let __args: [G; IN_462] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(462, &__args[..])?) { [G::ZERO; OUT_462] } else { let (__hash, __hit) = record.function_queries[462].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[462].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[462].bump_multiplicity(__i); } let __ret: [G; OUT_462] = unsafe { *(record.function_queries[462].output_at(__i).as_ptr() as *const [G; OUT_462]) }; __ret }, _ => { aiur_fn_462::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(0); let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(489, &__args[..])?) { [G::ZERO; OUT_489] } else { let (__hash, __hit) = record.function_queries[489].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[489].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[489].bump_multiplicity(__i); } let __ret: [G; OUT_489] = unsafe { *(record.function_queries[489].output_at(__i).as_ptr() as *const [G; OUT_489]) }; __ret }, _ => { aiur_fn_489::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(490, &__args[..])?) { [G::ZERO; OUT_490] } else { let (__hash, __hit) = record.function_queries[490].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[490].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[490].bump_multiplicity(__i); } let __ret: [G; OUT_490] = unsafe { *(record.function_queries[490].output_at(__i).as_ptr() as *const [G; OUT_490]) }; __ret }, _ => { aiur_fn_490::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_488] = []; record.function_queries[488].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_489: usize = 2; -const IN_489: usize = 2; -const OUT_489: usize = 0; -fn aiur_fn_489(inp: [G; IN_489], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_489], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = __v_1 - __v_2; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_489] = []; record.function_queries[489].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(475, &__args[..])?) { [G::ZERO; OUT_475] } else { let (__hash, __hit) = record.function_queries[475].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[475].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[475].bump_multiplicity(__i); } let __ret: [G; OUT_475] = unsafe { *(record.function_queries[475].output_at(__i).as_ptr() as *const [G; OUT_475]) }; __ret }, _ => { aiur_fn_475::(__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: Some("binding claim: a role is unbound".to_string()) }); } let __v_6: G = __v_1 + __v_5; let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(489, &__args[..])?) { [G::ZERO; OUT_489] } else { let (__hash, __hit) = record.function_queries[489].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[489].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[489].bump_multiplicity(__i); } let __ret: [G; OUT_489] = unsafe { *(record.function_queries[489].output_at(__i).as_ptr() as *const [G; OUT_489]) }; __ret }, _ => { aiur_fn_489::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_489] = []; record.function_queries[489].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_490: usize = 2; -const IN_490: usize = 2; -const OUT_490: usize = 0; -fn aiur_fn_490(inp: [G; IN_490], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_490], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(72); let __v_3: G = __v_1 - __v_2; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_490] = []; record.function_queries[490].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(483, &__args[..])?) { [G::ZERO; OUT_483] } else { let (__hash, __hit) = record.function_queries[483].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[483].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[483].bump_multiplicity(__i); } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => { aiur_fn_483::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = G::from_u64(1); let __v_5: G = __v_1 + __v_4; let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(490, &__args[..])?) { [G::ZERO; OUT_490] } else { let (__hash, __hit) = record.function_queries[490].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[490].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[490].bump_multiplicity(__i); } let __ret: [G; OUT_490] = unsafe { *(record.function_queries[490].output_at(__i).as_ptr() as *const [G; OUT_490]) }; __ret }, _ => { aiur_fn_490::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_490] = []; record.function_queries[490].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_491: usize = 2; -const IN_491: usize = 2; -const OUT_491: usize = 0; -fn aiur_fn_491(inp: [G; IN_491], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_491], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_491] = []; record.function_queries[491].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(549, &__args[..])?) { [G::ZERO; OUT_549] } else { let (__hash, __hit) = record.function_queries[549].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[549].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => { aiur_fn_549::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(483, &__args[..])?) { [G::ZERO; OUT_483] } else { let (__hash, __hit) = record.function_queries[483].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[483].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[483].bump_multiplicity(__i); } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => { aiur_fn_483::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(491, &__args[..])?) { [G::ZERO; OUT_491] } else { let (__hash, __hit) = record.function_queries[491].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[491].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[491].bump_multiplicity(__i); } let __ret: [G; OUT_491] = unsafe { *(record.function_queries[491].output_at(__i).as_ptr() as *const [G; OUT_491]) }; __ret }, _ => { aiur_fn_491::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_491] = []; record.function_queries[491].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_492: usize = 3; -const IN_492: usize = 3; -const OUT_492: usize = 0; -fn aiur_fn_492(inp: [G; IN_492], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_492], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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() { 1u64 => { let __ret: [G; OUT_492] = []; record.function_queries[492].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(493, &__args[..])?) { [G::ZERO; OUT_493] } else { let (__hash, __hit) = record.function_queries[493].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[493].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[493].bump_multiplicity(__i); } let __ret: [G; OUT_493] = unsafe { *(record.function_queries[493].output_at(__i).as_ptr() as *const [G; OUT_493]) }; __ret }, _ => { aiur_fn_493::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(492, &__args[..])?) { [G::ZERO; OUT_492] } else { let (__hash, __hit) = record.function_queries[492].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[492].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[492].bump_multiplicity(__i); } let __ret: [G; OUT_492] = unsafe { *(record.function_queries[492].output_at(__i).as_ptr() as *const [G; OUT_492]) }; __ret }, _ => { aiur_fn_492::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_492] = []; record.function_queries[492].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_493: usize = 3; -const IN_493: usize = 3; -const OUT_493: usize = 0; -fn aiur_fn_493(inp: [G; IN_493], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_493], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_476] = { let __args: [G; IN_476] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].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 __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(372, &__args[..])?) { [G::ZERO; OUT_372] } else { let (__hash, __hit) = record.function_queries[372].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[372].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => { aiur_fn_372::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(553, &__args[..])?) { [G::ZERO; OUT_553] } else { let (__hash, __hit) = record.function_queries[553].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[553].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[553].bump_multiplicity(__i); } let __ret: [G; OUT_553] = unsafe { *(record.function_queries[553].output_at(__i).as_ptr() as *const [G; OUT_553]) }; __ret }, _ => { aiur_fn_553::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; if (__v_17 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("a bound role has the wrong number of universe parameters".to_string()) }); } let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(552, &__args[..])?) { [G::ZERO; OUT_552] } else { let (__hash, __hit) = record.function_queries[552].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[552].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[552].bump_multiplicity(__i); } let __ret: [G; OUT_552] = unsafe { *(record.function_queries[552].output_at(__i).as_ptr() as *const [G; OUT_552]) }; __ret }, _ => { aiur_fn_552::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; match __v_19.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_0, __v_1, __v_2, __v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(496, &__args[..])?) { [G::ZERO; OUT_496] } else { let (__hash, __hit) = record.function_queries[496].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[496].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[496].bump_multiplicity(__i); } let __ret: [G; OUT_496] = unsafe { *(record.function_queries[496].output_at(__i).as_ptr() as *const [G; OUT_496]) }; __ret }, _ => { aiur_fn_496::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_493] = []; record.function_queries[493].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_0, __v_1, __v_2, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(498, &__args[..])?) { [G::ZERO; OUT_498] } else { let (__hash, __hit) = record.function_queries[498].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[498].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[498].bump_multiplicity(__i); } let __ret: [G; OUT_498] = unsafe { *(record.function_queries[498].output_at(__i).as_ptr() as *const [G; OUT_498]) }; __ret }, _ => { aiur_fn_498::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_493] = []; record.function_queries[493].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_0, __v_1, __v_2, __v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(502, &__args[..])?) { [G::ZERO; OUT_502] } else { let (__hash, __hit) = record.function_queries[502].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[502].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[502].bump_multiplicity(__i); } let __ret: [G; OUT_502] = unsafe { *(record.function_queries[502].output_at(__i).as_ptr() as *const [G; OUT_502]) }; __ret }, _ => { aiur_fn_502::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_493] = []; record.function_queries[493].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_0, __v_1, __v_2, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(499, &__args[..])?) { [G::ZERO; OUT_499] } else { let (__hash, __hit) = record.function_queries[499].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[499].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[499].bump_multiplicity(__i); } let __ret: [G; OUT_499] = unsafe { *(record.function_queries[499].output_at(__i).as_ptr() as *const [G; OUT_499]) }; __ret }, _ => { aiur_fn_499::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_493] = []; record.function_queries[493].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_0, __v_1, __v_2, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(500, &__args[..])?) { [G::ZERO; OUT_500] } else { let (__hash, __hit) = record.function_queries[500].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[500].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => { aiur_fn_500::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_493] = []; record.function_queries[493].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_0, __v_1, __v_2, __v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(504, &__args[..])?) { [G::ZERO; OUT_504] } else { let (__hash, __hit) = record.function_queries[504].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[504].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[504].bump_multiplicity(__i); } let __ret: [G; OUT_504] = unsafe { *(record.function_queries[504].output_at(__i).as_ptr() as *const [G; OUT_504]) }; __ret }, _ => { aiur_fn_504::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_493] = []; record.function_queries[493].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }) } -const INPUT_SIZE_494: usize = 3; -const IN_494: usize = 3; -const OUT_494: usize = 0; -fn aiur_fn_494(inp: [G; IN_494], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_494], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = __v_1 - __v_2; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_494] = []; record.function_queries[494].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { 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(1).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_380] = { let __args: [G; IN_380] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; if (__v_6 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("a bound role's type does not meet its specification".to_string()) }); } let __ret: [G; OUT_494] = []; record.function_queries[494].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_495: usize = 12; -const IN_495: usize = 12; -const OUT_495: usize = 0; -fn aiur_fn_495(inp: [G; IN_495], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_495], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(569, &__args[..])?) { [G::ZERO; OUT_569] } else { let (__hash, __hit) = record.function_queries[569].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[569].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[569].bump_multiplicity(__i); } let __ret: [G; OUT_569] = unsafe { *(record.function_queries[569].output_at(__i).as_ptr() as *const [G; OUT_569]) }; __ret }, _ => { aiur_fn_569::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); if (__v_12 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("a bound role is unsafe".to_string()) }); } let __ret: [G; OUT_495] = []; record.function_queries[495].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_496: usize = 16; -const IN_496: usize = 16; -const OUT_496: usize = 0; -fn aiur_fn_496(inp: [G; IN_496], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_496], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(495, &__args[..])?) { [G::ZERO; OUT_495] } else { let (__hash, __hit) = record.function_queries[495].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[495].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[495].bump_multiplicity(__i); } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => { aiur_fn_495::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(373, &__args[..])?) { [G::ZERO; OUT_373] } else { let (__hash, __hit) = record.function_queries[373].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[373].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[373].bump_multiplicity(__i); } let __ret: [G; OUT_373] = unsafe { *(record.function_queries[373].output_at(__i).as_ptr() as *const [G; OUT_373]) }; __ret }, _ => { aiur_fn_373::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(557, &__args[..])?) { [G::ZERO; OUT_557] } else { let (__hash, __hit) = record.function_queries[557].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[557].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[557].bump_multiplicity(__i); } let __ret: [G; OUT_557] = unsafe { *(record.function_queries[557].output_at(__i).as_ptr() as *const [G; OUT_557]) }; __ret }, _ => { aiur_fn_557::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0, __v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(494, &__args[..])?) { [G::ZERO; OUT_494] } else { let (__hash, __hit) = record.function_queries[494].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[494].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[494].bump_multiplicity(__i); } let __ret: [G; OUT_494] = unsafe { *(record.function_queries[494].output_at(__i).as_ptr() as *const [G; OUT_494]) }; __ret }, _ => { aiur_fn_494::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(554, &__args[..])?) { [G::ZERO; OUT_554] } else { let (__hash, __hit) = record.function_queries[554].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[554].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[554].bump_multiplicity(__i); } let __ret: [G; OUT_554] = unsafe { *(record.function_queries[554].output_at(__i).as_ptr() as *const [G; OUT_554]) }; __ret }, _ => { aiur_fn_554::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(556, &__args[..])?) { [G::ZERO; OUT_556] } else { let (__hash, __hit) = record.function_queries[556].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[556].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[556].bump_multiplicity(__i); } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => { aiur_fn_556::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; if (__v_9 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("a bound inductive has the wrong number of constructors".to_string()) }); } let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(698, &__args[..])?) { [G::ZERO; OUT_698] } else { let (__hash, __hit) = record.function_queries[698].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[698].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => { aiur_fn_698::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_496] = []; record.function_queries[496].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, 1u64 => { match __v_4.as_canonical_u64() { 6u64 => { let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(555, &__args[..])?) { [G::ZERO; OUT_555] } else { let (__hash, __hit) = record.function_queries[555].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[555].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[555].bump_multiplicity(__i); } let __ret: [G; OUT_555] = unsafe { *(record.function_queries[555].output_at(__i).as_ptr() as *const [G; OUT_555]) }; __ret }, _ => { aiur_fn_555::(__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 __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_1, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].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 __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_25.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_32]; 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_37: G = __r_arr[0]; let __v_38: G = G::from_u64(1); if (__v_37 != __v_38) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_38.as_canonical_u64(), msg: Some("a bound constructor is not its inductive's".to_string()) }); } if (__v_8 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: Some("a bound constructor is not its inductive's".to_string()) }); } break '__mc_0 []; }, _ => { return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); }, } }; if (__v_9 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("a bound constructor has the wrong index".to_string()) }); } if (__v_10 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("a bound constructor has the wrong number of parameters".to_string()) }); } if (__v_11 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("a bound constructor has the wrong number of fields".to_string()) }); } let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(698, &__args[..])?) { [G::ZERO; OUT_698] } else { let (__hash, __hit) = record.function_queries[698].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[698].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => { aiur_fn_698::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_496] = []; record.function_queries[496].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, 2u64 => { match __v_4.as_canonical_u64() { 7u64 => { let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(698, &__args[..])?) { [G::ZERO; OUT_698] } else { let (__hash, __hit) = record.function_queries[698].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[698].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => { aiur_fn_698::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_496] = []; record.function_queries[496].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, 3u64 => { match __v_4.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(553, &__args[..])?) { [G::ZERO; OUT_553] } else { let (__hash, __hit) = record.function_queries[553].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[553].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[553].bump_multiplicity(__i); } let __ret: [G; OUT_553] = unsafe { *(record.function_queries[553].output_at(__i).as_ptr() as *const [G; OUT_553]) }; __ret }, _ => { aiur_fn_553::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_6, __v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 3] = [__v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_index_mut(1).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_451] = { let __args: [G; IN_451] = [__v_0, __v_6, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_496] = []; record.function_queries[496].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, 4u64 => { let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(497, &__args[..])?) { [G::ZERO; OUT_497] } else { let (__hash, __hit) = record.function_queries[497].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[497].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[497].bump_multiplicity(__i); } let __ret: [G; OUT_497] = unsafe { *(record.function_queries[497].output_at(__i).as_ptr() as *const [G; OUT_497]) }; __ret }, _ => { aiur_fn_497::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_496] = []; record.function_queries[496].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_19: G = G::from_u64(1); let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(497, &__args[..])?) { [G::ZERO; OUT_497] } else { let (__hash, __hit) = record.function_queries[497].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[497].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[497].bump_multiplicity(__i); } let __ret: [G; OUT_497] = unsafe { *(record.function_queries[497].output_at(__i).as_ptr() as *const [G; OUT_497]) }; __ret }, _ => { aiur_fn_497::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_496] = []; record.function_queries[496].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_19: G = G::from_u64(2); let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(497, &__args[..])?) { [G::ZERO; OUT_497] } else { let (__hash, __hit) = record.function_queries[497].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[497].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[497].bump_multiplicity(__i); } let __ret: [G; OUT_497] = unsafe { *(record.function_queries[497].output_at(__i).as_ptr() as *const [G; OUT_497]) }; __ret }, _ => { aiur_fn_497::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_496] = []; record.function_queries[496].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_19: G = G::from_u64(3); let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(497, &__args[..])?) { [G::ZERO; OUT_497] } else { let (__hash, __hit) = record.function_queries[497].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[497].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[497].bump_multiplicity(__i); } let __ret: [G; OUT_497] = unsafe { *(record.function_queries[497].output_at(__i).as_ptr() as *const [G; OUT_497]) }; __ret }, _ => { aiur_fn_497::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_496] = []; record.function_queries[496].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); }, } }) } -const INPUT_SIZE_497: usize = 13; -const IN_497: usize = 13; -const OUT_497: usize = 0; -fn aiur_fn_497(inp: [G; IN_497], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_497], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_0.as_canonical_u64() { 4u64 => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); break '__mc_0 [__v_13]; }, 1u64 => { let __v_13: G = G::from_u64(1); break '__mc_0 [__v_13]; }, 2u64 => { let __v_13: G = G::from_u64(2); break '__mc_0 [__v_13]; }, 3u64 => { let __v_13: G = G::from_u64(3); break '__mc_0 [__v_13]; }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }; let __v_13: G = __mc_out___mc_0[0]; if (__v_13 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("a bound quotient constant has the wrong kind".to_string()) }); } let __ret: [G; OUT_497] = []; record.function_queries[497].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_498: usize = 15; -const IN_498: usize = 15; -const OUT_498: usize = 0; -fn aiur_fn_498(inp: [G; IN_498], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_498], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_495] = { let __args: [G; IN_495] = [__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(495, &__args[..])?) { [G::ZERO; OUT_495] } else { let (__hash, __hit) = record.function_queries[495].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[495].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[495].bump_multiplicity(__i); } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => { aiur_fn_495::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__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(373, &__args[..])?) { [G::ZERO; OUT_373] } else { let (__hash, __hit) = record.function_queries[373].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[373].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[373].bump_multiplicity(__i); } let __ret: [G; OUT_373] = unsafe { *(record.function_queries[373].output_at(__i).as_ptr() as *const [G; OUT_373]) }; __ret }, _ => { aiur_fn_373::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(557, &__args[..])?) { [G::ZERO; OUT_557] } else { let (__hash, __hit) = record.function_queries[557].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[557].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[557].bump_multiplicity(__i); } let __ret: [G; OUT_557] = unsafe { *(record.function_queries[557].output_at(__i).as_ptr() as *const [G; OUT_557]) }; __ret }, _ => { aiur_fn_557::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(494, &__args[..])?) { [G::ZERO; OUT_494] } else { let (__hash, __hit) = record.function_queries[494].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[494].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[494].bump_multiplicity(__i); } let __ret: [G; OUT_494] = unsafe { *(record.function_queries[494].output_at(__i).as_ptr() as *const [G; OUT_494]) }; __ret }, _ => { aiur_fn_494::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_498] = []; record.function_queries[498].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_499: usize = 15; -const IN_499: usize = 15; -const OUT_499: usize = 0; -fn aiur_fn_499(inp: [G; IN_499], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_499], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __v_15: G = G::from_u64(0); if (__v_6 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("a bound standard axiom is unsafe".to_string()) }); } let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_5, __v_15, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_451] = { let __args: [G; IN_451] = [__v_0, __v_5, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(557, &__args[..])?) { [G::ZERO; OUT_557] } else { let (__hash, __hit) = record.function_queries[557].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[557].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[557].bump_multiplicity(__i); } let __ret: [G; OUT_557] = unsafe { *(record.function_queries[557].output_at(__i).as_ptr() as *const [G; OUT_557]) }; __ret }, _ => { aiur_fn_557::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0, __v_5, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(494, &__args[..])?) { [G::ZERO; OUT_494] } else { let (__hash, __hit) = record.function_queries[494].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[494].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[494].bump_multiplicity(__i); } let __ret: [G; OUT_494] = unsafe { *(record.function_queries[494].output_at(__i).as_ptr() as *const [G; OUT_494]) }; __ret }, _ => { aiur_fn_494::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_499] = []; record.function_queries[499].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_500: usize = 15; -const IN_500: usize = 15; -const OUT_500: usize = 0; -fn aiur_fn_500(inp: [G; IN_500], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_500], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __v_15: G = G::from_u64(0); if (__v_6 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("a bound inert axiom is unsafe".to_string()) }); } let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_5, __v_15, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_451] = { let __args: [G; IN_451] = [__v_0, __v_5, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(557, &__args[..])?) { [G::ZERO; OUT_557] } else { let (__hash, __hit) = record.function_queries[557].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[557].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[557].bump_multiplicity(__i); } let __ret: [G; OUT_557] = unsafe { *(record.function_queries[557].output_at(__i).as_ptr() as *const [G; OUT_557]) }; __ret }, _ => { aiur_fn_557::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0, __v_5, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(494, &__args[..])?) { [G::ZERO; OUT_494] } else { let (__hash, __hit) = record.function_queries[494].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[494].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[494].bump_multiplicity(__i); } let __ret: [G; OUT_494] = unsafe { *(record.function_queries[494].output_at(__i).as_ptr() as *const [G; OUT_494]) }; __ret }, _ => { aiur_fn_494::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_500] = []; record.function_queries[500].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_501: usize = 2; -const IN_501: usize = 2; -const OUT_501: usize = 1; -fn aiur_fn_501(inp: [G; IN_501], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_501], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 19] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(11).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(19))?; 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: 19 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 19] = __args[..19].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; match __v_2.as_canonical_u64() { _ => { let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 4] = [__v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_index_mut(2).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_763] = { let __args: [G; IN_763] = [__v_1, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(763, &__args[..])?) { [G::ZERO; OUT_763] } else { let (__hash, __hit) = record.function_queries[763].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[763].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => { aiur_fn_763::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_501] = [__v_23]; record.function_queries[501].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_502: usize = 16; -const IN_502: usize = 16; -const OUT_502: usize = 0; -fn aiur_fn_502(inp: [G; IN_502], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_502], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_4.as_canonical_u64() { 1u64 => { let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_8.as_canonical_u64() { 1u64 => { break '__mc_0 []; }, _ => { let __v_16: G = G::from_u64(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: Some("a bound operation is not a safe definition".to_string()) }); } break '__mc_0 []; }, } }; let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(557, &__args[..])?) { [G::ZERO; OUT_557] } else { let (__hash, __hit) = record.function_queries[557].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[557].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[557].bump_multiplicity(__i); } let __ret: [G; OUT_557] = unsafe { *(record.function_queries[557].output_at(__i).as_ptr() as *const [G; OUT_557]) }; __ret }, _ => { aiur_fn_557::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0, __v_6, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(494, &__args[..])?) { [G::ZERO; OUT_494] } else { let (__hash, __hit) = record.function_queries[494].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[494].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[494].bump_multiplicity(__i); } let __ret: [G; OUT_494] = unsafe { *(record.function_queries[494].output_at(__i).as_ptr() as *const [G; OUT_494]) }; __ret }, _ => { aiur_fn_494::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(698, &__args[..])?) { [G::ZERO; OUT_698] } else { let (__hash, __hit) = record.function_queries[698].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[698].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => { aiur_fn_698::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(501, &__args[..])?) { [G::ZERO; OUT_501] } else { let (__hash, __hit) = record.function_queries[501].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[501].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[501].bump_multiplicity(__i); } let __ret: [G; OUT_501] = unsafe { *(record.function_queries[501].output_at(__i).as_ptr() as *const [G; OUT_501]) }; __ret }, _ => { aiur_fn_501::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(767, &__args[..])?) { [G::ZERO; OUT_767] } else { let (__hash, __hit) = record.function_queries[767].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[767].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[767].bump_multiplicity(__i); } let __ret: [G; OUT_767] = unsafe { *(record.function_queries[767].output_at(__i).as_ptr() as *const [G; OUT_767]) }; __ret }, _ => { aiur_fn_767::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(558, &__args[..])?) { [G::ZERO; OUT_558] } else { let (__hash, __hit) = record.function_queries[558].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[558].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[558].bump_multiplicity(__i); } let __ret: [G; OUT_558] = unsafe { *(record.function_queries[558].output_at(__i).as_ptr() as *const [G; OUT_558]) }; __ret }, _ => { aiur_fn_558::(__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: Some("an operation's evidence does not match its equations".to_string()) }); } let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_0, __v_1, __v_2, __v_17, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(503, &__args[..])?) { [G::ZERO; OUT_503] } else { let (__hash, __hit) = record.function_queries[503].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[503].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[503].bump_multiplicity(__i); } let __ret: [G; OUT_503] = unsafe { *(record.function_queries[503].output_at(__i).as_ptr() as *const [G; OUT_503]) }; __ret }, _ => { aiur_fn_503::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_502] = []; record.function_queries[502].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_503: usize = 5; -const IN_503: usize = 5; -const OUT_503: usize = 0; -fn aiur_fn_503(inp: [G; IN_503], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_503], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_503] = []; record.function_queries[503].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(559, &__args[..])?) { [G::ZERO; OUT_559] } else { let (__hash, __hit) = record.function_queries[559].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[559].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[559].bump_multiplicity(__i); } let __ret: [G; OUT_559] = unsafe { *(record.function_queries[559].output_at(__i).as_ptr() as *const [G; OUT_559]) }; __ret }, _ => { aiur_fn_559::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_9.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_1, __v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(560, &__args[..])?) { [G::ZERO; OUT_560] } else { let (__hash, __hit) = record.function_queries[560].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[560].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[560].bump_multiplicity(__i); } let __ret: [G; OUT_560] = unsafe { *(record.function_queries[560].output_at(__i).as_ptr() as *const [G; OUT_560]) }; __ret }, _ => { aiur_fn_560::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_1, __v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(561, &__args[..])?) { [G::ZERO; OUT_561] } else { let (__hash, __hit) = record.function_queries[561].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[561].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[561].bump_multiplicity(__i); } let __ret: [G; OUT_561] = unsafe { *(record.function_queries[561].output_at(__i).as_ptr() as *const [G; OUT_561]) }; __ret }, _ => { aiur_fn_561::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_380] = { let __args: [G; IN_380] = [__v_0, __v_10, __v_11, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; if (__v_14 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("an operation's equation does not hold by definition".to_string()) }); } break '__mc_0 []; }, 1u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); if (__v_10 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("a structural operation's evidence must be definitional".to_string()) }); } break '__mc_0 []; }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, _ => { match __v_6.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); if (__v_10 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("a well-founded operation's evidence must be proofs".to_string()) }); } break '__mc_0 []; }, 1u64 => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; let __v_15: G = __loaded[4]; let __v_16: G = __loaded[5]; let __v_17: G = __loaded[6]; let __v_18: G = __loaded[7]; let __v_19: G = __loaded[8]; let __v_20: G = __loaded[9]; let __v_21: G = __loaded[10]; let __v_22: G = __loaded[11]; match __v_11.as_canonical_u64() { 2u64 => { let __v_23: G = G::from_u64(0); if (__v_12 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("certificate theorem has universe parameters".to_string()) }); } let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(698, &__args[..])?) { [G::ZERO; OUT_698] } else { let (__hash, __hit) = record.function_queries[698].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[698].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => { aiur_fn_698::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_1, __v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(562, &__args[..])?) { [G::ZERO; OUT_562] } else { let (__hash, __hit) = record.function_queries[562].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[562].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[562].bump_multiplicity(__i); } let __ret: [G; OUT_562] = unsafe { *(record.function_queries[562].output_at(__i).as_ptr() as *const [G; OUT_562]) }; __ret }, _ => { aiur_fn_562::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0, __v_13, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(494, &__args[..])?) { [G::ZERO; OUT_494] } else { let (__hash, __hit) = record.function_queries[494].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[494].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[494].bump_multiplicity(__i); } let __ret: [G; OUT_494] = unsafe { *(record.function_queries[494].output_at(__i).as_ptr() as *const [G; OUT_494]) }; __ret }, _ => { aiur_fn_494::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, } }; let __v_10: G = G::from_u64(1); let __v_11: G = __v_4 + __v_10; let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_0, __v_1, __v_2, __v_8, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(503, &__args[..])?) { [G::ZERO; OUT_503] } else { let (__hash, __hit) = record.function_queries[503].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[503].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[503].bump_multiplicity(__i); } let __ret: [G; OUT_503] = unsafe { *(record.function_queries[503].output_at(__i).as_ptr() as *const [G; OUT_503]) }; __ret }, _ => { aiur_fn_503::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_503] = []; record.function_queries[503].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_504: usize = 16; -const IN_504: usize = 16; -const OUT_504: usize = 0; -fn aiur_fn_504(inp: [G; IN_504], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_504], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_4.as_canonical_u64() { 1u64 => { let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_8.as_canonical_u64() { 1u64 => { break '__mc_0 []; }, _ => { let __v_16: G = G::from_u64(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: Some("a bound definition is not safe".to_string()) }); } break '__mc_0 []; }, } }; let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(553, &__args[..])?) { [G::ZERO; OUT_553] } else { let (__hash, __hit) = record.function_queries[553].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[553].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[553].bump_multiplicity(__i); } let __ret: [G; OUT_553] = unsafe { *(record.function_queries[553].output_at(__i).as_ptr() as *const [G; OUT_553]) }; __ret }, _ => { aiur_fn_553::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; if (__v_5 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("a bound definition has another number of universe parameters".to_string()) }); } let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(557, &__args[..])?) { [G::ZERO; OUT_557] } else { let (__hash, __hit) = record.function_queries[557].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[557].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[557].bump_multiplicity(__i); } let __ret: [G; OUT_557] = unsafe { *(record.function_queries[557].output_at(__i).as_ptr() as *const [G; OUT_557]) }; __ret }, _ => { aiur_fn_557::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0, __v_6, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(494, &__args[..])?) { [G::ZERO; OUT_494] } else { let (__hash, __hit) = record.function_queries[494].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[494].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[494].bump_multiplicity(__i); } let __ret: [G; OUT_494] = unsafe { *(record.function_queries[494].output_at(__i).as_ptr() as *const [G; OUT_494]) }; __ret }, _ => { aiur_fn_494::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(698, &__args[..])?) { [G::ZERO; OUT_698] } else { let (__hash, __hit) = record.function_queries[698].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[698].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => { aiur_fn_698::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(501, &__args[..])?) { [G::ZERO; OUT_501] } else { let (__hash, __hit) = record.function_queries[501].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[501].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[501].bump_multiplicity(__i); } let __ret: [G; OUT_501] = unsafe { *(record.function_queries[501].output_at(__i).as_ptr() as *const [G; OUT_501]) }; __ret }, _ => { aiur_fn_501::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(767, &__args[..])?) { [G::ZERO; OUT_767] } else { let (__hash, __hit) = record.function_queries[767].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[767].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[767].bump_multiplicity(__i); } let __ret: [G; OUT_767] = unsafe { *(record.function_queries[767].output_at(__i).as_ptr() as *const [G; OUT_767]) }; __ret }, _ => { aiur_fn_767::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(563, &__args[..])?) { [G::ZERO; OUT_563] } else { let (__hash, __hit) = record.function_queries[563].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[563].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[563].bump_multiplicity(__i); } let __ret: [G; OUT_563] = unsafe { *(record.function_queries[563].output_at(__i).as_ptr() as *const [G; OUT_563]) }; __ret }, _ => { aiur_fn_563::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; if (__v_19 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("a definition's evidence does not match its equations".to_string()) }); } let __v_21: G = G::from_u64(0); let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_0, __v_1, __v_2, __v_18, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(505, &__args[..])?) { [G::ZERO; OUT_505] } else { let (__hash, __hit) = record.function_queries[505].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[505].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[505].bump_multiplicity(__i); } let __ret: [G; OUT_505] = unsafe { *(record.function_queries[505].output_at(__i).as_ptr() as *const [G; OUT_505]) }; __ret }, _ => { aiur_fn_505::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_504] = []; record.function_queries[504].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_505: usize = 5; -const IN_505: usize = 5; -const OUT_505: usize = 0; -fn aiur_fn_505(inp: [G; IN_505], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_505], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_505] = []; record.function_queries[505].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_6.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(564, &__args[..])?) { [G::ZERO; OUT_564] } else { let (__hash, __hit) = record.function_queries[564].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[564].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[564].bump_multiplicity(__i); } let __ret: [G; OUT_564] = unsafe { *(record.function_queries[564].output_at(__i).as_ptr() as *const [G; OUT_564]) }; __ret }, _ => { aiur_fn_564::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("a conditional equation's evidence must be a proof".to_string()) }); } let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_1, __v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(565, &__args[..])?) { [G::ZERO; OUT_565] } else { let (__hash, __hit) = record.function_queries[565].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[565].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[565].bump_multiplicity(__i); } let __ret: [G; OUT_565] = unsafe { *(record.function_queries[565].output_at(__i).as_ptr() as *const [G; OUT_565]) }; __ret }, _ => { aiur_fn_565::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_1, __v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(566, &__args[..])?) { [G::ZERO; OUT_566] } else { let (__hash, __hit) = record.function_queries[566].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[566].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[566].bump_multiplicity(__i); } let __ret: [G; OUT_566] = unsafe { *(record.function_queries[566].output_at(__i).as_ptr() as *const [G; OUT_566]) }; __ret }, _ => { aiur_fn_566::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 3] = [__v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_380] = { let __args: [G; IN_380] = [__v_0, __v_11, __v_12, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; if (__v_15 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("a definition's equation does not hold by definition".to_string()) }); } break '__mc_0 []; }, 1u64 => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].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]; match __v_10.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(553, &__args[..])?) { [G::ZERO; OUT_553] } else { let (__hash, __hit) = record.function_queries[553].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[553].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[553].bump_multiplicity(__i); } let __ret: [G; OUT_553] = unsafe { *(record.function_queries[553].output_at(__i).as_ptr() as *const [G; OUT_553]) }; __ret }, _ => { aiur_fn_553::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; if (__v_11 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("an equation's proof has another number of universe parameters".to_string()) }); } let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(698, &__args[..])?) { [G::ZERO; OUT_698] } else { let (__hash, __hit) = record.function_queries[698].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[698].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => { aiur_fn_698::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_1, __v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(567, &__args[..])?) { [G::ZERO; OUT_567] } else { let (__hash, __hit) = record.function_queries[567].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[567].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[567].bump_multiplicity(__i); } let __ret: [G; OUT_567] = unsafe { *(record.function_queries[567].output_at(__i).as_ptr() as *const [G; OUT_567]) }; __ret }, _ => { aiur_fn_567::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0, __v_12, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(494, &__args[..])?) { [G::ZERO; OUT_494] } else { let (__hash, __hit) = record.function_queries[494].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[494].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[494].bump_multiplicity(__i); } let __ret: [G; OUT_494] = unsafe { *(record.function_queries[494].output_at(__i).as_ptr() as *const [G; OUT_494]) }; __ret }, _ => { aiur_fn_494::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }; let __v_9: G = G::from_u64(1); let __v_10: G = __v_4 + __v_9; let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_0, __v_1, __v_2, __v_8, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(505, &__args[..])?) { [G::ZERO; OUT_505] } else { let (__hash, __hit) = record.function_queries[505].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[505].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[505].bump_multiplicity(__i); } let __ret: [G; OUT_505] = unsafe { *(record.function_queries[505].output_at(__i).as_ptr() as *const [G; OUT_505]) }; __ret }, _ => { aiur_fn_505::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_505] = []; record.function_queries[505].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_506: usize = 2; -const IN_506: usize = 2; -const OUT_506: usize = 1; -fn aiur_fn_506(inp: [G; IN_506], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_506], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_470] = { let __args: [G; IN_470] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(470, &__args[..])?) { [G::ZERO; OUT_470] } else { let (__hash, __hit) = record.function_queries[470].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[470].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[470].bump_multiplicity(__i); } let __ret: [G; OUT_470] = unsafe { *(record.function_queries[470].output_at(__i).as_ptr() as *const [G; OUT_470]) }; __ret }, _ => { aiur_fn_470::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(477, &__args[..])?) { [G::ZERO; OUT_477] } else { let (__hash, __hit) = record.function_queries[477].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[477].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => { aiur_fn_477::(__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 = G::from_u64(0); let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(763, &__args[..])?) { [G::ZERO; OUT_763] } else { let (__hash, __hit) = record.function_queries[763].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[763].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => { aiur_fn_763::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(471, &__args[..])?) { [G::ZERO; OUT_471] } else { let (__hash, __hit) = record.function_queries[471].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[471].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[471].bump_multiplicity(__i); } let __ret: [G; OUT_471] = unsafe { *(record.function_queries[471].output_at(__i).as_ptr() as *const [G; OUT_471]) }; __ret }, _ => { aiur_fn_471::(__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 = G::from_u64(0); let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_1, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(763, &__args[..])?) { [G::ZERO; OUT_763] } else { let (__hash, __hit) = record.function_queries[763].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[763].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => { aiur_fn_763::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_506] = [__v_18]; record.function_queries[506].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(507, &__args[..])?) { [G::ZERO; OUT_507] } else { let (__hash, __hit) = record.function_queries[507].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[507].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[507].bump_multiplicity(__i); } let __ret: [G; OUT_507] = unsafe { *(record.function_queries[507].output_at(__i).as_ptr() as *const [G; OUT_507]) }; __ret }, _ => { aiur_fn_507::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_506] = [__v_12]; record.function_queries[506].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(478, &__args[..])?) { [G::ZERO; OUT_478] } else { let (__hash, __hit) = record.function_queries[478].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[478].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[478].bump_multiplicity(__i); } let __ret: [G; OUT_478] = unsafe { *(record.function_queries[478].output_at(__i).as_ptr() as *const [G; OUT_478]) }; __ret }, _ => { aiur_fn_478::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_506] = [__v_13]; record.function_queries[506].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_506] = [__v_11]; record.function_queries[506].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_507: usize = 1; -const IN_507: usize = 1; -const OUT_507: usize = 1; -fn aiur_fn_507(inp: [G; IN_507], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_507], ExecError> { 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(0); let __ret: [G; OUT_507] = [__v_1]; record.function_queries[507].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 __v_3: G = G::from_u64(56); let __v_4: G = __v_2 - __v_3; match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_507] = [__v_5]; record.function_queries[507].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(57); let __v_6: G = __v_2 - __v_5; match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_507] = [__v_7]; record.function_queries[507].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(36); let __v_8: G = __v_2 - __v_7; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_507] = [__v_9]; record.function_queries[507].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(58); let __v_10: G = __v_2 - __v_9; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(2); let __ret: [G; OUT_507] = [__v_11]; record.function_queries[507].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_507] = [__v_11]; record.function_queries[507].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }) } -const INPUT_SIZE_508: usize = 2; -const IN_508: usize = 2; -const OUT_508: usize = 0; -fn aiur_fn_508(inp: [G; IN_508], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_508], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_506] = { let __args: [G; IN_506] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(506, &__args[..])?) { [G::ZERO; OUT_506] } else { let (__hash, __hit) = record.function_queries[506].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[506].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[506].bump_multiplicity(__i); } let __ret: [G; OUT_506] = unsafe { *(record.function_queries[506].output_at(__i).as_ptr() as *const [G; OUT_506]) }; __ret }, _ => { aiur_fn_506::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 2u64 => { let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(1); if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("a constant uses `sorryAx`".to_string()) }); } let __ret: [G; OUT_508] = []; record.function_queries[508].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_508] = []; record.function_queries[508].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_509: usize = 0; -const IN_509: usize = 0; -const OUT_509: usize = 1; -fn aiur_fn_509(inp: [G; IN_509], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_509], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(3); let __ret: [G; OUT_509] = [__v_0]; record.function_queries[509].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_510: usize = 0; -const IN_510: usize = 0; -const OUT_510: usize = 1; -fn aiur_fn_510(inp: [G; IN_510], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_510], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(109); let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(21); let __v_3: G = G::from_u64(62); let __v_4: G = G::from_u64(163); let __v_5: G = G::from_u64(17); let __v_6: G = G::from_u64(243); let __v_7: G = G::from_u64(239); let __v_8: G = G::from_u64(209); let __v_9: G = G::from_u64(119); let __v_10: G = G::from_u64(140); let __v_11: G = G::from_u64(73); let __v_12: G = G::from_u64(178); let __v_13: G = G::from_u64(238); let __v_14: G = G::from_u64(95); let __v_15: G = G::from_u64(49); let __v_16: G = G::from_u64(231); let __v_17: G = G::from_u64(154); let __v_18: G = G::from_u64(11); let __v_19: G = G::from_u64(174); let __v_20: G = G::from_u64(149); let __v_21: G = G::from_u64(229); let __v_22: G = G::from_u64(51); let __v_23: G = G::from_u64(160); let __v_24: G = G::from_u64(141); let __v_25: G = G::from_u64(20); let __v_26: G = G::from_u64(252); let __v_27: G = G::from_u64(5); let __v_28: G = G::from_u64(87); let __v_29: G = G::from_u64(45); let __v_30: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_11, __v_25, __v_26, __v_27, __v_28, __v_29, __v_22]; let __mq = record.memory_queries.get_index_mut(12).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_510] = [__v_30]; record.function_queries[510].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_511: usize = 0; -const IN_511: usize = 0; -const OUT_511: usize = 1; -fn aiur_fn_511(inp: [G; IN_511], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_511], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(103); let __ret: [G; OUT_511] = [__v_0]; record.function_queries[511].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_512: usize = 0; -const IN_512: usize = 0; -const OUT_512: usize = 1; -fn aiur_fn_512(inp: [G; IN_512], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_512], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(72); let __ret: [G; OUT_512] = [__v_0]; record.function_queries[512].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_513: usize = 0; -const IN_513: usize = 0; -const OUT_513: usize = 1; -fn aiur_fn_513(inp: [G; IN_513], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_513], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(33); let __ret: [G; OUT_513] = [__v_0]; record.function_queries[513].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_514: usize = 0; -const IN_514: usize = 0; -const OUT_514: usize = 1; -fn aiur_fn_514(inp: [G; IN_514], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_514], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(41); let __ret: [G; OUT_514] = [__v_0]; record.function_queries[514].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_515: usize = 0; -const IN_515: usize = 0; -const OUT_515: usize = 1; -fn aiur_fn_515(inp: [G; IN_515], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_515], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(0); let __ret: [G; OUT_515] = [__v_0]; record.function_queries[515].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_516: usize = 0; -const IN_516: usize = 0; -const OUT_516: usize = 1; -fn aiur_fn_516(inp: [G; IN_516], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_516], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(1); let __ret: [G; OUT_516] = [__v_0]; record.function_queries[516].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_517: usize = 0; -const IN_517: usize = 0; -const OUT_517: usize = 1; -fn aiur_fn_517(inp: [G; IN_517], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_517], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(2); let __ret: [G; OUT_517] = [__v_0]; record.function_queries[517].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_518: usize = 0; -const IN_518: usize = 0; -const OUT_518: usize = 1; -fn aiur_fn_518(inp: [G; IN_518], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_518], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(4); let __ret: [G; OUT_518] = [__v_0]; record.function_queries[518].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_519: usize = 0; -const IN_519: usize = 0; -const OUT_519: usize = 1; -fn aiur_fn_519(inp: [G; IN_519], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_519], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(5); let __ret: [G; OUT_519] = [__v_0]; record.function_queries[519].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_520: usize = 0; -const IN_520: usize = 0; -const OUT_520: usize = 1; -fn aiur_fn_520(inp: [G; IN_520], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_520], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(6); let __ret: [G; OUT_520] = [__v_0]; record.function_queries[520].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_521: usize = 0; -const IN_521: usize = 0; -const OUT_521: usize = 1; -fn aiur_fn_521(inp: [G; IN_521], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_521], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(8); let __ret: [G; OUT_521] = [__v_0]; record.function_queries[521].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_522: usize = 0; -const IN_522: usize = 0; -const OUT_522: usize = 1; -fn aiur_fn_522(inp: [G; IN_522], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_522], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(9); let __ret: [G; OUT_522] = [__v_0]; record.function_queries[522].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_523: usize = 0; -const IN_523: usize = 0; -const OUT_523: usize = 1; -fn aiur_fn_523(inp: [G; IN_523], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_523], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(30); let __ret: [G; OUT_523] = [__v_0]; record.function_queries[523].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_524: usize = 0; -const IN_524: usize = 0; -const OUT_524: usize = 1; -fn aiur_fn_524(inp: [G; IN_524], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_524], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(31); let __ret: [G; OUT_524] = [__v_0]; record.function_queries[524].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_525: usize = 0; -const IN_525: usize = 0; -const OUT_525: usize = 1; -fn aiur_fn_525(inp: [G; IN_525], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_525], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(32); let __ret: [G; OUT_525] = [__v_0]; record.function_queries[525].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_526: usize = 0; -const IN_526: usize = 0; -const OUT_526: usize = 1; -fn aiur_fn_526(inp: [G; IN_526], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_526], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(34); let __ret: [G; OUT_526] = [__v_0]; record.function_queries[526].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_527: usize = 0; -const IN_527: usize = 0; -const OUT_527: usize = 1; -fn aiur_fn_527(inp: [G; IN_527], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_527], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(35); let __ret: [G; OUT_527] = [__v_0]; record.function_queries[527].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_528: usize = 0; -const IN_528: usize = 0; -const OUT_528: usize = 1; -fn aiur_fn_528(inp: [G; IN_528], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_528], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(36); let __ret: [G; OUT_528] = [__v_0]; record.function_queries[528].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_529: usize = 0; -const IN_529: usize = 0; -const OUT_529: usize = 1; -fn aiur_fn_529(inp: [G; IN_529], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_529], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(37); let __ret: [G; OUT_529] = [__v_0]; record.function_queries[529].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_530: usize = 0; -const IN_530: usize = 0; -const OUT_530: usize = 1; -fn aiur_fn_530(inp: [G; IN_530], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_530], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(38); let __ret: [G; OUT_530] = [__v_0]; record.function_queries[530].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_531: usize = 0; -const IN_531: usize = 0; -const OUT_531: usize = 1; -fn aiur_fn_531(inp: [G; IN_531], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_531], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(39); let __ret: [G; OUT_531] = [__v_0]; record.function_queries[531].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_532: usize = 0; -const IN_532: usize = 0; -const OUT_532: usize = 1; -fn aiur_fn_532(inp: [G; IN_532], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_532], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(40); let __ret: [G; OUT_532] = [__v_0]; record.function_queries[532].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_533: usize = 0; -const IN_533: usize = 0; -const OUT_533: usize = 1; -fn aiur_fn_533(inp: [G; IN_533], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_533], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(42); let __ret: [G; OUT_533] = [__v_0]; record.function_queries[533].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_534: usize = 0; -const IN_534: usize = 0; -const OUT_534: usize = 1; -fn aiur_fn_534(inp: [G; IN_534], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_534], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(56); let __ret: [G; OUT_534] = [__v_0]; record.function_queries[534].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_535: usize = 0; -const IN_535: usize = 0; -const OUT_535: usize = 1; -fn aiur_fn_535(inp: [G; IN_535], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_535], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(57); let __ret: [G; OUT_535] = [__v_0]; record.function_queries[535].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_536: usize = 0; -const IN_536: usize = 0; -const OUT_536: usize = 1; -fn aiur_fn_536(inp: [G; IN_536], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_536], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(58); let __ret: [G; OUT_536] = [__v_0]; record.function_queries[536].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_537: usize = 0; -const IN_537: usize = 0; -const OUT_537: usize = 1; -fn aiur_fn_537(inp: [G; IN_537], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_537], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(60); let __ret: [G; OUT_537] = [__v_0]; record.function_queries[537].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_538: usize = 0; -const IN_538: usize = 0; -const OUT_538: usize = 1; -fn aiur_fn_538(inp: [G; IN_538], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_538], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(61); let __ret: [G; OUT_538] = [__v_0]; record.function_queries[538].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_539: usize = 0; -const IN_539: usize = 0; -const OUT_539: usize = 1; -fn aiur_fn_539(inp: [G; IN_539], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_539], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(63); let __ret: [G; OUT_539] = [__v_0]; record.function_queries[539].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_540: usize = 0; -const IN_540: usize = 0; -const OUT_540: usize = 1; -fn aiur_fn_540(inp: [G; IN_540], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_540], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(64); let __ret: [G; OUT_540] = [__v_0]; record.function_queries[540].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_541: usize = 0; -const IN_541: usize = 0; -const OUT_541: usize = 1; -fn aiur_fn_541(inp: [G; IN_541], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_541], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(66); let __ret: [G; OUT_541] = [__v_0]; record.function_queries[541].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_542: usize = 0; -const IN_542: usize = 0; -const OUT_542: usize = 1; -fn aiur_fn_542(inp: [G; IN_542], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_542], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(68); let __ret: [G; OUT_542] = [__v_0]; record.function_queries[542].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_543: usize = 0; -const IN_543: usize = 0; -const OUT_543: usize = 1; -fn aiur_fn_543(inp: [G; IN_543], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_543], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(70); let __ret: [G; OUT_543] = [__v_0]; record.function_queries[543].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_544: usize = 0; -const IN_544: usize = 0; -const OUT_544: usize = 1; -fn aiur_fn_544(inp: [G; IN_544], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_544], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(71); let __ret: [G; OUT_544] = [__v_0]; record.function_queries[544].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_545: usize = 0; -const IN_545: usize = 0; -const OUT_545: usize = 1; -fn aiur_fn_545(inp: [G; IN_545], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_545], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(84); let __ret: [G; OUT_545] = [__v_0]; record.function_queries[545].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_546: usize = 0; -const IN_546: usize = 0; -const OUT_546: usize = 1; -fn aiur_fn_546(inp: [G; IN_546], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_546], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(89); let __ret: [G; OUT_546] = [__v_0]; record.function_queries[546].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_547: usize = 0; -const IN_547: usize = 0; -const OUT_547: usize = 1; -fn aiur_fn_547(inp: [G; IN_547], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_547], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(94); let __ret: [G; OUT_547] = [__v_0]; record.function_queries[547].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_548: usize = 0; -const IN_548: usize = 0; -const OUT_548: usize = 1; -fn aiur_fn_548(inp: [G; IN_548], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_548], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 1024, || { let unconstrained = UNCONSTRAINED; aiur::execute::check_record_cap(&record.budget)?; let __v_0: G = G::from_u64(96); let __ret: [G; OUT_548] = [__v_0]; record.function_queries[548].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_549: usize = 1; -const IN_549: usize = 1; -const OUT_549: usize = 1; -fn aiur_fn_549(inp: [G; IN_549], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_549], ExecError> { 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() { 4u64 => { let __v_1: G = G::from_u64(11); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(11); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(11); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(11); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(3); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(3); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 18u64 => { let __v_1: G = G::from_u64(19); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 19u64 => { let __v_1: G = G::from_u64(19); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 20u64 => { let __v_1: G = G::from_u64(20); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 21u64 => { let __v_1: G = G::from_u64(20); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 22u64 => { let __v_1: G = G::from_u64(20); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 23u64 => { let __v_1: G = G::from_u64(21); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 24u64 => { let __v_1: G = G::from_u64(21); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 25u64 => { let __v_1: G = G::from_u64(21); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 26u64 => { let __v_1: G = G::from_u64(22); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 27u64 => { let __v_1: G = G::from_u64(22); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 28u64 => { let __v_1: G = G::from_u64(22); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 29u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 30u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 31u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 33u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 34u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 35u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 36u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 37u64 => { let __v_1: G = G::from_u64(7); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 38u64 => { let __v_1: G = G::from_u64(10); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 39u64 => { let __v_1: G = G::from_u64(6); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 40u64 => { let __v_1: G = G::from_u64(9); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 41u64 => { let __v_1: G = G::from_u64(12); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 42u64 => { let __v_1: G = G::from_u64(13); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 43u64 => { let __v_1: G = G::from_u64(14); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 44u64 => { let __v_1: G = G::from_u64(15); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 45u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 46u64 => { let __v_1: G = G::from_u64(17); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 47u64 => { let __v_1: G = G::from_u64(18); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 48u64 => { let __v_1: G = G::from_u64(33); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 49u64 => { let __v_1: G = G::from_u64(34); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 50u64 => { let __v_1: G = G::from_u64(35); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 51u64 => { let __v_1: G = G::from_u64(36); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 52u64 => { let __v_1: G = G::from_u64(37); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 53u64 => { let __v_1: G = G::from_u64(38); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 54u64 => { let __v_1: G = G::from_u64(39); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 55u64 => { let __v_1: G = G::from_u64(40); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 56u64 => { let __v_1: G = G::from_u64(23); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 57u64 => { let __v_1: G = G::from_u64(24); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 58u64 => { let __v_1: G = G::from_u64(25); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 59u64 => { let __v_1: G = G::from_u64(27); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 60u64 => { let __v_1: G = G::from_u64(27); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 61u64 => { let __v_1: G = G::from_u64(27); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 62u64 => { let __v_1: G = G::from_u64(26); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 63u64 => { let __v_1: G = G::from_u64(42); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 64u64 => { let __v_1: G = G::from_u64(43); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 65u64 => { let __v_1: G = G::from_u64(41); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 66u64 => { let __v_1: G = G::from_u64(28); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 67u64 => { let __v_1: G = G::from_u64(44); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 68u64 => { let __v_1: G = G::from_u64(45); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 69u64 => { let __v_1: G = G::from_u64(46); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 70u64 => { let __v_1: G = G::from_u64(29); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 71u64 => { let __v_1: G = G::from_u64(29); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 72u64 => { let __v_1: G = G::from_u64(29); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 73u64 => { let __v_1: G = G::from_u64(47); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 74u64 => { let __v_1: G = G::from_u64(48); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 75u64 => { let __v_1: G = G::from_u64(49); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 76u64 => { let __v_1: G = G::from_u64(50); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 77u64 => { let __v_1: G = G::from_u64(51); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 78u64 => { let __v_1: G = G::from_u64(52); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 79u64 => { let __v_1: G = G::from_u64(53); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 80u64 => { let __v_1: G = G::from_u64(54); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 81u64 => { let __v_1: G = G::from_u64(55); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 82u64 => { let __v_1: G = G::from_u64(56); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 83u64 => { let __v_1: G = G::from_u64(31); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 84u64 => { let __v_1: G = G::from_u64(31); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 85u64 => { let __v_1: G = G::from_u64(57); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 86u64 => { let __v_1: G = G::from_u64(58); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 87u64 => { let __v_1: G = G::from_u64(59); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 88u64 => { let __v_1: G = G::from_u64(32); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 89u64 => { let __v_1: G = G::from_u64(32); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 90u64 => { let __v_1: G = G::from_u64(60); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 91u64 => { let __v_1: G = G::from_u64(61); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 92u64 => { let __v_1: G = G::from_u64(62); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 93u64 => { let __v_1: G = G::from_u64(63); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 94u64 => { let __v_1: G = G::from_u64(30); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 95u64 => { let __v_1: G = G::from_u64(64); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 96u64 => { let __v_1: G = G::from_u64(65); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 97u64 => { let __v_1: G = G::from_u64(66); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 98u64 => { let __v_1: G = G::from_u64(67); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 99u64 => { let __v_1: G = G::from_u64(68); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 100u64 => { let __v_1: G = G::from_u64(69); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 101u64 => { let __v_1: G = G::from_u64(70); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 102u64 => { let __v_1: G = G::from_u64(71); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_549] = [__v_1]; record.function_queries[549].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_550: usize = 1; -const IN_550: usize = 1; -const OUT_550: usize = 1; -fn aiur_fn_550(inp: [G; IN_550], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_550], ExecError> { 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(0); let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(2); let __v_4: G = G::from_u64(3); let __v_5: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 3] = [__v_1, __v_4, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_1, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_9]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(8); let __v_3: G = G::from_u64(9); let __v_4: G = G::from_u64(10); 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(1).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_1, __v_4, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_9]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(11); let __v_3: G = G::from_u64(12); let __v_4: G = G::from_u64(13); 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(1).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_1, __v_4, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_9]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(14); let __v_3: G = G::from_u64(15); 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(1).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_6: G = { let __values: [G; 3] = [__v_1, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_7]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(16); let __v_3: G = G::from_u64(17); 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(1).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_6: G = { let __values: [G; 3] = [__v_1, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_7]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(32); let __v_3: G = G::from_u64(33); let __v_4: G = G::from_u64(34); let __v_5: G = G::from_u64(35); let __v_6: G = G::from_u64(36); 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(1).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_1, __v_6, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_5, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_13]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(39); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(37); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(29); let __v_3: G = G::from_u64(30); let __v_4: G = G::from_u64(31); 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(1).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_1, __v_4, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_9]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(40); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(38); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(4); let __v_3: G = G::from_u64(5); let __v_4: G = G::from_u64(6); let __v_5: G = G::from_u64(7); 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(1).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_1, __v_5, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_3, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_11]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(41); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(42); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(43); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(44); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(45); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(46); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 18u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(47); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 19u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(18); let __v_3: G = G::from_u64(19); 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(1).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_6: G = { let __values: [G; 3] = [__v_1, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_7]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 20u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(20); let __v_3: G = G::from_u64(21); let __v_4: G = G::from_u64(22); 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(1).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_1, __v_4, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_9]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 21u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(23); let __v_3: G = G::from_u64(24); let __v_4: G = G::from_u64(25); 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(1).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_1, __v_4, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_9]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 22u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(26); let __v_3: G = G::from_u64(27); let __v_4: G = G::from_u64(28); 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(1).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_1, __v_4, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_9]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 23u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(56); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 24u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(57); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 25u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(58); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 26u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(62); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 27u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(59); let __v_3: G = G::from_u64(60); let __v_4: G = G::from_u64(61); 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(1).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_1, __v_4, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_9]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 28u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(66); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 29u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(70); let __v_3: G = G::from_u64(71); let __v_4: G = G::from_u64(72); 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(1).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_1, __v_4, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_9]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 30u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(94); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 31u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(83); let __v_3: G = G::from_u64(84); 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(1).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_6: G = { let __values: [G; 3] = [__v_1, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_7]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(88); let __v_3: G = G::from_u64(89); 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(1).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_6: G = { let __values: [G; 3] = [__v_1, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_7]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 33u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(48); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 34u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(49); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 35u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(50); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 36u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(51); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 37u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(52); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 38u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(53); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 39u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(54); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 40u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(55); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 41u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(65); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 42u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(63); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 43u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(64); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 44u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(67); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 45u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(68); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 46u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(69); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 47u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(73); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 48u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(74); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 49u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(75); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 50u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(76); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 51u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(77); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 52u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(78); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 53u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(79); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 54u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(80); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 55u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(81); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 56u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(82); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 57u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(85); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 58u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(86); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 59u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(87); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 60u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(90); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 61u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(91); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 62u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(92); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 63u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(93); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 64u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(95); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 65u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(96); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 66u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(97); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 67u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(98); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 68u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(99); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 69u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(100); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 70u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(101); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 71u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(102); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_5]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1); let __v_2: G = { let __values: [G; 3] = [__v_1, __v_1, __v_1]; let __mq = record.memory_queries.get_index_mut(1).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_550] = [__v_2]; record.function_queries[550].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_551: usize = 1; -const IN_551: usize = 1; -const OUT_551: usize = 1; -fn aiur_fn_551(inp: [G; IN_551], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_551], ExecError> { 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() { 5u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(8); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_5]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(39); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 3] = [__v_1, __v_1, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_6]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(29); let __v_3: G = G::from_u64(39); let __v_4: G = G::from_u64(37); 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(1).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_1, __v_4, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_9]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(0); 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(1).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 = { let __values: [G; 3] = [__v_1, __v_1, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_4]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(0); 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(1).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 = { let __values: [G; 3] = [__v_1, __v_1, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_4]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(41); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 3] = [__v_1, __v_1, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_6]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(42); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 3] = [__v_1, __v_1, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_6]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(42); let __v_3: G = G::from_u64(44); 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(1).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_6: G = { let __values: [G; 3] = [__v_1, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_1, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_8]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(4); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 3] = [__v_1, __v_1, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_6]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 18u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(4); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 3] = [__v_1, __v_1, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_6]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 23u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(23); let __v_3: G = G::from_u64(8); 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(1).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_6: G = { let __values: [G; 3] = [__v_1, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_7]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 24u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(26); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_5]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 25u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(4); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_5]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 27u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(62); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_5]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 28u64 => { let __v_1: G = G::from_u64(0); 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(1).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 = { let __values: [G; 3] = [__v_1, __v_1, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_4]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 29u64 => { let __v_1: G = G::from_u64(0); 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(1).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 = { let __values: [G; 3] = [__v_1, __v_1, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_4]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 30u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(70); 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(1).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_5: G = { let __values: [G; 3] = [__v_1, __v_2, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_5]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 31u64 => { let __v_1: G = G::from_u64(0); 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(1).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 = { let __values: [G; 3] = [__v_1, __v_1, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_4]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 33u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(41); let __v_3: G = G::from_u64(43); let __v_4: G = G::from_u64(47); let __v_5: G = G::from_u64(4); let __v_6: G = G::from_u64(8); 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(1).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_1, __v_6, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_5, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_1, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_14]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 34u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(41); let __v_3: G = G::from_u64(43); let __v_4: G = G::from_u64(47); let __v_5: G = G::from_u64(4); let __v_6: G = G::from_u64(8); 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(1).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_1, __v_6, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_5, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_1, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_14]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 35u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(47); let __v_3: G = G::from_u64(49); let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(8); 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(1).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_1, __v_5, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_3, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_1, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_12]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 36u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(42); let __v_3: G = G::from_u64(44); let __v_4: G = G::from_u64(47); let __v_5: G = G::from_u64(48); let __v_6: G = G::from_u64(49); let __v_7: G = G::from_u64(4); let __v_8: G = G::from_u64(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(1).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_1, __v_8, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_6, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_5, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_3, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_2, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_17]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_18]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 37u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(42); let __v_3: G = G::from_u64(43); let __v_4: G = G::from_u64(44); let __v_5: G = G::from_u64(47); let __v_6: G = G::from_u64(48); let __v_7: G = G::from_u64(49); let __v_8: G = G::from_u64(4); let __v_9: G = G::from_u64(8); 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(1).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_1, __v_9, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_8, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_7, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_6, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_5, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_4, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_3, __v_17]; let __mq = record.memory_queries.get_index_mut(1).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_2, __v_18]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_19]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_20]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 38u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(42); let __v_3: G = G::from_u64(44); let __v_4: G = G::from_u64(47); let __v_5: G = G::from_u64(48); let __v_6: G = G::from_u64(49); let __v_7: G = G::from_u64(4); let __v_8: G = G::from_u64(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(1).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_1, __v_8, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_6, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_5, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_3, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_2, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_17]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_18]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 39u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(43); let __v_3: G = G::from_u64(44); let __v_4: G = G::from_u64(47); let __v_5: G = G::from_u64(4); let __v_6: G = G::from_u64(8); 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(1).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_1, __v_6, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_5, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_1, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_14]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 40u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(43); let __v_3: G = G::from_u64(47); let __v_4: G = G::from_u64(48); let __v_5: G = G::from_u64(4); let __v_6: G = G::from_u64(8); 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(1).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_1, __v_6, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_5, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_1, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_14]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 41u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(59); let __v_3: G = G::from_u64(62); let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(8); 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(1).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_1, __v_5, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_3, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_11]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 42u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(59); let __v_3: G = G::from_u64(65); let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(8); 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(1).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_1, __v_5, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_3, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_11]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 43u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(59); let __v_3: G = G::from_u64(65); let __v_4: G = G::from_u64(62); let __v_5: G = G::from_u64(4); let __v_6: G = G::from_u64(8); 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(1).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_1, __v_6, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_5, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_13]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 44u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(4); let __v_3: G = G::from_u64(8); let __v_4: G = G::from_u64(59); let __v_5: G = G::from_u64(65); let __v_6: G = G::from_u64(46); 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(1).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_1, __v_6, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_5, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_1, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_14]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 45u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(4); let __v_3: G = G::from_u64(8); let __v_4: G = G::from_u64(59); let __v_5: G = G::from_u64(65); let __v_6: G = G::from_u64(66); let __v_7: G = G::from_u64(47); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_5, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_16]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 46u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(8); let __v_3: G = G::from_u64(59); let __v_4: G = G::from_u64(66); let __v_5: G = G::from_u64(68); 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(1).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_1, __v_5, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_3, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_1, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_12]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 47u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(70); let __v_3: G = G::from_u64(8); 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(1).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_6: G = { let __values: [G; 3] = [__v_1, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_1, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_8]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 48u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(70); let __v_3: G = G::from_u64(4); let __v_4: G = G::from_u64(8); let __v_5: G = G::from_u64(41); let __v_6: G = G::from_u64(43); let __v_7: G = G::from_u64(47); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_5, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_16]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 49u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(70); let __v_3: G = G::from_u64(8); let __v_4: G = G::from_u64(73); 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(1).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_1, __v_4, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_1, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_10]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 50u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(70); let __v_3: G = G::from_u64(8); let __v_4: G = G::from_u64(42); let __v_5: G = G::from_u64(74); 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(1).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_1, __v_5, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_3, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_1, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_12]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 51u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(70); let __v_3: G = G::from_u64(8); let __v_4: G = G::from_u64(76); let __v_5: G = G::from_u64(75); 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(1).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_1, __v_5, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_3, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_11]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 52u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(70); let __v_3: G = G::from_u64(8); let __v_4: G = G::from_u64(44); let __v_5: G = G::from_u64(73); 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(1).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_1, __v_5, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_3, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_1, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_12]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 53u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(70); let __v_3: G = G::from_u64(8); 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(1).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_6: G = { let __values: [G; 3] = [__v_1, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_1, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_8]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 54u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(70); let __v_3: G = G::from_u64(8); let __v_4: G = G::from_u64(48); let __v_5: G = G::from_u64(75); 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(1).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_1, __v_5, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_3, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_1, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_12]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 55u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(70); let __v_3: G = G::from_u64(8); let __v_4: G = G::from_u64(49); let __v_5: G = G::from_u64(74); 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(1).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_1, __v_5, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_3, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_1, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_12]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 56u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(70); let __v_3: G = G::from_u64(4); let __v_4: G = G::from_u64(8); let __v_5: G = G::from_u64(45); let __v_6: G = G::from_u64(49); let __v_7: G = G::from_u64(46); let __v_8: G = G::from_u64(75); 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(1).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_1, __v_8, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_6, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_5, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_3, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_2, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_17]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_18]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 57u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(8); let __v_3: G = G::from_u64(83); let __v_4: G = G::from_u64(49); let __v_5: G = G::from_u64(45); 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(1).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_1, __v_5, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_3, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_1, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_12]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 58u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(4); let __v_3: G = G::from_u64(8); let __v_4: G = G::from_u64(83); let __v_5: G = G::from_u64(49); let __v_6: G = G::from_u64(45); let __v_7: G = G::from_u64(47); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_5, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_16]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 59u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(37); let __v_3: G = G::from_u64(4); let __v_4: G = G::from_u64(8); let __v_5: G = G::from_u64(59); let __v_6: G = G::from_u64(65); 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(1).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_1, __v_6, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_5, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_13]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 60u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(37); let __v_3: G = G::from_u64(29); let __v_4: G = G::from_u64(39); let __v_5: G = G::from_u64(38); let __v_6: G = G::from_u64(8); let __v_7: G = G::from_u64(88); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_5, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_15]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 61u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(29); let __v_3: G = G::from_u64(8); 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(1).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_6: G = { let __values: [G; 3] = [__v_1, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_7]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 62u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(37); let __v_3: G = G::from_u64(29); let __v_4: G = G::from_u64(39); let __v_5: G = G::from_u64(38); let __v_6: G = G::from_u64(8); let __v_7: G = G::from_u64(91); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_5, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_15]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 63u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(59); let __v_3: G = G::from_u64(62); let __v_4: G = G::from_u64(8); 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(1).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_1, __v_4, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_9]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 64u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(70); let __v_3: G = G::from_u64(4); let __v_4: G = G::from_u64(8); let __v_5: G = G::from_u64(59); let __v_6: G = G::from_u64(65); let __v_7: G = G::from_u64(46); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_5, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_16]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 65u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(70); let __v_3: G = G::from_u64(4); let __v_4: G = G::from_u64(8); let __v_5: G = G::from_u64(59); let __v_6: G = G::from_u64(65); let __v_7: G = G::from_u64(94); let __v_8: G = G::from_u64(47); 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(1).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_1, __v_8, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_6, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_5, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_3, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_2, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_17]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_18]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 66u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(70); let __v_3: G = G::from_u64(8); let __v_4: G = G::from_u64(59); let __v_5: G = G::from_u64(94); let __v_6: G = G::from_u64(76); let __v_7: G = G::from_u64(96); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_5, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_16]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 67u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(70); let __v_3: G = G::from_u64(8); let __v_4: G = G::from_u64(93); let __v_5: G = G::from_u64(94); let __v_6: G = G::from_u64(76); let __v_7: G = G::from_u64(77); let __v_8: G = G::from_u64(80); let __v_9: G = G::from_u64(81); let __v_10: G = G::from_u64(97); 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(1).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_1, __v_10, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_9, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_8, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_7, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_5, __v_17]; let __mq = record.memory_queries.get_index_mut(1).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_4, __v_18]; let __mq = record.memory_queries.get_index_mut(1).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_3, __v_19]; let __mq = record.memory_queries.get_index_mut(1).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_2, __v_20]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_21]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_22]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 68u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(70); let __v_3: G = G::from_u64(8); let __v_4: G = G::from_u64(93); let __v_5: G = G::from_u64(94); let __v_6: G = G::from_u64(76); let __v_7: G = G::from_u64(80); let __v_8: G = G::from_u64(81); let __v_9: G = G::from_u64(97); let __v_10: G = G::from_u64(67); 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(1).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_1, __v_10, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_9, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_8, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_7, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_5, __v_17]; let __mq = record.memory_queries.get_index_mut(1).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_4, __v_18]; let __mq = record.memory_queries.get_index_mut(1).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_3, __v_19]; let __mq = record.memory_queries.get_index_mut(1).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_2, __v_20]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_21]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_22]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 69u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(39); let __v_3: G = G::from_u64(40); let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(8); let __v_6: G = G::from_u64(44); let __v_7: G = G::from_u64(47); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_1, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_6, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_5, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_3, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_2, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_16]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 70u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(37); let __v_3: G = G::from_u64(29); let __v_4: G = G::from_u64(39); let __v_5: G = G::from_u64(38); let __v_6: G = G::from_u64(8); let __v_7: G = G::from_u64(42); let __v_8: G = G::from_u64(100); 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(1).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_1, __v_8, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_6, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_5, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_3, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_2, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_17]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_18]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 71u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(37); let __v_3: G = G::from_u64(29); let __v_4: G = G::from_u64(39); let __v_5: G = G::from_u64(40); let __v_6: G = G::from_u64(38); let __v_7: G = G::from_u64(8); let __v_8: G = G::from_u64(44); 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(1).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_1, __v_8, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_6, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_5, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_4, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_3, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_2, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_1, __v_17]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_18]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1); let __v_2: G = { let __values: [G; 3] = [__v_1, __v_1, __v_1]; let __mq = record.memory_queries.get_index_mut(1).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_551] = [__v_2]; record.function_queries[551].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_552: usize = 1; -const IN_552: usize = 1; -const OUT_552: usize = 1; -fn aiur_fn_552(inp: [G; IN_552], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_552], ExecError> { 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() { 4u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 18u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 19u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 20u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 21u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 22u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 29u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 30u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 31u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 37u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 38u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 39u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 40u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 41u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 42u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 43u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 44u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 45u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 46u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 47u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 48u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 49u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 50u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 51u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 52u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 53u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 54u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 55u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 56u64 => { let __v_1: G = G::from_u64(3); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 57u64 => { let __v_1: G = G::from_u64(3); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 58u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 59u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 60u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 61u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 62u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 63u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 64u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 65u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 66u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 67u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 68u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 69u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 70u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 71u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 72u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 73u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 74u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 75u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 76u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 77u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 78u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 79u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 80u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 81u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 82u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 83u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 84u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 85u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 86u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 87u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 88u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 89u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 90u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 91u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 92u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 93u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 94u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 95u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 96u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 97u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 98u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 99u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 100u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 101u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 102u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_552] = [__v_1]; record.function_queries[552].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_553: usize = 1; -const IN_553: usize = 1; -const OUT_553: usize = 1; -fn aiur_fn_553(inp: [G; IN_553], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_553], ExecError> { 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() { 3u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 22u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 25u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 26u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 27u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 28u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 29u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 30u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 31u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 33u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 34u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 35u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 36u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 57u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 58u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 91u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 93u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_553] = [__v_1]; record.function_queries[553].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_554: usize = 1; -const IN_554: usize = 1; -const OUT_554: usize = 1; -fn aiur_fn_554(inp: [G; IN_554], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_554], ExecError> { 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() { 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_554] = [__v_1]; record.function_queries[554].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_554] = [__v_1]; record.function_queries[554].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_554] = [__v_1]; record.function_queries[554].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_554] = [__v_1]; record.function_queries[554].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_554] = [__v_1]; record.function_queries[554].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_554] = [__v_1]; record.function_queries[554].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_554] = [__v_1]; record.function_queries[554].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_554] = [__v_1]; record.function_queries[554].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_554] = [__v_1]; record.function_queries[554].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 24u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_554] = [__v_1]; record.function_queries[554].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 25u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_554] = [__v_1]; record.function_queries[554].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 27u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_554] = [__v_1]; record.function_queries[554].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 28u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_554] = [__v_1]; record.function_queries[554].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_554] = [__v_1]; record.function_queries[554].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 33u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_554] = [__v_1]; record.function_queries[554].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 34u64 => { let __v_1: G = G::from_u64(6); let __ret: [G; OUT_554] = [__v_1]; record.function_queries[554].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 35u64 => { let __v_1: G = G::from_u64(7); let __ret: [G; OUT_554] = [__v_1]; record.function_queries[554].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 36u64 => { let __v_1: G = G::from_u64(3); let __ret: [G; OUT_554] = [__v_1]; record.function_queries[554].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_554] = [__v_1]; record.function_queries[554].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_555: usize = 1; -const IN_555: usize = 1; -const OUT_555: usize = 4; -fn aiur_fn_555(inp: [G; IN_555], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_555], ExecError> { 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() { 2u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(1); let __ret: [G; OUT_555] = [__v_1, __v_2, __v_1, __v_2]; record.function_queries[555].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(8); let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(2); let __ret: [G; OUT_555] = [__v_1, __v_2, __v_3, __v_2]; record.function_queries[555].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(11); let __v_2: G = G::from_u64(0); let __ret: [G; OUT_555] = [__v_1, __v_2, __v_2, __v_2]; record.function_queries[555].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 24u64 => { let __v_1: G = G::from_u64(23); let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(2); let __ret: [G; OUT_555] = [__v_1, __v_2, __v_3, __v_3]; record.function_queries[555].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 27u64 => { let __v_1: G = G::from_u64(26); let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(1); let __ret: [G; OUT_555] = [__v_1, __v_2, __v_3, __v_3]; record.function_queries[555].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_555] = [__v_1, __v_1, __v_1, __v_1]; record.function_queries[555].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_556: usize = 1; -const IN_556: usize = 1; -const OUT_556: usize = 1; -fn aiur_fn_556(inp: [G; IN_556], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_556], ExecError> { 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(2); let __ret: [G; OUT_556] = [__v_1]; record.function_queries[556].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_556] = [__v_1]; record.function_queries[556].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_556] = [__v_1]; record.function_queries[556].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 23u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_556] = [__v_1]; record.function_queries[556].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 26u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_556] = [__v_1]; record.function_queries[556].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_556] = [__v_1]; record.function_queries[556].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_557: usize = 2; -const IN_557: usize = 2; -const OUT_557: usize = 1; -fn aiur_fn_557(inp: [G; IN_557], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_557], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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 = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = { let __values: [G; 3] = [__v_2, __v_4, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 4] = [__v_2, __v_5, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_6]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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; 4] = [__v_2, __v_4, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_7]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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; 4] = [__v_2, __v_4, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_7, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_9]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { 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(1).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(2); let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 4] = [__v_4, __v_6, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = { let __values: [G; 4] = [__v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(3); let __v_10: G = { let __values: [G; 4] = [__v_5, __v_9, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_12: G = G::from_u64(4); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_2, __v_13, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_11, __v_7, __v_14, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 4] = [__v_4, __v_16, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_17, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_5, __v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_19, __v_8, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_4, __v_21, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_5, __v_2, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_9, __v_22, __v_23, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_9, __v_10, __v_24, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_11, __v_20, __v_25, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_11, __v_7, __v_26, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_9, __v_10, __v_8, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_11, __v_7, __v_28, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_11, __v_27, __v_29, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_11, __v_18, __v_30, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_11, __v_15, __v_31, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_32]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = { let __values: [G; 3] = [__v_2, __v_4, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 4] = [__v_2, __v_5, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_6]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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 = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_4, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_8]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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 = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_4, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_8]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { 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(1).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(2); let __v_5: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_4, __v_6, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = G::from_u64(5); let __v_11: G = { let __values: [G; 3] = [__v_5, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_2, __v_11, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_10, __v_8, __v_12, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_4, __v_15, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_14, __v_9, __v_16, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_2, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_4, __v_20, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_14, __v_18, __v_21, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_7, __v_14, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_14, __v_23, __v_9, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_10, __v_8, __v_24, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_10, __v_22, __v_25, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_10, __v_17, __v_26, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_10, __v_13, __v_27, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_28]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_2: G = G::from_u64(5); let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_3, __v_6, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = { let __values: [G; 4] = [__v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = { let __values: [G; 4] = [__v_5, __v_3, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_3, __v_10, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_2, __v_9, __v_11, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_2, __v_8, __v_12, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_2, __v_7, __v_13, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_14]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_2: G = G::from_u64(4); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = { let __values: [G; 4] = [__v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_6: G = G::from_u64(5); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 4] = [__v_7, __v_4, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(3); let __v_10: G = G::from_u64(2); let __v_11: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_3, __v_4, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_10, __v_12, __v_14, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_7, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_15, __v_16, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_17, __v_5, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_18, __v_5, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_6, __v_5, __v_19, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_6, __v_8, __v_20, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_21]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __v_2: G = G::from_u64(4); let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(0); let __v_5: G = { let __values: [G; 3] = [__v_2, __v_3, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_7: G = { let __values: [G; 4] = [__v_4, __v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_4, __v_5, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = G::from_u64(2); let __v_11: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_10, __v_12, __v_9, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_4, __v_10, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_16: G = { let __values: [G; 4] = [__v_4, __v_15, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_18: G = { let __values: [G; 4] = [__v_3, __v_5, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_15, __v_13, __v_14, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_15, __v_19, __v_7, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_15, __v_20, __v_6, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 3] = [__v_2, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_3, __v_22, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_17, __v_21, __v_23, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_17, __v_7, __v_24, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_15, __v_6, __v_7, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = G::from_u64(9); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_10, __v_28, __v_9, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_15, __v_29, __v_14, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_15, __v_30, __v_7, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_15, __v_26, __v_31, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_4, __v_2, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_15, __v_13, __v_33, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_15, __v_34, __v_16, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_15, __v_35, __v_6, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_15, __v_16, __v_7, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_15, __v_37, __v_6, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_17, __v_36, __v_38, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_17, __v_16, __v_39, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_17, __v_32, __v_40, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_17, __v_25, __v_41, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_17, __v_6, __v_42, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_17, __v_18, __v_43, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_44]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(4); let __v_4: G = G::from_u64(0); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 4] = [__v_2, __v_5, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_6]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(11); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(4); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_5, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_2, __v_4, __v_10, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_11]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(4); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_2, __v_5, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(11); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_14: G = { let __values: [G; 3] = [__v_3, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_4, __v_14, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_11, __v_15, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_18: G = G::from_u64(12); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_17, __v_12, __v_20, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_2, __v_8, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_17, __v_22, __v_12, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_13, __v_11, __v_23, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_13, __v_21, __v_24, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_13, __v_16, __v_25, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_26]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = { let __values: [G; 3] = [__v_2, __v_4, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 4] = [__v_2, __v_5, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_6]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 15u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(14); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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 = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_4, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(5); let __v_10: G = G::from_u64(4); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_5, __v_11, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_12, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_15: G = { let __values: [G; 4] = [__v_7, __v_5, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_14, __v_15, __v_16, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_17, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_13, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_19]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 17u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(16); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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 = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_4, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(5); let __v_10: G = G::from_u64(4); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_5, __v_11, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_12, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_15: G = { let __values: [G; 4] = [__v_7, __v_5, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_14, __v_15, __v_16, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_17, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_13, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_19]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 19u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(18); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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 = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_4, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_8]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 20u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = { let __values: [G; 4] = [__v_2, __v_4, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_6: G = G::from_u64(5); let __v_7: G = { let __values: [G; 4] = [__v_6, __v_5, __v_5, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = { let __values: [G; 4] = [__v_6, __v_5, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_8]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 21u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = { let __values: [G; 4] = [__v_2, __v_4, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_6: G = { let __values: [G; 4] = [__v_3, __v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_7: G = G::from_u64(5); let __v_8: G = G::from_u64(3); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(20); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_9, __v_11, __v_12, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_8, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_14, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_9, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_15, __v_16, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_6, __v_17, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_7, __v_6, __v_18, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_7, __v_5, __v_19, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_7, __v_5, __v_20, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_21]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 22u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = { let __values: [G; 4] = [__v_2, __v_4, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_6: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(2); let __v_8: G = G::from_u64(20); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_7, __v_9, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_7, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_15: G = { let __values: [G; 4] = [__v_3, __v_14, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_17: G = { let __values: [G; 4] = [__v_14, __v_10, __v_11, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_14, __v_17, __v_12, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(4); let __v_20: G = { let __values: [G; 3] = [__v_19, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_2, __v_20, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_16, __v_18, __v_21, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(21); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_7, __v_24, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_3, __v_19, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_14, __v_25, __v_26, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_14, __v_27, __v_15, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_14, __v_28, __v_11, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_14, __v_29, __v_12, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_14, __v_13, __v_30, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_16, __v_13, __v_31, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_16, __v_13, __v_32, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_14, __v_10, __v_15, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_14, __v_34, __v_13, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_14, __v_13, __v_12, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_16, __v_35, __v_36, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_16, __v_33, __v_37, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_16, __v_22, __v_38, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_16, __v_5, __v_39, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_16, __v_5, __v_40, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_41]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 23u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = { let __values: [G; 4] = [__v_2, __v_4, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_6: G = G::from_u64(5); let __v_7: G = { let __values: [G; 4] = [__v_6, __v_5, __v_5, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = { let __values: [G; 4] = [__v_6, __v_5, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_8]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 24u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = { let __values: [G; 4] = [__v_2, __v_4, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_6: G = { let __values: [G; 4] = [__v_3, __v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_7: G = G::from_u64(3); let __v_8: G = { let __values: [G; 4] = [__v_3, __v_7, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(5); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_6, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_8, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(2); let __v_13: G = G::from_u64(23); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_12, __v_14, __v_15, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_16, __v_8, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_12, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_7, __v_17, __v_18, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_11, __v_19, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_9, __v_10, __v_20, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_5, __v_21, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_9, __v_5, __v_22, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_23]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 25u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = { let __values: [G; 4] = [__v_2, __v_4, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_6: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(2); let __v_8: G = G::from_u64(23); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_7, __v_9, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_7, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_15: G = { let __values: [G; 4] = [__v_3, __v_14, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_17: G = { let __values: [G; 4] = [__v_3, __v_16, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_10, __v_11, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_16, __v_19, __v_12, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 3] = [__v_14, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_2, __v_21, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_18, __v_20, __v_22, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_18, __v_13, __v_13, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_18, __v_13, __v_15, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(24); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_7, __v_27, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_16, __v_28, __v_15, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_16, __v_29, __v_17, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_16, __v_30, __v_11, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_16, __v_31, __v_12, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_16, __v_13, __v_32, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_18, __v_25, __v_33, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_18, __v_24, __v_34, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_16, __v_10, __v_17, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_16, __v_36, __v_13, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_16, __v_13, __v_12, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_18, __v_37, __v_38, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_18, __v_35, __v_39, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_18, __v_23, __v_40, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_18, __v_5, __v_41, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_18, __v_5, __v_42, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_43]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 26u64 => { let __v_2: G = G::from_u64(5); let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_3, __v_6, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_3, __v_8, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = { let __values: [G; 4] = [__v_2, __v_7, __v_9, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_10]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 27u64 => { let __v_2: G = G::from_u64(4); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = G::from_u64(5); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 4] = [__v_6, __v_4, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = { let __values: [G; 4] = [__v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(3); let __v_10: G = G::from_u64(2); let __v_11: G = G::from_u64(26); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_3, __v_4, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_10, __v_12, __v_14, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_6, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_15, __v_16, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_5, __v_8, __v_17, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_5, __v_7, __v_18, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_19]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 28u64 => { let __v_2: G = G::from_u64(4); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_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(1).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_3, __v_4, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(26); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_5, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_8, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_16: G = { let __values: [G; 4] = [__v_5, __v_4, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_18: G = { let __values: [G; 4] = [__v_17, __v_11, __v_12, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_5, __v_19, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_15, __v_18, __v_20, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(27); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_8, __v_23, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_17, __v_24, __v_14, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_17, __v_25, __v_12, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_17, __v_13, __v_26, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_15, __v_13, __v_27, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_17, __v_11, __v_14, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_17, __v_14, __v_12, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_15, __v_29, __v_30, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_15, __v_28, __v_31, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_15, __v_21, __v_32, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_15, __v_16, __v_33, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_34]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 29u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(4); let __v_4: G = G::from_u64(0); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 3] = [__v_2, __v_5, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_2, __v_6, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_7, __v_7, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_9]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 30u64 => { let __v_2: G = G::from_u64(4); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = G::from_u64(5); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_4, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_6, __v_7, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(3); let __v_10: G = G::from_u64(2); let __v_11: G = G::from_u64(29); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_3, __v_4, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_10, __v_12, __v_14, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_15, __v_16, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_5, __v_8, __v_17, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_18]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 31u64 => { let __v_2: G = G::from_u64(4); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = G::from_u64(2); let __v_6: G = G::from_u64(29); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_3, __v_4, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_5, __v_7, __v_10, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_13: G = { let __values: [G; 3] = [__v_8, __v_4, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_17: G = { let __values: [G; 4] = [__v_3, __v_8, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_16, __v_11, __v_17, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_3, __v_5, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_16, __v_11, __v_19, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_12, __v_18, __v_20, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_15, __v_21, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_12, __v_14, __v_22, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_23]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 32u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(4); let __v_4: G = G::from_u64(0); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 4] = [__v_2, __v_5, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_7: G = G::from_u64(5); let __v_8: G = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = { let __values: [G; 4] = [__v_4, __v_2, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_2, __v_10, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_9, __v_11, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_8, __v_12, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_13, __v_6, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_6, __v_14, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_15]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 33u64 => { let __v_2: G = G::from_u64(4); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 4] = [__v_3, __v_5, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_7: G = G::from_u64(5); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_4, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = { let __values: [G; 4] = [__v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_5, __v_10, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_6, __v_11, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_9, __v_12, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_15: G = G::from_u64(2); let __v_16: G = G::from_u64(32); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_3, __v_4, __v_18]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_15, __v_17, __v_19, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_3, __v_15, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_14, __v_20, __v_21, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_14, __v_22, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_7, __v_6, __v_23, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_7, __v_13, __v_24, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_7, __v_8, __v_25, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_26]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 34u64 => { let __v_2: G = G::from_u64(4); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = { let __values: [G; 4] = [__v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 4] = [__v_3, __v_6, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = { let __values: [G; 3] = [__v_2, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(2); let __v_10: G = { let __values: [G; 4] = [__v_3, __v_9, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_12: G = { let __values: [G; 4] = [__v_3, __v_11, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(5); let __v_16: G = { let __values: [G; 4] = [__v_6, __v_4, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_6, __v_17, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_15, __v_7, __v_18, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_15, __v_5, __v_19, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_6, __v_8, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_15, __v_10, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_11, __v_13, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_11, __v_23, __v_5, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 3] = [__v_3, __v_8, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_9, __v_26, __v_27, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_11, __v_28, __v_13, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_11, __v_12, __v_10, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_11, __v_29, __v_30, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_11, __v_12, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_11, __v_31, __v_32, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_15, __v_24, __v_33, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_15, __v_13, __v_34, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_15, __v_12, __v_35, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(32); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 3] = [__v_3, __v_4, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_40: G = { let __values: [G; 4] = [__v_9, __v_38, __v_39, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_11, __v_40, __v_13, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_11, __v_41, __v_12, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_15, __v_42, __v_12, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_15, __v_36, __v_43, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_15, __v_22, __v_44, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_15, __v_21, __v_45, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_15, __v_20, __v_46, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_15, __v_16, __v_47, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_48]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 35u64 => { let __v_2: G = G::from_u64(4); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = { let __values: [G; 4] = [__v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 4] = [__v_3, __v_6, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_6, __v_8, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_3, __v_4, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(2); let __v_13: G = G::from_u64(32); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_12, __v_14, __v_11, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_12, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_18: G = { let __values: [G; 4] = [__v_3, __v_17, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(5); let __v_20: G = { let __values: [G; 4] = [__v_6, __v_4, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_19, __v_7, __v_9, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_19, __v_5, __v_21, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_17, __v_15, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_17, __v_23, __v_5, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_19, __v_24, __v_9, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(33); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_12, __v_27, __v_11, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_17, __v_28, __v_18, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_17, __v_29, __v_16, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_17, __v_30, __v_5, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_17, __v_7, __v_31, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_19, __v_16, __v_32, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_17, __v_15, __v_18, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_17, __v_34, __v_16, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_17, __v_16, __v_5, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_19, __v_35, __v_36, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_19, __v_33, __v_37, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_19, __v_25, __v_38, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_19, __v_22, __v_39, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_19, __v_20, __v_40, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_41]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 36u64 => { let __v_2: G = G::from_u64(4); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = { let __values: [G; 4] = [__v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 4] = [__v_3, __v_6, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(2); let __v_9: G = { let __values: [G; 4] = [__v_3, __v_8, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_3, __v_4, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_3, __v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_14: G = { let __values: [G; 4] = [__v_3, __v_13, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(33); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 4] = [__v_8, __v_16, __v_11, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_17, __v_12, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_13, __v_18, __v_14, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(5); let __v_21: G = { let __values: [G; 4] = [__v_6, __v_4, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_6, __v_22, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_20, __v_7, __v_23, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_20, __v_5, __v_24, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_13, __v_9, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_13, __v_26, __v_5, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = { let __values: [G; 4] = [__v_8, __v_29, __v_11, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = G::from_u64(32); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 4] = [__v_8, __v_32, __v_11, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_13, __v_33, __v_12, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_13, __v_34, __v_14, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_13, __v_30, __v_35, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_13, __v_19, __v_9, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_13, __v_36, __v_37, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_13, __v_19, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_13, __v_38, __v_39, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_20, __v_27, __v_40, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_20, __v_9, __v_41, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_20, __v_7, __v_42, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_20, __v_25, __v_43, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_20, __v_21, __v_44, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_45]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 37u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = { let __values: [G; 3] = [__v_2, __v_4, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 4] = [__v_2, __v_5, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_6]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 38u64 => { 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(1).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(5); let __v_5: G = G::from_u64(3); let __v_6: G = G::from_u64(2); let __v_7: G = G::from_u64(29); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_10, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_6, __v_8, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_6, __v_14, __v_3, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_5, __v_12, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(37); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_6, __v_18, __v_3, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_4, __v_16, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_20]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 39u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = { let __values: [G; 3] = [__v_2, __v_4, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 4] = [__v_2, __v_5, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_6]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 40u64 => { 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(1).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(5); let __v_5: G = G::from_u64(2); let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 4] = [__v_5, __v_7, __v_3, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_10, __v_3, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_4, __v_8, __v_11, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_12]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 41u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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; 4] = [__v_2, __v_4, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_7, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_9]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 42u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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; 4] = [__v_2, __v_4, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_7, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = { let __values: [G; 4] = [__v_8, __v_7, __v_9, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_10]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 43u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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; 4] = [__v_2, __v_4, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_7, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = { let __values: [G; 4] = [__v_8, __v_7, __v_9, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_10]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 44u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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; 4] = [__v_2, __v_4, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_7, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = { let __values: [G; 4] = [__v_8, __v_7, __v_9, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_10]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 45u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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; 4] = [__v_2, __v_4, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_7, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = { let __values: [G; 4] = [__v_8, __v_7, __v_9, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_10]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 46u64 => { 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(1).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(2); let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 4] = [__v_4, __v_6, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_4, __v_10, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_11, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_12, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_13]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 47u64 => { 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(1).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(2); let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 4] = [__v_4, __v_6, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_4, __v_10, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_11, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_12, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_13]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 48u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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; 4] = [__v_2, __v_4, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_7, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = { let __values: [G; 4] = [__v_8, __v_7, __v_9, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_10]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 49u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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; 4] = [__v_2, __v_4, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_7, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = { let __values: [G; 4] = [__v_8, __v_7, __v_9, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_10]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 50u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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; 4] = [__v_2, __v_4, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_7, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = { let __values: [G; 4] = [__v_8, __v_7, __v_9, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_10]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 51u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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; 4] = [__v_2, __v_4, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_7, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = { let __values: [G; 4] = [__v_8, __v_7, __v_9, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_10]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 52u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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; 4] = [__v_2, __v_4, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_7, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = { let __values: [G; 4] = [__v_8, __v_7, __v_9, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_10]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 53u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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; 4] = [__v_2, __v_4, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_7, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = { let __values: [G; 4] = [__v_8, __v_7, __v_9, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_10]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 54u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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; 4] = [__v_2, __v_4, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_7, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = { let __values: [G; 4] = [__v_8, __v_7, __v_9, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_10]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 55u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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; 4] = [__v_2, __v_4, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_7, __v_7, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = { let __values: [G; 4] = [__v_8, __v_7, __v_9, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_10]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 56u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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 = { let __values: [G; 4] = [__v_4, __v_3, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_6: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_2, __v_4, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = G::from_u64(3); let __v_10: G = G::from_u64(2); let __v_11: G = G::from_u64(23); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_10, __v_12, __v_6, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_13, __v_7, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_14, __v_15, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 3] = [__v_4, __v_3, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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_2, __v_19, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_10, __v_18, __v_20, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_21, __v_5, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_2, __v_10, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_9, __v_22, __v_23, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_9, __v_24, __v_7, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_8, __v_16, __v_25, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_8, __v_5, __v_26, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_8, __v_5, __v_27, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_28]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 57u64 => { let __v_2: G = G::from_u64(4); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = G::from_u64(5); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 4] = [__v_6, __v_4, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(3); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(26); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_3, __v_4, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_9, __v_11, __v_13, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_14, __v_15, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_6, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_5, __v_16, __v_17, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_5, __v_7, __v_18, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_19]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 58u64 => { let __v_2: G = G::from_u64(5); let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_3, __v_6, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(2); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_9, __v_10, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_5, __v_3, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_2, __v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_2, __v_7, __v_13, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_14]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 59u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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(5); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 4] = [__v_5, __v_3, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_5, __v_7, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = { let __values: [G; 4] = [__v_4, __v_6, __v_8, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_9]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 60u64 => { let __v_2: G = G::from_u64(5); let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(0); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 4] = [__v_3, __v_5, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_7: G = { let __values: [G; 4] = [__v_4, __v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(3); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(59); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_9, __v_11, __v_12, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_4, __v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_14, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_2, __v_7, __v_15, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_2, __v_6, __v_16, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_17]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 61u64 => { 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(1).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(5); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_2, __v_6, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(3); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(62); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_9, __v_11, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_13, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(59); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 4] = [__v_9, __v_16, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_5, __v_2, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_8, __v_17, __v_18, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_4, __v_14, __v_19, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_4, __v_7, __v_20, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_21]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 62u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = { let __values: [G; 4] = [__v_2, __v_4, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_6: G = G::from_u64(5); let __v_7: G = { let __values: [G; 4] = [__v_6, __v_5, __v_5, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_7]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 63u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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 = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_7: G = G::from_u64(5); let __v_8: G = { let __values: [G; 4] = [__v_4, __v_3, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(3); let __v_10: G = G::from_u64(2); let __v_11: G = G::from_u64(59); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_10, __v_12, __v_5, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_13, __v_6, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_4, __v_3, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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_2, __v_17, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_10, __v_16, __v_18, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_10, __v_21, __v_5, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_9, __v_19, __v_22, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_10, __v_25, __v_5, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_2, __v_4, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_9, __v_26, __v_27, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_9, __v_28, __v_6, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_9, __v_23, __v_29, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 4] = [__v_10, __v_32, __v_5, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_9, __v_30, __v_33, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_2, __v_10, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_7, __v_34, __v_35, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_7, __v_14, __v_36, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_7, __v_8, __v_37, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_38]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 64u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = { let __values: [G; 3] = [__v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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 = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 4] = [__v_2, __v_2, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_7: G = G::from_u64(5); let __v_8: G = { let __values: [G; 4] = [__v_4, __v_3, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(3); let __v_10: G = G::from_u64(2); let __v_11: G = G::from_u64(59); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_10, __v_12, __v_5, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_13, __v_6, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_4, __v_3, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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_2, __v_17, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_10, __v_16, __v_18, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_10, __v_21, __v_5, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_9, __v_19, __v_22, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_10, __v_25, __v_5, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_2, __v_4, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_9, __v_26, __v_27, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_9, __v_28, __v_6, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_9, __v_23, __v_29, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_10, __v_31, __v_5, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_9, __v_30, __v_32, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(62); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_10, __v_35, __v_5, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_2, __v_10, __v_2, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_9, __v_36, __v_37, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_7, __v_33, __v_38, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_7, __v_14, __v_39, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_7, __v_8, __v_40, __v_2]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_41]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 65u64 => { 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(1).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(5); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_2, __v_6, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(3); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(59); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_9, __v_11, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_13, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 4] = [__v_9, __v_16, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_4, __v_14, __v_17, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_4, __v_7, __v_18, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_19]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 66u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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; 4] = [__v_2, __v_4, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 4] = [__v_5, __v_9, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_10, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_11, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_12]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 67u64 => { 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(1).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(2); let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 4] = [__v_4, __v_6, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = G::from_u64(3); let __v_10: G = G::from_u64(59); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_4, __v_11, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_2, __v_15, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_5, __v_16, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_4, __v_14, __v_17, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_18, __v_7, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_5, __v_2, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_9, __v_19, __v_20, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_9, __v_21, __v_22, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_9, __v_12, __v_23, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_8, __v_7, __v_24, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_8, __v_7, __v_25, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_26]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 68u64 => { 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(1).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(2); let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 4] = [__v_4, __v_6, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = G::from_u64(3); let __v_10: G = G::from_u64(59); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_4, __v_11, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(66); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_4, __v_14, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_5, __v_2, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_15, __v_16, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_17, __v_18, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_12, __v_19, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_8, __v_7, __v_20, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_8, __v_7, __v_21, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_22]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 69u64 => { 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(1).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(2); let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 4] = [__v_4, __v_6, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = G::from_u64(3); let __v_10: G = G::from_u64(59); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_4, __v_11, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(66); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_4, __v_14, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 4] = [__v_4, __v_16, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_5, __v_2, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_17, __v_18, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_15, __v_19, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_20, __v_21, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_9, __v_12, __v_22, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_8, __v_7, __v_23, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_8, __v_7, __v_24, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_25]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 70u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = { let __values: [G; 3] = [__v_2, __v_4, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 4] = [__v_2, __v_5, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_6]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 71u64 => { 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(1).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(5); let __v_5: G = G::from_u64(2); let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 4] = [__v_5, __v_7, __v_3, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_10, __v_3, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_4, __v_8, __v_11, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_12]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 72u64 => { 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(1).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(5); let __v_5: G = G::from_u64(2); let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 4] = [__v_5, __v_7, __v_3, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_10, __v_3, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_4, __v_8, __v_11, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_12]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 73u64 => { 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(1).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(5); let __v_5: G = G::from_u64(2); let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 4] = [__v_5, __v_7, __v_3, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_10, __v_3, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_4, __v_8, __v_11, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_12]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 74u64 => { 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(1).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(2); let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 4] = [__v_4, __v_6, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_4, __v_10, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_11, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_12, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_13]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 75u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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 = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_4, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(5); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_8, __v_8, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_10]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 76u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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 = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_4, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(5); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_8, __v_8, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_10, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_11]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 77u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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 = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_4, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(5); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_8, __v_8, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_10, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_11]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 78u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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 = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_4, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(5); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_8, __v_8, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_10, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_11]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 79u64 => { 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(1).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(5); let __v_5: G = G::from_u64(2); let __v_6: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_10, __v_3, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_4, __v_9, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_12]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 80u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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 = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_4, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(5); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_8, __v_8, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_10, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_11]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 81u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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 = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_4, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(5); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_8, __v_8, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_10, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_11]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 82u64 => { 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(1).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(2); let __v_5: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_4, __v_6, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(5); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_4, __v_10, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_11, __v_8, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_12, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_13]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 83u64 => { let __v_2: G = G::from_u64(5); let __v_3: G = G::from_u64(2); let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; 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(1).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; 4] = [__v_3, __v_5, __v_7, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_6, __v_9, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_6, __v_10, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_2, __v_8, __v_11, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_12]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 84u64 => { 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(1).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(2); let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 4] = [__v_4, __v_6, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = G::from_u64(3); let __v_10: G = G::from_u64(83); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_4, __v_11, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_5, __v_2, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_12, __v_13, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_14, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_15, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_16]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 85u64 => { 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(1).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(2); let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 4] = [__v_4, __v_6, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(5); let __v_9: G = G::from_u64(3); let __v_10: G = G::from_u64(83); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_4, __v_11, __v_3, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_12, __v_13, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_14, __v_7, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_15, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_16]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 86u64 => { 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(1).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(2); let __v_5: G = G::from_u64(83); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_4, __v_6, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(5); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_4, __v_10, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_8, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_2, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_8, __v_15, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_4, __v_18, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_16, __v_19, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_9, __v_14, __v_20, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_11, __v_21, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_22]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 87u64 => { 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(1).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(2); let __v_5: G = G::from_u64(37); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_4, __v_6, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(5); let __v_10: G = G::from_u64(3); let __v_11: G = G::from_u64(59); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_4, __v_12, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_2, __v_16, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_7, __v_17, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_4, __v_15, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_10, __v_19, __v_8, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_7, __v_2, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_10, __v_20, __v_21, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_10, __v_22, __v_23, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_10, __v_13, __v_24, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_9, __v_8, __v_25, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_9, __v_8, __v_26, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_27]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 88u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = { let __values: [G; 3] = [__v_2, __v_4, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = { let __values: [G; 4] = [__v_2, __v_5, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_6]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 89u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(88); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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 = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_4, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_8]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 90u64 => { 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(1).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(5); let __v_5: G = G::from_u64(2); let __v_6: G = G::from_u64(37); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = G::from_u64(88); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_5, __v_11, __v_3, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_4, __v_9, __v_12, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_13]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 91u64 => { let __v_2: G = G::from_u64(4); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = G::from_u64(2); let __v_6: G = G::from_u64(29); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_3, __v_4, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_5, __v_7, __v_10, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_13: G = { let __values: [G; 3] = [__v_8, __v_4, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_16: G = { let __values: [G; 4] = [__v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_15, __v_11, __v_16, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_3, __v_8, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_15, __v_11, __v_18, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_3, __v_5, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_15, __v_11, __v_20, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_19, __v_21, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_12, __v_17, __v_22, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_12, __v_14, __v_23, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_24]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 92u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(37); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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 = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_4, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(5); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_8, __v_8, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_10, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_11]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 93u64 => { let __v_2: G = G::from_u64(5); let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_3, __v_6, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = { let __values: [G; 3] = [__v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_3, __v_8, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = G::from_u64(3); let __v_11: G = G::from_u64(2); let __v_12: G = G::from_u64(59); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_11, __v_13, __v_14, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_10, __v_15, __v_16, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_5, __v_11, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_5, __v_10, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_5, __v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_2, __v_19, __v_20, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_2, __v_18, __v_21, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_2, __v_17, __v_22, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_2, __v_9, __v_23, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_2, __v_7, __v_24, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_25]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 94u64 => { let __v_2: G = G::from_u64(2); let __v_3: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[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(1).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 = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_4, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(5); let __v_10: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_5, __v_10, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_11, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_12, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_13]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 95u64 => { 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(1).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(2); let __v_5: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_4, __v_6, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(5); let __v_10: G = G::from_u64(3); let __v_11: G = G::from_u64(59); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_4, __v_12, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_2, __v_16, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_7, __v_17, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_4, __v_15, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_10, __v_19, __v_8, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_7, __v_2, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_10, __v_20, __v_21, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_10, __v_22, __v_23, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_10, __v_13, __v_24, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_9, __v_8, __v_25, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_9, __v_8, __v_26, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_27]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 96u64 => { 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(1).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(2); let __v_5: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_4, __v_6, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(5); let __v_10: G = G::from_u64(3); let __v_11: G = G::from_u64(59); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_4, __v_12, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(94); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_4, __v_15, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_2, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_10, __v_16, __v_17, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_10, __v_18, __v_19, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_10, __v_13, __v_20, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_8, __v_21, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_9, __v_8, __v_22, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_23]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 97u64 => { 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(1).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(2); let __v_5: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_4, __v_6, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(5); let __v_10: G = G::from_u64(3); let __v_11: G = G::from_u64(59); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_4, __v_12, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(94); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_4, __v_15, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(76); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_4, __v_18, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_7, __v_2, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_10, __v_19, __v_20, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_4, __v_23, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_4, __v_25, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_4, __v_27, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_10, __v_26, __v_28, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_10, __v_24, __v_29, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_10, __v_21, __v_30, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_10, __v_16, __v_31, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_10, __v_32, __v_33, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_10, __v_13, __v_34, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_9, __v_8, __v_35, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_9, __v_8, __v_36, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_37]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 98u64 => { 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(1).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(2); let __v_5: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_4, __v_6, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(5); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_4, __v_10, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_11, __v_8, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_12, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_13]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 99u64 => { 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(1).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(2); let __v_5: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_4, __v_6, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(5); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_4, __v_10, __v_3, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_11, __v_8, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_12, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_13]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 100u64 => { 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(1).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(5); let __v_5: G = G::from_u64(2); let __v_6: G = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_10, __v_3, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_4, __v_9, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_12]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 101u64 => { 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(1).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(5); let __v_5: G = G::from_u64(2); let __v_6: G = G::from_u64(37); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_10, __v_3, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_4, __v_9, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_12]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 102u64 => { 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(1).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(5); let __v_5: G = G::from_u64(2); let __v_6: G = G::from_u64(37); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_5, __v_11, __v_3, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_4, __v_9, __v_12, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_13]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_5: G = { let __values: [G; 4] = [__v_2, __v_4, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(2).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_557] = [__v_5]; record.function_queries[557].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_558: usize = 1; -const IN_558: usize = 1; -const OUT_558: usize = 1; -fn aiur_fn_558(inp: [G; IN_558], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_558], ExecError> { 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() { 41u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_558] = [__v_1]; record.function_queries[558].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 42u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_558] = [__v_1]; record.function_queries[558].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 43u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_558] = [__v_1]; record.function_queries[558].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 44u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_558] = [__v_1]; record.function_queries[558].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 45u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_558] = [__v_1]; record.function_queries[558].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 46u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_558] = [__v_1]; record.function_queries[558].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 47u64 => { let __v_1: G = G::from_u64(3); let __ret: [G; OUT_558] = [__v_1]; record.function_queries[558].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 48u64 => { let __v_1: G = G::from_u64(3); let __ret: [G; OUT_558] = [__v_1]; record.function_queries[558].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 49u64 => { let __v_1: G = G::from_u64(3); let __ret: [G; OUT_558] = [__v_1]; record.function_queries[558].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 50u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_558] = [__v_1]; record.function_queries[558].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 51u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_558] = [__v_1]; record.function_queries[558].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 52u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_558] = [__v_1]; record.function_queries[558].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 53u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_558] = [__v_1]; record.function_queries[558].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 54u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_558] = [__v_1]; record.function_queries[558].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 55u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_558] = [__v_1]; record.function_queries[558].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_558] = [__v_1]; record.function_queries[558].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_559: usize = 1; -const IN_559: usize = 1; -const OUT_559: usize = 1; -fn aiur_fn_559(inp: [G; IN_559], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_559], ExecError> { 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() { 48u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_559] = [__v_1]; record.function_queries[559].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 49u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_559] = [__v_1]; record.function_queries[559].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 50u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_559] = [__v_1]; record.function_queries[559].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 51u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_559] = [__v_1]; record.function_queries[559].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 52u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_559] = [__v_1]; record.function_queries[559].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 53u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_559] = [__v_1]; record.function_queries[559].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 54u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_559] = [__v_1]; record.function_queries[559].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 55u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_559] = [__v_1]; record.function_queries[559].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_559] = [__v_1]; record.function_queries[559].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_560: usize = 3; -const IN_560: usize = 3; -const OUT_560: usize = 1; -fn aiur_fn_560(inp: [G; IN_560], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_560], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(64); let __v_4: G = __v_3 * __v_1; let __v_5: G = __v_4 + __v_2; match __v_5.as_canonical_u64() { 2624u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(41); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_13, __v_16, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_12, __v_11, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_12, __v_11, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_560] = [__v_21]; record.function_queries[560].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2625u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(41); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_13, __v_18, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_16, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_11, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_12, __v_11, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_560] = [__v_23]; record.function_queries[560].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2688u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(42); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_18, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_11, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_12, __v_11, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_560] = [__v_23]; record.function_queries[560].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2689u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(42); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_20, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_13, __v_18, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_12, __v_11, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_12, __v_11, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_560] = [__v_25]; record.function_queries[560].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2752u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(43); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_18, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_11, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_12, __v_11, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_560] = [__v_23]; record.function_queries[560].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2753u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(43); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_20, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_13, __v_18, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_12, __v_11, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_12, __v_11, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_560] = [__v_25]; record.function_queries[560].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2816u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_18, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_11, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_12, __v_11, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_560] = [__v_23]; record.function_queries[560].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2817u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_20, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_13, __v_18, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_12, __v_11, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_12, __v_11, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_560] = [__v_25]; record.function_queries[560].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2880u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(45); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_18, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_11, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_12, __v_11, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_560] = [__v_23]; record.function_queries[560].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2881u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(45); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_20, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_13, __v_18, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_12, __v_11, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_12, __v_11, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_560] = [__v_25]; record.function_queries[560].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2944u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_8, __v_12, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(46); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_15, __v_18, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_15, __v_19, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_14, __v_11, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_14, __v_11, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_560] = [__v_22]; record.function_queries[560].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2945u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(46); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_13, __v_16, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_13, __v_21, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_13, __v_19, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_12, __v_11, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_12, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_560] = [__v_26]; record.function_queries[560].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2946u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(46); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_13, __v_18, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_16, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_13, __v_21, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_12, __v_11, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_12, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_560] = [__v_26]; record.function_queries[560].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2947u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_8, __v_12, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(46); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_15, __v_13, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_15, __v_18, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_15, __v_13, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_15, __v_21, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_14, __v_11, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_14, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_560] = [__v_26]; record.function_queries[560].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3008u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_13, __v_16, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_11, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_12, __v_11, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_560] = [__v_23]; record.function_queries[560].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3009u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_13, __v_18, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_16, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_13, __v_21, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_12, __v_11, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_12, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_560] = [__v_26]; record.function_queries[560].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3010u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_8, __v_12, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_15, __v_13, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_15, __v_18, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_15, __v_13, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_15, __v_21, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_14, __v_11, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_14, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_560] = [__v_26]; record.function_queries[560].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_6, __v_8, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_560] = [__v_9]; record.function_queries[560].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_561: usize = 3; -const IN_561: usize = 3; -const OUT_561: usize = 1; -fn aiur_fn_561(inp: [G; IN_561], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_561], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(64); let __v_4: G = __v_3 * __v_1; let __v_5: G = __v_4 + __v_2; match __v_5.as_canonical_u64() { 2624u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_561] = [__v_16]; record.function_queries[561].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2625u64 => { let __v_6: G = G::from_u64(2); let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; 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(1).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; 4] = [__v_6, __v_8, __v_10, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_9, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_14, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_561] = [__v_15]; record.function_queries[561].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2688u64 => { let __v_6: G = G::from_u64(2); let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; 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(1).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; 4] = [__v_6, __v_8, __v_10, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_9, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_14, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_561] = [__v_15]; record.function_queries[561].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2689u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(42); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_13, __v_18, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_20, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_13, __v_15, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_12, __v_11, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_12, __v_11, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_561] = [__v_25]; record.function_queries[561].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2752u64 => { let __v_6: G = G::from_u64(2); let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; 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(1).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; 4] = [__v_6, __v_8, __v_10, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_9, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_14, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_561] = [__v_15]; record.function_queries[561].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2753u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(41); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(43); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_13, __v_21, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_13, __v_16, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_12, __v_11, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_12, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_561] = [__v_26]; record.function_queries[561].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2816u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_561] = [__v_16]; record.function_queries[561].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2817u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(42); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 4] = [__v_8, __v_16, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_14, __v_20, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_14, __v_21, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_14, __v_17, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_14, __v_24, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_13, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_13, __v_11, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_561] = [__v_27]; record.function_queries[561].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2880u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 4] = [__v_8, __v_16, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_15, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_12, __v_11, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_12, __v_11, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_561] = [__v_20]; record.function_queries[561].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2881u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 4] = [__v_8, __v_16, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(45); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_14, __v_20, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_14, __v_21, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_14, __v_17, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_14, __v_24, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_13, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_13, __v_11, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_561] = [__v_27]; record.function_queries[561].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2944u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_561] = [__v_17]; record.function_queries[561].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2945u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(5); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_561] = [__v_17]; record.function_queries[561].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2946u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(5); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_561] = [__v_17]; record.function_queries[561].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2947u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(46); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_13, __v_18, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_12, __v_11, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_11, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_561] = [__v_22]; record.function_queries[561].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3008u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_561] = [__v_17]; record.function_queries[561].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3009u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(5); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_561] = [__v_17]; record.function_queries[561].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3010u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_13, __v_18, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_12, __v_11, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_11, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_561] = [__v_22]; record.function_queries[561].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_6, __v_8, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_561] = [__v_9]; record.function_queries[561].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_562: usize = 3; -const IN_562: usize = 3; -const OUT_562: usize = 1; -fn aiur_fn_562(inp: [G; IN_562], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_562], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(64); let __v_4: G = __v_3 * __v_1; let __v_5: G = __v_4 + __v_2; match __v_5.as_canonical_u64() { 3072u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_19: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_18, __v_17, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = G::from_u64(48); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = { let __values: [G; 4] = [__v_8, __v_33, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_9, __v_18, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(5); let __v_38: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_18, __v_25, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_18, __v_39, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_18, __v_22, __v_40, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_18, __v_41, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = { let __values: [G; 4] = [__v_8, __v_43, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_18, __v_31, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_18, __v_25, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_18, __v_46, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_18, __v_22, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_18, __v_48, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_18, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_18, __v_34, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_18, __v_51, __v_36, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_18, __v_50, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = G::from_u64(43); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_54]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __v_56: G = { let __values: [G; 4] = [__v_8, __v_55, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = { let __values: [G; 4] = [__v_18, __v_56, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_58: G = { let __values: [G; 4] = [__v_18, __v_57, __v_36, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_59: G = { let __values: [G; 4] = [__v_18, __v_34, __v_58, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_60: G = { let __values: [G; 4] = [__v_18, __v_59, __v_36, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_61: G = { let __values: [G; 4] = [__v_18, __v_31, __v_60, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_62: G = { let __values: [G; 4] = [__v_18, __v_53, __v_61, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_63: G = { let __values: [G; 4] = [__v_37, __v_49, __v_62, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_64: G = { let __values: [G; 4] = [__v_37, __v_42, __v_63, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_65: G = { let __values: [G; 4] = [__v_37, __v_11, __v_64, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_66: G = { let __values: [G; 4] = [__v_37, __v_11, __v_65, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_562] = [__v_66]; record.function_queries[562].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3073u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(5); let __v_20: G = G::from_u64(3); let __v_21: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_20, __v_17, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_20, __v_27, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_20, __v_29, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_20, __v_24, __v_30, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 4] = [__v_8, __v_32, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_20, __v_31, __v_33, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_20, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = G::from_u64(48); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = { let __values: [G; 4] = [__v_8, __v_37, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_20, __v_38, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_20, __v_40, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_20, __v_35, __v_41, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = { let __values: [G; 4] = [__v_8, __v_43, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_20, __v_42, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_19, __v_34, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_19, __v_11, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_19, __v_11, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_562] = [__v_48]; record.function_queries[562].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3074u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(5); let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_8, __v_23, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_21, __v_17, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_8, __v_27, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = { let __values: [G; 4] = [__v_8, __v_29, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_21, __v_30, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_21, __v_28, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_21, __v_32, __v_33, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_21, __v_25, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 4] = [__v_8, __v_36, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_21, __v_35, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_21, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(48); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_21, __v_42, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_21, __v_44, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_21, __v_39, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_21, __v_47, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_20, __v_38, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_20, __v_11, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_20, __v_11, __v_50, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_562] = [__v_51]; record.function_queries[562].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3136u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_19: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_18, __v_17, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_8, __v_31, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_9, __v_18, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = G::from_u64(5); let __v_36: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_18, __v_25, __v_36, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_18, __v_37, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_18, __v_22, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_18, __v_39, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = { let __values: [G; 4] = [__v_8, __v_43, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_18, __v_42, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_18, __v_25, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_18, __v_46, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_18, __v_22, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_18, __v_48, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_18, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_18, __v_32, __v_33, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_18, __v_51, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_18, __v_50, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = G::from_u64(43); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_54]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __v_56: G = { let __values: [G; 4] = [__v_8, __v_55, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = { let __values: [G; 4] = [__v_18, __v_56, __v_33, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_58: G = { let __values: [G; 4] = [__v_18, __v_57, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_59: G = { let __values: [G; 4] = [__v_18, __v_32, __v_58, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_60: G = { let __values: [G; 4] = [__v_18, __v_59, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_61: G = { let __values: [G; 4] = [__v_18, __v_53, __v_60, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_62: G = { let __values: [G; 4] = [__v_35, __v_49, __v_61, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_63: G = { let __values: [G; 4] = [__v_35, __v_40, __v_62, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_64: G = { let __values: [G; 4] = [__v_35, __v_11, __v_63, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_65: G = { let __values: [G; 4] = [__v_35, __v_11, __v_64, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_562] = [__v_65]; record.function_queries[562].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3137u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(5); let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_8, __v_23, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_21, __v_17, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_8, __v_27, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_21, __v_28, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_21, __v_30, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_21, __v_25, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = { let __values: [G; 4] = [__v_8, __v_33, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_21, __v_32, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_21, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 4] = [__v_8, __v_38, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_21, __v_39, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_21, __v_40, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_21, __v_36, __v_41, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_21, __v_42, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_20, __v_35, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_20, __v_11, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_20, __v_11, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_562] = [__v_46]; record.function_queries[562].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3138u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(5); let __v_20: G = G::from_u64(3); let __v_21: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_20, __v_17, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_20, __v_29, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_20, __v_27, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_20, __v_33, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_20, __v_24, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = { let __values: [G; 4] = [__v_8, __v_37, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_20, __v_36, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_20, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = { let __values: [G; 4] = [__v_8, __v_42, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_20, __v_43, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_20, __v_44, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_20, __v_40, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_20, __v_47, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_19, __v_39, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_19, __v_11, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_19, __v_11, __v_50, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_562] = [__v_51]; record.function_queries[562].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3200u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(50); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(5); let __v_24: G = G::from_u64(3); let __v_25: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_24, __v_17, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 4] = [__v_8, __v_32, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_8, __v_34, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_24, __v_33, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_24, __v_31, __v_36, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_24, __v_37, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_24, __v_28, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_24, __v_39, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_24, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_24, __v_21, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_24, __v_45, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_24, __v_44, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = { let __values: [G; 4] = [__v_8, __v_49, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_24, __v_50, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_24, __v_51, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_24, __v_21, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_24, __v_53, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_24, __v_47, __v_54, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_56: G = { let __values: [G; 4] = [__v_23, __v_43, __v_55, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = { let __values: [G; 4] = [__v_23, __v_11, __v_56, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_58: G = { let __values: [G; 4] = [__v_23, __v_11, __v_57, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_562] = [__v_58]; record.function_queries[562].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3201u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(5); let __v_20: G = G::from_u64(3); let __v_21: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_20, __v_17, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_20, __v_29, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_20, __v_27, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_20, __v_33, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_20, __v_24, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 4] = [__v_8, __v_36, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_20, __v_35, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_20, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(50); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_20, __v_42, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_20, __v_44, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_20, __v_39, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_20, __v_46, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_19, __v_38, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_19, __v_11, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_19, __v_11, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_562] = [__v_50]; record.function_queries[562].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3264u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(3); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_8, __v_21, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_20, __v_19, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(51); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_20, __v_19, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = G::from_u64(48); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_8, __v_34, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = { let __values: [G; 4] = [__v_8, __v_37, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = G::from_u64(5); let __v_40: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_20, __v_17, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __v_46: G = { let __values: [G; 4] = [__v_8, __v_45, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_20, __v_46, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_20, __v_47, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_20, __v_43, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = { let __values: [G; 4] = [__v_8, __v_51, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_20, __v_49, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_20, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_20, __v_27, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_56: G = { let __values: [G; 4] = [__v_20, __v_55, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = { let __values: [G; 4] = [__v_20, __v_54, __v_56, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_58: G = G::from_u64(42); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __v_60: G = { let __values: [G; 4] = [__v_8, __v_59, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_61: G = { let __values: [G; 4] = [__v_20, __v_31, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_62: G = { let __values: [G; 4] = [__v_20, __v_35, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_63: G = { let __values: [G; 4] = [__v_20, __v_62, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_64: G = { let __values: [G; 4] = [__v_20, __v_27, __v_63, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_65: G = { let __values: [G; 4] = [__v_20, __v_35, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_66: G = { let __values: [G; 4] = [__v_20, __v_65, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_67: G = { let __values: [G; 4] = [__v_20, __v_64, __v_66, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_68: G = { let __values: [G; 4] = [__v_20, __v_61, __v_67, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_69: G = { let __values: [G; 4] = [__v_20, __v_60, __v_68, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_70: G = { let __values: [G; 4] = [__v_20, __v_38, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_71: G = { let __values: [G; 4] = [__v_20, __v_70, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_72: G = { let __values: [G; 4] = [__v_20, __v_31, __v_71, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_73: G = { let __values: [G; 4] = [__v_20, __v_38, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_74: G = { let __values: [G; 4] = [__v_20, __v_73, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_75: G = { let __values: [G; 4] = [__v_20, __v_72, __v_74, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_76: G = { let __values: [G; 4] = [__v_20, __v_69, __v_75, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_77: G = { let __values: [G; 4] = [__v_20, __v_57, __v_76, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_78: G = { let __values: [G; 4] = [__v_39, __v_53, __v_77, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_79: G = { let __values: [G; 4] = [__v_39, __v_11, __v_78, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_80: G = { let __values: [G; 4] = [__v_39, __v_11, __v_79, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_562] = [__v_80]; record.function_queries[562].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3265u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = G::from_u64(5); let __v_22: G = G::from_u64(3); let __v_23: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_22, __v_17, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_22, __v_31, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_22, __v_29, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_22, __v_33, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_22, __v_26, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 4] = [__v_8, __v_36, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_22, __v_35, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_22, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(51); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_22, __v_42, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_22, __v_44, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_22, __v_39, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_22, __v_46, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_21, __v_38, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_21, __v_11, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_21, __v_11, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_562] = [__v_50]; record.function_queries[562].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3328u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(3); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_8, __v_21, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_20, __v_19, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(52); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(42); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = { let __values: [G; 4] = [__v_8, __v_33, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_20, __v_19, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = G::from_u64(48); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = { let __values: [G; 4] = [__v_8, __v_37, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = { let __values: [G; 4] = [__v_8, __v_40, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_20, __v_41, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_20, __v_42, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_20, __v_41, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_20, __v_44, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = G::from_u64(5); let __v_47: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = { let __values: [G; 4] = [__v_8, __v_48, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_20, __v_17, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __v_53: G = { let __values: [G; 4] = [__v_8, __v_52, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_20, __v_53, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_20, __v_54, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_56: G = { let __values: [G; 4] = [__v_20, __v_50, __v_55, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __v_59: G = { let __values: [G; 4] = [__v_8, __v_58, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_60: G = { let __values: [G; 4] = [__v_20, __v_56, __v_59, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_61: G = { let __values: [G; 4] = [__v_20, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_62: G = { let __values: [G; 4] = [__v_20, __v_27, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_63: G = { let __values: [G; 4] = [__v_20, __v_62, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_64: G = { let __values: [G; 4] = [__v_20, __v_61, __v_63, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_65: G = { let __values: [G; 4] = [__v_20, __v_34, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_66: G = { let __values: [G; 4] = [__v_20, __v_38, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_67: G = { let __values: [G; 4] = [__v_20, __v_66, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_68: G = { let __values: [G; 4] = [__v_20, __v_27, __v_67, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_69: G = { let __values: [G; 4] = [__v_20, __v_38, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_70: G = { let __values: [G; 4] = [__v_20, __v_69, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_71: G = { let __values: [G; 4] = [__v_20, __v_68, __v_70, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_72: G = { let __values: [G; 4] = [__v_20, __v_65, __v_71, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_73: G = { let __values: [G; 4] = [__v_20, __v_31, __v_72, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_74: G = G::from_u64(43); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_74]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __v_76: G = { let __values: [G; 4] = [__v_8, __v_75, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_77: G = { let __values: [G; 4] = [__v_20, __v_31, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_78: G = { let __values: [G; 4] = [__v_20, __v_77, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_79: G = { let __values: [G; 4] = [__v_20, __v_76, __v_78, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_80: G = { let __values: [G; 4] = [__v_20, __v_34, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_81: G = { let __values: [G; 4] = [__v_20, __v_80, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_82: G = { let __values: [G; 4] = [__v_20, __v_79, __v_81, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_83: G = { let __values: [G; 4] = [__v_20, __v_73, __v_82, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_84: G = { let __values: [G; 4] = [__v_20, __v_64, __v_83, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_85: G = { let __values: [G; 4] = [__v_46, __v_60, __v_84, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_86: G = { let __values: [G; 4] = [__v_46, __v_11, __v_85, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_87: G = { let __values: [G; 4] = [__v_46, __v_11, __v_86, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_562] = [__v_87]; record.function_queries[562].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3329u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(5); let __v_20: G = G::from_u64(3); let __v_21: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_20, __v_17, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_20, __v_29, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_20, __v_27, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_20, __v_33, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_20, __v_24, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 4] = [__v_8, __v_36, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_20, __v_35, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_20, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(52); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_20, __v_42, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_20, __v_44, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_20, __v_39, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_20, __v_46, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_19, __v_38, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_19, __v_11, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_19, __v_11, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_562] = [__v_50]; record.function_queries[562].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3392u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(3); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_8, __v_21, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_20, __v_19, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(53); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(42); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_20, __v_19, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = G::from_u64(48); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_8, __v_34, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = { let __values: [G; 4] = [__v_8, __v_37, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = G::from_u64(5); let __v_40: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_20, __v_17, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __v_46: G = { let __values: [G; 4] = [__v_8, __v_45, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_20, __v_46, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_20, __v_47, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_20, __v_43, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = { let __values: [G; 4] = [__v_8, __v_51, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_20, __v_49, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_20, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_20, __v_27, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_56: G = { let __values: [G; 4] = [__v_20, __v_55, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = { let __values: [G; 4] = [__v_20, __v_54, __v_56, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_58: G = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; let __v_60: G = { let __values: [G; 4] = [__v_8, __v_59, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_61: G = { let __values: [G; 4] = [__v_20, __v_60, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_62: G = { let __values: [G; 4] = [__v_20, __v_35, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_63: G = { let __values: [G; 4] = [__v_20, __v_62, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_64: G = { let __values: [G; 4] = [__v_20, __v_27, __v_63, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_65: G = { let __values: [G; 4] = [__v_20, __v_35, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_66: G = { let __values: [G; 4] = [__v_20, __v_65, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_67: G = { let __values: [G; 4] = [__v_20, __v_64, __v_66, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_68: G = { let __values: [G; 4] = [__v_20, __v_61, __v_67, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_69: G = { let __values: [G; 4] = [__v_20, __v_31, __v_68, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_70: G = { let __values: [G; 4] = [__v_20, __v_38, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_71: G = { let __values: [G; 4] = [__v_20, __v_70, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_72: G = { let __values: [G; 4] = [__v_20, __v_31, __v_71, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_73: G = { let __values: [G; 4] = [__v_20, __v_38, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_74: G = { let __values: [G; 4] = [__v_20, __v_73, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_75: G = { let __values: [G; 4] = [__v_20, __v_72, __v_74, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_76: G = { let __values: [G; 4] = [__v_20, __v_38, __v_75, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_77: G = { let __values: [G; 4] = [__v_20, __v_76, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_78: G = { let __values: [G; 4] = [__v_20, __v_69, __v_77, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_79: G = { let __values: [G; 4] = [__v_20, __v_57, __v_78, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_80: G = { let __values: [G; 4] = [__v_39, __v_53, __v_79, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_81: G = { let __values: [G; 4] = [__v_39, __v_11, __v_80, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_82: G = { let __values: [G; 4] = [__v_39, __v_11, __v_81, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_562] = [__v_82]; record.function_queries[562].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3393u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(5); let __v_20: G = G::from_u64(3); let __v_21: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_20, __v_17, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_20, __v_29, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_20, __v_27, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_20, __v_33, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_20, __v_24, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 4] = [__v_8, __v_36, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_20, __v_35, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_20, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(53); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_20, __v_42, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_20, __v_44, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_20, __v_39, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_20, __v_46, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_19, __v_38, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_19, __v_11, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_19, __v_11, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_562] = [__v_50]; record.function_queries[562].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3456u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(3); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_8, __v_21, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_20, __v_19, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(54); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_8, __v_25, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(5); let __v_30: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_8, __v_31, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_20, __v_17, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_8, __v_35, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_20, __v_36, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_20, __v_37, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_20, __v_33, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = { let __values: [G; 4] = [__v_8, __v_42, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_20, __v_40, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_20, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_20, __v_26, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_20, __v_46, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_20, __v_45, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = { let __values: [G; 4] = [__v_8, __v_50, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_20, __v_19, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_20, __v_51, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_20, __v_53, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_20, __v_26, __v_54, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_56: G = G::from_u64(43); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_56]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = { let __values: [G; 4] = [__v_8, __v_57, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_59: G = { let __values: [G; 4] = [__v_20, __v_58, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_60: G = { let __values: [G; 4] = [__v_20, __v_59, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_61: G = { let __values: [G; 4] = [__v_20, __v_55, __v_60, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_62: G = { let __values: [G; 4] = [__v_20, __v_48, __v_61, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_63: G = { let __values: [G; 4] = [__v_29, __v_44, __v_62, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_64: G = { let __values: [G; 4] = [__v_29, __v_11, __v_63, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_65: G = { let __values: [G; 4] = [__v_29, __v_11, __v_64, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_562] = [__v_65]; record.function_queries[562].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3457u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(5); let __v_20: G = G::from_u64(3); let __v_21: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_20, __v_17, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_20, __v_29, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_20, __v_27, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_20, __v_33, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_20, __v_24, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = { let __values: [G; 4] = [__v_8, __v_37, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_20, __v_36, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_20, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = G::from_u64(54); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = { let __values: [G; 4] = [__v_8, __v_42, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_20, __v_43, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_20, __v_44, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_20, __v_40, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_20, __v_47, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_19, __v_39, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_19, __v_11, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_19, __v_11, __v_50, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_562] = [__v_51]; record.function_queries[562].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3520u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(3); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_8, __v_21, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_20, __v_19, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(55); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_8, __v_25, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_20, __v_26, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(5); let __v_31: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 4] = [__v_8, __v_32, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_20, __v_17, __v_33, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 4] = [__v_8, __v_36, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_20, __v_37, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_20, __v_38, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_20, __v_34, __v_40, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = { let __values: [G; 4] = [__v_8, __v_43, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_20, __v_41, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_20, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_20, __v_28, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_20, __v_46, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = G::from_u64(48); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = { let __values: [G; 4] = [__v_8, __v_50, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = G::from_u64(43); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = { let __values: [G; 4] = [__v_8, __v_53, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_20, __v_54, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_56: G = { let __values: [G; 4] = [__v_20, __v_55, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = { let __values: [G; 4] = [__v_20, __v_28, __v_56, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_58: G = { let __values: [G; 4] = [__v_20, __v_51, __v_57, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_59: G = { let __values: [G; 4] = [__v_20, __v_19, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_60: G = { let __values: [G; 4] = [__v_20, __v_58, __v_59, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_61: G = { let __values: [G; 4] = [__v_20, __v_48, __v_60, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_62: G = { let __values: [G; 4] = [__v_30, __v_45, __v_61, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_63: G = { let __values: [G; 4] = [__v_30, __v_11, __v_62, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_64: G = { let __values: [G; 4] = [__v_30, __v_11, __v_63, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_562] = [__v_64]; record.function_queries[562].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3521u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(5); let __v_20: G = G::from_u64(3); let __v_21: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_20, __v_17, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_20, __v_29, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_20, __v_27, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_20, __v_33, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_20, __v_24, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = { let __values: [G; 4] = [__v_8, __v_37, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_20, __v_36, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_20, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = G::from_u64(55); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = { let __values: [G; 4] = [__v_8, __v_42, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_20, __v_43, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_20, __v_44, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_20, __v_40, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_20, __v_47, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_19, __v_39, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_19, __v_11, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_19, __v_11, __v_50, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_562] = [__v_51]; record.function_queries[562].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_6, __v_8, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_562] = [__v_9]; record.function_queries[562].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_563: usize = 1; -const IN_563: usize = 1; -const OUT_563: usize = 1; -fn aiur_fn_563(inp: [G; IN_563], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_563], ExecError> { 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() { 65u64 => { let __v_1: G = G::from_u64(3); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 67u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 68u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 69u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 73u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 74u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 75u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 76u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 77u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 78u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 79u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 80u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 81u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 82u64 => { let __v_1: G = G::from_u64(3); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 85u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 86u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 87u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 90u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 91u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 92u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 93u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 95u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 96u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 97u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 98u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 99u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 100u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 101u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 102u64 => { let __v_1: G = G::from_u64(3); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_563] = [__v_1]; record.function_queries[563].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_564: usize = 2; -const IN_564: usize = 2; -const OUT_564: usize = 1; -fn aiur_fn_564(inp: [G; IN_564], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_564], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(64); let __v_3: G = __v_2 * __v_0; let __v_4: G = __v_3 + __v_1; match __v_4.as_canonical_u64() { 4162u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_564] = [__v_5]; record.function_queries[564].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4736u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_564] = [__v_5]; record.function_queries[564].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4737u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_564] = [__v_5]; record.function_queries[564].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5249u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_564] = [__v_5]; record.function_queries[564].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5250u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_564] = [__v_5]; record.function_queries[564].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6400u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_564] = [__v_5]; record.function_queries[564].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6401u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_564] = [__v_5]; record.function_queries[564].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6402u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_564] = [__v_5]; record.function_queries[564].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6403u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_564] = [__v_5]; record.function_queries[564].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6404u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_564] = [__v_5]; record.function_queries[564].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_564] = [__v_5]; record.function_queries[564].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_565: usize = 3; -const IN_565: usize = 3; -const OUT_565: usize = 1; -fn aiur_fn_565(inp: [G; IN_565], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_565], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(64); let __v_4: G = __v_3 * __v_1; let __v_5: G = __v_4 + __v_2; match __v_5.as_canonical_u64() { 4160u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 4] = [__v_6, __v_8, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_12: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_12, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_15: G = G::from_u64(2); let __v_16: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_15, __v_17, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_14, __v_18, __v_10, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(60); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_15, __v_21, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_14, __v_22, __v_10, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_14, __v_23, __v_7, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_14, __v_19, __v_24, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_11, __v_7, __v_25, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_11, __v_13, __v_26, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_27]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4161u64 => { 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(1).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 = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = { let __values: [G; 4] = [__v_8, __v_6, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_12: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_6, __v_12, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_15: G = G::from_u64(2); let __v_16: G = G::from_u64(62); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_15, __v_17, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_14, __v_18, __v_9, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_15, __v_21, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_14, __v_22, __v_10, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(61); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_15, __v_25, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_14, __v_26, __v_10, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_14, __v_27, __v_9, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_14, __v_23, __v_28, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_11, __v_19, __v_29, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_11, __v_13, __v_30, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_31]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4288u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_22, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_20, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_15, __v_24, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_15, __v_25, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_15, __v_26, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_15, __v_18, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(67); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_15, __v_31, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_15, __v_32, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_15, __v_28, __v_33, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_14, __v_11, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_14, __v_11, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_36]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4352u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(66); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_15, __v_21, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_15, __v_22, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_15, __v_18, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(68); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_15, __v_27, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_15, __v_28, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_15, __v_24, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_14, __v_11, __v_30, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_14, __v_11, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_32]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4416u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(69); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_13, __v_18, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_12, __v_11, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_11, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_22]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4672u64 => { 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(1).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 = G::from_u64(3); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(73); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_9, __v_11, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_9, __v_14, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_15, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_16]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4673u64 => { 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(1).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 = G::from_u64(4); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_9, __v_11, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_14: G = G::from_u64(73); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_9, __v_15, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_9, __v_17, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_13, __v_18, __v_19, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_16, __v_20, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_8, __v_12, __v_21, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_22]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4800u64 => { 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(1).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 = G::from_u64(4); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_9, __v_11, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_14: G = G::from_u64(75); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_9, __v_15, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_9, __v_18, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_16, __v_21, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_8, __v_12, __v_22, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_23]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4801u64 => { 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(1).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 = G::from_u64(4); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_9, __v_11, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_14: G = G::from_u64(75); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_9, __v_15, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_9, __v_18, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_16, __v_21, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_8, __v_12, __v_22, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_23]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4864u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(76); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_16, __v_14, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_16, __v_19, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_16, __v_14, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_16, __v_22, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_15, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_15, __v_11, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_27]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4865u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(76); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_16, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_13, __v_25, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_13, __v_22, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_12, __v_11, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_12, __v_11, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_30]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4866u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(76); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_16, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_13, __v_25, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_13, __v_22, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_12, __v_11, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_12, __v_11, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_30]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4867u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(76); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_16, __v_14, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_16, __v_19, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_16, __v_14, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_16, __v_22, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_15, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_15, __v_11, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_27]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4928u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(77); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 4] = [__v_8, __v_16, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_11, __v_6, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_14, __v_17, __v_18, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_14, __v_19, __v_20, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_12, __v_21, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_13, __v_12, __v_22, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_23]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4992u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(78); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_16, __v_14, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_16, __v_19, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_16, __v_14, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_16, __v_22, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_15, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_15, __v_11, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_27]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4993u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(78); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_16, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_13, __v_25, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_13, __v_22, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_12, __v_11, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_12, __v_11, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_30]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4994u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(78); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_16, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_13, __v_25, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_13, __v_22, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_12, __v_11, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_12, __v_11, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_30]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4995u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(78); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_16, __v_14, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_16, __v_19, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_16, __v_14, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_16, __v_22, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_15, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_15, __v_11, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_27]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5056u64 => { 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(1).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 = G::from_u64(4); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_9, __v_11, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_14: G = G::from_u64(79); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_9, __v_15, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_9, __v_18, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_16, __v_21, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_8, __v_12, __v_22, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_23]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5057u64 => { 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(1).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 = G::from_u64(4); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_9, __v_11, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_14: G = G::from_u64(79); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_9, __v_15, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_9, __v_18, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_16, __v_21, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_8, __v_12, __v_22, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_23]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5120u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(80); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_16, __v_14, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_16, __v_19, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_16, __v_14, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_16, __v_22, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_15, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_15, __v_11, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_27]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5121u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(80); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_16, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_13, __v_25, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_13, __v_22, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_12, __v_11, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_12, __v_11, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_30]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5122u64 => { 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(1).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 = G::from_u64(4); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_9, __v_11, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_14: G = G::from_u64(80); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_9, __v_15, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_9, __v_18, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_16, __v_21, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_9, __v_24, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_9, __v_26, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_13, __v_25, __v_27, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_13, __v_22, __v_28, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_8, __v_12, __v_29, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_30]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5123u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(80); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_16, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_13, __v_27, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_13, __v_25, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_13, __v_22, __v_30, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_12, __v_11, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_12, __v_11, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_33]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5124u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(80); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_16, __v_14, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_16, __v_19, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_16, __v_14, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_16, __v_22, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_15, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_15, __v_11, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_27]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5184u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(81); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_16, __v_14, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_16, __v_19, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_16, __v_14, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_16, __v_22, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_15, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_15, __v_11, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_27]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5185u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(81); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_16, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_13, __v_25, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_13, __v_22, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_12, __v_11, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_12, __v_11, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_30]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5186u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(81); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_16, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_13, __v_25, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_13, __v_22, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_12, __v_11, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_12, __v_11, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_30]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5187u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(81); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_16, __v_14, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_16, __v_19, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_16, __v_14, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_16, __v_22, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_15, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_15, __v_11, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_27]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5248u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(82); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_16, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_13, __v_22, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_12, __v_11, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_12, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_26]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5440u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(85); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 4] = [__v_8, __v_16, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_14, __v_17, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(84); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_14, __v_21, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_14, __v_22, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_14, __v_18, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_13, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_13, __v_11, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_27]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5504u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_14: G = G::from_u64(84); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_19: G = G::from_u64(86); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_21, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_13, __v_17, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_13, __v_22, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_13, __v_17, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_13, __v_25, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_18, __v_11, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_18, __v_11, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_18, __v_11, __v_30, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_31]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5568u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(37); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_21, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_22, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_20, __v_23, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_15, __v_24, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_15, __v_25, __v_13, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_15, __v_26, __v_13, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_15, __v_18, __v_27, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(87); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_15, __v_31, __v_13, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_15, __v_32, __v_13, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_15, __v_28, __v_33, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_14, __v_12, __v_34, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_35]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5760u64 => { 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(1).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 = G::from_u64(3); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(90); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_9, __v_11, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(38); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_9, __v_15, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(30); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 3] = [__v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_12, __v_19, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_9, __v_18, __v_20, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_9, __v_23, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_8, __v_21, __v_24, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_8, __v_16, __v_25, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_8, __v_13, __v_26, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_27]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5824u64 => { let __v_6: G = G::from_u64(4); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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 = 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(1).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_7, __v_8, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_9, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_9, __v_14, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_17: G = G::from_u64(2); let __v_18: G = G::from_u64(29); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_17, __v_19, __v_11, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_16, __v_20, __v_12, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(91); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_17, __v_23, __v_11, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_16, __v_24, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(30); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_17, __v_27, __v_11, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_16, __v_28, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_16, __v_25, __v_29, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_16, __v_30, __v_12, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_6, __v_21, __v_31, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_6, __v_15, __v_32, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_33]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5825u64 => { let __v_6: G = G::from_u64(4); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_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(1).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_7, __v_8, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(2); let __v_14: G = G::from_u64(29); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_13, __v_15, __v_12, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_10, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_13, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(3); let __v_20: G = { let __values: [G; 4] = [__v_7, __v_19, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 3] = [__v_10, __v_8, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_10, __v_21, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_19, __v_16, __v_17, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_19, __v_16, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(91); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_13, __v_26, __v_12, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_19, __v_27, __v_20, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(31); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_13, __v_30, __v_12, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_19, __v_31, __v_20, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_19, __v_32, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_19, __v_33, __v_17, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_19, __v_28, __v_34, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_19, __v_35, __v_9, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_6, __v_24, __v_36, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_6, __v_23, __v_37, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_6, __v_9, __v_38, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_6, __v_22, __v_39, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_40]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5888u64 => { 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(1).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 = G::from_u64(3); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(29); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_12, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_9, __v_11, __v_14, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_9, __v_17, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_8, __v_15, __v_18, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(38); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_9, __v_21, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(4); let __v_24: G = G::from_u64(92); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_9, __v_25, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_12, __v_6, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_8, __v_22, __v_27, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_8, __v_26, __v_28, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_8, __v_22, __v_30, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_8, __v_29, __v_31, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_23, __v_19, __v_32, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_23, __v_19, __v_33, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_34]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5952u64 => { let __v_6: G = G::from_u64(4); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = G::from_u64(2); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_10, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_12, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(1); let __v_15: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_14, __v_8, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_14, __v_17, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(93); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 3] = [__v_7, __v_8, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_10, __v_20, __v_21, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_7, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_12, __v_22, __v_23, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_12, __v_24, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(60); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_10, __v_27, __v_15, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_12, __v_28, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_12, __v_29, __v_11, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_12, __v_25, __v_30, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_7, __v_14, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_12, __v_31, __v_32, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_12, __v_33, __v_9, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_6, __v_13, __v_34, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_6, __v_11, __v_35, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_6, __v_9, __v_36, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_6, __v_18, __v_37, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_6, __v_16, __v_38, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_39]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5953u64 => { let __v_6: G = G::from_u64(4); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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 = 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(1).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; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(2); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_12, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_15: G = { let __values: [G; 4] = [__v_7, __v_14, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_9, __v_17, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(62); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_12, __v_20, __v_10, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_14, __v_21, __v_11, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(93); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 3] = [__v_7, __v_8, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_12, __v_24, __v_25, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_7, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_14, __v_26, __v_27, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_14, __v_28, __v_15, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(61); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_12, __v_31, __v_10, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_14, __v_32, __v_15, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_14, __v_33, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_14, __v_29, __v_34, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_7, __v_9, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_14, __v_35, __v_36, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_14, __v_37, __v_11, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_6, __v_15, __v_38, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_6, __v_13, __v_39, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_6, __v_22, __v_40, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_6, __v_18, __v_41, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_6, __v_16, __v_42, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_43]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6080u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_16: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_15, __v_14, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_15, __v_14, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(4); let __v_21: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_27, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_25, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_8, __v_31, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_15, __v_29, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_15, __v_33, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_15, __v_34, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_15, __v_23, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(95); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 4] = [__v_8, __v_38, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_15, __v_39, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_15, __v_40, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_15, __v_36, __v_41, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_20, __v_11, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_20, __v_11, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_44]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6081u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_13: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_15, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_20, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(4); let __v_24: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_8, __v_25, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_30, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_28, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_8, __v_34, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_12, __v_32, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_12, __v_36, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_12, __v_37, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_12, __v_26, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(95); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_12, __v_42, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_12, __v_43, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_12, __v_39, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_23, __v_11, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_23, __v_11, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_47]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6082u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_13: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_15, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_20, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(4); let __v_24: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_8, __v_25, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_30, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_28, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_8, __v_34, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_12, __v_32, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_12, __v_36, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_12, __v_37, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_12, __v_26, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(95); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_12, __v_42, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_12, __v_43, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_12, __v_39, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_23, __v_11, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_23, __v_11, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_47]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6083u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_16: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_15, __v_14, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_15, __v_14, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(4); let __v_21: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_27, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_25, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_8, __v_31, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_15, __v_29, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_15, __v_33, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_15, __v_34, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_15, __v_23, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(95); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 4] = [__v_8, __v_38, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_15, __v_39, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_15, __v_40, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_15, __v_36, __v_41, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_20, __v_11, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_20, __v_11, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_44]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6144u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_16: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_15, __v_14, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_15, __v_14, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(4); let __v_21: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(94); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_8, __v_25, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_15, __v_26, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_15, __v_27, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_15, __v_23, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(96); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_8, __v_31, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_15, __v_32, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_15, __v_33, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_15, __v_29, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_20, __v_11, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_20, __v_11, __v_36, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_37]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6145u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_13: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_15, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_20, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(4); let __v_24: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_8, __v_25, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = G::from_u64(94); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_12, __v_29, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_12, __v_30, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_12, __v_26, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = G::from_u64(96); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_8, __v_34, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_12, __v_35, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_12, __v_36, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_12, __v_32, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_23, __v_11, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_23, __v_11, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_40]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6146u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_13: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_15, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_20, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(4); let __v_24: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_8, __v_25, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = G::from_u64(94); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_12, __v_29, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_12, __v_30, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_12, __v_26, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = G::from_u64(96); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_8, __v_34, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_12, __v_35, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_12, __v_36, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_12, __v_32, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_23, __v_11, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_23, __v_11, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_40]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6147u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_16: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_15, __v_14, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_15, __v_14, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(4); let __v_21: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(94); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_8, __v_25, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_15, __v_26, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_15, __v_27, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_15, __v_23, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(96); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_8, __v_31, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_15, __v_32, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_15, __v_33, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_15, __v_29, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_20, __v_11, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_20, __v_11, __v_36, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_37]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6208u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(97); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 4] = [__v_8, __v_16, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_11, __v_6, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_14, __v_17, __v_18, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_14, __v_19, __v_20, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_12, __v_21, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_13, __v_12, __v_22, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_23]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6272u64 => { 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(1).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 = G::from_u64(4); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_9, __v_11, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_9, __v_14, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_17: G = G::from_u64(98); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_9, __v_18, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_12, __v_6, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_16, __v_19, __v_20, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_16, __v_21, __v_22, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_8, __v_15, __v_23, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_8, __v_13, __v_24, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_25]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6336u64 => { 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(1).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 = G::from_u64(4); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_9, __v_11, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_9, __v_14, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_17: G = G::from_u64(99); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_9, __v_18, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_12, __v_6, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_16, __v_19, __v_20, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_16, __v_21, __v_22, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_8, __v_15, __v_23, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_8, __v_13, __v_24, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_25]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6464u64 => { 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(1).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 = G::from_u64(3); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(101); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_9, __v_11, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(38); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_9, __v_15, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(30); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 3] = [__v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_12, __v_19, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_9, __v_18, __v_20, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_9, __v_23, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_8, __v_21, __v_24, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_8, __v_16, __v_25, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_8, __v_13, __v_26, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_27]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6465u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(4); let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(29); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_14, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_16, __v_19, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = G::from_u64(101); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(38); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_8, __v_25, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = G::from_u64(31); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_14, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_16, __v_29, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_11, __v_6, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_16, __v_30, __v_31, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_16, __v_32, __v_33, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_16, __v_26, __v_34, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_16, __v_23, __v_35, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_15, __v_20, __v_36, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_15, __v_12, __v_37, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_38]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6528u64 => { 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(1).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 = G::from_u64(3); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(102); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_9, __v_11, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(38); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_9, __v_15, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(30); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 3] = [__v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_12, __v_19, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_9, __v_18, __v_20, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_9, __v_23, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_8, __v_21, __v_24, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_8, __v_16, __v_25, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_8, __v_13, __v_26, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_27]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6529u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(4); let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(102); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(38); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_8, __v_21, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(31); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_14, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_16, __v_25, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_16, __v_26, __v_27, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(30); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_14, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_16, __v_31, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_16, __v_28, __v_32, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_16, __v_22, __v_33, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_16, __v_19, __v_34, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_15, __v_12, __v_35, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_36]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6530u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(3); let __v_16: G = G::from_u64(31); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_14, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_15, __v_18, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(4); let __v_21: G = G::from_u64(29); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_14, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_15, __v_23, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(102); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = G::from_u64(38); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = { let __values: [G; 4] = [__v_8, __v_29, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_11, __v_8, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_15, __v_19, __v_31, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_11, __v_6, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_15, __v_19, __v_33, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_15, __v_34, __v_35, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_15, __v_32, __v_36, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_15, __v_30, __v_37, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_15, __v_27, __v_38, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_20, __v_24, __v_39, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_20, __v_12, __v_40, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_20, __v_12, __v_41, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_42]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_6, __v_8, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_565] = [__v_9]; record.function_queries[565].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_566: usize = 3; -const IN_566: usize = 3; -const OUT_566: usize = 1; -fn aiur_fn_566(inp: [G; IN_566], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_566], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(64); let __v_4: G = __v_3 * __v_1; let __v_5: G = __v_4 + __v_2; match __v_5.as_canonical_u64() { 4160u64 => { let __v_6: G = G::from_u64(4); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 4] = [__v_7, __v_9, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(2); let __v_13: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_12, __v_14, __v_15, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_6, __v_11, __v_16, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_6, __v_10, __v_17, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_18]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4161u64 => { 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(1).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 = G::from_u64(4); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_6, __v_10, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_13: G = G::from_u64(2); let __v_14: G = G::from_u64(62); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_13, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_16, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(5); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_13, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_8, __v_18, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_8, __v_11, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_23]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4288u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(46); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_13, __v_18, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_12, __v_11, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_11, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_22]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4352u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_13, __v_18, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_12, __v_11, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_11, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_22]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4416u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(68); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_13, __v_18, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_16, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_13, __v_21, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_12, __v_11, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_12, __v_11, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_25]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4672u64 => { 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(1).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 = G::from_u64(3); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_9, __v_11, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_9, __v_14, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_15, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_16]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4673u64 => { 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(1).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 = G::from_u64(4); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_9, __v_11, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_14: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_9, __v_15, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_8, __v_12, __v_18, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_19]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4800u64 => { 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(1).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 = G::from_u64(4); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_9, __v_11, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_14: G = G::from_u64(73); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_9, __v_15, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_8, __v_12, __v_18, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_19]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4801u64 => { 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(1).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 = G::from_u64(4); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_9, __v_11, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_14: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_9, __v_15, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_9, __v_17, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_13, __v_18, __v_19, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_16, __v_20, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_8, __v_12, __v_21, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_22]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4864u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(42); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_13, __v_21, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_13, __v_16, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_12, __v_11, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_12, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_26]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4865u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(74); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_20, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_13, __v_18, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_12, __v_11, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_12, __v_11, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_25]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4866u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(74); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_13, __v_20, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_13, __v_18, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_12, __v_11, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_12, __v_11, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_25]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4867u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(42); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_13, __v_21, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_13, __v_23, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_13, __v_18, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_13, __v_16, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_12, __v_11, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_12, __v_11, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_29]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4928u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(76); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 4] = [__v_8, __v_16, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_11, __v_6, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_14, __v_17, __v_18, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(75); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_8, __v_21, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_14, __v_22, __v_23, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_14, __v_19, __v_24, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_13, __v_12, __v_25, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_13, __v_12, __v_26, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_27]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4992u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_13, __v_21, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_13, __v_16, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_12, __v_11, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_12, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_26]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4993u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(73); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_13, __v_23, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_13, __v_21, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_13, __v_16, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_12, __v_11, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_12, __v_11, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_29]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4994u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(73); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_13, __v_21, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_13, __v_19, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_13, __v_24, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_13, __v_16, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_12, __v_11, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_12, __v_11, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_29]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4995u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_8, __v_12, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_15, __v_13, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_15, __v_21, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_15, __v_13, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_15, __v_24, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_15, __v_18, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_14, __v_11, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_14, __v_11, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_30]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5056u64 => { let __v_6: G = G::from_u64(4); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; 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(1).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; 4] = [__v_7, __v_9, __v_11, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_6, __v_12, __v_13, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_14]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5057u64 => { 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(1).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 = G::from_u64(4); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_9, __v_11, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_9, __v_14, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_15, __v_16, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_17, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_18]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5120u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(48); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_13, __v_21, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_13, __v_16, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_12, __v_11, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_12, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_26]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5121u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(75); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(48); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_8, __v_21, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_13, __v_22, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_8, __v_25, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_13, __v_26, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_13, __v_24, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_13, __v_19, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_13, __v_16, __v_30, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_12, __v_11, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_12, __v_11, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_33]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5122u64 => { 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(1).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 = G::from_u64(4); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_9, __v_11, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_14: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_9, __v_15, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_9, __v_17, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_13, __v_16, __v_18, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_8, __v_12, __v_19, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_20]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5123u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(48); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_13, __v_23, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_13, __v_21, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_13, __v_16, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_12, __v_11, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_12, __v_11, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_29]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5124u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_8, __v_12, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(48); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_15, __v_21, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_15, __v_13, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_15, __v_23, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_15, __v_13, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_15, __v_18, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_14, __v_11, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_14, __v_11, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_30]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5184u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_13, __v_21, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_13, __v_16, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_12, __v_11, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_12, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_26]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5185u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_13, __v_23, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_13, __v_21, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_13, __v_16, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_12, __v_11, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_12, __v_11, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_29]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5186u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(74); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 4] = [__v_8, __v_16, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_14, __v_17, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_14, __v_23, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_14, __v_25, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_14, __v_20, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_14, __v_18, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_13, __v_11, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_13, __v_11, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_30]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5187u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_8, __v_12, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_15: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_14, __v_13, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_18: G = G::from_u64(74); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_14, __v_20, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_8, __v_23, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_14, __v_24, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_14, __v_26, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_14, __v_13, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_14, __v_21, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_17, __v_11, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_17, __v_11, __v_30, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_31]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5248u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(45); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_13, __v_19, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_13, __v_21, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_13, __v_16, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_12, __v_11, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_12, __v_11, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_26]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5440u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_8, __v_12, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_15, __v_18, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = G::from_u64(45); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_15, __v_13, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_15, __v_13, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_15, __v_23, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_15, __v_28, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_15, __v_20, __v_30, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_14, __v_11, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_14, __v_11, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_33]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5504u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_8, __v_12, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_18: G = G::from_u64(45); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_8, __v_21, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_17, __v_13, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_17, __v_13, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_17, __v_20, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_17, __v_25, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = G::from_u64(4); let __v_29: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_17, __v_16, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_17, __v_33, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_17, __v_13, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_17, __v_31, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_17, __v_16, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_17, __v_38, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_17, __v_36, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_28, __v_11, __v_40, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_28, __v_11, __v_41, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_28, __v_11, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_43]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5568u64 => { 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(1).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 = G::from_u64(4); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(37); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_9, __v_11, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_9, __v_15, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_17]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5760u64 => { let __v_6: G = G::from_u64(2); let __v_7: G = G::from_u64(89); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; 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(1).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 = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_8, __v_10, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_12]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5824u64 => { let __v_6: G = G::from_u64(4); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_10, __v_11, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_14: G = G::from_u64(2); let __v_15: G = G::from_u64(29); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_7, __v_8, __v_17]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_14, __v_16, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_13, __v_19, __v_9, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_6, __v_20, __v_9, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_6, __v_12, __v_21, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_22]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5825u64 => { let __v_6: G = G::from_u64(4); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_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(1).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_7, __v_8, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(2); let __v_14: G = G::from_u64(29); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_13, __v_15, __v_12, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_10, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_13, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(3); let __v_20: G = { let __values: [G; 4] = [__v_7, __v_19, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 3] = [__v_10, __v_8, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_10, __v_21, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_19, __v_16, __v_17, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_19, __v_16, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(31); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_13, __v_26, __v_12, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_19, __v_27, __v_20, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_19, __v_28, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(91); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_13, __v_31, __v_12, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_19, __v_32, __v_20, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_19, __v_33, __v_17, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_19, __v_34, __v_9, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_19, __v_29, __v_35, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_6, __v_24, __v_36, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_6, __v_23, __v_37, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_6, __v_9, __v_38, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_6, __v_22, __v_39, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_40]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5888u64 => { 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(1).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 = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(2); let __v_12: G = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_11, __v_13, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_16: G = G::from_u64(29); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_11, __v_17, __v_10, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_15, __v_18, __v_14, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(4); let __v_21: G = G::from_u64(38); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_11, __v_22, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(91); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_11, __v_25, __v_10, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_15, __v_26, __v_14, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_8, __v_6, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_15, __v_27, __v_28, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_15, __v_29, __v_30, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_15, __v_23, __v_31, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_20, __v_19, __v_32, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_20, __v_19, __v_33, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_34]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5952u64 => { let __v_6: G = G::from_u64(4); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_6, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 4] = [__v_7, __v_9, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_7, __v_11, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(2); let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_17: G = { let __values: [G; 4] = [__v_8, __v_16, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_6, __v_17, __v_18, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_6, __v_15, __v_19, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_6, __v_13, __v_20, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_6, __v_12, __v_21, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_6, __v_10, __v_22, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_23]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5953u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(4); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_9, __v_10, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_9, __v_12, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_15: G = G::from_u64(2); let __v_16: G = G::from_u64(62); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_15, __v_17, __v_18, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_14, __v_19, __v_7, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_6, __v_15, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_6, __v_14, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_8, __v_21, __v_23, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_8, __v_20, __v_24, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_8, __v_13, __v_25, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_8, __v_11, __v_26, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_27]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6080u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(46); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_13, __v_18, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_12, __v_11, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_11, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_22]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6081u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(5); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_17]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6082u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(5); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_17]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6083u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(46); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_13, __v_18, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_12, __v_11, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_11, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_22]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6144u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_13, __v_18, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_12, __v_11, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_11, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_22]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6145u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(5); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_17]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6146u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_17]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6147u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_13, __v_18, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_12, __v_11, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_11, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_22]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6208u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(96); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 4] = [__v_8, __v_16, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(76); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_11, __v_6, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_14, __v_20, __v_21, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_14, __v_27, __v_29, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_14, __v_25, __v_30, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_14, __v_22, __v_31, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_14, __v_17, __v_32, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_14, __v_33, __v_34, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_13, __v_12, __v_35, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_13, __v_12, __v_36, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_37]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6272u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(76); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(3); let __v_20: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_20, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(81); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_8, __v_23, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_11, __v_6, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_19, __v_24, __v_25, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_19, __v_26, __v_21, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_19, __v_29, __v_31, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_19, __v_18, __v_32, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(80); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_8, __v_35, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_19, __v_15, __v_21, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_19, __v_37, __v_33, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_19, __v_36, __v_38, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_19, __v_29, __v_32, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_19, __v_18, __v_40, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_19, __v_39, __v_41, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = { let __values: [G; 4] = [__v_8, __v_44, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = G::from_u64(93); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = { let __values: [G; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_49: G = { let __values: [G; 3] = [__v_6, __v_48, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_50: G = { let __values: [G; 3] = [__v_11, __v_49, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_51: G = { let __values: [G; 4] = [__v_8, __v_47, __v_50, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_19, __v_51, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = G::from_u64(94); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = { let __values: [G; 4] = [__v_8, __v_54, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_56: G = { let __values: [G; 4] = [__v_19, __v_15, __v_27, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = { let __values: [G; 4] = [__v_19, __v_56, __v_33, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_58: G = { let __values: [G; 4] = [__v_19, __v_55, __v_57, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_59: G = { let __values: [G; 4] = [__v_19, __v_58, __v_42, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_60: G = { let __values: [G; 4] = [__v_19, __v_52, __v_59, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_61: G = G::from_u64(97); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_61]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_62: G = __r_arr[0]; let __v_63: G = { let __values: [G; 4] = [__v_8, __v_62, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_64: G = { let __values: [G; 4] = [__v_19, __v_63, __v_27, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_65: G = { let __values: [G; 4] = [__v_19, __v_64, __v_42, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_66: G = { let __values: [G; 4] = [__v_19, __v_60, __v_65, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_67: G = { let __values: [G; 4] = [__v_19, __v_66, __v_27, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_68: G = G::from_u64(77); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_68]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_69: G = __r_arr[0]; let __v_70: G = { let __values: [G; 4] = [__v_8, __v_69, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_71: G = { let __values: [G; 4] = [__v_19, __v_70, __v_27, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_72: G = { let __values: [G; 4] = [__v_19, __v_71, __v_21, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_73: G = { let __values: [G; 4] = [__v_19, __v_67, __v_72, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_74: G = { let __values: [G; 4] = [__v_43, __v_45, __v_73, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_75: G = { let __values: [G; 4] = [__v_43, __v_12, __v_74, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_75]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6336u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_15, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_16, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(3); let __v_19: G = G::from_u64(93); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_17, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_18, __v_21, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_8, __v_27, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(76); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_11, __v_6, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_18, __v_28, __v_23, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(81); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_8, __v_35, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_18, __v_36, __v_32, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_18, __v_37, __v_33, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = { let __values: [G; 4] = [__v_8, __v_39, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_18, __v_40, __v_25, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_18, __v_28, __v_41, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = G::from_u64(80); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = { let __values: [G; 4] = [__v_8, __v_44, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_18, __v_31, __v_33, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_18, __v_46, __v_42, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_18, __v_45, __v_47, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_18, __v_40, __v_41, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_18, __v_28, __v_49, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_18, __v_48, __v_50, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_18, __v_45, __v_32, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_18, __v_52, __v_33, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = G::from_u64(4); let __v_55: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = { let __values: [G; 4] = [__v_8, __v_56, __v_17, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_58: G = { let __values: [G; 4] = [__v_18, __v_57, __v_14, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_59: G = { let __values: [G; 4] = [__v_18, __v_58, __v_23, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_60: G = { let __values: [G; 4] = [__v_18, __v_59, __v_25, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_61: G = { let __values: [G; 4] = [__v_18, __v_22, __v_60, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_62: G = G::from_u64(67); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_62]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = { let __values: [G; 4] = [__v_8, __v_63, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_65: G = { let __values: [G; 4] = [__v_18, __v_64, __v_23, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_66: G = { let __values: [G; 4] = [__v_18, __v_65, __v_25, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_67: G = { let __values: [G; 4] = [__v_18, __v_61, __v_66, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_68: G = { let __values: [G; 4] = [__v_18, __v_28, __v_25, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_69: G = { let __values: [G; 4] = [__v_18, __v_67, __v_68, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_70: G = G::from_u64(94); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_70]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_71: G = __r_arr[0]; let __v_72: G = { let __values: [G; 4] = [__v_8, __v_71, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_73: G = { let __values: [G; 4] = [__v_18, __v_31, __v_38, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_74: G = { let __values: [G; 4] = [__v_18, __v_73, __v_42, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_75: G = { let __values: [G; 4] = [__v_18, __v_72, __v_74, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_76: G = { let __values: [G; 4] = [__v_18, __v_75, __v_51, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_77: G = { let __values: [G; 4] = [__v_18, __v_22, __v_76, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_78: G = G::from_u64(97); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_78]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_79: G = __r_arr[0]; let __v_80: G = { let __values: [G; 4] = [__v_8, __v_79, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_81: G = { let __values: [G; 4] = [__v_18, __v_80, __v_38, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_82: G = { let __values: [G; 4] = [__v_18, __v_81, __v_51, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_83: G = { let __values: [G; 4] = [__v_18, __v_77, __v_82, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_84: G = { let __values: [G; 4] = [__v_18, __v_83, __v_53, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_85: G = { let __values: [G; 4] = [__v_18, __v_31, __v_53, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_86: G = { let __values: [G; 4] = [__v_18, __v_85, __v_42, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_87: G = { let __values: [G; 4] = [__v_18, __v_84, __v_86, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_88: G = { let __values: [G; 4] = [__v_18, __v_69, __v_87, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_89: G = { let __values: [G; 4] = [__v_54, __v_14, __v_88, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_90: G = { let __values: [G; 4] = [__v_54, __v_12, __v_89, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_90]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6464u64 => { let __v_6: G = G::from_u64(2); let __v_7: G = G::from_u64(1); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_6, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_11]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6465u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(4); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(29); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_17, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_16, __v_18, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_14, __v_19, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = G::from_u64(42); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(100); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_8, __v_25, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_11, __v_6, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_14, __v_26, __v_27, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_14, __v_23, __v_28, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(101); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_8, __v_31, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = G::from_u64(38); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_8, __v_34, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_14, __v_35, __v_36, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_14, __v_32, __v_37, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_14, __v_29, __v_38, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_13, __v_20, __v_39, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_13, __v_12, __v_40, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_41]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6528u64 => { 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(1).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 = G::from_u64(2); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_11, __v_14, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_12, __v_11, __v_15, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_12, __v_18, __v_19, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = G::from_u64(40); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_12, __v_20, __v_15, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_12, __v_20, __v_24, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_12, __v_20, __v_25, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_12, __v_20, __v_26, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_12, __v_20, __v_27, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_12, __v_20, __v_28, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_12, __v_11, __v_29, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_12, __v_23, __v_30, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_31]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6529u64 => { let __v_6: G = G::from_u64(4); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; 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(1).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 = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_9, __v_11, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_6, __v_13, __v_14, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_15]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6530u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(4); let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(29); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_14, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_16, __v_19, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = G::from_u64(102); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(38); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_8, __v_25, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = G::from_u64(31); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_14, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_16, __v_29, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_11, __v_6, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_16, __v_30, __v_31, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_16, __v_32, __v_33, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_16, __v_26, __v_34, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_16, __v_23, __v_35, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_15, __v_20, __v_36, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_15, __v_12, __v_37, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_15, __v_12, __v_38, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_39]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_6, __v_8, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_566] = [__v_9]; record.function_queries[566].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_567: usize = 3; -const IN_567: usize = 3; -const OUT_567: usize = 1; -fn aiur_fn_567(inp: [G; IN_567], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_567], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(64); let __v_4: G = __v_3 * __v_1; let __v_5: G = __v_4 + __v_2; match __v_5.as_canonical_u64() { 4160u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_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(1).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; 4] = [__v_6, __v_9, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_13: G = { let __values: [G; 4] = [__v_9, __v_7, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_15: G = G::from_u64(2); let __v_16: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_9, __v_7, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_18, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_15, __v_17, __v_19, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_15, __v_22, __v_10, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_14, __v_20, __v_23, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_15, __v_26, __v_10, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_14, __v_27, __v_11, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(60); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_15, __v_30, __v_10, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_14, __v_31, __v_11, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_14, __v_32, __v_8, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_14, __v_28, __v_33, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_14, __v_24, __v_34, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = { let __values: [G; 4] = [__v_15, __v_37, __v_10, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_14, __v_35, __v_38, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_12, __v_8, __v_39, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_12, __v_13, __v_40, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_41]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4161u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 4] = [__v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_6, __v_8, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_13: G = { let __values: [G; 4] = [__v_8, __v_7, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_15: G = G::from_u64(2); let __v_16: G = G::from_u64(62); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_15, __v_17, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_14, __v_18, __v_10, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_8, __v_7, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_15, __v_21, __v_23, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_15, __v_26, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_14, __v_24, __v_27, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_15, __v_30, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_14, __v_31, __v_11, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = G::from_u64(61); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_15, __v_34, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_14, __v_35, __v_11, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_14, __v_36, __v_10, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_14, __v_32, __v_37, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_14, __v_28, __v_38, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = { let __values: [G; 4] = [__v_15, __v_40, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_14, __v_39, __v_41, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_12, __v_19, __v_42, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_12, __v_13, __v_43, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_44]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4162u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = G::from_u64(2); let __v_11: G = G::from_u64(59); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_10, __v_12, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_6, __v_8, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_8, __v_7, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_10, __v_17, __v_19, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_6, __v_10, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(3); let __v_23: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_10, __v_24, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_22, __v_25, __v_21, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = G::from_u64(5); let __v_28: G = { let __values: [G; 4] = [__v_8, __v_7, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_22, __v_13, __v_14, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_22, __v_13, __v_15, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 4] = [__v_10, __v_32, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_22, __v_20, __v_33, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_22, __v_26, __v_15, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_22, __v_34, __v_35, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_22, __v_26, __v_14, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_22, __v_36, __v_37, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_6, __v_22, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_22, __v_13, __v_39, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_22, __v_20, __v_40, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_22, __v_41, __v_21, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_22, __v_42, __v_15, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_27, __v_38, __v_43, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_27, __v_30, __v_44, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_27, __v_29, __v_45, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_27, __v_28, __v_46, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_47]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4288u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(5); let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_8, __v_23, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_21, __v_17, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_8, __v_27, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_21, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_21, __v_29, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_21, __v_30, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_21, __v_28, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = G::from_u64(67); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_8, __v_34, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_21, __v_35, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_21, __v_36, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_21, __v_32, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_21, __v_25, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(46); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_21, __v_42, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_21, __v_43, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_21, __v_39, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_20, __v_11, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_20, __v_11, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_47]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4352u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_19, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_17, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_8, __v_23, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_15, __v_21, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_8, __v_27, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(66); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_15, __v_31, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_15, __v_32, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_15, __v_28, __v_33, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = G::from_u64(68); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 4] = [__v_8, __v_36, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_15, __v_37, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_15, __v_38, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_15, __v_34, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_15, __v_25, __v_40, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = { let __values: [G; 4] = [__v_8, __v_43, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_15, __v_44, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_15, __v_45, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_15, __v_41, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_14, __v_11, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_14, __v_11, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_49]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4416u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_15, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_19: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_22, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_20, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(59); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = G::from_u64(66); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = { let __values: [G; 4] = [__v_8, __v_29, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_13, __v_30, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_13, __v_31, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_13, __v_27, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_13, __v_24, __v_33, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = G::from_u64(69); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 4] = [__v_8, __v_36, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_13, __v_37, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_13, __v_38, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_13, __v_34, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = G::from_u64(68); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = { let __values: [G; 4] = [__v_8, __v_42, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_13, __v_43, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_13, __v_44, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_13, __v_40, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_18, __v_11, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_18, __v_11, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_48]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4672u64 => { 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(1).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 = G::from_u64(2); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_13: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 3] = [__v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_15, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_10, __v_16, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_14, __v_17, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_18, __v_21, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(73); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_12, __v_25, __v_11, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_12, __v_22, __v_26, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = { let __values: [G; 4] = [__v_8, __v_29, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_12, __v_30, __v_11, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_12, __v_27, __v_31, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_32]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4673u64 => { 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(1).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 = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = G::from_u64(5); let __v_11: G = G::from_u64(2); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_11, __v_12, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_15: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_17, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_8, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_11, __v_16, __v_19, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_11, __v_22, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_14, __v_20, __v_23, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(73); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_11, __v_26, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_11, __v_28, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_14, __v_29, __v_9, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_14, __v_27, __v_30, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_14, __v_24, __v_31, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_11, __v_34, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_14, __v_35, __v_9, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_14, __v_32, __v_36, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_10, __v_13, __v_37, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_38]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4736u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(5); let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_8, __v_23, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_21, __v_17, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_8, __v_27, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_21, __v_28, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_21, __v_30, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_21, __v_25, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_8, __v_34, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_21, __v_32, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 4] = [__v_8, __v_38, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_21, __v_17, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = G::from_u64(74); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = { let __values: [G; 4] = [__v_8, __v_42, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_21, __v_43, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_21, __v_44, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_21, __v_40, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = { let __values: [G; 4] = [__v_8, __v_48, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = G::from_u64(43); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = { let __values: [G; 4] = [__v_8, __v_51, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_21, __v_52, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_21, __v_53, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_21, __v_49, __v_54, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_56: G = { let __values: [G; 4] = [__v_21, __v_46, __v_55, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = { let __values: [G; 4] = [__v_20, __v_36, __v_56, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_58: G = { let __values: [G; 4] = [__v_20, __v_11, __v_57, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_59: G = { let __values: [G; 4] = [__v_20, __v_11, __v_58, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_59]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4737u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(5); let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_8, __v_23, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_21, __v_17, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_8, __v_27, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_21, __v_28, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_21, __v_30, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_21, __v_25, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = { let __values: [G; 4] = [__v_8, __v_33, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_21, __v_32, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = { let __values: [G; 4] = [__v_8, __v_37, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_21, __v_17, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(74); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_21, __v_42, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_21, __v_43, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_21, __v_39, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = { let __values: [G; 4] = [__v_8, __v_47, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = G::from_u64(41); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = { let __values: [G; 4] = [__v_8, __v_50, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = G::from_u64(43); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = { let __values: [G; 4] = [__v_8, __v_53, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_21, __v_54, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_56: G = { let __values: [G; 4] = [__v_21, __v_55, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = { let __values: [G; 4] = [__v_21, __v_51, __v_56, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_58: G = { let __values: [G; 4] = [__v_21, __v_48, __v_57, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_59: G = { let __values: [G; 4] = [__v_21, __v_45, __v_58, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_60: G = { let __values: [G; 4] = [__v_20, __v_35, __v_59, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_61: G = { let __values: [G; 4] = [__v_20, __v_11, __v_60, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_62: G = { let __values: [G; 4] = [__v_20, __v_11, __v_61, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_62]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4800u64 => { 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(1).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 = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = G::from_u64(5); let __v_11: G = G::from_u64(2); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_11, __v_12, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_15: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_17, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_8, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_11, __v_16, __v_19, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_11, __v_22, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_14, __v_20, __v_23, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(75); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_11, __v_26, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = { let __values: [G; 4] = [__v_11, __v_29, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_14, __v_30, __v_9, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_14, __v_27, __v_31, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_14, __v_24, __v_32, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(73); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_11, __v_35, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_14, __v_36, __v_9, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_14, __v_33, __v_37, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_10, __v_13, __v_38, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_39]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4801u64 => { 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(1).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 = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = G::from_u64(5); let __v_11: G = G::from_u64(2); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_11, __v_12, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_15: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_17, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_8, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_11, __v_16, __v_19, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_11, __v_22, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_14, __v_20, __v_23, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(75); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_11, __v_26, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = { let __values: [G; 4] = [__v_11, __v_29, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_14, __v_30, __v_9, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_14, __v_27, __v_31, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_14, __v_24, __v_32, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_11, __v_35, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = { let __values: [G; 4] = [__v_11, __v_37, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_14, __v_38, __v_9, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_14, __v_36, __v_39, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_14, __v_33, __v_40, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_10, __v_13, __v_41, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_42]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4864u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_18: G = G::from_u64(3); let __v_19: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_22, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_20, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_18, __v_24, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(76); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_18, __v_14, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_18, __v_31, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_18, __v_14, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_18, __v_33, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_18, __v_28, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(42); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 4] = [__v_8, __v_38, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_18, __v_39, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_18, __v_40, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_18, __v_14, __v_41, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_18, __v_36, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_17, __v_11, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_17, __v_11, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_45]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4865u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_19, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_17, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_8, __v_23, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_15, __v_21, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(76); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_8, __v_27, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_15, __v_31, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_15, __v_28, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_8, __v_35, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_15, __v_36, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_15, __v_33, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_15, __v_25, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(74); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_15, __v_42, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = { let __values: [G; 4] = [__v_8, __v_44, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_15, __v_45, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_15, __v_43, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_15, __v_39, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_14, __v_11, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_14, __v_11, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_50]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4866u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_19, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_17, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_8, __v_23, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_15, __v_21, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(76); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_8, __v_27, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_15, __v_31, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_15, __v_28, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_8, __v_35, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_15, __v_36, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_15, __v_33, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_15, __v_25, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(74); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_15, __v_42, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = { let __values: [G; 4] = [__v_8, __v_44, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_15, __v_45, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_15, __v_43, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_15, __v_39, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_14, __v_11, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_14, __v_11, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_50]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4867u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_18: G = G::from_u64(3); let __v_19: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_22, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_20, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_18, __v_24, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(76); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_18, __v_14, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_18, __v_31, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_18, __v_14, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_18, __v_33, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_18, __v_28, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = { let __values: [G; 4] = [__v_8, __v_37, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = G::from_u64(42); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = { let __values: [G; 4] = [__v_8, __v_40, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_18, __v_41, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_18, __v_42, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_18, __v_38, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_18, __v_14, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_18, __v_36, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_17, __v_11, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_17, __v_11, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_48]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4928u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_11, __v_6, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_19, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_20, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_18, __v_21, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_16, __v_22, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(77); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_8, __v_25, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_16, __v_26, __v_13, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_16, __v_27, __v_14, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_16, __v_23, __v_28, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(76); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_8, __v_31, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_16, __v_32, __v_13, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(75); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_8, __v_35, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_16, __v_36, __v_14, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_16, __v_33, __v_37, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_16, __v_29, __v_38, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_15, __v_12, __v_39, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_15, __v_12, __v_40, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_41]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4992u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_18: G = G::from_u64(3); let __v_19: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_22, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_20, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_18, __v_24, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(78); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_18, __v_14, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_18, __v_31, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_18, __v_14, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_18, __v_33, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_18, __v_28, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 4] = [__v_8, __v_38, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_18, __v_39, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_18, __v_40, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_18, __v_14, __v_41, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_18, __v_36, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_17, __v_11, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_17, __v_11, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_45]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4993u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_19, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_17, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_8, __v_23, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_15, __v_21, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(78); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_8, __v_27, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_15, __v_31, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_15, __v_28, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_8, __v_35, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_15, __v_36, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_15, __v_33, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_15, __v_25, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(73); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = { let __values: [G; 4] = [__v_8, __v_44, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_15, __v_45, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = { let __values: [G; 4] = [__v_8, __v_47, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_15, __v_48, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_15, __v_46, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_15, __v_42, __v_50, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_15, __v_39, __v_51, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_14, __v_11, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_14, __v_11, __v_53, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_54]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4994u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_19, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_17, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_8, __v_23, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_15, __v_21, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(78); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_8, __v_27, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_15, __v_31, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_15, __v_28, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_8, __v_35, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_15, __v_36, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_15, __v_33, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_15, __v_25, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(73); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = { let __values: [G; 4] = [__v_8, __v_44, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = { let __values: [G; 4] = [__v_8, __v_46, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_15, __v_47, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_15, __v_45, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_15, __v_49, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_15, __v_42, __v_50, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_15, __v_39, __v_51, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_14, __v_11, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_14, __v_11, __v_53, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_54]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4995u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(5); let __v_20: G = G::from_u64(3); let __v_21: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_24, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_22, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_20, __v_26, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = G::from_u64(78); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 4] = [__v_8, __v_32, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_20, __v_14, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_20, __v_33, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_20, __v_14, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_20, __v_35, __v_36, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_20, __v_30, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = { let __values: [G; 4] = [__v_8, __v_40, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = { let __values: [G; 4] = [__v_8, __v_43, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_20, __v_18, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_20, __v_44, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_20, __v_18, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_20, __v_46, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_20, __v_41, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_20, __v_38, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_19, __v_11, __v_50, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_19, __v_11, __v_51, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_52]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5056u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_16, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_14, __v_20, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(79); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_8, __v_23, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_14, __v_27, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_14, __v_24, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_14, __v_21, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_14, __v_30, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_13, __v_11, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_32]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5057u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_16, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_14, __v_20, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(79); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_8, __v_23, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_14, __v_27, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_14, __v_24, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_14, __v_21, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_8, __v_31, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_14, __v_32, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_14, __v_30, __v_33, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_13, __v_11, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_35]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5120u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_18: G = G::from_u64(3); let __v_19: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_22, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_20, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_18, __v_24, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(80); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_18, __v_14, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_18, __v_31, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_18, __v_14, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_18, __v_33, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_18, __v_28, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(48); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 4] = [__v_8, __v_38, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_18, __v_39, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_18, __v_40, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_18, __v_14, __v_41, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_18, __v_36, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_17, __v_11, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_17, __v_11, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_45]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5121u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_18: G = G::from_u64(3); let __v_19: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_22, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_20, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_18, __v_24, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(80); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_18, __v_14, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_18, __v_31, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_8, __v_35, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_18, __v_36, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_18, __v_33, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_18, __v_28, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(75); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = G::from_u64(48); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = { let __values: [G; 4] = [__v_8, __v_44, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_18, __v_45, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = { let __values: [G; 4] = [__v_8, __v_47, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_18, __v_48, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_18, __v_46, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_18, __v_14, __v_50, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_18, __v_42, __v_51, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_18, __v_39, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_17, __v_11, __v_53, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_17, __v_11, __v_54, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_55]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5122u64 => { 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(1).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 = G::from_u64(3); let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_9, __v_11, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_9, __v_14, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_15, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_9, __v_18, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_22, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_12, __v_23, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_9, __v_21, __v_24, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_9, __v_27, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_8, __v_25, __v_28, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(80); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_9, __v_31, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_9, __v_34, __v_7, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_8, __v_35, __v_36, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_8, __v_32, __v_37, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_8, __v_38, __v_16, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_8, __v_29, __v_39, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_8, __v_40, __v_16, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_17, __v_19, __v_41, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_42]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5123u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_16, __v_18, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = G::from_u64(5); let __v_22: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_25, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_23, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = { let __values: [G; 4] = [__v_8, __v_29, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_16, __v_27, __v_30, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = G::from_u64(80); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = { let __values: [G; 4] = [__v_8, __v_33, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_16, __v_14, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_16, __v_34, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 4] = [__v_8, __v_38, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_16, __v_39, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_16, __v_36, __v_40, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_16, __v_31, __v_41, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = G::from_u64(48); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = { let __values: [G; 4] = [__v_8, __v_44, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_16, __v_45, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_16, __v_46, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_16, __v_14, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_16, __v_42, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_21, __v_11, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_21, __v_11, __v_50, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_51]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5124u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(5); let __v_20: G = G::from_u64(3); let __v_21: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_24, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_22, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_20, __v_26, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = G::from_u64(80); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 4] = [__v_8, __v_32, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_20, __v_14, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_20, __v_33, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_20, __v_14, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_20, __v_35, __v_36, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_20, __v_30, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __v_41: G = { let __values: [G; 4] = [__v_8, __v_40, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = G::from_u64(48); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = { let __values: [G; 4] = [__v_8, __v_43, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_20, __v_44, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_20, __v_18, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_20, __v_45, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_20, __v_18, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_20, __v_41, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_20, __v_38, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_19, __v_11, __v_50, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_19, __v_11, __v_51, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_52]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5184u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_18: G = G::from_u64(3); let __v_19: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_22, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_20, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_18, __v_24, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(81); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_18, __v_14, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_18, __v_31, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_18, __v_14, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_18, __v_33, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_18, __v_28, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 4] = [__v_8, __v_38, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_18, __v_39, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_18, __v_40, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_18, __v_14, __v_41, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_18, __v_36, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_17, __v_11, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_17, __v_11, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_45]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5185u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_18: G = G::from_u64(3); let __v_19: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_22, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_20, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_18, __v_24, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(81); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_18, __v_14, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_18, __v_31, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_8, __v_35, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_18, __v_36, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_18, __v_33, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_18, __v_28, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_18, __v_42, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = { let __values: [G; 4] = [__v_8, __v_44, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_18, __v_45, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_18, __v_43, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_18, __v_14, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_18, __v_39, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_17, __v_11, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_17, __v_11, __v_50, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_51]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5186u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_19, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_17, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_8, __v_23, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_15, __v_21, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(81); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_8, __v_27, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_15, __v_31, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_15, __v_28, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_8, __v_35, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_15, __v_36, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_15, __v_33, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_15, __v_25, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(74); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_15, __v_42, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = { let __values: [G; 4] = [__v_8, __v_44, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = { let __values: [G; 4] = [__v_8, __v_47, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_15, __v_48, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_15, __v_49, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_15, __v_45, __v_50, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_15, __v_43, __v_51, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_15, __v_39, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_14, __v_11, __v_53, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_14, __v_11, __v_54, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_55]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5187u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_8, __v_17, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(3); let __v_20: G = { let __values: [G; 4] = [__v_19, __v_18, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = G::from_u64(5); let __v_22: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_25, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_23, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = { let __values: [G; 4] = [__v_8, __v_29, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_19, __v_27, __v_30, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = G::from_u64(81); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = { let __values: [G; 4] = [__v_8, __v_33, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_19, __v_14, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_19, __v_34, __v_35, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_19, __v_14, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_19, __v_36, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_19, __v_31, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(74); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_19, __v_42, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __v_46: G = { let __values: [G; 4] = [__v_8, __v_45, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_19, __v_46, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_19, __v_47, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_19, __v_18, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_19, __v_43, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_19, __v_39, __v_50, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_21, __v_11, __v_51, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_21, __v_11, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_53]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5248u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_18: G = G::from_u64(3); let __v_19: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_22, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_20, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_18, __v_24, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(82); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_18, __v_14, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_18, __v_31, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_18, __v_33, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_18, __v_28, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = G::from_u64(45); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = { let __values: [G; 4] = [__v_8, __v_37, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_18, __v_38, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_18, __v_39, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_18, __v_14, __v_40, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_18, __v_35, __v_41, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_17, __v_11, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_17, __v_11, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_44]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5249u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(5); let __v_25: G = G::from_u64(3); let __v_26: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_8, __v_27, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_25, __v_17, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(46); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_8, __v_31, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_8, __v_34, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_25, __v_35, __v_36, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_25, __v_19, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_25, __v_19, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_25, __v_37, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_25, __v_32, __v_40, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_25, __v_41, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_25, __v_29, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __v_46: G = { let __values: [G; 4] = [__v_8, __v_45, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_25, __v_43, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = { let __values: [G; 4] = [__v_8, __v_49, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_25, __v_17, __v_50, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = G::from_u64(82); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = { let __values: [G; 4] = [__v_8, __v_53, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = { let __values: [G; 4] = [__v_8, __v_56, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_58: G = { let __values: [G; 4] = [__v_25, __v_57, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_59: G = { let __values: [G; 4] = [__v_25, __v_54, __v_58, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_60: G = { let __values: [G; 4] = [__v_25, __v_59, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_61: G = { let __values: [G; 4] = [__v_25, __v_51, __v_60, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_62: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_62]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_63: G = __r_arr[0]; let __v_64: G = { let __values: [G; 4] = [__v_8, __v_63, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_65: G = G::from_u64(45); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_65]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_66: G = __r_arr[0]; let __v_67: G = { let __values: [G; 4] = [__v_8, __v_66, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_68: G = { let __values: [G; 4] = [__v_25, __v_19, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_69: G = { let __values: [G; 4] = [__v_25, __v_67, __v_68, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_70: G = { let __values: [G; 4] = [__v_25, __v_69, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_71: G = { let __values: [G; 4] = [__v_25, __v_64, __v_70, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_72: G = { let __values: [G; 4] = [__v_25, __v_61, __v_71, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_73: G = { let __values: [G; 4] = [__v_24, __v_47, __v_72, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_74: G = { let __values: [G; 4] = [__v_24, __v_11, __v_73, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_75: G = { let __values: [G; 4] = [__v_24, __v_11, __v_74, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_75]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5250u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(5); let __v_25: G = G::from_u64(3); let __v_26: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_8, __v_27, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_25, __v_17, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(46); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_8, __v_31, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_8, __v_34, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_25, __v_35, __v_36, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_25, __v_19, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_25, __v_19, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_25, __v_37, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_25, __v_32, __v_40, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_25, __v_41, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_25, __v_29, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = { let __values: [G; 4] = [__v_8, __v_44, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_25, __v_43, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = { let __values: [G; 4] = [__v_8, __v_48, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_25, __v_17, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = G::from_u64(82); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __v_53: G = { let __values: [G; 4] = [__v_8, __v_52, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_54]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __v_56: G = { let __values: [G; 4] = [__v_8, __v_55, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = { let __values: [G; 4] = [__v_25, __v_56, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_58: G = { let __values: [G; 4] = [__v_25, __v_53, __v_57, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_59: G = { let __values: [G; 4] = [__v_25, __v_58, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_60: G = { let __values: [G; 4] = [__v_25, __v_50, __v_59, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_61: G = G::from_u64(75); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_61]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_62: G = __r_arr[0]; let __v_63: G = { let __values: [G; 4] = [__v_8, __v_62, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_64: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_64]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_65: G = __r_arr[0]; let __v_66: G = { let __values: [G; 4] = [__v_8, __v_65, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_67: G = G::from_u64(45); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_67]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_68: G = __r_arr[0]; let __v_69: G = { let __values: [G; 4] = [__v_8, __v_68, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_70: G = { let __values: [G; 4] = [__v_25, __v_19, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_71: G = { let __values: [G; 4] = [__v_25, __v_69, __v_70, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_72: G = { let __values: [G; 4] = [__v_25, __v_71, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_73: G = { let __values: [G; 4] = [__v_25, __v_66, __v_72, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_74: G = { let __values: [G; 4] = [__v_25, __v_63, __v_73, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_75: G = { let __values: [G; 4] = [__v_25, __v_60, __v_74, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_76: G = { let __values: [G; 4] = [__v_24, __v_46, __v_75, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_77: G = { let __values: [G; 4] = [__v_24, __v_11, __v_76, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_78: G = { let __values: [G; 4] = [__v_24, __v_11, __v_77, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_78]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5440u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_17: G = G::from_u64(3); let __v_18: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_20, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_21, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_19, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_17, __v_23, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(85); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_17, __v_27, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(84); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_8, __v_30, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_17, __v_31, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_17, __v_32, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_17, __v_28, __v_33, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_17, __v_24, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = { let __values: [G; 4] = [__v_8, __v_37, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_17, __v_38, __v_13, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(45); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = { let __values: [G; 4] = [__v_8, __v_43, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_17, __v_15, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_17, __v_15, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_17, __v_42, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_17, __v_47, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_17, __v_39, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_17, __v_35, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_16, __v_11, __v_50, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_16, __v_11, __v_51, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_52]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5504u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_14: G = G::from_u64(84); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_8, __v_15, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_13, __v_16, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(49); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_8, __v_23, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(45); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_13, __v_21, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_13, __v_21, __v_30, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_13, __v_27, __v_31, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_13, __v_32, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(5); let __v_35: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_38, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_40: G = { let __values: [G; 4] = [__v_8, __v_36, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = { let __values: [G; 4] = [__v_8, __v_42, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_13, __v_40, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = G::from_u64(86); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = { let __values: [G; 4] = [__v_8, __v_46, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_13, __v_47, __v_12, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_13, __v_17, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_13, __v_48, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_13, __v_17, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_13, __v_50, __v_51, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_13, __v_44, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_54]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __v_56: G = { let __values: [G; 4] = [__v_8, __v_55, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = { let __values: [G; 4] = [__v_13, __v_24, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_58: G = { let __values: [G; 4] = [__v_13, __v_57, __v_33, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_59: G = { let __values: [G; 4] = [__v_13, __v_21, __v_58, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_60: G = { let __values: [G; 4] = [__v_13, __v_56, __v_59, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_61: G = { let __values: [G; 4] = [__v_13, __v_24, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_62: G = { let __values: [G; 4] = [__v_13, __v_61, __v_33, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_63: G = { let __values: [G; 4] = [__v_13, __v_60, __v_62, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_64: G = { let __values: [G; 4] = [__v_13, __v_53, __v_63, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_65: G = { let __values: [G; 4] = [__v_34, __v_11, __v_64, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_66: G = { let __values: [G; 4] = [__v_34, __v_11, __v_65, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_67: G = { let __values: [G; 4] = [__v_34, __v_11, __v_66, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_67]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5568u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(37); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_15, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_16, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_14, __v_17, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(5); let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_8, __v_23, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_21, __v_18, __v_24, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_8, __v_27, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_21, __v_18, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_21, __v_29, __v_19, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_21, __v_30, __v_19, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_21, __v_28, __v_31, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = G::from_u64(87); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_8, __v_34, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_21, __v_35, __v_19, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_21, __v_36, __v_19, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_21, __v_32, __v_37, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_21, __v_25, __v_38, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_21, __v_39, __v_42, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_20, __v_12, __v_43, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_44]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5760u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = G::from_u64(3); let __v_11: G = G::from_u64(2); let __v_12: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_8, __v_7, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_11, __v_13, __v_15, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(88); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_11, __v_18, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 4] = [__v_10, __v_16, __v_19, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = G::from_u64(90); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_11, __v_22, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(38); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_11, __v_25, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = G::from_u64(30); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 3] = [__v_6, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_11, __v_28, __v_29, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 4] = [__v_11, __v_32, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_10, __v_30, __v_33, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_10, __v_26, __v_34, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_10, __v_23, __v_35, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_10, __v_20, __v_36, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = G::from_u64(89); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = { let __values: [G; 4] = [__v_11, __v_39, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_10, __v_37, __v_40, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_41]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5824u64 => { let __v_6: G = G::from_u64(4); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_7, __v_8, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(2); let __v_14: G = G::from_u64(29); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_13, __v_15, __v_12, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_9, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(5); let __v_20: G = { let __values: [G; 4] = [__v_9, __v_10, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = G::from_u64(3); let __v_22: G = { let __values: [G; 4] = [__v_21, __v_16, __v_17, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 3] = [__v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_13, __v_24, __v_25, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_21, __v_16, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_21, __v_26, __v_27, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(91); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 4] = [__v_13, __v_30, __v_12, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = { let __values: [G; 4] = [__v_21, __v_31, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = G::from_u64(30); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_13, __v_34, __v_12, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_21, __v_35, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_21, __v_32, __v_36, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_21, __v_37, __v_17, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_21, __v_28, __v_38, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_21, __v_39, __v_17, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_19, __v_22, __v_40, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_19, __v_20, __v_41, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_42]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5825u64 => { let __v_6: G = G::from_u64(4); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_7, __v_8, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(2); let __v_15: G = G::from_u64(29); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 4] = [__v_14, __v_16, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_9, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_7, __v_14, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(3); let __v_21: G = { let __values: [G; 4] = [__v_7, __v_20, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(91); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_14, __v_23, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_20, __v_24, __v_21, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(31); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_14, __v_27, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_20, __v_28, __v_21, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_20, __v_29, __v_19, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = G::from_u64(5); let __v_32: G = { let __values: [G; 4] = [__v_9, __v_10, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_20, __v_17, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_20, __v_17, __v_19, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 3] = [__v_7, __v_10, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_14, __v_36, __v_37, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_20, __v_17, __v_21, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_20, __v_38, __v_39, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_20, __v_30, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_20, __v_25, __v_41, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_20, __v_42, __v_11, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_20, __v_40, __v_43, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_20, __v_25, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_20, __v_45, __v_11, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_20, __v_30, __v_46, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_20, __v_44, __v_47, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_31, __v_34, __v_48, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_31, __v_33, __v_49, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_31, __v_11, __v_50, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_31, __v_32, __v_51, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_52]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5888u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = { let __values: [G; 3] = [__v_6, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(2); let __v_12: G = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_11, __v_13, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_16: G = G::from_u64(29); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_11, __v_17, __v_10, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_15, __v_18, __v_14, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(38); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_11, __v_21, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_6, __v_8, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(5); let __v_26: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 3] = [__v_8, __v_7, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_11, __v_27, __v_29, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = G::from_u64(37); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 4] = [__v_11, __v_32, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_15, __v_30, __v_33, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = G::from_u64(92); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 4] = [__v_11, __v_36, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_15, __v_22, __v_23, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_15, __v_37, __v_38, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_15, __v_22, __v_24, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_15, __v_39, __v_40, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_15, __v_34, __v_41, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = G::from_u64(91); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = { let __values: [G; 4] = [__v_11, __v_44, __v_10, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_15, __v_45, __v_14, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_15, __v_46, __v_23, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_15, __v_47, __v_24, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_15, __v_22, __v_48, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_15, __v_42, __v_49, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_25, __v_19, __v_50, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_25, __v_19, __v_51, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_52]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5952u64 => { let __v_6: G = G::from_u64(4); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = G::from_u64(2); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_10, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_12, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(1); let __v_15: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_7, __v_8, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_7, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_7, __v_14, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(5); let __v_20: G = { let __values: [G; 4] = [__v_14, __v_8, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_14, __v_21, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_10, __v_24, __v_16, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_12, __v_25, __v_17, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = G::from_u64(93); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_10, __v_28, __v_16, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_12, __v_29, __v_17, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = { let __values: [G; 4] = [__v_12, __v_30, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_32: G = G::from_u64(60); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = { let __values: [G; 4] = [__v_10, __v_33, __v_15, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_12, __v_34, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_12, __v_35, __v_11, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_12, __v_31, __v_36, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_12, __v_37, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_12, __v_38, __v_9, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_12, __v_26, __v_39, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_12, __v_40, __v_18, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_19, __v_13, __v_41, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_19, __v_11, __v_42, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_19, __v_9, __v_43, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_19, __v_22, __v_44, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_19, __v_20, __v_45, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_46]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5953u64 => { let __v_6: G = G::from_u64(4); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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 = 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(1).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; 4] = [__v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(2); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_12, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_15: G = { let __values: [G; 4] = [__v_7, __v_14, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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; 3] = [__v_7, __v_8, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_7, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_19: G = { let __values: [G; 4] = [__v_9, __v_8, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_9, __v_20, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(62); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_12, __v_23, __v_10, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_14, __v_24, __v_11, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_12, __v_27, __v_16, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_14, __v_28, __v_17, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(93); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_12, __v_31, __v_16, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_14, __v_32, __v_17, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_14, __v_33, __v_15, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = G::from_u64(61); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 4] = [__v_12, __v_36, __v_10, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_14, __v_37, __v_15, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_14, __v_38, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_14, __v_34, __v_39, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_7, __v_9, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_14, __v_40, __v_41, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_14, __v_42, __v_11, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_14, __v_29, __v_43, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_14, __v_44, __v_11, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_18, __v_15, __v_45, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_18, __v_13, __v_46, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_18, __v_25, __v_47, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_18, __v_21, __v_48, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_18, __v_19, __v_49, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_50]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6080u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(3); let __v_23: G = { let __values: [G; 4] = [__v_22, __v_20, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_22, __v_20, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(5); let __v_27: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_22, __v_17, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 4] = [__v_8, __v_32, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_8, __v_35, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_22, __v_17, __v_36, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_22, __v_37, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_22, __v_38, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_22, __v_33, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = G::from_u64(95); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = { let __values: [G; 4] = [__v_8, __v_42, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_22, __v_43, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_22, __v_44, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_22, __v_40, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_22, __v_30, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = G::from_u64(46); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = { let __values: [G; 4] = [__v_8, __v_49, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_22, __v_50, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_22, __v_51, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_22, __v_47, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_26, __v_11, __v_53, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_26, __v_11, __v_54, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_55]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6081u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_19: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_18, __v_21, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_8, __v_25, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_18, __v_26, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(5); let __v_30: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_8, __v_31, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_18, __v_17, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_8, __v_35, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 4] = [__v_8, __v_38, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_18, __v_17, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_18, __v_40, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_18, __v_41, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_18, __v_36, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = G::from_u64(95); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __v_46: G = { let __values: [G; 4] = [__v_8, __v_45, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_18, __v_46, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_18, __v_47, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_18, __v_43, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_18, __v_33, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = { let __values: [G; 4] = [__v_8, __v_51, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_18, __v_50, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_29, __v_11, __v_53, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_29, __v_11, __v_54, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_55]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6082u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_19: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_18, __v_21, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_8, __v_25, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_18, __v_26, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(5); let __v_30: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_8, __v_31, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_18, __v_17, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_8, __v_35, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 4] = [__v_8, __v_38, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_18, __v_17, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_18, __v_40, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_18, __v_41, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_18, __v_36, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = G::from_u64(95); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __v_46: G = { let __values: [G; 4] = [__v_8, __v_45, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_18, __v_46, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_18, __v_47, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_18, __v_43, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_18, __v_33, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = { let __values: [G; 4] = [__v_8, __v_51, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_18, __v_50, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_29, __v_11, __v_53, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_29, __v_11, __v_54, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_55]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6083u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = G::from_u64(3); let __v_23: G = { let __values: [G; 4] = [__v_22, __v_20, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_22, __v_20, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(5); let __v_27: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_22, __v_17, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 4] = [__v_8, __v_32, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_8, __v_35, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_22, __v_17, __v_36, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_22, __v_37, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_22, __v_38, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_22, __v_33, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = G::from_u64(95); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = { let __values: [G; 4] = [__v_8, __v_42, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_22, __v_43, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_22, __v_44, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_22, __v_40, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_22, __v_30, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = G::from_u64(46); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = { let __values: [G; 4] = [__v_8, __v_49, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_22, __v_50, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_22, __v_51, __v_24, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_22, __v_47, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_26, __v_11, __v_53, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_26, __v_11, __v_54, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_55]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6144u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_17: G = { let __values: [G; 4] = [__v_16, __v_14, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_16, __v_14, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(5); let __v_21: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_24, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_22, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_16, __v_26, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 4] = [__v_8, __v_32, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(94); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_8, __v_35, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_16, __v_36, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_16, __v_37, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_16, __v_33, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(96); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_16, __v_42, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_16, __v_43, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_16, __v_39, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_16, __v_30, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = { let __values: [G; 4] = [__v_8, __v_48, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_16, __v_49, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_16, __v_50, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_16, __v_46, __v_51, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_20, __v_11, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_20, __v_11, __v_53, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_54]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6145u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_13: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_15, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_20, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(5); let __v_24: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_27, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_25, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_8, __v_31, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_12, __v_29, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_8, __v_35, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(94); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 4] = [__v_8, __v_38, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_12, __v_39, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_12, __v_40, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_12, __v_36, __v_41, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = G::from_u64(96); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = { let __values: [G; 4] = [__v_8, __v_44, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_12, __v_45, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_12, __v_46, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_12, __v_42, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_12, __v_33, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = { let __values: [G; 4] = [__v_8, __v_50, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_12, __v_49, __v_51, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_23, __v_11, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_23, __v_11, __v_53, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_54]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6146u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_13: G = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_8, __v_14, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_12, __v_15, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_12, __v_20, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(5); let __v_24: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_26, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_27, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_25, __v_28, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_8, __v_31, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_12, __v_29, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_8, __v_35, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(94); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 4] = [__v_8, __v_38, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_12, __v_39, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_12, __v_40, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_12, __v_36, __v_41, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = G::from_u64(96); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = { let __values: [G; 4] = [__v_8, __v_44, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_12, __v_45, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_12, __v_46, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_12, __v_42, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_12, __v_33, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __v_52: G = { let __values: [G; 4] = [__v_8, __v_51, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_12, __v_49, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_23, __v_11, __v_53, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_23, __v_11, __v_54, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_55]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6147u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(72); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_17: G = { let __values: [G; 4] = [__v_16, __v_14, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_16, __v_14, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(5); let __v_21: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_9, __v_24, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_22, __v_25, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_16, __v_26, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = G::from_u64(65); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 4] = [__v_8, __v_32, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(94); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_8, __v_35, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_16, __v_36, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_16, __v_37, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_16, __v_33, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(96); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_16, __v_42, __v_17, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_16, __v_43, __v_19, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_16, __v_39, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_16, __v_30, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = { let __values: [G; 4] = [__v_8, __v_48, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_16, __v_49, __v_18, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_16, __v_50, __v_15, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_16, __v_46, __v_51, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_20, __v_11, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_20, __v_11, __v_53, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_54]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6208u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_11, __v_6, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_15: G = G::from_u64(76); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 4] = [__v_8, __v_16, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_14, __v_17, __v_13, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_14, __v_23, __v_25, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_14, __v_21, __v_26, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_14, __v_18, __v_27, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(5); let __v_31: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_33, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_34, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_32, __v_35, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(59); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 4] = [__v_8, __v_38, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(94); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_14, __v_42, __v_28, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_14, __v_43, __v_29, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_14, __v_39, __v_44, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_14, __v_36, __v_45, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = G::from_u64(97); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __v_49: G = { let __values: [G; 4] = [__v_8, __v_48, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_14, __v_49, __v_13, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_14, __v_50, __v_29, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_14, __v_46, __v_51, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = G::from_u64(96); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = { let __values: [G; 4] = [__v_8, __v_54, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_56: G = { let __values: [G; 4] = [__v_14, __v_55, __v_28, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = { let __values: [G; 4] = [__v_14, __v_56, __v_29, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_58: G = { let __values: [G; 4] = [__v_14, __v_52, __v_57, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_59: G = { let __values: [G; 4] = [__v_30, __v_12, __v_58, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_60: G = { let __values: [G; 4] = [__v_30, __v_12, __v_59, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_60]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6272u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_13, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_14, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_11, __v_6, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(76); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 4] = [__v_8, __v_22, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(3); let __v_25: G = { let __values: [G; 4] = [__v_24, __v_23, __v_17, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(81); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_8, __v_27, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_24, __v_28, __v_16, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_24, __v_29, __v_25, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_8, __v_31, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = { let __values: [G; 4] = [__v_8, __v_33, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_24, __v_32, __v_34, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_24, __v_23, __v_35, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(80); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 4] = [__v_8, __v_38, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_24, __v_20, __v_25, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_24, __v_40, __v_36, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_24, __v_39, __v_41, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_24, __v_32, __v_35, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_24, __v_23, __v_43, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_24, __v_42, __v_44, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = G::from_u64(5); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = { let __values: [G; 4] = [__v_8, __v_47, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = { let __values: [G; 4] = [__v_8, __v_50, __v_15, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_24, __v_51, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = G::from_u64(98); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = { let __values: [G; 4] = [__v_8, __v_54, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_56: G = { let __values: [G; 4] = [__v_24, __v_55, __v_16, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = { let __values: [G; 4] = [__v_24, __v_56, __v_17, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_58: G = { let __values: [G; 4] = [__v_24, __v_52, __v_57, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_59: G = G::from_u64(93); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __v_61: G = { let __values: [G; 4] = [__v_8, __v_60, __v_15, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_62: G = { let __values: [G; 4] = [__v_24, __v_61, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_63: G = G::from_u64(94); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_64: G = __r_arr[0]; let __v_65: G = { let __values: [G; 4] = [__v_8, __v_64, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_66: G = { let __values: [G; 4] = [__v_24, __v_20, __v_30, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_67: G = { let __values: [G; 4] = [__v_24, __v_66, __v_36, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_68: G = { let __values: [G; 4] = [__v_24, __v_65, __v_67, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_69: G = { let __values: [G; 4] = [__v_24, __v_68, __v_45, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_70: G = { let __values: [G; 4] = [__v_24, __v_62, __v_69, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_71: G = G::from_u64(97); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_71]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = { let __values: [G; 4] = [__v_8, __v_72, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_74: G = { let __values: [G; 4] = [__v_24, __v_73, __v_30, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_75: G = { let __values: [G; 4] = [__v_24, __v_74, __v_45, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_76: G = { let __values: [G; 4] = [__v_24, __v_70, __v_75, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_77: G = { let __values: [G; 4] = [__v_24, __v_76, __v_30, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_78: G = G::from_u64(77); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_78]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_79: G = __r_arr[0]; let __v_80: G = { let __values: [G; 4] = [__v_8, __v_79, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_81: G = { let __values: [G; 4] = [__v_24, __v_80, __v_30, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_82: G = { let __values: [G; 4] = [__v_24, __v_81, __v_25, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_83: G = { let __values: [G; 4] = [__v_24, __v_77, __v_82, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_84: G = { let __values: [G; 4] = [__v_24, __v_58, __v_83, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_85: G = { let __values: [G; 4] = [__v_46, __v_48, __v_84, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_86: G = { let __values: [G; 4] = [__v_46, __v_12, __v_85, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_86]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6336u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(70); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 4] = [__v_8, __v_13, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_15, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_16, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_17, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_11, __v_6, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(3); let __v_24: G = G::from_u64(93); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_8, __v_25, __v_17, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_23, __v_26, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(71); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_8, __v_31, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = G::from_u64(76); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_8, __v_34, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_23, __v_32, __v_22, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(81); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 4] = [__v_8, __v_38, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_23, __v_39, __v_21, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_23, __v_40, __v_36, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = { let __values: [G; 4] = [__v_8, __v_42, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_23, __v_43, __v_29, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_23, __v_32, __v_44, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = G::from_u64(80); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = { let __values: [G; 4] = [__v_8, __v_47, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_23, __v_35, __v_36, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_23, __v_49, __v_45, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_23, __v_48, __v_50, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_23, __v_43, __v_44, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_23, __v_32, __v_52, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_23, __v_51, __v_53, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_23, __v_48, __v_21, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_56: G = { let __values: [G; 4] = [__v_23, __v_55, __v_36, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = G::from_u64(5); let __v_58: G = { let __values: [G; 4] = [__v_23, __v_20, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_59: G = G::from_u64(99); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_59]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __v_61: G = { let __values: [G; 4] = [__v_8, __v_60, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_62: G = { let __values: [G; 4] = [__v_23, __v_61, __v_21, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_63: G = { let __values: [G; 4] = [__v_23, __v_62, __v_22, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_64: G = { let __values: [G; 4] = [__v_23, __v_58, __v_63, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_65: G = { let __values: [G; 4] = [__v_23, __v_20, __v_14, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_66: G = { let __values: [G; 4] = [__v_23, __v_65, __v_22, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_67: G = { let __values: [G; 4] = [__v_23, __v_66, __v_29, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_68: G = { let __values: [G; 4] = [__v_23, __v_27, __v_67, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_69: G = G::from_u64(67); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_69]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_70: G = __r_arr[0]; let __v_71: G = { let __values: [G; 4] = [__v_8, __v_70, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_72: G = { let __values: [G; 4] = [__v_23, __v_71, __v_22, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_73: G = { let __values: [G; 4] = [__v_23, __v_72, __v_29, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_74: G = { let __values: [G; 4] = [__v_23, __v_68, __v_73, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_75: G = { let __values: [G; 4] = [__v_23, __v_32, __v_29, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_76: G = { let __values: [G; 4] = [__v_23, __v_74, __v_75, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_77: G = G::from_u64(94); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_77]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_78: G = __r_arr[0]; let __v_79: G = { let __values: [G; 4] = [__v_8, __v_78, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_80: G = { let __values: [G; 4] = [__v_23, __v_35, __v_41, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_81: G = { let __values: [G; 4] = [__v_23, __v_80, __v_45, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_82: G = { let __values: [G; 4] = [__v_23, __v_79, __v_81, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_83: G = { let __values: [G; 4] = [__v_23, __v_82, __v_54, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_84: G = { let __values: [G; 4] = [__v_23, __v_27, __v_83, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_85: G = G::from_u64(97); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_85]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_86: G = __r_arr[0]; let __v_87: G = { let __values: [G; 4] = [__v_8, __v_86, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_88: G = { let __values: [G; 4] = [__v_23, __v_87, __v_41, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_89: G = { let __values: [G; 4] = [__v_23, __v_88, __v_54, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_90: G = { let __values: [G; 4] = [__v_23, __v_84, __v_89, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_91: G = { let __values: [G; 4] = [__v_23, __v_90, __v_56, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_92: G = { let __values: [G; 4] = [__v_23, __v_35, __v_56, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_93: G = { let __values: [G; 4] = [__v_23, __v_92, __v_45, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_94: G = { let __values: [G; 4] = [__v_23, __v_91, __v_93, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_95: G = { let __values: [G; 4] = [__v_23, __v_76, __v_94, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_96: G = { let __values: [G; 4] = [__v_23, __v_64, __v_95, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_97: G = { let __values: [G; 4] = [__v_57, __v_14, __v_96, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_98: G = { let __values: [G; 4] = [__v_57, __v_12, __v_97, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_98]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6400u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_8, __v_18, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(3); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_8, __v_21, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_20, __v_19, __v_22, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_8, __v_25, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_20, __v_19, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_20, __v_26, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(5); let __v_30: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_8, __v_31, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_20, __v_17, __v_32, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_8, __v_35, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_20, __v_19, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_20, __v_36, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_20, __v_28, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_20, __v_28, __v_40, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_20, __v_28, __v_41, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_20, __v_28, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_20, __v_28, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_20, __v_28, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_20, __v_28, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_20, __v_39, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_20, __v_33, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = { let __values: [G; 4] = [__v_8, __v_50, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_20, __v_48, __v_51, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_20, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = G::from_u64(100); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_54]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __v_56: G = { let __values: [G; 4] = [__v_8, __v_55, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = G::from_u64(40); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __v_59: G = { let __values: [G; 4] = [__v_8, __v_58, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_60: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_61: G = { let __values: [G; 4] = [__v_20, __v_59, __v_60, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_62: G = { let __values: [G; 4] = [__v_20, __v_56, __v_61, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_63: G = { let __values: [G; 4] = [__v_20, __v_53, __v_62, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_64: G = { let __values: [G; 4] = [__v_20, __v_63, __v_23, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_65: G = { let __values: [G; 4] = [__v_29, __v_52, __v_64, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_66: G = { let __values: [G; 4] = [__v_29, __v_11, __v_65, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_66]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6401u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_19: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_18, __v_17, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_18, __v_27, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 4] = [__v_8, __v_32, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_18, __v_27, __v_30, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_18, __v_33, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_18, __v_35, __v_30, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_18, __v_35, __v_36, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_18, __v_35, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_18, __v_35, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_18, __v_35, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_18, __v_35, __v_40, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_18, __v_35, __v_41, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = { let __values: [G; 4] = [__v_8, __v_44, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = G::from_u64(5); let __v_47: G = { let __values: [G; 4] = [__v_18, __v_25, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_18, __v_47, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_18, __v_22, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_18, __v_50, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_18, __v_27, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_18, __v_25, __v_53, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_18, __v_35, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_56: G = { let __values: [G; 4] = [__v_18, __v_35, __v_55, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = { let __values: [G; 4] = [__v_18, __v_35, __v_56, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_58: G = { let __values: [G; 4] = [__v_18, __v_35, __v_57, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_59: G = { let __values: [G; 4] = [__v_18, __v_54, __v_58, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_60: G = { let __values: [G; 4] = [__v_18, __v_22, __v_59, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_61: G = { let __values: [G; 4] = [__v_18, __v_60, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_62: G = { let __values: [G; 4] = [__v_18, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_63: G = G::from_u64(100); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_64: G = __r_arr[0]; let __v_65: G = { let __values: [G; 4] = [__v_8, __v_64, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_66: G = G::from_u64(40); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_66]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __v_68: G = { let __values: [G; 4] = [__v_8, __v_67, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_69: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_70: G = { let __values: [G; 4] = [__v_18, __v_68, __v_69, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_71: G = { let __values: [G; 4] = [__v_18, __v_65, __v_70, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_72: G = { let __values: [G; 4] = [__v_18, __v_62, __v_71, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_73: G = { let __values: [G; 4] = [__v_18, __v_72, __v_36, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_74: G = { let __values: [G; 4] = [__v_46, __v_61, __v_73, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_75: G = { let __values: [G; 4] = [__v_46, __v_51, __v_74, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_76: G = { let __values: [G; 4] = [__v_46, __v_11, __v_75, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_76]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6402u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_19: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_18, __v_17, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_18, __v_27, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 4] = [__v_8, __v_32, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_18, __v_27, __v_30, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_18, __v_33, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_18, __v_35, __v_30, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 4] = [__v_8, __v_38, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_18, __v_27, __v_36, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = G::from_u64(5); let __v_42: G = { let __values: [G; 4] = [__v_18, __v_35, __v_36, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_18, __v_35, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_18, __v_35, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_18, __v_35, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_18, __v_35, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_18, __v_35, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_18, __v_35, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_18, __v_35, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_18, __v_35, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_18, __v_35, __v_50, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_18, __v_25, __v_51, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_18, __v_52, __v_53, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_18, __v_22, __v_54, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_56: G = { let __values: [G; 4] = [__v_18, __v_55, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_58: G = { let __values: [G; 4] = [__v_18, __v_27, __v_57, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_59: G = { let __values: [G; 4] = [__v_18, __v_25, __v_58, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_60: G = { let __values: [G; 4] = [__v_18, __v_35, __v_40, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_61: G = { let __values: [G; 4] = [__v_18, __v_35, __v_60, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_62: G = { let __values: [G; 4] = [__v_18, __v_27, __v_61, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_63: G = { let __values: [G; 4] = [__v_18, __v_35, __v_62, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_64: G = { let __values: [G; 4] = [__v_18, __v_27, __v_63, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_65: G = { let __values: [G; 4] = [__v_18, __v_35, __v_64, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_66: G = { let __values: [G; 4] = [__v_18, __v_35, __v_65, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_67: G = { let __values: [G; 4] = [__v_18, __v_35, __v_66, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_68: G = { let __values: [G; 4] = [__v_18, __v_35, __v_67, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_69: G = { let __values: [G; 4] = [__v_18, __v_35, __v_68, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_70: G = { let __values: [G; 4] = [__v_18, __v_35, __v_69, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_71: G = { let __values: [G; 4] = [__v_18, __v_35, __v_70, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_72: G = { let __values: [G; 4] = [__v_18, __v_35, __v_71, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_73: G = { let __values: [G; 4] = [__v_18, __v_35, __v_72, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_74: G = { let __values: [G; 4] = [__v_18, __v_35, __v_73, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_75: G = { let __values: [G; 4] = [__v_18, __v_35, __v_74, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_76: G = { let __values: [G; 4] = [__v_18, __v_59, __v_75, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_77: G = { let __values: [G; 4] = [__v_18, __v_22, __v_76, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_78: G = { let __values: [G; 4] = [__v_18, __v_77, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_79: G = { let __values: [G; 4] = [__v_18, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_80: G = G::from_u64(100); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __v_82: G = { let __values: [G; 4] = [__v_8, __v_81, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_83: G = G::from_u64(40); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __v_85: G = { let __values: [G; 4] = [__v_8, __v_84, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_86: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_87: G = { let __values: [G; 4] = [__v_18, __v_85, __v_86, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_88: G = { let __values: [G; 4] = [__v_18, __v_82, __v_87, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_89: G = { let __values: [G; 4] = [__v_18, __v_79, __v_88, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_90: G = { let __values: [G; 4] = [__v_18, __v_89, __v_40, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_91: G = { let __values: [G; 4] = [__v_41, __v_78, __v_90, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_92: G = { let __values: [G; 4] = [__v_41, __v_56, __v_91, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_93: G = { let __values: [G; 4] = [__v_41, __v_11, __v_92, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_93]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6403u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_19: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_18, __v_17, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_18, __v_27, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 4] = [__v_8, __v_32, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_18, __v_27, __v_30, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_18, __v_33, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_18, __v_35, __v_30, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_18, __v_27, __v_36, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = { let __values: [G; 4] = [__v_8, __v_39, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = G::from_u64(5); let __v_42: G = { let __values: [G; 4] = [__v_18, __v_35, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_18, __v_27, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_18, __v_35, __v_43, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_18, __v_35, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_18, __v_35, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_18, __v_35, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_18, __v_35, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_18, __v_35, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_18, __v_35, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_18, __v_35, __v_50, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_18, __v_35, __v_51, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_18, __v_35, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_18, __v_35, __v_53, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_18, __v_35, __v_54, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_56: G = { let __values: [G; 4] = [__v_18, __v_35, __v_55, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = { let __values: [G; 4] = [__v_18, __v_25, __v_56, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_58: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_59: G = { let __values: [G; 4] = [__v_18, __v_57, __v_58, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_60: G = { let __values: [G; 4] = [__v_18, __v_22, __v_59, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_61: G = { let __values: [G; 4] = [__v_18, __v_60, __v_40, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_62: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_63: G = { let __values: [G; 4] = [__v_18, __v_27, __v_62, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_64: G = { let __values: [G; 4] = [__v_18, __v_25, __v_63, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_65: G = { let __values: [G; 4] = [__v_18, __v_35, __v_36, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_66: G = { let __values: [G; 4] = [__v_18, __v_35, __v_65, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_67: G = { let __values: [G; 4] = [__v_18, __v_35, __v_66, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_68: G = { let __values: [G; 4] = [__v_18, __v_35, __v_67, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_69: G = { let __values: [G; 4] = [__v_18, __v_35, __v_68, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_70: G = { let __values: [G; 4] = [__v_18, __v_35, __v_69, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_71: G = { let __values: [G; 4] = [__v_18, __v_35, __v_70, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_72: G = { let __values: [G; 4] = [__v_18, __v_35, __v_71, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_73: G = { let __values: [G; 4] = [__v_18, __v_35, __v_72, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_74: G = { let __values: [G; 4] = [__v_18, __v_35, __v_73, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_75: G = { let __values: [G; 4] = [__v_18, __v_35, __v_74, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_76: G = { let __values: [G; 4] = [__v_18, __v_35, __v_75, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_77: G = { let __values: [G; 4] = [__v_18, __v_35, __v_76, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_78: G = { let __values: [G; 4] = [__v_18, __v_35, __v_77, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_79: G = { let __values: [G; 4] = [__v_18, __v_35, __v_78, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_80: G = { let __values: [G; 4] = [__v_18, __v_64, __v_79, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_81: G = { let __values: [G; 4] = [__v_18, __v_22, __v_80, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_82: G = { let __values: [G; 4] = [__v_18, __v_81, __v_40, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_83: G = { let __values: [G; 4] = [__v_18, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_84: G = G::from_u64(100); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_84]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_85: G = __r_arr[0]; let __v_86: G = { let __values: [G; 4] = [__v_8, __v_85, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_87: G = G::from_u64(40); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_87]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_88: G = __r_arr[0]; let __v_89: G = { let __values: [G; 4] = [__v_8, __v_88, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_90: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_91: G = { let __values: [G; 4] = [__v_18, __v_89, __v_90, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_92: G = { let __values: [G; 4] = [__v_18, __v_86, __v_91, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_93: G = { let __values: [G; 4] = [__v_18, __v_83, __v_92, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_94: G = { let __values: [G; 4] = [__v_18, __v_93, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_95: G = { let __values: [G; 4] = [__v_41, __v_82, __v_94, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_96: G = { let __values: [G; 4] = [__v_41, __v_61, __v_95, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_97: G = { let __values: [G; 4] = [__v_41, __v_11, __v_96, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_97]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6404u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_13, __v_16, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_19: G = G::from_u64(4); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 4] = [__v_8, __v_20, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_18, __v_17, __v_21, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(47); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_8, __v_24, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_18, __v_27, __v_29, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 4] = [__v_8, __v_32, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_18, __v_27, __v_30, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_18, __v_33, __v_34, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_18, __v_35, __v_30, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = { let __values: [G; 4] = [__v_18, __v_35, __v_36, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_18, __v_35, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_18, __v_35, __v_38, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = G::from_u64(6); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 4] = [__v_8, __v_41, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = G::from_u64(5); let __v_44: G = { let __values: [G; 4] = [__v_18, __v_35, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_18, __v_35, __v_44, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_18, __v_35, __v_45, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_18, __v_35, __v_46, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_18, __v_35, __v_47, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_18, __v_35, __v_48, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_18, __v_35, __v_49, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_18, __v_35, __v_50, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_18, __v_35, __v_51, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_18, __v_35, __v_52, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_18, __v_35, __v_53, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_18, __v_35, __v_54, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_56: G = { let __values: [G; 4] = [__v_18, __v_25, __v_55, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = { let __values: [G; 4] = [__v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_58: G = { let __values: [G; 4] = [__v_18, __v_56, __v_57, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_59: G = { let __values: [G; 4] = [__v_18, __v_22, __v_58, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_60: G = { let __values: [G; 4] = [__v_18, __v_59, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_61: G = { let __values: [G; 4] = [__v_9, __v_6, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_62: G = { let __values: [G; 4] = [__v_18, __v_27, __v_61, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_63: G = { let __values: [G; 4] = [__v_18, __v_25, __v_62, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_64: G = { let __values: [G; 4] = [__v_18, __v_27, __v_39, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_65: G = { let __values: [G; 4] = [__v_18, __v_35, __v_64, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_66: G = { let __values: [G; 4] = [__v_18, __v_35, __v_65, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_67: G = { let __values: [G; 4] = [__v_18, __v_35, __v_66, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_68: G = { let __values: [G; 4] = [__v_18, __v_35, __v_67, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_69: G = { let __values: [G; 4] = [__v_18, __v_35, __v_68, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_70: G = { let __values: [G; 4] = [__v_18, __v_35, __v_69, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_71: G = { let __values: [G; 4] = [__v_18, __v_35, __v_70, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_72: G = { let __values: [G; 4] = [__v_18, __v_35, __v_71, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_73: G = { let __values: [G; 4] = [__v_18, __v_35, __v_72, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_74: G = { let __values: [G; 4] = [__v_18, __v_35, __v_73, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_75: G = { let __values: [G; 4] = [__v_18, __v_35, __v_74, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_76: G = { let __values: [G; 4] = [__v_18, __v_35, __v_75, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_77: G = { let __values: [G; 4] = [__v_18, __v_35, __v_76, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_78: G = { let __values: [G; 4] = [__v_18, __v_35, __v_77, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_79: G = { let __values: [G; 4] = [__v_18, __v_35, __v_78, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_80: G = { let __values: [G; 4] = [__v_18, __v_35, __v_79, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_81: G = { let __values: [G; 4] = [__v_18, __v_63, __v_80, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_82: G = { let __values: [G; 4] = [__v_18, __v_22, __v_81, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_83: G = { let __values: [G; 4] = [__v_18, __v_82, __v_42, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_84: G = { let __values: [G; 4] = [__v_18, __v_17, __v_11, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_85: G = G::from_u64(100); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_85]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_86: G = __r_arr[0]; let __v_87: G = { let __values: [G; 4] = [__v_8, __v_86, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_88: G = G::from_u64(40); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_88]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_89: G = __r_arr[0]; let __v_90: G = { let __values: [G; 4] = [__v_8, __v_89, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_91: G = { let __values: [G; 4] = [__v_9, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_92: G = { let __values: [G; 4] = [__v_18, __v_90, __v_91, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_93: G = { let __values: [G; 4] = [__v_18, __v_87, __v_92, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_94: G = { let __values: [G; 4] = [__v_18, __v_84, __v_93, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_95: G = { let __values: [G; 4] = [__v_18, __v_94, __v_37, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_96: G = { let __values: [G; 4] = [__v_43, __v_83, __v_95, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_97: G = { let __values: [G; 4] = [__v_43, __v_60, __v_96, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_98: G = { let __values: [G; 4] = [__v_43, __v_11, __v_97, __v_9]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_98]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6464u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = G::from_u64(3); let __v_11: G = G::from_u64(2); let __v_12: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_8, __v_7, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_14, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_11, __v_13, __v_15, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_11, __v_17, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_10, __v_16, __v_18, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(101); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_11, __v_21, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(38); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 4] = [__v_11, __v_24, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = G::from_u64(30); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 3] = [__v_6, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_11, __v_27, __v_28, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_11, __v_31, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_10, __v_29, __v_32, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_10, __v_25, __v_33, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = { let __values: [G; 4] = [__v_10, __v_22, __v_34, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_10, __v_19, __v_35, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = { let __values: [G; 4] = [__v_11, __v_37, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_10, __v_36, __v_38, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_39]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6465u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(101); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 4] = [__v_8, __v_16, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(38); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = { let __values: [G; 4] = [__v_11, __v_6, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_22: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = G::from_u64(5); let __v_24: G = G::from_u64(3); let __v_25: G = G::from_u64(29); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_8, __v_26, __v_14, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_24, __v_27, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = { let __values: [G; 3] = [__v_6, __v_13, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_31, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_30, __v_32, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 4] = [__v_8, __v_34, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_36: G = { let __values: [G; 4] = [__v_24, __v_33, __v_35, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(31); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 4] = [__v_8, __v_38, __v_14, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_24, __v_39, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_24, __v_40, __v_21, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_24, __v_41, __v_22, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_24, __v_20, __v_42, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_24, __v_17, __v_43, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_24, __v_36, __v_44, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = G::from_u64(42); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = { let __values: [G; 4] = [__v_8, __v_47, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = G::from_u64(100); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = { let __values: [G; 4] = [__v_8, __v_50, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_24, __v_51, __v_21, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_24, __v_48, __v_52, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_24, __v_20, __v_22, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_24, __v_17, __v_54, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_56: G = { let __values: [G; 4] = [__v_24, __v_53, __v_55, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = { let __values: [G; 4] = [__v_24, __v_45, __v_56, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_58: G = { let __values: [G; 4] = [__v_23, __v_28, __v_57, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_59: G = { let __values: [G; 4] = [__v_23, __v_12, __v_58, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_59]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6528u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_10: G = G::from_u64(2); let __v_11: G = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_10, __v_12, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_476] = { let __args: [G; IN_476] = [__v_0, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 4] = [__v_10, __v_14, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 4] = [__v_10, __v_17, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_19: G = { let __values: [G; 4] = [__v_16, __v_15, __v_18, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_20: G = G::from_u64(44); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 4] = [__v_10, __v_21, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_16, __v_15, __v_19, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = { let __values: [G; 4] = [__v_16, __v_22, __v_23, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 3] = [__v_8, __v_7, __v_6]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_27, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_10, __v_26, __v_28, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = { let __values: [G; 4] = [__v_16, __v_29, __v_13, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_31: G = G::from_u64(102); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 4] = [__v_10, __v_32, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = G::from_u64(38); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_10, __v_35, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_37: G = G::from_u64(30); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __values: [G; 3] = [__v_6, __v_7, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_40: G = { let __values: [G; 4] = [__v_10, __v_38, __v_39, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_16, __v_40, __v_13, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_16, __v_36, __v_41, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_16, __v_33, __v_42, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_16, __v_30, __v_43, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = G::from_u64(40); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = { let __values: [G; 4] = [__v_10, __v_46, __v_9, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_16, __v_24, __v_19, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_16, __v_24, __v_48, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_16, __v_24, __v_49, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_16, __v_24, __v_50, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_16, __v_24, __v_51, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_53: G = { let __values: [G; 4] = [__v_16, __v_24, __v_52, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_54: G = { let __values: [G; 4] = [__v_16, __v_15, __v_53, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_55: G = { let __values: [G; 4] = [__v_16, __v_47, __v_54, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_56: G = { let __values: [G; 4] = [__v_16, __v_44, __v_55, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_56]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6529u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(5); let __v_17: G = G::from_u64(3); let __v_18: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 3] = [__v_6, __v_13, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_20, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_19, __v_21, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_23: G = { let __values: [G; 4] = [__v_17, __v_22, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_24: G = G::from_u64(102); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 4] = [__v_8, __v_25, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = G::from_u64(38); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_8, __v_28, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(31); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 4] = [__v_8, __v_31, __v_14, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_33: G = { let __values: [G; 4] = [__v_17, __v_32, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_17, __v_33, __v_15, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = G::from_u64(30); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 4] = [__v_8, __v_36, __v_14, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_38: G = { let __values: [G; 4] = [__v_17, __v_37, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_39: G = { let __values: [G; 4] = [__v_17, __v_34, __v_38, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_17, __v_29, __v_39, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_17, __v_26, __v_40, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_17, __v_23, __v_41, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_17, __v_42, __v_15, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_16, __v_12, __v_43, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_44]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6530u64 => { 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(1).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 = G::from_u64(2); let __v_9: G = G::from_u64(39); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_8, __v_10, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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; 3] = [__v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_13, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(102); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 4] = [__v_8, __v_16, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(38); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 4] = [__v_8, __v_19, __v_7, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = G::from_u64(3); let __v_22: G = G::from_u64(31); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = { let __values: [G; 4] = [__v_8, __v_23, __v_14, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_25: G = { let __values: [G; 4] = [__v_21, __v_24, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_26: G = { let __values: [G; 4] = [__v_11, __v_6, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_27: G = { let __values: [G; 4] = [__v_21, __v_25, __v_26, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_28: G = { let __values: [G; 4] = [__v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_29: G = { let __values: [G; 4] = [__v_21, __v_27, __v_28, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_30: G = G::from_u64(5); let __v_31: G = G::from_u64(29); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 4] = [__v_8, __v_32, __v_14, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_34: G = { let __values: [G; 4] = [__v_21, __v_33, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = G::from_u64(8); let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(476, &__args[..])?) { [G::ZERO; OUT_476] } else { let (__hash, __hit) = record.function_queries[476].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[476].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => { aiur_fn_476::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 3] = [__v_6, __v_13, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_11, __v_37, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_8, __v_36, __v_38, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_40: G = { let __values: [G; 4] = [__v_21, __v_39, __v_12, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_41: G = { let __values: [G; 4] = [__v_11, __v_8, __v_11, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_42: G = { let __values: [G; 4] = [__v_21, __v_25, __v_41, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_43: G = { let __values: [G; 4] = [__v_21, __v_42, __v_29, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_44: G = { let __values: [G; 4] = [__v_21, __v_20, __v_43, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_45: G = { let __values: [G; 4] = [__v_21, __v_17, __v_44, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = { let __values: [G; 4] = [__v_21, __v_40, __v_45, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_47: G = { let __values: [G; 4] = [__v_21, __v_20, __v_29, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_48: G = { let __values: [G; 4] = [__v_21, __v_17, __v_47, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_49: G = { let __values: [G; 4] = [__v_21, __v_46, __v_48, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_50: G = { let __values: [G; 4] = [__v_30, __v_34, __v_49, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_51: G = { let __values: [G; 4] = [__v_30, __v_12, __v_50, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_52: G = { let __values: [G; 4] = [__v_30, __v_12, __v_51, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_52]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_6, __v_8, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_567] = [__v_9]; record.function_queries[567].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_568: usize = 1; -const IN_568: usize = 1; -const OUT_568: usize = 2; -fn aiur_fn_568(inp: [G; IN_568], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_568], ExecError> { 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() { 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_568] = [__v_1, __v_1]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 38u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(1); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 41u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(2); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 42u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(3); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 43u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(4); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 44u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(5); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 45u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(9); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 46u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(15); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 47u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(16); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 48u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(6); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 49u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(7); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 50u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(8); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 51u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(10); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 52u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(11); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 53u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(12); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 54u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(13); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 55u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(14); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 67u64 => { let __v_1: G = G::from_u64(5); let __v_2: G = G::from_u64(3); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 68u64 => { let __v_1: G = G::from_u64(5); let __v_2: G = G::from_u64(2); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 69u64 => { let __v_1: G = G::from_u64(5); let __v_2: G = G::from_u64(1); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 75u64 => { let __v_1: G = G::from_u64(6); let __v_2: G = G::from_u64(1); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 76u64 => { let __v_1: G = G::from_u64(6); let __ret: [G; OUT_568] = [__v_1, __v_1]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 77u64 => { let __v_1: G = G::from_u64(6); let __v_2: G = G::from_u64(7); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 78u64 => { let __v_1: G = G::from_u64(6); let __v_2: G = G::from_u64(8); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 79u64 => { let __v_1: G = G::from_u64(6); let __v_2: G = G::from_u64(2); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 80u64 => { let __v_1: G = G::from_u64(6); let __v_2: G = G::from_u64(10); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 81u64 => { let __v_1: G = G::from_u64(6); let __v_2: G = G::from_u64(9); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 82u64 => { let __v_1: G = G::from_u64(6); let __v_2: G = G::from_u64(5); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 85u64 => { let __v_1: G = G::from_u64(3); let __v_2: G = G::from_u64(1); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 86u64 => { let __v_1: G = G::from_u64(3); let __v_2: G = G::from_u64(2); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 87u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(5); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 90u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(4); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 92u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(6); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 95u64 => { let __v_1: G = G::from_u64(5); let __v_2: G = G::from_u64(6); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 96u64 => { let __v_1: G = G::from_u64(5); let __ret: [G; OUT_568] = [__v_1, __v_1]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 97u64 => { let __v_1: G = G::from_u64(5); let __v_2: G = G::from_u64(4); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 98u64 => { let __v_1: G = G::from_u64(6); let __v_2: G = G::from_u64(3); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 99u64 => { let __v_1: G = G::from_u64(6); let __v_2: G = G::from_u64(4); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 101u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_568] = [__v_1, __v_1]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 102u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(3); let __ret: [G; OUT_568] = [__v_1, __v_2]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_568] = [__v_1, __v_1]; record.function_queries[568].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_569: usize = 12; -const IN_569: usize = 12; -const OUT_569: usize = 1; -fn aiur_fn_569(inp: [G; IN_569], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_569], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_569] = [__v_3]; record.function_queries[569].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { match __v_4.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_569] = [__v_12]; record.function_queries[569].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_569] = [__v_12]; record.function_queries[569].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_569] = [__v_12]; record.function_queries[569].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_569] = [__v_4]; record.function_queries[569].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_569] = [__v_12]; record.function_queries[569].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_569] = [__v_6]; record.function_queries[569].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __ret: [G; OUT_569] = [__v_8]; record.function_queries[569].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_569] = [__v_9]; record.function_queries[569].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_570: usize = 1; -const IN_570: usize = 1; -const OUT_570: usize = 1; -fn aiur_fn_570(inp: [G; IN_570], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_570], ExecError> { stacker::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(2).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 __v_5: G = G::from_u64(1); let __ret: [G; OUT_570] = [__v_5]; record.function_queries[570].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_570] = [__v_5]; record.function_queries[570].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; let __v_10: G = __loaded[4]; let __v_11: G = __loaded[5]; let __v_12: G = __loaded[6]; let __v_13: G = __loaded[7]; let __v_14: G = __loaded[8]; let __v_15: G = __loaded[9]; let __v_16: G = __loaded[10]; let __v_17: G = __loaded[11]; let __v_18: G = G::from_u64(1); let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(569, &__args[..])?) { [G::ZERO; OUT_569] } else { let (__hash, __hit) = record.function_queries[569].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[569].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[569].bump_multiplicity(__i); } let __ret: [G; OUT_569] = unsafe { *(record.function_queries[569].output_at(__i).as_ptr() as *const [G; OUT_569]) }; __ret }, _ => { aiur_fn_569::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __v_18 - __v_19; let __ret: [G; OUT_570] = [__v_20]; record.function_queries[570].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(570, &__args[..])?) { [G::ZERO; OUT_570] } else { let (__hash, __hit) = record.function_queries[570].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[570].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[570].bump_multiplicity(__i); } let __ret: [G; OUT_570] = unsafe { *(record.function_queries[570].output_at(__i).as_ptr() as *const [G; OUT_570]) }; __ret }, _ => { aiur_fn_570::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(570, &__args[..])?) { [G::ZERO; OUT_570] } else { let (__hash, __hit) = record.function_queries[570].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[570].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[570].bump_multiplicity(__i); } let __ret: [G; OUT_570] = unsafe { *(record.function_queries[570].output_at(__i).as_ptr() as *const [G; OUT_570]) }; __ret }, _ => { aiur_fn_570::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __v_5 * __v_6; let __ret: [G; OUT_570] = [__v_7]; record.function_queries[570].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(570, &__args[..])?) { [G::ZERO; OUT_570] } else { let (__hash, __hit) = record.function_queries[570].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[570].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[570].bump_multiplicity(__i); } let __ret: [G; OUT_570] = unsafe { *(record.function_queries[570].output_at(__i).as_ptr() as *const [G; OUT_570]) }; __ret }, _ => { aiur_fn_570::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(570, &__args[..])?) { [G::ZERO; OUT_570] } else { let (__hash, __hit) = record.function_queries[570].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[570].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[570].bump_multiplicity(__i); } let __ret: [G; OUT_570] = unsafe { *(record.function_queries[570].output_at(__i).as_ptr() as *const [G; OUT_570]) }; __ret }, _ => { aiur_fn_570::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __v_5 * __v_6; let __ret: [G; OUT_570] = [__v_7]; record.function_queries[570].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(570, &__args[..])?) { [G::ZERO; OUT_570] } else { let (__hash, __hit) = record.function_queries[570].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[570].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[570].bump_multiplicity(__i); } let __ret: [G; OUT_570] = unsafe { *(record.function_queries[570].output_at(__i).as_ptr() as *const [G; OUT_570]) }; __ret }, _ => { aiur_fn_570::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(570, &__args[..])?) { [G::ZERO; OUT_570] } else { let (__hash, __hit) = record.function_queries[570].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[570].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[570].bump_multiplicity(__i); } let __ret: [G; OUT_570] = unsafe { *(record.function_queries[570].output_at(__i).as_ptr() as *const [G; OUT_570]) }; __ret }, _ => { aiur_fn_570::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __v_5 * __v_6; let __ret: [G; OUT_570] = [__v_7]; record.function_queries[570].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(570, &__args[..])?) { [G::ZERO; OUT_570] } else { let (__hash, __hit) = record.function_queries[570].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[570].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[570].bump_multiplicity(__i); } let __ret: [G; OUT_570] = unsafe { *(record.function_queries[570].output_at(__i).as_ptr() as *const [G; OUT_570]) }; __ret }, _ => { aiur_fn_570::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(570, &__args[..])?) { [G::ZERO; OUT_570] } else { let (__hash, __hit) = record.function_queries[570].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[570].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[570].bump_multiplicity(__i); } let __ret: [G; OUT_570] = unsafe { *(record.function_queries[570].output_at(__i).as_ptr() as *const [G; OUT_570]) }; __ret }, _ => { aiur_fn_570::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = __v_5 * __v_6; let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(570, &__args[..])?) { [G::ZERO; OUT_570] } else { let (__hash, __hit) = record.function_queries[570].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[570].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[570].bump_multiplicity(__i); } let __ret: [G; OUT_570] = unsafe { *(record.function_queries[570].output_at(__i).as_ptr() as *const [G; OUT_570]) }; __ret }, _ => { aiur_fn_570::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __v_7 * __v_8; let __ret: [G; OUT_570] = [__v_9]; record.function_queries[570].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_570] = [__v_5]; record.function_queries[570].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(570, &__args[..])?) { [G::ZERO; OUT_570] } else { let (__hash, __hit) = record.function_queries[570].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[570].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[570].bump_multiplicity(__i); } let __ret: [G; OUT_570] = unsafe { *(record.function_queries[570].output_at(__i).as_ptr() as *const [G; OUT_570]) }; __ret }, _ => { aiur_fn_570::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_570] = [__v_5]; record.function_queries[570].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_571: usize = 2; -const IN_571: usize = 2; -const OUT_571: usize = 0; -fn aiur_fn_571(inp: [G; IN_571], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_571], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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() { 1u64 => { let __ret: [G; OUT_571] = []; record.function_queries[571].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(570, &__args[..])?) { [G::ZERO; OUT_570] } else { let (__hash, __hit) = record.function_queries[570].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[570].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[570].bump_multiplicity(__i); } let __ret: [G; OUT_570] = unsafe { *(record.function_queries[570].output_at(__i).as_ptr() as *const [G; OUT_570]) }; __ret }, _ => { aiur_fn_570::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); if (__v_2 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("safe constant references an unsafe constant".to_string()) }); } let __ret: [G; OUT_571] = []; record.function_queries[571].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_572: usize = 2; -const IN_572: usize = 2; -const OUT_572: usize = 0; -fn aiur_fn_572(inp: [G; IN_572], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_572], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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 __ret: [G; OUT_572] = []; record.function_queries[572].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(572, &__args[..])?) { [G::ZERO; OUT_572] } else { let (__hash, __hit) = record.function_queries[572].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[572].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[572].bump_multiplicity(__i); } let __ret: [G; OUT_572] = unsafe { *(record.function_queries[572].output_at(__i).as_ptr() as *const [G; OUT_572]) }; __ret }, _ => { aiur_fn_572::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_572] = []; record.function_queries[572].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(572, &__args[..])?) { [G::ZERO; OUT_572] } else { let (__hash, __hit) = record.function_queries[572].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[572].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[572].bump_multiplicity(__i); } let __ret: [G; OUT_572] = unsafe { *(record.function_queries[572].output_at(__i).as_ptr() as *const [G; OUT_572]) }; __ret }, _ => { aiur_fn_572::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(572, &__args[..])?) { [G::ZERO; OUT_572] } else { let (__hash, __hit) = record.function_queries[572].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[572].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[572].bump_multiplicity(__i); } let __ret: [G; OUT_572] = unsafe { *(record.function_queries[572].output_at(__i).as_ptr() as *const [G; OUT_572]) }; __ret }, _ => { aiur_fn_572::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_572] = []; record.function_queries[572].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(572, &__args[..])?) { [G::ZERO; OUT_572] } else { let (__hash, __hit) = record.function_queries[572].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[572].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[572].bump_multiplicity(__i); } let __ret: [G; OUT_572] = unsafe { *(record.function_queries[572].output_at(__i).as_ptr() as *const [G; OUT_572]) }; __ret }, _ => { aiur_fn_572::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(572, &__args[..])?) { [G::ZERO; OUT_572] } else { let (__hash, __hit) = record.function_queries[572].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[572].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[572].bump_multiplicity(__i); } let __ret: [G; OUT_572] = unsafe { *(record.function_queries[572].output_at(__i).as_ptr() as *const [G; OUT_572]) }; __ret }, _ => { aiur_fn_572::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_572] = []; record.function_queries[572].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_5: G = { let __a_val = __v_3.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 __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("universe param index out of range".to_string()) }); } let __ret: [G; OUT_572] = []; record.function_queries[572].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_573: usize = 2; -const IN_573: usize = 2; -const OUT_573: usize = 0; -fn aiur_fn_573(inp: [G; IN_573], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_573], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_573] = []; record.function_queries[573].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(572, &__args[..])?) { [G::ZERO; OUT_572] } else { let (__hash, __hit) = record.function_queries[572].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[572].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[572].bump_multiplicity(__i); } let __ret: [G; OUT_572] = unsafe { *(record.function_queries[572].output_at(__i).as_ptr() as *const [G; OUT_572]) }; __ret }, _ => { aiur_fn_572::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(573, &__args[..])?) { [G::ZERO; OUT_573] } else { let (__hash, __hit) = record.function_queries[573].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[573].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[573].bump_multiplicity(__i); } let __ret: [G; OUT_573] = unsafe { *(record.function_queries[573].output_at(__i).as_ptr() as *const [G; OUT_573]) }; __ret }, _ => { aiur_fn_573::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_573] = []; record.function_queries[573].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_574: usize = 3; -const IN_574: usize = 3; -const OUT_574: usize = 0; -fn aiur_fn_574(inp: [G; IN_574], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_574], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { let __v_7: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_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 __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("loose bound variable: BVar index exceeds binder depth".to_string()) }); } let __ret: [G; OUT_574] = []; record.function_queries[574].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_4, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(572, &__args[..])?) { [G::ZERO; OUT_572] } else { let (__hash, __hit) = record.function_queries[572].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[572].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[572].bump_multiplicity(__i); } let __ret: [G; OUT_572] = unsafe { *(record.function_queries[572].output_at(__i).as_ptr() as *const [G; OUT_572]) }; __ret }, _ => { aiur_fn_572::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_574] = []; record.function_queries[574].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].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 __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(372, &__args[..])?) { [G::ZERO; OUT_372] } else { let (__hash, __hit) = record.function_queries[372].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[372].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => { aiur_fn_372::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(573, &__args[..])?) { [G::ZERO; OUT_573] } else { let (__hash, __hit) = record.function_queries[573].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[573].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[573].bump_multiplicity(__i); } let __ret: [G; OUT_573] = unsafe { *(record.function_queries[573].output_at(__i).as_ptr() as *const [G; OUT_573]) }; __ret }, _ => { aiur_fn_573::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_574] = []; record.function_queries[574].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_574] = []; record.function_queries[574].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 + __v_7; let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_574] = []; record.function_queries[574].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 + __v_7; let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_574] = []; record.function_queries[574].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = G::from_u64(1); let __v_8: G = __v_1 + __v_7; let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_574] = []; record.function_queries[574].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_574] = []; record.function_queries[574].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_574] = []; record.function_queries[574].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_575: usize = 3; -const IN_575: usize = 3; -const OUT_575: usize = 0; -fn aiur_fn_575(inp: [G; IN_575], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_575], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(32); break '__mc_0 [__v_3]; }, 1u64 => { let __v_3: G = G::from_u64(33); break '__mc_0 [__v_3]; }, 2u64 => { let __v_3: G = G::from_u64(34); break '__mc_0 [__v_3]; }, 3u64 => { let __v_3: G = G::from_u64(35); break '__mc_0 [__v_3]; }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }; let __v_3: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(480, &__args[..])?) { [G::ZERO; OUT_480] } else { let (__hash, __hit) = record.function_queries[480].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[480].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => { aiur_fn_480::(__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: Some("a quotient constant is not the binding's quotient role of its kind".to_string()) }); } let __ret: [G; OUT_575] = []; record.function_queries[575].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_576: usize = 2; -const IN_576: usize = 2; -const OUT_576: usize = 1; -fn aiur_fn_576(inp: [G; IN_576], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_576], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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_576] = [__v_0]; record.function_queries[576].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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() { 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = __v_1 - __v_6; let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(576, &__args[..])?) { [G::ZERO; OUT_576] } else { let (__hash, __hit) = record.function_queries[576].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[576].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => { aiur_fn_576::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_576] = [__v_8]; record.function_queries[576].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_577: usize = 3; -const IN_577: usize = 3; -const OUT_577: usize = 0; -fn aiur_fn_577(inp: [G; IN_577], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_577], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("more universe levels than the inductive declares".to_string()) }); } let __ret: [G; OUT_577] = []; record.function_queries[577].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(1).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() { 0u64 => { let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 4u64 => { if (__v_7 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor return type: universe level is not Param(i) in order".to_string()) }); } let __v_9: G = G::from_u64(1); let __v_10: G = __v_1 - __v_9; let __v_11: G = __v_2 + __v_9; let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(577, &__args[..])?) { [G::ZERO; OUT_577] } else { let (__hash, __hit) = record.function_queries[577].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[577].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[577].bump_multiplicity(__i); } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => { aiur_fn_577::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_577] = []; record.function_queries[577].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_578: usize = 4; -const IN_578: usize = 4; -const OUT_578: usize = 0; -fn aiur_fn_578(inp: [G; IN_578], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_578], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_1 - __v_3; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_578] = []; record.function_queries[578].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(1).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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 0u64 => { let __v_12: G = __v_2 + __v_1; let __v_13: G = G::from_u64(1); let __v_14: G = __v_12 - __v_13; let __v_15: G = __v_14 - __v_3; if (__v_9 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("ctor return type: param arg is not the expected param BVar".to_string()) }); } let __v_16: G = __v_3 + __v_13; let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_7, __v_1, __v_2, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(578, &__args[..])?) { [G::ZERO; OUT_578] } else { let (__hash, __hit) = record.function_queries[578].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[578].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[578].bump_multiplicity(__i); } let __ret: [G; OUT_578] = unsafe { *(record.function_queries[578].output_at(__i).as_ptr() as *const [G; OUT_578]) }; __ret }, _ => { aiur_fn_578::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_578] = []; record.function_queries[578].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_579: usize = 3; -const IN_579: usize = 3; -const OUT_579: usize = 0; -fn aiur_fn_579(inp: [G; IN_579], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_579], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_234] = { let __args: [G; IN_234] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; let __v_8: G = __loaded[4]; let __v_9: G = __loaded[5]; let __v_10: G = __loaded[6]; let __v_11: G = __loaded[7]; let __v_12: G = __loaded[8]; let __v_13: G = __loaded[9]; let __v_14: G = __loaded[10]; let __v_15: G = __loaded[11]; match __v_4.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_11, __v_1]; 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_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: Some("ctor return head belongs to a different block".to_string()) }); } if (__v_12 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor return head is a different member of the block".to_string()) }); } let __ret: [G; OUT_579] = []; record.function_queries[579].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_580: usize = 7; -const IN_580: usize = 7; -const OUT_580: usize = 0; -fn aiur_fn_580(inp: [G; IN_580], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_580], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = __v_1 + __v_3; let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(576, &__args[..])?) { [G::ZERO; OUT_576] } else { let (__hash, __hit) = record.function_queries[576].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[576].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => { aiur_fn_576::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_12, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(579, &__args[..])?) { [G::ZERO; OUT_579] } else { let (__hash, __hit) = record.function_queries[579].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[579].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[579].bump_multiplicity(__i); } let __ret: [G; OUT_579] = unsafe { *(record.function_queries[579].output_at(__i).as_ptr() as *const [G; OUT_579]) }; __ret }, _ => { aiur_fn_579::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(577, &__args[..])?) { [G::ZERO; OUT_577] } else { let (__hash, __hit) = record.function_queries[577].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[577].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[577].bump_multiplicity(__i); } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => { aiur_fn_577::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __v_1 + __v_2; if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("ctor return type: wrong number of spine arguments".to_string()) }); } let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_10, __v_1, __v_3, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(578, &__args[..])?) { [G::ZERO; OUT_578] } else { let (__hash, __hit) = record.function_queries[578].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[578].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[578].bump_multiplicity(__i); } let __ret: [G; OUT_578] = unsafe { *(record.function_queries[578].output_at(__i).as_ptr() as *const [G; OUT_578]) }; __ret }, _ => { aiur_fn_578::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_10, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = { let __values: [G; 3] = [__v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_index_mut(1).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_15, __v_5, __v_20]; let __mq = record.memory_queries.get_index_mut(1).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_591] = { let __args: [G; IN_591] = [__v_18, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(591, &__args[..])?) { [G::ZERO; OUT_591] } else { let (__hash, __hit) = record.function_queries[591].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[591].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => { aiur_fn_591::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; if (__v_22 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("ctor return type: reflexive occurrence in an index argument".to_string()) }); } let __ret: [G; OUT_580] = []; record.function_queries[580].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); }, } }) } -const INPUT_SIZE_581: usize = 5; -const IN_581: usize = 5; -const OUT_581: usize = 0; -fn aiur_fn_581(inp: [G; IN_581], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_581], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __ret: [G; OUT_581] = []; record.function_queries[581].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 5u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_6, __v_10, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("ctor parameter type disagrees with the inductive's".to_string()) }); } let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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 = __v_3 - __v_14; let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_0, __v_7, __v_11, __v_17, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(581, &__args[..])?) { [G::ZERO; OUT_581] } else { let (__hash, __hit) = record.function_queries[581].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[581].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[581].bump_multiplicity(__i); } let __ret: [G; OUT_581] = unsafe { *(record.function_queries[581].output_at(__i).as_ptr() as *const [G; OUT_581]) }; __ret }, _ => { aiur_fn_581::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_581] = []; record.function_queries[581].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_582: usize = 4; -const IN_582: usize = 4; -const OUT_582: usize = 0; -fn aiur_fn_582(inp: [G; IN_582], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_582], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_581] = { let __args: [G; IN_581] = [__v_0, __v_1, __v_2, __v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(581, &__args[..])?) { [G::ZERO; OUT_581] } else { let (__hash, __hit) = record.function_queries[581].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[581].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[581].bump_multiplicity(__i); } let __ret: [G; OUT_581] = unsafe { *(record.function_queries[581].output_at(__i).as_ptr() as *const [G; OUT_581]) }; __ret }, _ => { aiur_fn_581::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_582] = []; record.function_queries[582].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_583: usize = 4; -const IN_583: usize = 4; -const OUT_583: usize = 1; -fn aiur_fn_583(inp: [G; IN_583], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_583], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; match __v_2.as_canonical_u64() { 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_583] = [__v_6]; record.function_queries[583].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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() { 5u64 => { let __v_9: G = G::from_u64(1); let __v_10: G = __v_2 - __v_9; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_11, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_583] = { let __args: [G; IN_583] = [__v_0, __v_7, __v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(583, &__args[..])?) { [G::ZERO; OUT_583] } else { let (__hash, __hit) = record.function_queries[583].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[583].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[583].bump_multiplicity(__i); } let __ret: [G; OUT_583] = unsafe { *(record.function_queries[583].output_at(__i).as_ptr() as *const [G; OUT_583]) }; __ret }, _ => { aiur_fn_583::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_583] = [__v_13]; record.function_queries[583].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_584: usize = 4; -const IN_584: usize = 4; -const OUT_584: usize = 0; -fn aiur_fn_584(inp: [G; IN_584], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_584], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(270, &__args[..])?) { [G::ZERO; OUT_270] } else { let (__hash, __hit) = record.function_queries[270].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[270].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => { aiur_fn_270::(__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("ctor field lives in a universe above the inductive's".to_string()) }); } let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_11, __v_5, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_584] = { let __args: [G; IN_584] = [__v_0, __v_6, __v_2, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(584, &__args[..])?) { [G::ZERO; OUT_584] } else { let (__hash, __hit) = record.function_queries[584].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[584].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[584].bump_multiplicity(__i); } let __ret: [G; OUT_584] = unsafe { *(record.function_queries[584].output_at(__i).as_ptr() as *const [G; OUT_584]) }; __ret }, _ => { aiur_fn_584::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_584] = []; record.function_queries[584].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_584] = []; record.function_queries[584].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_585: usize = 5; -const IN_585: usize = 5; -const OUT_585: usize = 0; -fn aiur_fn_585(inp: [G; IN_585], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_585], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(584, &__args[..])?) { [G::ZERO; OUT_584] } else { let (__hash, __hit) = record.function_queries[584].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[584].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[584].bump_multiplicity(__i); } let __ret: [G; OUT_584] = unsafe { *(record.function_queries[584].output_at(__i).as_ptr() as *const [G; OUT_584]) }; __ret }, _ => { aiur_fn_584::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_585] = []; record.function_queries[585].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 5u64 => { let __v_9: G = G::from_u64(1); let __v_10: G = __v_2 - __v_9; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_11, __v_6, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_585] = { let __args: [G; IN_585] = [__v_0, __v_7, __v_10, __v_3, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(585, &__args[..])?) { [G::ZERO; OUT_585] } else { let (__hash, __hit) = record.function_queries[585].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[585].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[585].bump_multiplicity(__i); } let __ret: [G; OUT_585] = unsafe { *(record.function_queries[585].output_at(__i).as_ptr() as *const [G; OUT_585]) }; __ret }, _ => { aiur_fn_585::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_585] = []; record.function_queries[585].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_586: usize = 4; -const IN_586: usize = 4; -const OUT_586: usize = 0; -fn aiur_fn_586(inp: [G; IN_586], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_586], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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 __ret: [G; OUT_586] = []; record.function_queries[586].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { 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(1).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_585] = { let __args: [G; IN_585] = [__v_0, __v_1, __v_2, __v_3, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(585, &__args[..])?) { [G::ZERO; OUT_585] } else { let (__hash, __hit) = record.function_queries[585].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[585].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[585].bump_multiplicity(__i); } let __ret: [G; OUT_585] = unsafe { *(record.function_queries[585].output_at(__i).as_ptr() as *const [G; OUT_585]) }; __ret }, _ => { aiur_fn_585::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_586] = []; record.function_queries[586].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_587: usize = 2; -const IN_587: usize = 2; -const OUT_587: usize = 1; -fn aiur_fn_587(inp: [G; IN_587], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_587], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_236] = { let __args: [G; IN_236] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(236, &__args[..])?) { [G::ZERO; OUT_236] } else { let (__hash, __hit) = record.function_queries[236].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[236].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[236].bump_multiplicity(__i); } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => { aiur_fn_236::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __ret: [G; OUT_587] = [__v_2]; record.function_queries[587].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_588: usize = 2; -const IN_588: usize = 2; -const OUT_588: usize = 1; -fn aiur_fn_588(inp: [G; IN_588], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_588], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_588] = [__v_5]; record.function_queries[588].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_1]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_588] = [__v_6]; record.function_queries[588].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(588, &__args[..])?) { [G::ZERO; OUT_588] } else { let (__hash, __hit) = record.function_queries[588].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[588].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[588].bump_multiplicity(__i); } let __ret: [G; OUT_588] = unsafe { *(record.function_queries[588].output_at(__i).as_ptr() as *const [G; OUT_588]) }; __ret }, _ => { aiur_fn_588::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_588] = [__v_6]; record.function_queries[588].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_589: usize = 2; -const IN_589: usize = 2; -const OUT_589: usize = 1; -fn aiur_fn_589(inp: [G; IN_589], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_589], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_234] = { let __args: [G; IN_234] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; let __v_9: G = __loaded[6]; let __v_10: G = __loaded[7]; let __v_11: G = __loaded[8]; let __v_12: G = __loaded[9]; let __v_13: G = __loaded[10]; let __v_14: G = __loaded[11]; match __v_3.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_1, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(588, &__args[..])?) { [G::ZERO; OUT_588] } else { let (__hash, __hit) = record.function_queries[588].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[588].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[588].bump_multiplicity(__i); } let __ret: [G; OUT_588] = unsafe { *(record.function_queries[588].output_at(__i).as_ptr() as *const [G; OUT_588]) }; __ret }, _ => { aiur_fn_588::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_589] = [__v_15]; record.function_queries[589].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_589] = [__v_15]; record.function_queries[589].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_590: usize = 2; -const IN_590: usize = 2; -const OUT_590: usize = 1; -fn aiur_fn_590(inp: [G; IN_590], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_590], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(2).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() { 0u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_590] = [__v_6]; record.function_queries[590].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_590] = [__v_6]; record.function_queries[590].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(589, &__args[..])?) { [G::ZERO; OUT_589] } else { let (__hash, __hit) = record.function_queries[589].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[589].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[589].bump_multiplicity(__i); } let __ret: [G; OUT_589] = unsafe { *(record.function_queries[589].output_at(__i).as_ptr() as *const [G; OUT_589]) }; __ret }, _ => { aiur_fn_589::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_590] = [__v_6]; record.function_queries[590].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(590, &__args[..])?) { [G::ZERO; OUT_590] } else { let (__hash, __hit) = record.function_queries[590].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[590].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[590].bump_multiplicity(__i); } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => { aiur_fn_590::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_590] = [__v_7]; record.function_queries[590].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(590, &__args[..])?) { [G::ZERO; OUT_590] } else { let (__hash, __hit) = record.function_queries[590].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[590].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[590].bump_multiplicity(__i); } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => { aiur_fn_590::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_590] = [__v_7]; record.function_queries[590].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(590, &__args[..])?) { [G::ZERO; OUT_590] } else { let (__hash, __hit) = record.function_queries[590].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[590].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[590].bump_multiplicity(__i); } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => { aiur_fn_590::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_590] = [__v_7]; record.function_queries[590].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(590, &__args[..])?) { [G::ZERO; OUT_590] } else { let (__hash, __hit) = record.function_queries[590].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[590].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[590].bump_multiplicity(__i); } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => { aiur_fn_590::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_590] = [__v_7]; record.function_queries[590].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 5u64 => { let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(590, &__args[..])?) { [G::ZERO; OUT_590] } else { let (__hash, __hit) = record.function_queries[590].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[590].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[590].bump_multiplicity(__i); } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => { aiur_fn_590::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_590] = [__v_7]; record.function_queries[590].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(590, &__args[..])?) { [G::ZERO; OUT_590] } else { let (__hash, __hit) = record.function_queries[590].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[590].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[590].bump_multiplicity(__i); } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => { aiur_fn_590::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_590] = [__v_7]; record.function_queries[590].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 6u64 => { let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(590, &__args[..])?) { [G::ZERO; OUT_590] } else { let (__hash, __hit) = record.function_queries[590].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[590].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[590].bump_multiplicity(__i); } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => { aiur_fn_590::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_590] = [__v_7]; record.function_queries[590].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(590, &__args[..])?) { [G::ZERO; OUT_590] } else { let (__hash, __hit) = record.function_queries[590].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[590].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[590].bump_multiplicity(__i); } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => { aiur_fn_590::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_590] = [__v_8]; record.function_queries[590].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(590, &__args[..])?) { [G::ZERO; OUT_590] } else { let (__hash, __hit) = record.function_queries[590].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[590].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[590].bump_multiplicity(__i); } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => { aiur_fn_590::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_590] = [__v_8]; record.function_queries[590].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, 7u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_590] = [__v_6]; record.function_queries[590].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(590, &__args[..])?) { [G::ZERO; OUT_590] } else { let (__hash, __hit) = record.function_queries[590].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[590].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[590].bump_multiplicity(__i); } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => { aiur_fn_590::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_590] = [__v_6]; record.function_queries[590].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_591: usize = 2; -const IN_591: usize = 2; -const OUT_591: usize = 1; -fn aiur_fn_591(inp: [G; IN_591], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_591], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_591] = [__v_5]; record.function_queries[591].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(590, &__args[..])?) { [G::ZERO; OUT_590] } else { let (__hash, __hit) = record.function_queries[590].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[590].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[590].bump_multiplicity(__i); } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => { aiur_fn_590::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_591] = [__v_6]; record.function_queries[591].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(591, &__args[..])?) { [G::ZERO; OUT_591] } else { let (__hash, __hit) = record.function_queries[591].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[591].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => { aiur_fn_591::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_591] = [__v_6]; record.function_queries[591].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_592: usize = 3; -const IN_592: usize = 3; -const OUT_592: usize = 2; -fn aiur_fn_592(inp: [G; IN_592], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_592], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __ret: [G; OUT_592] = [__v_0, __v_2]; record.function_queries[592].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 5u64 => { let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(1); let __v_10: G = __v_1 - __v_9; let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(592, &__args[..])?) { [G::ZERO; OUT_592] } else { let (__hash, __hit) = record.function_queries[592].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[592].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[592].bump_multiplicity(__i); } let __ret: [G; OUT_592] = unsafe { *(record.function_queries[592].output_at(__i).as_ptr() as *const [G; OUT_592]) }; __ret }, _ => { aiur_fn_592::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_592] = [__v_11, __v_12]; record.function_queries[592].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_592] = [__v_0, __v_2]; record.function_queries[592].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_593: usize = 4; -const IN_593: usize = 4; -const OUT_593: usize = 0; -fn aiur_fn_593(inp: [G; IN_593], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_593], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_1 - __v_3; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_593] = []; record.function_queries[593].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(1).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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = __v_2 - __v_12; let __v_14: G = __v_13 - __v_3; if (__v_9 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("recursive occurrence: parameter arg is not the parameter binder".to_string()) }); } let __v_15: G = __v_3 + __v_12; let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_7, __v_1, __v_2, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(593, &__args[..])?) { [G::ZERO; OUT_593] } else { let (__hash, __hit) = record.function_queries[593].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[593].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => { aiur_fn_593::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_593] = []; record.function_queries[593].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_594: usize = 5; -const IN_594: usize = 5; -const OUT_594: usize = 0; -fn aiur_fn_594(inp: [G; IN_594], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_594], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; let __v_10: G = __loaded[4]; let __v_11: G = __loaded[5]; let __v_12: G = __loaded[6]; let __v_13: G = __loaded[7]; let __v_14: G = __loaded[8]; let __v_15: G = __loaded[9]; let __v_16: G = __loaded[10]; let __v_17: G = __loaded[11]; match __v_6.as_canonical_u64() { 5u64 => { let __v_18: G = G::from_u64(0); let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_1, __v_7, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(577, &__args[..])?) { [G::ZERO; OUT_577] } else { let (__hash, __hit) = record.function_queries[577].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[577].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[577].bump_multiplicity(__i); } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => { aiur_fn_577::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __v_9 + __v_10; if (__v_19 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("recursive occurrence is not fully applied".to_string()) }); } let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_2, __v_9, __v_4, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(593, &__args[..])?) { [G::ZERO; OUT_593] } else { let (__hash, __hit) = record.function_queries[593].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[593].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => { aiur_fn_593::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_21, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(591, &__args[..])?) { [G::ZERO; OUT_591] } else { let (__hash, __hit) = record.function_queries[591].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[591].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => { aiur_fn_591::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; if (__v_22 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("recursive occurrence: index argument mentions the block".to_string()) }); } let __ret: [G; OUT_594] = []; record.function_queries[594].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } -const INPUT_SIZE_595: usize = 5; -const IN_595: usize = 5; -const OUT_595: usize = 0; -fn aiur_fn_595(inp: [G; IN_595], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_595], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(590, &__args[..])?) { [G::ZERO; OUT_590] } else { let (__hash, __hit) = record.function_queries[590].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[590].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[590].bump_multiplicity(__i); } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => { aiur_fn_590::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_595] = []; record.function_queries[595].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(590, &__args[..])?) { [G::ZERO; OUT_590] } else { let (__hash, __hit) = record.function_queries[590].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[590].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[590].bump_multiplicity(__i); } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => { aiur_fn_590::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); if (__v_11 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("strict positivity: block occurs left of an arrow".to_string()) }); } let __v_13: G = { let __values: [G; 3] = [__v_12, __v_8, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_595] = { let __args: [G; IN_595] = [__v_0, __v_9, __v_2, __v_13, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(595, &__args[..])?) { [G::ZERO; OUT_595] } else { let (__hash, __hit) = record.function_queries[595].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[595].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[595].bump_multiplicity(__i); } let __ret: [G; OUT_595] = unsafe { *(record.function_queries[595].output_at(__i).as_ptr() as *const [G; OUT_595]) }; __ret }, _ => { aiur_fn_595::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_595] = []; record.function_queries[595].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_6]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __idx = usize::try_from(__ptr_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() { 2u64 => { let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_14, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(589, &__args[..])?) { [G::ZERO; OUT_589] } else { let (__hash, __hit) = record.function_queries[589].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[589].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[589].bump_multiplicity(__i); } let __ret: [G; OUT_589] = unsafe { *(record.function_queries[589].output_at(__i).as_ptr() as *const [G; OUT_589]) }; __ret }, _ => { aiur_fn_589::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_14, __v_15, __v_12, __v_2, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(594, &__args[..])?) { [G::ZERO; OUT_594] } else { let (__hash, __hit) = record.function_queries[594].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[594].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[594].bump_multiplicity(__i); } let __ret: [G; OUT_594] = unsafe { *(record.function_queries[594].output_at(__i).as_ptr() as *const [G; OUT_594]) }; __ret }, _ => { aiur_fn_594::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_595] = []; record.function_queries[595].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_595] = []; record.function_queries[595].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].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]; match __v_19.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_12, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_31, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(591, &__args[..])?) { [G::ZERO; OUT_591] } else { let (__hash, __hit) = record.function_queries[591].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[591].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => { aiur_fn_591::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(0); if (__v_32 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: Some("strict positivity: block occurs in a nested inductive's index args".to_string()) }); } let __v_34: G = { let __values: [G; 3] = [__v_33, __v_26, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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_776] = { let __args: [G; IN_776] = [__v_12, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(776, &__args[..])?) { [G::ZERO; OUT_776] } else { let (__hash, __hit) = record.function_queries[776].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[776].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[776].bump_multiplicity(__i); } let __ret: [G; OUT_776] = unsafe { *(record.function_queries[776].output_at(__i).as_ptr() as *const [G; OUT_776]) }; __ret }, _ => { aiur_fn_776::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(764, &__args[..])?) { [G::ZERO; OUT_764] } else { let (__hash, __hit) = record.function_queries[764].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[764].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => { aiur_fn_764::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_26, __v_27, __v_24, __v_34, __v_33, __v_22, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(596, &__args[..])?) { [G::ZERO; OUT_596] } else { let (__hash, __hit) = record.function_queries[596].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[596].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => { aiur_fn_596::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_595] = []; record.function_queries[595].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, } }, } }) } -const INPUT_SIZE_596: usize = 8; -const IN_596: usize = 8; -const OUT_596: usize = 0; -fn aiur_fn_596(inp: [G; IN_596], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_596], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_3 - __v_5; match __v_8.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_596] = []; record.function_queries[596].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_1, __v_2, __v_5]; 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_9: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].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]; match __v_10.as_canonical_u64() { 6u64 => { 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(1).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_592] = { let __args: [G; IN_592] = [__v_12, __v_6, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(592, &__args[..])?) { [G::ZERO; OUT_592] } else { let (__hash, __hit) = record.function_queries[592].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[592].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[592].bump_multiplicity(__i); } let __ret: [G; OUT_592] = unsafe { *(record.function_queries[592].output_at(__i).as_ptr() as *const [G; OUT_592]) }; __ret }, _ => { aiur_fn_592::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = G::from_u64(0); let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_24, __v_7, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(320, &__args[..])?) { [G::ZERO; OUT_320] } else { let (__hash, __hit) = record.function_queries[320].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[320].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => { aiur_fn_320::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_0, __v_27, __v_4, __v_23, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(597, &__args[..])?) { [G::ZERO; OUT_597] } else { let (__hash, __hit) = record.function_queries[597].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[597].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[597].bump_multiplicity(__i); } let __ret: [G; OUT_597] = unsafe { *(record.function_queries[597].output_at(__i).as_ptr() as *const [G; OUT_597]) }; __ret }, _ => { aiur_fn_597::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __v_5 + __v_22; let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_28, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(596, &__args[..])?) { [G::ZERO; OUT_596] } else { let (__hash, __hit) = record.function_queries[596].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[596].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => { aiur_fn_596::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_596] = []; record.function_queries[596].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_597: usize = 5; -const IN_597: usize = 5; -const OUT_597: usize = 0; -fn aiur_fn_597(inp: [G; IN_597], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_597], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(2).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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(595, &__args[..])?) { [G::ZERO; OUT_595] } else { let (__hash, __hit) = record.function_queries[595].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[595].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[595].bump_multiplicity(__i); } let __ret: [G; OUT_595] = unsafe { *(record.function_queries[595].output_at(__i).as_ptr() as *const [G; OUT_595]) }; __ret }, _ => { aiur_fn_595::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_6, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_597] = { let __args: [G; IN_597] = [__v_0, __v_7, __v_2, __v_10, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(597, &__args[..])?) { [G::ZERO; OUT_597] } else { let (__hash, __hit) = record.function_queries[597].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[597].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[597].bump_multiplicity(__i); } let __ret: [G; OUT_597] = unsafe { *(record.function_queries[597].output_at(__i).as_ptr() as *const [G; OUT_597]) }; __ret }, _ => { aiur_fn_597::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_597] = []; record.function_queries[597].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_597] = []; record.function_queries[597].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_598: usize = 5; -const IN_598: usize = 5; -const OUT_598: usize = 0; -fn aiur_fn_598(inp: [G; IN_598], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_598], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = 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(1).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_3, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_592] = { let __args: [G; IN_592] = [__v_1, __v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(592, &__args[..])?) { [G::ZERO; OUT_592] } else { let (__hash, __hit) = record.function_queries[592].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[592].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[592].bump_multiplicity(__i); } let __ret: [G; OUT_592] = unsafe { *(record.function_queries[592].output_at(__i).as_ptr() as *const [G; OUT_592]) }; __ret }, _ => { aiur_fn_592::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_0, __v_9, __v_8, __v_10, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(597, &__args[..])?) { [G::ZERO; OUT_597] } else { let (__hash, __hit) = record.function_queries[597].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[597].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[597].bump_multiplicity(__i); } let __ret: [G; OUT_597] = unsafe { *(record.function_queries[597].output_at(__i).as_ptr() as *const [G; OUT_597]) }; __ret }, _ => { aiur_fn_597::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_598] = []; record.function_queries[598].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_599: usize = 9; -const IN_599: usize = 9; -const OUT_599: usize = 0; -fn aiur_fn_599(inp: [G; IN_599], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_599], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = __v_2 + __v_3; 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(1).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_583] = { let __args: [G; IN_583] = [__v_0, __v_1, __v_9, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(583, &__args[..])?) { [G::ZERO; OUT_583] } else { let (__hash, __hit) = record.function_queries[583].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[583].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[583].bump_multiplicity(__i); } let __ret: [G; OUT_583] = unsafe { *(record.function_queries[583].output_at(__i).as_ptr() as *const [G; OUT_583]) }; __ret }, _ => { aiur_fn_583::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_12, __v_8, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(600, &__args[..])?) { [G::ZERO; OUT_600] } else { let (__hash, __hit) = record.function_queries[600].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[600].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[600].bump_multiplicity(__i); } let __ret: [G; OUT_600] = unsafe { *(record.function_queries[600].output_at(__i).as_ptr() as *const [G; OUT_600]) }; __ret }, _ => { aiur_fn_600::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_599] = []; record.function_queries[599].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_600: usize = 11; -const IN_600: usize = 11; -const OUT_600: usize = 0; -fn aiur_fn_600(inp: [G; IN_600], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_600], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = __v_4 - __v_10; match __v_11.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_600] = []; record.function_queries[600].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_6, __v_7, __v_10]; 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_12: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; let __v_16: G = __loaded[3]; let __v_17: G = __loaded[4]; let __v_18: G = __loaded[5]; let __v_19: G = __loaded[6]; let __v_20: G = __loaded[7]; let __v_21: G = __loaded[8]; let __v_22: G = __loaded[9]; let __v_23: G = __loaded[10]; let __v_24: G = __loaded[11]; match __v_13.as_canonical_u64() { 6u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_16, __v_6]; 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_25: G = __r_arr[0]; let __v_26: G = G::from_u64(1); if (__v_25 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("ctor belongs to a different block than its inductive".to_string()) }); } if (__v_17 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("ctor points at a different member of the block".to_string()) }); } if (__v_18 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("ctor's stored index differs from its position".to_string()) }); } if (__v_19 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor parameter count differs from the inductive's".to_string()) }); } let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_1, __v_15, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(582, &__args[..])?) { [G::ZERO; OUT_582] } else { let (__hash, __hit) = record.function_queries[582].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[582].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[582].bump_multiplicity(__i); } let __ret: [G; OUT_582] = unsafe { *(record.function_queries[582].output_at(__i).as_ptr() as *const [G; OUT_582]) }; __ret }, _ => { aiur_fn_582::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_15, __v_19, __v_3, __v_20, __v_5, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(580, &__args[..])?) { [G::ZERO; OUT_580] } else { let (__hash, __hit) = record.function_queries[580].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[580].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => { aiur_fn_580::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_15, __v_19, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(586, &__args[..])?) { [G::ZERO; OUT_586] } else { let (__hash, __hit) = record.function_queries[586].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[586].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[586].bump_multiplicity(__i); } let __ret: [G; OUT_586] = unsafe { *(record.function_queries[586].output_at(__i).as_ptr() as *const [G; OUT_586]) }; __ret }, _ => { aiur_fn_586::(__args, __hash, record, io_buffer)? }, } } }; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_9.as_canonical_u64() { 0u64 => { let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 3] = [__v_27, __v_27, __v_27]; let __mq = record.memory_queries.get_index_mut(1).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_598] = { let __args: [G; IN_598] = [__v_0, __v_15, __v_19, __v_6, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(598, &__args[..])?) { [G::ZERO; OUT_598] } else { let (__hash, __hit) = record.function_queries[598].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[598].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[598].bump_multiplicity(__i); } let __ret: [G; OUT_598] = unsafe { *(record.function_queries[598].output_at(__i).as_ptr() as *const [G; OUT_598]) }; __ret }, _ => { aiur_fn_598::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, _ => { break '__mc_0 []; }, } }; let __v_27: G = G::from_u64(1); let __v_28: G = __v_10 + __v_27; let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(600, &__args[..])?) { [G::ZERO; OUT_600] } else { let (__hash, __hit) = record.function_queries[600].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[600].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[600].bump_multiplicity(__i); } let __ret: [G; OUT_600] = unsafe { *(record.function_queries[600].output_at(__i).as_ptr() as *const [G; OUT_600]) }; __ret }, _ => { aiur_fn_600::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_600] = []; record.function_queries[600].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_601: usize = 13; -const IN_601: usize = 13; -const OUT_601: usize = 0; -fn aiur_fn_601(inp: [G; IN_601], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_601], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_1.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_2, __v_8, __v_9, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(599, &__args[..])?) { [G::ZERO; OUT_599] } else { let (__hash, __hit) = record.function_queries[599].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[599].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[599].bump_multiplicity(__i); } let __ret: [G; OUT_599] = unsafe { *(record.function_queries[599].output_at(__i).as_ptr() as *const [G; OUT_599]) }; __ret }, _ => { aiur_fn_599::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_601] = []; record.function_queries[601].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_601] = []; record.function_queries[601].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_602: usize = 14; -const IN_602: usize = 14; -const OUT_602: usize = 0; -fn aiur_fn_602(inp: [G; IN_602], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_602], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_1.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_8, __v_13]; 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_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_602] = []; record.function_queries[602].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_8]; 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_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 __v_26: G = __r_arr[11]; let __v_27: G = __r_arr[12]; let __v_28: G = __r_arr[13]; let __v_29: G = __r_arr[14]; let __v_30: G = __r_arr[15]; let __v_31: G = __r_arr[16]; let __v_32: G = __r_arr[17]; let __v_33: G = __r_arr[18]; let __v_34: G = __r_arr[19]; let __v_35: G = __r_arr[20]; let __v_36: G = __r_arr[21]; let __v_37: G = __r_arr[22]; let __v_38: G = __r_arr[23]; let __v_39: G = __r_arr[24]; let __v_40: G = __r_arr[25]; let __v_41: G = __r_arr[26]; let __v_42: G = __r_arr[27]; let __v_43: G = __r_arr[28]; let __v_44: G = __r_arr[29]; let __v_45: G = __r_arr[30]; let __v_46: G = __r_arr[31]; let __v_47: G = __r_arr[32]; let __v_48: G = __r_arr[33]; let __v_49: G = __r_arr[34]; let __v_50: G = __r_arr[35]; let __v_51: G = __r_arr[36]; let __v_52: G = __r_arr[37]; let __v_53: G = __r_arr[38]; let __v_54: G = __r_arr[39]; let __v_55: G = __r_arr[40]; let __v_56: G = __r_arr[41]; let __v_57: G = __r_arr[42]; let __v_58: G = __r_arr[43]; let __v_59: G = __r_arr[44]; let __v_60: G = __r_arr[45]; let __v_61: G = __r_arr[46]; let __v_62: G = __r_arr[47]; match __v_15.as_canonical_u64() { _ => { match __v_15.as_canonical_u64() { 8u64 => { let __v_63: G = G::from_u64(0); let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_0, __v_16, __v_3, __v_4, __v_5, __v_9, __v_63, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(603, &__args[..])?) { [G::ZERO; OUT_603] } else { let (__hash, __hit) = record.function_queries[603].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[603].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[603].bump_multiplicity(__i); } let __ret: [G; OUT_603] = unsafe { *(record.function_queries[603].output_at(__i).as_ptr() as *const [G; OUT_603]) }; __ret }, _ => { aiur_fn_603::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_602] = []; record.function_queries[602].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_602] = []; record.function_queries[602].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { let __ret: [G; OUT_602] = []; record.function_queries[602].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_603: usize = 8; -const IN_603: usize = 8; -const OUT_603: usize = 0; -fn aiur_fn_603(inp: [G; IN_603], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_603], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 47] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(15).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __v_14: G = __loaded[6]; let __v_15: G = __loaded[7]; let __v_16: G = __loaded[8]; let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; let __v_20: G = __loaded[12]; let __v_21: G = __loaded[13]; let __v_22: G = __loaded[14]; let __v_23: G = __loaded[15]; let __v_24: G = __loaded[16]; let __v_25: G = __loaded[17]; let __v_26: G = __loaded[18]; let __v_27: G = __loaded[19]; let __v_28: G = __loaded[20]; let __v_29: G = __loaded[21]; let __v_30: G = __loaded[22]; let __v_31: G = __loaded[23]; let __v_32: G = __loaded[24]; let __v_33: G = __loaded[25]; let __v_34: G = __loaded[26]; let __v_35: G = __loaded[27]; let __v_36: G = __loaded[28]; let __v_37: G = __loaded[29]; let __v_38: G = __loaded[30]; let __v_39: G = __loaded[31]; let __v_40: G = __loaded[32]; let __v_41: G = __loaded[33]; let __v_42: G = __loaded[34]; let __v_43: G = __loaded[35]; let __v_44: G = __loaded[36]; let __v_45: G = __loaded[37]; let __v_46: G = __loaded[38]; let __v_47: G = __loaded[39]; let __v_48: G = __loaded[40]; let __v_49: G = __loaded[41]; let __v_50: G = __loaded[42]; let __v_51: G = __loaded[43]; let __v_52: G = __loaded[44]; let __v_53: G = __loaded[45]; let __v_54: G = __loaded[46]; match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_603] = []; record.function_queries[603].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { 1u64 => { let __v_55: G = __v_6 - __v_5; let __v_56: G = G::from_bool(__v_55 == G::ZERO); match __v_56.as_canonical_u64() { 1u64 => { let __v_57: G = G::from_u64(1); let __v_58: G = __v_6 + __v_57; let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_58, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(603, &__args[..])?) { [G::ZERO; OUT_603] } else { let (__hash, __hit) = record.function_queries[603].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[603].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[603].bump_multiplicity(__i); } let __ret: [G; OUT_603] = unsafe { *(record.function_queries[603].output_at(__i).as_ptr() as *const [G; OUT_603]) }; __ret }, _ => { aiur_fn_603::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_603] = []; record.function_queries[603].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_7, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(236, &__args[..])?) { [G::ZERO; OUT_236] } else { let (__hash, __hit) = record.function_queries[236].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[236].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[236].bump_multiplicity(__i); } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => { aiur_fn_236::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; let __v_61: G = __loaded[3]; let __v_62: G = __loaded[4]; let __v_63: G = __loaded[5]; let __v_64: G = __loaded[6]; let __v_65: G = __loaded[7]; let __v_66: G = __loaded[8]; let __v_67: G = __loaded[9]; let __v_68: G = __loaded[10]; let __v_69: G = __loaded[11]; match __v_58.as_canonical_u64() { 5u64 => { if (__v_61 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("mutual block peers disagree on parameter count".to_string()) }); } let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_2, __v_60, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(582, &__args[..])?) { [G::ZERO; OUT_582] } else { let (__hash, __hit) = record.function_queries[582].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[582].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[582].bump_multiplicity(__i); } let __ret: [G; OUT_582] = unsafe { *(record.function_queries[582].output_at(__i).as_ptr() as *const [G; OUT_582]) }; __ret }, _ => { aiur_fn_582::(__args, __hash, record, io_buffer)? }, } } }; let __v_70: G = __v_3 + __v_4; let __v_71: G = G::from_u64(1); let __v_72: G = { let __values: [G; 3] = [__v_71, __v_71, __v_71]; let __mq = record.memory_queries.get_index_mut(1).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_583] = { let __args: [G; IN_583] = [__v_0, __v_2, __v_70, __v_72]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(583, &__args[..])?) { [G::ZERO; OUT_583] } else { let (__hash, __hit) = record.function_queries[583].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[583].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[583].bump_multiplicity(__i); } let __ret: [G; OUT_583] = unsafe { *(record.function_queries[583].output_at(__i).as_ptr() as *const [G; OUT_583]) }; __ret }, _ => { aiur_fn_583::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = __v_61 + __v_62; let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_0, __v_60, __v_74, __v_72]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(583, &__args[..])?) { [G::ZERO; OUT_583] } else { let (__hash, __hit) = record.function_queries[583].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[583].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[583].bump_multiplicity(__i); } let __ret: [G; OUT_583] = unsafe { *(record.function_queries[583].output_at(__i).as_ptr() as *const [G; OUT_583]) }; __ret }, _ => { aiur_fn_583::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_73, __v_75]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(271, &__args[..])?) { [G::ZERO; OUT_271] } else { let (__hash, __hit) = record.function_queries[271].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[271].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[271].bump_multiplicity(__i); } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => { aiur_fn_271::(__args, __hash, record, io_buffer)? }, } } }; let __v_76: G = __r_arr[0]; if (__v_76 != __v_71) { return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: Some("mutual block peers land in different universes".to_string()) }); } let __v_77: G = __v_6 + __v_71; let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_77, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(603, &__args[..])?) { [G::ZERO; OUT_603] } else { let (__hash, __hit) = record.function_queries[603].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[603].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[603].bump_multiplicity(__i); } let __ret: [G; OUT_603] = unsafe { *(record.function_queries[603].output_at(__i).as_ptr() as *const [G; OUT_603]) }; __ret }, _ => { aiur_fn_603::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_603] = []; record.function_queries[603].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_70: G = G::from_u64(1); let __v_71: G = __v_6 + __v_70; let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_71, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(603, &__args[..])?) { [G::ZERO; OUT_603] } else { let (__hash, __hit) = record.function_queries[603].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[603].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[603].bump_multiplicity(__i); } let __ret: [G; OUT_603] = unsafe { *(record.function_queries[603].output_at(__i).as_ptr() as *const [G; OUT_603]) }; __ret }, _ => { aiur_fn_603::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_603] = []; record.function_queries[603].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_55: G = G::from_u64(1); let __v_56: G = __v_6 + __v_55; let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_56, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(603, &__args[..])?) { [G::ZERO; OUT_603] } else { let (__hash, __hit) = record.function_queries[603].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[603].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[603].bump_multiplicity(__i); } let __ret: [G; OUT_603] = unsafe { *(record.function_queries[603].output_at(__i).as_ptr() as *const [G; OUT_603]) }; __ret }, _ => { aiur_fn_603::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_603] = []; record.function_queries[603].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } -const INPUT_SIZE_604: usize = 17; -const IN_604: usize = 17; -const OUT_604: usize = 1; -fn aiur_fn_604(inp: [G; IN_604], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_604], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1]; 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_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { let __v_18: G = G::from_u64(1); let __ret: [G; OUT_604] = [__v_18]; record.function_queries[604].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { match __v_16.as_canonical_u64() { 0u64 => { let __v_18: G = G::from_u64(0); let __ret: [G; OUT_604] = [__v_18]; record.function_queries[604].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { match __v_2.as_canonical_u64() { 0u64 => { let __v_18: G = G::from_u64(1); let __ret: [G; OUT_604] = [__v_18]; record.function_queries[604].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { match __v_3.as_canonical_u64() { 0u64 => { let __v_18: G = G::from_u64(0); let __ret: [G; OUT_604] = [__v_18]; record.function_queries[604].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { match __v_4.as_canonical_u64() { 6u64 => { match __v_11.as_canonical_u64() { 0u64 => { let __v_18: G = G::from_u64(1); let __ret: [G; OUT_604] = [__v_18]; record.function_queries[604].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_18: G = G::from_u64(1); let __v_19: G = { let __values: [G; 3] = [__v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_index_mut(1).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_605] = { let __args: [G; IN_605] = [__v_0, __v_6, __v_10, __v_11, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(605, &__args[..])?) { [G::ZERO; OUT_605] } else { let (__hash, __hit) = record.function_queries[605].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[605].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[605].bump_multiplicity(__i); } let __ret: [G; OUT_605] = unsafe { *(record.function_queries[605].output_at(__i).as_ptr() as *const [G; OUT_605]) }; __ret }, _ => { aiur_fn_605::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_604] = [__v_20]; record.function_queries[604].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_18: G = G::from_u64(0); let __ret: [G; OUT_604] = [__v_18]; record.function_queries[604].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_18: G = G::from_u64(0); let __ret: [G; OUT_604] = [__v_18]; record.function_queries[604].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_605: usize = 5; -const IN_605: usize = 5; -const OUT_605: usize = 1; -fn aiur_fn_605(inp: [G; IN_605], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_605], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __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(1).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_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_3, __v_5, __v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(606, &__args[..])?) { [G::ZERO; OUT_606] } else { let (__hash, __hit) = record.function_queries[606].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[606].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[606].bump_multiplicity(__i); } let __ret: [G; OUT_606] = unsafe { *(record.function_queries[606].output_at(__i).as_ptr() as *const [G; OUT_606]) }; __ret }, _ => { aiur_fn_606::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_605] = [__v_8]; record.function_queries[605].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 5u64 => { let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_6, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(1); let __v_12: G = __v_2 - __v_11; let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_0, __v_7, __v_12, __v_3, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(605, &__args[..])?) { [G::ZERO; OUT_605] } else { let (__hash, __hit) = record.function_queries[605].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[605].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[605].bump_multiplicity(__i); } let __ret: [G; OUT_605] = unsafe { *(record.function_queries[605].output_at(__i).as_ptr() as *const [G; OUT_605]) }; __ret }, _ => { aiur_fn_605::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_605] = [__v_13]; record.function_queries[605].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_605] = [__v_9]; record.function_queries[605].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_606: usize = 6; -const IN_606: usize = 6; -const OUT_606: usize = 1; -fn aiur_fn_606(inp: [G; IN_606], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_606], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_2 - __v_3; match __v_6.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_1]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(607, &__args[..])?) { [G::ZERO; OUT_607] } else { let (__hash, __hit) = record.function_queries[607].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[607].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[607].bump_multiplicity(__i); } let __ret: [G; OUT_607] = unsafe { *(record.function_queries[607].output_at(__i).as_ptr() as *const [G; OUT_607]) }; __ret }, _ => { aiur_fn_607::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_606] = [__v_9]; record.function_queries[606].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_8, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_271] = { let __args: [G; IN_271] = [__v_11, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(271, &__args[..])?) { [G::ZERO; OUT_271] } else { let (__hash, __hit) = record.function_queries[271].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[271].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[271].bump_multiplicity(__i); } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => { aiur_fn_271::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = __v_12 - __v_15; let __v_17: G = __v_2 - __v_12; let __v_18: G = __v_17 - __v_3; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_16.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_5]; }, _ => { let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 3] = [__v_19, __v_18, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_20]; }, } }; let __v_19: G = __mc_out___mc_0[0]; let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 3] = [__v_20, __v_8, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(1); let __v_23: G = __v_3 + __v_22; let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_9, __v_2, __v_23, __v_21, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(606, &__args[..])?) { [G::ZERO; OUT_606] } else { let (__hash, __hit) = record.function_queries[606].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[606].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[606].bump_multiplicity(__i); } let __ret: [G; OUT_606] = unsafe { *(record.function_queries[606].output_at(__i).as_ptr() as *const [G; OUT_606]) }; __ret }, _ => { aiur_fn_606::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_606] = [__v_24]; record.function_queries[606].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_606] = [__v_11]; record.function_queries[606].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_607: usize = 2; -const IN_607: usize = 2; -const OUT_607: usize = 1; -fn aiur_fn_607(inp: [G; IN_607], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_607], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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 __ret: [G; OUT_607] = [__v_5]; record.function_queries[607].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(608, &__args[..])?) { [G::ZERO; OUT_608] } else { let (__hash, __hit) = record.function_queries[608].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[608].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[608].bump_multiplicity(__i); } let __ret: [G; OUT_608] = unsafe { *(record.function_queries[608].output_at(__i).as_ptr() as *const [G; OUT_608]) }; __ret }, _ => { aiur_fn_608::(__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(0); let __ret: [G; OUT_607] = [__v_6]; record.function_queries[607].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(607, &__args[..])?) { [G::ZERO; OUT_607] } else { let (__hash, __hit) = record.function_queries[607].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[607].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[607].bump_multiplicity(__i); } let __ret: [G; OUT_607] = unsafe { *(record.function_queries[607].output_at(__i).as_ptr() as *const [G; OUT_607]) }; __ret }, _ => { aiur_fn_607::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_607] = [__v_6]; record.function_queries[607].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_608: usize = 2; -const IN_608: usize = 2; -const OUT_608: usize = 1; -fn aiur_fn_608(inp: [G; IN_608], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_608], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_608] = [__v_5]; record.function_queries[608].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(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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 = __v_6 - __v_1; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_608] = [__v_10]; record.function_queries[608].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(608, &__args[..])?) { [G::ZERO; OUT_608] } else { let (__hash, __hit) = record.function_queries[608].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[608].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[608].bump_multiplicity(__i); } let __ret: [G; OUT_608] = unsafe { *(record.function_queries[608].output_at(__i).as_ptr() as *const [G; OUT_608]) }; __ret }, _ => { aiur_fn_608::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_608] = [__v_10]; record.function_queries[608].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(608, &__args[..])?) { [G::ZERO; OUT_608] } else { let (__hash, __hit) = record.function_queries[608].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[608].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[608].bump_multiplicity(__i); } let __ret: [G; OUT_608] = unsafe { *(record.function_queries[608].output_at(__i).as_ptr() as *const [G; OUT_608]) }; __ret }, _ => { aiur_fn_608::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_608] = [__v_9]; record.function_queries[608].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_609: usize = 14; -const IN_609: usize = 14; -const OUT_609: usize = 1; -fn aiur_fn_609(inp: [G; IN_609], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_609], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_1.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_8, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(610, &__args[..])?) { [G::ZERO; OUT_610] } else { let (__hash, __hit) = record.function_queries[610].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[610].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[610].bump_multiplicity(__i); } let __ret: [G; OUT_610] = unsafe { *(record.function_queries[610].output_at(__i).as_ptr() as *const [G; OUT_610]) }; __ret }, _ => { aiur_fn_610::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_609] = [__v_15]; record.function_queries[609].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = __v_4 + __v_5; let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_583] = { let __args: [G; IN_583] = [__v_0, __v_3, __v_15, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(583, &__args[..])?) { [G::ZERO; OUT_583] } else { let (__hash, __hit) = record.function_queries[583].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[583].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[583].bump_multiplicity(__i); } let __ret: [G; OUT_583] = unsafe { *(record.function_queries[583].output_at(__i).as_ptr() as *const [G; OUT_583]) }; __ret }, _ => { aiur_fn_583::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 3] = [__v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_index_mut(1).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_271] = { let __args: [G; IN_271] = [__v_18, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(271, &__args[..])?) { [G::ZERO; OUT_271] } else { let (__hash, __hit) = record.function_queries[271].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[271].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[271].bump_multiplicity(__i); } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => { aiur_fn_271::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_609] = [__v_22]; record.function_queries[609].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { match __v_6.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(0); let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_8, __v_9, __v_22]; 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_23: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; let __v_25: G = __loaded[1]; let __v_26: G = __loaded[2]; let __v_27: G = __loaded[3]; let __v_28: G = __loaded[4]; let __v_29: G = __loaded[5]; let __v_30: G = __loaded[6]; let __v_31: G = __loaded[7]; let __v_32: G = __loaded[8]; let __v_33: G = __loaded[9]; let __v_34: G = __loaded[10]; let __v_35: G = __loaded[11]; match __v_24.as_canonical_u64() { 6u64 => { let __v_36: G = G::from_bool(__v_31 == G::ZERO); let __ret: [G; OUT_609] = [__v_36]; record.function_queries[609].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_36: G = G::from_u64(0); let __ret: [G; OUT_609] = [__v_36]; record.function_queries[609].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_609] = [__v_22]; record.function_queries[609].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_609] = [__v_14]; record.function_queries[609].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_610: usize = 2; -const IN_610: usize = 2; -const OUT_610: usize = 1; -fn aiur_fn_610(inp: [G; IN_610], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_610], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_610] = [__v_3]; record.function_queries[610].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __v_12: G = __r_arr[9]; let __v_13: G = __r_arr[10]; let __v_14: G = __r_arr[11]; let __v_15: G = __r_arr[12]; let __v_16: G = __r_arr[13]; let __v_17: G = __r_arr[14]; let __v_18: G = __r_arr[15]; let __v_19: G = __r_arr[16]; let __v_20: G = __r_arr[17]; let __v_21: G = __r_arr[18]; let __v_22: G = __r_arr[19]; let __v_23: G = __r_arr[20]; let __v_24: G = __r_arr[21]; let __v_25: G = __r_arr[22]; let __v_26: G = __r_arr[23]; let __v_27: G = __r_arr[24]; let __v_28: G = __r_arr[25]; let __v_29: G = __r_arr[26]; let __v_30: G = __r_arr[27]; let __v_31: G = __r_arr[28]; let __v_32: G = __r_arr[29]; let __v_33: G = __r_arr[30]; let __v_34: G = __r_arr[31]; let __v_35: G = __r_arr[32]; let __v_36: G = __r_arr[33]; let __v_37: G = __r_arr[34]; let __v_38: G = __r_arr[35]; let __v_39: G = __r_arr[36]; let __v_40: G = __r_arr[37]; let __v_41: G = __r_arr[38]; let __v_42: G = __r_arr[39]; let __v_43: G = __r_arr[40]; let __v_44: G = __r_arr[41]; let __v_45: G = __r_arr[42]; let __v_46: G = __r_arr[43]; let __v_47: G = __r_arr[44]; let __v_48: G = __r_arr[45]; let __v_49: G = __r_arr[46]; let __v_50: G = __r_arr[47]; match __v_3.as_canonical_u64() { _ => { match __v_3.as_canonical_u64() { 8u64 => { let __v_51: G = G::from_u64(0); let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_4, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(612, &__args[..])?) { [G::ZERO; OUT_612] } else { let (__hash, __hit) = record.function_queries[612].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[612].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[612].bump_multiplicity(__i); } let __ret: [G; OUT_612] = unsafe { *(record.function_queries[612].output_at(__i).as_ptr() as *const [G; OUT_612]) }; __ret }, _ => { aiur_fn_612::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_610] = [__v_52]; record.function_queries[610].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_51: G = G::from_u64(0); let __ret: [G; OUT_610] = [__v_51]; record.function_queries[610].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_611: usize = 1; -const IN_611: usize = 1; -const OUT_611: usize = 1; -fn aiur_fn_611(inp: [G; IN_611], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_611], ExecError> { stacker::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_228] = { let __args: [G; IN_228] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __v_11: G = __r_arr[10]; let __v_12: G = __r_arr[11]; let __v_13: G = __r_arr[12]; let __v_14: G = __r_arr[13]; let __v_15: G = __r_arr[14]; let __v_16: G = __r_arr[15]; let __v_17: G = __r_arr[16]; let __v_18: G = __r_arr[17]; let __v_19: G = __r_arr[18]; let __v_20: G = __r_arr[19]; let __v_21: G = __r_arr[20]; let __v_22: G = __r_arr[21]; let __v_23: G = __r_arr[22]; let __v_24: G = __r_arr[23]; let __v_25: G = __r_arr[24]; let __v_26: G = __r_arr[25]; let __v_27: G = __r_arr[26]; let __v_28: G = __r_arr[27]; let __v_29: G = __r_arr[28]; let __v_30: G = __r_arr[29]; let __v_31: G = __r_arr[30]; let __v_32: G = __r_arr[31]; let __v_33: G = __r_arr[32]; let __v_34: G = __r_arr[33]; let __v_35: G = __r_arr[34]; let __v_36: G = __r_arr[35]; let __v_37: G = __r_arr[36]; let __v_38: G = __r_arr[37]; let __v_39: G = __r_arr[38]; let __v_40: G = __r_arr[39]; let __v_41: G = __r_arr[40]; let __v_42: G = __r_arr[41]; let __v_43: G = __r_arr[42]; let __v_44: G = __r_arr[43]; let __v_45: G = __r_arr[44]; let __v_46: G = __r_arr[45]; let __v_47: G = __r_arr[46]; let __v_48: G = __r_arr[47]; match __v_1.as_canonical_u64() { _ => { match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(1); let __ret: [G; OUT_611] = [__v_49]; record.function_queries[611].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); let __ret: [G; OUT_611] = [__v_49]; record.function_queries[611].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_612: usize = 2; -const IN_612: usize = 2; -const OUT_612: usize = 1; -fn aiur_fn_612(inp: [G; IN_612], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_612], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 47] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(15).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __v_34: G = __loaded[32]; let __v_35: G = __loaded[33]; let __v_36: G = __loaded[34]; let __v_37: G = __loaded[35]; let __v_38: G = __loaded[36]; let __v_39: G = __loaded[37]; let __v_40: G = __loaded[38]; let __v_41: G = __loaded[39]; let __v_42: G = __loaded[40]; let __v_43: G = __loaded[41]; let __v_44: G = __loaded[42]; let __v_45: G = __loaded[43]; let __v_46: G = __loaded[44]; let __v_47: G = __loaded[45]; let __v_48: G = __loaded[46]; match __v_2.as_canonical_u64() { 1u64 => { match __v_1.as_canonical_u64() { 1u64 => { let __v_49: G = G::from_u64(1); let __ret: [G; OUT_612] = [__v_49]; record.function_queries[612].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); let __ret: [G; OUT_612] = [__v_49]; record.function_queries[612].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 0u64 => { match __v_3.as_canonical_u64() { 1u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = __v_1 + __v_49; let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_48, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(612, &__args[..])?) { [G::ZERO; OUT_612] } else { let (__hash, __hit) = record.function_queries[612].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[612].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[612].bump_multiplicity(__i); } let __ret: [G; OUT_612] = unsafe { *(record.function_queries[612].output_at(__i).as_ptr() as *const [G; OUT_612]) }; __ret }, _ => { aiur_fn_612::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __ret: [G; OUT_612] = [__v_51]; record.function_queries[612].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_48, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(612, &__args[..])?) { [G::ZERO; OUT_612] } else { let (__hash, __hit) = record.function_queries[612].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[612].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[612].bump_multiplicity(__i); } let __ret: [G; OUT_612] = unsafe { *(record.function_queries[612].output_at(__i).as_ptr() as *const [G; OUT_612]) }; __ret }, _ => { aiur_fn_612::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __ret: [G; OUT_612] = [__v_49]; record.function_queries[612].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_613: usize = 5; -const IN_613: usize = 5; -const OUT_613: usize = 1; -fn aiur_fn_613(inp: [G; IN_613], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_613], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = __v_1 + __v_2; let __v_6: G = __v_5 + __v_3; let __v_7: G = __v_6 + __v_4; let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(576, &__args[..])?) { [G::ZERO; OUT_576] } else { let (__hash, __hit) = record.function_queries[576].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[576].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => { aiur_fn_576::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __idx = usize::try_from(__ptr_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() { 5u64 => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_10]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 2u64 => { let __ret: [G; OUT_613] = [__v_16]; record.function_queries[613].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_614: usize = 12; -const IN_614: usize = 12; -const OUT_614: usize = 1; -fn aiur_fn_614(inp: [G; IN_614], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_614], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_0.as_canonical_u64() { 7u64 => { let __v_12: G = __v_3 + __v_5; let __v_13: G = __v_12 + __v_6; let __v_14: G = __v_13 + __v_4; let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_2, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(576, &__args[..])?) { [G::ZERO; OUT_576] } else { let (__hash, __hit) = record.function_queries[576].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[576].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => { aiur_fn_576::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; let __v_19: G = __loaded[3]; match __v_16.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_17]; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; let __v_25: G = __loaded[3]; match __v_22.as_canonical_u64() { 2u64 => { let __ret: [G; OUT_614] = [__v_24]; record.function_queries[614].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(1); let __v_27: G = { let __values: [G; 3] = [__v_26, __v_26, __v_26]; let __mq = record.memory_queries.get_index_mut(1).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_614] = [__v_27]; record.function_queries[614].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_index_mut(1).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_614] = [__v_21]; record.function_queries[614].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_614] = [__v_13]; record.function_queries[614].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_615: usize = 6; -const IN_615: usize = 6; -const OUT_615: usize = 1; -fn aiur_fn_615(inp: [G; IN_615], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_615], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_1 + __v_2; let __v_7: G = __v_6 + __v_3; let __v_8: G = __v_7 + __v_4; let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(576, &__args[..])?) { [G::ZERO; OUT_576] } else { let (__hash, __hit) = record.function_queries[576].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[576].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => { aiur_fn_576::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_11]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_15, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(776, &__args[..])?) { [G::ZERO; OUT_776] } else { let (__hash, __hit) = record.function_queries[776].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[776].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[776].bump_multiplicity(__i); } let __ret: [G; OUT_776] = unsafe { *(record.function_queries[776].output_at(__i).as_ptr() as *const [G; OUT_776]) }; __ret }, _ => { aiur_fn_776::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __v_2 + __v_3; let __v_18: G = __v_17 + __v_4; let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_16, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(616, &__args[..])?) { [G::ZERO; OUT_616] } else { let (__hash, __hit) = record.function_queries[616].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[616].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[616].bump_multiplicity(__i); } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => { aiur_fn_616::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_615] = [__v_19]; record.function_queries[615].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }) } -const INPUT_SIZE_616: usize = 2; -const IN_616: usize = 2; -const OUT_616: usize = 1; -fn aiur_fn_616(inp: [G; IN_616], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_616], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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(1).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_616] = [__v_6]; record.function_queries[616].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(293, &__args[..])?) { [G::ZERO; OUT_293] } else { let (__hash, __hit) = record.function_queries[293].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[293].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => { aiur_fn_293::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; if (__v_6 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("nested occurrence's parameter references a motive, minor, or index binder".to_string()) }); } let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3, __v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(310, &__args[..])?) { [G::ZERO; OUT_310] } else { let (__hash, __hit) = record.function_queries[310].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[310].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => { aiur_fn_310::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(616, &__args[..])?) { [G::ZERO; OUT_616] } else { let (__hash, __hit) = record.function_queries[616].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[616].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[616].bump_multiplicity(__i); } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => { aiur_fn_616::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_616] = [__v_9]; record.function_queries[616].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_617: usize = 3; -const IN_617: usize = 3; -const OUT_617: usize = 1; -fn aiur_fn_617(inp: [G; IN_617], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_617], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = __v_1 - __v_2; match __v_3.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(1).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_617] = [__v_5]; record.function_queries[617].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(4); let __v_6: G = __v_0 + __v_2; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(1); let __v_9: G = __v_2 + __v_8; let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(617, &__args[..])?) { [G::ZERO; OUT_617] } else { let (__hash, __hit) = record.function_queries[617].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[617].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[617].bump_multiplicity(__i); } let __ret: [G; OUT_617] = unsafe { *(record.function_queries[617].output_at(__i).as_ptr() as *const [G; OUT_617]) }; __ret }, _ => { aiur_fn_617::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_4, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_617] = [__v_11]; record.function_queries[617].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_618: usize = 2; -const IN_618: usize = 2; -const OUT_618: usize = 1; -fn aiur_fn_618(inp: [G; IN_618], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_618], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_228] = { let __args: [G; IN_228] = [__v_0]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = __r_arr[10]; let __v_13: G = __r_arr[11]; let __v_14: G = __r_arr[12]; let __v_15: G = __r_arr[13]; let __v_16: G = __r_arr[14]; let __v_17: G = __r_arr[15]; let __v_18: G = __r_arr[16]; let __v_19: G = __r_arr[17]; let __v_20: G = __r_arr[18]; let __v_21: G = __r_arr[19]; let __v_22: G = __r_arr[20]; let __v_23: G = __r_arr[21]; let __v_24: G = __r_arr[22]; let __v_25: G = __r_arr[23]; let __v_26: G = __r_arr[24]; let __v_27: G = __r_arr[25]; let __v_28: G = __r_arr[26]; let __v_29: G = __r_arr[27]; let __v_30: G = __r_arr[28]; let __v_31: G = __r_arr[29]; let __v_32: G = __r_arr[30]; let __v_33: G = __r_arr[31]; let __v_34: G = __r_arr[32]; let __v_35: G = __r_arr[33]; let __v_36: G = __r_arr[34]; let __v_37: G = __r_arr[35]; let __v_38: G = __r_arr[36]; let __v_39: G = __r_arr[37]; let __v_40: G = __r_arr[38]; let __v_41: G = __r_arr[39]; let __v_42: G = __r_arr[40]; let __v_43: G = __r_arr[41]; let __v_44: G = __r_arr[42]; let __v_45: G = __r_arr[43]; let __v_46: G = __r_arr[44]; let __v_47: G = __r_arr[45]; let __v_48: G = __r_arr[46]; let __v_49: G = __r_arr[47]; match __v_2.as_canonical_u64() { _ => { match __v_2.as_canonical_u64() { 8u64 => { let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(619, &__args[..])?) { [G::ZERO; OUT_619] } else { let (__hash, __hit) = record.function_queries[619].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[619].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[619].bump_multiplicity(__i); } let __ret: [G; OUT_619] = unsafe { *(record.function_queries[619].output_at(__i).as_ptr() as *const [G; OUT_619]) }; __ret }, _ => { aiur_fn_619::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __ret: [G; OUT_618] = [__v_51]; record.function_queries[618].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_51: G = __loaded[0]; let __v_52: G = __loaded[1]; let __v_53: G = __loaded[2]; let __v_54: G = __loaded[3]; let __v_55: G = __loaded[4]; let __v_56: G = __loaded[5]; let __v_57: G = __loaded[6]; let __v_58: G = __loaded[7]; let __v_59: G = __loaded[8]; let __v_60: G = __loaded[9]; let __v_61: G = __loaded[10]; let __v_62: G = __loaded[11]; match __v_51.as_canonical_u64() { 5u64 => { let __v_63: G = G::from_u64(0); let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_1, __v_52, __v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(617, &__args[..])?) { [G::ZERO; OUT_617] } else { let (__hash, __hit) = record.function_queries[617].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[617].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[617].bump_multiplicity(__i); } let __ret: [G; OUT_617] = unsafe { *(record.function_queries[617].output_at(__i).as_ptr() as *const [G; OUT_617]) }; __ret }, _ => { aiur_fn_617::(__args, __hash, record, io_buffer)? }, } } }; let __v_64: G = __r_arr[0]; let __v_65: G = G::from_u64(1); let __v_66: G = { let __values: [G; 3] = [__v_65, __v_65, __v_65]; let __mq = record.memory_queries.get_index_mut(1).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_67: G = { let __values: [G; 6] = [__v_65, __v_65, __v_65, __v_65, __v_65, __v_65]; let __mq = record.memory_queries.get_index_mut(4).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_68: G = { let __values: [G; 6] = [__v_63, __v_0, __v_63, __v_66, __v_64, __v_67]; let __mq = record.memory_queries.get_index_mut(4).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_618] = [__v_68]; record.function_queries[618].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_63: G = G::from_u64(1); let __v_64: G = { let __values: [G; 6] = [__v_63, __v_63, __v_63, __v_63, __v_63, __v_63]; let __mq = record.memory_queries.get_index_mut(4).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_618] = [__v_64]; record.function_queries[618].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_619: usize = 5; -const IN_619: usize = 5; -const OUT_619: usize = 1; -fn aiur_fn_619(inp: [G; IN_619], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_619], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 47] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(15).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].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 __v_37: G = __loaded[32]; let __v_38: G = __loaded[33]; let __v_39: G = __loaded[34]; let __v_40: G = __loaded[35]; let __v_41: G = __loaded[36]; let __v_42: G = __loaded[37]; let __v_43: G = __loaded[38]; let __v_44: G = __loaded[39]; let __v_45: G = __loaded[40]; let __v_46: G = __loaded[41]; let __v_47: G = __loaded[42]; let __v_48: G = __loaded[43]; let __v_49: G = __loaded[44]; let __v_50: G = __loaded[45]; let __v_51: G = __loaded[46]; match __v_5.as_canonical_u64() { 1u64 => { let __v_52: G = G::from_u64(1); let __v_53: G = { let __values: [G; 6] = [__v_52, __v_52, __v_52, __v_52, __v_52, __v_52]; let __mq = record.memory_queries.get_index_mut(4).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_619] = [__v_53]; record.function_queries[619].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_0, __v_2, __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_52: G = __r_arr[0]; let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(236, &__args[..])?) { [G::ZERO; OUT_236] } else { let (__hash, __hit) = record.function_queries[236].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[236].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[236].bump_multiplicity(__i); } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => { aiur_fn_236::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_54: G = __loaded[0]; let __v_55: G = __loaded[1]; let __v_56: G = __loaded[2]; let __v_57: G = __loaded[3]; let __v_58: G = __loaded[4]; let __v_59: G = __loaded[5]; let __v_60: G = __loaded[6]; let __v_61: G = __loaded[7]; let __v_62: G = __loaded[8]; let __v_63: G = __loaded[9]; let __v_64: G = __loaded[10]; let __v_65: G = __loaded[11]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_54.as_canonical_u64() { 5u64 => { break '__mc_0 [__v_55]; }, _ => { let __v_66: G = G::from_u64(0); break '__mc_0 [__v_66]; }, } }; let __v_66: G = __mc_out___mc_0[0]; let __v_67: G = G::from_u64(0); let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_3, __v_66, __v_67]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(617, &__args[..])?) { [G::ZERO; OUT_617] } else { let (__hash, __hit) = record.function_queries[617].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[617].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[617].bump_multiplicity(__i); } let __ret: [G; OUT_617] = unsafe { *(record.function_queries[617].output_at(__i).as_ptr() as *const [G; OUT_617]) }; __ret }, _ => { aiur_fn_617::(__args, __hash, record, io_buffer)? }, } } }; let __v_68: G = __r_arr[0]; let __v_69: G = G::from_u64(1); let __v_70: G = { let __values: [G; 3] = [__v_69, __v_69, __v_69]; let __mq = record.memory_queries.get_index_mut(1).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_71: G = __v_4 + __v_69; let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_0, __v_51, __v_2, __v_3, __v_71]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(619, &__args[..])?) { [G::ZERO; OUT_619] } else { let (__hash, __hit) = record.function_queries[619].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[619].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[619].bump_multiplicity(__i); } let __ret: [G; OUT_619] = unsafe { *(record.function_queries[619].output_at(__i).as_ptr() as *const [G; OUT_619]) }; __ret }, _ => { aiur_fn_619::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __v_73: G = { let __values: [G; 6] = [__v_67, __v_52, __v_67, __v_70, __v_68, __v_72]; let __mq = record.memory_queries.get_index_mut(4).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_619] = [__v_73]; record.function_queries[619].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_52: G = G::from_u64(1); let __v_53: G = __v_4 + __v_52; let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(619, &__args[..])?) { [G::ZERO; OUT_619] } else { let (__hash, __hit) = record.function_queries[619].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[619].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[619].bump_multiplicity(__i); } let __ret: [G; OUT_619] = unsafe { *(record.function_queries[619].output_at(__i).as_ptr() as *const [G; OUT_619]) }; __ret }, _ => { aiur_fn_619::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __ret: [G; OUT_619] = [__v_54]; record.function_queries[619].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_620: usize = 3; -const IN_620: usize = 3; -const OUT_620: usize = 1; -fn aiur_fn_620(inp: [G; IN_620], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_620], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_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() { 1u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_620] = [__v_9]; record.function_queries[620].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_5.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_1]; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_6, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(623, &__args[..])?) { [G::ZERO; OUT_623] } else { let (__hash, __hit) = record.function_queries[623].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[623].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[623].bump_multiplicity(__i); } let __ret: [G; OUT_623] = unsafe { *(record.function_queries[623].output_at(__i).as_ptr() as *const [G; OUT_623]) }; __ret }, _ => { aiur_fn_623::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __ret: [G; OUT_620] = [__v_11]; record.function_queries[620].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(620, &__args[..])?) { [G::ZERO; OUT_620] } else { let (__hash, __hit) = record.function_queries[620].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[620].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[620].bump_multiplicity(__i); } let __ret: [G; OUT_620] = unsafe { *(record.function_queries[620].output_at(__i).as_ptr() as *const [G; OUT_620]) }; __ret }, _ => { aiur_fn_620::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_620] = [__v_11]; record.function_queries[620].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(620, &__args[..])?) { [G::ZERO; OUT_620] } else { let (__hash, __hit) = record.function_queries[620].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[620].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[620].bump_multiplicity(__i); } let __ret: [G; OUT_620] = unsafe { *(record.function_queries[620].output_at(__i).as_ptr() as *const [G; OUT_620]) }; __ret }, _ => { aiur_fn_620::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_620] = [__v_10]; record.function_queries[620].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(620, &__args[..])?) { [G::ZERO; OUT_620] } else { let (__hash, __hit) = record.function_queries[620].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[620].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[620].bump_multiplicity(__i); } let __ret: [G; OUT_620] = unsafe { *(record.function_queries[620].output_at(__i).as_ptr() as *const [G; OUT_620]) }; __ret }, _ => { aiur_fn_620::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_620] = [__v_9]; record.function_queries[620].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_621: usize = 2; -const IN_621: usize = 2; -const OUT_621: usize = 1; -fn aiur_fn_621(inp: [G; IN_621], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_621], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_1; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_621] = [__v_3]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_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 __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 0u64 => { let __v_11: G = __v_4 - __v_8; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_621] = [__v_12]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_621] = [__v_12]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_621] = [__v_11]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 1u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_4, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(274, &__args[..])?) { [G::ZERO; OUT_274] } else { let (__hash, __hit) = record.function_queries[274].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[274].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => { aiur_fn_274::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_621] = [__v_11]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_621] = [__v_11]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_5, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(622, &__args[..])?) { [G::ZERO; OUT_622] } else { let (__hash, __hit) = record.function_queries[622].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[622].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[622].bump_multiplicity(__i); } let __ret: [G; OUT_622] = unsafe { *(record.function_queries[622].output_at(__i).as_ptr() as *const [G; OUT_622]) }; __ret }, _ => { aiur_fn_622::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_621] = [__v_12]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_621] = [__v_12]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_621] = [__v_11]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 3u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_4, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(621, &__args[..])?) { [G::ZERO; OUT_621] } else { let (__hash, __hit) = record.function_queries[621].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[621].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => { aiur_fn_621::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_5, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(621, &__args[..])?) { [G::ZERO; OUT_621] } else { let (__hash, __hit) = record.function_queries[621].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[621].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => { aiur_fn_621::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_621] = [__v_12]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_621] = [__v_12]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_621] = [__v_11]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 4u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_4, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(621, &__args[..])?) { [G::ZERO; OUT_621] } else { let (__hash, __hit) = record.function_queries[621].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[621].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => { aiur_fn_621::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_5, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(621, &__args[..])?) { [G::ZERO; OUT_621] } else { let (__hash, __hit) = record.function_queries[621].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[621].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => { aiur_fn_621::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_621] = [__v_12]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_621] = [__v_12]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_621] = [__v_11]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 5u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_4, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(621, &__args[..])?) { [G::ZERO; OUT_621] } else { let (__hash, __hit) = record.function_queries[621].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[621].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => { aiur_fn_621::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_5, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(621, &__args[..])?) { [G::ZERO; OUT_621] } else { let (__hash, __hit) = record.function_queries[621].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[621].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => { aiur_fn_621::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_621] = [__v_12]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_621] = [__v_12]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_621] = [__v_11]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 6u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 6u64 => { let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_4, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(621, &__args[..])?) { [G::ZERO; OUT_621] } else { let (__hash, __hit) = record.function_queries[621].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[621].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => { aiur_fn_621::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_5, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(621, &__args[..])?) { [G::ZERO; OUT_621] } else { let (__hash, __hit) = record.function_queries[621].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[621].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => { aiur_fn_621::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_6, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(621, &__args[..])?) { [G::ZERO; OUT_621] } else { let (__hash, __hit) = record.function_queries[621].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[621].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => { aiur_fn_621::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_621] = [__v_13]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_621] = [__v_13]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_621] = [__v_12]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_621] = [__v_11]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 7u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(287, &__args[..])?) { [G::ZERO; OUT_287] } else { let (__hash, __hit) = record.function_queries[287].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[287].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => { aiur_fn_287::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_621] = [__v_11]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_621] = [__v_11]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 8u64 => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 8u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = __v_5 - __v_9; match __v_12.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_6, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(621, &__args[..])?) { [G::ZERO; OUT_621] } else { let (__hash, __hit) = record.function_queries[621].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[621].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => { aiur_fn_621::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_621] = [__v_13]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_621] = [__v_13]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_621] = [__v_12]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_621] = [__v_11]; record.function_queries[621].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_622: usize = 2; -const IN_622: usize = 2; -const OUT_622: usize = 1; -fn aiur_fn_622(inp: [G; IN_622], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_622], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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(1).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() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_622] = [__v_8]; record.function_queries[622].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_622] = [__v_8]; record.function_queries[622].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(1).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() { 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_622] = [__v_8]; record.function_queries[622].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(274, &__args[..])?) { [G::ZERO; OUT_274] } else { let (__hash, __hit) = record.function_queries[274].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[274].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => { aiur_fn_274::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(622, &__args[..])?) { [G::ZERO; OUT_622] } else { let (__hash, __hit) = record.function_queries[622].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[622].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[622].bump_multiplicity(__i); } let __ret: [G; OUT_622] = unsafe { *(record.function_queries[622].output_at(__i).as_ptr() as *const [G; OUT_622]) }; __ret }, _ => { aiur_fn_622::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_622] = [__v_9]; record.function_queries[622].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_622] = [__v_9]; record.function_queries[622].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_623: usize = 2; -const IN_623: usize = 2; -const OUT_623: usize = 1; -fn aiur_fn_623(inp: [G; IN_623], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_623], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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(1).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() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_623] = [__v_8]; record.function_queries[623].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_623] = [__v_8]; record.function_queries[623].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(1).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() { 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_623] = [__v_8]; record.function_queries[623].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(621, &__args[..])?) { [G::ZERO; OUT_621] } else { let (__hash, __hit) = record.function_queries[621].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[621].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => { aiur_fn_621::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(623, &__args[..])?) { [G::ZERO; OUT_623] } else { let (__hash, __hit) = record.function_queries[623].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[623].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[623].bump_multiplicity(__i); } let __ret: [G; OUT_623] = unsafe { *(record.function_queries[623].output_at(__i).as_ptr() as *const [G; OUT_623]) }; __ret }, _ => { aiur_fn_623::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_623] = [__v_9]; record.function_queries[623].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_623] = [__v_9]; record.function_queries[623].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_624: usize = 13; -const IN_624: usize = 13; -const OUT_624: usize = 1; -fn aiur_fn_624(inp: [G; IN_624], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_624], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_0.as_canonical_u64() { 7u64 => { let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(615, &__args[..])?) { [G::ZERO; OUT_615] } else { let (__hash, __hit) = record.function_queries[615].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[615].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[615].bump_multiplicity(__i); } let __ret: [G; OUT_615] = unsafe { *(record.function_queries[615].output_at(__i).as_ptr() as *const [G; OUT_615]) }; __ret }, _ => { aiur_fn_615::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_624] = [__v_13]; record.function_queries[624].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 3] = [__v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_index_mut(1).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_624] = [__v_14]; record.function_queries[624].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_625: usize = 2; -const IN_625: usize = 2; -const OUT_625: usize = 1; -fn aiur_fn_625(inp: [G; IN_625], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_625], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_228] = { let __args: [G; IN_228] = [__v_0]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = __r_arr[10]; let __v_13: G = __r_arr[11]; let __v_14: G = __r_arr[12]; let __v_15: G = __r_arr[13]; let __v_16: G = __r_arr[14]; let __v_17: G = __r_arr[15]; let __v_18: G = __r_arr[16]; let __v_19: G = __r_arr[17]; let __v_20: G = __r_arr[18]; let __v_21: G = __r_arr[19]; let __v_22: G = __r_arr[20]; let __v_23: G = __r_arr[21]; let __v_24: G = __r_arr[22]; let __v_25: G = __r_arr[23]; let __v_26: G = __r_arr[24]; let __v_27: G = __r_arr[25]; let __v_28: G = __r_arr[26]; let __v_29: G = __r_arr[27]; let __v_30: G = __r_arr[28]; let __v_31: G = __r_arr[29]; let __v_32: G = __r_arr[30]; let __v_33: G = __r_arr[31]; let __v_34: G = __r_arr[32]; let __v_35: G = __r_arr[33]; let __v_36: G = __r_arr[34]; let __v_37: G = __r_arr[35]; let __v_38: G = __r_arr[36]; let __v_39: G = __r_arr[37]; let __v_40: G = __r_arr[38]; let __v_41: G = __r_arr[39]; let __v_42: G = __r_arr[40]; let __v_43: G = __r_arr[41]; let __v_44: G = __r_arr[42]; let __v_45: G = __r_arr[43]; let __v_46: G = __r_arr[44]; let __v_47: G = __r_arr[45]; let __v_48: G = __r_arr[46]; let __v_49: G = __r_arr[47]; match __v_2.as_canonical_u64() { _ => { match __v_2.as_canonical_u64() { 8u64 => { let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(626, &__args[..])?) { [G::ZERO; OUT_626] } else { let (__hash, __hit) = record.function_queries[626].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[626].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[626].bump_multiplicity(__i); } let __ret: [G; OUT_626] = unsafe { *(record.function_queries[626].output_at(__i).as_ptr() as *const [G; OUT_626]) }; __ret }, _ => { aiur_fn_626::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __ret: [G; OUT_625] = [__v_51]; record.function_queries[625].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_625] = [__v_1]; record.function_queries[625].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_626: usize = 5; -const IN_626: usize = 5; -const OUT_626: usize = 1; -fn aiur_fn_626(inp: [G; IN_626], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_626], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 47] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(15).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].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 __v_37: G = __loaded[32]; let __v_38: G = __loaded[33]; let __v_39: G = __loaded[34]; let __v_40: G = __loaded[35]; let __v_41: G = __loaded[36]; let __v_42: G = __loaded[37]; let __v_43: G = __loaded[38]; let __v_44: G = __loaded[39]; let __v_45: G = __loaded[40]; let __v_46: G = __loaded[41]; let __v_47: G = __loaded[42]; let __v_48: G = __loaded[43]; let __v_49: G = __loaded[44]; let __v_50: G = __loaded[45]; let __v_51: G = __loaded[46]; match __v_5.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_626] = [__v_4]; record.function_queries[626].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_0, __v_2, __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_52: G = __r_arr[0]; let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_54: G = __loaded[0]; let __v_55: G = __loaded[1]; let __v_56: G = __loaded[2]; let __v_57: G = __loaded[3]; let __v_58: G = __loaded[4]; let __v_59: G = __loaded[5]; let __v_60: G = __loaded[6]; let __v_61: G = __loaded[7]; let __v_62: G = __loaded[8]; let __v_63: G = __loaded[9]; let __v_64: G = __loaded[10]; let __v_65: G = __loaded[11]; match __v_54.as_canonical_u64() { 7u64 => { let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(613, &__args[..])?) { [G::ZERO; OUT_613] } else { let (__hash, __hit) = record.function_queries[613].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[613].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[613].bump_multiplicity(__i); } let __ret: [G; OUT_613] = unsafe { *(record.function_queries[613].output_at(__i).as_ptr() as *const [G; OUT_613]) }; __ret }, _ => { aiur_fn_613::(__args, __hash, record, io_buffer)? }, } } }; let __v_66: G = __r_arr[0]; let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_66]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_67.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_68: G = __loaded[0]; let __v_69: G = __loaded[1]; let __v_70: G = __loaded[2]; let __v_71: G = __loaded[3]; let __v_72: G = __loaded[4]; let __v_73: G = __loaded[5]; let __v_74: G = __loaded[6]; let __v_75: G = __loaded[7]; let __v_76: G = __loaded[8]; let __v_77: G = __loaded[9]; let __v_78: G = __loaded[10]; let __v_79: G = __loaded[11]; match __v_68.as_canonical_u64() { 5u64 => { let __ret: [G; OUT_626] = [__v_75]; record.function_queries[626].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_626] = [__v_4]; record.function_queries[626].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_626] = [__v_4]; record.function_queries[626].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_52: G = G::from_u64(1); let __v_53: G = __v_3 + __v_52; let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(626, &__args[..])?) { [G::ZERO; OUT_626] } else { let (__hash, __hit) = record.function_queries[626].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[626].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[626].bump_multiplicity(__i); } let __ret: [G; OUT_626] = unsafe { *(record.function_queries[626].output_at(__i).as_ptr() as *const [G; OUT_626]) }; __ret }, _ => { aiur_fn_626::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __ret: [G; OUT_626] = [__v_54]; record.function_queries[626].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_627: usize = 3; -const IN_627: usize = 3; -const OUT_627: usize = 1; -fn aiur_fn_627(inp: [G; IN_627], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_627], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_228] = { let __args: [G; IN_228] = [__v_0]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __v_12: G = __r_arr[9]; let __v_13: G = __r_arr[10]; let __v_14: G = __r_arr[11]; let __v_15: G = __r_arr[12]; let __v_16: G = __r_arr[13]; let __v_17: G = __r_arr[14]; let __v_18: G = __r_arr[15]; let __v_19: G = __r_arr[16]; let __v_20: G = __r_arr[17]; let __v_21: G = __r_arr[18]; let __v_22: G = __r_arr[19]; let __v_23: G = __r_arr[20]; let __v_24: G = __r_arr[21]; let __v_25: G = __r_arr[22]; let __v_26: G = __r_arr[23]; let __v_27: G = __r_arr[24]; let __v_28: G = __r_arr[25]; let __v_29: G = __r_arr[26]; let __v_30: G = __r_arr[27]; let __v_31: G = __r_arr[28]; let __v_32: G = __r_arr[29]; let __v_33: G = __r_arr[30]; let __v_34: G = __r_arr[31]; let __v_35: G = __r_arr[32]; let __v_36: G = __r_arr[33]; let __v_37: G = __r_arr[34]; let __v_38: G = __r_arr[35]; let __v_39: G = __r_arr[36]; let __v_40: G = __r_arr[37]; let __v_41: G = __r_arr[38]; let __v_42: G = __r_arr[39]; let __v_43: G = __r_arr[40]; let __v_44: G = __r_arr[41]; let __v_45: G = __r_arr[42]; let __v_46: G = __r_arr[43]; let __v_47: G = __r_arr[44]; let __v_48: G = __r_arr[45]; let __v_49: G = __r_arr[46]; let __v_50: G = __r_arr[47]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() { _ => { match __v_3.as_canonical_u64() { 8u64 => { let __v_51: G = G::from_u64(0); let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_4, __v_4, __v_0, __v_51, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(626, &__args[..])?) { [G::ZERO; OUT_626] } else { let (__hash, __hit) = record.function_queries[626].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[626].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[626].bump_multiplicity(__i); } let __ret: [G; OUT_626] = unsafe { *(record.function_queries[626].output_at(__i).as_ptr() as *const [G; OUT_626]) }; __ret }, _ => { aiur_fn_626::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; break '__mc_0 [__v_52]; }, _ => { break '__mc_0 [__v_1]; }, } }, } }; let __v_51: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_51]; 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_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; let __v_55: G = __r_arr[3]; let __v_56: G = __r_arr[4]; let __v_57: G = __r_arr[5]; let __v_58: G = __r_arr[6]; let __v_59: G = __r_arr[7]; let __v_60: G = __r_arr[8]; let __v_61: G = __r_arr[9]; let __v_62: G = __r_arr[10]; let __v_63: G = __r_arr[11]; let __v_64: G = __r_arr[12]; let __v_65: G = __r_arr[13]; let __v_66: G = __r_arr[14]; let __v_67: G = __r_arr[15]; let __v_68: G = __r_arr[16]; let __v_69: G = __r_arr[17]; let __v_70: G = __r_arr[18]; let __v_71: G = __r_arr[19]; let __v_72: G = __r_arr[20]; let __v_73: G = __r_arr[21]; let __v_74: G = __r_arr[22]; let __v_75: G = __r_arr[23]; let __v_76: G = __r_arr[24]; let __v_77: G = __r_arr[25]; let __v_78: G = __r_arr[26]; let __v_79: G = __r_arr[27]; let __v_80: G = __r_arr[28]; let __v_81: G = __r_arr[29]; let __v_82: G = __r_arr[30]; let __v_83: G = __r_arr[31]; let __v_84: G = __r_arr[32]; let __v_85: G = __r_arr[33]; let __v_86: G = __r_arr[34]; let __v_87: G = __r_arr[35]; let __v_88: G = __r_arr[36]; let __v_89: G = __r_arr[37]; let __v_90: G = __r_arr[38]; let __v_91: G = __r_arr[39]; let __v_92: G = __r_arr[40]; let __v_93: G = __r_arr[41]; let __v_94: G = __r_arr[42]; let __v_95: G = __r_arr[43]; let __v_96: G = __r_arr[44]; let __v_97: G = __r_arr[45]; let __v_98: G = __r_arr[46]; let __v_99: G = __r_arr[47]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_52.as_canonical_u64() { _ => { match __v_52.as_canonical_u64() { 8u64 => { let __v_100: G = G::from_u64(0); let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_53, __v_53, __v_51, __v_2, __v_100]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(619, &__args[..])?) { [G::ZERO; OUT_619] } else { let (__hash, __hit) = record.function_queries[619].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[619].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[619].bump_multiplicity(__i); } let __ret: [G; OUT_619] = unsafe { *(record.function_queries[619].output_at(__i).as_ptr() as *const [G; OUT_619]) }; __ret }, _ => { aiur_fn_619::(__args, __hash, record, io_buffer)? }, } } }; let __v_101: G = __r_arr[0]; break '__mc_1 [__v_101]; }, _ => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_100: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_100.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_101: G = __loaded[0]; let __v_102: G = __loaded[1]; let __v_103: G = __loaded[2]; let __v_104: G = __loaded[3]; let __v_105: G = __loaded[4]; let __v_106: G = __loaded[5]; let __v_107: G = __loaded[6]; let __v_108: G = __loaded[7]; let __v_109: G = __loaded[8]; let __v_110: G = __loaded[9]; let __v_111: G = __loaded[10]; let __v_112: G = __loaded[11]; match __v_101.as_canonical_u64() { 5u64 => { let __v_113: G = G::from_u64(0); let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_2, __v_102, __v_113]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(617, &__args[..])?) { [G::ZERO; OUT_617] } else { let (__hash, __hit) = record.function_queries[617].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[617].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[617].bump_multiplicity(__i); } let __ret: [G; OUT_617] = unsafe { *(record.function_queries[617].output_at(__i).as_ptr() as *const [G; OUT_617]) }; __ret }, _ => { aiur_fn_617::(__args, __hash, record, io_buffer)? }, } } }; let __v_114: G = __r_arr[0]; let __v_115: G = G::from_u64(1); let __v_116: G = { let __values: [G; 3] = [__v_115, __v_115, __v_115]; let __mq = record.memory_queries.get_index_mut(1).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_117: G = { let __values: [G; 6] = [__v_115, __v_115, __v_115, __v_115, __v_115, __v_115]; let __mq = record.memory_queries.get_index_mut(4).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_118: G = { let __values: [G; 6] = [__v_113, __v_51, __v_113, __v_116, __v_114, __v_117]; let __mq = record.memory_queries.get_index_mut(4).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 }, } }; break '__mc_1 [__v_118]; }, _ => { let __v_113: G = G::from_u64(1); let __v_114: G = { let __values: [G; 6] = [__v_113, __v_113, __v_113, __v_113, __v_113, __v_113]; let __mq = record.memory_queries.get_index_mut(4).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 }, } }; break '__mc_1 [__v_114]; }, } }, } }, } }; let __v_100: G = __mc_out___mc_1[0]; let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(611, &__args[..])?) { [G::ZERO; OUT_611] } else { let (__hash, __hit) = record.function_queries[611].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[611].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => { aiur_fn_611::(__args, __hash, record, io_buffer)? }, } } }; let __v_101: G = __r_arr[0]; match __v_101.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_627] = [__v_100]; record.function_queries[627].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_0, __v_51, __v_2, __v_100]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(628, &__args[..])?) { [G::ZERO; OUT_628] } else { let (__hash, __hit) = record.function_queries[628].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[628].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[628].bump_multiplicity(__i); } let __ret: [G; OUT_628] = unsafe { *(record.function_queries[628].output_at(__i).as_ptr() as *const [G; OUT_628]) }; __ret }, _ => { aiur_fn_628::(__args, __hash, record, io_buffer)? }, } } }; let __v_102: G = __r_arr[0]; let __ret: [G; OUT_627] = [__v_102]; record.function_queries[627].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_628: usize = 4; -const IN_628: usize = 4; -const OUT_628: usize = 1; -fn aiur_fn_628(inp: [G; IN_628], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_628], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_228] = { let __args: [G; IN_228] = [__v_0]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = __r_arr[3]; let __v_8: G = __r_arr[4]; let __v_9: G = __r_arr[5]; let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; let __v_12: G = __r_arr[8]; let __v_13: G = __r_arr[9]; let __v_14: G = __r_arr[10]; let __v_15: G = __r_arr[11]; let __v_16: G = __r_arr[12]; let __v_17: G = __r_arr[13]; let __v_18: G = __r_arr[14]; let __v_19: G = __r_arr[15]; let __v_20: G = __r_arr[16]; let __v_21: G = __r_arr[17]; let __v_22: G = __r_arr[18]; let __v_23: G = __r_arr[19]; let __v_24: G = __r_arr[20]; let __v_25: G = __r_arr[21]; let __v_26: G = __r_arr[22]; let __v_27: G = __r_arr[23]; let __v_28: G = __r_arr[24]; let __v_29: G = __r_arr[25]; let __v_30: G = __r_arr[26]; let __v_31: G = __r_arr[27]; let __v_32: G = __r_arr[28]; let __v_33: G = __r_arr[29]; let __v_34: G = __r_arr[30]; let __v_35: G = __r_arr[31]; let __v_36: G = __r_arr[32]; let __v_37: G = __r_arr[33]; let __v_38: G = __r_arr[34]; let __v_39: G = __r_arr[35]; let __v_40: G = __r_arr[36]; let __v_41: G = __r_arr[37]; let __v_42: G = __r_arr[38]; let __v_43: G = __r_arr[39]; let __v_44: G = __r_arr[40]; let __v_45: G = __r_arr[41]; let __v_46: G = __r_arr[42]; let __v_47: G = __r_arr[43]; let __v_48: G = __r_arr[44]; let __v_49: G = __r_arr[45]; let __v_50: G = __r_arr[46]; let __v_51: G = __r_arr[47]; match __v_4.as_canonical_u64() { _ => { match __v_4.as_canonical_u64() { 8u64 => { let __v_52: G = G::from_u64(0); let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(629, &__args[..])?) { [G::ZERO; OUT_629] } else { let (__hash, __hit) = record.function_queries[629].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[629].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[629].bump_multiplicity(__i); } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => { aiur_fn_629::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __ret: [G; OUT_628] = [__v_53]; record.function_queries[628].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_628] = [__v_3]; record.function_queries[628].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_629: usize = 7; -const IN_629: usize = 7; -const OUT_629: usize = 1; -fn aiur_fn_629(inp: [G; IN_629], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_629], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 47] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(15).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; let __v_11: G = __loaded[4]; let __v_12: G = __loaded[5]; let __v_13: G = __loaded[6]; let __v_14: G = __loaded[7]; let __v_15: G = __loaded[8]; let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; let __v_19: G = __loaded[12]; let __v_20: G = __loaded[13]; let __v_21: G = __loaded[14]; let __v_22: G = __loaded[15]; let __v_23: G = __loaded[16]; let __v_24: G = __loaded[17]; let __v_25: G = __loaded[18]; let __v_26: G = __loaded[19]; let __v_27: G = __loaded[20]; let __v_28: G = __loaded[21]; let __v_29: G = __loaded[22]; let __v_30: G = __loaded[23]; let __v_31: G = __loaded[24]; let __v_32: G = __loaded[25]; let __v_33: G = __loaded[26]; let __v_34: G = __loaded[27]; let __v_35: G = __loaded[28]; let __v_36: G = __loaded[29]; let __v_37: G = __loaded[30]; let __v_38: G = __loaded[31]; let __v_39: G = __loaded[32]; let __v_40: G = __loaded[33]; let __v_41: G = __loaded[34]; let __v_42: G = __loaded[35]; let __v_43: G = __loaded[36]; let __v_44: G = __loaded[37]; let __v_45: G = __loaded[38]; let __v_46: G = __loaded[39]; let __v_47: G = __loaded[40]; let __v_48: G = __loaded[41]; let __v_49: G = __loaded[42]; let __v_50: G = __loaded[43]; let __v_51: G = __loaded[44]; let __v_52: G = __loaded[45]; let __v_53: G = __loaded[46]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_629] = [__v_5]; record.function_queries[629].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_8.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_0, __v_2, __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_54: G = __r_arr[0]; let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_54]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_55.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_56: G = __loaded[0]; let __v_57: G = __loaded[1]; let __v_58: G = __loaded[2]; let __v_59: G = __loaded[3]; let __v_60: G = __loaded[4]; let __v_61: G = __loaded[5]; let __v_62: G = __loaded[6]; let __v_63: G = __loaded[7]; let __v_64: G = __loaded[8]; let __v_65: G = __loaded[9]; let __v_66: G = __loaded[10]; let __v_67: G = __loaded[11]; let __mc_out___mc_0: [G; 5] = '__mc_0: { match __v_56.as_canonical_u64() { 7u64 => { let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(613, &__args[..])?) { [G::ZERO; OUT_613] } else { let (__hash, __hit) = record.function_queries[613].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[613].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[613].bump_multiplicity(__i); } let __ret: [G; OUT_613] = unsafe { *(record.function_queries[613].output_at(__i).as_ptr() as *const [G; OUT_613]) }; __ret }, _ => { aiur_fn_613::(__args, __hash, record, io_buffer)? }, } } }; let __v_68: G = __r_arr[0]; let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_68]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_69: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; let __v_73: G = __loaded[3]; let __v_74: G = __loaded[4]; let __v_75: G = __loaded[5]; let __v_76: G = __loaded[6]; let __v_77: G = __loaded[7]; let __v_78: G = __loaded[8]; let __v_79: G = __loaded[9]; let __v_80: G = __loaded[10]; let __v_81: G = __loaded[11]; match __v_70.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_77, __v_3]; 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]; match __v_82.as_canonical_u64() { 1u64 => { let __v_83: G = G::from_u64(0); break '__mc_0 [__v_83, __v_68, __v_83, __v_73, __v_71]; }, _ => { let __v_83: G = G::from_u64(1); break '__mc_0 [__v_83, __v_68, __v_83, __v_73, __v_71]; }, } }, _ => { let __v_82: G = G::from_u64(0); break '__mc_0 [__v_82, __v_68, __v_82, __v_82, __v_82]; }, } }, _ => { let __v_68: G = G::from_u64(0); break '__mc_0 [__v_68, __v_3, __v_68, __v_68, __v_68]; }, } }; let __v_68: G = __mc_out___mc_0[0]; let __v_69: G = __mc_out___mc_0[1]; let __v_70: G = __mc_out___mc_0[2]; let __v_71: G = __mc_out___mc_0[3]; let __v_72: G = __mc_out___mc_0[4]; match __v_68.as_canonical_u64() { 0u64 => { let __v_73: G = G::from_u64(1); let __v_74: G = __v_6 + __v_73; let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(629, &__args[..])?) { [G::ZERO; OUT_629] } else { let (__hash, __hit) = record.function_queries[629].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[629].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[629].bump_multiplicity(__i); } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => { aiur_fn_629::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; let __ret: [G; OUT_629] = [__v_75]; record.function_queries[629].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__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_71]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(624, &__args[..])?) { [G::ZERO; OUT_624] } else { let (__hash, __hit) = record.function_queries[624].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[624].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[624].bump_multiplicity(__i); } let __ret: [G; OUT_624] = unsafe { *(record.function_queries[624].output_at(__i).as_ptr() as *const [G; OUT_624]) }; __ret }, _ => { aiur_fn_624::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(614, &__args[..])?) { [G::ZERO; OUT_614] } else { let (__hash, __hit) = record.function_queries[614].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[614].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[614].bump_multiplicity(__i); } let __ret: [G; OUT_614] = unsafe { *(record.function_queries[614].output_at(__i).as_ptr() as *const [G; OUT_614]) }; __ret }, _ => { aiur_fn_614::(__args, __hash, record, io_buffer)? }, } } }; let __v_74: G = __r_arr[0]; let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_5, __v_69, __v_73]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(620, &__args[..])?) { [G::ZERO; OUT_620] } else { let (__hash, __hit) = record.function_queries[620].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[620].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[620].bump_multiplicity(__i); } let __ret: [G; OUT_620] = unsafe { *(record.function_queries[620].output_at(__i).as_ptr() as *const [G; OUT_620]) }; __ret }, _ => { aiur_fn_620::(__args, __hash, record, io_buffer)? }, } } }; let __v_75: G = __r_arr[0]; match __v_75.as_canonical_u64() { 1u64 => { let __v_76: G = G::from_u64(1); let __v_77: G = __v_6 + __v_76; let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(629, &__args[..])?) { [G::ZERO; OUT_629] } else { let (__hash, __hit) = record.function_queries[629].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[629].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[629].bump_multiplicity(__i); } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => { aiur_fn_629::(__args, __hash, record, io_buffer)? }, } } }; let __v_78: G = __r_arr[0]; let __ret: [G; OUT_629] = [__v_78]; record.function_queries[629].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_76: G = G::from_u64(1); let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(774, &__args[..])?) { [G::ZERO; OUT_774] } else { let (__hash, __hit) = record.function_queries[774].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[774].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => { aiur_fn_774::(__args, __hash, record, io_buffer)? }, } } }; let __v_77: G = __r_arr[0]; let __v_78: G = __v_6 + __v_76; let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_78]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(629, &__args[..])?) { [G::ZERO; OUT_629] } else { let (__hash, __hit) = record.function_queries[629].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[629].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[629].bump_multiplicity(__i); } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => { aiur_fn_629::(__args, __hash, record, io_buffer)? }, } } }; let __v_79: G = __r_arr[0]; let __ret: [G; OUT_629] = [__v_79]; record.function_queries[629].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_54: G = G::from_u64(1); let __v_55: G = __v_6 + __v_54; let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(629, &__args[..])?) { [G::ZERO; OUT_629] } else { let (__hash, __hit) = record.function_queries[629].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[629].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[629].bump_multiplicity(__i); } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => { aiur_fn_629::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __ret: [G; OUT_629] = [__v_56]; record.function_queries[629].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_630: usize = 3; -const IN_630: usize = 3; -const OUT_630: usize = 2; -fn aiur_fn_630(inp: [G; IN_630], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_630], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_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() { 1u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_630] = [__v_9, __v_9]; record.function_queries[630].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_1]; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_630] = [__v_10, __v_2]; record.function_queries[630].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); let __v_11: G = __v_2 + __v_10; let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(630, &__args[..])?) { [G::ZERO; OUT_630] } else { let (__hash, __hit) = record.function_queries[630].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[630].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[630].bump_multiplicity(__i); } let __ret: [G; OUT_630] = unsafe { *(record.function_queries[630].output_at(__i).as_ptr() as *const [G; OUT_630]) }; __ret }, _ => { aiur_fn_630::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_630] = [__v_12, __v_13]; record.function_queries[630].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_631: usize = 5; -const IN_631: usize = 5; -const OUT_631: usize = 2; -fn aiur_fn_631(inp: [G; IN_631], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_631], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_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() { 1u64 => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_631] = [__v_11, __v_11]; record.function_queries[631].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_1]; 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_11: G = __r_arr[0]; let __v_12: G = __v_2 - __v_7; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(1); break '__mc_0 [__v_13]; }, _ => { let __v_13: G = G::from_u64(0); break '__mc_0 [__v_13]; }, } }; let __v_13: G = __mc_out___mc_0[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_2.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_8, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(623, &__args[..])?) { [G::ZERO; OUT_623] } else { let (__hash, __hit) = record.function_queries[623].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[623].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[623].bump_multiplicity(__i); } let __ret: [G; OUT_623] = unsafe { *(record.function_queries[623].output_at(__i).as_ptr() as *const [G; OUT_623]) }; __ret }, _ => { aiur_fn_623::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; break '__mc_1 [__v_14]; }, _ => { let __v_14: G = G::from_u64(1); break '__mc_1 [__v_14]; }, } }; let __v_14: G = __mc_out___mc_1[0]; let __v_15: G = __v_11 * __v_13; let __v_16: G = __v_15 * __v_14; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); let __ret: [G; OUT_631] = [__v_17, __v_4]; record.function_queries[631].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(1); let __v_18: G = __v_4 + __v_17; let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(631, &__args[..])?) { [G::ZERO; OUT_631] } else { let (__hash, __hit) = record.function_queries[631].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[631].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[631].bump_multiplicity(__i); } let __ret: [G; OUT_631] = unsafe { *(record.function_queries[631].output_at(__i).as_ptr() as *const [G; OUT_631]) }; __ret }, _ => { aiur_fn_631::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_631] = [__v_19, __v_20]; record.function_queries[631].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_632: usize = 2; -const IN_632: usize = 2; -const OUT_632: usize = 4; -fn aiur_fn_632(inp: [G; IN_632], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_632], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(4).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 __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 32] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_index_mut(12).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_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(1).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_632] = [__v_9, __v_8, __v_11, __v_11]; record.function_queries[632].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_632] = [__v_3, __v_4, __v_5, __v_6]; record.function_queries[632].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = __v_1 - __v_8; let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_7, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(632, &__args[..])?) { [G::ZERO; OUT_632] } else { let (__hash, __hit) = record.function_queries[632].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[632].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[632].bump_multiplicity(__i); } let __ret: [G; OUT_632] = unsafe { *(record.function_queries[632].output_at(__i).as_ptr() as *const [G; OUT_632]) }; __ret }, _ => { aiur_fn_632::(__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 __ret: [G; OUT_632] = [__v_10, __v_11, __v_12, __v_13]; record.function_queries[632].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_633: usize = 4; -const IN_633: usize = 4; -const OUT_633: usize = 1; -fn aiur_fn_633(inp: [G; IN_633], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_633], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(0); let __v_5: G = G::from_u64(1); let __v_6: G = __v_1 - __v_5; let __v_7: G = __v_6 - __v_0; let __v_8: G = { let __values: [G; 4] = [__v_4, __v_7, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_633] = [__v_8]; record.function_queries[633].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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() { 1u64 => { let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_3, __v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_633] = [__v_6]; record.function_queries[633].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_1 - __v_7; let __v_9: G = __v_8 - __v_0; let __v_10: G = { let __values: [G; 4] = [__v_6, __v_9, __v_6, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_633] = [__v_10]; record.function_queries[633].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_634: usize = 6; -const IN_634: usize = 6; -const OUT_634: usize = 1; -fn aiur_fn_634(inp: [G; IN_634], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_634], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_634] = [__v_0]; record.function_queries[634].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(633, &__args[..])?) { [G::ZERO; OUT_633] } else { let (__hash, __hit) = record.function_queries[633].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[633].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[633].bump_multiplicity(__i); } let __ret: [G; OUT_633] = unsafe { *(record.function_queries[633].output_at(__i).as_ptr() as *const [G; OUT_633]) }; __ret }, _ => { aiur_fn_633::(__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_316] = { let __args: [G; IN_316] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__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_1 - __v_13; let __v_15: G = __v_5 + __v_13; let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(634, &__args[..])?) { [G::ZERO; OUT_634] } else { let (__hash, __hit) = record.function_queries[634].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[634].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[634].bump_multiplicity(__i); } let __ret: [G; OUT_634] = unsafe { *(record.function_queries[634].output_at(__i).as_ptr() as *const [G; OUT_634]) }; __ret }, _ => { aiur_fn_634::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_634] = [__v_16]; record.function_queries[634].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_635: usize = 3; -const IN_635: usize = 3; -const OUT_635: usize = 1; -fn aiur_fn_635(inp: [G; IN_635], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_635], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_635] = [__v_4]; record.function_queries[635].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 5u64 => { let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = __v_2 - __v_8; let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_5, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(635, &__args[..])?) { [G::ZERO; OUT_635] } else { let (__hash, __hit) = record.function_queries[635].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[635].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[635].bump_multiplicity(__i); } let __ret: [G; OUT_635] = unsafe { *(record.function_queries[635].output_at(__i).as_ptr() as *const [G; OUT_635]) }; __ret }, _ => { aiur_fn_635::(__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(1).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_635] = [__v_11]; record.function_queries[635].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { 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(1).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_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 5u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = __v_2 - __v_15; let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_12, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(635, &__args[..])?) { [G::ZERO; OUT_635] } else { let (__hash, __hit) = record.function_queries[635].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[635].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[635].bump_multiplicity(__i); } let __ret: [G; OUT_635] = unsafe { *(record.function_queries[635].output_at(__i).as_ptr() as *const [G; OUT_635]) }; __ret }, _ => { aiur_fn_635::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_14, __v_11, __v_17]; let __mq = record.memory_queries.get_index_mut(1).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_635] = [__v_18]; record.function_queries[635].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_635] = [__v_15]; record.function_queries[635].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_636: usize = 4; -const IN_636: usize = 4; -const OUT_636: usize = 1; -fn aiur_fn_636(inp: [G; IN_636], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_636], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_1 - __v_3; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_636] = [__v_0]; record.function_queries[636].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = __v_1 - __v_6; let __v_8: G = __v_7 - __v_3; let __v_9: G = __v_8 + __v_2; let __v_10: G = { let __values: [G; 4] = [__v_5, __v_9, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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 = G::from_u64(3); let __v_12: G = { let __values: [G; 4] = [__v_11, __v_0, __v_10, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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 = __v_3 + __v_6; let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_12, __v_1, __v_2, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(636, &__args[..])?) { [G::ZERO; OUT_636] } else { let (__hash, __hit) = record.function_queries[636].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[636].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[636].bump_multiplicity(__i); } let __ret: [G; OUT_636] = unsafe { *(record.function_queries[636].output_at(__i).as_ptr() as *const [G; OUT_636]) }; __ret }, _ => { aiur_fn_636::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_636] = [__v_14]; record.function_queries[636].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_637: usize = 3; -const IN_637: usize = 3; -const OUT_637: usize = 1; -fn aiur_fn_637(inp: [G; IN_637], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_637], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_637] = [__v_0]; record.function_queries[637].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(3); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_6]; let __mq = record.memory_queries.get_index_mut(2).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_637] = { let __args: [G; IN_637] = [__v_9, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(637, &__args[..])?) { [G::ZERO; OUT_637] } else { let (__hash, __hit) = record.function_queries[637].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[637].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[637].bump_multiplicity(__i); } let __ret: [G; OUT_637] = unsafe { *(record.function_queries[637].output_at(__i).as_ptr() as *const [G; OUT_637]) }; __ret }, _ => { aiur_fn_637::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_637] = [__v_10]; record.function_queries[637].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_638: usize = 5; -const IN_638: usize = 5; -const OUT_638: usize = 1; -fn aiur_fn_638(inp: [G; IN_638], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_638], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(0); let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(636, &__args[..])?) { [G::ZERO; OUT_636] } else { let (__hash, __hit) = record.function_queries[636].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[636].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[636].bump_multiplicity(__i); } let __ret: [G; OUT_636] = unsafe { *(record.function_queries[636].output_at(__i).as_ptr() as *const [G; OUT_636]) }; __ret }, _ => { aiur_fn_636::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_638] = [__v_6]; record.function_queries[638].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(637, &__args[..])?) { [G::ZERO; OUT_637] } else { let (__hash, __hit) = record.function_queries[637].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[637].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[637].bump_multiplicity(__i); } let __ret: [G; OUT_637] = unsafe { *(record.function_queries[637].output_at(__i).as_ptr() as *const [G; OUT_637]) }; __ret }, _ => { aiur_fn_637::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_638] = [__v_5]; record.function_queries[638].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_639: usize = 3; -const IN_639: usize = 3; -const OUT_639: usize = 1; -fn aiur_fn_639(inp: [G; IN_639], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_639], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = __v_1 - __v_2; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_639] = [__v_0]; record.function_queries[639].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = __v_1 - __v_5; let __v_7: G = __v_6 - __v_2; let __v_8: G = { let __values: [G; 4] = [__v_4, __v_7, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(3); let __v_10: G = { let __values: [G; 4] = [__v_9, __v_0, __v_8, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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 = __v_2 + __v_5; let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_10, __v_1, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(639, &__args[..])?) { [G::ZERO; OUT_639] } else { let (__hash, __hit) = record.function_queries[639].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[639].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[639].bump_multiplicity(__i); } let __ret: [G; OUT_639] = unsafe { *(record.function_queries[639].output_at(__i).as_ptr() as *const [G; OUT_639]) }; __ret }, _ => { aiur_fn_639::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_639] = [__v_12]; record.function_queries[639].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_640: usize = 2; -const IN_640: usize = 2; -const OUT_640: usize = 1; -fn aiur_fn_640(inp: [G; IN_640], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_640], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_640] = [__v_0]; record.function_queries[640].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(5); let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(640, &__args[..])?) { [G::ZERO; OUT_640] } else { let (__hash, __hit) = record.function_queries[640].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[640].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[640].bump_multiplicity(__i); } let __ret: [G; OUT_640] = unsafe { *(record.function_queries[640].output_at(__i).as_ptr() as *const [G; OUT_640]) }; __ret }, _ => { aiur_fn_640::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_640] = [__v_8]; record.function_queries[640].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_641: usize = 3; -const IN_641: usize = 3; -const OUT_641: usize = 2; -fn aiur_fn_641(inp: [G; IN_641], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_641], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_641] = [__v_4, __v_1]; record.function_queries[641].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 5u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = __v_2 - __v_7; let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_0, __v_5, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(641, &__args[..])?) { [G::ZERO; OUT_641] } else { let (__hash, __hit) = record.function_queries[641].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[641].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[641].bump_multiplicity(__i); } let __ret: [G; OUT_641] = unsafe { *(record.function_queries[641].output_at(__i).as_ptr() as *const [G; OUT_641]) }; __ret }, _ => { aiur_fn_641::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_11, __v_4, __v_9]; let __mq = record.memory_queries.get_index_mut(1).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_641] = [__v_12, __v_10]; record.function_queries[641].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { 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(1).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_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 5u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = __v_2 - __v_14; let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_0, __v_12, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(641, &__args[..])?) { [G::ZERO; OUT_641] } else { let (__hash, __hit) = record.function_queries[641].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[641].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[641].bump_multiplicity(__i); } let __ret: [G; OUT_641] = unsafe { *(record.function_queries[641].output_at(__i).as_ptr() as *const [G; OUT_641]) }; __ret }, _ => { aiur_fn_641::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 3] = [__v_18, __v_11, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_641] = [__v_19, __v_17]; record.function_queries[641].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 3] = [__v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_index_mut(1).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_641] = [__v_15, __v_1]; record.function_queries[641].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }) } -const INPUT_SIZE_642: usize = 3; -const IN_642: usize = 3; -const OUT_642: usize = 1; -fn aiur_fn_642(inp: [G; IN_642], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_642], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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(1).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_642] = [__v_7]; record.function_queries[642].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__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_2 + __v_8; let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(642, &__args[..])?) { [G::ZERO; OUT_642] } else { let (__hash, __hit) = record.function_queries[642].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[642].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[642].bump_multiplicity(__i); } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => { aiur_fn_642::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_index_mut(1).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_642] = [__v_11]; record.function_queries[642].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_643: usize = 6; -const IN_643: usize = 6; -const OUT_643: usize = 1; -fn aiur_fn_643(inp: [G; IN_643], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_643], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_4.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(637, &__args[..])?) { [G::ZERO; OUT_637] } else { let (__hash, __hit) = record.function_queries[637].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[637].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[637].bump_multiplicity(__i); } let __ret: [G; OUT_637] = unsafe { *(record.function_queries[637].output_at(__i).as_ptr() as *const [G; OUT_637]) }; __ret }, _ => { aiur_fn_637::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_643] = [__v_6]; record.function_queries[643].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(647, &__args[..])?) { [G::ZERO; OUT_647] } else { let (__hash, __hit) = record.function_queries[647].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[647].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => { aiur_fn_647::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_643] = [__v_7]; record.function_queries[643].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_644: usize = 3; -const IN_644: usize = 3; -const OUT_644: usize = 1; -fn aiur_fn_644(inp: [G; IN_644], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_644], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = __v_1 - __v_2; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_644] = [__v_0]; record.function_queries[644].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __v_5: G = __v_1 - __v_2; let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_7: G = G::from_u64(3); let __v_8: G = { let __values: [G; 4] = [__v_7, __v_0, __v_6, __v_4]; let __mq = record.memory_queries.get_index_mut(2).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_9: G = G::from_u64(1); let __v_10: G = __v_2 + __v_9; let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_8, __v_1, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(644, &__args[..])?) { [G::ZERO; OUT_644] } else { let (__hash, __hit) = record.function_queries[644].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[644].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[644].bump_multiplicity(__i); } let __ret: [G; OUT_644] = unsafe { *(record.function_queries[644].output_at(__i).as_ptr() as *const [G; OUT_644]) }; __ret }, _ => { aiur_fn_644::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_644] = [__v_11]; record.function_queries[644].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_645: usize = 10; -const IN_645: usize = 10; -const OUT_645: usize = 1; -fn aiur_fn_645(inp: [G; IN_645], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_645], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_283] = { let __args: [G; IN_283] = [__v_2, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__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_634] = { let __args: [G; IN_634] = [__v_10, __v_3, __v_7, __v_8, __v_9, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(634, &__args[..])?) { [G::ZERO; OUT_634] } else { let (__hash, __hit) = record.function_queries[634].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[634].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[634].bump_multiplicity(__i); } let __ret: [G; OUT_634] = unsafe { *(record.function_queries[634].output_at(__i).as_ptr() as *const [G; OUT_634]) }; __ret }, _ => { aiur_fn_634::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_12, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(635, &__args[..])?) { [G::ZERO; OUT_635] } else { let (__hash, __hit) = record.function_queries[635].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[635].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[635].bump_multiplicity(__i); } let __ret: [G; OUT_635] = unsafe { *(record.function_queries[635].output_at(__i).as_ptr() as *const [G; OUT_635]) }; __ret }, _ => { aiur_fn_635::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(2); let __v_15: G = { let __values: [G; 4] = [__v_14, __v_1, __v_5, __v_11]; let __mq = record.memory_queries.get_index_mut(2).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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_15, __v_7, __v_4, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(636, &__args[..])?) { [G::ZERO; OUT_636] } else { let (__hash, __hit) = record.function_queries[636].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[636].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[636].bump_multiplicity(__i); } let __ret: [G; OUT_636] = unsafe { *(record.function_queries[636].output_at(__i).as_ptr() as *const [G; OUT_636]) }; __ret }, _ => { aiur_fn_636::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; break '__mc_0 [__v_17]; }, _ => { let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_15, __v_9, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(637, &__args[..])?) { [G::ZERO; OUT_637] } else { let (__hash, __hit) = record.function_queries[637].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[637].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[637].bump_multiplicity(__i); } let __ret: [G; OUT_637] = unsafe { *(record.function_queries[637].output_at(__i).as_ptr() as *const [G; OUT_637]) }; __ret }, _ => { aiur_fn_637::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, } }; let __v_16: G = __mc_out___mc_0[0]; let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_16, __v_4, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(639, &__args[..])?) { [G::ZERO; OUT_639] } else { let (__hash, __hit) = record.function_queries[639].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[639].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[639].bump_multiplicity(__i); } let __ret: [G; OUT_639] = unsafe { *(record.function_queries[639].output_at(__i).as_ptr() as *const [G; OUT_639]) }; __ret }, _ => { aiur_fn_639::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = { let __values: [G; 4] = [__v_19, __v_6, __v_17, __v_17]; let __mq = record.memory_queries.get_index_mut(2).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_21: G = G::from_u64(5); let __v_22: G = { let __values: [G; 4] = [__v_21, __v_18, __v_20, __v_17]; let __mq = record.memory_queries.get_index_mut(2).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_640] = { let __args: [G; IN_640] = [__v_22, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(640, &__args[..])?) { [G::ZERO; OUT_640] } else { let (__hash, __hit) = record.function_queries[640].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[640].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[640].bump_multiplicity(__i); } let __ret: [G; OUT_640] = unsafe { *(record.function_queries[640].output_at(__i).as_ptr() as *const [G; OUT_640]) }; __ret }, _ => { aiur_fn_640::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_645] = [__v_23]; record.function_queries[645].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_646: usize = 4; -const IN_646: usize = 4; -const OUT_646: usize = 1; -fn aiur_fn_646(inp: [G; IN_646], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_646], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(681, &__args[..])?) { [G::ZERO; OUT_681] } else { let (__hash, __hit) = record.function_queries[681].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[681].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[681].bump_multiplicity(__i); } let __ret: [G; OUT_681] = unsafe { *(record.function_queries[681].output_at(__i).as_ptr() as *const [G; OUT_681]) }; __ret }, _ => { aiur_fn_681::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_646] = [__v_5]; record.function_queries[646].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_647: usize = 4; -const IN_647: usize = 4; -const OUT_647: usize = 1; -fn aiur_fn_647(inp: [G; IN_647], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_647], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_1 - __v_3; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_647] = [__v_0]; record.function_queries[647].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = __v_2 - __v_3; let __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_8: G = G::from_u64(3); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = G::from_u64(1); let __v_11: G = __v_3 + __v_10; let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_9, __v_1, __v_2, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(647, &__args[..])?) { [G::ZERO; OUT_647] } else { let (__hash, __hit) = record.function_queries[647].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[647].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => { aiur_fn_647::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_647] = [__v_12]; record.function_queries[647].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_648: usize = 2; -const IN_648: usize = 2; -const OUT_648: usize = 1; -fn aiur_fn_648(inp: [G; IN_648], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_648], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_648] = [__v_0]; record.function_queries[648].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(4); let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(648, &__args[..])?) { [G::ZERO; OUT_648] } else { let (__hash, __hit) = record.function_queries[648].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[648].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[648].bump_multiplicity(__i); } let __ret: [G; OUT_648] = unsafe { *(record.function_queries[648].output_at(__i).as_ptr() as *const [G; OUT_648]) }; __ret }, _ => { aiur_fn_648::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_648] = [__v_8]; record.function_queries[648].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_649: usize = 10; -const IN_649: usize = 10; -const OUT_649: usize = 1; -fn aiur_fn_649(inp: [G; IN_649], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_649], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(0); let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_7, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(632, &__args[..])?) { [G::ZERO; OUT_632] } else { let (__hash, __hit) = record.function_queries[632].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[632].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[632].bump_multiplicity(__i); } let __ret: [G; OUT_632] = unsafe { *(record.function_queries[632].output_at(__i).as_ptr() as *const [G; OUT_632]) }; __ret }, _ => { aiur_fn_632::(__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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; let __v_19: G = __loaded[3]; let __v_20: G = __loaded[4]; let __v_21: G = __loaded[5]; let __v_22: G = __loaded[6]; let __v_23: G = __loaded[7]; let __v_24: G = __loaded[8]; let __v_25: G = __loaded[9]; let __v_26: G = __loaded[10]; let __v_27: G = __loaded[11]; match __v_16.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_0, __v_18, __v_17, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(650, &__args[..])?) { [G::ZERO; OUT_650] } else { let (__hash, __hit) = record.function_queries[650].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[650].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[650].bump_multiplicity(__i); } let __ret: [G; OUT_650] = unsafe { *(record.function_queries[650].output_at(__i).as_ptr() as *const [G; OUT_650]) }; __ret }, _ => { aiur_fn_650::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_649] = [__v_28]; record.function_queries[649].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_0, __v_1, __v_2, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(650, &__args[..])?) { [G::ZERO; OUT_650] } else { let (__hash, __hit) = record.function_queries[650].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[650].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[650].bump_multiplicity(__i); } let __ret: [G; OUT_650] = unsafe { *(record.function_queries[650].output_at(__i).as_ptr() as *const [G; OUT_650]) }; __ret }, _ => { aiur_fn_650::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_649] = [__v_28]; record.function_queries[649].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_650: usize = 12; -const IN_650: usize = 12; -const OUT_650: usize = 1; -fn aiur_fn_650(inp: [G; IN_650], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_650], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(780, &__args[..])?) { [G::ZERO; OUT_780] } else { let (__hash, __hit) = record.function_queries[780].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[780].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => { aiur_fn_780::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_8, __v_2, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(617, &__args[..])?) { [G::ZERO; OUT_617] } else { let (__hash, __hit) = record.function_queries[617].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[617].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[617].bump_multiplicity(__i); } let __ret: [G; OUT_617] = unsafe { *(record.function_queries[617].output_at(__i).as_ptr() as *const [G; OUT_617]) }; __ret }, _ => { aiur_fn_617::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_1, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_0, __v_15, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(641, &__args[..])?) { [G::ZERO; OUT_641] } else { let (__hash, __hit) = record.function_queries[641].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[641].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[641].bump_multiplicity(__i); } let __ret: [G; OUT_641] = unsafe { *(record.function_queries[641].output_at(__i).as_ptr() as *const [G; OUT_641]) }; __ret }, _ => { aiur_fn_641::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_0, __v_9, __v_7, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(646, &__args[..])?) { [G::ZERO; OUT_646] } else { let (__hash, __hit) = record.function_queries[646].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[646].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[646].bump_multiplicity(__i); } let __ret: [G; OUT_646] = unsafe { *(record.function_queries[646].output_at(__i).as_ptr() as *const [G; OUT_646]) }; __ret }, _ => { aiur_fn_646::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_0, __v_9, __v_10, __v_5, __v_12, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(664, &__args[..])?) { [G::ZERO; OUT_664] } else { let (__hash, __hit) = record.function_queries[664].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[664].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[664].bump_multiplicity(__i); } let __ret: [G; OUT_664] = unsafe { *(record.function_queries[664].output_at(__i).as_ptr() as *const [G; OUT_664]) }; __ret }, _ => { aiur_fn_664::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_9, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(632, &__args[..])?) { [G::ZERO; OUT_632] } else { let (__hash, __hit) = record.function_queries[632].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[632].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[632].bump_multiplicity(__i); } let __ret: [G; OUT_632] = unsafe { *(record.function_queries[632].output_at(__i).as_ptr() as *const [G; OUT_632]) }; __ret }, _ => { aiur_fn_632::(__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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; let __v_29: G = __loaded[3]; let __v_30: G = __loaded[4]; let __v_31: G = __loaded[5]; let __v_32: G = __loaded[6]; let __v_33: G = __loaded[7]; let __v_34: G = __loaded[8]; let __v_35: G = __loaded[9]; let __v_36: G = __loaded[10]; let __v_37: G = __loaded[11]; match __v_26.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_28, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__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_634] = { let __args: [G; IN_634] = [__v_38, __v_29, __v_5, __v_22, __v_23, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(634, &__args[..])?) { [G::ZERO; OUT_634] } else { let (__hash, __hit) = record.function_queries[634].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[634].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[634].bump_multiplicity(__i); } let __ret: [G; OUT_634] = unsafe { *(record.function_queries[634].output_at(__i).as_ptr() as *const [G; OUT_634]) }; __ret }, _ => { aiur_fn_634::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_40, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(635, &__args[..])?) { [G::ZERO; OUT_635] } else { let (__hash, __hit) = record.function_queries[635].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[635].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[635].bump_multiplicity(__i); } let __ret: [G; OUT_635] = unsafe { *(record.function_queries[635].output_at(__i).as_ptr() as *const [G; OUT_635]) }; __ret }, _ => { aiur_fn_635::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = __v_12 + __v_20; let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_41, __v_42, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(642, &__args[..])?) { [G::ZERO; OUT_642] } else { let (__hash, __hit) = record.function_queries[642].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[642].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[642].bump_multiplicity(__i); } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => { aiur_fn_642::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(2); let __v_45: G = { let __values: [G; 4] = [__v_44, __v_21, __v_24, __v_39]; let __mq = record.memory_queries.get_index_mut(2).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_46: G = __v_5 + __v_12; let __v_47: G = __v_46 + __v_20; let __v_48: G = __v_47 + __v_6; let __v_49: G = G::from_u64(1); let __v_50: G = __v_48 - __v_49; let __v_51: G = __v_42 + __v_6; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_22.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_45, __v_23, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(637, &__args[..])?) { [G::ZERO; OUT_637] } else { let (__hash, __hit) = record.function_queries[637].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[637].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[637].bump_multiplicity(__i); } let __ret: [G; OUT_637] = unsafe { *(record.function_queries[637].output_at(__i).as_ptr() as *const [G; OUT_637]) }; __ret }, _ => { aiur_fn_637::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; break '__mc_0 [__v_52]; }, _ => { let __v_52: G = G::from_u64(0); let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_45, __v_5, __v_50, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(647, &__args[..])?) { [G::ZERO; OUT_647] } else { let (__hash, __hit) = record.function_queries[647].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[647].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => { aiur_fn_647::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; break '__mc_0 [__v_53]; }, } }; let __v_52: G = __mc_out___mc_0[0]; let __v_53: G = G::from_u64(0); let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_52, __v_6, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(639, &__args[..])?) { [G::ZERO; OUT_639] } else { let (__hash, __hit) = record.function_queries[639].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[639].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[639].bump_multiplicity(__i); } let __ret: [G; OUT_639] = unsafe { *(record.function_queries[639].output_at(__i).as_ptr() as *const [G; OUT_639]) }; __ret }, _ => { aiur_fn_639::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = G::from_u64(1); let __v_56: G = __v_48 + __v_55; let __v_57: G = __v_56 - __v_55; let __v_58: G = __v_5 + __v_11; let __v_59: G = __v_57 - __v_58; let __v_60: G = { let __values: [G; 4] = [__v_53, __v_59, __v_53, __v_53]; let __mq = record.memory_queries.get_index_mut(2).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_644] = { let __args: [G; IN_644] = [__v_60, __v_6, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(644, &__args[..])?) { [G::ZERO; OUT_644] } else { let (__hash, __hit) = record.function_queries[644].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[644].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[644].bump_multiplicity(__i); } let __ret: [G; OUT_644] = unsafe { *(record.function_queries[644].output_at(__i).as_ptr() as *const [G; OUT_644]) }; __ret }, _ => { aiur_fn_644::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = G::from_u64(3); let __v_63: G = { let __values: [G; 4] = [__v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_index_mut(2).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_64: G = { let __values: [G; 4] = [__v_62, __v_61, __v_63, __v_53]; let __mq = record.memory_queries.get_index_mut(2).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_65: G = G::from_u64(5); let __v_66: G = { let __values: [G; 4] = [__v_65, __v_54, __v_64, __v_53]; let __mq = record.memory_queries.get_index_mut(2).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_640] = { let __args: [G; IN_640] = [__v_66, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(640, &__args[..])?) { [G::ZERO; OUT_640] } else { let (__hash, __hit) = record.function_queries[640].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[640].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[640].bump_multiplicity(__i); } let __ret: [G; OUT_640] = unsafe { *(record.function_queries[640].output_at(__i).as_ptr() as *const [G; OUT_640]) }; __ret }, _ => { aiur_fn_640::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_67, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(640, &__args[..])?) { [G::ZERO; OUT_640] } else { let (__hash, __hit) = record.function_queries[640].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[640].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[640].bump_multiplicity(__i); } let __ret: [G; OUT_640] = unsafe { *(record.function_queries[640].output_at(__i).as_ptr() as *const [G; OUT_640]) }; __ret }, _ => { aiur_fn_640::(__args, __hash, record, io_buffer)? }, } } }; let __v_68: G = __r_arr[0]; let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_68, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(640, &__args[..])?) { [G::ZERO; OUT_640] } else { let (__hash, __hit) = record.function_queries[640].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[640].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[640].bump_multiplicity(__i); } let __ret: [G; OUT_640] = unsafe { *(record.function_queries[640].output_at(__i).as_ptr() as *const [G; OUT_640]) }; __ret }, _ => { aiur_fn_640::(__args, __hash, record, io_buffer)? }, } } }; let __v_69: G = __r_arr[0]; let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_69, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(640, &__args[..])?) { [G::ZERO; OUT_640] } else { let (__hash, __hit) = record.function_queries[640].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[640].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[640].bump_multiplicity(__i); } let __ret: [G; OUT_640] = unsafe { *(record.function_queries[640].output_at(__i).as_ptr() as *const [G; OUT_640]) }; __ret }, _ => { aiur_fn_640::(__args, __hash, record, io_buffer)? }, } } }; let __v_70: G = __r_arr[0]; let __ret: [G; OUT_650] = [__v_70]; record.function_queries[650].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_26.as_canonical_u64())); }, } }) } -const INPUT_SIZE_651: usize = 27; -const IN_651: usize = 27; -const OUT_651: usize = 0; -fn aiur_fn_651(inp: [G; IN_651], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_651], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_1.as_canonical_u64() { 7u64 => { match __v_14.as_canonical_u64() { 5u64 => { let __mc_out___mc_0: [G; 13] = '__mc_0: { match __v_19.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(0); let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_21, __v_22, __v_27]; 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_28: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_29: G = __loaded[0]; let __v_30: G = __loaded[1]; let __v_31: G = __loaded[2]; let __v_32: G = __loaded[3]; let __v_33: G = __loaded[4]; let __v_34: G = __loaded[5]; let __v_35: G = __loaded[6]; let __v_36: G = __loaded[7]; let __v_37: G = __loaded[8]; let __v_38: G = __loaded[9]; let __v_39: G = __loaded[10]; let __v_40: G = __loaded[11]; let __v_41: G = G::from_u64(1); break '__mc_0 [__v_41, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40]; }, _ => { let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(1); let __v_29: G = { let __values: [G; 3] = [__v_27, __v_27, __v_27]; let __mq = record.memory_queries.get_index_mut(1).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; 4] = [__v_28, __v_29, __v_27, __v_27]; let __mq = record.memory_queries.get_index_mut(2).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_27, __v_27, __v_27, __v_30, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27]; }, } }; let __v_27: G = __mc_out___mc_0[0]; let __v_28: G = __mc_out___mc_0[1]; let __v_29: G = __mc_out___mc_0[2]; let __v_30: G = __mc_out___mc_0[3]; let __v_31: G = __mc_out___mc_0[4]; let __v_32: G = __mc_out___mc_0[5]; let __v_33: G = __mc_out___mc_0[6]; let __v_34: G = __mc_out___mc_0[7]; let __v_35: G = __mc_out___mc_0[8]; let __v_36: G = __mc_out___mc_0[9]; let __v_37: G = __mc_out___mc_0[10]; let __v_38: G = __mc_out___mc_0[11]; let __v_39: G = __mc_out___mc_0[12]; let __v_40: G = __v_17 + __v_18; let __v_41: G = G::from_u64(1); let __v_42: G = { let __values: [G; 3] = [__v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_index_mut(1).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_583] = { let __args: [G; IN_583] = [__v_0, __v_16, __v_40, __v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(583, &__args[..])?) { [G::ZERO; OUT_583] } else { let (__hash, __hit) = record.function_queries[583].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[583].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[583].bump_multiplicity(__i); } let __ret: [G; OUT_583] = unsafe { *(record.function_queries[583].output_at(__i).as_ptr() as *const [G; OUT_583]) }; __ret }, _ => { aiur_fn_583::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_21, __v_26]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(610, &__args[..])?) { [G::ZERO; OUT_610] } else { let (__hash, __hit) = record.function_queries[610].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[610].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[610].bump_multiplicity(__i); } let __ret: [G; OUT_610] = unsafe { *(record.function_queries[610].output_at(__i).as_ptr() as *const [G; OUT_610]) }; __ret }, _ => { aiur_fn_610::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_0, __v_43, __v_19, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(604, &__args[..])?) { [G::ZERO; OUT_604] } else { let (__hash, __hit) = record.function_queries[604].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[604].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[604].bump_multiplicity(__i); } let __ret: [G; OUT_604] = unsafe { *(record.function_queries[604].output_at(__i).as_ptr() as *const [G; OUT_604]) }; __ret }, _ => { aiur_fn_604::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_45.as_canonical_u64() { 1u64 => { let __v_46: G = G::from_u64(4); let __v_47: G = G::from_u64(0); let __v_48: G = { let __values: [G; 3] = [__v_46, __v_47, __v_47]; let __mq = record.memory_queries.get_index_mut(1).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_1 [__v_48]; }, _ => { let __v_46: G = G::from_u64(0); let __v_47: G = { let __values: [G; 3] = [__v_46, __v_46, __v_46]; let __mq = record.memory_queries.get_index_mut(1).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_1 [__v_47]; }, } }; let __v_46: G = __mc_out___mc_1[0]; let __v_47: G = G::from_u64(0); let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_2, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(684, &__args[..])?) { [G::ZERO; OUT_684] } else { let (__hash, __hit) = record.function_queries[684].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[684].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[684].bump_multiplicity(__i); } let __ret: [G; OUT_684] = unsafe { *(record.function_queries[684].output_at(__i).as_ptr() as *const [G; OUT_684]) }; __ret }, _ => { aiur_fn_684::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_11, __v_21, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(627, &__args[..])?) { [G::ZERO; OUT_627] } else { let (__hash, __hit) = record.function_queries[627].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[627].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[627].bump_multiplicity(__i); } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => { aiur_fn_627::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_49, __v_11, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(658, &__args[..])?) { [G::ZERO; OUT_658] } else { let (__hash, __hit) = record.function_queries[658].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[658].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[658].bump_multiplicity(__i); } let __ret: [G; OUT_658] = unsafe { *(record.function_queries[658].output_at(__i).as_ptr() as *const [G; OUT_658]) }; __ret }, _ => { aiur_fn_658::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(661, &__args[..])?) { [G::ZERO; OUT_661] } else { let (__hash, __hit) = record.function_queries[661].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[661].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[661].bump_multiplicity(__i); } let __ret: [G; OUT_661] = unsafe { *(record.function_queries[661].output_at(__i).as_ptr() as *const [G; OUT_661]) }; __ret }, _ => { aiur_fn_661::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(611, &__args[..])?) { [G::ZERO; OUT_611] } else { let (__hash, __hit) = record.function_queries[611].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[611].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => { aiur_fn_611::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(611, &__args[..])?) { [G::ZERO; OUT_611] } else { let (__hash, __hit) = record.function_queries[611].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[611].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => { aiur_fn_611::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; let __v_54: G = __v_52 * __v_53; let __v_55: G = G::from_u64(1); let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_11, __v_21]; 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_56: G = __r_arr[0]; let __v_57: G = __v_55 - __v_56; let __v_58: G = __v_54 * __v_57; let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_58.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(624, &__args[..])?) { [G::ZERO; OUT_624] } else { let (__hash, __hit) = record.function_queries[624].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[624].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[624].bump_multiplicity(__i); } let __ret: [G; OUT_624] = unsafe { *(record.function_queries[624].output_at(__i).as_ptr() as *const [G; OUT_624]) }; __ret }, _ => { aiur_fn_624::(__args, __hash, record, io_buffer)? }, } } }; let __v_59: G = __r_arr[0]; break '__mc_2 [__v_59]; }, _ => { let __v_59: G = G::from_u64(1); let __v_60: G = { let __values: [G; 3] = [__v_59, __v_59, __v_59]; let __mq = record.memory_queries.get_index_mut(1).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_2 [__v_60]; }, } }; let __v_59: G = __mc_out___mc_2[0]; let __v_60: G = G::from_u64(0); let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_49, __v_26, __v_58, __v_59, __v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(631, &__args[..])?) { [G::ZERO; OUT_631] } else { let (__hash, __hit) = record.function_queries[631].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[631].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[631].bump_multiplicity(__i); } let __ret: [G; OUT_631] = unsafe { *(record.function_queries[631].output_at(__i).as_ptr() as *const [G; OUT_631]) }; __ret }, _ => { aiur_fn_631::(__args, __hash, record, io_buffer)? }, } } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; match __v_61.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0, __v_49, __v_62, __v_19, __v_21, __v_22, __v_4, __v_6, __v_7, __v_48, __v_50, __v_51, __v_8, __v_3, __v_16, __v_15, __v_18, __v_46, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(652, &__args[..])?) { [G::ZERO; OUT_652] } else { let (__hash, __hit) = record.function_queries[652].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[652].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[652].bump_multiplicity(__i); } let __ret: [G; OUT_652] = unsafe { *(record.function_queries[652].output_at(__i).as_ptr() as *const [G; OUT_652]) }; __ret }, _ => { aiur_fn_652::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_651] = []; record.function_queries[651].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_63: G = G::from_u64(0); let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_49, __v_26, __v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(630, &__args[..])?) { [G::ZERO; OUT_630] } else { let (__hash, __hit) = record.function_queries[630].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[630].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[630].bump_multiplicity(__i); } let __ret: [G; OUT_630] = unsafe { *(record.function_queries[630].output_at(__i).as_ptr() as *const [G; OUT_630]) }; __ret }, _ => { aiur_fn_630::(__args, __hash, record, io_buffer)? }, } } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; match __v_64.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0, __v_49, __v_65, __v_19, __v_21, __v_22, __v_4, __v_6, __v_7, __v_48, __v_50, __v_51, __v_8, __v_3, __v_16, __v_15, __v_18, __v_46, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(652, &__args[..])?) { [G::ZERO; OUT_652] } else { let (__hash, __hit) = record.function_queries[652].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[652].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[652].bump_multiplicity(__i); } let __ret: [G; OUT_652] = unsafe { *(record.function_queries[652].output_at(__i).as_ptr() as *const [G; OUT_652]) }; __ret }, _ => { aiur_fn_652::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_651] = []; record.function_queries[651].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_64.as_canonical_u64())); }, } }, } }, _ => { let __ret: [G; OUT_651] = []; record.function_queries[651].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_652: usize = 19; -const IN_652: usize = 19; -const OUT_652: usize = 0; -fn aiur_fn_652(inp: [G; IN_652], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_652], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(632, &__args[..])?) { [G::ZERO; OUT_632] } else { let (__hash, __hit) = record.function_queries[632].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[632].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[632].bump_multiplicity(__i); } let __ret: [G; OUT_632] = unsafe { *(record.function_queries[632].output_at(__i).as_ptr() as *const [G; OUT_632]) }; __ret }, _ => { aiur_fn_632::(__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 __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_0, __v_14, __v_15, __v_6, __v_16, __v_17, __v_18, __v_1, __v_11, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(649, &__args[..])?) { [G::ZERO; OUT_649] } else { let (__hash, __hit) = record.function_queries[649].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[649].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[649].bump_multiplicity(__i); } let __ret: [G; OUT_649] = unsafe { *(record.function_queries[649].output_at(__i).as_ptr() as *const [G; OUT_649]) }; __ret }, _ => { aiur_fn_649::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); let __v_25: G = { let __values: [G; 3] = [__v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_index_mut(1).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_380] = { let __args: [G; IN_380] = [__v_0, __v_13, __v_23, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__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: Some("recursor's declared type is not def-eq to the canonical reconstruction".to_string()) }); } let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(780, &__args[..])?) { [G::ZERO; OUT_780] } else { let (__hash, __hit) = record.function_queries[780].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[780].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => { aiur_fn_780::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_0, __v_1, __v_11, __v_6, __v_27, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(664, &__args[..])?) { [G::ZERO; OUT_664] } else { let (__hash, __hit) = record.function_queries[664].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[664].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[664].bump_multiplicity(__i); } let __ret: [G; OUT_664] = unsafe { *(record.function_queries[664].output_at(__i).as_ptr() as *const [G; OUT_664]) }; __ret }, _ => { aiur_fn_664::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; if (__v_7 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("recursor motive count disagrees with the canonical reconstruction".to_string()) }); } if (__v_8 != __v_29) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("recursor minor count disagrees with the canonical reconstruction".to_string()) }); } let __v_30: G = G::from_u64(0); let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_1, __v_2, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(653, &__args[..])?) { [G::ZERO; OUT_653] } else { let (__hash, __hit) = record.function_queries[653].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[653].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[653].bump_multiplicity(__i); } let __ret: [G; OUT_653] = unsafe { *(record.function_queries[653].output_at(__i).as_ptr() as *const [G; OUT_653]) }; __ret }, _ => { aiur_fn_653::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_0, __v_3, __v_31, __v_4, __v_5, __v_6, __v_7, __v_8, __v_22, __v_9, __v_1, __v_10, __v_11, __v_20, __v_21, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(654, &__args[..])?) { [G::ZERO; OUT_654] } else { let (__hash, __hit) = record.function_queries[654].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[654].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[654].bump_multiplicity(__i); } let __ret: [G; OUT_654] = unsafe { *(record.function_queries[654].output_at(__i).as_ptr() as *const [G; OUT_654]) }; __ret }, _ => { aiur_fn_654::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_0, __v_12, __v_32, __v_6, __v_7, __v_8, __v_4, __v_5, __v_3, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(655, &__args[..])?) { [G::ZERO; OUT_655] } else { let (__hash, __hit) = record.function_queries[655].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[655].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[655].bump_multiplicity(__i); } let __ret: [G; OUT_655] = unsafe { *(record.function_queries[655].output_at(__i).as_ptr() as *const [G; OUT_655]) }; __ret }, _ => { aiur_fn_655::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_652] = []; record.function_queries[652].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_653: usize = 3; -const IN_653: usize = 3; -const OUT_653: usize = 1; -fn aiur_fn_653(inp: [G; IN_653], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_653], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = __v_2 - __v_1; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_653] = [__v_4]; record.function_queries[653].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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(0); let __ret: [G; OUT_653] = [__v_10]; record.function_queries[653].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; let __v_15: G = __loaded[4]; let __v_16: G = __loaded[5]; let __v_17: G = __loaded[6]; let __v_18: G = __loaded[7]; let __v_19: G = __loaded[8]; let __v_20: G = __loaded[9]; let __v_21: G = __loaded[10]; let __v_22: G = __loaded[11]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_11.as_canonical_u64() { 5u64 => { break '__mc_0 [__v_16]; }, _ => { let __v_23: G = G::from_u64(0); break '__mc_0 [__v_23]; }, } }; let __v_23: G = __mc_out___mc_0[0]; let __v_24: G = G::from_u64(1); let __v_25: G = __v_2 + __v_24; let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_9, __v_1, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(653, &__args[..])?) { [G::ZERO; OUT_653] } else { let (__hash, __hit) = record.function_queries[653].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[653].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[653].bump_multiplicity(__i); } let __ret: [G; OUT_653] = unsafe { *(record.function_queries[653].output_at(__i).as_ptr() as *const [G; OUT_653]) }; __ret }, _ => { aiur_fn_653::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __v_23 + __v_26; let __ret: [G; OUT_653] = [__v_27]; record.function_queries[653].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_654: usize = 16; -const IN_654: usize = 16; -const OUT_654: usize = 1; -fn aiur_fn_654(inp: [G; IN_654], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_654], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_1 - __v_15; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_index_mut(1).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_654] = [__v_18]; record.function_queries[654].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_3, __v_4, __v_15]; 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_17: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; let __v_21: G = __loaded[3]; let __v_22: G = __loaded[4]; let __v_23: G = __loaded[5]; let __v_24: G = __loaded[6]; let __v_25: G = __loaded[7]; let __v_26: G = __loaded[8]; let __v_27: G = __loaded[9]; let __v_28: G = __loaded[10]; let __v_29: G = __loaded[11]; match __v_18.as_canonical_u64() { 6u64 => { let __v_30: G = __v_2 + __v_15; let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_0, __v_20, __v_30, __v_5, __v_6, __v_7, __v_24, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(657, &__args[..])?) { [G::ZERO; OUT_657] } else { let (__hash, __hit) = record.function_queries[657].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[657].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[657].bump_multiplicity(__i); } let __ret: [G; OUT_657] = unsafe { *(record.function_queries[657].output_at(__i).as_ptr() as *const [G; OUT_657]) }; __ret }, _ => { aiur_fn_657::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); let __v_34: G = __v_15 + __v_33; let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(654, &__args[..])?) { [G::ZERO; OUT_654] } else { let (__hash, __hit) = record.function_queries[654].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[654].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[654].bump_multiplicity(__i); } let __ret: [G; OUT_654] = unsafe { *(record.function_queries[654].output_at(__i).as_ptr() as *const [G; OUT_654]) }; __ret }, _ => { aiur_fn_654::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 3] = [__v_32, __v_31, __v_35]; let __mq = record.memory_queries.get_index_mut(1).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_654] = [__v_36]; record.function_queries[654].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_30: G = G::from_u64(1); let __v_31: G = { let __values: [G; 3] = [__v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_index_mut(1).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_654] = [__v_31]; record.function_queries[654].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_655: usize = 10; -const IN_655: usize = 10; -const OUT_655: usize = 0; -fn aiur_fn_655(inp: [G; IN_655], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_655], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __loaded: [G; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(5))?; 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: 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_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]; match __v_10.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_655] = []; record.function_queries[655].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_11.as_canonical_u64() { _ => { if (__v_11 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("recursor rule is out of ctor order".to_string()) }); } let __v_15: G = { let __a_val = __v_11.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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 __v_16: G = G::from_u64(1); if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("recursor rule names a ctor index out of range".to_string()) }); } let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_6, __v_7, __v_11]; 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_17: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; let __v_21: G = __loaded[3]; let __v_22: G = __loaded[4]; let __v_23: G = __loaded[5]; let __v_24: G = __loaded[6]; let __v_25: G = __loaded[7]; let __v_26: G = __loaded[8]; let __v_27: G = __loaded[9]; let __v_28: G = __loaded[10]; let __v_29: G = __loaded[11]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_18.as_canonical_u64() { 6u64 => { if (__v_12 != __v_25) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("recursor rule field count differs from the ctor's".to_string()) }); } break '__mc_0 []; }, _ => { return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); }, } }; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_30: G = __loaded[0]; let __v_31: G = __loaded[1]; let __v_32: G = __loaded[2]; match __v_30.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_655] = []; record.function_queries[655].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_33: G = __v_3 + __v_4; let __v_34: G = __v_33 + __v_5; let __v_35: G = __v_34 + __v_12; let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(1); let __v_38: G = { let __values: [G; 3] = [__v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_index_mut(1).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_686] = { let __args: [G; IN_686] = [__v_13, __v_35, __v_36, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(686, &__args[..])?) { [G::ZERO; OUT_686] } else { let (__hash, __hit) = record.function_queries[686].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[686].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[686].bump_multiplicity(__i); } let __ret: [G; OUT_686] = unsafe { *(record.function_queries[686].output_at(__i).as_ptr() as *const [G; OUT_686]) }; __ret }, _ => { aiur_fn_686::(__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]; if (__v_40 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("recursor rule rhs has too few binders to peel".to_string()) }); } let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_39, __v_31, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(380, &__args[..])?) { [G::ZERO; OUT_380] } else { let (__hash, __hit) = record.function_queries[380].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[380].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => { aiur_fn_380::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; if (__v_42 != __v_37) { return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_37.as_canonical_u64(), msg: Some("recursor rule rhs differs from canonical reconstruction".to_string()) }); } let __v_43: G = __v_9 + __v_37; let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_0, __v_14, __v_32, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(655, &__args[..])?) { [G::ZERO; OUT_655] } else { let (__hash, __hit) = record.function_queries[655].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[655].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[655].bump_multiplicity(__i); } let __ret: [G; OUT_655] = unsafe { *(record.function_queries[655].output_at(__i).as_ptr() as *const [G; OUT_655]) }; __ret }, _ => { aiur_fn_655::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_655] = []; record.function_queries[655].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_30.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }) } -const INPUT_SIZE_656: usize = 13; -const IN_656: usize = 13; -const OUT_656: usize = 1; -fn aiur_fn_656(inp: [G; IN_656], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_656], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_656] = [__v_1]; record.function_queries[656].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_3, __v_12, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(759, &__args[..])?) { [G::ZERO; OUT_759] } else { let (__hash, __hit) = record.function_queries[759].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[759].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[759].bump_multiplicity(__i); } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => { aiur_fn_759::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 32] = [__v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(12).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_759] = { let __args: [G; IN_759] = [__v_5, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(759, &__args[..])?) { [G::ZERO; OUT_759] } else { let (__hash, __hit) = record.function_queries[759].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[759].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[759].bump_multiplicity(__i); } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => { aiur_fn_759::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_6, __v_17, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(759, &__args[..])?) { [G::ZERO; OUT_759] } else { let (__hash, __hit) = record.function_queries[759].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[759].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[759].bump_multiplicity(__i); } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => { aiur_fn_759::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = __v_7 + __v_8; let __v_22: G = __v_21 + __v_9; let __v_23: G = __v_22 + __v_10; let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_4, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = __v_10 - __v_14; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_24, __v_25, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = __v_8 + __v_9; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_26, __v_27, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(670, &__args[..])?) { [G::ZERO; OUT_670] } else { let (__hash, __hit) = record.function_queries[670].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[670].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[670].bump_multiplicity(__i); } let __ret: [G; OUT_670] = unsafe { *(record.function_queries[670].output_at(__i).as_ptr() as *const [G; OUT_670]) }; __ret }, _ => { aiur_fn_670::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = __v_23 + __v_31; let __v_33: G = G::from_u64(2); let __v_34: G = { let __values: [G; 4] = [__v_33, __v_19, __v_11, __v_16]; let __mq = record.memory_queries.get_index_mut(2).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_35: G = G::from_u64(1); let __v_36: G = __v_32 - __v_35; let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_34, __v_7, __v_36, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(647, &__args[..])?) { [G::ZERO; OUT_647] } else { let (__hash, __hit) = record.function_queries[647].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[647].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => { aiur_fn_647::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = __v_36 - __v_7; let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_37, __v_8, __v_38, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(647, &__args[..])?) { [G::ZERO; OUT_647] } else { let (__hash, __hit) = record.function_queries[647].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[647].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => { aiur_fn_647::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = __v_38 - __v_8; let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_39, __v_9, __v_40, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(647, &__args[..])?) { [G::ZERO; OUT_647] } else { let (__hash, __hit) = record.function_queries[647].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[647].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => { aiur_fn_647::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __v_42: G = { let __values: [G; 3] = [__v_35, __v_35, __v_35]; let __mq = record.memory_queries.get_index_mut(1).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_359] = { let __args: [G; IN_359] = [__v_0, __v_30, __v_42]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_43: G = __r_arr[0]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_43]; 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_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_45, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_41, __v_46]; 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_47: G = __r_arr[0]; let __v_48: G = __v_10 - __v_35; let __v_49: G = __v_48 - __v_14; let __v_50: G = __v_49 + __v_31; let __v_51: G = { let __values: [G; 4] = [__v_16, __v_50, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(2).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_639] = { let __args: [G; IN_639] = [__v_51, __v_31, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(639, &__args[..])?) { [G::ZERO; OUT_639] } else { let (__hash, __hit) = record.function_queries[639].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[639].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[639].bump_multiplicity(__i); } let __ret: [G; OUT_639] = unsafe { *(record.function_queries[639].output_at(__i).as_ptr() as *const [G; OUT_639]) }; __ret }, _ => { aiur_fn_639::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(3); let __v_54: G = { let __values: [G; 4] = [__v_53, __v_47, __v_52, __v_16]; let __mq = record.memory_queries.get_index_mut(2).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_648] = { let __args: [G; IN_648] = [__v_54, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(648, &__args[..])?) { [G::ZERO; OUT_648] } else { let (__hash, __hit) = record.function_queries[648].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[648].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[648].bump_multiplicity(__i); } let __ret: [G; OUT_648] = unsafe { *(record.function_queries[648].output_at(__i).as_ptr() as *const [G; OUT_648]) }; __ret }, _ => { aiur_fn_648::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __v_56: G = { let __values: [G; 4] = [__v_53, __v_1, __v_55, __v_16]; let __mq = record.memory_queries.get_index_mut(2).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_57: G = __v_12 + __v_35; let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_0, __v_56, __v_15, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_57]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(656, &__args[..])?) { [G::ZERO; OUT_656] } else { let (__hash, __hit) = record.function_queries[656].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[656].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[656].bump_multiplicity(__i); } let __ret: [G; OUT_656] = unsafe { *(record.function_queries[656].output_at(__i).as_ptr() as *const [G; OUT_656]) }; __ret }, _ => { aiur_fn_656::(__args, __hash, record, io_buffer)? }, } } }; let __v_58: G = __r_arr[0]; let __ret: [G; OUT_656] = [__v_58]; record.function_queries[656].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); }, } }) } -const INPUT_SIZE_657: usize = 14; -const IN_657: usize = 14; -const OUT_657: usize = 1; -fn aiur_fn_657(inp: [G; IN_657], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_657], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_1, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_14, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(576, &__args[..])?) { [G::ZERO; OUT_576] } else { let (__hash, __hit) = record.function_queries[576].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[576].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => { aiur_fn_576::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(667, &__args[..])?) { [G::ZERO; OUT_667] } else { let (__hash, __hit) = record.function_queries[667].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[667].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[667].bump_multiplicity(__i); } let __ret: [G; OUT_667] = unsafe { *(record.function_queries[667].output_at(__i).as_ptr() as *const [G; OUT_667]) }; __ret }, _ => { aiur_fn_667::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __v_3 + __v_4; let __v_19: G = __v_18 + __v_5; let __v_20: G = __v_19 + __v_17; let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_0, __v_14, __v_6, __v_6, __v_16, __v_12, __v_13, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(668, &__args[..])?) { [G::ZERO; OUT_668] } else { let (__hash, __hit) = record.function_queries[668].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[668].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[668].bump_multiplicity(__i); } let __ret: [G; OUT_668] = unsafe { *(record.function_queries[668].output_at(__i).as_ptr() as *const [G; OUT_668]) }; __ret }, _ => { aiur_fn_668::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; 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(1).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_680] = { let __args: [G; IN_680] = [__v_0, __v_21, __v_9, __v_23, __v_23, __v_23, __v_16, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(680, &__args[..])?) { [G::ZERO; OUT_680] } else { let (__hash, __hit) = record.function_queries[680].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[680].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[680].bump_multiplicity(__i); } let __ret: [G; OUT_680] = unsafe { *(record.function_queries[680].output_at(__i).as_ptr() as *const [G; OUT_680]) }; __ret }, _ => { aiur_fn_680::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = __r_arr[2]; let __v_27: G = __r_arr[3]; let __v_28: G = __v_20 - __v_22; let __v_29: G = __v_18 + __v_2; let __v_30: G = __v_28 - __v_29; let __v_31: G = { let __values: [G; 4] = [__v_16, __v_30, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(2).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_674] = { let __args: [G; IN_674] = [__v_31, __v_17, __v_17, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(674, &__args[..])?) { [G::ZERO; OUT_674] } else { let (__hash, __hit) = record.function_queries[674].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[674].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[674].bump_multiplicity(__i); } let __ret: [G; OUT_674] = unsafe { *(record.function_queries[674].output_at(__i).as_ptr() as *const [G; OUT_674]) }; __ret }, _ => { aiur_fn_674::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_0, __v_32, __v_25, __v_26, __v_24, __v_10, __v_11, __v_3, __v_4, __v_5, __v_17, __v_8, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(656, &__args[..])?) { [G::ZERO; OUT_656] } else { let (__hash, __hit) = record.function_queries[656].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[656].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[656].bump_multiplicity(__i); } let __ret: [G; OUT_656] = unsafe { *(record.function_queries[656].output_at(__i).as_ptr() as *const [G; OUT_656]) }; __ret }, _ => { aiur_fn_656::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __ret: [G; OUT_657] = [__v_33]; record.function_queries[657].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_658: usize = 3; -const IN_658: usize = 3; -const OUT_658: usize = 1; -fn aiur_fn_658(inp: [G; IN_658], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_658], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_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() { 1u64 => { 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(1).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_658] = [__v_10]; record.function_queries[658].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(659, &__args[..])?) { [G::ZERO; OUT_659] } else { let (__hash, __hit) = record.function_queries[659].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[659].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[659].bump_multiplicity(__i); } let __ret: [G; OUT_659] = unsafe { *(record.function_queries[659].output_at(__i).as_ptr() as *const [G; OUT_659]) }; __ret }, _ => { aiur_fn_659::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(658, &__args[..])?) { [G::ZERO; OUT_658] } else { let (__hash, __hit) = record.function_queries[658].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[658].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[658].bump_multiplicity(__i); } let __ret: [G; OUT_658] = unsafe { *(record.function_queries[658].output_at(__i).as_ptr() as *const [G; OUT_658]) }; __ret }, _ => { aiur_fn_658::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_10, __v_9, __v_11]; let __mq = record.memory_queries.get_index_mut(1).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_658] = [__v_12]; record.function_queries[658].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_659: usize = 5; -const IN_659: usize = 5; -const OUT_659: usize = 1; -fn aiur_fn_659(inp: [G; IN_659], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_659], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; let __v_8: G = __r_arr[3]; let __v_9: G = __r_arr[4]; let __v_10: G = __r_arr[5]; let __v_11: G = __r_arr[6]; let __v_12: G = __r_arr[7]; let __v_13: G = __r_arr[8]; let __v_14: G = __r_arr[9]; let __v_15: G = __r_arr[10]; let __v_16: G = __r_arr[11]; let __v_17: G = __r_arr[12]; let __v_18: G = __r_arr[13]; let __v_19: G = __r_arr[14]; let __v_20: G = __r_arr[15]; let __v_21: G = __r_arr[16]; let __v_22: G = __r_arr[17]; let __v_23: G = __r_arr[18]; let __v_24: G = __r_arr[19]; let __v_25: G = __r_arr[20]; let __v_26: G = __r_arr[21]; let __v_27: G = __r_arr[22]; let __v_28: G = __r_arr[23]; let __v_29: G = __r_arr[24]; let __v_30: G = __r_arr[25]; let __v_31: G = __r_arr[26]; let __v_32: G = __r_arr[27]; let __v_33: G = __r_arr[28]; let __v_34: G = __r_arr[29]; let __v_35: G = __r_arr[30]; let __v_36: G = __r_arr[31]; let __v_37: G = __r_arr[32]; let __v_38: G = __r_arr[33]; let __v_39: G = __r_arr[34]; let __v_40: G = __r_arr[35]; let __v_41: G = __r_arr[36]; let __v_42: G = __r_arr[37]; let __v_43: G = __r_arr[38]; let __v_44: G = __r_arr[39]; let __v_45: G = __r_arr[40]; let __v_46: G = __r_arr[41]; let __v_47: G = __r_arr[42]; let __v_48: G = __r_arr[43]; let __v_49: G = __r_arr[44]; let __v_50: G = __r_arr[45]; let __v_51: G = __r_arr[46]; let __v_52: G = __r_arr[47]; match __v_5.as_canonical_u64() { _ => { match __v_5.as_canonical_u64() { 8u64 => { let __v_53: G = G::from_u64(0); let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(660, &__args[..])?) { [G::ZERO; OUT_660] } else { let (__hash, __hit) = record.function_queries[660].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[660].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[660].bump_multiplicity(__i); } let __ret: [G; OUT_660] = unsafe { *(record.function_queries[660].output_at(__i).as_ptr() as *const [G; OUT_660]) }; __ret }, _ => { aiur_fn_660::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __ret: [G; OUT_659] = [__v_54]; record.function_queries[659].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_659] = [__v_4]; record.function_queries[659].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_660: usize = 8; -const IN_660: usize = 8; -const OUT_660: usize = 1; -fn aiur_fn_660(inp: [G; IN_660], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_660], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 47] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(15).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __v_14: G = __loaded[6]; let __v_15: G = __loaded[7]; let __v_16: G = __loaded[8]; let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; let __v_20: G = __loaded[12]; let __v_21: G = __loaded[13]; let __v_22: G = __loaded[14]; let __v_23: G = __loaded[15]; let __v_24: G = __loaded[16]; let __v_25: G = __loaded[17]; let __v_26: G = __loaded[18]; let __v_27: G = __loaded[19]; let __v_28: G = __loaded[20]; let __v_29: G = __loaded[21]; let __v_30: G = __loaded[22]; let __v_31: G = __loaded[23]; let __v_32: G = __loaded[24]; let __v_33: G = __loaded[25]; let __v_34: G = __loaded[26]; let __v_35: G = __loaded[27]; let __v_36: G = __loaded[28]; let __v_37: G = __loaded[29]; let __v_38: G = __loaded[30]; let __v_39: G = __loaded[31]; let __v_40: G = __loaded[32]; let __v_41: G = __loaded[33]; let __v_42: G = __loaded[34]; let __v_43: G = __loaded[35]; let __v_44: G = __loaded[36]; let __v_45: G = __loaded[37]; let __v_46: G = __loaded[38]; let __v_47: G = __loaded[39]; let __v_48: G = __loaded[40]; let __v_49: G = __loaded[41]; let __v_50: G = __loaded[42]; let __v_51: G = __loaded[43]; let __v_52: G = __loaded[44]; let __v_53: G = __loaded[45]; let __v_54: G = __loaded[46]; match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_660] = [__v_6]; record.function_queries[660].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { 2u64 => { let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_0, __v_2, __v_7]; 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_55: G = __r_arr[0]; let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_57: G = __loaded[0]; let __v_58: G = __loaded[1]; let __v_59: G = __loaded[2]; let __v_60: G = __loaded[3]; let __v_61: G = __loaded[4]; let __v_62: G = __loaded[5]; let __v_63: G = __loaded[6]; let __v_64: G = __loaded[7]; let __v_65: G = __loaded[8]; let __v_66: G = __loaded[9]; let __v_67: G = __loaded[10]; let __v_68: G = __loaded[11]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_57.as_canonical_u64() { 7u64 => { let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(613, &__args[..])?) { [G::ZERO; OUT_613] } else { let (__hash, __hit) = record.function_queries[613].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[613].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[613].bump_multiplicity(__i); } let __ret: [G; OUT_613] = unsafe { *(record.function_queries[613].output_at(__i).as_ptr() as *const [G; OUT_613]) }; __ret }, _ => { aiur_fn_613::(__args, __hash, record, io_buffer)? }, } } }; let __v_69: G = __r_arr[0]; let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_69]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_70: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_70.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_71: G = __loaded[0]; let __v_72: G = __loaded[1]; let __v_73: G = __loaded[2]; let __v_74: G = __loaded[3]; let __v_75: G = __loaded[4]; let __v_76: G = __loaded[5]; let __v_77: G = __loaded[6]; let __v_78: G = __loaded[7]; let __v_79: G = __loaded[8]; let __v_80: G = __loaded[9]; let __v_81: G = __loaded[10]; let __v_82: G = __loaded[11]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_71.as_canonical_u64() { 5u64 => { break '__mc_1 [__v_74]; }, _ => { let __v_83: G = G::from_u64(0); break '__mc_1 [__v_83]; }, } }; let __v_83: G = __mc_out___mc_1[0]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_69, __v_3]; 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]; match __v_84.as_canonical_u64() { 1u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __v_85: G = G::from_u64(1); break '__mc_0 [__v_85]; }, _ => { let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(615, &__args[..])?) { [G::ZERO; OUT_615] } else { let (__hash, __hit) = record.function_queries[615].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[615].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[615].bump_multiplicity(__i); } let __ret: [G; OUT_615] = unsafe { *(record.function_queries[615].output_at(__i).as_ptr() as *const [G; OUT_615]) }; __ret }, _ => { aiur_fn_615::(__args, __hash, record, io_buffer)? }, } } }; let __v_85: G = __r_arr[0]; let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_85, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(623, &__args[..])?) { [G::ZERO; OUT_623] } else { let (__hash, __hit) = record.function_queries[623].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[623].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[623].bump_multiplicity(__i); } let __ret: [G; OUT_623] = unsafe { *(record.function_queries[623].output_at(__i).as_ptr() as *const [G; OUT_623]) }; __ret }, _ => { aiur_fn_623::(__args, __hash, record, io_buffer)? }, } } }; let __v_86: G = __r_arr[0]; break '__mc_0 [__v_86]; }, } }, _ => { let __v_85: G = G::from_u64(0); break '__mc_0 [__v_85]; }, } }, _ => { let __v_69: G = G::from_u64(0); break '__mc_0 [__v_69]; }, } }; let __v_69: G = __mc_out___mc_0[0]; match __v_69.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_660] = [__v_55]; record.function_queries[660].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_70: G = G::from_u64(1); let __v_71: G = __v_7 + __v_70; let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(660, &__args[..])?) { [G::ZERO; OUT_660] } else { let (__hash, __hit) = record.function_queries[660].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[660].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[660].bump_multiplicity(__i); } let __ret: [G; OUT_660] = unsafe { *(record.function_queries[660].output_at(__i).as_ptr() as *const [G; OUT_660]) }; __ret }, _ => { aiur_fn_660::(__args, __hash, record, io_buffer)? }, } } }; let __v_72: G = __r_arr[0]; let __ret: [G; OUT_660] = [__v_72]; record.function_queries[660].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_55: G = G::from_u64(1); let __v_56: G = __v_7 + __v_55; let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(660, &__args[..])?) { [G::ZERO; OUT_660] } else { let (__hash, __hit) = record.function_queries[660].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[660].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[660].bump_multiplicity(__i); } let __ret: [G; OUT_660] = unsafe { *(record.function_queries[660].output_at(__i).as_ptr() as *const [G; OUT_660]) }; __ret }, _ => { aiur_fn_660::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __ret: [G; OUT_660] = [__v_57]; record.function_queries[660].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } -const INPUT_SIZE_661: usize = 1; -const IN_661: usize = 1; -const OUT_661: usize = 1; -fn aiur_fn_661(inp: [G; IN_661], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_661], ExecError> { stacker::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(4).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(1).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_661] = [__v_8]; record.function_queries[661].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() { 5u64 => { break '__mc_0 [__v_11]; }, _ => { let __v_20: G = G::from_u64(0); break '__mc_0 [__v_20]; }, } }; let __v_20: G = __mc_out___mc_0[0]; let __v_21: G = G::from_u64(0); let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(661, &__args[..])?) { [G::ZERO; OUT_661] } else { let (__hash, __hit) = record.function_queries[661].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[661].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[661].bump_multiplicity(__i); } let __ret: [G; OUT_661] = unsafe { *(record.function_queries[661].output_at(__i).as_ptr() as *const [G; OUT_661]) }; __ret }, _ => { aiur_fn_661::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 3] = [__v_21, __v_20, __v_22]; let __mq = record.memory_queries.get_index_mut(1).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_661] = [__v_23]; record.function_queries[661].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_662: usize = 3; -const IN_662: usize = 3; -const OUT_662: usize = 1; -fn aiur_fn_662(inp: [G; IN_662], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_662], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_240] = { let __args: [G; IN_240] = [__v_0]; 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_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 __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_1]; 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_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 = G::from_u64(4); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 3] = [__v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_index_mut(1).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_82] = { let __args: [G; IN_82] = [__v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_22, __v_22, __v_22, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(82, &__args[..])?) { [G::ZERO; OUT_82] } else { let (__hash, __hit) = record.function_queries[82].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[82].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => { aiur_fn_82::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(23, &__args[..])?) { [G::ZERO; OUT_23] } else { let (__hash, __hit) = record.function_queries[23].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[23].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[23].bump_multiplicity(__i); } let __ret: [G; OUT_23] = unsafe { *(record.function_queries[23].output_at(__i).as_ptr() as *const [G; OUT_23]) }; __ret }, _ => { aiur_fn_23::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_662] = [__v_24]; record.function_queries[662].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_663: usize = 16; -const IN_663: usize = 16; -const OUT_663: usize = 1; -fn aiur_fn_663(inp: [G; IN_663], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_663], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_13 - __v_15; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_index_mut(1).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_663] = [__v_18]; record.function_queries[663].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_11, __v_12, __v_15]; 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_17: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; let __v_21: G = __loaded[3]; let __v_22: G = __loaded[4]; let __v_23: G = __loaded[5]; let __v_24: G = __loaded[6]; let __v_25: G = __loaded[7]; let __v_26: G = __loaded[8]; let __v_27: G = __loaded[9]; let __v_28: G = __loaded[10]; let __v_29: G = __loaded[11]; match __v_18.as_canonical_u64() { 6u64 => { let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_12, __v_15, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(662, &__args[..])?) { [G::ZERO; OUT_662] } else { let (__hash, __hit) = record.function_queries[662].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[662].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[662].bump_multiplicity(__i); } let __ret: [G; OUT_662] = unsafe { *(record.function_queries[662].output_at(__i).as_ptr() as *const [G; OUT_662]) }; __ret }, _ => { aiur_fn_662::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_0, __v_30, __v_20, __v_24, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_14, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(669, &__args[..])?) { [G::ZERO; OUT_669] } else { let (__hash, __hit) = record.function_queries[669].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[669].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[669].bump_multiplicity(__i); } let __ret: [G; OUT_669] = unsafe { *(record.function_queries[669].output_at(__i).as_ptr() as *const [G; OUT_669]) }; __ret }, _ => { aiur_fn_669::(__args, __hash, record, io_buffer)? }, } } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); let __v_34: G = __v_14 + __v_33; let __v_35: G = __v_15 + __v_33; let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_34, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(663, &__args[..])?) { [G::ZERO; OUT_663] } else { let (__hash, __hit) = record.function_queries[663].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[663].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[663].bump_multiplicity(__i); } let __ret: [G; OUT_663] = unsafe { *(record.function_queries[663].output_at(__i).as_ptr() as *const [G; OUT_663]) }; __ret }, _ => { aiur_fn_663::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 3] = [__v_32, __v_31, __v_36]; let __mq = record.memory_queries.get_index_mut(1).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_663] = [__v_37]; record.function_queries[663].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_664: usize = 6; -const IN_664: usize = 6; -const OUT_664: usize = 1; -fn aiur_fn_664(inp: [G; IN_664], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_664], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(0); let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_0, __v_1, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(665, &__args[..])?) { [G::ZERO; OUT_665] } else { let (__hash, __hit) = record.function_queries[665].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[665].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[665].bump_multiplicity(__i); } let __ret: [G; OUT_665] = unsafe { *(record.function_queries[665].output_at(__i).as_ptr() as *const [G; OUT_665]) }; __ret }, _ => { aiur_fn_665::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_664] = [__v_7]; record.function_queries[664].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_665: usize = 9; -const IN_665: usize = 9; -const OUT_665: usize = 1; -fn aiur_fn_665(inp: [G; IN_665], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_665], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_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]; match __v_9.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_665] = [__v_16]; record.function_queries[665].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; let __v_19: G = __loaded[3]; let __v_20: G = __loaded[4]; let __v_21: G = __loaded[5]; let __v_22: G = __loaded[6]; let __v_23: G = __loaded[7]; let __v_24: G = __loaded[8]; let __v_25: G = __loaded[9]; let __v_26: G = __loaded[10]; let __v_27: G = __loaded[11]; match __v_16.as_canonical_u64() { 5u64 => { let __v_28: G = G::from_u64(0); let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_0, __v_10, __v_11, __v_12, __v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_8, __v_23, __v_24, __v_21, __v_7, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(663, &__args[..])?) { [G::ZERO; OUT_663] } else { let (__hash, __hit) = record.function_queries[663].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[663].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[663].bump_multiplicity(__i); } let __ret: [G; OUT_663] = unsafe { *(record.function_queries[663].output_at(__i).as_ptr() as *const [G; OUT_663]) }; __ret }, _ => { aiur_fn_663::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __v_31: G = __v_7 + __v_30; let __v_32: G = G::from_u64(1); let __v_33: G = __v_8 + __v_32; let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_0, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_31, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(665, &__args[..])?) { [G::ZERO; OUT_665] } else { let (__hash, __hit) = record.function_queries[665].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[665].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[665].bump_multiplicity(__i); } let __ret: [G; OUT_665] = unsafe { *(record.function_queries[665].output_at(__i).as_ptr() as *const [G; OUT_665]) }; __ret }, _ => { aiur_fn_665::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_29, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __ret: [G; OUT_665] = [__v_35]; record.function_queries[665].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(1); let __v_29: G = __v_8 + __v_28; let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_0, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(665, &__args[..])?) { [G::ZERO; OUT_665] } else { let (__hash, __hit) = record.function_queries[665].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[665].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[665].bump_multiplicity(__i); } let __ret: [G; OUT_665] = unsafe { *(record.function_queries[665].output_at(__i).as_ptr() as *const [G; OUT_665]) }; __ret }, _ => { aiur_fn_665::(__args, __hash, record, io_buffer)? }, } } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_665] = [__v_30]; record.function_queries[665].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_666: usize = 5; -const IN_666: usize = 5; -const OUT_666: usize = 1; -fn aiur_fn_666(inp: [G; IN_666], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_666], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(0); let __v_6: G = G::from_u64(1); let __v_7: G = __v_1 - __v_6; let __v_8: G = __v_7 - __v_0; let __v_9: G = { let __values: [G; 4] = [__v_5, __v_8, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_666] = [__v_9]; record.function_queries[666].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_6.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_4, __v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_666] = [__v_9]; record.function_queries[666].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = __v_1 - __v_8; let __v_10: G = __v_9 - __v_0; let __v_11: G = { let __values: [G; 4] = [__v_7, __v_10, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(2).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_666] = [__v_11]; record.function_queries[666].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_667: usize = 2; -const IN_667: usize = 2; -const OUT_667: usize = 1; -fn aiur_fn_667(inp: [G; IN_667], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_667], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(2).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() { 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = __v_1 + __v_6; let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(667, &__args[..])?) { [G::ZERO; OUT_667] } else { let (__hash, __hit) = record.function_queries[667].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[667].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[667].bump_multiplicity(__i); } let __ret: [G; OUT_667] = unsafe { *(record.function_queries[667].output_at(__i).as_ptr() as *const [G; OUT_667]) }; __ret }, _ => { aiur_fn_667::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_667] = [__v_8]; record.function_queries[667].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_667] = [__v_1]; record.function_queries[667].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_668: usize = 8; -const IN_668: usize = 8; -const OUT_668: usize = 1; -fn aiur_fn_668(inp: [G; IN_668], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_668], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_668] = [__v_1]; record.function_queries[668].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_7, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(666, &__args[..])?) { [G::ZERO; OUT_666] } else { let (__hash, __hit) = record.function_queries[666].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[666].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[666].bump_multiplicity(__i); } let __ret: [G; OUT_666] = unsafe { *(record.function_queries[666].output_at(__i).as_ptr() as *const [G; OUT_666]) }; __ret }, _ => { aiur_fn_666::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_10, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); let __v_16: G = __v_2 - __v_15; let __v_17: G = __v_7 + __v_15; let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_0, __v_14, __v_16, __v_3, __v_4, __v_5, __v_6, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(668, &__args[..])?) { [G::ZERO; OUT_668] } else { let (__hash, __hit) = record.function_queries[668].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[668].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[668].bump_multiplicity(__i); } let __ret: [G; OUT_668] = unsafe { *(record.function_queries[668].output_at(__i).as_ptr() as *const [G; OUT_668]) }; __ret }, _ => { aiur_fn_668::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_668] = [__v_18]; record.function_queries[668].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_7, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(666, &__args[..])?) { [G::ZERO; OUT_666] } else { let (__hash, __hit) = record.function_queries[666].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[666].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[666].bump_multiplicity(__i); } let __ret: [G; OUT_666] = unsafe { *(record.function_queries[666].output_at(__i).as_ptr() as *const [G; OUT_666]) }; __ret }, _ => { aiur_fn_666::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(316, &__args[..])?) { [G::ZERO; OUT_316] } else { let (__hash, __hit) = record.function_queries[316].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[316].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => { aiur_fn_316::(__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_2 - __v_22; let __v_24: G = __v_7 + __v_22; let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_0, __v_21, __v_23, __v_3, __v_4, __v_5, __v_6, __v_24]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(668, &__args[..])?) { [G::ZERO; OUT_668] } else { let (__hash, __hit) = record.function_queries[668].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[668].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[668].bump_multiplicity(__i); } let __ret: [G; OUT_668] = unsafe { *(record.function_queries[668].output_at(__i).as_ptr() as *const [G; OUT_668]) }; __ret }, _ => { aiur_fn_668::(__args, __hash, record, io_buffer)? }, } } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_668] = [__v_25]; record.function_queries[668].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, } }, } }) } -const INPUT_SIZE_669: usize = 14; -const IN_669: usize = 14; -const OUT_669: usize = 1; -fn aiur_fn_669(inp: [G; IN_669], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_669], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(283, &__args[..])?) { [G::ZERO; OUT_283] } else { let (__hash, __hit) = record.function_queries[283].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[283].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => { aiur_fn_283::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __v_9 + __v_10; let __v_16: G = __v_15 + __v_11; let __v_17: G = __v_10 + __v_11; let __v_18: G = G::from_u64(0); let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_0, __v_14, __v_3, __v_16, __v_17, __v_4, __v_5, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(668, &__args[..])?) { [G::ZERO; OUT_668] } else { let (__hash, __hit) = record.function_queries[668].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[668].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[668].bump_multiplicity(__i); } let __ret: [G; OUT_668] = unsafe { *(record.function_queries[668].output_at(__i).as_ptr() as *const [G; OUT_668]) }; __ret }, _ => { aiur_fn_668::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_index_mut(1).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_680] = { let __args: [G; IN_680] = [__v_0, __v_19, __v_7, __v_21, __v_21, __v_21, __v_18, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(680, &__args[..])?) { [G::ZERO; OUT_680] } else { let (__hash, __hit) = record.function_queries[680].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[680].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[680].bump_multiplicity(__i); } let __ret: [G; OUT_680] = unsafe { *(record.function_queries[680].output_at(__i).as_ptr() as *const [G; OUT_680]) }; __ret }, _ => { aiur_fn_680::(__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_775] = { let __args: [G; IN_775] = [__v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_27: G = __r_arr[0]; let __v_28: G = __v_26 + __v_27; let __v_29: G = __v_16 + __v_28; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_25]; 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_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_31, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_32, __v_27, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(673, &__args[..])?) { [G::ZERO; OUT_673] } else { let (__hash, __hit) = record.function_queries[673].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[673].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[673].bump_multiplicity(__i); } let __ret: [G; OUT_673] = unsafe { *(record.function_queries[673].output_at(__i).as_ptr() as *const [G; OUT_673]) }; __ret }, _ => { aiur_fn_673::(__args, __hash, record, io_buffer)? }, } } }; let __v_33: G = __r_arr[0]; let __v_34: G = __v_29 - __v_20; let __v_35: G = __v_12 + __v_13; let __v_36: G = __v_34 - __v_35; let __v_37: G = { let __values: [G; 4] = [__v_18, __v_36, __v_18, __v_18]; let __mq = record.memory_queries.get_index_mut(2).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_201] = { let __args: [G; IN_201] = [__v_37, __v_33]; 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_38: G = __r_arr[0]; let __v_39: G = G::from_u64(2); let __v_40: G = { let __values: [G; 4] = [__v_39, __v_1, __v_6, __v_18]; let __mq = record.memory_queries.get_index_mut(2).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_675] = { let __args: [G; IN_675] = [__v_40, __v_3, __v_9, __v_29, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(675, &__args[..])?) { [G::ZERO; OUT_675] } else { let (__hash, __hit) = record.function_queries[675].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[675].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[675].bump_multiplicity(__i); } let __ret: [G; OUT_675] = unsafe { *(record.function_queries[675].output_at(__i).as_ptr() as *const [G; OUT_675]) }; __ret }, _ => { aiur_fn_675::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_41, __v_26, __v_28, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(674, &__args[..])?) { [G::ZERO; OUT_674] } else { let (__hash, __hit) = record.function_queries[674].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[674].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[674].bump_multiplicity(__i); } let __ret: [G; OUT_674] = unsafe { *(record.function_queries[674].output_at(__i).as_ptr() as *const [G; OUT_674]) }; __ret }, _ => { aiur_fn_674::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = G::from_u64(3); let __v_44: G = { let __values: [G; 4] = [__v_43, __v_38, __v_42, __v_18]; let __mq = record.memory_queries.get_index_mut(2).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_672] = { let __args: [G; IN_672] = [__v_0, __v_23, __v_24, __v_22, __v_8, __v_12, __v_26, __v_16, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(672, &__args[..])?) { [G::ZERO; OUT_672] } else { let (__hash, __hit) = record.function_queries[672].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[672].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[672].bump_multiplicity(__i); } let __ret: [G; OUT_672] = unsafe { *(record.function_queries[672].output_at(__i).as_ptr() as *const [G; OUT_672]) }; __ret }, _ => { aiur_fn_672::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_44, __v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(640, &__args[..])?) { [G::ZERO; OUT_640] } else { let (__hash, __hit) = record.function_queries[640].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[640].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[640].bump_multiplicity(__i); } let __ret: [G; OUT_640] = unsafe { *(record.function_queries[640].output_at(__i).as_ptr() as *const [G; OUT_640]) }; __ret }, _ => { aiur_fn_640::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_46, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(640, &__args[..])?) { [G::ZERO; OUT_640] } else { let (__hash, __hit) = record.function_queries[640].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[640].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[640].bump_multiplicity(__i); } let __ret: [G; OUT_640] = unsafe { *(record.function_queries[640].output_at(__i).as_ptr() as *const [G; OUT_640]) }; __ret }, _ => { aiur_fn_640::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __ret: [G; OUT_669] = [__v_47]; record.function_queries[669].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_670: usize = 1; -const IN_670: usize = 1; -const OUT_670: usize = 2; -fn aiur_fn_670(inp: [G; IN_670], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_670], ExecError> { stacker::maybe_grow(64 * 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(1); let __v_2: G = { let __values: [G; 3] = [__v_1, __v_1, __v_1]; let __mq = record.memory_queries.get_index_mut(1).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_671] = { let __args: [G; IN_671] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(671, &__args[..])?) { [G::ZERO; OUT_671] } else { let (__hash, __hit) = record.function_queries[671].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[671].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[671].bump_multiplicity(__i); } let __ret: [G; OUT_671] = unsafe { *(record.function_queries[671].output_at(__i).as_ptr() as *const [G; OUT_671]) }; __ret }, _ => { aiur_fn_671::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(764, &__args[..])?) { [G::ZERO; OUT_764] } else { let (__hash, __hit) = record.function_queries[764].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[764].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => { aiur_fn_764::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_670] = [__v_5, __v_4]; record.function_queries[670].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_671: usize = 2; -const IN_671: usize = 2; -const OUT_671: usize = 2; -fn aiur_fn_671(inp: [G; IN_671], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_671], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(2).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() { 5u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_index_mut(1).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_671] = { let __args: [G; IN_671] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(671, &__args[..])?) { [G::ZERO; OUT_671] } else { let (__hash, __hit) = record.function_queries[671].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[671].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[671].bump_multiplicity(__i); } let __ret: [G; OUT_671] = unsafe { *(record.function_queries[671].output_at(__i).as_ptr() as *const [G; OUT_671]) }; __ret }, _ => { aiur_fn_671::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_671] = [__v_8, __v_9]; record.function_queries[671].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_671] = [__v_1, __v_0]; record.function_queries[671].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_672: usize = 9; -const IN_672: usize = 9; -const OUT_672: usize = 1; -fn aiur_fn_672(inp: [G; IN_672], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_672], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_672] = [__v_13]; record.function_queries[672].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_2, __v_8, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(759, &__args[..])?) { [G::ZERO; OUT_759] } else { let (__hash, __hit) = record.function_queries[759].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[759].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[759].bump_multiplicity(__i); } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => { aiur_fn_759::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_13, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(759, &__args[..])?) { [G::ZERO; OUT_759] } else { let (__hash, __hit) = record.function_queries[759].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[759].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[759].bump_multiplicity(__i); } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => { aiur_fn_759::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = __v_7 + __v_6; let __v_16: G = __v_15 + __v_8; let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_3, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(768, &__args[..])?) { [G::ZERO; OUT_768] } else { let (__hash, __hit) = record.function_queries[768].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[768].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => { aiur_fn_768::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = __v_6 - __v_10; let __v_19: G = __v_18 + __v_8; let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_17, __v_19, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(670, &__args[..])?) { [G::ZERO; OUT_670] } else { let (__hash, __hit) = record.function_queries[670].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[670].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[670].bump_multiplicity(__i); } let __ret: [G; OUT_670] = unsafe { *(record.function_queries[670].output_at(__i).as_ptr() as *const [G; OUT_670]) }; __ret }, _ => { aiur_fn_670::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __v_24: G = __v_16 + __v_23; let __v_25: G = G::from_u64(1); let __v_26: G = __v_24 - __v_25; let __v_27: G = __v_5 + __v_13; let __v_28: G = __v_26 - __v_27; let __v_29: G = __v_7 + __v_10; let __v_30: G = __v_26 - __v_29; let __v_31: G = { let __values: [G; 3] = [__v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_index_mut(1).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_359] = { let __args: [G; IN_359] = [__v_0, __v_22, __v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __r_arr[0]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_32]; 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_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_34, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __values: [G; 4] = [__v_12, __v_28, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_201] = { let __args: [G; IN_201] = [__v_36, __v_35]; 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_37: G = __r_arr[0]; let __v_38: G = { let __values: [G; 4] = [__v_12, __v_30, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_639] = { let __args: [G; IN_639] = [__v_38, __v_23, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(639, &__args[..])?) { [G::ZERO; OUT_639] } else { let (__hash, __hit) = record.function_queries[639].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[639].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[639].bump_multiplicity(__i); } let __ret: [G; OUT_639] = unsafe { *(record.function_queries[639].output_at(__i).as_ptr() as *const [G; OUT_639]) }; __ret }, _ => { aiur_fn_639::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __v_40: G = G::from_u64(3); let __v_41: G = { let __values: [G; 4] = [__v_40, __v_37, __v_39, __v_12]; let __mq = record.memory_queries.get_index_mut(2).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_640] = { let __args: [G; IN_640] = [__v_41, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(640, &__args[..])?) { [G::ZERO; OUT_640] } else { let (__hash, __hit) = record.function_queries[640].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[640].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[640].bump_multiplicity(__i); } let __ret: [G; OUT_640] = unsafe { *(record.function_queries[640].output_at(__i).as_ptr() as *const [G; OUT_640]) }; __ret }, _ => { aiur_fn_640::(__args, __hash, record, io_buffer)? }, } } }; let __v_42: G = __r_arr[0]; let __v_43: G = __v_8 + __v_25; let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_0, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(672, &__args[..])?) { [G::ZERO; OUT_672] } else { let (__hash, __hit) = record.function_queries[672].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[672].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[672].bump_multiplicity(__i); } let __ret: [G; OUT_672] = unsafe { *(record.function_queries[672].output_at(__i).as_ptr() as *const [G; OUT_672]) }; __ret }, _ => { aiur_fn_672::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __v_45: G = { let __values: [G; 3] = [__v_12, __v_42, __v_44]; let __mq = record.memory_queries.get_index_mut(1).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_672] = [__v_45]; record.function_queries[672].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_673: usize = 3; -const IN_673: usize = 3; -const OUT_673: usize = 1; -fn aiur_fn_673(inp: [G; IN_673], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_673], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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(1).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_673] = [__v_7]; record.function_queries[673].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(673, &__args[..])?) { [G::ZERO; OUT_673] } else { let (__hash, __hit) = record.function_queries[673].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[673].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[673].bump_multiplicity(__i); } let __ret: [G; OUT_673] = unsafe { *(record.function_queries[673].output_at(__i).as_ptr() as *const [G; OUT_673]) }; __ret }, _ => { aiur_fn_673::(__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(1).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_673] = [__v_9]; record.function_queries[673].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_674: usize = 4; -const IN_674: usize = 4; -const OUT_674: usize = 1; -fn aiur_fn_674(inp: [G; IN_674], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_674], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_1 - __v_3; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_674] = [__v_0]; record.function_queries[674].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = __v_2 - __v_6; let __v_8: G = __v_7 - __v_3; let __v_9: G = { let __values: [G; 4] = [__v_5, __v_8, __v_5, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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_10: G = G::from_u64(3); let __v_11: G = { let __values: [G; 4] = [__v_10, __v_0, __v_9, __v_5]; let __mq = record.memory_queries.get_index_mut(2).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 = __v_3 + __v_6; let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_11, __v_1, __v_2, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(674, &__args[..])?) { [G::ZERO; OUT_674] } else { let (__hash, __hit) = record.function_queries[674].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[674].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[674].bump_multiplicity(__i); } let __ret: [G; OUT_674] = unsafe { *(record.function_queries[674].output_at(__i).as_ptr() as *const [G; OUT_674]) }; __ret }, _ => { aiur_fn_674::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_674] = [__v_13]; record.function_queries[674].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_675: usize = 6; -const IN_675: usize = 6; -const OUT_675: usize = 1; -fn aiur_fn_675(inp: [G; IN_675], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_675], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_4.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = __v_3 - __v_6; let __v_8: G = G::from_u64(0); let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(647, &__args[..])?) { [G::ZERO; OUT_647] } else { let (__hash, __hit) = record.function_queries[647].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[647].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => { aiur_fn_647::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_675] = [__v_9]; record.function_queries[675].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_6: G = __v_3 - __v_2; let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(637, &__args[..])?) { [G::ZERO; OUT_637] } else { let (__hash, __hit) = record.function_queries[637].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[637].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[637].bump_multiplicity(__i); } let __ret: [G; OUT_637] = unsafe { *(record.function_queries[637].output_at(__i).as_ptr() as *const [G; OUT_637]) }; __ret }, _ => { aiur_fn_637::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_675] = [__v_7]; record.function_queries[675].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_676: usize = 4; -const IN_676: usize = 4; -const OUT_676: usize = 2; -fn aiur_fn_676(inp: [G; IN_676], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_676], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_677] = { let __args: [G; IN_677] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(677, &__args[..])?) { [G::ZERO; OUT_677] } else { let (__hash, __hit) = record.function_queries[677].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[677].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[677].bump_multiplicity(__i); } let __ret: [G; OUT_677] = unsafe { *(record.function_queries[677].output_at(__i).as_ptr() as *const [G; OUT_677]) }; __ret }, _ => { aiur_fn_677::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __ret: [G; OUT_676] = [__v_4, __v_5]; record.function_queries[676].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_677: usize = 4; -const IN_677: usize = 4; -const OUT_677: usize = 2; -fn aiur_fn_677(inp: [G; IN_677], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_677], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_0, __v_9, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(677, &__args[..])?) { [G::ZERO; OUT_677] } else { let (__hash, __hit) = record.function_queries[677].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[677].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[677].bump_multiplicity(__i); } let __ret: [G; OUT_677] = unsafe { *(record.function_queries[677].output_at(__i).as_ptr() as *const [G; OUT_677]) }; __ret }, _ => { aiur_fn_677::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_677] = [__v_11, __v_12]; record.function_queries[677].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_6]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __idx = usize::try_from(__ptr_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() { 2u64 => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_2, __v_14, __v_12, __v_3, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(678, &__args[..])?) { [G::ZERO; OUT_678] } else { let (__hash, __hit) = record.function_queries[678].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[678].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[678].bump_multiplicity(__i); } let __ret: [G; OUT_678] = unsafe { *(record.function_queries[678].output_at(__i).as_ptr() as *const [G; OUT_678]) }; __ret }, _ => { aiur_fn_678::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __ret: [G; OUT_677] = [__v_18, __v_19]; record.function_queries[677].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_677] = [__v_17, __v_17]; record.function_queries[677].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_678: usize = 5; -const IN_678: usize = 5; -const OUT_678: usize = 2; -fn aiur_fn_678(inp: [G; IN_678], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_678], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_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() { 1u64 => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_678] = [__v_11, __v_11]; record.function_queries[678].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_1]; 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_11: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(1); break '__mc_0 [__v_12]; }, _ => { let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(679, &__args[..])?) { [G::ZERO; OUT_679] } else { let (__hash, __hit) = record.function_queries[679].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[679].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[679].bump_multiplicity(__i); } let __ret: [G; OUT_679] = unsafe { *(record.function_queries[679].output_at(__i).as_ptr() as *const [G; OUT_679]) }; __ret }, _ => { aiur_fn_679::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; break '__mc_0 [__v_12]; }, } }; let __v_12: G = __mc_out___mc_0[0]; let __v_13: G = __v_11 * __v_12; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); let __ret: [G; OUT_678] = [__v_14, __v_4]; record.function_queries[678].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = __v_4 + __v_14; let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(678, &__args[..])?) { [G::ZERO; OUT_678] } else { let (__hash, __hit) = record.function_queries[678].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[678].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[678].bump_multiplicity(__i); } let __ret: [G; OUT_678] = unsafe { *(record.function_queries[678].output_at(__i).as_ptr() as *const [G; OUT_678]) }; __ret }, _ => { aiur_fn_678::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_678] = [__v_16, __v_17]; record.function_queries[678].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_679: usize = 3; -const IN_679: usize = 3; -const OUT_679: usize = 1; -fn aiur_fn_679(inp: [G; IN_679], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_679], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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 __ret: [G; OUT_679] = [__v_6]; record.function_queries[679].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(1).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() { 1u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_679] = [__v_9]; record.function_queries[679].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_10, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(621, &__args[..])?) { [G::ZERO; OUT_621] } else { let (__hash, __hit) = record.function_queries[621].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[621].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => { aiur_fn_621::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(679, &__args[..])?) { [G::ZERO; OUT_679] } else { let (__hash, __hit) = record.function_queries[679].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[679].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[679].bump_multiplicity(__i); } let __ret: [G; OUT_679] = unsafe { *(record.function_queries[679].output_at(__i).as_ptr() as *const [G; OUT_679]) }; __ret }, _ => { aiur_fn_679::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_679] = [__v_12]; record.function_queries[679].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_679] = [__v_12]; record.function_queries[679].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_680: usize = 8; -const IN_680: usize = 8; -const OUT_680: usize = 4; -fn aiur_fn_680(inp: [G; IN_680], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_680], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 5u64 => { let __v_12: G = __v_7 + __v_6; let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_0, __v_9, __v_2, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(676, &__args[..])?) { [G::ZERO; OUT_676] } else { let (__hash, __hit) = record.function_queries[676].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[676].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[676].bump_multiplicity(__i); } let __ret: [G; OUT_676] = unsafe { *(record.function_queries[676].output_at(__i).as_ptr() as *const [G; OUT_676]) }; __ret }, _ => { aiur_fn_676::(__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; 3] = [__v_15, __v_9, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_13.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 3] = [__v_17, __v_6, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_17, __v_14, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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 = G::from_u64(1); let __v_21: G = __v_6 + __v_20; let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_0, __v_10, __v_2, __v_16, __v_18, __v_19, __v_21, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(680, &__args[..])?) { [G::ZERO; OUT_680] } else { let (__hash, __hit) = record.function_queries[680].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[680].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[680].bump_multiplicity(__i); } let __ret: [G; OUT_680] = unsafe { *(record.function_queries[680].output_at(__i).as_ptr() as *const [G; OUT_680]) }; __ret }, _ => { aiur_fn_680::(__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 __ret: [G; OUT_680] = [__v_22, __v_23, __v_24, __v_25]; record.function_queries[680].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(1); let __v_18: G = __v_6 + __v_17; let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_0, __v_10, __v_2, __v_16, __v_4, __v_5, __v_18, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(680, &__args[..])?) { [G::ZERO; OUT_680] } else { let (__hash, __hit) = record.function_queries[680].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[680].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[680].bump_multiplicity(__i); } let __ret: [G; OUT_680] = unsafe { *(record.function_queries[680].output_at(__i).as_ptr() as *const [G; OUT_680]) }; __ret }, _ => { aiur_fn_680::(__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 __ret: [G; OUT_680] = [__v_19, __v_20, __v_21, __v_22]; record.function_queries[680].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(764, &__args[..])?) { [G::ZERO; OUT_764] } else { let (__hash, __hit) = record.function_queries[764].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[764].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => { aiur_fn_764::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(764, &__args[..])?) { [G::ZERO; OUT_764] } else { let (__hash, __hit) = record.function_queries[764].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[764].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => { aiur_fn_764::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(764, &__args[..])?) { [G::ZERO; OUT_764] } else { let (__hash, __hit) = record.function_queries[764].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[764].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => { aiur_fn_764::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_680] = [__v_12, __v_13, __v_14, __v_1]; record.function_queries[680].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_681: usize = 5; -const IN_681: usize = 5; -const OUT_681: usize = 1; -fn aiur_fn_681(inp: [G; IN_681], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_681], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_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() { 1u64 => { 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(1).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_681] = [__v_12]; record.function_queries[681].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; let __v_16: G = __loaded[4]; let __v_17: G = __loaded[5]; let __v_18: G = __loaded[6]; let __v_19: G = __loaded[7]; let __v_20: G = __loaded[8]; let __v_21: G = __loaded[9]; let __v_22: G = __loaded[10]; let __v_23: G = __loaded[11]; match __v_12.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0, __v_6, __v_14, __v_15, __v_16, __v_9, __v_2, __v_3, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(645, &__args[..])?) { [G::ZERO; OUT_645] } else { let (__hash, __hit) = record.function_queries[645].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[645].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[645].bump_multiplicity(__i); } let __ret: [G; OUT_645] = unsafe { *(record.function_queries[645].output_at(__i).as_ptr() as *const [G; OUT_645]) }; __ret }, _ => { aiur_fn_645::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_24, __v_4, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(306, &__args[..])?) { [G::ZERO; OUT_306] } else { let (__hash, __hit) = record.function_queries[306].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[306].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => { aiur_fn_306::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); let __v_28: G = __v_4 + __v_27; let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_0, __v_10, __v_2, __v_3, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(681, &__args[..])?) { [G::ZERO; OUT_681] } else { let (__hash, __hit) = record.function_queries[681].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[681].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[681].bump_multiplicity(__i); } let __ret: [G; OUT_681] = unsafe { *(record.function_queries[681].output_at(__i).as_ptr() as *const [G; OUT_681]) }; __ret }, _ => { aiur_fn_681::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = { let __values: [G; 3] = [__v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_index_mut(1).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_681] = [__v_30]; record.function_queries[681].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_0, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(681, &__args[..])?) { [G::ZERO; OUT_681] } else { let (__hash, __hit) = record.function_queries[681].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[681].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[681].bump_multiplicity(__i); } let __ret: [G; OUT_681] = unsafe { *(record.function_queries[681].output_at(__i).as_ptr() as *const [G; OUT_681]) }; __ret }, _ => { aiur_fn_681::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_681] = [__v_24]; record.function_queries[681].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_682: usize = 14; -const IN_682: usize = 14; -const OUT_682: usize = 0; -fn aiur_fn_682(inp: [G; IN_682], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_682], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_1.as_canonical_u64() { 7u64 => { let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_3, __v_4, __v_6, __v_7, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(613, &__args[..])?) { [G::ZERO; OUT_613] } else { let (__hash, __hit) = record.function_queries[613].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[613].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[613].bump_multiplicity(__i); } let __ret: [G; OUT_613] = unsafe { *(record.function_queries[613].output_at(__i).as_ptr() as *const [G; OUT_613]) }; __ret }, _ => { aiur_fn_613::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; let __v_19: G = __loaded[3]; let __v_20: G = __loaded[4]; let __v_21: G = __loaded[5]; let __v_22: G = __loaded[6]; let __v_23: G = __loaded[7]; let __v_24: G = __loaded[8]; let __v_25: G = __loaded[9]; let __v_26: G = __loaded[10]; let __v_27: G = __loaded[11]; match __v_16.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(611, &__args[..])?) { [G::ZERO; OUT_611] } else { let (__hash, __hit) = record.function_queries[611].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[611].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => { aiur_fn_611::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(611, &__args[..])?) { [G::ZERO; OUT_611] } else { let (__hash, __hit) = record.function_queries[611].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[611].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => { aiur_fn_611::(__args, __hash, record, io_buffer)? }, } } }; let __v_29: G = __r_arr[0]; let __v_30: G = __v_28 * __v_29; let __v_31: G = G::from_u64(1); let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_11, __v_23]; 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_32: G = __r_arr[0]; let __v_33: G = __v_31 - __v_32; let __v_34: G = __v_30 * __v_33; let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(778, &__args[..])?) { [G::ZERO; OUT_778] } else { let (__hash, __hit) = record.function_queries[778].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[778].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[778].bump_multiplicity(__i); } let __ret: [G; OUT_778] = unsafe { *(record.function_queries[778].output_at(__i).as_ptr() as *const [G; OUT_778]) }; __ret }, _ => { aiur_fn_778::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; if (__v_35 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("recursor rule count differs from the inductive's ctor count".to_string()) }); } let __v_36: G = __v_4 + __v_6; let __v_37: G = __v_36 + __v_7; let __v_38: G = __v_37 + __v_5; let __v_39: G = __v_38 + __v_31; let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_3, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(576, &__args[..])?) { [G::ZERO; OUT_576] } else { let (__hash, __hit) = record.function_queries[576].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[576].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => { aiur_fn_576::(__args, __hash, record, io_buffer)? }, } } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_8, __v_37, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(685, &__args[..])?) { [G::ZERO; OUT_685] } else { let (__hash, __hit) = record.function_queries[685].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[685].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[685].bump_multiplicity(__i); } let __ret: [G; OUT_685] = unsafe { *(record.function_queries[685].output_at(__i).as_ptr() as *const [G; OUT_685]) }; __ret }, _ => { aiur_fn_685::(__args, __hash, record, io_buffer)? }, } } }; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_34.as_canonical_u64() { 1u64 => { break '__mc_0 []; }, _ => { if (__v_4 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("recursor parameter count differs from its inductive's".to_string()) }); } if (__v_5 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("recursor index count differs from its inductive's".to_string()) }); } let __v_41: G = __v_19 + __v_20; let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_3, __v_4, __v_6, __v_7, __v_5, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(683, &__args[..])?) { [G::ZERO; OUT_683] } else { let (__hash, __hit) = record.function_queries[683].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[683].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[683].bump_multiplicity(__i); } let __ret: [G; OUT_683] = unsafe { *(record.function_queries[683].output_at(__i).as_ptr() as *const [G; OUT_683]) }; __ret }, _ => { aiur_fn_683::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, } }; let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_0, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(609, &__args[..])?) { [G::ZERO; OUT_609] } else { let (__hash, __hit) = record.function_queries[609].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[609].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[609].bump_multiplicity(__i); } let __ret: [G; OUT_609] = unsafe { *(record.function_queries[609].output_at(__i).as_ptr() as *const [G; OUT_609]) }; __ret }, _ => { aiur_fn_609::(__args, __hash, record, io_buffer)? }, } } }; let __v_41: G = __r_arr[0]; if (__v_9 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: Some("recursor k_flag disagrees with its inductive's K eligibility".to_string()) }); } let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_0, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(601, &__args[..])?) { [G::ZERO; OUT_601] } else { let (__hash, __hit) = record.function_queries[601].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[601].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[601].bump_multiplicity(__i); } let __ret: [G; OUT_601] = unsafe { *(record.function_queries[601].output_at(__i).as_ptr() as *const [G; OUT_601]) }; __ret }, _ => { aiur_fn_601::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(651, &__args[..])?) { [G::ZERO; OUT_651] } else { let (__hash, __hit) = record.function_queries[651].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[651].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[651].bump_multiplicity(__i); } let __ret: [G; OUT_651] = unsafe { *(record.function_queries[651].output_at(__i).as_ptr() as *const [G; OUT_651]) }; __ret }, _ => { aiur_fn_651::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_682] = []; record.function_queries[682].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_683: usize = 6; -const IN_683: usize = 6; -const OUT_683: usize = 0; -fn aiur_fn_683(inp: [G; IN_683], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_683], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_1 + __v_2; let __v_7: G = __v_6 + __v_3; let __v_8: G = __v_7 + __v_4; let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_0, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(576, &__args[..])?) { [G::ZERO; OUT_576] } else { let (__hash, __hit) = record.function_queries[576].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[576].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => { aiur_fn_576::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 5u64 => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_11]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; if (__v_16 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("recursor major premise has the wrong number of spine args".to_string()) }); } let __ret: [G; OUT_683] = []; record.function_queries[683].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }) } -const INPUT_SIZE_684: usize = 2; -const IN_684: usize = 2; -const OUT_684: usize = 1; -fn aiur_fn_684(inp: [G; IN_684], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_684], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_1; 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(1).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_684] = [__v_4]; record.function_queries[684].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(4); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_1, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_6: G = G::from_u64(1); let __v_7: G = __v_1 + __v_6; let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_0, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(684, &__args[..])?) { [G::ZERO; OUT_684] } else { let (__hash, __hit) = record.function_queries[684].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[684].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[684].bump_multiplicity(__i); } let __ret: [G; OUT_684] = unsafe { *(record.function_queries[684].output_at(__i).as_ptr() as *const [G; OUT_684]) }; __ret }, _ => { aiur_fn_684::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_3, __v_5, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_684] = [__v_9]; record.function_queries[684].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_685: usize = 3; -const IN_685: usize = 3; -const OUT_685: usize = 0; -fn aiur_fn_685(inp: [G; IN_685], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_685], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 5] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(3).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; match __v_3.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_685] = []; record.function_queries[685].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_4.as_canonical_u64() { _ => { let __v_8: G = __v_1 + __v_5; let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(685, &__args[..])?) { [G::ZERO; OUT_685] } else { let (__hash, __hit) = record.function_queries[685].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[685].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[685].bump_multiplicity(__i); } let __ret: [G; OUT_685] = unsafe { *(record.function_queries[685].output_at(__i).as_ptr() as *const [G; OUT_685]) }; __ret }, _ => { aiur_fn_685::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_685] = []; record.function_queries[685].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_686: usize = 4; -const IN_686: usize = 4; -const OUT_686: usize = 3; -fn aiur_fn_686(inp: [G; IN_686], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_686], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_686] = [__v_0, __v_2, __v_3]; record.function_queries[686].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 4u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = __v_1 - __v_8; let __v_10: G = __v_2 + __v_8; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_11, __v_5, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_686] = { let __args: [G; IN_686] = [__v_6, __v_9, __v_10, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(686, &__args[..])?) { [G::ZERO; OUT_686] } else { let (__hash, __hit) = record.function_queries[686].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[686].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[686].bump_multiplicity(__i); } let __ret: [G; OUT_686] = unsafe { *(record.function_queries[686].output_at(__i).as_ptr() as *const [G; OUT_686]) }; __ret }, _ => { aiur_fn_686::(__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 __ret: [G; OUT_686] = [__v_13, __v_14, __v_15]; record.function_queries[686].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_686] = [__v_0, __v_2, __v_3]; record.function_queries[686].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_687: usize = 2; -const IN_687: usize = 2; -const OUT_687: usize = 1; -fn aiur_fn_687(inp: [G; IN_687], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_687], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 47] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(15).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __v_34: G = __loaded[32]; let __v_35: G = __loaded[33]; let __v_36: G = __loaded[34]; let __v_37: G = __loaded[35]; let __v_38: G = __loaded[36]; let __v_39: G = __loaded[37]; let __v_40: G = __loaded[38]; let __v_41: G = __loaded[39]; let __v_42: G = __loaded[40]; let __v_43: G = __loaded[41]; let __v_44: G = __loaded[42]; let __v_45: G = __loaded[43]; let __v_46: G = __loaded[44]; let __v_47: G = __loaded[45]; let __v_48: G = __loaded[46]; match __v_2.as_canonical_u64() { 1u64 => { let __v_49: G = G::from_u64(0); let __ret: [G; OUT_687] = [__v_49]; record.function_queries[687].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_1]; }, 1u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = __v_49 - __v_1; break '__mc_0 [__v_50]; }, 2u64 => { let __v_49: G = G::from_u64(0); break '__mc_0 [__v_49]; }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }; let __v_49: G = __mc_out___mc_0[0]; match __v_49.as_canonical_u64() { 1u64 => { let __v_50: G = G::from_u64(1); let __ret: [G; OUT_687] = [__v_50]; record.function_queries[687].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_48, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(687, &__args[..])?) { [G::ZERO; OUT_687] } else { let (__hash, __hit) = record.function_queries[687].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[687].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[687].bump_multiplicity(__i); } let __ret: [G; OUT_687] = unsafe { *(record.function_queries[687].output_at(__i).as_ptr() as *const [G; OUT_687]) }; __ret }, _ => { aiur_fn_687::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_687] = [__v_50]; record.function_queries[687].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_688: usize = 1; -const IN_688: usize = 1; -const OUT_688: usize = 0; -fn aiur_fn_688(inp: [G; IN_688], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_688], ExecError> { stacker::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_228] = { let __args: [G; IN_228] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = __r_arr[4]; let __v_6: G = __r_arr[5]; let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; let __v_11: G = __r_arr[10]; let __v_12: G = __r_arr[11]; let __v_13: G = __r_arr[12]; let __v_14: G = __r_arr[13]; let __v_15: G = __r_arr[14]; let __v_16: G = __r_arr[15]; let __v_17: G = __r_arr[16]; let __v_18: G = __r_arr[17]; let __v_19: G = __r_arr[18]; let __v_20: G = __r_arr[19]; let __v_21: G = __r_arr[20]; let __v_22: G = __r_arr[21]; let __v_23: G = __r_arr[22]; let __v_24: G = __r_arr[23]; let __v_25: G = __r_arr[24]; let __v_26: G = __r_arr[25]; let __v_27: G = __r_arr[26]; let __v_28: G = __r_arr[27]; let __v_29: G = __r_arr[28]; let __v_30: G = __r_arr[29]; let __v_31: G = __r_arr[30]; let __v_32: G = __r_arr[31]; let __v_33: G = __r_arr[32]; let __v_34: G = __r_arr[33]; let __v_35: G = __r_arr[34]; let __v_36: G = __r_arr[35]; let __v_37: G = __r_arr[36]; let __v_38: G = __r_arr[37]; let __v_39: G = __r_arr[38]; let __v_40: G = __r_arr[39]; let __v_41: G = __r_arr[40]; let __v_42: G = __r_arr[41]; let __v_43: G = __r_arr[42]; let __v_44: G = __r_arr[43]; let __v_45: G = __r_arr[44]; let __v_46: G = __r_arr[45]; let __v_47: G = __r_arr[46]; let __v_48: G = __r_arr[47]; match __v_1.as_canonical_u64() { _ => { match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(1); let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_2, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(687, &__args[..])?) { [G::ZERO; OUT_687] } else { let (__hash, __hit) = record.function_queries[687].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[687].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[687].bump_multiplicity(__i); } let __ret: [G; OUT_687] = unsafe { *(record.function_queries[687].output_at(__i).as_ptr() as *const [G; OUT_687]) }; __ret }, _ => { aiur_fn_687::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_2, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(687, &__args[..])?) { [G::ZERO; OUT_687] } else { let (__hash, __hit) = record.function_queries[687].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[687].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[687].bump_multiplicity(__i); } let __ret: [G; OUT_687] = unsafe { *(record.function_queries[687].output_at(__i).as_ptr() as *const [G; OUT_687]) }; __ret }, _ => { aiur_fn_687::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __v_53: G = __v_50 * __v_52; if (__v_53 != __v_51) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: Some("mutual block mixes a definition member with inductives".to_string()) }); } let __ret: [G; OUT_688] = []; record.function_queries[688].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_688] = []; record.function_queries[688].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_689: usize = 14; -const IN_689: usize = 14; -const OUT_689: usize = 0; -fn aiur_fn_689(inp: [G; IN_689], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_689], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(569, &__args[..])?) { [G::ZERO; OUT_569] } else { let (__hash, __hit) = record.function_queries[569].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[569].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[569].bump_multiplicity(__i); } let __ret: [G; OUT_569] = unsafe { *(record.function_queries[569].output_at(__i).as_ptr() as *const [G; OUT_569]) }; __ret }, _ => { aiur_fn_569::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; match __v_1.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_3, __v_15, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_451] = { let __args: [G; IN_451] = [__v_0, __v_3, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_14, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(571, &__args[..])?) { [G::ZERO; OUT_571] } else { let (__hash, __hit) = record.function_queries[571].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[571].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[571].bump_multiplicity(__i); } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => { aiur_fn_571::(__args, __hash, record, io_buffer)? }, } } }; match __v_14.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_689] = []; record.function_queries[689].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_0, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(506, &__args[..])?) { [G::ZERO; OUT_506] } else { let (__hash, __hit) = record.function_queries[506].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[506].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[506].bump_multiplicity(__i); } let __ret: [G; OUT_506] = unsafe { *(record.function_queries[506].output_at(__i).as_ptr() as *const [G; OUT_506]) }; __ret }, _ => { aiur_fn_506::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; match __v_19.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(1); if (__v_20 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("an axiom that is not one of Lean's standard axioms".to_string()) }); } let __ret: [G; OUT_689] = []; record.function_queries[689].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_689] = []; record.function_queries[689].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, 1u64 => { let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_3, __v_15, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_4, __v_15, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_451] = { let __args: [G; IN_451] = [__v_0, __v_3, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_14, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(571, &__args[..])?) { [G::ZERO; OUT_571] } else { let (__hash, __hit) = record.function_queries[571].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[571].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[571].bump_multiplicity(__i); } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => { aiur_fn_571::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_14, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(571, &__args[..])?) { [G::ZERO; OUT_571] } else { let (__hash, __hit) = record.function_queries[571].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[571].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[571].bump_multiplicity(__i); } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => { aiur_fn_571::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0, __v_4, __v_3, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(452, &__args[..])?) { [G::ZERO; OUT_452] } else { let (__hash, __hit) = record.function_queries[452].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[452].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[452].bump_multiplicity(__i); } let __ret: [G; OUT_452] = unsafe { *(record.function_queries[452].output_at(__i).as_ptr() as *const [G; OUT_452]) }; __ret }, _ => { aiur_fn_452::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_689] = []; record.function_queries[689].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_3, __v_15, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_4, __v_15, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_451] = { let __args: [G; IN_451] = [__v_0, __v_3, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 3] = [__v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_index_mut(1).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_271] = { let __args: [G; IN_271] = [__v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(271, &__args[..])?) { [G::ZERO; OUT_271] } else { let (__hash, __hit) = record.function_queries[271].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[271].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[271].bump_multiplicity(__i); } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => { aiur_fn_271::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; if (__v_20 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("theorem's type is not a Prop".to_string()) }); } let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_14, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(571, &__args[..])?) { [G::ZERO; OUT_571] } else { let (__hash, __hit) = record.function_queries[571].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[571].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[571].bump_multiplicity(__i); } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => { aiur_fn_571::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_14, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(571, &__args[..])?) { [G::ZERO; OUT_571] } else { let (__hash, __hit) = record.function_queries[571].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[571].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[571].bump_multiplicity(__i); } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => { aiur_fn_571::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0, __v_4, __v_3, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(452, &__args[..])?) { [G::ZERO; OUT_452] } else { let (__hash, __hit) = record.function_queries[452].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[452].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[452].bump_multiplicity(__i); } let __ret: [G; OUT_452] = unsafe { *(record.function_queries[452].output_at(__i).as_ptr() as *const [G; OUT_452]) }; __ret }, _ => { aiur_fn_452::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_689] = []; record.function_queries[689].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_3, __v_15, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_4, __v_15, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_451] = { let __args: [G; IN_451] = [__v_0, __v_3, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_14, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(571, &__args[..])?) { [G::ZERO; OUT_571] } else { let (__hash, __hit) = record.function_queries[571].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[571].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[571].bump_multiplicity(__i); } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => { aiur_fn_571::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_14, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(571, &__args[..])?) { [G::ZERO; OUT_571] } else { let (__hash, __hit) = record.function_queries[571].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[571].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[571].bump_multiplicity(__i); } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => { aiur_fn_571::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0, __v_4, __v_3, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(452, &__args[..])?) { [G::ZERO; OUT_452] } else { let (__hash, __hit) = record.function_queries[452].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[452].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[452].bump_multiplicity(__i); } let __ret: [G; OUT_452] = unsafe { *(record.function_queries[452].output_at(__i).as_ptr() as *const [G; OUT_452]) }; __ret }, _ => { aiur_fn_452::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_689] = []; record.function_queries[689].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_3, __v_15, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_451] = { let __args: [G; IN_451] = [__v_0, __v_3, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_14, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(571, &__args[..])?) { [G::ZERO; OUT_571] } else { let (__hash, __hit) = record.function_queries[571].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[571].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[571].bump_multiplicity(__i); } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => { aiur_fn_571::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_0, __v_13, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(575, &__args[..])?) { [G::ZERO; OUT_575] } else { let (__hash, __hit) = record.function_queries[575].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[575].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[575].bump_multiplicity(__i); } let __ret: [G; OUT_575] = unsafe { *(record.function_queries[575].output_at(__i).as_ptr() as *const [G; OUT_575]) }; __ret }, _ => { aiur_fn_575::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_689] = []; record.function_queries[689].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_3, __v_15, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_451] = { let __args: [G; IN_451] = [__v_0, __v_3, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_14, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(571, &__args[..])?) { [G::ZERO; OUT_571] } else { let (__hash, __hit) = record.function_queries[571].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[571].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[571].bump_multiplicity(__i); } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => { aiur_fn_571::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(688, &__args[..])?) { [G::ZERO; OUT_688] } else { let (__hash, __hit) = record.function_queries[688].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[688].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[688].bump_multiplicity(__i); } let __ret: [G; OUT_688] = unsafe { *(record.function_queries[688].output_at(__i).as_ptr() as *const [G; OUT_688]) }; __ret }, _ => { aiur_fn_688::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_2, __v_8, __v_9, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(599, &__args[..])?) { [G::ZERO; OUT_599] } else { let (__hash, __hit) = record.function_queries[599].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[599].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[599].bump_multiplicity(__i); } let __ret: [G; OUT_599] = unsafe { *(record.function_queries[599].output_at(__i).as_ptr() as *const [G; OUT_599]) }; __ret }, _ => { aiur_fn_599::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(602, &__args[..])?) { [G::ZERO; OUT_602] } else { let (__hash, __hit) = record.function_queries[602].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[602].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[602].bump_multiplicity(__i); } let __ret: [G; OUT_602] = unsafe { *(record.function_queries[602].output_at(__i).as_ptr() as *const [G; OUT_602]) }; __ret }, _ => { aiur_fn_602::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_689] = []; record.function_queries[689].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_3, __v_15, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_451] = { let __args: [G; IN_451] = [__v_0, __v_3, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_14, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(571, &__args[..])?) { [G::ZERO; OUT_571] } else { let (__hash, __hit) = record.function_queries[571].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[571].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[571].bump_multiplicity(__i); } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => { aiur_fn_571::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(236, &__args[..])?) { [G::ZERO; OUT_236] } else { let (__hash, __hit) = record.function_queries[236].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[236].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[236].bump_multiplicity(__i); } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => { aiur_fn_236::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; let __v_23: G = __loaded[3]; let __v_24: G = __loaded[4]; let __v_25: G = __loaded[5]; let __v_26: G = __loaded[6]; let __v_27: G = __loaded[7]; let __v_28: G = __loaded[8]; let __v_29: G = __loaded[9]; let __v_30: G = __loaded[10]; let __v_31: G = __loaded[11]; match __v_20.as_canonical_u64() { 5u64 => { if (__v_7 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("ctor parameter count differs from its inductive's".to_string()) }); } let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_22, __v_3, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(582, &__args[..])?) { [G::ZERO; OUT_582] } else { let (__hash, __hit) = record.function_queries[582].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[582].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[582].bump_multiplicity(__i); } let __ret: [G; OUT_582] = unsafe { *(record.function_queries[582].output_at(__i).as_ptr() as *const [G; OUT_582]) }; __ret }, _ => { aiur_fn_582::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_3, __v_7, __v_24, __v_8, __v_21, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(580, &__args[..])?) { [G::ZERO; OUT_580] } else { let (__hash, __hit) = record.function_queries[580].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[580].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => { aiur_fn_580::(__args, __hash, record, io_buffer)? }, } } }; let __v_32: G = __v_23 + __v_24; let __v_33: G = G::from_u64(1); let __v_34: G = { let __values: [G; 3] = [__v_33, __v_33, __v_33]; let __mq = record.memory_queries.get_index_mut(1).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_583] = { let __args: [G; IN_583] = [__v_0, __v_22, __v_32, __v_34]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(583, &__args[..])?) { [G::ZERO; OUT_583] } else { let (__hash, __hit) = record.function_queries[583].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[583].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[583].bump_multiplicity(__i); } let __ret: [G; OUT_583] = unsafe { *(record.function_queries[583].output_at(__i).as_ptr() as *const [G; OUT_583]) }; __ret }, _ => { aiur_fn_583::(__args, __hash, record, io_buffer)? }, } } }; let __v_35: G = __r_arr[0]; let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_3, __v_7, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(586, &__args[..])?) { [G::ZERO; OUT_586] } else { let (__hash, __hit) = record.function_queries[586].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[586].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[586].bump_multiplicity(__i); } let __ret: [G; OUT_586] = unsafe { *(record.function_queries[586].output_at(__i).as_ptr() as *const [G; OUT_586]) }; __ret }, _ => { aiur_fn_586::(__args, __hash, record, io_buffer)? }, } } }; match __v_26.as_canonical_u64() { 0u64 => { 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(1).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_598] = { let __args: [G; IN_598] = [__v_0, __v_3, __v_7, __v_4, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(598, &__args[..])?) { [G::ZERO; OUT_598] } else { let (__hash, __hit) = record.function_queries[598].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[598].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[598].bump_multiplicity(__i); } let __ret: [G; OUT_598] = unsafe { *(record.function_queries[598].output_at(__i).as_ptr() as *const [G; OUT_598]) }; __ret }, _ => { aiur_fn_598::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_689] = []; record.function_queries[689].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_689] = []; record.function_queries[689].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }, 7u64 => { let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_3, __v_15, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(574, &__args[..])?) { [G::ZERO; OUT_574] } else { let (__hash, __hit) = record.function_queries[574].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[574].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => { aiur_fn_574::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_index_mut(1).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_451] = { let __args: [G; IN_451] = [__v_0, __v_3, __v_17]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(451, &__args[..])?) { [G::ZERO; OUT_451] } else { let (__hash, __hit) = record.function_queries[451].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[451].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => { aiur_fn_451::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_14, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(571, &__args[..])?) { [G::ZERO; OUT_571] } else { let (__hash, __hit) = record.function_queries[571].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[571].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[571].bump_multiplicity(__i); } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => { aiur_fn_571::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(688, &__args[..])?) { [G::ZERO; OUT_688] } else { let (__hash, __hit) = record.function_queries[688].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[688].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[688].bump_multiplicity(__i); } let __ret: [G; OUT_688] = unsafe { *(record.function_queries[688].output_at(__i).as_ptr() as *const [G; OUT_688]) }; __ret }, _ => { aiur_fn_688::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(682, &__args[..])?) { [G::ZERO; OUT_682] } else { let (__hash, __hit) = record.function_queries[682].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[682].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[682].bump_multiplicity(__i); } let __ret: [G; OUT_682] = unsafe { *(record.function_queries[682].output_at(__i).as_ptr() as *const [G; OUT_682]) }; __ret }, _ => { aiur_fn_682::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_689] = []; record.function_queries[689].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_690: usize = 2; -const IN_690: usize = 2; -const OUT_690: usize = 0; -fn aiur_fn_690(inp: [G; IN_690], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_690], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_234] = { let __args: [G; IN_234] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; let __v_9: G = __loaded[6]; let __v_10: G = __loaded[7]; let __v_11: G = __loaded[8]; let __v_12: G = __loaded[9]; let __v_13: G = __loaded[10]; let __v_14: G = __loaded[11]; let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(689, &__args[..])?) { [G::ZERO; OUT_689] } else { let (__hash, __hit) = record.function_queries[689].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[689].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[689].bump_multiplicity(__i); } let __ret: [G; OUT_689] = unsafe { *(record.function_queries[689].output_at(__i).as_ptr() as *const [G; OUT_689]) }; __ret }, _ => { aiur_fn_689::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_690] = []; record.function_queries[690].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_691: usize = 1; -const IN_691: usize = 1; -const OUT_691: usize = 1; -fn aiur_fn_691(inp: [G; IN_691], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_691], ExecError> { stacker::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; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; match __v_1.as_canonical_u64() { 2u64 => { let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 3] = [__v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_index_mut(1).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_19, __v_20, __v_22]; let __mq = record.memory_queries.get_index_mut(1).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_691] = [__v_23]; record.function_queries[691].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_19, __v_20, __v_21]; let __mq = record.memory_queries.get_index_mut(1).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_691] = [__v_22]; record.function_queries[691].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_691] = [__v_21]; record.function_queries[691].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_691] = [__v_21]; record.function_queries[691].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_19, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_691] = [__v_21]; record.function_queries[691].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_20, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_19, __v_22]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_691] = [__v_23]; record.function_queries[691].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(1); let __v_20: G = { let __values: [G; 3] = [__v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_index_mut(1).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_691] = [__v_20]; record.function_queries[691].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_692: usize = 1; -const IN_692: usize = 1; -const OUT_692: usize = 1; -fn aiur_fn_692(inp: [G; IN_692], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_692], ExecError> { stacker::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(1).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 __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_4]; let __mq = record.memory_queries.get_index_mut(1).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_692] = [__v_5]; record.function_queries[692].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(692, &__args[..])?) { [G::ZERO; OUT_692] } else { let (__hash, __hit) = record.function_queries[692].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[692].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[692].bump_multiplicity(__i); } let __ret: [G; OUT_692] = unsafe { *(record.function_queries[692].output_at(__i).as_ptr() as *const [G; OUT_692]) }; __ret }, _ => { aiur_fn_692::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_692] = [__v_6]; record.function_queries[692].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_693: usize = 1; -const IN_693: usize = 1; -const OUT_693: usize = 1; -fn aiur_fn_693(inp: [G; IN_693], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_693], ExecError> { stacker::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(8).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(1); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(1).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_693] = [__v_13]; record.function_queries[693].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(693, &__args[..])?) { [G::ZERO; OUT_693] } else { let (__hash, __hit) = record.function_queries[693].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[693].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[693].bump_multiplicity(__i); } let __ret: [G; OUT_693] = unsafe { *(record.function_queries[693].output_at(__i).as_ptr() as *const [G; OUT_693]) }; __ret }, _ => { aiur_fn_693::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_693] = [__v_14]; record.function_queries[693].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_694: usize = 1; -const IN_694: usize = 1; -const OUT_694: usize = 1; -fn aiur_fn_694(inp: [G; IN_694], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_694], ExecError> { stacker::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; 36] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(14).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(36))?; 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: 36 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = __loaded[32]; let __v_34: G = __loaded[33]; let __v_35: G = __loaded[34]; let __v_36: G = __loaded[35]; match __v_1.as_canonical_u64() { 1u64 => { let __v_37: G = G::from_u64(1); let __v_38: G = { let __values: [G; 3] = [__v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_index_mut(1).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_694] = [__v_38]; record.function_queries[694].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(694, &__args[..])?) { [G::ZERO; OUT_694] } else { let (__hash, __hit) = record.function_queries[694].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[694].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[694].bump_multiplicity(__i); } let __ret: [G; OUT_694] = unsafe { *(record.function_queries[694].output_at(__i).as_ptr() as *const [G; OUT_694]) }; __ret }, _ => { aiur_fn_694::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_37, __v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_39: G = __r_arr[0]; let __ret: [G; OUT_694] = [__v_39]; record.function_queries[694].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_695: usize = 1; -const IN_695: usize = 1; -const OUT_695: usize = 1; -fn aiur_fn_695(inp: [G; IN_695], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_695], ExecError> { stacker::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; 47] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(15).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = __loaded[32]; let __v_34: G = __loaded[33]; let __v_35: G = __loaded[34]; let __v_36: G = __loaded[35]; let __v_37: G = __loaded[36]; let __v_38: G = __loaded[37]; let __v_39: G = __loaded[38]; let __v_40: G = __loaded[39]; let __v_41: G = __loaded[40]; let __v_42: G = __loaded[41]; let __v_43: G = __loaded[42]; let __v_44: G = __loaded[43]; let __v_45: G = __loaded[44]; let __v_46: G = __loaded[45]; let __v_47: G = __loaded[46]; match __v_1.as_canonical_u64() { 1u64 => { let __v_48: G = G::from_u64(1); let __v_49: G = { let __values: [G; 3] = [__v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_index_mut(1).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_695] = [__v_49]; record.function_queries[695].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(695, &__args[..])?) { [G::ZERO; OUT_695] } else { let (__hash, __hit) = record.function_queries[695].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[695].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[695].bump_multiplicity(__i); } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => { aiur_fn_695::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_50, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_695] = [__v_52]; record.function_queries[695].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 1u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_29]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(694, &__args[..])?) { [G::ZERO; OUT_694] } else { let (__hash, __hit) = record.function_queries[694].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[694].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[694].bump_multiplicity(__i); } let __ret: [G; OUT_694] = unsafe { *(record.function_queries[694].output_at(__i).as_ptr() as *const [G; OUT_694]) }; __ret }, _ => { aiur_fn_694::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(695, &__args[..])?) { [G::ZERO; OUT_695] } else { let (__hash, __hit) = record.function_queries[695].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[695].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[695].bump_multiplicity(__i); } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => { aiur_fn_695::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_50, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_695] = [__v_52]; record.function_queries[695].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(693, &__args[..])?) { [G::ZERO; OUT_693] } else { let (__hash, __hit) = record.function_queries[693].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[693].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[693].bump_multiplicity(__i); } let __ret: [G; OUT_693] = unsafe { *(record.function_queries[693].output_at(__i).as_ptr() as *const [G; OUT_693]) }; __ret }, _ => { aiur_fn_693::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(695, &__args[..])?) { [G::ZERO; OUT_695] } else { let (__hash, __hit) = record.function_queries[695].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[695].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[695].bump_multiplicity(__i); } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => { aiur_fn_695::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_50, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_695] = [__v_52]; record.function_queries[695].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_696: usize = 48; -const IN_696: usize = 48; -const OUT_696: usize = 1; -fn aiur_fn_696(inp: [G; IN_696], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_696], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_0.as_canonical_u64() { _ => { let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_45]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(692, &__args[..])?) { [G::ZERO; OUT_692] } else { let (__hash, __hit) = record.function_queries[692].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[692].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[692].bump_multiplicity(__i); } let __ret: [G; OUT_692] = unsafe { *(record.function_queries[692].output_at(__i).as_ptr() as *const [G; OUT_692]) }; __ret }, _ => { aiur_fn_692::(__args, __hash, record, io_buffer)? }, } } }; let __v_48: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_49, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_48, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_696] = [__v_52]; record.function_queries[696].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 1u64 => { match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(693, &__args[..])?) { [G::ZERO; OUT_693] } else { let (__hash, __hit) = record.function_queries[693].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[693].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[693].bump_multiplicity(__i); } let __ret: [G; OUT_693] = unsafe { *(record.function_queries[693].output_at(__i).as_ptr() as *const [G; OUT_693]) }; __ret }, _ => { aiur_fn_693::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_49, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_48, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_696] = [__v_52]; record.function_queries[696].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_696] = [__v_50]; record.function_queries[696].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 3u64 => { match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(691, &__args[..])?) { [G::ZERO; OUT_691] } else { let (__hash, __hit) = record.function_queries[691].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[691].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => { aiur_fn_691::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_696] = [__v_50]; record.function_queries[696].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 8u64 => { let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(695, &__args[..])?) { [G::ZERO; OUT_695] } else { let (__hash, __hit) = record.function_queries[695].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[695].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[695].bump_multiplicity(__i); } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => { aiur_fn_695::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_696] = [__v_50]; record.function_queries[696].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_696] = [__v_48]; record.function_queries[696].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_697: usize = 2; -const IN_697: usize = 2; -const OUT_697: usize = 1; -fn aiur_fn_697(inp: [G; IN_697], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_697], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_697] = [__v_5]; record.function_queries[697].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = __v_3 - __v_1; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_697] = [__v_6]; record.function_queries[697].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(697, &__args[..])?) { [G::ZERO; OUT_697] } else { let (__hash, __hit) = record.function_queries[697].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[697].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[697].bump_multiplicity(__i); } let __ret: [G; OUT_697] = unsafe { *(record.function_queries[697].output_at(__i).as_ptr() as *const [G; OUT_697]) }; __ret }, _ => { aiur_fn_697::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_697] = [__v_6]; record.function_queries[697].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_698: usize = 2; -const IN_698: usize = 2; -const OUT_698: usize = 0; -fn aiur_fn_698(inp: [G; IN_698], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_698], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_228] = { let __args: [G; IN_228] = [__v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = __r_arr[10]; let __v_13: G = __r_arr[11]; let __v_14: G = __r_arr[12]; let __v_15: G = __r_arr[13]; let __v_16: G = __r_arr[14]; let __v_17: G = __r_arr[15]; let __v_18: G = __r_arr[16]; let __v_19: G = __r_arr[17]; let __v_20: G = __r_arr[18]; let __v_21: G = __r_arr[19]; let __v_22: G = __r_arr[20]; let __v_23: G = __r_arr[21]; let __v_24: G = __r_arr[22]; let __v_25: G = __r_arr[23]; let __v_26: G = __r_arr[24]; let __v_27: G = __r_arr[25]; let __v_28: G = __r_arr[26]; let __v_29: G = __r_arr[27]; let __v_30: G = __r_arr[28]; let __v_31: G = __r_arr[29]; let __v_32: G = __r_arr[30]; let __v_33: G = __r_arr[31]; let __v_34: G = __r_arr[32]; let __v_35: G = __r_arr[33]; let __v_36: G = __r_arr[34]; let __v_37: G = __r_arr[35]; let __v_38: G = __r_arr[36]; let __v_39: G = __r_arr[37]; let __v_40: G = __r_arr[38]; let __v_41: G = __r_arr[39]; let __v_42: G = __r_arr[40]; let __v_43: G = __r_arr[41]; let __v_44: G = __r_arr[42]; let __v_45: G = __r_arr[43]; let __v_46: G = __r_arr[44]; let __v_47: G = __r_arr[45]; let __v_48: G = __r_arr[46]; let __v_49: G = __r_arr[47]; match __v_2.as_canonical_u64() { _ => { let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_2.as_canonical_u64() { 8u64 => { let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_0, __v_1, __v_3, __v_3, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(700, &__args[..])?) { [G::ZERO; OUT_700] } else { let (__hash, __hit) = record.function_queries[700].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[700].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[700].bump_multiplicity(__i); } let __ret: [G; OUT_700] = unsafe { *(record.function_queries[700].output_at(__i).as_ptr() as *const [G; OUT_700]) }; __ret }, _ => { aiur_fn_700::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, 7u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(690, &__args[..])?) { [G::ZERO; OUT_690] } else { let (__hash, __hit) = record.function_queries[690].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[690].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => { aiur_fn_690::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(698, &__args[..])?) { [G::ZERO; OUT_698] } else { let (__hash, __hit) = record.function_queries[698].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[698].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => { aiur_fn_698::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, } }, 6u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(690, &__args[..])?) { [G::ZERO; OUT_690] } else { let (__hash, __hit) = record.function_queries[690].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[690].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => { aiur_fn_690::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(698, &__args[..])?) { [G::ZERO; OUT_698] } else { let (__hash, __hit) = record.function_queries[698].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[698].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => { aiur_fn_698::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, } }, 4u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(690, &__args[..])?) { [G::ZERO; OUT_690] } else { let (__hash, __hit) = record.function_queries[690].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[690].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => { aiur_fn_690::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(698, &__args[..])?) { [G::ZERO; OUT_698] } else { let (__hash, __hit) = record.function_queries[698].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[698].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => { aiur_fn_698::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, } }, 5u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(690, &__args[..])?) { [G::ZERO; OUT_690] } else { let (__hash, __hit) = record.function_queries[690].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[690].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => { aiur_fn_690::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(698, &__args[..])?) { [G::ZERO; OUT_698] } else { let (__hash, __hit) = record.function_queries[698].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[698].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => { aiur_fn_698::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, } }, _ => { let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(690, &__args[..])?) { [G::ZERO; OUT_690] } else { let (__hash, __hit) = record.function_queries[690].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[690].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => { aiur_fn_690::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, } }; let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(696, &__args[..])?) { [G::ZERO; OUT_696] } else { let (__hash, __hit) = record.function_queries[696].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[696].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[696].bump_multiplicity(__i); } let __ret: [G; OUT_696] = unsafe { *(record.function_queries[696].output_at(__i).as_ptr() as *const [G; OUT_696]) }; __ret }, _ => { aiur_fn_696::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_0, __v_48, __v_50, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(699, &__args[..])?) { [G::ZERO; OUT_699] } else { let (__hash, __hit) = record.function_queries[699].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[699].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => { aiur_fn_699::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_698] = []; record.function_queries[698].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_699: usize = 4; -const IN_699: usize = 4; -const OUT_699: usize = 0; -fn aiur_fn_699(inp: [G; IN_699], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_699], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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 __ret: [G; OUT_699] = []; record.function_queries[699].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(697, &__args[..])?) { [G::ZERO; OUT_697] } else { let (__hash, __hit) = record.function_queries[697].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[697].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[697].bump_multiplicity(__i); } let __ret: [G; OUT_697] = unsafe { *(record.function_queries[697].output_at(__i).as_ptr() as *const [G; OUT_697]) }; __ret }, _ => { aiur_fn_697::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(508, &__args[..])?) { [G::ZERO; OUT_508] } else { let (__hash, __hit) = record.function_queries[508].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[508].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[508].bump_multiplicity(__i); } let __ret: [G; OUT_508] = unsafe { *(record.function_queries[508].output_at(__i).as_ptr() as *const [G; OUT_508]) }; __ret }, _ => { aiur_fn_508::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(487, &__args[..])?) { [G::ZERO; OUT_487] } else { let (__hash, __hit) = record.function_queries[487].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[487].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => { aiur_fn_487::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(486, &__args[..])?) { [G::ZERO; OUT_486] } else { let (__hash, __hit) = record.function_queries[486].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[486].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[486].bump_multiplicity(__i); } let __ret: [G; OUT_486] = unsafe { *(record.function_queries[486].output_at(__i).as_ptr() as *const [G; OUT_486]) }; __ret }, _ => { aiur_fn_486::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_9, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(698, &__args[..])?) { [G::ZERO; OUT_698] } else { let (__hash, __hit) = record.function_queries[698].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[698].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => { aiur_fn_698::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, _ => { break '__mc_0 []; }, } }, _ => { break '__mc_0 []; }, } }; let __v_8: G = G::from_u64(1); let __v_9: G = __v_3 + __v_8; let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_0, __v_6, __v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(699, &__args[..])?) { [G::ZERO; OUT_699] } else { let (__hash, __hit) = record.function_queries[699].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[699].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => { aiur_fn_699::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_699] = []; record.function_queries[699].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_700: usize = 5; -const IN_700: usize = 5; -const OUT_700: usize = 0; -fn aiur_fn_700(inp: [G; IN_700], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_700], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 47] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(15).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].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 __v_37: G = __loaded[32]; let __v_38: G = __loaded[33]; let __v_39: G = __loaded[34]; let __v_40: G = __loaded[35]; let __v_41: G = __loaded[36]; let __v_42: G = __loaded[37]; let __v_43: G = __loaded[38]; let __v_44: G = __loaded[39]; let __v_45: G = __loaded[40]; let __v_46: G = __loaded[41]; let __v_47: G = __loaded[42]; let __v_48: G = __loaded[43]; let __v_49: G = __loaded[44]; let __v_50: G = __loaded[45]; let __v_51: G = __loaded[46]; match __v_5.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_700] = []; record.function_queries[700].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __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_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(701, &__args[..])?) { [G::ZERO; OUT_701] } else { let (__hash, __hit) = record.function_queries[701].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[701].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[701].bump_multiplicity(__i); } let __ret: [G; OUT_701] = unsafe { *(record.function_queries[701].output_at(__i).as_ptr() as *const [G; OUT_701]) }; __ret }, _ => { aiur_fn_701::(__args, __hash, record, io_buffer)? }, } } }; let __v_52: G = G::from_u64(1); let __v_53: G = __v_4 + __v_52; let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_0, __v_1, __v_2, __v_51, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(700, &__args[..])?) { [G::ZERO; OUT_700] } else { let (__hash, __hit) = record.function_queries[700].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[700].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[700].bump_multiplicity(__i); } let __ret: [G; OUT_700] = unsafe { *(record.function_queries[700].output_at(__i).as_ptr() as *const [G; OUT_700]) }; __ret }, _ => { aiur_fn_700::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_700] = []; record.function_queries[700].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_701: usize = 49; -const IN_701: usize = 49; -const OUT_701: usize = 0; -fn aiur_fn_701(inp: [G; IN_701], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_701], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2, __v_1, __v_48]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_51: G = __loaded[0]; let __v_52: G = __loaded[1]; let __v_53: G = __loaded[2]; let __v_54: G = __loaded[3]; let __v_55: G = __loaded[4]; let __v_56: G = __loaded[5]; let __v_57: G = __loaded[6]; let __v_58: G = __loaded[7]; let __v_59: G = __loaded[8]; let __v_60: G = __loaded[9]; let __v_61: G = __loaded[10]; let __v_62: G = __loaded[11]; let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_0, __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_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(689, &__args[..])?) { [G::ZERO; OUT_689] } else { let (__hash, __hit) = record.function_queries[689].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[689].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[689].bump_multiplicity(__i); } let __ret: [G; OUT_689] = unsafe { *(record.function_queries[689].output_at(__i).as_ptr() as *const [G; OUT_689]) }; __ret }, _ => { aiur_fn_689::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_701] = []; record.function_queries[701].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_702: usize = 1; -const IN_702: usize = 1; -const OUT_702: usize = 1; -fn aiur_fn_702(inp: [G; IN_702], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_702], ExecError> { stacker::maybe_grow(64 * 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(1); let __v_2: G = { let __values: [G; 3] = [__v_1, __v_1, __v_1]; let __mq = record.memory_queries.get_index_mut(1).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_56] = { let __args: [G; IN_56] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(56, &__args[..])?) { [G::ZERO; OUT_56] } else { let (__hash, __hit) = record.function_queries[56].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[56].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => { aiur_fn_56::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); let __v_5: G = { let __values: [G; 3] = [__v_4, __v_4, __v_3]; let __mq = record.memory_queries.get_index_mut(1).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_23] = { let __args: [G; IN_23] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(23, &__args[..])?) { [G::ZERO; OUT_23] } else { let (__hash, __hit) = record.function_queries[23].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[23].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[23].bump_multiplicity(__i); } let __ret: [G; OUT_23] = unsafe { *(record.function_queries[23].output_at(__i).as_ptr() as *const [G; OUT_23]) }; __ret }, _ => { aiur_fn_23::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_702] = [__v_6]; record.function_queries[702].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_703: usize = 2; -const IN_703: usize = 2; -const OUT_703: usize = 1; -fn aiur_fn_703(inp: [G; IN_703], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_703], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_56] = { let __args: [G; IN_56] = [__v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(56, &__args[..])?) { [G::ZERO; OUT_56] } else { let (__hash, __hit) = record.function_queries[56].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[56].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => { aiur_fn_56::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(56, &__args[..])?) { [G::ZERO; OUT_56] } else { let (__hash, __hit) = record.function_queries[56].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[56].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => { aiur_fn_56::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_2, __v_5]; let __mq = record.memory_queries.get_index_mut(1).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_23] = { let __args: [G; IN_23] = [__v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(23, &__args[..])?) { [G::ZERO; OUT_23] } else { let (__hash, __hit) = record.function_queries[23].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[23].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[23].bump_multiplicity(__i); } let __ret: [G; OUT_23] = unsafe { *(record.function_queries[23].output_at(__i).as_ptr() as *const [G; OUT_23]) }; __ret }, _ => { aiur_fn_23::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_703] = [__v_8]; record.function_queries[703].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_704: usize = 1; -const IN_704: usize = 1; -const OUT_704: usize = 3; -fn aiur_fn_704(inp: [G; IN_704], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_704], ExecError> { stacker::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_83] = { let __args: [G; IN_83] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(702, &__args[..])?) { [G::ZERO; OUT_702] } else { let (__hash, __hit) = record.function_queries[702].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[702].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[702].bump_multiplicity(__i); } let __ret: [G; OUT_702] = unsafe { *(record.function_queries[702].output_at(__i).as_ptr() as *const [G; OUT_702]) }; __ret }, _ => { aiur_fn_702::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_index_mut(1).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_6, __v_3, __v_8]; let __mq = record.memory_queries.get_index_mut(1).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_704] = [__v_5, __v_9, __v_4]; record.function_queries[704].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 32] = [__v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_index_mut(12).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_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(1).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_704] = [__v_4, __v_6, __v_2]; record.function_queries[704].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(704, &__args[..])?) { [G::ZERO; OUT_704] } else { let (__hash, __hit) = record.function_queries[704].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[704].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[704].bump_multiplicity(__i); } let __ret: [G; OUT_704] = unsafe { *(record.function_queries[704].output_at(__i).as_ptr() as *const [G; OUT_704]) }; __ret }, _ => { aiur_fn_704::(__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 __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(704, &__args[..])?) { [G::ZERO; OUT_704] } else { let (__hash, __hit) = record.function_queries[704].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[704].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[704].bump_multiplicity(__i); } let __ret: [G; OUT_704] = unsafe { *(record.function_queries[704].output_at(__i).as_ptr() as *const [G; OUT_704]) }; __ret }, _ => { aiur_fn_704::(__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 __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_3, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(703, &__args[..])?) { [G::ZERO; OUT_703] } else { let (__hash, __hit) = record.function_queries[703].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[703].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[703].bump_multiplicity(__i); } let __ret: [G; OUT_703] = unsafe { *(record.function_queries[703].output_at(__i).as_ptr() as *const [G; OUT_703]) }; __ret }, _ => { aiur_fn_703::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_704] = [__v_9, __v_10, __v_8]; record.function_queries[704].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_705: usize = 1; -const IN_705: usize = 1; -const OUT_705: usize = 1; -fn aiur_fn_705(inp: [G; IN_705], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_705], ExecError> { stacker::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; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).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_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = G::from_u64(1); let __io_pair: (G, G) = { let __key: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_33, __v_34, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(5, &__args[..])?) { [G::ZERO; OUT_5] } else { let (__hash, __hit) = record.function_queries[5].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[5].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => { aiur_fn_5::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_36]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = G::from_u64(226); if (__v_37 != __v_39) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_39.as_canonical_u64(), msg: Some("assumption tree: wrong TagN header".to_string()) }); } let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_38]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(704, &__args[..])?) { [G::ZERO; OUT_704] } else { let (__hash, __hit) = record.function_queries[704].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[704].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[704].bump_multiplicity(__i); } let __ret: [G; OUT_704] = unsafe { *(record.function_queries[704].output_at(__i).as_ptr() as *const [G; OUT_704]) }; __ret }, _ => { aiur_fn_704::(__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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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]; if (__v_43 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: Some("assumption tree: trailing bytes after tree body".to_string()) }); } if (__v_44 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: Some("assumption tree: trailing bytes after tree body".to_string()) }); } if (__v_45 != __v_33) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: Some("assumption tree: trailing bytes after tree body".to_string()) }); } let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_46: G = __loaded[0]; let __v_47: G = __loaded[1]; let __v_48: G = __loaded[2]; let __v_49: G = __loaded[3]; let __v_50: G = __loaded[4]; let __v_51: G = __loaded[5]; let __v_52: G = __loaded[6]; let __v_53: G = __loaded[7]; let __v_54: G = __loaded[8]; let __v_55: G = __loaded[9]; let __v_56: G = __loaded[10]; let __v_57: G = __loaded[11]; let __v_58: G = __loaded[12]; let __v_59: G = __loaded[13]; let __v_60: G = __loaded[14]; let __v_61: G = __loaded[15]; let __v_62: G = __loaded[16]; let __v_63: G = __loaded[17]; let __v_64: G = __loaded[18]; let __v_65: G = __loaded[19]; let __v_66: G = __loaded[20]; let __v_67: G = __loaded[21]; let __v_68: G = __loaded[22]; let __v_69: G = __loaded[23]; let __v_70: G = __loaded[24]; let __v_71: G = __loaded[25]; let __v_72: G = __loaded[26]; let __v_73: G = __loaded[27]; let __v_74: G = __loaded[28]; let __v_75: G = __loaded[29]; let __v_76: G = __loaded[30]; let __v_77: G = __loaded[31]; if (__v_46 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_47 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_48 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_49 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_50 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_50.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_51 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_52 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_53 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_54 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_55 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_56 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_57 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_58 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_59 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_60 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_61 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_62 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_63 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_64 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_65 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_66 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_67 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_68 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_69 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_70 != __v_25) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_71 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_72 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_73 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_74 != __v_29) { return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_75 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_76 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } if (__v_77 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } let __ret: [G; OUT_705] = [__v_41]; record.function_queries[705].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_706: usize = 7; -const IN_706: usize = 7; -const OUT_706: usize = 6; -fn aiur_fn_706(inp: [G; IN_706], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_706], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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 __ret: [G; OUT_706] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; record.function_queries[706].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(1); let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(779, &__args[..])?) { [G::ZERO; OUT_779] } else { let (__hash, __hit) = record.function_queries[779].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[779].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => { aiur_fn_779::(__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 __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(706, &__args[..])?) { [G::ZERO; OUT_706] } else { let (__hash, __hit) = record.function_queries[706].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[706].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[706].bump_multiplicity(__i); } let __ret: [G; OUT_706] = unsafe { *(record.function_queries[706].output_at(__i).as_ptr() as *const [G; OUT_706]) }; __ret }, _ => { aiur_fn_706::(__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 __ret: [G; OUT_706] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; record.function_queries[706].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_707: usize = 7; -const IN_707: usize = 7; -const OUT_707: usize = 1; -fn aiur_fn_707(inp: [G; IN_707], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_707], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = G::from_u64(0); let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(763, &__args[..])?) { [G::ZERO; OUT_763] } else { let (__hash, __hit) = record.function_queries[763].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[763].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => { aiur_fn_763::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_707] = [__v_8]; record.function_queries[707].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_708: usize = 15; -const IN_708: usize = 15; -const OUT_708: usize = 0; -fn aiur_fn_708(inp: [G; IN_708], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_708], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_707] = { let __args: [G; IN_707] = [__v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(707, &__args[..])?) { [G::ZERO; OUT_707] } else { let (__hash, __hit) = record.function_queries[707].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[707].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[707].bump_multiplicity(__i); } let __ret: [G; OUT_707] = unsafe { *(record.function_queries[707].output_at(__i).as_ptr() as *const [G; OUT_707]) }; __ret }, _ => { aiur_fn_707::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(2); let __v_17: G = __v_14 - __v_16; let __v_18: G = G::from_bool(__v_17 == G::ZERO); let __v_19: G = G::from_u64(0); if (__v_18 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Check: target is in the assumption set".to_string()) }); } let __ret: [G; OUT_708] = []; record.function_queries[708].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_14.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(707, &__args[..])?) { [G::ZERO; OUT_707] } else { let (__hash, __hit) = record.function_queries[707].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[707].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[707].bump_multiplicity(__i); } let __ret: [G; OUT_707] = unsafe { *(record.function_queries[707].output_at(__i).as_ptr() as *const [G; OUT_707]) }; __ret }, _ => { aiur_fn_707::(__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: Some("CheckEnv: walk reached a constant outside the owned set".to_string()) }); } break '__mc_0 [__v_17]; }, _ => { let __v_16: G = G::from_u64(0); break '__mc_0 [__v_16]; }, } }; let __v_16: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_1]; 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_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 __v_28: G = __r_arr[11]; let __v_29: G = __r_arr[12]; let __v_30: G = __r_arr[13]; let __v_31: G = __r_arr[14]; let __v_32: G = __r_arr[15]; let __v_33: G = __r_arr[16]; let __v_34: G = __r_arr[17]; let __v_35: G = __r_arr[18]; let __v_36: G = __r_arr[19]; let __v_37: G = __r_arr[20]; let __v_38: G = __r_arr[21]; let __v_39: G = __r_arr[22]; let __v_40: G = __r_arr[23]; let __v_41: G = __r_arr[24]; let __v_42: G = __r_arr[25]; let __v_43: G = __r_arr[26]; let __v_44: G = __r_arr[27]; let __v_45: G = __r_arr[28]; let __v_46: G = __r_arr[29]; let __v_47: G = __r_arr[30]; let __v_48: G = __r_arr[31]; let __v_49: G = __r_arr[32]; let __v_50: G = __r_arr[33]; let __v_51: G = __r_arr[34]; let __v_52: G = __r_arr[35]; let __v_53: G = __r_arr[36]; let __v_54: G = __r_arr[37]; let __v_55: G = __r_arr[38]; let __v_56: G = __r_arr[39]; let __v_57: G = __r_arr[40]; let __v_58: G = __r_arr[41]; let __v_59: G = __r_arr[42]; let __v_60: G = __r_arr[43]; let __v_61: G = __r_arr[44]; let __v_62: G = __r_arr[45]; let __v_63: G = __r_arr[46]; let __v_64: G = __r_arr[47]; match __v_17.as_canonical_u64() { _ => { let __mc_out___mc_1: [G; 0] = '__mc_1: { match __v_17.as_canonical_u64() { 8u64 => { let __v_65: G = G::from_u64(0); let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_0, __v_1, __v_18, __v_18, __v_65]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(700, &__args[..])?) { [G::ZERO; OUT_700] } else { let (__hash, __hit) = record.function_queries[700].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[700].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[700].bump_multiplicity(__i); } let __ret: [G; OUT_700] = unsafe { *(record.function_queries[700].output_at(__i).as_ptr() as *const [G; OUT_700]) }; __ret }, _ => { aiur_fn_700::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_1 []; }, 7u64 => { match __v_18.as_canonical_u64() { _ => { let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(690, &__args[..])?) { [G::ZERO; OUT_690] } else { let (__hash, __hit) = record.function_queries[690].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[690].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => { aiur_fn_690::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_26, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(708, &__args[..])?) { [G::ZERO; OUT_708] } else { let (__hash, __hit) = record.function_queries[708].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[708].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[708].bump_multiplicity(__i); } let __ret: [G; OUT_708] = unsafe { *(record.function_queries[708].output_at(__i).as_ptr() as *const [G; OUT_708]) }; __ret }, _ => { aiur_fn_708::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_1 []; }, } }, 6u64 => { match __v_18.as_canonical_u64() { _ => { let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(690, &__args[..])?) { [G::ZERO; OUT_690] } else { let (__hash, __hit) = record.function_queries[690].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[690].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => { aiur_fn_690::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_26, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(708, &__args[..])?) { [G::ZERO; OUT_708] } else { let (__hash, __hit) = record.function_queries[708].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[708].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[708].bump_multiplicity(__i); } let __ret: [G; OUT_708] = unsafe { *(record.function_queries[708].output_at(__i).as_ptr() as *const [G; OUT_708]) }; __ret }, _ => { aiur_fn_708::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_1 []; }, } }, 4u64 => { match __v_18.as_canonical_u64() { _ => { let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(690, &__args[..])?) { [G::ZERO; OUT_690] } else { let (__hash, __hit) = record.function_queries[690].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[690].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => { aiur_fn_690::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_34, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(708, &__args[..])?) { [G::ZERO; OUT_708] } else { let (__hash, __hit) = record.function_queries[708].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[708].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[708].bump_multiplicity(__i); } let __ret: [G; OUT_708] = unsafe { *(record.function_queries[708].output_at(__i).as_ptr() as *const [G; OUT_708]) }; __ret }, _ => { aiur_fn_708::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_1 []; }, } }, 5u64 => { match __v_18.as_canonical_u64() { _ => { let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(690, &__args[..])?) { [G::ZERO; OUT_690] } else { let (__hash, __hit) = record.function_queries[690].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[690].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => { aiur_fn_690::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_26, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(708, &__args[..])?) { [G::ZERO; OUT_708] } else { let (__hash, __hit) = record.function_queries[708].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[708].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[708].bump_multiplicity(__i); } let __ret: [G; OUT_708] = unsafe { *(record.function_queries[708].output_at(__i).as_ptr() as *const [G; OUT_708]) }; __ret }, _ => { aiur_fn_708::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_1 []; }, } }, _ => { let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(690, &__args[..])?) { [G::ZERO; OUT_690] } else { let (__hash, __hit) = record.function_queries[690].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[690].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => { aiur_fn_690::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_1 []; }, } }; let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(696, &__args[..])?) { [G::ZERO; OUT_696] } else { let (__hash, __hit) = record.function_queries[696].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[696].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[696].bump_multiplicity(__i); } let __ret: [G; OUT_696] = unsafe { *(record.function_queries[696].output_at(__i).as_ptr() as *const [G; OUT_696]) }; __ret }, _ => { aiur_fn_696::(__args, __hash, record, io_buffer)? }, } } }; let __v_65: G = __r_arr[0]; let __v_66: G = G::from_u64(0); let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0, __v_63, __v_65, __v_66, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(709, &__args[..])?) { [G::ZERO; OUT_709] } else { let (__hash, __hit) = record.function_queries[709].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[709].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[709].bump_multiplicity(__i); } let __ret: [G; OUT_709] = unsafe { *(record.function_queries[709].output_at(__i).as_ptr() as *const [G; OUT_709]) }; __ret }, _ => { aiur_fn_709::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_708] = []; record.function_queries[708].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_709: usize = 17; -const IN_709: usize = 17; -const OUT_709: usize = 0; -fn aiur_fn_709(inp: [G; IN_709], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_709], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; match __v_17.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_709] = []; record.function_queries[709].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(697, &__args[..])?) { [G::ZERO; OUT_697] } else { let (__hash, __hit) = record.function_queries[697].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[697].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[697].bump_multiplicity(__i); } let __ret: [G; OUT_697] = unsafe { *(record.function_queries[697].output_at(__i).as_ptr() as *const [G; OUT_697]) }; __ret }, _ => { aiur_fn_697::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_20.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(508, &__args[..])?) { [G::ZERO; OUT_508] } else { let (__hash, __hit) = record.function_queries[508].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[508].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[508].bump_multiplicity(__i); } let __ret: [G; OUT_508] = unsafe { *(record.function_queries[508].output_at(__i).as_ptr() as *const [G; OUT_508]) }; __ret }, _ => { aiur_fn_508::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(487, &__args[..])?) { [G::ZERO; OUT_487] } else { let (__hash, __hit) = record.function_queries[487].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[487].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => { aiur_fn_487::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; match __v_21.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(486, &__args[..])?) { [G::ZERO; OUT_486] } else { let (__hash, __hit) = record.function_queries[486].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[486].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[486].bump_multiplicity(__i); } let __ret: [G; OUT_486] = unsafe { *(record.function_queries[486].output_at(__i).as_ptr() as *const [G; OUT_486]) }; __ret }, _ => { aiur_fn_486::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_22, __v_18, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(708, &__args[..])?) { [G::ZERO; OUT_708] } else { let (__hash, __hit) = record.function_queries[708].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[708].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[708].bump_multiplicity(__i); } let __ret: [G; OUT_708] = unsafe { *(record.function_queries[708].output_at(__i).as_ptr() as *const [G; OUT_708]) }; __ret }, _ => { aiur_fn_708::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, _ => { break '__mc_0 []; }, } }, _ => { break '__mc_0 []; }, } }; let __v_21: G = G::from_u64(1); let __v_22: G = __v_3 + __v_21; let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0, __v_19, __v_2, __v_22, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(709, &__args[..])?) { [G::ZERO; OUT_709] } else { let (__hash, __hit) = record.function_queries[709].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[709].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[709].bump_multiplicity(__i); } let __ret: [G; OUT_709] = unsafe { *(record.function_queries[709].output_at(__i).as_ptr() as *const [G; OUT_709]) }; __ret }, _ => { aiur_fn_709::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_709] = []; record.function_queries[709].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }) } -const INPUT_SIZE_710: usize = 14; -const IN_710: usize = 14; -const OUT_710: usize = 0; -fn aiur_fn_710(inp: [G; IN_710], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_710], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; match __v_14.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_710] = []; record.function_queries[710].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_15, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(707, &__args[..])?) { [G::ZERO; OUT_707] } else { let (__hash, __hit) = record.function_queries[707].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[707].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[707].bump_multiplicity(__i); } let __ret: [G; OUT_707] = unsafe { *(record.function_queries[707].output_at(__i).as_ptr() as *const [G; OUT_707]) }; __ret }, _ => { aiur_fn_707::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); if (__v_17 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("CheckEnv: owned constant is in the assumption set".to_string()) }); } let __v_19: G = G::from_u64(1); let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(708, &__args[..])?) { [G::ZERO; OUT_708] } else { let (__hash, __hit) = record.function_queries[708].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[708].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[708].bump_multiplicity(__i); } let __ret: [G; OUT_708] = unsafe { *(record.function_queries[708].output_at(__i).as_ptr() as *const [G; OUT_708]) }; __ret }, _ => { aiur_fn_708::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__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]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(710, &__args[..])?) { [G::ZERO; OUT_710] } else { let (__hash, __hit) = record.function_queries[710].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[710].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => { aiur_fn_710::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_710] = []; record.function_queries[710].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }) } -const INPUT_SIZE_711: usize = 4; -const IN_711: usize = 4; -const OUT_711: usize = 0; -fn aiur_fn_711(inp: [G; IN_711], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_711], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_705] = { let __args: [G; IN_705] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(705, &__args[..])?) { [G::ZERO; OUT_705] } else { let (__hash, __hit) = record.function_queries[705].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[705].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[705].bump_multiplicity(__i); } let __ret: [G; OUT_705] = unsafe { *(record.function_queries[705].output_at(__i).as_ptr() as *const [G; OUT_705]) }; __ret }, _ => { aiur_fn_705::(__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(1).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]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(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: Some("CheckEnv: owned tree has no leaves".to_string()) }); } break '__mc_0 []; }, 0u64 => { break '__mc_0 []; }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }; match __v_2.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(471, &__args[..])?) { [G::ZERO; OUT_471] } else { let (__hash, __hit) = record.function_queries[471].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[471].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[471].bump_multiplicity(__i); } let __ret: [G; OUT_471] = unsafe { *(record.function_queries[471].output_at(__i).as_ptr() as *const [G; OUT_471]) }; __ret }, _ => { aiur_fn_471::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; let __v_11: G = __r_arr[3]; let __v_12: G = __r_arr[4]; let __v_13: G = __r_arr[5]; match __v_8.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(713, &__args[..])?) { [G::ZERO; OUT_713] } else { let (__hash, __hit) = record.function_queries[713].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[713].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[713].bump_multiplicity(__i); } let __ret: [G; OUT_713] = unsafe { *(record.function_queries[713].output_at(__i).as_ptr() as *const [G; OUT_713]) }; __ret }, _ => { aiur_fn_713::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_711] = []; record.function_queries[711].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(712, &__args[..])?) { [G::ZERO; OUT_712] } else { let (__hash, __hit) = record.function_queries[712].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[712].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[712].bump_multiplicity(__i); } let __ret: [G; OUT_712] = unsafe { *(record.function_queries[712].output_at(__i).as_ptr() as *const [G; OUT_712]) }; __ret }, _ => { aiur_fn_712::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_711] = []; record.function_queries[711].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, 0u64 => { let __v_8: G = G::from_u64(1); let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_4, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(706, &__args[..])?) { [G::ZERO; OUT_706] } else { let (__hash, __hit) = record.function_queries[706].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[706].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[706].bump_multiplicity(__i); } let __ret: [G; OUT_706] = unsafe { *(record.function_queries[706].output_at(__i).as_ptr() as *const [G; OUT_706]) }; __ret }, _ => { aiur_fn_706::(__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 __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(705, &__args[..])?) { [G::ZERO; OUT_705] } else { let (__hash, __hit) = record.function_queries[705].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[705].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[705].bump_multiplicity(__i); } let __ret: [G; OUT_705] = unsafe { *(record.function_queries[705].output_at(__i).as_ptr() as *const [G; OUT_705]) }; __ret }, _ => { aiur_fn_705::(__args, __hash, record, io_buffer)? }, } } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_15, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(706, &__args[..])?) { [G::ZERO; OUT_706] } else { let (__hash, __hit) = record.function_queries[706].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[706].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[706].bump_multiplicity(__i); } let __ret: [G; OUT_706] = unsafe { *(record.function_queries[706].output_at(__i).as_ptr() as *const [G; OUT_706]) }; __ret }, _ => { aiur_fn_706::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; let __v_19: G = __r_arr[3]; let __v_20: G = __r_arr[4]; let __v_21: G = __r_arr[5]; let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_0, __v_4, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(710, &__args[..])?) { [G::ZERO; OUT_710] } else { let (__hash, __hit) = record.function_queries[710].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[710].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => { aiur_fn_710::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_711] = []; record.function_queries[711].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_712: usize = 2; -const IN_712: usize = 2; -const OUT_712: usize = 0; -fn aiur_fn_712(inp: [G; IN_712], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_712], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_712] = []; record.function_queries[712].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(698, &__args[..])?) { [G::ZERO; OUT_698] } else { let (__hash, __hit) = record.function_queries[698].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[698].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => { aiur_fn_698::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(712, &__args[..])?) { [G::ZERO; OUT_712] } else { let (__hash, __hit) = record.function_queries[712].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[712].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[712].bump_multiplicity(__i); } let __ret: [G; OUT_712] = unsafe { *(record.function_queries[712].output_at(__i).as_ptr() as *const [G; OUT_712]) }; __ret }, _ => { aiur_fn_712::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_712] = []; record.function_queries[712].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_713: usize = 2; -const IN_713: usize = 2; -const OUT_713: usize = 0; -fn aiur_fn_713(inp: [G; IN_713], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_713], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_713] = []; record.function_queries[713].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(473, &__args[..])?) { [G::ZERO; OUT_473] } else { let (__hash, __hit) = record.function_queries[473].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[473].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[473].bump_multiplicity(__i); } let __ret: [G; OUT_473] = unsafe { *(record.function_queries[473].output_at(__i).as_ptr() as *const [G; OUT_473]) }; __ret }, _ => { aiur_fn_473::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; 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: 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_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; let __v_10: G = __loaded[4]; let __v_11: G = __loaded[5]; let __v_12: G = __loaded[6]; let __v_13: G = __loaded[7]; let __v_14: G = __loaded[8]; let __v_15: G = __loaded[9]; let __v_16: G = __loaded[10]; let __v_17: G = __loaded[11]; let __v_18: G = __loaded[12]; let __v_19: G = __loaded[13]; let __v_20: G = __loaded[14]; let __v_21: G = __loaded[15]; let __v_22: G = __loaded[16]; let __v_23: G = __loaded[17]; let __v_24: G = __loaded[18]; let __v_25: G = __loaded[19]; let __v_26: G = __loaded[20]; let __v_27: G = __loaded[21]; let __v_28: G = __loaded[22]; let __v_29: G = __loaded[23]; let __v_30: G = __loaded[24]; let __v_31: G = __loaded[25]; let __v_32: G = __loaded[26]; let __v_33: G = __loaded[27]; let __v_34: G = __loaded[28]; let __v_35: G = __loaded[29]; let __v_36: G = __loaded[30]; let __v_37: G = __loaded[31]; let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(469, &__args[..])?) { [G::ZERO; OUT_469] } else { let (__hash, __hit) = record.function_queries[469].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[469].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[469].bump_multiplicity(__i); } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => { aiur_fn_469::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).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_39: G = __loaded[0]; let __v_40: G = __loaded[1]; let __v_41: G = __loaded[2]; let __v_42: G = __loaded[3]; let __v_43: G = __loaded[4]; let __v_44: G = __loaded[5]; let __v_45: G = __loaded[6]; let __v_46: G = __loaded[7]; let __v_47: G = __loaded[8]; let __v_48: G = __loaded[9]; let __v_49: G = __loaded[10]; let __v_50: G = __loaded[11]; let __v_51: G = __loaded[12]; let __v_52: G = __loaded[13]; let __v_53: G = __loaded[14]; let __v_54: G = __loaded[15]; let __v_55: G = __loaded[16]; let __v_56: G = __loaded[17]; let __v_57: G = __loaded[18]; let __v_58: G = __loaded[19]; let __v_59: G = __loaded[20]; let __v_60: G = __loaded[21]; let __v_61: G = __loaded[22]; let __v_62: G = __loaded[23]; let __v_63: G = __loaded[24]; let __v_64: G = __loaded[25]; let __v_65: G = __loaded[26]; let __v_66: G = __loaded[27]; let __v_67: G = __loaded[28]; let __v_68: G = __loaded[29]; let __v_69: G = __loaded[30]; let __v_70: G = __loaded[31]; let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __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]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(714, &__args[..])?) { [G::ZERO; OUT_714] } else { let (__hash, __hit) = record.function_queries[714].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[714].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => { aiur_fn_714::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(713, &__args[..])?) { [G::ZERO; OUT_713] } else { let (__hash, __hit) = record.function_queries[713].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[713].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[713].bump_multiplicity(__i); } let __ret: [G; OUT_713] = unsafe { *(record.function_queries[713].output_at(__i).as_ptr() as *const [G; OUT_713]) }; __ret }, _ => { aiur_fn_713::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_713] = []; record.function_queries[713].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_714: usize = 65; -const IN_714: usize = 65; -const OUT_714: usize = 0; -fn aiur_fn_714(inp: [G; IN_714], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_714], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_index_mut(12).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_466] = { let __args: [G; IN_466] = [__v_65, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(466, &__args[..])?) { [G::ZERO; OUT_466] } else { let (__hash, __hit) = record.function_queries[466].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[466].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[466].bump_multiplicity(__i); } let __ret: [G; OUT_466] = unsafe { *(record.function_queries[466].output_at(__i).as_ptr() as *const [G; OUT_466]) }; __ret }, _ => { aiur_fn_466::(__args, __hash, record, io_buffer)? }, } } }; let __v_66: G = __r_arr[0]; let __v_67: G = { let __values: [G; 32] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __mq = record.memory_queries.get_index_mut(12).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_715] = { let __args: [G; IN_715] = [__v_66, __v_67]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(715, &__args[..])?) { [G::ZERO; OUT_715] } else { let (__hash, __hit) = record.function_queries[715].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[715].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => { aiur_fn_715::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_714] = []; record.function_queries[714].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_715: usize = 2; -const IN_715: usize = 2; -const OUT_715: usize = 0; -fn aiur_fn_715(inp: [G; IN_715], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_715], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_228] = { let __args: [G; IN_228] = [__v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; let __v_5: G = __r_arr[3]; let __v_6: G = __r_arr[4]; let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; let __v_12: G = __r_arr[10]; let __v_13: G = __r_arr[11]; let __v_14: G = __r_arr[12]; let __v_15: G = __r_arr[13]; let __v_16: G = __r_arr[14]; let __v_17: G = __r_arr[15]; let __v_18: G = __r_arr[16]; let __v_19: G = __r_arr[17]; let __v_20: G = __r_arr[18]; let __v_21: G = __r_arr[19]; let __v_22: G = __r_arr[20]; let __v_23: G = __r_arr[21]; let __v_24: G = __r_arr[22]; let __v_25: G = __r_arr[23]; let __v_26: G = __r_arr[24]; let __v_27: G = __r_arr[25]; let __v_28: G = __r_arr[26]; let __v_29: G = __r_arr[27]; let __v_30: G = __r_arr[28]; let __v_31: G = __r_arr[29]; let __v_32: G = __r_arr[30]; let __v_33: G = __r_arr[31]; let __v_34: G = __r_arr[32]; let __v_35: G = __r_arr[33]; let __v_36: G = __r_arr[34]; let __v_37: G = __r_arr[35]; let __v_38: G = __r_arr[36]; let __v_39: G = __r_arr[37]; let __v_40: G = __r_arr[38]; let __v_41: G = __r_arr[39]; let __v_42: G = __r_arr[40]; let __v_43: G = __r_arr[41]; let __v_44: G = __r_arr[42]; let __v_45: G = __r_arr[43]; let __v_46: G = __r_arr[44]; let __v_47: G = __r_arr[45]; let __v_48: G = __r_arr[46]; let __v_49: G = __r_arr[47]; match __v_2.as_canonical_u64() { _ => { let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_2.as_canonical_u64() { 8u64 => { let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_0, __v_1, __v_3, __v_3, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(700, &__args[..])?) { [G::ZERO; OUT_700] } else { let (__hash, __hit) = record.function_queries[700].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[700].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[700].bump_multiplicity(__i); } let __ret: [G; OUT_700] = unsafe { *(record.function_queries[700].output_at(__i).as_ptr() as *const [G; OUT_700]) }; __ret }, _ => { aiur_fn_700::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, 7u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(690, &__args[..])?) { [G::ZERO; OUT_690] } else { let (__hash, __hit) = record.function_queries[690].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[690].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => { aiur_fn_690::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(473, &__args[..])?) { [G::ZERO; OUT_473] } else { let (__hash, __hit) = record.function_queries[473].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[473].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[473].bump_multiplicity(__i); } let __ret: [G; OUT_473] = unsafe { *(record.function_queries[473].output_at(__i).as_ptr() as *const [G; OUT_473]) }; __ret }, _ => { aiur_fn_473::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_51: G = __loaded[0]; let __v_52: G = __loaded[1]; let __v_53: G = __loaded[2]; let __v_54: G = __loaded[3]; let __v_55: G = __loaded[4]; let __v_56: G = __loaded[5]; let __v_57: G = __loaded[6]; let __v_58: G = __loaded[7]; let __v_59: G = __loaded[8]; let __v_60: G = __loaded[9]; let __v_61: G = __loaded[10]; let __v_62: G = __loaded[11]; let __v_63: G = __loaded[12]; let __v_64: G = __loaded[13]; let __v_65: G = __loaded[14]; let __v_66: G = __loaded[15]; let __v_67: G = __loaded[16]; let __v_68: G = __loaded[17]; let __v_69: G = __loaded[18]; let __v_70: G = __loaded[19]; let __v_71: G = __loaded[20]; let __v_72: G = __loaded[21]; let __v_73: G = __loaded[22]; let __v_74: G = __loaded[23]; let __v_75: G = __loaded[24]; let __v_76: G = __loaded[25]; let __v_77: G = __loaded[26]; let __v_78: G = __loaded[27]; let __v_79: G = __loaded[28]; let __v_80: G = __loaded[29]; let __v_81: G = __loaded[30]; let __v_82: G = __loaded[31]; let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(469, &__args[..])?) { [G::ZERO; OUT_469] } else { let (__hash, __hit) = record.function_queries[469].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[469].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[469].bump_multiplicity(__i); } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => { aiur_fn_469::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_84: G = __loaded[0]; let __v_85: G = __loaded[1]; let __v_86: G = __loaded[2]; let __v_87: G = __loaded[3]; let __v_88: G = __loaded[4]; let __v_89: G = __loaded[5]; let __v_90: G = __loaded[6]; let __v_91: G = __loaded[7]; let __v_92: G = __loaded[8]; let __v_93: G = __loaded[9]; let __v_94: G = __loaded[10]; let __v_95: G = __loaded[11]; let __v_96: G = __loaded[12]; let __v_97: G = __loaded[13]; let __v_98: G = __loaded[14]; let __v_99: G = __loaded[15]; let __v_100: G = __loaded[16]; let __v_101: G = __loaded[17]; let __v_102: G = __loaded[18]; let __v_103: G = __loaded[19]; let __v_104: G = __loaded[20]; let __v_105: G = __loaded[21]; let __v_106: G = __loaded[22]; let __v_107: G = __loaded[23]; let __v_108: G = __loaded[24]; let __v_109: G = __loaded[25]; let __v_110: G = __loaded[26]; let __v_111: G = __loaded[27]; let __v_112: G = __loaded[28]; let __v_113: G = __loaded[29]; let __v_114: G = __loaded[30]; let __v_115: G = __loaded[31]; let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(714, &__args[..])?) { [G::ZERO; OUT_714] } else { let (__hash, __hit) = record.function_queries[714].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[714].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => { aiur_fn_714::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, } }, 6u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(690, &__args[..])?) { [G::ZERO; OUT_690] } else { let (__hash, __hit) = record.function_queries[690].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[690].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => { aiur_fn_690::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(473, &__args[..])?) { [G::ZERO; OUT_473] } else { let (__hash, __hit) = record.function_queries[473].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[473].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[473].bump_multiplicity(__i); } let __ret: [G; OUT_473] = unsafe { *(record.function_queries[473].output_at(__i).as_ptr() as *const [G; OUT_473]) }; __ret }, _ => { aiur_fn_473::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_51: G = __loaded[0]; let __v_52: G = __loaded[1]; let __v_53: G = __loaded[2]; let __v_54: G = __loaded[3]; let __v_55: G = __loaded[4]; let __v_56: G = __loaded[5]; let __v_57: G = __loaded[6]; let __v_58: G = __loaded[7]; let __v_59: G = __loaded[8]; let __v_60: G = __loaded[9]; let __v_61: G = __loaded[10]; let __v_62: G = __loaded[11]; let __v_63: G = __loaded[12]; let __v_64: G = __loaded[13]; let __v_65: G = __loaded[14]; let __v_66: G = __loaded[15]; let __v_67: G = __loaded[16]; let __v_68: G = __loaded[17]; let __v_69: G = __loaded[18]; let __v_70: G = __loaded[19]; let __v_71: G = __loaded[20]; let __v_72: G = __loaded[21]; let __v_73: G = __loaded[22]; let __v_74: G = __loaded[23]; let __v_75: G = __loaded[24]; let __v_76: G = __loaded[25]; let __v_77: G = __loaded[26]; let __v_78: G = __loaded[27]; let __v_79: G = __loaded[28]; let __v_80: G = __loaded[29]; let __v_81: G = __loaded[30]; let __v_82: G = __loaded[31]; let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(469, &__args[..])?) { [G::ZERO; OUT_469] } else { let (__hash, __hit) = record.function_queries[469].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[469].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[469].bump_multiplicity(__i); } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => { aiur_fn_469::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_84: G = __loaded[0]; let __v_85: G = __loaded[1]; let __v_86: G = __loaded[2]; let __v_87: G = __loaded[3]; let __v_88: G = __loaded[4]; let __v_89: G = __loaded[5]; let __v_90: G = __loaded[6]; let __v_91: G = __loaded[7]; let __v_92: G = __loaded[8]; let __v_93: G = __loaded[9]; let __v_94: G = __loaded[10]; let __v_95: G = __loaded[11]; let __v_96: G = __loaded[12]; let __v_97: G = __loaded[13]; let __v_98: G = __loaded[14]; let __v_99: G = __loaded[15]; let __v_100: G = __loaded[16]; let __v_101: G = __loaded[17]; let __v_102: G = __loaded[18]; let __v_103: G = __loaded[19]; let __v_104: G = __loaded[20]; let __v_105: G = __loaded[21]; let __v_106: G = __loaded[22]; let __v_107: G = __loaded[23]; let __v_108: G = __loaded[24]; let __v_109: G = __loaded[25]; let __v_110: G = __loaded[26]; let __v_111: G = __loaded[27]; let __v_112: G = __loaded[28]; let __v_113: G = __loaded[29]; let __v_114: G = __loaded[30]; let __v_115: G = __loaded[31]; let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(714, &__args[..])?) { [G::ZERO; OUT_714] } else { let (__hash, __hit) = record.function_queries[714].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[714].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => { aiur_fn_714::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, } }, 4u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(690, &__args[..])?) { [G::ZERO; OUT_690] } else { let (__hash, __hit) = record.function_queries[690].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[690].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => { aiur_fn_690::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(473, &__args[..])?) { [G::ZERO; OUT_473] } else { let (__hash, __hit) = record.function_queries[473].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[473].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[473].bump_multiplicity(__i); } let __ret: [G; OUT_473] = unsafe { *(record.function_queries[473].output_at(__i).as_ptr() as *const [G; OUT_473]) }; __ret }, _ => { aiur_fn_473::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_51: G = __loaded[0]; let __v_52: G = __loaded[1]; let __v_53: G = __loaded[2]; let __v_54: G = __loaded[3]; let __v_55: G = __loaded[4]; let __v_56: G = __loaded[5]; let __v_57: G = __loaded[6]; let __v_58: G = __loaded[7]; let __v_59: G = __loaded[8]; let __v_60: G = __loaded[9]; let __v_61: G = __loaded[10]; let __v_62: G = __loaded[11]; let __v_63: G = __loaded[12]; let __v_64: G = __loaded[13]; let __v_65: G = __loaded[14]; let __v_66: G = __loaded[15]; let __v_67: G = __loaded[16]; let __v_68: G = __loaded[17]; let __v_69: G = __loaded[18]; let __v_70: G = __loaded[19]; let __v_71: G = __loaded[20]; let __v_72: G = __loaded[21]; let __v_73: G = __loaded[22]; let __v_74: G = __loaded[23]; let __v_75: G = __loaded[24]; let __v_76: G = __loaded[25]; let __v_77: G = __loaded[26]; let __v_78: G = __loaded[27]; let __v_79: G = __loaded[28]; let __v_80: G = __loaded[29]; let __v_81: G = __loaded[30]; let __v_82: G = __loaded[31]; let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(469, &__args[..])?) { [G::ZERO; OUT_469] } else { let (__hash, __hit) = record.function_queries[469].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[469].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[469].bump_multiplicity(__i); } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => { aiur_fn_469::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; 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: 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_84: G = __loaded[0]; let __v_85: G = __loaded[1]; let __v_86: G = __loaded[2]; let __v_87: G = __loaded[3]; let __v_88: G = __loaded[4]; let __v_89: G = __loaded[5]; let __v_90: G = __loaded[6]; let __v_91: G = __loaded[7]; let __v_92: G = __loaded[8]; let __v_93: G = __loaded[9]; let __v_94: G = __loaded[10]; let __v_95: G = __loaded[11]; let __v_96: G = __loaded[12]; let __v_97: G = __loaded[13]; let __v_98: G = __loaded[14]; let __v_99: G = __loaded[15]; let __v_100: G = __loaded[16]; let __v_101: G = __loaded[17]; let __v_102: G = __loaded[18]; let __v_103: G = __loaded[19]; let __v_104: G = __loaded[20]; let __v_105: G = __loaded[21]; let __v_106: G = __loaded[22]; let __v_107: G = __loaded[23]; let __v_108: G = __loaded[24]; let __v_109: G = __loaded[25]; let __v_110: G = __loaded[26]; let __v_111: G = __loaded[27]; let __v_112: G = __loaded[28]; let __v_113: G = __loaded[29]; let __v_114: G = __loaded[30]; let __v_115: G = __loaded[31]; let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(714, &__args[..])?) { [G::ZERO; OUT_714] } else { let (__hash, __hit) = record.function_queries[714].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[714].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => { aiur_fn_714::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, } }, 5u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(690, &__args[..])?) { [G::ZERO; OUT_690] } else { let (__hash, __hit) = record.function_queries[690].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[690].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => { aiur_fn_690::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(473, &__args[..])?) { [G::ZERO; OUT_473] } else { let (__hash, __hit) = record.function_queries[473].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[473].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[473].bump_multiplicity(__i); } let __ret: [G; OUT_473] = unsafe { *(record.function_queries[473].output_at(__i).as_ptr() as *const [G; OUT_473]) }; __ret }, _ => { aiur_fn_473::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_51: G = __loaded[0]; let __v_52: G = __loaded[1]; let __v_53: G = __loaded[2]; let __v_54: G = __loaded[3]; let __v_55: G = __loaded[4]; let __v_56: G = __loaded[5]; let __v_57: G = __loaded[6]; let __v_58: G = __loaded[7]; let __v_59: G = __loaded[8]; let __v_60: G = __loaded[9]; let __v_61: G = __loaded[10]; let __v_62: G = __loaded[11]; let __v_63: G = __loaded[12]; let __v_64: G = __loaded[13]; let __v_65: G = __loaded[14]; let __v_66: G = __loaded[15]; let __v_67: G = __loaded[16]; let __v_68: G = __loaded[17]; let __v_69: G = __loaded[18]; let __v_70: G = __loaded[19]; let __v_71: G = __loaded[20]; let __v_72: G = __loaded[21]; let __v_73: G = __loaded[22]; let __v_74: G = __loaded[23]; let __v_75: G = __loaded[24]; let __v_76: G = __loaded[25]; let __v_77: G = __loaded[26]; let __v_78: G = __loaded[27]; let __v_79: G = __loaded[28]; let __v_80: G = __loaded[29]; let __v_81: G = __loaded[30]; let __v_82: G = __loaded[31]; let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(469, &__args[..])?) { [G::ZERO; OUT_469] } else { let (__hash, __hit) = record.function_queries[469].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[469].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[469].bump_multiplicity(__i); } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => { aiur_fn_469::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_84: G = __loaded[0]; let __v_85: G = __loaded[1]; let __v_86: G = __loaded[2]; let __v_87: G = __loaded[3]; let __v_88: G = __loaded[4]; let __v_89: G = __loaded[5]; let __v_90: G = __loaded[6]; let __v_91: G = __loaded[7]; let __v_92: G = __loaded[8]; let __v_93: G = __loaded[9]; let __v_94: G = __loaded[10]; let __v_95: G = __loaded[11]; let __v_96: G = __loaded[12]; let __v_97: G = __loaded[13]; let __v_98: G = __loaded[14]; let __v_99: G = __loaded[15]; let __v_100: G = __loaded[16]; let __v_101: G = __loaded[17]; let __v_102: G = __loaded[18]; let __v_103: G = __loaded[19]; let __v_104: G = __loaded[20]; let __v_105: G = __loaded[21]; let __v_106: G = __loaded[22]; let __v_107: G = __loaded[23]; let __v_108: G = __loaded[24]; let __v_109: G = __loaded[25]; let __v_110: G = __loaded[26]; let __v_111: G = __loaded[27]; let __v_112: G = __loaded[28]; let __v_113: G = __loaded[29]; let __v_114: G = __loaded[30]; let __v_115: G = __loaded[31]; let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(714, &__args[..])?) { [G::ZERO; OUT_714] } else { let (__hash, __hit) = record.function_queries[714].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[714].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => { aiur_fn_714::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, } }, _ => { let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(690, &__args[..])?) { [G::ZERO; OUT_690] } else { let (__hash, __hit) = record.function_queries[690].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[690].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => { aiur_fn_690::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, } }; let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(696, &__args[..])?) { [G::ZERO; OUT_696] } else { let (__hash, __hit) = record.function_queries[696].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[696].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[696].bump_multiplicity(__i); } let __ret: [G; OUT_696] = unsafe { *(record.function_queries[696].output_at(__i).as_ptr() as *const [G; OUT_696]) }; __ret }, _ => { aiur_fn_696::(__args, __hash, record, io_buffer)? }, } } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_0, __v_48, __v_50, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(716, &__args[..])?) { [G::ZERO; OUT_716] } else { let (__hash, __hit) = record.function_queries[716].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[716].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[716].bump_multiplicity(__i); } let __ret: [G; OUT_716] = unsafe { *(record.function_queries[716].output_at(__i).as_ptr() as *const [G; OUT_716]) }; __ret }, _ => { aiur_fn_716::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_715] = []; record.function_queries[715].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_716: usize = 4; -const IN_716: usize = 4; -const OUT_716: usize = 0; -fn aiur_fn_716(inp: [G; IN_716], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_716], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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 __ret: [G; OUT_716] = []; record.function_queries[716].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(697, &__args[..])?) { [G::ZERO; OUT_697] } else { let (__hash, __hit) = record.function_queries[697].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[697].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[697].bump_multiplicity(__i); } let __ret: [G; OUT_697] = unsafe { *(record.function_queries[697].output_at(__i).as_ptr() as *const [G; OUT_697]) }; __ret }, _ => { aiur_fn_697::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_7.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(508, &__args[..])?) { [G::ZERO; OUT_508] } else { let (__hash, __hit) = record.function_queries[508].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[508].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[508].bump_multiplicity(__i); } let __ret: [G; OUT_508] = unsafe { *(record.function_queries[508].output_at(__i).as_ptr() as *const [G; OUT_508]) }; __ret }, _ => { aiur_fn_508::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(487, &__args[..])?) { [G::ZERO; OUT_487] } else { let (__hash, __hit) = record.function_queries[487].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[487].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => { aiur_fn_487::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(486, &__args[..])?) { [G::ZERO; OUT_486] } else { let (__hash, __hit) = record.function_queries[486].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[486].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[486].bump_multiplicity(__i); } let __ret: [G; OUT_486] = unsafe { *(record.function_queries[486].output_at(__i).as_ptr() as *const [G; OUT_486]) }; __ret }, _ => { aiur_fn_486::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = __v_9 - __v_0; match __v_10.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(473, &__args[..])?) { [G::ZERO; OUT_473] } else { let (__hash, __hit) = record.function_queries[473].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[473].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[473].bump_multiplicity(__i); } let __ret: [G; OUT_473] = unsafe { *(record.function_queries[473].output_at(__i).as_ptr() as *const [G; OUT_473]) }; __ret }, _ => { aiur_fn_473::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __idx = usize::try_from(__ptr_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_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; let __v_16: G = __loaded[4]; let __v_17: G = __loaded[5]; let __v_18: G = __loaded[6]; let __v_19: G = __loaded[7]; let __v_20: G = __loaded[8]; let __v_21: G = __loaded[9]; let __v_22: G = __loaded[10]; let __v_23: G = __loaded[11]; let __v_24: G = __loaded[12]; let __v_25: G = __loaded[13]; let __v_26: G = __loaded[14]; let __v_27: G = __loaded[15]; let __v_28: G = __loaded[16]; let __v_29: G = __loaded[17]; let __v_30: G = __loaded[18]; let __v_31: G = __loaded[19]; let __v_32: G = __loaded[20]; let __v_33: G = __loaded[21]; let __v_34: G = __loaded[22]; let __v_35: G = __loaded[23]; let __v_36: G = __loaded[24]; let __v_37: G = __loaded[25]; let __v_38: G = __loaded[26]; let __v_39: G = __loaded[27]; let __v_40: G = __loaded[28]; let __v_41: G = __loaded[29]; let __v_42: G = __loaded[30]; let __v_43: G = __loaded[31]; let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(469, &__args[..])?) { [G::ZERO; OUT_469] } else { let (__hash, __hit) = record.function_queries[469].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[469].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[469].bump_multiplicity(__i); } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => { aiur_fn_469::(__args, __hash, record, io_buffer)? }, } } }; let __v_44: G = __r_arr[0]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; 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: 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_45: G = __loaded[0]; let __v_46: G = __loaded[1]; let __v_47: G = __loaded[2]; let __v_48: G = __loaded[3]; let __v_49: G = __loaded[4]; let __v_50: G = __loaded[5]; let __v_51: G = __loaded[6]; let __v_52: G = __loaded[7]; let __v_53: G = __loaded[8]; let __v_54: G = __loaded[9]; let __v_55: G = __loaded[10]; let __v_56: G = __loaded[11]; let __v_57: G = __loaded[12]; let __v_58: G = __loaded[13]; let __v_59: G = __loaded[14]; let __v_60: G = __loaded[15]; let __v_61: G = __loaded[16]; let __v_62: G = __loaded[17]; let __v_63: G = __loaded[18]; let __v_64: G = __loaded[19]; let __v_65: G = __loaded[20]; let __v_66: G = __loaded[21]; let __v_67: G = __loaded[22]; let __v_68: G = __loaded[23]; let __v_69: G = __loaded[24]; let __v_70: G = __loaded[25]; let __v_71: G = __loaded[26]; let __v_72: G = __loaded[27]; let __v_73: G = __loaded[28]; let __v_74: G = __loaded[29]; let __v_75: G = __loaded[30]; let __v_76: G = __loaded[31]; let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __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]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(714, &__args[..])?) { [G::ZERO; OUT_714] } else { let (__hash, __hit) = record.function_queries[714].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[714].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => { aiur_fn_714::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, _ => { let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_9, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(698, &__args[..])?) { [G::ZERO; OUT_698] } else { let (__hash, __hit) = record.function_queries[698].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[698].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => { aiur_fn_698::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, } }, _ => { break '__mc_0 []; }, } }, _ => { break '__mc_0 []; }, } }; let __v_8: G = G::from_u64(1); let __v_9: G = __v_3 + __v_8; let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_0, __v_6, __v_2, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(716, &__args[..])?) { [G::ZERO; OUT_716] } else { let (__hash, __hit) = record.function_queries[716].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[716].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[716].bump_multiplicity(__i); } let __ret: [G; OUT_716] = unsafe { *(record.function_queries[716].output_at(__i).as_ptr() as *const [G; OUT_716]) }; __ret }, _ => { aiur_fn_716::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_716] = []; record.function_queries[716].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_717: usize = 1; -const IN_717: usize = 1; -const OUT_717: usize = 3; -fn aiur_fn_717(inp: [G; IN_717], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_717], ExecError> { stacker::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_83] = { let __args: [G; IN_83] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_717] = [__v_3, __v_3, __v_2]; record.function_queries[717].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); let __ret: [G; OUT_717] = [__v_5, __v_3, __v_4]; record.function_queries[717].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_718: usize = 1; -const IN_718: usize = 1; -const OUT_718: usize = 4; -fn aiur_fn_718(inp: [G; IN_718], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_718], ExecError> { stacker::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_102] = { let __args: [G; IN_102] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = G::from_u64(109); let __v_4: G = G::from_u64(2); let __v_5: G = G::from_u64(21); let __v_6: G = G::from_u64(62); let __v_7: G = G::from_u64(163); let __v_8: G = G::from_u64(17); let __v_9: G = G::from_u64(243); let __v_10: G = G::from_u64(239); let __v_11: G = G::from_u64(209); let __v_12: G = G::from_u64(119); let __v_13: G = G::from_u64(140); let __v_14: G = G::from_u64(73); let __v_15: G = G::from_u64(178); let __v_16: G = G::from_u64(238); let __v_17: G = G::from_u64(95); let __v_18: G = G::from_u64(49); let __v_19: G = G::from_u64(231); let __v_20: G = G::from_u64(154); let __v_21: G = G::from_u64(11); let __v_22: G = G::from_u64(174); let __v_23: G = G::from_u64(149); let __v_24: G = G::from_u64(229); let __v_25: G = G::from_u64(51); let __v_26: G = G::from_u64(160); let __v_27: G = G::from_u64(141); let __v_28: G = G::from_u64(20); let __v_29: G = G::from_u64(252); let __v_30: G = G::from_u64(5); let __v_31: G = G::from_u64(87); let __v_32: G = G::from_u64(45); let __v_33: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_14, __v_28, __v_29, __v_30, __v_31, __v_32, __v_25]; let __mq = record.memory_queries.get_index_mut(12).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_2] = { let __args: [G; IN_2] = [__v_1, __v_33]; 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_34: G = __r_arr[0]; let __v_35: G = G::from_u64(1); if (__v_34 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("claim: specification digest is not this circuit's".to_string()) }); } let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_2]; 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_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(717, &__args[..])?) { [G::ZERO; OUT_717] } else { let (__hash, __hit) = record.function_queries[717].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[717].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[717].bump_multiplicity(__i); } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => { aiur_fn_717::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __ret: [G; OUT_718] = [__v_36, __v_38, __v_39, __v_40]; record.function_queries[718].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_719: usize = 2; -const IN_719: usize = 2; -const OUT_719: usize = 10; -fn aiur_fn_719(inp: [G; IN_719], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_719], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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 __ret: [G; OUT_719] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_1]; record.function_queries[719].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_1]; 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 = G::from_u64(0); let __ret: [G; OUT_719] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; record.function_queries[719].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_720: usize = 2; -const IN_720: usize = 2; -const OUT_720: usize = 3; -fn aiur_fn_720(inp: [G; IN_720], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_720], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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 __ret: [G; OUT_720] = [__v_2, __v_2, __v_1]; record.function_queries[720].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); let __ret: [G; OUT_720] = [__v_4, __v_2, __v_3]; record.function_queries[720].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_721: usize = 2; -const IN_721: usize = 2; -const OUT_721: usize = 3; -fn aiur_fn_721(inp: [G; IN_721], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_721], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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 __ret: [G; OUT_721] = [__v_2, __v_2, __v_1]; record.function_queries[721].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); let __ret: [G; OUT_721] = [__v_4, __v_2, __v_3]; record.function_queries[721].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_722: usize = 2; -const IN_722: usize = 2; -const OUT_722: usize = 3; -fn aiur_fn_722(inp: [G; IN_722], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_722], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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 __ret: [G; OUT_722] = [__v_2, __v_2, __v_1]; record.function_queries[722].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_722] = [__v_4, __v_4, __v_3]; record.function_queries[722].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 __ret: [G; OUT_722] = [__v_4, __v_5, __v_3]; record.function_queries[722].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(2); let __ret: [G; OUT_722] = [__v_4, __v_5, __v_3]; record.function_queries[722].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_723: usize = 2; -const IN_723: usize = 2; -const OUT_723: usize = 3; -fn aiur_fn_723(inp: [G; IN_723], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_723], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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 __ret: [G; OUT_723] = [__v_2, __v_2, __v_1]; record.function_queries[723].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_723] = [__v_4, __v_4, __v_3]; record.function_queries[723].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 __ret: [G; OUT_723] = [__v_4, __v_5, __v_3]; record.function_queries[723].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(2); let __ret: [G; OUT_723] = [__v_4, __v_5, __v_3]; record.function_queries[723].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(3); let __ret: [G; OUT_723] = [__v_4, __v_5, __v_3]; record.function_queries[723].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_724: usize = 9; -const IN_724: usize = 9; -const OUT_724: usize = 2; -fn aiur_fn_724(inp: [G; IN_724], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_724], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 19] = [__v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(11).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(19))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 19)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_724] = [__v_11, __v_0]; record.function_queries[724].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __v_19: G = __r_arr[9]; let __v_20: G = __r_arr[10]; let __v_21: G = __r_arr[11]; let __v_22: G = __r_arr[12]; let __v_23: G = __r_arr[13]; let __v_24: G = __r_arr[14]; let __v_25: G = __r_arr[15]; let __v_26: G = __r_arr[16]; let __v_27: G = __r_arr[17]; let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(17, &__args[..])?) { [G::ZERO; OUT_17] } else { let (__hash, __hit) = record.function_queries[17].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[17].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => { aiur_fn_17::(__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 __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(724, &__args[..])?) { [G::ZERO; OUT_724] } else { let (__hash, __hit) = record.function_queries[724].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[724].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[724].bump_multiplicity(__i); } let __ret: [G; OUT_724] = unsafe { *(record.function_queries[724].output_at(__i).as_ptr() as *const [G; OUT_724]) }; __ret }, _ => { aiur_fn_724::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 19] = [__v_38, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_36]; let __mq = record.memory_queries.get_index_mut(11).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(19))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 19)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_724] = [__v_39, __v_37]; record.function_queries[724].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_725: usize = 2; -const IN_725: usize = 2; -const OUT_725: usize = 3; -fn aiur_fn_725(inp: [G; IN_725], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_725], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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 __ret: [G; OUT_725] = [__v_2, __v_2, __v_1]; record.function_queries[725].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_1]; 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 __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(724, &__args[..])?) { [G::ZERO; OUT_724] } else { let (__hash, __hit) = record.function_queries[724].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[724].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[724].bump_multiplicity(__i); } let __ret: [G; OUT_724] = unsafe { *(record.function_queries[724].output_at(__i).as_ptr() as *const [G; OUT_724]) }; __ret }, _ => { aiur_fn_724::(__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 __ret: [G; OUT_725] = [__v_13, __v_11, __v_12]; record.function_queries[725].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_726: usize = 1; -const IN_726: usize = 1; -const OUT_726: usize = 41; -fn aiur_fn_726(inp: [G; IN_726], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_726], ExecError> { stacker::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 __b1_out: [G; 8] = if unconstrained { let __v: Vec = aiur::execute::CodegenBytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { aiur::execute::bytes1_bit_decompose_value(__v_1, record) }; let __v_10: G = __b1_out[0]; let __v_11: G = __b1_out[1]; let __v_12: G = __b1_out[2]; let __v_13: G = __b1_out[3]; let __v_14: G = __b1_out[4]; let __v_15: G = __b1_out[5]; let __v_16: G = __b1_out[6]; let __v_17: G = __b1_out[7]; let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_10, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(721, &__args[..])?) { [G::ZERO; OUT_721] } else { let (__hash, __hit) = record.function_queries[721].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[721].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => { aiur_fn_721::(__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 __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_11, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__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_719] = { let __args: [G; IN_719] = [__v_12, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__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_719] = { let __args: [G; IN_719] = [__v_13, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__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_719] = { let __args: [G; IN_719] = [__v_14, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__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_720] = { let __args: [G; IN_720] = [__v_15, __v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(720, &__args[..])?) { [G::ZERO; OUT_720] } else { let (__hash, __hit) = record.function_queries[720].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[720].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[720].bump_multiplicity(__i); } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => { aiur_fn_720::(__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 __ret: [G; OUT_726] = [__v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_63]; record.function_queries[726].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_727: usize = 1; -const IN_727: usize = 1; -const OUT_727: usize = 49; -fn aiur_fn_727(inp: [G; IN_727], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_727], ExecError> { stacker::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 __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(726, &__args[..])?) { [G::ZERO; OUT_726] } else { let (__hash, __hit) = record.function_queries[726].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[726].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[726].bump_multiplicity(__i); } let __ret: [G; OUT_726] = unsafe { *(record.function_queries[726].output_at(__i).as_ptr() as *const [G; OUT_726]) }; __ret }, _ => { aiur_fn_726::(__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 = __r_arr[9]; let __v_20: G = __r_arr[10]; let __v_21: G = __r_arr[11]; let __v_22: G = __r_arr[12]; let __v_23: G = __r_arr[13]; let __v_24: G = __r_arr[14]; let __v_25: G = __r_arr[15]; let __v_26: G = __r_arr[16]; let __v_27: G = __r_arr[17]; let __v_28: G = __r_arr[18]; let __v_29: G = __r_arr[19]; let __v_30: G = __r_arr[20]; let __v_31: G = __r_arr[21]; let __v_32: G = __r_arr[22]; let __v_33: G = __r_arr[23]; let __v_34: G = __r_arr[24]; let __v_35: G = __r_arr[25]; let __v_36: G = __r_arr[26]; let __v_37: G = __r_arr[27]; let __v_38: G = __r_arr[28]; let __v_39: G = __r_arr[29]; let __v_40: G = __r_arr[30]; let __v_41: G = __r_arr[31]; let __v_42: G = __r_arr[32]; let __v_43: G = __r_arr[33]; let __v_44: G = __r_arr[34]; let __v_45: G = __r_arr[35]; let __v_46: G = __r_arr[36]; let __v_47: G = __r_arr[37]; let __v_48: G = __r_arr[38]; let __v_49: G = __r_arr[39]; let __v_50: G = __r_arr[40]; let __ret: [G; OUT_727] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; record.function_queries[727].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_728: usize = 9; -const IN_728: usize = 9; -const OUT_728: usize = 2; -fn aiur_fn_728(inp: [G; IN_728], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_728], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 50] = [__v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(16).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(50))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 50)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_728] = [__v_11, __v_0]; record.function_queries[728].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(727, &__args[..])?) { [G::ZERO; OUT_727] } else { let (__hash, __hit) = record.function_queries[727].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[727].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[727].bump_multiplicity(__i); } let __ret: [G; OUT_727] = unsafe { *(record.function_queries[727].output_at(__i).as_ptr() as *const [G; OUT_727]) }; __ret }, _ => { aiur_fn_727::(__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 = __r_arr[9]; let __v_20: G = __r_arr[10]; let __v_21: G = __r_arr[11]; let __v_22: G = __r_arr[12]; let __v_23: G = __r_arr[13]; let __v_24: G = __r_arr[14]; let __v_25: G = __r_arr[15]; let __v_26: G = __r_arr[16]; let __v_27: G = __r_arr[17]; let __v_28: G = __r_arr[18]; let __v_29: G = __r_arr[19]; let __v_30: G = __r_arr[20]; let __v_31: G = __r_arr[21]; let __v_32: G = __r_arr[22]; let __v_33: G = __r_arr[23]; let __v_34: G = __r_arr[24]; let __v_35: G = __r_arr[25]; let __v_36: G = __r_arr[26]; let __v_37: G = __r_arr[27]; let __v_38: G = __r_arr[28]; let __v_39: G = __r_arr[29]; let __v_40: G = __r_arr[30]; let __v_41: G = __r_arr[31]; let __v_42: G = __r_arr[32]; let __v_43: G = __r_arr[33]; let __v_44: G = __r_arr[34]; let __v_45: G = __r_arr[35]; let __v_46: G = __r_arr[36]; let __v_47: G = __r_arr[37]; let __v_48: G = __r_arr[38]; let __v_49: G = __r_arr[39]; let __v_50: G = __r_arr[40]; let __v_51: G = __r_arr[41]; let __v_52: G = __r_arr[42]; let __v_53: G = __r_arr[43]; let __v_54: G = __r_arr[44]; let __v_55: G = __r_arr[45]; let __v_56: G = __r_arr[46]; let __v_57: G = __r_arr[47]; let __v_58: G = __r_arr[48]; let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(17, &__args[..])?) { [G::ZERO; OUT_17] } else { let (__hash, __hit) = record.function_queries[17].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[17].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => { aiur_fn_17::(__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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(728, &__args[..])?) { [G::ZERO; OUT_728] } else { let (__hash, __hit) = record.function_queries[728].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[728].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[728].bump_multiplicity(__i); } let __ret: [G; OUT_728] = unsafe { *(record.function_queries[728].output_at(__i).as_ptr() as *const [G; OUT_728]) }; __ret }, _ => { aiur_fn_728::(__args, __hash, record, io_buffer)? }, } } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __v_69: G = G::from_u64(0); let __v_70: G = { let __values: [G; 50] = [__v_69, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_67]; let __mq = record.memory_queries.get_index_mut(16).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(50))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 50)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_728] = [__v_70, __v_68]; record.function_queries[728].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_729: usize = 2; -const IN_729: usize = 2; -const OUT_729: usize = 3; -fn aiur_fn_729(inp: [G; IN_729], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_729], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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 __ret: [G; OUT_729] = [__v_2, __v_2, __v_1]; record.function_queries[729].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_1]; 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(728, &__args[..])?) { [G::ZERO; OUT_728] } else { let (__hash, __hit) = record.function_queries[728].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[728].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[728].bump_multiplicity(__i); } let __ret: [G; OUT_728] = unsafe { *(record.function_queries[728].output_at(__i).as_ptr() as *const [G; OUT_728]) }; __ret }, _ => { aiur_fn_728::(__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 __ret: [G; OUT_729] = [__v_13, __v_11, __v_12]; record.function_queries[729].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_730: usize = 1; -const IN_730: usize = 1; -const OUT_730: usize = 55; -fn aiur_fn_730(inp: [G; IN_730], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_730], ExecError> { stacker::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_83] = { let __args: [G; IN_83] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __b1_out: [G; 8] = 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_12: G = __b1_out[0]; let __v_13: G = __b1_out[1]; let __v_14: G = __b1_out[2]; let __v_15: G = __b1_out[3]; let __v_16: G = __b1_out[4]; let __v_17: G = __b1_out[5]; let __v_18: G = __b1_out[6]; let __v_19: G = __b1_out[7]; let __b1_out: [G; 8] = 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_20: G = __b1_out[0]; let __v_21: G = __b1_out[1]; let __v_22: G = __b1_out[2]; let __v_23: G = __b1_out[3]; let __v_24: G = __b1_out[4]; let __v_25: G = __b1_out[5]; let __v_26: G = __b1_out[6]; let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(722, &__args[..])?) { [G::ZERO; OUT_722] } else { let (__hash, __hit) = record.function_queries[722].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[722].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => { aiur_fn_722::(__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 __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(722, &__args[..])?) { [G::ZERO; OUT_722] } else { let (__hash, __hit) = record.function_queries[722].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[722].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => { aiur_fn_722::(__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 __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_14, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; let __v_37: G = __r_arr[3]; let __v_38: G = __r_arr[4]; let __v_39: G = __r_arr[5]; let __v_40: G = __r_arr[6]; let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_15, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(720, &__args[..])?) { [G::ZERO; OUT_720] } else { let (__hash, __hit) = record.function_queries[720].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[720].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[720].bump_multiplicity(__i); } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => { aiur_fn_720::(__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_720] = { let __args: [G; IN_720] = [__v_16, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(720, &__args[..])?) { [G::ZERO; OUT_720] } else { let (__hash, __hit) = record.function_queries[720].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[720].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[720].bump_multiplicity(__i); } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => { aiur_fn_720::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; let __v_50: G = G::from_u64(0); let __ret: [G; OUT_730] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_49]; record.function_queries[730].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(721, &__args[..])?) { [G::ZERO; OUT_721] } else { let (__hash, __hit) = record.function_queries[721].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[721].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => { aiur_fn_721::(__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 __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_13, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__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_719] = { let __args: [G; IN_719] = [__v_14, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__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_719] = { let __args: [G; IN_719] = [__v_15, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__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_720] = { let __args: [G; IN_720] = [__v_16, __v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(720, &__args[..])?) { [G::ZERO; OUT_720] } else { let (__hash, __hit) = record.function_queries[720].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[720].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[720].bump_multiplicity(__i); } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => { aiur_fn_720::(__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 __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_17, __v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(729, &__args[..])?) { [G::ZERO; OUT_729] } else { let (__hash, __hit) = record.function_queries[729].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[729].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[729].bump_multiplicity(__i); } let __ret: [G; OUT_729] = unsafe { *(record.function_queries[729].output_at(__i).as_ptr() as *const [G; OUT_729]) }; __ret }, _ => { aiur_fn_729::(__args, __hash, record, io_buffer)? }, } } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; let __v_67: G = G::from_u64(1); let __v_68: G = G::from_u64(0); let __ret: [G; OUT_730] = [__v_67, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_64, __v_65, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_66]; record.function_queries[730].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(721, &__args[..])?) { [G::ZERO; OUT_721] } else { let (__hash, __hit) = record.function_queries[721].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[721].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => { aiur_fn_721::(__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 __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(721, &__args[..])?) { [G::ZERO; OUT_721] } else { let (__hash, __hit) = record.function_queries[721].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[721].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => { aiur_fn_721::(__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 __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_14, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; let __v_37: G = __r_arr[3]; let __v_38: G = __r_arr[4]; let __v_39: G = __r_arr[5]; let __v_40: G = __r_arr[6]; let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_15, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__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 __v_47: G = __r_arr[3]; let __v_48: G = __r_arr[4]; let __v_49: G = __r_arr[5]; let __v_50: G = __r_arr[6]; let __v_51: G = __r_arr[7]; let __v_52: G = __r_arr[8]; let __v_53: G = __r_arr[9]; let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_16, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; let __v_57: G = __r_arr[3]; let __v_58: G = __r_arr[4]; let __v_59: G = __r_arr[5]; let __v_60: G = __r_arr[6]; let __v_61: G = __r_arr[7]; let __v_62: G = __r_arr[8]; let __v_63: G = __r_arr[9]; let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_17, __v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__args, __hash, record, io_buffer)? }, } } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; let __v_67: G = __r_arr[3]; let __v_68: G = __r_arr[4]; let __v_69: G = __r_arr[5]; let __v_70: G = __r_arr[6]; let __v_71: G = __r_arr[7]; let __v_72: G = __r_arr[8]; let __v_73: G = __r_arr[9]; let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_18, __v_73]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__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 = __r_arr[5]; let __v_80: G = __r_arr[6]; let __v_81: G = __r_arr[7]; let __v_82: G = __r_arr[8]; let __v_83: G = __r_arr[9]; let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_19, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(720, &__args[..])?) { [G::ZERO; OUT_720] } else { let (__hash, __hit) = record.function_queries[720].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[720].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[720].bump_multiplicity(__i); } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => { aiur_fn_720::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_20, __v_86]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(725, &__args[..])?) { [G::ZERO; OUT_725] } else { let (__hash, __hit) = record.function_queries[725].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[725].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[725].bump_multiplicity(__i); } let __ret: [G; OUT_725] = unsafe { *(record.function_queries[725].output_at(__i).as_ptr() as *const [G; OUT_725]) }; __ret }, _ => { aiur_fn_725::(__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 = G::from_u64(2); let __ret: [G; OUT_730] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; record.function_queries[730].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_731: usize = 1; -const IN_731: usize = 1; -const OUT_731: usize = 63; -fn aiur_fn_731(inp: [G; IN_731], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_731], ExecError> { stacker::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 __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(730, &__args[..])?) { [G::ZERO; OUT_730] } else { let (__hash, __hit) = record.function_queries[730].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[730].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[730].bump_multiplicity(__i); } let __ret: [G; OUT_730] = unsafe { *(record.function_queries[730].output_at(__i).as_ptr() as *const [G; OUT_730]) }; __ret }, _ => { aiur_fn_730::(__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 = __r_arr[9]; let __v_20: G = __r_arr[10]; let __v_21: G = __r_arr[11]; let __v_22: G = __r_arr[12]; let __v_23: G = __r_arr[13]; let __v_24: G = __r_arr[14]; let __v_25: G = __r_arr[15]; let __v_26: G = __r_arr[16]; let __v_27: G = __r_arr[17]; let __v_28: G = __r_arr[18]; let __v_29: G = __r_arr[19]; let __v_30: G = __r_arr[20]; let __v_31: G = __r_arr[21]; let __v_32: G = __r_arr[22]; let __v_33: G = __r_arr[23]; let __v_34: G = __r_arr[24]; let __v_35: G = __r_arr[25]; let __v_36: G = __r_arr[26]; let __v_37: G = __r_arr[27]; let __v_38: G = __r_arr[28]; let __v_39: G = __r_arr[29]; let __v_40: G = __r_arr[30]; let __v_41: G = __r_arr[31]; let __v_42: G = __r_arr[32]; let __v_43: G = __r_arr[33]; let __v_44: G = __r_arr[34]; let __v_45: G = __r_arr[35]; let __v_46: G = __r_arr[36]; let __v_47: G = __r_arr[37]; let __v_48: G = __r_arr[38]; let __v_49: G = __r_arr[39]; let __v_50: G = __r_arr[40]; let __v_51: G = __r_arr[41]; let __v_52: G = __r_arr[42]; let __v_53: G = __r_arr[43]; let __v_54: G = __r_arr[44]; let __v_55: G = __r_arr[45]; let __v_56: G = __r_arr[46]; let __v_57: G = __r_arr[47]; let __v_58: G = __r_arr[48]; let __v_59: G = __r_arr[49]; let __v_60: G = __r_arr[50]; let __v_61: G = __r_arr[51]; let __v_62: G = __r_arr[52]; let __v_63: G = __r_arr[53]; let __v_64: G = __r_arr[54]; let __ret: [G; OUT_731] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; record.function_queries[731].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_732: usize = 9; -const IN_732: usize = 9; -const OUT_732: usize = 2; -fn aiur_fn_732(inp: [G; IN_732], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_732], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 64] = [__v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_index_mut(17).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(64))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 64)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_732] = [__v_11, __v_0]; record.function_queries[732].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(731, &__args[..])?) { [G::ZERO; OUT_731] } else { let (__hash, __hit) = record.function_queries[731].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[731].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[731].bump_multiplicity(__i); } let __ret: [G; OUT_731] = unsafe { *(record.function_queries[731].output_at(__i).as_ptr() as *const [G; OUT_731]) }; __ret }, _ => { aiur_fn_731::(__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 = __r_arr[9]; let __v_20: G = __r_arr[10]; let __v_21: G = __r_arr[11]; let __v_22: G = __r_arr[12]; let __v_23: G = __r_arr[13]; let __v_24: G = __r_arr[14]; let __v_25: G = __r_arr[15]; let __v_26: G = __r_arr[16]; let __v_27: G = __r_arr[17]; let __v_28: G = __r_arr[18]; let __v_29: G = __r_arr[19]; let __v_30: G = __r_arr[20]; let __v_31: G = __r_arr[21]; let __v_32: G = __r_arr[22]; let __v_33: G = __r_arr[23]; let __v_34: G = __r_arr[24]; let __v_35: G = __r_arr[25]; let __v_36: G = __r_arr[26]; let __v_37: G = __r_arr[27]; let __v_38: G = __r_arr[28]; let __v_39: G = __r_arr[29]; let __v_40: G = __r_arr[30]; let __v_41: G = __r_arr[31]; let __v_42: G = __r_arr[32]; let __v_43: G = __r_arr[33]; let __v_44: G = __r_arr[34]; let __v_45: G = __r_arr[35]; let __v_46: G = __r_arr[36]; let __v_47: G = __r_arr[37]; let __v_48: G = __r_arr[38]; let __v_49: G = __r_arr[39]; let __v_50: G = __r_arr[40]; let __v_51: G = __r_arr[41]; let __v_52: G = __r_arr[42]; let __v_53: G = __r_arr[43]; let __v_54: G = __r_arr[44]; let __v_55: G = __r_arr[45]; let __v_56: G = __r_arr[46]; let __v_57: G = __r_arr[47]; let __v_58: G = __r_arr[48]; let __v_59: G = __r_arr[49]; let __v_60: G = __r_arr[50]; let __v_61: G = __r_arr[51]; let __v_62: G = __r_arr[52]; let __v_63: G = __r_arr[53]; let __v_64: G = __r_arr[54]; let __v_65: G = __r_arr[55]; let __v_66: G = __r_arr[56]; let __v_67: G = __r_arr[57]; let __v_68: G = __r_arr[58]; let __v_69: G = __r_arr[59]; let __v_70: G = __r_arr[60]; let __v_71: G = __r_arr[61]; let __v_72: G = __r_arr[62]; let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(17, &__args[..])?) { [G::ZERO; OUT_17] } else { let (__hash, __hit) = record.function_queries[17].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[17].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => { aiur_fn_17::(__args, __hash, record, io_buffer)? }, } } }; let __v_73: G = __r_arr[0]; let __v_74: G = __r_arr[1]; let __v_75: G = __r_arr[2]; let __v_76: G = __r_arr[3]; let __v_77: G = __r_arr[4]; let __v_78: G = __r_arr[5]; let __v_79: G = __r_arr[6]; let __v_80: G = __r_arr[7]; let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(732, &__args[..])?) { [G::ZERO; OUT_732] } else { let (__hash, __hit) = record.function_queries[732].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[732].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => { aiur_fn_732::(__args, __hash, record, io_buffer)? }, } } }; let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = G::from_u64(0); let __v_84: G = { let __values: [G; 64] = [__v_83, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_81]; let __mq = record.memory_queries.get_index_mut(17).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(64))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 64)?; let __ptr = G::from_usize(record.pointer_base + __mq.len()); __mq.insert_hashed(&__values[..], &[__ptr], G::from_bool(!unconstrained), __hash)?; __ptr }, } }; let __ret: [G; OUT_732] = [__v_84, __v_82]; record.function_queries[732].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_733: usize = 1; -const IN_733: usize = 1; -const OUT_733: usize = 55; -fn aiur_fn_733(inp: [G; IN_733], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_733], ExecError> { stacker::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_83] = { let __args: [G; IN_83] = [__v_0]; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __b1_out: [G; 8] = 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_12: G = __b1_out[0]; let __v_13: G = __b1_out[1]; let __v_14: G = __b1_out[2]; let __v_15: G = __b1_out[3]; let __v_16: G = __b1_out[4]; let __v_17: G = __b1_out[5]; let __v_18: G = __b1_out[6]; let __v_19: G = __b1_out[7]; let __b1_out: [G; 8] = 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_20: G = __b1_out[0]; let __v_21: G = __b1_out[1]; let __v_22: G = __b1_out[2]; let __v_23: G = __b1_out[3]; let __v_24: G = __b1_out[4]; let __v_25: G = __b1_out[5]; let __v_26: G = __b1_out[6]; let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(722, &__args[..])?) { [G::ZERO; OUT_722] } else { let (__hash, __hit) = record.function_queries[722].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[722].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => { aiur_fn_722::(__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 __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(722, &__args[..])?) { [G::ZERO; OUT_722] } else { let (__hash, __hit) = record.function_queries[722].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[722].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => { aiur_fn_722::(__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 __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_14, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; let __v_37: G = __r_arr[3]; let __v_38: G = __r_arr[4]; let __v_39: G = __r_arr[5]; let __v_40: G = __r_arr[6]; let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_15, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(720, &__args[..])?) { [G::ZERO; OUT_720] } else { let (__hash, __hit) = record.function_queries[720].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[720].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[720].bump_multiplicity(__i); } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => { aiur_fn_720::(__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_720] = { let __args: [G; IN_720] = [__v_16, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(720, &__args[..])?) { [G::ZERO; OUT_720] } else { let (__hash, __hit) = record.function_queries[720].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[720].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[720].bump_multiplicity(__i); } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => { aiur_fn_720::(__args, __hash, record, io_buffer)? }, } } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; let __v_50: G = G::from_u64(0); let __ret: [G; OUT_733] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_50, __v_49]; record.function_queries[733].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(721, &__args[..])?) { [G::ZERO; OUT_721] } else { let (__hash, __hit) = record.function_queries[721].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[721].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => { aiur_fn_721::(__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 __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(721, &__args[..])?) { [G::ZERO; OUT_721] } else { let (__hash, __hit) = record.function_queries[721].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[721].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => { aiur_fn_721::(__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 __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_14, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; let __v_37: G = __r_arr[3]; let __v_38: G = __r_arr[4]; let __v_39: G = __r_arr[5]; let __v_40: G = __r_arr[6]; let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_15, __v_43]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__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 __v_47: G = __r_arr[3]; let __v_48: G = __r_arr[4]; let __v_49: G = __r_arr[5]; let __v_50: G = __r_arr[6]; let __v_51: G = __r_arr[7]; let __v_52: G = __r_arr[8]; let __v_53: G = __r_arr[9]; let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_16, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; let __v_57: G = __r_arr[3]; let __v_58: G = __r_arr[4]; let __v_59: G = __r_arr[5]; let __v_60: G = __r_arr[6]; let __v_61: G = __r_arr[7]; let __v_62: G = __r_arr[8]; let __v_63: G = __r_arr[9]; let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_17, __v_63]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__args, __hash, record, io_buffer)? }, } } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; let __v_67: G = __r_arr[3]; let __v_68: G = __r_arr[4]; let __v_69: G = __r_arr[5]; let __v_70: G = __r_arr[6]; let __v_71: G = __r_arr[7]; let __v_72: G = __r_arr[8]; let __v_73: G = __r_arr[9]; let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_18, __v_73]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__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 = __r_arr[5]; let __v_80: G = __r_arr[6]; let __v_81: G = __r_arr[7]; let __v_82: G = __r_arr[8]; let __v_83: G = __r_arr[9]; let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_19, __v_83]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(720, &__args[..])?) { [G::ZERO; OUT_720] } else { let (__hash, __hit) = record.function_queries[720].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[720].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[720].bump_multiplicity(__i); } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => { aiur_fn_720::(__args, __hash, record, io_buffer)? }, } } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_20, __v_86]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(725, &__args[..])?) { [G::ZERO; OUT_725] } else { let (__hash, __hit) = record.function_queries[725].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[725].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[725].bump_multiplicity(__i); } let __ret: [G; OUT_725] = unsafe { *(record.function_queries[725].output_at(__i).as_ptr() as *const [G; OUT_725]) }; __ret }, _ => { aiur_fn_725::(__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 = G::from_u64(1); let __ret: [G; OUT_733] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; record.function_queries[733].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(721, &__args[..])?) { [G::ZERO; OUT_721] } else { let (__hash, __hit) = record.function_queries[721].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[721].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => { aiur_fn_721::(__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 __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_13, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__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_720] = { let __args: [G; IN_720] = [__v_14, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(720, &__args[..])?) { [G::ZERO; OUT_720] } else { let (__hash, __hit) = record.function_queries[720].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[720].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[720].bump_multiplicity(__i); } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => { aiur_fn_720::(__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 = G::from_u64(2); let __v_45: G = G::from_u64(0); let __ret: [G; OUT_733] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; record.function_queries[733].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(723, &__args[..])?) { [G::ZERO; OUT_723] } else { let (__hash, __hit) = record.function_queries[723].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[723].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[723].bump_multiplicity(__i); } let __ret: [G; OUT_723] = unsafe { *(record.function_queries[723].output_at(__i).as_ptr() as *const [G; OUT_723]) }; __ret }, _ => { aiur_fn_723::(__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 __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_13, __v_30]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__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_720] = { let __args: [G; IN_720] = [__v_14, __v_40]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(720, &__args[..])?) { [G::ZERO; OUT_720] } else { let (__hash, __hit) = record.function_queries[720].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[720].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[720].bump_multiplicity(__i); } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => { aiur_fn_720::(__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 = G::from_u64(3); let __v_45: G = G::from_u64(0); let __ret: [G; OUT_733] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; record.function_queries[733].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__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 __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_13, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = __r_arr[3]; let __v_42: G = __r_arr[4]; let __v_43: G = __r_arr[5]; let __v_44: G = __r_arr[6]; let __v_45: G = __r_arr[7]; let __v_46: G = __r_arr[8]; let __v_47: G = __r_arr[9]; let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_14, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(720, &__args[..])?) { [G::ZERO; OUT_720] } else { let (__hash, __hit) = record.function_queries[720].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[720].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[720].bump_multiplicity(__i); } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => { aiur_fn_720::(__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 = G::from_u64(4); let __v_52: G = G::from_u64(0); let __ret: [G; OUT_733] = [__v_51, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_48, __v_49, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_50]; record.function_queries[733].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__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 __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(720, &__args[..])?) { [G::ZERO; OUT_720] } else { let (__hash, __hit) = record.function_queries[720].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[720].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[720].bump_multiplicity(__i); } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => { aiur_fn_720::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(5); let __v_42: G = G::from_u64(0); let __ret: [G; OUT_733] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; record.function_queries[733].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__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 __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(720, &__args[..])?) { [G::ZERO; OUT_720] } else { let (__hash, __hit) = record.function_queries[720].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[720].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[720].bump_multiplicity(__i); } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => { aiur_fn_720::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(6); let __v_42: G = G::from_u64(0); let __ret: [G; OUT_733] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; record.function_queries[733].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(719, &__args[..])?) { [G::ZERO; OUT_719] } else { let (__hash, __hit) = record.function_queries[719].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[719].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => { aiur_fn_719::(__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 __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(720, &__args[..])?) { [G::ZERO; OUT_720] } else { let (__hash, __hit) = record.function_queries[720].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[720].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[720].bump_multiplicity(__i); } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => { aiur_fn_720::(__args, __hash, record, io_buffer)? }, } } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(7); let __v_42: G = G::from_u64(0); let __ret: [G; OUT_733] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; record.function_queries[733].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_12.as_canonical_u64() { 0u64 => { let __v_28: G = G::from_u64(1); let __v_29: G = { let __values: [G; 64] = [__v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; let __mq = record.memory_queries.get_index_mut(17).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(64))?; let (__hash, __hit) = __mq.lookup(&__values[..]); match __hit { Some(__i) => { if (!unconstrained) { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] }, _ => { aiur::execute::check_store(&record.budget, __mq, 64)?; 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_29, __v_11]; }, 1u64 => { 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(732, &__args[..])?) { [G::ZERO; OUT_732] } else { let (__hash, __hit) = record.function_queries[732].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[732].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => { aiur_fn_732::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; break '__mc_0 [__v_37, __v_38]; }, _ => { return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }; let __v_28: G = __mc_out___mc_0[0]; let __v_29: G = __mc_out___mc_0[1]; let __v_30: G = G::from_u64(8); let __v_31: G = G::from_u64(0); let __ret: [G; OUT_733] = [__v_30, __v_28, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_29]; record.function_queries[733].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_734: usize = 1; -const IN_734: usize = 1; -const OUT_734: usize = 1; -fn aiur_fn_734(inp: [G; IN_734], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_734], ExecError> { stacker::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; 18] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(10).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = G::from_u64(1); let __v_20: G = { let __values: [G; 3] = [__v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_index_mut(1).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_38] = { let __args: [G; IN_38] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20]; let __cu = unconstrained; if ((!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_21: G = __r_arr[0]; let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(23, &__args[..])?) { [G::ZERO; OUT_23] } else { let (__hash, __hit) = record.function_queries[23].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[23].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[23].bump_multiplicity(__i); } let __ret: [G; OUT_23] = unsafe { *(record.function_queries[23].output_at(__i).as_ptr() as *const [G; OUT_23]) }; __ret }, _ => { aiur_fn_23::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_734] = [__v_22]; record.function_queries[734].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_735: usize = 1; -const IN_735: usize = 1; -const OUT_735: usize = 1; -fn aiur_fn_735(inp: [G; IN_735], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_735], ExecError> { 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(0); let __ret: [G; OUT_735] = [__v_1]; record.function_queries[735].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_735] = [__v_1]; record.function_queries[735].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_735] = [__v_1]; record.function_queries[735].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_736: usize = 3; -const IN_736: usize = 3; -const OUT_736: usize = 0; -fn aiur_fn_736(inp: [G; IN_736], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_736], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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() { 1u64 => { let __ret: [G; OUT_736] = []; record.function_queries[736].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(735, &__args[..])?) { [G::ZERO; OUT_735] } else { let (__hash, __hit) = record.function_queries[735].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[735].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[735].bump_multiplicity(__i); } let __ret: [G; OUT_735] = unsafe { *(record.function_queries[735].output_at(__i).as_ptr() as *const [G; OUT_735]) }; __ret }, _ => { aiur_fn_735::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(735, &__args[..])?) { [G::ZERO; OUT_735] } else { let (__hash, __hit) = record.function_queries[735].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[735].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[735].bump_multiplicity(__i); } let __ret: [G; OUT_735] = unsafe { *(record.function_queries[735].output_at(__i).as_ptr() as *const [G; OUT_735]) }; __ret }, _ => { aiur_fn_735::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed definition kind != real".to_string()) }); } let __ret: [G; OUT_736] = []; record.function_queries[736].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_737: usize = 3; -const IN_737: usize = 3; -const OUT_737: usize = 0; -fn aiur_fn_737(inp: [G; IN_737], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_737], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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() { 1u64 => { let __ret: [G; OUT_737] = []; record.function_queries[737].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(735, &__args[..])?) { [G::ZERO; OUT_735] } else { let (__hash, __hit) = record.function_queries[735].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[735].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[735].bump_multiplicity(__i); } let __ret: [G; OUT_735] = unsafe { *(record.function_queries[735].output_at(__i).as_ptr() as *const [G; OUT_735]) }; __ret }, _ => { aiur_fn_735::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(735, &__args[..])?) { [G::ZERO; OUT_735] } else { let (__hash, __hit) = record.function_queries[735].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[735].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[735].bump_multiplicity(__i); } let __ret: [G; OUT_735] = unsafe { *(record.function_queries[735].output_at(__i).as_ptr() as *const [G; OUT_735]) }; __ret }, _ => { aiur_fn_735::(__args, __hash, record, io_buffer)? }, } } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed definition safety != real".to_string()) }); } let __ret: [G; OUT_737] = []; record.function_queries[737].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_738: usize = 3; -const IN_738: usize = 3; -const OUT_738: usize = 0; -fn aiur_fn_738(inp: [G; IN_738], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_738], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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() { 1u64 => { let __ret: [G; OUT_738] = []; record.function_queries[738].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__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_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed quotient kind != real".to_string()) }); } let __ret: [G; OUT_738] = []; record.function_queries[738].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_739: usize = 3; -const IN_739: usize = 3; -const OUT_739: usize = 0; -fn aiur_fn_739(inp: [G; IN_739], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_739], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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() { 1u64 => { let __ret: [G; OUT_739] = []; record.function_queries[739].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { if (__v_0 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Reveal: claimed flag != real".to_string()) }); } let __ret: [G; OUT_739] = []; record.function_queries[739].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_740: usize = 17; -const IN_740: usize = 17; -const OUT_740: usize = 0; -fn aiur_fn_740(inp: [G; IN_740], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_740], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_740] = []; record.function_queries[740].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { if (__v_0 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) }); } if (__v_1 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) }); } if (__v_2 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) }); } if (__v_3 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) }); } if (__v_4 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) }); } if (__v_5 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) }); } if (__v_6 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) }); } if (__v_7 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) }); } let __ret: [G; OUT_740] = []; record.function_queries[740].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } -const INPUT_SIZE_741: usize = 3; -const IN_741: usize = 3; -const OUT_741: usize = 0; -fn aiur_fn_741(inp: [G; IN_741], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_741], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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() { 1u64 => { let __ret: [G; OUT_741] = []; record.function_queries[741].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(12).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_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; let __v_7: G = __loaded[4]; let __v_8: G = __loaded[5]; let __v_9: G = __loaded[6]; let __v_10: G = __loaded[7]; let __v_11: G = __loaded[8]; let __v_12: G = __loaded[9]; let __v_13: G = __loaded[10]; let __v_14: G = __loaded[11]; let __v_15: G = __loaded[12]; let __v_16: G = __loaded[13]; let __v_17: G = __loaded[14]; let __v_18: G = __loaded[15]; let __v_19: G = __loaded[16]; let __v_20: G = __loaded[17]; let __v_21: G = __loaded[18]; let __v_22: G = __loaded[19]; let __v_23: G = __loaded[20]; let __v_24: G = __loaded[21]; let __v_25: G = __loaded[22]; let __v_26: G = __loaded[23]; let __v_27: G = __loaded[24]; let __v_28: G = __loaded[25]; let __v_29: G = __loaded[26]; let __v_30: G = __loaded[27]; let __v_31: G = __loaded[28]; let __v_32: G = __loaded[29]; let __v_33: G = __loaded[30]; let __v_34: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; 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: 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_35: G = __loaded[0]; let __v_36: G = __loaded[1]; let __v_37: G = __loaded[2]; let __v_38: G = __loaded[3]; let __v_39: G = __loaded[4]; let __v_40: G = __loaded[5]; let __v_41: G = __loaded[6]; let __v_42: G = __loaded[7]; let __v_43: G = __loaded[8]; let __v_44: G = __loaded[9]; let __v_45: G = __loaded[10]; let __v_46: G = __loaded[11]; let __v_47: G = __loaded[12]; let __v_48: G = __loaded[13]; let __v_49: G = __loaded[14]; let __v_50: G = __loaded[15]; let __v_51: G = __loaded[16]; let __v_52: G = __loaded[17]; let __v_53: G = __loaded[18]; let __v_54: G = __loaded[19]; let __v_55: G = __loaded[20]; let __v_56: G = __loaded[21]; let __v_57: G = __loaded[22]; let __v_58: G = __loaded[23]; let __v_59: G = __loaded[24]; let __v_60: G = __loaded[25]; let __v_61: G = __loaded[26]; let __v_62: G = __loaded[27]; let __v_63: G = __loaded[28]; let __v_64: G = __loaded[29]; let __v_65: G = __loaded[30]; let __v_66: G = __loaded[31]; if (__v_3 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_4 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_5 != __v_37) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_37.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_6 != __v_38) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_38.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_7 != __v_39) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_39.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_8 != __v_40) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_9 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_10 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_11 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_12 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_13 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_14 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_15 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_16 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_17 != __v_49) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_49.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_18 != __v_50) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_50.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_19 != __v_51) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_20 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_21 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_22 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_23 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_24 != __v_56) { return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_25 != __v_57) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_57.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_26 != __v_58) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_27 != __v_59) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_59.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_28 != __v_60) { return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_29 != __v_61) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_30 != __v_62) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_62.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_31 != __v_63) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_63.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_32 != __v_64) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_64.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_33 != __v_65) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } if (__v_34 != __v_66) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } let __ret: [G; OUT_741] = []; record.function_queries[741].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_742: usize = 3; -const IN_742: usize = 3; -const OUT_742: usize = 0; -fn aiur_fn_742(inp: [G; IN_742], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_742], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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() { 1u64 => { let __ret: [G; OUT_742] = []; record.function_queries[742].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(734, &__args[..])?) { [G::ZERO; OUT_734] } else { let (__hash, __hit) = record.function_queries[734].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[734].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[734].bump_multiplicity(__i); } let __ret: [G; OUT_734] = unsafe { *(record.function_queries[734].output_at(__i).as_ptr() as *const [G; OUT_734]) }; __ret }, _ => { aiur_fn_734::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).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_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; let __v_8: G = __loaded[4]; let __v_9: G = __loaded[5]; let __v_10: G = __loaded[6]; let __v_11: G = __loaded[7]; let __v_12: G = __loaded[8]; let __v_13: G = __loaded[9]; let __v_14: G = __loaded[10]; let __v_15: G = __loaded[11]; let __v_16: G = __loaded[12]; let __v_17: G = __loaded[13]; let __v_18: G = __loaded[14]; let __v_19: G = __loaded[15]; let __v_20: G = __loaded[16]; let __v_21: G = __loaded[17]; let __v_22: G = __loaded[18]; let __v_23: G = __loaded[19]; let __v_24: G = __loaded[20]; let __v_25: G = __loaded[21]; let __v_26: G = __loaded[22]; let __v_27: G = __loaded[23]; let __v_28: G = __loaded[24]; let __v_29: G = __loaded[25]; let __v_30: G = __loaded[26]; let __v_31: G = __loaded[27]; let __v_32: G = __loaded[28]; let __v_33: G = __loaded[29]; let __v_34: G = __loaded[30]; let __v_35: G = __loaded[31]; let __loaded: [G; 32] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(12).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(32))?; 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: 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_36: G = __loaded[0]; let __v_37: G = __loaded[1]; let __v_38: G = __loaded[2]; let __v_39: G = __loaded[3]; let __v_40: G = __loaded[4]; let __v_41: G = __loaded[5]; let __v_42: G = __loaded[6]; let __v_43: G = __loaded[7]; let __v_44: G = __loaded[8]; let __v_45: G = __loaded[9]; let __v_46: G = __loaded[10]; let __v_47: G = __loaded[11]; let __v_48: G = __loaded[12]; let __v_49: G = __loaded[13]; let __v_50: G = __loaded[14]; let __v_51: G = __loaded[15]; let __v_52: G = __loaded[16]; let __v_53: G = __loaded[17]; let __v_54: G = __loaded[18]; let __v_55: G = __loaded[19]; let __v_56: G = __loaded[20]; let __v_57: G = __loaded[21]; let __v_58: G = __loaded[22]; let __v_59: G = __loaded[23]; let __v_60: G = __loaded[24]; let __v_61: G = __loaded[25]; let __v_62: G = __loaded[26]; let __v_63: G = __loaded[27]; let __v_64: G = __loaded[28]; let __v_65: G = __loaded[29]; let __v_66: G = __loaded[30]; let __v_67: G = __loaded[31]; if (__v_4 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_5 != __v_37) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_37.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_6 != __v_38) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_38.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_7 != __v_39) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_39.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_8 != __v_40) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_9 != __v_41) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_10 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_11 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_12 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_13 != __v_45) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_14 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_15 != __v_47) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_16 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_17 != __v_49) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_49.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_18 != __v_50) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_50.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_19 != __v_51) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_20 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_21 != __v_53) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_22 != __v_54) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_23 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_24 != __v_56) { return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_25 != __v_57) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_57.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_26 != __v_58) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_27 != __v_59) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_59.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_28 != __v_60) { return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_29 != __v_61) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_30 != __v_62) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_62.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_31 != __v_63) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_63.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_32 != __v_64) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_64.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_33 != __v_65) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_34 != __v_66) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } if (__v_35 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } let __ret: [G; OUT_742] = []; record.function_queries[742].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_743: usize = 10; -const IN_743: usize = 10; -const OUT_743: usize = 0; -fn aiur_fn_743(inp: [G; IN_743], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_743], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __loaded: [G; 19] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(11).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(19))?; 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: 19 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 19] = __args[..19].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]; match __v_10.as_canonical_u64() { 1u64 => { let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).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_29: G = __loaded[0]; let __v_30: G = __loaded[1]; let __v_31: G = __loaded[2]; let __v_32: G = __loaded[3]; let __v_33: G = __loaded[4]; let __v_34: G = __loaded[5]; let __v_35: G = __loaded[6]; let __v_36: G = __loaded[7]; let __v_37: G = __loaded[8]; let __v_38: G = __loaded[9]; let __v_39: G = __loaded[10]; match __v_29.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_743] = []; record.function_queries[743].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_29.as_canonical_u64())); }, } }, 0u64 => { let __loaded: [G; 11] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(8).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_29: G = __loaded[0]; let __v_30: G = __loaded[1]; let __v_31: G = __loaded[2]; let __v_32: G = __loaded[3]; let __v_33: G = __loaded[4]; let __v_34: G = __loaded[5]; let __v_35: G = __loaded[6]; let __v_36: G = __loaded[7]; let __v_37: G = __loaded[8]; let __v_38: G = __loaded[9]; let __v_39: G = __loaded[10]; match __v_29.as_canonical_u64() { 0u64 => { match __v_11.as_canonical_u64() { _ => { match __v_30.as_canonical_u64() { _ => { if (__v_11 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) }); } if (__v_12 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) }); } if (__v_13 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) }); } if (__v_14 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) }); } if (__v_15 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) }); } if (__v_16 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) }); } if (__v_17 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) }); } if (__v_18 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) }); } if (__v_30 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) }); } if (__v_31 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) }); } if (__v_32 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) }); } if (__v_33 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) }); } if (__v_34 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) }); } if (__v_35 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) }); } if (__v_36 != __v_25) { return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) }); } if (__v_37 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) }); } let __v_40: G = G::from_u64(0); let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_38, __v_40, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(742, &__args[..])?) { [G::ZERO; OUT_742] } else { let (__hash, __hit) = record.function_queries[742].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[742].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => { aiur_fn_742::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(16, &__args[..])?) { [G::ZERO; OUT_16] } else { let (__hash, __hit) = record.function_queries[16].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[16].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => { aiur_fn_16::(__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 __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(743, &__args[..])?) { [G::ZERO; OUT_743] } else { let (__hash, __hit) = record.function_queries[743].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[743].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[743].bump_multiplicity(__i); } let __ret: [G; OUT_743] = unsafe { *(record.function_queries[743].output_at(__i).as_ptr() as *const [G; OUT_743]) }; __ret }, _ => { aiur_fn_743::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_743] = []; record.function_queries[743].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_29.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }) } -const INPUT_SIZE_744: usize = 3; -const IN_744: usize = 3; -const OUT_744: usize = 0; -fn aiur_fn_744(inp: [G; IN_744], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_744], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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() { 1u64 => { let __ret: [G; OUT_744] = []; record.function_queries[744].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_0, __v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(743, &__args[..])?) { [G::ZERO; OUT_743] } else { let (__hash, __hit) = record.function_queries[743].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[743].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[743].bump_multiplicity(__i); } let __ret: [G; OUT_743] = unsafe { *(record.function_queries[743].output_at(__i).as_ptr() as *const [G; OUT_743]) }; __ret }, _ => { aiur_fn_743::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_744] = []; record.function_queries[744].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_745: usize = 49; -const IN_745: usize = 49; -const OUT_745: usize = 0; -fn aiur_fn_745(inp: [G; IN_745], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_745], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__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(772, &__args[..])?) { [G::ZERO; OUT_772] } else { let (__hash, __hit) = record.function_queries[772].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[772].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[772].bump_multiplicity(__i); } let __ret: [G; OUT_772] = unsafe { *(record.function_queries[772].output_at(__i).as_ptr() as *const [G; OUT_772]) }; __ret }, _ => { aiur_fn_772::(__args, __hash, record, io_buffer)? }, } } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; let __v_52: G = __r_arr[3]; let __v_53: G = __r_arr[4]; let __v_54: G = __r_arr[5]; let __v_55: G = __r_arr[6]; let __v_56: G = __r_arr[7]; let __v_57: G = __r_arr[8]; let __v_58: G = __r_arr[9]; let __v_59: G = __r_arr[10]; let __v_60: G = __r_arr[11]; let __v_61: G = __r_arr[12]; let __v_62: G = __r_arr[13]; let __v_63: G = __r_arr[14]; let __v_64: G = __r_arr[15]; let __v_65: G = __r_arr[16]; let __v_66: G = __r_arr[17]; let __v_67: G = __r_arr[18]; let __v_68: G = __r_arr[19]; let __v_69: G = __r_arr[20]; let __v_70: G = __r_arr[21]; let __v_71: G = __r_arr[22]; let __v_72: G = __r_arr[23]; let __v_73: G = __r_arr[24]; let __v_74: G = __r_arr[25]; let __v_75: G = __r_arr[26]; let __v_76: G = __r_arr[27]; let __v_77: G = __r_arr[28]; let __v_78: G = __r_arr[29]; let __v_79: G = __r_arr[30]; let __v_80: G = __r_arr[31]; let __v_81: G = __r_arr[32]; let __v_82: G = __r_arr[33]; match __v_9.as_canonical_u64() { _ => { match __v_49.as_canonical_u64() { _ => { let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(739, &__args[..])?) { [G::ZERO; OUT_739] } else { let (__hash, __hit) = record.function_queries[739].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[739].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[739].bump_multiplicity(__i); } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => { aiur_fn_739::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(742, &__args[..])?) { [G::ZERO; OUT_742] } else { let (__hash, __hit) = record.function_queries[742].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[742].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => { aiur_fn_742::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_745] = []; record.function_queries[745].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_746: usize = 2; -const IN_746: usize = 2; -const OUT_746: usize = 0; -fn aiur_fn_746(inp: [G; IN_746], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_746], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 50] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(16).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(50))?; 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: 50 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 50] = __args[..50].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __v_34: G = __loaded[32]; let __v_35: G = __loaded[33]; let __v_36: G = __loaded[34]; let __v_37: G = __loaded[35]; let __v_38: G = __loaded[36]; let __v_39: G = __loaded[37]; let __v_40: G = __loaded[38]; let __v_41: G = __loaded[39]; let __v_42: G = __loaded[40]; let __v_43: G = __loaded[41]; let __v_44: G = __loaded[42]; let __v_45: G = __loaded[43]; let __v_46: G = __loaded[44]; let __v_47: G = __loaded[45]; let __v_48: G = __loaded[46]; let __v_49: G = __loaded[47]; let __v_50: G = __loaded[48]; let __v_51: G = __loaded[49]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_746] = []; record.function_queries[746].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(745, &__args[..])?) { [G::ZERO; OUT_745] } else { let (__hash, __hit) = record.function_queries[745].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[745].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[745].bump_multiplicity(__i); } let __ret: [G; OUT_745] = unsafe { *(record.function_queries[745].output_at(__i).as_ptr() as *const [G; OUT_745]) }; __ret }, _ => { aiur_fn_745::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_0, __v_51]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(746, &__args[..])?) { [G::ZERO; OUT_746] } else { let (__hash, __hit) = record.function_queries[746].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[746].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[746].bump_multiplicity(__i); } let __ret: [G; OUT_746] = unsafe { *(record.function_queries[746].output_at(__i).as_ptr() as *const [G; OUT_746]) }; __ret }, _ => { aiur_fn_746::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_746] = []; record.function_queries[746].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_747: usize = 3; -const IN_747: usize = 3; -const OUT_747: usize = 0; -fn aiur_fn_747(inp: [G; IN_747], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_747], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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() { 1u64 => { let __ret: [G; OUT_747] = []; record.function_queries[747].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(746, &__args[..])?) { [G::ZERO; OUT_746] } else { let (__hash, __hit) = record.function_queries[746].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[746].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[746].bump_multiplicity(__i); } let __ret: [G; OUT_746] = unsafe { *(record.function_queries[746].output_at(__i).as_ptr() as *const [G; OUT_746]) }; __ret }, _ => { aiur_fn_746::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_747] = []; record.function_queries[747].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_748: usize = 99; -const IN_748: usize = 99; -const OUT_748: usize = 0; -fn aiur_fn_748(inp: [G; IN_748], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_748], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_0.as_canonical_u64() { 0u64 => { match __v_45.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(736, &__args[..])?) { [G::ZERO; OUT_736] } else { let (__hash, __hit) = record.function_queries[736].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[736].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[736].bump_multiplicity(__i); } let __ret: [G; OUT_736] = unsafe { *(record.function_queries[736].output_at(__i).as_ptr() as *const [G; OUT_736]) }; __ret }, _ => { aiur_fn_736::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(737, &__args[..])?) { [G::ZERO; OUT_737] } else { let (__hash, __hit) = record.function_queries[737].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[737].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => { aiur_fn_737::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(742, &__args[..])?) { [G::ZERO; OUT_742] } else { let (__hash, __hit) = record.function_queries[742].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[742].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => { aiur_fn_742::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(742, &__args[..])?) { [G::ZERO; OUT_742] } else { let (__hash, __hit) = record.function_queries[742].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[742].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => { aiur_fn_742::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_748] = []; record.function_queries[748].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); }, } }, 1u64 => { match __v_45.as_canonical_u64() { 1u64 => { match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(739, &__args[..])?) { [G::ZERO; OUT_739] } else { let (__hash, __hit) = record.function_queries[739].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[739].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[739].bump_multiplicity(__i); } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => { aiur_fn_739::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(742, &__args[..])?) { [G::ZERO; OUT_742] } else { let (__hash, __hit) = record.function_queries[742].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[742].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => { aiur_fn_742::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(747, &__args[..])?) { [G::ZERO; OUT_747] } else { let (__hash, __hit) = record.function_queries[747].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[747].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[747].bump_multiplicity(__i); } let __ret: [G; OUT_747] = unsafe { *(record.function_queries[747].output_at(__i).as_ptr() as *const [G; OUT_747]) }; __ret }, _ => { aiur_fn_747::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_748] = []; record.function_queries[748].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); }, } }, 2u64 => { match __v_45.as_canonical_u64() { 2u64 => { match __v_1.as_canonical_u64() { _ => { let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(739, &__args[..])?) { [G::ZERO; OUT_739] } else { let (__hash, __hit) = record.function_queries[739].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[739].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[739].bump_multiplicity(__i); } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => { aiur_fn_739::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(739, &__args[..])?) { [G::ZERO; OUT_739] } else { let (__hash, __hit) = record.function_queries[739].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[739].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[739].bump_multiplicity(__i); } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => { aiur_fn_739::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(742, &__args[..])?) { [G::ZERO; OUT_742] } else { let (__hash, __hit) = record.function_queries[742].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[742].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => { aiur_fn_742::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(744, &__args[..])?) { [G::ZERO; OUT_744] } else { let (__hash, __hit) = record.function_queries[744].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[744].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[744].bump_multiplicity(__i); } let __ret: [G; OUT_744] = unsafe { *(record.function_queries[744].output_at(__i).as_ptr() as *const [G; OUT_744]) }; __ret }, _ => { aiur_fn_744::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_748] = []; record.function_queries[748].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_749: usize = 2; -const IN_749: usize = 2; -const OUT_749: usize = 0; -fn aiur_fn_749(inp: [G; IN_749], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_749], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 64] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(17).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(64))?; 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: 64 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 64] = __args[..64].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __v_14: G = __loaded[12]; let __v_15: G = __loaded[13]; let __v_16: G = __loaded[14]; let __v_17: G = __loaded[15]; let __v_18: G = __loaded[16]; let __v_19: G = __loaded[17]; let __v_20: G = __loaded[18]; let __v_21: G = __loaded[19]; let __v_22: G = __loaded[20]; let __v_23: G = __loaded[21]; let __v_24: G = __loaded[22]; let __v_25: G = __loaded[23]; let __v_26: G = __loaded[24]; let __v_27: G = __loaded[25]; let __v_28: G = __loaded[26]; let __v_29: G = __loaded[27]; let __v_30: G = __loaded[28]; let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __v_34: G = __loaded[32]; let __v_35: G = __loaded[33]; let __v_36: G = __loaded[34]; let __v_37: G = __loaded[35]; let __v_38: G = __loaded[36]; let __v_39: G = __loaded[37]; let __v_40: G = __loaded[38]; let __v_41: G = __loaded[39]; let __v_42: G = __loaded[40]; let __v_43: G = __loaded[41]; let __v_44: G = __loaded[42]; let __v_45: G = __loaded[43]; let __v_46: G = __loaded[44]; let __v_47: G = __loaded[45]; let __v_48: G = __loaded[46]; let __v_49: G = __loaded[47]; let __v_50: G = __loaded[48]; let __v_51: G = __loaded[49]; let __v_52: G = __loaded[50]; let __v_53: G = __loaded[51]; let __v_54: G = __loaded[52]; let __v_55: G = __loaded[53]; let __v_56: G = __loaded[54]; let __v_57: G = __loaded[55]; let __v_58: G = __loaded[56]; let __v_59: G = __loaded[57]; let __v_60: G = __loaded[58]; let __v_61: G = __loaded[59]; let __v_62: G = __loaded[60]; let __v_63: G = __loaded[61]; let __v_64: G = __loaded[62]; let __v_65: G = __loaded[63]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_749] = []; record.function_queries[749].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(769, &__args[..])?) { [G::ZERO; OUT_769] } else { let (__hash, __hit) = record.function_queries[769].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[769].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[769].bump_multiplicity(__i); } let __ret: [G; OUT_769] = unsafe { *(record.function_queries[769].output_at(__i).as_ptr() as *const [G; OUT_769]) }; __ret }, _ => { aiur_fn_769::(__args, __hash, record, io_buffer)? }, } } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; let __v_69: G = __r_arr[3]; let __v_70: G = __r_arr[4]; let __v_71: G = __r_arr[5]; let __v_72: G = __r_arr[6]; let __v_73: G = __r_arr[7]; let __v_74: G = __r_arr[8]; let __v_75: G = __r_arr[9]; let __v_76: G = __r_arr[10]; let __v_77: G = __r_arr[11]; let __v_78: G = __r_arr[12]; let __v_79: G = __r_arr[13]; let __v_80: G = __r_arr[14]; let __v_81: G = __r_arr[15]; let __v_82: G = __r_arr[16]; let __v_83: G = __r_arr[17]; let __v_84: G = __r_arr[18]; let __v_85: G = __r_arr[19]; let __v_86: G = __r_arr[20]; let __v_87: G = __r_arr[21]; let __v_88: G = __r_arr[22]; let __v_89: G = __r_arr[23]; let __v_90: G = __r_arr[24]; let __v_91: G = __r_arr[25]; let __v_92: G = __r_arr[26]; let __v_93: G = __r_arr[27]; let __v_94: G = __r_arr[28]; let __v_95: G = __r_arr[29]; let __v_96: G = __r_arr[30]; let __v_97: G = __r_arr[31]; let __v_98: G = __r_arr[32]; let __v_99: G = __r_arr[33]; let __v_100: G = __r_arr[34]; let __v_101: G = __r_arr[35]; let __v_102: G = __r_arr[36]; let __v_103: G = __r_arr[37]; let __v_104: G = __r_arr[38]; let __v_105: G = __r_arr[39]; let __v_106: G = __r_arr[40]; let __v_107: G = __r_arr[41]; let __v_108: G = __r_arr[42]; let __v_109: G = __r_arr[43]; let __v_110: G = __r_arr[44]; let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(748, &__args[..])?) { [G::ZERO; OUT_748] } else { let (__hash, __hit) = record.function_queries[748].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[748].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[748].bump_multiplicity(__i); } let __ret: [G; OUT_748] = unsafe { *(record.function_queries[748].output_at(__i).as_ptr() as *const [G; OUT_748]) }; __ret }, _ => { aiur_fn_748::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_0, __v_65]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(749, &__args[..])?) { [G::ZERO; OUT_749] } else { let (__hash, __hit) = record.function_queries[749].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[749].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[749].bump_multiplicity(__i); } let __ret: [G; OUT_749] = unsafe { *(record.function_queries[749].output_at(__i).as_ptr() as *const [G; OUT_749]) }; __ret }, _ => { aiur_fn_749::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_749] = []; record.function_queries[749].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_750: usize = 55; -const IN_750: usize = 55; -const OUT_750: usize = 0; -fn aiur_fn_750(inp: [G; IN_750], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_750], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0]; 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_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; let __v_58: G = __r_arr[3]; let __v_59: G = __r_arr[4]; let __v_60: G = __r_arr[5]; let __v_61: G = __r_arr[6]; let __v_62: G = __r_arr[7]; let __v_63: G = __r_arr[8]; let __v_64: G = __r_arr[9]; let __v_65: G = __r_arr[10]; let __v_66: G = __r_arr[11]; let __v_67: G = __r_arr[12]; let __v_68: G = __r_arr[13]; let __v_69: G = __r_arr[14]; let __v_70: G = __r_arr[15]; let __v_71: G = __r_arr[16]; let __v_72: G = __r_arr[17]; let __v_73: G = __r_arr[18]; let __v_74: G = __r_arr[19]; let __v_75: G = __r_arr[20]; let __v_76: G = __r_arr[21]; let __v_77: G = __r_arr[22]; let __v_78: G = __r_arr[23]; let __v_79: G = __r_arr[24]; let __v_80: G = __r_arr[25]; let __v_81: G = __r_arr[26]; let __v_82: G = __r_arr[27]; let __v_83: G = __r_arr[28]; let __v_84: G = __r_arr[29]; let __v_85: G = __r_arr[30]; let __v_86: G = __r_arr[31]; let __v_87: G = __r_arr[32]; let __v_88: G = __r_arr[33]; let __v_89: G = __r_arr[34]; let __v_90: G = __r_arr[35]; let __v_91: G = __r_arr[36]; let __v_92: G = __r_arr[37]; let __v_93: G = __r_arr[38]; let __v_94: G = __r_arr[39]; let __v_95: G = __r_arr[40]; let __v_96: G = __r_arr[41]; let __v_97: G = __r_arr[42]; let __v_98: G = __r_arr[43]; let __v_99: G = __r_arr[44]; let __v_100: G = __r_arr[45]; let __v_101: G = __r_arr[46]; let __v_102: G = __r_arr[47]; match __v_55.as_canonical_u64() { _ => { match __v_55.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { match __v_56.as_canonical_u64() { _ => { let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(736, &__args[..])?) { [G::ZERO; OUT_736] } else { let (__hash, __hit) = record.function_queries[736].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[736].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[736].bump_multiplicity(__i); } let __ret: [G; OUT_736] = unsafe { *(record.function_queries[736].output_at(__i).as_ptr() as *const [G; OUT_736]) }; __ret }, _ => { aiur_fn_736::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(737, &__args[..])?) { [G::ZERO; OUT_737] } else { let (__hash, __hit) = record.function_queries[737].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[737].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => { aiur_fn_737::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(742, &__args[..])?) { [G::ZERO; OUT_742] } else { let (__hash, __hit) = record.function_queries[742].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[742].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => { aiur_fn_742::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(742, &__args[..])?) { [G::ZERO; OUT_742] } else { let (__hash, __hit) = record.function_queries[742].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[742].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => { aiur_fn_742::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_750] = []; record.function_queries[750].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }, 1u64 => { match __v_1.as_canonical_u64() { 1u64 => { match __v_56.as_canonical_u64() { _ => { let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(739, &__args[..])?) { [G::ZERO; OUT_739] } else { let (__hash, __hit) = record.function_queries[739].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[739].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[739].bump_multiplicity(__i); } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => { aiur_fn_739::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(739, &__args[..])?) { [G::ZERO; OUT_739] } else { let (__hash, __hit) = record.function_queries[739].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[739].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[739].bump_multiplicity(__i); } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => { aiur_fn_739::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(742, &__args[..])?) { [G::ZERO; OUT_742] } else { let (__hash, __hit) = record.function_queries[742].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[742].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => { aiur_fn_742::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(744, &__args[..])?) { [G::ZERO; OUT_744] } else { let (__hash, __hit) = record.function_queries[744].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[744].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[744].bump_multiplicity(__i); } let __ret: [G; OUT_744] = unsafe { *(record.function_queries[744].output_at(__i).as_ptr() as *const [G; OUT_744]) }; __ret }, _ => { aiur_fn_744::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_750] = []; record.function_queries[750].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }, 2u64 => { match __v_1.as_canonical_u64() { 2u64 => { match __v_56.as_canonical_u64() { _ => { let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(739, &__args[..])?) { [G::ZERO; OUT_739] } else { let (__hash, __hit) = record.function_queries[739].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[739].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[739].bump_multiplicity(__i); } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => { aiur_fn_739::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(742, &__args[..])?) { [G::ZERO; OUT_742] } else { let (__hash, __hit) = record.function_queries[742].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[742].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => { aiur_fn_742::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_750] = []; record.function_queries[750].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }, 3u64 => { match __v_1.as_canonical_u64() { 3u64 => { match __v_56.as_canonical_u64() { _ => { let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(738, &__args[..])?) { [G::ZERO; OUT_738] } else { let (__hash, __hit) = record.function_queries[738].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[738].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[738].bump_multiplicity(__i); } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => { aiur_fn_738::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(742, &__args[..])?) { [G::ZERO; OUT_742] } else { let (__hash, __hit) = record.function_queries[742].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[742].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => { aiur_fn_742::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_750] = []; record.function_queries[750].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }, 4u64 => { match __v_1.as_canonical_u64() { 4u64 => { match __v_56.as_canonical_u64() { _ => { let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(741, &__args[..])?) { [G::ZERO; OUT_741] } else { let (__hash, __hit) = record.function_queries[741].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[741].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[741].bump_multiplicity(__i); } let __ret: [G; OUT_741] = unsafe { *(record.function_queries[741].output_at(__i).as_ptr() as *const [G; OUT_741]) }; __ret }, _ => { aiur_fn_741::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_750] = []; record.function_queries[750].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }, 5u64 => { match __v_1.as_canonical_u64() { 5u64 => { match __v_56.as_canonical_u64() { _ => { let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(741, &__args[..])?) { [G::ZERO; OUT_741] } else { let (__hash, __hit) = record.function_queries[741].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[741].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[741].bump_multiplicity(__i); } let __ret: [G; OUT_741] = unsafe { *(record.function_queries[741].output_at(__i).as_ptr() as *const [G; OUT_741]) }; __ret }, _ => { aiur_fn_741::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_750] = []; record.function_queries[750].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }, 6u64 => { match __v_1.as_canonical_u64() { 6u64 => { match __v_56.as_canonical_u64() { _ => { let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(741, &__args[..])?) { [G::ZERO; OUT_741] } else { let (__hash, __hit) = record.function_queries[741].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[741].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[741].bump_multiplicity(__i); } let __ret: [G; OUT_741] = unsafe { *(record.function_queries[741].output_at(__i).as_ptr() as *const [G; OUT_741]) }; __ret }, _ => { aiur_fn_741::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_750] = []; record.function_queries[750].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }, 7u64 => { match __v_1.as_canonical_u64() { 7u64 => { match __v_56.as_canonical_u64() { _ => { let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(740, &__args[..])?) { [G::ZERO; OUT_740] } else { let (__hash, __hit) = record.function_queries[740].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[740].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => { aiur_fn_740::(__args, __hash, record, io_buffer)? }, } } }; let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(741, &__args[..])?) { [G::ZERO; OUT_741] } else { let (__hash, __hit) = record.function_queries[741].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[741].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[741].bump_multiplicity(__i); } let __ret: [G; OUT_741] = unsafe { *(record.function_queries[741].output_at(__i).as_ptr() as *const [G; OUT_741]) }; __ret }, _ => { aiur_fn_741::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_750] = []; record.function_queries[750].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }, 8u64 => { match __v_1.as_canonical_u64() { 8u64 => { let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_56, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(749, &__args[..])?) { [G::ZERO; OUT_749] } else { let (__hash, __hit) = record.function_queries[749].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[749].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[749].bump_multiplicity(__i); } let __ret: [G; OUT_749] = unsafe { *(record.function_queries[749].output_at(__i).as_ptr() as *const [G; OUT_749]) }; __ret }, _ => { aiur_fn_749::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_750] = []; record.function_queries[750].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_751: usize = 2; -const IN_751: usize = 2; -const OUT_751: usize = 0; -fn aiur_fn_751(inp: [G; IN_751], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_751], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_705] = { let __args: [G; IN_705] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(705, &__args[..])?) { [G::ZERO; OUT_705] } else { let (__hash, __hit) = record.function_queries[705].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[705].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[705].bump_multiplicity(__i); } let __ret: [G; OUT_705] = unsafe { *(record.function_queries[705].output_at(__i).as_ptr() as *const [G; OUT_705]) }; __ret }, _ => { aiur_fn_705::(__args, __hash, record, io_buffer)? }, } } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(358, &__args[..])?) { [G::ZERO; OUT_358] } else { let (__hash, __hit) = record.function_queries[358].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[358].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => { aiur_fn_358::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Contains: target is not a leaf of the claimed tree".to_string()) }); } let __ret: [G; OUT_751] = []; record.function_queries[751].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_752: usize = 8; -const IN_752: usize = 8; -const OUT_752: usize = 0; -fn aiur_fn_752(inp: [G; IN_752], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_752], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __io_pair: (G, G) = { let __key: [G; 8] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __info = io_buffer.get_info(__v_8, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_9: G = __io_pair.0; let __v_10: G = __io_pair.1; let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_8, __v_9, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(5, &__args[..])?) { [G::ZERO; OUT_5] } else { let (__hash, __hit) = record.function_queries[5].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[5].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => { aiur_fn_5::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(103); let __v_13: G = G::from_u64(230); let __v_14: G = G::from_u64(9); let __v_15: G = G::from_u64(106); let __v_16: G = G::from_u64(133); let __v_17: G = G::from_u64(174); let __v_18: G = G::from_u64(187); let __v_19: G = G::from_u64(114); let __v_20: G = G::from_u64(243); let __v_21: G = G::from_u64(110); let __v_22: G = G::from_u64(60); let __v_23: G = G::from_u64(58); let __v_24: G = G::from_u64(245); let __v_25: G = G::from_u64(79); let __v_26: G = G::from_u64(165); let __v_27: G = G::from_u64(127); let __v_28: G = G::from_u64(82); let __v_29: G = G::from_u64(14); let __v_30: G = G::from_u64(81); let __v_31: G = G::from_u64(140); let __v_32: G = G::from_u64(104); let __v_33: G = G::from_u64(5); let __v_34: G = G::from_u64(155); let __v_35: G = G::from_u64(171); let __v_36: G = G::from_u64(217); let __v_37: G = G::from_u64(131); let __v_38: G = G::from_u64(31); let __v_39: G = G::from_u64(25); let __v_40: G = G::from_u64(205); let __v_41: G = G::from_u64(224); let __v_42: G = G::from_u64(91); let __v_43: G = G::from_u64(1); let __v_44: G = { let __values: [G; 3] = [__v_43, __v_43, __v_43]; let __mq = record.memory_queries.get_index_mut(1).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_45: G = { let __values: [G; 8] = [__v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; 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_46: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_12, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42]; let __mq = record.memory_queries.get_index_mut(12).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_47: G = { let __values: [G; 34] = [__v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __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(13).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_26] = { let __args: [G; IN_26] = [__v_11, __v_44, __v_8, __v_8, __v_45, __v_46, __v_47]; 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_48: G = __r_arr[0]; let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_48]; 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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; let __v_52: G = __r_arr[3]; let __v_53: G = __r_arr[4]; let __v_54: G = __r_arr[5]; let __v_55: G = __r_arr[6]; let __v_56: G = __r_arr[7]; let __v_57: G = __r_arr[8]; let __v_58: G = __r_arr[9]; let __v_59: G = __r_arr[10]; let __v_60: G = __r_arr[11]; let __v_61: G = __r_arr[12]; let __v_62: G = __r_arr[13]; let __v_63: G = __r_arr[14]; let __v_64: G = __r_arr[15]; let __v_65: G = __r_arr[16]; let __v_66: G = __r_arr[17]; let __v_67: G = __r_arr[18]; let __v_68: G = __r_arr[19]; let __v_69: G = __r_arr[20]; let __v_70: G = __r_arr[21]; let __v_71: G = __r_arr[22]; let __v_72: G = __r_arr[23]; let __v_73: G = __r_arr[24]; let __v_74: G = __r_arr[25]; let __v_75: G = __r_arr[26]; let __v_76: G = __r_arr[27]; let __v_77: G = __r_arr[28]; let __v_78: G = __r_arr[29]; let __v_79: G = __r_arr[30]; let __v_80: G = __r_arr[31]; let __v_81: G = G::from_u64(256); let __v_82: G = __v_81 * __v_50; let __v_83: G = __v_49 + __v_82; let __v_84: G = G::from_u64(65536); let __v_85: G = __v_84 * __v_51; let __v_86: G = __v_83 + __v_85; let __v_87: G = G::from_u64(16777216); let __v_88: G = __v_87 * __v_52; let __v_89: G = __v_86 + __v_88; let __v_90: G = __v_81 * __v_54; let __v_91: G = __v_53 + __v_90; let __v_92: G = __v_84 * __v_55; let __v_93: G = __v_91 + __v_92; let __v_94: G = __v_87 * __v_56; let __v_95: G = __v_93 + __v_94; let __v_96: G = __v_81 * __v_58; let __v_97: G = __v_57 + __v_96; let __v_98: G = __v_84 * __v_59; let __v_99: G = __v_97 + __v_98; let __v_100: G = __v_87 * __v_60; let __v_101: G = __v_99 + __v_100; let __v_102: G = __v_81 * __v_62; let __v_103: G = __v_61 + __v_102; let __v_104: G = __v_84 * __v_63; let __v_105: G = __v_103 + __v_104; let __v_106: G = __v_87 * __v_64; let __v_107: G = __v_105 + __v_106; let __v_108: G = __v_81 * __v_66; let __v_109: G = __v_65 + __v_108; let __v_110: G = __v_84 * __v_67; let __v_111: G = __v_109 + __v_110; let __v_112: G = __v_87 * __v_68; let __v_113: G = __v_111 + __v_112; let __v_114: G = __v_81 * __v_70; let __v_115: G = __v_69 + __v_114; let __v_116: G = __v_84 * __v_71; let __v_117: G = __v_115 + __v_116; let __v_118: G = __v_87 * __v_72; let __v_119: G = __v_117 + __v_118; let __v_120: G = __v_81 * __v_74; let __v_121: G = __v_73 + __v_120; let __v_122: G = __v_84 * __v_75; let __v_123: G = __v_121 + __v_122; let __v_124: G = __v_87 * __v_76; let __v_125: G = __v_123 + __v_124; let __v_126: G = __v_81 * __v_78; let __v_127: G = __v_77 + __v_126; let __v_128: G = __v_84 * __v_79; let __v_129: G = __v_127 + __v_128; let __v_130: G = __v_87 * __v_80; let __v_131: G = __v_129 + __v_130; if (__v_89 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("claim: bytes do not hash to the public claim digest".to_string()) }); } if (__v_95 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_95.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("claim: bytes do not hash to the public claim digest".to_string()) }); } if (__v_101 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_101.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("claim: bytes do not hash to the public claim digest".to_string()) }); } if (__v_107 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_107.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("claim: bytes do not hash to the public claim digest".to_string()) }); } if (__v_113 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_113.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("claim: bytes do not hash to the public claim digest".to_string()) }); } if (__v_119 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_119.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("claim: bytes do not hash to the public claim digest".to_string()) }); } if (__v_125 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("claim: bytes do not hash to the public claim digest".to_string()) }); } if (__v_131 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_131.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("claim: bytes do not hash to the public claim digest".to_string()) }); } let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_11]; 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_132: G = __r_arr[0]; let __v_133: G = __r_arr[1]; let __v_134: G = __r_arr[2]; let __v_135: G = __r_arr[3]; let __v_136: G = __r_arr[4]; let __v_137: G = __r_arr[5]; let __v_138: G = __r_arr[6]; let __v_139: G = __r_arr[7]; let __v_140: G = __r_arr[8]; let __v_141: G = __r_arr[9]; if (__v_132 != __v_29) { return Err(ExecError::AssertEqMismatch { lhs: __v_132.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("claim: wrong TagN flag".to_string()) }); } let __v_142: G = __v_134 + __v_135; let __v_143: G = __v_142 + __v_136; let __v_144: G = __v_143 + __v_137; let __v_145: G = __v_144 + __v_138; let __v_146: G = __v_145 + __v_139; let __v_147: G = __v_146 + __v_140; if (__v_147 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_147.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("claim: TagN size exceeds a single byte".to_string()) }); } let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_141]; 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_148: G = __r_arr[0]; let __v_149: G = __r_arr[1]; let __v_150: G = G::from_u64(4); if (__v_148 != __v_150) { return Err(ExecError::AssertEqMismatch { lhs: __v_148.as_canonical_u64(), rhs: __v_150.as_canonical_u64(), msg: Some("claim: unsupported object format".to_string()) }); } let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_149]; 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]; match __v_133.as_canonical_u64() { 3u64 => { let __v_153: G = G::from_u64(3); if (__v_151 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_151.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: Some("claim: wrong validator identity".to_string()) }); } let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_152]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(718, &__args[..])?) { [G::ZERO; OUT_718] } else { let (__hash, __hit) = record.function_queries[718].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[718].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[718].bump_multiplicity(__i); } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => { aiur_fn_718::(__args, __hash, record, io_buffer)? }, } } }; let __v_154: G = __r_arr[0]; let __v_155: G = __r_arr[1]; let __v_156: G = __r_arr[2]; let __v_157: G = __r_arr[3]; let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_154, __v_153, __v_155, __v_156]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(468, &__args[..])?) { [G::ZERO; OUT_468] } else { let (__hash, __hit) = record.function_queries[468].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[468].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[468].bump_multiplicity(__i); } let __ret: [G; OUT_468] = unsafe { *(record.function_queries[468].output_at(__i).as_ptr() as *const [G; OUT_468]) }; __ret }, _ => { aiur_fn_468::(__args, __hash, record, io_buffer)? }, } } }; let __v_158: G = __r_arr[0]; let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_157]; 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_159: G = __r_arr[0]; let __v_160: G = __r_arr[1]; let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_160]; 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_161: G = __r_arr[0]; let __v_162: G = __r_arr[1]; let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_162]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(717, &__args[..])?) { [G::ZERO; OUT_717] } else { let (__hash, __hit) = record.function_queries[717].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[717].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[717].bump_multiplicity(__i); } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => { aiur_fn_717::(__args, __hash, record, io_buffer)? }, } } }; let __v_163: G = __r_arr[0]; let __v_164: G = __r_arr[1]; let __v_165: G = __r_arr[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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]; let __v_169: G = G::from_u64(1); if (__v_166 != __v_169) { return Err(ExecError::AssertEqMismatch { lhs: __v_166.as_canonical_u64(), rhs: __v_169.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } if (__v_167 != __v_169) { return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_169.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } if (__v_168 != __v_169) { return Err(ExecError::AssertEqMismatch { lhs: __v_168.as_canonical_u64(), rhs: __v_169.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_158, __v_159, __v_161, __v_163, __v_164]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(757, &__args[..])?) { [G::ZERO; OUT_757] } else { let (__hash, __hit) = record.function_queries[757].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[757].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[757].bump_multiplicity(__i); } let __ret: [G; OUT_757] = unsafe { *(record.function_queries[757].output_at(__i).as_ptr() as *const [G; OUT_757]) }; __ret }, _ => { aiur_fn_757::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_752] = []; record.function_queries[752].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_152]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(718, &__args[..])?) { [G::ZERO; OUT_718] } else { let (__hash, __hit) = record.function_queries[718].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[718].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[718].bump_multiplicity(__i); } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => { aiur_fn_718::(__args, __hash, record, io_buffer)? }, } } }; let __v_153: G = __r_arr[0]; let __v_154: G = __r_arr[1]; let __v_155: G = __r_arr[2]; let __v_156: G = __r_arr[3]; let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_153, __v_151, __v_154, __v_155]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(468, &__args[..])?) { [G::ZERO; OUT_468] } else { let (__hash, __hit) = record.function_queries[468].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[468].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[468].bump_multiplicity(__i); } let __ret: [G; OUT_468] = unsafe { *(record.function_queries[468].output_at(__i).as_ptr() as *const [G; OUT_468]) }; __ret }, _ => { aiur_fn_468::(__args, __hash, record, io_buffer)? }, } } }; let __v_157: G = __r_arr[0]; let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_156]; 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_158: G = __r_arr[0]; let __v_159: G = __r_arr[1]; let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_159]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(717, &__args[..])?) { [G::ZERO; OUT_717] } else { let (__hash, __hit) = record.function_queries[717].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[717].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[717].bump_multiplicity(__i); } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => { aiur_fn_717::(__args, __hash, record, io_buffer)? }, } } }; let __v_160: G = __r_arr[0]; let __v_161: G = __r_arr[1]; let __v_162: G = __r_arr[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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]; let __v_166: G = G::from_u64(1); if (__v_163 != __v_166) { return Err(ExecError::AssertEqMismatch { lhs: __v_163.as_canonical_u64(), rhs: __v_166.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } if (__v_164 != __v_166) { return Err(ExecError::AssertEqMismatch { lhs: __v_164.as_canonical_u64(), rhs: __v_166.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } if (__v_165 != __v_166) { return Err(ExecError::AssertEqMismatch { lhs: __v_165.as_canonical_u64(), rhs: __v_166.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } match __v_160.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_157, __v_158]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(698, &__args[..])?) { [G::ZERO; OUT_698] } else { let (__hash, __hit) = record.function_queries[698].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[698].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => { aiur_fn_698::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_752] = []; record.function_queries[752].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_161]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(705, &__args[..])?) { [G::ZERO; OUT_705] } else { let (__hash, __hit) = record.function_queries[705].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[705].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[705].bump_multiplicity(__i); } let __ret: [G; OUT_705] = unsafe { *(record.function_queries[705].output_at(__i).as_ptr() as *const [G; OUT_705]) }; __ret }, _ => { aiur_fn_705::(__args, __hash, record, io_buffer)? }, } } }; let __v_167: G = __r_arr[0]; let __v_168: G = G::from_u64(1); let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_167, __v_168, __v_168, __v_168, __v_168, __v_168, __v_168]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(706, &__args[..])?) { [G::ZERO; OUT_706] } else { let (__hash, __hit) = record.function_queries[706].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[706].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[706].bump_multiplicity(__i); } let __ret: [G; OUT_706] = unsafe { *(record.function_queries[706].output_at(__i).as_ptr() as *const [G; OUT_706]) }; __ret }, _ => { aiur_fn_706::(__args, __hash, record, io_buffer)? }, } } }; let __v_169: G = __r_arr[0]; let __v_170: G = __r_arr[1]; let __v_171: G = __r_arr[2]; let __v_172: G = __r_arr[3]; let __v_173: G = __r_arr[4]; let __v_174: G = __r_arr[5]; let __v_175: G = G::from_u64(2); let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_157, __v_158, __v_168, __v_168, __v_168, __v_168, __v_168, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(708, &__args[..])?) { [G::ZERO; OUT_708] } else { let (__hash, __hit) = record.function_queries[708].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[708].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[708].bump_multiplicity(__i); } let __ret: [G; OUT_708] = unsafe { *(record.function_queries[708].output_at(__i).as_ptr() as *const [G; OUT_708]) }; __ret }, _ => { aiur_fn_708::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_752] = []; record.function_queries[752].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_160.as_canonical_u64())); }, } }, 5u64 => { let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_152]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(718, &__args[..])?) { [G::ZERO; OUT_718] } else { let (__hash, __hit) = record.function_queries[718].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[718].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[718].bump_multiplicity(__i); } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => { aiur_fn_718::(__args, __hash, record, io_buffer)? }, } } }; let __v_153: G = __r_arr[0]; let __v_154: G = __r_arr[1]; let __v_155: G = __r_arr[2]; let __v_156: G = __r_arr[3]; let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_153, __v_151, __v_154, __v_155]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(468, &__args[..])?) { [G::ZERO; OUT_468] } else { let (__hash, __hit) = record.function_queries[468].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[468].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[468].bump_multiplicity(__i); } let __ret: [G; OUT_468] = unsafe { *(record.function_queries[468].output_at(__i).as_ptr() as *const [G; OUT_468]) }; __ret }, _ => { aiur_fn_468::(__args, __hash, record, io_buffer)? }, } } }; let __v_157: G = __r_arr[0]; let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_156]; 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_158: G = __r_arr[0]; let __v_159: G = __r_arr[1]; let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_159]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(717, &__args[..])?) { [G::ZERO; OUT_717] } else { let (__hash, __hit) = record.function_queries[717].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[717].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[717].bump_multiplicity(__i); } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => { aiur_fn_717::(__args, __hash, record, io_buffer)? }, } } }; let __v_160: G = __r_arr[0]; let __v_161: G = __r_arr[1]; let __v_162: G = __r_arr[2]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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]; let __v_166: G = G::from_u64(1); if (__v_163 != __v_166) { return Err(ExecError::AssertEqMismatch { lhs: __v_163.as_canonical_u64(), rhs: __v_166.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } if (__v_164 != __v_166) { return Err(ExecError::AssertEqMismatch { lhs: __v_164.as_canonical_u64(), rhs: __v_166.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } if (__v_165 != __v_166) { return Err(ExecError::AssertEqMismatch { lhs: __v_165.as_canonical_u64(), rhs: __v_166.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_157, __v_158, __v_160, __v_161]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(711, &__args[..])?) { [G::ZERO; OUT_711] } else { let (__hash, __hit) = record.function_queries[711].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[711].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[711].bump_multiplicity(__i); } let __ret: [G; OUT_711] = unsafe { *(record.function_queries[711].output_at(__i).as_ptr() as *const [G; OUT_711]) }; __ret }, _ => { aiur_fn_711::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_752] = []; record.function_queries[752].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_153: G = G::from_u64(0); if (__v_151 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_151.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: Some("claim: wrong validator identity".to_string()) }); } let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_152]; 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_154: G = __r_arr[0]; let __v_155: G = __r_arr[1]; let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_155]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(733, &__args[..])?) { [G::ZERO; OUT_733] } else { let (__hash, __hit) = record.function_queries[733].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[733].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[733].bump_multiplicity(__i); } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => { aiur_fn_733::(__args, __hash, record, io_buffer)? }, } } }; let __v_156: G = __r_arr[0]; let __v_157: G = __r_arr[1]; let __v_158: G = __r_arr[2]; let __v_159: G = __r_arr[3]; let __v_160: G = __r_arr[4]; let __v_161: G = __r_arr[5]; let __v_162: G = __r_arr[6]; let __v_163: G = __r_arr[7]; let __v_164: G = __r_arr[8]; let __v_165: G = __r_arr[9]; let __v_166: G = __r_arr[10]; let __v_167: G = __r_arr[11]; let __v_168: G = __r_arr[12]; let __v_169: G = __r_arr[13]; let __v_170: G = __r_arr[14]; let __v_171: G = __r_arr[15]; let __v_172: G = __r_arr[16]; let __v_173: G = __r_arr[17]; let __v_174: G = __r_arr[18]; let __v_175: G = __r_arr[19]; let __v_176: G = __r_arr[20]; let __v_177: G = __r_arr[21]; let __v_178: G = __r_arr[22]; let __v_179: G = __r_arr[23]; let __v_180: G = __r_arr[24]; let __v_181: G = __r_arr[25]; let __v_182: G = __r_arr[26]; let __v_183: G = __r_arr[27]; let __v_184: G = __r_arr[28]; let __v_185: G = __r_arr[29]; let __v_186: G = __r_arr[30]; let __v_187: G = __r_arr[31]; let __v_188: G = __r_arr[32]; let __v_189: G = __r_arr[33]; let __v_190: G = __r_arr[34]; let __v_191: G = __r_arr[35]; let __v_192: G = __r_arr[36]; let __v_193: G = __r_arr[37]; let __v_194: G = __r_arr[38]; let __v_195: G = __r_arr[39]; let __v_196: G = __r_arr[40]; let __v_197: G = __r_arr[41]; let __v_198: G = __r_arr[42]; let __v_199: G = __r_arr[43]; let __v_200: G = __r_arr[44]; let __v_201: G = __r_arr[45]; let __v_202: G = __r_arr[46]; let __v_203: G = __r_arr[47]; let __v_204: G = __r_arr[48]; let __v_205: G = __r_arr[49]; let __v_206: G = __r_arr[50]; let __v_207: G = __r_arr[51]; let __v_208: G = __r_arr[52]; let __v_209: G = __r_arr[53]; let __v_210: G = __r_arr[54]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_210.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_211: G = __loaded[0]; let __v_212: G = __loaded[1]; let __v_213: G = __loaded[2]; let __v_214: G = G::from_u64(1); if (__v_211 != __v_214) { return Err(ExecError::AssertEqMismatch { lhs: __v_211.as_canonical_u64(), rhs: __v_214.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } if (__v_212 != __v_214) { return Err(ExecError::AssertEqMismatch { lhs: __v_212.as_canonical_u64(), rhs: __v_214.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } if (__v_213 != __v_214) { return Err(ExecError::AssertEqMismatch { lhs: __v_213.as_canonical_u64(), rhs: __v_214.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_154, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_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]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(750, &__args[..])?) { [G::ZERO; OUT_750] } else { let (__hash, __hit) = record.function_queries[750].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[750].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[750].bump_multiplicity(__i); } let __ret: [G; OUT_750] = unsafe { *(record.function_queries[750].output_at(__i).as_ptr() as *const [G; OUT_750]) }; __ret }, _ => { aiur_fn_750::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_752] = []; record.function_queries[752].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_153: G = G::from_u64(0); if (__v_151 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_151.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: Some("claim: wrong validator identity".to_string()) }); } let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_152]; 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_154: G = __r_arr[0]; let __v_155: G = __r_arr[1]; let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_155]; 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_156: G = __r_arr[0]; let __v_157: G = __r_arr[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_157.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_158: G = __loaded[0]; let __v_159: G = __loaded[1]; let __v_160: G = __loaded[2]; let __v_161: G = G::from_u64(1); if (__v_158 != __v_161) { return Err(ExecError::AssertEqMismatch { lhs: __v_158.as_canonical_u64(), rhs: __v_161.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } if (__v_159 != __v_161) { return Err(ExecError::AssertEqMismatch { lhs: __v_159.as_canonical_u64(), rhs: __v_161.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } if (__v_160 != __v_161) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_161.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_154, __v_156]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(751, &__args[..])?) { [G::ZERO; OUT_751] } else { let (__hash, __hit) = record.function_queries[751].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[751].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[751].bump_multiplicity(__i); } let __ret: [G; OUT_751] = unsafe { *(record.function_queries[751].output_at(__i).as_ptr() as *const [G; OUT_751]) }; __ret }, _ => { aiur_fn_751::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_752] = []; record.function_queries[752].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_153: G = G::from_u64(2); if (__v_151 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_151.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: Some("claim: wrong resource validator identity".to_string()) }); } let __v_154: G = G::from_u64(0); let __v_155: G = G::from_u64(1); if (__v_154 != __v_155) { return Err(ExecError::AssertEqMismatch { lhs: __v_154.as_canonical_u64(), rhs: __v_155.as_canonical_u64(), msg: Some("claim: resource-v1 is not implemented by IxVM".to_string()) }); } let __ret: [G; OUT_752] = []; record.function_queries[752].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __v_153: G = G::from_u64(3); if (__v_151 != __v_153) { return Err(ExecError::AssertEqMismatch { lhs: __v_151.as_canonical_u64(), rhs: __v_153.as_canonical_u64(), msg: Some("claim: wrong validator identity".to_string()) }); } let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_152]; 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_154: G = __r_arr[0]; let __v_155: G = __r_arr[1]; let __v_156: G = G::from_u64(109); let __v_157: G = G::from_u64(2); let __v_158: G = G::from_u64(21); let __v_159: G = G::from_u64(62); let __v_160: G = G::from_u64(163); let __v_161: G = G::from_u64(17); let __v_162: G = G::from_u64(243); let __v_163: G = G::from_u64(239); let __v_164: G = G::from_u64(209); let __v_165: G = G::from_u64(119); let __v_166: G = G::from_u64(140); let __v_167: G = G::from_u64(73); let __v_168: G = G::from_u64(178); let __v_169: G = G::from_u64(238); let __v_170: G = G::from_u64(95); let __v_171: G = G::from_u64(49); let __v_172: G = G::from_u64(231); let __v_173: G = G::from_u64(154); let __v_174: G = G::from_u64(11); let __v_175: G = G::from_u64(174); let __v_176: G = G::from_u64(149); let __v_177: G = G::from_u64(229); let __v_178: G = G::from_u64(51); let __v_179: G = G::from_u64(160); let __v_180: G = G::from_u64(141); let __v_181: G = G::from_u64(20); let __v_182: G = G::from_u64(252); let __v_183: G = G::from_u64(5); let __v_184: G = G::from_u64(87); let __v_185: G = G::from_u64(45); let __v_186: G = { let __values: [G; 32] = [__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_167, __v_181, __v_182, __v_183, __v_184, __v_185, __v_178]; let __mq = record.memory_queries.get_index_mut(12).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_2] = { let __args: [G; IN_2] = [__v_154, __v_186]; 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_187: G = __r_arr[0]; let __v_188: G = G::from_u64(1); if (__v_187 != __v_188) { return Err(ExecError::AssertEqMismatch { lhs: __v_187.as_canonical_u64(), rhs: __v_188.as_canonical_u64(), msg: Some("claim: specification digest is not this circuit's".to_string()) }); } let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_155]; 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_189: G = __r_arr[0]; let __v_190: G = __r_arr[1]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_190.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_191: G = __loaded[0]; let __v_192: G = __loaded[1]; let __v_193: G = __loaded[2]; if (__v_191 != __v_188) { return Err(ExecError::AssertEqMismatch { lhs: __v_191.as_canonical_u64(), rhs: __v_188.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } if (__v_192 != __v_188) { return Err(ExecError::AssertEqMismatch { lhs: __v_192.as_canonical_u64(), rhs: __v_188.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } if (__v_193 != __v_188) { return Err(ExecError::AssertEqMismatch { lhs: __v_193.as_canonical_u64(), rhs: __v_188.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) }); } let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_189]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(488, &__args[..])?) { [G::ZERO; OUT_488] } else { let (__hash, __hit) = record.function_queries[488].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[488].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[488].bump_multiplicity(__i); } let __ret: [G; OUT_488] = unsafe { *(record.function_queries[488].output_at(__i).as_ptr() as *const [G; OUT_488]) }; __ret }, _ => { aiur_fn_488::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_752] = []; record.function_queries[752].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_133.as_canonical_u64())); }, } }) } -const INPUT_SIZE_753: usize = 3; -const IN_753: usize = 3; -const OUT_753: usize = 1; -fn aiur_fn_753(inp: [G; IN_753], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_753], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(359, &__args[..])?) { [G::ZERO; OUT_359] } else { let (__hash, __hit) = record.function_queries[359].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[359].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => { aiur_fn_359::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 4u64 => { let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_0, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(753, &__args[..])?) { [G::ZERO; OUT_753] } else { let (__hash, __hit) = record.function_queries[753].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[753].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => { aiur_fn_753::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(4); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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_753] = { let __args: [G; IN_753] = [__v_0, __v_6, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(753, &__args[..])?) { [G::ZERO; OUT_753] } else { let (__hash, __hit) = record.function_queries[753].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[753].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => { aiur_fn_753::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_9, __v_8, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_753] = [__v_13]; record.function_queries[753].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_0, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(753, &__args[..])?) { [G::ZERO; OUT_753] } else { let (__hash, __hit) = record.function_queries[753].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[753].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => { aiur_fn_753::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(5); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_2]; let __mq = record.memory_queries.get_index_mut(1).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_753] = { let __args: [G; IN_753] = [__v_0, __v_6, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(753, &__args[..])?) { [G::ZERO; OUT_753] } else { let (__hash, __hit) = record.function_queries[753].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[753].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => { aiur_fn_753::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_9, __v_8, __v_12, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_753] = [__v_13]; record.function_queries[753].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_0, __v_3, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(754, &__args[..])?) { [G::ZERO; OUT_754] } else { let (__hash, __hit) = record.function_queries[754].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[754].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[754].bump_multiplicity(__i); } let __ret: [G; OUT_754] = unsafe { *(record.function_queries[754].output_at(__i).as_ptr() as *const [G; OUT_754]) }; __ret }, _ => { aiur_fn_754::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_753] = [__v_8]; record.function_queries[753].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_754: usize = 3; -const IN_754: usize = 3; -const OUT_754: usize = 1; -fn aiur_fn_754(inp: [G; IN_754], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_754], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 4] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(2).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_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() { 3u64 => { let __v_7: G = G::from_u64(3); let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(754, &__args[..])?) { [G::ZERO; OUT_754] } else { let (__hash, __hit) = record.function_queries[754].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[754].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[754].bump_multiplicity(__i); } let __ret: [G; OUT_754] = unsafe { *(record.function_queries[754].output_at(__i).as_ptr() as *const [G; OUT_754]) }; __ret }, _ => { aiur_fn_754::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_0, __v_5, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(753, &__args[..])?) { [G::ZERO; OUT_753] } else { let (__hash, __hit) = record.function_queries[753].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[753].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => { aiur_fn_753::(__args, __hash, record, io_buffer)? }, } } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_index_mut(2).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_754] = [__v_11]; record.function_queries[754].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_0, __v_6, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(753, &__args[..])?) { [G::ZERO; OUT_753] } else { let (__hash, __hit) = record.function_queries[753].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[753].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => { aiur_fn_753::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_index_mut(2).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_754] = [__v_9]; record.function_queries[754].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_754] = [__v_1]; record.function_queries[754].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_755: usize = 1; -const IN_755: usize = 1; -const OUT_755: usize = 3; -fn aiur_fn_755(inp: [G; IN_755], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_755], ExecError> { stacker::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_234] = { let __args: [G; IN_234] = [__v_0]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_1: G = __r_arr[0]; let __loaded: [G; 12] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(9).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; let __v_9: G = __loaded[7]; let __v_10: G = __loaded[8]; let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(569, &__args[..])?) { [G::ZERO; OUT_569] } else { let (__hash, __hit) = record.function_queries[569].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[569].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[569].bump_multiplicity(__i); } let __ret: [G; OUT_569] = unsafe { *(record.function_queries[569].output_at(__i).as_ptr() as *const [G; OUT_569]) }; __ret }, _ => { aiur_fn_569::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); if (__v_14 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("Eval: unsafe or partial input".to_string()) }); } match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_755] = [__v_3, __v_4, __v_5]; record.function_queries[755].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_755] = [__v_3, __v_4, __v_5]; record.function_queries[755].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_755] = [__v_3, __v_4, __v_5]; record.function_queries[755].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_756: usize = 3; -const IN_756: usize = 3; -const OUT_756: usize = 1; -fn aiur_fn_756(inp: [G; IN_756], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_756], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_228] = { let __args: [G; IN_228] = [__v_0]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; let __v_6: G = __r_arr[3]; let __v_7: G = __r_arr[4]; let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __v_12: G = __r_arr[9]; let __v_13: G = __r_arr[10]; let __v_14: G = __r_arr[11]; let __v_15: G = __r_arr[12]; let __v_16: G = __r_arr[13]; let __v_17: G = __r_arr[14]; let __v_18: G = __r_arr[15]; let __v_19: G = __r_arr[16]; let __v_20: G = __r_arr[17]; let __v_21: G = __r_arr[18]; let __v_22: G = __r_arr[19]; let __v_23: G = __r_arr[20]; let __v_24: G = __r_arr[21]; let __v_25: G = __r_arr[22]; let __v_26: G = __r_arr[23]; let __v_27: G = __r_arr[24]; let __v_28: G = __r_arr[25]; let __v_29: G = __r_arr[26]; let __v_30: G = __r_arr[27]; let __v_31: G = __r_arr[28]; let __v_32: G = __r_arr[29]; let __v_33: G = __r_arr[30]; let __v_34: G = __r_arr[31]; let __v_35: G = __r_arr[32]; let __v_36: G = __r_arr[33]; let __v_37: G = __r_arr[34]; let __v_38: G = __r_arr[35]; let __v_39: G = __r_arr[36]; let __v_40: G = __r_arr[37]; let __v_41: G = __r_arr[38]; let __v_42: G = __r_arr[39]; let __v_43: G = __r_arr[40]; let __v_44: G = __r_arr[41]; let __v_45: G = __r_arr[42]; let __v_46: G = __r_arr[43]; let __v_47: G = __r_arr[44]; let __v_48: G = __r_arr[45]; let __v_49: G = __r_arr[46]; let __v_50: G = __r_arr[47]; match __v_3.as_canonical_u64() { _ => { match __v_3.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { _ => { let __v_51: G = G::from_u64(0); if (__v_4 != __v_51) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: Some("Eval: output must be a definition".to_string()) }); } let __v_52: G = G::from_u64(1); if (__v_5 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: Some("Eval: unsafe or partial output".to_string()) }); } let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(18, &__args[..])?) { [G::ZERO; OUT_18] } else { let (__hash, __hit) = record.function_queries[18].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[18].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[18].bump_multiplicity(__i); } let __ret: [G; OUT_18] = unsafe { *(record.function_queries[18].output_at(__i).as_ptr() as *const [G; OUT_18]) }; __ret }, _ => { aiur_fn_18::(__args, __hash, record, io_buffer)? }, } } }; let __v_53: G = __r_arr[0]; if (__v_53 != __v_1) { return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("Eval: universe parameter count mismatch".to_string()) }); } let __v_54: G = { let __values: [G; 3] = [__v_52, __v_52, __v_52]; let __mq = record.memory_queries.get_index_mut(1).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_218] = { let __args: [G; IN_218] = [__v_14, __v_48, __v_49, __v_54, __v_50]; 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_55: G = __r_arr[0]; if (__v_55 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Eval: output type does not match input".to_string()) }); } let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_15, __v_48, __v_49, __v_54, __v_50]; 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_56: G = __r_arr[0]; let __ret: [G; OUT_756] = [__v_56]; record.function_queries[756].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_757: usize = 5; -const IN_757: usize = 5; -const OUT_757: usize = 0; -fn aiur_fn_757(inp: [G; IN_757], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_757], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(690, &__args[..])?) { [G::ZERO; OUT_690] } else { let (__hash, __hit) = record.function_queries[690].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[690].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => { aiur_fn_690::(__args, __hash, record, io_buffer)? }, } } }; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_3.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(698, &__args[..])?) { [G::ZERO; OUT_698] } else { let (__hash, __hit) = record.function_queries[698].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[698].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => { aiur_fn_698::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, 0u64 => { let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(705, &__args[..])?) { [G::ZERO; OUT_705] } else { let (__hash, __hit) = record.function_queries[705].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[705].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[705].bump_multiplicity(__i); } let __ret: [G; OUT_705] = unsafe { *(record.function_queries[705].output_at(__i).as_ptr() as *const [G; OUT_705]) }; __ret }, _ => { aiur_fn_705::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(706, &__args[..])?) { [G::ZERO; OUT_706] } else { let (__hash, __hit) = record.function_queries[706].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[706].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[706].bump_multiplicity(__i); } let __ret: [G; OUT_706] = unsafe { *(record.function_queries[706].output_at(__i).as_ptr() as *const [G; OUT_706]) }; __ret }, _ => { aiur_fn_706::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; let __v_10: G = __r_arr[3]; let __v_11: G = __r_arr[4]; let __v_12: G = __r_arr[5]; let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_1, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(707, &__args[..])?) { [G::ZERO; OUT_707] } else { let (__hash, __hit) = record.function_queries[707].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[707].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[707].bump_multiplicity(__i); } let __ret: [G; OUT_707] = unsafe { *(record.function_queries[707].output_at(__i).as_ptr() as *const [G; OUT_707]) }; __ret }, _ => { aiur_fn_707::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("Eval: input is an assumption".to_string()) }); } let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_1, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(708, &__args[..])?) { [G::ZERO; OUT_708] } else { let (__hash, __hit) = record.function_queries[708].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[708].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[708].bump_multiplicity(__i); } let __ret: [G; OUT_708] = unsafe { *(record.function_queries[708].output_at(__i).as_ptr() as *const [G; OUT_708]) }; __ret }, _ => { aiur_fn_708::(__args, __hash, record, io_buffer)? }, } } }; break '__mc_0 []; }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }; let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(755, &__args[..])?) { [G::ZERO; OUT_755] } else { let (__hash, __hit) = record.function_queries[755].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[755].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[755].bump_multiplicity(__i); } let __ret: [G; OUT_755] = unsafe { *(record.function_queries[755].output_at(__i).as_ptr() as *const [G; OUT_755]) }; __ret }, _ => { aiur_fn_755::(__args, __hash, record, io_buffer)? }, } } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(756, &__args[..])?) { [G::ZERO; OUT_756] } else { let (__hash, __hit) = record.function_queries[756].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[756].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[756].bump_multiplicity(__i); } let __ret: [G; OUT_756] = unsafe { *(record.function_queries[756].output_at(__i).as_ptr() as *const [G; OUT_756]) }; __ret }, _ => { aiur_fn_756::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; 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(1).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_753] = { let __args: [G; IN_753] = [__v_0, __v_7, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(753, &__args[..])?) { [G::ZERO; OUT_753] } else { let (__hash, __hit) = record.function_queries[753].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[753].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => { aiur_fn_753::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; if (__v_11 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("Eval: result does not match output".to_string()) }); } let __ret: [G; OUT_757] = []; record.function_queries[757].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_758: usize = 8; -const IN_758: usize = 8; -const OUT_758: usize = 0; -fn aiur_fn_758(inp: [G; IN_758], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_758], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(752, &__args[..])?) { [G::ZERO; OUT_752] } else { let (__hash, __hit) = record.function_queries[752].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[752].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[752].bump_multiplicity(__i); } let __ret: [G; OUT_752] = unsafe { *(record.function_queries[752].output_at(__i).as_ptr() as *const [G; OUT_752]) }; __ret }, _ => { aiur_fn_752::(__args, __hash, record, io_buffer)? }, } } }; let __ret: [G; OUT_758] = []; record.function_queries[758].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_759: usize = 3; -const IN_759: usize = 3; -const OUT_759: usize = 1; -fn aiur_fn_759(inp: [G; IN_759], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_759], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_777] = { let __args: [G; IN_777] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(1).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() { 1u64 => { let __ret: [G; OUT_759] = [__v_2]; record.function_queries[759].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_759] = [__v_5]; record.function_queries[759].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_760: usize = 2; -const IN_760: usize = 2; -const OUT_760: usize = 1; -fn aiur_fn_760(inp: [G; IN_760], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_760], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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 __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(1).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(1).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_760] = [__v_8]; record.function_queries[760].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(760, &__args[..])?) { [G::ZERO; OUT_760] } else { let (__hash, __hit) = record.function_queries[760].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[760].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[760].bump_multiplicity(__i); } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => { aiur_fn_760::(__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(1).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_760] = [__v_7]; record.function_queries[760].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_761: usize = 1; -const IN_761: usize = 1; -const OUT_761: usize = 8; -fn aiur_fn_761(inp: [G; IN_761], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_761], ExecError> { stacker::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(7).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_761] = [__v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; record.function_queries[761].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(761, &__args[..])?) { [G::ZERO; OUT_761] } else { let (__hash, __hit) = record.function_queries[761].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[761].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[761].bump_multiplicity(__i); } let __ret: [G; OUT_761] = unsafe { *(record.function_queries[761].output_at(__i).as_ptr() as *const [G; OUT_761]) }; __ret }, _ => { aiur_fn_761::(__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 __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(16, &__args[..])?) { [G::ZERO; OUT_16] } else { let (__hash, __hit) = record.function_queries[16].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[16].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => { aiur_fn_16::(__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 __ret: [G; OUT_761] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; record.function_queries[761].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_762: usize = 1; -const IN_762: usize = 1; -const OUT_762: usize = 8; -fn aiur_fn_762(inp: [G; IN_762], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_762], ExecError> { stacker::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(1).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_762] = [__v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4, __v_4]; record.function_queries[762].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(762, &__args[..])?) { [G::ZERO; OUT_762] } else { let (__hash, __hit) = record.function_queries[762].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[762].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[762].bump_multiplicity(__i); } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => { aiur_fn_762::(__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 __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(16, &__args[..])?) { [G::ZERO; OUT_16] } else { let (__hash, __hit) = record.function_queries[16].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[16].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => { aiur_fn_16::(__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 __ret: [G; OUT_762] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; record.function_queries[762].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_763: usize = 8; -const IN_763: usize = 8; -const OUT_763: usize = 1; -fn aiur_fn_763(inp: [G; IN_763], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_763], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_763] = [__v_7]; record.function_queries[763].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(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; 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: 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]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; let __v_18: G = __loaded[4]; let __v_19: G = __loaded[5]; let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_20.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(763, &__args[..])?) { [G::ZERO; OUT_763] } else { let (__hash, __hit) = record.function_queries[763].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[763].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => { aiur_fn_763::(__args, __hash, record, io_buffer)? }, } } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_763] = [__v_21]; record.function_queries[763].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_21: G = __v_0 - __v_3; match __v_21.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_763] = [__v_4]; record.function_queries[763].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(763, &__args[..])?) { [G::ZERO; OUT_763] } else { let (__hash, __hit) = record.function_queries[763].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[763].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => { aiur_fn_763::(__args, __hash, record, io_buffer)? }, } } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_763] = [__v_22]; record.function_queries[763].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_764: usize = 1; -const IN_764: usize = 1; -const OUT_764: usize = 1; -fn aiur_fn_764(inp: [G; IN_764], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_764], ExecError> { stacker::maybe_grow(64 * 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(1); let __v_2: G = { let __values: [G; 3] = [__v_1, __v_1, __v_1]; let __mq = record.memory_queries.get_index_mut(1).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_781] = { let __args: [G; IN_781] = [__v_0, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(781, &__args[..])?) { [G::ZERO; OUT_781] } else { let (__hash, __hit) = record.function_queries[781].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[781].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[781].bump_multiplicity(__i); } let __ret: [G; OUT_781] = unsafe { *(record.function_queries[781].output_at(__i).as_ptr() as *const [G; OUT_781]) }; __ret }, _ => { aiur_fn_781::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_764] = [__v_3]; record.function_queries[764].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_765: usize = 2; -const IN_765: usize = 2; -const OUT_765: usize = 1; -fn aiur_fn_765(inp: [G; IN_765], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_765], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_765] = [__v_1]; record.function_queries[765].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(765, &__args[..])?) { [G::ZERO; OUT_765] } else { let (__hash, __hit) = record.function_queries[765].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[765].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => { aiur_fn_765::(__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(1).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_765] = [__v_7]; record.function_queries[765].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_766: usize = 1; -const IN_766: usize = 1; -const OUT_766: usize = 8; -fn aiur_fn_766(inp: [G; IN_766], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_766], ExecError> { stacker::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; 36] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(14).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(36))?; 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: 36 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = __loaded[32]; let __v_34: G = __loaded[33]; let __v_35: G = __loaded[34]; let __v_36: G = __loaded[35]; match __v_1.as_canonical_u64() { 1u64 => { let __v_37: G = G::from_u64(0); let __ret: [G; OUT_766] = [__v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; record.function_queries[766].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(766, &__args[..])?) { [G::ZERO; OUT_766] } else { let (__hash, __hit) = record.function_queries[766].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[766].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => { aiur_fn_766::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; let __v_40: G = __r_arr[3]; let __v_41: G = __r_arr[4]; let __v_42: G = __r_arr[5]; let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(16, &__args[..])?) { [G::ZERO; OUT_16] } else { let (__hash, __hit) = record.function_queries[16].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[16].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => { aiur_fn_16::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __v_47: G = __r_arr[2]; let __v_48: G = __r_arr[3]; let __v_49: G = __r_arr[4]; let __v_50: G = __r_arr[5]; let __v_51: G = __r_arr[6]; let __v_52: G = __r_arr[7]; let __ret: [G; OUT_766] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; record.function_queries[766].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_767: usize = 1; -const IN_767: usize = 1; -const OUT_767: usize = 1; -fn aiur_fn_767(inp: [G; IN_767], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_767], ExecError> { stacker::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(2).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_767] = [__v_5]; record.function_queries[767].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(767, &__args[..])?) { [G::ZERO; OUT_767] } else { let (__hash, __hit) = record.function_queries[767].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[767].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[767].bump_multiplicity(__i); } let __ret: [G; OUT_767] = unsafe { *(record.function_queries[767].output_at(__i).as_ptr() as *const [G; OUT_767]) }; __ret }, _ => { aiur_fn_767::(__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_767] = [__v_7]; record.function_queries[767].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_768: usize = 2; -const IN_768: usize = 2; -const OUT_768: usize = 1; -fn aiur_fn_768(inp: [G; IN_768], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_768], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_777] = { let __args: [G; IN_777] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__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(1).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_768] = [__v_4]; record.function_queries[768].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_769: usize = 9; -const IN_769: usize = 9; -const OUT_769: usize = 45; -fn aiur_fn_769(inp: [G; IN_769], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_769], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 47] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(15).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __v_17: G = __loaded[8]; let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; let __v_20: G = __loaded[11]; let __v_21: G = __loaded[12]; let __v_22: G = __loaded[13]; let __v_23: G = __loaded[14]; let __v_24: G = __loaded[15]; let __v_25: G = __loaded[16]; let __v_26: G = __loaded[17]; let __v_27: G = __loaded[18]; let __v_28: G = __loaded[19]; let __v_29: G = __loaded[20]; let __v_30: G = __loaded[21]; let __v_31: G = __loaded[22]; let __v_32: G = __loaded[23]; let __v_33: G = __loaded[24]; let __v_34: G = __loaded[25]; let __v_35: G = __loaded[26]; let __v_36: G = __loaded[27]; let __v_37: G = __loaded[28]; let __v_38: G = __loaded[29]; let __v_39: G = __loaded[30]; let __v_40: G = __loaded[31]; let __v_41: G = __loaded[32]; let __v_42: G = __loaded[33]; let __v_43: G = __loaded[34]; let __v_44: G = __loaded[35]; let __v_45: G = __loaded[36]; let __v_46: G = __loaded[37]; let __v_47: G = __loaded[38]; let __v_48: G = __loaded[39]; let __v_49: G = __loaded[40]; let __v_50: G = __loaded[41]; let __v_51: G = __loaded[42]; let __v_52: G = __loaded[43]; let __v_53: G = __loaded[44]; let __v_54: G = __loaded[45]; let __v_55: G = __loaded[46]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; match __v_56.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_769] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; record.function_queries[769].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(17, &__args[..])?) { [G::ZERO; OUT_17] } else { let (__hash, __hit) = record.function_queries[17].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[17].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => { aiur_fn_17::(__args, __hash, record, io_buffer)? }, } } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = __r_arr[2]; let __v_60: G = __r_arr[3]; let __v_61: G = __r_arr[4]; let __v_62: G = __r_arr[5]; let __v_63: G = __r_arr[6]; let __v_64: G = __r_arr[7]; let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(769, &__args[..])?) { [G::ZERO; OUT_769] } else { let (__hash, __hit) = record.function_queries[769].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[769].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[769].bump_multiplicity(__i); } let __ret: [G; OUT_769] = unsafe { *(record.function_queries[769].output_at(__i).as_ptr() as *const [G; OUT_769]) }; __ret }, _ => { aiur_fn_769::(__args, __hash, record, io_buffer)? }, } } }; let __v_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __v_67: G = __r_arr[2]; let __v_68: G = __r_arr[3]; let __v_69: G = __r_arr[4]; let __v_70: G = __r_arr[5]; let __v_71: G = __r_arr[6]; let __v_72: G = __r_arr[7]; let __v_73: G = __r_arr[8]; let __v_74: G = __r_arr[9]; let __v_75: G = __r_arr[10]; let __v_76: G = __r_arr[11]; let __v_77: G = __r_arr[12]; let __v_78: G = __r_arr[13]; let __v_79: G = __r_arr[14]; let __v_80: G = __r_arr[15]; let __v_81: G = __r_arr[16]; let __v_82: G = __r_arr[17]; let __v_83: G = __r_arr[18]; let __v_84: G = __r_arr[19]; let __v_85: G = __r_arr[20]; let __v_86: G = __r_arr[21]; let __v_87: G = __r_arr[22]; let __v_88: G = __r_arr[23]; let __v_89: G = __r_arr[24]; let __v_90: G = __r_arr[25]; let __v_91: G = __r_arr[26]; let __v_92: G = __r_arr[27]; let __v_93: G = __r_arr[28]; let __v_94: G = __r_arr[29]; let __v_95: G = __r_arr[30]; let __v_96: G = __r_arr[31]; let __v_97: G = __r_arr[32]; let __v_98: G = __r_arr[33]; let __v_99: G = __r_arr[34]; let __v_100: G = __r_arr[35]; let __v_101: G = __r_arr[36]; let __v_102: G = __r_arr[37]; let __v_103: G = __r_arr[38]; let __v_104: G = __r_arr[39]; let __v_105: G = __r_arr[40]; let __v_106: G = __r_arr[41]; let __v_107: G = __r_arr[42]; let __v_108: G = __r_arr[43]; let __v_109: G = __r_arr[44]; let __ret: [G; OUT_769] = [__v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109]; record.function_queries[769].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_56.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_770: usize = 1; -const IN_770: usize = 1; -const OUT_770: usize = 8; -fn aiur_fn_770(inp: [G; IN_770], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_770], ExecError> { stacker::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; 47] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(15).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; let __v_6: G = __loaded[5]; let __v_7: G = __loaded[6]; let __v_8: G = __loaded[7]; let __v_9: G = __loaded[8]; let __v_10: G = __loaded[9]; let __v_11: G = __loaded[10]; let __v_12: G = __loaded[11]; let __v_13: G = __loaded[12]; let __v_14: G = __loaded[13]; let __v_15: G = __loaded[14]; let __v_16: G = __loaded[15]; let __v_17: G = __loaded[16]; let __v_18: G = __loaded[17]; let __v_19: G = __loaded[18]; let __v_20: G = __loaded[19]; let __v_21: G = __loaded[20]; let __v_22: G = __loaded[21]; let __v_23: G = __loaded[22]; let __v_24: G = __loaded[23]; let __v_25: G = __loaded[24]; let __v_26: G = __loaded[25]; let __v_27: G = __loaded[26]; let __v_28: G = __loaded[27]; let __v_29: G = __loaded[28]; let __v_30: G = __loaded[29]; let __v_31: G = __loaded[30]; let __v_32: G = __loaded[31]; let __v_33: G = __loaded[32]; let __v_34: G = __loaded[33]; let __v_35: G = __loaded[34]; let __v_36: G = __loaded[35]; let __v_37: G = __loaded[36]; let __v_38: G = __loaded[37]; let __v_39: G = __loaded[38]; let __v_40: G = __loaded[39]; let __v_41: G = __loaded[40]; let __v_42: G = __loaded[41]; let __v_43: G = __loaded[42]; let __v_44: G = __loaded[43]; let __v_45: G = __loaded[44]; let __v_46: G = __loaded[45]; let __v_47: G = __loaded[46]; match __v_1.as_canonical_u64() { 1u64 => { let __v_48: G = G::from_u64(0); let __ret: [G; OUT_770] = [__v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; record.function_queries[770].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_47]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(770, &__args[..])?) { [G::ZERO; OUT_770] } else { let (__hash, __hit) = record.function_queries[770].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[770].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[770].bump_multiplicity(__i); } let __ret: [G; OUT_770] = unsafe { *(record.function_queries[770].output_at(__i).as_ptr() as *const [G; OUT_770]) }; __ret }, _ => { aiur_fn_770::(__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 = __r_arr[4]; let __v_53: G = __r_arr[5]; let __v_54: G = __r_arr[6]; let __v_55: G = __r_arr[7]; let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(16, &__args[..])?) { [G::ZERO; OUT_16] } else { let (__hash, __hit) = record.function_queries[16].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[16].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => { aiur_fn_16::(__args, __hash, record, io_buffer)? }, } } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __v_58: G = __r_arr[2]; let __v_59: G = __r_arr[3]; let __v_60: G = __r_arr[4]; let __v_61: G = __r_arr[5]; let __v_62: G = __r_arr[6]; let __v_63: G = __r_arr[7]; let __ret: [G; OUT_770] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; record.function_queries[770].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_771: usize = 1; -const IN_771: usize = 1; -const OUT_771: usize = 8; -fn aiur_fn_771(inp: [G; IN_771], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_771], ExecError> { stacker::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(8).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_771] = [__v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; record.function_queries[771].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(771, &__args[..])?) { [G::ZERO; OUT_771] } else { let (__hash, __hit) = record.function_queries[771].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[771].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[771].bump_multiplicity(__i); } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => { aiur_fn_771::(__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 __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(16, &__args[..])?) { [G::ZERO; OUT_16] } else { let (__hash, __hit) = record.function_queries[16].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[16].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => { aiur_fn_16::(__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 __ret: [G; OUT_771] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; record.function_queries[771].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_772: usize = 9; -const IN_772: usize = 9; -const OUT_772: usize = 34; -fn aiur_fn_772(inp: [G; IN_772], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_772], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 36] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(14).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(36))?; 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: 36 })?; if (!unconstrained) { __mq.bump_multiplicity(__idx); } let (__args, _) = __mq.get_index(__idx).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __v_17: G = __loaded[8]; let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; let __v_20: G = __loaded[11]; let __v_21: G = __loaded[12]; let __v_22: G = __loaded[13]; let __v_23: G = __loaded[14]; let __v_24: G = __loaded[15]; let __v_25: G = __loaded[16]; let __v_26: G = __loaded[17]; let __v_27: G = __loaded[18]; let __v_28: G = __loaded[19]; let __v_29: G = __loaded[20]; let __v_30: G = __loaded[21]; let __v_31: G = __loaded[22]; let __v_32: G = __loaded[23]; let __v_33: G = __loaded[24]; let __v_34: G = __loaded[25]; let __v_35: G = __loaded[26]; let __v_36: G = __loaded[27]; let __v_37: G = __loaded[28]; let __v_38: G = __loaded[29]; let __v_39: G = __loaded[30]; let __v_40: G = __loaded[31]; let __v_41: G = __loaded[32]; let __v_42: G = __loaded[33]; let __v_43: G = __loaded[34]; let __v_44: G = __loaded[35]; match __v_9.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(6, &__args[..])?) { [G::ZERO; OUT_6] } else { let (__hash, __hit) = record.function_queries[6].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[6].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[6].bump_multiplicity(__i); } let __ret: [G; OUT_6] = unsafe { *(record.function_queries[6].output_at(__i).as_ptr() as *const [G; OUT_6]) }; __ret }, _ => { aiur_fn_6::(__args, __hash, record, io_buffer)? }, } } }; let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_772] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; record.function_queries[772].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(17, &__args[..])?) { [G::ZERO; OUT_17] } else { let (__hash, __hit) = record.function_queries[17].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[17].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => { aiur_fn_17::(__args, __hash, record, io_buffer)? }, } } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = __r_arr[2]; let __v_49: G = __r_arr[3]; let __v_50: G = __r_arr[4]; let __v_51: G = __r_arr[5]; let __v_52: G = __r_arr[6]; let __v_53: G = __r_arr[7]; let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(772, &__args[..])?) { [G::ZERO; OUT_772] } else { let (__hash, __hit) = record.function_queries[772].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[772].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[772].bump_multiplicity(__i); } let __ret: [G; OUT_772] = unsafe { *(record.function_queries[772].output_at(__i).as_ptr() as *const [G; OUT_772]) }; __ret }, _ => { aiur_fn_772::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; let __v_57: G = __r_arr[3]; let __v_58: G = __r_arr[4]; let __v_59: G = __r_arr[5]; let __v_60: G = __r_arr[6]; let __v_61: G = __r_arr[7]; let __v_62: G = __r_arr[8]; let __v_63: G = __r_arr[9]; let __v_64: G = __r_arr[10]; let __v_65: G = __r_arr[11]; let __v_66: G = __r_arr[12]; let __v_67: G = __r_arr[13]; let __v_68: G = __r_arr[14]; let __v_69: G = __r_arr[15]; let __v_70: G = __r_arr[16]; let __v_71: G = __r_arr[17]; let __v_72: G = __r_arr[18]; let __v_73: G = __r_arr[19]; let __v_74: G = __r_arr[20]; let __v_75: G = __r_arr[21]; let __v_76: G = __r_arr[22]; let __v_77: G = __r_arr[23]; let __v_78: G = __r_arr[24]; let __v_79: G = __r_arr[25]; let __v_80: G = __r_arr[26]; let __v_81: G = __r_arr[27]; let __v_82: G = __r_arr[28]; let __v_83: G = __r_arr[29]; let __v_84: G = __r_arr[30]; let __v_85: G = __r_arr[31]; let __v_86: G = __r_arr[32]; let __v_87: G = __r_arr[33]; let __ret: [G; OUT_772] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; record.function_queries[772].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); }, } }) } -const INPUT_SIZE_773: usize = 1; -const IN_773: usize = 1; -const OUT_773: usize = 1; -fn aiur_fn_773(inp: [G; IN_773], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_773], ExecError> { stacker::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(1).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_773] = [__v_4]; record.function_queries[773].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_773] = [__v_4]; record.function_queries[773].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_774: usize = 5; -const IN_774: usize = 5; -const OUT_774: usize = 1; -fn aiur_fn_774(inp: [G; IN_774], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_774], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_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() { 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 6] = [__v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_index_mut(4).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_14: G = { let __values: [G; 6] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_774] = [__v_14]; record.function_queries[774].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(774, &__args[..])?) { [G::ZERO; OUT_774] } else { let (__hash, __hit) = record.function_queries[774].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[774].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => { aiur_fn_774::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 6] = [__v_11, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_index_mut(4).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_774] = [__v_13]; record.function_queries[774].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_775: usize = 1; -const IN_775: usize = 1; -const OUT_775: usize = 1; -fn aiur_fn_775(inp: [G; IN_775], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_775], ExecError> { stacker::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(1).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_775] = [__v_4]; record.function_queries[775].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(775, &__args[..])?) { [G::ZERO; OUT_775] } else { let (__hash, __hit) = record.function_queries[775].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[775].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => { aiur_fn_775::(__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_775] = [__v_6]; record.function_queries[775].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_776: usize = 2; -const IN_776: usize = 2; -const OUT_776: usize = 1; -fn aiur_fn_776(inp: [G; IN_776], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_776], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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(1).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_776] = [__v_3]; record.function_queries[776].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(1).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_776] = { let __args: [G; IN_776] = [__v_4, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(776, &__args[..])?) { [G::ZERO; OUT_776] } else { let (__hash, __hit) = record.function_queries[776].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[776].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[776].bump_multiplicity(__i); } let __ret: [G; OUT_776] = unsafe { *(record.function_queries[776].output_at(__i).as_ptr() as *const [G; OUT_776]) }; __ret }, _ => { aiur_fn_776::(__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(1).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_776] = [__v_9]; record.function_queries[776].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_777: usize = 2; -const IN_777: usize = 2; -const OUT_777: usize = 1; -fn aiur_fn_777(inp: [G; IN_777], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_777], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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_777] = [__v_0]; record.function_queries[777].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_777] = { let __args: [G; IN_777] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(777, &__args[..])?) { [G::ZERO; OUT_777] } else { let (__hash, __hit) = record.function_queries[777].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[777].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => { aiur_fn_777::(__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(1).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_777] = [__v_7]; record.function_queries[777].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_778: usize = 1; -const IN_778: usize = 1; -const OUT_778: usize = 1; -fn aiur_fn_778(inp: [G; IN_778], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_778], ExecError> { stacker::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(3).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_778] = [__v_6]; record.function_queries[778].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(778, &__args[..])?) { [G::ZERO; OUT_778] } else { let (__hash, __hit) = record.function_queries[778].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[778].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[778].bump_multiplicity(__i); } let __ret: [G; OUT_778] = unsafe { *(record.function_queries[778].output_at(__i).as_ptr() as *const [G; OUT_778]) }; __ret }, _ => { aiur_fn_778::(__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_778] = [__v_8]; record.function_queries[778].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_779: usize = 8; -const IN_779: usize = 8; -const OUT_779: usize = 6; -fn aiur_fn_779(inp: [G; IN_779], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_779], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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 __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(782, &__args[..])?) { [G::ZERO; OUT_782] } else { let (__hash, __hit) = record.function_queries[782].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[782].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => { aiur_fn_782::(__args, __hash, record, io_buffer)? }, } } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; let __v_11: G = __r_arr[3]; let __v_12: G = __r_arr[4]; let __v_13: G = __r_arr[5]; match __v_8.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __ret: [G; OUT_779] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; record.function_queries[779].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } -const INPUT_SIZE_780: usize = 1; -const IN_780: usize = 1; -const OUT_780: usize = 1; -fn aiur_fn_780(inp: [G; IN_780], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_780], ExecError> { stacker::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(4).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_780] = [__v_7]; record.function_queries[780].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(780, &__args[..])?) { [G::ZERO; OUT_780] } else { let (__hash, __hit) = record.function_queries[780].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[780].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => { aiur_fn_780::(__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_780] = [__v_9]; record.function_queries[780].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_781: usize = 2; -const IN_781: usize = 2; -const OUT_781: usize = 1; -fn aiur_fn_781(inp: [G; IN_781], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_781], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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(1).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_781] = [__v_1]; record.function_queries[781].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(1).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_781] = { let __args: [G; IN_781] = [__v_4, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(781, &__args[..])?) { [G::ZERO; OUT_781] } else { let (__hash, __hit) = record.function_queries[781].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[781].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[781].bump_multiplicity(__i); } let __ret: [G; OUT_781] = unsafe { *(record.function_queries[781].output_at(__i).as_ptr() as *const [G; OUT_781]) }; __ret }, _ => { aiur_fn_781::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_781] = [__v_7]; record.function_queries[781].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_782: usize = 8; -const IN_782: usize = 8; -const OUT_782: usize = 6; -fn aiur_fn_782(inp: [G; IN_782], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_782], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_2.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); 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(4).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_782] = [__v_8, __v_8, __v_0, __v_1, __v_10, __v_10]; record.function_queries[782].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(4).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_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; 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: 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]; let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if (!unconstrained) { let __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_20.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(782, &__args[..])?) { [G::ZERO; OUT_782] } else { let (__hash, __hit) = record.function_queries[782].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[782].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => { aiur_fn_782::(__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 __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(783, &__args[..])?) { [G::ZERO; OUT_783] } else { let (__hash, __hit) = record.function_queries[783].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[783].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[783].bump_multiplicity(__i); } let __ret: [G; OUT_783] = unsafe { *(record.function_queries[783].output_at(__i).as_ptr() as *const [G; OUT_783]) }; __ret }, _ => { aiur_fn_783::(__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 __ret: [G; OUT_782] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; record.function_queries[782].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_21: G = __v_0 - __v_4; match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_24: G = { let __values: [G; 6] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_index_mut(4).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_782] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; record.function_queries[782].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(782, &__args[..])?) { [G::ZERO; OUT_782] } else { let (__hash, __hit) = record.function_queries[782].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[782].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => { aiur_fn_782::(__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 __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(783, &__args[..])?) { [G::ZERO; OUT_783] } else { let (__hash, __hit) = record.function_queries[783].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[783].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[783].bump_multiplicity(__i); } let __ret: [G; OUT_783] = unsafe { *(record.function_queries[783].output_at(__i).as_ptr() as *const [G; OUT_783]) }; __ret }, _ => { aiur_fn_783::(__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 __ret: [G; OUT_782] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; record.function_queries[782].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_783: usize = 15; -const IN_783: usize = 15; -const OUT_783: usize = 6; -fn aiur_fn_783(inp: [G; IN_783], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_783], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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_0.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_1, __v_2, __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(784, &__args[..])?) { [G::ZERO; OUT_784] } else { let (__hash, __hit) = record.function_queries[784].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[784].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[784].bump_multiplicity(__i); } let __ret: [G; OUT_784] = unsafe { *(record.function_queries[784].output_at(__i).as_ptr() as *const [G; OUT_784]) }; __ret }, _ => { aiur_fn_784::(__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 __ret: [G; OUT_783] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; record.function_queries[783].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 6] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_index_mut(4).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_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __mq = record.memory_queries.get_index_mut(4).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_783] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; record.function_queries[783].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_784: usize = 14; -const IN_784: usize = 14; -const OUT_784: usize = 6; -fn aiur_fn_784(inp: [G; IN_784], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_784], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 1024) * 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]; match __v_2.as_canonical_u64() { 0u64 => { match __v_3.as_canonical_u64() { 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; let __v_18: G = __loaded[4]; let __v_19: G = __loaded[5]; match __v_14.as_canonical_u64() { 0u64 => { match __v_15.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 6] = [__v_20, __v_21, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_index_mut(4).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_23: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_24: G = { let __values: [G; 6] = [__v_20, __v_21, __v_0, __v_1, __v_7, __v_23]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_20, __v_20, __v_4, __v_5, __v_22, __v_24]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; 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: 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_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; let __v_23: G = __loaded[3]; let __v_24: G = __loaded[4]; let __v_25: G = __loaded[5]; match __v_20.as_canonical_u64() { 0u64 => { match __v_21.as_canonical_u64() { 0u64 => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_30: G = { let __values: [G; 6] = [__v_26, __v_27, __v_0, __v_1, __v_25, __v_29]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_26, __v_22, __v_23, __v_28, __v_30]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { match __v_8.as_canonical_u64() { 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; let __v_29: G = __loaded[3]; let __v_30: G = __loaded[4]; let __v_31: G = __loaded[5]; match __v_26.as_canonical_u64() { 0u64 => { match __v_27.as_canonical_u64() { 0u64 => { let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); let __v_34: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_35: G = { let __values: [G; 6] = [__v_32, __v_33, __v_0, __v_1, __v_34, __v_30]; let __mq = record.memory_queries.get_index_mut(4).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_36: G = { let __values: [G; 6] = [__v_32, __v_33, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_32, __v_32, __v_28, __v_29, __v_35, __v_36]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; let __v_35: G = __loaded[3]; let __v_36: G = __loaded[4]; let __v_37: G = __loaded[5]; match __v_32.as_canonical_u64() { 0u64 => { match __v_33.as_canonical_u64() { 0u64 => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_12]; let __mq = record.memory_queries.get_index_mut(4).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_42: G = { let __values: [G; 6] = [__v_38, __v_39, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; let __v_35: G = __loaded[3]; let __v_36: G = __loaded[4]; let __v_37: G = __loaded[5]; match __v_32.as_canonical_u64() { 0u64 => { match __v_33.as_canonical_u64() { 0u64 => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_12]; let __mq = record.memory_queries.get_index_mut(4).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_42: G = { let __values: [G; 6] = [__v_38, __v_39, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_8.as_canonical_u64() { 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; let __v_29: G = __loaded[3]; let __v_30: G = __loaded[4]; let __v_31: G = __loaded[5]; match __v_26.as_canonical_u64() { 0u64 => { match __v_27.as_canonical_u64() { 0u64 => { let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); let __v_34: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_35: G = { let __values: [G; 6] = [__v_32, __v_33, __v_0, __v_1, __v_34, __v_30]; let __mq = record.memory_queries.get_index_mut(4).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_36: G = { let __values: [G; 6] = [__v_32, __v_33, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_32, __v_32, __v_28, __v_29, __v_35, __v_36]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; let __v_35: G = __loaded[3]; let __v_36: G = __loaded[4]; let __v_37: G = __loaded[5]; match __v_32.as_canonical_u64() { 0u64 => { match __v_33.as_canonical_u64() { 0u64 => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_12]; let __mq = record.memory_queries.get_index_mut(4).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_42: G = { let __values: [G; 6] = [__v_38, __v_39, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; let __v_35: G = __loaded[3]; let __v_36: G = __loaded[4]; let __v_37: G = __loaded[5]; match __v_32.as_canonical_u64() { 0u64 => { match __v_33.as_canonical_u64() { 0u64 => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_12]; let __mq = record.memory_queries.get_index_mut(4).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_42: G = { let __values: [G; 6] = [__v_38, __v_39, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(6))?; 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: 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_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; let __v_23: G = __loaded[3]; let __v_24: G = __loaded[4]; let __v_25: G = __loaded[5]; match __v_20.as_canonical_u64() { 0u64 => { match __v_21.as_canonical_u64() { 0u64 => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_30: G = { let __values: [G; 6] = [__v_26, __v_27, __v_0, __v_1, __v_25, __v_29]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_26, __v_22, __v_23, __v_28, __v_30]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { match __v_8.as_canonical_u64() { 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; let __v_29: G = __loaded[3]; let __v_30: G = __loaded[4]; let __v_31: G = __loaded[5]; match __v_26.as_canonical_u64() { 0u64 => { match __v_27.as_canonical_u64() { 0u64 => { let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); let __v_34: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_35: G = { let __values: [G; 6] = [__v_32, __v_33, __v_0, __v_1, __v_34, __v_30]; let __mq = record.memory_queries.get_index_mut(4).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_36: G = { let __values: [G; 6] = [__v_32, __v_33, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_32, __v_32, __v_28, __v_29, __v_35, __v_36]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; let __v_35: G = __loaded[3]; let __v_36: G = __loaded[4]; let __v_37: G = __loaded[5]; match __v_32.as_canonical_u64() { 0u64 => { match __v_33.as_canonical_u64() { 0u64 => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_12]; let __mq = record.memory_queries.get_index_mut(4).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_42: G = { let __values: [G; 6] = [__v_38, __v_39, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; let __v_35: G = __loaded[3]; let __v_36: G = __loaded[4]; let __v_37: G = __loaded[5]; match __v_32.as_canonical_u64() { 0u64 => { match __v_33.as_canonical_u64() { 0u64 => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_12]; let __mq = record.memory_queries.get_index_mut(4).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_42: G = { let __values: [G; 6] = [__v_38, __v_39, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_8.as_canonical_u64() { 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; let __v_29: G = __loaded[3]; let __v_30: G = __loaded[4]; let __v_31: G = __loaded[5]; match __v_26.as_canonical_u64() { 0u64 => { match __v_27.as_canonical_u64() { 0u64 => { let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); let __v_34: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_35: G = { let __values: [G; 6] = [__v_32, __v_33, __v_0, __v_1, __v_34, __v_30]; let __mq = record.memory_queries.get_index_mut(4).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_36: G = { let __values: [G; 6] = [__v_32, __v_33, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_32, __v_32, __v_28, __v_29, __v_35, __v_36]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; let __v_35: G = __loaded[3]; let __v_36: G = __loaded[4]; let __v_37: G = __loaded[5]; match __v_32.as_canonical_u64() { 0u64 => { match __v_33.as_canonical_u64() { 0u64 => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_12]; let __mq = record.memory_queries.get_index_mut(4).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_42: G = { let __values: [G; 6] = [__v_38, __v_39, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; let __v_35: G = __loaded[3]; let __v_36: G = __loaded[4]; let __v_37: G = __loaded[5]; match __v_32.as_canonical_u64() { 0u64 => { match __v_33.as_canonical_u64() { 0u64 => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_12]; let __mq = record.memory_queries.get_index_mut(4).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_42: G = { let __values: [G; 6] = [__v_38, __v_39, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_38, __v_10, __v_11, __v_41, __v_42]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { match __v_8.as_canonical_u64() { 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; let __v_18: G = __loaded[4]; let __v_19: G = __loaded[5]; match __v_14.as_canonical_u64() { 0u64 => { match __v_15.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_23: G = { let __values: [G; 6] = [__v_20, __v_21, __v_0, __v_1, __v_22, __v_18]; let __mq = record.memory_queries.get_index_mut(4).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_24: G = { let __values: [G; 6] = [__v_20, __v_21, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_20, __v_20, __v_16, __v_17, __v_23, __v_24]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; let __v_23: G = __loaded[3]; let __v_24: G = __loaded[4]; let __v_25: G = __loaded[5]; match __v_20.as_canonical_u64() { 0u64 => { match __v_21.as_canonical_u64() { 0u64 => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_12]; let __mq = record.memory_queries.get_index_mut(4).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_30: G = { let __values: [G; 6] = [__v_26, __v_27, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_26, __v_10, __v_11, __v_29, __v_30]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; let __v_23: G = __loaded[3]; let __v_24: G = __loaded[4]; let __v_25: G = __loaded[5]; match __v_20.as_canonical_u64() { 0u64 => { match __v_21.as_canonical_u64() { 0u64 => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_12]; let __mq = record.memory_queries.get_index_mut(4).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_30: G = { let __values: [G; 6] = [__v_26, __v_27, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_26, __v_10, __v_11, __v_29, __v_30]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { match __v_8.as_canonical_u64() { 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; let __v_18: G = __loaded[4]; let __v_19: G = __loaded[5]; match __v_14.as_canonical_u64() { 0u64 => { match __v_15.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_23: G = { let __values: [G; 6] = [__v_20, __v_21, __v_0, __v_1, __v_22, __v_18]; let __mq = record.memory_queries.get_index_mut(4).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_24: G = { let __values: [G; 6] = [__v_20, __v_21, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_20, __v_20, __v_16, __v_17, __v_23, __v_24]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; let __v_23: G = __loaded[3]; let __v_24: G = __loaded[4]; let __v_25: G = __loaded[5]; match __v_20.as_canonical_u64() { 0u64 => { match __v_21.as_canonical_u64() { 0u64 => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_12]; let __mq = record.memory_queries.get_index_mut(4).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_30: G = { let __values: [G; 6] = [__v_26, __v_27, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_26, __v_10, __v_11, __v_29, __v_30]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __loaded: [G; 6] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(4).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_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; let __v_23: G = __loaded[3]; let __v_24: G = __loaded[4]; let __v_25: G = __loaded[5]; match __v_20.as_canonical_u64() { 0u64 => { match __v_21.as_canonical_u64() { 0u64 => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_12]; let __mq = record.memory_queries.get_index_mut(4).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_30: G = { let __values: [G; 6] = [__v_26, __v_27, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_26, __v_10, __v_11, __v_29, __v_30]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_index_mut(4).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_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_index_mut(4).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_784] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; record.function_queries[784].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -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(2)) { return Err(ExecError::InvalidMemorySize(2)); } if (record.memory_queries.get_index(1).map(|(size, _)| (*size)) != Some(3)) { return Err(ExecError::InvalidMemorySize(3)); } if (record.memory_queries.get_index(2).map(|(size, _)| (*size)) != Some(4)) { return Err(ExecError::InvalidMemorySize(4)); } if (record.memory_queries.get_index(3).map(|(size, _)| (*size)) != Some(5)) { return Err(ExecError::InvalidMemorySize(5)); } if (record.memory_queries.get_index(4).map(|(size, _)| (*size)) != Some(6)) { return Err(ExecError::InvalidMemorySize(6)); } 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(9)) { return Err(ExecError::InvalidMemorySize(9)); } if (record.memory_queries.get_index(7).map(|(size, _)| (*size)) != Some(10)) { return Err(ExecError::InvalidMemorySize(10)); } if (record.memory_queries.get_index(8).map(|(size, _)| (*size)) != Some(11)) { return Err(ExecError::InvalidMemorySize(11)); } if (record.memory_queries.get_index(9).map(|(size, _)| (*size)) != Some(12)) { return Err(ExecError::InvalidMemorySize(12)); } if (record.memory_queries.get_index(10).map(|(size, _)| (*size)) != Some(18)) { return Err(ExecError::InvalidMemorySize(18)); } if (record.memory_queries.get_index(11).map(|(size, _)| (*size)) != Some(19)) { return Err(ExecError::InvalidMemorySize(19)); } if (record.memory_queries.get_index(12).map(|(size, _)| (*size)) != Some(32)) { return Err(ExecError::InvalidMemorySize(32)); } if (record.memory_queries.get_index(13).map(|(size, _)| (*size)) != Some(34)) { return Err(ExecError::InvalidMemorySize(34)); } if (record.memory_queries.get_index(14).map(|(size, _)| (*size)) != Some(36)) { return Err(ExecError::InvalidMemorySize(36)); } if (record.memory_queries.get_index(15).map(|(size, _)| (*size)) != Some(47)) { return Err(ExecError::InvalidMemorySize(47)); } if (record.memory_queries.get_index(16).map(|(size, _)| (*size)) != Some(50)) { return Err(ExecError::InvalidMemorySize(50)); } if (record.memory_queries.get_index(17).map(|(size, _)| (*size)) != Some(64)) { return Err(ExecError::InvalidMemorySize(64)); } 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()); }, 256u64 => { let __inp: [G; IN_256] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_256::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 257u64 => { let __inp: [G; IN_257] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_257::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 258u64 => { let __inp: [G; IN_258] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_258::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 259u64 => { let __inp: [G; IN_259] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_259::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 260u64 => { let __inp: [G; IN_260] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_260::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 261u64 => { let __inp: [G; IN_261] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_261::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 262u64 => { let __inp: [G; IN_262] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_262::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 263u64 => { let __inp: [G; IN_263] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_263::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 264u64 => { let __inp: [G; IN_264] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_264::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 265u64 => { let __inp: [G; IN_265] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_265::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 266u64 => { let __inp: [G; IN_266] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_266::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 267u64 => { let __inp: [G; IN_267] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_267::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 268u64 => { let __inp: [G; IN_268] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_268::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 269u64 => { let __inp: [G; IN_269] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_269::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 270u64 => { let __inp: [G; IN_270] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_270::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 271u64 => { let __inp: [G; IN_271] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_271::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 272u64 => { let __inp: [G; IN_272] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_272::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 273u64 => { let __inp: [G; IN_273] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_273::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 274u64 => { let __inp: [G; IN_274] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_274::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 275u64 => { let __inp: [G; IN_275] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_275::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 276u64 => { let __inp: [G; IN_276] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_276::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 277u64 => { let __inp: [G; IN_277] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_277::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 278u64 => { let __inp: [G; IN_278] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_278::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 279u64 => { let __inp: [G; IN_279] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_279::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 280u64 => { let __inp: [G; IN_280] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_280::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 281u64 => { let __inp: [G; IN_281] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_281::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 282u64 => { let __inp: [G; IN_282] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_282::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 283u64 => { let __inp: [G; IN_283] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_283::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 284u64 => { let __inp: [G; IN_284] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_284::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 285u64 => { let __inp: [G; IN_285] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_285::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 286u64 => { let __inp: [G; IN_286] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_286::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 287u64 => { let __inp: [G; IN_287] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_287::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 288u64 => { let __inp: [G; IN_288] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_288::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 289u64 => { let __inp: [G; IN_289] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_289::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 290u64 => { let __inp: [G; IN_290] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_290::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 291u64 => { let __inp: [G; IN_291] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_291::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 292u64 => { let __inp: [G; IN_292] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_292::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 293u64 => { let __inp: [G; IN_293] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_293::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 294u64 => { let __inp: [G; IN_294] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_294::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 295u64 => { let __inp: [G; IN_295] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_295::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 296u64 => { let __inp: [G; IN_296] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_296::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 297u64 => { let __inp: [G; IN_297] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_297::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 298u64 => { let __inp: [G; IN_298] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_298::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 299u64 => { let __inp: [G; IN_299] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_299::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 300u64 => { let __inp: [G; IN_300] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_300::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 301u64 => { let __inp: [G; IN_301] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_301::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 302u64 => { let __inp: [G; IN_302] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_302::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 303u64 => { let __inp: [G; IN_303] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_303::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 304u64 => { let __inp: [G; IN_304] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_304::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 305u64 => { let __inp: [G; IN_305] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_305::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 306u64 => { let __inp: [G; IN_306] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_306::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 307u64 => { let __inp: [G; IN_307] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_307::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 308u64 => { let __inp: [G; IN_308] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_308::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 309u64 => { let __inp: [G; IN_309] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_309::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 310u64 => { let __inp: [G; IN_310] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_310::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 311u64 => { let __inp: [G; IN_311] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_311::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 312u64 => { let __inp: [G; IN_312] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_312::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 313u64 => { let __inp: [G; IN_313] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_313::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 314u64 => { let __inp: [G; IN_314] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_314::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 315u64 => { let __inp: [G; IN_315] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_315::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 316u64 => { let __inp: [G; IN_316] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_316::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 317u64 => { let __inp: [G; IN_317] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_317::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 318u64 => { let __inp: [G; IN_318] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_318::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 319u64 => { let __inp: [G; IN_319] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_319::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 320u64 => { let __inp: [G; IN_320] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_320::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 321u64 => { let __inp: [G; IN_321] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_321::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 322u64 => { let __inp: [G; IN_322] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_322::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 323u64 => { let __inp: [G; IN_323] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_323::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 324u64 => { let __inp: [G; IN_324] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_324::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 325u64 => { let __inp: [G; IN_325] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_325::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 326u64 => { let __inp: [G; IN_326] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_326::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 327u64 => { let __inp: [G; IN_327] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_327::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 328u64 => { let __inp: [G; IN_328] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_328::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 329u64 => { let __inp: [G; IN_329] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_329::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 330u64 => { let __inp: [G; IN_330] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_330::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 331u64 => { let __inp: [G; IN_331] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_331::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 332u64 => { let __inp: [G; IN_332] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_332::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 333u64 => { let __inp: [G; IN_333] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_333::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 334u64 => { let __inp: [G; IN_334] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_334::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 335u64 => { let __inp: [G; IN_335] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_335::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 336u64 => { let __inp: [G; IN_336] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_336::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 337u64 => { let __inp: [G; IN_337] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_337::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 338u64 => { let __inp: [G; IN_338] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_338::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 339u64 => { let __inp: [G; IN_339] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_339::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 340u64 => { let __inp: [G; IN_340] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_340::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 341u64 => { let __inp: [G; IN_341] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_341::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 342u64 => { let __inp: [G; IN_342] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_342::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 343u64 => { let __inp: [G; IN_343] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_343::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 344u64 => { let __inp: [G; IN_344] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_344::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 345u64 => { let __inp: [G; IN_345] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_345::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 346u64 => { let __inp: [G; IN_346] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_346::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 347u64 => { let __inp: [G; IN_347] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_347::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 348u64 => { let __inp: [G; IN_348] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_348::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 349u64 => { let __inp: [G; IN_349] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_349::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 350u64 => { let __inp: [G; IN_350] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_350::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 351u64 => { let __inp: [G; IN_351] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_351::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 352u64 => { let __inp: [G; IN_352] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_352::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 353u64 => { let __inp: [G; IN_353] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_353::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 354u64 => { let __inp: [G; IN_354] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_354::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 355u64 => { let __inp: [G; IN_355] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_355::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 356u64 => { let __inp: [G; IN_356] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_356::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 357u64 => { let __inp: [G; IN_357] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_357::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 358u64 => { let __inp: [G; IN_358] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_358::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 359u64 => { let __inp: [G; IN_359] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_359::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 360u64 => { let __inp: [G; IN_360] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_360::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 361u64 => { let __inp: [G; IN_361] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_361::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 362u64 => { let __inp: [G; IN_362] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_362::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 363u64 => { let __inp: [G; IN_363] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_363::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 364u64 => { let __inp: [G; IN_364] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_364::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 365u64 => { let __inp: [G; IN_365] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_365::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 366u64 => { let __inp: [G; IN_366] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_366::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 367u64 => { let __inp: [G; IN_367] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_367::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 368u64 => { let __inp: [G; IN_368] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_368::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 369u64 => { let __inp: [G; IN_369] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_369::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 370u64 => { let __inp: [G; IN_370] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_370::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 371u64 => { let __inp: [G; IN_371] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_371::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 372u64 => { let __inp: [G; IN_372] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_372::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 373u64 => { let __inp: [G; IN_373] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_373::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 374u64 => { let __inp: [G; IN_374] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_374::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 375u64 => { let __inp: [G; IN_375] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_375::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 376u64 => { let __inp: [G; IN_376] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_376::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 377u64 => { let __inp: [G; IN_377] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_377::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 378u64 => { let __inp: [G; IN_378] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_378::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 379u64 => { let __inp: [G; IN_379] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_379::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 380u64 => { let __inp: [G; IN_380] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_380::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 381u64 => { let __inp: [G; IN_381] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_381::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 382u64 => { let __inp: [G; IN_382] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_382::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 383u64 => { let __inp: [G; IN_383] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_383::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 384u64 => { let __inp: [G; IN_384] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_384::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 385u64 => { let __inp: [G; IN_385] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_385::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 386u64 => { let __inp: [G; IN_386] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_386::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 387u64 => { let __inp: [G; IN_387] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_387::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 388u64 => { let __inp: [G; IN_388] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_388::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 389u64 => { let __inp: [G; IN_389] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_389::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 390u64 => { let __inp: [G; IN_390] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_390::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 391u64 => { let __inp: [G; IN_391] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_391::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 392u64 => { let __inp: [G; IN_392] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_392::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 393u64 => { let __inp: [G; IN_393] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_393::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 394u64 => { let __inp: [G; IN_394] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_394::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 395u64 => { let __inp: [G; IN_395] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_395::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 396u64 => { let __inp: [G; IN_396] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_396::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 397u64 => { let __inp: [G; IN_397] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_397::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 398u64 => { let __inp: [G; IN_398] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_398::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 399u64 => { let __inp: [G; IN_399] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_399::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 400u64 => { let __inp: [G; IN_400] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_400::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 401u64 => { let __inp: [G; IN_401] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_401::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 402u64 => { let __inp: [G; IN_402] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_402::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 403u64 => { let __inp: [G; IN_403] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_403::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 404u64 => { let __inp: [G; IN_404] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_404::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 405u64 => { let __inp: [G; IN_405] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_405::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 406u64 => { let __inp: [G; IN_406] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_406::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 407u64 => { let __inp: [G; IN_407] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_407::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 408u64 => { let __inp: [G; IN_408] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_408::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 409u64 => { let __inp: [G; IN_409] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_409::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 410u64 => { let __inp: [G; IN_410] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_410::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 411u64 => { let __inp: [G; IN_411] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_411::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 412u64 => { let __inp: [G; IN_412] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_412::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 413u64 => { let __inp: [G; IN_413] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_413::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 414u64 => { let __inp: [G; IN_414] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_414::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 415u64 => { let __inp: [G; IN_415] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_415::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 416u64 => { let __inp: [G; IN_416] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_416::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 417u64 => { let __inp: [G; IN_417] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_417::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 418u64 => { let __inp: [G; IN_418] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_418::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 419u64 => { let __inp: [G; IN_419] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_419::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 420u64 => { let __inp: [G; IN_420] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_420::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 421u64 => { let __inp: [G; IN_421] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_421::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 422u64 => { let __inp: [G; IN_422] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_422::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 423u64 => { let __inp: [G; IN_423] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_423::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 424u64 => { let __inp: [G; IN_424] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_424::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 425u64 => { let __inp: [G; IN_425] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_425::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 426u64 => { let __inp: [G; IN_426] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_426::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 427u64 => { let __inp: [G; IN_427] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_427::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 428u64 => { let __inp: [G; IN_428] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_428::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 429u64 => { let __inp: [G; IN_429] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_429::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 430u64 => { let __inp: [G; IN_430] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_430::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 431u64 => { let __inp: [G; IN_431] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_431::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 432u64 => { let __inp: [G; IN_432] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_432::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 433u64 => { let __inp: [G; IN_433] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_433::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 434u64 => { let __inp: [G; IN_434] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_434::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 435u64 => { let __inp: [G; IN_435] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_435::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 436u64 => { let __inp: [G; IN_436] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_436::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 437u64 => { let __inp: [G; IN_437] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_437::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 438u64 => { let __inp: [G; IN_438] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_438::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 439u64 => { let __inp: [G; IN_439] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_439::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 440u64 => { let __inp: [G; IN_440] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_440::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 441u64 => { let __inp: [G; IN_441] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_441::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 442u64 => { let __inp: [G; IN_442] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_442::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 443u64 => { let __inp: [G; IN_443] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_443::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 444u64 => { let __inp: [G; IN_444] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_444::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 445u64 => { let __inp: [G; IN_445] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_445::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 446u64 => { let __inp: [G; IN_446] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_446::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 447u64 => { let __inp: [G; IN_447] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_447::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 448u64 => { let __inp: [G; IN_448] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_448::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 449u64 => { let __inp: [G; IN_449] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_449::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 450u64 => { let __inp: [G; IN_450] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_450::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 451u64 => { let __inp: [G; IN_451] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_451::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 452u64 => { let __inp: [G; IN_452] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_452::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 453u64 => { let __inp: [G; IN_453] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_453::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 454u64 => { let __inp: [G; IN_454] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_454::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 455u64 => { let __inp: [G; IN_455] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_455::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 456u64 => { let __inp: [G; IN_456] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_456::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 457u64 => { let __inp: [G; IN_457] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_457::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 458u64 => { let __inp: [G; IN_458] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_458::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 459u64 => { let __inp: [G; IN_459] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_459::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 460u64 => { let __inp: [G; IN_460] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_460::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 461u64 => { let __inp: [G; IN_461] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_461::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 462u64 => { let __inp: [G; IN_462] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_462::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 463u64 => { let __inp: [G; IN_463] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_463::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 464u64 => { let __inp: [G; IN_464] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_464::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 465u64 => { let __inp: [G; IN_465] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_465::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 466u64 => { let __inp: [G; IN_466] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_466::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 467u64 => { let __inp: [G; IN_467] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_467::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 468u64 => { let __inp: [G; IN_468] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_468::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 469u64 => { let __inp: [G; IN_469] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_469::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 470u64 => { let __inp: [G; IN_470] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_470::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 471u64 => { let __inp: [G; IN_471] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_471::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 472u64 => { let __inp: [G; IN_472] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_472::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 473u64 => { let __inp: [G; IN_473] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_473::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 474u64 => { let __inp: [G; IN_474] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_474::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 475u64 => { let __inp: [G; IN_475] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_475::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 476u64 => { let __inp: [G; IN_476] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_476::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 477u64 => { let __inp: [G; IN_477] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_477::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 478u64 => { let __inp: [G; IN_478] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_478::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 479u64 => { let __inp: [G; IN_479] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_479::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 480u64 => { let __inp: [G; IN_480] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_480::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 481u64 => { let __inp: [G; IN_481] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_481::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 482u64 => { let __inp: [G; IN_482] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_482::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 483u64 => { let __inp: [G; IN_483] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_483::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 484u64 => { let __inp: [G; IN_484] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_484::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 485u64 => { let __inp: [G; IN_485] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_485::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 486u64 => { let __inp: [G; IN_486] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_486::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 487u64 => { let __inp: [G; IN_487] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_487::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 488u64 => { let __inp: [G; IN_488] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_488::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 489u64 => { let __inp: [G; IN_489] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_489::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 490u64 => { let __inp: [G; IN_490] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_490::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 491u64 => { let __inp: [G; IN_491] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_491::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 492u64 => { let __inp: [G; IN_492] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_492::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 493u64 => { let __inp: [G; IN_493] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_493::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 494u64 => { let __inp: [G; IN_494] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_494::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 495u64 => { let __inp: [G; IN_495] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_495::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 496u64 => { let __inp: [G; IN_496] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_496::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 497u64 => { let __inp: [G; IN_497] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_497::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 498u64 => { let __inp: [G; IN_498] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_498::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 499u64 => { let __inp: [G; IN_499] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_499::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 500u64 => { let __inp: [G; IN_500] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_500::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 501u64 => { let __inp: [G; IN_501] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_501::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 502u64 => { let __inp: [G; IN_502] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_502::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 503u64 => { let __inp: [G; IN_503] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_503::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 504u64 => { let __inp: [G; IN_504] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_504::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 505u64 => { let __inp: [G; IN_505] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_505::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 506u64 => { let __inp: [G; IN_506] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_506::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 507u64 => { let __inp: [G; IN_507] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_507::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 508u64 => { let __inp: [G; IN_508] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_508::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 509u64 => { let __inp: [G; IN_509] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_509::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 510u64 => { let __inp: [G; IN_510] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_510::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 511u64 => { let __inp: [G; IN_511] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_511::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 512u64 => { let __inp: [G; IN_512] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_512::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 513u64 => { let __inp: [G; IN_513] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_513::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 514u64 => { let __inp: [G; IN_514] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_514::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 515u64 => { let __inp: [G; IN_515] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_515::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 516u64 => { let __inp: [G; IN_516] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_516::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 517u64 => { let __inp: [G; IN_517] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_517::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 518u64 => { let __inp: [G; IN_518] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_518::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 519u64 => { let __inp: [G; IN_519] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_519::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 520u64 => { let __inp: [G; IN_520] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_520::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 521u64 => { let __inp: [G; IN_521] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_521::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 522u64 => { let __inp: [G; IN_522] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_522::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 523u64 => { let __inp: [G; IN_523] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_523::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 524u64 => { let __inp: [G; IN_524] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_524::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 525u64 => { let __inp: [G; IN_525] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_525::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 526u64 => { let __inp: [G; IN_526] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_526::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 527u64 => { let __inp: [G; IN_527] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_527::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 528u64 => { let __inp: [G; IN_528] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_528::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 529u64 => { let __inp: [G; IN_529] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_529::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 530u64 => { let __inp: [G; IN_530] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_530::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 531u64 => { let __inp: [G; IN_531] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_531::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 532u64 => { let __inp: [G; IN_532] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_532::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 533u64 => { let __inp: [G; IN_533] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_533::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 534u64 => { let __inp: [G; IN_534] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_534::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 535u64 => { let __inp: [G; IN_535] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_535::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 536u64 => { let __inp: [G; IN_536] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_536::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 537u64 => { let __inp: [G; IN_537] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_537::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 538u64 => { let __inp: [G; IN_538] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_538::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 539u64 => { let __inp: [G; IN_539] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_539::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 540u64 => { let __inp: [G; IN_540] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_540::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 541u64 => { let __inp: [G; IN_541] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_541::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 542u64 => { let __inp: [G; IN_542] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_542::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 543u64 => { let __inp: [G; IN_543] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_543::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 544u64 => { let __inp: [G; IN_544] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_544::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 545u64 => { let __inp: [G; IN_545] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_545::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 546u64 => { let __inp: [G; IN_546] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_546::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 547u64 => { let __inp: [G; IN_547] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_547::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 548u64 => { let __inp: [G; IN_548] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_548::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 549u64 => { let __inp: [G; IN_549] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_549::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 550u64 => { let __inp: [G; IN_550] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_550::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 551u64 => { let __inp: [G; IN_551] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_551::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 552u64 => { let __inp: [G; IN_552] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_552::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 553u64 => { let __inp: [G; IN_553] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_553::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 554u64 => { let __inp: [G; IN_554] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_554::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 555u64 => { let __inp: [G; IN_555] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_555::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 556u64 => { let __inp: [G; IN_556] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_556::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 557u64 => { let __inp: [G; IN_557] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_557::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 558u64 => { let __inp: [G; IN_558] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_558::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 559u64 => { let __inp: [G; IN_559] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_559::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 560u64 => { let __inp: [G; IN_560] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_560::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 561u64 => { let __inp: [G; IN_561] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_561::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 562u64 => { let __inp: [G; IN_562] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_562::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 563u64 => { let __inp: [G; IN_563] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_563::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 564u64 => { let __inp: [G; IN_564] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_564::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 565u64 => { let __inp: [G; IN_565] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_565::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 566u64 => { let __inp: [G; IN_566] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_566::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 567u64 => { let __inp: [G; IN_567] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_567::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 568u64 => { let __inp: [G; IN_568] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_568::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 569u64 => { let __inp: [G; IN_569] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_569::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 570u64 => { let __inp: [G; IN_570] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_570::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 571u64 => { let __inp: [G; IN_571] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_571::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 572u64 => { let __inp: [G; IN_572] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_572::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 573u64 => { let __inp: [G; IN_573] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_573::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 574u64 => { let __inp: [G; IN_574] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_574::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 575u64 => { let __inp: [G; IN_575] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_575::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 576u64 => { let __inp: [G; IN_576] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_576::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 577u64 => { let __inp: [G; IN_577] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_577::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 578u64 => { let __inp: [G; IN_578] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_578::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 579u64 => { let __inp: [G; IN_579] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_579::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 580u64 => { let __inp: [G; IN_580] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_580::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 581u64 => { let __inp: [G; IN_581] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_581::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 582u64 => { let __inp: [G; IN_582] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_582::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 583u64 => { let __inp: [G; IN_583] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_583::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 584u64 => { let __inp: [G; IN_584] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_584::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 585u64 => { let __inp: [G; IN_585] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_585::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 586u64 => { let __inp: [G; IN_586] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_586::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 587u64 => { let __inp: [G; IN_587] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_587::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 588u64 => { let __inp: [G; IN_588] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_588::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 589u64 => { let __inp: [G; IN_589] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_589::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 590u64 => { let __inp: [G; IN_590] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_590::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 591u64 => { let __inp: [G; IN_591] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_591::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 592u64 => { let __inp: [G; IN_592] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_592::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 593u64 => { let __inp: [G; IN_593] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_593::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 594u64 => { let __inp: [G; IN_594] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_594::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 595u64 => { let __inp: [G; IN_595] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_595::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 596u64 => { let __inp: [G; IN_596] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_596::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 597u64 => { let __inp: [G; IN_597] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_597::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 598u64 => { let __inp: [G; IN_598] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_598::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 599u64 => { let __inp: [G; IN_599] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_599::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 600u64 => { let __inp: [G; IN_600] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_600::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 601u64 => { let __inp: [G; IN_601] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_601::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 602u64 => { let __inp: [G; IN_602] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_602::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 603u64 => { let __inp: [G; IN_603] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_603::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 604u64 => { let __inp: [G; IN_604] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_604::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 605u64 => { let __inp: [G; IN_605] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_605::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 606u64 => { let __inp: [G; IN_606] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_606::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 607u64 => { let __inp: [G; IN_607] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_607::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 608u64 => { let __inp: [G; IN_608] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_608::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 609u64 => { let __inp: [G; IN_609] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_609::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 610u64 => { let __inp: [G; IN_610] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_610::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 611u64 => { let __inp: [G; IN_611] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_611::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 612u64 => { let __inp: [G; IN_612] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_612::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 613u64 => { let __inp: [G; IN_613] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_613::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 614u64 => { let __inp: [G; IN_614] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_614::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 615u64 => { let __inp: [G; IN_615] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_615::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 616u64 => { let __inp: [G; IN_616] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_616::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 617u64 => { let __inp: [G; IN_617] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_617::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 618u64 => { let __inp: [G; IN_618] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_618::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 619u64 => { let __inp: [G; IN_619] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_619::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 620u64 => { let __inp: [G; IN_620] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_620::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 621u64 => { let __inp: [G; IN_621] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_621::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 622u64 => { let __inp: [G; IN_622] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_622::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 623u64 => { let __inp: [G; IN_623] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_623::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 624u64 => { let __inp: [G; IN_624] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_624::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 625u64 => { let __inp: [G; IN_625] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_625::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 626u64 => { let __inp: [G; IN_626] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_626::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 627u64 => { let __inp: [G; IN_627] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_627::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 628u64 => { let __inp: [G; IN_628] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_628::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 629u64 => { let __inp: [G; IN_629] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_629::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 630u64 => { let __inp: [G; IN_630] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_630::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 631u64 => { let __inp: [G; IN_631] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_631::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 632u64 => { let __inp: [G; IN_632] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_632::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 633u64 => { let __inp: [G; IN_633] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_633::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 634u64 => { let __inp: [G; IN_634] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_634::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 635u64 => { let __inp: [G; IN_635] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_635::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 636u64 => { let __inp: [G; IN_636] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_636::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 637u64 => { let __inp: [G; IN_637] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_637::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 638u64 => { let __inp: [G; IN_638] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_638::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 639u64 => { let __inp: [G; IN_639] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_639::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 640u64 => { let __inp: [G; IN_640] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_640::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 641u64 => { let __inp: [G; IN_641] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_641::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 642u64 => { let __inp: [G; IN_642] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_642::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 643u64 => { let __inp: [G; IN_643] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_643::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 644u64 => { let __inp: [G; IN_644] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_644::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 645u64 => { let __inp: [G; IN_645] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_645::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 646u64 => { let __inp: [G; IN_646] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_646::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 647u64 => { let __inp: [G; IN_647] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_647::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 648u64 => { let __inp: [G; IN_648] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_648::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 649u64 => { let __inp: [G; IN_649] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_649::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 650u64 => { let __inp: [G; IN_650] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_650::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 651u64 => { let __inp: [G; IN_651] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_651::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 652u64 => { let __inp: [G; IN_652] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_652::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 653u64 => { let __inp: [G; IN_653] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_653::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 654u64 => { let __inp: [G; IN_654] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_654::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 655u64 => { let __inp: [G; IN_655] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_655::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 656u64 => { let __inp: [G; IN_656] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_656::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 657u64 => { let __inp: [G; IN_657] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_657::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 658u64 => { let __inp: [G; IN_658] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_658::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 659u64 => { let __inp: [G; IN_659] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_659::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 660u64 => { let __inp: [G; IN_660] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_660::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 661u64 => { let __inp: [G; IN_661] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_661::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 662u64 => { let __inp: [G; IN_662] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_662::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 663u64 => { let __inp: [G; IN_663] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_663::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 664u64 => { let __inp: [G; IN_664] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_664::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 665u64 => { let __inp: [G; IN_665] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_665::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 666u64 => { let __inp: [G; IN_666] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_666::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 667u64 => { let __inp: [G; IN_667] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_667::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 668u64 => { let __inp: [G; IN_668] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_668::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 669u64 => { let __inp: [G; IN_669] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_669::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 670u64 => { let __inp: [G; IN_670] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_670::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 671u64 => { let __inp: [G; IN_671] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_671::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 672u64 => { let __inp: [G; IN_672] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_672::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 673u64 => { let __inp: [G; IN_673] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_673::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 674u64 => { let __inp: [G; IN_674] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_674::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 675u64 => { let __inp: [G; IN_675] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_675::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 676u64 => { let __inp: [G; IN_676] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_676::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 677u64 => { let __inp: [G; IN_677] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_677::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 678u64 => { let __inp: [G; IN_678] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_678::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 679u64 => { let __inp: [G; IN_679] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_679::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 680u64 => { let __inp: [G; IN_680] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_680::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 681u64 => { let __inp: [G; IN_681] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_681::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 682u64 => { let __inp: [G; IN_682] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_682::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 683u64 => { let __inp: [G; IN_683] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_683::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 684u64 => { let __inp: [G; IN_684] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_684::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 685u64 => { let __inp: [G; IN_685] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_685::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 686u64 => { let __inp: [G; IN_686] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_686::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 687u64 => { let __inp: [G; IN_687] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_687::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 688u64 => { let __inp: [G; IN_688] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_688::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 689u64 => { let __inp: [G; IN_689] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_689::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 690u64 => { let __inp: [G; IN_690] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_690::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 691u64 => { let __inp: [G; IN_691] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_691::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 692u64 => { let __inp: [G; IN_692] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_692::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 693u64 => { let __inp: [G; IN_693] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_693::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 694u64 => { let __inp: [G; IN_694] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_694::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 695u64 => { let __inp: [G; IN_695] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_695::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 696u64 => { let __inp: [G; IN_696] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_696::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 697u64 => { let __inp: [G; IN_697] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_697::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 698u64 => { let __inp: [G; IN_698] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_698::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 699u64 => { let __inp: [G; IN_699] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_699::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 700u64 => { let __inp: [G; IN_700] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_700::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 701u64 => { let __inp: [G; IN_701] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_701::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 702u64 => { let __inp: [G; IN_702] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_702::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 703u64 => { let __inp: [G; IN_703] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_703::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 704u64 => { let __inp: [G; IN_704] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_704::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 705u64 => { let __inp: [G; IN_705] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_705::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 706u64 => { let __inp: [G; IN_706] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_706::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 707u64 => { let __inp: [G; IN_707] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_707::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 708u64 => { let __inp: [G; IN_708] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_708::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 709u64 => { let __inp: [G; IN_709] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_709::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 710u64 => { let __inp: [G; IN_710] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_710::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 711u64 => { let __inp: [G; IN_711] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_711::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 712u64 => { let __inp: [G; IN_712] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_712::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 713u64 => { let __inp: [G; IN_713] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_713::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 714u64 => { let __inp: [G; IN_714] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_714::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 715u64 => { let __inp: [G; IN_715] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_715::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 716u64 => { let __inp: [G; IN_716] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_716::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 717u64 => { let __inp: [G; IN_717] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_717::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 718u64 => { let __inp: [G; IN_718] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_718::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 719u64 => { let __inp: [G; IN_719] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_719::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 720u64 => { let __inp: [G; IN_720] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_720::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 721u64 => { let __inp: [G; IN_721] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_721::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 722u64 => { let __inp: [G; IN_722] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_722::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 723u64 => { let __inp: [G; IN_723] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_723::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 724u64 => { let __inp: [G; IN_724] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_724::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 725u64 => { let __inp: [G; IN_725] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_725::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 726u64 => { let __inp: [G; IN_726] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_726::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 727u64 => { let __inp: [G; IN_727] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_727::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 728u64 => { let __inp: [G; IN_728] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_728::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 729u64 => { let __inp: [G; IN_729] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_729::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 730u64 => { let __inp: [G; IN_730] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_730::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 731u64 => { let __inp: [G; IN_731] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_731::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 732u64 => { let __inp: [G; IN_732] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_732::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 733u64 => { let __inp: [G; IN_733] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_733::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 734u64 => { let __inp: [G; IN_734] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_734::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 735u64 => { let __inp: [G; IN_735] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_735::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 736u64 => { let __inp: [G; IN_736] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_736::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 737u64 => { let __inp: [G; IN_737] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_737::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 738u64 => { let __inp: [G; IN_738] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_738::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 739u64 => { let __inp: [G; IN_739] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_739::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 740u64 => { let __inp: [G; IN_740] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_740::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 741u64 => { let __inp: [G; IN_741] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_741::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 742u64 => { let __inp: [G; IN_742] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_742::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 743u64 => { let __inp: [G; IN_743] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_743::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 744u64 => { let __inp: [G; IN_744] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_744::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 745u64 => { let __inp: [G; IN_745] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_745::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 746u64 => { let __inp: [G; IN_746] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_746::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 747u64 => { let __inp: [G; IN_747] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_747::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 748u64 => { let __inp: [G; IN_748] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_748::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 749u64 => { let __inp: [G; IN_749] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_749::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 750u64 => { let __inp: [G; IN_750] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_750::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 751u64 => { let __inp: [G; IN_751] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_751::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 752u64 => { let __inp: [G; IN_752] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_752::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 753u64 => { let __inp: [G; IN_753] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_753::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 754u64 => { let __inp: [G; IN_754] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_754::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 755u64 => { let __inp: [G; IN_755] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_755::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 756u64 => { let __inp: [G; IN_756] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_756::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 757u64 => { let __inp: [G; IN_757] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_757::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 758u64 => { let __inp: [G; IN_758] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_758::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 759u64 => { let __inp: [G; IN_759] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_759::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 760u64 => { let __inp: [G; IN_760] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_760::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 761u64 => { let __inp: [G; IN_761] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_761::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 762u64 => { let __inp: [G; IN_762] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_762::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 763u64 => { let __inp: [G; IN_763] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_763::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 764u64 => { let __inp: [G; IN_764] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_764::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 765u64 => { let __inp: [G; IN_765] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_765::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 766u64 => { let __inp: [G; IN_766] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_766::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 767u64 => { let __inp: [G; IN_767] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_767::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 768u64 => { let __inp: [G; IN_768] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_768::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 769u64 => { let __inp: [G; IN_769] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_769::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 770u64 => { let __inp: [G; IN_770] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_770::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 771u64 => { let __inp: [G; IN_771] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_771::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 772u64 => { let __inp: [G; IN_772] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_772::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 773u64 => { let __inp: [G; IN_773] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_773::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 774u64 => { let __inp: [G; IN_774] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_774::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 775u64 => { let __inp: [G; IN_775] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_775::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 776u64 => { let __inp: [G; IN_776] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_776::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 777u64 => { let __inp: [G; IN_777] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_777::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 778u64 => { let __inp: [G; IN_778] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_778::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 779u64 => { let __inp: [G; IN_779] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_779::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 780u64 => { let __inp: [G; IN_780] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_780::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 781u64 => { let __inp: [G; IN_781] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_781::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 782u64 => { let __inp: [G; IN_782] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_782::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 783u64 => { let __inp: [G; IN_783] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_783::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 784u64 => { let __inp: [G; IN_784] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_784::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, _ => { return Err(ExecError::InvalidFunIdx(fun_idx)); }, } } diff --git a/crates/ixvm-codegen/src/aiur_ixvm_runner.rs b/crates/ixvm-codegen/src/aiur_ixvm_runner.rs deleted file mode 100644 index 660f4b037..000000000 --- a/crates/ixvm-codegen/src/aiur_ixvm_runner.rs +++ /dev/null @@ -1,58 +0,0 @@ -//! IxVM-native execute path. -//! -//! Parallel to `aiur::execute::Toplevel::execute`, but routes the -//! Aiur fn invocation through the codegen'd Rust kernel -//! (`crate::aiur_ixvm::execute_generated`) instead of the interpreter. -//! -//! Same `QueryRecord` shape, same multiplicity rules, same memory and -//! IO side effects — so the trace produced here is byte-for-byte -//! identical to the interpreter's (modulo the `execute_generated` -//! codegen's correctness, which is the standing parity invariant). -//! -//! Caller still needs a `Toplevel` to size the `QueryRecord` correctly -//! (one `QueryMap` per function, one per `memory_sizes` entry). The -//! `Toplevel`'s bytecode is NOT walked at execution time; only its -//! shape is consulted. - -use crate::aiur_ixvm::execute_generated; -use aiur::G; -use aiur::bytecode::{FunIdx, Toplevel}; -use aiur::execute::{ExecError, IOBuffer, QueryRecord}; - -/// Mirror of `Toplevel::execute` (same return shape, same -/// `entry`-flag gate), but routes execution through the codegen'd -/// Rust kernel. Deep recursion is handled via per-fn -/// `stacker::maybe_grow` checks in the generated code — no -/// pre-reserved giant stack on this thread, no scope dance. -// `args: Vec` mirrors `Toplevel::execute`'s signature so this function -// satisfies `AiurSystem::prove_ixvm`'s executor bound; a `&[G]` here would -// break it. -#[allow(clippy::needless_pass_by_value)] -pub fn execute_ixvm( - toplevel: &Toplevel, - fun_idx: FunIdx, - args: Vec, - io_buffer: &mut IOBuffer, -) -> Result<(QueryRecord, Vec), ExecError> { - if !toplevel.functions[fun_idx].entry { - return Err(ExecError::NotEntryFunction(fun_idx)); - } - let mut record = QueryRecord::new(toplevel); - let output = execute_generated(fun_idx, &args, &mut record, io_buffer)?; - Ok((record, output)) -} - -/// [`execute_ixvm`] into an existing record, memoizing against what it -/// already holds (see `Toplevel::execute_in`). -pub fn execute_ixvm_in( - toplevel: &Toplevel, - fun_idx: FunIdx, - args: &[G], - io_buffer: &mut IOBuffer, - record: &mut QueryRecord, -) -> Result, ExecError> { - if !toplevel.functions[fun_idx].entry { - return Err(ExecError::NotEntryFunction(fun_idx)); - } - execute_generated(fun_idx, args, record, io_buffer) -} diff --git a/crates/ixvm-codegen/src/aiur_ixvm_witness.rs b/crates/ixvm-codegen/src/aiur_ixvm_witness.rs deleted file mode 100644 index d7b754ef4..000000000 --- a/crates/ixvm-codegen/src/aiur_ixvm_witness.rs +++ /dev/null @@ -1,731 +0,0 @@ -//! Rust port of `IxVM.ClaimHarness.buildShardCheckEnvWitness`. -//! -//! Replaces the Lean-side IOBuffer construction (~92% of shard -//! wall time on heavy partitions) with a direct Rust implementation -//! that builds `aiur::execute::IOBuffer` without per-byte boxing -//! into Lean values. -//! -//! Mirrors the per-channel layout documented in -//! `Ix/IxVM/ClaimHarness.lean`: -//! -//! | ch | purpose | key | value | -//! |----|--------------------------|----------------|-----------| -//! | 0 | claim wire bytes | claim_digest | bytes | -//! | 1 | assumption tree bytes | tree.root | bytes | -//! | 2 | constant wire bytes | const addr | bytes | -//! | 3 | Defn reducibility hint | Defn addr | single G | -//! | 4 | blob raw bytes | blob addr | bytes | -//! -//! An address is seeded on ch 2 iff it is a constant and on ch 4 iff it -//! is a blob. The two sets are NOT disjoint: constant and blob addresses -//! share a hash codomain, so one address can be read both ways, and the -//! Expr context (`Ref`/`Prj` vs `Str`/`Nat`) is what says which table a -//! reference means. Each channel is therefore seeded independently, and -//! the kernel derives which it wants from that context, so no -//! discriminator entry is shipped. -//! -//! Every byte-stream is blake3-verified kernel-side against its -//! content-addressed key. -//! -//! # Parallelism -//! -//! The byte scope is computed by `witness_scope`, which delegates to -//! `Env::bfs_closure` — a single sequential BFS that parses each closure -//! member exactly once. The hot phase that follows uses rayon: -//! -//! * **Byte→G conversion** (`add_entries_parallel`): assign offsets in -//! sorted address order, then fill disjoint slices of the final channel -//! arenas in parallel. No intermediate field-element buffers are kept. - -use multi_stark::p3_field::PrimeCharacteristicRing; -use rayon::prelude::*; -use rustc_hash::FxHashSet; - -use aiur::G; -use aiur::execute::{IOBuffer, IOKeyInfo}; -use ix_common::address::Address; -use ix_common::env::ReducibilityHints; -use ix_common::prim_addrs::PrimAddrs; -use ixon::Env; -use ixon::assumption_tree::AssumptionTree; -use ixon::proof::{Claim, ClaimContext}; -use ixon::role_table::{Evidence, RoleTable}; - -/// Append `data` to the per-channel arena and record `(idx, len)` -/// in the `(channel, key)` info map. -#[inline] -fn extend(io: &mut IOBuffer, channel: G, key: Vec, data: Vec) { - let arena = io.data.entry(channel).or_default(); - let idx = arena.len(); - let len = data.len(); - arena.extend(data); - io.map.insert((channel, key), IOKeyInfo { idx, len }); -} - -/// An address as its 32 bytes, one field element each: the memory-table key -/// of an interned `Addr` and the argument of `check_owned`. -#[inline] -pub fn addr_key(addr: &Address) -> Vec { - addr.as_bytes().iter().map(|b| G::from_u8(*b)).collect() -} - -/// An address as 8 packed-4-LE-byte field elements: the `verify_claim` -/// public-input (and ch-0 key) form. Mirrors the in-circuit `b3_pack` -/// and Lean `IxVM.ClaimHarness.packedDigestKey`. -#[inline] -fn packed_digest_key(addr: &Address) -> Vec { - addr - .as_bytes() - .as_chunks::<4>() - .0 - .iter() - .map(|w| { - G::from_u32( - u32::from(w[0]) - | u32::from(w[1]) << 8 - | u32::from(w[2]) << 16 - | u32::from(w[3]) << 24, - ) - }) - .collect() -} - -#[inline] -fn bytes_to_g(bytes: &[u8]) -> Vec { - bytes.iter().map(|b| G::from_u8(*b)).collect() -} - -/// Mirror of `IxVM.ClaimHarness.hintToG`: -/// `Opaque → 0`, `Abbrev → 0xFFFFFFFF`, `Regular n → min(1+n, 0xFFFFFFFE)`. -fn hint_to_g(h: &ReducibilityHints) -> G { - let v: u64 = match h { - ReducibilityHints::Opaque => 0, - ReducibilityHints::Abbrev => 0xFFFF_FFFF, - ReducibilityHints::Regular(n) => { - let v = (1u64).saturating_add(u64::from(*n)); - v.min(0xFFFF_FFFE) - }, - }; - G::from_u64(v) -} - -/// Assign deterministic offsets, then convert bytes directly into the -/// final arenas. Holding converted partials while growing/copying the -/// arenas can otherwise multiply the peak memory of large witnesses. -fn add_entries_parallel( - env: &Env, - closure: &FxHashSet
, - io: &mut IOBuffer, -) { - let ch_hint = G::from_u8(3); - - // Pull the set of addrs we'll touch as a Vec for parallel iteration, - // SORTED: the closure set is unioned by racing threads (DashSet), so its - // iteration order varies run to run; the arena indices assigned below - // follow this order and flow into the trace via ioGetInfo, so an - // unsorted walk makes proof bytes nondeterministic (semantically - // equivalent, but bytes and FRI queries reshuffle every run). - let mut closure_vec: Vec
= closure.iter().cloned().collect(); - closure_vec.sort_unstable(); - - // Seed the constant and blob channels independently: a single address - // may occur in BOTH tables. Missing addresses remain absent, as before. - for channel in [2, 4] { - let entries: Vec<_> = closure_vec - .iter() - .filter_map(|addr| { - let len = if channel == 2 { - env.consts.get(addr).map(|c| c.raw_bytes().len()) - } else { - env.blobs.get(addr).map(|b| b.len()) - }; - len.map(|len| (addr, len)) - }) - .collect(); - if entries.is_empty() { - continue; - } - let channel = G::from_u8(channel); - let arena = io.data.entry(channel).or_default(); - let mut idx = arena.len(); - let len: usize = entries.iter().map(|(_, len)| len).sum(); - arena.reserve_exact(len); - arena.resize(idx + len, G::ZERO); - let mut remaining = &mut arena[idx..]; - let mut jobs = Vec::with_capacity(entries.len()); - for (addr, len) in entries { - io.map.insert((channel, addr_key(addr)), IOKeyInfo { idx, len }); - idx += len; - let (dst, rest) = remaining.split_at_mut(len); - remaining = rest; - jobs.push((addr, dst)); - } - jobs.into_par_iter().for_each(|(addr, dst)| { - let fill = |src: &[u8], dst: &mut [G]| { - assert_eq!(src.len(), dst.len()); - for (out, byte) in dst.iter_mut().zip(src) { - *out = G::from_u8(*byte); - } - }; - if channel == G::from_u8(2) { - let constant = - env.consts.get(addr).expect("witness constant disappeared"); - fill(constant.raw_bytes(), dst); - } else { - let blob = env.blobs.get(addr).expect("witness blob disappeared"); - fill(blob.value(), dst); - } - }); - } - for addr in &closure_vec { - if let Some(hint) = env.anon_hints.get(addr) { - extend(io, ch_hint, addr_key(addr), vec![hint_to_g(&hint)]); - } - } -} - -/// Build a `Check { ctx, const_addr, assumptions=None }` claim witness -/// directly in Rust, with the context of `env`'s own role binding. Returns `(claim, claim_digest_input, io_buffer)` -/// ready to feed to `crate::ix::aiur_ixvm_runner::execute_ixvm`. -/// -/// Mirrors `IxVM.ClaimHarness.buildClaimWitness` on the -/// `Claim.check addr none` branch: the witness scope seeds ch 2/3/4, -/// claim bytes go to ch 0. Asm-tree variant deferred — caller falls -/// back to Lean witness when `asm = Some _`. -pub fn build_claim_check_witness( - env: &Env, - target: &Address, -) -> Result<(Claim, Vec, IOBuffer), String> { - build_claim_check_witness_with(env, target, false) -} - -/// [`build_claim_check_witness`], whose claim assumes the environment's -/// binding meets the specifications when `assume_binding` (validator 4) and -/// validates it otherwise (validator 3). -pub fn build_claim_check_witness_with( - env: &Env, - target: &Address, - assume_binding: bool, -) -> Result<(Claim, Vec, IOBuffer), String> { - let closure: FxHashSet
= - witness_scope_with(env, std::slice::from_ref(target), assume_binding); - - let mut ctx = ClaimContext::for_env(env)?; - ctx.binding_assumed = assume_binding; - let claim = - Claim::Check { ctx, const_addr: target.clone(), assumptions: None }; - let mut claim_bytes: Vec = Vec::new(); - claim.put(&mut claim_bytes); - let digest = Address::hash(&claim_bytes); - let digest_key = packed_digest_key(&digest); - - let mut io = IOBuffer { - data: rustc_hash::FxHashMap::default(), - map: rustc_hash::FxHashMap::default(), - }; - // ch 0: claim bytes - extend(&mut io, G::ZERO, digest_key.clone(), bytes_to_g(&claim_bytes)); - if let Some(ax_tree) = ClaimContext::user_axiom_tree(env) { - extend( - &mut io, - G::ONE, - addr_key(&ax_tree.root()), - bytes_to_g(&ax_tree.ser()), - ); - } - // ch 2/3/4: per-const/hint/blob entries — parallel byte conversion. - add_entries_parallel(env, &closure, &mut io); - seed_binding(env, &mut io); - - Ok((claim, digest_key, io)) -} - -/// Build a `Binding { spec, binding }` claim witness directly in Rust, -/// over `env`'s role binding. -pub fn build_binding_witness( - env: &Env, -) -> Result<(Claim, Vec, IOBuffer), String> { - let ctx = ClaimContext::for_env(env)?; - let mut roots = binding_roots(env, false); - roots.extend(prim_addrs().into_iter().filter(|a| env.consts.contains_key(a))); - let closure = env.bfs_closure(&roots); - let claim = Claim::Binding { spec: ctx.spec, binding: ctx.binding }; - let mut claim_bytes: Vec = Vec::new(); - claim.put(&mut claim_bytes); - let digest = Address::hash(&claim_bytes); - let digest_key = packed_digest_key(&digest); - let mut io = IOBuffer { - data: rustc_hash::FxHashMap::default(), - map: rustc_hash::FxHashMap::default(), - }; - extend(&mut io, G::ZERO, digest_key.clone(), bytes_to_g(&claim_bytes)); - add_entries_parallel(env, &closure, &mut io); - seed_binding(env, &mut io); - Ok((claim, digest_key, io)) -} - -/// Every primitive address the kernel can name, as the Lean seeder sees -/// them: the parity table plus the reserved reduction markers. Built from -/// `ix_common::prim_addrs::PrimAddrs`, which the `prim-addrs` parity test -/// pins against `Ix.PrimAddrs`, so both seeders cover the same set by -/// construction. -fn prim_addrs() -> Vec
{ - let mut v: Vec
= PrimAddrs::lean_parity_table() - .iter() - .map(|(name, hex)| { - Address::from_hex(hex) - .unwrap_or_else(|| panic!("primitive {name}: invalid address hex")) - }) - .collect(); - v.extend(PrimAddrs::reserved_marker_addrs().iter().map(|(_, a)| a.clone())); - v -} - -/// The full WITNESS byte scope for `roots`: the env dependency closure -/// plus every primitive present in the env. -/// -/// `Env::bfs_closure` follows `refs`, each projection's `block` pointer, -/// AND — for a `Muts` block — every member/constructor projection -/// address it derives. That last edge is what the kernel needs: its -/// lazy `get_ci` synthesizes IPrj/CPrj/RPrj/DPrj wrapper addrs via -/// kernel-side blake3 and faults their bytes from ch 2, so wrappers -/// over a closure block must ship even when no `Constant.refs` edge -/// reaches them. The closure already carries them — expanding a wrapper -/// only re-adds its (already present) block — so no reverse scan of the -/// env is needed. -/// -/// Primitives are seeded as additional ROOTS because the kernel -/// FABRICATES references to them while reducing — `Const(nat_succ_addr(), -/// ..)` and friends are built from addresses hardcoded in the Aiur -/// source, not discovered by walking `refs` — and `get_ci` then faults -/// their bytes from ch 2 like any other constant. Such a primitive need -/// not appear anywhere in the target's ref closure, so a closure-only -/// scope aborts with `invalid IO key`. Intersected with `env.consts`: a -/// primitive the env does not carry is one the check cannot reach. -/// -/// They are walked rather than merely inserted because def-eq -/// delta-unfolds primitive BODIES, and a body's refs are reachable from -/// nowhere else in the scope (the `strAppend*` arena fixtures exercise -/// exactly this). -/// -/// Every witness builder goes through here, so the byte scope cannot -/// drift apart per call site. Mirrors -/// `Ix.IxVM.ClaimHarness.closureFrom`. -/// The constants the role binding names: every bound role and (when not -/// `assume_binding`) every proof evidence theorem the environment carries. -fn binding_roots(env: &Env, assume_binding: bool) -> Vec
{ - let Some(binding) = env.role_binding.as_ref() else { - return Vec::new(); - }; - let Ok(table) = RoleTable::from_bytes(binding.bytes.as_ref()) else { - return Vec::new(); - }; - let mut roots: Vec
= - table.bound.into_iter().map(|(_, address)| address).collect(); - if !assume_binding { - for (_, entries) in table.evidence { - for entry in entries { - if let Evidence::Proof(address) = entry { - roots.push(address); - } - } - } - } - roots.retain(|a| env.consts.contains_key(a)); - roots -} - -/// Seed the role binding's section on channel 6, keyed by its hash, where -/// the circuit reads the claim's roles. -fn seed_binding(env: &Env, io: &mut IOBuffer) { - if let Some(binding) = env.role_binding.as_ref() { - extend( - io, - G::from_u8(6), - addr_key(&binding.address), - bytes_to_g(binding.bytes.as_ref()), - ); - } -} - -/// The argument of `check_owned`: the binding hash, one field element per -/// byte; the claim's validator (3 validates the binding, 4 assumes it); then -/// the constant's address, one field element per byte. -pub fn check_owned_key( - binding: &Address, - validator: u8, - addr: &Address, -) -> Vec { - let mut key = addr_key(binding); - key.push(G::from_u8(validator)); - key.extend(addr_key(addr)); - key -} - -fn witness_scope_with( - env: &Env, - roots: &[Address], - assume_binding: bool, -) -> FxHashSet
{ - let mut all_roots: Vec
= roots.to_vec(); - all_roots - .extend(prim_addrs().into_iter().filter(|a| env.consts.contains_key(a))); - all_roots.extend(binding_roots(env, assume_binding)); - all_roots.extend(ClaimContext::user_axioms(env)); - env.bfs_closure(&all_roots) -} - -fn witness_scope(env: &Env, roots: &[Address]) -> FxHashSet
{ - witness_scope_with(env, roots, false) -} - -/// Whole-environment `CheckEnv` witness split across workers (trace-sharding -/// design §13.3): the claim over the environment's canonical tree with no -/// assumptions, the digest key worker 0's `verify_claim` takes as input, and -/// one IO buffer per worker. Worker 0's carries the claim bytes (ch 0) and -/// the tree (ch 1); every worker's carries the byte scope (ch 2) of the -/// constants it owns, which is all a worker's `check_owned` runs fault. -pub fn build_env_check_witnesses( - env: &Env, - owners: &[Vec
], -) -> Result<(Claim, Vec, Vec), String> { - let statement = EnvCheckStatement::new(env)?; - let ios = (0..owners.len()) - .map(|worker| statement.worker_io(env, owners, worker)) - .collect(); - Ok((statement.claim, statement.digest_key, ios)) -} - -/// The whole-environment `CheckEnv` statement: the claim over the -/// environment's canonical tree with no assumptions, the packed digest key -/// worker 0's `verify_claim` takes as input, and the tree itself. -pub struct EnvCheckStatement { - pub claim: Claim, - pub digest_key: Vec, - claim_bytes: Vec, - tree: AssumptionTree, -} - -impl EnvCheckStatement { - /// The binding hash the statement is relative to, which every worker's - /// `check_owned` calls take. - pub fn binding(&self) -> Address { - self - .claim - .context() - .map(|ctx| ctx.binding.clone()) - .expect("an environment statement is a typing claim") - } - - /// The statement over `env` that validates its binding. - pub fn new(env: &Env) -> Result { - Self::with_binding(env, false) - } - - /// The statement over `env`, assuming its binding meets the - /// specifications when `assume_binding` (validator 4) and validating it - /// otherwise (validator 3). - pub fn with_binding(env: &Env, assume_binding: bool) -> Result { - let mut all: Vec
= - env.consts.iter().map(|entry| entry.key().clone()).collect(); - all.sort(); - let tree = AssumptionTree::canonical(&all) - .ok_or_else(|| "EnvCheckStatement: empty environment".to_string())?; - let mut ctx = ClaimContext::for_env(env)?; - ctx.binding_assumed = assume_binding; - let claim = Claim::CheckEnv { ctx, root: tree.root(), assumptions: None }; - let mut claim_bytes: Vec = Vec::new(); - claim.put(&mut claim_bytes); - let digest_key = packed_digest_key(&Address::hash(&claim_bytes)); - Ok(Self { claim, digest_key, claim_bytes, tree }) - } - - /// Worker `worker`'s IO buffer, built on demand (see - /// [`build_env_check_witnesses`] for the layout): a worker's execution - /// reads it, and a re-execution reads a fresh one. - pub fn worker_io( - &self, - env: &Env, - owners: &[Vec
], - worker: usize, - ) -> IOBuffer { - let mut io = IOBuffer { - data: rustc_hash::FxHashMap::default(), - map: rustc_hash::FxHashMap::default(), - }; - if worker == 0 { - extend( - &mut io, - G::ZERO, - self.digest_key.clone(), - bytes_to_g(&self.claim_bytes), - ); - extend( - &mut io, - G::ONE, - addr_key(&self.tree.root()), - bytes_to_g(&self.tree.ser()), - ); - if let Some(ax_tree) = ClaimContext::user_axiom_tree(env) { - extend( - &mut io, - G::ONE, - addr_key(&ax_tree.root()), - bytes_to_g(&ax_tree.ser()), - ); - } - } - let assume_binding = - self.claim.context().is_some_and(|ctx| ctx.binding_assumed); - add_entries_parallel( - env, - &witness_scope_with(env, &owners[worker], assume_binding), - &mut io, - ); - seed_binding(env, &mut io); - io - } -} - -/// Every worker's byte scope: the closure its `check_owned` runs can reach -/// from the constants it owns. -pub fn worker_scopes( - env: &Env, - owners: &[Vec
], -) -> Vec> { - owners.par_iter().map(|owned| witness_scope(env, owned)).collect() -} - -/// Which workers may call into which: `callers[r]` lists every worker -/// other than `r` whose byte scope (`scopes`, from [`worker_scopes`]) -/// contains a constant `r` owns, plus worker 0 for every `r`, whose -/// `verify_claim` walk reaches every chunk. A superset of the calls actually -/// deferred, so a worker whose callers have all executed can commit. -pub fn worker_callers( - owners: &[Vec
], - scopes: &[FxHashSet
], -) -> Vec> { - (0..owners.len()) - .map(|r| { - (0..owners.len()) - .filter(|&c| { - c != r - && (c == 0 || owners[r].iter().any(|addr| scopes[c].contains(addr))) - }) - .collect() - }) - .collect() -} - -/// Shard `CheckEnv` witness: thin-frontier claim (see -/// `ixon::shard_claim`) plus the `bfs_closure` byte scope the kernel -/// needs for its blake3-synthesized projection addresses. The frontier -/// membership set stays at `closure_from` granularity — the claim's walk -/// only follows refs + Prj→block edges; the block→wrapper edges -/// `bfs_closure` adds are byte scope only. -pub fn build_shard_check_env_witness( - env: &Env, - owned: &[Address], -) -> Result<(Claim, Vec, IOBuffer), String> { - build_shard_check_env_witness_with(env, owned, false) -} - -/// [`build_shard_check_env_witness`], whose claim assumes the environment's -/// binding meets the specifications when `assume_binding` (validator 4) and -/// validates it otherwise (validator 3). -pub fn build_shard_check_env_witness_with( - env: &Env, - owned: &[Address], - assume_binding: bool, -) -> Result<(Claim, Vec, IOBuffer), String> { - // Claim + THIN frontier from the shared convention module — the - // single source of truth for shard CheckEnv digests (see - // ixon::shard_claim; Lean mirror: - // IxVM.ClaimHarness.shardCheckEnvClaimThin). - let mut ctx = ClaimContext::for_env(env)?; - ctx.binding_assumed = assume_binding; - let (claim, frontier) = - ixon::shard_claim::shard_check_env_claim(&ctx, env, owned).ok_or_else( - || "build_shard_check_env_witness: empty owned set".to_string(), - )?; - let mut owned_sorted: Vec
= owned.to_vec(); - owned_sorted.sort(); - let owned_tree = - AssumptionTree::canonical(&owned_sorted).ok_or_else(|| { - "build_shard_check_env_witness: empty owned set".to_string() - })?; - let asm_tree = AssumptionTree::canonical(&frontier); - debug_assert_eq!( - claim, - Claim::CheckEnv { - ctx, - root: owned_tree.root(), - assumptions: asm_tree.as_ref().map(|t| t.root()), - } - ); - let mut claim_bytes: Vec = Vec::new(); - claim.put(&mut claim_bytes); - let digest = Address::hash(&claim_bytes); - let digest_key = packed_digest_key(&digest); - - let mut io = IOBuffer { - data: rustc_hash::FxHashMap::default(), - map: rustc_hash::FxHashMap::default(), - }; - extend(&mut io, G::ZERO, digest_key.clone(), bytes_to_g(&claim_bytes)); - let byte_scope = witness_scope_with(env, owned, assume_binding); - add_entries_parallel(env, &byte_scope, &mut io); - seed_binding(env, &mut io); - extend( - &mut io, - G::ONE, - addr_key(&owned_tree.root()), - bytes_to_g(&owned_tree.ser()), - ); - if let Some(at) = asm_tree { - extend(&mut io, G::ONE, addr_key(&at.root()), bytes_to_g(&at.ser())); - } - if let Some(ax_tree) = ClaimContext::user_axiom_tree(env) { - extend( - &mut io, - G::ONE, - addr_key(&ax_tree.root()), - bytes_to_g(&ax_tree.ser()), - ); - } - - Ok((claim, digest_key, io)) -} - -#[cfg(test)] -mod tests { - use super::*; - use ixon::constant::{Axiom, Constant, ConstantInfo}; - use ixon::expr::Expr; - use std::sync::Arc; - - fn const_with_refs(refs: Vec
) -> Constant { - Constant::with_tables( - ConstantInfo::Axio(Axiom { - is_unsafe: false, - lvls: 0, - typ: Arc::new(Expr::Sort(0)), - }), - Vec::new(), - refs, - Vec::new(), - ) - } - - #[test] - fn direct_arenas_preserve_serial_layout() { - let env = Env::new(); - let mut closure = FxHashSet::default(); - // Cross the old 256-entry chunk boundaries; include constant-only, - // blob-only, dual-use, missing, zero-length, and hint-only entries. - for i in 0_u32..600 { - let addr = Address::hash(&i.to_le_bytes()); - closure.insert(addr.clone()); - if i % 2 == 0 { - env.store_const(addr.clone(), const_with_refs(vec![])); - } - if i % 3 == 0 { - env - .blobs - .insert(addr.clone(), vec![i.to_le_bytes()[0]; (i % 17) as usize]); - } - if i % 5 == 0 { - env.anon_hints.insert(addr, ReducibilityHints::Regular(i)); - } - } - let initial = || { - let mut io = - IOBuffer { data: Default::default(), map: Default::default() }; - // Offsets must remain correct when appending to nonempty arenas. - for channel in [2, 3, 4] { - extend(&mut io, G::from_u8(channel), vec![G::ZERO], vec![G::ONE]); - } - io - }; - let mut expected = initial(); - let mut sorted: Vec<_> = closure.iter().collect(); - sorted.sort_unstable(); - for addr in sorted { - if let Some(c) = env.consts.get(addr) { - extend( - &mut expected, - G::from_u8(2), - addr_key(addr), - bytes_to_g(c.raw_bytes()), - ); - } - if let Some(b) = env.blobs.get(addr) { - extend( - &mut expected, - G::from_u8(4), - addr_key(addr), - bytes_to_g(b.value()), - ); - } - if let Some(h) = env.anon_hints.get(addr) { - extend( - &mut expected, - G::from_u8(3), - addr_key(addr), - vec![hint_to_g(&h)], - ); - } - } - for threads in [1, 4] { - let mut actual = initial(); - rayon::ThreadPoolBuilder::new() - .num_threads(threads) - .build() - .unwrap() - .install(|| add_entries_parallel(&env, &closure, &mut actual)); - assert_eq!(actual.data, expected.data); - assert_eq!(actual.map.len(), expected.map.len()); - for (key, info) in &expected.map { - let got = actual.map.get(key).unwrap(); - assert_eq!((got.idx, got.len), (info.idx, info.len)); - } - } - let mut empty = - IOBuffer { data: Default::default(), map: Default::default() }; - add_entries_parallel(&env, &FxHashSet::default(), &mut empty); - assert!(empty.data.is_empty()); - assert!(empty.map.is_empty()); - } - - /// One address can legitimately be read as both a constant and a blob - /// payload: blob and constant addresses share a hash codomain, and the - /// Expr context (`Ref`/`Prj` vs `Str`/`Nat`) is what disambiguates. The - /// kernel faults such an address from ch 2 and ch 4 independently, so - /// the witness must seed both — a constant hit must not suppress the - /// blob lookup, or the check aborts with `invalid IO key`. - #[test] - fn dual_use_address_is_seeded_on_both_channels() { - let mut env = Env::new(); - let section: Arc<[u8]> = Arc::from(&b"stand-in role binding section"[..]); - env.role_binding = Some(ixon::env::RoleBinding { - address: Address::hash(§ion), - bytes: section, - }); - let target = Address::hash(b"target"); - let dual = Address::hash(b"dual"); - env.store_const(target.clone(), const_with_refs(vec![dual.clone()])); - env.store_const(dual.clone(), const_with_refs(vec![])); - env.blobs.insert(dual.clone(), vec![1, 2, 3]); - - let (_, _, io) = build_claim_check_witness(&env, &target).unwrap(); - let key = addr_key(&dual); - assert!( - io.map.contains_key(&(G::from_u8(2), key.clone())), - "dual-use address missing from ch 2 (constant bytes)" - ); - assert!( - io.map.contains_key(&(G::from_u8(4), key)), - "dual-use address missing from ch 4 (blob bytes)" - ); - } -} diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs deleted file mode 100644 index f0b8140e6..000000000 --- a/crates/ixvm-codegen/src/aiur_multi_stark.rs +++ /dev/null @@ -1,1048 +0,0 @@ -// Auto-generated by Aiur codegen. Do not edit. -// Mirrors crates/aiur/src/execute.rs QueryRecord side effects. -#![cfg_attr(rustfmt, rustfmt::skip)] -#![allow(unused_variables, unused_assignments, unused_mut, dead_code, -unused_parens, non_snake_case, clippy::all, -clippy::ptr_as_ptr, clippy::match_same_arms, -clippy::large_types_passed_by_value)] -use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; -use aiur::G; -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); }) } -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); }, 1u64 => { 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_3: G = __io_read[0]; if (!unconstrained) { let __vi = __v_3; 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); } 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 __v_7: G = { let __values: [G; 3] = [__v_4, __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_1] = [__v_7]; record.function_queries[1].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __io_read: [G; 2] = { 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, 2)?; let __arr: [G; 2] = __data[..2].try_into().unwrap(); __arr }; let __v_3: G = __io_read[0]; let __v_4: G = __io_read[1]; 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); } let __v_5: G = G::from_u64(2); let __v_6: G = __v_1 + __v_5; let __v_7: G = __v_2 - __v_5; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6, __v_7]; 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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __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 __v_11: G = { let __values: [G; 3] = [__v_9, __v_3, __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_1] = [__v_11]; 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); }, } }) } -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); }) } -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 = __v_16 * __v_18; let __v_20: G = G::from_u64(2); let __v_21: G = __v_16 - __v_20; let __v_22: G = __v_19 * __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); }) } -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); }) } -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); }) } -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); }) } -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); }) } -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); }, } }) } -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); }, } }) } -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 = __v_0 + __v_10; let __v_12: G = G::from_u64(65536); let __v_13: G = __v_12 * __v_2; let __v_14: G = __v_11 + __v_13; let __v_15: G = G::from_u64(16777216); let __v_16: G = __v_15 * __v_3; let __v_17: G = __v_14 + __v_16; let __v_18: G = G::from_u64(4294967296); let __v_19: G = __v_18 * __v_4; let __v_20: G = __v_17 + __v_19; let __v_21: G = G::from_u64(1099511627776); let __v_22: G = __v_21 * __v_5; let __v_23: G = __v_20 + __v_22; let __v_24: G = G::from_u64(281474976710656); let __v_25: G = __v_24 * __v_6; let __v_26: G = __v_23 + __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 = __v_0 + __v_9; let __v_11: G = G::from_u64(65536); let __v_12: G = __v_11 * __v_2; let __v_13: G = __v_10 + __v_12; let __v_14: G = G::from_u64(16777216); let __v_15: G = __v_14 * __v_3; let __v_16: G = __v_13 + __v_15; let __v_17: G = G::from_u64(4294967296); let __v_18: G = __v_17 * __v_4; let __v_19: G = __v_16 + __v_18; let __v_20: G = G::from_u64(1099511627776); let __v_21: G = __v_20 * __v_5; let __v_22: G = __v_19 + __v_21; let __v_23: G = G::from_u64(281474976710656); let __v_24: G = __v_23 * __v_6; let __v_25: G = __v_22 + __v_24; let __v_26: G = G::from_u64(72057594037927936); let __v_27: G = __v_26 * __v_7; let __v_28: G = __v_25 + __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 = __v_4 + __v_5; let __v_9: G = __v_8 + __v_6; let __v_10: G = __v_9 + __v_7; let __v_11: G = G::from_u64(1020); let __v_12: G = __v_10 - __v_11; let __v_13: G = G::from_bool(__v_12 == G::ZERO); let __v_14: G = __v_0 + __v_1; let __v_15: G = __v_14 + __v_2; let __v_16: G = __v_15 + __v_3; 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 = __v_1 + __v_10; let __v_12: G = G::from_u64(65536); let __v_13: G = __v_12 * __v_3; let __v_14: G = __v_11 + __v_13; let __v_15: G = G::from_u64(16777216); let __v_16: G = __v_15 * __v_4; let __v_17: G = __v_14 + __v_16; let __v_18: G = G::from_u64(4294967296); let __v_19: G = __v_18 * __v_5; let __v_20: G = __v_17 + __v_19; let __v_21: G = G::from_u64(1099511627776); let __v_22: G = __v_21 * __v_6; let __v_23: G = __v_20 + __v_22; let __v_24: G = G::from_u64(281474976710656); let __v_25: G = __v_24 * __v_7; let __v_26: G = __v_23 + __v_25; let __v_27: G = G::from_u64(72057594037927936); let __v_28: G = __v_27 * __v_8; let __v_29: G = __v_26 + __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 = __v_5 + __v_6; let __v_31: G = __v_30 + __v_7; let __v_32: G = __v_31 + __v_8; let __v_33: G = G::from_u64(1020); let __v_34: G = __v_32 - __v_33; let __v_35: G = G::from_bool(__v_34 == G::ZERO); let __v_36: G = __v_1 + __v_2; let __v_37: G = __v_36 + __v_3; let __v_38: G = __v_37 + __v_4; 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); }) } -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); }) } -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); }) } -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); }) } -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); }) } -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); }) } -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); }) } -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); }) } -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())); }, } }) } -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); }) } -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); }) } -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); }) } -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); }) } -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); }) } -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 = __v_1 + __v_20; let __v_22: G = G::from_u64(65536); let __v_23: G = __v_22 * __v_3; let __v_24: G = __v_21 + __v_23; let __v_25: G = G::from_u64(16777216); let __v_26: G = __v_25 * __v_4; let __v_27: G = __v_24 + __v_26; let __v_28: G = G::from_u64(4294967296); let __v_29: G = __v_28 * __v_5; let __v_30: G = __v_27 + __v_29; let __v_31: G = G::from_u64(1099511627776); let __v_32: G = __v_31 * __v_6; let __v_33: G = __v_30 + __v_32; let __v_34: G = G::from_u64(281474976710656); let __v_35: G = __v_34 * __v_7; let __v_36: G = __v_33 + __v_35; let __v_37: G = G::from_u64(72057594037927936); let __v_38: G = __v_37 * __v_8; let __v_39: G = __v_36 + __v_38; let __v_40: G = __v_19 * __v_11; let __v_41: G = __v_10 + __v_40; let __v_42: G = __v_22 * __v_12; let __v_43: G = __v_41 + __v_42; let __v_44: G = __v_25 * __v_13; let __v_45: G = __v_43 + __v_44; let __v_46: G = __v_28 * __v_14; let __v_47: G = __v_45 + __v_46; let __v_48: G = __v_31 * __v_15; let __v_49: G = __v_47 + __v_48; let __v_50: G = __v_34 * __v_16; let __v_51: G = __v_49 + __v_50; let __v_52: G = __v_37 * __v_17; let __v_53: G = __v_51 + __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); }) } -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); }) } -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); }, } }) } -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); }) } -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); }, } }) } -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); }) } -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 = __v_2 + __v_21; let __v_23: G = G::from_u64(65536); let __v_24: G = __v_23 * __v_4; let __v_25: G = __v_22 + __v_24; let __v_26: G = G::from_u64(16777216); let __v_27: G = __v_26 * __v_5; let __v_28: G = __v_25 + __v_27; let __v_29: G = G::from_u64(4294967296); let __v_30: G = __v_29 * __v_6; let __v_31: G = __v_28 + __v_30; let __v_32: G = G::from_u64(1099511627776); let __v_33: G = __v_32 * __v_7; let __v_34: G = __v_31 + __v_33; let __v_35: G = G::from_u64(281474976710656); let __v_36: G = __v_35 * __v_8; let __v_37: G = __v_34 + __v_36; let __v_38: G = G::from_u64(72057594037927936); let __v_39: G = __v_38 * __v_9; let __v_40: G = __v_37 + __v_39; let __v_41: G = __v_20 * __v_12; let __v_42: G = __v_11 + __v_41; let __v_43: G = __v_23 * __v_13; let __v_44: G = __v_42 + __v_43; let __v_45: G = __v_26 * __v_14; let __v_46: G = __v_44 + __v_45; let __v_47: G = __v_29 * __v_15; let __v_48: G = __v_46 + __v_47; let __v_49: G = __v_32 * __v_16; let __v_50: G = __v_48 + __v_49; let __v_51: G = __v_35 * __v_17; let __v_52: G = __v_50 + __v_51; let __v_53: G = __v_38 * __v_18; let __v_54: G = __v_52 + __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); }) } -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); }, } }) } -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); }) } -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); }, } }) } -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); }) } -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); }, } }) } -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); }) } -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); }, } }) } -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); }) } -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); }, } }) } -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); }) } -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); }) } -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); }, } }) } -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); }) } -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); }) } -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); }) } -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); }, } }) } -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); }) } -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); }) } -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); }, } }) } -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); }) } -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); }, } }) } -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); }) } -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); }) } -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); }) } -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); }, } }) } -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); }) } -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); }) } -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); }, } }) } -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); }) } -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); }, } }) } -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); }) } -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 = __v_0 + __v_5; let __v_7: G = G::from_u64(65536); let __v_8: G = __v_7 * __v_2; let __v_9: G = __v_6 + __v_8; let __v_10: G = G::from_u64(16777216); let __v_11: G = __v_10 * __v_3; let __v_12: G = __v_9 + __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 = __v_0 + __v_33; let __v_35: G = G::from_u64(65536); let __v_36: G = __v_35 * __v_2; let __v_37: G = __v_34 + __v_36; let __v_38: G = G::from_u64(16777216); let __v_39: G = __v_38 * __v_3; let __v_40: G = __v_37 + __v_39; let __v_41: G = __v_32 * __v_5; let __v_42: G = __v_4 + __v_41; let __v_43: G = __v_35 * __v_6; let __v_44: G = __v_42 + __v_43; let __v_45: G = __v_38 * __v_7; let __v_46: G = __v_44 + __v_45; let __v_47: G = __v_32 * __v_9; let __v_48: G = __v_8 + __v_47; let __v_49: G = __v_35 * __v_10; let __v_50: G = __v_48 + __v_49; let __v_51: G = __v_38 * __v_11; let __v_52: G = __v_50 + __v_51; let __v_53: G = __v_32 * __v_13; let __v_54: G = __v_12 + __v_53; let __v_55: G = __v_35 * __v_14; let __v_56: G = __v_54 + __v_55; let __v_57: G = __v_38 * __v_15; let __v_58: G = __v_56 + __v_57; let __v_59: G = __v_32 * __v_17; let __v_60: G = __v_16 + __v_59; let __v_61: G = __v_35 * __v_18; let __v_62: G = __v_60 + __v_61; let __v_63: G = __v_38 * __v_19; let __v_64: G = __v_62 + __v_63; let __v_65: G = __v_32 * __v_21; let __v_66: G = __v_20 + __v_65; let __v_67: G = __v_35 * __v_22; let __v_68: G = __v_66 + __v_67; let __v_69: G = __v_38 * __v_23; let __v_70: G = __v_68 + __v_69; let __v_71: G = __v_32 * __v_25; let __v_72: G = __v_24 + __v_71; let __v_73: G = __v_35 * __v_26; let __v_74: G = __v_72 + __v_73; let __v_75: G = __v_38 * __v_27; let __v_76: G = __v_74 + __v_75; let __v_77: G = __v_32 * __v_29; let __v_78: G = __v_28 + __v_77; let __v_79: G = __v_35 * __v_30; let __v_80: G = __v_78 + __v_79; let __v_81: G = __v_38 * __v_31; let __v_82: G = __v_80 + __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); }) } -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_86] = { let __args: [G; IN_86] = [__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(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_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_86] = { let __args: [G; IN_86] = [__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(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_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())); }, } }) } -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_81] = { let __args: [G; IN_81] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(81, &__args[..])?) { [G::ZERO; OUT_81] } else { let (__hash, __hit) = record.function_queries[81].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[81].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => { aiur_fn_81::(__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_82] = { let __args: [G; IN_82] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(82, &__args[..])?) { [G::ZERO; OUT_82] } else { let (__hash, __hit) = record.function_queries[82].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[82].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => { aiur_fn_82::(__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 __loaded: [G; 3] = { let __base = 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_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; match __v_15.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_11, __v_13, __v_14, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(81, &__args[..])?) { [G::ZERO; OUT_81] } else { let (__hash, __hit) = record.function_queries[81].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[81].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => { aiur_fn_81::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_18]; record.function_queries[75].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 3] = [__v_18, __v_16, __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 }, } }; match __v_13.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_17, __v_19, __v_14, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(82, &__args[..])?) { [G::ZERO; OUT_82] } else { let (__hash, __hit) = record.function_queries[82].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[82].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => { aiur_fn_82::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_20]; record.function_queries[75].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(1); let __v_21: G = __v_13 + __v_20; let __v_22: G = __v_14 + __v_20; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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() { 1u64 => { let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_19, __v_21, __v_22, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(81, &__args[..])?) { [G::ZERO; OUT_81] } else { let (__hash, __hit) = record.function_queries[81].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[81].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => { aiur_fn_81::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_26]; record.function_queries[75].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 3] = [__v_26, __v_24, __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 }, } }; match __v_21.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_25, __v_27, __v_22, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(82, &__args[..])?) { [G::ZERO; OUT_82] } else { let (__hash, __hit) = record.function_queries[82].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[82].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => { aiur_fn_82::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_28]; record.function_queries[75].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(1); let __v_29: G = __v_21 + __v_28; let __v_30: G = __v_22 + __v_28; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; 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: 3 })?; if (!unconstrained) { __mq.bump_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() { 1u64 => { let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_27, __v_29, __v_30, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(81, &__args[..])?) { [G::ZERO; OUT_81] } else { let (__hash, __hit) = record.function_queries[81].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[81].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => { aiur_fn_81::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_34]; record.function_queries[75].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 3] = [__v_34, __v_32, __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 }, } }; match __v_29.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_33, __v_35, __v_30, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(82, &__args[..])?) { [G::ZERO; OUT_82] } else { let (__hash, __hit) = record.function_queries[82].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[82].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => { aiur_fn_82::(__args, __hash, record, io_buffer)? }, } } }; let __v_36: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_36]; record.function_queries[75].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_36: G = G::from_u64(1); let __v_37: G = __v_29 + __v_36; let __v_38: G = __v_30 + __v_36; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_33, __v_35, __v_37, __v_38, __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_39: G = __r_arr[0]; let __ret: [G; OUT_75] = [__v_39]; record.function_queries[75].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_76: usize = 7; -const IN_76: usize = 7; -const OUT_76: usize = 1; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __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_81] = { let __args: [G; IN_81] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(81, &__args[..])?) { [G::ZERO; OUT_81] } else { let (__hash, __hit) = record.function_queries[81].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[81].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => { aiur_fn_81::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_76] = [__v_10]; record.function_queries[76].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_82] = { let __args: [G; IN_82] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(82, &__args[..])?) { [G::ZERO; OUT_82] } else { let (__hash, __hit) = record.function_queries[82].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[82].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => { aiur_fn_82::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_76] = [__v_12]; record.function_queries[76].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 __loaded: [G; 3] = { let __base = 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_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; match __v_15.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_11, __v_13, __v_14, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(81, &__args[..])?) { [G::ZERO; OUT_81] } else { let (__hash, __hit) = record.function_queries[81].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[81].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => { aiur_fn_81::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_76] = [__v_18]; record.function_queries[76].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 3] = [__v_18, __v_16, __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 }, } }; match __v_13.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_17, __v_19, __v_14, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(82, &__args[..])?) { [G::ZERO; OUT_82] } else { let (__hash, __hit) = record.function_queries[82].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[82].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => { aiur_fn_82::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_76] = [__v_20]; record.function_queries[76].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(1); let __v_21: G = __v_13 + __v_20; let __v_22: G = __v_14 + __v_20; let __loaded: [G; 3] = { let __base = record.pointer_base; let __mq = record.memory_queries.get_index_mut(0).map(|(_, q)| q).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __idx = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?.checked_sub(__base).filter(|__i| ((*__i) < __mq.len())).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if (!unconstrained) { __mq.bump_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() { 1u64 => { let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_19, __v_21, __v_22, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(81, &__args[..])?) { [G::ZERO; OUT_81] } else { let (__hash, __hit) = record.function_queries[81].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[81].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => { aiur_fn_81::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_76] = [__v_26]; record.function_queries[76].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 3] = [__v_26, __v_24, __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 }, } }; match __v_21.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_25, __v_27, __v_22, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(82, &__args[..])?) { [G::ZERO; OUT_82] } else { let (__hash, __hit) = record.function_queries[82].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[82].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => { aiur_fn_82::(__args, __hash, record, io_buffer)? }, } } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_76] = [__v_28]; record.function_queries[76].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(1); let __v_29: G = __v_21 + __v_28; let __v_30: G = __v_22 + __v_28; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_25, __v_27, __v_29, __v_30, __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_31: G = __r_arr[0]; let __ret: [G; OUT_76] = [__v_31]; record.function_queries[76].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_77: usize = 7; -const IN_77: usize = 7; -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]; let __v_2: G = inp[2]; let __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_81] = { let __args: [G; IN_81] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(81, &__args[..])?) { [G::ZERO; OUT_81] } else { let (__hash, __hit) = record.function_queries[81].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[81].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => { aiur_fn_81::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_77] = [__v_10]; record.function_queries[77].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_82] = { let __args: [G; IN_82] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(82, &__args[..])?) { [G::ZERO; OUT_82] } else { let (__hash, __hit) = record.function_queries[82].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[82].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => { aiur_fn_82::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_77] = [__v_12]; record.function_queries[77].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 __loaded: [G; 3] = { let __base = 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_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; match __v_15.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_11, __v_13, __v_14, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(81, &__args[..])?) { [G::ZERO; OUT_81] } else { let (__hash, __hit) = record.function_queries[81].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[81].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => { aiur_fn_81::(__args, __hash, record, io_buffer)? }, } } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_77] = [__v_18]; record.function_queries[77].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 3] = [__v_18, __v_16, __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 }, } }; match __v_13.as_canonical_u64() { 63u64 => { let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_17, __v_19, __v_14, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(82, &__args[..])?) { [G::ZERO; OUT_82] } else { let (__hash, __hit) = record.function_queries[82].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[82].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => { aiur_fn_82::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_77] = [__v_20]; record.function_queries[77].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(1); let __v_21: G = __v_13 + __v_20; let __v_22: G = __v_14 + __v_20; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_17, __v_19, __v_21, __v_22, __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_23: G = __r_arr[0]; let __ret: [G; OUT_77] = [__v_23]; record.function_queries[77].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_78: usize = 7; -const IN_78: usize = 7; -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 = 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_81] = { let __args: [G; IN_81] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(81, &__args[..])?) { [G::ZERO; OUT_81] } else { let (__hash, __hit) = record.function_queries[81].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[81].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => { aiur_fn_81::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_10]; record.function_queries[78].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_82] = { let __args: [G; IN_82] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(82, &__args[..])?) { [G::ZERO; OUT_82] } else { let (__hash, __hit) = record.function_queries[82].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[82].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => { aiur_fn_82::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_78] = [__v_12]; record.function_queries[78].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_78] = [__v_15]; record.function_queries[78].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_79: usize = 1; -const IN_79: usize = 1; -const OUT_79: usize = 64; -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 __loaded: [G; 3] = { let __base = 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_79] = [__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[79].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_80: usize = 2; -const IN_80: usize = 2; -const OUT_80: usize = 1; -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]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_80] = [__v_0]; record.function_queries[80].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_80] = { let __args: [G; IN_80] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(80, &__args[..])?) { [G::ZERO; OUT_80] } else { let (__hash, __hit) = record.function_queries[80].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[80].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => { aiur_fn_80::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_80] = [__v_6]; record.function_queries[80].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_81: usize = 6; -const IN_81: usize = 6; -const OUT_81: usize = 1; -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 = 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_8 + __v_6; let __v_18: G = __v_17 + __v_7; 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_86] = { let __args: [G; IN_86] = [__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(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_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_81] = [__v_107]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_81] = [__v_5]; record.function_queries[81].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_81] = [__v_42]; record.function_queries[81].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_7 + __v_18; let __v_20: G = __v_2 - __v_1; let __v_21: G = G::from_bool(__v_20 == G::ZERO); let __v_22: G = __v_21 * __v_6; let __v_23: G = __v_19 + __v_22; let __v_24: G = G::from_u64(64); let __v_25: G = __v_24 - __v_1; let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0, __v_25]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(80, &__args[..])?) { [G::ZERO; OUT_80] } else { let (__hash, __hit) = record.function_queries[80].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[80].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => { aiur_fn_80::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_26]; 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_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_86] = { let __args: [G; IN_86] = [__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(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_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_81] = [__v_171]; record.function_queries[81].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_82: usize = 6; -const IN_82: usize = 6; -const OUT_82: usize = 1; -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 = 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_79] = { let __args: [G; IN_79] = [__v_1]; 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_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_252] = { let __args: [G; IN_252] = [__v_0]; 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_73: G = __r_arr[0]; let __v_74: G = __v_8 * __v_73; 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_75: G = __loaded[0]; let __v_76: G = __loaded[1]; let __v_77: G = __loaded[2]; let __v_78: G = __loaded[3]; let __v_79: G = __loaded[4]; let __v_80: G = __loaded[5]; let __v_81: G = __loaded[6]; let __v_82: G = __loaded[7]; let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; 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_83: G = __r_arr[0]; let __v_84: G = __v_74 * __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_86] = { let __args: [G; IN_86] = [__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_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __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(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_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_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; 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_82] = [__v_196]; record.function_queries[82].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0]; 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_73: G = __r_arr[0]; let __v_74: G = __v_73 * __v_7; let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0]; 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_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_75 * __v_84; let __v_86: G = __v_85 * __v_8; 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_74 + __v_86; let __v_92: G = __v_91 + __v_90; 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_86] = { let __args: [G; IN_86] = [__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(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_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_82] = [__v_178]; record.function_queries[82].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_83: usize = 24; -const IN_83: usize = 24; -const OUT_83: usize = 16; -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 __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 = __v_28 * __v_30; let __v_32: G = G::from_u64(2); let __v_33: G = __v_28 - __v_32; let __v_34: G = __v_31 * __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_63; let __v_65: G = __v_62 - __v_32; let __v_66: G = __v_64 * __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_83] = [__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[83].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_84: usize = 128; -const IN_84: usize = 128; -const OUT_84: usize = 128; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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 = __v_132 * __v_134; let __v_136: G = G::from_u64(2); let __v_137: G = __v_132 - __v_136; let __v_138: G = __v_135 * __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_167; let __v_169: G = __v_166 - __v_136; let __v_170: G = __v_168 * __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_198; let __v_200: G = __v_197 - __v_136; let __v_201: G = __v_199 * __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_229; let __v_231: G = __v_228 - __v_136; let __v_232: G = __v_230 * __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_260; let __v_262: G = __v_259 - __v_136; let __v_263: G = __v_261 * __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_291; let __v_293: G = __v_290 - __v_136; let __v_294: G = __v_292 * __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_322; let __v_324: G = __v_321 - __v_136; let __v_325: G = __v_323 * __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_353; let __v_355: G = __v_352 - __v_136; let __v_356: G = __v_354 * __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_384; let __v_386: G = __v_383 - __v_136; let __v_387: G = __v_385 * __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_415; let __v_417: G = __v_414 - __v_136; let __v_418: G = __v_416 * __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_446; let __v_448: G = __v_445 - __v_136; let __v_449: G = __v_447 * __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_477; let __v_479: G = __v_476 - __v_136; let __v_480: G = __v_478 * __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_508; let __v_510: G = __v_507 - __v_136; let __v_511: G = __v_509 * __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_539; let __v_541: G = __v_538 - __v_136; let __v_542: G = __v_540 * __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_570; let __v_572: G = __v_569 - __v_136; let __v_573: G = __v_571 * __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_601; let __v_603: G = __v_600 - __v_136; let __v_604: G = __v_602 * __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_84] = [__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[84].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_85: usize = 106; -const IN_85: usize = 106; -const OUT_85: usize = 32; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_86] = { let __args: [G; IN_86] = [__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(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_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_85] = [__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[85].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_86: usize = 129; -const IN_86: usize = 129; -const OUT_86: usize = 32; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_86] = [__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[86].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 = __v_133 * __v_135; let __v_137: G = G::from_u64(2); let __v_138: G = __v_133 - __v_137; let __v_139: G = __v_136 * __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_168; let __v_170: G = __v_167 - __v_137; let __v_171: G = __v_169 * __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_199; let __v_201: G = __v_198 - __v_137; let __v_202: G = __v_200 * __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_230; let __v_232: G = __v_229 - __v_137; let __v_233: G = __v_231 * __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_261; let __v_263: G = __v_260 - __v_137; let __v_264: G = __v_262 * __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_292; let __v_294: G = __v_291 - __v_137; let __v_295: G = __v_293 * __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_323; let __v_325: G = __v_322 - __v_137; let __v_326: G = __v_324 * __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_354; let __v_356: G = __v_353 - __v_137; let __v_357: G = __v_355 * __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_385; let __v_387: G = __v_384 - __v_137; let __v_388: G = __v_386 * __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_416; let __v_418: G = __v_415 - __v_137; let __v_419: G = __v_417 * __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_447; let __v_449: G = __v_446 - __v_137; let __v_450: G = __v_448 * __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_478; let __v_480: G = __v_477 - __v_137; let __v_481: G = __v_479 * __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_509; let __v_511: G = __v_508 - __v_137; let __v_512: G = __v_510 * __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_540; let __v_542: G = __v_539 - __v_137; let __v_543: G = __v_541 * __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_571; let __v_573: G = __v_570 - __v_137; let __v_574: G = __v_572 * __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_602; let __v_604: G = __v_601 - __v_137; let __v_605: G = __v_603 * __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_86] = { let __args: [G; IN_86] = [__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(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_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_86] = [__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[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 = 2; -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 __loaded: [G; 3] = { let __base = 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_87] = [__v_2, __v_3]; record.function_queries[87].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_88: usize = 1; -const IN_88: usize = 1; -const OUT_88: usize = 2; -fn aiur_fn_88(inp: [G; IN_88], 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_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 __ret: [G; OUT_88] = [__v_1, __v_2]; 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 = 2; -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_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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; 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_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_89] = [__v_7, __v_4]; 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 = 10; -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_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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; 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_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_90] = [__v_7, __v_1, __v_3, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_4]; 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 = 10; -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_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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_4]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_6]; 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_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 = __v_1 + __v_10; let __v_12: G = G::from_u64(65536); let __v_13: G = __v_12 * __v_5; let __v_14: G = __v_11 + __v_13; let __v_15: G = G::from_u64(16777216); let __v_16: G = __v_15 * __v_7; let __v_17: G = __v_14 + __v_16; let __v_18: G = G::from_u64(0); let __ret: [G; OUT_91] = [__v_17, __v_1, __v_3, __v_5, __v_7, __v_18, __v_18, __v_18, __v_18, __v_8]; record.function_queries[91].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_92: usize = 1; -const IN_92: usize = 1; -const OUT_92: usize = 9; -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 __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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_4]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; 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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_14]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_92] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; record.function_queries[92].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_93: usize = 1; -const IN_93: usize = 1; -const OUT_93: usize = 2; -fn aiur_fn_93(inp: [G; IN_93], 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 __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_0]; 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_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 = __v_1 + __v_11; let __v_13: G = G::from_u64(65536); let __v_14: G = __v_13 * __v_3; let __v_15: G = __v_12 + __v_14; let __v_16: G = G::from_u64(16777216); let __v_17: G = __v_16 * __v_4; let __v_18: G = __v_15 + __v_17; let __v_19: G = G::from_u64(4294967296); let __v_20: G = __v_19 * __v_5; let __v_21: G = __v_18 + __v_20; let __v_22: G = G::from_u64(1099511627776); let __v_23: G = __v_22 * __v_6; let __v_24: G = __v_21 + __v_23; let __v_25: G = G::from_u64(281474976710656); let __v_26: G = __v_25 * __v_7; let __v_27: G = __v_24 + __v_26; let __v_28: G = G::from_u64(72057594037927936); let __v_29: G = __v_28 * __v_8; let __v_30: G = __v_27 + __v_29; let __ret: [G; OUT_93] = [__v_30, __v_9]; record.function_queries[93].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_94: usize = 1; -const IN_94: usize = 1; -const OUT_94: usize = 33; -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 __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_0]; 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_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_92] = { let __args: [G; IN_92] = [__v_9]; 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_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_92] = { let __args: [G; IN_92] = [__v_18]; 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_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_92] = { let __args: [G; IN_92] = [__v_27]; 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_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_94] = [__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[94].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_95: usize = 2; -const IN_95: usize = 2; -const OUT_95: usize = 2; -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 __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_95] = [__v_3, __v_0]; record.function_queries[95].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_0]; 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_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_92] = { let __args: [G; IN_92] = [__v_10]; 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_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_92] = { let __args: [G; IN_92] = [__v_19]; 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_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_92] = { let __args: [G; IN_92] = [__v_28]; 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_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_95] = { let __args: [G; IN_95] = [__v_37, __v_39]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(95, &__args[..])?) { [G::ZERO; OUT_95] } else { let (__hash, __hit) = record.function_queries[95].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[95].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => { aiur_fn_95::(__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_95] = [__v_44, __v_41]; record.function_queries[95].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_96: usize = 3; -const IN_96: usize = 3; -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]; 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_96] = [__v_4, __v_0]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_0]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; match __v_3.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; 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_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_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __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; 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_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_4]; 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_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_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __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; 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_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_4]; 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_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_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __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 = 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_96] = [__v_14, __v_11]; record.function_queries[96].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_96] = { let __args: [G; IN_96] = [__v_4, __v_6, __v_7]; 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_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_96] = [__v_12, __v_9]; record.function_queries[96].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_96] = { let __args: [G; IN_96] = [__v_4, __v_6, __v_7]; 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_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_96] = [__v_12, __v_9]; record.function_queries[96].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_96] = { let __args: [G; IN_96] = [__v_4, __v_6, __v_7]; 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_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_96] = [__v_12, __v_9]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_6]; 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_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_96] = { let __args: [G; IN_96] = [__v_8, __v_12, __v_13]; 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_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_96] = [__v_18, __v_15]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_6]; 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_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_96] = { let __args: [G; IN_96] = [__v_8, __v_12, __v_13]; 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_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_96] = [__v_18, __v_15]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_6]; 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_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_96] = { let __args: [G; IN_96] = [__v_8, __v_12, __v_13]; 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_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_96] = [__v_18, __v_15]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; 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_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_96] = { let __args: [G; IN_96] = [__v_6, __v_9, __v_10]; 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_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_96] = [__v_15, __v_12]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; 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_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_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __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; 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_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; 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_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_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __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; 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_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; 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_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_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __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; 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_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; 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_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_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __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; 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_96] = [__v_13, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; 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_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_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __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 = 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_96] = [__v_14, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_4]; 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_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_96] = { let __args: [G; IN_96] = [__v_6, __v_8, __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 = 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_96] = [__v_14, __v_11]; record.function_queries[96].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_97: usize = 2; -const IN_97: usize = 2; -const OUT_97: usize = 2; -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]; 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_97] = [__v_3, __v_0]; record.function_queries[97].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 = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_3, __v_5]; 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 = __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_97] = [__v_9, __v_7]; 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 = 3; -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_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 __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_4, __v_3]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_98] = [__v_1, __v_5, __v_6]; record.function_queries[98].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_99: usize = 2; -const IN_99: usize = 2; -const OUT_99: usize = 2; -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]; 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_99] = [__v_3, __v_0]; record.function_queries[99].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 __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_3]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_5, __v_4]; 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 = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = __v_1 - __v_8; let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_7, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__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_99] = [__v_13, __v_11]; record.function_queries[99].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_100: usize = 3; -const IN_100: usize = 3; -const OUT_100: usize = 1; -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]; 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_100] = [__v_3]; record.function_queries[100].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_100] = { let __args: [G; IN_100] = [__v_4, __v_5, __v_2]; 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_6: G = __r_arr[0]; let __v_7: G = __v_3 + __v_6; let __ret: [G; OUT_100] = [__v_7]; record.function_queries[100].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_100] = { let __args: [G; IN_100] = [__v_4, __v_5, __v_2]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_100] = [__v_6]; 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 = 66; -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_90] = { let __args: [G; IN_90] = [__v_0]; 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_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_90] = { let __args: [G; IN_90] = [__v_10]; 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_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_91] = { let __args: [G; IN_91] = [__v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(91, &__args[..])?) { [G::ZERO; OUT_91] } else { let (__hash, __hit) = record.function_queries[91].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[91].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[91].bump_multiplicity(__i); } let __ret: [G; OUT_91] = unsafe { *(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91]) }; __ret }, _ => { aiur_fn_91::(__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_90] = { let __args: [G; IN_90] = [__v_30]; 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_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_88] = { let __args: [G; IN_88] = [__v_40]; 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_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_42]; 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_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_96] = { let __args: [G; IN_96] = [__v_44, __v_43, __v_45]; 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_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_47]; 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_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_49, __v_48]; 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_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_51]; 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_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_53, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__args, __hash, record, io_buffer)? }, } } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_52, __v_45, __v_41]; 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_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 = __v_61 + __v_70; let __v_72: G = G::from_u64(65536); let __v_73: G = __v_72 * __v_63; let __v_74: G = __v_71 + __v_73; let __v_75: G = G::from_u64(16777216); let __v_76: G = __v_75 * __v_64; let __v_77: G = __v_74 + __v_76; let __v_78: G = G::from_u64(4294967296); let __v_79: G = __v_78 * __v_65; let __v_80: G = __v_77 + __v_79; let __v_81: G = G::from_u64(1099511627776); let __v_82: G = __v_81 * __v_66; let __v_83: G = __v_80 + __v_82; let __v_84: G = G::from_u64(281474976710656); let __v_85: G = __v_84 * __v_67; let __v_86: G = __v_83 + __v_85; let __v_87: G = G::from_u64(72057594037927936); let __v_88: G = __v_87 * __v_68; let __v_89: G = __v_86 + __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 = __v_65 + __v_66; let __v_91: G = __v_90 + __v_67; let __v_92: G = __v_91 + __v_68; let __v_93: G = G::from_u64(1020); let __v_94: G = __v_92 - __v_93; let __v_95: G = G::from_bool(__v_94 == G::ZERO); let __v_96: G = __v_61 + __v_62; let __v_97: G = __v_96 + __v_63; let __v_98: G = __v_97 + __v_64; 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_104 + __v_112; let __v_114: G = __v_72 * __v_106; let __v_115: G = __v_113 + __v_114; let __v_116: G = __v_75 * __v_107; let __v_117: G = __v_115 + __v_116; let __v_118: G = __v_78 * __v_108; let __v_119: G = __v_117 + __v_118; let __v_120: G = __v_81 * __v_109; let __v_121: G = __v_119 + __v_120; let __v_122: G = __v_84 * __v_110; let __v_123: G = __v_121 + __v_122; let __v_124: G = __v_87 * __v_111; let __v_125: G = __v_123 + __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_108 + __v_109; let __v_127: G = __v_126 + __v_110; let __v_128: G = __v_127 + __v_111; let __v_129: G = __v_128 - __v_93; let __v_130: G = G::from_bool(__v_129 == G::ZERO); let __v_131: G = __v_104 + __v_105; let __v_132: G = __v_131 + __v_106; let __v_133: G = __v_132 + __v_107; 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_138 + __v_146; let __v_148: G = __v_72 * __v_140; let __v_149: G = __v_147 + __v_148; let __v_150: G = __v_75 * __v_141; let __v_151: G = __v_149 + __v_150; let __v_152: G = __v_78 * __v_142; let __v_153: G = __v_151 + __v_152; let __v_154: G = __v_81 * __v_143; let __v_155: G = __v_153 + __v_154; let __v_156: G = __v_84 * __v_144; let __v_157: G = __v_155 + __v_156; let __v_158: G = __v_87 * __v_145; let __v_159: G = __v_157 + __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_142 + __v_143; let __v_161: G = __v_160 + __v_144; let __v_162: G = __v_161 + __v_145; let __v_163: G = __v_162 - __v_93; let __v_164: G = G::from_bool(__v_163 == G::ZERO); let __v_165: G = __v_138 + __v_139; let __v_166: G = __v_165 + __v_140; let __v_167: G = __v_166 + __v_141; 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_101] = [__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[101].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_102: usize = 57; -const IN_102: usize = 57; -const OUT_102: usize = 1; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_102] = [__v_64]; record.function_queries[102].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_103: usize = 2; -const IN_103: usize = 2; -const OUT_103: usize = 3; -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 __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_103] = [__v_3, __v_4, __v_0]; record.function_queries[103].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; 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_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_90] = { let __args: [G; IN_90] = [__v_11]; 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_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_91] = { let __args: [G; IN_91] = [__v_21]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(91, &__args[..])?) { [G::ZERO; OUT_91] } else { let (__hash, __hit) = record.function_queries[91].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[91].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[91].bump_multiplicity(__i); } let __ret: [G; OUT_91] = unsafe { *(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91]) }; __ret }, _ => { aiur_fn_91::(__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_90] = { let __args: [G; IN_90] = [__v_31]; 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_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_88] = { let __args: [G; IN_88] = [__v_41]; 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_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_43]; 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_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_96] = { let __args: [G; IN_96] = [__v_45, __v_44, __v_46]; 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_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_48]; 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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_50, __v_49]; 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_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_52]; 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_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_54, __v_53]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(99, &__args[..])?) { [G::ZERO; OUT_99] } else { let (__hash, __hit) = record.function_queries[99].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[99].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => { aiur_fn_99::(__args, __hash, record, io_buffer)? }, } } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_53, __v_46, __v_42]; 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_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 = __v_62 + __v_71; let __v_73: G = G::from_u64(65536); let __v_74: G = __v_73 * __v_64; let __v_75: G = __v_72 + __v_74; let __v_76: G = G::from_u64(16777216); let __v_77: G = __v_76 * __v_65; let __v_78: G = __v_75 + __v_77; let __v_79: G = G::from_u64(4294967296); let __v_80: G = __v_79 * __v_66; let __v_81: G = __v_78 + __v_80; let __v_82: G = G::from_u64(1099511627776); let __v_83: G = __v_82 * __v_67; let __v_84: G = __v_81 + __v_83; let __v_85: G = G::from_u64(281474976710656); let __v_86: G = __v_85 * __v_68; let __v_87: G = __v_84 + __v_86; let __v_88: G = G::from_u64(72057594037927936); let __v_89: G = __v_88 * __v_69; let __v_90: G = __v_87 + __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 = __v_66 + __v_67; let __v_92: G = __v_91 + __v_68; let __v_93: G = __v_92 + __v_69; let __v_94: G = G::from_u64(1020); let __v_95: G = __v_93 - __v_94; let __v_96: G = G::from_bool(__v_95 == G::ZERO); let __v_97: G = __v_62 + __v_63; let __v_98: G = __v_97 + __v_64; let __v_99: G = __v_98 + __v_65; 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_105 + __v_113; let __v_115: G = __v_73 * __v_107; let __v_116: G = __v_114 + __v_115; let __v_117: G = __v_76 * __v_108; let __v_118: G = __v_116 + __v_117; let __v_119: G = __v_79 * __v_109; let __v_120: G = __v_118 + __v_119; let __v_121: G = __v_82 * __v_110; let __v_122: G = __v_120 + __v_121; let __v_123: G = __v_85 * __v_111; let __v_124: G = __v_122 + __v_123; let __v_125: G = __v_88 * __v_112; let __v_126: G = __v_124 + __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_109 + __v_110; let __v_128: G = __v_127 + __v_111; let __v_129: G = __v_128 + __v_112; let __v_130: G = __v_129 - __v_94; let __v_131: G = G::from_bool(__v_130 == G::ZERO); let __v_132: G = __v_105 + __v_106; let __v_133: G = __v_132 + __v_107; let __v_134: G = __v_133 + __v_108; 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_139 + __v_147; let __v_149: G = __v_73 * __v_141; let __v_150: G = __v_148 + __v_149; let __v_151: G = __v_76 * __v_142; let __v_152: G = __v_150 + __v_151; let __v_153: G = __v_79 * __v_143; let __v_154: G = __v_152 + __v_153; let __v_155: G = __v_82 * __v_144; let __v_156: G = __v_154 + __v_155; let __v_157: G = __v_85 * __v_145; let __v_158: G = __v_156 + __v_157; let __v_159: G = __v_88 * __v_146; let __v_160: G = __v_158 + __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_143 + __v_144; let __v_162: G = __v_161 + __v_145; let __v_163: G = __v_162 + __v_146; let __v_164: G = __v_163 - __v_94; let __v_165: G = G::from_bool(__v_164 == G::ZERO); let __v_166: G = __v_139 + __v_140; let __v_167: G = __v_166 + __v_141; let __v_168: G = __v_167 + __v_142; 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_103] = { let __args: [G; IN_103] = [__v_56, __v_173]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(103, &__args[..])?) { [G::ZERO; OUT_103] } else { let (__hash, __hit) = record.function_queries[103].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[103].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => { aiur_fn_103::(__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_103] = [__v_177, __v_184, __v_176]; 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 = 3; -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]; match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_104] = [__v_3, __v_3, __v_2]; record.function_queries[104].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_4, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(95, &__args[..])?) { [G::ZERO; OUT_95] } else { let (__hash, __hit) = record.function_queries[95].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[95].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => { aiur_fn_95::(__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_104] = [__v_7, __v_5, __v_6]; record.function_queries[104].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_105: usize = 2; -const IN_105: usize = 2; -const OUT_105: usize = 2; -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]; 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_105] = [__v_3, __v_0]; record.function_queries[105].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 = G::from_u64(1); let __v_5: G = __v_1 - __v_4; let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_3, __v_5]; 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_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_105] = [__v_9, __v_7]; record.function_queries[105].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_105] = [__v_10, __v_7]; record.function_queries[105].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_106: usize = 1; -const IN_106: usize = 1; -const OUT_106: usize = 9; -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 __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; 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_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_90] = { let __args: [G; IN_90] = [__v_10]; 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_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_90] = { let __args: [G; IN_90] = [__v_20]; 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_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_90] = { let __args: [G; IN_90] = [__v_30]; 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_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_90] = { let __args: [G; IN_90] = [__v_40]; 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_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_90] = { let __args: [G; IN_90] = [__v_50]; 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_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_90] = { let __args: [G; IN_90] = [__v_60]; 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_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_106] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_80, __v_70]; record.function_queries[106].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_107: usize = 1; -const IN_107: usize = 1; -const OUT_107: usize = 13; -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 __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; 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_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_90] = { let __args: [G; IN_90] = [__v_10]; 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_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_90] = { let __args: [G; IN_90] = [__v_20]; 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_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_90] = { let __args: [G; IN_90] = [__v_30]; 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_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_90] = { let __args: [G; IN_90] = [__v_40]; 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_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_90] = { let __args: [G; IN_90] = [__v_50]; 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_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_90] = { let __args: [G; IN_90] = [__v_60]; 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_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_90] = { let __args: [G; IN_90] = [__v_70]; 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_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_103] = { let __args: [G; IN_103] = [__v_90, __v_81]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(103, &__args[..])?) { [G::ZERO; OUT_103] } else { let (__hash, __hit) = record.function_queries[103].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[103].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => { aiur_fn_103::(__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_104] = { let __args: [G; IN_104] = [__v_93]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(104, &__args[..])?) { [G::ZERO; OUT_104] } else { let (__hash, __hit) = record.function_queries[104].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[104].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[104].bump_multiplicity(__i); } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => { aiur_fn_104::(__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_105] = { let __args: [G; IN_105] = [__v_96, __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_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_254] = { let __args: [G; IN_254] = [__v_80, __v_99]; 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_100: G = __r_arr[0]; let __ret: [G; OUT_107] = [__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[107].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_108: usize = 5; -const IN_108: usize = 5; -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 = 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_108] = [__v_9]; record.function_queries[108].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_109: usize = 33; -const IN_109: usize = 33; -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]; let __v_3: G = inp[3]; let __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_108] = { let __args: [G; IN_108] = [__v_28, __v_29, __v_30, __v_31, __v_32]; 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_33: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_24, __v_25, __v_26, __v_27, __v_33]; 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_34: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_20, __v_21, __v_22, __v_23, __v_34]; 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_35: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_16, __v_17, __v_18, __v_19, __v_35]; 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_36: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_12, __v_13, __v_14, __v_15, __v_36]; 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_37: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_8, __v_9, __v_10, __v_11, __v_37]; 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_38: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_4, __v_5, __v_6, __v_7, __v_38]; 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_39: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_0, __v_1, __v_2, __v_3, __v_39]; 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_40: G = __r_arr[0]; let __ret: [G; OUT_109] = [__v_40]; record.function_queries[109].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_110: usize = 32; -const IN_110: usize = 32; -const OUT_110: usize = 32; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_110] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; record.function_queries[110].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_111: usize = 2; -const IN_111: usize = 2; -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 = 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_86] = { let __args: [G; IN_86] = [__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(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_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_111] = [__v_132]; record.function_queries[111].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -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]; match __v_0.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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 __ret: [G; OUT_112] = [__v_3]; record.function_queries[112].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2, __v_1]; 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 __ret: [G; OUT_112] = [__v_3]; record.function_queries[112].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_113: usize = 2; -const IN_113: usize = 2; -const OUT_113: usize = 1; -fn aiur_fn_113(inp: [G; IN_113], 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; 3] = { let __base = 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_113] = [__v_5]; record.function_queries[113].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_113] = [__v_7]; record.function_queries[113].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_4, __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_7: G = __r_arr[0]; let __ret: [G; OUT_113] = [__v_7]; record.function_queries[113].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_114: usize = 3; -const IN_114: usize = 3; -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 __loaded: [G; 3] = { let __base = 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_114] = [__v_7]; record.function_queries[114].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_114] = { let __args: [G; IN_114] = [__v_5, __v_8, __v_2]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_114] = [__v_11]; record.function_queries[114].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_114] = { let __args: [G; IN_114] = [__v_5, __v_8, __v_2]; 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_21: G = __r_arr[0]; let __ret: [G; OUT_114] = [__v_21]; record.function_queries[114].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_21: G = G::from_u64(0); let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_5, __v_8, __v_2]; 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_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_114] = [__v_23]; record.function_queries[114].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_115: usize = 3; -const IN_115: usize = 3; -const OUT_115: usize = 1; -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 = 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_115] = [__v_7]; record.function_queries[115].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_115] = { let __args: [G; IN_115] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(115, &__args[..])?) { [G::ZERO; OUT_115] } else { let (__hash, __hit) = record.function_queries[115].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[115].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => { aiur_fn_115::(__args, __hash, record, io_buffer)? }, } } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_115] = [__v_10]; record.function_queries[115].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_115] = { let __args: [G; IN_115] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(115, &__args[..])?) { [G::ZERO; OUT_115] } else { let (__hash, __hit) = record.function_queries[115].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[115].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => { aiur_fn_115::(__args, __hash, record, io_buffer)? }, } } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_115] = [__v_20]; record.function_queries[115].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(115, &__args[..])?) { [G::ZERO; OUT_115] } else { let (__hash, __hit) = record.function_queries[115].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[115].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => { aiur_fn_115::(__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_115] = [__v_22]; record.function_queries[115].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_116: usize = 2; -const IN_116: usize = 2; -const OUT_116: usize = 11; -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 __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 = __v_3 + __v_13; let __v_15: G = G::from_u64(65536); let __v_16: G = __v_15 * __v_5; let __v_17: G = __v_14 + __v_16; let __v_18: G = G::from_u64(16777216); let __v_19: G = __v_18 * __v_6; let __v_20: G = __v_17 + __v_19; let __v_21: G = G::from_u64(4294967296); let __v_22: G = __v_21 * __v_7; let __v_23: G = __v_20 + __v_22; let __v_24: G = G::from_u64(1099511627776); let __v_25: G = __v_24 * __v_8; let __v_26: G = __v_23 + __v_25; let __v_27: G = G::from_u64(281474976710656); let __v_28: G = __v_27 * __v_9; let __v_29: G = __v_26 + __v_28; let __v_30: G = G::from_u64(72057594037927936); let __v_31: G = __v_30 * __v_10; let __v_32: G = __v_29 + __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_33 + __v_41; let __v_43: G = __v_15 * __v_35; let __v_44: G = __v_42 + __v_43; let __v_45: G = __v_18 * __v_36; let __v_46: G = __v_44 + __v_45; let __v_47: G = __v_21 * __v_37; let __v_48: G = __v_46 + __v_47; let __v_49: G = __v_24 * __v_38; let __v_50: G = __v_48 + __v_49; let __v_51: G = __v_27 * __v_39; let __v_52: G = __v_50 + __v_51; let __v_53: G = __v_30 * __v_40; let __v_54: G = __v_52 + __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 = __v_37 + __v_38; let __v_56: G = __v_55 + __v_39; let __v_57: G = __v_56 + __v_40; let __v_58: G = G::from_u64(1020); let __v_59: G = __v_57 - __v_58; let __v_60: G = G::from_bool(__v_59 == G::ZERO); let __v_61: G = __v_33 + __v_34; let __v_62: G = __v_61 + __v_35; let __v_63: G = __v_62 + __v_36; 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_116] = [__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[116].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_116] = [__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[116].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_13, __v_14]; 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_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_116] = [__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[116].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_117: usize = 6; -const IN_117: usize = 6; -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 __v_4: G = inp[4]; let __v_5: G = inp[5]; let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0, __v_1]; 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_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_86] = { let __args: [G; IN_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]; 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_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_117] = [__v_114]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; record.function_queries[117].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_117] = [__v_5]; 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_14, __v_15]; 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_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_116] = { let __args: [G; IN_116] = [__v_25, __v_26]; 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_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_116] = { let __args: [G; IN_116] = [__v_36, __v_37]; 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_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_116] = { let __args: [G; IN_116] = [__v_47, __v_48]; 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_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_116] = { let __args: [G; IN_116] = [__v_58, __v_59]; 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_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_116] = { let __args: [G; IN_116] = [__v_69, __v_70]; 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_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_116] = { let __args: [G; IN_116] = [__v_80, __v_81]; 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_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_16 + __v_27; let __v_96: G = __v_95 + __v_38; let __v_97: G = __v_96 + __v_49; let __v_98: G = __v_97 + __v_60; let __v_99: G = __v_98 + __v_71; let __v_100: G = __v_99 + __v_82; let __v_101: G = __v_100 + __v_93; 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_113 * __v_116; let __v_120: G = __v_118 - __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 = __v_117 + __v_132; let __v_134: G = G::from_u64(8); let __v_135: G = __v_134 * __v_130; let __v_136: G = __v_133 + __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_86] = { let __args: [G; IN_86] = [__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(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_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_117] = [__v_218]; record.function_queries[117].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_117] = { let __args: [G; IN_117] = [__v_91, __v_92, __v_248, __v_265, __v_266, __v_267]; 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_268: G = __r_arr[0]; let __ret: [G; OUT_117] = [__v_268]; record.function_queries[117].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_117] = { let __args: [G; IN_117] = [__v_91, __v_92, __v_218, __v_3, __v_219, __v_5]; 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_220: G = __r_arr[0]; let __ret: [G; OUT_117] = [__v_220]; 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 = 32; -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 __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_117] = { let __args: [G; IN_117] = [__v_33, __v_0, __v_34, __v_35, __v_36, __v_37]; 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_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_118] = [__v_39, __v_40, __v_41, __v_42, __v_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[118].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_119: usize = 3; -const IN_119: usize = 3; -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 __v_2: G = inp[2]; let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0, __v_1, __v_2]; 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_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_117] = { let __args: [G; IN_117] = [__v_36, __v_3, __v_37, __v_38, __v_39, __v_40]; 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_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_119] = [__v_74]; record.function_queries[119].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_120: usize = 4; -const IN_120: usize = 4; -const OUT_120: usize = 1; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_1, __v_2]; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_120] = [__v_3]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_1, __v_2]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_3, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_120] = [__v_6]; record.function_queries[120].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -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; 3] = { let __base = 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_121] = [__v_4]; record.function_queries[121].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3]; 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_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_121] = [__v_7]; record.function_queries[121].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_122: usize = 2; -const IN_122: usize = 2; -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 __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_122] = [__v_1]; record.function_queries[122].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_122] = [__v_0]; record.function_queries[122].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_122] = { let __args: [G; IN_122] = [__v_7, __v_1]; 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_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_122] = [__v_17]; record.function_queries[122].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_122] = { let __args: [G; IN_122] = [__v_7, __v_13]; 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_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_122] = [__v_19]; record.function_queries[122].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_13]; 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_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_122] = [__v_19]; record.function_queries[122].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_123: usize = 1; -const IN_123: usize = 1; -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 __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_123] = [__v_8, __v_8]; record.function_queries[123].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_123] = [__v_16, __v_15]; record.function_queries[123].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_12]; 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_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_123] = [__v_16, __v_17]; record.function_queries[123].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_124: usize = 1; -const IN_124: usize = 1; -const OUT_124: usize = 1; -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 __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_124] = [__v_0]; record.function_queries[124].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_124] = [__v_0]; record.function_queries[124].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_14]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_15, __v_16]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_124] = [__v_17]; record.function_queries[124].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_125: usize = 4; -const IN_125: usize = 4; -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 __loaded: [G; 3] = { let __base = 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_244] = { let __args: [G; IN_244] = [__v_1]; 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(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_125] = [__v_10]; record.function_queries[125].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_119] = { let __args: [G; IN_119] = [__v_8, __v_2, __v_3]; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_5]; 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_125] = { let __args: [G; IN_125] = [__v_6, __v_9, __v_2, __v_3]; 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_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_125] = [__v_14]; record.function_queries[125].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_126: usize = 4; -const IN_126: usize = 4; -const OUT_126: usize = 2; -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 __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_126] = [__v_11, __v_1]; record.function_queries[126].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_121] = { let __args: [G; IN_121] = [__v_12]; 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_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_121] = { let __args: [G; IN_121] = [__v_22]; 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_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_115] = { let __args: [G; IN_115] = [__v_7, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(115, &__args[..])?) { [G::ZERO; OUT_115] } else { let (__hash, __hit) = record.function_queries[115].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[115].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => { aiur_fn_115::(__args, __hash, record, io_buffer)? }, } } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_17, __v_2, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(115, &__args[..])?) { [G::ZERO; OUT_115] } else { let (__hash, __hit) = record.function_queries[115].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[115].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => { aiur_fn_115::(__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_111] = { let __args: [G; IN_111] = [__v_8, __v_18]; 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_28: G = __r_arr[0]; let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_7, __v_2, __v_3, __v_28]; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_19, __v_1, __v_2, __v_3]; 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_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_126] = [__v_33, __v_31]; record.function_queries[126].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_112] = { let __args: [G; IN_112] = [__v_11, __v_8, __v_27]; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_7, __v_2, __v_3, __v_29]; 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_30: G = __r_arr[0]; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_9, __v_28, __v_2, __v_3]; 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_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_126] = [__v_34, __v_32]; record.function_queries[126].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_112] = { let __args: [G; IN_112] = [__v_11, __v_8, __v_21]; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_7, __v_2, __v_3, __v_23]; 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_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_126] = [__v_28, __v_22]; record.function_queries[126].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_127: usize = 4; -const IN_127: usize = 4; -const OUT_127: usize = 2; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_127] = [__v_0, __v_1]; record.function_queries[127].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_126] = { let __args: [G; IN_126] = [__v_0, __v_1, __v_2, __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 __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6, __v_7, __v_2, __v_5]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_127] = [__v_8, __v_9]; record.function_queries[127].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_128: usize = 6; -const IN_128: usize = 6; -const OUT_128: usize = 1; -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 __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_3]; 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 = __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_125] = { let __args: [G; IN_125] = [__v_3, __v_1, __v_2, __v_5]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_11]; 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_12: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_12, __v_4, __v_2, __v_5]; 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 = __r_arr[1]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_14]; 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 __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_247] = { let __args: [G; IN_247] = [__v_22]; 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_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_242] = { let __args: [G; IN_242] = [__v_0, __v_18]; 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_21; let __v_27: G = G::from_bool(__v_26 == G::ZERO); let __ret: [G; OUT_128] = [__v_27]; record.function_queries[128].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }) } -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 __loaded: [G; 3] = { let __base = 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_129] = [__v_1]; record.function_queries[129].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_129] = { let __args: [G; IN_129] = [__v_4, __v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_129] = [__v_7]; record.function_queries[129].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_130: usize = 2; -const IN_130: usize = 2; -const OUT_130: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_130] = [__v_5]; record.function_queries[130].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = __v_0 * __v_0; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_5, __v_4]; 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_6: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_130] = [__v_6]; record.function_queries[130].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_7: G = __v_0 * __v_6; let __ret: [G; OUT_130] = [__v_7]; record.function_queries[130].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_131: usize = 8; -const IN_131: usize = 8; -const OUT_131: usize = 2; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_186] = { let __args: [G; IN_186] = [__v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__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_129] = { let __args: [G; IN_129] = [__v_0, __v_11]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_10, __v_12]; 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_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_131] = [__v_64, __v_65]; record.function_queries[131].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -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 __v_2: G = G::from_u64(7); let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__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_129] = { let __args: [G; IN_129] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3, __v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __v_2 * __v_7; let __ret: [G; OUT_132] = [__v_8]; record.function_queries[132].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_133: usize = 8; -const IN_133: usize = 8; -const OUT_133: usize = 4; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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 __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() { 1u64 => { let __ret: [G; OUT_133] = [__v_4, __v_5, __v_6, __v_7]; record.function_queries[133].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_18.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_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 = __v_9 + __v_23; let __v_25: G = G::from_u64(65536); let __v_26: G = __v_25 * __v_11; let __v_27: G = __v_24 + __v_26; let __v_28: G = G::from_u64(16777216); let __v_29: G = __v_28 * __v_12; let __v_30: G = __v_27 + __v_29; let __v_31: G = G::from_u64(4294967296); let __v_32: G = __v_31 * __v_13; let __v_33: G = __v_30 + __v_32; let __v_34: G = G::from_u64(1099511627776); let __v_35: G = __v_34 * __v_14; let __v_36: G = __v_33 + __v_35; let __v_37: G = G::from_u64(281474976710656); let __v_38: G = __v_37 * __v_15; let __v_39: G = __v_36 + __v_38; let __v_40: G = G::from_u64(72057594037927936); let __v_41: G = __v_40 * __v_16; let __v_42: G = __v_39 + __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_133] = { let __args: [G; IN_133] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_59, __v_62]; 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_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_133] = [__v_63, __v_64, __v_65, __v_66]; record.function_queries[133].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_134: usize = 2; -const IN_134: usize = 2; -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 __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_134] = [__v_1]; record.function_queries[134].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 = __v_6 + __v_15; let __v_17: G = G::from_u64(65536); let __v_18: G = __v_17 * __v_8; let __v_19: G = __v_16 + __v_18; let __v_20: G = G::from_u64(16777216); let __v_21: G = __v_20 * __v_9; let __v_22: G = __v_19 + __v_21; let __v_23: G = G::from_u64(4294967296); let __v_24: G = __v_23 * __v_10; let __v_25: G = __v_22 + __v_24; let __v_26: G = G::from_u64(1099511627776); let __v_27: G = __v_26 * __v_11; let __v_28: G = __v_25 + __v_27; let __v_29: G = G::from_u64(281474976710656); let __v_30: G = __v_29 * __v_12; let __v_31: G = __v_28 + __v_30; let __v_32: G = G::from_u64(72057594037927936); let __v_33: G = __v_32 * __v_13; let __v_34: G = __v_31 + __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 = __v_10 + __v_11; let __v_36: G = __v_35 + __v_12; let __v_37: G = __v_36 + __v_13; let __v_38: G = G::from_u64(1020); let __v_39: G = __v_37 - __v_38; let __v_40: G = G::from_bool(__v_39 == G::ZERO); let __v_41: G = __v_6 + __v_7; let __v_42: G = __v_41 + __v_8; let __v_43: G = __v_42 + __v_9; 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_49 + __v_57; let __v_59: G = __v_17 * __v_51; let __v_60: G = __v_58 + __v_59; let __v_61: G = __v_20 * __v_52; let __v_62: G = __v_60 + __v_61; let __v_63: G = __v_23 * __v_53; let __v_64: G = __v_62 + __v_63; let __v_65: G = __v_26 * __v_54; let __v_66: G = __v_64 + __v_65; let __v_67: G = __v_29 * __v_55; let __v_68: G = __v_66 + __v_67; let __v_69: G = __v_32 * __v_56; let __v_70: G = __v_68 + __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_53 + __v_54; let __v_72: G = __v_71 + __v_55; let __v_73: G = __v_72 + __v_56; let __v_74: G = __v_73 - __v_38; let __v_75: G = G::from_bool(__v_74 == G::ZERO); let __v_76: G = __v_49 + __v_50; let __v_77: G = __v_76 + __v_51; let __v_78: G = __v_77 + __v_52; 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_134] = { let __args: [G; IN_134] = [__v_5, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(134, &__args[..])?) { [G::ZERO; OUT_134] } else { let (__hash, __hit) = record.function_queries[134].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[134].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => { aiur_fn_134::(__args, __hash, record, io_buffer)? }, } } }; let __v_83: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__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(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_84: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__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(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_85: G = __r_arr[0]; let __ret: [G; OUT_134] = [__v_85]; record.function_queries[134].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.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_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_135] = [__v_1]; record.function_queries[135].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_4, __v_1]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_3, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(134, &__args[..])?) { [G::ZERO; OUT_134] } else { let (__hash, __hit) = record.function_queries[134].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[134].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => { aiur_fn_134::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_135] = [__v_6]; 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 = 2; -const IN_136: usize = 2; -const OUT_136: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_136] = [__v_1]; record.function_queries[136].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_4, __v_1]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_3, __v_5]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_136] = [__v_6]; record.function_queries[136].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_137: usize = 3; -const IN_137: usize = 3; -const OUT_137: usize = 1; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_137] = [__v_2]; record.function_queries[137].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; 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_3: G = __r_arr[0]; let __ret: [G; OUT_137] = [__v_3]; record.function_queries[137].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_138: usize = 2; -const IN_138: usize = 2; -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 __loaded: [G; 3] = { let __base = 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_138] = [__v_0]; record.function_queries[138].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_180] = { let __args: [G; IN_180] = [__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(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_138] = { let __args: [G; IN_138] = [__v_7, __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_8: G = __r_arr[0]; let __ret: [G; OUT_138] = [__v_8]; record.function_queries[138].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_139: usize = 10; -const IN_139: usize = 10; -const OUT_139: usize = 2; -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]; let __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_139] = [__v_0, __v_11]; record.function_queries[139].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__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(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_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_179] = { let __args: [G; IN_179] = [__v_10, __v_12, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(179, &__args[..])?) { [G::ZERO; OUT_179] } else { let (__hash, __hit) = record.function_queries[179].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[179].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { *(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179]) }; __ret }, _ => { aiur_fn_179::(__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_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_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_139] = [__v_14, __v_15]; record.function_queries[139].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_140: usize = 4; -const IN_140: usize = 4; -const OUT_140: usize = 2; -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 __loaded: [G; 3] = { let __base = 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_140] = [__v_8, __v_0]; record.function_queries[140].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_181] = { let __args: [G; IN_181] = [__v_0, __v_5]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(181, &__args[..])?) { [G::ZERO; OUT_181] } else { let (__hash, __hit) = record.function_queries[181].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[181].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => { aiur_fn_181::(__args, __hash, record, io_buffer)? }, } } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__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(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_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_18, __v_19]; 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_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_140] = { let __args: [G; IN_140] = [__v_36, __v_6, __v_16, __v_3]; 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 __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 = __v_20 + __v_41; let __v_43: G = G::from_u64(65536); let __v_44: G = __v_43 * __v_22; let __v_45: G = __v_42 + __v_44; let __v_46: G = G::from_u64(16777216); let __v_47: G = __v_46 * __v_23; let __v_48: G = __v_45 + __v_47; let __v_49: G = G::from_u64(4294967296); let __v_50: G = __v_49 * __v_24; let __v_51: G = __v_48 + __v_50; let __v_52: G = G::from_u64(1099511627776); let __v_53: G = __v_52 * __v_25; let __v_54: G = __v_51 + __v_53; let __v_55: G = G::from_u64(281474976710656); let __v_56: G = __v_55 * __v_26; let __v_57: G = __v_54 + __v_56; let __v_58: G = G::from_u64(72057594037927936); let __v_59: G = __v_58 * __v_27; let __v_60: G = __v_57 + __v_59; let __v_61: G = G::from_u64(0); let __v_62: G = __v_40 * __v_29; let __v_63: G = __v_28 + __v_62; let __v_64: G = __v_43 * __v_30; let __v_65: G = __v_63 + __v_64; let __v_66: G = __v_46 * __v_31; let __v_67: G = __v_65 + __v_66; let __v_68: G = __v_49 * __v_32; let __v_69: G = __v_67 + __v_68; let __v_70: G = __v_52 * __v_33; let __v_71: G = __v_69 + __v_70; let __v_72: G = __v_55 * __v_34; let __v_73: G = __v_71 + __v_72; let __v_74: G = __v_58 * __v_35; let __v_75: G = __v_73 + __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_140] = [__v_76, __v_39]; record.function_queries[140].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_141: usize = 5; -const IN_141: usize = 5; -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 __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_141] = [__v_5]; record.function_queries[141].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0, __v_3]; 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 = __v_5 + __v_1; let __v_7: G = __v_6 - __v_4; 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_141] = [__v_9]; record.function_queries[141].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_141] = { let __args: [G; IN_141] = [__v_0, __v_1, __v_10, __v_11, __v_4]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_141] = [__v_12]; record.function_queries[141].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_142: usize = 4; -const IN_142: usize = 4; -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]; 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_142] = [__v_5]; record.function_queries[142].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_0, __v_1, __v_2, __v_4, __v_3]; 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_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_142] = { let __args: [G; IN_142] = [__v_0, __v_1, __v_2, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_142] = [__v_8]; record.function_queries[142].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_142] = { let __args: [G; IN_142] = [__v_0, __v_1, __v_2, __v_8]; 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_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_142] = [__v_10]; record.function_queries[142].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_143: usize = 8; -const IN_143: usize = 8; -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 __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 __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_3]; 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 = __v_15 - __v_16; let __v_18: G = G::from_bool(__v_17 == G::ZERO); let __v_19: G = G::from_u64(1); 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 = { let __values: [G; 7] = [__v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; 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_143] = [__v_20]; record.function_queries[143].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_133] = { let __args: [G; IN_133] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_17, __v_10, __v_11]; 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_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_143] = [__v_32]; record.function_queries[143].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_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_143] = [__v_19]; record.function_queries[143].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }) } -const INPUT_SIZE_144: usize = 2; -const IN_144: usize = 2; -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 __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_144] = [__v_9]; record.function_queries[144].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_144] = [__v_17]; record.function_queries[144].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_8, __v_1]; 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_11: G = __r_arr[0]; let __ret: [G; OUT_144] = [__v_11]; record.function_queries[144].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_145: usize = 2; -const IN_145: usize = 2; -const OUT_145: usize = 1; -fn aiur_fn_145(inp: [G; IN_145], 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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_145] = [__v_2]; record.function_queries[145].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_145] = [__v_2]; record.function_queries[145].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_146: usize = 10; -const IN_146: usize = 10; -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 = __v_3 - __v_1; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_2, __v_10]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(256, &__args[..])?) { [G::ZERO; OUT_256] } else { let (__hash, __hit) = record.function_queries[256].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[256].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => { aiur_fn_256::(__args, __hash, record, io_buffer)? }, } } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(7); let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: 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_129] = { let __args: [G; IN_129] = [__v_11, __v_15]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__args, __hash, record, io_buffer)? }, } } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_13, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = __v_12 * __v_17; let __v_19: G = G::from_u64(0); let __v_20: G = __v_4 - __v_18; let __v_21: G = __v_5 - __v_19; let __v_22: G = __v_20 * __v_20; let __v_23: G = __v_21 * __v_21; let __v_24: G = __v_12 * __v_23; let __v_25: G = __v_22 - __v_24; let __v_26: G = aiur::execute::g_inverse_value(__v_25); let __v_27: G = __v_25 * __v_26; let __v_28: G = __v_27 - __v_14; let __v_29: G = __v_25 * __v_28; if (__v_29 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __v_30: G = __v_26 * __v_28; if (__v_30 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None }); } let __v_31: G = __v_20 * __v_26; let __v_32: G = __v_19 - __v_21; let __v_33: G = __v_32 * __v_26; let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_1, __v_6, __v_7, __v_31, __v_33, __v_8, __v_9]; 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_34: G = __r_arr[0]; let __ret: [G; OUT_146] = [__v_34]; record.function_queries[146].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_147: usize = 11; -const IN_147: usize = 11; -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 = G::from_u64(0); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8, __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_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8, __v_13]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__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_146] = { let __args: [G; IN_146] = [__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(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_24: G = __r_arr[0]; let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__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(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_25: G = __r_arr[0]; let __ret: [G; OUT_147] = [__v_25]; record.function_queries[147].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_148: usize = 13; -const IN_148: usize = 13; -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]; match __v_5.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); }, _ => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_6, __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_13: G = __r_arr[0]; let __v_14: G = __v_13 + __v_3; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_9, __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_15: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_10, __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_16: G = __r_arr[0]; let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__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(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_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_148] = { let __args: [G; IN_148] = [__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(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_21: G = __r_arr[0]; let __ret: [G; OUT_148] = [__v_21]; record.function_queries[148].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_149: usize = 13; -const IN_149: usize = 13; -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]; let __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_149] = [__v_0]; record.function_queries[149].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_6, __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_13: G = __r_arr[0]; let __v_14: G = __v_13 + __v_3; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_9, __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_15: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_10, __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_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_16, __v_17]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__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(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_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_149] = { let __args: [G; IN_149] = [__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(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_23: G = __r_arr[0]; let __ret: [G; OUT_149] = [__v_23]; record.function_queries[149].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_150: usize = 15; -const IN_150: usize = 15; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_150] = [__v_0]; record.function_queries[150].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_8, __v_4]; 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_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_150] = { let __args: [G; IN_150] = [__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(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_20: G = __r_arr[0]; let __ret: [G; OUT_150] = [__v_20]; record.function_queries[150].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_7, __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_17: G = __r_arr[0]; let __v_18: G = __v_17 + __v_3; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_11, __v_6]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_12, __v_6]; 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 __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__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(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_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_150] = { let __args: [G; IN_150] = [__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(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_26: G = __r_arr[0]; let __ret: [G; OUT_150] = [__v_26]; record.function_queries[150].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_151: usize = 15; -const IN_151: usize = 15; -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]; 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_151] = [__v_0]; record.function_queries[151].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(3); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_1, __v_15]; 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_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { _ => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_16]; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_4]; 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_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_154] = { let __args: [G; IN_154] = [__v_6, __v_10, __v_5, __v_7, __v_22]; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_23]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(153, &__args[..])?) { [G::ZERO; OUT_153] } else { let (__hash, __hit) = record.function_queries[153].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[153].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => { aiur_fn_153::(__args, __hash, record, io_buffer)? }, } } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__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(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_25: G = __r_arr[0]; let __ret: [G; OUT_151] = [__v_25]; record.function_queries[151].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_152: usize = 4; -const IN_152: usize = 4; -const OUT_152: usize = 1; -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]; 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_152] = [__v_5]; record.function_queries[152].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0, __v_3]; 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 = __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_152] = { let __args: [G; IN_152] = [__v_0, __v_1, __v_8, __v_9]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(152, &__args[..])?) { [G::ZERO; OUT_152] } else { let (__hash, __hit) = record.function_queries[152].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[152].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => { aiur_fn_152::(__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_152] = [__v_11]; record.function_queries[152].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_153: usize = 1; -const IN_153: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_153] = [__v_4]; record.function_queries[153].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(153, &__args[..])?) { [G::ZERO; OUT_153] } else { let (__hash, __hit) = record.function_queries[153].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[153].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => { aiur_fn_153::(__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_153] = [__v_4]; record.function_queries[153].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_153] = [__v_2]; record.function_queries[153].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_154: usize = 5; -const IN_154: usize = 5; -const OUT_154: usize = 1; -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]; 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_154] = [__v_6]; record.function_queries[154].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_2, __v_4]; 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_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_154] = { let __args: [G; IN_154] = [__v_0, __v_1, __v_2, __v_8, __v_9]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_154] = [__v_10]; record.function_queries[154].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0, __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_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_154] = { let __args: [G; IN_154] = [__v_0, __v_1, __v_2, __v_11, __v_12]; 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_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_154] = [__v_14]; record.function_queries[154].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_155: usize = 5; -const IN_155: usize = 5; -const OUT_155: usize = 4; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_155] = [__v_1, __v_2, __v_3, __v_4]; record.function_queries[155].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_155] = [__v_3, __v_4, __v_1, __v_2]; record.function_queries[155].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_156: usize = 4; -const IN_156: usize = 4; -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 __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 = __v_4 + __v_13; let __v_15: G = G::from_u64(65536); let __v_16: G = __v_15 * __v_6; let __v_17: G = __v_14 + __v_16; let __v_18: G = G::from_u64(16777216); let __v_19: G = __v_18 * __v_7; let __v_20: G = __v_17 + __v_19; let __v_21: G = G::from_u64(4294967296); let __v_22: G = __v_21 * __v_8; let __v_23: G = __v_20 + __v_22; let __v_24: G = G::from_u64(1099511627776); let __v_25: G = __v_24 * __v_9; let __v_26: G = __v_23 + __v_25; let __v_27: G = G::from_u64(281474976710656); let __v_28: G = __v_27 * __v_10; let __v_29: G = __v_26 + __v_28; let __v_30: G = G::from_u64(72057594037927936); let __v_31: G = __v_30 * __v_11; let __v_32: G = __v_29 + __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 = __v_8 + __v_9; let __v_34: G = __v_33 + __v_10; let __v_35: G = __v_34 + __v_11; let __v_36: G = G::from_u64(1020); let __v_37: G = __v_35 - __v_36; let __v_38: G = G::from_bool(__v_37 == G::ZERO); let __v_39: G = __v_4 + __v_5; let __v_40: G = __v_39 + __v_6; let __v_41: G = __v_40 + __v_7; 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_47 + __v_55; let __v_57: G = __v_15 * __v_49; let __v_58: G = __v_56 + __v_57; let __v_59: G = __v_18 * __v_50; let __v_60: G = __v_58 + __v_59; let __v_61: G = __v_21 * __v_51; let __v_62: G = __v_60 + __v_61; let __v_63: G = __v_24 * __v_52; let __v_64: G = __v_62 + __v_63; let __v_65: G = __v_27 * __v_53; let __v_66: G = __v_64 + __v_65; let __v_67: G = __v_30 * __v_54; let __v_68: G = __v_66 + __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_51 + __v_52; let __v_70: G = __v_69 + __v_53; let __v_71: G = __v_70 + __v_54; let __v_72: G = __v_71 - __v_36; let __v_73: G = G::from_bool(__v_72 == G::ZERO); let __v_74: G = __v_47 + __v_48; let __v_75: G = __v_74 + __v_49; let __v_76: G = __v_75 + __v_50; 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_81 + __v_89; let __v_91: G = __v_15 * __v_83; let __v_92: G = __v_90 + __v_91; let __v_93: G = __v_18 * __v_84; let __v_94: G = __v_92 + __v_93; let __v_95: G = __v_21 * __v_85; let __v_96: G = __v_94 + __v_95; let __v_97: G = __v_24 * __v_86; let __v_98: G = __v_96 + __v_97; let __v_99: G = __v_27 * __v_87; let __v_100: G = __v_98 + __v_99; let __v_101: G = __v_30 * __v_88; let __v_102: G = __v_100 + __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_85 + __v_86; let __v_104: G = __v_103 + __v_87; let __v_105: G = __v_104 + __v_88; let __v_106: G = __v_105 - __v_36; let __v_107: G = G::from_bool(__v_106 == G::ZERO); let __v_108: G = __v_81 + __v_82; let __v_109: G = __v_108 + __v_83; let __v_110: G = __v_109 + __v_84; 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_115 + __v_123; let __v_125: G = __v_15 * __v_117; let __v_126: G = __v_124 + __v_125; let __v_127: G = __v_18 * __v_118; let __v_128: G = __v_126 + __v_127; let __v_129: G = __v_21 * __v_119; let __v_130: G = __v_128 + __v_129; let __v_131: G = __v_24 * __v_120; let __v_132: G = __v_130 + __v_131; let __v_133: G = __v_27 * __v_121; let __v_134: G = __v_132 + __v_133; let __v_135: G = __v_30 * __v_122; let __v_136: G = __v_134 + __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_119 + __v_120; let __v_138: G = __v_137 + __v_121; let __v_139: G = __v_138 + __v_122; let __v_140: G = __v_139 - __v_36; let __v_141: G = G::from_bool(__v_140 == G::ZERO); let __v_142: G = __v_115 + __v_116; let __v_143: G = __v_142 + __v_117; let __v_144: G = __v_143 + __v_118; 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_156] = [__v_154]; record.function_queries[156].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_157: usize = 6; -const IN_157: usize = 6; -const OUT_157: usize = 3; -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 __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_157] = [__v_0, __v_1, __v_5]; record.function_queries[157].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_185] = { let __args: [G; IN_185] = [__v_3, __v_4, __v_15]; 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_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_157] = [__v_26, __v_27, __v_12]; record.function_queries[157].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_157] = [__v_0, __v_1, __v_5]; record.function_queries[157].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } -const INPUT_SIZE_158: usize = 9; -const IN_158: usize = 9; -const OUT_158: usize = 3; -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]; let __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_248] = { let __args: [G; IN_248] = [__v_7]; 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_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_158] = [__v_0, __v_1, __v_18]; record.function_queries[158].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_245] = { let __args: [G; IN_245] = [__v_11]; 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_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_253] = { let __args: [G; IN_253] = [__v_11, __v_27]; 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_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_131] = { let __args: [G; IN_131] = [__v_24, __v_26, __v_14, __v_15, __v_30, __v_31, __v_32, __v_33]; 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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_34, __v_35, __v_26, __v_14, __v_15, __v_7]; 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_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__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(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_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 = __v_42 + __v_51; let __v_53: G = G::from_u64(65536); let __v_54: G = __v_53 * __v_44; let __v_55: G = __v_52 + __v_54; let __v_56: G = G::from_u64(16777216); let __v_57: G = __v_56 * __v_45; let __v_58: G = __v_55 + __v_57; let __v_59: G = G::from_u64(4294967296); let __v_60: G = __v_59 * __v_46; let __v_61: G = __v_58 + __v_60; let __v_62: G = G::from_u64(1099511627776); let __v_63: G = __v_62 * __v_47; let __v_64: G = __v_61 + __v_63; let __v_65: G = G::from_u64(281474976710656); let __v_66: G = __v_65 * __v_48; let __v_67: G = __v_64 + __v_66; let __v_68: G = G::from_u64(72057594037927936); let __v_69: G = __v_68 * __v_49; let __v_70: G = __v_67 + __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 = __v_46 + __v_47; let __v_72: G = __v_71 + __v_48; let __v_73: G = __v_72 + __v_49; let __v_74: G = G::from_u64(1020); let __v_75: G = __v_73 - __v_74; let __v_76: G = G::from_bool(__v_75 == G::ZERO); let __v_77: G = __v_42 + __v_43; let __v_78: G = __v_77 + __v_44; let __v_79: G = __v_78 + __v_45; 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_85 + __v_93; let __v_95: G = __v_53 * __v_87; let __v_96: G = __v_94 + __v_95; let __v_97: G = __v_56 * __v_88; let __v_98: G = __v_96 + __v_97; let __v_99: G = __v_59 * __v_89; let __v_100: G = __v_98 + __v_99; let __v_101: G = __v_62 * __v_90; let __v_102: G = __v_100 + __v_101; let __v_103: G = __v_65 * __v_91; let __v_104: G = __v_102 + __v_103; let __v_105: G = __v_68 * __v_92; let __v_106: G = __v_104 + __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_89 + __v_90; let __v_108: G = __v_107 + __v_91; let __v_109: G = __v_108 + __v_92; let __v_110: G = __v_109 - __v_74; let __v_111: G = G::from_bool(__v_110 == G::ZERO); let __v_112: G = __v_85 + __v_86; let __v_113: G = __v_112 + __v_87; let __v_114: G = __v_113 + __v_88; 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_119 + __v_127; let __v_129: G = __v_53 * __v_121; let __v_130: G = __v_128 + __v_129; let __v_131: G = __v_56 * __v_122; let __v_132: G = __v_130 + __v_131; let __v_133: G = __v_59 * __v_123; let __v_134: G = __v_132 + __v_133; let __v_135: G = __v_62 * __v_124; let __v_136: G = __v_134 + __v_135; let __v_137: G = __v_65 * __v_125; let __v_138: G = __v_136 + __v_137; let __v_139: G = __v_68 * __v_126; let __v_140: G = __v_138 + __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_123 + __v_124; let __v_142: G = __v_141 + __v_125; let __v_143: G = __v_142 + __v_126; let __v_144: G = __v_143 - __v_74; let __v_145: G = G::from_bool(__v_144 == G::ZERO); let __v_146: G = __v_119 + __v_120; let __v_147: G = __v_146 + __v_121; let __v_148: G = __v_147 + __v_122; 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_153 + __v_161; let __v_163: G = __v_53 * __v_155; let __v_164: G = __v_162 + __v_163; let __v_165: G = __v_56 * __v_156; let __v_166: G = __v_164 + __v_165; let __v_167: G = __v_59 * __v_157; let __v_168: G = __v_166 + __v_167; let __v_169: G = __v_62 * __v_158; let __v_170: G = __v_168 + __v_169; let __v_171: G = __v_65 * __v_159; let __v_172: G = __v_170 + __v_171; let __v_173: G = __v_68 * __v_160; let __v_174: G = __v_172 + __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_157 + __v_158; let __v_176: G = __v_175 + __v_159; let __v_177: G = __v_176 + __v_160; let __v_178: G = __v_177 - __v_74; let __v_179: G = G::from_bool(__v_178 == G::ZERO); let __v_180: G = __v_153 + __v_154; let __v_181: G = __v_180 + __v_155; let __v_182: G = __v_181 + __v_156; 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_158] = [__v_39, __v_40, __v_193]; record.function_queries[158].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_159: usize = 25; -const IN_159: usize = 25; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_245] = { let __args: [G; IN_245] = [__v_2]; 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_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_244] = { let __args: [G; IN_244] = [__v_1]; 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_29: G = __r_arr[0]; let __v_30: G = G::from_u64(3); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_8, __v_9]; 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_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_142] = { let __args: [G; IN_142] = [__v_15, __v_19, __v_18, __v_20]; 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_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_15, __v_19, __v_18, __v_36]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(152, &__args[..])?) { [G::ZERO; OUT_152] } else { let (__hash, __hit) = record.function_queries[152].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[152].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => { aiur_fn_152::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_1, __v_36]; 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_38: G = __r_arr[0]; match __v_38.as_canonical_u64() { _ => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_38]; 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_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_148] = { let __args: [G; IN_148] = [__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(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_44: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_1, __v_42]; 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_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { _ => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_45]; 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_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_148] = { let __args: [G; IN_148] = [__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(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_51: G = __r_arr[0]; let __v_52: G = G::from_u64(2); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_1, __v_52]; 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]; match __v_53.as_canonical_u64() { _ => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_53]; 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_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_149] = { let __args: [G; IN_149] = [__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(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_59: G = __r_arr[0]; let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__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(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_60: G = __r_arr[0]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_60, __v_19]; 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_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_158] = { let __args: [G; IN_158] = [__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(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_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_253] = { let __args: [G; IN_253] = [__v_23, __v_75]; 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_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_159] = [__v_74]; record.function_queries[159].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_62.as_canonical_u64())); }, } }, } }, } }, } }, } }) } -const INPUT_SIZE_160: usize = 25; -const IN_160: usize = 25; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_160] = [__v_30]; record.function_queries[160].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(179, &__args[..])?) { [G::ZERO; OUT_179] } else { let (__hash, __hit) = record.function_queries[179].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[179].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { *(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179]) }; __ret }, _ => { aiur_fn_179::(__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_159] = { let __args: [G; IN_159] = [__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(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_32: G = __r_arr[0]; let __v_33: G = G::from_u64(0); let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__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(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_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_160] = [__v_35]; record.function_queries[160].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_25.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_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_161] = [__v_5]; record.function_queries[161].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(179, &__args[..])?) { [G::ZERO; OUT_179] } else { let (__hash, __hit) = record.function_queries[179].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[179].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { *(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179]) }; __ret }, _ => { aiur_fn_179::(__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_161] = { let __args: [G; IN_161] = [__v_5, __v_6, __v_9, __v_3]; 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; 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_161] = [__v_11]; record.function_queries[161].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_162: usize = 2; -const IN_162: usize = 2; -const OUT_162: usize = 1; -fn aiur_fn_162(inp: [G; IN_162], 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 __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_162] = [__v_7]; record.function_queries[162].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_242] = { let __args: [G; IN_242] = [__v_3, __v_1]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_5, __v_1]; 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_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_162] = [__v_9]; record.function_queries[162].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.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; 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_163] = [__v_8]; record.function_queries[163].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_242] = { let __args: [G; IN_242] = [__v_4, __v_1]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_6, __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_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_163] = [__v_10]; 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 = 4; -const IN_164: usize = 4; -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 __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_164] = [__v_5]; record.function_queries[164].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_2]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_1, __v_2]; 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_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_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_8, __v_9]; 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; 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_164] = [__v_11]; record.function_queries[164].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_165: usize = 13; -const IN_165: usize = 13; -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 __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_152] = { let __args: [G; IN_152] = [__v_9, __v_11, __v_10, __v_13]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(152, &__args[..])?) { [G::ZERO; OUT_152] } else { let (__hash, __hit) = record.function_queries[152].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[152].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => { aiur_fn_152::(__args, __hash, record, io_buffer)? }, } } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_13]; 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_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_253] = { let __args: [G; IN_253] = [__v_0, __v_17]; 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_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_253] = { let __args: [G; IN_253] = [__v_0, __v_20]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { _ => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_2, __v_15, __v_14, __v_1, __v_16, __v_12]; 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_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_128] = { let __args: [G; IN_128] = [__v_3, __v_18, __v_14, __v_1, __v_19, __v_12]; 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_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_128] = { let __args: [G; IN_128] = [__v_4, __v_21, __v_14, __v_1, __v_22, __v_12]; 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_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_165] = [__v_27]; record.function_queries[165].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_27: G = G::from_u64(3); let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_27]; 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_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_154] = { let __args: [G; IN_154] = [__v_9, __v_11, __v_8, __v_10, __v_30]; 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_31: G = __r_arr[0]; let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(153, &__args[..])?) { [G::ZERO; OUT_153] } else { let (__hash, __hit) = record.function_queries[153].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[153].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => { aiur_fn_153::(__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_166] = { let __args: [G; IN_166] = [__v_1, __v_33]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(166, &__args[..])?) { [G::ZERO; OUT_166] } else { let (__hash, __hit) = record.function_queries[166].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[166].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => { aiur_fn_166::(__args, __hash, record, io_buffer)? }, } } }; let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_5, __v_28, __v_31, __v_34, __v_29, __v_32]; 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_35: G = __r_arr[0]; let __ret: [G; OUT_165] = [__v_35]; record.function_queries[165].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }, } }, } }, } }) } -const INPUT_SIZE_166: usize = 2; -const IN_166: usize = 2; -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 __loaded: [G; 3] = { let __base = 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_166] = [__v_0]; record.function_queries[166].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_3, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(256, &__args[..])?) { [G::ZERO; OUT_256] } else { let (__hash, __hit) = record.function_queries[256].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[256].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => { aiur_fn_256::(__args, __hash, record, io_buffer)? }, } } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(166, &__args[..])?) { [G::ZERO; OUT_166] } else { let (__hash, __hit) = record.function_queries[166].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[166].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => { aiur_fn_166::(__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_166] = [__v_8]; record.function_queries[166].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -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 __loaded: [G; 3] = { let __base = 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_167] = [__v_6]; record.function_queries[167].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_3, __v_1]; 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_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_167] = { let __args: [G; IN_167] = [__v_4, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(167, &__args[..])?) { [G::ZERO; OUT_167] } else { let (__hash, __hit) = record.function_queries[167].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[167].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => { aiur_fn_167::(__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_167] = [__v_11]; record.function_queries[167].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_168: usize = 6; -const IN_168: usize = 6; -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 __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_244] = { let __args: [G; IN_244] = [__v_1]; 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_11: G = __r_arr[0]; let __v_12: G = G::from_bool(__v_11 == G::ZERO); let __ret: [G; OUT_168] = [__v_12]; record.function_queries[168].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_244] = { let __args: [G; IN_244] = [__v_8]; 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_244] = { let __args: [G; IN_244] = [__v_3]; 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_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_166] = { let __args: [G; IN_166] = [__v_3, __v_14]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(166, &__args[..])?) { [G::ZERO; OUT_166] } else { let (__hash, __hit) = record.function_queries[166].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[166].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => { aiur_fn_166::(__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_167] = { let __args: [G; IN_167] = [__v_2, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(167, &__args[..])?) { [G::ZERO; OUT_167] } else { let (__hash, __hit) = record.function_queries[167].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[167].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => { aiur_fn_167::(__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_128] = { let __args: [G; IN_128] = [__v_12, __v_19, __v_22, __v_17, __v_9, __v_18]; 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_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_168] = { let __args: [G; IN_168] = [__v_10, __v_13, __v_2, __v_17, __v_24, __v_18]; 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_25: G = __r_arr[0]; let __ret: [G; OUT_168] = [__v_25]; record.function_queries[168].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_169: usize = 32; -const IN_169: usize = 32; -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]; match __v_6.as_canonical_u64() { _ => { 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_32: G = __r_arr[0]; let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_7]; 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_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_245] = { let __args: [G; IN_245] = [__v_8]; 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_37: G = __r_arr[0]; let __v_38: G = G::from_u64(3); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_4, __v_5]; 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_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_255] = { let __args: [G; IN_255] = [__v_9]; 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_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_245] = { let __args: [G; IN_245] = [__v_10]; 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_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_136] = { let __args: [G; IN_136] = [__v_5, __v_45]; 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_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_136] = { let __args: [G; IN_136] = [__v_3, __v_46]; 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_47: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_2, __v_47]; 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_48: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_48]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_49]; 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_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_177] = { let __args: [G; IN_177] = [__v_50, __v_52]; 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_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 = __v_53 + __v_72; let __v_74: G = G::from_u64(65536); let __v_75: G = __v_74 * __v_55; let __v_76: G = __v_73 + __v_75; let __v_77: G = G::from_u64(16777216); let __v_78: G = __v_77 * __v_56; let __v_79: G = __v_76 + __v_78; let __v_80: G = G::from_u64(4294967296); let __v_81: G = __v_80 * __v_57; let __v_82: G = __v_79 + __v_81; let __v_83: G = G::from_u64(1099511627776); let __v_84: G = __v_83 * __v_58; let __v_85: G = __v_82 + __v_84; let __v_86: G = G::from_u64(281474976710656); let __v_87: G = __v_86 * __v_59; let __v_88: G = __v_85 + __v_87; let __v_89: G = G::from_u64(72057594037927936); let __v_90: G = __v_89 * __v_60; let __v_91: G = __v_88 + __v_90; let __v_92: G = __v_71 * __v_62; let __v_93: G = __v_61 + __v_92; let __v_94: G = __v_74 * __v_63; let __v_95: G = __v_93 + __v_94; let __v_96: G = __v_77 * __v_64; let __v_97: G = __v_95 + __v_96; let __v_98: G = __v_80 * __v_65; let __v_99: G = __v_97 + __v_98; let __v_100: G = __v_83 * __v_66; let __v_101: G = __v_99 + __v_100; let __v_102: G = __v_86 * __v_67; let __v_103: G = __v_101 + __v_102; let __v_104: G = __v_89 * __v_68; let __v_105: G = __v_103 + __v_104; let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_69, __v_6, __v_7, __v_30]; 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_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_10, __v_52]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(134, &__args[..])?) { [G::ZERO; OUT_134] } else { let (__hash, __hit) = record.function_queries[134].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[134].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => { aiur_fn_134::(__args, __hash, record, io_buffer)? }, } } }; let __v_108: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_107, __v_108]; 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_109: G = __r_arr[0]; let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_109, __v_6]; 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_110: G = __r_arr[0]; let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__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(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_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_161] = { let __args: [G; IN_161] = [__v_111, __v_112, __v_29, __v_113]; 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_116: G = __r_arr[0]; let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__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(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_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_164] = { let __args: [G; IN_164] = [__v_8, __v_9, __v_118, __v_29]; 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_119: G = __r_arr[0]; let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__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(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_120: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_9, __v_6, __v_120, __v_116, __v_118, __v_113]; 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_121: G = __r_arr[0]; let __ret: [G; OUT_169] = [__v_121]; 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 __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_170] = [__v_4]; record.function_queries[170].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_171: usize = 9; -const IN_171: usize = 9; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_171] = [__v_17]; record.function_queries[171].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_172: usize = 33; -const IN_172: usize = 33; -const OUT_172: usize = 1; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_171] = { let __args: [G; IN_171] = [__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(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_33: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__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(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_34: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__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(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_35: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__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(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_36: G = __r_arr[0]; let __ret: [G; OUT_172] = [__v_36]; record.function_queries[172].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_173: usize = 2; -const IN_173: usize = 2; -const OUT_173: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_173] = [__v_1]; record.function_queries[173].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_173] = { let __args: [G; IN_173] = [__v_4, __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_37: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__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(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_38: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__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(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_39: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__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(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_40: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__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(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_41: G = __r_arr[0]; let __ret: [G; OUT_173] = [__v_41]; record.function_queries[173].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_174: usize = 2; -const IN_174: usize = 2; -const OUT_174: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_174] = [__v_1]; record.function_queries[174].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_4, __v_1]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__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(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 __ret: [G; OUT_174] = [__v_7]; record.function_queries[174].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_175: usize = 2; -const IN_175: usize = 2; -const OUT_175: usize = 10; -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]; let __loaded: [G; 3] = { let __base = 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_108] = { let __args: [G; IN_108] = [__v_71, __v_72, __v_73, __v_74, __v_37]; 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_75: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_67, __v_68, __v_69, __v_70, __v_75]; 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_76: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_63, __v_64, __v_65, __v_66, __v_76]; 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_77: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_59, __v_60, __v_61, __v_62, __v_77]; 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_78: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_55, __v_56, __v_57, __v_58, __v_78]; 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_79: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_51, __v_52, __v_53, __v_54, __v_79]; 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_80: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_47, __v_48, __v_49, __v_50, __v_80]; 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_81: G = __r_arr[0]; let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_43, __v_44, __v_45, __v_46, __v_81]; 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_82: G = __r_arr[0]; let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_82, __v_37]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(129, &__args[..])?) { [G::ZERO; OUT_129] } else { let (__hash, __hit) = record.function_queries[129].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[129].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => { aiur_fn_129::(__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_175] = [__v_85, __v_88, __v_91, __v_94, __v_97, __v_100, __v_103, __v_106, __v_82, __v_107]; record.function_queries[175].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_175] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25]; record.function_queries[175].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_176: usize = 2; -const IN_176: usize = 2; -const OUT_176: usize = 10; -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 __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_0, __v_1]; 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_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 = __v_6 + __v_7; let __v_13: G = __v_12 + __v_8; let __v_14: G = __v_13 + __v_9; let __v_15: G = G::from_u64(1020); let __v_16: G = __v_14 - __v_15; let __v_17: G = G::from_bool(__v_16 == G::ZERO); let __v_18: G = __v_2 + __v_3; let __v_19: G = __v_18 + __v_4; let __v_20: G = __v_19 + __v_5; 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_176] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; record.function_queries[176].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_10, __v_11]; 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_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_176] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; record.function_queries[176].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_177: usize = 2; -const IN_177: usize = 2; -const OUT_177: usize = 18; -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 __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1]; 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_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_176] = { let __args: [G; IN_176] = [__v_10, __v_11]; 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_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_177] = [__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[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]; 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_178] = [__v_3]; record.function_queries[178].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_178] = { let __args: [G; IN_178] = [__v_4, __v_7]; 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_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_178] = [__v_9]; record.function_queries[178].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_179: usize = 3; -const IN_179: usize = 3; -const OUT_179: usize = 3; -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 = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_0, __v_1]; 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_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_171] = { let __args: [G; IN_171] = [__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(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_47: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__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(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_48: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__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(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_49: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__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(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_50: G = __r_arr[0]; let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_50, __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_51: G = __r_arr[0]; let __ret: [G; OUT_179] = [__v_51, __v_11, __v_12]; record.function_queries[179].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_180: usize = 9; -const IN_180: usize = 9; -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 __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_171] = { let __args: [G; IN_171] = [__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(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_11: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_11]; 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_12: G = __r_arr[0]; let __ret: [G; OUT_180] = [__v_12]; record.function_queries[180].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -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]; 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_173] = { let __args: [G; IN_173] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_4]; 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 __ret: [G; OUT_181] = [__v_5]; record.function_queries[181].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_182: usize = 1; -const IN_182: usize = 1; -const OUT_182: usize = 1; -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 = 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_182] = [__v_28]; record.function_queries[182].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_183: usize = 2; -const IN_183: usize = 2; -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]; 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_183] = [__v_1]; record.function_queries[183].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_11, __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_12: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__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(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_13: G = __r_arr[0]; let __ret: [G; OUT_183] = [__v_13]; record.function_queries[183].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_184: usize = 2; -const IN_184: usize = 2; -const OUT_184: usize = 1; -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]; 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_184] = [__v_3]; record.function_queries[184].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_184] = [__v_1]; record.function_queries[184].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); }, } }) } -const INPUT_SIZE_185: usize = 3; -const IN_185: usize = 3; -const OUT_185: usize = 2; -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]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_185] = [__v_0, __v_1]; record.function_queries[185].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_185] = { let __args: [G; IN_185] = [__v_7, __v_10, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_185] = [__v_13, __v_14]; record.function_queries[185].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_186: usize = 1; -const IN_186: usize = 1; -const OUT_186: usize = 1; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_186] = [__v_1]; record.function_queries[186].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1753635133440165772); let __ret: [G; OUT_186] = [__v_1]; record.function_queries[186].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_186] = { let __args: [G; IN_186] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __v_3 * __v_3; let __ret: [G; OUT_186] = [__v_4]; record.function_queries[186].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_187: usize = 3; -const IN_187: usize = 3; -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 __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_1, __v_2]; 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_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_187] = [__v_7, __v_8]; record.function_queries[187].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_188: usize = 1; -const IN_188: usize = 1; -const OUT_188: usize = 1; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_188] = [__v_1]; record.function_queries[188].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_188] = { let __args: [G; IN_188] = [__v_3]; 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_4: G = __r_arr[0]; let __v_5: G = __v_1 * __v_4; let __ret: [G; OUT_188] = [__v_5]; record.function_queries[188].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_189: usize = 3; -const IN_189: usize = 3; -const OUT_189: usize = 8; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_1, __v_2]; 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_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_186] = { let __args: [G; IN_186] = [__v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__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_189] = [__v_33, __v_36, __v_50, __v_53, __v_37, __v_16, __v_63, __v_65]; record.function_queries[189].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_190: usize = 6; -const IN_190: usize = 6; -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 = __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_190] = [__v_14, __v_15]; record.function_queries[190].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_191: usize = 4; -const IN_191: usize = 4; -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 = 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_191] = [__v_14, __v_15]; record.function_queries[191].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_192: usize = 1; -const IN_192: usize = 1; -const OUT_192: usize = 1; -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 __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_192] = [__v_6]; record.function_queries[192].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_191] = { let __args: [G; IN_191] = [__v_2, __v_3, __v_6, __v_7]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8]; 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_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_192] = [__v_13]; record.function_queries[192].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_193: usize = 15; -const IN_193: usize = 15; -const OUT_193: usize = 2; -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 __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __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_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_193] = [__v_16, __v_19]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_19: G = __v_16 + __v_16; let __v_20: G = __v_19 + __v_17; match __v_20.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_4, __v_18]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_21, __v_22]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_5, __v_18]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_21, __v_22]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_2, __v_18]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_21, __v_22]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_3, __v_18]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_21, __v_22]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_6, __v_18]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_21, __v_22]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_7, __v_18]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_21, __v_22]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, 2u64 => { let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_8, __v_16]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_19, __v_20]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_193] = [__v_9, __v_10]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_193] = [__v_11, __v_12]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_193] = [__v_13, __v_14]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__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(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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__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(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_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_193] = [__v_23, __v_24]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__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(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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__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(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_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_193] = [__v_23, __v_24]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__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(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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__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(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_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_193] = [__v_27, __v_30]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__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(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_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_193] = [__v_22, __v_23]; record.function_queries[193].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); }, } }) } -const INPUT_SIZE_194: usize = 19; -const IN_194: usize = 19; -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 __loaded: [G; 3] = { let __base = 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_194] = [__v_0, __v_1]; record.function_queries[194].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__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(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 __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__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(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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __ret: [G; OUT_194] = [__v_26, __v_27]; record.function_queries[194].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }) } -const INPUT_SIZE_195: usize = 8; -const IN_195: usize = 8; -const OUT_195: usize = 4; -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 = __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_195] = [__v_31, __v_32, __v_47, __v_48]; record.function_queries[195].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_196: usize = 19; -const IN_196: usize = 19; -const OUT_196: usize = 4; -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 = 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_196] = [__v_22, __v_22, __v_22, __v_22]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__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(196, &__args[..])?) { [G::ZERO; OUT_196] } else { let (__hash, __hit) = record.function_queries[196].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[196].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => { aiur_fn_196::(__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_195] = { let __args: [G; IN_195] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(195, &__args[..])?) { [G::ZERO; OUT_195] } else { let (__hash, __hit) = record.function_queries[195].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[195].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => { aiur_fn_195::(__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_193] = { let __args: [G; IN_193] = [__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(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_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_196] = [__v_32, __v_33, __v_28, __v_29]; record.function_queries[196].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }) } -const INPUT_SIZE_197: usize = 44; -const IN_197: usize = 44; -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 __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_197] = [__v_0, __v_1]; record.function_queries[197].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_45.as_canonical_u64() { _ => { let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__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(196, &__args[..])?) { [G::ZERO; OUT_196] } else { let (__hash, __hit) = record.function_queries[196].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[196].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => { aiur_fn_196::(__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_193] = { let __args: [G; IN_193] = [__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(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_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(195, &__args[..])?) { [G::ZERO; OUT_195] } else { let (__hash, __hit) = record.function_queries[195].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[195].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => { aiur_fn_195::(__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_195] = { let __args: [G; IN_195] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(195, &__args[..])?) { [G::ZERO; OUT_195] } else { let (__hash, __hit) = record.function_queries[195].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[195].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => { aiur_fn_195::(__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_5 + __v_85; let __v_87: G = __v_86 - __v_6; match __v_87.as_canonical_u64() { 0u64 => { let __v_88: G = __v_7 + __v_7; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_35, __v_88]; 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_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_88 + __v_91; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_35, __v_92]; 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_93: G = __r_arr[0]; let __v_94: G = __r_arr[1]; let __v_95: G = G::from_u64(0); let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_36, __v_95]; 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_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __v_96 + __v_18; let __v_99: G = __v_97 + __v_19; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_36, __v_91]; 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_100: G = __r_arr[0]; let __v_101: G = __r_arr[1]; let __v_102: G = __v_100 + __v_20; let __v_103: G = __v_101 + __v_21; let __v_104: G = __v_98 - __v_89; let __v_105: G = __v_99 - __v_90; let __v_106: G = __v_102 - __v_93; let __v_107: G = __v_103 - __v_94; let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_81, __v_82, __v_83, __v_84, __v_104, __v_105, __v_106, __v_107]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(195, &__args[..])?) { [G::ZERO; OUT_195] } else { let (__hash, __hit) = record.function_queries[195].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[195].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => { aiur_fn_195::(__args, __hash, record, io_buffer)? }, } } }; let __v_108: G = __r_arr[0]; let __v_109: G = __r_arr[1]; let __v_110: G = __r_arr[2]; let __v_111: G = __r_arr[3]; let __v_112: G = __v_108 - __v_70; let __v_113: G = __v_109 - __v_71; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_1, __v_2, __v_3, __v_112, __v_113]; 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_114: G = __r_arr[0]; let __v_115: G = __r_arr[1]; let __v_116: G = __v_110 - __v_79; let __v_117: G = __v_111 - __v_80; let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_114, __v_115, __v_2, __v_3, __v_116, __v_117]; 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_118: G = __r_arr[0]; let __v_119: G = __r_arr[1]; let __ret: [G; OUT_197] = [__v_118, __v_119]; record.function_queries[197].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_253] = { let __args: [G; IN_253] = [__v_35, __v_90]; 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_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_90 + __v_93; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_35, __v_94]; 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_95: G = __r_arr[0]; let __v_96: G = __r_arr[1]; let __v_97: G = G::from_u64(2); let __v_98: G = __v_90 + __v_97; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_35, __v_98]; 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_99: G = __r_arr[0]; let __v_100: G = __r_arr[1]; let __v_101: G = G::from_u64(3); let __v_102: G = __v_90 + __v_101; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_35, __v_102]; 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_103: G = __r_arr[0]; let __v_104: G = __r_arr[1]; let __v_105: G = __v_99 - __v_91; let __v_106: G = __v_100 - __v_92; let __v_107: G = __v_103 - __v_95; let __v_108: G = __v_104 - __v_96; let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_81, __v_82, __v_83, __v_84, __v_105, __v_106, __v_107, __v_108]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(195, &__args[..])?) { [G::ZERO; OUT_195] } else { let (__hash, __hit) = record.function_queries[195].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[195].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => { aiur_fn_195::(__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_190] = { let __args: [G; IN_190] = [__v_0, __v_1, __v_2, __v_3, __v_113, __v_114]; 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_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_190] = { let __args: [G; IN_190] = [__v_115, __v_116, __v_2, __v_3, __v_117, __v_118]; 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_119: G = __r_arr[0]; let __v_120: G = __r_arr[1]; let __v_121: G = __v_5 + __v_93; let __v_122: G = __v_7 + __v_93; let __v_123: G = G::from_u64(0); let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_119, __v_120, __v_2, __v_3, __v_47, __v_121, __v_6, __v_122, __v_9, __v_9, __v_93, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __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(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_124: G = __r_arr[0]; let __v_125: G = __r_arr[1]; let __ret: [G; OUT_197] = [__v_124, __v_125]; record.function_queries[197].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_197] = { let __args: [G; IN_197] = [__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(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_93: G = __r_arr[0]; let __v_94: G = __r_arr[1]; let __ret: [G; OUT_197] = [__v_93, __v_94]; record.function_queries[197].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, _ => { return Err(ExecError::MatchNoCase(__v_44.as_canonical_u64())); }, } }) } -const INPUT_SIZE_198: usize = 28; -const IN_198: usize = 28; -const OUT_198: usize = 2; -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]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_194] = { let __args: [G; IN_194] = [__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(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_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_253] = { let __args: [G; IN_253] = [__v_9, __v_64]; 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_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_8, __v_64]; 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_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_190] = { let __args: [G; IN_190] = [__v_29, __v_30, __v_25, __v_26, __v_71, __v_72]; 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_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_253] = { let __args: [G; IN_253] = [__v_9, __v_75]; 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_76: G = __r_arr[0]; let __v_77: G = __r_arr[1]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_8, __v_75]; 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_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_190] = { let __args: [G; IN_190] = [__v_73, __v_74, __v_25, __v_26, __v_82, __v_83]; 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_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __ret: [G; OUT_198] = [__v_84, __v_85]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_64: G = G::from_u64(0); let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2]; 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_65: G = __r_arr[0]; let __v_66: G = G::from_u64(1); let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__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(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_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __ret: [G; OUT_198] = [__v_67, __v_68]; record.function_queries[198].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_60.as_canonical_u64())); }, } }) } -const INPUT_SIZE_199: usize = 8; -const IN_199: usize = 8; -const OUT_199: usize = 1; -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]; let __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_199] = [__v_18]; record.function_queries[199].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_200: usize = 5; -const IN_200: usize = 5; -const OUT_200: usize = 2; -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 __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_200] = [__v_9, __v_9]; record.function_queries[200].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_200] = { let __args: [G; IN_200] = [__v_8, __v_1, __v_2, __v_20, __v_23]; 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_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_200] = [__v_26, __v_27]; record.function_queries[200].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }) } -const INPUT_SIZE_201: usize = 1; -const IN_201: usize = 1; -const OUT_201: usize = 1; -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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(32); let __ret: [G; OUT_201] = [__v_1]; record.function_queries[201].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_202: usize = 4; -const IN_202: usize = 4; -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]; 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_202] = [__v_5, __v_5]; record.function_queries[202].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_202] = [__v_5, __v_5]; record.function_queries[202].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_4, __v_5]; 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_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_4, __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_8: G = __r_arr[0]; let __ret: [G; OUT_202] = [__v_6, __v_8]; record.function_queries[202].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_203: usize = 20; -const IN_203: usize = 20; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_203] = [__v_31]; record.function_queries[203].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_21.as_canonical_u64() { _ => { let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_2, __v_9]; 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_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_201] = { let __args: [G; IN_201] = [__v_24]; 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 __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_3, __v_9]; 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_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_4, __v_9]; 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_38: G = __r_arr[0]; let __v_39: G = G::from_u64(0); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_38, __v_39]; 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_40: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_38, __v_34]; 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_41: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_5, __v_9]; 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_42: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_42, __v_39]; 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_43: G = __r_arr[0]; let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_42, __v_34]; 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]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_1, __v_9]; 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_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_242] = { let __args: [G; IN_242] = [__v_7, __v_46]; 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_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_47, __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_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_47, __v_50]; 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_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_245] = { let __args: [G; IN_245] = [__v_40]; 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_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_245] = { let __args: [G; IN_245] = [__v_41]; 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_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_245] = { let __args: [G; IN_245] = [__v_43]; 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_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_245] = { let __args: [G; IN_245] = [__v_44]; 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_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_245] = { let __args: [G; IN_245] = [__v_47]; 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_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_245] = { let __args: [G; IN_245] = [__v_48]; 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_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_185] = { let __args: [G; IN_185] = [__v_18, __v_19, __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_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_186] = { let __args: [G; IN_186] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__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_188] = { let __args: [G; IN_188] = [__v_31]; 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_139: G = __r_arr[0]; let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_31]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(186, &__args[..])?) { [G::ZERO; OUT_186] } else { let (__hash, __hit) = record.function_queries[186].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[186].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => { aiur_fn_186::(__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_194] = { let __args: [G; IN_194] = [__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(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_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_253] = { let __args: [G; IN_253] = [__v_44, __v_181]; 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_182: G = __r_arr[0]; let __v_183: G = __r_arr[1]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_43, __v_181]; 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_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_190] = { let __args: [G; IN_190] = [__v_147, __v_148, __v_16, __v_17, __v_188, __v_189]; 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_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_253] = { let __args: [G; IN_253] = [__v_44, __v_192]; 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_193: G = __r_arr[0]; let __v_194: G = __r_arr[1]; let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_43, __v_192]; 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_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_190] = { let __args: [G; IN_190] = [__v_190, __v_191, __v_16, __v_17, __v_199, __v_200]; 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_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_245] = { let __args: [G; IN_245] = [__v_25]; 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_182: G = __r_arr[0]; let __v_183: G = G::from_u64(1); let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__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(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_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_242] = { let __args: [G; IN_242] = [__v_8, __v_9]; 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_183: G = __r_arr[0]; let __v_184: G = G::from_u64(0); let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_183, __v_184]; 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_185: G = __r_arr[0]; let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_185]; 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_186: G = __r_arr[0]; let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_186]; 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_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_185] = { let __args: [G; IN_185] = [__v_18, __v_19, __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_191: G = __r_arr[0]; let __v_192: G = __r_arr[1]; let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_186, __v_191, __v_192, __v_190, __v_184]; 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_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_203] = { let __args: [G; IN_203] = [__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(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_209: G = __r_arr[0]; let __ret: [G; OUT_203] = [__v_209]; record.function_queries[203].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }) } -const INPUT_SIZE_204: usize = 3; -const IN_204: usize = 3; -const OUT_204: usize = 2; -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 __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_204] = [__v_13, __v_13]; record.function_queries[204].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 = __v_4 + __v_14; let __v_16: G = G::from_u64(65536); let __v_17: G = __v_16 * __v_6; let __v_18: G = __v_15 + __v_17; let __v_19: G = G::from_u64(16777216); let __v_20: G = __v_19 * __v_7; let __v_21: G = __v_18 + __v_20; let __v_22: G = G::from_u64(4294967296); let __v_23: G = __v_22 * __v_8; let __v_24: G = __v_21 + __v_23; let __v_25: G = G::from_u64(1099511627776); let __v_26: G = __v_25 * __v_9; let __v_27: G = __v_24 + __v_26; let __v_28: G = G::from_u64(281474976710656); let __v_29: G = __v_28 * __v_10; let __v_30: G = __v_27 + __v_29; let __v_31: G = G::from_u64(72057594037927936); let __v_32: G = __v_31 * __v_11; let __v_33: G = __v_30 + __v_32; let __v_34: G = G::from_u64(0); let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_1, __v_12]; 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_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_204] = [__v_45, __v_46]; record.function_queries[204].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_205: usize = 7; -const IN_205: usize = 7; -const OUT_205: usize = 2; -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 __v_2: G = inp[2]; let __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_205] = [__v_0, __v_1]; record.function_queries[205].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_5, __v_6, __v_8]; 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_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_205] = { let __args: [G; IN_205] = [__v_29, __v_30, __v_9, __v_3, __v_4, __v_5, __v_6]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __ret: [G; OUT_205] = [__v_31, __v_32]; record.function_queries[205].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }) } -const INPUT_SIZE_206: usize = 1; -const IN_206: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_206] = [__v_4]; record.function_queries[206].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_206] = { let __args: [G; IN_206] = [__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_8: G = __r_arr[0]; let __ret: [G; OUT_206] = [__v_8]; record.function_queries[206].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -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 __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_207] = [__v_14]; record.function_queries[207].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_207] = { let __args: [G; IN_207] = [__v_12, __v_15]; 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_16: G = __r_arr[0]; let __ret: [G; OUT_207] = [__v_16]; record.function_queries[207].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_12, __v_15]; 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_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_207] = [__v_18]; record.function_queries[207].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_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; 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_208] = [__v_7]; record.function_queries[208].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_208] = { let __args: [G; IN_208] = [__v_5, __v_8]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_208] = [__v_9]; record.function_queries[208].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_5, __v_8]; 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_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_208] = [__v_11]; record.function_queries[208].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_209: usize = 2; -const IN_209: usize = 2; -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 __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 = __v_2 + __v_11; let __v_13: G = G::from_u64(65536); let __v_14: G = __v_13 * __v_4; let __v_15: G = __v_12 + __v_14; let __v_16: G = G::from_u64(16777216); let __v_17: G = __v_16 * __v_5; let __v_18: G = __v_15 + __v_17; let __v_19: G = G::from_u64(4294967296); let __v_20: G = __v_19 * __v_6; let __v_21: G = __v_18 + __v_20; let __v_22: G = G::from_u64(1099511627776); let __v_23: G = __v_22 * __v_7; let __v_24: G = __v_21 + __v_23; let __v_25: G = G::from_u64(281474976710656); let __v_26: G = __v_25 * __v_8; let __v_27: G = __v_24 + __v_26; let __v_28: G = G::from_u64(72057594037927936); let __v_29: G = __v_28 * __v_9; let __v_30: G = __v_27 + __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 = __v_6 + __v_7; let __v_32: G = __v_31 + __v_8; let __v_33: G = __v_32 + __v_9; let __v_34: G = G::from_u64(1020); let __v_35: G = __v_33 - __v_34; let __v_36: G = G::from_bool(__v_35 == G::ZERO); let __v_37: G = __v_2 + __v_3; let __v_38: G = __v_37 + __v_4; let __v_39: G = __v_38 + __v_5; 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_171] = { let __args: [G; IN_171] = [__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(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_45: G = __r_arr[0]; let __ret: [G; OUT_209] = [__v_45]; 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 __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0]; 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_2: G = __r_arr[0]; let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_0, __v_1]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_2, __v_3]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_210] = [__v_4]; record.function_queries[210].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -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 __loaded: [G; 3] = { let __base = 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_211] = [__v_1]; record.function_queries[211].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_3]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_4, __v_1]; 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_183] = { let __args: [G; IN_183] = [__v_3, __v_6]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_5, __v_7]; 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_8: G = __r_arr[0]; let __ret: [G; OUT_211] = [__v_8]; record.function_queries[211].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_212: usize = 5; -const IN_212: usize = 5; -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 __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_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_5: G = __r_arr[0]; let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_3, __v_4]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_2, __v_6]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_5, __v_7]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_1, __v_8]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_0, __v_9]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_212] = [__v_10]; record.function_queries[212].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_213: usize = 2; -const IN_213: usize = 2; -const OUT_213: usize = 1; -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 __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_213] = [__v_1]; record.function_queries[213].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_7, __v_1]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_3, __v_4, __v_5, __v_6, __v_8]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_213] = [__v_9]; record.function_queries[213].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_214: usize = 2; -const IN_214: usize = 2; -const OUT_214: usize = 1; -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 __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0]; 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_2: G = __r_arr[0]; let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_1]; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_2, __v_3]; 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_4: G = __r_arr[0]; let __ret: [G; OUT_214] = [__v_4]; 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; 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_215] = [__v_1]; record.function_queries[215].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_3]; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_12, __v_1]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__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(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_15: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_3, __v_15]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_13, __v_16]; 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_17: G = __r_arr[0]; let __ret: [G; OUT_215] = [__v_17]; record.function_queries[215].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_216: usize = 4; -const IN_216: usize = 4; -const OUT_216: usize = 5; -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 __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_214] = { let __args: [G; IN_214] = [__v_3, __v_5]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_2, __v_6]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_8, __v_7]; 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 __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_1, __v_9]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_10]; 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_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_177] = { let __args: [G; IN_177] = [__v_39, __v_5]; 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_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_171] = { let __args: [G; IN_171] = [__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(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_58: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__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(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_59: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_56, __v_59]; 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_60: G = __r_arr[0]; let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_60, __v_5]; 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_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_171] = { let __args: [G; IN_171] = [__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(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_79: G = __r_arr[0]; let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__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(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_80: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_77, __v_80]; 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_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 = __v_40 + __v_83; let __v_85: G = G::from_u64(65536); let __v_86: G = __v_85 * __v_42; let __v_87: G = __v_84 + __v_86; let __v_88: G = G::from_u64(16777216); let __v_89: G = __v_88 * __v_43; let __v_90: G = __v_87 + __v_89; let __v_91: G = G::from_u64(4294967296); let __v_92: G = __v_91 * __v_44; let __v_93: G = __v_90 + __v_92; let __v_94: G = G::from_u64(1099511627776); let __v_95: G = __v_94 * __v_45; let __v_96: G = __v_93 + __v_95; let __v_97: G = G::from_u64(281474976710656); let __v_98: G = __v_97 * __v_46; let __v_99: G = __v_96 + __v_98; let __v_100: G = G::from_u64(72057594037927936); let __v_101: G = __v_100 * __v_47; let __v_102: G = __v_99 + __v_101; let __v_103: G = __v_82 * __v_49; let __v_104: G = __v_48 + __v_103; let __v_105: G = __v_85 * __v_50; let __v_106: G = __v_104 + __v_105; let __v_107: G = __v_88 * __v_51; let __v_108: G = __v_106 + __v_107; let __v_109: G = __v_91 * __v_52; let __v_110: G = __v_108 + __v_109; let __v_111: G = __v_94 * __v_53; let __v_112: G = __v_110 + __v_111; let __v_113: G = __v_97 * __v_54; let __v_114: G = __v_112 + __v_113; let __v_115: G = __v_100 * __v_55; let __v_116: G = __v_114 + __v_115; let __v_117: G = __v_82 * __v_62; let __v_118: G = __v_61 + __v_117; let __v_119: G = __v_85 * __v_63; let __v_120: G = __v_118 + __v_119; let __v_121: G = __v_88 * __v_64; let __v_122: G = __v_120 + __v_121; let __v_123: G = __v_91 * __v_65; let __v_124: G = __v_122 + __v_123; let __v_125: G = __v_94 * __v_66; let __v_126: G = __v_124 + __v_125; let __v_127: G = __v_97 * __v_67; let __v_128: G = __v_126 + __v_127; let __v_129: G = __v_100 * __v_68; let __v_130: G = __v_128 + __v_129; let __v_131: G = __v_82 * __v_70; let __v_132: G = __v_69 + __v_131; let __v_133: G = __v_85 * __v_71; let __v_134: G = __v_132 + __v_133; let __v_135: G = __v_88 * __v_72; let __v_136: G = __v_134 + __v_135; let __v_137: G = __v_91 * __v_73; let __v_138: G = __v_136 + __v_137; let __v_139: G = __v_94 * __v_74; let __v_140: G = __v_138 + __v_139; let __v_141: G = __v_97 * __v_75; let __v_142: G = __v_140 + __v_141; let __v_143: G = __v_100 * __v_76; let __v_144: G = __v_142 + __v_143; let __ret: [G; OUT_216] = [__v_102, __v_116, __v_130, __v_144, __v_81]; record.function_queries[216].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_217: usize = 5; -const IN_217: usize = 5; -const OUT_217: usize = 5; -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 __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 = __v_5 + __v_14; let __v_16: G = G::from_u64(65536); let __v_17: G = __v_16 * __v_7; let __v_18: G = __v_15 + __v_17; let __v_19: G = G::from_u64(16777216); let __v_20: G = __v_19 * __v_8; let __v_21: G = __v_18 + __v_20; let __v_22: G = G::from_u64(4294967296); let __v_23: G = __v_22 * __v_9; let __v_24: G = __v_21 + __v_23; let __v_25: G = G::from_u64(1099511627776); let __v_26: G = __v_25 * __v_10; let __v_27: G = __v_24 + __v_26; let __v_28: G = G::from_u64(281474976710656); let __v_29: G = __v_28 * __v_11; let __v_30: G = __v_27 + __v_29; let __v_31: G = G::from_u64(72057594037927936); let __v_32: G = __v_31 * __v_12; let __v_33: G = __v_30 + __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 = __v_9 + __v_10; let __v_35: G = __v_34 + __v_11; let __v_36: G = __v_35 + __v_12; let __v_37: G = G::from_u64(1020); let __v_38: G = __v_36 - __v_37; let __v_39: G = G::from_bool(__v_38 == G::ZERO); let __v_40: G = __v_5 + __v_6; let __v_41: G = __v_40 + __v_7; let __v_42: G = __v_41 + __v_8; 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_180] = { let __args: [G; IN_180] = [__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(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_48: G = __r_arr[0]; let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_48, __v_2]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(181, &__args[..])?) { [G::ZERO; OUT_181] } else { let (__hash, __hit) = record.function_queries[181].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[181].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => { aiur_fn_181::(__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_134] = { let __args: [G; IN_134] = [__v_4, __v_50]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(134, &__args[..])?) { [G::ZERO; OUT_134] } else { let (__hash, __hit) = record.function_queries[134].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[134].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => { aiur_fn_134::(__args, __hash, record, io_buffer)? }, } } }; let __v_51: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_49, __v_51]; 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_52: G = __r_arr[0]; let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_52, __v_50]; 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_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_181] = { let __args: [G; IN_181] = [__v_69, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(181, &__args[..])?) { [G::ZERO; OUT_181] } else { let (__hash, __hit) = record.function_queries[181].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[181].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => { aiur_fn_181::(__args, __hash, record, io_buffer)? }, } } }; let __v_71: G = __r_arr[0]; let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_71, __v_50]; 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_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_53 + __v_90; let __v_92: G = __v_16 * __v_55; let __v_93: G = __v_91 + __v_92; let __v_94: G = __v_19 * __v_56; let __v_95: G = __v_93 + __v_94; let __v_96: G = __v_22 * __v_57; let __v_97: G = __v_95 + __v_96; let __v_98: G = __v_25 * __v_58; let __v_99: G = __v_97 + __v_98; let __v_100: G = __v_28 * __v_59; let __v_101: G = __v_99 + __v_100; let __v_102: G = __v_31 * __v_60; let __v_103: G = __v_101 + __v_102; let __v_104: G = __v_13 * __v_62; let __v_105: G = __v_61 + __v_104; let __v_106: G = __v_16 * __v_63; let __v_107: G = __v_105 + __v_106; let __v_108: G = __v_19 * __v_64; let __v_109: G = __v_107 + __v_108; let __v_110: G = __v_22 * __v_65; let __v_111: G = __v_109 + __v_110; let __v_112: G = __v_25 * __v_66; let __v_113: G = __v_111 + __v_112; let __v_114: G = __v_28 * __v_67; let __v_115: G = __v_113 + __v_114; let __v_116: G = __v_31 * __v_68; let __v_117: G = __v_115 + __v_116; let __v_118: G = __v_13 * __v_73; let __v_119: G = __v_72 + __v_118; let __v_120: G = __v_16 * __v_74; let __v_121: G = __v_119 + __v_120; let __v_122: G = __v_19 * __v_75; let __v_123: G = __v_121 + __v_122; let __v_124: G = __v_22 * __v_76; let __v_125: G = __v_123 + __v_124; let __v_126: G = __v_25 * __v_77; let __v_127: G = __v_125 + __v_126; let __v_128: G = __v_28 * __v_78; let __v_129: G = __v_127 + __v_128; let __v_130: G = __v_31 * __v_79; let __v_131: G = __v_129 + __v_130; let __v_132: G = __v_13 * __v_81; let __v_133: G = __v_80 + __v_132; let __v_134: G = __v_16 * __v_82; let __v_135: G = __v_133 + __v_134; let __v_136: G = __v_19 * __v_83; let __v_137: G = __v_135 + __v_136; let __v_138: G = __v_22 * __v_84; let __v_139: G = __v_137 + __v_138; let __v_140: G = __v_25 * __v_85; let __v_141: G = __v_139 + __v_140; let __v_142: G = __v_28 * __v_86; let __v_143: G = __v_141 + __v_142; let __v_144: G = __v_31 * __v_87; let __v_145: G = __v_143 + __v_144; let __ret: [G; OUT_217] = [__v_103, __v_117, __v_131, __v_145, __v_88]; record.function_queries[217].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -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 => { 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_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_8: G = __r_arr[0]; let __ret: [G; OUT_218] = [__v_8]; 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 = 2; -const IN_219: usize = 2; -const OUT_219: usize = 1; -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 __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_219] = [__v_22]; record.function_queries[219].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_219] = { let __args: [G; IN_219] = [__v_11, __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_24: G = __r_arr[0]; let __ret: [G; OUT_219] = [__v_24]; record.function_queries[219].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_220: usize = 2; -const IN_220: usize = 2; -const OUT_220: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_220] = [__v_8]; record.function_queries[220].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_219] = { let __args: [G; IN_219] = [__v_3, __v_6]; 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_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_220] = { let __args: [G; IN_220] = [__v_4, __v_7]; 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_10: G = __r_arr[0]; let __ret: [G; OUT_220] = [__v_10]; record.function_queries[220].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_221: usize = 2; -const IN_221: usize = 2; -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]; 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_221] = [__v_8]; record.function_queries[221].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_221] = { let __args: [G; IN_221] = [__v_4, __v_7]; 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_77: G = __r_arr[0]; let __ret: [G; OUT_221] = [__v_77]; record.function_queries[221].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_222: usize = 1; -const IN_222: usize = 1; -const OUT_222: usize = 2; -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; 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_222] = [__v_2, __v_3]; record.function_queries[222].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_4]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_222] = [__v_9, __v_10]; 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 = 7; -const IN_223: usize = 7; -const OUT_223: usize = 2; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __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_223] = [__v_0, __v_1]; record.function_queries[223].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_8.as_canonical_u64() { _ => { let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_5, __v_6, __v_8]; 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_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 = __v_9 + __v_38; let __v_40: G = G::from_u64(65536); let __v_41: G = __v_40 * __v_11; let __v_42: G = __v_39 + __v_41; let __v_43: G = G::from_u64(16777216); let __v_44: G = __v_43 * __v_12; let __v_45: G = __v_42 + __v_44; let __v_46: G = G::from_u64(4294967296); let __v_47: G = __v_46 * __v_13; let __v_48: G = __v_45 + __v_47; let __v_49: G = G::from_u64(1099511627776); let __v_50: G = __v_49 * __v_14; let __v_51: G = __v_48 + __v_50; let __v_52: G = G::from_u64(281474976710656); let __v_53: G = __v_52 * __v_15; let __v_54: G = __v_51 + __v_53; let __v_55: G = G::from_u64(72057594037927936); let __v_56: G = __v_55 * __v_16; let __v_57: G = __v_54 + __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_223] = { let __args: [G; IN_223] = [__v_65, __v_66, __v_17, __v_3, __v_4, __v_5, __v_6]; 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_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __ret: [G; OUT_223] = [__v_67, __v_68]; record.function_queries[223].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_7.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]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 18u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 19u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 20u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 21u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 22u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 23u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 24u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 25u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 26u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 27u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 28u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 29u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 30u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 31u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_1]; record.function_queries[224].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_224] = [__v_1]; 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 = 1; -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; 3] = { let __base = 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_225] = [__v_4]; record.function_queries[225].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_2]; 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_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_225] = { let __args: [G; IN_225] = [__v_3]; 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_6: G = __r_arr[0]; let __ret: [G; OUT_225] = [__v_6]; record.function_queries[225].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_226: usize = 1; -const IN_226: usize = 1; -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 __loaded: [G; 3] = { let __base = 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_226] = [__v_4]; record.function_queries[226].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_3]; 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_4: G = __r_arr[0]; let __v_5: G = __v_2 + __v_4; let __ret: [G; OUT_226] = [__v_5]; record.function_queries[226].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_227: usize = 1; -const IN_227: usize = 1; -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 = 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 = __v_3 + __v_12; let __v_14: G = G::from_u64(65536); let __v_15: G = __v_14 * __v_5; let __v_16: G = __v_13 + __v_15; let __v_17: G = G::from_u64(16777216); let __v_18: G = __v_17 * __v_6; let __v_19: G = __v_16 + __v_18; let __v_20: G = G::from_u64(4294967296); let __v_21: G = __v_20 * __v_7; let __v_22: G = __v_19 + __v_21; let __v_23: G = G::from_u64(1099511627776); let __v_24: G = __v_23 * __v_8; let __v_25: G = __v_22 + __v_24; let __v_26: G = G::from_u64(281474976710656); let __v_27: G = __v_26 * __v_9; let __v_28: G = __v_25 + __v_27; let __v_29: G = G::from_u64(72057594037927936); let __v_30: G = __v_29 * __v_10; let __v_31: G = __v_28 + __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 = __v_7 + __v_8; let __v_33: G = __v_32 + __v_9; let __v_34: G = __v_33 + __v_10; let __v_35: G = G::from_u64(1020); let __v_36: G = __v_34 - __v_35; let __v_37: G = G::from_bool(__v_36 == G::ZERO); let __v_38: G = __v_3 + __v_4; let __v_39: G = __v_38 + __v_5; let __v_40: G = __v_39 + __v_6; 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_6 + __v_7; let __v_47: G = __v_46 + __v_8; let __v_48: G = __v_47 + __v_9; let __v_49: G = __v_48 + __v_10; 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_5 * __v_38; if (__v_52 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_227] = [__v_42]; record.function_queries[227].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_228: usize = 1; -const IN_228: usize = 1; -const OUT_228: usize = 24; -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 __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_228] = [__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[228].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_229: usize = 3; -const IN_229: usize = 3; -const OUT_229: usize = 1; -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 = 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_229] = [__v_7]; record.function_queries[229].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_230: usize = 16; -const IN_230: usize = 16; -const OUT_230: usize = 1; -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 = G::from_u64(1); let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_8, __v_16]; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_1, __v_9, __v_17]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_10, __v_18]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_3, __v_11, __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_20: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_4, __v_12, __v_20]; 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_21: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_5, __v_13, __v_21]; 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_22: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_6, __v_14, __v_22]; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_7, __v_15, __v_23]; 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_24: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_24]; record.function_queries[230].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_231: usize = 3; -const IN_231: usize = 3; -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 __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_231] = [__v_14]; record.function_queries[231].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 = __v_5 + __v_26; let __v_28: G = G::from_u64(65536); let __v_29: G = __v_28 * __v_7; let __v_30: G = __v_27 + __v_29; let __v_31: G = G::from_u64(16777216); let __v_32: G = __v_31 * __v_8; let __v_33: G = __v_30 + __v_32; let __v_34: G = G::from_u64(4294967296); let __v_35: G = __v_34 * __v_9; let __v_36: G = __v_33 + __v_35; let __v_37: G = G::from_u64(1099511627776); let __v_38: G = __v_37 * __v_10; let __v_39: G = __v_36 + __v_38; let __v_40: G = G::from_u64(281474976710656); let __v_41: G = __v_40 * __v_11; let __v_42: G = __v_39 + __v_41; let __v_43: G = G::from_u64(72057594037927936); let __v_44: G = __v_43 * __v_12; let __v_45: G = __v_42 + __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_16 + __v_49; let __v_51: G = __v_28 * __v_18; let __v_52: G = __v_50 + __v_51; let __v_53: G = __v_31 * __v_19; let __v_54: G = __v_52 + __v_53; let __v_55: G = __v_34 * __v_20; let __v_56: G = __v_54 + __v_55; let __v_57: G = __v_37 * __v_21; let __v_58: G = __v_56 + __v_57; let __v_59: G = __v_40 * __v_22; let __v_60: G = __v_58 + __v_59; let __v_61: G = __v_43 * __v_23; let __v_62: G = __v_60 + __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_228] = { let __args: [G; IN_228] = [__v_4]; 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_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_228] = { let __args: [G; IN_228] = [__v_15]; 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_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_63 + __v_111; let __v_113: G = __v_28 * __v_65; let __v_114: G = __v_112 + __v_113; let __v_115: G = __v_31 * __v_66; let __v_116: G = __v_114 + __v_115; let __v_117: G = __v_34 * __v_67; let __v_118: G = __v_116 + __v_117; let __v_119: G = __v_37 * __v_68; let __v_120: G = __v_118 + __v_119; let __v_121: G = __v_40 * __v_69; let __v_122: G = __v_120 + __v_121; let __v_123: G = __v_43 * __v_70; let __v_124: G = __v_122 + __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_87 + __v_126; let __v_128: G = __v_28 * __v_89; let __v_129: G = __v_127 + __v_128; let __v_130: G = __v_31 * __v_90; let __v_131: G = __v_129 + __v_130; let __v_132: G = __v_34 * __v_91; let __v_133: G = __v_131 + __v_132; let __v_134: G = __v_37 * __v_92; let __v_135: G = __v_133 + __v_134; let __v_136: G = __v_40 * __v_93; let __v_137: G = __v_135 + __v_136; let __v_138: G = __v_43 * __v_94; let __v_139: G = __v_137 + __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_71 + __v_140; let __v_142: G = __v_28 * __v_73; let __v_143: G = __v_141 + __v_142; let __v_144: G = __v_31 * __v_74; let __v_145: G = __v_143 + __v_144; let __v_146: G = __v_34 * __v_75; let __v_147: G = __v_145 + __v_146; let __v_148: G = __v_37 * __v_76; let __v_149: G = __v_147 + __v_148; let __v_150: G = __v_40 * __v_77; let __v_151: G = __v_149 + __v_150; let __v_152: G = __v_43 * __v_78; let __v_153: G = __v_151 + __v_152; let __v_154: G = __v_25 * __v_96; let __v_155: G = __v_95 + __v_154; let __v_156: G = __v_28 * __v_97; let __v_157: G = __v_155 + __v_156; let __v_158: G = __v_31 * __v_98; let __v_159: G = __v_157 + __v_158; let __v_160: G = __v_34 * __v_99; let __v_161: G = __v_159 + __v_160; let __v_162: G = __v_37 * __v_100; let __v_163: G = __v_161 + __v_162; let __v_164: G = __v_40 * __v_101; let __v_165: G = __v_163 + __v_164; let __v_166: G = __v_43 * __v_102; let __v_167: G = __v_165 + __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_79 + __v_168; let __v_170: G = __v_28 * __v_81; let __v_171: G = __v_169 + __v_170; let __v_172: G = __v_31 * __v_82; let __v_173: G = __v_171 + __v_172; let __v_174: G = __v_34 * __v_83; let __v_175: G = __v_173 + __v_174; let __v_176: G = __v_37 * __v_84; let __v_177: G = __v_175 + __v_176; let __v_178: G = __v_40 * __v_85; let __v_179: G = __v_177 + __v_178; let __v_180: G = __v_43 * __v_86; let __v_181: G = __v_179 + __v_180; let __v_182: G = __v_25 * __v_104; let __v_183: G = __v_103 + __v_182; let __v_184: G = __v_28 * __v_105; let __v_185: G = __v_183 + __v_184; let __v_186: G = __v_31 * __v_106; let __v_187: G = __v_185 + __v_186; let __v_188: G = __v_34 * __v_107; let __v_189: G = __v_187 + __v_188; let __v_190: G = __v_37 * __v_108; let __v_191: G = __v_189 + __v_190; let __v_192: G = __v_40 * __v_109; let __v_193: G = __v_191 + __v_192; let __v_194: G = __v_43 * __v_110; let __v_195: G = __v_193 + __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_196 + __v_204; let __v_206: G = __v_28 * __v_198; let __v_207: G = __v_205 + __v_206; let __v_208: G = __v_31 * __v_199; let __v_209: G = __v_207 + __v_208; let __v_210: G = __v_34 * __v_200; let __v_211: G = __v_209 + __v_210; let __v_212: G = __v_37 * __v_201; let __v_213: G = __v_211 + __v_212; let __v_214: G = __v_40 * __v_202; let __v_215: G = __v_213 + __v_214; let __v_216: G = __v_43 * __v_203; let __v_217: G = __v_215 + __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 = __v_200 + __v_201; let __v_219: G = __v_218 + __v_202; let __v_220: G = __v_219 + __v_203; let __v_221: G = G::from_u64(1020); let __v_222: G = __v_220 - __v_221; let __v_223: G = G::from_bool(__v_222 == G::ZERO); let __v_224: G = __v_196 + __v_197; let __v_225: G = __v_224 + __v_198; let __v_226: G = __v_225 + __v_199; 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_231 + __v_239; let __v_241: G = __v_28 * __v_233; let __v_242: G = __v_240 + __v_241; let __v_243: G = __v_31 * __v_234; let __v_244: G = __v_242 + __v_243; let __v_245: G = __v_34 * __v_235; let __v_246: G = __v_244 + __v_245; let __v_247: G = __v_37 * __v_236; let __v_248: G = __v_246 + __v_247; let __v_249: G = __v_40 * __v_237; let __v_250: G = __v_248 + __v_249; let __v_251: G = __v_43 * __v_238; let __v_252: G = __v_250 + __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_235 + __v_236; let __v_254: G = __v_253 + __v_237; let __v_255: G = __v_254 + __v_238; let __v_256: G = __v_255 - __v_221; let __v_257: G = G::from_bool(__v_256 == G::ZERO); let __v_258: G = __v_231 + __v_232; let __v_259: G = __v_258 + __v_233; let __v_260: G = __v_259 + __v_234; 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_230] = { let __args: [G; IN_230] = [__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(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_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_268 + __v_276; let __v_278: G = __v_28 * __v_270; let __v_279: G = __v_277 + __v_278; let __v_280: G = __v_31 * __v_271; let __v_281: G = __v_279 + __v_280; let __v_282: G = __v_34 * __v_272; let __v_283: G = __v_281 + __v_282; let __v_284: G = __v_37 * __v_273; let __v_285: G = __v_283 + __v_284; let __v_286: G = __v_40 * __v_274; let __v_287: G = __v_285 + __v_286; let __v_288: G = __v_43 * __v_275; let __v_289: G = __v_287 + __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_272 + __v_273; let __v_291: G = __v_290 + __v_274; let __v_292: G = __v_291 + __v_275; let __v_293: G = __v_292 - __v_221; let __v_294: G = G::from_bool(__v_293 == G::ZERO); let __v_295: G = __v_268 + __v_269; let __v_296: G = __v_295 + __v_270; let __v_297: G = __v_296 + __v_271; 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_302 + __v_310; let __v_312: G = __v_28 * __v_304; let __v_313: G = __v_311 + __v_312; let __v_314: G = __v_31 * __v_305; let __v_315: G = __v_313 + __v_314; let __v_316: G = __v_34 * __v_306; let __v_317: G = __v_315 + __v_316; let __v_318: G = __v_37 * __v_307; let __v_319: G = __v_317 + __v_318; let __v_320: G = __v_40 * __v_308; let __v_321: G = __v_319 + __v_320; let __v_322: G = __v_43 * __v_309; let __v_323: G = __v_321 + __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_306 + __v_307; let __v_325: G = __v_324 + __v_308; let __v_326: G = __v_325 + __v_309; let __v_327: G = __v_326 - __v_221; let __v_328: G = G::from_bool(__v_327 == G::ZERO); let __v_329: G = __v_302 + __v_303; let __v_330: G = __v_329 + __v_304; let __v_331: G = __v_330 + __v_305; 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_230] = { let __args: [G; IN_230] = [__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(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_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_338 + __v_346; let __v_348: G = __v_28 * __v_340; let __v_349: G = __v_347 + __v_348; let __v_350: G = __v_31 * __v_341; let __v_351: G = __v_349 + __v_350; let __v_352: G = __v_34 * __v_342; let __v_353: G = __v_351 + __v_352; let __v_354: G = __v_37 * __v_343; let __v_355: G = __v_353 + __v_354; let __v_356: G = __v_40 * __v_344; let __v_357: G = __v_355 + __v_356; let __v_358: G = __v_43 * __v_345; let __v_359: G = __v_357 + __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_342 + __v_343; let __v_361: G = __v_360 + __v_344; let __v_362: G = __v_361 + __v_345; let __v_363: G = __v_362 - __v_221; let __v_364: G = G::from_bool(__v_363 == G::ZERO); let __v_365: G = __v_338 + __v_339; let __v_366: G = __v_365 + __v_340; let __v_367: G = __v_366 + __v_341; 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_372 + __v_380; let __v_382: G = __v_28 * __v_374; let __v_383: G = __v_381 + __v_382; let __v_384: G = __v_31 * __v_375; let __v_385: G = __v_383 + __v_384; let __v_386: G = __v_34 * __v_376; let __v_387: G = __v_385 + __v_386; let __v_388: G = __v_37 * __v_377; let __v_389: G = __v_387 + __v_388; let __v_390: G = __v_40 * __v_378; let __v_391: G = __v_389 + __v_390; let __v_392: G = __v_43 * __v_379; let __v_393: G = __v_391 + __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_376 + __v_377; let __v_395: G = __v_394 + __v_378; let __v_396: G = __v_395 + __v_379; let __v_397: G = __v_396 - __v_221; let __v_398: G = G::from_bool(__v_397 == G::ZERO); let __v_399: G = __v_372 + __v_373; let __v_400: G = __v_399 + __v_374; let __v_401: G = __v_400 + __v_375; 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_230] = { let __args: [G; IN_230] = [__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(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_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_231] = { let __args: [G; IN_231] = [__v_24, __v_153, __v_195]; 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_409: G = __r_arr[0]; let __ret: [G; OUT_231] = [__v_409]; record.function_queries[231].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_232: usize = 46; -const IN_232: usize = 46; -const OUT_232: usize = 2; -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]; 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_245] = { let __args: [G; IN_245] = [__v_21]; 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_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_244] = { let __args: [G; IN_244] = [__v_39]; 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_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_244] = { let __args: [G; IN_244] = [__v_40]; 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_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_244] = { let __args: [G; IN_244] = [__v_36]; 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_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_206] = { let __args: [G; IN_206] = [__v_17]; 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_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_244] = { let __args: [G; IN_244] = [__v_17]; 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_56: G = __r_arr[0]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_8]; 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_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_207] = { let __args: [G; IN_207] = [__v_8, __v_17]; 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_60: G = __r_arr[0]; let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_11, __v_17]; 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_61: G = __r_arr[0]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_60]; 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_62: G = __r_arr[0]; let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_21]; 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_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_218] = { let __args: [G; IN_218] = [__v_12, __v_17]; 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_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_221] = { let __args: [G; IN_221] = [__v_13, __v_18]; 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_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_218] = { let __args: [G; IN_218] = [__v_14, __v_22]; 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_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_225] = { let __args: [G; IN_225] = [__v_22]; 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_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_226] = { let __args: [G; IN_226] = [__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_71: G = __r_arr[0]; 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_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_217] = { let __args: [G; IN_217] = [__v_41, __v_16, __v_19, __v_20, __v_21]; 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_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_205] = { let __args: [G; IN_205] = [__v_79, __v_79, __v_15, __v_42, __v_43, __v_44, __v_45]; 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_80: G = __r_arr[0]; let __v_81: G = __r_arr[1]; let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__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(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_82: G = __r_arr[0]; let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_60]; 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_83: G = __r_arr[0]; match __v_23.as_canonical_u64() { _ => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_23]; 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_84: G = __r_arr[0]; let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_24]; 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_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_245] = { let __args: [G; IN_245] = [__v_25]; 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_89: G = __r_arr[0]; let __v_90: G = G::from_u64(3); let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_37, __v_38]; 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_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_255] = { let __args: [G; IN_255] = [__v_26]; 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_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_245] = { let __args: [G; IN_245] = [__v_27]; 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_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_136] = { let __args: [G; IN_136] = [__v_38, __v_97]; 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_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_136] = { let __args: [G; IN_136] = [__v_36, __v_98]; 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_99: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_40, __v_99]; 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_100: G = __r_arr[0]; let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_39, __v_100]; 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_101: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_78, __v_101]; 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_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_177] = { let __args: [G; IN_177] = [__v_102, __v_104]; 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_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 = __v_105 + __v_124; let __v_126: G = G::from_u64(65536); let __v_127: G = __v_126 * __v_107; let __v_128: G = __v_125 + __v_127; let __v_129: G = G::from_u64(16777216); let __v_130: G = __v_129 * __v_108; let __v_131: G = __v_128 + __v_130; let __v_132: G = G::from_u64(4294967296); let __v_133: G = __v_132 * __v_109; let __v_134: G = __v_131 + __v_133; let __v_135: G = G::from_u64(1099511627776); let __v_136: G = __v_135 * __v_110; let __v_137: G = __v_134 + __v_136; let __v_138: G = G::from_u64(281474976710656); let __v_139: G = __v_138 * __v_111; let __v_140: G = __v_137 + __v_139; let __v_141: G = G::from_u64(72057594037927936); let __v_142: G = __v_141 * __v_112; let __v_143: G = __v_140 + __v_142; let __v_144: G = __v_123 * __v_114; let __v_145: G = __v_113 + __v_144; let __v_146: G = __v_126 * __v_115; let __v_147: G = __v_145 + __v_146; let __v_148: G = __v_129 * __v_116; let __v_149: G = __v_147 + __v_148; let __v_150: G = __v_132 * __v_117; let __v_151: G = __v_149 + __v_150; let __v_152: G = __v_135 * __v_118; let __v_153: G = __v_151 + __v_152; let __v_154: G = __v_138 * __v_119; let __v_155: G = __v_153 + __v_154; let __v_156: G = __v_141 * __v_120; let __v_157: G = __v_155 + __v_156; let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_121, __v_23, __v_24, __v_5]; 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_158: G = __r_arr[0]; let __v_159: G = __r_arr[1]; let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_27, __v_104]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(134, &__args[..])?) { [G::ZERO; OUT_134] } else { let (__hash, __hit) = record.function_queries[134].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[134].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => { aiur_fn_134::(__args, __hash, record, io_buffer)? }, } } }; let __v_160: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_159, __v_160]; 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_161: G = __r_arr[0]; let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_161, __v_23]; 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_162: G = __r_arr[0]; let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__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(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_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_161] = { let __args: [G; IN_161] = [__v_163, __v_164, __v_4, __v_165]; 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_168: G = __r_arr[0]; let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__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(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_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_164] = { let __args: [G; IN_164] = [__v_25, __v_26, __v_170, __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_171: G = __r_arr[0]; let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__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(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_172: G = __r_arr[0]; let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_26, __v_23, __v_172, __v_168, __v_170, __v_165]; 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_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_222] = { let __args: [G; IN_222] = [__v_21]; 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_174: G = __r_arr[0]; let __v_175: G = __r_arr[1]; let __ret: [G; OUT_232] = [__v_174, __v_175]; record.function_queries[232].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }, } }, } }, } }, } }) } -const INPUT_SIZE_233: usize = 22; -const IN_233: usize = 22; -const OUT_233: usize = 2; -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 __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_233] = [__v_20, __v_21]; record.function_queries[233].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_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_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(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_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_233] = { let __args: [G; IN_233] = [__v_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(233, &__args[..])?) { [G::ZERO; OUT_233] } else { let (__hash, __hit) = record.function_queries[233].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[233].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => { aiur_fn_233::(__args, __hash, record, io_buffer)? }, } } }; let __v_60: G = __r_arr[0]; let __v_61: G = __r_arr[1]; let __ret: [G; OUT_233] = [__v_60, __v_61]; record.function_queries[233].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_234: usize = 1; -const IN_234: usize = 1; -const OUT_234: usize = 1; -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 __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_234] = [__v_8]; record.function_queries[234].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_6]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_5, __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_8: G = __r_arr[0]; let __ret: [G; OUT_234] = [__v_8]; record.function_queries[234].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_235: usize = 15; -const IN_235: usize = 15; -const OUT_235: usize = 1; -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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_247] = { let __args: [G; IN_247] = [__v_12]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_15]; 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_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_243] = { let __args: [G; IN_243] = [__v_14]; 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_18: G = __r_arr[0]; let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_12]; 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_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_231] = { let __args: [G; IN_231] = [__v_13, __v_20, __v_20]; 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_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_216] = { let __args: [G; IN_216] = [__v_7, __v_22, __v_12, __v_13]; 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_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_223] = { let __args: [G; IN_223] = [__v_28, __v_28, __v_13, __v_23, __v_24, __v_25, __v_26]; 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_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_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(233, &__args[..])?) { [G::ZERO; OUT_233] } else { let (__hash, __hit) = record.function_queries[233].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[233].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => { aiur_fn_233::(__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_234] = { let __args: [G; IN_234] = [__v_12]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(234, &__args[..])?) { [G::ZERO; OUT_234] } else { let (__hash, __hit) = record.function_queries[234].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[234].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => { aiur_fn_234::(__args, __hash, record, io_buffer)? }, } } }; let __v_37: G = __r_arr[0]; let __ret: [G; OUT_235] = [__v_37]; record.function_queries[235].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }, } }) } -const INPUT_SIZE_236: usize = 15; -const IN_236: usize = 15; -const OUT_236: usize = 1; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_235] = { let __args: [G; IN_235] = [__v_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(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_28: G = __r_arr[0]; let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_28, __v_14]; 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 = 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_236] = [__v_30]; record.function_queries[236].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_237: usize = 1; -const IN_237: usize = 1; -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 __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_238] = { let __args: [G; IN_238] = [__v_2, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(238, &__args[..])?) { [G::ZERO; OUT_238] } else { let (__hash, __hit) = record.function_queries[238].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[238].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => { aiur_fn_238::(__args, __hash, record, io_buffer)? }, } } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_237] = [__v_3, __v_4]; record.function_queries[237].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_238: usize = 2; -const IN_238: usize = 2; -const OUT_238: usize = 2; -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]; 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_238] = [__v_3, __v_0]; record.function_queries[238].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_240] = { let __args: [G; IN_240] = [__v_3, __v_2]; 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_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_238] = { let __args: [G; IN_238] = [__v_5, __v_7]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(238, &__args[..])?) { [G::ZERO; OUT_238] } else { let (__hash, __hit) = record.function_queries[238].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[238].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => { aiur_fn_238::(__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_238] = [__v_11, __v_9]; record.function_queries[238].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_239: usize = 1; -const IN_239: usize = 1; -const OUT_239: usize = 2; -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 __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_240] = { let __args: [G; IN_240] = [__v_2, __v_1]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_239] = [__v_3, __v_4]; record.function_queries[239].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_240: usize = 2; -const IN_240: usize = 2; -const OUT_240: usize = 2; -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 __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_240] = [__v_3, __v_0]; record.function_queries[240].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_240] = { let __args: [G; IN_240] = [__v_10, __v_12]; 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_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_240] = [__v_16, __v_14]; record.function_queries[240].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_241: usize = 16; -const IN_241: usize = 16; -const OUT_241: usize = 0; -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 __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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 = 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_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 = __v_59 + __v_92; let __v_94: G = G::from_u64(65536); let __v_95: G = __v_94 * __v_61; let __v_96: G = __v_93 + __v_95; let __v_97: G = G::from_u64(16777216); let __v_98: G = __v_97 * __v_62; let __v_99: G = __v_96 + __v_98; let __v_100: G = __v_91 * __v_64; let __v_101: G = __v_63 + __v_100; let __v_102: G = __v_94 * __v_65; let __v_103: G = __v_101 + __v_102; let __v_104: G = __v_97 * __v_66; let __v_105: G = __v_103 + __v_104; let __v_106: G = __v_91 * __v_68; let __v_107: G = __v_67 + __v_106; let __v_108: G = __v_94 * __v_69; let __v_109: G = __v_107 + __v_108; let __v_110: G = __v_97 * __v_70; let __v_111: G = __v_109 + __v_110; let __v_112: G = __v_91 * __v_72; let __v_113: G = __v_71 + __v_112; let __v_114: G = __v_94 * __v_73; let __v_115: G = __v_113 + __v_114; let __v_116: G = __v_97 * __v_74; let __v_117: G = __v_115 + __v_116; let __v_118: G = __v_91 * __v_76; let __v_119: G = __v_75 + __v_118; let __v_120: G = __v_94 * __v_77; let __v_121: G = __v_119 + __v_120; let __v_122: G = __v_97 * __v_78; let __v_123: G = __v_121 + __v_122; let __v_124: G = __v_91 * __v_80; let __v_125: G = __v_79 + __v_124; let __v_126: G = __v_94 * __v_81; let __v_127: G = __v_125 + __v_126; let __v_128: G = __v_97 * __v_82; let __v_129: G = __v_127 + __v_128; let __v_130: G = __v_91 * __v_84; let __v_131: G = __v_83 + __v_130; let __v_132: G = __v_94 * __v_85; let __v_133: G = __v_131 + __v_132; let __v_134: G = __v_97 * __v_86; let __v_135: G = __v_133 + __v_134; let __v_136: G = __v_91 * __v_88; let __v_137: G = __v_87 + __v_136; let __v_138: G = __v_94 * __v_89; let __v_139: G = __v_137 + __v_138; let __v_140: G = __v_97 * __v_90; let __v_141: G = __v_139 + __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_90] = { let __args: [G; IN_90] = [__v_22]; 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_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_90] = { let __args: [G; IN_90] = [__v_151]; 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_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_90] = { let __args: [G; IN_90] = [__v_161]; 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_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_90] = { let __args: [G; IN_90] = [__v_171]; 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_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_90] = { let __args: [G; IN_90] = [__v_181]; 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_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_90] = { let __args: [G; IN_90] = [__v_191]; 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_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_90] = { let __args: [G; IN_90] = [__v_201]; 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_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_90] = { let __args: [G; IN_90] = [__v_211]; 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_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_103] = { let __args: [G; IN_103] = [__v_229, __v_220]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(103, &__args[..])?) { [G::ZERO; OUT_103] } else { let (__hash, __hit) = record.function_queries[103].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[103].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => { aiur_fn_103::(__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_104] = { let __args: [G; IN_104] = [__v_232]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(104, &__args[..])?) { [G::ZERO; OUT_104] } else { let (__hash, __hit) = record.function_queries[104].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[104].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[104].bump_multiplicity(__i); } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => { aiur_fn_104::(__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_105] = { let __args: [G; IN_105] = [__v_235, __v_220]; 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_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_254] = { let __args: [G; IN_254] = [__v_219, __v_238]; 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_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 = 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_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_248 + __v_280; let __v_282: G = __v_94 * __v_250; let __v_283: G = __v_281 + __v_282; let __v_284: G = __v_97 * __v_251; let __v_285: G = __v_283 + __v_284; let __v_286: G = __v_91 * __v_253; let __v_287: G = __v_252 + __v_286; let __v_288: G = __v_94 * __v_254; let __v_289: G = __v_287 + __v_288; let __v_290: G = __v_97 * __v_255; let __v_291: G = __v_289 + __v_290; let __v_292: G = __v_91 * __v_257; let __v_293: G = __v_256 + __v_292; let __v_294: G = __v_94 * __v_258; let __v_295: G = __v_293 + __v_294; let __v_296: G = __v_97 * __v_259; let __v_297: G = __v_295 + __v_296; let __v_298: G = __v_91 * __v_261; let __v_299: G = __v_260 + __v_298; let __v_300: G = __v_94 * __v_262; let __v_301: G = __v_299 + __v_300; let __v_302: G = __v_97 * __v_263; let __v_303: G = __v_301 + __v_302; let __v_304: G = __v_91 * __v_265; let __v_305: G = __v_264 + __v_304; let __v_306: G = __v_94 * __v_266; let __v_307: G = __v_305 + __v_306; let __v_308: G = __v_97 * __v_267; let __v_309: G = __v_307 + __v_308; let __v_310: G = __v_91 * __v_269; let __v_311: G = __v_268 + __v_310; let __v_312: G = __v_94 * __v_270; let __v_313: G = __v_311 + __v_312; let __v_314: G = __v_97 * __v_271; let __v_315: G = __v_313 + __v_314; let __v_316: G = __v_91 * __v_273; let __v_317: G = __v_272 + __v_316; let __v_318: G = __v_94 * __v_274; let __v_319: G = __v_317 + __v_318; let __v_320: G = __v_97 * __v_275; let __v_321: G = __v_319 + __v_320; let __v_322: G = __v_91 * __v_277; let __v_323: G = __v_276 + __v_322; let __v_324: G = __v_94 * __v_278; let __v_325: G = __v_323 + __v_324; let __v_326: G = __v_97 * __v_279; let __v_327: G = __v_325 + __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_238] = { let __args: [G; IN_238] = [__v_329, __v_328]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(238, &__args[..])?) { [G::ZERO; OUT_238] } else { let (__hash, __hit) = record.function_queries[238].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[238].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => { aiur_fn_238::(__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_235] = { let __args: [G; IN_235] = [__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(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_348: G = __r_arr[0]; let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_348, __v_330]; 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_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_241] = []; record.function_queries[241].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }) } -const INPUT_SIZE_242: usize = 2; -const IN_242: usize = 2; -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 __v_1: G = inp[1]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(256, &__args[..])?) { [G::ZERO; OUT_256] } else { let (__hash, __hit) = record.function_queries[256].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[256].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => { aiur_fn_256::(__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_242] = [__v_4]; record.function_queries[242].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); }, } }) } -const INPUT_SIZE_243: usize = 1; -const IN_243: usize = 1; -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 __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_243] = [__v_27]; record.function_queries[243].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_26]; 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_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_243] = [__v_29]; record.function_queries[243].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.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; 3] = { let __base = 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_244] = [__v_4]; 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_3]; 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_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_244] = [__v_6]; 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; 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_245] = [__v_5]; 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_4]; 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_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_245] = [__v_7]; 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 = 2; -const IN_246: usize = 2; -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 __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_246] = [__v_1]; record.function_queries[246].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_4, __v_1]; 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_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_246] = [__v_7]; record.function_queries[246].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.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; 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_247] = [__v_7]; 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_6]; 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_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_247] = [__v_9]; 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 = 1; -const IN_248: usize = 1; -const OUT_248: usize = 1; -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 __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_248] = [__v_8]; record.function_queries[248].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_7]; 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_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_248] = [__v_10]; record.function_queries[248].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.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; 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_249] = [__v_11]; record.function_queries[249].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_10]; 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_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_249] = [__v_13]; 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 = 1; -const IN_250: usize = 1; -const OUT_250: usize = 1; -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 __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_250] = [__v_12]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_11]; 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_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_250] = [__v_14]; record.function_queries[250].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_251: usize = 2; -const IN_251: usize = 2; -const OUT_251: usize = 4; -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 __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(258, &__args[..])?) { [G::ZERO; OUT_258] } else { let (__hash, __hit) = record.function_queries[258].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[258].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => { aiur_fn_258::(__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_251] = [__v_4, __v_5, __v_6, __v_7]; record.function_queries[251].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.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; 3] = { let __base = 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_252] = [__v_4]; record.function_queries[252].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_252] = [__v_4]; 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 = 2; -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]; let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_0, __v_1]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, &__args[..])?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => { aiur_fn_257::(__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_253] = [__v_4, __v_5]; record.function_queries[253].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_3.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]; 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_254] = [__v_1]; record.function_queries[254].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_11, __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_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_254] = [__v_14]; record.function_queries[254].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_255: usize = 1; -const IN_255: usize = 1; -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 __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_255] = [__v_6]; record.function_queries[255].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_5]; 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_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_255] = [__v_8]; record.function_queries[255].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -const INPUT_SIZE_256: usize = 2; -const IN_256: usize = 2; -const OUT_256: usize = 1; -fn aiur_fn_256(inp: [G; IN_256], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_256], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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_256] = [__v_0]; record.function_queries[256].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_256] = { let __args: [G; IN_256] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(256, &__args[..])?) { [G::ZERO; OUT_256] } else { let (__hash, __hit) = record.function_queries[256].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[256].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => { aiur_fn_256::(__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_256] = [__v_7]; record.function_queries[256].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_257: usize = 2; -const IN_257: usize = 2; -const OUT_257: usize = 1; -fn aiur_fn_257(inp: [G; IN_257], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_257], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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_257] = [__v_0]; record.function_queries[257].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_257] = { let __args: [G; IN_257] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(257, &__args[..])?) { [G::ZERO; OUT_257] } else { let (__hash, __hit) = record.function_queries[257].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[257].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => { aiur_fn_257::(__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_257] = [__v_8]; record.function_queries[257].finish_hashed(&inp[..], &__ret[..], !unconstrained, input_hash)?; return Ok(__ret); }, _ => { return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); }, } }, } }) } -const INPUT_SIZE_258: usize = 2; -const IN_258: usize = 2; -const OUT_258: usize = 1; -fn aiur_fn_258(inp: [G; IN_258], input_hash: u64, record: &mut QueryRecord, io_buffer: &mut IOBuffer,) -> Result<[G; OUT_258], ExecError> { stacker::maybe_grow(64 * 1024, (4 * 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_258] = [__v_0]; record.function_queries[258].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_258] = { let __args: [G; IN_258] = [__v_0, __v_3]; let __cu = unconstrained; if ((!unconstrained) && record.defer_call(258, &__args[..])?) { [G::ZERO; OUT_258] } else { let (__hash, __hit) = record.function_queries[258].lookup(&__args[..]); match __hit { Some(__i) if (__cu || (record.function_queries[258].mult_at(__i) != G::ZERO)) => { if (!unconstrained) { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => { aiur_fn_258::(__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_258] = [__v_10]; record.function_queries[258].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()); }, 256u64 => { let __inp: [G; IN_256] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_256::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 257u64 => { let __inp: [G; IN_257] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_257::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, 258u64 => { let __inp: [G; IN_258] = args.try_into().expect("input size mismatch"); let __out = aiur_fn_258::(__inp, __input_hash, record, io_buffer)?; return Ok(__out.to_vec()); }, _ => { return Err(ExecError::InvalidFunIdx(fun_idx)); }, } } diff --git a/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs b/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs deleted file mode 100644 index 56b8ca522..000000000 --- a/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs +++ /dev/null @@ -1,114 +0,0 @@ -//! MultiStark-native execute path. -//! -//! Parallel to `aiur::execute::Toplevel::execute`, but routes the -//! Aiur fn invocation through the codegen'd Rust recursive verifier -//! (`crate::aiur_multi_stark::execute_generated`) instead of the -//! interpreter. Mirror of `aiur_ixvm_runner` for the MultiStark -//! toplevel — same `QueryRecord` shape, same multiplicity rules, -//! same memory and IO side effects, so the trace produced here is -//! byte-for-byte identical to the interpreter's (modulo the -//! `execute_generated` codegen's correctness, which is the standing -//! parity invariant). -//! -//! Also home to `verifier_io_buffer`, the native builder for -//! `verify_multi_stark_proof`'s IO advice — replaces the Lean-side -//! `MultiStark.verifierInput` buffer construction, which boxed every -//! proof/vk/claims byte into a Lean `G` and marshalled the whole -//! buffer across FFI. - -use multi_stark::p3_field::PrimeCharacteristicRing; -use rustc_hash::FxHashMap; - -use crate::aiur_multi_stark::execute_generated; -use aiur::G; -use aiur::bytecode::{FunIdx, Toplevel}; -use aiur::execute::{ExecError, IOBuffer, IOKeyInfo, QueryRecord}; - -/// Append one keyed byte stream to an IO channel arena. -#[inline] -fn extend_bytes(io: &mut IOBuffer, channel: G, key: Vec, bytes: &[u8]) { - let arena = io.data.entry(channel).or_default(); - let idx = arena.len(); - let len = bytes.len(); - arena.extend(bytes.iter().map(|b| G::from_u8(*b))); - io.map.insert((channel, key), IOKeyInfo { idx, len }); -} - -/// An integer stream index (`[0]`, `[1]`, or `[2]`) as an Aiur IO key. -#[inline] -fn index_key(index: u8) -> Vec { - vec![G::from_u8(index)] -} - -/// Mirror of `Toplevel::execute` (same return shape, same -/// `entry`-flag gate), but routes execution through the codegen'd -/// Rust verifier. Deep recursion is handled via per-fn -/// `stacker::maybe_grow` checks in the generated code. -// `args: Vec` mirrors `Toplevel::execute`'s signature so this fn -// can be used as an `impl Fn(&Toplevel, _, Vec, _) -> _` in -// `AiurSystem::prove_ixvm` — a `&[G]` here would break that bound. -#[allow(clippy::needless_pass_by_value)] -pub fn execute_multi_stark( - toplevel: &Toplevel, - fun_idx: FunIdx, - args: Vec, - io_buffer: &mut IOBuffer, -) -> Result<(QueryRecord, Vec), ExecError> { - if !toplevel.functions[fun_idx].entry { - return Err(ExecError::NotEntryFunction(fun_idx)); - } - let mut record = QueryRecord::new(toplevel); - let output = execute_generated(fun_idx, &args, &mut record, io_buffer)?; - Ok((record, output)) -} - -/// Build `verify_multi_stark_proof`'s IO advice directly from the raw -/// byte blobs: channel 0 = proof, 1 = vk, 2 = claims, each registered -/// under key `[0]` on its channel (one stream per channel). Mirrors -/// the layout of `MultiStark.verifierInput` (`MultiStark.lean`). -pub fn verifier_io_buffer(proof: &[u8], vk: &[u8], claims: &[u8]) -> IOBuffer { - // Measurement hook: dump the raw advice blobs for offline analysis - // (vk encoding/activation studies) when IX_DUMP_RECURSION_IO is set - // to a directory. - if let Ok(dir) = std::env::var("IX_DUMP_RECURSION_IO") { - let _ = std::fs::write(format!("{dir}/proof.bin"), proof); - let _ = std::fs::write(format!("{dir}/vk.bin"), vk); - let _ = std::fs::write(format!("{dir}/claims.bin"), claims); - } - let mut io = - IOBuffer { data: FxHashMap::default(), map: FxHashMap::default() }; - for (channel, bytes) in [(0u8, proof), (1, vk), (2, claims)] { - extend_bytes(&mut io, G::from_u8(channel), index_key(0), bytes); - } - io -} - -#[cfg(test)] -mod tests { - use super::*; - use multi_stark::p3_field::PrimeField64; - - fn info(io: &IOBuffer, channel: u8, key: Vec) -> (usize, usize) { - let info = - io.map.get(&(G::from_u8(channel), key)).expect("missing IO mapping"); - (info.idx, info.len) - } - - fn arena_bytes(io: &IOBuffer, channel: u8) -> Vec { - io.data[&G::from_u8(channel)] - .iter() - .map(|g| u8::try_from(g.as_canonical_u64()).expect("IO test byte")) - .collect() - } - - #[test] - fn verifier_layout_remains_three_zero_keyed_channels() { - let io = verifier_io_buffer(&[1, 2], &[3], &[4, 5, 6]); - assert_eq!(info(&io, 0, index_key(0)), (0, 2)); - assert_eq!(info(&io, 1, index_key(0)), (0, 1)); - assert_eq!(info(&io, 2, index_key(0)), (0, 3)); - assert_eq!(arena_bytes(&io, 0), vec![1, 2]); - assert_eq!(arena_bytes(&io, 1), vec![3]); - assert_eq!(arena_bytes(&io, 2), vec![4, 5, 6]); - } -} diff --git a/crates/ixvm-codegen/src/env_handle.rs b/crates/ixvm-codegen/src/env_handle.rs deleted file mode 100644 index 8a5168dce..000000000 --- a/crates/ixvm-codegen/src/env_handle.rs +++ /dev/null @@ -1,35 +0,0 @@ -//! `EnvHandle`: a Rust-owned `ixon::Env` exposed to Lean as an opaque -//! external handle. -//! -//! Built once per CLI invocation from either a memory-mappable `.ixe` -//! path or a `Ixon.serEnv`-shaped byte blob. All downstream per-claim / -//! per-shard FFI calls take a `&EnvHandle` (shared across the batch) so -//! the env is parsed exactly once instead of every call. -//! -//! `anon_hints` (`Defn` reducibility hints) come from the `.ixe` §3 -//! hints section, which every writer emits straight from the -//! `Env::anon_hints` map — both readers used here populate the map -//! directly, so no post-decode harvest is needed. - -use ixon::Env; - -pub struct EnvHandle { - pub env: Env, -} - -impl EnvHandle { - /// Load via `Env::get_anon_mmap` (zero-copy mmap of the `.ixe` file). - pub fn from_ixe_path(path: &std::path::Path) -> Result { - let env = Env::get_anon_mmap(path)?; - Ok(Self { env }) - } - - /// Decode a serialized env blob (`Ixon.serEnv` output) via - /// `Env::get`. Used by the compiled-Lean-env path where the env is - /// built in Lean memory and serialized for the cross-FFI handoff. - pub fn from_bytes(bytes: &[u8]) -> Result { - let mut cursor: &[u8] = bytes; - let env = Env::get(&mut cursor)?; - Ok(Self { env }) - } -} diff --git a/crates/ixvm-codegen/src/lib.rs b/crates/ixvm-codegen/src/lib.rs deleted file mode 100644 index 476613e05..000000000 --- a/crates/ixvm-codegen/src/lib.rs +++ /dev/null @@ -1,13 +0,0 @@ -//! IxVM-specific Rust glue: codegen'd kernel + codegen'd MultiStark -//! recursive verifier, their native runners, witness builders. -//! Bridges the `aiur` proving framework with `ixon` / `ix-common` -//! content-addressed env types. - -pub mod aiur_ix_aggr; -pub mod aiur_ix_aggr_runner; -pub mod aiur_ixvm; -pub mod aiur_ixvm_runner; -pub mod aiur_ixvm_witness; -pub mod aiur_multi_stark; -pub mod aiur_multi_stark_runner; -pub mod env_handle; diff --git a/crates/ixvm/Cargo.toml b/crates/ixvm/Cargo.toml new file mode 100644 index 000000000..3040f893a --- /dev/null +++ b/crates/ixvm/Cargo.toml @@ -0,0 +1,35 @@ +[package] +name = "ixvm" +default-run = "ixvm" +version.workspace = true +edition.workspace = true +license.workspace = true +rust-version = "1.98" + +[dependencies] +aiur = { workspace = true } +multi-stark = { workspace = true } +serde = { version = "1", features = ["derive"] } +serde_json = { workspace = true } +blake3 = { workspace = true } + +[features] +default = [] +stark = ["aiur/stark"] +parallel = ["stark", "aiur/parallel"] +cuda = ["stark", "aiur/cuda"] +function-profile = ["aiur/function-profile"] +function-profile-ops = ["function-profile", "aiur/function-profile-ops"] + +[[example]] +name = "ixvm_bench" +required-features = ["stark"] + +[[example]] +name = "witness" +required-features = ["stark"] + +[[bin]] +name = "ixvm-proof" +path = "src/proof.rs" +required-features = ["stark"] diff --git a/crates/ixvm/examples/ixvm_bench.rs b/crates/ixvm/examples/ixvm_bench.rs new file mode 100644 index 000000000..9c4c7930e --- /dev/null +++ b/crates/ixvm/examples/ixvm_bench.rs @@ -0,0 +1,281 @@ +//! Bytecode-only IxVM with value hints and constrained recursive calls. +use aiur::field::FieldBackend; +use aiur::{ + Program, + hints::HintEntry, + trace::{ + TraceArtifact, TracePlan, + stark::{Backend, Parameters, Proof}, + }, +}; +use multi_stark::p3_matrix::Matrix; +use serde::Deserialize; +use serde_json::json; +use std::{error::Error, time::Instant}; + +#[path = "../../../tools/bench/profile.rs"] +mod profile; + +use ixvm as ixvm_hints; + +#[derive(Deserialize)] +struct Package { + program: Program, + trace: TraceArtifact, + hints: Vec, + address: Vec, +} +fn main() -> Result<(), Box> { + let cli: Vec<_> = std::env::args().collect(); + if cli.len() != 5 { + return Err( + "usage: ixvm_bench PACKAGE.json FIXTURE.json prove|execute|witness|functions SAMPLES" + .into(), + ); + } + let mode = &cli[3]; + let samples: usize = cli[4].parse()?; + if !["prove", "execute", "witness", "functions"].contains(&mode.as_str()) + || samples == 0 + { + return Err("invalid mode or sample count".into()); + } + let start = Instant::now(); + let package: Package = aiur::decode_artifact(&std::fs::read(&cli[1])?)?; + let fixture: serde_json::Value = + serde_json::from_slice(&std::fs::read(&cli[2])?)?; + let args: Vec = serde_json::from_value(fixture["address"].clone())?; + assert_eq!(args, package.address); + let program = package.program.check_field::()?; + let args = program.field().decode(&args)?; + let hints = ixvm_hints::prepare(&program, &package.hints)?; + let function_chips: Vec<_> = + package.trace.functions.iter().map(|f| f.chip.clone()).collect(); + let plan = TracePlan::new(&program, package.trace)?; + let entry = &program.program().entries[0].name; + let prepare_seconds = start.elapsed().as_secs_f64(); + let parameters = Parameters::default(); + let start = Instant::now(); + let backend = Backend::new(&plan, parameters)?; + let setup_seconds = start.elapsed().as_secs_f64(); + let profiler = profile::Profiler::from_env()?; + let mut times = vec![]; + if mode == "functions" { + #[cfg(not(feature = "function-profile"))] + return Err("functions mode requires --features function-profile".into()); + #[cfg(feature = "function-profile")] + { + use aiur::function_profile::FunctionProfiler; + let baseline = hints.execute(entry, args.clone())?; + let fingerprint = execution_fingerprint(&baseline); + drop(baseline); + let count = program.program().functions.len(); + let mut profiles = vec![]; + for sample in 0..samples + 2 { + let mut profile = FunctionProfiler::new(count); + let start = Instant::now(); + let record = + hints.execute_profiled(entry, args.clone(), &mut profile)?; + let seconds = start.elapsed().as_secs_f64(); + assert!(record.output.is_empty()); + assert!(profile.is_complete()); + if sample == 2 { + assert_eq!(execution_fingerprint(&record), fingerprint); + } + let mut queries = vec![0; count]; + for key in record.queries.keys().filter(|k| k.function < count) { + queries[key.function] += 1; + } + let functions: Vec<_> = profile + .functions + .iter() + .enumerate() + .map(|(id, t)| { + assert_eq!(t.calls - t.cache_hits, queries[id]); + json!({"id": id, "calls": t.calls, "cache_hits": t.cache_hits, + "queries": queries[id], "self_ns": t.self_ns, + "inclusive_ns": t.inclusive_ns, "cached_ns": t.cached_ns}) + }) + .collect(); + if sample >= 2 { + #[cfg(feature = "function-profile-ops")] + let operations = Some(&profile.operations); + #[cfg(not(feature = "function-profile-ops"))] + let operations: Option<()> = None; + profiles.push(json!({"seconds": seconds, "functions": functions, "operations": operations})); + } + } + let names: Vec<_> = + program.program().functions.iter().map(|f| &f.name).collect(); + println!( + "{}", + json!({"engine": "new-aiur-bytecode", "mode": mode, + "record_matches_unprofiled": true, "record_fingerprint": fingerprint, + "names": names, "profiles": profiles}) + ); + return Ok(()); + } + } + if mode == "execute" { + for sample in 0..samples + 2 { + let guard = if sample >= 2 { + profiler.as_ref().map(|p| p.start("execute", sample - 2)).transpose()? + } else { + None + }; + let start = Instant::now(); + let record = hints.execute(entry, args.clone())?; + let elapsed = start.elapsed().as_secs_f64(); + drop(guard); + assert!(record.output.is_empty()); + if sample >= 2 { + times.push(elapsed); + } + } + println!( + "{}", + json!({"engine": "new-aiur-bytecode", "mode": mode, "seconds": times, "output": Vec::::new()}) + ); + return Ok(()); + } + let start = Instant::now(); + let record = hints.execute(entry, args.clone())?; + let execution_seconds = start.elapsed().as_secs_f64(); + assert!(record.output.is_empty()); + let mut checked_scope = std::collections::BTreeMap::new(); + for (name, module) in [ + ("run_check_transitive", "KernelClaim"), + ("run_check", "KernelClaim"), + ("load_verified_constant", "Ingress"), + ("load_verified_blob", "Ingress"), + ] { + let mut addresses = std::collections::BTreeSet::new(); + let full_name = format!("{module}::{name}"); + let old_name = format!("IxVM::{name}"); + for (key, _) in record.queries.iter() { + let callable = program.callable_name(key.function); + if callable == Some(full_name.as_str()) + || callable == Some(old_name.as_str()) + { + let addr_ptr = *key.args.last().ok_or("missing address arg")?; + let cell = record + .memory + .get_by_width(32, program.field().to_u64(addr_ptr) as usize) + .ok_or("missing address cell")?; + assert_eq!(cell.cell.value.len(), 32); + addresses.insert( + cell + .cell + .value + .iter() + .map(|x| format!("{:02x}", program.field().to_u64(*x))) + .collect::(), + ); + } + } + checked_scope.insert(name, addresses); + } + let mut counted = vec![ + (0usize, 0u64); + program.program().functions.len() + + program.program().maps.len() + ]; + for (key, q) in record.queries.iter() { + counted[key.function].0 += 1; + counted[key.function].1 += q.multiplicity; + } + let mut function_counts = vec![]; + for (id, (queries, uses)) in counted.into_iter().enumerate() { + function_counts.push(json!({"id": id, "name": program.callable_name(id), "queries": queries, + "constrained_rows": queries, "uses": uses, "map": id >= program.program().functions.len()})); + } + let counts = json!({"queries": record.queries.len(), "function_queries": record.queries.keys().filter(|k| k.function < program.program().functions.len()).count(), "map_queries": record.queries.keys().filter(|k| k.function >= program.program().functions.len()).count(), "memory_queries": record.memory.len(), "instructions": record.instructions}); + let mut raw_rows = std::collections::HashMap::new(); + for key in record.queries.keys() { + if let Some(chip) = function_chips.get(key.function) { + *raw_rows.entry(chip.clone()).or_insert(0usize) += 1; + } + } + for cell in record.memory.iter() { + *raw_rows.entry(format!("", cell.cell.value.len())).or_insert(0) += + 1; + } + let mut last = None; + for sample in 0..if mode == "witness" { samples + 2 } else { 1 } { + let guard = if mode == "witness" && sample >= 2 { + profiler.as_ref().map(|p| p.start("witness", sample - 2)).transpose()? + } else { + None + }; + let start = Instant::now(); + let witness = backend.generate(&record, entry, &args)?; + let elapsed = start.elapsed().as_secs_f64(); + drop(guard); + if mode == "prove" || sample >= 2 { + times.push(elapsed); + } + last = Some(witness); + } + let witness = last.unwrap(); + let statistics = backend.statistics(); + let circuits: Vec<_> = statistics + .iter() + .zip(&witness.traces) + .map(|(s, t)| { + let mut value = serde_json::to_value(s).unwrap(); + value["height"] = json!(t.height()); + value["rows"] = json!(if s.preprocessed_height > 0 { + s.preprocessed_height + } else { + raw_rows.get(s.name.as_str()).copied().unwrap_or(0) + }); + value + }) + .collect(); + let stage1_words: usize = witness.traces.iter().map(|t| t.values.len()).sum(); + // Compare before/after implementations outside all measured intervals. + let record_fingerprint = execution_fingerprint(&record); + let trace_fingerprint = { + use std::hash::{Hash, Hasher}; + let mut hash = std::collections::hash_map::DefaultHasher::new(); + for trace in &witness.traces { + trace.width.hash(&mut hash); + trace.values.hash(&mut hash); + } + hash.finish() + }; + drop(record); + let start = Instant::now(); + let proof = backend.prove(entry, &args, &[], witness)?; + let prove_seconds = start.elapsed().as_secs_f64(); + let bytes = proof.to_bytes()?; + let proof = Proof::from_bytes(&bytes)?; + let start = Instant::now(); + backend.verify(entry, &args, &[], &proof)?; + let verify_seconds = start.elapsed().as_secs_f64(); + println!( + "{}", + json!({"engine": "new-aiur-bytecode", "mode": mode, "args": args, "output": Vec::::new(), + "prepare_seconds": prepare_seconds, "setup_seconds": setup_seconds, + "execution_seconds": execution_seconds, "witness_seconds": times[0], "seconds": times, + "prove_seconds": prove_seconds, "verify_seconds": verify_seconds, "proof_bytes": bytes.len(), + "counts": counts, "function_counts": function_counts, "checked_scope": checked_scope, "stage1_words": stage1_words, "circuits": circuits, "verified": true, + "record_fingerprint": record_fingerprint, "trace_fingerprint": trace_fingerprint}) + ); + Ok(()) +} + +fn execution_fingerprint(record: &aiur::Execution) -> u64 { + use std::hash::{Hash, Hasher}; + let mut hash = std::collections::hash_map::DefaultHasher::new(); + for (input, output) in record.queries.iter() { + input.function.hash(&mut hash); + input.args.hash(&mut hash); + output.output.hash(&mut hash); + output.multiplicity.hash(&mut hash); + } + serde_json::to_vec(&record.memory).unwrap().hash(&mut hash); + record.output.hash(&mut hash); + record.instructions.hash(&mut hash); + hash.finish() +} diff --git a/crates/ixvm/examples/witness.rs b/crates/ixvm/examples/witness.rs new file mode 100644 index 000000000..d75dedb47 --- /dev/null +++ b/crates/ixvm/examples/witness.rs @@ -0,0 +1,106 @@ +//! Repeated witness preparation over an immutable execution record. +//! CPU profiles exclude setup, execution, warmups, diagnostics and destruction. +use aiur::field::FieldBackend; +use aiur::{ + Program, + hints::HintEntry, + trace::{ + TraceArtifact, TracePlan, + stark::{Backend, Parameters}, + }, +}; +use serde::Deserialize; +use serde_json::json; +use std::{error::Error, time::Instant}; + +#[path = "../../../tools/bench/profile.rs"] +mod profile; + +use ixvm as ixvm_hints; + +#[derive(Deserialize)] +struct Package { + program: Program, + #[serde(default)] + hints: Vec, + #[serde(alias = "args")] + address: Vec, + trace: TraceArtifact, +} + +fn main() -> Result<(), Box> { + let args: Vec<_> = std::env::args().collect(); + let path = args.get(1).ok_or("usage: witness PACKAGE.json [SAMPLES]")?; + let samples = + args.get(2).map(|s| s.parse::()).transpose()?.unwrap_or(10); + if samples == 0 { + return Err("SAMPLES must be positive".into()); + } + let package: Package = aiur::decode_artifact(&std::fs::read(path)?)?; + let program = package.program.check_field::()?; + let address = program.field().decode(&package.address)?; + let hints = ixvm_hints::prepare(&program, &package.hints)?; + let plan = TracePlan::new(&program, package.trace)?; + let entry = &program.program().entries.first().ok_or("missing entry")?.name; + let backend = Backend::new(&plan, Parameters::default())?; + let record = hints.execute(entry, address.clone())?; + let compared_providers = + std::env::var_os("AIUR_CHECK_HINT_PROVIDERS").is_some(); + if compared_providers { + let data_record = + program.prepare_hints(&package.hints)?.execute(entry, address.clone())?; + assert_eq!(record.output, data_record.output); + assert_eq!(record.instructions, data_record.instructions); + assert_eq!(record.queries, data_record.queries); + assert_eq!( + serde_json::to_value(&record.memory)?, + serde_json::to_value(&data_record.memory)? + ); + } + let profiler = profile::Profiler::from_env()?; + let reference = std::env::var_os("AIUR_WITNESS_REFERENCE").is_some(); + let mut seconds = vec![]; + let mut last = None; + for sample in 0..samples + 2 { + let guard = if sample >= 2 { + profiler.as_ref().map(|p| p.start("witness", sample - 2)).transpose()? + } else { + None + }; + let start = Instant::now(); + let trace = if reference { + Some(plan.generate(&record, entry, &address, true)?) + } else { + None + }; + let witness = if let Some(trace) = &trace { + backend.witness(&record, trace)? + } else { + backend.generate(&record, entry, &address)? + }; + let elapsed = start.elapsed().as_secs_f64(); + drop(guard); + if sample >= 2 { + seconds.push(elapsed); + } + last = Some(witness); + } + let witness = last.unwrap(); + let trace = plan.generate_reference(&record, entry, &address, true)?; + plan.check(&record, &trace, entry, &address)?; + let expected = backend.witness(&record, &trace)?; + for (got, expected) in witness.traces.iter().zip(&expected.traces) { + if got.width != expected.width || got.values != expected.values { + return Err("fused witness differs from the reference trace".into()); + } + } + let words: usize = witness.traces.iter().map(|t| t.values.len()).sum(); + let proof = backend.prove(entry, &address, &record.output, witness)?; + backend.verify(entry, &address, &record.output, &proof)?; + println!( + "{}", + json!({"witness_seconds": seconds, "stage1_words": words, "verified": true, + "reference": reference, "compared_reference": true, "compared_providers": compared_providers}) + ); + Ok(()) +} diff --git a/crates/ixvm/src/io.rs b/crates/ixvm/src/io.rs new file mode 100644 index 000000000..41456a49d --- /dev/null +++ b/crates/ixvm/src/io.rs @@ -0,0 +1,79 @@ +//! The IxVM fixture stores constant and blob bytes at contiguous offsets. +//! Bind those rows to immutable field-element vectors once, without a per-byte +//! key hash. Metadata hints still use the ordinary address-keyed data provider. +use aiur::{ + bytecode::Type, + field::FieldBackend, + hints::{HintChannels, HintEntry}, +}; + +pub(super) const READ_CHANNEL: &str = "ixvm.io.read"; + +/// Returns false for sparse/other IO channels, retaining the ordinary data +/// provider. In particular, missing entries must not silently become zeroes. +/// Sorting avoids allocating an arena proportional to an unchecked offset. +pub(super) fn register( + field: B, + entries: &[HintEntry], + channels: &mut HintChannels, +) -> Result { + let key_type = Type::Tuple { items: vec![Type::Field; 2] }; + let mut rows = [vec![], vec![], vec![]]; + for entry in entries.iter().filter(|e| e.channel == READ_CHANNEL) { + if entry.key_type != key_type + || entry.r#type != Type::Field + || entry.key.len() != 2 + || entry.output.len() != 1 + { + return Err("invalid IO byte hint signature".into()); + } + if !entry.key.iter().chain(&entry.output).all(|&word| field.contains(word)) + { + return Err("noncanonical IO byte hint field element".into()); + } + let arena = match entry.key[0] { + 2 => 0, + 4 => 1, + 6 => 2, + _ => return Ok(false), + }; + rows[arena].push(entry); + } + let mut arenas = [vec![], vec![], vec![]]; + for (rows, arena) in rows.iter_mut().zip(&mut arenas) { + rows.sort_unstable_by_key(|entry| entry.key[1]); + for entry in rows { + let offset = entry.key[1]; + if offset > arena.len() as u64 { + return Ok(false); + } + let value = field.from_u64(entry.output[0]); + if offset == arena.len() as u64 { + arena.push(value); + } else if arena[offset as usize] != value { + return Err("conflicting IO byte hint entries".into()); + } + } + } + let [constants, blobs, roles] = arenas; + channels.insert( + READ_CHANNEL, + key_type, + Type::Field, + move |key, output| { + let arena = match field.to_u64(key[0]) { + 2 => &constants, + 4 => &blobs, + 6 => &roles, + _ => return Err("missing hint data: unknown IO channel".into()), + }; + let offset = usize::try_from(field.to_u64(key[1])) + .map_err(|_| "IO byte offset exceeds host index range")?; + output[0] = *arena + .get(offset) + .ok_or("missing hint data: IO byte offset out of bounds")?; + Ok(()) + }, + )?; + Ok(true) +} diff --git a/crates/ixvm/src/lib.rs b/crates/ixvm/src/lib.rs new file mode 100644 index 000000000..07e93bf49 --- /dev/null +++ b/crates/ixvm/src/lib.rs @@ -0,0 +1,82 @@ +//! IxVM-specific host advice. The Aiur runtime knows no scalar operations or +//! field-specific hint algorithms; these are supplied by the embedding program. +use aiur::{ + bytecode::CheckedProgram, + field::FieldBackend, + hints::{HintChannels, HintEntry, PreparedHints}, + maps::MapOverrides, +}; + +mod io; + +/// Prepare a production claim witness using immutable IO arenas. +pub fn prepare_streams<'a, B: FieldBackend>( + program: &'a CheckedProgram, + streams: &aiur::library::io::Streams, +) -> Result, String> { + use aiur::bytecode::Type; + let arenas = streams.prepare(program.field())?; + let mut channels = HintChannels::new(); + aiur::library::u32::register(&mut channels, program.field())?; + aiur::library::u64::register(&mut channels, program.field())?; + arenas.register_read::<1>(io::READ_CHANNEL, true, &mut channels)?; + let address = Type::Tuple { items: vec![Type::Field; 32] }; + let address_key = Type::Tuple { items: vec![Type::Field, address] }; + let mut data = arenas.metadata( + "ixvm.io.info", + address_key.clone(), + None, + |s| [1, 2, 4, 6].contains(&s.channel), + false, + )?; + data.extend(arenas.metadata( + "ixvm.io.claim", + Type::Tuple { items: vec![Type::Field; 8] }, + Some(0), + |s| s.channel == 0, + false, + )?); + data.extend(arenas.metadata( + "ixvm.io.tag", + address_key, + None, + |s| s.channel == 3, + true, + )?); + let hints = program.prepare_hint_channels(&data, &channels)?; + let mut maps = MapOverrides::new(); + aiur::library::u8::register_maps(program, &mut maps)?; + hints.with_map_overrides(&maps) +} + +pub fn prepare<'a, B: FieldBackend>( + program: &'a CheckedProgram, + entries: &[HintEntry], +) -> Result, String> { + let hints = if std::env::var_os("AIUR_IXVM_DATA_HINTS").is_some() { + program.prepare_hints(entries)? + } else { + let mut channels = HintChannels::new(); + aiur::library::u32::register(&mut channels, program.field())?; + aiur::library::u64::register(&mut channels, program.field())?; + // Metadata remains keyed by address. Dense byte arenas are captured by + // the bound read closure, shared by execution and witness replay. + let vector_io = std::env::var_os("AIUR_IXVM_DATA_IO").is_none() + && io::register(program.field(), entries, &mut channels)?; + let data: Vec<_> = entries + .iter() + .filter(|e| { + e.channel != "bytes_le" && !(vector_io && e.channel == io::READ_CHANNEL) + }) + .cloned() + .collect(); + program.prepare_hint_channels(&data, &channels)? + }; + let mut maps = MapOverrides::new(); + // Benchmark ablation: keep row-count recording, but use original tables + // for execution and population instead of native byte calculations. + if std::env::var_os("AIUR_IXVM_TABLE_MAPS").is_none() { + aiur::library::u8::register_maps(program, &mut maps)?; + } + hints.with_map_overrides(&maps) +} diff --git a/crates/ixvm/src/main.rs b/crates/ixvm/src/main.rs new file mode 100644 index 000000000..544d82218 --- /dev/null +++ b/crates/ixvm/src/main.rs @@ -0,0 +1,319 @@ +//! Run a Lean-produced IxVM execution package without transporting the full +//! query record back through JSON. Execution uses the same VM as the Lean FFI. +use aiur::{ + Program, + field::{FieldBackend, NativeField}, + hints::HintEntry, +}; +// The embedding chooses multi-stark's reference configuration; the VM is generic. +type HostField = NativeField; +type CheckedProgram = aiur::bytecode::CheckedProgram; +type Execution = aiur::execute::Execution; +use serde::Deserialize; +use std::{error::Error, time::Instant}; + +#[path = "../../../tools/bench/profile.rs"] +mod profile; + +use ixvm as ixvm_hints; + +#[derive(Deserialize)] +struct Package { + program: Program, + address: Vec, + hints: Vec, + #[serde(default)] + invalid_address: Vec, +} + +fn run( + program: &CheckedProgram, + name: &str, + args: Vec, + hints: &[HintEntry], +) -> Result> { + let args = program.field().decode(&args)?; + let start = Instant::now(); + let result = ixvm_hints::prepare(program, hints)?.execute(name, args)?; + let elapsed = start.elapsed(); + if !result.output.is_empty() { + return Err(format!("{name} returned a non-unit result").into()); + } + let uses: u64 = result.queries.values().map(|q| q.multiplicity).sum(); + println!( + "{name}: OK ({:.3}s, {} instructions, {} queries, {} query uses, {} ROM cells)", + elapsed.as_secs_f64(), + result.instructions, + result.queries.len(), + uses, + result.memory.len(), + ); + Ok(result) +} + +fn benchmark( + program: &CheckedProgram, + package: &Package, + samples: usize, +) -> Result<(), Box> { + if samples == 0 { + return Err("benchmark requires at least one sample".into()); + } + let start = Instant::now(); + let hints = ixvm_hints::prepare(program, &package.hints)?; + let preparation_seconds = start.elapsed().as_secs_f64(); + let profiler = profile::Profiler::from_env()?; + let mut times = Vec::with_capacity(samples); + let mut counts = None; + let address = program.field().decode(&package.address)?; + for i in 0..samples + 3 { + let args = address.clone(); + let profile = if i >= 3 { + profiler.as_ref().map(|p| p.start("new-aiur", i - 3)).transpose()? + } else { + None + }; + let start = Instant::now(); + let result = hints.execute("IxVM::verify_transitive", args)?; + let seconds = start.elapsed().as_secs_f64(); + drop(profile); + assert!(result.output.is_empty()); + let observed = ( + result.instructions, + result.queries.len(), + result + .queries + .keys() + .filter(|q| q.function < program.program().functions.len()) + .count(), + result.queries.values().map(|q| q.multiplicity).sum::(), + result.memory.len(), + ); + if let Some(expected) = counts { + assert_eq!(observed, expected, "fresh runs must do the same work"); + } + counts = Some(observed); + if i == 0 && std::env::var_os("AIUR_QUERY_STATS").is_some() { + let mut rows = vec![ + (0usize, 0u64); + program.program().functions.len() + + program.program().maps.len() + ]; + for (key, output) in result.queries.iter() { + rows[key.function].0 += 1; + rows[key.function].1 += output.multiplicity; + } + let mut rows: Vec<_> = rows.into_iter().enumerate().collect(); + rows.sort_by_key(|(_, (unique, _))| std::cmp::Reverse(*unique)); + for (id, (unique, uses)) in rows.into_iter().take(35) { + eprintln!( + "{unique:>8} queries {uses:>8} uses {}", + program.callable_name(id).unwrap() + ); + } + } + if i >= 3 { + times.push(seconds); + } + // Drop the returned query record outside the measured interval. + } + let (instructions, queries, function_queries, uses, memory) = counts.unwrap(); + println!( + "{}", + serde_json::json!({ + "engine": "new-aiur-bytecode", "warmups": 3, + "seconds": times, "hint_preparation_seconds": preparation_seconds, + "instructions": instructions, "queries": queries, "query_uses": uses, + "function_queries": function_queries, "map_queries": queries - function_queries, + "rom_cells": memory, + }) + ); + Ok(()) +} + +fn rejected( + program: &CheckedProgram, + label: &str, + args: Vec, + hints: &[HintEntry], + reason: &str, +) -> Result<(), Box> { + let args = program.field().decode(&args)?; + match ixvm_hints::prepare(program, hints)? + .execute("IxVM::verify_constant", args) + { + Ok(_) => Err(format!("accepted {label}").into()), + Err(e) if e.message.contains(reason) => { + println!("{label}: rejected ({e})"); + Ok(()) + }, + Err(e) => { + Err(format!("{label}: wrong rejection: {e}; expected {reason}").into()) + }, + } +} + +fn negatives( + program: &CheckedProgram, + package: &Package, +) -> Result<(), Box> { + let mut key = vec![2]; + key.extend(&package.address); + let info = package + .hints + .iter() + .position(|h| h.key == key && h.output.len() == 2) + .ok_or("fixture has no target stream")?; + let offset = package.hints[info].output[0]; + let byte = package + .hints + .iter() + .position(|h| h.key == [2, offset] && h.output.len() == 1) + .ok_or("fixture has no target byte")?; + let mut bad = package.hints.clone(); + bad[byte].output[0] ^= 1; + rejected( + program, + "corrupted serialization", + package.address.clone(), + &bad, + "hash of the supplied bytes", + )?; + + let mut bad = package.hints.clone(); + let mut digest = package.address.clone(); + digest[0] ^= 1; + bad[info].key[1..].copy_from_slice(&digest); + rejected( + program, + "wrong Blake3 address", + digest, + &bad, + "hash of the supplied bytes", + )?; + + let mut bad = package.hints.clone(); + bad.remove(byte); + rejected( + program, + "missing byte hint", + package.address.clone(), + &bad, + "missing hint", + )?; + if !package.invalid_address.is_empty() { + rejected( + program, + "correctly hashed invalid proof", + package.invalid_address.clone(), + &package.hints, + "inferred type is not def-eq", + )?; + } + Ok(()) +} + +fn main() -> Result<(), Box> { + let args: Vec<_> = std::env::args().collect(); + let path = args.get(1).ok_or( + "usage: ixvm PACKAGE.json [all|primitives|serde|constant|transitive|negative|bench [SAMPLES]|record OUTPUT.json]", + )?; + let mode = args.get(2).map(String::as_str).unwrap_or("all"); + let package: Package = serde_json::from_slice(&std::fs::read(path)?)?; + let program = + package.program.clone().check_field::()?; + if mode == "validate" { + let fixture: serde_json::Value = serde_json::from_slice(&std::fs::read( + args.get(3).ok_or("validate requires FIXTURE.json")?, + )?)?; + let hints = ixvm_hints::prepare(&program, &package.hints)?; + let mut cases = vec![]; + for name in [ + "verify_transitive", + "verify_constant", + "verify_serde", + "check_primitives", + "check_port_cases", + ] { + let input = if name.starts_with("check_") { + vec![] + } else { + package.address.clone() + }; + let result = hints + .execute(&format!("IxVM::{name}"), program.field().decode(&input)?); + cases.push(serde_json::json!({"entry": name, "accepted": result.is_ok(), "error": result.err().map(|e| e.to_string())})); + } + let mut serde_failures = vec![]; + for row in fixture["constants"].as_array().unwrap() { + let input: Vec = serde_json::from_value(row["address"].clone())?; + let input = program.field().decode(&input)?; + if let Err(error) = hints.execute("IxVM::verify_serde", input) { + serde_failures.push( + serde_json::json!({"address": row["address"], "error": error.to_string()}), + ); + } + } + let accepted = cases.iter().all(|case| case["accepted"] == true) + && serde_failures.is_empty(); + println!( + "{}", + serde_json::json!({"cases": cases, "serde_cases": fixture["constants"].as_array().unwrap().len(), "serde_failures": serde_failures}) + ); + if !accepted { + return Err("IxVM validation failed; see the case report".into()); + } + return Ok(()); + } + if mode == "record" { + let result = ixvm_hints::prepare(&program, &package.hints)?.execute( + "IxVM::verify_transitive", + program.field().decode(&package.address)?, + )?; + let mut queries: Vec<_> = result.queries.iter().collect(); + queries.sort_by_key(|(key, _)| *key); + let output = args.get(3).ok_or("record requires an output path")?; + let file = std::io::BufWriter::new(std::fs::File::create(output)?); + serde_json::to_writer( + file, + &serde_json::json!({ + "output": result.output, "queries": queries, + "memory": result.memory, "instructions": result.instructions, + }), + )?; + return Ok(()); + } + if mode == "bench" { + return benchmark( + &program, + &package, + args.get(3).map(|s| s.parse()).transpose()?.unwrap_or(20), + ); + } + let entries = [ + ("primitives", "IxVM::check_primitives"), + ("serde", "IxVM::verify_serde"), + ("constant", "IxVM::verify_constant"), + ("transitive", "IxVM::verify_transitive"), + ]; + if mode != "all" + && mode != "negative" + && !entries.iter().any(|(m, _)| *m == mode) + { + return Err(format!("unknown mode: {mode}").into()); + } + for (selected, entry) in entries { + if mode == "all" || mode == selected { + run( + &program, + entry, + if selected == "primitives" { vec![] } else { package.address.clone() }, + &package.hints, + )?; + } + } + if mode == "all" || mode == "negative" { + negatives(&program, &package)?; + } + Ok(()) +} diff --git a/crates/ixvm/src/proof.rs b/crates/ixvm/src/proof.rs new file mode 100644 index 000000000..5a77ef8f8 --- /dev/null +++ b/crates/ixvm/src/proof.rs @@ -0,0 +1,221 @@ +//! Production claim driver. The trusted artifact is separate from witness and +//! proof inputs. No legacy executor or generated kernels are linked here. +use aiur::{ + field::FieldBackend, + library::io::Invocation, + trace::{ + TraceArtifact, TracePlan, + stark::{Backend, BatchProof, Parameters, VerifyingKey, planning::Options}, + }, +}; +use multi_stark::{p3_field::PrimeField64, types::Val}; +use std::{error::Error, time::Instant}; + +const MAGIC: &[u8] = b"IXAIUR2\0"; +#[derive(serde::Deserialize)] +struct Package { + program: aiur::Program, + trace: Option, +} + +#[derive(serde::Deserialize)] +struct Case { + label: String, + accept: bool, + invocation: Invocation, +} + +fn main() -> Result<(), Box> { + let cli: Vec<_> = std::env::args().collect(); + if cli.get(1).is_some_and(|s| s == "resources") { + println!( + "{}", + serde_json::json!({"available_bytes":aiur::trace::stark::planning::available_memory(), + "cores":std::thread::available_parallelism().map_or(1, usize::from)}) + ); + return Ok(()); + } + if cli.len() < 4 { + return Err("usage: ixvm-proof execute|plan|prove|verify ARTIFACT INPUT [PROOF] [SHARD_ROWS] [RETENTION] [OPTIONS.json]".into()); + } + let mode = cli[1].as_str(); + if !["execute", "plan", "prove", "verify", "test", "key"].contains(&mode) { + return Err("unknown mode".into()); + } + let package: Package = aiur::decode_artifact(&std::fs::read(&cli[2])?)?; + let program = package.program.check_field::()?; + let artifact_resident = aiur::trace::stark::planning::resident_memory(); + if mode == "key" { + let plan = TracePlan::new( + &program, + package.trace.ok_or("artifact has no circuits")?, + )?; + let backend = + Backend::for_batch_verification(&plan, Parameters::default())?; + let key = backend.verifying_key_bytes()?; + let claim = backend.claim( + "IxVM::verify_claim", + &program.field().decode(&[0; 8])?, + &[], + )?; + let dir = std::path::Path::new(&cli[3]); + std::fs::create_dir_all(dir)?; + std::fs::write(dir.join("key.bin"), &key)?; + serde_json::to_writer( + std::fs::File::create(dir.join("identity.json"))?, + &serde_json::json!({"function_index":claim[1].as_canonical_u64(), + "call_channel":claim[0].as_canonical_u64(), "key_digest":blake3::hash(&key).to_hex().to_string()}), + )?; + return Ok(()); + } + if mode == "test" { + let cases: Vec = serde_json::from_slice(&std::fs::read(&cli[3])?)?; + for case in cases { + let args = program.field().decode(&case.invocation.args)?; + let result = ixvm::prepare_streams(&program, &case.invocation.streams)? + .execute(&case.invocation.entry, args); + if result.is_ok() != case.accept { + return Err( + format!("{}: unexpected result: {:?}", case.label, result.err()) + .into(), + ); + } + println!( + "{}: {}", + case.label, + if case.accept { "accepted" } else { "rejected" } + ); + } + return Ok(()); + } + let input: Invocation = serde_json::from_slice(&std::fs::read(&cli[3])?)?; + let args = program.field().decode(&input.args)?; + // A production claim has precisely eight public digest words and no result. + if input.entry != "IxVM::verify_claim" || args.len() != 8 { + return Err("expected IxVM::verify_claim and eight digest words".into()); + } + if mode == "execute" { + let start = Instant::now(); + let result = ixvm::prepare_streams(&program, &input.streams)? + .execute(&input.entry, args)?; + if !result.output.is_empty() { + return Err("claim verifier returned a value".into()); + } + println!( + "verified claim in {:.3}s ({} queries, {} instructions)", + start.elapsed().as_secs_f64(), + result.queries.len(), + result.instructions + ); + return Ok(()); + } + let path = cli.get(4).ok_or("missing proof path")?; + let options = Options::read(cli.get(7), cli.get(5), cli.get(6))?; + let before_setup = aiur::trace::stark::planning::resident_memory(); + let plan = + TracePlan::new(&program, package.trace.ok_or("artifact has no circuits")?)?; + let backend = if mode == "verify" { + Backend::for_batch_verification(&plan, Parameters::default())? + } else { + Backend::for_batch_on_device(&plan, Parameters::default(), options.device)? + }; + if mode == "verify" { + let bytes = std::fs::read(path)?; + let bytes = bytes.strip_prefix(MAGIC).ok_or("not a formal Aiur proof")?; + let proof = BatchProof::from_bytes(bytes)?; + if proof.to_bytes()? != bytes { + return Err("noncanonical or trailing proof bytes".into()); + } + backend.verify_batch(&input.entry, &args, &[], &proof)?; + println!( + "verified formal Aiur proof ({} trace shards)", + proof.proofs.len() + ); + return Ok(()); + } + let static_resident = artifact_resident.saturating_add( + aiur::trace::stark::planning::resident_memory() + .saturating_sub(before_setup), + ); + let fixed = backend.plan_fixed(&options, static_resident)?; + if !fixed.fits { + let report = serde_json::json!({"plan":fixed, "can_split":false, "verified":false, + "error":"budget is below the estimated artifact and fixed-table floor"}); + std::fs::write( + format!("{path}.report.json"), + serde_json::to_vec_pretty(&report)?, + )?; + println!("{report}"); + if mode == "plan" { + return Ok(()); + } + std::process::exit(75); + } + let hints = ixvm::prepare_streams(&program, &input.streams)?; + drop(input.streams); + let start = Instant::now(); + let record = hints.execute(&input.entry, args.clone())?; + let execute = start.elapsed().as_secs_f64(); + if !record.output.is_empty() { + return Err("claim verifier returned a value".into()); + } + let batch = backend.plan_batch(&record, &options)?; + let mut report = serde_json::json!({"plan":batch, "execution_seconds":execute, + "queries":record.queries.len(), "instructions":record.instructions, + "circuits":backend.statistics(), "verified":false}); + let report_path = format!("{path}.report.json"); + std::fs::write(&report_path, serde_json::to_vec_pretty(&report)?)?; + if mode == "plan" { + report.as_object_mut().unwrap().remove("circuits"); + println!("{}", report); + return Ok(()); + } + if !batch.fits { + eprintln!("proving estimate exceeds budget; see {report_path}"); + std::process::exit(75); + } + let start = Instant::now(); + let witness = backend.prepare_stage_1(&record, &input.entry, &args)?; + if witness.cells() != batch.stage1_cells { + return Err("generated trace differs from the resource plan".into()); + } + let trace = start.elapsed().as_secs_f64(); + drop(record); + drop(hints); + let start = Instant::now(); + let proof = backend.prove_stage_one( + &input.entry, + &args, + &[], + witness, + batch.max_rows, + batch.retention(), + )?; + let proving = start.elapsed().as_secs_f64(); + let raw = proof.to_bytes()?; + let mut bytes = MAGIC.to_vec(); + bytes.extend(&raw); + let key = backend.verifying_key_bytes()?; + let claim = backend.claim(&input.entry, &args, &[])?; + VerifyingKey::from_bytes(&key)? + .verify(std::slice::from_ref(&claim), &proof)?; + std::fs::write(path, bytes)?; + // Sidecars make the proof immediately consumable by the recursive verifier. + std::fs::write(format!("{path}.vk"), &key)?; + let mut claims = 1u64.to_le_bytes().to_vec(); + claims.extend_from_slice(&(claim.len() as u64).to_le_bytes()); + for v in claim { + claims.extend_from_slice(&v.as_canonical_u64().to_le_bytes()); + } + std::fs::write(format!("{path}.claims"), claims)?; + report["verified"] = true.into(); + report["trace_seconds"] = trace.into(); + report["proving_seconds"] = proving.into(); + report["shards"] = proof.proofs.len().into(); + report["proof_bytes"] = raw.len().into(); + report["key_digest"] = blake3::hash(&key).to_hex().to_string().into(); + std::fs::write(report_path, serde_json::to_vec_pretty(&report)?)?; + report.as_object_mut().unwrap().remove("circuits"); + println!("{}", report); + Ok(()) +} diff --git a/crates/ixvm/tests/io.rs b/crates/ixvm/tests/io.rs new file mode 100644 index 000000000..8816bafeb --- /dev/null +++ b/crates/ixvm/tests/io.rs @@ -0,0 +1,154 @@ +//! Exercise the embedding's vector-backed IO through the public hint API. +use aiur::{ + bytecode::{Entry, Function, Instruction, Program, Type, VERSION}, + field::{FieldBackend, NativeField, PrimeField}, + hints::{HintChannels, HintEntry}, + value::IoType, +}; + +#[path = "../src/io.rs"] +mod io; + +fn row(channel: u64, offset: u64, value: u64) -> HintEntry { + HintEntry { + channel: io::READ_CHANNEL.into(), + key_type: Type::Tuple { items: vec![Type::Field; 2] }, + r#type: Type::Field, + key: vec![channel, offset], + output: vec![value], + } +} + +fn program(modulus: u64) -> Program { + Program { + version: VERSION, + modulus, + enums: vec![], + tables: vec![], + maps: vec![], + functions: vec![Function { + name: "read".into(), + params: vec![Type::Field; 2], + result: Type::Field, + registers: 3, + code: vec![ + Instruction::Hint { + channel: io::READ_CHANNEL.into(), + key_type: row(2, 0, 0).key_type, + r#type: Type::Field, + key: vec![0, 1], + dest: vec![2], + }, + Instruction::Ret { value: vec![2] }, + ], + }], + entries: vec![Entry { + name: "read".into(), + function: 0, + inputs: vec![IoType::Field; 2], + output: Some(IoType::Field), + }], + } +} + +fn dense_matches_data(field: B) { + let p = program(field.modulus()).check_with(field).unwrap(); + // Unsorted input, overlapping offsets across channels, an identical + // duplicate and a zero byte must all retain the original data semantics. + let rows = vec![ + row(4, 1, 19), + row(2, 1, 31), + row(4, 0, 0), + row(2, 0, 27), + row(2, 1, 31), + ]; + let mut channels = HintChannels::new(); + assert!(io::register(field, &rows, &mut channels).unwrap()); + let code = p.prepare_hint_channels(&[], &channels).unwrap(); + let data = p.prepare_hints(&rows).unwrap(); + for key in [[2, 1], [4, 0], [2, 0], [4, 1], [2, 1]] { + let args = field.decode(&key).unwrap(); + let actual = code.execute("read", args.clone()).unwrap(); + let expected = data.execute("read", args).unwrap(); + assert_eq!(actual.output, expected.output); + assert_eq!(actual.queries, expected.queries); + assert_eq!(actual.instructions, expected.instructions); + } + for key in [[2, 2], [4, 2], [3, 0], [2, field.modulus() - 1]] { + let args = field.decode(&key).unwrap(); + assert!( + code + .execute("read", args.clone()) + .unwrap_err() + .message + .contains("missing hint") + ); + assert!(data.execute("read", args).is_err()); + } +} + +#[test] +fn dense_vectors_match_maps_with_native_and_runtime_fields() { + dense_matches_data(NativeField::::new()); + dense_matches_data(PrimeField::new(97).unwrap()); +} + +#[test] +fn sparse_or_other_channels_keep_data_fallback() { + let field = PrimeField::new(97).unwrap(); + let p = program(field.modulus()).check_with(field).unwrap(); + for rows in [ + vec![row(2, 0, 11), row(2, 2, 13)], + vec![row(3, 0, 17)], + vec![row(2, 96, 21)], + ] { + let mut channels = HintChannels::new(); + assert!(!io::register(field, &rows, &mut channels).unwrap()); + let prepared = p.prepare_hint_channels(&rows, &channels).unwrap(); + for entry in &rows { + assert_eq!( + prepared.execute("read", entry.key.clone()).unwrap().output, + entry.output + ); + } + assert!( + prepared + .execute("read", vec![2, 1]) + .unwrap_err() + .message + .contains("missing hint") + ); + } +} + +#[test] +fn malformed_or_conflicting_dense_data_is_rejected() { + let field = PrimeField::new(97).unwrap(); + let mut wrong_type = row(2, 0, 1); + wrong_type.r#type = Type::Tuple { items: vec![Type::Field] }; + let mut wrong_width = row(2, 0, 1); + wrong_width.key.pop(); + for rows in [ + vec![row(2, 0, 97)], + vec![row(2, 97, 1)], + vec![row(2, 0, 1), row(2, 0, 2)], + vec![wrong_type], + vec![wrong_width], + ] { + assert!(io::register(field, &rows, &mut HintChannels::new()).is_err()); + } +} + +#[test] +fn byte_range_still_belongs_to_aiur_constraints() { + let field = NativeField::::new(); + let p = program(field.modulus()).check_with(field).unwrap(); + let mut channels = HintChannels::new(); + // The hint has type Field, not opaque U8. Its consumer must still perform + // UInt8::from_field, just as with the original data-backed hints. + assert!(io::register(field, &[row(2, 0, 256)], &mut channels).unwrap()); + let prepared = p.prepare_hint_channels(&[], &channels).unwrap(); + let result = + prepared.execute("read", field.decode(&[2, 0]).unwrap()).unwrap(); + assert_eq!(result.output, field.decode(&[256]).unwrap()); +} diff --git a/crates/proof-compression/Cargo.toml b/crates/proof-compression/Cargo.toml index 09188255d..d404f7f09 100644 --- a/crates/proof-compression/Cargo.toml +++ b/crates/proof-compression/Cargo.toml @@ -6,8 +6,9 @@ license.workspace = true publish = false [dependencies] -aiur = { workspace = true } +aiur = { path = "../aiur", default-features = false, features = ["stark"] } multi-stark = { workspace = true } +stark-key = { path = "../stark-key" } ark-bn254 = { version = "0.5", features = ["curve"] } ark-ec = "0.5" ark-ff = { version = "0.5", features = ["asm"] } diff --git a/crates/proof-compression/src/pipeline/compress.rs b/crates/proof-compression/src/pipeline/compress.rs index b6dba0ca9..54065e075 100644 --- a/crates/proof-compression/src/pipeline/compress.rs +++ b/crates/proof-compression/src/pipeline/compress.rs @@ -484,7 +484,7 @@ fn check_fri( } let layout = root.join(root::FIXED_ROOT_LAYOUT); if layout.is_file() { - let key = aiur::vk_codec::AiurVerifyingKey::from_bytes(&fs::read( + let key = aiur::trace::stark::VerifyingKey::from_bytes(&fs::read( root.join("root-vk.bin"), )?)?; let fixed = FixedRoot::from_json(&fs::read_to_string(layout)?)?; diff --git a/crates/proof-compression/src/pipeline/derive.rs b/crates/proof-compression/src/pipeline/derive.rs index 8a1a08365..d2f7df0e1 100644 --- a/crates/proof-compression/src/pipeline/derive.rs +++ b/crates/proof-compression/src/pipeline/derive.rs @@ -16,7 +16,7 @@ pub fn derive_recursive_vk( setup: &SetupConfig, ) -> Result> { let fri = { - let key = aiur::vk_codec::AiurVerifyingKey::from_bytes(root_vk)?; + let key = aiur::trace::stark::VerifyingKey::from_bytes(root_vk)?; root::verifier(&key, &FixedRoot::from_json(layout)?)? }; let (manifest, parts, _) = diff --git a/crates/proof-compression/src/pipeline/prepare.rs b/crates/proof-compression/src/pipeline/prepare.rs index b98128191..935a3bd5a 100644 --- a/crates/proof-compression/src/pipeline/prepare.rs +++ b/crates/proof-compression/src/pipeline/prepare.rs @@ -125,7 +125,7 @@ fn prepare_first( return Ok((None, Prepared::Present { bytes }, cache)); } let fri = { - let key = aiur::vk_codec::AiurVerifyingKey::from_bytes(root_vk)?; + let key = aiur::trace::stark::VerifyingKey::from_bytes(root_vk)?; let layout = verifying_keys::release_root_layout(root_vk)?; root::verifier(&key, &FixedRoot::from_json(layout)?)? }; diff --git a/crates/proof-compression/src/pipeline/root.rs b/crates/proof-compression/src/pipeline/root.rs index 82058730f..d611195e3 100644 --- a/crates/proof-compression/src/pipeline/root.rs +++ b/crates/proof-compression/src/pipeline/root.rs @@ -10,7 +10,9 @@ use super::{ stage::{FriVerifier, Prepared}, }; use crate::fri::*; -use aiur::{synthesis::AiurProof, vk_codec::AiurVerifyingKey}; +use aiur::trace::stark::{ + BatchProof as AiurProof, VerifyingKey as AiurVerifyingKey, +}; use multi_stark::batch::BatchProof; use multi_stark::plonkish::CircuitBuilder; use multi_stark::types::GoldilocksBlake3Config; @@ -66,7 +68,7 @@ pub(super) fn run(dir: &Path, out: &Path, prove: bool) -> Result<()> { drop(input_span); let start = Instant::now(); tracing::info_span!("compression/verify_input") - .in_scope(|| native_key.verify(&claims[0], &proof)) + .in_scope(|| native_key.verify(&claims, &proof)) .map_err(|e| format!("Aiur policy: {e:?}"))?; eprintln!( "Native Ix root batch verified in {:?}: {} bytes, {} circuits, {} shards", @@ -191,7 +193,9 @@ pub fn prepare_root( expected: &[Val], limits: VerifierLimits, ) -> Result> { - key.verify(expected, proof).map_err(|e| format!("aggregate root: {e:?}"))?; + key + .verify(&[expected.to_vec()], proof) + .map_err(|e| format!("aggregate root: {e:?}"))?; let verifier = VerifierKey::from_system(key.system()); RootPlan::new(&verifier, proof, limits)?.prepare( proof, diff --git a/crates/proof-compression/src/pipeline/root/fixed.rs b/crates/proof-compression/src/pipeline/root/fixed.rs index 1aa565a9e..c2bc0ff88 100644 --- a/crates/proof-compression/src/pipeline/root/fixed.rs +++ b/crates/proof-compression/src/pipeline/root/fixed.rs @@ -2,7 +2,10 @@ //! Only the claim, proof and memory interval ends vary between invocations. use super::{Prepared, Result}; use crate::fri::*; -use aiur::{synthesis::AiurProof, vk_codec::AiurVerifyingKey}; +use aiur::trace::stark::{ + BatchProof as AiurProof, MEMSEG, VerifyingKey as AiurVerifyingKey, + batch::memseg_args, +}; use multi_stark::{ batch::{BatchMessage, BatchPreamble, ShardHeader}, plonkish::{Circuit, CircuitBuilder, Value}, @@ -121,13 +124,8 @@ impl FixedRoot { } let mut messages = vec![]; for (&(width, _), &end) in self.memory_traces.iter().zip(ends) { - messages.push(BatchMessage::pull( - aiur::memory::Memory::memseg_args(Val::from_usize(width), Val::ZERO) - .to_vec(), - )); - messages.push(BatchMessage::push( - aiur::memory::Memory::memseg_args(Val::from_usize(width), end).to_vec(), - )); + messages.push(BatchMessage::pull(memseg_args(width, Val::ZERO).to_vec())); + messages.push(BatchMessage::push(memseg_args(width, end).to_vec())); } Ok(BatchPreamble { headers: vec![ShardHeader { @@ -205,7 +203,7 @@ impl FixedRoot { b.assert_equal(value, end); let overflow = b.mul(low, top); b.assert_zero(overflow); - let channel = b.constant(aiur::shard::memseg_channel_value()); + let channel = b.constant(Val::from_u64(MEMSEG)); let width = b.constant(Val::from_usize(width)); let zero = b.constant(Val::ZERO); let minus = b.constant(Val::NEG_ONE); @@ -252,7 +250,7 @@ impl FixedRoot { limits: VerifierLimits, ) -> Result> { key - .verify(expected, proof) + .verify(&[expected.to_vec()], proof) .map_err(|e| format!("normalized root: {e:?}"))?; if expected.len() != self.claim_len || proof.preamble.headers.len() != 1 @@ -324,7 +322,31 @@ mod tests { #[test] fn normalized_aiur_execution_matches_the_fixed_verifier() -> Result<()> { - use aiur::{bytecode::*, execute::IOBuffer, synthesis::AiurSystem}; + use aiur::{ + Program, + trace::{ + TraceArtifact, TracePlan, + stark::{Backend, Parameters}, + }, + }; + #[derive(serde::Deserialize)] + struct Package { + program: Program, + trace: TraceArtifact, + } + let mut package: Package = serde_json::from_str(include_str!( + "../../../../aiur/tests/fixtures/grouping.json" + ))?; + package.program.maps = serde_json::from_value(serde_json::json!([ + {"name":"id","params":[{"kind":"field"}],"result":{"kind":"tuple","items":[{"kind":"field"}]},"input":0,"output":0} + ]))?; + package.program.tables = serde_json::from_value(serde_json::json!([ + {"name":"xs","type":{"kind":"tuple","items":[{"kind":"field"}]},"rows":[[0],[1],[2],[3]]} + ]))?; + let program = package.program.check_field::()?; + let plan = TracePlan::new(&program, package.trace)?; + let params = Parameters { log_blowup: 2, num_queries: 2 }; + let backend = Backend::for_batch(&plan, params)?; let cp = CommitmentParameters { log_blowup: 2, cap_height: 0 }; let fp = FriParameters { log_final_poly_len: 0, @@ -333,38 +355,16 @@ mod tests { commit_proof_of_work_bits: 0, query_proof_of_work_bits: 0, }; - let layout = FunctionLayout { - input_size: 2, - selectors: 1, - auxiliaries: 2, - lookups: 1, - }; - let top = Toplevel { - functions: vec![Function { - body: Block { - ops: vec![Op::Mul(0, 1)], - ctrl: Ctrl::Return(0, vec![2]), - }, - layout, - entry: true, - constrained: true, - }], - memory_sizes: vec![1], - circuits: vec![Circuit { members: vec![0], layout }], - }; - let system = AiurSystem::build(top, cp, fp); - let key = AiurVerifyingKey::from_bytes( - &aiur::vk_codec::aiur_system_to_bytes(&system)?, - )?; - let fixed = FixedRoot::new(vec![4, 1, 8, 16], vec![(1, 1)], 5)?; - for logs in [vec![4, 1, 8], vec![4, 1, 8, 15]] { - let invalid = FixedRoot::new(logs, vec![(1, 1)], 5)?; + let key = AiurVerifyingKey::from_bytes(&backend.verifying_key_bytes()?)?; + let fixed = FixedRoot::new(vec![4, 4, 2, 1], vec![(2, 3)], 4)?; + for logs in [vec![4, 4, 2, 1, 1], vec![4, 4, 3, 1]] { + let invalid = FixedRoot::new(logs, vec![(2, 3)], 4)?; assert!(invalid.circuit(&key, Default::default()).is_err()); } - for memories in [vec![(1, 4)], vec![(1, 1), (2, 1)], vec![(2, 1), (1, 0)]] { - assert!(FixedRoot::new(vec![4, 1, 8, 16], memories, 5).is_err()); + for memories in [vec![(2, 4)], vec![(1, 3), (2, 3)], vec![(2, 3), (1, 0)]] { + assert!(FixedRoot::new(vec![4, 4, 2, 1], memories, 4).is_err()); } - assert_eq!(system.memory_circuits(), fixed.memory_traces()); + assert_eq!(backend.memory_circuits(), fixed.memory_traces()); assert_eq!( FixedRoot::from_json(&fixed.to_json())?.to_json(), fixed.to_json() @@ -372,7 +372,7 @@ mod tests { assert!( FixedRoot::from_json(&fixed.to_json().replace("-v1", "-v0")).is_err() ); - let other = FixedRoot::new(vec![4, 2, 8, 16], vec![(1, 1)], 5)?; + let other = FixedRoot::new(vec![4, 4, 2, 2], vec![(2, 3)], 4)?; assert_ne!(fixed.identity(&key), other.identity(&key)); let config = || GoldilocksBlake3Config::new(cp, fp); let local = FriVerifier::derive( @@ -381,22 +381,19 @@ mod tests { 1 << 16, )?; for value in [3, 7] { - let input = vec![Val::from_u32(value), Val::TWO]; - let mut io = - IOBuffer { data: Default::default(), map: Default::default() }; - let (record, output) = - system.toplevel().execute(0, input.clone(), &mut io)?; + let input = vec![Val::from_u32(value)]; + let record = program.execute("Grouped::run", input.clone())?; let logs = - system.normalized_log_heights(&system.execution_rows(&record), 0)?; - assert_eq!(&logs[2..], &[8, 16]); + backend.normalized_log_heights(&backend.execution_rows(&record), 0)?; + assert_eq!(logs[2], 2); assert!(logs.iter().zip(fixed.log_heights()).all(|(a, b)| a <= b)); - let (claim, proof) = system.prove_from_execution_normalized( - 0, + let output = record.output.clone(); + let (claim, proof) = backend.prove_normalized( + "Grouped::run", &input, - &io, - record, &output, - &[4, 1, 8, 16], + record, + &[4, 4, 2, 1], )?; assert!(other.prepare(&key, &proof, &claim, Default::default()).is_err()); let prepared = fixed.prepare(&key, &proof, &claim, Default::default())?; @@ -417,7 +414,7 @@ mod tests { commit_proof_of_work_bits: 0, query_proof_of_work_bits: 0, }; - let channel = aiur::shard::memseg_channel_value(); + let channel = Val::from_u64(MEMSEG); let (system, pk) = System::new( GoldilocksBlake3Config::new(cp, fp), [(8, 8), (1, 2)].into_iter().map(|(width, height)| CircuitInputs { @@ -445,7 +442,7 @@ mod tests { }), ); let key = - AiurVerifyingKey::from_bytes(&aiur::vk_codec::to_bytes(&system, cp, fp))?; + AiurVerifyingKey::from_bytes(&stark_key::to_bytes(&system, cp, fp))?; let fixed = FixedRoot::new(vec![3, 1], vec![(1, 1), (8, 0)], 2)?; let config = || { GoldilocksBlake3Config::new( @@ -498,7 +495,7 @@ mod tests { }], messages, ); - key.verify(&expected, &proof).unwrap(); + key.verify(std::slice::from_ref(&expected), &proof).unwrap(); if small_end <= 2 && large_end <= 8 { let stage = fixed.prepare(&key, &proof, &expected, Default::default())?; diff --git a/crates/proof-compression/tests/integration/pipeline_root.rs b/crates/proof-compression/tests/integration/pipeline_root.rs index 0db6f36df..11071ceb2 100644 --- a/crates/proof-compression/tests/integration/pipeline_root.rs +++ b/crates/proof-compression/tests/integration/pipeline_root.rs @@ -1,5 +1,7 @@ //! Generated aggregate-shaped statements, including multi-shard Aiur batches. -use aiur::vk_codec::{AiurVerifyingKey, to_bytes}; +use aiur::trace::stark::{ + BatchProof as AiurProof, VerifyingKey as AiurVerifyingKey, +}; use ix_proof_compression::kzg::Srs; use ix_proof_compression::pipeline::{ FixedRoot, FriVerifier, KzgVerifier, RecursiveVerifier, prepare_kzg, @@ -14,6 +16,7 @@ use multi_stark::types::{ }; use p3_field::PrimeCharacteristicRing; use p3_matrix::dense::RowMajorMatrix; +use stark_key::to_bytes; use std::sync::Arc; fn root_system() -> ( @@ -239,7 +242,7 @@ fn shared_batch_root_preserves_single_batch_verifier_and_proof_bytes() fn check_root_directory( key: &[u8], - proof: &aiur::synthesis::AiurProof, + proof: &AiurProof, expected: &[Val], shards: usize, stats: multi_stark::plonkish::CircuitStats, diff --git a/crates/record-pool/Cargo.toml b/crates/record-pool/Cargo.toml new file mode 100644 index 000000000..9ea9b2cb5 --- /dev/null +++ b/crates/record-pool/Cargo.toml @@ -0,0 +1,5 @@ +[package] +name = "record-pool" +version.workspace = true +edition.workspace = true +license.workspace = true diff --git a/crates/aiur/src/record_pool.rs b/crates/record-pool/src/lib.rs similarity index 97% rename from crates/aiur/src/record_pool.rs rename to crates/record-pool/src/lib.rs index 3159adbb4..f6a00c3bd 100644 --- a/crates/aiur/src/record_pool.rs +++ b/crates/record-pool/src/lib.rs @@ -1,4 +1,5 @@ //! Shared capacity for execution records, retained until their storage drops. +pub mod queue; use std::collections::{BTreeMap, VecDeque}; use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; @@ -14,6 +15,21 @@ pub enum BudgetError { Shutdown, } +impl std::fmt::Display for BudgetError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::Exceeded { bytes, cap } => { + write!(f, "record needs {bytes} bytes, limit is {cap}") + }, + Self::Cancelled => { + f.write_str("record execution cancelled for memory contention") + }, + Self::Shutdown => f.write_str("record pool shut down"), + } + } +} +impl std::error::Error for BudgetError {} + #[derive(Clone, Copy, Debug)] pub struct ProverBudget { pub trace_cells: usize, diff --git a/crates/ffi/src/aiur/aggregate/multi_gpu/queue.rs b/crates/record-pool/src/queue.rs similarity index 67% rename from crates/ffi/src/aiur/aggregate/multi_gpu/queue.rs rename to crates/record-pool/src/queue.rs index 4f8b3eb89..2f0269829 100644 --- a/crates/ffi/src/aiur/aggregate/multi_gpu/queue.rs +++ b/crates/record-pool/src/queue.rs @@ -8,14 +8,14 @@ struct State { } /// Bounded ownership transfer with ready joins ahead of claims. -pub(super) struct WorkQueue { +pub struct WorkQueue { capacity: usize, state: Mutex>, changed: Condvar, } impl WorkQueue { - pub(super) fn new(capacity: usize) -> Self { + pub fn new(capacity: usize) -> Self { assert!(capacity > 0); Self { capacity, @@ -28,7 +28,7 @@ impl WorkQueue { } } - pub(super) fn push(&self, item: T, priority: bool) -> Result<(), T> { + pub 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 @@ -47,14 +47,28 @@ impl WorkQueue { Ok(()) } - pub(super) fn pop(&self) -> Option { + pub fn pop(&self) -> Option { + self.pop_matching(|_| true) + } + + pub fn pop_matching(&self, mut accept: impl FnMut(&T) -> bool) -> 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()) + if let Some(item) = state + .priority + .iter() + .position(&mut accept) + .and_then(|i| state.priority.remove(i)) + .or_else(|| { + state + .ordinary + .iter() + .position(&mut accept) + .and_then(|i| state.ordinary.remove(i)) + }) { self.changed.notify_all(); return Some(item); @@ -63,7 +77,7 @@ impl WorkQueue { } } - pub(super) fn close(&self) { + pub fn close(&self) { let mut state = self.state.lock().unwrap(); state.closed = true; let priority = std::mem::take(&mut state.priority); @@ -96,6 +110,31 @@ mod tests { ); } + #[test] + fn pop_matching_routes_items_to_compatible_lanes() { + let queue = WorkQueue::new(4); + queue.push((1, Some(1)), false).unwrap(); + queue.push((2, None), false).unwrap(); + queue.push((3, Some(1)), true).unwrap(); + queue.push((4, Some(0)), true).unwrap(); + assert_eq!( + queue.pop_matching(|(_, dev)| dev.is_none() || *dev == Some(0)), + Some((4, Some(0))) + ); + assert_eq!( + queue.pop_matching(|(_, dev)| dev.is_none() || *dev == Some(0)), + Some((2, None)) + ); + assert_eq!( + queue.pop_matching(|(_, dev)| dev.is_none() || *dev == Some(1)), + Some((3, Some(1))) + ); + assert_eq!( + queue.pop_matching(|(_, dev)| dev.is_none() || *dev == Some(1)), + Some((1, Some(1))) + ); + } + #[test] fn closing_releases_items_and_wakes_producers_and_consumers() { let full = Arc::new(WorkQueue::new(1)); diff --git a/crates/stark-key/Cargo.toml b/crates/stark-key/Cargo.toml new file mode 100644 index 000000000..bb12cb5a0 --- /dev/null +++ b/crates/stark-key/Cargo.toml @@ -0,0 +1,9 @@ +[package] +name = "stark-key" +version.workspace = true +edition.workspace = true +license.workspace = true + +[dependencies] +multi-stark = { workspace = true } +bincode = { version = "2", features = ["serde"] } diff --git a/crates/aiur/src/vk_codec.rs b/crates/stark-key/src/lib.rs similarity index 71% rename from crates/aiur/src/vk_codec.rs rename to crates/stark-key/src/lib.rs index 3ed529a6a..b054aa44a 100644 --- a/crates/aiur/src/vk_codec.rs +++ b/crates/stark-key/src/lib.rs @@ -17,8 +17,8 @@ //! packed into the tag byte, a small/big constant split, and u16 zeros and //! lookup references. The logUp constraints are never serialized — they are //! evaluated directly by both verifiers from the compiled lookups. -//! The Lean mirror is `MultiStark/SystemDeserialize.lean`; the two must -//! stay byte-identical. +//! The in-circuit mirror lives in the formal `MultiStark/*.aiur` programs +//! (`MultiStark/MultiStark/Modules/SystemDeserialize.aiur`); they must stay byte-identical. //! //! # Wire format (v5, dense) //! @@ -28,12 +28,11 @@ //! log_final_poly_len, max_log_arity, num_queries, //! commit_proof_of_work_bits, query_proof_of_work_bits) //! u16 circuit count -//! PER-CIRCUIT RECORDS (circuit count times; each is `u32 LE len` + `len` bytes -//! so a record is a contiguous byte range) +//! PER-CIRCUIT RECORDS (circuit count times; no outer length prefix) //! u16 main_width, u16 preprocessed_width, u32 preprocessed_height, //! u16 max_constraint_degree (combined user + logUp), //! u8 lookup_group_size (k: lookups per chained accumulator step) -//! node_count nodes, each a u8 tag then payload: +//! u16 node_count, then node_count nodes, each a u8 tag then payload: //! 0 ConstSmall: u16 LE canonical value //! 1 ConstBig: u64 LE canonical value //! 2 Public: u8 index @@ -42,8 +41,8 @@ //! 9 Neg: u16 LE child node id //! 10..=15 Var (tag = 10 + 2*source + offset; source 0 Preprocessed //! 1 Main 2 Stage2, offset 0 current 1 next): u16 LE column -//! u32 zero_count, then zero_count x u16 LE constraint-root node ids -//! u32 lookup_count, then per lookup: +//! u16 zero_count, then zero_count x u16 LE constraint-root node ids +//! u16 lookup_count, then per lookup: //! u16 LE multiplicity node id //! u16 LE arg count, then arg_count x u16 LE arg node ids //! TRAILER @@ -58,8 +57,7 @@ //! precede parents in the compiled vector). Goldilocks constants are written //! canonically and reduced on read. -// The codec is exercised by tests and wired to the FFI / Aiur port. -#![allow(dead_code)] +pub mod range; use multi_stark::{ expr::{ColRef, RowOffset, Source}, @@ -70,7 +68,7 @@ use multi_stark::{ types::{Commitment, CommitmentParameters, FriParameters, Val}, }; -use crate::synthesis::{AiurConfig, AiurSystem}; +use multi_stark::types::GoldilocksBlake3Config as AiurConfig; /// Sentinel for `None` in the preprocessed-index trailer. const NO_PREP_INDEX: u16 = u16::MAX; @@ -239,11 +237,6 @@ pub fn to_bytes( buf } -/// Convenience: serialize the verifying key of a built [`AiurSystem`]. -pub fn aiur_system_to_bytes(sys: &AiurSystem) -> Result, String> { - Ok(to_bytes(&sys.system, sys.commitment_parameters, sys.fri_parameters)) -} - // ════════════════════════════════════════════════════════════════════════════ // Decoder — bytes -> System // ════════════════════════════════════════════════════════════════════════════ @@ -438,7 +431,7 @@ fn zeros_plus_logup( /// Deserialize a `System` from [`to_bytes`] output, requiring that /// every byte is consumed. Also returns the config's construction parameters, /// which the `System` itself doesn't expose. -pub(crate) fn from_bytes( +pub fn from_bytes( bytes: &[u8], ) -> Result<(System, CommitmentParameters, FriParameters), String> { let mut r = Seg { buf: bytes, pos: 0 }; @@ -490,175 +483,3 @@ pub(crate) fn from_bytes( }; Ok((system, commitment_parameters, fri_parameters)) } - -/// A verifier-only Aiur key decoded from [`aiur_system_to_bytes`]. -/// -/// This is the narrow surface used by zkVM guests: unlike [`AiurSystem`], it -/// carries neither bytecode nor a prover key, but it can verify a serialized -/// proof under the exact commitment and FRI parameters embedded in the key. -pub struct AiurVerifyingKey { - system: System, - commitment_parameters: CommitmentParameters, - fri_parameters: FriParameters, -} - -impl AiurVerifyingKey { - /// Decode a verifying key and require full input consumption. - pub fn from_bytes(bytes: &[u8]) -> Result { - from_bytes(bytes).map(|(system, commitment_parameters, fri_parameters)| { - Self { system, commitment_parameters, fri_parameters } - }) - } - - /// Re-encode to the canonical Aiur verifying-key wire format. - pub fn to_bytes(&self) -> Vec { - to_bytes(&self.system, self.commitment_parameters, self.fri_parameters) - } - - pub const fn commitment_parameters(&self) -> CommitmentParameters { - self.commitment_parameters - } - - pub const fn fri_parameters(&self) -> FriParameters { - self.fri_parameters - } - - /// Constraint system and fixed commitments for recursive verifier construction. - pub fn system(&self) -> &System { - &self.system - } - - /// Check application policy and trace bounds without a proof. Intended for - /// deterministic construction of a verifier circuit, not proof verification. - pub fn validate_preamble( - &self, - claim: &[Val], - preamble: &multi_stark::batch::BatchPreamble, - ) -> Result<(), crate::synthesis::AiurVerificationError> { - crate::synthesis::validate_preamble( - &self.system, - self.commitment_parameters, - claim, - preamble, - ) - } - - pub fn num_circuits(&self) -> usize { - self.system.circuits.len() - } - - /// Verifies a batch proof of `claim` under this key: shard headers, Aiur's - /// batch policy and the multi-stark batch (see - /// [`crate::synthesis::verify_against`]). - pub fn verify( - &self, - claim: &[Val], - proof: &crate::synthesis::AiurProof, - ) -> Result<(), crate::synthesis::AiurVerificationError> { - crate::synthesis::verify_against( - &self.system, - self.commitment_parameters, - claim, - proof, - ) - } -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::gadgets::{AiurGadget, bytes1::Bytes1, bytes2::Bytes2}; - use multi_stark::system::CircuitInputs; - - fn test_parameters() -> (CommitmentParameters, FriParameters) { - let cp = CommitmentParameters { log_blowup: 1, 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, - }; - (cp, fp) - } - - fn test_system() -> (System, CommitmentParameters, FriParameters) - { - let (cp, fp) = test_parameters(); - let inputs = [ - CircuitInputs { - main_width: Bytes1.main_width(), - preprocessed: Bytes1.preprocessed(), - constraints: vec![], - ext_constraints: vec![], - lookups: Bytes1.lookups(), - lookup_group_size: 1, - }, - CircuitInputs { - main_width: Bytes2.main_width(), - preprocessed: Bytes2.preprocessed(), - constraints: vec![], - ext_constraints: vec![], - lookups: Bytes2.lookups(), - // Grouped-circuit coverage: the codec must carry the group size - // through (it changes the derived stage-2 width and count). - lookup_group_size: 2, - }, - ]; - let (system, _key) = System::new(AiurConfig::new(cp, fp), inputs); - (system, cp, fp) - } - - /// Round-trip: decode(encode(x)) re-encodes to the same bytes, with matching - /// compiled node graphs, constraint roots, and lookups. - #[test] - fn system_vk_round_trips() { - let (system, cp, fp) = test_system(); - let bytes = to_bytes(&system, cp, fp); - let (back, back_cp, back_fp) = from_bytes(&bytes).expect("decode"); - let reencoded = to_bytes(&back, back_cp, back_fp); - assert_eq!(bytes, reencoded, "verifying-key codec round-trip mismatch"); - assert_eq!(system.circuits.len(), back.circuits.len()); - for (a, b) in system.circuits.iter().zip(&back.circuits) { - assert_eq!(a.graph.nodes, b.graph.nodes, "nodes mismatch"); - assert_eq!(a.graph.zeros, b.graph.zeros, "zeros mismatch"); - assert_eq!(a.graph.lookups.len(), b.graph.lookups.len()); - for (la, lb) in a.graph.lookups.iter().zip(&b.graph.lookups) { - assert_eq!(la.multiplicity, lb.multiplicity); - assert_eq!(la.args, lb.args); - } - assert_eq!(a.main_width, b.main_width); - assert_eq!(a.lookup_group_size, b.lookup_group_size); - assert_eq!(a.stage_2_width, b.stage_2_width); - assert_eq!(a.num_publics, b.num_publics); - assert_eq!(a.preprocessed_width, b.preprocessed_width); - assert_eq!(a.preprocessed_height, b.preprocessed_height); - } - } - - #[test] - fn rejects_trailing_bytes() { - let (system, cp, fp) = test_system(); - let mut bytes = to_bytes(&system, cp, fp); - bytes.push(0); - assert!(from_bytes(&bytes).is_err(), "should reject trailing data"); - } - - /// A tampered per-circuit record length must be rejected (the record reader - /// enforces exact consumption). - #[test] - fn rejects_bad_record_length() { - let (system, cp, fp) = test_system(); - let bytes = to_bytes(&system, cp, fp); - // Records carry no length prefix (nothing derivable is serialized), so - // the malformation guards are the full-consumption check and read - // overflow: truncated and padded inputs must both be rejected. - assert!( - from_bytes(&bytes[..bytes.len() - 1]).is_err(), - "should reject truncated vk" - ); - let mut padded = bytes.clone(); - padded.push(0); - assert!(from_bytes(&padded).is_err(), "should reject padded vk"); - } -} diff --git a/crates/aiur/src/range.rs b/crates/stark-key/src/range.rs similarity index 96% rename from crates/aiur/src/range.rs rename to crates/stark-key/src/range.rs index c9f029f8a..9610bd3d8 100644 --- a/crates/aiur/src/range.rs +++ b/crates/stark-key/src/range.rs @@ -13,7 +13,8 @@ use bincode::serde::encode_to_vec; use multi_stark::p3_field::{BasedVectorSpace, PrimeField64}; use multi_stark::types::ExtVal; -use crate::{G, synthesis::AiurProof}; +use multi_stark::types::{GoldilocksBlake3Config, Val as G}; +type AiurProof = multi_stark::batch::BatchProof; /// The byte every range statement opens with. `Ix.Claim` tags live in /// `0xE0..=0xF?`, so a range statement never parses as a `CheckEnv` claim. diff --git a/crates/stark-verifier/Cargo.toml b/crates/stark-verifier/Cargo.toml new file mode 100644 index 000000000..cc3c8b337 --- /dev/null +++ b/crates/stark-verifier/Cargo.toml @@ -0,0 +1,21 @@ +[package] +name = "stark-verifier" +version.workspace = true +edition.workspace = true +license.workspace = true + +[dependencies] +aiur = { workspace = true, features = ["stark"] } +multi-stark = { workspace = true } +stark-key = { workspace = true } +blake3 = { workspace = true } +serde = { version = "1", features = ["derive"] } +serde_json = { workspace = true } + +[features] +parallel = ["aiur/parallel"] +cuda = ["aiur/cuda"] + +[dev-dependencies] +ixvm = { path = "../ixvm" } +libc = { workspace = true } diff --git a/crates/stark-verifier/examples/claim_fixture.rs b/crates/stark-verifier/examples/claim_fixture.rs new file mode 100644 index 000000000..313c814c1 --- /dev/null +++ b/crates/stark-verifier/examples/claim_fixture.rs @@ -0,0 +1,84 @@ +//! Small real proofs for testing recursive statement bindings. These systems +//! intentionally accept arbitrary digest arguments; they are not IxVM keys. +use multi_stark::{ + batch::ShardInput, + expr::Expr, + lookup::Lookup, + p3_field::{PrimeCharacteristicRing, PrimeField64}, + p3_matrix::dense::RowMajorMatrix, + system::{CircuitInputs, System, SystemWitness}, + types::{CommitmentParameters, FriParameters, GoldilocksBlake3Config, Val}, +}; +use std::{error::Error, path::Path}; + +fn main() -> Result<(), Box> { + let cli: Vec<_> = std::env::args().collect(); + let args: Vec = serde_json::from_slice(&std::fs::read( + cli.get(1).ok_or("expected digest arguments JSON")?, + )?)?; + if ![8, 16].contains(&args.len()) || args.iter().any(|&x| x >= Val::ORDER_U64) + { + return Err("expected eight or sixteen canonical field elements".into()); + } + let out = Path::new(cli.get(2).ok_or("missing output directory")?); + std::fs::create_dir_all(out)?; + let cp = CommitmentParameters { log_blowup: 1, cap_height: 0 }; + let fp = FriParameters { + log_final_poly_len: 0, + max_log_arity: 1, + num_queries: 4, + commit_proof_of_work_bits: 0, + query_proof_of_work_bits: 0, + }; + let one = Expr::constant(Val::ONE); + let mut lookup = vec![one.clone(), Expr::constant(Val::ZERO)]; + lookup.extend((0..args.len()).map(|i| Expr::main(i as u32))); + let inputs = vec![CircuitInputs { + main_width: args.len(), + constraints: vec![], + lookups: vec![Lookup::pull(one, lookup)], + ..Default::default() + }]; + let (system, pk) = System::new(GoldilocksBlake3Config::new(cp, fp), inputs); + let args: Vec<_> = args.into_iter().map(Val::from_u64).collect(); + let mut claim = vec![Val::ONE, Val::ZERO]; + claim.extend(&args); + let claims = vec![claim]; + let witness = SystemWitness::from_stage_1( + vec![RowMajorMatrix::new(args.clone(), args.len())], + &system, + ); + let proof = system.prove_batch( + &pk, + vec![ShardInput { claims: claims.clone(), witness }], + vec![], + ); + system + .verify_batch(&proof) + .map_err(|e| format!("fixture verification failed: {e:?}"))?; + std::fs::write(out.join("key.bin"), stark_key::to_bytes(&system, cp, fp))?; + std::fs::write(out.join("proof.bin"), proof.to_bytes()?)?; + std::fs::write( + out.join("claims.bin"), + stark_verifier::claims_bytes(&claims), + )?; + for hi in [0, 1] { + let preamble = stark_key::range::preamble_bytes(&proof)?; + let residual = stark_key::range::range_residual(&proof, 0, hi); + std::fs::write(out.join("preamble.bin"), &preamble)?; + std::fs::write( + out.join(format!("range-{hi}.bin")), + stark_key::range::proofs_slice_bytes(&proof, 0, hi)?, + )?; + std::fs::write( + out.join(format!("statement-{hi}.bin")), + stark_key::range::range_statement( + blake3::hash(&preamble).as_bytes(), + 0, + hi, + residual, + ), + )?; + } + Ok(()) +} diff --git a/crates/stark-verifier/examples/compare.rs b/crates/stark-verifier/examples/compare.rs new file mode 100644 index 000000000..d3d2d210f --- /dev/null +++ b/crates/stark-verifier/examples/compare.rs @@ -0,0 +1,207 @@ +//! Same bytecode benchmark contract as Benchmarks.CompareAiur for legacy. +use aiur::{ + field::FieldBackend, + library::io::Invocation, + trace::{ + TraceArtifact, TracePlan, + stark::{Backend, Parameters}, + }, +}; +use multi_stark::{batch::Retention, p3_matrix::Matrix, types::Val}; +use serde_json::json; +use std::{error::Error, time::Instant}; + +#[derive(serde::Deserialize)] +struct Package { + program: aiur::Program, + trace: TraceArtifact, +} + +fn main() -> Result<(), Box> { + let thp_disabled = configure_benchmark_memory()?; + let cli: Vec<_> = std::env::args().collect(); + if cli.len() < 5 { + return Err( + "usage: compare PACKAGE INPUT OUTPUT SAMPLES [--ungrouped] [--prove] [--counts-only] [--groups FILE]" + .into(), + ); + } + let mut package: Package = aiur::decode_artifact(&std::fs::read(&cli[1])?)?; + let invocation: Invocation = + serde_json::from_slice(&std::fs::read(&cli[2])?)?; + let samples: usize = cli[4].parse()?; + if samples == 0 { + return Err("zero benchmark samples".into()); + } + if cli.iter().any(|a| a == "--ungrouped") { + package.trace.groups.clear(); + } + if let Some(at) = cli.iter().position(|a| a == "--groups") { + let path = cli.get(at + 1).ok_or("missing groups path")?; + package.trace.groups = aiur::decode_artifact(&std::fs::read(path)?)?; + } + let counts_only = cli.iter().any(|a| a == "--counts-only"); + let reuse_execution = + std::env::var("IX_BENCH_REUSE_EXECUTION").is_ok_and(|v| v == "1"); + let functions: Vec<_> = package + .program + .functions + .iter() + .map(|f| { + let plan = package + .trace + .functions + .iter() + .find(|p| p.name == f.name) + .ok_or("missing function plan")?; + Ok((f.name.clone(), plan.chip.clone())) + }) + .collect::>()?; + let start = Instant::now(); + let program = package.program.check_field::()?; + let args = program.field().decode(&invocation.args)?; + let hints = if invocation.entry.starts_with("IxVM::") { + ixvm::prepare_streams(&program, &invocation.streams)? + } else { + stark_verifier::prepare(&program, &invocation.streams)? + }; + let prepare = start.elapsed().as_secs_f64(); + let start = Instant::now(); + let plan = TracePlan::new(&program, package.trace)?; + let backend = Backend::for_batch(&plan, Parameters::default())?; + let setup = start.elapsed().as_secs_f64(); + let mut times = vec![]; + let mut circuits = vec![]; + let mut proof_report = serde_json::Value::Null; + let mut function_rows = vec![]; + let mut cached_record = None; + let mut initial_execute = None; + let iterations = if counts_only { 1 } else { samples + 2 }; + for sample in 0..iterations { + let (record, execute) = if let Some(record) = cached_record.take() { + (record, None) + } else { + let start = Instant::now(); + let record = hints.execute(&invocation.entry, args.clone())?; + let execute = start.elapsed().as_secs_f64(); + initial_execute.get_or_insert(execute); + (record, Some(execute)) + }; + if counts_only { + let mut counts = vec![0_usize; functions.len()]; + for key in record.queries.keys() { + if let Some(count) = counts.get_mut(key.function) { + *count += 1; + } + } + function_rows = functions.iter().enumerate().map(|(i, (name, chip))| { + json!({"name": name, "chip": chip, "rows": counts[i]}) + }).collect(); + break; + } + let start = Instant::now(); + let witness = backend.generate(&record, &invocation.entry, &args)?; + let trace = start.elapsed().as_secs_f64(); + if sample >= 2 { + times.push( + json!({"execute_seconds":execute,"trace_with_lookups_seconds":trace}), + ); + } + if sample == samples + 1 { + for (i, (shape, matrix)) in + backend.statistics().iter().zip(&witness.traces).enumerate() + { + let mut row = serde_json::to_value(shape)?; + row["index"] = json!(i); + row["height"] = json!(matrix.height()); + row["cells"] = json!(matrix.values.len()); + row["fft_cost"] = json!(fft_cost( + shape.stage1_width, + shape.stage2_width, + shape.quotient_degree, + matrix.height(), + 1 + )); + circuits.push(row); + } + } + drop(witness); + if sample == samples + 1 && cli.iter().any(|a| a == "--prove") { + let start = Instant::now(); + let traces = + backend.generate_stage_1(&record, &invocation.entry, &args)?; + let output = record.output.clone(); + drop(record); + let proof = backend.prove_batch_stage_1( + &invocation.entry, + &args, + &output, + traces, + 1 << 30, + Retention::Retain, + )?; + let seconds = start.elapsed().as_secs_f64(); + proof_report = json!({"prove_including_trace_seconds":seconds,"bytes":proof.to_bytes()?.len(),"verified":true}); + if cli.iter().any(|a| a == "--save-proof") { + let directory = std::path::PathBuf::from(format!("{}.inner", cli[3])); + std::fs::create_dir_all(&directory)?; + let key = backend.verifying_key_bytes()?; + let claim = backend.claim(&invocation.entry, &args, &output)?; + let claims = stark_verifier::claims_bytes(&[claim]); + let bytes = proof.to_bytes()?; + std::fs::write(directory.join("key.bin"), &key)?; + std::fs::write(directory.join("claims.bin"), &claims)?; + std::fs::write(directory.join("proof.bin"), &bytes)?; + std::fs::write( + directory.join("input.json"), + serde_json::to_vec(&stark_verifier::invocation( + &key, &claims, &bytes, + ))?, + )?; + } + } else if reuse_execution { + cached_record = Some(record); + } + } + let report = json!({"backend":"new-bytecode","thp_disabled":thp_disabled,"prepare_seconds":prepare,"setup_seconds":setup,"reused_execution":reuse_execution,"initial_execute_seconds":initial_execute,"samples":times,"circuits":circuits,"function_rows":function_rows,"proof":proof_report}); + std::fs::write(&cli[3], serde_json::to_vec_pretty(&report)?)?; + println!("Wrote {}", cli[3]); + Ok(()) +} + +/// Same Goldilocks FFT model as `LegacyAiur.Statistics.fftCost`: two extension +/// limbs, inverse/forward trace transforms, and quotient transforms. This is +/// a work estimate, not elapsed time; height is already padded. +#[allow(clippy::cast_precision_loss)] // Approximate work, not an exact cell count. +fn fft_cost( + stage1: usize, + stage2: usize, + quotient_degree: usize, + height: usize, + log_blowup: usize, +) -> f64 { + let transform = |n: usize| { + if n == 0 { 0.0 } else { n as f64 * f64::from(n.max(2).ilog2()) } + }; + let blowup = 1usize << log_blowup; + (blowup + 1) as f64 * (stage1 + stage2) as f64 * transform(height) + + 2.0 * transform(quotient_degree * height) + + (2 * quotient_degree) as f64 * transform(blowup * height) +} + +/// Optional process-local control for comparing allocation-heavy small runs. +/// Legacy query arenas request huge pages; faulting a 2 MiB page for a tiny +/// function can dominate execution. Never changes the machine's THP policy. +fn configure_benchmark_memory() -> Result { + let disable = std::env::var("IX_BENCH_NO_THP").as_deref() == Ok("1"); + if disable { + #[cfg(target_os = "linux")] + // SAFETY: this prctl changes only the calling process's huge-page policy. + if unsafe { libc::prctl(libc::PR_SET_THP_DISABLE, 1, 0, 0, 0) } != 0 { + return Err(std::io::Error::last_os_error().to_string()); + } + #[cfg(not(target_os = "linux"))] + return Err("IX_BENCH_NO_THP requires Linux".into()); + } + Ok(disable) +} diff --git a/crates/stark-verifier/src/lib.rs b/crates/stark-verifier/src/lib.rs new file mode 100644 index 000000000..3a3a7269e --- /dev/null +++ b/crates/stark-verifier/src/lib.rs @@ -0,0 +1,103 @@ +//! Host advice for the ordinary Aiur recursive verifier. Source and compilation +//! live in the independent MultiStark Lean package; no generated Rust kernels. +use aiur::{ + bytecode::{CheckedProgram, Type}, + field::FieldBackend, + hints::{HintChannels, PreparedHints}, + library::io::Streams, + maps::MapOverrides, +}; + +pub fn prepare<'a, B: FieldBackend>( + program: &'a CheckedProgram, + streams: &Streams, +) -> Result, String> { + let field = program.field(); + let arenas = streams.prepare(field)?; + let mut channels = HintChannels::new(); + aiur::library::u32::register(&mut channels, field)?; + aiur::library::u64::register(&mut channels, field)?; + channels.insert_fixed::<1, 1>( + "goldilocks.inverse", + Type::Field, + Type::Field, + move |[x]| Ok([field.inverse(x).unwrap_or_else(|| field.zero())]), + )?; + arenas.register_read::<1>("stark.io.read1", false, &mut channels)?; + arenas.register_read::<8>("stark.io.read8", false, &mut channels)?; + arenas.register_read::<64>("stark.io.read64", false, &mut channels)?; + let mut data = arenas.metadata( + "stark.io.info", + Type::Tuple { items: vec![Type::Field; 2] }, + None, + |s| s.key.len() == 1, + false, + )?; + data.extend(arenas.metadata( + "stark.io.address", + Type::Tuple { + items: vec![Type::Field, Type::Tuple { items: vec![Type::Field; 32] }], + }, + None, + |s| s.key.len() == 32, + false, + )?); + data.extend(arenas.metadata( + "stark.io.digest", + Type::Tuple { items: vec![Type::Field; 8] }, + Some(4), + |s| s.channel == 4 && s.key.len() == 8, + false, + )?); + let prepared = program.prepare_hint_channels(&data, &channels)?; + let mut maps = MapOverrides::new(); + aiur::library::u8::register_maps(program, &mut maps)?; + prepared.with_map_overrides(&maps) +} + +pub fn digest_words(bytes: &[u8]) -> Vec { + blake3::hash(bytes) + .as_bytes() + .as_chunks::<4>() + .0 + .iter() + .map(|b| u64::from(u32::from_le_bytes(*b))) + .collect() +} + +pub fn claims_bytes(claims: &[Vec]) -> Vec { + use multi_stark::p3_field::PrimeField64; + let mut bytes = (claims.len() as u64).to_le_bytes().to_vec(); + for claim in claims { + bytes.extend_from_slice(&(claim.len() as u64).to_le_bytes()); + for word in claim { + bytes.extend_from_slice(&word.as_canonical_u64().to_le_bytes()); + } + } + bytes +} + +pub use aiur::library::io::Invocation; + +/// The proof is advice. Only the key and public claims enter the statement. +pub fn invocation(key: &[u8], claims: &[u8], proof: &[u8]) -> Invocation { + use aiur::library::io::Stream; + let mut args = digest_words(key); + args.extend(digest_words(claims)); + let streams = Streams( + [proof, key, claims] + .iter() + .enumerate() + .map(|(channel, bytes)| Stream { + channel: channel as u64, + key: vec![0], + values: bytes.iter().map(|&b| u64::from(b)).collect(), + }) + .collect(), + ); + Invocation { + entry: "MultiStark::verify_multi_stark_proof".into(), + args, + streams, + } +} diff --git a/crates/stark-verifier/src/main.rs b/crates/stark-verifier/src/main.rs new file mode 100644 index 000000000..e7605290f --- /dev/null +++ b/crates/stark-verifier/src/main.rs @@ -0,0 +1,421 @@ +use aiur::{ + field::FieldBackend, + trace::{ + TraceArtifact, TracePlan, + stark::{Backend, Parameters, planning::Options}, + }, +}; +use multi_stark::{ + batch::ShardInput, + expr::Expr, + lookup::Lookup, + p3_field::PrimeCharacteristicRing, + p3_matrix::dense::RowMajorMatrix, + system::{CircuitInputs, System, SystemWitness}, + types::{CommitmentParameters, FriParameters, GoldilocksBlake3Config, Val}, +}; +use std::{ + error::Error, + io::{BufWriter, Write}, + path::Path, + time::Instant, +}; + +#[derive(serde::Deserialize)] +struct Package { + program: aiur::Program, + trace: TraceArtifact, +} + +/// Serialize through a buffer. Recursive invocations encode every proof byte +/// as a JSON number; unbuffered, each token was a separate write syscall. +fn write_json( + path: &Path, + value: &impl serde::Serialize, +) -> Result<(), Box> { + let mut file = BufWriter::new(std::fs::File::create(path)?); + serde_json::to_writer(&mut file, value)?; + file.flush()?; + Ok(()) +} + +fn fixture(dir: &Path) -> Result<(), Box> { + std::fs::create_dir_all(dir)?; + let cp = CommitmentParameters { log_blowup: 1, cap_height: 0 }; + let fp = FriParameters { + log_final_poly_len: 0, + max_log_arity: 1, + num_queries: 16, + commit_proof_of_work_bits: 0, + query_proof_of_work_bits: 0, + }; + let x = Expr::main(0); + let y = Expr::main(1); + let one = Expr::constant(Val::ONE); + let inputs = vec![CircuitInputs { + main_width: 2, + constraints: vec![x.clone() * x.clone() - y.clone()], + lookups: vec![Lookup::pull( + one.clone(), + vec![one, Expr::constant(Val::ZERO), x, y], + )], + ..Default::default() + }]; + let (system, pk) = System::new(GoldilocksBlake3Config::new(cp, fp), inputs); + let claims = + vec![vec![Val::ONE, Val::ZERO, Val::from_u64(3), Val::from_u64(9)]]; + let witness = SystemWitness::from_stage_1( + vec![RowMajorMatrix::new(vec![Val::from_u64(3), Val::from_u64(9)], 2)], + &system, + ); + let proof = system.prove_batch( + &pk, + vec![ShardInput { claims: claims.clone(), witness }], + vec![], + ); + system + .verify_batch(&proof) + .map_err(|e| format!("fixture failed native verification: {e:?}"))?; + let key = stark_key::to_bytes(&system, cp, fp); + let claims = stark_verifier::claims_bytes(&claims); + let proof = proof.to_bytes()?; + std::fs::write(dir.join("key.bin"), &key)?; + std::fs::write(dir.join("claims.bin"), &claims)?; + std::fs::write(dir.join("proof.bin"), &proof)?; + write_json( + &dir.join("input.json"), + &stark_verifier::invocation(&key, &claims, &proof), + )?; + println!("created natively verified recursion fixture in {}", dir.display()); + Ok(()) +} + +fn main() -> Result<(), Box> { + let cli: Vec<_> = std::env::args().collect(); + let mode = cli.get(1).ok_or("usage: stark-verifier fixture DIR | key PACKAGE DIR | execute|test|prove|verify PACKAGE INPUT [OUTPUT] [SHARD_ROWS] [RETENTION]")?; + if mode == "fixture" { + return fixture(Path::new(cli.get(2).ok_or("missing directory")?)); + } + if mode == "ranges" || mode == "inspect" { + return ranges(&cli); + } + if !["execute", "plan", "test", "prove", "verify", "key", "cases"] + .contains(&mode.as_str()) + { + return Err("unknown mode".into()); + } + let package: Package = aiur::decode_artifact(&std::fs::read( + cli.get(2).ok_or("missing package")?, + )?)?; + let program = package.program.check_field::()?; + let artifact_resident = aiur::trace::stark::planning::resident_memory(); + if mode == "cases" { + #[derive(serde::Deserialize)] + struct Case { + label: String, + accept: bool, + invocation: stark_verifier::Invocation, + } + let cases: Vec = serde_json::from_slice(&std::fs::read( + cli.get(3).ok_or("missing cases")?, + )?)?; + for case in cases { + let args = program.field().decode(&case.invocation.args)?; + let result = stark_verifier::prepare(&program, &case.invocation.streams)? + .execute(&case.invocation.entry, args); + if result.is_ok() != case.accept { + return Err( + format!("{}: unexpected result {:?}", case.label, result.err()) + .into(), + ); + } + println!( + "{}: {}", + case.label, + if case.accept { "accepted" } else { "rejected" } + ); + } + return Ok(()); + } + if mode == "key" { + let out = Path::new(cli.get(3).ok_or("missing output directory")?); + std::fs::create_dir_all(out)?; + let plan = TracePlan::new(&program, package.trace)?; + let backend = + Backend::for_batch_verification(&plan, Parameters::default())?; + let entry = &program.program().entries[0].name; + let claim = backend.claim(entry, &[Val::ZERO; 16], &[])?; + use multi_stark::p3_field::PrimeField64; + let key = backend.verifying_key_bytes()?; + std::fs::write(out.join("key.bin"), &key)?; + write_json( + &out.join("identity.json"), + &serde_json::json!({ + "function_index":claim[1].as_canonical_u64(), "call_channel":claim[0].as_canonical_u64(), + "key_digest":blake3::hash(&key).to_hex().to_string()}), + )?; + return Ok(()); + } + let invocation: stark_verifier::Invocation = serde_json::from_slice( + &std::fs::read(cli.get(3).ok_or("missing invocation")?)?, + )?; + if !["MultiStark::verify_multi_stark_proof", "MultiStark::ix_aggr"] + .contains(&invocation.entry.as_str()) + || invocation.args.len() != 16 + { + return Err( + "expected a recursive entrypoint with sixteen public digest words".into(), + ); + } + let args = program.field().decode(&invocation.args)?; + if mode == "verify" { + use aiur::trace::stark::BatchProof; + let plan = TracePlan::new(&program, package.trace)?; + let backend = + Backend::for_batch_verification(&plan, Parameters::default())?; + let bytes = std::fs::read(cli.get(4).ok_or("missing proof")?)?; + let proof = BatchProof::from_bytes(&bytes)?; + if proof.to_bytes()? != bytes { + return Err("noncanonical or trailing proof bytes".into()); + } + backend.verify_batch(&invocation.entry, &args, &[], &proof)?; + println!("verified recursive proof"); + return Ok(()); + } + let options = Options::read(cli.get(7), cli.get(5), cli.get(6))?; + let before_setup = aiur::trace::stark::planning::resident_memory(); + let trace_plan = if mode == "execute" || mode == "test" { + None + } else { + Some(TracePlan::new(&program, package.trace)?) + }; + let backend = trace_plan + .as_ref() + .map(|plan| { + Backend::for_batch_on_device(plan, Parameters::default(), options.device) + }) + .transpose()?; + if let Some(backend) = &backend { + let static_resident = artifact_resident.saturating_add( + aiur::trace::stark::planning::resident_memory() + .saturating_sub(before_setup), + ); + let fixed = backend.plan_fixed(&options, static_resident)?; + if !fixed.fits { + let out = Path::new(cli.get(4).ok_or("missing output directory")?); + std::fs::create_dir_all(out)?; + let report = serde_json::json!({"plan":fixed, "can_split":false, "verified":false, + "error":"budget is below the estimated artifact and fixed-table floor"}); + std::fs::write( + out.join("report.json"), + serde_json::to_vec_pretty(&report)?, + )?; + println!("{report}"); + if mode == "plan" { + return Ok(()); + } + std::process::exit(75); + } + } + let hints = stark_verifier::prepare(&program, &invocation.streams)?; + let start = Instant::now(); + let record = hints.execute(&invocation.entry, args.clone())?; + let execute = start.elapsed().as_secs_f64(); + if !record.output.is_empty() { + return Err("verifier returned a non-unit value".into()); + } + eprintln!( + "recursive bytecode verified in {:.3}s ({} queries, {} instructions)", + start.elapsed().as_secs_f64(), + record.queries.len(), + record.instructions + ); + if mode == "execute" { + return Ok(()); + } + if mode == "test" { + for i in [0, 8] { + let mut wrong = args.clone(); + wrong[i] += Val::ONE; + if hints.execute(&invocation.entry, wrong).is_ok() { + return Err("accepted wrong public digest".into()); + } + } + for channel in [0, 1, 2] { + let mut wrong = invocation.streams.clone(); + let stream = wrong.0.iter_mut().find(|s| s.channel == channel).unwrap(); + // Truncation tests full consumption / bounds without inducing giant + // adversarial count allocations in the honest interpreter. + stream.values.pop(); + if stark_verifier::prepare(&program, &wrong)? + .execute(&invocation.entry, args.clone()) + .is_ok() + { + return Err(format!("accepted truncated stream {channel}").into()); + } + } + let mut wrong = invocation.streams.clone(); + let stream = wrong.0.iter_mut().find(|s| s.channel == 0).unwrap(); + let bytes: Vec<_> = + stream.values.iter().map(|&v| u8::try_from(v).unwrap()).collect(); + let mut proof = aiur::trace::stark::BatchProof::from_bytes(&bytes)?; + proof.proofs[0].stage_1_opened_values[0][0][0] += + multi_stark::types::ExtVal::ONE; + stream.values = proof.to_bytes()?.into_iter().map(u64::from).collect(); + if stark_verifier::prepare(&program, &wrong)? + .execute(&invocation.entry, args.clone()) + .is_ok() + { + return Err("accepted a corrupted opening".into()); + } + println!( + "honest proof accepted; wrong public digests, truncated streams and corrupted opening rejected" + ); + return Ok(()); + } + drop(invocation.streams); + let backend = backend.ok_or("missing proving backend")?; + let out = Path::new(cli.get(4).ok_or("missing output directory")?); + std::fs::create_dir_all(out)?; + let batch = backend.plan_batch(&record, &options)?; + let mut report = serde_json::json!({"plan":batch, "execution_seconds":execute, + "queries":record.queries.len(), "instructions":record.instructions, "verified":false}); + std::fs::write(out.join("report.json"), serde_json::to_vec_pretty(&report)?)?; + if mode == "plan" { + println!("{}", report); + return Ok(()); + } + if !batch.fits { + eprintln!( + "recursive proving estimate exceeds budget; see {}", + out.join("report.json").display() + ); + std::process::exit(75); + } + let start = Instant::now(); + let witness = backend.prepare_stage_1(&record, &invocation.entry, &args)?; + if witness.cells() != batch.stage1_cells { + return Err("generated trace differs from the resource plan".into()); + } + let trace = start.elapsed().as_secs_f64(); + drop(record); + drop(hints); + let start = Instant::now(); + let proof = backend.prove_stage_one( + &invocation.entry, + &args, + &[], + witness, + batch.max_rows, + batch.retention(), + )?; + let proving = start.elapsed().as_secs_f64(); + let key = backend.verifying_key_bytes()?; + let claims = stark_verifier::claims_bytes(&[backend.claim( + &invocation.entry, + &args, + &[], + )?]); + let bytes = proof.to_bytes()?; + std::fs::write(out.join("proof.bin"), &bytes)?; + std::fs::write(out.join("key.bin"), &key)?; + std::fs::write(out.join("claims.bin"), &claims)?; + write_json( + &out.join("public.json"), + &aiur::library::io::Invocation { + entry: invocation.entry, + args: invocation.args, + streams: Default::default(), + }, + )?; + report["verified"] = true.into(); + report["trace_seconds"] = trace.into(); + report["proving_seconds"] = proving.into(); + report["proof_bytes"] = bytes.len().into(); + report["shards"] = proof.proofs.len().into(); + std::fs::write(out.join("report.json"), serde_json::to_vec_pretty(&report)?)?; + write_json( + &out.join("input.json"), + &stark_verifier::invocation(&key, &claims, &bytes), + )?; + println!( + "outer proof verified: {} bytes, {} shards", + bytes.len(), + proof.proofs.len() + ); + Ok(()) +} + +/// Produce range advice, never a verification result. The controller verifies +/// the source proof before calling this; the Aiur range circuit checks it again. +fn ranges(cli: &[String]) -> Result<(), Box> { + use aiur::trace::stark::BatchProof; + use stark_key::range::{ + preamble_bytes, proofs_slice_bytes, range_residual, range_statement, + }; + let bytes = std::fs::read(cli.get(2).ok_or("missing proof")?)?; + let proof = BatchProof::from_bytes(&bytes)?; + if proof.to_bytes()? != bytes || proof.proofs.is_empty() { + return Err("noncanonical, empty or trailing proof bytes".into()); + } + if cli[1] == "inspect" { + println!("{}", serde_json::json!({"shards":proof.proofs.len()})); + return Ok(()); + } + let out = Path::new(cli.get(3).ok_or("missing output directory")?); + let size: usize = cli.get(4).ok_or("missing range size")?.parse()?; + if size == 0 { + return Err("range size must be positive".into()); + } + std::fs::create_dir_all(out)?; + let preamble = preamble_bytes(&proof)?; + let digest = blake3::hash(&preamble); + std::fs::write(out.join("preamble.bin"), preamble)?; + let mut specs = Vec::new(); + let mut layer = Vec::new(); + for lo in (0..proof.proofs.len()).step_by(size) { + let hi = lo.saturating_add(size).min(proof.proofs.len()); + let id = specs.len(); + std::fs::write( + out.join(format!("{id}.proofs")), + proofs_slice_bytes(&proof, lo, hi)?, + )?; + layer.push((id, lo, hi)); + specs.push(serde_json::json!({"lo":lo, "hi":hi, "children":[]})); + } + while layer.len() > 1 { + let mut next = Vec::new(); + for pair in layer.chunks(2) { + let [(left, lo, _), (right, _, hi)] = pair else { + next.push(pair[0]); + continue; + }; + let id = specs.len(); + next.push((id, *lo, *hi)); + specs + .push(serde_json::json!({"lo":lo, "hi":hi, "children":[left,right]})); + } + layer = next; + } + for (id, spec) in specs.iter().enumerate() { + let lo = spec["lo"].as_u64().unwrap() as usize; + let hi = spec["hi"].as_u64().unwrap() as usize; + if proof.proofs[lo..hi] + .iter() + .any(|p| p.intermediate_accumulators.is_empty()) + { + return Err("range contains a shard without accumulators".into()); + } + std::fs::write( + out.join(format!("{id}.statement")), + range_statement( + digest.as_bytes(), + lo, + hi, + range_residual(&proof, lo, hi), + ), + )?; + } + std::fs::write(out.join("ranges.json"), serde_json::to_vec_pretty(&specs)?)?; + Ok(()) +} diff --git a/docs/Ixon-v4.md b/docs/Ixon-v4.md index 15652ff4b..fa99e8b43 100644 --- a/docs/Ixon-v4.md +++ b/docs/Ixon-v4.md @@ -27,9 +27,9 @@ typing and explicitly rejects resource-proof requests. The [v3 verification record](ixon-v3-verification.md) lists the gates executed for the contract model. -The IxVM circuit has its own codec (`Ix/IxVM/IxonDeserialize.lean`, -`Ix/IxVM/IxonSerialize.lean`, generated into -`crates/ixvm-codegen/src/aiur_ixvm.rs`). It reads and writes TagN with the +The IxVM circuit has its own codec (`LegacyIxVM/IxonDeserialize.lean`, +`LegacyIxVM/IxonSerialize.lean`, generated into +`crates/ixvm-legacy-native/src/aiur_ixvm.rs`). It reads and writes TagN with the host codec's accept and reject rules. The suite `ixvm-tagn` checks it against `Ixon.putTagN`/`getTagN` on every rung boundary, the rejection vectors, every one-byte string, and every header with a sample of second diff --git a/docs/aiur-gpu-proving.md b/docs/aiur-gpu-proving.md index ac94fb046..0a08af342 100644 --- a/docs/aiur-gpu-proving.md +++ b/docs/aiur-gpu-proving.md @@ -1,5 +1,15 @@ # Proving on GPUs: multi-GPU scheduling, generated traces, and how to benchmark them +The certified Formal Aiur backend (`crates/aiur`, `crates/ixvm`, +`crates/ix-prover`) is now the default and only backend; the legacy `--legacy` +flag and `aiur-legacy` / `ixvm-legacy` crates have been retired. For current +resident controller and CUDA commands (`ix prepare --cuda`, +`ix prove --lanes N --gpu-device 0 ...`), see +[Formal Aiur orchestration](formal-aiur-orchestration.md) and +[Formal Aiur in Ix](formal-aiur-migration.md#cuda-and-native-builds). The rest +of this document records the multi-GPU scheduling design, device trace +population, and benchmark methodology. + 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 @@ -25,7 +35,7 @@ everything else unchanged. Build on a GPU host: ```sh -IX_CUDA_TRACE_CODEGEN=1 lake build ix +ix prepare --cuda ``` The build detects the installed GPUs and compiles only their distinct SM @@ -76,12 +86,12 @@ ix shard mathlib.ixe --max-ram 230 --exec-jobs 3 --out mathlib.ixes # 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_PROOF_CACHE_DIR=$PWD/cache +export AIUR_GPU_TRACE=generated systemd-run --user --scope -q -p MemoryMax=920G -- \ ix prove --ixe mathlib.ixe --ixes mathlib.ixes \ - --gpus 4 --exec-jobs 3 --max-ram 230 --out-ixes mathlib-proven.ixes \ + --lanes 4 --gpu-device 0 --trace-shards --exec-jobs 3 --max-ram 230 \ + --out-ixes mathlib-proven.ixes \ > prove.out 2> prove.err # 3. Verify the root against the partition that was actually proven. @@ -157,29 +167,12 @@ 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 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: +In the Formal Aiur backend, `crates/aiur/cuda/population.cu` interprets the +compiled population plans and group placements directly on the 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 +cargo test --release --locked -p aiur -p ixvm -p ix-prover --features parallel +IX_TEST_CUDA=1 bash tools/ixvm/check-formal.sh ``` ## 5. Knobs diff --git a/docs/aiur-trace-sharding.md b/docs/aiur-trace-sharding.md index 64a78d176..f935605ee 100644 --- a/docs/aiur-trace-sharding.md +++ b/docs/aiur-trace-sharding.md @@ -87,25 +87,24 @@ on one or several GPUs is [aiur-gpu-proving.md](aiur-gpu-proving.md). an ungated `m` would let a padding row — every constraint off — pull an arbitrary `f(x) = y`); every constrained `Call`, `Store`, `Load` and byte op pushes one message with the branch selector as multiplicity - (`crates/aiur/src/constraints.rs:170-190, 400-490`; - `crates/aiur/src/trace.rs:96-160`). Function circuits have no + (`crates/aiur/src/trace/`). Function circuits have no cross-row constraints. - The claim `[chan 0, fun_idx, input…, output…]` is the verifier's push - balancing the entry row's pull (`crates/aiur/src/synthesis.rs:447-452`). + balancing the entry row's pull (`crates/aiur/src/trace/stark.rs`). - Memory is content-addressed and write-once: `Store(values)` dedups by value and assigns `ptr = insertion index`; `Load(ptr)` bumps the - multiplicity (`crates/aiur/src/execute.rs:365-407`). The memory circuit + multiplicity (`crates/aiur/src/execute.rs`). The memory circuit for width `w` has rows `[mult, sel, ptr, values…]`, one pull of `(chan 1, w, ptr, values)` with multiplicity `sel · mult`, and constraints: `sel` boolean, real-next ⇒ real-current, `ptr_next = ptr + 1` on real transitions. There is no - first-row anchor (`crates/aiur/src/memory.rs:34-67`). An unqueried + first-row anchor (`crates/aiur/src/trace/stark.rs`). An unqueried memory width yields an empty trace and is deactivated. -- Bytes1 (256 rows) and Bytes2 (65 536 rows) carry preprocessed operand +- Fixed byte tables carry preprocessed operand columns and always emit the full table - (`crates/aiur/src/gadgets/bytes2.rs:284-`). They are the per-proof + (`crates/aiur/src/trace/stark.rs`). They are the per-proof fixed floor of the RAM model. -- Prover peak model (`crates/aiur/src/synthesis.rs:287-367`): +- Prover peak model (`crates/aiur/src/trace/stark/planning.rs`): `max(phase_witness, phase_stage2, phase_open) + preprocessed`, where `phase_open` ∝ committed LDE bytes `8·b·n·(main + stage2 + q·d)` per circuit plus FRI buffers ∝ `b · tallest`. `suggested_split_parts` @@ -227,7 +226,7 @@ q·d` is circuit `c`'s committed width, `n_c` its padded height in `S`, - proof size: `9 B · q · Σ_{c active in S} W_c` — a fixed price per *activation*, independent of rows. -Planner (`plan_rows` in `crates/aiur/src/shard.rs`): every shard commits +Planner (`crates/aiur/src/trace/stark/planning.rs`): every shard commits the byte tables, so their cells are charged to every shard and the room a shard has for rows is what remains after them. Each circuit is cut into the fewest pieces that each fit that room — a circuit that fits whole is diff --git a/docs/benchmarks/formal-aiur-gpu-preparation/manifest.json b/docs/benchmarks/formal-aiur-gpu-preparation/manifest.json new file mode 100644 index 000000000..7573b7b28 --- /dev/null +++ b/docs/benchmarks/formal-aiur-gpu-preparation/manifest.json @@ -0,0 +1,68 @@ +{ + "revision": "e2326c95d746c345e9a2ecc8b19197a4f2a2e043", + "threads": 16, + "affinity": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15 + ], + "gpu_available": false, + "cpu": "Intel Xeon 6975P-C", + "rustc": "rustc 1.98.1 (48a229cea 2026-09-01)", + "cuda_hardware_validated": false, + "environment": { + "RAYON_NUM_THREADS": "16", + "IX_BENCH_NO_THP": "1", + "IX_BENCH_REUSE_EXECUTION": "1", + "AIUR_TRACE_ONLY_LOOKUPS": "0" + }, + "flags": "--release; -Ctarget-cpu=native; features parallel,aiur/trace-profile", + "measurement": "CPU trace generation, batch proving and verification. Execution and setup excluded. Same lookup/copy instrumentation in both binaries. Three process runs per workload/version, each with two trace warmups.", + "baseline_changes": "e2326c95 plus optional phase timers only", + "local_raw_directory": ".lake/gpu-followup-20261030", + "binary_sha256": { + "baseline": "e27d665db9f1154fbd5f39161e1289b8ed26d7b65f56dbec97a7492a531fc251", + "fixed": "6d1385fd36d2ddc9264b3049a4ae49c0d1a4a4aedb6db1c4c23df86e9ec217f3" + }, + "input_sha256": { + ".lake/formal-integration/ixvm-tuned.json": "1f8c10da7b10587e985d5166b26ad0c7edd4f4cbdfe0978c7deb237cf6683d9a", + ".lake/formal-integration/recursion-tuned.json": "40e88dd1f84e4f119626189e83f8eb181f6ef9875c190f33cdd7853e83c5afe1", + ".lake/formal-comparison/final/environment-input.json": "14a147c1d6141721547092a9a835249969aa1f82c8f57f9ed0a2b0522f7aaa56", + ".lake/formal-comparison/final/new-environment-grouped.json.inner/input.json": "2ecf2051d112503637b9d3c1a6201bd66f91df4568a95faff3cef068e3f96a1a" + }, + "identities": { + "environment": { + "proof.bin": "68c9ab5d23678f921a6af89d2a65dd76356f50b1218d823c2913849b8a708072", + "key.bin": "50760291ae2c66b2564f7c494f81a31cf377cc125fbbd9382d86d4c370378143", + "claims.bin": "3bf7b58d3da6199546ac0ac885d60323969d3867c08bbfc5ac0e12dacb46a4c9" + }, + "recursion": { + "proof.bin": "e1a67b6847c7770f1f4340253bf5fe8a9c7f1aaa69cca175a9b6e42db6450590", + "key.bin": "21083c7b19de3e0a83c647e5a5420d34c2df2aab618aa7de327cf96670fc0121", + "claims.bin": "b86c6d532256574ab4f3c0d757b301215be733dd5943d105371cd35147907f64" + } + }, + "proof_key_claim_and_circuit_shapes_identical": true, + "validation": { + "parallel_rust_tests_passed": 104, + "serial_aiur_tests_passed": 88, + "cpu_parity_report": ".lake/orchestration-final/cuda-check-7g951y0z/report.json", + "controller_report": ".lake/orchestration-final/controller-check-67ry6a6t/report.json", + "cuda_build": "CUDA 13.3.1 development container; SM 80; ixvm-proof, stark-verifier, ix-prover release build/link and all-target Clippy", + "cuda_hardware_validated": false, + "lean_sources_changed": false + } +} diff --git a/docs/benchmarks/formal-aiur-gpu-preparation/runs.json b/docs/benchmarks/formal-aiur-gpu-preparation/runs.json new file mode 100644 index 000000000..49aa360b6 --- /dev/null +++ b/docs/benchmarks/formal-aiur-gpu-preparation/runs.json @@ -0,0 +1,146 @@ +[ + { + "workload": "environment", + "variant": "baseline", + "sample": 1, + "prove_including_trace_seconds": 2.483720852, + "stage1_seconds": 0.032726669, + "source_copy_seconds": 0.114354732, + "host_lookups_seconds": 0.695808151, + "proof_bytes": 6557454, + "main_cells": 43146214, + "verified": true + }, + { + "workload": "environment", + "variant": "baseline", + "sample": 2, + "prove_including_trace_seconds": 2.537897644, + "stage1_seconds": 0.033426032, + "source_copy_seconds": 0.116838292, + "host_lookups_seconds": 0.707270493, + "proof_bytes": 6557454, + "main_cells": 43146214, + "verified": true + }, + { + "workload": "environment", + "variant": "baseline", + "sample": 3, + "prove_including_trace_seconds": 2.551670177, + "stage1_seconds": 0.033218398, + "source_copy_seconds": 0.119056886, + "host_lookups_seconds": 0.712157922, + "proof_bytes": 6557454, + "main_cells": 43146214, + "verified": true + }, + { + "workload": "environment", + "variant": "fixed", + "sample": 1, + "prove_including_trace_seconds": 1.740918872, + "stage1_seconds": 0.033456568, + "source_copy_seconds": 1.123e-06, + "host_lookups_seconds": 0.045639777, + "proof_bytes": 6557454, + "main_cells": 43146214, + "verified": true + }, + { + "workload": "environment", + "variant": "fixed", + "sample": 2, + "prove_including_trace_seconds": 1.747065365, + "stage1_seconds": 0.033146104, + "source_copy_seconds": 9.06e-06, + "host_lookups_seconds": 0.050370063, + "proof_bytes": 6557454, + "main_cells": 43146214, + "verified": true + }, + { + "workload": "environment", + "variant": "fixed", + "sample": 3, + "prove_including_trace_seconds": 1.7409950250000001, + "stage1_seconds": 0.03279693, + "source_copy_seconds": 1.015e-06, + "host_lookups_seconds": 0.049110966, + "proof_bytes": 6557454, + "main_cells": 43146214, + "verified": true + }, + { + "workload": "recursion", + "variant": "baseline", + "sample": 1, + "prove_including_trace_seconds": 40.424412828, + "stage1_seconds": 0.877909882, + "source_copy_seconds": 2.722077503, + "host_lookups_seconds": 13.066015886, + "proof_bytes": 3168863, + "main_cells": 937960213, + "verified": true + }, + { + "workload": "recursion", + "variant": "baseline", + "sample": 2, + "prove_including_trace_seconds": 40.421598996, + "stage1_seconds": 0.885476864, + "source_copy_seconds": 2.746098321, + "host_lookups_seconds": 13.049758233, + "proof_bytes": 3168863, + "main_cells": 937960213, + "verified": true + }, + { + "workload": "recursion", + "variant": "baseline", + "sample": 3, + "prove_including_trace_seconds": 40.497571596, + "stage1_seconds": 0.875800172, + "source_copy_seconds": 3.081995649, + "host_lookups_seconds": 13.055382119, + "proof_bytes": 3168863, + "main_cells": 937960213, + "verified": true + }, + { + "workload": "recursion", + "variant": "fixed", + "sample": 1, + "prove_including_trace_seconds": 24.963702152, + "stage1_seconds": 0.882072177, + "source_copy_seconds": 1.628e-06, + "host_lookups_seconds": 0.97131443, + "proof_bytes": 3168863, + "main_cells": 937960213, + "verified": true + }, + { + "workload": "recursion", + "variant": "fixed", + "sample": 2, + "prove_including_trace_seconds": 24.681068026, + "stage1_seconds": 0.871207973, + "source_copy_seconds": 1.645e-06, + "host_lookups_seconds": 0.928675833, + "proof_bytes": 3168863, + "main_cells": 937960213, + "verified": true + }, + { + "workload": "recursion", + "variant": "fixed", + "sample": 3, + "prove_including_trace_seconds": 24.787299644, + "stage1_seconds": 0.992412044, + "source_copy_seconds": 1.602e-06, + "host_lookups_seconds": 0.915792781, + "proof_bytes": 3168863, + "main_cells": 937960213, + "verified": true + } +] diff --git a/docs/benchmarks/formal-aiur-gpu-preparation/summary.csv b/docs/benchmarks/formal-aiur-gpu-preparation/summary.csv new file mode 100644 index 000000000..45babb60a --- /dev/null +++ b/docs/benchmarks/formal-aiur-gpu-preparation/summary.csv @@ -0,0 +1,5 @@ +workload,variant,samples,prove_including_trace_seconds,stage1_seconds,source_copy_seconds,host_lookups_seconds,proof_bytes,main_cells +environment,baseline,3,2.537897644,0.033218398,0.116838292,0.707270493,6557454,43146214 +environment,fixed,3,1.7409950250000001,0.033146104,1.123e-06,0.049110966,6557454,43146214 +recursion,baseline,3,40.424412828,0.877909882,2.746098321,13.055382119,3168863,937960213 +recursion,fixed,3,24.787299644,0.882072177,1.628e-06,0.928675833,3168863,937960213 diff --git a/docs/benchmarks/formal-aiur-gpu-validation/pipeline.json b/docs/benchmarks/formal-aiur-gpu-validation/pipeline.json new file mode 100644 index 000000000..eaeda4fce --- /dev/null +++ b/docs/benchmarks/formal-aiur-gpu-validation/pipeline.json @@ -0,0 +1,360 @@ +{ + "revision": "129c805642fa0960974d049e08811265bcacc9c8", + "environment": "342-constant Nat.add_comm environment from formal-aiur-tests, ix shard --shards 4", + "command": "ix prove --ixe env.ixe --ixes env4.ixes --trace-shards --lanes 1 --exec-jobs N --max-ram 160 --no-index [--no-cache] --out-ixes OUT", + "runs": [ + { + "label": "legacy-graph", + "exit": 0, + "wall_seconds": 95.7, + "peak_rss_gib": 29.8, + "sampled_gpu_peak_gib": 50.6, + "root": "a5ee668351d932bf24893ac6258861ccb348c0a79df2b50925e9107374d80666", + "configuration": "legacy, --legacy, AIUR_TRACE_ONLY_LOOKUPS=1, --exec-jobs 2" + }, + { + "label": "legacy-graph-x4", + "exit": 0, + "wall_seconds": 97.0, + "peak_rss_gib": 29.8, + "sampled_gpu_peak_gib": 50.7, + "root": "a5ee668351d932bf24893ac6258861ccb348c0a79df2b50925e9107374d80666", + "configuration": "legacy, --exec-jobs 4" + }, + { + "label": "formal-head-host", + "exit": 1, + "wall_seconds": 210.8, + "peak_rss_gib": 38.2, + "sampled_gpu_peak_gib": 4.6, + "root": null, + "configuration": "HEAD ix-prover, --shard-rows 65536 (HEAD GPU default), host lookups" + }, + { + "label": "formal-head-graph", + "exit": 1, + "wall_seconds": 204.3, + "peak_rss_gib": 37.2, + "sampled_gpu_peak_gib": 4.6, + "root": null, + "configuration": "HEAD ix-prover, --shard-rows 65536, graph lookups" + }, + { + "label": "formal-head-4m-graph", + "exit": 0, + "wall_seconds": 94.7, + "peak_rss_gib": 23.1, + "sampled_gpu_peak_gib": 32.5, + "root": "ce29cb0ef6caa97854e35b96ab77ac89350793cdc9831e642733ddeac723108b", + "configuration": "HEAD ix-prover, --shard-rows 4194304, graph lookups" + }, + { + "label": "formal-head-4m-host", + "exit": 0, + "wall_seconds": 105.5, + "peak_rss_gib": 41.0, + "sampled_gpu_peak_gib": 32.5, + "root": "ce29cb0ef6caa97854e35b96ab77ac89350793cdc9831e642733ddeac723108b", + "configuration": "HEAD ix-prover, --shard-rows 4194304, host lookups" + }, + { + "label": "formal-fixed2-graph-1", + "exit": 0, + "wall_seconds": 63.3, + "peak_rss_gib": 26.5, + "sampled_gpu_peak_gib": 32.5, + "root": "ce29cb0ef6caa97854e35b96ab77ac89350793cdc9831e642733ddeac723108b", + "configuration": "fixed, defaults, graph lookups (run 1)" + }, + { + "label": "formal-fixed2-graph-2", + "exit": 0, + "wall_seconds": 63.3, + "peak_rss_gib": 26.0, + "sampled_gpu_peak_gib": 32.5, + "root": "ce29cb0ef6caa97854e35b96ab77ac89350793cdc9831e642733ddeac723108b", + "configuration": "fixed, defaults, graph lookups (run 2)" + }, + { + "label": "formal-fixed2-host", + "exit": 0, + "wall_seconds": 74.5, + "peak_rss_gib": 45.6, + "sampled_gpu_peak_gib": 32.5, + "root": "ce29cb0ef6caa97854e35b96ab77ac89350793cdc9831e642733ddeac723108b", + "configuration": "fixed, defaults, host lookups" + }, + { + "label": "formal-graph-x4", + "exit": 0, + "wall_seconds": 57.6, + "peak_rss_gib": 33.3, + "sampled_gpu_peak_gib": 32.5, + "root": "ce29cb0ef6caa97854e35b96ab77ac89350793cdc9831e642733ddeac723108b", + "configuration": "fixed, graph lookups, --exec-jobs 4" + }, + { + "label": "formal-direct-graph", + "exit": 0, + "wall_seconds": 64.0, + "peak_rss_gib": 34.8, + "sampled_gpu_peak_gib": 32.6, + "root": "7f1e2a3eb6214a1602d62aec157b4a748867d033ea62c75a27af667e814f4b10", + "configuration": "fixed, graph lookups, --direct-joins" + }, + { + "label": "main-host", + "exit": 0, + "wall_seconds": 131.4, + "peak_rss_gib": 29.5, + "sampled_gpu_peak_gib": 20.0, + "root": "8515dba7536220e9f913ae9d681e349d4170e5713beac7c12243df33238c8f36", + "configuration": "origin/main 7a313fdf (legacy Aiur, native execution), IX_CUDA=1 build, defaults (host lookups), --exec-jobs 2" + }, + { + "label": "main-graph", + "exit": 0, + "wall_seconds": 67.6, + "peak_rss_gib": 29.7, + "sampled_gpu_peak_gib": 50.6, + "root": "a5ee668351d932bf24893ac6258861ccb348c0a79df2b50925e9107374d80666", + "configuration": "origin/main 7a313fdf, AIUR_TRACE_ONLY_LOOKUPS=1, --exec-jobs 2" + }, + { + "label": "main-graph-x4", + "exit": 0, + "wall_seconds": 68.8, + "peak_rss_gib": 29.7, + "sampled_gpu_peak_gib": 50.7, + "root": "a5ee668351d932bf24893ac6258861ccb348c0a79df2b50925e9107374d80666", + "configuration": "origin/main 7a313fdf, AIUR_TRACE_ONLY_LOOKUPS=1, --exec-jobs 4" + }, + { + "label": "formal-fixed3-host", + "exit": 0, + "wall_seconds": 74.0, + "peak_rss_gib": 46.1, + "sampled_gpu_peak_gib": 32.5, + "root": "ce29cb0ef6caa97854e35b96ab77ac89350793cdc9831e642733ddeac723108b", + "configuration": "fixed, defaults, host lookups (same-day repeat alongside the main runs)" + }, + { + "label": "main-rec", + "exit": 0, + "wall_seconds": 60.6, + "peak_rss_gib": 22.7, + "sampled_gpu_peak_gib": 50.8, + "root": "a5ee668351d932bf24893ac6258861ccb348c0a79df2b50925e9107374d80666", + "configuration": "origin/main 7a313fdf built with IX_CUDA_TRACE_CODEGEN=1; AIUR_TRACE_ONLY_LOOKUPS=1 AIUR_MAX_PIECE_LOG_HEIGHT=24 AIUR_TRACE_SHARD_MAX_CELLS=1500000000 AIUR_GPU_TRACE=generated, --exec-jobs 2" + }, + { + "label": "formal-gpu-ram96", + "exit": 1, + "wall_seconds": 153.2, + "peak_rss_gib": 42.2, + "sampled_gpu_peak_gib": 17.7, + "root": null, + "configuration": "fixed shard sizing, CPU memory model on CUDA, --max-ram 96, host lookups: root wrap 5.5e9 cells exceeds the 51 GB lane" + }, + { + "label": "formal-gpu-ram96-graph", + "exit": 1, + "wall_seconds": 128.3, + "peak_rss_gib": 31.3, + "sampled_gpu_peak_gib": 17.7, + "root": null, + "configuration": "as formal-gpu-ram96, AIUR_TRACE_ONLY_LOOKUPS=1" + }, + { + "label": "formal-gpu-ram96-fixed2", + "exit": 0, + "wall_seconds": 75.3, + "peak_rss_gib": 40.2, + "sampled_gpu_peak_gib": 32.5, + "root": "5113efa2918af7153de0b47a059dd092e8b136498616efae2e4818fdda8e238c", + "configuration": "CUDA host-memory model, --max-ram 96, host lookups (root join planned as four shards)" + }, + { + "label": "formal-plan-host", + "exit": 0, + "wall_seconds": 73.6, + "peak_rss_gib": 45.7, + "sampled_gpu_peak_gib": 32.5, + "root": "ce29cb0ef6caa97854e35b96ab77ac89350793cdc9831e642733ddeac723108b", + "configuration": "CUDA host-memory model, --max-ram 160, host lookups" + }, + { + "label": "formal-plan-graph", + "exit": 0, + "wall_seconds": 66.2, + "peak_rss_gib": 26.6, + "sampled_gpu_peak_gib": 32.5, + "root": "ce29cb0ef6caa97854e35b96ab77ac89350793cdc9831e642733ddeac723108b", + "configuration": "CUDA host-memory model, --max-ram 160, AIUR_TRACE_ONLY_LOOKUPS=1" + }, + { + "label": "formal-plan-graph2", + "exit": 0, + "wall_seconds": 66.6, + "peak_rss_gib": 26.7, + "sampled_gpu_peak_gib": 32.5, + "root": "ce29cb0ef6caa97854e35b96ab77ac89350793cdc9831e642733ddeac723108b", + "configuration": "repeat of formal-plan-graph" + }, + { + "label": "formal-newdefault", + "exit": 0, + "wall_seconds": 66.0, + "peak_rss_gib": 26.7, + "sampled_gpu_peak_gib": 32.5, + "root": "ce29cb0ef6caa97854e35b96ab77ac89350793cdc9831e642733ddeac723108b", + "configuration": "device lookups by default with multi-stark fallback, shared workspace, CUDA host model" + }, + { + "label": "formal-newdefault-host", + "exit": 0, + "wall_seconds": 73.3, + "peak_rss_gib": 45.8, + "sampled_gpu_peak_gib": 32.5, + "root": "ce29cb0ef6caa97854e35b96ab77ac89350793cdc9831e642733ddeac723108b", + "configuration": "as formal-newdefault with AIUR_TRACE_ONLY_LOOKUPS=0" + }, + { + "label": "formal-2lanes-shared", + "exit": 0, + "wall_seconds": 56.6, + "peak_rss_gib": 33.3, + "sampled_gpu_peak_gib": 64.1, + "root": "ce29cb0ef6caa97854e35b96ab77ac89350793cdc9831e642733ddeac723108b", + "configuration": "--lanes 2 --max-ram 96 with IX_PROVER_SHARED_DEVICES=1 (both lanes on device 0)" + }, + { + "label": "formal-gputrace", + "exit": 0, + "wall_seconds": 66.0, + "peak_rss_gib": 14.0, + "sampled_gpu_peak_gib": 28.0, + "root": "ce29cb0ef6caa97854e35b96ab77ac89350793cdc9831e642733ddeac723108b", + "configuration": "AIUR_GPU_TRACE=generated" + }, + { + "label": "formal-elsewhere", + "exit": 0, + "wall_seconds": 70.6, + "peak_rss_gib": null, + "sampled_gpu_peak_gib": null, + "root": "ce29cb0ef6caa97854e35b96ab77ac89350793cdc9831e642733ddeac723108b", + "configuration": "run from an unrelated directory without IX_* artifact overrides, after ix prepare --cuda" + } + ], + "cpu_runs": [ + { + "label": "cpu-default", + "exit": 1, + "wall_seconds": 184.6, + "peak_rss_gib": 46.0, + "root": null, + "configuration": "ix prove --aggregate --jobs 2 --exec-jobs 4 --max-ram 192 --no-index --no-cache, former 65536-row default: first joins plan 256 shards / 121 GB against 51 GB" + }, + { + "label": "cpu-4m", + "exit": 1, + "wall_seconds": 316.2, + "peak_rss_gib": 85.9, + "root": null, + "configuration": "as cpu-default with --shard-rows 4194304 (documented recipe): wraps 8 shards, joins 8, next join 32, root wrap 5.5e9 cells exceeds the 51 GB lane" + }, + { + "label": "cpu-auto-j1", + "exit": 0, + "wall_seconds": 199.0, + "peak_rss_gib": 67.4, + "root": "ce29cb0ef6caa97854e35b96ab77ac89350793cdc9831e642733ddeac723108b", + "configuration": "--jobs 1 --exec-jobs 4 --max-ram 192, new automatic default" + }, + { + "label": "cpu-borrow-j2", + "exit": 0, + "wall_seconds": 199.6, + "peak_rss_gib": 69.1, + "root": "ce29cb0ef6caa97854e35b96ab77ac89350793cdc9831e642733ddeac723108b", + "configuration": "--jobs 2 --exec-jobs 4 --max-ram 192 with the shared workspace (recursive jobs borrow it)" + } + ], + "host_memory_calibration": { + "workload": "large recursive verifier, standalone CUDA stark-verifier, peak RSS of the whole process", + "rows": [ + { + "shards": 1, + "lookups": "host", + "retention": "retain", + "planned_before_gib": 76.4, + "planned_now_gib": 42.7, + "measured_gib": 25.0 + }, + { + "shards": 1, + "lookups": "device", + "retention": "retain", + "planned_before_gib": 76.5, + "planned_now_gib": 15.2, + "measured_gib": 10.5 + }, + { + "shards": 1, + "lookups": "host", + "retention": "regenerate", + "planned_before_gib": null, + "planned_now_gib": 51.7, + "measured_gib": 33.0 + }, + { + "shards": 8, + "lookups": "host", + "retention": "regenerate", + "planned_before_gib": 46.4, + "planned_now_gib": 48.6, + "measured_gib": 31.6 + }, + { + "shards": 8, + "lookups": "device", + "retention": "regenerate", + "planned_before_gib": 46.4, + "planned_now_gib": 23.3, + "measured_gib": 14.7 + } + ] + }, + "device_pressure": { + "workload": "large recursive verifier, one shard, MULTI_STARK_CUDA_MIN_FREE_BYTES held free", + "rows": [ + { + "min_free_gb": 85, + "lookups": "device", + "before": "abort (exit 134)", + "after_seconds": 12.0, + "proof": "identical" + }, + { + "min_free_gb": 85, + "lookups": "device", + "retention": "regenerate", + "after_seconds": 14.1, + "proof": "identical" + }, + { + "min_free_gb": 93, + "lookups": "device", + "after_seconds": 14.6, + "proof": "identical" + }, + { + "min_free_gb": 85, + "lookups": "host", + "seconds": 6.8, + "proof": "identical" + } + ] + } +} diff --git a/docs/benchmarks/formal-aiur-gpu-validation/prover.csv b/docs/benchmarks/formal-aiur-gpu-validation/prover.csv new file mode 100644 index 000000000..d3e42c0c2 --- /dev/null +++ b/docs/benchmarks/formal-aiur-gpu-validation/prover.csv @@ -0,0 +1,25 @@ +workload,variant,samples,proof_seconds_median,proof_seconds_min,proof_seconds_max,trace_seconds_median,peak_rss_gib,sampled_gpu_peak_gib,proof_bytes +environment,formal-cpu,3,1.8542,1.8532,1.8746,0.0884,2.66,,6557454 +environment,formal-gpu,3,0.4931,0.4743,0.5098,0.083,2.06,2.51,6557454 +environment,formal-gpu-graph,3,0.4399,0.4247,0.443,0.0365,1.23,2.51,6557454 +environment,legacy-cpu,3,1.8451,1.7851,1.9372,0.0498,2.6,,6854018 +environment,legacy-gpu,3,0.4122,0.4079,0.4144,0.0658,1.99,2.85,6854018 +environment,legacy-gpu-graph,3,0.4658,0.4651,0.4678,0.0488,1.15,2.85,6854018 +frontier,formal-cpu,3,0.3342,0.2592,0.3775,0.0058,0.55,,5478175 +frontier,formal-gpu,3,0.1828,0.1801,0.1844,0.0057,0.67,0.92,5478175 +frontier,formal-gpu-graph,3,0.1787,0.178,0.1803,0.0029,0.56,0.92,5478175 +frontier,legacy-cpu,3,0.2501,0.2501,0.2532,0.0135,0.41,,5669347 +frontier,legacy-gpu,3,0.1986,0.1985,0.2015,0.0132,0.49,0.92,5669347 +frontier,legacy-gpu-graph,3,0.2026,0.1967,0.2049,0.0036,0.39,0.92,5669347 +recursion,formal-cpu,3,0.1572,0.1496,0.224,0.0046,0.32,,2972473 +recursion,formal-gpu,3,0.092,0.0906,0.0926,0.0049,0.44,0.92,2972473 +recursion,formal-gpu-graph,3,0.0905,0.0896,0.0908,0.003,0.35,0.92,2972473 +recursion,legacy-cpu,3,0.1734,0.1563,0.2,0.0135,0.34,,3446443 +recursion,legacy-gpu,3,0.1056,0.1029,0.1057,0.0134,0.43,0.92,3446443 +recursion,legacy-gpu-graph,3,0.1017,0.0991,0.1034,0.0027,0.35,0.7,3446443 +recursion_real,formal-cpu,3,23.8554,23.7969,23.9691,1.6955,46.2,,3165439 +recursion_real,formal-gpu,3,4.1722,4.1255,4.1828,1.7036,27.8,32.77,3165439 +recursion_real,formal-gpu-graph,3,2.7242,2.7049,2.7523,0.8514,10.78,32.81,3165439 +recursion_real,legacy-cpu,3,27.4238,27.3675,27.4894,1.0886,40.23,,3707335 +recursion_real,legacy-gpu,3,3.4115,3.3985,3.4299,1.088,24.43,36.46,3707335 +recursion_real,legacy-gpu-graph,3,4.0115,3.9897,4.0186,0.6628,11.28,36.46,3707335 diff --git a/docs/benchmarks/formal-aiur-grouping-tuning/circuits.csv b/docs/benchmarks/formal-aiur-grouping-tuning/circuits.csv new file mode 100644 index 000000000..fbdfa06fd --- /dev/null +++ b/docs/benchmarks/formal-aiur-grouping-tuning/circuits.csv @@ -0,0 +1,1113 @@ +workload,variant,cells,fft_cost,height,index,lookup_group_size,lookups,name,preprocessed_height,preprocessed_width,quotient_degree,stage1_width,stage2_width +ixvm,baseline,10,48.0,1,0,1,2,IxVM::verify_claim,0,0,1,10,4 +ixvm,baseline,1624,18600.0,8,1,1,25,ixvm_group_07,0,0,2,203,50 +ixvm,baseline,112,2944.0,16,2,1,3,IxVM::read_finite_byte_stream,0,0,1,7,6 +ixvm,baseline,45056,3440640.0,4096,3,1,4,IxVM::read_byte_stream,0,0,2,11,8 +ixvm,baseline,36864,2818048.0,4096,4,1,4,"${""name"":""IxVM::list_depth_checked"",""types"":[""field""]}",0,0,1,9,8 +ixvm,baseline,4096,311296.0,1024,5,1,2,IxVM::checked_depth_succ,0,0,1,4,4 +ixvm,baseline,69632,3538944.0,2048,6,1,7,ixvm_group_00,0,0,2,34,14 +ixvm,baseline,30464,727296.0,128,7,1,14,ixvm_group_08,0,0,2,238,28 +ixvm,baseline,256512,10111488.0,512,8,2,226,Blake3::compress,0,0,2,501,226 +ixvm,baseline,69632,4030464.0,4096,9,2,6,Blake3::compress_chunks,0,0,2,17,6 +ixvm,baseline,608,12384.0,32,10,1,1,UInt64::is_zero,0,0,2,19,2 +ixvm,baseline,8384,303232.0,64,11,1,65,Blake3::bytes_to_block,0,0,1,131,130 +ixvm,baseline,16384,1105920.0,2048,12,2,3,Blake3::pad_block,0,0,2,8,4 +ixvm,baseline,5760,111744.0,32,13,1,24,Blake3::compress_block,0,0,2,180,48 +ixvm,baseline,224,6368.0,32,14,1,2,"${""name"":""Lists::is_empty"",""types"":[""field""]}",0,0,1,7,4 +ixvm,baseline,0,0.0,0,15,1,3,ixvm_group_02,0,0,2,56,6 +ixvm,baseline,11776,517632.0,512,16,1,5,IxVM::get_tagn4,0,0,2,23,10 +ixvm,baseline,704,17408.0,32,17,1,6,IxVM::get_tagn_tail,0,0,1,22,12 +ixvm,baseline,0,0.0,0,18,1,5,IxVM::get_tagn_wide,0,0,2,28,10 +ixvm,baseline,0,0.0,0,19,1,3,IxVM::get_u64_le,0,0,2,17,6 +ixvm,baseline,256,3120.0,4,20,1,30,ixvm_group_03,0,0,2,64,60 +ixvm,baseline,2816,92928.0,128,21,1,4,ixvm_group_24,0,0,2,22,8 +ixvm,baseline,4352,159232.0,64,22,1,34,IxVM::get_address,0,0,1,68,68 +ixvm,baseline,176,1440.0,4,23,1,5,ixvm_group_23,0,0,2,44,10 +ixvm,baseline,0,0.0,0,24,1,12,IxVM::run_eval,0,0,1,22,24 +ixvm,baseline,720,12288.0,16,25,1,7,ixvm_group_34,0,0,2,45,14 +ixvm,baseline,4224,81984.0,32,26,1,17,ixvm_group_01,0,0,2,132,34 +ixvm,baseline,3264,57024.0,32,27,1,6,ixvm_group_33,0,0,2,102,12 +ixvm,baseline,3680,65184.0,32,28,1,8,ixvm_group_05,0,0,2,115,16 +ixvm,baseline,2976,54624.0,32,29,1,8,ixvm_group_06,0,0,2,93,16 +ixvm,baseline,1216,28224.0,32,30,1,8,ixvm_group_31,0,0,2,38,16 +ixvm,baseline,1344,25344.0,32,31,1,3,ixvm_group_30,0,0,2,42,6 +ixvm,baseline,4352,166912.0,256,32,1,4,IxVM::get_tagn0,0,0,1,17,8 +ixvm,baseline,24576,1056768.0,512,33,1,12,IxVM::get_expr,0,0,2,48,24 +ixvm,baseline,4224,133248.0,128,34,1,6,IxVM::get_u64_list,0,0,2,33,12 +ixvm,baseline,1856,43392.0,64,35,1,2,ixvm_group_04,0,0,2,29,4 +ixvm,baseline,6912,252928.0,256,36,1,6,IxVM::get_app_telescope,0,0,1,27,12 +ixvm,baseline,6656,195072.0,128,37,1,8,ixvm_group_26,0,0,2,52,16 +ixvm,baseline,512,12608.0,32,38,1,4,IxVM::get_lam_mode,0,0,1,16,8 +ixvm,baseline,15,63.0,1,39,1,2,IxVM::binder_contract_from_bits,0,0,1,15,4 +ixvm,baseline,8,36.0,1,40,1,1,IxVM::value_contract_from_bits,0,0,1,8,2 +ixvm,baseline,576,14528.0,32,41,1,5,IxVM::get_all_mode,0,0,1,18,10 +ixvm,baseline,452,3624.0,4,42,1,16,ixvm_group_19,0,0,2,113,32 +ixvm,baseline,1328,20352.0,16,43,1,9,ixvm_group_35,0,0,2,83,18 +ixvm,baseline,0,0.0,0,44,1,11,ixvm_group_32,0,0,2,103,22 +ixvm,baseline,1568,34464.0,32,45,1,9,ixvm_group_25,0,0,2,49,18 +ixvm,baseline,1664,49152.0,64,46,1,6,IxVM::get_expr_list,0,0,2,26,12 +ixvm,baseline,1664,49152.0,64,47,1,6,IxVM::get_address_list,0,0,2,26,12 +ixvm,baseline,2048,42624.0,32,48,1,10,ixvm_group_28,0,0,2,64,20 +ixvm,baseline,3200,61824.0,32,49,1,12,ixvm_group_27,0,0,2,100,24 +ixvm,baseline,288,3056.0,8,50,1,2,IxVM::load_constant_hint,0,0,1,36,4 +ixvm,baseline,2656,48864.0,32,51,1,7,ixvm_group_11,0,0,2,83,14 +ixvm,baseline,20992,1153536.0,512,52,1,19,IxVM::convert_expr,0,0,2,41,38 +ixvm,baseline,896,40832.0,128,53,1,3,"${""name"":""IxVM::list_lookup"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Univ""}}}}]}",0,0,1,7,6 +ixvm,baseline,2304,119808.0,256,54,1,3,"${""name"":""IxVM::list_drop"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Univ""}}}}]}",0,0,2,9,6 +ixvm,baseline,688,12288.0,16,55,1,8,ixvm_group_64,0,0,2,43,16 +ixvm,baseline,352,4992.0,8,56,1,10,ixvm_group_55,0,0,2,44,20 +ixvm,baseline,72,378.0,1,57,1,25,ixvm_group_56,0,0,2,72,50 +ixvm,baseline,288,3552.0,8,58,1,4,ixvm_group_14,0,0,2,36,8 +ixvm,baseline,328,2640.0,4,59,1,11,ixvm_group_36,0,0,2,82,22 +ixvm,baseline,156,1272.0,4,60,1,4,ixvm_group_39,0,0,2,39,8 +ixvm,baseline,0,0.0,0,61,1,31,ixvm_group_59,0,0,2,194,62 +ixvm,baseline,6336,140160.0,64,62,1,9,ixvm_group_12,0,0,2,99,18 +ixvm,baseline,912,14592.0,16,63,1,7,ixvm_group_47,0,0,2,57,14 +ixvm,baseline,260,2184.0,4,64,1,10,ixvm_group_20,0,0,2,65,20 +ixvm,baseline,720,8448.0,8,65,1,11,ixvm_group_22,0,0,2,90,22 +ixvm,baseline,92,808.0,4,66,1,4,"${""name"":""IxVM::list_length_u64"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Expr""}}}}]}",0,0,1,23,8 +ixvm,baseline,0,0.0,0,67,1,9,IxVM::put_tagn_tail,0,0,1,30,18 +ixvm,baseline,0,0.0,0,68,1,6,IxVM::put_tagn_wide,0,0,2,30,12 +ixvm,baseline,424,5208.0,8,69,1,7,ixvm_group_10,0,0,2,53,14 +ixvm,baseline,2624,44352.0,16,70,1,31,ixvm_group_09,0,0,2,164,62 +ixvm,baseline,0,0.0,0,71,1,13,ixvm_group_18,0,0,2,93,26 +ixvm,baseline,0,0.0,0,72,1,6,ixvm_group_13,0,0,2,69,12 +ixvm,baseline,7808,173568.0,64,73,1,12,ixvm_group_16,0,0,2,122,24 +ixvm,baseline,0,0.0,0,74,1,4,IxVM::put_lam_mode,0,0,1,9,8 +ixvm,baseline,0,0.0,0,75,1,2,IxVM::binder_contract_code,0,0,1,10,4 +ixvm,baseline,0,0.0,0,76,1,1,IxVM::value_contract_code,0,0,1,8,2 +ixvm,baseline,26112,932352.0,512,77,1,6,ixvm_group_15,0,0,2,51,12 +ixvm,baseline,3584,123264.0,32,78,1,70,ixvm_group_17,0,0,2,112,140 +ixvm,baseline,6304,132384.0,32,79,1,37,ixvm_group_21,0,0,2,197,74 +ixvm,baseline,2048,69888.0,64,80,1,12,IxVM::validate_expr_well_scoped,0,0,2,32,24 +ixvm,baseline,180,1800.0,4,81,1,12,ixvm_group_48,0,0,2,45,24 +ixvm,baseline,368,5760.0,16,82,1,1,ixvm_group_79,0,0,2,23,2 +ixvm,baseline,512,21504.0,64,83,1,3,"${""name"":""IxVM::list_length"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KLevelNode""}}}}]}",0,0,2,8,6 +ixvm,baseline,72,1400.0,8,84,1,4,IxVM::k_ensure_sort,0,0,1,9,8 +ixvm,baseline,256,9024.0,32,85,2,5,IxVM::k_infer,0,0,2,8,6 +ixvm,baseline,2432,111744.0,128,86,1,9,IxVM::expr_lbr,0,0,2,19,18 +ixvm,baseline,1056,40224.0,32,87,1,23,IxVM::k_infer_core,0,0,2,33,46 +ixvm,baseline,6,42.0,1,88,1,3,IxVM::types_lookup,0,0,1,6,6 +ixvm,baseline,176,3840.0,16,89,2,4,IxVM::expr_lift,0,0,2,11,4 +ixvm,baseline,20,114.0,1,90,1,7,IxVM::expr_lift_walk,0,0,2,20,14 +ixvm,baseline,0,0.0,0,91,1,13,ixvm_group_61,0,0,2,52,26 +ixvm,baseline,160,1632.0,4,92,1,11,ixvm_group_38,0,0,2,40,22 +ixvm,baseline,320,6336.0,16,93,1,4,ixvm_group_70,0,0,2,20,8 +ixvm,baseline,16,84.0,1,94,1,4,ixvm_group_57,0,0,2,16,8 +ixvm,baseline,928,23904.0,32,95,1,8,ixvm_group_65,0,0,2,29,16 +ixvm,baseline,640,21504.0,64,96,2,3,IxVM::expr_inst_levels,0,0,2,10,4 +ixvm,baseline,1280,46848.0,64,97,1,8,IxVM::expr_inst_levels_walk,0,0,2,20,16 +ixvm,baseline,608,17184.0,32,98,1,6,ixvm_group_71,0,0,2,19,12 +ixvm,baseline,704,29568.0,64,99,1,5,IxVM::collect_spine,0,0,2,11,10 +ixvm,baseline,640,28416.0,64,100,1,5,"${""name"":""IxVM::list_snoc"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",0,0,2,10,10 +ixvm,baseline,960,33024.0,32,101,1,17,IxVM::k_infer_app_spine_loop,0,0,2,30,34 +ixvm,baseline,960,31872.0,64,102,2,7,IxVM::expr_inst_many,0,0,2,15,8 +ixvm,baseline,1344,48000.0,64,103,1,8,IxVM::has_bvar_in_range,0,0,2,21,16 +ixvm,baseline,48,576.0,4,104,1,3,ixvm_group_72,0,0,2,12,6 +ixvm,baseline,1280,44544.0,64,105,1,7,IxVM::expr_inst_many_walk,0,0,2,20,14 +ixvm,baseline,320,11648.0,32,106,1,6,IxVM::expr_inst_many_bvar,0,0,1,10,12 +ixvm,baseline,208,2208.0,4,107,1,17,ixvm_group_68,0,0,2,52,34 +ixvm,baseline,352,9504.0,32,108,2,4,IxVM::expr_lower,0,0,2,11,4 +ixvm,baseline,352,7872.0,16,109,1,7,IxVM::expr_lower_walk,0,0,2,22,14 +ixvm,baseline,112,2944.0,16,110,1,3,IxVM::k_check,0,0,1,7,6 +ixvm,baseline,352,11424.0,32,111,2,7,IxVM::k_is_def_eq,0,0,2,11,8 +ixvm,baseline,800,21024.0,32,112,1,7,ixvm_group_81,0,0,2,25,14 +ixvm,baseline,352,10464.0,32,113,1,3,ixvm_group_75,0,0,2,11,6 +ixvm,baseline,1024,23424.0,32,114,2,11,IxVM::try_def_eq_app,0,0,2,32,12 +ixvm,baseline,576,13824.0,32,115,2,5,IxVM::de_args,0,0,2,18,6 +ixvm,baseline,4544,91776.0,64,116,2,4,IxVM::address_eq,0,0,2,71,4 +ixvm,baseline,424,5208.0,8,117,1,7,ixvm_group_67,0,0,2,53,14 +ixvm,baseline,296,4056.0,8,118,1,7,ixvm_group_51,0,0,2,37,14 +ixvm,baseline,122,630.0,2,119,1,18,ixvm_group_53,0,0,2,61,36 +ixvm,baseline,0,0.0,0,120,1,33,ixvm_group_49,0,0,2,83,66 +ixvm,baseline,680,9960.0,8,121,1,24,ixvm_group_66,0,0,2,85,48 +ixvm,baseline,17408,605184.0,256,122,1,13,ixvm_group_50,0,0,2,68,26 +ixvm,baseline,224,4800.0,16,123,2,5,IxVM::try_string_lit_one,0,0,2,14,6 +ixvm,baseline,88,816.0,4,124,2,6,IxVM::whnf_nd,0,0,2,22,6 +ixvm,baseline,160,2688.0,8,125,2,11,IxVM::whnf_nd_with_spine,0,0,2,20,12 +ixvm,baseline,640,23296.0,64,126,1,4,"${""name"":""IxVM::list_concat"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",0,0,1,10,8 +ixvm,baseline,16,90.0,1,127,2,10,IxVM::whnf_nd_apply_beta,0,0,2,16,10 +ixvm,baseline,72,720.0,4,128,2,5,IxVM::peel_beta,0,0,2,18,6 +ixvm,baseline,80,1472.0,8,129,1,4,IxVM::apply_spine,0,0,1,10,8 +ixvm,baseline,192,4416.0,16,130,2,6,IxVM::expr_inst1,0,0,2,12,6 +ixvm,baseline,736,19104.0,32,131,1,6,IxVM::expr_has_bvar_at,0,0,2,23,12 +ixvm,baseline,160,2832.0,8,132,1,7,IxVM::expr_inst1_walk,0,0,2,20,14 +ixvm,baseline,57,321.0,1,133,1,23,IxVM::whnf_nd_const_head,0,0,2,57,46 +ixvm,baseline,95,525.0,1,134,1,38,ixvm_group_77,0,0,2,95,76 +ixvm,baseline,288,5184.0,16,135,1,2,ixvm_group_43,0,0,2,18,4 +ixvm,baseline,288,5184.0,16,136,1,2,ixvm_group_46,0,0,2,18,4 +ixvm,baseline,288,5184.0,16,137,1,2,ixvm_group_45,0,0,2,18,4 +ixvm,baseline,22,108.0,1,138,2,10,IxVM::try_prim_dispatch,0,0,2,22,10 +ixvm,baseline,176,2400.0,8,139,2,6,IxVM::whnf,0,0,2,22,6 +ixvm,baseline,80,912.0,4,140,2,11,IxVM::whnf_with_spine,0,0,2,20,12 +ixvm,baseline,16,90.0,1,141,2,10,IxVM::whnf_apply_beta,0,0,2,16,10 +ixvm,baseline,0,0.0,0,142,1,21,IxVM::whnf_const_head,0,0,2,51,42 +ixvm,baseline,168,3048.0,8,143,1,8,ixvm_group_74,0,0,2,21,16 +ixvm,baseline,0,0.0,0,144,1,8,ixvm_group_41,0,0,2,64,16 +ixvm,baseline,0,0.0,0,145,1,45,ixvm_group_42,0,0,2,79,90 +ixvm,baseline,0,0.0,0,146,1,19,ixvm_group_52,0,0,2,84,38 +ixvm,baseline,0,0.0,0,147,1,26,ixvm_group_63,0,0,2,89,52 +ixvm,baseline,20,156.0,2,148,1,4,"${""name"":""IxVM::list_take"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",0,0,2,10,8 +ixvm,baseline,0,0.0,0,149,1,14,ixvm_group_40,0,0,2,53,28 +ixvm,baseline,0,0.0,0,150,1,2,IxVM::klimbs_add,0,0,1,5,4 +ixvm,baseline,0,0.0,0,151,1,9,IxVM::klimbs_add_carry,0,0,2,50,18 +ixvm,baseline,0,0.0,0,152,1,7,IxVM::klimbs_normalize,0,0,2,30,14 +ixvm,baseline,0,0.0,0,153,1,15,ixvm_group_37,0,0,2,80,30 +ixvm,baseline,288,3744.0,4,154,1,39,ixvm_group_80,0,0,2,72,78 +ixvm,baseline,0,0.0,0,155,1,6,ixvm_group_69,0,0,2,24,12 +ixvm,baseline,54,318.0,2,156,1,9,ixvm_group_73,0,0,2,27,18 +ixvm,baseline,0,0.0,0,157,1,13,ixvm_group_76,0,0,2,41,26 +ixvm,baseline,0,0.0,0,158,1,2,ixvm_group_54,0,0,2,9,4 +ixvm,baseline,1104,18432.0,16,159,1,11,ixvm_group_58,0,0,2,69,22 +ixvm,baseline,0,0.0,0,160,1,5,IxVM::split_u32,0,0,1,11,10 +ixvm,baseline,0,0.0,0,161,1,3,IxVM::divmod_256,0,0,1,8,6 +ixvm,baseline,0,0.0,0,162,1,2,ixvm_group_44,0,0,2,18,4 +ixvm,baseline,0,0.0,0,163,1,6,IxVM::klimbs_mul_outer,0,0,1,21,12 +ixvm,baseline,0,0.0,0,164,1,10,IxVM::klimbs_mul_single,0,0,2,68,20 +ixvm,baseline,0,0.0,0,165,2,3,IxVM::klimbs_shl_limbs,0,0,2,8,4 +ixvm,baseline,0,0.0,0,166,2,6,IxVM::ordinary_div_mod,0,0,2,11,6 +ixvm,baseline,0,0.0,0,167,1,9,IxVM::divide_grow,0,0,2,16,18 +ixvm,baseline,0,0.0,0,168,1,4,IxVM::utf8_groups,0,0,1,9,8 +ixvm,baseline,0,0.0,0,169,2,3,IxVM::divmod_64u,0,0,2,9,4 +ixvm,baseline,0,0.0,0,170,1,12,ixvm_group_60,0,0,2,71,24 +ixvm,baseline,0,0.0,0,171,1,10,ixvm_group_62,0,0,2,59,20 +ixvm,baseline,352,6336.0,16,172,2,6,IxVM::whnf_struct_core,0,0,2,22,6 +ixvm,baseline,200,4776.0,8,173,1,18,IxVM::whnf_struct_core_spine,0,0,2,25,36 +ixvm,baseline,33,153.0,1,174,1,7,ixvm_group_78,0,0,2,33,14 +ixvm,baseline,26,162.0,2,175,2,5,IxVM::is_nat_zero,0,0,2,13,6 +ixvm,baseline,72,444.0,2,176,1,15,IxVM::nat_offset_of,0,0,2,36,30 +ixvm,baseline,48,240.0,2,177,2,8,IxVM::lazy_delta_loop,0,0,2,24,8 +ixvm,baseline,24,168.0,2,178,1,4,IxVM::head_addr,0,0,2,12,8 +ixvm,baseline,68,312.0,2,179,1,5,ixvm_group_82,0,0,2,34,10 +ixvm,baseline,43,213.0,1,180,1,12,IxVM::k_is_def_eq_struct_bounded,0,0,2,43,24 +ixvm,baseline,288,7104.0,16,181,2,13,IxVM::k_def_eq_rebase,0,0,2,18,14 +ixvm,baseline,576,20352.0,64,182,2,4,IxVM::expr_glb,0,0,2,9,4 +ixvm,baseline,1408,51456.0,64,183,1,9,IxVM::expr_glb_walk,0,0,2,22,18 +ixvm,baseline,80,1392.0,8,184,2,4,IxVM::expr_glb_binder,0,0,2,10,4 +ixvm,baseline,0,0.0,0,185,1,7,IxVM::k_infer_let_start,0,0,1,11,14 +ixvm,baseline,0,0.0,0,186,1,10,IxVM::k_infer_let_env,0,0,2,20,20 +ixvm,baseline,0,0.0,0,187,1,3,IxVM::infer_let_local_cutoff,0,0,2,13,6 +ixvm,baseline,0,0.0,0,188,1,26,IxVM::k_infer_let_env_core,0,0,2,27,52 +ixvm,baseline,0,0.0,0,189,1,4,IxVM::infer_let_lookup_type,0,0,2,16,8 +ixvm,baseline,0,0.0,0,190,1,12,IxVM::infer_let_materialize,0,0,2,28,24 +ixvm,baseline,0,0.0,0,191,1,5,IxVM::infer_let_lookup_value,0,0,2,16,10 +ixvm,baseline,0,0.0,0,192,1,7,IxVM::k_infer_let_env_rebase,0,0,1,14,14 +ixvm,baseline,0,0.0,0,193,1,3,IxVM::infer_let_drop_unused,0,0,2,16,6 +ixvm,baseline,240,6144.0,16,194,2,11,IxVM::k_infer_rebase,0,0,2,15,12 +ixvm,baseline,1920,60672.0,64,195,1,9,IxVM::safe_refs_only,0,0,2,30,18 +ixvm,baseline,0,0.0,0,196,1,4,"${""name"":""IxVM::list_concat"",""types"":[{""tuple"":{""items"":[{""ptr"":{""target"":{""array"":{""element"":""field"",""length"":32}}}},""field""]}}]}",0,0,1,11,8 +ixvm,baseline,0,0.0,0,197,1,25,IxVM::canon_cmp_kexpr_node_ctx,0,0,2,61,50 +ixvm,baseline,0,0.0,0,198,1,5,"${""name"":""IxVM::list_snoc"",""types"":[{""tuple"":{""items"":[{""ptr"":{""target"":{""array"":{""element"":""field"",""length"":32}}}},""field"",{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}],""name"":""Lists::Node""}}}},{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KLevelNode""}}}}],""name"":""Lists::Node""}}}}]}}]}",0,0,2,16,10 +ixvm,baseline,0,0.0,0,199,1,3,"${""name"":""IxVM::list_length"",""types"":[{""tuple"":{""items"":[{""ptr"":{""target"":{""array"":{""element"":""field"",""length"":32}}}},""field"",{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}],""name"":""Lists::Node""}}}},{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KLevelNode""}}}}],""name"":""Lists::Node""}}}}]}}]}",0,0,2,11,6 +ixvm,baseline,0,0.0,0,200,1,3,"${""name"":""IxVM::list_lookup_or_default"",""types"":[""field""]}",0,0,2,10,6 +ixvm,baseline,0,0.0,0,201,2,5,IxVM::walk_refs_transitive,0,0,2,12,6 +ixvm,baseline,352,9504.0,32,202,2,3,IxVM::g_list_has,0,0,2,11,4 +ixvm,baseline,80,1760.0,8,203,1,6,IxVM::const_idxs_exprs,0,0,1,10,12 +ixvm,baseline,2176,72192.0,64,204,1,12,IxVM::const_idxs_expr,0,0,2,34,24 +ixvm,baseline,4816,61824.0,16,205,1,8,"${""name"":""IxVM::rbtree_map_balance_fix"",""types"":[""field""]}",0,0,2,301,16 +ixvm,baseline,0,0.0,0,206,1,4,IxVM::eval_body,0,0,2,19,8 +ixvm,baseline,0,0.0,0,207,1,7,IxVM::eval_output,0,0,1,58,14 +ixvm,baseline,0,0.0,0,208,1,8,IxVM::eval_nf,0,0,2,15,16 +ixvm,baseline,0,0.0,0,209,1,6,IxVM::eval_nf_spine,0,0,2,13,12 +ixvm,baseline,0,0.0,0,210,1,5,IxVM::walk_leaves_owned,0,0,1,39,10 +ixvm,baseline,0,0.0,0,211,1,3,IxVM::check_owned,0,0,1,35,6 +ixvm,baseline,0,0.0,0,212,1,8,IxVM::env_walk_all,0,0,2,89,16 +ixvm,baseline,0,0.0,0,213,2,6,IxVM::env_walk_refs_all,0,0,2,43,6 +ixvm,baseline,512,50176.0,256,214,1,2,,256,11,1,2,4 +ixvm,baseline,458752,60555264.0,65536,215,2,7,,65536,14,2,7,8 +ixvm,baseline,1024,157696.0,1024,216,1,1,,1024,3,1,1,2 +ixvm,baseline,0,0.0,0,217,1,3,,0,0,1,5,6 +ixvm,baseline,49152,4505600.0,8192,218,1,3,,0,0,1,6,6 +ixvm,baseline,3584,209408.0,512,219,1,3,,0,0,1,7,6 +ixvm,baseline,0,0.0,0,220,1,3,,0,0,1,8,6 +ixvm,baseline,288,8288.0,32,221,1,3,,0,0,1,9,6 +ixvm,baseline,11,57.0,1,222,1,3,,0,0,1,11,6 +ixvm,baseline,192,3904.0,16,223,1,3,,0,0,1,12,6 +ixvm,baseline,208,4096.0,16,224,1,3,,0,0,1,13,6 +ixvm,baseline,0,0.0,0,225,1,3,,0,0,1,14,6 +ixvm,baseline,240,4480.0,16,226,1,3,,0,0,1,15,6 +ixvm,baseline,10752,402944.0,512,227,1,3,,0,0,1,21,6 +ixvm,baseline,0,0.0,0,228,1,3,,0,0,1,22,6 +ixvm,baseline,4480,116096.0,128,229,1,3,,0,0,1,35,6 +ixvm,baseline,1184,21728.0,32,230,1,3,,0,0,1,37,6 +ixvm,baseline,156,1144.0,4,231,1,3,,0,0,1,39,6 +ixvm,baseline,200,1408.0,4,232,1,3,,0,0,1,50,6 +ixvm,baseline,0,0.0,0,233,1,3,,0,0,1,53,6 +ixvm,baseline,0,0.0,0,234,1,3,,0,0,1,67,6 +ixvm,selected,10,48.0,1,0,1,2,IxVM::verify_claim,0,0,1,10,4 +ixvm,selected,1768,19896.0,8,1,1,25,ixvm_group_00,0,0,2,221,50 +ixvm,selected,1728,50304.0,64,2,1,6,ixvm_group_01,0,0,2,27,12 +ixvm,selected,49152,3588096.0,4096,3,1,4,ixvm_group_02,0,0,2,12,8 +ixvm,selected,45056,3440640.0,4096,4,1,4,ixvm_group_03,0,0,2,11,8 +ixvm,selected,28672,2035712.0,2048,5,1,7,UInt32::less_than_fields,0,0,1,14,14 +ixvm,selected,4768,83424.0,32,6,1,10,ixvm_group_04,0,0,2,149,20 +ixvm,selected,256512,10111488.0,512,7,2,226,Blake3::compress,0,0,2,501,226 +ixvm,selected,69632,4030464.0,4096,8,2,6,Blake3::compress_chunks,0,0,2,17,6 +ixvm,selected,5568,99264.0,32,9,1,14,ixvm_group_05,0,0,2,174,28 +ixvm,selected,832,15744.0,32,10,1,1,ixvm_group_06,0,0,2,26,2 +ixvm,selected,9280,322176.0,64,11,1,65,ixvm_group_07,0,0,2,145,130 +ixvm,selected,5792,112224.0,32,12,1,24,ixvm_group_08,0,0,2,181,48 +ixvm,selected,224,6368.0,32,13,1,2,"${""name"":""Lists::is_empty"",""types"":[""field""]}",0,0,1,7,4 +ixvm,selected,0,0.0,0,14,1,7,ixvm_group_09,0,0,2,75,14 +ixvm,selected,13824,572928.0,512,15,1,5,ixvm_group_10,0,0,2,27,10 +ixvm,selected,864,21024.0,32,16,1,6,ixvm_group_11,0,0,2,27,12 +ixvm,selected,0,0.0,0,17,1,6,ixvm_group_12,0,0,2,71,12 +ixvm,selected,0,0.0,0,18,1,19,ixvm_group_13,0,0,2,92,38 +ixvm,selected,0,0.0,0,19,1,70,ixvm_group_14,0,0,2,140,140 +ixvm,selected,896,41856.0,128,20,1,2,ixvm_group_15,0,0,2,7,4 +ixvm,selected,4352,159232.0,64,21,1,34,IxVM::get_address,0,0,1,68,68 +ixvm,selected,164,1560.0,4,22,1,9,ixvm_group_16,0,0,2,41,18 +ixvm,selected,104,1248.0,4,23,1,10,ixvm_group_17,0,0,2,26,20 +ixvm,selected,1536,30912.0,16,24,1,30,ixvm_group_18,0,0,2,96,60 +ixvm,selected,3616,66144.0,32,25,1,10,ixvm_group_19,0,0,2,113,20 +ixvm,selected,1328,20352.0,16,26,1,9,ixvm_group_20,0,0,2,83,18 +ixvm,selected,266,1242.0,2,27,1,33,ixvm_group_21,0,0,2,133,66 +ixvm,selected,2048,62976.0,64,28,1,9,ixvm_group_22,0,0,2,32,18 +ixvm,selected,4928,63168.0,16,29,1,8,ixvm_group_23,0,0,2,308,16 +ixvm,selected,31232,1236480.0,512,30,1,12,ixvm_group_24,0,0,2,61,24 +ixvm,selected,640,13824.0,32,31,1,2,UInt64::saturating_pred,0,0,2,20,4 +ixvm,selected,7424,279552.0,256,32,1,6,ixvm_group_25,0,0,2,29,12 +ixvm,selected,2624,71040.0,64,33,1,8,ixvm_group_26,0,0,2,41,16 +ixvm,selected,1600,48000.0,64,34,1,6,ixvm_group_27,0,0,2,25,12 +ixvm,selected,196,2040.0,4,35,1,15,ixvm_group_28,0,0,2,49,30 +ixvm,selected,100,1128.0,4,36,1,8,ixvm_group_29,0,0,2,25,16 +ixvm,selected,2368,66432.0,64,37,1,8,ixvm_group_30,0,0,2,37,16 +ixvm,selected,21504,1167360.0,512,38,1,19,ixvm_group_31,0,0,2,42,38 +ixvm,selected,2144,43104.0,32,39,1,9,ixvm_group_32,0,0,2,67,18 +ixvm,selected,1792,28224.0,16,40,1,15,ixvm_group_33,0,0,2,112,30 +ixvm,selected,29,129.0,1,41,1,5,ixvm_group_34,0,0,2,29,10 +ixvm,selected,1280,18624.0,16,42,1,6,ixvm_group_35,0,0,2,80,12 +ixvm,selected,280,2496.0,4,43,1,14,ixvm_group_36,0,0,2,70,28 +ixvm,selected,296,2448.0,4,44,1,11,ixvm_group_37,0,0,2,74,22 +ixvm,selected,146,678.0,1,45,1,38,ixvm_group_38,0,0,2,146,76 +ixvm,selected,1792,51456.0,64,46,1,6,ixvm_group_39,0,0,2,28,12 +ixvm,selected,784,13440.0,16,47,1,8,ixvm_group_40,0,0,2,49,16 +ixvm,selected,832,19584.0,32,48,1,5,ixvm_group_41,0,0,2,26,10 +ixvm,selected,1232,17664.0,16,49,1,5,ixvm_group_42,0,0,2,77,10 +ixvm,selected,2752,76224.0,32,50,1,34,ixvm_group_43,0,0,2,86,68 +ixvm,selected,560,9600.0,16,51,1,5,ixvm_group_44,0,0,2,35,10 +ixvm,selected,896,40832.0,128,52,1,3,"${""name"":""IxVM::list_lookup"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Univ""}}}}]}",0,0,1,7,6 +ixvm,selected,2304,119808.0,256,53,1,3,"${""name"":""IxVM::list_drop"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Univ""}}}}]}",0,0,2,9,6 +ixvm,selected,400,8064.0,16,54,1,6,ixvm_group_45,0,0,2,25,12 +ixvm,selected,2304,74496.0,64,55,1,12,ixvm_group_46,0,0,2,36,24 +ixvm,selected,0,0.0,0,56,1,31,ixvm_group_47,0,0,2,204,62 +ixvm,selected,94,486.0,2,57,1,13,ixvm_group_48,0,0,2,47,26 +ixvm,selected,288,7488.0,16,58,1,8,ixvm_group_49,0,0,2,18,16 +ixvm,selected,176,3840.0,16,59,1,2,ixvm_group_50,0,0,2,11,4 +ixvm,selected,216,1824.0,4,60,1,8,ixvm_group_51,0,0,2,54,16 +ixvm,selected,368,7296.0,16,61,1,5,ixvm_group_52,0,0,2,23,10 +ixvm,selected,0,0.0,0,62,1,13,ixvm_group_53,0,0,2,90,26 +ixvm,selected,0,0.0,0,63,1,16,ixvm_group_54,0,0,2,101,32 +ixvm,selected,0,0.0,0,64,1,10,ixvm_group_55,0,0,2,63,20 +ixvm,selected,49,195.0,1,65,1,6,ixvm_group_56,0,0,2,49,12 +ixvm,selected,0,0.0,0,66,1,45,ixvm_group_57,0,0,2,82,90 +ixvm,selected,364,3864.0,4,67,1,32,ixvm_group_58,0,0,2,91,64 +ixvm,selected,80,456.0,2,68,1,14,ixvm_group_59,0,0,2,40,28 +ixvm,selected,3264,89472.0,64,69,1,11,ixvm_group_60,0,0,2,51,22 +ixvm,selected,200,3048.0,8,70,1,6,ixvm_group_61,0,0,2,25,12 +ixvm,selected,512,21504.0,64,71,1,3,"${""name"":""IxVM::list_length"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KLevelNode""}}}}]}",0,0,2,8,6 +ixvm,selected,88,1752.0,8,72,1,4,ixvm_group_62,0,0,2,11,8 +ixvm,selected,1536,53760.0,64,73,1,9,ixvm_group_63,0,0,2,24,18 +ixvm,selected,2688,117120.0,128,74,1,9,ixvm_group_64,0,0,2,21,18 +ixvm,selected,128,3264.0,16,75,1,2,ixvm_group_65,0,0,2,8,4 +ixvm,selected,1344,44544.0,32,76,1,23,ixvm_group_66,0,0,2,42,46 +ixvm,selected,1152,42240.0,64,77,1,7,ixvm_group_67,0,0,2,18,14 +ixvm,selected,704,19584.0,32,78,1,7,ixvm_group_68,0,0,2,22,14 +ixvm,selected,192,1632.0,4,79,1,7,ixvm_group_69,0,0,2,48,14 +ixvm,selected,104,1056.0,4,80,1,6,ixvm_group_70,0,0,2,26,12 +ixvm,selected,41,171.0,1,81,1,6,ixvm_group_71,0,0,2,41,12 +ixvm,selected,72,324.0,2,82,1,5,ixvm_group_72,0,0,2,36,10 +ixvm,selected,128,732.0,2,83,1,25,ixvm_group_73,0,0,2,64,50 +ixvm,selected,640,21504.0,64,84,2,3,IxVM::expr_inst_levels,0,0,2,10,4 +ixvm,selected,1408,49152.0,64,85,1,8,ixvm_group_74,0,0,2,22,16 +ixvm,selected,768,30720.0,64,86,1,5,ixvm_group_75,0,0,2,12,10 +ixvm,selected,832,31872.0,64,87,1,5,ixvm_group_76,0,0,2,13,10 +ixvm,selected,1024,33984.0,32,88,1,17,ixvm_group_77,0,0,2,32,34 +ixvm,selected,1344,48000.0,64,89,1,8,IxVM::has_bvar_in_range,0,0,2,21,16 +ixvm,selected,512,9792.0,16,90,1,7,ixvm_group_78,0,0,2,32,14 +ixvm,selected,0,0.0,0,91,1,25,ixvm_group_79,0,0,2,116,50 +ixvm,selected,1984,57216.0,64,92,1,7,ixvm_group_80,0,0,2,31,14 +ixvm,selected,288,8544.0,32,93,2,3,IxVM::k_is_def_eq_ordered,0,0,2,9,4 +ixvm,selected,1024,23424.0,32,94,2,11,IxVM::try_def_eq_app,0,0,2,32,12 +ixvm,selected,736,18144.0,32,95,1,5,ixvm_group_81,0,0,2,23,10 +ixvm,selected,4672,103296.0,64,96,1,6,ixvm_group_82,0,0,2,73,12 +ixvm,selected,552,7512.0,8,97,1,15,ixvm_group_83,0,0,2,69,30 +ixvm,selected,224,3840.0,8,98,1,10,ixvm_group_84,0,0,2,28,20 +ixvm,selected,0,0.0,0,99,1,17,ixvm_group_85,0,0,2,79,34 +ixvm,selected,65,351.0,1,100,1,24,ixvm_group_86,0,0,2,65,48 +ixvm,selected,0,0.0,0,101,1,13,ixvm_group_87,0,0,2,114,26 +ixvm,selected,31,165.0,1,102,1,10,ixvm_group_88,0,0,2,31,20 +ixvm,selected,48,240.0,2,103,1,4,ixvm_group_89,0,0,2,24,8 +ixvm,selected,480,15264.0,32,104,1,6,ixvm_group_90,0,0,2,15,12 +ixvm,selected,224,4800.0,16,105,2,5,IxVM::try_string_lit_one,0,0,2,14,6 +ixvm,selected,188,1560.0,4,106,1,6,ixvm_group_91,0,0,2,47,12 +ixvm,selected,160,2688.0,8,107,2,11,IxVM::whnf_nd_with_spine,0,0,2,20,12 +ixvm,selected,160,2832.0,8,108,1,7,IxVM::expr_inst1_walk,0,0,2,20,14 +ixvm,selected,288,5184.0,16,109,1,2,ixvm_group_92,0,0,2,18,4 +ixvm,selected,272,4992.0,16,110,1,2,ixvm_group_93,0,0,2,17,4 +ixvm,selected,80,1392.0,8,111,1,2,ixvm_group_94,0,0,2,10,4 +ixvm,selected,102,534.0,2,112,1,15,ixvm_group_95,0,0,2,51,30 +ixvm,selected,37,279.0,1,113,1,26,ixvm_group_96,0,0,2,37,52 +ixvm,selected,35,189.0,1,114,1,12,ixvm_group_97,0,0,2,35,24 +ixvm,selected,384,10560.0,16,115,1,13,ixvm_group_98,0,0,2,24,26 +ixvm,selected,0,0.0,0,116,1,21,ixvm_group_99,0,0,2,65,42 +ixvm,selected,192,1632.0,4,117,1,7,ixvm_group_100,0,0,2,48,14 +ixvm,selected,0,0.0,0,118,1,11,ixvm_group_101,0,0,2,73,22 +ixvm,selected,120,2616.0,8,119,1,8,ixvm_group_102,0,0,2,15,16 +ixvm,selected,36,156.0,1,120,1,6,ixvm_group_103,0,0,2,36,12 +ixvm,selected,0,0.0,0,121,1,21,ixvm_group_104,0,0,2,84,42 +ixvm,selected,0,0.0,0,122,1,8,ixvm_group_105,0,0,2,38,16 +ixvm,selected,0,0.0,0,123,1,18,ixvm_group_106,0,0,2,82,36 +ixvm,selected,0,0.0,0,124,1,2,ixvm_group_107,0,0,2,18,4 +ixvm,selected,224,4800.0,16,125,2,6,IxVM::k_is_def_eq_slow_nd,0,0,2,14,6 +ixvm,selected,352,6336.0,16,126,2,6,IxVM::whnf_struct_core,0,0,2,22,6 +ixvm,selected,164,1560.0,4,127,1,9,ixvm_group_108,0,0,2,41,18 +ixvm,selected,122,498.0,2,128,2,14,IxVM::try_eta_struct,0,0,2,61,14 +ixvm,selected,116,1224.0,4,129,1,8,ixvm_group_109,0,0,2,29,16 +ixvm,selected,26,162.0,2,130,2,5,IxVM::is_nat_zero,0,0,2,13,6 +ixvm,selected,43,213.0,1,131,1,12,IxVM::k_is_def_eq_struct_bounded,0,0,2,43,24 +ixvm,selected,304,8832.0,16,132,1,11,ixvm_group_110,0,0,2,19,22 +ixvm,selected,576,20352.0,64,133,2,4,IxVM::expr_glb,0,0,2,9,4 +ixvm,selected,80,1392.0,8,134,2,4,IxVM::expr_glb_binder,0,0,2,10,4 +ixvm,selected,240,6144.0,16,135,2,11,IxVM::k_infer_rebase,0,0,2,15,12 +ixvm,selected,2048,89088.0,256,136,2,2,IxVM::canon_ord_cmp_g,0,0,2,8,2 +ixvm,selected,2656,58208.0,32,137,1,18,IxVM::canon_addr_cmp,0,0,1,83,36 +ixvm,selected,2816,105472.0,256,138,1,2,IxVM::canon_addr_chunk,0,0,1,11,4 +ixvm,selected,0,0.0,0,139,1,21,ixvm_group_111,0,0,2,155,42 +ixvm,selected,352,9504.0,32,140,2,3,IxVM::g_list_has,0,0,2,11,4 +ixvm,selected,512,50176.0,256,141,1,2,,256,11,1,2,4 +ixvm,selected,458752,60555264.0,65536,142,2,7,,65536,14,2,7,8 +ixvm,selected,1024,157696.0,1024,143,1,1,,1024,3,1,1,2 +ixvm,selected,0,0.0,0,144,1,3,,0,0,1,5,6 +ixvm,selected,49152,4505600.0,8192,145,1,3,,0,0,1,6,6 +ixvm,selected,3584,209408.0,512,146,1,3,,0,0,1,7,6 +ixvm,selected,0,0.0,0,147,1,3,,0,0,1,8,6 +ixvm,selected,288,8288.0,32,148,1,3,,0,0,1,9,6 +ixvm,selected,11,57.0,1,149,1,3,,0,0,1,11,6 +ixvm,selected,192,3904.0,16,150,1,3,,0,0,1,12,6 +ixvm,selected,208,4096.0,16,151,1,3,,0,0,1,13,6 +ixvm,selected,0,0.0,0,152,1,3,,0,0,1,14,6 +ixvm,selected,240,4480.0,16,153,1,3,,0,0,1,15,6 +ixvm,selected,10752,402944.0,512,154,1,3,,0,0,1,21,6 +ixvm,selected,0,0.0,0,155,1,3,,0,0,1,22,6 +ixvm,selected,4480,116096.0,128,156,1,3,,0,0,1,35,6 +ixvm,selected,1184,21728.0,32,157,1,3,,0,0,1,37,6 +ixvm,selected,156,1144.0,4,158,1,3,,0,0,1,39,6 +ixvm,selected,200,1408.0,4,159,1,3,,0,0,1,50,6 +ixvm,selected,0,0.0,0,160,1,3,,0,0,1,53,6 +ixvm,selected,0,0.0,0,161,1,3,,0,0,1,67,6 +environment,baseline,10,48.0,1,0,1,2,IxVM::verify_claim,0,0,1,10,4 +environment,baseline,51968,1582080.0,256,1,1,25,ixvm_group_07,0,0,2,203,50 +environment,baseline,3584,209408.0,512,2,1,3,IxVM::read_finite_byte_stream,0,0,1,7,6 +environment,baseline,1441792,155320320.0,131072,3,1,4,IxVM::read_byte_stream,0,0,2,11,8 +environment,baseline,1179648,127533056.0,131072,4,1,4,"${""name"":""IxVM::list_depth_checked"",""types"":[""field""]}",0,0,1,9,8 +environment,baseline,65536,6946816.0,16384,5,1,2,IxVM::checked_depth_succ,0,0,1,4,4 +environment,baseline,557056,35979264.0,16384,6,1,7,ixvm_group_00,0,0,2,34,14 +environment,baseline,974848,39862272.0,4096,7,1,14,ixvm_group_08,0,0,2,238,28 +environment,baseline,16416768,1078296576.0,32768,8,2,226,Blake3::compress,0,0,2,501,226 +environment,baseline,2228224,182059008.0,131072,9,2,6,Blake3::compress_chunks,0,0,2,17,6 +environment,baseline,2432,68736.0,128,10,1,1,UInt64::is_zero,0,0,2,19,2 +environment,baseline,536576,38797312.0,4096,11,1,65,Blake3::bytes_to_block,0,0,1,131,130 +environment,baseline,524288,51118080.0,65536,12,2,3,Blake3::pad_block,0,0,2,8,4 +environment,baseline,368640,15704064.0,2048,13,1,24,Blake3::compress_block,0,0,2,180,48 +environment,baseline,14336,886784.0,2048,14,1,2,"${""name"":""Lists::is_empty"",""types"":[""field""]}",0,0,1,7,4 +environment,baseline,1792,32064.0,32,15,1,3,ixvm_group_02,0,0,2,56,6 +environment,baseline,753664,54951936.0,32768,16,1,5,IxVM::get_tagn4,0,0,2,23,10 +environment,baseline,45056,2441216.0,2048,17,1,6,IxVM::get_tagn_tail,0,0,1,22,12 +environment,baseline,0,0.0,0,18,1,5,IxVM::get_tagn_wide,0,0,2,28,10 +environment,baseline,0,0.0,0,19,1,3,IxVM::get_u64_le,0,0,2,17,6 +environment,baseline,65536,3944448.0,1024,20,1,30,ixvm_group_03,0,0,2,64,60 +environment,baseline,180224,10960896.0,8192,21,1,4,ixvm_group_24,0,0,2,22,8 +environment,baseline,139264,9334784.0,2048,22,1,34,IxVM::get_address,0,0,1,68,68 +environment,baseline,11264,359424.0,256,23,1,5,ixvm_group_23,0,0,2,44,10 +environment,baseline,0,0.0,0,24,1,12,IxVM::run_eval,0,0,1,22,24 +environment,baseline,184320,9338880.0,4096,25,1,7,ixvm_group_34,0,0,2,45,14 +environment,baseline,135168,5234688.0,1024,26,1,17,ixvm_group_01,0,0,2,132,34 +environment,baseline,104448,3637248.0,1024,27,1,6,ixvm_group_33,0,0,2,102,12 +environment,baseline,117760,4159488.0,1024,28,1,8,ixvm_group_05,0,0,2,115,16 +environment,baseline,95232,3483648.0,1024,29,1,8,ixvm_group_06,0,0,2,93,16 +environment,baseline,38912,1794048.0,1024,30,1,8,ixvm_group_31,0,0,2,38,16 +environment,baseline,21504,724992.0,512,31,1,3,ixvm_group_30,0,0,2,42,6 +environment,baseline,139264,8658944.0,8192,32,1,4,IxVM::get_tagn0,0,0,1,17,8 +environment,baseline,1572864,112459776.0,32768,33,1,12,IxVM::get_expr,0,0,2,48,24 +environment,baseline,135168,7274496.0,4096,34,1,6,IxVM::get_u64_list,0,0,2,33,12 +environment,baseline,7424,230400.0,256,35,1,2,ixvm_group_04,0,0,2,29,4 +environment,baseline,442368,28278784.0,16384,36,1,6,IxVM::get_app_telescope,0,0,1,27,12 +environment,baseline,425984,23101440.0,8192,37,1,8,ixvm_group_26,0,0,2,52,16 +environment,baseline,32768,1765376.0,2048,38,1,4,IxVM::get_lam_mode,0,0,1,16,8 +environment,baseline,15,63.0,1,39,1,2,IxVM::binder_contract_from_bits,0,0,1,15,4 +environment,baseline,8,36.0,1,40,1,1,IxVM::value_contract_from_bits,0,0,1,8,2 +environment,baseline,36864,2035712.0,2048,41,1,5,IxVM::get_all_mode,0,0,1,18,10 +environment,baseline,28928,918528.0,256,42,1,16,ixvm_group_19,0,0,2,113,32 +environment,baseline,42496,1457664.0,512,43,1,9,ixvm_group_35,0,0,2,83,18 +environment,baseline,6592,149376.0,64,44,1,11,ixvm_group_32,0,0,2,103,22 +environment,baseline,25088,987648.0,512,45,1,9,ixvm_group_25,0,0,2,49,18 +environment,baseline,53248,2863104.0,2048,46,1,6,IxVM::get_expr_list,0,0,2,26,12 +environment,baseline,53248,2863104.0,2048,47,1,6,IxVM::get_address_list,0,0,2,26,12 +environment,baseline,65536,2715648.0,1024,48,1,10,ixvm_group_28,0,0,2,64,20 +environment,baseline,51200,1775616.0,512,49,1,12,ixvm_group_27,0,0,2,100,24 +environment,baseline,9216,259072.0,256,50,1,2,IxVM::load_constant_hint,0,0,1,36,4 +environment,baseline,84992,3115008.0,1024,51,1,7,ixvm_group_11,0,0,2,83,14 +environment,baseline,671744,57311232.0,16384,52,1,19,IxVM::convert_expr,0,0,2,41,38 +environment,baseline,57344,4825088.0,8192,53,1,3,"${""name"":""IxVM::list_lookup"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Univ""}}}}]}",0,0,1,7,6 +environment,baseline,147456,13271040.0,16384,54,1,3,"${""name"":""IxVM::list_drop"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Univ""}}}}]}",0,0,2,9,6 +environment,baseline,44032,1947648.0,1024,55,1,8,ixvm_group_64,0,0,2,43,16 +environment,baseline,22528,946176.0,512,56,1,10,ixvm_group_55,0,0,2,44,20 +environment,baseline,36864,1747968.0,512,57,1,25,ixvm_group_56,0,0,2,72,50 +environment,baseline,0,0.0,0,58,1,4,ixvm_group_14,0,0,2,36,8 +environment,baseline,20992,666624.0,256,59,1,11,ixvm_group_36,0,0,2,82,22 +environment,baseline,9984,316416.0,256,60,1,4,ixvm_group_39,0,0,2,39,8 +environment,baseline,0,0.0,0,61,1,31,ixvm_group_59,0,0,2,194,62 +environment,baseline,0,0.0,0,62,1,9,ixvm_group_12,0,0,2,99,18 +environment,baseline,58368,2316288.0,1024,63,1,7,ixvm_group_47,0,0,2,57,14 +environment,baseline,8320,240768.0,128,64,1,10,ixvm_group_20,0,0,2,65,20 +environment,baseline,92160,3575808.0,1024,65,1,11,ixvm_group_22,0,0,2,90,22 +environment,baseline,92,808.0,4,66,1,4,"${""name"":""IxVM::list_length_u64"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Expr""}}}}]}",0,0,1,23,8 +environment,baseline,0,0.0,0,67,1,9,IxVM::put_tagn_tail,0,0,1,30,18 +environment,baseline,0,0.0,0,68,1,6,IxVM::put_tagn_wide,0,0,2,30,12 +environment,baseline,0,0.0,0,69,1,7,ixvm_group_10,0,0,2,53,14 +environment,baseline,164,690.0,1,70,1,31,ixvm_group_09,0,0,2,164,62 +environment,baseline,0,0.0,0,71,1,13,ixvm_group_18,0,0,2,93,26 +environment,baseline,0,0.0,0,72,1,6,ixvm_group_13,0,0,2,69,12 +environment,baseline,0,0.0,0,73,1,12,ixvm_group_16,0,0,2,122,24 +environment,baseline,0,0.0,0,74,1,4,IxVM::put_lam_mode,0,0,1,9,8 +environment,baseline,0,0.0,0,75,1,2,IxVM::binder_contract_code,0,0,1,10,4 +environment,baseline,0,0.0,0,76,1,1,IxVM::value_contract_code,0,0,1,8,2 +environment,baseline,52224,2070528.0,1024,77,1,6,ixvm_group_15,0,0,2,51,12 +environment,baseline,229376,17326080.0,2048,78,1,70,ixvm_group_17,0,0,2,112,140 +environment,baseline,0,0.0,0,79,1,37,ixvm_group_21,0,0,2,197,74 +environment,baseline,524288,41484288.0,16384,80,1,12,IxVM::validate_expr_well_scoped,0,0,2,32,24 +environment,baseline,46080,2254848.0,1024,81,1,12,ixvm_group_48,0,0,2,45,24 +environment,baseline,23552,903168.0,1024,82,1,1,ixvm_group_79,0,0,2,23,2 +environment,baseline,65536,5849088.0,8192,83,1,3,"${""name"":""IxVM::list_length"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KLevelNode""}}}}]}",0,0,2,8,6 +environment,baseline,36864,2818048.0,4096,84,1,4,IxVM::k_ensure_sort,0,0,1,9,8 +environment,baseline,65536,5849088.0,8192,85,2,5,IxVM::k_infer,0,0,2,8,6 +environment,baseline,622592,60850176.0,32768,86,1,9,IxVM::expr_lbr,0,0,2,19,18 +environment,baseline,270336,26615808.0,8192,87,1,23,IxVM::k_infer_core,0,0,2,33,46 +environment,baseline,6144,434176.0,1024,88,1,3,IxVM::types_lookup,0,0,1,6,6 +environment,baseline,180224,13271040.0,16384,89,2,4,IxVM::expr_lift,0,0,2,11,4 +environment,baseline,327680,26345472.0,16384,90,1,7,IxVM::expr_lift_walk,0,0,2,20,14 +environment,baseline,1664,39744.0,32,91,1,13,ixvm_group_61,0,0,2,52,26 +environment,baseline,40960,2039808.0,1024,92,1,11,ixvm_group_38,0,0,2,40,22 +environment,baseline,81920,4767744.0,4096,93,1,4,ixvm_group_70,0,0,2,20,8 +environment,baseline,32768,1916928.0,2048,94,1,4,ixvm_group_57,0,0,2,16,8 +environment,baseline,29696,1517568.0,1024,95,1,8,ixvm_group_65,0,0,2,29,16 +environment,baseline,40960,2703360.0,4096,96,2,3,IxVM::expr_inst_levels,0,0,2,10,4 +environment,baseline,81920,5947392.0,4096,97,1,8,IxVM::expr_inst_levels_walk,0,0,2,20,16 +environment,baseline,77824,5210112.0,4096,98,1,6,ixvm_group_71,0,0,2,19,12 +environment,baseline,180224,17399808.0,16384,99,1,5,IxVM::collect_spine,0,0,2,11,10 +environment,baseline,163840,16711680.0,16384,100,1,5,"${""name"":""IxVM::list_snoc"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",0,0,2,10,10 +environment,baseline,245760,21823488.0,8192,101,1,17,IxVM::k_infer_app_spine_loop,0,0,2,30,34 +environment,baseline,491520,40206336.0,32768,102,2,7,IxVM::expr_inst_many,0,0,2,15,8 +environment,baseline,172032,13197312.0,8192,103,1,8,IxVM::has_bvar_in_range,0,0,2,21,16 +environment,baseline,24576,1511424.0,2048,104,1,3,ixvm_group_72,0,0,2,12,6 +environment,baseline,327680,26345472.0,16384,105,1,7,IxVM::expr_inst_many_walk,0,0,2,20,14 +environment,baseline,81920,7700480.0,8192,106,1,6,IxVM::expr_inst_many_bvar,0,0,1,10,12 +environment,baseline,26624,1250304.0,512,107,1,17,ixvm_group_68,0,0,2,52,34 +environment,baseline,360448,28409856.0,32768,108,2,4,IxVM::expr_lower,0,0,2,11,4 +environment,baseline,720896,59375616.0,32768,109,1,7,IxVM::expr_lower_walk,0,0,2,22,14 +environment,baseline,28672,2228224.0,4096,110,1,3,IxVM::k_check,0,0,1,7,6 +environment,baseline,90112,7446528.0,8192,111,2,7,IxVM::k_is_def_eq,0,0,2,11,8 +environment,baseline,204800,13836288.0,8192,112,1,7,ixvm_group_81,0,0,2,25,14 +environment,baseline,90112,6807552.0,8192,113,1,3,ixvm_group_75,0,0,2,11,6 +environment,baseline,131072,7127040.0,4096,114,2,11,IxVM::try_def_eq_app,0,0,2,32,12 +environment,baseline,73728,4177920.0,4096,115,2,5,IxVM::de_args,0,0,2,18,6 +environment,baseline,581632,25337856.0,8192,116,2,4,IxVM::address_eq,0,0,2,71,4 +environment,baseline,27136,987648.0,512,117,1,7,ixvm_group_67,0,0,2,53,14 +environment,baseline,18944,766464.0,512,118,1,7,ixvm_group_51,0,0,2,37,14 +environment,baseline,7808,273024.0,128,119,1,18,ixvm_group_53,0,0,2,61,36 +environment,baseline,332,3720.0,4,120,1,33,ixvm_group_49,0,0,2,83,66 +environment,baseline,43520,1900032.0,512,121,1,24,ixvm_group_66,0,0,2,85,48 +environment,baseline,68,294.0,1,122,1,13,ixvm_group_50,0,0,2,68,26 +environment,baseline,57344,3588096.0,4096,123,2,5,IxVM::try_string_lit_one,0,0,2,14,6 +environment,baseline,45056,2187264.0,2048,124,2,6,IxVM::whnf_nd,0,0,2,22,6 +environment,baseline,81920,5357568.0,4096,125,2,11,IxVM::whnf_nd_with_spine,0,0,2,20,12 +environment,baseline,163840,13828096.0,16384,126,1,4,"${""name"":""IxVM::list_concat"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",0,0,1,10,8 +environment,baseline,8192,420864.0,512,127,2,10,IxVM::whnf_nd_apply_beta,0,0,2,16,10 +environment,baseline,147456,9043968.0,8192,128,2,5,IxVM::peel_beta,0,0,2,18,6 +environment,baseline,81920,6422528.0,8192,129,1,4,IxVM::apply_spine,0,0,1,10,8 +environment,baseline,98304,7127040.0,8192,130,2,6,IxVM::expr_inst1,0,0,2,12,6 +environment,baseline,188416,12558336.0,8192,131,1,6,IxVM::expr_has_bvar_at,0,0,2,23,12 +environment,baseline,81920,5652480.0,4096,132,1,7,IxVM::expr_inst1_walk,0,0,2,20,14 +environment,baseline,58368,3299328.0,1024,133,1,23,IxVM::whnf_nd_const_head,0,0,2,57,46 +environment,baseline,24320,1078272.0,256,134,1,38,ixvm_group_77,0,0,2,95,76 +environment,baseline,576,12864.0,32,135,1,2,ixvm_group_43,0,0,2,18,4 +environment,baseline,576,12864.0,32,136,1,2,ixvm_group_46,0,0,2,18,4 +environment,baseline,288,5184.0,16,137,1,2,ixvm_group_45,0,0,2,18,4 +environment,baseline,45056,2457600.0,2048,138,2,10,IxVM::try_prim_dispatch,0,0,2,22,10 +environment,baseline,90112,4767744.0,4096,139,2,6,IxVM::whnf,0,0,2,22,6 +environment,baseline,81920,5357568.0,4096,140,2,11,IxVM::whnf_with_spine,0,0,2,20,12 +environment,baseline,16384,933888.0,1024,141,2,10,IxVM::whnf_apply_beta,0,0,2,16,10 +environment,baseline,52224,2992128.0,1024,142,1,21,IxVM::whnf_const_head,0,0,2,51,42 +environment,baseline,86016,6094848.0,4096,143,1,8,ixvm_group_74,0,0,2,21,16 +environment,baseline,2048,40704.0,32,144,1,8,ixvm_group_41,0,0,2,64,16 +environment,baseline,632,12552.0,8,145,1,45,ixvm_group_42,0,0,2,79,90 +environment,baseline,0,0.0,0,146,1,19,ixvm_group_52,0,0,2,84,38 +environment,baseline,45568,2010624.0,512,147,1,26,ixvm_group_63,0,0,2,89,52 +environment,baseline,20480,1511424.0,2048,148,1,4,"${""name"":""IxVM::list_take"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",0,0,2,10,8 +environment,baseline,27136,1181184.0,512,149,1,14,ixvm_group_40,0,0,2,53,28 +environment,baseline,160,5408.0,32,150,1,2,IxVM::klimbs_add,0,0,1,5,4 +environment,baseline,1600,34944.0,32,151,1,9,IxVM::klimbs_add_carry,0,0,2,50,18 +environment,baseline,960,23424.0,32,152,1,7,IxVM::klimbs_normalize,0,0,2,30,14 +environment,baseline,20480,703488.0,256,153,1,15,ixvm_group_37,0,0,2,80,30 +environment,baseline,147456,10432512.0,2048,154,1,39,ixvm_group_80,0,0,2,72,78 +environment,baseline,12288,559104.0,512,155,1,6,ixvm_group_69,0,0,2,24,12 +environment,baseline,55296,3336192.0,2048,156,1,9,ixvm_group_73,0,0,2,27,18 +environment,baseline,20992,987648.0,512,157,1,13,ixvm_group_76,0,0,2,41,26 +environment,baseline,0,0.0,0,158,1,2,ixvm_group_54,0,0,2,9,4 +environment,baseline,70656,2930688.0,1024,159,1,11,ixvm_group_58,0,0,2,69,22 +environment,baseline,0,0.0,0,160,1,5,IxVM::split_u32,0,0,1,11,10 +environment,baseline,0,0.0,0,161,1,3,IxVM::divmod_256,0,0,1,8,6 +environment,baseline,288,5184.0,16,162,1,2,ixvm_group_44,0,0,2,18,4 +environment,baseline,672,16928.0,32,163,1,6,IxVM::klimbs_mul_outer,0,0,1,21,12 +environment,baseline,2176,44544.0,32,164,1,10,IxVM::klimbs_mul_single,0,0,2,68,20 +environment,baseline,128,3264.0,16,165,2,3,IxVM::klimbs_shl_limbs,0,0,2,8,4 +environment,baseline,88,1608.0,8,166,2,6,IxVM::ordinary_div_mod,0,0,2,11,6 +environment,baseline,512,18624.0,32,167,1,9,IxVM::divide_grow,0,0,2,16,18 +environment,baseline,0,0.0,0,168,1,4,IxVM::utf8_groups,0,0,1,9,8 +environment,baseline,0,0.0,0,169,2,3,IxVM::divmod_64u,0,0,2,9,4 +environment,baseline,2272,47904.0,32,170,1,12,ixvm_group_60,0,0,2,71,24 +environment,baseline,0,0.0,0,171,1,10,ixvm_group_62,0,0,2,59,20 +environment,baseline,90112,4767744.0,4096,172,2,6,IxVM::whnf_struct_core,0,0,2,22,6 +environment,baseline,102400,9633792.0,4096,173,1,18,IxVM::whnf_struct_core_spine,0,0,2,25,36 +environment,baseline,67584,3471360.0,2048,174,1,7,ixvm_group_78,0,0,2,33,14 +environment,baseline,13312,718848.0,1024,175,2,5,IxVM::is_nat_zero,0,0,2,13,6 +environment,baseline,36864,2162688.0,1024,176,1,15,IxVM::nat_offset_of,0,0,2,36,30 +environment,baseline,49152,2457600.0,2048,177,2,8,IxVM::lazy_delta_loop,0,0,2,24,8 +environment,baseline,12288,749568.0,1024,178,1,4,IxVM::head_addr,0,0,2,12,8 +environment,baseline,34816,1486848.0,1024,179,1,5,ixvm_group_82,0,0,2,34,10 +environment,baseline,176128,10518528.0,4096,180,1,12,IxVM::k_is_def_eq_struct_bounded,0,0,2,43,24 +environment,baseline,147456,11599872.0,8192,181,2,13,IxVM::k_def_eq_rebase,0,0,2,18,14 +environment,baseline,294912,25460736.0,32768,182,2,4,IxVM::expr_glb,0,0,2,9,4 +environment,baseline,720896,65273856.0,32768,183,1,9,IxVM::expr_glb_walk,0,0,2,22,18 +environment,baseline,81920,5849088.0,8192,184,2,4,IxVM::expr_glb_binder,0,0,2,10,4 +environment,baseline,176,5248.0,16,185,1,7,IxVM::k_infer_let_start,0,0,1,11,14 +environment,baseline,10240,614400.0,512,186,1,10,IxVM::k_infer_let_env,0,0,2,20,20 +environment,baseline,832,27264.0,64,187,1,3,IxVM::infer_let_local_cutoff,0,0,2,13,6 +environment,baseline,13824,1153536.0,512,188,1,26,IxVM::k_infer_let_env_core,0,0,2,27,52 +environment,baseline,2048,76800.0,128,189,1,4,IxVM::infer_let_lookup_type,0,0,2,16,8 +environment,baseline,28672,1732608.0,1024,190,1,12,IxVM::infer_let_materialize,0,0,2,28,24 +environment,baseline,4096,187392.0,256,191,1,5,IxVM::infer_let_lookup_value,0,0,2,16,10 +environment,baseline,896,34816.0,64,192,1,7,IxVM::k_infer_let_env_rebase,0,0,1,14,14 +environment,baseline,2048,71424.0,128,193,1,3,IxVM::infer_let_drop_unused,0,0,2,16,6 +environment,baseline,122880,10002432.0,8192,194,2,11,IxVM::k_infer_rebase,0,0,2,15,12 +environment,baseline,245760,16711680.0,8192,195,1,9,IxVM::safe_refs_only,0,0,2,30,18 +environment,baseline,0,0.0,0,196,1,4,"${""name"":""IxVM::list_concat"",""types"":[{""tuple"":{""items"":[{""ptr"":{""target"":{""array"":{""element"":""field"",""length"":32}}}},""field""]}}]}",0,0,1,11,8 +environment,baseline,0,0.0,0,197,1,25,IxVM::canon_cmp_kexpr_node_ctx,0,0,2,61,50 +environment,baseline,0,0.0,0,198,1,5,"${""name"":""IxVM::list_snoc"",""types"":[{""tuple"":{""items"":[{""ptr"":{""target"":{""array"":{""element"":""field"",""length"":32}}}},""field"",{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}],""name"":""Lists::Node""}}}},{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KLevelNode""}}}}],""name"":""Lists::Node""}}}}]}}]}",0,0,2,16,10 +environment,baseline,176,4224.0,16,199,1,3,"${""name"":""IxVM::list_length"",""types"":[{""tuple"":{""items"":[{""ptr"":{""target"":{""array"":{""element"":""field"",""length"":32}}}},""field"",{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}],""name"":""Lists::Node""}}}},{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KLevelNode""}}}}],""name"":""Lists::Node""}}}}]}}]}",0,0,2,11,6 +environment,baseline,80,1536.0,8,200,1,3,"${""name"":""IxVM::list_lookup_or_default"",""types"":[""field""]}",0,0,2,10,6 +environment,baseline,0,0.0,0,201,2,5,IxVM::walk_refs_transitive,0,0,2,12,6 +environment,baseline,180224,13271040.0,16384,202,2,3,IxVM::g_list_has,0,0,2,11,4 +environment,baseline,20480,1630208.0,2048,203,1,6,IxVM::const_idxs_exprs,0,0,1,10,12 +environment,baseline,278528,19906560.0,8192,204,1,12,IxVM::const_idxs_expr,0,0,2,34,24 +environment,baseline,0,0.0,0,205,1,8,"${""name"":""IxVM::rbtree_map_balance_fix"",""types"":[""field""]}",0,0,2,301,16 +environment,baseline,0,0.0,0,206,1,4,IxVM::eval_body,0,0,2,19,8 +environment,baseline,0,0.0,0,207,1,7,IxVM::eval_output,0,0,1,58,14 +environment,baseline,0,0.0,0,208,1,8,IxVM::eval_nf,0,0,2,15,16 +environment,baseline,0,0.0,0,209,1,6,IxVM::eval_nf_spine,0,0,2,13,12 +environment,baseline,19968,707072.0,512,210,1,5,IxVM::walk_leaves_owned,0,0,1,39,10 +environment,baseline,17920,596480.0,512,211,1,3,IxVM::check_owned,0,0,1,35,6 +environment,baseline,45568,1512960.0,512,212,1,8,IxVM::env_walk_all,0,0,2,89,16 +environment,baseline,176128,7864320.0,4096,213,2,6,IxVM::env_walk_refs_all,0,0,2,43,6 +environment,baseline,512,50176.0,256,214,1,2,,256,11,1,2,4 +environment,baseline,458752,60555264.0,65536,215,2,7,,65536,14,2,7,8 +environment,baseline,1024,157696.0,1024,216,1,1,,1024,3,1,1,2 +environment,baseline,40,968.0,8,217,1,3,,0,0,1,5,6 +environment,baseline,3145728,420478976.0,524288,218,1,3,,0,0,1,6,6 +environment,baseline,229376,22249472.0,32768,219,1,3,,0,0,1,7,6 +environment,baseline,1024,43520.0,128,220,1,3,,0,0,1,8,6 +environment,baseline,144,3328.0,16,221,1,3,,0,0,1,9,6 +environment,baseline,22,122.0,2,222,1,3,,0,0,1,11,6 +environment,baseline,384,9728.0,32,223,1,3,,0,0,1,12,6 +environment,baseline,832,24448.0,64,224,1,3,,0,0,1,13,6 +environment,baseline,448,10688.0,32,225,1,3,,0,0,1,14,6 +environment,baseline,7680,320000.0,512,226,1,3,,0,0,1,15,6 +environment,baseline,172032,9297920.0,8192,227,1,3,,0,0,1,21,6 +environment,baseline,0,0.0,0,228,1,3,,0,0,1,22,6 +environment,baseline,143360,6356992.0,4096,229,1,3,,0,0,1,35,6 +environment,baseline,75776,3049472.0,2048,230,1,3,,0,0,1,37,6 +environment,baseline,2496,54400.0,64,231,1,3,,0,0,1,39,6 +environment,baseline,1600,27968.0,32,232,1,3,,0,0,1,50,6 +environment,baseline,0,0.0,0,233,1,3,,0,0,1,53,6 +environment,baseline,0,0.0,0,234,1,3,,0,0,1,67,6 +environment,selected,10,48.0,1,0,1,2,IxVM::verify_claim,0,0,1,10,4 +environment,selected,28288,740736.0,128,1,1,25,ixvm_group_00,0,0,2,221,50 +environment,selected,55296,2930688.0,2048,2,1,6,ixvm_group_01,0,0,2,27,12 +environment,selected,1572864,162004992.0,131072,3,1,4,ixvm_group_02,0,0,2,12,8 +environment,selected,1441792,155320320.0,131072,4,1,4,ixvm_group_03,0,0,2,11,8 +environment,selected,229376,20709376.0,16384,5,1,7,UInt32::less_than_fields,0,0,1,14,14 +environment,selected,305152,11716608.0,2048,6,1,10,ixvm_group_04,0,0,2,149,20 +environment,selected,16416768,1078296576.0,32768,7,2,226,Blake3::compress,0,0,2,501,226 +environment,selected,2228224,182059008.0,131072,8,2,6,Blake3::compress_chunks,0,0,2,17,6 +environment,selected,356352,13946880.0,2048,9,1,14,ixvm_group_05,0,0,2,174,28 +environment,selected,13312,448512.0,512,10,1,1,ixvm_group_06,0,0,2,26,2 +environment,selected,593920,41189376.0,4096,11,1,65,ixvm_group_07,0,0,2,145,130 +environment,selected,370688,15771648.0,2048,12,1,24,ixvm_group_08,0,0,2,181,48 +environment,selected,14336,886784.0,2048,13,1,2,"${""name"":""Lists::is_empty"",""types"":[""field""]}",0,0,1,7,4 +environment,selected,4800,107904.0,64,14,1,7,ixvm_group_09,0,0,2,75,14 +environment,selected,884736,60850176.0,32768,15,1,5,ixvm_group_10,0,0,2,27,10 +environment,selected,55296,2930688.0,2048,16,1,6,ixvm_group_11,0,0,2,27,12 +environment,selected,0,0.0,0,17,1,6,ixvm_group_12,0,0,2,71,12 +environment,selected,0,0.0,0,18,1,19,ixvm_group_13,0,0,2,92,38 +environment,selected,17920,764928.0,128,19,1,70,ixvm_group_14,0,0,2,140,140 +environment,selected,57344,4890624.0,8192,20,1,2,ixvm_group_15,0,0,2,7,4 +environment,selected,139264,9334784.0,2048,21,1,34,IxVM::get_address,0,0,1,68,68 +environment,selected,20992,877056.0,512,22,1,9,ixvm_group_16,0,0,2,41,18 +environment,selected,53248,3403776.0,2048,23,1,10,ixvm_group_17,0,0,2,26,20 +environment,selected,98304,4927488.0,1024,24,1,30,ixvm_group_18,0,0,2,96,60 +environment,selected,115712,4220928.0,1024,25,1,10,ixvm_group_19,0,0,2,113,20 +environment,selected,42496,1457664.0,512,26,1,9,ixvm_group_20,0,0,2,83,18 +environment,selected,8512,234624.0,64,27,1,33,ixvm_group_21,0,0,2,133,66 +environment,selected,262144,17350656.0,8192,28,1,9,ixvm_group_22,0,0,2,32,18 +environment,selected,1232,7920.0,4,29,1,8,ixvm_group_23,0,0,2,308,16 +environment,selected,1998848,131629056.0,32768,30,1,12,ixvm_group_24,0,0,2,61,24 +environment,selected,2560,76800.0,128,31,1,2,UInt64::saturating_pred,0,0,2,20,4 +environment,selected,475136,31162368.0,16384,32,1,6,ixvm_group_25,0,0,2,29,12 +environment,selected,167936,9043968.0,4096,33,1,8,ixvm_group_26,0,0,2,41,16 +environment,selected,204800,13197312.0,8192,34,1,6,ixvm_group_27,0,0,2,25,12 +environment,selected,50176,2562048.0,1024,35,1,15,ixvm_group_28,0,0,2,49,30 +environment,selected,25600,1394688.0,1024,36,1,8,ixvm_group_29,0,0,2,25,16 +environment,selected,75776,3876864.0,2048,37,1,8,ixvm_group_30,0,0,2,37,16 +environment,selected,688128,57999360.0,16384,38,1,19,ixvm_group_31,0,0,2,42,38 +environment,selected,34304,1236480.0,512,39,1,9,ixvm_group_32,0,0,2,67,18 +environment,selected,28672,900096.0,256,40,1,15,ixvm_group_33,0,0,2,112,30 +environment,selected,14848,600576.0,512,41,1,5,ixvm_group_34,0,0,2,29,10 +environment,selected,20480,592896.0,256,42,1,6,ixvm_group_35,0,0,2,80,12 +environment,selected,17920,629760.0,256,43,1,14,ixvm_group_36,0,0,2,70,28 +environment,selected,18944,617472.0,256,44,1,11,ixvm_group_37,0,0,2,74,22 +environment,selected,74752,3130368.0,512,45,1,38,ixvm_group_38,0,0,2,146,76 +environment,selected,57344,2998272.0,2048,46,1,6,ixvm_group_39,0,0,2,28,12 +environment,selected,50176,2131968.0,1024,47,1,8,ixvm_group_40,0,0,2,49,16 +environment,selected,6656,248832.0,256,48,1,5,ixvm_group_41,0,0,2,26,10 +environment,selected,19712,562176.0,256,49,1,5,ixvm_group_42,0,0,2,77,10 +environment,selected,176128,10702848.0,2048,50,1,34,ixvm_group_43,0,0,2,86,68 +environment,selected,8960,304128.0,256,51,1,5,ixvm_group_44,0,0,2,35,10 +environment,selected,57344,4825088.0,8192,52,1,3,"${""name"":""IxVM::list_lookup"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Univ""}}}}]}",0,0,1,7,6 +environment,selected,147456,13271040.0,16384,53,1,3,"${""name"":""IxVM::list_drop"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Univ""}}}}]}",0,0,2,9,6 +environment,selected,3200,111744.0,128,54,1,6,ixvm_group_45,0,0,2,25,12 +environment,selected,294912,20545536.0,8192,55,1,12,ixvm_group_46,0,0,2,36,24 +environment,selected,0,0.0,0,56,1,31,ixvm_group_47,0,0,2,204,62 +environment,selected,24064,1070592.0,512,57,1,13,ixvm_group_48,0,0,2,47,26 +environment,selected,4608,236544.0,256,58,1,8,ixvm_group_49,0,0,2,18,16 +environment,selected,11264,595968.0,1024,59,1,2,ixvm_group_50,0,0,2,11,4 +environment,selected,6912,200448.0,128,60,1,8,ixvm_group_51,0,0,2,54,16 +environment,selected,2944,100992.0,128,61,1,5,ixvm_group_52,0,0,2,23,10 +environment,selected,0,0.0,0,62,1,13,ixvm_group_53,0,0,2,90,26 +environment,selected,25856,844800.0,256,63,1,16,ixvm_group_54,0,0,2,101,32 +environment,selected,0,0.0,0,64,1,10,ixvm_group_55,0,0,2,63,20 +environment,selected,12544,402432.0,256,65,1,6,ixvm_group_56,0,0,2,49,12 +environment,selected,328,4272.0,4,66,1,45,ixvm_group_57,0,0,2,82,90 +environment,selected,23296,979968.0,256,67,1,32,ixvm_group_58,0,0,2,91,64 +environment,selected,10240,445440.0,256,68,1,14,ixvm_group_59,0,0,2,40,28 +environment,selected,52224,2377728.0,1024,69,1,11,ixvm_group_60,0,0,2,51,22 +environment,selected,25600,1271808.0,1024,70,1,6,ixvm_group_61,0,0,2,25,12 +environment,selected,65536,5849088.0,8192,71,1,3,"${""name"":""IxVM::list_length"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KLevelNode""}}}}]}",0,0,2,8,6 +environment,selected,45056,3440640.0,4096,72,1,4,ixvm_group_62,0,0,2,11,8 +environment,selected,786432,68222976.0,32768,73,1,9,ixvm_group_63,0,0,2,24,18 +environment,selected,688128,63799296.0,32768,74,1,9,ixvm_group_64,0,0,2,21,18 +environment,selected,4096,227328.0,512,75,1,2,ixvm_group_65,0,0,2,8,4 +environment,selected,344064,29491200.0,8192,76,1,23,ixvm_group_66,0,0,2,42,46 +environment,selected,589824,53477376.0,32768,77,1,7,ixvm_group_67,0,0,2,18,14 +environment,selected,360448,27721728.0,16384,78,1,7,ixvm_group_68,0,0,2,22,14 +environment,selected,3072,76800.0,64,79,1,7,ixvm_group_69,0,0,2,48,14 +environment,selected,13312,586752.0,512,80,1,6,ixvm_group_70,0,0,2,26,12 +environment,selected,20992,794112.0,512,81,1,6,ixvm_group_71,0,0,2,41,12 +environment,selected,18432,697344.0,512,82,1,5,ixvm_group_72,0,0,2,36,10 +environment,selected,32768,1637376.0,512,83,1,25,ixvm_group_73,0,0,2,64,50 +environment,selected,40960,2703360.0,4096,84,2,3,IxVM::expr_inst_levels,0,0,2,10,4 +environment,selected,90112,6242304.0,4096,85,1,8,ixvm_group_74,0,0,2,22,16 +environment,selected,196608,18087936.0,16384,86,1,5,ixvm_group_75,0,0,2,12,10 +environment,selected,425984,40206336.0,32768,87,1,5,ixvm_group_76,0,0,2,13,10 +environment,selected,262144,22462464.0,8192,88,1,17,ixvm_group_77,0,0,2,32,34 +environment,selected,172032,13197312.0,8192,89,1,8,IxVM::has_bvar_in_range,0,0,2,21,16 +environment,selected,131072,7421952.0,4096,90,1,7,ixvm_group_78,0,0,2,32,14 +environment,selected,1856,32832.0,16,91,1,25,ixvm_group_79,0,0,2,116,50 +environment,selected,1015808,72646656.0,32768,92,1,7,ixvm_group_80,0,0,2,31,14 +environment,selected,36864,2555904.0,4096,93,2,3,IxVM::k_is_def_eq_ordered,0,0,2,9,4 +environment,selected,131072,7127040.0,4096,94,2,11,IxVM::try_def_eq_app,0,0,2,32,12 +environment,selected,188416,11919360.0,8192,95,1,5,ixvm_group_81,0,0,2,23,10 +environment,selected,598016,28532736.0,8192,96,1,6,ixvm_group_82,0,0,2,73,12 +environment,selected,35328,1430016.0,512,97,1,15,ixvm_group_83,0,0,2,69,30 +environment,selected,3584,141312.0,128,98,1,10,ixvm_group_84,0,0,2,28,20 +environment,selected,10112,316032.0,128,99,1,17,ixvm_group_85,0,0,2,79,34 +environment,selected,8320,316032.0,128,100,1,24,ixvm_group_86,0,0,2,65,48 +environment,selected,3648,69504.0,32,101,1,13,ixvm_group_87,0,0,2,114,26 +environment,selected,15872,766464.0,512,102,1,10,ixvm_group_88,0,0,2,31,20 +environment,selected,12288,503808.0,512,103,1,4,ixvm_group_89,0,0,2,24,8 +environment,selected,122880,10002432.0,8192,104,1,6,ixvm_group_90,0,0,2,15,12 +environment,selected,57344,3588096.0,4096,105,2,5,IxVM::try_string_lit_one,0,0,2,14,6 +environment,selected,192512,9338880.0,4096,106,1,6,ixvm_group_91,0,0,2,47,12 +environment,selected,81920,5357568.0,4096,107,2,11,IxVM::whnf_nd_with_spine,0,0,2,20,12 +environment,selected,81920,5652480.0,4096,108,1,7,IxVM::expr_inst1_walk,0,0,2,20,14 +environment,selected,576,12864.0,32,109,1,2,ixvm_group_92,0,0,2,18,4 +environment,selected,272,4992.0,16,110,1,2,ixvm_group_93,0,0,2,17,4 +environment,selected,80,1392.0,8,111,1,2,ixvm_group_94,0,0,2,10,4 +environment,selected,26112,1181184.0,512,112,1,15,ixvm_group_95,0,0,2,51,30 +environment,selected,18944,1291776.0,512,113,1,26,ixvm_group_96,0,0,2,37,52 +environment,selected,35840,1947648.0,1024,114,1,12,ixvm_group_97,0,0,2,35,24 +environment,selected,196608,17350656.0,8192,115,1,13,ixvm_group_98,0,0,2,24,26 +environment,selected,66560,3422208.0,1024,116,1,21,ixvm_group_99,0,0,2,65,42 +environment,selected,49152,2039808.0,1024,117,1,7,ixvm_group_100,0,0,2,48,14 +environment,selected,18688,611328.0,256,118,1,11,ixvm_group_101,0,0,2,73,22 +environment,selected,61440,5210112.0,4096,119,1,8,ixvm_group_102,0,0,2,15,16 +environment,selected,18432,724992.0,512,120,1,6,ixvm_group_103,0,0,2,36,12 +environment,selected,43008,1803264.0,512,121,1,21,ixvm_group_104,0,0,2,84,42 +environment,selected,608,11328.0,16,122,1,8,ixvm_group_105,0,0,2,38,16 +environment,selected,1312,23616.0,16,123,1,18,ixvm_group_106,0,0,2,82,36 +environment,selected,288,5184.0,16,124,1,2,ixvm_group_107,0,0,2,18,4 +environment,selected,57344,3588096.0,4096,125,2,6,IxVM::k_is_def_eq_slow_nd,0,0,2,14,6 +environment,selected,90112,4767744.0,4096,126,2,6,IxVM::whnf_struct_core,0,0,2,22,6 +environment,selected,41984,1947648.0,1024,127,1,9,ixvm_group_108,0,0,2,41,18 +environment,selected,31232,1098240.0,512,128,2,14,IxVM::try_eta_struct,0,0,2,61,14 +environment,selected,59392,3336192.0,2048,129,1,8,ixvm_group_109,0,0,2,29,16 +environment,selected,13312,718848.0,1024,130,2,5,IxVM::is_nat_zero,0,0,2,13,6 +environment,selected,176128,10518528.0,4096,131,1,12,IxVM::k_is_def_eq_struct_bounded,0,0,2,43,24 +environment,selected,19456,1394688.0,1024,132,1,11,ixvm_group_110,0,0,2,19,22 +environment,selected,294912,25460736.0,32768,133,2,4,IxVM::expr_glb,0,0,2,9,4 +environment,selected,81920,5849088.0,8192,134,2,4,IxVM::expr_glb_binder,0,0,2,10,4 +environment,selected,122880,10002432.0,8192,135,2,11,IxVM::k_infer_rebase,0,0,2,15,12 +environment,selected,0,0.0,0,136,2,2,IxVM::canon_ord_cmp_g,0,0,2,8,2 +environment,selected,0,0.0,0,137,1,18,IxVM::canon_addr_cmp,0,0,1,83,36 +environment,selected,0,0.0,0,138,1,2,IxVM::canon_addr_chunk,0,0,1,11,4 +environment,selected,310,1230.0,2,139,1,21,ixvm_group_111,0,0,2,155,42 +environment,selected,180224,13271040.0,16384,140,2,3,IxVM::g_list_has,0,0,2,11,4 +environment,selected,512,50176.0,256,141,1,2,,256,11,1,2,4 +environment,selected,458752,60555264.0,65536,142,2,7,,65536,14,2,7,8 +environment,selected,1024,157696.0,1024,143,1,1,,1024,3,1,1,2 +environment,selected,40,968.0,8,144,1,3,,0,0,1,5,6 +environment,selected,3145728,420478976.0,524288,145,1,3,,0,0,1,6,6 +environment,selected,229376,22249472.0,32768,146,1,3,,0,0,1,7,6 +environment,selected,1024,43520.0,128,147,1,3,,0,0,1,8,6 +environment,selected,144,3328.0,16,148,1,3,,0,0,1,9,6 +environment,selected,22,122.0,2,149,1,3,,0,0,1,11,6 +environment,selected,384,9728.0,32,150,1,3,,0,0,1,12,6 +environment,selected,832,24448.0,64,151,1,3,,0,0,1,13,6 +environment,selected,448,10688.0,32,152,1,3,,0,0,1,14,6 +environment,selected,7680,320000.0,512,153,1,3,,0,0,1,15,6 +environment,selected,172032,9297920.0,8192,154,1,3,,0,0,1,21,6 +environment,selected,0,0.0,0,155,1,3,,0,0,1,22,6 +environment,selected,143360,6356992.0,4096,156,1,3,,0,0,1,35,6 +environment,selected,75776,3049472.0,2048,157,1,3,,0,0,1,37,6 +environment,selected,2496,54400.0,64,158,1,3,,0,0,1,39,6 +environment,selected,1600,27968.0,32,159,1,3,,0,0,1,50,6 +environment,selected,0,0.0,0,160,1,3,,0,0,1,53,6 +environment,selected,0,0.0,0,161,1,3,,0,0,1,67,6 +recursion,baseline,219,951.0,1,0,1,48,MultiStark::verify_multi_stark_proof,0,0,1,219,96 +recursion,baseline,2816,144384.0,256,1,1,4,MultiStark::read_byte_stream,0,0,2,11,8 +recursion,baseline,13184,291072.0,64,2,1,21,verifier_group_03,0,0,2,206,42 +recursion,baseline,128256,4494336.0,256,3,2,226,Blake3::compress,0,0,2,501,226 +recursion,baseline,17408,841728.0,1024,4,2,6,Blake3::compress_chunks,0,0,2,17,6 +recursion,baseline,48384,1377792.0,128,5,1,65,verifier_group_12,0,0,2,378,130 +recursion,baseline,18944,605184.0,256,6,1,10,verifier_group_00,0,0,2,74,20 +recursion,baseline,17408,642048.0,512,7,1,4,verifier_group_08,0,0,2,34,8 +recursion,baseline,56,968.0,8,8,1,2,"${""name"":""Lists::is_empty"",""types"":[""field""]}",0,0,1,7,4 +recursion,baseline,640,30080.0,128,9,1,2,MultiStark::read_vk_u8,0,0,1,5,4 +recursion,baseline,6656,184320.0,128,10,1,6,verifier_group_02,0,0,2,52,12 +recursion,baseline,40,824.0,8,11,1,2,MultiStark::read_vk_tag,0,0,1,5,4 +recursion,baseline,224,7328.0,32,12,1,3,MultiStark::read_vk_u16,0,0,1,7,6 +recursion,baseline,352,6144.0,8,13,1,18,MultiStark::read_nodes_n,0,0,2,44,36 +recursion,baseline,1920,74112.0,128,14,1,4,verifier_group_11,0,0,2,15,8 +recursion,baseline,1312,24384.0,16,15,1,20,verifier_group_13,0,0,2,82,40 +recursion,baseline,11392,299904.0,128,16,1,9,verifier_group_10,0,0,2,89,18 +recursion,baseline,9408,250752.0,64,17,1,33,verifier_group_04,0,0,2,147,66 +recursion,baseline,4096,162816.0,256,18,1,3,verifier_group_05,0,0,2,16,6 +recursion,baseline,9728,541184.0,512,19,1,9,MultiStark::read_u64_at,0,0,1,19,18 +recursion,baseline,46,306.0,2,20,1,10,MultiStark::read_header_vec_n,0,0,2,23,20 +recursion,baseline,12544,402432.0,256,21,1,6,verifier_group_06,0,0,2,49,12 +recursion,baseline,40,824.0,8,22,1,2,MultiStark::read_u8_at,0,0,1,5,4 +recursion,baseline,448,17536.0,64,23,1,3,MultiStark::read_u64_vec,0,0,1,7,6 +recursion,baseline,4608,187392.0,256,24,1,4,MultiStark::read_u64_vec_n,0,0,2,18,8 +recursion,baseline,20,102.0,1,25,1,5,MultiStark::read_message_vec_n,0,0,2,20,10 +recursion,baseline,68,300.0,2,26,1,4,MultiStark::read_proof_vec_n,0,0,2,34,8 +recursion,baseline,53,297.0,1,27,1,22,MultiStark::read_proof,0,0,1,53,44 +recursion,baseline,896,20544.0,32,28,1,5,verifier_group_09,0,0,2,28,10 +recursion,baseline,40,168.0,1,29,2,11,MultiStark::verify_batch,0,0,2,40,12 +recursion,baseline,16,78.0,1,30,2,5,MultiStark::assert_shard_count_ok,0,0,2,16,6 +recursion,baseline,62,270.0,2,31,1,3,"${""name"":""MultiStark::list_length"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::Proof""}}]}",0,0,2,31,6 +recursion,baseline,159,591.0,1,32,2,33,MultiStark::assert_closure_pairs,0,0,2,159,34 +recursion,baseline,0,0.0,0,33,1,5,MultiStark::three_limbs,0,0,1,39,10 +recursion,baseline,0,0.0,0,34,1,9,MultiStark::bytes8_le,0,0,1,26,18 +recursion,baseline,0,0.0,0,35,2,2,MultiStark::le_step,0,0,2,11,2 +recursion,baseline,73,429.0,1,36,1,34,MultiStark::batch_fiat_shamir,0,0,1,73,68 +recursion,baseline,7,51.0,1,37,1,4,MultiStark::messages_onto,0,0,1,7,8 +recursion,baseline,144,2112.0,8,38,2,6,MultiStark::count_onto,0,0,2,18,6 +recursion,baseline,2432,105344.0,128,39,1,9,MultiStark::b8_onto,0,0,1,19,18 +recursion,baseline,21,111.0,1,40,1,7,MultiStark::messages_onto_each,0,0,1,21,14 +recursion,baseline,120,1896.0,8,41,1,3,"${""name"":""MultiStark::list_length"",""types"":[{""array"":{""element"":""field"",""length"":8}}]}",0,0,2,15,6 +recursion,baseline,26,146.0,2,42,1,4,MultiStark::headers_onto,0,0,1,13,8 +recursion,baseline,13,87.0,1,43,1,7,MultiStark::header_onto,0,0,1,13,14 +recursion,baseline,22,146.0,2,44,1,5,MultiStark::active_onto,0,0,1,11,10 +recursion,baseline,1024,49920.0,128,45,1,3,"${""name"":""MultiStark::list_length"",""types"":[""field""]}",0,0,2,8,6 +recursion,baseline,7,51.0,1,46,1,4,MultiStark::claims_onto,0,0,1,7,8 +recursion,baseline,24,164.0,2,47,1,6,MultiStark::claims_onto_each,0,0,1,12,12 +recursion,baseline,8704,407040.0,512,48,1,4,verifier_group_16,0,0,2,17,8 +recursion,baseline,5120,278528.0,512,49,1,4,"${""name"":""MultiStark::list_concat"",""types"":[""field""]}",0,0,1,10,8 +recursion,baseline,32,120.0,1,50,2,4,MultiStark::messages_acc,0,0,2,32,4 +recursion,baseline,120,444.0,2,51,2,5,MultiStark::verify_shards,0,0,2,60,6 +recursion,baseline,125,681.0,1,52,1,50,MultiStark::verify_shard,0,0,1,125,100 +recursion,baseline,1664,63360.0,128,53,1,3,verifier_group_19,0,0,2,13,6 +recursion,baseline,44,600.0,4,54,1,4,MultiStark::assert_same_bits,0,0,2,11,8 +recursion,baseline,158,642.0,2,55,1,10,MultiStark::assert_same_cap,0,0,2,79,20 +recursion,baseline,864,16224.0,32,56,1,1,UInt64::eq,0,0,2,27,2 +recursion,baseline,18,122.0,2,57,1,4,MultiStark::assert_log_degrees_ok,0,0,1,9,8 +recursion,baseline,69,225.0,1,58,1,1,MultiStark::log_degree_ok,0,0,2,69,2 +recursion,baseline,16,132.0,2,59,1,3,MultiStark::count_ones,0,0,2,8,6 +recursion,baseline,64,252.0,1,60,2,15,MultiStark::shard_fiat_shamir,0,0,2,64,16 +recursion,baseline,1632,46944.0,32,61,1,21,verifier_group_15,0,0,2,51,42 +recursion,baseline,1440,31584.0,32,62,1,8,verifier_group_17,0,0,2,45,16 +recursion,baseline,336,4128.0,8,63,1,5,MultiStark::eval_at,0,0,2,42,10 +recursion,baseline,80,1328.0,8,64,1,3,"${""name"":""MultiStark::list_lookup"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::SysNode""}}]}",0,0,1,10,6 +recursion,baseline,14,66.0,1,65,1,2,verifier_group_14,0,0,2,14,4 +recursion,baseline,296,2112.0,4,66,2,7,MultiStark::digest_eq,0,0,2,74,8 +recursion,baseline,48,576.0,4,67,2,5,MultiStark::assert_same_claims,0,0,2,12,6 +recursion,baseline,208,2688.0,8,68,2,5,MultiStark::assert_same_limbs,0,0,2,26,6 +recursion,baseline,460,1764.0,2,69,1,28,MultiStark::b3_rows_chunks,0,0,2,230,56 +recursion,baseline,328,3912.0,8,70,2,8,MultiStark::rows_pop,0,0,2,41,8 +recursion,baseline,120,1200.0,4,71,1,7,MultiStark::select_rows,0,0,2,30,14 +recursion,baseline,384,7488.0,16,72,2,9,MultiStark::ri_apply,0,0,2,24,10 +recursion,baseline,496,8064.0,16,73,2,5,MultiStark::bucket_update,0,0,2,31,6 +recursion,baseline,576,8640.0,16,74,2,4,MultiStark::ro_fold,0,0,2,36,4 +recursion,baseline,14,66.0,1,75,2,4,MultiStark::last_acc,0,0,2,14,4 +recursion,baseline,24,152.0,2,76,1,5,MultiStark::batch_claims,0,0,1,12,10 +recursion,baseline,512,50176.0,256,77,1,2,,256,11,1,2,4 +recursion,baseline,458752,60555264.0,65536,78,2,7,,65536,14,2,7,8 +recursion,baseline,1024,157696.0,1024,79,1,1,,1024,3,1,1,2 +recursion,baseline,24576,2080768.0,4096,80,1,3,,0,0,1,6,6 +recursion,baseline,224,7328.0,32,81,1,3,,0,0,1,7,6 +recursion,baseline,8,48.0,1,82,1,3,,0,0,1,8,6 +recursion,baseline,1152,46208.0,128,83,1,3,,0,0,1,9,6 +recursion,baseline,80,1328.0,8,84,1,3,,0,0,1,10,6 +recursion,baseline,11,57.0,1,85,1,3,,0,0,1,11,6 +recursion,baseline,416,10208.0,32,86,1,3,,0,0,1,13,6 +recursion,baseline,28,140.0,2,87,1,3,,0,0,1,14,6 +recursion,baseline,58,230.0,2,88,1,3,,0,0,1,29,6 +recursion,baseline,560,8320.0,16,89,1,3,,0,0,1,35,6 +recursion,baseline,592,8704.0,16,90,1,3,,0,0,1,37,6 +recursion,selected,219,951.0,1,0,1,48,MultiStark::verify_multi_stark_proof,0,0,1,219,96 +recursion,selected,7168,365568.0,512,1,1,4,verifier_group_00,0,0,2,14,8 +recursion,selected,5600,99744.0,32,2,1,14,verifier_group_01,0,0,2,175,28 +recursion,selected,1816,24504.0,8,3,1,54,verifier_group_02,0,0,2,227,108 +recursion,selected,128256,4494336.0,256,4,2,226,Blake3::compress,0,0,2,501,226 +recursion,selected,17408,841728.0,1024,5,2,6,Blake3::compress_chunks,0,0,2,17,6 +recursion,selected,416,6000.0,8,6,1,13,verifier_group_03,0,0,2,52,26 +recursion,selected,4576,133344.0,32,7,1,65,verifier_group_04,0,0,2,143,130 +recursion,selected,2048,101376.0,256,8,2,3,Blake3::pad_block,0,0,2,8,4 +recursion,selected,3840,57792.0,16,9,1,28,verifier_group_05,0,0,2,240,56 +recursion,selected,1440,36384.0,32,10,1,13,verifier_group_06,0,0,2,45,26 +recursion,selected,484,3528.0,4,11,1,10,verifier_group_07,0,0,2,121,20 +recursion,selected,640,23808.0,64,12,1,3,verifier_group_08,0,0,2,10,6 +recursion,selected,640,30080.0,128,13,1,2,MultiStark::read_vk_u8,0,0,1,5,4 +recursion,selected,968,13992.0,8,14,1,34,verifier_group_09,0,0,2,121,68 +recursion,selected,480,9024.0,16,15,1,6,verifier_group_10,0,0,2,30,12 +recursion,selected,40,824.0,8,16,1,2,MultiStark::read_vk_tag,0,0,1,5,4 +recursion,selected,352,6144.0,8,17,1,18,MultiStark::read_nodes_n,0,0,2,44,36 +recursion,selected,496,9600.0,16,18,1,7,verifier_group_11,0,0,2,31,14 +recursion,selected,88,1752.0,8,19,1,4,MultiStark::read_node_ids_n,0,0,2,11,8 +recursion,selected,184,2760.0,8,20,1,5,verifier_group_12,0,0,2,23,10 +recursion,selected,320,4704.0,8,21,1,10,verifier_group_13,0,0,2,40,20 +recursion,selected,896,19584.0,32,22,1,4,verifier_group_14,0,0,2,28,8 +recursion,selected,816,12672.0,16,23,1,5,verifier_group_15,0,0,2,51,10 +recursion,selected,400,9216.0,16,24,1,9,verifier_group_16,0,0,2,25,18 +recursion,selected,576,22656.0,64,25,1,3,verifier_group_17,0,0,2,9,6 +recursion,selected,960,20544.0,32,26,1,4,verifier_group_18,0,0,2,30,8 +recursion,selected,10240,586752.0,512,27,1,9,verifier_group_19,0,0,2,20,18 +recursion,selected,1408,63360.0,128,28,1,4,MultiStark::read_u64_vec_vec_n,0,0,2,11,8 +recursion,selected,5120,199680.0,256,29,1,4,verifier_group_20,0,0,2,20,8 +recursion,selected,1056,22944.0,32,30,1,5,verifier_group_21,0,0,2,33,10 +recursion,selected,4864,205824.0,256,31,1,5,verifier_group_22,0,0,2,19,10 +recursion,selected,104,1056.0,4,32,1,6,verifier_group_23,0,0,2,26,12 +recursion,selected,304,6144.0,16,33,1,4,verifier_group_24,0,0,2,19,8 +recursion,selected,304,6144.0,16,34,1,4,verifier_group_25,0,0,2,19,8 +recursion,selected,512,8016.0,8,35,1,21,verifier_group_26,0,0,2,64,42 +recursion,selected,1152,29184.0,32,36,1,10,verifier_group_27,0,0,2,36,20 +recursion,selected,2432,105344.0,128,37,1,9,MultiStark::b8_onto,0,0,1,19,18 +recursion,selected,256,5184.0,16,38,1,3,verifier_group_28,0,0,2,16,6 +recursion,selected,3968,138624.0,128,39,1,8,verifier_group_29,0,0,2,31,16 +recursion,selected,2496,65664.0,32,40,1,27,verifier_group_30,0,0,2,78,54 +recursion,selected,1408,29184.0,32,41,1,6,verifier_group_31,0,0,2,44,12 +recursion,selected,5120,278528.0,512,42,1,4,"${""name"":""MultiStark::list_concat"",""types"":[""field""]}",0,0,1,10,8 +recursion,selected,1216,38784.0,64,43,1,5,verifier_group_32,0,0,2,19,10 +recursion,selected,960,19584.0,32,44,1,3,verifier_group_33,0,0,2,30,6 +recursion,selected,1376,29664.0,32,45,1,7,verifier_group_34,0,0,2,43,14 +recursion,selected,576,18048.0,64,46,2,2,MultiStark::two_adic_gen,0,0,2,9,2 +recursion,selected,704,11328.0,16,47,1,5,verifier_group_35,0,0,2,44,10 +recursion,selected,104,1752.0,8,48,1,3,verifier_group_36,0,0,2,13,6 +recursion,selected,288,6336.0,16,49,1,5,verifier_group_37,0,0,2,18,10 +recursion,selected,848,15232.0,16,50,1,12,MultiStark::ch_sample_bits,0,0,1,53,24 +recursion,selected,320,10944.0,32,51,1,4,MultiStark::take_bits,0,0,2,10,8 +recursion,selected,328,3912.0,8,52,2,8,MultiStark::rows_pop,0,0,2,41,8 +recursion,selected,1280,26304.0,32,53,1,5,verifier_group_38,0,0,2,40,10 +recursion,selected,512,50176.0,256,54,1,2,,256,11,1,2,4 +recursion,selected,458752,60555264.0,65536,55,2,7,,65536,14,2,7,8 +recursion,selected,1024,157696.0,1024,56,1,1,,1024,3,1,1,2 +recursion,selected,24576,2080768.0,4096,57,1,3,,0,0,1,6,6 +recursion,selected,224,7328.0,32,58,1,3,,0,0,1,7,6 +recursion,selected,8,48.0,1,59,1,3,,0,0,1,8,6 +recursion,selected,1152,46208.0,128,60,1,3,,0,0,1,9,6 +recursion,selected,80,1328.0,8,61,1,3,,0,0,1,10,6 +recursion,selected,11,57.0,1,62,1,3,,0,0,1,11,6 +recursion,selected,416,10208.0,32,63,1,3,,0,0,1,13,6 +recursion,selected,28,140.0,2,64,1,3,,0,0,1,14,6 +recursion,selected,58,230.0,2,65,1,3,,0,0,1,29,6 +recursion,selected,560,8320.0,16,66,1,3,,0,0,1,35,6 +recursion,selected,592,8704.0,16,67,1,3,,0,0,1,37,6 +recursion-real,baseline,219,951.0,1,0,1,48,MultiStark::verify_multi_stark_proof,0,0,1,219,96 +recursion-real,baseline,11534336,1459617792.0,1048576,1,1,4,MultiStark::read_byte_stream,0,0,2,11,8 +recursion-real,baseline,6750208,371982336.0,32768,2,1,21,verifier_group_03,0,0,2,206,42 +recursion-real,baseline,525336576,46003126272.0,1048576,3,2,226,Blake3::compress,0,0,2,501,226 +recursion-real,baseline,35651584,3592421376.0,2097152,4,2,6,Blake3::compress_chunks,0,0,2,17,6 +recursion-real,baseline,24772608,1611399168.0,65536,5,1,65,verifier_group_12,0,0,2,378,130 +recursion-real,baseline,19398656,1390411776.0,262144,6,1,10,verifier_group_00,0,0,2,74,20 +recursion-real,baseline,1114112,68222976.0,32768,7,1,4,verifier_group_08,0,0,2,34,8 +recursion-real,baseline,229376,19300352.0,32768,8,1,2,"${""name"":""Lists::is_empty"",""types"":[""field""]}",0,0,1,7,4 +recursion-real,baseline,5242880,696254464.0,1048576,9,1,2,MultiStark::read_vk_u8,0,0,1,5,4 +recursion-real,baseline,425984,21823488.0,8192,10,1,6,verifier_group_02,0,0,2,52,12 +recursion-real,baseline,655360,74055680.0,131072,11,1,2,MultiStark::read_vk_tag,0,0,1,5,4 +recursion-real,baseline,3670016,450363392.0,524288,12,1,3,MultiStark::read_vk_u16,0,0,1,7,6 +recursion-real,baseline,5767168,563085312.0,131072,13,1,18,MultiStark::read_nodes_n,0,0,2,44,36 +recursion-real,baseline,1966080,182059008.0,131072,14,1,4,verifier_group_11,0,0,2,15,8 +recursion-real,baseline,10496,340224.0,128,15,1,20,verifier_group_13,0,0,2,82,40 +recursion-real,baseline,1458176,76578816.0,16384,16,1,9,verifier_group_10,0,0,2,89,18 +recursion-real,baseline,2408448,149520384.0,16384,17,1,33,verifier_group_04,0,0,2,147,66 +recursion-real,baseline,4194304,371195904.0,262144,18,1,3,verifier_group_05,0,0,2,16,6 +recursion-real,baseline,19922944,2457862144.0,1048576,19,1,9,MultiStark::read_u64_at,0,0,1,19,18 +recursion-real,baseline,46,306.0,2,20,1,10,MultiStark::read_header_vec_n,0,0,2,23,20 +recursion-real,baseline,401408,20865024.0,8192,21,1,6,verifier_group_06,0,0,2,49,12 +recursion-real,baseline,5120,342016.0,1024,22,1,2,MultiStark::read_u8_at,0,0,1,5,4 +recursion-real,baseline,458752,47448064.0,65536,23,1,3,MultiStark::read_u64_vec,0,0,1,7,6 +recursion-real,baseline,18874368,1900019712.0,1048576,24,1,4,MultiStark::read_u64_vec_n,0,0,2,18,8 +recursion-real,baseline,640,16704.0,32,25,1,5,MultiStark::read_message_vec_n,0,0,2,20,10 +recursion-real,baseline,68,300.0,2,26,1,4,MultiStark::read_proof_vec_n,0,0,2,34,8 +recursion-real,baseline,53,297.0,1,27,1,22,MultiStark::read_proof,0,0,1,53,44 +recursion-real,baseline,1835008,132907008.0,65536,28,1,5,verifier_group_09,0,0,2,28,10 +recursion-real,baseline,40,168.0,1,29,2,11,MultiStark::verify_batch,0,0,2,40,12 +recursion-real,baseline,16,78.0,1,30,2,5,MultiStark::assert_shard_count_ok,0,0,2,16,6 +recursion-real,baseline,62,270.0,2,31,1,3,"${""name"":""MultiStark::list_length"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::Proof""}}]}",0,0,2,31,6 +recursion-real,baseline,2544,38016.0,16,32,2,33,MultiStark::assert_closure_pairs,0,0,2,159,34 +recursion-real,baseline,1248,24608.0,32,33,1,5,MultiStark::three_limbs,0,0,1,39,10 +recursion-real,baseline,1664,53248.0,64,34,1,9,MultiStark::bytes8_le,0,0,1,26,18 +recursion-real,baseline,704,20352.0,64,35,2,2,MultiStark::le_step,0,0,2,11,2 +recursion-real,baseline,73,429.0,1,36,1,34,MultiStark::batch_fiat_shamir,0,0,1,73,68 +recursion-real,baseline,7,51.0,1,37,1,4,MultiStark::messages_onto,0,0,1,7,8 +recursion-real,baseline,1152,33024.0,64,38,2,6,MultiStark::count_onto,0,0,2,18,6 +recursion-real,baseline,1245184,122945536.0,65536,39,1,9,MultiStark::b8_onto,0,0,1,19,18 +recursion-real,baseline,672,17888.0,32,40,1,7,MultiStark::messages_onto_each,0,0,1,21,14 +recursion-real,baseline,15728640,1585446912.0,1048576,41,1,3,"${""name"":""MultiStark::list_length"",""types"":[{""array"":{""element"":""field"",""length"":8}}]}",0,0,2,15,6 +recursion-real,baseline,26,146.0,2,42,1,4,MultiStark::headers_onto,0,0,1,13,8 +recursion-real,baseline,13,87.0,1,43,1,7,MultiStark::header_onto,0,0,1,13,14 +recursion-real,baseline,2816,142336.0,256,44,1,5,MultiStark::active_onto,0,0,1,11,10 +recursion-real,baseline,524288,57409536.0,65536,45,1,3,"${""name"":""MultiStark::list_length"",""types"":[""field""]}",0,0,2,8,6 +recursion-real,baseline,7,51.0,1,46,1,4,MultiStark::claims_onto,0,0,1,7,8 +recursion-real,baseline,24,164.0,2,47,1,6,MultiStark::claims_onto_each,0,0,1,12,12 +recursion-real,baseline,1114112,92012544.0,65536,48,1,4,verifier_group_16,0,0,2,17,8 +recursion-real,baseline,20480,1359872.0,2048,49,1,4,"${""name"":""MultiStark::list_concat"",""types"":[""field""]}",0,0,1,10,8 +recursion-real,baseline,1024,19584.0,32,50,2,4,MultiStark::messages_acc,0,0,2,32,4 +recursion-real,baseline,120,444.0,2,51,2,5,MultiStark::verify_shards,0,0,2,60,6 +recursion-real,baseline,125,681.0,1,52,1,50,MultiStark::verify_shard,0,0,1,125,100 +recursion-real,baseline,1703936,155320320.0,131072,53,1,3,verifier_group_19,0,0,2,13,6 +recursion-real,baseline,5632,324096.0,512,54,1,4,MultiStark::assert_same_bits,0,0,2,11,8 +recursion-real,baseline,158,642.0,2,55,1,10,MultiStark::assert_same_cap,0,0,2,79,20 +recursion-real,baseline,884736,49053696.0,32768,56,1,1,UInt64::eq,0,0,2,27,2 +recursion-real,baseline,2304,117760.0,256,57,1,4,MultiStark::assert_log_degrees_ok,0,0,1,9,8 +recursion-real,baseline,2208,36384.0,32,58,1,1,MultiStark::log_degree_ok,0,0,2,69,2 +recursion-real,baseline,2048,113664.0,256,59,1,3,MultiStark::count_ones,0,0,2,8,6 +recursion-real,baseline,64,252.0,1,60,2,15,MultiStark::shard_fiat_shamir,0,0,2,64,16 +recursion-real,baseline,6684672,649986048.0,131072,61,1,21,verifier_group_15,0,0,2,51,42 +recursion-real,baseline,5898240,436076544.0,131072,62,1,8,verifier_group_17,0,0,2,45,16 +recursion-real,baseline,5505024,375914496.0,131072,63,1,5,MultiStark::eval_at,0,0,2,42,10 +recursion-real,baseline,1310720,120848384.0,131072,64,1,3,"${""name"":""MultiStark::list_lookup"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::SysNode""}}]}",0,0,1,10,6 +recursion-real,baseline,458752,32833536.0,32768,65,1,2,verifier_group_14,0,0,2,14,4 +recursion-real,baseline,9472,232704.0,128,66,2,7,MultiStark::digest_eq,0,0,2,74,8 +recursion-real,baseline,98304,7127040.0,8192,67,2,5,MultiStark::assert_same_claims,0,0,2,12,6 +recursion-real,baseline,851968,53477376.0,32768,68,2,5,MultiStark::assert_same_limbs,0,0,2,26,6 +recursion-real,baseline,30146560,1940127744.0,131072,69,1,28,MultiStark::b3_rows_chunks,0,0,2,230,56 +recursion-real,baseline,42991616,3347054592.0,1048576,70,2,8,MultiStark::rows_pop,0,0,2,41,8 +recursion-real,baseline,31457280,3032481792.0,1048576,71,1,7,MultiStark::select_rows,0,0,2,30,14 +recursion-real,baseline,1572864,120324096.0,65536,72,2,9,MultiStark::ri_apply,0,0,2,24,10 +recursion-real,baseline,32505856,2592079872.0,1048576,73,2,5,MultiStark::bucket_update,0,0,2,31,6 +recursion-real,baseline,75497472,5838471168.0,2097152,74,2,4,MultiStark::ro_fold,0,0,2,36,4 +recursion-real,baseline,3584,138240.0,256,75,2,4,MultiStark::last_acc,0,0,2,14,4 +recursion-real,baseline,24,152.0,2,76,1,5,MultiStark::batch_claims,0,0,1,12,10 +recursion-real,baseline,512,50176.0,256,77,1,2,,256,11,1,2,4 +recursion-real,baseline,458752,60555264.0,65536,78,2,7,,65536,14,2,7,8 +recursion-real,baseline,1024,157696.0,1024,79,1,1,,1024,3,1,1,2 +recursion-real,baseline,25165824,3892314112.0,4194304,80,1,3,,0,0,1,6,6 +recursion-real,baseline,229376,22249472.0,32768,81,1,3,,0,0,1,7,6 +recursion-real,baseline,256,7808.0,32,82,1,3,,0,0,1,8,6 +recursion-real,baseline,2359296,241696768.0,262144,83,1,3,,0,0,1,9,6 +recursion-real,baseline,10485760,1136656384.0,1048576,84,1,3,,0,0,1,10,6 +recursion-real,baseline,11264,587776.0,1024,85,1,3,,0,0,1,11,6 +recursion-real,baseline,13631488,1325400064.0,1048576,86,1,3,,0,0,1,13,6 +recursion-real,baseline,7168,306176.0,512,87,1,3,,0,0,1,14,6 +recursion-real,baseline,58,230.0,2,88,1,3,,0,0,1,29,6 +recursion-real,baseline,4587520,287965184.0,131072,89,1,3,,0,0,1,35,6 +recursion-real,baseline,606208,31031296.0,16384,90,1,3,,0,0,1,37,6 +recursion-real,selected,219,951.0,1,0,1,48,MultiStark::verify_multi_stark_proof,0,0,1,219,96 +recursion-real,selected,14680064,1648361472.0,1048576,1,1,4,verifier_group_00,0,0,2,14,8 +recursion-real,selected,1433600,66232320.0,8192,2,1,14,verifier_group_01,0,0,2,175,28 +recursion-real,selected,3719168,233472000.0,16384,3,1,54,verifier_group_02,0,0,2,227,108 +recursion-real,selected,525336576,46003126272.0,1048576,4,2,226,Blake3::compress,0,0,2,501,226 +recursion-real,selected,35651584,3592421376.0,2097152,5,2,6,Blake3::compress_chunks,0,0,2,17,6 +recursion-real,selected,106496,5566464.0,2048,6,1,13,verifier_group_03,0,0,2,52,26 +recursion-real,selected,4685824,408846336.0,32768,7,1,65,verifier_group_04,0,0,2,143,130 +recursion-real,selected,8192,503808.0,1024,8,2,3,Blake3::pad_block,0,0,2,8,4 +recursion-real,selected,31457280,2006974464.0,131072,9,1,28,verifier_group_05,0,0,2,240,56 +recursion-real,selected,5898240,502923264.0,131072,10,1,13,verifier_group_06,0,0,2,45,26 +recursion-real,selected,247808,9824256.0,2048,11,1,10,verifier_group_07,0,0,2,121,20 +recursion-real,selected,655360,63700992.0,65536,12,1,3,verifier_group_08,0,0,2,10,6 +recursion-real,selected,5242880,696254464.0,1048576,13,1,2,MultiStark::read_vk_u8,0,0,1,5,4 +recursion-real,selected,1982464,133005312.0,16384,14,1,34,verifier_group_09,0,0,2,121,68 +recursion-real,selected,122880,6832128.0,4096,15,1,6,verifier_group_10,0,0,2,30,12 +recursion-real,selected,655360,74055680.0,131072,16,1,2,MultiStark::read_vk_tag,0,0,1,5,4 +recursion-real,selected,5767168,563085312.0,131072,17,1,18,MultiStark::read_nodes_n,0,0,2,44,36 +recursion-real,selected,32505856,3095396352.0,1048576,18,1,7,verifier_group_11,0,0,2,31,14 +recursion-real,selected,720896,73138176.0,65536,19,1,4,MultiStark::read_node_ids_n,0,0,2,11,8 +recursion-real,selected,23552,1148928.0,1024,20,1,5,verifier_group_12,0,0,2,23,10 +recursion-real,selected,81920,4349952.0,2048,21,1,10,verifier_group_13,0,0,2,40,20 +recursion-real,selected,114688,5947392.0,4096,22,1,4,verifier_group_14,0,0,2,28,8 +recursion-real,selected,6528,176256.0,128,23,1,5,verifier_group_15,0,0,2,51,10 +recursion-real,selected,1638400,148635648.0,65536,24,1,9,verifier_group_16,0,0,2,25,18 +recursion-real,selected,9216,595968.0,1024,25,1,3,verifier_group_17,0,0,2,9,6 +recursion-real,selected,122880,6242304.0,4096,26,1,4,verifier_group_18,0,0,2,30,8 +recursion-real,selected,20971520,2654994432.0,1048576,27,1,9,verifier_group_19,0,0,2,20,18 +recursion-real,selected,720896,73138176.0,65536,28,1,4,MultiStark::read_u64_vec_vec_n,0,0,2,11,8 +recursion-real,selected,20971520,2025848832.0,1048576,29,1,4,verifier_group_20,0,0,2,20,8 +recursion-real,selected,1081344,69697536.0,32768,30,1,5,verifier_group_21,0,0,2,33,10 +recursion-real,selected,1245184,104595456.0,65536,31,1,5,verifier_group_22,0,0,2,19,10 +recursion-real,selected,53248,2863104.0,2048,32,1,6,verifier_group_23,0,0,2,26,12 +recursion-real,selected,38912,2119680.0,2048,33,1,4,verifier_group_24,0,0,2,19,8 +recursion-real,selected,622592,46104576.0,32768,34,1,4,verifier_group_25,0,0,2,19,8 +recursion-real,selected,1048576,75890688.0,16384,35,1,21,verifier_group_26,0,0,2,64,42 +recursion-real,selected,294912,19267584.0,8192,36,1,10,verifier_group_27,0,0,2,36,20 +recursion-real,selected,1245184,122945536.0,65536,37,1,9,MultiStark::b8_onto,0,0,1,19,18 +recursion-real,selected,16777216,1648361472.0,1048576,38,1,3,verifier_group_28,0,0,2,16,6 +recursion-real,selected,507904,35291136.0,16384,39,1,8,verifier_group_29,0,0,2,31,16 +recursion-real,selected,19968,838656.0,256,40,1,27,verifier_group_30,0,0,2,78,54 +recursion-real,selected,11264,371712.0,256,41,1,6,verifier_group_31,0,0,2,44,12 +recursion-real,selected,20480,1359872.0,2048,42,1,4,"${""name"":""MultiStark::list_concat"",""types"":[""field""]}",0,0,1,10,8 +recursion-real,selected,622592,49053696.0,32768,43,1,5,verifier_group_32,0,0,2,19,10 +recursion-real,selected,983040,59375616.0,32768,44,1,3,verifier_group_33,0,0,2,30,6 +recursion-real,selected,5636096,409337856.0,131072,45,1,7,verifier_group_34,0,0,2,43,14 +recursion-real,selected,576,18048.0,64,46,2,2,MultiStark::two_adic_gen,0,0,2,9,2 +recursion-real,selected,5767168,389283840.0,131072,47,1,5,verifier_group_35,0,0,2,44,10 +recursion-real,selected,1703936,155320320.0,131072,48,1,3,verifier_group_36,0,0,2,13,6 +recursion-real,selected,294912,22216704.0,16384,49,1,5,verifier_group_37,0,0,2,18,10 +recursion-real,selected,3392,91264.0,64,50,1,12,MultiStark::ch_sample_bits,0,0,1,53,24 +recursion-real,selected,20480,1511424.0,2048,51,1,4,MultiStark::take_bits,0,0,2,10,8 +recursion-real,selected,42991616,3347054592.0,1048576,52,2,8,MultiStark::rows_pop,0,0,2,41,8 +recursion-real,selected,83886080,7159676928.0,2097152,53,1,5,verifier_group_38,0,0,2,40,10 +recursion-real,selected,512,50176.0,256,54,1,2,,256,11,1,2,4 +recursion-real,selected,458752,60555264.0,65536,55,2,7,,65536,14,2,7,8 +recursion-real,selected,1024,157696.0,1024,56,1,1,,1024,3,1,1,2 +recursion-real,selected,25165824,3892314112.0,4194304,57,1,3,,0,0,1,6,6 +recursion-real,selected,229376,22249472.0,32768,58,1,3,,0,0,1,7,6 +recursion-real,selected,256,7808.0,32,59,1,3,,0,0,1,8,6 +recursion-real,selected,2359296,241696768.0,262144,60,1,3,,0,0,1,9,6 +recursion-real,selected,10485760,1136656384.0,1048576,61,1,3,,0,0,1,10,6 +recursion-real,selected,11264,587776.0,1024,62,1,3,,0,0,1,11,6 +recursion-real,selected,13631488,1325400064.0,1048576,63,1,3,,0,0,1,13,6 +recursion-real,selected,7168,306176.0,512,64,1,3,,0,0,1,14,6 +recursion-real,selected,58,230.0,2,65,1,3,,0,0,1,29,6 +recursion-real,selected,4587520,287965184.0,131072,66,1,3,,0,0,1,35,6 +recursion-real,selected,606208,31031296.0,16384,67,1,3,,0,0,1,37,6 diff --git a/docs/benchmarks/formal-aiur-grouping-tuning/environment-counts.json b/docs/benchmarks/formal-aiur-grouping-tuning/environment-counts.json new file mode 100644 index 000000000..b6ee5900f --- /dev/null +++ b/docs/benchmarks/formal-aiur-grouping-tuning/environment-counts.json @@ -0,0 +1,4151 @@ +{ + "backend": "new-bytecode", + "circuits": [], + "function_rows": [ + { + "chip": "IxVM::verify_claim", + "name": "IxVM::verify_claim", + "rows": 1 + }, + { + "chip": "IxVM::run_claim", + "name": "IxVM::run_claim", + "rows": 1 + }, + { + "chip": "IxVM::read_finite_byte_stream", + "name": "IxVM::read_finite_byte_stream", + "rows": 364 + }, + { + "chip": "IxVM::read_byte_stream", + "name": "IxVM::read_byte_stream", + "rows": 104050 + }, + { + "chip": "${\"name\":\"IxVM::list_depth_checked\",\"types\":[\"field\"]}", + "name": "${\"name\":\"IxVM::list_depth_checked\",\"types\":[\"field\"]}", + "rows": 91464 + }, + { + "chip": "IxVM::checked_depth_succ", + "name": "IxVM::checked_depth_succ", + "rows": 11636 + }, + { + "chip": "UInt32::less_than_fields", + "name": "UInt32::less_than_fields", + "rows": 12209 + }, + { + "chip": "Blake3::compress_layer", + "name": "Blake3::compress_layer", + "rows": 1057 + }, + { + "chip": "Blake3::next_layer", + "name": "Blake3::next_layer", + "rows": 14 + }, + { + "chip": "Blake3::compress", + "name": "Blake3::compress", + "rows": 21280 + }, + { + "chip": "Blake3::compress_chunks", + "name": "Blake3::compress_chunks", + "rows": 126811 + }, + { + "chip": "Blake3::finish", + "name": "Blake3::finish", + "rows": 1050 + }, + { + "chip": "UInt64::is_zero", + "name": "UInt64::is_zero", + "rows": 90 + }, + { + "chip": "Blake3::bytes_to_block", + "name": "Blake3::bytes_to_block", + "rows": 2428 + }, + { + "chip": "Blake3::pad_block", + "name": "Blake3::pad_block", + "rows": 33178 + }, + { + "chip": "Blake3::compress_block", + "name": "Blake3::compress_block", + "rows": 1614 + }, + { + "chip": "${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}", + "name": "${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}", + "rows": 1413 + }, + { + "chip": "UInt64::wrapping_succ", + "name": "UInt64::wrapping_succ", + "rows": 1 + }, + { + "chip": "IxVM::get_tagn4", + "name": "IxVM::get_tagn4", + "rows": 17168 + }, + { + "chip": "IxVM::get_tagn_tail", + "name": "IxVM::get_tagn_tail", + "rows": 1166 + }, + { + "chip": "IxVM::get_tagn_wide", + "name": "IxVM::get_tagn_wide", + "rows": 0 + }, + { + "chip": "IxVM::get_u64_le", + "name": "IxVM::get_u64_le", + "rows": 0 + }, + { + "chip": "UInt64::add", + "name": "UInt64::add", + "rows": 18 + }, + { + "chip": "IxVM::read_byte", + "name": "IxVM::read_byte", + "rows": 4144 + }, + { + "chip": "IxVM::get_address", + "name": "IxVM::get_address", + "rows": 2022 + }, + { + "chip": "IxVM::get_opt_addr", + "name": "IxVM::get_opt_addr", + "rows": 1 + }, + { + "chip": "IxVM::run_eval", + "name": "IxVM::run_eval", + "rows": 0 + }, + { + "chip": "IxVM::run_check", + "name": "IxVM::run_check", + "rows": 313 + }, + { + "chip": "IxVM::get_ci", + "name": "IxVM::get_ci", + "rows": 313 + }, + { + "chip": "IxVM::load_verified_constant", + "name": "IxVM::load_verified_constant", + "rows": 342 + }, + { + "chip": "Blake3::verify_bytes_against", + "name": "Blake3::verify_bytes_against", + "rows": 362 + }, + { + "chip": "IxVM::get_constant", + "name": "IxVM::get_constant", + "rows": 342 + }, + { + "chip": "IxVM::get_mut_const_list", + "name": "IxVM::get_mut_const_list", + "rows": 54 + }, + { + "chip": "IxVM::get_mut_const", + "name": "IxVM::get_mut_const", + "rows": 29 + }, + { + "chip": "IxVM::get_definition", + "name": "IxVM::get_definition", + "rows": 237 + }, + { + "chip": "IxVM::unpack_def_kind_safety", + "name": "IxVM::unpack_def_kind_safety", + "rows": 2 + }, + { + "chip": "IxVM::get_tagn0", + "name": "IxVM::get_tagn0", + "rows": 4190 + }, + { + "chip": "IxVM::get_expr", + "name": "IxVM::get_expr", + "rows": 16825 + }, + { + "chip": "IxVM::get_u64_list", + "name": "IxVM::get_u64_list", + "rows": 2944 + }, + { + "chip": "UInt64::saturating_pred", + "name": "UInt64::saturating_pred", + "rows": 74 + }, + { + "chip": "IxVM::get_app_telescope", + "name": "IxVM::get_app_telescope", + "rows": 10307 + }, + { + "chip": "IxVM::get_lam_telescope", + "name": "IxVM::get_lam_telescope", + "rows": 2449 + }, + { + "chip": "IxVM::get_lam_mode", + "name": "IxVM::get_lam_mode", + "rows": 1689 + }, + { + "chip": "IxVM::binder_contract_from_bits", + "name": "IxVM::binder_contract_from_bits", + "rows": 1 + }, + { + "chip": "IxVM::value_contract_from_bits", + "name": "IxVM::value_contract_from_bits", + "rows": 1 + }, + { + "chip": "IxVM::get_all_telescope", + "name": "IxVM::get_all_telescope", + "rows": 2031 + }, + { + "chip": "IxVM::get_all_mode", + "name": "IxVM::get_all_mode", + "rows": 1418 + }, + { + "chip": "IxVM::get_expr_let", + "name": "IxVM::get_expr_let", + "rows": 12 + }, + { + "chip": "IxVM::get_inductive", + "name": "IxVM::get_inductive", + "rows": 29 + }, + { + "chip": "IxVM::assert_wire_bool", + "name": "IxVM::assert_wire_bool", + "rows": 1 + }, + { + "chip": "IxVM::get_constructor_list", + "name": "IxVM::get_constructor_list", + "rows": 60 + }, + { + "chip": "IxVM::get_constructor", + "name": "IxVM::get_constructor", + "rows": 35 + }, + { + "chip": "IxVM::get_recursor", + "name": "IxVM::get_recursor", + "rows": 12 + }, + { + "chip": "IxVM::get_recursor_rule_list", + "name": "IxVM::get_recursor_rule_list", + "rows": 30 + }, + { + "chip": "IxVM::get_constant_info_by_variant", + "name": "IxVM::get_constant_info_by_variant", + "rows": 313 + }, + { + "chip": "IxVM::get_axiom", + "name": "IxVM::get_axiom", + "rows": 0 + }, + { + "chip": "IxVM::get_quotient", + "name": "IxVM::get_quotient", + "rows": 0 + }, + { + "chip": "IxVM::get_quot_kind", + "name": "IxVM::get_quot_kind", + "rows": 0 + }, + { + "chip": "IxVM::get_constructor_proj", + "name": "IxVM::get_constructor_proj", + "rows": 35 + }, + { + "chip": "IxVM::get_recursor_proj", + "name": "IxVM::get_recursor_proj", + "rows": 0 + }, + { + "chip": "IxVM::get_recursor_proj", + "name": "IxVM::get_inductive_proj", + "rows": 29 + }, + { + "chip": "IxVM::get_recursor_proj", + "name": "IxVM::get_definition_proj", + "rows": 0 + }, + { + "chip": "IxVM::get_expr_list", + "name": "IxVM::get_expr_list", + "rows": 1671 + }, + { + "chip": "IxVM::get_address_list", + "name": "IxVM::get_address_list", + "rows": 1674 + }, + { + "chip": "IxVM::get_univ_list", + "name": "IxVM::get_univ_list", + "rows": 39 + }, + { + "chip": "IxVM::get_univ", + "name": "IxVM::get_univ", + "rows": 72 + }, + { + "chip": "IxVM::get_tagn2", + "name": "IxVM::get_tagn2", + "rows": 72 + }, + { + "chip": "IxVM::build_succ_chain", + "name": "IxVM::build_succ_chain", + "rows": 11 + }, + { + "chip": "IxVM::load_constant_hint", + "name": "IxVM::load_constant_hint", + "rows": 237 + }, + { + "chip": "IxVM::defn_is_unsafe_ci", + "name": "IxVM::defn_is_unsafe_ci", + "rows": 2 + }, + { + "chip": "IxVM::convert_definition", + "name": "IxVM::convert_definition", + "rows": 237 + }, + { + "chip": "IxVM::convert_expr", + "name": "IxVM::convert_expr", + "rows": 14678 + }, + { + "chip": "${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "name": "${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "rows": 72 + }, + { + "chip": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "name": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "rows": 72 + }, + { + "chip": "UInt64::to_field", + "name": "UInt64::to_field", + "rows": 74 + }, + { + "chip": "IxVM::convert_univ", + "name": "IxVM::convert_univ", + "rows": 20 + }, + { + "chip": "${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "name": "${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}}]}", + "rows": 1888 + }, + { + "chip": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "name": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}}]}", + "rows": 1888 + }, + { + "chip": "IxVM::convert_univ_idxs", + "name": "IxVM::convert_univ_idxs", + "rows": 107 + }, + { + "chip": "IxVM::load_verified_blob", + "name": "IxVM::load_verified_blob", + "rows": 20 + }, + { + "chip": "IxVM::utf8_validate", + "name": "IxVM::utf8_validate", + "rows": 0 + }, + { + "chip": "IxVM::utf8_decode_one", + "name": "IxVM::utf8_decode_one", + "rows": 0 + }, + { + "chip": "IxVM::utf8_cont", + "name": "IxVM::utf8_cont", + "rows": 0 + }, + { + "chip": "IxVM::bytes_to_limbs", + "name": "IxVM::bytes_to_limbs", + "rows": 20 + }, + { + "chip": "IxVM::bytes_to_u64_limb", + "name": "IxVM::bytes_to_u64_limb", + "rows": 53 + }, + { + "chip": "IxVM::skip_bytes", + "name": "IxVM::skip_bytes", + "rows": 37 + }, + { + "chip": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "name": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Expr\"}}}}]}", + "rows": 1389 + }, + { + "chip": "IxVM::convert_axiom", + "name": "IxVM::convert_axiom", + "rows": 0 + }, + { + "chip": "IxVM::convert_quotient", + "name": "IxVM::convert_quotient", + "rows": 0 + }, + { + "chip": "IxVM::get_ci_dprj", + "name": "IxVM::get_ci_dprj", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}", + "name": "${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}", + "rows": 0 + }, + { + "chip": "IxVM::defn_member_recur_addrs", + "name": "IxVM::defn_member_recur_addrs", + "rows": 0 + }, + { + "chip": "IxVM::build_recur_addrs", + "name": "IxVM::build_recur_addrs", + "rows": 29 + }, + { + "chip": "IxVM::build_recur_addrs_walk", + "name": "IxVM::build_recur_addrs_walk", + "rows": 58 + }, + { + "chip": "IxVM::projection_addr", + "name": "IxVM::projection_addr", + "rows": 29 + }, + { + "chip": "IxVM::muts_member_at", + "name": "IxVM::muts_member_at", + "rows": 28 + }, + { + "chip": "UInt64::from_field", + "name": "UInt64::from_field", + "rows": 2 + }, + { + "chip": "IxVM::put_constant", + "name": "IxVM::put_constant", + "rows": 47 + }, + { + "chip": "IxVM::put_sharing", + "name": "IxVM::put_sharing", + "rows": 1 + }, + { + "chip": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Expr\"}}}}]}", + "name": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Expr\"}}}}]}", + "rows": 1 + }, + { + "chip": "IxVM::put_tagn0", + "name": "IxVM::put_tagn0", + "rows": 57 + }, + { + "chip": "IxVM::put_tagn_tail", + "name": "IxVM::put_tagn_tail", + "rows": 0 + }, + { + "chip": "IxVM::put_tagn_wide", + "name": "IxVM::put_tagn_wide", + "rows": 0 + }, + { + "chip": "IxVM::put_u64_le", + "name": "IxVM::put_u64_le", + "rows": 0 + }, + { + "chip": "IxVM::put_expr_list", + "name": "IxVM::put_expr_list", + "rows": 1 + }, + { + "chip": "IxVM::put_expr", + "name": "IxVM::put_expr", + "rows": 0 + }, + { + "chip": "IxVM::put_tagn4", + "name": "IxVM::put_tagn4", + "rows": 47 + }, + { + "chip": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "name": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "rows": 0 + }, + { + "chip": "IxVM::put_u64_list", + "name": "IxVM::put_u64_list", + "rows": 0 + }, + { + "chip": "IxVM::app_telescope_count", + "name": "IxVM::app_telescope_count", + "rows": 0 + }, + { + "chip": "IxVM::put_app_telescope", + "name": "IxVM::put_app_telescope", + "rows": 0 + }, + { + "chip": "IxVM::lam_telescope_count", + "name": "IxVM::lam_telescope_count", + "rows": 0 + }, + { + "chip": "IxVM::put_lam_telescope", + "name": "IxVM::put_lam_telescope", + "rows": 0 + }, + { + "chip": "IxVM::put_lam_mode", + "name": "IxVM::put_lam_mode", + "rows": 0 + }, + { + "chip": "IxVM::binder_contract_code", + "name": "IxVM::binder_contract_code", + "rows": 0 + }, + { + "chip": "IxVM::value_contract_code", + "name": "IxVM::value_contract_code", + "rows": 0 + }, + { + "chip": "IxVM::all_telescope_count", + "name": "IxVM::all_telescope_count", + "rows": 0 + }, + { + "chip": "IxVM::put_all_telescope", + "name": "IxVM::put_all_telescope", + "rows": 0 + }, + { + "chip": "IxVM::put_all_mode", + "name": "IxVM::put_all_mode", + "rows": 0 + }, + { + "chip": "IxVM::put_refs", + "name": "IxVM::put_refs", + "rows": 1 + }, + { + "chip": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Expr\"}}}}]}", + "name": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}}]}", + "rows": 1 + }, + { + "chip": "IxVM::put_address_list", + "name": "IxVM::put_address_list", + "rows": 1 + }, + { + "chip": "IxVM::put_address", + "name": "IxVM::put_address", + "rows": 1058 + }, + { + "chip": "IxVM::put_univs", + "name": "IxVM::put_univs", + "rows": 1 + }, + { + "chip": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Expr\"}}}}]}", + "name": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "rows": 1 + }, + { + "chip": "IxVM::put_univ_list", + "name": "IxVM::put_univ_list", + "rows": 1 + }, + { + "chip": "IxVM::put_univ", + "name": "IxVM::put_univ", + "rows": 0 + }, + { + "chip": "IxVM::univ_succ_count", + "name": "IxVM::univ_succ_count", + "rows": 0 + }, + { + "chip": "IxVM::univ_succ_base", + "name": "IxVM::univ_succ_base", + "rows": 0 + }, + { + "chip": "IxVM::put_tagn2", + "name": "IxVM::put_tagn2", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}", + "name": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}", + "rows": 0 + }, + { + "chip": "IxVM::put_mut_const_list", + "name": "IxVM::put_mut_const_list", + "rows": 0 + }, + { + "chip": "IxVM::put_mut_const", + "name": "IxVM::put_mut_const", + "rows": 0 + }, + { + "chip": "IxVM::put_definition", + "name": "IxVM::put_definition", + "rows": 0 + }, + { + "chip": "IxVM::pack_def_kind_safety", + "name": "IxVM::pack_def_kind_safety", + "rows": 0 + }, + { + "chip": "IxVM::put_inductive", + "name": "IxVM::put_inductive", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}", + "name": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}", + "rows": 0 + }, + { + "chip": "IxVM::put_constructor_list", + "name": "IxVM::put_constructor_list", + "rows": 0 + }, + { + "chip": "IxVM::put_constructor", + "name": "IxVM::put_constructor", + "rows": 0 + }, + { + "chip": "IxVM::put_recursor", + "name": "IxVM::put_recursor", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::RecursorRule\"}}]}", + "name": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::RecursorRule\"}}]}", + "rows": 0 + }, + { + "chip": "IxVM::put_recursor_rule_list", + "name": "IxVM::put_recursor_rule_list", + "rows": 0 + }, + { + "chip": "IxVM::put_recursor_rule", + "name": "IxVM::put_recursor_rule", + "rows": 0 + }, + { + "chip": "IxVM::put_constant_info", + "name": "IxVM::put_constant_info", + "rows": 47 + }, + { + "chip": "IxVM::put_axiom", + "name": "IxVM::put_axiom", + "rows": 0 + }, + { + "chip": "IxVM::put_quotient", + "name": "IxVM::put_quotient", + "rows": 0 + }, + { + "chip": "IxVM::put_quot_kind", + "name": "IxVM::put_quot_kind", + "rows": 0 + }, + { + "chip": "IxVM::put_constructor_proj", + "name": "IxVM::put_constructor_proj", + "rows": 18 + }, + { + "chip": "IxVM::put_recursor_proj", + "name": "IxVM::put_recursor_proj", + "rows": 0 + }, + { + "chip": "IxVM::put_recursor_proj", + "name": "IxVM::put_inductive_proj", + "rows": 29 + }, + { + "chip": "IxVM::put_recursor_proj", + "name": "IxVM::put_definition_proj", + "rows": 0 + }, + { + "chip": "Blake3::bytes_to_addr", + "name": "Blake3::bytes_to_addr", + "rows": 734 + }, + { + "chip": "IxVM::get_ci_iprj", + "name": "IxVM::get_ci_iprj", + "rows": 29 + }, + { + "chip": "IxVM::convert_inductive", + "name": "IxVM::convert_inductive", + "rows": 29 + }, + { + "chip": "IxVM::count_ctors", + "name": "IxVM::count_ctors", + "rows": 35 + }, + { + "chip": "IxVM::get_ci_cprj", + "name": "IxVM::get_ci_cprj", + "rows": 35 + }, + { + "chip": "IxVM::ctor_at", + "name": "IxVM::ctor_at", + "rows": 41 + }, + { + "chip": "IxVM::convert_constructor", + "name": "IxVM::convert_constructor", + "rows": 35 + }, + { + "chip": "IxVM::get_ci_rprj", + "name": "IxVM::get_ci_rprj", + "rows": 0 + }, + { + "chip": "IxVM::convert_recursor", + "name": "IxVM::convert_recursor", + "rows": 12 + }, + { + "chip": "IxVM::convert_rec_rules", + "name": "IxVM::convert_rec_rules", + "rows": 30 + }, + { + "chip": "IxVM::check_const", + "name": "IxVM::check_const", + "rows": 313 + }, + { + "chip": "IxVM::is_unsafe_ci", + "name": "IxVM::is_unsafe_ci", + "rows": 313 + }, + { + "chip": "IxVM::validate_expr_well_scoped", + "name": "IxVM::validate_expr_well_scoped", + "rows": 10689 + }, + { + "chip": "IxVM::validate_univ_params_seen", + "name": "IxVM::validate_univ_params_seen", + "rows": 30 + }, + { + "chip": "IxVM::const_num_lvls", + "name": "IxVM::const_num_lvls", + "rows": 310 + }, + { + "chip": "${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}", + "rows": 35 + }, + { + "chip": "IxVM::validate_univ_params_list", + "name": "IxVM::validate_univ_params_list", + "rows": 43 + }, + { + "chip": "IxVM::k_ensure_sort", + "name": "IxVM::k_ensure_sort", + "rows": 2495 + }, + { + "chip": "IxVM::k_infer", + "name": "IxVM::k_infer", + "rows": 8162 + }, + { + "chip": "IxVM::expr_lbr", + "name": "IxVM::expr_lbr", + "rows": 22064 + }, + { + "chip": "IxVM::lbr_max", + "name": "IxVM::lbr_max", + "rows": 383 + }, + { + "chip": "IxVM::lbr_dec", + "name": "IxVM::lbr_dec", + "rows": 28 + }, + { + "chip": "IxVM::expr_lbr_let", + "name": "IxVM::expr_lbr_let", + "rows": 14 + }, + { + "chip": "IxVM::k_infer_core", + "name": "IxVM::k_infer_core", + "rows": 5150 + }, + { + "chip": "IxVM::types_lookup", + "name": "IxVM::types_lookup", + "rows": 624 + }, + { + "chip": "${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "name": "${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "rows": 5566 + }, + { + "chip": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "name": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "rows": 12483 + }, + { + "chip": "IxVM::expr_lift", + "name": "IxVM::expr_lift", + "rows": 11293 + }, + { + "chip": "IxVM::expr_lift_walk", + "name": "IxVM::expr_lift_walk", + "rows": 8605 + }, + { + "chip": "IxVM::expr_lift_bvar", + "name": "IxVM::expr_lift_bvar", + "rows": 545 + }, + { + "chip": "IxVM::expr_lift_let", + "name": "IxVM::expr_lift_let", + "rows": 0 + }, + { + "chip": "IxVM::level_reduce", + "name": "IxVM::level_reduce", + "rows": 29 + }, + { + "chip": "IxVM::level_max", + "name": "IxVM::level_max", + "rows": 81 + }, + { + "chip": "IxVM::level_explicit_val", + "name": "IxVM::level_explicit_val", + "rows": 23 + }, + { + "chip": "IxVM::level_max_go", + "name": "IxVM::level_max_go", + "rows": 77 + }, + { + "chip": "IxVM::level_struct_eq", + "name": "IxVM::level_struct_eq", + "rows": 187 + }, + { + "chip": "IxVM::level_max_subsumes", + "name": "IxVM::level_max_subsumes", + "rows": 129 + }, + { + "chip": "IxVM::level_max_offsets", + "name": "IxVM::level_max_offsets", + "rows": 61 + }, + { + "chip": "IxVM::level_offset_of", + "name": "IxVM::level_offset_of", + "rows": 72 + }, + { + "chip": "IxVM::level_imax", + "name": "IxVM::level_imax", + "rows": 183 + }, + { + "chip": "IxVM::level_is_not_zero", + "name": "IxVM::level_is_not_zero", + "rows": 126 + }, + { + "chip": "IxVM::level_struct_eq", + "name": "IxVM::level_eq", + "rows": 154 + }, + { + "chip": "IxVM::const_type_of", + "name": "IxVM::const_type_of", + "rows": 310 + }, + { + "chip": "IxVM::expr_inst_levels", + "name": "IxVM::expr_inst_levels", + "rows": 2904 + }, + { + "chip": "IxVM::expr_inst_levels_walk", + "name": "IxVM::expr_inst_levels_walk", + "rows": 2693 + }, + { + "chip": "IxVM::level_inst_params", + "name": "IxVM::level_inst_params", + "rows": 174 + }, + { + "chip": "${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "name": "${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}", + "rows": 67 + }, + { + "chip": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "name": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}", + "rows": 67 + }, + { + "chip": "IxVM::level_list_inst", + "name": "IxVM::level_list_inst", + "rows": 140 + }, + { + "chip": "IxVM::collect_spine", + "name": "IxVM::collect_spine", + "rows": 11818 + }, + { + "chip": "${\"name\":\"IxVM::list_snoc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_snoc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "rows": 10919 + }, + { + "chip": "IxVM::k_infer_app_spine_loop", + "name": "IxVM::k_infer_app_spine_loop", + "rows": 5861 + }, + { + "chip": "${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "rows": 7341 + }, + { + "chip": "IxVM::expr_inst_many", + "name": "IxVM::expr_inst_many", + "rows": 20447 + }, + { + "chip": "IxVM::has_bvar_in_range", + "name": "IxVM::has_bvar_in_range", + "rows": 8143 + }, + { + "chip": "IxVM::has_bvar_in_range_binder", + "name": "IxVM::has_bvar_in_range_binder", + "rows": 1293 + }, + { + "chip": "IxVM::has_bvar_in_range_let", + "name": "IxVM::has_bvar_in_range_let", + "rows": 0 + }, + { + "chip": "IxVM::expr_inst_many_walk", + "name": "IxVM::expr_inst_many_walk", + "rows": 14568 + }, + { + "chip": "IxVM::expr_inst_many_bvar", + "name": "IxVM::expr_inst_many_bvar", + "rows": 4956 + }, + { + "chip": "IxVM::expr_inst_many_let", + "name": "IxVM::expr_inst_many_let", + "rows": 0 + }, + { + "chip": "IxVM::expr_lower", + "name": "IxVM::expr_lower", + "rows": 18782 + }, + { + "chip": "IxVM::expr_lower_walk", + "name": "IxVM::expr_lower_walk", + "rows": 16566 + }, + { + "chip": "IxVM::k_check", + "name": "IxVM::k_check", + "rows": 3313 + }, + { + "chip": "IxVM::k_is_def_eq", + "name": "IxVM::k_is_def_eq", + "rows": 6888 + }, + { + "chip": "IxVM::k_is_def_eq_core", + "name": "IxVM::k_is_def_eq_core", + "rows": 3597 + }, + { + "chip": "IxVM::k_is_def_eq_ordered", + "name": "IxVM::k_is_def_eq_ordered", + "rows": 3597 + }, + { + "chip": "IxVM::try_def_eq_app", + "name": "IxVM::try_def_eq_app", + "rows": 3916 + }, + { + "chip": "IxVM::de_args", + "name": "IxVM::de_args", + "rows": 3389 + }, + { + "chip": "IxVM::address_eq", + "name": "IxVM::address_eq", + "rows": 5755 + }, + { + "chip": "IxVM::address_eq_tail", + "name": "IxVM::address_eq_tail", + "rows": 176 + }, + { + "chip": "IxVM::level_list_eq", + "name": "IxVM::level_list_eq", + "rows": 28 + }, + { + "chip": "IxVM::level_equal", + "name": "IxVM::level_equal", + "rows": 32 + }, + { + "chip": "IxVM::nl_eq", + "name": "IxVM::nl_eq", + "rows": 23 + }, + { + "chip": "IxVM::nl_skip_empty", + "name": "IxVM::nl_skip_empty", + "rows": 21 + }, + { + "chip": "IxVM::glist_cmp", + "name": "IxVM::glist_cmp", + "rows": 10 + }, + { + "chip": "IxVM::nlvars_eq", + "name": "IxVM::nlvars_eq", + "rows": 5 + }, + { + "chip": "IxVM::level_normalize", + "name": "IxVM::level_normalize", + "rows": 23 + }, + { + "chip": "IxVM::normalize_aux", + "name": "IxVM::normalize_aux", + "rows": 79 + }, + { + "chip": "IxVM::nl_add_const", + "name": "IxVM::nl_add_const", + "rows": 14 + }, + { + "chip": "IxVM::nl_add_const_go", + "name": "IxVM::nl_add_const_go", + "rows": 12 + }, + { + "chip": "IxVM::normalize_imax_dispatch", + "name": "IxVM::normalize_imax_dispatch", + "rows": 0 + }, + { + "chip": "IxVM::glist_ordered_insert", + "name": "IxVM::glist_ordered_insert", + "rows": 3 + }, + { + "chip": "IxVM::nl_add_var", + "name": "IxVM::nl_add_var", + "rows": 31 + }, + { + "chip": "IxVM::nlvars_add", + "name": "IxVM::nlvars_add", + "rows": 3 + }, + { + "chip": "IxVM::nl_subsumption_walk", + "name": "IxVM::nl_subsumption_walk", + "rows": 47 + }, + { + "chip": "IxVM::nl_subsume_entry", + "name": "IxVM::nl_subsume_entry", + "rows": 86 + }, + { + "chip": "IxVM::glist_subset", + "name": "IxVM::glist_subset", + "rows": 16 + }, + { + "chip": "IxVM::glist_eq_len", + "name": "IxVM::glist_eq_len", + "rows": 7 + }, + { + "chip": "IxVM::nlvars_max_offset", + "name": "IxVM::nlvars_max_offset", + "rows": 0 + }, + { + "chip": "IxVM::nlvars_subsume", + "name": "IxVM::nlvars_subsume", + "rows": 0 + }, + { + "chip": "IxVM::k_is_def_eq_slow", + "name": "IxVM::k_is_def_eq_slow", + "rows": 2291 + }, + { + "chip": "IxVM::try_string_lit_one", + "name": "IxVM::try_string_lit_one", + "rows": 3551 + }, + { + "chip": "IxVM::str_lit_delta_step", + "name": "IxVM::str_lit_delta_step", + "rows": 0 + }, + { + "chip": "IxVM::whnf_nd", + "name": "IxVM::whnf_nd", + "rows": 1388 + }, + { + "chip": "IxVM::whnf_nd_with_spine", + "name": "IxVM::whnf_nd_with_spine", + "rows": 2814 + }, + { + "chip": "${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "rows": 3749 + }, + { + "chip": "IxVM::whnf_nd_apply_beta", + "name": "IxVM::whnf_nd_apply_beta", + "rows": 470 + }, + { + "chip": "IxVM::peel_beta", + "name": "IxVM::peel_beta", + "rows": 4214 + }, + { + "chip": "IxVM::apply_spine", + "name": "IxVM::apply_spine", + "rows": 6399 + }, + { + "chip": "IxVM::expr_inst1", + "name": "IxVM::expr_inst1", + "rows": 5723 + }, + { + "chip": "IxVM::expr_has_bvar_at", + "name": "IxVM::expr_has_bvar_at", + "rows": 6449 + }, + { + "chip": "IxVM::expr_has_bvar_at_binder", + "name": "IxVM::expr_has_bvar_at_binder", + "rows": 1603 + }, + { + "chip": "IxVM::expr_has_bvar_at_let", + "name": "IxVM::expr_has_bvar_at_let", + "rows": 0 + }, + { + "chip": "IxVM::expr_inst1_walk", + "name": "IxVM::expr_inst1_walk", + "rows": 3433 + }, + { + "chip": "IxVM::expr_inst1_bvar", + "name": "IxVM::expr_inst1_bvar", + "rows": 445 + }, + { + "chip": "IxVM::expr_inst1_let", + "name": "IxVM::expr_inst1_let", + "rows": 0 + }, + { + "chip": "IxVM::whnf_nd_const_head", + "name": "IxVM::whnf_nd_const_head", + "rows": 676 + }, + { + "chip": "IxVM::prim_family", + "name": "IxVM::prim_family", + "rows": 125 + }, + { + "chip": "IxVM::nat_succ_addr", + "name": "IxVM::nat_succ_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_pred_addr", + "name": "IxVM::nat_pred_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_add_addr", + "name": "IxVM::nat_add_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_sub_addr", + "name": "IxVM::nat_sub_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_mul_addr", + "name": "IxVM::nat_mul_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_div_addr", + "name": "IxVM::nat_div_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_mod_addr", + "name": "IxVM::nat_mod_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_pow_addr", + "name": "IxVM::nat_pow_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_gcd_addr", + "name": "IxVM::nat_gcd_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_beq_addr", + "name": "IxVM::nat_beq_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_ble_addr", + "name": "IxVM::nat_ble_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_land_addr", + "name": "IxVM::nat_land_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_lor_addr", + "name": "IxVM::nat_lor_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_xor_addr", + "name": "IxVM::nat_xor_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_shift_left_addr", + "name": "IxVM::nat_shift_left_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_shift_right_addr", + "name": "IxVM::nat_shift_right_addr", + "rows": 1 + }, + { + "chip": "IxVM::is_str_prim_addr", + "name": "IxVM::is_str_prim_addr", + "rows": 116 + }, + { + "chip": "IxVM::string_utf8_byte_size_addr", + "name": "IxVM::string_utf8_byte_size_addr", + "rows": 1 + }, + { + "chip": "IxVM::string_append_addr", + "name": "IxVM::string_append_addr", + "rows": 1 + }, + { + "chip": "IxVM::string_of_list_addr", + "name": "IxVM::string_of_list_addr", + "rows": 1 + }, + { + "chip": "IxVM::string_back_addr", + "name": "IxVM::string_back_addr", + "rows": 1 + }, + { + "chip": "IxVM::string_legacy_back_addr", + "name": "IxVM::string_legacy_back_addr", + "rows": 1 + }, + { + "chip": "IxVM::string_to_byte_array_addr", + "name": "IxVM::string_to_byte_array_addr", + "rows": 1 + }, + { + "chip": "IxVM::string_dec_eq_addr", + "name": "IxVM::string_dec_eq_addr", + "rows": 1 + }, + { + "chip": "IxVM::is_bitvec_prim_addr", + "name": "IxVM::is_bitvec_prim_addr", + "rows": 116 + }, + { + "chip": "IxVM::bit_vec_to_nat_addr", + "name": "IxVM::bit_vec_to_nat_addr", + "rows": 1 + }, + { + "chip": "IxVM::bit_vec_ult_addr", + "name": "IxVM::bit_vec_ult_addr", + "rows": 1 + }, + { + "chip": "IxVM::decidable_decide_addr", + "name": "IxVM::decidable_decide_addr", + "rows": 1 + }, + { + "chip": "IxVM::is_native_prim_addr", + "name": "IxVM::is_native_prim_addr", + "rows": 114 + }, + { + "chip": "IxVM::system_platform_num_bits_addr", + "name": "IxVM::system_platform_num_bits_addr", + "rows": 1 + }, + { + "chip": "IxVM::punit_size_of_1_addr", + "name": "IxVM::punit_size_of_1_addr", + "rows": 1 + }, + { + "chip": "IxVM::reduce_bool_addr", + "name": "IxVM::reduce_bool_addr", + "rows": 1 + }, + { + "chip": "IxVM::reduce_nat_addr", + "name": "IxVM::reduce_nat_addr", + "rows": 1 + }, + { + "chip": "IxVM::subtype_val_addr", + "name": "IxVM::subtype_val_addr", + "rows": 1 + }, + { + "chip": "IxVM::is_dec_prim_addr", + "name": "IxVM::is_dec_prim_addr", + "rows": 114 + }, + { + "chip": "IxVM::nat_dec_le_addr_dec", + "name": "IxVM::nat_dec_le_addr_dec", + "rows": 1 + }, + { + "chip": "IxVM::nat_dec_eq_addr_dec", + "name": "IxVM::nat_dec_eq_addr_dec", + "rows": 1 + }, + { + "chip": "IxVM::nat_dec_lt_addr_dec", + "name": "IxVM::nat_dec_lt_addr_dec", + "rows": 1 + }, + { + "chip": "IxVM::int_dec_le_addr_dec", + "name": "IxVM::int_dec_le_addr_dec", + "rows": 1 + }, + { + "chip": "IxVM::int_dec_eq_addr_dec", + "name": "IxVM::int_dec_eq_addr_dec", + "rows": 1 + }, + { + "chip": "IxVM::int_dec_lt_addr_dec", + "name": "IxVM::int_dec_lt_addr_dec", + "rows": 1 + }, + { + "chip": "IxVM::is_int_prim_addr", + "name": "IxVM::is_int_prim_addr", + "rows": 112 + }, + { + "chip": "IxVM::int_add_addr", + "name": "IxVM::int_add_addr", + "rows": 1 + }, + { + "chip": "IxVM::int_sub_addr", + "name": "IxVM::int_sub_addr", + "rows": 1 + }, + { + "chip": "IxVM::int_mul_addr", + "name": "IxVM::int_mul_addr", + "rows": 1 + }, + { + "chip": "IxVM::int_neg_addr", + "name": "IxVM::int_neg_addr", + "rows": 1 + }, + { + "chip": "IxVM::int_emod_addr", + "name": "IxVM::int_emod_addr", + "rows": 1 + }, + { + "chip": "IxVM::int_ediv_addr", + "name": "IxVM::int_ediv_addr", + "rows": 1 + }, + { + "chip": "IxVM::int_bmod_addr", + "name": "IxVM::int_bmod_addr", + "rows": 1 + }, + { + "chip": "IxVM::int_bdiv_addr", + "name": "IxVM::int_bdiv_addr", + "rows": 1 + }, + { + "chip": "IxVM::int_nat_abs_addr", + "name": "IxVM::int_nat_abs_addr", + "rows": 1 + }, + { + "chip": "IxVM::int_pow_addr", + "name": "IxVM::int_pow_addr", + "rows": 1 + }, + { + "chip": "IxVM::try_prim_dispatch", + "name": "IxVM::try_prim_dispatch", + "rows": 1076 + }, + { + "chip": "IxVM::try_nat_dispatch_prewhnf", + "name": "IxVM::try_nat_dispatch_prewhnf", + "rows": 89 + }, + { + "chip": "IxVM::whnf_spine", + "name": "IxVM::whnf_spine", + "rows": 125 + }, + { + "chip": "IxVM::whnf", + "name": "IxVM::whnf", + "rows": 2292 + }, + { + "chip": "IxVM::whnf_with_spine", + "name": "IxVM::whnf_with_spine", + "rows": 2591 + }, + { + "chip": "IxVM::whnf_apply_beta", + "name": "IxVM::whnf_apply_beta", + "rows": 611 + }, + { + "chip": "IxVM::whnf_const_head", + "name": "IxVM::whnf_const_head", + "rows": 722 + }, + { + "chip": "IxVM::try_reduce_projection_definition", + "name": "IxVM::try_reduce_projection_definition", + "rows": 602 + }, + { + "chip": "IxVM::projection_definition_info", + "name": "IxVM::projection_definition_info", + "rows": 266 + }, + { + "chip": "IxVM::try_quot_iota", + "name": "IxVM::try_quot_iota", + "rows": 0 + }, + { + "chip": "IxVM::quot_lift_addr_iota", + "name": "IxVM::quot_lift_addr_iota", + "rows": 0 + }, + { + "chip": "IxVM::try_quot_lift", + "name": "IxVM::try_quot_lift", + "rows": 0 + }, + { + "chip": "IxVM::quot_extract_arg", + "name": "IxVM::quot_extract_arg", + "rows": 0 + }, + { + "chip": "IxVM::quot_ctor_addr_iota", + "name": "IxVM::quot_ctor_addr_iota", + "rows": 0 + }, + { + "chip": "IxVM::quot_ind_addr_iota", + "name": "IxVM::quot_ind_addr_iota", + "rows": 0 + }, + { + "chip": "IxVM::try_quot_ind", + "name": "IxVM::try_quot_ind", + "rows": 0 + }, + { + "chip": "IxVM::se_parent_addr", + "name": "IxVM::se_parent_addr", + "rows": 6 + }, + { + "chip": "IxVM::try_k_synth_iota", + "name": "IxVM::try_k_synth_iota", + "rows": 2 + }, + { + "chip": "IxVM::k_synth_gate", + "name": "IxVM::k_synth_gate", + "rows": 2 + }, + { + "chip": "IxVM::canon_cprj_addr", + "name": "IxVM::canon_cprj_addr", + "rows": 1 + }, + { + "chip": "${\"name\":\"IxVM::list_take\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_take\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "rows": 1866 + }, + { + "chip": "IxVM::try_iota", + "name": "IxVM::try_iota", + "rows": 193 + }, + { + "chip": "IxVM::try_nat_linear_rec", + "name": "IxVM::try_nat_linear_rec", + "rows": 174 + }, + { + "chip": "IxVM::try_extract_nat", + "name": "IxVM::try_extract_nat", + "rows": 84 + }, + { + "chip": "IxVM::nat_zero_addr", + "name": "IxVM::nat_zero_addr", + "rows": 1 + }, + { + "chip": "IxVM::try_extract_nat_app", + "name": "IxVM::try_extract_nat_app", + "rows": 66 + }, + { + "chip": "IxVM::klimbs_succ", + "name": "IxVM::klimbs_succ", + "rows": 4 + }, + { + "chip": "IxVM::is_nat_succ_ih_step", + "name": "IxVM::is_nat_succ_ih_step", + "rows": 16 + }, + { + "chip": "IxVM::apply_spine", + "name": "IxVM::np_apply_spine", + "rows": 9 + }, + { + "chip": "IxVM::mk_nat_lit", + "name": "IxVM::mk_nat_lit", + "rows": 6 + }, + { + "chip": "IxVM::klimbs_add", + "name": "IxVM::klimbs_add", + "rows": 22 + }, + { + "chip": "IxVM::klimbs_add_carry", + "name": "IxVM::klimbs_add_carry", + "rows": 22 + }, + { + "chip": "IxVM::mk_nat_offset_stuck", + "name": "IxVM::mk_nat_offset_stuck", + "rows": 3 + }, + { + "chip": "IxVM::klimbs_is_zero", + "name": "IxVM::klimbs_is_zero", + "rows": 21 + }, + { + "chip": "IxVM::klimbs_normalize", + "name": "IxVM::klimbs_normalize", + "rows": 25 + }, + { + "chip": "IxVM::cleanup_nat_offset_major", + "name": "IxVM::cleanup_nat_offset_major", + "rows": 92 + }, + { + "chip": "IxVM::try_match_nat_add", + "name": "IxVM::try_match_nat_add", + "rows": 73 + }, + { + "chip": "IxVM::build_succ_offset", + "name": "IxVM::build_succ_offset", + "rows": 1 + }, + { + "chip": "IxVM::klimbs_sub", + "name": "IxVM::klimbs_sub", + "rows": 33 + }, + { + "chip": "IxVM::klimbs_sub_borrow", + "name": "IxVM::klimbs_sub_borrow", + "rows": 34 + }, + { + "chip": "UInt64::sub_with_borrow", + "name": "UInt64::sub_with_borrow", + "rows": 49 + }, + { + "chip": "IxVM::whnf_iota_major", + "name": "IxVM::whnf_iota_major", + "rows": 109 + }, + { + "chip": "IxVM::nat_lit_to_ctor_or_self", + "name": "IxVM::nat_lit_to_ctor_or_self", + "rows": 55 + }, + { + "chip": "IxVM::nat_zero_addr", + "name": "IxVM::nat_zero_addr_iota", + "rows": 1 + }, + { + "chip": "IxVM::klimbs_dec", + "name": "IxVM::klimbs_dec", + "rows": 2 + }, + { + "chip": "IxVM::nat_succ_addr", + "name": "IxVM::nat_succ_addr_iota", + "rows": 1 + }, + { + "chip": "IxVM::collect_spine_of_ctor", + "name": "IxVM::collect_spine_of_ctor", + "rows": 54 + }, + { + "chip": "IxVM::compute_iprj_addr", + "name": "IxVM::compute_iprj_addr", + "rows": 8 + }, + { + "chip": "IxVM::find_rule", + "name": "IxVM::find_rule", + "rows": 12 + }, + { + "chip": "IxVM::replace_spine_major", + "name": "IxVM::replace_spine_major", + "rows": 55 + }, + { + "chip": "IxVM::rec_to_parent_addr", + "name": "IxVM::rec_to_parent_addr", + "rows": 12 + }, + { + "chip": "IxVM::peel_n_foralls", + "name": "IxVM::peel_n_foralls", + "rows": 262 + }, + { + "chip": "IxVM::try_struct_eta_iota", + "name": "IxVM::try_struct_eta_iota", + "rows": 51 + }, + { + "chip": "IxVM::struct_is_rec", + "name": "IxVM::struct_is_rec", + "rows": 4 + }, + { + "chip": "IxVM::struct_block_member_addrs", + "name": "IxVM::struct_block_member_addrs", + "rows": 4 + }, + { + "chip": "IxVM::struct_scan_ctors", + "name": "IxVM::struct_scan_ctors", + "rows": 8 + }, + { + "chip": "IxVM::se_peel_tol", + "name": "IxVM::se_peel_tol", + "rows": 11 + }, + { + "chip": "IxVM::se_scan_fields", + "name": "IxVM::se_scan_fields", + "rows": 9 + }, + { + "chip": "IxVM::se_mentions", + "name": "IxVM::se_mentions", + "rows": 14 + }, + { + "chip": "IxVM::se_addr_in", + "name": "IxVM::se_addr_in", + "rows": 0 + }, + { + "chip": "IxVM::is_prop_type", + "name": "IxVM::is_prop_type", + "rows": 93 + }, + { + "chip": "IxVM::k_infer_only", + "name": "IxVM::k_infer_only", + "rows": 813 + }, + { + "chip": "IxVM::const_num_lvls", + "name": "IxVM::io_const_num_lvls", + "rows": 61 + }, + { + "chip": "IxVM::const_type_of", + "name": "IxVM::io_const_type_of", + "rows": 61 + }, + { + "chip": "IxVM::ensure_sort_only", + "name": "IxVM::ensure_sort_only", + "rows": 53 + }, + { + "chip": "IxVM::nat_addr_io", + "name": "IxVM::nat_addr_io", + "rows": 1 + }, + { + "chip": "IxVM::str_addr_io", + "name": "IxVM::str_addr_io", + "rows": 0 + }, + { + "chip": "IxVM::io_peel_params_subst", + "name": "IxVM::io_peel_params_subst", + "rows": 32 + }, + { + "chip": "IxVM::io_peel_field_loop", + "name": "IxVM::io_peel_field_loop", + "rows": 19 + }, + { + "chip": "IxVM::ctx_trim", + "name": "IxVM::ctx_trim", + "rows": 2099 + }, + { + "chip": "IxVM::ctx_seek_cut", + "name": "IxVM::ctx_seek_cut", + "rows": 1175 + }, + { + "chip": "IxVM::ctx_next_cut", + "name": "IxVM::ctx_next_cut", + "rows": 882 + }, + { + "chip": "IxVM::ctx_close_cut", + "name": "IxVM::ctx_close_cut", + "rows": 643 + }, + { + "chip": "IxVM::lbr_min", + "name": "IxVM::lbr_min", + "rows": 285 + }, + { + "chip": "IxVM::apply_n_projs", + "name": "IxVM::apply_n_projs", + "rows": 0 + }, + { + "chip": "IxVM::whnf_proj_head", + "name": "IxVM::whnf_proj_head", + "rows": 129 + }, + { + "chip": "IxVM::str_lit_to_ctor_app_or_self", + "name": "IxVM::str_lit_to_ctor_app_or_self", + "rows": 202 + }, + { + "chip": "IxVM::str_lit_to_ctor", + "name": "IxVM::str_lit_to_ctor", + "rows": 0 + }, + { + "chip": "IxVM::list_nil_addr", + "name": "IxVM::list_nil_addr", + "rows": 0 + }, + { + "chip": "IxVM::list_cons_addr", + "name": "IxVM::list_cons_addr", + "rows": 0 + }, + { + "chip": "IxVM::char_type_addr", + "name": "IxVM::char_type_addr", + "rows": 0 + }, + { + "chip": "IxVM::char_of_nat_addr", + "name": "IxVM::char_of_nat_addr", + "rows": 0 + }, + { + "chip": "IxVM::build_char_list", + "name": "IxVM::build_char_list", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_from_g", + "name": "IxVM::klimbs_from_g", + "rows": 0 + }, + { + "chip": "IxVM::split_u32", + "name": "IxVM::split_u32", + "rows": 0 + }, + { + "chip": "IxVM::divmod_256", + "name": "IxVM::divmod_256", + "rows": 0 + }, + { + "chip": "IxVM::try_reduce_fin_val_decidable_rec", + "name": "IxVM::try_reduce_fin_val_decidable_rec", + "rows": 103 + }, + { + "chip": "IxVM::fin_addr", + "name": "IxVM::fin_addr", + "rows": 1 + }, + { + "chip": "IxVM::decidable_rec_addr", + "name": "IxVM::decidable_rec_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_addr_io", + "name": "IxVM::nat_ty_addr", + "rows": 0 + }, + { + "chip": "IxVM::whnf_get_ctor_or_none", + "name": "IxVM::whnf_get_ctor_or_none", + "rows": 24 + }, + { + "chip": "IxVM::try_nat_binop_dispatch", + "name": "IxVM::try_nat_binop_dispatch", + "rows": 42 + }, + { + "chip": "IxVM::try_nat_binop_addr", + "name": "IxVM::try_nat_binop_addr", + "rows": 6 + }, + { + "chip": "IxVM::klimbs_mul", + "name": "IxVM::klimbs_mul", + "rows": 12 + }, + { + "chip": "IxVM::klimbs_mul_outer", + "name": "IxVM::klimbs_mul_outer", + "rows": 23 + }, + { + "chip": "IxVM::klimbs_mul_single", + "name": "IxVM::klimbs_mul_single", + "rows": 20 + }, + { + "chip": "UInt64::mul", + "name": "UInt64::mul", + "rows": 11 + }, + { + "chip": "IxVM::klimbs_shl_limbs", + "name": "IxVM::klimbs_shl_limbs", + "rows": 9 + }, + { + "chip": "IxVM::klimbs_div", + "name": "IxVM::klimbs_div", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_div_mod", + "name": "IxVM::klimbs_div_mod", + "rows": 6 + }, + { + "chip": "IxVM::ordinary_div_mod", + "name": "IxVM::ordinary_div_mod", + "rows": 6 + }, + { + "chip": "IxVM::divide_grow", + "name": "IxVM::divide_grow", + "rows": 21 + }, + { + "chip": "IxVM::klimbs_le", + "name": "IxVM::klimbs_le", + "rows": 31 + }, + { + "chip": "IxVM::klimbs_eq", + "name": "IxVM::klimbs_eq", + "rows": 23 + }, + { + "chip": "UInt64::eq", + "name": "UInt64::eq", + "rows": 20 + }, + { + "chip": "IxVM::klimbs_mod", + "name": "IxVM::klimbs_mod", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_gcd", + "name": "IxVM::klimbs_gcd", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_pow", + "name": "IxVM::klimbs_pow", + "rows": 7 + }, + { + "chip": "IxVM::klimbs_land", + "name": "IxVM::klimbs_land", + "rows": 0 + }, + { + "chip": "UInt64::and", + "name": "UInt64::and", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_lor", + "name": "IxVM::klimbs_lor", + "rows": 0 + }, + { + "chip": "UInt64::or", + "name": "UInt64::or", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_xor_op", + "name": "IxVM::klimbs_xor_op", + "rows": 0 + }, + { + "chip": "UInt64::xor", + "name": "UInt64::xor", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_shl", + "name": "IxVM::klimbs_shl", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_shr", + "name": "IxVM::klimbs_shr", + "rows": 0 + }, + { + "chip": "IxVM::mk_bool", + "name": "IxVM::mk_bool", + "rows": 2 + }, + { + "chip": "IxVM::bool_false_addr", + "name": "IxVM::bool_false_addr", + "rows": 1 + }, + { + "chip": "IxVM::bool_true_addr", + "name": "IxVM::bool_true_addr", + "rows": 1 + }, + { + "chip": "IxVM::try_nat_offset_dispatch", + "name": "IxVM::try_nat_offset_dispatch", + "rows": 5 + }, + { + "chip": "IxVM::mk_nat_binop_stuck", + "name": "IxVM::mk_nat_binop_stuck", + "rows": 0 + }, + { + "chip": "IxVM::try_str_dispatch", + "name": "IxVM::try_str_dispatch", + "rows": 0 + }, + { + "chip": "IxVM::walk_char_list_bytes", + "name": "IxVM::walk_char_list_bytes", + "rows": 0 + }, + { + "chip": "IxVM::char_lit_codepoint", + "name": "IxVM::char_lit_codepoint", + "rows": 0 + }, + { + "chip": "IxVM::char_lit_codepoint_syn", + "name": "IxVM::char_lit_codepoint_syn", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_scalar_value", + "name": "IxVM::klimbs_scalar_value", + "rows": 0 + }, + { + "chip": "IxVM::utf8_encode_prepend", + "name": "IxVM::utf8_encode_prepend", + "rows": 0 + }, + { + "chip": "IxVM::utf8_groups", + "name": "IxVM::utf8_groups", + "rows": 0 + }, + { + "chip": "IxVM::divmod_64u", + "name": "IxVM::divmod_64u", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_length\",\"types\":[\"field\"]}", + "rows": 4 + }, + { + "chip": "IxVM::try_str_back", + "name": "IxVM::try_str_back", + "rows": 0 + }, + { + "chip": "IxVM::utf8_last_codepoint", + "name": "IxVM::utf8_last_codepoint", + "rows": 0 + }, + { + "chip": "IxVM::utf8_last_go", + "name": "IxVM::utf8_last_go", + "rows": 0 + }, + { + "chip": "IxVM::try_str_to_byte_array", + "name": "IxVM::try_str_to_byte_array", + "rows": 0 + }, + { + "chip": "IxVM::byte_array_empty_addr", + "name": "IxVM::byte_array_empty_addr", + "rows": 0 + }, + { + "chip": "IxVM::try_str_dec_eq", + "name": "IxVM::try_str_dec_eq", + "rows": 0 + }, + { + "chip": "IxVM::bytestream_eq", + "name": "IxVM::bytestream_eq", + "rows": 0 + }, + { + "chip": "IxVM::str_dec_eq_build", + "name": "IxVM::str_dec_eq_build", + "rows": 0 + }, + { + "chip": "IxVM::eq_refl_addr_dec", + "name": "IxVM::eq_refl_addr_dec", + "rows": 1 + }, + { + "chip": "IxVM::str_addr_io", + "name": "IxVM::string_type_addr", + "rows": 0 + }, + { + "chip": "IxVM::decidable_is_true_addr_dec", + "name": "IxVM::decidable_is_true_addr_dec", + "rows": 1 + }, + { + "chip": "${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_concat\",\"types\":[\"field\"]}", + "rows": 4011 + }, + { + "chip": "IxVM::try_bitvec_dispatch", + "name": "IxVM::try_bitvec_dispatch", + "rows": 7 + }, + { + "chip": "IxVM::bitvec_prep_spine", + "name": "IxVM::bitvec_prep_spine", + "rows": 2 + }, + { + "chip": "IxVM::bv_to_nat_via", + "name": "IxVM::bv_to_nat_via", + "rows": 2 + }, + { + "chip": "IxVM::bitvec_of_nat_args_direct", + "name": "IxVM::bitvec_of_nat_args_direct", + "rows": 2 + }, + { + "chip": "IxVM::bit_vec_of_nat_addr", + "name": "IxVM::bit_vec_of_nat_addr", + "rows": 1 + }, + { + "chip": "IxVM::bitvec_prep_spine_ult", + "name": "IxVM::bitvec_prep_spine_ult", + "rows": 0 + }, + { + "chip": "IxVM::np_whnf_inner_bv", + "name": "IxVM::np_whnf_inner_bv", + "rows": 0 + }, + { + "chip": "IxVM::try_reduce_bit_vec_ult", + "name": "IxVM::try_reduce_bit_vec_ult", + "rows": 0 + }, + { + "chip": "IxVM::try_reduce_decide_bitvec_lt", + "name": "IxVM::try_reduce_decide_bitvec_lt", + "rows": 5 + }, + { + "chip": "IxVM::lt_lt_addr", + "name": "IxVM::lt_lt_addr", + "rows": 1 + }, + { + "chip": "IxVM::bit_vec_addr", + "name": "IxVM::bit_vec_addr", + "rows": 1 + }, + { + "chip": "IxVM::try_native_dispatch", + "name": "IxVM::try_native_dispatch", + "rows": 0 + }, + { + "chip": "IxVM::mk_nat_literal_64", + "name": "IxVM::mk_nat_literal_64", + "rows": 0 + }, + { + "chip": "IxVM::mk_nat_one", + "name": "IxVM::mk_nat_one", + "rows": 0 + }, + { + "chip": "IxVM::try_reduce_subtype_val", + "name": "IxVM::try_reduce_subtype_val", + "rows": 0 + }, + { + "chip": "IxVM::system_platform_get_num_bits_addr", + "name": "IxVM::system_platform_get_num_bits_addr", + "rows": 0 + }, + { + "chip": "IxVM::check_native_bool", + "name": "IxVM::check_native_bool", + "rows": 0 + }, + { + "chip": "IxVM::check_native_nat", + "name": "IxVM::check_native_nat", + "rows": 0 + }, + { + "chip": "IxVM::try_dec_dispatch", + "name": "IxVM::try_dec_dispatch", + "rows": 15 + }, + { + "chip": "IxVM::is_int_dec_prim_addr", + "name": "IxVM::is_int_dec_prim_addr", + "rows": 2 + }, + { + "chip": "IxVM::try_normalize_int_decidable", + "name": "IxVM::try_normalize_int_decidable", + "rows": 0 + }, + { + "chip": "IxVM::try_extract_int", + "name": "IxVM::try_extract_int", + "rows": 0 + }, + { + "chip": "IxVM::int_of_nat_addr_dec", + "name": "IxVM::int_of_nat_addr_dec", + "rows": 0 + }, + { + "chip": "IxVM::int_neg_succ_addr_dec", + "name": "IxVM::int_neg_succ_addr_dec", + "rows": 0 + }, + { + "chip": "IxVM::normalize_int_dec_rebuild", + "name": "IxVM::normalize_int_dec_rebuild", + "rows": 0 + }, + { + "chip": "IxVM::intern_int_lit", + "name": "IxVM::intern_int_lit", + "rows": 0 + }, + { + "chip": "IxVM::dec_rewrite_lt_to_le", + "name": "IxVM::dec_rewrite_lt_to_le", + "rows": 6 + }, + { + "chip": "IxVM::dec_dispatch_le_eq", + "name": "IxVM::dec_dispatch_le_eq", + "rows": 9 + }, + { + "chip": "IxVM::dec_build_proof", + "name": "IxVM::dec_build_proof", + "rows": 4 + }, + { + "chip": "IxVM::bool_type_addr_dec", + "name": "IxVM::bool_type_addr_dec", + "rows": 1 + }, + { + "chip": "IxVM::nat_le_of_ble_eq_true_addr_dec", + "name": "IxVM::nat_le_of_ble_eq_true_addr_dec", + "rows": 1 + }, + { + "chip": "IxVM::nat_not_le_of_not_ble_eq_true_addr_dec", + "name": "IxVM::nat_not_le_of_not_ble_eq_true_addr_dec", + "rows": 0 + }, + { + "chip": "IxVM::nat_eq_of_beq_eq_true_addr_dec", + "name": "IxVM::nat_eq_of_beq_eq_true_addr_dec", + "rows": 0 + }, + { + "chip": "IxVM::nat_ne_of_beq_eq_false_addr_dec", + "name": "IxVM::nat_ne_of_beq_eq_false_addr_dec", + "rows": 0 + }, + { + "chip": "IxVM::dec_finish", + "name": "IxVM::dec_finish", + "rows": 4 + }, + { + "chip": "IxVM::decidable_is_false_addr_dec", + "name": "IxVM::decidable_is_false_addr_dec", + "rows": 0 + }, + { + "chip": "IxVM::try_int_prim_dispatch", + "name": "IxVM::try_int_prim_dispatch", + "rows": 0 + }, + { + "chip": "IxVM::try_extract_int_prim", + "name": "IxVM::try_extract_int_prim", + "rows": 0 + }, + { + "chip": "IxVM::int_of_nat_addr_dec", + "name": "IxVM::int_of_nat_addr", + "rows": 0 + }, + { + "chip": "IxVM::int_neg_succ_addr_dec", + "name": "IxVM::int_neg_succ_addr", + "rows": 0 + }, + { + "chip": "IxVM::mk_int_prim", + "name": "IxVM::mk_int_prim", + "rows": 0 + }, + { + "chip": "IxVM::try_int_prim_second", + "name": "IxVM::try_int_prim_second", + "rows": 0 + }, + { + "chip": "IxVM::int_bmod_prim", + "name": "IxVM::int_bmod_prim", + "rows": 0 + }, + { + "chip": "IxVM::int_bdiv_prim", + "name": "IxVM::int_bdiv_prim", + "rows": 0 + }, + { + "chip": "IxVM::int_add_prim", + "name": "IxVM::int_add_prim", + "rows": 0 + }, + { + "chip": "IxVM::int_emod_prim", + "name": "IxVM::int_emod_prim", + "rows": 0 + }, + { + "chip": "IxVM::int_ediv_prim", + "name": "IxVM::int_ediv_prim", + "rows": 0 + }, + { + "chip": "IxVM::whnf_nd_proj_head", + "name": "IxVM::whnf_nd_proj_head", + "rows": 325 + }, + { + "chip": "IxVM::k_is_def_eq_slow_nd", + "name": "IxVM::k_is_def_eq_slow_nd", + "rows": 2291 + }, + { + "chip": "IxVM::whnf_struct_core", + "name": "IxVM::whnf_struct_core", + "rows": 3336 + }, + { + "chip": "IxVM::whnf_struct_core_spine", + "name": "IxVM::whnf_struct_core_spine", + "rows": 2225 + }, + { + "chip": "IxVM::whnf_struct_core_proj", + "name": "IxVM::whnf_struct_core_proj", + "rows": 26 + }, + { + "chip": "IxVM::whnf_struct_core_const", + "name": "IxVM::whnf_struct_core_const", + "rows": 463 + }, + { + "chip": "IxVM::k_is_def_eq_struct_safe", + "name": "IxVM::k_is_def_eq_struct_safe", + "rows": 2317 + }, + { + "chip": "IxVM::k_is_def_eq_slow_nd_after_core", + "name": "IxVM::k_is_def_eq_slow_nd_after_core", + "rows": 264 + }, + { + "chip": "IxVM::k_is_def_eq_slow2", + "name": "IxVM::k_is_def_eq_slow2", + "rows": 263 + }, + { + "chip": "IxVM::try_proof_irrel", + "name": "IxVM::try_proof_irrel", + "rows": 306 + }, + { + "chip": "IxVM::try_unit_like", + "name": "IxVM::try_unit_like", + "rows": 304 + }, + { + "chip": "IxVM::is_unit_like_type", + "name": "IxVM::is_unit_like_type", + "rows": 31 + }, + { + "chip": "IxVM::try_eta_struct", + "name": "IxVM::try_eta_struct", + "rows": 470 + }, + { + "chip": "IxVM::compare_struct_fields", + "name": "IxVM::compare_struct_fields", + "rows": 10 + }, + { + "chip": "IxVM::try_def_eq_nat", + "name": "IxVM::try_def_eq_nat", + "rows": 992 + }, + { + "chip": "IxVM::is_nat_zero", + "name": "IxVM::is_nat_zero", + "rows": 765 + }, + { + "chip": "IxVM::nat_offset_of", + "name": "IxVM::nat_offset_of", + "rows": 767 + }, + { + "chip": "IxVM::lazy_delta_loop", + "name": "IxVM::lazy_delta_loop", + "rows": 1031 + }, + { + "chip": "IxVM::head_addr", + "name": "IxVM::head_addr", + "rows": 739 + }, + { + "chip": "IxVM::lazy_delta_step_const_const", + "name": "IxVM::lazy_delta_step_const_const", + "rows": 301 + }, + { + "chip": "IxVM::is_defn_or_thm", + "name": "IxVM::is_defn_or_thm", + "rows": 76 + }, + { + "chip": "IxVM::unfold_b_and_loop", + "name": "IxVM::unfold_b_and_loop", + "rows": 55 + }, + { + "chip": "IxVM::delta_unfold", + "name": "IxVM::delta_unfold", + "rows": 316 + }, + { + "chip": "IxVM::unfold_a_and_loop", + "name": "IxVM::unfold_a_and_loop", + "rows": 75 + }, + { + "chip": "IxVM::delta_rank", + "name": "IxVM::delta_rank", + "rows": 34 + }, + { + "chip": "IxVM::unfold_both_and_loop", + "name": "IxVM::unfold_both_and_loop", + "rows": 55 + }, + { + "chip": "IxVM::lazy_delta_a_const_b_proj", + "name": "IxVM::lazy_delta_a_const_b_proj", + "rows": 181 + }, + { + "chip": "IxVM::try_unfold_proj_app", + "name": "IxVM::try_unfold_proj_app", + "rows": 465 + }, + { + "chip": "IxVM::try_unfold_head", + "name": "IxVM::try_unfold_head", + "rows": 144 + }, + { + "chip": "IxVM::lazy_delta_b_const_a_proj", + "name": "IxVM::lazy_delta_b_const_a_proj", + "rows": 215 + }, + { + "chip": "IxVM::lazy_delta_both_proj", + "name": "IxVM::lazy_delta_both_proj", + "rows": 296 + }, + { + "chip": "IxVM::slow2_after_delta", + "name": "IxVM::slow2_after_delta", + "rows": 235 + }, + { + "chip": "IxVM::k_is_def_eq_struct_bounded", + "name": "IxVM::k_is_def_eq_struct_bounded", + "rows": 3747 + }, + { + "chip": "IxVM::k_is_def_eq_struct_spend", + "name": "IxVM::k_is_def_eq_struct_spend", + "rows": 578 + }, + { + "chip": "IxVM::literal_eq", + "name": "IxVM::literal_eq", + "rows": 6 + }, + { + "chip": "IxVM::k_is_def_eq_structure_tree", + "name": "IxVM::k_is_def_eq_structure_tree", + "rows": 238 + }, + { + "chip": "IxVM::try_same_proj_head_app", + "name": "IxVM::try_same_proj_head_app", + "rows": 213 + }, + { + "chip": "IxVM::k_is_def_eq_structure_tree_app", + "name": "IxVM::k_is_def_eq_structure_tree_app", + "rows": 203 + }, + { + "chip": "IxVM::slow2_eager_fallback", + "name": "IxVM::slow2_eager_fallback", + "rows": 112 + }, + { + "chip": "IxVM::try_eta_swap", + "name": "IxVM::try_eta_swap", + "rows": 88 + }, + { + "chip": "IxVM::try_eta_expand", + "name": "IxVM::try_eta_expand", + "rows": 2 + }, + { + "chip": "IxVM::k_is_def_eq_struct", + "name": "IxVM::k_is_def_eq_struct", + "rows": 88 + }, + { + "chip": "IxVM::k_is_def_eq_struct_go", + "name": "IxVM::k_is_def_eq_struct_go", + "rows": 89 + }, + { + "chip": "IxVM::try_lazy_delta_app", + "name": "IxVM::try_lazy_delta_app", + "rows": 32 + }, + { + "chip": "IxVM::k_def_eq_rebase", + "name": "IxVM::k_def_eq_rebase", + "rows": 4797 + }, + { + "chip": "IxVM::expr_glb", + "name": "IxVM::expr_glb", + "rows": 25043 + }, + { + "chip": "IxVM::expr_glb_walk", + "name": "IxVM::expr_glb_walk", + "rows": 23339 + }, + { + "chip": "IxVM::expr_glb_binder", + "name": "IxVM::expr_glb_binder", + "rows": 6930 + }, + { + "chip": "IxVM::expr_glb_let", + "name": "IxVM::expr_glb_let", + "rows": 20 + }, + { + "chip": "IxVM::k_infer_let_start", + "name": "IxVM::k_infer_let_start", + "rows": 12 + }, + { + "chip": "IxVM::k_infer_let_env", + "name": "IxVM::k_infer_let_env", + "rows": 403 + }, + { + "chip": "IxVM::infer_let_local_cutoff", + "name": "IxVM::infer_let_local_cutoff", + "rows": 39 + }, + { + "chip": "IxVM::k_infer_let_env_core", + "name": "IxVM::k_infer_let_env_core", + "rows": 332 + }, + { + "chip": "IxVM::infer_let_lookup_type", + "name": "IxVM::infer_let_lookup_type", + "rows": 80 + }, + { + "chip": "IxVM::infer_let_materialize", + "name": "IxVM::infer_let_materialize", + "rows": 597 + }, + { + "chip": "IxVM::infer_let_lookup_value", + "name": "IxVM::infer_let_lookup_value", + "rows": 136 + }, + { + "chip": "IxVM::k_infer_let_env_rebase", + "name": "IxVM::k_infer_let_env_rebase", + "rows": 33 + }, + { + "chip": "IxVM::infer_let_drop_unused", + "name": "IxVM::infer_let_drop_unused", + "rows": 69 + }, + { + "chip": "IxVM::k_infer_lit", + "name": "IxVM::k_infer_lit", + "rows": 22 + }, + { + "chip": "IxVM::nat_addr_io", + "name": "IxVM::nat_addr", + "rows": 1 + }, + { + "chip": "IxVM::str_addr_io", + "name": "IxVM::str_addr", + "rows": 0 + }, + { + "chip": "IxVM::k_infer_proj", + "name": "IxVM::k_infer_proj", + "rows": 36 + }, + { + "chip": "IxVM::io_peel_params_subst", + "name": "IxVM::peel_params_subst", + "rows": 96 + }, + { + "chip": "IxVM::is_inductive_prop", + "name": "IxVM::is_inductive_prop", + "rows": 35 + }, + { + "chip": "IxVM::peel_n_alls_whnf", + "name": "IxVM::peel_n_alls_whnf", + "rows": 96 + }, + { + "chip": "IxVM::peel_field_loop", + "name": "IxVM::peel_field_loop", + "rows": 37 + }, + { + "chip": "IxVM::check_prop_field_if_prop", + "name": "IxVM::check_prop_field_if_prop", + "rows": 36 + }, + { + "chip": "IxVM::check_no_dep_data_field_if_prop", + "name": "IxVM::check_no_dep_data_field_if_prop", + "rows": 1 + }, + { + "chip": "IxVM::k_infer_rebase", + "name": "IxVM::k_infer_rebase", + "rows": 5870 + }, + { + "chip": "IxVM::assert_safety", + "name": "IxVM::assert_safety", + "rows": 510 + }, + { + "chip": "IxVM::safe_refs_only", + "name": "IxVM::safe_refs_only", + "rows": 7567 + }, + { + "chip": "IxVM::check_quot", + "name": "IxVM::check_quot", + "rows": 0 + }, + { + "chip": "IxVM::quot_type_addr", + "name": "IxVM::quot_type_addr", + "rows": 0 + }, + { + "chip": "IxVM::quot_ctor_addr_iota", + "name": "IxVM::quot_ctor_addr", + "rows": 0 + }, + { + "chip": "IxVM::quot_lift_addr_iota", + "name": "IxVM::quot_lift_addr", + "rows": 0 + }, + { + "chip": "IxVM::check_eq_type", + "name": "IxVM::check_eq_type", + "rows": 0 + }, + { + "chip": "IxVM::eq_type_addr", + "name": "IxVM::eq_type_addr", + "rows": 0 + }, + { + "chip": "IxVM::quot_ind_addr_iota", + "name": "IxVM::quot_ind_addr", + "rows": 0 + }, + { + "chip": "IxVM::count_foralls_at_least", + "name": "IxVM::count_foralls_at_least", + "rows": 0 + }, + { + "chip": "IxVM::check_canonical_block", + "name": "IxVM::check_canonical_block", + "rows": 41 + }, + { + "chip": "IxVM::canon_muts_has_kind", + "name": "IxVM::canon_muts_has_kind", + "rows": 57 + }, + { + "chip": "IxVM::canon_indc_positions", + "name": "IxVM::canon_indc_positions", + "rows": 29 + }, + { + "chip": "IxVM::canon_sort_loop", + "name": "IxVM::canon_sort_loop", + "rows": 0 + }, + { + "chip": "IxVM::canon_build_ctx_classes", + "name": "IxVM::canon_build_ctx_classes", + "rows": 0 + }, + { + "chip": "IxVM::canon_build_ctx_members", + "name": "IxVM::canon_build_ctx_members", + "rows": 0 + }, + { + "chip": "IxVM::canon_member_num_ctors", + "name": "IxVM::canon_member_num_ctors", + "rows": 0 + }, + { + "chip": "IxVM::canon_member_ci", + "name": "IxVM::canon_member_ci", + "rows": 0 + }, + { + "chip": "IxVM::canon_ctor_ctx_entries", + "name": "IxVM::canon_ctor_ctx_entries", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_concat\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\"]}}]}", + "name": "${\"name\":\"IxVM::list_concat\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\"]}}]}", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[\"field\"],\"name\":\"Lists::Node\"}}}}]}", + "rows": 0 + }, + { + "chip": "IxVM::canon_refine_classes", + "name": "IxVM::canon_refine_classes", + "rows": 0 + }, + { + "chip": "IxVM::canon_refine_one", + "name": "IxVM::canon_refine_one", + "rows": 0 + }, + { + "chip": "IxVM::canon_ins_sort", + "name": "IxVM::canon_ins_sort", + "rows": 0 + }, + { + "chip": "IxVM::canon_insert_sorted", + "name": "IxVM::canon_insert_sorted", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_member_ctx", + "name": "IxVM::canon_cmp_member_ctx", + "rows": 0 + }, + { + "chip": "IxVM::canon_ord_cmp_g", + "name": "IxVM::canon_ord_cmp_g", + "rows": 0 + }, + { + "chip": "IxVM::canon_kind_ord", + "name": "IxVM::canon_kind_ord", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_member_same_kind_ctx", + "name": "IxVM::canon_cmp_member_same_kind_ctx", + "rows": 0 + }, + { + "chip": "IxVM::canon_sord_then", + "name": "IxVM::canon_sord_then", + "rows": 0 + }, + { + "chip": "IxVM::canon_sord_of_g", + "name": "IxVM::canon_sord_of_g", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_kexpr_ctx", + "name": "IxVM::canon_cmp_kexpr_ctx", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_kexpr_node_ctx", + "name": "IxVM::canon_cmp_kexpr_node_ctx", + "rows": 0 + }, + { + "chip": "IxVM::canon_sord_lt_strong", + "name": "IxVM::canon_sord_lt_strong", + "rows": 0 + }, + { + "chip": "IxVM::canon_sord_gt_strong", + "name": "IxVM::canon_sord_gt_strong", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_kuniv", + "name": "IxVM::canon_cmp_kuniv", + "rows": 0 + }, + { + "chip": "IxVM::canon_ord_then", + "name": "IxVM::canon_ord_then", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_kuniv_list", + "name": "IxVM::canon_cmp_kuniv_list", + "rows": 0 + }, + { + "chip": "IxVM::canon_ctx_cmp_addr", + "name": "IxVM::canon_ctx_cmp_addr", + "rows": 0 + }, + { + "chip": "IxVM::canon_sord_eq_strong", + "name": "IxVM::canon_sord_eq_strong", + "rows": 0 + }, + { + "chip": "IxVM::canon_ctx_class_idx", + "name": "IxVM::canon_ctx_class_idx", + "rows": 0 + }, + { + "chip": "IxVM::canon_addr_cmp", + "name": "IxVM::canon_addr_cmp", + "rows": 0 + }, + { + "chip": "IxVM::canon_addr_chunk", + "name": "IxVM::canon_addr_chunk", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_kliteral", + "name": "IxVM::canon_cmp_kliteral", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_klimbs", + "name": "IxVM::canon_cmp_klimbs", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "name": "${\"name\":\"IxVM::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_klimbs_tail", + "name": "IxVM::canon_cmp_klimbs_tail", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_u64_lex", + "name": "IxVM::canon_cmp_u64_lex", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_bytes", + "name": "IxVM::canon_cmp_bytes", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_ctor_range_ctx", + "name": "IxVM::canon_cmp_ctor_range_ctx", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_ctor_pair_ctx", + "name": "IxVM::canon_cmp_ctor_pair_ctx", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_krec_rule_list_ctx", + "name": "IxVM::canon_cmp_krec_rule_list_ctx", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_krec_rule_ctx", + "name": "IxVM::canon_cmp_krec_rule_ctx", + "rows": 0 + }, + { + "chip": "IxVM::canon_group_consec", + "name": "IxVM::canon_group_consec", + "rows": 0 + }, + { + "chip": "IxVM::canon_group_walk", + "name": "IxVM::canon_group_walk", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_snoc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_snoc\",\"types\":[\"field\"]}", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[\"field\"],\"name\":\"Lists::Node\"}}}}]}", + "rows": 0 + }, + { + "chip": "IxVM::canon_classes_eq", + "name": "IxVM::canon_classes_eq", + "rows": 0 + }, + { + "chip": "IxVM::bytestream_eq", + "name": "IxVM::canon_g_list_eq", + "rows": 0 + }, + { + "chip": "IxVM::canon_all_singleton", + "name": "IxVM::canon_all_singleton", + "rows": 0 + }, + { + "chip": "IxVM::canon_flatten", + "name": "IxVM::canon_flatten", + "rows": 0 + }, + { + "chip": "IxVM::check_inductive_shape", + "name": "IxVM::check_inductive_shape", + "rows": 29 + }, + { + "chip": "IxVM::get_result_sort_level", + "name": "IxVM::get_result_sort_level", + "rows": 44 + }, + { + "chip": "IxVM::check_inductive_shape_ctors", + "name": "IxVM::check_inductive_shape_ctors", + "rows": 64 + }, + { + "chip": "IxVM::check_param_agreement", + "name": "IxVM::check_param_agreement", + "rows": 34 + }, + { + "chip": "IxVM::check_param_agreement_go", + "name": "IxVM::check_param_agreement_go", + "rows": 70 + }, + { + "chip": "IxVM::check_ctor_return_type", + "name": "IxVM::check_ctor_return_type", + "rows": 34 + }, + { + "chip": "IxVM::assert_return_head_is_parent", + "name": "IxVM::assert_return_head_is_parent", + "rows": 28 + }, + { + "chip": "IxVM::assert_lvls_are_params", + "name": "IxVM::assert_lvls_are_params", + "rows": 10 + }, + { + "chip": "IxVM::assert_first_args_are_param_bvars", + "name": "IxVM::assert_first_args_are_param_bvars", + "rows": 35 + }, + { + "chip": "IxVM::list_any_mentions_block", + "name": "IxVM::list_any_mentions_block", + "rows": 39 + }, + { + "chip": "IxVM::expr_mentions_block", + "name": "IxVM::expr_mentions_block", + "rows": 150 + }, + { + "chip": "IxVM::caddr_is_peer", + "name": "IxVM::caddr_is_peer", + "rows": 44 + }, + { + "chip": "IxVM::addr_list_contains", + "name": "IxVM::addr_list_contains", + "rows": 37 + }, + { + "chip": "IxVM::check_field_universes", + "name": "IxVM::check_field_universes", + "rows": 34 + }, + { + "chip": "IxVM::check_field_universes_skip_params", + "name": "IxVM::check_field_universes_skip_params", + "rows": 42 + }, + { + "chip": "IxVM::check_field_universes_inner", + "name": "IxVM::check_field_universes_inner", + "rows": 47 + }, + { + "chip": "IxVM::level_leq", + "name": "IxVM::level_leq", + "rows": 9 + }, + { + "chip": "IxVM::nl_le", + "name": "IxVM::nl_le", + "rows": 12 + }, + { + "chip": "IxVM::nl_covers_const", + "name": "IxVM::nl_covers_const", + "rows": 2 + }, + { + "chip": "IxVM::nlvars_any_offset_geq", + "name": "IxVM::nlvars_any_offset_geq", + "rows": 0 + }, + { + "chip": "IxVM::nl_le_vars", + "name": "IxVM::nl_le_vars", + "rows": 13 + }, + { + "chip": "IxVM::nl_covers_var", + "name": "IxVM::nl_covers_var", + "rows": 12 + }, + { + "chip": "IxVM::nlvars_dominates", + "name": "IxVM::nlvars_dominates", + "rows": 8 + }, + { + "chip": "IxVM::check_positivity", + "name": "IxVM::check_positivity", + "rows": 34 + }, + { + "chip": "IxVM::peel_n_foralls_with_types", + "name": "IxVM::peel_n_foralls_with_types", + "rows": 70 + }, + { + "chip": "IxVM::check_positivity_fields", + "name": "IxVM::check_positivity_fields", + "rows": 70 + }, + { + "chip": "IxVM::check_positivity_aug", + "name": "IxVM::check_positivity_aug", + "rows": 36 + }, + { + "chip": "IxVM::check_valid_ind_app", + "name": "IxVM::check_valid_ind_app", + "rows": 4 + }, + { + "chip": "IxVM::assert_occ_param_bvars", + "name": "IxVM::assert_occ_param_bvars", + "rows": 8 + }, + { + "chip": "${\"name\":\"IxVM::list_reverse\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_reverse\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "rows": 16 + }, + { + "chip": "${\"name\":\"IxVM::list_reverse_acc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_reverse_acc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "rows": 43 + }, + { + "chip": "IxVM::check_nested_ctors_positivity", + "name": "IxVM::check_nested_ctors_positivity", + "rows": 0 + }, + { + "chip": "IxVM::check_block_peer_param_agreement", + "name": "IxVM::check_block_peer_param_agreement", + "rows": 29 + }, + { + "chip": "IxVM::peer_agree_walk", + "name": "IxVM::peer_agree_walk", + "rows": 58 + }, + { + "chip": "IxVM::check_recursor_member", + "name": "IxVM::check_recursor_member", + "rows": 12 + }, + { + "chip": "IxVM::is_muts_block", + "name": "IxVM::is_muts_block", + "rows": 24 + }, + { + "chip": "${\"name\":\"IxVM::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::KRecRule\"}}]}", + "name": "${\"name\":\"IxVM::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::KRecRule\"}}]}", + "rows": 19 + }, + { + "chip": "IxVM::check_rec_rules_wellscoped", + "name": "IxVM::check_rec_rules_wellscoped", + "rows": 25 + }, + { + "chip": "IxVM::check_rec_major_spine", + "name": "IxVM::check_rec_major_spine", + "rows": 12 + }, + { + "chip": "IxVM::compute_k_target", + "name": "IxVM::compute_k_target", + "rows": 12 + }, + { + "chip": "IxVM::ind_is_solo", + "name": "IxVM::ind_is_solo", + "rows": 12 + }, + { + "chip": "IxVM::muts_indc_count_is_one", + "name": "IxVM::muts_indc_count_is_one", + "rows": 13 + }, + { + "chip": "IxVM::check_parent_inductive_shape", + "name": "IxVM::check_parent_inductive_shape", + "rows": 12 + }, + { + "chip": "IxVM::check_recursor_canonical_full", + "name": "IxVM::check_recursor_canonical_full", + "rows": 12 + }, + { + "chip": "IxVM::is_large_eliminator", + "name": "IxVM::is_large_eliminator", + "rows": 8 + }, + { + "chip": "IxVM::check_large_prop_ctor", + "name": "IxVM::check_large_prop_ctor", + "rows": 3 + }, + { + "chip": "IxVM::check_large_walk_fields", + "name": "IxVM::check_large_walk_fields", + "rows": 3 + }, + { + "chip": "IxVM::all_bvars_in_args", + "name": "IxVM::all_bvars_in_args", + "rows": 1 + }, + { + "chip": "IxVM::args_contain_bvar", + "name": "IxVM::args_contain_bvar", + "rows": 0 + }, + { + "chip": "IxVM::build_rec_lvls_list", + "name": "IxVM::build_rec_lvls_list", + "rows": 6 + }, + { + "chip": "IxVM::build_flat_block", + "name": "IxVM::build_flat_block", + "rows": 12 + }, + { + "chip": "IxVM::first_recr_parent_block", + "name": "IxVM::first_recr_parent_block", + "rows": 0 + }, + { + "chip": "IxVM::flat_originals_walk", + "name": "IxVM::flat_originals_walk", + "rows": 24 + }, + { + "chip": "IxVM::build_param_lvls_range", + "name": "IxVM::build_param_lvls_range", + "rows": 4 + }, + { + "chip": "IxVM::detect_aux_from_recrs_ex", + "name": "IxVM::detect_aux_from_recrs_ex", + "rows": 0 + }, + { + "chip": "IxVM::aux_from_recrs_walk_ex", + "name": "IxVM::aux_from_recrs_walk_ex", + "rows": 0 + }, + { + "chip": "IxVM::extract_aux_spec_params_from_rec", + "name": "IxVM::extract_aux_spec_params_from_rec", + "rows": 0 + }, + { + "chip": "IxVM::extract_aux_spec_params", + "name": "IxVM::extract_aux_spec_params", + "rows": 0 + }, + { + "chip": "IxVM::spec_params_lower", + "name": "IxVM::spec_params_lower", + "rows": 0 + }, + { + "chip": "IxVM::extract_aux_occ_us", + "name": "IxVM::extract_aux_occ_us", + "rows": 0 + }, + { + "chip": "IxVM::aux_already_in", + "name": "IxVM::aux_already_in", + "rows": 0 + }, + { + "chip": "IxVM::spec_params_ptr_eq", + "name": "IxVM::spec_params_ptr_eq", + "rows": 0 + }, + { + "chip": "IxVM::kexpr_struct_eq", + "name": "IxVM::kexpr_struct_eq", + "rows": 0 + }, + { + "chip": "IxVM::level_list_struct_eq", + "name": "IxVM::level_list_struct_eq", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_snoc\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}", + "name": "${\"name\":\"IxVM::list_snoc\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}", + "rows": 0 + }, + { + "chip": "IxVM::build_peer_recs", + "name": "IxVM::build_peer_recs", + "rows": 24 + }, + { + "chip": "IxVM::find_peer_recursor_with_spec", + "name": "IxVM::find_peer_recursor_with_spec", + "rows": 12 + }, + { + "chip": "IxVM::find_peer_rec_spec_walk", + "name": "IxVM::find_peer_rec_spec_walk", + "rows": 0 + }, + { + "chip": "IxVM::build_flat_own_params", + "name": "IxVM::build_flat_own_params", + "rows": 13 + }, + { + "chip": "IxVM::flat_find_pos_kind", + "name": "IxVM::flat_find_pos_kind", + "rows": 12 + }, + { + "chip": "IxVM::canonical_rules_at_pos", + "name": "IxVM::canonical_rules_at_pos", + "rows": 12 + }, + { + "chip": "IxVM::flat_member_at", + "name": "IxVM::flat_member_at", + "rows": 12 + }, + { + "chip": "IxVM::build_rec_type", + "name": "IxVM::build_rec_type", + "rows": 12 + }, + { + "chip": "IxVM::build_rec_type_from", + "name": "IxVM::build_rec_type_from", + "rows": 12 + }, + { + "chip": "${\"name\":\"IxVM::list_length\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}", + "name": "${\"name\":\"IxVM::list_length\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}", + "rows": 13 + }, + { + "chip": "IxVM::collect_n_doms_whnf", + "name": "IxVM::collect_n_doms_whnf", + "rows": 18 + }, + { + "chip": "IxVM::build_all_motives", + "name": "IxVM::build_all_motives", + "rows": 12 + }, + { + "chip": "IxVM::build_all_motives_walk", + "name": "IxVM::build_all_motives_walk", + "rows": 17 + }, + { + "chip": "IxVM::build_motive_type_flat", + "name": "IxVM::build_motive_type_flat", + "rows": 12 + }, + { + "chip": "IxVM::peel_motive_params_subst", + "name": "IxVM::peel_motive_params_subst", + "rows": 20 + }, + { + "chip": "IxVM::subst_param_for", + "name": "IxVM::subst_param_for", + "rows": 3 + }, + { + "chip": "IxVM::collect_index_doms", + "name": "IxVM::collect_index_doms", + "rows": 9 + }, + { + "chip": "IxVM::build_major_params", + "name": "IxVM::build_major_params", + "rows": 25 + }, + { + "chip": "IxVM::apply_spec_params_lifted", + "name": "IxVM::apply_spec_params_lifted", + "rows": 0 + }, + { + "chip": "IxVM::build_major_indices", + "name": "IxVM::build_major_indices", + "rows": 32 + }, + { + "chip": "IxVM::wrap_foralls", + "name": "IxVM::wrap_foralls", + "rows": 152 + }, + { + "chip": "IxVM::build_all_minors", + "name": "IxVM::build_all_minors", + "rows": 12 + }, + { + "chip": "IxVM::build_all_minors_walk", + "name": "IxVM::build_all_minors_walk", + "rows": 24 + }, + { + "chip": "IxVM::build_minor_doms", + "name": "IxVM::build_minor_doms", + "rows": 30 + }, + { + "chip": "IxVM::projection_addr_ctor", + "name": "IxVM::projection_addr_ctor", + "rows": 18 + }, + { + "chip": "IxVM::build_minor_at_depth", + "name": "IxVM::build_minor_at_depth", + "rows": 18 + }, + { + "chip": "IxVM::peel_ctor_params_subst", + "name": "IxVM::peel_ctor_params_subst", + "rows": 75 + }, + { + "chip": "IxVM::ctor_subst_param_for", + "name": "IxVM::ctor_subst_param_for", + "rows": 9 + }, + { + "chip": "IxVM::walk_fields_classify", + "name": "IxVM::walk_fields_classify", + "rows": 67 + }, + { + "chip": "IxVM::is_rec_field", + "name": "IxVM::is_rec_field", + "rows": 32 + }, + { + "chip": "IxVM::is_rec_field_peel", + "name": "IxVM::is_rec_field_peel", + "rows": 34 + }, + { + "chip": "IxVM::flat_find_matching", + "name": "IxVM::flat_find_matching", + "rows": 26 + }, + { + "chip": "IxVM::spec_params_dom_prefix_match", + "name": "IxVM::spec_params_dom_prefix_match", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_reverse\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_reverse\",\"types\":[\"field\"]}", + "rows": 4 + }, + { + "chip": "${\"name\":\"IxVM::list_reverse_acc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_reverse_acc\",\"types\":[\"field\"]}", + "rows": 7 + }, + { + "chip": "IxVM::list_lift_each", + "name": "IxVM::list_lift_each", + "rows": 9 + }, + { + "chip": "IxVM::apply_spine", + "name": "IxVM::apply_spine_expr", + "rows": 30 + }, + { + "chip": "IxVM::build_ctor_app_params", + "name": "IxVM::build_ctor_app_params", + "rows": 18 + }, + { + "chip": "IxVM::build_apply_bvars_decreasing", + "name": "IxVM::build_apply_bvars_decreasing", + "rows": 71 + }, + { + "chip": "IxVM::build_apply_field_bvars", + "name": "IxVM::build_apply_field_bvars", + "rows": 48 + }, + { + "chip": "IxVM::build_ih_doms", + "name": "IxVM::build_ih_doms", + "rows": 18 + }, + { + "chip": "${\"name\":\"IxVM::list_lookup_or_default\",\"types\":[\"field\"]}", + "name": "${\"name\":\"IxVM::list_lookup_or_default\",\"types\":[\"field\"]}", + "rows": 3 + }, + { + "chip": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "name": "${\"name\":\"IxVM::list_drop\",\"types\":[\"field\"]}", + "rows": 3 + }, + { + "chip": "IxVM::peel_leading_foralls", + "name": "IxVM::peel_leading_foralls", + "rows": 7 + }, + { + "chip": "IxVM::peel_leading_foralls_acc", + "name": "IxVM::peel_leading_foralls_acc", + "rows": 7 + }, + { + "chip": "IxVM::build_major_indices", + "name": "IxVM::build_apply_xs", + "rows": 2 + }, + { + "chip": "IxVM::list_lift_indices", + "name": "IxVM::list_lift_indices", + "rows": 13 + }, + { + "chip": "IxVM::apply_indices_in_conclusion", + "name": "IxVM::apply_indices_in_conclusion", + "rows": 13 + }, + { + "chip": "IxVM::ctors_before_pos", + "name": "IxVM::ctors_before_pos", + "rows": 12 + }, + { + "chip": "IxVM::populate_rules", + "name": "IxVM::populate_rules", + "rows": 30 + }, + { + "chip": "IxVM::build_rule_rhs", + "name": "IxVM::build_rule_rhs", + "rows": 18 + }, + { + "chip": "IxVM::count_foralls_body", + "name": "IxVM::count_foralls_body", + "rows": 31 + }, + { + "chip": "IxVM::apply_ihs_full", + "name": "IxVM::apply_ihs_full", + "rows": 22 + }, + { + "chip": "${\"name\":\"IxVM::list_lookup_or_default\",\"types\":[\"field\"]}", + "name": "${\"name\":\"IxVM::list_lookup_or_default\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}}]}", + "rows": 4 + }, + { + "chip": "IxVM::build_apply_bvars_decreasing", + "name": "IxVM::build_motive_apps", + "rows": 8 + }, + { + "chip": "IxVM::build_apply_bvars_decreasing", + "name": "IxVM::build_minor_apps", + "rows": 12 + }, + { + "chip": "IxVM::wrap_lams", + "name": "IxVM::wrap_lams", + "rows": 4 + }, + { + "chip": "IxVM::compare_rules", + "name": "IxVM::compare_rules", + "rows": 30 + }, + { + "chip": "IxVM::peel_n_lams_collect", + "name": "IxVM::peel_n_lams_collect", + "rows": 104 + }, + { + "chip": "IxVM::flat_find_pos", + "name": "IxVM::flat_find_pos", + "rows": 0 + }, + { + "chip": "IxVM::run_check_transitive", + "name": "IxVM::run_check_transitive", + "rows": 0 + }, + { + "chip": "IxVM::check_muts_all", + "name": "IxVM::check_muts_all", + "rows": 58 + }, + { + "chip": "IxVM::check_muts_member_at", + "name": "IxVM::check_muts_member_at", + "rows": 29 + }, + { + "chip": "IxVM::walk_refs_transitive", + "name": "IxVM::walk_refs_transitive", + "rows": 0 + }, + { + "chip": "IxVM::g_list_has", + "name": "IxVM::g_list_has", + "rows": 12036 + }, + { + "chip": "IxVM::const_idxs_of", + "name": "IxVM::const_idxs_of", + "rows": 342 + }, + { + "chip": "IxVM::const_idxs_exprs", + "name": "IxVM::const_idxs_exprs", + "rows": 1355 + }, + { + "chip": "IxVM::const_idxs_expr", + "name": "IxVM::const_idxs_expr", + "rows": 7784 + }, + { + "chip": "IxVM::const_idxs_rules", + "name": "IxVM::const_idxs_rules", + "rows": 18 + }, + { + "chip": "IxVM::const_idxs_muts", + "name": "IxVM::const_idxs_muts", + "rows": 29 + }, + { + "chip": "IxVM::const_idxs_ctors", + "name": "IxVM::const_idxs_ctors", + "rows": 35 + }, + { + "chip": "IxVM::addr_set_build", + "name": "IxVM::addr_set_build", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::rbtree_map_insert\",\"types\":[\"field\"]}", + "name": "${\"name\":\"IxVM::rbtree_map_insert\",\"types\":[\"field\"]}", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::rbtree_map_ins\",\"types\":[\"field\"]}", + "name": "${\"name\":\"IxVM::rbtree_map_ins\",\"types\":[\"field\"]}", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::rbtree_map_balance\",\"types\":[\"field\"]}", + "name": "${\"name\":\"IxVM::rbtree_map_balance\",\"types\":[\"field\"]}", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::rbtree_map_balance_fix\",\"types\":[\"field\"]}", + "name": "${\"name\":\"IxVM::rbtree_map_balance_fix\",\"types\":[\"field\"]}", + "rows": 0 + }, + { + "chip": "IxVM::load_assumption_tree", + "name": "IxVM::load_assumption_tree", + "rows": 1 + }, + { + "chip": "IxVM::parse_atree_body", + "name": "IxVM::parse_atree_body", + "rows": 691 + }, + { + "chip": "IxVM::leaf_hash", + "name": "IxVM::leaf_hash", + "rows": 342 + }, + { + "chip": "IxVM::node_hash", + "name": "IxVM::node_hash", + "rows": 345 + }, + { + "chip": "${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}}]}", + "rows": 2021 + }, + { + "chip": "IxVM::addr_set_member", + "name": "IxVM::addr_set_member", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::rbtree_map_lookup_or_default\",\"types\":[\"field\"]}", + "name": "${\"name\":\"IxVM::rbtree_map_lookup_or_default\",\"types\":[\"field\"]}", + "rows": 0 + }, + { + "chip": "IxVM::env_walk", + "name": "IxVM::env_walk", + "rows": 0 + }, + { + "chip": "IxVM::env_walk_refs", + "name": "IxVM::env_walk_refs", + "rows": 0 + }, + { + "chip": "IxVM::eval_body", + "name": "IxVM::eval_body", + "rows": 0 + }, + { + "chip": "IxVM::eval_output", + "name": "IxVM::eval_output", + "rows": 0 + }, + { + "chip": "IxVM::eval_nf", + "name": "IxVM::eval_nf", + "rows": 0 + }, + { + "chip": "IxVM::eval_nf_spine", + "name": "IxVM::eval_nf_spine", + "rows": 0 + }, + { + "chip": "IxVM::run_check_env", + "name": "IxVM::run_check_env", + "rows": 1 + }, + { + "chip": "IxVM::walk_leaves_owned", + "name": "IxVM::walk_leaves_owned", + "rows": 343 + }, + { + "chip": "IxVM::check_owned", + "name": "IxVM::check_owned", + "rows": 342 + }, + { + "chip": "IxVM::env_walk_all", + "name": "IxVM::env_walk_all", + "rows": 342 + }, + { + "chip": "IxVM::env_walk_refs_all", + "name": "IxVM::env_walk_refs_all", + "rows": 2091 + }, + { + "chip": "IxVM::env_walk_leaves", + "name": "IxVM::env_walk_leaves", + "rows": 0 + }, + { + "chip": "IxVM::get_reveal_info", + "name": "IxVM::get_reveal_info", + "rows": 0 + }, + { + "chip": "IxVM::get_opt_def_kind_masked", + "name": "IxVM::get_opt_def_kind_masked", + "rows": 0 + }, + { + "chip": "IxVM::get_opt_def_kind_masked", + "name": "IxVM::get_opt_def_safety_masked", + "rows": 0 + }, + { + "chip": "IxVM::get_opt_u64_masked", + "name": "IxVM::get_opt_u64_masked", + "rows": 0 + }, + { + "chip": "IxVM::get_opt_addr_masked", + "name": "IxVM::get_opt_addr_masked", + "rows": 0 + }, + { + "chip": "IxVM::get_opt_bool_masked", + "name": "IxVM::get_opt_bool_masked", + "rows": 0 + }, + { + "chip": "IxVM::get_opt_rule_list_masked", + "name": "IxVM::get_opt_rule_list_masked", + "rows": 0 + }, + { + "chip": "IxVM::get_reveal_rule_list_inner", + "name": "IxVM::get_reveal_rule_list_inner", + "rows": 0 + }, + { + "chip": "IxVM::get_constructor_proj", + "name": "IxVM::get_reveal_rule", + "rows": 0 + }, + { + "chip": "IxVM::get_opt_quot_kind_masked", + "name": "IxVM::get_opt_quot_kind_masked", + "rows": 0 + }, + { + "chip": "IxVM::get_mut_entry_list_inner", + "name": "IxVM::get_mut_entry_list_inner", + "rows": 0 + }, + { + "chip": "IxVM::get_mut_entry", + "name": "IxVM::get_mut_entry", + "rows": 0 + }, + { + "chip": "IxVM::get_reveal_mut_const_info", + "name": "IxVM::get_reveal_mut_const_info", + "rows": 0 + }, + { + "chip": "IxVM::get_opt_ctor_entry_list_masked", + "name": "IxVM::get_opt_ctor_entry_list_masked", + "rows": 0 + }, + { + "chip": "IxVM::get_ctor_entry_list_inner", + "name": "IxVM::get_ctor_entry_list_inner", + "rows": 0 + }, + { + "chip": "IxVM::get_ctor_entry", + "name": "IxVM::get_ctor_entry", + "rows": 0 + }, + { + "chip": "IxVM::get_reveal_ctor_info", + "name": "IxVM::get_reveal_ctor_info", + "rows": 0 + }, + { + "chip": "IxVM::run_reveal", + "name": "IxVM::run_reveal", + "rows": 0 + }, + { + "chip": "IxVM::check_opt_def_kind", + "name": "IxVM::check_opt_def_kind", + "rows": 0 + }, + { + "chip": "IxVM::def_kind_tag", + "name": "IxVM::def_kind_tag", + "rows": 0 + }, + { + "chip": "IxVM::check_opt_def_kind", + "name": "IxVM::check_opt_def_safety", + "rows": 0 + }, + { + "chip": "IxVM::def_kind_tag", + "name": "IxVM::def_safety_tag", + "rows": 0 + }, + { + "chip": "IxVM::check_opt_u64", + "name": "IxVM::check_opt_u64", + "rows": 0 + }, + { + "chip": "IxVM::check_opt_expr_addr", + "name": "IxVM::check_opt_expr_addr", + "rows": 0 + }, + { + "chip": "IxVM::expr_addr", + "name": "IxVM::expr_addr", + "rows": 0 + }, + { + "chip": "IxVM::check_opt_bool", + "name": "IxVM::check_opt_bool", + "rows": 0 + }, + { + "chip": "IxVM::check_opt_recr_rules", + "name": "IxVM::check_opt_recr_rules", + "rows": 0 + }, + { + "chip": "IxVM::check_recr_rules", + "name": "IxVM::check_recr_rules", + "rows": 0 + }, + { + "chip": "IxVM::check_opt_quot_kind", + "name": "IxVM::check_opt_quot_kind", + "rows": 0 + }, + { + "chip": "IxVM::get_quot_kind", + "name": "IxVM::quot_kind_tag", + "rows": 0 + }, + { + "chip": "IxVM::check_opt_addr", + "name": "IxVM::check_opt_addr", + "rows": 0 + }, + { + "chip": "IxVM::check_muts_components", + "name": "IxVM::check_muts_components", + "rows": 0 + }, + { + "chip": "IxVM::check_mut_const", + "name": "IxVM::check_mut_const", + "rows": 0 + }, + { + "chip": "IxVM::check_opt_ctor_entries", + "name": "IxVM::check_opt_ctor_entries", + "rows": 0 + }, + { + "chip": "IxVM::check_ctor_entries", + "name": "IxVM::check_ctor_entries", + "rows": 0 + }, + { + "chip": "IxVM::check_ctor_entry", + "name": "IxVM::check_ctor_entry", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}", + "name": "${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}", + "rows": 0 + }, + { + "chip": "IxVM::run_contains", + "name": "IxVM::run_contains", + "rows": 0 + } + ], + "prepare_seconds": 0.137504482, + "proof": null, + "samples": [], + "setup_seconds": 0.308874549, + "thp_disabled": true +} \ No newline at end of file diff --git a/docs/benchmarks/formal-aiur-grouping-tuning/ixvm-counts.json b/docs/benchmarks/formal-aiur-grouping-tuning/ixvm-counts.json new file mode 100644 index 000000000..ed1f9e3d5 --- /dev/null +++ b/docs/benchmarks/formal-aiur-grouping-tuning/ixvm-counts.json @@ -0,0 +1,4151 @@ +{ + "backend": "new-bytecode", + "circuits": [], + "function_rows": [ + { + "chip": "IxVM::verify_claim", + "name": "IxVM::verify_claim", + "rows": 1 + }, + { + "chip": "IxVM::run_claim", + "name": "IxVM::run_claim", + "rows": 1 + }, + { + "chip": "IxVM::read_finite_byte_stream", + "name": "IxVM::read_finite_byte_stream", + "rows": 16 + }, + { + "chip": "IxVM::read_byte_stream", + "name": "IxVM::read_byte_stream", + "rows": 2337 + }, + { + "chip": "${\"name\":\"IxVM::list_depth_checked\",\"types\":[\"field\"]}", + "name": "${\"name\":\"IxVM::list_depth_checked\",\"types\":[\"field\"]}", + "rows": 2304 + }, + { + "chip": "IxVM::checked_depth_succ", + "name": "IxVM::checked_depth_succ", + "rows": 892 + }, + { + "chip": "UInt32::less_than_fields", + "name": "UInt32::less_than_fields", + "rows": 1101 + }, + { + "chip": "Blake3::compress_layer", + "name": "Blake3::compress_layer", + "rows": 29 + }, + { + "chip": "Blake3::next_layer", + "name": "Blake3::next_layer", + "rows": 0 + }, + { + "chip": "Blake3::compress", + "name": "Blake3::compress", + "rows": 488 + }, + { + "chip": "Blake3::compress_chunks", + "name": "Blake3::compress_chunks", + "rows": 2795 + }, + { + "chip": "Blake3::finish", + "name": "Blake3::finish", + "rows": 29 + }, + { + "chip": "UInt64::is_zero", + "name": "UInt64::is_zero", + "rows": 20 + }, + { + "chip": "Blake3::bytes_to_block", + "name": "Blake3::bytes_to_block", + "rows": 60 + }, + { + "chip": "Blake3::pad_block", + "name": "Blake3::pad_block", + "rows": 1103 + }, + { + "chip": "Blake3::compress_block", + "name": "Blake3::compress_block", + "rows": 32 + }, + { + "chip": "${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}", + "name": "${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}", + "rows": 32 + }, + { + "chip": "UInt64::wrapping_succ", + "name": "UInt64::wrapping_succ", + "rows": 0 + }, + { + "chip": "IxVM::get_tagn4", + "name": "IxVM::get_tagn4", + "rows": 369 + }, + { + "chip": "IxVM::get_tagn_tail", + "name": "IxVM::get_tagn_tail", + "rows": 27 + }, + { + "chip": "IxVM::get_tagn_wide", + "name": "IxVM::get_tagn_wide", + "rows": 0 + }, + { + "chip": "IxVM::get_u64_le", + "name": "IxVM::get_u64_le", + "rows": 0 + }, + { + "chip": "UInt64::add", + "name": "UInt64::add", + "rows": 0 + }, + { + "chip": "IxVM::read_byte", + "name": "IxVM::read_byte", + "rows": 92 + }, + { + "chip": "IxVM::get_address", + "name": "IxVM::get_address", + "rows": 52 + }, + { + "chip": "IxVM::get_opt_addr", + "name": "IxVM::get_opt_addr", + "rows": 1 + }, + { + "chip": "IxVM::run_eval", + "name": "IxVM::run_eval", + "rows": 0 + }, + { + "chip": "IxVM::run_check", + "name": "IxVM::run_check", + "rows": 1 + }, + { + "chip": "IxVM::get_ci", + "name": "IxVM::get_ci", + "rows": 9 + }, + { + "chip": "IxVM::load_verified_constant", + "name": "IxVM::load_verified_constant", + "rows": 11 + }, + { + "chip": "Blake3::verify_bytes_against", + "name": "Blake3::verify_bytes_against", + "rows": 13 + }, + { + "chip": "IxVM::get_constant", + "name": "IxVM::get_constant", + "rows": 11 + }, + { + "chip": "IxVM::get_mut_const_list", + "name": "IxVM::get_mut_const_list", + "rows": 4 + }, + { + "chip": "IxVM::get_mut_const", + "name": "IxVM::get_mut_const", + "rows": 2 + }, + { + "chip": "IxVM::get_definition", + "name": "IxVM::get_definition", + "rows": 7 + }, + { + "chip": "IxVM::unpack_def_kind_safety", + "name": "IxVM::unpack_def_kind_safety", + "rows": 2 + }, + { + "chip": "IxVM::get_tagn0", + "name": "IxVM::get_tagn0", + "rows": 135 + }, + { + "chip": "IxVM::get_expr", + "name": "IxVM::get_expr", + "rows": 357 + }, + { + "chip": "IxVM::get_u64_list", + "name": "IxVM::get_u64_list", + "rows": 75 + }, + { + "chip": "UInt64::saturating_pred", + "name": "UInt64::saturating_pred", + "rows": 19 + }, + { + "chip": "IxVM::get_app_telescope", + "name": "IxVM::get_app_telescope", + "rows": 218 + }, + { + "chip": "IxVM::get_lam_telescope", + "name": "IxVM::get_lam_telescope", + "rows": 40 + }, + { + "chip": "IxVM::get_lam_mode", + "name": "IxVM::get_lam_mode", + "rows": 28 + }, + { + "chip": "IxVM::binder_contract_from_bits", + "name": "IxVM::binder_contract_from_bits", + "rows": 1 + }, + { + "chip": "IxVM::value_contract_from_bits", + "name": "IxVM::value_contract_from_bits", + "rows": 1 + }, + { + "chip": "IxVM::get_all_telescope", + "name": "IxVM::get_all_telescope", + "rows": 43 + }, + { + "chip": "IxVM::get_all_mode", + "name": "IxVM::get_all_mode", + "rows": 29 + }, + { + "chip": "IxVM::get_expr_let", + "name": "IxVM::get_expr_let", + "rows": 1 + }, + { + "chip": "IxVM::get_inductive", + "name": "IxVM::get_inductive", + "rows": 2 + }, + { + "chip": "IxVM::assert_wire_bool", + "name": "IxVM::assert_wire_bool", + "rows": 1 + }, + { + "chip": "IxVM::get_constructor_list", + "name": "IxVM::get_constructor_list", + "rows": 5 + }, + { + "chip": "IxVM::get_constructor", + "name": "IxVM::get_constructor", + "rows": 3 + }, + { + "chip": "IxVM::get_recursor", + "name": "IxVM::get_recursor", + "rows": 0 + }, + { + "chip": "IxVM::get_recursor_rule_list", + "name": "IxVM::get_recursor_rule_list", + "rows": 0 + }, + { + "chip": "IxVM::get_constant_info_by_variant", + "name": "IxVM::get_constant_info_by_variant", + "rows": 9 + }, + { + "chip": "IxVM::get_axiom", + "name": "IxVM::get_axiom", + "rows": 0 + }, + { + "chip": "IxVM::get_quotient", + "name": "IxVM::get_quotient", + "rows": 0 + }, + { + "chip": "IxVM::get_quot_kind", + "name": "IxVM::get_quot_kind", + "rows": 0 + }, + { + "chip": "IxVM::get_constructor_proj", + "name": "IxVM::get_constructor_proj", + "rows": 0 + }, + { + "chip": "IxVM::get_recursor_proj", + "name": "IxVM::get_recursor_proj", + "rows": 0 + }, + { + "chip": "IxVM::get_recursor_proj", + "name": "IxVM::get_inductive_proj", + "rows": 2 + }, + { + "chip": "IxVM::get_recursor_proj", + "name": "IxVM::get_definition_proj", + "rows": 0 + }, + { + "chip": "IxVM::get_expr_list", + "name": "IxVM::get_expr_list", + "rows": 41 + }, + { + "chip": "IxVM::get_address_list", + "name": "IxVM::get_address_list", + "rows": 48 + }, + { + "chip": "IxVM::get_univ_list", + "name": "IxVM::get_univ_list", + "rows": 14 + }, + { + "chip": "IxVM::get_univ", + "name": "IxVM::get_univ", + "rows": 18 + }, + { + "chip": "IxVM::get_tagn2", + "name": "IxVM::get_tagn2", + "rows": 18 + }, + { + "chip": "IxVM::build_succ_chain", + "name": "IxVM::build_succ_chain", + "rows": 9 + }, + { + "chip": "IxVM::load_constant_hint", + "name": "IxVM::load_constant_hint", + "rows": 7 + }, + { + "chip": "IxVM::defn_is_unsafe_ci", + "name": "IxVM::defn_is_unsafe_ci", + "rows": 2 + }, + { + "chip": "IxVM::convert_definition", + "name": "IxVM::convert_definition", + "rows": 7 + }, + { + "chip": "IxVM::convert_expr", + "name": "IxVM::convert_expr", + "rows": 295 + }, + { + "chip": "${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "name": "${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "rows": 16 + }, + { + "chip": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "name": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "rows": 16 + }, + { + "chip": "UInt64::to_field", + "name": "UInt64::to_field", + "rows": 19 + }, + { + "chip": "IxVM::convert_univ", + "name": "IxVM::convert_univ", + "rows": 9 + }, + { + "chip": "${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "name": "${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}}]}", + "rows": 40 + }, + { + "chip": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "name": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}}]}", + "rows": 40 + }, + { + "chip": "IxVM::convert_univ_idxs", + "name": "IxVM::convert_univ_idxs", + "rows": 19 + }, + { + "chip": "IxVM::load_verified_blob", + "name": "IxVM::load_verified_blob", + "rows": 2 + }, + { + "chip": "IxVM::utf8_validate", + "name": "IxVM::utf8_validate", + "rows": 0 + }, + { + "chip": "IxVM::utf8_decode_one", + "name": "IxVM::utf8_decode_one", + "rows": 0 + }, + { + "chip": "IxVM::utf8_cont", + "name": "IxVM::utf8_cont", + "rows": 0 + }, + { + "chip": "IxVM::bytes_to_limbs", + "name": "IxVM::bytes_to_limbs", + "rows": 2 + }, + { + "chip": "IxVM::bytes_to_u64_limb", + "name": "IxVM::bytes_to_u64_limb", + "rows": 4 + }, + { + "chip": "IxVM::skip_bytes", + "name": "IxVM::skip_bytes", + "rows": 3 + }, + { + "chip": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "name": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Expr\"}}}}]}", + "rows": 30 + }, + { + "chip": "IxVM::convert_axiom", + "name": "IxVM::convert_axiom", + "rows": 0 + }, + { + "chip": "IxVM::convert_quotient", + "name": "IxVM::convert_quotient", + "rows": 0 + }, + { + "chip": "IxVM::get_ci_dprj", + "name": "IxVM::get_ci_dprj", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}", + "name": "${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}", + "rows": 0 + }, + { + "chip": "IxVM::defn_member_recur_addrs", + "name": "IxVM::defn_member_recur_addrs", + "rows": 0 + }, + { + "chip": "IxVM::build_recur_addrs", + "name": "IxVM::build_recur_addrs", + "rows": 2 + }, + { + "chip": "IxVM::build_recur_addrs_walk", + "name": "IxVM::build_recur_addrs_walk", + "rows": 4 + }, + { + "chip": "IxVM::projection_addr", + "name": "IxVM::projection_addr", + "rows": 2 + }, + { + "chip": "IxVM::muts_member_at", + "name": "IxVM::muts_member_at", + "rows": 2 + }, + { + "chip": "UInt64::from_field", + "name": "UInt64::from_field", + "rows": 1 + }, + { + "chip": "IxVM::put_constant", + "name": "IxVM::put_constant", + "rows": 2 + }, + { + "chip": "IxVM::put_sharing", + "name": "IxVM::put_sharing", + "rows": 1 + }, + { + "chip": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Expr\"}}}}]}", + "name": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Expr\"}}}}]}", + "rows": 1 + }, + { + "chip": "IxVM::put_tagn0", + "name": "IxVM::put_tagn0", + "rows": 5 + }, + { + "chip": "IxVM::put_tagn_tail", + "name": "IxVM::put_tagn_tail", + "rows": 0 + }, + { + "chip": "IxVM::put_tagn_wide", + "name": "IxVM::put_tagn_wide", + "rows": 0 + }, + { + "chip": "IxVM::put_u64_le", + "name": "IxVM::put_u64_le", + "rows": 0 + }, + { + "chip": "IxVM::put_expr_list", + "name": "IxVM::put_expr_list", + "rows": 1 + }, + { + "chip": "IxVM::put_expr", + "name": "IxVM::put_expr", + "rows": 0 + }, + { + "chip": "IxVM::put_tagn4", + "name": "IxVM::put_tagn4", + "rows": 2 + }, + { + "chip": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "name": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "rows": 0 + }, + { + "chip": "IxVM::put_u64_list", + "name": "IxVM::put_u64_list", + "rows": 0 + }, + { + "chip": "IxVM::app_telescope_count", + "name": "IxVM::app_telescope_count", + "rows": 0 + }, + { + "chip": "IxVM::put_app_telescope", + "name": "IxVM::put_app_telescope", + "rows": 0 + }, + { + "chip": "IxVM::lam_telescope_count", + "name": "IxVM::lam_telescope_count", + "rows": 0 + }, + { + "chip": "IxVM::put_lam_telescope", + "name": "IxVM::put_lam_telescope", + "rows": 0 + }, + { + "chip": "IxVM::put_lam_mode", + "name": "IxVM::put_lam_mode", + "rows": 0 + }, + { + "chip": "IxVM::binder_contract_code", + "name": "IxVM::binder_contract_code", + "rows": 0 + }, + { + "chip": "IxVM::value_contract_code", + "name": "IxVM::value_contract_code", + "rows": 0 + }, + { + "chip": "IxVM::all_telescope_count", + "name": "IxVM::all_telescope_count", + "rows": 0 + }, + { + "chip": "IxVM::put_all_telescope", + "name": "IxVM::put_all_telescope", + "rows": 0 + }, + { + "chip": "IxVM::put_all_mode", + "name": "IxVM::put_all_mode", + "rows": 0 + }, + { + "chip": "IxVM::put_refs", + "name": "IxVM::put_refs", + "rows": 1 + }, + { + "chip": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Expr\"}}}}]}", + "name": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}}]}", + "rows": 1 + }, + { + "chip": "IxVM::put_address_list", + "name": "IxVM::put_address_list", + "rows": 1 + }, + { + "chip": "IxVM::put_address", + "name": "IxVM::put_address", + "rows": 24 + }, + { + "chip": "IxVM::put_univs", + "name": "IxVM::put_univs", + "rows": 1 + }, + { + "chip": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Expr\"}}}}]}", + "name": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "rows": 1 + }, + { + "chip": "IxVM::put_univ_list", + "name": "IxVM::put_univ_list", + "rows": 1 + }, + { + "chip": "IxVM::put_univ", + "name": "IxVM::put_univ", + "rows": 0 + }, + { + "chip": "IxVM::univ_succ_count", + "name": "IxVM::univ_succ_count", + "rows": 0 + }, + { + "chip": "IxVM::univ_succ_base", + "name": "IxVM::univ_succ_base", + "rows": 0 + }, + { + "chip": "IxVM::put_tagn2", + "name": "IxVM::put_tagn2", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}", + "name": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}", + "rows": 0 + }, + { + "chip": "IxVM::put_mut_const_list", + "name": "IxVM::put_mut_const_list", + "rows": 0 + }, + { + "chip": "IxVM::put_mut_const", + "name": "IxVM::put_mut_const", + "rows": 0 + }, + { + "chip": "IxVM::put_definition", + "name": "IxVM::put_definition", + "rows": 0 + }, + { + "chip": "IxVM::pack_def_kind_safety", + "name": "IxVM::pack_def_kind_safety", + "rows": 0 + }, + { + "chip": "IxVM::put_inductive", + "name": "IxVM::put_inductive", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}", + "name": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}", + "rows": 0 + }, + { + "chip": "IxVM::put_constructor_list", + "name": "IxVM::put_constructor_list", + "rows": 0 + }, + { + "chip": "IxVM::put_constructor", + "name": "IxVM::put_constructor", + "rows": 0 + }, + { + "chip": "IxVM::put_recursor", + "name": "IxVM::put_recursor", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::RecursorRule\"}}]}", + "name": "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::RecursorRule\"}}]}", + "rows": 0 + }, + { + "chip": "IxVM::put_recursor_rule_list", + "name": "IxVM::put_recursor_rule_list", + "rows": 0 + }, + { + "chip": "IxVM::put_recursor_rule", + "name": "IxVM::put_recursor_rule", + "rows": 0 + }, + { + "chip": "IxVM::put_constant_info", + "name": "IxVM::put_constant_info", + "rows": 2 + }, + { + "chip": "IxVM::put_axiom", + "name": "IxVM::put_axiom", + "rows": 0 + }, + { + "chip": "IxVM::put_quotient", + "name": "IxVM::put_quotient", + "rows": 0 + }, + { + "chip": "IxVM::put_quot_kind", + "name": "IxVM::put_quot_kind", + "rows": 0 + }, + { + "chip": "IxVM::put_constructor_proj", + "name": "IxVM::put_constructor_proj", + "rows": 0 + }, + { + "chip": "IxVM::put_recursor_proj", + "name": "IxVM::put_recursor_proj", + "rows": 0 + }, + { + "chip": "IxVM::put_recursor_proj", + "name": "IxVM::put_inductive_proj", + "rows": 2 + }, + { + "chip": "IxVM::put_recursor_proj", + "name": "IxVM::put_definition_proj", + "rows": 0 + }, + { + "chip": "Blake3::bytes_to_addr", + "name": "Blake3::bytes_to_addr", + "rows": 17 + }, + { + "chip": "IxVM::get_ci_iprj", + "name": "IxVM::get_ci_iprj", + "rows": 2 + }, + { + "chip": "IxVM::convert_inductive", + "name": "IxVM::convert_inductive", + "rows": 2 + }, + { + "chip": "IxVM::count_ctors", + "name": "IxVM::count_ctors", + "rows": 4 + }, + { + "chip": "IxVM::get_ci_cprj", + "name": "IxVM::get_ci_cprj", + "rows": 0 + }, + { + "chip": "IxVM::ctor_at", + "name": "IxVM::ctor_at", + "rows": 0 + }, + { + "chip": "IxVM::convert_constructor", + "name": "IxVM::convert_constructor", + "rows": 0 + }, + { + "chip": "IxVM::get_ci_rprj", + "name": "IxVM::get_ci_rprj", + "rows": 0 + }, + { + "chip": "IxVM::convert_recursor", + "name": "IxVM::convert_recursor", + "rows": 0 + }, + { + "chip": "IxVM::convert_rec_rules", + "name": "IxVM::convert_rec_rules", + "rows": 0 + }, + { + "chip": "IxVM::check_const", + "name": "IxVM::check_const", + "rows": 1 + }, + { + "chip": "IxVM::is_unsafe_ci", + "name": "IxVM::is_unsafe_ci", + "rows": 8 + }, + { + "chip": "IxVM::validate_expr_well_scoped", + "name": "IxVM::validate_expr_well_scoped", + "rows": 55 + }, + { + "chip": "IxVM::validate_univ_params_seen", + "name": "IxVM::validate_univ_params_seen", + "rows": 2 + }, + { + "chip": "IxVM::const_num_lvls", + "name": "IxVM::const_num_lvls", + "rows": 7 + }, + { + "chip": "${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}", + "rows": 5 + }, + { + "chip": "IxVM::validate_univ_params_list", + "name": "IxVM::validate_univ_params_list", + "rows": 5 + }, + { + "chip": "IxVM::k_ensure_sort", + "name": "IxVM::k_ensure_sort", + "rows": 6 + }, + { + "chip": "IxVM::k_infer", + "name": "IxVM::k_infer", + "rows": 23 + }, + { + "chip": "IxVM::expr_lbr", + "name": "IxVM::expr_lbr", + "rows": 78 + }, + { + "chip": "IxVM::lbr_max", + "name": "IxVM::lbr_max", + "rows": 14 + }, + { + "chip": "IxVM::lbr_dec", + "name": "IxVM::lbr_dec", + "rows": 5 + }, + { + "chip": "IxVM::expr_lbr_let", + "name": "IxVM::expr_lbr_let", + "rows": 0 + }, + { + "chip": "IxVM::k_infer_core", + "name": "IxVM::k_infer_core", + "rows": 20 + }, + { + "chip": "IxVM::types_lookup", + "name": "IxVM::types_lookup", + "rows": 1 + }, + { + "chip": "${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "name": "${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "rows": 18 + }, + { + "chip": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "name": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "rows": 42 + }, + { + "chip": "IxVM::expr_lift", + "name": "IxVM::expr_lift", + "rows": 9 + }, + { + "chip": "IxVM::expr_lift_walk", + "name": "IxVM::expr_lift_walk", + "rows": 1 + }, + { + "chip": "IxVM::expr_lift_bvar", + "name": "IxVM::expr_lift_bvar", + "rows": 1 + }, + { + "chip": "IxVM::expr_lift_let", + "name": "IxVM::expr_lift_let", + "rows": 0 + }, + { + "chip": "IxVM::level_reduce", + "name": "IxVM::level_reduce", + "rows": 4 + }, + { + "chip": "IxVM::level_max", + "name": "IxVM::level_max", + "rows": 0 + }, + { + "chip": "IxVM::level_explicit_val", + "name": "IxVM::level_explicit_val", + "rows": 0 + }, + { + "chip": "IxVM::level_max_go", + "name": "IxVM::level_max_go", + "rows": 0 + }, + { + "chip": "IxVM::level_struct_eq", + "name": "IxVM::level_struct_eq", + "rows": 0 + }, + { + "chip": "IxVM::level_max_subsumes", + "name": "IxVM::level_max_subsumes", + "rows": 0 + }, + { + "chip": "IxVM::level_max_offsets", + "name": "IxVM::level_max_offsets", + "rows": 0 + }, + { + "chip": "IxVM::level_offset_of", + "name": "IxVM::level_offset_of", + "rows": 0 + }, + { + "chip": "IxVM::level_imax", + "name": "IxVM::level_imax", + "rows": 1 + }, + { + "chip": "IxVM::level_is_not_zero", + "name": "IxVM::level_is_not_zero", + "rows": 0 + }, + { + "chip": "IxVM::level_struct_eq", + "name": "IxVM::level_eq", + "rows": 3 + }, + { + "chip": "IxVM::const_type_of", + "name": "IxVM::const_type_of", + "rows": 7 + }, + { + "chip": "IxVM::expr_inst_levels", + "name": "IxVM::expr_inst_levels", + "rows": 58 + }, + { + "chip": "IxVM::expr_inst_levels_walk", + "name": "IxVM::expr_inst_levels_walk", + "rows": 55 + }, + { + "chip": "IxVM::level_inst_params", + "name": "IxVM::level_inst_params", + "rows": 12 + }, + { + "chip": "${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "name": "${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}", + "rows": 6 + }, + { + "chip": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "name": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}", + "rows": 6 + }, + { + "chip": "IxVM::level_list_inst", + "name": "IxVM::level_list_inst", + "rows": 9 + }, + { + "chip": "IxVM::collect_spine", + "name": "IxVM::collect_spine", + "rows": 52 + }, + { + "chip": "${\"name\":\"IxVM::list_snoc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_snoc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "rows": 46 + }, + { + "chip": "IxVM::k_infer_app_spine_loop", + "name": "IxVM::k_infer_app_spine_loop", + "rows": 30 + }, + { + "chip": "${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "rows": 40 + }, + { + "chip": "IxVM::expr_inst_many", + "name": "IxVM::expr_inst_many", + "rows": 51 + }, + { + "chip": "IxVM::has_bvar_in_range", + "name": "IxVM::has_bvar_in_range", + "rows": 47 + }, + { + "chip": "IxVM::has_bvar_in_range_binder", + "name": "IxVM::has_bvar_in_range_binder", + "rows": 2 + }, + { + "chip": "IxVM::has_bvar_in_range_let", + "name": "IxVM::has_bvar_in_range_let", + "rows": 0 + }, + { + "chip": "IxVM::expr_inst_many_walk", + "name": "IxVM::expr_inst_many_walk", + "rows": 35 + }, + { + "chip": "IxVM::expr_inst_many_bvar", + "name": "IxVM::expr_inst_many_bvar", + "rows": 17 + }, + { + "chip": "IxVM::expr_inst_many_let", + "name": "IxVM::expr_inst_many_let", + "rows": 0 + }, + { + "chip": "IxVM::expr_lower", + "name": "IxVM::expr_lower", + "rows": 17 + }, + { + "chip": "IxVM::expr_lower_walk", + "name": "IxVM::expr_lower_walk", + "rows": 11 + }, + { + "chip": "IxVM::k_check", + "name": "IxVM::k_check", + "rows": 12 + }, + { + "chip": "IxVM::k_is_def_eq", + "name": "IxVM::k_is_def_eq", + "rows": 27 + }, + { + "chip": "IxVM::k_is_def_eq_core", + "name": "IxVM::k_is_def_eq_core", + "rows": 22 + }, + { + "chip": "IxVM::k_is_def_eq_ordered", + "name": "IxVM::k_is_def_eq_ordered", + "rows": 22 + }, + { + "chip": "IxVM::try_def_eq_app", + "name": "IxVM::try_def_eq_app", + "rows": 22 + }, + { + "chip": "IxVM::de_args", + "name": "IxVM::de_args", + "rows": 28 + }, + { + "chip": "IxVM::address_eq", + "name": "IxVM::address_eq", + "rows": 55 + }, + { + "chip": "IxVM::address_eq_tail", + "name": "IxVM::address_eq_tail", + "rows": 8 + }, + { + "chip": "IxVM::level_list_eq", + "name": "IxVM::level_list_eq", + "rows": 5 + }, + { + "chip": "IxVM::level_equal", + "name": "IxVM::level_equal", + "rows": 3 + }, + { + "chip": "IxVM::nl_eq", + "name": "IxVM::nl_eq", + "rows": 1 + }, + { + "chip": "IxVM::nl_skip_empty", + "name": "IxVM::nl_skip_empty", + "rows": 3 + }, + { + "chip": "IxVM::glist_cmp", + "name": "IxVM::glist_cmp", + "rows": 1 + }, + { + "chip": "IxVM::nlvars_eq", + "name": "IxVM::nlvars_eq", + "rows": 0 + }, + { + "chip": "IxVM::level_normalize", + "name": "IxVM::level_normalize", + "rows": 2 + }, + { + "chip": "IxVM::normalize_aux", + "name": "IxVM::normalize_aux", + "rows": 5 + }, + { + "chip": "IxVM::nl_add_const", + "name": "IxVM::nl_add_const", + "rows": 2 + }, + { + "chip": "IxVM::nl_add_const_go", + "name": "IxVM::nl_add_const_go", + "rows": 1 + }, + { + "chip": "IxVM::normalize_imax_dispatch", + "name": "IxVM::normalize_imax_dispatch", + "rows": 0 + }, + { + "chip": "IxVM::glist_ordered_insert", + "name": "IxVM::glist_ordered_insert", + "rows": 0 + }, + { + "chip": "IxVM::nl_add_var", + "name": "IxVM::nl_add_var", + "rows": 0 + }, + { + "chip": "IxVM::nlvars_add", + "name": "IxVM::nlvars_add", + "rows": 0 + }, + { + "chip": "IxVM::nl_subsumption_walk", + "name": "IxVM::nl_subsumption_walk", + "rows": 4 + }, + { + "chip": "IxVM::nl_subsume_entry", + "name": "IxVM::nl_subsume_entry", + "rows": 4 + }, + { + "chip": "IxVM::glist_subset", + "name": "IxVM::glist_subset", + "rows": 1 + }, + { + "chip": "IxVM::glist_eq_len", + "name": "IxVM::glist_eq_len", + "rows": 1 + }, + { + "chip": "IxVM::nlvars_max_offset", + "name": "IxVM::nlvars_max_offset", + "rows": 0 + }, + { + "chip": "IxVM::nlvars_subsume", + "name": "IxVM::nlvars_subsume", + "rows": 0 + }, + { + "chip": "IxVM::k_is_def_eq_slow", + "name": "IxVM::k_is_def_eq_slow", + "rows": 11 + }, + { + "chip": "IxVM::try_string_lit_one", + "name": "IxVM::try_string_lit_one", + "rows": 15 + }, + { + "chip": "IxVM::str_lit_delta_step", + "name": "IxVM::str_lit_delta_step", + "rows": 0 + }, + { + "chip": "IxVM::whnf_nd", + "name": "IxVM::whnf_nd", + "rows": 3 + }, + { + "chip": "IxVM::whnf_nd_with_spine", + "name": "IxVM::whnf_nd_with_spine", + "rows": 5 + }, + { + "chip": "${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "rows": 3 + }, + { + "chip": "IxVM::whnf_nd_apply_beta", + "name": "IxVM::whnf_nd_apply_beta", + "rows": 1 + }, + { + "chip": "IxVM::peel_beta", + "name": "IxVM::peel_beta", + "rows": 4 + }, + { + "chip": "IxVM::apply_spine", + "name": "IxVM::apply_spine", + "rows": 6 + }, + { + "chip": "IxVM::expr_inst1", + "name": "IxVM::expr_inst1", + "rows": 13 + }, + { + "chip": "IxVM::expr_has_bvar_at", + "name": "IxVM::expr_has_bvar_at", + "rows": 23 + }, + { + "chip": "IxVM::expr_has_bvar_at_binder", + "name": "IxVM::expr_has_bvar_at_binder", + "rows": 1 + }, + { + "chip": "IxVM::expr_has_bvar_at_let", + "name": "IxVM::expr_has_bvar_at_let", + "rows": 0 + }, + { + "chip": "IxVM::expr_inst1_walk", + "name": "IxVM::expr_inst1_walk", + "rows": 8 + }, + { + "chip": "IxVM::expr_inst1_bvar", + "name": "IxVM::expr_inst1_bvar", + "rows": 2 + }, + { + "chip": "IxVM::expr_inst1_let", + "name": "IxVM::expr_inst1_let", + "rows": 0 + }, + { + "chip": "IxVM::whnf_nd_const_head", + "name": "IxVM::whnf_nd_const_head", + "rows": 1 + }, + { + "chip": "IxVM::prim_family", + "name": "IxVM::prim_family", + "rows": 1 + }, + { + "chip": "IxVM::nat_succ_addr", + "name": "IxVM::nat_succ_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_pred_addr", + "name": "IxVM::nat_pred_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_add_addr", + "name": "IxVM::nat_add_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_sub_addr", + "name": "IxVM::nat_sub_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_mul_addr", + "name": "IxVM::nat_mul_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_div_addr", + "name": "IxVM::nat_div_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_mod_addr", + "name": "IxVM::nat_mod_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_pow_addr", + "name": "IxVM::nat_pow_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_gcd_addr", + "name": "IxVM::nat_gcd_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_beq_addr", + "name": "IxVM::nat_beq_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_ble_addr", + "name": "IxVM::nat_ble_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_land_addr", + "name": "IxVM::nat_land_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_lor_addr", + "name": "IxVM::nat_lor_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_xor_addr", + "name": "IxVM::nat_xor_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_shift_left_addr", + "name": "IxVM::nat_shift_left_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_shift_right_addr", + "name": "IxVM::nat_shift_right_addr", + "rows": 1 + }, + { + "chip": "IxVM::is_str_prim_addr", + "name": "IxVM::is_str_prim_addr", + "rows": 1 + }, + { + "chip": "IxVM::string_utf8_byte_size_addr", + "name": "IxVM::string_utf8_byte_size_addr", + "rows": 1 + }, + { + "chip": "IxVM::string_append_addr", + "name": "IxVM::string_append_addr", + "rows": 1 + }, + { + "chip": "IxVM::string_of_list_addr", + "name": "IxVM::string_of_list_addr", + "rows": 1 + }, + { + "chip": "IxVM::string_back_addr", + "name": "IxVM::string_back_addr", + "rows": 1 + }, + { + "chip": "IxVM::string_legacy_back_addr", + "name": "IxVM::string_legacy_back_addr", + "rows": 1 + }, + { + "chip": "IxVM::string_to_byte_array_addr", + "name": "IxVM::string_to_byte_array_addr", + "rows": 1 + }, + { + "chip": "IxVM::string_dec_eq_addr", + "name": "IxVM::string_dec_eq_addr", + "rows": 1 + }, + { + "chip": "IxVM::is_bitvec_prim_addr", + "name": "IxVM::is_bitvec_prim_addr", + "rows": 1 + }, + { + "chip": "IxVM::bit_vec_to_nat_addr", + "name": "IxVM::bit_vec_to_nat_addr", + "rows": 1 + }, + { + "chip": "IxVM::bit_vec_ult_addr", + "name": "IxVM::bit_vec_ult_addr", + "rows": 1 + }, + { + "chip": "IxVM::decidable_decide_addr", + "name": "IxVM::decidable_decide_addr", + "rows": 1 + }, + { + "chip": "IxVM::is_native_prim_addr", + "name": "IxVM::is_native_prim_addr", + "rows": 1 + }, + { + "chip": "IxVM::system_platform_num_bits_addr", + "name": "IxVM::system_platform_num_bits_addr", + "rows": 1 + }, + { + "chip": "IxVM::punit_size_of_1_addr", + "name": "IxVM::punit_size_of_1_addr", + "rows": 1 + }, + { + "chip": "IxVM::reduce_bool_addr", + "name": "IxVM::reduce_bool_addr", + "rows": 1 + }, + { + "chip": "IxVM::reduce_nat_addr", + "name": "IxVM::reduce_nat_addr", + "rows": 1 + }, + { + "chip": "IxVM::subtype_val_addr", + "name": "IxVM::subtype_val_addr", + "rows": 1 + }, + { + "chip": "IxVM::is_dec_prim_addr", + "name": "IxVM::is_dec_prim_addr", + "rows": 1 + }, + { + "chip": "IxVM::nat_dec_le_addr_dec", + "name": "IxVM::nat_dec_le_addr_dec", + "rows": 1 + }, + { + "chip": "IxVM::nat_dec_eq_addr_dec", + "name": "IxVM::nat_dec_eq_addr_dec", + "rows": 1 + }, + { + "chip": "IxVM::nat_dec_lt_addr_dec", + "name": "IxVM::nat_dec_lt_addr_dec", + "rows": 1 + }, + { + "chip": "IxVM::int_dec_le_addr_dec", + "name": "IxVM::int_dec_le_addr_dec", + "rows": 1 + }, + { + "chip": "IxVM::int_dec_eq_addr_dec", + "name": "IxVM::int_dec_eq_addr_dec", + "rows": 1 + }, + { + "chip": "IxVM::int_dec_lt_addr_dec", + "name": "IxVM::int_dec_lt_addr_dec", + "rows": 1 + }, + { + "chip": "IxVM::is_int_prim_addr", + "name": "IxVM::is_int_prim_addr", + "rows": 1 + }, + { + "chip": "IxVM::int_add_addr", + "name": "IxVM::int_add_addr", + "rows": 1 + }, + { + "chip": "IxVM::int_sub_addr", + "name": "IxVM::int_sub_addr", + "rows": 1 + }, + { + "chip": "IxVM::int_mul_addr", + "name": "IxVM::int_mul_addr", + "rows": 1 + }, + { + "chip": "IxVM::int_neg_addr", + "name": "IxVM::int_neg_addr", + "rows": 1 + }, + { + "chip": "IxVM::int_emod_addr", + "name": "IxVM::int_emod_addr", + "rows": 1 + }, + { + "chip": "IxVM::int_ediv_addr", + "name": "IxVM::int_ediv_addr", + "rows": 1 + }, + { + "chip": "IxVM::int_bmod_addr", + "name": "IxVM::int_bmod_addr", + "rows": 1 + }, + { + "chip": "IxVM::int_bdiv_addr", + "name": "IxVM::int_bdiv_addr", + "rows": 1 + }, + { + "chip": "IxVM::int_nat_abs_addr", + "name": "IxVM::int_nat_abs_addr", + "rows": 1 + }, + { + "chip": "IxVM::int_pow_addr", + "name": "IxVM::int_pow_addr", + "rows": 1 + }, + { + "chip": "IxVM::try_prim_dispatch", + "name": "IxVM::try_prim_dispatch", + "rows": 1 + }, + { + "chip": "IxVM::try_nat_dispatch_prewhnf", + "name": "IxVM::try_nat_dispatch_prewhnf", + "rows": 0 + }, + { + "chip": "IxVM::whnf_spine", + "name": "IxVM::whnf_spine", + "rows": 0 + }, + { + "chip": "IxVM::whnf", + "name": "IxVM::whnf", + "rows": 8 + }, + { + "chip": "IxVM::whnf_with_spine", + "name": "IxVM::whnf_with_spine", + "rows": 3 + }, + { + "chip": "IxVM::whnf_apply_beta", + "name": "IxVM::whnf_apply_beta", + "rows": 1 + }, + { + "chip": "IxVM::whnf_const_head", + "name": "IxVM::whnf_const_head", + "rows": 0 + }, + { + "chip": "IxVM::try_reduce_projection_definition", + "name": "IxVM::try_reduce_projection_definition", + "rows": 1 + }, + { + "chip": "IxVM::projection_definition_info", + "name": "IxVM::projection_definition_info", + "rows": 2 + }, + { + "chip": "IxVM::try_quot_iota", + "name": "IxVM::try_quot_iota", + "rows": 0 + }, + { + "chip": "IxVM::quot_lift_addr_iota", + "name": "IxVM::quot_lift_addr_iota", + "rows": 0 + }, + { + "chip": "IxVM::try_quot_lift", + "name": "IxVM::try_quot_lift", + "rows": 0 + }, + { + "chip": "IxVM::quot_extract_arg", + "name": "IxVM::quot_extract_arg", + "rows": 0 + }, + { + "chip": "IxVM::quot_ctor_addr_iota", + "name": "IxVM::quot_ctor_addr_iota", + "rows": 0 + }, + { + "chip": "IxVM::quot_ind_addr_iota", + "name": "IxVM::quot_ind_addr_iota", + "rows": 0 + }, + { + "chip": "IxVM::try_quot_ind", + "name": "IxVM::try_quot_ind", + "rows": 0 + }, + { + "chip": "IxVM::se_parent_addr", + "name": "IxVM::se_parent_addr", + "rows": 0 + }, + { + "chip": "IxVM::try_k_synth_iota", + "name": "IxVM::try_k_synth_iota", + "rows": 0 + }, + { + "chip": "IxVM::k_synth_gate", + "name": "IxVM::k_synth_gate", + "rows": 0 + }, + { + "chip": "IxVM::canon_cprj_addr", + "name": "IxVM::canon_cprj_addr", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_take\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_take\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "rows": 2 + }, + { + "chip": "IxVM::try_iota", + "name": "IxVM::try_iota", + "rows": 0 + }, + { + "chip": "IxVM::try_nat_linear_rec", + "name": "IxVM::try_nat_linear_rec", + "rows": 0 + }, + { + "chip": "IxVM::try_extract_nat", + "name": "IxVM::try_extract_nat", + "rows": 0 + }, + { + "chip": "IxVM::nat_zero_addr", + "name": "IxVM::nat_zero_addr", + "rows": 0 + }, + { + "chip": "IxVM::try_extract_nat_app", + "name": "IxVM::try_extract_nat_app", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_succ", + "name": "IxVM::klimbs_succ", + "rows": 0 + }, + { + "chip": "IxVM::is_nat_succ_ih_step", + "name": "IxVM::is_nat_succ_ih_step", + "rows": 0 + }, + { + "chip": "IxVM::apply_spine", + "name": "IxVM::np_apply_spine", + "rows": 0 + }, + { + "chip": "IxVM::mk_nat_lit", + "name": "IxVM::mk_nat_lit", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_add", + "name": "IxVM::klimbs_add", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_add_carry", + "name": "IxVM::klimbs_add_carry", + "rows": 0 + }, + { + "chip": "IxVM::mk_nat_offset_stuck", + "name": "IxVM::mk_nat_offset_stuck", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_is_zero", + "name": "IxVM::klimbs_is_zero", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_normalize", + "name": "IxVM::klimbs_normalize", + "rows": 0 + }, + { + "chip": "IxVM::cleanup_nat_offset_major", + "name": "IxVM::cleanup_nat_offset_major", + "rows": 0 + }, + { + "chip": "IxVM::try_match_nat_add", + "name": "IxVM::try_match_nat_add", + "rows": 0 + }, + { + "chip": "IxVM::build_succ_offset", + "name": "IxVM::build_succ_offset", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_sub", + "name": "IxVM::klimbs_sub", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_sub_borrow", + "name": "IxVM::klimbs_sub_borrow", + "rows": 0 + }, + { + "chip": "UInt64::sub_with_borrow", + "name": "UInt64::sub_with_borrow", + "rows": 0 + }, + { + "chip": "IxVM::whnf_iota_major", + "name": "IxVM::whnf_iota_major", + "rows": 0 + }, + { + "chip": "IxVM::nat_lit_to_ctor_or_self", + "name": "IxVM::nat_lit_to_ctor_or_self", + "rows": 0 + }, + { + "chip": "IxVM::nat_zero_addr", + "name": "IxVM::nat_zero_addr_iota", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_dec", + "name": "IxVM::klimbs_dec", + "rows": 0 + }, + { + "chip": "IxVM::nat_succ_addr", + "name": "IxVM::nat_succ_addr_iota", + "rows": 0 + }, + { + "chip": "IxVM::collect_spine_of_ctor", + "name": "IxVM::collect_spine_of_ctor", + "rows": 0 + }, + { + "chip": "IxVM::compute_iprj_addr", + "name": "IxVM::compute_iprj_addr", + "rows": 0 + }, + { + "chip": "IxVM::find_rule", + "name": "IxVM::find_rule", + "rows": 0 + }, + { + "chip": "IxVM::replace_spine_major", + "name": "IxVM::replace_spine_major", + "rows": 0 + }, + { + "chip": "IxVM::rec_to_parent_addr", + "name": "IxVM::rec_to_parent_addr", + "rows": 0 + }, + { + "chip": "IxVM::peel_n_foralls", + "name": "IxVM::peel_n_foralls", + "rows": 0 + }, + { + "chip": "IxVM::try_struct_eta_iota", + "name": "IxVM::try_struct_eta_iota", + "rows": 0 + }, + { + "chip": "IxVM::struct_is_rec", + "name": "IxVM::struct_is_rec", + "rows": 0 + }, + { + "chip": "IxVM::struct_block_member_addrs", + "name": "IxVM::struct_block_member_addrs", + "rows": 0 + }, + { + "chip": "IxVM::struct_scan_ctors", + "name": "IxVM::struct_scan_ctors", + "rows": 0 + }, + { + "chip": "IxVM::se_peel_tol", + "name": "IxVM::se_peel_tol", + "rows": 0 + }, + { + "chip": "IxVM::se_scan_fields", + "name": "IxVM::se_scan_fields", + "rows": 0 + }, + { + "chip": "IxVM::se_mentions", + "name": "IxVM::se_mentions", + "rows": 0 + }, + { + "chip": "IxVM::se_addr_in", + "name": "IxVM::se_addr_in", + "rows": 0 + }, + { + "chip": "IxVM::is_prop_type", + "name": "IxVM::is_prop_type", + "rows": 1 + }, + { + "chip": "IxVM::k_infer_only", + "name": "IxVM::k_infer_only", + "rows": 2 + }, + { + "chip": "IxVM::const_num_lvls", + "name": "IxVM::io_const_num_lvls", + "rows": 0 + }, + { + "chip": "IxVM::const_type_of", + "name": "IxVM::io_const_type_of", + "rows": 0 + }, + { + "chip": "IxVM::ensure_sort_only", + "name": "IxVM::ensure_sort_only", + "rows": 0 + }, + { + "chip": "IxVM::nat_addr_io", + "name": "IxVM::nat_addr_io", + "rows": 0 + }, + { + "chip": "IxVM::str_addr_io", + "name": "IxVM::str_addr_io", + "rows": 0 + }, + { + "chip": "IxVM::io_peel_params_subst", + "name": "IxVM::io_peel_params_subst", + "rows": 0 + }, + { + "chip": "IxVM::io_peel_field_loop", + "name": "IxVM::io_peel_field_loop", + "rows": 0 + }, + { + "chip": "IxVM::ctx_trim", + "name": "IxVM::ctx_trim", + "rows": 4 + }, + { + "chip": "IxVM::ctx_seek_cut", + "name": "IxVM::ctx_seek_cut", + "rows": 1 + }, + { + "chip": "IxVM::ctx_next_cut", + "name": "IxVM::ctx_next_cut", + "rows": 1 + }, + { + "chip": "IxVM::ctx_close_cut", + "name": "IxVM::ctx_close_cut", + "rows": 1 + }, + { + "chip": "IxVM::lbr_min", + "name": "IxVM::lbr_min", + "rows": 9 + }, + { + "chip": "IxVM::apply_n_projs", + "name": "IxVM::apply_n_projs", + "rows": 0 + }, + { + "chip": "IxVM::whnf_proj_head", + "name": "IxVM::whnf_proj_head", + "rows": 0 + }, + { + "chip": "IxVM::str_lit_to_ctor_app_or_self", + "name": "IxVM::str_lit_to_ctor_app_or_self", + "rows": 0 + }, + { + "chip": "IxVM::str_lit_to_ctor", + "name": "IxVM::str_lit_to_ctor", + "rows": 0 + }, + { + "chip": "IxVM::list_nil_addr", + "name": "IxVM::list_nil_addr", + "rows": 0 + }, + { + "chip": "IxVM::list_cons_addr", + "name": "IxVM::list_cons_addr", + "rows": 0 + }, + { + "chip": "IxVM::char_type_addr", + "name": "IxVM::char_type_addr", + "rows": 0 + }, + { + "chip": "IxVM::char_of_nat_addr", + "name": "IxVM::char_of_nat_addr", + "rows": 0 + }, + { + "chip": "IxVM::build_char_list", + "name": "IxVM::build_char_list", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_from_g", + "name": "IxVM::klimbs_from_g", + "rows": 0 + }, + { + "chip": "IxVM::split_u32", + "name": "IxVM::split_u32", + "rows": 0 + }, + { + "chip": "IxVM::divmod_256", + "name": "IxVM::divmod_256", + "rows": 0 + }, + { + "chip": "IxVM::try_reduce_fin_val_decidable_rec", + "name": "IxVM::try_reduce_fin_val_decidable_rec", + "rows": 0 + }, + { + "chip": "IxVM::fin_addr", + "name": "IxVM::fin_addr", + "rows": 0 + }, + { + "chip": "IxVM::decidable_rec_addr", + "name": "IxVM::decidable_rec_addr", + "rows": 0 + }, + { + "chip": "IxVM::nat_addr_io", + "name": "IxVM::nat_ty_addr", + "rows": 0 + }, + { + "chip": "IxVM::whnf_get_ctor_or_none", + "name": "IxVM::whnf_get_ctor_or_none", + "rows": 0 + }, + { + "chip": "IxVM::try_nat_binop_dispatch", + "name": "IxVM::try_nat_binop_dispatch", + "rows": 0 + }, + { + "chip": "IxVM::try_nat_binop_addr", + "name": "IxVM::try_nat_binop_addr", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_mul", + "name": "IxVM::klimbs_mul", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_mul_outer", + "name": "IxVM::klimbs_mul_outer", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_mul_single", + "name": "IxVM::klimbs_mul_single", + "rows": 0 + }, + { + "chip": "UInt64::mul", + "name": "UInt64::mul", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_shl_limbs", + "name": "IxVM::klimbs_shl_limbs", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_div", + "name": "IxVM::klimbs_div", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_div_mod", + "name": "IxVM::klimbs_div_mod", + "rows": 0 + }, + { + "chip": "IxVM::ordinary_div_mod", + "name": "IxVM::ordinary_div_mod", + "rows": 0 + }, + { + "chip": "IxVM::divide_grow", + "name": "IxVM::divide_grow", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_le", + "name": "IxVM::klimbs_le", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_eq", + "name": "IxVM::klimbs_eq", + "rows": 0 + }, + { + "chip": "UInt64::eq", + "name": "UInt64::eq", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_mod", + "name": "IxVM::klimbs_mod", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_gcd", + "name": "IxVM::klimbs_gcd", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_pow", + "name": "IxVM::klimbs_pow", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_land", + "name": "IxVM::klimbs_land", + "rows": 0 + }, + { + "chip": "UInt64::and", + "name": "UInt64::and", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_lor", + "name": "IxVM::klimbs_lor", + "rows": 0 + }, + { + "chip": "UInt64::or", + "name": "UInt64::or", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_xor_op", + "name": "IxVM::klimbs_xor_op", + "rows": 0 + }, + { + "chip": "UInt64::xor", + "name": "UInt64::xor", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_shl", + "name": "IxVM::klimbs_shl", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_shr", + "name": "IxVM::klimbs_shr", + "rows": 0 + }, + { + "chip": "IxVM::mk_bool", + "name": "IxVM::mk_bool", + "rows": 0 + }, + { + "chip": "IxVM::bool_false_addr", + "name": "IxVM::bool_false_addr", + "rows": 0 + }, + { + "chip": "IxVM::bool_true_addr", + "name": "IxVM::bool_true_addr", + "rows": 0 + }, + { + "chip": "IxVM::try_nat_offset_dispatch", + "name": "IxVM::try_nat_offset_dispatch", + "rows": 0 + }, + { + "chip": "IxVM::mk_nat_binop_stuck", + "name": "IxVM::mk_nat_binop_stuck", + "rows": 0 + }, + { + "chip": "IxVM::try_str_dispatch", + "name": "IxVM::try_str_dispatch", + "rows": 0 + }, + { + "chip": "IxVM::walk_char_list_bytes", + "name": "IxVM::walk_char_list_bytes", + "rows": 0 + }, + { + "chip": "IxVM::char_lit_codepoint", + "name": "IxVM::char_lit_codepoint", + "rows": 0 + }, + { + "chip": "IxVM::char_lit_codepoint_syn", + "name": "IxVM::char_lit_codepoint_syn", + "rows": 0 + }, + { + "chip": "IxVM::klimbs_scalar_value", + "name": "IxVM::klimbs_scalar_value", + "rows": 0 + }, + { + "chip": "IxVM::utf8_encode_prepend", + "name": "IxVM::utf8_encode_prepend", + "rows": 0 + }, + { + "chip": "IxVM::utf8_groups", + "name": "IxVM::utf8_groups", + "rows": 0 + }, + { + "chip": "IxVM::divmod_64u", + "name": "IxVM::divmod_64u", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_length\",\"types\":[\"field\"]}", + "rows": 0 + }, + { + "chip": "IxVM::try_str_back", + "name": "IxVM::try_str_back", + "rows": 0 + }, + { + "chip": "IxVM::utf8_last_codepoint", + "name": "IxVM::utf8_last_codepoint", + "rows": 0 + }, + { + "chip": "IxVM::utf8_last_go", + "name": "IxVM::utf8_last_go", + "rows": 0 + }, + { + "chip": "IxVM::try_str_to_byte_array", + "name": "IxVM::try_str_to_byte_array", + "rows": 0 + }, + { + "chip": "IxVM::byte_array_empty_addr", + "name": "IxVM::byte_array_empty_addr", + "rows": 0 + }, + { + "chip": "IxVM::try_str_dec_eq", + "name": "IxVM::try_str_dec_eq", + "rows": 0 + }, + { + "chip": "IxVM::bytestream_eq", + "name": "IxVM::bytestream_eq", + "rows": 0 + }, + { + "chip": "IxVM::str_dec_eq_build", + "name": "IxVM::str_dec_eq_build", + "rows": 0 + }, + { + "chip": "IxVM::eq_refl_addr_dec", + "name": "IxVM::eq_refl_addr_dec", + "rows": 0 + }, + { + "chip": "IxVM::str_addr_io", + "name": "IxVM::string_type_addr", + "rows": 0 + }, + { + "chip": "IxVM::decidable_is_true_addr_dec", + "name": "IxVM::decidable_is_true_addr_dec", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_concat\",\"types\":[\"field\"]}", + "rows": 26 + }, + { + "chip": "IxVM::try_bitvec_dispatch", + "name": "IxVM::try_bitvec_dispatch", + "rows": 0 + }, + { + "chip": "IxVM::bitvec_prep_spine", + "name": "IxVM::bitvec_prep_spine", + "rows": 0 + }, + { + "chip": "IxVM::bv_to_nat_via", + "name": "IxVM::bv_to_nat_via", + "rows": 0 + }, + { + "chip": "IxVM::bitvec_of_nat_args_direct", + "name": "IxVM::bitvec_of_nat_args_direct", + "rows": 0 + }, + { + "chip": "IxVM::bit_vec_of_nat_addr", + "name": "IxVM::bit_vec_of_nat_addr", + "rows": 0 + }, + { + "chip": "IxVM::bitvec_prep_spine_ult", + "name": "IxVM::bitvec_prep_spine_ult", + "rows": 0 + }, + { + "chip": "IxVM::np_whnf_inner_bv", + "name": "IxVM::np_whnf_inner_bv", + "rows": 0 + }, + { + "chip": "IxVM::try_reduce_bit_vec_ult", + "name": "IxVM::try_reduce_bit_vec_ult", + "rows": 0 + }, + { + "chip": "IxVM::try_reduce_decide_bitvec_lt", + "name": "IxVM::try_reduce_decide_bitvec_lt", + "rows": 0 + }, + { + "chip": "IxVM::lt_lt_addr", + "name": "IxVM::lt_lt_addr", + "rows": 0 + }, + { + "chip": "IxVM::bit_vec_addr", + "name": "IxVM::bit_vec_addr", + "rows": 0 + }, + { + "chip": "IxVM::try_native_dispatch", + "name": "IxVM::try_native_dispatch", + "rows": 0 + }, + { + "chip": "IxVM::mk_nat_literal_64", + "name": "IxVM::mk_nat_literal_64", + "rows": 0 + }, + { + "chip": "IxVM::mk_nat_one", + "name": "IxVM::mk_nat_one", + "rows": 0 + }, + { + "chip": "IxVM::try_reduce_subtype_val", + "name": "IxVM::try_reduce_subtype_val", + "rows": 0 + }, + { + "chip": "IxVM::system_platform_get_num_bits_addr", + "name": "IxVM::system_platform_get_num_bits_addr", + "rows": 0 + }, + { + "chip": "IxVM::check_native_bool", + "name": "IxVM::check_native_bool", + "rows": 0 + }, + { + "chip": "IxVM::check_native_nat", + "name": "IxVM::check_native_nat", + "rows": 0 + }, + { + "chip": "IxVM::try_dec_dispatch", + "name": "IxVM::try_dec_dispatch", + "rows": 0 + }, + { + "chip": "IxVM::is_int_dec_prim_addr", + "name": "IxVM::is_int_dec_prim_addr", + "rows": 0 + }, + { + "chip": "IxVM::try_normalize_int_decidable", + "name": "IxVM::try_normalize_int_decidable", + "rows": 0 + }, + { + "chip": "IxVM::try_extract_int", + "name": "IxVM::try_extract_int", + "rows": 0 + }, + { + "chip": "IxVM::int_of_nat_addr_dec", + "name": "IxVM::int_of_nat_addr_dec", + "rows": 0 + }, + { + "chip": "IxVM::int_neg_succ_addr_dec", + "name": "IxVM::int_neg_succ_addr_dec", + "rows": 0 + }, + { + "chip": "IxVM::normalize_int_dec_rebuild", + "name": "IxVM::normalize_int_dec_rebuild", + "rows": 0 + }, + { + "chip": "IxVM::intern_int_lit", + "name": "IxVM::intern_int_lit", + "rows": 0 + }, + { + "chip": "IxVM::dec_rewrite_lt_to_le", + "name": "IxVM::dec_rewrite_lt_to_le", + "rows": 0 + }, + { + "chip": "IxVM::dec_dispatch_le_eq", + "name": "IxVM::dec_dispatch_le_eq", + "rows": 0 + }, + { + "chip": "IxVM::dec_build_proof", + "name": "IxVM::dec_build_proof", + "rows": 0 + }, + { + "chip": "IxVM::bool_type_addr_dec", + "name": "IxVM::bool_type_addr_dec", + "rows": 0 + }, + { + "chip": "IxVM::nat_le_of_ble_eq_true_addr_dec", + "name": "IxVM::nat_le_of_ble_eq_true_addr_dec", + "rows": 0 + }, + { + "chip": "IxVM::nat_not_le_of_not_ble_eq_true_addr_dec", + "name": "IxVM::nat_not_le_of_not_ble_eq_true_addr_dec", + "rows": 0 + }, + { + "chip": "IxVM::nat_eq_of_beq_eq_true_addr_dec", + "name": "IxVM::nat_eq_of_beq_eq_true_addr_dec", + "rows": 0 + }, + { + "chip": "IxVM::nat_ne_of_beq_eq_false_addr_dec", + "name": "IxVM::nat_ne_of_beq_eq_false_addr_dec", + "rows": 0 + }, + { + "chip": "IxVM::dec_finish", + "name": "IxVM::dec_finish", + "rows": 0 + }, + { + "chip": "IxVM::decidable_is_false_addr_dec", + "name": "IxVM::decidable_is_false_addr_dec", + "rows": 0 + }, + { + "chip": "IxVM::try_int_prim_dispatch", + "name": "IxVM::try_int_prim_dispatch", + "rows": 0 + }, + { + "chip": "IxVM::try_extract_int_prim", + "name": "IxVM::try_extract_int_prim", + "rows": 0 + }, + { + "chip": "IxVM::int_of_nat_addr_dec", + "name": "IxVM::int_of_nat_addr", + "rows": 0 + }, + { + "chip": "IxVM::int_neg_succ_addr_dec", + "name": "IxVM::int_neg_succ_addr", + "rows": 0 + }, + { + "chip": "IxVM::mk_int_prim", + "name": "IxVM::mk_int_prim", + "rows": 0 + }, + { + "chip": "IxVM::try_int_prim_second", + "name": "IxVM::try_int_prim_second", + "rows": 0 + }, + { + "chip": "IxVM::int_bmod_prim", + "name": "IxVM::int_bmod_prim", + "rows": 0 + }, + { + "chip": "IxVM::int_bdiv_prim", + "name": "IxVM::int_bdiv_prim", + "rows": 0 + }, + { + "chip": "IxVM::int_add_prim", + "name": "IxVM::int_add_prim", + "rows": 0 + }, + { + "chip": "IxVM::int_emod_prim", + "name": "IxVM::int_emod_prim", + "rows": 0 + }, + { + "chip": "IxVM::int_ediv_prim", + "name": "IxVM::int_ediv_prim", + "rows": 0 + }, + { + "chip": "IxVM::whnf_nd_proj_head", + "name": "IxVM::whnf_nd_proj_head", + "rows": 0 + }, + { + "chip": "IxVM::k_is_def_eq_slow_nd", + "name": "IxVM::k_is_def_eq_slow_nd", + "rows": 11 + }, + { + "chip": "IxVM::whnf_struct_core", + "name": "IxVM::whnf_struct_core", + "rows": 13 + }, + { + "chip": "IxVM::whnf_struct_core_spine", + "name": "IxVM::whnf_struct_core_spine", + "rows": 5 + }, + { + "chip": "IxVM::whnf_struct_core_proj", + "name": "IxVM::whnf_struct_core_proj", + "rows": 0 + }, + { + "chip": "IxVM::whnf_struct_core_const", + "name": "IxVM::whnf_struct_core_const", + "rows": 1 + }, + { + "chip": "IxVM::k_is_def_eq_struct_safe", + "name": "IxVM::k_is_def_eq_struct_safe", + "rows": 10 + }, + { + "chip": "IxVM::k_is_def_eq_slow_nd_after_core", + "name": "IxVM::k_is_def_eq_slow_nd_after_core", + "rows": 1 + }, + { + "chip": "IxVM::k_is_def_eq_slow2", + "name": "IxVM::k_is_def_eq_slow2", + "rows": 1 + }, + { + "chip": "IxVM::try_proof_irrel", + "name": "IxVM::try_proof_irrel", + "rows": 1 + }, + { + "chip": "IxVM::try_unit_like", + "name": "IxVM::try_unit_like", + "rows": 1 + }, + { + "chip": "IxVM::is_unit_like_type", + "name": "IxVM::is_unit_like_type", + "rows": 1 + }, + { + "chip": "IxVM::try_eta_struct", + "name": "IxVM::try_eta_struct", + "rows": 2 + }, + { + "chip": "IxVM::compare_struct_fields", + "name": "IxVM::compare_struct_fields", + "rows": 0 + }, + { + "chip": "IxVM::try_def_eq_nat", + "name": "IxVM::try_def_eq_nat", + "rows": 2 + }, + { + "chip": "IxVM::is_nat_zero", + "name": "IxVM::is_nat_zero", + "rows": 2 + }, + { + "chip": "IxVM::nat_offset_of", + "name": "IxVM::nat_offset_of", + "rows": 2 + }, + { + "chip": "IxVM::lazy_delta_loop", + "name": "IxVM::lazy_delta_loop", + "rows": 2 + }, + { + "chip": "IxVM::head_addr", + "name": "IxVM::head_addr", + "rows": 2 + }, + { + "chip": "IxVM::lazy_delta_step_const_const", + "name": "IxVM::lazy_delta_step_const_const", + "rows": 0 + }, + { + "chip": "IxVM::is_defn_or_thm", + "name": "IxVM::is_defn_or_thm", + "rows": 1 + }, + { + "chip": "IxVM::unfold_b_and_loop", + "name": "IxVM::unfold_b_and_loop", + "rows": 0 + }, + { + "chip": "IxVM::delta_unfold", + "name": "IxVM::delta_unfold", + "rows": 1 + }, + { + "chip": "IxVM::unfold_a_and_loop", + "name": "IxVM::unfold_a_and_loop", + "rows": 0 + }, + { + "chip": "IxVM::delta_rank", + "name": "IxVM::delta_rank", + "rows": 0 + }, + { + "chip": "IxVM::unfold_both_and_loop", + "name": "IxVM::unfold_both_and_loop", + "rows": 0 + }, + { + "chip": "IxVM::lazy_delta_a_const_b_proj", + "name": "IxVM::lazy_delta_a_const_b_proj", + "rows": 0 + }, + { + "chip": "IxVM::try_unfold_proj_app", + "name": "IxVM::try_unfold_proj_app", + "rows": 1 + }, + { + "chip": "IxVM::try_unfold_head", + "name": "IxVM::try_unfold_head", + "rows": 1 + }, + { + "chip": "IxVM::lazy_delta_b_const_a_proj", + "name": "IxVM::lazy_delta_b_const_a_proj", + "rows": 1 + }, + { + "chip": "IxVM::lazy_delta_both_proj", + "name": "IxVM::lazy_delta_both_proj", + "rows": 1 + }, + { + "chip": "IxVM::slow2_after_delta", + "name": "IxVM::slow2_after_delta", + "rows": 1 + }, + { + "chip": "IxVM::k_is_def_eq_struct_bounded", + "name": "IxVM::k_is_def_eq_struct_bounded", + "rows": 1 + }, + { + "chip": "IxVM::k_is_def_eq_struct_spend", + "name": "IxVM::k_is_def_eq_struct_spend", + "rows": 0 + }, + { + "chip": "IxVM::literal_eq", + "name": "IxVM::literal_eq", + "rows": 0 + }, + { + "chip": "IxVM::k_is_def_eq_structure_tree", + "name": "IxVM::k_is_def_eq_structure_tree", + "rows": 0 + }, + { + "chip": "IxVM::try_same_proj_head_app", + "name": "IxVM::try_same_proj_head_app", + "rows": 0 + }, + { + "chip": "IxVM::k_is_def_eq_structure_tree_app", + "name": "IxVM::k_is_def_eq_structure_tree_app", + "rows": 0 + }, + { + "chip": "IxVM::slow2_eager_fallback", + "name": "IxVM::slow2_eager_fallback", + "rows": 0 + }, + { + "chip": "IxVM::try_eta_swap", + "name": "IxVM::try_eta_swap", + "rows": 0 + }, + { + "chip": "IxVM::try_eta_expand", + "name": "IxVM::try_eta_expand", + "rows": 0 + }, + { + "chip": "IxVM::k_is_def_eq_struct", + "name": "IxVM::k_is_def_eq_struct", + "rows": 0 + }, + { + "chip": "IxVM::k_is_def_eq_struct_go", + "name": "IxVM::k_is_def_eq_struct_go", + "rows": 0 + }, + { + "chip": "IxVM::try_lazy_delta_app", + "name": "IxVM::try_lazy_delta_app", + "rows": 0 + }, + { + "chip": "IxVM::k_def_eq_rebase", + "name": "IxVM::k_def_eq_rebase", + "rows": 12 + }, + { + "chip": "IxVM::expr_glb", + "name": "IxVM::expr_glb", + "rows": 47 + }, + { + "chip": "IxVM::expr_glb_walk", + "name": "IxVM::expr_glb_walk", + "rows": 36 + }, + { + "chip": "IxVM::expr_glb_binder", + "name": "IxVM::expr_glb_binder", + "rows": 6 + }, + { + "chip": "IxVM::expr_glb_let", + "name": "IxVM::expr_glb_let", + "rows": 0 + }, + { + "chip": "IxVM::k_infer_let_start", + "name": "IxVM::k_infer_let_start", + "rows": 0 + }, + { + "chip": "IxVM::k_infer_let_env", + "name": "IxVM::k_infer_let_env", + "rows": 0 + }, + { + "chip": "IxVM::infer_let_local_cutoff", + "name": "IxVM::infer_let_local_cutoff", + "rows": 0 + }, + { + "chip": "IxVM::k_infer_let_env_core", + "name": "IxVM::k_infer_let_env_core", + "rows": 0 + }, + { + "chip": "IxVM::infer_let_lookup_type", + "name": "IxVM::infer_let_lookup_type", + "rows": 0 + }, + { + "chip": "IxVM::infer_let_materialize", + "name": "IxVM::infer_let_materialize", + "rows": 0 + }, + { + "chip": "IxVM::infer_let_lookup_value", + "name": "IxVM::infer_let_lookup_value", + "rows": 0 + }, + { + "chip": "IxVM::k_infer_let_env_rebase", + "name": "IxVM::k_infer_let_env_rebase", + "rows": 0 + }, + { + "chip": "IxVM::infer_let_drop_unused", + "name": "IxVM::infer_let_drop_unused", + "rows": 0 + }, + { + "chip": "IxVM::k_infer_lit", + "name": "IxVM::k_infer_lit", + "rows": 0 + }, + { + "chip": "IxVM::nat_addr_io", + "name": "IxVM::nat_addr", + "rows": 0 + }, + { + "chip": "IxVM::str_addr_io", + "name": "IxVM::str_addr", + "rows": 0 + }, + { + "chip": "IxVM::k_infer_proj", + "name": "IxVM::k_infer_proj", + "rows": 0 + }, + { + "chip": "IxVM::io_peel_params_subst", + "name": "IxVM::peel_params_subst", + "rows": 0 + }, + { + "chip": "IxVM::is_inductive_prop", + "name": "IxVM::is_inductive_prop", + "rows": 0 + }, + { + "chip": "IxVM::peel_n_alls_whnf", + "name": "IxVM::peel_n_alls_whnf", + "rows": 0 + }, + { + "chip": "IxVM::peel_field_loop", + "name": "IxVM::peel_field_loop", + "rows": 0 + }, + { + "chip": "IxVM::check_prop_field_if_prop", + "name": "IxVM::check_prop_field_if_prop", + "rows": 0 + }, + { + "chip": "IxVM::check_no_dep_data_field_if_prop", + "name": "IxVM::check_no_dep_data_field_if_prop", + "rows": 0 + }, + { + "chip": "IxVM::k_infer_rebase", + "name": "IxVM::k_infer_rebase", + "rows": 10 + }, + { + "chip": "IxVM::assert_safety", + "name": "IxVM::assert_safety", + "rows": 2 + }, + { + "chip": "IxVM::safe_refs_only", + "name": "IxVM::safe_refs_only", + "rows": 34 + }, + { + "chip": "IxVM::check_quot", + "name": "IxVM::check_quot", + "rows": 0 + }, + { + "chip": "IxVM::quot_type_addr", + "name": "IxVM::quot_type_addr", + "rows": 0 + }, + { + "chip": "IxVM::quot_ctor_addr_iota", + "name": "IxVM::quot_ctor_addr", + "rows": 0 + }, + { + "chip": "IxVM::quot_lift_addr_iota", + "name": "IxVM::quot_lift_addr", + "rows": 0 + }, + { + "chip": "IxVM::check_eq_type", + "name": "IxVM::check_eq_type", + "rows": 0 + }, + { + "chip": "IxVM::eq_type_addr", + "name": "IxVM::eq_type_addr", + "rows": 0 + }, + { + "chip": "IxVM::quot_ind_addr_iota", + "name": "IxVM::quot_ind_addr", + "rows": 0 + }, + { + "chip": "IxVM::count_foralls_at_least", + "name": "IxVM::count_foralls_at_least", + "rows": 0 + }, + { + "chip": "IxVM::check_canonical_block", + "name": "IxVM::check_canonical_block", + "rows": 0 + }, + { + "chip": "IxVM::canon_muts_has_kind", + "name": "IxVM::canon_muts_has_kind", + "rows": 0 + }, + { + "chip": "IxVM::canon_indc_positions", + "name": "IxVM::canon_indc_positions", + "rows": 0 + }, + { + "chip": "IxVM::canon_sort_loop", + "name": "IxVM::canon_sort_loop", + "rows": 0 + }, + { + "chip": "IxVM::canon_build_ctx_classes", + "name": "IxVM::canon_build_ctx_classes", + "rows": 0 + }, + { + "chip": "IxVM::canon_build_ctx_members", + "name": "IxVM::canon_build_ctx_members", + "rows": 0 + }, + { + "chip": "IxVM::canon_member_num_ctors", + "name": "IxVM::canon_member_num_ctors", + "rows": 0 + }, + { + "chip": "IxVM::canon_member_ci", + "name": "IxVM::canon_member_ci", + "rows": 0 + }, + { + "chip": "IxVM::canon_ctor_ctx_entries", + "name": "IxVM::canon_ctor_ctx_entries", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_concat\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\"]}}]}", + "name": "${\"name\":\"IxVM::list_concat\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\"]}}]}", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[\"field\"],\"name\":\"Lists::Node\"}}}}]}", + "rows": 0 + }, + { + "chip": "IxVM::canon_refine_classes", + "name": "IxVM::canon_refine_classes", + "rows": 0 + }, + { + "chip": "IxVM::canon_refine_one", + "name": "IxVM::canon_refine_one", + "rows": 0 + }, + { + "chip": "IxVM::canon_ins_sort", + "name": "IxVM::canon_ins_sort", + "rows": 0 + }, + { + "chip": "IxVM::canon_insert_sorted", + "name": "IxVM::canon_insert_sorted", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_member_ctx", + "name": "IxVM::canon_cmp_member_ctx", + "rows": 0 + }, + { + "chip": "IxVM::canon_ord_cmp_g", + "name": "IxVM::canon_ord_cmp_g", + "rows": 248 + }, + { + "chip": "IxVM::canon_kind_ord", + "name": "IxVM::canon_kind_ord", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_member_same_kind_ctx", + "name": "IxVM::canon_cmp_member_same_kind_ctx", + "rows": 0 + }, + { + "chip": "IxVM::canon_sord_then", + "name": "IxVM::canon_sord_then", + "rows": 0 + }, + { + "chip": "IxVM::canon_sord_of_g", + "name": "IxVM::canon_sord_of_g", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_kexpr_ctx", + "name": "IxVM::canon_cmp_kexpr_ctx", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_kexpr_node_ctx", + "name": "IxVM::canon_cmp_kexpr_node_ctx", + "rows": 0 + }, + { + "chip": "IxVM::canon_sord_lt_strong", + "name": "IxVM::canon_sord_lt_strong", + "rows": 0 + }, + { + "chip": "IxVM::canon_sord_gt_strong", + "name": "IxVM::canon_sord_gt_strong", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_kuniv", + "name": "IxVM::canon_cmp_kuniv", + "rows": 0 + }, + { + "chip": "IxVM::canon_ord_then", + "name": "IxVM::canon_ord_then", + "rows": 5 + }, + { + "chip": "IxVM::canon_cmp_kuniv_list", + "name": "IxVM::canon_cmp_kuniv_list", + "rows": 0 + }, + { + "chip": "IxVM::canon_ctx_cmp_addr", + "name": "IxVM::canon_ctx_cmp_addr", + "rows": 0 + }, + { + "chip": "IxVM::canon_sord_eq_strong", + "name": "IxVM::canon_sord_eq_strong", + "rows": 0 + }, + { + "chip": "IxVM::canon_ctx_class_idx", + "name": "IxVM::canon_ctx_class_idx", + "rows": 0 + }, + { + "chip": "IxVM::canon_addr_cmp", + "name": "IxVM::canon_addr_cmp", + "rows": 31 + }, + { + "chip": "IxVM::canon_addr_chunk", + "name": "IxVM::canon_addr_chunk", + "rows": 248 + }, + { + "chip": "IxVM::canon_cmp_kliteral", + "name": "IxVM::canon_cmp_kliteral", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_klimbs", + "name": "IxVM::canon_cmp_klimbs", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "name": "${\"name\":\"IxVM::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_klimbs_tail", + "name": "IxVM::canon_cmp_klimbs_tail", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_u64_lex", + "name": "IxVM::canon_cmp_u64_lex", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_bytes", + "name": "IxVM::canon_cmp_bytes", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_ctor_range_ctx", + "name": "IxVM::canon_cmp_ctor_range_ctx", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_ctor_pair_ctx", + "name": "IxVM::canon_cmp_ctor_pair_ctx", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_krec_rule_list_ctx", + "name": "IxVM::canon_cmp_krec_rule_list_ctx", + "rows": 0 + }, + { + "chip": "IxVM::canon_cmp_krec_rule_ctx", + "name": "IxVM::canon_cmp_krec_rule_ctx", + "rows": 0 + }, + { + "chip": "IxVM::canon_group_consec", + "name": "IxVM::canon_group_consec", + "rows": 0 + }, + { + "chip": "IxVM::canon_group_walk", + "name": "IxVM::canon_group_walk", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_snoc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_snoc\",\"types\":[\"field\"]}", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[\"field\"],\"name\":\"Lists::Node\"}}}}]}", + "rows": 0 + }, + { + "chip": "IxVM::canon_classes_eq", + "name": "IxVM::canon_classes_eq", + "rows": 0 + }, + { + "chip": "IxVM::bytestream_eq", + "name": "IxVM::canon_g_list_eq", + "rows": 0 + }, + { + "chip": "IxVM::canon_all_singleton", + "name": "IxVM::canon_all_singleton", + "rows": 0 + }, + { + "chip": "IxVM::canon_flatten", + "name": "IxVM::canon_flatten", + "rows": 0 + }, + { + "chip": "IxVM::check_inductive_shape", + "name": "IxVM::check_inductive_shape", + "rows": 0 + }, + { + "chip": "IxVM::get_result_sort_level", + "name": "IxVM::get_result_sort_level", + "rows": 0 + }, + { + "chip": "IxVM::check_inductive_shape_ctors", + "name": "IxVM::check_inductive_shape_ctors", + "rows": 0 + }, + { + "chip": "IxVM::check_param_agreement", + "name": "IxVM::check_param_agreement", + "rows": 0 + }, + { + "chip": "IxVM::check_param_agreement_go", + "name": "IxVM::check_param_agreement_go", + "rows": 0 + }, + { + "chip": "IxVM::check_ctor_return_type", + "name": "IxVM::check_ctor_return_type", + "rows": 0 + }, + { + "chip": "IxVM::assert_return_head_is_parent", + "name": "IxVM::assert_return_head_is_parent", + "rows": 0 + }, + { + "chip": "IxVM::assert_lvls_are_params", + "name": "IxVM::assert_lvls_are_params", + "rows": 0 + }, + { + "chip": "IxVM::assert_first_args_are_param_bvars", + "name": "IxVM::assert_first_args_are_param_bvars", + "rows": 0 + }, + { + "chip": "IxVM::list_any_mentions_block", + "name": "IxVM::list_any_mentions_block", + "rows": 0 + }, + { + "chip": "IxVM::expr_mentions_block", + "name": "IxVM::expr_mentions_block", + "rows": 0 + }, + { + "chip": "IxVM::caddr_is_peer", + "name": "IxVM::caddr_is_peer", + "rows": 0 + }, + { + "chip": "IxVM::addr_list_contains", + "name": "IxVM::addr_list_contains", + "rows": 0 + }, + { + "chip": "IxVM::check_field_universes", + "name": "IxVM::check_field_universes", + "rows": 0 + }, + { + "chip": "IxVM::check_field_universes_skip_params", + "name": "IxVM::check_field_universes_skip_params", + "rows": 0 + }, + { + "chip": "IxVM::check_field_universes_inner", + "name": "IxVM::check_field_universes_inner", + "rows": 0 + }, + { + "chip": "IxVM::level_leq", + "name": "IxVM::level_leq", + "rows": 0 + }, + { + "chip": "IxVM::nl_le", + "name": "IxVM::nl_le", + "rows": 0 + }, + { + "chip": "IxVM::nl_covers_const", + "name": "IxVM::nl_covers_const", + "rows": 0 + }, + { + "chip": "IxVM::nlvars_any_offset_geq", + "name": "IxVM::nlvars_any_offset_geq", + "rows": 0 + }, + { + "chip": "IxVM::nl_le_vars", + "name": "IxVM::nl_le_vars", + "rows": 0 + }, + { + "chip": "IxVM::nl_covers_var", + "name": "IxVM::nl_covers_var", + "rows": 0 + }, + { + "chip": "IxVM::nlvars_dominates", + "name": "IxVM::nlvars_dominates", + "rows": 0 + }, + { + "chip": "IxVM::check_positivity", + "name": "IxVM::check_positivity", + "rows": 0 + }, + { + "chip": "IxVM::peel_n_foralls_with_types", + "name": "IxVM::peel_n_foralls_with_types", + "rows": 0 + }, + { + "chip": "IxVM::check_positivity_fields", + "name": "IxVM::check_positivity_fields", + "rows": 0 + }, + { + "chip": "IxVM::check_positivity_aug", + "name": "IxVM::check_positivity_aug", + "rows": 0 + }, + { + "chip": "IxVM::check_valid_ind_app", + "name": "IxVM::check_valid_ind_app", + "rows": 0 + }, + { + "chip": "IxVM::assert_occ_param_bvars", + "name": "IxVM::assert_occ_param_bvars", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_reverse\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_reverse\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_reverse_acc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_reverse_acc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "rows": 0 + }, + { + "chip": "IxVM::check_nested_ctors_positivity", + "name": "IxVM::check_nested_ctors_positivity", + "rows": 0 + }, + { + "chip": "IxVM::check_block_peer_param_agreement", + "name": "IxVM::check_block_peer_param_agreement", + "rows": 0 + }, + { + "chip": "IxVM::peer_agree_walk", + "name": "IxVM::peer_agree_walk", + "rows": 0 + }, + { + "chip": "IxVM::check_recursor_member", + "name": "IxVM::check_recursor_member", + "rows": 0 + }, + { + "chip": "IxVM::is_muts_block", + "name": "IxVM::is_muts_block", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::KRecRule\"}}]}", + "name": "${\"name\":\"IxVM::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::KRecRule\"}}]}", + "rows": 0 + }, + { + "chip": "IxVM::check_rec_rules_wellscoped", + "name": "IxVM::check_rec_rules_wellscoped", + "rows": 0 + }, + { + "chip": "IxVM::check_rec_major_spine", + "name": "IxVM::check_rec_major_spine", + "rows": 0 + }, + { + "chip": "IxVM::compute_k_target", + "name": "IxVM::compute_k_target", + "rows": 0 + }, + { + "chip": "IxVM::ind_is_solo", + "name": "IxVM::ind_is_solo", + "rows": 0 + }, + { + "chip": "IxVM::muts_indc_count_is_one", + "name": "IxVM::muts_indc_count_is_one", + "rows": 0 + }, + { + "chip": "IxVM::check_parent_inductive_shape", + "name": "IxVM::check_parent_inductive_shape", + "rows": 0 + }, + { + "chip": "IxVM::check_recursor_canonical_full", + "name": "IxVM::check_recursor_canonical_full", + "rows": 0 + }, + { + "chip": "IxVM::is_large_eliminator", + "name": "IxVM::is_large_eliminator", + "rows": 0 + }, + { + "chip": "IxVM::check_large_prop_ctor", + "name": "IxVM::check_large_prop_ctor", + "rows": 0 + }, + { + "chip": "IxVM::check_large_walk_fields", + "name": "IxVM::check_large_walk_fields", + "rows": 0 + }, + { + "chip": "IxVM::all_bvars_in_args", + "name": "IxVM::all_bvars_in_args", + "rows": 0 + }, + { + "chip": "IxVM::args_contain_bvar", + "name": "IxVM::args_contain_bvar", + "rows": 0 + }, + { + "chip": "IxVM::build_rec_lvls_list", + "name": "IxVM::build_rec_lvls_list", + "rows": 0 + }, + { + "chip": "IxVM::build_flat_block", + "name": "IxVM::build_flat_block", + "rows": 0 + }, + { + "chip": "IxVM::first_recr_parent_block", + "name": "IxVM::first_recr_parent_block", + "rows": 0 + }, + { + "chip": "IxVM::flat_originals_walk", + "name": "IxVM::flat_originals_walk", + "rows": 0 + }, + { + "chip": "IxVM::build_param_lvls_range", + "name": "IxVM::build_param_lvls_range", + "rows": 0 + }, + { + "chip": "IxVM::detect_aux_from_recrs_ex", + "name": "IxVM::detect_aux_from_recrs_ex", + "rows": 0 + }, + { + "chip": "IxVM::aux_from_recrs_walk_ex", + "name": "IxVM::aux_from_recrs_walk_ex", + "rows": 0 + }, + { + "chip": "IxVM::extract_aux_spec_params_from_rec", + "name": "IxVM::extract_aux_spec_params_from_rec", + "rows": 0 + }, + { + "chip": "IxVM::extract_aux_spec_params", + "name": "IxVM::extract_aux_spec_params", + "rows": 0 + }, + { + "chip": "IxVM::spec_params_lower", + "name": "IxVM::spec_params_lower", + "rows": 0 + }, + { + "chip": "IxVM::extract_aux_occ_us", + "name": "IxVM::extract_aux_occ_us", + "rows": 0 + }, + { + "chip": "IxVM::aux_already_in", + "name": "IxVM::aux_already_in", + "rows": 0 + }, + { + "chip": "IxVM::spec_params_ptr_eq", + "name": "IxVM::spec_params_ptr_eq", + "rows": 0 + }, + { + "chip": "IxVM::kexpr_struct_eq", + "name": "IxVM::kexpr_struct_eq", + "rows": 0 + }, + { + "chip": "IxVM::level_list_struct_eq", + "name": "IxVM::level_list_struct_eq", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_snoc\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}", + "name": "${\"name\":\"IxVM::list_snoc\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}", + "rows": 0 + }, + { + "chip": "IxVM::build_peer_recs", + "name": "IxVM::build_peer_recs", + "rows": 0 + }, + { + "chip": "IxVM::find_peer_recursor_with_spec", + "name": "IxVM::find_peer_recursor_with_spec", + "rows": 0 + }, + { + "chip": "IxVM::find_peer_rec_spec_walk", + "name": "IxVM::find_peer_rec_spec_walk", + "rows": 0 + }, + { + "chip": "IxVM::build_flat_own_params", + "name": "IxVM::build_flat_own_params", + "rows": 0 + }, + { + "chip": "IxVM::flat_find_pos_kind", + "name": "IxVM::flat_find_pos_kind", + "rows": 0 + }, + { + "chip": "IxVM::canonical_rules_at_pos", + "name": "IxVM::canonical_rules_at_pos", + "rows": 0 + }, + { + "chip": "IxVM::flat_member_at", + "name": "IxVM::flat_member_at", + "rows": 0 + }, + { + "chip": "IxVM::build_rec_type", + "name": "IxVM::build_rec_type", + "rows": 0 + }, + { + "chip": "IxVM::build_rec_type_from", + "name": "IxVM::build_rec_type_from", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_length\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}", + "name": "${\"name\":\"IxVM::list_length\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}", + "rows": 0 + }, + { + "chip": "IxVM::collect_n_doms_whnf", + "name": "IxVM::collect_n_doms_whnf", + "rows": 0 + }, + { + "chip": "IxVM::build_all_motives", + "name": "IxVM::build_all_motives", + "rows": 0 + }, + { + "chip": "IxVM::build_all_motives_walk", + "name": "IxVM::build_all_motives_walk", + "rows": 0 + }, + { + "chip": "IxVM::build_motive_type_flat", + "name": "IxVM::build_motive_type_flat", + "rows": 0 + }, + { + "chip": "IxVM::peel_motive_params_subst", + "name": "IxVM::peel_motive_params_subst", + "rows": 0 + }, + { + "chip": "IxVM::subst_param_for", + "name": "IxVM::subst_param_for", + "rows": 0 + }, + { + "chip": "IxVM::collect_index_doms", + "name": "IxVM::collect_index_doms", + "rows": 0 + }, + { + "chip": "IxVM::build_major_params", + "name": "IxVM::build_major_params", + "rows": 0 + }, + { + "chip": "IxVM::apply_spec_params_lifted", + "name": "IxVM::apply_spec_params_lifted", + "rows": 0 + }, + { + "chip": "IxVM::build_major_indices", + "name": "IxVM::build_major_indices", + "rows": 0 + }, + { + "chip": "IxVM::wrap_foralls", + "name": "IxVM::wrap_foralls", + "rows": 0 + }, + { + "chip": "IxVM::build_all_minors", + "name": "IxVM::build_all_minors", + "rows": 0 + }, + { + "chip": "IxVM::build_all_minors_walk", + "name": "IxVM::build_all_minors_walk", + "rows": 0 + }, + { + "chip": "IxVM::build_minor_doms", + "name": "IxVM::build_minor_doms", + "rows": 0 + }, + { + "chip": "IxVM::projection_addr_ctor", + "name": "IxVM::projection_addr_ctor", + "rows": 0 + }, + { + "chip": "IxVM::build_minor_at_depth", + "name": "IxVM::build_minor_at_depth", + "rows": 0 + }, + { + "chip": "IxVM::peel_ctor_params_subst", + "name": "IxVM::peel_ctor_params_subst", + "rows": 0 + }, + { + "chip": "IxVM::ctor_subst_param_for", + "name": "IxVM::ctor_subst_param_for", + "rows": 0 + }, + { + "chip": "IxVM::walk_fields_classify", + "name": "IxVM::walk_fields_classify", + "rows": 0 + }, + { + "chip": "IxVM::is_rec_field", + "name": "IxVM::is_rec_field", + "rows": 0 + }, + { + "chip": "IxVM::is_rec_field_peel", + "name": "IxVM::is_rec_field_peel", + "rows": 0 + }, + { + "chip": "IxVM::flat_find_matching", + "name": "IxVM::flat_find_matching", + "rows": 0 + }, + { + "chip": "IxVM::spec_params_dom_prefix_match", + "name": "IxVM::spec_params_dom_prefix_match", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_reverse\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_reverse\",\"types\":[\"field\"]}", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_reverse_acc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_reverse_acc\",\"types\":[\"field\"]}", + "rows": 0 + }, + { + "chip": "IxVM::list_lift_each", + "name": "IxVM::list_lift_each", + "rows": 0 + }, + { + "chip": "IxVM::apply_spine", + "name": "IxVM::apply_spine_expr", + "rows": 0 + }, + { + "chip": "IxVM::build_ctor_app_params", + "name": "IxVM::build_ctor_app_params", + "rows": 0 + }, + { + "chip": "IxVM::build_apply_bvars_decreasing", + "name": "IxVM::build_apply_bvars_decreasing", + "rows": 0 + }, + { + "chip": "IxVM::build_apply_field_bvars", + "name": "IxVM::build_apply_field_bvars", + "rows": 0 + }, + { + "chip": "IxVM::build_ih_doms", + "name": "IxVM::build_ih_doms", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_lookup_or_default\",\"types\":[\"field\"]}", + "name": "${\"name\":\"IxVM::list_lookup_or_default\",\"types\":[\"field\"]}", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}", + "name": "${\"name\":\"IxVM::list_drop\",\"types\":[\"field\"]}", + "rows": 0 + }, + { + "chip": "IxVM::peel_leading_foralls", + "name": "IxVM::peel_leading_foralls", + "rows": 0 + }, + { + "chip": "IxVM::peel_leading_foralls_acc", + "name": "IxVM::peel_leading_foralls_acc", + "rows": 0 + }, + { + "chip": "IxVM::build_major_indices", + "name": "IxVM::build_apply_xs", + "rows": 0 + }, + { + "chip": "IxVM::list_lift_indices", + "name": "IxVM::list_lift_indices", + "rows": 0 + }, + { + "chip": "IxVM::apply_indices_in_conclusion", + "name": "IxVM::apply_indices_in_conclusion", + "rows": 0 + }, + { + "chip": "IxVM::ctors_before_pos", + "name": "IxVM::ctors_before_pos", + "rows": 0 + }, + { + "chip": "IxVM::populate_rules", + "name": "IxVM::populate_rules", + "rows": 0 + }, + { + "chip": "IxVM::build_rule_rhs", + "name": "IxVM::build_rule_rhs", + "rows": 0 + }, + { + "chip": "IxVM::count_foralls_body", + "name": "IxVM::count_foralls_body", + "rows": 0 + }, + { + "chip": "IxVM::apply_ihs_full", + "name": "IxVM::apply_ihs_full", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_lookup_or_default\",\"types\":[\"field\"]}", + "name": "${\"name\":\"IxVM::list_lookup_or_default\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}}]}", + "rows": 0 + }, + { + "chip": "IxVM::build_apply_bvars_decreasing", + "name": "IxVM::build_motive_apps", + "rows": 0 + }, + { + "chip": "IxVM::build_apply_bvars_decreasing", + "name": "IxVM::build_minor_apps", + "rows": 0 + }, + { + "chip": "IxVM::wrap_lams", + "name": "IxVM::wrap_lams", + "rows": 0 + }, + { + "chip": "IxVM::compare_rules", + "name": "IxVM::compare_rules", + "rows": 0 + }, + { + "chip": "IxVM::peel_n_lams_collect", + "name": "IxVM::peel_n_lams_collect", + "rows": 0 + }, + { + "chip": "IxVM::flat_find_pos", + "name": "IxVM::flat_find_pos", + "rows": 0 + }, + { + "chip": "IxVM::run_check_transitive", + "name": "IxVM::run_check_transitive", + "rows": 0 + }, + { + "chip": "IxVM::check_muts_all", + "name": "IxVM::check_muts_all", + "rows": 0 + }, + { + "chip": "IxVM::check_muts_member_at", + "name": "IxVM::check_muts_member_at", + "rows": 0 + }, + { + "chip": "IxVM::walk_refs_transitive", + "name": "IxVM::walk_refs_transitive", + "rows": 0 + }, + { + "chip": "IxVM::g_list_has", + "name": "IxVM::g_list_has", + "rows": 28 + }, + { + "chip": "IxVM::const_idxs_of", + "name": "IxVM::const_idxs_of", + "rows": 1 + }, + { + "chip": "IxVM::const_idxs_exprs", + "name": "IxVM::const_idxs_exprs", + "rows": 6 + }, + { + "chip": "IxVM::const_idxs_expr", + "name": "IxVM::const_idxs_expr", + "rows": 39 + }, + { + "chip": "IxVM::const_idxs_rules", + "name": "IxVM::const_idxs_rules", + "rows": 0 + }, + { + "chip": "IxVM::const_idxs_muts", + "name": "IxVM::const_idxs_muts", + "rows": 0 + }, + { + "chip": "IxVM::const_idxs_ctors", + "name": "IxVM::const_idxs_ctors", + "rows": 0 + }, + { + "chip": "IxVM::addr_set_build", + "name": "IxVM::addr_set_build", + "rows": 10 + }, + { + "chip": "${\"name\":\"IxVM::rbtree_map_insert\",\"types\":[\"field\"]}", + "name": "${\"name\":\"IxVM::rbtree_map_insert\",\"types\":[\"field\"]}", + "rows": 8 + }, + { + "chip": "${\"name\":\"IxVM::rbtree_map_ins\",\"types\":[\"field\"]}", + "name": "${\"name\":\"IxVM::rbtree_map_ins\",\"types\":[\"field\"]}", + "rows": 23 + }, + { + "chip": "${\"name\":\"IxVM::rbtree_map_balance\",\"types\":[\"field\"]}", + "name": "${\"name\":\"IxVM::rbtree_map_balance\",\"types\":[\"field\"]}", + "rows": 15 + }, + { + "chip": "${\"name\":\"IxVM::rbtree_map_balance_fix\",\"types\":[\"field\"]}", + "name": "${\"name\":\"IxVM::rbtree_map_balance_fix\",\"types\":[\"field\"]}", + "rows": 10 + }, + { + "chip": "IxVM::load_assumption_tree", + "name": "IxVM::load_assumption_tree", + "rows": 2 + }, + { + "chip": "IxVM::parse_atree_body", + "name": "IxVM::parse_atree_body", + "rows": 16 + }, + { + "chip": "IxVM::leaf_hash", + "name": "IxVM::leaf_hash", + "rows": 8 + }, + { + "chip": "IxVM::node_hash", + "name": "IxVM::node_hash", + "rows": 7 + }, + { + "chip": "${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "name": "${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}}]}", + "rows": 19 + }, + { + "chip": "IxVM::addr_set_member", + "name": "IxVM::addr_set_member", + "rows": 9 + }, + { + "chip": "${\"name\":\"IxVM::rbtree_map_lookup_or_default\",\"types\":[\"field\"]}", + "name": "${\"name\":\"IxVM::rbtree_map_lookup_or_default\",\"types\":[\"field\"]}", + "rows": 22 + }, + { + "chip": "IxVM::env_walk", + "name": "IxVM::env_walk", + "rows": 8 + }, + { + "chip": "IxVM::env_walk_refs", + "name": "IxVM::env_walk_refs", + "rows": 8 + }, + { + "chip": "IxVM::eval_body", + "name": "IxVM::eval_body", + "rows": 0 + }, + { + "chip": "IxVM::eval_output", + "name": "IxVM::eval_output", + "rows": 0 + }, + { + "chip": "IxVM::eval_nf", + "name": "IxVM::eval_nf", + "rows": 0 + }, + { + "chip": "IxVM::eval_nf_spine", + "name": "IxVM::eval_nf_spine", + "rows": 0 + }, + { + "chip": "IxVM::run_check_env", + "name": "IxVM::run_check_env", + "rows": 1 + }, + { + "chip": "IxVM::walk_leaves_owned", + "name": "IxVM::walk_leaves_owned", + "rows": 0 + }, + { + "chip": "IxVM::check_owned", + "name": "IxVM::check_owned", + "rows": 0 + }, + { + "chip": "IxVM::env_walk_all", + "name": "IxVM::env_walk_all", + "rows": 0 + }, + { + "chip": "IxVM::env_walk_refs_all", + "name": "IxVM::env_walk_refs_all", + "rows": 0 + }, + { + "chip": "IxVM::env_walk_leaves", + "name": "IxVM::env_walk_leaves", + "rows": 2 + }, + { + "chip": "IxVM::get_reveal_info", + "name": "IxVM::get_reveal_info", + "rows": 0 + }, + { + "chip": "IxVM::get_opt_def_kind_masked", + "name": "IxVM::get_opt_def_kind_masked", + "rows": 0 + }, + { + "chip": "IxVM::get_opt_def_kind_masked", + "name": "IxVM::get_opt_def_safety_masked", + "rows": 0 + }, + { + "chip": "IxVM::get_opt_u64_masked", + "name": "IxVM::get_opt_u64_masked", + "rows": 0 + }, + { + "chip": "IxVM::get_opt_addr_masked", + "name": "IxVM::get_opt_addr_masked", + "rows": 0 + }, + { + "chip": "IxVM::get_opt_bool_masked", + "name": "IxVM::get_opt_bool_masked", + "rows": 0 + }, + { + "chip": "IxVM::get_opt_rule_list_masked", + "name": "IxVM::get_opt_rule_list_masked", + "rows": 0 + }, + { + "chip": "IxVM::get_reveal_rule_list_inner", + "name": "IxVM::get_reveal_rule_list_inner", + "rows": 0 + }, + { + "chip": "IxVM::get_constructor_proj", + "name": "IxVM::get_reveal_rule", + "rows": 0 + }, + { + "chip": "IxVM::get_opt_quot_kind_masked", + "name": "IxVM::get_opt_quot_kind_masked", + "rows": 0 + }, + { + "chip": "IxVM::get_mut_entry_list_inner", + "name": "IxVM::get_mut_entry_list_inner", + "rows": 0 + }, + { + "chip": "IxVM::get_mut_entry", + "name": "IxVM::get_mut_entry", + "rows": 0 + }, + { + "chip": "IxVM::get_reveal_mut_const_info", + "name": "IxVM::get_reveal_mut_const_info", + "rows": 0 + }, + { + "chip": "IxVM::get_opt_ctor_entry_list_masked", + "name": "IxVM::get_opt_ctor_entry_list_masked", + "rows": 0 + }, + { + "chip": "IxVM::get_ctor_entry_list_inner", + "name": "IxVM::get_ctor_entry_list_inner", + "rows": 0 + }, + { + "chip": "IxVM::get_ctor_entry", + "name": "IxVM::get_ctor_entry", + "rows": 0 + }, + { + "chip": "IxVM::get_reveal_ctor_info", + "name": "IxVM::get_reveal_ctor_info", + "rows": 0 + }, + { + "chip": "IxVM::run_reveal", + "name": "IxVM::run_reveal", + "rows": 0 + }, + { + "chip": "IxVM::check_opt_def_kind", + "name": "IxVM::check_opt_def_kind", + "rows": 0 + }, + { + "chip": "IxVM::def_kind_tag", + "name": "IxVM::def_kind_tag", + "rows": 0 + }, + { + "chip": "IxVM::check_opt_def_kind", + "name": "IxVM::check_opt_def_safety", + "rows": 0 + }, + { + "chip": "IxVM::def_kind_tag", + "name": "IxVM::def_safety_tag", + "rows": 0 + }, + { + "chip": "IxVM::check_opt_u64", + "name": "IxVM::check_opt_u64", + "rows": 0 + }, + { + "chip": "IxVM::check_opt_expr_addr", + "name": "IxVM::check_opt_expr_addr", + "rows": 0 + }, + { + "chip": "IxVM::expr_addr", + "name": "IxVM::expr_addr", + "rows": 0 + }, + { + "chip": "IxVM::check_opt_bool", + "name": "IxVM::check_opt_bool", + "rows": 0 + }, + { + "chip": "IxVM::check_opt_recr_rules", + "name": "IxVM::check_opt_recr_rules", + "rows": 0 + }, + { + "chip": "IxVM::check_recr_rules", + "name": "IxVM::check_recr_rules", + "rows": 0 + }, + { + "chip": "IxVM::check_opt_quot_kind", + "name": "IxVM::check_opt_quot_kind", + "rows": 0 + }, + { + "chip": "IxVM::get_quot_kind", + "name": "IxVM::quot_kind_tag", + "rows": 0 + }, + { + "chip": "IxVM::check_opt_addr", + "name": "IxVM::check_opt_addr", + "rows": 0 + }, + { + "chip": "IxVM::check_muts_components", + "name": "IxVM::check_muts_components", + "rows": 0 + }, + { + "chip": "IxVM::check_mut_const", + "name": "IxVM::check_mut_const", + "rows": 0 + }, + { + "chip": "IxVM::check_opt_ctor_entries", + "name": "IxVM::check_opt_ctor_entries", + "rows": 0 + }, + { + "chip": "IxVM::check_ctor_entries", + "name": "IxVM::check_ctor_entries", + "rows": 0 + }, + { + "chip": "IxVM::check_ctor_entry", + "name": "IxVM::check_ctor_entry", + "rows": 0 + }, + { + "chip": "${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}", + "name": "${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}", + "rows": 0 + }, + { + "chip": "IxVM::run_contains", + "name": "IxVM::run_contains", + "rows": 0 + } + ], + "prepare_seconds": 0.136467526, + "proof": null, + "samples": [], + "setup_seconds": 0.310558312, + "thp_disabled": true +} \ No newline at end of file diff --git a/docs/benchmarks/formal-aiur-grouping-tuning/ixvm-metrics.json b/docs/benchmarks/formal-aiur-grouping-tuning/ixvm-metrics.json new file mode 100644 index 000000000..8352d6857 --- /dev/null +++ b/docs/benchmarks/formal-aiur-grouping-tuning/ixvm-metrics.json @@ -0,0 +1 @@ +{"chips":[{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::verify_claim","private":1,"private_columns":[8],"shared":8,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::run_claim","private":6,"private_columns":[8,9,10,11,12,126],"shared":121,"width":127},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::read_finite_byte_stream","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::read_byte_stream","private":2,"private_columns":[4,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_depth_checked\",\"types\":[\"field\"]}","private":2,"private_columns":[2,7],"shared":6,"width":8},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::checked_depth_succ","private":1,"private_columns":[2],"shared":2,"width":3},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"UInt32::less_than_fields","private":1,"private_columns":[12],"shared":12,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"Blake3::compress_layer","private":3,"private_columns":[33,34,138],"shared":136,"width":139},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"Blake3::next_layer","private":37,"private_columns":[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,34,35,36,175],"shared":139,"width":176},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"Blake3::compress","private":2,"private_columns":[161,499],"shared":498,"width":500},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"Blake3::compress_chunks","private":3,"private_columns":[8,9,15],"shared":13,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"Blake3::finish","private":6,"private_columns":[2,7,8,9,10,164],"shared":159,"width":165},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"UInt64::is_zero","private":2,"private_columns":[8,17],"shared":16,"width":18},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"Blake3::bytes_to_block","private":1,"private_columns":[129],"shared":129,"width":130},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"Blake3::pad_block","private":2,"private_columns":[3,6],"shared":5,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"Blake3::compress_block","private":5,"private_columns":[7,8,73,177,178],"shared":174,"width":179},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"UInt64::wrapping_succ","private":18,"private_columns":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18],"shared":1,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_tagn4","private":8,"private_columns":[1,3,8,9,10,11,12,21],"shared":14,"width":22},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_tagn_tail","private":2,"private_columns":[12,20],"shared":19,"width":21},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_tagn_wide","private":13,"private_columns":[3,4,5,16,17,18,19,20,21,22,23,24,26],"shared":14,"width":27},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::get_u64_le","private":3,"private_columns":[0,2,15],"shared":13,"width":16},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"UInt64::add","private":1,"private_columns":[24],"shared":24,"width":25},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::read_byte","private":1,"private_columns":[3],"shared":3,"width":4},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_address","private":1,"private_columns":[66],"shared":66,"width":67},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::get_opt_addr","private":3,"private_columns":[1,3,6],"shared":4,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::run_eval","private":2,"private_columns":[4,20],"shared":19,"width":21},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::run_check","private":1,"private_columns":[14],"shared":14,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_ci","private":9,"private_columns":[2,3,4,5,6,7,8,9,75],"shared":67,"width":76},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::load_verified_constant","private":1,"private_columns":[87],"shared":87,"width":88},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"Blake3::verify_bytes_against","private":1,"private_columns":[70],"shared":70,"width":71},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_constant","private":2,"private_columns":[1,93],"shared":92,"width":94},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_mut_const_list","private":4,"private_columns":[0,9,11,68],"shared":65,"width":69},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_mut_const","private":16,"private_columns":[1,2,5,6,7,8,9,10,11,12,13,14,15,16,17,50],"shared":35,"width":51},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_definition","private":1,"private_columns":[18],"shared":18,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"IxVM::unpack_def_kind_safety","private":1,"private_columns":[9],"shared":9,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_tagn0","private":2,"private_columns":[10,15],"shared":14,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_expr","private":17,"private_columns":[4,5,6,9,10,11,13,15,16,17,18,19,20,21,22,24,46],"shared":30,"width":47},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_u64_list","private":4,"private_columns":[0,9,11,31],"shared":28,"width":32},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"UInt64::saturating_pred","private":18,"private_columns":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,17,18],"shared":1,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_app_telescope","private":2,"private_columns":[12,25],"shared":24,"width":26},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_lam_telescope","private":4,"private_columns":[9,26,27,32],"shared":29,"width":33},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_lam_mode","private":1,"private_columns":[14],"shared":14,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::binder_contract_from_bits","private":1,"private_columns":[13],"shared":13,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"IxVM::value_contract_from_bits","private":1,"private_columns":[6],"shared":6,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_all_telescope","private":4,"private_columns":[9,28,29,32],"shared":29,"width":33},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_all_mode","private":1,"private_columns":[16],"shared":16,"width":17},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_expr_let","private":1,"private_columns":[32],"shared":32,"width":33},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_inductive","private":1,"private_columns":[51],"shared":51,"width":52},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::assert_wire_bool","private":1,"private_columns":[3],"shared":3,"width":4},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_constructor_list","private":4,"private_columns":[0,9,11,57],"shared":54,"width":58},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_constructor","private":1,"private_columns":[41],"shared":41,"width":42},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_recursor","private":1,"private_columns":[71],"shared":71,"width":72},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_recursor_rule_list","private":4,"private_columns":[0,9,11,33],"shared":30,"width":34},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_constant_info_by_variant","private":21,"private_columns":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,54],"shared":34,"width":55},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_axiom","private":1,"private_columns":[14],"shared":14,"width":15},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_quotient","private":1,"private_columns":[15],"shared":15,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"IxVM::get_quot_kind","private":1,"private_columns":[4],"shared":4,"width":5},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_constructor_proj","private":1,"private_columns":[21],"shared":21,"width":22},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::get_recursor_proj","private":1,"private_columns":[12],"shared":12,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_expr_list","private":4,"private_columns":[0,9,11,24],"shared":21,"width":25},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_address_list","private":4,"private_columns":[0,9,11,24],"shared":21,"width":25},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_univ_list","private":4,"private_columns":[0,9,11,33],"shared":30,"width":34},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_univ","private":8,"private_columns":[1,2,3,4,34,35,36,37],"shared":30,"width":38},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_tagn2","private":6,"private_columns":[1,3,10,11,12,21],"shared":16,"width":22},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_succ_chain","private":11,"private_columns":[0,1,2,3,4,5,6,7,8,17,37],"shared":27,"width":38},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::load_constant_hint","private":1,"private_columns":[34],"shared":34,"width":35},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"IxVM::defn_is_unsafe_ci","private":4,"private_columns":[3,5,6,7],"shared":4,"width":8},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::convert_definition","private":9,"private_columns":[1,16,17,18,19,20,21,22,25],"shared":17,"width":26},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::convert_expr","private":12,"private_columns":[6,7,8,9,10,11,12,13,14,15,16,39],"shared":28,"width":40},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}","private":3,"private_columns":[0,2,7],"shared":5,"width":8},{"constraint_degree":2,"lifted":0,"lookups":[[2,1]],"name":"UInt64::to_field","private":1,"private_columns":[8],"shared":8,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::convert_univ","private":5,"private_columns":[2,3,4,5,17],"shared":13,"width":18},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::convert_univ_idxs","private":2,"private_columns":[3,18],"shared":17,"width":19},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::load_verified_blob","private":1,"private_columns":[36],"shared":36,"width":37},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::utf8_validate","private":2,"private_columns":[1,7],"shared":6,"width":8},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::utf8_decode_one","private":6,"private_columns":[0,1,2,3,4,29],"shared":24,"width":30},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::utf8_cont","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::bytes_to_limbs","private":5,"private_columns":[2,3,4,29,31],"shared":27,"width":32},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::bytes_to_u64_limb","private":11,"private_columns":[18,19,20,21,22,23,24,25,26,27,38],"shared":28,"width":39},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::skip_bytes","private":3,"private_columns":[3,4,9],"shared":7,"width":10},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::convert_axiom","private":1,"private_columns":[16],"shared":16,"width":17},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::convert_quotient","private":1,"private_columns":[16],"shared":16,"width":17},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_ci_dprj","private":1,"private_columns":[118],"shared":118,"width":119},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}","private":2,"private_columns":[54,110],"shared":109,"width":111},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::defn_member_recur_addrs","private":2,"private_columns":[15,18],"shared":17,"width":19},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::build_recur_addrs","private":1,"private_columns":[3],"shared":3,"width":4},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_recur_addrs_walk","private":2,"private_columns":[5,55],"shared":54,"width":56},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::projection_addr","private":1,"private_columns":[109],"shared":109,"width":110},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::muts_member_at","private":2,"private_columns":[47,95],"shared":94,"width":96},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"UInt64::from_field","private":1,"private_columns":[10],"shared":10,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_constant","private":9,"private_columns":[50,51,52,53,54,55,56,57,70],"shared":62,"width":71},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_sharing","private":1,"private_columns":[12],"shared":12,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Expr\"}}}}]}","private":2,"private_columns":[9,21],"shared":20,"width":22},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_tagn0","private":4,"private_columns":[10,11,12,14],"shared":11,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_tagn_tail","private":2,"private_columns":[12,28],"shared":27,"width":29},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_tagn_wide","private":17,"private_columns":[0,2,3,4,5,6,7,8,9,10,11,13,15,17,18,19,28],"shared":12,"width":29},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::put_u64_le","private":2,"private_columns":[11,14],"shared":13,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_expr_list","private":2,"private_columns":[3,27],"shared":26,"width":28},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_expr","private":14,"private_columns":[0,20,21,22,23,24,25,26,27,28,29,30,31,102],"shared":89,"width":103},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_tagn4","private":4,"private_columns":[11,12,13,16],"shared":13,"width":17},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}","private":2,"private_columns":[9,28],"shared":27,"width":29},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_u64_list","private":2,"private_columns":[3,15],"shared":14,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::app_telescope_count","private":2,"private_columns":[26,53],"shared":52,"width":54},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_app_telescope","private":2,"private_columns":[20,58],"shared":57,"width":59},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::lam_telescope_count","private":2,"private_columns":[26,53],"shared":52,"width":54},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_lam_telescope","private":2,"private_columns":[20,59],"shared":58,"width":60},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_lam_mode","private":1,"private_columns":[7],"shared":7,"width":8},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::binder_contract_code","private":1,"private_columns":[8],"shared":8,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"IxVM::value_contract_code","private":1,"private_columns":[6],"shared":6,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::all_telescope_count","private":2,"private_columns":[26,53],"shared":52,"width":54},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_all_telescope","private":2,"private_columns":[20,59],"shared":58,"width":60},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_all_mode","private":1,"private_columns":[10],"shared":10,"width":11},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_refs","private":1,"private_columns":[12],"shared":12,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_address_list","private":2,"private_columns":[3,8],"shared":7,"width":9},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_address","private":1,"private_columns":[66],"shared":66,"width":67},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_univs","private":1,"private_columns":[12],"shared":12,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_univ_list","private":2,"private_columns":[3,18],"shared":17,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_univ","private":5,"private_columns":[11,12,13,14,38],"shared":34,"width":39},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::univ_succ_count","private":2,"private_columns":[17,35],"shared":34,"width":36},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::univ_succ_base","private":2,"private_columns":[18,28],"shared":27,"width":29},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_tagn2","private":4,"private_columns":[11,12,13,16],"shared":13,"width":17},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}","private":2,"private_columns":[9,65],"shared":64,"width":66},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_mut_const_list","private":2,"private_columns":[3,52],"shared":51,"width":53},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_mut_const","private":3,"private_columns":[47,48,50],"shared":48,"width":51},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_definition","private":1,"private_columns":[55],"shared":55,"width":56},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"IxVM::pack_def_kind_safety","private":1,"private_columns":[10],"shared":10,"width":11},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_inductive","private":1,"private_columns":[62],"shared":62,"width":63},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}","private":2,"private_columns":[9,54],"shared":53,"width":55},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_constructor_list","private":2,"private_columns":[3,41],"shared":40,"width":42},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_constructor","private":1,"private_columns":[60],"shared":60,"width":61},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_recursor","private":1,"private_columns":[81],"shared":81,"width":82},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::RecursorRule\"}}]}","private":2,"private_columns":[9,29],"shared":28,"width":30},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_recursor_rule_list","private":2,"private_columns":[3,16],"shared":15,"width":17},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_recursor_rule","private":1,"private_columns":[30],"shared":30,"width":31},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_constant_info","private":8,"private_columns":[47,48,49,50,51,52,53,54],"shared":47,"width":55},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_axiom","private":1,"private_columns":[33],"shared":33,"width":34},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_quotient","private":1,"private_columns":[32],"shared":32,"width":33},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::put_quot_kind","private":3,"private_columns":[1,2,6],"shared":4,"width":7},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::put_constructor_proj","private":1,"private_columns":[21],"shared":21,"width":22},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::put_recursor_proj","private":1,"private_columns":[12],"shared":12,"width":13},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"Blake3::bytes_to_addr","private":1,"private_columns":[39],"shared":39,"width":40},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_ci_iprj","private":1,"private_columns":[109],"shared":109,"width":110},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::convert_inductive","private":1,"private_columns":[38],"shared":38,"width":39},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::count_ctors","private":2,"private_columns":[1,39],"shared":38,"width":40},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_ci_cprj","private":1,"private_columns":[144],"shared":144,"width":145},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::ctor_at","private":2,"private_columns":[36,73],"shared":72,"width":74},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::convert_constructor","private":1,"private_columns":[45],"shared":45,"width":46},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_ci_rprj","private":1,"private_columns":[109],"shared":109,"width":110},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::convert_recursor","private":1,"private_columns":[57],"shared":57,"width":58},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::convert_rec_rules","private":2,"private_columns":[7,22],"shared":21,"width":23},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_const","private":9,"private_columns":[13,14,15,16,17,18,19,20,40],"shared":32,"width":41},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"IxVM::is_unsafe_ci","private":7,"private_columns":[3,13,15,16,17,19,21],"shared":15,"width":22},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::validate_expr_well_scoped","private":9,"private_columns":[3,4,5,6,7,8,9,10,30],"shared":22,"width":31},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::validate_univ_params_seen","private":5,"private_columns":[2,3,4,5,10],"shared":6,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"IxVM::const_num_lvls","private":2,"private_columns":[1,19],"shared":18,"width":20},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}","private":2,"private_columns":[1,6],"shared":5,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::validate_univ_params_list","private":2,"private_columns":[2,6],"shared":5,"width":7},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_ensure_sort","private":1,"private_columns":[7],"shared":7,"width":8},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_infer","private":2,"private_columns":[3,6],"shared":5,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_lbr","private":6,"private_columns":[5,6,7,8,9,17],"shared":12,"width":18},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::lbr_max","private":3,"private_columns":[1,2,4],"shared":2,"width":5},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"IxVM::lbr_dec","private":2,"private_columns":[1,3],"shared":2,"width":4},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_lbr_let","private":1,"private_columns":[9],"shared":9,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_infer_core","private":9,"private_columns":[3,4,5,6,7,8,9,10,31],"shared":23,"width":32},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::types_lookup","private":1,"private_columns":[4],"shared":4,"width":5},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_lift","private":3,"private_columns":[4,5,9],"shared":7,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_lift_walk","private":9,"private_columns":[4,5,6,7,8,9,10,11,18],"shared":10,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::expr_lift_bvar","private":2,"private_columns":[4,6],"shared":5,"width":7},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_lift_let","private":1,"private_columns":[9],"shared":9,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::level_reduce","private":5,"private_columns":[2,3,4,5,11],"shared":7,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::level_max","private":5,"private_columns":[3,4,5,8,11],"shared":7,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::level_explicit_val","private":4,"private_columns":[1,2,3,10],"shared":7,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::level_max_go","private":6,"private_columns":[3,4,5,6,7,19],"shared":14,"width":20},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::level_struct_eq","private":12,"private_columns":[3,4,5,6,7,8,9,10,11,12,19,21],"shared":10,"width":22},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::level_max_subsumes","private":4,"private_columns":[3,4,8,9],"shared":6,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::level_max_offsets","private":3,"private_columns":[3,4,11],"shared":9,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::level_offset_of","private":2,"private_columns":[4,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::level_imax","private":6,"private_columns":[3,4,5,6,7,19],"shared":14,"width":20},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::level_is_not_zero","private":4,"private_columns":[4,5,6,14],"shared":11,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"IxVM::const_type_of","private":2,"private_columns":[2,19],"shared":18,"width":20},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::expr_inst_levels","private":2,"private_columns":[3,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_inst_levels_walk","private":9,"private_columns":[3,4,5,6,7,8,9,10,18],"shared":10,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::level_inst_params","private":5,"private_columns":[3,4,5,6,12],"shared":8,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::level_list_inst","private":2,"private_columns":[3,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::collect_spine","private":4,"private_columns":[1,6,8,9],"shared":6,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_snoc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}","private":2,"private_columns":[3,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_infer_app_spine_loop","private":6,"private_columns":[5,6,7,8,9,28],"shared":23,"width":29},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_inst_many","private":4,"private_columns":[4,5,6,13],"shared":10,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::has_bvar_in_range","private":9,"private_columns":[6,7,8,9,10,11,12,13,19],"shared":11,"width":20},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::has_bvar_in_range_binder","private":2,"private_columns":[5,7],"shared":6,"width":8},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::has_bvar_in_range_let","private":3,"private_columns":[6,7,10],"shared":8,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_inst_many_walk","private":9,"private_columns":[4,5,6,7,8,9,10,11,18],"shared":10,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_inst_many_bvar","private":2,"private_columns":[4,8],"shared":7,"width":9},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_inst_many_let","private":1,"private_columns":[9],"shared":9,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_lower","private":3,"private_columns":[4,5,9],"shared":7,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_lower_walk","private":11,"private_columns":[3,5,6,7,8,10,11,12,14,15,20],"shared":10,"width":21},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::k_check","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_is_def_eq","private":2,"private_columns":[4,9],"shared":8,"width":10},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::k_is_def_eq_core","private":1,"private_columns":[4],"shared":4,"width":5},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::k_is_def_eq_ordered","private":2,"private_columns":[4,7],"shared":6,"width":8},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_def_eq_app","private":11,"private_columns":[4,5,6,7,8,9,10,11,20,21,30],"shared":20,"width":31},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::de_args","private":5,"private_columns":[4,5,6,7,16],"shared":12,"width":17},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::address_eq","private":2,"private_columns":[3,69],"shared":68,"width":70},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::address_eq_tail","private":7,"private_columns":[2,3,4,5,6,71,72],"shared":66,"width":73},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::level_list_eq","private":5,"private_columns":[3,4,5,6,15],"shared":11,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::level_equal","private":2,"private_columns":[3,7],"shared":6,"width":8},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::nl_eq","private":6,"private_columns":[4,5,6,7,8,25],"shared":20,"width":26},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::nl_skip_empty","private":4,"private_columns":[2,3,4,14],"shared":11,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::glist_cmp","private":5,"private_columns":[4,5,6,7,16],"shared":12,"width":17},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::nlvars_eq","private":5,"private_columns":[4,5,6,7,19],"shared":15,"width":20},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::level_normalize","private":1,"private_columns":[9],"shared":9,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::normalize_aux","private":7,"private_columns":[5,6,7,8,9,10,17],"shared":11,"width":18},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::nl_add_const","private":4,"private_columns":[4,5,6,10],"shared":7,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::nl_add_const_go","private":5,"private_columns":[4,5,6,7,18],"shared":14,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::normalize_imax_dispatch","private":7,"private_columns":[6,7,8,9,10,11,19],"shared":13,"width":20},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::glist_ordered_insert","private":5,"private_columns":[2,3,4,9,13],"shared":9,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::nl_add_var","private":4,"private_columns":[5,6,7,19],"shared":16,"width":20},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::nlvars_add","private":5,"private_columns":[4,5,6,7,17],"shared":13,"width":18},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::nl_subsumption_walk","private":2,"private_columns":[3,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::nl_subsume_entry","private":9,"private_columns":[3,4,5,6,7,8,9,10,38],"shared":30,"width":39},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::glist_subset","private":5,"private_columns":[3,4,5,6,15],"shared":11,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::glist_eq_len","private":3,"private_columns":[4,5,12],"shared":10,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::nlvars_max_offset","private":3,"private_columns":[1,2,10],"shared":8,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::nlvars_subsume","private":6,"private_columns":[3,4,5,6,7,22],"shared":17,"width":23},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_is_def_eq_slow","private":3,"private_columns":[4,5,10],"shared":8,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_string_lit_one","private":4,"private_columns":[4,5,10,12],"shared":9,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::str_lit_delta_step","private":6,"private_columns":[3,4,5,6,11,36],"shared":31,"width":37},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::whnf_nd","private":2,"private_columns":[7,20],"shared":19,"width":21},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::whnf_nd_with_spine","private":6,"private_columns":[4,5,6,7,8,18],"shared":13,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}","private":2,"private_columns":[3,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::whnf_nd_apply_beta","private":3,"private_columns":[4,5,14],"shared":12,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::peel_beta","private":4,"private_columns":[6,7,12,16],"shared":13,"width":17},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::apply_spine","private":2,"private_columns":[3,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_inst1","private":3,"private_columns":[4,5,10],"shared":8,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_has_bvar_at","private":9,"private_columns":[3,4,5,6,7,8,9,10,21],"shared":13,"width":22},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::expr_has_bvar_at_binder","private":2,"private_columns":[4,7],"shared":6,"width":8},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_has_bvar_at_let","private":3,"private_columns":[5,6,11],"shared":9,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_inst1_walk","private":9,"private_columns":[4,5,6,7,8,9,10,11,18],"shared":10,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_inst1_bvar","private":3,"private_columns":[4,5,8],"shared":6,"width":9},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_inst1_let","private":1,"private_columns":[9],"shared":9,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::whnf_nd_const_head","private":17,"private_columns":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,24,55],"shared":39,"width":56},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::prim_family","private":23,"private_columns":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,83],"shared":61,"width":84},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_succ_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_pred_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_add_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_sub_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_mul_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_div_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_mod_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_pow_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_gcd_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_beq_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_ble_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_land_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_lor_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_xor_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_shift_left_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_shift_right_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::is_str_prim_addr","private":8,"private_columns":[1,2,3,4,5,6,7,29],"shared":22,"width":30},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::string_utf8_byte_size_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::string_append_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::string_of_list_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::string_back_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::string_legacy_back_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::string_to_byte_array_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::string_dec_eq_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::is_bitvec_prim_addr","private":4,"private_columns":[1,2,3,13],"shared":10,"width":14},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::bit_vec_to_nat_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::bit_vec_ult_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::decidable_decide_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::is_native_prim_addr","private":6,"private_columns":[1,2,3,4,5,21],"shared":16,"width":22},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::system_platform_num_bits_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::punit_size_of_1_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::reduce_bool_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::reduce_nat_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::subtype_val_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::is_dec_prim_addr","private":7,"private_columns":[1,2,3,4,5,6,25],"shared":19,"width":26},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_dec_le_addr_dec","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_dec_eq_addr_dec","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_dec_lt_addr_dec","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::int_dec_le_addr_dec","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::int_dec_eq_addr_dec","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::int_dec_lt_addr_dec","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::is_int_prim_addr","private":1,"private_columns":[21],"shared":21,"width":22},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::int_add_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::int_sub_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::int_mul_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::int_neg_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::int_emod_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::int_ediv_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::int_bmod_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::int_bdiv_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::int_nat_abs_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::int_pow_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_prim_dispatch","private":7,"private_columns":[6,7,8,9,10,11,20],"shared":14,"width":21},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_nat_dispatch_prewhnf","private":7,"private_columns":[5,6,7,8,9,10,28],"shared":22,"width":29},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::whnf_spine","private":2,"private_columns":[3,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::whnf","private":2,"private_columns":[7,20],"shared":19,"width":21},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::whnf_with_spine","private":6,"private_columns":[4,5,6,7,8,18],"shared":13,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::whnf_apply_beta","private":3,"private_columns":[4,5,14],"shared":12,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::whnf_const_head","private":18,"private_columns":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,22,23,39,49],"shared":32,"width":50},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_reduce_projection_definition","private":5,"private_columns":[2,3,9,10,16],"shared":12,"width":17},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::projection_definition_info","private":5,"private_columns":[7,8,9,10,22],"shared":18,"width":23},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_quot_iota","private":3,"private_columns":[5,6,14],"shared":12,"width":15},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::quot_lift_addr_iota","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_quot_lift","private":4,"private_columns":[2,3,6,14],"shared":11,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[1,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::quot_extract_arg","private":6,"private_columns":[2,3,4,12,13,17],"shared":12,"width":18},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::quot_ctor_addr_iota","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::quot_ind_addr_iota","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_quot_ind","private":4,"private_columns":[2,3,6,14],"shared":11,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::se_parent_addr","private":6,"private_columns":[4,5,6,7,12,20],"shared":15,"width":21},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_k_synth_iota","private":6,"private_columns":[9,10,11,12,18,29],"shared":24,"width":30},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_synth_gate","private":5,"private_columns":[6,7,8,17,37],"shared":33,"width":38},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_cprj_addr","private":1,"private_columns":[25],"shared":25,"width":26},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_take\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}","private":2,"private_columns":[3,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[1,1]],"name":"IxVM::try_iota","private":6,"private_columns":[10,11,12,13,16,41],"shared":36,"width":42},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_nat_linear_rec","private":5,"private_columns":[7,8,9,10,26],"shared":22,"width":27},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_extract_nat","private":6,"private_columns":[3,4,5,6,7,16],"shared":11,"width":17},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_zero_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[1,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_extract_nat_app","private":6,"private_columns":[2,3,4,9,10,15],"shared":10,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_succ","private":3,"private_columns":[2,3,25],"shared":23,"width":26},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::is_nat_succ_ih_step","private":9,"private_columns":[1,2,3,4,5,6,7,12,32],"shared":24,"width":33},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::mk_nat_lit","private":1,"private_columns":[2],"shared":2,"width":3},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::klimbs_add","private":1,"private_columns":[3],"shared":3,"width":4},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_add_carry","private":5,"private_columns":[4,5,6,7,48],"shared":44,"width":49},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::mk_nat_offset_stuck","private":3,"private_columns":[3,5,13],"shared":11,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_is_zero","private":2,"private_columns":[1,14],"shared":13,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_normalize","private":4,"private_columns":[2,3,4,28],"shared":25,"width":29},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::cleanup_nat_offset_major","private":5,"private_columns":[2,3,4,5,23],"shared":19,"width":24},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[1,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_match_nat_add","private":9,"private_columns":[0,2,3,4,5,6,11,12,23],"shared":15,"width":24},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_succ_offset","private":2,"private_columns":[3,19],"shared":18,"width":20},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_sub","private":2,"private_columns":[3,6],"shared":5,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_sub_borrow","private":8,"private_columns":[2,3,4,5,6,7,28,50],"shared":43,"width":51},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"UInt64::sub_with_borrow","private":1,"private_columns":[24],"shared":24,"width":25},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::whnf_iota_major","private":4,"private_columns":[3,4,12,27],"shared":24,"width":28},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::nat_lit_to_ctor_or_self","private":5,"private_columns":[2,3,4,9,17],"shared":13,"width":18},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_dec","private":1,"private_columns":[4],"shared":4,"width":5},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::collect_spine_of_ctor","private":6,"private_columns":[1,2,9,10,11,25],"shared":20,"width":26},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::compute_iprj_addr","private":1,"private_columns":[16],"shared":16,"width":17},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::find_rule","private":3,"private_columns":[5,6,13],"shared":11,"width":14},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::replace_spine_major","private":1,"private_columns":[9],"shared":9,"width":10},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::rec_to_parent_addr","private":1,"private_columns":[14],"shared":14,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::peel_n_foralls","private":2,"private_columns":[3,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_struct_eta_iota","private":13,"private_columns":[9,10,11,12,13,14,15,16,17,23,28,45,60],"shared":48,"width":61},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::struct_is_rec","private":2,"private_columns":[2,17],"shared":16,"width":18},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::struct_block_member_addrs","private":2,"private_columns":[3,54],"shared":53,"width":55},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::struct_scan_ctors","private":4,"private_columns":[7,8,9,27],"shared":24,"width":28},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::se_peel_tol","private":3,"private_columns":[3,4,11],"shared":9,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::se_scan_fields","private":4,"private_columns":[3,4,9,11],"shared":8,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::se_mentions","private":13,"private_columns":[3,4,5,6,7,8,9,10,11,12,13,19,24],"shared":12,"width":25},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::se_addr_in","private":3,"private_columns":[3,4,10],"shared":8,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::is_prop_type","private":2,"private_columns":[3,11],"shared":10,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_infer_only","private":11,"private_columns":[3,4,5,6,7,8,9,10,11,12,56],"shared":46,"width":57},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::ensure_sort_only","private":3,"private_columns":[2,5,14],"shared":12,"width":15},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_addr_io","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::str_addr_io","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::io_peel_params_subst","private":2,"private_columns":[4,14],"shared":13,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::io_peel_field_loop","private":2,"private_columns":[6,13],"shared":12,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::ctx_trim","private":3,"private_columns":[3,4,11],"shared":9,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::ctx_seek_cut","private":3,"private_columns":[2,3,7],"shared":5,"width":8},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::ctx_next_cut","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::ctx_close_cut","private":3,"private_columns":[2,3,9],"shared":7,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::lbr_min","private":3,"private_columns":[0,2,4],"shared":2,"width":5},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::apply_n_projs","private":2,"private_columns":[6,10],"shared":9,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::whnf_proj_head","private":4,"private_columns":[6,7,8,35],"shared":32,"width":36},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::str_lit_to_ctor_app_or_self","private":4,"private_columns":[3,4,9,10],"shared":7,"width":11},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::str_lit_to_ctor","private":1,"private_columns":[21],"shared":21,"width":22},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::list_nil_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::list_cons_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::char_type_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::char_of_nat_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_char_list","private":2,"private_columns":[5,16],"shared":15,"width":17},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_from_g","private":1,"private_columns":[12],"shared":12,"width":13},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::split_u32","private":1,"private_columns":[9],"shared":9,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::divmod_256","private":2,"private_columns":[4,6],"shared":5,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_reduce_fin_val_decidable_rec","private":10,"private_columns":[4,5,6,7,8,9,10,11,14,58],"shared":49,"width":59},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::fin_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::decidable_rec_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::whnf_get_ctor_or_none","private":2,"private_columns":[2,10],"shared":9,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_nat_binop_dispatch","private":6,"private_columns":[5,6,7,8,9,22],"shared":17,"width":23},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_nat_binop_addr","private":16,"private_columns":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,21,60],"shared":45,"width":61},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_mul","private":1,"private_columns":[4],"shared":4,"width":5},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_mul_outer","private":2,"private_columns":[5,19],"shared":18,"width":20},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_mul_single","private":4,"private_columns":[18,19,20,66],"shared":63,"width":67},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[1,1]],"name":"UInt64::mul","private":1,"private_columns":[50],"shared":50,"width":51},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_shl_limbs","private":2,"private_columns":[3,6],"shared":5,"width":7},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::klimbs_div","private":1,"private_columns":[4],"shared":4,"width":5},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_div_mod","private":4,"private_columns":[2,5,6,15],"shared":12,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::ordinary_div_mod","private":2,"private_columns":[4,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[1,1]],"name":"IxVM::divide_grow","private":5,"private_columns":[0,2,3,5,14],"shared":10,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_le","private":2,"private_columns":[2,15],"shared":14,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_eq","private":5,"private_columns":[3,4,5,6,28],"shared":24,"width":29},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"UInt64::eq","private":2,"private_columns":[16,25],"shared":24,"width":26},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::klimbs_mod","private":1,"private_columns":[4],"shared":4,"width":5},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_gcd","private":2,"private_columns":[3,6],"shared":5,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_pow","private":3,"private_columns":[3,4,15],"shared":13,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_land","private":3,"private_columns":[3,4,34],"shared":32,"width":35},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"UInt64::and","private":1,"private_columns":[24],"shared":24,"width":25},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_lor","private":3,"private_columns":[3,4,34],"shared":32,"width":35},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"UInt64::or","private":1,"private_columns":[24],"shared":24,"width":25},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_xor_op","private":3,"private_columns":[3,4,34],"shared":32,"width":35},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"UInt64::xor","private":1,"private_columns":[24],"shared":24,"width":25},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_shl","private":1,"private_columns":[6],"shared":6,"width":7},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_shr","private":1,"private_columns":[6],"shared":6,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::mk_bool","private":2,"private_columns":[2,6],"shared":5,"width":7},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::bool_false_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::bool_true_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_nat_offset_dispatch","private":9,"private_columns":[4,5,6,8,10,12,17,18,25],"shared":17,"width":26},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::mk_nat_binop_stuck","private":1,"private_columns":[10],"shared":10,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_str_dispatch","private":19,"private_columns":[5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,25,57],"shared":39,"width":58},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[1,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::walk_char_list_bytes","private":10,"private_columns":[2,3,4,5,6,7,8,16,17,30],"shared":21,"width":31},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::char_lit_codepoint","private":2,"private_columns":[4,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::char_lit_codepoint_syn","private":7,"private_columns":[3,4,5,6,7,12,24],"shared":18,"width":25},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::klimbs_scalar_value","private":9,"private_columns":[1,2,3,4,5,6,7,8,37],"shared":29,"width":38},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::utf8_encode_prepend","private":4,"private_columns":[3,4,5,31],"shared":28,"width":32},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::utf8_groups","private":1,"private_columns":[7],"shared":7,"width":8},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::divmod_64u","private":2,"private_columns":[4,7],"shared":6,"width":8},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_str_back","private":5,"private_columns":[1,2,3,6,19],"shared":15,"width":20},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::utf8_last_codepoint","private":1,"private_columns":[2],"shared":2,"width":3},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::utf8_last_go","private":2,"private_columns":[3,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_str_to_byte_array","private":6,"private_columns":[1,2,3,4,7,19],"shared":14,"width":20},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::byte_array_empty_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_str_dec_eq","private":8,"private_columns":[5,6,7,8,9,10,13,26],"shared":19,"width":27},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::bytestream_eq","private":6,"private_columns":[3,4,5,6,13,14],"shared":9,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::str_dec_eq_build","private":3,"private_columns":[4,27,36],"shared":34,"width":37},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::eq_refl_addr_dec","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::decidable_is_true_addr_dec","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_bitvec_dispatch","private":6,"private_columns":[5,6,7,8,9,21],"shared":16,"width":22},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::bitvec_prep_spine","private":3,"private_columns":[3,4,18],"shared":16,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::bv_to_nat_via","private":5,"private_columns":[2,3,4,8,17],"shared":13,"width":18},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[1,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::bitvec_of_nat_args_direct","private":7,"private_columns":[1,2,3,10,11,12,16],"shared":10,"width":17},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::bit_vec_of_nat_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::bitvec_prep_spine_ult","private":4,"private_columns":[3,4,5,20],"shared":17,"width":21},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::np_whnf_inner_bv","private":1,"private_columns":[6],"shared":6,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_reduce_bit_vec_ult","private":5,"private_columns":[1,2,3,6,16],"shared":12,"width":17},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_reduce_decide_bitvec_lt","private":8,"private_columns":[3,4,5,6,7,8,9,46],"shared":39,"width":47},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::lt_lt_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::bit_vec_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_native_dispatch","private":7,"private_columns":[5,6,7,8,9,10,31],"shared":25,"width":32},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::mk_nat_literal_64","private":1,"private_columns":[3],"shared":3,"width":4},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::mk_nat_one","private":1,"private_columns":[3],"shared":3,"width":4},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_reduce_subtype_val","private":5,"private_columns":[1,2,3,6,18],"shared":14,"width":19},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::system_platform_get_num_bits_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[1,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_native_bool","private":5,"private_columns":[1,2,7,8,12],"shared":8,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::check_native_nat","private":5,"private_columns":[1,2,7,8,9],"shared":5,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_dec_dispatch","private":4,"private_columns":[6,7,8,21],"shared":18,"width":22},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::is_int_dec_prim_addr","private":4,"private_columns":[1,2,3,13],"shared":10,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_normalize_int_decidable","private":4,"private_columns":[6,7,8,21],"shared":18,"width":22},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_extract_int","private":8,"private_columns":[1,2,3,4,5,10,11,25],"shared":18,"width":26},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::int_of_nat_addr_dec","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::int_neg_succ_addr_dec","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::normalize_int_dec_rebuild","private":5,"private_columns":[6,7,13,14,23],"shared":19,"width":24},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::intern_int_lit","private":2,"private_columns":[3,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::dec_rewrite_lt_to_le","private":3,"private_columns":[3,9,17],"shared":15,"width":18},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::dec_dispatch_le_eq","private":4,"private_columns":[8,9,10,21],"shared":18,"width":22},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::dec_build_proof","private":7,"private_columns":[0,11,12,13,14,15,41],"shared":35,"width":42},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::bool_type_addr_dec","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_le_of_ble_eq_true_addr_dec","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_not_le_of_not_ble_eq_true_addr_dec","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_eq_of_beq_eq_true_addr_dec","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::nat_ne_of_beq_eq_false_addr_dec","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::dec_finish","private":4,"private_columns":[6,7,19,27],"shared":24,"width":28},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::decidable_is_false_addr_dec","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_int_prim_dispatch","private":7,"private_columns":[5,6,7,8,9,10,31],"shared":25,"width":32},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_extract_int_prim","private":8,"private_columns":[1,2,3,4,5,10,11,23],"shared":16,"width":24},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::mk_int_prim","private":4,"private_columns":[0,3,4,17],"shared":14,"width":18},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[1,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_int_prim_second","private":14,"private_columns":[4,5,6,7,8,9,10,11,12,22,23,35,38,41],"shared":28,"width":42},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::int_bmod_prim","private":4,"private_columns":[4,5,6,20],"shared":17,"width":21},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::int_bdiv_prim","private":5,"private_columns":[4,5,6,7,30],"shared":26,"width":31},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::int_add_prim","private":3,"private_columns":[5,6,11],"shared":9,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::int_emod_prim","private":3,"private_columns":[4,5,12],"shared":10,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::int_ediv_prim","private":3,"private_columns":[5,6,18],"shared":16,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::whnf_nd_proj_head","private":4,"private_columns":[6,7,8,35],"shared":32,"width":36},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_is_def_eq_slow_nd","private":3,"private_columns":[4,5,12],"shared":10,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::whnf_struct_core","private":2,"private_columns":[7,20],"shared":19,"width":21},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::whnf_struct_core_spine","private":8,"private_columns":[4,5,6,7,8,9,10,23],"shared":16,"width":24},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::whnf_struct_core_proj","private":4,"private_columns":[7,8,16,30],"shared":27,"width":31},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::whnf_struct_core_const","private":4,"private_columns":[6,7,21,25],"shared":22,"width":26},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_is_def_eq_struct_safe","private":17,"private_columns":[4,5,6,7,8,9,10,11,12,13,14,15,20,21,22,23,25],"shared":9,"width":26},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_is_def_eq_slow_nd_after_core","private":3,"private_columns":[6,7,14],"shared":12,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_is_def_eq_slow2","private":7,"private_columns":[6,7,8,9,10,11,27],"shared":21,"width":28},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_proof_irrel","private":2,"private_columns":[4,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_unit_like","private":2,"private_columns":[4,10],"shared":9,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::is_unit_like_type","private":8,"private_columns":[1,2,3,4,5,6,13,40],"shared":33,"width":41},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_eta_struct","private":11,"private_columns":[4,5,6,7,8,9,10,11,12,19,59],"shared":49,"width":60},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::compare_struct_fields","private":3,"private_columns":[8,9,15],"shared":13,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_def_eq_nat","private":5,"private_columns":[3,4,5,6,21],"shared":17,"width":22},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::is_nat_zero","private":4,"private_columns":[2,3,4,11],"shared":8,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[1,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::nat_offset_of","private":16,"private_columns":[0,1,2,3,4,5,6,7,8,9,10,11,16,17,18,34],"shared":19,"width":35},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::lazy_delta_loop","private":6,"private_columns":[7,8,9,10,11,22],"shared":17,"width":23},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::head_addr","private":3,"private_columns":[1,5,10],"shared":8,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::lazy_delta_step_const_const","private":6,"private_columns":[9,10,11,12,13,50],"shared":45,"width":51},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"IxVM::is_defn_or_thm","private":2,"private_columns":[13,16],"shared":15,"width":17},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::unfold_b_and_loop","private":2,"private_columns":[7,11],"shared":10,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::delta_unfold","private":7,"private_columns":[0,1,2,3,10,24,25],"shared":19,"width":26},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::unfold_a_and_loop","private":2,"private_columns":[7,11],"shared":10,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"IxVM::delta_rank","private":3,"private_columns":[5,12,14],"shared":12,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::unfold_both_and_loop","private":4,"private_columns":[7,8,11,15],"shared":12,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::lazy_delta_a_const_b_proj","private":4,"private_columns":[8,9,10,32],"shared":29,"width":33},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_unfold_proj_app","private":6,"private_columns":[0,2,3,4,11,22],"shared":17,"width":23},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::try_unfold_head","private":9,"private_columns":[0,14,15,16,17,18,19,20,21],"shared":13,"width":22},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::lazy_delta_b_const_a_proj","private":4,"private_columns":[8,9,10,32],"shared":29,"width":33},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::lazy_delta_both_proj","private":5,"private_columns":[7,8,9,14,16],"shared":12,"width":17},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::slow2_after_delta","private":3,"private_columns":[6,7,13],"shared":11,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_is_def_eq_struct_bounded","private":32,"private_columns":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,34,35,36,37,38,39,40,41],"shared":10,"width":42},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_is_def_eq_struct_spend","private":4,"private_columns":[6,7,8,19],"shared":16,"width":20},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::literal_eq","private":4,"private_columns":[5,6,7,9],"shared":6,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_is_def_eq_structure_tree","private":3,"private_columns":[4,5,11],"shared":9,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_same_proj_head_app","private":8,"private_columns":[4,5,6,7,8,9,10,30],"shared":23,"width":31},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_is_def_eq_structure_tree_app","private":5,"private_columns":[4,5,6,11,17],"shared":13,"width":18},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::slow2_eager_fallback","private":7,"private_columns":[4,5,6,7,8,9,25],"shared":19,"width":26},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_eta_swap","private":4,"private_columns":[4,5,6,17],"shared":14,"width":18},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_eta_expand","private":4,"private_columns":[5,6,13,19],"shared":16,"width":20},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::k_is_def_eq_struct","private":1,"private_columns":[4],"shared":4,"width":5},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_is_def_eq_struct_go","private":27,"private_columns":[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,37,41],"shared":15,"width":42},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::try_lazy_delta_app","private":6,"private_columns":[4,5,6,7,8,46],"shared":41,"width":47},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_def_eq_rebase","private":2,"private_columns":[5,16],"shared":15,"width":17},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_glb","private":2,"private_columns":[3,7],"shared":6,"width":8},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_glb_walk","private":9,"private_columns":[5,6,7,8,9,10,11,12,20],"shared":12,"width":21},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_glb_binder","private":2,"private_columns":[4,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_glb_let","private":3,"private_columns":[5,6,13],"shared":11,"width":14},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_infer_let_start","private":1,"private_columns":[9],"shared":9,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_infer_let_env","private":5,"private_columns":[5,6,7,8,18],"shared":14,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::infer_let_local_cutoff","private":4,"private_columns":[1,2,3,11],"shared":8,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_infer_let_env_core","private":7,"private_columns":[5,6,7,8,9,10,25],"shared":19,"width":26},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::infer_let_lookup_type","private":5,"private_columns":[4,5,6,7,14],"shared":10,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::infer_let_materialize","private":9,"private_columns":[5,6,7,8,9,10,11,12,26],"shared":18,"width":27},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::infer_let_lookup_value","private":5,"private_columns":[4,5,6,7,14],"shared":10,"width":15},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_infer_let_env_rebase","private":1,"private_columns":[12],"shared":12,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::infer_let_drop_unused","private":5,"private_columns":[0,2,3,4,14],"shared":10,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_infer_lit","private":2,"private_columns":[3,6],"shared":5,"width":7},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_infer_proj","private":1,"private_columns":[39],"shared":39,"width":40},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::is_inductive_prop","private":1,"private_columns":[11],"shared":11,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::peel_n_alls_whnf","private":3,"private_columns":[4,5,13],"shared":11,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::peel_field_loop","private":2,"private_columns":[8,15],"shared":14,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_prop_field_if_prop","private":2,"private_columns":[3,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_no_dep_data_field_if_prop","private":3,"private_columns":[4,5,12],"shared":10,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::k_infer_rebase","private":2,"private_columns":[4,13],"shared":12,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::assert_safety","private":2,"private_columns":[2,5],"shared":4,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::safe_refs_only","private":7,"private_columns":[3,4,5,6,7,9,28],"shared":22,"width":29},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[1,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_quot","private":4,"private_columns":[4,5,6,11],"shared":8,"width":12},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::quot_type_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[1,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_eq_type","private":1,"private_columns":[10],"shared":10,"width":11},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::eq_type_addr","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::count_foralls_at_least","private":3,"private_columns":[4,5,12],"shared":10,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_canonical_block","private":4,"private_columns":[1,2,51,65],"shared":62,"width":66},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::canon_muts_has_kind","private":2,"private_columns":[6,56],"shared":55,"width":57},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_indc_positions","private":3,"private_columns":[3,4,54],"shared":52,"width":55},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_sort_loop","private":3,"private_columns":[5,6,13],"shared":11,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_build_ctx_classes","private":2,"private_columns":[6,13],"shared":12,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_build_ctx_members","private":4,"private_columns":[5,6,10,19],"shared":16,"width":20},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::canon_member_num_ctors","private":3,"private_columns":[2,8,16],"shared":14,"width":17},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_member_ci","private":1,"private_columns":[16],"shared":16,"width":17},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_ctor_ctx_entries","private":2,"private_columns":[6,10],"shared":9,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_concat\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\"]}}]}","private":2,"private_columns":[3,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_refine_classes","private":2,"private_columns":[4,10],"shared":9,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_refine_one","private":3,"private_columns":[4,5,10],"shared":8,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_ins_sort","private":2,"private_columns":[4,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_insert_sorted","private":3,"private_columns":[5,6,38],"shared":36,"width":39},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_cmp_member_ctx","private":2,"private_columns":[27,32],"shared":31,"width":33},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::canon_ord_cmp_g","private":4,"private_columns":[2,3,4,6],"shared":3,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"IxVM::canon_kind_ord","private":1,"private_columns":[19],"shared":19,"width":20},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_cmp_member_same_kind_ctx","private":11,"private_columns":[27,28,29,30,31,32,33,34,35,36,68],"shared":58,"width":69},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"IxVM::canon_sord_then","private":4,"private_columns":[0,5,6,7],"shared":4,"width":8},{"constraint_degree":2,"lifted":0,"lookups":[[2,1]],"name":"IxVM::canon_sord_of_g","private":1,"private_columns":[1],"shared":1,"width":2},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_cmp_kexpr_ctx","private":1,"private_columns":[13],"shared":13,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_cmp_kexpr_node_ctx","private":41,"private_columns":[4,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,59],"shared":19,"width":60},{"constraint_degree":2,"lifted":0,"lookups":[[1,1]],"name":"IxVM::canon_sord_lt_strong","private":1,"private_columns":[0],"shared":0,"width":1},{"constraint_degree":2,"lifted":0,"lookups":[[1,1]],"name":"IxVM::canon_sord_gt_strong","private":1,"private_columns":[0],"shared":0,"width":1},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_cmp_kuniv","private":14,"private_columns":[1,3,5,6,9,10,14,16,17,21,22,23,24,27],"shared":14,"width":28},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"IxVM::canon_ord_then","private":3,"private_columns":[1,2,4],"shared":2,"width":5},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_cmp_kuniv_list","private":4,"private_columns":[3,4,5,14],"shared":11,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_ctx_cmp_addr","private":5,"private_columns":[5,6,7,8,16],"shared":12,"width":17},{"constraint_degree":2,"lifted":0,"lookups":[[1,1]],"name":"IxVM::canon_sord_eq_strong","private":1,"private_columns":[0],"shared":0,"width":1},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_ctx_class_idx","private":3,"private_columns":[3,4,11],"shared":9,"width":12},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_addr_cmp","private":1,"private_columns":[81],"shared":81,"width":82},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::canon_addr_chunk","private":1,"private_columns":[9],"shared":9,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::canon_cmp_kliteral","private":4,"private_columns":[5,6,7,8],"shared":5,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_cmp_klimbs","private":2,"private_columns":[3,10],"shared":9,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}","private":2,"private_columns":[1,13],"shared":12,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_cmp_klimbs_tail","private":2,"private_columns":[3,26],"shared":25,"width":27},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_cmp_u64_lex","private":1,"private_columns":[31],"shared":31,"width":32},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_cmp_bytes","private":4,"private_columns":[3,4,5,14],"shared":11,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_cmp_ctor_range_ctx","private":2,"private_columns":[9,41],"shared":40,"width":42},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_cmp_ctor_pair_ctx","private":4,"private_columns":[27,28,29,49],"shared":46,"width":50},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_cmp_krec_rule_list_ctx","private":4,"private_columns":[5,6,7,22],"shared":19,"width":23},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_cmp_krec_rule_ctx","private":1,"private_columns":[14],"shared":14,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_group_consec","private":2,"private_columns":[4,10],"shared":9,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_group_walk","private":3,"private_columns":[6,7,41],"shared":39,"width":42},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_classes_eq","private":5,"private_columns":[3,4,5,6,15],"shared":11,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_all_singleton","private":3,"private_columns":[2,3,9],"shared":7,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canon_flatten","private":2,"private_columns":[2,7],"shared":6,"width":8},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_inductive_shape","private":1,"private_columns":[10],"shared":10,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_result_sort_level","private":2,"private_columns":[4,12],"shared":11,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_inductive_shape_ctors","private":3,"private_columns":[10,11,28],"shared":26,"width":29},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::check_param_agreement","private":1,"private_columns":[4],"shared":4,"width":5},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_param_agreement_go","private":2,"private_columns":[4,16],"shared":15,"width":17},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_ctor_return_type","private":1,"private_columns":[18],"shared":18,"width":19},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::assert_return_head_is_parent","private":1,"private_columns":[15],"shared":15,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::assert_lvls_are_params","private":2,"private_columns":[3,11],"shared":10,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::assert_first_args_are_param_bvars","private":2,"private_columns":[4,13],"shared":12,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::list_any_mentions_block","private":3,"private_columns":[3,4,10],"shared":8,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_mentions_block","private":13,"private_columns":[4,6,7,8,9,10,11,12,13,14,15,21,24],"shared":12,"width":25},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::caddr_is_peer","private":2,"private_columns":[3,18],"shared":17,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::addr_list_contains","private":3,"private_columns":[3,4,10],"shared":8,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_field_universes","private":2,"private_columns":[3,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_field_universes_skip_params","private":2,"private_columns":[4,11],"shared":10,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_field_universes_inner","private":2,"private_columns":[3,11],"shared":10,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::level_leq","private":3,"private_columns":[3,4,12],"shared":10,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::nl_le","private":5,"private_columns":[3,4,5,6,16],"shared":12,"width":17},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::nl_covers_const","private":5,"private_columns":[4,5,6,7,18],"shared":14,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::nlvars_any_offset_geq","private":3,"private_columns":[3,4,11],"shared":9,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::nl_le_vars","private":3,"private_columns":[4,5,12],"shared":10,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::nl_covers_var","private":4,"private_columns":[5,6,7,17],"shared":14,"width":18},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::nlvars_dominates","private":4,"private_columns":[4,5,6,13],"shared":10,"width":14},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_positivity","private":1,"private_columns":[8],"shared":8,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::peel_n_foralls_with_types","private":3,"private_columns":[5,6,13],"shared":11,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_positivity_fields","private":2,"private_columns":[4,10],"shared":9,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_positivity_aug","private":5,"private_columns":[4,5,6,7,42],"shared":38,"width":43},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_valid_ind_app","private":1,"private_columns":[19],"shared":19,"width":20},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::assert_occ_param_bvars","private":2,"private_columns":[4,13],"shared":12,"width":14},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_reverse\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}","private":1,"private_columns":[3],"shared":3,"width":4},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_reverse_acc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}","private":2,"private_columns":[3,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_nested_ctors_positivity","private":2,"private_columns":[7,27],"shared":26,"width":28},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_block_peer_param_agreement","private":5,"private_columns":[13,14,15,16,67],"shared":63,"width":68},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::peer_agree_walk","private":6,"private_columns":[7,8,9,10,11,80],"shared":75,"width":81},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_recursor_member","private":4,"private_columns":[13,26,31,35],"shared":32,"width":36},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::is_muts_block","private":2,"private_columns":[1,51],"shared":50,"width":52},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::KRecRule\"}}]}","private":2,"private_columns":[1,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_rec_rules_wellscoped","private":2,"private_columns":[3,9],"shared":8,"width":10},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_rec_major_spine","private":1,"private_columns":[13],"shared":13,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::compute_k_target","private":8,"private_columns":[13,14,15,16,17,18,19,40],"shared":33,"width":41},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::ind_is_solo","private":3,"private_columns":[3,4,56],"shared":54,"width":57},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::muts_indc_count_is_one","private":5,"private_columns":[3,4,5,53,54],"shared":50,"width":55},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::check_parent_inductive_shape","private":2,"private_columns":[12,14],"shared":13,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_recursor_canonical_full","private":7,"private_columns":[26,27,28,29,30,31,81],"shared":75,"width":82},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::is_large_eliminator","private":9,"private_columns":[17,18,19,20,21,22,23,25,30],"shared":22,"width":31},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_large_prop_ctor","private":3,"private_columns":[5,6,13],"shared":11,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_large_walk_fields","private":4,"private_columns":[6,7,8,20],"shared":17,"width":21},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::all_bvars_in_args","private":3,"private_columns":[3,4,10],"shared":8,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::args_contain_bvar","private":4,"private_columns":[3,4,5,14],"shared":11,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_rec_lvls_list","private":2,"private_columns":[3,7],"shared":6,"width":8},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_flat_block","private":5,"private_columns":[4,5,6,7,126],"shared":122,"width":127},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::first_recr_parent_block","private":5,"private_columns":[6,7,8,9,86],"shared":82,"width":87},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::flat_originals_walk","private":4,"private_columns":[6,7,8,75],"shared":72,"width":76},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_param_lvls_range","private":2,"private_columns":[4,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::detect_aux_from_recrs_ex","private":2,"private_columns":[5,55],"shared":54,"width":56},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::aux_from_recrs_walk_ex","private":8,"private_columns":[8,9,10,11,12,13,14,103],"shared":96,"width":104},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::extract_aux_spec_params_from_rec","private":2,"private_columns":[14,16],"shared":15,"width":17},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::extract_aux_spec_params","private":1,"private_columns":[14],"shared":14,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::spec_params_lower","private":2,"private_columns":[3,10],"shared":9,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::extract_aux_occ_us","private":5,"private_columns":[13,14,15,16,28],"shared":24,"width":29},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::aux_already_in","private":5,"private_columns":[4,5,6,7,17],"shared":13,"width":18},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::spec_params_ptr_eq","private":5,"private_columns":[3,4,5,6,15],"shared":11,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::kexpr_struct_eq","private":29,"private_columns":[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,37,38,40],"shared":12,"width":41},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::level_list_struct_eq","private":5,"private_columns":[3,4,5,6,15],"shared":11,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_snoc\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}","private":2,"private_columns":[6,14],"shared":13,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_peer_recs","private":2,"private_columns":[4,13],"shared":12,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::find_peer_recursor_with_spec","private":2,"private_columns":[6,56],"shared":55,"width":57},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::find_peer_rec_spec_walk","private":8,"private_columns":[9,10,11,12,13,14,15,98],"shared":91,"width":99},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_flat_own_params","private":3,"private_columns":[2,3,26],"shared":24,"width":27},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::flat_find_pos_kind","private":5,"private_columns":[7,8,9,10,25],"shared":21,"width":26},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::canonical_rules_at_pos","private":1,"private_columns":[30],"shared":30,"width":31},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::flat_member_at","private":3,"private_columns":[6,7,17],"shared":15,"width":18},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_rec_type","private":2,"private_columns":[10,29],"shared":28,"width":30},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_rec_type_from","private":2,"private_columns":[12,53],"shared":52,"width":54},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_length\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}","private":2,"private_columns":[1,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::collect_n_doms_whnf","private":6,"private_columns":[0,2,3,4,5,20],"shared":15,"width":21},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::build_all_motives","private":1,"private_columns":[4],"shared":4,"width":5},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_all_motives_walk","private":3,"private_columns":[5,6,29],"shared":27,"width":30},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_motive_type_flat","private":2,"private_columns":[10,20],"shared":19,"width":21},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::peel_motive_params_subst","private":2,"private_columns":[7,15],"shared":14,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::subst_param_for","private":3,"private_columns":[5,6,11],"shared":9,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::collect_index_doms","private":4,"private_columns":[3,4,5,19],"shared":16,"width":20},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_major_params","private":2,"private_columns":[5,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::apply_spec_params_lifted","private":2,"private_columns":[4,10],"shared":9,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_major_indices","private":2,"private_columns":[4,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::wrap_foralls","private":2,"private_columns":[3,8],"shared":7,"width":9},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::build_all_minors","private":1,"private_columns":[6],"shared":6,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_all_minors_walk","private":3,"private_columns":[9,10,33],"shared":31,"width":34},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_minor_doms","private":2,"private_columns":[16,34],"shared":33,"width":35},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::projection_addr_ctor","private":1,"private_columns":[25],"shared":25,"width":26},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_minor_at_depth","private":1,"private_columns":[37],"shared":37,"width":38},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::peel_ctor_params_subst","private":3,"private_columns":[8,9,24],"shared":22,"width":25},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::ctor_subst_param_for","private":3,"private_columns":[6,7,12],"shared":10,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::walk_fields_classify","private":4,"private_columns":[11,12,17,22],"shared":19,"width":23},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::is_rec_field","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::is_rec_field_peel","private":3,"private_columns":[5,6,21],"shared":19,"width":22},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::flat_find_matching","private":4,"private_columns":[7,8,9,21],"shared":18,"width":22},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::spec_params_dom_prefix_match","private":4,"private_columns":[4,5,6,16],"shared":13,"width":17},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::list_lift_each","private":2,"private_columns":[4,10],"shared":9,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::build_ctor_app_params","private":2,"private_columns":[7,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_apply_bvars_decreasing","private":2,"private_columns":[5,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_apply_field_bvars","private":2,"private_columns":[5,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_ih_doms","private":2,"private_columns":[9,32],"shared":31,"width":33},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_lookup_or_default\",\"types\":[\"field\"]}","private":3,"private_columns":[2,3,8],"shared":6,"width":9},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::peel_leading_foralls","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::peel_leading_foralls_acc","private":2,"private_columns":[4,10],"shared":9,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::list_lift_indices","private":2,"private_columns":[4,10],"shared":9,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::apply_indices_in_conclusion","private":2,"private_columns":[4,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::ctors_before_pos","private":4,"private_columns":[3,4,5,29],"shared":26,"width":30},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::populate_rules","private":3,"private_columns":[16,17,34],"shared":32,"width":35},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::build_rule_rhs","private":1,"private_columns":[27],"shared":27,"width":28},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::count_foralls_body","private":2,"private_columns":[3,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::apply_ihs_full","private":2,"private_columns":[13,42],"shared":41,"width":43},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::wrap_lams","private":2,"private_columns":[3,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::compare_rules","private":3,"private_columns":[9,10,39],"shared":37,"width":40},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::peel_n_lams_collect","private":3,"private_columns":[7,8,15],"shared":13,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::flat_find_pos","private":3,"private_columns":[5,6,15],"shared":13,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::run_check_transitive","private":6,"private_columns":[1,2,3,4,5,60],"shared":55,"width":61},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_muts_all","private":2,"private_columns":[4,52],"shared":51,"width":53},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_muts_member_at","private":1,"private_columns":[62],"shared":62,"width":63},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::walk_refs_transitive","private":3,"private_columns":[3,4,10],"shared":8,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::g_list_has","private":2,"private_columns":[4,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::const_idxs_of","private":6,"private_columns":[49,50,51,52,53,60],"shared":55,"width":61},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::const_idxs_exprs","private":2,"private_columns":[2,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::const_idxs_expr","private":7,"private_columns":[2,3,4,5,6,7,32],"shared":26,"width":33},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::const_idxs_rules","private":2,"private_columns":[2,16],"shared":15,"width":17},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::const_idxs_muts","private":4,"private_columns":[2,3,4,56],"shared":53,"width":57},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::const_idxs_ctors","private":2,"private_columns":[2,41],"shared":40,"width":42},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::addr_set_build","private":2,"private_columns":[13,23],"shared":22,"width":24},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"${\"name\":\"IxVM::rbtree_map_insert\",\"types\":[\"field\"]}","private":1,"private_columns":[14],"shared":14,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::rbtree_map_ins\",\"types\":[\"field\"]}","private":5,"private_columns":[14,15,16,17,43],"shared":39,"width":44},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::rbtree_map_balance\",\"types\":[\"field\"]}","private":2,"private_columns":[21,25],"shared":24,"width":26},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::rbtree_map_balance_fix\",\"types\":[\"field\"]}","private":284,"private_columns":[0,1,4,5,10,11,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,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,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,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,282,283,284,285,286,290,291,292,297,298,299],"shared":16,"width":300},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::load_assumption_tree","private":1,"private_columns":[43],"shared":43,"width":44},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::parse_atree_body","private":6,"private_columns":[1,2,6,7,9,13],"shared":8,"width":14},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::leaf_hash","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::node_hash","private":1,"private_columns":[7],"shared":7,"width":8},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::addr_set_member","private":1,"private_columns":[8],"shared":8,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::rbtree_map_lookup_or_default\",\"types\":[\"field\"]}","private":5,"private_columns":[9,10,11,12,32],"shared":28,"width":33},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::env_walk","private":9,"private_columns":[14,15,16,17,18,19,20,22,78],"shared":70,"width":79},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::env_walk_refs","private":3,"private_columns":[16,17,23],"shared":21,"width":24},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::eval_body","private":6,"private_columns":[1,2,5,6,7,17],"shared":12,"width":18},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::eval_output","private":1,"private_columns":[56],"shared":56,"width":57},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::eval_nf","private":3,"private_columns":[3,4,13],"shared":11,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::eval_nf_spine","private":3,"private_columns":[3,4,11],"shared":9,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::run_check_env","private":2,"private_columns":[3,18],"shared":17,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::walk_leaves_owned","private":2,"private_columns":[1,37],"shared":36,"width":38},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::check_owned","private":1,"private_columns":[33],"shared":33,"width":34},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::env_walk_all","private":6,"private_columns":[1,2,3,4,5,87],"shared":82,"width":88},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::env_walk_refs_all","private":3,"private_columns":[3,4,41],"shared":39,"width":42},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::env_walk_leaves","private":2,"private_columns":[13,17],"shared":16,"width":18},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_reveal_info","private":28,"private_columns":[1,2,3,4,5,6,7,8,9,37,38,40,41,43,44,45,46,47,48,49,50,51,53,54,56,57,58,99],"shared":72,"width":100},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::get_opt_def_kind_masked","private":7,"private_columns":[0,1,2,3,4,7,8],"shared":2,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::get_opt_u64_masked","private":3,"private_columns":[1,2,13],"shared":11,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::get_opt_addr_masked","private":3,"private_columns":[1,2,6],"shared":4,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::get_opt_bool_masked","private":3,"private_columns":[1,2,6],"shared":4,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::get_opt_rule_list_masked","private":3,"private_columns":[1,2,15],"shared":13,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_reveal_rule_list_inner","private":4,"private_columns":[0,9,11,41],"shared":38,"width":42},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::get_opt_quot_kind_masked","private":8,"private_columns":[0,1,2,3,4,5,8,9],"shared":2,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_mut_entry_list_inner","private":4,"private_columns":[0,9,11,86],"shared":83,"width":87},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::get_mut_entry","private":1,"private_columns":[65],"shared":65,"width":66},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_reveal_mut_const_info","private":21,"private_columns":[1,2,30,31,33,34,36,37,38,39,40,41,42,43,44,46,47,49,50,51,92],"shared":72,"width":93},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::get_opt_ctor_entry_list_masked","private":3,"private_columns":[1,2,15],"shared":13,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_ctor_entry_list_inner","private":4,"private_columns":[0,9,11,72],"shared":69,"width":73},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::get_ctor_entry","private":1,"private_columns":[51],"shared":51,"width":52},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::get_reveal_ctor_info","private":1,"private_columns":[64],"shared":64,"width":65},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::run_reveal","private":9,"private_columns":[55,56,57,58,59,60,61,62,111],"shared":103,"width":112},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::check_opt_def_kind","private":2,"private_columns":[3,6],"shared":5,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"IxVM::def_kind_tag","private":1,"private_columns":[3],"shared":3,"width":4},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::check_opt_u64","private":2,"private_columns":[17,19],"shared":18,"width":20},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::check_opt_expr_addr","private":2,"private_columns":[3,6],"shared":5,"width":7},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::expr_addr","private":1,"private_columns":[22],"shared":22,"width":23},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"IxVM::check_opt_bool","private":1,"private_columns":[4],"shared":4,"width":5},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::check_opt_recr_rules","private":2,"private_columns":[3,4],"shared":3,"width":5},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_recr_rules","private":2,"private_columns":[10,51],"shared":50,"width":52},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::check_opt_quot_kind","private":2,"private_columns":[3,6],"shared":5,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::check_opt_addr","private":2,"private_columns":[3,5],"shared":4,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_muts_components","private":2,"private_columns":[2,112],"shared":111,"width":113},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_mut_const","private":3,"private_columns":[99,100,101],"shared":99,"width":102},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"IxVM::check_opt_ctor_entries","private":2,"private_columns":[3,4],"shared":3,"width":5},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_ctor_entries","private":2,"private_columns":[2,53],"shared":52,"width":54},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"IxVM::check_ctor_entry","private":1,"private_columns":[83],"shared":83,"width":84},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}","private":2,"private_columns":[43,88],"shared":87,"width":89},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"IxVM::run_contains","private":1,"private_columns":[4],"shared":4,"width":5}],"entries":["IxVM::verify_claim"],"groups":[["ixvm_group_00",["UInt32::less_than_fields","IxVM::lbr_max","IxVM::lbr_min","IxVM::delta_unfold"]],["ixvm_group_01",["IxVM::address_eq_tail","IxVM::get_recursor","IxVM::count_ctors","IxVM::ctor_at","IxVM::load_verified_blob","IxVM::get_ci","IxVM::check_canonical_block","IxVM::peer_agree_walk","IxVM::ind_is_solo","IxVM::flat_originals_walk","IxVM::find_peer_recursor_with_spec"]],["ixvm_group_02",["UInt64::eq","UInt64::wrapping_succ","IxVM::quot_kind_tag","IxVM::klimbs_mod","IxVM::system_platform_get_num_bits_addr","IxVM::str_addr","IxVM::convert_axiom","IxVM::convert_quotient","IxVM::quot_ctor_addr","IxVM::quot_lift_addr_iota","IxVM::quot_ind_addr","IxVM::quot_type_addr"]],["ixvm_group_03",["UInt64::add","IxVM::is_str_prim_addr","IxVM::is_dec_prim_addr","IxVM::check_const"]],["ixvm_group_04",["UInt64::saturating_pred","UInt64::to_field"]],["ixvm_group_05",["Blake3::verify_bytes_against","IxVM::put_constructor_proj","IxVM::get_expr_let","IxVM::build_succ_chain","IxVM::bytes_to_u64_limb","IxVM::io_peel_field_loop","IxVM::assert_occ_param_bvars","IxVM::populate_rules","IxVM::build_minor_doms","IxVM::peel_leading_foralls_acc","IxVM::flat_find_matching","IxVM::const_idxs_rules"]],["ixvm_group_06",["Blake3::bytes_to_addr","IxVM::get_constructor","IxVM::get_mut_const","IxVM::is_unit_like_type","IxVM::canon_muts_has_kind","IxVM::is_muts_block","IxVM::muts_indc_count_is_one","IxVM::const_idxs_ctors"]],["ixvm_group_07",["Blake3::next_layer","IxVM::get_ci_iprj","IxVM::get_ci_cprj","IxVM::muts_member_at","IxVM::projection_addr","IxVM::build_flat_block","IxVM::run_claim"]],["ixvm_group_08",["Blake3::compress_layer","Blake3::finish","IxVM::get_constant"]],["ixvm_group_09",["IxVM::put_expr","IxVM::get_ci_rprj","IxVM::first_recr_parent_block","IxVM::load_assumption_tree","IxVM::env_walk","IxVM::get_mut_entry","IxVM::get_mut_entry_list_inner","IxVM::check_opt_addr","IxVM::check_muts_components","${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}","${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}"]],["ixvm_group_10",["IxVM::put_u64_le","IxVM::check_native_nat","IxVM::utf8_last_go","IxVM::char_lit_codepoint","IxVM::mk_nat_binop_stuck","IxVM::canon_cmp_krec_rule_ctx","IxVM::canon_kind_ord","IxVM::canon_ctor_ctx_entries","IxVM::canon_refine_one","IxVM::canon_ins_sort","IxVM::canon_flatten","IxVM::canon_all_singleton","IxVM::extract_aux_spec_params_from_rec","IxVM::check_opt_u64","IxVM::list_concat.Tup.Ptr.U8_32.G","${\"name\":\"IxVM::rbtree_map_insert\",\"types\":[\"field\"]}"]],["ixvm_group_11",["IxVM::put_tagn0","IxVM::put_tagn4","IxVM::put_definition_proj","IxVM::convert_definition","IxVM::level_reduce","IxVM::compare_struct_fields","IxVM::try_unfold_head","IxVM::k_infer_lit","IxVM::list_any_mentions_block","IxVM::check_inductive_shape","${\"name\":\"IxVM::list_reverse\",\"types\":[\"field\"]}"]],["ixvm_group_12",["IxVM::put_tagn2","IxVM::univ_succ_base","IxVM::put_recursor_rule","IxVM::put_mut_const","UInt64::or","UInt64::xor","IxVM::defn_member_recur_addrs","IxVM::canon_cmp_member_ctx","IxVM::canon_sort_loop","IxVM::aux_already_in","IxVM::spec_params_dom_prefix_match","IxVM::addr_set_build","IxVM::env_walk_refs","IxVM::env_walk_leaves","IxVM::expr_addr","${\"name\":\"IxVM::rbtree_map_balance\",\"types\":[\"field\"]}"]],["ixvm_group_13",["IxVM::put_u64_list","IxVM::put_recursor_rule_list","IxVM::canon_g_list_eq","IxVM::canon_ctx_class_idx","IxVM::canon_cmp_kexpr_ctx","IxVM::canon_member_ci","IxVM::canon_member_num_ctors","IxVM::canon_refine_classes","IxVM::canon_group_consec","IxVM::level_list_struct_eq","IxVM::spec_params_ptr_eq","IxVM::flat_find_pos","IxVM::get_opt_rule_list_masked","IxVM::get_opt_ctor_entry_list_masked","${\"name\":\"IxVM::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}"]],["ixvm_group_14",["IxVM::put_quot_kind","IxVM::pack_def_kind_safety","IxVM::mk_nat_literal_64","IxVM::mk_nat_one","IxVM::char_of_nat_addr","IxVM::char_type_addr","IxVM::byte_array_empty_addr","IxVM::utf8_last_codepoint","IxVM::utf8_cont","IxVM::canon_ord_then","IxVM::canon_sord_then","IxVM::def_safety_tag","IxVM::check_opt_bool","IxVM::check_opt_recr_rules","IxVM::check_opt_ctor_entries","IxVM::run_contains"]],["ixvm_group_15",["IxVM::put_all_mode","IxVM::klimbs_shl","IxVM::np_whnf_inner_bv","IxVM::canon_addr_chunk","IxVM::canon_cmp_kliteral","IxVM::leaf_hash","IxVM::node_hash","IxVM::addr_set_member","IxVM::get_opt_u64_masked","IxVM::get_opt_addr_masked","IxVM::get_opt_bool_masked","IxVM::get_opt_def_kind_masked","IxVM::get_opt_quot_kind_masked","IxVM::check_opt_def_kind","IxVM::check_opt_def_safety","IxVM::check_opt_quot_kind"]],["ixvm_group_16",["IxVM::app_telescope_count","IxVM::lam_telescope_count","IxVM::all_telescope_count","IxVM::put_app_telescope","IxVM::put_lam_telescope","IxVM::put_all_telescope","IxVM::put_definition","IxVM::put_constructor","IxVM::put_inductive","IxVM::str_lit_delta_step","IxVM::canon_cmp_ctor_range_ctx","IxVM::canon_group_walk","IxVM::get_reveal_rule_list_inner","IxVM::check_recr_rules","${\"name\":\"IxVM::rbtree_map_lookup_or_default\",\"types\":[\"field\"]}","${\"name\":\"IxVM::rbtree_map_ins\",\"types\":[\"field\"]}"]],["ixvm_group_17",["IxVM::put_address","UInt64::mul","IxVM::try_reduce_decide_bitvec_lt","IxVM::try_nat_binop_addr","IxVM::build_rec_type_from","IxVM::check_recursor_canonical_full"]],["ixvm_group_18",["IxVM::univ_succ_count","IxVM::put_univ","IxVM::put_axiom","IxVM::put_quotient","IxVM::put_constructor_list","IxVM::put_mut_const_list","IxVM::klimbs_lor","IxVM::klimbs_xor_op","IxVM::canon_cmp_klimbs_tail","IxVM::extract_aux_occ_us","IxVM::detect_aux_from_recrs_ex","IxVM::get_ctor_entry","IxVM::check_ctor_entries","${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}","${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}","${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::RecursorRule\"}}]}"]],["ixvm_group_19",["IxVM::put_expr_list","IxVM::get_recursor_rule_list","IxVM::get_inductive","IxVM::canon_indc_positions","IxVM::check_block_peer_param_agreement","IxVM::flat_find_pos_kind","IxVM::build_rec_type","IxVM::build_flat_own_params","IxVM::build_all_minors_walk","IxVM::build_all_motives_walk","IxVM::const_idxs_muts","IxVM::list_length_u64.Ptr.U8_32"]],["ixvm_group_20",["IxVM::put_univ_list","IxVM::put_address_list","IxVM::put_sharing","IxVM::klimbs_dec","IxVM::mk_nat_offset_stuck","UInt64::from_field","IxVM::nlvars_eq","IxVM::se_scan_fields","IxVM::se_addr_in","IxVM::compute_iprj_addr","IxVM::flat_member_at","IxVM::collect_index_doms","IxVM::collect_n_doms_whnf","IxVM::wrap_lams","IxVM::is_rec_field_peel"]],["ixvm_group_21",["IxVM::put_recursor","IxVM::klimbs_scalar_value","IxVM::str_dec_eq_build","IxVM::canon_addr_cmp","IxVM::canon_cmp_member_same_kind_ctx","IxVM::canon_cmp_ctor_pair_ctx","IxVM::get_reveal_ctor_info","IxVM::get_ctor_entry_list_inner","IxVM::check_opt_expr_addr","IxVM::check_ctor_entry","IxVM::check_mut_const","IxVM::run_reveal"]],["ixvm_group_22",["IxVM::put_constant_info","IxVM::put_constant","IxVM::convert_inductive","IxVM::convert_constructor","IxVM::convert_recursor","IxVM::const_idxs_of","IxVM::check_muts_member_at"]],["ixvm_group_23",["IxVM::put_refs","IxVM::put_univs","IxVM::klimbs_le","IxVM::check_no_dep_data_field_if_prop","IxVM::assert_return_head_is_parent","IxVM::caddr_is_peer","IxVM::rec_to_parent_addr","IxVM::peel_motive_params_subst","IxVM::list_lift_indices","IxVM::build_peer_recs","IxVM::list_lift_each","IxVM::check_rec_major_spine","IxVM::get_opt_addr","IxVM::list_length.Tup.Ptr.U8_32.G.Ptr.ListNode.Ptr.KExprNode.Ptr.ListNode.Ptr.KLevelNode"]],["ixvm_group_24",["IxVM::read_byte","IxVM::klimbs_mul","IxVM::expr_inst1_bvar","IxVM::unfold_b_and_loop","IxVM::peel_n_foralls"]],["ixvm_group_25",["IxVM::get_tagn2","IxVM::get_constructor_proj","IxVM::level_max","IxVM::whnf_iota_major","IxVM::collect_spine_of_ctor"]],["ixvm_group_26",["IxVM::get_lam_telescope","IxVM::get_all_telescope"]],["ixvm_group_27",["IxVM::get_univ","IxVM::klimbs_sub_borrow","IxVM::try_same_proj_head_app"]],["ixvm_group_28",["IxVM::get_univ_list","IxVM::level_max_offsets","IxVM::projection_definition_info","IxVM::whnf_struct_core_proj","IxVM::slow2_eager_fallback","IxVM::lazy_delta_a_const_b_proj","IxVM::lazy_delta_b_const_a_proj"]],["ixvm_group_30",["IxVM::unpack_def_kind_safety","IxVM::assert_wire_bool","IxVM::defn_is_unsafe_ci","IxVM::lbr_dec","IxVM::delta_rank","IxVM::is_defn_or_thm","IxVM::is_unsafe_ci","IxVM::check_parent_inductive_shape","IxVM::build_all_motives","IxVM::build_all_minors","IxVM::build_ctor_app_params"]],["ixvm_group_31",["IxVM::get_definition","IxVM::cleanup_nat_offset_major","IxVM::convert_univ_idxs","IxVM::k_is_def_eq_slow2"]],["ixvm_group_32",["IxVM::get_axiom","IxVM::get_quotient","IxVM::bv_to_nat_via","IxVM::bitvec_of_nat_args_direct","IxVM::mk_int_prim","IxVM::klimbs_eq","IxVM::bitvec_prep_spine","IxVM::quot_extract_arg","IxVM::struct_block_member_addrs","IxVM::try_eta_expand","IxVM::check_eq_type"]],["ixvm_group_33",["IxVM::get_constructor_list","IxVM::get_mut_const_list","IxVM::load_verified_constant","IxVM::build_recur_addrs_walk","IxVM::check_muts_all"]],["ixvm_group_34",["IxVM::get_inductive_proj","IxVM::klimbs_is_zero","IxVM::k_is_def_eq_struct_safe","IxVM::try_eta_swap","IxVM::run_check"]],["ixvm_group_35",["IxVM::get_constant_info_by_variant","IxVM::run_check_transitive"]],["ixvm_group_36",["IxVM::klimbs_succ","IxVM::is_nat_succ_ih_step","IxVM::bytes_to_limbs","IxVM::convert_rec_rules","IxVM::nl_eq","IxVM::nlvars_dominates","IxVM::dec_dispatch_le_eq","IxVM::ctors_before_pos","IxVM::projection_addr_ctor"]],["ixvm_group_37",["UInt64::sub_with_borrow","IxVM::try_nat_offset_dispatch","IxVM::nl_covers_const","IxVM::normalize_int_dec_rebuild","IxVM::check_valid_ind_app","IxVM::is_large_eliminator","IxVM::compute_k_target","IxVM::build_motive_type_flat","IxVM::canonical_rules_at_pos","IxVM::build_rule_rhs","IxVM::check_recursor_member"]],["ixvm_group_38",["IxVM::glimbs_to_klimbs","IxVM::try_match_nat_add","IxVM::level_normalize","IxVM::level_max_go","IxVM::ctx_close_cut","IxVM::nat_lit_to_ctor_or_self"]],["ixvm_group_39",["IxVM::klimbs_sub","IxVM::skip_bytes","IxVM::level_explicit_val","IxVM::expr_has_bvar_at_let","IxVM::build_param_lvls_range","IxVM::build_major_params","IxVM::build_apply_xs","IxVM::apply_indices_in_conclusion","IxVM::count_foralls_body","IxVM::peel_leading_foralls","IxVM::build_rec_lvls_list","IxVM::check_rec_rules_wellscoped","IxVM::list_lookup_or_default.Ptr.U8_32"]],["ixvm_group_40",["IxVM::klimbs_div_mod","IxVM::klimbs_pow","IxVM::try_nat_linear_rec","IxVM::check_ctor_return_type","IxVM::check_inductive_shape_ctors","IxVM::peel_ctor_params_subst","IxVM::walk_fields_classify"]],["ixvm_group_41",["IxVM::klimbs_div","IxVM::klimbs_gcd","IxVM::klimbs_shr","IxVM::mk_bool","IxVM::try_quot_iota","IxVM::se_parent_addr","IxVM::struct_is_rec","IxVM::struct_scan_ctors","IxVM::intern_int_lit","IxVM::all_bvars_in_args","IxVM::args_contain_bvar"]],["ixvm_group_42",["UInt64::and","IxVM::klimbs_land","IxVM::try_reduce_subtype_val","IxVM::try_str_to_byte_array","IxVM::try_int_prim_second","IxVM::try_quot_lift","IxVM::k_synth_gate","IxVM::dec_finish","IxVM::canon_cprj_addr"]],["ixvm_group_43",["IxVM::nat_zero_addr","IxVM::nat_succ_addr_iota","IxVM::nat_pred_addr","IxVM::nat_sub_addr","IxVM::nat_xor_addr","IxVM::nat_shift_right_addr","IxVM::punit_size_of_1_addr","IxVM::reduce_bool_addr","IxVM::reduce_nat_addr","IxVM::string_utf8_byte_size_addr","IxVM::string_append_addr","IxVM::string_of_list_addr","IxVM::string_back_addr","IxVM::string_legacy_back_addr","IxVM::string_to_byte_array_addr","IxVM::string_dec_eq_addr"]],["ixvm_group_44",["IxVM::int_of_nat_addr","IxVM::int_neg_succ_addr_dec","IxVM::bool_true_addr","IxVM::bool_false_addr","IxVM::bit_vec_of_nat_addr","IxVM::bit_vec_addr","IxVM::lt_lt_addr","IxVM::decidable_rec_addr","IxVM::decidable_is_true_addr_dec","IxVM::decidable_is_false_addr_dec","IxVM::nat_le_of_ble_eq_true_addr_dec","IxVM::nat_eq_of_beq_eq_true_addr_dec","IxVM::nat_ne_of_beq_eq_false_addr_dec","IxVM::bool_type_addr_dec","IxVM::eq_refl_addr_dec","IxVM::eq_type_addr"]],["ixvm_group_45",["IxVM::int_add_addr","IxVM::int_mul_addr","IxVM::int_neg_addr","IxVM::int_emod_addr","IxVM::int_ediv_addr","IxVM::int_bmod_addr","IxVM::int_bdiv_addr","IxVM::int_nat_abs_addr","IxVM::int_pow_addr","IxVM::bit_vec_to_nat_addr","IxVM::bit_vec_ult_addr","IxVM::decidable_decide_addr","IxVM::fin_addr","IxVM::int_dec_eq_addr_dec","IxVM::int_dec_le_addr_dec","IxVM::int_dec_lt_addr_dec"]],["ixvm_group_46",["IxVM::int_sub_addr","IxVM::nat_add_addr","IxVM::nat_mul_addr","IxVM::nat_pow_addr","IxVM::nat_gcd_addr","IxVM::nat_mod_addr","IxVM::nat_div_addr","IxVM::nat_land_addr","IxVM::nat_lor_addr","IxVM::nat_shift_left_addr","IxVM::nat_beq_addr","IxVM::nat_ble_addr","IxVM::nat_addr_io","IxVM::nat_dec_le_addr_dec","IxVM::nat_dec_eq_addr_dec","IxVM::nat_dec_lt_addr_dec"]],["ixvm_group_47",["IxVM::system_platform_num_bits_addr","IxVM::subtype_val_addr","IxVM::mk_nat_lit","IxVM::build_recur_addrs","IxVM::level_eq","IxVM::nl_add_const","IxVM::check_prop_field_if_prop","IxVM::validate_univ_params_list","IxVM::check_param_agreement","IxVM::expr_mentions_block","IxVM::build_motive_apps","IxVM::is_rec_field"]],["ixvm_group_48",["IxVM::is_native_prim_addr","IxVM::nl_add_var","IxVM::expr_lbr_let","IxVM::expr_lift_bvar","IxVM::validate_univ_params_seen"]],["ixvm_group_49",["IxVM::try_native_dispatch","IxVM::try_str_dispatch","IxVM::str_lit_to_ctor","IxVM::nlvars_add","IxVM::nlvars_subsume"]],["ixvm_group_50",["IxVM::check_native_bool","IxVM::bitvec_prep_spine_ult","IxVM::build_char_list","IxVM::char_lit_codepoint_syn","IxVM::int_ediv_prim","IxVM::int_bmod_prim","IxVM::nlvars_max_offset","IxVM::nlvars_any_offset_geq","IxVM::canon_ord_cmp_g","IxVM::canon_cmp_krec_rule_list_ctx","IxVM::run_check_env"]],["ixvm_group_51",["IxVM::is_bitvec_prim_addr","IxVM::try_extract_nat_app","IxVM::nl_skip_empty","IxVM::whnf_get_ctor_or_none","IxVM::is_prop_type","IxVM::get_result_sort_level"]],["ixvm_group_52",["IxVM::try_reduce_bit_vec_ult","IxVM::try_str_back","IxVM::walk_char_list_bytes","IxVM::int_bdiv_prim","IxVM::try_quot_ind","IxVM::try_str_dec_eq","IxVM::canon_cmp_u64_lex","IxVM::canon_build_ctx_members","IxVM::canon_insert_sorted"]],["ixvm_group_53",["IxVM::try_bitvec_dispatch","IxVM::try_nat_binop_dispatch","IxVM::glist_cmp","IxVM::nl_add_const_go","IxVM::try_normalize_int_decidable","IxVM::try_dec_dispatch"]],["ixvm_group_54",["IxVM::list_nil_addr","IxVM::list_cons_addr","IxVM::nat_not_le_of_not_ble_eq_true_addr_dec","IxVM::canon_sord_lt_strong","IxVM::canon_sord_eq_strong","IxVM::canon_sord_gt_strong","IxVM::canon_sord_of_g"]],["ixvm_group_55",["IxVM::utf8_validate","IxVM::try_extract_nat","IxVM::glist_eq_len","IxVM::normalize_aux","IxVM::assert_lvls_are_params","IxVM::check_field_universes","IxVM::addr_list_contains","IxVM::wrap_foralls","${\"name\":\"IxVM::list_reverse_acc\",\"types\":[\"field\"]}"]],["ixvm_group_56",["IxVM::utf8_decode_one","IxVM::is_int_prim_addr","IxVM::try_int_prim_dispatch","IxVM::glist_ordered_insert","IxVM::try_iota","IxVM::check_positivity_aug"]],["ixvm_group_57",["IxVM::str_lit_to_ctor_app_or_self","IxVM::level_offset_of","IxVM::ctx_next_cut"]],["ixvm_group_58",["IxVM::klimbs_from_g","IxVM::canon_cmp_kuniv_list","IxVM::canon_cmp_bytes","IxVM::kexpr_struct_eq","IxVM::parse_atree_body"]],["ixvm_group_59",["IxVM::utf8_encode_prepend","IxVM::get_ci_dprj","IxVM::aux_from_recrs_walk_ex","IxVM::find_peer_rec_spec_walk","IxVM::get_reveal_mut_const_info","IxVM::get_reveal_info","${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}"]],["ixvm_group_60",["IxVM::try_extract_int_prim","IxVM::literal_eq","IxVM::is_int_dec_prim_addr","IxVM::try_extract_int","IxVM::check_quot","IxVM::check_nested_ctors_positivity","IxVM::check_large_walk_fields","IxVM::subst_param_for","IxVM::ctor_subst_param_for"]],["ixvm_group_61",["IxVM::int_add_prim","IxVM::normalize_imax_dispatch","IxVM::has_bvar_in_range_let","IxVM::expr_lift_let","IxVM::apply_n_projs","IxVM::se_peel_tol","IxVM::se_mentions","IxVM::count_foralls_at_least","IxVM::check_large_prop_ctor"]],["ixvm_group_62",["IxVM::int_emod_prim","IxVM::canon_ctx_cmp_addr","IxVM::canon_cmp_kuniv","IxVM::canon_cmp_klimbs","IxVM::canon_build_ctx_classes","IxVM::canon_classes_eq","IxVM::extract_aux_spec_params","IxVM::spec_params_lower","IxVM::apply_spec_params_lifted","IxVM::list_snoc.Tup.Ptr.U8_32.G.Ptr.ListNode.Ptr.KExprNode.Ptr.ListNode.Ptr.KLevelNode"]],["ixvm_group_63",["IxVM::build_succ_offset","IxVM::try_k_synth_iota","IxVM::lazy_delta_step_const_const","IxVM::try_lazy_delta_app","IxVM::dec_rewrite_lt_to_le","IxVM::dec_build_proof","IxVM::compare_rules","IxVM::apply_ihs_full","IxVM::build_minor_at_depth","IxVM::build_ih_doms"]],["ixvm_group_64",["IxVM::convert_univ","IxVM::nl_le_vars","IxVM::level_imax","IxVM::expr_glb_let","IxVM::replace_spine_major","IxVM::k_is_def_eq_slow_nd_after_core","IxVM::check_param_agreement_go","IxVM::check_field_universes_inner"]],["ixvm_group_65",["IxVM::level_is_not_zero","IxVM::nl_subsumption_walk","IxVM::level_inst_params","IxVM::whnf_spine","IxVM::try_proof_irrel"]],["ixvm_group_66",["IxVM::glist_subset","IxVM::nl_subsume_entry","IxVM::try_nat_dispatch_prewhnf","IxVM::try_struct_eta_iota","IxVM::k_infer_proj"]],["ixvm_group_67",["IxVM::nl_covers_var","IxVM::nl_le","IxVM::level_leq","IxVM::find_rule","IxVM::ensure_sort_only","IxVM::level_list_eq","IxVM::unfold_both_and_loop","IxVM::is_inductive_prop","IxVM::peel_field_loop","IxVM::peel_n_lams_collect","${\"name\":\"IxVM::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::KRecRule\"}}]}"]],["ixvm_group_68",["IxVM::level_equal","IxVM::expr_inst1_let","IxVM::expr_inst_many_let","IxVM::k_is_def_eq_struct_go","IxVM::check_positivity_fields","IxVM::check_positivity","IxVM::build_apply_field_bvars"]],["ixvm_group_69",["IxVM::level_struct_eq","IxVM::peel_params_subst","IxVM::k_is_def_eq_structure_tree_app","IxVM::peel_n_alls_whnf"]],["ixvm_group_70",["IxVM::level_max_subsumes","IxVM::k_is_def_eq_slow","IxVM::k_is_def_eq_structure_tree"]],["ixvm_group_71",["IxVM::level_list_inst","IxVM::k_is_def_eq_slow_nd","IxVM::try_unit_like"]],["ixvm_group_72",["IxVM::has_bvar_in_range_binder","IxVM::k_is_def_eq_struct","IxVM::assert_safety"]],["ixvm_group_73",["IxVM::ctx_seek_cut","IxVM::try_unfold_proj_app"]],["ixvm_group_74",["IxVM::ctx_trim","IxVM::try_reduce_projection_definition"]],["ixvm_group_75",["IxVM::expr_has_bvar_at_binder","IxVM::k_is_def_eq_ordered"]],["ixvm_group_76",["IxVM::whnf_proj_head","IxVM::whnf_nd_proj_head"]],["ixvm_group_77",["IxVM::try_reduce_fin_val_decidable_rec","IxVM::prim_family"]],["ixvm_group_78",["IxVM::whnf_struct_core_const","IxVM::k_is_def_eq_struct_spend"]],["ixvm_group_79",["IxVM::const_num_lvls","IxVM::const_type_of"]],["ixvm_group_80",["IxVM::k_infer_only","IxVM::try_eta_struct"]],["ixvm_group_81",["IxVM::k_is_def_eq_core","IxVM::try_def_eq_nat"]],["ixvm_group_82",["IxVM::slow2_after_delta","IxVM::unfold_a_and_loop","IxVM::lazy_delta_both_proj","IxVM::assert_first_args_are_param_bvars","IxVM::check_field_universes_skip_params","IxVM::peel_n_foralls_with_types"]]],"representatives":[["IxVM::verify_claim","IxVM::verify_claim"],["IxVM::run_claim","IxVM::run_claim"],["IxVM::read_finite_byte_stream","IxVM::read_finite_byte_stream"],["IxVM::read_byte_stream","IxVM::read_byte_stream"],["${\"name\":\"IxVM::list_depth_checked\",\"types\":[\"field\"]}","${\"name\":\"IxVM::list_depth_checked\",\"types\":[\"field\"]}"],["IxVM::checked_depth_succ","IxVM::checked_depth_succ"],["UInt32::less_than_fields","UInt32::less_than_fields"],["Blake3::compress_layer","Blake3::compress_layer"],["Blake3::next_layer","Blake3::next_layer"],["Blake3::compress","Blake3::compress"],["Blake3::compress_chunks","Blake3::compress_chunks"],["Blake3::finish","Blake3::finish"],["UInt64::is_zero","UInt64::is_zero"],["Blake3::bytes_to_block","Blake3::bytes_to_block"],["Blake3::pad_block","Blake3::pad_block"],["Blake3::compress_block","Blake3::compress_block"],["${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}","${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}"],["UInt64::wrapping_succ","UInt64::wrapping_succ"],["IxVM::get_tagn4","IxVM::get_tagn4"],["IxVM::get_tagn_tail","IxVM::get_tagn_tail"],["IxVM::get_tagn_wide","IxVM::get_tagn_wide"],["IxVM::get_u64_le","IxVM::get_u64_le"],["UInt64::add","UInt64::add"],["IxVM::read_byte","IxVM::read_byte"],["IxVM::get_address","IxVM::get_address"],["IxVM::get_opt_addr","IxVM::get_opt_addr"],["IxVM::run_eval","IxVM::run_eval"],["IxVM::run_check","IxVM::run_check"],["IxVM::get_ci","IxVM::get_ci"],["IxVM::load_verified_constant","IxVM::load_verified_constant"],["Blake3::verify_bytes_against","Blake3::verify_bytes_against"],["IxVM::get_constant","IxVM::get_constant"],["IxVM::get_mut_const_list","IxVM::get_mut_const_list"],["IxVM::get_mut_const","IxVM::get_mut_const"],["IxVM::get_definition","IxVM::get_definition"],["IxVM::unpack_def_kind_safety","IxVM::unpack_def_kind_safety"],["IxVM::get_tagn0","IxVM::get_tagn0"],["IxVM::get_expr","IxVM::get_expr"],["IxVM::get_u64_list","IxVM::get_u64_list"],["UInt64::saturating_pred","UInt64::saturating_pred"],["IxVM::get_app_telescope","IxVM::get_app_telescope"],["IxVM::get_lam_telescope","IxVM::get_lam_telescope"],["IxVM::get_lam_mode","IxVM::get_lam_mode"],["IxVM::binder_contract_from_bits","IxVM::binder_contract_from_bits"],["IxVM::value_contract_from_bits","IxVM::value_contract_from_bits"],["IxVM::get_all_telescope","IxVM::get_all_telescope"],["IxVM::get_all_mode","IxVM::get_all_mode"],["IxVM::get_expr_let","IxVM::get_expr_let"],["IxVM::get_inductive","IxVM::get_inductive"],["IxVM::assert_wire_bool","IxVM::assert_wire_bool"],["IxVM::get_constructor_list","IxVM::get_constructor_list"],["IxVM::get_constructor","IxVM::get_constructor"],["IxVM::get_recursor","IxVM::get_recursor"],["IxVM::get_recursor_rule_list","IxVM::get_recursor_rule_list"],["IxVM::get_constant_info_by_variant","IxVM::get_constant_info_by_variant"],["IxVM::get_axiom","IxVM::get_axiom"],["IxVM::get_quotient","IxVM::get_quotient"],["IxVM::get_quot_kind","IxVM::get_quot_kind"],["IxVM::get_constructor_proj","IxVM::get_constructor_proj"],["IxVM::get_recursor_proj","IxVM::get_recursor_proj"],["IxVM::get_inductive_proj","IxVM::get_recursor_proj"],["IxVM::get_definition_proj","IxVM::get_recursor_proj"],["IxVM::get_expr_list","IxVM::get_expr_list"],["IxVM::get_address_list","IxVM::get_address_list"],["IxVM::get_univ_list","IxVM::get_univ_list"],["IxVM::get_univ","IxVM::get_univ"],["IxVM::get_tagn2","IxVM::get_tagn2"],["IxVM::build_succ_chain","IxVM::build_succ_chain"],["IxVM::load_constant_hint","IxVM::load_constant_hint"],["IxVM::defn_is_unsafe_ci","IxVM::defn_is_unsafe_ci"],["IxVM::convert_definition","IxVM::convert_definition"],["IxVM::convert_expr","IxVM::convert_expr"],["${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}","${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}"],["${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}","${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}"],["UInt64::to_field","UInt64::to_field"],["IxVM::convert_univ","IxVM::convert_univ"],["${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}}]}","${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}"],["${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}}]}","${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}"],["IxVM::convert_univ_idxs","IxVM::convert_univ_idxs"],["IxVM::load_verified_blob","IxVM::load_verified_blob"],["IxVM::utf8_validate","IxVM::utf8_validate"],["IxVM::utf8_decode_one","IxVM::utf8_decode_one"],["IxVM::utf8_cont","IxVM::utf8_cont"],["IxVM::bytes_to_limbs","IxVM::bytes_to_limbs"],["IxVM::bytes_to_u64_limb","IxVM::bytes_to_u64_limb"],["IxVM::skip_bytes","IxVM::skip_bytes"],["${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Expr\"}}}}]}","${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}"],["IxVM::convert_axiom","IxVM::convert_axiom"],["IxVM::convert_quotient","IxVM::convert_quotient"],["IxVM::get_ci_dprj","IxVM::get_ci_dprj"],["${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}","${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}"],["IxVM::defn_member_recur_addrs","IxVM::defn_member_recur_addrs"],["IxVM::build_recur_addrs","IxVM::build_recur_addrs"],["IxVM::build_recur_addrs_walk","IxVM::build_recur_addrs_walk"],["IxVM::projection_addr","IxVM::projection_addr"],["IxVM::muts_member_at","IxVM::muts_member_at"],["UInt64::from_field","UInt64::from_field"],["IxVM::put_constant","IxVM::put_constant"],["IxVM::put_sharing","IxVM::put_sharing"],["${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Expr\"}}}}]}","${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Expr\"}}}}]}"],["IxVM::put_tagn0","IxVM::put_tagn0"],["IxVM::put_tagn_tail","IxVM::put_tagn_tail"],["IxVM::put_tagn_wide","IxVM::put_tagn_wide"],["IxVM::put_u64_le","IxVM::put_u64_le"],["IxVM::put_expr_list","IxVM::put_expr_list"],["IxVM::put_expr","IxVM::put_expr"],["IxVM::put_tagn4","IxVM::put_tagn4"],["${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}","${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}"],["IxVM::put_u64_list","IxVM::put_u64_list"],["IxVM::app_telescope_count","IxVM::app_telescope_count"],["IxVM::put_app_telescope","IxVM::put_app_telescope"],["IxVM::lam_telescope_count","IxVM::lam_telescope_count"],["IxVM::put_lam_telescope","IxVM::put_lam_telescope"],["IxVM::put_lam_mode","IxVM::put_lam_mode"],["IxVM::binder_contract_code","IxVM::binder_contract_code"],["IxVM::value_contract_code","IxVM::value_contract_code"],["IxVM::all_telescope_count","IxVM::all_telescope_count"],["IxVM::put_all_telescope","IxVM::put_all_telescope"],["IxVM::put_all_mode","IxVM::put_all_mode"],["IxVM::put_refs","IxVM::put_refs"],["${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}}]}","${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Expr\"}}}}]}"],["IxVM::put_address_list","IxVM::put_address_list"],["IxVM::put_address","IxVM::put_address"],["IxVM::put_univs","IxVM::put_univs"],["${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}","${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Expr\"}}}}]}"],["IxVM::put_univ_list","IxVM::put_univ_list"],["IxVM::put_univ","IxVM::put_univ"],["IxVM::univ_succ_count","IxVM::univ_succ_count"],["IxVM::univ_succ_base","IxVM::univ_succ_base"],["IxVM::put_tagn2","IxVM::put_tagn2"],["${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}","${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}"],["IxVM::put_mut_const_list","IxVM::put_mut_const_list"],["IxVM::put_mut_const","IxVM::put_mut_const"],["IxVM::put_definition","IxVM::put_definition"],["IxVM::pack_def_kind_safety","IxVM::pack_def_kind_safety"],["IxVM::put_inductive","IxVM::put_inductive"],["${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}","${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}"],["IxVM::put_constructor_list","IxVM::put_constructor_list"],["IxVM::put_constructor","IxVM::put_constructor"],["IxVM::put_recursor","IxVM::put_recursor"],["${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::RecursorRule\"}}]}","${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::RecursorRule\"}}]}"],["IxVM::put_recursor_rule_list","IxVM::put_recursor_rule_list"],["IxVM::put_recursor_rule","IxVM::put_recursor_rule"],["IxVM::put_constant_info","IxVM::put_constant_info"],["IxVM::put_axiom","IxVM::put_axiom"],["IxVM::put_quotient","IxVM::put_quotient"],["IxVM::put_quot_kind","IxVM::put_quot_kind"],["IxVM::put_constructor_proj","IxVM::put_constructor_proj"],["IxVM::put_recursor_proj","IxVM::put_recursor_proj"],["IxVM::put_inductive_proj","IxVM::put_recursor_proj"],["IxVM::put_definition_proj","IxVM::put_recursor_proj"],["Blake3::bytes_to_addr","Blake3::bytes_to_addr"],["IxVM::get_ci_iprj","IxVM::get_ci_iprj"],["IxVM::convert_inductive","IxVM::convert_inductive"],["IxVM::count_ctors","IxVM::count_ctors"],["IxVM::get_ci_cprj","IxVM::get_ci_cprj"],["IxVM::ctor_at","IxVM::ctor_at"],["IxVM::convert_constructor","IxVM::convert_constructor"],["IxVM::get_ci_rprj","IxVM::get_ci_rprj"],["IxVM::convert_recursor","IxVM::convert_recursor"],["IxVM::convert_rec_rules","IxVM::convert_rec_rules"],["IxVM::check_const","IxVM::check_const"],["IxVM::is_unsafe_ci","IxVM::is_unsafe_ci"],["IxVM::validate_expr_well_scoped","IxVM::validate_expr_well_scoped"],["IxVM::validate_univ_params_seen","IxVM::validate_univ_params_seen"],["IxVM::const_num_lvls","IxVM::const_num_lvls"],["${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}","${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}"],["IxVM::validate_univ_params_list","IxVM::validate_univ_params_list"],["IxVM::k_ensure_sort","IxVM::k_ensure_sort"],["IxVM::k_infer","IxVM::k_infer"],["IxVM::expr_lbr","IxVM::expr_lbr"],["IxVM::lbr_max","IxVM::lbr_max"],["IxVM::lbr_dec","IxVM::lbr_dec"],["IxVM::expr_lbr_let","IxVM::expr_lbr_let"],["IxVM::k_infer_core","IxVM::k_infer_core"],["IxVM::types_lookup","IxVM::types_lookup"],["${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}","${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}"],["${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}","${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}"],["IxVM::expr_lift","IxVM::expr_lift"],["IxVM::expr_lift_walk","IxVM::expr_lift_walk"],["IxVM::expr_lift_bvar","IxVM::expr_lift_bvar"],["IxVM::expr_lift_let","IxVM::expr_lift_let"],["IxVM::level_reduce","IxVM::level_reduce"],["IxVM::level_max","IxVM::level_max"],["IxVM::level_explicit_val","IxVM::level_explicit_val"],["IxVM::level_max_go","IxVM::level_max_go"],["IxVM::level_struct_eq","IxVM::level_struct_eq"],["IxVM::level_max_subsumes","IxVM::level_max_subsumes"],["IxVM::level_max_offsets","IxVM::level_max_offsets"],["IxVM::level_offset_of","IxVM::level_offset_of"],["IxVM::level_imax","IxVM::level_imax"],["IxVM::level_is_not_zero","IxVM::level_is_not_zero"],["IxVM::level_eq","IxVM::level_struct_eq"],["IxVM::const_type_of","IxVM::const_type_of"],["IxVM::expr_inst_levels","IxVM::expr_inst_levels"],["IxVM::expr_inst_levels_walk","IxVM::expr_inst_levels_walk"],["IxVM::level_inst_params","IxVM::level_inst_params"],["${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}","${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}"],["${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}","${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}"],["IxVM::level_list_inst","IxVM::level_list_inst"],["IxVM::collect_spine","IxVM::collect_spine"],["${\"name\":\"IxVM::list_snoc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}","${\"name\":\"IxVM::list_snoc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}"],["IxVM::k_infer_app_spine_loop","IxVM::k_infer_app_spine_loop"],["${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}","${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}"],["IxVM::expr_inst_many","IxVM::expr_inst_many"],["IxVM::has_bvar_in_range","IxVM::has_bvar_in_range"],["IxVM::has_bvar_in_range_binder","IxVM::has_bvar_in_range_binder"],["IxVM::has_bvar_in_range_let","IxVM::has_bvar_in_range_let"],["IxVM::expr_inst_many_walk","IxVM::expr_inst_many_walk"],["IxVM::expr_inst_many_bvar","IxVM::expr_inst_many_bvar"],["IxVM::expr_inst_many_let","IxVM::expr_inst_many_let"],["IxVM::expr_lower","IxVM::expr_lower"],["IxVM::expr_lower_walk","IxVM::expr_lower_walk"],["IxVM::k_check","IxVM::k_check"],["IxVM::k_is_def_eq","IxVM::k_is_def_eq"],["IxVM::k_is_def_eq_core","IxVM::k_is_def_eq_core"],["IxVM::k_is_def_eq_ordered","IxVM::k_is_def_eq_ordered"],["IxVM::try_def_eq_app","IxVM::try_def_eq_app"],["IxVM::de_args","IxVM::de_args"],["IxVM::address_eq","IxVM::address_eq"],["IxVM::address_eq_tail","IxVM::address_eq_tail"],["IxVM::level_list_eq","IxVM::level_list_eq"],["IxVM::level_equal","IxVM::level_equal"],["IxVM::nl_eq","IxVM::nl_eq"],["IxVM::nl_skip_empty","IxVM::nl_skip_empty"],["IxVM::glist_cmp","IxVM::glist_cmp"],["IxVM::nlvars_eq","IxVM::nlvars_eq"],["IxVM::level_normalize","IxVM::level_normalize"],["IxVM::normalize_aux","IxVM::normalize_aux"],["IxVM::nl_add_const","IxVM::nl_add_const"],["IxVM::nl_add_const_go","IxVM::nl_add_const_go"],["IxVM::normalize_imax_dispatch","IxVM::normalize_imax_dispatch"],["IxVM::glist_ordered_insert","IxVM::glist_ordered_insert"],["IxVM::nl_add_var","IxVM::nl_add_var"],["IxVM::nlvars_add","IxVM::nlvars_add"],["IxVM::nl_subsumption_walk","IxVM::nl_subsumption_walk"],["IxVM::nl_subsume_entry","IxVM::nl_subsume_entry"],["IxVM::glist_subset","IxVM::glist_subset"],["IxVM::glist_eq_len","IxVM::glist_eq_len"],["IxVM::nlvars_max_offset","IxVM::nlvars_max_offset"],["IxVM::nlvars_subsume","IxVM::nlvars_subsume"],["IxVM::k_is_def_eq_slow","IxVM::k_is_def_eq_slow"],["IxVM::try_string_lit_one","IxVM::try_string_lit_one"],["IxVM::str_lit_delta_step","IxVM::str_lit_delta_step"],["IxVM::whnf_nd","IxVM::whnf_nd"],["IxVM::whnf_nd_with_spine","IxVM::whnf_nd_with_spine"],["${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}","${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}"],["IxVM::whnf_nd_apply_beta","IxVM::whnf_nd_apply_beta"],["IxVM::peel_beta","IxVM::peel_beta"],["IxVM::apply_spine","IxVM::apply_spine"],["IxVM::expr_inst1","IxVM::expr_inst1"],["IxVM::expr_has_bvar_at","IxVM::expr_has_bvar_at"],["IxVM::expr_has_bvar_at_binder","IxVM::expr_has_bvar_at_binder"],["IxVM::expr_has_bvar_at_let","IxVM::expr_has_bvar_at_let"],["IxVM::expr_inst1_walk","IxVM::expr_inst1_walk"],["IxVM::expr_inst1_bvar","IxVM::expr_inst1_bvar"],["IxVM::expr_inst1_let","IxVM::expr_inst1_let"],["IxVM::whnf_nd_const_head","IxVM::whnf_nd_const_head"],["IxVM::prim_family","IxVM::prim_family"],["IxVM::nat_succ_addr","IxVM::nat_succ_addr"],["IxVM::nat_pred_addr","IxVM::nat_pred_addr"],["IxVM::nat_add_addr","IxVM::nat_add_addr"],["IxVM::nat_sub_addr","IxVM::nat_sub_addr"],["IxVM::nat_mul_addr","IxVM::nat_mul_addr"],["IxVM::nat_div_addr","IxVM::nat_div_addr"],["IxVM::nat_mod_addr","IxVM::nat_mod_addr"],["IxVM::nat_pow_addr","IxVM::nat_pow_addr"],["IxVM::nat_gcd_addr","IxVM::nat_gcd_addr"],["IxVM::nat_beq_addr","IxVM::nat_beq_addr"],["IxVM::nat_ble_addr","IxVM::nat_ble_addr"],["IxVM::nat_land_addr","IxVM::nat_land_addr"],["IxVM::nat_lor_addr","IxVM::nat_lor_addr"],["IxVM::nat_xor_addr","IxVM::nat_xor_addr"],["IxVM::nat_shift_left_addr","IxVM::nat_shift_left_addr"],["IxVM::nat_shift_right_addr","IxVM::nat_shift_right_addr"],["IxVM::is_str_prim_addr","IxVM::is_str_prim_addr"],["IxVM::string_utf8_byte_size_addr","IxVM::string_utf8_byte_size_addr"],["IxVM::string_append_addr","IxVM::string_append_addr"],["IxVM::string_of_list_addr","IxVM::string_of_list_addr"],["IxVM::string_back_addr","IxVM::string_back_addr"],["IxVM::string_legacy_back_addr","IxVM::string_legacy_back_addr"],["IxVM::string_to_byte_array_addr","IxVM::string_to_byte_array_addr"],["IxVM::string_dec_eq_addr","IxVM::string_dec_eq_addr"],["IxVM::is_bitvec_prim_addr","IxVM::is_bitvec_prim_addr"],["IxVM::bit_vec_to_nat_addr","IxVM::bit_vec_to_nat_addr"],["IxVM::bit_vec_ult_addr","IxVM::bit_vec_ult_addr"],["IxVM::decidable_decide_addr","IxVM::decidable_decide_addr"],["IxVM::is_native_prim_addr","IxVM::is_native_prim_addr"],["IxVM::system_platform_num_bits_addr","IxVM::system_platform_num_bits_addr"],["IxVM::punit_size_of_1_addr","IxVM::punit_size_of_1_addr"],["IxVM::reduce_bool_addr","IxVM::reduce_bool_addr"],["IxVM::reduce_nat_addr","IxVM::reduce_nat_addr"],["IxVM::subtype_val_addr","IxVM::subtype_val_addr"],["IxVM::is_dec_prim_addr","IxVM::is_dec_prim_addr"],["IxVM::nat_dec_le_addr_dec","IxVM::nat_dec_le_addr_dec"],["IxVM::nat_dec_eq_addr_dec","IxVM::nat_dec_eq_addr_dec"],["IxVM::nat_dec_lt_addr_dec","IxVM::nat_dec_lt_addr_dec"],["IxVM::int_dec_le_addr_dec","IxVM::int_dec_le_addr_dec"],["IxVM::int_dec_eq_addr_dec","IxVM::int_dec_eq_addr_dec"],["IxVM::int_dec_lt_addr_dec","IxVM::int_dec_lt_addr_dec"],["IxVM::is_int_prim_addr","IxVM::is_int_prim_addr"],["IxVM::int_add_addr","IxVM::int_add_addr"],["IxVM::int_sub_addr","IxVM::int_sub_addr"],["IxVM::int_mul_addr","IxVM::int_mul_addr"],["IxVM::int_neg_addr","IxVM::int_neg_addr"],["IxVM::int_emod_addr","IxVM::int_emod_addr"],["IxVM::int_ediv_addr","IxVM::int_ediv_addr"],["IxVM::int_bmod_addr","IxVM::int_bmod_addr"],["IxVM::int_bdiv_addr","IxVM::int_bdiv_addr"],["IxVM::int_nat_abs_addr","IxVM::int_nat_abs_addr"],["IxVM::int_pow_addr","IxVM::int_pow_addr"],["IxVM::try_prim_dispatch","IxVM::try_prim_dispatch"],["IxVM::try_nat_dispatch_prewhnf","IxVM::try_nat_dispatch_prewhnf"],["IxVM::whnf_spine","IxVM::whnf_spine"],["IxVM::whnf","IxVM::whnf"],["IxVM::whnf_with_spine","IxVM::whnf_with_spine"],["IxVM::whnf_apply_beta","IxVM::whnf_apply_beta"],["IxVM::whnf_const_head","IxVM::whnf_const_head"],["IxVM::try_reduce_projection_definition","IxVM::try_reduce_projection_definition"],["IxVM::projection_definition_info","IxVM::projection_definition_info"],["IxVM::try_quot_iota","IxVM::try_quot_iota"],["IxVM::quot_lift_addr_iota","IxVM::quot_lift_addr_iota"],["IxVM::try_quot_lift","IxVM::try_quot_lift"],["IxVM::quot_extract_arg","IxVM::quot_extract_arg"],["IxVM::quot_ctor_addr_iota","IxVM::quot_ctor_addr_iota"],["IxVM::quot_ind_addr_iota","IxVM::quot_ind_addr_iota"],["IxVM::try_quot_ind","IxVM::try_quot_ind"],["IxVM::se_parent_addr","IxVM::se_parent_addr"],["IxVM::try_k_synth_iota","IxVM::try_k_synth_iota"],["IxVM::k_synth_gate","IxVM::k_synth_gate"],["IxVM::canon_cprj_addr","IxVM::canon_cprj_addr"],["${\"name\":\"IxVM::list_take\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}","${\"name\":\"IxVM::list_take\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}"],["IxVM::try_iota","IxVM::try_iota"],["IxVM::try_nat_linear_rec","IxVM::try_nat_linear_rec"],["IxVM::try_extract_nat","IxVM::try_extract_nat"],["IxVM::nat_zero_addr","IxVM::nat_zero_addr"],["IxVM::try_extract_nat_app","IxVM::try_extract_nat_app"],["IxVM::klimbs_succ","IxVM::klimbs_succ"],["IxVM::is_nat_succ_ih_step","IxVM::is_nat_succ_ih_step"],["IxVM::np_apply_spine","IxVM::apply_spine"],["IxVM::mk_nat_lit","IxVM::mk_nat_lit"],["IxVM::klimbs_add","IxVM::klimbs_add"],["IxVM::klimbs_add_carry","IxVM::klimbs_add_carry"],["IxVM::mk_nat_offset_stuck","IxVM::mk_nat_offset_stuck"],["IxVM::klimbs_is_zero","IxVM::klimbs_is_zero"],["IxVM::klimbs_normalize","IxVM::klimbs_normalize"],["IxVM::cleanup_nat_offset_major","IxVM::cleanup_nat_offset_major"],["IxVM::try_match_nat_add","IxVM::try_match_nat_add"],["IxVM::build_succ_offset","IxVM::build_succ_offset"],["IxVM::klimbs_sub","IxVM::klimbs_sub"],["IxVM::klimbs_sub_borrow","IxVM::klimbs_sub_borrow"],["UInt64::sub_with_borrow","UInt64::sub_with_borrow"],["IxVM::whnf_iota_major","IxVM::whnf_iota_major"],["IxVM::nat_lit_to_ctor_or_self","IxVM::nat_lit_to_ctor_or_self"],["IxVM::nat_zero_addr_iota","IxVM::nat_zero_addr"],["IxVM::klimbs_dec","IxVM::klimbs_dec"],["IxVM::nat_succ_addr_iota","IxVM::nat_succ_addr"],["IxVM::collect_spine_of_ctor","IxVM::collect_spine_of_ctor"],["IxVM::compute_iprj_addr","IxVM::compute_iprj_addr"],["IxVM::find_rule","IxVM::find_rule"],["IxVM::replace_spine_major","IxVM::replace_spine_major"],["IxVM::rec_to_parent_addr","IxVM::rec_to_parent_addr"],["IxVM::peel_n_foralls","IxVM::peel_n_foralls"],["IxVM::try_struct_eta_iota","IxVM::try_struct_eta_iota"],["IxVM::struct_is_rec","IxVM::struct_is_rec"],["IxVM::struct_block_member_addrs","IxVM::struct_block_member_addrs"],["IxVM::struct_scan_ctors","IxVM::struct_scan_ctors"],["IxVM::se_peel_tol","IxVM::se_peel_tol"],["IxVM::se_scan_fields","IxVM::se_scan_fields"],["IxVM::se_mentions","IxVM::se_mentions"],["IxVM::se_addr_in","IxVM::se_addr_in"],["IxVM::is_prop_type","IxVM::is_prop_type"],["IxVM::k_infer_only","IxVM::k_infer_only"],["IxVM::io_const_num_lvls","IxVM::const_num_lvls"],["IxVM::io_const_type_of","IxVM::const_type_of"],["IxVM::ensure_sort_only","IxVM::ensure_sort_only"],["IxVM::nat_addr_io","IxVM::nat_addr_io"],["IxVM::str_addr_io","IxVM::str_addr_io"],["IxVM::io_peel_params_subst","IxVM::io_peel_params_subst"],["IxVM::io_peel_field_loop","IxVM::io_peel_field_loop"],["IxVM::ctx_trim","IxVM::ctx_trim"],["IxVM::ctx_seek_cut","IxVM::ctx_seek_cut"],["IxVM::ctx_next_cut","IxVM::ctx_next_cut"],["IxVM::ctx_close_cut","IxVM::ctx_close_cut"],["IxVM::lbr_min","IxVM::lbr_min"],["IxVM::apply_n_projs","IxVM::apply_n_projs"],["IxVM::whnf_proj_head","IxVM::whnf_proj_head"],["IxVM::str_lit_to_ctor_app_or_self","IxVM::str_lit_to_ctor_app_or_self"],["IxVM::str_lit_to_ctor","IxVM::str_lit_to_ctor"],["IxVM::list_nil_addr","IxVM::list_nil_addr"],["IxVM::list_cons_addr","IxVM::list_cons_addr"],["IxVM::char_type_addr","IxVM::char_type_addr"],["IxVM::char_of_nat_addr","IxVM::char_of_nat_addr"],["IxVM::build_char_list","IxVM::build_char_list"],["IxVM::klimbs_from_g","IxVM::klimbs_from_g"],["IxVM::split_u32","IxVM::split_u32"],["IxVM::divmod_256","IxVM::divmod_256"],["IxVM::try_reduce_fin_val_decidable_rec","IxVM::try_reduce_fin_val_decidable_rec"],["IxVM::fin_addr","IxVM::fin_addr"],["IxVM::decidable_rec_addr","IxVM::decidable_rec_addr"],["IxVM::nat_ty_addr","IxVM::nat_addr_io"],["IxVM::whnf_get_ctor_or_none","IxVM::whnf_get_ctor_or_none"],["IxVM::try_nat_binop_dispatch","IxVM::try_nat_binop_dispatch"],["IxVM::try_nat_binop_addr","IxVM::try_nat_binop_addr"],["IxVM::klimbs_mul","IxVM::klimbs_mul"],["IxVM::klimbs_mul_outer","IxVM::klimbs_mul_outer"],["IxVM::klimbs_mul_single","IxVM::klimbs_mul_single"],["UInt64::mul","UInt64::mul"],["IxVM::klimbs_shl_limbs","IxVM::klimbs_shl_limbs"],["IxVM::klimbs_div","IxVM::klimbs_div"],["IxVM::klimbs_div_mod","IxVM::klimbs_div_mod"],["IxVM::ordinary_div_mod","IxVM::ordinary_div_mod"],["IxVM::divide_grow","IxVM::divide_grow"],["IxVM::klimbs_le","IxVM::klimbs_le"],["IxVM::klimbs_eq","IxVM::klimbs_eq"],["UInt64::eq","UInt64::eq"],["IxVM::klimbs_mod","IxVM::klimbs_mod"],["IxVM::klimbs_gcd","IxVM::klimbs_gcd"],["IxVM::klimbs_pow","IxVM::klimbs_pow"],["IxVM::klimbs_land","IxVM::klimbs_land"],["UInt64::and","UInt64::and"],["IxVM::klimbs_lor","IxVM::klimbs_lor"],["UInt64::or","UInt64::or"],["IxVM::klimbs_xor_op","IxVM::klimbs_xor_op"],["UInt64::xor","UInt64::xor"],["IxVM::klimbs_shl","IxVM::klimbs_shl"],["IxVM::klimbs_shr","IxVM::klimbs_shr"],["IxVM::mk_bool","IxVM::mk_bool"],["IxVM::bool_false_addr","IxVM::bool_false_addr"],["IxVM::bool_true_addr","IxVM::bool_true_addr"],["IxVM::try_nat_offset_dispatch","IxVM::try_nat_offset_dispatch"],["IxVM::mk_nat_binop_stuck","IxVM::mk_nat_binop_stuck"],["IxVM::try_str_dispatch","IxVM::try_str_dispatch"],["IxVM::walk_char_list_bytes","IxVM::walk_char_list_bytes"],["IxVM::char_lit_codepoint","IxVM::char_lit_codepoint"],["IxVM::char_lit_codepoint_syn","IxVM::char_lit_codepoint_syn"],["IxVM::klimbs_scalar_value","IxVM::klimbs_scalar_value"],["IxVM::utf8_encode_prepend","IxVM::utf8_encode_prepend"],["IxVM::utf8_groups","IxVM::utf8_groups"],["IxVM::divmod_64u","IxVM::divmod_64u"],["${\"name\":\"IxVM::list_length\",\"types\":[\"field\"]}","${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}"],["IxVM::try_str_back","IxVM::try_str_back"],["IxVM::utf8_last_codepoint","IxVM::utf8_last_codepoint"],["IxVM::utf8_last_go","IxVM::utf8_last_go"],["IxVM::try_str_to_byte_array","IxVM::try_str_to_byte_array"],["IxVM::byte_array_empty_addr","IxVM::byte_array_empty_addr"],["IxVM::try_str_dec_eq","IxVM::try_str_dec_eq"],["IxVM::bytestream_eq","IxVM::bytestream_eq"],["IxVM::str_dec_eq_build","IxVM::str_dec_eq_build"],["IxVM::eq_refl_addr_dec","IxVM::eq_refl_addr_dec"],["IxVM::string_type_addr","IxVM::str_addr_io"],["IxVM::decidable_is_true_addr_dec","IxVM::decidable_is_true_addr_dec"],["${\"name\":\"IxVM::list_concat\",\"types\":[\"field\"]}","${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}"],["IxVM::try_bitvec_dispatch","IxVM::try_bitvec_dispatch"],["IxVM::bitvec_prep_spine","IxVM::bitvec_prep_spine"],["IxVM::bv_to_nat_via","IxVM::bv_to_nat_via"],["IxVM::bitvec_of_nat_args_direct","IxVM::bitvec_of_nat_args_direct"],["IxVM::bit_vec_of_nat_addr","IxVM::bit_vec_of_nat_addr"],["IxVM::bitvec_prep_spine_ult","IxVM::bitvec_prep_spine_ult"],["IxVM::np_whnf_inner_bv","IxVM::np_whnf_inner_bv"],["IxVM::try_reduce_bit_vec_ult","IxVM::try_reduce_bit_vec_ult"],["IxVM::try_reduce_decide_bitvec_lt","IxVM::try_reduce_decide_bitvec_lt"],["IxVM::lt_lt_addr","IxVM::lt_lt_addr"],["IxVM::bit_vec_addr","IxVM::bit_vec_addr"],["IxVM::try_native_dispatch","IxVM::try_native_dispatch"],["IxVM::mk_nat_literal_64","IxVM::mk_nat_literal_64"],["IxVM::mk_nat_one","IxVM::mk_nat_one"],["IxVM::try_reduce_subtype_val","IxVM::try_reduce_subtype_val"],["IxVM::system_platform_get_num_bits_addr","IxVM::system_platform_get_num_bits_addr"],["IxVM::check_native_bool","IxVM::check_native_bool"],["IxVM::check_native_nat","IxVM::check_native_nat"],["IxVM::try_dec_dispatch","IxVM::try_dec_dispatch"],["IxVM::is_int_dec_prim_addr","IxVM::is_int_dec_prim_addr"],["IxVM::try_normalize_int_decidable","IxVM::try_normalize_int_decidable"],["IxVM::try_extract_int","IxVM::try_extract_int"],["IxVM::int_of_nat_addr_dec","IxVM::int_of_nat_addr_dec"],["IxVM::int_neg_succ_addr_dec","IxVM::int_neg_succ_addr_dec"],["IxVM::normalize_int_dec_rebuild","IxVM::normalize_int_dec_rebuild"],["IxVM::intern_int_lit","IxVM::intern_int_lit"],["IxVM::dec_rewrite_lt_to_le","IxVM::dec_rewrite_lt_to_le"],["IxVM::dec_dispatch_le_eq","IxVM::dec_dispatch_le_eq"],["IxVM::dec_build_proof","IxVM::dec_build_proof"],["IxVM::bool_type_addr_dec","IxVM::bool_type_addr_dec"],["IxVM::nat_le_of_ble_eq_true_addr_dec","IxVM::nat_le_of_ble_eq_true_addr_dec"],["IxVM::nat_not_le_of_not_ble_eq_true_addr_dec","IxVM::nat_not_le_of_not_ble_eq_true_addr_dec"],["IxVM::nat_eq_of_beq_eq_true_addr_dec","IxVM::nat_eq_of_beq_eq_true_addr_dec"],["IxVM::nat_ne_of_beq_eq_false_addr_dec","IxVM::nat_ne_of_beq_eq_false_addr_dec"],["IxVM::dec_finish","IxVM::dec_finish"],["IxVM::decidable_is_false_addr_dec","IxVM::decidable_is_false_addr_dec"],["IxVM::try_int_prim_dispatch","IxVM::try_int_prim_dispatch"],["IxVM::try_extract_int_prim","IxVM::try_extract_int_prim"],["IxVM::int_of_nat_addr","IxVM::int_of_nat_addr_dec"],["IxVM::int_neg_succ_addr","IxVM::int_neg_succ_addr_dec"],["IxVM::mk_int_prim","IxVM::mk_int_prim"],["IxVM::try_int_prim_second","IxVM::try_int_prim_second"],["IxVM::int_bmod_prim","IxVM::int_bmod_prim"],["IxVM::int_bdiv_prim","IxVM::int_bdiv_prim"],["IxVM::int_add_prim","IxVM::int_add_prim"],["IxVM::int_emod_prim","IxVM::int_emod_prim"],["IxVM::int_ediv_prim","IxVM::int_ediv_prim"],["IxVM::whnf_nd_proj_head","IxVM::whnf_nd_proj_head"],["IxVM::k_is_def_eq_slow_nd","IxVM::k_is_def_eq_slow_nd"],["IxVM::whnf_struct_core","IxVM::whnf_struct_core"],["IxVM::whnf_struct_core_spine","IxVM::whnf_struct_core_spine"],["IxVM::whnf_struct_core_proj","IxVM::whnf_struct_core_proj"],["IxVM::whnf_struct_core_const","IxVM::whnf_struct_core_const"],["IxVM::k_is_def_eq_struct_safe","IxVM::k_is_def_eq_struct_safe"],["IxVM::k_is_def_eq_slow_nd_after_core","IxVM::k_is_def_eq_slow_nd_after_core"],["IxVM::k_is_def_eq_slow2","IxVM::k_is_def_eq_slow2"],["IxVM::try_proof_irrel","IxVM::try_proof_irrel"],["IxVM::try_unit_like","IxVM::try_unit_like"],["IxVM::is_unit_like_type","IxVM::is_unit_like_type"],["IxVM::try_eta_struct","IxVM::try_eta_struct"],["IxVM::compare_struct_fields","IxVM::compare_struct_fields"],["IxVM::try_def_eq_nat","IxVM::try_def_eq_nat"],["IxVM::is_nat_zero","IxVM::is_nat_zero"],["IxVM::nat_offset_of","IxVM::nat_offset_of"],["IxVM::lazy_delta_loop","IxVM::lazy_delta_loop"],["IxVM::head_addr","IxVM::head_addr"],["IxVM::lazy_delta_step_const_const","IxVM::lazy_delta_step_const_const"],["IxVM::is_defn_or_thm","IxVM::is_defn_or_thm"],["IxVM::unfold_b_and_loop","IxVM::unfold_b_and_loop"],["IxVM::delta_unfold","IxVM::delta_unfold"],["IxVM::unfold_a_and_loop","IxVM::unfold_a_and_loop"],["IxVM::delta_rank","IxVM::delta_rank"],["IxVM::unfold_both_and_loop","IxVM::unfold_both_and_loop"],["IxVM::lazy_delta_a_const_b_proj","IxVM::lazy_delta_a_const_b_proj"],["IxVM::try_unfold_proj_app","IxVM::try_unfold_proj_app"],["IxVM::try_unfold_head","IxVM::try_unfold_head"],["IxVM::lazy_delta_b_const_a_proj","IxVM::lazy_delta_b_const_a_proj"],["IxVM::lazy_delta_both_proj","IxVM::lazy_delta_both_proj"],["IxVM::slow2_after_delta","IxVM::slow2_after_delta"],["IxVM::k_is_def_eq_struct_bounded","IxVM::k_is_def_eq_struct_bounded"],["IxVM::k_is_def_eq_struct_spend","IxVM::k_is_def_eq_struct_spend"],["IxVM::literal_eq","IxVM::literal_eq"],["IxVM::k_is_def_eq_structure_tree","IxVM::k_is_def_eq_structure_tree"],["IxVM::try_same_proj_head_app","IxVM::try_same_proj_head_app"],["IxVM::k_is_def_eq_structure_tree_app","IxVM::k_is_def_eq_structure_tree_app"],["IxVM::slow2_eager_fallback","IxVM::slow2_eager_fallback"],["IxVM::try_eta_swap","IxVM::try_eta_swap"],["IxVM::try_eta_expand","IxVM::try_eta_expand"],["IxVM::k_is_def_eq_struct","IxVM::k_is_def_eq_struct"],["IxVM::k_is_def_eq_struct_go","IxVM::k_is_def_eq_struct_go"],["IxVM::try_lazy_delta_app","IxVM::try_lazy_delta_app"],["IxVM::k_def_eq_rebase","IxVM::k_def_eq_rebase"],["IxVM::expr_glb","IxVM::expr_glb"],["IxVM::expr_glb_walk","IxVM::expr_glb_walk"],["IxVM::expr_glb_binder","IxVM::expr_glb_binder"],["IxVM::expr_glb_let","IxVM::expr_glb_let"],["IxVM::k_infer_let_start","IxVM::k_infer_let_start"],["IxVM::k_infer_let_env","IxVM::k_infer_let_env"],["IxVM::infer_let_local_cutoff","IxVM::infer_let_local_cutoff"],["IxVM::k_infer_let_env_core","IxVM::k_infer_let_env_core"],["IxVM::infer_let_lookup_type","IxVM::infer_let_lookup_type"],["IxVM::infer_let_materialize","IxVM::infer_let_materialize"],["IxVM::infer_let_lookup_value","IxVM::infer_let_lookup_value"],["IxVM::k_infer_let_env_rebase","IxVM::k_infer_let_env_rebase"],["IxVM::infer_let_drop_unused","IxVM::infer_let_drop_unused"],["IxVM::k_infer_lit","IxVM::k_infer_lit"],["IxVM::nat_addr","IxVM::nat_addr_io"],["IxVM::str_addr","IxVM::str_addr_io"],["IxVM::k_infer_proj","IxVM::k_infer_proj"],["IxVM::peel_params_subst","IxVM::io_peel_params_subst"],["IxVM::is_inductive_prop","IxVM::is_inductive_prop"],["IxVM::peel_n_alls_whnf","IxVM::peel_n_alls_whnf"],["IxVM::peel_field_loop","IxVM::peel_field_loop"],["IxVM::check_prop_field_if_prop","IxVM::check_prop_field_if_prop"],["IxVM::check_no_dep_data_field_if_prop","IxVM::check_no_dep_data_field_if_prop"],["IxVM::k_infer_rebase","IxVM::k_infer_rebase"],["IxVM::assert_safety","IxVM::assert_safety"],["IxVM::safe_refs_only","IxVM::safe_refs_only"],["IxVM::check_quot","IxVM::check_quot"],["IxVM::quot_type_addr","IxVM::quot_type_addr"],["IxVM::quot_ctor_addr","IxVM::quot_ctor_addr_iota"],["IxVM::quot_lift_addr","IxVM::quot_lift_addr_iota"],["IxVM::check_eq_type","IxVM::check_eq_type"],["IxVM::eq_type_addr","IxVM::eq_type_addr"],["IxVM::quot_ind_addr","IxVM::quot_ind_addr_iota"],["IxVM::count_foralls_at_least","IxVM::count_foralls_at_least"],["IxVM::check_canonical_block","IxVM::check_canonical_block"],["IxVM::canon_muts_has_kind","IxVM::canon_muts_has_kind"],["IxVM::canon_indc_positions","IxVM::canon_indc_positions"],["IxVM::canon_sort_loop","IxVM::canon_sort_loop"],["IxVM::canon_build_ctx_classes","IxVM::canon_build_ctx_classes"],["IxVM::canon_build_ctx_members","IxVM::canon_build_ctx_members"],["IxVM::canon_member_num_ctors","IxVM::canon_member_num_ctors"],["IxVM::canon_member_ci","IxVM::canon_member_ci"],["IxVM::canon_ctor_ctx_entries","IxVM::canon_ctor_ctx_entries"],["${\"name\":\"IxVM::list_concat\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\"]}}]}","${\"name\":\"IxVM::list_concat\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\"]}}]}"],["${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[\"field\"],\"name\":\"Lists::Node\"}}}}]}","${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}"],["IxVM::canon_refine_classes","IxVM::canon_refine_classes"],["IxVM::canon_refine_one","IxVM::canon_refine_one"],["IxVM::canon_ins_sort","IxVM::canon_ins_sort"],["IxVM::canon_insert_sorted","IxVM::canon_insert_sorted"],["IxVM::canon_cmp_member_ctx","IxVM::canon_cmp_member_ctx"],["IxVM::canon_ord_cmp_g","IxVM::canon_ord_cmp_g"],["IxVM::canon_kind_ord","IxVM::canon_kind_ord"],["IxVM::canon_cmp_member_same_kind_ctx","IxVM::canon_cmp_member_same_kind_ctx"],["IxVM::canon_sord_then","IxVM::canon_sord_then"],["IxVM::canon_sord_of_g","IxVM::canon_sord_of_g"],["IxVM::canon_cmp_kexpr_ctx","IxVM::canon_cmp_kexpr_ctx"],["IxVM::canon_cmp_kexpr_node_ctx","IxVM::canon_cmp_kexpr_node_ctx"],["IxVM::canon_sord_lt_strong","IxVM::canon_sord_lt_strong"],["IxVM::canon_sord_gt_strong","IxVM::canon_sord_gt_strong"],["IxVM::canon_cmp_kuniv","IxVM::canon_cmp_kuniv"],["IxVM::canon_ord_then","IxVM::canon_ord_then"],["IxVM::canon_cmp_kuniv_list","IxVM::canon_cmp_kuniv_list"],["IxVM::canon_ctx_cmp_addr","IxVM::canon_ctx_cmp_addr"],["IxVM::canon_sord_eq_strong","IxVM::canon_sord_eq_strong"],["IxVM::canon_ctx_class_idx","IxVM::canon_ctx_class_idx"],["IxVM::canon_addr_cmp","IxVM::canon_addr_cmp"],["IxVM::canon_addr_chunk","IxVM::canon_addr_chunk"],["IxVM::canon_cmp_kliteral","IxVM::canon_cmp_kliteral"],["IxVM::canon_cmp_klimbs","IxVM::canon_cmp_klimbs"],["${\"name\":\"IxVM::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}","${\"name\":\"IxVM::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}"],["IxVM::canon_cmp_klimbs_tail","IxVM::canon_cmp_klimbs_tail"],["IxVM::canon_cmp_u64_lex","IxVM::canon_cmp_u64_lex"],["IxVM::canon_cmp_bytes","IxVM::canon_cmp_bytes"],["IxVM::canon_cmp_ctor_range_ctx","IxVM::canon_cmp_ctor_range_ctx"],["IxVM::canon_cmp_ctor_pair_ctx","IxVM::canon_cmp_ctor_pair_ctx"],["IxVM::canon_cmp_krec_rule_list_ctx","IxVM::canon_cmp_krec_rule_list_ctx"],["IxVM::canon_cmp_krec_rule_ctx","IxVM::canon_cmp_krec_rule_ctx"],["IxVM::canon_group_consec","IxVM::canon_group_consec"],["IxVM::canon_group_walk","IxVM::canon_group_walk"],["${\"name\":\"IxVM::list_snoc\",\"types\":[\"field\"]}","${\"name\":\"IxVM::list_snoc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}"],["${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[\"field\"],\"name\":\"Lists::Node\"}}}}]}","${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}"],["IxVM::canon_classes_eq","IxVM::canon_classes_eq"],["IxVM::canon_g_list_eq","IxVM::bytestream_eq"],["IxVM::canon_all_singleton","IxVM::canon_all_singleton"],["IxVM::canon_flatten","IxVM::canon_flatten"],["IxVM::check_inductive_shape","IxVM::check_inductive_shape"],["IxVM::get_result_sort_level","IxVM::get_result_sort_level"],["IxVM::check_inductive_shape_ctors","IxVM::check_inductive_shape_ctors"],["IxVM::check_param_agreement","IxVM::check_param_agreement"],["IxVM::check_param_agreement_go","IxVM::check_param_agreement_go"],["IxVM::check_ctor_return_type","IxVM::check_ctor_return_type"],["IxVM::assert_return_head_is_parent","IxVM::assert_return_head_is_parent"],["IxVM::assert_lvls_are_params","IxVM::assert_lvls_are_params"],["IxVM::assert_first_args_are_param_bvars","IxVM::assert_first_args_are_param_bvars"],["IxVM::list_any_mentions_block","IxVM::list_any_mentions_block"],["IxVM::expr_mentions_block","IxVM::expr_mentions_block"],["IxVM::caddr_is_peer","IxVM::caddr_is_peer"],["IxVM::addr_list_contains","IxVM::addr_list_contains"],["IxVM::check_field_universes","IxVM::check_field_universes"],["IxVM::check_field_universes_skip_params","IxVM::check_field_universes_skip_params"],["IxVM::check_field_universes_inner","IxVM::check_field_universes_inner"],["IxVM::level_leq","IxVM::level_leq"],["IxVM::nl_le","IxVM::nl_le"],["IxVM::nl_covers_const","IxVM::nl_covers_const"],["IxVM::nlvars_any_offset_geq","IxVM::nlvars_any_offset_geq"],["IxVM::nl_le_vars","IxVM::nl_le_vars"],["IxVM::nl_covers_var","IxVM::nl_covers_var"],["IxVM::nlvars_dominates","IxVM::nlvars_dominates"],["IxVM::check_positivity","IxVM::check_positivity"],["IxVM::peel_n_foralls_with_types","IxVM::peel_n_foralls_with_types"],["IxVM::check_positivity_fields","IxVM::check_positivity_fields"],["IxVM::check_positivity_aug","IxVM::check_positivity_aug"],["IxVM::check_valid_ind_app","IxVM::check_valid_ind_app"],["IxVM::assert_occ_param_bvars","IxVM::assert_occ_param_bvars"],["${\"name\":\"IxVM::list_reverse\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}","${\"name\":\"IxVM::list_reverse\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}"],["${\"name\":\"IxVM::list_reverse_acc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}","${\"name\":\"IxVM::list_reverse_acc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}"],["IxVM::check_nested_ctors_positivity","IxVM::check_nested_ctors_positivity"],["IxVM::check_block_peer_param_agreement","IxVM::check_block_peer_param_agreement"],["IxVM::peer_agree_walk","IxVM::peer_agree_walk"],["IxVM::check_recursor_member","IxVM::check_recursor_member"],["IxVM::is_muts_block","IxVM::is_muts_block"],["${\"name\":\"IxVM::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::KRecRule\"}}]}","${\"name\":\"IxVM::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::KRecRule\"}}]}"],["IxVM::check_rec_rules_wellscoped","IxVM::check_rec_rules_wellscoped"],["IxVM::check_rec_major_spine","IxVM::check_rec_major_spine"],["IxVM::compute_k_target","IxVM::compute_k_target"],["IxVM::ind_is_solo","IxVM::ind_is_solo"],["IxVM::muts_indc_count_is_one","IxVM::muts_indc_count_is_one"],["IxVM::check_parent_inductive_shape","IxVM::check_parent_inductive_shape"],["IxVM::check_recursor_canonical_full","IxVM::check_recursor_canonical_full"],["IxVM::is_large_eliminator","IxVM::is_large_eliminator"],["IxVM::check_large_prop_ctor","IxVM::check_large_prop_ctor"],["IxVM::check_large_walk_fields","IxVM::check_large_walk_fields"],["IxVM::all_bvars_in_args","IxVM::all_bvars_in_args"],["IxVM::args_contain_bvar","IxVM::args_contain_bvar"],["IxVM::build_rec_lvls_list","IxVM::build_rec_lvls_list"],["IxVM::build_flat_block","IxVM::build_flat_block"],["IxVM::first_recr_parent_block","IxVM::first_recr_parent_block"],["IxVM::flat_originals_walk","IxVM::flat_originals_walk"],["IxVM::build_param_lvls_range","IxVM::build_param_lvls_range"],["IxVM::detect_aux_from_recrs_ex","IxVM::detect_aux_from_recrs_ex"],["IxVM::aux_from_recrs_walk_ex","IxVM::aux_from_recrs_walk_ex"],["IxVM::extract_aux_spec_params_from_rec","IxVM::extract_aux_spec_params_from_rec"],["IxVM::extract_aux_spec_params","IxVM::extract_aux_spec_params"],["IxVM::spec_params_lower","IxVM::spec_params_lower"],["IxVM::extract_aux_occ_us","IxVM::extract_aux_occ_us"],["IxVM::aux_already_in","IxVM::aux_already_in"],["IxVM::spec_params_ptr_eq","IxVM::spec_params_ptr_eq"],["IxVM::kexpr_struct_eq","IxVM::kexpr_struct_eq"],["IxVM::level_list_struct_eq","IxVM::level_list_struct_eq"],["${\"name\":\"IxVM::list_snoc\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}","${\"name\":\"IxVM::list_snoc\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}"],["IxVM::build_peer_recs","IxVM::build_peer_recs"],["IxVM::find_peer_recursor_with_spec","IxVM::find_peer_recursor_with_spec"],["IxVM::find_peer_rec_spec_walk","IxVM::find_peer_rec_spec_walk"],["IxVM::build_flat_own_params","IxVM::build_flat_own_params"],["IxVM::flat_find_pos_kind","IxVM::flat_find_pos_kind"],["IxVM::canonical_rules_at_pos","IxVM::canonical_rules_at_pos"],["IxVM::flat_member_at","IxVM::flat_member_at"],["IxVM::build_rec_type","IxVM::build_rec_type"],["IxVM::build_rec_type_from","IxVM::build_rec_type_from"],["${\"name\":\"IxVM::list_length\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}","${\"name\":\"IxVM::list_length\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}"],["IxVM::collect_n_doms_whnf","IxVM::collect_n_doms_whnf"],["IxVM::build_all_motives","IxVM::build_all_motives"],["IxVM::build_all_motives_walk","IxVM::build_all_motives_walk"],["IxVM::build_motive_type_flat","IxVM::build_motive_type_flat"],["IxVM::peel_motive_params_subst","IxVM::peel_motive_params_subst"],["IxVM::subst_param_for","IxVM::subst_param_for"],["IxVM::collect_index_doms","IxVM::collect_index_doms"],["IxVM::build_major_params","IxVM::build_major_params"],["IxVM::apply_spec_params_lifted","IxVM::apply_spec_params_lifted"],["IxVM::build_major_indices","IxVM::build_major_indices"],["IxVM::wrap_foralls","IxVM::wrap_foralls"],["IxVM::build_all_minors","IxVM::build_all_minors"],["IxVM::build_all_minors_walk","IxVM::build_all_minors_walk"],["IxVM::build_minor_doms","IxVM::build_minor_doms"],["IxVM::projection_addr_ctor","IxVM::projection_addr_ctor"],["IxVM::build_minor_at_depth","IxVM::build_minor_at_depth"],["IxVM::peel_ctor_params_subst","IxVM::peel_ctor_params_subst"],["IxVM::ctor_subst_param_for","IxVM::ctor_subst_param_for"],["IxVM::walk_fields_classify","IxVM::walk_fields_classify"],["IxVM::is_rec_field","IxVM::is_rec_field"],["IxVM::is_rec_field_peel","IxVM::is_rec_field_peel"],["IxVM::flat_find_matching","IxVM::flat_find_matching"],["IxVM::spec_params_dom_prefix_match","IxVM::spec_params_dom_prefix_match"],["${\"name\":\"IxVM::list_reverse\",\"types\":[\"field\"]}","${\"name\":\"IxVM::list_reverse\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}"],["${\"name\":\"IxVM::list_reverse_acc\",\"types\":[\"field\"]}","${\"name\":\"IxVM::list_reverse_acc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}"],["IxVM::list_lift_each","IxVM::list_lift_each"],["IxVM::apply_spine_expr","IxVM::apply_spine"],["IxVM::build_ctor_app_params","IxVM::build_ctor_app_params"],["IxVM::build_apply_bvars_decreasing","IxVM::build_apply_bvars_decreasing"],["IxVM::build_apply_field_bvars","IxVM::build_apply_field_bvars"],["IxVM::build_ih_doms","IxVM::build_ih_doms"],["${\"name\":\"IxVM::list_lookup_or_default\",\"types\":[\"field\"]}","${\"name\":\"IxVM::list_lookup_or_default\",\"types\":[\"field\"]}"],["${\"name\":\"IxVM::list_drop\",\"types\":[\"field\"]}","${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}"],["IxVM::peel_leading_foralls","IxVM::peel_leading_foralls"],["IxVM::peel_leading_foralls_acc","IxVM::peel_leading_foralls_acc"],["IxVM::build_apply_xs","IxVM::build_major_indices"],["IxVM::list_lift_indices","IxVM::list_lift_indices"],["IxVM::apply_indices_in_conclusion","IxVM::apply_indices_in_conclusion"],["IxVM::ctors_before_pos","IxVM::ctors_before_pos"],["IxVM::populate_rules","IxVM::populate_rules"],["IxVM::build_rule_rhs","IxVM::build_rule_rhs"],["IxVM::count_foralls_body","IxVM::count_foralls_body"],["IxVM::apply_ihs_full","IxVM::apply_ihs_full"],["${\"name\":\"IxVM::list_lookup_or_default\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}}]}","${\"name\":\"IxVM::list_lookup_or_default\",\"types\":[\"field\"]}"],["IxVM::build_motive_apps","IxVM::build_apply_bvars_decreasing"],["IxVM::build_minor_apps","IxVM::build_apply_bvars_decreasing"],["IxVM::wrap_lams","IxVM::wrap_lams"],["IxVM::compare_rules","IxVM::compare_rules"],["IxVM::peel_n_lams_collect","IxVM::peel_n_lams_collect"],["IxVM::flat_find_pos","IxVM::flat_find_pos"],["IxVM::run_check_transitive","IxVM::run_check_transitive"],["IxVM::check_muts_all","IxVM::check_muts_all"],["IxVM::check_muts_member_at","IxVM::check_muts_member_at"],["IxVM::walk_refs_transitive","IxVM::walk_refs_transitive"],["IxVM::g_list_has","IxVM::g_list_has"],["IxVM::const_idxs_of","IxVM::const_idxs_of"],["IxVM::const_idxs_exprs","IxVM::const_idxs_exprs"],["IxVM::const_idxs_expr","IxVM::const_idxs_expr"],["IxVM::const_idxs_rules","IxVM::const_idxs_rules"],["IxVM::const_idxs_muts","IxVM::const_idxs_muts"],["IxVM::const_idxs_ctors","IxVM::const_idxs_ctors"],["IxVM::addr_set_build","IxVM::addr_set_build"],["${\"name\":\"IxVM::rbtree_map_insert\",\"types\":[\"field\"]}","${\"name\":\"IxVM::rbtree_map_insert\",\"types\":[\"field\"]}"],["${\"name\":\"IxVM::rbtree_map_ins\",\"types\":[\"field\"]}","${\"name\":\"IxVM::rbtree_map_ins\",\"types\":[\"field\"]}"],["${\"name\":\"IxVM::rbtree_map_balance\",\"types\":[\"field\"]}","${\"name\":\"IxVM::rbtree_map_balance\",\"types\":[\"field\"]}"],["${\"name\":\"IxVM::rbtree_map_balance_fix\",\"types\":[\"field\"]}","${\"name\":\"IxVM::rbtree_map_balance_fix\",\"types\":[\"field\"]}"],["IxVM::load_assumption_tree","IxVM::load_assumption_tree"],["IxVM::parse_atree_body","IxVM::parse_atree_body"],["IxVM::leaf_hash","IxVM::leaf_hash"],["IxVM::node_hash","IxVM::node_hash"],["${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}}]}","${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}"],["IxVM::addr_set_member","IxVM::addr_set_member"],["${\"name\":\"IxVM::rbtree_map_lookup_or_default\",\"types\":[\"field\"]}","${\"name\":\"IxVM::rbtree_map_lookup_or_default\",\"types\":[\"field\"]}"],["IxVM::env_walk","IxVM::env_walk"],["IxVM::env_walk_refs","IxVM::env_walk_refs"],["IxVM::eval_body","IxVM::eval_body"],["IxVM::eval_output","IxVM::eval_output"],["IxVM::eval_nf","IxVM::eval_nf"],["IxVM::eval_nf_spine","IxVM::eval_nf_spine"],["IxVM::run_check_env","IxVM::run_check_env"],["IxVM::walk_leaves_owned","IxVM::walk_leaves_owned"],["IxVM::check_owned","IxVM::check_owned"],["IxVM::env_walk_all","IxVM::env_walk_all"],["IxVM::env_walk_refs_all","IxVM::env_walk_refs_all"],["IxVM::env_walk_leaves","IxVM::env_walk_leaves"],["IxVM::get_reveal_info","IxVM::get_reveal_info"],["IxVM::get_opt_def_kind_masked","IxVM::get_opt_def_kind_masked"],["IxVM::get_opt_def_safety_masked","IxVM::get_opt_def_kind_masked"],["IxVM::get_opt_u64_masked","IxVM::get_opt_u64_masked"],["IxVM::get_opt_addr_masked","IxVM::get_opt_addr_masked"],["IxVM::get_opt_bool_masked","IxVM::get_opt_bool_masked"],["IxVM::get_opt_rule_list_masked","IxVM::get_opt_rule_list_masked"],["IxVM::get_reveal_rule_list_inner","IxVM::get_reveal_rule_list_inner"],["IxVM::get_reveal_rule","IxVM::get_constructor_proj"],["IxVM::get_opt_quot_kind_masked","IxVM::get_opt_quot_kind_masked"],["IxVM::get_mut_entry_list_inner","IxVM::get_mut_entry_list_inner"],["IxVM::get_mut_entry","IxVM::get_mut_entry"],["IxVM::get_reveal_mut_const_info","IxVM::get_reveal_mut_const_info"],["IxVM::get_opt_ctor_entry_list_masked","IxVM::get_opt_ctor_entry_list_masked"],["IxVM::get_ctor_entry_list_inner","IxVM::get_ctor_entry_list_inner"],["IxVM::get_ctor_entry","IxVM::get_ctor_entry"],["IxVM::get_reveal_ctor_info","IxVM::get_reveal_ctor_info"],["IxVM::run_reveal","IxVM::run_reveal"],["IxVM::check_opt_def_kind","IxVM::check_opt_def_kind"],["IxVM::def_kind_tag","IxVM::def_kind_tag"],["IxVM::check_opt_def_safety","IxVM::check_opt_def_kind"],["IxVM::def_safety_tag","IxVM::def_kind_tag"],["IxVM::check_opt_u64","IxVM::check_opt_u64"],["IxVM::check_opt_expr_addr","IxVM::check_opt_expr_addr"],["IxVM::expr_addr","IxVM::expr_addr"],["IxVM::check_opt_bool","IxVM::check_opt_bool"],["IxVM::check_opt_recr_rules","IxVM::check_opt_recr_rules"],["IxVM::check_recr_rules","IxVM::check_recr_rules"],["IxVM::check_opt_quot_kind","IxVM::check_opt_quot_kind"],["IxVM::quot_kind_tag","IxVM::get_quot_kind"],["IxVM::check_opt_addr","IxVM::check_opt_addr"],["IxVM::check_muts_components","IxVM::check_muts_components"],["IxVM::check_mut_const","IxVM::check_mut_const"],["IxVM::check_opt_ctor_entries","IxVM::check_opt_ctor_entries"],["IxVM::check_ctor_entries","IxVM::check_ctor_entries"],["IxVM::check_ctor_entry","IxVM::check_ctor_entry"],["${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}","${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}"],["IxVM::run_contains","IxVM::run_contains"],["UInt8::from_field","UInt8::from_field"],["UInt8::raw_bit_decomposition","UInt8::raw_bit_decomposition"],["UInt8::range_pair","UInt8::range_pair"],["UInt8::raw_xor","UInt8::raw_xor"],["UInt8::raw_add","UInt8::raw_add"],["UInt8::raw_sub","UInt8::raw_sub"],["UInt8::raw_mul","UInt8::raw_mul"],["UInt8::raw_xor_split4","UInt8::raw_xor_split4"],["UInt8::raw_xor_split7","UInt8::raw_xor_split7"],["UInt8::raw_sum_byte","UInt8::raw_sum_byte"]]} \ No newline at end of file diff --git a/docs/benchmarks/formal-aiur-grouping-tuning/ixvm-policy.json b/docs/benchmarks/formal-aiur-grouping-tuning/ixvm-policy.json new file mode 100644 index 000000000..f064ca20c --- /dev/null +++ b/docs/benchmarks/formal-aiur-grouping-tuning/ixvm-policy.json @@ -0,0 +1,1311 @@ +[ + [ + "ixvm_group_00", + [ + "IxVM::run_claim", + "Blake3::next_layer", + "IxVM::get_recursor", + "IxVM::get_ci_dprj", + "${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}", + "IxVM::projection_addr", + "IxVM::muts_member_at", + "IxVM::put_expr_list", + "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}", + "IxVM::put_recursor", + "IxVM::get_ci_iprj", + "IxVM::get_ci_rprj", + "IxVM::build_flat_block", + "IxVM::first_recr_parent_block", + "IxVM::aux_from_recrs_walk_ex", + "IxVM::run_check_transitive" + ] + ], + [ + "ixvm_group_01", + [ + "IxVM::read_finite_byte_stream", + "IxVM::get_address_list" + ] + ], + [ + "ixvm_group_02", + [ + "IxVM::read_byte_stream", + "IxVM::checked_depth_succ" + ] + ], + [ + "ixvm_group_03", + [ + "${\"name\":\"IxVM::list_depth_checked\",\"types\":[\"field\"]}", + "Blake3::pad_block" + ] + ], + [ + "ixvm_group_04", + [ + "Blake3::compress_layer", + "IxVM::whnf_apply_beta", + "IxVM::env_walk_all" + ] + ], + [ + "ixvm_group_05", + [ + "Blake3::finish", + "IxVM::convert_inductive", + "IxVM::get_ci_cprj", + "IxVM::expr_lift_bvar", + "IxVM::walk_leaves_owned", + "IxVM::check_muts_components" + ] + ], + [ + "ixvm_group_06", + [ + "UInt64::is_zero", + "IxVM::is_unsafe_ci" + ] + ], + [ + "ixvm_group_07", + [ + "Blake3::bytes_to_block", + "IxVM::k_infer_only", + "IxVM::head_addr" + ] + ], + [ + "ixvm_group_08", + [ + "Blake3::compress_block", + "IxVM::check_owned" + ] + ], + [ + "ixvm_group_09", + [ + "UInt64::wrapping_succ", + "IxVM::canon_sord_then", + "IxVM::canon_sord_of_g", + "IxVM::canon_sord_lt_strong", + "IxVM::canon_sord_gt_strong", + "IxVM::canon_cmp_kuniv_list", + "IxVM::canon_sord_eq_strong", + "IxVM::level_leq", + "IxVM::nl_le", + "IxVM::nlvars_any_offset_geq", + "IxVM::nl_covers_var", + "IxVM::nlvars_dominates", + "IxVM::assert_occ_param_bvars", + "IxVM::check_rec_major_spine", + "IxVM::args_contain_bvar", + "IxVM::spec_params_dom_prefix_match" + ] + ], + [ + "ixvm_group_10", + [ + "IxVM::get_tagn4", + "IxVM::get_tagn0", + "IxVM::apply_spine" + ] + ], + [ + "ixvm_group_11", + [ + "IxVM::get_tagn_tail", + "IxVM::nl_subsumption_walk", + "IxVM::ctx_close_cut" + ] + ], + [ + "ixvm_group_12", + [ + "IxVM::get_tagn_wide", + "IxVM::put_u64_list", + "IxVM::expr_lift_let", + "IxVM::bytestream_eq", + "IxVM::canon_member_num_ctors", + "IxVM::canon_ctor_ctx_entries", + "IxVM::canon_refine_classes", + "IxVM::canon_cmp_kexpr_ctx", + "IxVM::canon_ctx_class_idx", + "${\"name\":\"IxVM::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "IxVM::canon_group_consec", + "IxVM::spec_params_ptr_eq", + "IxVM::level_list_struct_eq", + "IxVM::flat_find_pos", + "IxVM::get_opt_rule_list_masked", + "IxVM::get_opt_ctor_entry_list_masked" + ] + ], + [ + "ixvm_group_13", + [ + "IxVM::get_u64_le", + "IxVM::run_eval", + "IxVM::get_axiom", + "IxVM::get_quotient", + "IxVM::get_quot_kind", + "IxVM::utf8_validate", + "IxVM::utf8_decode_one", + "IxVM::try_quot_ind", + "IxVM::walk_char_list_bytes", + "IxVM::try_str_back", + "IxVM::try_str_dec_eq", + "IxVM::try_reduce_bit_vec_ult", + "IxVM::int_bdiv_prim", + "IxVM::canon_build_ctx_members", + "IxVM::canon_cmp_member_ctx", + "IxVM::canon_cmp_u64_lex" + ] + ], + [ + "ixvm_group_14", + [ + "UInt64::add", + "IxVM::all_telescope_count", + "IxVM::put_mut_const", + "IxVM::klimbs_succ", + "IxVM::try_struct_eta_iota", + "IxVM::struct_scan_ctors", + "IxVM::try_nat_binop_addr", + "IxVM::klimbs_eq", + "IxVM::try_reduce_decide_bitvec_lt", + "IxVM::try_eta_expand", + "IxVM::check_no_dep_data_field_if_prop", + "IxVM::canon_member_ci", + "IxVM::canon_insert_sorted", + "IxVM::canon_cmp_member_same_kind_ctx", + "IxVM::check_nested_ctors_positivity", + "IxVM::detect_aux_from_recrs_ex" + ] + ], + [ + "ixvm_group_15", + [ + "IxVM::read_byte", + "IxVM::k_is_def_eq_core" + ] + ], + [ + "ixvm_group_16", + [ + "IxVM::get_opt_addr", + "IxVM::level_imax", + "IxVM::nat_shift_right_addr", + "IxVM::bit_vec_ult_addr", + "IxVM::try_match_nat_add", + "IxVM::peel_n_alls_whnf", + "IxVM::build_apply_bvars_decreasing" + ] + ], + [ + "ixvm_group_17", + [ + "IxVM::run_check", + "IxVM::whnf_nd_apply_beta", + "IxVM::try_prim_dispatch" + ] + ], + [ + "ixvm_group_18", + [ + "IxVM::get_ci", + "IxVM::check_const", + "IxVM::apply_ihs_full", + "IxVM::check_muts_member_at", + "IxVM::const_idxs_of", + "IxVM::load_assumption_tree" + ] + ], + [ + "ixvm_group_19", + [ + "IxVM::load_verified_constant", + "IxVM::get_constant", + "IxVM::get_mut_const_list", + "IxVM::k_is_def_eq_slow2", + "IxVM::get_mut_entry_list_inner", + "${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}" + ] + ], + [ + "ixvm_group_20", + [ + "Blake3::verify_bytes_against", + "IxVM::put_constant", + "IxVM::is_defn_or_thm" + ] + ], + [ + "ixvm_group_21", + [ + "IxVM::get_mut_const", + "IxVM::k_synth_gate", + "IxVM::klimbs_mul", + "IxVM::klimbs_div_mod", + "IxVM::ordinary_div_mod", + "IxVM::klimbs_pow", + "IxVM::klimbs_land", + "IxVM::try_str_dispatch", + "IxVM::klimbs_scalar_value", + "IxVM::str_dec_eq_build", + "IxVM::bitvec_of_nat_args_direct", + "IxVM::try_native_dispatch", + "IxVM::try_int_prim_dispatch", + "IxVM::int_ediv_prim", + "IxVM::check_eq_type", + "IxVM::canon_sort_loop" + ] + ], + [ + "ixvm_group_22", + [ + "IxVM::get_definition", + "UInt64::to_field", + "IxVM::safe_refs_only" + ] + ], + [ + "ixvm_group_23", + [ + "IxVM::unpack_def_kind_safety", + "IxVM::defn_is_unsafe_ci", + "${\"name\":\"IxVM::rbtree_map_balance_fix\",\"types\":[\"field\"]}", + "IxVM::env_walk_leaves" + ] + ], + [ + "ixvm_group_24", + [ + "IxVM::get_expr", + "IxVM::get_u64_list", + "IxVM::validate_expr_well_scoped" + ] + ], + [ + "ixvm_group_25", + [ + "IxVM::get_app_telescope", + "IxVM::expr_inst_many_bvar" + ] + ], + [ + "ixvm_group_26", + [ + "IxVM::get_lam_telescope", + "IxVM::const_type_of", + "IxVM::ctx_seek_cut", + "${\"name\":\"IxVM::rbtree_map_balance\",\"types\":[\"field\"]}" + ] + ], + [ + "ixvm_group_27", + [ + "IxVM::get_lam_mode", + "IxVM::expr_has_bvar_at" + ] + ], + [ + "ixvm_group_28", + [ + "IxVM::binder_contract_from_bits", + "IxVM::system_platform_num_bits_addr", + "IxVM::cleanup_nat_offset_major", + "IxVM::nat_offset_of", + "IxVM::check_param_agreement_go", + "IxVM::walk_fields_classify" + ] + ], + [ + "ixvm_group_29", + [ + "IxVM::value_contract_from_bits", + "IxVM::is_bitvec_prim_addr", + "IxVM::try_reduce_projection_definition", + "IxVM::try_unit_like" + ] + ], + [ + "ixvm_group_30", + [ + "IxVM::get_all_telescope", + "IxVM::addr_set_build", + "${\"name\":\"IxVM::rbtree_map_insert\",\"types\":[\"field\"]}" + ] + ], + [ + "ixvm_group_31", + [ + "IxVM::get_all_mode", + "IxVM::convert_expr" + ] + ], + [ + "ixvm_group_32", + [ + "IxVM::get_expr_let", + "IxVM::get_constant_info_by_variant", + "IxVM::get_recursor_proj", + "IxVM::get_univ", + "IxVM::level_normalize" + ] + ], + [ + "ixvm_group_33", + [ + "IxVM::get_inductive", + "IxVM::load_verified_blob", + "IxVM::count_ctors", + "IxVM::klimbs_mul_single", + "IxVM::check_canonical_block", + "IxVM::peer_agree_walk", + "IxVM::ind_is_solo", + "IxVM::flat_originals_walk", + "IxVM::find_peer_recursor_with_spec", + "IxVM::env_walk" + ] + ], + [ + "ixvm_group_34", + [ + "IxVM::assert_wire_bool", + "IxVM::io_peel_params_subst", + "IxVM::unfold_a_and_loop", + "IxVM::k_is_def_eq_structure_tree_app", + "IxVM::check_inductive_shape", + "IxVM::get_result_sort_level", + "${\"name\":\"IxVM::list_reverse\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "IxVM::build_all_minors" + ] + ], + [ + "ixvm_group_35", + [ + "IxVM::get_constructor_list", + "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Expr\"}}}}]}", + "IxVM::address_eq_tail" + ] + ], + [ + "ixvm_group_36", + [ + "IxVM::get_constructor", + "IxVM::expr_lbr_let", + "IxVM::nl_add_var", + "IxVM::nat_pred_addr", + "IxVM::ensure_sort_only", + "IxVM::try_nat_binop_dispatch", + "IxVM::klimbs_shl_limbs", + "IxVM::compare_struct_fields", + "IxVM::k_infer_lit", + "IxVM::k_infer_proj", + "IxVM::get_reveal_rule_list_inner" + ] + ], + [ + "ixvm_group_37", + [ + "IxVM::get_recursor_rule_list", + "IxVM::bytes_to_u64_limb", + "IxVM::nat_lit_to_ctor_or_self", + "UInt64::eq", + "IxVM::compute_k_target", + "IxVM::is_rec_field_peel", + "IxVM::ctors_before_pos", + "IxVM::populate_rules" + ] + ], + [ + "ixvm_group_38", + [ + "IxVM::get_constructor_proj", + "IxVM::ctor_at", + "IxVM::level_max", + "IxVM::level_max_go", + "IxVM::prim_family", + "IxVM::klimbs_sub", + "IxVM::collect_spine_of_ctor", + "IxVM::struct_block_member_addrs", + "UInt64::mul", + "IxVM::check_recursor_member", + "IxVM::muts_indc_count_is_one", + "IxVM::check_recursor_canonical_full", + "IxVM::build_rec_type_from", + "IxVM::eval_output", + "IxVM::get_mut_entry", + "IxVM::check_recr_rules" + ] + ], + [ + "ixvm_group_39", + [ + "IxVM::get_expr_list", + "IxVM::leaf_hash", + "IxVM::addr_set_member" + ] + ], + [ + "ixvm_group_40", + [ + "IxVM::get_univ_list", + "IxVM::peel_n_foralls", + "IxVM::str_lit_to_ctor_app_or_self", + "IxVM::lazy_delta_a_const_b_proj", + "IxVM::lazy_delta_b_const_a_proj" + ] + ], + [ + "ixvm_group_41", + [ + "IxVM::get_tagn2", + "IxVM::put_recursor_proj", + "IxVM::level_list_inst" + ] + ], + [ + "ixvm_group_42", + [ + "IxVM::build_succ_chain", + "IxVM::build_recur_addrs_walk", + "IxVM::level_equal", + "IxVM::canon_muts_has_kind", + "IxVM::is_muts_block", + "IxVM::check_muts_all" + ] + ], + [ + "ixvm_group_43", + [ + "IxVM::load_constant_hint", + "IxVM::put_address", + "IxVM::whnf_nd_const_head" + ] + ], + [ + "ixvm_group_44", + [ + "IxVM::convert_definition", + "IxVM::put_refs", + "IxVM::env_walk_refs" + ] + ], + [ + "ixvm_group_45", + [ + "IxVM::convert_univ", + "IxVM::put_tagn4", + "IxVM::lbr_dec" + ] + ], + [ + "ixvm_group_46", + [ + "IxVM::convert_univ_idxs", + "IxVM::const_idxs_expr" + ] + ], + [ + "ixvm_group_47", + [ + "IxVM::utf8_cont", + "IxVM::convert_axiom", + "IxVM::convert_quotient", + "IxVM::defn_member_recur_addrs", + "IxVM::put_tagn_tail", + "IxVM::put_tagn_wide", + "IxVM::put_u64_le", + "IxVM::put_expr", + "IxVM::app_telescope_count", + "IxVM::put_app_telescope", + "IxVM::lam_telescope_count", + "IxVM::utf8_encode_prepend", + "IxVM::aux_already_in", + "IxVM::find_peer_rec_spec_walk", + "IxVM::get_reveal_info", + "IxVM::get_reveal_mut_const_info" + ] + ], + [ + "ixvm_group_48", + [ + "IxVM::bytes_to_limbs", + "IxVM::whnf_proj_head", + "IxVM::whnf_nd_proj_head", + "IxVM::check_ctor_return_type" + ] + ], + [ + "ixvm_group_49", + [ + "IxVM::skip_bytes", + "IxVM::level_inst_params", + "IxVM::nat_xor_addr" + ] + ], + [ + "ixvm_group_50", + [ + "IxVM::build_recur_addrs", + "IxVM::lbr_min", + "IxVM::assert_safety" + ] + ], + [ + "ixvm_group_51", + [ + "UInt64::from_field", + "IxVM::put_sharing", + "IxVM::put_univs", + "IxVM::put_univ_list", + "IxVM::mk_nat_lit", + "IxVM::klimbs_is_zero", + "IxVM::find_rule", + "IxVM::struct_is_rec", + "IxVM::k_infer_let_start", + "IxVM::canon_refine_one", + "IxVM::canon_ins_sort", + "IxVM::flat_member_at", + "IxVM::collect_n_doms_whnf", + "IxVM::collect_index_doms", + "IxVM::list_lift_each", + "IxVM::build_ctor_app_params" + ] + ], + [ + "ixvm_group_52", + [ + "IxVM::put_tagn0", + "IxVM::validate_univ_params_list", + "IxVM::level_list_eq" + ] + ], + [ + "ixvm_group_53", + [ + "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "IxVM::put_univ", + "IxVM::univ_succ_count", + "IxVM::put_mut_const_list", + "IxVM::put_constructor_list", + "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::RecursorRule\"}}]}", + "IxVM::put_recursor_rule_list", + "IxVM::put_axiom", + "IxVM::put_quotient", + "IxVM::klimbs_lor", + "IxVM::klimbs_xor_op", + "IxVM::canon_cmp_klimbs_tail", + "IxVM::extract_aux_spec_params_from_rec", + "IxVM::extract_aux_occ_us", + "IxVM::get_ctor_entry", + "IxVM::check_ctor_entries" + ] + ], + [ + "ixvm_group_54", + [ + "IxVM::put_lam_telescope", + "IxVM::put_all_telescope", + "IxVM::put_definition", + "IxVM::put_inductive", + "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}", + "IxVM::put_constructor", + "IxVM::convert_constructor", + "IxVM::convert_recursor", + "IxVM::canon_indc_positions", + "IxVM::check_block_peer_param_agreement", + "IxVM::build_rec_type", + "IxVM::build_all_motives_walk", + "IxVM::build_all_minors_walk", + "IxVM::build_minor_doms", + "IxVM::flat_find_matching", + "IxVM::const_idxs_muts" + ] + ], + [ + "ixvm_group_55", + [ + "IxVM::put_lam_mode", + "IxVM::binder_contract_code", + "IxVM::value_contract_code", + "IxVM::put_all_mode", + "IxVM::put_tagn2", + "IxVM::pack_def_kind_safety", + "IxVM::put_quot_kind", + "IxVM::int_emod_prim", + "IxVM::canon_build_ctx_classes", + "IxVM::canon_cmp_kuniv", + "IxVM::canon_ctx_cmp_addr", + "IxVM::canon_cmp_klimbs", + "IxVM::canon_classes_eq", + "IxVM::extract_aux_spec_params", + "IxVM::spec_params_lower", + "IxVM::apply_spec_params_lifted" + ] + ], + [ + "ixvm_group_56", + [ + "IxVM::put_address_list", + "IxVM::level_max_offsets", + "IxVM::whnf_get_ctor_or_none", + "IxVM::klimbs_le", + "IxVM::addr_list_contains", + "IxVM::nl_le_vars", + "IxVM::check_parent_inductive_shape", + "IxVM::check_large_prop_ctor", + "IxVM::build_peer_recs", + "${\"name\":\"IxVM::list_length\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}", + "IxVM::peel_motive_params_subst", + "IxVM::list_lift_indices", + "IxVM::eval_nf_spine", + "IxVM::get_opt_u64_masked" + ] + ], + [ + "ixvm_group_57", + [ + "IxVM::univ_succ_base", + "IxVM::put_recursor_rule", + "IxVM::str_lit_delta_step", + "IxVM::se_addr_in", + "IxVM::str_addr_io", + "IxVM::apply_n_projs", + "IxVM::str_lit_to_ctor", + "IxVM::list_nil_addr", + "IxVM::list_cons_addr", + "IxVM::char_type_addr", + "UInt64::and", + "UInt64::or", + "IxVM::try_str_to_byte_array", + "IxVM::try_reduce_subtype_val", + "IxVM::dec_finish", + "IxVM::try_int_prim_second" + ] + ], + [ + "ixvm_group_58", + [ + "IxVM::put_constant_info", + "IxVM::level_explicit_val", + "IxVM::nat_mul_addr", + "IxVM::nat_gcd_addr", + "IxVM::try_reduce_fin_val_decidable_rec", + "IxVM::klimbs_mul_outer", + "IxVM::dec_dispatch_le_eq", + "IxVM::dec_build_proof", + "IxVM::peel_leading_foralls_acc", + "IxVM::const_idxs_ctors" + ] + ], + [ + "ixvm_group_59", + [ + "IxVM::put_constructor_proj", + "IxVM::convert_rec_rules", + "IxVM::validate_univ_params_seen", + "IxVM::try_nat_linear_rec", + "IxVM::canon_kind_ord", + "IxVM::eval_nf" + ] + ], + [ + "ixvm_group_60", + [ + "Blake3::bytes_to_addr", + "${\"name\":\"IxVM::rbtree_map_ins\",\"types\":[\"field\"]}", + "${\"name\":\"IxVM::rbtree_map_lookup_or_default\",\"types\":[\"field\"]}" + ] + ], + [ + "ixvm_group_61", + [ + "IxVM::const_num_lvls", + "IxVM::k_is_def_eq_struct_spend" + ] + ], + [ + "ixvm_group_62", + [ + "IxVM::k_ensure_sort", + "IxVM::types_lookup", + "IxVM::ctx_next_cut" + ] + ], + [ + "ixvm_group_63", + [ + "IxVM::k_infer", + "IxVM::expr_glb_walk" + ] + ], + [ + "ixvm_group_64", + [ + "IxVM::expr_lbr", + "${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}" + ] + ], + [ + "ixvm_group_65", + [ + "IxVM::lbr_max", + "IxVM::bit_vec_to_nat_addr", + "IxVM::decidable_decide_addr" + ] + ], + [ + "ixvm_group_66", + [ + "IxVM::k_infer_core", + "IxVM::whnf_struct_core_spine", + "IxVM::node_hash" + ] + ], + [ + "ixvm_group_67", + [ + "IxVM::expr_lift", + "IxVM::expr_inst_many" + ] + ], + [ + "ixvm_group_68", + [ + "IxVM::expr_lift_walk", + "IxVM::k_is_def_eq" + ] + ], + [ + "ixvm_group_69", + [ + "IxVM::level_reduce", + "IxVM::build_param_lvls_range", + "${\"name\":\"IxVM::list_lookup_or_default\",\"types\":[\"field\"]}", + "IxVM::peel_leading_foralls", + "IxVM::apply_indices_in_conclusion", + "IxVM::wrap_lams", + "IxVM::get_opt_def_kind_masked", + "IxVM::get_opt_addr_masked", + "IxVM::get_opt_bool_masked", + "IxVM::get_opt_quot_kind_masked", + "IxVM::check_opt_def_kind", + "IxVM::check_opt_quot_kind" + ] + ], + [ + "ixvm_group_70", + [ + "IxVM::level_struct_eq", + "IxVM::string_utf8_byte_size_addr", + "IxVM::wrap_foralls" + ] + ], + [ + "ixvm_group_71", + [ + "IxVM::level_max_subsumes", + "IxVM::glist_cmp", + "IxVM::unfold_b_and_loop", + "IxVM::unfold_both_and_loop", + "IxVM::try_eta_swap", + "IxVM::check_prop_field_if_prop", + "IxVM::assert_first_args_are_param_bvars", + "IxVM::peel_n_lams_collect" + ] + ], + [ + "ixvm_group_72", + [ + "IxVM::level_offset_of", + "IxVM::nl_add_const", + "IxVM::infer_let_local_cutoff", + "IxVM::infer_let_lookup_value", + "IxVM::check_field_universes_skip_params", + "IxVM::check_positivity_fields", + "IxVM::build_major_indices", + "IxVM::build_apply_field_bvars", + "IxVM::count_foralls_body" + ] + ], + [ + "ixvm_group_73", + [ + "IxVM::level_is_not_zero", + "IxVM::is_int_prim_addr", + "IxVM::try_iota", + "IxVM::is_unit_like_type", + "IxVM::check_positivity_aug", + "IxVM::canonical_rules_at_pos" + ] + ], + [ + "ixvm_group_74", + [ + "IxVM::expr_inst_levels_walk", + "IxVM::const_idxs_exprs" + ] + ], + [ + "ixvm_group_75", + [ + "IxVM::collect_spine", + "IxVM::k_check" + ] + ], + [ + "ixvm_group_76", + [ + "${\"name\":\"IxVM::list_snoc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "IxVM::expr_lower" + ] + ], + [ + "ixvm_group_77", + [ + "IxVM::k_infer_app_spine_loop", + "IxVM::expr_has_bvar_at_binder" + ] + ], + [ + "ixvm_group_78", + [ + "IxVM::has_bvar_in_range_binder", + "IxVM::expr_inst1_bvar", + "IxVM::k_is_def_eq_struct_safe" + ] + ], + [ + "ixvm_group_79", + [ + "IxVM::has_bvar_in_range_let", + "IxVM::expr_inst_many_let", + "IxVM::normalize_imax_dispatch", + "IxVM::nlvars_max_offset", + "IxVM::nlvars_subsume", + "IxVM::expr_has_bvar_at_let", + "IxVM::expr_inst1_let", + "IxVM::try_quot_iota", + "IxVM::quot_lift_addr_iota", + "IxVM::try_quot_lift", + "IxVM::quot_extract_arg", + "IxVM::quot_ctor_addr_iota", + "IxVM::quot_ind_addr_iota", + "IxVM::build_succ_offset", + "IxVM::se_mentions", + "IxVM::canon_cmp_kexpr_node_ctx" + ] + ], + [ + "ixvm_group_80", + [ + "IxVM::expr_inst_many_walk", + "IxVM::expr_lower_walk" + ] + ], + [ + "ixvm_group_81", + [ + "IxVM::de_args", + "IxVM::peel_beta" + ] + ], + [ + "ixvm_group_82", + [ + "IxVM::address_eq", + "IxVM::whnf" + ] + ], + [ + "ixvm_group_83", + [ + "IxVM::nl_eq", + "IxVM::nl_subsume_entry", + "IxVM::nat_sub_addr", + "IxVM::nat_div_addr", + "IxVM::try_extract_nat_app", + "IxVM::replace_spine_major", + "IxVM::try_unfold_head", + "IxVM::projection_addr_ctor", + "IxVM::peel_ctor_params_subst", + "IxVM::build_rule_rhs" + ] + ], + [ + "ixvm_group_84", + [ + "IxVM::nl_skip_empty", + "IxVM::normalize_aux", + "IxVM::divide_grow" + ] + ], + [ + "ixvm_group_85", + [ + "IxVM::nlvars_eq", + "IxVM::glist_ordered_insert", + "IxVM::se_parent_addr", + "IxVM::nat_zero_addr", + "IxVM::se_scan_fields", + "IxVM::nat_addr_io", + "IxVM::mk_bool", + "IxVM::divmod_64u", + "IxVM::utf8_last_codepoint", + "IxVM::utf8_last_go", + "IxVM::byte_array_empty_addr", + "IxVM::np_whnf_inner_bv", + "IxVM::mk_nat_literal_64", + "IxVM::k_is_def_eq_struct_go", + "IxVM::build_rec_lvls_list", + "${\"name\":\"IxVM::list_snoc\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}" + ] + ], + [ + "ixvm_group_86", + [ + "IxVM::nl_add_const_go", + "IxVM::try_nat_dispatch_prewhnf", + "IxVM::try_dec_dispatch", + "IxVM::dec_rewrite_lt_to_le", + "IxVM::quot_type_addr", + "${\"name\":\"IxVM::list_concat\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\"]}}]}", + "IxVM::check_valid_ind_app", + "IxVM::eval_body", + "IxVM::def_kind_tag", + "IxVM::check_opt_u64", + "IxVM::check_opt_expr_addr", + "IxVM::check_opt_bool", + "IxVM::check_opt_recr_rules", + "IxVM::check_opt_addr", + "IxVM::check_opt_ctor_entries", + "IxVM::run_contains" + ] + ], + [ + "ixvm_group_87", + [ + "IxVM::nlvars_add", + "IxVM::try_k_synth_iota", + "IxVM::mk_nat_offset_stuck", + "IxVM::klimbs_from_g", + "IxVM::fin_addr", + "UInt64::xor", + "IxVM::is_int_dec_prim_addr", + "IxVM::try_extract_int", + "IxVM::normalize_int_dec_rebuild", + "IxVM::try_extract_int_prim", + "IxVM::literal_eq", + "IxVM::check_quot", + "IxVM::check_large_walk_fields", + "IxVM::kexpr_struct_eq", + "IxVM::subst_param_for", + "IxVM::ctor_subst_param_for" + ] + ], + [ + "ixvm_group_88", + [ + "IxVM::glist_subset", + "IxVM::delta_rank", + "IxVM::k_infer_let_env", + "IxVM::k_infer_let_env_rebase", + "IxVM::build_major_params" + ] + ], + [ + "ixvm_group_89", + [ + "IxVM::glist_eq_len", + "IxVM::slow2_after_delta", + "IxVM::k_is_def_eq_struct", + "IxVM::peel_n_foralls_with_types", + "${\"name\":\"IxVM::list_reverse_acc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}" + ] + ], + [ + "ixvm_group_90", + [ + "IxVM::k_is_def_eq_slow", + "IxVM::expr_inst1" + ] + ], + [ + "ixvm_group_91", + [ + "IxVM::whnf_nd", + "IxVM::try_proof_irrel", + "IxVM::env_walk_refs_all" + ] + ], + [ + "ixvm_group_92", + [ + "IxVM::nat_succ_addr", + "IxVM::nat_add_addr", + "IxVM::string_append_addr", + "IxVM::subtype_val_addr", + "IxVM::int_dec_le_addr_dec", + "IxVM::int_dec_eq_addr_dec", + "IxVM::int_dec_lt_addr_dec", + "IxVM::int_add_addr", + "IxVM::int_mul_addr", + "IxVM::int_neg_addr", + "IxVM::int_emod_addr", + "IxVM::int_ediv_addr", + "IxVM::int_bmod_addr", + "IxVM::int_bdiv_addr", + "IxVM::int_nat_abs_addr", + "IxVM::int_pow_addr" + ] + ], + [ + "ixvm_group_93", + [ + "IxVM::nat_mod_addr", + "IxVM::nat_pow_addr", + "IxVM::nat_beq_addr", + "IxVM::string_of_list_addr", + "IxVM::string_back_addr", + "IxVM::string_legacy_back_addr", + "IxVM::string_to_byte_array_addr", + "IxVM::string_dec_eq_addr", + "IxVM::punit_size_of_1_addr", + "IxVM::reduce_bool_addr", + "IxVM::reduce_nat_addr", + "IxVM::canon_ord_then" + ] + ], + [ + "ixvm_group_94", + [ + "IxVM::nat_ble_addr", + "IxVM::nat_land_addr", + "IxVM::nat_lor_addr", + "IxVM::nat_shift_left_addr", + "IxVM::nat_dec_le_addr_dec", + "IxVM::nat_dec_eq_addr_dec", + "IxVM::nat_dec_lt_addr_dec", + "IxVM::int_sub_addr" + ] + ], + [ + "ixvm_group_95", + [ + "IxVM::is_str_prim_addr", + "IxVM::is_native_prim_addr", + "IxVM::try_same_proj_head_app", + "IxVM::infer_let_drop_unused" + ] + ], + [ + "ixvm_group_96", + [ + "IxVM::is_dec_prim_addr", + "IxVM::k_infer_let_env_core", + "IxVM::peel_field_loop", + "IxVM::assert_return_head_is_parent" + ] + ], + [ + "ixvm_group_97", + [ + "IxVM::whnf_spine", + "IxVM::lazy_delta_both_proj", + "IxVM::infer_let_materialize" + ] + ], + [ + "ixvm_group_98", + [ + "IxVM::whnf_with_spine", + "IxVM::k_def_eq_rebase" + ] + ], + [ + "ixvm_group_99", + [ + "IxVM::whnf_const_head", + "IxVM::whnf_iota_major", + "IxVM::slow2_eager_fallback", + "IxVM::check_inductive_shape_ctors" + ] + ], + [ + "ixvm_group_100", + [ + "IxVM::projection_definition_info", + "IxVM::k_is_def_eq_slow_nd_after_core", + "IxVM::delta_unfold", + "IxVM::expr_mentions_block" + ] + ], + [ + "ixvm_group_101", + [ + "IxVM::canon_cprj_addr", + "IxVM::is_nat_succ_ih_step", + "IxVM::klimbs_add", + "IxVM::klimbs_normalize", + "UInt64::sub_with_borrow", + "IxVM::compute_iprj_addr", + "IxVM::rec_to_parent_addr", + "IxVM::io_peel_field_loop", + "IxVM::assert_lvls_are_params", + "${\"name\":\"IxVM::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::KRecRule\"}}]}", + "IxVM::is_large_eliminator", + "IxVM::build_flat_own_params", + "IxVM::flat_find_pos_kind", + "IxVM::build_all_motives", + "IxVM::build_motive_type_flat", + "IxVM::walk_refs_transitive" + ] + ], + [ + "ixvm_group_102", + [ + "${\"name\":\"IxVM::list_take\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "IxVM::ctx_trim" + ] + ], + [ + "ixvm_group_103", + [ + "IxVM::try_extract_nat", + "IxVM::is_prop_type", + "IxVM::infer_let_lookup_type", + "IxVM::is_inductive_prop", + "IxVM::check_param_agreement", + "IxVM::list_any_mentions_block", + "IxVM::check_field_universes", + "IxVM::check_field_universes_inner", + "IxVM::check_positivity", + "IxVM::is_rec_field" + ] + ], + [ + "ixvm_group_104", + [ + "IxVM::klimbs_add_carry", + "IxVM::klimbs_sub_borrow", + "IxVM::whnf_struct_core_proj", + "IxVM::lazy_delta_step_const_const", + "IxVM::try_lazy_delta_app", + "IxVM::expr_glb_let", + "IxVM::build_minor_at_depth", + "IxVM::build_ih_doms", + "IxVM::compare_rules" + ] + ], + [ + "ixvm_group_105", + [ + "IxVM::klimbs_dec", + "IxVM::se_peel_tol", + "IxVM::char_of_nat_addr", + "IxVM::split_u32", + "IxVM::divmod_256", + "IxVM::klimbs_div", + "IxVM::klimbs_mod", + "IxVM::klimbs_gcd", + "IxVM::klimbs_shl", + "IxVM::klimbs_shr", + "IxVM::mk_nat_binop_stuck", + "IxVM::char_lit_codepoint", + "IxVM::utf8_groups", + "IxVM::int_add_prim", + "IxVM::count_foralls_at_least", + "IxVM::all_bvars_in_args" + ] + ], + [ + "ixvm_group_106", + [ + "IxVM::build_char_list", + "IxVM::try_nat_offset_dispatch", + "IxVM::char_lit_codepoint_syn", + "IxVM::try_bitvec_dispatch", + "IxVM::bitvec_prep_spine", + "IxVM::bv_to_nat_via", + "IxVM::bitvec_prep_spine_ult", + "IxVM::mk_nat_one", + "IxVM::system_platform_get_num_bits_addr", + "IxVM::check_native_bool", + "IxVM::check_native_nat", + "IxVM::try_normalize_int_decidable", + "IxVM::intern_int_lit", + "IxVM::nat_not_le_of_not_ble_eq_true_addr_dec", + "IxVM::mk_int_prim", + "IxVM::int_bmod_prim" + ] + ], + [ + "ixvm_group_107", + [ + "IxVM::decidable_rec_addr", + "IxVM::bool_false_addr", + "IxVM::bool_true_addr", + "IxVM::eq_refl_addr_dec", + "IxVM::decidable_is_true_addr_dec", + "IxVM::bit_vec_of_nat_addr", + "IxVM::lt_lt_addr", + "IxVM::bit_vec_addr", + "IxVM::int_of_nat_addr_dec", + "IxVM::int_neg_succ_addr_dec", + "IxVM::bool_type_addr_dec", + "IxVM::nat_le_of_ble_eq_true_addr_dec", + "IxVM::nat_eq_of_beq_eq_true_addr_dec", + "IxVM::nat_ne_of_beq_eq_false_addr_dec", + "IxVM::decidable_is_false_addr_dec", + "IxVM::eq_type_addr" + ] + ], + [ + "ixvm_group_108", + [ + "IxVM::whnf_struct_core_const", + "IxVM::try_unfold_proj_app", + "IxVM::caddr_is_peer", + "IxVM::check_rec_rules_wellscoped", + "IxVM::const_idxs_rules", + "IxVM::run_check_env" + ] + ], + [ + "ixvm_group_109", + [ + "IxVM::try_def_eq_nat", + "IxVM::lazy_delta_loop" + ] + ], + [ + "ixvm_group_110", + [ + "IxVM::k_is_def_eq_structure_tree", + "IxVM::parse_atree_body" + ] + ], + [ + "ixvm_group_111", + [ + "IxVM::canon_cmp_kliteral", + "IxVM::canon_cmp_bytes", + "IxVM::canon_cmp_ctor_range_ctx", + "IxVM::canon_cmp_ctor_pair_ctx", + "IxVM::canon_cmp_krec_rule_list_ctx", + "IxVM::canon_cmp_krec_rule_ctx", + "IxVM::canon_group_walk", + "IxVM::canon_all_singleton", + "IxVM::canon_flatten", + "IxVM::nl_covers_const", + "IxVM::get_ctor_entry_list_inner", + "IxVM::get_reveal_ctor_info", + "IxVM::run_reveal", + "IxVM::expr_addr", + "IxVM::check_mut_const", + "IxVM::check_ctor_entry" + ] + ] +] diff --git a/docs/benchmarks/formal-aiur-grouping-tuning/ixvm-policy.report.json b/docs/benchmarks/formal-aiur-grouping-tuning/ixvm-policy.report.json new file mode 100644 index 000000000..b590a4d07 --- /dev/null +++ b/docs/benchmarks/formal-aiur-grouping-tuning/ixvm-policy.report.json @@ -0,0 +1,3213 @@ +{ + "initial": [ + 8781, + 214, + 772418, + 34231776, + 41842973, + 2985196243 + ], + "optimized": [ + 7584, + 141, + 643248, + 29613088, + 38904984, + 2764501198 + ], + "dimensions": [ + "stage1_columns", + "function_circuits", + "cells_0", + "fft_0", + "cells_1", + "fft_1" + ], + "profiles": [ + [ + ".lake/grouping-tune/ixvm-counts.json", + ".lake/formal-comparison/final/new-ixvm-ungrouped.json" + ], + [ + ".lake/grouping-tune/environment-counts.json", + ".lake/formal-comparison/final/new-environment-ungrouped.json" + ] + ], + "circuits": [ + { + "members": [ + "IxVM::verify_claim" + ], + "shape": [ + 10, + 4, + 1 + ], + "cost": [ + 10, + 1, + 10, + 48, + 10, + 48 + ] + }, + { + "members": [ + "IxVM::run_claim", + "Blake3::next_layer", + "IxVM::get_recursor", + "IxVM::get_ci_dprj", + "${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}", + "IxVM::projection_addr", + "IxVM::muts_member_at", + "IxVM::put_expr_list", + "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}", + "IxVM::put_recursor", + "IxVM::get_ci_iprj", + "IxVM::get_ci_rprj", + "IxVM::build_flat_block", + "IxVM::first_recr_parent_block", + "IxVM::aux_from_recrs_walk_ex", + "IxVM::run_check_transitive" + ], + "shape": [ + 221, + 50, + 2 + ], + "cost": [ + 221, + 1, + 1768, + 19896, + 28288, + 740736 + ] + }, + { + "members": [ + "IxVM::read_finite_byte_stream", + "IxVM::get_address_list" + ], + "shape": [ + 27, + 12, + 2 + ], + "cost": [ + 27, + 1, + 1728, + 50304, + 55296, + 2930688 + ] + }, + { + "members": [ + "IxVM::read_byte_stream", + "IxVM::checked_depth_succ" + ], + "shape": [ + 12, + 8, + 2 + ], + "cost": [ + 12, + 1, + 49152, + 3588096, + 1572864, + 162004992 + ] + }, + { + "members": [ + "${\"name\":\"IxVM::list_depth_checked\",\"types\":[\"field\"]}", + "Blake3::pad_block" + ], + "shape": [ + 11, + 8, + 2 + ], + "cost": [ + 11, + 1, + 45056, + 3440640, + 1441792, + 155320320 + ] + }, + { + "members": [ + "UInt32::less_than_fields" + ], + "shape": [ + 14, + 14, + 1 + ], + "cost": [ + 14, + 1, + 28672, + 2035712, + 229376, + 20709376 + ] + }, + { + "members": [ + "Blake3::compress_layer", + "IxVM::whnf_apply_beta", + "IxVM::env_walk_all" + ], + "shape": [ + 149, + 20, + 2 + ], + "cost": [ + 149, + 1, + 4768, + 83424, + 305152, + 11716608 + ] + }, + { + "members": [ + "Blake3::compress" + ], + "shape": [ + 501, + 226, + 2 + ], + "cost": [ + 501, + 1, + 256512, + 10111488, + 16416768, + 1078296576 + ] + }, + { + "members": [ + "Blake3::compress_chunks" + ], + "shape": [ + 17, + 6, + 2 + ], + "cost": [ + 17, + 1, + 69632, + 4030464, + 2228224, + 182059008 + ] + }, + { + "members": [ + "Blake3::finish", + "IxVM::convert_inductive", + "IxVM::get_ci_cprj", + "IxVM::expr_lift_bvar", + "IxVM::walk_leaves_owned", + "IxVM::check_muts_components" + ], + "shape": [ + 174, + 28, + 2 + ], + "cost": [ + 174, + 1, + 5568, + 99264, + 356352, + 13946880 + ] + }, + { + "members": [ + "UInt64::is_zero", + "IxVM::is_unsafe_ci" + ], + "shape": [ + 26, + 2, + 2 + ], + "cost": [ + 26, + 1, + 832, + 15744, + 13312, + 448512 + ] + }, + { + "members": [ + "Blake3::bytes_to_block", + "IxVM::k_infer_only", + "IxVM::head_addr" + ], + "shape": [ + 145, + 130, + 2 + ], + "cost": [ + 145, + 1, + 9280, + 322176, + 593920, + 41189376 + ] + }, + { + "members": [ + "Blake3::compress_block", + "IxVM::check_owned" + ], + "shape": [ + 181, + 48, + 2 + ], + "cost": [ + 181, + 1, + 5792, + 112224, + 370688, + 15771648 + ] + }, + { + "members": [ + "${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}" + ], + "shape": [ + 7, + 4, + 1 + ], + "cost": [ + 7, + 1, + 224, + 6368, + 14336, + 886784 + ] + }, + { + "members": [ + "UInt64::wrapping_succ", + "IxVM::canon_sord_then", + "IxVM::canon_sord_of_g", + "IxVM::canon_sord_lt_strong", + "IxVM::canon_sord_gt_strong", + "IxVM::canon_cmp_kuniv_list", + "IxVM::canon_sord_eq_strong", + "IxVM::level_leq", + "IxVM::nl_le", + "IxVM::nlvars_any_offset_geq", + "IxVM::nl_covers_var", + "IxVM::nlvars_dominates", + "IxVM::assert_occ_param_bvars", + "IxVM::check_rec_major_spine", + "IxVM::args_contain_bvar", + "IxVM::spec_params_dom_prefix_match" + ], + "shape": [ + 75, + 14, + 2 + ], + "cost": [ + 75, + 1, + 0, + 0, + 4800, + 107904 + ] + }, + { + "members": [ + "IxVM::get_tagn4", + "IxVM::get_tagn0", + "IxVM::apply_spine" + ], + "shape": [ + 27, + 10, + 2 + ], + "cost": [ + 27, + 1, + 13824, + 572928, + 884736, + 60850176 + ] + }, + { + "members": [ + "IxVM::get_tagn_tail", + "IxVM::nl_subsumption_walk", + "IxVM::ctx_close_cut" + ], + "shape": [ + 27, + 12, + 2 + ], + "cost": [ + 27, + 1, + 864, + 21024, + 55296, + 2930688 + ] + }, + { + "members": [ + "IxVM::get_tagn_wide", + "IxVM::put_u64_list", + "IxVM::expr_lift_let", + "IxVM::bytestream_eq", + "IxVM::canon_member_num_ctors", + "IxVM::canon_ctor_ctx_entries", + "IxVM::canon_refine_classes", + "IxVM::canon_cmp_kexpr_ctx", + "IxVM::canon_ctx_class_idx", + "${\"name\":\"IxVM::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "IxVM::canon_group_consec", + "IxVM::spec_params_ptr_eq", + "IxVM::level_list_struct_eq", + "IxVM::flat_find_pos", + "IxVM::get_opt_rule_list_masked", + "IxVM::get_opt_ctor_entry_list_masked" + ], + "shape": [ + 71, + 12, + 2 + ], + "cost": [ + 71, + 1, + 0, + 0, + 0, + 0 + ] + }, + { + "members": [ + "IxVM::get_u64_le", + "IxVM::run_eval", + "IxVM::get_axiom", + "IxVM::get_quotient", + "IxVM::get_quot_kind", + "IxVM::utf8_validate", + "IxVM::utf8_decode_one", + "IxVM::try_quot_ind", + "IxVM::walk_char_list_bytes", + "IxVM::try_str_back", + "IxVM::try_str_dec_eq", + "IxVM::try_reduce_bit_vec_ult", + "IxVM::int_bdiv_prim", + "IxVM::canon_build_ctx_members", + "IxVM::canon_cmp_member_ctx", + "IxVM::canon_cmp_u64_lex" + ], + "shape": [ + 92, + 38, + 2 + ], + "cost": [ + 92, + 1, + 0, + 0, + 0, + 0 + ] + }, + { + "members": [ + "UInt64::add", + "IxVM::all_telescope_count", + "IxVM::put_mut_const", + "IxVM::klimbs_succ", + "IxVM::try_struct_eta_iota", + "IxVM::struct_scan_ctors", + "IxVM::try_nat_binop_addr", + "IxVM::klimbs_eq", + "IxVM::try_reduce_decide_bitvec_lt", + "IxVM::try_eta_expand", + "IxVM::check_no_dep_data_field_if_prop", + "IxVM::canon_member_ci", + "IxVM::canon_insert_sorted", + "IxVM::canon_cmp_member_same_kind_ctx", + "IxVM::check_nested_ctors_positivity", + "IxVM::detect_aux_from_recrs_ex" + ], + "shape": [ + 140, + 140, + 2 + ], + "cost": [ + 140, + 1, + 0, + 0, + 17920, + 764928 + ] + }, + { + "members": [ + "IxVM::read_byte", + "IxVM::k_is_def_eq_core" + ], + "shape": [ + 7, + 4, + 2 + ], + "cost": [ + 7, + 1, + 896, + 41856, + 57344, + 4890624 + ] + }, + { + "members": [ + "IxVM::get_address" + ], + "shape": [ + 68, + 68, + 1 + ], + "cost": [ + 68, + 1, + 4352, + 159232, + 139264, + 9334784 + ] + }, + { + "members": [ + "IxVM::get_opt_addr", + "IxVM::level_imax", + "IxVM::nat_shift_right_addr", + "IxVM::bit_vec_ult_addr", + "IxVM::try_match_nat_add", + "IxVM::peel_n_alls_whnf", + "IxVM::build_apply_bvars_decreasing" + ], + "shape": [ + 41, + 18, + 2 + ], + "cost": [ + 41, + 1, + 164, + 1560, + 20992, + 877056 + ] + }, + { + "members": [ + "IxVM::run_check", + "IxVM::whnf_nd_apply_beta", + "IxVM::try_prim_dispatch" + ], + "shape": [ + 26, + 20, + 2 + ], + "cost": [ + 26, + 1, + 104, + 1248, + 53248, + 3403776 + ] + }, + { + "members": [ + "IxVM::get_ci", + "IxVM::check_const", + "IxVM::apply_ihs_full", + "IxVM::check_muts_member_at", + "IxVM::const_idxs_of", + "IxVM::load_assumption_tree" + ], + "shape": [ + 96, + 60, + 2 + ], + "cost": [ + 96, + 1, + 1536, + 30912, + 98304, + 4927488 + ] + }, + { + "members": [ + "IxVM::load_verified_constant", + "IxVM::get_constant", + "IxVM::get_mut_const_list", + "IxVM::k_is_def_eq_slow2", + "IxVM::get_mut_entry_list_inner", + "${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}" + ], + "shape": [ + 113, + 20, + 2 + ], + "cost": [ + 113, + 1, + 3616, + 66144, + 115712, + 4220928 + ] + }, + { + "members": [ + "Blake3::verify_bytes_against", + "IxVM::put_constant", + "IxVM::is_defn_or_thm" + ], + "shape": [ + 83, + 18, + 2 + ], + "cost": [ + 83, + 1, + 1328, + 20352, + 42496, + 1457664 + ] + }, + { + "members": [ + "IxVM::get_mut_const", + "IxVM::k_synth_gate", + "IxVM::klimbs_mul", + "IxVM::klimbs_div_mod", + "IxVM::ordinary_div_mod", + "IxVM::klimbs_pow", + "IxVM::klimbs_land", + "IxVM::try_str_dispatch", + "IxVM::klimbs_scalar_value", + "IxVM::str_dec_eq_build", + "IxVM::bitvec_of_nat_args_direct", + "IxVM::try_native_dispatch", + "IxVM::try_int_prim_dispatch", + "IxVM::int_ediv_prim", + "IxVM::check_eq_type", + "IxVM::canon_sort_loop" + ], + "shape": [ + 133, + 66, + 2 + ], + "cost": [ + 133, + 1, + 266, + 1242, + 8512, + 234624 + ] + }, + { + "members": [ + "IxVM::get_definition", + "UInt64::to_field", + "IxVM::safe_refs_only" + ], + "shape": [ + 32, + 18, + 2 + ], + "cost": [ + 32, + 1, + 2048, + 62976, + 262144, + 17350656 + ] + }, + { + "members": [ + "IxVM::unpack_def_kind_safety", + "IxVM::defn_is_unsafe_ci", + "${\"name\":\"IxVM::rbtree_map_balance_fix\",\"types\":[\"field\"]}", + "IxVM::env_walk_leaves" + ], + "shape": [ + 308, + 16, + 2 + ], + "cost": [ + 308, + 1, + 4928, + 63168, + 1232, + 7920 + ] + }, + { + "members": [ + "IxVM::get_expr", + "IxVM::get_u64_list", + "IxVM::validate_expr_well_scoped" + ], + "shape": [ + 61, + 24, + 2 + ], + "cost": [ + 61, + 1, + 31232, + 1236480, + 1998848, + 131629056 + ] + }, + { + "members": [ + "UInt64::saturating_pred" + ], + "shape": [ + 20, + 4, + 2 + ], + "cost": [ + 20, + 1, + 640, + 13824, + 2560, + 76800 + ] + }, + { + "members": [ + "IxVM::get_app_telescope", + "IxVM::expr_inst_many_bvar" + ], + "shape": [ + 29, + 12, + 2 + ], + "cost": [ + 29, + 1, + 7424, + 279552, + 475136, + 31162368 + ] + }, + { + "members": [ + "IxVM::get_lam_telescope", + "IxVM::const_type_of", + "IxVM::ctx_seek_cut", + "${\"name\":\"IxVM::rbtree_map_balance\",\"types\":[\"field\"]}" + ], + "shape": [ + 41, + 16, + 2 + ], + "cost": [ + 41, + 1, + 2624, + 71040, + 167936, + 9043968 + ] + }, + { + "members": [ + "IxVM::get_lam_mode", + "IxVM::expr_has_bvar_at" + ], + "shape": [ + 25, + 12, + 2 + ], + "cost": [ + 25, + 1, + 1600, + 48000, + 204800, + 13197312 + ] + }, + { + "members": [ + "IxVM::binder_contract_from_bits", + "IxVM::system_platform_num_bits_addr", + "IxVM::cleanup_nat_offset_major", + "IxVM::nat_offset_of", + "IxVM::check_param_agreement_go", + "IxVM::walk_fields_classify" + ], + "shape": [ + 49, + 30, + 2 + ], + "cost": [ + 49, + 1, + 196, + 2040, + 50176, + 2562048 + ] + }, + { + "members": [ + "IxVM::value_contract_from_bits", + "IxVM::is_bitvec_prim_addr", + "IxVM::try_reduce_projection_definition", + "IxVM::try_unit_like" + ], + "shape": [ + 25, + 16, + 2 + ], + "cost": [ + 25, + 1, + 100, + 1128, + 25600, + 1394688 + ] + }, + { + "members": [ + "IxVM::get_all_telescope", + "IxVM::addr_set_build", + "${\"name\":\"IxVM::rbtree_map_insert\",\"types\":[\"field\"]}" + ], + "shape": [ + 37, + 16, + 2 + ], + "cost": [ + 37, + 1, + 2368, + 66432, + 75776, + 3876864 + ] + }, + { + "members": [ + "IxVM::get_all_mode", + "IxVM::convert_expr" + ], + "shape": [ + 42, + 38, + 2 + ], + "cost": [ + 42, + 1, + 21504, + 1167360, + 688128, + 57999360 + ] + }, + { + "members": [ + "IxVM::get_expr_let", + "IxVM::get_constant_info_by_variant", + "IxVM::get_recursor_proj", + "IxVM::get_univ", + "IxVM::level_normalize" + ], + "shape": [ + 67, + 18, + 2 + ], + "cost": [ + 67, + 1, + 2144, + 43104, + 34304, + 1236480 + ] + }, + { + "members": [ + "IxVM::get_inductive", + "IxVM::load_verified_blob", + "IxVM::count_ctors", + "IxVM::klimbs_mul_single", + "IxVM::check_canonical_block", + "IxVM::peer_agree_walk", + "IxVM::ind_is_solo", + "IxVM::flat_originals_walk", + "IxVM::find_peer_recursor_with_spec", + "IxVM::env_walk" + ], + "shape": [ + 112, + 30, + 2 + ], + "cost": [ + 112, + 1, + 1792, + 28224, + 28672, + 900096 + ] + }, + { + "members": [ + "IxVM::assert_wire_bool", + "IxVM::io_peel_params_subst", + "IxVM::unfold_a_and_loop", + "IxVM::k_is_def_eq_structure_tree_app", + "IxVM::check_inductive_shape", + "IxVM::get_result_sort_level", + "${\"name\":\"IxVM::list_reverse\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "IxVM::build_all_minors" + ], + "shape": [ + 29, + 10, + 2 + ], + "cost": [ + 29, + 1, + 29, + 129, + 14848, + 600576 + ] + }, + { + "members": [ + "IxVM::get_constructor_list", + "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Expr\"}}}}]}", + "IxVM::address_eq_tail" + ], + "shape": [ + 80, + 12, + 2 + ], + "cost": [ + 80, + 1, + 1280, + 18624, + 20480, + 592896 + ] + }, + { + "members": [ + "IxVM::get_constructor", + "IxVM::expr_lbr_let", + "IxVM::nl_add_var", + "IxVM::nat_pred_addr", + "IxVM::ensure_sort_only", + "IxVM::try_nat_binop_dispatch", + "IxVM::klimbs_shl_limbs", + "IxVM::compare_struct_fields", + "IxVM::k_infer_lit", + "IxVM::k_infer_proj", + "IxVM::get_reveal_rule_list_inner" + ], + "shape": [ + 70, + 28, + 2 + ], + "cost": [ + 70, + 1, + 280, + 2496, + 17920, + 629760 + ] + }, + { + "members": [ + "IxVM::get_recursor_rule_list", + "IxVM::bytes_to_u64_limb", + "IxVM::nat_lit_to_ctor_or_self", + "UInt64::eq", + "IxVM::compute_k_target", + "IxVM::is_rec_field_peel", + "IxVM::ctors_before_pos", + "IxVM::populate_rules" + ], + "shape": [ + 74, + 22, + 2 + ], + "cost": [ + 74, + 1, + 296, + 2448, + 18944, + 617472 + ] + }, + { + "members": [ + "IxVM::get_constructor_proj", + "IxVM::ctor_at", + "IxVM::level_max", + "IxVM::level_max_go", + "IxVM::prim_family", + "IxVM::klimbs_sub", + "IxVM::collect_spine_of_ctor", + "IxVM::struct_block_member_addrs", + "UInt64::mul", + "IxVM::check_recursor_member", + "IxVM::muts_indc_count_is_one", + "IxVM::check_recursor_canonical_full", + "IxVM::build_rec_type_from", + "IxVM::eval_output", + "IxVM::get_mut_entry", + "IxVM::check_recr_rules" + ], + "shape": [ + 146, + 76, + 2 + ], + "cost": [ + 146, + 1, + 146, + 678, + 74752, + 3130368 + ] + }, + { + "members": [ + "IxVM::get_expr_list", + "IxVM::leaf_hash", + "IxVM::addr_set_member" + ], + "shape": [ + 28, + 12, + 2 + ], + "cost": [ + 28, + 1, + 1792, + 51456, + 57344, + 2998272 + ] + }, + { + "members": [ + "IxVM::get_univ_list", + "IxVM::peel_n_foralls", + "IxVM::str_lit_to_ctor_app_or_self", + "IxVM::lazy_delta_a_const_b_proj", + "IxVM::lazy_delta_b_const_a_proj" + ], + "shape": [ + 49, + 16, + 2 + ], + "cost": [ + 49, + 1, + 784, + 13440, + 50176, + 2131968 + ] + }, + { + "members": [ + "IxVM::get_tagn2", + "IxVM::put_recursor_proj", + "IxVM::level_list_inst" + ], + "shape": [ + 26, + 10, + 2 + ], + "cost": [ + 26, + 1, + 832, + 19584, + 6656, + 248832 + ] + }, + { + "members": [ + "IxVM::build_succ_chain", + "IxVM::build_recur_addrs_walk", + "IxVM::level_equal", + "IxVM::canon_muts_has_kind", + "IxVM::is_muts_block", + "IxVM::check_muts_all" + ], + "shape": [ + 77, + 10, + 2 + ], + "cost": [ + 77, + 1, + 1232, + 17664, + 19712, + 562176 + ] + }, + { + "members": [ + "IxVM::load_constant_hint", + "IxVM::put_address", + "IxVM::whnf_nd_const_head" + ], + "shape": [ + 86, + 68, + 2 + ], + "cost": [ + 86, + 1, + 2752, + 76224, + 176128, + 10702848 + ] + }, + { + "members": [ + "IxVM::convert_definition", + "IxVM::put_refs", + "IxVM::env_walk_refs" + ], + "shape": [ + 35, + 10, + 2 + ], + "cost": [ + 35, + 1, + 560, + 9600, + 8960, + 304128 + ] + }, + { + "members": [ + "${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}" + ], + "shape": [ + 7, + 6, + 1 + ], + "cost": [ + 7, + 1, + 896, + 40832, + 57344, + 4825088 + ] + }, + { + "members": [ + "${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}" + ], + "shape": [ + 9, + 6, + 2 + ], + "cost": [ + 9, + 1, + 2304, + 119808, + 147456, + 13271040 + ] + }, + { + "members": [ + "IxVM::convert_univ", + "IxVM::put_tagn4", + "IxVM::lbr_dec" + ], + "shape": [ + 25, + 12, + 2 + ], + "cost": [ + 25, + 1, + 400, + 8064, + 3200, + 111744 + ] + }, + { + "members": [ + "IxVM::convert_univ_idxs", + "IxVM::const_idxs_expr" + ], + "shape": [ + 36, + 24, + 2 + ], + "cost": [ + 36, + 1, + 2304, + 74496, + 294912, + 20545536 + ] + }, + { + "members": [ + "IxVM::utf8_cont", + "IxVM::convert_axiom", + "IxVM::convert_quotient", + "IxVM::defn_member_recur_addrs", + "IxVM::put_tagn_tail", + "IxVM::put_tagn_wide", + "IxVM::put_u64_le", + "IxVM::put_expr", + "IxVM::app_telescope_count", + "IxVM::put_app_telescope", + "IxVM::lam_telescope_count", + "IxVM::utf8_encode_prepend", + "IxVM::aux_already_in", + "IxVM::find_peer_rec_spec_walk", + "IxVM::get_reveal_info", + "IxVM::get_reveal_mut_const_info" + ], + "shape": [ + 204, + 62, + 2 + ], + "cost": [ + 204, + 1, + 0, + 0, + 0, + 0 + ] + }, + { + "members": [ + "IxVM::bytes_to_limbs", + "IxVM::whnf_proj_head", + "IxVM::whnf_nd_proj_head", + "IxVM::check_ctor_return_type" + ], + "shape": [ + 47, + 26, + 2 + ], + "cost": [ + 47, + 1, + 94, + 486, + 24064, + 1070592 + ] + }, + { + "members": [ + "IxVM::skip_bytes", + "IxVM::level_inst_params", + "IxVM::nat_xor_addr" + ], + "shape": [ + 18, + 16, + 2 + ], + "cost": [ + 18, + 1, + 288, + 7488, + 4608, + 236544 + ] + }, + { + "members": [ + "IxVM::build_recur_addrs", + "IxVM::lbr_min", + "IxVM::assert_safety" + ], + "shape": [ + 11, + 4, + 2 + ], + "cost": [ + 11, + 1, + 176, + 3840, + 11264, + 595968 + ] + }, + { + "members": [ + "UInt64::from_field", + "IxVM::put_sharing", + "IxVM::put_univs", + "IxVM::put_univ_list", + "IxVM::mk_nat_lit", + "IxVM::klimbs_is_zero", + "IxVM::find_rule", + "IxVM::struct_is_rec", + "IxVM::k_infer_let_start", + "IxVM::canon_refine_one", + "IxVM::canon_ins_sort", + "IxVM::flat_member_at", + "IxVM::collect_n_doms_whnf", + "IxVM::collect_index_doms", + "IxVM::list_lift_each", + "IxVM::build_ctor_app_params" + ], + "shape": [ + 54, + 16, + 2 + ], + "cost": [ + 54, + 1, + 216, + 1824, + 6912, + 200448 + ] + }, + { + "members": [ + "IxVM::put_tagn0", + "IxVM::validate_univ_params_list", + "IxVM::level_list_eq" + ], + "shape": [ + 23, + 10, + 2 + ], + "cost": [ + 23, + 1, + 368, + 7296, + 2944, + 100992 + ] + }, + { + "members": [ + "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "IxVM::put_univ", + "IxVM::univ_succ_count", + "IxVM::put_mut_const_list", + "IxVM::put_constructor_list", + "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::RecursorRule\"}}]}", + "IxVM::put_recursor_rule_list", + "IxVM::put_axiom", + "IxVM::put_quotient", + "IxVM::klimbs_lor", + "IxVM::klimbs_xor_op", + "IxVM::canon_cmp_klimbs_tail", + "IxVM::extract_aux_spec_params_from_rec", + "IxVM::extract_aux_occ_us", + "IxVM::get_ctor_entry", + "IxVM::check_ctor_entries" + ], + "shape": [ + 90, + 26, + 2 + ], + "cost": [ + 90, + 1, + 0, + 0, + 0, + 0 + ] + }, + { + "members": [ + "IxVM::put_lam_telescope", + "IxVM::put_all_telescope", + "IxVM::put_definition", + "IxVM::put_inductive", + "${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}", + "IxVM::put_constructor", + "IxVM::convert_constructor", + "IxVM::convert_recursor", + "IxVM::canon_indc_positions", + "IxVM::check_block_peer_param_agreement", + "IxVM::build_rec_type", + "IxVM::build_all_motives_walk", + "IxVM::build_all_minors_walk", + "IxVM::build_minor_doms", + "IxVM::flat_find_matching", + "IxVM::const_idxs_muts" + ], + "shape": [ + 101, + 32, + 2 + ], + "cost": [ + 101, + 1, + 0, + 0, + 25856, + 844800 + ] + }, + { + "members": [ + "IxVM::put_lam_mode", + "IxVM::binder_contract_code", + "IxVM::value_contract_code", + "IxVM::put_all_mode", + "IxVM::put_tagn2", + "IxVM::pack_def_kind_safety", + "IxVM::put_quot_kind", + "IxVM::int_emod_prim", + "IxVM::canon_build_ctx_classes", + "IxVM::canon_cmp_kuniv", + "IxVM::canon_ctx_cmp_addr", + "IxVM::canon_cmp_klimbs", + "IxVM::canon_classes_eq", + "IxVM::extract_aux_spec_params", + "IxVM::spec_params_lower", + "IxVM::apply_spec_params_lifted" + ], + "shape": [ + 63, + 20, + 2 + ], + "cost": [ + 63, + 1, + 0, + 0, + 0, + 0 + ] + }, + { + "members": [ + "IxVM::put_address_list", + "IxVM::level_max_offsets", + "IxVM::whnf_get_ctor_or_none", + "IxVM::klimbs_le", + "IxVM::addr_list_contains", + "IxVM::nl_le_vars", + "IxVM::check_parent_inductive_shape", + "IxVM::check_large_prop_ctor", + "IxVM::build_peer_recs", + "${\"name\":\"IxVM::list_length\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}", + "IxVM::peel_motive_params_subst", + "IxVM::list_lift_indices", + "IxVM::eval_nf_spine", + "IxVM::get_opt_u64_masked" + ], + "shape": [ + 49, + 12, + 2 + ], + "cost": [ + 49, + 1, + 49, + 195, + 12544, + 402432 + ] + }, + { + "members": [ + "IxVM::univ_succ_base", + "IxVM::put_recursor_rule", + "IxVM::str_lit_delta_step", + "IxVM::se_addr_in", + "IxVM::str_addr_io", + "IxVM::apply_n_projs", + "IxVM::str_lit_to_ctor", + "IxVM::list_nil_addr", + "IxVM::list_cons_addr", + "IxVM::char_type_addr", + "UInt64::and", + "UInt64::or", + "IxVM::try_str_to_byte_array", + "IxVM::try_reduce_subtype_val", + "IxVM::dec_finish", + "IxVM::try_int_prim_second" + ], + "shape": [ + 82, + 90, + 2 + ], + "cost": [ + 82, + 1, + 0, + 0, + 328, + 4272 + ] + }, + { + "members": [ + "IxVM::put_constant_info", + "IxVM::level_explicit_val", + "IxVM::nat_mul_addr", + "IxVM::nat_gcd_addr", + "IxVM::try_reduce_fin_val_decidable_rec", + "IxVM::klimbs_mul_outer", + "IxVM::dec_dispatch_le_eq", + "IxVM::dec_build_proof", + "IxVM::peel_leading_foralls_acc", + "IxVM::const_idxs_ctors" + ], + "shape": [ + 91, + 64, + 2 + ], + "cost": [ + 91, + 1, + 364, + 3864, + 23296, + 979968 + ] + }, + { + "members": [ + "IxVM::put_constructor_proj", + "IxVM::convert_rec_rules", + "IxVM::validate_univ_params_seen", + "IxVM::try_nat_linear_rec", + "IxVM::canon_kind_ord", + "IxVM::eval_nf" + ], + "shape": [ + 40, + 28, + 2 + ], + "cost": [ + 40, + 1, + 80, + 456, + 10240, + 445440 + ] + }, + { + "members": [ + "Blake3::bytes_to_addr", + "${\"name\":\"IxVM::rbtree_map_ins\",\"types\":[\"field\"]}", + "${\"name\":\"IxVM::rbtree_map_lookup_or_default\",\"types\":[\"field\"]}" + ], + "shape": [ + 51, + 22, + 2 + ], + "cost": [ + 51, + 1, + 3264, + 89472, + 52224, + 2377728 + ] + }, + { + "members": [ + "IxVM::const_num_lvls", + "IxVM::k_is_def_eq_struct_spend" + ], + "shape": [ + 25, + 12, + 2 + ], + "cost": [ + 25, + 1, + 200, + 3048, + 25600, + 1271808 + ] + }, + { + "members": [ + "${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}" + ], + "shape": [ + 8, + 6, + 2 + ], + "cost": [ + 8, + 1, + 512, + 21504, + 65536, + 5849088 + ] + }, + { + "members": [ + "IxVM::k_ensure_sort", + "IxVM::types_lookup", + "IxVM::ctx_next_cut" + ], + "shape": [ + 11, + 8, + 2 + ], + "cost": [ + 11, + 1, + 88, + 1752, + 45056, + 3440640 + ] + }, + { + "members": [ + "IxVM::k_infer", + "IxVM::expr_glb_walk" + ], + "shape": [ + 24, + 18, + 2 + ], + "cost": [ + 24, + 1, + 1536, + 53760, + 786432, + 68222976 + ] + }, + { + "members": [ + "IxVM::expr_lbr", + "${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}" + ], + "shape": [ + 21, + 18, + 2 + ], + "cost": [ + 21, + 1, + 2688, + 117120, + 688128, + 63799296 + ] + }, + { + "members": [ + "IxVM::lbr_max", + "IxVM::bit_vec_to_nat_addr", + "IxVM::decidable_decide_addr" + ], + "shape": [ + 8, + 4, + 2 + ], + "cost": [ + 8, + 1, + 128, + 3264, + 4096, + 227328 + ] + }, + { + "members": [ + "IxVM::k_infer_core", + "IxVM::whnf_struct_core_spine", + "IxVM::node_hash" + ], + "shape": [ + 42, + 46, + 2 + ], + "cost": [ + 42, + 1, + 1344, + 44544, + 344064, + 29491200 + ] + }, + { + "members": [ + "IxVM::expr_lift", + "IxVM::expr_inst_many" + ], + "shape": [ + 18, + 14, + 2 + ], + "cost": [ + 18, + 1, + 1152, + 42240, + 589824, + 53477376 + ] + }, + { + "members": [ + "IxVM::expr_lift_walk", + "IxVM::k_is_def_eq" + ], + "shape": [ + 22, + 14, + 2 + ], + "cost": [ + 22, + 1, + 704, + 19584, + 360448, + 27721728 + ] + }, + { + "members": [ + "IxVM::level_reduce", + "IxVM::build_param_lvls_range", + "${\"name\":\"IxVM::list_lookup_or_default\",\"types\":[\"field\"]}", + "IxVM::peel_leading_foralls", + "IxVM::apply_indices_in_conclusion", + "IxVM::wrap_lams", + "IxVM::get_opt_def_kind_masked", + "IxVM::get_opt_addr_masked", + "IxVM::get_opt_bool_masked", + "IxVM::get_opt_quot_kind_masked", + "IxVM::check_opt_def_kind", + "IxVM::check_opt_quot_kind" + ], + "shape": [ + 48, + 14, + 2 + ], + "cost": [ + 48, + 1, + 192, + 1632, + 3072, + 76800 + ] + }, + { + "members": [ + "IxVM::level_struct_eq", + "IxVM::string_utf8_byte_size_addr", + "IxVM::wrap_foralls" + ], + "shape": [ + 26, + 12, + 2 + ], + "cost": [ + 26, + 1, + 104, + 1056, + 13312, + 586752 + ] + }, + { + "members": [ + "IxVM::level_max_subsumes", + "IxVM::glist_cmp", + "IxVM::unfold_b_and_loop", + "IxVM::unfold_both_and_loop", + "IxVM::try_eta_swap", + "IxVM::check_prop_field_if_prop", + "IxVM::assert_first_args_are_param_bvars", + "IxVM::peel_n_lams_collect" + ], + "shape": [ + 41, + 12, + 2 + ], + "cost": [ + 41, + 1, + 41, + 171, + 20992, + 794112 + ] + }, + { + "members": [ + "IxVM::level_offset_of", + "IxVM::nl_add_const", + "IxVM::infer_let_local_cutoff", + "IxVM::infer_let_lookup_value", + "IxVM::check_field_universes_skip_params", + "IxVM::check_positivity_fields", + "IxVM::build_major_indices", + "IxVM::build_apply_field_bvars", + "IxVM::count_foralls_body" + ], + "shape": [ + 36, + 10, + 2 + ], + "cost": [ + 36, + 1, + 72, + 324, + 18432, + 697344 + ] + }, + { + "members": [ + "IxVM::level_is_not_zero", + "IxVM::is_int_prim_addr", + "IxVM::try_iota", + "IxVM::is_unit_like_type", + "IxVM::check_positivity_aug", + "IxVM::canonical_rules_at_pos" + ], + "shape": [ + 64, + 50, + 2 + ], + "cost": [ + 64, + 1, + 128, + 732, + 32768, + 1637376 + ] + }, + { + "members": [ + "IxVM::expr_inst_levels" + ], + "shape": [ + 10, + 4, + 2 + ], + "cost": [ + 10, + 1, + 640, + 21504, + 40960, + 2703360 + ] + }, + { + "members": [ + "IxVM::expr_inst_levels_walk", + "IxVM::const_idxs_exprs" + ], + "shape": [ + 22, + 16, + 2 + ], + "cost": [ + 22, + 1, + 1408, + 49152, + 90112, + 6242304 + ] + }, + { + "members": [ + "IxVM::collect_spine", + "IxVM::k_check" + ], + "shape": [ + 12, + 10, + 2 + ], + "cost": [ + 12, + 1, + 768, + 30720, + 196608, + 18087936 + ] + }, + { + "members": [ + "${\"name\":\"IxVM::list_snoc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "IxVM::expr_lower" + ], + "shape": [ + 13, + 10, + 2 + ], + "cost": [ + 13, + 1, + 832, + 31872, + 425984, + 40206336 + ] + }, + { + "members": [ + "IxVM::k_infer_app_spine_loop", + "IxVM::expr_has_bvar_at_binder" + ], + "shape": [ + 32, + 34, + 2 + ], + "cost": [ + 32, + 1, + 1024, + 33984, + 262144, + 22462464 + ] + }, + { + "members": [ + "IxVM::has_bvar_in_range" + ], + "shape": [ + 21, + 16, + 2 + ], + "cost": [ + 21, + 1, + 1344, + 48000, + 172032, + 13197312 + ] + }, + { + "members": [ + "IxVM::has_bvar_in_range_binder", + "IxVM::expr_inst1_bvar", + "IxVM::k_is_def_eq_struct_safe" + ], + "shape": [ + 32, + 14, + 2 + ], + "cost": [ + 32, + 1, + 512, + 9792, + 131072, + 7421952 + ] + }, + { + "members": [ + "IxVM::has_bvar_in_range_let", + "IxVM::expr_inst_many_let", + "IxVM::normalize_imax_dispatch", + "IxVM::nlvars_max_offset", + "IxVM::nlvars_subsume", + "IxVM::expr_has_bvar_at_let", + "IxVM::expr_inst1_let", + "IxVM::try_quot_iota", + "IxVM::quot_lift_addr_iota", + "IxVM::try_quot_lift", + "IxVM::quot_extract_arg", + "IxVM::quot_ctor_addr_iota", + "IxVM::quot_ind_addr_iota", + "IxVM::build_succ_offset", + "IxVM::se_mentions", + "IxVM::canon_cmp_kexpr_node_ctx" + ], + "shape": [ + 116, + 50, + 2 + ], + "cost": [ + 116, + 1, + 0, + 0, + 1856, + 32832 + ] + }, + { + "members": [ + "IxVM::expr_inst_many_walk", + "IxVM::expr_lower_walk" + ], + "shape": [ + 31, + 14, + 2 + ], + "cost": [ + 31, + 1, + 1984, + 57216, + 1015808, + 72646656 + ] + }, + { + "members": [ + "IxVM::k_is_def_eq_ordered" + ], + "shape": [ + 9, + 4, + 2 + ], + "cost": [ + 9, + 1, + 288, + 8544, + 36864, + 2555904 + ] + }, + { + "members": [ + "IxVM::try_def_eq_app" + ], + "shape": [ + 32, + 12, + 2 + ], + "cost": [ + 32, + 1, + 1024, + 23424, + 131072, + 7127040 + ] + }, + { + "members": [ + "IxVM::de_args", + "IxVM::peel_beta" + ], + "shape": [ + 23, + 10, + 2 + ], + "cost": [ + 23, + 1, + 736, + 18144, + 188416, + 11919360 + ] + }, + { + "members": [ + "IxVM::address_eq", + "IxVM::whnf" + ], + "shape": [ + 73, + 12, + 2 + ], + "cost": [ + 73, + 1, + 4672, + 103296, + 598016, + 28532736 + ] + }, + { + "members": [ + "IxVM::nl_eq", + "IxVM::nl_subsume_entry", + "IxVM::nat_sub_addr", + "IxVM::nat_div_addr", + "IxVM::try_extract_nat_app", + "IxVM::replace_spine_major", + "IxVM::try_unfold_head", + "IxVM::projection_addr_ctor", + "IxVM::peel_ctor_params_subst", + "IxVM::build_rule_rhs" + ], + "shape": [ + 69, + 30, + 2 + ], + "cost": [ + 69, + 1, + 552, + 7512, + 35328, + 1430016 + ] + }, + { + "members": [ + "IxVM::nl_skip_empty", + "IxVM::normalize_aux", + "IxVM::divide_grow" + ], + "shape": [ + 28, + 20, + 2 + ], + "cost": [ + 28, + 1, + 224, + 3840, + 3584, + 141312 + ] + }, + { + "members": [ + "IxVM::nlvars_eq", + "IxVM::glist_ordered_insert", + "IxVM::se_parent_addr", + "IxVM::nat_zero_addr", + "IxVM::se_scan_fields", + "IxVM::nat_addr_io", + "IxVM::mk_bool", + "IxVM::divmod_64u", + "IxVM::utf8_last_codepoint", + "IxVM::utf8_last_go", + "IxVM::byte_array_empty_addr", + "IxVM::np_whnf_inner_bv", + "IxVM::mk_nat_literal_64", + "IxVM::k_is_def_eq_struct_go", + "IxVM::build_rec_lvls_list", + "${\"name\":\"IxVM::list_snoc\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}" + ], + "shape": [ + 79, + 34, + 2 + ], + "cost": [ + 79, + 1, + 0, + 0, + 10112, + 316032 + ] + }, + { + "members": [ + "IxVM::nl_add_const_go", + "IxVM::try_nat_dispatch_prewhnf", + "IxVM::try_dec_dispatch", + "IxVM::dec_rewrite_lt_to_le", + "IxVM::quot_type_addr", + "${\"name\":\"IxVM::list_concat\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\"]}}]}", + "IxVM::check_valid_ind_app", + "IxVM::eval_body", + "IxVM::def_kind_tag", + "IxVM::check_opt_u64", + "IxVM::check_opt_expr_addr", + "IxVM::check_opt_bool", + "IxVM::check_opt_recr_rules", + "IxVM::check_opt_addr", + "IxVM::check_opt_ctor_entries", + "IxVM::run_contains" + ], + "shape": [ + 65, + 48, + 2 + ], + "cost": [ + 65, + 1, + 65, + 351, + 8320, + 316032 + ] + }, + { + "members": [ + "IxVM::nlvars_add", + "IxVM::try_k_synth_iota", + "IxVM::mk_nat_offset_stuck", + "IxVM::klimbs_from_g", + "IxVM::fin_addr", + "UInt64::xor", + "IxVM::is_int_dec_prim_addr", + "IxVM::try_extract_int", + "IxVM::normalize_int_dec_rebuild", + "IxVM::try_extract_int_prim", + "IxVM::literal_eq", + "IxVM::check_quot", + "IxVM::check_large_walk_fields", + "IxVM::kexpr_struct_eq", + "IxVM::subst_param_for", + "IxVM::ctor_subst_param_for" + ], + "shape": [ + 114, + 26, + 2 + ], + "cost": [ + 114, + 1, + 0, + 0, + 3648, + 69504 + ] + }, + { + "members": [ + "IxVM::glist_subset", + "IxVM::delta_rank", + "IxVM::k_infer_let_env", + "IxVM::k_infer_let_env_rebase", + "IxVM::build_major_params" + ], + "shape": [ + 31, + 20, + 2 + ], + "cost": [ + 31, + 1, + 31, + 165, + 15872, + 766464 + ] + }, + { + "members": [ + "IxVM::glist_eq_len", + "IxVM::slow2_after_delta", + "IxVM::k_is_def_eq_struct", + "IxVM::peel_n_foralls_with_types", + "${\"name\":\"IxVM::list_reverse_acc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}" + ], + "shape": [ + 24, + 8, + 2 + ], + "cost": [ + 24, + 1, + 48, + 240, + 12288, + 503808 + ] + }, + { + "members": [ + "IxVM::k_is_def_eq_slow", + "IxVM::expr_inst1" + ], + "shape": [ + 15, + 12, + 2 + ], + "cost": [ + 15, + 1, + 480, + 15264, + 122880, + 10002432 + ] + }, + { + "members": [ + "IxVM::try_string_lit_one" + ], + "shape": [ + 14, + 6, + 2 + ], + "cost": [ + 14, + 1, + 224, + 4800, + 57344, + 3588096 + ] + }, + { + "members": [ + "IxVM::whnf_nd", + "IxVM::try_proof_irrel", + "IxVM::env_walk_refs_all" + ], + "shape": [ + 47, + 12, + 2 + ], + "cost": [ + 47, + 1, + 188, + 1560, + 192512, + 9338880 + ] + }, + { + "members": [ + "IxVM::whnf_nd_with_spine" + ], + "shape": [ + 20, + 12, + 2 + ], + "cost": [ + 20, + 1, + 160, + 2688, + 81920, + 5357568 + ] + }, + { + "members": [ + "IxVM::expr_inst1_walk" + ], + "shape": [ + 20, + 14, + 2 + ], + "cost": [ + 20, + 1, + 160, + 2832, + 81920, + 5652480 + ] + }, + { + "members": [ + "IxVM::nat_succ_addr", + "IxVM::nat_add_addr", + "IxVM::string_append_addr", + "IxVM::subtype_val_addr", + "IxVM::int_dec_le_addr_dec", + "IxVM::int_dec_eq_addr_dec", + "IxVM::int_dec_lt_addr_dec", + "IxVM::int_add_addr", + "IxVM::int_mul_addr", + "IxVM::int_neg_addr", + "IxVM::int_emod_addr", + "IxVM::int_ediv_addr", + "IxVM::int_bmod_addr", + "IxVM::int_bdiv_addr", + "IxVM::int_nat_abs_addr", + "IxVM::int_pow_addr" + ], + "shape": [ + 18, + 4, + 2 + ], + "cost": [ + 18, + 1, + 288, + 5184, + 576, + 12864 + ] + }, + { + "members": [ + "IxVM::nat_mod_addr", + "IxVM::nat_pow_addr", + "IxVM::nat_beq_addr", + "IxVM::string_of_list_addr", + "IxVM::string_back_addr", + "IxVM::string_legacy_back_addr", + "IxVM::string_to_byte_array_addr", + "IxVM::string_dec_eq_addr", + "IxVM::punit_size_of_1_addr", + "IxVM::reduce_bool_addr", + "IxVM::reduce_nat_addr", + "IxVM::canon_ord_then" + ], + "shape": [ + 17, + 4, + 2 + ], + "cost": [ + 17, + 1, + 272, + 4992, + 272, + 4992 + ] + }, + { + "members": [ + "IxVM::nat_ble_addr", + "IxVM::nat_land_addr", + "IxVM::nat_lor_addr", + "IxVM::nat_shift_left_addr", + "IxVM::nat_dec_le_addr_dec", + "IxVM::nat_dec_eq_addr_dec", + "IxVM::nat_dec_lt_addr_dec", + "IxVM::int_sub_addr" + ], + "shape": [ + 10, + 4, + 2 + ], + "cost": [ + 10, + 1, + 80, + 1392, + 80, + 1392 + ] + }, + { + "members": [ + "IxVM::is_str_prim_addr", + "IxVM::is_native_prim_addr", + "IxVM::try_same_proj_head_app", + "IxVM::infer_let_drop_unused" + ], + "shape": [ + 51, + 30, + 2 + ], + "cost": [ + 51, + 1, + 102, + 534, + 26112, + 1181184 + ] + }, + { + "members": [ + "IxVM::is_dec_prim_addr", + "IxVM::k_infer_let_env_core", + "IxVM::peel_field_loop", + "IxVM::assert_return_head_is_parent" + ], + "shape": [ + 37, + 52, + 2 + ], + "cost": [ + 37, + 1, + 37, + 279, + 18944, + 1291776 + ] + }, + { + "members": [ + "IxVM::whnf_spine", + "IxVM::lazy_delta_both_proj", + "IxVM::infer_let_materialize" + ], + "shape": [ + 35, + 24, + 2 + ], + "cost": [ + 35, + 1, + 35, + 189, + 35840, + 1947648 + ] + }, + { + "members": [ + "IxVM::whnf_with_spine", + "IxVM::k_def_eq_rebase" + ], + "shape": [ + 24, + 26, + 2 + ], + "cost": [ + 24, + 1, + 384, + 10560, + 196608, + 17350656 + ] + }, + { + "members": [ + "IxVM::whnf_const_head", + "IxVM::whnf_iota_major", + "IxVM::slow2_eager_fallback", + "IxVM::check_inductive_shape_ctors" + ], + "shape": [ + 65, + 42, + 2 + ], + "cost": [ + 65, + 1, + 0, + 0, + 66560, + 3422208 + ] + }, + { + "members": [ + "IxVM::projection_definition_info", + "IxVM::k_is_def_eq_slow_nd_after_core", + "IxVM::delta_unfold", + "IxVM::expr_mentions_block" + ], + "shape": [ + 48, + 14, + 2 + ], + "cost": [ + 48, + 1, + 192, + 1632, + 49152, + 2039808 + ] + }, + { + "members": [ + "IxVM::canon_cprj_addr", + "IxVM::is_nat_succ_ih_step", + "IxVM::klimbs_add", + "IxVM::klimbs_normalize", + "UInt64::sub_with_borrow", + "IxVM::compute_iprj_addr", + "IxVM::rec_to_parent_addr", + "IxVM::io_peel_field_loop", + "IxVM::assert_lvls_are_params", + "${\"name\":\"IxVM::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::KRecRule\"}}]}", + "IxVM::is_large_eliminator", + "IxVM::build_flat_own_params", + "IxVM::flat_find_pos_kind", + "IxVM::build_all_motives", + "IxVM::build_motive_type_flat", + "IxVM::walk_refs_transitive" + ], + "shape": [ + 73, + 22, + 2 + ], + "cost": [ + 73, + 1, + 0, + 0, + 18688, + 611328 + ] + }, + { + "members": [ + "${\"name\":\"IxVM::list_take\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}", + "IxVM::ctx_trim" + ], + "shape": [ + 15, + 16, + 2 + ], + "cost": [ + 15, + 1, + 120, + 2616, + 61440, + 5210112 + ] + }, + { + "members": [ + "IxVM::try_extract_nat", + "IxVM::is_prop_type", + "IxVM::infer_let_lookup_type", + "IxVM::is_inductive_prop", + "IxVM::check_param_agreement", + "IxVM::list_any_mentions_block", + "IxVM::check_field_universes", + "IxVM::check_field_universes_inner", + "IxVM::check_positivity", + "IxVM::is_rec_field" + ], + "shape": [ + 36, + 12, + 2 + ], + "cost": [ + 36, + 1, + 36, + 156, + 18432, + 724992 + ] + }, + { + "members": [ + "IxVM::klimbs_add_carry", + "IxVM::klimbs_sub_borrow", + "IxVM::whnf_struct_core_proj", + "IxVM::lazy_delta_step_const_const", + "IxVM::try_lazy_delta_app", + "IxVM::expr_glb_let", + "IxVM::build_minor_at_depth", + "IxVM::build_ih_doms", + "IxVM::compare_rules" + ], + "shape": [ + 84, + 42, + 2 + ], + "cost": [ + 84, + 1, + 0, + 0, + 43008, + 1803264 + ] + }, + { + "members": [ + "IxVM::klimbs_dec", + "IxVM::se_peel_tol", + "IxVM::char_of_nat_addr", + "IxVM::split_u32", + "IxVM::divmod_256", + "IxVM::klimbs_div", + "IxVM::klimbs_mod", + "IxVM::klimbs_gcd", + "IxVM::klimbs_shl", + "IxVM::klimbs_shr", + "IxVM::mk_nat_binop_stuck", + "IxVM::char_lit_codepoint", + "IxVM::utf8_groups", + "IxVM::int_add_prim", + "IxVM::count_foralls_at_least", + "IxVM::all_bvars_in_args" + ], + "shape": [ + 38, + 16, + 2 + ], + "cost": [ + 38, + 1, + 0, + 0, + 608, + 11328 + ] + }, + { + "members": [ + "IxVM::build_char_list", + "IxVM::try_nat_offset_dispatch", + "IxVM::char_lit_codepoint_syn", + "IxVM::try_bitvec_dispatch", + "IxVM::bitvec_prep_spine", + "IxVM::bv_to_nat_via", + "IxVM::bitvec_prep_spine_ult", + "IxVM::mk_nat_one", + "IxVM::system_platform_get_num_bits_addr", + "IxVM::check_native_bool", + "IxVM::check_native_nat", + "IxVM::try_normalize_int_decidable", + "IxVM::intern_int_lit", + "IxVM::nat_not_le_of_not_ble_eq_true_addr_dec", + "IxVM::mk_int_prim", + "IxVM::int_bmod_prim" + ], + "shape": [ + 82, + 36, + 2 + ], + "cost": [ + 82, + 1, + 0, + 0, + 1312, + 23616 + ] + }, + { + "members": [ + "IxVM::decidable_rec_addr", + "IxVM::bool_false_addr", + "IxVM::bool_true_addr", + "IxVM::eq_refl_addr_dec", + "IxVM::decidable_is_true_addr_dec", + "IxVM::bit_vec_of_nat_addr", + "IxVM::lt_lt_addr", + "IxVM::bit_vec_addr", + "IxVM::int_of_nat_addr_dec", + "IxVM::int_neg_succ_addr_dec", + "IxVM::bool_type_addr_dec", + "IxVM::nat_le_of_ble_eq_true_addr_dec", + "IxVM::nat_eq_of_beq_eq_true_addr_dec", + "IxVM::nat_ne_of_beq_eq_false_addr_dec", + "IxVM::decidable_is_false_addr_dec", + "IxVM::eq_type_addr" + ], + "shape": [ + 18, + 4, + 2 + ], + "cost": [ + 18, + 1, + 0, + 0, + 288, + 5184 + ] + }, + { + "members": [ + "IxVM::k_is_def_eq_slow_nd" + ], + "shape": [ + 14, + 6, + 2 + ], + "cost": [ + 14, + 1, + 224, + 4800, + 57344, + 3588096 + ] + }, + { + "members": [ + "IxVM::whnf_struct_core" + ], + "shape": [ + 22, + 6, + 2 + ], + "cost": [ + 22, + 1, + 352, + 6336, + 90112, + 4767744 + ] + }, + { + "members": [ + "IxVM::whnf_struct_core_const", + "IxVM::try_unfold_proj_app", + "IxVM::caddr_is_peer", + "IxVM::check_rec_rules_wellscoped", + "IxVM::const_idxs_rules", + "IxVM::run_check_env" + ], + "shape": [ + 41, + 18, + 2 + ], + "cost": [ + 41, + 1, + 164, + 1560, + 41984, + 1947648 + ] + }, + { + "members": [ + "IxVM::try_eta_struct" + ], + "shape": [ + 61, + 14, + 2 + ], + "cost": [ + 61, + 1, + 122, + 498, + 31232, + 1098240 + ] + }, + { + "members": [ + "IxVM::try_def_eq_nat", + "IxVM::lazy_delta_loop" + ], + "shape": [ + 29, + 16, + 2 + ], + "cost": [ + 29, + 1, + 116, + 1224, + 59392, + 3336192 + ] + }, + { + "members": [ + "IxVM::is_nat_zero" + ], + "shape": [ + 13, + 6, + 2 + ], + "cost": [ + 13, + 1, + 26, + 162, + 13312, + 718848 + ] + }, + { + "members": [ + "IxVM::k_is_def_eq_struct_bounded" + ], + "shape": [ + 43, + 24, + 2 + ], + "cost": [ + 43, + 1, + 43, + 213, + 176128, + 10518528 + ] + }, + { + "members": [ + "IxVM::k_is_def_eq_structure_tree", + "IxVM::parse_atree_body" + ], + "shape": [ + 19, + 22, + 2 + ], + "cost": [ + 19, + 1, + 304, + 8832, + 19456, + 1394688 + ] + }, + { + "members": [ + "IxVM::expr_glb" + ], + "shape": [ + 9, + 4, + 2 + ], + "cost": [ + 9, + 1, + 576, + 20352, + 294912, + 25460736 + ] + }, + { + "members": [ + "IxVM::expr_glb_binder" + ], + "shape": [ + 10, + 4, + 2 + ], + "cost": [ + 10, + 1, + 80, + 1392, + 81920, + 5849088 + ] + }, + { + "members": [ + "IxVM::k_infer_rebase" + ], + "shape": [ + 15, + 12, + 2 + ], + "cost": [ + 15, + 1, + 240, + 6144, + 122880, + 10002432 + ] + }, + { + "members": [ + "IxVM::canon_ord_cmp_g" + ], + "shape": [ + 8, + 2, + 2 + ], + "cost": [ + 8, + 1, + 2048, + 89088, + 0, + 0 + ] + }, + { + "members": [ + "IxVM::canon_addr_cmp" + ], + "shape": [ + 83, + 36, + 1 + ], + "cost": [ + 83, + 1, + 2656, + 58208, + 0, + 0 + ] + }, + { + "members": [ + "IxVM::canon_addr_chunk" + ], + "shape": [ + 11, + 4, + 1 + ], + "cost": [ + 11, + 1, + 2816, + 105472, + 0, + 0 + ] + }, + { + "members": [ + "IxVM::canon_cmp_kliteral", + "IxVM::canon_cmp_bytes", + "IxVM::canon_cmp_ctor_range_ctx", + "IxVM::canon_cmp_ctor_pair_ctx", + "IxVM::canon_cmp_krec_rule_list_ctx", + "IxVM::canon_cmp_krec_rule_ctx", + "IxVM::canon_group_walk", + "IxVM::canon_all_singleton", + "IxVM::canon_flatten", + "IxVM::nl_covers_const", + "IxVM::get_ctor_entry_list_inner", + "IxVM::get_reveal_ctor_info", + "IxVM::run_reveal", + "IxVM::expr_addr", + "IxVM::check_mut_const", + "IxVM::check_ctor_entry" + ], + "shape": [ + 155, + 42, + 2 + ], + "cost": [ + 155, + 1, + 0, + 0, + 310, + 1230 + ] + }, + { + "members": [ + "IxVM::g_list_has" + ], + "shape": [ + 11, + 4, + 2 + ], + "cost": [ + 11, + 1, + 352, + 9504, + 180224, + 13271040 + ] + } + ] +} diff --git a/docs/benchmarks/formal-aiur-grouping-tuning/ixvm-ungrouped-shapes.json b/docs/benchmarks/formal-aiur-grouping-tuning/ixvm-ungrouped-shapes.json new file mode 100644 index 000000000..57c59cb93 --- /dev/null +++ b/docs/benchmarks/formal-aiur-grouping-tuning/ixvm-ungrouped-shapes.json @@ -0,0 +1 @@ +{"circuits":[{"cells":10,"fft_cost":48.0,"height":1,"index":0,"lookup_group_size":1,"lookups":2,"name":"IxVM::verify_claim","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":4},{"cells":128,"fft_cost":546.0,"height":1,"index":1,"lookup_group_size":1,"lookups":25,"name":"IxVM::run_claim","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":128,"stage2_width":50},{"cells":112,"fft_cost":2944.0,"height":16,"index":2,"lookup_group_size":1,"lookups":3,"name":"IxVM::read_finite_byte_stream","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":6},{"cells":45056,"fft_cost":3440640.0,"height":4096,"index":3,"lookup_group_size":1,"lookups":4,"name":"IxVM::read_byte_stream","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":8},{"cells":36864,"fft_cost":2818048.0,"height":4096,"index":4,"lookup_group_size":1,"lookups":4,"name":"${\"name\":\"IxVM::list_depth_checked\",\"types\":[\"field\"]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":9,"stage2_width":8},{"cells":4096,"fft_cost":311296.0,"height":1024,"index":5,"lookup_group_size":1,"lookups":2,"name":"IxVM::checked_depth_succ","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":4,"stage2_width":4},{"cells":28672,"fft_cost":2035712.0,"height":2048,"index":6,"lookup_group_size":1,"lookups":7,"name":"UInt32::less_than_fields","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":14,"stage2_width":14},{"cells":4480,"fft_cost":75264.0,"height":32,"index":7,"lookup_group_size":1,"lookups":6,"name":"Blake3::compress_layer","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":140,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":8,"lookup_group_size":1,"lookups":10,"name":"Blake3::next_layer","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":177,"stage2_width":20},{"cells":256512,"fft_cost":10111488.0,"height":512,"index":9,"lookup_group_size":2,"lookups":226,"name":"Blake3::compress","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":501,"stage2_width":226},{"cells":69632,"fft_cost":4030464.0,"height":4096,"index":10,"lookup_group_size":2,"lookups":6,"name":"Blake3::compress_chunks","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":6},{"cells":5312,"fft_cost":95424.0,"height":32,"index":11,"lookup_group_size":1,"lookups":14,"name":"Blake3::finish","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":166,"stage2_width":28},{"cells":608,"fft_cost":12384.0,"height":32,"index":12,"lookup_group_size":1,"lookups":1,"name":"UInt64::is_zero","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":2},{"cells":8384,"fft_cost":303232.0,"height":64,"index":13,"lookup_group_size":1,"lookups":65,"name":"Blake3::bytes_to_block","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":131,"stage2_width":130},{"cells":16384,"fft_cost":1105920.0,"height":2048,"index":14,"lookup_group_size":2,"lookups":3,"name":"Blake3::pad_block","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":4},{"cells":5760,"fft_cost":111744.0,"height":32,"index":15,"lookup_group_size":1,"lookups":24,"name":"Blake3::compress_block","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":180,"stage2_width":48},{"cells":224,"fft_cost":6368.0,"height":32,"index":16,"lookup_group_size":1,"lookups":2,"name":"${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":17,"lookup_group_size":1,"lookups":2,"name":"UInt64::wrapping_succ","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":4},{"cells":11776,"fft_cost":517632.0,"height":512,"index":18,"lookup_group_size":1,"lookups":5,"name":"IxVM::get_tagn4","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":10},{"cells":704,"fft_cost":17408.0,"height":32,"index":19,"lookup_group_size":1,"lookups":6,"name":"IxVM::get_tagn_tail","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":22,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":20,"lookup_group_size":1,"lookups":5,"name":"IxVM::get_tagn_wide","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":28,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":21,"lookup_group_size":1,"lookups":3,"name":"IxVM::get_u64_le","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":22,"lookup_group_size":1,"lookups":9,"name":"UInt64::add","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":26,"stage2_width":18},{"cells":640,"fft_cost":30080.0,"height":128,"index":23,"lookup_group_size":1,"lookups":2,"name":"IxVM::read_byte","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":5,"stage2_width":4},{"cells":4352,"fft_cost":159232.0,"height":64,"index":24,"lookup_group_size":1,"lookups":34,"name":"IxVM::get_address","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":68,"stage2_width":68},{"cells":8,"fft_cost":54.0,"height":1,"index":25,"lookup_group_size":1,"lookups":3,"name":"IxVM::get_opt_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":26,"lookup_group_size":1,"lookups":12,"name":"IxVM::run_eval","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":22,"stage2_width":24},{"cells":16,"fft_cost":78.0,"height":1,"index":27,"lookup_group_size":1,"lookups":4,"name":"IxVM::run_check","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":16,"stage2_width":8},{"cells":1232,"fft_cost":22272.0,"height":16,"index":28,"lookup_group_size":1,"lookups":17,"name":"IxVM::get_ci","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":77,"stage2_width":34},{"cells":1424,"fft_cost":19840.0,"height":16,"index":29,"lookup_group_size":1,"lookups":6,"name":"IxVM::load_verified_constant","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":89,"stage2_width":12},{"cells":1152,"fft_cost":16960.0,"height":16,"index":30,"lookup_group_size":1,"lookups":7,"name":"Blake3::verify_bytes_against","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":72,"stage2_width":14},{"cells":1520,"fft_cost":22528.0,"height":16,"index":31,"lookup_group_size":1,"lookups":10,"name":"IxVM::get_constant","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":95,"stage2_width":20},{"cells":280,"fft_cost":2112.0,"height":4,"index":32,"lookup_group_size":1,"lookups":6,"name":"IxVM::get_mut_const_list","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":70,"stage2_width":12},{"cells":104,"fft_cost":420.0,"height":2,"index":33,"lookup_group_size":1,"lookups":5,"name":"IxVM::get_mut_const","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":52,"stage2_width":10},{"cells":160,"fft_cost":2480.0,"height":8,"index":34,"lookup_group_size":1,"lookups":6,"name":"IxVM::get_definition","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":20,"stage2_width":12},{"cells":22,"fft_cost":98.0,"height":2,"index":35,"lookup_group_size":1,"lookups":1,"name":"IxVM::unpack_def_kind_safety","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":2},{"cells":4352,"fft_cost":166912.0,"height":256,"index":36,"lookup_group_size":1,"lookups":4,"name":"IxVM::get_tagn0","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":17,"stage2_width":8},{"cells":24576,"fft_cost":1056768.0,"height":512,"index":37,"lookup_group_size":1,"lookups":12,"name":"IxVM::get_expr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":48,"stage2_width":24},{"cells":4224,"fft_cost":133248.0,"height":128,"index":38,"lookup_group_size":1,"lookups":6,"name":"IxVM::get_u64_list","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":33,"stage2_width":12},{"cells":640,"fft_cost":13824.0,"height":32,"index":39,"lookup_group_size":1,"lookups":2,"name":"UInt64::saturating_pred","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":4},{"cells":6912,"fft_cost":252928.0,"height":256,"index":40,"lookup_group_size":1,"lookups":6,"name":"IxVM::get_app_telescope","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":27,"stage2_width":12},{"cells":2176,"fft_cost":62976.0,"height":64,"index":41,"lookup_group_size":1,"lookups":8,"name":"IxVM::get_lam_telescope","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":34,"stage2_width":16},{"cells":512,"fft_cost":12608.0,"height":32,"index":42,"lookup_group_size":1,"lookups":4,"name":"IxVM::get_lam_mode","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":16,"stage2_width":8},{"cells":15,"fft_cost":63.0,"height":1,"index":43,"lookup_group_size":1,"lookups":2,"name":"IxVM::binder_contract_from_bits","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":15,"stage2_width":4},{"cells":8,"fft_cost":36.0,"height":1,"index":44,"lookup_group_size":1,"lookups":1,"name":"IxVM::value_contract_from_bits","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":8,"stage2_width":2},{"cells":2176,"fft_cost":62976.0,"height":64,"index":45,"lookup_group_size":1,"lookups":8,"name":"IxVM::get_all_telescope","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":34,"stage2_width":16},{"cells":576,"fft_cost":14528.0,"height":32,"index":46,"lookup_group_size":1,"lookups":5,"name":"IxVM::get_all_mode","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":18,"stage2_width":10},{"cells":34,"fft_cost":156.0,"height":1,"index":47,"lookup_group_size":1,"lookups":8,"name":"IxVM::get_expr_let","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":34,"stage2_width":16},{"cells":106,"fft_cost":458.0,"height":2,"index":48,"lookup_group_size":1,"lookups":10,"name":"IxVM::get_inductive","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":53,"stage2_width":20},{"cells":5,"fft_cost":33.0,"height":1,"index":49,"lookup_group_size":1,"lookups":2,"name":"IxVM::assert_wire_bool","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":5,"stage2_width":4},{"cells":472,"fft_cost":5496.0,"height":8,"index":50,"lookup_group_size":1,"lookups":6,"name":"IxVM::get_constructor_list","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":59,"stage2_width":12},{"cells":172,"fft_cost":1480.0,"height":4,"index":51,"lookup_group_size":1,"lookups":8,"name":"IxVM::get_constructor","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":43,"stage2_width":16},{"cells":0,"fft_cost":0.0,"height":0,"index":52,"lookup_group_size":1,"lookups":12,"name":"IxVM::get_recursor","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":73,"stage2_width":24},{"cells":0,"fft_cost":0.0,"height":0,"index":53,"lookup_group_size":1,"lookups":7,"name":"IxVM::get_recursor_rule_list","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":35,"stage2_width":14},{"cells":896,"fft_cost":15168.0,"height":16,"index":54,"lookup_group_size":1,"lookups":9,"name":"IxVM::get_constant_info_by_variant","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":56,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":55,"lookup_group_size":1,"lookups":5,"name":"IxVM::get_axiom","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":16,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":56,"lookup_group_size":1,"lookups":5,"name":"IxVM::get_quotient","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":17,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":57,"lookup_group_size":1,"lookups":1,"name":"IxVM::get_quot_kind","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":6,"stage2_width":2},{"cells":0,"fft_cost":0.0,"height":0,"index":58,"lookup_group_size":1,"lookups":4,"name":"IxVM::get_constructor_proj","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":23,"stage2_width":8},{"cells":28,"fft_cost":140.0,"height":2,"index":59,"lookup_group_size":1,"lookups":3,"name":"IxVM::get_recursor_proj","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":14,"stage2_width":6},{"cells":1664,"fft_cost":49152.0,"height":64,"index":60,"lookup_group_size":1,"lookups":6,"name":"IxVM::get_expr_list","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":26,"stage2_width":12},{"cells":1664,"fft_cost":49152.0,"height":64,"index":61,"lookup_group_size":1,"lookups":6,"name":"IxVM::get_address_list","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":26,"stage2_width":12},{"cells":560,"fft_cost":10368.0,"height":16,"index":62,"lookup_group_size":1,"lookups":7,"name":"IxVM::get_univ_list","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":35,"stage2_width":14},{"cells":1248,"fft_cost":29664.0,"height":32,"index":63,"lookup_group_size":1,"lookups":9,"name":"IxVM::get_univ","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":39,"stage2_width":18},{"cells":736,"fft_cost":18144.0,"height":32,"index":64,"lookup_group_size":1,"lookups":5,"name":"IxVM::get_tagn2","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":10},{"cells":624,"fft_cost":10368.0,"height":16,"index":65,"lookup_group_size":1,"lookups":5,"name":"IxVM::build_succ_chain","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":39,"stage2_width":10},{"cells":288,"fft_cost":3056.0,"height":8,"index":66,"lookup_group_size":1,"lookups":2,"name":"IxVM::load_constant_hint","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":36,"stage2_width":4},{"cells":18,"fft_cost":114.0,"height":2,"index":67,"lookup_group_size":1,"lookups":1,"name":"IxVM::defn_is_unsafe_ci","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":2},{"cells":216,"fft_cost":2904.0,"height":8,"index":68,"lookup_group_size":1,"lookups":4,"name":"IxVM::convert_definition","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":8},{"cells":20992,"fft_cost":1153536.0,"height":512,"index":69,"lookup_group_size":1,"lookups":19,"name":"IxVM::convert_expr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":41,"stage2_width":38},{"cells":896,"fft_cost":40832.0,"height":128,"index":70,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":6},{"cells":2304,"fft_cost":119808.0,"height":256,"index":71,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":6},{"cells":320,"fft_cost":6848.0,"height":32,"index":72,"lookup_group_size":1,"lookups":1,"name":"UInt64::to_field","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":2},{"cells":304,"fft_cost":6912.0,"height":16,"index":73,"lookup_group_size":1,"lookups":6,"name":"IxVM::convert_univ","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":12},{"cells":640,"fft_cost":15744.0,"height":32,"index":74,"lookup_group_size":2,"lookups":7,"name":"IxVM::convert_univ_idxs","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":8},{"cells":76,"fft_cost":296.0,"height":2,"index":75,"lookup_group_size":1,"lookups":4,"name":"IxVM::load_verified_blob","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":38,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":76,"lookup_group_size":1,"lookups":4,"name":"IxVM::utf8_validate","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":9,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":77,"lookup_group_size":1,"lookups":16,"name":"IxVM::utf8_decode_one","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":31,"stage2_width":32},{"cells":0,"fft_cost":0.0,"height":0,"index":78,"lookup_group_size":1,"lookups":3,"name":"IxVM::utf8_cont","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":6},{"cells":66,"fft_cost":366.0,"height":2,"index":79,"lookup_group_size":1,"lookups":10,"name":"IxVM::bytes_to_limbs","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":33,"stage2_width":20},{"cells":160,"fft_cost":1248.0,"height":4,"index":80,"lookup_group_size":1,"lookups":3,"name":"IxVM::bytes_to_u64_limb","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":40,"stage2_width":6},{"cells":44,"fft_cost":504.0,"height":4,"index":81,"lookup_group_size":2,"lookups":4,"name":"IxVM::skip_bytes","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":82,"lookup_group_size":1,"lookups":3,"name":"IxVM::convert_axiom","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":18,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":83,"lookup_group_size":1,"lookups":3,"name":"IxVM::convert_quotient","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":18,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":84,"lookup_group_size":1,"lookups":7,"name":"IxVM::get_ci_dprj","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":120,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":85,"lookup_group_size":1,"lookups":5,"name":"${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":112,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":86,"lookup_group_size":2,"lookups":4,"name":"IxVM::defn_member_recur_addrs","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":4},{"cells":10,"fft_cost":74.0,"height":2,"index":87,"lookup_group_size":1,"lookups":2,"name":"IxVM::build_recur_addrs","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":5,"stage2_width":4},{"cells":228,"fft_cost":1656.0,"height":4,"index":88,"lookup_group_size":2,"lookups":5,"name":"IxVM::build_recur_addrs_walk","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":57,"stage2_width":6},{"cells":222,"fft_cost":794.0,"height":2,"index":89,"lookup_group_size":1,"lookups":9,"name":"IxVM::projection_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":111,"stage2_width":18},{"cells":194,"fft_cost":654.0,"height":2,"index":90,"lookup_group_size":2,"lookups":3,"name":"IxVM::muts_member_at","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":97,"stage2_width":4},{"cells":12,"fft_cost":78.0,"height":1,"index":91,"lookup_group_size":1,"lookups":6,"name":"UInt64::from_field","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":12,"stage2_width":12},{"cells":144,"fft_cost":588.0,"height":2,"index":92,"lookup_group_size":1,"lookups":9,"name":"IxVM::put_constant","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":72,"stage2_width":18},{"cells":14,"fft_cost":72.0,"height":1,"index":93,"lookup_group_size":1,"lookups":4,"name":"IxVM::put_sharing","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":14,"stage2_width":8},{"cells":92,"fft_cost":808.0,"height":4,"index":94,"lookup_group_size":1,"lookups":4,"name":"${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Expr\"}}}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":23,"stage2_width":8},{"cells":128,"fft_cost":2112.0,"height":8,"index":95,"lookup_group_size":1,"lookups":4,"name":"IxVM::put_tagn0","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":96,"lookup_group_size":1,"lookups":9,"name":"IxVM::put_tagn_tail","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":30,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":97,"lookup_group_size":1,"lookups":6,"name":"IxVM::put_tagn_wide","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":30,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":98,"lookup_group_size":2,"lookups":3,"name":"IxVM::put_u64_le","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":4},{"cells":29,"fft_cost":117.0,"height":1,"index":99,"lookup_group_size":2,"lookups":5,"name":"IxVM::put_expr_list","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":29,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":100,"lookup_group_size":1,"lookups":31,"name":"IxVM::put_expr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":104,"stage2_width":62},{"cells":36,"fft_cost":216.0,"height":2,"index":101,"lookup_group_size":1,"lookups":5,"name":"IxVM::put_tagn4","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":102,"lookup_group_size":1,"lookups":4,"name":"${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":30,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":103,"lookup_group_size":1,"lookups":4,"name":"IxVM::put_u64_list","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":17,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":104,"lookup_group_size":2,"lookups":4,"name":"IxVM::app_telescope_count","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":55,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":105,"lookup_group_size":2,"lookups":6,"name":"IxVM::put_app_telescope","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":60,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":106,"lookup_group_size":2,"lookups":4,"name":"IxVM::lam_telescope_count","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":55,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":107,"lookup_group_size":2,"lookups":7,"name":"IxVM::put_lam_telescope","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":61,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":108,"lookup_group_size":1,"lookups":4,"name":"IxVM::put_lam_mode","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":9,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":109,"lookup_group_size":1,"lookups":2,"name":"IxVM::binder_contract_code","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":110,"lookup_group_size":1,"lookups":1,"name":"IxVM::value_contract_code","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":8,"stage2_width":2},{"cells":0,"fft_cost":0.0,"height":0,"index":111,"lookup_group_size":2,"lookups":4,"name":"IxVM::all_telescope_count","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":55,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":112,"lookup_group_size":2,"lookups":7,"name":"IxVM::put_all_telescope","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":61,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":113,"lookup_group_size":1,"lookups":5,"name":"IxVM::put_all_mode","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":12,"stage2_width":10},{"cells":14,"fft_cost":72.0,"height":1,"index":114,"lookup_group_size":1,"lookups":4,"name":"IxVM::put_refs","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":14,"stage2_width":8},{"cells":10,"fft_cost":60.0,"height":1,"index":115,"lookup_group_size":1,"lookups":4,"name":"IxVM::put_address_list","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":8},{"cells":2176,"fft_cost":66368.0,"height":32,"index":116,"lookup_group_size":1,"lookups":34,"name":"IxVM::put_address","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":68,"stage2_width":68},{"cells":14,"fft_cost":72.0,"height":1,"index":117,"lookup_group_size":1,"lookups":4,"name":"IxVM::put_univs","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":14,"stage2_width":8},{"cells":20,"fft_cost":90.0,"height":1,"index":118,"lookup_group_size":2,"lookups":5,"name":"IxVM::put_univ_list","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":119,"lookup_group_size":1,"lookups":13,"name":"IxVM::put_univ","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":40,"stage2_width":26},{"cells":0,"fft_cost":0.0,"height":0,"index":120,"lookup_group_size":2,"lookups":4,"name":"IxVM::univ_succ_count","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":37,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":121,"lookup_group_size":2,"lookups":3,"name":"IxVM::univ_succ_base","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":30,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":122,"lookup_group_size":1,"lookups":5,"name":"IxVM::put_tagn2","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":123,"lookup_group_size":1,"lookups":4,"name":"${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::MutConst\"}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":67,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":124,"lookup_group_size":1,"lookups":4,"name":"IxVM::put_mut_const_list","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":54,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":125,"lookup_group_size":2,"lookups":5,"name":"IxVM::put_mut_const","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":52,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":126,"lookup_group_size":1,"lookups":9,"name":"IxVM::put_definition","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":57,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":127,"lookup_group_size":1,"lookups":1,"name":"IxVM::pack_def_kind_safety","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":12,"stage2_width":2},{"cells":0,"fft_cost":0.0,"height":0,"index":128,"lookup_group_size":1,"lookups":11,"name":"IxVM::put_inductive","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":64,"stage2_width":22},{"cells":0,"fft_cost":0.0,"height":0,"index":129,"lookup_group_size":1,"lookups":4,"name":"${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":56,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":130,"lookup_group_size":1,"lookups":4,"name":"IxVM::put_constructor_list","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":43,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":131,"lookup_group_size":1,"lookups":9,"name":"IxVM::put_constructor","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":62,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":132,"lookup_group_size":1,"lookups":13,"name":"IxVM::put_recursor","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":83,"stage2_width":26},{"cells":0,"fft_cost":0.0,"height":0,"index":133,"lookup_group_size":1,"lookups":4,"name":"${\"name\":\"IxVM::list_length_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::RecursorRule\"}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":31,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":134,"lookup_group_size":1,"lookups":4,"name":"IxVM::put_recursor_rule_list","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":18,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":135,"lookup_group_size":1,"lookups":4,"name":"IxVM::put_recursor_rule","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":32,"stage2_width":8},{"cells":112,"fft_cost":464.0,"height":2,"index":136,"lookup_group_size":1,"lookups":9,"name":"IxVM::put_constant_info","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":56,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":137,"lookup_group_size":1,"lookups":6,"name":"IxVM::put_axiom","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":35,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":138,"lookup_group_size":1,"lookups":5,"name":"IxVM::put_quotient","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":34,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":139,"lookup_group_size":1,"lookups":2,"name":"IxVM::put_quot_kind","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":140,"lookup_group_size":1,"lookups":4,"name":"IxVM::put_constructor_proj","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":23,"stage2_width":8},{"cells":28,"fft_cost":140.0,"height":2,"index":141,"lookup_group_size":1,"lookups":3,"name":"IxVM::put_recursor_proj","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":14,"stage2_width":6},{"cells":1312,"fft_cost":28448.0,"height":32,"index":142,"lookup_group_size":1,"lookups":8,"name":"Blake3::bytes_to_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":41,"stage2_width":16},{"cells":222,"fft_cost":758.0,"height":2,"index":143,"lookup_group_size":1,"lookups":6,"name":"IxVM::get_ci_iprj","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":111,"stage2_width":12},{"cells":80,"fft_cost":332.0,"height":2,"index":144,"lookup_group_size":1,"lookups":6,"name":"IxVM::convert_inductive","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":40,"stage2_width":12},{"cells":164,"fft_cost":1272.0,"height":4,"index":145,"lookup_group_size":1,"lookups":3,"name":"IxVM::count_ctors","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":41,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":146,"lookup_group_size":1,"lookups":7,"name":"IxVM::get_ci_cprj","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":146,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":147,"lookup_group_size":2,"lookups":3,"name":"IxVM::ctor_at","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":75,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":148,"lookup_group_size":1,"lookups":6,"name":"IxVM::convert_constructor","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":47,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":149,"lookup_group_size":1,"lookups":6,"name":"IxVM::get_ci_rprj","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":111,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":150,"lookup_group_size":1,"lookups":8,"name":"IxVM::convert_recursor","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":59,"stage2_width":16},{"cells":0,"fft_cost":0.0,"height":0,"index":151,"lookup_group_size":1,"lookups":6,"name":"IxVM::convert_rec_rules","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":24,"stage2_width":12},{"cells":42,"fft_cost":318.0,"height":1,"index":152,"lookup_group_size":1,"lookups":30,"name":"IxVM::check_const","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":42,"stage2_width":60},{"cells":184,"fft_cost":2184.0,"height":8,"index":153,"lookup_group_size":1,"lookups":1,"name":"IxVM::is_unsafe_ci","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":2},{"cells":2048,"fft_cost":69888.0,"height":64,"index":154,"lookup_group_size":1,"lookups":12,"name":"IxVM::validate_expr_well_scoped","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":32,"stage2_width":24},{"cells":24,"fft_cost":180.0,"height":2,"index":155,"lookup_group_size":1,"lookups":5,"name":"IxVM::validate_univ_params_seen","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":10},{"cells":168,"fft_cost":2040.0,"height":8,"index":156,"lookup_group_size":1,"lookups":1,"name":"IxVM::const_num_lvls","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":21,"stage2_width":2},{"cells":512,"fft_cost":21504.0,"height":64,"index":157,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":6},{"cells":64,"fft_cost":1328.0,"height":8,"index":158,"lookup_group_size":1,"lookups":4,"name":"IxVM::validate_univ_params_list","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":8,"stage2_width":8},{"cells":72,"fft_cost":1400.0,"height":8,"index":159,"lookup_group_size":1,"lookups":4,"name":"IxVM::k_ensure_sort","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":9,"stage2_width":8},{"cells":256,"fft_cost":9024.0,"height":32,"index":160,"lookup_group_size":2,"lookups":5,"name":"IxVM::k_infer","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":6},{"cells":2432,"fft_cost":111744.0,"height":128,"index":161,"lookup_group_size":1,"lookups":9,"name":"IxVM::expr_lbr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":18},{"cells":96,"fft_cost":2880.0,"height":16,"index":162,"lookup_group_size":1,"lookups":2,"name":"IxVM::lbr_max","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":6,"stage2_width":4},{"cells":40,"fft_cost":888.0,"height":8,"index":163,"lookup_group_size":1,"lookups":1,"name":"IxVM::lbr_dec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":5,"stage2_width":2},{"cells":0,"fft_cost":0.0,"height":0,"index":164,"lookup_group_size":1,"lookups":7,"name":"IxVM::expr_lbr_let","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":14},{"cells":1056,"fft_cost":40224.0,"height":32,"index":165,"lookup_group_size":1,"lookups":23,"name":"IxVM::k_infer_core","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":33,"stage2_width":46},{"cells":6,"fft_cost":42.0,"height":1,"index":166,"lookup_group_size":1,"lookups":3,"name":"IxVM::types_lookup","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":6,"stage2_width":6},{"cells":176,"fft_cost":3840.0,"height":16,"index":167,"lookup_group_size":2,"lookups":4,"name":"IxVM::expr_lift","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4},{"cells":20,"fft_cost":114.0,"height":1,"index":168,"lookup_group_size":1,"lookups":7,"name":"IxVM::expr_lift_walk","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":14},{"cells":8,"fft_cost":48.0,"height":1,"index":169,"lookup_group_size":2,"lookups":3,"name":"IxVM::expr_lift_bvar","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":170,"lookup_group_size":1,"lookups":5,"name":"IxVM::expr_lift_let","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":10},{"cells":52,"fft_cost":792.0,"height":4,"index":171,"lookup_group_size":1,"lookups":7,"name":"IxVM::level_reduce","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":172,"lookup_group_size":2,"lookups":5,"name":"IxVM::level_max","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":173,"lookup_group_size":1,"lookups":3,"name":"IxVM::level_explicit_val","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":174,"lookup_group_size":2,"lookups":7,"name":"IxVM::level_max_go","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":21,"stage2_width":8},{"cells":92,"fft_cost":984.0,"height":4,"index":175,"lookup_group_size":1,"lookups":6,"name":"IxVM::level_struct_eq","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":176,"lookup_group_size":2,"lookups":4,"name":"IxVM::level_max_subsumes","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":177,"lookup_group_size":1,"lookups":6,"name":"IxVM::level_max_offsets","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":13,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":178,"lookup_group_size":2,"lookups":3,"name":"IxVM::level_offset_of","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4},{"cells":21,"fft_cost":123.0,"height":1,"index":179,"lookup_group_size":1,"lookups":8,"name":"IxVM::level_imax","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":21,"stage2_width":16},{"cells":0,"fft_cost":0.0,"height":0,"index":180,"lookup_group_size":2,"lookups":5,"name":"IxVM::level_is_not_zero","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":6},{"cells":168,"fft_cost":2040.0,"height":8,"index":181,"lookup_group_size":1,"lookups":1,"name":"IxVM::const_type_of","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":21,"stage2_width":2},{"cells":640,"fft_cost":21504.0,"height":64,"index":182,"lookup_group_size":2,"lookups":3,"name":"IxVM::expr_inst_levels","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":4},{"cells":1280,"fft_cost":46848.0,"height":64,"index":183,"lookup_group_size":1,"lookups":8,"name":"IxVM::expr_inst_levels_walk","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":16},{"cells":224,"fft_cost":6720.0,"height":16,"index":184,"lookup_group_size":1,"lookups":8,"name":"IxVM::level_inst_params","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":14,"stage2_width":16},{"cells":176,"fft_cost":4224.0,"height":16,"index":185,"lookup_group_size":2,"lookups":5,"name":"IxVM::level_list_inst","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":6},{"cells":704,"fft_cost":29568.0,"height":64,"index":186,"lookup_group_size":1,"lookups":5,"name":"IxVM::collect_spine","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":10},{"cells":640,"fft_cost":28416.0,"height":64,"index":187,"lookup_group_size":1,"lookups":5,"name":"${\"name\":\"IxVM::list_snoc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":10},{"cells":960,"fft_cost":33024.0,"height":32,"index":188,"lookup_group_size":1,"lookups":17,"name":"IxVM::k_infer_app_spine_loop","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":30,"stage2_width":34},{"cells":960,"fft_cost":31872.0,"height":64,"index":189,"lookup_group_size":2,"lookups":7,"name":"IxVM::expr_inst_many","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":8},{"cells":1344,"fft_cost":48000.0,"height":64,"index":190,"lookup_group_size":1,"lookups":8,"name":"IxVM::has_bvar_in_range","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":21,"stage2_width":16},{"cells":18,"fft_cost":110.0,"height":2,"index":191,"lookup_group_size":1,"lookups":3,"name":"IxVM::has_bvar_in_range_binder","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":9,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":192,"lookup_group_size":1,"lookups":4,"name":"IxVM::has_bvar_in_range_let","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":12,"stage2_width":8},{"cells":1280,"fft_cost":44544.0,"height":64,"index":193,"lookup_group_size":1,"lookups":7,"name":"IxVM::expr_inst_many_walk","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":14},{"cells":320,"fft_cost":11648.0,"height":32,"index":194,"lookup_group_size":1,"lookups":6,"name":"IxVM::expr_inst_many_bvar","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":195,"lookup_group_size":1,"lookups":5,"name":"IxVM::expr_inst_many_let","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":10},{"cells":352,"fft_cost":9504.0,"height":32,"index":196,"lookup_group_size":2,"lookups":4,"name":"IxVM::expr_lower","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4},{"cells":352,"fft_cost":7872.0,"height":16,"index":197,"lookup_group_size":1,"lookups":7,"name":"IxVM::expr_lower_walk","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":22,"stage2_width":14},{"cells":112,"fft_cost":2944.0,"height":16,"index":198,"lookup_group_size":1,"lookups":3,"name":"IxVM::k_check","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":6},{"cells":352,"fft_cost":11424.0,"height":32,"index":199,"lookup_group_size":2,"lookups":7,"name":"IxVM::k_is_def_eq","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":8},{"cells":192,"fft_cost":5888.0,"height":32,"index":200,"lookup_group_size":1,"lookups":2,"name":"IxVM::k_is_def_eq_core","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":6,"stage2_width":4},{"cells":288,"fft_cost":8544.0,"height":32,"index":201,"lookup_group_size":2,"lookups":3,"name":"IxVM::k_is_def_eq_ordered","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":4},{"cells":1024,"fft_cost":23424.0,"height":32,"index":202,"lookup_group_size":2,"lookups":11,"name":"IxVM::try_def_eq_app","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":32,"stage2_width":12},{"cells":576,"fft_cost":13824.0,"height":32,"index":203,"lookup_group_size":2,"lookups":5,"name":"IxVM::de_args","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":6},{"cells":4544,"fft_cost":91776.0,"height":64,"index":204,"lookup_group_size":2,"lookups":4,"name":"IxVM::address_eq","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":71,"stage2_width":4},{"cells":592,"fft_cost":6000.0,"height":8,"index":205,"lookup_group_size":2,"lookups":3,"name":"IxVM::address_eq_tail","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":74,"stage2_width":4},{"cells":136,"fft_cost":2040.0,"height":8,"index":206,"lookup_group_size":2,"lookups":5,"name":"IxVM::level_list_eq","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":6},{"cells":36,"fft_cost":520.0,"height":4,"index":207,"lookup_group_size":1,"lookups":5,"name":"IxVM::level_equal","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":9,"stage2_width":10},{"cells":27,"fft_cost":153.0,"height":1,"index":208,"lookup_group_size":1,"lookups":10,"name":"IxVM::nl_eq","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":20},{"cells":64,"fft_cost":672.0,"height":4,"index":209,"lookup_group_size":2,"lookups":5,"name":"IxVM::nl_skip_empty","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":6},{"cells":18,"fft_cost":102.0,"height":1,"index":210,"lookup_group_size":1,"lookups":6,"name":"IxVM::glist_cmp","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":211,"lookup_group_size":1,"lookups":6,"name":"IxVM::nlvars_eq","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":21,"stage2_width":12},{"cells":22,"fft_cost":194.0,"height":2,"index":212,"lookup_group_size":1,"lookups":9,"name":"IxVM::level_normalize","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":18},{"cells":152,"fft_cost":3192.0,"height":8,"index":213,"lookup_group_size":1,"lookups":10,"name":"IxVM::normalize_aux","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":20},{"cells":24,"fft_cost":156.0,"height":2,"index":214,"lookup_group_size":1,"lookups":3,"name":"IxVM::nl_add_const","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":6},{"cells":20,"fft_cost":132.0,"height":1,"index":215,"lookup_group_size":1,"lookups":10,"name":"IxVM::nl_add_const_go","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":20},{"cells":0,"fft_cost":0.0,"height":0,"index":216,"lookup_group_size":1,"lookups":13,"name":"IxVM::normalize_imax_dispatch","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":21,"stage2_width":26},{"cells":0,"fft_cost":0.0,"height":0,"index":217,"lookup_group_size":1,"lookups":7,"name":"IxVM::glist_ordered_insert","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":218,"lookup_group_size":1,"lookups":12,"name":"IxVM::nl_add_var","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":21,"stage2_width":24},{"cells":0,"fft_cost":0.0,"height":0,"index":219,"lookup_group_size":1,"lookups":10,"name":"IxVM::nlvars_add","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":20},{"cells":44,"fft_cost":568.0,"height":4,"index":220,"lookup_group_size":1,"lookups":5,"name":"IxVM::nl_subsumption_walk","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":10},{"cells":160,"fft_cost":1488.0,"height":4,"index":221,"lookup_group_size":2,"lookups":15,"name":"IxVM::nl_subsume_entry","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":40,"stage2_width":16},{"cells":17,"fft_cost":99.0,"height":1,"index":222,"lookup_group_size":1,"lookups":6,"name":"IxVM::glist_subset","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":12},{"cells":14,"fft_cost":78.0,"height":1,"index":223,"lookup_group_size":1,"lookups":4,"name":"IxVM::glist_eq_len","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":14,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":224,"lookup_group_size":1,"lookups":5,"name":"IxVM::nlvars_max_offset","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":225,"lookup_group_size":2,"lookups":13,"name":"IxVM::nlvars_subsume","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":24,"stage2_width":14},{"cells":192,"fft_cost":4032.0,"height":16,"index":226,"lookup_group_size":2,"lookups":4,"name":"IxVM::k_is_def_eq_slow","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":4},{"cells":224,"fft_cost":4800.0,"height":16,"index":227,"lookup_group_size":2,"lookups":5,"name":"IxVM::try_string_lit_one","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":14,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":228,"lookup_group_size":1,"lookups":11,"name":"IxVM::str_lit_delta_step","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":38,"stage2_width":22},{"cells":88,"fft_cost":816.0,"height":4,"index":229,"lookup_group_size":2,"lookups":6,"name":"IxVM::whnf_nd","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":22,"stage2_width":6},{"cells":160,"fft_cost":2688.0,"height":8,"index":230,"lookup_group_size":2,"lookups":11,"name":"IxVM::whnf_nd_with_spine","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":12},{"cells":640,"fft_cost":23296.0,"height":64,"index":231,"lookup_group_size":1,"lookups":4,"name":"${\"name\":\"IxVM::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":8},{"cells":16,"fft_cost":90.0,"height":1,"index":232,"lookup_group_size":2,"lookups":10,"name":"IxVM::whnf_nd_apply_beta","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":10},{"cells":72,"fft_cost":720.0,"height":4,"index":233,"lookup_group_size":2,"lookups":5,"name":"IxVM::peel_beta","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":6},{"cells":80,"fft_cost":1472.0,"height":8,"index":234,"lookup_group_size":1,"lookups":4,"name":"IxVM::apply_spine","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":8},{"cells":192,"fft_cost":4416.0,"height":16,"index":235,"lookup_group_size":2,"lookups":6,"name":"IxVM::expr_inst1","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":6},{"cells":736,"fft_cost":19104.0,"height":32,"index":236,"lookup_group_size":1,"lookups":6,"name":"IxVM::expr_has_bvar_at","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":12},{"cells":9,"fft_cost":51.0,"height":1,"index":237,"lookup_group_size":2,"lookups":3,"name":"IxVM::expr_has_bvar_at_binder","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":238,"lookup_group_size":2,"lookups":4,"name":"IxVM::expr_has_bvar_at_let","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":4},{"cells":160,"fft_cost":2832.0,"height":8,"index":239,"lookup_group_size":1,"lookups":7,"name":"IxVM::expr_inst1_walk","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":14},{"cells":20,"fft_cost":156.0,"height":2,"index":240,"lookup_group_size":1,"lookups":4,"name":"IxVM::expr_inst1_bvar","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":241,"lookup_group_size":1,"lookups":5,"name":"IxVM::expr_inst1_let","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":10},{"cells":57,"fft_cost":321.0,"height":1,"index":242,"lookup_group_size":1,"lookups":23,"name":"IxVM::whnf_nd_const_head","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":57,"stage2_width":46},{"cells":85,"fft_cost":381.0,"height":1,"index":243,"lookup_group_size":2,"lookups":38,"name":"IxVM::prim_family","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":85,"stage2_width":38},{"cells":3,"fft_cost":27.0,"height":1,"index":244,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_succ_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":245,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_pred_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":246,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_add_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":247,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_sub_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":248,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_mul_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":249,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_div_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":250,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_mod_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":251,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_pow_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":252,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_gcd_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":253,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_beq_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":254,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_ble_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":255,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_land_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":256,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_lor_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":257,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_xor_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":258,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_shift_left_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":259,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_shift_right_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":31,"fft_cost":153.0,"height":1,"index":260,"lookup_group_size":2,"lookups":15,"name":"IxVM::is_str_prim_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":31,"stage2_width":16},{"cells":3,"fft_cost":27.0,"height":1,"index":261,"lookup_group_size":1,"lookups":2,"name":"IxVM::string_utf8_byte_size_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":262,"lookup_group_size":1,"lookups":2,"name":"IxVM::string_append_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":263,"lookup_group_size":1,"lookups":2,"name":"IxVM::string_of_list_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":264,"lookup_group_size":1,"lookups":2,"name":"IxVM::string_back_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":265,"lookup_group_size":1,"lookups":2,"name":"IxVM::string_legacy_back_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":266,"lookup_group_size":1,"lookups":2,"name":"IxVM::string_to_byte_array_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":267,"lookup_group_size":1,"lookups":2,"name":"IxVM::string_dec_eq_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":15,"fft_cost":81.0,"height":1,"index":268,"lookup_group_size":2,"lookups":7,"name":"IxVM::is_bitvec_prim_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":8},{"cells":3,"fft_cost":27.0,"height":1,"index":269,"lookup_group_size":1,"lookups":2,"name":"IxVM::bit_vec_to_nat_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":270,"lookup_group_size":1,"lookups":2,"name":"IxVM::bit_vec_ult_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":271,"lookup_group_size":1,"lookups":2,"name":"IxVM::decidable_decide_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":23,"fft_cost":117.0,"height":1,"index":272,"lookup_group_size":2,"lookups":11,"name":"IxVM::is_native_prim_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":12},{"cells":3,"fft_cost":27.0,"height":1,"index":273,"lookup_group_size":1,"lookups":2,"name":"IxVM::system_platform_num_bits_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":274,"lookup_group_size":1,"lookups":2,"name":"IxVM::punit_size_of_1_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":275,"lookup_group_size":1,"lookups":2,"name":"IxVM::reduce_bool_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":276,"lookup_group_size":1,"lookups":2,"name":"IxVM::reduce_nat_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":277,"lookup_group_size":1,"lookups":2,"name":"IxVM::subtype_val_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":27,"fft_cost":135.0,"height":1,"index":278,"lookup_group_size":2,"lookups":13,"name":"IxVM::is_dec_prim_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":14},{"cells":3,"fft_cost":27.0,"height":1,"index":279,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_dec_le_addr_dec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":280,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_dec_eq_addr_dec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":281,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_dec_lt_addr_dec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":282,"lookup_group_size":1,"lookups":2,"name":"IxVM::int_dec_le_addr_dec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":283,"lookup_group_size":1,"lookups":2,"name":"IxVM::int_dec_eq_addr_dec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":284,"lookup_group_size":1,"lookups":2,"name":"IxVM::int_dec_lt_addr_dec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":23,"fft_cost":201.0,"height":1,"index":285,"lookup_group_size":1,"lookups":21,"name":"IxVM::is_int_prim_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":23,"stage2_width":42},{"cells":3,"fft_cost":27.0,"height":1,"index":286,"lookup_group_size":1,"lookups":2,"name":"IxVM::int_add_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":287,"lookup_group_size":1,"lookups":2,"name":"IxVM::int_sub_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":288,"lookup_group_size":1,"lookups":2,"name":"IxVM::int_mul_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":289,"lookup_group_size":1,"lookups":2,"name":"IxVM::int_neg_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":290,"lookup_group_size":1,"lookups":2,"name":"IxVM::int_emod_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":291,"lookup_group_size":1,"lookups":2,"name":"IxVM::int_ediv_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":292,"lookup_group_size":1,"lookups":2,"name":"IxVM::int_bmod_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":293,"lookup_group_size":1,"lookups":2,"name":"IxVM::int_bdiv_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":294,"lookup_group_size":1,"lookups":2,"name":"IxVM::int_nat_abs_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":3,"fft_cost":27.0,"height":1,"index":295,"lookup_group_size":1,"lookups":2,"name":"IxVM::int_pow_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":22,"fft_cost":108.0,"height":1,"index":296,"lookup_group_size":2,"lookups":10,"name":"IxVM::try_prim_dispatch","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":22,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":297,"lookup_group_size":1,"lookups":24,"name":"IxVM::try_nat_dispatch_prewhnf","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":30,"stage2_width":48},{"cells":0,"fft_cost":0.0,"height":0,"index":298,"lookup_group_size":2,"lookups":5,"name":"IxVM::whnf_spine","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":6},{"cells":176,"fft_cost":2400.0,"height":8,"index":299,"lookup_group_size":2,"lookups":6,"name":"IxVM::whnf","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":22,"stage2_width":6},{"cells":80,"fft_cost":912.0,"height":4,"index":300,"lookup_group_size":2,"lookups":11,"name":"IxVM::whnf_with_spine","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":12},{"cells":16,"fft_cost":90.0,"height":1,"index":301,"lookup_group_size":2,"lookups":10,"name":"IxVM::whnf_apply_beta","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":302,"lookup_group_size":1,"lookups":21,"name":"IxVM::whnf_const_head","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":51,"stage2_width":42},{"cells":18,"fft_cost":114.0,"height":1,"index":303,"lookup_group_size":1,"lookups":8,"name":"IxVM::try_reduce_projection_definition","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":16},{"cells":48,"fft_cost":264.0,"height":2,"index":304,"lookup_group_size":1,"lookups":6,"name":"IxVM::projection_definition_info","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":24,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":305,"lookup_group_size":2,"lookups":8,"name":"IxVM::try_quot_iota","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":306,"lookup_group_size":1,"lookups":2,"name":"IxVM::quot_lift_addr_iota","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":307,"lookup_group_size":1,"lookups":9,"name":"IxVM::try_quot_lift","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":308,"lookup_group_size":1,"lookups":9,"name":"IxVM::quot_extract_arg","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":309,"lookup_group_size":1,"lookups":2,"name":"IxVM::quot_ctor_addr_iota","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":310,"lookup_group_size":1,"lookups":2,"name":"IxVM::quot_ind_addr_iota","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":311,"lookup_group_size":1,"lookups":9,"name":"IxVM::try_quot_ind","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":312,"lookup_group_size":1,"lookups":6,"name":"IxVM::se_parent_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":22,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":313,"lookup_group_size":1,"lookups":13,"name":"IxVM::try_k_synth_iota","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":31,"stage2_width":26},{"cells":0,"fft_cost":0.0,"height":0,"index":314,"lookup_group_size":2,"lookups":14,"name":"IxVM::k_synth_gate","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":39,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":315,"lookup_group_size":1,"lookups":9,"name":"IxVM::canon_cprj_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":27,"stage2_width":18},{"cells":20,"fft_cost":156.0,"height":2,"index":316,"lookup_group_size":1,"lookups":4,"name":"${\"name\":\"IxVM::list_take\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":317,"lookup_group_size":1,"lookups":25,"name":"IxVM::try_iota","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":43,"stage2_width":50},{"cells":0,"fft_cost":0.0,"height":0,"index":318,"lookup_group_size":1,"lookups":14,"name":"IxVM::try_nat_linear_rec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":28,"stage2_width":28},{"cells":0,"fft_cost":0.0,"height":0,"index":319,"lookup_group_size":1,"lookups":6,"name":"IxVM::try_extract_nat","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":320,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_zero_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":321,"lookup_group_size":1,"lookups":7,"name":"IxVM::try_extract_nat_app","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":322,"lookup_group_size":1,"lookups":6,"name":"IxVM::klimbs_succ","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":323,"lookup_group_size":2,"lookups":10,"name":"IxVM::is_nat_succ_ih_step","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":34,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":324,"lookup_group_size":1,"lookups":2,"name":"IxVM::mk_nat_lit","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":4,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":325,"lookup_group_size":1,"lookups":2,"name":"IxVM::klimbs_add","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":5,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":326,"lookup_group_size":1,"lookups":9,"name":"IxVM::klimbs_add_carry","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":50,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":327,"lookup_group_size":1,"lookups":10,"name":"IxVM::mk_nat_offset_stuck","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":20},{"cells":0,"fft_cost":0.0,"height":0,"index":328,"lookup_group_size":2,"lookups":3,"name":"IxVM::klimbs_is_zero","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":329,"lookup_group_size":1,"lookups":7,"name":"IxVM::klimbs_normalize","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":30,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":330,"lookup_group_size":2,"lookups":8,"name":"IxVM::cleanup_nat_offset_major","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":25,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":331,"lookup_group_size":1,"lookups":9,"name":"IxVM::try_match_nat_add","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":25,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":332,"lookup_group_size":1,"lookups":16,"name":"IxVM::build_succ_offset","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":21,"stage2_width":32},{"cells":0,"fft_cost":0.0,"height":0,"index":333,"lookup_group_size":1,"lookups":4,"name":"IxVM::klimbs_sub","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":8,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":334,"lookup_group_size":1,"lookups":12,"name":"IxVM::klimbs_sub_borrow","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":52,"stage2_width":24},{"cells":0,"fft_cost":0.0,"height":0,"index":335,"lookup_group_size":1,"lookups":9,"name":"UInt64::sub_with_borrow","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":26,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":336,"lookup_group_size":2,"lookups":9,"name":"IxVM::whnf_iota_major","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":29,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":337,"lookup_group_size":1,"lookups":11,"name":"IxVM::nat_lit_to_ctor_or_self","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":22},{"cells":0,"fft_cost":0.0,"height":0,"index":338,"lookup_group_size":1,"lookups":4,"name":"IxVM::klimbs_dec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":6,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":339,"lookup_group_size":1,"lookups":8,"name":"IxVM::collect_spine_of_ctor","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":16},{"cells":0,"fft_cost":0.0,"height":0,"index":340,"lookup_group_size":1,"lookups":8,"name":"IxVM::compute_iprj_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":18,"stage2_width":16},{"cells":0,"fft_cost":0.0,"height":0,"index":341,"lookup_group_size":2,"lookups":4,"name":"IxVM::find_rule","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":342,"lookup_group_size":1,"lookups":7,"name":"IxVM::replace_spine_major","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":343,"lookup_group_size":1,"lookups":5,"name":"IxVM::rec_to_parent_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":16,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":344,"lookup_group_size":2,"lookups":3,"name":"IxVM::peel_n_foralls","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":345,"lookup_group_size":1,"lookups":20,"name":"IxVM::try_struct_eta_iota","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":62,"stage2_width":40},{"cells":0,"fft_cost":0.0,"height":0,"index":346,"lookup_group_size":2,"lookups":5,"name":"IxVM::struct_is_rec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":347,"lookup_group_size":2,"lookups":5,"name":"IxVM::struct_block_member_addrs","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":56,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":348,"lookup_group_size":2,"lookups":6,"name":"IxVM::struct_scan_ctors","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":29,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":349,"lookup_group_size":2,"lookups":3,"name":"IxVM::se_peel_tol","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":350,"lookup_group_size":2,"lookups":4,"name":"IxVM::se_scan_fields","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":351,"lookup_group_size":1,"lookups":7,"name":"IxVM::se_mentions","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":26,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":352,"lookup_group_size":2,"lookups":4,"name":"IxVM::se_addr_in","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":4},{"cells":13,"fft_cost":69.0,"height":1,"index":353,"lookup_group_size":2,"lookups":6,"name":"IxVM::is_prop_type","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":6},{"cells":116,"fft_cost":864.0,"height":2,"index":354,"lookup_group_size":1,"lookups":39,"name":"IxVM::k_infer_only","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":58,"stage2_width":78},{"cells":0,"fft_cost":0.0,"height":0,"index":355,"lookup_group_size":1,"lookups":5,"name":"IxVM::ensure_sort_only","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":356,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_addr_io","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":357,"lookup_group_size":1,"lookups":2,"name":"IxVM::str_addr_io","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":358,"lookup_group_size":2,"lookups":5,"name":"IxVM::io_peel_params_subst","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":359,"lookup_group_size":2,"lookups":5,"name":"IxVM::io_peel_field_loop","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":6},{"cells":52,"fft_cost":648.0,"height":4,"index":360,"lookup_group_size":2,"lookups":8,"name":"IxVM::ctx_trim","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":8},{"cells":9,"fft_cost":69.0,"height":1,"index":361,"lookup_group_size":1,"lookups":5,"name":"IxVM::ctx_seek_cut","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":10},{"cells":7,"fft_cost":51.0,"height":1,"index":362,"lookup_group_size":1,"lookups":4,"name":"IxVM::ctx_next_cut","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":8},{"cells":11,"fft_cost":75.0,"height":1,"index":363,"lookup_group_size":1,"lookups":5,"name":"IxVM::ctx_close_cut","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":10},{"cells":96,"fft_cost":2880.0,"height":16,"index":364,"lookup_group_size":1,"lookups":2,"name":"IxVM::lbr_min","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":6,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":365,"lookup_group_size":2,"lookups":4,"name":"IxVM::apply_n_projs","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":366,"lookup_group_size":1,"lookups":13,"name":"IxVM::whnf_proj_head","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":37,"stage2_width":26},{"cells":0,"fft_cost":0.0,"height":0,"index":367,"lookup_group_size":2,"lookups":4,"name":"IxVM::str_lit_to_ctor_app_or_self","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":368,"lookup_group_size":1,"lookups":21,"name":"IxVM::str_lit_to_ctor","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":23,"stage2_width":42},{"cells":0,"fft_cost":0.0,"height":0,"index":369,"lookup_group_size":1,"lookups":2,"name":"IxVM::list_nil_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":370,"lookup_group_size":1,"lookups":2,"name":"IxVM::list_cons_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":371,"lookup_group_size":1,"lookups":2,"name":"IxVM::char_type_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":372,"lookup_group_size":1,"lookups":2,"name":"IxVM::char_of_nat_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":373,"lookup_group_size":1,"lookups":9,"name":"IxVM::build_char_list","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":18,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":374,"lookup_group_size":1,"lookups":9,"name":"IxVM::klimbs_from_g","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":14,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":375,"lookup_group_size":1,"lookups":5,"name":"IxVM::split_u32","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":376,"lookup_group_size":1,"lookups":3,"name":"IxVM::divmod_256","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":8,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":377,"lookup_group_size":1,"lookups":32,"name":"IxVM::try_reduce_fin_val_decidable_rec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":60,"stage2_width":64},{"cells":0,"fft_cost":0.0,"height":0,"index":378,"lookup_group_size":1,"lookups":2,"name":"IxVM::fin_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":379,"lookup_group_size":1,"lookups":2,"name":"IxVM::decidable_rec_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":380,"lookup_group_size":2,"lookups":6,"name":"IxVM::whnf_get_ctor_or_none","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":381,"lookup_group_size":1,"lookups":12,"name":"IxVM::try_nat_binop_dispatch","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":24,"stage2_width":24},{"cells":0,"fft_cost":0.0,"height":0,"index":382,"lookup_group_size":1,"lookups":70,"name":"IxVM::try_nat_binop_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":62,"stage2_width":140},{"cells":0,"fft_cost":0.0,"height":0,"index":383,"lookup_group_size":1,"lookups":3,"name":"IxVM::klimbs_mul","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":6,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":384,"lookup_group_size":1,"lookups":6,"name":"IxVM::klimbs_mul_outer","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":21,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":385,"lookup_group_size":1,"lookups":10,"name":"IxVM::klimbs_mul_single","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":68,"stage2_width":20},{"cells":0,"fft_cost":0.0,"height":0,"index":386,"lookup_group_size":1,"lookups":22,"name":"UInt64::mul","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":52,"stage2_width":44},{"cells":0,"fft_cost":0.0,"height":0,"index":387,"lookup_group_size":2,"lookups":3,"name":"IxVM::klimbs_shl_limbs","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":388,"lookup_group_size":1,"lookups":2,"name":"IxVM::klimbs_div","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":6,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":389,"lookup_group_size":1,"lookups":13,"name":"IxVM::klimbs_div_mod","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":26},{"cells":0,"fft_cost":0.0,"height":0,"index":390,"lookup_group_size":2,"lookups":6,"name":"IxVM::ordinary_div_mod","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":391,"lookup_group_size":1,"lookups":9,"name":"IxVM::divide_grow","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":392,"lookup_group_size":2,"lookups":3,"name":"IxVM::klimbs_le","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":393,"lookup_group_size":2,"lookups":5,"name":"IxVM::klimbs_eq","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":30,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":394,"lookup_group_size":1,"lookups":1,"name":"UInt64::eq","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":2},{"cells":0,"fft_cost":0.0,"height":0,"index":395,"lookup_group_size":1,"lookups":2,"name":"IxVM::klimbs_mod","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":6,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":396,"lookup_group_size":1,"lookups":4,"name":"IxVM::klimbs_gcd","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":8,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":397,"lookup_group_size":1,"lookups":11,"name":"IxVM::klimbs_pow","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":22},{"cells":0,"fft_cost":0.0,"height":0,"index":398,"lookup_group_size":1,"lookups":6,"name":"IxVM::klimbs_land","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":36,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":399,"lookup_group_size":1,"lookups":9,"name":"UInt64::and","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":26,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":400,"lookup_group_size":1,"lookups":6,"name":"IxVM::klimbs_lor","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":36,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":401,"lookup_group_size":1,"lookups":9,"name":"UInt64::or","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":26,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":402,"lookup_group_size":1,"lookups":6,"name":"IxVM::klimbs_xor_op","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":36,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":403,"lookup_group_size":1,"lookups":9,"name":"UInt64::xor","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":26,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":404,"lookup_group_size":1,"lookups":5,"name":"IxVM::klimbs_shl","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":8,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":405,"lookup_group_size":1,"lookups":5,"name":"IxVM::klimbs_shr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":8,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":406,"lookup_group_size":1,"lookups":5,"name":"IxVM::mk_bool","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":407,"lookup_group_size":1,"lookups":2,"name":"IxVM::bool_false_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":408,"lookup_group_size":1,"lookups":2,"name":"IxVM::bool_true_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":409,"lookup_group_size":1,"lookups":15,"name":"IxVM::try_nat_offset_dispatch","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":30},{"cells":0,"fft_cost":0.0,"height":0,"index":410,"lookup_group_size":1,"lookups":7,"name":"IxVM::mk_nat_binop_stuck","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":12,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":411,"lookup_group_size":1,"lookups":33,"name":"IxVM::try_str_dispatch","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":59,"stage2_width":66},{"cells":0,"fft_cost":0.0,"height":0,"index":412,"lookup_group_size":1,"lookups":16,"name":"IxVM::walk_char_list_bytes","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":32,"stage2_width":32},{"cells":0,"fft_cost":0.0,"height":0,"index":413,"lookup_group_size":2,"lookups":4,"name":"IxVM::char_lit_codepoint","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":414,"lookup_group_size":2,"lookups":7,"name":"IxVM::char_lit_codepoint_syn","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":26,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":415,"lookup_group_size":1,"lookups":6,"name":"IxVM::klimbs_scalar_value","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":39,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":416,"lookup_group_size":1,"lookups":25,"name":"IxVM::utf8_encode_prepend","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":33,"stage2_width":50},{"cells":0,"fft_cost":0.0,"height":0,"index":417,"lookup_group_size":1,"lookups":4,"name":"IxVM::utf8_groups","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":9,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":418,"lookup_group_size":2,"lookups":3,"name":"IxVM::divmod_64u","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":419,"lookup_group_size":1,"lookups":12,"name":"IxVM::try_str_back","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":21,"stage2_width":24},{"cells":0,"fft_cost":0.0,"height":0,"index":420,"lookup_group_size":1,"lookups":2,"name":"IxVM::utf8_last_codepoint","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":4,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":421,"lookup_group_size":1,"lookups":4,"name":"IxVM::utf8_last_go","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":422,"lookup_group_size":1,"lookups":9,"name":"IxVM::try_str_to_byte_array","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":21,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":423,"lookup_group_size":1,"lookups":2,"name":"IxVM::byte_array_empty_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":424,"lookup_group_size":1,"lookups":10,"name":"IxVM::try_str_dec_eq","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":28,"stage2_width":20},{"cells":0,"fft_cost":0.0,"height":0,"index":425,"lookup_group_size":1,"lookups":4,"name":"IxVM::bytestream_eq","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":426,"lookup_group_size":1,"lookups":30,"name":"IxVM::str_dec_eq_build","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":38,"stage2_width":60},{"cells":0,"fft_cost":0.0,"height":0,"index":427,"lookup_group_size":1,"lookups":2,"name":"IxVM::eq_refl_addr_dec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":428,"lookup_group_size":1,"lookups":2,"name":"IxVM::decidable_is_true_addr_dec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":429,"lookup_group_size":1,"lookups":18,"name":"IxVM::try_bitvec_dispatch","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":36},{"cells":0,"fft_cost":0.0,"height":0,"index":430,"lookup_group_size":1,"lookups":10,"name":"IxVM::bitvec_prep_spine","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":20,"stage2_width":20},{"cells":0,"fft_cost":0.0,"height":0,"index":431,"lookup_group_size":1,"lookups":9,"name":"IxVM::bv_to_nat_via","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":432,"lookup_group_size":1,"lookups":10,"name":"IxVM::bitvec_of_nat_args_direct","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":20},{"cells":0,"fft_cost":0.0,"height":0,"index":433,"lookup_group_size":1,"lookups":2,"name":"IxVM::bit_vec_of_nat_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":434,"lookup_group_size":1,"lookups":10,"name":"IxVM::bitvec_prep_spine_ult","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":22,"stage2_width":20},{"cells":0,"fft_cost":0.0,"height":0,"index":435,"lookup_group_size":1,"lookups":4,"name":"IxVM::np_whnf_inner_bv","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":8,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":436,"lookup_group_size":1,"lookups":11,"name":"IxVM::try_reduce_bit_vec_ult","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":22},{"cells":0,"fft_cost":0.0,"height":0,"index":437,"lookup_group_size":1,"lookups":26,"name":"IxVM::try_reduce_decide_bitvec_lt","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":48,"stage2_width":52},{"cells":0,"fft_cost":0.0,"height":0,"index":438,"lookup_group_size":1,"lookups":2,"name":"IxVM::lt_lt_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":439,"lookup_group_size":1,"lookups":2,"name":"IxVM::bit_vec_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":440,"lookup_group_size":2,"lookups":21,"name":"IxVM::try_native_dispatch","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":33,"stage2_width":22},{"cells":0,"fft_cost":0.0,"height":0,"index":441,"lookup_group_size":1,"lookups":4,"name":"IxVM::mk_nat_literal_64","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":5,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":442,"lookup_group_size":1,"lookups":4,"name":"IxVM::mk_nat_one","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":5,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":443,"lookup_group_size":1,"lookups":10,"name":"IxVM::try_reduce_subtype_val","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":20},{"cells":0,"fft_cost":0.0,"height":0,"index":444,"lookup_group_size":1,"lookups":2,"name":"IxVM::system_platform_get_num_bits_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":445,"lookup_group_size":1,"lookups":7,"name":"IxVM::check_native_bool","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":14,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":446,"lookup_group_size":1,"lookups":3,"name":"IxVM::check_native_nat","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":447,"lookup_group_size":2,"lookups":14,"name":"IxVM::try_dec_dispatch","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":448,"lookup_group_size":2,"lookups":7,"name":"IxVM::is_int_dec_prim_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":449,"lookup_group_size":1,"lookups":9,"name":"IxVM::try_normalize_int_decidable","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":450,"lookup_group_size":1,"lookups":9,"name":"IxVM::try_extract_int","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":451,"lookup_group_size":1,"lookups":2,"name":"IxVM::int_of_nat_addr_dec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":452,"lookup_group_size":1,"lookups":2,"name":"IxVM::int_neg_succ_addr_dec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":453,"lookup_group_size":1,"lookups":12,"name":"IxVM::normalize_int_dec_rebuild","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":25,"stage2_width":24},{"cells":0,"fft_cost":0.0,"height":0,"index":454,"lookup_group_size":2,"lookups":7,"name":"IxVM::intern_int_lit","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":455,"lookup_group_size":1,"lookups":13,"name":"IxVM::dec_rewrite_lt_to_le","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":26},{"cells":0,"fft_cost":0.0,"height":0,"index":456,"lookup_group_size":2,"lookups":11,"name":"IxVM::dec_dispatch_le_eq","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":457,"lookup_group_size":1,"lookups":26,"name":"IxVM::dec_build_proof","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":43,"stage2_width":52},{"cells":0,"fft_cost":0.0,"height":0,"index":458,"lookup_group_size":1,"lookups":2,"name":"IxVM::bool_type_addr_dec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":459,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_le_of_ble_eq_true_addr_dec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":460,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_not_le_of_not_ble_eq_true_addr_dec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":461,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_eq_of_beq_eq_true_addr_dec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":462,"lookup_group_size":1,"lookups":2,"name":"IxVM::nat_ne_of_beq_eq_false_addr_dec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":463,"lookup_group_size":1,"lookups":18,"name":"IxVM::dec_finish","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":29,"stage2_width":36},{"cells":0,"fft_cost":0.0,"height":0,"index":464,"lookup_group_size":1,"lookups":2,"name":"IxVM::decidable_is_false_addr_dec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":465,"lookup_group_size":1,"lookups":22,"name":"IxVM::try_int_prim_dispatch","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":33,"stage2_width":44},{"cells":0,"fft_cost":0.0,"height":0,"index":466,"lookup_group_size":1,"lookups":12,"name":"IxVM::try_extract_int_prim","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":25,"stage2_width":24},{"cells":0,"fft_cost":0.0,"height":0,"index":467,"lookup_group_size":2,"lookups":11,"name":"IxVM::mk_int_prim","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":468,"lookup_group_size":1,"lookups":45,"name":"IxVM::try_int_prim_second","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":43,"stage2_width":90},{"cells":0,"fft_cost":0.0,"height":0,"index":469,"lookup_group_size":1,"lookups":13,"name":"IxVM::int_bmod_prim","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":22,"stage2_width":26},{"cells":0,"fft_cost":0.0,"height":0,"index":470,"lookup_group_size":1,"lookups":19,"name":"IxVM::int_bdiv_prim","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":32,"stage2_width":38},{"cells":0,"fft_cost":0.0,"height":0,"index":471,"lookup_group_size":2,"lookups":8,"name":"IxVM::int_add_prim","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":472,"lookup_group_size":2,"lookups":7,"name":"IxVM::int_emod_prim","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":14,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":473,"lookup_group_size":2,"lookups":10,"name":"IxVM::int_ediv_prim","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":474,"lookup_group_size":1,"lookups":13,"name":"IxVM::whnf_nd_proj_head","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":37,"stage2_width":26},{"cells":224,"fft_cost":4800.0,"height":16,"index":475,"lookup_group_size":2,"lookups":6,"name":"IxVM::k_is_def_eq_slow_nd","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":14,"stage2_width":6},{"cells":352,"fft_cost":6336.0,"height":16,"index":476,"lookup_group_size":2,"lookups":6,"name":"IxVM::whnf_struct_core","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":22,"stage2_width":6},{"cells":200,"fft_cost":4776.0,"height":8,"index":477,"lookup_group_size":1,"lookups":18,"name":"IxVM::whnf_struct_core_spine","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":25,"stage2_width":36},{"cells":0,"fft_cost":0.0,"height":0,"index":478,"lookup_group_size":1,"lookups":9,"name":"IxVM::whnf_struct_core_proj","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":32,"stage2_width":18},{"cells":27,"fft_cost":135.0,"height":1,"index":479,"lookup_group_size":1,"lookups":7,"name":"IxVM::whnf_struct_core_const","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":14},{"cells":432,"fft_cost":8832.0,"height":16,"index":480,"lookup_group_size":1,"lookups":7,"name":"IxVM::k_is_def_eq_struct_safe","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":14},{"cells":16,"fft_cost":78.0,"height":1,"index":481,"lookup_group_size":2,"lookups":6,"name":"IxVM::k_is_def_eq_slow_nd_after_core","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":6},{"cells":29,"fft_cost":123.0,"height":1,"index":482,"lookup_group_size":2,"lookups":8,"name":"IxVM::k_is_def_eq_slow2","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":29,"stage2_width":8},{"cells":11,"fft_cost":63.0,"height":1,"index":483,"lookup_group_size":2,"lookups":5,"name":"IxVM::try_proof_irrel","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":6},{"cells":12,"fft_cost":66.0,"height":1,"index":484,"lookup_group_size":2,"lookups":6,"name":"IxVM::try_unit_like","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":6},{"cells":42,"fft_cost":162.0,"height":1,"index":485,"lookup_group_size":2,"lookups":7,"name":"IxVM::is_unit_like_type","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":42,"stage2_width":8},{"cells":122,"fft_cost":498.0,"height":2,"index":486,"lookup_group_size":2,"lookups":14,"name":"IxVM::try_eta_struct","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":61,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":487,"lookup_group_size":2,"lookups":5,"name":"IxVM::compare_struct_fields","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":6},{"cells":46,"fft_cost":270.0,"height":2,"index":488,"lookup_group_size":1,"lookups":7,"name":"IxVM::try_def_eq_nat","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":14},{"cells":26,"fft_cost":162.0,"height":2,"index":489,"lookup_group_size":2,"lookups":5,"name":"IxVM::is_nat_zero","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":6},{"cells":72,"fft_cost":444.0,"height":2,"index":490,"lookup_group_size":1,"lookups":15,"name":"IxVM::nat_offset_of","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":36,"stage2_width":30},{"cells":48,"fft_cost":240.0,"height":2,"index":491,"lookup_group_size":2,"lookups":8,"name":"IxVM::lazy_delta_loop","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":24,"stage2_width":8},{"cells":24,"fft_cost":168.0,"height":2,"index":492,"lookup_group_size":1,"lookups":4,"name":"IxVM::head_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":493,"lookup_group_size":2,"lookups":16,"name":"IxVM::lazy_delta_step_const_const","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":52,"stage2_width":16},{"cells":18,"fft_cost":72.0,"height":1,"index":494,"lookup_group_size":1,"lookups":1,"name":"IxVM::is_defn_or_thm","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":2},{"cells":0,"fft_cost":0.0,"height":0,"index":495,"lookup_group_size":2,"lookups":4,"name":"IxVM::unfold_b_and_loop","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":4},{"cells":27,"fft_cost":135.0,"height":1,"index":496,"lookup_group_size":1,"lookups":7,"name":"IxVM::delta_unfold","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":497,"lookup_group_size":2,"lookups":4,"name":"IxVM::unfold_a_and_loop","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":498,"lookup_group_size":1,"lookups":1,"name":"IxVM::delta_rank","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":2},{"cells":0,"fft_cost":0.0,"height":0,"index":499,"lookup_group_size":2,"lookups":6,"name":"IxVM::unfold_both_and_loop","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":500,"lookup_group_size":2,"lookups":8,"name":"IxVM::lazy_delta_a_const_b_proj","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":34,"stage2_width":8},{"cells":24,"fft_cost":138.0,"height":1,"index":501,"lookup_group_size":1,"lookups":9,"name":"IxVM::try_unfold_proj_app","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":24,"stage2_width":18},{"cells":23,"fft_cost":99.0,"height":1,"index":502,"lookup_group_size":1,"lookups":3,"name":"IxVM::try_unfold_head","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":6},{"cells":34,"fft_cost":138.0,"height":1,"index":503,"lookup_group_size":2,"lookups":8,"name":"IxVM::lazy_delta_b_const_a_proj","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":34,"stage2_width":8},{"cells":18,"fft_cost":90.0,"height":1,"index":504,"lookup_group_size":1,"lookups":4,"name":"IxVM::lazy_delta_both_proj","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":8},{"cells":15,"fft_cost":69.0,"height":1,"index":505,"lookup_group_size":2,"lookups":4,"name":"IxVM::slow2_after_delta","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":4},{"cells":43,"fft_cost":213.0,"height":1,"index":506,"lookup_group_size":1,"lookups":12,"name":"IxVM::k_is_def_eq_struct_bounded","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":43,"stage2_width":24},{"cells":0,"fft_cost":0.0,"height":0,"index":507,"lookup_group_size":2,"lookups":6,"name":"IxVM::k_is_def_eq_struct_spend","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":21,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":508,"lookup_group_size":2,"lookups":3,"name":"IxVM::literal_eq","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":509,"lookup_group_size":2,"lookups":4,"name":"IxVM::k_is_def_eq_structure_tree","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":510,"lookup_group_size":2,"lookups":11,"name":"IxVM::try_same_proj_head_app","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":32,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":511,"lookup_group_size":2,"lookups":5,"name":"IxVM::k_is_def_eq_structure_tree_app","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":512,"lookup_group_size":2,"lookups":10,"name":"IxVM::slow2_eager_fallback","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":513,"lookup_group_size":1,"lookups":4,"name":"IxVM::try_eta_swap","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":514,"lookup_group_size":2,"lookups":10,"name":"IxVM::try_eta_expand","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":21,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":515,"lookup_group_size":1,"lookups":2,"name":"IxVM::k_is_def_eq_struct","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":6,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":516,"lookup_group_size":1,"lookups":17,"name":"IxVM::k_is_def_eq_struct_go","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":43,"stage2_width":34},{"cells":0,"fft_cost":0.0,"height":0,"index":517,"lookup_group_size":1,"lookups":10,"name":"IxVM::try_lazy_delta_app","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":48,"stage2_width":20},{"cells":288,"fft_cost":7104.0,"height":16,"index":518,"lookup_group_size":2,"lookups":13,"name":"IxVM::k_def_eq_rebase","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":14},{"cells":576,"fft_cost":20352.0,"height":64,"index":519,"lookup_group_size":2,"lookups":4,"name":"IxVM::expr_glb","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":4},{"cells":1408,"fft_cost":51456.0,"height":64,"index":520,"lookup_group_size":1,"lookups":9,"name":"IxVM::expr_glb_walk","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":22,"stage2_width":18},{"cells":80,"fft_cost":1392.0,"height":8,"index":521,"lookup_group_size":2,"lookups":4,"name":"IxVM::expr_glb_binder","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":522,"lookup_group_size":2,"lookups":6,"name":"IxVM::expr_glb_let","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":523,"lookup_group_size":1,"lookups":7,"name":"IxVM::k_infer_let_start","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":524,"lookup_group_size":1,"lookups":10,"name":"IxVM::k_infer_let_env","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":20},{"cells":0,"fft_cost":0.0,"height":0,"index":525,"lookup_group_size":1,"lookups":3,"name":"IxVM::infer_let_local_cutoff","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":526,"lookup_group_size":1,"lookups":26,"name":"IxVM::k_infer_let_env_core","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":52},{"cells":0,"fft_cost":0.0,"height":0,"index":527,"lookup_group_size":1,"lookups":4,"name":"IxVM::infer_let_lookup_type","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":528,"lookup_group_size":1,"lookups":12,"name":"IxVM::infer_let_materialize","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":28,"stage2_width":24},{"cells":0,"fft_cost":0.0,"height":0,"index":529,"lookup_group_size":1,"lookups":5,"name":"IxVM::infer_let_lookup_value","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":530,"lookup_group_size":1,"lookups":7,"name":"IxVM::k_infer_let_env_rebase","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":14,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":531,"lookup_group_size":1,"lookups":3,"name":"IxVM::infer_let_drop_unused","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":532,"lookup_group_size":1,"lookups":5,"name":"IxVM::k_infer_lit","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":533,"lookup_group_size":1,"lookups":14,"name":"IxVM::k_infer_proj","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":41,"stage2_width":28},{"cells":0,"fft_cost":0.0,"height":0,"index":534,"lookup_group_size":1,"lookups":6,"name":"IxVM::is_inductive_prop","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":13,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":535,"lookup_group_size":2,"lookups":6,"name":"IxVM::peel_n_alls_whnf","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":536,"lookup_group_size":2,"lookups":7,"name":"IxVM::peel_field_loop","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":537,"lookup_group_size":2,"lookups":4,"name":"IxVM::check_prop_field_if_prop","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":538,"lookup_group_size":2,"lookups":5,"name":"IxVM::check_no_dep_data_field_if_prop","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":14,"stage2_width":6},{"cells":240,"fft_cost":6144.0,"height":16,"index":539,"lookup_group_size":2,"lookups":11,"name":"IxVM::k_infer_rebase","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":12},{"cells":14,"fft_cost":102.0,"height":2,"index":540,"lookup_group_size":2,"lookups":2,"name":"IxVM::assert_safety","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":7,"stage2_width":2},{"cells":1920,"fft_cost":60672.0,"height":64,"index":541,"lookup_group_size":1,"lookups":9,"name":"IxVM::safe_refs_only","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":30,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":542,"lookup_group_size":1,"lookups":11,"name":"IxVM::check_quot","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":13,"stage2_width":22},{"cells":0,"fft_cost":0.0,"height":0,"index":543,"lookup_group_size":1,"lookups":2,"name":"IxVM::quot_type_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":544,"lookup_group_size":1,"lookups":4,"name":"IxVM::check_eq_type","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":12,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":545,"lookup_group_size":1,"lookups":2,"name":"IxVM::eq_type_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":546,"lookup_group_size":2,"lookups":3,"name":"IxVM::count_foralls_at_least","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":14,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":547,"lookup_group_size":2,"lookups":15,"name":"IxVM::check_canonical_block","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":67,"stage2_width":16},{"cells":0,"fft_cost":0.0,"height":0,"index":548,"lookup_group_size":2,"lookups":3,"name":"IxVM::canon_muts_has_kind","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":58,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":549,"lookup_group_size":1,"lookups":4,"name":"IxVM::canon_indc_positions","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":56,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":550,"lookup_group_size":2,"lookups":6,"name":"IxVM::canon_sort_loop","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":551,"lookup_group_size":1,"lookups":6,"name":"IxVM::canon_build_ctx_classes","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":15,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":552,"lookup_group_size":1,"lookups":9,"name":"IxVM::canon_build_ctx_members","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":21,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":553,"lookup_group_size":1,"lookups":2,"name":"IxVM::canon_member_num_ctors","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":554,"lookup_group_size":1,"lookups":4,"name":"IxVM::canon_member_ci","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":18,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":555,"lookup_group_size":1,"lookups":4,"name":"IxVM::canon_ctor_ctx_entries","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":556,"lookup_group_size":1,"lookups":4,"name":"${\"name\":\"IxVM::list_concat\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\"]}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":557,"lookup_group_size":1,"lookups":6,"name":"IxVM::canon_refine_classes","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":12,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":558,"lookup_group_size":1,"lookups":6,"name":"IxVM::canon_refine_one","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":559,"lookup_group_size":1,"lookups":5,"name":"IxVM::canon_ins_sort","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":560,"lookup_group_size":1,"lookups":8,"name":"IxVM::canon_insert_sorted","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":40,"stage2_width":16},{"cells":0,"fft_cost":0.0,"height":0,"index":561,"lookup_group_size":2,"lookups":6,"name":"IxVM::canon_cmp_member_ctx","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":34,"stage2_width":6},{"cells":2048,"fft_cost":89088.0,"height":256,"index":562,"lookup_group_size":2,"lookups":2,"name":"IxVM::canon_ord_cmp_g","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":2},{"cells":0,"fft_cost":0.0,"height":0,"index":563,"lookup_group_size":1,"lookups":1,"name":"IxVM::canon_kind_ord","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":21,"stage2_width":2},{"cells":0,"fft_cost":0.0,"height":0,"index":564,"lookup_group_size":1,"lookups":37,"name":"IxVM::canon_cmp_member_same_kind_ctx","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":70,"stage2_width":74},{"cells":0,"fft_cost":0.0,"height":0,"index":565,"lookup_group_size":1,"lookups":1,"name":"IxVM::canon_sord_then","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":2},{"cells":0,"fft_cost":0.0,"height":0,"index":566,"lookup_group_size":1,"lookups":1,"name":"IxVM::canon_sord_of_g","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":3,"stage2_width":2},{"cells":0,"fft_cost":0.0,"height":0,"index":567,"lookup_group_size":1,"lookups":4,"name":"IxVM::canon_cmp_kexpr_ctx","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":15,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":568,"lookup_group_size":1,"lookups":25,"name":"IxVM::canon_cmp_kexpr_node_ctx","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":61,"stage2_width":50},{"cells":0,"fft_cost":0.0,"height":0,"index":569,"lookup_group_size":1,"lookups":1,"name":"IxVM::canon_sord_lt_strong","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":2,"stage2_width":2},{"cells":0,"fft_cost":0.0,"height":0,"index":570,"lookup_group_size":1,"lookups":1,"name":"IxVM::canon_sord_gt_strong","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":2,"stage2_width":2},{"cells":0,"fft_cost":0.0,"height":0,"index":571,"lookup_group_size":1,"lookups":8,"name":"IxVM::canon_cmp_kuniv","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":29,"stage2_width":16},{"cells":48,"fft_cost":960.0,"height":8,"index":572,"lookup_group_size":1,"lookups":1,"name":"IxVM::canon_ord_then","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":6,"stage2_width":2},{"cells":0,"fft_cost":0.0,"height":0,"index":573,"lookup_group_size":1,"lookups":6,"name":"IxVM::canon_cmp_kuniv_list","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":574,"lookup_group_size":2,"lookups":10,"name":"IxVM::canon_ctx_cmp_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":575,"lookup_group_size":1,"lookups":1,"name":"IxVM::canon_sord_eq_strong","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":2,"stage2_width":2},{"cells":0,"fft_cost":0.0,"height":0,"index":576,"lookup_group_size":2,"lookups":4,"name":"IxVM::canon_ctx_class_idx","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":4},{"cells":2656,"fft_cost":58208.0,"height":32,"index":577,"lookup_group_size":1,"lookups":18,"name":"IxVM::canon_addr_cmp","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":83,"stage2_width":36},{"cells":2816,"fft_cost":105472.0,"height":256,"index":578,"lookup_group_size":1,"lookups":2,"name":"IxVM::canon_addr_chunk","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":579,"lookup_group_size":1,"lookups":3,"name":"IxVM::canon_cmp_kliteral","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":580,"lookup_group_size":2,"lookups":7,"name":"IxVM::canon_cmp_klimbs","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":581,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"IxVM::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":582,"lookup_group_size":1,"lookups":6,"name":"IxVM::canon_cmp_klimbs_tail","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":28,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":583,"lookup_group_size":1,"lookups":16,"name":"IxVM::canon_cmp_u64_lex","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":33,"stage2_width":32},{"cells":0,"fft_cost":0.0,"height":0,"index":584,"lookup_group_size":1,"lookups":6,"name":"IxVM::canon_cmp_bytes","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":585,"lookup_group_size":2,"lookups":9,"name":"IxVM::canon_cmp_ctor_range_ctx","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":43,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":586,"lookup_group_size":1,"lookups":18,"name":"IxVM::canon_cmp_ctor_pair_ctx","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":51,"stage2_width":36},{"cells":0,"fft_cost":0.0,"height":0,"index":587,"lookup_group_size":2,"lookups":9,"name":"IxVM::canon_cmp_krec_rule_list_ctx","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":24,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":588,"lookup_group_size":1,"lookups":5,"name":"IxVM::canon_cmp_krec_rule_ctx","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":16,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":589,"lookup_group_size":1,"lookups":6,"name":"IxVM::canon_group_consec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":12,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":590,"lookup_group_size":1,"lookups":12,"name":"IxVM::canon_group_walk","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":43,"stage2_width":24},{"cells":0,"fft_cost":0.0,"height":0,"index":591,"lookup_group_size":2,"lookups":5,"name":"IxVM::canon_classes_eq","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":592,"lookup_group_size":2,"lookups":4,"name":"IxVM::canon_all_singleton","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":593,"lookup_group_size":1,"lookups":5,"name":"IxVM::canon_flatten","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":9,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":594,"lookup_group_size":1,"lookups":4,"name":"IxVM::check_inductive_shape","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":12,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":595,"lookup_group_size":1,"lookups":5,"name":"IxVM::get_result_sort_level","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":14,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":596,"lookup_group_size":2,"lookups":10,"name":"IxVM::check_inductive_shape_ctors","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":30,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":597,"lookup_group_size":1,"lookups":3,"name":"IxVM::check_param_agreement","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":6,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":598,"lookup_group_size":2,"lookups":6,"name":"IxVM::check_param_agreement_go","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":599,"lookup_group_size":1,"lookups":12,"name":"IxVM::check_ctor_return_type","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":20,"stage2_width":24},{"cells":0,"fft_cost":0.0,"height":0,"index":600,"lookup_group_size":1,"lookups":4,"name":"IxVM::assert_return_head_is_parent","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":17,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":601,"lookup_group_size":2,"lookups":5,"name":"IxVM::assert_lvls_are_params","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":602,"lookup_group_size":2,"lookups":4,"name":"IxVM::assert_first_args_are_param_bvars","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":603,"lookup_group_size":2,"lookups":4,"name":"IxVM::list_any_mentions_block","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":604,"lookup_group_size":1,"lookups":7,"name":"IxVM::expr_mentions_block","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":26,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":605,"lookup_group_size":2,"lookups":4,"name":"IxVM::caddr_is_peer","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":606,"lookup_group_size":2,"lookups":4,"name":"IxVM::addr_list_contains","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":607,"lookup_group_size":2,"lookups":4,"name":"IxVM::check_field_universes","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":608,"lookup_group_size":2,"lookups":5,"name":"IxVM::check_field_universes_skip_params","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":609,"lookup_group_size":2,"lookups":6,"name":"IxVM::check_field_universes_inner","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":610,"lookup_group_size":2,"lookups":6,"name":"IxVM::level_leq","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":14,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":611,"lookup_group_size":2,"lookups":6,"name":"IxVM::nl_le","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":612,"lookup_group_size":2,"lookups":8,"name":"IxVM::nl_covers_const","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":613,"lookup_group_size":1,"lookups":5,"name":"IxVM::nlvars_any_offset_geq","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":13,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":614,"lookup_group_size":1,"lookups":5,"name":"IxVM::nl_le_vars","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":14,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":615,"lookup_group_size":2,"lookups":7,"name":"IxVM::nl_covers_var","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":616,"lookup_group_size":1,"lookups":5,"name":"IxVM::nlvars_dominates","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":617,"lookup_group_size":1,"lookups":5,"name":"IxVM::check_positivity","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":618,"lookup_group_size":2,"lookups":4,"name":"IxVM::peel_n_foralls_with_types","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":619,"lookup_group_size":2,"lookups":5,"name":"IxVM::check_positivity_fields","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":620,"lookup_group_size":2,"lookups":20,"name":"IxVM::check_positivity_aug","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":44,"stage2_width":20},{"cells":0,"fft_cost":0.0,"height":0,"index":621,"lookup_group_size":1,"lookups":8,"name":"IxVM::check_valid_ind_app","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":21,"stage2_width":16},{"cells":0,"fft_cost":0.0,"height":0,"index":622,"lookup_group_size":2,"lookups":4,"name":"IxVM::assert_occ_param_bvars","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":623,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"IxVM::list_reverse\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":5,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":624,"lookup_group_size":1,"lookups":4,"name":"${\"name\":\"IxVM::list_reverse_acc\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":625,"lookup_group_size":2,"lookups":9,"name":"IxVM::check_nested_ctors_positivity","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":29,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":626,"lookup_group_size":2,"lookups":4,"name":"IxVM::check_block_peer_param_agreement","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":69,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":627,"lookup_group_size":1,"lookups":12,"name":"IxVM::peer_agree_walk","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":82,"stage2_width":24},{"cells":0,"fft_cost":0.0,"height":0,"index":628,"lookup_group_size":2,"lookups":14,"name":"IxVM::check_recursor_member","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":37,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":629,"lookup_group_size":2,"lookups":2,"name":"IxVM::is_muts_block","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":53,"stage2_width":2},{"cells":0,"fft_cost":0.0,"height":0,"index":630,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"IxVM::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::KRecRule\"}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":631,"lookup_group_size":1,"lookups":4,"name":"IxVM::check_rec_rules_wellscoped","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":632,"lookup_group_size":1,"lookups":5,"name":"IxVM::check_rec_major_spine","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":15,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":633,"lookup_group_size":2,"lookups":8,"name":"IxVM::compute_k_target","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":42,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":634,"lookup_group_size":2,"lookups":4,"name":"IxVM::ind_is_solo","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":58,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":635,"lookup_group_size":1,"lookups":3,"name":"IxVM::muts_indc_count_is_one","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":56,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":636,"lookup_group_size":2,"lookups":2,"name":"IxVM::check_parent_inductive_shape","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":2},{"cells":0,"fft_cost":0.0,"height":0,"index":637,"lookup_group_size":1,"lookups":23,"name":"IxVM::check_recursor_canonical_full","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":83,"stage2_width":46},{"cells":0,"fft_cost":0.0,"height":0,"index":638,"lookup_group_size":2,"lookups":4,"name":"IxVM::is_large_eliminator","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":32,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":639,"lookup_group_size":2,"lookups":6,"name":"IxVM::check_large_prop_ctor","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":640,"lookup_group_size":2,"lookups":10,"name":"IxVM::check_large_walk_fields","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":22,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":641,"lookup_group_size":2,"lookups":4,"name":"IxVM::all_bvars_in_args","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":642,"lookup_group_size":1,"lookups":4,"name":"IxVM::args_contain_bvar","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":643,"lookup_group_size":1,"lookups":4,"name":"IxVM::build_rec_lvls_list","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":644,"lookup_group_size":1,"lookups":13,"name":"IxVM::build_flat_block","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":128,"stage2_width":26},{"cells":0,"fft_cost":0.0,"height":0,"index":645,"lookup_group_size":2,"lookups":9,"name":"IxVM::first_recr_parent_block","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":88,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":646,"lookup_group_size":1,"lookups":10,"name":"IxVM::flat_originals_walk","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":77,"stage2_width":20},{"cells":0,"fft_cost":0.0,"height":0,"index":647,"lookup_group_size":1,"lookups":4,"name":"IxVM::build_param_lvls_range","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":648,"lookup_group_size":2,"lookups":3,"name":"IxVM::detect_aux_from_recrs_ex","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":57,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":649,"lookup_group_size":1,"lookups":16,"name":"IxVM::aux_from_recrs_walk_ex","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":105,"stage2_width":32},{"cells":0,"fft_cost":0.0,"height":0,"index":650,"lookup_group_size":2,"lookups":3,"name":"IxVM::extract_aux_spec_params_from_rec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":651,"lookup_group_size":1,"lookups":6,"name":"IxVM::extract_aux_spec_params","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":16,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":652,"lookup_group_size":1,"lookups":6,"name":"IxVM::spec_params_lower","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":653,"lookup_group_size":1,"lookups":6,"name":"IxVM::extract_aux_occ_us","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":30,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":654,"lookup_group_size":1,"lookups":5,"name":"IxVM::aux_already_in","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":655,"lookup_group_size":2,"lookups":5,"name":"IxVM::spec_params_ptr_eq","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":656,"lookup_group_size":1,"lookups":11,"name":"IxVM::kexpr_struct_eq","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":42,"stage2_width":22},{"cells":0,"fft_cost":0.0,"height":0,"index":657,"lookup_group_size":2,"lookups":5,"name":"IxVM::level_list_struct_eq","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":658,"lookup_group_size":1,"lookups":5,"name":"${\"name\":\"IxVM::list_snoc\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":659,"lookup_group_size":2,"lookups":5,"name":"IxVM::build_peer_recs","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":660,"lookup_group_size":2,"lookups":3,"name":"IxVM::find_peer_recursor_with_spec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":58,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":661,"lookup_group_size":1,"lookups":12,"name":"IxVM::find_peer_rec_spec_walk","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":100,"stage2_width":24},{"cells":0,"fft_cost":0.0,"height":0,"index":662,"lookup_group_size":1,"lookups":6,"name":"IxVM::build_flat_own_params","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":28,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":663,"lookup_group_size":2,"lookups":5,"name":"IxVM::flat_find_pos_kind","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":664,"lookup_group_size":1,"lookups":11,"name":"IxVM::canonical_rules_at_pos","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":32,"stage2_width":22},{"cells":0,"fft_cost":0.0,"height":0,"index":665,"lookup_group_size":2,"lookups":6,"name":"IxVM::flat_member_at","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":666,"lookup_group_size":1,"lookups":5,"name":"IxVM::build_rec_type","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":31,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":667,"lookup_group_size":2,"lookups":28,"name":"IxVM::build_rec_type_from","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":55,"stage2_width":28},{"cells":0,"fft_cost":0.0,"height":0,"index":668,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"IxVM::list_length\",\"types\":[{\"tuple\":{\"items\":[{\"ptr\":{\"target\":{\"array\":{\"element\":\"field\",\"length\":32}}}},\"field\",{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KExprNode\"}}}}],\"name\":\"Lists::Node\"}}}},{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}],\"name\":\"Lists::Node\"}}}}]}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":669,"lookup_group_size":1,"lookups":8,"name":"IxVM::collect_n_doms_whnf","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":22,"stage2_width":16},{"cells":0,"fft_cost":0.0,"height":0,"index":670,"lookup_group_size":1,"lookups":2,"name":"IxVM::build_all_motives","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":6,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":671,"lookup_group_size":1,"lookups":9,"name":"IxVM::build_all_motives_walk","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":31,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":672,"lookup_group_size":2,"lookups":11,"name":"IxVM::build_motive_type_flat","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":22,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":673,"lookup_group_size":2,"lookups":5,"name":"IxVM::peel_motive_params_subst","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":674,"lookup_group_size":2,"lookups":5,"name":"IxVM::subst_param_for","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":675,"lookup_group_size":1,"lookups":8,"name":"IxVM::collect_index_doms","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":21,"stage2_width":16},{"cells":0,"fft_cost":0.0,"height":0,"index":676,"lookup_group_size":2,"lookups":4,"name":"IxVM::build_major_params","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":677,"lookup_group_size":1,"lookups":5,"name":"IxVM::apply_spec_params_lifted","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":12,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":678,"lookup_group_size":2,"lookups":4,"name":"IxVM::build_major_indices","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":679,"lookup_group_size":1,"lookups":4,"name":"IxVM::wrap_foralls","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":680,"lookup_group_size":1,"lookups":2,"name":"IxVM::build_all_minors","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":8,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":681,"lookup_group_size":2,"lookups":10,"name":"IxVM::build_all_minors_walk","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":35,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":682,"lookup_group_size":1,"lookups":7,"name":"IxVM::build_minor_doms","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":36,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":683,"lookup_group_size":1,"lookups":9,"name":"IxVM::projection_addr_ctor","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":27,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":684,"lookup_group_size":1,"lookups":21,"name":"IxVM::build_minor_at_depth","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":39,"stage2_width":42},{"cells":0,"fft_cost":0.0,"height":0,"index":685,"lookup_group_size":2,"lookups":11,"name":"IxVM::peel_ctor_params_subst","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":26,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":686,"lookup_group_size":1,"lookups":6,"name":"IxVM::ctor_subst_param_for","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":14,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":687,"lookup_group_size":1,"lookups":10,"name":"IxVM::walk_fields_classify","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":24,"stage2_width":20},{"cells":0,"fft_cost":0.0,"height":0,"index":688,"lookup_group_size":1,"lookups":2,"name":"IxVM::is_rec_field","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":689,"lookup_group_size":2,"lookups":8,"name":"IxVM::is_rec_field_peel","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":690,"lookup_group_size":2,"lookups":5,"name":"IxVM::flat_find_matching","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":691,"lookup_group_size":2,"lookups":6,"name":"IxVM::spec_params_dom_prefix_match","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":692,"lookup_group_size":2,"lookups":5,"name":"IxVM::list_lift_each","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":693,"lookup_group_size":2,"lookups":3,"name":"IxVM::build_ctor_app_params","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":694,"lookup_group_size":2,"lookups":4,"name":"IxVM::build_apply_bvars_decreasing","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":695,"lookup_group_size":2,"lookups":4,"name":"IxVM::build_apply_field_bvars","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":696,"lookup_group_size":1,"lookups":20,"name":"IxVM::build_ih_doms","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":34,"stage2_width":40},{"cells":0,"fft_cost":0.0,"height":0,"index":697,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"IxVM::list_lookup_or_default\",\"types\":[\"field\"]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":698,"lookup_group_size":1,"lookups":4,"name":"IxVM::peel_leading_foralls","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":699,"lookup_group_size":2,"lookups":4,"name":"IxVM::peel_leading_foralls_acc","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":700,"lookup_group_size":2,"lookups":5,"name":"IxVM::list_lift_indices","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":701,"lookup_group_size":2,"lookups":4,"name":"IxVM::apply_indices_in_conclusion","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":702,"lookup_group_size":1,"lookups":5,"name":"IxVM::ctors_before_pos","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":31,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":703,"lookup_group_size":1,"lookups":6,"name":"IxVM::populate_rules","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":36,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":704,"lookup_group_size":1,"lookups":12,"name":"IxVM::build_rule_rhs","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":29,"stage2_width":24},{"cells":0,"fft_cost":0.0,"height":0,"index":705,"lookup_group_size":2,"lookups":3,"name":"IxVM::count_foralls_body","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":706,"lookup_group_size":1,"lookups":26,"name":"IxVM::apply_ihs_full","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":44,"stage2_width":52},{"cells":0,"fft_cost":0.0,"height":0,"index":707,"lookup_group_size":1,"lookups":4,"name":"IxVM::wrap_lams","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":708,"lookup_group_size":1,"lookups":11,"name":"IxVM::compare_rules","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":41,"stage2_width":22},{"cells":0,"fft_cost":0.0,"height":0,"index":709,"lookup_group_size":2,"lookups":4,"name":"IxVM::peel_n_lams_collect","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":710,"lookup_group_size":2,"lookups":4,"name":"IxVM::flat_find_pos","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":711,"lookup_group_size":1,"lookups":7,"name":"IxVM::run_check_transitive","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":62,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":712,"lookup_group_size":1,"lookups":4,"name":"IxVM::check_muts_all","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":54,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":713,"lookup_group_size":1,"lookups":5,"name":"IxVM::check_muts_member_at","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":64,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":714,"lookup_group_size":2,"lookups":5,"name":"IxVM::walk_refs_transitive","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":6},{"cells":352,"fft_cost":9504.0,"height":32,"index":715,"lookup_group_size":2,"lookups":3,"name":"IxVM::g_list_has","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4},{"cells":62,"fft_cost":264.0,"height":1,"index":716,"lookup_group_size":1,"lookups":11,"name":"IxVM::const_idxs_of","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":62,"stage2_width":22},{"cells":80,"fft_cost":1760.0,"height":8,"index":717,"lookup_group_size":1,"lookups":6,"name":"IxVM::const_idxs_exprs","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":12},{"cells":2176,"fft_cost":72192.0,"height":64,"index":718,"lookup_group_size":1,"lookups":12,"name":"IxVM::const_idxs_expr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":34,"stage2_width":24},{"cells":0,"fft_cost":0.0,"height":0,"index":719,"lookup_group_size":1,"lookups":6,"name":"IxVM::const_idxs_rules","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":18,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":720,"lookup_group_size":1,"lookups":16,"name":"IxVM::const_idxs_muts","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":58,"stage2_width":32},{"cells":0,"fft_cost":0.0,"height":0,"index":721,"lookup_group_size":1,"lookups":6,"name":"IxVM::const_idxs_ctors","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":43,"stage2_width":12},{"cells":400,"fft_cost":6784.0,"height":16,"index":722,"lookup_group_size":1,"lookups":4,"name":"IxVM::addr_set_build","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":25,"stage2_width":8},{"cells":128,"fft_cost":1616.0,"height":8,"index":723,"lookup_group_size":1,"lookups":2,"name":"${\"name\":\"IxVM::rbtree_map_insert\",\"types\":[\"field\"]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":16,"stage2_width":4},{"cells":1440,"fft_cost":34464.0,"height":32,"index":724,"lookup_group_size":1,"lookups":11,"name":"${\"name\":\"IxVM::rbtree_map_ins\",\"types\":[\"field\"]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":45,"stage2_width":22},{"cells":432,"fft_cost":6912.0,"height":16,"index":725,"lookup_group_size":2,"lookups":4,"name":"${\"name\":\"IxVM::rbtree_map_balance\",\"types\":[\"field\"]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":4},{"cells":4816,"fft_cost":61824.0,"height":16,"index":726,"lookup_group_size":1,"lookups":8,"name":"${\"name\":\"IxVM::rbtree_map_balance_fix\",\"types\":[\"field\"]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":301,"stage2_width":16},{"cells":90,"fft_cost":374.0,"height":2,"index":727,"lookup_group_size":1,"lookups":7,"name":"IxVM::load_assumption_tree","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":45,"stage2_width":14},{"cells":240,"fft_cost":8064.0,"height":16,"index":728,"lookup_group_size":1,"lookups":11,"name":"IxVM::parse_atree_body","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":22},{"cells":56,"fft_cost":1400.0,"height":8,"index":729,"lookup_group_size":1,"lookups":5,"name":"IxVM::leaf_hash","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":10},{"cells":72,"fft_cost":1688.0,"height":8,"index":730,"lookup_group_size":1,"lookups":6,"name":"IxVM::node_hash","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":9,"stage2_width":12},{"cells":160,"fft_cost":3136.0,"height":16,"index":731,"lookup_group_size":1,"lookups":2,"name":"IxVM::addr_set_member","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":4},{"cells":1088,"fft_cost":22464.0,"height":32,"index":732,"lookup_group_size":2,"lookups":7,"name":"${\"name\":\"IxVM::rbtree_map_lookup_or_default\",\"types\":[\"field\"]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":34,"stage2_width":8},{"cells":640,"fft_cost":7440.0,"height":8,"index":733,"lookup_group_size":1,"lookups":9,"name":"IxVM::env_walk","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":80,"stage2_width":18},{"cells":200,"fft_cost":2616.0,"height":8,"index":734,"lookup_group_size":2,"lookups":5,"name":"IxVM::env_walk_refs","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":25,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":735,"lookup_group_size":1,"lookups":4,"name":"IxVM::eval_body","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":736,"lookup_group_size":1,"lookups":7,"name":"IxVM::eval_output","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":58,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":737,"lookup_group_size":1,"lookups":8,"name":"IxVM::eval_nf","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":16},{"cells":0,"fft_cost":0.0,"height":0,"index":738,"lookup_group_size":1,"lookups":6,"name":"IxVM::eval_nf_spine","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":12},{"cells":20,"fft_cost":114.0,"height":1,"index":739,"lookup_group_size":1,"lookups":7,"name":"IxVM::run_check_env","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":740,"lookup_group_size":1,"lookups":5,"name":"IxVM::walk_leaves_owned","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":39,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":741,"lookup_group_size":1,"lookups":3,"name":"IxVM::check_owned","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":35,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":742,"lookup_group_size":1,"lookups":8,"name":"IxVM::env_walk_all","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":89,"stage2_width":16},{"cells":0,"fft_cost":0.0,"height":0,"index":743,"lookup_group_size":2,"lookups":6,"name":"IxVM::env_walk_refs_all","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":43,"stage2_width":6},{"cells":38,"fft_cost":182.0,"height":2,"index":744,"lookup_group_size":1,"lookups":4,"name":"IxVM::env_walk_leaves","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":19,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":745,"lookup_group_size":1,"lookups":31,"name":"IxVM::get_reveal_info","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":101,"stage2_width":62},{"cells":0,"fft_cost":0.0,"height":0,"index":746,"lookup_group_size":1,"lookups":2,"name":"IxVM::get_opt_def_kind_masked","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":747,"lookup_group_size":1,"lookups":2,"name":"IxVM::get_opt_u64_masked","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":748,"lookup_group_size":1,"lookups":2,"name":"IxVM::get_opt_addr_masked","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":749,"lookup_group_size":1,"lookups":2,"name":"IxVM::get_opt_bool_masked","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":750,"lookup_group_size":1,"lookups":3,"name":"IxVM::get_opt_rule_list_masked","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":751,"lookup_group_size":1,"lookups":6,"name":"IxVM::get_reveal_rule_list_inner","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":43,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":752,"lookup_group_size":1,"lookups":2,"name":"IxVM::get_opt_quot_kind_masked","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":753,"lookup_group_size":1,"lookups":6,"name":"IxVM::get_mut_entry_list_inner","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":88,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":754,"lookup_group_size":1,"lookups":3,"name":"IxVM::get_mut_entry","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":67,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":755,"lookup_group_size":1,"lookups":24,"name":"IxVM::get_reveal_mut_const_info","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":94,"stage2_width":48},{"cells":0,"fft_cost":0.0,"height":0,"index":756,"lookup_group_size":1,"lookups":3,"name":"IxVM::get_opt_ctor_entry_list_masked","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":757,"lookup_group_size":1,"lookups":6,"name":"IxVM::get_ctor_entry_list_inner","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":74,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":758,"lookup_group_size":1,"lookups":3,"name":"IxVM::get_ctor_entry","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":53,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":759,"lookup_group_size":1,"lookups":9,"name":"IxVM::get_reveal_ctor_info","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":66,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":760,"lookup_group_size":1,"lookups":21,"name":"IxVM::run_reveal","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":113,"stage2_width":42},{"cells":0,"fft_cost":0.0,"height":0,"index":761,"lookup_group_size":1,"lookups":3,"name":"IxVM::check_opt_def_kind","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":8,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":762,"lookup_group_size":1,"lookups":1,"name":"IxVM::def_kind_tag","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":5,"stage2_width":2},{"cells":0,"fft_cost":0.0,"height":0,"index":763,"lookup_group_size":1,"lookups":2,"name":"IxVM::check_opt_u64","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":21,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":764,"lookup_group_size":1,"lookups":3,"name":"IxVM::check_opt_expr_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":8,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":765,"lookup_group_size":1,"lookups":5,"name":"IxVM::expr_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":24,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":766,"lookup_group_size":1,"lookups":1,"name":"IxVM::check_opt_bool","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":6,"stage2_width":2},{"cells":0,"fft_cost":0.0,"height":0,"index":767,"lookup_group_size":1,"lookups":2,"name":"IxVM::check_opt_recr_rules","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":6,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":768,"lookup_group_size":1,"lookups":8,"name":"IxVM::check_recr_rules","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":53,"stage2_width":16},{"cells":0,"fft_cost":0.0,"height":0,"index":769,"lookup_group_size":1,"lookups":3,"name":"IxVM::check_opt_quot_kind","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":8,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":770,"lookup_group_size":1,"lookups":2,"name":"IxVM::check_opt_addr","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":771,"lookup_group_size":1,"lookups":5,"name":"IxVM::check_muts_components","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":114,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":772,"lookup_group_size":1,"lookups":20,"name":"IxVM::check_mut_const","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":103,"stage2_width":40},{"cells":0,"fft_cost":0.0,"height":0,"index":773,"lookup_group_size":1,"lookups":2,"name":"IxVM::check_opt_ctor_entries","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":6,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":774,"lookup_group_size":1,"lookups":4,"name":"IxVM::check_ctor_entries","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":55,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":775,"lookup_group_size":1,"lookups":8,"name":"IxVM::check_ctor_entry","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":85,"stage2_width":16},{"cells":0,"fft_cost":0.0,"height":0,"index":776,"lookup_group_size":1,"lookups":5,"name":"${\"name\":\"IxVM::list_lookup_u64\",\"types\":[{\"named\":{\"args\":[],\"name\":\"IxVM::Constructor\"}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":90,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":777,"lookup_group_size":1,"lookups":3,"name":"IxVM::run_contains","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":6,"stage2_width":6},{"cells":512,"fft_cost":50176.0,"height":256,"index":778,"lookup_group_size":1,"lookups":2,"name":"","preprocessed_height":256,"preprocessed_width":11,"quotient_degree":1,"stage1_width":2,"stage2_width":4},{"cells":458752,"fft_cost":60555264.0,"height":65536,"index":779,"lookup_group_size":2,"lookups":7,"name":"","preprocessed_height":65536,"preprocessed_width":14,"quotient_degree":2,"stage1_width":7,"stage2_width":8},{"cells":1024,"fft_cost":157696.0,"height":1024,"index":780,"lookup_group_size":1,"lookups":1,"name":"","preprocessed_height":1024,"preprocessed_width":3,"quotient_degree":1,"stage1_width":1,"stage2_width":2},{"cells":0,"fft_cost":0.0,"height":0,"index":781,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":5,"stage2_width":6},{"cells":49152,"fft_cost":4505600.0,"height":8192,"index":782,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":6,"stage2_width":6},{"cells":3584,"fft_cost":209408.0,"height":512,"index":783,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":784,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":8,"stage2_width":6},{"cells":288,"fft_cost":8288.0,"height":32,"index":785,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":9,"stage2_width":6},{"cells":11,"fft_cost":57.0,"height":1,"index":786,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":6},{"cells":192,"fft_cost":3904.0,"height":16,"index":787,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":12,"stage2_width":6},{"cells":208,"fft_cost":4096.0,"height":16,"index":788,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":13,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":789,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":14,"stage2_width":6},{"cells":240,"fft_cost":4480.0,"height":16,"index":790,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":15,"stage2_width":6},{"cells":10752,"fft_cost":402944.0,"height":512,"index":791,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":21,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":792,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":22,"stage2_width":6},{"cells":4480,"fft_cost":116096.0,"height":128,"index":793,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":35,"stage2_width":6},{"cells":1184,"fft_cost":21728.0,"height":32,"index":794,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":37,"stage2_width":6},{"cells":156,"fft_cost":1144.0,"height":4,"index":795,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":39,"stage2_width":6},{"cells":200,"fft_cost":1408.0,"height":4,"index":796,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":50,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":797,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":53,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":798,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":67,"stage2_width":6}]} diff --git a/docs/benchmarks/formal-aiur-grouping-tuning/manifest.json b/docs/benchmarks/formal-aiur-grouping-tuning/manifest.json new file mode 100644 index 000000000..d89ca9711 --- /dev/null +++ b/docs/benchmarks/formal-aiur-grouping-tuning/manifest.json @@ -0,0 +1,50 @@ +{ + "date": "2026-10-27", + "base_revision": "ade9330c4a03728354bce67e968fc3ed60ccb01a", + "branch": "migration/formal-aiur", + "machine": "Intel Xeon 6975P-C, Linux x86-64", + "rustflags": "-Ctarget-cpu=native", + "rayon_threads": 8, + "transparent_hugepages_disabled": true, + "execution": "bytecode only, unchanged by grouping", + "warmups": 2, + "small_samples": 5, + "large_recursive_samples": 3, + "prove_samples": 1, + "prove_includes": "trace regeneration and proof verification; excludes execution and key setup", + "cost_model": "Exact multi-stark circuit shape and ix_bench FFT formula, checked per function circuit on all four workloads; FFT is an estimate, not elapsed time", + "policy_objective": "equal weighting of two workloads: normalized FFT + 0.2 cells, plus 0.05 columns + 0.01 circuit count; no workload cells or FFT above the starting layout budget; at most 16 members", + "legacy_column_reference": "../formal-aiur-grouping/summary.csv", + "artifact_sha256": { + "ixvm-baseline": "114311f43f6fb39a2d5ccc5c4e6fb279d4eb6c08655cd08731c949e7e537fabf", + "recursion-baseline": "ae96efa2ce33a07bd79fc5100395aa09a7f3d5f436ae04ee7be2f6bcd71e2afa", + "recursion-selected": "40e88dd1f84e4f119626189e83f8eb181f6ef9875c190f33cdd7853e83c5afe1", + "aggregate-baseline": "8f5f2d4e356656cec16ab9c22e11de4e9d4bee6d42d6497ba733d31c86039fae", + "aggregate-selected": "50638b554026d4db272e725cf07f70d27b280ca9e62b0323a197fa572f21cb60", + "ixvm-selected": "1f8c10da7b10587e985d5166b26ad0c7edd4f4cbdfe0978c7deb237cf6683d9a" + }, + "input_sha256": { + "ixvm": "2733974cdf8d687799f678140ab967d3ab2c5a9f8768c8c3455bc86b5281a7b8", + "environment": "14a147c1d6141721547092a9a835249969aa1f82c8f57f9ed0a2b0522f7aaa56", + "recursion": "def7a0c827ef2d00d315d8770ec05faeb4e0e3f53acdb1f1e6c9551706418d1c", + "recursion-real": "2ecf2051d112503637b9d3c1a6201bd66f91df4568a95faff3cef068e3f96a1a" + }, + "source_sha256": { + "Aiur/Aiur/Optimized/Grouping/Compile.lean": "77259c43003e8ca02c04d7f12de30a56478b0d34715b058d269fa49c122ffbaa", + "Aiur/Aiur/Optimized/Grouping/Certificate.lean": "995a790d174cd1b95b43e44653242739e38ac90be8263b856d7d712c12d6e8de", + "IxVM/IxVM/FunctionGroups.lean": "8e8d7448d2de18b03cff600b239115bfcf895cead68f0274497fd613a8d321c0", + "MultiStark/MultiStark/FunctionGroups.lean": "e0ce18a545bc6f8066c04bac82160cc49133f5bf042267deb3e4b626c3e042fc", + "tools/ixvm/tune-groups.py": "0d09ea6983bc06f6003ca0cfc8bbee8d623f5f28117ac58b2d0d0ae179fce85b" + }, + "validation": [ + "Lean full Aiur proof graph and application builds", + "grouping fixture freshness, rejection checks and masked-quadratic regression", + "axiom audit: propext, Classical.choice, Quot.sound only", + "Rust grouped proof/trace regression", + "tools/ixvm/check-formal.sh: claims, recursion, thirteen aggregation shapes and malformed-input rejection", + "All eight benchmark proof runs verified", + "Clippy for the comparison example with warnings denied", + "Saved metrics/counts/shapes reproduce both committed membership policies exactly", + "Normal IxVM, verifier and aggregation exports equal the artifacts used for integration and the groups used for benchmarks" + ] +} diff --git a/docs/benchmarks/formal-aiur-grouping-tuning/recursion-counts.json b/docs/benchmarks/formal-aiur-grouping-tuning/recursion-counts.json new file mode 100644 index 000000000..5d7980ceb --- /dev/null +++ b/docs/benchmarks/formal-aiur-grouping-tuning/recursion-counts.json @@ -0,0 +1,1131 @@ +{ + "backend": "new-bytecode", + "circuits": [], + "function_rows": [ + { + "chip": "MultiStark::verify_multi_stark_proof", + "name": "MultiStark::verify_multi_stark_proof", + "rows": 1 + }, + { + "chip": "MultiStark::read_byte_stream", + "name": "MultiStark::read_byte_stream", + "rows": 131 + }, + { + "chip": "Blake3::compress_layer", + "name": "Blake3::compress_layer", + "rows": 13 + }, + { + "chip": "Blake3::next_layer", + "name": "Blake3::next_layer", + "rows": 0 + }, + { + "chip": "Blake3::compress", + "name": "Blake3::compress", + "rows": 176 + }, + { + "chip": "Blake3::compress_chunks", + "name": "Blake3::compress_chunks", + "rows": 946 + }, + { + "chip": "Blake3::finish", + "name": "Blake3::finish", + "rows": 11 + }, + { + "chip": "UInt64::is_zero", + "name": "UInt64::is_zero", + "rows": 1 + }, + { + "chip": "Blake3::bytes_to_block", + "name": "Blake3::bytes_to_block", + "rows": 18 + }, + { + "chip": "Blake3::pad_block", + "name": "Blake3::pad_block", + "rows": 226 + }, + { + "chip": "Blake3::compress_block", + "name": "Blake3::compress_block", + "rows": 9 + }, + { + "chip": "${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}", + "name": "${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}", + "rows": 8 + }, + { + "chip": "UInt64::wrapping_succ", + "name": "UInt64::wrapping_succ", + "rows": 0 + }, + { + "chip": "MultiStark::read_vk_u16_limb", + "name": "MultiStark::read_vk_u16_limb", + "rows": 11 + }, + { + "chip": "MultiStark::read_vk_u8", + "name": "MultiStark::read_vk_u8", + "rows": 81 + }, + { + "chip": "MultiStark::read_sys_circuits_n", + "name": "MultiStark::read_sys_circuits_n", + "rows": 2 + }, + { + "chip": "MultiStark::read_vk_u32_limb", + "name": "MultiStark::read_vk_u32_limb", + "rows": 1 + }, + { + "chip": "MultiStark::read_vk_tag", + "name": "MultiStark::read_vk_tag", + "rows": 8 + }, + { + "chip": "MultiStark::read_vk_u16", + "name": "MultiStark::read_vk_u16", + "rows": 19 + }, + { + "chip": "MultiStark::read_nodes_n", + "name": "MultiStark::read_nodes_n", + "rows": 8 + }, + { + "chip": "MultiStark::read_field", + "name": "MultiStark::read_field", + "rows": 1 + }, + { + "chip": "MultiStark::read_vk_u64", + "name": "MultiStark::read_vk_u64", + "rows": 1 + }, + { + "chip": "UInt32::less_than_fields", + "name": "UInt32::less_than_fields", + "rows": 8 + }, + { + "chip": "MultiStark::read_node_ids_n", + "name": "MultiStark::read_node_ids_n", + "rows": 7 + }, + { + "chip": "MultiStark::read_sys_lookups_n", + "name": "MultiStark::read_sys_lookups_n", + "rows": 2 + }, + { + "chip": "MultiStark::lookup_groups_count", + "name": "MultiStark::lookup_groups_count", + "rows": 2 + }, + { + "chip": "MultiStark::read_opt_commit", + "name": "MultiStark::read_opt_commit", + "rows": 1 + }, + { + "chip": "MultiStark::read_vk_cap_n", + "name": "MultiStark::read_vk_cap_n", + "rows": 0 + }, + { + "chip": "MultiStark::read_opt_idx_n", + "name": "MultiStark::read_opt_idx_n", + "rows": 2 + }, + { + "chip": "${\"name\":\"MultiStark::list_concat\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "name": "${\"name\":\"MultiStark::list_concat\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "rows": 8 + }, + { + "chip": "MultiStark::read_count", + "name": "MultiStark::read_count", + "rows": 2 + }, + { + "chip": "MultiStark::read_u64", + "name": "MultiStark::read_u64", + "rows": 6 + }, + { + "chip": "MultiStark::read_u8", + "name": "MultiStark::read_u8", + "rows": 48 + }, + { + "chip": "UInt64::to_field", + "name": "UInt64::to_field", + "rows": 6 + }, + { + "chip": "MultiStark::read_claims_n", + "name": "MultiStark::read_claims_n", + "rows": 2 + }, + { + "chip": "MultiStark::read_claim_vals_n", + "name": "MultiStark::read_claim_vals_n", + "rows": 5 + }, + { + "chip": "MultiStark::read_count_at", + "name": "MultiStark::read_count_at", + "rows": 132 + }, + { + "chip": "MultiStark::read_u64_at", + "name": "MultiStark::read_u64_at", + "rows": 273 + }, + { + "chip": "MultiStark::read_header_vec_n", + "name": "MultiStark::read_header_vec_n", + "rows": 2 + }, + { + "chip": "MultiStark::read_active_n", + "name": "MultiStark::read_active_n", + "rows": 4 + }, + { + "chip": "MultiStark::read_u8_at", + "name": "MultiStark::read_u8_at", + "rows": 5 + }, + { + "chip": "MultiStark::read_digest_vec_at", + "name": "MultiStark::read_digest_vec_at", + "rows": 7 + }, + { + "chip": "MultiStark::read_digest_vec_at_n", + "name": "MultiStark::read_digest_vec_at_n", + "rows": 11 + }, + { + "chip": "MultiStark::read_active_n", + "name": "MultiStark::read_u8_vec_n", + "rows": 4 + }, + { + "chip": "MultiStark::read_u64_vec_vec_n", + "name": "MultiStark::read_u64_vec_vec_n", + "rows": 98 + }, + { + "chip": "MultiStark::read_u64_vec", + "name": "MultiStark::read_u64_vec", + "rows": 50 + }, + { + "chip": "MultiStark::read_u64_vec_n", + "name": "MultiStark::read_u64_vec_n", + "rows": 150 + }, + { + "chip": "MultiStark::read_message_vec_n", + "name": "MultiStark::read_message_vec_n", + "rows": 1 + }, + { + "chip": "MultiStark::read_proof_vec_n", + "name": "MultiStark::read_proof_vec_n", + "rows": 2 + }, + { + "chip": "MultiStark::read_proof", + "name": "MultiStark::read_proof", + "rows": 1 + }, + { + "chip": "MultiStark::read_ext_vec", + "name": "MultiStark::read_ext_vec", + "rows": 7 + }, + { + "chip": "MultiStark::read_ext_vec_n", + "name": "MultiStark::read_ext_vec_n", + "rows": 19 + }, + { + "chip": "MultiStark::read_merkle_cap_vec_n", + "name": "MultiStark::read_merkle_cap_vec_n", + "rows": 1 + }, + { + "chip": "MultiStark::read_batch_opening_vec_n", + "name": "MultiStark::read_batch_opening_vec_n", + "rows": 4 + }, + { + "chip": "MultiStark::read_u64_vec_vec_vec_n", + "name": "MultiStark::read_u64_vec_vec_vec_n", + "rows": 51 + }, + { + "chip": "MultiStark::read_commit_phase_step_vec_n", + "name": "MultiStark::read_commit_phase_step_vec_n", + "rows": 1 + }, + { + "chip": "MultiStark::read_ext_vec_vec", + "name": "MultiStark::read_ext_vec_vec", + "rows": 3 + }, + { + "chip": "MultiStark::read_ext_vec_vec_n", + "name": "MultiStark::read_ext_vec_vec_n", + "rows": 8 + }, + { + "chip": "MultiStark::read_opened_round", + "name": "MultiStark::read_opened_round", + "rows": 3 + }, + { + "chip": "MultiStark::read_opened_round_n", + "name": "MultiStark::read_opened_round_n", + "rows": 6 + }, + { + "chip": "MultiStark::read_preprocessed", + "name": "MultiStark::read_preprocessed", + "rows": 1 + }, + { + "chip": "MultiStark::verify_batch", + "name": "MultiStark::verify_batch", + "rows": 1 + }, + { + "chip": "MultiStark::assert_shard_count_ok", + "name": "MultiStark::assert_shard_count_ok", + "rows": 1 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::ShardHeader\"}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::ShardHeader\"}}]}", + "rows": 2 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Proof\"}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Proof\"}}]}", + "rows": 2 + }, + { + "chip": "MultiStark::assert_closure_pairs", + "name": "MultiStark::assert_closure_pairs", + "rows": 1 + }, + { + "chip": "MultiStark::three_limbs", + "name": "MultiStark::three_limbs", + "rows": 0 + }, + { + "chip": "MultiStark::bytes8_le", + "name": "MultiStark::bytes8_le", + "rows": 0 + }, + { + "chip": "MultiStark::le_step", + "name": "MultiStark::le_step", + "rows": 0 + }, + { + "chip": "MultiStark::batch_fiat_shamir", + "name": "MultiStark::batch_fiat_shamir", + "rows": 1 + }, + { + "chip": "MultiStark::messages_onto", + "name": "MultiStark::messages_onto", + "rows": 1 + }, + { + "chip": "MultiStark::count_onto", + "name": "MultiStark::count_onto", + "rows": 5 + }, + { + "chip": "MultiStark::b8_onto", + "name": "MultiStark::b8_onto", + "rows": 57 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMessage\"}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMessage\"}}]}", + "rows": 1 + }, + { + "chip": "MultiStark::messages_onto_each", + "name": "MultiStark::messages_onto_each", + "rows": 1 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "rows": 7 + }, + { + "chip": "MultiStark::limbs_onto", + "name": "MultiStark::limbs_onto", + "rows": 21 + }, + { + "chip": "MultiStark::headers_onto", + "name": "MultiStark::headers_onto", + "rows": 2 + }, + { + "chip": "MultiStark::header_onto", + "name": "MultiStark::header_onto", + "rows": 1 + }, + { + "chip": "MultiStark::active_onto", + "name": "MultiStark::active_onto", + "rows": 2 + }, + { + "chip": "MultiStark::cap_onto", + "name": "MultiStark::cap_onto", + "rows": 5 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "rows": 3 + }, + { + "chip": "MultiStark::log_degrees_onto", + "name": "MultiStark::log_degrees_onto", + "rows": 2 + }, + { + "chip": "MultiStark::claims_onto", + "name": "MultiStark::claims_onto", + "rows": 1 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 4 + }, + { + "chip": "MultiStark::claims_onto_each", + "name": "MultiStark::claims_onto_each", + "rows": 2 + }, + { + "chip": "MultiStark::ch_sample_ext", + "name": "MultiStark::ch_sample_ext", + "rows": 5 + }, + { + "chip": "MultiStark::ch_sample_field", + "name": "MultiStark::ch_sample_field", + "rows": 10 + }, + { + "chip": "MultiStark::ch_sample8", + "name": "MultiStark::ch_sample8", + "rows": 26 + }, + { + "chip": "MultiStark::b3_w4_onto", + "name": "MultiStark::b3_w4_onto", + "rows": 72 + }, + { + "chip": "MultiStark::rev_onto", + "name": "MultiStark::rev_onto", + "rows": 297 + }, + { + "chip": "${\"name\":\"MultiStark::list_concat\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_concat\",\"types\":[\"field\"]}", + "rows": 358 + }, + { + "chip": "MultiStark::messages_acc", + "name": "MultiStark::messages_acc", + "rows": 1 + }, + { + "chip": "MultiStark::fingerprint_vals", + "name": "MultiStark::fingerprint_vals", + "rows": 5 + }, + { + "chip": "MultiStark::verify_shards", + "name": "MultiStark::verify_shards", + "rows": 2 + }, + { + "chip": "MultiStark::verify_shard", + "name": "MultiStark::verify_shard", + "rows": 1 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "rows": 5 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":2}}],\"name\":\"Lists::Node\"}}}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 4 + }, + { + "chip": "MultiStark::assert_bits", + "name": "MultiStark::assert_bits", + "rows": 2 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMessage\"}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysCircuit\"}}]}", + "rows": 2 + }, + { + "chip": "MultiStark::select_active_circuits", + "name": "MultiStark::select_active_circuits", + "rows": 2 + }, + { + "chip": "MultiStark::select_active_prep", + "name": "MultiStark::select_active_prep", + "rows": 2 + }, + { + "chip": "MultiStark::assert_same_bits", + "name": "MultiStark::assert_same_bits", + "rows": 2 + }, + { + "chip": "MultiStark::assert_same_cap", + "name": "MultiStark::assert_same_cap", + "rows": 2 + }, + { + "chip": "UInt64::eq", + "name": "UInt64::eq", + "rows": 20 + }, + { + "chip": "MultiStark::assert_same_bits", + "name": "MultiStark::assert_same_u8s", + "rows": 2 + }, + { + "chip": "MultiStark::assert_log_degrees_ok", + "name": "MultiStark::assert_log_degrees_ok", + "rows": 2 + }, + { + "chip": "MultiStark::log_degree_ok", + "name": "MultiStark::log_degree_ok", + "rows": 1 + }, + { + "chip": "MultiStark::count_ones", + "name": "MultiStark::count_ones", + "rows": 2 + }, + { + "chip": "MultiStark::shard_fiat_shamir", + "name": "MultiStark::shard_fiat_shamir", + "rows": 1 + }, + { + "chip": "MultiStark::snoc_b8", + "name": "MultiStark::snoc_b8", + "rows": 1 + }, + { + "chip": "MultiStark::snoc_cap", + "name": "MultiStark::snoc_cap", + "rows": 2 + }, + { + "chip": "MultiStark::accs_onto", + "name": "MultiStark::accs_onto", + "rows": 2 + }, + { + "chip": "MultiStark::claims_acc", + "name": "MultiStark::claims_acc", + "rows": 2 + }, + { + "chip": "MultiStark::ood_loop", + "name": "MultiStark::ood_loop", + "rows": 2 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}", + "rows": 1 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}", + "rows": 2 + }, + { + "chip": "MultiStark::quotient_degree_of", + "name": "MultiStark::quotient_degree_of", + "rows": 1 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "rows": 5 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "rows": 5 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":2}}],\"name\":\"Lists::Node\"}}}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 3 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":2}}],\"name\":\"Lists::Node\"}}}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 3 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":2}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 5 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":2}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 5 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::OptIdx\"}}]}", + "rows": 1 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::OptIdx\"}}]}", + "rows": 1 + }, + { + "chip": "MultiStark::ext_exp_pow2", + "name": "MultiStark::ext_exp_pow2", + "rows": 1 + }, + { + "chip": "MultiStark::two_adic_gen", + "name": "MultiStark::two_adic_gen", + "rows": 33 + }, + { + "chip": "MultiStark::pow2", + "name": "MultiStark::pow2", + "rows": 1 + }, + { + "chip": "MultiStark::fold_roots", + "name": "MultiStark::fold_roots", + "rows": 2 + }, + { + "chip": "MultiStark::eval_at", + "name": "MultiStark::eval_at", + "rows": 7 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}", + "rows": 7 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}", + "rows": 7 + }, + { + "chip": "MultiStark::ood_fold", + "name": "MultiStark::ood_fold", + "rows": 1 + }, + { + "chip": "MultiStark::logup_steps_fold", + "name": "MultiStark::logup_steps_fold", + "rows": 1 + }, + { + "chip": "MultiStark::logup_fingerprint", + "name": "MultiStark::logup_fingerprint", + "rows": 5 + }, + { + "chip": "MultiStark::pair_mul", + "name": "MultiStark::pair_mul", + "rows": 7 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysLookup\"}}]}", + "rows": 2 + }, + { + "chip": "MultiStark::reconstruct_ext_row", + "name": "MultiStark::reconstruct_ext_row", + "rows": 2 + }, + { + "chip": "MultiStark::from_ext_basis", + "name": "MultiStark::from_ext_basis", + "rows": 1 + }, + { + "chip": "MultiStark::quotient_eval", + "name": "MultiStark::quotient_eval", + "rows": 2 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"array\":{\"element\":{\"array\":{\"element\":\"field\",\"length\":8}},\"length\":4}}}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 1 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMultiOpening\"}}]}", + "rows": 4 + }, + { + "chip": "MultiStark::prep_count", + "name": "MultiStark::prep_count", + "rows": 1 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::CommitPhaseMultiStep\"}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::CommitPhaseMultiStep\"}}]}", + "rows": 1 + }, + { + "chip": "MultiStark::round_onto", + "name": "MultiStark::round_onto", + "rows": 6 + }, + { + "chip": "MultiStark::points_onto", + "name": "MultiStark::points_onto", + "rows": 8 + }, + { + "chip": "MultiStark::accs_onto", + "name": "MultiStark::ext_row_onto", + "rows": 15 + }, + { + "chip": "MultiStark::pcs_betas", + "name": "MultiStark::pcs_betas", + "rows": 1 + }, + { + "chip": "MultiStark::pcs_check_witness", + "name": "MultiStark::pcs_check_witness", + "rows": 1 + }, + { + "chip": "MultiStark::ch_sample_bits", + "name": "MultiStark::ch_sample_bits", + "rows": 16 + }, + { + "chip": "MultiStark::b8_onto", + "name": "MultiStark::cons8", + "rows": 62 + }, + { + "chip": "MultiStark::take_bits", + "name": "MultiStark::take_bits", + "rows": 32 + }, + { + "chip": "MultiStark::bits_to_num", + "name": "MultiStark::bits_to_num", + "rows": 3 + }, + { + "chip": "MultiStark::obs_log_arities", + "name": "MultiStark::obs_log_arities", + "rows": 1 + }, + { + "chip": "MultiStark::sample_query_indices", + "name": "MultiStark::sample_query_indices", + "rows": 17 + }, + { + "chip": "MultiStark::verify_input_multi", + "name": "MultiStark::verify_input_multi", + "rows": 1 + }, + { + "chip": "MultiStark::heights_all", + "name": "MultiStark::heights_all", + "rows": 2 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMultiOpening\"}}]}", + "rows": 3 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMultiOpening\"}}]}", + "rows": 3 + }, + { + "chip": "MultiStark::mmcs_verify_multi", + "name": "MultiStark::mmcs_verify_multi", + "rows": 2 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 33 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[\"field\"],\"name\":\"Lists::Node\"}}}}]}", + "rows": 17 + }, + { + "chip": "MultiStark::frontier_sort", + "name": "MultiStark::frontier_sort", + "rows": 24 + }, + { + "chip": "MultiStark::frontier_split", + "name": "MultiStark::frontier_split", + "rows": 41 + }, + { + "chip": "MultiStark::frontier_merge", + "name": "MultiStark::frontier_merge", + "rows": 19 + }, + { + "chip": "MultiStark::digest_eq", + "name": "MultiStark::digest_eq", + "rows": 4 + }, + { + "chip": "MultiStark::assert_same_claims", + "name": "MultiStark::assert_same_claims", + "rows": 4 + }, + { + "chip": "MultiStark::assert_same_limbs", + "name": "MultiStark::assert_same_limbs", + "rows": 7 + }, + { + "chip": "MultiStark::frontier_leaves", + "name": "MultiStark::frontier_leaves", + "rows": 33 + }, + { + "chip": "MultiStark::leaf_hash_at", + "name": "MultiStark::leaf_hash_at", + "rows": 2 + }, + { + "chip": "MultiStark::b3_rows_chunks", + "name": "MultiStark::b3_rows_chunks", + "rows": 2 + }, + { + "chip": "MultiStark::rows_pop", + "name": "MultiStark::rows_pop", + "rows": 7 + }, + { + "chip": "MultiStark::select_rows", + "name": "MultiStark::select_rows", + "rows": 3 + }, + { + "chip": "MultiStark::frontier_fold", + "name": "MultiStark::frontier_fold", + "rows": 4 + }, + { + "chip": "MultiStark::frontier_level", + "name": "MultiStark::frontier_level", + "rows": 3 + }, + { + "chip": "MultiStark::select_rows_le", + "name": "MultiStark::select_rows_le", + "rows": 3 + }, + { + "chip": "MultiStark::inject_maybe", + "name": "MultiStark::inject_maybe", + "rows": 2 + }, + { + "chip": "MultiStark::has_height", + "name": "MultiStark::has_height", + "rows": 2 + }, + { + "chip": "MultiStark::mmcs_compress", + "name": "MultiStark::mmcs_compress", + "rows": 2 + }, + { + "chip": "MultiStark::compress_ordered", + "name": "MultiStark::compress_ordered", + "rows": 0 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":{\"array\":{\"element\":\"field\",\"length\":8}},\"length\":4}}}}]}", + "rows": 1 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::ShardHeader\"}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::FrontierNode\"}}]}", + "rows": 1 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":{\"array\":{\"element\":\"field\",\"length\":8}},\"length\":4}}}}]}", + "rows": 2 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":{\"array\":{\"element\":\"field\",\"length\":8}},\"length\":4}}}}]}", + "rows": 2 + }, + { + "chip": "MultiStark::heights_prep", + "name": "MultiStark::heights_prep", + "rows": 0 + }, + { + "chip": "MultiStark::heights_max", + "name": "MultiStark::heights_max", + "rows": 0 + }, + { + "chip": "MultiStark::drop_index_bits", + "name": "MultiStark::drop_index_bits", + "rows": 0 + }, + { + "chip": "MultiStark::query_views", + "name": "MultiStark::query_views", + "rows": 17 + }, + { + "chip": "MultiStark::batch_views_at", + "name": "MultiStark::batch_views_at", + "rows": 64 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 32 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 32 + }, + { + "chip": "MultiStark::step_views_at", + "name": "MultiStark::step_views_at", + "rows": 16 + }, + { + "chip": "MultiStark::query_loop", + "name": "MultiStark::query_loop", + "rows": 17 + }, + { + "chip": "MultiStark::verify_one_query", + "name": "MultiStark::verify_one_query", + "rows": 2 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::CommitPhaseProofStep\"}}]}", + "rows": 1 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchOpening\"}}]}", + "rows": 4 + }, + { + "chip": "MultiStark::build_buckets", + "name": "MultiStark::build_buckets", + "rows": 2 + }, + { + "chip": "MultiStark::circ_has_height", + "name": "MultiStark::circ_has_height", + "rows": 1 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchOpening\"}}]}", + "rows": 3 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchOpening\"}}]}", + "rows": 3 + }, + { + "chip": "MultiStark::open_batch_2pt", + "name": "MultiStark::open_batch_2pt", + "rows": 8 + }, + { + "chip": "MultiStark::open_2pt_mat", + "name": "MultiStark::open_2pt_mat", + "rows": 4 + }, + { + "chip": "MultiStark::ri_apply", + "name": "MultiStark::ri_apply", + "rows": 10 + }, + { + "chip": "MultiStark::exp_by_bits", + "name": "MultiStark::exp_by_bits", + "rows": 3 + }, + { + "chip": "MultiStark::rev_onto", + "name": "MultiStark::glist_rev", + "rows": 4 + }, + { + "chip": "MultiStark::bucket_update", + "name": "MultiStark::bucket_update", + "rows": 10 + }, + { + "chip": "MultiStark::ro_fold", + "name": "MultiStark::ro_fold", + "rows": 15 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 2 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 2 + }, + { + "chip": "MultiStark::open_quotient", + "name": "MultiStark::open_quotient", + "rows": 4 + }, + { + "chip": "MultiStark::open_prep_batch", + "name": "MultiStark::open_prep_batch", + "rows": 2 + }, + { + "chip": "MultiStark::open_prep", + "name": "MultiStark::open_prep", + "rows": 0 + }, + { + "chip": "MultiStark::assert_blowup_zero", + "name": "MultiStark::assert_blowup_zero", + "rows": 1 + }, + { + "chip": "MultiStark::verify_query", + "name": "MultiStark::verify_query", + "rows": 2 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Bucket\"}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Bucket\"}}]}", + "rows": 1 + }, + { + "chip": "MultiStark::fri_fold2", + "name": "MultiStark::fri_fold2", + "rows": 0 + }, + { + "chip": "MultiStark::rollin", + "name": "MultiStark::rollin", + "rows": 0 + }, + { + "chip": "MultiStark::verify_commit_multi", + "name": "MultiStark::verify_commit_multi", + "rows": 1 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":2}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 0 + }, + { + "chip": "MultiStark::rows_at_round", + "name": "MultiStark::rows_at_round", + "rows": 0 + }, + { + "chip": "MultiStark::last_acc", + "name": "MultiStark::last_acc", + "rows": 1 + }, + { + "chip": "MultiStark::batch_claims", + "name": "MultiStark::batch_claims", + "rows": 2 + }, + { + "chip": "${\"name\":\"MultiStark::list_concat\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 2 + } + ], + "prepare_seconds": 0.042114704, + "proof": null, + "samples": [], + "setup_seconds": 0.041860872, + "thp_disabled": true +} \ No newline at end of file diff --git a/docs/benchmarks/formal-aiur-grouping-tuning/recursion-metrics.json b/docs/benchmarks/formal-aiur-grouping-tuning/recursion-metrics.json new file mode 100644 index 000000000..20fa27c73 --- /dev/null +++ b/docs/benchmarks/formal-aiur-grouping-tuning/recursion-metrics.json @@ -0,0 +1 @@ +{"chips":[{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::verify_multi_stark_proof","private":1,"private_columns":[217],"shared":217,"width":218},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_byte_stream","private":2,"private_columns":[4,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"Blake3::compress_layer","private":3,"private_columns":[33,34,138],"shared":136,"width":139},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"Blake3::next_layer","private":37,"private_columns":[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,34,35,36,175],"shared":139,"width":176},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"Blake3::compress","private":2,"private_columns":[161,499],"shared":498,"width":500},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"Blake3::compress_chunks","private":3,"private_columns":[8,9,15],"shared":13,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"Blake3::finish","private":6,"private_columns":[2,7,8,9,10,164],"shared":159,"width":165},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"UInt64::is_zero","private":2,"private_columns":[8,17],"shared":16,"width":18},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"Blake3::bytes_to_block","private":1,"private_columns":[129],"shared":129,"width":130},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"Blake3::pad_block","private":2,"private_columns":[3,6],"shared":5,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"Blake3::compress_block","private":5,"private_columns":[7,8,73,177,178],"shared":174,"width":179},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"UInt64::wrapping_succ","private":18,"private_columns":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18],"shared":1,"width":19},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::read_vk_u16_limb","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"MultiStark::read_vk_u8","private":1,"private_columns":[3],"shared":3,"width":4},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_sys_circuits_n","private":12,"private_columns":[0,2,3,4,5,6,7,8,9,10,11,112],"shared":101,"width":113},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_vk_u32_limb","private":1,"private_columns":[9],"shared":9,"width":10},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"MultiStark::read_vk_tag","private":1,"private_columns":[3],"shared":3,"width":4},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::read_vk_u16","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_nodes_n","private":25,"private_columns":[0,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,23,24,25,26,29,30,42],"shared":18,"width":43},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"MultiStark::read_field","private":1,"private_columns":[10],"shared":10,"width":11},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_vk_u64","private":1,"private_columns":[17],"shared":17,"width":18},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"UInt32::less_than_fields","private":1,"private_columns":[12],"shared":12,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_node_ids_n","private":4,"private_columns":[0,2,3,9],"shared":6,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_sys_lookups_n","private":4,"private_columns":[0,2,3,13],"shared":10,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::lookup_groups_count","private":3,"private_columns":[4,5,8],"shared":6,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_opt_commit","private":3,"private_columns":[1,3,9],"shared":7,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_vk_cap_n","private":4,"private_columns":[0,2,3,44],"shared":41,"width":45},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_opt_idx_n","private":5,"private_columns":[0,2,3,4,11],"shared":7,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"${\"name\":\"MultiStark::list_concat\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}","private":2,"private_columns":[3,15],"shared":14,"width":16},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::read_count","private":1,"private_columns":[11],"shared":11,"width":12},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_u64","private":1,"private_columns":[17],"shared":17,"width":18},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::read_u8","private":4,"private_columns":[1,3,4,6],"shared":3,"width":7},{"constraint_degree":2,"lifted":0,"lookups":[[2,1]],"name":"UInt64::to_field","private":1,"private_columns":[8],"shared":8,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_claims_n","private":4,"private_columns":[0,2,3,11],"shared":8,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_claim_vals_n","private":4,"private_columns":[0,2,3,16],"shared":13,"width":17},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::read_count_at","private":1,"private_columns":[11],"shared":11,"width":12},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_u64_at","private":1,"private_columns":[17],"shared":17,"width":18},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_header_vec_n","private":4,"private_columns":[0,2,3,21],"shared":18,"width":22},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_active_n","private":4,"private_columns":[0,2,3,9],"shared":6,"width":10},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1]],"name":"MultiStark::read_u8_at","private":1,"private_columns":[3],"shared":3,"width":4},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::read_digest_vec_at","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_digest_vec_at_n","private":4,"private_columns":[0,2,3,44],"shared":41,"width":45},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_u64_vec_vec_n","private":4,"private_columns":[0,2,3,9],"shared":6,"width":10},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::read_u64_vec","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_u64_vec_n","private":4,"private_columns":[0,2,3,16],"shared":13,"width":17},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_message_vec_n","private":4,"private_columns":[0,2,3,18],"shared":15,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_proof_vec_n","private":4,"private_columns":[0,2,3,32],"shared":29,"width":33},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_proof","private":1,"private_columns":[51],"shared":51,"width":52},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::read_ext_vec","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_ext_vec_n","private":4,"private_columns":[0,2,3,25],"shared":22,"width":26},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_merkle_cap_vec_n","private":4,"private_columns":[0,2,3,9],"shared":6,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_batch_opening_vec_n","private":4,"private_columns":[0,2,3,13],"shared":10,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_u64_vec_vec_vec_n","private":4,"private_columns":[0,2,3,11],"shared":8,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_commit_phase_step_vec_n","private":4,"private_columns":[0,2,3,13],"shared":10,"width":14},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::read_ext_vec_vec","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_ext_vec_vec_n","private":4,"private_columns":[0,2,3,9],"shared":6,"width":10},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::read_opened_round","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::read_opened_round_n","private":4,"private_columns":[0,2,3,9],"shared":6,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::read_preprocessed","private":3,"private_columns":[1,3,7],"shared":5,"width":8},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::verify_batch","private":4,"private_columns":[16,17,18,38],"shared":35,"width":39},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::assert_shard_count_ok","private":3,"private_columns":[1,2,14],"shared":12,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::ShardHeader\"}}]}","private":2,"private_columns":[1,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Proof\"}}]}","private":2,"private_columns":[1,29],"shared":28,"width":30},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::assert_closure_pairs","private":15,"private_columns":[4,5,6,7,8,9,10,11,12,13,14,15,16,17,157],"shared":143,"width":158},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::three_limbs","private":1,"private_columns":[37],"shared":37,"width":38},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::bytes8_le","private":1,"private_columns":[24],"shared":24,"width":25},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"MultiStark::le_step","private":2,"private_columns":[4,9],"shared":8,"width":10},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::batch_fiat_shamir","private":1,"private_columns":[71],"shared":71,"width":72},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::messages_onto","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::count_onto","private":3,"private_columns":[3,4,16],"shared":14,"width":17},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::b8_onto","private":1,"private_columns":[17],"shared":17,"width":18},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMessage\"}}]}","private":2,"private_columns":[1,14],"shared":13,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::messages_onto_each","private":2,"private_columns":[3,19],"shared":18,"width":20},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}","private":2,"private_columns":[1,13],"shared":12,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::limbs_onto","private":2,"private_columns":[3,15],"shared":14,"width":16},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::headers_onto","private":2,"private_columns":[3,11],"shared":10,"width":12},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::header_onto","private":1,"private_columns":[11],"shared":11,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::active_onto","private":2,"private_columns":[3,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::cap_onto","private":2,"private_columns":[3,43],"shared":42,"width":44},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}","private":2,"private_columns":[1,6],"shared":5,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::log_degrees_onto","private":2,"private_columns":[3,8],"shared":7,"width":9},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::claims_onto","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::claims_onto_each","private":2,"private_columns":[3,10],"shared":9,"width":11},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::ch_sample_ext","private":1,"private_columns":[22],"shared":22,"width":23},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::ch_sample_field","private":5,"private_columns":[12,13,14,25,31],"shared":27,"width":32},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::ch_sample8","private":12,"private_columns":[2,51,54,56,58,60,62,64,66,68,69,70],"shared":59,"width":71},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::b3_w4_onto","private":1,"private_columns":[9],"shared":9,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::rev_onto","private":2,"private_columns":[3,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"${\"name\":\"MultiStark::list_concat\",\"types\":[\"field\"]}","private":2,"private_columns":[3,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::messages_acc","private":2,"private_columns":[9,30],"shared":29,"width":31},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::fingerprint_vals","private":2,"private_columns":[5,18],"shared":17,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::verify_shards","private":2,"private_columns":[24,58],"shared":57,"width":59},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::verify_shard","private":3,"private_columns":[48,49,123],"shared":121,"width":124},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}","private":2,"private_columns":[1,7],"shared":6,"width":8},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::assert_bits","private":2,"private_columns":[2,6],"shared":5,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::select_active_circuits","private":3,"private_columns":[3,4,20],"shared":18,"width":21},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::select_active_prep","private":3,"private_columns":[3,4,13],"shared":11,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::assert_same_bits","private":2,"private_columns":[3,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::assert_same_cap","private":2,"private_columns":[3,77],"shared":76,"width":78},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"UInt64::eq","private":2,"private_columns":[16,25],"shared":24,"width":26},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::assert_log_degrees_ok","private":2,"private_columns":[2,7],"shared":6,"width":8},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"MultiStark::log_degree_ok","private":2,"private_columns":[33,67],"shared":66,"width":68},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::count_ones","private":2,"private_columns":[1,6],"shared":5,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::shard_fiat_shamir","private":3,"private_columns":[5,6,62],"shared":60,"width":63},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::snoc_b8","private":1,"private_columns":[12],"shared":12,"width":13},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::snoc_cap","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::accs_onto","private":6,"private_columns":[3,4,5,6,7,36],"shared":31,"width":37},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::claims_acc","private":2,"private_columns":[9,20],"shared":19,"width":21},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::ood_loop","private":7,"private_columns":[21,22,23,24,25,26,151],"shared":145,"width":152},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}","private":1,"private_columns":[5],"shared":5,"width":6},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}","private":3,"private_columns":[0,2,7],"shared":5,"width":8},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"MultiStark::quotient_degree_of","private":2,"private_columns":[18,37],"shared":36,"width":38},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}","private":1,"private_columns":[6],"shared":6,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"MultiStark::list_drop\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}","private":3,"private_columns":[0,2,8],"shared":6,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"MultiStark::ext_exp_pow2","private":2,"private_columns":[5,11],"shared":10,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"MultiStark::two_adic_gen","private":2,"private_columns":[3,7],"shared":6,"width":8},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"MultiStark::pow2","private":2,"private_columns":[1,4],"shared":3,"width":5},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::fold_roots","private":2,"private_columns":[21,29],"shared":28,"width":30},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::eval_at","private":12,"private_columns":[17,21,22,23,24,25,26,27,28,29,30,40],"shared":29,"width":41},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}","private":1,"private_columns":[8],"shared":8,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"MultiStark::list_drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}","private":3,"private_columns":[0,2,10],"shared":8,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"MultiStark::ood_fold","private":1,"private_columns":[8],"shared":8,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::logup_steps_fold","private":4,"private_columns":[46,47,48,92],"shared":89,"width":93},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::logup_fingerprint","private":2,"private_columns":[19,33],"shared":32,"width":34},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"MultiStark::pair_mul","private":1,"private_columns":[12],"shared":12,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::reconstruct_ext_row","private":2,"private_columns":[2,13],"shared":12,"width":14},{"constraint_degree":2,"lifted":0,"lookups":[[2,1]],"name":"MultiStark::from_ext_basis","private":1,"private_columns":[4],"shared":4,"width":5},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::quotient_eval","private":2,"private_columns":[7,18],"shared":17,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1]],"name":"MultiStark::prep_count","private":1,"private_columns":[3],"shared":3,"width":4},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::CommitPhaseMultiStep\"}}]}","private":2,"private_columns":[1,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::round_onto","private":2,"private_columns":[3,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::points_onto","private":2,"private_columns":[3,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::pcs_betas","private":4,"private_columns":[0,4,8,41],"shared":38,"width":42},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::pcs_check_witness","private":4,"private_columns":[0,10,11,18],"shared":15,"width":19},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::ch_sample_bits","private":1,"private_columns":[51],"shared":51,"width":52},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::take_bits","private":2,"private_columns":[3,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::bits_to_num","private":2,"private_columns":[1,6],"shared":5,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::obs_log_arities","private":2,"private_columns":[3,8],"shared":7,"width":9},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::sample_query_indices","private":2,"private_columns":[5,11],"shared":10,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::verify_input_multi","private":2,"private_columns":[14,30],"shared":29,"width":31},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::heights_all","private":2,"private_columns":[5,9],"shared":8,"width":10},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::mmcs_verify_multi","private":1,"private_columns":[21],"shared":21,"width":22},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::frontier_sort","private":3,"private_columns":[2,3,20],"shared":18,"width":21},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::frontier_split","private":5,"private_columns":[1,2,9,10,19],"shared":15,"width":20},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::frontier_merge","private":6,"private_columns":[3,4,5,6,7,27],"shared":22,"width":28},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::digest_eq","private":3,"private_columns":[67,71,72],"shared":70,"width":73},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::assert_same_claims","private":2,"private_columns":[3,10],"shared":9,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::assert_same_limbs","private":2,"private_columns":[3,24],"shared":23,"width":25},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::frontier_leaves","private":2,"private_columns":[5,14],"shared":13,"width":15},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::leaf_hash_at","private":1,"private_columns":[42],"shared":42,"width":43},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::b3_rows_chunks","private":9,"private_columns":[7,8,9,10,11,12,13,14,228],"shared":220,"width":229},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::rows_pop","private":6,"private_columns":[13,14,15,16,35,39],"shared":34,"width":40},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::select_rows","private":5,"private_columns":[4,5,6,7,28],"shared":24,"width":29},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::frontier_fold","private":2,"private_columns":[6,10],"shared":9,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::frontier_level","private":7,"private_columns":[1,4,5,6,7,14,36],"shared":30,"width":37},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::select_rows_le","private":4,"private_columns":[4,5,6,26],"shared":23,"width":27},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::inject_maybe","private":2,"private_columns":[5,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::has_height","private":3,"private_columns":[3,5,12],"shared":10,"width":13},{"constraint_degree":2,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::mmcs_compress","private":1,"private_columns":[101],"shared":101,"width":102},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1]],"name":"MultiStark::compress_ordered","private":2,"private_columns":[4,6],"shared":5,"width":7},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::heights_prep","private":3,"private_columns":[6,7,13],"shared":11,"width":14},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::heights_max","private":3,"private_columns":[1,2,9],"shared":7,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::drop_index_bits","private":2,"private_columns":[3,9],"shared":8,"width":10},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::query_views","private":2,"private_columns":[5,10],"shared":9,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::batch_views_at","private":2,"private_columns":[3,10],"shared":9,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::step_views_at","private":2,"private_columns":[3,11],"shared":10,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::query_loop","private":2,"private_columns":[26,36],"shared":35,"width":37},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::verify_one_query","private":3,"private_columns":[25,26,57],"shared":55,"width":58},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::build_buckets","private":3,"private_columns":[5,6,11],"shared":9,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::circ_has_height","private":4,"private_columns":[6,7,8,14],"shared":11,"width":15},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::open_batch_2pt","private":2,"private_columns":[14,20],"shared":19,"width":21},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::open_2pt_mat","private":1,"private_columns":[18],"shared":18,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::ri_apply","private":4,"private_columns":[4,18,19,22],"shared":19,"width":23},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::exp_by_bits","private":3,"private_columns":[3,4,11],"shared":9,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::bucket_update","private":4,"private_columns":[9,10,11,29],"shared":26,"width":30},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::ro_fold","private":2,"private_columns":[12,34],"shared":33,"width":35},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::open_quotient","private":2,"private_columns":[14,21],"shared":20,"width":22},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::open_prep_batch","private":2,"private_columns":[16,22],"shared":21,"width":23},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::open_prep","private":3,"private_columns":[16,17,25],"shared":23,"width":26},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::assert_blowup_zero","private":6,"private_columns":[3,4,5,6,7,21],"shared":16,"width":22},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::verify_query","private":14,"private_columns":[0,1,9,10,11,12,13,14,15,16,17,18,25,96],"shared":83,"width":97},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Bucket\"}}]}","private":2,"private_columns":[1,10],"shared":9,"width":11},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::fri_fold2","private":5,"private_columns":[13,15,16,17,18],"shared":14,"width":19},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1]],"name":"MultiStark::rollin","private":5,"private_columns":[5,8,9,10,22],"shared":18,"width":23},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::verify_commit_multi","private":3,"private_columns":[7,8,23],"shared":21,"width":24},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::rows_at_round","private":2,"private_columns":[3,11],"shared":10,"width":12},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::last_acc","private":2,"private_columns":[3,12],"shared":11,"width":13},{"constraint_degree":3,"lifted":0,"lookups":[[2,1],[2,1],[2,1],[2,1],[2,1]],"name":"MultiStark::batch_claims","private":2,"private_columns":[2,10],"shared":9,"width":11}],"entries":["MultiStark::verify_multi_stark_proof"],"groups":[["verifier_group_00",["UInt32::less_than_fields","UInt64::is_zero","UInt64::wrapping_succ","UInt64::to_field","MultiStark::read_sys_lookups_n","MultiStark::frontier_merge","MultiStark::frontier_split","MultiStark::frontier_sort","MultiStark::frontier_leaves","MultiStark::rows_at_round","MultiStark::limbs_onto","MultiStark::from_ext_basis"]],["verifier_group_02",["MultiStark::read_u8","MultiStark::read_digest_vec_at","MultiStark::read_vk_u32_limb","MultiStark::read_field","MultiStark::lookup_groups_count","MultiStark::assert_blowup_zero","MultiStark::ext_exp_pow2","MultiStark::reconstruct_ext_row","MultiStark::assert_bits","MultiStark::select_active_circuits","MultiStark::select_active_prep","${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysCircuit\"}}]}"]],["verifier_group_03",["MultiStark::read_u64","Blake3::next_layer","Blake3::compress_layer","MultiStark::read_vk_u64","MultiStark::mmcs_verify_multi","MultiStark::pcs_check_witness","MultiStark::open_prep_batch","MultiStark::query_loop","MultiStark::verify_commit_multi","MultiStark::ch_sample_field","MultiStark::ch_sample_ext","MultiStark::snoc_b8","MultiStark::logup_steps_fold"]],["verifier_group_04",["MultiStark::read_count","MultiStark::read_opened_round","MultiStark::read_batch_opening_vec_n","MultiStark::read_commit_phase_step_vec_n","MultiStark::read_preprocessed","MultiStark::mmcs_compress","MultiStark::pcs_betas","MultiStark::verify_query","MultiStark::cap_onto","MultiStark::ch_sample_bits","MultiStark::fingerprint_vals","MultiStark::read_claim_vals_n","${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Bucket\"}}]}","${\"name\":\"MultiStark::list_concat\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}"]],["verifier_group_05",["MultiStark::read_count_at","${\"name\":\"MultiStark::list_drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}"]],["verifier_group_06",["MultiStark::read_active_n","MultiStark::read_u64_vec_vec_vec_n","MultiStark::read_opened_round_n","MultiStark::b3_w4_onto","MultiStark::frontier_fold","MultiStark::circ_has_height","MultiStark::heights_all","MultiStark::heights_prep","MultiStark::batch_views_at","MultiStark::step_views_at","MultiStark::drop_index_bits","MultiStark::take_bits"]],["verifier_group_07",["MultiStark::read_u64_vec","MultiStark::list_length.Ptr.U8_8_4"]],["verifier_group_08",["MultiStark::read_ext_vec","MultiStark::read_ext_vec_vec","MultiStark::read_ext_vec_vec_n","Blake3::pad_block","MultiStark::read_vk_u16_limb","MultiStark::has_height","MultiStark::bits_to_num","MultiStark::exp_by_bits","MultiStark::points_onto","MultiStark::round_onto","MultiStark::log_degrees_onto"]],["verifier_group_09",["MultiStark::read_ext_vec_n","MultiStark::pair_mul"]],["verifier_group_10",["MultiStark::read_digest_vec_at_n","MultiStark::read_merkle_cap_vec_n","MultiStark::read_opt_idx_n","MultiStark::leaf_hash_at","MultiStark::fri_fold2","MultiStark::obs_log_arities","MultiStark::build_buckets","MultiStark::rollin","MultiStark::sample_query_indices","MultiStark::query_views","MultiStark::snoc_cap","MultiStark::two_adic_gen","MultiStark::pow2","MultiStark::quotient_eval","${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::CommitPhaseMultiStep\"}}]}"]],["verifier_group_11",["MultiStark::read_u64_vec_vec_n","MultiStark::read_node_ids_n"]],["verifier_group_12",["Blake3::bytes_to_block","Blake3::finish","Blake3::compress_block","MultiStark::read_sys_circuits_n","MultiStark::ch_sample8","MultiStark::ood_loop"]],["verifier_group_13",["MultiStark::read_vk_cap_n","MultiStark::read_opt_commit","MultiStark::prep_count","MultiStark::heights_max","MultiStark::verify_one_query","MultiStark::verify_input_multi","MultiStark::quotient_degree_of","MultiStark::claims_acc","MultiStark::read_claims_n","${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::FrontierNode\"}}]}"]],["verifier_group_14",["MultiStark::compress_ordered","MultiStark::ood_fold"]],["verifier_group_15",["MultiStark::select_rows_le","MultiStark::frontier_level","MultiStark::accs_onto"]],["verifier_group_16",["MultiStark::inject_maybe","MultiStark::rev_onto","${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}","${\"name\":\"MultiStark::list_drop\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}"]],["verifier_group_17",["MultiStark::open_2pt_mat","MultiStark::open_batch_2pt","MultiStark::open_quotient","MultiStark::open_prep","MultiStark::fold_roots","MultiStark::logup_fingerprint"]],["verifier_group_19",["${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchOpening\"}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::CommitPhaseProofStep\"}}]}","${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}"]]],"representatives":[["MultiStark::verify_multi_stark_proof","MultiStark::verify_multi_stark_proof"],["MultiStark::read_byte_stream","MultiStark::read_byte_stream"],["Blake3::compress_layer","Blake3::compress_layer"],["Blake3::next_layer","Blake3::next_layer"],["Blake3::compress","Blake3::compress"],["Blake3::compress_chunks","Blake3::compress_chunks"],["Blake3::finish","Blake3::finish"],["UInt64::is_zero","UInt64::is_zero"],["Blake3::bytes_to_block","Blake3::bytes_to_block"],["Blake3::pad_block","Blake3::pad_block"],["Blake3::compress_block","Blake3::compress_block"],["${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}","${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}"],["UInt64::wrapping_succ","UInt64::wrapping_succ"],["MultiStark::read_vk_u16_limb","MultiStark::read_vk_u16_limb"],["MultiStark::read_vk_u8","MultiStark::read_vk_u8"],["MultiStark::read_sys_circuits_n","MultiStark::read_sys_circuits_n"],["MultiStark::read_vk_u32_limb","MultiStark::read_vk_u32_limb"],["MultiStark::read_vk_tag","MultiStark::read_vk_tag"],["MultiStark::read_vk_u16","MultiStark::read_vk_u16"],["MultiStark::read_nodes_n","MultiStark::read_nodes_n"],["MultiStark::read_field","MultiStark::read_field"],["MultiStark::read_vk_u64","MultiStark::read_vk_u64"],["UInt32::less_than_fields","UInt32::less_than_fields"],["MultiStark::read_node_ids_n","MultiStark::read_node_ids_n"],["MultiStark::read_sys_lookups_n","MultiStark::read_sys_lookups_n"],["MultiStark::lookup_groups_count","MultiStark::lookup_groups_count"],["MultiStark::read_opt_commit","MultiStark::read_opt_commit"],["MultiStark::read_vk_cap_n","MultiStark::read_vk_cap_n"],["MultiStark::read_opt_idx_n","MultiStark::read_opt_idx_n"],["${\"name\":\"MultiStark::list_concat\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}","${\"name\":\"MultiStark::list_concat\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}"],["MultiStark::read_count","MultiStark::read_count"],["MultiStark::read_u64","MultiStark::read_u64"],["MultiStark::read_u8","MultiStark::read_u8"],["UInt64::to_field","UInt64::to_field"],["MultiStark::read_claims_n","MultiStark::read_claims_n"],["MultiStark::read_claim_vals_n","MultiStark::read_claim_vals_n"],["MultiStark::read_count_at","MultiStark::read_count_at"],["MultiStark::read_u64_at","MultiStark::read_u64_at"],["MultiStark::read_header_vec_n","MultiStark::read_header_vec_n"],["MultiStark::read_active_n","MultiStark::read_active_n"],["MultiStark::read_u8_at","MultiStark::read_u8_at"],["MultiStark::read_digest_vec_at","MultiStark::read_digest_vec_at"],["MultiStark::read_digest_vec_at_n","MultiStark::read_digest_vec_at_n"],["MultiStark::read_u8_vec_n","MultiStark::read_active_n"],["MultiStark::read_u64_vec_vec_n","MultiStark::read_u64_vec_vec_n"],["MultiStark::read_u64_vec","MultiStark::read_u64_vec"],["MultiStark::read_u64_vec_n","MultiStark::read_u64_vec_n"],["MultiStark::read_message_vec_n","MultiStark::read_message_vec_n"],["MultiStark::read_proof_vec_n","MultiStark::read_proof_vec_n"],["MultiStark::read_proof","MultiStark::read_proof"],["MultiStark::read_ext_vec","MultiStark::read_ext_vec"],["MultiStark::read_ext_vec_n","MultiStark::read_ext_vec_n"],["MultiStark::read_merkle_cap_vec_n","MultiStark::read_merkle_cap_vec_n"],["MultiStark::read_batch_opening_vec_n","MultiStark::read_batch_opening_vec_n"],["MultiStark::read_u64_vec_vec_vec_n","MultiStark::read_u64_vec_vec_vec_n"],["MultiStark::read_commit_phase_step_vec_n","MultiStark::read_commit_phase_step_vec_n"],["MultiStark::read_ext_vec_vec","MultiStark::read_ext_vec_vec"],["MultiStark::read_ext_vec_vec_n","MultiStark::read_ext_vec_vec_n"],["MultiStark::read_opened_round","MultiStark::read_opened_round"],["MultiStark::read_opened_round_n","MultiStark::read_opened_round_n"],["MultiStark::read_preprocessed","MultiStark::read_preprocessed"],["MultiStark::verify_batch","MultiStark::verify_batch"],["MultiStark::assert_shard_count_ok","MultiStark::assert_shard_count_ok"],["${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::ShardHeader\"}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::ShardHeader\"}}]}"],["${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Proof\"}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Proof\"}}]}"],["MultiStark::assert_closure_pairs","MultiStark::assert_closure_pairs"],["MultiStark::three_limbs","MultiStark::three_limbs"],["MultiStark::bytes8_le","MultiStark::bytes8_le"],["MultiStark::le_step","MultiStark::le_step"],["MultiStark::batch_fiat_shamir","MultiStark::batch_fiat_shamir"],["MultiStark::messages_onto","MultiStark::messages_onto"],["MultiStark::count_onto","MultiStark::count_onto"],["MultiStark::b8_onto","MultiStark::b8_onto"],["${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMessage\"}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMessage\"}}]}"],["MultiStark::messages_onto_each","MultiStark::messages_onto_each"],["${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}"],["MultiStark::limbs_onto","MultiStark::limbs_onto"],["MultiStark::headers_onto","MultiStark::headers_onto"],["MultiStark::header_onto","MultiStark::header_onto"],["MultiStark::active_onto","MultiStark::active_onto"],["MultiStark::cap_onto","MultiStark::cap_onto"],["${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}","${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}"],["MultiStark::log_degrees_onto","MultiStark::log_degrees_onto"],["MultiStark::claims_onto","MultiStark::claims_onto"],["${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}"],["MultiStark::claims_onto_each","MultiStark::claims_onto_each"],["MultiStark::ch_sample_ext","MultiStark::ch_sample_ext"],["MultiStark::ch_sample_field","MultiStark::ch_sample_field"],["MultiStark::ch_sample8","MultiStark::ch_sample8"],["MultiStark::b3_w4_onto","MultiStark::b3_w4_onto"],["MultiStark::rev_onto","MultiStark::rev_onto"],["${\"name\":\"MultiStark::list_concat\",\"types\":[\"field\"]}","${\"name\":\"MultiStark::list_concat\",\"types\":[\"field\"]}"],["MultiStark::messages_acc","MultiStark::messages_acc"],["MultiStark::fingerprint_vals","MultiStark::fingerprint_vals"],["MultiStark::verify_shards","MultiStark::verify_shards"],["MultiStark::verify_shard","MultiStark::verify_shard"],["${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}"],["${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":2}}],\"name\":\"Lists::Node\"}}}}],\"name\":\"Lists::Node\"}}}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}"],["MultiStark::assert_bits","MultiStark::assert_bits"],["${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysCircuit\"}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMessage\"}}]}"],["MultiStark::select_active_circuits","MultiStark::select_active_circuits"],["MultiStark::select_active_prep","MultiStark::select_active_prep"],["MultiStark::assert_same_bits","MultiStark::assert_same_bits"],["MultiStark::assert_same_cap","MultiStark::assert_same_cap"],["UInt64::eq","UInt64::eq"],["MultiStark::assert_same_u8s","MultiStark::assert_same_bits"],["MultiStark::assert_log_degrees_ok","MultiStark::assert_log_degrees_ok"],["MultiStark::log_degree_ok","MultiStark::log_degree_ok"],["MultiStark::count_ones","MultiStark::count_ones"],["MultiStark::shard_fiat_shamir","MultiStark::shard_fiat_shamir"],["MultiStark::snoc_b8","MultiStark::snoc_b8"],["MultiStark::snoc_cap","MultiStark::snoc_cap"],["MultiStark::accs_onto","MultiStark::accs_onto"],["MultiStark::claims_acc","MultiStark::claims_acc"],["MultiStark::ood_loop","MultiStark::ood_loop"],["${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}","${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}"],["${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}","${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}"],["MultiStark::quotient_degree_of","MultiStark::quotient_degree_of"],["${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}","${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}"],["${\"name\":\"MultiStark::list_drop\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}","${\"name\":\"MultiStark::list_drop\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}"],["${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":2}}],\"name\":\"Lists::Node\"}}}}],\"name\":\"Lists::Node\"}}}}]}","${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}"],["${\"name\":\"MultiStark::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":2}}],\"name\":\"Lists::Node\"}}}}],\"name\":\"Lists::Node\"}}}}]}","${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}"],["${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":2}}],\"name\":\"Lists::Node\"}}}}]}","${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}"],["${\"name\":\"MultiStark::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":2}}],\"name\":\"Lists::Node\"}}}}]}","${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}"],["${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::OptIdx\"}}]}","${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}"],["${\"name\":\"MultiStark::list_drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::OptIdx\"}}]}","${\"name\":\"MultiStark::list_drop\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}"],["MultiStark::ext_exp_pow2","MultiStark::ext_exp_pow2"],["MultiStark::two_adic_gen","MultiStark::two_adic_gen"],["MultiStark::pow2","MultiStark::pow2"],["MultiStark::fold_roots","MultiStark::fold_roots"],["MultiStark::eval_at","MultiStark::eval_at"],["${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}","${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}"],["${\"name\":\"MultiStark::list_drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}","${\"name\":\"MultiStark::list_drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}"],["MultiStark::ood_fold","MultiStark::ood_fold"],["MultiStark::logup_steps_fold","MultiStark::logup_steps_fold"],["MultiStark::logup_fingerprint","MultiStark::logup_fingerprint"],["MultiStark::pair_mul","MultiStark::pair_mul"],["${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysLookup\"}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}"],["MultiStark::reconstruct_ext_row","MultiStark::reconstruct_ext_row"],["MultiStark::from_ext_basis","MultiStark::from_ext_basis"],["MultiStark::quotient_eval","MultiStark::quotient_eval"],["${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"array\":{\"element\":{\"array\":{\"element\":\"field\",\"length\":8}},\"length\":4}}}}],\"name\":\"Lists::Node\"}}}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}"],["${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMultiOpening\"}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}"],["MultiStark::prep_count","MultiStark::prep_count"],["${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::CommitPhaseMultiStep\"}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::CommitPhaseMultiStep\"}}]}"],["MultiStark::round_onto","MultiStark::round_onto"],["MultiStark::points_onto","MultiStark::points_onto"],["MultiStark::ext_row_onto","MultiStark::accs_onto"],["MultiStark::pcs_betas","MultiStark::pcs_betas"],["MultiStark::pcs_check_witness","MultiStark::pcs_check_witness"],["MultiStark::ch_sample_bits","MultiStark::ch_sample_bits"],["MultiStark::cons8","MultiStark::b8_onto"],["MultiStark::take_bits","MultiStark::take_bits"],["MultiStark::bits_to_num","MultiStark::bits_to_num"],["MultiStark::obs_log_arities","MultiStark::obs_log_arities"],["MultiStark::sample_query_indices","MultiStark::sample_query_indices"],["MultiStark::verify_input_multi","MultiStark::verify_input_multi"],["MultiStark::heights_all","MultiStark::heights_all"],["${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMultiOpening\"}}]}","${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}"],["${\"name\":\"MultiStark::list_drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMultiOpening\"}}]}","${\"name\":\"MultiStark::list_drop\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}"],["MultiStark::mmcs_verify_multi","MultiStark::mmcs_verify_multi"],["${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}],\"name\":\"Lists::Node\"}}}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}"],["${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[\"field\"],\"name\":\"Lists::Node\"}}}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}"],["MultiStark::frontier_sort","MultiStark::frontier_sort"],["MultiStark::frontier_split","MultiStark::frontier_split"],["MultiStark::frontier_merge","MultiStark::frontier_merge"],["MultiStark::digest_eq","MultiStark::digest_eq"],["MultiStark::assert_same_claims","MultiStark::assert_same_claims"],["MultiStark::assert_same_limbs","MultiStark::assert_same_limbs"],["MultiStark::frontier_leaves","MultiStark::frontier_leaves"],["MultiStark::leaf_hash_at","MultiStark::leaf_hash_at"],["MultiStark::b3_rows_chunks","MultiStark::b3_rows_chunks"],["MultiStark::rows_pop","MultiStark::rows_pop"],["MultiStark::select_rows","MultiStark::select_rows"],["MultiStark::frontier_fold","MultiStark::frontier_fold"],["MultiStark::frontier_level","MultiStark::frontier_level"],["MultiStark::select_rows_le","MultiStark::select_rows_le"],["MultiStark::inject_maybe","MultiStark::inject_maybe"],["MultiStark::has_height","MultiStark::has_height"],["MultiStark::mmcs_compress","MultiStark::mmcs_compress"],["MultiStark::compress_ordered","MultiStark::compress_ordered"],["${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":{\"array\":{\"element\":\"field\",\"length\":8}},\"length\":4}}}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}"],["${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::FrontierNode\"}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::ShardHeader\"}}]}"],["${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":{\"array\":{\"element\":\"field\",\"length\":8}},\"length\":4}}}}]}","${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}"],["${\"name\":\"MultiStark::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":{\"array\":{\"element\":\"field\",\"length\":8}},\"length\":4}}}}]}","${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}"],["MultiStark::heights_prep","MultiStark::heights_prep"],["MultiStark::heights_max","MultiStark::heights_max"],["MultiStark::drop_index_bits","MultiStark::drop_index_bits"],["MultiStark::query_views","MultiStark::query_views"],["MultiStark::batch_views_at","MultiStark::batch_views_at"],["${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}],\"name\":\"Lists::Node\"}}}}]}","${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}"],["${\"name\":\"MultiStark::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}],\"name\":\"Lists::Node\"}}}}]}","${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}"],["MultiStark::step_views_at","MultiStark::step_views_at"],["MultiStark::query_loop","MultiStark::query_loop"],["MultiStark::verify_one_query","MultiStark::verify_one_query"],["${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::CommitPhaseProofStep\"}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}"],["${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchOpening\"}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}"],["MultiStark::build_buckets","MultiStark::build_buckets"],["MultiStark::circ_has_height","MultiStark::circ_has_height"],["${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchOpening\"}}]}","${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}"],["${\"name\":\"MultiStark::list_drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchOpening\"}}]}","${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}"],["MultiStark::open_batch_2pt","MultiStark::open_batch_2pt"],["MultiStark::open_2pt_mat","MultiStark::open_2pt_mat"],["MultiStark::ri_apply","MultiStark::ri_apply"],["MultiStark::exp_by_bits","MultiStark::exp_by_bits"],["MultiStark::glist_rev","MultiStark::rev_onto"],["MultiStark::bucket_update","MultiStark::bucket_update"],["MultiStark::ro_fold","MultiStark::ro_fold"],["${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}]}","${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}"],["${\"name\":\"MultiStark::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}]}","${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}"],["MultiStark::open_quotient","MultiStark::open_quotient"],["MultiStark::open_prep_batch","MultiStark::open_prep_batch"],["MultiStark::open_prep","MultiStark::open_prep"],["MultiStark::assert_blowup_zero","MultiStark::assert_blowup_zero"],["MultiStark::verify_query","MultiStark::verify_query"],["${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Bucket\"}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Bucket\"}}]}"],["MultiStark::fri_fold2","MultiStark::fri_fold2"],["MultiStark::rollin","MultiStark::rollin"],["MultiStark::verify_commit_multi","MultiStark::verify_commit_multi"],["${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":2}}],\"name\":\"Lists::Node\"}}}}]}","${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}"],["MultiStark::rows_at_round","MultiStark::rows_at_round"],["MultiStark::last_acc","MultiStark::last_acc"],["MultiStark::batch_claims","MultiStark::batch_claims"],["${\"name\":\"MultiStark::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}]}","${\"name\":\"MultiStark::list_concat\",\"types\":[\"field\"]}"],["UInt8::from_field","UInt8::from_field"],["UInt8::raw_bit_decomposition","UInt8::raw_bit_decomposition"],["UInt8::range_pair","UInt8::range_pair"],["UInt8::raw_xor","UInt8::raw_xor"],["UInt8::raw_add","UInt8::raw_add"],["UInt8::raw_sub","UInt8::raw_sub"],["UInt8::raw_mul","UInt8::raw_mul"],["UInt8::raw_xor_split4","UInt8::raw_xor_split4"],["UInt8::raw_xor_split7","UInt8::raw_xor_split7"],["UInt8::raw_sum_byte","UInt8::raw_sum_byte"]]} \ No newline at end of file diff --git a/docs/benchmarks/formal-aiur-grouping-tuning/recursion-policy.json b/docs/benchmarks/formal-aiur-grouping-tuning/recursion-policy.json new file mode 100644 index 000000000..6ddc15828 --- /dev/null +++ b/docs/benchmarks/formal-aiur-grouping-tuning/recursion-policy.json @@ -0,0 +1,371 @@ +[ + [ + "verifier_group_00", + [ + "MultiStark::read_byte_stream", + "MultiStark::read_vk_u16", + "MultiStark::rev_onto" + ] + ], + [ + "verifier_group_01", + [ + "Blake3::compress_layer", + "Blake3::finish", + "MultiStark::read_vk_u64", + "MultiStark::active_onto", + "MultiStark::digest_eq" + ] + ], + [ + "verifier_group_02", + [ + "Blake3::next_layer", + "MultiStark::assert_closure_pairs", + "MultiStark::verify_shard", + "MultiStark::ood_loop", + "MultiStark::verify_query", + "MultiStark::verify_commit_multi", + "MultiStark::last_acc" + ] + ], + [ + "verifier_group_03", + [ + "UInt64::is_zero", + "MultiStark::read_merkle_cap_vec_n", + "MultiStark::messages_onto_each", + "MultiStark::messages_acc", + "MultiStark::obs_log_arities", + "MultiStark::verify_input_multi", + "MultiStark::assert_blowup_zero", + "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Bucket\"}}]}" + ] + ], + [ + "verifier_group_04", + [ + "Blake3::bytes_to_block", + "MultiStark::read_digest_vec_at_n", + "MultiStark::batch_fiat_shamir", + "MultiStark::shard_fiat_shamir", + "MultiStark::logup_steps_fold" + ] + ], + [ + "verifier_group_05", + [ + "Blake3::compress_block", + "MultiStark::cap_onto", + "MultiStark::b3_rows_chunks", + "MultiStark::open_prep" + ] + ], + [ + "verifier_group_06", + [ + "${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}", + "MultiStark::accs_onto", + "MultiStark::select_rows_le", + "MultiStark::inject_maybe" + ] + ], + [ + "verifier_group_07", + [ + "UInt64::wrapping_succ", + "MultiStark::read_vk_cap_n", + "MultiStark::three_limbs", + "MultiStark::bytes8_le", + "MultiStark::le_step", + "MultiStark::assert_same_cap", + "MultiStark::pcs_betas", + "MultiStark::pcs_check_witness", + "MultiStark::heights_prep", + "MultiStark::fri_fold2" + ] + ], + [ + "verifier_group_08", + [ + "MultiStark::read_vk_u16_limb", + "${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}" + ] + ], + [ + "verifier_group_09", + [ + "MultiStark::read_sys_circuits_n", + "MultiStark::read_proof", + "MultiStark::log_degree_ok", + "MultiStark::mmcs_compress", + "MultiStark::verify_one_query" + ] + ], + [ + "verifier_group_10", + [ + "MultiStark::read_vk_u32_limb", + "MultiStark::read_field", + "MultiStark::read_sys_lookups_n", + "MultiStark::read_batch_opening_vec_n", + "MultiStark::claims_onto", + "MultiStark::claims_onto_each", + "MultiStark::snoc_b8", + "MultiStark::reconstruct_ext_row", + "MultiStark::prep_count" + ] + ], + [ + "verifier_group_11", + [ + "UInt32::less_than_fields", + "MultiStark::select_rows" + ] + ], + [ + "verifier_group_12", + [ + "MultiStark::lookup_groups_count", + "MultiStark::read_opt_idx_n", + "MultiStark::read_claims_n", + "MultiStark::log_degrees_onto" + ] + ], + [ + "verifier_group_13", + [ + "MultiStark::read_opt_commit", + "MultiStark::read_header_vec_n", + "MultiStark::read_message_vec_n", + "MultiStark::select_active_circuits", + "MultiStark::quotient_eval", + "MultiStark::rollin" + ] + ], + [ + "verifier_group_14", + [ + "${\"name\":\"MultiStark::list_concat\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "MultiStark::read_active_n", + "MultiStark::read_ext_vec", + "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMessage\"}}]}", + "MultiStark::heights_all", + "MultiStark::frontier_fold" + ] + ], + [ + "verifier_group_15", + [ + "MultiStark::read_count", + "MultiStark::read_proof_vec_n", + "MultiStark::assert_shard_count_ok", + "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::ShardHeader\"}}]}", + "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Proof\"}}]}", + "MultiStark::claims_acc", + "MultiStark::pow2", + "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::CommitPhaseMultiStep\"}}]}", + "MultiStark::build_buckets" + ] + ], + [ + "verifier_group_16", + [ + "MultiStark::read_u64", + "MultiStark::ri_apply" + ] + ], + [ + "verifier_group_17", + [ + "MultiStark::read_u8", + "MultiStark::read_u8_at" + ] + ], + [ + "verifier_group_18", + [ + "UInt64::to_field", + "MultiStark::read_claim_vals_n", + "MultiStark::read_digest_vec_at", + "MultiStark::headers_onto", + "MultiStark::assert_same_bits", + "MultiStark::snoc_cap", + "MultiStark::bits_to_num", + "MultiStark::has_height" + ] + ], + [ + "verifier_group_19", + [ + "MultiStark::read_count_at", + "MultiStark::read_u64_at" + ] + ], + [ + "verifier_group_20", + [ + "MultiStark::read_u64_vec", + "MultiStark::read_u64_vec_n", + "${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}" + ] + ], + [ + "verifier_group_21", + [ + "MultiStark::read_ext_vec_n", + "MultiStark::read_ext_vec_vec_n", + "MultiStark::fingerprint_vals" + ] + ], + [ + "verifier_group_22", + [ + "MultiStark::read_u64_vec_vec_vec_n", + "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "MultiStark::b3_w4_onto", + "MultiStark::batch_views_at" + ] + ], + [ + "verifier_group_23", + [ + "MultiStark::read_commit_phase_step_vec_n", + "MultiStark::select_active_prep", + "MultiStark::ext_exp_pow2", + "MultiStark::heights_max", + "MultiStark::drop_index_bits" + ] + ], + [ + "verifier_group_24", + [ + "MultiStark::read_ext_vec_vec", + "MultiStark::read_opened_round_n", + "MultiStark::messages_onto", + "MultiStark::assert_bits", + "MultiStark::assert_log_degrees_ok", + "MultiStark::count_ones" + ] + ], + [ + "verifier_group_25", + [ + "MultiStark::read_opened_round", + "MultiStark::pair_mul", + "MultiStark::round_onto", + "MultiStark::compress_ordered" + ] + ], + [ + "verifier_group_26", + [ + "MultiStark::read_preprocessed", + "MultiStark::verify_batch", + "MultiStark::leaf_hash_at", + "MultiStark::frontier_level", + "MultiStark::circ_has_height", + "MultiStark::rows_at_round" + ] + ], + [ + "verifier_group_27", + [ + "MultiStark::count_onto", + "MultiStark::frontier_merge", + "MultiStark::open_prep_batch", + "MultiStark::batch_claims" + ] + ], + [ + "verifier_group_28", + [ + "${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}" + ] + ], + [ + "verifier_group_29", + [ + "MultiStark::limbs_onto", + "MultiStark::frontier_sort", + "MultiStark::frontier_split", + "MultiStark::frontier_leaves" + ] + ], + [ + "verifier_group_30", + [ + "MultiStark::header_onto", + "MultiStark::ch_sample8", + "MultiStark::verify_shards", + "MultiStark::quotient_degree_of", + "MultiStark::mmcs_verify_multi" + ] + ], + [ + "verifier_group_31", + [ + "MultiStark::ch_sample_ext", + "MultiStark::ch_sample_field", + "MultiStark::query_loop" + ] + ], + [ + "verifier_group_32", + [ + "${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "MultiStark::sample_query_indices", + "MultiStark::query_views", + "MultiStark::step_views_at" + ] + ], + [ + "verifier_group_33", + [ + "UInt64::eq", + "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}" + ] + ], + [ + "verifier_group_34", + [ + "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "MultiStark::fold_roots", + "MultiStark::logup_fingerprint", + "MultiStark::open_batch_2pt", + "MultiStark::open_2pt_mat", + "MultiStark::open_quotient" + ] + ], + [ + "verifier_group_35", + [ + "MultiStark::eval_at", + "MultiStark::assert_same_limbs" + ] + ], + [ + "verifier_group_36", + [ + "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}", + "MultiStark::ood_fold" + ] + ], + [ + "verifier_group_37", + [ + "MultiStark::from_ext_basis", + "MultiStark::points_onto", + "MultiStark::assert_same_claims", + "MultiStark::exp_by_bits" + ] + ], + [ + "verifier_group_38", + [ + "MultiStark::bucket_update", + "MultiStark::ro_fold" + ] + ] +] diff --git a/docs/benchmarks/formal-aiur-grouping-tuning/recursion-policy.report.json b/docs/benchmarks/formal-aiur-grouping-tuning/recursion-policy.report.json new file mode 100644 index 000000000..06316938f --- /dev/null +++ b/docs/benchmarks/formal-aiur-grouping-tuning/recursion-policy.report.json @@ -0,0 +1,1145 @@ +{ + "initial": [ + 3739, + 77, + 315000, + 11154380, + 936297673, + 81689846845 + ], + "optimized": [ + 3010, + 54, + 229871, + 8286135, + 880415707, + 77827446583 + ], + "dimensions": [ + "stage1_columns", + "function_circuits", + "cells_0", + "fft_0", + "cells_1", + "fft_1" + ], + "profiles": [ + [ + ".lake/grouping-tune/recursion-counts.json", + ".lake/formal-comparison/final/new-recursion-ungrouped.json" + ], + [ + ".lake/grouping-tune/recursion-real-counts.json", + ".lake/formal-comparison/final/new-recursion-real-ungrouped.json" + ] + ], + "circuits": [ + { + "members": [ + "MultiStark::verify_multi_stark_proof" + ], + "shape": [ + 219, + 96, + 1 + ], + "cost": [ + 219, + 1, + 219, + 951, + 219, + 951 + ] + }, + { + "members": [ + "MultiStark::read_byte_stream", + "MultiStark::read_vk_u16", + "MultiStark::rev_onto" + ], + "shape": [ + 14, + 8, + 2 + ], + "cost": [ + 14, + 1, + 7168, + 365568, + 14680064, + 1648361472 + ] + }, + { + "members": [ + "Blake3::compress_layer", + "Blake3::finish", + "MultiStark::read_vk_u64", + "MultiStark::active_onto", + "MultiStark::digest_eq" + ], + "shape": [ + 175, + 28, + 2 + ], + "cost": [ + 175, + 1, + 5600, + 99744, + 1433600, + 66232320 + ] + }, + { + "members": [ + "Blake3::next_layer", + "MultiStark::assert_closure_pairs", + "MultiStark::verify_shard", + "MultiStark::ood_loop", + "MultiStark::verify_query", + "MultiStark::verify_commit_multi", + "MultiStark::last_acc" + ], + "shape": [ + 227, + 108, + 2 + ], + "cost": [ + 227, + 1, + 1816, + 24504, + 3719168, + 233472000 + ] + }, + { + "members": [ + "Blake3::compress" + ], + "shape": [ + 501, + 226, + 2 + ], + "cost": [ + 501, + 1, + 128256, + 4494336, + 525336576, + 46003126272 + ] + }, + { + "members": [ + "Blake3::compress_chunks" + ], + "shape": [ + 17, + 6, + 2 + ], + "cost": [ + 17, + 1, + 17408, + 841728, + 35651584, + 3592421376 + ] + }, + { + "members": [ + "UInt64::is_zero", + "MultiStark::read_merkle_cap_vec_n", + "MultiStark::messages_onto_each", + "MultiStark::messages_acc", + "MultiStark::obs_log_arities", + "MultiStark::verify_input_multi", + "MultiStark::assert_blowup_zero", + "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Bucket\"}}]}" + ], + "shape": [ + 52, + 26, + 2 + ], + "cost": [ + 52, + 1, + 416, + 6000, + 106496, + 5566464 + ] + }, + { + "members": [ + "Blake3::bytes_to_block", + "MultiStark::read_digest_vec_at_n", + "MultiStark::batch_fiat_shamir", + "MultiStark::shard_fiat_shamir", + "MultiStark::logup_steps_fold" + ], + "shape": [ + 143, + 130, + 2 + ], + "cost": [ + 143, + 1, + 4576, + 133344, + 4685824, + 408846336 + ] + }, + { + "members": [ + "Blake3::pad_block" + ], + "shape": [ + 8, + 4, + 2 + ], + "cost": [ + 8, + 1, + 2048, + 101376, + 8192, + 503808 + ] + }, + { + "members": [ + "Blake3::compress_block", + "MultiStark::cap_onto", + "MultiStark::b3_rows_chunks", + "MultiStark::open_prep" + ], + "shape": [ + 240, + 56, + 2 + ], + "cost": [ + 240, + 1, + 3840, + 57792, + 31457280, + 2006974464 + ] + }, + { + "members": [ + "${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}", + "MultiStark::accs_onto", + "MultiStark::select_rows_le", + "MultiStark::inject_maybe" + ], + "shape": [ + 45, + 26, + 2 + ], + "cost": [ + 45, + 1, + 1440, + 36384, + 5898240, + 502923264 + ] + }, + { + "members": [ + "UInt64::wrapping_succ", + "MultiStark::read_vk_cap_n", + "MultiStark::three_limbs", + "MultiStark::bytes8_le", + "MultiStark::le_step", + "MultiStark::assert_same_cap", + "MultiStark::pcs_betas", + "MultiStark::pcs_check_witness", + "MultiStark::heights_prep", + "MultiStark::fri_fold2" + ], + "shape": [ + 121, + 20, + 2 + ], + "cost": [ + 121, + 1, + 484, + 3528, + 247808, + 9824256 + ] + }, + { + "members": [ + "MultiStark::read_vk_u16_limb", + "${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}" + ], + "shape": [ + 10, + 6, + 2 + ], + "cost": [ + 10, + 1, + 640, + 23808, + 655360, + 63700992 + ] + }, + { + "members": [ + "MultiStark::read_vk_u8" + ], + "shape": [ + 5, + 4, + 1 + ], + "cost": [ + 5, + 1, + 640, + 30080, + 5242880, + 696254464 + ] + }, + { + "members": [ + "MultiStark::read_sys_circuits_n", + "MultiStark::read_proof", + "MultiStark::log_degree_ok", + "MultiStark::mmcs_compress", + "MultiStark::verify_one_query" + ], + "shape": [ + 121, + 68, + 2 + ], + "cost": [ + 121, + 1, + 968, + 13992, + 1982464, + 133005312 + ] + }, + { + "members": [ + "MultiStark::read_vk_u32_limb", + "MultiStark::read_field", + "MultiStark::read_sys_lookups_n", + "MultiStark::read_batch_opening_vec_n", + "MultiStark::claims_onto", + "MultiStark::claims_onto_each", + "MultiStark::snoc_b8", + "MultiStark::reconstruct_ext_row", + "MultiStark::prep_count" + ], + "shape": [ + 30, + 12, + 2 + ], + "cost": [ + 30, + 1, + 480, + 9024, + 122880, + 6832128 + ] + }, + { + "members": [ + "MultiStark::read_vk_tag" + ], + "shape": [ + 5, + 4, + 1 + ], + "cost": [ + 5, + 1, + 40, + 824, + 655360, + 74055680 + ] + }, + { + "members": [ + "MultiStark::read_nodes_n" + ], + "shape": [ + 44, + 36, + 2 + ], + "cost": [ + 44, + 1, + 352, + 6144, + 5767168, + 563085312 + ] + }, + { + "members": [ + "UInt32::less_than_fields", + "MultiStark::select_rows" + ], + "shape": [ + 31, + 14, + 2 + ], + "cost": [ + 31, + 1, + 496, + 9600, + 32505856, + 3095396352 + ] + }, + { + "members": [ + "MultiStark::read_node_ids_n" + ], + "shape": [ + 11, + 8, + 2 + ], + "cost": [ + 11, + 1, + 88, + 1752, + 720896, + 73138176 + ] + }, + { + "members": [ + "MultiStark::lookup_groups_count", + "MultiStark::read_opt_idx_n", + "MultiStark::read_claims_n", + "MultiStark::log_degrees_onto" + ], + "shape": [ + 23, + 10, + 2 + ], + "cost": [ + 23, + 1, + 184, + 2760, + 23552, + 1148928 + ] + }, + { + "members": [ + "MultiStark::read_opt_commit", + "MultiStark::read_header_vec_n", + "MultiStark::read_message_vec_n", + "MultiStark::select_active_circuits", + "MultiStark::quotient_eval", + "MultiStark::rollin" + ], + "shape": [ + 40, + 20, + 2 + ], + "cost": [ + 40, + 1, + 320, + 4704, + 81920, + 4349952 + ] + }, + { + "members": [ + "${\"name\":\"MultiStark::list_concat\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "MultiStark::read_active_n", + "MultiStark::read_ext_vec", + "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMessage\"}}]}", + "MultiStark::heights_all", + "MultiStark::frontier_fold" + ], + "shape": [ + 28, + 8, + 2 + ], + "cost": [ + 28, + 1, + 896, + 19584, + 114688, + 5947392 + ] + }, + { + "members": [ + "MultiStark::read_count", + "MultiStark::read_proof_vec_n", + "MultiStark::assert_shard_count_ok", + "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::ShardHeader\"}}]}", + "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Proof\"}}]}", + "MultiStark::claims_acc", + "MultiStark::pow2", + "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::CommitPhaseMultiStep\"}}]}", + "MultiStark::build_buckets" + ], + "shape": [ + 51, + 10, + 2 + ], + "cost": [ + 51, + 1, + 816, + 12672, + 6528, + 176256 + ] + }, + { + "members": [ + "MultiStark::read_u64", + "MultiStark::ri_apply" + ], + "shape": [ + 25, + 18, + 2 + ], + "cost": [ + 25, + 1, + 400, + 9216, + 1638400, + 148635648 + ] + }, + { + "members": [ + "MultiStark::read_u8", + "MultiStark::read_u8_at" + ], + "shape": [ + 9, + 6, + 2 + ], + "cost": [ + 9, + 1, + 576, + 22656, + 9216, + 595968 + ] + }, + { + "members": [ + "UInt64::to_field", + "MultiStark::read_claim_vals_n", + "MultiStark::read_digest_vec_at", + "MultiStark::headers_onto", + "MultiStark::assert_same_bits", + "MultiStark::snoc_cap", + "MultiStark::bits_to_num", + "MultiStark::has_height" + ], + "shape": [ + 30, + 8, + 2 + ], + "cost": [ + 30, + 1, + 960, + 20544, + 122880, + 6242304 + ] + }, + { + "members": [ + "MultiStark::read_count_at", + "MultiStark::read_u64_at" + ], + "shape": [ + 20, + 18, + 2 + ], + "cost": [ + 20, + 1, + 10240, + 586752, + 20971520, + 2654994432 + ] + }, + { + "members": [ + "MultiStark::read_u64_vec_vec_n" + ], + "shape": [ + 11, + 8, + 2 + ], + "cost": [ + 11, + 1, + 1408, + 63360, + 720896, + 73138176 + ] + }, + { + "members": [ + "MultiStark::read_u64_vec", + "MultiStark::read_u64_vec_n", + "${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}" + ], + "shape": [ + 20, + 8, + 2 + ], + "cost": [ + 20, + 1, + 5120, + 199680, + 20971520, + 2025848832 + ] + }, + { + "members": [ + "MultiStark::read_ext_vec_n", + "MultiStark::read_ext_vec_vec_n", + "MultiStark::fingerprint_vals" + ], + "shape": [ + 33, + 10, + 2 + ], + "cost": [ + 33, + 1, + 1056, + 22944, + 1081344, + 69697536 + ] + }, + { + "members": [ + "MultiStark::read_u64_vec_vec_vec_n", + "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "MultiStark::b3_w4_onto", + "MultiStark::batch_views_at" + ], + "shape": [ + 19, + 10, + 2 + ], + "cost": [ + 19, + 1, + 4864, + 205824, + 1245184, + 104595456 + ] + }, + { + "members": [ + "MultiStark::read_commit_phase_step_vec_n", + "MultiStark::select_active_prep", + "MultiStark::ext_exp_pow2", + "MultiStark::heights_max", + "MultiStark::drop_index_bits" + ], + "shape": [ + 26, + 12, + 2 + ], + "cost": [ + 26, + 1, + 104, + 1056, + 53248, + 2863104 + ] + }, + { + "members": [ + "MultiStark::read_ext_vec_vec", + "MultiStark::read_opened_round_n", + "MultiStark::messages_onto", + "MultiStark::assert_bits", + "MultiStark::assert_log_degrees_ok", + "MultiStark::count_ones" + ], + "shape": [ + 19, + 8, + 2 + ], + "cost": [ + 19, + 1, + 304, + 6144, + 38912, + 2119680 + ] + }, + { + "members": [ + "MultiStark::read_opened_round", + "MultiStark::pair_mul", + "MultiStark::round_onto", + "MultiStark::compress_ordered" + ], + "shape": [ + 19, + 8, + 2 + ], + "cost": [ + 19, + 1, + 304, + 6144, + 622592, + 46104576 + ] + }, + { + "members": [ + "MultiStark::read_preprocessed", + "MultiStark::verify_batch", + "MultiStark::leaf_hash_at", + "MultiStark::frontier_level", + "MultiStark::circ_has_height", + "MultiStark::rows_at_round" + ], + "shape": [ + 64, + 42, + 2 + ], + "cost": [ + 64, + 1, + 512, + 8016, + 1048576, + 75890688 + ] + }, + { + "members": [ + "MultiStark::count_onto", + "MultiStark::frontier_merge", + "MultiStark::open_prep_batch", + "MultiStark::batch_claims" + ], + "shape": [ + 36, + 20, + 2 + ], + "cost": [ + 36, + 1, + 1152, + 29184, + 294912, + 19267584 + ] + }, + { + "members": [ + "MultiStark::b8_onto" + ], + "shape": [ + 19, + 18, + 1 + ], + "cost": [ + 19, + 1, + 2432, + 105344, + 1245184, + 122945536 + ] + }, + { + "members": [ + "${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}" + ], + "shape": [ + 16, + 6, + 2 + ], + "cost": [ + 16, + 1, + 256, + 5184, + 16777216, + 1648361472 + ] + }, + { + "members": [ + "MultiStark::limbs_onto", + "MultiStark::frontier_sort", + "MultiStark::frontier_split", + "MultiStark::frontier_leaves" + ], + "shape": [ + 31, + 16, + 2 + ], + "cost": [ + 31, + 1, + 3968, + 138624, + 507904, + 35291136 + ] + }, + { + "members": [ + "MultiStark::header_onto", + "MultiStark::ch_sample8", + "MultiStark::verify_shards", + "MultiStark::quotient_degree_of", + "MultiStark::mmcs_verify_multi" + ], + "shape": [ + 78, + 54, + 2 + ], + "cost": [ + 78, + 1, + 2496, + 65664, + 19968, + 838656 + ] + }, + { + "members": [ + "MultiStark::ch_sample_ext", + "MultiStark::ch_sample_field", + "MultiStark::query_loop" + ], + "shape": [ + 44, + 12, + 2 + ], + "cost": [ + 44, + 1, + 1408, + 29184, + 11264, + 371712 + ] + }, + { + "members": [ + "${\"name\":\"MultiStark::list_concat\",\"types\":[\"field\"]}" + ], + "shape": [ + 10, + 8, + 1 + ], + "cost": [ + 10, + 1, + 5120, + 278528, + 20480, + 1359872 + ] + }, + { + "members": [ + "${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "MultiStark::sample_query_indices", + "MultiStark::query_views", + "MultiStark::step_views_at" + ], + "shape": [ + 19, + 10, + 2 + ], + "cost": [ + 19, + 1, + 1216, + 38784, + 622592, + 49053696 + ] + }, + { + "members": [ + "UInt64::eq", + "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}" + ], + "shape": [ + 30, + 6, + 2 + ], + "cost": [ + 30, + 1, + 960, + 19584, + 983040, + 59375616 + ] + }, + { + "members": [ + "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "MultiStark::fold_roots", + "MultiStark::logup_fingerprint", + "MultiStark::open_batch_2pt", + "MultiStark::open_2pt_mat", + "MultiStark::open_quotient" + ], + "shape": [ + 43, + 14, + 2 + ], + "cost": [ + 43, + 1, + 1376, + 29664, + 5636096, + 409337856 + ] + }, + { + "members": [ + "MultiStark::two_adic_gen" + ], + "shape": [ + 9, + 2, + 2 + ], + "cost": [ + 9, + 1, + 576, + 18048, + 576, + 18048 + ] + }, + { + "members": [ + "MultiStark::eval_at", + "MultiStark::assert_same_limbs" + ], + "shape": [ + 44, + 10, + 2 + ], + "cost": [ + 44, + 1, + 704, + 11328, + 5767168, + 389283840 + ] + }, + { + "members": [ + "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}", + "MultiStark::ood_fold" + ], + "shape": [ + 13, + 6, + 2 + ], + "cost": [ + 13, + 1, + 104, + 1752, + 1703936, + 155320320 + ] + }, + { + "members": [ + "MultiStark::from_ext_basis", + "MultiStark::points_onto", + "MultiStark::assert_same_claims", + "MultiStark::exp_by_bits" + ], + "shape": [ + 18, + 10, + 2 + ], + "cost": [ + 18, + 1, + 288, + 6336, + 294912, + 22216704 + ] + }, + { + "members": [ + "MultiStark::ch_sample_bits" + ], + "shape": [ + 53, + 24, + 1 + ], + "cost": [ + 53, + 1, + 848, + 15232, + 3392, + 91264 + ] + }, + { + "members": [ + "MultiStark::take_bits" + ], + "shape": [ + 10, + 8, + 2 + ], + "cost": [ + 10, + 1, + 320, + 10944, + 20480, + 1511424 + ] + }, + { + "members": [ + "MultiStark::rows_pop" + ], + "shape": [ + 41, + 8, + 2 + ], + "cost": [ + 41, + 1, + 328, + 3912, + 42991616, + 3347054592 + ] + }, + { + "members": [ + "MultiStark::bucket_update", + "MultiStark::ro_fold" + ], + "shape": [ + 40, + 10, + 2 + ], + "cost": [ + 40, + 1, + 1280, + 26304, + 83886080, + 7159676928 + ] + } + ] +} diff --git a/docs/benchmarks/formal-aiur-grouping-tuning/recursion-real-counts.json b/docs/benchmarks/formal-aiur-grouping-tuning/recursion-real-counts.json new file mode 100644 index 000000000..9fde87bb1 --- /dev/null +++ b/docs/benchmarks/formal-aiur-grouping-tuning/recursion-real-counts.json @@ -0,0 +1,1131 @@ +{ + "backend": "new-bytecode", + "circuits": [], + "function_rows": [ + { + "chip": "MultiStark::verify_multi_stark_proof", + "name": "MultiStark::verify_multi_stark_proof", + "rows": 1 + }, + { + "chip": "MultiStark::read_byte_stream", + "name": "MultiStark::read_byte_stream", + "rows": 727164 + }, + { + "chip": "Blake3::compress_layer", + "name": "Blake3::compress_layer", + "rows": 6615 + }, + { + "chip": "Blake3::next_layer", + "name": "Blake3::next_layer", + "rows": 11834 + }, + { + "chip": "Blake3::compress", + "name": "Blake3::compress", + "rows": 993400 + }, + { + "chip": "Blake3::compress_chunks", + "name": "Blake3::compress_chunks", + "rows": 1128426 + }, + { + "chip": "Blake3::finish", + "name": "Blake3::finish", + "rows": 42 + }, + { + "chip": "UInt64::is_zero", + "name": "UInt64::is_zero", + "rows": 711 + }, + { + "chip": "Blake3::bytes_to_block", + "name": "Blake3::bytes_to_block", + "rows": 17056 + }, + { + "chip": "Blake3::pad_block", + "name": "Blake3::pad_block", + "rows": 726 + }, + { + "chip": "Blake3::compress_block", + "name": "Blake3::compress_block", + "rows": 17620 + }, + { + "chip": "${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}", + "name": "${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}", + "rows": 17601 + }, + { + "chip": "UInt64::wrapping_succ", + "name": "UInt64::wrapping_succ", + "rows": 710 + }, + { + "chip": "MultiStark::read_vk_u16_limb", + "name": "MultiStark::read_vk_u16_limb", + "rows": 713 + }, + { + "chip": "MultiStark::read_vk_u8", + "name": "MultiStark::read_vk_u8", + "rows": 727066 + }, + { + "chip": "MultiStark::read_sys_circuits_n", + "name": "MultiStark::read_sys_circuits_n", + "rows": 236 + }, + { + "chip": "MultiStark::read_vk_u32_limb", + "name": "MultiStark::read_vk_u32_limb", + "rows": 235 + }, + { + "chip": "MultiStark::read_vk_tag", + "name": "MultiStark::read_vk_tag", + "rows": 129659 + }, + { + "chip": "MultiStark::read_vk_u16", + "name": "MultiStark::read_vk_u16", + "rows": 294348 + }, + { + "chip": "MultiStark::read_nodes_n", + "name": "MultiStark::read_nodes_n", + "rows": 129659 + }, + { + "chip": "MultiStark::read_field", + "name": "MultiStark::read_field", + "rows": 789 + }, + { + "chip": "MultiStark::read_vk_u64", + "name": "MultiStark::read_vk_u64", + "rows": 793 + }, + { + "chip": "UInt32::less_than_fields", + "name": "UInt32::less_than_fields", + "rows": 133513 + }, + { + "chip": "MultiStark::read_node_ids_n", + "name": "MultiStark::read_node_ids_n", + "rows": 49175 + }, + { + "chip": "MultiStark::read_sys_lookups_n", + "name": "MultiStark::read_sys_lookups_n", + "rows": 2547 + }, + { + "chip": "MultiStark::lookup_groups_count", + "name": "MultiStark::lookup_groups_count", + "rows": 312 + }, + { + "chip": "MultiStark::read_opt_commit", + "name": "MultiStark::read_opt_commit", + "rows": 1 + }, + { + "chip": "MultiStark::read_vk_cap_n", + "name": "MultiStark::read_vk_cap_n", + "rows": 2 + }, + { + "chip": "MultiStark::read_opt_idx_n", + "name": "MultiStark::read_opt_idx_n", + "rows": 236 + }, + { + "chip": "${\"name\":\"MultiStark::list_concat\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "name": "${\"name\":\"MultiStark::list_concat\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "rows": 8 + }, + { + "chip": "MultiStark::read_count", + "name": "MultiStark::read_count", + "rows": 2 + }, + { + "chip": "MultiStark::read_u64", + "name": "MultiStark::read_u64", + "rows": 12 + }, + { + "chip": "MultiStark::read_u8", + "name": "MultiStark::read_u8", + "rows": 96 + }, + { + "chip": "UInt64::to_field", + "name": "UInt64::to_field", + "rows": 105 + }, + { + "chip": "MultiStark::read_claims_n", + "name": "MultiStark::read_claims_n", + "rows": 2 + }, + { + "chip": "MultiStark::read_claim_vals_n", + "name": "MultiStark::read_claim_vals_n", + "rows": 11 + }, + { + "chip": "MultiStark::read_count_at", + "name": "MultiStark::read_count_at", + "rows": 41791 + }, + { + "chip": "MultiStark::read_u64_at", + "name": "MultiStark::read_u64_at", + "rows": 903915 + }, + { + "chip": "MultiStark::read_header_vec_n", + "name": "MultiStark::read_header_vec_n", + "rows": 2 + }, + { + "chip": "MultiStark::read_active_n", + "name": "MultiStark::read_active_n", + "rows": 472 + }, + { + "chip": "MultiStark::read_u8_at", + "name": "MultiStark::read_u8_at", + "rows": 890 + }, + { + "chip": "MultiStark::read_digest_vec_at", + "name": "MultiStark::read_digest_vec_at", + "rows": 46 + }, + { + "chip": "MultiStark::read_digest_vec_at_n", + "name": "MultiStark::read_digest_vec_at_n", + "rows": 8497 + }, + { + "chip": "MultiStark::read_active_n", + "name": "MultiStark::read_u8_vec_n", + "rows": 402 + }, + { + "chip": "MultiStark::read_u64_vec_vec_n", + "name": "MultiStark::read_u64_vec_vec_n", + "rows": 38850 + }, + { + "chip": "MultiStark::read_u64_vec", + "name": "MultiStark::read_u64_vec", + "rows": 38624 + }, + { + "chip": "MultiStark::read_u64_vec_n", + "name": "MultiStark::read_u64_vec_n", + "rows": 816855 + }, + { + "chip": "MultiStark::read_message_vec_n", + "name": "MultiStark::read_message_vec_n", + "rows": 31 + }, + { + "chip": "MultiStark::read_proof_vec_n", + "name": "MultiStark::read_proof_vec_n", + "rows": 2 + }, + { + "chip": "MultiStark::read_proof", + "name": "MultiStark::read_proof", + "rows": 1 + }, + { + "chip": "MultiStark::read_ext_vec", + "name": "MultiStark::read_ext_vec", + "rows": 2224 + }, + { + "chip": "MultiStark::read_ext_vec_n", + "name": "MultiStark::read_ext_vec_n", + "rows": 27253 + }, + { + "chip": "MultiStark::read_merkle_cap_vec_n", + "name": "MultiStark::read_merkle_cap_vec_n", + "rows": 20 + }, + { + "chip": "MultiStark::read_batch_opening_vec_n", + "name": "MultiStark::read_batch_opening_vec_n", + "rows": 5 + }, + { + "chip": "MultiStark::read_u64_vec_vec_vec_n", + "name": "MultiStark::read_u64_vec_vec_vec_n", + "rows": 260 + }, + { + "chip": "MultiStark::read_commit_phase_step_vec_n", + "name": "MultiStark::read_commit_phase_step_vec_n", + "rows": 20 + }, + { + "chip": "MultiStark::read_ext_vec_vec", + "name": "MultiStark::read_ext_vec_vec", + "rows": 622 + }, + { + "chip": "MultiStark::read_ext_vec_vec_n", + "name": "MultiStark::read_ext_vec_vec_n", + "rows": 2844 + }, + { + "chip": "MultiStark::read_opened_round", + "name": "MultiStark::read_opened_round", + "rows": 4 + }, + { + "chip": "MultiStark::read_opened_round_n", + "name": "MultiStark::read_opened_round_n", + "rows": 607 + }, + { + "chip": "MultiStark::read_preprocessed", + "name": "MultiStark::read_preprocessed", + "rows": 1 + }, + { + "chip": "MultiStark::verify_batch", + "name": "MultiStark::verify_batch", + "rows": 1 + }, + { + "chip": "MultiStark::assert_shard_count_ok", + "name": "MultiStark::assert_shard_count_ok", + "rows": 1 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::ShardHeader\"}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::ShardHeader\"}}]}", + "rows": 2 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Proof\"}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Proof\"}}]}", + "rows": 2 + }, + { + "chip": "MultiStark::assert_closure_pairs", + "name": "MultiStark::assert_closure_pairs", + "rows": 16 + }, + { + "chip": "MultiStark::three_limbs", + "name": "MultiStark::three_limbs", + "rows": 30 + }, + { + "chip": "MultiStark::bytes8_le", + "name": "MultiStark::bytes8_le", + "rows": 44 + }, + { + "chip": "MultiStark::le_step", + "name": "MultiStark::le_step", + "rows": 57 + }, + { + "chip": "MultiStark::batch_fiat_shamir", + "name": "MultiStark::batch_fiat_shamir", + "rows": 1 + }, + { + "chip": "MultiStark::messages_onto", + "name": "MultiStark::messages_onto", + "rows": 1 + }, + { + "chip": "MultiStark::count_onto", + "name": "MultiStark::count_onto", + "rows": 35 + }, + { + "chip": "MultiStark::b8_onto", + "name": "MultiStark::b8_onto", + "rows": 49976 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMessage\"}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMessage\"}}]}", + "rows": 31 + }, + { + "chip": "MultiStark::messages_onto_each", + "name": "MultiStark::messages_onto_each", + "rows": 31 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}", + "rows": 694986 + }, + { + "chip": "MultiStark::limbs_onto", + "name": "MultiStark::limbs_onto", + "rows": 1785 + }, + { + "chip": "MultiStark::headers_onto", + "name": "MultiStark::headers_onto", + "rows": 2 + }, + { + "chip": "MultiStark::header_onto", + "name": "MultiStark::header_onto", + "rows": 1 + }, + { + "chip": "MultiStark::active_onto", + "name": "MultiStark::active_onto", + "rows": 236 + }, + { + "chip": "MultiStark::cap_onto", + "name": "MultiStark::cap_onto", + "rows": 26 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "rows": 436 + }, + { + "chip": "MultiStark::log_degrees_onto", + "name": "MultiStark::log_degrees_onto", + "rows": 201 + }, + { + "chip": "MultiStark::claims_onto", + "name": "MultiStark::claims_onto", + "rows": 1 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 38476 + }, + { + "chip": "MultiStark::claims_onto_each", + "name": "MultiStark::claims_onto_each", + "rows": 2 + }, + { + "chip": "MultiStark::ch_sample_ext", + "name": "MultiStark::ch_sample_ext", + "rows": 24 + }, + { + "chip": "MultiStark::ch_sample_field", + "name": "MultiStark::ch_sample_field", + "rows": 48 + }, + { + "chip": "MultiStark::ch_sample8", + "name": "MultiStark::ch_sample8", + "rows": 112 + }, + { + "chip": "MultiStark::b3_w4_onto", + "name": "MultiStark::b3_w4_onto", + "rows": 320 + }, + { + "chip": "MultiStark::rev_onto", + "name": "MultiStark::rev_onto", + "rows": 1320 + }, + { + "chip": "${\"name\":\"MultiStark::list_concat\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_concat\",\"types\":[\"field\"]}", + "rows": 2044 + }, + { + "chip": "MultiStark::messages_acc", + "name": "MultiStark::messages_acc", + "rows": 31 + }, + { + "chip": "MultiStark::fingerprint_vals", + "name": "MultiStark::fingerprint_vals", + "rows": 87 + }, + { + "chip": "MultiStark::verify_shards", + "name": "MultiStark::verify_shards", + "rows": 2 + }, + { + "chip": "MultiStark::verify_shard", + "name": "MultiStark::verify_shard", + "rows": 1 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "rows": 24683 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":2}}],\"name\":\"Lists::Node\"}}}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 604 + }, + { + "chip": "MultiStark::assert_bits", + "name": "MultiStark::assert_bits", + "rows": 236 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMessage\"}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysCircuit\"}}]}", + "rows": 436 + }, + { + "chip": "MultiStark::select_active_circuits", + "name": "MultiStark::select_active_circuits", + "rows": 236 + }, + { + "chip": "MultiStark::select_active_prep", + "name": "MultiStark::select_active_prep", + "rows": 236 + }, + { + "chip": "MultiStark::assert_same_bits", + "name": "MultiStark::assert_same_bits", + "rows": 236 + }, + { + "chip": "MultiStark::assert_same_cap", + "name": "MultiStark::assert_same_cap", + "rows": 2 + }, + { + "chip": "UInt64::eq", + "name": "UInt64::eq", + "rows": 19259 + }, + { + "chip": "MultiStark::assert_same_bits", + "name": "MultiStark::assert_same_u8s", + "rows": 201 + }, + { + "chip": "MultiStark::assert_log_degrees_ok", + "name": "MultiStark::assert_log_degrees_ok", + "rows": 201 + }, + { + "chip": "MultiStark::log_degree_ok", + "name": "MultiStark::log_degree_ok", + "rows": 19 + }, + { + "chip": "MultiStark::count_ones", + "name": "MultiStark::count_ones", + "rows": 236 + }, + { + "chip": "MultiStark::shard_fiat_shamir", + "name": "MultiStark::shard_fiat_shamir", + "rows": 1 + }, + { + "chip": "MultiStark::snoc_b8", + "name": "MultiStark::snoc_b8", + "rows": 20 + }, + { + "chip": "MultiStark::snoc_cap", + "name": "MultiStark::snoc_cap", + "rows": 21 + }, + { + "chip": "MultiStark::accs_onto", + "name": "MultiStark::accs_onto", + "rows": 201 + }, + { + "chip": "MultiStark::claims_acc", + "name": "MultiStark::claims_acc", + "rows": 2 + }, + { + "chip": "MultiStark::ood_loop", + "name": "MultiStark::ood_loop", + "rows": 201 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}", + "rows": 200 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}", + "rows": 3288 + }, + { + "chip": "MultiStark::quotient_degree_of", + "name": "MultiStark::quotient_degree_of", + "rows": 2 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "rows": 13040 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "rows": 13058 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":2}}],\"name\":\"Lists::Node\"}}}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 603 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":2}}],\"name\":\"Lists::Node\"}}}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 603 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":2}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 2219 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":2}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 2219 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::OptIdx\"}}]}", + "rows": 200 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::OptIdx\"}}]}", + "rows": 200 + }, + { + "chip": "MultiStark::ext_exp_pow2", + "name": "MultiStark::ext_exp_pow2", + "rows": 227 + }, + { + "chip": "MultiStark::two_adic_gen", + "name": "MultiStark::two_adic_gen", + "rows": 33 + }, + { + "chip": "MultiStark::pow2", + "name": "MultiStark::pow2", + "rows": 20 + }, + { + "chip": "MultiStark::fold_roots", + "name": "MultiStark::fold_roots", + "rows": 16292 + }, + { + "chip": "MultiStark::eval_at", + "name": "MultiStark::eval_at", + "rows": 90140 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}", + "rows": 90140 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}", + "rows": 90140 + }, + { + "chip": "MultiStark::ood_fold", + "name": "MultiStark::ood_fold", + "rows": 18454 + }, + { + "chip": "MultiStark::logup_steps_fold", + "name": "MultiStark::logup_steps_fold", + "rows": 2024 + }, + { + "chip": "MultiStark::logup_fingerprint", + "name": "MultiStark::logup_fingerprint", + "rows": 19141 + }, + { + "chip": "MultiStark::pair_mul", + "name": "MultiStark::pair_mul", + "rows": 20036 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysLookup\"}}]}", + "rows": 1968 + }, + { + "chip": "MultiStark::reconstruct_ext_row", + "name": "MultiStark::reconstruct_ext_row", + "rows": 344 + }, + { + "chip": "MultiStark::from_ext_basis", + "name": "MultiStark::from_ext_basis", + "rows": 342 + }, + { + "chip": "MultiStark::quotient_eval", + "name": "MultiStark::quotient_eval", + "rows": 383 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"array\":{\"element\":{\"array\":{\"element\":\"field\",\"length\":8}},\"length\":4}}}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 20 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMultiOpening\"}}]}", + "rows": 5 + }, + { + "chip": "MultiStark::prep_count", + "name": "MultiStark::prep_count", + "rows": 1 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::CommitPhaseMultiStep\"}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::CommitPhaseMultiStep\"}}]}", + "rows": 20 + }, + { + "chip": "MultiStark::round_onto", + "name": "MultiStark::round_onto", + "rows": 607 + }, + { + "chip": "MultiStark::points_onto", + "name": "MultiStark::points_onto", + "rows": 1609 + }, + { + "chip": "MultiStark::accs_onto", + "name": "MultiStark::ext_row_onto", + "rows": 24619 + }, + { + "chip": "MultiStark::pcs_betas", + "name": "MultiStark::pcs_betas", + "rows": 20 + }, + { + "chip": "MultiStark::pcs_check_witness", + "name": "MultiStark::pcs_check_witness", + "rows": 20 + }, + { + "chip": "MultiStark::ch_sample_bits", + "name": "MultiStark::ch_sample_bits", + "rows": 64 + }, + { + "chip": "MultiStark::b8_onto", + "name": "MultiStark::cons8", + "rows": 250 + }, + { + "chip": "MultiStark::take_bits", + "name": "MultiStark::take_bits", + "rows": 1344 + }, + { + "chip": "MultiStark::bits_to_num", + "name": "MultiStark::bits_to_num", + "rows": 971 + }, + { + "chip": "MultiStark::obs_log_arities", + "name": "MultiStark::obs_log_arities", + "rows": 20 + }, + { + "chip": "MultiStark::sample_query_indices", + "name": "MultiStark::sample_query_indices", + "rows": 65 + }, + { + "chip": "MultiStark::verify_input_multi", + "name": "MultiStark::verify_input_multi", + "rows": 1 + }, + { + "chip": "MultiStark::heights_all", + "name": "MultiStark::heights_all", + "rows": 201 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMultiOpening\"}}]}", + "rows": 4 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMultiOpening\"}}]}", + "rows": 4 + }, + { + "chip": "MultiStark::mmcs_verify_multi", + "name": "MultiStark::mmcs_verify_multi", + "rows": 23 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 1473 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[\"field\"],\"name\":\"Lists::Node\"}}}}]}", + "rows": 1281 + }, + { + "chip": "MultiStark::frontier_sort", + "name": "MultiStark::frontier_sort", + "rows": 2550 + }, + { + "chip": "MultiStark::frontier_split", + "name": "MultiStark::frontier_split", + "rows": 4251 + }, + { + "chip": "MultiStark::frontier_merge", + "name": "MultiStark::frontier_merge", + "rows": 6992 + }, + { + "chip": "MultiStark::digest_eq", + "name": "MultiStark::digest_eq", + "rows": 108 + }, + { + "chip": "MultiStark::assert_same_claims", + "name": "MultiStark::assert_same_claims", + "rows": 4185 + }, + { + "chip": "MultiStark::assert_same_limbs", + "name": "MultiStark::assert_same_limbs", + "rows": 32125 + }, + { + "chip": "MultiStark::frontier_leaves", + "name": "MultiStark::frontier_leaves", + "rows": 1493 + }, + { + "chip": "MultiStark::leaf_hash_at", + "name": "MultiStark::leaf_hash_at", + "rows": 3813 + }, + { + "chip": "MultiStark::b3_rows_chunks", + "name": "MultiStark::b3_rows_chunks", + "rows": 89051 + }, + { + "chip": "MultiStark::rows_pop", + "name": "MultiStark::rows_pop", + "rows": 734238 + }, + { + "chip": "MultiStark::select_rows", + "name": "MultiStark::select_rows", + "rows": 543739 + }, + { + "chip": "MultiStark::frontier_fold", + "name": "MultiStark::frontier_fold", + "rows": 290 + }, + { + "chip": "MultiStark::frontier_level", + "name": "MultiStark::frontier_level", + "rows": 9662 + }, + { + "chip": "MultiStark::select_rows_le", + "name": "MultiStark::select_rows_le", + "rows": 77642 + }, + { + "chip": "MultiStark::inject_maybe", + "name": "MultiStark::inject_maybe", + "rows": 9567 + }, + { + "chip": "MultiStark::has_height", + "name": "MultiStark::has_height", + "rows": 1320 + }, + { + "chip": "MultiStark::mmcs_compress", + "name": "MultiStark::mmcs_compress", + "rows": 12218 + }, + { + "chip": "MultiStark::compress_ordered", + "name": "MultiStark::compress_ordered", + "rows": 8428 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":{\"array\":{\"element\":\"field\",\"length\":8}},\"length\":4}}}}]}", + "rows": 1 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::ShardHeader\"}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::FrontierNode\"}}]}", + "rows": 1 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":{\"array\":{\"element\":\"field\",\"length\":8}},\"length\":4}}}}]}", + "rows": 23 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"array\":{\"element\":{\"array\":{\"element\":\"field\",\"length\":8}},\"length\":4}}}}]}", + "rows": 23 + }, + { + "chip": "MultiStark::heights_prep", + "name": "MultiStark::heights_prep", + "rows": 201 + }, + { + "chip": "MultiStark::heights_max", + "name": "MultiStark::heights_max", + "rows": 4 + }, + { + "chip": "MultiStark::drop_index_bits", + "name": "MultiStark::drop_index_bits", + "rows": 1282 + }, + { + "chip": "MultiStark::query_views", + "name": "MultiStark::query_views", + "rows": 65 + }, + { + "chip": "MultiStark::batch_views_at", + "name": "MultiStark::batch_views_at", + "rows": 320 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 256 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 256 + }, + { + "chip": "MultiStark::step_views_at", + "name": "MultiStark::step_views_at", + "rows": 1280 + }, + { + "chip": "MultiStark::query_loop", + "name": "MultiStark::query_loop", + "rows": 65 + }, + { + "chip": "MultiStark::verify_one_query", + "name": "MultiStark::verify_one_query", + "rows": 64 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::CommitPhaseProofStep\"}}]}", + "rows": 969 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchOpening\"}}]}", + "rows": 257 + }, + { + "chip": "MultiStark::build_buckets", + "name": "MultiStark::build_buckets", + "rows": 21 + }, + { + "chip": "MultiStark::circ_has_height", + "name": "MultiStark::circ_has_height", + "rows": 1060 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchOpening\"}}]}", + "rows": 256 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchOpening\"}}]}", + "rows": 256 + }, + { + "chip": "MultiStark::open_batch_2pt", + "name": "MultiStark::open_batch_2pt", + "rows": 25728 + }, + { + "chip": "MultiStark::open_2pt_mat", + "name": "MultiStark::open_2pt_mat", + "rows": 25792 + }, + { + "chip": "MultiStark::ri_apply", + "name": "MultiStark::ri_apply", + "rows": 64384 + }, + { + "chip": "MultiStark::exp_by_bits", + "name": "MultiStark::exp_by_bits", + "rows": 8240 + }, + { + "chip": "MultiStark::rev_onto", + "name": "MultiStark::glist_rev", + "rows": 13352 + }, + { + "chip": "MultiStark::bucket_update", + "name": "MultiStark::bucket_update", + "rows": 559785 + }, + { + "chip": "MultiStark::ro_fold", + "name": "MultiStark::ro_fold", + "rows": 1409233 + }, + { + "chip": "${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 39808 + }, + { + "chip": "${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 39808 + }, + { + "chip": "MultiStark::open_quotient", + "name": "MultiStark::open_quotient", + "rows": 12864 + }, + { + "chip": "MultiStark::open_prep_batch", + "name": "MultiStark::open_prep_batch", + "rows": 64 + }, + { + "chip": "MultiStark::open_prep", + "name": "MultiStark::open_prep", + "rows": 12864 + }, + { + "chip": "MultiStark::assert_blowup_zero", + "name": "MultiStark::assert_blowup_zero", + "rows": 902 + }, + { + "chip": "MultiStark::verify_query", + "name": "MultiStark::verify_query", + "rows": 970 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Bucket\"}}]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Bucket\"}}]}", + "rows": 1 + }, + { + "chip": "MultiStark::fri_fold2", + "name": "MultiStark::fri_fold2", + "rows": 906 + }, + { + "chip": "MultiStark::rollin", + "name": "MultiStark::rollin", + "rows": 905 + }, + { + "chip": "MultiStark::verify_commit_multi", + "name": "MultiStark::verify_commit_multi", + "rows": 20 + }, + { + "chip": "${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":2}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 1217 + }, + { + "chip": "MultiStark::rows_at_round", + "name": "MultiStark::rows_at_round", + "rows": 1235 + }, + { + "chip": "MultiStark::last_acc", + "name": "MultiStark::last_acc", + "rows": 200 + }, + { + "chip": "MultiStark::batch_claims", + "name": "MultiStark::batch_claims", + "rows": 2 + }, + { + "chip": "${\"name\":\"MultiStark::list_concat\",\"types\":[\"field\"]}", + "name": "${\"name\":\"MultiStark::list_concat\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[{\"array\":{\"element\":\"field\",\"length\":8}}],\"name\":\"Lists::Node\"}}}}]}", + "rows": 2 + } + ], + "prepare_seconds": 0.10453488, + "proof": null, + "samples": [], + "setup_seconds": 0.037982039, + "thp_disabled": true +} \ No newline at end of file diff --git a/docs/benchmarks/formal-aiur-grouping-tuning/recursion-ungrouped-shapes.json b/docs/benchmarks/formal-aiur-grouping-tuning/recursion-ungrouped-shapes.json new file mode 100644 index 000000000..777fd2d52 --- /dev/null +++ b/docs/benchmarks/formal-aiur-grouping-tuning/recursion-ungrouped-shapes.json @@ -0,0 +1 @@ +{"circuits":[{"cells":219,"fft_cost":951.0,"height":1,"index":0,"lookup_group_size":1,"lookups":48,"name":"MultiStark::verify_multi_stark_proof","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":219,"stage2_width":96},{"cells":2816,"fft_cost":144384.0,"height":256,"index":1,"lookup_group_size":1,"lookups":4,"name":"MultiStark::read_byte_stream","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":8},{"cells":2240,"fft_cost":30144.0,"height":16,"index":2,"lookup_group_size":1,"lookups":6,"name":"Blake3::compress_layer","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":140,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":3,"lookup_group_size":1,"lookups":10,"name":"Blake3::next_layer","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":177,"stage2_width":20},{"cells":128256,"fft_cost":4494336.0,"height":256,"index":4,"lookup_group_size":2,"lookups":226,"name":"Blake3::compress","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":501,"stage2_width":226},{"cells":17408,"fft_cost":841728.0,"height":1024,"index":5,"lookup_group_size":2,"lookups":6,"name":"Blake3::compress_chunks","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":6},{"cells":2656,"fft_cost":38208.0,"height":16,"index":6,"lookup_group_size":1,"lookups":14,"name":"Blake3::finish","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":166,"stage2_width":28},{"cells":19,"fft_cost":75.0,"height":1,"index":7,"lookup_group_size":1,"lookups":1,"name":"UInt64::is_zero","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":2},{"cells":4192,"fft_cost":126368.0,"height":32,"index":8,"lookup_group_size":1,"lookups":65,"name":"Blake3::bytes_to_block","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":131,"stage2_width":130},{"cells":2048,"fft_cost":101376.0,"height":256,"index":9,"lookup_group_size":2,"lookups":3,"name":"Blake3::pad_block","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":4},{"cells":2880,"fft_cost":44736.0,"height":16,"index":10,"lookup_group_size":1,"lookups":24,"name":"Blake3::compress_block","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":180,"stage2_width":48},{"cells":56,"fft_cost":968.0,"height":8,"index":11,"lookup_group_size":1,"lookups":2,"name":"${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":12,"lookup_group_size":1,"lookups":2,"name":"UInt64::wrapping_succ","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":4},{"cells":112,"fft_cost":2944.0,"height":16,"index":13,"lookup_group_size":1,"lookups":3,"name":"MultiStark::read_vk_u16_limb","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":6},{"cells":640,"fft_cost":30080.0,"height":128,"index":14,"lookup_group_size":1,"lookups":2,"name":"MultiStark::read_vk_u8","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":5,"stage2_width":4},{"cells":228,"fft_cost":1140.0,"height":2,"index":15,"lookup_group_size":1,"lookups":34,"name":"MultiStark::read_sys_circuits_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":114,"stage2_width":68},{"cells":11,"fft_cost":69.0,"height":1,"index":16,"lookup_group_size":1,"lookups":5,"name":"MultiStark::read_vk_u32_limb","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":10},{"cells":40,"fft_cost":824.0,"height":8,"index":17,"lookup_group_size":1,"lookups":2,"name":"MultiStark::read_vk_tag","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":5,"stage2_width":4},{"cells":224,"fft_cost":7328.0,"height":32,"index":18,"lookup_group_size":1,"lookups":3,"name":"MultiStark::read_vk_u16","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":6},{"cells":352,"fft_cost":6144.0,"height":8,"index":19,"lookup_group_size":1,"lookups":18,"name":"MultiStark::read_nodes_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":44,"stage2_width":36},{"cells":12,"fft_cost":54.0,"height":1,"index":20,"lookup_group_size":1,"lookups":2,"name":"MultiStark::read_field","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":12,"stage2_width":4},{"cells":19,"fft_cost":117.0,"height":1,"index":21,"lookup_group_size":1,"lookups":9,"name":"MultiStark::read_vk_u64","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":19,"stage2_width":18},{"cells":112,"fft_cost":2192.0,"height":8,"index":22,"lookup_group_size":1,"lookups":7,"name":"UInt32::less_than_fields","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":14,"stage2_width":14},{"cells":88,"fft_cost":1752.0,"height":8,"index":23,"lookup_group_size":1,"lookups":4,"name":"MultiStark::read_node_ids_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":8},{"cells":30,"fft_cost":210.0,"height":2,"index":24,"lookup_group_size":1,"lookups":6,"name":"MultiStark::read_sys_lookups_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":12},{"cells":20,"fft_cost":132.0,"height":2,"index":25,"lookup_group_size":2,"lookups":3,"name":"MultiStark::lookup_groups_count","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":4},{"cells":11,"fft_cost":69.0,"height":1,"index":26,"lookup_group_size":1,"lookups":4,"name":"MultiStark::read_opt_commit","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":27,"lookup_group_size":1,"lookups":8,"name":"MultiStark::read_vk_cap_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":46,"stage2_width":16},{"cells":26,"fft_cost":174.0,"height":2,"index":28,"lookup_group_size":1,"lookups":4,"name":"MultiStark::read_opt_idx_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":8},{"cells":136,"fft_cost":1976.0,"height":8,"index":29,"lookup_group_size":1,"lookups":4,"name":"${\"name\":\"MultiStark::list_concat\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":17,"stage2_width":8},{"cells":26,"fft_cost":134.0,"height":2,"index":30,"lookup_group_size":1,"lookups":3,"name":"MultiStark::read_count","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":13,"stage2_width":6},{"cells":152,"fft_cost":2840.0,"height":8,"index":31,"lookup_group_size":1,"lookups":9,"name":"MultiStark::read_u64","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":19,"stage2_width":18},{"cells":512,"fft_cost":21504.0,"height":64,"index":32,"lookup_group_size":1,"lookups":3,"name":"MultiStark::read_u8","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":6},{"cells":80,"fft_cost":1040.0,"height":8,"index":33,"lookup_group_size":1,"lookups":1,"name":"UInt64::to_field","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":2},{"cells":26,"fft_cost":186.0,"height":2,"index":34,"lookup_group_size":1,"lookups":5,"name":"MultiStark::read_claims_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":10},{"cells":144,"fft_cost":2256.0,"height":8,"index":35,"lookup_group_size":1,"lookups":4,"name":"MultiStark::read_claim_vals_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":8},{"cells":3328,"fft_cost":130048.0,"height":256,"index":36,"lookup_group_size":1,"lookups":3,"name":"MultiStark::read_count_at","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":13,"stage2_width":6},{"cells":9728,"fft_cost":541184.0,"height":512,"index":37,"lookup_group_size":1,"lookups":9,"name":"MultiStark::read_u64_at","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":19,"stage2_width":18},{"cells":46,"fft_cost":306.0,"height":2,"index":38,"lookup_group_size":1,"lookups":10,"name":"MultiStark::read_header_vec_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":20},{"cells":88,"fft_cost":1752.0,"height":8,"index":39,"lookup_group_size":1,"lookups":4,"name":"MultiStark::read_active_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":8},{"cells":40,"fft_cost":824.0,"height":8,"index":40,"lookup_group_size":1,"lookups":2,"name":"MultiStark::read_u8_at","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":5,"stage2_width":4},{"cells":56,"fft_cost":1112.0,"height":8,"index":41,"lookup_group_size":1,"lookups":3,"name":"MultiStark::read_digest_vec_at","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":6},{"cells":736,"fft_cost":12864.0,"height":16,"index":42,"lookup_group_size":1,"lookups":8,"name":"MultiStark::read_digest_vec_at_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":46,"stage2_width":16},{"cells":1408,"fft_cost":63360.0,"height":128,"index":43,"lookup_group_size":1,"lookups":4,"name":"MultiStark::read_u64_vec_vec_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":8},{"cells":448,"fft_cost":17536.0,"height":64,"index":44,"lookup_group_size":1,"lookups":3,"name":"MultiStark::read_u64_vec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":6},{"cells":4608,"fft_cost":187392.0,"height":256,"index":45,"lookup_group_size":1,"lookups":4,"name":"MultiStark::read_u64_vec_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":8},{"cells":20,"fft_cost":102.0,"height":1,"index":46,"lookup_group_size":1,"lookups":5,"name":"MultiStark::read_message_vec_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":10},{"cells":68,"fft_cost":300.0,"height":2,"index":47,"lookup_group_size":1,"lookups":4,"name":"MultiStark::read_proof_vec_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":34,"stage2_width":8},{"cells":53,"fft_cost":297.0,"height":1,"index":48,"lookup_group_size":1,"lookups":22,"name":"MultiStark::read_proof","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":53,"stage2_width":44},{"cells":56,"fft_cost":1112.0,"height":8,"index":49,"lookup_group_size":1,"lookups":3,"name":"MultiStark::read_ext_vec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":6},{"cells":864,"fft_cost":20064.0,"height":32,"index":50,"lookup_group_size":1,"lookups":5,"name":"MultiStark::read_ext_vec_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":10},{"cells":11,"fft_cost":69.0,"height":1,"index":51,"lookup_group_size":1,"lookups":4,"name":"MultiStark::read_merkle_cap_vec_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":8},{"cells":60,"fft_cost":792.0,"height":4,"index":52,"lookup_group_size":1,"lookups":6,"name":"MultiStark::read_batch_opening_vec_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":12},{"cells":832,"fft_cost":31872.0,"height":64,"index":53,"lookup_group_size":1,"lookups":5,"name":"MultiStark::read_u64_vec_vec_vec_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":10},{"cells":15,"fft_cost":93.0,"height":1,"index":54,"lookup_group_size":1,"lookups":6,"name":"MultiStark::read_commit_phase_step_vec_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":12},{"cells":28,"fft_cost":376.0,"height":4,"index":55,"lookup_group_size":1,"lookups":3,"name":"MultiStark::read_ext_vec_vec","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":6},{"cells":88,"fft_cost":1752.0,"height":8,"index":56,"lookup_group_size":1,"lookups":4,"name":"MultiStark::read_ext_vec_vec_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":8},{"cells":28,"fft_cost":376.0,"height":4,"index":57,"lookup_group_size":1,"lookups":3,"name":"MultiStark::read_opened_round","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":6},{"cells":88,"fft_cost":1752.0,"height":8,"index":58,"lookup_group_size":1,"lookups":4,"name":"MultiStark::read_opened_round_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":8},{"cells":9,"fft_cost":57.0,"height":1,"index":59,"lookup_group_size":1,"lookups":3,"name":"MultiStark::read_preprocessed","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":6},{"cells":40,"fft_cost":168.0,"height":1,"index":60,"lookup_group_size":2,"lookups":11,"name":"MultiStark::verify_batch","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":40,"stage2_width":12},{"cells":16,"fft_cost":78.0,"height":1,"index":61,"lookup_group_size":2,"lookups":5,"name":"MultiStark::assert_shard_count_ok","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":6},{"cells":44,"fft_cost":552.0,"height":4,"index":62,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::ShardHeader\"}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":6},{"cells":62,"fft_cost":270.0,"height":2,"index":63,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Proof\"}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":31,"stage2_width":6},{"cells":159,"fft_cost":591.0,"height":1,"index":64,"lookup_group_size":2,"lookups":33,"name":"MultiStark::assert_closure_pairs","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":159,"stage2_width":34},{"cells":0,"fft_cost":0.0,"height":0,"index":65,"lookup_group_size":1,"lookups":5,"name":"MultiStark::three_limbs","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":39,"stage2_width":10},{"cells":0,"fft_cost":0.0,"height":0,"index":66,"lookup_group_size":1,"lookups":9,"name":"MultiStark::bytes8_le","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":26,"stage2_width":18},{"cells":0,"fft_cost":0.0,"height":0,"index":67,"lookup_group_size":2,"lookups":2,"name":"MultiStark::le_step","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":2},{"cells":73,"fft_cost":429.0,"height":1,"index":68,"lookup_group_size":1,"lookups":34,"name":"MultiStark::batch_fiat_shamir","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":73,"stage2_width":68},{"cells":7,"fft_cost":51.0,"height":1,"index":69,"lookup_group_size":1,"lookups":4,"name":"MultiStark::messages_onto","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":8},{"cells":144,"fft_cost":2112.0,"height":8,"index":70,"lookup_group_size":2,"lookups":6,"name":"MultiStark::count_onto","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":6},{"cells":2432,"fft_cost":105344.0,"height":128,"index":71,"lookup_group_size":1,"lookups":9,"name":"MultiStark::b8_onto","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":19,"stage2_width":18},{"cells":64,"fft_cost":672.0,"height":4,"index":72,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::BatchMessage\"}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":6},{"cells":21,"fft_cost":111.0,"height":1,"index":73,"lookup_group_size":1,"lookups":7,"name":"MultiStark::messages_onto_each","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":21,"stage2_width":14},{"cells":120,"fft_cost":1896.0,"height":8,"index":74,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":8}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":6},{"cells":544,"fft_cost":13088.0,"height":32,"index":75,"lookup_group_size":1,"lookups":4,"name":"MultiStark::limbs_onto","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":17,"stage2_width":8},{"cells":26,"fft_cost":146.0,"height":2,"index":76,"lookup_group_size":1,"lookups":4,"name":"MultiStark::headers_onto","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":13,"stage2_width":8},{"cells":13,"fft_cost":87.0,"height":1,"index":77,"lookup_group_size":1,"lookups":7,"name":"MultiStark::header_onto","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":13,"stage2_width":14},{"cells":22,"fft_cost":146.0,"height":2,"index":78,"lookup_group_size":1,"lookups":5,"name":"MultiStark::active_onto","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":10},{"cells":360,"fft_cost":4568.0,"height":8,"index":79,"lookup_group_size":1,"lookups":8,"name":"MultiStark::cap_onto","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":45,"stage2_width":16},{"cells":1024,"fft_cost":49920.0,"height":128,"index":80,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"MultiStark::list_length\",\"types\":[\"field\"]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":6},{"cells":20,"fft_cost":128.0,"height":2,"index":81,"lookup_group_size":1,"lookups":4,"name":"MultiStark::log_degrees_onto","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":8},{"cells":7,"fft_cost":51.0,"height":1,"index":82,"lookup_group_size":1,"lookups":4,"name":"MultiStark::claims_onto","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":8},{"cells":24,"fft_cost":164.0,"height":2,"index":83,"lookup_group_size":1,"lookups":6,"name":"MultiStark::claims_onto_each","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":12,"stage2_width":12},{"cells":192,"fft_cost":2336.0,"height":8,"index":84,"lookup_group_size":1,"lookups":3,"name":"MultiStark::ch_sample_ext","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":24,"stage2_width":6},{"cells":528,"fft_cost":8064.0,"height":16,"index":85,"lookup_group_size":2,"lookups":3,"name":"MultiStark::ch_sample_field","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":33,"stage2_width":4},{"cells":2304,"fft_cost":62784.0,"height":32,"index":86,"lookup_group_size":1,"lookups":27,"name":"MultiStark::ch_sample8","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":72,"stage2_width":54},{"cells":1408,"fft_cost":62336.0,"height":128,"index":87,"lookup_group_size":1,"lookups":5,"name":"MultiStark::b3_w4_onto","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":10},{"cells":5120,"fft_cost":278528.0,"height":512,"index":88,"lookup_group_size":1,"lookups":4,"name":"MultiStark::rev_onto","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":8},{"cells":5120,"fft_cost":278528.0,"height":512,"index":89,"lookup_group_size":1,"lookups":4,"name":"${\"name\":\"MultiStark::list_concat\",\"types\":[\"field\"]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":8},{"cells":32,"fft_cost":120.0,"height":1,"index":90,"lookup_group_size":2,"lookups":4,"name":"MultiStark::messages_acc","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":32,"stage2_width":4},{"cells":160,"fft_cost":2112.0,"height":8,"index":91,"lookup_group_size":2,"lookups":3,"name":"MultiStark::fingerprint_vals","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":4},{"cells":120,"fft_cost":444.0,"height":2,"index":92,"lookup_group_size":2,"lookups":5,"name":"MultiStark::verify_shards","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":60,"stage2_width":6},{"cells":125,"fft_cost":681.0,"height":1,"index":93,"lookup_group_size":1,"lookups":50,"name":"MultiStark::verify_shard","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":125,"stage2_width":100},{"cells":144,"fft_cost":3840.0,"height":16,"index":94,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"MultiStark::list_length\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":6},{"cells":16,"fft_cost":120.0,"height":2,"index":95,"lookup_group_size":2,"lookups":3,"name":"MultiStark::assert_bits","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":4},{"cells":44,"fft_cost":252.0,"height":2,"index":96,"lookup_group_size":1,"lookups":6,"name":"MultiStark::select_active_circuits","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":22,"stage2_width":12},{"cells":30,"fft_cost":210.0,"height":2,"index":97,"lookup_group_size":1,"lookups":6,"name":"MultiStark::select_active_prep","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":12},{"cells":44,"fft_cost":600.0,"height":4,"index":98,"lookup_group_size":1,"lookups":4,"name":"MultiStark::assert_same_bits","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":8},{"cells":158,"fft_cost":642.0,"height":2,"index":99,"lookup_group_size":1,"lookups":10,"name":"MultiStark::assert_same_cap","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":79,"stage2_width":20},{"cells":864,"fft_cost":16224.0,"height":32,"index":100,"lookup_group_size":1,"lookups":1,"name":"UInt64::eq","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":2},{"cells":18,"fft_cost":122.0,"height":2,"index":101,"lookup_group_size":1,"lookups":4,"name":"MultiStark::assert_log_degrees_ok","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":9,"stage2_width":8},{"cells":69,"fft_cost":225.0,"height":1,"index":102,"lookup_group_size":1,"lookups":1,"name":"MultiStark::log_degree_ok","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":69,"stage2_width":2},{"cells":16,"fft_cost":132.0,"height":2,"index":103,"lookup_group_size":1,"lookups":3,"name":"MultiStark::count_ones","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":6},{"cells":64,"fft_cost":252.0,"height":1,"index":104,"lookup_group_size":2,"lookups":15,"name":"MultiStark::shard_fiat_shamir","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":64,"stage2_width":16},{"cells":14,"fft_cost":72.0,"height":1,"index":105,"lookup_group_size":1,"lookups":4,"name":"MultiStark::snoc_b8","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":14,"stage2_width":8},{"cells":14,"fft_cost":110.0,"height":2,"index":106,"lookup_group_size":1,"lookups":4,"name":"MultiStark::snoc_cap","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":8},{"cells":1216,"fft_cost":27264.0,"height":32,"index":107,"lookup_group_size":2,"lookups":13,"name":"MultiStark::accs_onto","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":38,"stage2_width":14},{"cells":44,"fft_cost":204.0,"height":2,"index":108,"lookup_group_size":2,"lookups":4,"name":"MultiStark::claims_acc","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":22,"stage2_width":4},{"cells":306,"fft_cost":1614.0,"height":2,"index":109,"lookup_group_size":1,"lookups":54,"name":"MultiStark::ood_loop","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":153,"stage2_width":108},{"cells":448,"fft_cost":17536.0,"height":64,"index":110,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"MultiStark::list_lookup\",\"types\":[\"field\"]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":6},{"cells":576,"fft_cost":22656.0,"height":64,"index":111,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"MultiStark::list_drop\",\"types\":[\"field\"]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":6},{"cells":39,"fft_cost":135.0,"height":1,"index":112,"lookup_group_size":1,"lookups":1,"name":"MultiStark::quotient_degree_of","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":39,"stage2_width":2},{"cells":128,"fft_cost":3136.0,"height":16,"index":113,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":8,"stage2_width":6},{"cells":160,"fft_cost":4032.0,"height":16,"index":114,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"MultiStark::list_drop\",\"types\":[{\"array\":{\"element\":\"field\",\"length\":2}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":6},{"cells":13,"fft_cost":57.0,"height":1,"index":115,"lookup_group_size":2,"lookups":2,"name":"MultiStark::ext_exp_pow2","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":2},{"cells":576,"fft_cost":18048.0,"height":64,"index":116,"lookup_group_size":2,"lookups":2,"name":"MultiStark::two_adic_gen","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":2},{"cells":6,"fft_cost":42.0,"height":1,"index":117,"lookup_group_size":1,"lookups":2,"name":"MultiStark::pow2","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":6,"stage2_width":4},{"cells":62,"fft_cost":266.0,"height":2,"index":118,"lookup_group_size":1,"lookups":5,"name":"MultiStark::fold_roots","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":31,"stage2_width":10},{"cells":336,"fft_cost":4128.0,"height":8,"index":119,"lookup_group_size":1,"lookups":5,"name":"MultiStark::eval_at","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":42,"stage2_width":10},{"cells":80,"fft_cost":1328.0,"height":8,"index":120,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"MultiStark::list_lookup\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":6},{"cells":96,"fft_cost":1680.0,"height":8,"index":121,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"MultiStark::list_drop\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::SysNode\"}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":6},{"cells":10,"fft_cost":42.0,"height":1,"index":122,"lookup_group_size":1,"lookups":1,"name":"MultiStark::ood_fold","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":2},{"cells":94,"fft_cost":420.0,"height":1,"index":123,"lookup_group_size":1,"lookups":21,"name":"MultiStark::logup_steps_fold","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":94,"stage2_width":42},{"cells":280,"fft_cost":3624.0,"height":8,"index":124,"lookup_group_size":1,"lookups":5,"name":"MultiStark::logup_fingerprint","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":35,"stage2_width":10},{"cells":112,"fft_cost":1328.0,"height":8,"index":125,"lookup_group_size":1,"lookups":1,"name":"MultiStark::pair_mul","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":14,"stage2_width":2},{"cells":30,"fft_cost":210.0,"height":2,"index":126,"lookup_group_size":1,"lookups":6,"name":"MultiStark::reconstruct_ext_row","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":12},{"cells":6,"fft_cost":30.0,"height":1,"index":127,"lookup_group_size":1,"lookups":1,"name":"MultiStark::from_ext_basis","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":6,"stage2_width":2},{"cells":40,"fft_cost":192.0,"height":2,"index":128,"lookup_group_size":2,"lookups":3,"name":"MultiStark::quotient_eval","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":4},{"cells":5,"fft_cost":27.0,"height":1,"index":129,"lookup_group_size":1,"lookups":1,"name":"MultiStark::prep_count","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":5,"stage2_width":2},{"cells":10,"fft_cost":60.0,"height":1,"index":130,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::CommitPhaseMultiStep\"}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":6},{"cells":80,"fft_cost":1472.0,"height":8,"index":131,"lookup_group_size":1,"lookups":4,"name":"MultiStark::round_onto","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":8},{"cells":80,"fft_cost":1472.0,"height":8,"index":132,"lookup_group_size":1,"lookups":4,"name":"MultiStark::points_onto","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":8},{"cells":43,"fft_cost":189.0,"height":1,"index":133,"lookup_group_size":1,"lookups":8,"name":"MultiStark::pcs_betas","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":43,"stage2_width":16},{"cells":20,"fft_cost":102.0,"height":1,"index":134,"lookup_group_size":1,"lookups":5,"name":"MultiStark::pcs_check_witness","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":10},{"cells":848,"fft_cost":15232.0,"height":16,"index":135,"lookup_group_size":1,"lookups":12,"name":"MultiStark::ch_sample_bits","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":53,"stage2_width":24},{"cells":320,"fft_cost":10944.0,"height":32,"index":136,"lookup_group_size":1,"lookups":4,"name":"MultiStark::take_bits","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":8},{"cells":32,"fft_cost":480.0,"height":4,"index":137,"lookup_group_size":1,"lookups":3,"name":"MultiStark::bits_to_num","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":6},{"cells":10,"fft_cost":60.0,"height":1,"index":138,"lookup_group_size":1,"lookups":4,"name":"MultiStark::obs_log_arities","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":8},{"cells":416,"fft_cost":12384.0,"height":32,"index":139,"lookup_group_size":1,"lookups":4,"name":"MultiStark::sample_query_indices","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":8},{"cells":32,"fft_cost":180.0,"height":1,"index":140,"lookup_group_size":1,"lookups":13,"name":"MultiStark::verify_input_multi","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":32,"stage2_width":26},{"cells":22,"fft_cost":162.0,"height":2,"index":141,"lookup_group_size":1,"lookups":4,"name":"MultiStark::heights_all","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":8},{"cells":46,"fft_cost":290.0,"height":2,"index":142,"lookup_group_size":1,"lookups":11,"name":"MultiStark::mmcs_verify_multi","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":23,"stage2_width":22},{"cells":704,"fft_cost":18368.0,"height":32,"index":143,"lookup_group_size":1,"lookups":7,"name":"MultiStark::frontier_sort","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":22,"stage2_width":14},{"cells":1344,"fft_cost":45696.0,"height":64,"index":144,"lookup_group_size":1,"lookups":7,"name":"MultiStark::frontier_split","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":21,"stage2_width":14},{"cells":928,"fft_cost":25824.0,"height":32,"index":145,"lookup_group_size":1,"lookups":10,"name":"MultiStark::frontier_merge","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":29,"stage2_width":20},{"cells":296,"fft_cost":2112.0,"height":4,"index":146,"lookup_group_size":2,"lookups":7,"name":"MultiStark::digest_eq","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":74,"stage2_width":8},{"cells":48,"fft_cost":576.0,"height":4,"index":147,"lookup_group_size":2,"lookups":5,"name":"MultiStark::assert_same_claims","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":6},{"cells":208,"fft_cost":2688.0,"height":8,"index":148,"lookup_group_size":2,"lookups":5,"name":"MultiStark::assert_same_limbs","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":26,"stage2_width":6},{"cells":1024,"fft_cost":42240.0,"height":64,"index":149,"lookup_group_size":1,"lookups":8,"name":"MultiStark::frontier_leaves","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":16},{"cells":88,"fft_cost":392.0,"height":2,"index":150,"lookup_group_size":1,"lookups":9,"name":"MultiStark::leaf_hash_at","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":44,"stage2_width":18},{"cells":460,"fft_cost":1764.0,"height":2,"index":151,"lookup_group_size":1,"lookups":28,"name":"MultiStark::b3_rows_chunks","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":230,"stage2_width":56},{"cells":328,"fft_cost":3912.0,"height":8,"index":152,"lookup_group_size":2,"lookups":8,"name":"MultiStark::rows_pop","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":41,"stage2_width":8},{"cells":120,"fft_cost":1200.0,"height":4,"index":153,"lookup_group_size":1,"lookups":7,"name":"MultiStark::select_rows","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":30,"stage2_width":14},{"cells":48,"fft_cost":528.0,"height":4,"index":154,"lookup_group_size":2,"lookups":3,"name":"MultiStark::frontier_fold","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":4},{"cells":152,"fft_cost":2064.0,"height":4,"index":155,"lookup_group_size":1,"lookups":21,"name":"MultiStark::frontier_level","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":38,"stage2_width":42},{"cells":112,"fft_cost":1200.0,"height":4,"index":156,"lookup_group_size":1,"lookups":8,"name":"MultiStark::select_rows_le","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":28,"stage2_width":16},{"cells":22,"fft_cost":138.0,"height":2,"index":157,"lookup_group_size":2,"lookups":4,"name":"MultiStark::inject_maybe","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4},{"cells":28,"fft_cost":156.0,"height":2,"index":158,"lookup_group_size":2,"lookups":3,"name":"MultiStark::has_height","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":14,"stage2_width":4},{"cells":206,"fft_cost":722.0,"height":2,"index":159,"lookup_group_size":1,"lookups":7,"name":"MultiStark::mmcs_compress","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":103,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":160,"lookup_group_size":1,"lookups":2,"name":"MultiStark::compress_ordered","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":4},{"cells":0,"fft_cost":0.0,"height":0,"index":161,"lookup_group_size":1,"lookups":6,"name":"MultiStark::heights_prep","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":162,"lookup_group_size":1,"lookups":4,"name":"MultiStark::heights_max","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":8},{"cells":0,"fft_cost":0.0,"height":0,"index":163,"lookup_group_size":1,"lookups":5,"name":"MultiStark::drop_index_bits","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":10},{"cells":384,"fft_cost":10944.0,"height":32,"index":164,"lookup_group_size":2,"lookups":5,"name":"MultiStark::query_views","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":6},{"cells":768,"fft_cost":26112.0,"height":64,"index":165,"lookup_group_size":2,"lookups":5,"name":"MultiStark::batch_views_at","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":6},{"cells":208,"fft_cost":4608.0,"height":16,"index":166,"lookup_group_size":2,"lookups":5,"name":"MultiStark::step_views_at","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":6},{"cells":1216,"fft_cost":26304.0,"height":32,"index":167,"lookup_group_size":1,"lookups":6,"name":"MultiStark::query_loop","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":38,"stage2_width":12},{"cells":118,"fft_cost":522.0,"height":2,"index":168,"lookup_group_size":2,"lookups":20,"name":"MultiStark::verify_one_query","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":59,"stage2_width":20},{"cells":26,"fft_cost":162.0,"height":2,"index":169,"lookup_group_size":2,"lookups":5,"name":"MultiStark::build_buckets","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":6},{"cells":16,"fft_cost":72.0,"height":1,"index":170,"lookup_group_size":2,"lookups":3,"name":"MultiStark::circ_has_height","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":4},{"cells":176,"fft_cost":2400.0,"height":8,"index":171,"lookup_group_size":2,"lookups":6,"name":"MultiStark::open_batch_2pt","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":22,"stage2_width":6},{"cells":80,"fft_cost":832.0,"height":4,"index":172,"lookup_group_size":1,"lookups":6,"name":"MultiStark::open_2pt_mat","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":20,"stage2_width":12},{"cells":384,"fft_cost":7488.0,"height":16,"index":173,"lookup_group_size":2,"lookups":9,"name":"MultiStark::ri_apply","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":24,"stage2_width":10},{"cells":52,"fft_cost":552.0,"height":4,"index":174,"lookup_group_size":2,"lookups":3,"name":"MultiStark::exp_by_bits","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":4},{"cells":496,"fft_cost":8064.0,"height":16,"index":175,"lookup_group_size":2,"lookups":5,"name":"MultiStark::bucket_update","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":31,"stage2_width":6},{"cells":576,"fft_cost":8640.0,"height":16,"index":176,"lookup_group_size":2,"lookups":4,"name":"MultiStark::ro_fold","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":36,"stage2_width":4},{"cells":92,"fft_cost":888.0,"height":4,"index":177,"lookup_group_size":2,"lookups":7,"name":"MultiStark::open_quotient","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":8},{"cells":48,"fft_cost":248.0,"height":2,"index":178,"lookup_group_size":1,"lookups":7,"name":"MultiStark::open_prep_batch","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":24,"stage2_width":14},{"cells":0,"fft_cost":0.0,"height":0,"index":179,"lookup_group_size":2,"lookups":8,"name":"MultiStark::open_prep","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":8},{"cells":23,"fft_cost":93.0,"height":1,"index":180,"lookup_group_size":2,"lookups":3,"name":"MultiStark::assert_blowup_zero","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":4},{"cells":196,"fft_cost":1032.0,"height":2,"index":181,"lookup_group_size":1,"lookups":33,"name":"MultiStark::verify_query","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":98,"stage2_width":66},{"cells":12,"fft_cost":66.0,"height":1,"index":182,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"MultiStark::list_length\",\"types\":[{\"named\":{\"args\":[],\"name\":\"MultiStark::Bucket\"}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":183,"lookup_group_size":2,"lookups":5,"name":"MultiStark::fri_fold2","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":6},{"cells":0,"fft_cost":0.0,"height":0,"index":184,"lookup_group_size":1,"lookups":3,"name":"MultiStark::rollin","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":24,"stage2_width":6},{"cells":25,"fft_cost":123.0,"height":1,"index":185,"lookup_group_size":2,"lookups":12,"name":"MultiStark::verify_commit_multi","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":25,"stage2_width":12},{"cells":0,"fft_cost":0.0,"height":0,"index":186,"lookup_group_size":1,"lookups":7,"name":"MultiStark::rows_at_round","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":14},{"cells":14,"fft_cost":66.0,"height":1,"index":187,"lookup_group_size":2,"lookups":4,"name":"MultiStark::last_acc","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":14,"stage2_width":4},{"cells":24,"fft_cost":152.0,"height":2,"index":188,"lookup_group_size":1,"lookups":5,"name":"MultiStark::batch_claims","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":12,"stage2_width":10},{"cells":512,"fft_cost":50176.0,"height":256,"index":189,"lookup_group_size":1,"lookups":2,"name":"","preprocessed_height":256,"preprocessed_width":11,"quotient_degree":1,"stage1_width":2,"stage2_width":4},{"cells":458752,"fft_cost":60555264.0,"height":65536,"index":190,"lookup_group_size":2,"lookups":7,"name":"","preprocessed_height":65536,"preprocessed_width":14,"quotient_degree":2,"stage1_width":7,"stage2_width":8},{"cells":1024,"fft_cost":157696.0,"height":1024,"index":191,"lookup_group_size":1,"lookups":1,"name":"","preprocessed_height":1024,"preprocessed_width":3,"quotient_degree":1,"stage1_width":1,"stage2_width":2},{"cells":24576,"fft_cost":2080768.0,"height":4096,"index":192,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":6,"stage2_width":6},{"cells":224,"fft_cost":7328.0,"height":32,"index":193,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":6},{"cells":8,"fft_cost":48.0,"height":1,"index":194,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":8,"stage2_width":6},{"cells":1152,"fft_cost":46208.0,"height":128,"index":195,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":9,"stage2_width":6},{"cells":80,"fft_cost":1328.0,"height":8,"index":196,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":6},{"cells":11,"fft_cost":57.0,"height":1,"index":197,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":6},{"cells":416,"fft_cost":10208.0,"height":32,"index":198,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":13,"stage2_width":6},{"cells":28,"fft_cost":140.0,"height":2,"index":199,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":14,"stage2_width":6},{"cells":58,"fft_cost":230.0,"height":2,"index":200,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":29,"stage2_width":6},{"cells":560,"fft_cost":8320.0,"height":16,"index":201,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":35,"stage2_width":6},{"cells":592,"fft_cost":8704.0,"height":16,"index":202,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":37,"stage2_width":6}]} diff --git a/docs/benchmarks/formal-aiur-grouping-tuning/runs.json b/docs/benchmarks/formal-aiur-grouping-tuning/runs.json new file mode 100644 index 000000000..f6fd23efc --- /dev/null +++ b/docs/benchmarks/formal-aiur-grouping-tuning/runs.json @@ -0,0 +1,250 @@ +{ + "ixvm-baseline": { + "backend": "new-bytecode", + "prepare_seconds": 0.133206008, + "proof": { + "bytes": 6320763, + "prove_including_trace_seconds": 0.323813881, + "verified": true + }, + "samples": [ + { + "execute_seconds": 0.005475585, + "trace_with_lookups_seconds": 0.006909195 + }, + { + "execute_seconds": 0.005800192, + "trace_with_lookups_seconds": 0.006507144 + }, + { + "execute_seconds": 0.00550802, + "trace_with_lookups_seconds": 0.005713973 + }, + { + "execute_seconds": 0.005763812, + "trace_with_lookups_seconds": 0.004824658 + }, + { + "execute_seconds": 0.005714245, + "trace_with_lookups_seconds": 0.006683408 + } + ], + "setup_seconds": 0.295478218, + "thp_disabled": true + }, + "ixvm-selected": { + "backend": "new-bytecode", + "prepare_seconds": 0.128174854, + "proof": { + "bytes": 5478175, + "prove_including_trace_seconds": 0.283005233, + "verified": true + }, + "samples": [ + { + "execute_seconds": 0.005826926, + "trace_with_lookups_seconds": 0.006289355 + }, + { + "execute_seconds": 0.005800293, + "trace_with_lookups_seconds": 0.00636884 + }, + { + "execute_seconds": 0.005752825, + "trace_with_lookups_seconds": 0.006187914 + }, + { + "execute_seconds": 0.005786026, + "trace_with_lookups_seconds": 0.005263984 + }, + { + "execute_seconds": 0.005600679, + "trace_with_lookups_seconds": 0.006062015 + } + ], + "setup_seconds": 0.314618132, + "thp_disabled": true + }, + "environment-baseline": { + "backend": "new-bytecode", + "prepare_seconds": 0.133130814, + "proof": { + "bytes": 7227058, + "prove_including_trace_seconds": 3.61765854, + "verified": true + }, + "samples": [ + { + "execute_seconds": 0.35812349, + "trace_with_lookups_seconds": 0.155726205 + }, + { + "execute_seconds": 0.443671611, + "trace_with_lookups_seconds": 0.163751354 + }, + { + "execute_seconds": 0.406637502, + "trace_with_lookups_seconds": 0.162264424 + }, + { + "execute_seconds": 0.384674704, + "trace_with_lookups_seconds": 0.153248113 + }, + { + "execute_seconds": 0.393635062, + "trace_with_lookups_seconds": 0.161113585 + } + ], + "setup_seconds": 0.305386995, + "thp_disabled": true + }, + "environment-selected": { + "backend": "new-bytecode", + "prepare_seconds": 0.128846202, + "proof": { + "bytes": 6557454, + "prove_including_trace_seconds": 3.3998496080000002, + "verified": true + }, + "samples": [ + { + "execute_seconds": 0.357373407, + "trace_with_lookups_seconds": 0.18560857 + }, + { + "execute_seconds": 0.355163402, + "trace_with_lookups_seconds": 0.173344043 + }, + { + "execute_seconds": 0.352991365, + "trace_with_lookups_seconds": 0.173092983 + }, + { + "execute_seconds": 0.359051829, + "trace_with_lookups_seconds": 0.17804781 + }, + { + "execute_seconds": 0.332571743, + "trace_with_lookups_seconds": 0.171257647 + } + ], + "setup_seconds": 0.305855609, + "thp_disabled": true + }, + "recursion-baseline": { + "backend": "new-bytecode", + "prepare_seconds": 0.040000637, + "proof": { + "bytes": 3585743, + "prove_including_trace_seconds": 0.213947019, + "verified": true + }, + "samples": [ + { + "execute_seconds": 0.00252076, + "trace_with_lookups_seconds": 0.004051814 + }, + { + "execute_seconds": 0.002484614, + "trace_with_lookups_seconds": 0.004738907 + }, + { + "execute_seconds": 0.002367088, + "trace_with_lookups_seconds": 0.006182233 + }, + { + "execute_seconds": 0.003502531, + "trace_with_lookups_seconds": 0.006392397 + }, + { + "execute_seconds": 0.00220088, + "trace_with_lookups_seconds": 0.004143117 + } + ], + "setup_seconds": 0.039555387, + "thp_disabled": true + }, + "recursion-selected": { + "backend": "new-bytecode", + "prepare_seconds": 0.039920021, + "proof": { + "bytes": 2972473, + "prove_including_trace_seconds": 0.20641283, + "verified": true + }, + "samples": [ + { + "execute_seconds": 0.002493089, + "trace_with_lookups_seconds": 0.004411169 + }, + { + "execute_seconds": 0.002547064, + "trace_with_lookups_seconds": 0.005531274 + }, + { + "execute_seconds": 0.002287803, + "trace_with_lookups_seconds": 0.005767196 + }, + { + "execute_seconds": 0.002388841, + "trace_with_lookups_seconds": 0.003679591 + }, + { + "execute_seconds": 0.003498959, + "trace_with_lookups_seconds": 0.004332047 + } + ], + "setup_seconds": 0.041543849, + "thp_disabled": true + }, + "recursion-real-baseline": { + "backend": "new-bytecode", + "prepare_seconds": 0.101522772, + "proof": { + "bytes": 3845899, + "prove_including_trace_seconds": 54.841168009, + "verified": true + }, + "samples": [ + { + "execute_seconds": 7.659587048, + "trace_with_lookups_seconds": 3.5528092989999998 + }, + { + "execute_seconds": 7.6863125740000005, + "trace_with_lookups_seconds": 3.519352687 + }, + { + "execute_seconds": 7.667051882, + "trace_with_lookups_seconds": 3.560951336 + } + ], + "setup_seconds": 0.036276874, + "thp_disabled": true + }, + "recursion-real-selected": { + "backend": "new-bytecode", + "prepare_seconds": 0.102368589, + "proof": { + "bytes": 3168863, + "prove_including_trace_seconds": 52.648571714, + "verified": true + }, + "samples": [ + { + "execute_seconds": 7.832905957, + "trace_with_lookups_seconds": 3.759408438 + }, + { + "execute_seconds": 7.963177618, + "trace_with_lookups_seconds": 3.7497445320000002 + }, + { + "execute_seconds": 7.994769895, + "trace_with_lookups_seconds": 3.794459276 + } + ], + "setup_seconds": 0.035439834, + "thp_disabled": true + } +} diff --git a/docs/benchmarks/formal-aiur-grouping-tuning/summary.csv b/docs/benchmarks/formal-aiur-grouping-tuning/summary.csv new file mode 100644 index 000000000..f69bbd64f --- /dev/null +++ b/docs/benchmarks/formal-aiur-grouping-tuning/summary.csv @@ -0,0 +1,9 @@ +workload,variant,circuits,stage1_columns,stage2_columns,stage1_cells,fft_work,execute_ms,trace_ms,prove_seconds,proof_bytes +ixvm,baseline,235,9650,4194,1322458,100644448,5.714245,6.507144,0.323813881,6320763 +ixvm,selected,162,8018,3436,1173983,95655377,5.786026,6.187914,0.283005233,5478175 +environment,baseline,235,9650,4194,46656479,3527936909,393.635062,161.113585,3.61765854,7227058 +environment,selected,162,8018,3436,43146214,3287192336,355.163402,173.344043,3.3998496080000002,6557454 +recursion,baseline,91,4109,1630,826803,74587165,2.484614,4.738906999999999,0.213947019,3585743 +recursion,selected,68,3199,1412,717864,71212610,2.493089,4.411169,0.20641283,2972473 +recursion-real,baseline,91,4109,1630,1005868035,89271866275,7667.051882,3552.8092989999996,54.841168009,3845899 +recursion-real,selected,68,3199,1412,937960213,84826424989,7963.177618,3759.408438,52.648571714,3168863 diff --git a/docs/benchmarks/formal-aiur-grouping/circuits.csv b/docs/benchmarks/formal-aiur-grouping/circuits.csv new file mode 100644 index 000000000..37aaea744 --- /dev/null +++ b/docs/benchmarks/formal-aiur-grouping/circuits.csv @@ -0,0 +1,5251 @@ +run,name,index,height,stage1_width,stage2_width,preprocessed_width,preprocessed_height,quotient_degree,cells,fft_cost +legacy-environment-grouped,ixvm_group_00,0,16384,33,14,0,0,2,540672,35291136 +legacy-environment-grouped,ixvm_group_01,1,1024,119,40,0,0,2,121856,5019648 +legacy-environment-grouped,address_eq,2,8192,70,8,0,0,2,573440,26296320 +legacy-environment-grouped,checked_depth_succ,3,16384,4,4,0,0,1,65536,6946816 +legacy-environment-grouped,read_finite_byte_stream,4,512,7,4,0,0,1,3584,181760 +legacy-environment-grouped,u64_is_zero,5,128,19,2,0,0,2,2432,68736 +legacy-environment-grouped,ixvm_group_02,6,2,50,6,0,0,2,100,384 +legacy-environment-grouped,ixvm_group_03,7,1024,63,32,0,0,2,64512,3053568 +legacy-environment-grouped,ixvm_group_04,8,256,20,2,0,0,2,5120,162816 +legacy-environment-grouped,ixvm_group_05,9,1024,106,16,0,0,2,108544,3883008 +legacy-environment-grouped,ixvm_group_06,10,1024,79,16,0,0,2,80896,3053568 +legacy-environment-grouped,ixvm_group_07,11,256,202,34,0,0,2,51712,1477632 +legacy-environment-grouped,ixvm_group_08,12,4096,166,18,0,0,2,679936,27770880 +legacy-environment-grouped,blake3_compress_chunks,13,131072,17,8,0,0,2,2228224,195428352 +legacy-environment-grouped,bytes_to_block,14,4096,195,130,0,0,2,798720,48562176 +legacy-environment-grouped,pad_block,15,65536,8,6,0,0,2,524288,57409536 +legacy-environment-grouped,blake3_compress_block,16,2048,161,26,0,0,2,329728,12933120 +legacy-environment-grouped,blake3_compress,17,32768,533,388,0,0,2,17465344,1364361216 +legacy-environment-grouped,ixvm_group_09,18,1,171,18,0,0,2,171,579 +legacy-environment-grouped,ixvm_group_10,19,0,63,14,0,0,2,0,0 +legacy-environment-grouped,ixvm_group_11,20,1024,56,10,0,0,2,57344,2162688 +legacy-environment-grouped,ixvm_group_12,21,0,106,18,0,0,2,0,0 +legacy-environment-grouped,put_tagn_tail,22,0,26,10,0,0,2,0,0 +legacy-environment-grouped,put_tagn_wide,23,0,30,6,0,0,2,0,0 +legacy-environment-grouped,ixvm_group_13,24,0,58,10,0,0,2,0,0 +legacy-environment-grouped,value_contract_code,25,0,10,2,0,0,2,0,0 +legacy-environment-grouped,binder_contract_code,26,0,11,4,0,0,2,0,0 +legacy-environment-grouped,put_lam_mode,27,0,8,6,0,0,1,0,0 +legacy-environment-grouped,ixvm_group_15,28,1024,51,12,0,0,2,52224,2070528 +legacy-environment-grouped,ixvm_group_16,29,0,114,22,0,0,2,0,0 +legacy-environment-grouped,ixvm_group_17,30,2048,136,80,0,0,2,278528,14893056 +legacy-environment-grouped,ixvm_group_14,31,0,42,8,0,0,2,0,0 +legacy-environment-grouped,ixvm_group_18,32,0,101,12,0,0,2,0,0 +legacy-environment-grouped,ixvm_group_19,33,256,103,20,0,0,2,26368,783360 +legacy-environment-grouped,ixvm_group_20,34,128,57,18,0,0,2,7296,213888 +legacy-environment-grouped,ixvm_group_21,35,0,219,66,0,0,2,0,0 +legacy-environment-grouped,ixvm_group_22,36,1024,92,16,0,0,2,94208,3452928 +legacy-environment-grouped,ixvm_group_23,37,256,45,10,0,0,2,11520,365568 +legacy-environment-grouped,ixvm_group_24,38,8192,20,8,0,0,2,163840,10321920 +legacy-environment-grouped,get_u64_le,39,0,18,6,0,0,2,0,0 +legacy-environment-grouped,get_tagn4,40,32768,24,8,0,0,2,786432,53477376 +legacy-environment-grouped,ixvm_group_25,41,512,39,18,0,0,2,19968,849408 +legacy-environment-grouped,get_tagn0,42,8192,17,8,0,0,2,139264,9363456 +legacy-environment-grouped,get_tagn_tail,43,2048,16,8,0,0,2,32768,1916928 +legacy-environment-grouped,get_tagn_wide,44,0,26,6,0,0,2,0,0 +legacy-environment-grouped,get_u64_list,45,4096,33,12,0,0,2,135168,7274496 +legacy-environment-grouped,get_app_telescope,46,16384,27,12,0,0,2,442368,29786112 +legacy-environment-grouped,value_contract_from_bits,47,1,10,2,0,0,2,10,48 +legacy-environment-grouped,binder_contract_from_bits,48,1,13,4,0,0,2,13,63 +legacy-environment-grouped,get_lam_mode,49,2048,16,4,0,0,2,32768,1646592 +legacy-environment-grouped,get_all_mode,50,2048,18,6,0,0,2,36864,1916928 +legacy-environment-grouped,ixvm_group_26,51,8192,38,14,0,0,2,311296,17989632 +legacy-environment-grouped,get_expr,52,32768,49,12,0,0,2,1605632,96239616 +legacy-environment-grouped,ixvm_group_27,53,256,64,22,0,0,2,16384,556032 +legacy-environment-grouped,get_address,54,2048,100,68,0,0,2,204800,11649024 +legacy-environment-grouped,get_expr_list,55,2048,26,12,0,0,2,53248,2863104 +legacy-environment-grouped,ixvm_group_28,56,1024,62,20,0,0,2,63488,2654208 +legacy-environment-grouped,get_address_list,57,2048,26,12,0,0,2,53248,2863104 +legacy-environment-grouped,ixvm_group_30,58,512,52,4,0,0,2,26624,835584 +legacy-environment-grouped,ixvm_group_31,59,1024,40,16,0,0,2,40960,1855488 +legacy-environment-grouped,ixvm_group_32,60,16,89,20,0,0,2,1424,21888 +legacy-environment-grouped,ixvm_group_33,61,1024,106,12,0,0,2,108544,3760128 +legacy-environment-grouped,ixvm_group_34,62,2048,34,12,0,0,2,69632,3403776 +legacy-environment-grouped,ixvm_group_35,63,512,72,12,0,0,2,36864,1222656 +legacy-environment-grouped,collect_spine,64,16384,11,8,0,0,2,180224,16023552 +legacy-environment-grouped,ixvm_group_36,65,256,74,20,0,0,2,18944,605184 +legacy-environment-grouped,klimbs_add_carry,66,16,49,14,0,0,2,784,13056 +legacy-environment-grouped,klimbs_add,67,16,5,4,0,0,1,80,2176 +legacy-environment-grouped,ixvm_group_37,68,128,79,32,0,0,2,10112,310656 +legacy-environment-grouped,ixvm_group_38,69,1024,40,20,0,0,2,40960,1978368 +legacy-environment-grouped,glimbs_to_klimbs_with_depth,70,8,18,18,0,0,2,144,2976 +legacy-environment-grouped,klimbs_normalize,71,16,30,14,0,0,2,480,9408 +legacy-environment-grouped,ixvm_group_39,72,256,40,8,0,0,2,10240,322560 +legacy-environment-grouped,klimbs_mul_outer,73,32,21,12,0,0,2,672,18144 +legacy-environment-grouped,klimbs_mul_single,74,32,68,14,0,0,2,2176,41664 +legacy-environment-grouped,klimbs_shl_limbs,75,16,8,6,0,0,2,128,3648 +legacy-environment-grouped,ixvm_group_40,76,512,52,34,0,0,2,26624,1250304 +legacy-environment-grouped,ixvm_group_41,77,32,55,12,0,0,2,1760,34464 +legacy-environment-grouped,ixvm_group_42,78,8,84,44,0,0,2,672,9600 +legacy-environment-grouped,ixvm_group_43,79,16,18,4,0,0,2,288,5184 +legacy-environment-grouped,ixvm_group_44,80,16,18,4,0,0,2,288,5184 +legacy-environment-grouped,ixvm_group_45,81,16,18,4,0,0,2,288,5184 +legacy-environment-grouped,ixvm_group_46,82,16,18,4,0,0,2,288,5184 +legacy-environment-grouped,ixvm_group_47,83,1024,54,10,0,0,2,55296,2101248 +legacy-environment-grouped,ixvm_group_48,84,1024,38,22,0,0,2,38912,1978368 +legacy-environment-grouped,ixvm_group_49,85,4,81,56,0,0,2,324,3432 +legacy-environment-grouped,ixvm_group_50,86,1,61,24,0,0,2,61,267 +legacy-environment-grouped,ixvm_group_51,87,512,32,14,0,0,2,16384,697344 +legacy-environment-grouped,ixvm_group_52,88,0,89,34,0,0,2,0,0 +legacy-environment-grouped,ixvm_group_53,89,128,55,32,0,0,2,7040,246144 +legacy-environment-grouped,ixvm_group_54,90,0,10,4,0,0,2,0,0 +legacy-environment-grouped,ixvm_group_55,91,512,43,10,0,0,2,22016,794112 +legacy-environment-grouped,ixvm_group_56,92,512,72,50,0,0,2,36864,1747968 +legacy-environment-grouped,ixvm_group_57,93,2048,15,8,0,0,2,30720,1849344 +legacy-environment-grouped,ixvm_group_58,94,1024,55,16,0,0,2,56320,2316288 +legacy-environment-grouped,ixvm_group_59,95,0,159,102,0,0,2,0,0 +legacy-environment-grouped,ixvm_group_60,96,32,65,20,0,0,2,2080,43104 +legacy-environment-grouped,ixvm_group_61,97,32,54,12,0,0,2,1728,33984 +legacy-environment-grouped,ixvm_group_62,98,0,56,14,0,0,2,0,0 +legacy-environment-grouped,apply_spine_expr,99,8192,10,8,0,0,2,81920,7127040 +legacy-environment-grouped,ixvm_group_63,100,512,100,52,0,0,2,51200,2162688 +legacy-environment-grouped,ixvm_group_64,101,1024,44,14,0,0,2,45056,1916928 +legacy-environment-grouped,convert_expr,102,16384,42,14,0,0,2,688128,41484288 +legacy-environment-grouped,ixvm_group_65,103,1024,28,10,0,0,2,28672,1302528 +legacy-environment-grouped,ixvm_group_66,104,512,88,48,0,0,2,45056,1941504 +legacy-environment-grouped,ixvm_group_67,105,512,53,12,0,0,2,27136,960000 +legacy-environment-grouped,ixvm_group_68,106,256,53,12,0,0,2,13568,427008 +legacy-environment-grouped,ixvm_group_69,107,1024,35,10,0,0,2,35840,1517568 +legacy-environment-grouped,ixvm_group_70,108,2048,20,8,0,0,2,40960,2187264 +legacy-environment-grouped,ixvm_group_71,109,2048,20,12,0,0,2,40960,2457600 +legacy-environment-grouped,expr_inst_levels,110,4096,10,6,0,0,2,40960,2998272 +legacy-environment-grouped,expr_inst_levels_walk,111,4096,20,12,0,0,2,81920,5357568 +legacy-environment-grouped,expr_lbr,112,32768,19,12,0,0,2,622592,52002816 +legacy-environment-grouped,has_bvar_in_range,113,8192,31,28,0,0,2,253952,20226048 +legacy-environment-grouped,ixvm_group_72,114,2048,12,6,0,0,2,24576,1511424 +legacy-environment-grouped,ixvm_group_73,115,2048,26,20,0,0,2,53248,3403776 +legacy-environment-grouped,ixvm_group_74,116,4096,26,26,0,0,2,106496,8306688 +legacy-environment-grouped,expr_glb,117,32768,9,8,0,0,2,294912,31358976 +legacy-environment-grouped,expr_glb_walk,118,32768,22,10,0,0,2,720896,53477376 +legacy-environment-grouped,expr_glb_binder,119,8192,10,8,0,0,2,81920,7127040 +legacy-environment-grouped,expr_lift,120,16384,11,8,0,0,2,180224,16023552 +legacy-environment-grouped,expr_lift_walk,121,16384,20,10,0,0,2,327680,23592960 +legacy-environment-grouped,expr_lower,122,32768,11,8,0,0,2,360448,34308096 +legacy-environment-grouped,expr_lower_walk,123,16384,25,18,0,0,2,409600,32538624 +legacy-environment-grouped,expr_has_bvar_at,124,8192,22,8,0,0,2,180224,10960896 +legacy-environment-grouped,ixvm_group_75,125,4096,11,6,0,0,2,45056,3145728 +legacy-environment-grouped,expr_inst1,126,8192,12,10,0,0,2,98304,8404992 +legacy-environment-grouped,expr_inst1_walk,127,4096,20,10,0,0,2,81920,5062656 +legacy-environment-grouped,expr_inst_many,128,32768,15,12,0,0,2,491520,46104576 +legacy-environment-grouped,expr_inst_many_bvar,129,8192,10,10,0,0,2,81920,7766016 +legacy-environment-grouped,expr_inst_many_walk,130,16384,20,10,0,0,2,327680,23592960 +legacy-environment-grouped,peel_beta,131,4096,18,10,0,0,2,73728,4767744 +legacy-environment-grouped,whnf_apply_beta,132,1024,16,14,0,0,2,16384,1056768 +legacy-environment-grouped,whnf_with_spine,133,4096,20,10,0,0,2,81920,5062656 +legacy-environment-grouped,ixvm_group_76,134,512,41,20,0,0,2,20992,904704 +legacy-environment-grouped,ixvm_group_77,135,256,98,76,0,0,2,25088,1096704 +legacy-environment-grouped,try_prim_dispatch,136,2048,20,8,0,0,2,40960,2187264 +legacy-environment-grouped,whnf_const_head,137,1024,53,20,0,0,2,54272,2377728 +legacy-environment-grouped,whnf,138,4096,22,12,0,0,2,90112,5652480 +legacy-environment-grouped,whnf_struct_core,139,4096,22,12,0,0,2,90112,5652480 +legacy-environment-grouped,whnf_struct_core_spine,140,4096,25,16,0,0,2,102400,6684672 +legacy-environment-grouped,ixvm_group_78,141,1024,32,12,0,0,2,32768,1486848 +legacy-environment-grouped,whnf_nd,142,2048,22,12,0,0,2,45056,2592768 +legacy-environment-grouped,whnf_nd_with_spine,143,4096,20,10,0,0,2,81920,5062656 +legacy-environment-grouped,whnf_nd_apply_beta,144,512,16,14,0,0,2,8192,476160 +legacy-environment-grouped,whnf_nd_const_head,145,1024,60,26,0,0,2,61440,2777088 +legacy-environment-grouped,types_lookup,146,16,6,6,0,0,1,96,2752 +legacy-environment-grouped,ixvm_group_79,147,1024,29,2,0,0,2,29696,1087488 +legacy-environment-grouped,ixvm_group_80,148,2048,70,30,0,0,2,143360,7053312 +legacy-environment-grouped,k_is_def_eq,149,8192,13,12,0,0,2,106496,9363456 +legacy-environment-grouped,k_def_eq_rebase,150,2048,18,22,0,0,2,36864,2998272 +legacy-environment-grouped,ixvm_group_81,151,4096,25,16,0,0,2,102400,6684672 +legacy-environment-grouped,try_def_eq_app,152,2048,27,18,0,0,2,55296,3336192 +legacy-environment-grouped,de_args,153,512,18,10,0,0,2,9216,448512 +legacy-environment-grouped,is_nat_zero,154,1024,12,8,0,0,2,12288,749568 +legacy-environment-grouped,nat_offset_of,155,1024,36,18,0,0,2,36864,1794048 +legacy-environment-grouped,try_string_lit_one,156,4096,14,10,0,0,2,57344,4177920 +legacy-environment-grouped,ixvm_group_82,157,1024,30,8,0,0,2,30720,1302528 +legacy-environment-grouped,k_is_def_eq_struct_bounded,158,2048,45,12,0,0,2,92160,4147200 +legacy-environment-grouped,lazy_delta_loop,159,1024,26,10,0,0,2,26624,1241088 +legacy-environment-grouped,head_addr,160,1024,12,8,0,0,2,12288,749568 +legacy-environment-grouped,k_infer,161,8192,8,8,0,0,2,65536,6488064 +legacy-environment-grouped,k_infer_rebase,162,8192,15,18,0,0,2,122880,11919360 +legacy-environment-grouped,k_infer_core,163,8192,33,16,0,0,2,270336,17031168 +legacy-environment-grouped,k_infer_let_start,164,16,11,8,0,0,2,176,4608 +legacy-environment-grouped,infer_let_lookup_type,165,128,16,6,0,0,2,2048,71424 +legacy-environment-grouped,infer_let_lookup_value,166,256,16,6,0,0,2,4096,162816 +legacy-environment-grouped,infer_let_materialize,167,1024,27,16,0,0,2,27648,1456128 +legacy-environment-grouped,k_infer_let_env,168,512,20,12,0,0,2,10240,503808 +legacy-environment-grouped,infer_let_local_cutoff,169,64,13,6,0,0,2,832,27264 +legacy-environment-grouped,k_infer_let_env_rebase,170,64,14,8,0,0,2,896,30720 +legacy-environment-grouped,infer_let_drop_unused,171,128,16,6,0,0,2,2048,71424 +legacy-environment-grouped,k_infer_let_env_core,172,512,28,22,0,0,2,14336,752640 +legacy-environment-grouped,k_infer_app_spine_loop,173,8192,33,22,0,0,2,270336,18948096 +legacy-environment-grouped,k_ensure_sort,174,4096,10,8,0,0,2,40960,3293184 +legacy-environment-grouped,k_check,175,4096,7,6,0,0,1,28672,2228224 +legacy-environment-grouped,canon_cmp_kexpr_node_ctx,176,0,61,14,0,0,2,0,0 +legacy-environment-grouped,safe_refs_only,177,8192,29,10,0,0,2,237568,13836288 +legacy-environment-grouped,validate_expr_well_scoped,178,16384,32,16,0,0,2,524288,35979264 +legacy-environment-grouped,const_idxs_expr,179,8192,34,14,0,0,2,278528,16711680 +legacy-environment-grouped,const_idxs_exprs,180,2048,10,10,0,0,2,20480,1646592 +legacy-environment-grouped,g_list_has,181,16384,11,6,0,0,2,180224,14647296 +legacy-environment-grouped,walk_refs_transitive,182,0,13,10,0,0,2,0,0 +legacy-environment-grouped,walk_leaves_owned,183,512,39,10,0,0,2,19968,738816 +legacy-environment-grouped,check_owned,184,512,35,6,0,0,1,17920,596480 +legacy-environment-grouped,env_walk_all,185,512,90,14,0,0,2,46080,1499136 +legacy-environment-grouped,env_walk_refs_all,186,4096,44,12,0,0,2,180224,8896512 +legacy-environment-grouped,eval_nf,187,0,15,14,0,0,2,0,0 +legacy-environment-grouped,eval_nf_spine,188,0,13,10,0,0,2,0,0 +legacy-environment-grouped,eval_body,189,0,19,8,0,0,2,0,0 +legacy-environment-grouped,eval_output,190,0,57,12,0,0,2,0,0 +legacy-environment-grouped,run_eval,191,0,22,20,0,0,2,0,0 +legacy-environment-grouped,verify_claim,192,1,10,4,0,0,1,10,48 +legacy-environment-grouped,list_snoc.G,193,16384,10,8,0,0,2,163840,15335424 +legacy-environment-grouped,list_concat.Ptr.KExprNode,194,16384,10,8,0,0,2,163840,15335424 +legacy-environment-grouped,list_length.Ptr.KExprNode,195,8192,8,6,0,0,2,65536,5849088 +legacy-environment-grouped,list_lookup.Ptr.KLevelNode,196,8192,8,6,0,0,2,65536,5849088 +legacy-environment-grouped,list_is_empty.U8,197,2048,7,4,0,0,2,14336,1038336 +legacy-environment-grouped,list_take.Ptr.KExprNode,198,2048,11,8,0,0,2,22528,1579008 +legacy-environment-grouped,list_drop.Ptr.Expr,199,16384,10,6,0,0,2,163840,13959168 +legacy-environment-grouped,list_depth_checked.U8,200,131072,9,8,0,0,2,1179648,141950976 +legacy-environment-grouped,rbtree_map_balance_fix.G,201,0,102,16,0,0,2,0,0 +legacy-environment-grouped,ROM:2,202,8,5,6,0,0,2,40,1176 +legacy-environment-grouped,ROM:3,203,524288,6,6,0,0,2,3145728,484442112 +legacy-environment-grouped,ROM:4,204,32768,7,6,0,0,2,229376,25460736 +legacy-environment-grouped,ROM:5,205,128,8,6,0,0,2,1024,49920 +legacy-environment-grouped,ROM:6,206,16,9,6,0,0,2,144,3840 +legacy-environment-grouped,ROM:8,207,2,11,6,0,0,2,22,150 +legacy-environment-grouped,ROM:9,208,32,12,6,0,0,2,384,10944 +legacy-environment-grouped,ROM:10,209,64,13,6,0,0,2,832,27264 +legacy-environment-grouped,ROM:11,210,32,14,6,0,0,2,448,11904 +legacy-environment-grouped,ROM:12,211,512,15,6,0,0,2,7680,351744 +legacy-environment-grouped,ROM:18,212,8192,21,6,0,0,2,172032,10002432 +legacy-environment-grouped,ROM:19,213,0,22,6,0,0,2,0,0 +legacy-environment-grouped,ROM:32,214,4096,35,6,0,0,2,143360,6684672 +legacy-environment-grouped,ROM:34,215,2048,37,6,0,0,2,75776,3201024 +legacy-environment-grouped,ROM:36,216,64,39,6,0,0,2,2496,57216 +legacy-environment-grouped,ROM:47,217,32,50,6,0,0,2,1600,29184 +legacy-environment-grouped,ROM:50,218,0,53,6,0,0,2,0,0 +legacy-environment-grouped,ROM:64,219,0,67,6,0,0,2,0,0 +legacy-environment-grouped,Bytes1,220,256,3,6,11,256,1,768,68608 +legacy-environment-grouped,Bytes2,221,65536,8,8,11,65536,2,524288,63700992 +legacy-environment-ungrouped,memo_u32_less_than,0,16384,10,8,0,0,2,163840,15335424 +legacy-environment-ungrouped,address_eq_tail,1,128,74,6,0,0,2,9472,227328 +legacy-environment-ungrouped,address_eq,2,8192,70,8,0,0,2,573440,26296320 +legacy-environment-ungrouped,checked_depth_succ,3,16384,4,4,0,0,1,65536,6946816 +legacy-environment-ungrouped,read_finite_byte_stream,4,512,7,4,0,0,1,3584,181760 +legacy-environment-ungrouped,u64_is_zero,5,128,19,2,0,0,2,2432,68736 +legacy-environment-ungrouped,u64_eq,6,1,27,2,0,0,2,27,99 +legacy-environment-ungrouped,u64_add,7,16,33,16,0,0,2,528,10368 +legacy-environment-ungrouped,relaxed_u64_succ,8,1,19,2,0,0,2,19,75 +legacy-environment-ungrouped,relaxed_u64_pred,9,128,19,2,0,0,2,2432,68736 +legacy-environment-ungrouped,flatten_u64,10,128,10,2,0,0,1,1280,38144 +legacy-environment-ungrouped,verify_bytes_against,11,512,72,8,0,0,2,36864,1167360 +legacy-environment-ungrouped,bytes_to_addr,12,1024,41,8,0,0,2,41984,1640448 +legacy-environment-ungrouped,blake3_next_layer,13,16,175,12,0,0,2,2800,36864 +legacy-environment-ungrouped,blake3_compress_layer,14,2048,141,12,0,0,2,288768,10635264 +legacy-environment-ungrouped,blake3_compress_chunks,15,131072,17,8,0,0,2,2228224,195428352 +legacy-environment-ungrouped,bytes_to_block,16,4096,195,130,0,0,2,798720,48562176 +legacy-environment-ungrouped,pad_block,17,65536,8,6,0,0,2,524288,57409536 +legacy-environment-ungrouped,blake3_finish,18,2048,160,16,0,0,2,327680,12189696 +legacy-environment-ungrouped,blake3_compress_block,19,2048,161,26,0,0,2,329728,12933120 +legacy-environment-ungrouped,blake3_compress,20,32768,533,388,0,0,2,17465344,1364361216 +legacy-environment-ungrouped,put_expr,21,0,94,18,0,0,2,0,0 +legacy-environment-ungrouped,put_u64_le,22,0,16,6,0,0,2,0,0 +legacy-environment-ungrouped,put_tagn4,23,64,16,6,0,0,2,1024,30720 +legacy-environment-ungrouped,put_tagn2,24,0,16,6,0,0,2,0,0 +legacy-environment-ungrouped,put_tagn0,25,64,15,6,0,0,2,960,29568 +legacy-environment-ungrouped,put_tagn_tail,26,0,26,10,0,0,2,0,0 +legacy-environment-ungrouped,put_tagn_wide,27,0,30,6,0,0,2,0,0 +legacy-environment-ungrouped,put_u64_list,28,0,17,8,0,0,2,0,0 +legacy-environment-ungrouped,value_contract_code,29,0,10,2,0,0,2,0,0 +legacy-environment-ungrouped,binder_contract_code,30,0,11,4,0,0,2,0,0 +legacy-environment-ungrouped,put_lam_mode,31,0,8,6,0,0,1,0,0 +legacy-environment-ungrouped,put_all_mode,32,0,11,4,0,0,2,0,0 +legacy-environment-ungrouped,app_telescope_count,33,0,55,8,0,0,2,0,0 +legacy-environment-ungrouped,lam_telescope_count,34,0,55,8,0,0,2,0,0 +legacy-environment-ungrouped,all_telescope_count,35,0,55,8,0,0,2,0,0 +legacy-environment-ungrouped,put_app_telescope,36,0,60,10,0,0,2,0,0 +legacy-environment-ungrouped,put_lam_telescope,37,0,61,12,0,0,2,0,0 +legacy-environment-ungrouped,put_all_telescope,38,0,61,12,0,0,2,0,0 +legacy-environment-ungrouped,put_address,39,2048,68,34,0,0,2,139264,7188480 +legacy-environment-ungrouped,pack_def_kind_safety,40,0,12,2,0,0,2,0,0 +legacy-environment-ungrouped,univ_succ_count,41,0,37,8,0,0,2,0,0 +legacy-environment-ungrouped,univ_succ_base,42,0,30,6,0,0,2,0,0 +legacy-environment-ungrouped,put_univ,43,0,37,12,0,0,2,0,0 +legacy-environment-ungrouped,put_expr_list,44,1,28,10,0,0,2,28,126 +legacy-environment-ungrouped,put_univ_list,45,1,19,10,0,0,2,19,99 +legacy-environment-ungrouped,put_address_list,46,1,10,8,0,0,2,10,66 +legacy-environment-ungrouped,put_quot_kind,47,0,8,4,0,0,2,0,0 +legacy-environment-ungrouped,put_definition,48,0,56,16,0,0,2,0,0 +legacy-environment-ungrouped,put_recursor_rule,49,0,32,8,0,0,2,0,0 +legacy-environment-ungrouped,put_recursor_rule_list,50,0,18,8,0,0,2,0,0 +legacy-environment-ungrouped,put_recursor,51,0,82,24,0,0,2,0,0 +legacy-environment-ungrouped,put_axiom,52,0,34,10,0,0,2,0,0 +legacy-environment-ungrouped,put_quotient,53,0,34,10,0,0,2,0,0 +legacy-environment-ungrouped,put_constructor,54,0,61,16,0,0,2,0,0 +legacy-environment-ungrouped,put_constructor_list,55,0,43,8,0,0,2,0,0 +legacy-environment-ungrouped,put_inductive,56,0,63,20,0,0,2,0,0 +legacy-environment-ungrouped,put_definition_proj,57,32,14,6,0,0,2,448,11904 +legacy-environment-ungrouped,put_constructor_proj,58,32,23,8,0,0,2,736,17184 +legacy-environment-ungrouped,put_mut_const,59,0,52,6,0,0,2,0,0 +legacy-environment-ungrouped,put_mut_const_list,60,0,54,8,0,0,2,0,0 +legacy-environment-ungrouped,put_constant_info,61,64,56,4,0,0,2,3584,74496 +legacy-environment-ungrouped,put_sharing,62,1,14,4,0,0,2,14,66 +legacy-environment-ungrouped,put_refs,63,1,14,4,0,0,2,14,66 +legacy-environment-ungrouped,put_univs,64,1,14,4,0,0,2,14,66 +legacy-environment-ungrouped,put_constant,65,64,72,14,0,0,2,4608,104448 +legacy-environment-ungrouped,read_byte,66,8192,6,4,0,0,2,49152,4571136 +legacy-environment-ungrouped,get_u64_le,67,0,18,6,0,0,2,0,0 +legacy-environment-ungrouped,get_tagn4,68,32768,24,8,0,0,2,786432,53477376 +legacy-environment-ungrouped,get_tagn2,69,128,24,8,0,0,2,3072,98304 +legacy-environment-ungrouped,get_tagn0,70,8192,17,8,0,0,2,139264,9363456 +legacy-environment-ungrouped,get_tagn_tail,71,2048,16,8,0,0,2,32768,1916928 +legacy-environment-ungrouped,get_tagn_wide,72,0,26,6,0,0,2,0,0 +legacy-environment-ungrouped,get_u64_list,73,4096,33,12,0,0,2,135168,7274496 +legacy-environment-ungrouped,get_app_telescope,74,16384,27,12,0,0,2,442368,29786112 +legacy-environment-ungrouped,value_contract_from_bits,75,1,10,2,0,0,2,10,48 +legacy-environment-ungrouped,binder_contract_from_bits,76,1,13,4,0,0,2,13,63 +legacy-environment-ungrouped,get_lam_mode,77,2048,16,4,0,0,2,32768,1646592 +legacy-environment-ungrouped,get_all_mode,78,2048,18,6,0,0,2,36864,1916928 +legacy-environment-ungrouped,get_lam_telescope,79,4096,35,14,0,0,2,143360,7864320 +legacy-environment-ungrouped,get_all_telescope,80,2048,35,14,0,0,2,71680,3606528 +legacy-environment-ungrouped,get_expr,81,32768,49,12,0,0,2,1605632,96239616 +legacy-environment-ungrouped,get_expr_let,82,16,34,16,0,0,2,544,10560 +legacy-environment-ungrouped,build_succ_chain,83,16,39,10,0,0,2,624,10368 +legacy-environment-ungrouped,get_univ,84,128,39,12,0,0,2,4992,149376 +legacy-environment-ungrouped,get_address,85,2048,100,68,0,0,2,204800,11649024 +legacy-environment-ungrouped,get_expr_list,86,2048,26,12,0,0,2,53248,2863104 +legacy-environment-ungrouped,get_univ_list,87,64,35,14,0,0,2,2240,61824 +legacy-environment-ungrouped,get_address_list,88,2048,26,12,0,0,2,53248,2863104 +legacy-environment-ungrouped,unpack_def_kind_safety,89,2,11,2,0,0,2,22,126 +legacy-environment-ungrouped,get_definition,90,256,20,6,0,0,2,5120,187392 +legacy-environment-ungrouped,get_recursor_rule_list,91,32,35,14,0,0,2,1120,25824 +legacy-environment-ungrouped,get_recursor,92,16,72,12,0,0,2,1152,17088 +legacy-environment-ungrouped,assert_wire_bool,93,1,4,4,0,0,1,4,30 +legacy-environment-ungrouped,get_axiom,94,0,16,6,0,0,2,0,0 +legacy-environment-ungrouped,quot_kind_tag,95,0,6,2,0,0,2,0,0 +legacy-environment-ungrouped,get_quotient,96,0,17,6,0,0,2,0,0 +legacy-environment-ungrouped,get_constructor,97,64,43,8,0,0,2,2752,64128 +legacy-environment-ungrouped,get_constructor_list,98,64,59,12,0,0,2,3776,87168 +legacy-environment-ungrouped,get_inductive,99,32,53,10,0,0,2,1696,32544 +legacy-environment-ungrouped,get_inductive_proj,100,32,14,6,0,0,1,448,10688 +legacy-environment-ungrouped,get_constructor_proj,101,64,23,4,0,0,2,1472,36480 +legacy-environment-ungrouped,get_mut_const,102,32,52,6,0,0,2,1664,30144 +legacy-environment-ungrouped,get_mut_const_list,103,64,70,12,0,0,2,4480,99840 +legacy-environment-ungrouped,get_constant_info_by_variant,104,512,56,4,0,0,2,28672,890880 +legacy-environment-ungrouped,get_constant,105,512,140,18,0,0,2,71680,2245632 +legacy-environment-ungrouped,collect_spine,106,16384,11,8,0,0,2,180224,16023552 +legacy-environment-ungrouped,klimbs_succ,107,4,27,10,0,0,2,108,1032 +legacy-environment-ungrouped,klimbs_add_carry,108,16,49,14,0,0,2,784,13056 +legacy-environment-ungrouped,klimbs_add,109,16,5,4,0,0,1,80,2176 +legacy-environment-ungrouped,u64_sub_with_borrow,110,16,33,16,0,0,2,528,10368 +legacy-environment-ungrouped,klimbs_sub_borrow,111,16,51,14,0,0,2,816,13440 +legacy-environment-ungrouped,glimbs_to_klimbs,112,8,5,4,0,0,1,40,824 +legacy-environment-ungrouped,glimbs_to_klimbs_with_depth,113,8,18,18,0,0,2,144,2976 +legacy-environment-ungrouped,klimbs_normalize,114,16,30,14,0,0,2,480,9408 +legacy-environment-ungrouped,klimbs_sub,115,16,8,6,0,0,2,128,3648 +legacy-environment-ungrouped,klimbs_le,116,8,17,6,0,0,2,136,2040 +legacy-environment-ungrouped,klimbs_dec,117,2,6,4,0,0,2,12,108 +legacy-environment-ungrouped,u64_mul,118,16,90,22,0,0,2,1440,22464 +legacy-environment-ungrouped,klimbs_mul,119,16,6,6,0,0,1,96,2752 +legacy-environment-ungrouped,klimbs_mul_outer,120,32,21,12,0,0,2,672,18144 +legacy-environment-ungrouped,klimbs_mul_single,121,32,68,14,0,0,2,2176,41664 +legacy-environment-ungrouped,klimbs_shl_limbs,122,16,8,6,0,0,2,128,3648 +legacy-environment-ungrouped,klimbs_is_zero,123,8,16,6,0,0,2,128,1968 +legacy-environment-ungrouped,klimbs_div_mod,124,8,18,24,0,0,2,144,3408 +legacy-environment-ungrouped,klimbs_div,125,0,6,4,0,0,1,0,0 +legacy-environment-ungrouped,klimbs_mod,126,0,6,4,0,0,1,0,0 +legacy-environment-ungrouped,klimbs_gcd,127,0,8,8,0,0,2,0,0 +legacy-environment-ungrouped,klimbs_pow,128,8,17,22,0,0,2,136,3192 +legacy-environment-ungrouped,u64_and,129,0,26,10,0,0,2,0,0 +legacy-environment-ungrouped,u64_or,130,0,26,10,0,0,2,0,0 +legacy-environment-ungrouped,u64_xor_kbits,131,0,26,10,0,0,2,0,0 +legacy-environment-ungrouped,klimbs_land,132,0,36,12,0,0,2,0,0 +legacy-environment-ungrouped,klimbs_lor,133,0,36,12,0,0,2,0,0 +legacy-environment-ungrouped,klimbs_xor_op,134,0,36,12,0,0,2,0,0 +legacy-environment-ungrouped,klimbs_shl,135,0,8,6,0,0,2,0,0 +legacy-environment-ungrouped,klimbs_shr,136,0,8,6,0,0,2,0,0 +legacy-environment-ungrouped,nat_zero_addr,137,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,nat_succ_addr_iota,138,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,nat_pred_addr,139,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,int_of_nat_addr,140,0,3,4,0,0,1,0,0 +legacy-environment-ungrouped,int_neg_succ_addr_dec,141,0,3,4,0,0,1,0,0 +legacy-environment-ungrouped,int_add_addr,142,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,int_sub_addr,143,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,int_mul_addr,144,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,int_neg_addr,145,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,int_emod_addr,146,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,int_ediv_addr,147,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,int_bmod_addr,148,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,int_bdiv_addr,149,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,int_nat_abs_addr,150,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,int_pow_addr,151,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,nat_add_addr,152,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,nat_sub_addr,153,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,nat_mul_addr,154,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,nat_pow_addr,155,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,nat_gcd_addr,156,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,nat_mod_addr,157,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,nat_div_addr,158,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,nat_land_addr,159,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,nat_lor_addr,160,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,nat_xor_addr,161,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,nat_shift_left_addr,162,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,nat_shift_right_addr,163,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,nat_beq_addr,164,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,nat_ble_addr,165,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,bool_true_addr,166,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,bool_false_addr,167,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,system_platform_num_bits_addr,168,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,punit_size_of_1_addr,169,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,reduce_bool_addr,170,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,reduce_nat_addr,171,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,subtype_val_addr,172,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,system_platform_get_num_bits_addr,173,0,3,4,0,0,1,0,0 +legacy-environment-ungrouped,is_native_prim_addr,174,128,23,22,0,0,2,2944,133248 +legacy-environment-ungrouped,mk_nat_literal_64,175,0,5,4,0,0,2,0,0 +legacy-environment-ungrouped,mk_nat_one,176,0,5,4,0,0,2,0,0 +legacy-environment-ungrouped,try_native_dispatch,177,0,38,42,0,0,2,0,0 +legacy-environment-ungrouped,try_reduce_subtype_val,178,0,25,28,0,0,2,0,0 +legacy-environment-ungrouped,check_native_bool,179,0,14,14,0,0,2,0,0 +legacy-environment-ungrouped,check_native_nat,180,0,11,6,0,0,2,0,0 +legacy-environment-ungrouped,bit_vec_to_nat_addr,181,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,bit_vec_of_nat_addr,182,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,bit_vec_addr,183,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,bit_vec_ult_addr,184,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,decidable_decide_addr,185,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,lt_lt_addr,186,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,is_bitvec_prim_addr,187,128,15,14,0,0,2,1920,90240 +legacy-environment-ungrouped,mk_bool,188,2,8,8,0,0,2,16,144 +legacy-environment-ungrouped,bv_to_nat_via,189,2,19,18,0,0,2,38,270 +legacy-environment-ungrouped,try_reduce_bit_vec_ult,190,0,23,30,0,0,2,0,0 +legacy-environment-ungrouped,try_reduce_decide_bitvec_lt,191,8,63,80,0,0,2,504,10680 +legacy-environment-ungrouped,bitvec_of_nat_args_direct,192,2,17,16,0,0,2,34,246 +legacy-environment-ungrouped,try_bitvec_dispatch,193,8,26,30,0,0,2,208,4416 +legacy-environment-ungrouped,bitvec_prep_spine_ult,194,0,22,20,0,0,2,0,0 +legacy-environment-ungrouped,np_whnf_inner_bv,195,0,8,4,0,0,2,0,0 +legacy-environment-ungrouped,string_utf8_byte_size_addr,196,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,string_append_addr,197,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,string_of_list_addr,198,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,char_of_nat_addr,199,0,3,4,0,0,1,0,0 +legacy-environment-ungrouped,list_nil_addr,200,0,3,4,0,0,1,0,0 +legacy-environment-ungrouped,list_cons_addr,201,0,3,4,0,0,1,0,0 +legacy-environment-ungrouped,char_type_addr,202,0,3,4,0,0,1,0,0 +legacy-environment-ungrouped,string_back_addr,203,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,string_legacy_back_addr,204,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,string_to_byte_array_addr,205,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,byte_array_empty_addr,206,0,3,4,0,0,1,0,0 +legacy-environment-ungrouped,string_dec_eq_addr,207,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,str_addr,208,0,3,4,0,0,1,0,0 +legacy-environment-ungrouped,is_str_prim_addr,209,128,31,30,0,0,2,3968,176256 +legacy-environment-ungrouped,try_str_dispatch,210,0,62,56,0,0,2,0,0 +legacy-environment-ungrouped,try_str_back,211,0,26,34,0,0,2,0,0 +legacy-environment-ungrouped,try_str_to_byte_array,212,0,26,28,0,0,2,0,0 +legacy-environment-ungrouped,utf8_validate,213,0,9,8,0,0,2,0,0 +legacy-environment-ungrouped,utf8_last_codepoint,214,0,4,4,0,0,1,0,0 +legacy-environment-ungrouped,utf8_last_go,215,0,11,8,0,0,2,0,0 +legacy-environment-ungrouped,utf8_cont,216,0,5,6,0,0,2,0,0 +legacy-environment-ungrouped,utf8_decode_one,217,0,32,34,0,0,2,0,0 +legacy-environment-ungrouped,str_lit_to_ctor,218,0,20,18,0,0,2,0,0 +legacy-environment-ungrouped,build_char_list,219,0,18,18,0,0,2,0,0 +legacy-environment-ungrouped,str_lit_delta_step,220,0,38,20,0,0,2,0,0 +legacy-environment-ungrouped,str_lit_to_ctor_app_or_self,221,256,12,8,0,0,2,3072,150528 +legacy-environment-ungrouped,klimbs_from_g,222,0,14,8,0,0,2,0,0 +legacy-environment-ungrouped,walk_char_list_bytes,223,0,32,28,0,0,2,0,0 +legacy-environment-ungrouped,char_lit_codepoint,224,0,11,8,0,0,2,0,0 +legacy-environment-ungrouped,char_lit_codepoint_syn,225,0,25,14,0,0,2,0,0 +legacy-environment-ungrouped,klimbs_scalar_value,226,0,53,42,0,0,2,0,0 +legacy-environment-ungrouped,utf8_encode_prepend,227,0,64,102,0,0,2,0,0 +legacy-environment-ungrouped,is_int_prim_addr,228,128,23,22,0,0,2,2944,133248 +legacy-environment-ungrouped,try_extract_nat,229,128,16,10,0,0,2,2048,82176 +legacy-environment-ungrouped,try_extract_nat_app,230,64,17,12,0,0,2,1088,38784 +legacy-environment-ungrouped,mk_nat_lit,231,8,4,4,0,0,1,32,752 +legacy-environment-ungrouped,try_extract_int_prim,232,0,25,20,0,0,2,0,0 +legacy-environment-ungrouped,mk_int_prim,233,0,22,20,0,0,2,0,0 +legacy-environment-ungrouped,int_add_prim,234,0,13,8,0,0,2,0,0 +legacy-environment-ungrouped,int_emod_prim,235,0,14,12,0,0,2,0,0 +legacy-environment-ungrouped,int_ediv_prim,236,0,21,16,0,0,2,0,0 +legacy-environment-ungrouped,int_bmod_prim,237,0,23,24,0,0,2,0,0 +legacy-environment-ungrouped,int_bdiv_prim,238,0,34,34,0,0,2,0,0 +legacy-environment-ungrouped,try_int_prim_dispatch,239,0,38,42,0,0,2,0,0 +legacy-environment-ungrouped,try_int_prim_second,240,0,46,42,0,0,2,0,0 +legacy-environment-ungrouped,apply_spine_expr,241,8192,10,8,0,0,2,81920,7127040 +legacy-environment-ungrouped,try_nat_binop_addr,242,8,62,62,0,0,2,496,9312 +legacy-environment-ungrouped,try_match_nat_add,243,128,25,18,0,0,2,3200,127872 +legacy-environment-ungrouped,build_succ_offset,244,1,21,32,0,0,2,21,171 +legacy-environment-ungrouped,cleanup_nat_offset_major,245,128,25,16,0,0,2,3200,122496 +legacy-environment-ungrouped,mk_nat_offset_stuck,246,4,15,18,0,0,2,60,936 +legacy-environment-ungrouped,is_nat_succ_ih_step,247,16,34,20,0,0,2,544,11328 +legacy-environment-ungrouped,try_nat_linear_rec,248,256,31,34,0,0,2,7936,427008 +legacy-environment-ungrouped,try_nat_binop_dispatch,249,64,27,28,0,0,2,1728,68736 +legacy-environment-ungrouped,try_nat_offset_dispatch,250,8,27,28,0,0,2,216,4344 +legacy-environment-ungrouped,mk_nat_binop_stuck,251,0,12,8,0,0,2,0,0 +legacy-environment-ungrouped,bytes_to_u64_limb,252,64,40,6,0,0,2,2560,58368 +legacy-environment-ungrouped,skip_bytes,253,64,11,6,0,0,2,704,24960 +legacy-environment-ungrouped,bytes_to_limbs,254,32,35,18,0,0,2,1120,27744 +legacy-environment-ungrouped,convert_univ,255,32,19,10,0,0,2,608,16224 +legacy-environment-ungrouped,convert_univ_idxs,256,128,20,14,0,0,2,2560,103680 +legacy-environment-ungrouped,convert_expr,257,16384,42,14,0,0,2,688128,41484288 +legacy-environment-ungrouped,convert_definition,258,256,28,8,0,0,2,7168,248832 +legacy-environment-ungrouped,convert_axiom,259,0,18,6,0,0,2,0,0 +legacy-environment-ungrouped,convert_quotient,260,0,18,6,0,0,2,0,0 +legacy-environment-ungrouped,count_ctors,261,64,41,6,0,0,2,2624,59520 +legacy-environment-ungrouped,ctor_at,262,64,76,6,0,0,2,4864,99840 +legacy-environment-ungrouped,convert_inductive,263,32,40,12,0,0,2,1280,27264 +legacy-environment-ungrouped,convert_constructor,264,64,47,12,0,0,2,3008,73344 +legacy-environment-ungrouped,convert_rec_rules,265,32,24,12,0,0,2,768,19584 +legacy-environment-ungrouped,convert_recursor,266,16,59,16,0,0,2,944,15360 +legacy-environment-ungrouped,load_verified_constant,267,512,90,6,0,0,2,46080,1388544 +legacy-environment-ungrouped,load_verified_blob,268,32,38,4,0,0,2,1216,22464 +legacy-environment-ungrouped,defn_is_unsafe_ci,269,2,9,2,0,0,2,18,114 +legacy-environment-ungrouped,defn_member_recur_addrs,270,0,20,6,0,0,2,0,0 +legacy-environment-ungrouped,get_ci,271,512,79,14,0,0,2,40448,1347072 +legacy-environment-ungrouped,get_ci_dprj,272,0,120,12,0,0,2,0,0 +legacy-environment-ungrouped,get_ci_iprj,273,32,111,12,0,0,2,3552,61344 +legacy-environment-ungrouped,get_ci_cprj,274,64,146,14,0,0,2,9344,189696 +legacy-environment-ungrouped,get_ci_rprj,275,0,111,12,0,0,2,0,0 +legacy-environment-ungrouped,muts_member_at,276,32,98,6,0,0,2,3136,52224 +legacy-environment-ungrouped,idx_to_u64,277,2,12,6,0,0,2,24,156 +legacy-environment-ungrouped,projection_addr,278,32,109,12,0,0,2,3488,60384 +legacy-environment-ungrouped,build_recur_addrs,279,32,5,4,0,0,1,160,5408 +legacy-environment-ungrouped,build_recur_addrs_walk,280,64,57,10,0,0,2,3648,82560 +legacy-environment-ungrouped,level_is_not_zero,281,128,15,8,0,0,2,1920,74112 +legacy-environment-ungrouped,level_eq,282,256,22,10,0,0,2,5632,224256 +legacy-environment-ungrouped,glist_cmp,283,16,28,32,0,0,2,448,12480 +legacy-environment-ungrouped,glist_subset,284,16,27,32,0,0,2,432,12288 +legacy-environment-ungrouped,glist_eq_len,285,8,14,8,0,0,2,112,1968 +legacy-environment-ungrouped,glist_ordered_insert,286,4,25,32,0,0,2,100,1512 +legacy-environment-ungrouped,nlvars_add,287,4,34,46,0,0,2,136,2064 +legacy-environment-ungrouped,nlvars_eq,288,8,20,12,0,0,2,160,2688 +legacy-environment-ungrouped,nlvars_max_offset,289,0,17,20,0,0,2,0,0 +legacy-environment-ungrouped,nlvars_subsume,290,0,39,50,0,0,2,0,0 +legacy-environment-ungrouped,nl_add_const,291,16,12,6,0,0,2,192,4416 +legacy-environment-ungrouped,nl_add_const_go,292,16,24,24,0,0,2,384,10176 +legacy-environment-ungrouped,nl_add_var,293,32,21,18,0,0,2,672,21024 +legacy-environment-ungrouped,normalize_aux,294,128,19,10,0,0,2,2432,90240 +legacy-environment-ungrouped,normalize_imax_dispatch,295,0,23,12,0,0,2,0,0 +legacy-environment-ungrouped,nl_subsumption_walk,296,64,11,10,0,0,2,704,29568 +legacy-environment-ungrouped,nl_subsume_entry,297,128,57,48,0,0,2,7296,294528 +legacy-environment-ungrouped,nl_skip_empty,298,32,16,10,0,0,2,512,14784 +legacy-environment-ungrouped,nl_eq,299,32,27,20,0,0,2,864,24864 +legacy-environment-ungrouped,nl_covers_const,300,2,27,24,0,0,2,54,354 +legacy-environment-ungrouped,nlvars_any_offset_geq,301,0,18,20,0,0,2,0,0 +legacy-environment-ungrouped,nl_covers_var,302,16,19,12,0,0,2,304,6912 +legacy-environment-ungrouped,nlvars_dominates,303,8,20,20,0,0,2,160,3264 +legacy-environment-ungrouped,nl_le,304,16,20,12,0,0,2,320,7104 +legacy-environment-ungrouped,nl_le_vars,305,16,14,10,0,0,2,224,5568 +legacy-environment-ungrouped,level_normalize,306,32,8,6,0,0,2,256,9024 +legacy-environment-ungrouped,level_leq,307,16,14,12,0,0,2,224,5952 +legacy-environment-ungrouped,level_equal,308,32,9,10,0,0,2,288,11424 +legacy-environment-ungrouped,level_max,309,128,17,18,0,0,2,2176,106368 +legacy-environment-ungrouped,level_max_go,310,128,21,14,0,0,2,2688,106368 +legacy-environment-ungrouped,level_struct_eq,311,256,25,10,0,0,2,6400,242688 +legacy-environment-ungrouped,level_max_subsumes,312,256,11,8,0,0,2,2816,144384 +legacy-environment-ungrouped,level_max_offsets,313,64,17,20,0,0,2,1088,48000 +legacy-environment-ungrouped,level_explicit_val,314,32,12,6,0,0,2,384,10944 +legacy-environment-ungrouped,level_offset_of,315,128,10,6,0,0,2,1280,55296 +legacy-environment-ungrouped,level_imax,316,256,21,12,0,0,2,5376,230400 +legacy-environment-ungrouped,level_reduce,317,32,13,10,0,0,2,416,13344 +legacy-environment-ungrouped,level_inst_params,318,256,14,10,0,0,2,3584,175104 +legacy-environment-ungrouped,level_list_inst,319,256,11,10,0,0,2,2816,156672 +legacy-environment-ungrouped,expr_inst_levels,320,4096,10,6,0,0,2,40960,2998272 +legacy-environment-ungrouped,expr_inst_levels_walk,321,4096,20,12,0,0,2,81920,5357568 +legacy-environment-ungrouped,klimbs_eq,322,4,30,10,0,0,2,120,1104 +legacy-environment-ungrouped,canon_g_list_eq,323,0,15,8,0,0,2,0,0 +legacy-environment-ungrouped,literal_eq,324,0,10,4,0,0,2,0,0 +legacy-environment-ungrouped,expr_lbr,325,32768,19,12,0,0,2,622592,52002816 +legacy-environment-ungrouped,expr_lbr_let,326,16,11,8,0,0,2,176,4608 +legacy-environment-ungrouped,lbr_max,327,512,11,14,0,0,2,5632,407040 +legacy-environment-ungrouped,lbr_dec,328,32,5,2,0,0,2,160,5664 +legacy-environment-ungrouped,lbr_min,329,512,11,14,0,0,2,5632,407040 +legacy-environment-ungrouped,has_bvar_in_range,330,8192,31,28,0,0,2,253952,20226048 +legacy-environment-ungrouped,has_bvar_in_range_binder,331,2048,9,6,0,0,2,18432,1308672 +legacy-environment-ungrouped,has_bvar_in_range_let,332,0,12,8,0,0,2,0,0 +legacy-environment-ungrouped,ctx_seek_cut,333,2048,14,20,0,0,2,28672,2592768 +legacy-environment-ungrouped,ctx_next_cut,334,1024,8,8,0,0,2,8192,626688 +legacy-environment-ungrouped,ctx_close_cut,335,1024,16,20,0,0,2,16384,1241088 +legacy-environment-ungrouped,ctx_trim,336,2048,18,24,0,0,2,36864,3133440 +legacy-environment-ungrouped,expr_glb,337,32768,9,8,0,0,2,294912,31358976 +legacy-environment-ungrouped,expr_glb_walk,338,32768,22,10,0,0,2,720896,53477376 +legacy-environment-ungrouped,expr_glb_binder,339,8192,10,8,0,0,2,81920,7127040 +legacy-environment-ungrouped,expr_glb_let,340,32,15,12,0,0,2,480,15264 +legacy-environment-ungrouped,expr_lift,341,16384,11,8,0,0,2,180224,16023552 +legacy-environment-ungrouped,expr_lift_walk,342,16384,20,10,0,0,2,327680,23592960 +legacy-environment-ungrouped,expr_lift_bvar,343,1024,13,16,0,0,2,13312,1026048 +legacy-environment-ungrouped,expr_lift_let,344,0,11,6,0,0,2,0,0 +legacy-environment-ungrouped,expr_lower,345,32768,11,8,0,0,2,360448,34308096 +legacy-environment-ungrouped,expr_lower_walk,346,16384,25,18,0,0,2,409600,32538624 +legacy-environment-ungrouped,expr_has_bvar_at,347,8192,22,8,0,0,2,180224,10960896 +legacy-environment-ungrouped,expr_has_bvar_at_binder,348,2048,9,6,0,0,2,18432,1308672 +legacy-environment-ungrouped,expr_has_bvar_at_let,349,0,13,8,0,0,2,0,0 +legacy-environment-ungrouped,expr_inst1,350,8192,12,10,0,0,2,98304,8404992 +legacy-environment-ungrouped,expr_inst1_walk,351,4096,20,10,0,0,2,81920,5062656 +legacy-environment-ungrouped,expr_inst1_bvar,352,512,10,6,0,0,2,5120,282624 +legacy-environment-ungrouped,expr_inst1_let,353,0,11,6,0,0,2,0,0 +legacy-environment-ungrouped,expr_inst_many,354,32768,15,12,0,0,2,491520,46104576 +legacy-environment-ungrouped,expr_inst_many_bvar,355,8192,10,10,0,0,2,81920,7766016 +legacy-environment-ungrouped,expr_inst_many_walk,356,16384,20,10,0,0,2,327680,23592960 +legacy-environment-ungrouped,expr_inst_many_let,357,0,11,6,0,0,2,0,0 +legacy-environment-ungrouped,peel_beta,358,4096,18,10,0,0,2,73728,4767744 +legacy-environment-ungrouped,whnf_apply_beta,359,1024,16,14,0,0,2,16384,1056768 +legacy-environment-ungrouped,whnf_with_spine,360,4096,20,10,0,0,2,81920,5062656 +legacy-environment-ungrouped,whnf_proj_head,361,128,37,20,0,0,2,4736,165504 +legacy-environment-ungrouped,fin_addr,362,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,decidable_rec_addr,363,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,nat_addr_io,364,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,quot_ctor_addr,365,0,3,4,0,0,1,0,0 +legacy-environment-ungrouped,quot_lift_addr_iota,366,0,3,4,0,0,1,0,0 +legacy-environment-ungrouped,quot_ind_addr,367,0,3,4,0,0,1,0,0 +legacy-environment-ungrouped,try_reduce_fin_val_decidable_rec,368,128,65,74,0,0,2,8320,385920 +legacy-environment-ungrouped,whnf_get_ctor_or_none,369,32,12,10,0,0,2,384,12864 +legacy-environment-ungrouped,whnf_spine,370,128,11,10,0,0,2,1408,68736 +legacy-environment-ungrouped,try_nat_dispatch_prewhnf,371,128,33,40,0,0,2,4224,208512 +legacy-environment-ungrouped,bitvec_prep_spine,372,2,20,20,0,0,2,40,288 +legacy-environment-ungrouped,prim_family,373,128,86,76,0,0,2,11008,447744 +legacy-environment-ungrouped,try_prim_dispatch,374,2048,20,8,0,0,2,40960,2187264 +legacy-environment-ungrouped,try_quot_iota,375,0,14,12,0,0,2,0,0 +legacy-environment-ungrouped,try_quot_lift,376,0,21,28,0,0,2,0,0 +legacy-environment-ungrouped,try_quot_ind,377,0,21,28,0,0,2,0,0 +legacy-environment-ungrouped,quot_extract_arg,378,0,19,16,0,0,2,0,0 +legacy-environment-ungrouped,whnf_const_head,379,1024,53,20,0,0,2,54272,2377728 +legacy-environment-ungrouped,try_reduce_projection_definition,380,1024,23,26,0,0,2,23552,1640448 +legacy-environment-ungrouped,projection_definition_info,381,512,24,20,0,0,2,12288,669696 +legacy-environment-ungrouped,nat_lit_to_ctor_or_self,382,64,19,20,0,0,2,1216,50304 +legacy-environment-ungrouped,try_k_synth_iota,383,2,31,24,0,0,2,62,378 +legacy-environment-ungrouped,k_synth_gate,384,2,39,28,0,0,2,78,450 +legacy-environment-ungrouped,replace_spine_major,385,64,11,8,0,0,2,704,27264 +legacy-environment-ungrouped,whnf_iota_major,386,128,29,18,0,0,2,3712,138624 +legacy-environment-ungrouped,try_iota,387,256,48,50,0,0,2,12288,629760 +legacy-environment-ungrouped,collect_spine_of_ctor,388,64,27,14,0,0,2,1728,52608 +legacy-environment-ungrouped,find_rule,389,16,15,6,0,0,2,240,4992 +legacy-environment-ungrouped,try_struct_eta_iota,390,64,62,38,0,0,2,3968,120576 +legacy-environment-ungrouped,se_parent_addr,391,8,20,10,0,0,2,160,2544 +legacy-environment-ungrouped,apply_n_projs,392,0,12,8,0,0,2,0,0 +legacy-environment-ungrouped,struct_is_rec,393,4,19,10,0,0,2,76,840 +legacy-environment-ungrouped,struct_block_member_addrs,394,4,56,8,0,0,2,224,1680 +legacy-environment-ungrouped,struct_scan_ctors,395,8,29,12,0,0,2,232,3336 +legacy-environment-ungrouped,se_peel_tol,396,16,12,6,0,0,2,192,4416 +legacy-environment-ungrouped,se_scan_fields,397,16,13,8,0,0,2,208,4992 +legacy-environment-ungrouped,se_mentions,398,16,25,10,0,0,2,400,7680 +legacy-environment-ungrouped,se_addr_in,399,0,12,8,0,0,2,0,0 +legacy-environment-ungrouped,whnf,400,4096,22,12,0,0,2,90112,5652480 +legacy-environment-ungrouped,whnf_struct_core,401,4096,22,12,0,0,2,90112,5652480 +legacy-environment-ungrouped,whnf_struct_core_spine,402,4096,25,16,0,0,2,102400,6684672 +legacy-environment-ungrouped,whnf_struct_core_proj,403,32,32,16,0,0,2,1024,25344 +legacy-environment-ungrouped,whnf_struct_core_const,404,512,27,12,0,0,2,13824,600576 +legacy-environment-ungrouped,whnf_nd,405,2048,22,12,0,0,2,45056,2592768 +legacy-environment-ungrouped,whnf_nd_with_spine,406,4096,20,10,0,0,2,81920,5062656 +legacy-environment-ungrouped,whnf_nd_apply_beta,407,512,16,14,0,0,2,8192,476160 +legacy-environment-ungrouped,whnf_nd_proj_head,408,512,37,20,0,0,2,18944,849408 +legacy-environment-ungrouped,whnf_nd_const_head,409,1024,60,26,0,0,2,61440,2777088 +legacy-environment-ungrouped,types_lookup,410,16,6,6,0,0,1,96,2752 +legacy-environment-ungrouped,const_num_lvls,411,512,21,2,0,0,2,10752,379392 +legacy-environment-ungrouped,const_type_of,412,512,21,2,0,0,2,10752,379392 +legacy-environment-ungrouped,k_infer_only,413,1024,57,30,0,0,2,58368,2807808 +legacy-environment-ungrouped,ensure_sort_only,414,64,16,10,0,0,2,1024,35328 +legacy-environment-ungrouped,peel_params_subst,415,128,16,10,0,0,2,2048,82176 +legacy-environment-ungrouped,io_peel_field_loop,416,16,16,10,0,0,2,256,5952 +legacy-environment-ungrouped,level_list_eq,417,16,17,10,0,0,2,272,6144 +legacy-environment-ungrouped,k_is_def_eq,418,8192,13,12,0,0,2,106496,9363456 +legacy-environment-ungrouped,k_def_eq_rebase,419,2048,18,22,0,0,2,36864,2998272 +legacy-environment-ungrouped,k_is_def_eq_core,420,2048,14,16,0,0,2,28672,2322432 +legacy-environment-ungrouped,k_is_def_eq_ordered,421,2048,9,6,0,0,2,18432,1308672 +legacy-environment-ungrouped,try_def_eq_app,422,2048,27,18,0,0,2,55296,3336192 +legacy-environment-ungrouped,de_args,423,512,18,10,0,0,2,9216,448512 +legacy-environment-ungrouped,is_nat_zero,424,1024,12,8,0,0,2,12288,749568 +legacy-environment-ungrouped,nat_offset_of,425,1024,36,18,0,0,2,36864,1794048 +legacy-environment-ungrouped,try_def_eq_nat,426,1024,23,14,0,0,2,23552,1271808 +legacy-environment-ungrouped,try_string_lit_one,427,4096,14,10,0,0,2,57344,4177920 +legacy-environment-ungrouped,k_is_def_eq_slow,428,2048,14,8,0,0,2,28672,1781760 +legacy-environment-ungrouped,k_is_def_eq_slow_nd,429,2048,16,12,0,0,2,32768,2187264 +legacy-environment-ungrouped,k_is_def_eq_slow_nd_after_core,430,256,18,12,0,0,2,4608,211968 +legacy-environment-ungrouped,k_is_def_eq_struct_safe,431,2048,24,12,0,0,2,49152,2727936 +legacy-environment-ungrouped,k_is_def_eq_slow2,432,256,31,16,0,0,2,7936,316416 +legacy-environment-ungrouped,slow2_after_delta,433,128,15,8,0,0,2,1920,74112 +legacy-environment-ungrouped,try_same_proj_head_app,434,256,31,22,0,0,2,7936,353280 +legacy-environment-ungrouped,k_is_def_eq_structure_tree,435,256,13,8,0,0,2,3328,156672 +legacy-environment-ungrouped,k_is_def_eq_structure_tree_app,436,256,18,10,0,0,2,4608,199680 +legacy-environment-ungrouped,k_is_def_eq_struct_bounded,437,2048,45,12,0,0,2,92160,4147200 +legacy-environment-ungrouped,k_is_def_eq_struct_spend,438,1024,23,12,0,0,2,23552,1210368 +legacy-environment-ungrouped,slow2_eager_fallback,439,128,29,20,0,0,2,3712,144000 +legacy-environment-ungrouped,try_eta_struct,440,512,59,28,0,0,2,30208,1264128 +legacy-environment-ungrouped,compare_struct_fields,441,16,17,10,0,0,2,272,6144 +legacy-environment-ungrouped,compute_iprj_addr,442,8,15,6,0,0,2,120,1896 +legacy-environment-ungrouped,try_eta_swap,443,64,18,8,0,0,2,1152,35328 +legacy-environment-ungrouped,try_unit_like,444,256,12,12,0,0,2,3072,175104 +legacy-environment-ungrouped,is_unit_like_type,445,32,42,14,0,0,2,1344,29184 +legacy-environment-ungrouped,try_proof_irrel,446,256,11,10,0,0,2,2816,156672 +legacy-environment-ungrouped,try_eta_expand,447,2,21,20,0,0,2,42,294 +legacy-environment-ungrouped,is_prop_type,448,128,13,12,0,0,2,1664,79488 +legacy-environment-ungrouped,k_is_def_eq_struct,449,64,6,4,0,0,1,384,14080 +legacy-environment-ungrouped,k_is_def_eq_struct_go,450,64,42,12,0,0,2,2688,67584 +legacy-environment-ungrouped,lazy_delta_loop,451,1024,26,10,0,0,2,26624,1241088 +legacy-environment-ungrouped,delta_rank,452,64,16,2,0,0,2,1024,26112 +legacy-environment-ungrouped,lazy_delta_step_const_const,453,256,62,44,0,0,2,15872,678912 +legacy-environment-ungrouped,unfold_a_and_loop,454,64,13,8,0,0,2,832,29568 +legacy-environment-ungrouped,unfold_b_and_loop,455,128,13,8,0,0,2,1664,68736 +legacy-environment-ungrouped,unfold_both_and_loop,456,64,17,12,0,0,2,1088,38784 +legacy-environment-ungrouped,lazy_delta_a_const_b_proj,457,256,33,14,0,0,2,8448,316416 +legacy-environment-ungrouped,lazy_delta_b_const_a_proj,458,256,33,14,0,0,2,8448,316416 +legacy-environment-ungrouped,lazy_delta_both_proj,459,256,17,8,0,0,2,4352,181248 +legacy-environment-ungrouped,is_defn_or_thm,460,128,18,2,0,0,2,2304,66048 +legacy-environment-ungrouped,try_unfold_proj_app,461,512,24,18,0,0,2,12288,642048 +legacy-environment-ungrouped,delta_unfold,462,512,27,14,0,0,2,13824,628224 +legacy-environment-ungrouped,try_lazy_delta_app,463,32,48,20,0,0,2,1536,34944 +legacy-environment-ungrouped,head_addr,464,1024,12,8,0,0,2,12288,749568 +legacy-environment-ungrouped,try_unfold_head,465,256,23,6,0,0,2,5888,205824 +legacy-environment-ungrouped,k_infer,466,8192,8,8,0,0,2,65536,6488064 +legacy-environment-ungrouped,k_infer_rebase,467,8192,15,18,0,0,2,122880,11919360 +legacy-environment-ungrouped,k_infer_core,468,8192,33,16,0,0,2,270336,17031168 +legacy-environment-ungrouped,k_infer_let_start,469,16,11,8,0,0,2,176,4608 +legacy-environment-ungrouped,infer_let_lookup_type,470,128,16,6,0,0,2,2048,71424 +legacy-environment-ungrouped,infer_let_lookup_value,471,256,16,6,0,0,2,4096,162816 +legacy-environment-ungrouped,infer_let_materialize,472,1024,27,16,0,0,2,27648,1456128 +legacy-environment-ungrouped,k_infer_let_env,473,512,20,12,0,0,2,10240,503808 +legacy-environment-ungrouped,infer_let_local_cutoff,474,64,13,6,0,0,2,832,27264 +legacy-environment-ungrouped,k_infer_let_env_rebase,475,64,14,8,0,0,2,896,30720 +legacy-environment-ungrouped,infer_let_drop_unused,476,128,16,6,0,0,2,2048,71424 +legacy-environment-ungrouped,k_infer_let_env_core,477,512,28,22,0,0,2,14336,752640 +legacy-environment-ungrouped,k_infer_app_spine_loop,478,8192,33,22,0,0,2,270336,18948096 +legacy-environment-ungrouped,k_infer_lit,479,32,8,8,0,0,2,256,9984 +legacy-environment-ungrouped,is_inductive_prop,480,64,14,12,0,0,2,896,35328 +legacy-environment-ungrouped,peel_n_alls_whnf,481,128,15,10,0,0,2,1920,79488 +legacy-environment-ungrouped,check_prop_field_if_prop,482,64,10,8,0,0,2,640,26112 +legacy-environment-ungrouped,check_no_dep_data_field_if_prop,483,1,14,10,0,0,2,14,84 +legacy-environment-ungrouped,peel_field_loop,484,64,18,12,0,0,2,1152,39936 +legacy-environment-ungrouped,k_infer_proj,485,64,44,26,0,0,2,2816,86016 +legacy-environment-ungrouped,k_ensure_sort,486,4096,10,8,0,0,2,40960,3293184 +legacy-environment-ungrouped,k_check,487,4096,7,6,0,0,1,28672,2228224 +legacy-environment-ungrouped,nat_dec_le_addr_dec,488,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,nat_dec_eq_addr_dec,489,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,nat_dec_lt_addr_dec,490,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,decidable_is_true_addr_dec,491,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,decidable_is_false_addr_dec,492,0,3,4,0,0,1,0,0 +legacy-environment-ungrouped,nat_le_of_ble_eq_true_addr_dec,493,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,nat_not_le_of_not_ble_eq_true_addr_dec,494,0,3,4,0,0,1,0,0 +legacy-environment-ungrouped,nat_eq_of_beq_eq_true_addr_dec,495,0,3,4,0,0,1,0,0 +legacy-environment-ungrouped,nat_ne_of_beq_eq_false_addr_dec,496,0,3,4,0,0,1,0,0 +legacy-environment-ungrouped,bool_type_addr_dec,497,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,eq_refl_addr_dec,498,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,int_dec_eq_addr_dec,499,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,int_dec_le_addr_dec,500,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,int_dec_lt_addr_dec,501,1,3,4,0,0,1,3,27 +legacy-environment-ungrouped,is_dec_prim_addr,502,128,27,26,0,0,2,3456,154752 +legacy-environment-ungrouped,is_int_dec_prim_addr,503,2,15,14,0,0,2,30,222 +legacy-environment-ungrouped,try_extract_int,504,0,27,18,0,0,2,0,0 +legacy-environment-ungrouped,intern_int_lit,505,0,13,12,0,0,2,0,0 +legacy-environment-ungrouped,try_normalize_int_decidable,506,0,28,26,0,0,2,0,0 +legacy-environment-ungrouped,normalize_int_dec_rebuild,507,0,25,24,0,0,2,0,0 +legacy-environment-ungrouped,try_dec_dispatch,508,16,28,32,0,0,2,448,12480 +legacy-environment-ungrouped,dec_rewrite_lt_to_le,509,8,19,26,0,0,2,152,3624 +legacy-environment-ungrouped,dec_dispatch_le_eq,510,8,25,18,0,0,2,200,3480 +legacy-environment-ungrouped,dec_build_proof,511,4,46,42,0,0,2,184,2256 +legacy-environment-ungrouped,try_str_dec_eq,512,0,33,28,0,0,2,0,0 +legacy-environment-ungrouped,str_dec_eq_build,513,0,41,66,0,0,2,0,0 +legacy-environment-ungrouped,dec_finish,514,4,36,44,0,0,2,144,2064 +legacy-environment-ungrouped,canon_ord_cmp_g,515,0,13,14,0,0,2,0,0 +legacy-environment-ungrouped,canon_ord_then,516,0,6,2,0,0,2,0,0 +legacy-environment-ungrouped,canon_sord_lt_strong,517,0,2,2,0,0,1,0,0 +legacy-environment-ungrouped,canon_sord_eq_strong,518,0,2,2,0,0,1,0,0 +legacy-environment-ungrouped,canon_sord_gt_strong,519,0,2,2,0,0,1,0,0 +legacy-environment-ungrouped,canon_sord_then,520,0,8,2,0,0,2,0,0 +legacy-environment-ungrouped,canon_sord_of_g,521,0,3,2,0,0,1,0,0 +legacy-environment-ungrouped,canon_addr_cmp,522,0,83,18,0,0,2,0,0 +legacy-environment-ungrouped,canon_addr_chunk,523,0,11,4,0,0,1,0,0 +legacy-environment-ungrouped,canon_ctx_class_idx,524,0,13,8,0,0,2,0,0 +legacy-environment-ungrouped,canon_ctx_cmp_addr,525,0,16,12,0,0,2,0,0 +legacy-environment-ungrouped,canon_cmp_kuniv,526,0,28,12,0,0,2,0,0 +legacy-environment-ungrouped,canon_cmp_kuniv_list,527,0,16,12,0,0,2,0,0 +legacy-environment-ungrouped,canon_cmp_kliteral,528,0,10,4,0,0,2,0,0 +legacy-environment-ungrouped,canon_cmp_klimbs,529,0,11,14,0,0,2,0,0 +legacy-environment-ungrouped,canon_cmp_klimbs_tail,530,0,28,12,0,0,2,0,0 +legacy-environment-ungrouped,canon_cmp_u64_lex,531,0,33,16,0,0,2,0,0 +legacy-environment-ungrouped,canon_cmp_bytes,532,0,16,12,0,0,2,0,0 +legacy-environment-ungrouped,canon_cmp_kexpr_ctx,533,0,17,8,0,0,2,0,0 +legacy-environment-ungrouped,canon_cmp_kexpr_node_ctx,534,0,61,14,0,0,2,0,0 +legacy-environment-ungrouped,canon_cmp_krec_rule_ctx,535,0,16,10,0,0,2,0,0 +legacy-environment-ungrouped,canon_cmp_krec_rule_list_ctx,536,0,24,12,0,0,2,0,0 +legacy-environment-ungrouped,canon_kind_ord,537,0,21,2,0,0,2,0,0 +legacy-environment-ungrouped,canon_cmp_member_ctx,538,0,34,10,0,0,2,0,0 +legacy-environment-ungrouped,canon_cmp_member_same_kind_ctx,539,0,70,44,0,0,2,0,0 +legacy-environment-ungrouped,canon_cmp_ctor_range_ctx,540,0,43,16,0,0,2,0,0 +legacy-environment-ungrouped,canon_cmp_ctor_pair_ctx,541,0,51,28,0,0,2,0,0 +legacy-environment-ungrouped,canon_cprj_addr,542,1,24,6,0,0,2,24,102 +legacy-environment-ungrouped,canon_member_ci,543,0,18,4,0,0,2,0,0 +legacy-environment-ungrouped,canon_member_num_ctors,544,0,18,4,0,0,2,0,0 +legacy-environment-ungrouped,canon_build_ctx_classes,545,0,15,10,0,0,2,0,0 +legacy-environment-ungrouped,canon_build_ctx_members,546,0,26,28,0,0,2,0,0 +legacy-environment-ungrouped,canon_ctor_ctx_entries,547,0,12,8,0,0,2,0,0 +legacy-environment-ungrouped,canon_sort_loop,548,0,15,12,0,0,2,0,0 +legacy-environment-ungrouped,canon_refine_classes,549,0,12,10,0,0,2,0,0 +legacy-environment-ungrouped,canon_refine_one,550,0,12,8,0,0,2,0,0 +legacy-environment-ungrouped,canon_ins_sort,551,0,11,8,0,0,2,0,0 +legacy-environment-ungrouped,canon_insert_sorted,552,0,40,14,0,0,2,0,0 +legacy-environment-ungrouped,canon_group_consec,553,0,12,10,0,0,2,0,0 +legacy-environment-ungrouped,canon_group_walk,554,0,43,18,0,0,2,0,0 +legacy-environment-ungrouped,canon_classes_eq,555,0,17,10,0,0,2,0,0 +legacy-environment-ungrouped,canon_flatten,556,0,9,8,0,0,2,0,0 +legacy-environment-ungrouped,canon_all_singleton,557,0,10,8,0,0,2,0,0 +legacy-environment-ungrouped,canon_indc_positions,558,32,55,8,0,0,2,1760,32544 +legacy-environment-ungrouped,canon_muts_has_kind,559,64,59,6,0,0,2,3776,80256 +legacy-environment-ungrouped,check_canonical_block,560,64,73,40,0,0,2,4672,135552 +legacy-environment-ungrouped,is_unsafe_ci,561,512,23,2,0,0,2,11776,407040 +legacy-environment-ungrouped,safe_refs_only,562,8192,29,10,0,0,2,237568,13836288 +legacy-environment-ungrouped,assert_safety,563,512,7,4,0,0,2,3584,213504 +legacy-environment-ungrouped,validate_univ_params_seen,564,32,17,16,0,0,2,544,18144 +legacy-environment-ungrouped,validate_univ_params_list,565,64,8,8,0,0,2,512,23808 +legacy-environment-ungrouped,validate_expr_well_scoped,566,16384,32,16,0,0,2,524288,35979264 +legacy-environment-ungrouped,quot_type_addr,567,0,3,4,0,0,1,0,0 +legacy-environment-ungrouped,eq_type_addr,568,0,3,4,0,0,1,0,0 +legacy-environment-ungrouped,count_foralls_at_least,569,0,13,6,0,0,2,0,0 +legacy-environment-ungrouped,check_eq_type,570,0,16,8,0,0,2,0,0 +legacy-environment-ungrouped,check_quot,571,0,15,10,0,0,2,0,0 +legacy-environment-ungrouped,peel_n_foralls,572,512,11,6,0,0,2,5632,296448 +legacy-environment-ungrouped,assert_lvls_are_params,573,16,13,8,0,0,2,208,4992 +legacy-environment-ungrouped,assert_first_args_are_param_bvars,574,64,15,8,0,0,2,960,31872 +legacy-environment-ungrouped,assert_return_head_is_parent,575,32,19,8,0,0,2,608,15264 +legacy-environment-ungrouped,check_ctor_return_type,576,64,21,24,0,0,2,1344,57216 +legacy-environment-ungrouped,check_param_agreement_go,577,128,18,12,0,0,2,2304,92928 +legacy-environment-ungrouped,check_param_agreement,578,64,6,6,0,0,1,384,16384 +legacy-environment-ungrouped,get_result_sort_level,579,64,14,10,0,0,2,896,33024 +legacy-environment-ungrouped,check_field_universes_inner,580,64,13,12,0,0,2,832,34176 +legacy-environment-ungrouped,check_field_universes_skip_params,581,64,13,8,0,0,2,832,29568 +legacy-environment-ungrouped,check_field_universes,582,64,11,8,0,0,2,704,27264 +legacy-environment-ungrouped,addr_list_contains,583,64,12,8,0,0,2,768,28416 +legacy-environment-ungrouped,caddr_is_peer,584,64,19,8,0,0,2,1216,36480 +legacy-environment-ungrouped,expr_mentions_block,585,256,26,10,0,0,2,6656,248832 +legacy-environment-ungrouped,list_any_mentions_block,586,64,12,8,0,0,2,768,28416 +legacy-environment-ungrouped,peel_n_foralls_with_types,587,128,15,8,0,0,2,1920,74112 +legacy-environment-ungrouped,assert_occ_param_bvars,588,8,15,8,0,0,2,120,2040 +legacy-environment-ungrouped,check_valid_ind_app,589,4,23,16,0,0,2,92,1080 +legacy-environment-ungrouped,check_positivity_aug,590,64,44,30,0,0,2,2816,90624 +legacy-environment-ungrouped,check_nested_ctors_positivity,591,0,28,16,0,0,2,0,0 +legacy-environment-ungrouped,check_positivity_fields,592,128,12,10,0,0,2,1536,71424 +legacy-environment-ungrouped,check_positivity,593,64,10,6,0,0,2,640,23808 +legacy-environment-ungrouped,check_inductive_shape,594,32,12,4,0,0,2,384,9984 +legacy-environment-ungrouped,check_inductive_shape_ctors,595,64,31,20,0,0,2,1984,64128 +legacy-environment-ungrouped,check_parent_inductive_shape,596,16,16,4,0,0,2,256,4800 +legacy-environment-ungrouped,check_block_peer_param_agreement,597,32,69,8,0,0,2,2208,39264 +legacy-environment-ungrouped,peer_agree_walk,598,64,80,20,0,0,2,5120,120576 +legacy-environment-ungrouped,is_large_eliminator,599,8,32,8,0,0,2,256,3264 +legacy-environment-ungrouped,check_large_prop_ctor,600,4,15,8,0,0,2,60,696 +legacy-environment-ungrouped,check_large_walk_fields,601,4,24,16,0,0,2,96,1104 +legacy-environment-ungrouped,all_bvars_in_args,602,1,12,8,0,0,2,12,72 +legacy-environment-ungrouped,args_contain_bvar,603,0,16,8,0,0,2,0,0 +legacy-environment-ungrouped,compute_k_target,604,16,42,16,0,0,2,672,12096 +legacy-environment-ungrouped,ind_is_solo,605,16,57,8,0,0,2,912,13440 +legacy-environment-ungrouped,is_muts_block,606,32,53,4,0,0,2,1696,29664 +legacy-environment-ungrouped,muts_indc_count_is_one,607,16,56,6,0,0,2,896,12864 +legacy-environment-ungrouped,rec_to_parent_addr,608,16,18,10,0,0,2,288,6336 +legacy-environment-ungrouped,extract_aux_occ_us,609,0,30,12,0,0,2,0,0 +legacy-environment-ungrouped,extract_aux_spec_params,610,0,17,12,0,0,2,0,0 +legacy-environment-ungrouped,spec_params_lower,611,0,12,12,0,0,2,0,0 +legacy-environment-ungrouped,build_param_lvls_range,612,4,10,8,0,0,2,40,576 +legacy-environment-ungrouped,flat_originals_walk,613,32,78,18,0,0,2,2496,48384 +legacy-environment-ungrouped,aux_already_in,614,0,19,10,0,0,2,0,0 +legacy-environment-ungrouped,kexpr_struct_eq,615,0,43,12,0,0,2,0,0 +legacy-environment-ungrouped,level_list_struct_eq,616,0,16,10,0,0,2,0,0 +legacy-environment-ungrouped,spec_params_ptr_eq,617,0,16,10,0,0,2,0,0 +legacy-environment-ungrouped,extract_aux_spec_params_from_rec,618,0,18,4,0,0,2,0,0 +legacy-environment-ungrouped,first_recr_parent_block,619,0,87,16,0,0,2,0,0 +legacy-environment-ungrouped,build_flat_block,620,16,131,24,0,0,2,2096,30720 +legacy-environment-ungrouped,detect_aux_from_recrs_ex,621,0,56,6,0,0,2,0,0 +legacy-environment-ungrouped,aux_from_recrs_walk_ex,622,0,106,28,0,0,2,0,0 +legacy-environment-ungrouped,flat_find_pos,623,0,17,8,0,0,2,0,0 +legacy-environment-ungrouped,flat_find_pos_kind,624,16,29,10,0,0,2,464,8448 +legacy-environment-ungrouped,flat_member_at,625,16,17,8,0,0,2,272,5760 +legacy-environment-ungrouped,subst_param_for,626,4,18,18,0,0,2,72,1008 +legacy-environment-ungrouped,peel_motive_params_subst,627,32,17,10,0,0,2,544,15264 +legacy-environment-ungrouped,collect_index_doms,628,16,21,14,0,0,2,336,7680 +legacy-environment-ungrouped,build_major_params,629,32,11,8,0,0,2,352,11424 +legacy-environment-ungrouped,apply_spec_params_lifted,630,0,12,10,0,0,2,0,0 +legacy-environment-ungrouped,build_apply_xs,631,64,10,8,0,0,2,640,26112 +legacy-environment-ungrouped,wrap_foralls,632,256,10,8,0,0,2,2560,138240 +legacy-environment-ungrouped,collect_n_doms_whnf,633,32,22,14,0,0,2,704,19584 +legacy-environment-ungrouped,list_lift_indices,634,16,12,10,0,0,2,192,5184 +legacy-environment-ungrouped,apply_indices_in_conclusion,635,16,10,8,0,0,2,160,4416 +legacy-environment-ungrouped,build_motive_type_flat,636,16,24,20,0,0,2,384,9408 +legacy-environment-ungrouped,build_all_motives,637,16,6,4,0,0,1,96,2368 +legacy-environment-ungrouped,build_motive_apps,638,128,11,8,0,0,2,1408,63360 +legacy-environment-ungrouped,wrap_lams,639,4,10,8,0,0,2,40,576 +legacy-environment-ungrouped,build_rec_type,640,16,31,10,0,0,2,496,8832 +legacy-environment-ungrouped,build_rec_type_from,641,16,58,54,0,0,2,928,22464 +legacy-environment-ungrouped,check_recursor_canonical_full,642,16,86,38,0,0,2,1376,24768 +legacy-environment-ungrouped,canonical_rules_at_pos,643,16,32,12,0,0,2,512,9408 +legacy-environment-ungrouped,ctors_before_pos,644,16,32,10,0,0,2,512,9024 +legacy-environment-ungrouped,populate_rules,645,32,36,12,0,0,2,1152,25344 +legacy-environment-ungrouped,compare_rules,646,32,46,30,0,0,2,1472,38784 +legacy-environment-ungrouped,apply_ihs_full,647,32,44,52,0,0,2,1408,48384 +legacy-environment-ungrouped,build_rule_rhs,648,32,27,10,0,0,2,864,20064 +legacy-environment-ungrouped,build_peer_recs,649,32,15,10,0,0,2,480,14304 +legacy-environment-ungrouped,find_peer_recursor_with_spec,650,16,57,6,0,0,2,912,13056 +legacy-environment-ungrouped,find_peer_rec_spec_walk,651,0,103,24,0,0,2,0,0 +legacy-environment-ungrouped,build_flat_own_params,652,16,29,12,0,0,2,464,8832 +legacy-environment-ungrouped,projection_addr_ctor,653,32,24,6,0,0,2,768,16704 +legacy-environment-ungrouped,build_minor_doms,654,32,36,14,0,0,2,1152,26304 +legacy-environment-ungrouped,build_all_minors,655,16,8,4,0,0,1,128,2752 +legacy-environment-ungrouped,build_all_minors_walk,656,32,35,16,0,0,2,1120,26784 +legacy-environment-ungrouped,ctor_subst_param_for,657,16,19,20,0,0,2,304,8448 +legacy-environment-ungrouped,count_foralls_body,658,32,10,6,0,0,2,320,9984 +legacy-environment-ungrouped,peel_ctor_params_subst,659,128,26,16,0,0,2,3328,125184 +legacy-environment-ungrouped,build_minor_at_depth,660,32,37,20,0,0,2,1184,29664 +legacy-environment-ungrouped,peel_leading_foralls,661,8,7,4,0,0,2,56,1176 +legacy-environment-ungrouped,peel_leading_foralls_acc,662,8,12,8,0,0,2,96,1824 +legacy-environment-ungrouped,build_ih_doms,663,32,34,40,0,0,2,1088,37824 +legacy-environment-ungrouped,list_lift_each,664,16,12,10,0,0,2,192,5184 +legacy-environment-ungrouped,build_apply_field_bvars,665,64,11,8,0,0,2,704,27264 +legacy-environment-ungrouped,build_ctor_app_params,666,32,11,4,0,0,2,352,9504 +legacy-environment-ungrouped,is_rec_field,667,32,7,4,0,0,1,224,6368 +legacy-environment-ungrouped,is_rec_field_peel,668,64,22,14,0,0,2,1408,46848 +legacy-environment-ungrouped,flat_find_matching,669,32,25,10,0,0,2,800,19104 +legacy-environment-ungrouped,spec_params_dom_prefix_match,670,0,17,12,0,0,2,0,0 +legacy-environment-ungrouped,walk_fields_classify,671,128,24,14,0,0,2,3072,114432 +legacy-environment-ungrouped,build_all_motives_walk,672,32,31,16,0,0,2,992,24864 +legacy-environment-ungrouped,check_recursor_member,673,16,40,28,0,0,2,640,14016 +legacy-environment-ungrouped,check_rec_major_spine,674,16,16,10,0,0,2,256,5952 +legacy-environment-ungrouped,build_rec_lvls_list,675,8,9,8,0,0,2,72,1608 +legacy-environment-ungrouped,check_rec_rules_wellscoped,676,32,11,8,0,0,2,352,11424 +legacy-environment-ungrouped,peel_n_lams_collect,677,128,17,8,0,0,2,2176,79488 +legacy-environment-ungrouped,check_const,678,512,42,30,0,0,2,21504,1056768 +legacy-environment-ungrouped,run_check,679,512,16,4,0,0,2,8192,337920 +legacy-environment-ungrouped,const_idxs_expr,680,8192,34,14,0,0,2,278528,16711680 +legacy-environment-ungrouped,const_idxs_exprs,681,2048,10,10,0,0,2,20480,1646592 +legacy-environment-ungrouped,const_idxs_rules,682,32,18,10,0,0,2,576,15744 +legacy-environment-ungrouped,const_idxs_ctors,683,64,43,10,0,0,2,2752,66432 +legacy-environment-ungrouped,const_idxs_muts,684,32,58,14,0,0,2,1856,36864 +legacy-environment-ungrouped,const_idxs_of,685,512,61,12,0,0,2,31232,1070592 +legacy-environment-ungrouped,g_list_has,686,16384,11,6,0,0,2,180224,14647296 +legacy-environment-ungrouped,run_check_transitive,687,0,63,12,0,0,2,0,0 +legacy-environment-ungrouped,walk_refs_transitive,688,0,13,10,0,0,2,0,0 +legacy-environment-ungrouped,check_muts_all,689,64,54,8,0,0,2,3456,76800 +legacy-environment-ungrouped,check_muts_member_at,690,32,64,6,0,0,2,2048,35904 +legacy-environment-ungrouped,leaf_hash,691,512,7,6,0,0,2,3584,241152 +legacy-environment-ungrouped,node_hash,692,512,9,6,0,0,2,4608,268800 +legacy-environment-ungrouped,parse_atree_body,693,1024,15,12,0,0,2,15360,964608 +legacy-environment-ungrouped,load_assumption_tree,694,1,78,8,0,0,2,78,270 +legacy-environment-ungrouped,addr_set_build,695,0,25,8,0,0,2,0,0 +legacy-environment-ungrouped,addr_set_member,696,0,10,4,0,0,1,0,0 +legacy-environment-ungrouped,env_walk,697,0,82,16,0,0,2,0,0 +legacy-environment-ungrouped,env_walk_refs,698,0,26,10,0,0,2,0,0 +legacy-environment-ungrouped,env_walk_leaves,699,0,19,8,0,0,2,0,0 +legacy-environment-ungrouped,run_check_env,700,1,20,12,0,0,2,20,108 +legacy-environment-ungrouped,walk_leaves_owned,701,512,39,10,0,0,2,19968,738816 +legacy-environment-ungrouped,check_owned,702,512,35,6,0,0,1,17920,596480 +legacy-environment-ungrouped,env_walk_all,703,512,90,14,0,0,2,46080,1499136 +legacy-environment-ungrouped,env_walk_refs_all,704,4096,44,12,0,0,2,180224,8896512 +legacy-environment-ungrouped,get_opt_addr,705,1,8,6,0,0,2,8,54 +legacy-environment-ungrouped,get_opt_u64_masked,706,0,15,4,0,0,2,0,0 +legacy-environment-ungrouped,get_opt_addr_masked,707,0,8,4,0,0,2,0,0 +legacy-environment-ungrouped,get_opt_bool_masked,708,0,8,4,0,0,2,0,0 +legacy-environment-ungrouped,get_opt_def_kind_masked,709,0,10,4,0,0,2,0,0 +legacy-environment-ungrouped,get_opt_quot_kind_masked,710,0,11,4,0,0,2,0,0 +legacy-environment-ungrouped,get_reveal_rule_list_inner,711,0,43,12,0,0,2,0,0 +legacy-environment-ungrouped,get_opt_rule_list_masked,712,0,17,6,0,0,2,0,0 +legacy-environment-ungrouped,get_reveal_ctor_info,713,0,66,10,0,0,2,0,0 +legacy-environment-ungrouped,get_ctor_entry,714,0,53,6,0,0,1,0,0 +legacy-environment-ungrouped,get_ctor_entry_list_inner,715,0,74,12,0,0,2,0,0 +legacy-environment-ungrouped,get_opt_ctor_entry_list_masked,716,0,17,6,0,0,2,0,0 +legacy-environment-ungrouped,get_reveal_mut_const_info,717,0,94,28,0,0,2,0,0 +legacy-environment-ungrouped,get_mut_entry,718,0,67,6,0,0,1,0,0 +legacy-environment-ungrouped,get_mut_entry_list_inner,719,0,88,12,0,0,2,0,0 +legacy-environment-ungrouped,get_reveal_info,720,0,102,28,0,0,2,0,0 +legacy-environment-ungrouped,expr_addr,721,0,24,6,0,0,2,0,0 +legacy-environment-ungrouped,def_safety_tag,722,0,5,2,0,0,2,0,0 +legacy-environment-ungrouped,check_opt_def_kind,723,0,8,6,0,0,2,0,0 +legacy-environment-ungrouped,check_opt_def_safety,724,0,8,6,0,0,2,0,0 +legacy-environment-ungrouped,check_opt_quot_kind,725,0,8,6,0,0,2,0,0 +legacy-environment-ungrouped,check_opt_bool,726,0,6,2,0,0,2,0,0 +legacy-environment-ungrouped,check_opt_u64,727,0,20,2,0,0,2,0,0 +legacy-environment-ungrouped,check_opt_addr,728,0,70,6,0,0,2,0,0 +legacy-environment-ungrouped,check_opt_expr_addr,729,0,71,8,0,0,2,0,0 +legacy-environment-ungrouped,check_recr_rules,730,0,51,12,0,0,2,0,0 +legacy-environment-ungrouped,check_opt_recr_rules,731,0,6,4,0,0,2,0,0 +legacy-environment-ungrouped,check_ctor_entry,732,0,85,16,0,0,2,0,0 +legacy-environment-ungrouped,check_ctor_entries,733,0,55,8,0,0,2,0,0 +legacy-environment-ungrouped,check_opt_ctor_entries,734,0,6,4,0,0,2,0,0 +legacy-environment-ungrouped,check_mut_const,735,0,103,20,0,0,2,0,0 +legacy-environment-ungrouped,check_muts_components,736,0,114,10,0,0,2,0,0 +legacy-environment-ungrouped,run_reveal,737,0,113,22,0,0,2,0,0 +legacy-environment-ungrouped,run_contains,738,0,6,6,0,0,1,0,0 +legacy-environment-ungrouped,run_claim,739,1,130,34,0,0,2,130,504 +legacy-environment-ungrouped,eval_nf,740,0,15,14,0,0,2,0,0 +legacy-environment-ungrouped,eval_nf_spine,741,0,13,10,0,0,2,0,0 +legacy-environment-ungrouped,eval_body,742,0,19,8,0,0,2,0,0 +legacy-environment-ungrouped,eval_output,743,0,57,12,0,0,2,0,0 +legacy-environment-ungrouped,run_eval,744,0,22,20,0,0,2,0,0 +legacy-environment-ungrouped,verify_claim,745,1,10,4,0,0,1,10,48 +legacy-environment-ungrouped,list_lookup_or_default.Ptr.U8_32,746,8,10,6,0,0,2,80,1536 +legacy-environment-ungrouped,list_snoc.G,747,16384,10,8,0,0,2,163840,15335424 +legacy-environment-ungrouped,list_length_u64.U8_8,748,0,30,8,0,0,2,0,0 +legacy-environment-ungrouped,list_concat.Tup.Ptr.U8_32.G,749,0,11,8,0,0,2,0,0 +legacy-environment-ungrouped,list_length_u64.Ptr.U8_32,750,1,23,8,0,0,2,23,105 +legacy-environment-ungrouped,rbtree_map_lookup_or_default.G,751,0,34,20,0,0,2,0,0 +legacy-environment-ungrouped,list_reverse.G,752,32,5,6,0,0,1,160,6368 +legacy-environment-ungrouped,list_concat.Ptr.KExprNode,753,16384,10,8,0,0,2,163840,15335424 +legacy-environment-ungrouped,list_length.Ptr.KExprNode,754,8192,8,6,0,0,2,65536,5849088 +legacy-environment-ungrouped,list_length_u64.Constructor,755,0,56,8,0,0,2,0,0 +legacy-environment-ungrouped,list_lookup.Ptr.KLevelNode,756,8192,8,6,0,0,2,65536,5849088 +legacy-environment-ungrouped,list_length.U8_8,757,0,15,6,0,0,2,0,0 +legacy-environment-ungrouped,list_lookup_u64.MutConst,758,0,113,10,0,0,2,0,0 +legacy-environment-ungrouped,list_length_u64.MutConst,759,0,67,8,0,0,2,0,0 +legacy-environment-ungrouped,list_length_u64.RecursorRule,760,0,31,8,0,0,2,0,0 +legacy-environment-ungrouped,list_lookup_u64.Constructor,761,0,91,10,0,0,2,0,0 +legacy-environment-ungrouped,list_is_empty.U8,762,2048,7,4,0,0,2,14336,1038336 +legacy-environment-ungrouped,list_snoc.Tup.Ptr.U8_32.G.Ptr.ListNode.Ptr.KExprNode.Ptr.ListNode.Ptr.KLevelNode,763,0,16,8,0,0,2,0,0 +legacy-environment-ungrouped,list_take.Ptr.KExprNode,764,2048,11,8,0,0,2,22528,1579008 +legacy-environment-ungrouped,list_drop.Ptr.Expr,765,16384,10,6,0,0,2,163840,13959168 +legacy-environment-ungrouped,list_length.KRecRule,766,32,10,6,0,0,2,320,9984 +legacy-environment-ungrouped,list_depth_checked.U8,767,131072,9,8,0,0,2,1179648,141950976 +legacy-environment-ungrouped,rbtree_map_insert.G,768,0,16,4,0,0,2,0,0 +legacy-environment-ungrouped,list_length.Tup.Ptr.U8_32.G.Ptr.ListNode.Ptr.KExprNode.Ptr.ListNode.Ptr.KLevelNode,769,16,11,6,0,0,2,176,4224 +legacy-environment-ungrouped,list_reverse_acc.G,770,64,10,8,0,0,2,640,26112 +legacy-environment-ungrouped,rbtree_map_ins.G,771,0,45,22,0,0,2,0,0 +legacy-environment-ungrouped,rbtree_map_balance.G,772,0,24,6,0,0,2,0,0 +legacy-environment-ungrouped,rbtree_map_balance_fix.G,773,0,102,16,0,0,2,0,0 +legacy-environment-ungrouped,ROM:2,774,8,5,6,0,0,2,40,1176 +legacy-environment-ungrouped,ROM:3,775,524288,6,6,0,0,2,3145728,484442112 +legacy-environment-ungrouped,ROM:4,776,32768,7,6,0,0,2,229376,25460736 +legacy-environment-ungrouped,ROM:5,777,128,8,6,0,0,2,1024,49920 +legacy-environment-ungrouped,ROM:6,778,16,9,6,0,0,2,144,3840 +legacy-environment-ungrouped,ROM:8,779,2,11,6,0,0,2,22,150 +legacy-environment-ungrouped,ROM:9,780,32,12,6,0,0,2,384,10944 +legacy-environment-ungrouped,ROM:10,781,64,13,6,0,0,2,832,27264 +legacy-environment-ungrouped,ROM:11,782,32,14,6,0,0,2,448,11904 +legacy-environment-ungrouped,ROM:12,783,512,15,6,0,0,2,7680,351744 +legacy-environment-ungrouped,ROM:18,784,8192,21,6,0,0,2,172032,10002432 +legacy-environment-ungrouped,ROM:19,785,0,22,6,0,0,2,0,0 +legacy-environment-ungrouped,ROM:32,786,4096,35,6,0,0,2,143360,6684672 +legacy-environment-ungrouped,ROM:34,787,2048,37,6,0,0,2,75776,3201024 +legacy-environment-ungrouped,ROM:36,788,64,39,6,0,0,2,2496,57216 +legacy-environment-ungrouped,ROM:47,789,32,50,6,0,0,2,1600,29184 +legacy-environment-ungrouped,ROM:50,790,0,53,6,0,0,2,0,0 +legacy-environment-ungrouped,ROM:64,791,0,67,6,0,0,2,0,0 +legacy-environment-ungrouped,Bytes1,792,256,3,6,11,256,1,768,68608 +legacy-environment-ungrouped,Bytes2,793,65536,8,8,11,65536,2,524288,63700992 +legacy-ixvm-grouped,ixvm_group_00,0,1024,33,14,0,0,2,33792,1579008 +legacy-ixvm-grouped,ixvm_group_01,1,16,119,40,0,0,2,1904,31488 +legacy-ixvm-grouped,address_eq,2,64,70,8,0,0,2,4480,95232 +legacy-ixvm-grouped,checked_depth_succ,3,1024,4,4,0,0,1,4096,311296 +legacy-ixvm-grouped,read_finite_byte_stream,4,16,7,4,0,0,1,112,2560 +legacy-ixvm-grouped,u64_is_zero,5,32,19,2,0,0,2,608,12384 +legacy-ixvm-grouped,ixvm_group_02,6,0,50,6,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_03,7,4,63,32,0,0,2,252,2424 +legacy-ixvm-grouped,ixvm_group_04,8,64,20,2,0,0,2,1280,30720 +legacy-ixvm-grouped,ixvm_group_05,9,32,106,16,0,0,2,3392,60864 +legacy-ixvm-grouped,ixvm_group_06,10,32,79,16,0,0,2,2528,47904 +legacy-ixvm-grouped,ixvm_group_07,11,8,202,34,0,0,2,1616,17376 +legacy-ixvm-grouped,ixvm_group_08,12,128,166,18,0,0,2,21248,506880 +legacy-ixvm-grouped,blake3_compress_chunks,13,4096,17,8,0,0,2,69632,4325376 +legacy-ixvm-grouped,bytes_to_block,14,64,195,130,0,0,2,12480,379776 +legacy-ixvm-grouped,pad_block,15,2048,8,6,0,0,2,16384,1241088 +legacy-ixvm-grouped,blake3_compress_block,16,32,161,26,0,0,2,5152,92064 +legacy-ixvm-grouped,blake3_compress,17,512,533,388,0,0,2,272896,12793344 +legacy-ixvm-grouped,ixvm_group_09,18,16,171,18,0,0,2,2736,37248 +legacy-ixvm-grouped,ixvm_group_10,19,8,63,14,0,0,2,504,5928 +legacy-ixvm-grouped,ixvm_group_11,20,32,56,10,0,0,2,1792,33984 +legacy-ixvm-grouped,ixvm_group_12,21,64,106,18,0,0,2,6784,148224 +legacy-ixvm-grouped,put_tagn_tail,22,0,26,10,0,0,2,0,0 +legacy-ixvm-grouped,put_tagn_wide,23,0,30,6,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_13,24,0,58,10,0,0,2,0,0 +legacy-ixvm-grouped,value_contract_code,25,0,10,2,0,0,2,0,0 +legacy-ixvm-grouped,binder_contract_code,26,0,11,4,0,0,2,0,0 +legacy-ixvm-grouped,put_lam_mode,27,0,8,6,0,0,1,0,0 +legacy-ixvm-grouped,ixvm_group_15,28,32,51,12,0,0,2,1632,32544 +legacy-ixvm-grouped,ixvm_group_16,29,64,114,22,0,0,2,7296,162048 +legacy-ixvm-grouped,ixvm_group_17,30,32,136,80,0,0,2,4352,105984 +legacy-ixvm-grouped,ixvm_group_14,31,0,42,8,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_18,32,0,101,12,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_19,33,4,103,20,0,0,2,412,3096 +legacy-ixvm-grouped,ixvm_group_20,34,4,57,18,0,0,2,228,1944 +legacy-ixvm-grouped,ixvm_group_21,35,0,219,66,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_22,36,8,92,16,0,0,2,736,8160 +legacy-ixvm-grouped,ixvm_group_23,37,4,45,10,0,0,2,180,1464 +legacy-ixvm-grouped,ixvm_group_24,38,128,20,8,0,0,2,2560,87552 +legacy-ixvm-grouped,get_u64_le,39,0,18,6,0,0,2,0,0 +legacy-ixvm-grouped,get_tagn4,40,512,24,8,0,0,2,12288,503808 +legacy-ixvm-grouped,ixvm_group_25,41,32,39,18,0,0,2,1248,29664 +legacy-ixvm-grouped,get_tagn0,42,256,17,8,0,0,2,4352,181248 +legacy-ixvm-grouped,get_tagn_tail,43,32,16,8,0,0,2,512,13824 +legacy-ixvm-grouped,get_tagn_wide,44,0,26,6,0,0,2,0,0 +legacy-ixvm-grouped,get_u64_list,45,128,33,12,0,0,2,4224,133248 +legacy-ixvm-grouped,get_app_telescope,46,256,27,12,0,0,2,6912,267264 +legacy-ixvm-grouped,value_contract_from_bits,47,1,10,2,0,0,2,10,48 +legacy-ixvm-grouped,binder_contract_from_bits,48,1,13,4,0,0,2,13,63 +legacy-ixvm-grouped,get_lam_mode,49,32,16,4,0,0,2,512,11904 +legacy-ixvm-grouped,get_all_mode,50,32,18,6,0,0,2,576,13824 +legacy-ixvm-grouped,ixvm_group_26,51,128,38,14,0,0,2,4864,152064 +legacy-ixvm-grouped,get_expr,52,512,49,12,0,0,2,25088,904704 +legacy-ixvm-grouped,ixvm_group_27,53,32,64,22,0,0,2,2048,43584 +legacy-ixvm-grouped,get_address,54,64,100,68,0,0,2,6400,198912 +legacy-ixvm-grouped,get_expr_list,55,64,26,12,0,0,2,1664,49152 +legacy-ixvm-grouped,ixvm_group_28,56,32,62,20,0,0,2,1984,41664 +legacy-ixvm-grouped,get_address_list,57,64,26,12,0,0,2,1664,49152 +legacy-ixvm-grouped,ixvm_group_30,58,32,52,4,0,0,2,1664,29184 +legacy-ixvm-grouped,ixvm_group_31,59,32,40,16,0,0,2,1280,29184 +legacy-ixvm-grouped,ixvm_group_32,60,0,89,20,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_33,61,32,106,12,0,0,2,3392,58944 +legacy-ixvm-grouped,ixvm_group_34,62,8,34,12,0,0,2,272,3696 +legacy-ixvm-grouped,ixvm_group_35,63,16,72,12,0,0,2,1152,17088 +legacy-ixvm-grouped,collect_spine,64,64,11,8,0,0,2,704,27264 +legacy-ixvm-grouped,ixvm_group_36,65,4,74,20,0,0,2,296,2400 +legacy-ixvm-grouped,klimbs_add_carry,66,0,49,14,0,0,2,0,0 +legacy-ixvm-grouped,klimbs_add,67,0,5,4,0,0,1,0,0 +legacy-ixvm-grouped,ixvm_group_37,68,0,79,32,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_38,69,4,40,20,0,0,2,160,1584 +legacy-ixvm-grouped,glimbs_to_klimbs_with_depth,70,0,18,18,0,0,2,0,0 +legacy-ixvm-grouped,klimbs_normalize,71,0,30,14,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_39,72,4,40,8,0,0,2,160,1296 +legacy-ixvm-grouped,klimbs_mul_outer,73,0,21,12,0,0,2,0,0 +legacy-ixvm-grouped,klimbs_mul_single,74,0,68,14,0,0,2,0,0 +legacy-ixvm-grouped,klimbs_shl_limbs,75,0,8,6,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_40,76,0,52,34,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_41,77,0,55,12,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_42,78,0,84,44,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_43,79,16,18,4,0,0,2,288,5184 +legacy-ixvm-grouped,ixvm_group_44,80,0,18,4,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_45,81,16,18,4,0,0,2,288,5184 +legacy-ixvm-grouped,ixvm_group_46,82,16,18,4,0,0,2,288,5184 +legacy-ixvm-grouped,ixvm_group_47,83,16,54,10,0,0,2,864,13248 +legacy-ixvm-grouped,ixvm_group_48,84,4,38,22,0,0,2,152,1584 +legacy-ixvm-grouped,ixvm_group_49,85,0,81,56,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_50,86,1,61,24,0,0,2,61,267 +legacy-ixvm-grouped,ixvm_group_51,87,8,32,14,0,0,2,256,3696 +legacy-ixvm-grouped,ixvm_group_52,88,0,89,34,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_53,89,2,55,32,0,0,2,110,570 +legacy-ixvm-grouped,ixvm_group_54,90,0,10,4,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_55,91,8,43,10,0,0,2,344,4200 +legacy-ixvm-grouped,ixvm_group_56,92,1,72,50,0,0,2,72,378 +legacy-ixvm-grouped,ixvm_group_57,93,1,15,8,0,0,2,15,81 +legacy-ixvm-grouped,ixvm_group_58,94,16,55,16,0,0,2,880,14592 +legacy-ixvm-grouped,ixvm_group_59,95,0,159,102,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_60,96,0,65,20,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_61,97,0,54,12,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_62,98,0,56,14,0,0,2,0,0 +legacy-ixvm-grouped,apply_spine_expr,99,8,10,8,0,0,2,80,1680 +legacy-ixvm-grouped,ixvm_group_63,100,0,100,52,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_64,101,16,44,14,0,0,2,704,12096 +legacy-ixvm-grouped,convert_expr,102,512,42,14,0,0,2,21504,835584 +legacy-ixvm-grouped,ixvm_group_65,103,32,28,10,0,0,2,896,20544 +legacy-ixvm-grouped,ixvm_group_66,104,8,88,48,0,0,2,704,10176 +legacy-ixvm-grouped,ixvm_group_67,105,0,53,12,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_68,106,2,53,12,0,0,2,106,438 +legacy-ixvm-grouped,ixvm_group_69,107,0,35,10,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_70,108,4,20,8,0,0,2,80,816 +legacy-ixvm-grouped,ixvm_group_71,109,16,20,12,0,0,2,320,7104 +legacy-ixvm-grouped,expr_inst_levels,110,64,10,6,0,0,2,640,23808 +legacy-ixvm-grouped,expr_inst_levels_walk,111,64,20,12,0,0,2,1280,42240 +legacy-ixvm-grouped,expr_lbr,112,128,19,12,0,0,2,2432,95616 +legacy-ixvm-grouped,has_bvar_in_range,113,64,31,28,0,0,2,1984,73344 +legacy-ixvm-grouped,ixvm_group_72,114,4,12,6,0,0,2,48,576 +legacy-ixvm-grouped,ixvm_group_73,115,2,26,20,0,0,2,52,324 +legacy-ixvm-grouped,ixvm_group_74,116,8,26,26,0,0,2,208,4128 +legacy-ixvm-grouped,expr_glb,117,64,9,8,0,0,2,576,24960 +legacy-ixvm-grouped,expr_glb_walk,118,64,22,10,0,0,2,1408,42240 +legacy-ixvm-grouped,expr_glb_binder,119,8,10,8,0,0,2,80,1680 +legacy-ixvm-grouped,expr_lift,120,16,11,8,0,0,2,176,4608 +legacy-ixvm-grouped,expr_lift_walk,121,1,20,10,0,0,2,20,102 +legacy-ixvm-grouped,expr_lower,122,32,11,8,0,0,2,352,11424 +legacy-ixvm-grouped,expr_lower_walk,123,16,25,18,0,0,2,400,9216 +legacy-ixvm-grouped,expr_has_bvar_at,124,32,22,8,0,0,2,704,16704 +legacy-ixvm-grouped,ixvm_group_75,125,8,11,6,0,0,2,88,1608 +legacy-ixvm-grouped,expr_inst1,126,16,12,10,0,0,2,192,5184 +legacy-ixvm-grouped,expr_inst1_walk,127,8,20,10,0,0,2,160,2544 +legacy-ixvm-grouped,expr_inst_many,128,64,15,12,0,0,2,960,36480 +legacy-ixvm-grouped,expr_inst_many_bvar,129,32,10,10,0,0,2,320,11904 +legacy-ixvm-grouped,expr_inst_many_walk,130,64,20,10,0,0,2,1280,39936 +legacy-ixvm-grouped,peel_beta,131,4,18,10,0,0,2,72,816 +legacy-ixvm-grouped,whnf_apply_beta,132,1,16,14,0,0,2,16,102 +legacy-ixvm-grouped,whnf_with_spine,133,4,20,10,0,0,2,80,864 +legacy-ixvm-grouped,ixvm_group_76,134,0,41,20,0,0,2,0,0 +legacy-ixvm-grouped,ixvm_group_77,135,1,98,76,0,0,2,98,534 +legacy-ixvm-grouped,try_prim_dispatch,136,1,20,8,0,0,2,20,96 +legacy-ixvm-grouped,whnf_const_head,137,0,53,20,0,0,2,0,0 +legacy-ixvm-grouped,whnf,138,8,22,12,0,0,2,176,2832 +legacy-ixvm-grouped,whnf_struct_core,139,8,22,12,0,0,2,176,2832 +legacy-ixvm-grouped,whnf_struct_core_spine,140,8,25,16,0,0,2,200,3336 +legacy-ixvm-grouped,ixvm_group_78,141,1,32,12,0,0,2,32,144 +legacy-ixvm-grouped,whnf_nd,142,4,22,12,0,0,2,88,960 +legacy-ixvm-grouped,whnf_nd_with_spine,143,8,20,10,0,0,2,160,2544 +legacy-ixvm-grouped,whnf_nd_apply_beta,144,1,16,14,0,0,2,16,102 +legacy-ixvm-grouped,whnf_nd_const_head,145,1,60,26,0,0,2,60,270 +legacy-ixvm-grouped,types_lookup,146,0,6,6,0,0,1,0,0 +legacy-ixvm-grouped,ixvm_group_79,147,16,29,2,0,0,2,464,6912 +legacy-ixvm-grouped,ixvm_group_80,148,4,70,30,0,0,2,280,2544 +legacy-ixvm-grouped,k_is_def_eq,149,16,13,12,0,0,2,208,5760 +legacy-ixvm-grouped,k_def_eq_rebase,150,2,18,22,0,0,2,36,288 +legacy-ixvm-grouped,ixvm_group_81,151,8,25,16,0,0,2,200,3336 +legacy-ixvm-grouped,try_def_eq_app,152,4,27,18,0,0,2,108,1224 +legacy-ixvm-grouped,de_args,153,0,18,10,0,0,2,0,0 +legacy-ixvm-grouped,is_nat_zero,154,2,12,8,0,0,2,24,168 +legacy-ixvm-grouped,nat_offset_of,155,2,36,18,0,0,2,72,372 +legacy-ixvm-grouped,try_string_lit_one,156,8,14,10,0,0,2,112,2112 +legacy-ixvm-grouped,ixvm_group_82,157,0,30,8,0,0,2,0,0 +legacy-ixvm-grouped,k_is_def_eq_struct_bounded,158,0,45,12,0,0,2,0,0 +legacy-ixvm-grouped,lazy_delta_loop,159,2,26,10,0,0,2,52,264 +legacy-ixvm-grouped,head_addr,160,2,12,8,0,0,2,24,168 +legacy-ixvm-grouped,k_infer,161,32,8,8,0,0,2,256,9984 +legacy-ixvm-grouped,k_infer_rebase,162,16,15,18,0,0,2,240,7296 +legacy-ixvm-grouped,k_infer_core,163,32,33,16,0,0,2,1056,25824 +legacy-ixvm-grouped,k_infer_let_start,164,0,11,8,0,0,2,0,0 +legacy-ixvm-grouped,infer_let_lookup_type,165,0,16,6,0,0,2,0,0 +legacy-ixvm-grouped,infer_let_lookup_value,166,0,16,6,0,0,2,0,0 +legacy-ixvm-grouped,infer_let_materialize,167,0,27,16,0,0,2,0,0 +legacy-ixvm-grouped,k_infer_let_env,168,0,20,12,0,0,2,0,0 +legacy-ixvm-grouped,infer_let_local_cutoff,169,0,13,6,0,0,2,0,0 +legacy-ixvm-grouped,k_infer_let_env_rebase,170,0,14,8,0,0,2,0,0 +legacy-ixvm-grouped,infer_let_drop_unused,171,0,16,6,0,0,2,0,0 +legacy-ixvm-grouped,k_infer_let_env_core,172,0,28,22,0,0,2,0,0 +legacy-ixvm-grouped,k_infer_app_spine_loop,173,32,33,22,0,0,2,1056,28704 +legacy-ixvm-grouped,k_ensure_sort,174,8,10,8,0,0,2,80,1680 +legacy-ixvm-grouped,k_check,175,16,7,6,0,0,1,112,2944 +legacy-ixvm-grouped,canon_cmp_kexpr_node_ctx,176,0,61,14,0,0,2,0,0 +legacy-ixvm-grouped,safe_refs_only,177,64,29,10,0,0,2,1856,50304 +legacy-ixvm-grouped,validate_expr_well_scoped,178,64,32,16,0,0,2,2048,60672 +legacy-ixvm-grouped,const_idxs_expr,179,64,34,14,0,0,2,2176,60672 +legacy-ixvm-grouped,const_idxs_exprs,180,8,10,10,0,0,2,80,1824 +legacy-ixvm-grouped,g_list_has,181,32,11,6,0,0,2,352,10464 +legacy-ixvm-grouped,walk_refs_transitive,182,0,13,10,0,0,2,0,0 +legacy-ixvm-grouped,walk_leaves_owned,183,0,39,10,0,0,2,0,0 +legacy-ixvm-grouped,check_owned,184,0,35,6,0,0,1,0,0 +legacy-ixvm-grouped,env_walk_all,185,0,90,14,0,0,2,0,0 +legacy-ixvm-grouped,env_walk_refs_all,186,0,44,12,0,0,2,0,0 +legacy-ixvm-grouped,eval_nf,187,0,15,14,0,0,2,0,0 +legacy-ixvm-grouped,eval_nf_spine,188,0,13,10,0,0,2,0,0 +legacy-ixvm-grouped,eval_body,189,0,19,8,0,0,2,0,0 +legacy-ixvm-grouped,eval_output,190,0,57,12,0,0,2,0,0 +legacy-ixvm-grouped,run_eval,191,0,22,20,0,0,2,0,0 +legacy-ixvm-grouped,verify_claim,192,1,10,4,0,0,1,10,48 +legacy-ixvm-grouped,list_snoc.G,193,64,10,8,0,0,2,640,26112 +legacy-ixvm-grouped,list_concat.Ptr.KExprNode,194,64,10,8,0,0,2,640,26112 +legacy-ixvm-grouped,list_length.Ptr.KExprNode,195,32,8,6,0,0,2,256,9024 +legacy-ixvm-grouped,list_lookup.Ptr.KLevelNode,196,128,8,6,0,0,2,1024,49920 +legacy-ixvm-grouped,list_is_empty.U8,197,32,7,4,0,0,2,224,7584 +legacy-ixvm-grouped,list_take.Ptr.KExprNode,198,2,11,8,0,0,2,22,162 +legacy-ixvm-grouped,list_drop.Ptr.Expr,199,256,10,6,0,0,2,2560,125952 +legacy-ixvm-grouped,list_depth_checked.U8,200,4096,9,8,0,0,2,36864,3145728 +legacy-ixvm-grouped,rbtree_map_balance_fix.G,201,16,102,16,0,0,2,1632,23616 +legacy-ixvm-grouped,ROM:2,202,0,5,6,0,0,2,0,0 +legacy-ixvm-grouped,ROM:3,203,8192,6,6,0,0,2,49152,5210112 +legacy-ixvm-grouped,ROM:4,204,512,7,6,0,0,2,3584,241152 +legacy-ixvm-grouped,ROM:5,205,0,8,6,0,0,2,0,0 +legacy-ixvm-grouped,ROM:6,206,32,9,6,0,0,2,288,9504 +legacy-ixvm-grouped,ROM:8,207,1,11,6,0,0,2,11,63 +legacy-ixvm-grouped,ROM:9,208,16,12,6,0,0,2,192,4416 +legacy-ixvm-grouped,ROM:10,209,16,13,6,0,0,2,208,4608 +legacy-ixvm-grouped,ROM:11,210,0,14,6,0,0,2,0,0 +legacy-ixvm-grouped,ROM:12,211,16,15,6,0,0,2,240,4992 +legacy-ixvm-grouped,ROM:18,212,512,21,6,0,0,2,10752,434688 +legacy-ixvm-grouped,ROM:19,213,0,22,6,0,0,2,0,0 +legacy-ixvm-grouped,ROM:32,214,128,35,6,0,0,2,4480,122496 +legacy-ixvm-grouped,ROM:34,215,32,37,6,0,0,2,1184,22944 +legacy-ixvm-grouped,ROM:36,216,4,39,6,0,0,2,156,1224 +legacy-ixvm-grouped,ROM:47,217,4,50,6,0,0,2,200,1488 +legacy-ixvm-grouped,ROM:50,218,0,53,6,0,0,2,0,0 +legacy-ixvm-grouped,ROM:64,219,0,67,6,0,0,2,0,0 +legacy-ixvm-grouped,Bytes1,220,256,3,6,11,256,1,768,68608 +legacy-ixvm-grouped,Bytes2,221,65536,8,8,11,65536,2,524288,63700992 +legacy-ixvm-ungrouped,memo_u32_less_than,0,1024,10,8,0,0,2,10240,688128 +legacy-ixvm-ungrouped,address_eq_tail,1,0,74,6,0,0,2,0,0 +legacy-ixvm-ungrouped,address_eq,2,64,70,8,0,0,2,4480,95232 +legacy-ixvm-ungrouped,checked_depth_succ,3,1024,4,4,0,0,1,4096,311296 +legacy-ixvm-ungrouped,read_finite_byte_stream,4,16,7,4,0,0,1,112,2560 +legacy-ixvm-ungrouped,u64_is_zero,5,32,19,2,0,0,2,608,12384 +legacy-ixvm-ungrouped,u64_eq,6,0,27,2,0,0,2,0,0 +legacy-ixvm-ungrouped,u64_add,7,0,33,16,0,0,2,0,0 +legacy-ixvm-ungrouped,relaxed_u64_succ,8,0,19,2,0,0,2,0,0 +legacy-ixvm-ungrouped,relaxed_u64_pred,9,32,19,2,0,0,2,608,12384 +legacy-ixvm-ungrouped,flatten_u64,10,32,10,2,0,0,1,320,6848 +legacy-ixvm-ungrouped,verify_bytes_against,11,16,72,8,0,0,2,1152,16320 +legacy-ixvm-ungrouped,bytes_to_addr,12,32,41,8,0,0,2,1312,25824 +legacy-ixvm-ungrouped,blake3_next_layer,13,0,175,12,0,0,2,0,0 +legacy-ixvm-ungrouped,blake3_compress_layer,14,32,141,12,0,0,2,4512,75744 +legacy-ixvm-ungrouped,blake3_compress_chunks,15,4096,17,8,0,0,2,69632,4325376 +legacy-ixvm-ungrouped,bytes_to_block,16,64,195,130,0,0,2,12480,379776 +legacy-ixvm-ungrouped,pad_block,17,2048,8,6,0,0,2,16384,1241088 +legacy-ixvm-ungrouped,blake3_finish,18,32,160,16,0,0,2,5120,86784 +legacy-ixvm-ungrouped,blake3_compress_block,19,32,161,26,0,0,2,5152,92064 +legacy-ixvm-ungrouped,blake3_compress,20,512,533,388,0,0,2,272896,12793344 +legacy-ixvm-ungrouped,put_expr,21,0,94,18,0,0,2,0,0 +legacy-ixvm-ungrouped,put_u64_le,22,0,16,6,0,0,2,0,0 +legacy-ixvm-ungrouped,put_tagn4,23,2,16,6,0,0,2,32,180 +legacy-ixvm-ungrouped,put_tagn2,24,0,16,6,0,0,2,0,0 +legacy-ixvm-ungrouped,put_tagn0,25,8,15,6,0,0,2,120,1896 +legacy-ixvm-ungrouped,put_tagn_tail,26,0,26,10,0,0,2,0,0 +legacy-ixvm-ungrouped,put_tagn_wide,27,0,30,6,0,0,2,0,0 +legacy-ixvm-ungrouped,put_u64_list,28,0,17,8,0,0,2,0,0 +legacy-ixvm-ungrouped,value_contract_code,29,0,10,2,0,0,2,0,0 +legacy-ixvm-ungrouped,binder_contract_code,30,0,11,4,0,0,2,0,0 +legacy-ixvm-ungrouped,put_lam_mode,31,0,8,6,0,0,1,0,0 +legacy-ixvm-ungrouped,put_all_mode,32,0,11,4,0,0,2,0,0 +legacy-ixvm-ungrouped,app_telescope_count,33,0,55,8,0,0,2,0,0 +legacy-ixvm-ungrouped,lam_telescope_count,34,0,55,8,0,0,2,0,0 +legacy-ixvm-ungrouped,all_telescope_count,35,0,55,8,0,0,2,0,0 +legacy-ixvm-ungrouped,put_app_telescope,36,0,60,10,0,0,2,0,0 +legacy-ixvm-ungrouped,put_lam_telescope,37,0,61,12,0,0,2,0,0 +legacy-ixvm-ungrouped,put_all_telescope,38,0,61,12,0,0,2,0,0 +legacy-ixvm-ungrouped,put_address,39,32,68,34,0,0,2,2176,51264 +legacy-ixvm-ungrouped,pack_def_kind_safety,40,0,12,2,0,0,2,0,0 +legacy-ixvm-ungrouped,univ_succ_count,41,0,37,8,0,0,2,0,0 +legacy-ixvm-ungrouped,univ_succ_base,42,0,30,6,0,0,2,0,0 +legacy-ixvm-ungrouped,put_univ,43,0,37,12,0,0,2,0,0 +legacy-ixvm-ungrouped,put_expr_list,44,1,28,10,0,0,2,28,126 +legacy-ixvm-ungrouped,put_univ_list,45,1,19,10,0,0,2,19,99 +legacy-ixvm-ungrouped,put_address_list,46,1,10,8,0,0,2,10,66 +legacy-ixvm-ungrouped,put_quot_kind,47,0,8,4,0,0,2,0,0 +legacy-ixvm-ungrouped,put_definition,48,0,56,16,0,0,2,0,0 +legacy-ixvm-ungrouped,put_recursor_rule,49,0,32,8,0,0,2,0,0 +legacy-ixvm-ungrouped,put_recursor_rule_list,50,0,18,8,0,0,2,0,0 +legacy-ixvm-ungrouped,put_recursor,51,0,82,24,0,0,2,0,0 +legacy-ixvm-ungrouped,put_axiom,52,0,34,10,0,0,2,0,0 +legacy-ixvm-ungrouped,put_quotient,53,0,34,10,0,0,2,0,0 +legacy-ixvm-ungrouped,put_constructor,54,0,61,16,0,0,2,0,0 +legacy-ixvm-ungrouped,put_constructor_list,55,0,43,8,0,0,2,0,0 +legacy-ixvm-ungrouped,put_inductive,56,0,63,20,0,0,2,0,0 +legacy-ixvm-ungrouped,put_definition_proj,57,2,14,6,0,0,2,28,168 +legacy-ixvm-ungrouped,put_constructor_proj,58,0,23,8,0,0,2,0,0 +legacy-ixvm-ungrouped,put_mut_const,59,0,52,6,0,0,2,0,0 +legacy-ixvm-ungrouped,put_mut_const_list,60,0,54,8,0,0,2,0,0 +legacy-ixvm-ungrouped,put_constant_info,61,2,56,4,0,0,2,112,408 +legacy-ixvm-ungrouped,put_sharing,62,1,14,4,0,0,2,14,66 +legacy-ixvm-ungrouped,put_refs,63,1,14,4,0,0,2,14,66 +legacy-ixvm-ungrouped,put_univs,64,1,14,4,0,0,2,14,66 +legacy-ixvm-ungrouped,put_constant,65,2,72,14,0,0,2,144,564 +legacy-ixvm-ungrouped,read_byte,66,128,6,4,0,0,2,768,39168 +legacy-ixvm-ungrouped,get_u64_le,67,0,18,6,0,0,2,0,0 +legacy-ixvm-ungrouped,get_tagn4,68,512,24,8,0,0,2,12288,503808 +legacy-ixvm-ungrouped,get_tagn2,69,32,24,8,0,0,2,768,17664 +legacy-ixvm-ungrouped,get_tagn0,70,256,17,8,0,0,2,4352,181248 +legacy-ixvm-ungrouped,get_tagn_tail,71,32,16,8,0,0,2,512,13824 +legacy-ixvm-ungrouped,get_tagn_wide,72,0,26,6,0,0,2,0,0 +legacy-ixvm-ungrouped,get_u64_list,73,128,33,12,0,0,2,4224,133248 +legacy-ixvm-ungrouped,get_app_telescope,74,256,27,12,0,0,2,6912,267264 +legacy-ixvm-ungrouped,value_contract_from_bits,75,1,10,2,0,0,2,10,48 +legacy-ixvm-ungrouped,binder_contract_from_bits,76,1,13,4,0,0,2,13,63 +legacy-ixvm-ungrouped,get_lam_mode,77,32,16,4,0,0,2,512,11904 +legacy-ixvm-ungrouped,get_all_mode,78,32,18,6,0,0,2,576,13824 +legacy-ixvm-ungrouped,get_lam_telescope,79,64,35,14,0,0,2,2240,61824 +legacy-ixvm-ungrouped,get_all_telescope,80,64,35,14,0,0,2,2240,61824 +legacy-ixvm-ungrouped,get_expr,81,512,49,12,0,0,2,25088,904704 +legacy-ixvm-ungrouped,get_expr_let,82,1,34,16,0,0,2,34,162 +legacy-ixvm-ungrouped,build_succ_chain,83,16,39,10,0,0,2,624,10368 +legacy-ixvm-ungrouped,get_univ,84,32,39,12,0,0,2,1248,26784 +legacy-ixvm-ungrouped,get_address,85,64,100,68,0,0,2,6400,198912 +legacy-ixvm-ungrouped,get_expr_list,86,64,26,12,0,0,2,1664,49152 +legacy-ixvm-ungrouped,get_univ_list,87,16,35,14,0,0,2,560,10368 +legacy-ixvm-ungrouped,get_address_list,88,64,26,12,0,0,2,1664,49152 +legacy-ixvm-ungrouped,unpack_def_kind_safety,89,2,11,2,0,0,2,22,126 +legacy-ixvm-ungrouped,get_definition,90,8,20,6,0,0,2,160,2256 +legacy-ixvm-ungrouped,get_recursor_rule_list,91,0,35,14,0,0,2,0,0 +legacy-ixvm-ungrouped,get_recursor,92,0,72,12,0,0,2,0,0 +legacy-ixvm-ungrouped,assert_wire_bool,93,1,4,4,0,0,1,4,30 +legacy-ixvm-ungrouped,get_axiom,94,0,16,6,0,0,2,0,0 +legacy-ixvm-ungrouped,quot_kind_tag,95,0,6,2,0,0,2,0,0 +legacy-ixvm-ungrouped,get_quotient,96,0,17,6,0,0,2,0,0 +legacy-ixvm-ungrouped,get_constructor,97,4,43,8,0,0,2,172,1368 +legacy-ixvm-ungrouped,get_constructor_list,98,8,59,12,0,0,2,472,5496 +legacy-ixvm-ungrouped,get_inductive,99,2,53,10,0,0,2,106,426 +legacy-ixvm-ungrouped,get_inductive_proj,100,2,14,6,0,0,1,28,140 +legacy-ixvm-ungrouped,get_constructor_proj,101,0,23,4,0,0,2,0,0 +legacy-ixvm-ungrouped,get_mut_const,102,2,52,6,0,0,2,104,396 +legacy-ixvm-ungrouped,get_mut_const_list,103,4,70,12,0,0,2,280,2112 +legacy-ixvm-ungrouped,get_constant_info_by_variant,104,16,56,4,0,0,2,896,12480 +legacy-ixvm-ungrouped,get_constant,105,16,140,18,0,0,2,2240,31296 +legacy-ixvm-ungrouped,collect_spine,106,64,11,8,0,0,2,704,27264 +legacy-ixvm-ungrouped,klimbs_succ,107,0,27,10,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_add_carry,108,0,49,14,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_add,109,0,5,4,0,0,1,0,0 +legacy-ixvm-ungrouped,u64_sub_with_borrow,110,0,33,16,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_sub_borrow,111,0,51,14,0,0,2,0,0 +legacy-ixvm-ungrouped,glimbs_to_klimbs,112,0,5,4,0,0,1,0,0 +legacy-ixvm-ungrouped,glimbs_to_klimbs_with_depth,113,0,18,18,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_normalize,114,0,30,14,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_sub,115,0,8,6,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_le,116,0,17,6,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_dec,117,0,6,4,0,0,2,0,0 +legacy-ixvm-ungrouped,u64_mul,118,0,90,22,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_mul,119,0,6,6,0,0,1,0,0 +legacy-ixvm-ungrouped,klimbs_mul_outer,120,0,21,12,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_mul_single,121,0,68,14,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_shl_limbs,122,0,8,6,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_is_zero,123,0,16,6,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_div_mod,124,0,18,24,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_div,125,0,6,4,0,0,1,0,0 +legacy-ixvm-ungrouped,klimbs_mod,126,0,6,4,0,0,1,0,0 +legacy-ixvm-ungrouped,klimbs_gcd,127,0,8,8,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_pow,128,0,17,22,0,0,2,0,0 +legacy-ixvm-ungrouped,u64_and,129,0,26,10,0,0,2,0,0 +legacy-ixvm-ungrouped,u64_or,130,0,26,10,0,0,2,0,0 +legacy-ixvm-ungrouped,u64_xor_kbits,131,0,26,10,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_land,132,0,36,12,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_lor,133,0,36,12,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_xor_op,134,0,36,12,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_shl,135,0,8,6,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_shr,136,0,8,6,0,0,2,0,0 +legacy-ixvm-ungrouped,nat_zero_addr,137,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,nat_succ_addr_iota,138,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,nat_pred_addr,139,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,int_of_nat_addr,140,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,int_neg_succ_addr_dec,141,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,int_add_addr,142,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,int_sub_addr,143,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,int_mul_addr,144,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,int_neg_addr,145,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,int_emod_addr,146,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,int_ediv_addr,147,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,int_bmod_addr,148,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,int_bdiv_addr,149,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,int_nat_abs_addr,150,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,int_pow_addr,151,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,nat_add_addr,152,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,nat_sub_addr,153,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,nat_mul_addr,154,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,nat_pow_addr,155,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,nat_gcd_addr,156,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,nat_mod_addr,157,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,nat_div_addr,158,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,nat_land_addr,159,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,nat_lor_addr,160,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,nat_xor_addr,161,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,nat_shift_left_addr,162,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,nat_shift_right_addr,163,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,nat_beq_addr,164,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,nat_ble_addr,165,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,bool_true_addr,166,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,bool_false_addr,167,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,system_platform_num_bits_addr,168,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,punit_size_of_1_addr,169,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,reduce_bool_addr,170,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,reduce_nat_addr,171,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,subtype_val_addr,172,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,system_platform_get_num_bits_addr,173,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,is_native_prim_addr,174,1,23,22,0,0,2,23,147 +legacy-ixvm-ungrouped,mk_nat_literal_64,175,0,5,4,0,0,2,0,0 +legacy-ixvm-ungrouped,mk_nat_one,176,0,5,4,0,0,2,0,0 +legacy-ixvm-ungrouped,try_native_dispatch,177,0,38,42,0,0,2,0,0 +legacy-ixvm-ungrouped,try_reduce_subtype_val,178,0,25,28,0,0,2,0,0 +legacy-ixvm-ungrouped,check_native_bool,179,0,14,14,0,0,2,0,0 +legacy-ixvm-ungrouped,check_native_nat,180,0,11,6,0,0,2,0,0 +legacy-ixvm-ungrouped,bit_vec_to_nat_addr,181,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,bit_vec_of_nat_addr,182,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,bit_vec_addr,183,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,bit_vec_ult_addr,184,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,decidable_decide_addr,185,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,lt_lt_addr,186,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,is_bitvec_prim_addr,187,1,15,14,0,0,2,15,99 +legacy-ixvm-ungrouped,mk_bool,188,0,8,8,0,0,2,0,0 +legacy-ixvm-ungrouped,bv_to_nat_via,189,0,19,18,0,0,2,0,0 +legacy-ixvm-ungrouped,try_reduce_bit_vec_ult,190,0,23,30,0,0,2,0,0 +legacy-ixvm-ungrouped,try_reduce_decide_bitvec_lt,191,0,63,80,0,0,2,0,0 +legacy-ixvm-ungrouped,bitvec_of_nat_args_direct,192,0,17,16,0,0,2,0,0 +legacy-ixvm-ungrouped,try_bitvec_dispatch,193,0,26,30,0,0,2,0,0 +legacy-ixvm-ungrouped,bitvec_prep_spine_ult,194,0,22,20,0,0,2,0,0 +legacy-ixvm-ungrouped,np_whnf_inner_bv,195,0,8,4,0,0,2,0,0 +legacy-ixvm-ungrouped,string_utf8_byte_size_addr,196,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,string_append_addr,197,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,string_of_list_addr,198,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,char_of_nat_addr,199,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,list_nil_addr,200,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,list_cons_addr,201,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,char_type_addr,202,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,string_back_addr,203,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,string_legacy_back_addr,204,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,string_to_byte_array_addr,205,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,byte_array_empty_addr,206,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,string_dec_eq_addr,207,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,str_addr,208,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,is_str_prim_addr,209,1,31,30,0,0,2,31,195 +legacy-ixvm-ungrouped,try_str_dispatch,210,0,62,56,0,0,2,0,0 +legacy-ixvm-ungrouped,try_str_back,211,0,26,34,0,0,2,0,0 +legacy-ixvm-ungrouped,try_str_to_byte_array,212,0,26,28,0,0,2,0,0 +legacy-ixvm-ungrouped,utf8_validate,213,0,9,8,0,0,2,0,0 +legacy-ixvm-ungrouped,utf8_last_codepoint,214,0,4,4,0,0,1,0,0 +legacy-ixvm-ungrouped,utf8_last_go,215,0,11,8,0,0,2,0,0 +legacy-ixvm-ungrouped,utf8_cont,216,0,5,6,0,0,2,0,0 +legacy-ixvm-ungrouped,utf8_decode_one,217,0,32,34,0,0,2,0,0 +legacy-ixvm-ungrouped,str_lit_to_ctor,218,0,20,18,0,0,2,0,0 +legacy-ixvm-ungrouped,build_char_list,219,0,18,18,0,0,2,0,0 +legacy-ixvm-ungrouped,str_lit_delta_step,220,0,38,20,0,0,2,0,0 +legacy-ixvm-ungrouped,str_lit_to_ctor_app_or_self,221,0,12,8,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_from_g,222,0,14,8,0,0,2,0,0 +legacy-ixvm-ungrouped,walk_char_list_bytes,223,0,32,28,0,0,2,0,0 +legacy-ixvm-ungrouped,char_lit_codepoint,224,0,11,8,0,0,2,0,0 +legacy-ixvm-ungrouped,char_lit_codepoint_syn,225,0,25,14,0,0,2,0,0 +legacy-ixvm-ungrouped,klimbs_scalar_value,226,0,53,42,0,0,2,0,0 +legacy-ixvm-ungrouped,utf8_encode_prepend,227,0,64,102,0,0,2,0,0 +legacy-ixvm-ungrouped,is_int_prim_addr,228,1,23,22,0,0,2,23,147 +legacy-ixvm-ungrouped,try_extract_nat,229,0,16,10,0,0,2,0,0 +legacy-ixvm-ungrouped,try_extract_nat_app,230,0,17,12,0,0,2,0,0 +legacy-ixvm-ungrouped,mk_nat_lit,231,0,4,4,0,0,1,0,0 +legacy-ixvm-ungrouped,try_extract_int_prim,232,0,25,20,0,0,2,0,0 +legacy-ixvm-ungrouped,mk_int_prim,233,0,22,20,0,0,2,0,0 +legacy-ixvm-ungrouped,int_add_prim,234,0,13,8,0,0,2,0,0 +legacy-ixvm-ungrouped,int_emod_prim,235,0,14,12,0,0,2,0,0 +legacy-ixvm-ungrouped,int_ediv_prim,236,0,21,16,0,0,2,0,0 +legacy-ixvm-ungrouped,int_bmod_prim,237,0,23,24,0,0,2,0,0 +legacy-ixvm-ungrouped,int_bdiv_prim,238,0,34,34,0,0,2,0,0 +legacy-ixvm-ungrouped,try_int_prim_dispatch,239,0,38,42,0,0,2,0,0 +legacy-ixvm-ungrouped,try_int_prim_second,240,0,46,42,0,0,2,0,0 +legacy-ixvm-ungrouped,apply_spine_expr,241,8,10,8,0,0,2,80,1680 +legacy-ixvm-ungrouped,try_nat_binop_addr,242,0,62,62,0,0,2,0,0 +legacy-ixvm-ungrouped,try_match_nat_add,243,0,25,18,0,0,2,0,0 +legacy-ixvm-ungrouped,build_succ_offset,244,0,21,32,0,0,2,0,0 +legacy-ixvm-ungrouped,cleanup_nat_offset_major,245,0,25,16,0,0,2,0,0 +legacy-ixvm-ungrouped,mk_nat_offset_stuck,246,0,15,18,0,0,2,0,0 +legacy-ixvm-ungrouped,is_nat_succ_ih_step,247,0,34,20,0,0,2,0,0 +legacy-ixvm-ungrouped,try_nat_linear_rec,248,0,31,34,0,0,2,0,0 +legacy-ixvm-ungrouped,try_nat_binop_dispatch,249,0,27,28,0,0,2,0,0 +legacy-ixvm-ungrouped,try_nat_offset_dispatch,250,0,27,28,0,0,2,0,0 +legacy-ixvm-ungrouped,mk_nat_binop_stuck,251,0,12,8,0,0,2,0,0 +legacy-ixvm-ungrouped,bytes_to_u64_limb,252,4,40,6,0,0,2,160,1248 +legacy-ixvm-ungrouped,skip_bytes,253,4,11,6,0,0,2,44,552 +legacy-ixvm-ungrouped,bytes_to_limbs,254,2,35,18,0,0,2,70,366 +legacy-ixvm-ungrouped,convert_univ,255,16,19,10,0,0,2,304,6528 +legacy-ixvm-ungrouped,convert_univ_idxs,256,32,20,14,0,0,2,640,18624 +legacy-ixvm-ungrouped,convert_expr,257,512,42,14,0,0,2,21504,835584 +legacy-ixvm-ungrouped,convert_definition,258,8,28,8,0,0,2,224,2976 +legacy-ixvm-ungrouped,convert_axiom,259,0,18,6,0,0,2,0,0 +legacy-ixvm-ungrouped,convert_quotient,260,0,18,6,0,0,2,0,0 +legacy-ixvm-ungrouped,count_ctors,261,4,41,6,0,0,2,164,1272 +legacy-ixvm-ungrouped,ctor_at,262,0,76,6,0,0,2,0,0 +legacy-ixvm-ungrouped,convert_inductive,263,2,40,12,0,0,2,80,360 +legacy-ixvm-ungrouped,convert_constructor,264,0,47,12,0,0,2,0,0 +legacy-ixvm-ungrouped,convert_rec_rules,265,0,24,12,0,0,2,0,0 +legacy-ixvm-ungrouped,convert_recursor,266,0,59,16,0,0,2,0,0 +legacy-ixvm-ungrouped,load_verified_constant,267,16,90,6,0,0,2,1440,19392 +legacy-ixvm-ungrouped,load_verified_blob,268,2,38,4,0,0,2,76,300 +legacy-ixvm-ungrouped,defn_is_unsafe_ci,269,2,9,2,0,0,2,18,114 +legacy-ixvm-ungrouped,defn_member_recur_addrs,270,0,20,6,0,0,2,0,0 +legacy-ixvm-ungrouped,get_ci,271,16,79,14,0,0,2,1264,18816 +legacy-ixvm-ungrouped,get_ci_dprj,272,0,120,12,0,0,2,0,0 +legacy-ixvm-ungrouped,get_ci_iprj,273,2,111,12,0,0,2,222,786 +legacy-ixvm-ungrouped,get_ci_cprj,274,0,146,14,0,0,2,0,0 +legacy-ixvm-ungrouped,get_ci_rprj,275,0,111,12,0,0,2,0,0 +legacy-ixvm-ungrouped,muts_member_at,276,2,98,6,0,0,2,196,672 +legacy-ixvm-ungrouped,idx_to_u64,277,1,12,6,0,0,2,12,66 +legacy-ixvm-ungrouped,projection_addr,278,2,109,12,0,0,2,218,774 +legacy-ixvm-ungrouped,build_recur_addrs,279,2,5,4,0,0,1,10,74 +legacy-ixvm-ungrouped,build_recur_addrs_walk,280,4,57,10,0,0,2,228,1752 +legacy-ixvm-ungrouped,level_is_not_zero,281,0,15,8,0,0,2,0,0 +legacy-ixvm-ungrouped,level_eq,282,2,22,10,0,0,2,44,240 +legacy-ixvm-ungrouped,glist_cmp,283,1,28,32,0,0,2,28,192 +legacy-ixvm-ungrouped,glist_subset,284,1,27,32,0,0,2,27,189 +legacy-ixvm-ungrouped,glist_eq_len,285,1,14,8,0,0,2,14,78 +legacy-ixvm-ungrouped,glist_ordered_insert,286,0,25,32,0,0,2,0,0 +legacy-ixvm-ungrouped,nlvars_add,287,0,34,46,0,0,2,0,0 +legacy-ixvm-ungrouped,nlvars_eq,288,0,20,12,0,0,2,0,0 +legacy-ixvm-ungrouped,nlvars_max_offset,289,0,17,20,0,0,2,0,0 +legacy-ixvm-ungrouped,nlvars_subsume,290,0,39,50,0,0,2,0,0 +legacy-ixvm-ungrouped,nl_add_const,291,2,12,6,0,0,2,24,156 +legacy-ixvm-ungrouped,nl_add_const_go,292,1,24,24,0,0,2,24,156 +legacy-ixvm-ungrouped,nl_add_var,293,0,21,18,0,0,2,0,0 +legacy-ixvm-ungrouped,normalize_aux,294,8,19,10,0,0,2,152,2472 +legacy-ixvm-ungrouped,normalize_imax_dispatch,295,0,23,12,0,0,2,0,0 +legacy-ixvm-ungrouped,nl_subsumption_walk,296,4,11,10,0,0,2,44,648 +legacy-ixvm-ungrouped,nl_subsume_entry,297,4,57,48,0,0,2,228,2664 +legacy-ixvm-ungrouped,nl_skip_empty,298,4,16,10,0,0,2,64,768 +legacy-ixvm-ungrouped,nl_eq,299,1,27,20,0,0,2,27,153 +legacy-ixvm-ungrouped,nl_covers_const,300,0,27,24,0,0,2,0,0 +legacy-ixvm-ungrouped,nlvars_any_offset_geq,301,0,18,20,0,0,2,0,0 +legacy-ixvm-ungrouped,nl_covers_var,302,0,19,12,0,0,2,0,0 +legacy-ixvm-ungrouped,nlvars_dominates,303,0,20,20,0,0,2,0,0 +legacy-ixvm-ungrouped,nl_le,304,0,20,12,0,0,2,0,0 +legacy-ixvm-ungrouped,nl_le_vars,305,0,14,10,0,0,2,0,0 +legacy-ixvm-ungrouped,level_normalize,306,2,8,6,0,0,2,16,132 +legacy-ixvm-ungrouped,level_leq,307,0,14,12,0,0,2,0,0 +legacy-ixvm-ungrouped,level_equal,308,2,9,10,0,0,2,18,162 +legacy-ixvm-ungrouped,level_max,309,0,17,18,0,0,2,0,0 +legacy-ixvm-ungrouped,level_max_go,310,0,21,14,0,0,2,0,0 +legacy-ixvm-ungrouped,level_struct_eq,311,0,25,10,0,0,2,0,0 +legacy-ixvm-ungrouped,level_max_subsumes,312,0,11,8,0,0,2,0,0 +legacy-ixvm-ungrouped,level_max_offsets,313,0,17,20,0,0,2,0,0 +legacy-ixvm-ungrouped,level_explicit_val,314,0,12,6,0,0,2,0,0 +legacy-ixvm-ungrouped,level_offset_of,315,0,10,6,0,0,2,0,0 +legacy-ixvm-ungrouped,level_imax,316,1,21,12,0,0,2,21,111 +legacy-ixvm-ungrouped,level_reduce,317,4,13,10,0,0,2,52,696 +legacy-ixvm-ungrouped,level_inst_params,318,16,14,10,0,0,2,224,5568 +legacy-ixvm-ungrouped,level_list_inst,319,16,11,10,0,0,2,176,4992 +legacy-ixvm-ungrouped,expr_inst_levels,320,64,10,6,0,0,2,640,23808 +legacy-ixvm-ungrouped,expr_inst_levels_walk,321,64,20,12,0,0,2,1280,42240 +legacy-ixvm-ungrouped,klimbs_eq,322,0,30,10,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_g_list_eq,323,0,15,8,0,0,2,0,0 +legacy-ixvm-ungrouped,literal_eq,324,0,10,4,0,0,2,0,0 +legacy-ixvm-ungrouped,expr_lbr,325,128,19,12,0,0,2,2432,95616 +legacy-ixvm-ungrouped,expr_lbr_let,326,0,11,8,0,0,2,0,0 +legacy-ixvm-ungrouped,lbr_max,327,16,11,14,0,0,2,176,5760 +legacy-ixvm-ungrouped,lbr_dec,328,4,5,2,0,0,2,20,312 +legacy-ixvm-ungrouped,lbr_min,329,16,11,14,0,0,2,176,5760 +legacy-ixvm-ungrouped,has_bvar_in_range,330,64,31,28,0,0,2,1984,73344 +legacy-ixvm-ungrouped,has_bvar_in_range_binder,331,2,9,6,0,0,2,18,138 +legacy-ixvm-ungrouped,has_bvar_in_range_let,332,0,12,8,0,0,2,0,0 +legacy-ixvm-ungrouped,ctx_seek_cut,333,1,14,20,0,0,2,14,114 +legacy-ixvm-ungrouped,ctx_next_cut,334,1,8,8,0,0,2,8,60 +legacy-ixvm-ungrouped,ctx_close_cut,335,1,16,20,0,0,2,16,120 +legacy-ixvm-ungrouped,ctx_trim,336,4,18,24,0,0,2,72,1152 +legacy-ixvm-ungrouped,expr_glb,337,64,9,8,0,0,2,576,24960 +legacy-ixvm-ungrouped,expr_glb_walk,338,64,22,10,0,0,2,1408,42240 +legacy-ixvm-ungrouped,expr_glb_binder,339,8,10,8,0,0,2,80,1680 +legacy-ixvm-ungrouped,expr_glb_let,340,0,15,12,0,0,2,0,0 +legacy-ixvm-ungrouped,expr_lift,341,16,11,8,0,0,2,176,4608 +legacy-ixvm-ungrouped,expr_lift_walk,342,1,20,10,0,0,2,20,102 +legacy-ixvm-ungrouped,expr_lift_bvar,343,1,13,16,0,0,2,13,99 +legacy-ixvm-ungrouped,expr_lift_let,344,0,11,6,0,0,2,0,0 +legacy-ixvm-ungrouped,expr_lower,345,32,11,8,0,0,2,352,11424 +legacy-ixvm-ungrouped,expr_lower_walk,346,16,25,18,0,0,2,400,9216 +legacy-ixvm-ungrouped,expr_has_bvar_at,347,32,22,8,0,0,2,704,16704 +legacy-ixvm-ungrouped,expr_has_bvar_at_binder,348,1,9,6,0,0,2,9,57 +legacy-ixvm-ungrouped,expr_has_bvar_at_let,349,0,13,8,0,0,2,0,0 +legacy-ixvm-ungrouped,expr_inst1,350,16,12,10,0,0,2,192,5184 +legacy-ixvm-ungrouped,expr_inst1_walk,351,8,20,10,0,0,2,160,2544 +legacy-ixvm-ungrouped,expr_inst1_bvar,352,2,10,6,0,0,2,20,144 +legacy-ixvm-ungrouped,expr_inst1_let,353,0,11,6,0,0,2,0,0 +legacy-ixvm-ungrouped,expr_inst_many,354,64,15,12,0,0,2,960,36480 +legacy-ixvm-ungrouped,expr_inst_many_bvar,355,32,10,10,0,0,2,320,11904 +legacy-ixvm-ungrouped,expr_inst_many_walk,356,64,20,10,0,0,2,1280,39936 +legacy-ixvm-ungrouped,expr_inst_many_let,357,0,11,6,0,0,2,0,0 +legacy-ixvm-ungrouped,peel_beta,358,4,18,10,0,0,2,72,816 +legacy-ixvm-ungrouped,whnf_apply_beta,359,1,16,14,0,0,2,16,102 +legacy-ixvm-ungrouped,whnf_with_spine,360,4,20,10,0,0,2,80,864 +legacy-ixvm-ungrouped,whnf_proj_head,361,0,37,20,0,0,2,0,0 +legacy-ixvm-ungrouped,fin_addr,362,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,decidable_rec_addr,363,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,nat_addr_io,364,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,quot_ctor_addr,365,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,quot_lift_addr_iota,366,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,quot_ind_addr,367,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,try_reduce_fin_val_decidable_rec,368,0,65,74,0,0,2,0,0 +legacy-ixvm-ungrouped,whnf_get_ctor_or_none,369,0,12,10,0,0,2,0,0 +legacy-ixvm-ungrouped,whnf_spine,370,0,11,10,0,0,2,0,0 +legacy-ixvm-ungrouped,try_nat_dispatch_prewhnf,371,0,33,40,0,0,2,0,0 +legacy-ixvm-ungrouped,bitvec_prep_spine,372,0,20,20,0,0,2,0,0 +legacy-ixvm-ungrouped,prim_family,373,1,86,76,0,0,2,86,498 +legacy-ixvm-ungrouped,try_prim_dispatch,374,1,20,8,0,0,2,20,96 +legacy-ixvm-ungrouped,try_quot_iota,375,0,14,12,0,0,2,0,0 +legacy-ixvm-ungrouped,try_quot_lift,376,0,21,28,0,0,2,0,0 +legacy-ixvm-ungrouped,try_quot_ind,377,0,21,28,0,0,2,0,0 +legacy-ixvm-ungrouped,quot_extract_arg,378,0,19,16,0,0,2,0,0 +legacy-ixvm-ungrouped,whnf_const_head,379,0,53,20,0,0,2,0,0 +legacy-ixvm-ungrouped,try_reduce_projection_definition,380,1,23,26,0,0,2,23,159 +legacy-ixvm-ungrouped,projection_definition_info,381,2,24,20,0,0,2,48,312 +legacy-ixvm-ungrouped,nat_lit_to_ctor_or_self,382,0,19,20,0,0,2,0,0 +legacy-ixvm-ungrouped,try_k_synth_iota,383,0,31,24,0,0,2,0,0 +legacy-ixvm-ungrouped,k_synth_gate,384,0,39,28,0,0,2,0,0 +legacy-ixvm-ungrouped,replace_spine_major,385,0,11,8,0,0,2,0,0 +legacy-ixvm-ungrouped,whnf_iota_major,386,0,29,18,0,0,2,0,0 +legacy-ixvm-ungrouped,try_iota,387,0,48,50,0,0,2,0,0 +legacy-ixvm-ungrouped,collect_spine_of_ctor,388,0,27,14,0,0,2,0,0 +legacy-ixvm-ungrouped,find_rule,389,0,15,6,0,0,2,0,0 +legacy-ixvm-ungrouped,try_struct_eta_iota,390,0,62,38,0,0,2,0,0 +legacy-ixvm-ungrouped,se_parent_addr,391,0,20,10,0,0,2,0,0 +legacy-ixvm-ungrouped,apply_n_projs,392,0,12,8,0,0,2,0,0 +legacy-ixvm-ungrouped,struct_is_rec,393,0,19,10,0,0,2,0,0 +legacy-ixvm-ungrouped,struct_block_member_addrs,394,0,56,8,0,0,2,0,0 +legacy-ixvm-ungrouped,struct_scan_ctors,395,0,29,12,0,0,2,0,0 +legacy-ixvm-ungrouped,se_peel_tol,396,0,12,6,0,0,2,0,0 +legacy-ixvm-ungrouped,se_scan_fields,397,0,13,8,0,0,2,0,0 +legacy-ixvm-ungrouped,se_mentions,398,0,25,10,0,0,2,0,0 +legacy-ixvm-ungrouped,se_addr_in,399,0,12,8,0,0,2,0,0 +legacy-ixvm-ungrouped,whnf,400,8,22,12,0,0,2,176,2832 +legacy-ixvm-ungrouped,whnf_struct_core,401,8,22,12,0,0,2,176,2832 +legacy-ixvm-ungrouped,whnf_struct_core_spine,402,8,25,16,0,0,2,200,3336 +legacy-ixvm-ungrouped,whnf_struct_core_proj,403,0,32,16,0,0,2,0,0 +legacy-ixvm-ungrouped,whnf_struct_core_const,404,1,27,12,0,0,2,27,129 +legacy-ixvm-ungrouped,whnf_nd,405,4,22,12,0,0,2,88,960 +legacy-ixvm-ungrouped,whnf_nd_with_spine,406,8,20,10,0,0,2,160,2544 +legacy-ixvm-ungrouped,whnf_nd_apply_beta,407,1,16,14,0,0,2,16,102 +legacy-ixvm-ungrouped,whnf_nd_proj_head,408,0,37,20,0,0,2,0,0 +legacy-ixvm-ungrouped,whnf_nd_const_head,409,1,60,26,0,0,2,60,270 +legacy-ixvm-ungrouped,types_lookup,410,0,6,6,0,0,1,0,0 +legacy-ixvm-ungrouped,const_num_lvls,411,8,21,2,0,0,2,168,2040 +legacy-ixvm-ungrouped,const_type_of,412,8,21,2,0,0,2,168,2040 +legacy-ixvm-ungrouped,k_infer_only,413,2,57,30,0,0,2,114,570 +legacy-ixvm-ungrouped,ensure_sort_only,414,0,16,10,0,0,2,0,0 +legacy-ixvm-ungrouped,peel_params_subst,415,0,16,10,0,0,2,0,0 +legacy-ixvm-ungrouped,io_peel_field_loop,416,0,16,10,0,0,2,0,0 +legacy-ixvm-ungrouped,level_list_eq,417,0,17,10,0,0,2,0,0 +legacy-ixvm-ungrouped,k_is_def_eq,418,16,13,12,0,0,2,208,5760 +legacy-ixvm-ungrouped,k_def_eq_rebase,419,2,18,22,0,0,2,36,288 +legacy-ixvm-ungrouped,k_is_def_eq_core,420,4,14,16,0,0,2,56,864 +legacy-ixvm-ungrouped,k_is_def_eq_ordered,421,4,9,6,0,0,2,36,504 +legacy-ixvm-ungrouped,try_def_eq_app,422,4,27,18,0,0,2,108,1224 +legacy-ixvm-ungrouped,de_args,423,0,18,10,0,0,2,0,0 +legacy-ixvm-ungrouped,is_nat_zero,424,2,12,8,0,0,2,24,168 +legacy-ixvm-ungrouped,nat_offset_of,425,2,36,18,0,0,2,72,372 +legacy-ixvm-ungrouped,try_def_eq_nat,426,1,23,14,0,0,2,23,123 +legacy-ixvm-ungrouped,try_string_lit_one,427,8,14,10,0,0,2,112,2112 +legacy-ixvm-ungrouped,k_is_def_eq_slow,428,4,14,8,0,0,2,56,672 +legacy-ixvm-ungrouped,k_is_def_eq_slow_nd,429,4,16,12,0,0,2,64,816 +legacy-ixvm-ungrouped,k_is_def_eq_slow_nd_after_core,430,1,18,12,0,0,2,18,102 +legacy-ixvm-ungrouped,k_is_def_eq_struct_safe,431,4,24,12,0,0,2,96,1008 +legacy-ixvm-ungrouped,k_is_def_eq_slow2,432,1,31,16,0,0,2,31,153 +legacy-ixvm-ungrouped,slow2_after_delta,433,0,15,8,0,0,2,0,0 +legacy-ixvm-ungrouped,try_same_proj_head_app,434,0,31,22,0,0,2,0,0 +legacy-ixvm-ungrouped,k_is_def_eq_structure_tree,435,0,13,8,0,0,2,0,0 +legacy-ixvm-ungrouped,k_is_def_eq_structure_tree_app,436,0,18,10,0,0,2,0,0 +legacy-ixvm-ungrouped,k_is_def_eq_struct_bounded,437,0,45,12,0,0,2,0,0 +legacy-ixvm-ungrouped,k_is_def_eq_struct_spend,438,0,23,12,0,0,2,0,0 +legacy-ixvm-ungrouped,slow2_eager_fallback,439,0,29,20,0,0,2,0,0 +legacy-ixvm-ungrouped,try_eta_struct,440,2,59,28,0,0,2,118,570 +legacy-ixvm-ungrouped,compare_struct_fields,441,0,17,10,0,0,2,0,0 +legacy-ixvm-ungrouped,compute_iprj_addr,442,0,15,6,0,0,2,0,0 +legacy-ixvm-ungrouped,try_eta_swap,443,0,18,8,0,0,2,0,0 +legacy-ixvm-ungrouped,try_unit_like,444,1,12,12,0,0,2,12,84 +legacy-ixvm-ungrouped,is_unit_like_type,445,1,42,14,0,0,2,42,180 +legacy-ixvm-ungrouped,try_proof_irrel,446,1,11,10,0,0,2,11,75 +legacy-ixvm-ungrouped,try_eta_expand,447,0,21,20,0,0,2,0,0 +legacy-ixvm-ungrouped,is_prop_type,448,1,13,12,0,0,2,13,87 +legacy-ixvm-ungrouped,k_is_def_eq_struct,449,0,6,4,0,0,1,0,0 +legacy-ixvm-ungrouped,k_is_def_eq_struct_go,450,0,42,12,0,0,2,0,0 +legacy-ixvm-ungrouped,lazy_delta_loop,451,2,26,10,0,0,2,52,264 +legacy-ixvm-ungrouped,delta_rank,452,0,16,2,0,0,2,0,0 +legacy-ixvm-ungrouped,lazy_delta_step_const_const,453,0,62,44,0,0,2,0,0 +legacy-ixvm-ungrouped,unfold_a_and_loop,454,0,13,8,0,0,2,0,0 +legacy-ixvm-ungrouped,unfold_b_and_loop,455,0,13,8,0,0,2,0,0 +legacy-ixvm-ungrouped,unfold_both_and_loop,456,0,17,12,0,0,2,0,0 +legacy-ixvm-ungrouped,lazy_delta_a_const_b_proj,457,0,33,14,0,0,2,0,0 +legacy-ixvm-ungrouped,lazy_delta_b_const_a_proj,458,1,33,14,0,0,2,33,153 +legacy-ixvm-ungrouped,lazy_delta_both_proj,459,0,17,8,0,0,2,0,0 +legacy-ixvm-ungrouped,is_defn_or_thm,460,1,18,2,0,0,2,18,72 +legacy-ixvm-ungrouped,try_unfold_proj_app,461,1,24,18,0,0,2,24,138 +legacy-ixvm-ungrouped,delta_unfold,462,1,27,14,0,0,2,27,135 +legacy-ixvm-ungrouped,try_lazy_delta_app,463,0,48,20,0,0,2,0,0 +legacy-ixvm-ungrouped,head_addr,464,2,12,8,0,0,2,24,168 +legacy-ixvm-ungrouped,try_unfold_head,465,1,23,6,0,0,2,23,99 +legacy-ixvm-ungrouped,k_infer,466,32,8,8,0,0,2,256,9984 +legacy-ixvm-ungrouped,k_infer_rebase,467,16,15,18,0,0,2,240,7296 +legacy-ixvm-ungrouped,k_infer_core,468,32,33,16,0,0,2,1056,25824 +legacy-ixvm-ungrouped,k_infer_let_start,469,0,11,8,0,0,2,0,0 +legacy-ixvm-ungrouped,infer_let_lookup_type,470,0,16,6,0,0,2,0,0 +legacy-ixvm-ungrouped,infer_let_lookup_value,471,0,16,6,0,0,2,0,0 +legacy-ixvm-ungrouped,infer_let_materialize,472,0,27,16,0,0,2,0,0 +legacy-ixvm-ungrouped,k_infer_let_env,473,0,20,12,0,0,2,0,0 +legacy-ixvm-ungrouped,infer_let_local_cutoff,474,0,13,6,0,0,2,0,0 +legacy-ixvm-ungrouped,k_infer_let_env_rebase,475,0,14,8,0,0,2,0,0 +legacy-ixvm-ungrouped,infer_let_drop_unused,476,0,16,6,0,0,2,0,0 +legacy-ixvm-ungrouped,k_infer_let_env_core,477,0,28,22,0,0,2,0,0 +legacy-ixvm-ungrouped,k_infer_app_spine_loop,478,32,33,22,0,0,2,1056,28704 +legacy-ixvm-ungrouped,k_infer_lit,479,0,8,8,0,0,2,0,0 +legacy-ixvm-ungrouped,is_inductive_prop,480,0,14,12,0,0,2,0,0 +legacy-ixvm-ungrouped,peel_n_alls_whnf,481,0,15,10,0,0,2,0,0 +legacy-ixvm-ungrouped,check_prop_field_if_prop,482,0,10,8,0,0,2,0,0 +legacy-ixvm-ungrouped,check_no_dep_data_field_if_prop,483,0,14,10,0,0,2,0,0 +legacy-ixvm-ungrouped,peel_field_loop,484,0,18,12,0,0,2,0,0 +legacy-ixvm-ungrouped,k_infer_proj,485,0,44,26,0,0,2,0,0 +legacy-ixvm-ungrouped,k_ensure_sort,486,8,10,8,0,0,2,80,1680 +legacy-ixvm-ungrouped,k_check,487,16,7,6,0,0,1,112,2944 +legacy-ixvm-ungrouped,nat_dec_le_addr_dec,488,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,nat_dec_eq_addr_dec,489,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,nat_dec_lt_addr_dec,490,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,decidable_is_true_addr_dec,491,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,decidable_is_false_addr_dec,492,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,nat_le_of_ble_eq_true_addr_dec,493,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,nat_not_le_of_not_ble_eq_true_addr_dec,494,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,nat_eq_of_beq_eq_true_addr_dec,495,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,nat_ne_of_beq_eq_false_addr_dec,496,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,bool_type_addr_dec,497,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,eq_refl_addr_dec,498,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,int_dec_eq_addr_dec,499,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,int_dec_le_addr_dec,500,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,int_dec_lt_addr_dec,501,1,3,4,0,0,1,3,27 +legacy-ixvm-ungrouped,is_dec_prim_addr,502,1,27,26,0,0,2,27,171 +legacy-ixvm-ungrouped,is_int_dec_prim_addr,503,0,15,14,0,0,2,0,0 +legacy-ixvm-ungrouped,try_extract_int,504,0,27,18,0,0,2,0,0 +legacy-ixvm-ungrouped,intern_int_lit,505,0,13,12,0,0,2,0,0 +legacy-ixvm-ungrouped,try_normalize_int_decidable,506,0,28,26,0,0,2,0,0 +legacy-ixvm-ungrouped,normalize_int_dec_rebuild,507,0,25,24,0,0,2,0,0 +legacy-ixvm-ungrouped,try_dec_dispatch,508,0,28,32,0,0,2,0,0 +legacy-ixvm-ungrouped,dec_rewrite_lt_to_le,509,0,19,26,0,0,2,0,0 +legacy-ixvm-ungrouped,dec_dispatch_le_eq,510,0,25,18,0,0,2,0,0 +legacy-ixvm-ungrouped,dec_build_proof,511,0,46,42,0,0,2,0,0 +legacy-ixvm-ungrouped,try_str_dec_eq,512,0,33,28,0,0,2,0,0 +legacy-ixvm-ungrouped,str_dec_eq_build,513,0,41,66,0,0,2,0,0 +legacy-ixvm-ungrouped,dec_finish,514,0,36,44,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_ord_cmp_g,515,0,13,14,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_ord_then,516,0,6,2,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_sord_lt_strong,517,0,2,2,0,0,1,0,0 +legacy-ixvm-ungrouped,canon_sord_eq_strong,518,0,2,2,0,0,1,0,0 +legacy-ixvm-ungrouped,canon_sord_gt_strong,519,0,2,2,0,0,1,0,0 +legacy-ixvm-ungrouped,canon_sord_then,520,0,8,2,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_sord_of_g,521,0,3,2,0,0,1,0,0 +legacy-ixvm-ungrouped,canon_addr_cmp,522,0,83,18,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_addr_chunk,523,0,11,4,0,0,1,0,0 +legacy-ixvm-ungrouped,canon_ctx_class_idx,524,0,13,8,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_ctx_cmp_addr,525,0,16,12,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_cmp_kuniv,526,0,28,12,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_cmp_kuniv_list,527,0,16,12,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_cmp_kliteral,528,0,10,4,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_cmp_klimbs,529,0,11,14,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_cmp_klimbs_tail,530,0,28,12,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_cmp_u64_lex,531,0,33,16,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_cmp_bytes,532,0,16,12,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_cmp_kexpr_ctx,533,0,17,8,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_cmp_kexpr_node_ctx,534,0,61,14,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_cmp_krec_rule_ctx,535,0,16,10,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_cmp_krec_rule_list_ctx,536,0,24,12,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_kind_ord,537,0,21,2,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_cmp_member_ctx,538,0,34,10,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_cmp_member_same_kind_ctx,539,0,70,44,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_cmp_ctor_range_ctx,540,0,43,16,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_cmp_ctor_pair_ctx,541,0,51,28,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_cprj_addr,542,0,24,6,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_member_ci,543,0,18,4,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_member_num_ctors,544,0,18,4,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_build_ctx_classes,545,0,15,10,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_build_ctx_members,546,0,26,28,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_ctor_ctx_entries,547,0,12,8,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_sort_loop,548,0,15,12,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_refine_classes,549,0,12,10,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_refine_one,550,0,12,8,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_ins_sort,551,0,11,8,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_insert_sorted,552,0,40,14,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_group_consec,553,0,12,10,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_group_walk,554,0,43,18,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_classes_eq,555,0,17,10,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_flatten,556,0,9,8,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_all_singleton,557,0,10,8,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_indc_positions,558,0,55,8,0,0,2,0,0 +legacy-ixvm-ungrouped,canon_muts_has_kind,559,0,59,6,0,0,2,0,0 +legacy-ixvm-ungrouped,check_canonical_block,560,0,73,40,0,0,2,0,0 +legacy-ixvm-ungrouped,is_unsafe_ci,561,8,23,2,0,0,2,184,2184 +legacy-ixvm-ungrouped,safe_refs_only,562,64,29,10,0,0,2,1856,50304 +legacy-ixvm-ungrouped,assert_safety,563,2,7,4,0,0,2,14,114 +legacy-ixvm-ungrouped,validate_univ_params_seen,564,2,17,16,0,0,2,34,246 +legacy-ixvm-ungrouped,validate_univ_params_list,565,8,8,8,0,0,2,64,1536 +legacy-ixvm-ungrouped,validate_expr_well_scoped,566,64,32,16,0,0,2,2048,60672 +legacy-ixvm-ungrouped,quot_type_addr,567,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,eq_type_addr,568,0,3,4,0,0,1,0,0 +legacy-ixvm-ungrouped,count_foralls_at_least,569,0,13,6,0,0,2,0,0 +legacy-ixvm-ungrouped,check_eq_type,570,0,16,8,0,0,2,0,0 +legacy-ixvm-ungrouped,check_quot,571,0,15,10,0,0,2,0,0 +legacy-ixvm-ungrouped,peel_n_foralls,572,0,11,6,0,0,2,0,0 +legacy-ixvm-ungrouped,assert_lvls_are_params,573,0,13,8,0,0,2,0,0 +legacy-ixvm-ungrouped,assert_first_args_are_param_bvars,574,0,15,8,0,0,2,0,0 +legacy-ixvm-ungrouped,assert_return_head_is_parent,575,0,19,8,0,0,2,0,0 +legacy-ixvm-ungrouped,check_ctor_return_type,576,0,21,24,0,0,2,0,0 +legacy-ixvm-ungrouped,check_param_agreement_go,577,0,18,12,0,0,2,0,0 +legacy-ixvm-ungrouped,check_param_agreement,578,0,6,6,0,0,1,0,0 +legacy-ixvm-ungrouped,get_result_sort_level,579,0,14,10,0,0,2,0,0 +legacy-ixvm-ungrouped,check_field_universes_inner,580,0,13,12,0,0,2,0,0 +legacy-ixvm-ungrouped,check_field_universes_skip_params,581,0,13,8,0,0,2,0,0 +legacy-ixvm-ungrouped,check_field_universes,582,0,11,8,0,0,2,0,0 +legacy-ixvm-ungrouped,addr_list_contains,583,0,12,8,0,0,2,0,0 +legacy-ixvm-ungrouped,caddr_is_peer,584,0,19,8,0,0,2,0,0 +legacy-ixvm-ungrouped,expr_mentions_block,585,0,26,10,0,0,2,0,0 +legacy-ixvm-ungrouped,list_any_mentions_block,586,0,12,8,0,0,2,0,0 +legacy-ixvm-ungrouped,peel_n_foralls_with_types,587,0,15,8,0,0,2,0,0 +legacy-ixvm-ungrouped,assert_occ_param_bvars,588,0,15,8,0,0,2,0,0 +legacy-ixvm-ungrouped,check_valid_ind_app,589,0,23,16,0,0,2,0,0 +legacy-ixvm-ungrouped,check_positivity_aug,590,0,44,30,0,0,2,0,0 +legacy-ixvm-ungrouped,check_nested_ctors_positivity,591,0,28,16,0,0,2,0,0 +legacy-ixvm-ungrouped,check_positivity_fields,592,0,12,10,0,0,2,0,0 +legacy-ixvm-ungrouped,check_positivity,593,0,10,6,0,0,2,0,0 +legacy-ixvm-ungrouped,check_inductive_shape,594,0,12,4,0,0,2,0,0 +legacy-ixvm-ungrouped,check_inductive_shape_ctors,595,0,31,20,0,0,2,0,0 +legacy-ixvm-ungrouped,check_parent_inductive_shape,596,0,16,4,0,0,2,0,0 +legacy-ixvm-ungrouped,check_block_peer_param_agreement,597,0,69,8,0,0,2,0,0 +legacy-ixvm-ungrouped,peer_agree_walk,598,0,80,20,0,0,2,0,0 +legacy-ixvm-ungrouped,is_large_eliminator,599,0,32,8,0,0,2,0,0 +legacy-ixvm-ungrouped,check_large_prop_ctor,600,0,15,8,0,0,2,0,0 +legacy-ixvm-ungrouped,check_large_walk_fields,601,0,24,16,0,0,2,0,0 +legacy-ixvm-ungrouped,all_bvars_in_args,602,0,12,8,0,0,2,0,0 +legacy-ixvm-ungrouped,args_contain_bvar,603,0,16,8,0,0,2,0,0 +legacy-ixvm-ungrouped,compute_k_target,604,0,42,16,0,0,2,0,0 +legacy-ixvm-ungrouped,ind_is_solo,605,0,57,8,0,0,2,0,0 +legacy-ixvm-ungrouped,is_muts_block,606,0,53,4,0,0,2,0,0 +legacy-ixvm-ungrouped,muts_indc_count_is_one,607,0,56,6,0,0,2,0,0 +legacy-ixvm-ungrouped,rec_to_parent_addr,608,0,18,10,0,0,2,0,0 +legacy-ixvm-ungrouped,extract_aux_occ_us,609,0,30,12,0,0,2,0,0 +legacy-ixvm-ungrouped,extract_aux_spec_params,610,0,17,12,0,0,2,0,0 +legacy-ixvm-ungrouped,spec_params_lower,611,0,12,12,0,0,2,0,0 +legacy-ixvm-ungrouped,build_param_lvls_range,612,0,10,8,0,0,2,0,0 +legacy-ixvm-ungrouped,flat_originals_walk,613,0,78,18,0,0,2,0,0 +legacy-ixvm-ungrouped,aux_already_in,614,0,19,10,0,0,2,0,0 +legacy-ixvm-ungrouped,kexpr_struct_eq,615,0,43,12,0,0,2,0,0 +legacy-ixvm-ungrouped,level_list_struct_eq,616,0,16,10,0,0,2,0,0 +legacy-ixvm-ungrouped,spec_params_ptr_eq,617,0,16,10,0,0,2,0,0 +legacy-ixvm-ungrouped,extract_aux_spec_params_from_rec,618,0,18,4,0,0,2,0,0 +legacy-ixvm-ungrouped,first_recr_parent_block,619,0,87,16,0,0,2,0,0 +legacy-ixvm-ungrouped,build_flat_block,620,0,131,24,0,0,2,0,0 +legacy-ixvm-ungrouped,detect_aux_from_recrs_ex,621,0,56,6,0,0,2,0,0 +legacy-ixvm-ungrouped,aux_from_recrs_walk_ex,622,0,106,28,0,0,2,0,0 +legacy-ixvm-ungrouped,flat_find_pos,623,0,17,8,0,0,2,0,0 +legacy-ixvm-ungrouped,flat_find_pos_kind,624,0,29,10,0,0,2,0,0 +legacy-ixvm-ungrouped,flat_member_at,625,0,17,8,0,0,2,0,0 +legacy-ixvm-ungrouped,subst_param_for,626,0,18,18,0,0,2,0,0 +legacy-ixvm-ungrouped,peel_motive_params_subst,627,0,17,10,0,0,2,0,0 +legacy-ixvm-ungrouped,collect_index_doms,628,0,21,14,0,0,2,0,0 +legacy-ixvm-ungrouped,build_major_params,629,0,11,8,0,0,2,0,0 +legacy-ixvm-ungrouped,apply_spec_params_lifted,630,0,12,10,0,0,2,0,0 +legacy-ixvm-ungrouped,build_apply_xs,631,0,10,8,0,0,2,0,0 +legacy-ixvm-ungrouped,wrap_foralls,632,0,10,8,0,0,2,0,0 +legacy-ixvm-ungrouped,collect_n_doms_whnf,633,0,22,14,0,0,2,0,0 +legacy-ixvm-ungrouped,list_lift_indices,634,0,12,10,0,0,2,0,0 +legacy-ixvm-ungrouped,apply_indices_in_conclusion,635,0,10,8,0,0,2,0,0 +legacy-ixvm-ungrouped,build_motive_type_flat,636,0,24,20,0,0,2,0,0 +legacy-ixvm-ungrouped,build_all_motives,637,0,6,4,0,0,1,0,0 +legacy-ixvm-ungrouped,build_motive_apps,638,0,11,8,0,0,2,0,0 +legacy-ixvm-ungrouped,wrap_lams,639,0,10,8,0,0,2,0,0 +legacy-ixvm-ungrouped,build_rec_type,640,0,31,10,0,0,2,0,0 +legacy-ixvm-ungrouped,build_rec_type_from,641,0,58,54,0,0,2,0,0 +legacy-ixvm-ungrouped,check_recursor_canonical_full,642,0,86,38,0,0,2,0,0 +legacy-ixvm-ungrouped,canonical_rules_at_pos,643,0,32,12,0,0,2,0,0 +legacy-ixvm-ungrouped,ctors_before_pos,644,0,32,10,0,0,2,0,0 +legacy-ixvm-ungrouped,populate_rules,645,0,36,12,0,0,2,0,0 +legacy-ixvm-ungrouped,compare_rules,646,0,46,30,0,0,2,0,0 +legacy-ixvm-ungrouped,apply_ihs_full,647,0,44,52,0,0,2,0,0 +legacy-ixvm-ungrouped,build_rule_rhs,648,0,27,10,0,0,2,0,0 +legacy-ixvm-ungrouped,build_peer_recs,649,0,15,10,0,0,2,0,0 +legacy-ixvm-ungrouped,find_peer_recursor_with_spec,650,0,57,6,0,0,2,0,0 +legacy-ixvm-ungrouped,find_peer_rec_spec_walk,651,0,103,24,0,0,2,0,0 +legacy-ixvm-ungrouped,build_flat_own_params,652,0,29,12,0,0,2,0,0 +legacy-ixvm-ungrouped,projection_addr_ctor,653,0,24,6,0,0,2,0,0 +legacy-ixvm-ungrouped,build_minor_doms,654,0,36,14,0,0,2,0,0 +legacy-ixvm-ungrouped,build_all_minors,655,0,8,4,0,0,1,0,0 +legacy-ixvm-ungrouped,build_all_minors_walk,656,0,35,16,0,0,2,0,0 +legacy-ixvm-ungrouped,ctor_subst_param_for,657,0,19,20,0,0,2,0,0 +legacy-ixvm-ungrouped,count_foralls_body,658,0,10,6,0,0,2,0,0 +legacy-ixvm-ungrouped,peel_ctor_params_subst,659,0,26,16,0,0,2,0,0 +legacy-ixvm-ungrouped,build_minor_at_depth,660,0,37,20,0,0,2,0,0 +legacy-ixvm-ungrouped,peel_leading_foralls,661,0,7,4,0,0,2,0,0 +legacy-ixvm-ungrouped,peel_leading_foralls_acc,662,0,12,8,0,0,2,0,0 +legacy-ixvm-ungrouped,build_ih_doms,663,0,34,40,0,0,2,0,0 +legacy-ixvm-ungrouped,list_lift_each,664,0,12,10,0,0,2,0,0 +legacy-ixvm-ungrouped,build_apply_field_bvars,665,0,11,8,0,0,2,0,0 +legacy-ixvm-ungrouped,build_ctor_app_params,666,0,11,4,0,0,2,0,0 +legacy-ixvm-ungrouped,is_rec_field,667,0,7,4,0,0,1,0,0 +legacy-ixvm-ungrouped,is_rec_field_peel,668,0,22,14,0,0,2,0,0 +legacy-ixvm-ungrouped,flat_find_matching,669,0,25,10,0,0,2,0,0 +legacy-ixvm-ungrouped,spec_params_dom_prefix_match,670,0,17,12,0,0,2,0,0 +legacy-ixvm-ungrouped,walk_fields_classify,671,0,24,14,0,0,2,0,0 +legacy-ixvm-ungrouped,build_all_motives_walk,672,0,31,16,0,0,2,0,0 +legacy-ixvm-ungrouped,check_recursor_member,673,0,40,28,0,0,2,0,0 +legacy-ixvm-ungrouped,check_rec_major_spine,674,0,16,10,0,0,2,0,0 +legacy-ixvm-ungrouped,build_rec_lvls_list,675,0,9,8,0,0,2,0,0 +legacy-ixvm-ungrouped,check_rec_rules_wellscoped,676,0,11,8,0,0,2,0,0 +legacy-ixvm-ungrouped,peel_n_lams_collect,677,0,17,8,0,0,2,0,0 +legacy-ixvm-ungrouped,check_const,678,1,42,30,0,0,2,42,228 +legacy-ixvm-ungrouped,run_check,679,1,16,4,0,0,2,16,72 +legacy-ixvm-ungrouped,const_idxs_expr,680,64,34,14,0,0,2,2176,60672 +legacy-ixvm-ungrouped,const_idxs_exprs,681,8,10,10,0,0,2,80,1824 +legacy-ixvm-ungrouped,const_idxs_rules,682,0,18,10,0,0,2,0,0 +legacy-ixvm-ungrouped,const_idxs_ctors,683,0,43,10,0,0,2,0,0 +legacy-ixvm-ungrouped,const_idxs_muts,684,0,58,14,0,0,2,0,0 +legacy-ixvm-ungrouped,const_idxs_of,685,1,61,12,0,0,2,61,231 +legacy-ixvm-ungrouped,g_list_has,686,32,11,6,0,0,2,352,10464 +legacy-ixvm-ungrouped,run_check_transitive,687,0,63,12,0,0,2,0,0 +legacy-ixvm-ungrouped,walk_refs_transitive,688,0,13,10,0,0,2,0,0 +legacy-ixvm-ungrouped,check_muts_all,689,0,54,8,0,0,2,0,0 +legacy-ixvm-ungrouped,check_muts_member_at,690,0,64,6,0,0,2,0,0 +legacy-ixvm-ungrouped,leaf_hash,691,8,7,6,0,0,2,56,1320 +legacy-ixvm-ungrouped,node_hash,692,8,9,6,0,0,2,72,1464 +legacy-ixvm-ungrouped,parse_atree_body,693,16,15,12,0,0,2,240,6144 +legacy-ixvm-ungrouped,load_assumption_tree,694,2,78,8,0,0,2,156,564 +legacy-ixvm-ungrouped,addr_set_build,695,16,25,8,0,0,2,400,7296 +legacy-ixvm-ungrouped,addr_set_member,696,16,10,4,0,0,1,160,3136 +legacy-ixvm-ungrouped,env_walk,697,8,82,16,0,0,2,656,7440 +legacy-ixvm-ungrouped,env_walk_refs,698,8,26,10,0,0,2,208,2976 +legacy-ixvm-ungrouped,env_walk_leaves,699,2,19,8,0,0,2,38,210 +legacy-ixvm-ungrouped,run_check_env,700,1,20,12,0,0,2,20,108 +legacy-ixvm-ungrouped,walk_leaves_owned,701,0,39,10,0,0,2,0,0 +legacy-ixvm-ungrouped,check_owned,702,0,35,6,0,0,1,0,0 +legacy-ixvm-ungrouped,env_walk_all,703,0,90,14,0,0,2,0,0 +legacy-ixvm-ungrouped,env_walk_refs_all,704,0,44,12,0,0,2,0,0 +legacy-ixvm-ungrouped,get_opt_addr,705,1,8,6,0,0,2,8,54 +legacy-ixvm-ungrouped,get_opt_u64_masked,706,0,15,4,0,0,2,0,0 +legacy-ixvm-ungrouped,get_opt_addr_masked,707,0,8,4,0,0,2,0,0 +legacy-ixvm-ungrouped,get_opt_bool_masked,708,0,8,4,0,0,2,0,0 +legacy-ixvm-ungrouped,get_opt_def_kind_masked,709,0,10,4,0,0,2,0,0 +legacy-ixvm-ungrouped,get_opt_quot_kind_masked,710,0,11,4,0,0,2,0,0 +legacy-ixvm-ungrouped,get_reveal_rule_list_inner,711,0,43,12,0,0,2,0,0 +legacy-ixvm-ungrouped,get_opt_rule_list_masked,712,0,17,6,0,0,2,0,0 +legacy-ixvm-ungrouped,get_reveal_ctor_info,713,0,66,10,0,0,2,0,0 +legacy-ixvm-ungrouped,get_ctor_entry,714,0,53,6,0,0,1,0,0 +legacy-ixvm-ungrouped,get_ctor_entry_list_inner,715,0,74,12,0,0,2,0,0 +legacy-ixvm-ungrouped,get_opt_ctor_entry_list_masked,716,0,17,6,0,0,2,0,0 +legacy-ixvm-ungrouped,get_reveal_mut_const_info,717,0,94,28,0,0,2,0,0 +legacy-ixvm-ungrouped,get_mut_entry,718,0,67,6,0,0,1,0,0 +legacy-ixvm-ungrouped,get_mut_entry_list_inner,719,0,88,12,0,0,2,0,0 +legacy-ixvm-ungrouped,get_reveal_info,720,0,102,28,0,0,2,0,0 +legacy-ixvm-ungrouped,expr_addr,721,0,24,6,0,0,2,0,0 +legacy-ixvm-ungrouped,def_safety_tag,722,0,5,2,0,0,2,0,0 +legacy-ixvm-ungrouped,check_opt_def_kind,723,0,8,6,0,0,2,0,0 +legacy-ixvm-ungrouped,check_opt_def_safety,724,0,8,6,0,0,2,0,0 +legacy-ixvm-ungrouped,check_opt_quot_kind,725,0,8,6,0,0,2,0,0 +legacy-ixvm-ungrouped,check_opt_bool,726,0,6,2,0,0,2,0,0 +legacy-ixvm-ungrouped,check_opt_u64,727,0,20,2,0,0,2,0,0 +legacy-ixvm-ungrouped,check_opt_addr,728,0,70,6,0,0,2,0,0 +legacy-ixvm-ungrouped,check_opt_expr_addr,729,0,71,8,0,0,2,0,0 +legacy-ixvm-ungrouped,check_recr_rules,730,0,51,12,0,0,2,0,0 +legacy-ixvm-ungrouped,check_opt_recr_rules,731,0,6,4,0,0,2,0,0 +legacy-ixvm-ungrouped,check_ctor_entry,732,0,85,16,0,0,2,0,0 +legacy-ixvm-ungrouped,check_ctor_entries,733,0,55,8,0,0,2,0,0 +legacy-ixvm-ungrouped,check_opt_ctor_entries,734,0,6,4,0,0,2,0,0 +legacy-ixvm-ungrouped,check_mut_const,735,0,103,20,0,0,2,0,0 +legacy-ixvm-ungrouped,check_muts_components,736,0,114,10,0,0,2,0,0 +legacy-ixvm-ungrouped,run_reveal,737,0,113,22,0,0,2,0,0 +legacy-ixvm-ungrouped,run_contains,738,0,6,6,0,0,1,0,0 +legacy-ixvm-ungrouped,run_claim,739,1,130,34,0,0,2,130,504 +legacy-ixvm-ungrouped,eval_nf,740,0,15,14,0,0,2,0,0 +legacy-ixvm-ungrouped,eval_nf_spine,741,0,13,10,0,0,2,0,0 +legacy-ixvm-ungrouped,eval_body,742,0,19,8,0,0,2,0,0 +legacy-ixvm-ungrouped,eval_output,743,0,57,12,0,0,2,0,0 +legacy-ixvm-ungrouped,run_eval,744,0,22,20,0,0,2,0,0 +legacy-ixvm-ungrouped,verify_claim,745,1,10,4,0,0,1,10,48 +legacy-ixvm-ungrouped,list_lookup_or_default.Ptr.U8_32,746,0,10,6,0,0,2,0,0 +legacy-ixvm-ungrouped,list_snoc.G,747,64,10,8,0,0,2,640,26112 +legacy-ixvm-ungrouped,list_length_u64.U8_8,748,0,30,8,0,0,2,0,0 +legacy-ixvm-ungrouped,list_concat.Tup.Ptr.U8_32.G,749,0,11,8,0,0,2,0,0 +legacy-ixvm-ungrouped,list_length_u64.Ptr.U8_32,750,1,23,8,0,0,2,23,105 +legacy-ixvm-ungrouped,rbtree_map_lookup_or_default.G,751,32,34,20,0,0,2,1088,28224 +legacy-ixvm-ungrouped,list_reverse.G,752,0,5,6,0,0,1,0,0 +legacy-ixvm-ungrouped,list_concat.Ptr.KExprNode,753,64,10,8,0,0,2,640,26112 +legacy-ixvm-ungrouped,list_length.Ptr.KExprNode,754,32,8,6,0,0,2,256,9024 +legacy-ixvm-ungrouped,list_length_u64.Constructor,755,0,56,8,0,0,2,0,0 +legacy-ixvm-ungrouped,list_lookup.Ptr.KLevelNode,756,128,8,6,0,0,2,1024,49920 +legacy-ixvm-ungrouped,list_length.U8_8,757,0,15,6,0,0,2,0,0 +legacy-ixvm-ungrouped,list_lookup_u64.MutConst,758,0,113,10,0,0,2,0,0 +legacy-ixvm-ungrouped,list_length_u64.MutConst,759,0,67,8,0,0,2,0,0 +legacy-ixvm-ungrouped,list_length_u64.RecursorRule,760,0,31,8,0,0,2,0,0 +legacy-ixvm-ungrouped,list_lookup_u64.Constructor,761,0,91,10,0,0,2,0,0 +legacy-ixvm-ungrouped,list_is_empty.U8,762,32,7,4,0,0,2,224,7584 +legacy-ixvm-ungrouped,list_snoc.Tup.Ptr.U8_32.G.Ptr.ListNode.Ptr.KExprNode.Ptr.ListNode.Ptr.KLevelNode,763,0,16,8,0,0,2,0,0 +legacy-ixvm-ungrouped,list_take.Ptr.KExprNode,764,2,11,8,0,0,2,22,162 +legacy-ixvm-ungrouped,list_drop.Ptr.Expr,765,256,10,6,0,0,2,2560,125952 +legacy-ixvm-ungrouped,list_length.KRecRule,766,0,10,6,0,0,2,0,0 +legacy-ixvm-ungrouped,list_depth_checked.U8,767,4096,9,8,0,0,2,36864,3145728 +legacy-ixvm-ungrouped,rbtree_map_insert.G,768,8,16,4,0,0,2,128,1824 +legacy-ixvm-ungrouped,list_length.Tup.Ptr.U8_32.G.Ptr.ListNode.Ptr.KExprNode.Ptr.ListNode.Ptr.KLevelNode,769,0,11,6,0,0,2,0,0 +legacy-ixvm-ungrouped,list_reverse_acc.G,770,0,10,8,0,0,2,0,0 +legacy-ixvm-ungrouped,rbtree_map_ins.G,771,32,45,22,0,0,2,1440,34464 +legacy-ixvm-ungrouped,rbtree_map_balance.G,772,16,24,6,0,0,2,384,6720 +legacy-ixvm-ungrouped,rbtree_map_balance_fix.G,773,16,102,16,0,0,2,1632,23616 +legacy-ixvm-ungrouped,ROM:2,774,0,5,6,0,0,2,0,0 +legacy-ixvm-ungrouped,ROM:3,775,8192,6,6,0,0,2,49152,5210112 +legacy-ixvm-ungrouped,ROM:4,776,512,7,6,0,0,2,3584,241152 +legacy-ixvm-ungrouped,ROM:5,777,0,8,6,0,0,2,0,0 +legacy-ixvm-ungrouped,ROM:6,778,32,9,6,0,0,2,288,9504 +legacy-ixvm-ungrouped,ROM:8,779,1,11,6,0,0,2,11,63 +legacy-ixvm-ungrouped,ROM:9,780,16,12,6,0,0,2,192,4416 +legacy-ixvm-ungrouped,ROM:10,781,16,13,6,0,0,2,208,4608 +legacy-ixvm-ungrouped,ROM:11,782,0,14,6,0,0,2,0,0 +legacy-ixvm-ungrouped,ROM:12,783,16,15,6,0,0,2,240,4992 +legacy-ixvm-ungrouped,ROM:18,784,512,21,6,0,0,2,10752,434688 +legacy-ixvm-ungrouped,ROM:19,785,0,22,6,0,0,2,0,0 +legacy-ixvm-ungrouped,ROM:32,786,128,35,6,0,0,2,4480,122496 +legacy-ixvm-ungrouped,ROM:34,787,32,37,6,0,0,2,1184,22944 +legacy-ixvm-ungrouped,ROM:36,788,4,39,6,0,0,2,156,1224 +legacy-ixvm-ungrouped,ROM:47,789,4,50,6,0,0,2,200,1488 +legacy-ixvm-ungrouped,ROM:50,790,0,53,6,0,0,2,0,0 +legacy-ixvm-ungrouped,ROM:64,791,0,67,6,0,0,2,0,0 +legacy-ixvm-ungrouped,Bytes1,792,256,3,6,11,256,1,768,68608 +legacy-ixvm-ungrouped,Bytes2,793,65536,8,8,11,65536,2,524288,63700992 +legacy-recursion-grouped,verifier_group_00,0,256,68,14,0,0,2,17408,531456 +legacy-recursion-grouped,u64_eq,1,8,27,2,0,0,2,216,2472 +legacy-recursion-grouped,verifier_group_02,2,128,46,12,0,0,2,5888,168192 +legacy-recursion-grouped,verifier_group_03,3,64,207,28,0,0,2,13248,276096 +legacy-recursion-grouped,verifier_group_04,4,64,133,64,0,0,2,8512,232320 +legacy-recursion-grouped,verifier_group_05,5,256,16,6,0,0,2,4096,162816 +legacy-recursion-grouped,verifier_group_06,6,256,39,10,0,0,2,9984,328704 +legacy-recursion-grouped,verifier_group_07,7,128,9,6,0,0,2,1152,52608 +legacy-recursion-grouped,read_u64_vec_n,8,256,18,6,0,0,2,4608,175104 +legacy-recursion-grouped,verifier_group_08,9,512,31,8,0,0,2,15872,600576 +legacy-recursion-grouped,verifier_group_09,10,32,34,6,0,0,2,1088,21504 +legacy-recursion-grouped,verifier_group_10,11,128,81,18,0,0,2,10368,278400 +legacy-recursion-grouped,verifier_group_11,12,128,13,8,0,0,2,1664,68736 +legacy-recursion-grouped,read_proof,13,1,53,22,0,0,2,53,237 +legacy-recursion-grouped,read_header_vec_n,14,2,23,20,0,0,2,46,306 +legacy-recursion-grouped,read_message_vec_n,15,1,20,8,0,0,2,20,96 +legacy-recursion-grouped,read_proof_vec_n,16,2,34,8,0,0,2,68,300 +legacy-recursion-grouped,blake3_compress_chunks,17,1024,17,8,0,0,2,17408,903168 +legacy-recursion-grouped,verifier_group_12,18,128,238,130,0,0,2,30464,1001472 +legacy-recursion-grouped,blake3_compress,19,256,533,388,0,0,2,136448,5686272 +legacy-recursion-grouped,read_vk_u8,20,128,6,4,0,0,2,768,39168 +legacy-recursion-grouped,read_vk_tag,21,8,5,4,0,0,1,40,824 +legacy-recursion-grouped,read_vk_u16,22,32,7,6,0,0,1,224,7328 +legacy-recursion-grouped,verifier_group_13,23,16,108,40,0,0,2,1728,29376 +legacy-recursion-grouped,read_nodes_n,24,8,44,16,0,0,2,352,4704 +legacy-recursion-grouped,verifier_group_14,25,1,14,4,0,0,2,14,66 +legacy-recursion-grouped,select_rows,26,4,30,12,0,0,2,120,1152 +legacy-recursion-grouped,verifier_group_15,27,32,48,26,0,0,2,1536,37824 +legacy-recursion-grouped,rows_pop,28,8,30,12,0,0,2,240,3408 +legacy-recursion-grouped,b3_rows_chunks,29,2,226,42,0,0,2,452,1656 +legacy-recursion-grouped,verifier_group_16,30,512,18,8,0,0,2,9216,420864 +legacy-recursion-grouped,ro_fold,31,16,37,8,0,0,2,592,9600 +legacy-recursion-grouped,bucket_update,32,16,30,8,0,0,2,480,8256 +legacy-recursion-grouped,ri_apply,33,16,30,10,0,0,2,480,8640 +legacy-recursion-grouped,verifier_group_17,34,32,45,14,0,0,2,1440,30624 +legacy-recursion-grouped,cons8,35,128,19,10,0,0,2,2432,90240 +legacy-recursion-grouped,eval_at,36,8,43,8,0,0,2,344,4056 +legacy-recursion-grouped,count_onto,37,8,18,6,0,0,2,144,2112 +legacy-recursion-grouped,claims_onto,38,1,7,4,0,0,2,7,45 +legacy-recursion-grouped,claims_onto_each,39,2,12,12,0,0,2,24,192 +legacy-recursion-grouped,header_onto,40,1,13,14,0,0,2,13,93 +legacy-recursion-grouped,headers_onto,41,2,13,8,0,0,2,26,174 +legacy-recursion-grouped,messages_onto,42,1,7,4,0,0,2,7,45 +legacy-recursion-grouped,messages_onto_each,43,1,21,14,0,0,2,21,117 +legacy-recursion-grouped,batch_fiat_shamir,44,1,69,30,0,0,2,69,309 +legacy-recursion-grouped,shard_fiat_shamir,45,1,62,14,0,0,2,62,240 +legacy-recursion-grouped,assert_same_u8s,46,4,12,8,0,0,2,48,624 +legacy-recursion-grouped,assert_same_limbs,47,8,27,10,0,0,2,216,3048 +legacy-recursion-grouped,assert_same_claims,48,2,13,10,0,0,2,26,186 +legacy-recursion-grouped,assert_same_cap,49,2,80,20,0,0,2,160,648 +legacy-recursion-grouped,last_acc,50,1,15,8,0,0,2,15,81 +legacy-recursion-grouped,messages_acc,51,1,35,8,0,0,2,35,141 +legacy-recursion-grouped,log_degree_ok,52,1,69,2,0,0,2,69,225 +legacy-recursion-grouped,assert_log_degrees_ok,53,2,9,8,0,0,2,18,150 +legacy-recursion-grouped,count_ones,54,2,8,6,0,0,2,16,132 +legacy-recursion-grouped,assert_shard_count_ok,55,1,20,6,0,0,2,20,90 +legacy-recursion-grouped,three_limbs,56,0,43,10,0,0,2,0,0 +legacy-recursion-grouped,le_step,57,0,9,2,0,0,2,0,0 +legacy-recursion-grouped,bytes8_le,58,0,26,10,0,0,2,0,0 +legacy-recursion-grouped,assert_closure_pairs,59,1,161,66,0,0,2,161,693 +legacy-recursion-grouped,verify_shard,60,1,142,108,0,0,2,142,762 +legacy-recursion-grouped,verify_shards,61,2,61,10,0,0,2,122,474 +legacy-recursion-grouped,batch_claims,62,2,12,8,0,0,2,24,168 +legacy-recursion-grouped,verify_batch,63,1,41,22,0,0,2,41,201 +legacy-recursion-grouped,verify_multi_stark_proof,64,1,218,42,0,0,2,218,792 +legacy-recursion-grouped,verifier_group_19,65,128,13,6,0,0,2,1664,63360 +legacy-recursion-grouped,list_length.Proof,66,2,31,6,0,0,2,62,270 +legacy-recursion-grouped,list_concat.Ptr.ListNode.U8_8,67,512,10,8,0,0,2,5120,310272 +legacy-recursion-grouped,list_length.U8_8,68,8,15,6,0,0,2,120,1896 +legacy-recursion-grouped,list_lookup.SysNode,69,8,11,6,0,0,2,88,1608 +legacy-recursion-grouped,list_is_empty.U8,70,8,7,4,0,0,2,56,1176 +legacy-recursion-grouped,ROM:3,71,4096,6,6,0,0,2,24576,2408448 +legacy-recursion-grouped,ROM:4,72,32,7,6,0,0,2,224,8544 +legacy-recursion-grouped,ROM:5,73,1,8,6,0,0,2,8,54 +legacy-recursion-grouped,ROM:6,74,128,9,6,0,0,2,1152,52608 +legacy-recursion-grouped,ROM:7,75,8,10,6,0,0,2,80,1536 +legacy-recursion-grouped,ROM:8,76,1,11,6,0,0,2,11,63 +legacy-recursion-grouped,ROM:10,77,32,13,6,0,0,2,416,11424 +legacy-recursion-grouped,ROM:11,78,2,14,6,0,0,2,28,168 +legacy-recursion-grouped,ROM:26,79,2,29,6,0,0,2,58,258 +legacy-recursion-grouped,ROM:32,80,16,35,6,0,0,2,560,8832 +legacy-recursion-grouped,ROM:34,81,16,37,6,0,0,2,592,9216 +legacy-recursion-grouped,Bytes1,82,256,3,6,11,256,1,768,68608 +legacy-recursion-grouped,Bytes2,83,65536,8,8,11,65536,2,524288,63700992 +legacy-recursion-real-grouped,verifier_group_00,0,262144,68,14,0,0,2,17825792,1220542464 +legacy-recursion-real-grouped,u64_eq,1,16,27,2,0,0,2,432,6528 +legacy-recursion-real-grouped,verifier_group_02,2,8192,46,12,0,0,2,376832,19906560 +legacy-recursion-real-grouped,verifier_group_03,3,32768,207,28,0,0,2,6782976,352813056 +legacy-recursion-real-grouped,verifier_group_04,4,16384,133,64,0,0,2,2179072,138510336 +legacy-recursion-real-grouped,verifier_group_05,5,262144,16,6,0,0,2,4194304,371195904 +legacy-recursion-real-grouped,verifier_group_06,6,8192,39,10,0,0,2,319488,17031168 +legacy-recursion-real-grouped,verifier_group_07,7,131072,9,6,0,0,2,1179648,128581632 +legacy-recursion-real-grouped,read_u64_vec_n,8,1048576,18,6,0,0,2,18874368,1774190592 +legacy-recursion-real-grouped,verifier_group_08,9,32768,31,8,0,0,2,1015808,63799296 +legacy-recursion-real-grouped,verifier_group_09,10,65536,34,6,0,0,2,2228224,139198464 +legacy-recursion-real-grouped,verifier_group_10,11,16384,81,18,0,0,2,1327104,71073792 +legacy-recursion-real-grouped,verifier_group_11,12,131072,13,8,0,0,2,1703936,168689664 +legacy-recursion-real-grouped,read_proof,13,1,53,22,0,0,2,53,237 +legacy-recursion-real-grouped,read_header_vec_n,14,2,23,20,0,0,2,46,306 +legacy-recursion-real-grouped,read_message_vec_n,15,32,20,8,0,0,2,640,15744 +legacy-recursion-real-grouped,read_proof_vec_n,16,2,34,8,0,0,2,68,300 +legacy-recursion-real-grouped,blake3_compress_chunks,17,2097152,17,8,0,0,2,35651584,3856662528 +legacy-recursion-real-grouped,verifier_group_12,18,65536,238,130,0,0,2,15597568,1170997248 +legacy-recursion-real-grouped,blake3_compress,19,1048576,533,388,0,0,2,558891008,58208550912 +legacy-recursion-real-grouped,read_vk_u8,20,1048576,6,4,0,0,2,6291456,893386752 +legacy-recursion-real-grouped,read_vk_tag,21,131072,5,4,0,0,1,655360,74055680 +legacy-recursion-real-grouped,read_vk_u16,22,524288,7,6,0,0,1,3670016,450363392 +legacy-recursion-real-grouped,verifier_group_13,23,128,108,40,0,0,2,13824,410112 +legacy-recursion-real-grouped,read_nodes_n,24,131072,44,16,0,0,2,5767168,429391872 +legacy-recursion-real-grouped,verifier_group_14,25,32768,14,4,0,0,2,458752,32833536 +legacy-recursion-real-grouped,select_rows,26,1048576,30,12,0,0,2,31457280,2906652672 +legacy-recursion-real-grouped,verifier_group_15,27,131072,48,26,0,0,2,6291456,522977280 +legacy-recursion-real-grouped,rows_pop,28,1048576,30,12,0,0,2,31457280,2906652672 +legacy-recursion-real-grouped,b3_rows_chunks,29,131072,226,42,0,0,2,29622272,1819803648 +legacy-recursion-real-grouped,verifier_group_16,30,65536,18,8,0,0,2,1179648,95158272 +legacy-recursion-real-grouped,ro_fold,31,2097152,37,8,0,0,2,77594624,6499074048 +legacy-recursion-real-grouped,bucket_update,32,1048576,30,8,0,0,2,31457280,2654994432 +legacy-recursion-real-grouped,ri_apply,33,65536,30,10,0,0,2,1966080,139198464 +legacy-recursion-real-grouped,verifier_group_17,34,131072,45,14,0,0,2,5898240,422707200 +legacy-recursion-real-grouped,cons8,35,65536,19,10,0,0,2,1245184,104595456 +legacy-recursion-real-grouped,eval_at,36,131072,43,8,0,0,2,5636096,369229824 +legacy-recursion-real-grouped,count_onto,37,64,18,6,0,0,2,1152,33024 +legacy-recursion-real-grouped,claims_onto,38,1,7,4,0,0,2,7,45 +legacy-recursion-real-grouped,claims_onto_each,39,2,12,12,0,0,2,24,192 +legacy-recursion-real-grouped,header_onto,40,1,13,14,0,0,2,13,93 +legacy-recursion-real-grouped,headers_onto,41,2,13,8,0,0,2,26,174 +legacy-recursion-real-grouped,messages_onto,42,1,7,4,0,0,2,7,45 +legacy-recursion-real-grouped,messages_onto_each,43,32,21,14,0,0,2,672,19104 +legacy-recursion-real-grouped,batch_fiat_shamir,44,1,69,30,0,0,2,69,309 +legacy-recursion-real-grouped,shard_fiat_shamir,45,1,62,14,0,0,2,62,240 +legacy-recursion-real-grouped,assert_same_u8s,46,512,12,8,0,0,2,6144,337920 +legacy-recursion-real-grouped,assert_same_limbs,47,16,27,10,0,0,2,432,8064 +legacy-recursion-real-grouped,assert_same_claims,48,2,13,10,0,0,2,26,186 +legacy-recursion-real-grouped,assert_same_cap,49,2,80,20,0,0,2,160,648 +legacy-recursion-real-grouped,last_acc,50,256,15,8,0,0,2,3840,168960 +legacy-recursion-real-grouped,messages_acc,51,32,35,8,0,0,2,1120,22944 +legacy-recursion-real-grouped,log_degree_ok,52,32,69,2,0,0,2,2208,36384 +legacy-recursion-real-grouped,assert_log_degrees_ok,53,256,9,8,0,0,2,2304,132096 +legacy-recursion-real-grouped,count_ones,54,256,8,6,0,0,2,2048,113664 +legacy-recursion-real-grouped,assert_shard_count_ok,55,1,20,6,0,0,2,20,90 +legacy-recursion-real-grouped,three_limbs,56,32,43,10,0,0,2,1376,27744 +legacy-recursion-real-grouped,le_step,57,64,9,2,0,0,2,576,18048 +legacy-recursion-real-grouped,bytes8_le,58,64,26,10,0,0,2,1664,46848 +legacy-recursion-real-grouped,assert_closure_pairs,59,16,161,66,0,0,2,2576,44544 +legacy-recursion-real-grouped,verify_shard,60,1,142,108,0,0,2,142,762 +legacy-recursion-real-grouped,verify_shards,61,2,61,10,0,0,2,122,474 +legacy-recursion-real-grouped,batch_claims,62,2,12,8,0,0,2,24,168 +legacy-recursion-real-grouped,verify_batch,63,1,41,22,0,0,2,41,201 +legacy-recursion-real-grouped,verify_multi_stark_proof,64,1,218,42,0,0,2,218,792 +legacy-recursion-real-grouped,verifier_group_19,65,131072,13,6,0,0,2,1703936,155320320 +legacy-recursion-real-grouped,list_length.Proof,66,2,31,6,0,0,2,62,270 +legacy-recursion-real-grouped,list_concat.Ptr.ListNode.U8_8,67,2048,10,8,0,0,2,20480,1511424 +legacy-recursion-real-grouped,list_length.U8_8,68,1048576,15,6,0,0,2,15728640,1585446912 +legacy-recursion-real-grouped,list_lookup.SysNode,69,131072,11,6,0,0,2,1441792,141950976 +legacy-recursion-real-grouped,list_is_empty.U8,70,32768,7,4,0,0,2,229376,22511616 +legacy-recursion-real-grouped,ROM:3,71,4194304,6,6,0,0,2,25165824,4479516672 +legacy-recursion-real-grouped,ROM:4,72,32768,7,6,0,0,2,229376,25460736 +legacy-recursion-real-grouped,ROM:5,73,32,8,6,0,0,2,256,9024 +legacy-recursion-real-grouped,ROM:6,74,262144,9,6,0,0,2,2359296,272105472 +legacy-recursion-real-grouped,ROM:7,75,1048576,10,6,0,0,2,10485760,1270874112 +legacy-recursion-real-grouped,ROM:8,76,1024,11,6,0,0,2,11264,657408 +legacy-recursion-real-grouped,ROM:10,77,1048576,13,6,0,0,2,13631488,1459617792 +legacy-recursion-real-grouped,ROM:11,78,512,14,6,0,0,2,7168,337920 +legacy-recursion-real-grouped,ROM:26,79,2,29,6,0,0,2,58,258 +legacy-recursion-real-grouped,ROM:32,80,131072,35,6,0,0,2,4587520,302383104 +legacy-recursion-real-grouped,ROM:34,81,16384,37,6,0,0,2,606208,32538624 +legacy-recursion-real-grouped,Bytes1,82,256,3,6,11,256,1,768,68608 +legacy-recursion-real-grouped,Bytes2,83,65536,8,8,11,65536,2,524288,63700992 +legacy-recursion-real-ungrouped,memo_u32_less_than,0,262144,10,8,0,0,2,2621440,314572800 +legacy-recursion-real-ungrouped,u64_is_zero,1,1024,19,2,0,0,2,19456,780288 +legacy-recursion-real-ungrouped,u64_eq,2,16,27,2,0,0,2,432,6528 +legacy-recursion-real-ungrouped,relaxed_u64_succ,3,1024,19,2,0,0,2,19456,780288 +legacy-recursion-real-ungrouped,flatten_u64,4,128,10,2,0,0,1,1280,38144 +legacy-recursion-real-ungrouped,read_u8,5,128,8,6,0,0,2,1024,49920 +legacy-recursion-real-ungrouped,read_u64,6,16,19,10,0,0,2,304,6528 +legacy-recursion-real-ungrouped,read_count,7,2,13,6,0,0,1,26,134 +legacy-recursion-real-ungrouped,read_count_at,8,65536,13,4,0,0,1,851968,60030976 +legacy-recursion-real-ungrouped,read_active_n,9,1024,11,6,0,0,2,11264,657408 +legacy-recursion-real-ungrouped,read_u64_vec,10,65536,7,6,0,0,1,458752,47448064 +legacy-recursion-real-ungrouped,read_u64_vec_n,11,1048576,18,6,0,0,2,18874368,1774190592 +legacy-recursion-real-ungrouped,read_ext_vec,12,4096,7,6,0,0,1,28672,2228224 +legacy-recursion-real-ungrouped,read_ext_vec_n,13,32768,27,6,0,0,2,884736,54951936 +legacy-recursion-real-ungrouped,read_digest_vec_at,14,64,7,6,0,0,1,448,17536 +legacy-recursion-real-ungrouped,read_digest_vec_at_n,15,16384,46,8,0,0,2,753664,40108032 +legacy-recursion-real-ungrouped,read_u64_vec_vec_n,16,65536,11,8,0,0,2,720896,73138176 +legacy-recursion-real-ungrouped,read_u64_vec_vec_vec_n,17,512,13,10,0,0,2,6656,379392 +legacy-recursion-real-ungrouped,read_ext_vec_vec,18,1024,7,6,0,0,1,7168,464896 +legacy-recursion-real-ungrouped,read_ext_vec_vec_n,19,4096,11,8,0,0,2,45056,3440640 +legacy-recursion-real-ungrouped,read_opened_round,20,4,7,6,0,0,1,28,376 +legacy-recursion-real-ungrouped,read_opened_round_n,21,1024,11,8,0,0,2,11264,718848 +legacy-recursion-real-ungrouped,read_merkle_cap_vec_n,22,32,11,8,0,0,2,352,11424 +legacy-recursion-real-ungrouped,read_batch_opening_vec_n,23,8,15,12,0,0,2,120,2328 +legacy-recursion-real-ungrouped,read_commit_phase_step_vec_n,24,32,17,12,0,0,2,544,16224 +legacy-recursion-real-ungrouped,read_preprocessed,25,1,9,4,0,0,2,9,51 +legacy-recursion-real-ungrouped,read_proof,26,1,53,22,0,0,2,53,237 +legacy-recursion-real-ungrouped,read_header_vec_n,27,2,23,20,0,0,2,46,306 +legacy-recursion-real-ungrouped,read_message_vec_n,28,32,20,8,0,0,2,640,15744 +legacy-recursion-real-ungrouped,read_proof_vec_n,29,2,34,8,0,0,2,68,300 +legacy-recursion-real-ungrouped,blake3_next_layer,30,16384,175,12,0,0,2,2867200,131629056 +legacy-recursion-real-ungrouped,blake3_compress_layer,31,8192,141,12,0,0,2,1155072,50257920 +legacy-recursion-real-ungrouped,blake3_compress_chunks,32,2097152,17,8,0,0,2,35651584,3856662528 +legacy-recursion-real-ungrouped,bytes_to_block,33,32768,195,130,0,0,2,6389760,485523456 +legacy-recursion-real-ungrouped,pad_block,34,1024,8,6,0,0,2,8192,565248 +legacy-recursion-real-ungrouped,blake3_finish,35,64,160,16,0,0,2,10240,208128 +legacy-recursion-real-ungrouped,blake3_compress_block,36,32768,161,26,0,0,2,5275648,282034176 +legacy-recursion-real-ungrouped,blake3_compress,37,1048576,533,388,0,0,2,558891008,58208550912 +legacy-recursion-real-ungrouped,read_vk_u8,38,1048576,6,4,0,0,2,6291456,893386752 +legacy-recursion-real-ungrouped,read_vk_tag,39,131072,5,4,0,0,1,655360,74055680 +legacy-recursion-real-ungrouped,read_vk_u16,40,524288,7,6,0,0,1,3670016,450363392 +legacy-recursion-real-ungrouped,read_vk_u16_limb,41,1024,7,6,0,0,1,7168,464896 +legacy-recursion-real-ungrouped,read_vk_u32_limb,42,256,11,6,0,0,2,2816,132096 +legacy-recursion-real-ungrouped,read_vk_u64,43,1024,19,10,0,0,2,19456,1026048 +legacy-recursion-real-ungrouped,read_field,44,1024,12,4,0,0,1,12288,557056 +legacy-recursion-real-ungrouped,read_vk_cap_n,45,2,46,16,0,0,2,92,420 +legacy-recursion-real-ungrouped,read_nodes_n,46,131072,44,16,0,0,2,5767168,429391872 +legacy-recursion-real-ungrouped,read_node_ids_n,47,65536,11,8,0,0,2,720896,73138176 +legacy-recursion-real-ungrouped,read_sys_lookups_n,48,4096,15,12,0,0,2,61440,4620288 +legacy-recursion-real-ungrouped,lookup_groups_count,49,512,10,4,0,0,2,5120,254976 +legacy-recursion-real-ungrouped,read_sys_circuits_n,50,256,113,68,0,0,2,28928,1139712 +legacy-recursion-real-ungrouped,read_opt_commit,51,1,11,8,0,0,2,11,69 +legacy-recursion-real-ungrouped,read_opt_idx_n,52,256,13,8,0,0,2,3328,156672 +legacy-recursion-real-ungrouped,b3_w4_onto,53,512,11,6,0,0,2,5632,296448 +legacy-recursion-real-ungrouped,mmcs_compress,54,16384,101,6,0,0,2,1654784,76578816 +legacy-recursion-real-ungrouped,compress_ordered,55,16384,8,4,0,0,2,131072,11206656 +legacy-recursion-real-ungrouped,has_height,56,2048,13,6,0,0,2,26624,1579008 +legacy-recursion-real-ungrouped,select_rows,57,1048576,30,12,0,0,2,31457280,2906652672 +legacy-recursion-real-ungrouped,select_rows_le,58,131072,34,24,0,0,2,4456448,416022528 +legacy-recursion-real-ungrouped,rows_pop,59,1048576,30,12,0,0,2,31457280,2906652672 +legacy-recursion-real-ungrouped,b3_rows_chunks,60,131072,226,42,0,0,2,29622272,1819803648 +legacy-recursion-real-ungrouped,leaf_hash_at,61,4096,44,10,0,0,2,180224,8601600 +legacy-recursion-real-ungrouped,inject_maybe,62,16384,11,8,0,0,2,180224,16023552 +legacy-recursion-real-ungrouped,bits_to_num,63,1024,8,6,0,0,2,8192,565248 +legacy-recursion-real-ungrouped,frontier_merge,64,8192,27,12,0,0,2,221184,13836288 +legacy-recursion-real-ungrouped,frontier_split,65,8192,21,12,0,0,2,172032,11919360 +legacy-recursion-real-ungrouped,frontier_sort,66,4096,22,14,0,0,2,90112,5947392 +legacy-recursion-real-ungrouped,frontier_leaves,67,2048,17,14,0,0,2,34816,2390016 +legacy-recursion-real-ungrouped,frontier_level,68,16384,40,26,0,0,2,655360,48365568 +legacy-recursion-real-ungrouped,frontier_fold,69,512,12,6,0,0,2,6144,310272 +legacy-recursion-real-ungrouped,mmcs_verify_multi,70,32,27,20,0,0,2,864,24864 +legacy-recursion-real-ungrouped,rev_onto,71,16384,10,8,0,0,2,163840,15335424 +legacy-recursion-real-ungrouped,exp_by_bits,72,16384,13,6,0,0,2,212992,16023552 +legacy-recursion-real-ungrouped,fri_fold2,73,1024,34,6,0,0,2,34816,1363968 +legacy-recursion-real-ungrouped,ro_fold,74,2097152,37,8,0,0,2,77594624,6499074048 +legacy-recursion-real-ungrouped,accs_onto,75,32768,38,26,0,0,2,1245184,100663296 +legacy-recursion-real-ungrouped,points_onto,76,2048,10,8,0,0,2,20480,1511424 +legacy-recursion-real-ungrouped,round_onto,77,1024,10,8,0,0,2,10240,688128 +legacy-recursion-real-ungrouped,obs_log_arities,78,32,10,8,0,0,2,320,10944 +legacy-recursion-real-ungrouped,pcs_check_witness,79,32,20,10,0,0,2,640,16704 +legacy-recursion-real-ungrouped,pcs_betas,80,32,44,16,0,0,2,1408,31104 +legacy-recursion-real-ungrouped,circ_has_height,81,2048,15,6,0,0,2,30720,1714176 +legacy-recursion-real-ungrouped,build_buckets,82,32,13,8,0,0,2,416,12384 +legacy-recursion-real-ungrouped,bucket_update,83,1048576,30,8,0,0,2,31457280,2654994432 +legacy-recursion-real-ungrouped,assert_blowup_zero,84,1024,20,6,0,0,2,20480,933888 +legacy-recursion-real-ungrouped,prep_count,85,1,5,2,0,0,2,5,33 +legacy-recursion-real-ungrouped,ri_apply,86,65536,30,10,0,0,2,1966080,139198464 +legacy-recursion-real-ungrouped,open_2pt_mat,87,32768,20,6,0,0,2,655360,44630016 +legacy-recursion-real-ungrouped,open_batch_2pt,88,32768,22,12,0,0,2,720896,56426496 +legacy-recursion-real-ungrouped,open_quotient,89,16384,23,14,0,0,2,376832,28409856 +legacy-recursion-real-ungrouped,open_prep,90,16384,27,14,0,0,2,442368,31162368 +legacy-recursion-real-ungrouped,open_prep_batch,91,64,26,14,0,0,2,1664,51456 +legacy-recursion-real-ungrouped,heights_all,92,256,11,8,0,0,2,2816,144384 +legacy-recursion-real-ungrouped,heights_max,93,4,16,18,0,0,2,64,960 +legacy-recursion-real-ungrouped,heights_prep,94,256,15,10,0,0,2,3840,181248 +legacy-recursion-real-ungrouped,rollin,95,1024,25,6,0,0,2,25600,1087488 +legacy-recursion-real-ungrouped,verify_query,96,1024,102,64,0,0,2,104448,5234688 +legacy-recursion-real-ungrouped,verify_one_query,97,64,72,40,0,0,2,4608,134400 +legacy-recursion-real-ungrouped,query_loop,98,128,38,12,0,0,2,4864,146688 +legacy-recursion-real-ungrouped,sample_query_indices,99,128,13,8,0,0,2,1664,68736 +legacy-recursion-real-ungrouped,batch_views_at,100,512,12,10,0,0,2,6144,365568 +legacy-recursion-real-ungrouped,step_views_at,101,2048,13,10,0,0,2,26624,1849344 +legacy-recursion-real-ungrouped,query_views,102,128,12,10,0,0,2,1536,71424 +legacy-recursion-real-ungrouped,verify_input_multi,103,1,32,26,0,0,2,32,186 +legacy-recursion-real-ungrouped,drop_index_bits,104,2048,11,10,0,0,2,22528,1714176 +legacy-recursion-real-ungrouped,rows_at_round,105,2048,13,14,0,0,2,26624,2119680 +legacy-recursion-real-ungrouped,verify_commit_multi,106,32,25,22,0,0,2,800,24864 +legacy-recursion-real-ungrouped,cons8,107,65536,19,10,0,0,2,1245184,104595456 +legacy-recursion-real-ungrouped,cap_onto,108,32,45,16,0,0,2,1440,31584 +legacy-recursion-real-ungrouped,log_degrees_onto,109,512,10,8,0,0,2,5120,310272 +legacy-recursion-real-ungrouped,ch_sample8,110,128,78,50,0,0,2,9984,356352 +legacy-recursion-real-ungrouped,ch_sample_field,111,64,31,6,0,0,2,1984,48000 +legacy-recursion-real-ungrouped,ch_sample_ext,112,32,24,6,0,0,1,768,15488 +legacy-recursion-real-ungrouped,take_bits,113,2048,11,8,0,0,2,22528,1579008 +legacy-recursion-real-ungrouped,ch_sample_bits,114,64,53,12,0,0,2,3392,80256 +legacy-recursion-real-ungrouped,snoc_b8,115,32,14,4,0,0,2,448,10944 +legacy-recursion-real-ungrouped,snoc_cap,116,32,7,4,0,0,2,224,7584 +legacy-recursion-real-ungrouped,limbs_onto,117,2048,17,8,0,0,2,34816,1984512 +legacy-recursion-real-ungrouped,ext_exp_pow2,118,256,13,4,0,0,2,3328,132096 +legacy-recursion-real-ungrouped,two_adic_gen,119,64,9,4,0,0,2,576,20352 +legacy-recursion-real-ungrouped,pow2,120,32,6,4,0,0,2,192,7104 +legacy-recursion-real-ungrouped,ood_fold,121,32768,12,2,0,0,2,393216,26935296 +legacy-recursion-real-ungrouped,from_ext_basis,122,512,6,2,0,0,1,3072,140288 +legacy-recursion-real-ungrouped,reconstruct_ext_row,123,512,16,12,0,0,2,8192,448512 +legacy-recursion-real-ungrouped,eval_at,124,131072,43,8,0,0,2,5636096,369229824 +legacy-recursion-real-ungrouped,fold_roots,125,16384,31,10,0,0,2,507904,31162368 +legacy-recursion-real-ungrouped,pair_mul,126,32768,26,2,0,0,2,851968,47579136 +legacy-recursion-real-ungrouped,logup_fingerprint,127,32768,35,10,0,0,2,1146880,72646656 +legacy-recursion-real-ungrouped,logup_steps_fold,128,2048,94,28,0,0,2,192512,8540160 +legacy-recursion-real-ungrouped,quotient_eval,129,512,22,6,0,0,2,11264,448512 +legacy-recursion-real-ungrouped,quotient_degree_of,130,2,39,2,0,0,2,78,294 +legacy-recursion-real-ungrouped,ood_loop,131,256,179,100,0,0,2,45824,1741824 +legacy-recursion-real-ungrouped,fingerprint_vals,132,128,22,6,0,0,2,2816,87552 +legacy-recursion-real-ungrouped,claims_acc,133,2,25,8,0,0,2,50,246 +legacy-recursion-real-ungrouped,assert_bits,134,256,9,6,0,0,2,2304,119808 +legacy-recursion-real-ungrouped,select_active_circuits,135,256,23,10,0,0,2,5888,230400 +legacy-recursion-real-ungrouped,select_active_prep,136,256,16,10,0,0,2,4096,187392 +legacy-recursion-real-ungrouped,count_onto,137,64,18,6,0,0,2,1152,33024 +legacy-recursion-real-ungrouped,claims_onto,138,1,7,4,0,0,2,7,45 +legacy-recursion-real-ungrouped,claims_onto_each,139,2,12,12,0,0,2,24,192 +legacy-recursion-real-ungrouped,header_onto,140,1,13,14,0,0,2,13,93 +legacy-recursion-real-ungrouped,headers_onto,141,2,13,8,0,0,2,26,174 +legacy-recursion-real-ungrouped,messages_onto,142,1,7,4,0,0,2,7,45 +legacy-recursion-real-ungrouped,messages_onto_each,143,32,21,14,0,0,2,672,19104 +legacy-recursion-real-ungrouped,batch_fiat_shamir,144,1,69,30,0,0,2,69,309 +legacy-recursion-real-ungrouped,shard_fiat_shamir,145,1,62,14,0,0,2,62,240 +legacy-recursion-real-ungrouped,assert_same_u8s,146,512,12,8,0,0,2,6144,337920 +legacy-recursion-real-ungrouped,assert_same_limbs,147,16,27,10,0,0,2,432,8064 +legacy-recursion-real-ungrouped,assert_same_claims,148,2,13,10,0,0,2,26,186 +legacy-recursion-real-ungrouped,assert_same_cap,149,2,80,20,0,0,2,160,648 +legacy-recursion-real-ungrouped,last_acc,150,256,15,8,0,0,2,3840,168960 +legacy-recursion-real-ungrouped,messages_acc,151,32,35,8,0,0,2,1120,22944 +legacy-recursion-real-ungrouped,log_degree_ok,152,32,69,2,0,0,2,2208,36384 +legacy-recursion-real-ungrouped,assert_log_degrees_ok,153,256,9,8,0,0,2,2304,132096 +legacy-recursion-real-ungrouped,count_ones,154,256,8,6,0,0,2,2048,113664 +legacy-recursion-real-ungrouped,assert_shard_count_ok,155,1,20,6,0,0,2,20,90 +legacy-recursion-real-ungrouped,three_limbs,156,32,43,10,0,0,2,1376,27744 +legacy-recursion-real-ungrouped,le_step,157,64,9,2,0,0,2,576,18048 +legacy-recursion-real-ungrouped,bytes8_le,158,64,26,10,0,0,2,1664,46848 +legacy-recursion-real-ungrouped,assert_closure_pairs,159,16,161,66,0,0,2,2576,44544 +legacy-recursion-real-ungrouped,verify_shard,160,1,142,108,0,0,2,142,762 +legacy-recursion-real-ungrouped,verify_shards,161,2,61,10,0,0,2,122,474 +legacy-recursion-real-ungrouped,batch_claims,162,2,12,8,0,0,2,24,168 +legacy-recursion-real-ungrouped,verify_batch,163,1,41,22,0,0,2,41,201 +legacy-recursion-real-ungrouped,read_claims_n,164,2,13,10,0,0,2,26,186 +legacy-recursion-real-ungrouped,read_claim_vals_n,165,16,18,8,0,0,2,288,5952 +legacy-recursion-real-ungrouped,verify_multi_stark_proof,166,1,218,42,0,0,2,218,792 +legacy-recursion-real-ungrouped,list_lookup.BatchOpening,167,65536,8,6,0,0,2,524288,57409536 +legacy-recursion-real-ungrouped,list_length.Proof,168,2,31,6,0,0,2,62,270 +legacy-recursion-real-ungrouped,list_length.Ptr.U8_8_4,169,65536,8,6,0,0,2,524288,57409536 +legacy-recursion-real-ungrouped,list_length.CommitPhaseProofStep,170,32768,9,6,0,0,2,294912,28409856 +legacy-recursion-real-ungrouped,list_concat.Ptr.ListNode.U8_8,171,2048,10,8,0,0,2,20480,1511424 +legacy-recursion-real-ungrouped,list_length.FrontierNode,172,2,11,6,0,0,2,22,150 +legacy-recursion-real-ungrouped,list_length.Bucket,173,1,12,6,0,0,2,12,66 +legacy-recursion-real-ungrouped,list_length.U8_8,174,1048576,15,6,0,0,2,15728640,1585446912 +legacy-recursion-real-ungrouped,list_length.SysCircuit,175,512,16,6,0,0,2,8192,365568 +legacy-recursion-real-ungrouped,list_lookup.SysNode,176,131072,11,6,0,0,2,1441792,141950976 +legacy-recursion-real-ungrouped,list_is_empty.U8,177,32768,7,4,0,0,2,229376,22511616 +legacy-recursion-real-ungrouped,list_lookup.G_2,178,16384,9,6,0,0,2,147456,13271040 +legacy-recursion-real-ungrouped,list_concat.U8_8,179,8,17,8,0,0,2,136,2184 +legacy-recursion-real-ungrouped,list_length.CommitPhaseMultiStep,180,32,10,6,0,0,2,320,9984 +legacy-recursion-real-ungrouped,list_drop.G,181,65536,10,6,0,0,2,655360,63700992 +legacy-recursion-real-ungrouped,list_drop.G_2,182,16384,11,6,0,0,2,180224,14647296 +legacy-recursion-real-ungrouped,list_drop.SysNode,183,131072,13,6,0,0,2,1703936,155320320 +legacy-recursion-real-ungrouped,ROM:3,184,4194304,6,6,0,0,2,25165824,4479516672 +legacy-recursion-real-ungrouped,ROM:4,185,32768,7,6,0,0,2,229376,25460736 +legacy-recursion-real-ungrouped,ROM:5,186,32,8,6,0,0,2,256,9024 +legacy-recursion-real-ungrouped,ROM:6,187,262144,9,6,0,0,2,2359296,272105472 +legacy-recursion-real-ungrouped,ROM:7,188,1048576,10,6,0,0,2,10485760,1270874112 +legacy-recursion-real-ungrouped,ROM:8,189,1024,11,6,0,0,2,11264,657408 +legacy-recursion-real-ungrouped,ROM:10,190,1048576,13,6,0,0,2,13631488,1459617792 +legacy-recursion-real-ungrouped,ROM:11,191,512,14,6,0,0,2,7168,337920 +legacy-recursion-real-ungrouped,ROM:26,192,2,29,6,0,0,2,58,258 +legacy-recursion-real-ungrouped,ROM:32,193,131072,35,6,0,0,2,4587520,302383104 +legacy-recursion-real-ungrouped,ROM:34,194,16384,37,6,0,0,2,606208,32538624 +legacy-recursion-real-ungrouped,Bytes1,195,256,3,6,11,256,1,768,68608 +legacy-recursion-real-ungrouped,Bytes2,196,65536,8,8,11,65536,2,524288,63700992 +legacy-recursion-ungrouped,memo_u32_less_than,0,8,10,8,0,0,2,80,1680 +legacy-recursion-ungrouped,u64_is_zero,1,1,19,2,0,0,2,19,75 +legacy-recursion-ungrouped,u64_eq,2,8,27,2,0,0,2,216,2472 +legacy-recursion-ungrouped,relaxed_u64_succ,3,0,19,2,0,0,2,0,0 +legacy-recursion-ungrouped,flatten_u64,4,8,10,2,0,0,1,80,1040 +legacy-recursion-ungrouped,read_u8,5,64,8,6,0,0,2,512,21504 +legacy-recursion-ungrouped,read_u64,6,8,19,10,0,0,2,152,2472 +legacy-recursion-ungrouped,read_count,7,2,13,6,0,0,1,26,134 +legacy-recursion-ungrouped,read_count_at,8,256,13,4,0,0,1,3328,117760 +legacy-recursion-ungrouped,read_active_n,9,8,11,6,0,0,2,88,1608 +legacy-recursion-ungrouped,read_u64_vec,10,64,7,6,0,0,1,448,17536 +legacy-recursion-ungrouped,read_u64_vec_n,11,256,18,6,0,0,2,4608,175104 +legacy-recursion-ungrouped,read_ext_vec,12,8,7,6,0,0,1,56,1112 +legacy-recursion-ungrouped,read_ext_vec_n,13,32,27,6,0,0,2,864,18144 +legacy-recursion-ungrouped,read_digest_vec_at,14,8,7,6,0,0,1,56,1112 +legacy-recursion-ungrouped,read_digest_vec_at_n,15,16,46,8,0,0,2,736,11328 +legacy-recursion-ungrouped,read_u64_vec_vec_n,16,128,11,8,0,0,2,1408,63360 +legacy-recursion-ungrouped,read_u64_vec_vec_vec_n,17,64,13,10,0,0,2,832,31872 +legacy-recursion-ungrouped,read_ext_vec_vec,18,4,7,6,0,0,1,28,376 +legacy-recursion-ungrouped,read_ext_vec_vec_n,19,8,11,8,0,0,2,88,1752 +legacy-recursion-ungrouped,read_opened_round,20,4,7,6,0,0,1,28,376 +legacy-recursion-ungrouped,read_opened_round_n,21,8,11,8,0,0,2,88,1752 +legacy-recursion-ungrouped,read_merkle_cap_vec_n,22,1,11,8,0,0,2,11,69 +legacy-recursion-ungrouped,read_batch_opening_vec_n,23,4,15,12,0,0,2,60,792 +legacy-recursion-ungrouped,read_commit_phase_step_vec_n,24,1,17,12,0,0,2,17,99 +legacy-recursion-ungrouped,read_preprocessed,25,1,9,4,0,0,2,9,51 +legacy-recursion-ungrouped,read_proof,26,1,53,22,0,0,2,53,237 +legacy-recursion-ungrouped,read_header_vec_n,27,2,23,20,0,0,2,46,306 +legacy-recursion-ungrouped,read_message_vec_n,28,1,20,8,0,0,2,20,96 +legacy-recursion-ungrouped,read_proof_vec_n,29,2,34,8,0,0,2,68,300 +legacy-recursion-ungrouped,blake3_next_layer,30,0,175,12,0,0,2,0,0 +legacy-recursion-ungrouped,blake3_compress_layer,31,16,141,12,0,0,2,2256,30336 +legacy-recursion-ungrouped,blake3_compress_chunks,32,1024,17,8,0,0,2,17408,903168 +legacy-recursion-ungrouped,bytes_to_block,33,32,195,130,0,0,2,6240,158304 +legacy-recursion-ungrouped,pad_block,34,256,8,6,0,0,2,2048,113664 +legacy-recursion-ungrouped,blake3_finish,35,16,160,16,0,0,2,2560,34752 +legacy-recursion-ungrouped,blake3_compress_block,36,16,161,26,0,0,2,2576,36864 +legacy-recursion-ungrouped,blake3_compress,37,256,533,388,0,0,2,136448,5686272 +legacy-recursion-ungrouped,read_vk_u8,38,128,6,4,0,0,2,768,39168 +legacy-recursion-ungrouped,read_vk_tag,39,8,5,4,0,0,1,40,824 +legacy-recursion-ungrouped,read_vk_u16,40,32,7,6,0,0,1,224,7328 +legacy-recursion-ungrouped,read_vk_u16_limb,41,16,7,6,0,0,1,112,2944 +legacy-recursion-ungrouped,read_vk_u32_limb,42,1,11,6,0,0,2,11,63 +legacy-recursion-ungrouped,read_vk_u64,43,1,19,10,0,0,2,19,99 +legacy-recursion-ungrouped,read_field,44,1,12,4,0,0,1,12,54 +legacy-recursion-ungrouped,read_vk_cap_n,45,0,46,16,0,0,2,0,0 +legacy-recursion-ungrouped,read_nodes_n,46,8,44,16,0,0,2,352,4704 +legacy-recursion-ungrouped,read_node_ids_n,47,8,11,8,0,0,2,88,1752 +legacy-recursion-ungrouped,read_sys_lookups_n,48,2,15,12,0,0,2,30,210 +legacy-recursion-ungrouped,lookup_groups_count,49,2,10,4,0,0,2,20,132 +legacy-recursion-ungrouped,read_sys_circuits_n,50,2,113,68,0,0,2,226,1134 +legacy-recursion-ungrouped,read_opt_commit,51,1,11,8,0,0,2,11,69 +legacy-recursion-ungrouped,read_opt_idx_n,52,2,13,8,0,0,2,26,174 +legacy-recursion-ungrouped,b3_w4_onto,53,128,11,6,0,0,2,1408,57984 +legacy-recursion-ungrouped,mmcs_compress,54,2,101,6,0,0,2,202,690 +legacy-recursion-ungrouped,compress_ordered,55,0,8,4,0,0,2,0,0 +legacy-recursion-ungrouped,has_height,56,2,13,6,0,0,2,26,162 +legacy-recursion-ungrouped,select_rows,57,4,30,12,0,0,2,120,1152 +legacy-recursion-ungrouped,select_rows_le,58,4,34,24,0,0,2,136,1536 +legacy-recursion-ungrouped,rows_pop,59,8,30,12,0,0,2,240,3408 +legacy-recursion-ungrouped,b3_rows_chunks,60,2,226,42,0,0,2,452,1656 +legacy-recursion-ungrouped,leaf_hash_at,61,2,44,10,0,0,2,88,372 +legacy-recursion-ungrouped,inject_maybe,62,2,11,8,0,0,2,22,162 +legacy-recursion-ungrouped,bits_to_num,63,4,8,6,0,0,2,32,480 +legacy-recursion-ungrouped,frontier_merge,64,32,27,12,0,0,2,864,21024 +legacy-recursion-ungrouped,frontier_split,65,64,21,12,0,0,2,1344,43392 +legacy-recursion-ungrouped,frontier_sort,66,32,22,14,0,0,2,704,19584 +legacy-recursion-ungrouped,frontier_leaves,67,64,17,14,0,0,2,1088,41088 +legacy-recursion-ungrouped,frontier_level,68,4,40,26,0,0,2,160,1728 +legacy-recursion-ungrouped,frontier_fold,69,4,12,6,0,0,2,48,576 +legacy-recursion-ungrouped,mmcs_verify_multi,70,2,27,20,0,0,2,54,330 +legacy-recursion-ungrouped,rev_onto,71,512,10,8,0,0,2,5120,310272 +legacy-recursion-ungrouped,exp_by_bits,72,4,13,6,0,0,2,52,600 +legacy-recursion-ungrouped,fri_fold2,73,0,34,6,0,0,2,0,0 +legacy-recursion-ungrouped,ro_fold,74,16,37,8,0,0,2,592,9600 +legacy-recursion-ungrouped,accs_onto,75,16,38,26,0,0,2,608,13248 +legacy-recursion-ungrouped,points_onto,76,8,10,8,0,0,2,80,1680 +legacy-recursion-ungrouped,round_onto,77,8,10,8,0,0,2,80,1680 +legacy-recursion-ungrouped,obs_log_arities,78,1,10,8,0,0,2,10,66 +legacy-recursion-ungrouped,pcs_check_witness,79,1,20,10,0,0,2,20,102 +legacy-recursion-ungrouped,pcs_betas,80,1,44,16,0,0,2,44,192 +legacy-recursion-ungrouped,circ_has_height,81,1,15,6,0,0,2,15,75 +legacy-recursion-ungrouped,build_buckets,82,2,13,8,0,0,2,26,174 +legacy-recursion-ungrouped,bucket_update,83,16,30,8,0,0,2,480,8256 +legacy-recursion-ungrouped,assert_blowup_zero,84,1,20,6,0,0,2,20,90 +legacy-recursion-ungrouped,prep_count,85,1,5,2,0,0,2,5,33 +legacy-recursion-ungrouped,ri_apply,86,16,30,10,0,0,2,480,8640 +legacy-recursion-ungrouped,open_2pt_mat,87,4,20,6,0,0,2,80,768 +legacy-recursion-ungrouped,open_batch_2pt,88,8,22,12,0,0,2,176,2832 +legacy-recursion-ungrouped,open_quotient,89,4,23,14,0,0,2,92,1032 +legacy-recursion-ungrouped,open_prep,90,0,27,14,0,0,2,0,0 +legacy-recursion-ungrouped,open_prep_batch,91,2,26,14,0,0,2,52,288 +legacy-recursion-ungrouped,heights_all,92,2,11,8,0,0,2,22,162 +legacy-recursion-ungrouped,heights_max,93,0,16,18,0,0,2,0,0 +legacy-recursion-ungrouped,heights_prep,94,0,15,10,0,0,2,0,0 +legacy-recursion-ungrouped,rollin,95,0,25,6,0,0,2,0,0 +legacy-recursion-ungrouped,verify_query,96,2,102,64,0,0,2,204,1044 +legacy-recursion-ungrouped,verify_one_query,97,2,72,40,0,0,2,144,720 +legacy-recursion-ungrouped,query_loop,98,32,38,12,0,0,2,1216,26304 +legacy-recursion-ungrouped,sample_query_indices,99,32,13,8,0,0,2,416,12384 +legacy-recursion-ungrouped,batch_views_at,100,64,12,10,0,0,2,768,30720 +legacy-recursion-ungrouped,step_views_at,101,16,13,10,0,0,2,208,5376 +legacy-recursion-ungrouped,query_views,102,32,12,10,0,0,2,384,12864 +legacy-recursion-ungrouped,verify_input_multi,103,1,32,26,0,0,2,32,186 +legacy-recursion-ungrouped,drop_index_bits,104,0,11,10,0,0,2,0,0 +legacy-recursion-ungrouped,rows_at_round,105,0,13,14,0,0,2,0,0 +legacy-recursion-ungrouped,verify_commit_multi,106,1,25,22,0,0,2,25,153 +legacy-recursion-ungrouped,cons8,107,128,19,10,0,0,2,2432,90240 +legacy-recursion-ungrouped,cap_onto,108,8,45,16,0,0,2,360,4776 +legacy-recursion-ungrouped,log_degrees_onto,109,4,10,8,0,0,2,40,576 +legacy-recursion-ungrouped,ch_sample8,110,32,78,50,0,0,2,2496,63744 +legacy-recursion-ungrouped,ch_sample_field,111,16,31,6,0,0,2,496,8064 +legacy-recursion-ungrouped,ch_sample_ext,112,8,24,6,0,0,1,192,2336 +legacy-recursion-ungrouped,take_bits,113,32,11,8,0,0,2,352,11424 +legacy-recursion-ungrouped,ch_sample_bits,114,16,53,12,0,0,2,848,13440 +legacy-recursion-ungrouped,snoc_b8,115,1,14,4,0,0,2,14,66 +legacy-recursion-ungrouped,snoc_cap,116,2,7,4,0,0,2,14,114 +legacy-recursion-ungrouped,limbs_onto,117,32,17,8,0,0,2,544,14304 +legacy-recursion-ungrouped,ext_exp_pow2,118,1,13,4,0,0,2,13,63 +legacy-recursion-ungrouped,two_adic_gen,119,64,9,4,0,0,2,576,20352 +legacy-recursion-ungrouped,pow2,120,1,6,4,0,0,2,6,42 +legacy-recursion-ungrouped,ood_fold,121,1,12,2,0,0,2,12,54 +legacy-recursion-ungrouped,from_ext_basis,122,1,6,2,0,0,1,6,30 +legacy-recursion-ungrouped,reconstruct_ext_row,123,2,16,12,0,0,2,32,216 +legacy-recursion-ungrouped,eval_at,124,8,43,8,0,0,2,344,4056 +legacy-recursion-ungrouped,fold_roots,125,2,31,10,0,0,2,62,294 +legacy-recursion-ungrouped,pair_mul,126,8,26,2,0,0,2,208,2400 +legacy-recursion-ungrouped,logup_fingerprint,127,8,35,10,0,0,2,280,3624 +legacy-recursion-ungrouped,logup_steps_fold,128,1,94,28,0,0,2,94,378 +legacy-recursion-ungrouped,quotient_eval,129,2,22,6,0,0,2,44,216 +legacy-recursion-ungrouped,quotient_degree_of,130,1,39,2,0,0,2,39,135 +legacy-recursion-ungrouped,ood_loop,131,2,179,100,0,0,2,358,1722 +legacy-recursion-ungrouped,fingerprint_vals,132,8,22,6,0,0,2,176,2400 +legacy-recursion-ungrouped,claims_acc,133,2,25,8,0,0,2,50,246 +legacy-recursion-ungrouped,assert_bits,134,2,9,6,0,0,2,18,138 +legacy-recursion-ungrouped,select_active_circuits,135,2,23,10,0,0,2,46,246 +legacy-recursion-ungrouped,select_active_prep,136,2,16,10,0,0,2,32,204 +legacy-recursion-ungrouped,count_onto,137,8,18,6,0,0,2,144,2112 +legacy-recursion-ungrouped,claims_onto,138,1,7,4,0,0,2,7,45 +legacy-recursion-ungrouped,claims_onto_each,139,2,12,12,0,0,2,24,192 +legacy-recursion-ungrouped,header_onto,140,1,13,14,0,0,2,13,93 +legacy-recursion-ungrouped,headers_onto,141,2,13,8,0,0,2,26,174 +legacy-recursion-ungrouped,messages_onto,142,1,7,4,0,0,2,7,45 +legacy-recursion-ungrouped,messages_onto_each,143,1,21,14,0,0,2,21,117 +legacy-recursion-ungrouped,batch_fiat_shamir,144,1,69,30,0,0,2,69,309 +legacy-recursion-ungrouped,shard_fiat_shamir,145,1,62,14,0,0,2,62,240 +legacy-recursion-ungrouped,assert_same_u8s,146,4,12,8,0,0,2,48,624 +legacy-recursion-ungrouped,assert_same_limbs,147,8,27,10,0,0,2,216,3048 +legacy-recursion-ungrouped,assert_same_claims,148,2,13,10,0,0,2,26,186 +legacy-recursion-ungrouped,assert_same_cap,149,2,80,20,0,0,2,160,648 +legacy-recursion-ungrouped,last_acc,150,1,15,8,0,0,2,15,81 +legacy-recursion-ungrouped,messages_acc,151,1,35,8,0,0,2,35,141 +legacy-recursion-ungrouped,log_degree_ok,152,1,69,2,0,0,2,69,225 +legacy-recursion-ungrouped,assert_log_degrees_ok,153,2,9,8,0,0,2,18,150 +legacy-recursion-ungrouped,count_ones,154,2,8,6,0,0,2,16,132 +legacy-recursion-ungrouped,assert_shard_count_ok,155,1,20,6,0,0,2,20,90 +legacy-recursion-ungrouped,three_limbs,156,0,43,10,0,0,2,0,0 +legacy-recursion-ungrouped,le_step,157,0,9,2,0,0,2,0,0 +legacy-recursion-ungrouped,bytes8_le,158,0,26,10,0,0,2,0,0 +legacy-recursion-ungrouped,assert_closure_pairs,159,1,161,66,0,0,2,161,693 +legacy-recursion-ungrouped,verify_shard,160,1,142,108,0,0,2,142,762 +legacy-recursion-ungrouped,verify_shards,161,2,61,10,0,0,2,122,474 +legacy-recursion-ungrouped,batch_claims,162,2,12,8,0,0,2,24,168 +legacy-recursion-ungrouped,verify_batch,163,1,41,22,0,0,2,41,201 +legacy-recursion-ungrouped,read_claims_n,164,2,13,10,0,0,2,26,186 +legacy-recursion-ungrouped,read_claim_vals_n,165,8,18,8,0,0,2,144,2256 +legacy-recursion-ungrouped,verify_multi_stark_proof,166,1,218,42,0,0,2,218,792 +legacy-recursion-ungrouped,list_lookup.BatchOpening,167,64,8,6,0,0,2,512,21504 +legacy-recursion-ungrouped,list_length.Proof,168,2,31,6,0,0,2,62,270 +legacy-recursion-ungrouped,list_length.Ptr.U8_8_4,169,64,8,6,0,0,2,512,21504 +legacy-recursion-ungrouped,list_length.CommitPhaseProofStep,170,16,9,6,0,0,2,144,3840 +legacy-recursion-ungrouped,list_concat.Ptr.ListNode.U8_8,171,512,10,8,0,0,2,5120,310272 +legacy-recursion-ungrouped,list_length.FrontierNode,172,2,11,6,0,0,2,22,150 +legacy-recursion-ungrouped,list_length.Bucket,173,1,12,6,0,0,2,12,66 +legacy-recursion-ungrouped,list_length.U8_8,174,8,15,6,0,0,2,120,1896 +legacy-recursion-ungrouped,list_length.SysCircuit,175,2,16,6,0,0,2,32,180 +legacy-recursion-ungrouped,list_lookup.SysNode,176,8,11,6,0,0,2,88,1608 +legacy-recursion-ungrouped,list_is_empty.U8,177,8,7,4,0,0,2,56,1176 +legacy-recursion-ungrouped,list_lookup.G_2,178,8,9,6,0,0,2,72,1464 +legacy-recursion-ungrouped,list_concat.U8_8,179,8,17,8,0,0,2,136,2184 +legacy-recursion-ungrouped,list_length.CommitPhaseMultiStep,180,1,10,6,0,0,2,10,60 +legacy-recursion-ungrouped,list_drop.G,181,64,10,6,0,0,2,640,23808 +legacy-recursion-ungrouped,list_drop.G_2,182,8,11,6,0,0,2,88,1608 +legacy-recursion-ungrouped,list_drop.SysNode,183,8,13,6,0,0,2,104,1752 +legacy-recursion-ungrouped,ROM:3,184,4096,6,6,0,0,2,24576,2408448 +legacy-recursion-ungrouped,ROM:4,185,32,7,6,0,0,2,224,8544 +legacy-recursion-ungrouped,ROM:5,186,1,8,6,0,0,2,8,54 +legacy-recursion-ungrouped,ROM:6,187,128,9,6,0,0,2,1152,52608 +legacy-recursion-ungrouped,ROM:7,188,8,10,6,0,0,2,80,1536 +legacy-recursion-ungrouped,ROM:8,189,1,11,6,0,0,2,11,63 +legacy-recursion-ungrouped,ROM:10,190,32,13,6,0,0,2,416,11424 +legacy-recursion-ungrouped,ROM:11,191,2,14,6,0,0,2,28,168 +legacy-recursion-ungrouped,ROM:26,192,2,29,6,0,0,2,58,258 +legacy-recursion-ungrouped,ROM:32,193,16,35,6,0,0,2,560,8832 +legacy-recursion-ungrouped,ROM:34,194,16,37,6,0,0,2,592,9216 +legacy-recursion-ungrouped,Bytes1,195,256,3,6,11,256,1,768,68608 +legacy-recursion-ungrouped,Bytes2,196,65536,8,8,11,65536,2,524288,63700992 +new-environment-grouped,IxVM::verify_claim,0,1,10,4,0,0,1,10,48.0 +new-environment-grouped,ixvm_group_07,1,256,203,50,0,0,2,51968,1582080.0 +new-environment-grouped,IxVM::read_finite_byte_stream,2,512,7,6,0,0,1,3584,209408.0 +new-environment-grouped,IxVM::read_byte_stream,3,131072,11,8,0,0,2,1441792,155320320.0 +new-environment-grouped,"${""name"":""IxVM::list_depth_checked"",""types"":[""field""]}",4,131072,9,8,0,0,1,1179648,127533056.0 +new-environment-grouped,IxVM::checked_depth_succ,5,16384,4,4,0,0,1,65536,6946816.0 +new-environment-grouped,ixvm_group_00,6,16384,34,14,0,0,2,557056,35979264.0 +new-environment-grouped,ixvm_group_08,7,4096,238,28,0,0,2,974848,39862272.0 +new-environment-grouped,Blake3::compress,8,32768,501,226,0,0,2,16416768,1078296576.0 +new-environment-grouped,Blake3::compress_chunks,9,131072,17,6,0,0,2,2228224,182059008.0 +new-environment-grouped,UInt64::is_zero,10,128,19,2,0,0,2,2432,68736.0 +new-environment-grouped,Blake3::bytes_to_block,11,4096,131,130,0,0,1,536576,38797312.0 +new-environment-grouped,Blake3::pad_block,12,65536,8,4,0,0,2,524288,51118080.0 +new-environment-grouped,Blake3::compress_block,13,2048,180,48,0,0,2,368640,15704064.0 +new-environment-grouped,"${""name"":""Lists::is_empty"",""types"":[""field""]}",14,2048,7,4,0,0,1,14336,886784.0 +new-environment-grouped,ixvm_group_02,15,32,56,6,0,0,2,1792,32064.0 +new-environment-grouped,IxVM::get_tagn4,16,32768,23,10,0,0,2,753664,54951936.0 +new-environment-grouped,IxVM::get_tagn_tail,17,2048,22,12,0,0,1,45056,2441216.0 +new-environment-grouped,IxVM::get_tagn_wide,18,0,28,10,0,0,2,0,0.0 +new-environment-grouped,IxVM::get_u64_le,19,0,17,6,0,0,2,0,0.0 +new-environment-grouped,ixvm_group_03,20,1024,64,60,0,0,2,65536,3944448.0 +new-environment-grouped,ixvm_group_24,21,8192,22,8,0,0,2,180224,10960896.0 +new-environment-grouped,IxVM::get_address,22,2048,68,68,0,0,1,139264,9334784.0 +new-environment-grouped,ixvm_group_23,23,256,44,10,0,0,2,11264,359424.0 +new-environment-grouped,IxVM::run_eval,24,0,22,24,0,0,1,0,0.0 +new-environment-grouped,ixvm_group_34,25,4096,45,14,0,0,2,184320,9338880.0 +new-environment-grouped,ixvm_group_01,26,1024,132,34,0,0,2,135168,5234688.0 +new-environment-grouped,ixvm_group_33,27,1024,102,12,0,0,2,104448,3637248.0 +new-environment-grouped,ixvm_group_05,28,1024,115,16,0,0,2,117760,4159488.0 +new-environment-grouped,ixvm_group_06,29,1024,93,16,0,0,2,95232,3483648.0 +new-environment-grouped,ixvm_group_31,30,1024,38,16,0,0,2,38912,1794048.0 +new-environment-grouped,ixvm_group_30,31,512,42,6,0,0,2,21504,724992.0 +new-environment-grouped,IxVM::get_tagn0,32,8192,17,8,0,0,1,139264,8658944.0 +new-environment-grouped,IxVM::get_expr,33,32768,48,24,0,0,2,1572864,112459776.0 +new-environment-grouped,IxVM::get_u64_list,34,4096,33,12,0,0,2,135168,7274496.0 +new-environment-grouped,ixvm_group_04,35,256,29,4,0,0,2,7424,230400.0 +new-environment-grouped,IxVM::get_app_telescope,36,16384,27,12,0,0,1,442368,28278784.0 +new-environment-grouped,ixvm_group_26,37,8192,52,16,0,0,2,425984,23101440.0 +new-environment-grouped,IxVM::get_lam_mode,38,2048,16,8,0,0,1,32768,1765376.0 +new-environment-grouped,IxVM::binder_contract_from_bits,39,1,15,4,0,0,1,15,63.0 +new-environment-grouped,IxVM::value_contract_from_bits,40,1,8,2,0,0,1,8,36.0 +new-environment-grouped,IxVM::get_all_mode,41,2048,18,10,0,0,1,36864,2035712.0 +new-environment-grouped,ixvm_group_19,42,256,113,32,0,0,2,28928,918528.0 +new-environment-grouped,ixvm_group_35,43,512,83,18,0,0,2,42496,1457664.0 +new-environment-grouped,ixvm_group_32,44,64,103,22,0,0,2,6592,149376.0 +new-environment-grouped,ixvm_group_25,45,512,49,18,0,0,2,25088,987648.0 +new-environment-grouped,IxVM::get_expr_list,46,2048,26,12,0,0,2,53248,2863104.0 +new-environment-grouped,IxVM::get_address_list,47,2048,26,12,0,0,2,53248,2863104.0 +new-environment-grouped,ixvm_group_28,48,1024,64,20,0,0,2,65536,2715648.0 +new-environment-grouped,ixvm_group_27,49,512,100,24,0,0,2,51200,1775616.0 +new-environment-grouped,IxVM::load_constant_hint,50,256,36,4,0,0,1,9216,259072.0 +new-environment-grouped,ixvm_group_11,51,1024,83,14,0,0,2,84992,3115008.0 +new-environment-grouped,IxVM::convert_expr,52,16384,41,38,0,0,2,671744,57311232.0 +new-environment-grouped,"${""name"":""IxVM::list_lookup"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Univ""}}}}]}",53,8192,7,6,0,0,1,57344,4825088.0 +new-environment-grouped,"${""name"":""IxVM::list_drop"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Univ""}}}}]}",54,16384,9,6,0,0,2,147456,13271040.0 +new-environment-grouped,ixvm_group_64,55,1024,43,16,0,0,2,44032,1947648.0 +new-environment-grouped,ixvm_group_55,56,512,44,20,0,0,2,22528,946176.0 +new-environment-grouped,ixvm_group_56,57,512,72,50,0,0,2,36864,1747968.0 +new-environment-grouped,ixvm_group_14,58,0,36,8,0,0,2,0,0.0 +new-environment-grouped,ixvm_group_36,59,256,82,22,0,0,2,20992,666624.0 +new-environment-grouped,ixvm_group_39,60,256,39,8,0,0,2,9984,316416.0 +new-environment-grouped,ixvm_group_59,61,0,194,62,0,0,2,0,0.0 +new-environment-grouped,ixvm_group_12,62,0,99,18,0,0,2,0,0.0 +new-environment-grouped,ixvm_group_47,63,1024,57,14,0,0,2,58368,2316288.0 +new-environment-grouped,ixvm_group_20,64,128,65,20,0,0,2,8320,240768.0 +new-environment-grouped,ixvm_group_22,65,1024,90,22,0,0,2,92160,3575808.0 +new-environment-grouped,"${""name"":""IxVM::list_length_u64"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Expr""}}}}]}",66,4,23,8,0,0,1,92,808.0 +new-environment-grouped,IxVM::put_tagn_tail,67,0,30,18,0,0,1,0,0.0 +new-environment-grouped,IxVM::put_tagn_wide,68,0,30,12,0,0,2,0,0.0 +new-environment-grouped,ixvm_group_10,69,0,53,14,0,0,2,0,0.0 +new-environment-grouped,ixvm_group_09,70,1,164,62,0,0,2,164,690.0 +new-environment-grouped,ixvm_group_18,71,0,93,26,0,0,2,0,0.0 +new-environment-grouped,ixvm_group_13,72,0,69,12,0,0,2,0,0.0 +new-environment-grouped,ixvm_group_16,73,0,122,24,0,0,2,0,0.0 +new-environment-grouped,IxVM::put_lam_mode,74,0,9,8,0,0,1,0,0.0 +new-environment-grouped,IxVM::binder_contract_code,75,0,10,4,0,0,1,0,0.0 +new-environment-grouped,IxVM::value_contract_code,76,0,8,2,0,0,1,0,0.0 +new-environment-grouped,ixvm_group_15,77,1024,51,12,0,0,2,52224,2070528.0 +new-environment-grouped,ixvm_group_17,78,2048,112,140,0,0,2,229376,17326080.0 +new-environment-grouped,ixvm_group_21,79,0,197,74,0,0,2,0,0.0 +new-environment-grouped,IxVM::validate_expr_well_scoped,80,16384,32,24,0,0,2,524288,41484288.0 +new-environment-grouped,ixvm_group_48,81,1024,45,24,0,0,2,46080,2254848.0 +new-environment-grouped,ixvm_group_79,82,1024,23,2,0,0,2,23552,903168.0 +new-environment-grouped,"${""name"":""IxVM::list_length"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KLevelNode""}}}}]}",83,8192,8,6,0,0,2,65536,5849088.0 +new-environment-grouped,IxVM::k_ensure_sort,84,4096,9,8,0,0,1,36864,2818048.0 +new-environment-grouped,IxVM::k_infer,85,8192,8,6,0,0,2,65536,5849088.0 +new-environment-grouped,IxVM::expr_lbr,86,32768,19,18,0,0,2,622592,60850176.0 +new-environment-grouped,IxVM::k_infer_core,87,8192,33,46,0,0,2,270336,26615808.0 +new-environment-grouped,IxVM::types_lookup,88,1024,6,6,0,0,1,6144,434176.0 +new-environment-grouped,IxVM::expr_lift,89,16384,11,4,0,0,2,180224,13271040.0 +new-environment-grouped,IxVM::expr_lift_walk,90,16384,20,14,0,0,2,327680,26345472.0 +new-environment-grouped,ixvm_group_61,91,32,52,26,0,0,2,1664,39744.0 +new-environment-grouped,ixvm_group_38,92,1024,40,22,0,0,2,40960,2039808.0 +new-environment-grouped,ixvm_group_70,93,4096,20,8,0,0,2,81920,4767744.0 +new-environment-grouped,ixvm_group_57,94,2048,16,8,0,0,2,32768,1916928.0 +new-environment-grouped,ixvm_group_65,95,1024,29,16,0,0,2,29696,1517568.0 +new-environment-grouped,IxVM::expr_inst_levels,96,4096,10,4,0,0,2,40960,2703360.0 +new-environment-grouped,IxVM::expr_inst_levels_walk,97,4096,20,16,0,0,2,81920,5947392.0 +new-environment-grouped,ixvm_group_71,98,4096,19,12,0,0,2,77824,5210112.0 +new-environment-grouped,IxVM::collect_spine,99,16384,11,10,0,0,2,180224,17399808.0 +new-environment-grouped,"${""name"":""IxVM::list_snoc"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",100,16384,10,10,0,0,2,163840,16711680.0 +new-environment-grouped,IxVM::k_infer_app_spine_loop,101,8192,30,34,0,0,2,245760,21823488.0 +new-environment-grouped,IxVM::expr_inst_many,102,32768,15,8,0,0,2,491520,40206336.0 +new-environment-grouped,IxVM::has_bvar_in_range,103,8192,21,16,0,0,2,172032,13197312.0 +new-environment-grouped,ixvm_group_72,104,2048,12,6,0,0,2,24576,1511424.0 +new-environment-grouped,IxVM::expr_inst_many_walk,105,16384,20,14,0,0,2,327680,26345472.0 +new-environment-grouped,IxVM::expr_inst_many_bvar,106,8192,10,12,0,0,1,81920,7700480.0 +new-environment-grouped,ixvm_group_68,107,512,52,34,0,0,2,26624,1250304.0 +new-environment-grouped,IxVM::expr_lower,108,32768,11,4,0,0,2,360448,28409856.0 +new-environment-grouped,IxVM::expr_lower_walk,109,32768,22,14,0,0,2,720896,59375616.0 +new-environment-grouped,IxVM::k_check,110,4096,7,6,0,0,1,28672,2228224.0 +new-environment-grouped,IxVM::k_is_def_eq,111,8192,11,8,0,0,2,90112,7446528.0 +new-environment-grouped,ixvm_group_81,112,8192,25,14,0,0,2,204800,13836288.0 +new-environment-grouped,ixvm_group_75,113,8192,11,6,0,0,2,90112,6807552.0 +new-environment-grouped,IxVM::try_def_eq_app,114,4096,32,12,0,0,2,131072,7127040.0 +new-environment-grouped,IxVM::de_args,115,4096,18,6,0,0,2,73728,4177920.0 +new-environment-grouped,IxVM::address_eq,116,8192,71,4,0,0,2,581632,25337856.0 +new-environment-grouped,ixvm_group_67,117,512,53,14,0,0,2,27136,987648.0 +new-environment-grouped,ixvm_group_51,118,512,37,14,0,0,2,18944,766464.0 +new-environment-grouped,ixvm_group_53,119,128,61,36,0,0,2,7808,273024.0 +new-environment-grouped,ixvm_group_49,120,4,83,66,0,0,2,332,3720.0 +new-environment-grouped,ixvm_group_66,121,512,85,48,0,0,2,43520,1900032.0 +new-environment-grouped,ixvm_group_50,122,1,68,26,0,0,2,68,294.0 +new-environment-grouped,IxVM::try_string_lit_one,123,4096,14,6,0,0,2,57344,3588096.0 +new-environment-grouped,IxVM::whnf_nd,124,2048,22,6,0,0,2,45056,2187264.0 +new-environment-grouped,IxVM::whnf_nd_with_spine,125,4096,20,12,0,0,2,81920,5357568.0 +new-environment-grouped,"${""name"":""IxVM::list_concat"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",126,16384,10,8,0,0,1,163840,13828096.0 +new-environment-grouped,IxVM::whnf_nd_apply_beta,127,512,16,10,0,0,2,8192,420864.0 +new-environment-grouped,IxVM::peel_beta,128,8192,18,6,0,0,2,147456,9043968.0 +new-environment-grouped,IxVM::apply_spine,129,8192,10,8,0,0,1,81920,6422528.0 +new-environment-grouped,IxVM::expr_inst1,130,8192,12,6,0,0,2,98304,7127040.0 +new-environment-grouped,IxVM::expr_has_bvar_at,131,8192,23,12,0,0,2,188416,12558336.0 +new-environment-grouped,IxVM::expr_inst1_walk,132,4096,20,14,0,0,2,81920,5652480.0 +new-environment-grouped,IxVM::whnf_nd_const_head,133,1024,57,46,0,0,2,58368,3299328.0 +new-environment-grouped,ixvm_group_77,134,256,95,76,0,0,2,24320,1078272.0 +new-environment-grouped,ixvm_group_43,135,32,18,4,0,0,2,576,12864.0 +new-environment-grouped,ixvm_group_46,136,32,18,4,0,0,2,576,12864.0 +new-environment-grouped,ixvm_group_45,137,16,18,4,0,0,2,288,5184.0 +new-environment-grouped,IxVM::try_prim_dispatch,138,2048,22,10,0,0,2,45056,2457600.0 +new-environment-grouped,IxVM::whnf,139,4096,22,6,0,0,2,90112,4767744.0 +new-environment-grouped,IxVM::whnf_with_spine,140,4096,20,12,0,0,2,81920,5357568.0 +new-environment-grouped,IxVM::whnf_apply_beta,141,1024,16,10,0,0,2,16384,933888.0 +new-environment-grouped,IxVM::whnf_const_head,142,1024,51,42,0,0,2,52224,2992128.0 +new-environment-grouped,ixvm_group_74,143,4096,21,16,0,0,2,86016,6094848.0 +new-environment-grouped,ixvm_group_41,144,32,64,16,0,0,2,2048,40704.0 +new-environment-grouped,ixvm_group_42,145,8,79,90,0,0,2,632,12552.0 +new-environment-grouped,ixvm_group_52,146,0,84,38,0,0,2,0,0.0 +new-environment-grouped,ixvm_group_63,147,512,89,52,0,0,2,45568,2010624.0 +new-environment-grouped,"${""name"":""IxVM::list_take"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",148,2048,10,8,0,0,2,20480,1511424.0 +new-environment-grouped,ixvm_group_40,149,512,53,28,0,0,2,27136,1181184.0 +new-environment-grouped,IxVM::klimbs_add,150,32,5,4,0,0,1,160,5408.0 +new-environment-grouped,IxVM::klimbs_add_carry,151,32,50,18,0,0,2,1600,34944.0 +new-environment-grouped,IxVM::klimbs_normalize,152,32,30,14,0,0,2,960,23424.0 +new-environment-grouped,ixvm_group_37,153,256,80,30,0,0,2,20480,703488.0 +new-environment-grouped,ixvm_group_80,154,2048,72,78,0,0,2,147456,10432512.0 +new-environment-grouped,ixvm_group_69,155,512,24,12,0,0,2,12288,559104.0 +new-environment-grouped,ixvm_group_73,156,2048,27,18,0,0,2,55296,3336192.0 +new-environment-grouped,ixvm_group_76,157,512,41,26,0,0,2,20992,987648.0 +new-environment-grouped,ixvm_group_54,158,0,9,4,0,0,2,0,0.0 +new-environment-grouped,ixvm_group_58,159,1024,69,22,0,0,2,70656,2930688.0 +new-environment-grouped,IxVM::split_u32,160,0,11,10,0,0,1,0,0.0 +new-environment-grouped,IxVM::divmod_256,161,0,8,6,0,0,1,0,0.0 +new-environment-grouped,ixvm_group_44,162,16,18,4,0,0,2,288,5184.0 +new-environment-grouped,IxVM::klimbs_mul_outer,163,32,21,12,0,0,1,672,16928.0 +new-environment-grouped,IxVM::klimbs_mul_single,164,32,68,20,0,0,2,2176,44544.0 +new-environment-grouped,IxVM::klimbs_shl_limbs,165,16,8,4,0,0,2,128,3264.0 +new-environment-grouped,IxVM::ordinary_div_mod,166,8,11,6,0,0,2,88,1608.0 +new-environment-grouped,IxVM::divide_grow,167,32,16,18,0,0,2,512,18624.0 +new-environment-grouped,IxVM::utf8_groups,168,0,9,8,0,0,1,0,0.0 +new-environment-grouped,IxVM::divmod_64u,169,0,9,4,0,0,2,0,0.0 +new-environment-grouped,ixvm_group_60,170,32,71,24,0,0,2,2272,47904.0 +new-environment-grouped,ixvm_group_62,171,0,59,20,0,0,2,0,0.0 +new-environment-grouped,IxVM::whnf_struct_core,172,4096,22,6,0,0,2,90112,4767744.0 +new-environment-grouped,IxVM::whnf_struct_core_spine,173,4096,25,36,0,0,2,102400,9633792.0 +new-environment-grouped,ixvm_group_78,174,2048,33,14,0,0,2,67584,3471360.0 +new-environment-grouped,IxVM::is_nat_zero,175,1024,13,6,0,0,2,13312,718848.0 +new-environment-grouped,IxVM::nat_offset_of,176,1024,36,30,0,0,2,36864,2162688.0 +new-environment-grouped,IxVM::lazy_delta_loop,177,2048,24,8,0,0,2,49152,2457600.0 +new-environment-grouped,IxVM::head_addr,178,1024,12,8,0,0,2,12288,749568.0 +new-environment-grouped,ixvm_group_82,179,1024,34,10,0,0,2,34816,1486848.0 +new-environment-grouped,IxVM::k_is_def_eq_struct_bounded,180,4096,43,24,0,0,2,176128,10518528.0 +new-environment-grouped,IxVM::k_def_eq_rebase,181,8192,18,14,0,0,2,147456,11599872.0 +new-environment-grouped,IxVM::expr_glb,182,32768,9,4,0,0,2,294912,25460736.0 +new-environment-grouped,IxVM::expr_glb_walk,183,32768,22,18,0,0,2,720896,65273856.0 +new-environment-grouped,IxVM::expr_glb_binder,184,8192,10,4,0,0,2,81920,5849088.0 +new-environment-grouped,IxVM::k_infer_let_start,185,16,11,14,0,0,1,176,5248.0 +new-environment-grouped,IxVM::k_infer_let_env,186,512,20,20,0,0,2,10240,614400.0 +new-environment-grouped,IxVM::infer_let_local_cutoff,187,64,13,6,0,0,2,832,27264.0 +new-environment-grouped,IxVM::k_infer_let_env_core,188,512,27,52,0,0,2,13824,1153536.0 +new-environment-grouped,IxVM::infer_let_lookup_type,189,128,16,8,0,0,2,2048,76800.0 +new-environment-grouped,IxVM::infer_let_materialize,190,1024,28,24,0,0,2,28672,1732608.0 +new-environment-grouped,IxVM::infer_let_lookup_value,191,256,16,10,0,0,2,4096,187392.0 +new-environment-grouped,IxVM::k_infer_let_env_rebase,192,64,14,14,0,0,1,896,34816.0 +new-environment-grouped,IxVM::infer_let_drop_unused,193,128,16,6,0,0,2,2048,71424.0 +new-environment-grouped,IxVM::k_infer_rebase,194,8192,15,12,0,0,2,122880,10002432.0 +new-environment-grouped,IxVM::safe_refs_only,195,8192,30,18,0,0,2,245760,16711680.0 +new-environment-grouped,"${""name"":""IxVM::list_concat"",""types"":[{""tuple"":{""items"":[{""ptr"":{""target"":{""array"":{""element"":""field"",""length"":32}}}},""field""]}}]}",196,0,11,8,0,0,1,0,0.0 +new-environment-grouped,IxVM::canon_cmp_kexpr_node_ctx,197,0,61,50,0,0,2,0,0.0 +new-environment-grouped,"${""name"":""IxVM::list_snoc"",""types"":[{""tuple"":{""items"":[{""ptr"":{""target"":{""array"":{""element"":""field"",""length"":32}}}},""field"",{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}],""name"":""Lists::Node""}}}},{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KLevelNode""}}}}],""name"":""Lists::Node""}}}}]}}]}",198,0,16,10,0,0,2,0,0.0 +new-environment-grouped,"${""name"":""IxVM::list_length"",""types"":[{""tuple"":{""items"":[{""ptr"":{""target"":{""array"":{""element"":""field"",""length"":32}}}},""field"",{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}],""name"":""Lists::Node""}}}},{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KLevelNode""}}}}],""name"":""Lists::Node""}}}}]}}]}",199,16,11,6,0,0,2,176,4224.0 +new-environment-grouped,"${""name"":""IxVM::list_lookup_or_default"",""types"":[""field""]}",200,8,10,6,0,0,2,80,1536.0 +new-environment-grouped,IxVM::walk_refs_transitive,201,0,12,6,0,0,2,0,0.0 +new-environment-grouped,IxVM::g_list_has,202,16384,11,4,0,0,2,180224,13271040.0 +new-environment-grouped,IxVM::const_idxs_exprs,203,2048,10,12,0,0,1,20480,1630208.0 +new-environment-grouped,IxVM::const_idxs_expr,204,8192,34,24,0,0,2,278528,19906560.0 +new-environment-grouped,"${""name"":""IxVM::rbtree_map_balance_fix"",""types"":[""field""]}",205,0,301,16,0,0,2,0,0.0 +new-environment-grouped,IxVM::eval_body,206,0,19,8,0,0,2,0,0.0 +new-environment-grouped,IxVM::eval_output,207,0,58,14,0,0,1,0,0.0 +new-environment-grouped,IxVM::eval_nf,208,0,15,16,0,0,2,0,0.0 +new-environment-grouped,IxVM::eval_nf_spine,209,0,13,12,0,0,2,0,0.0 +new-environment-grouped,IxVM::walk_leaves_owned,210,512,39,10,0,0,1,19968,707072.0 +new-environment-grouped,IxVM::check_owned,211,512,35,6,0,0,1,17920,596480.0 +new-environment-grouped,IxVM::env_walk_all,212,512,89,16,0,0,2,45568,1512960.0 +new-environment-grouped,IxVM::env_walk_refs_all,213,4096,43,6,0,0,2,176128,7864320.0 +new-environment-grouped,,214,256,2,4,11,256,1,512,50176.0 +new-environment-grouped,,215,65536,7,8,14,65536,2,458752,60555264.0 +new-environment-grouped,,216,1024,1,2,3,1024,1,1024,157696.0 +new-environment-grouped,,217,8,5,6,0,0,1,40,968.0 +new-environment-grouped,,218,524288,6,6,0,0,1,3145728,420478976.0 +new-environment-grouped,,219,32768,7,6,0,0,1,229376,22249472.0 +new-environment-grouped,,220,128,8,6,0,0,1,1024,43520.0 +new-environment-grouped,,221,16,9,6,0,0,1,144,3328.0 +new-environment-grouped,,222,2,11,6,0,0,1,22,122.0 +new-environment-grouped,,223,32,12,6,0,0,1,384,9728.0 +new-environment-grouped,,224,64,13,6,0,0,1,832,24448.0 +new-environment-grouped,,225,32,14,6,0,0,1,448,10688.0 +new-environment-grouped,,226,512,15,6,0,0,1,7680,320000.0 +new-environment-grouped,,227,8192,21,6,0,0,1,172032,9297920.0 +new-environment-grouped,,228,0,22,6,0,0,1,0,0.0 +new-environment-grouped,,229,4096,35,6,0,0,1,143360,6356992.0 +new-environment-grouped,,230,2048,37,6,0,0,1,75776,3049472.0 +new-environment-grouped,,231,64,39,6,0,0,1,2496,54400.0 +new-environment-grouped,,232,32,50,6,0,0,1,1600,27968.0 +new-environment-grouped,,233,0,53,6,0,0,1,0,0.0 +new-environment-grouped,,234,0,67,6,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::verify_claim,0,1,10,4,0,0,1,10,48.0 +new-environment-ungrouped,IxVM::run_claim,1,1,128,50,0,0,2,128,546.0 +new-environment-ungrouped,IxVM::read_finite_byte_stream,2,512,7,6,0,0,1,3584,209408.0 +new-environment-ungrouped,IxVM::read_byte_stream,3,131072,11,8,0,0,2,1441792,155320320.0 +new-environment-ungrouped,"${""name"":""IxVM::list_depth_checked"",""types"":[""field""]}",4,131072,9,8,0,0,1,1179648,127533056.0 +new-environment-ungrouped,IxVM::checked_depth_succ,5,16384,4,4,0,0,1,65536,6946816.0 +new-environment-ungrouped,UInt32::less_than_fields,6,16384,14,14,0,0,1,229376,20709376.0 +new-environment-ungrouped,Blake3::compress_layer,7,2048,140,12,0,0,2,286720,10567680.0 +new-environment-ungrouped,Blake3::next_layer,8,16,177,20,0,0,2,2832,38784.0 +new-environment-ungrouped,Blake3::compress,9,32768,501,226,0,0,2,16416768,1078296576.0 +new-environment-ungrouped,Blake3::compress_chunks,10,131072,17,6,0,0,2,2228224,182059008.0 +new-environment-ungrouped,Blake3::finish,11,2048,166,28,0,0,2,339968,13406208.0 +new-environment-ungrouped,UInt64::is_zero,12,128,19,2,0,0,2,2432,68736.0 +new-environment-ungrouped,Blake3::bytes_to_block,13,4096,131,130,0,0,1,536576,38797312.0 +new-environment-ungrouped,Blake3::pad_block,14,65536,8,4,0,0,2,524288,51118080.0 +new-environment-ungrouped,Blake3::compress_block,15,2048,180,48,0,0,2,368640,15704064.0 +new-environment-ungrouped,"${""name"":""Lists::is_empty"",""types"":[""field""]}",16,2048,7,4,0,0,1,14336,886784.0 +new-environment-ungrouped,UInt64::wrapping_succ,17,1,20,4,0,0,2,20,84.0 +new-environment-ungrouped,IxVM::get_tagn4,18,32768,23,10,0,0,2,753664,54951936.0 +new-environment-ungrouped,IxVM::get_tagn_tail,19,2048,22,12,0,0,1,45056,2441216.0 +new-environment-ungrouped,IxVM::get_tagn_wide,20,0,28,10,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::get_u64_le,21,0,17,6,0,0,2,0,0.0 +new-environment-ungrouped,UInt64::add,22,32,26,18,0,0,1,832,22208.0 +new-environment-ungrouped,IxVM::read_byte,23,8192,5,4,0,0,1,40960,3547136.0 +new-environment-ungrouped,IxVM::get_address,24,2048,68,68,0,0,1,139264,9334784.0 +new-environment-ungrouped,IxVM::get_opt_addr,25,1,8,6,0,0,2,8,54.0 +new-environment-ungrouped,IxVM::run_eval,26,0,22,24,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::run_check,27,512,16,8,0,0,1,8192,361472.0 +new-environment-ungrouped,IxVM::get_ci,28,512,77,34,0,0,2,39424,1595904.0 +new-environment-ungrouped,IxVM::load_verified_constant,29,512,89,12,0,0,1,45568,1425920.0 +new-environment-ungrouped,Blake3::verify_bytes_against,30,512,72,14,0,0,1,36864,1218560.0 +new-environment-ungrouped,IxVM::get_constant,31,512,95,20,0,0,1,48640,1619456.0 +new-environment-ungrouped,IxVM::get_mut_const_list,32,64,70,12,0,0,2,4480,99840.0 +new-environment-ungrouped,IxVM::get_mut_const,33,32,52,10,0,0,2,1664,32064.0 +new-environment-ungrouped,IxVM::get_definition,34,256,20,12,0,0,1,5120,209920.0 +new-environment-ungrouped,IxVM::unpack_def_kind_safety,35,2,11,2,0,0,1,22,98.0 +new-environment-ungrouped,IxVM::get_tagn0,36,8192,17,8,0,0,1,139264,8658944.0 +new-environment-ungrouped,IxVM::get_expr,37,32768,48,24,0,0,2,1572864,112459776.0 +new-environment-ungrouped,IxVM::get_u64_list,38,4096,33,12,0,0,2,135168,7274496.0 +new-environment-ungrouped,UInt64::saturating_pred,39,128,20,4,0,0,2,2560,76800.0 +new-environment-ungrouped,IxVM::get_app_telescope,40,16384,27,12,0,0,1,442368,28278784.0 +new-environment-ungrouped,IxVM::get_lam_telescope,41,4096,34,16,0,0,2,139264,8011776.0 +new-environment-ungrouped,IxVM::get_lam_mode,42,2048,16,8,0,0,1,32768,1765376.0 +new-environment-ungrouped,IxVM::binder_contract_from_bits,43,1,15,4,0,0,1,15,63.0 +new-environment-ungrouped,IxVM::value_contract_from_bits,44,1,8,2,0,0,1,8,36.0 +new-environment-ungrouped,IxVM::get_all_telescope,45,2048,34,16,0,0,2,69632,3674112.0 +new-environment-ungrouped,IxVM::get_all_mode,46,2048,18,10,0,0,1,36864,2035712.0 +new-environment-ungrouped,IxVM::get_expr_let,47,16,34,16,0,0,1,544,10048.0 +new-environment-ungrouped,IxVM::get_inductive,48,32,53,20,0,0,1,1696,36128.0 +new-environment-ungrouped,IxVM::assert_wire_bool,49,1,5,4,0,0,1,5,33.0 +new-environment-ungrouped,IxVM::get_constructor_list,50,64,59,12,0,0,2,3776,87168.0 +new-environment-ungrouped,IxVM::get_constructor,51,64,43,16,0,0,1,2752,70528.0 +new-environment-ungrouped,IxVM::get_recursor,52,16,73,24,0,0,1,1168,19072.0 +new-environment-ungrouped,IxVM::get_recursor_rule_list,53,32,35,14,0,0,2,1120,25824.0 +new-environment-ungrouped,IxVM::get_constant_info_by_variant,54,512,56,18,0,0,2,28672,1084416.0 +new-environment-ungrouped,IxVM::get_axiom,55,0,16,10,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::get_quotient,56,0,17,10,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::get_quot_kind,57,0,6,2,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::get_constructor_proj,58,64,23,8,0,0,1,1472,38272.0 +new-environment-ungrouped,IxVM::get_recursor_proj,59,32,14,6,0,0,1,448,10688.0 +new-environment-ungrouped,IxVM::get_expr_list,60,2048,26,12,0,0,2,53248,2863104.0 +new-environment-ungrouped,IxVM::get_address_list,61,2048,26,12,0,0,2,53248,2863104.0 +new-environment-ungrouped,IxVM::get_univ_list,62,64,35,14,0,0,2,2240,61824.0 +new-environment-ungrouped,IxVM::get_univ,63,128,39,18,0,0,2,4992,165504.0 +new-environment-ungrouped,IxVM::get_tagn2,64,128,23,10,0,0,2,2944,100992.0 +new-environment-ungrouped,IxVM::build_succ_chain,65,16,39,10,0,0,2,624,10368.0 +new-environment-ungrouped,IxVM::load_constant_hint,66,256,36,4,0,0,1,9216,259072.0 +new-environment-ungrouped,IxVM::defn_is_unsafe_ci,67,2,9,2,0,0,2,18,114.0 +new-environment-ungrouped,IxVM::convert_definition,68,256,27,8,0,0,2,6912,242688.0 +new-environment-ungrouped,IxVM::convert_expr,69,16384,41,38,0,0,2,671744,57311232.0 +new-environment-ungrouped,"${""name"":""IxVM::list_lookup"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Univ""}}}}]}",70,8192,7,6,0,0,1,57344,4825088.0 +new-environment-ungrouped,"${""name"":""IxVM::list_drop"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Univ""}}}}]}",71,16384,9,6,0,0,2,147456,13271040.0 +new-environment-ungrouped,UInt64::to_field,72,128,10,2,0,0,1,1280,38144.0 +new-environment-ungrouped,IxVM::convert_univ,73,32,19,12,0,0,2,608,17184.0 +new-environment-ungrouped,IxVM::convert_univ_idxs,74,128,20,8,0,0,2,2560,87552.0 +new-environment-ungrouped,IxVM::load_verified_blob,75,32,38,8,0,0,1,1216,23168.0 +new-environment-ungrouped,IxVM::utf8_validate,76,0,9,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::utf8_decode_one,77,0,31,32,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::utf8_cont,78,0,7,6,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::bytes_to_limbs,79,32,33,20,0,0,2,1056,27744.0 +new-environment-ungrouped,IxVM::bytes_to_u64_limb,80,64,40,6,0,0,2,2560,58368.0 +new-environment-ungrouped,IxVM::skip_bytes,81,64,11,4,0,0,2,704,22656.0 +new-environment-ungrouped,IxVM::convert_axiom,82,0,18,6,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::convert_quotient,83,0,18,6,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::get_ci_dprj,84,0,120,14,0,0,1,0,0.0 +new-environment-ungrouped,"${""name"":""IxVM::list_lookup_u64"",""types"":[{""named"":{""args"":[],""name"":""IxVM::MutConst""}}]}",85,0,112,10,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::defn_member_recur_addrs,86,0,20,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::build_recur_addrs,87,32,5,4,0,0,1,160,5408.0 +new-environment-ungrouped,IxVM::build_recur_addrs_walk,88,64,57,6,0,0,2,3648,77952.0 +new-environment-ungrouped,IxVM::projection_addr,89,32,111,18,0,0,1,3552,63008.0 +new-environment-ungrouped,IxVM::muts_member_at,90,32,97,4,0,0,2,3104,50784.0 +new-environment-ungrouped,UInt64::from_field,91,2,12,12,0,0,1,24,164.0 +new-environment-ungrouped,IxVM::put_constant,92,64,72,18,0,0,2,4608,109056.0 +new-environment-ungrouped,IxVM::put_sharing,93,1,14,8,0,0,1,14,72.0 +new-environment-ungrouped,"${""name"":""IxVM::list_length_u64"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Expr""}}}}]}",94,4,23,8,0,0,1,92,808.0 +new-environment-ungrouped,IxVM::put_tagn0,95,64,16,8,0,0,2,1024,33024.0 +new-environment-ungrouped,IxVM::put_tagn_tail,96,0,30,18,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::put_tagn_wide,97,0,30,12,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::put_u64_le,98,0,16,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::put_expr_list,99,1,29,6,0,0,2,29,117.0 +new-environment-ungrouped,IxVM::put_expr,100,0,104,62,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::put_tagn4,101,64,18,10,0,0,2,1152,37632.0 +new-environment-ungrouped,"${""name"":""IxVM::list_length_u64"",""types"":[{""array"":{""element"":""field"",""length"":8}}]}",102,0,30,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::put_u64_list,103,0,17,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::app_telescope_count,104,0,55,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::put_app_telescope,105,0,60,6,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::lam_telescope_count,106,0,55,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::put_lam_telescope,107,0,61,8,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::put_lam_mode,108,0,9,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::binder_contract_code,109,0,10,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::value_contract_code,110,0,8,2,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::all_telescope_count,111,0,55,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::put_all_telescope,112,0,61,8,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::put_all_mode,113,0,12,10,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::put_refs,114,1,14,8,0,0,1,14,72.0 +new-environment-ungrouped,IxVM::put_address_list,115,1,10,8,0,0,1,10,60.0 +new-environment-ungrouped,IxVM::put_address,116,2048,68,68,0,0,1,139264,9334784.0 +new-environment-ungrouped,IxVM::put_univs,117,1,14,8,0,0,1,14,72.0 +new-environment-ungrouped,IxVM::put_univ_list,118,1,20,6,0,0,2,20,90.0 +new-environment-ungrouped,IxVM::put_univ,119,0,40,26,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::univ_succ_count,120,0,37,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::univ_succ_base,121,0,30,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::put_tagn2,122,0,18,10,0,0,2,0,0.0 +new-environment-ungrouped,"${""name"":""IxVM::list_length_u64"",""types"":[{""named"":{""args"":[],""name"":""IxVM::MutConst""}}]}",123,0,67,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::put_mut_const_list,124,0,54,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::put_mut_const,125,0,52,6,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::put_definition,126,0,57,18,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::pack_def_kind_safety,127,0,12,2,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::put_inductive,128,0,64,22,0,0,1,0,0.0 +new-environment-ungrouped,"${""name"":""IxVM::list_length_u64"",""types"":[{""named"":{""args"":[],""name"":""IxVM::Constructor""}}]}",129,0,56,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::put_constructor_list,130,0,43,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::put_constructor,131,0,62,18,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::put_recursor,132,0,83,26,0,0,1,0,0.0 +new-environment-ungrouped,"${""name"":""IxVM::list_length_u64"",""types"":[{""named"":{""args"":[],""name"":""IxVM::RecursorRule""}}]}",133,0,31,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::put_recursor_rule_list,134,0,18,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::put_recursor_rule,135,0,32,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::put_constant_info,136,64,56,18,0,0,1,3584,87808.0 +new-environment-ungrouped,IxVM::put_axiom,137,0,35,12,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::put_quotient,138,0,34,10,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::put_quot_kind,139,0,8,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::put_constructor_proj,140,32,23,8,0,0,1,736,15968.0 +new-environment-ungrouped,IxVM::put_recursor_proj,141,32,14,6,0,0,1,448,10688.0 +new-environment-ungrouped,Blake3::bytes_to_addr,142,1024,41,16,0,0,1,41984,1816576.0 +new-environment-ungrouped,IxVM::get_ci_iprj,143,32,111,12,0,0,1,3552,60128.0 +new-environment-ungrouped,IxVM::convert_inductive,144,32,40,12,0,0,1,1280,26048.0 +new-environment-ungrouped,IxVM::count_ctors,145,64,41,6,0,0,2,2624,59520.0 +new-environment-ungrouped,IxVM::get_ci_cprj,146,64,146,14,0,0,1,9344,186880.0 +new-environment-ungrouped,IxVM::ctor_at,147,64,75,4,0,0,2,4800,96384.0 +new-environment-ungrouped,IxVM::convert_constructor,148,64,47,12,0,0,1,3008,70528.0 +new-environment-ungrouped,IxVM::get_ci_rprj,149,0,111,12,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::convert_recursor,150,16,59,16,0,0,1,944,14848.0 +new-environment-ungrouped,IxVM::convert_rec_rules,151,32,24,12,0,0,2,768,19584.0 +new-environment-ungrouped,IxVM::check_const,152,512,42,60,0,0,2,21504,1471488.0 +new-environment-ungrouped,IxVM::is_unsafe_ci,153,512,23,2,0,0,2,11776,407040.0 +new-environment-ungrouped,IxVM::validate_expr_well_scoped,154,16384,32,24,0,0,2,524288,41484288.0 +new-environment-ungrouped,IxVM::validate_univ_params_seen,155,32,12,10,0,0,2,384,12864.0 +new-environment-ungrouped,IxVM::const_num_lvls,156,512,21,2,0,0,2,10752,379392.0 +new-environment-ungrouped,"${""name"":""IxVM::list_length"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KLevelNode""}}}}]}",157,8192,8,6,0,0,2,65536,5849088.0 +new-environment-ungrouped,IxVM::validate_univ_params_list,158,64,8,8,0,0,1,512,20992.0 +new-environment-ungrouped,IxVM::k_ensure_sort,159,4096,9,8,0,0,1,36864,2818048.0 +new-environment-ungrouped,IxVM::k_infer,160,8192,8,6,0,0,2,65536,5849088.0 +new-environment-ungrouped,IxVM::expr_lbr,161,32768,19,18,0,0,2,622592,60850176.0 +new-environment-ungrouped,IxVM::lbr_max,162,512,6,4,0,0,2,3072,199680.0 +new-environment-ungrouped,IxVM::lbr_dec,163,32,5,2,0,0,2,160,5664.0 +new-environment-ungrouped,IxVM::expr_lbr_let,164,16,11,14,0,0,1,176,5248.0 +new-environment-ungrouped,IxVM::k_infer_core,165,8192,33,46,0,0,2,270336,26615808.0 +new-environment-ungrouped,IxVM::types_lookup,166,1024,6,6,0,0,1,6144,434176.0 +new-environment-ungrouped,IxVM::expr_lift,167,16384,11,4,0,0,2,180224,13271040.0 +new-environment-ungrouped,IxVM::expr_lift_walk,168,16384,20,14,0,0,2,327680,26345472.0 +new-environment-ungrouped,IxVM::expr_lift_bvar,169,1024,8,4,0,0,2,8192,503808.0 +new-environment-ungrouped,IxVM::expr_lift_let,170,0,11,10,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::level_reduce,171,32,13,14,0,0,2,416,15264.0 +new-environment-ungrouped,IxVM::level_max,172,128,13,6,0,0,2,1664,63360.0 +new-environment-ungrouped,IxVM::level_explicit_val,173,32,12,6,0,0,2,384,10944.0 +new-environment-ungrouped,IxVM::level_max_go,174,128,21,8,0,0,2,2688,90240.0 +new-environment-ungrouped,IxVM::level_struct_eq,175,512,23,12,0,0,2,11776,545280.0 +new-environment-ungrouped,IxVM::level_max_subsumes,176,256,11,4,0,0,2,2816,119808.0 +new-environment-ungrouped,IxVM::level_max_offsets,177,64,13,12,0,0,1,832,31360.0 +new-environment-ungrouped,IxVM::level_offset_of,178,128,11,4,0,0,2,1408,52608.0 +new-environment-ungrouped,IxVM::level_imax,179,256,21,16,0,0,2,5376,254976.0 +new-environment-ungrouped,IxVM::level_is_not_zero,180,128,16,6,0,0,2,2048,71424.0 +new-environment-ungrouped,IxVM::const_type_of,181,512,21,2,0,0,2,10752,379392.0 +new-environment-ungrouped,IxVM::expr_inst_levels,182,4096,10,4,0,0,2,40960,2703360.0 +new-environment-ungrouped,IxVM::expr_inst_levels_walk,183,4096,20,16,0,0,2,81920,5947392.0 +new-environment-ungrouped,IxVM::level_inst_params,184,256,14,16,0,0,2,3584,211968.0 +new-environment-ungrouped,IxVM::level_list_inst,185,256,11,6,0,0,2,2816,132096.0 +new-environment-ungrouped,IxVM::collect_spine,186,16384,11,10,0,0,2,180224,17399808.0 +new-environment-ungrouped,"${""name"":""IxVM::list_snoc"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",187,16384,10,10,0,0,2,163840,16711680.0 +new-environment-ungrouped,IxVM::k_infer_app_spine_loop,188,8192,30,34,0,0,2,245760,21823488.0 +new-environment-ungrouped,IxVM::expr_inst_many,189,32768,15,8,0,0,2,491520,40206336.0 +new-environment-ungrouped,IxVM::has_bvar_in_range,190,8192,21,16,0,0,2,172032,13197312.0 +new-environment-ungrouped,IxVM::has_bvar_in_range_binder,191,2048,9,6,0,0,1,18432,1157120.0 +new-environment-ungrouped,IxVM::has_bvar_in_range_let,192,0,12,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::expr_inst_many_walk,193,16384,20,14,0,0,2,327680,26345472.0 +new-environment-ungrouped,IxVM::expr_inst_many_bvar,194,8192,10,12,0,0,1,81920,7700480.0 +new-environment-ungrouped,IxVM::expr_inst_many_let,195,0,11,10,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::expr_lower,196,32768,11,4,0,0,2,360448,28409856.0 +new-environment-ungrouped,IxVM::expr_lower_walk,197,32768,22,14,0,0,2,720896,59375616.0 +new-environment-ungrouped,IxVM::k_check,198,4096,7,6,0,0,1,28672,2228224.0 +new-environment-ungrouped,IxVM::k_is_def_eq,199,8192,11,8,0,0,2,90112,7446528.0 +new-environment-ungrouped,IxVM::k_is_def_eq_core,200,4096,6,4,0,0,1,24576,1785856.0 +new-environment-ungrouped,IxVM::k_is_def_eq_ordered,201,4096,9,4,0,0,2,36864,2555904.0 +new-environment-ungrouped,IxVM::try_def_eq_app,202,4096,32,12,0,0,2,131072,7127040.0 +new-environment-ungrouped,IxVM::de_args,203,4096,18,6,0,0,2,73728,4177920.0 +new-environment-ungrouped,IxVM::address_eq,204,8192,71,4,0,0,2,581632,25337856.0 +new-environment-ungrouped,IxVM::address_eq_tail,205,256,74,4,0,0,2,18944,506880.0 +new-environment-ungrouped,IxVM::level_list_eq,206,32,17,6,0,0,2,544,13344.0 +new-environment-ungrouped,IxVM::level_equal,207,32,9,10,0,0,1,288,10208.0 +new-environment-ungrouped,IxVM::nl_eq,208,32,27,20,0,0,2,864,24864.0 +new-environment-ungrouped,IxVM::nl_skip_empty,209,32,16,6,0,0,2,512,12864.0 +new-environment-ungrouped,IxVM::glist_cmp,210,16,18,12,0,0,2,288,6720.0 +new-environment-ungrouped,IxVM::nlvars_eq,211,8,21,12,0,0,2,168,2760.0 +new-environment-ungrouped,IxVM::level_normalize,212,32,11,18,0,0,1,352,15008.0 +new-environment-ungrouped,IxVM::normalize_aux,213,128,19,20,0,0,2,2432,117120.0 +new-environment-ungrouped,IxVM::nl_add_const,214,16,12,6,0,0,2,192,4416.0 +new-environment-ungrouped,IxVM::nl_add_const_go,215,16,20,20,0,0,2,320,8640.0 +new-environment-ungrouped,IxVM::normalize_imax_dispatch,216,0,21,26,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::glist_ordered_insert,217,4,15,14,0,0,2,60,840.0 +new-environment-ungrouped,IxVM::nl_add_var,218,32,21,24,0,0,2,672,23904.0 +new-environment-ungrouped,IxVM::nlvars_add,219,4,19,20,0,0,2,76,1080.0 +new-environment-ungrouped,IxVM::nl_subsumption_walk,220,64,11,10,0,0,1,704,26752.0 +new-environment-ungrouped,IxVM::nl_subsume_entry,221,128,40,16,0,0,2,5120,162816.0 +new-environment-ungrouped,IxVM::glist_subset,222,16,17,12,0,0,2,272,6528.0 +new-environment-ungrouped,IxVM::glist_eq_len,223,8,14,8,0,0,2,112,1968.0 +new-environment-ungrouped,IxVM::nlvars_max_offset,224,0,12,10,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::nlvars_subsume,225,0,24,14,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::k_is_def_eq_slow,226,4096,12,4,0,0,2,49152,2998272.0 +new-environment-ungrouped,IxVM::try_string_lit_one,227,4096,14,6,0,0,2,57344,3588096.0 +new-environment-ungrouped,IxVM::str_lit_delta_step,228,0,38,22,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::whnf_nd,229,2048,22,6,0,0,2,45056,2187264.0 +new-environment-ungrouped,IxVM::whnf_nd_with_spine,230,4096,20,12,0,0,2,81920,5357568.0 +new-environment-ungrouped,"${""name"":""IxVM::list_concat"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",231,16384,10,8,0,0,1,163840,13828096.0 +new-environment-ungrouped,IxVM::whnf_nd_apply_beta,232,512,16,10,0,0,2,8192,420864.0 +new-environment-ungrouped,IxVM::peel_beta,233,8192,18,6,0,0,2,147456,9043968.0 +new-environment-ungrouped,IxVM::apply_spine,234,8192,10,8,0,0,1,81920,6422528.0 +new-environment-ungrouped,IxVM::expr_inst1,235,8192,12,6,0,0,2,98304,7127040.0 +new-environment-ungrouped,IxVM::expr_has_bvar_at,236,8192,23,12,0,0,2,188416,12558336.0 +new-environment-ungrouped,IxVM::expr_has_bvar_at_binder,237,2048,9,4,0,0,2,18432,1173504.0 +new-environment-ungrouped,IxVM::expr_has_bvar_at_let,238,0,13,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::expr_inst1_walk,239,4096,20,14,0,0,2,81920,5652480.0 +new-environment-ungrouped,IxVM::expr_inst1_bvar,240,512,10,8,0,0,2,5120,310272.0 +new-environment-ungrouped,IxVM::expr_inst1_let,241,0,11,10,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::whnf_nd_const_head,242,1024,57,46,0,0,2,58368,3299328.0 +new-environment-ungrouped,IxVM::prim_family,243,128,85,38,0,0,2,10880,342912.0 +new-environment-ungrouped,IxVM::nat_succ_addr,244,2,3,4,0,0,1,6,62.0 +new-environment-ungrouped,IxVM::nat_pred_addr,245,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::nat_add_addr,246,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::nat_sub_addr,247,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::nat_mul_addr,248,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::nat_div_addr,249,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::nat_mod_addr,250,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::nat_pow_addr,251,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::nat_gcd_addr,252,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::nat_beq_addr,253,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::nat_ble_addr,254,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::nat_land_addr,255,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::nat_lor_addr,256,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::nat_xor_addr,257,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::nat_shift_left_addr,258,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::nat_shift_right_addr,259,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::is_str_prim_addr,260,128,31,16,0,0,2,3968,138624.0 +new-environment-ungrouped,IxVM::string_utf8_byte_size_addr,261,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::string_append_addr,262,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::string_of_list_addr,263,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::string_back_addr,264,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::string_legacy_back_addr,265,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::string_to_byte_array_addr,266,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::string_dec_eq_addr,267,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::is_bitvec_prim_addr,268,128,15,8,0,0,2,1920,74112.0 +new-environment-ungrouped,IxVM::bit_vec_to_nat_addr,269,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::bit_vec_ult_addr,270,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::decidable_decide_addr,271,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::is_native_prim_addr,272,128,23,12,0,0,2,2944,106368.0 +new-environment-ungrouped,IxVM::system_platform_num_bits_addr,273,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::punit_size_of_1_addr,274,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::reduce_bool_addr,275,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::reduce_nat_addr,276,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::subtype_val_addr,277,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::is_dec_prim_addr,278,128,27,14,0,0,2,3456,122496.0 +new-environment-ungrouped,IxVM::nat_dec_le_addr_dec,279,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::nat_dec_eq_addr_dec,280,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::nat_dec_lt_addr_dec,281,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::int_dec_le_addr_dec,282,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::int_dec_eq_addr_dec,283,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::int_dec_lt_addr_dec,284,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::is_int_prim_addr,285,128,23,42,0,0,1,2944,180608.0 +new-environment-ungrouped,IxVM::int_add_addr,286,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::int_sub_addr,287,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::int_mul_addr,288,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::int_neg_addr,289,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::int_emod_addr,290,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::int_ediv_addr,291,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::int_bmod_addr,292,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::int_bdiv_addr,293,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::int_nat_abs_addr,294,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::int_pow_addr,295,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::try_prim_dispatch,296,2048,22,10,0,0,2,45056,2457600.0 +new-environment-ungrouped,IxVM::try_nat_dispatch_prewhnf,297,128,30,48,0,0,2,3840,221952.0 +new-environment-ungrouped,IxVM::whnf_spine,298,128,11,6,0,0,2,1408,57984.0 +new-environment-ungrouped,IxVM::whnf,299,4096,22,6,0,0,2,90112,4767744.0 +new-environment-ungrouped,IxVM::whnf_with_spine,300,4096,20,12,0,0,2,81920,5357568.0 +new-environment-ungrouped,IxVM::whnf_apply_beta,301,1024,16,10,0,0,2,16384,933888.0 +new-environment-ungrouped,IxVM::whnf_const_head,302,1024,51,42,0,0,2,52224,2992128.0 +new-environment-ungrouped,IxVM::try_reduce_projection_definition,303,1024,18,16,0,0,2,18432,1179648.0 +new-environment-ungrouped,IxVM::projection_definition_info,304,512,24,12,0,0,2,12288,559104.0 +new-environment-ungrouped,IxVM::try_quot_iota,305,0,16,8,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::quot_lift_addr_iota,306,0,3,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::try_quot_lift,307,0,16,18,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::quot_extract_arg,308,0,19,18,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::quot_ctor_addr_iota,309,0,3,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::quot_ind_addr_iota,310,0,3,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::try_quot_ind,311,0,16,18,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::se_parent_addr,312,8,22,12,0,0,2,176,2832.0 +new-environment-ungrouped,IxVM::try_k_synth_iota,313,2,31,26,0,0,2,62,390.0 +new-environment-ungrouped,IxVM::k_synth_gate,314,2,39,14,0,0,2,78,366.0 +new-environment-ungrouped,IxVM::canon_cprj_addr,315,1,27,18,0,0,1,27,141.0 +new-environment-ungrouped,"${""name"":""IxVM::list_take"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",316,2048,10,8,0,0,2,20480,1511424.0 +new-environment-ungrouped,IxVM::try_iota,317,256,43,50,0,0,2,11008,599040.0 +new-environment-ungrouped,IxVM::try_nat_linear_rec,318,256,28,28,0,0,2,7168,371712.0 +new-environment-ungrouped,IxVM::try_extract_nat,319,128,18,12,0,0,2,2304,92928.0 +new-environment-ungrouped,IxVM::nat_zero_addr,320,2,3,4,0,0,1,6,62.0 +new-environment-ungrouped,IxVM::try_extract_nat_app,321,128,17,14,0,0,2,2176,95616.0 +new-environment-ungrouped,IxVM::klimbs_succ,322,4,27,12,0,0,2,108,1080.0 +new-environment-ungrouped,IxVM::is_nat_succ_ih_step,323,16,34,10,0,0,2,544,9408.0 +new-environment-ungrouped,IxVM::mk_nat_lit,324,8,4,4,0,0,1,32,752.0 +new-environment-ungrouped,IxVM::klimbs_add,325,32,5,4,0,0,1,160,5408.0 +new-environment-ungrouped,IxVM::klimbs_add_carry,326,32,50,18,0,0,2,1600,34944.0 +new-environment-ungrouped,IxVM::mk_nat_offset_stuck,327,4,15,20,0,0,2,60,984.0 +new-environment-ungrouped,IxVM::klimbs_is_zero,328,32,16,4,0,0,2,512,11904.0 +new-environment-ungrouped,IxVM::klimbs_normalize,329,32,30,14,0,0,2,960,23424.0 +new-environment-ungrouped,IxVM::cleanup_nat_offset_major,330,128,25,8,0,0,2,3200,100992.0 +new-environment-ungrouped,IxVM::try_match_nat_add,331,128,25,18,0,0,2,3200,127872.0 +new-environment-ungrouped,IxVM::build_succ_offset,332,1,21,32,0,0,2,21,171.0 +new-environment-ungrouped,IxVM::klimbs_sub,333,64,8,8,0,0,1,512,20992.0 +new-environment-ungrouped,IxVM::klimbs_sub_borrow,334,64,52,24,0,0,2,3328,92928.0 +new-environment-ungrouped,UInt64::sub_with_borrow,335,64,26,18,0,0,1,1664,53248.0 +new-environment-ungrouped,IxVM::whnf_iota_major,336,128,29,10,0,0,2,3712,117120.0 +new-environment-ungrouped,IxVM::nat_lit_to_ctor_or_self,337,64,19,22,0,0,2,1216,52608.0 +new-environment-ungrouped,IxVM::klimbs_dec,338,2,6,8,0,0,1,12,104.0 +new-environment-ungrouped,IxVM::collect_spine_of_ctor,339,64,27,16,0,0,2,1728,54912.0 +new-environment-ungrouped,IxVM::compute_iprj_addr,340,8,18,16,0,0,1,144,2624.0 +new-environment-ungrouped,IxVM::find_rule,341,16,15,4,0,0,2,240,4608.0 +new-environment-ungrouped,IxVM::replace_spine_major,342,64,11,14,0,0,1,704,31360.0 +new-environment-ungrouped,IxVM::rec_to_parent_addr,343,16,16,10,0,0,1,256,5440.0 +new-environment-ungrouped,IxVM::peel_n_foralls,344,512,11,4,0,0,2,5632,268800.0 +new-environment-ungrouped,IxVM::try_struct_eta_iota,345,64,62,40,0,0,2,3968,122880.0 +new-environment-ungrouped,IxVM::struct_is_rec,346,4,19,6,0,0,2,76,744.0 +new-environment-ungrouped,IxVM::struct_block_member_addrs,347,4,56,6,0,0,2,224,1632.0 +new-environment-ungrouped,IxVM::struct_scan_ctors,348,8,29,6,0,0,2,232,2904.0 +new-environment-ungrouped,IxVM::se_peel_tol,349,16,13,4,0,0,2,208,4224.0 +new-environment-ungrouped,IxVM::se_scan_fields,350,16,13,4,0,0,2,208,4224.0 +new-environment-ungrouped,IxVM::se_mentions,351,16,26,14,0,0,2,416,8640.0 +new-environment-ungrouped,IxVM::se_addr_in,352,0,12,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::is_prop_type,353,128,13,6,0,0,2,1664,63360.0 +new-environment-ungrouped,IxVM::k_infer_only,354,1024,58,78,0,0,2,59392,4313088.0 +new-environment-ungrouped,IxVM::ensure_sort_only,355,64,16,10,0,0,2,1024,35328.0 +new-environment-ungrouped,IxVM::nat_addr_io,356,2,3,4,0,0,1,6,62.0 +new-environment-ungrouped,IxVM::str_addr_io,357,0,3,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::io_peel_params_subst,358,128,16,6,0,0,2,2048,71424.0 +new-environment-ungrouped,IxVM::io_peel_field_loop,359,32,15,6,0,0,2,480,12384.0 +new-environment-ungrouped,IxVM::ctx_trim,360,4096,13,8,0,0,2,53248,3735552.0 +new-environment-ungrouped,IxVM::ctx_seek_cut,361,2048,9,10,0,0,2,18432,1579008.0 +new-environment-ungrouped,IxVM::ctx_next_cut,362,1024,7,8,0,0,1,7168,526336.0 +new-environment-ungrouped,IxVM::ctx_close_cut,363,1024,11,10,0,0,2,11264,780288.0 +new-environment-ungrouped,IxVM::lbr_min,364,512,6,4,0,0,2,3072,199680.0 +new-environment-ungrouped,IxVM::apply_n_projs,365,0,12,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::whnf_proj_head,366,256,37,26,0,0,2,9472,414720.0 +new-environment-ungrouped,IxVM::str_lit_to_ctor_app_or_self,367,256,12,4,0,0,2,3072,125952.0 +new-environment-ungrouped,IxVM::str_lit_to_ctor,368,0,23,42,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::list_nil_addr,369,0,3,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::list_cons_addr,370,0,3,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::char_type_addr,371,0,3,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::char_of_nat_addr,372,0,3,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::build_char_list,373,0,18,18,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::klimbs_from_g,374,0,14,18,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::split_u32,375,0,11,10,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::divmod_256,376,0,8,6,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::try_reduce_fin_val_decidable_rec,377,128,60,64,0,0,2,7680,345600.0 +new-environment-ungrouped,IxVM::fin_addr,378,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::decidable_rec_addr,379,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::whnf_get_ctor_or_none,380,32,12,6,0,0,2,384,10944.0 +new-environment-ungrouped,IxVM::try_nat_binop_dispatch,381,64,24,24,0,0,2,1536,60672.0 +new-environment-ungrouped,IxVM::try_nat_binop_addr,382,8,62,140,0,0,2,496,14928.0 +new-environment-ungrouped,IxVM::klimbs_mul,383,16,6,6,0,0,1,96,2752.0 +new-environment-ungrouped,IxVM::klimbs_mul_outer,384,32,21,12,0,0,1,672,16928.0 +new-environment-ungrouped,IxVM::klimbs_mul_single,385,32,68,20,0,0,2,2176,44544.0 +new-environment-ungrouped,UInt64::mul,386,16,52,44,0,0,1,832,18880.0 +new-environment-ungrouped,IxVM::klimbs_shl_limbs,387,16,8,4,0,0,2,128,3264.0 +new-environment-ungrouped,IxVM::klimbs_div,388,0,6,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::klimbs_div_mod,389,8,17,26,0,0,2,136,3480.0 +new-environment-ungrouped,IxVM::ordinary_div_mod,390,8,11,6,0,0,2,88,1608.0 +new-environment-ungrouped,IxVM::divide_grow,391,32,16,18,0,0,2,512,18624.0 +new-environment-ungrouped,IxVM::klimbs_le,392,32,17,4,0,0,2,544,12384.0 +new-environment-ungrouped,IxVM::klimbs_eq,393,32,30,6,0,0,2,960,19584.0 +new-environment-ungrouped,UInt64::eq,394,32,27,2,0,0,2,864,16224.0 +new-environment-ungrouped,IxVM::klimbs_mod,395,0,6,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::klimbs_gcd,396,0,8,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::klimbs_pow,397,8,17,22,0,0,2,136,3192.0 +new-environment-ungrouped,IxVM::klimbs_land,398,0,36,12,0,0,2,0,0.0 +new-environment-ungrouped,UInt64::and,399,0,26,18,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::klimbs_lor,400,0,36,12,0,0,1,0,0.0 +new-environment-ungrouped,UInt64::or,401,0,26,18,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::klimbs_xor_op,402,0,36,12,0,0,1,0,0.0 +new-environment-ungrouped,UInt64::xor,403,0,26,18,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::klimbs_shl,404,0,8,10,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::klimbs_shr,405,0,8,10,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::mk_bool,406,2,8,10,0,0,2,16,156.0 +new-environment-ungrouped,IxVM::bool_false_addr,407,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::bool_true_addr,408,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::try_nat_offset_dispatch,409,8,27,30,0,0,2,216,4488.0 +new-environment-ungrouped,IxVM::mk_nat_binop_stuck,410,0,12,14,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::try_str_dispatch,411,0,59,66,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::walk_char_list_bytes,412,0,32,32,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::char_lit_codepoint,413,0,11,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::char_lit_codepoint_syn,414,0,26,8,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::klimbs_scalar_value,415,0,39,12,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::utf8_encode_prepend,416,0,33,50,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::utf8_groups,417,0,9,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::divmod_64u,418,0,9,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::try_str_back,419,0,21,24,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::utf8_last_codepoint,420,0,4,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::utf8_last_go,421,0,11,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::try_str_to_byte_array,422,0,21,18,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::byte_array_empty_addr,423,0,3,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::try_str_dec_eq,424,0,28,20,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::bytestream_eq,425,0,16,8,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::str_dec_eq_build,426,0,38,60,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::eq_refl_addr_dec,427,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::decidable_is_true_addr_dec,428,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::try_bitvec_dispatch,429,8,23,36,0,0,2,184,4632.0 +new-environment-ungrouped,IxVM::bitvec_prep_spine,430,2,20,20,0,0,1,40,260.0 +new-environment-ungrouped,IxVM::bv_to_nat_via,431,2,19,18,0,0,2,38,270.0 +new-environment-ungrouped,IxVM::bitvec_of_nat_args_direct,432,2,18,20,0,0,2,36,276.0 +new-environment-ungrouped,IxVM::bit_vec_of_nat_addr,433,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::bitvec_prep_spine_ult,434,0,22,20,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::np_whnf_inner_bv,435,0,8,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::try_reduce_bit_vec_ult,436,0,18,22,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::try_reduce_decide_bitvec_lt,437,8,48,52,0,0,2,384,7584.0 +new-environment-ungrouped,IxVM::lt_lt_addr,438,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::bit_vec_addr,439,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::try_native_dispatch,440,0,33,22,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::mk_nat_literal_64,441,0,5,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::mk_nat_one,442,0,5,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::try_reduce_subtype_val,443,0,20,20,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::system_platform_get_num_bits_addr,444,0,3,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::check_native_bool,445,0,14,14,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::check_native_nat,446,0,11,6,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::try_dec_dispatch,447,16,23,14,0,0,2,368,8064.0 +new-environment-ungrouped,IxVM::is_int_dec_prim_addr,448,2,15,8,0,0,2,30,186.0 +new-environment-ungrouped,IxVM::try_normalize_int_decidable,449,0,23,18,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::try_extract_int,450,0,27,18,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::int_of_nat_addr_dec,451,0,3,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::int_neg_succ_addr_dec,452,0,3,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::normalize_int_dec_rebuild,453,0,25,24,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::intern_int_lit,454,0,11,8,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::dec_rewrite_lt_to_le,455,8,19,26,0,0,2,152,3624.0 +new-environment-ungrouped,IxVM::dec_dispatch_le_eq,456,16,23,12,0,0,2,368,7680.0 +new-environment-ungrouped,IxVM::dec_build_proof,457,4,43,52,0,0,2,172,2424.0 +new-environment-ungrouped,IxVM::bool_type_addr_dec,458,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::nat_le_of_ble_eq_true_addr_dec,459,1,3,4,0,0,1,3,27.0 +new-environment-ungrouped,IxVM::nat_not_le_of_not_ble_eq_true_addr_dec,460,0,3,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::nat_eq_of_beq_eq_true_addr_dec,461,0,3,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::nat_ne_of_beq_eq_false_addr_dec,462,0,3,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::dec_finish,463,4,29,36,0,0,2,116,1704.0 +new-environment-ungrouped,IxVM::decidable_is_false_addr_dec,464,0,3,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::try_int_prim_dispatch,465,0,33,44,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::try_extract_int_prim,466,0,25,24,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::mk_int_prim,467,0,19,12,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::try_int_prim_second,468,0,43,90,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::int_bmod_prim,469,0,22,26,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::int_bdiv_prim,470,0,32,38,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::int_add_prim,471,0,13,8,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::int_emod_prim,472,0,14,8,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::int_ediv_prim,473,0,20,10,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::whnf_nd_proj_head,474,512,37,26,0,0,2,18944,932352.0 +new-environment-ungrouped,IxVM::k_is_def_eq_slow_nd,475,4096,14,6,0,0,2,57344,3588096.0 +new-environment-ungrouped,IxVM::whnf_struct_core,476,4096,22,6,0,0,2,90112,4767744.0 +new-environment-ungrouped,IxVM::whnf_struct_core_spine,477,4096,25,36,0,0,2,102400,9633792.0 +new-environment-ungrouped,IxVM::whnf_struct_core_proj,478,32,32,18,0,0,2,1024,26304.0 +new-environment-ungrouped,IxVM::whnf_struct_core_const,479,512,27,14,0,0,2,13824,628224.0 +new-environment-ungrouped,IxVM::k_is_def_eq_struct_safe,480,4096,27,14,0,0,2,110592,6684672.0 +new-environment-ungrouped,IxVM::k_is_def_eq_slow_nd_after_core,481,512,16,6,0,0,2,8192,365568.0 +new-environment-ungrouped,IxVM::k_is_def_eq_slow2,482,512,29,8,0,0,2,14848,572928.0 +new-environment-ungrouped,IxVM::try_proof_irrel,483,512,11,6,0,0,2,5632,296448.0 +new-environment-ungrouped,IxVM::try_unit_like,484,512,12,6,0,0,2,6144,310272.0 +new-environment-ungrouped,IxVM::is_unit_like_type,485,32,42,8,0,0,2,1344,26304.0 +new-environment-ungrouped,IxVM::try_eta_struct,486,512,61,14,0,0,2,31232,1098240.0 +new-environment-ungrouped,IxVM::compare_struct_fields,487,16,17,6,0,0,2,272,5376.0 +new-environment-ungrouped,IxVM::try_def_eq_nat,488,1024,23,14,0,0,2,23552,1271808.0 +new-environment-ungrouped,IxVM::is_nat_zero,489,1024,13,6,0,0,2,13312,718848.0 +new-environment-ungrouped,IxVM::nat_offset_of,490,1024,36,30,0,0,2,36864,2162688.0 +new-environment-ungrouped,IxVM::lazy_delta_loop,491,2048,24,8,0,0,2,49152,2457600.0 +new-environment-ungrouped,IxVM::head_addr,492,1024,12,8,0,0,2,12288,749568.0 +new-environment-ungrouped,IxVM::lazy_delta_step_const_const,493,512,52,16,0,0,2,26624,1001472.0 +new-environment-ungrouped,IxVM::is_defn_or_thm,494,128,18,2,0,0,2,2304,66048.0 +new-environment-ungrouped,IxVM::unfold_b_and_loop,495,64,13,4,0,0,2,832,24960.0 +new-environment-ungrouped,IxVM::delta_unfold,496,512,27,14,0,0,2,13824,628224.0 +new-environment-ungrouped,IxVM::unfold_a_and_loop,497,128,13,4,0,0,2,1664,57984.0 +new-environment-ungrouped,IxVM::delta_rank,498,64,16,2,0,0,2,1024,26112.0 +new-environment-ungrouped,IxVM::unfold_both_and_loop,499,64,17,6,0,0,2,1088,31872.0 +new-environment-ungrouped,IxVM::lazy_delta_a_const_b_proj,500,256,34,8,0,0,2,8704,285696.0 +new-environment-ungrouped,IxVM::try_unfold_proj_app,501,512,24,18,0,0,2,12288,642048.0 +new-environment-ungrouped,IxVM::try_unfold_head,502,256,23,6,0,0,2,5888,205824.0 +new-environment-ungrouped,IxVM::lazy_delta_b_const_a_proj,503,256,34,8,0,0,2,8704,285696.0 +new-environment-ungrouped,IxVM::lazy_delta_both_proj,504,512,18,8,0,0,2,9216,420864.0 +new-environment-ungrouped,IxVM::slow2_after_delta,505,256,15,4,0,0,2,3840,144384.0 +new-environment-ungrouped,IxVM::k_is_def_eq_struct_bounded,506,4096,43,24,0,0,2,176128,10518528.0 +new-environment-ungrouped,IxVM::k_is_def_eq_struct_spend,507,1024,21,6,0,0,2,21504,964608.0 +new-environment-ungrouped,IxVM::literal_eq,508,8,11,4,0,0,2,88,1464.0 +new-environment-ungrouped,IxVM::k_is_def_eq_structure_tree,509,256,13,4,0,0,2,3328,132096.0 +new-environment-ungrouped,IxVM::try_same_proj_head_app,510,256,32,12,0,0,2,8192,297984.0 +new-environment-ungrouped,IxVM::k_is_def_eq_structure_tree_app,511,256,19,6,0,0,2,4864,181248.0 +new-environment-ungrouped,IxVM::slow2_eager_fallback,512,128,27,10,0,0,2,3456,111744.0 +new-environment-ungrouped,IxVM::try_eta_swap,513,128,19,8,0,0,2,2432,84864.0 +new-environment-ungrouped,IxVM::try_eta_expand,514,2,21,10,0,0,2,42,234.0 +new-environment-ungrouped,IxVM::k_is_def_eq_struct,515,128,6,4,0,0,1,768,32768.0 +new-environment-ungrouped,IxVM::k_is_def_eq_struct_go,516,128,43,34,0,0,2,5504,219264.0 +new-environment-ungrouped,IxVM::try_lazy_delta_app,517,32,48,20,0,0,2,1536,34944.0 +new-environment-ungrouped,IxVM::k_def_eq_rebase,518,8192,18,14,0,0,2,147456,11599872.0 +new-environment-ungrouped,IxVM::expr_glb,519,32768,9,4,0,0,2,294912,25460736.0 +new-environment-ungrouped,IxVM::expr_glb_walk,520,32768,22,18,0,0,2,720896,65273856.0 +new-environment-ungrouped,IxVM::expr_glb_binder,521,8192,10,4,0,0,2,81920,5849088.0 +new-environment-ungrouped,IxVM::expr_glb_let,522,32,15,6,0,0,2,480,12384.0 +new-environment-ungrouped,IxVM::k_infer_let_start,523,16,11,14,0,0,1,176,5248.0 +new-environment-ungrouped,IxVM::k_infer_let_env,524,512,20,20,0,0,2,10240,614400.0 +new-environment-ungrouped,IxVM::infer_let_local_cutoff,525,64,13,6,0,0,2,832,27264.0 +new-environment-ungrouped,IxVM::k_infer_let_env_core,526,512,27,52,0,0,2,13824,1153536.0 +new-environment-ungrouped,IxVM::infer_let_lookup_type,527,128,16,8,0,0,2,2048,76800.0 +new-environment-ungrouped,IxVM::infer_let_materialize,528,1024,28,24,0,0,2,28672,1732608.0 +new-environment-ungrouped,IxVM::infer_let_lookup_value,529,256,16,10,0,0,2,4096,187392.0 +new-environment-ungrouped,IxVM::k_infer_let_env_rebase,530,64,14,14,0,0,1,896,34816.0 +new-environment-ungrouped,IxVM::infer_let_drop_unused,531,128,16,6,0,0,2,2048,71424.0 +new-environment-ungrouped,IxVM::k_infer_lit,532,32,8,10,0,0,2,256,10944.0 +new-environment-ungrouped,IxVM::k_infer_proj,533,64,41,28,0,0,1,2624,82048.0 +new-environment-ungrouped,IxVM::is_inductive_prop,534,64,13,12,0,0,1,832,31360.0 +new-environment-ungrouped,IxVM::peel_n_alls_whnf,535,128,15,6,0,0,2,1920,68736.0 +new-environment-ungrouped,IxVM::peel_field_loop,536,64,17,8,0,0,2,1088,34176.0 +new-environment-ungrouped,IxVM::check_prop_field_if_prop,537,64,10,4,0,0,2,640,21504.0 +new-environment-ungrouped,IxVM::check_no_dep_data_field_if_prop,538,1,14,6,0,0,2,14,72.0 +new-environment-ungrouped,IxVM::k_infer_rebase,539,8192,15,12,0,0,2,122880,10002432.0 +new-environment-ungrouped,IxVM::assert_safety,540,512,7,2,0,0,2,3584,185856.0 +new-environment-ungrouped,IxVM::safe_refs_only,541,8192,30,18,0,0,2,245760,16711680.0 +new-environment-ungrouped,IxVM::check_quot,542,0,13,22,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::quot_type_addr,543,0,3,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::check_eq_type,544,0,12,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::eq_type_addr,545,0,3,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::count_foralls_at_least,546,0,14,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::check_canonical_block,547,64,67,16,0,0,2,4288,100992.0 +new-environment-ungrouped,IxVM::canon_muts_has_kind,548,64,58,4,0,0,2,3712,76800.0 +new-environment-ungrouped,IxVM::canon_indc_positions,549,32,56,8,0,0,2,1792,33024.0 +new-environment-ungrouped,IxVM::canon_sort_loop,550,0,15,6,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_build_ctx_classes,551,0,15,12,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::canon_build_ctx_members,552,0,21,18,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_member_num_ctors,553,0,18,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_member_ci,554,0,18,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::canon_ctor_ctx_entries,555,0,12,8,0,0,2,0,0.0 +new-environment-ungrouped,"${""name"":""IxVM::list_concat"",""types"":[{""tuple"":{""items"":[{""ptr"":{""target"":{""array"":{""element"":""field"",""length"":32}}}},""field""]}}]}",556,0,11,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::canon_refine_classes,557,0,12,12,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::canon_refine_one,558,0,12,12,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_ins_sort,559,0,11,10,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::canon_insert_sorted,560,0,40,16,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_cmp_member_ctx,561,0,34,6,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_ord_cmp_g,562,0,8,2,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_kind_ord,563,0,21,2,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::canon_cmp_member_same_kind_ctx,564,0,70,74,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_sord_then,565,0,9,2,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_sord_of_g,566,0,3,2,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::canon_cmp_kexpr_ctx,567,0,15,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::canon_cmp_kexpr_node_ctx,568,0,61,50,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_sord_lt_strong,569,0,2,2,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::canon_sord_gt_strong,570,0,2,2,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::canon_cmp_kuniv,571,0,29,16,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_ord_then,572,0,6,2,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_cmp_kuniv_list,573,0,16,12,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_ctx_cmp_addr,574,0,18,10,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_sord_eq_strong,575,0,2,2,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::canon_ctx_class_idx,576,0,13,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_addr_cmp,577,0,83,36,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::canon_addr_chunk,578,0,11,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::canon_cmp_kliteral,579,0,10,6,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::canon_cmp_klimbs,580,0,12,8,0,0,2,0,0.0 +new-environment-ungrouped,"${""name"":""IxVM::list_length"",""types"":[{""array"":{""element"":""field"",""length"":8}}]}",581,0,15,6,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_cmp_klimbs_tail,582,0,28,12,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::canon_cmp_u64_lex,583,0,33,32,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::canon_cmp_bytes,584,0,16,12,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_cmp_ctor_range_ctx,585,0,43,10,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_cmp_ctor_pair_ctx,586,0,51,36,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_cmp_krec_rule_list_ctx,587,0,24,10,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_cmp_krec_rule_ctx,588,0,16,10,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::canon_group_consec,589,0,12,12,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::canon_group_walk,590,0,43,24,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_classes_eq,591,0,17,6,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_all_singleton,592,0,11,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::canon_flatten,593,0,9,10,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::check_inductive_shape,594,32,12,8,0,0,1,384,10688.0 +new-environment-ungrouped,IxVM::get_result_sort_level,595,64,14,10,0,0,2,896,33024.0 +new-environment-ungrouped,IxVM::check_inductive_shape_ctors,596,64,30,10,0,0,2,1920,51456.0 +new-environment-ungrouped,IxVM::check_param_agreement,597,64,6,6,0,0,1,384,16384.0 +new-environment-ungrouped,IxVM::check_param_agreement_go,598,128,18,6,0,0,2,2304,76800.0 +new-environment-ungrouped,IxVM::check_ctor_return_type,599,64,20,24,0,0,1,1280,53248.0 +new-environment-ungrouped,IxVM::assert_return_head_is_parent,600,32,17,8,0,0,1,544,13088.0 +new-environment-ungrouped,IxVM::assert_lvls_are_params,601,16,13,6,0,0,2,208,4608.0 +new-environment-ungrouped,IxVM::assert_first_args_are_param_bvars,602,64,15,4,0,0,2,960,27264.0 +new-environment-ungrouped,IxVM::list_any_mentions_block,603,64,12,4,0,0,2,768,23808.0 +new-environment-ungrouped,IxVM::expr_mentions_block,604,256,26,14,0,0,2,6656,273408.0 +new-environment-ungrouped,IxVM::caddr_is_peer,605,64,20,4,0,0,2,1280,33024.0 +new-environment-ungrouped,IxVM::addr_list_contains,606,64,12,4,0,0,2,768,23808.0 +new-environment-ungrouped,IxVM::check_field_universes,607,64,11,4,0,0,2,704,22656.0 +new-environment-ungrouped,IxVM::check_field_universes_skip_params,608,64,13,6,0,0,2,832,27264.0 +new-environment-ungrouped,IxVM::check_field_universes_inner,609,64,13,6,0,0,2,832,27264.0 +new-environment-ungrouped,IxVM::level_leq,610,16,14,6,0,0,2,224,4800.0 +new-environment-ungrouped,IxVM::nl_le,611,16,18,6,0,0,2,288,5568.0 +new-environment-ungrouped,IxVM::nl_covers_const,612,2,20,8,0,0,2,40,216.0 +new-environment-ungrouped,IxVM::nlvars_any_offset_geq,613,0,13,10,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::nl_le_vars,614,16,14,10,0,0,1,224,5056.0 +new-environment-ungrouped,IxVM::nl_covers_var,615,16,19,8,0,0,2,304,6144.0 +new-environment-ungrouped,IxVM::nlvars_dominates,616,8,15,10,0,0,2,120,2184.0 +new-environment-ungrouped,IxVM::check_positivity,617,64,10,10,0,0,1,640,25600.0 +new-environment-ungrouped,IxVM::peel_n_foralls_with_types,618,128,15,4,0,0,2,1920,63360.0 +new-environment-ungrouped,IxVM::check_positivity_fields,619,128,12,6,0,0,2,1536,60672.0 +new-environment-ungrouped,IxVM::check_positivity_aug,620,64,44,20,0,0,2,2816,79104.0 +new-environment-ungrouped,IxVM::check_valid_ind_app,621,4,21,16,0,0,1,84,952.0 +new-environment-ungrouped,IxVM::assert_occ_param_bvars,622,8,15,4,0,0,2,120,1752.0 +new-environment-ungrouped,"${""name"":""IxVM::list_reverse"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",623,32,5,6,0,0,1,160,6368.0 +new-environment-ungrouped,"${""name"":""IxVM::list_reverse_acc"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",624,64,10,8,0,0,1,640,23296.0 +new-environment-ungrouped,IxVM::check_nested_ctors_positivity,625,0,29,10,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::check_block_peer_param_agreement,626,32,69,4,0,0,2,2208,37344.0 +new-environment-ungrouped,IxVM::peer_agree_walk,627,64,82,24,0,0,2,5248,127488.0 +new-environment-ungrouped,IxVM::check_recursor_member,628,16,37,14,0,0,2,592,10752.0 +new-environment-ungrouped,IxVM::is_muts_block,629,32,53,2,0,0,2,1696,28704.0 +new-environment-ungrouped,"${""name"":""IxVM::list_length"",""types"":[{""named"":{""args"":[],""name"":""IxVM::KRecRule""}}]}",630,32,10,6,0,0,2,320,9984.0 +new-environment-ungrouped,IxVM::check_rec_rules_wellscoped,631,32,11,8,0,0,1,352,10208.0 +new-environment-ungrouped,IxVM::check_rec_major_spine,632,16,15,10,0,0,1,240,5248.0 +new-environment-ungrouped,IxVM::compute_k_target,633,16,42,8,0,0,2,672,10560.0 +new-environment-ungrouped,IxVM::ind_is_solo,634,16,58,4,0,0,2,928,12864.0 +new-environment-ungrouped,IxVM::muts_indc_count_is_one,635,16,56,6,0,0,2,896,12864.0 +new-environment-ungrouped,IxVM::check_parent_inductive_shape,636,16,16,2,0,0,2,256,4416.0 +new-environment-ungrouped,IxVM::check_recursor_canonical_full,637,16,83,46,0,0,2,1328,25728.0 +new-environment-ungrouped,IxVM::is_large_eliminator,638,8,32,4,0,0,2,256,2976.0 +new-environment-ungrouped,IxVM::check_large_prop_ctor,639,4,15,6,0,0,2,60,648.0 +new-environment-ungrouped,IxVM::check_large_walk_fields,640,4,22,10,0,0,2,88,912.0 +new-environment-ungrouped,IxVM::all_bvars_in_args,641,1,12,4,0,0,2,12,60.0 +new-environment-ungrouped,IxVM::args_contain_bvar,642,0,16,8,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::build_rec_lvls_list,643,8,9,8,0,0,2,72,1608.0 +new-environment-ungrouped,IxVM::build_flat_block,644,16,128,26,0,0,2,2048,30528.0 +new-environment-ungrouped,IxVM::first_recr_parent_block,645,0,88,10,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::flat_originals_walk,646,32,77,20,0,0,2,2464,48864.0 +new-environment-ungrouped,IxVM::build_param_lvls_range,647,4,10,8,0,0,2,40,576.0 +new-environment-ungrouped,IxVM::detect_aux_from_recrs_ex,648,0,57,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::aux_from_recrs_walk_ex,649,0,105,32,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::extract_aux_spec_params_from_rec,650,0,18,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::extract_aux_spec_params,651,0,16,12,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::spec_params_lower,652,0,12,12,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::extract_aux_occ_us,653,0,30,12,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::aux_already_in,654,0,19,10,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::spec_params_ptr_eq,655,0,17,6,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::kexpr_struct_eq,656,0,42,22,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::level_list_struct_eq,657,0,17,6,0,0,2,0,0.0 +new-environment-ungrouped,"${""name"":""IxVM::list_snoc"",""types"":[{""tuple"":{""items"":[{""ptr"":{""target"":{""array"":{""element"":""field"",""length"":32}}}},""field"",{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}],""name"":""Lists::Node""}}}},{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KLevelNode""}}}}],""name"":""Lists::Node""}}}}]}}]}",658,0,16,10,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::build_peer_recs,659,32,15,6,0,0,2,480,12384.0 +new-environment-ungrouped,IxVM::find_peer_recursor_with_spec,660,16,58,4,0,0,2,928,12864.0 +new-environment-ungrouped,IxVM::find_peer_rec_spec_walk,661,0,100,24,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::build_flat_own_params,662,16,28,12,0,0,2,448,8640.0 +new-environment-ungrouped,IxVM::flat_find_pos_kind,663,16,27,6,0,0,2,432,7296.0 +new-environment-ungrouped,IxVM::canonical_rules_at_pos,664,16,32,22,0,0,1,512,10816.0 +new-environment-ungrouped,IxVM::flat_member_at,665,16,19,6,0,0,2,304,5760.0 +new-environment-ungrouped,IxVM::build_rec_type,666,16,31,10,0,0,2,496,8832.0 +new-environment-ungrouped,IxVM::build_rec_type_from,667,16,55,28,0,0,2,880,16896.0 +new-environment-ungrouped,"${""name"":""IxVM::list_length"",""types"":[{""tuple"":{""items"":[{""ptr"":{""target"":{""array"":{""element"":""field"",""length"":32}}}},""field"",{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}],""name"":""Lists::Node""}}}},{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KLevelNode""}}}}],""name"":""Lists::Node""}}}}]}}]}",668,16,11,6,0,0,2,176,4224.0 +new-environment-ungrouped,IxVM::collect_n_doms_whnf,669,32,22,16,0,0,2,704,20544.0 +new-environment-ungrouped,IxVM::build_all_motives,670,16,6,4,0,0,1,96,2368.0 +new-environment-ungrouped,IxVM::build_all_motives_walk,671,32,31,18,0,0,2,992,25824.0 +new-environment-ungrouped,IxVM::build_motive_type_flat,672,16,22,12,0,0,2,352,7488.0 +new-environment-ungrouped,IxVM::peel_motive_params_subst,673,32,17,6,0,0,2,544,13344.0 +new-environment-ungrouped,IxVM::subst_param_for,674,4,13,6,0,0,2,52,600.0 +new-environment-ungrouped,IxVM::collect_index_doms,675,16,21,16,0,0,2,336,8064.0 +new-environment-ungrouped,IxVM::build_major_params,676,32,11,4,0,0,2,352,9504.0 +new-environment-ungrouped,IxVM::apply_spec_params_lifted,677,0,12,10,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::build_major_indices,678,64,10,4,0,0,2,640,21504.0 +new-environment-ungrouped,IxVM::wrap_foralls,679,256,10,8,0,0,1,2560,123904.0 +new-environment-ungrouped,IxVM::build_all_minors,680,16,8,4,0,0,1,128,2752.0 +new-environment-ungrouped,IxVM::build_all_minors_walk,681,32,35,10,0,0,2,1120,23904.0 +new-environment-ungrouped,IxVM::build_minor_doms,682,32,36,14,0,0,2,1152,26304.0 +new-environment-ungrouped,IxVM::projection_addr_ctor,683,32,27,18,0,0,1,864,22688.0 +new-environment-ungrouped,IxVM::build_minor_at_depth,684,32,39,42,0,0,1,1248,39968.0 +new-environment-ungrouped,IxVM::peel_ctor_params_subst,685,128,26,12,0,0,2,3328,114432.0 +new-environment-ungrouped,IxVM::ctor_subst_param_for,686,16,14,12,0,0,2,224,5952.0 +new-environment-ungrouped,IxVM::walk_fields_classify,687,128,24,20,0,0,2,3072,130560.0 +new-environment-ungrouped,IxVM::is_rec_field,688,32,7,4,0,0,1,224,6368.0 +new-environment-ungrouped,IxVM::is_rec_field_peel,689,64,23,8,0,0,2,1472,41088.0 +new-environment-ungrouped,IxVM::flat_find_matching,690,32,23,6,0,0,2,736,16224.0 +new-environment-ungrouped,IxVM::spec_params_dom_prefix_match,691,0,18,6,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::list_lift_each,692,16,12,6,0,0,2,192,4416.0 +new-environment-ungrouped,IxVM::build_ctor_app_params,693,32,11,4,0,0,2,352,9504.0 +new-environment-ungrouped,IxVM::build_apply_bvars_decreasing,694,128,11,4,0,0,2,1408,52608.0 +new-environment-ungrouped,IxVM::build_apply_field_bvars,695,64,11,4,0,0,2,704,22656.0 +new-environment-ungrouped,IxVM::build_ih_doms,696,32,34,40,0,0,2,1088,37824.0 +new-environment-ungrouped,"${""name"":""IxVM::list_lookup_or_default"",""types"":[""field""]}",697,8,10,6,0,0,2,80,1536.0 +new-environment-ungrouped,IxVM::peel_leading_foralls,698,8,7,8,0,0,1,56,1256.0 +new-environment-ungrouped,IxVM::peel_leading_foralls_acc,699,8,12,4,0,0,2,96,1536.0 +new-environment-ungrouped,IxVM::list_lift_indices,700,16,12,6,0,0,2,192,4416.0 +new-environment-ungrouped,IxVM::apply_indices_in_conclusion,701,16,10,4,0,0,2,160,3648.0 +new-environment-ungrouped,IxVM::ctors_before_pos,702,16,31,10,0,0,2,496,8832.0 +new-environment-ungrouped,IxVM::populate_rules,703,32,36,12,0,0,2,1152,25344.0 +new-environment-ungrouped,IxVM::build_rule_rhs,704,32,29,24,0,0,1,928,26528.0 +new-environment-ungrouped,IxVM::count_foralls_body,705,32,11,4,0,0,2,352,9504.0 +new-environment-ungrouped,IxVM::apply_ihs_full,706,32,44,52,0,0,1,1408,47168.0 +new-environment-ungrouped,IxVM::wrap_lams,707,4,10,8,0,0,1,40,496.0 +new-environment-ungrouped,IxVM::compare_rules,708,32,41,22,0,0,1,1312,31328.0 +new-environment-ungrouped,IxVM::peel_n_lams_collect,709,128,17,4,0,0,2,2176,68736.0 +new-environment-ungrouped,IxVM::flat_find_pos,710,0,17,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::run_check_transitive,711,0,62,14,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::check_muts_all,712,64,54,8,0,0,1,3456,73984.0 +new-environment-ungrouped,IxVM::check_muts_member_at,713,32,64,10,0,0,1,2048,36608.0 +new-environment-ungrouped,IxVM::walk_refs_transitive,714,0,12,6,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::g_list_has,715,16384,11,4,0,0,2,180224,13271040.0 +new-environment-ungrouped,IxVM::const_idxs_of,716,512,62,22,0,0,2,31744,1222656.0 +new-environment-ungrouped,IxVM::const_idxs_exprs,717,2048,10,12,0,0,1,20480,1630208.0 +new-environment-ungrouped,IxVM::const_idxs_expr,718,8192,34,24,0,0,2,278528,19906560.0 +new-environment-ungrouped,IxVM::const_idxs_rules,719,32,18,12,0,0,1,576,15488.0 +new-environment-ungrouped,IxVM::const_idxs_muts,720,32,58,32,0,0,2,1856,45504.0 +new-environment-ungrouped,IxVM::const_idxs_ctors,721,64,43,12,0,0,1,2752,65920.0 +new-environment-ungrouped,IxVM::addr_set_build,722,0,25,8,0,0,1,0,0.0 +new-environment-ungrouped,"${""name"":""IxVM::rbtree_map_insert"",""types"":[""field""]}",723,0,16,4,0,0,1,0,0.0 +new-environment-ungrouped,"${""name"":""IxVM::rbtree_map_ins"",""types"":[""field""]}",724,0,45,22,0,0,2,0,0.0 +new-environment-ungrouped,"${""name"":""IxVM::rbtree_map_balance"",""types"":[""field""]}",725,0,27,4,0,0,2,0,0.0 +new-environment-ungrouped,"${""name"":""IxVM::rbtree_map_balance_fix"",""types"":[""field""]}",726,0,301,16,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::load_assumption_tree,727,1,45,14,0,0,1,45,183.0 +new-environment-ungrouped,IxVM::parse_atree_body,728,1024,15,22,0,0,2,15360,1271808.0 +new-environment-ungrouped,IxVM::leaf_hash,729,512,7,10,0,0,1,3584,264704.0 +new-environment-ungrouped,IxVM::node_hash,730,512,9,12,0,0,1,4608,320000.0 +new-environment-ungrouped,IxVM::addr_set_member,731,0,10,4,0,0,1,0,0.0 +new-environment-ungrouped,"${""name"":""IxVM::rbtree_map_lookup_or_default"",""types"":[""field""]}",732,0,34,8,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::env_walk,733,0,80,18,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::env_walk_refs,734,0,25,6,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::eval_body,735,0,19,8,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::eval_output,736,0,58,14,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::eval_nf,737,0,15,16,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::eval_nf_spine,738,0,13,12,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::run_check_env,739,1,20,14,0,0,2,20,114.0 +new-environment-ungrouped,IxVM::walk_leaves_owned,740,512,39,10,0,0,1,19968,707072.0 +new-environment-ungrouped,IxVM::check_owned,741,512,35,6,0,0,1,17920,596480.0 +new-environment-ungrouped,IxVM::env_walk_all,742,512,89,16,0,0,2,45568,1512960.0 +new-environment-ungrouped,IxVM::env_walk_refs_all,743,4096,43,6,0,0,2,176128,7864320.0 +new-environment-ungrouped,IxVM::env_walk_leaves,744,0,19,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::get_reveal_info,745,0,101,62,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::get_opt_def_kind_masked,746,0,10,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::get_opt_u64_masked,747,0,15,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::get_opt_addr_masked,748,0,8,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::get_opt_bool_masked,749,0,8,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::get_opt_rule_list_masked,750,0,17,6,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::get_reveal_rule_list_inner,751,0,43,12,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::get_opt_quot_kind_masked,752,0,11,4,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::get_mut_entry_list_inner,753,0,88,12,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::get_mut_entry,754,0,67,6,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::get_reveal_mut_const_info,755,0,94,48,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::get_opt_ctor_entry_list_masked,756,0,17,6,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::get_ctor_entry_list_inner,757,0,74,12,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::get_ctor_entry,758,0,53,6,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::get_reveal_ctor_info,759,0,66,18,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::run_reveal,760,0,113,42,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::check_opt_def_kind,761,0,8,6,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::def_kind_tag,762,0,5,2,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::check_opt_u64,763,0,21,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::check_opt_expr_addr,764,0,8,6,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::expr_addr,765,0,24,10,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::check_opt_bool,766,0,6,2,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::check_opt_recr_rules,767,0,6,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::check_recr_rules,768,0,53,16,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::check_opt_quot_kind,769,0,8,6,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::check_opt_addr,770,0,7,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::check_muts_components,771,0,114,10,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::check_mut_const,772,0,103,40,0,0,2,0,0.0 +new-environment-ungrouped,IxVM::check_opt_ctor_entries,773,0,6,4,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::check_ctor_entries,774,0,55,8,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::check_ctor_entry,775,0,85,16,0,0,1,0,0.0 +new-environment-ungrouped,"${""name"":""IxVM::list_lookup_u64"",""types"":[{""named"":{""args"":[],""name"":""IxVM::Constructor""}}]}",776,0,90,10,0,0,1,0,0.0 +new-environment-ungrouped,IxVM::run_contains,777,0,6,6,0,0,1,0,0.0 +new-environment-ungrouped,,778,256,2,4,11,256,1,512,50176.0 +new-environment-ungrouped,,779,65536,7,8,14,65536,2,458752,60555264.0 +new-environment-ungrouped,,780,1024,1,2,3,1024,1,1024,157696.0 +new-environment-ungrouped,,781,8,5,6,0,0,1,40,968.0 +new-environment-ungrouped,,782,524288,6,6,0,0,1,3145728,420478976.0 +new-environment-ungrouped,,783,32768,7,6,0,0,1,229376,22249472.0 +new-environment-ungrouped,,784,128,8,6,0,0,1,1024,43520.0 +new-environment-ungrouped,,785,16,9,6,0,0,1,144,3328.0 +new-environment-ungrouped,,786,2,11,6,0,0,1,22,122.0 +new-environment-ungrouped,,787,32,12,6,0,0,1,384,9728.0 +new-environment-ungrouped,,788,64,13,6,0,0,1,832,24448.0 +new-environment-ungrouped,,789,32,14,6,0,0,1,448,10688.0 +new-environment-ungrouped,,790,512,15,6,0,0,1,7680,320000.0 +new-environment-ungrouped,,791,8192,21,6,0,0,1,172032,9297920.0 +new-environment-ungrouped,,792,0,22,6,0,0,1,0,0.0 +new-environment-ungrouped,,793,4096,35,6,0,0,1,143360,6356992.0 +new-environment-ungrouped,,794,2048,37,6,0,0,1,75776,3049472.0 +new-environment-ungrouped,,795,64,39,6,0,0,1,2496,54400.0 +new-environment-ungrouped,,796,32,50,6,0,0,1,1600,27968.0 +new-environment-ungrouped,,797,0,53,6,0,0,1,0,0.0 +new-environment-ungrouped,,798,0,67,6,0,0,1,0,0.0 +new-ixvm-grouped,IxVM::verify_claim,0,1,10,4,0,0,1,10,48.0 +new-ixvm-grouped,ixvm_group_07,1,8,203,50,0,0,2,1624,18600.0 +new-ixvm-grouped,IxVM::read_finite_byte_stream,2,16,7,6,0,0,1,112,2944.0 +new-ixvm-grouped,IxVM::read_byte_stream,3,4096,11,8,0,0,2,45056,3440640.0 +new-ixvm-grouped,"${""name"":""IxVM::list_depth_checked"",""types"":[""field""]}",4,4096,9,8,0,0,1,36864,2818048.0 +new-ixvm-grouped,IxVM::checked_depth_succ,5,1024,4,4,0,0,1,4096,311296.0 +new-ixvm-grouped,ixvm_group_00,6,2048,34,14,0,0,2,69632,3538944.0 +new-ixvm-grouped,ixvm_group_08,7,128,238,28,0,0,2,30464,727296.0 +new-ixvm-grouped,Blake3::compress,8,512,501,226,0,0,2,256512,10111488.0 +new-ixvm-grouped,Blake3::compress_chunks,9,4096,17,6,0,0,2,69632,4030464.0 +new-ixvm-grouped,UInt64::is_zero,10,32,19,2,0,0,2,608,12384.0 +new-ixvm-grouped,Blake3::bytes_to_block,11,64,131,130,0,0,1,8384,303232.0 +new-ixvm-grouped,Blake3::pad_block,12,2048,8,4,0,0,2,16384,1105920.0 +new-ixvm-grouped,Blake3::compress_block,13,32,180,48,0,0,2,5760,111744.0 +new-ixvm-grouped,"${""name"":""Lists::is_empty"",""types"":[""field""]}",14,32,7,4,0,0,1,224,6368.0 +new-ixvm-grouped,ixvm_group_02,15,0,56,6,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::get_tagn4,16,512,23,10,0,0,2,11776,517632.0 +new-ixvm-grouped,IxVM::get_tagn_tail,17,32,22,12,0,0,1,704,17408.0 +new-ixvm-grouped,IxVM::get_tagn_wide,18,0,28,10,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::get_u64_le,19,0,17,6,0,0,2,0,0.0 +new-ixvm-grouped,ixvm_group_03,20,4,64,60,0,0,2,256,3120.0 +new-ixvm-grouped,ixvm_group_24,21,128,22,8,0,0,2,2816,92928.0 +new-ixvm-grouped,IxVM::get_address,22,64,68,68,0,0,1,4352,159232.0 +new-ixvm-grouped,ixvm_group_23,23,4,44,10,0,0,2,176,1440.0 +new-ixvm-grouped,IxVM::run_eval,24,0,22,24,0,0,1,0,0.0 +new-ixvm-grouped,ixvm_group_34,25,16,45,14,0,0,2,720,12288.0 +new-ixvm-grouped,ixvm_group_01,26,32,132,34,0,0,2,4224,81984.0 +new-ixvm-grouped,ixvm_group_33,27,32,102,12,0,0,2,3264,57024.0 +new-ixvm-grouped,ixvm_group_05,28,32,115,16,0,0,2,3680,65184.0 +new-ixvm-grouped,ixvm_group_06,29,32,93,16,0,0,2,2976,54624.0 +new-ixvm-grouped,ixvm_group_31,30,32,38,16,0,0,2,1216,28224.0 +new-ixvm-grouped,ixvm_group_30,31,32,42,6,0,0,2,1344,25344.0 +new-ixvm-grouped,IxVM::get_tagn0,32,256,17,8,0,0,1,4352,166912.0 +new-ixvm-grouped,IxVM::get_expr,33,512,48,24,0,0,2,24576,1056768.0 +new-ixvm-grouped,IxVM::get_u64_list,34,128,33,12,0,0,2,4224,133248.0 +new-ixvm-grouped,ixvm_group_04,35,64,29,4,0,0,2,1856,43392.0 +new-ixvm-grouped,IxVM::get_app_telescope,36,256,27,12,0,0,1,6912,252928.0 +new-ixvm-grouped,ixvm_group_26,37,128,52,16,0,0,2,6656,195072.0 +new-ixvm-grouped,IxVM::get_lam_mode,38,32,16,8,0,0,1,512,12608.0 +new-ixvm-grouped,IxVM::binder_contract_from_bits,39,1,15,4,0,0,1,15,63.0 +new-ixvm-grouped,IxVM::value_contract_from_bits,40,1,8,2,0,0,1,8,36.0 +new-ixvm-grouped,IxVM::get_all_mode,41,32,18,10,0,0,1,576,14528.0 +new-ixvm-grouped,ixvm_group_19,42,4,113,32,0,0,2,452,3624.0 +new-ixvm-grouped,ixvm_group_35,43,16,83,18,0,0,2,1328,20352.0 +new-ixvm-grouped,ixvm_group_32,44,0,103,22,0,0,2,0,0.0 +new-ixvm-grouped,ixvm_group_25,45,32,49,18,0,0,2,1568,34464.0 +new-ixvm-grouped,IxVM::get_expr_list,46,64,26,12,0,0,2,1664,49152.0 +new-ixvm-grouped,IxVM::get_address_list,47,64,26,12,0,0,2,1664,49152.0 +new-ixvm-grouped,ixvm_group_28,48,32,64,20,0,0,2,2048,42624.0 +new-ixvm-grouped,ixvm_group_27,49,32,100,24,0,0,2,3200,61824.0 +new-ixvm-grouped,IxVM::load_constant_hint,50,8,36,4,0,0,1,288,3056.0 +new-ixvm-grouped,ixvm_group_11,51,32,83,14,0,0,2,2656,48864.0 +new-ixvm-grouped,IxVM::convert_expr,52,512,41,38,0,0,2,20992,1153536.0 +new-ixvm-grouped,"${""name"":""IxVM::list_lookup"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Univ""}}}}]}",53,128,7,6,0,0,1,896,40832.0 +new-ixvm-grouped,"${""name"":""IxVM::list_drop"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Univ""}}}}]}",54,256,9,6,0,0,2,2304,119808.0 +new-ixvm-grouped,ixvm_group_64,55,16,43,16,0,0,2,688,12288.0 +new-ixvm-grouped,ixvm_group_55,56,8,44,20,0,0,2,352,4992.0 +new-ixvm-grouped,ixvm_group_56,57,1,72,50,0,0,2,72,378.0 +new-ixvm-grouped,ixvm_group_14,58,8,36,8,0,0,2,288,3552.0 +new-ixvm-grouped,ixvm_group_36,59,4,82,22,0,0,2,328,2640.0 +new-ixvm-grouped,ixvm_group_39,60,4,39,8,0,0,2,156,1272.0 +new-ixvm-grouped,ixvm_group_59,61,0,194,62,0,0,2,0,0.0 +new-ixvm-grouped,ixvm_group_12,62,64,99,18,0,0,2,6336,140160.0 +new-ixvm-grouped,ixvm_group_47,63,16,57,14,0,0,2,912,14592.0 +new-ixvm-grouped,ixvm_group_20,64,4,65,20,0,0,2,260,2184.0 +new-ixvm-grouped,ixvm_group_22,65,8,90,22,0,0,2,720,8448.0 +new-ixvm-grouped,"${""name"":""IxVM::list_length_u64"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Expr""}}}}]}",66,4,23,8,0,0,1,92,808.0 +new-ixvm-grouped,IxVM::put_tagn_tail,67,0,30,18,0,0,1,0,0.0 +new-ixvm-grouped,IxVM::put_tagn_wide,68,0,30,12,0,0,2,0,0.0 +new-ixvm-grouped,ixvm_group_10,69,8,53,14,0,0,2,424,5208.0 +new-ixvm-grouped,ixvm_group_09,70,16,164,62,0,0,2,2624,44352.0 +new-ixvm-grouped,ixvm_group_18,71,0,93,26,0,0,2,0,0.0 +new-ixvm-grouped,ixvm_group_13,72,0,69,12,0,0,2,0,0.0 +new-ixvm-grouped,ixvm_group_16,73,64,122,24,0,0,2,7808,173568.0 +new-ixvm-grouped,IxVM::put_lam_mode,74,0,9,8,0,0,1,0,0.0 +new-ixvm-grouped,IxVM::binder_contract_code,75,0,10,4,0,0,1,0,0.0 +new-ixvm-grouped,IxVM::value_contract_code,76,0,8,2,0,0,1,0,0.0 +new-ixvm-grouped,ixvm_group_15,77,512,51,12,0,0,2,26112,932352.0 +new-ixvm-grouped,ixvm_group_17,78,32,112,140,0,0,2,3584,123264.0 +new-ixvm-grouped,ixvm_group_21,79,32,197,74,0,0,2,6304,132384.0 +new-ixvm-grouped,IxVM::validate_expr_well_scoped,80,64,32,24,0,0,2,2048,69888.0 +new-ixvm-grouped,ixvm_group_48,81,4,45,24,0,0,2,180,1800.0 +new-ixvm-grouped,ixvm_group_79,82,16,23,2,0,0,2,368,5760.0 +new-ixvm-grouped,"${""name"":""IxVM::list_length"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KLevelNode""}}}}]}",83,64,8,6,0,0,2,512,21504.0 +new-ixvm-grouped,IxVM::k_ensure_sort,84,8,9,8,0,0,1,72,1400.0 +new-ixvm-grouped,IxVM::k_infer,85,32,8,6,0,0,2,256,9024.0 +new-ixvm-grouped,IxVM::expr_lbr,86,128,19,18,0,0,2,2432,111744.0 +new-ixvm-grouped,IxVM::k_infer_core,87,32,33,46,0,0,2,1056,40224.0 +new-ixvm-grouped,IxVM::types_lookup,88,1,6,6,0,0,1,6,42.0 +new-ixvm-grouped,IxVM::expr_lift,89,16,11,4,0,0,2,176,3840.0 +new-ixvm-grouped,IxVM::expr_lift_walk,90,1,20,14,0,0,2,20,114.0 +new-ixvm-grouped,ixvm_group_61,91,0,52,26,0,0,2,0,0.0 +new-ixvm-grouped,ixvm_group_38,92,4,40,22,0,0,2,160,1632.0 +new-ixvm-grouped,ixvm_group_70,93,16,20,8,0,0,2,320,6336.0 +new-ixvm-grouped,ixvm_group_57,94,1,16,8,0,0,2,16,84.0 +new-ixvm-grouped,ixvm_group_65,95,32,29,16,0,0,2,928,23904.0 +new-ixvm-grouped,IxVM::expr_inst_levels,96,64,10,4,0,0,2,640,21504.0 +new-ixvm-grouped,IxVM::expr_inst_levels_walk,97,64,20,16,0,0,2,1280,46848.0 +new-ixvm-grouped,ixvm_group_71,98,32,19,12,0,0,2,608,17184.0 +new-ixvm-grouped,IxVM::collect_spine,99,64,11,10,0,0,2,704,29568.0 +new-ixvm-grouped,"${""name"":""IxVM::list_snoc"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",100,64,10,10,0,0,2,640,28416.0 +new-ixvm-grouped,IxVM::k_infer_app_spine_loop,101,32,30,34,0,0,2,960,33024.0 +new-ixvm-grouped,IxVM::expr_inst_many,102,64,15,8,0,0,2,960,31872.0 +new-ixvm-grouped,IxVM::has_bvar_in_range,103,64,21,16,0,0,2,1344,48000.0 +new-ixvm-grouped,ixvm_group_72,104,4,12,6,0,0,2,48,576.0 +new-ixvm-grouped,IxVM::expr_inst_many_walk,105,64,20,14,0,0,2,1280,44544.0 +new-ixvm-grouped,IxVM::expr_inst_many_bvar,106,32,10,12,0,0,1,320,11648.0 +new-ixvm-grouped,ixvm_group_68,107,4,52,34,0,0,2,208,2208.0 +new-ixvm-grouped,IxVM::expr_lower,108,32,11,4,0,0,2,352,9504.0 +new-ixvm-grouped,IxVM::expr_lower_walk,109,16,22,14,0,0,2,352,7872.0 +new-ixvm-grouped,IxVM::k_check,110,16,7,6,0,0,1,112,2944.0 +new-ixvm-grouped,IxVM::k_is_def_eq,111,32,11,8,0,0,2,352,11424.0 +new-ixvm-grouped,ixvm_group_81,112,32,25,14,0,0,2,800,21024.0 +new-ixvm-grouped,ixvm_group_75,113,32,11,6,0,0,2,352,10464.0 +new-ixvm-grouped,IxVM::try_def_eq_app,114,32,32,12,0,0,2,1024,23424.0 +new-ixvm-grouped,IxVM::de_args,115,32,18,6,0,0,2,576,13824.0 +new-ixvm-grouped,IxVM::address_eq,116,64,71,4,0,0,2,4544,91776.0 +new-ixvm-grouped,ixvm_group_67,117,8,53,14,0,0,2,424,5208.0 +new-ixvm-grouped,ixvm_group_51,118,8,37,14,0,0,2,296,4056.0 +new-ixvm-grouped,ixvm_group_53,119,2,61,36,0,0,2,122,630.0 +new-ixvm-grouped,ixvm_group_49,120,0,83,66,0,0,2,0,0.0 +new-ixvm-grouped,ixvm_group_66,121,8,85,48,0,0,2,680,9960.0 +new-ixvm-grouped,ixvm_group_50,122,256,68,26,0,0,2,17408,605184.0 +new-ixvm-grouped,IxVM::try_string_lit_one,123,16,14,6,0,0,2,224,4800.0 +new-ixvm-grouped,IxVM::whnf_nd,124,4,22,6,0,0,2,88,816.0 +new-ixvm-grouped,IxVM::whnf_nd_with_spine,125,8,20,12,0,0,2,160,2688.0 +new-ixvm-grouped,"${""name"":""IxVM::list_concat"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",126,64,10,8,0,0,1,640,23296.0 +new-ixvm-grouped,IxVM::whnf_nd_apply_beta,127,1,16,10,0,0,2,16,90.0 +new-ixvm-grouped,IxVM::peel_beta,128,4,18,6,0,0,2,72,720.0 +new-ixvm-grouped,IxVM::apply_spine,129,8,10,8,0,0,1,80,1472.0 +new-ixvm-grouped,IxVM::expr_inst1,130,16,12,6,0,0,2,192,4416.0 +new-ixvm-grouped,IxVM::expr_has_bvar_at,131,32,23,12,0,0,2,736,19104.0 +new-ixvm-grouped,IxVM::expr_inst1_walk,132,8,20,14,0,0,2,160,2832.0 +new-ixvm-grouped,IxVM::whnf_nd_const_head,133,1,57,46,0,0,2,57,321.0 +new-ixvm-grouped,ixvm_group_77,134,1,95,76,0,0,2,95,525.0 +new-ixvm-grouped,ixvm_group_43,135,16,18,4,0,0,2,288,5184.0 +new-ixvm-grouped,ixvm_group_46,136,16,18,4,0,0,2,288,5184.0 +new-ixvm-grouped,ixvm_group_45,137,16,18,4,0,0,2,288,5184.0 +new-ixvm-grouped,IxVM::try_prim_dispatch,138,1,22,10,0,0,2,22,108.0 +new-ixvm-grouped,IxVM::whnf,139,8,22,6,0,0,2,176,2400.0 +new-ixvm-grouped,IxVM::whnf_with_spine,140,4,20,12,0,0,2,80,912.0 +new-ixvm-grouped,IxVM::whnf_apply_beta,141,1,16,10,0,0,2,16,90.0 +new-ixvm-grouped,IxVM::whnf_const_head,142,0,51,42,0,0,2,0,0.0 +new-ixvm-grouped,ixvm_group_74,143,8,21,16,0,0,2,168,3048.0 +new-ixvm-grouped,ixvm_group_41,144,0,64,16,0,0,2,0,0.0 +new-ixvm-grouped,ixvm_group_42,145,0,79,90,0,0,2,0,0.0 +new-ixvm-grouped,ixvm_group_52,146,0,84,38,0,0,2,0,0.0 +new-ixvm-grouped,ixvm_group_63,147,0,89,52,0,0,2,0,0.0 +new-ixvm-grouped,"${""name"":""IxVM::list_take"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",148,2,10,8,0,0,2,20,156.0 +new-ixvm-grouped,ixvm_group_40,149,0,53,28,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::klimbs_add,150,0,5,4,0,0,1,0,0.0 +new-ixvm-grouped,IxVM::klimbs_add_carry,151,0,50,18,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::klimbs_normalize,152,0,30,14,0,0,2,0,0.0 +new-ixvm-grouped,ixvm_group_37,153,0,80,30,0,0,2,0,0.0 +new-ixvm-grouped,ixvm_group_80,154,4,72,78,0,0,2,288,3744.0 +new-ixvm-grouped,ixvm_group_69,155,0,24,12,0,0,2,0,0.0 +new-ixvm-grouped,ixvm_group_73,156,2,27,18,0,0,2,54,318.0 +new-ixvm-grouped,ixvm_group_76,157,0,41,26,0,0,2,0,0.0 +new-ixvm-grouped,ixvm_group_54,158,0,9,4,0,0,2,0,0.0 +new-ixvm-grouped,ixvm_group_58,159,16,69,22,0,0,2,1104,18432.0 +new-ixvm-grouped,IxVM::split_u32,160,0,11,10,0,0,1,0,0.0 +new-ixvm-grouped,IxVM::divmod_256,161,0,8,6,0,0,1,0,0.0 +new-ixvm-grouped,ixvm_group_44,162,0,18,4,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::klimbs_mul_outer,163,0,21,12,0,0,1,0,0.0 +new-ixvm-grouped,IxVM::klimbs_mul_single,164,0,68,20,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::klimbs_shl_limbs,165,0,8,4,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::ordinary_div_mod,166,0,11,6,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::divide_grow,167,0,16,18,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::utf8_groups,168,0,9,8,0,0,1,0,0.0 +new-ixvm-grouped,IxVM::divmod_64u,169,0,9,4,0,0,2,0,0.0 +new-ixvm-grouped,ixvm_group_60,170,0,71,24,0,0,2,0,0.0 +new-ixvm-grouped,ixvm_group_62,171,0,59,20,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::whnf_struct_core,172,16,22,6,0,0,2,352,6336.0 +new-ixvm-grouped,IxVM::whnf_struct_core_spine,173,8,25,36,0,0,2,200,4776.0 +new-ixvm-grouped,ixvm_group_78,174,1,33,14,0,0,2,33,153.0 +new-ixvm-grouped,IxVM::is_nat_zero,175,2,13,6,0,0,2,26,162.0 +new-ixvm-grouped,IxVM::nat_offset_of,176,2,36,30,0,0,2,72,444.0 +new-ixvm-grouped,IxVM::lazy_delta_loop,177,2,24,8,0,0,2,48,240.0 +new-ixvm-grouped,IxVM::head_addr,178,2,12,8,0,0,2,24,168.0 +new-ixvm-grouped,ixvm_group_82,179,2,34,10,0,0,2,68,312.0 +new-ixvm-grouped,IxVM::k_is_def_eq_struct_bounded,180,1,43,24,0,0,2,43,213.0 +new-ixvm-grouped,IxVM::k_def_eq_rebase,181,16,18,14,0,0,2,288,7104.0 +new-ixvm-grouped,IxVM::expr_glb,182,64,9,4,0,0,2,576,20352.0 +new-ixvm-grouped,IxVM::expr_glb_walk,183,64,22,18,0,0,2,1408,51456.0 +new-ixvm-grouped,IxVM::expr_glb_binder,184,8,10,4,0,0,2,80,1392.0 +new-ixvm-grouped,IxVM::k_infer_let_start,185,0,11,14,0,0,1,0,0.0 +new-ixvm-grouped,IxVM::k_infer_let_env,186,0,20,20,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::infer_let_local_cutoff,187,0,13,6,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::k_infer_let_env_core,188,0,27,52,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::infer_let_lookup_type,189,0,16,8,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::infer_let_materialize,190,0,28,24,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::infer_let_lookup_value,191,0,16,10,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::k_infer_let_env_rebase,192,0,14,14,0,0,1,0,0.0 +new-ixvm-grouped,IxVM::infer_let_drop_unused,193,0,16,6,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::k_infer_rebase,194,16,15,12,0,0,2,240,6144.0 +new-ixvm-grouped,IxVM::safe_refs_only,195,64,30,18,0,0,2,1920,60672.0 +new-ixvm-grouped,"${""name"":""IxVM::list_concat"",""types"":[{""tuple"":{""items"":[{""ptr"":{""target"":{""array"":{""element"":""field"",""length"":32}}}},""field""]}}]}",196,0,11,8,0,0,1,0,0.0 +new-ixvm-grouped,IxVM::canon_cmp_kexpr_node_ctx,197,0,61,50,0,0,2,0,0.0 +new-ixvm-grouped,"${""name"":""IxVM::list_snoc"",""types"":[{""tuple"":{""items"":[{""ptr"":{""target"":{""array"":{""element"":""field"",""length"":32}}}},""field"",{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}],""name"":""Lists::Node""}}}},{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KLevelNode""}}}}],""name"":""Lists::Node""}}}}]}}]}",198,0,16,10,0,0,2,0,0.0 +new-ixvm-grouped,"${""name"":""IxVM::list_length"",""types"":[{""tuple"":{""items"":[{""ptr"":{""target"":{""array"":{""element"":""field"",""length"":32}}}},""field"",{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}],""name"":""Lists::Node""}}}},{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KLevelNode""}}}}],""name"":""Lists::Node""}}}}]}}]}",199,0,11,6,0,0,2,0,0.0 +new-ixvm-grouped,"${""name"":""IxVM::list_lookup_or_default"",""types"":[""field""]}",200,0,10,6,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::walk_refs_transitive,201,0,12,6,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::g_list_has,202,32,11,4,0,0,2,352,9504.0 +new-ixvm-grouped,IxVM::const_idxs_exprs,203,8,10,12,0,0,1,80,1760.0 +new-ixvm-grouped,IxVM::const_idxs_expr,204,64,34,24,0,0,2,2176,72192.0 +new-ixvm-grouped,"${""name"":""IxVM::rbtree_map_balance_fix"",""types"":[""field""]}",205,16,301,16,0,0,2,4816,61824.0 +new-ixvm-grouped,IxVM::eval_body,206,0,19,8,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::eval_output,207,0,58,14,0,0,1,0,0.0 +new-ixvm-grouped,IxVM::eval_nf,208,0,15,16,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::eval_nf_spine,209,0,13,12,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::walk_leaves_owned,210,0,39,10,0,0,1,0,0.0 +new-ixvm-grouped,IxVM::check_owned,211,0,35,6,0,0,1,0,0.0 +new-ixvm-grouped,IxVM::env_walk_all,212,0,89,16,0,0,2,0,0.0 +new-ixvm-grouped,IxVM::env_walk_refs_all,213,0,43,6,0,0,2,0,0.0 +new-ixvm-grouped,,214,256,2,4,11,256,1,512,50176.0 +new-ixvm-grouped,,215,65536,7,8,14,65536,2,458752,60555264.0 +new-ixvm-grouped,,216,1024,1,2,3,1024,1,1024,157696.0 +new-ixvm-grouped,,217,0,5,6,0,0,1,0,0.0 +new-ixvm-grouped,,218,8192,6,6,0,0,1,49152,4505600.0 +new-ixvm-grouped,,219,512,7,6,0,0,1,3584,209408.0 +new-ixvm-grouped,,220,0,8,6,0,0,1,0,0.0 +new-ixvm-grouped,,221,32,9,6,0,0,1,288,8288.0 +new-ixvm-grouped,,222,1,11,6,0,0,1,11,57.0 +new-ixvm-grouped,,223,16,12,6,0,0,1,192,3904.0 +new-ixvm-grouped,,224,16,13,6,0,0,1,208,4096.0 +new-ixvm-grouped,,225,0,14,6,0,0,1,0,0.0 +new-ixvm-grouped,,226,16,15,6,0,0,1,240,4480.0 +new-ixvm-grouped,,227,512,21,6,0,0,1,10752,402944.0 +new-ixvm-grouped,,228,0,22,6,0,0,1,0,0.0 +new-ixvm-grouped,,229,128,35,6,0,0,1,4480,116096.0 +new-ixvm-grouped,,230,32,37,6,0,0,1,1184,21728.0 +new-ixvm-grouped,,231,4,39,6,0,0,1,156,1144.0 +new-ixvm-grouped,,232,4,50,6,0,0,1,200,1408.0 +new-ixvm-grouped,,233,0,53,6,0,0,1,0,0.0 +new-ixvm-grouped,,234,0,67,6,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::verify_claim,0,1,10,4,0,0,1,10,48.0 +new-ixvm-ungrouped,IxVM::run_claim,1,1,128,50,0,0,2,128,546.0 +new-ixvm-ungrouped,IxVM::read_finite_byte_stream,2,16,7,6,0,0,1,112,2944.0 +new-ixvm-ungrouped,IxVM::read_byte_stream,3,4096,11,8,0,0,2,45056,3440640.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_depth_checked"",""types"":[""field""]}",4,4096,9,8,0,0,1,36864,2818048.0 +new-ixvm-ungrouped,IxVM::checked_depth_succ,5,1024,4,4,0,0,1,4096,311296.0 +new-ixvm-ungrouped,UInt32::less_than_fields,6,2048,14,14,0,0,1,28672,2035712.0 +new-ixvm-ungrouped,Blake3::compress_layer,7,32,140,12,0,0,2,4480,75264.0 +new-ixvm-ungrouped,Blake3::next_layer,8,0,177,20,0,0,2,0,0.0 +new-ixvm-ungrouped,Blake3::compress,9,512,501,226,0,0,2,256512,10111488.0 +new-ixvm-ungrouped,Blake3::compress_chunks,10,4096,17,6,0,0,2,69632,4030464.0 +new-ixvm-ungrouped,Blake3::finish,11,32,166,28,0,0,2,5312,95424.0 +new-ixvm-ungrouped,UInt64::is_zero,12,32,19,2,0,0,2,608,12384.0 +new-ixvm-ungrouped,Blake3::bytes_to_block,13,64,131,130,0,0,1,8384,303232.0 +new-ixvm-ungrouped,Blake3::pad_block,14,2048,8,4,0,0,2,16384,1105920.0 +new-ixvm-ungrouped,Blake3::compress_block,15,32,180,48,0,0,2,5760,111744.0 +new-ixvm-ungrouped,"${""name"":""Lists::is_empty"",""types"":[""field""]}",16,32,7,4,0,0,1,224,6368.0 +new-ixvm-ungrouped,UInt64::wrapping_succ,17,0,20,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::get_tagn4,18,512,23,10,0,0,2,11776,517632.0 +new-ixvm-ungrouped,IxVM::get_tagn_tail,19,32,22,12,0,0,1,704,17408.0 +new-ixvm-ungrouped,IxVM::get_tagn_wide,20,0,28,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::get_u64_le,21,0,17,6,0,0,2,0,0.0 +new-ixvm-ungrouped,UInt64::add,22,0,26,18,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::read_byte,23,128,5,4,0,0,1,640,30080.0 +new-ixvm-ungrouped,IxVM::get_address,24,64,68,68,0,0,1,4352,159232.0 +new-ixvm-ungrouped,IxVM::get_opt_addr,25,1,8,6,0,0,2,8,54.0 +new-ixvm-ungrouped,IxVM::run_eval,26,0,22,24,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::run_check,27,1,16,8,0,0,1,16,78.0 +new-ixvm-ungrouped,IxVM::get_ci,28,16,77,34,0,0,2,1232,22272.0 +new-ixvm-ungrouped,IxVM::load_verified_constant,29,16,89,12,0,0,1,1424,19840.0 +new-ixvm-ungrouped,Blake3::verify_bytes_against,30,16,72,14,0,0,1,1152,16960.0 +new-ixvm-ungrouped,IxVM::get_constant,31,16,95,20,0,0,1,1520,22528.0 +new-ixvm-ungrouped,IxVM::get_mut_const_list,32,4,70,12,0,0,2,280,2112.0 +new-ixvm-ungrouped,IxVM::get_mut_const,33,2,52,10,0,0,2,104,420.0 +new-ixvm-ungrouped,IxVM::get_definition,34,8,20,12,0,0,1,160,2480.0 +new-ixvm-ungrouped,IxVM::unpack_def_kind_safety,35,2,11,2,0,0,1,22,98.0 +new-ixvm-ungrouped,IxVM::get_tagn0,36,256,17,8,0,0,1,4352,166912.0 +new-ixvm-ungrouped,IxVM::get_expr,37,512,48,24,0,0,2,24576,1056768.0 +new-ixvm-ungrouped,IxVM::get_u64_list,38,128,33,12,0,0,2,4224,133248.0 +new-ixvm-ungrouped,UInt64::saturating_pred,39,32,20,4,0,0,2,640,13824.0 +new-ixvm-ungrouped,IxVM::get_app_telescope,40,256,27,12,0,0,1,6912,252928.0 +new-ixvm-ungrouped,IxVM::get_lam_telescope,41,64,34,16,0,0,2,2176,62976.0 +new-ixvm-ungrouped,IxVM::get_lam_mode,42,32,16,8,0,0,1,512,12608.0 +new-ixvm-ungrouped,IxVM::binder_contract_from_bits,43,1,15,4,0,0,1,15,63.0 +new-ixvm-ungrouped,IxVM::value_contract_from_bits,44,1,8,2,0,0,1,8,36.0 +new-ixvm-ungrouped,IxVM::get_all_telescope,45,64,34,16,0,0,2,2176,62976.0 +new-ixvm-ungrouped,IxVM::get_all_mode,46,32,18,10,0,0,1,576,14528.0 +new-ixvm-ungrouped,IxVM::get_expr_let,47,1,34,16,0,0,1,34,156.0 +new-ixvm-ungrouped,IxVM::get_inductive,48,2,53,20,0,0,1,106,458.0 +new-ixvm-ungrouped,IxVM::assert_wire_bool,49,1,5,4,0,0,1,5,33.0 +new-ixvm-ungrouped,IxVM::get_constructor_list,50,8,59,12,0,0,2,472,5496.0 +new-ixvm-ungrouped,IxVM::get_constructor,51,4,43,16,0,0,1,172,1480.0 +new-ixvm-ungrouped,IxVM::get_recursor,52,0,73,24,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::get_recursor_rule_list,53,0,35,14,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::get_constant_info_by_variant,54,16,56,18,0,0,2,896,15168.0 +new-ixvm-ungrouped,IxVM::get_axiom,55,0,16,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::get_quotient,56,0,17,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::get_quot_kind,57,0,6,2,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::get_constructor_proj,58,0,23,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::get_recursor_proj,59,2,14,6,0,0,1,28,140.0 +new-ixvm-ungrouped,IxVM::get_expr_list,60,64,26,12,0,0,2,1664,49152.0 +new-ixvm-ungrouped,IxVM::get_address_list,61,64,26,12,0,0,2,1664,49152.0 +new-ixvm-ungrouped,IxVM::get_univ_list,62,16,35,14,0,0,2,560,10368.0 +new-ixvm-ungrouped,IxVM::get_univ,63,32,39,18,0,0,2,1248,29664.0 +new-ixvm-ungrouped,IxVM::get_tagn2,64,32,23,10,0,0,2,736,18144.0 +new-ixvm-ungrouped,IxVM::build_succ_chain,65,16,39,10,0,0,2,624,10368.0 +new-ixvm-ungrouped,IxVM::load_constant_hint,66,8,36,4,0,0,1,288,3056.0 +new-ixvm-ungrouped,IxVM::defn_is_unsafe_ci,67,2,9,2,0,0,2,18,114.0 +new-ixvm-ungrouped,IxVM::convert_definition,68,8,27,8,0,0,2,216,2904.0 +new-ixvm-ungrouped,IxVM::convert_expr,69,512,41,38,0,0,2,20992,1153536.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_lookup"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Univ""}}}}]}",70,128,7,6,0,0,1,896,40832.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_drop"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Univ""}}}}]}",71,256,9,6,0,0,2,2304,119808.0 +new-ixvm-ungrouped,UInt64::to_field,72,32,10,2,0,0,1,320,6848.0 +new-ixvm-ungrouped,IxVM::convert_univ,73,16,19,12,0,0,2,304,6912.0 +new-ixvm-ungrouped,IxVM::convert_univ_idxs,74,32,20,8,0,0,2,640,15744.0 +new-ixvm-ungrouped,IxVM::load_verified_blob,75,2,38,8,0,0,1,76,296.0 +new-ixvm-ungrouped,IxVM::utf8_validate,76,0,9,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::utf8_decode_one,77,0,31,32,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::utf8_cont,78,0,7,6,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::bytes_to_limbs,79,2,33,20,0,0,2,66,366.0 +new-ixvm-ungrouped,IxVM::bytes_to_u64_limb,80,4,40,6,0,0,2,160,1248.0 +new-ixvm-ungrouped,IxVM::skip_bytes,81,4,11,4,0,0,2,44,504.0 +new-ixvm-ungrouped,IxVM::convert_axiom,82,0,18,6,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::convert_quotient,83,0,18,6,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::get_ci_dprj,84,0,120,14,0,0,1,0,0.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_lookup_u64"",""types"":[{""named"":{""args"":[],""name"":""IxVM::MutConst""}}]}",85,0,112,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::defn_member_recur_addrs,86,0,20,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::build_recur_addrs,87,2,5,4,0,0,1,10,74.0 +new-ixvm-ungrouped,IxVM::build_recur_addrs_walk,88,4,57,6,0,0,2,228,1656.0 +new-ixvm-ungrouped,IxVM::projection_addr,89,2,111,18,0,0,1,222,794.0 +new-ixvm-ungrouped,IxVM::muts_member_at,90,2,97,4,0,0,2,194,654.0 +new-ixvm-ungrouped,UInt64::from_field,91,1,12,12,0,0,1,12,78.0 +new-ixvm-ungrouped,IxVM::put_constant,92,2,72,18,0,0,2,144,588.0 +new-ixvm-ungrouped,IxVM::put_sharing,93,1,14,8,0,0,1,14,72.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_length_u64"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::Expr""}}}}]}",94,4,23,8,0,0,1,92,808.0 +new-ixvm-ungrouped,IxVM::put_tagn0,95,8,16,8,0,0,2,128,2112.0 +new-ixvm-ungrouped,IxVM::put_tagn_tail,96,0,30,18,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::put_tagn_wide,97,0,30,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::put_u64_le,98,0,16,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::put_expr_list,99,1,29,6,0,0,2,29,117.0 +new-ixvm-ungrouped,IxVM::put_expr,100,0,104,62,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::put_tagn4,101,2,18,10,0,0,2,36,216.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_length_u64"",""types"":[{""array"":{""element"":""field"",""length"":8}}]}",102,0,30,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::put_u64_list,103,0,17,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::app_telescope_count,104,0,55,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::put_app_telescope,105,0,60,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::lam_telescope_count,106,0,55,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::put_lam_telescope,107,0,61,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::put_lam_mode,108,0,9,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::binder_contract_code,109,0,10,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::value_contract_code,110,0,8,2,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::all_telescope_count,111,0,55,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::put_all_telescope,112,0,61,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::put_all_mode,113,0,12,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::put_refs,114,1,14,8,0,0,1,14,72.0 +new-ixvm-ungrouped,IxVM::put_address_list,115,1,10,8,0,0,1,10,60.0 +new-ixvm-ungrouped,IxVM::put_address,116,32,68,68,0,0,1,2176,66368.0 +new-ixvm-ungrouped,IxVM::put_univs,117,1,14,8,0,0,1,14,72.0 +new-ixvm-ungrouped,IxVM::put_univ_list,118,1,20,6,0,0,2,20,90.0 +new-ixvm-ungrouped,IxVM::put_univ,119,0,40,26,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::univ_succ_count,120,0,37,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::univ_succ_base,121,0,30,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::put_tagn2,122,0,18,10,0,0,2,0,0.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_length_u64"",""types"":[{""named"":{""args"":[],""name"":""IxVM::MutConst""}}]}",123,0,67,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::put_mut_const_list,124,0,54,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::put_mut_const,125,0,52,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::put_definition,126,0,57,18,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::pack_def_kind_safety,127,0,12,2,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::put_inductive,128,0,64,22,0,0,1,0,0.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_length_u64"",""types"":[{""named"":{""args"":[],""name"":""IxVM::Constructor""}}]}",129,0,56,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::put_constructor_list,130,0,43,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::put_constructor,131,0,62,18,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::put_recursor,132,0,83,26,0,0,1,0,0.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_length_u64"",""types"":[{""named"":{""args"":[],""name"":""IxVM::RecursorRule""}}]}",133,0,31,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::put_recursor_rule_list,134,0,18,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::put_recursor_rule,135,0,32,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::put_constant_info,136,2,56,18,0,0,1,112,464.0 +new-ixvm-ungrouped,IxVM::put_axiom,137,0,35,12,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::put_quotient,138,0,34,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::put_quot_kind,139,0,8,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::put_constructor_proj,140,0,23,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::put_recursor_proj,141,2,14,6,0,0,1,28,140.0 +new-ixvm-ungrouped,Blake3::bytes_to_addr,142,32,41,16,0,0,1,1312,28448.0 +new-ixvm-ungrouped,IxVM::get_ci_iprj,143,2,111,12,0,0,1,222,758.0 +new-ixvm-ungrouped,IxVM::convert_inductive,144,2,40,12,0,0,1,80,332.0 +new-ixvm-ungrouped,IxVM::count_ctors,145,4,41,6,0,0,2,164,1272.0 +new-ixvm-ungrouped,IxVM::get_ci_cprj,146,0,146,14,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::ctor_at,147,0,75,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::convert_constructor,148,0,47,12,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::get_ci_rprj,149,0,111,12,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::convert_recursor,150,0,59,16,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::convert_rec_rules,151,0,24,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_const,152,1,42,60,0,0,2,42,318.0 +new-ixvm-ungrouped,IxVM::is_unsafe_ci,153,8,23,2,0,0,2,184,2184.0 +new-ixvm-ungrouped,IxVM::validate_expr_well_scoped,154,64,32,24,0,0,2,2048,69888.0 +new-ixvm-ungrouped,IxVM::validate_univ_params_seen,155,2,12,10,0,0,2,24,180.0 +new-ixvm-ungrouped,IxVM::const_num_lvls,156,8,21,2,0,0,2,168,2040.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_length"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KLevelNode""}}}}]}",157,64,8,6,0,0,2,512,21504.0 +new-ixvm-ungrouped,IxVM::validate_univ_params_list,158,8,8,8,0,0,1,64,1328.0 +new-ixvm-ungrouped,IxVM::k_ensure_sort,159,8,9,8,0,0,1,72,1400.0 +new-ixvm-ungrouped,IxVM::k_infer,160,32,8,6,0,0,2,256,9024.0 +new-ixvm-ungrouped,IxVM::expr_lbr,161,128,19,18,0,0,2,2432,111744.0 +new-ixvm-ungrouped,IxVM::lbr_max,162,16,6,4,0,0,2,96,2880.0 +new-ixvm-ungrouped,IxVM::lbr_dec,163,8,5,2,0,0,2,40,888.0 +new-ixvm-ungrouped,IxVM::expr_lbr_let,164,0,11,14,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::k_infer_core,165,32,33,46,0,0,2,1056,40224.0 +new-ixvm-ungrouped,IxVM::types_lookup,166,1,6,6,0,0,1,6,42.0 +new-ixvm-ungrouped,IxVM::expr_lift,167,16,11,4,0,0,2,176,3840.0 +new-ixvm-ungrouped,IxVM::expr_lift_walk,168,1,20,14,0,0,2,20,114.0 +new-ixvm-ungrouped,IxVM::expr_lift_bvar,169,1,8,4,0,0,2,8,48.0 +new-ixvm-ungrouped,IxVM::expr_lift_let,170,0,11,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::level_reduce,171,4,13,14,0,0,2,52,792.0 +new-ixvm-ungrouped,IxVM::level_max,172,0,13,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::level_explicit_val,173,0,12,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::level_max_go,174,0,21,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::level_struct_eq,175,4,23,12,0,0,2,92,984.0 +new-ixvm-ungrouped,IxVM::level_max_subsumes,176,0,11,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::level_max_offsets,177,0,13,12,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::level_offset_of,178,0,11,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::level_imax,179,1,21,16,0,0,2,21,123.0 +new-ixvm-ungrouped,IxVM::level_is_not_zero,180,0,16,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::const_type_of,181,8,21,2,0,0,2,168,2040.0 +new-ixvm-ungrouped,IxVM::expr_inst_levels,182,64,10,4,0,0,2,640,21504.0 +new-ixvm-ungrouped,IxVM::expr_inst_levels_walk,183,64,20,16,0,0,2,1280,46848.0 +new-ixvm-ungrouped,IxVM::level_inst_params,184,16,14,16,0,0,2,224,6720.0 +new-ixvm-ungrouped,IxVM::level_list_inst,185,16,11,6,0,0,2,176,4224.0 +new-ixvm-ungrouped,IxVM::collect_spine,186,64,11,10,0,0,2,704,29568.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_snoc"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",187,64,10,10,0,0,2,640,28416.0 +new-ixvm-ungrouped,IxVM::k_infer_app_spine_loop,188,32,30,34,0,0,2,960,33024.0 +new-ixvm-ungrouped,IxVM::expr_inst_many,189,64,15,8,0,0,2,960,31872.0 +new-ixvm-ungrouped,IxVM::has_bvar_in_range,190,64,21,16,0,0,2,1344,48000.0 +new-ixvm-ungrouped,IxVM::has_bvar_in_range_binder,191,2,9,6,0,0,1,18,110.0 +new-ixvm-ungrouped,IxVM::has_bvar_in_range_let,192,0,12,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::expr_inst_many_walk,193,64,20,14,0,0,2,1280,44544.0 +new-ixvm-ungrouped,IxVM::expr_inst_many_bvar,194,32,10,12,0,0,1,320,11648.0 +new-ixvm-ungrouped,IxVM::expr_inst_many_let,195,0,11,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::expr_lower,196,32,11,4,0,0,2,352,9504.0 +new-ixvm-ungrouped,IxVM::expr_lower_walk,197,16,22,14,0,0,2,352,7872.0 +new-ixvm-ungrouped,IxVM::k_check,198,16,7,6,0,0,1,112,2944.0 +new-ixvm-ungrouped,IxVM::k_is_def_eq,199,32,11,8,0,0,2,352,11424.0 +new-ixvm-ungrouped,IxVM::k_is_def_eq_core,200,32,6,4,0,0,1,192,5888.0 +new-ixvm-ungrouped,IxVM::k_is_def_eq_ordered,201,32,9,4,0,0,2,288,8544.0 +new-ixvm-ungrouped,IxVM::try_def_eq_app,202,32,32,12,0,0,2,1024,23424.0 +new-ixvm-ungrouped,IxVM::de_args,203,32,18,6,0,0,2,576,13824.0 +new-ixvm-ungrouped,IxVM::address_eq,204,64,71,4,0,0,2,4544,91776.0 +new-ixvm-ungrouped,IxVM::address_eq_tail,205,8,74,4,0,0,2,592,6000.0 +new-ixvm-ungrouped,IxVM::level_list_eq,206,8,17,6,0,0,2,136,2040.0 +new-ixvm-ungrouped,IxVM::level_equal,207,4,9,10,0,0,1,36,520.0 +new-ixvm-ungrouped,IxVM::nl_eq,208,1,27,20,0,0,2,27,153.0 +new-ixvm-ungrouped,IxVM::nl_skip_empty,209,4,16,6,0,0,2,64,672.0 +new-ixvm-ungrouped,IxVM::glist_cmp,210,1,18,12,0,0,2,18,102.0 +new-ixvm-ungrouped,IxVM::nlvars_eq,211,0,21,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::level_normalize,212,2,11,18,0,0,1,22,194.0 +new-ixvm-ungrouped,IxVM::normalize_aux,213,8,19,20,0,0,2,152,3192.0 +new-ixvm-ungrouped,IxVM::nl_add_const,214,2,12,6,0,0,2,24,156.0 +new-ixvm-ungrouped,IxVM::nl_add_const_go,215,1,20,20,0,0,2,20,132.0 +new-ixvm-ungrouped,IxVM::normalize_imax_dispatch,216,0,21,26,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::glist_ordered_insert,217,0,15,14,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::nl_add_var,218,0,21,24,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::nlvars_add,219,0,19,20,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::nl_subsumption_walk,220,4,11,10,0,0,1,44,568.0 +new-ixvm-ungrouped,IxVM::nl_subsume_entry,221,4,40,16,0,0,2,160,1488.0 +new-ixvm-ungrouped,IxVM::glist_subset,222,1,17,12,0,0,2,17,99.0 +new-ixvm-ungrouped,IxVM::glist_eq_len,223,1,14,8,0,0,2,14,78.0 +new-ixvm-ungrouped,IxVM::nlvars_max_offset,224,0,12,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::nlvars_subsume,225,0,24,14,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::k_is_def_eq_slow,226,16,12,4,0,0,2,192,4032.0 +new-ixvm-ungrouped,IxVM::try_string_lit_one,227,16,14,6,0,0,2,224,4800.0 +new-ixvm-ungrouped,IxVM::str_lit_delta_step,228,0,38,22,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::whnf_nd,229,4,22,6,0,0,2,88,816.0 +new-ixvm-ungrouped,IxVM::whnf_nd_with_spine,230,8,20,12,0,0,2,160,2688.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_concat"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",231,64,10,8,0,0,1,640,23296.0 +new-ixvm-ungrouped,IxVM::whnf_nd_apply_beta,232,1,16,10,0,0,2,16,90.0 +new-ixvm-ungrouped,IxVM::peel_beta,233,4,18,6,0,0,2,72,720.0 +new-ixvm-ungrouped,IxVM::apply_spine,234,8,10,8,0,0,1,80,1472.0 +new-ixvm-ungrouped,IxVM::expr_inst1,235,16,12,6,0,0,2,192,4416.0 +new-ixvm-ungrouped,IxVM::expr_has_bvar_at,236,32,23,12,0,0,2,736,19104.0 +new-ixvm-ungrouped,IxVM::expr_has_bvar_at_binder,237,1,9,4,0,0,2,9,51.0 +new-ixvm-ungrouped,IxVM::expr_has_bvar_at_let,238,0,13,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::expr_inst1_walk,239,8,20,14,0,0,2,160,2832.0 +new-ixvm-ungrouped,IxVM::expr_inst1_bvar,240,2,10,8,0,0,2,20,156.0 +new-ixvm-ungrouped,IxVM::expr_inst1_let,241,0,11,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::whnf_nd_const_head,242,1,57,46,0,0,2,57,321.0 +new-ixvm-ungrouped,IxVM::prim_family,243,1,85,38,0,0,2,85,381.0 +new-ixvm-ungrouped,IxVM::nat_succ_addr,244,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::nat_pred_addr,245,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::nat_add_addr,246,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::nat_sub_addr,247,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::nat_mul_addr,248,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::nat_div_addr,249,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::nat_mod_addr,250,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::nat_pow_addr,251,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::nat_gcd_addr,252,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::nat_beq_addr,253,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::nat_ble_addr,254,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::nat_land_addr,255,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::nat_lor_addr,256,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::nat_xor_addr,257,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::nat_shift_left_addr,258,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::nat_shift_right_addr,259,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::is_str_prim_addr,260,1,31,16,0,0,2,31,153.0 +new-ixvm-ungrouped,IxVM::string_utf8_byte_size_addr,261,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::string_append_addr,262,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::string_of_list_addr,263,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::string_back_addr,264,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::string_legacy_back_addr,265,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::string_to_byte_array_addr,266,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::string_dec_eq_addr,267,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::is_bitvec_prim_addr,268,1,15,8,0,0,2,15,81.0 +new-ixvm-ungrouped,IxVM::bit_vec_to_nat_addr,269,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::bit_vec_ult_addr,270,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::decidable_decide_addr,271,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::is_native_prim_addr,272,1,23,12,0,0,2,23,117.0 +new-ixvm-ungrouped,IxVM::system_platform_num_bits_addr,273,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::punit_size_of_1_addr,274,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::reduce_bool_addr,275,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::reduce_nat_addr,276,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::subtype_val_addr,277,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::is_dec_prim_addr,278,1,27,14,0,0,2,27,135.0 +new-ixvm-ungrouped,IxVM::nat_dec_le_addr_dec,279,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::nat_dec_eq_addr_dec,280,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::nat_dec_lt_addr_dec,281,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::int_dec_le_addr_dec,282,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::int_dec_eq_addr_dec,283,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::int_dec_lt_addr_dec,284,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::is_int_prim_addr,285,1,23,42,0,0,1,23,201.0 +new-ixvm-ungrouped,IxVM::int_add_addr,286,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::int_sub_addr,287,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::int_mul_addr,288,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::int_neg_addr,289,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::int_emod_addr,290,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::int_ediv_addr,291,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::int_bmod_addr,292,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::int_bdiv_addr,293,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::int_nat_abs_addr,294,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::int_pow_addr,295,1,3,4,0,0,1,3,27.0 +new-ixvm-ungrouped,IxVM::try_prim_dispatch,296,1,22,10,0,0,2,22,108.0 +new-ixvm-ungrouped,IxVM::try_nat_dispatch_prewhnf,297,0,30,48,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::whnf_spine,298,0,11,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::whnf,299,8,22,6,0,0,2,176,2400.0 +new-ixvm-ungrouped,IxVM::whnf_with_spine,300,4,20,12,0,0,2,80,912.0 +new-ixvm-ungrouped,IxVM::whnf_apply_beta,301,1,16,10,0,0,2,16,90.0 +new-ixvm-ungrouped,IxVM::whnf_const_head,302,0,51,42,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_reduce_projection_definition,303,1,18,16,0,0,2,18,114.0 +new-ixvm-ungrouped,IxVM::projection_definition_info,304,2,24,12,0,0,2,48,264.0 +new-ixvm-ungrouped,IxVM::try_quot_iota,305,0,16,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::quot_lift_addr_iota,306,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::try_quot_lift,307,0,16,18,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::quot_extract_arg,308,0,19,18,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::quot_ctor_addr_iota,309,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::quot_ind_addr_iota,310,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::try_quot_ind,311,0,16,18,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::se_parent_addr,312,0,22,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_k_synth_iota,313,0,31,26,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::k_synth_gate,314,0,39,14,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_cprj_addr,315,0,27,18,0,0,1,0,0.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_take"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",316,2,10,8,0,0,2,20,156.0 +new-ixvm-ungrouped,IxVM::try_iota,317,0,43,50,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_nat_linear_rec,318,0,28,28,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_extract_nat,319,0,18,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::nat_zero_addr,320,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::try_extract_nat_app,321,0,17,14,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_succ,322,0,27,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::is_nat_succ_ih_step,323,0,34,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::mk_nat_lit,324,0,4,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_add,325,0,5,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_add_carry,326,0,50,18,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::mk_nat_offset_stuck,327,0,15,20,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_is_zero,328,0,16,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_normalize,329,0,30,14,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::cleanup_nat_offset_major,330,0,25,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_match_nat_add,331,0,25,18,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::build_succ_offset,332,0,21,32,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_sub,333,0,8,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_sub_borrow,334,0,52,24,0,0,2,0,0.0 +new-ixvm-ungrouped,UInt64::sub_with_borrow,335,0,26,18,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::whnf_iota_major,336,0,29,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::nat_lit_to_ctor_or_self,337,0,19,22,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_dec,338,0,6,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::collect_spine_of_ctor,339,0,27,16,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::compute_iprj_addr,340,0,18,16,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::find_rule,341,0,15,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::replace_spine_major,342,0,11,14,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::rec_to_parent_addr,343,0,16,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::peel_n_foralls,344,0,11,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_struct_eta_iota,345,0,62,40,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::struct_is_rec,346,0,19,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::struct_block_member_addrs,347,0,56,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::struct_scan_ctors,348,0,29,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::se_peel_tol,349,0,13,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::se_scan_fields,350,0,13,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::se_mentions,351,0,26,14,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::se_addr_in,352,0,12,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::is_prop_type,353,1,13,6,0,0,2,13,69.0 +new-ixvm-ungrouped,IxVM::k_infer_only,354,2,58,78,0,0,2,116,864.0 +new-ixvm-ungrouped,IxVM::ensure_sort_only,355,0,16,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::nat_addr_io,356,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::str_addr_io,357,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::io_peel_params_subst,358,0,16,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::io_peel_field_loop,359,0,15,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::ctx_trim,360,4,13,8,0,0,2,52,648.0 +new-ixvm-ungrouped,IxVM::ctx_seek_cut,361,1,9,10,0,0,2,9,69.0 +new-ixvm-ungrouped,IxVM::ctx_next_cut,362,1,7,8,0,0,1,7,51.0 +new-ixvm-ungrouped,IxVM::ctx_close_cut,363,1,11,10,0,0,2,11,75.0 +new-ixvm-ungrouped,IxVM::lbr_min,364,16,6,4,0,0,2,96,2880.0 +new-ixvm-ungrouped,IxVM::apply_n_projs,365,0,12,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::whnf_proj_head,366,0,37,26,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::str_lit_to_ctor_app_or_self,367,0,12,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::str_lit_to_ctor,368,0,23,42,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::list_nil_addr,369,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::list_cons_addr,370,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::char_type_addr,371,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::char_of_nat_addr,372,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::build_char_list,373,0,18,18,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_from_g,374,0,14,18,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::split_u32,375,0,11,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::divmod_256,376,0,8,6,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::try_reduce_fin_val_decidable_rec,377,0,60,64,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::fin_addr,378,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::decidable_rec_addr,379,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::whnf_get_ctor_or_none,380,0,12,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_nat_binop_dispatch,381,0,24,24,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_nat_binop_addr,382,0,62,140,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_mul,383,0,6,6,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_mul_outer,384,0,21,12,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_mul_single,385,0,68,20,0,0,2,0,0.0 +new-ixvm-ungrouped,UInt64::mul,386,0,52,44,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_shl_limbs,387,0,8,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_div,388,0,6,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_div_mod,389,0,17,26,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::ordinary_div_mod,390,0,11,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::divide_grow,391,0,16,18,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_le,392,0,17,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_eq,393,0,30,6,0,0,2,0,0.0 +new-ixvm-ungrouped,UInt64::eq,394,0,27,2,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_mod,395,0,6,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_gcd,396,0,8,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_pow,397,0,17,22,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_land,398,0,36,12,0,0,2,0,0.0 +new-ixvm-ungrouped,UInt64::and,399,0,26,18,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_lor,400,0,36,12,0,0,1,0,0.0 +new-ixvm-ungrouped,UInt64::or,401,0,26,18,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_xor_op,402,0,36,12,0,0,1,0,0.0 +new-ixvm-ungrouped,UInt64::xor,403,0,26,18,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_shl,404,0,8,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_shr,405,0,8,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::mk_bool,406,0,8,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::bool_false_addr,407,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::bool_true_addr,408,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::try_nat_offset_dispatch,409,0,27,30,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::mk_nat_binop_stuck,410,0,12,14,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::try_str_dispatch,411,0,59,66,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::walk_char_list_bytes,412,0,32,32,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::char_lit_codepoint,413,0,11,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::char_lit_codepoint_syn,414,0,26,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::klimbs_scalar_value,415,0,39,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::utf8_encode_prepend,416,0,33,50,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::utf8_groups,417,0,9,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::divmod_64u,418,0,9,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_str_back,419,0,21,24,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::utf8_last_codepoint,420,0,4,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::utf8_last_go,421,0,11,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::try_str_to_byte_array,422,0,21,18,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::byte_array_empty_addr,423,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::try_str_dec_eq,424,0,28,20,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::bytestream_eq,425,0,16,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::str_dec_eq_build,426,0,38,60,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::eq_refl_addr_dec,427,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::decidable_is_true_addr_dec,428,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::try_bitvec_dispatch,429,0,23,36,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::bitvec_prep_spine,430,0,20,20,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::bv_to_nat_via,431,0,19,18,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::bitvec_of_nat_args_direct,432,0,18,20,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::bit_vec_of_nat_addr,433,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::bitvec_prep_spine_ult,434,0,22,20,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::np_whnf_inner_bv,435,0,8,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::try_reduce_bit_vec_ult,436,0,18,22,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_reduce_decide_bitvec_lt,437,0,48,52,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::lt_lt_addr,438,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::bit_vec_addr,439,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::try_native_dispatch,440,0,33,22,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::mk_nat_literal_64,441,0,5,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::mk_nat_one,442,0,5,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::try_reduce_subtype_val,443,0,20,20,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::system_platform_get_num_bits_addr,444,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::check_native_bool,445,0,14,14,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_native_nat,446,0,11,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_dec_dispatch,447,0,23,14,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::is_int_dec_prim_addr,448,0,15,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_normalize_int_decidable,449,0,23,18,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_extract_int,450,0,27,18,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::int_of_nat_addr_dec,451,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::int_neg_succ_addr_dec,452,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::normalize_int_dec_rebuild,453,0,25,24,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::intern_int_lit,454,0,11,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::dec_rewrite_lt_to_le,455,0,19,26,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::dec_dispatch_le_eq,456,0,23,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::dec_build_proof,457,0,43,52,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::bool_type_addr_dec,458,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::nat_le_of_ble_eq_true_addr_dec,459,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::nat_not_le_of_not_ble_eq_true_addr_dec,460,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::nat_eq_of_beq_eq_true_addr_dec,461,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::nat_ne_of_beq_eq_false_addr_dec,462,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::dec_finish,463,0,29,36,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::decidable_is_false_addr_dec,464,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::try_int_prim_dispatch,465,0,33,44,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_extract_int_prim,466,0,25,24,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::mk_int_prim,467,0,19,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_int_prim_second,468,0,43,90,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::int_bmod_prim,469,0,22,26,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::int_bdiv_prim,470,0,32,38,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::int_add_prim,471,0,13,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::int_emod_prim,472,0,14,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::int_ediv_prim,473,0,20,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::whnf_nd_proj_head,474,0,37,26,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::k_is_def_eq_slow_nd,475,16,14,6,0,0,2,224,4800.0 +new-ixvm-ungrouped,IxVM::whnf_struct_core,476,16,22,6,0,0,2,352,6336.0 +new-ixvm-ungrouped,IxVM::whnf_struct_core_spine,477,8,25,36,0,0,2,200,4776.0 +new-ixvm-ungrouped,IxVM::whnf_struct_core_proj,478,0,32,18,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::whnf_struct_core_const,479,1,27,14,0,0,2,27,135.0 +new-ixvm-ungrouped,IxVM::k_is_def_eq_struct_safe,480,16,27,14,0,0,2,432,8832.0 +new-ixvm-ungrouped,IxVM::k_is_def_eq_slow_nd_after_core,481,1,16,6,0,0,2,16,78.0 +new-ixvm-ungrouped,IxVM::k_is_def_eq_slow2,482,1,29,8,0,0,2,29,123.0 +new-ixvm-ungrouped,IxVM::try_proof_irrel,483,1,11,6,0,0,2,11,63.0 +new-ixvm-ungrouped,IxVM::try_unit_like,484,1,12,6,0,0,2,12,66.0 +new-ixvm-ungrouped,IxVM::is_unit_like_type,485,1,42,8,0,0,2,42,162.0 +new-ixvm-ungrouped,IxVM::try_eta_struct,486,2,61,14,0,0,2,122,498.0 +new-ixvm-ungrouped,IxVM::compare_struct_fields,487,0,17,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_def_eq_nat,488,2,23,14,0,0,2,46,270.0 +new-ixvm-ungrouped,IxVM::is_nat_zero,489,2,13,6,0,0,2,26,162.0 +new-ixvm-ungrouped,IxVM::nat_offset_of,490,2,36,30,0,0,2,72,444.0 +new-ixvm-ungrouped,IxVM::lazy_delta_loop,491,2,24,8,0,0,2,48,240.0 +new-ixvm-ungrouped,IxVM::head_addr,492,2,12,8,0,0,2,24,168.0 +new-ixvm-ungrouped,IxVM::lazy_delta_step_const_const,493,0,52,16,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::is_defn_or_thm,494,1,18,2,0,0,2,18,72.0 +new-ixvm-ungrouped,IxVM::unfold_b_and_loop,495,0,13,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::delta_unfold,496,1,27,14,0,0,2,27,135.0 +new-ixvm-ungrouped,IxVM::unfold_a_and_loop,497,0,13,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::delta_rank,498,0,16,2,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::unfold_both_and_loop,499,0,17,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::lazy_delta_a_const_b_proj,500,0,34,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_unfold_proj_app,501,1,24,18,0,0,2,24,138.0 +new-ixvm-ungrouped,IxVM::try_unfold_head,502,1,23,6,0,0,2,23,99.0 +new-ixvm-ungrouped,IxVM::lazy_delta_b_const_a_proj,503,1,34,8,0,0,2,34,138.0 +new-ixvm-ungrouped,IxVM::lazy_delta_both_proj,504,1,18,8,0,0,2,18,90.0 +new-ixvm-ungrouped,IxVM::slow2_after_delta,505,1,15,4,0,0,2,15,69.0 +new-ixvm-ungrouped,IxVM::k_is_def_eq_struct_bounded,506,1,43,24,0,0,2,43,213.0 +new-ixvm-ungrouped,IxVM::k_is_def_eq_struct_spend,507,0,21,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::literal_eq,508,0,11,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::k_is_def_eq_structure_tree,509,0,13,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_same_proj_head_app,510,0,32,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::k_is_def_eq_structure_tree_app,511,0,19,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::slow2_eager_fallback,512,0,27,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_eta_swap,513,0,19,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_eta_expand,514,0,21,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::k_is_def_eq_struct,515,0,6,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::k_is_def_eq_struct_go,516,0,43,34,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::try_lazy_delta_app,517,0,48,20,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::k_def_eq_rebase,518,16,18,14,0,0,2,288,7104.0 +new-ixvm-ungrouped,IxVM::expr_glb,519,64,9,4,0,0,2,576,20352.0 +new-ixvm-ungrouped,IxVM::expr_glb_walk,520,64,22,18,0,0,2,1408,51456.0 +new-ixvm-ungrouped,IxVM::expr_glb_binder,521,8,10,4,0,0,2,80,1392.0 +new-ixvm-ungrouped,IxVM::expr_glb_let,522,0,15,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::k_infer_let_start,523,0,11,14,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::k_infer_let_env,524,0,20,20,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::infer_let_local_cutoff,525,0,13,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::k_infer_let_env_core,526,0,27,52,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::infer_let_lookup_type,527,0,16,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::infer_let_materialize,528,0,28,24,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::infer_let_lookup_value,529,0,16,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::k_infer_let_env_rebase,530,0,14,14,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::infer_let_drop_unused,531,0,16,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::k_infer_lit,532,0,8,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::k_infer_proj,533,0,41,28,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::is_inductive_prop,534,0,13,12,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::peel_n_alls_whnf,535,0,15,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::peel_field_loop,536,0,17,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_prop_field_if_prop,537,0,10,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_no_dep_data_field_if_prop,538,0,14,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::k_infer_rebase,539,16,15,12,0,0,2,240,6144.0 +new-ixvm-ungrouped,IxVM::assert_safety,540,2,7,2,0,0,2,14,102.0 +new-ixvm-ungrouped,IxVM::safe_refs_only,541,64,30,18,0,0,2,1920,60672.0 +new-ixvm-ungrouped,IxVM::check_quot,542,0,13,22,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::quot_type_addr,543,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::check_eq_type,544,0,12,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::eq_type_addr,545,0,3,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::count_foralls_at_least,546,0,14,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_canonical_block,547,0,67,16,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_muts_has_kind,548,0,58,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_indc_positions,549,0,56,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_sort_loop,550,0,15,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_build_ctx_classes,551,0,15,12,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::canon_build_ctx_members,552,0,21,18,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_member_num_ctors,553,0,18,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_member_ci,554,0,18,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::canon_ctor_ctx_entries,555,0,12,8,0,0,2,0,0.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_concat"",""types"":[{""tuple"":{""items"":[{""ptr"":{""target"":{""array"":{""element"":""field"",""length"":32}}}},""field""]}}]}",556,0,11,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::canon_refine_classes,557,0,12,12,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::canon_refine_one,558,0,12,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_ins_sort,559,0,11,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::canon_insert_sorted,560,0,40,16,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_cmp_member_ctx,561,0,34,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_ord_cmp_g,562,256,8,2,0,0,2,2048,89088.0 +new-ixvm-ungrouped,IxVM::canon_kind_ord,563,0,21,2,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::canon_cmp_member_same_kind_ctx,564,0,70,74,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_sord_then,565,0,9,2,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_sord_of_g,566,0,3,2,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::canon_cmp_kexpr_ctx,567,0,15,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::canon_cmp_kexpr_node_ctx,568,0,61,50,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_sord_lt_strong,569,0,2,2,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::canon_sord_gt_strong,570,0,2,2,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::canon_cmp_kuniv,571,0,29,16,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_ord_then,572,8,6,2,0,0,2,48,960.0 +new-ixvm-ungrouped,IxVM::canon_cmp_kuniv_list,573,0,16,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_ctx_cmp_addr,574,0,18,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_sord_eq_strong,575,0,2,2,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::canon_ctx_class_idx,576,0,13,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_addr_cmp,577,32,83,36,0,0,1,2656,58208.0 +new-ixvm-ungrouped,IxVM::canon_addr_chunk,578,256,11,4,0,0,1,2816,105472.0 +new-ixvm-ungrouped,IxVM::canon_cmp_kliteral,579,0,10,6,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::canon_cmp_klimbs,580,0,12,8,0,0,2,0,0.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_length"",""types"":[{""array"":{""element"":""field"",""length"":8}}]}",581,0,15,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_cmp_klimbs_tail,582,0,28,12,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::canon_cmp_u64_lex,583,0,33,32,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::canon_cmp_bytes,584,0,16,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_cmp_ctor_range_ctx,585,0,43,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_cmp_ctor_pair_ctx,586,0,51,36,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_cmp_krec_rule_list_ctx,587,0,24,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_cmp_krec_rule_ctx,588,0,16,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::canon_group_consec,589,0,12,12,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::canon_group_walk,590,0,43,24,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_classes_eq,591,0,17,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_all_singleton,592,0,11,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canon_flatten,593,0,9,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::check_inductive_shape,594,0,12,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::get_result_sort_level,595,0,14,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_inductive_shape_ctors,596,0,30,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_param_agreement,597,0,6,6,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::check_param_agreement_go,598,0,18,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_ctor_return_type,599,0,20,24,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::assert_return_head_is_parent,600,0,17,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::assert_lvls_are_params,601,0,13,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::assert_first_args_are_param_bvars,602,0,15,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::list_any_mentions_block,603,0,12,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::expr_mentions_block,604,0,26,14,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::caddr_is_peer,605,0,20,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::addr_list_contains,606,0,12,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_field_universes,607,0,11,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_field_universes_skip_params,608,0,13,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_field_universes_inner,609,0,13,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::level_leq,610,0,14,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::nl_le,611,0,18,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::nl_covers_const,612,0,20,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::nlvars_any_offset_geq,613,0,13,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::nl_le_vars,614,0,14,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::nl_covers_var,615,0,19,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::nlvars_dominates,616,0,15,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_positivity,617,0,10,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::peel_n_foralls_with_types,618,0,15,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_positivity_fields,619,0,12,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_positivity_aug,620,0,44,20,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_valid_ind_app,621,0,21,16,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::assert_occ_param_bvars,622,0,15,4,0,0,2,0,0.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_reverse"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",623,0,5,6,0,0,1,0,0.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_reverse_acc"",""types"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}]}",624,0,10,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::check_nested_ctors_positivity,625,0,29,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_block_peer_param_agreement,626,0,69,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::peer_agree_walk,627,0,82,24,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_recursor_member,628,0,37,14,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::is_muts_block,629,0,53,2,0,0,2,0,0.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_length"",""types"":[{""named"":{""args"":[],""name"":""IxVM::KRecRule""}}]}",630,0,10,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_rec_rules_wellscoped,631,0,11,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::check_rec_major_spine,632,0,15,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::compute_k_target,633,0,42,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::ind_is_solo,634,0,58,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::muts_indc_count_is_one,635,0,56,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_parent_inductive_shape,636,0,16,2,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_recursor_canonical_full,637,0,83,46,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::is_large_eliminator,638,0,32,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_large_prop_ctor,639,0,15,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_large_walk_fields,640,0,22,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::all_bvars_in_args,641,0,12,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::args_contain_bvar,642,0,16,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::build_rec_lvls_list,643,0,9,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::build_flat_block,644,0,128,26,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::first_recr_parent_block,645,0,88,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::flat_originals_walk,646,0,77,20,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::build_param_lvls_range,647,0,10,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::detect_aux_from_recrs_ex,648,0,57,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::aux_from_recrs_walk_ex,649,0,105,32,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::extract_aux_spec_params_from_rec,650,0,18,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::extract_aux_spec_params,651,0,16,12,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::spec_params_lower,652,0,12,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::extract_aux_occ_us,653,0,30,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::aux_already_in,654,0,19,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::spec_params_ptr_eq,655,0,17,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::kexpr_struct_eq,656,0,42,22,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::level_list_struct_eq,657,0,17,6,0,0,2,0,0.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_snoc"",""types"":[{""tuple"":{""items"":[{""ptr"":{""target"":{""array"":{""element"":""field"",""length"":32}}}},""field"",{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}],""name"":""Lists::Node""}}}},{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KLevelNode""}}}}],""name"":""Lists::Node""}}}}]}}]}",658,0,16,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::build_peer_recs,659,0,15,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::find_peer_recursor_with_spec,660,0,58,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::find_peer_rec_spec_walk,661,0,100,24,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::build_flat_own_params,662,0,28,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::flat_find_pos_kind,663,0,27,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::canonical_rules_at_pos,664,0,32,22,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::flat_member_at,665,0,19,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::build_rec_type,666,0,31,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::build_rec_type_from,667,0,55,28,0,0,2,0,0.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_length"",""types"":[{""tuple"":{""items"":[{""ptr"":{""target"":{""array"":{""element"":""field"",""length"":32}}}},""field"",{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KExprNode""}}}}],""name"":""Lists::Node""}}}},{""ptr"":{""target"":{""named"":{""args"":[{""ptr"":{""target"":{""named"":{""args"":[],""name"":""IxVM::KLevelNode""}}}}],""name"":""Lists::Node""}}}}]}}]}",668,0,11,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::collect_n_doms_whnf,669,0,22,16,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::build_all_motives,670,0,6,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::build_all_motives_walk,671,0,31,18,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::build_motive_type_flat,672,0,22,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::peel_motive_params_subst,673,0,17,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::subst_param_for,674,0,13,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::collect_index_doms,675,0,21,16,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::build_major_params,676,0,11,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::apply_spec_params_lifted,677,0,12,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::build_major_indices,678,0,10,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::wrap_foralls,679,0,10,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::build_all_minors,680,0,8,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::build_all_minors_walk,681,0,35,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::build_minor_doms,682,0,36,14,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::projection_addr_ctor,683,0,27,18,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::build_minor_at_depth,684,0,39,42,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::peel_ctor_params_subst,685,0,26,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::ctor_subst_param_for,686,0,14,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::walk_fields_classify,687,0,24,20,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::is_rec_field,688,0,7,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::is_rec_field_peel,689,0,23,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::flat_find_matching,690,0,23,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::spec_params_dom_prefix_match,691,0,18,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::list_lift_each,692,0,12,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::build_ctor_app_params,693,0,11,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::build_apply_bvars_decreasing,694,0,11,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::build_apply_field_bvars,695,0,11,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::build_ih_doms,696,0,34,40,0,0,2,0,0.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_lookup_or_default"",""types"":[""field""]}",697,0,10,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::peel_leading_foralls,698,0,7,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::peel_leading_foralls_acc,699,0,12,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::list_lift_indices,700,0,12,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::apply_indices_in_conclusion,701,0,10,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::ctors_before_pos,702,0,31,10,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::populate_rules,703,0,36,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::build_rule_rhs,704,0,29,24,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::count_foralls_body,705,0,11,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::apply_ihs_full,706,0,44,52,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::wrap_lams,707,0,10,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::compare_rules,708,0,41,22,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::peel_n_lams_collect,709,0,17,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::flat_find_pos,710,0,17,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::run_check_transitive,711,0,62,14,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_muts_all,712,0,54,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::check_muts_member_at,713,0,64,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::walk_refs_transitive,714,0,12,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::g_list_has,715,32,11,4,0,0,2,352,9504.0 +new-ixvm-ungrouped,IxVM::const_idxs_of,716,1,62,22,0,0,2,62,264.0 +new-ixvm-ungrouped,IxVM::const_idxs_exprs,717,8,10,12,0,0,1,80,1760.0 +new-ixvm-ungrouped,IxVM::const_idxs_expr,718,64,34,24,0,0,2,2176,72192.0 +new-ixvm-ungrouped,IxVM::const_idxs_rules,719,0,18,12,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::const_idxs_muts,720,0,58,32,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::const_idxs_ctors,721,0,43,12,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::addr_set_build,722,16,25,8,0,0,1,400,6784.0 +new-ixvm-ungrouped,"${""name"":""IxVM::rbtree_map_insert"",""types"":[""field""]}",723,8,16,4,0,0,1,128,1616.0 +new-ixvm-ungrouped,"${""name"":""IxVM::rbtree_map_ins"",""types"":[""field""]}",724,32,45,22,0,0,2,1440,34464.0 +new-ixvm-ungrouped,"${""name"":""IxVM::rbtree_map_balance"",""types"":[""field""]}",725,16,27,4,0,0,2,432,6912.0 +new-ixvm-ungrouped,"${""name"":""IxVM::rbtree_map_balance_fix"",""types"":[""field""]}",726,16,301,16,0,0,2,4816,61824.0 +new-ixvm-ungrouped,IxVM::load_assumption_tree,727,2,45,14,0,0,1,90,374.0 +new-ixvm-ungrouped,IxVM::parse_atree_body,728,16,15,22,0,0,2,240,8064.0 +new-ixvm-ungrouped,IxVM::leaf_hash,729,8,7,10,0,0,1,56,1400.0 +new-ixvm-ungrouped,IxVM::node_hash,730,8,9,12,0,0,1,72,1688.0 +new-ixvm-ungrouped,IxVM::addr_set_member,731,16,10,4,0,0,1,160,3136.0 +new-ixvm-ungrouped,"${""name"":""IxVM::rbtree_map_lookup_or_default"",""types"":[""field""]}",732,32,34,8,0,0,2,1088,22464.0 +new-ixvm-ungrouped,IxVM::env_walk,733,8,80,18,0,0,2,640,7440.0 +new-ixvm-ungrouped,IxVM::env_walk_refs,734,8,25,6,0,0,2,200,2616.0 +new-ixvm-ungrouped,IxVM::eval_body,735,0,19,8,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::eval_output,736,0,58,14,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::eval_nf,737,0,15,16,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::eval_nf_spine,738,0,13,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::run_check_env,739,1,20,14,0,0,2,20,114.0 +new-ixvm-ungrouped,IxVM::walk_leaves_owned,740,0,39,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::check_owned,741,0,35,6,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::env_walk_all,742,0,89,16,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::env_walk_refs_all,743,0,43,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::env_walk_leaves,744,2,19,8,0,0,1,38,182.0 +new-ixvm-ungrouped,IxVM::get_reveal_info,745,0,101,62,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::get_opt_def_kind_masked,746,0,10,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::get_opt_u64_masked,747,0,15,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::get_opt_addr_masked,748,0,8,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::get_opt_bool_masked,749,0,8,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::get_opt_rule_list_masked,750,0,17,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::get_reveal_rule_list_inner,751,0,43,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::get_opt_quot_kind_masked,752,0,11,4,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::get_mut_entry_list_inner,753,0,88,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::get_mut_entry,754,0,67,6,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::get_reveal_mut_const_info,755,0,94,48,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::get_opt_ctor_entry_list_masked,756,0,17,6,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::get_ctor_entry_list_inner,757,0,74,12,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::get_ctor_entry,758,0,53,6,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::get_reveal_ctor_info,759,0,66,18,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::run_reveal,760,0,113,42,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_opt_def_kind,761,0,8,6,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::def_kind_tag,762,0,5,2,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::check_opt_u64,763,0,21,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::check_opt_expr_addr,764,0,8,6,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::expr_addr,765,0,24,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::check_opt_bool,766,0,6,2,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::check_opt_recr_rules,767,0,6,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::check_recr_rules,768,0,53,16,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_opt_quot_kind,769,0,8,6,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::check_opt_addr,770,0,7,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::check_muts_components,771,0,114,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::check_mut_const,772,0,103,40,0,0,2,0,0.0 +new-ixvm-ungrouped,IxVM::check_opt_ctor_entries,773,0,6,4,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::check_ctor_entries,774,0,55,8,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::check_ctor_entry,775,0,85,16,0,0,1,0,0.0 +new-ixvm-ungrouped,"${""name"":""IxVM::list_lookup_u64"",""types"":[{""named"":{""args"":[],""name"":""IxVM::Constructor""}}]}",776,0,90,10,0,0,1,0,0.0 +new-ixvm-ungrouped,IxVM::run_contains,777,0,6,6,0,0,1,0,0.0 +new-ixvm-ungrouped,,778,256,2,4,11,256,1,512,50176.0 +new-ixvm-ungrouped,,779,65536,7,8,14,65536,2,458752,60555264.0 +new-ixvm-ungrouped,,780,1024,1,2,3,1024,1,1024,157696.0 +new-ixvm-ungrouped,,781,0,5,6,0,0,1,0,0.0 +new-ixvm-ungrouped,,782,8192,6,6,0,0,1,49152,4505600.0 +new-ixvm-ungrouped,,783,512,7,6,0,0,1,3584,209408.0 +new-ixvm-ungrouped,,784,0,8,6,0,0,1,0,0.0 +new-ixvm-ungrouped,,785,32,9,6,0,0,1,288,8288.0 +new-ixvm-ungrouped,,786,1,11,6,0,0,1,11,57.0 +new-ixvm-ungrouped,,787,16,12,6,0,0,1,192,3904.0 +new-ixvm-ungrouped,,788,16,13,6,0,0,1,208,4096.0 +new-ixvm-ungrouped,,789,0,14,6,0,0,1,0,0.0 +new-ixvm-ungrouped,,790,16,15,6,0,0,1,240,4480.0 +new-ixvm-ungrouped,,791,512,21,6,0,0,1,10752,402944.0 +new-ixvm-ungrouped,,792,0,22,6,0,0,1,0,0.0 +new-ixvm-ungrouped,,793,128,35,6,0,0,1,4480,116096.0 +new-ixvm-ungrouped,,794,32,37,6,0,0,1,1184,21728.0 +new-ixvm-ungrouped,,795,4,39,6,0,0,1,156,1144.0 +new-ixvm-ungrouped,,796,4,50,6,0,0,1,200,1408.0 +new-ixvm-ungrouped,,797,0,53,6,0,0,1,0,0.0 +new-ixvm-ungrouped,,798,0,67,6,0,0,1,0,0.0 +new-recursion-grouped,MultiStark::verify_multi_stark_proof,0,1,219,96,0,0,1,219,951.0 +new-recursion-grouped,MultiStark::read_byte_stream,1,256,11,8,0,0,2,2816,144384.0 +new-recursion-grouped,verifier_group_03,2,64,206,42,0,0,2,13184,291072.0 +new-recursion-grouped,Blake3::compress,3,256,501,226,0,0,2,128256,4494336.0 +new-recursion-grouped,Blake3::compress_chunks,4,1024,17,6,0,0,2,17408,841728.0 +new-recursion-grouped,verifier_group_12,5,128,378,130,0,0,2,48384,1377792.0 +new-recursion-grouped,verifier_group_00,6,256,74,20,0,0,2,18944,605184.0 +new-recursion-grouped,verifier_group_08,7,512,34,8,0,0,2,17408,642048.0 +new-recursion-grouped,"${""name"":""Lists::is_empty"",""types"":[""field""]}",8,8,7,4,0,0,1,56,968.0 +new-recursion-grouped,MultiStark::read_vk_u8,9,128,5,4,0,0,1,640,30080.0 +new-recursion-grouped,verifier_group_02,10,128,52,12,0,0,2,6656,184320.0 +new-recursion-grouped,MultiStark::read_vk_tag,11,8,5,4,0,0,1,40,824.0 +new-recursion-grouped,MultiStark::read_vk_u16,12,32,7,6,0,0,1,224,7328.0 +new-recursion-grouped,MultiStark::read_nodes_n,13,8,44,36,0,0,2,352,6144.0 +new-recursion-grouped,verifier_group_11,14,128,15,8,0,0,2,1920,74112.0 +new-recursion-grouped,verifier_group_13,15,16,82,40,0,0,2,1312,24384.0 +new-recursion-grouped,verifier_group_10,16,128,89,18,0,0,2,11392,299904.0 +new-recursion-grouped,verifier_group_04,17,64,147,66,0,0,2,9408,250752.0 +new-recursion-grouped,verifier_group_05,18,256,16,6,0,0,2,4096,162816.0 +new-recursion-grouped,MultiStark::read_u64_at,19,512,19,18,0,0,1,9728,541184.0 +new-recursion-grouped,MultiStark::read_header_vec_n,20,2,23,20,0,0,2,46,306.0 +new-recursion-grouped,verifier_group_06,21,256,49,12,0,0,2,12544,402432.0 +new-recursion-grouped,MultiStark::read_u8_at,22,8,5,4,0,0,1,40,824.0 +new-recursion-grouped,MultiStark::read_u64_vec,23,64,7,6,0,0,1,448,17536.0 +new-recursion-grouped,MultiStark::read_u64_vec_n,24,256,18,8,0,0,2,4608,187392.0 +new-recursion-grouped,MultiStark::read_message_vec_n,25,1,20,10,0,0,2,20,102.0 +new-recursion-grouped,MultiStark::read_proof_vec_n,26,2,34,8,0,0,2,68,300.0 +new-recursion-grouped,MultiStark::read_proof,27,1,53,44,0,0,1,53,297.0 +new-recursion-grouped,verifier_group_09,28,32,28,10,0,0,2,896,20544.0 +new-recursion-grouped,MultiStark::verify_batch,29,1,40,12,0,0,2,40,168.0 +new-recursion-grouped,MultiStark::assert_shard_count_ok,30,1,16,6,0,0,2,16,78.0 +new-recursion-grouped,"${""name"":""MultiStark::list_length"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::Proof""}}]}",31,2,31,6,0,0,2,62,270.0 +new-recursion-grouped,MultiStark::assert_closure_pairs,32,1,159,34,0,0,2,159,591.0 +new-recursion-grouped,MultiStark::three_limbs,33,0,39,10,0,0,1,0,0.0 +new-recursion-grouped,MultiStark::bytes8_le,34,0,26,18,0,0,1,0,0.0 +new-recursion-grouped,MultiStark::le_step,35,0,11,2,0,0,2,0,0.0 +new-recursion-grouped,MultiStark::batch_fiat_shamir,36,1,73,68,0,0,1,73,429.0 +new-recursion-grouped,MultiStark::messages_onto,37,1,7,8,0,0,1,7,51.0 +new-recursion-grouped,MultiStark::count_onto,38,8,18,6,0,0,2,144,2112.0 +new-recursion-grouped,MultiStark::b8_onto,39,128,19,18,0,0,1,2432,105344.0 +new-recursion-grouped,MultiStark::messages_onto_each,40,1,21,14,0,0,1,21,111.0 +new-recursion-grouped,"${""name"":""MultiStark::list_length"",""types"":[{""array"":{""element"":""field"",""length"":8}}]}",41,8,15,6,0,0,2,120,1896.0 +new-recursion-grouped,MultiStark::headers_onto,42,2,13,8,0,0,1,26,146.0 +new-recursion-grouped,MultiStark::header_onto,43,1,13,14,0,0,1,13,87.0 +new-recursion-grouped,MultiStark::active_onto,44,2,11,10,0,0,1,22,146.0 +new-recursion-grouped,"${""name"":""MultiStark::list_length"",""types"":[""field""]}",45,128,8,6,0,0,2,1024,49920.0 +new-recursion-grouped,MultiStark::claims_onto,46,1,7,8,0,0,1,7,51.0 +new-recursion-grouped,MultiStark::claims_onto_each,47,2,12,12,0,0,1,24,164.0 +new-recursion-grouped,verifier_group_16,48,512,17,8,0,0,2,8704,407040.0 +new-recursion-grouped,"${""name"":""MultiStark::list_concat"",""types"":[""field""]}",49,512,10,8,0,0,1,5120,278528.0 +new-recursion-grouped,MultiStark::messages_acc,50,1,32,4,0,0,2,32,120.0 +new-recursion-grouped,MultiStark::verify_shards,51,2,60,6,0,0,2,120,444.0 +new-recursion-grouped,MultiStark::verify_shard,52,1,125,100,0,0,1,125,681.0 +new-recursion-grouped,verifier_group_19,53,128,13,6,0,0,2,1664,63360.0 +new-recursion-grouped,MultiStark::assert_same_bits,54,4,11,8,0,0,2,44,600.0 +new-recursion-grouped,MultiStark::assert_same_cap,55,2,79,20,0,0,2,158,642.0 +new-recursion-grouped,UInt64::eq,56,32,27,2,0,0,2,864,16224.0 +new-recursion-grouped,MultiStark::assert_log_degrees_ok,57,2,9,8,0,0,1,18,122.0 +new-recursion-grouped,MultiStark::log_degree_ok,58,1,69,2,0,0,2,69,225.0 +new-recursion-grouped,MultiStark::count_ones,59,2,8,6,0,0,2,16,132.0 +new-recursion-grouped,MultiStark::shard_fiat_shamir,60,1,64,16,0,0,2,64,252.0 +new-recursion-grouped,verifier_group_15,61,32,51,42,0,0,2,1632,46944.0 +new-recursion-grouped,verifier_group_17,62,32,45,16,0,0,2,1440,31584.0 +new-recursion-grouped,MultiStark::eval_at,63,8,42,10,0,0,2,336,4128.0 +new-recursion-grouped,"${""name"":""MultiStark::list_lookup"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::SysNode""}}]}",64,8,10,6,0,0,1,80,1328.0 +new-recursion-grouped,verifier_group_14,65,1,14,4,0,0,2,14,66.0 +new-recursion-grouped,MultiStark::digest_eq,66,4,74,8,0,0,2,296,2112.0 +new-recursion-grouped,MultiStark::assert_same_claims,67,4,12,6,0,0,2,48,576.0 +new-recursion-grouped,MultiStark::assert_same_limbs,68,8,26,6,0,0,2,208,2688.0 +new-recursion-grouped,MultiStark::b3_rows_chunks,69,2,230,56,0,0,2,460,1764.0 +new-recursion-grouped,MultiStark::rows_pop,70,8,41,8,0,0,2,328,3912.0 +new-recursion-grouped,MultiStark::select_rows,71,4,30,14,0,0,2,120,1200.0 +new-recursion-grouped,MultiStark::ri_apply,72,16,24,10,0,0,2,384,7488.0 +new-recursion-grouped,MultiStark::bucket_update,73,16,31,6,0,0,2,496,8064.0 +new-recursion-grouped,MultiStark::ro_fold,74,16,36,4,0,0,2,576,8640.0 +new-recursion-grouped,MultiStark::last_acc,75,1,14,4,0,0,2,14,66.0 +new-recursion-grouped,MultiStark::batch_claims,76,2,12,10,0,0,1,24,152.0 +new-recursion-grouped,,77,256,2,4,11,256,1,512,50176.0 +new-recursion-grouped,,78,65536,7,8,14,65536,2,458752,60555264.0 +new-recursion-grouped,,79,1024,1,2,3,1024,1,1024,157696.0 +new-recursion-grouped,,80,4096,6,6,0,0,1,24576,2080768.0 +new-recursion-grouped,,81,32,7,6,0,0,1,224,7328.0 +new-recursion-grouped,,82,1,8,6,0,0,1,8,48.0 +new-recursion-grouped,,83,128,9,6,0,0,1,1152,46208.0 +new-recursion-grouped,,84,8,10,6,0,0,1,80,1328.0 +new-recursion-grouped,,85,1,11,6,0,0,1,11,57.0 +new-recursion-grouped,,86,32,13,6,0,0,1,416,10208.0 +new-recursion-grouped,,87,2,14,6,0,0,1,28,140.0 +new-recursion-grouped,,88,2,29,6,0,0,1,58,230.0 +new-recursion-grouped,,89,16,35,6,0,0,1,560,8320.0 +new-recursion-grouped,,90,16,37,6,0,0,1,592,8704.0 +new-recursion-real-grouped,MultiStark::verify_multi_stark_proof,0,1,219,96,0,0,1,219,951.0 +new-recursion-real-grouped,MultiStark::read_byte_stream,1,1048576,11,8,0,0,2,11534336,1459617792.0 +new-recursion-real-grouped,verifier_group_03,2,32768,206,42,0,0,2,6750208,371982336.0 +new-recursion-real-grouped,Blake3::compress,3,1048576,501,226,0,0,2,525336576,46003126272.0 +new-recursion-real-grouped,Blake3::compress_chunks,4,2097152,17,6,0,0,2,35651584,3592421376.0 +new-recursion-real-grouped,verifier_group_12,5,65536,378,130,0,0,2,24772608,1611399168.0 +new-recursion-real-grouped,verifier_group_00,6,262144,74,20,0,0,2,19398656,1390411776.0 +new-recursion-real-grouped,verifier_group_08,7,32768,34,8,0,0,2,1114112,68222976.0 +new-recursion-real-grouped,"${""name"":""Lists::is_empty"",""types"":[""field""]}",8,32768,7,4,0,0,1,229376,19300352.0 +new-recursion-real-grouped,MultiStark::read_vk_u8,9,1048576,5,4,0,0,1,5242880,696254464.0 +new-recursion-real-grouped,verifier_group_02,10,8192,52,12,0,0,2,425984,21823488.0 +new-recursion-real-grouped,MultiStark::read_vk_tag,11,131072,5,4,0,0,1,655360,74055680.0 +new-recursion-real-grouped,MultiStark::read_vk_u16,12,524288,7,6,0,0,1,3670016,450363392.0 +new-recursion-real-grouped,MultiStark::read_nodes_n,13,131072,44,36,0,0,2,5767168,563085312.0 +new-recursion-real-grouped,verifier_group_11,14,131072,15,8,0,0,2,1966080,182059008.0 +new-recursion-real-grouped,verifier_group_13,15,128,82,40,0,0,2,10496,340224.0 +new-recursion-real-grouped,verifier_group_10,16,16384,89,18,0,0,2,1458176,76578816.0 +new-recursion-real-grouped,verifier_group_04,17,16384,147,66,0,0,2,2408448,149520384.0 +new-recursion-real-grouped,verifier_group_05,18,262144,16,6,0,0,2,4194304,371195904.0 +new-recursion-real-grouped,MultiStark::read_u64_at,19,1048576,19,18,0,0,1,19922944,2457862144.0 +new-recursion-real-grouped,MultiStark::read_header_vec_n,20,2,23,20,0,0,2,46,306.0 +new-recursion-real-grouped,verifier_group_06,21,8192,49,12,0,0,2,401408,20865024.0 +new-recursion-real-grouped,MultiStark::read_u8_at,22,1024,5,4,0,0,1,5120,342016.0 +new-recursion-real-grouped,MultiStark::read_u64_vec,23,65536,7,6,0,0,1,458752,47448064.0 +new-recursion-real-grouped,MultiStark::read_u64_vec_n,24,1048576,18,8,0,0,2,18874368,1900019712.0 +new-recursion-real-grouped,MultiStark::read_message_vec_n,25,32,20,10,0,0,2,640,16704.0 +new-recursion-real-grouped,MultiStark::read_proof_vec_n,26,2,34,8,0,0,2,68,300.0 +new-recursion-real-grouped,MultiStark::read_proof,27,1,53,44,0,0,1,53,297.0 +new-recursion-real-grouped,verifier_group_09,28,65536,28,10,0,0,2,1835008,132907008.0 +new-recursion-real-grouped,MultiStark::verify_batch,29,1,40,12,0,0,2,40,168.0 +new-recursion-real-grouped,MultiStark::assert_shard_count_ok,30,1,16,6,0,0,2,16,78.0 +new-recursion-real-grouped,"${""name"":""MultiStark::list_length"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::Proof""}}]}",31,2,31,6,0,0,2,62,270.0 +new-recursion-real-grouped,MultiStark::assert_closure_pairs,32,16,159,34,0,0,2,2544,38016.0 +new-recursion-real-grouped,MultiStark::three_limbs,33,32,39,10,0,0,1,1248,24608.0 +new-recursion-real-grouped,MultiStark::bytes8_le,34,64,26,18,0,0,1,1664,53248.0 +new-recursion-real-grouped,MultiStark::le_step,35,64,11,2,0,0,2,704,20352.0 +new-recursion-real-grouped,MultiStark::batch_fiat_shamir,36,1,73,68,0,0,1,73,429.0 +new-recursion-real-grouped,MultiStark::messages_onto,37,1,7,8,0,0,1,7,51.0 +new-recursion-real-grouped,MultiStark::count_onto,38,64,18,6,0,0,2,1152,33024.0 +new-recursion-real-grouped,MultiStark::b8_onto,39,65536,19,18,0,0,1,1245184,122945536.0 +new-recursion-real-grouped,MultiStark::messages_onto_each,40,32,21,14,0,0,1,672,17888.0 +new-recursion-real-grouped,"${""name"":""MultiStark::list_length"",""types"":[{""array"":{""element"":""field"",""length"":8}}]}",41,1048576,15,6,0,0,2,15728640,1585446912.0 +new-recursion-real-grouped,MultiStark::headers_onto,42,2,13,8,0,0,1,26,146.0 +new-recursion-real-grouped,MultiStark::header_onto,43,1,13,14,0,0,1,13,87.0 +new-recursion-real-grouped,MultiStark::active_onto,44,256,11,10,0,0,1,2816,142336.0 +new-recursion-real-grouped,"${""name"":""MultiStark::list_length"",""types"":[""field""]}",45,65536,8,6,0,0,2,524288,57409536.0 +new-recursion-real-grouped,MultiStark::claims_onto,46,1,7,8,0,0,1,7,51.0 +new-recursion-real-grouped,MultiStark::claims_onto_each,47,2,12,12,0,0,1,24,164.0 +new-recursion-real-grouped,verifier_group_16,48,65536,17,8,0,0,2,1114112,92012544.0 +new-recursion-real-grouped,"${""name"":""MultiStark::list_concat"",""types"":[""field""]}",49,2048,10,8,0,0,1,20480,1359872.0 +new-recursion-real-grouped,MultiStark::messages_acc,50,32,32,4,0,0,2,1024,19584.0 +new-recursion-real-grouped,MultiStark::verify_shards,51,2,60,6,0,0,2,120,444.0 +new-recursion-real-grouped,MultiStark::verify_shard,52,1,125,100,0,0,1,125,681.0 +new-recursion-real-grouped,verifier_group_19,53,131072,13,6,0,0,2,1703936,155320320.0 +new-recursion-real-grouped,MultiStark::assert_same_bits,54,512,11,8,0,0,2,5632,324096.0 +new-recursion-real-grouped,MultiStark::assert_same_cap,55,2,79,20,0,0,2,158,642.0 +new-recursion-real-grouped,UInt64::eq,56,32768,27,2,0,0,2,884736,49053696.0 +new-recursion-real-grouped,MultiStark::assert_log_degrees_ok,57,256,9,8,0,0,1,2304,117760.0 +new-recursion-real-grouped,MultiStark::log_degree_ok,58,32,69,2,0,0,2,2208,36384.0 +new-recursion-real-grouped,MultiStark::count_ones,59,256,8,6,0,0,2,2048,113664.0 +new-recursion-real-grouped,MultiStark::shard_fiat_shamir,60,1,64,16,0,0,2,64,252.0 +new-recursion-real-grouped,verifier_group_15,61,131072,51,42,0,0,2,6684672,649986048.0 +new-recursion-real-grouped,verifier_group_17,62,131072,45,16,0,0,2,5898240,436076544.0 +new-recursion-real-grouped,MultiStark::eval_at,63,131072,42,10,0,0,2,5505024,375914496.0 +new-recursion-real-grouped,"${""name"":""MultiStark::list_lookup"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::SysNode""}}]}",64,131072,10,6,0,0,1,1310720,120848384.0 +new-recursion-real-grouped,verifier_group_14,65,32768,14,4,0,0,2,458752,32833536.0 +new-recursion-real-grouped,MultiStark::digest_eq,66,128,74,8,0,0,2,9472,232704.0 +new-recursion-real-grouped,MultiStark::assert_same_claims,67,8192,12,6,0,0,2,98304,7127040.0 +new-recursion-real-grouped,MultiStark::assert_same_limbs,68,32768,26,6,0,0,2,851968,53477376.0 +new-recursion-real-grouped,MultiStark::b3_rows_chunks,69,131072,230,56,0,0,2,30146560,1940127744.0 +new-recursion-real-grouped,MultiStark::rows_pop,70,1048576,41,8,0,0,2,42991616,3347054592.0 +new-recursion-real-grouped,MultiStark::select_rows,71,1048576,30,14,0,0,2,31457280,3032481792.0 +new-recursion-real-grouped,MultiStark::ri_apply,72,65536,24,10,0,0,2,1572864,120324096.0 +new-recursion-real-grouped,MultiStark::bucket_update,73,1048576,31,6,0,0,2,32505856,2592079872.0 +new-recursion-real-grouped,MultiStark::ro_fold,74,2097152,36,4,0,0,2,75497472,5838471168.0 +new-recursion-real-grouped,MultiStark::last_acc,75,256,14,4,0,0,2,3584,138240.0 +new-recursion-real-grouped,MultiStark::batch_claims,76,2,12,10,0,0,1,24,152.0 +new-recursion-real-grouped,,77,256,2,4,11,256,1,512,50176.0 +new-recursion-real-grouped,,78,65536,7,8,14,65536,2,458752,60555264.0 +new-recursion-real-grouped,,79,1024,1,2,3,1024,1,1024,157696.0 +new-recursion-real-grouped,,80,4194304,6,6,0,0,1,25165824,3892314112.0 +new-recursion-real-grouped,,81,32768,7,6,0,0,1,229376,22249472.0 +new-recursion-real-grouped,,82,32,8,6,0,0,1,256,7808.0 +new-recursion-real-grouped,,83,262144,9,6,0,0,1,2359296,241696768.0 +new-recursion-real-grouped,,84,1048576,10,6,0,0,1,10485760,1136656384.0 +new-recursion-real-grouped,,85,1024,11,6,0,0,1,11264,587776.0 +new-recursion-real-grouped,,86,1048576,13,6,0,0,1,13631488,1325400064.0 +new-recursion-real-grouped,,87,512,14,6,0,0,1,7168,306176.0 +new-recursion-real-grouped,,88,2,29,6,0,0,1,58,230.0 +new-recursion-real-grouped,,89,131072,35,6,0,0,1,4587520,287965184.0 +new-recursion-real-grouped,,90,16384,37,6,0,0,1,606208,31031296.0 +new-recursion-real-ungrouped,MultiStark::verify_multi_stark_proof,0,1,219,96,0,0,1,219,951.0 +new-recursion-real-ungrouped,MultiStark::read_byte_stream,1,1048576,11,8,0,0,2,11534336,1459617792.0 +new-recursion-real-ungrouped,Blake3::compress_layer,2,8192,140,12,0,0,2,1146880,49938432.0 +new-recursion-real-ungrouped,Blake3::next_layer,3,16384,177,20,0,0,2,2899968,138510336.0 +new-recursion-real-ungrouped,Blake3::compress,4,1048576,501,226,0,0,2,525336576,46003126272.0 +new-recursion-real-ungrouped,Blake3::compress_chunks,5,2097152,17,6,0,0,2,35651584,3592421376.0 +new-recursion-real-ungrouped,Blake3::finish,6,64,166,28,0,0,2,10624,228864.0 +new-recursion-real-ungrouped,UInt64::is_zero,7,1024,19,2,0,0,2,19456,780288.0 +new-recursion-real-ungrouped,Blake3::bytes_to_block,8,32768,131,130,0,0,1,4292608,387940352.0 +new-recursion-real-ungrouped,Blake3::pad_block,9,1024,8,4,0,0,2,8192,503808.0 +new-recursion-real-ungrouped,Blake3::compress_block,10,32768,180,48,0,0,2,5898240,342491136.0 +new-recursion-real-ungrouped,"${""name"":""Lists::is_empty"",""types"":[""field""]}",11,32768,7,4,0,0,1,229376,19300352.0 +new-recursion-real-ungrouped,UInt64::wrapping_succ,12,1024,20,4,0,0,2,20480,872448.0 +new-recursion-real-ungrouped,MultiStark::read_vk_u16_limb,13,1024,7,6,0,0,1,7168,464896.0 +new-recursion-real-ungrouped,MultiStark::read_vk_u8,14,1048576,5,4,0,0,1,5242880,696254464.0 +new-recursion-real-ungrouped,MultiStark::read_sys_circuits_n,15,256,114,68,0,0,2,29184,1145856.0 +new-recursion-real-ungrouped,MultiStark::read_vk_u32_limb,16,256,11,10,0,0,1,2816,142336.0 +new-recursion-real-ungrouped,MultiStark::read_vk_tag,17,131072,5,4,0,0,1,655360,74055680.0 +new-recursion-real-ungrouped,MultiStark::read_vk_u16,18,524288,7,6,0,0,1,3670016,450363392.0 +new-recursion-real-ungrouped,MultiStark::read_nodes_n,19,131072,44,36,0,0,2,5767168,563085312.0 +new-recursion-real-ungrouped,MultiStark::read_field,20,1024,12,4,0,0,1,12288,557056.0 +new-recursion-real-ungrouped,MultiStark::read_vk_u64,21,1024,19,18,0,0,1,19456,1202176.0 +new-recursion-real-ungrouped,UInt32::less_than_fields,22,262144,14,14,0,0,1,3670016,425721856.0 +new-recursion-real-ungrouped,MultiStark::read_node_ids_n,23,65536,11,8,0,0,2,720896,73138176.0 +new-recursion-real-ungrouped,MultiStark::read_sys_lookups_n,24,4096,15,12,0,0,2,61440,4620288.0 +new-recursion-real-ungrouped,MultiStark::lookup_groups_count,25,512,10,4,0,0,2,5120,254976.0 +new-recursion-real-ungrouped,MultiStark::read_opt_commit,26,1,11,8,0,0,2,11,69.0 +new-recursion-real-ungrouped,MultiStark::read_vk_cap_n,27,2,46,16,0,0,2,92,420.0 +new-recursion-real-ungrouped,MultiStark::read_opt_idx_n,28,256,13,8,0,0,2,3328,156672.0 +new-recursion-real-ungrouped,"${""name"":""MultiStark::list_concat"",""types"":[{""array"":{""element"":""field"",""length"":8}}]}",29,8,17,8,0,0,1,136,1976.0 +new-recursion-real-ungrouped,MultiStark::read_count,30,2,13,6,0,0,1,26,134.0 +new-recursion-real-ungrouped,MultiStark::read_u64,31,16,19,18,0,0,1,304,7552.0 +new-recursion-real-ungrouped,MultiStark::read_u8,32,128,8,6,0,0,2,1024,49920.0 +new-recursion-real-ungrouped,UInt64::to_field,33,128,10,2,0,0,1,1280,38144.0 +new-recursion-real-ungrouped,MultiStark::read_claims_n,34,2,13,10,0,0,2,26,186.0 +new-recursion-real-ungrouped,MultiStark::read_claim_vals_n,35,16,18,8,0,0,2,288,5952.0 +new-recursion-real-ungrouped,MultiStark::read_count_at,36,65536,13,6,0,0,1,851968,66322432.0 +new-recursion-real-ungrouped,MultiStark::read_u64_at,37,1048576,19,18,0,0,1,19922944,2457862144.0 +new-recursion-real-ungrouped,MultiStark::read_header_vec_n,38,2,23,20,0,0,2,46,306.0 +new-recursion-real-ungrouped,MultiStark::read_active_n,39,1024,11,8,0,0,2,11264,718848.0 +new-recursion-real-ungrouped,MultiStark::read_u8_at,40,1024,5,4,0,0,1,5120,342016.0 +new-recursion-real-ungrouped,MultiStark::read_digest_vec_at,41,64,7,6,0,0,1,448,17536.0 +new-recursion-real-ungrouped,MultiStark::read_digest_vec_at_n,42,16384,46,16,0,0,2,753664,45613056.0 +new-recursion-real-ungrouped,MultiStark::read_u64_vec_vec_n,43,65536,11,8,0,0,2,720896,73138176.0 +new-recursion-real-ungrouped,MultiStark::read_u64_vec,44,65536,7,6,0,0,1,458752,47448064.0 +new-recursion-real-ungrouped,MultiStark::read_u64_vec_n,45,1048576,18,8,0,0,2,18874368,1900019712.0 +new-recursion-real-ungrouped,MultiStark::read_message_vec_n,46,32,20,10,0,0,2,640,16704.0 +new-recursion-real-ungrouped,MultiStark::read_proof_vec_n,47,2,34,8,0,0,2,68,300.0 +new-recursion-real-ungrouped,MultiStark::read_proof,48,1,53,44,0,0,1,53,297.0 +new-recursion-real-ungrouped,MultiStark::read_ext_vec,49,4096,7,6,0,0,1,28672,2228224.0 +new-recursion-real-ungrouped,MultiStark::read_ext_vec_n,50,32768,27,10,0,0,2,884736,60850176.0 +new-recursion-real-ungrouped,MultiStark::read_merkle_cap_vec_n,51,32,11,8,0,0,2,352,11424.0 +new-recursion-real-ungrouped,MultiStark::read_batch_opening_vec_n,52,8,15,12,0,0,2,120,2328.0 +new-recursion-real-ungrouped,MultiStark::read_u64_vec_vec_vec_n,53,512,13,10,0,0,2,6656,379392.0 +new-recursion-real-ungrouped,MultiStark::read_commit_phase_step_vec_n,54,32,15,12,0,0,2,480,15264.0 +new-recursion-real-ungrouped,MultiStark::read_ext_vec_vec,55,1024,7,6,0,0,1,7168,464896.0 +new-recursion-real-ungrouped,MultiStark::read_ext_vec_vec_n,56,4096,11,8,0,0,2,45056,3440640.0 +new-recursion-real-ungrouped,MultiStark::read_opened_round,57,4,7,6,0,0,1,28,376.0 +new-recursion-real-ungrouped,MultiStark::read_opened_round_n,58,1024,11,8,0,0,2,11264,718848.0 +new-recursion-real-ungrouped,MultiStark::read_preprocessed,59,1,9,6,0,0,2,9,57.0 +new-recursion-real-ungrouped,MultiStark::verify_batch,60,1,40,12,0,0,2,40,168.0 +new-recursion-real-ungrouped,MultiStark::assert_shard_count_ok,61,1,16,6,0,0,2,16,78.0 +new-recursion-real-ungrouped,"${""name"":""MultiStark::list_length"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::ShardHeader""}}]}",62,4,11,6,0,0,2,44,552.0 +new-recursion-real-ungrouped,"${""name"":""MultiStark::list_length"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::Proof""}}]}",63,2,31,6,0,0,2,62,270.0 +new-recursion-real-ungrouped,MultiStark::assert_closure_pairs,64,16,159,34,0,0,2,2544,38016.0 +new-recursion-real-ungrouped,MultiStark::three_limbs,65,32,39,10,0,0,1,1248,24608.0 +new-recursion-real-ungrouped,MultiStark::bytes8_le,66,64,26,18,0,0,1,1664,53248.0 +new-recursion-real-ungrouped,MultiStark::le_step,67,64,11,2,0,0,2,704,20352.0 +new-recursion-real-ungrouped,MultiStark::batch_fiat_shamir,68,1,73,68,0,0,1,73,429.0 +new-recursion-real-ungrouped,MultiStark::messages_onto,69,1,7,8,0,0,1,7,51.0 +new-recursion-real-ungrouped,MultiStark::count_onto,70,64,18,6,0,0,2,1152,33024.0 +new-recursion-real-ungrouped,MultiStark::b8_onto,71,65536,19,18,0,0,1,1245184,122945536.0 +new-recursion-real-ungrouped,"${""name"":""MultiStark::list_length"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::BatchMessage""}}]}",72,512,16,6,0,0,2,8192,365568.0 +new-recursion-real-ungrouped,MultiStark::messages_onto_each,73,32,21,14,0,0,1,672,17888.0 +new-recursion-real-ungrouped,"${""name"":""MultiStark::list_length"",""types"":[{""array"":{""element"":""field"",""length"":8}}]}",74,1048576,15,6,0,0,2,15728640,1585446912.0 +new-recursion-real-ungrouped,MultiStark::limbs_onto,75,2048,17,8,0,0,1,34816,1832960.0 +new-recursion-real-ungrouped,MultiStark::headers_onto,76,2,13,8,0,0,1,26,146.0 +new-recursion-real-ungrouped,MultiStark::header_onto,77,1,13,14,0,0,1,13,87.0 +new-recursion-real-ungrouped,MultiStark::active_onto,78,256,11,10,0,0,1,2816,142336.0 +new-recursion-real-ungrouped,MultiStark::cap_onto,79,32,45,16,0,0,1,1440,30368.0 +new-recursion-real-ungrouped,"${""name"":""MultiStark::list_length"",""types"":[""field""]}",80,65536,8,6,0,0,2,524288,57409536.0 +new-recursion-real-ungrouped,MultiStark::log_degrees_onto,81,256,10,8,0,0,1,2560,123904.0 +new-recursion-real-ungrouped,MultiStark::claims_onto,82,1,7,8,0,0,1,7,51.0 +new-recursion-real-ungrouped,MultiStark::claims_onto_each,83,2,12,12,0,0,1,24,164.0 +new-recursion-real-ungrouped,MultiStark::ch_sample_ext,84,32,24,6,0,0,1,768,15488.0 +new-recursion-real-ungrouped,MultiStark::ch_sample_field,85,64,33,4,0,0,2,2112,48000.0 +new-recursion-real-ungrouped,MultiStark::ch_sample8,86,128,72,54,0,0,2,9216,350976.0 +new-recursion-real-ungrouped,MultiStark::b3_w4_onto,87,512,11,10,0,0,1,5632,320000.0 +new-recursion-real-ungrouped,MultiStark::rev_onto,88,16384,10,8,0,0,1,163840,13828096.0 +new-recursion-real-ungrouped,"${""name"":""MultiStark::list_concat"",""types"":[""field""]}",89,2048,10,8,0,0,1,20480,1359872.0 +new-recursion-real-ungrouped,MultiStark::messages_acc,90,32,32,4,0,0,2,1024,19584.0 +new-recursion-real-ungrouped,MultiStark::fingerprint_vals,91,128,20,4,0,0,2,2560,76800.0 +new-recursion-real-ungrouped,MultiStark::verify_shards,92,2,60,6,0,0,2,120,444.0 +new-recursion-real-ungrouped,MultiStark::verify_shard,93,1,125,100,0,0,1,125,681.0 +new-recursion-real-ungrouped,"${""name"":""MultiStark::list_length"",""types"":[{""array"":{""element"":""field"",""length"":2}}]}",94,32768,9,6,0,0,2,294912,28409856.0 +new-recursion-real-ungrouped,MultiStark::assert_bits,95,256,8,4,0,0,2,2048,101376.0 +new-recursion-real-ungrouped,MultiStark::select_active_circuits,96,256,22,12,0,0,2,5632,236544.0 +new-recursion-real-ungrouped,MultiStark::select_active_prep,97,256,15,12,0,0,2,3840,193536.0 +new-recursion-real-ungrouped,MultiStark::assert_same_bits,98,512,11,8,0,0,2,5632,324096.0 +new-recursion-real-ungrouped,MultiStark::assert_same_cap,99,2,79,20,0,0,2,158,642.0 +new-recursion-real-ungrouped,UInt64::eq,100,32768,27,2,0,0,2,884736,49053696.0 +new-recursion-real-ungrouped,MultiStark::assert_log_degrees_ok,101,256,9,8,0,0,1,2304,117760.0 +new-recursion-real-ungrouped,MultiStark::log_degree_ok,102,32,69,2,0,0,2,2208,36384.0 +new-recursion-real-ungrouped,MultiStark::count_ones,103,256,8,6,0,0,2,2048,113664.0 +new-recursion-real-ungrouped,MultiStark::shard_fiat_shamir,104,1,64,16,0,0,2,64,252.0 +new-recursion-real-ungrouped,MultiStark::snoc_b8,105,32,14,8,0,0,1,448,11648.0 +new-recursion-real-ungrouped,MultiStark::snoc_cap,106,32,7,8,0,0,1,224,8288.0 +new-recursion-real-ungrouped,MultiStark::accs_onto,107,32768,38,14,0,0,2,1245184,82968576.0 +new-recursion-real-ungrouped,MultiStark::claims_acc,108,2,22,4,0,0,2,44,204.0 +new-recursion-real-ungrouped,MultiStark::ood_loop,109,256,153,108,0,0,2,39168,1631232.0 +new-recursion-real-ungrouped,"${""name"":""MultiStark::list_lookup"",""types"":[""field""]}",110,65536,7,6,0,0,1,458752,47448064.0 +new-recursion-real-ungrouped,"${""name"":""MultiStark::list_drop"",""types"":[""field""]}",111,65536,9,6,0,0,2,589824,60555264.0 +new-recursion-real-ungrouped,MultiStark::quotient_degree_of,112,2,39,2,0,0,2,78,294.0 +new-recursion-real-ungrouped,"${""name"":""MultiStark::list_lookup"",""types"":[{""array"":{""element"":""field"",""length"":2}}]}",113,16384,8,6,0,0,1,131072,11075584.0 +new-recursion-real-ungrouped,"${""name"":""MultiStark::list_drop"",""types"":[{""array"":{""element"":""field"",""length"":2}}]}",114,16384,10,6,0,0,2,163840,13959168.0 +new-recursion-real-ungrouped,MultiStark::ext_exp_pow2,115,256,13,2,0,0,2,3328,119808.0 +new-recursion-real-ungrouped,MultiStark::two_adic_gen,116,64,9,2,0,0,2,576,18048.0 +new-recursion-real-ungrouped,MultiStark::pow2,117,32,6,4,0,0,2,192,7104.0 +new-recursion-real-ungrouped,MultiStark::fold_roots,118,16384,31,10,0,0,1,507904,29655040.0 +new-recursion-real-ungrouped,MultiStark::eval_at,119,131072,42,10,0,0,2,5505024,375914496.0 +new-recursion-real-ungrouped,"${""name"":""MultiStark::list_lookup"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::SysNode""}}]}",120,131072,10,6,0,0,1,1310720,120848384.0 +new-recursion-real-ungrouped,"${""name"":""MultiStark::list_drop"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::SysNode""}}]}",121,131072,12,6,0,0,2,1572864,148635648.0 +new-recursion-real-ungrouped,MultiStark::ood_fold,122,32768,10,2,0,0,1,327680,20774912.0 +new-recursion-real-ungrouped,MultiStark::logup_steps_fold,123,2048,94,42,0,0,2,192512,9486336.0 +new-recursion-real-ungrouped,MultiStark::logup_fingerprint,124,32768,35,10,0,0,2,1146880,72646656.0 +new-recursion-real-ungrouped,MultiStark::pair_mul,125,32768,14,2,0,0,1,458752,26673152.0 +new-recursion-real-ungrouped,MultiStark::reconstruct_ext_row,126,512,15,12,0,0,2,7680,434688.0 +new-recursion-real-ungrouped,MultiStark::from_ext_basis,127,512,6,2,0,0,1,3072,140288.0 +new-recursion-real-ungrouped,MultiStark::quotient_eval,128,512,20,4,0,0,2,10240,393216.0 +new-recursion-real-ungrouped,MultiStark::prep_count,129,1,5,2,0,0,1,5,27.0 +new-recursion-real-ungrouped,"${""name"":""MultiStark::list_length"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::CommitPhaseMultiStep""}}]}",130,32,10,6,0,0,2,320,9984.0 +new-recursion-real-ungrouped,MultiStark::round_onto,131,1024,10,8,0,0,1,10240,618496.0 +new-recursion-real-ungrouped,MultiStark::points_onto,132,2048,10,8,0,0,1,20480,1359872.0 +new-recursion-real-ungrouped,MultiStark::pcs_betas,133,32,43,16,0,0,2,1376,30624.0 +new-recursion-real-ungrouped,MultiStark::pcs_check_witness,134,32,20,10,0,0,2,640,16704.0 +new-recursion-real-ungrouped,MultiStark::ch_sample_bits,135,64,53,24,0,0,1,3392,91264.0 +new-recursion-real-ungrouped,MultiStark::take_bits,136,2048,10,8,0,0,2,20480,1511424.0 +new-recursion-real-ungrouped,MultiStark::bits_to_num,137,1024,8,6,0,0,2,8192,565248.0 +new-recursion-real-ungrouped,MultiStark::obs_log_arities,138,32,10,8,0,0,1,320,9728.0 +new-recursion-real-ungrouped,MultiStark::sample_query_indices,139,128,13,8,0,0,2,1664,68736.0 +new-recursion-real-ungrouped,MultiStark::verify_input_multi,140,1,32,26,0,0,1,32,180.0 +new-recursion-real-ungrouped,MultiStark::heights_all,141,256,11,8,0,0,2,2816,144384.0 +new-recursion-real-ungrouped,MultiStark::mmcs_verify_multi,142,32,23,22,0,0,1,736,22688.0 +new-recursion-real-ungrouped,MultiStark::frontier_sort,143,4096,22,14,0,0,1,90112,5619712.0 +new-recursion-real-ungrouped,MultiStark::frontier_split,144,8192,21,14,0,0,2,172032,12558336.0 +new-recursion-real-ungrouped,MultiStark::frontier_merge,145,8192,29,20,0,0,2,237568,17031168.0 +new-recursion-real-ungrouped,MultiStark::digest_eq,146,128,74,8,0,0,2,9472,232704.0 +new-recursion-real-ungrouped,MultiStark::assert_same_claims,147,8192,12,6,0,0,2,98304,7127040.0 +new-recursion-real-ungrouped,MultiStark::assert_same_limbs,148,32768,26,6,0,0,2,851968,53477376.0 +new-recursion-real-ungrouped,MultiStark::frontier_leaves,149,2048,16,16,0,0,2,32768,2457600.0 +new-recursion-real-ungrouped,MultiStark::leaf_hash_at,150,4096,44,18,0,0,1,180224,9453568.0 +new-recursion-real-ungrouped,MultiStark::b3_rows_chunks,151,131072,230,56,0,0,2,30146560,1940127744.0 +new-recursion-real-ungrouped,MultiStark::rows_pop,152,1048576,41,8,0,0,2,42991616,3347054592.0 +new-recursion-real-ungrouped,MultiStark::select_rows,153,1048576,30,14,0,0,2,31457280,3032481792.0 +new-recursion-real-ungrouped,MultiStark::frontier_fold,154,512,12,4,0,0,2,6144,282624.0 +new-recursion-real-ungrouped,MultiStark::frontier_level,155,16384,38,42,0,0,2,622592,57999360.0 +new-recursion-real-ungrouped,MultiStark::select_rows_le,156,131072,28,16,0,0,2,3670016,322437120.0 +new-recursion-real-ungrouped,MultiStark::inject_maybe,157,16384,11,4,0,0,2,180224,13271040.0 +new-recursion-real-ungrouped,MultiStark::has_height,158,2048,14,4,0,0,2,28672,1511424.0 +new-recursion-real-ungrouped,MultiStark::mmcs_compress,159,16384,103,14,0,0,1,1687552,81952768.0 +new-recursion-real-ungrouped,MultiStark::compress_ordered,160,16384,8,4,0,0,2,131072,11206656.0 +new-recursion-real-ungrouped,MultiStark::heights_prep,161,256,15,12,0,0,2,3840,193536.0 +new-recursion-real-ungrouped,MultiStark::heights_max,162,4,11,8,0,0,2,44,600.0 +new-recursion-real-ungrouped,MultiStark::drop_index_bits,163,2048,11,10,0,0,1,22528,1562624.0 +new-recursion-real-ungrouped,MultiStark::query_views,164,128,12,6,0,0,2,1536,60672.0 +new-recursion-real-ungrouped,MultiStark::batch_views_at,165,512,12,6,0,0,2,6144,310272.0 +new-recursion-real-ungrouped,MultiStark::step_views_at,166,2048,13,6,0,0,2,26624,1579008.0 +new-recursion-real-ungrouped,MultiStark::query_loop,167,128,38,12,0,0,2,4864,146688.0 +new-recursion-real-ungrouped,MultiStark::verify_one_query,168,64,59,20,0,0,2,3776,96384.0 +new-recursion-real-ungrouped,MultiStark::build_buckets,169,32,13,6,0,0,2,416,11424.0 +new-recursion-real-ungrouped,MultiStark::circ_has_height,170,2048,16,4,0,0,2,32768,1646592.0 +new-recursion-real-ungrouped,MultiStark::open_batch_2pt,171,32768,22,6,0,0,2,720896,47579136.0 +new-recursion-real-ungrouped,MultiStark::open_2pt_mat,172,32768,20,12,0,0,1,655360,50266112.0 +new-recursion-real-ungrouped,MultiStark::ri_apply,173,65536,24,10,0,0,2,1572864,120324096.0 +new-recursion-real-ungrouped,MultiStark::exp_by_bits,174,16384,13,4,0,0,2,212992,14647296.0 +new-recursion-real-ungrouped,MultiStark::bucket_update,175,1048576,31,6,0,0,2,32505856,2592079872.0 +new-recursion-real-ungrouped,MultiStark::ro_fold,176,2097152,36,4,0,0,2,75497472,5838471168.0 +new-recursion-real-ungrouped,MultiStark::open_quotient,177,16384,23,8,0,0,2,376832,24281088.0 +new-recursion-real-ungrouped,MultiStark::open_prep_batch,178,64,24,14,0,0,1,1536,46336.0 +new-recursion-real-ungrouped,MultiStark::open_prep,179,16384,27,8,0,0,2,442368,27033600.0 +new-recursion-real-ungrouped,MultiStark::assert_blowup_zero,180,1024,23,4,0,0,2,23552,964608.0 +new-recursion-real-ungrouped,MultiStark::verify_query,181,1024,98,66,0,0,2,100352,5173248.0 +new-recursion-real-ungrouped,"${""name"":""MultiStark::list_length"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::Bucket""}}]}",182,1,12,6,0,0,2,12,66.0 +new-recursion-real-ungrouped,MultiStark::fri_fold2,183,1024,20,6,0,0,2,20480,933888.0 +new-recursion-real-ungrouped,MultiStark::rollin,184,1024,24,6,0,0,2,24576,1056768.0 +new-recursion-real-ungrouped,MultiStark::verify_commit_multi,185,32,25,12,0,0,2,800,20064.0 +new-recursion-real-ungrouped,MultiStark::rows_at_round,186,2048,13,14,0,0,2,26624,2119680.0 +new-recursion-real-ungrouped,MultiStark::last_acc,187,256,14,4,0,0,2,3584,138240.0 +new-recursion-real-ungrouped,MultiStark::batch_claims,188,2,12,10,0,0,1,24,152.0 +new-recursion-real-ungrouped,,189,256,2,4,11,256,1,512,50176.0 +new-recursion-real-ungrouped,,190,65536,7,8,14,65536,2,458752,60555264.0 +new-recursion-real-ungrouped,,191,1024,1,2,3,1024,1,1024,157696.0 +new-recursion-real-ungrouped,,192,4194304,6,6,0,0,1,25165824,3892314112.0 +new-recursion-real-ungrouped,,193,32768,7,6,0,0,1,229376,22249472.0 +new-recursion-real-ungrouped,,194,32,8,6,0,0,1,256,7808.0 +new-recursion-real-ungrouped,,195,262144,9,6,0,0,1,2359296,241696768.0 +new-recursion-real-ungrouped,,196,1048576,10,6,0,0,1,10485760,1136656384.0 +new-recursion-real-ungrouped,,197,1024,11,6,0,0,1,11264,587776.0 +new-recursion-real-ungrouped,,198,1048576,13,6,0,0,1,13631488,1325400064.0 +new-recursion-real-ungrouped,,199,512,14,6,0,0,1,7168,306176.0 +new-recursion-real-ungrouped,,200,2,29,6,0,0,1,58,230.0 +new-recursion-real-ungrouped,,201,131072,35,6,0,0,1,4587520,287965184.0 +new-recursion-real-ungrouped,,202,16384,37,6,0,0,1,606208,31031296.0 +new-recursion-ungrouped,MultiStark::verify_multi_stark_proof,0,1,219,96,0,0,1,219,951.0 +new-recursion-ungrouped,MultiStark::read_byte_stream,1,256,11,8,0,0,2,2816,144384.0 +new-recursion-ungrouped,Blake3::compress_layer,2,16,140,12,0,0,2,2240,30144.0 +new-recursion-ungrouped,Blake3::next_layer,3,0,177,20,0,0,2,0,0.0 +new-recursion-ungrouped,Blake3::compress,4,256,501,226,0,0,2,128256,4494336.0 +new-recursion-ungrouped,Blake3::compress_chunks,5,1024,17,6,0,0,2,17408,841728.0 +new-recursion-ungrouped,Blake3::finish,6,16,166,28,0,0,2,2656,38208.0 +new-recursion-ungrouped,UInt64::is_zero,7,1,19,2,0,0,2,19,75.0 +new-recursion-ungrouped,Blake3::bytes_to_block,8,32,131,130,0,0,1,4192,126368.0 +new-recursion-ungrouped,Blake3::pad_block,9,256,8,4,0,0,2,2048,101376.0 +new-recursion-ungrouped,Blake3::compress_block,10,16,180,48,0,0,2,2880,44736.0 +new-recursion-ungrouped,"${""name"":""Lists::is_empty"",""types"":[""field""]}",11,8,7,4,0,0,1,56,968.0 +new-recursion-ungrouped,UInt64::wrapping_succ,12,0,20,4,0,0,2,0,0.0 +new-recursion-ungrouped,MultiStark::read_vk_u16_limb,13,16,7,6,0,0,1,112,2944.0 +new-recursion-ungrouped,MultiStark::read_vk_u8,14,128,5,4,0,0,1,640,30080.0 +new-recursion-ungrouped,MultiStark::read_sys_circuits_n,15,2,114,68,0,0,2,228,1140.0 +new-recursion-ungrouped,MultiStark::read_vk_u32_limb,16,1,11,10,0,0,1,11,69.0 +new-recursion-ungrouped,MultiStark::read_vk_tag,17,8,5,4,0,0,1,40,824.0 +new-recursion-ungrouped,MultiStark::read_vk_u16,18,32,7,6,0,0,1,224,7328.0 +new-recursion-ungrouped,MultiStark::read_nodes_n,19,8,44,36,0,0,2,352,6144.0 +new-recursion-ungrouped,MultiStark::read_field,20,1,12,4,0,0,1,12,54.0 +new-recursion-ungrouped,MultiStark::read_vk_u64,21,1,19,18,0,0,1,19,117.0 +new-recursion-ungrouped,UInt32::less_than_fields,22,8,14,14,0,0,1,112,2192.0 +new-recursion-ungrouped,MultiStark::read_node_ids_n,23,8,11,8,0,0,2,88,1752.0 +new-recursion-ungrouped,MultiStark::read_sys_lookups_n,24,2,15,12,0,0,2,30,210.0 +new-recursion-ungrouped,MultiStark::lookup_groups_count,25,2,10,4,0,0,2,20,132.0 +new-recursion-ungrouped,MultiStark::read_opt_commit,26,1,11,8,0,0,2,11,69.0 +new-recursion-ungrouped,MultiStark::read_vk_cap_n,27,0,46,16,0,0,2,0,0.0 +new-recursion-ungrouped,MultiStark::read_opt_idx_n,28,2,13,8,0,0,2,26,174.0 +new-recursion-ungrouped,"${""name"":""MultiStark::list_concat"",""types"":[{""array"":{""element"":""field"",""length"":8}}]}",29,8,17,8,0,0,1,136,1976.0 +new-recursion-ungrouped,MultiStark::read_count,30,2,13,6,0,0,1,26,134.0 +new-recursion-ungrouped,MultiStark::read_u64,31,8,19,18,0,0,1,152,2840.0 +new-recursion-ungrouped,MultiStark::read_u8,32,64,8,6,0,0,2,512,21504.0 +new-recursion-ungrouped,UInt64::to_field,33,8,10,2,0,0,1,80,1040.0 +new-recursion-ungrouped,MultiStark::read_claims_n,34,2,13,10,0,0,2,26,186.0 +new-recursion-ungrouped,MultiStark::read_claim_vals_n,35,8,18,8,0,0,2,144,2256.0 +new-recursion-ungrouped,MultiStark::read_count_at,36,256,13,6,0,0,1,3328,130048.0 +new-recursion-ungrouped,MultiStark::read_u64_at,37,512,19,18,0,0,1,9728,541184.0 +new-recursion-ungrouped,MultiStark::read_header_vec_n,38,2,23,20,0,0,2,46,306.0 +new-recursion-ungrouped,MultiStark::read_active_n,39,8,11,8,0,0,2,88,1752.0 +new-recursion-ungrouped,MultiStark::read_u8_at,40,8,5,4,0,0,1,40,824.0 +new-recursion-ungrouped,MultiStark::read_digest_vec_at,41,8,7,6,0,0,1,56,1112.0 +new-recursion-ungrouped,MultiStark::read_digest_vec_at_n,42,16,46,16,0,0,2,736,12864.0 +new-recursion-ungrouped,MultiStark::read_u64_vec_vec_n,43,128,11,8,0,0,2,1408,63360.0 +new-recursion-ungrouped,MultiStark::read_u64_vec,44,64,7,6,0,0,1,448,17536.0 +new-recursion-ungrouped,MultiStark::read_u64_vec_n,45,256,18,8,0,0,2,4608,187392.0 +new-recursion-ungrouped,MultiStark::read_message_vec_n,46,1,20,10,0,0,2,20,102.0 +new-recursion-ungrouped,MultiStark::read_proof_vec_n,47,2,34,8,0,0,2,68,300.0 +new-recursion-ungrouped,MultiStark::read_proof,48,1,53,44,0,0,1,53,297.0 +new-recursion-ungrouped,MultiStark::read_ext_vec,49,8,7,6,0,0,1,56,1112.0 +new-recursion-ungrouped,MultiStark::read_ext_vec_n,50,32,27,10,0,0,2,864,20064.0 +new-recursion-ungrouped,MultiStark::read_merkle_cap_vec_n,51,1,11,8,0,0,2,11,69.0 +new-recursion-ungrouped,MultiStark::read_batch_opening_vec_n,52,4,15,12,0,0,2,60,792.0 +new-recursion-ungrouped,MultiStark::read_u64_vec_vec_vec_n,53,64,13,10,0,0,2,832,31872.0 +new-recursion-ungrouped,MultiStark::read_commit_phase_step_vec_n,54,1,15,12,0,0,2,15,93.0 +new-recursion-ungrouped,MultiStark::read_ext_vec_vec,55,4,7,6,0,0,1,28,376.0 +new-recursion-ungrouped,MultiStark::read_ext_vec_vec_n,56,8,11,8,0,0,2,88,1752.0 +new-recursion-ungrouped,MultiStark::read_opened_round,57,4,7,6,0,0,1,28,376.0 +new-recursion-ungrouped,MultiStark::read_opened_round_n,58,8,11,8,0,0,2,88,1752.0 +new-recursion-ungrouped,MultiStark::read_preprocessed,59,1,9,6,0,0,2,9,57.0 +new-recursion-ungrouped,MultiStark::verify_batch,60,1,40,12,0,0,2,40,168.0 +new-recursion-ungrouped,MultiStark::assert_shard_count_ok,61,1,16,6,0,0,2,16,78.0 +new-recursion-ungrouped,"${""name"":""MultiStark::list_length"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::ShardHeader""}}]}",62,4,11,6,0,0,2,44,552.0 +new-recursion-ungrouped,"${""name"":""MultiStark::list_length"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::Proof""}}]}",63,2,31,6,0,0,2,62,270.0 +new-recursion-ungrouped,MultiStark::assert_closure_pairs,64,1,159,34,0,0,2,159,591.0 +new-recursion-ungrouped,MultiStark::three_limbs,65,0,39,10,0,0,1,0,0.0 +new-recursion-ungrouped,MultiStark::bytes8_le,66,0,26,18,0,0,1,0,0.0 +new-recursion-ungrouped,MultiStark::le_step,67,0,11,2,0,0,2,0,0.0 +new-recursion-ungrouped,MultiStark::batch_fiat_shamir,68,1,73,68,0,0,1,73,429.0 +new-recursion-ungrouped,MultiStark::messages_onto,69,1,7,8,0,0,1,7,51.0 +new-recursion-ungrouped,MultiStark::count_onto,70,8,18,6,0,0,2,144,2112.0 +new-recursion-ungrouped,MultiStark::b8_onto,71,128,19,18,0,0,1,2432,105344.0 +new-recursion-ungrouped,"${""name"":""MultiStark::list_length"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::BatchMessage""}}]}",72,4,16,6,0,0,2,64,672.0 +new-recursion-ungrouped,MultiStark::messages_onto_each,73,1,21,14,0,0,1,21,111.0 +new-recursion-ungrouped,"${""name"":""MultiStark::list_length"",""types"":[{""array"":{""element"":""field"",""length"":8}}]}",74,8,15,6,0,0,2,120,1896.0 +new-recursion-ungrouped,MultiStark::limbs_onto,75,32,17,8,0,0,1,544,13088.0 +new-recursion-ungrouped,MultiStark::headers_onto,76,2,13,8,0,0,1,26,146.0 +new-recursion-ungrouped,MultiStark::header_onto,77,1,13,14,0,0,1,13,87.0 +new-recursion-ungrouped,MultiStark::active_onto,78,2,11,10,0,0,1,22,146.0 +new-recursion-ungrouped,MultiStark::cap_onto,79,8,45,16,0,0,1,360,4568.0 +new-recursion-ungrouped,"${""name"":""MultiStark::list_length"",""types"":[""field""]}",80,128,8,6,0,0,2,1024,49920.0 +new-recursion-ungrouped,MultiStark::log_degrees_onto,81,2,10,8,0,0,1,20,128.0 +new-recursion-ungrouped,MultiStark::claims_onto,82,1,7,8,0,0,1,7,51.0 +new-recursion-ungrouped,MultiStark::claims_onto_each,83,2,12,12,0,0,1,24,164.0 +new-recursion-ungrouped,MultiStark::ch_sample_ext,84,8,24,6,0,0,1,192,2336.0 +new-recursion-ungrouped,MultiStark::ch_sample_field,85,16,33,4,0,0,2,528,8064.0 +new-recursion-ungrouped,MultiStark::ch_sample8,86,32,72,54,0,0,2,2304,62784.0 +new-recursion-ungrouped,MultiStark::b3_w4_onto,87,128,11,10,0,0,1,1408,62336.0 +new-recursion-ungrouped,MultiStark::rev_onto,88,512,10,8,0,0,1,5120,278528.0 +new-recursion-ungrouped,"${""name"":""MultiStark::list_concat"",""types"":[""field""]}",89,512,10,8,0,0,1,5120,278528.0 +new-recursion-ungrouped,MultiStark::messages_acc,90,1,32,4,0,0,2,32,120.0 +new-recursion-ungrouped,MultiStark::fingerprint_vals,91,8,20,4,0,0,2,160,2112.0 +new-recursion-ungrouped,MultiStark::verify_shards,92,2,60,6,0,0,2,120,444.0 +new-recursion-ungrouped,MultiStark::verify_shard,93,1,125,100,0,0,1,125,681.0 +new-recursion-ungrouped,"${""name"":""MultiStark::list_length"",""types"":[{""array"":{""element"":""field"",""length"":2}}]}",94,16,9,6,0,0,2,144,3840.0 +new-recursion-ungrouped,MultiStark::assert_bits,95,2,8,4,0,0,2,16,120.0 +new-recursion-ungrouped,MultiStark::select_active_circuits,96,2,22,12,0,0,2,44,252.0 +new-recursion-ungrouped,MultiStark::select_active_prep,97,2,15,12,0,0,2,30,210.0 +new-recursion-ungrouped,MultiStark::assert_same_bits,98,4,11,8,0,0,2,44,600.0 +new-recursion-ungrouped,MultiStark::assert_same_cap,99,2,79,20,0,0,2,158,642.0 +new-recursion-ungrouped,UInt64::eq,100,32,27,2,0,0,2,864,16224.0 +new-recursion-ungrouped,MultiStark::assert_log_degrees_ok,101,2,9,8,0,0,1,18,122.0 +new-recursion-ungrouped,MultiStark::log_degree_ok,102,1,69,2,0,0,2,69,225.0 +new-recursion-ungrouped,MultiStark::count_ones,103,2,8,6,0,0,2,16,132.0 +new-recursion-ungrouped,MultiStark::shard_fiat_shamir,104,1,64,16,0,0,2,64,252.0 +new-recursion-ungrouped,MultiStark::snoc_b8,105,1,14,8,0,0,1,14,72.0 +new-recursion-ungrouped,MultiStark::snoc_cap,106,2,7,8,0,0,1,14,110.0 +new-recursion-ungrouped,MultiStark::accs_onto,107,32,38,14,0,0,2,1216,27264.0 +new-recursion-ungrouped,MultiStark::claims_acc,108,2,22,4,0,0,2,44,204.0 +new-recursion-ungrouped,MultiStark::ood_loop,109,2,153,108,0,0,2,306,1614.0 +new-recursion-ungrouped,"${""name"":""MultiStark::list_lookup"",""types"":[""field""]}",110,64,7,6,0,0,1,448,17536.0 +new-recursion-ungrouped,"${""name"":""MultiStark::list_drop"",""types"":[""field""]}",111,64,9,6,0,0,2,576,22656.0 +new-recursion-ungrouped,MultiStark::quotient_degree_of,112,1,39,2,0,0,2,39,135.0 +new-recursion-ungrouped,"${""name"":""MultiStark::list_lookup"",""types"":[{""array"":{""element"":""field"",""length"":2}}]}",113,16,8,6,0,0,1,128,3136.0 +new-recursion-ungrouped,"${""name"":""MultiStark::list_drop"",""types"":[{""array"":{""element"":""field"",""length"":2}}]}",114,16,10,6,0,0,2,160,4032.0 +new-recursion-ungrouped,MultiStark::ext_exp_pow2,115,1,13,2,0,0,2,13,57.0 +new-recursion-ungrouped,MultiStark::two_adic_gen,116,64,9,2,0,0,2,576,18048.0 +new-recursion-ungrouped,MultiStark::pow2,117,1,6,4,0,0,2,6,42.0 +new-recursion-ungrouped,MultiStark::fold_roots,118,2,31,10,0,0,1,62,266.0 +new-recursion-ungrouped,MultiStark::eval_at,119,8,42,10,0,0,2,336,4128.0 +new-recursion-ungrouped,"${""name"":""MultiStark::list_lookup"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::SysNode""}}]}",120,8,10,6,0,0,1,80,1328.0 +new-recursion-ungrouped,"${""name"":""MultiStark::list_drop"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::SysNode""}}]}",121,8,12,6,0,0,2,96,1680.0 +new-recursion-ungrouped,MultiStark::ood_fold,122,1,10,2,0,0,1,10,42.0 +new-recursion-ungrouped,MultiStark::logup_steps_fold,123,1,94,42,0,0,2,94,420.0 +new-recursion-ungrouped,MultiStark::logup_fingerprint,124,8,35,10,0,0,2,280,3624.0 +new-recursion-ungrouped,MultiStark::pair_mul,125,8,14,2,0,0,1,112,1328.0 +new-recursion-ungrouped,MultiStark::reconstruct_ext_row,126,2,15,12,0,0,2,30,210.0 +new-recursion-ungrouped,MultiStark::from_ext_basis,127,1,6,2,0,0,1,6,30.0 +new-recursion-ungrouped,MultiStark::quotient_eval,128,2,20,4,0,0,2,40,192.0 +new-recursion-ungrouped,MultiStark::prep_count,129,1,5,2,0,0,1,5,27.0 +new-recursion-ungrouped,"${""name"":""MultiStark::list_length"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::CommitPhaseMultiStep""}}]}",130,1,10,6,0,0,2,10,60.0 +new-recursion-ungrouped,MultiStark::round_onto,131,8,10,8,0,0,1,80,1472.0 +new-recursion-ungrouped,MultiStark::points_onto,132,8,10,8,0,0,1,80,1472.0 +new-recursion-ungrouped,MultiStark::pcs_betas,133,1,43,16,0,0,2,43,189.0 +new-recursion-ungrouped,MultiStark::pcs_check_witness,134,1,20,10,0,0,2,20,102.0 +new-recursion-ungrouped,MultiStark::ch_sample_bits,135,16,53,24,0,0,1,848,15232.0 +new-recursion-ungrouped,MultiStark::take_bits,136,32,10,8,0,0,2,320,10944.0 +new-recursion-ungrouped,MultiStark::bits_to_num,137,4,8,6,0,0,2,32,480.0 +new-recursion-ungrouped,MultiStark::obs_log_arities,138,1,10,8,0,0,1,10,60.0 +new-recursion-ungrouped,MultiStark::sample_query_indices,139,32,13,8,0,0,2,416,12384.0 +new-recursion-ungrouped,MultiStark::verify_input_multi,140,1,32,26,0,0,1,32,180.0 +new-recursion-ungrouped,MultiStark::heights_all,141,2,11,8,0,0,2,22,162.0 +new-recursion-ungrouped,MultiStark::mmcs_verify_multi,142,2,23,22,0,0,1,46,290.0 +new-recursion-ungrouped,MultiStark::frontier_sort,143,32,22,14,0,0,1,704,18368.0 +new-recursion-ungrouped,MultiStark::frontier_split,144,64,21,14,0,0,2,1344,45696.0 +new-recursion-ungrouped,MultiStark::frontier_merge,145,32,29,20,0,0,2,928,25824.0 +new-recursion-ungrouped,MultiStark::digest_eq,146,4,74,8,0,0,2,296,2112.0 +new-recursion-ungrouped,MultiStark::assert_same_claims,147,4,12,6,0,0,2,48,576.0 +new-recursion-ungrouped,MultiStark::assert_same_limbs,148,8,26,6,0,0,2,208,2688.0 +new-recursion-ungrouped,MultiStark::frontier_leaves,149,64,16,16,0,0,2,1024,42240.0 +new-recursion-ungrouped,MultiStark::leaf_hash_at,150,2,44,18,0,0,1,88,392.0 +new-recursion-ungrouped,MultiStark::b3_rows_chunks,151,2,230,56,0,0,2,460,1764.0 +new-recursion-ungrouped,MultiStark::rows_pop,152,8,41,8,0,0,2,328,3912.0 +new-recursion-ungrouped,MultiStark::select_rows,153,4,30,14,0,0,2,120,1200.0 +new-recursion-ungrouped,MultiStark::frontier_fold,154,4,12,4,0,0,2,48,528.0 +new-recursion-ungrouped,MultiStark::frontier_level,155,4,38,42,0,0,2,152,2064.0 +new-recursion-ungrouped,MultiStark::select_rows_le,156,4,28,16,0,0,2,112,1200.0 +new-recursion-ungrouped,MultiStark::inject_maybe,157,2,11,4,0,0,2,22,138.0 +new-recursion-ungrouped,MultiStark::has_height,158,2,14,4,0,0,2,28,156.0 +new-recursion-ungrouped,MultiStark::mmcs_compress,159,2,103,14,0,0,1,206,722.0 +new-recursion-ungrouped,MultiStark::compress_ordered,160,0,8,4,0,0,2,0,0.0 +new-recursion-ungrouped,MultiStark::heights_prep,161,0,15,12,0,0,2,0,0.0 +new-recursion-ungrouped,MultiStark::heights_max,162,0,11,8,0,0,2,0,0.0 +new-recursion-ungrouped,MultiStark::drop_index_bits,163,0,11,10,0,0,1,0,0.0 +new-recursion-ungrouped,MultiStark::query_views,164,32,12,6,0,0,2,384,10944.0 +new-recursion-ungrouped,MultiStark::batch_views_at,165,64,12,6,0,0,2,768,26112.0 +new-recursion-ungrouped,MultiStark::step_views_at,166,16,13,6,0,0,2,208,4608.0 +new-recursion-ungrouped,MultiStark::query_loop,167,32,38,12,0,0,2,1216,26304.0 +new-recursion-ungrouped,MultiStark::verify_one_query,168,2,59,20,0,0,2,118,522.0 +new-recursion-ungrouped,MultiStark::build_buckets,169,2,13,6,0,0,2,26,162.0 +new-recursion-ungrouped,MultiStark::circ_has_height,170,1,16,4,0,0,2,16,72.0 +new-recursion-ungrouped,MultiStark::open_batch_2pt,171,8,22,6,0,0,2,176,2400.0 +new-recursion-ungrouped,MultiStark::open_2pt_mat,172,4,20,12,0,0,1,80,832.0 +new-recursion-ungrouped,MultiStark::ri_apply,173,16,24,10,0,0,2,384,7488.0 +new-recursion-ungrouped,MultiStark::exp_by_bits,174,4,13,4,0,0,2,52,552.0 +new-recursion-ungrouped,MultiStark::bucket_update,175,16,31,6,0,0,2,496,8064.0 +new-recursion-ungrouped,MultiStark::ro_fold,176,16,36,4,0,0,2,576,8640.0 +new-recursion-ungrouped,MultiStark::open_quotient,177,4,23,8,0,0,2,92,888.0 +new-recursion-ungrouped,MultiStark::open_prep_batch,178,2,24,14,0,0,1,48,248.0 +new-recursion-ungrouped,MultiStark::open_prep,179,0,27,8,0,0,2,0,0.0 +new-recursion-ungrouped,MultiStark::assert_blowup_zero,180,1,23,4,0,0,2,23,93.0 +new-recursion-ungrouped,MultiStark::verify_query,181,2,98,66,0,0,2,196,1032.0 +new-recursion-ungrouped,"${""name"":""MultiStark::list_length"",""types"":[{""named"":{""args"":[],""name"":""MultiStark::Bucket""}}]}",182,1,12,6,0,0,2,12,66.0 +new-recursion-ungrouped,MultiStark::fri_fold2,183,0,20,6,0,0,2,0,0.0 +new-recursion-ungrouped,MultiStark::rollin,184,0,24,6,0,0,2,0,0.0 +new-recursion-ungrouped,MultiStark::verify_commit_multi,185,1,25,12,0,0,2,25,123.0 +new-recursion-ungrouped,MultiStark::rows_at_round,186,0,13,14,0,0,2,0,0.0 +new-recursion-ungrouped,MultiStark::last_acc,187,1,14,4,0,0,2,14,66.0 +new-recursion-ungrouped,MultiStark::batch_claims,188,2,12,10,0,0,1,24,152.0 +new-recursion-ungrouped,,189,256,2,4,11,256,1,512,50176.0 +new-recursion-ungrouped,,190,65536,7,8,14,65536,2,458752,60555264.0 +new-recursion-ungrouped,,191,1024,1,2,3,1024,1,1024,157696.0 +new-recursion-ungrouped,,192,4096,6,6,0,0,1,24576,2080768.0 +new-recursion-ungrouped,,193,32,7,6,0,0,1,224,7328.0 +new-recursion-ungrouped,,194,1,8,6,0,0,1,8,48.0 +new-recursion-ungrouped,,195,128,9,6,0,0,1,1152,46208.0 +new-recursion-ungrouped,,196,8,10,6,0,0,1,80,1328.0 +new-recursion-ungrouped,,197,1,11,6,0,0,1,11,57.0 +new-recursion-ungrouped,,198,32,13,6,0,0,1,416,10208.0 +new-recursion-ungrouped,,199,2,14,6,0,0,1,28,140.0 +new-recursion-ungrouped,,200,2,29,6,0,0,1,58,230.0 +new-recursion-ungrouped,,201,16,35,6,0,0,1,560,8320.0 +new-recursion-ungrouped,,202,16,37,6,0,0,1,592,8704.0 diff --git a/docs/benchmarks/formal-aiur-grouping/manifest.json b/docs/benchmarks/formal-aiur-grouping/manifest.json new file mode 100644 index 000000000..5df888a24 --- /dev/null +++ b/docs/benchmarks/formal-aiur-grouping/manifest.json @@ -0,0 +1,30 @@ +{ + "base_revision": "9bd5d3ce3dd11142f57a9c1e4acded8c8f3c358e", + "working_tree_modified": true, + "platform": "Linux-7.0.0-1014-aws-x86_64-with-glibc2.39", + "threads": "8", + "thp": "1", + "rustflags": "[build]\nrustflags = [\"-Ctarget-cpu=native\"]", + "artifacts": { + ".lake/formal-integration/ixvm-final.json": "114311f43f6fb39a2d5ccc5c4e6fb279d4eb6c08655cd08731c949e7e537fabf", + ".lake/formal-integration/recursion-final.json": "ae96efa2ce33a07bd79fc5100395aa09a7f3d5f436ae04ee7be2f6bcd71e2afa" + }, + "recursive_input": { + "proof.bin": { + "bytes": 7232210, + "sha256": "12e57eb8e260e0fe6a416b24d2c015c74a1e01006caea3beae87f63dd276c23a" + }, + "key.bin": { + "bytes": 727066, + "sha256": "a1712dc53c8928f7539937085f6b6f904064a533d40cc1e9b9f6ea18d6d05606" + }, + "claims.bin": { + "bytes": 96, + "sha256": "3bf7b58d3da6199546ac0ac885d60323969d3867c08bbfc5ac0e12dacb46a4c9" + }, + "input.json": { + "bytes": 25521014, + "sha256": "2ecf2051d112503637b9d3c1a6201bd66f91df4568a95faff3cef068e3f96a1a" + } + } +} diff --git a/docs/benchmarks/formal-aiur-grouping/runs.json b/docs/benchmarks/formal-aiur-grouping/runs.json new file mode 100644 index 000000000..5d41a9a48 --- /dev/null +++ b/docs/benchmarks/formal-aiur-grouping/runs.json @@ -0,0 +1,482 @@ +{ + "legacy-environment-grouped": { + "thp_disabled": true, + "setup_seconds": 0.076047444, + "samples": [ + { + "trace_with_lookups_seconds": 0.081557777, + "execute_seconds": 0.39694079 + }, + { + "trace_with_lookups_seconds": 0.086292135, + "execute_seconds": 0.397741859 + }, + { + "trace_with_lookups_seconds": 0.084350744, + "execute_seconds": 0.398091789 + }, + { + "trace_with_lookups_seconds": 0.081483986, + "execute_seconds": 0.396436093 + }, + { + "trace_with_lookups_seconds": 0.087176121, + "execute_seconds": 0.400138541 + } + ], + "proof": { + "verified": true, + "prove_including_trace_seconds": 2.449755292, + "bytes": 6854018 + }, + "backend": "legacy-bytecode" + }, + "legacy-environment-ungrouped": { + "thp_disabled": true, + "setup_seconds": 0.06004794, + "samples": [ + { + "trace_with_lookups_seconds": 0.105635153, + "execute_seconds": 0.386776311 + }, + { + "trace_with_lookups_seconds": 0.114584263, + "execute_seconds": 0.388725391 + }, + { + "trace_with_lookups_seconds": 0.098282221, + "execute_seconds": 0.389947833 + }, + { + "trace_with_lookups_seconds": 0.100203899, + "execute_seconds": 0.390350548 + }, + { + "trace_with_lookups_seconds": 0.077690792, + "execute_seconds": 0.393669849 + } + ], + "proof": { + "verified": true, + "prove_including_trace_seconds": 2.903080081, + "bytes": 13641248 + }, + "backend": "legacy-bytecode" + }, + "legacy-ixvm-grouped": { + "thp_disabled": true, + "setup_seconds": 0.079015013, + "samples": [ + { + "trace_with_lookups_seconds": 0.014471597, + "execute_seconds": 0.009000444 + }, + { + "trace_with_lookups_seconds": 0.011531999, + "execute_seconds": 0.009223491 + }, + { + "trace_with_lookups_seconds": 0.011553616, + "execute_seconds": 0.008779689 + }, + { + "trace_with_lookups_seconds": 0.011297992, + "execute_seconds": 0.008808963 + }, + { + "trace_with_lookups_seconds": 0.006547986, + "execute_seconds": 0.008777393 + } + ], + "proof": { + "verified": true, + "prove_including_trace_seconds": 0.294008628, + "bytes": 5669347 + }, + "backend": "legacy-bytecode" + }, + "legacy-ixvm-ungrouped": { + "thp_disabled": true, + "setup_seconds": 0.059585136, + "samples": [ + { + "trace_with_lookups_seconds": 0.014757027, + "execute_seconds": 0.009166877 + }, + { + "trace_with_lookups_seconds": 0.01332742, + "execute_seconds": 0.008943193 + }, + { + "trace_with_lookups_seconds": 0.007992184, + "execute_seconds": 0.00900008 + }, + { + "trace_with_lookups_seconds": 0.008374487, + "execute_seconds": 0.008652334 + }, + { + "trace_with_lookups_seconds": 0.011523387, + "execute_seconds": 0.008857624 + } + ], + "proof": { + "verified": true, + "prove_including_trace_seconds": 0.289305378, + "bytes": 7053239 + }, + "backend": "legacy-bytecode" + }, + "legacy-recursion-grouped": { + "thp_disabled": true, + "setup_seconds": 0.031248566, + "samples": [ + { + "trace_with_lookups_seconds": 0.011727278, + "execute_seconds": 0.00420134 + }, + { + "trace_with_lookups_seconds": 0.010913536, + "execute_seconds": 0.004066102 + }, + { + "trace_with_lookups_seconds": 0.0061596, + "execute_seconds": 0.003901586 + }, + { + "trace_with_lookups_seconds": 0.007437187, + "execute_seconds": 0.004151221 + }, + { + "trace_with_lookups_seconds": 0.012957897, + "execute_seconds": 0.003922958 + } + ], + "proof": { + "verified": true, + "prove_including_trace_seconds": 0.193554784, + "bytes": 3446443 + }, + "backend": "legacy-bytecode" + }, + "legacy-recursion-real-grouped": { + "thp_disabled": true, + "setup_seconds": 0.024223216, + "samples": [ + { + "trace_with_lookups_seconds": 2.255246306, + "execute_seconds": 8.767378601 + }, + { + "trace_with_lookups_seconds": 2.26979904, + "execute_seconds": 8.893816584 + }, + { + "trace_with_lookups_seconds": 2.249765906, + "execute_seconds": 8.821552426 + } + ], + "proof": { + "verified": true, + "prove_including_trace_seconds": 43.336270723, + "bytes": 3706823 + }, + "backend": "legacy-bytecode" + }, + "legacy-recursion-real-ungrouped": { + "thp_disabled": true, + "setup_seconds": 0.021167741, + "samples": [ + { + "trace_with_lookups_seconds": 2.215617275, + "execute_seconds": 8.562322261 + }, + { + "trace_with_lookups_seconds": 2.225973237, + "execute_seconds": 8.614019507 + }, + { + "trace_with_lookups_seconds": 2.238022196, + "execute_seconds": 8.56303241 + } + ], + "proof": null, + "backend": "legacy-bytecode" + }, + "legacy-recursion-ungrouped": { + "thp_disabled": true, + "setup_seconds": 0.030230798, + "samples": [ + { + "trace_with_lookups_seconds": 0.011264631, + "execute_seconds": 0.004155824 + }, + { + "trace_with_lookups_seconds": 0.006123067, + "execute_seconds": 0.003965857 + }, + { + "trace_with_lookups_seconds": 0.007140913, + "execute_seconds": 0.00383872 + }, + { + "trace_with_lookups_seconds": 0.0112362, + "execute_seconds": 0.003970797 + }, + { + "trace_with_lookups_seconds": 0.008653358, + "execute_seconds": 0.003888236 + } + ], + "proof": { + "verified": true, + "prove_including_trace_seconds": 0.214212501, + "bytes": 5522745 + }, + "backend": "legacy-bytecode" + }, + "new-environment-grouped": { + "backend": "new-bytecode", + "prepare_seconds": 0.132464764, + "proof": { + "bytes": 7227058, + "prove_including_trace_seconds": 3.632477276, + "verified": true + }, + "samples": [ + { + "execute_seconds": 0.364449723, + "trace_with_lookups_seconds": 0.154146488 + }, + { + "execute_seconds": 0.349189468, + "trace_with_lookups_seconds": 0.154719896 + }, + { + "execute_seconds": 0.358461287, + "trace_with_lookups_seconds": 0.149352298 + }, + { + "execute_seconds": 0.361377318, + "trace_with_lookups_seconds": 0.149341662 + }, + { + "execute_seconds": 0.360528516, + "trace_with_lookups_seconds": 0.15859383 + } + ], + "setup_seconds": 0.289413644, + "thp_disabled": true + }, + "new-environment-ungrouped": { + "backend": "new-bytecode", + "prepare_seconds": 0.12973461, + "proof": { + "bytes": 13201304, + "prove_including_trace_seconds": 3.9103374520000003, + "verified": true + }, + "samples": [ + { + "execute_seconds": 0.341932683, + "trace_with_lookups_seconds": 0.157360247 + }, + { + "execute_seconds": 0.361428507, + "trace_with_lookups_seconds": 0.14809004 + }, + { + "execute_seconds": 0.354676403, + "trace_with_lookups_seconds": 0.149419147 + }, + { + "execute_seconds": 0.358926832, + "trace_with_lookups_seconds": 0.154093866 + }, + { + "execute_seconds": 0.359224517, + "trace_with_lookups_seconds": 0.147582286 + } + ], + "setup_seconds": 0.277710595, + "thp_disabled": true + }, + "new-ixvm-grouped": { + "backend": "new-bytecode", + "prepare_seconds": 0.133448156, + "proof": { + "bytes": 6320763, + "prove_including_trace_seconds": 0.306254756, + "verified": true + }, + "samples": [ + { + "execute_seconds": 0.005795523, + "trace_with_lookups_seconds": 0.007127367 + }, + { + "execute_seconds": 0.0057252, + "trace_with_lookups_seconds": 0.006028823 + }, + { + "execute_seconds": 0.005897024, + "trace_with_lookups_seconds": 0.006645933 + }, + { + "execute_seconds": 0.006214188, + "trace_with_lookups_seconds": 0.005493144 + }, + { + "execute_seconds": 0.005733797, + "trace_with_lookups_seconds": 0.00646927 + } + ], + "setup_seconds": 0.294222455, + "thp_disabled": true + }, + "new-ixvm-ungrouped": { + "backend": "new-bytecode", + "prepare_seconds": 0.130384313, + "proof": { + "bytes": 7239989, + "prove_including_trace_seconds": 0.319077654, + "verified": true + }, + "samples": [ + { + "execute_seconds": 0.005896784, + "trace_with_lookups_seconds": 0.006270345 + }, + { + "execute_seconds": 0.005690966, + "trace_with_lookups_seconds": 0.006983003 + }, + { + "execute_seconds": 0.005869135, + "trace_with_lookups_seconds": 0.005394423 + }, + { + "execute_seconds": 0.006009078, + "trace_with_lookups_seconds": 0.005384266 + }, + { + "execute_seconds": 0.00604033, + "trace_with_lookups_seconds": 0.006156724 + } + ], + "setup_seconds": 0.274913671, + "thp_disabled": true + }, + "new-recursion-grouped": { + "backend": "new-bytecode", + "prepare_seconds": 0.040501789, + "proof": { + "bytes": 3585743, + "prove_including_trace_seconds": 0.213977614, + "verified": true + }, + "samples": [ + { + "execute_seconds": 0.002884992, + "trace_with_lookups_seconds": 0.004701708 + }, + { + "execute_seconds": 0.002495215, + "trace_with_lookups_seconds": 0.004221867 + }, + { + "execute_seconds": 0.002122304, + "trace_with_lookups_seconds": 0.005382521 + }, + { + "execute_seconds": 0.002042437, + "trace_with_lookups_seconds": 0.006158917 + }, + { + "execute_seconds": 0.002389625, + "trace_with_lookups_seconds": 0.004231292 + } + ], + "setup_seconds": 0.040630288, + "thp_disabled": true + }, + "new-recursion-real-grouped": { + "backend": "new-bytecode", + "prepare_seconds": 0.101803493, + "proof": { + "bytes": 3845899, + "prove_including_trace_seconds": 55.064503669, + "verified": true + }, + "samples": [ + { + "execute_seconds": 7.972376886, + "trace_with_lookups_seconds": 3.553346614 + }, + { + "execute_seconds": 7.9547783899999995, + "trace_with_lookups_seconds": 3.572674917 + }, + { + "execute_seconds": 7.957455595, + "trace_with_lookups_seconds": 3.5628524539999997 + } + ], + "setup_seconds": 0.034483757, + "thp_disabled": true + }, + "new-recursion-real-ungrouped": { + "backend": "new-bytecode", + "prepare_seconds": 0.097651174, + "proof": null, + "samples": [ + { + "execute_seconds": 7.917346044, + "trace_with_lookups_seconds": 3.398995707 + }, + { + "execute_seconds": 7.910016249, + "trace_with_lookups_seconds": 3.323557759 + }, + { + "execute_seconds": 7.9684180829999995, + "trace_with_lookups_seconds": 3.473215938 + } + ], + "setup_seconds": 0.032357274, + "thp_disabled": true + }, + "new-recursion-ungrouped": { + "backend": "new-bytecode", + "prepare_seconds": 0.040377497, + "proof": { + "bytes": 5486185, + "prove_including_trace_seconds": 0.238928249, + "verified": true + }, + "samples": [ + { + "execute_seconds": 0.00239003, + "trace_with_lookups_seconds": 0.006444447 + }, + { + "execute_seconds": 0.002052921, + "trace_with_lookups_seconds": 0.005409143 + }, + { + "execute_seconds": 0.002123758, + "trace_with_lookups_seconds": 0.00515627 + }, + { + "execute_seconds": 0.003619588, + "trace_with_lookups_seconds": 0.004164671 + }, + { + "execute_seconds": 0.002143173, + "trace_with_lookups_seconds": 0.004843126 + } + ], + "setup_seconds": 0.038641642, + "thp_disabled": true + } +} diff --git a/docs/benchmarks/formal-aiur-grouping/summary.csv b/docs/benchmarks/formal-aiur-grouping/summary.csv new file mode 100644 index 000000000..77722ecde --- /dev/null +++ b/docs/benchmarks/formal-aiur-grouping/summary.csv @@ -0,0 +1,17 @@ +run,backend,samples,thp_disabled,execute_seconds,trace_with_lookups_seconds,circuits,active_circuits,stage1_columns,stage2_columns,cells,fft_cost,verified,prove_including_trace_seconds,bytes +legacy-environment-grouped,legacy-bytecode,5,True,0.397741859,0.084350744,222,193,9163,3616,45169839,3617041155,True,2.449755292,6854018 +legacy-environment-ungrouped,legacy-bytecode,5,True,0.389947833,0.100203899,794,540,21351,9962,43419720,3529383826,True,2.903080081,13641248 +legacy-ixvm-grouped,legacy-bytecode,5,True,0.008808963,0.011531999,222,155,9163,3616,1257336,99854452,True,0.294008628,5669347 +legacy-ixvm-ungrouped,legacy-bytecode,5,True,0.008943193,0.011523387,794,281,21351,9962,1188947,97893641,True,0.289305378,7053239 +legacy-recursion-grouped,legacy-bytecode,5,True,0.004066102,0.010913536,84,81,3880,1590,860644,77849696,True,0.193554784,3446443 +legacy-recursion-real-grouped,legacy-bytecode,3,True,8.821552426,2.255246306,84,84,3880,1590,985571600,97838278046,True,43.336270723,3706823 +legacy-recursion-real-ungrouped,legacy-bytecode,3,True,8.56303241,2.225973237,197,197,6359,2754,957602119,95889284097,,, +legacy-recursion-ungrouped,legacy-bytecode,5,True,0.003965857,0.008653358,197,183,6359,2754,776488,75065576,True,0.214212501,5522745 +new-environment-grouped,new-bytecode,5,True,0.360528516,0.154146488,235,200,9650,4194,46656479,3527936909.0,True,3.632477276,7227058 +new-environment-ungrouped,new-bytecode,5,True,0.358926832,0.149419147,799,543,20887,9948,44212339,3403597273.0,True,3.9103374520000003,13201304 +new-ixvm-grouped,new-bytecode,5,True,0.005795523,0.00646927,235,166,9650,4194,1322458,100644448.0,True,0.306254756,6320763 +new-ixvm-ungrouped,new-bytecode,5,True,0.005896784,0.006156724,799,295,20887,9948,1177665,96255407.0,True,0.319077654,7239989 +new-recursion-grouped,new-bytecode,5,True,0.002389625,0.004701708,91,88,4109,1630,826803,74587165.0,True,0.213977614,3585743 +new-recursion-real-grouped,new-bytecode,3,True,7.957455595,3.5628524539999997,91,91,4109,1630,1005868035,89271866275.0,True,55.064503669,3845899 +new-recursion-real-ungrouped,new-bytecode,3,True,7.917346044,3.398995707,203,203,6285,2816,964643478,86483564816.0,,, +new-recursion-ungrouped,new-bytecode,5,True,0.002143173,0.00515627,203,189,6285,2816,715988,71147586.0,True,0.238928249,5486185 diff --git a/docs/benchmarks/formal-aiur-modules/summary.json b/docs/benchmarks/formal-aiur-modules/summary.json new file mode 100644 index 000000000..124c3bf55 --- /dev/null +++ b/docs/benchmarks/formal-aiur-modules/summary.json @@ -0,0 +1,67 @@ +{ + "baseline_revision": "44ea874244a16dd2347c7f2ff1675bad8bc4a258", + "legacy_program_revision": "827550579ea660a4749c520968ad6f58be63acf4", + "legacy_program_sources_unchanged_since_pin": true, + "comparison": "Complete artifacts equal after global renaming, empty-guard removal with PC relocation, and identity trace assignment removal.", + "workloads": { + "ixvm": { + "equivalent_artifacts_modulo_names_and_noops": true, + "functions": 828, + "maps": 10, + "chips": 778, + "groups": 112, + "removed_empty_guards": 3404, + "before_sha256": "1f8c10da7b10587e985d5166b26ad0c7edd4f4cbdfe0978c7deb237cf6683d9a", + "after_sha256": "d2572d9787a384ba6f4e99d45070407182dcbaaa9791480a31c08167120934fa", + "ungrouped_function_columns": 19675 + }, + "recursion": { + "equivalent_artifacts_modulo_names_and_noops": true, + "functions": 224, + "maps": 10, + "chips": 189, + "groups": 39, + "removed_empty_guards": 390, + "before_sha256": "40e88dd1f84e4f119626189e83f8eb181f6ef9875c190f33cdd7853e83c5afe1", + "after_sha256": "53a2fe4442dd1db1b082c54ac425930cf4746c1268a2f92f261acfc9e2bba1a3", + "ungrouped_function_columns": 5907 + }, + "aggregate": { + "equivalent_artifacts_modulo_names_and_noops": true, + "functions": 285, + "maps": 10, + "chips": 245, + "groups": 39, + "removed_empty_guards": 528, + "before_sha256": "50638b554026d4db272e725cf07f70d27b280ca9e62b0323a197fa572f21cb60", + "after_sha256": "aa69584ed7f0e746094f46f367c27d72c3178030a048be86a960436f0ba08f0d", + "ungrouped_function_columns": 7878 + } + }, + "library_validation": { + "native_table_reference_trace_comparisons": 2586, + "rejected_dishonest_hint_proofs": 2, + "verified_u64_blake3_proofs": 2, + "lean_u8_u32_u64_domain_opacity_tests": "passed", + "abstract_signature_clients_and_opaque_hint_rejections": "passed" + }, + "integration_validation": { + "lean_packages_and_cli_build": "passed", + "ixvm_valid_invalid_claims_and_legacy_bytecode_check": "passed", + "recursive_proof_and_negative_cases": "passed", + "aggregation_shapes_and_negative_cases": "passed", + "controller": { + "success": true, + "commands": 19, + "report": ".lake/modular-library/integration/controller-check-wa8xjhpn/report.json" + }, + "cpu_parity": { + "success": true, + "workloads": 3, + "hardware_validated": false, + "report": ".lake/modular-library/integration/cuda-check-gmcsnb_g/report.json" + }, + "clippy_and_format": "passed", + "note": "Initial controller run found the old check_owned name; after adding old/new name compatibility, the controller gate passed. The CPU parity gate was then completed separately." + } +} diff --git a/docs/benchmarks/formal-aiur-rom-reuse/circuits.json b/docs/benchmarks/formal-aiur-rom-reuse/circuits.json new file mode 100644 index 000000000..bed9c4d70 --- /dev/null +++ b/docs/benchmarks/formal-aiur-rom-reuse/circuits.json @@ -0,0 +1,710 @@ +{ + "recursion-real-new": [ + {"cells":219,"fft_cost":951.0,"height":1,"index":0,"lookup_group_size":1,"lookups":48,"name":"MultiStark::verify_multi_stark_proof","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":219,"stage2_width":96}, + {"cells":14680064,"fft_cost":1648361472.0,"height":1048576,"index":1,"lookup_group_size":1,"lookups":4,"name":"verifier_group_00","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":14,"stage2_width":8}, + {"cells":1433600,"fft_cost":66232320.0,"height":8192,"index":2,"lookup_group_size":1,"lookups":14,"name":"verifier_group_01","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":175,"stage2_width":28}, + {"cells":3719168,"fft_cost":233472000.0,"height":16384,"index":3,"lookup_group_size":1,"lookups":54,"name":"verifier_group_02","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":227,"stage2_width":108}, + {"cells":525336576,"fft_cost":46003126272.0,"height":1048576,"index":4,"lookup_group_size":2,"lookups":226,"name":"Blake3::compress","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":501,"stage2_width":226}, + {"cells":35651584,"fft_cost":3592421376.0,"height":2097152,"index":5,"lookup_group_size":2,"lookups":6,"name":"Blake3::compress_chunks","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":6}, + {"cells":106496,"fft_cost":5566464.0,"height":2048,"index":6,"lookup_group_size":1,"lookups":13,"name":"verifier_group_03","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":52,"stage2_width":26}, + {"cells":4685824,"fft_cost":408846336.0,"height":32768,"index":7,"lookup_group_size":1,"lookups":65,"name":"verifier_group_04","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":143,"stage2_width":130}, + {"cells":8192,"fft_cost":503808.0,"height":1024,"index":8,"lookup_group_size":2,"lookups":3,"name":"Blake3::pad_block","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":4}, + {"cells":31457280,"fft_cost":2006974464.0,"height":131072,"index":9,"lookup_group_size":1,"lookups":28,"name":"verifier_group_05","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":240,"stage2_width":56}, + {"cells":5898240,"fft_cost":502923264.0,"height":131072,"index":10,"lookup_group_size":1,"lookups":13,"name":"verifier_group_06","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":45,"stage2_width":26}, + {"cells":247808,"fft_cost":9824256.0,"height":2048,"index":11,"lookup_group_size":1,"lookups":10,"name":"verifier_group_07","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":121,"stage2_width":20}, + {"cells":655360,"fft_cost":63700992.0,"height":65536,"index":12,"lookup_group_size":1,"lookups":3,"name":"verifier_group_08","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":6}, + {"cells":5242880,"fft_cost":696254464.0,"height":1048576,"index":13,"lookup_group_size":1,"lookups":2,"name":"MultiStark::read_vk_u8","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":5,"stage2_width":4}, + {"cells":1982464,"fft_cost":133005312.0,"height":16384,"index":14,"lookup_group_size":1,"lookups":34,"name":"verifier_group_09","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":121,"stage2_width":68}, + {"cells":122880,"fft_cost":6832128.0,"height":4096,"index":15,"lookup_group_size":1,"lookups":6,"name":"verifier_group_10","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":30,"stage2_width":12}, + {"cells":655360,"fft_cost":74055680.0,"height":131072,"index":16,"lookup_group_size":1,"lookups":2,"name":"MultiStark::read_vk_tag","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":5,"stage2_width":4}, + {"cells":5767168,"fft_cost":563085312.0,"height":131072,"index":17,"lookup_group_size":1,"lookups":18,"name":"MultiStark::read_nodes_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":44,"stage2_width":36}, + {"cells":32505856,"fft_cost":3095396352.0,"height":1048576,"index":18,"lookup_group_size":1,"lookups":7,"name":"verifier_group_11","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":31,"stage2_width":14}, + {"cells":720896,"fft_cost":73138176.0,"height":65536,"index":19,"lookup_group_size":1,"lookups":4,"name":"MultiStark::read_node_ids_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":8}, + {"cells":23552,"fft_cost":1148928.0,"height":1024,"index":20,"lookup_group_size":1,"lookups":5,"name":"verifier_group_12","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":10}, + {"cells":81920,"fft_cost":4349952.0,"height":2048,"index":21,"lookup_group_size":1,"lookups":10,"name":"verifier_group_13","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":40,"stage2_width":20}, + {"cells":114688,"fft_cost":5947392.0,"height":4096,"index":22,"lookup_group_size":1,"lookups":4,"name":"verifier_group_14","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":28,"stage2_width":8}, + {"cells":6528,"fft_cost":176256.0,"height":128,"index":23,"lookup_group_size":1,"lookups":5,"name":"verifier_group_15","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":51,"stage2_width":10}, + {"cells":1638400,"fft_cost":148635648.0,"height":65536,"index":24,"lookup_group_size":1,"lookups":9,"name":"verifier_group_16","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":25,"stage2_width":18}, + {"cells":9216,"fft_cost":595968.0,"height":1024,"index":25,"lookup_group_size":1,"lookups":3,"name":"verifier_group_17","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":6}, + {"cells":122880,"fft_cost":6242304.0,"height":4096,"index":26,"lookup_group_size":1,"lookups":4,"name":"verifier_group_18","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":30,"stage2_width":8}, + {"cells":20971520,"fft_cost":2654994432.0,"height":1048576,"index":27,"lookup_group_size":1,"lookups":9,"name":"verifier_group_19","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":18}, + {"cells":720896,"fft_cost":73138176.0,"height":65536,"index":28,"lookup_group_size":1,"lookups":4,"name":"MultiStark::read_u64_vec_vec_n","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":8}, + {"cells":20971520,"fft_cost":2025848832.0,"height":1048576,"index":29,"lookup_group_size":1,"lookups":4,"name":"verifier_group_20","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":8}, + {"cells":1081344,"fft_cost":69697536.0,"height":32768,"index":30,"lookup_group_size":1,"lookups":5,"name":"verifier_group_21","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":33,"stage2_width":10}, + {"cells":1245184,"fft_cost":104595456.0,"height":65536,"index":31,"lookup_group_size":1,"lookups":5,"name":"verifier_group_22","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":10}, + {"cells":53248,"fft_cost":2863104.0,"height":2048,"index":32,"lookup_group_size":1,"lookups":6,"name":"verifier_group_23","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":26,"stage2_width":12}, + {"cells":38912,"fft_cost":2119680.0,"height":2048,"index":33,"lookup_group_size":1,"lookups":4,"name":"verifier_group_24","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":8}, + {"cells":622592,"fft_cost":46104576.0,"height":32768,"index":34,"lookup_group_size":1,"lookups":4,"name":"verifier_group_25","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":8}, + {"cells":1048576,"fft_cost":75890688.0,"height":16384,"index":35,"lookup_group_size":1,"lookups":21,"name":"verifier_group_26","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":64,"stage2_width":42}, + {"cells":294912,"fft_cost":19267584.0,"height":8192,"index":36,"lookup_group_size":1,"lookups":10,"name":"verifier_group_27","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":36,"stage2_width":20}, + {"cells":1245184,"fft_cost":122945536.0,"height":65536,"index":37,"lookup_group_size":1,"lookups":9,"name":"MultiStark::b8_onto","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":19,"stage2_width":18}, + {"cells":16777216,"fft_cost":1648361472.0,"height":1048576,"index":38,"lookup_group_size":1,"lookups":3,"name":"verifier_group_28","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":16,"stage2_width":6}, + {"cells":507904,"fft_cost":35291136.0,"height":16384,"index":39,"lookup_group_size":1,"lookups":8,"name":"verifier_group_29","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":31,"stage2_width":16}, + {"cells":19968,"fft_cost":838656.0,"height":256,"index":40,"lookup_group_size":1,"lookups":27,"name":"verifier_group_30","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":78,"stage2_width":54}, + {"cells":11264,"fft_cost":371712.0,"height":256,"index":41,"lookup_group_size":1,"lookups":6,"name":"verifier_group_31","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":44,"stage2_width":12}, + {"cells":20480,"fft_cost":1359872.0,"height":2048,"index":42,"lookup_group_size":1,"lookups":4,"name":"${\"name\":\"MultiStark::list_concat\",\"types\":[\"field\"]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":8}, + {"cells":622592,"fft_cost":49053696.0,"height":32768,"index":43,"lookup_group_size":1,"lookups":5,"name":"verifier_group_32","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":10}, + {"cells":983040,"fft_cost":59375616.0,"height":32768,"index":44,"lookup_group_size":1,"lookups":3,"name":"verifier_group_33","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":30,"stage2_width":6}, + {"cells":5636096,"fft_cost":409337856.0,"height":131072,"index":45,"lookup_group_size":1,"lookups":7,"name":"verifier_group_34","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":43,"stage2_width":14}, + {"cells":576,"fft_cost":18048.0,"height":64,"index":46,"lookup_group_size":2,"lookups":2,"name":"MultiStark::two_adic_gen","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":2}, + {"cells":5767168,"fft_cost":389283840.0,"height":131072,"index":47,"lookup_group_size":1,"lookups":5,"name":"verifier_group_35","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":44,"stage2_width":10}, + {"cells":1703936,"fft_cost":155320320.0,"height":131072,"index":48,"lookup_group_size":1,"lookups":3,"name":"verifier_group_36","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":6}, + {"cells":294912,"fft_cost":22216704.0,"height":16384,"index":49,"lookup_group_size":1,"lookups":5,"name":"verifier_group_37","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":10}, + {"cells":3392,"fft_cost":91264.0,"height":64,"index":50,"lookup_group_size":1,"lookups":12,"name":"MultiStark::ch_sample_bits","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":53,"stage2_width":24}, + {"cells":20480,"fft_cost":1511424.0,"height":2048,"index":51,"lookup_group_size":1,"lookups":4,"name":"MultiStark::take_bits","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":8}, + {"cells":42991616,"fft_cost":3347054592.0,"height":1048576,"index":52,"lookup_group_size":2,"lookups":8,"name":"MultiStark::rows_pop","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":41,"stage2_width":8}, + {"cells":83886080,"fft_cost":7159676928.0,"height":2097152,"index":53,"lookup_group_size":1,"lookups":5,"name":"verifier_group_38","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":40,"stage2_width":10}, + {"cells":512,"fft_cost":50176.0,"height":256,"index":54,"lookup_group_size":1,"lookups":2,"name":"","preprocessed_height":256,"preprocessed_width":11,"quotient_degree":1,"stage1_width":2,"stage2_width":4}, + {"cells":458752,"fft_cost":60555264.0,"height":65536,"index":55,"lookup_group_size":2,"lookups":7,"name":"","preprocessed_height":65536,"preprocessed_width":14,"quotient_degree":2,"stage1_width":7,"stage2_width":8}, + {"cells":1024,"fft_cost":157696.0,"height":1024,"index":56,"lookup_group_size":1,"lookups":1,"name":"","preprocessed_height":1024,"preprocessed_width":3,"quotient_degree":1,"stage1_width":1,"stage2_width":2}, + {"cells":25165824,"fft_cost":3892314112.0,"height":4194304,"index":57,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":6,"stage2_width":6}, + {"cells":229376,"fft_cost":22249472.0,"height":32768,"index":58,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":6}, + {"cells":256,"fft_cost":7808.0,"height":32,"index":59,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":8,"stage2_width":6}, + {"cells":2359296,"fft_cost":241696768.0,"height":262144,"index":60,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":9,"stage2_width":6}, + {"cells":10485760,"fft_cost":1136656384.0,"height":1048576,"index":61,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":6}, + {"cells":11264,"fft_cost":587776.0,"height":1024,"index":62,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":6}, + {"cells":13631488,"fft_cost":1325400064.0,"height":1048576,"index":63,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":13,"stage2_width":6}, + {"cells":7168,"fft_cost":306176.0,"height":512,"index":64,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":14,"stage2_width":6}, + {"cells":58,"fft_cost":230.0,"height":2,"index":65,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":29,"stage2_width":6}, + {"cells":4587520,"fft_cost":287965184.0,"height":131072,"index":66,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":35,"stage2_width":6}, + {"cells":606208,"fft_cost":31031296.0,"height":16384,"index":67,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":37,"stage2_width":6} + ], + "recursion-real-legacy": [ + {"stage2_width":14,"stage1_width":68,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[0,2,11,12,96,119,120,121,122,164,180,188],"index":0,"height":262144,"fft_cost":1220542464,"cells":17825792}, + {"stage2_width":2,"stage1_width":27,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[10],"index":1,"height":16,"fft_cost":6528,"cells":432}, + {"stage2_width":12,"stage1_width":46,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[24,38,88,90,97,141,182,189,203,204,205,247],"index":2,"height":8192,"fft_cost":19906560,"cells":376832}, + {"stage2_width":28,"stage1_width":207,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[25,73,74,89,125,136,148,157,165,173,174,177,194],"index":3,"height":32768,"fft_cost":352813056,"cells":6782976}, + {"stage2_width":64,"stage1_width":133,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[26,46,54,57,59,108,137,155,170,176,201,237,245,251],"index":4,"height":16384,"fft_cost":138510336,"cells":2179072}, + {"stage2_width":6,"stage1_width":16,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[29,255],"index":5,"height":262144,"fft_cost":371195904,"cells":4194304}, + {"stage2_width":10,"stage1_width":39,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[33,43,47,105,124,138,149,151,159,160,163,175],"index":6,"height":8192,"fft_cost":17031168,"cells":319488}, + {"stage2_width":6,"stage1_width":9,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[34,241],"index":7,"height":131072,"fft_cost":128581632,"cells":1179648}, + {"stage2_width":6,"stage1_width":18,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[35],"index":8,"height":1048576,"fft_cost":1774190592,"cells":18874368}, + {"stage2_width":8,"stage1_width":31,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[36,44,45,77,87,110,118,127,132,133,171],"index":9,"height":32768,"fft_cost":63799296,"cells":1015808}, + {"stage2_width":6,"stage1_width":34,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[37,192],"index":10,"height":65536,"fft_cost":139198464,"cells":2228224}, + {"stage2_width":18,"stage1_width":81,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[39,50,102,116,128,135,139,154,158,161,178,183,185,197,252],"index":11,"height":16384,"fft_cost":71073792,"cells":1327104}, + {"stage2_width":8,"stage1_width":13,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[41,94],"index":12,"height":131072,"fft_cost":168689664,"cells":1703936}, + {"stage2_width":22,"stage1_width":53,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[60],"index":13,"height":1,"fft_cost":237,"cells":53}, + {"stage2_width":20,"stage1_width":23,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[63],"index":14,"height":2,"fft_cost":306,"cells":46}, + {"stage2_width":8,"stage1_width":20,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[66],"index":15,"height":32,"fft_cost":15744,"cells":640}, + {"stage2_width":8,"stage1_width":34,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[68],"index":16,"height":2,"fft_cost":300,"cells":68}, + {"stage2_width":8,"stage1_width":17,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[75],"index":17,"height":2097152,"fft_cost":3856662528,"cells":35651584}, + {"stage2_width":130,"stage1_width":238,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[76,78,79,100,172,200],"index":18,"height":65536,"fft_cost":1170997248,"cells":15597568}, + {"stage2_width":388,"stage1_width":533,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[83],"index":19,"height":1048576,"fft_cost":58208550912,"cells":558891008}, + {"stage2_width":4,"stage1_width":6,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[84],"index":20,"height":1048576,"fft_cost":893386752,"cells":6291456}, + {"stage2_width":4,"stage1_width":5,"quotient_degree":1,"preprocessed_width":0,"preprocessed_height":0,"members":[85],"index":21,"height":131072,"fft_cost":74055680,"cells":655360}, + {"stage2_width":6,"stage1_width":7,"quotient_degree":1,"preprocessed_width":0,"preprocessed_height":0,"members":[86],"index":22,"height":524288,"fft_cost":450363392,"cells":3670016}, + {"stage2_width":40,"stage1_width":108,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[92,101,142,150,156,162,198,202,235,244],"index":23,"height":128,"fft_cost":410112,"cells":13824}, + {"stage2_width":16,"stage1_width":44,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[93],"index":24,"height":131072,"fft_cost":429391872,"cells":5767168}, + {"stage2_width":4,"stage1_width":14,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[109,187],"index":25,"height":32768,"fft_cost":32833536,"cells":458752}, + {"stage2_width":12,"stage1_width":30,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[111],"index":26,"height":1048576,"fft_cost":2906652672,"cells":31457280}, + {"stage2_width":26,"stage1_width":48,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[112,123,131],"index":27,"height":131072,"fft_cost":522977280,"cells":6291456}, + {"stage2_width":12,"stage1_width":30,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[113],"index":28,"height":1048576,"fft_cost":2906652672,"cells":31457280}, + {"stage2_width":42,"stage1_width":226,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[114],"index":29,"height":131072,"fft_cost":1819803648,"cells":29622272}, + {"stage2_width":8,"stage1_width":18,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[117,126,250,254],"index":30,"height":65536,"fft_cost":95158272,"cells":1179648}, + {"stage2_width":8,"stage1_width":37,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[130],"index":31,"height":2097152,"fft_cost":6499074048,"cells":77594624}, + {"stage2_width":8,"stage1_width":30,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[140],"index":32,"height":1048576,"fft_cost":2654994432,"cells":31457280}, + {"stage2_width":10,"stage1_width":30,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[143],"index":33,"height":65536,"fft_cost":139198464,"cells":1966080}, + {"stage2_width":14,"stage1_width":45,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[144,145,146,147,191,193],"index":34,"height":131072,"fft_cost":422707200,"cells":5898240}, + {"stage2_width":10,"stage1_width":19,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[168],"index":35,"height":65536,"fft_cost":104595456,"cells":1245184}, + {"stage2_width":8,"stage1_width":43,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[190],"index":36,"height":131072,"fft_cost":369229824,"cells":5636096}, + {"stage2_width":6,"stage1_width":18,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[206],"index":37,"height":64,"fft_cost":33024,"cells":1152}, + {"stage2_width":4,"stage1_width":7,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[207],"index":38,"height":1,"fft_cost":45,"cells":7}, + {"stage2_width":12,"stage1_width":12,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[208],"index":39,"height":2,"fft_cost":192,"cells":24}, + {"stage2_width":14,"stage1_width":13,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[209],"index":40,"height":1,"fft_cost":93,"cells":13}, + {"stage2_width":8,"stage1_width":13,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[210],"index":41,"height":2,"fft_cost":174,"cells":26}, + {"stage2_width":4,"stage1_width":7,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[211],"index":42,"height":1,"fft_cost":45,"cells":7}, + {"stage2_width":14,"stage1_width":21,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[212],"index":43,"height":32,"fft_cost":19104,"cells":672}, + {"stage2_width":30,"stage1_width":69,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[213],"index":44,"height":1,"fft_cost":309,"cells":69}, + {"stage2_width":14,"stage1_width":62,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[214],"index":45,"height":1,"fft_cost":240,"cells":62}, + {"stage2_width":8,"stage1_width":12,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[215],"index":46,"height":512,"fft_cost":337920,"cells":6144}, + {"stage2_width":10,"stage1_width":27,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[216],"index":47,"height":16,"fft_cost":8064,"cells":432}, + {"stage2_width":10,"stage1_width":13,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[217],"index":48,"height":2,"fft_cost":186,"cells":26}, + {"stage2_width":20,"stage1_width":80,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[218],"index":49,"height":2,"fft_cost":648,"cells":160}, + {"stage2_width":8,"stage1_width":15,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[219],"index":50,"height":256,"fft_cost":168960,"cells":3840}, + {"stage2_width":8,"stage1_width":35,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[220],"index":51,"height":32,"fft_cost":22944,"cells":1120}, + {"stage2_width":2,"stage1_width":69,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[221],"index":52,"height":32,"fft_cost":36384,"cells":2208}, + {"stage2_width":8,"stage1_width":9,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[222],"index":53,"height":256,"fft_cost":132096,"cells":2304}, + {"stage2_width":6,"stage1_width":8,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[223],"index":54,"height":256,"fft_cost":113664,"cells":2048}, + {"stage2_width":6,"stage1_width":20,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[224],"index":55,"height":1,"fft_cost":90,"cells":20}, + {"stage2_width":10,"stage1_width":43,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[225],"index":56,"height":32,"fft_cost":27744,"cells":1376}, + {"stage2_width":2,"stage1_width":9,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[226],"index":57,"height":64,"fft_cost":18048,"cells":576}, + {"stage2_width":10,"stage1_width":26,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[227],"index":58,"height":64,"fft_cost":46848,"cells":1664}, + {"stage2_width":66,"stage1_width":161,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[228],"index":59,"height":16,"fft_cost":44544,"cells":2576}, + {"stage2_width":108,"stage1_width":142,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[229],"index":60,"height":1,"fft_cost":762,"cells":142}, + {"stage2_width":10,"stage1_width":61,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[230],"index":61,"height":2,"fft_cost":474,"cells":122}, + {"stage2_width":8,"stage1_width":12,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[231],"index":62,"height":2,"fft_cost":168,"cells":24}, + {"stage2_width":22,"stage1_width":41,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[232],"index":63,"height":1,"fft_cost":201,"cells":41}, + {"stage2_width":42,"stage1_width":218,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[238],"index":64,"height":1,"fft_cost":792,"cells":218}, + {"stage2_width":6,"stage1_width":13,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[239,242,253],"index":65,"height":131072,"fft_cost":155320320,"cells":1703936}, + {"stage2_width":6,"stage1_width":31,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[240],"index":66,"height":2,"fft_cost":270,"cells":62}, + {"stage2_width":8,"stage1_width":10,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[243],"index":67,"height":2048,"fft_cost":1511424,"cells":20480}, + {"stage2_width":6,"stage1_width":15,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[246],"index":68,"height":1048576,"fft_cost":1585446912,"cells":15728640}, + {"stage2_width":6,"stage1_width":11,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[248],"index":69,"height":131072,"fft_cost":141950976,"cells":1441792}, + {"stage2_width":4,"stage1_width":7,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[249],"index":70,"height":32768,"fft_cost":22511616,"cells":229376}, + {"stage2_width":6,"stage1_width":6,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":71,"height":4194304,"fft_cost":4479516672,"cells":25165824}, + {"stage2_width":6,"stage1_width":7,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":72,"height":32768,"fft_cost":25460736,"cells":229376}, + {"stage2_width":6,"stage1_width":8,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":73,"height":32,"fft_cost":9024,"cells":256}, + {"stage2_width":6,"stage1_width":9,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":74,"height":262144,"fft_cost":272105472,"cells":2359296}, + {"stage2_width":6,"stage1_width":10,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":75,"height":1048576,"fft_cost":1270874112,"cells":10485760}, + {"stage2_width":6,"stage1_width":11,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":76,"height":1024,"fft_cost":657408,"cells":11264}, + {"stage2_width":6,"stage1_width":13,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":77,"height":1048576,"fft_cost":1459617792,"cells":13631488}, + {"stage2_width":6,"stage1_width":14,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":78,"height":512,"fft_cost":337920,"cells":7168}, + {"stage2_width":6,"stage1_width":29,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":79,"height":2,"fft_cost":258,"cells":58}, + {"stage2_width":6,"stage1_width":35,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":80,"height":131072,"fft_cost":302383104,"cells":4587520}, + {"stage2_width":6,"stage1_width":37,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":81,"height":16384,"fft_cost":32538624,"cells":606208}, + {"stage2_width":6,"stage1_width":3,"quotient_degree":1,"preprocessed_width":11,"preprocessed_height":256,"members":[],"index":82,"height":256,"fft_cost":68608,"cells":768}, + {"stage2_width":8,"stage1_width":8,"quotient_degree":2,"preprocessed_width":11,"preprocessed_height":65536,"members":[],"index":83,"height":65536,"fft_cost":63700992,"cells":524288} + ], + "environment-new": [ + {"cells":10,"fft_cost":48.0,"height":1,"index":0,"lookup_group_size":1,"lookups":2,"name":"IxVM::verify_claim","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":4}, + {"cells":28288,"fft_cost":740736.0,"height":128,"index":1,"lookup_group_size":1,"lookups":25,"name":"ixvm_group_00","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":221,"stage2_width":50}, + {"cells":55296,"fft_cost":2930688.0,"height":2048,"index":2,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_01","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":12}, + {"cells":1572864,"fft_cost":162004992.0,"height":131072,"index":3,"lookup_group_size":1,"lookups":4,"name":"ixvm_group_02","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":8}, + {"cells":1441792,"fft_cost":155320320.0,"height":131072,"index":4,"lookup_group_size":1,"lookups":4,"name":"ixvm_group_03","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":8}, + {"cells":229376,"fft_cost":20709376.0,"height":16384,"index":5,"lookup_group_size":1,"lookups":7,"name":"UInt32::less_than_fields","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":14,"stage2_width":14}, + {"cells":305152,"fft_cost":11716608.0,"height":2048,"index":6,"lookup_group_size":1,"lookups":10,"name":"ixvm_group_04","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":149,"stage2_width":20}, + {"cells":16416768,"fft_cost":1078296576.0,"height":32768,"index":7,"lookup_group_size":2,"lookups":226,"name":"Blake3::compress","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":501,"stage2_width":226}, + {"cells":2228224,"fft_cost":182059008.0,"height":131072,"index":8,"lookup_group_size":2,"lookups":6,"name":"Blake3::compress_chunks","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":6}, + {"cells":356352,"fft_cost":13946880.0,"height":2048,"index":9,"lookup_group_size":1,"lookups":14,"name":"ixvm_group_05","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":174,"stage2_width":28}, + {"cells":13312,"fft_cost":448512.0,"height":512,"index":10,"lookup_group_size":1,"lookups":1,"name":"ixvm_group_06","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":26,"stage2_width":2}, + {"cells":593920,"fft_cost":41189376.0,"height":4096,"index":11,"lookup_group_size":1,"lookups":65,"name":"ixvm_group_07","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":145,"stage2_width":130}, + {"cells":370688,"fft_cost":15771648.0,"height":2048,"index":12,"lookup_group_size":1,"lookups":24,"name":"ixvm_group_08","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":181,"stage2_width":48}, + {"cells":14336,"fft_cost":886784.0,"height":2048,"index":13,"lookup_group_size":1,"lookups":2,"name":"${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":4}, + {"cells":4800,"fft_cost":107904.0,"height":64,"index":14,"lookup_group_size":1,"lookups":7,"name":"ixvm_group_09","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":75,"stage2_width":14}, + {"cells":884736,"fft_cost":60850176.0,"height":32768,"index":15,"lookup_group_size":1,"lookups":5,"name":"ixvm_group_10","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":10}, + {"cells":55296,"fft_cost":2930688.0,"height":2048,"index":16,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_11","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":12}, + {"cells":0,"fft_cost":0.0,"height":0,"index":17,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_12","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":71,"stage2_width":12}, + {"cells":0,"fft_cost":0.0,"height":0,"index":18,"lookup_group_size":1,"lookups":19,"name":"ixvm_group_13","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":92,"stage2_width":38}, + {"cells":17920,"fft_cost":764928.0,"height":128,"index":19,"lookup_group_size":1,"lookups":70,"name":"ixvm_group_14","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":140,"stage2_width":140}, + {"cells":57344,"fft_cost":4890624.0,"height":8192,"index":20,"lookup_group_size":1,"lookups":2,"name":"ixvm_group_15","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":7,"stage2_width":4}, + {"cells":139264,"fft_cost":9334784.0,"height":2048,"index":21,"lookup_group_size":1,"lookups":34,"name":"IxVM::get_address","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":68,"stage2_width":68}, + {"cells":20992,"fft_cost":877056.0,"height":512,"index":22,"lookup_group_size":1,"lookups":9,"name":"ixvm_group_16","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":41,"stage2_width":18}, + {"cells":53248,"fft_cost":3403776.0,"height":2048,"index":23,"lookup_group_size":1,"lookups":10,"name":"ixvm_group_17","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":26,"stage2_width":20}, + {"cells":98304,"fft_cost":4927488.0,"height":1024,"index":24,"lookup_group_size":1,"lookups":30,"name":"ixvm_group_18","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":96,"stage2_width":60}, + {"cells":115712,"fft_cost":4220928.0,"height":1024,"index":25,"lookup_group_size":1,"lookups":10,"name":"ixvm_group_19","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":113,"stage2_width":20}, + {"cells":42496,"fft_cost":1457664.0,"height":512,"index":26,"lookup_group_size":1,"lookups":9,"name":"ixvm_group_20","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":83,"stage2_width":18}, + {"cells":8512,"fft_cost":234624.0,"height":64,"index":27,"lookup_group_size":1,"lookups":33,"name":"ixvm_group_21","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":133,"stage2_width":66}, + {"cells":262144,"fft_cost":17350656.0,"height":8192,"index":28,"lookup_group_size":1,"lookups":9,"name":"ixvm_group_22","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":32,"stage2_width":18}, + {"cells":1232,"fft_cost":7920.0,"height":4,"index":29,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_23","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":308,"stage2_width":16}, + {"cells":1998848,"fft_cost":131629056.0,"height":32768,"index":30,"lookup_group_size":1,"lookups":12,"name":"ixvm_group_24","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":61,"stage2_width":24}, + {"cells":2560,"fft_cost":76800.0,"height":128,"index":31,"lookup_group_size":1,"lookups":2,"name":"UInt64::saturating_pred","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":4}, + {"cells":475136,"fft_cost":31162368.0,"height":16384,"index":32,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_25","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":29,"stage2_width":12}, + {"cells":167936,"fft_cost":9043968.0,"height":4096,"index":33,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_26","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":41,"stage2_width":16}, + {"cells":204800,"fft_cost":13197312.0,"height":8192,"index":34,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_27","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":25,"stage2_width":12}, + {"cells":50176,"fft_cost":2562048.0,"height":1024,"index":35,"lookup_group_size":1,"lookups":15,"name":"ixvm_group_28","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":49,"stage2_width":30}, + {"cells":25600,"fft_cost":1394688.0,"height":1024,"index":36,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_29","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":25,"stage2_width":16}, + {"cells":75776,"fft_cost":3876864.0,"height":2048,"index":37,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_30","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":37,"stage2_width":16}, + {"cells":688128,"fft_cost":57999360.0,"height":16384,"index":38,"lookup_group_size":1,"lookups":19,"name":"ixvm_group_31","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":42,"stage2_width":38}, + {"cells":34304,"fft_cost":1236480.0,"height":512,"index":39,"lookup_group_size":1,"lookups":9,"name":"ixvm_group_32","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":67,"stage2_width":18}, + {"cells":28672,"fft_cost":900096.0,"height":256,"index":40,"lookup_group_size":1,"lookups":15,"name":"ixvm_group_33","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":112,"stage2_width":30}, + {"cells":14848,"fft_cost":600576.0,"height":512,"index":41,"lookup_group_size":1,"lookups":5,"name":"ixvm_group_34","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":29,"stage2_width":10}, + {"cells":20480,"fft_cost":592896.0,"height":256,"index":42,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_35","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":80,"stage2_width":12}, + {"cells":17920,"fft_cost":629760.0,"height":256,"index":43,"lookup_group_size":1,"lookups":14,"name":"ixvm_group_36","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":70,"stage2_width":28}, + {"cells":18944,"fft_cost":617472.0,"height":256,"index":44,"lookup_group_size":1,"lookups":11,"name":"ixvm_group_37","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":74,"stage2_width":22}, + {"cells":74752,"fft_cost":3130368.0,"height":512,"index":45,"lookup_group_size":1,"lookups":38,"name":"ixvm_group_38","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":146,"stage2_width":76}, + {"cells":57344,"fft_cost":2998272.0,"height":2048,"index":46,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_39","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":28,"stage2_width":12}, + {"cells":50176,"fft_cost":2131968.0,"height":1024,"index":47,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_40","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":49,"stage2_width":16}, + {"cells":6656,"fft_cost":248832.0,"height":256,"index":48,"lookup_group_size":1,"lookups":5,"name":"ixvm_group_41","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":26,"stage2_width":10}, + {"cells":19712,"fft_cost":562176.0,"height":256,"index":49,"lookup_group_size":1,"lookups":5,"name":"ixvm_group_42","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":77,"stage2_width":10}, + {"cells":176128,"fft_cost":10702848.0,"height":2048,"index":50,"lookup_group_size":1,"lookups":34,"name":"ixvm_group_43","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":86,"stage2_width":68}, + {"cells":8960,"fft_cost":304128.0,"height":256,"index":51,"lookup_group_size":1,"lookups":5,"name":"ixvm_group_44","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":35,"stage2_width":10}, + {"cells":57344,"fft_cost":4825088.0,"height":8192,"index":52,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":6}, + {"cells":147456,"fft_cost":13271040.0,"height":16384,"index":53,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":6}, + {"cells":3200,"fft_cost":111744.0,"height":128,"index":54,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_45","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":25,"stage2_width":12}, + {"cells":294912,"fft_cost":20545536.0,"height":8192,"index":55,"lookup_group_size":1,"lookups":12,"name":"ixvm_group_46","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":36,"stage2_width":24}, + {"cells":0,"fft_cost":0.0,"height":0,"index":56,"lookup_group_size":1,"lookups":31,"name":"ixvm_group_47","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":204,"stage2_width":62}, + {"cells":24064,"fft_cost":1070592.0,"height":512,"index":57,"lookup_group_size":1,"lookups":13,"name":"ixvm_group_48","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":47,"stage2_width":26}, + {"cells":4608,"fft_cost":236544.0,"height":256,"index":58,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_49","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":16}, + {"cells":11264,"fft_cost":595968.0,"height":1024,"index":59,"lookup_group_size":1,"lookups":2,"name":"ixvm_group_50","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4}, + {"cells":6912,"fft_cost":200448.0,"height":128,"index":60,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_51","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":54,"stage2_width":16}, + {"cells":2944,"fft_cost":100992.0,"height":128,"index":61,"lookup_group_size":1,"lookups":5,"name":"ixvm_group_52","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":10}, + {"cells":0,"fft_cost":0.0,"height":0,"index":62,"lookup_group_size":1,"lookups":13,"name":"ixvm_group_53","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":90,"stage2_width":26}, + {"cells":25856,"fft_cost":844800.0,"height":256,"index":63,"lookup_group_size":1,"lookups":16,"name":"ixvm_group_54","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":101,"stage2_width":32}, + {"cells":0,"fft_cost":0.0,"height":0,"index":64,"lookup_group_size":1,"lookups":10,"name":"ixvm_group_55","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":63,"stage2_width":20}, + {"cells":12544,"fft_cost":402432.0,"height":256,"index":65,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_56","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":49,"stage2_width":12}, + {"cells":328,"fft_cost":4272.0,"height":4,"index":66,"lookup_group_size":1,"lookups":45,"name":"ixvm_group_57","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":82,"stage2_width":90}, + {"cells":23296,"fft_cost":979968.0,"height":256,"index":67,"lookup_group_size":1,"lookups":32,"name":"ixvm_group_58","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":91,"stage2_width":64}, + {"cells":10240,"fft_cost":445440.0,"height":256,"index":68,"lookup_group_size":1,"lookups":14,"name":"ixvm_group_59","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":40,"stage2_width":28}, + {"cells":52224,"fft_cost":2377728.0,"height":1024,"index":69,"lookup_group_size":1,"lookups":11,"name":"ixvm_group_60","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":51,"stage2_width":22}, + {"cells":25600,"fft_cost":1271808.0,"height":1024,"index":70,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_61","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":25,"stage2_width":12}, + {"cells":65536,"fft_cost":5849088.0,"height":8192,"index":71,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":6}, + {"cells":45056,"fft_cost":3440640.0,"height":4096,"index":72,"lookup_group_size":1,"lookups":4,"name":"ixvm_group_62","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":8}, + {"cells":786432,"fft_cost":68222976.0,"height":32768,"index":73,"lookup_group_size":1,"lookups":9,"name":"ixvm_group_63","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":24,"stage2_width":18}, + {"cells":688128,"fft_cost":63799296.0,"height":32768,"index":74,"lookup_group_size":1,"lookups":9,"name":"ixvm_group_64","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":21,"stage2_width":18}, + {"cells":4096,"fft_cost":227328.0,"height":512,"index":75,"lookup_group_size":1,"lookups":2,"name":"ixvm_group_65","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":4}, + {"cells":344064,"fft_cost":29491200.0,"height":8192,"index":76,"lookup_group_size":1,"lookups":23,"name":"ixvm_group_66","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":42,"stage2_width":46}, + {"cells":589824,"fft_cost":53477376.0,"height":32768,"index":77,"lookup_group_size":1,"lookups":7,"name":"ixvm_group_67","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":14}, + {"cells":360448,"fft_cost":27721728.0,"height":16384,"index":78,"lookup_group_size":1,"lookups":7,"name":"ixvm_group_68","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":22,"stage2_width":14}, + {"cells":3072,"fft_cost":76800.0,"height":64,"index":79,"lookup_group_size":1,"lookups":7,"name":"ixvm_group_69","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":48,"stage2_width":14}, + {"cells":13312,"fft_cost":586752.0,"height":512,"index":80,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_70","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":26,"stage2_width":12}, + {"cells":20992,"fft_cost":794112.0,"height":512,"index":81,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_71","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":41,"stage2_width":12}, + {"cells":18432,"fft_cost":697344.0,"height":512,"index":82,"lookup_group_size":1,"lookups":5,"name":"ixvm_group_72","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":36,"stage2_width":10}, + {"cells":32768,"fft_cost":1637376.0,"height":512,"index":83,"lookup_group_size":1,"lookups":25,"name":"ixvm_group_73","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":64,"stage2_width":50}, + {"cells":40960,"fft_cost":2703360.0,"height":4096,"index":84,"lookup_group_size":2,"lookups":3,"name":"IxVM::expr_inst_levels","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":4}, + {"cells":90112,"fft_cost":6242304.0,"height":4096,"index":85,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_74","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":22,"stage2_width":16}, + {"cells":196608,"fft_cost":18087936.0,"height":16384,"index":86,"lookup_group_size":1,"lookups":5,"name":"ixvm_group_75","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":10}, + {"cells":425984,"fft_cost":40206336.0,"height":32768,"index":87,"lookup_group_size":1,"lookups":5,"name":"ixvm_group_76","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":10}, + {"cells":262144,"fft_cost":22462464.0,"height":8192,"index":88,"lookup_group_size":1,"lookups":17,"name":"ixvm_group_77","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":32,"stage2_width":34}, + {"cells":172032,"fft_cost":13197312.0,"height":8192,"index":89,"lookup_group_size":1,"lookups":8,"name":"IxVM::has_bvar_in_range","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":21,"stage2_width":16}, + {"cells":131072,"fft_cost":7421952.0,"height":4096,"index":90,"lookup_group_size":1,"lookups":7,"name":"ixvm_group_78","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":32,"stage2_width":14}, + {"cells":1856,"fft_cost":32832.0,"height":16,"index":91,"lookup_group_size":1,"lookups":25,"name":"ixvm_group_79","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":116,"stage2_width":50}, + {"cells":1015808,"fft_cost":72646656.0,"height":32768,"index":92,"lookup_group_size":1,"lookups":7,"name":"ixvm_group_80","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":31,"stage2_width":14}, + {"cells":36864,"fft_cost":2555904.0,"height":4096,"index":93,"lookup_group_size":2,"lookups":3,"name":"IxVM::k_is_def_eq_ordered","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":4}, + {"cells":131072,"fft_cost":7127040.0,"height":4096,"index":94,"lookup_group_size":2,"lookups":11,"name":"IxVM::try_def_eq_app","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":32,"stage2_width":12}, + {"cells":188416,"fft_cost":11919360.0,"height":8192,"index":95,"lookup_group_size":1,"lookups":5,"name":"ixvm_group_81","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":10}, + {"cells":598016,"fft_cost":28532736.0,"height":8192,"index":96,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_82","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":73,"stage2_width":12}, + {"cells":35328,"fft_cost":1430016.0,"height":512,"index":97,"lookup_group_size":1,"lookups":15,"name":"ixvm_group_83","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":69,"stage2_width":30}, + {"cells":3584,"fft_cost":141312.0,"height":128,"index":98,"lookup_group_size":1,"lookups":10,"name":"ixvm_group_84","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":28,"stage2_width":20}, + {"cells":10112,"fft_cost":316032.0,"height":128,"index":99,"lookup_group_size":1,"lookups":17,"name":"ixvm_group_85","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":79,"stage2_width":34}, + {"cells":8320,"fft_cost":316032.0,"height":128,"index":100,"lookup_group_size":1,"lookups":24,"name":"ixvm_group_86","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":65,"stage2_width":48}, + {"cells":3648,"fft_cost":69504.0,"height":32,"index":101,"lookup_group_size":1,"lookups":13,"name":"ixvm_group_87","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":114,"stage2_width":26}, + {"cells":15872,"fft_cost":766464.0,"height":512,"index":102,"lookup_group_size":1,"lookups":10,"name":"ixvm_group_88","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":31,"stage2_width":20}, + {"cells":12288,"fft_cost":503808.0,"height":512,"index":103,"lookup_group_size":1,"lookups":4,"name":"ixvm_group_89","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":24,"stage2_width":8}, + {"cells":122880,"fft_cost":10002432.0,"height":8192,"index":104,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_90","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":12}, + {"cells":57344,"fft_cost":3588096.0,"height":4096,"index":105,"lookup_group_size":2,"lookups":5,"name":"IxVM::try_string_lit_one","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":14,"stage2_width":6}, + {"cells":192512,"fft_cost":9338880.0,"height":4096,"index":106,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_91","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":47,"stage2_width":12}, + {"cells":81920,"fft_cost":5357568.0,"height":4096,"index":107,"lookup_group_size":2,"lookups":11,"name":"IxVM::whnf_nd_with_spine","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":12}, + {"cells":81920,"fft_cost":5652480.0,"height":4096,"index":108,"lookup_group_size":1,"lookups":7,"name":"IxVM::expr_inst1_walk","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":14}, + {"cells":576,"fft_cost":12864.0,"height":32,"index":109,"lookup_group_size":1,"lookups":2,"name":"ixvm_group_92","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":4}, + {"cells":272,"fft_cost":4992.0,"height":16,"index":110,"lookup_group_size":1,"lookups":2,"name":"ixvm_group_93","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":4}, + {"cells":80,"fft_cost":1392.0,"height":8,"index":111,"lookup_group_size":1,"lookups":2,"name":"ixvm_group_94","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":4}, + {"cells":26112,"fft_cost":1181184.0,"height":512,"index":112,"lookup_group_size":1,"lookups":15,"name":"ixvm_group_95","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":51,"stage2_width":30}, + {"cells":18944,"fft_cost":1291776.0,"height":512,"index":113,"lookup_group_size":1,"lookups":26,"name":"ixvm_group_96","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":37,"stage2_width":52}, + {"cells":35840,"fft_cost":1947648.0,"height":1024,"index":114,"lookup_group_size":1,"lookups":12,"name":"ixvm_group_97","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":35,"stage2_width":24}, + {"cells":196608,"fft_cost":17350656.0,"height":8192,"index":115,"lookup_group_size":1,"lookups":13,"name":"ixvm_group_98","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":24,"stage2_width":26}, + {"cells":66560,"fft_cost":3422208.0,"height":1024,"index":116,"lookup_group_size":1,"lookups":21,"name":"ixvm_group_99","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":65,"stage2_width":42}, + {"cells":49152,"fft_cost":2039808.0,"height":1024,"index":117,"lookup_group_size":1,"lookups":7,"name":"ixvm_group_100","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":48,"stage2_width":14}, + {"cells":18688,"fft_cost":611328.0,"height":256,"index":118,"lookup_group_size":1,"lookups":11,"name":"ixvm_group_101","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":73,"stage2_width":22}, + {"cells":61440,"fft_cost":5210112.0,"height":4096,"index":119,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_102","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":16}, + {"cells":18432,"fft_cost":724992.0,"height":512,"index":120,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_103","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":36,"stage2_width":12}, + {"cells":43008,"fft_cost":1803264.0,"height":512,"index":121,"lookup_group_size":1,"lookups":21,"name":"ixvm_group_104","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":84,"stage2_width":42}, + {"cells":608,"fft_cost":11328.0,"height":16,"index":122,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_105","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":38,"stage2_width":16}, + {"cells":1312,"fft_cost":23616.0,"height":16,"index":123,"lookup_group_size":1,"lookups":18,"name":"ixvm_group_106","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":82,"stage2_width":36}, + {"cells":288,"fft_cost":5184.0,"height":16,"index":124,"lookup_group_size":1,"lookups":2,"name":"ixvm_group_107","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":4}, + {"cells":57344,"fft_cost":3588096.0,"height":4096,"index":125,"lookup_group_size":2,"lookups":6,"name":"IxVM::k_is_def_eq_slow_nd","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":14,"stage2_width":6}, + {"cells":90112,"fft_cost":4767744.0,"height":4096,"index":126,"lookup_group_size":2,"lookups":6,"name":"IxVM::whnf_struct_core","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":22,"stage2_width":6}, + {"cells":41984,"fft_cost":1947648.0,"height":1024,"index":127,"lookup_group_size":1,"lookups":9,"name":"ixvm_group_108","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":41,"stage2_width":18}, + {"cells":31232,"fft_cost":1098240.0,"height":512,"index":128,"lookup_group_size":2,"lookups":14,"name":"IxVM::try_eta_struct","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":61,"stage2_width":14}, + {"cells":59392,"fft_cost":3336192.0,"height":2048,"index":129,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_109","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":29,"stage2_width":16}, + {"cells":13312,"fft_cost":718848.0,"height":1024,"index":130,"lookup_group_size":2,"lookups":5,"name":"IxVM::is_nat_zero","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":6}, + {"cells":176128,"fft_cost":10518528.0,"height":4096,"index":131,"lookup_group_size":1,"lookups":12,"name":"IxVM::k_is_def_eq_struct_bounded","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":43,"stage2_width":24}, + {"cells":19456,"fft_cost":1394688.0,"height":1024,"index":132,"lookup_group_size":1,"lookups":11,"name":"ixvm_group_110","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":22}, + {"cells":294912,"fft_cost":25460736.0,"height":32768,"index":133,"lookup_group_size":2,"lookups":4,"name":"IxVM::expr_glb","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":4}, + {"cells":81920,"fft_cost":5849088.0,"height":8192,"index":134,"lookup_group_size":2,"lookups":4,"name":"IxVM::expr_glb_binder","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":4}, + {"cells":122880,"fft_cost":10002432.0,"height":8192,"index":135,"lookup_group_size":2,"lookups":11,"name":"IxVM::k_infer_rebase","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":12}, + {"cells":0,"fft_cost":0.0,"height":0,"index":136,"lookup_group_size":2,"lookups":2,"name":"IxVM::canon_ord_cmp_g","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":2}, + {"cells":0,"fft_cost":0.0,"height":0,"index":137,"lookup_group_size":1,"lookups":18,"name":"IxVM::canon_addr_cmp","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":83,"stage2_width":36}, + {"cells":0,"fft_cost":0.0,"height":0,"index":138,"lookup_group_size":1,"lookups":2,"name":"IxVM::canon_addr_chunk","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":4}, + {"cells":310,"fft_cost":1230.0,"height":2,"index":139,"lookup_group_size":1,"lookups":21,"name":"ixvm_group_111","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":155,"stage2_width":42}, + {"cells":180224,"fft_cost":13271040.0,"height":16384,"index":140,"lookup_group_size":2,"lookups":3,"name":"IxVM::g_list_has","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4}, + {"cells":512,"fft_cost":50176.0,"height":256,"index":141,"lookup_group_size":1,"lookups":2,"name":"","preprocessed_height":256,"preprocessed_width":11,"quotient_degree":1,"stage1_width":2,"stage2_width":4}, + {"cells":458752,"fft_cost":60555264.0,"height":65536,"index":142,"lookup_group_size":2,"lookups":7,"name":"","preprocessed_height":65536,"preprocessed_width":14,"quotient_degree":2,"stage1_width":7,"stage2_width":8}, + {"cells":1024,"fft_cost":157696.0,"height":1024,"index":143,"lookup_group_size":1,"lookups":1,"name":"","preprocessed_height":1024,"preprocessed_width":3,"quotient_degree":1,"stage1_width":1,"stage2_width":2}, + {"cells":40,"fft_cost":968.0,"height":8,"index":144,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":5,"stage2_width":6}, + {"cells":3145728,"fft_cost":420478976.0,"height":524288,"index":145,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":6,"stage2_width":6}, + {"cells":229376,"fft_cost":22249472.0,"height":32768,"index":146,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":6}, + {"cells":1024,"fft_cost":43520.0,"height":128,"index":147,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":8,"stage2_width":6}, + {"cells":144,"fft_cost":3328.0,"height":16,"index":148,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":9,"stage2_width":6}, + {"cells":22,"fft_cost":122.0,"height":2,"index":149,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":6}, + {"cells":384,"fft_cost":9728.0,"height":32,"index":150,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":12,"stage2_width":6}, + {"cells":832,"fft_cost":24448.0,"height":64,"index":151,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":13,"stage2_width":6}, + {"cells":448,"fft_cost":10688.0,"height":32,"index":152,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":14,"stage2_width":6}, + {"cells":7680,"fft_cost":320000.0,"height":512,"index":153,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":15,"stage2_width":6}, + {"cells":172032,"fft_cost":9297920.0,"height":8192,"index":154,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":21,"stage2_width":6}, + {"cells":0,"fft_cost":0.0,"height":0,"index":155,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":22,"stage2_width":6}, + {"cells":143360,"fft_cost":6356992.0,"height":4096,"index":156,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":35,"stage2_width":6}, + {"cells":75776,"fft_cost":3049472.0,"height":2048,"index":157,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":37,"stage2_width":6}, + {"cells":2496,"fft_cost":54400.0,"height":64,"index":158,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":39,"stage2_width":6}, + {"cells":1600,"fft_cost":27968.0,"height":32,"index":159,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":50,"stage2_width":6}, + {"cells":0,"fft_cost":0.0,"height":0,"index":160,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":53,"stage2_width":6}, + {"cells":0,"fft_cost":0.0,"height":0,"index":161,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":67,"stage2_width":6} + ], + "environment-legacy": [ + {"stage2_width":14,"stage1_width":33,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[0,354,356,494],"index":0,"height":16384,"fft_cost":35291136,"cells":540672}, + {"stage2_width":40,"stage1_width":119,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[1,110,287,288,295,298,596,635,642,651,691],"index":1,"height":1024,"fft_cost":5019648,"cells":121856}, + {"stage2_width":8,"stage1_width":70,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[2],"index":2,"height":8192,"fft_cost":26296320,"cells":573440}, + {"stage2_width":4,"stage1_width":4,"quotient_degree":1,"preprocessed_width":0,"preprocessed_height":0,"members":[3],"index":3,"height":16384,"fft_cost":6946816,"cells":65536}, + {"stage2_width":4,"stage1_width":7,"quotient_degree":1,"preprocessed_width":0,"preprocessed_height":0,"members":[5],"index":4,"height":512,"fft_cost":181760,"cells":3584}, + {"stage2_width":2,"stage1_width":19,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[6],"index":5,"height":128,"fft_cost":68736,"cells":2432}, + {"stage2_width":6,"stage1_width":50,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[14,16,113,147,194,229,285,286,393,394,395,603],"index":6,"height":2,"fft_cost":384,"cells":100}, + {"stage2_width":32,"stage1_width":63,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[15,230,536,719],"index":7,"height":1024,"fft_cost":3053568,"cells":64512}, + {"stage2_width":2,"stage1_width":20,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[17,18],"index":8,"height":256,"fft_cost":162816,"cells":5120}, + {"stage2_width":16,"stage1_width":106,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[22,72,96,97,278,447,625,686,695,703,710,723],"index":9,"height":1024,"fft_cost":3883008,"cells":108544}, + {"stage2_width":16,"stage1_width":79,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[23,115,120,477,595,643,644,724],"index":10,"height":1024,"fft_cost":3053568,"cells":80896}, + {"stage2_width":34,"stage1_width":202,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[24,300,301,303,305,659,780],"index":11,"height":256,"fft_cost":1477632,"cells":51712}, + {"stage2_width":18,"stage1_width":166,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[25,29,124],"index":12,"height":4096,"fft_cost":27770880,"cells":679936}, + {"stage2_width":8,"stage1_width":17,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[26],"index":13,"height":131072,"fft_cost":195428352,"cells":2228224}, + {"stage2_width":130,"stage1_width":195,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[27],"index":14,"height":4096,"fft_cost":48562176,"cells":798720}, + {"stage2_width":6,"stage1_width":8,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[28],"index":15,"height":65536,"fft_cost":57409536,"cells":524288}, + {"stage2_width":26,"stage1_width":161,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[30],"index":16,"height":2048,"fft_cost":12933120,"cells":329728}, + {"stage2_width":388,"stage1_width":533,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[34],"index":17,"height":32768,"fft_cost":1364361216,"cells":17465344}, + {"stage2_width":18,"stage1_width":171,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[35,302,658,735,738,759,760,769,777,800,802],"index":18,"height":1,"fft_cost":579,"cells":171}, + {"stage2_width":14,"stage1_width":63,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[36,201,236,246,277,569,571,582,586,587,592,593,656,768,790,809],"index":19,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":10,"stage1_width":56,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[39,37,71,284,344,473,497,513,623,631,793],"index":20,"height":1024,"fft_cost":2162688,"cells":57344}, + {"stage2_width":18,"stage1_width":106,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[38,56,63,73,151,152,297,572,584,652,711,736,739,740,762,813],"index":21,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":10,"stage1_width":26,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[40],"index":22,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":6,"stage1_width":30,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[41],"index":23,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":10,"stage1_width":58,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[42,64,350,558,567,577,578,585,589,654,655,662,753,757,798],"index":24,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":2,"stage1_width":10,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[43],"index":25,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":4,"stage1_width":11,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[44],"index":26,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":6,"stage1_width":8,"quotient_degree":1,"preprocessed_width":0,"preprocessed_height":0,"members":[45],"index":27,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":12,"stage1_width":51,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[46,156,216,557,562,732,733,737,747,748,749,750,751,764,765,766],"index":28,"height":1024,"fft_cost":2070528,"cells":52224}, + {"stage2_width":22,"stage1_width":114,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[47,48,49,50,51,52,62,68,70,241,574,590,752,771,792,812],"index":29,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":80,"stage1_width":136,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[53,138,212,267,682,683],"index":30,"height":2048,"fft_cost":14893056,"cells":278528}, + {"stage2_width":8,"stage1_width":42,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[61,54,196,197,220,223,227,235,237,550,554,763,767,772,775,779],"index":31,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":12,"stage1_width":101,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[55,57,66,67,69,74,154,155,564,646,660,755,774,789,796,801],"index":32,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":20,"stage1_width":103,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[58,109,117,594,634,663,681,693,697,713,725,791],"index":33,"height":256,"fft_cost":783360,"cells":26368}, + {"stage2_width":18,"stage1_width":57,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[59,60,76,136,271,304,315,425,427,474,664,667,673,680,709],"index":34,"height":128,"fft_cost":213888,"cells":7296}, + {"stage2_width":66,"stage1_width":219,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[65,248,547,556,573,575,754,756,770,773,776,778],"index":35,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":16,"stage1_width":92,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[75,79,289,290,292,726,731],"index":36,"height":1024,"fft_cost":3452928,"cells":94208}, + {"stage2_width":10,"stage1_width":45,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[77,78,135,517,611,621,645,666,674,690,705,715,746,810],"index":37,"height":256,"fft_cost":365568,"cells":11520}, + {"stage2_width":8,"stage1_width":20,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[80,140,380,487,608],"index":38,"height":8192,"fft_cost":10321920,"cells":163840}, + {"stage2_width":6,"stage1_width":18,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[81],"index":39,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":8,"stage1_width":24,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[82],"index":40,"height":32768,"fft_cost":53477376,"cells":786432}, + {"stage2_width":18,"stage1_width":39,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[83,119,336,414,416],"index":41,"height":512,"fft_cost":849408,"cells":19968}, + {"stage2_width":8,"stage1_width":17,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[84],"index":42,"height":8192,"fft_cost":9363456,"cells":139264}, + {"stage2_width":8,"stage1_width":16,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[85],"index":43,"height":2048,"fft_cost":1916928,"cells":32768}, + {"stage2_width":6,"stage1_width":26,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[86],"index":44,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":12,"stage1_width":33,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[87],"index":45,"height":4096,"fft_cost":7274496,"cells":135168}, + {"stage2_width":12,"stage1_width":27,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[88],"index":46,"height":16384,"fft_cost":29786112,"cells":442368}, + {"stage2_width":2,"stage1_width":10,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[89],"index":47,"height":1,"fft_cost":48,"cells":10}, + {"stage2_width":4,"stage1_width":13,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[90],"index":48,"height":1,"fft_cost":63,"cells":13}, + {"stage2_width":4,"stage1_width":16,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[91],"index":49,"height":2048,"fft_cost":1646592,"cells":32768}, + {"stage2_width":6,"stage1_width":18,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[92],"index":50,"height":2048,"fft_cost":1916928,"cells":36864}, + {"stage2_width":14,"stage1_width":38,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[93,94],"index":51,"height":8192,"fft_cost":17989632,"cells":311296}, + {"stage2_width":12,"stage1_width":49,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[95],"index":52,"height":32768,"fft_cost":96239616,"cells":1605632}, + {"stage2_width":22,"stage1_width":64,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[98,130,466],"index":53,"height":256,"fft_cost":556032,"cells":16384}, + {"stage2_width":68,"stage1_width":100,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[99],"index":54,"height":2048,"fft_cost":11649024,"cells":204800}, + {"stage2_width":12,"stage1_width":26,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[100],"index":55,"height":2048,"fft_cost":2863104,"cells":53248}, + {"stage2_width":20,"stage1_width":62,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[101,340,409,432,471,489,490],"index":56,"height":1024,"fft_cost":2654208,"cells":63488}, + {"stage2_width":12,"stage1_width":26,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[102],"index":57,"height":2048,"fft_cost":2863104,"cells":53248}, + {"stage2_width":4,"stage1_width":52,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[106,111,296,355,484,492,597,633,678,696,707],"index":58,"height":512,"fft_cost":835584,"cells":26624}, + {"stage2_width":16,"stage1_width":40,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[107,270,282,464],"index":59,"height":1024,"fft_cost":1855488,"cells":40960}, + {"stage2_width":20,"stage1_width":89,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[112,114,210,213,258,349,400,406,422,479,606],"index":60,"height":16,"fft_cost":21888,"cells":1424}, + {"stage2_width":12,"stage1_width":106,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[116,121,293,307,730],"index":61,"height":1024,"fft_cost":3760128,"cells":108544}, + {"stage2_width":12,"stage1_width":34,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[118,144,463,475,720],"index":62,"height":2048,"fft_cost":3403776,"cells":69632}, + {"stage2_width":12,"stage1_width":72,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[122,728],"index":63,"height":512,"fft_cost":1222656,"cells":36864}, + {"stage2_width":8,"stage1_width":11,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[125],"index":64,"height":16384,"fft_cost":16023552,"cells":180224}, + {"stage2_width":20,"stage1_width":74,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[126,272,280,291,326,330,544,685,694],"index":65,"height":256,"fft_cost":605184,"cells":18944}, + {"stage2_width":14,"stage1_width":49,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[127],"index":66,"height":16,"fft_cost":13056,"cells":784}, + {"stage2_width":4,"stage1_width":5,"quotient_degree":1,"preprocessed_width":0,"preprocessed_height":0,"members":[128],"index":67,"height":16,"fft_cost":2176,"cells":80}, + {"stage2_width":32,"stage1_width":79,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[129,276,327,541,626,636,641,677,684,689,714],"index":68,"height":128,"fft_cost":310656,"cells":10112}, + {"stage2_width":20,"stage1_width":40,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[131,268,333,337,363,410],"index":69,"height":1024,"fft_cost":1978368,"cells":40960}, + {"stage2_width":18,"stage1_width":18,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[132],"index":70,"height":8,"fft_cost":2976,"cells":144}, + {"stage2_width":14,"stage1_width":30,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[133],"index":71,"height":16,"fft_cost":9408,"cells":480}, + {"stage2_width":8,"stage1_width":40,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[134,279,341,377,649,668,671,676,699,702,716,717,787],"index":72,"height":256,"fft_cost":322560,"cells":10240}, + {"stage2_width":12,"stage1_width":21,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[141],"index":73,"height":32,"fft_cost":18144,"cells":672}, + {"stage2_width":14,"stage1_width":68,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[142],"index":74,"height":32,"fft_cost":41664,"cells":2176}, + {"stage2_width":6,"stage1_width":8,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[143],"index":75,"height":16,"fft_cost":3648,"cells":128}, + {"stage2_width":34,"stage1_width":52,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[145,149,273,612,632,700,712],"index":76,"height":512,"fft_cost":1250304,"cells":26624}, + {"stage2_width":12,"stage1_width":55,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[146,148,157,209,403,419,421,423,539,639,640],"index":77,"height":32,"fft_cost":34464,"cells":1760}, + {"stage2_width":44,"stage1_width":84,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[150,153,199,233,265,404,412,548,576],"index":78,"height":8,"fft_cost":9600,"cells":672}, + {"stage2_width":4,"stage1_width":18,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[158,159,160,174,182,184,190,191,192,217,218,219,224,225,226,228],"index":79,"height":16,"fft_cost":5184,"cells":288}, + {"stage2_width":4,"stage1_width":18,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[161,162,187,188,203,204,207,391,525,526,527,529,530,531,532,604],"index":80,"height":16,"fft_cost":5184,"cells":288}, + {"stage2_width":4,"stage1_width":18,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[163,165,166,167,168,169,170,171,172,202,205,206,390,533,534,535],"index":81,"height":16,"fft_cost":5184,"cells":288}, + {"stage2_width":4,"stage1_width":18,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[164,173,175,176,177,178,179,180,181,183,185,186,392,522,523,524],"index":82,"height":16,"fft_cost":5184,"cells":288}, + {"stage2_width":10,"stage1_width":54,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[189,193,256,306,309,318,516,601,614,622,679,708],"index":83,"height":1024,"fft_cost":2101248,"cells":55296}, + {"stage2_width":22,"stage1_width":38,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[195,320,353,371,600],"index":84,"height":1024,"fft_cost":1978368,"cells":38912}, + {"stage2_width":56,"stage1_width":81,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[198,231,239,314,317],"index":85,"height":4,"fft_cost":3432,"cells":324}, + {"stage2_width":24,"stage1_width":61,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[200,215,240,247,261,262,316,328,549,570,741],"index":86,"height":1,"fft_cost":267,"cells":61}, + {"stage2_width":14,"stage1_width":32,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[208,255,325,397,480,615],"index":87,"height":512,"fft_cost":697344,"cells":16384}, + {"stage2_width":34,"stage1_width":89,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[211,232,245,263,405,546,565,581,588],"index":88,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":32,"stage1_width":55,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[214,275,310,319,540,542],"index":89,"height":128,"fft_cost":246144,"cells":7040}, + {"stage2_width":4,"stage1_width":10,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[221,222,528,551,552,553,555],"index":90,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":10,"stage1_width":43,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[234,254,312,321,609,618,620,672,811],"index":91,"height":512,"fft_cost":794112,"cells":22016}, + {"stage2_width":50,"stage1_width":72,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[238,253,264,313,415,627],"index":92,"height":512,"fft_cost":1747968,"cells":36864}, + {"stage2_width":8,"stage1_width":15,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[242,342,362],"index":93,"height":2048,"fft_cost":1849344,"cells":30720}, + {"stage2_width":16,"stage1_width":55,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[244,561,566,653,734],"index":94,"height":1024,"fft_cost":2316288,"cells":56320}, + {"stage2_width":102,"stage1_width":159,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[251,299,661,692,758,761,799],"index":95,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":20,"stage1_width":65,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[257,351,537,538,607,628,638,665,698],"index":96,"height":32,"fft_cost":43104,"cells":2080}, + {"stage2_width":12,"stage1_width":54,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[259,322,359,372,420,424,426,605,637],"index":97,"height":32,"fft_cost":33984,"cells":1728}, + {"stage2_width":14,"stage1_width":56,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[260,559,560,563,580,591,647,648,669,804],"index":98,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":8,"stage1_width":10,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[266],"index":99,"height":8192,"fft_cost":7127040,"cells":81920}, + {"stage2_width":52,"stage1_width":100,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[269,411,485,495,543,545,687,688,701,704],"index":100,"height":512,"fft_cost":2162688,"cells":51200}, + {"stage2_width":14,"stage1_width":44,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[281,332,343,368,413,462,613,616],"index":101,"height":1024,"fft_cost":1916928,"cells":45056}, + {"stage2_width":14,"stage1_width":42,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[283],"index":102,"height":16384,"fft_cost":41484288,"cells":688128}, + {"stage2_width":10,"stage1_width":28,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[308,323,345,398,478],"index":103,"height":1024,"fft_cost":1302528,"cells":28672}, + {"stage2_width":48,"stage1_width":88,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[311,324,399,418,519],"index":104,"height":512,"fft_cost":1941504,"cells":45056}, + {"stage2_width":12,"stage1_width":53,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[329,331,334,417,445,448,488,514,518,718,807],"index":105,"height":512,"fft_cost":960000,"cells":27136}, + {"stage2_width":12,"stage1_width":53,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[335,381,385,482,629,630,706],"index":106,"height":256,"fft_cost":427008,"cells":13568}, + {"stage2_width":10,"stage1_width":35,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[338,446,468,515],"index":107,"height":1024,"fft_cost":1517568,"cells":35840}, + {"stage2_width":8,"stage1_width":20,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[339,460,467],"index":108,"height":2048,"fft_cost":2187264,"cells":40960}, + {"stage2_width":12,"stage1_width":20,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[346,461,476],"index":109,"height":2048,"fft_cost":2457600,"cells":40960}, + {"stage2_width":6,"stage1_width":10,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[347],"index":110,"height":4096,"fft_cost":2998272,"cells":40960}, + {"stage2_width":12,"stage1_width":20,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[348],"index":111,"height":4096,"fft_cost":5357568,"cells":81920}, + {"stage2_width":12,"stage1_width":19,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[352],"index":112,"height":32768,"fft_cost":52002816,"cells":622592}, + {"stage2_width":28,"stage1_width":31,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[357],"index":113,"height":8192,"fft_cost":20226048,"cells":253952}, + {"stage2_width":6,"stage1_width":12,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[358,481,599],"index":114,"height":2048,"fft_cost":1511424,"cells":24576}, + {"stage2_width":20,"stage1_width":26,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[361,493],"index":115,"height":2048,"fft_cost":3403776,"cells":53248}, + {"stage2_width":26,"stage1_width":26,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[364,408],"index":116,"height":4096,"fft_cost":8306688,"cells":106496}, + {"stage2_width":8,"stage1_width":9,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[365],"index":117,"height":32768,"fft_cost":31358976,"cells":294912}, + {"stage2_width":10,"stage1_width":22,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[366],"index":118,"height":32768,"fft_cost":53477376,"cells":720896}, + {"stage2_width":8,"stage1_width":10,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[367],"index":119,"height":8192,"fft_cost":7127040,"cells":81920}, + {"stage2_width":8,"stage1_width":11,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[369],"index":120,"height":16384,"fft_cost":16023552,"cells":180224}, + {"stage2_width":10,"stage1_width":20,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[370],"index":121,"height":16384,"fft_cost":23592960,"cells":327680}, + {"stage2_width":8,"stage1_width":11,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[373],"index":122,"height":32768,"fft_cost":34308096,"cells":360448}, + {"stage2_width":18,"stage1_width":25,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[374],"index":123,"height":16384,"fft_cost":32538624,"cells":409600}, + {"stage2_width":8,"stage1_width":22,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[375],"index":124,"height":8192,"fft_cost":10960896,"cells":180224}, + {"stage2_width":6,"stage1_width":11,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[376,452],"index":125,"height":4096,"fft_cost":3145728,"cells":45056}, + {"stage2_width":10,"stage1_width":12,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[378],"index":126,"height":8192,"fft_cost":8404992,"cells":98304}, + {"stage2_width":10,"stage1_width":20,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[379],"index":127,"height":4096,"fft_cost":5062656,"cells":81920}, + {"stage2_width":12,"stage1_width":15,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[382],"index":128,"height":32768,"fft_cost":46104576,"cells":491520}, + {"stage2_width":10,"stage1_width":10,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[383],"index":129,"height":8192,"fft_cost":7766016,"cells":81920}, + {"stage2_width":10,"stage1_width":20,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[384],"index":130,"height":16384,"fft_cost":23592960,"cells":327680}, + {"stage2_width":10,"stage1_width":18,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[386],"index":131,"height":4096,"fft_cost":4767744,"cells":73728}, + {"stage2_width":14,"stage1_width":16,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[387],"index":132,"height":1024,"fft_cost":1056768,"cells":16384}, + {"stage2_width":10,"stage1_width":20,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[388],"index":133,"height":4096,"fft_cost":5062656,"cells":81920}, + {"stage2_width":20,"stage1_width":41,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[389,438],"index":134,"height":512,"fft_cost":904704,"cells":20992}, + {"stage2_width":76,"stage1_width":98,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[396,401],"index":135,"height":256,"fft_cost":1096704,"cells":25088}, + {"stage2_width":8,"stage1_width":20,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[402],"index":136,"height":2048,"fft_cost":2187264,"cells":40960}, + {"stage2_width":20,"stage1_width":53,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[407],"index":137,"height":1024,"fft_cost":2377728,"cells":54272}, + {"stage2_width":12,"stage1_width":22,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[428],"index":138,"height":4096,"fft_cost":5652480,"cells":90112}, + {"stage2_width":12,"stage1_width":22,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[430],"index":139,"height":4096,"fft_cost":5652480,"cells":90112}, + {"stage2_width":16,"stage1_width":25,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[431],"index":140,"height":4096,"fft_cost":6684672,"cells":102400}, + {"stage2_width":12,"stage1_width":32,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[433,470],"index":141,"height":1024,"fft_cost":1486848,"cells":32768}, + {"stage2_width":12,"stage1_width":22,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[434],"index":142,"height":2048,"fft_cost":2592768,"cells":45056}, + {"stage2_width":10,"stage1_width":20,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[436],"index":143,"height":4096,"fft_cost":5062656,"cells":81920}, + {"stage2_width":14,"stage1_width":16,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[437],"index":144,"height":512,"fft_cost":476160,"cells":8192}, + {"stage2_width":26,"stage1_width":60,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[439],"index":145,"height":1024,"fft_cost":2777088,"cells":61440}, + {"stage2_width":6,"stage1_width":6,"quotient_degree":1,"preprocessed_width":0,"preprocessed_height":0,"members":[440],"index":146,"height":16,"fft_cost":2752,"cells":96}, + {"stage2_width":2,"stage1_width":29,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[441,442],"index":147,"height":1024,"fft_cost":1087488,"cells":29696}, + {"stage2_width":30,"stage1_width":70,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[443,472],"index":148,"height":2048,"fft_cost":7053312,"cells":143360}, + {"stage2_width":12,"stage1_width":13,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[449],"index":149,"height":8192,"fft_cost":9363456,"cells":106496}, + {"stage2_width":22,"stage1_width":18,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[450],"index":150,"height":2048,"fft_cost":2998272,"cells":36864}, + {"stage2_width":16,"stage1_width":25,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[451,457],"index":151,"height":4096,"fft_cost":6684672,"cells":102400}, + {"stage2_width":18,"stage1_width":27,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[453],"index":152,"height":2048,"fft_cost":3336192,"cells":55296}, + {"stage2_width":10,"stage1_width":18,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[454],"index":153,"height":512,"fft_cost":448512,"cells":9216}, + {"stage2_width":8,"stage1_width":12,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[455],"index":154,"height":1024,"fft_cost":749568,"cells":12288}, + {"stage2_width":18,"stage1_width":36,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[456],"index":155,"height":1024,"fft_cost":1794048,"cells":36864}, + {"stage2_width":10,"stage1_width":14,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[459],"index":156,"height":4096,"fft_cost":4177920,"cells":57344}, + {"stage2_width":8,"stage1_width":30,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[465,486,491,610,617,624],"index":157,"height":1024,"fft_cost":1302528,"cells":30720}, + {"stage2_width":12,"stage1_width":45,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[469],"index":158,"height":2048,"fft_cost":4147200,"cells":92160}, + {"stage2_width":10,"stage1_width":26,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[483],"index":159,"height":1024,"fft_cost":1241088,"cells":26624}, + {"stage2_width":8,"stage1_width":12,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[496],"index":160,"height":1024,"fft_cost":749568,"cells":12288}, + {"stage2_width":8,"stage1_width":8,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[498],"index":161,"height":8192,"fft_cost":6488064,"cells":65536}, + {"stage2_width":18,"stage1_width":15,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[499],"index":162,"height":8192,"fft_cost":11919360,"cells":122880}, + {"stage2_width":16,"stage1_width":33,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[500],"index":163,"height":8192,"fft_cost":17031168,"cells":270336}, + {"stage2_width":8,"stage1_width":11,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[501],"index":164,"height":16,"fft_cost":4608,"cells":176}, + {"stage2_width":6,"stage1_width":16,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[503],"index":165,"height":128,"fft_cost":71424,"cells":2048}, + {"stage2_width":6,"stage1_width":16,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[505],"index":166,"height":256,"fft_cost":162816,"cells":4096}, + {"stage2_width":16,"stage1_width":27,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[506],"index":167,"height":1024,"fft_cost":1456128,"cells":27648}, + {"stage2_width":12,"stage1_width":20,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[507],"index":168,"height":512,"fft_cost":503808,"cells":10240}, + {"stage2_width":6,"stage1_width":13,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[508],"index":169,"height":64,"fft_cost":27264,"cells":832}, + {"stage2_width":8,"stage1_width":14,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[509],"index":170,"height":64,"fft_cost":30720,"cells":896}, + {"stage2_width":6,"stage1_width":16,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[510],"index":171,"height":128,"fft_cost":71424,"cells":2048}, + {"stage2_width":22,"stage1_width":28,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[511],"index":172,"height":512,"fft_cost":752640,"cells":14336}, + {"stage2_width":22,"stage1_width":33,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[512],"index":173,"height":8192,"fft_cost":18948096,"cells":270336}, + {"stage2_width":8,"stage1_width":10,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[520],"index":174,"height":4096,"fft_cost":3293184,"cells":40960}, + {"stage2_width":6,"stage1_width":7,"quotient_degree":1,"preprocessed_width":0,"preprocessed_height":0,"members":[521],"index":175,"height":4096,"fft_cost":2228224,"cells":28672}, + {"stage2_width":14,"stage1_width":61,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[568],"index":176,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":10,"stage1_width":29,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[598],"index":177,"height":8192,"fft_cost":13836288,"cells":237568}, + {"stage2_width":16,"stage1_width":32,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[602],"index":178,"height":16384,"fft_cost":35979264,"cells":524288}, + {"stage2_width":14,"stage1_width":34,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[721],"index":179,"height":8192,"fft_cost":16711680,"cells":278528}, + {"stage2_width":10,"stage1_width":10,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[722],"index":180,"height":2048,"fft_cost":1646592,"cells":20480}, + {"stage2_width":6,"stage1_width":11,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[727],"index":181,"height":16384,"fft_cost":14647296,"cells":180224}, + {"stage2_width":10,"stage1_width":13,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[729],"index":182,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":10,"stage1_width":39,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[742],"index":183,"height":512,"fft_cost":738816,"cells":19968}, + {"stage2_width":6,"stage1_width":35,"quotient_degree":1,"preprocessed_width":0,"preprocessed_height":0,"members":[743],"index":184,"height":512,"fft_cost":596480,"cells":17920}, + {"stage2_width":14,"stage1_width":90,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[744],"index":185,"height":512,"fft_cost":1499136,"cells":46080}, + {"stage2_width":12,"stage1_width":44,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[745],"index":186,"height":4096,"fft_cost":8896512,"cells":180224}, + {"stage2_width":14,"stage1_width":15,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[781],"index":187,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":10,"stage1_width":13,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[782],"index":188,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":8,"stage1_width":19,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[783],"index":189,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":12,"stage1_width":57,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[784],"index":190,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":20,"stage1_width":22,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[785],"index":191,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":4,"stage1_width":10,"quotient_degree":1,"preprocessed_width":0,"preprocessed_height":0,"members":[786],"index":192,"height":1,"fft_cost":48,"cells":10}, + {"stage2_width":8,"stage1_width":10,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[788],"index":193,"height":16384,"fft_cost":15335424,"cells":163840}, + {"stage2_width":8,"stage1_width":10,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[794],"index":194,"height":16384,"fft_cost":15335424,"cells":163840}, + {"stage2_width":6,"stage1_width":8,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[795],"index":195,"height":8192,"fft_cost":5849088,"cells":65536}, + {"stage2_width":6,"stage1_width":8,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[797],"index":196,"height":8192,"fft_cost":5849088,"cells":65536}, + {"stage2_width":4,"stage1_width":7,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[803],"index":197,"height":2048,"fft_cost":1038336,"cells":14336}, + {"stage2_width":8,"stage1_width":11,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[805],"index":198,"height":2048,"fft_cost":1579008,"cells":22528}, + {"stage2_width":6,"stage1_width":10,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[806],"index":199,"height":16384,"fft_cost":13959168,"cells":163840}, + {"stage2_width":8,"stage1_width":9,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[808],"index":200,"height":131072,"fft_cost":141950976,"cells":1179648}, + {"stage2_width":16,"stage1_width":102,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[814],"index":201,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":6,"stage1_width":5,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":202,"height":8,"fft_cost":1176,"cells":40}, + {"stage2_width":6,"stage1_width":6,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":203,"height":524288,"fft_cost":484442112,"cells":3145728}, + {"stage2_width":6,"stage1_width":7,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":204,"height":32768,"fft_cost":25460736,"cells":229376}, + {"stage2_width":6,"stage1_width":8,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":205,"height":128,"fft_cost":49920,"cells":1024}, + {"stage2_width":6,"stage1_width":9,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":206,"height":16,"fft_cost":3840,"cells":144}, + {"stage2_width":6,"stage1_width":11,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":207,"height":2,"fft_cost":150,"cells":22}, + {"stage2_width":6,"stage1_width":12,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":208,"height":32,"fft_cost":10944,"cells":384}, + {"stage2_width":6,"stage1_width":13,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":209,"height":64,"fft_cost":27264,"cells":832}, + {"stage2_width":6,"stage1_width":14,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":210,"height":32,"fft_cost":11904,"cells":448}, + {"stage2_width":6,"stage1_width":15,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":211,"height":512,"fft_cost":351744,"cells":7680}, + {"stage2_width":6,"stage1_width":21,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":212,"height":8192,"fft_cost":10002432,"cells":172032}, + {"stage2_width":6,"stage1_width":22,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":213,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":6,"stage1_width":35,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":214,"height":4096,"fft_cost":6684672,"cells":143360}, + {"stage2_width":6,"stage1_width":37,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":215,"height":2048,"fft_cost":3201024,"cells":75776}, + {"stage2_width":6,"stage1_width":39,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":216,"height":64,"fft_cost":57216,"cells":2496}, + {"stage2_width":6,"stage1_width":50,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":217,"height":32,"fft_cost":29184,"cells":1600}, + {"stage2_width":6,"stage1_width":53,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":218,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":6,"stage1_width":67,"quotient_degree":2,"preprocessed_width":0,"preprocessed_height":0,"members":[],"index":219,"height":0,"fft_cost":0,"cells":0}, + {"stage2_width":6,"stage1_width":3,"quotient_degree":1,"preprocessed_width":11,"preprocessed_height":256,"members":[],"index":220,"height":256,"fft_cost":68608,"cells":768}, + {"stage2_width":8,"stage1_width":8,"quotient_degree":2,"preprocessed_width":11,"preprocessed_height":65536,"members":[],"index":221,"height":65536,"fft_cost":63700992,"cells":524288} + ], + "nat-frontier-new": [ + {"cells":10,"fft_cost":48.0,"height":1,"index":0,"lookup_group_size":1,"lookups":2,"name":"IxVM::verify_claim","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":10,"stage2_width":4}, + {"cells":1768,"fft_cost":19896.0,"height":8,"index":1,"lookup_group_size":1,"lookups":25,"name":"ixvm_group_00","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":221,"stage2_width":50}, + {"cells":1728,"fft_cost":50304.0,"height":64,"index":2,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_01","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":12}, + {"cells":49152,"fft_cost":3588096.0,"height":4096,"index":3,"lookup_group_size":1,"lookups":4,"name":"ixvm_group_02","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":8}, + {"cells":45056,"fft_cost":3440640.0,"height":4096,"index":4,"lookup_group_size":1,"lookups":4,"name":"ixvm_group_03","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":8}, + {"cells":28672,"fft_cost":2035712.0,"height":2048,"index":5,"lookup_group_size":1,"lookups":7,"name":"UInt32::less_than_fields","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":14,"stage2_width":14}, + {"cells":4768,"fft_cost":83424.0,"height":32,"index":6,"lookup_group_size":1,"lookups":10,"name":"ixvm_group_04","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":149,"stage2_width":20}, + {"cells":256512,"fft_cost":10111488.0,"height":512,"index":7,"lookup_group_size":2,"lookups":226,"name":"Blake3::compress","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":501,"stage2_width":226}, + {"cells":69632,"fft_cost":4030464.0,"height":4096,"index":8,"lookup_group_size":2,"lookups":6,"name":"Blake3::compress_chunks","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":6}, + {"cells":5568,"fft_cost":99264.0,"height":32,"index":9,"lookup_group_size":1,"lookups":14,"name":"ixvm_group_05","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":174,"stage2_width":28}, + {"cells":832,"fft_cost":15744.0,"height":32,"index":10,"lookup_group_size":1,"lookups":1,"name":"ixvm_group_06","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":26,"stage2_width":2}, + {"cells":9280,"fft_cost":322176.0,"height":64,"index":11,"lookup_group_size":1,"lookups":65,"name":"ixvm_group_07","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":145,"stage2_width":130}, + {"cells":5792,"fft_cost":112224.0,"height":32,"index":12,"lookup_group_size":1,"lookups":24,"name":"ixvm_group_08","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":181,"stage2_width":48}, + {"cells":224,"fft_cost":6368.0,"height":32,"index":13,"lookup_group_size":1,"lookups":2,"name":"${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":4}, + {"cells":0,"fft_cost":0.0,"height":0,"index":14,"lookup_group_size":1,"lookups":7,"name":"ixvm_group_09","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":75,"stage2_width":14}, + {"cells":13824,"fft_cost":572928.0,"height":512,"index":15,"lookup_group_size":1,"lookups":5,"name":"ixvm_group_10","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":10}, + {"cells":864,"fft_cost":21024.0,"height":32,"index":16,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_11","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":27,"stage2_width":12}, + {"cells":0,"fft_cost":0.0,"height":0,"index":17,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_12","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":71,"stage2_width":12}, + {"cells":0,"fft_cost":0.0,"height":0,"index":18,"lookup_group_size":1,"lookups":19,"name":"ixvm_group_13","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":92,"stage2_width":38}, + {"cells":0,"fft_cost":0.0,"height":0,"index":19,"lookup_group_size":1,"lookups":70,"name":"ixvm_group_14","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":140,"stage2_width":140}, + {"cells":896,"fft_cost":41856.0,"height":128,"index":20,"lookup_group_size":1,"lookups":2,"name":"ixvm_group_15","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":7,"stage2_width":4}, + {"cells":4352,"fft_cost":159232.0,"height":64,"index":21,"lookup_group_size":1,"lookups":34,"name":"IxVM::get_address","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":68,"stage2_width":68}, + {"cells":164,"fft_cost":1560.0,"height":4,"index":22,"lookup_group_size":1,"lookups":9,"name":"ixvm_group_16","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":41,"stage2_width":18}, + {"cells":104,"fft_cost":1248.0,"height":4,"index":23,"lookup_group_size":1,"lookups":10,"name":"ixvm_group_17","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":26,"stage2_width":20}, + {"cells":1536,"fft_cost":30912.0,"height":16,"index":24,"lookup_group_size":1,"lookups":30,"name":"ixvm_group_18","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":96,"stage2_width":60}, + {"cells":3616,"fft_cost":66144.0,"height":32,"index":25,"lookup_group_size":1,"lookups":10,"name":"ixvm_group_19","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":113,"stage2_width":20}, + {"cells":1328,"fft_cost":20352.0,"height":16,"index":26,"lookup_group_size":1,"lookups":9,"name":"ixvm_group_20","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":83,"stage2_width":18}, + {"cells":266,"fft_cost":1242.0,"height":2,"index":27,"lookup_group_size":1,"lookups":33,"name":"ixvm_group_21","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":133,"stage2_width":66}, + {"cells":2048,"fft_cost":62976.0,"height":64,"index":28,"lookup_group_size":1,"lookups":9,"name":"ixvm_group_22","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":32,"stage2_width":18}, + {"cells":4928,"fft_cost":63168.0,"height":16,"index":29,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_23","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":308,"stage2_width":16}, + {"cells":31232,"fft_cost":1236480.0,"height":512,"index":30,"lookup_group_size":1,"lookups":12,"name":"ixvm_group_24","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":61,"stage2_width":24}, + {"cells":640,"fft_cost":13824.0,"height":32,"index":31,"lookup_group_size":1,"lookups":2,"name":"UInt64::saturating_pred","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":4}, + {"cells":7424,"fft_cost":279552.0,"height":256,"index":32,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_25","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":29,"stage2_width":12}, + {"cells":2624,"fft_cost":71040.0,"height":64,"index":33,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_26","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":41,"stage2_width":16}, + {"cells":1600,"fft_cost":48000.0,"height":64,"index":34,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_27","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":25,"stage2_width":12}, + {"cells":196,"fft_cost":2040.0,"height":4,"index":35,"lookup_group_size":1,"lookups":15,"name":"ixvm_group_28","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":49,"stage2_width":30}, + {"cells":100,"fft_cost":1128.0,"height":4,"index":36,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_29","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":25,"stage2_width":16}, + {"cells":2368,"fft_cost":66432.0,"height":64,"index":37,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_30","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":37,"stage2_width":16}, + {"cells":21504,"fft_cost":1167360.0,"height":512,"index":38,"lookup_group_size":1,"lookups":19,"name":"ixvm_group_31","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":42,"stage2_width":38}, + {"cells":2144,"fft_cost":43104.0,"height":32,"index":39,"lookup_group_size":1,"lookups":9,"name":"ixvm_group_32","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":67,"stage2_width":18}, + {"cells":1792,"fft_cost":28224.0,"height":16,"index":40,"lookup_group_size":1,"lookups":15,"name":"ixvm_group_33","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":112,"stage2_width":30}, + {"cells":29,"fft_cost":129.0,"height":1,"index":41,"lookup_group_size":1,"lookups":5,"name":"ixvm_group_34","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":29,"stage2_width":10}, + {"cells":1280,"fft_cost":18624.0,"height":16,"index":42,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_35","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":80,"stage2_width":12}, + {"cells":280,"fft_cost":2496.0,"height":4,"index":43,"lookup_group_size":1,"lookups":14,"name":"ixvm_group_36","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":70,"stage2_width":28}, + {"cells":296,"fft_cost":2448.0,"height":4,"index":44,"lookup_group_size":1,"lookups":11,"name":"ixvm_group_37","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":74,"stage2_width":22}, + {"cells":146,"fft_cost":678.0,"height":1,"index":45,"lookup_group_size":1,"lookups":38,"name":"ixvm_group_38","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":146,"stage2_width":76}, + {"cells":1792,"fft_cost":51456.0,"height":64,"index":46,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_39","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":28,"stage2_width":12}, + {"cells":784,"fft_cost":13440.0,"height":16,"index":47,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_40","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":49,"stage2_width":16}, + {"cells":832,"fft_cost":19584.0,"height":32,"index":48,"lookup_group_size":1,"lookups":5,"name":"ixvm_group_41","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":26,"stage2_width":10}, + {"cells":1232,"fft_cost":17664.0,"height":16,"index":49,"lookup_group_size":1,"lookups":5,"name":"ixvm_group_42","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":77,"stage2_width":10}, + {"cells":2752,"fft_cost":76224.0,"height":32,"index":50,"lookup_group_size":1,"lookups":34,"name":"ixvm_group_43","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":86,"stage2_width":68}, + {"cells":560,"fft_cost":9600.0,"height":16,"index":51,"lookup_group_size":1,"lookups":5,"name":"ixvm_group_44","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":35,"stage2_width":10}, + {"cells":896,"fft_cost":40832.0,"height":128,"index":52,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":6}, + {"cells":2304,"fft_cost":119808.0,"height":256,"index":53,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":6}, + {"cells":400,"fft_cost":8064.0,"height":16,"index":54,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_45","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":25,"stage2_width":12}, + {"cells":2304,"fft_cost":74496.0,"height":64,"index":55,"lookup_group_size":1,"lookups":12,"name":"ixvm_group_46","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":36,"stage2_width":24}, + {"cells":0,"fft_cost":0.0,"height":0,"index":56,"lookup_group_size":1,"lookups":31,"name":"ixvm_group_47","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":204,"stage2_width":62}, + {"cells":94,"fft_cost":486.0,"height":2,"index":57,"lookup_group_size":1,"lookups":13,"name":"ixvm_group_48","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":47,"stage2_width":26}, + {"cells":288,"fft_cost":7488.0,"height":16,"index":58,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_49","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":16}, + {"cells":176,"fft_cost":3840.0,"height":16,"index":59,"lookup_group_size":1,"lookups":2,"name":"ixvm_group_50","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4}, + {"cells":216,"fft_cost":1824.0,"height":4,"index":60,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_51","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":54,"stage2_width":16}, + {"cells":368,"fft_cost":7296.0,"height":16,"index":61,"lookup_group_size":1,"lookups":5,"name":"ixvm_group_52","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":10}, + {"cells":0,"fft_cost":0.0,"height":0,"index":62,"lookup_group_size":1,"lookups":13,"name":"ixvm_group_53","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":90,"stage2_width":26}, + {"cells":0,"fft_cost":0.0,"height":0,"index":63,"lookup_group_size":1,"lookups":16,"name":"ixvm_group_54","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":101,"stage2_width":32}, + {"cells":0,"fft_cost":0.0,"height":0,"index":64,"lookup_group_size":1,"lookups":10,"name":"ixvm_group_55","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":63,"stage2_width":20}, + {"cells":49,"fft_cost":195.0,"height":1,"index":65,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_56","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":49,"stage2_width":12}, + {"cells":0,"fft_cost":0.0,"height":0,"index":66,"lookup_group_size":1,"lookups":45,"name":"ixvm_group_57","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":82,"stage2_width":90}, + {"cells":364,"fft_cost":3864.0,"height":4,"index":67,"lookup_group_size":1,"lookups":32,"name":"ixvm_group_58","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":91,"stage2_width":64}, + {"cells":80,"fft_cost":456.0,"height":2,"index":68,"lookup_group_size":1,"lookups":14,"name":"ixvm_group_59","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":40,"stage2_width":28}, + {"cells":3264,"fft_cost":89472.0,"height":64,"index":69,"lookup_group_size":1,"lookups":11,"name":"ixvm_group_60","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":51,"stage2_width":22}, + {"cells":200,"fft_cost":3048.0,"height":8,"index":70,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_61","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":25,"stage2_width":12}, + {"cells":512,"fft_cost":21504.0,"height":64,"index":71,"lookup_group_size":1,"lookups":3,"name":"${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":6}, + {"cells":88,"fft_cost":1752.0,"height":8,"index":72,"lookup_group_size":1,"lookups":4,"name":"ixvm_group_62","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":8}, + {"cells":1536,"fft_cost":53760.0,"height":64,"index":73,"lookup_group_size":1,"lookups":9,"name":"ixvm_group_63","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":24,"stage2_width":18}, + {"cells":2688,"fft_cost":117120.0,"height":128,"index":74,"lookup_group_size":1,"lookups":9,"name":"ixvm_group_64","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":21,"stage2_width":18}, + {"cells":128,"fft_cost":3264.0,"height":16,"index":75,"lookup_group_size":1,"lookups":2,"name":"ixvm_group_65","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":4}, + {"cells":1344,"fft_cost":44544.0,"height":32,"index":76,"lookup_group_size":1,"lookups":23,"name":"ixvm_group_66","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":42,"stage2_width":46}, + {"cells":1152,"fft_cost":42240.0,"height":64,"index":77,"lookup_group_size":1,"lookups":7,"name":"ixvm_group_67","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":14}, + {"cells":704,"fft_cost":19584.0,"height":32,"index":78,"lookup_group_size":1,"lookups":7,"name":"ixvm_group_68","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":22,"stage2_width":14}, + {"cells":192,"fft_cost":1632.0,"height":4,"index":79,"lookup_group_size":1,"lookups":7,"name":"ixvm_group_69","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":48,"stage2_width":14}, + {"cells":104,"fft_cost":1056.0,"height":4,"index":80,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_70","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":26,"stage2_width":12}, + {"cells":41,"fft_cost":171.0,"height":1,"index":81,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_71","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":41,"stage2_width":12}, + {"cells":72,"fft_cost":324.0,"height":2,"index":82,"lookup_group_size":1,"lookups":5,"name":"ixvm_group_72","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":36,"stage2_width":10}, + {"cells":128,"fft_cost":732.0,"height":2,"index":83,"lookup_group_size":1,"lookups":25,"name":"ixvm_group_73","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":64,"stage2_width":50}, + {"cells":640,"fft_cost":21504.0,"height":64,"index":84,"lookup_group_size":2,"lookups":3,"name":"IxVM::expr_inst_levels","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":4}, + {"cells":1408,"fft_cost":49152.0,"height":64,"index":85,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_74","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":22,"stage2_width":16}, + {"cells":768,"fft_cost":30720.0,"height":64,"index":86,"lookup_group_size":1,"lookups":5,"name":"ixvm_group_75","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":12,"stage2_width":10}, + {"cells":832,"fft_cost":31872.0,"height":64,"index":87,"lookup_group_size":1,"lookups":5,"name":"ixvm_group_76","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":10}, + {"cells":1024,"fft_cost":33984.0,"height":32,"index":88,"lookup_group_size":1,"lookups":17,"name":"ixvm_group_77","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":32,"stage2_width":34}, + {"cells":1344,"fft_cost":48000.0,"height":64,"index":89,"lookup_group_size":1,"lookups":8,"name":"IxVM::has_bvar_in_range","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":21,"stage2_width":16}, + {"cells":512,"fft_cost":9792.0,"height":16,"index":90,"lookup_group_size":1,"lookups":7,"name":"ixvm_group_78","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":32,"stage2_width":14}, + {"cells":0,"fft_cost":0.0,"height":0,"index":91,"lookup_group_size":1,"lookups":25,"name":"ixvm_group_79","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":116,"stage2_width":50}, + {"cells":1984,"fft_cost":57216.0,"height":64,"index":92,"lookup_group_size":1,"lookups":7,"name":"ixvm_group_80","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":31,"stage2_width":14}, + {"cells":288,"fft_cost":8544.0,"height":32,"index":93,"lookup_group_size":2,"lookups":3,"name":"IxVM::k_is_def_eq_ordered","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":4}, + {"cells":1024,"fft_cost":23424.0,"height":32,"index":94,"lookup_group_size":2,"lookups":11,"name":"IxVM::try_def_eq_app","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":32,"stage2_width":12}, + {"cells":736,"fft_cost":18144.0,"height":32,"index":95,"lookup_group_size":1,"lookups":5,"name":"ixvm_group_81","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":23,"stage2_width":10}, + {"cells":4672,"fft_cost":103296.0,"height":64,"index":96,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_82","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":73,"stage2_width":12}, + {"cells":552,"fft_cost":7512.0,"height":8,"index":97,"lookup_group_size":1,"lookups":15,"name":"ixvm_group_83","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":69,"stage2_width":30}, + {"cells":224,"fft_cost":3840.0,"height":8,"index":98,"lookup_group_size":1,"lookups":10,"name":"ixvm_group_84","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":28,"stage2_width":20}, + {"cells":0,"fft_cost":0.0,"height":0,"index":99,"lookup_group_size":1,"lookups":17,"name":"ixvm_group_85","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":79,"stage2_width":34}, + {"cells":65,"fft_cost":351.0,"height":1,"index":100,"lookup_group_size":1,"lookups":24,"name":"ixvm_group_86","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":65,"stage2_width":48}, + {"cells":0,"fft_cost":0.0,"height":0,"index":101,"lookup_group_size":1,"lookups":13,"name":"ixvm_group_87","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":114,"stage2_width":26}, + {"cells":31,"fft_cost":165.0,"height":1,"index":102,"lookup_group_size":1,"lookups":10,"name":"ixvm_group_88","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":31,"stage2_width":20}, + {"cells":48,"fft_cost":240.0,"height":2,"index":103,"lookup_group_size":1,"lookups":4,"name":"ixvm_group_89","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":24,"stage2_width":8}, + {"cells":480,"fft_cost":15264.0,"height":32,"index":104,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_90","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":12}, + {"cells":224,"fft_cost":4800.0,"height":16,"index":105,"lookup_group_size":2,"lookups":5,"name":"IxVM::try_string_lit_one","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":14,"stage2_width":6}, + {"cells":188,"fft_cost":1560.0,"height":4,"index":106,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_91","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":47,"stage2_width":12}, + {"cells":160,"fft_cost":2688.0,"height":8,"index":107,"lookup_group_size":2,"lookups":11,"name":"IxVM::whnf_nd_with_spine","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":12}, + {"cells":160,"fft_cost":2832.0,"height":8,"index":108,"lookup_group_size":1,"lookups":7,"name":"IxVM::expr_inst1_walk","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":20,"stage2_width":14}, + {"cells":288,"fft_cost":5184.0,"height":16,"index":109,"lookup_group_size":1,"lookups":2,"name":"ixvm_group_92","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":4}, + {"cells":272,"fft_cost":4992.0,"height":16,"index":110,"lookup_group_size":1,"lookups":2,"name":"ixvm_group_93","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":17,"stage2_width":4}, + {"cells":80,"fft_cost":1392.0,"height":8,"index":111,"lookup_group_size":1,"lookups":2,"name":"ixvm_group_94","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":4}, + {"cells":102,"fft_cost":534.0,"height":2,"index":112,"lookup_group_size":1,"lookups":15,"name":"ixvm_group_95","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":51,"stage2_width":30}, + {"cells":37,"fft_cost":279.0,"height":1,"index":113,"lookup_group_size":1,"lookups":26,"name":"ixvm_group_96","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":37,"stage2_width":52}, + {"cells":35,"fft_cost":189.0,"height":1,"index":114,"lookup_group_size":1,"lookups":12,"name":"ixvm_group_97","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":35,"stage2_width":24}, + {"cells":384,"fft_cost":10560.0,"height":16,"index":115,"lookup_group_size":1,"lookups":13,"name":"ixvm_group_98","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":24,"stage2_width":26}, + {"cells":0,"fft_cost":0.0,"height":0,"index":116,"lookup_group_size":1,"lookups":21,"name":"ixvm_group_99","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":65,"stage2_width":42}, + {"cells":192,"fft_cost":1632.0,"height":4,"index":117,"lookup_group_size":1,"lookups":7,"name":"ixvm_group_100","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":48,"stage2_width":14}, + {"cells":0,"fft_cost":0.0,"height":0,"index":118,"lookup_group_size":1,"lookups":11,"name":"ixvm_group_101","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":73,"stage2_width":22}, + {"cells":120,"fft_cost":2616.0,"height":8,"index":119,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_102","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":16}, + {"cells":36,"fft_cost":156.0,"height":1,"index":120,"lookup_group_size":1,"lookups":6,"name":"ixvm_group_103","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":36,"stage2_width":12}, + {"cells":0,"fft_cost":0.0,"height":0,"index":121,"lookup_group_size":1,"lookups":21,"name":"ixvm_group_104","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":84,"stage2_width":42}, + {"cells":0,"fft_cost":0.0,"height":0,"index":122,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_105","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":38,"stage2_width":16}, + {"cells":0,"fft_cost":0.0,"height":0,"index":123,"lookup_group_size":1,"lookups":18,"name":"ixvm_group_106","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":82,"stage2_width":36}, + {"cells":0,"fft_cost":0.0,"height":0,"index":124,"lookup_group_size":1,"lookups":2,"name":"ixvm_group_107","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":18,"stage2_width":4}, + {"cells":224,"fft_cost":4800.0,"height":16,"index":125,"lookup_group_size":2,"lookups":6,"name":"IxVM::k_is_def_eq_slow_nd","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":14,"stage2_width":6}, + {"cells":352,"fft_cost":6336.0,"height":16,"index":126,"lookup_group_size":2,"lookups":6,"name":"IxVM::whnf_struct_core","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":22,"stage2_width":6}, + {"cells":164,"fft_cost":1560.0,"height":4,"index":127,"lookup_group_size":1,"lookups":9,"name":"ixvm_group_108","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":41,"stage2_width":18}, + {"cells":122,"fft_cost":498.0,"height":2,"index":128,"lookup_group_size":2,"lookups":14,"name":"IxVM::try_eta_struct","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":61,"stage2_width":14}, + {"cells":116,"fft_cost":1224.0,"height":4,"index":129,"lookup_group_size":1,"lookups":8,"name":"ixvm_group_109","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":29,"stage2_width":16}, + {"cells":26,"fft_cost":162.0,"height":2,"index":130,"lookup_group_size":2,"lookups":5,"name":"IxVM::is_nat_zero","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":13,"stage2_width":6}, + {"cells":43,"fft_cost":213.0,"height":1,"index":131,"lookup_group_size":1,"lookups":12,"name":"IxVM::k_is_def_eq_struct_bounded","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":43,"stage2_width":24}, + {"cells":304,"fft_cost":8832.0,"height":16,"index":132,"lookup_group_size":1,"lookups":11,"name":"ixvm_group_110","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":19,"stage2_width":22}, + {"cells":576,"fft_cost":20352.0,"height":64,"index":133,"lookup_group_size":2,"lookups":4,"name":"IxVM::expr_glb","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":9,"stage2_width":4}, + {"cells":80,"fft_cost":1392.0,"height":8,"index":134,"lookup_group_size":2,"lookups":4,"name":"IxVM::expr_glb_binder","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":10,"stage2_width":4}, + {"cells":240,"fft_cost":6144.0,"height":16,"index":135,"lookup_group_size":2,"lookups":11,"name":"IxVM::k_infer_rebase","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":15,"stage2_width":12}, + {"cells":2048,"fft_cost":89088.0,"height":256,"index":136,"lookup_group_size":2,"lookups":2,"name":"IxVM::canon_ord_cmp_g","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":8,"stage2_width":2}, + {"cells":2656,"fft_cost":58208.0,"height":32,"index":137,"lookup_group_size":1,"lookups":18,"name":"IxVM::canon_addr_cmp","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":83,"stage2_width":36}, + {"cells":2816,"fft_cost":105472.0,"height":256,"index":138,"lookup_group_size":1,"lookups":2,"name":"IxVM::canon_addr_chunk","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":4}, + {"cells":0,"fft_cost":0.0,"height":0,"index":139,"lookup_group_size":1,"lookups":21,"name":"ixvm_group_111","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":155,"stage2_width":42}, + {"cells":352,"fft_cost":9504.0,"height":32,"index":140,"lookup_group_size":2,"lookups":3,"name":"IxVM::g_list_has","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":2,"stage1_width":11,"stage2_width":4}, + {"cells":512,"fft_cost":50176.0,"height":256,"index":141,"lookup_group_size":1,"lookups":2,"name":"","preprocessed_height":256,"preprocessed_width":11,"quotient_degree":1,"stage1_width":2,"stage2_width":4}, + {"cells":458752,"fft_cost":60555264.0,"height":65536,"index":142,"lookup_group_size":2,"lookups":7,"name":"","preprocessed_height":65536,"preprocessed_width":14,"quotient_degree":2,"stage1_width":7,"stage2_width":8}, + {"cells":1024,"fft_cost":157696.0,"height":1024,"index":143,"lookup_group_size":1,"lookups":1,"name":"","preprocessed_height":1024,"preprocessed_width":3,"quotient_degree":1,"stage1_width":1,"stage2_width":2}, + {"cells":0,"fft_cost":0.0,"height":0,"index":144,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":5,"stage2_width":6}, + {"cells":49152,"fft_cost":4505600.0,"height":8192,"index":145,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":6,"stage2_width":6}, + {"cells":3584,"fft_cost":209408.0,"height":512,"index":146,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":7,"stage2_width":6}, + {"cells":0,"fft_cost":0.0,"height":0,"index":147,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":8,"stage2_width":6}, + {"cells":288,"fft_cost":8288.0,"height":32,"index":148,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":9,"stage2_width":6}, + {"cells":11,"fft_cost":57.0,"height":1,"index":149,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":11,"stage2_width":6}, + {"cells":192,"fft_cost":3904.0,"height":16,"index":150,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":12,"stage2_width":6}, + {"cells":208,"fft_cost":4096.0,"height":16,"index":151,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":13,"stage2_width":6}, + {"cells":0,"fft_cost":0.0,"height":0,"index":152,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":14,"stage2_width":6}, + {"cells":240,"fft_cost":4480.0,"height":16,"index":153,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":15,"stage2_width":6}, + {"cells":10752,"fft_cost":402944.0,"height":512,"index":154,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":21,"stage2_width":6}, + {"cells":0,"fft_cost":0.0,"height":0,"index":155,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":22,"stage2_width":6}, + {"cells":4480,"fft_cost":116096.0,"height":128,"index":156,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":35,"stage2_width":6}, + {"cells":1184,"fft_cost":21728.0,"height":32,"index":157,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":37,"stage2_width":6}, + {"cells":156,"fft_cost":1144.0,"height":4,"index":158,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":39,"stage2_width":6}, + {"cells":200,"fft_cost":1408.0,"height":4,"index":159,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":50,"stage2_width":6}, + {"cells":0,"fft_cost":0.0,"height":0,"index":160,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":53,"stage2_width":6}, + {"cells":0,"fft_cost":0.0,"height":0,"index":161,"lookup_group_size":1,"lookups":3,"name":"","preprocessed_height":0,"preprocessed_width":0,"quotient_degree":1,"stage1_width":67,"stage2_width":6} + ] +} diff --git a/docs/benchmarks/formal-aiur-rom-reuse/manifest.json b/docs/benchmarks/formal-aiur-rom-reuse/manifest.json new file mode 100644 index 000000000..c17016c66 --- /dev/null +++ b/docs/benchmarks/formal-aiur-rom-reuse/manifest.json @@ -0,0 +1,259 @@ +{ + "date": "2026-10-28", + "base_revision": "5502287489c5a954ef23ad8b766611122c877e3e", + "rustflags": "-Ctarget-cpu=native", + "features": "parallel", + "profile_instrumentation": false, + "codegen": false, + "warmups": 2, + "host_lookups": true, + "thp_disabled": true, + "affinity": "CPUs 0 through (threads - 1)", + "lscpu": { + "lscpu": [ + { + "field": "Architecture:", + "data": "x86_64" + }, + { + "field": "CPU op-mode(s):", + "data": "32-bit, 64-bit" + }, + { + "field": "Address sizes:", + "data": "48 bits physical, 48 bits virtual" + }, + { + "field": "Byte Order:", + "data": "Little Endian" + }, + { + "field": "CPU(s):", + "data": "64" + }, + { + "field": "On-line CPU(s) list:", + "data": "0-63" + }, + { + "field": "Vendor ID:", + "data": "GenuineIntel" + }, + { + "field": "Model name:", + "data": "Intel(R) Xeon(R) 6975P-C" + }, + { + "field": "CPU family:", + "data": "6" + }, + { + "field": "Model:", + "data": "173" + }, + { + "field": "Thread(s) per core:", + "data": "2" + }, + { + "field": "Core(s) per socket:", + "data": "32" + }, + { + "field": "Socket(s):", + "data": "1" + }, + { + "field": "Stepping:", + "data": "1" + }, + { + "field": "BogoMIPS:", + "data": "5400.00" + }, + { + "field": "Flags:", + "data": "fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ss ht syscall nx pdpe1gb rdtscp lm constant_tsc arch_perfmon rep_good nopl xtopology nonstop_tsc cpuid aperfmperf tsc_known_freq pni pclmulqdq monitor ssse3 fma cx16 pdcm pcid sse4_1 sse4_2 x2apic movbe popcnt tsc_deadline_timer aes xsave avx f16c rdrand hypervisor lahf_lm abm 3dnowprefetch cpuid_fault ssbd ibrs ibpb stibp ibrs_enhanced fsgsbase tsc_adjust bmi1 avx2 smep bmi2 erms invpcid avx512f avx512dq rdseed adx smap avx512ifma clflushopt clwb avx512cd sha_ni avx512bw avx512vl xsaveopt xsavec xgetbv1 xsaves avx_vnni avx512_bf16 wbnoinvd ida arat avx512vbmi umip pku ospke waitpkg avx512_vbmi2 gfni vaes vpclmulqdq avx512_vnni avx512_bitalg tme avx512_vpopcntdq rdpid bus_lock_detect cldemote movdiri movdir64b md_clear serialize amx_bf16 avx512_fp16 amx_tile amx_int8 flush_l1d arch_capabilities" + }, + { + "field": "Hypervisor vendor:", + "data": "KVM" + }, + { + "field": "Virtualization type:", + "data": "full" + }, + { + "field": "L1d cache:", + "data": "1.5 MiB (32 instances)" + }, + { + "field": "L1i cache:", + "data": "2 MiB (32 instances)" + }, + { + "field": "L2 cache:", + "data": "64 MiB (32 instances)" + }, + { + "field": "L3 cache:", + "data": "480 MiB (1 instance)" + }, + { + "field": "NUMA node(s):", + "data": "1" + }, + { + "field": "NUMA node0 CPU(s):", + "data": "0-63" + }, + { + "field": "Vulnerability Gather data sampling:", + "data": "Not affected" + }, + { + "field": "Vulnerability Ghostwrite:", + "data": "Not affected" + }, + { + "field": "Vulnerability Indirect target selection:", + "data": "Not affected" + }, + { + "field": "Vulnerability Itlb multihit:", + "data": "Not affected" + }, + { + "field": "Vulnerability L1tf:", + "data": "Not affected" + }, + { + "field": "Vulnerability Mds:", + "data": "Not affected" + }, + { + "field": "Vulnerability Meltdown:", + "data": "Not affected" + }, + { + "field": "Vulnerability Mmio stale data:", + "data": "Not affected" + }, + { + "field": "Vulnerability Old microcode:", + "data": "Not affected" + }, + { + "field": "Vulnerability Reg file data sampling:", + "data": "Not affected" + }, + { + "field": "Vulnerability Retbleed:", + "data": "Not affected" + }, + { + "field": "Vulnerability Spec rstack overflow:", + "data": "Not affected" + }, + { + "field": "Vulnerability Spec store bypass:", + "data": "Mitigation; Speculative Store Bypass disabled via prctl" + }, + { + "field": "Vulnerability Spectre v1:", + "data": "Mitigation; usercopy/swapgs barriers and __user pointer sanitization" + }, + { + "field": "Vulnerability Spectre v2:", + "data": "Mitigation; Enhanced / Automatic IBRS; IBPB conditional; PBRSB-eIBRS Not affected; BHI BHI_DIS_S" + }, + { + "field": "Vulnerability Srbds:", + "data": "Not affected" + }, + { + "field": "Vulnerability Tsa:", + "data": "Not affected" + }, + { + "field": "Vulnerability Tsx async abort:", + "data": "Not affected" + }, + { + "field": "Vulnerability Vmscape:", + "data": "Not affected" + } + ] + }, + "artifact_input_sha256": { + ".lake/formal-integration/ixvm-tuned.json": "1f8c10da7b10587e985d5166b26ad0c7edd4f4cbdfe0978c7deb237cf6683d9a", + ".lake/formal-integration/recursion-tuned.json": "40e88dd1f84e4f119626189e83f8eb181f6ef9875c190f33cdd7853e83c5afe1", + ".lake/formal-comparison/final/ixvm-input.json": "2733974cdf8d687799f678140ab967d3ab2c5a9f8768c8c3455bc86b5281a7b8", + ".lake/formal-comparison/final/environment-input.json": "14a147c1d6141721547092a9a835249969aa1f82c8f57f9ed0a2b0522f7aaa56", + ".lake/formal-comparison/final/new-environment-grouped.json.inner/input.json": "2ecf2051d112503637b9d3c1a6201bd66f91df4568a95faff3cef068e3f96a1a" + }, + "binary_sha256": { + "before": "fab48b6e03dd59c5a5335c89be2686cbaf4e1d60123d4bb547f430b9222facfc", + "after": "5bd2b2fad615d6ccac5d68bc36c716bb26ba35667e31ebe170a99d0783cfe736", + "legacy": "becd57658a2d232dc158fada7fc977bdff27ae8834e6a80f5db82f18dea05024" + }, + "source_sha256": { + "crates/aiur/src/memory.rs": "c3f7cf99ff4f7ad2050575b3a692e5262d13044f27e540655c47e6f054da6f13", + "crates/aiur/src/execute.rs": "5e5b2bd5b0848c99ef509d03baace69f61c282eabdf330a5ae422436b3be8f77", + "crates/aiur/src/trace.rs": "e9928c4875ed041cc93040fa18f50a50d7ecce3784c523873da23da57b397443", + "crates/aiur/src/trace/plan.rs": "ba27c6fb8f514cc2503af28d23c405fffcdb4c2505185c5b664df49e2305e7f0", + "crates/aiur/src/trace/stark.rs": "8f4bb1b92fe8d32593244bb3c6be041ab19a2442b33a7275495449fbf3713865", + "crates/aiur/src/trace/stark/rom.rs": "c5481deb55dc05566eee2a11e9179be7da5c982f5fa2db46f9d193496f13d411", + "crates/aiur/src/trace/stark/witness.rs": "2aa09d84232e939cdb452fd48732ed1c53e0f86b041ab37eb60937d14b2ee984" + }, + "notes": [ + "Primary trace runs reuse one execution record, with five measured traces after two warmups; single-thread controls use seven samples.", + "Execution controls reexecute every iteration: seven measured samples for environment, three for recursion, after two warmups.", + "Peak RSS comes from /usr/bin/time -v and covers the whole benchmark process, not just its trace timer.", + "All new-Aiur circuit statistics, heights, cells and FFT estimates are identical before/after and across thread counts for each workload.", + "The final before execution controls and single-thread control were repeated immediately before their after run. Earlier controls and implementation experiments remain in .lake/trace-rom-reuse.", + "Additional phase profile has three samples after two warmups. Per-circuit spans overlap and are not isolated CPU times; primary benchmarks are uninstrumented." + ], + "profiled_binary_sha256": "11ffc2ba1bf1ff156b3d119da59ddbd1332b9e83d964167e8e2b987a0a804961", + "profile_threads": 64, + "profile_samples": 3, + "profile_features": "parallel,aiur/trace-profile", + "validation": { + "serial_tests": { + "command": "cargo test --release --locked -p aiur --features stark", + "passed": 82 + }, + "parallel_tests": { + "command": "cargo test --release --locked -p aiur --features parallel,trace-profile", + "passed": 82 + }, + "clippy_profiled_comparison": true, + "proofs": [ + { + "name": "nat-proof-before", + "bytes": 5478175, + "prove_including_trace_seconds": 0.228871069, + "verified": true, + "sha256": "536879768e52b1a611089656e5466fdc27db5b281ef729c2296e4a2f389cba28" + }, + { + "name": "nat-proof-after", + "bytes": 5478175, + "prove_including_trace_seconds": 0.232060764, + "verified": true, + "sha256": "536879768e52b1a611089656e5466fdc27db5b281ef729c2296e4a2f389cba28" + }, + { + "name": "recursion-proof-after", + "bytes": 3168863, + "prove_including_trace_seconds": 35.192673799, + "verified": true, + "sha256": "e1a67b6847c7770f1f4340253bf5fe8a9c7f1aaa69cca175a9b6e42db6450590" + } + ], + "nat_proof_byte_identical": true, + "clippy_default_all_targets": true, + "formatting": true, + "ordinary_binary_restored": true + } +} diff --git a/docs/benchmarks/formal-aiur-rom-reuse/phase-summary.csv b/docs/benchmarks/formal-aiur-rom-reuse/phase-summary.csv new file mode 100644 index 000000000..12dc6f8ef --- /dev/null +++ b/docs/benchmarks/formal-aiur-rom-reuse/phase-summary.csv @@ -0,0 +1,7 @@ +phase,median_seconds,min_seconds,max_seconds +validate_and_root,0.023016797,0.022885727,0.025213235 +auxiliary_counts,0.008883519,0.00880228,0.008982025 +populate_circuits,0.78155053,0.751633568,0.790242744 +check_shape,5.738e-06,5.568e-06,6.821e-06 +cleanup,3.37e-06,2.73e-06,4.31e-06 +total,0.813329478,0.78583799,0.822073557 diff --git a/docs/benchmarks/formal-aiur-rom-reuse/phases.jsonl b/docs/benchmarks/formal-aiur-rom-reuse/phases.jsonl new file mode 100644 index 000000000..df3baa14a --- /dev/null +++ b/docs/benchmarks/formal-aiur-rom-reuse/phases.jsonl @@ -0,0 +1,3 @@ +{"circuits":[["MultiStark::verify_multi_stark_proof",6.0499e-05],["verifier_group_00",0.746335559],["verifier_group_01",0.720689202],["verifier_group_02",0.720238478],["Blake3::compress",0.748328373],["Blake3::compress_chunks",0.742124012],["verifier_group_03",0.13214674],["verifier_group_04",0.719705559],["Blake3::pad_block",0.743631515],["verifier_group_05",0.720472398],["verifier_group_06",0.72044656],["verifier_group_07",0.720365144],["verifier_group_08",0.035461805],["MultiStark::read_vk_u8",0.723330837],["verifier_group_09",0.720430491],["verifier_group_10",0.720371868],["MultiStark::read_vk_tag",0.040855914],["MultiStark::read_nodes_n",0.720624281],["verifier_group_11",0.738794158],["MultiStark::read_node_ids_n",0.123681171],["verifier_group_12",0.077085072],["verifier_group_13",0.743546739],["verifier_group_14",0.008210048],["verifier_group_15",0.743129008],["verifier_group_16",0.720358577],["verifier_group_17",0.743762557],["verifier_group_18",0.720367865],["verifier_group_19",0.736219002],["MultiStark::read_u64_vec_vec_n",0.720212485],["verifier_group_20",0.750534133],["verifier_group_21",0.05473168],["verifier_group_22",0.720335581],["verifier_group_23",0.720384589],["verifier_group_24",0.005077788],["verifier_group_25",0.720595849],["verifier_group_26",0.720499649],["verifier_group_27",0.720601233],["MultiStark::b8_onto",0.720467754],["verifier_group_28",0.726194969],["verifier_group_29",0.025217851],["verifier_group_30",0.15660761],["verifier_group_31",0.001026644],["${\"name\":\"MultiStark::list_concat\",\"types\":[\"field\"]}",0.743782933],["verifier_group_32",0.028076804],["verifier_group_33",0.093823584],["verifier_group_34",0.720240646],["MultiStark::two_adic_gen",3.8152e-05],["verifier_group_35",0.720216326],["verifier_group_36",0.720092412],["verifier_group_37",0.065979847],["MultiStark::ch_sample_bits",0.000182402],["MultiStark::take_bits",0.743809543],["MultiStark::rows_pop",0.734203649],["verifier_group_38",0.729785858],["",0.05482833],["",0.017262799],["",0.739034742],["",0.421946753],["",0.00922537],["",2.1753e-05],["",0.043960659],["",0.150370114],["",0.000560841],["",0.731771772],["",0.00018527],["",6.473e-06],["",0.064650384],["",0.008931831]],"elapsed_seconds":0.78583799,"event":"aiur_trace_profile","host_lookups":true,"phases":[["validate_and_root",0.025213235],["auxiliary_counts",0.008982025],["populate_circuits",0.751633568],["check_shape",5.738e-06],["cleanup",2.73e-06]]} +{"circuits":[["MultiStark::verify_multi_stark_proof",5.7963e-05],["verifier_group_00",0.7779553],["verifier_group_01",0.752647645],["verifier_group_02",0.752440452],["Blake3::compress",0.775203248],["Blake3::compress_chunks",0.76549049],["verifier_group_03",0.0076607],["verifier_group_04",0.752488521],["Blake3::pad_block",0.780996271],["verifier_group_05",0.752457308],["verifier_group_06",0.752420471],["verifier_group_07",0.752458495],["verifier_group_08",0.752488207],["MultiStark::read_vk_u8",0.154729621],["verifier_group_09",0.75244176],["verifier_group_10",0.752452651],["MultiStark::read_vk_tag",0.752445244],["MultiStark::read_nodes_n",0.752649304],["verifier_group_11",0.76984612],["MultiStark::read_node_ids_n",0.752211198],["verifier_group_12",0.001324053],["verifier_group_13",0.772475738],["verifier_group_14",0.008881146],["verifier_group_15",0.000358096],["verifier_group_16",0.072881127],["verifier_group_17",0.752390185],["verifier_group_18",0.772399683],["verifier_group_19",0.779979499],["MultiStark::read_u64_vec_vec_n",0.752335157],["verifier_group_20",0.782741219],["verifier_group_21",0.752343772],["verifier_group_22",0.752359394],["verifier_group_23",0.00441541],["verifier_group_24",0.752347538],["verifier_group_25",0.752626712],["verifier_group_26",0.044867551],["verifier_group_27",0.752529691],["MultiStark::b8_onto",0.752427999],["verifier_group_28",0.789696932],["verifier_group_29",0.023036886],["verifier_group_30",0.001528924],["verifier_group_31",0.000807557],["${\"name\":\"MultiStark::list_concat\",\"types\":[\"field\"]}",0.003702609],["verifier_group_32",0.030084152],["verifier_group_33",0.752438098],["verifier_group_34",0.752410755],["MultiStark::two_adic_gen",3.6395e-05],["verifier_group_35",0.752439904],["verifier_group_36",0.75244547],["verifier_group_37",0.046936192],["MultiStark::ch_sample_bits",0.752356189],["MultiStark::take_bits",0.780657984],["MultiStark::rows_pop",0.770196494],["verifier_group_38",0.786997176],["",2.7606e-05],["",0.018527453],["",4.6129e-05],["",0.75837898],["",0.752440341],["",1.514e-05],["",0.053021975],["",0.76089764],["",0.000457614],["",0.767359785],["",0.000201961],["",1.0303e-05],["",0.752402874],["",0.008988619]],"elapsed_seconds":0.822073557,"event":"aiur_trace_profile","host_lookups":true,"phases":[["validate_and_root",0.023016797],["auxiliary_counts",0.00880228],["populate_circuits",0.790242744],["check_shape",6.821e-06],["cleanup",4.31e-06]]} +{"circuits":[["MultiStark::verify_multi_stark_proof",6.1289e-05],["verifier_group_00",0.779019741],["verifier_group_01",0.752542907],["verifier_group_02",0.752541502],["Blake3::compress",0.781043794],["Blake3::compress_chunks",0.769162151],["verifier_group_03",0.752458086],["verifier_group_04",0.752122484],["Blake3::pad_block",0.752579569],["verifier_group_05",0.752228155],["verifier_group_06",0.75230527],["verifier_group_07",0.752315847],["verifier_group_08",0.752338901],["MultiStark::read_vk_u8",0.755113963],["verifier_group_09",0.752326445],["verifier_group_10",0.752204325],["MultiStark::read_vk_tag",0.030309922],["MultiStark::read_nodes_n",0.752551319],["verifier_group_11",0.764239609],["MultiStark::read_node_ids_n",0.752219351],["verifier_group_12",0.006417954],["verifier_group_13",0.752465046],["verifier_group_14",0.024296757],["verifier_group_15",0.752402056],["verifier_group_16",0.752279859],["verifier_group_17",0.755828379],["verifier_group_18",0.008872126],["verifier_group_19",0.76209151],["MultiStark::read_u64_vec_vec_n",0.032359693],["verifier_group_20",0.759999152],["verifier_group_21",0.752073429],["verifier_group_22",0.094271251],["verifier_group_23",0.008218454],["verifier_group_24",0.004446566],["verifier_group_25",0.752669312],["verifier_group_26",0.751968606],["verifier_group_27",0.031074982],["MultiStark::b8_onto",0.751995486],["verifier_group_28",0.757445968],["verifier_group_29",0.7520353],["verifier_group_30",0.002900776],["verifier_group_31",0.00052623],["${\"name\":\"MultiStark::list_concat\",\"types\":[\"field\"]}",0.757914643],["verifier_group_32",0.752224833],["verifier_group_33",0.016939715],["verifier_group_34",0.752133839],["MultiStark::two_adic_gen",4.8888e-05],["verifier_group_35",0.752148892],["verifier_group_36",0.082870572],["verifier_group_37",0.752164354],["MultiStark::ch_sample_bits",0.000190457],["MultiStark::take_bits",0.752573043],["MultiStark::rows_pop",0.771400061],["verifier_group_38",0.775955298],["",3.001e-05],["",0.013159214],["",6.3493e-05],["",0.420069323],["",0.005309461],["",1.1315e-05],["",0.047910815],["",0.176275358],["",0.752444851],["",0.146140377],["",0.752324946],["",1.3615e-05],["",0.061556309],["",0.009437963]],"elapsed_seconds":0.813329478,"event":"aiur_trace_profile","host_lookups":true,"phases":[["validate_and_root",0.022885727],["auxiliary_counts",0.008883519],["populate_circuits",0.78155053],["check_shape",5.568e-06],["cleanup",3.37e-06]]} diff --git a/docs/benchmarks/formal-aiur-rom-reuse/runs.json b/docs/benchmarks/formal-aiur-rom-reuse/runs.json new file mode 100644 index 000000000..698f71c83 --- /dev/null +++ b/docs/benchmarks/formal-aiur-rom-reuse/runs.json @@ -0,0 +1,948 @@ +[ + { + "workload": "recursion-real", + "version": "before", + "threads": 64, + "peak_rss_kib": 33161460, + "report": { + "backend": "new-bytecode", + "function_rows": [], + "initial_execute_seconds": 8.47199176, + "prepare_seconds": 0.104275378, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.155563461 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.166214709 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.18902988 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.17903538 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.200906444 + } + ], + "setup_seconds": 0.038139071, + "thp_disabled": true, + "source_report": ".lake/trace-rom-reuse/recursion-real-before-64.json" + } + }, + { + "workload": "recursion-real", + "version": "after", + "threads": 64, + "peak_rss_kib": 32855756, + "report": { + "backend": "new-bytecode", + "function_rows": [], + "initial_execute_seconds": 8.422921376, + "prepare_seconds": 0.102862632, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.774523583 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.815869941 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.821910108 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.834549858 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.798773967 + } + ], + "setup_seconds": 0.039915728, + "thp_disabled": true, + "source_report": ".lake/trace-rom-reuse/recursion-real-after-64.json" + } + }, + { + "workload": "recursion-real", + "version": "legacy", + "threads": 64, + "peak_rss_kib": 30698904, + "report": { + "thp_disabled": true, + "setup_seconds": 0.024871591, + "samples": [ + { + "trace_with_lookups_seconds": 0.580716202, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.681849536, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.687254515, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.696399799, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.749651405, + "execute_seconds": null + } + ], + "reused_execution": true, + "proof": null, + "initial_execute_seconds": 8.562772401, + "circuit_names": [ + "verifier_group_00", + "u64_eq", + "verifier_group_02", + "verifier_group_03", + "verifier_group_04", + "verifier_group_05", + "verifier_group_06", + "verifier_group_07", + "read_u64_vec_n", + "verifier_group_08", + "verifier_group_09", + "verifier_group_10", + "verifier_group_11", + "read_proof", + "read_header_vec_n", + "read_message_vec_n", + "read_proof_vec_n", + "blake3_compress_chunks", + "verifier_group_12", + "blake3_compress", + "read_vk_u8", + "read_vk_tag", + "read_vk_u16", + "verifier_group_13", + "read_nodes_n", + "verifier_group_14", + "select_rows", + "verifier_group_15", + "rows_pop", + "b3_rows_chunks", + "verifier_group_16", + "ro_fold", + "bucket_update", + "ri_apply", + "verifier_group_17", + "cons8", + "eval_at", + "count_onto", + "claims_onto", + "claims_onto_each", + "header_onto", + "headers_onto", + "messages_onto", + "messages_onto_each", + "batch_fiat_shamir", + "shard_fiat_shamir", + "assert_same_u8s", + "assert_same_limbs", + "assert_same_claims", + "assert_same_cap", + "last_acc", + "messages_acc", + "log_degree_ok", + "assert_log_degrees_ok", + "count_ones", + "assert_shard_count_ok", + "three_limbs", + "le_step", + "bytes8_le", + "assert_closure_pairs", + "verify_shard", + "verify_shards", + "batch_claims", + "verify_batch", + "verify_multi_stark_proof", + "verifier_group_19", + "list_length.Proof", + "list_concat.Ptr.ListNode.U8_8", + "list_length.U8_8", + "list_lookup.SysNode", + "list_is_empty.U8", + "ROM:3", + "ROM:4", + "ROM:5", + "ROM:6", + "ROM:7", + "ROM:8", + "ROM:10", + "ROM:11", + "ROM:26", + "ROM:32", + "ROM:34", + "Bytes1", + "Bytes2" + ], + "backend": "legacy-bytecode", + "source_report": ".lake/trace-rom-reuse/recursion-real-legacy-64.json" + } + }, + { + "workload": "recursion-real", + "version": "before", + "threads": 8, + "peak_rss_kib": 31267400, + "report": { + "backend": "new-bytecode", + "function_rows": [], + "initial_execute_seconds": 8.897202338, + "prepare_seconds": 0.102426899, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 3.76702339 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 3.746706993 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 3.720119701 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 3.712494595 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 3.965910889 + } + ], + "setup_seconds": 0.034163862, + "thp_disabled": true, + "source_report": ".lake/trace-rom-reuse/recursion-real-before-8.json" + } + }, + { + "workload": "recursion-real", + "version": "after", + "threads": 8, + "peak_rss_kib": 31261444, + "report": { + "backend": "new-bytecode", + "function_rows": [], + "initial_execute_seconds": 8.741785067, + "prepare_seconds": 0.102750888, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 3.377041931 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 3.322383143 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 3.451785187 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 3.346335667 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 3.322701609 + } + ], + "setup_seconds": 0.035058655, + "thp_disabled": true, + "source_report": ".lake/trace-rom-reuse/recursion-real-after-8.json" + } + }, + { + "workload": "environment", + "version": "before", + "threads": 64, + "peak_rss_kib": 2735500, + "report": { + "backend": "new-bytecode", + "function_rows": [], + "initial_execute_seconds": 0.353954044, + "prepare_seconds": 0.131552345, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.046271222 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.05074245 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.045158082 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.046452293 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.045162997 + } + ], + "setup_seconds": 0.310193883, + "thp_disabled": true, + "source_report": ".lake/trace-rom-reuse/environment-before-64.json" + } + }, + { + "workload": "environment", + "version": "after", + "threads": 64, + "peak_rss_kib": 2692984, + "report": { + "backend": "new-bytecode", + "function_rows": [], + "initial_execute_seconds": 0.349963253, + "prepare_seconds": 0.131250346, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.035529341 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.046118373 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.034540328 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.037519189 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.042746566 + } + ], + "setup_seconds": 0.311314517, + "thp_disabled": true, + "source_report": ".lake/trace-rom-reuse/environment-after-64.json" + } + }, + { + "workload": "environment", + "version": "legacy", + "threads": 64, + "peak_rss_kib": 2860884, + "report": { + "thp_disabled": true, + "setup_seconds": 0.077388041, + "samples": [ + { + "trace_with_lookups_seconds": 0.063414971, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.028746304, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.04726461, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.027207929, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.043628496, + "execute_seconds": null + } + ], + "reused_execution": true, + "proof": null, + "initial_execute_seconds": 0.39492426, + "circuit_names": [ + "ixvm_group_00", + "ixvm_group_01", + "address_eq", + "checked_depth_succ", + "read_finite_byte_stream", + "u64_is_zero", + "ixvm_group_02", + "ixvm_group_03", + "ixvm_group_04", + "ixvm_group_05", + "ixvm_group_06", + "ixvm_group_07", + "ixvm_group_08", + "blake3_compress_chunks", + "bytes_to_block", + "pad_block", + "blake3_compress_block", + "blake3_compress", + "ixvm_group_09", + "ixvm_group_10", + "ixvm_group_11", + "ixvm_group_12", + "put_tagn_tail", + "put_tagn_wide", + "ixvm_group_13", + "value_contract_code", + "binder_contract_code", + "put_lam_mode", + "ixvm_group_15", + "ixvm_group_16", + "ixvm_group_17", + "ixvm_group_14", + "ixvm_group_18", + "ixvm_group_19", + "ixvm_group_20", + "ixvm_group_21", + "ixvm_group_22", + "ixvm_group_23", + "ixvm_group_24", + "get_u64_le", + "get_tagn4", + "ixvm_group_25", + "get_tagn0", + "get_tagn_tail", + "get_tagn_wide", + "get_u64_list", + "get_app_telescope", + "value_contract_from_bits", + "binder_contract_from_bits", + "get_lam_mode", + "get_all_mode", + "ixvm_group_26", + "get_expr", + "ixvm_group_27", + "get_address", + "get_expr_list", + "ixvm_group_28", + "get_address_list", + "ixvm_group_30", + "ixvm_group_31", + "ixvm_group_32", + "ixvm_group_33", + "ixvm_group_34", + "ixvm_group_35", + "collect_spine", + "ixvm_group_36", + "klimbs_add_carry", + "klimbs_add", + "ixvm_group_37", + "ixvm_group_38", + "glimbs_to_klimbs_with_depth", + "klimbs_normalize", + "ixvm_group_39", + "klimbs_mul_outer", + "klimbs_mul_single", + "klimbs_shl_limbs", + "ixvm_group_40", + "ixvm_group_41", + "ixvm_group_42", + "ixvm_group_43", + "ixvm_group_44", + "ixvm_group_45", + "ixvm_group_46", + "ixvm_group_47", + "ixvm_group_48", + "ixvm_group_49", + "ixvm_group_50", + "ixvm_group_51", + "ixvm_group_52", + "ixvm_group_53", + "ixvm_group_54", + "ixvm_group_55", + "ixvm_group_56", + "ixvm_group_57", + "ixvm_group_58", + "ixvm_group_59", + "ixvm_group_60", + "ixvm_group_61", + "ixvm_group_62", + "apply_spine_expr", + "ixvm_group_63", + "ixvm_group_64", + "convert_expr", + "ixvm_group_65", + "ixvm_group_66", + "ixvm_group_67", + "ixvm_group_68", + "ixvm_group_69", + "ixvm_group_70", + "ixvm_group_71", + "expr_inst_levels", + "expr_inst_levels_walk", + "expr_lbr", + "has_bvar_in_range", + "ixvm_group_72", + "ixvm_group_73", + "ixvm_group_74", + "expr_glb", + "expr_glb_walk", + "expr_glb_binder", + "expr_lift", + "expr_lift_walk", + "expr_lower", + "expr_lower_walk", + "expr_has_bvar_at", + "ixvm_group_75", + "expr_inst1", + "expr_inst1_walk", + "expr_inst_many", + "expr_inst_many_bvar", + "expr_inst_many_walk", + "peel_beta", + "whnf_apply_beta", + "whnf_with_spine", + "ixvm_group_76", + "ixvm_group_77", + "try_prim_dispatch", + "whnf_const_head", + "whnf", + "whnf_struct_core", + "whnf_struct_core_spine", + "ixvm_group_78", + "whnf_nd", + "whnf_nd_with_spine", + "whnf_nd_apply_beta", + "whnf_nd_const_head", + "types_lookup", + "ixvm_group_79", + "ixvm_group_80", + "k_is_def_eq", + "k_def_eq_rebase", + "ixvm_group_81", + "try_def_eq_app", + "de_args", + "is_nat_zero", + "nat_offset_of", + "try_string_lit_one", + "ixvm_group_82", + "k_is_def_eq_struct_bounded", + "lazy_delta_loop", + "head_addr", + "k_infer", + "k_infer_rebase", + "k_infer_core", + "k_infer_let_start", + "infer_let_lookup_type", + "infer_let_lookup_value", + "infer_let_materialize", + "k_infer_let_env", + "infer_let_local_cutoff", + "k_infer_let_env_rebase", + "infer_let_drop_unused", + "k_infer_let_env_core", + "k_infer_app_spine_loop", + "k_ensure_sort", + "k_check", + "canon_cmp_kexpr_node_ctx", + "safe_refs_only", + "validate_expr_well_scoped", + "const_idxs_expr", + "const_idxs_exprs", + "g_list_has", + "walk_refs_transitive", + "walk_leaves_owned", + "check_owned", + "env_walk_all", + "env_walk_refs_all", + "eval_nf", + "eval_nf_spine", + "eval_body", + "eval_output", + "run_eval", + "verify_claim", + "list_snoc.G", + "list_concat.Ptr.KExprNode", + "list_length.Ptr.KExprNode", + "list_lookup.Ptr.KLevelNode", + "list_is_empty.U8", + "list_take.Ptr.KExprNode", + "list_drop.Ptr.Expr", + "list_depth_checked.U8", + "rbtree_map_balance_fix.G", + "ROM:2", + "ROM:3", + "ROM:4", + "ROM:5", + "ROM:6", + "ROM:8", + "ROM:9", + "ROM:10", + "ROM:11", + "ROM:12", + "ROM:18", + "ROM:19", + "ROM:32", + "ROM:34", + "ROM:36", + "ROM:47", + "ROM:50", + "ROM:64", + "Bytes1", + "Bytes2" + ], + "backend": "legacy-bytecode", + "source_report": ".lake/trace-rom-reuse/environment-legacy-64.json" + } + }, + { + "workload": "nat-frontier", + "version": "before", + "threads": 8, + "peak_rss_kib": 528948, + "report": { + "backend": "new-bytecode", + "function_rows": [], + "initial_execute_seconds": 0.005943244, + "prepare_seconds": 0.132465402, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.005860235 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.004629695 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.004854088 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.00500133 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.003766314 + } + ], + "setup_seconds": 0.308456838, + "thp_disabled": true, + "source_report": ".lake/trace-rom-reuse/nat-frontier-before-8.json" + } + }, + { + "workload": "nat-frontier", + "version": "after", + "threads": 8, + "peak_rss_kib": 502016, + "report": { + "backend": "new-bytecode", + "function_rows": [], + "initial_execute_seconds": 0.005658887, + "prepare_seconds": 0.131574581, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.005292236 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.004251044 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.004685638 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.003642888 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.003597198 + } + ], + "setup_seconds": 0.307630262, + "thp_disabled": true, + "source_report": ".lake/trace-rom-reuse/nat-frontier-after-8.json" + } + }, + { + "workload": "environment", + "version": "before", + "threads": 1, + "peak_rss_kib": 1638336, + "report": { + "backend": "new-bytecode", + "function_rows": [], + "initial_execute_seconds": 0.36701827, + "prepare_seconds": 0.131748936, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.053992048 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.04522975 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.0460100940000001 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.045521451 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.035948373 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.030051527 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.031595177 + } + ], + "setup_seconds": 0.352281495, + "thp_disabled": true, + "source_report": ".lake/trace-rom-reuse/environment-before-1-control.json" + } + }, + { + "workload": "environment", + "version": "after", + "threads": 1, + "peak_rss_kib": 1614336, + "report": { + "backend": "new-bytecode", + "function_rows": [], + "initial_execute_seconds": 0.364770631, + "prepare_seconds": 0.132108845, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.099835276 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.05893824 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.038276022 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.035865654 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.035648138 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.03441593 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.035719573 + } + ], + "setup_seconds": 0.353487061, + "thp_disabled": true, + "source_report": ".lake/trace-rom-reuse/environment-after-1.json" + } + }, + { + "workload": "recursion-real", + "version": "before", + "threads": 64, + "peak_rss_kib": 32892492, + "report": { + "backend": "new-bytecode", + "function_rows": [], + "initial_execute_seconds": 8.506663605, + "prepare_seconds": 0.102233171, + "proof": null, + "reused_execution": false, + "samples": [ + { + "execute_seconds": 8.036972906, + "trace_with_lookups_seconds": 1.193211115 + }, + { + "execute_seconds": 7.965733047, + "trace_with_lookups_seconds": 1.2015805 + }, + { + "execute_seconds": 7.97696767, + "trace_with_lookups_seconds": 1.195626571 + } + ], + "setup_seconds": 0.039092586, + "thp_disabled": true, + "source_report": ".lake/trace-rom-reuse/recursion-real-before-64-execute-control.json" + } + }, + { + "workload": "recursion-real", + "version": "after", + "threads": 64, + "peak_rss_kib": 32386332, + "report": { + "backend": "new-bytecode", + "function_rows": [], + "initial_execute_seconds": 8.456119514, + "prepare_seconds": 0.102793352, + "proof": null, + "reused_execution": false, + "samples": [ + { + "execute_seconds": 7.855048111, + "trace_with_lookups_seconds": 0.82331303 + }, + { + "execute_seconds": 7.893231397, + "trace_with_lookups_seconds": 0.825366706 + }, + { + "execute_seconds": 7.960565911, + "trace_with_lookups_seconds": 0.813162851 + } + ], + "setup_seconds": 0.038498527, + "thp_disabled": true, + "source_report": ".lake/trace-rom-reuse/recursion-real-after-64-execute.json" + } + }, + { + "workload": "environment", + "version": "before", + "threads": 8, + "peak_rss_kib": 1783672, + "report": { + "backend": "new-bytecode", + "function_rows": [], + "initial_execute_seconds": 0.360020828, + "prepare_seconds": 0.130382701, + "proof": null, + "reused_execution": false, + "samples": [ + { + "execute_seconds": 0.34342845, + "trace_with_lookups_seconds": 0.171609409 + }, + { + "execute_seconds": 0.339794891, + "trace_with_lookups_seconds": 0.166820398 + }, + { + "execute_seconds": 0.33654005, + "trace_with_lookups_seconds": 0.17480632 + }, + { + "execute_seconds": 0.333318081, + "trace_with_lookups_seconds": 0.161910382 + }, + { + "execute_seconds": 0.327633773, + "trace_with_lookups_seconds": 0.164534814 + }, + { + "execute_seconds": 0.330828194, + "trace_with_lookups_seconds": 0.169791653 + }, + { + "execute_seconds": 0.341451165, + "trace_with_lookups_seconds": 0.168694825 + } + ], + "setup_seconds": 0.306169559, + "thp_disabled": true, + "source_report": ".lake/trace-rom-reuse/environment-before-8-execute-control.json" + } + }, + { + "workload": "environment", + "version": "after", + "threads": 8, + "peak_rss_kib": 1745552, + "report": { + "backend": "new-bytecode", + "function_rows": [], + "initial_execute_seconds": 0.352677831, + "prepare_seconds": 0.132380878, + "proof": null, + "reused_execution": false, + "samples": [ + { + "execute_seconds": 0.350287944, + "trace_with_lookups_seconds": 0.148761292 + }, + { + "execute_seconds": 0.359173343, + "trace_with_lookups_seconds": 0.155687993 + }, + { + "execute_seconds": 0.337600957, + "trace_with_lookups_seconds": 0.149076474 + }, + { + "execute_seconds": 0.328338814, + "trace_with_lookups_seconds": 0.152075767 + }, + { + "execute_seconds": 0.347675405, + "trace_with_lookups_seconds": 0.149049375 + }, + { + "execute_seconds": 0.356321865, + "trace_with_lookups_seconds": 0.149276511 + }, + { + "execute_seconds": 0.359402022, + "trace_with_lookups_seconds": 0.148436867 + } + ], + "setup_seconds": 0.305503672, + "thp_disabled": true, + "source_report": ".lake/trace-rom-reuse/environment-after-8-execute.json" + } + } +] diff --git a/docs/benchmarks/formal-aiur-rom-reuse/summary.csv b/docs/benchmarks/formal-aiur-rom-reuse/summary.csv new file mode 100644 index 000000000..8582d14f6 --- /dev/null +++ b/docs/benchmarks/formal-aiur-rom-reuse/summary.csv @@ -0,0 +1,17 @@ +workload,version,threads,reused_execution,samples,trace_median_seconds,trace_min_seconds,trace_max_seconds,execute_median_seconds,peak_rss_kib,cells +recursion-real,before,64,True,5,1.17903538,1.155563461,1.200906444,,33161460,937960213 +recursion-real,after,64,True,5,0.815869941,0.774523583,0.834549858,,32855756,937960213 +recursion-real,legacy,64,True,5,0.687254515,0.580716202,0.749651405,,30698904,985571600 +recursion-real,before,8,True,5,3.746706993,3.712494595,3.965910889,,31267400,937960213 +recursion-real,after,8,True,5,3.346335667,3.322383143,3.451785187,,31261444,937960213 +environment,before,64,True,5,0.046271222,0.045158082,0.05074245,,2735500,43146214 +environment,after,64,True,5,0.037519189,0.034540328,0.046118373,,2692984,43146214 +environment,legacy,64,True,5,0.043628496,0.027207929,0.063414971,,2860884,45169839 +nat-frontier,before,8,True,5,0.004854088,0.003766314,0.005860235,,528948,1173983 +nat-frontier,after,8,True,5,0.004251044,0.003597198,0.005292236,,502016,1173983 +environment,before,1,True,7,1.04522975,1.030051527,1.053992048,,1638336,43146214 +environment,after,1,True,7,1.035865654,1.03441593,1.099835276,,1614336,43146214 +recursion-real,before,64,False,3,1.195626571,1.193211115,1.2015805,7.97696767,32892492,937960213 +recursion-real,after,64,False,3,0.82331303,0.813162851,0.825366706,7.893231397,32386332,937960213 +environment,before,8,False,7,0.168694825,0.161910382,0.17480632,0.33654005,1783672,43146214 +environment,after,8,False,7,0.149076474,0.148436867,0.155687993,0.350287944,1745552,43146214 diff --git a/docs/benchmarks/formal-aiur-trace-profile/manifest.json b/docs/benchmarks/formal-aiur-trace-profile/manifest.json new file mode 100644 index 000000000..f03dbde39 --- /dev/null +++ b/docs/benchmarks/formal-aiur-trace-profile/manifest.json @@ -0,0 +1,37 @@ +{ + "date": "2026-10-28", + "base_revision": "1a19788bc051528aa59d37756d405752b166e012", + "phase_threads": 64, + "phase_samples": 3, + "nat_samples": 5, + "warmups": 2, + "nat_threads": [ + 1, + 8, + 32, + 64 + ], + "reuse_execution": true, + "host_lookups": true, + "thp_disabled": true, + "rustflags": "-Ctarget-cpu=native", + "profile_features": "parallel,aiur/trace-profile", + "profiled_binary_sha256": "1b3c052fbe957172bbbf4cf8705e3b4ae545cdadf094bc18f04bd3d955489f95", + "artifact_input_sha256": { + ".lake/formal-integration/ixvm-tuned.json": "1f8c10da7b10587e985d5166b26ad0c7edd4f4cbdfe0978c7deb237cf6683d9a", + ".lake/formal-integration/recursion-tuned.json": "40e88dd1f84e4f119626189e83f8eb181f6ef9875c190f33cdd7853e83c5afe1", + ".lake/formal-comparison/final/ixvm-input.json": "2733974cdf8d687799f678140ab967d3ab2c5a9f8768c8c3455bc86b5281a7b8", + ".lake/formal-comparison/final/environment-input.json": "14a147c1d6141721547092a9a835249969aa1f82c8f57f9ed0a2b0522f7aaa56", + ".lake/formal-comparison/final/new-environment-grouped.json.inner/input.json": "2ecf2051d112503637b9d3c1a6201bd66f91df4568a95faff3cef068e3f96a1a" + }, + "validation": [ + "Profiled Nat.add_comm proof verifies (5478175 bytes, same size as unprofiled)", + "Grouped trace/proof regression passes with trace-profile enabled", + "Clippy passes with warnings denied for the profiled comparison example" + ], + "notes": [ + "Phase timings are sequential wall-clock checkpoints; per-circuit spans overlap and cannot be summed", + "Profile logging is outside the reported profile total and inside the outer benchmark timer", + "The Nat frontier scaling sweep used the ordinary binary before enabling profiling" + ] +} diff --git a/docs/benchmarks/formal-aiur-trace-profile/nat-frontier-runs.json b/docs/benchmarks/formal-aiur-trace-profile/nat-frontier-runs.json new file mode 100644 index 000000000..0fb83b51b --- /dev/null +++ b/docs/benchmarks/formal-aiur-trace-profile/nat-frontier-runs.json @@ -0,0 +1,246 @@ +{ + "legacy-1": { + "thp_disabled": true, + "setup_seconds": 0.120975996, + "samples": [ + { + "trace_with_lookups_seconds": 0.012478271, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.012028038, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.011956103, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.01217488, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.011935519, + "execute_seconds": null + } + ], + "reused_execution": true, + "proof": null, + "initial_execute_seconds": 0.014163194, + "backend": "legacy-bytecode" + }, + "legacy-32": { + "thp_disabled": true, + "setup_seconds": 0.070487177, + "samples": [ + { + "trace_with_lookups_seconds": 0.014779181, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.014267297, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.01339321, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.013107607, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.013102537, + "execute_seconds": null + } + ], + "reused_execution": true, + "proof": null, + "initial_execute_seconds": 0.014142136, + "backend": "legacy-bytecode" + }, + "legacy-64": { + "thp_disabled": true, + "setup_seconds": 0.07812747, + "samples": [ + { + "trace_with_lookups_seconds": 0.015566075, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.015574868, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.015219073, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.015564552, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.014942384, + "execute_seconds": null + } + ], + "reused_execution": true, + "proof": null, + "initial_execute_seconds": 0.013910478, + "backend": "legacy-bytecode" + }, + "legacy-8": { + "thp_disabled": true, + "setup_seconds": 0.07516096, + "samples": [ + { + "trace_with_lookups_seconds": 0.01256787, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.012339572, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.014384268, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.009214589, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.011877105, + "execute_seconds": null + } + ], + "reused_execution": true, + "proof": null, + "initial_execute_seconds": 0.014071228, + "backend": "legacy-bytecode" + }, + "new-1": { + "backend": "new-bytecode", + "initial_execute_seconds": 0.006142283, + "prepare_seconds": 0.123633447, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.020932274 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.019830428 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.019796538 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.019672556 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.019737968 + } + ], + "setup_seconds": 0.353909596, + "thp_disabled": true + }, + "new-32": { + "backend": "new-bytecode", + "initial_execute_seconds": 0.005722324, + "prepare_seconds": 0.128970265, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.004883333 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.005035318 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.004258492 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.004430207 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.004429382 + } + ], + "setup_seconds": 0.302645966, + "thp_disabled": true + }, + "new-64": { + "backend": "new-bytecode", + "initial_execute_seconds": 0.005869321, + "prepare_seconds": 0.129300466, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.005457398 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.005455055 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.005070982 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.004546933 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.005195302 + } + ], + "setup_seconds": 0.307874953, + "thp_disabled": true + }, + "new-8": { + "backend": "new-bytecode", + "initial_execute_seconds": 0.005795452, + "prepare_seconds": 0.126303895, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.005281514 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.0052951 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.004992366 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.004420117 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.004661302 + } + ], + "setup_seconds": 0.299281124, + "thp_disabled": true + } +} diff --git a/docs/benchmarks/formal-aiur-trace-profile/nat-frontier.csv b/docs/benchmarks/formal-aiur-trace-profile/nat-frontier.csv new file mode 100644 index 000000000..f62b07b53 --- /dev/null +++ b/docs/benchmarks/formal-aiur-trace-profile/nat-frontier.csv @@ -0,0 +1,9 @@ +backend,threads,median_ms,min_ms,max_ms +legacy,1,12.028038,11.935519000000001,12.478271000000001 +new,1,19.796537999999998,19.672556,20.932274 +legacy,8,12.339572,9.214589,14.384268 +new,8,4.992366,4.420117,5.2951 +legacy,32,13.39321,13.102537,14.779181000000001 +new,32,4.430207,4.258492,5.035318 +legacy,64,15.564552,14.942383999999999,15.574868 +new,64,5.195302,4.546933,5.4573979999999995 diff --git a/docs/benchmarks/formal-aiur-trace-profile/phase-summary.csv b/docs/benchmarks/formal-aiur-trace-profile/phase-summary.csv new file mode 100644 index 000000000..6b81c1035 --- /dev/null +++ b/docs/benchmarks/formal-aiur-trace-profile/phase-summary.csv @@ -0,0 +1,25 @@ +workload,phase,median_seconds,min_seconds,max_seconds +nat-frontier,validate_and_root,0.000478113,0.000449092,0.000491713 +nat-frontier,rom_index,0.000179741,0.000174895,0.000197683 +nat-frontier,auxiliary_counts,0.000313809,0.000282546,0.000449697 +nat-frontier,rom_partition,0.000131174,0.000128579,0.0001355 +nat-frontier,populate_circuits,0.004312875,0.003952003,0.004467018 +nat-frontier,check_shape,6.648e-06,5.923e-06,7.07e-06 +nat-frontier,cleanup,7.253e-06,5.438e-06,8.311e-06 +nat-frontier,total,0.005428307,0.005234007,0.005523038 +environment,validate_and_root,0.002842828,0.002795816,0.002960328 +environment,rom_index,0.00616681,0.006078668,0.006545034 +environment,auxiliary_counts,0.001228802,0.001069443,0.001481691 +environment,rom_partition,0.005474557,0.004893128,0.007046908 +environment,populate_circuits,0.033344161,0.030517027,0.038378088 +environment,check_shape,8.958e-06,8.956e-06,1.0774e-05 +environment,cleanup,7.762e-06,5.763e-06,9.043e-06 +environment,total,0.048937053,0.048158767,0.053779366 +recursion-real,validate_and_root,0.023119241,0.023087607,0.023120912 +recursion-real,rom_index,0.232557565,0.230787776,0.234007817 +recursion-real,auxiliary_counts,0.024400828,0.02381734,0.024516162 +recursion-real,rom_partition,0.125742256,0.124718225,0.1278865 +recursion-real,populate_circuits,0.777291425,0.773331998,0.798083393 +recursion-real,check_shape,6.048e-06,5.41e-06,7.17e-06 +recursion-real,cleanup,0.011573816,0.011460786,0.011718546 +recursion-real,total,1.197592147,1.190875994,1.212773213 diff --git a/docs/benchmarks/formal-aiur-trace-profile/phases.jsonl b/docs/benchmarks/formal-aiur-trace-profile/phases.jsonl new file mode 100644 index 000000000..ae275bb47 --- /dev/null +++ b/docs/benchmarks/formal-aiur-trace-profile/phases.jsonl @@ -0,0 +1,9 @@ +{"workload":"nat-frontier","sample":0,"circuits":[["IxVM::verify_claim",3.509e-06],["ixvm_group_00",0.000209774],["ixvm_group_01",0.000210161],["ixvm_group_02",0.000606258],["ixvm_group_03",0.000558862],["UInt32::less_than_fields",0.000995861],["ixvm_group_04",0.000189384],["Blake3::compress",0.00100105],["Blake3::compress_chunks",0.000654361],["ixvm_group_05",0.000361325],["ixvm_group_06",2.5641e-05],["ixvm_group_07",0.000578699],["ixvm_group_08",0.000244015],["${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}",8.75e-06],["ixvm_group_09",5.15e-07],["ixvm_group_10",0.000616446],["ixvm_group_11",3.3854e-05],["ixvm_group_12",9.51e-07],["ixvm_group_13",5.71e-07],["ixvm_group_14",7.56e-07],["ixvm_group_15",0.004175355],["IxVM::get_address",0.000182369],["ixvm_group_16",1.623e-05],["ixvm_group_17",1.7451e-05],["ixvm_group_18",0.00012663],["ixvm_group_19",0.000253723],["ixvm_group_20",9.9499e-05],["ixvm_group_21",4.6093e-05],["ixvm_group_22",6.3391e-05],["ixvm_group_23",0.000977206],["ixvm_group_24",0.000610146],["UInt64::saturating_pred",3.0482e-05],["ixvm_group_25",0.000915377],["ixvm_group_26",0.000166596],["ixvm_group_27",3.4341e-05],["ixvm_group_28",2.9819e-05],["ixvm_group_29",1.5089e-05],["ixvm_group_30",0.000870556],["ixvm_group_31",0.000586071],["ixvm_group_32",0.000169643],["ixvm_group_33",0.000241242],["ixvm_group_34",6.998e-06],["ixvm_group_35",5.3626e-05],["ixvm_group_36",3.5252e-05],["ixvm_group_37",4.9605e-05],["ixvm_group_38",3.7354e-05],["ixvm_group_39",6.4481e-05],["ixvm_group_40",4.8628e-05],["ixvm_group_41",3.5621e-05],["ixvm_group_42",6.2356e-05],["ixvm_group_43",0.000162161],["ixvm_group_44",2.8708e-05],["${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}",0.000706356],["${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}",5.5865e-05],["ixvm_group_45",2.8488e-05],["ixvm_group_46",0.000101682],["ixvm_group_47",7.85e-07],["ixvm_group_48",1.3738e-05],["ixvm_group_49",1.9896e-05],["ixvm_group_50",1.0706e-05],["ixvm_group_51",4.3035e-05],["ixvm_group_52",2.4071e-05],["ixvm_group_53",4.92e-07],["ixvm_group_54",3.36e-07],["ixvm_group_55",2.84e-07],["ixvm_group_56",1.0303e-05],["ixvm_group_57",9.25e-07],["ixvm_group_58",3.7604e-05],["ixvm_group_59",1.2087e-05],["ixvm_group_60",0.00052271],["ixvm_group_61",9.315e-06],["${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}",1.5715e-05],["ixvm_group_62",9.182e-06],["ixvm_group_63",0.000192204],["ixvm_group_64",5.7413e-05],["ixvm_group_65",1.6183e-05],["ixvm_group_66",8.3533e-05],["ixvm_group_67",0.000263679],["ixvm_group_68",4.1316e-05],["ixvm_group_69",1.8001e-05],["ixvm_group_70",1.2836e-05],["ixvm_group_71",9.154e-06],["ixvm_group_72",1.2343e-05],["ixvm_group_73",2.8285e-05],["IxVM::expr_inst_levels",2.0957e-05],["ixvm_group_74",0.00077173],["ixvm_group_75",0.000647293],["ixvm_group_76",4.2156e-05],["ixvm_group_77",6.2035e-05],["IxVM::has_bvar_in_range",3.1158e-05],["ixvm_group_78",3.0998e-05],["ixvm_group_79",1.471e-06],["ixvm_group_80",7.9214e-05],["IxVM::k_is_def_eq_ordered",1.3997e-05],["IxVM::try_def_eq_app",3.4687e-05],["ixvm_group_81",3.5044e-05],["ixvm_group_82",0.000302103],["ixvm_group_83",7.0575e-05],["ixvm_group_84",2.2938e-05],["ixvm_group_85",8.73e-07],["ixvm_group_86",1.4481e-05],["ixvm_group_87",1.897e-06],["ixvm_group_88",6.981e-06],["ixvm_group_89",9.207e-06],["ixvm_group_90",2.5146e-05],["IxVM::try_string_lit_one",1.1168e-05],["ixvm_group_91",1.451e-05],["IxVM::whnf_nd_with_spine",1.3126e-05],["IxVM::expr_inst1_walk",1.4786e-05],["ixvm_group_92",0.000100966],["ixvm_group_93",6.3083e-05],["ixvm_group_94",2.7687e-05],["ixvm_group_95",1.6062e-05],["ixvm_group_96",1.1678e-05],["ixvm_group_97",7.16e-06],["ixvm_group_98",2.5243e-05],["ixvm_group_99",5.76e-07],["ixvm_group_100",2.1288e-05],["ixvm_group_101",5.06e-07],["ixvm_group_102",1.1549e-05],["ixvm_group_103",9.062e-06],["ixvm_group_104",1.444e-06],["ixvm_group_105",7.91e-07],["ixvm_group_106",1.505e-06],["ixvm_group_107",8.47e-07],["IxVM::k_is_def_eq_slow_nd",1.1707e-05],["IxVM::whnf_struct_core",1.9617e-05],["ixvm_group_108",2.0842e-05],["IxVM::try_eta_struct",7.722e-06],["ixvm_group_109",1.4015e-05],["IxVM::is_nat_zero",8.538e-06],["IxVM::k_is_def_eq_struct_bounded",1.6857e-05],["ixvm_group_110",2.5041e-05],["IxVM::expr_glb",0.000546403],["IxVM::expr_glb_binder",4.685e-06],["IxVM::k_infer_rebase",8.242e-06],["IxVM::canon_ord_cmp_g",0.00029618],["IxVM::canon_addr_cmp",8.0203e-05],["IxVM::canon_addr_chunk",3.6877e-05],["ixvm_group_111",1.138e-06],["IxVM::g_list_has",1.1913e-05],["",1.5269e-05],["",0.004072052],["",7.4099e-05],["",2.81e-07],["",0.000504859],["",2.89e-05],["",3.85e-07],["",3.255e-06],["",8.54e-07],["",2.37e-06],["",4.07e-06],["",3.27e-07],["",2.179e-06],["",0.00011874],["",8.94e-07],["",0.000715345],["",5.652e-06],["",1.341e-06],["",2.105e-06],["",2.24e-07],["",1.44e-07]],"elapsed_seconds":0.005428307,"event":"aiur_trace_profile","host_lookups":true,"phases":[["validate_and_root",0.000478113],["rom_index",0.000179741],["auxiliary_counts",0.000313809],["rom_partition",0.000131174],["populate_circuits",0.004312875],["check_shape",7.07e-06],["cleanup",5.438e-06]]} +{"workload":"nat-frontier","sample":1,"circuits":[["IxVM::verify_claim",3.002e-06],["ixvm_group_00",0.000207764],["ixvm_group_01",0.000164457],["ixvm_group_02",0.00091274],["ixvm_group_03",0.000631924],["UInt32::less_than_fields",0.000640496],["ixvm_group_04",0.000117114],["Blake3::compress",0.001045006],["Blake3::compress_chunks",0.001032309],["ixvm_group_05",0.000509446],["ixvm_group_06",2.2442e-05],["ixvm_group_07",0.000364596],["ixvm_group_08",0.000321505],["${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}",9.06e-06],["ixvm_group_09",8.49e-07],["ixvm_group_10",0.000599739],["ixvm_group_11",4.3293e-05],["ixvm_group_12",1.497e-06],["ixvm_group_13",1.965e-06],["ixvm_group_14",1.889e-06],["ixvm_group_15",3.4788e-05],["IxVM::get_address",0.000125209],["ixvm_group_16",1.9789e-05],["ixvm_group_17",1.2738e-05],["ixvm_group_18",0.00016568],["ixvm_group_19",0.000276598],["ixvm_group_20",0.000142798],["ixvm_group_21",5.7526e-05],["ixvm_group_22",0.000113274],["ixvm_group_23",0.000987084],["ixvm_group_24",0.000587524],["UInt64::saturating_pred",3.3876e-05],["ixvm_group_25",0.000994286],["ixvm_group_26",0.000539209],["ixvm_group_27",6.6617e-05],["ixvm_group_28",2.9918e-05],["ixvm_group_29",1.6012e-05],["ixvm_group_30",0.000183009],["ixvm_group_31",0.000414499],["ixvm_group_32",0.000153176],["ixvm_group_33",0.000214215],["ixvm_group_34",8.692e-06],["ixvm_group_35",5.8891e-05],["ixvm_group_36",3.8153e-05],["ixvm_group_37",3.3129e-05],["ixvm_group_38",4.3008e-05],["ixvm_group_39",5.1984e-05],["ixvm_group_40",5.4936e-05],["ixvm_group_41",4.5618e-05],["ixvm_group_42",6.2685e-05],["ixvm_group_43",0.00020307],["ixvm_group_44",3.072e-05],["${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}",4.3529e-05],["${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}",6.5285e-05],["ixvm_group_45",3.3918e-05],["ixvm_group_46",0.000110141],["ixvm_group_47",9.25e-07],["ixvm_group_48",1.9587e-05],["ixvm_group_49",2.1654e-05],["ixvm_group_50",1.1382e-05],["ixvm_group_51",3.6941e-05],["ixvm_group_52",2.2029e-05],["ixvm_group_53",6.85e-07],["ixvm_group_54",3.7e-07],["ixvm_group_55",5e-07],["ixvm_group_56",1.2763e-05],["ixvm_group_57",1.988e-06],["ixvm_group_58",3.4455e-05],["ixvm_group_59",1.5474e-05],["ixvm_group_60",0.000334101],["ixvm_group_61",1.119e-05],["${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}",1.7354e-05],["ixvm_group_62",2.4126e-05],["ixvm_group_63",6.7255e-05],["ixvm_group_64",0.000160302],["ixvm_group_65",1.9581e-05],["ixvm_group_66",9.342e-05],["ixvm_group_67",4.4759e-05],["ixvm_group_68",4.4162e-05],["ixvm_group_69",1.7002e-05],["ixvm_group_70",1.4179e-05],["ixvm_group_71",9.43e-06],["ixvm_group_72",1.0927e-05],["ixvm_group_73",2.2987e-05],["IxVM::expr_inst_levels",2.1664e-05],["ixvm_group_74",0.000775754],["ixvm_group_75",4.3233e-05],["ixvm_group_76",3.7979e-05],["ixvm_group_77",5.1255e-05],["IxVM::has_bvar_in_range",0.000910757],["ixvm_group_78",3.1559e-05],["ixvm_group_79",2.11e-06],["ixvm_group_80",0.000110282],["IxVM::k_is_def_eq_ordered",1.2988e-05],["IxVM::try_def_eq_app",3.7216e-05],["ixvm_group_81",3.7112e-05],["ixvm_group_82",0.000585277],["ixvm_group_83",7.6408e-05],["ixvm_group_84",2.2132e-05],["ixvm_group_85",9.65e-07],["ixvm_group_86",1.5172e-05],["ixvm_group_87",3.111e-06],["ixvm_group_88",1.7278e-05],["ixvm_group_89",1.104e-05],["ixvm_group_90",2.5395e-05],["IxVM::try_string_lit_one",1.0212e-05],["ixvm_group_91",1.3947e-05],["IxVM::whnf_nd_with_spine",8.249e-06],["IxVM::expr_inst1_walk",1.2509e-05],["ixvm_group_92",0.000111029],["ixvm_group_93",8.5066e-05],["ixvm_group_94",2.8177e-05],["ixvm_group_95",1.6808e-05],["ixvm_group_96",1.1756e-05],["ixvm_group_97",8.893e-06],["ixvm_group_98",2.4118e-05],["ixvm_group_99",6.83e-07],["ixvm_group_100",2.2239e-05],["ixvm_group_101",1.063e-06],["ixvm_group_102",1.3632e-05],["ixvm_group_103",1.1593e-05],["ixvm_group_104",1.375e-06],["ixvm_group_105",3.91e-07],["ixvm_group_106",1.104e-06],["ixvm_group_107",1.744e-06],["IxVM::k_is_def_eq_slow_nd",1.1924e-05],["IxVM::whnf_struct_core",1.5699e-05],["ixvm_group_108",2.4343e-05],["IxVM::try_eta_struct",1.2423e-05],["ixvm_group_109",1.4612e-05],["IxVM::is_nat_zero",3.841e-06],["IxVM::k_is_def_eq_struct_bounded",1.25e-05],["ixvm_group_110",2.7988e-05],["IxVM::expr_glb",1.547e-05],["IxVM::expr_glb_binder",7.15e-06],["IxVM::k_infer_rebase",1.1606e-05],["IxVM::canon_ord_cmp_g",0.000966268],["IxVM::canon_addr_cmp",7.3238e-05],["IxVM::canon_addr_chunk",3.6494e-05],["ixvm_group_111",6.56e-07],["IxVM::g_list_has",1.234e-05],["",1.5202e-05],["",0.003686836],["",0.000857994],["",1.869e-06],["",0.00054526],["",0.001225398],["",1.486e-06],["",5.257e-06],["",3.023e-06],["",3.061e-06],["",3.766e-06],["",3.83e-07],["",2.168e-06],["",5.4802e-05],["",8.2e-07],["",1.6404e-05],["",4.596e-06],["",1.243e-06],["",3.004e-06],["",7.3e-07],["",1.75e-07]],"elapsed_seconds":0.005234007,"event":"aiur_trace_profile","host_lookups":true,"phases":[["validate_and_root",0.000491713],["rom_index",0.000197683],["auxiliary_counts",0.000449697],["rom_partition",0.000128579],["populate_circuits",0.003952003],["check_shape",5.923e-06],["cleanup",8.311e-06]]} +{"workload":"nat-frontier","sample":2,"circuits":[["IxVM::verify_claim",3.603e-06],["ixvm_group_00",0.000235365],["ixvm_group_01",0.001286986],["ixvm_group_02",0.001239435],["ixvm_group_03",0.001165083],["UInt32::less_than_fields",0.001087296],["ixvm_group_04",0.000134173],["Blake3::compress",0.001228355],["Blake3::compress_chunks",0.001231088],["ixvm_group_05",0.000333558],["ixvm_group_06",2.2228e-05],["ixvm_group_07",0.000532408],["ixvm_group_08",0.000256872],["${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}",9.815e-06],["ixvm_group_09",6.98e-07],["ixvm_group_10",0.001270438],["ixvm_group_11",3.8444e-05],["ixvm_group_12",7.37e-07],["ixvm_group_13",7.05e-07],["ixvm_group_14",9.59e-07],["ixvm_group_15",3.8524e-05],["IxVM::get_address",7.6056e-05],["ixvm_group_16",2.407e-05],["ixvm_group_17",1.4075e-05],["ixvm_group_18",0.000138671],["ixvm_group_19",0.000262659],["ixvm_group_20",0.000101028],["ixvm_group_21",4.3301e-05],["ixvm_group_22",5.0622e-05],["ixvm_group_23",0.000957046],["ixvm_group_24",0.000737503],["UInt64::saturating_pred",3.1578e-05],["ixvm_group_25",0.000739702],["ixvm_group_26",9.0544e-05],["ixvm_group_27",0.000206729],["ixvm_group_28",3.4151e-05],["ixvm_group_29",1.2875e-05],["ixvm_group_30",8.4229e-05],["ixvm_group_31",0.001154306],["ixvm_group_32",0.000165157],["ixvm_group_33",0.000171244],["ixvm_group_34",8.104e-06],["ixvm_group_35",4.5357e-05],["ixvm_group_36",3.7614e-05],["ixvm_group_37",4.1441e-05],["ixvm_group_38",3.9413e-05],["ixvm_group_39",5.6814e-05],["ixvm_group_40",6.0814e-05],["ixvm_group_41",3.0045e-05],["ixvm_group_42",5.992e-05],["ixvm_group_43",0.000153783],["ixvm_group_44",2.7022e-05],["${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}",2.2585e-05],["${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}",5.519e-05],["ixvm_group_45",2.9829e-05],["ixvm_group_46",0.000105262],["ixvm_group_47",7.03e-07],["ixvm_group_48",1.6711e-05],["ixvm_group_49",2.0713e-05],["ixvm_group_50",9.083e-06],["ixvm_group_51",3.8565e-05],["ixvm_group_52",2.5111e-05],["ixvm_group_53",7.9e-07],["ixvm_group_54",3.95e-07],["ixvm_group_55",3.5e-07],["ixvm_group_56",1.1428e-05],["ixvm_group_57",8.77e-07],["ixvm_group_58",3.2834e-05],["ixvm_group_59",1.3264e-05],["ixvm_group_60",0.000105964],["ixvm_group_61",9.596e-06],["${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}",0.000104577],["ixvm_group_62",9.178e-06],["ixvm_group_63",6.4287e-05],["ixvm_group_64",7.3084e-05],["ixvm_group_65",1.9865e-05],["ixvm_group_66",0.000104161],["ixvm_group_67",7.4182e-05],["ixvm_group_68",3.6848e-05],["ixvm_group_69",2.07e-05],["ixvm_group_70",1.3507e-05],["ixvm_group_71",8.734e-06],["ixvm_group_72",1.3064e-05],["ixvm_group_73",3.3053e-05],["IxVM::expr_inst_levels",2.1438e-05],["ixvm_group_74",5.6013e-05],["ixvm_group_75",0.00129064],["ixvm_group_76",5.843e-05],["ixvm_group_77",5.2901e-05],["IxVM::has_bvar_in_range",3.131e-05],["ixvm_group_78",3.6066e-05],["ixvm_group_79",1.971e-06],["ixvm_group_80",0.000112312],["IxVM::k_is_def_eq_ordered",9.312e-06],["IxVM::try_def_eq_app",3.4612e-05],["ixvm_group_81",3.8481e-05],["ixvm_group_82",0.000125225],["ixvm_group_83",5.6995e-05],["ixvm_group_84",1.8152e-05],["ixvm_group_85",6.2e-07],["ixvm_group_86",1.3024e-05],["ixvm_group_87",7.58e-07],["ixvm_group_88",9.754e-06],["ixvm_group_89",8.703e-06],["ixvm_group_90",2.4318e-05],["IxVM::try_string_lit_one",9.548e-06],["ixvm_group_91",1.0454e-05],["IxVM::whnf_nd_with_spine",9.684e-06],["IxVM::expr_inst1_walk",1.5803e-05],["ixvm_group_92",0.000104806],["ixvm_group_93",9.1039e-05],["ixvm_group_94",3.6066e-05],["ixvm_group_95",1.5242e-05],["ixvm_group_96",1.3205e-05],["ixvm_group_97",6.134e-06],["ixvm_group_98",2.5096e-05],["ixvm_group_99",9.43e-07],["ixvm_group_100",2.4849e-05],["ixvm_group_101",6.27e-07],["ixvm_group_102",1.014e-05],["ixvm_group_103",1.0792e-05],["ixvm_group_104",1.225e-06],["ixvm_group_105",6.25e-07],["ixvm_group_106",4.66e-07],["ixvm_group_107",3.3e-07],["IxVM::k_is_def_eq_slow_nd",8.356e-06],["IxVM::whnf_struct_core",1.0139e-05],["ixvm_group_108",1.6922e-05],["IxVM::try_eta_struct",7.821e-06],["ixvm_group_109",1.1914e-05],["IxVM::is_nat_zero",4.768e-06],["IxVM::k_is_def_eq_struct_bounded",1.2768e-05],["ixvm_group_110",2.8218e-05],["IxVM::expr_glb",2.0149e-05],["IxVM::expr_glb_binder",4.392e-06],["IxVM::k_infer_rebase",8.237e-06],["IxVM::canon_ord_cmp_g",0.000273951],["IxVM::canon_addr_cmp",4.347e-05],["IxVM::canon_addr_chunk",8.9825e-05],["ixvm_group_111",8.46e-07],["IxVM::g_list_has",1.1579e-05],["",1.5679e-05],["",0.004214735],["",5.4726e-05],["",7.4e-07],["",0.000925472],["",0.001181213],["",9.44e-07],["",5.647e-06],["",5.792e-06],["",6.643e-06],["",3.008e-06],["",6.09e-07],["",1.957e-06],["",4.6162e-05],["",7.23e-07],["",1.7319e-05],["",5.36e-06],["",1.357e-06],["",1.246e-06],["",2.48e-07],["",1.46e-07]],"elapsed_seconds":0.005523038,"event":"aiur_trace_profile","host_lookups":true,"phases":[["validate_and_root",0.000449092],["rom_index",0.000174895],["auxiliary_counts",0.000282546],["rom_partition",0.0001355],["populate_circuits",0.004467018],["check_shape",6.648e-06],["cleanup",7.253e-06]]} +{"workload":"environment","sample":0,"circuits":[["IxVM::verify_claim",5.21e-06],["ixvm_group_00",0.030161091],["ixvm_group_01",0.003765326],["ixvm_group_02",0.027860716],["ixvm_group_03",0.021347046],["UInt32::less_than_fields",0.030014109],["ixvm_group_04",0.012425024],["Blake3::compress",0.029898692],["Blake3::compress_chunks",0.037926441],["ixvm_group_05",0.029893606],["ixvm_group_06",0.000284974],["ixvm_group_07",0.029704518],["ixvm_group_08",0.027705637],["${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}",0.000490122],["ixvm_group_09",0.000297471],["ixvm_group_10",0.029888207],["ixvm_group_11",0.002561429],["ixvm_group_12",2.613e-06],["ixvm_group_13",1.977e-06],["ixvm_group_14",0.029875207],["ixvm_group_15",0.002571047],["IxVM::get_address",0.029872501],["ixvm_group_16",0.001483546],["ixvm_group_17",0.029883721],["ixvm_group_18",0.029575579],["ixvm_group_19",0.030025422],["ixvm_group_20",0.003017768],["ixvm_group_21",0.001293978],["ixvm_group_22",0.029886403],["ixvm_group_23",0.000769681],["ixvm_group_24",0.029987132],["UInt64::saturating_pred",0.029967476],["ixvm_group_25",0.029950265],["ixvm_group_26",0.029839848],["ixvm_group_27",0.027702437],["ixvm_group_28",0.003769004],["ixvm_group_29",0.029898641],["ixvm_group_30",0.029887573],["ixvm_group_31",0.029851558],["ixvm_group_32",0.014129876],["ixvm_group_33",0.003428752],["ixvm_group_34",0.001067067],["ixvm_group_35",0.000788377],["ixvm_group_36",0.001741469],["ixvm_group_37",0.001582138],["ixvm_group_38",0.009502851],["ixvm_group_39",0.002802034],["ixvm_group_40",0.002146832],["ixvm_group_41",0.00026578],["ixvm_group_42",0.002081777],["ixvm_group_43",0.017395483],["ixvm_group_44",0.000496329],["${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}",0.003117457],["${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}",0.015650268],["ixvm_group_45",0.000134058],["ixvm_group_46",0.017226541],["ixvm_group_47",1.895e-06],["ixvm_group_48",0.001528906],["ixvm_group_49",0.000196471],["ixvm_group_50",0.000476402],["ixvm_group_51",0.000669995],["ixvm_group_52",0.000144359],["ixvm_group_53",1.58e-06],["ixvm_group_54",0.004160935],["ixvm_group_55",2.012e-06],["ixvm_group_56",0.000909115],["ixvm_group_57",8.1656e-05],["ixvm_group_58",0.001771513],["ixvm_group_59",0.000741776],["ixvm_group_60",0.002498128],["ixvm_group_61",0.000982012],["${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}",0.001936072],["ixvm_group_62",0.002761016],["ixvm_group_63",0.019554341],["ixvm_group_64",0.017356281],["ixvm_group_65",0.000285095],["ixvm_group_66",0.022547036],["ixvm_group_67",0.019858219],["ixvm_group_68",0.022836217],["ixvm_group_69",0.000201753],["ixvm_group_70",0.000503655],["ixvm_group_71",0.001382255],["ixvm_group_72",0.001037226],["ixvm_group_73",0.029786038],["IxVM::expr_inst_levels",0.000899773],["ixvm_group_74",0.028246468],["ixvm_group_75",0.007819313],["ixvm_group_76",0.027280007],["ixvm_group_77",0.029834114],["IxVM::has_bvar_in_range",0.005531991],["ixvm_group_78",0.024862542],["ixvm_group_79",0.000405708],["ixvm_group_80",0.029474785],["IxVM::k_is_def_eq_ordered",0.002966245],["IxVM::try_def_eq_app",0.006048646],["ixvm_group_81",0.005086213],["ixvm_group_82",0.029833397],["ixvm_group_83",0.026151451],["ixvm_group_84",0.000194866],["ixvm_group_85",0.001219449],["ixvm_group_86",0.000971067],["ixvm_group_87",0.000838194],["ixvm_group_88",0.001054245],["ixvm_group_89",0.000783698],["ixvm_group_90",0.005544341],["IxVM::try_string_lit_one",0.023518856],["ixvm_group_91",0.011451963],["IxVM::whnf_nd_with_spine",0.004798531],["IxVM::expr_inst1_walk",0.005910614],["ixvm_group_92",0.000171178],["ixvm_group_93",0.000137608],["ixvm_group_94",5.0134e-05],["ixvm_group_95",0.001614951],["ixvm_group_96",0.002364958],["ixvm_group_97",0.003966253],["ixvm_group_98",0.026349555],["ixvm_group_99",0.004240545],["ixvm_group_100",0.002374723],["ixvm_group_101",0.001703201],["ixvm_group_102",0.024919864],["ixvm_group_103",0.023437037],["ixvm_group_104",0.029892439],["ixvm_group_105",8.5966e-05],["ixvm_group_106",0.000321081],["ixvm_group_107",0.000210871],["IxVM::k_is_def_eq_slow_nd",0.001899106],["IxVM::whnf_struct_core",0.002775939],["ixvm_group_108",0.029878565],["IxVM::try_eta_struct",0.001866774],["ixvm_group_109",0.002970978],["IxVM::is_nat_zero",0.000621618],["IxVM::k_is_def_eq_struct_bounded",0.029859584],["ixvm_group_110",0.001419082],["IxVM::expr_glb",0.029900645],["IxVM::expr_glb_binder",0.029017641],["IxVM::k_infer_rebase",0.027517364],["IxVM::canon_ord_cmp_g",2.052e-06],["IxVM::canon_addr_cmp",1.965e-06],["IxVM::canon_addr_chunk",2.556e-06],["ixvm_group_111",0.000191744],["IxVM::g_list_has",0.004597765],["",6.6473e-05],["",0.02023568],["",8.1315e-05],["",1.3166e-05],["",0.029793559],["",0.003231145],["",1.198e-05],["",7.13e-06],["",2.938e-06],["",4.704e-06],["",2.0306e-05],["",1.1632e-05],["",0.000134508],["",0.002842602],["",1.764e-06],["",0.001566986],["",0.000420247],["",1.336e-05],["",1.34e-05],["",7.1e-07],["",1.473e-06]],"elapsed_seconds":0.053779366,"event":"aiur_trace_profile","host_lookups":true,"phases":[["validate_and_root",0.002842828],["rom_index",0.00616681],["auxiliary_counts",0.001481691],["rom_partition",0.004893128],["populate_circuits",0.038378088],["check_shape",8.956e-06],["cleanup",7.762e-06]]} +{"workload":"environment","sample":1,"circuits":[["IxVM::verify_claim",4.904e-06],["ixvm_group_00",0.030368816],["ixvm_group_01",0.030176298],["ixvm_group_02",0.029916596],["ixvm_group_03",0.029912704],["UInt32::less_than_fields",0.004664512],["ixvm_group_04",0.030173835],["Blake3::compress",0.030239366],["Blake3::compress_chunks",0.030166636],["ixvm_group_05",0.03013704],["ixvm_group_06",0.000267569],["ixvm_group_07",0.029924833],["ixvm_group_08",0.007946843],["${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}",0.000401029],["ixvm_group_09",0.00027105],["ixvm_group_10",0.023089893],["ixvm_group_11",0.015529413],["ixvm_group_12",2.603e-06],["ixvm_group_13",8.24e-07],["ixvm_group_14",0.002264079],["ixvm_group_15",0.002399159],["IxVM::get_address",0.004035313],["ixvm_group_16",0.001187907],["ixvm_group_17",0.004286121],["ixvm_group_18",0.012878544],["ixvm_group_19",0.0095109],["ixvm_group_20",0.002971721],["ixvm_group_21",0.000990292],["ixvm_group_22",0.010989461],["ixvm_group_23",0.000321453],["ixvm_group_24",0.029912282],["UInt64::saturating_pred",0.000117541],["ixvm_group_25",0.025853693],["ixvm_group_26",0.015582495],["ixvm_group_27",0.012593617],["ixvm_group_28",0.003779072],["ixvm_group_29",0.022179825],["ixvm_group_30",0.00636019],["ixvm_group_31",0.01599992],["ixvm_group_32",0.002280518],["ixvm_group_33",0.003667531],["ixvm_group_34",0.001087311],["ixvm_group_35",0.000803505],["ixvm_group_36",0.00158225],["ixvm_group_37",0.001305499],["ixvm_group_38",0.008716245],["ixvm_group_39",0.00473598],["ixvm_group_40",0.002075225],["ixvm_group_41",0.000274969],["ixvm_group_42",0.000760172],["ixvm_group_43",0.011312942],["ixvm_group_44",0.000423933],["${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}",0.002530211],["${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}",0.011234738],["ixvm_group_45",0.000133824],["ixvm_group_46",0.014054318],["ixvm_group_47",2.177e-06],["ixvm_group_48",0.001729164],["ixvm_group_49",0.000201412],["ixvm_group_50",0.000497172],["ixvm_group_51",0.000990569],["ixvm_group_52",0.000207593],["ixvm_group_53",3.909e-06],["ixvm_group_54",0.003709247],["ixvm_group_55",2.908e-06],["ixvm_group_56",0.00101808],["ixvm_group_57",0.000208193],["ixvm_group_58",0.003874783],["ixvm_group_59",0.000842117],["ixvm_group_60",0.002684469],["ixvm_group_61",0.001278229],["${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}",0.002213229],["ixvm_group_62",0.003198641],["ixvm_group_63",0.025078405],["ixvm_group_64",0.017479693],["ixvm_group_65",0.000487816],["ixvm_group_66",0.020606577],["ixvm_group_67",0.011618371],["ixvm_group_68",0.020875582],["ixvm_group_69",0.000170428],["ixvm_group_70",0.000761582],["ixvm_group_71",0.001778213],["ixvm_group_72",0.000987458],["ixvm_group_73",0.002825144],["IxVM::expr_inst_levels",0.000921232],["ixvm_group_74",0.005021203],["ixvm_group_75",0.029881887],["ixvm_group_76",0.029568536],["ixvm_group_77",0.012529663],["IxVM::has_bvar_in_range",0.006434785],["ixvm_group_78",0.018936753],["ixvm_group_79",0.000484189],["ixvm_group_80",0.0299119],["IxVM::k_is_def_eq_ordered",0.001641919],["IxVM::try_def_eq_app",0.007543296],["ixvm_group_81",0.004477117],["ixvm_group_82",0.010816583],["ixvm_group_83",0.00372981],["ixvm_group_84",0.000320668],["ixvm_group_85",0.001022083],["ixvm_group_86",0.001705247],["ixvm_group_87",0.000535684],["ixvm_group_88",0.001392093],["ixvm_group_89",0.000943879],["ixvm_group_90",0.005809708],["IxVM::try_string_lit_one",0.001461447],["ixvm_group_91",0.01610734],["IxVM::whnf_nd_with_spine",0.002742359],["IxVM::expr_inst1_walk",0.030065639],["ixvm_group_92",0.000157615],["ixvm_group_93",8.6463e-05],["ixvm_group_94",3.8389e-05],["ixvm_group_95",0.001755264],["ixvm_group_96",0.005205362],["ixvm_group_97",0.002652586],["ixvm_group_98",0.016635452],["ixvm_group_99",0.004063506],["ixvm_group_100",0.002476067],["ixvm_group_101",0.001700366],["ixvm_group_102",0.003338941],["ixvm_group_103",0.001212427],["ixvm_group_104",0.005455261],["ixvm_group_105",6.8368e-05],["ixvm_group_106",0.000243946],["ixvm_group_107",8.0949e-05],["IxVM::k_is_def_eq_slow_nd",0.001456021],["IxVM::whnf_struct_core",0.002652235],["ixvm_group_108",0.002663108],["IxVM::try_eta_struct",0.000784796],["ixvm_group_109",0.00262962],["IxVM::is_nat_zero",0.000461951],["IxVM::k_is_def_eq_struct_bounded",0.010283293],["ixvm_group_110",0.001419111],["IxVM::expr_glb",0.008922624],["IxVM::expr_glb_binder",0.003010971],["IxVM::k_infer_rebase",0.016277985],["IxVM::canon_ord_cmp_g",2.04e-06],["IxVM::canon_addr_cmp",1.174e-06],["IxVM::canon_addr_chunk",2.064e-06],["ixvm_group_111",0.000286074],["IxVM::g_list_has",0.004746744],["",5.0276e-05],["",0.029917124],["",0.000130763],["",5.424e-06],["",0.029754808],["",0.003258649],["",3.0344e-05],["",9.797e-06],["",5.863e-06],["",5.839e-06],["",2.0723e-05],["",6.661e-06],["",0.000102991],["",0.002067707],["",1.771e-06],["",0.001853914],["",0.00050694],["",1.4616e-05],["",3.678e-06],["",4.42e-07],["",7.77e-07]],"elapsed_seconds":0.048158767,"event":"aiur_trace_profile","host_lookups":true,"phases":[["validate_and_root",0.002960328],["rom_index",0.006545034],["auxiliary_counts",0.001069443],["rom_partition",0.007046908],["populate_circuits",0.030517027],["check_shape",1.0774e-05],["cleanup",9.043e-06]]} +{"workload":"environment","sample":2,"circuits":[["IxVM::verify_claim",5.352e-06],["ixvm_group_00",0.031970684],["ixvm_group_01",0.004607318],["ixvm_group_02",0.031382951],["ixvm_group_03",0.028668824],["UInt32::less_than_fields",0.00462113],["ixvm_group_04",0.030043386],["Blake3::compress",0.031807318],["Blake3::compress_chunks",0.031659276],["ixvm_group_05",0.031642058],["ixvm_group_06",0.000374289],["ixvm_group_07",0.031491091],["ixvm_group_08",0.031293836],["${\"name\":\"Lists::is_empty\",\"types\":[\"field\"]}",0.001197467],["ixvm_group_09",0.000331895],["ixvm_group_10",0.031641326],["ixvm_group_11",0.022777971],["ixvm_group_12",2.668e-06],["ixvm_group_13",1.237e-06],["ixvm_group_14",0.025824547],["ixvm_group_15",0.00333283],["IxVM::get_address",0.004661301],["ixvm_group_16",0.001229353],["ixvm_group_17",0.00422846],["ixvm_group_18",0.030099954],["ixvm_group_19",0.009622829],["ixvm_group_20",0.003358462],["ixvm_group_21",0.001631786],["ixvm_group_22",0.031681322],["ixvm_group_23",0.001113112],["ixvm_group_24",0.031847347],["UInt64::saturating_pred",0.00016909],["ixvm_group_25",0.030941323],["ixvm_group_26",0.027308146],["ixvm_group_27",0.019790803],["ixvm_group_28",0.00407059],["ixvm_group_29",0.001426173],["ixvm_group_30",0.005451761],["ixvm_group_31",0.02494602],["ixvm_group_32",0.023478201],["ixvm_group_33",0.004284637],["ixvm_group_34",0.001091908],["ixvm_group_35",0.001263369],["ixvm_group_36",0.001433967],["ixvm_group_37",0.002163845],["ixvm_group_38",0.031749811],["ixvm_group_39",0.005893956],["ixvm_group_40",0.002832789],["ixvm_group_41",0.00037982],["ixvm_group_42",0.031386954],["ixvm_group_43",0.031811503],["ixvm_group_44",0.000712888],["${\"name\":\"IxVM::list_lookup\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}",0.003658643],["${\"name\":\"IxVM::list_drop\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::Univ\"}}}}]}",0.006055737],["ixvm_group_45",0.000126685],["ixvm_group_46",0.031675044],["ixvm_group_47",2.803e-06],["ixvm_group_48",0.031200374],["ixvm_group_49",0.000227128],["ixvm_group_50",0.000664438],["ixvm_group_51",0.031728598],["ixvm_group_52",0.031651512],["ixvm_group_53",3.131e-06],["ixvm_group_54",0.003209676],["ixvm_group_55",2.153e-06],["ixvm_group_56",0.00154093],["ixvm_group_57",0.000282888],["ixvm_group_58",0.0025037],["ixvm_group_59",0.000788772],["ixvm_group_60",0.00253326],["ixvm_group_61",0.001496367],["${\"name\":\"IxVM::list_length\",\"types\":[{\"ptr\":{\"target\":{\"named\":{\"args\":[],\"name\":\"IxVM::KLevelNode\"}}}}]}",0.030440982],["ixvm_group_62",0.002801515],["ixvm_group_63",0.030901413],["ixvm_group_64",0.027879593],["ixvm_group_65",0.000412135],["ixvm_group_66",0.031612339],["ixvm_group_67",0.031653563],["ixvm_group_68",0.031809528],["ixvm_group_69",0.000256868],["ixvm_group_70",0.000823926],["ixvm_group_71",0.031900828],["ixvm_group_72",0.031814321],["ixvm_group_73",0.031874743],["IxVM::expr_inst_levels",0.000988717],["ixvm_group_74",0.030819297],["ixvm_group_75",0.031967139],["ixvm_group_76",0.031725769],["ixvm_group_77",0.012683417],["IxVM::has_bvar_in_range",0.031709625],["ixvm_group_78",0.03140877],["ixvm_group_79",0.000418836],["ixvm_group_80",0.031450823],["IxVM::k_is_def_eq_ordered",0.001075366],["IxVM::try_def_eq_app",0.02622331],["ixvm_group_81",0.024274611],["ixvm_group_82",0.028887618],["ixvm_group_83",0.003412724],["ixvm_group_84",0.000225214],["ixvm_group_85",0.001080577],["ixvm_group_86",0.00077691],["ixvm_group_87",0.001017085],["ixvm_group_88",0.001174374],["ixvm_group_89",0.000749026],["ixvm_group_90",0.028873114],["IxVM::try_string_lit_one",0.028323319],["ixvm_group_91",0.007284967],["IxVM::whnf_nd_with_spine",0.002287547],["IxVM::expr_inst1_walk",0.003492888],["ixvm_group_92",0.000102174],["ixvm_group_93",5.7204e-05],["ixvm_group_94",5.7921e-05],["ixvm_group_95",0.001852481],["ixvm_group_96",0.001886799],["ixvm_group_97",0.002165557],["ixvm_group_98",0.026945724],["ixvm_group_99",0.004107984],["ixvm_group_100",0.008504722],["ixvm_group_101",0.00177836],["ixvm_group_102",0.023451297],["ixvm_group_103",0.001162781],["ixvm_group_104",0.005579741],["ixvm_group_105",6.5969e-05],["ixvm_group_106",0.000213776],["ixvm_group_107",7.2511e-05],["IxVM::k_is_def_eq_slow_nd",0.001432752],["IxVM::whnf_struct_core",0.002097458],["ixvm_group_108",0.002460062],["IxVM::try_eta_struct",0.000702888],["ixvm_group_109",0.002547397],["IxVM::is_nat_zero",0.000413029],["IxVM::k_is_def_eq_struct_bounded",0.011373959],["ixvm_group_110",0.002188342],["IxVM::expr_glb",0.011001906],["IxVM::expr_glb_binder",0.003001023],["IxVM::k_infer_rebase",0.005229773],["IxVM::canon_ord_cmp_g",2.648e-06],["IxVM::canon_addr_cmp",1.795e-06],["IxVM::canon_addr_chunk",6.69e-07],["ixvm_group_111",0.000121492],["IxVM::g_list_has",0.004995556],["",4.5428e-05],["",0.031728865],["",3.8366e-05],["",2.225e-06],["",0.022797279],["",0.002623567],["",1.4405e-05],["",4.438e-06],["",2.327e-06],["",4.819e-06],["",1.3677e-05],["",5.498e-06],["",6.7453e-05],["",0.001950006],["",1.218e-06],["",0.001568991],["",0.000701292],["",1.3508e-05],["",6.677e-06],["",1.798e-06],["",1.46e-06]],"elapsed_seconds":0.048937053,"event":"aiur_trace_profile","host_lookups":true,"phases":[["validate_and_root",0.002795816],["rom_index",0.006078668],["auxiliary_counts",0.001228802],["rom_partition",0.005474557],["populate_circuits",0.033344161],["check_shape",8.958e-06],["cleanup",5.763e-06]]} +{"workload":"recursion-real","sample":0,"circuits":[["MultiStark::verify_multi_stark_proof",6.4451e-05],["verifier_group_00",0.765512332],["verifier_group_01",0.743185801],["verifier_group_02",0.74292027],["Blake3::compress",0.79747004],["Blake3::compress_chunks",0.759986619],["verifier_group_03",0.743070318],["verifier_group_04",0.743055618],["Blake3::pad_block",0.76304977],["verifier_group_05",0.743103747],["verifier_group_06",0.743141075],["verifier_group_07",0.743076598],["verifier_group_08",0.048368547],["MultiStark::read_vk_u8",0.108088379],["verifier_group_09",0.743049297],["verifier_group_10",0.742932753],["MultiStark::read_vk_tag",0.032584434],["MultiStark::read_nodes_n",0.743246145],["verifier_group_11",0.762905807],["MultiStark::read_node_ids_n",0.054955325],["verifier_group_12",0.00115798],["verifier_group_13",0.743103275],["verifier_group_14",0.743054168],["verifier_group_15",0.743080117],["verifier_group_16",0.742901677],["verifier_group_17",0.760412928],["verifier_group_18",0.742982658],["verifier_group_19",0.751687186],["MultiStark::read_u64_vec_vec_n",0.042828415],["verifier_group_20",0.772274005],["verifier_group_21",0.157076706],["verifier_group_22",0.039494833],["verifier_group_23",0.743074382],["verifier_group_24",0.742921691],["verifier_group_25",0.058482554],["verifier_group_26",0.74309521],["verifier_group_27",0.743144943],["MultiStark::b8_onto",0.743099161],["verifier_group_28",0.769867101],["verifier_group_29",0.018383011],["verifier_group_30",0.743114993],["verifier_group_31",0.000387893],["${\"name\":\"MultiStark::list_concat\",\"types\":[\"field\"]}",0.760301835],["verifier_group_32",0.029329267],["verifier_group_33",0.018347614],["verifier_group_34",0.742804969],["MultiStark::two_adic_gen",4.595e-05],["verifier_group_35",0.743015304],["verifier_group_36",0.743041362],["verifier_group_37",0.019203069],["MultiStark::ch_sample_bits",0.000211755],["MultiStark::take_bits",0.743125394],["MultiStark::rows_pop",0.767118392],["verifier_group_38",0.755806721],["",0.000123101],["",0.742906448],["",6.4868e-05],["",0.748886816],["",0.005799692],["",1.4402e-05],["",0.048735825],["",0.164263704],["",0.000259228],["",0.463387669],["",0.742707881],["",1.604e-05],["",0.087793604],["",0.00852092]],"elapsed_seconds":1.212773213,"event":"aiur_trace_profile","host_lookups":true,"phases":[["validate_and_root",0.023087607],["rom_index",0.230787776],["auxiliary_counts",0.024516162],["rom_partition",0.124718225],["populate_circuits",0.798083393],["check_shape",6.048e-06],["cleanup",0.011573816]]} +{"workload":"recursion-real","sample":1,"circuits":[["MultiStark::verify_multi_stark_proof",6.3808e-05],["verifier_group_00",0.757053563],["verifier_group_01",0.169673594],["verifier_group_02",0.743931519],["Blake3::compress",0.776657663],["Blake3::compress_chunks",0.75434699],["verifier_group_03",0.743952387],["verifier_group_04",0.743730506],["Blake3::pad_block",0.743526569],["verifier_group_05",0.743450047],["verifier_group_06",0.743615135],["verifier_group_07",0.742272104],["verifier_group_08",0.035624747],["MultiStark::read_vk_u8",0.761202283],["verifier_group_09",0.143456184],["verifier_group_10",0.743697834],["MultiStark::read_vk_tag",0.034308617],["MultiStark::read_nodes_n",0.744220028],["verifier_group_11",0.766487754],["MultiStark::read_node_ids_n",0.743557459],["verifier_group_12",0.743414034],["verifier_group_13",0.743920404],["verifier_group_14",0.74389931],["verifier_group_15",0.000698938],["verifier_group_16",0.74372415],["verifier_group_17",0.743906794],["verifier_group_18",0.038840804],["verifier_group_19",0.764060612],["MultiStark::read_u64_vec_vec_n",0.743724379],["verifier_group_20",0.773118632],["verifier_group_21",0.743728485],["verifier_group_22",0.084659242],["verifier_group_23",0.743763106],["verifier_group_24",0.743754279],["verifier_group_25",0.017453372],["verifier_group_26",0.743949213],["verifier_group_27",0.743937511],["MultiStark::b8_onto",0.7436865],["verifier_group_28",0.758950939],["verifier_group_29",0.743887828],["verifier_group_30",0.039256218],["verifier_group_31",0.005053369],["${\"name\":\"MultiStark::list_concat\",\"types\":[\"field\"]}",0.743896361],["verifier_group_32",0.055867577],["verifier_group_33",0.018108615],["verifier_group_34",0.743658893],["MultiStark::two_adic_gen",5.1352e-05],["verifier_group_35",0.743693937],["verifier_group_36",0.064441784],["verifier_group_37",0.037439937],["MultiStark::ch_sample_bits",0.000174252],["MultiStark::take_bits",0.74389745],["MultiStark::rows_pop",0.74381428],["verifier_group_38",0.770880464],["",5.7969e-05],["",0.014644276],["",4.0209e-05],["",0.749575742],["",0.004897506],["",1.7248e-05],["",0.773753892],["",0.15202819],["",0.000665069],["",0.21913195],["",0.000155716],["",7.625e-06],["",0.743454778],["",0.009439278]],"elapsed_seconds":1.197592147,"event":"aiur_trace_profile","host_lookups":true,"phases":[["validate_and_root",0.023120912],["rom_index",0.234007817],["auxiliary_counts",0.02381734],["rom_partition",0.1278865],["populate_circuits",0.777291425],["check_shape",7.17e-06],["cleanup",0.011460786]]} +{"workload":"recursion-real","sample":2,"circuits":[["MultiStark::verify_multi_stark_proof",6.1188e-05],["verifier_group_00",0.770991265],["verifier_group_01",0.733273497],["verifier_group_02",0.733098229],["Blake3::compress",0.768608205],["Blake3::compress_chunks",0.760073199],["verifier_group_03",0.733110077],["verifier_group_04",0.732922953],["Blake3::pad_block",0.760504051],["verifier_group_05",0.733092942],["verifier_group_06",0.733077158],["verifier_group_07",0.732877128],["verifier_group_08",0.73325749],["MultiStark::read_vk_u8",0.762765985],["verifier_group_09",0.733055733],["verifier_group_10",0.732992912],["MultiStark::read_vk_tag",0.034072562],["MultiStark::read_nodes_n",0.733308301],["verifier_group_11",0.772717359],["MultiStark::read_node_ids_n",0.733201019],["verifier_group_12",0.733236499],["verifier_group_13",0.004247583],["verifier_group_14",0.008970783],["verifier_group_15",0.002525089],["verifier_group_16",0.085938904],["verifier_group_17",0.733119407],["verifier_group_18",0.733101232],["verifier_group_19",0.765723567],["MultiStark::read_u64_vec_vec_n",0.733061123],["verifier_group_20",0.742749366],["verifier_group_21",0.732909984],["verifier_group_22",0.061134505],["verifier_group_23",0.732941598],["verifier_group_24",0.73293424],["verifier_group_25",0.051471749],["verifier_group_26",0.096056983],["verifier_group_27",0.036617763],["MultiStark::b8_onto",0.732937068],["verifier_group_28",0.740000375],["verifier_group_29",0.732474545],["verifier_group_30",0.00273266],["verifier_group_31",0.000312481],["${\"name\":\"MultiStark::list_concat\",\"types\":[\"field\"]}",0.733059249],["verifier_group_32",0.733070595],["verifier_group_33",0.108140304],["verifier_group_34",0.733011373],["MultiStark::two_adic_gen",8.5593e-05],["verifier_group_35",0.733053403],["verifier_group_36",0.7330843],["verifier_group_37",0.036820734],["MultiStark::ch_sample_bits",0.732991187],["MultiStark::take_bits",0.755701856],["MultiStark::rows_pop",0.737865471],["verifier_group_38",0.752964395],["",6.086e-05],["",0.04227875],["",0.000422572],["",0.748377196],["",0.005290907],["",1.5313e-05],["",0.055823918],["",0.755180848],["",0.732717246],["",0.735386692],["",0.000170529],["",7.837e-06],["",0.099544641],["",0.008633762]],"elapsed_seconds":1.190875994,"event":"aiur_trace_profile","host_lookups":true,"phases":[["validate_and_root",0.023119241],["rom_index",0.232557565],["auxiliary_counts",0.024400828],["rom_partition",0.125742256],["populate_circuits",0.773331998],["check_shape",5.41e-06],["cleanup",0.011718546]]} diff --git a/docs/benchmarks/formal-aiur-trace-scaling/manifest.json b/docs/benchmarks/formal-aiur-trace-scaling/manifest.json new file mode 100644 index 000000000..efe743eaa --- /dev/null +++ b/docs/benchmarks/formal-aiur-trace-scaling/manifest.json @@ -0,0 +1,465 @@ +{ + "base_revision": "5de73a2353f593ec0d9c4b2bf657f6a39da84081", + "cpus": [ + 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, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "threads": [ + 8, + 64, + 1, + 32 + ], + "samples": 3, + "warmups": 2, + "lscpu": { + "lscpu": [ + { + "field": "Architecture:", + "data": "x86_64" + }, + { + "field": "CPU op-mode(s):", + "data": "32-bit, 64-bit" + }, + { + "field": "Address sizes:", + "data": "48 bits physical, 48 bits virtual" + }, + { + "field": "Byte Order:", + "data": "Little Endian" + }, + { + "field": "CPU(s):", + "data": "64" + }, + { + "field": "On-line CPU(s) list:", + "data": "0-63" + }, + { + "field": "Vendor ID:", + "data": "GenuineIntel" + }, + { + "field": "Model name:", + "data": "Intel(R) Xeon(R) 6975P-C" + }, + { + "field": "CPU family:", + "data": "6" + }, + { + "field": "Model:", + "data": "173" + }, + { + "field": "Thread(s) per core:", + "data": "2" + }, + { + "field": "Core(s) per socket:", + "data": "32" + }, + { + "field": "Socket(s):", + "data": "1" + }, + { + "field": "Stepping:", + "data": "1" + }, + { + "field": "BogoMIPS:", + "data": "5400.00" + }, + { + "field": "Flags:", + "data": "fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ss ht syscall nx pdpe1gb rdtscp lm constant_tsc arch_perfmon rep_good nopl xtopology nonstop_tsc cpuid aperfmperf tsc_known_freq pni pclmulqdq monitor ssse3 fma cx16 pdcm pcid sse4_1 sse4_2 x2apic movbe popcnt tsc_deadline_timer aes xsave avx f16c rdrand hypervisor lahf_lm abm 3dnowprefetch cpuid_fault ssbd ibrs ibpb stibp ibrs_enhanced fsgsbase tsc_adjust bmi1 avx2 smep bmi2 erms invpcid avx512f avx512dq rdseed adx smap avx512ifma clflushopt clwb avx512cd sha_ni avx512bw avx512vl xsaveopt xsavec xgetbv1 xsaves avx_vnni avx512_bf16 wbnoinvd ida arat avx512vbmi umip pku ospke waitpkg avx512_vbmi2 gfni vaes vpclmulqdq avx512_vnni avx512_bitalg tme avx512_vpopcntdq rdpid bus_lock_detect cldemote movdiri movdir64b md_clear serialize amx_bf16 avx512_fp16 amx_tile amx_int8 flush_l1d arch_capabilities" + }, + { + "field": "Hypervisor vendor:", + "data": "KVM" + }, + { + "field": "Virtualization type:", + "data": "full" + }, + { + "field": "L1d cache:", + "data": "1.5 MiB (32 instances)" + }, + { + "field": "L1i cache:", + "data": "2 MiB (32 instances)" + }, + { + "field": "L2 cache:", + "data": "64 MiB (32 instances)" + }, + { + "field": "L3 cache:", + "data": "480 MiB (1 instance)" + }, + { + "field": "NUMA node(s):", + "data": "1" + }, + { + "field": "NUMA node0 CPU(s):", + "data": "0-63" + }, + { + "field": "Vulnerability Gather data sampling:", + "data": "Not affected" + }, + { + "field": "Vulnerability Ghostwrite:", + "data": "Not affected" + }, + { + "field": "Vulnerability Indirect target selection:", + "data": "Not affected" + }, + { + "field": "Vulnerability Itlb multihit:", + "data": "Not affected" + }, + { + "field": "Vulnerability L1tf:", + "data": "Not affected" + }, + { + "field": "Vulnerability Mds:", + "data": "Not affected" + }, + { + "field": "Vulnerability Meltdown:", + "data": "Not affected" + }, + { + "field": "Vulnerability Mmio stale data:", + "data": "Not affected" + }, + { + "field": "Vulnerability Old microcode:", + "data": "Not affected" + }, + { + "field": "Vulnerability Reg file data sampling:", + "data": "Not affected" + }, + { + "field": "Vulnerability Retbleed:", + "data": "Not affected" + }, + { + "field": "Vulnerability Spec rstack overflow:", + "data": "Not affected" + }, + { + "field": "Vulnerability Spec store bypass:", + "data": "Mitigation; Speculative Store Bypass disabled via prctl" + }, + { + "field": "Vulnerability Spectre v1:", + "data": "Mitigation; usercopy/swapgs barriers and __user pointer sanitization" + }, + { + "field": "Vulnerability Spectre v2:", + "data": "Mitigation; Enhanced / Automatic IBRS; IBPB conditional; PBRSB-eIBRS Not affected; BHI BHI_DIS_S" + }, + { + "field": "Vulnerability Srbds:", + "data": "Not affected" + }, + { + "field": "Vulnerability Tsa:", + "data": "Not affected" + }, + { + "field": "Vulnerability Tsx async abort:", + "data": "Not affected" + }, + { + "field": "Vulnerability Vmscape:", + "data": "Not affected" + } + ] + }, + "reused_execution": true, + "host_lookups": true, + "thp_disabled": true, + "artifact_input_sha256": { + ".lake/formal-integration/ixvm-tuned.json": "1f8c10da7b10587e985d5166b26ad0c7edd4f4cbdfe0978c7deb237cf6683d9a", + ".lake/formal-comparison/final/environment-input.json": "14a147c1d6141721547092a9a835249969aa1f82c8f57f9ed0a2b0522f7aaa56", + ".lake/formal-integration/recursion-tuned.json": "40e88dd1f84e4f119626189e83f8eb181f6ef9875c190f33cdd7853e83c5afe1", + ".lake/formal-comparison/final/new-environment-grouped.json.inner/input.json": "2ecf2051d112503637b9d3c1a6201bd66f91df4568a95faff3cef068e3f96a1a", + ".lake/formal-integration/ixvm-checked.json": "114311f43f6fb39a2d5ccc5c4e6fb279d4eb6c08655cd08731c949e7e537fabf", + ".lake/formal-integration/recursion-checked.json": "ae96efa2ce33a07bd79fc5100395aa09a7f3d5f436ae04ee7be2f6bcd71e2afa" + }, + "binary_sha256": { + "legacy": "becd57658a2d232dc158fada7fc977bdff27ae8834e6a80f5db82f18dea05024", + "new": "19c3e08f05bbe44f1ec217829c0f62d3c11c032dc89760fe394dfa7ece71bb5d" + }, + "commands": [ + [ + "taskset", + "-c", + "0,1,2,3,4,5,6,7", + ".lake/build/bin/bench-compare-aiur", + "ixvm", + ".lake/formal-comparison/final/environment-input.json", + ".lake/trace-scaling/sweep/environment-legacy-8.json", + "3" + ], + [ + "taskset", + "-c", + "0,1,2,3,4,5,6,7", + "target/release/examples/compare", + ".lake/formal-integration/ixvm-tuned.json", + ".lake/formal-comparison/final/environment-input.json", + ".lake/trace-scaling/sweep/environment-new-8.json", + "3" + ], + [ + "taskset", + "-c", + "0,1,2,3,4,5,6,7", + "target/release/examples/compare", + ".lake/formal-integration/recursion-tuned.json", + ".lake/formal-comparison/final/new-environment-grouped.json.inner/input.json", + ".lake/trace-scaling/sweep/recursion-real-new-8.json", + "3" + ], + [ + "taskset", + "-c", + "0,1,2,3,4,5,6,7", + ".lake/build/bin/bench-compare-aiur", + "recursion", + ".lake/formal-comparison/final/new-environment-grouped.json.inner/input.json", + ".lake/trace-scaling/sweep/recursion-real-legacy-8.json", + "3" + ], + [ + "taskset", + "-c", + "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,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63", + "target/release/examples/compare", + ".lake/formal-integration/ixvm-tuned.json", + ".lake/formal-comparison/final/environment-input.json", + ".lake/trace-scaling/sweep/environment-new-64.json", + "3" + ], + [ + "taskset", + "-c", + "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,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63", + ".lake/build/bin/bench-compare-aiur", + "ixvm", + ".lake/formal-comparison/final/environment-input.json", + ".lake/trace-scaling/sweep/environment-legacy-64.json", + "3" + ], + [ + "taskset", + "-c", + "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,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63", + ".lake/build/bin/bench-compare-aiur", + "recursion", + ".lake/formal-comparison/final/new-environment-grouped.json.inner/input.json", + ".lake/trace-scaling/sweep/recursion-real-legacy-64.json", + "3" + ], + [ + "taskset", + "-c", + "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,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63", + "target/release/examples/compare", + ".lake/formal-integration/recursion-tuned.json", + ".lake/formal-comparison/final/new-environment-grouped.json.inner/input.json", + ".lake/trace-scaling/sweep/recursion-real-new-64.json", + "3" + ], + [ + "taskset", + "-c", + "0", + ".lake/build/bin/bench-compare-aiur", + "ixvm", + ".lake/formal-comparison/final/environment-input.json", + ".lake/trace-scaling/sweep/environment-legacy-1.json", + "3" + ], + [ + "taskset", + "-c", + "0", + "target/release/examples/compare", + ".lake/formal-integration/ixvm-tuned.json", + ".lake/formal-comparison/final/environment-input.json", + ".lake/trace-scaling/sweep/environment-new-1.json", + "3" + ], + [ + "taskset", + "-c", + "0", + "target/release/examples/compare", + ".lake/formal-integration/recursion-tuned.json", + ".lake/formal-comparison/final/new-environment-grouped.json.inner/input.json", + ".lake/trace-scaling/sweep/recursion-real-new-1.json", + "3" + ], + [ + "taskset", + "-c", + "0", + ".lake/build/bin/bench-compare-aiur", + "recursion", + ".lake/formal-comparison/final/new-environment-grouped.json.inner/input.json", + ".lake/trace-scaling/sweep/recursion-real-legacy-1.json", + "3" + ], + [ + "taskset", + "-c", + "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", + "target/release/examples/compare", + ".lake/formal-integration/ixvm-tuned.json", + ".lake/formal-comparison/final/environment-input.json", + ".lake/trace-scaling/sweep/environment-new-32.json", + "3" + ], + [ + "taskset", + "-c", + "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", + ".lake/build/bin/bench-compare-aiur", + "ixvm", + ".lake/formal-comparison/final/environment-input.json", + ".lake/trace-scaling/sweep/environment-legacy-32.json", + "3" + ], + [ + "taskset", + "-c", + "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", + ".lake/build/bin/bench-compare-aiur", + "recursion", + ".lake/formal-comparison/final/new-environment-grouped.json.inner/input.json", + ".lake/trace-scaling/sweep/recursion-real-legacy-32.json", + "3" + ], + [ + "taskset", + "-c", + "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", + "target/release/examples/compare", + ".lake/formal-integration/recursion-tuned.json", + ".lake/formal-comparison/final/new-environment-grouped.json.inner/input.json", + ".lake/trace-scaling/sweep/recursion-real-new-32.json", + "3" + ], + [ + "taskset", + "-c", + "0-63", + "target/release/examples/compare", + ".lake/formal-integration/ixvm-checked.json", + ".lake/formal-comparison/final/environment-input.json", + ".lake/trace-scaling/sweep/environment-new-before-64.json", + "3" + ], + [ + "taskset", + "-c", + "0-63", + "target/release/examples/compare", + ".lake/formal-integration/recursion-checked.json", + ".lake/formal-comparison/final/new-environment-grouped.json.inner/input.json", + ".lake/trace-scaling/sweep/recursion-real-new-before-64.json", + "3" + ] + ], + "date": "2026-10-28", + "cpu_quota": "No quota: cpu.max is max 100000 at the session and both parent cgroups", + "timing_scope": "Trace planning, main rows and host lookup buffers; excludes execution, compilation, key/setup and destruction. Reuses one immutable execution record per process; still regenerates every trace.", + "validation": [ + "Both record-reuse smoke proofs verify with the same circuit shapes as normal execution", + "Circuit heights, widths and cell counts invariant under thread count for each backend/workload", + "Nullable execution sample summaries supported", + "Clippy passes with warnings denied for the new comparison example and legacy FFI library" + ], + "source_sha256": { + "crates/ffi/src/aiur/benchmark.rs": "1a9008c899ef6dea39d298e2728c709298d3265532b9a1fa6d42dfbb43256fb5", + "crates/stark-verifier/examples/compare.rs": "2b3522f834df44149a50088631656859a02659198d12aa4a3771b4113f60f4c0", + "tools/ixvm/compare-results.py": "b640f1a1ff0ad339c60ac39ffca1fd04635f283da0c31c5e4f39605a48de0645", + "tools/ixvm/trace-scaling.py": "cbf37fd568710e30893e925f89b21914824daa8a5a603ab002f4a964ad63a7ff" + } +} diff --git a/docs/benchmarks/formal-aiur-trace-scaling/runs.json b/docs/benchmarks/formal-aiur-trace-scaling/runs.json new file mode 100644 index 000000000..0527c7602 --- /dev/null +++ b/docs/benchmarks/formal-aiur-trace-scaling/runs.json @@ -0,0 +1,408 @@ +{ + "environment-legacy-1": { + "thp_disabled": true, + "setup_seconds": 0.120733863, + "samples": [ + { + "trace_with_lookups_seconds": 0.582838236, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.571593427, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.569890616, + "execute_seconds": null + } + ], + "reused_execution": true, + "proof": null, + "initial_execute_seconds": 0.405850536, + "backend": "legacy-bytecode" + }, + "environment-legacy-32": { + "thp_disabled": true, + "setup_seconds": 0.074795339, + "samples": [ + { + "trace_with_lookups_seconds": 0.033888117, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.049700014, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.046856506, + "execute_seconds": null + } + ], + "reused_execution": true, + "proof": null, + "initial_execute_seconds": 0.398324751, + "backend": "legacy-bytecode" + }, + "environment-legacy-64": { + "thp_disabled": true, + "setup_seconds": 0.079211653, + "samples": [ + { + "trace_with_lookups_seconds": 0.042936, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.043212989, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.032519304, + "execute_seconds": null + } + ], + "reused_execution": true, + "proof": null, + "initial_execute_seconds": 0.390498727, + "backend": "legacy-bytecode" + }, + "environment-legacy-8": { + "thp_disabled": true, + "setup_seconds": 0.076052333, + "samples": [ + { + "trace_with_lookups_seconds": 0.088110815, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.080892936, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.082462732, + "execute_seconds": null + } + ], + "reused_execution": true, + "proof": null, + "initial_execute_seconds": 0.394261938, + "backend": "legacy-bytecode" + }, + "environment-new-1": { + "backend": "new-bytecode", + "initial_execute_seconds": 0.370538784, + "prepare_seconds": 0.13155845, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.063618645 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.072017509 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.055532957 + } + ], + "setup_seconds": 0.352510606, + "thp_disabled": true + }, + "environment-new-32": { + "backend": "new-bytecode", + "initial_execute_seconds": 0.355862662, + "prepare_seconds": 0.130659156, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.056708404 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.0576552 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.056873301 + } + ], + "setup_seconds": 0.306089715, + "thp_disabled": true + }, + "environment-new-64": { + "backend": "new-bytecode", + "initial_execute_seconds": 0.357784535, + "prepare_seconds": 0.13057008, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.05169888 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.050509376 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.049915811 + } + ], + "setup_seconds": 0.309064763, + "thp_disabled": true + }, + "environment-new-8": { + "backend": "new-bytecode", + "initial_execute_seconds": 0.357474266, + "prepare_seconds": 0.13163609, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.155205977 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.160331151 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.159225807 + } + ], + "setup_seconds": 0.303398964, + "thp_disabled": true + }, + "environment-new-before-64": { + "backend": "new-bytecode", + "initial_execute_seconds": 0.356046912, + "prepare_seconds": 0.131259405, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.047994868 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.046127802 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 0.043244861 + } + ], + "setup_seconds": 0.294366541, + "thp_disabled": true + }, + "recursion-real-legacy-1": { + "thp_disabled": true, + "setup_seconds": 0.064885263, + "samples": [ + { + "trace_with_lookups_seconds": 16.707207555, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 16.715780898, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 16.734178335, + "execute_seconds": null + } + ], + "reused_execution": true, + "proof": null, + "initial_execute_seconds": 8.790523498, + "backend": "legacy-bytecode" + }, + "recursion-real-legacy-32": { + "thp_disabled": true, + "setup_seconds": 0.021273283, + "samples": [ + { + "trace_with_lookups_seconds": 0.682353933, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.690084917, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.715665752, + "execute_seconds": null + } + ], + "reused_execution": true, + "proof": null, + "initial_execute_seconds": 8.402849458, + "backend": "legacy-bytecode" + }, + "recursion-real-legacy-64": { + "thp_disabled": true, + "setup_seconds": 0.026094613, + "samples": [ + { + "trace_with_lookups_seconds": 0.516785923, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.677273568, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 0.630917061, + "execute_seconds": null + } + ], + "reused_execution": true, + "proof": null, + "initial_execute_seconds": 8.405435643, + "backend": "legacy-bytecode" + }, + "recursion-real-legacy-8": { + "thp_disabled": true, + "setup_seconds": 0.021338137, + "samples": [ + { + "trace_with_lookups_seconds": 2.163425498, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 2.172847219, + "execute_seconds": null + }, + { + "trace_with_lookups_seconds": 2.367510997, + "execute_seconds": null + } + ], + "reused_execution": true, + "proof": null, + "initial_execute_seconds": 8.343030986, + "backend": "legacy-bytecode" + }, + "recursion-real-new-1": { + "backend": "new-bytecode", + "initial_execute_seconds": 8.852611883, + "prepare_seconds": 0.099156177, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 25.748082991 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 25.713752221 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 25.641574315 + } + ], + "setup_seconds": 0.085861834, + "thp_disabled": true + }, + "recursion-real-new-32": { + "backend": "new-bytecode", + "initial_execute_seconds": 8.646103034, + "prepare_seconds": 0.101926796, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.43048941 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.4077947100000001 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.432541313 + } + ], + "setup_seconds": 0.033437387, + "thp_disabled": true + }, + "recursion-real-new-64": { + "backend": "new-bytecode", + "initial_execute_seconds": 8.629453467, + "prepare_seconds": 0.099707911, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.220389507 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.218058449 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.2621842 + } + ], + "setup_seconds": 0.037955817, + "thp_disabled": true + }, + "recursion-real-new-8": { + "backend": "new-bytecode", + "initial_execute_seconds": 8.738889755, + "prepare_seconds": 0.099330017, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 3.815473118 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 3.660410378 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 3.67757257 + } + ], + "setup_seconds": 0.034580375, + "thp_disabled": true + }, + "recursion-real-new-before-64": { + "backend": "new-bytecode", + "initial_execute_seconds": 8.713034853, + "prepare_seconds": 0.099013694, + "proof": null, + "reused_execution": true, + "samples": [ + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.176184352 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.221290663 + }, + { + "execute_seconds": null, + "trace_with_lookups_seconds": 1.156918591 + } + ], + "setup_seconds": 0.038954955, + "thp_disabled": true + } +} diff --git a/docs/benchmarks/formal-aiur-trace-scaling/summary.csv b/docs/benchmarks/formal-aiur-trace-scaling/summary.csv new file mode 100644 index 000000000..800cbb80a --- /dev/null +++ b/docs/benchmarks/formal-aiur-trace-scaling/summary.csv @@ -0,0 +1,19 @@ +workload,backend,threads,median_seconds,min_seconds,max_seconds,cells +environment,legacy,1,0.571593427,0.569890616,0.582838236,45169839 +environment,new,1,1.063618645,1.055532957,1.072017509,43146214 +environment,legacy,8,0.082462732,0.080892936,0.088110815,45169839 +environment,new,8,0.159225807,0.155205977,0.160331151,43146214 +environment,legacy,32,0.046856506,0.033888117,0.049700014,45169839 +environment,new,32,0.056873301,0.056708404,0.0576552,43146214 +environment,legacy,64,0.042936,0.032519304,0.043212989,45169839 +environment,new,64,0.050509376,0.049915811,0.05169888,43146214 +environment,new-before,64,0.046127802,0.043244861,0.047994868,46656479 +recursion-real,legacy,1,16.715780898,16.707207555,16.734178335,985571600 +recursion-real,new,1,25.713752221,25.641574315,25.748082991,937960213 +recursion-real,legacy,8,2.172847219,2.163425498,2.367510997,985571600 +recursion-real,new,8,3.67757257,3.660410378,3.815473118,937960213 +recursion-real,legacy,32,0.690084917,0.682353933,0.715665752,985571600 +recursion-real,new,32,1.43048941,1.4077947100000001,1.432541313,937960213 +recursion-real,legacy,64,0.630917061,0.516785923,0.677273568,985571600 +recursion-real,new,64,1.220389507,1.218058449,1.2621842,937960213 +recursion-real,new-before,64,1.176184352,1.156918591,1.221290663,1005868035 diff --git a/docs/ci.md b/docs/ci.md index 3a7a3bdfa..49007306e 100644 --- a/docs/ci.md +++ b/docs/ci.md @@ -6,6 +6,14 @@ which does not run on a GPU. Future GPU benchmarks should explicitly request `spot=false`. RunsOn may fall back to on-demand capacity when Spot is unavailable or when provisioning an automatic recovery attempt. +Formal Aiur's CPU integration job exercises the CPU controls of +`tools/ixvm/check-cuda.py`. Actual CPU/CUDA proof and key parity, including +sharded IxVM, recursion, and aggregation, requires a GPU host running +`IX_TEST_CUDA=1 bash tools/ixvm/check-formal.sh`. The +[migration guide](formal-aiur-migration.md#legacy-support-and-native-builds) +documents the retained logs and report; the CUDA compilation job does not +provide hardware validation. + CI jobs request the `r7i+r8i+r7a+r8a` families and let RunsOn pick the size from `cpu=`, so a Spot request can draw from several pools; exact r8i types alone had no Spot capacity. Their Rust builds use the `portable` codegen mode diff --git a/docs/formal-aiur-gpu-preparation.md b/docs/formal-aiur-gpu-preparation.md new file mode 100644 index 000000000..b0f7d0adf --- /dev/null +++ b/docs/formal-aiur-gpu-preparation.md @@ -0,0 +1,151 @@ +# Removing redundant batch preparation from formal Aiur + +Measured 2026-10-30 against `e2326c95`. This fixes work in the batch adapter +shared by the CPU and CUDA provers. It does not change Aiur programs, certified +circuits, grouping, cryptographic parameters, or proof formats. + +## What the GPU report exposed + +The hardware review reported the following three-run medians on an RTX PRO +6000 Blackwell with 96 GB VRAM and 16 CPU threads. Times include trace +generation, proving and verification, excluding execution and setup: + +| Workload | Legacy CUDA | Formal CUDA | Legacy GPU lookups | Formal GPU lookups | +|---|---:|---:|---:|---:| +| `Nat.add_comm` frontier | 0.196 s | 0.200 s | 0.202 s | 0.186 s | +| 342-constant environment | 0.401 s | 1.286 s | 0.468 s | 0.680 s | +| Large recursive verifier | 3.414 s | 20.288 s | 3.948 s | 8.330 s | + +These are the user's hardware measurements, not locally reproduced GPU +results. The review directory was not available in this checkout, and this +machine has no NVIDIA device. `AIUR_TRACE_ONLY_LOOKUPS=1` removes the host +lookup buffers in the last two columns. + +There were three concrete inefficiencies in the formal adapter: + +1. `generate_stage_1` produces rows efficiently, but batch proving then called + `SystemWitness::from_stage_1` to reconstruct every lookup buffer. That + evaluator processes circuits and rows sequentially, interprets the graph, + and copies arguments even for zero-multiplicity messages. The existing + `Backend::generate` benchmark measured a different path: fused rows and the + compiled, parallel lookup writer. It missed this later serial pass. +2. Even a one-shard retained proof copied every stage-one matrix and kept the + originals for the proof's lifetime. The recursive fixture has 937,960,213 + cells: that copy alone allocates approximately 6.99 GiB. +3. Selecting device-derived lookups unconditionally forced commitment + regeneration. A single shard therefore repeated its upload, LDE and Merkle + commitment despite the caller requesting retention. A single shard has no + other commitments to release between rounds; retaining it needs the same + peak proving workspace. + +Distributed execution replay and missing generated execution kernels do not +explain these measured preparation costs. Execution is outside this timer. +Ordinary legacy CUDA also uses CPU trace generation; the reported failure of +legacy's optional generated CUDA traces is a separate issue. + +## Changes + +Batch lookup reconstruction now uses the existing compiled lookup writer, +parallel across circuits and row batches. That writer is compiled from the +actual constraint graph and rejects nonlocal lookup expressions. Shard +boundary selectors in the current adapter occur in constraints, not lookup +messages. Tests compare the resulting stage-two witnesses and accumulators +with the independent graph evaluator, including sliced ROMs, fixed-table +padding, inactive circuits, and zero multiplicities. + +For a single retained shard, the supplier moves the owned matrices into the +prover. Multi-shard proofs and explicit regeneration still slice their source +matrices. GPU lookup mode now honors retention for one shard, including in the +streamed API and resource planner. Multiple GPU shards still regenerate to +bound device residency. Explicit single-shard regeneration remains available +for parity checks. + +Full host lookup buffers remain the default because they support the backend's +memory-pressure fallback. `AIUR_TRACE_ONLY_LOOKUPS=1` remains the faster CUDA +option when graph evaluation is available. Shape-only buffers still fail +explicitly if a host fallback tries to consume them; verification and key +export still ignore this prover-only setting. + +## Local measurements + +Same environment and real recursive fixtures used in the earlier comparison; +16 Rayon threads pinned to CPUs 0–15 on an Intel Xeon 6975P-C. Both binaries +use native release builds, identical optional timers and disabled transparent +huge pages. Each number is a median of three independent process runs. Two +trace warmups precede the measured proof in each process. These are **CPU** +measurements of the shared adapter and CPU prover, not new CUDA timings. + +| Workload and phase | Before | After | +|---|---:|---:| +| Environment: stage-one population | 0.0332 s | 0.0331 s | +| Environment: source trace copy | 0.1168 s | removed | +| Environment: batch host lookups | 0.7073 s | 0.0491 s | +| Environment: trace + proof + verification | 2.5379 s | 1.7410 s | +| Recursion: stage-one population | 0.8779 s | 0.8821 s | +| Recursion: source trace copy | 2.7461 s | removed | +| Recursion: batch host lookups | 13.0554 s | 0.9287 s | +| Recursion: trace + proof + verification | 40.4244 s | 24.7873 s | + +The full measured CPU path improves by 31.4% for the environment and 38.7% +for recursion. Stage-one population is unchanged. The new move-only supplier +takes roughly 1–2 microseconds; the table labels the eliminated matrix copy +as removed. Independently computed phase medians need not sum to the total. + +Both saved proofs, verifying keys and claims are byte-identical before and +after, and every circuit statistic is unchanged. All twelve benchmark proofs +verified. The environment proof is 6,557,454 bytes; recursion is 3,168,863 bytes. +The GPU benefit of avoiding a second commitment still needs hardware timing; +subtracting these CPU timings from the reported GPU totals would not be a +valid measurement. + +## Reproduction and validation + +[Summary](benchmarks/formal-aiur-gpu-preparation/summary.csv), +[individual runs](benchmarks/formal-aiur-gpu-preparation/runs.json), and +[manifest](benchmarks/formal-aiur-gpu-preparation/manifest.json) preserve the +measurements, binary/input hashes and proof identities. Full local logs, +baseline/fixed binaries and saved proofs are in +`.lake/gpu-followup-20261030`. + +```sh +cargo build --release --locked -p stark-verifier \ + --features parallel,aiur/trace-profile --example compare +RAYON_NUM_THREADS=16 IX_BENCH_NO_THP=1 IX_BENCH_REUSE_EXECUTION=1 \ + AIUR_TRACE_ONLY_LOOKUPS=0 taskset -c 0-15 target/release/examples/compare \ + .lake/formal-integration/recursion-tuned.json \ + .lake/formal-comparison/final/new-environment-grouped.json.inner/input.json \ + /tmp/recursive-proof.json 1 --prove --save-proof +``` + +`aiur/trace-profile` now also emits `aiur_prover_profile` events for +`shard_copy` and `shard_lookups`. These timers compile out of normal builds. +For GPU timing, build the same example in a separate target directory with +`parallel,cuda,aiur/trace-profile`, and compare lookup modes 0 and 1. + +The hardware gate in `tools/ixvm/check-cuda.py` adds single-shard graph-lookup +retention/regeneration proofs for IxVM, recursion and aggregation, each checked +against a CPU reference. It asserts the requested retention policy was honored. +The existing multi-shard cases remain. Run it through `IX_TEST_CUDA=1 +tools/ixvm/check-formal.sh` on the GPU host. + +Validation passed: 104 targeted Rust tests with parallel generation and 88 +Aiur tests with serial generation; Clippy with warnings denied; CPU retained, +regenerated and single-shard proof/key parity for all three applications; and +the resident/distributed controller gate including complete aggregation and +cache replay. CPU reports are in +`.lake/orchestration-final/cuda-check-7g951y0z/report.json` and +`.lake/orchestration-final/controller-check-67ry6a6t/report.json`. +All three CUDA hosts compile/link, and all affected CUDA targets pass Clippy +in the CUDA 13.3.1 development image for SM 80. This is build validation only; +the new single-shard retention path has not run on a GPU here. No Lean source, +theorem, axiom, or correctness certificate changed. + +The 2026-10-31 [hardware validation](formal-aiur-gpu-validation.md) ran these +single-shard paths on a GPU: proofs and keys match the CPU byte for byte, and +the large recursive verifier now takes 4.17 s (host lookups) and 2.72 s (graph +lookups) on CUDA. + +The hardware report's legacy `AIUR_GPU_TRACE=generated` failure in `ood_loop` +is not fixed by this change. Its reproducer and GPU output were not available +locally; ordinary legacy CUDA and the formal backend do not use that generated +row writer. diff --git a/docs/formal-aiur-gpu-validation.md b/docs/formal-aiur-gpu-validation.md new file mode 100644 index 000000000..2a0cb9f91 --- /dev/null +++ b/docs/formal-aiur-gpu-validation.md @@ -0,0 +1,332 @@ +# Formal Aiur on CUDA: hardware validation and pipeline bottlenecks + +Measured 2026-10-31 on one RTX PRO 6000 Blackwell Server Edition (96 GB, +driver 595.99.02, CUDA 13.3, `MULTI_STARK_CUDA_ARCHS=120`), a 32-thread Xeon +Platinum 8559C and 249 GB of RAM, starting from `129c8056`. Legacy numbers use +the binaries built for the 2026-10-29 review; the legacy sources have not +changed since. Prover benchmarks pin `RAYON_NUM_THREADS=16` and disable +transparent huge pages, as in the earlier comparisons. The same machine also +ran `origin/main` and the complete CPU pipeline for comparison. + +## Hardware validation + +`IX_TEST_CUDA=1 tools/ixvm/check-formal.sh` passes. CPU and CUDA proofs and +keys are byte-identical for IxVM, recursion and aggregation under retain and +regenerate, with host and graph-derived lookups. This includes the single-shard +graph-lookup retain/regenerate cases added by the +[batch preparation follow-up](formal-aiur-gpu-preparation.md), which had not +run on a GPU before. The one-device resident controller and distributed proofs +pass, and the CPU host verifies every GPU proof. The gate now also checks +GPU stage-one population (`AIUR_GPU_TRACE=generated`) for all three +applications, sharded and single-shard; with every change below, all 43 +earlier proof and key files are byte-identical to the first run and the 10 new +ones match the CPU. The 97 Rust tests of the CUDA-featured `aiur`, `ixvm`, +`stark-verifier` and `ix-prover` and multi-stark's 54 CPU and 88 CUDA tests +pass. The gate previously required ripgrep and stopped on hosts without it; it +now uses grep. + +## Prover benchmark + +Same inputs and benchmark contract as the 10-29 review (trace generation, +proving and verification; median of three processes, seconds). Formal +artifacts were exported at `129c8056`. The fixes below do not change this +single-shard path. + +| Workload | Formal CUDA | Legacy CUDA | Formal graph lookups | Legacy graph lookups | Formal CPU | Legacy CPU | +|---|---:|---:|---:|---:|---:|---:| +| `Nat.add_comm` frontier | 0.183 | 0.199 | 0.179 | 0.203 | 0.334 | 0.250 | +| 342-constant environment | 0.493 | 0.412 | 0.440 | 0.466 | 1.854 | 1.845 | +| Small recursive verifier | 0.092 | 0.106 | 0.091 | 0.102 | 0.157 | 0.173 | +| Large recursive verifier | 4.172 | 3.411 | 2.724 | 4.011 | 23.855 | 27.424 | + +The 10-29 review measured 20.288 s and 8.330 s for the large recursive verifier +on CUDA (host and graph lookups) and 1.286 s and 0.680 s for the environment; +`44ea8742` accounts for the difference. Formal circuits are smaller than +legacy's (87.3 versus 94.7 billion FFT-cost units for the large verifier), and +with graph-derived lookups formal is faster than legacy on every workload. + +With host lookup buffers (the default), formal remains slower than legacy on +the two large workloads. multi-stark's CUDA prover took the graph path for all +68 lookup jobs of the large verifier even though host buffers were supplied: +the buffers are built (0.97 s, about 17 GB) and never read unless device memory +pressure forces a fallback. `Blake3::compress` alone, with 226 lookup slots and +1,672 lookup values per row over 2^20 rows, accounts for 14 GB of that. A +different allocator does not change it (mimalloc: 4.05 s versus 4.13 s). + +## Pipeline: `ix prove --lanes 1` + +The 342-constant environment, partitioned with `ix shard --shards 4`, proved +with `ix prove --ixe env.ixe --ixes env4.ixes --trace-shards --lanes 1 +--exec-jobs 2 --max-ram 160 --no-index --no-cache`. Every successful run +verifies its root; runs of the same configuration produce the same root. + +| Configuration | Wall | Peak RSS | Sampled GPU peak | +|---|---:|---:|---:| +| Legacy (`--legacy`, `AIUR_TRACE_ONLY_LOOKUPS=1`) | 95.7 s | 29.8 GB | 50.6 GB | +| Legacy, `--exec-jobs 4` | 97.0 s | 29.8 GB | 50.7 GB | +| Formal `129c8056`, its GPU default (`--shard-rows 65536`) | fails after 204–211 s | 37–38 GB | 4.6 GB | +| Formal `129c8056`, `--shard-rows 4194304`, graph lookups | 94.7 s | 23.1 GB | 32.5 GB | +| Formal `129c8056`, `--shard-rows 4194304`, host lookups | 105.5 s | 41.0 GB | 32.5 GB | +| Formal with these fixes, defaults, graph lookups | 63.3–66.6 s (four runs) | 26.5 GB | 32.5 GB | +| Formal with these fixes, defaults, host lookups | 73.6–74.5 s (three runs) | 45.6 GB | 32.5 GB | +| Formal with these fixes, graph lookups, `--exec-jobs 4` | 57.6 s | 33.3 GB | 32.5 GB | +| Formal with these fixes, graph lookups, `--direct-joins` | 64.0 s | 34.8 GB | 32.6 GB | + +At the old GPU default, each wrapped leaf became a 64-shard, ~30 MB proof. The +next join then executed for 65 s (34 billion instructions), produced a 29.8 GB +record and 10.9 billion stage-one cells, and planned a 121 GB peak against an +85 GB lane budget, so the run stopped with exit 75. The fixed and 4M-row runs +publish the same root, `ce29cb0e…3108b`. + +## Comparison with main + +`origin/main` at `7a313fdf` is this branch's base plus one test-only commit. +It was built in a separate worktree with `IX_CUDA=1` (and, for its recommended +configuration, `IX_CUDA_TRACE_CODEGEN=1`) and run on the same day with the same +environment, partition, flags and machine as above. Main's backend is legacy +Aiur, which on main executes IxVM, the recursive verifier and aggregation +through generated native Rust. This branch's `--legacy` runs the same programs +as bytecode. The two pin multi-stark one commit apart. + +| Configuration | Wall | Peak RSS | Sampled GPU peak | +|---|---:|---:|---:| +| main, defaults (host lookups) | 131.4 s | 29.5 GB | 20.0 GB | +| main, `AIUR_TRACE_ONLY_LOOKUPS=1` | 67.6 s | 29.7 GB | 50.6 GB | +| main, the same, `--exec-jobs 4` | 68.8 s | 29.7 GB | 50.7 GB | +| main, its recommended GPU settings¹ | 60.6 s | 22.7 GB | 50.8 GB | +| this branch, `--legacy`, `AIUR_TRACE_ONLY_LOOKUPS=1` | 95.7 s | 29.8 GB | 50.6 GB | +| this branch, host lookups (`AIUR_TRACE_ONLY_LOOKUPS=0`) | 73.3–74.5 s | 46.1 GB | 32.5 GB | +| this branch, defaults (device lookups) | 63.3–66.6 s | 26.7 GB | 32.5 GB | +| this branch, the same, `--exec-jobs 4` | 57.6 s | 33.3 GB | 32.5 GB | +| this branch, two lanes sharing the GPU, 96 GB each | 56.6 s | 33.3 GB | 64.1 GB | + +¹ `AIUR_TRACE_ONLY_LOOKUPS=1 AIUR_MAX_PIECE_LOG_HEIGHT=24 +AIUR_TRACE_SHARD_MAX_CELLS=1500000000 AIUR_GPU_TRACE=generated`, from main's +`docs/aiur-gpu-proving.md`. + +- With device lookups, main and this branch's `--legacy` publish the same root + (`a5ee6683…`), including main's generated GPU traces. Legacy is unchanged by + the migration apart from execution: main's joins execute in 10.4–11.6 s, + the branch's legacy bytecode in 20.7–21.8 s. +- Main's default is slower than its device-lookup run because host lookup + buffers count against its per-GPU workspace. Its planner cut shards to 375 + million cells: each join became 11 shards and the root 25 shards (a 10 GB + record). Wrapping that root took 44.5 s and left it at 25 shards. This is the + same small-shard failure mode as this branch's former 65536-row default; main + degrades rather than failing. +- Per verified leaf proof, main's native executor takes about 5.3–5.8 s and + legacy bytecode about 10.4–10.9 s. Formal bytecode wraps one leaf in 7.8–8.9 s + and joins two wraps in 7.2–7.9 s. Formal circuits and proving make up the + difference, so formal's default is at parity with main's recommended + settings here and twice as fast as main's default. + +## Where formal pipeline time goes + +The fixed formal pipeline spends 61 s executing and 22.5 s proving, with +recursive executions on the critical path (7–9 s each, as above); the GPU is busy +16–20% of the time. A per-function profile (`aiur/function-profile`) of the +large recursive verifier input (a 7.2 MB IxVM proof, 8.0 s, 3.3 billion +instructions) attributes half the execution to Blake3: + +| Function | Self time | Calls | +|---|---:|---:| +| `Blake3::compress` | 50% | 911,439 | +| `Blake3::compress_chunks` | 7% | 1,101,373 | +| `Pcs::ro_fold` | 7% | 1,259,911 | +| `Pcs::rows_pop` | 5% | 667,757 | +| proof, key and stream decoding | about 15% | | + +Each `compress` call (one Blake3 round) executes about 172 byte-table +operations, 57 field additions and 28 word hints, at roughly 15 ns per +operation. A microbenchmark of random multiplicity updates over eight 512 KiB +tables costs 3–5 ns per update, so table cache misses do not explain this. The +cost is interpreter dispatch, which compiled execution removes; main's native +executor verifies a leaf proof about 1.5 times faster than formal bytecode. + +## Recursion under per-lane budgets + +Aggregation converges only when each recursive proof has few shards: a wrap +or join verifies every shard of its children, so a child split by its lane's +budget makes the parent's record and trace larger, and so on up the tree. The +controller gives every lane an equal, fixed share of the prover workspace. + +The complete CPU pipeline (`ix prove --aggregate`, same environment and +partition, `--exec-jobs 4 --max-ram 192 --no-cache`) shows both failure modes: + +| CPU configuration | Result | Wall | Peak RSS | +|---|---|---:|---:| +| `--jobs 2`, former default 65536 rows | first joins exceed the budget (exit 75) | 3:05 | 46 GB | +| `--jobs 2 --shard-rows 4194304` (the guide's former recipe) | root wrap exceeds the budget (exit 75) | 5:16 | 86 GB | +| `--jobs 1`, new default (automatic rows) | verified root `ce29cb0e…` | 3:19 | 67 GB | + +At 65536 rows the first join reproduced the GPU failure exactly (78 s of +execution, a 29.8 GB record, 256 shards, a 121 GB plan against 51 GB). With two +lanes, each lane's 51 GB could not hold a single-shard wrap of a leaf (75 GB +planned), so wraps used 8 shards, joins 8, the next join 32, and the root +wrap's stage-one trace alone (5.5 billion cells) exceeded the lane. Records +grew 6.7 → 7.4 → 11.2 → 15.1 GB. With one lane every recursive proof had one +shard (the root join two) and the CPU pipeline produced the same root as the +GPU pipeline. + +The same divergence affected CUDA, because the shared planner charged the CPU +prover's commitment phases to host RAM even when they run on the device. At +`--max-ram 96` (the per-GPU budget of the orchestration guide's four-GPU example) +one GPU lane failed in 2:33 with host or device lookups. The standalone CUDA +host shows the overestimate for the large recursive verifier: + +| Shards, lookups, retention | Planned before | Planned now | Measured RSS | +|---|---:|---:|---:| +| 1, host, retain | 76.4 GiB | 42.7 GiB | 25.0 GiB | +| 1, device, retain | 76.5 GiB | 15.2 GiB | 10.5 GiB | +| 1, host, regenerate | — | 51.7 GiB | 32.1–33.0 GiB | +| 8, host, regenerate | 46.4 GiB | 48.6 GiB | 30.8–31.6 GiB | +| 8, device, regenerate | 46.4 GiB | 23.3 GiB | 14.7–14.9 GiB | + +Measured RSS covers the whole process, including execution; every plan stays +above it. Forced retention of eight shards still plans the CPU commitment +model and is refused, as before. With the CUDA host +model below, the `--max-ram 96` pipeline verifies its root in 75.3 s with 40 GB +peak RSS: every wrap and join plans one shard, and the root join four. At +`--max-ram 160` the plans, proofs and root (`ce29cb0e…`) are unchanged +(73.6 s with host lookups, 66.2–66.6 s with device lookups; the earlier +63.3 s used the same plans and differs only in job order). + +## Fixes + +**Buffered JSON outputs.** `stark-verifier` and the resident controller wrote +each recursive proof's `input.json` (every proof byte as a JSON number) +through an unbuffered `File`, one write syscall per token. That cost about +2.3 s of lane time per 3.5 MB proof and 18 s for a 30 MB, 64-shard proof. +Lane time per recursive job dropped from 4.5–4.9 s to 2.3–2.5 s; the proof +and `input.json` bytes are unchanged. + +**Automatic, device-sized shards.** The CLI used `--shard-rows 65536` +everywhere. It now defaults to automatic planning: the largest shards that fit +the RAM budget. On CUDA the planner also bounds each shard's committed cells +(stage-one, stage-two and quotient columns over padded rows) by +`AIUR_TRACE_SHARD_MAX_CELLS`, 1.5 billion by default. That is legacy lanes' +default; one such shard of the large recursive verifier (1.46 billion cells) +peaks near 33 GB. CPU builds apply a cell bound only when `max_cells` is given. +Explicit `--shard-rows` remains a cap. Lower the cell bound on smaller devices. +The CPU pipeline failed the same way at 65536 rows (above). + +**CUDA host-memory model.** CUDA plans now charge host RAM for what the host +holds while the device commits, builds stage two and opens: the source +matrices, the shard witness (trace and, unless the device derives them, lookup +buffers), the next shard's witness when there are several, and 256 MiB of +upload staging. A retained single shard moves its trace from the source and +is charged only its lookups. Retained multi-shard commitments keep the CPU +model, because device pressure can spill them to host memory. This mirrors +legacy's CUDA host workspace. CPU builds are unchanged. + +**Parallel slicing, moved on last use.** Multi-shard batches copied every +shard's rows with a serial `to_vec`, again in round two when regenerating. +Slices are now copied in parallel. On a shard's last supply, matrices that no +later shard reads (fixed tables and circuits no taller than one shard) move +into the prover instead of being copied. The large recursive verifier as two +shards, standalone host, proving seconds: + +| Case | Before | After | +|---|---:|---:| +| Graph lookups, regenerate | 8.13 | 2.76 | +| Host lookups, regenerate | 11.31 | 5.70 | +| Host lookups, retain | 6.39 | 3.19 | +| One shard (automatic plan) | 1.79 | 1.79 | + +In the pipeline, the upper join that needed two shards went from 13.2 s to +4.2 s of proving. All standalone proofs above are byte-identical to `129c8056`. + +**Device lookups by default, with a safe fallback.** CUDA proving no longer +builds host lookup buffers by default. multi-stark's direct and CPU lookup +paths, taken when device memory pressure keeps a commitment off the device, +used to abort on shape-only buffers. As of multi-stark `ed65a7c`, pinned here, +they rebuild the omitted values from +the committed trace: the committed LDE's evaluations on `gH` interpolate the +trace back onto `H` (a retained host trace is used when present), and +multi-stark's lookup evaluator, now parallel over rows, derives the values. +With `MULTI_STARK_CUDA_MIN_FREE_BYTES` holding 85 or 93 GB of the device free, +the large recursive verifier went from an aborted prover to 12.0–14.6 s and +the same proof bytes as an unpressured run (host lookups take 6.8 s under the +same pressure). Unpressured it proves in 1.84 s with 10.5 GiB peak RSS, +against 3.19 s and 24.9 GiB with host buffers. The pipeline default drops from +73.3 s and 45.8 GB to 66.0 s and 26.7 GB. multi-stark's CPU tests now prove +shape-only witnesses (with preprocessed columns, and batches under both +retention policies) byte-identically. `AIUR_TRACE_ONLY_LOOKUPS=0` restores host +buffers. + +**Shared prover workspace.** Lanes reserve their planned peak from one +workspace instead of owning a fixed share. A recursive job that its share would +split into more shards plans within the whole workspace and waits for it; on +CPU it also takes every lane's threads. The CPU pipeline with `--jobs 2 +--max-ram 192`, which failed before, now proves single-shard wraps and the +same root as one lane in 3:20 (69 GB peak RSS). + +**Run from anywhere, prepare ahead.** Formal `ix` resolves its exporters, +sources, artifact cache and Rust hosts against the checkout it was built in +(or `IX_ROOT`) instead of the working directory, and announces a first-use +export. `ix prepare [--cuda]` builds the hosts and exports the IxVM and +aggregation artifacts ahead of time. The IxVM export itself still takes 9.5 +minutes: 41 s parsing and checking, 10 s table checks, 35 s bytecode and 480 s +compiling the certified circuits, grouping and population plans. + +**Multi-lane GPU smoke tests.** Every multi-stark CUDA entry point selects its +device explicitly, and its process-wide caches are host-only or keyed by +device, so lanes on different devices in one process do not share device +state. With one GPU, the test opt-in `IX_PROVER_SHARED_DEVICES=1` lets lanes +share a device: `check-controller.py --devices 0,0` passed (jobs split across +both lanes, every proof byte-identical to the CPU reference), and the pipeline +with `--lanes 2` on device 0 proved the same root as one lane in 56.6 s. + +**Opt-in GPU stage-one population.** `AIUR_GPU_TRACE=generated` fills on the +device every function circuit whose population plan reads only recorded calls +(through a device hash of the callee's queries), the U8 byte tables and the +word hints: `crates/aiur/cuda/population.cu` interprets the compiled plans and +group placements, and the rows reach multi-stark as generated traces, so the +host neither builds nor uploads them. The record tables they read are uploaded +once per proof. In the recursive verifier 3 of 54 circuits qualify, among them +`Blake3::compress` (over half the cells); the rest use memory or stream hints, +or are ROMs and fixed tables. Proofs are byte-identical: a unit test covers a +grouped program sharded and whole under both retention policies, the hardware +gate covers IxVM, recursion and aggregation, and the pipeline publishes the +same root. The large recursive verifier proves with 7.8 GiB peak RSS instead of +10.5 GiB, but host population only drops from 0.66 s to 0.51 s while proving +grows from 1.84 s to 2.29 s: the interpreter fills `compress` in about 10 ms per +64K rows, and graph lookups regenerate its tiles (42 tile fills, 2.6 times the +trace). The pipeline takes the same 66.0 s with 14.0 GB peak RSS (26.7 GB by +default) and 28 GB on the GPU (32.5 GB). + +## Remaining gaps + +- **Native execution.** Recursive-verifier execution is the critical path + (61 s of execution against 23 s of proving; the GPU is busy 16–20% of the + time), and half of it is `Blake3::compress` in the bytecode interpreter. + Main executes the same kind of work with generated native Rust about 1.5 + times faster per verified proof. The planned procedural-macro backend is the + fix; more lanes and `--exec-jobs` help meanwhile (56.6–57.6 s). +- **GPU trace generation speed.** Formal's `AIUR_GPU_TRACE=generated` is + correct and halves host RAM but is not faster: it interprets plans and + covers only plans without memory or stream state. CPU population costs 5.2 s + across the pipeline (0.63–0.73 s per large recursive job), and the covered + circuits are about 0.15 s of each. A speedup needs generated kernels covering + memory and ROM circuits too, the same code generation as native execution. + Main's legacy `AIUR_GPU_TRACE=generated` (built with `IX_CUDA_TRACE_CODEGEN=1`) + works in main's pipeline here, with roots identical to CPU traces, and saves + about 2 s per three-shard join. The 10-29 review's `OodEvaluationMismatch` + came from the standalone legacy benchmark on the recursion fixture and was + not reproduced in main's pipeline. +- **Multiple physical GPUs.** Lanes on distinct devices were reviewed and + smoke-tested on one shared device, not run on several devices. +- **Row-capped shards.** Every circuit shorter than the row cap stays in shard + zero, so a job just over the cell bound becomes one large shard plus small + ones, and graph lookups regenerate every shard of a multi-shard batch. +- **Export time.** The certified IxVM export takes 9.5 minutes, 85% of it in + circuit compilation, grouping certification and population plans. `ix + prepare` moves it out of the first proof but does not shorten it. +- **multi-stark revision.** The lookup fallback is multi-stark `ed65a7c` on + branch `formal-aiur/lazy-lookups`, on top of the previous pin `c7324887` + (`perf/aiur-lookup-writes`). Neither is on multi-stark's main branch yet. + +## Data + +[Prover medians](benchmarks/formal-aiur-gpu-validation/prover.csv) and +[pipeline runs](benchmarks/formal-aiur-gpu-validation/pipeline.json). diff --git a/docs/formal-aiur-grouping-comparison.md b/docs/formal-aiur-grouping-comparison.md new file mode 100644 index 000000000..a813e89a7 --- /dev/null +++ b/docs/formal-aiur-grouping-comparison.md @@ -0,0 +1,252 @@ +# Function grouping, primitive acceleration, and CUDA integration + +Measured 2026-10-26 on branch `migration/formal-aiur` in Ix. Both execution +paths use bytecode. Native codegen remains deferred to the future macro backend. + +The [2026-10-27 grouping tuning](formal-aiur-grouping-tuning.md) supersedes the +grouped new-Aiur sizes below, reducing IxVM to 8,018 main columns and the +recursive verifier to 3,199. This report retains the original baseline data. + +## What changed + +- Both application exports now group distinct functions into shared physical + circuits. The application policies translate legacy's measured function + groups after physical deduplication. Missing or inlined members are skipped; + entrypoints remain separate. `--ungrouped` retains the comparison baseline. +- Shared data columns coexist with private selector/branch columns. Inactive + private values are constrained to zero. Polynomial silence checks avoid + raising cubic constraints to degree four. Quadratic lookup arguments that + need another selector are materialized in private columns. Consequently, + maximum constraint degree stays three and lookup degree stays two. +- The prepared trace writer fills the grouped row directly, preserving each + function's logical call identity. Shard planning, multiplicities, fixed tables, + and ROM placement use the resulting physical circuit order. +- Legacy's nonrecursive helpers called only with `@` now pass through Aiur's + proved inliner. Recursive helpers and helpers with ordinary or unconstrained + calls retain their call boundaries. The adapter does not generate native code. +- The ordinary U8 module computes AND/OR from XOR and less-than from subtraction, + matching current legacy's primitive table sharing. Lean proves the arithmetic + identities over fields in which two is nonzero. This reduces the pair table + from ten multiplicity columns to seven. Legacy's eight include its U16 check. +- Fixed tables pair lookup messages when the known height makes the saved + stage-two FFT work exceed the additional quotient work. The pair table's + stage-two width falls from fourteen to eight, at unchanged global blowup. + This uses multi-stark's existing lookup grouping, not a new Aiur operation. +- U32 decomposition/subtraction/comparison and U64 decomposition use generic + fixed-arity hint closures. Existing byte table overrides return output plus + row index. Opaque U8/U32 values still enter through checked library code. + +## Correctness and CUDA boundaries + +Grouping now has a checked equivalence theorem for the layout that is actually +exported. `Grouping.compile` returns a `Checked` result: finite polynomial and +structural checks certify the heuristic's output before it can reach JSON. +The exporter also certifies the complete partition with `Grouping.preparePlan`, +including functions that remain separate. A failed check rejects the export. + +`Checked.localRule_iff` proves that a finite grouped row, with exactly the +exported width, implements precisely one of the original function row rules, +in both directions. Selector Booleanity and exclusivity, inactive private +zeros, and lifted argument equations follow from the emitted constraints. +Source memory validity follows from the actual shared lookup words; it is no +longer an extra premise supplied to the grouping theorem. + +`Checked.packet_sound` and `Checked.packet_complete` additionally cover every +raw lookup word, including numeric channel/function IDs, memory widths, enables, +unused slots, and zero-padded tails. `Checked.zero_padding` proves the all-zero +row satisfies the equations and emits no lookup messages. +`Plan.derives_iff` lifts row equivalence to whole-program finite derivations. +`Physical.Prepared.grouped_native_heap_sound` composes this with the existing +compiler theorem to obtain source evaluation and heap representation. + +These proofs introduce no `sorry`, new axioms, or `native_decide` obligations. +Their axiom audit uses only Lean's standard `propext`, `Classical.choice`, and +`Quot.sound`. They retain the existing finite-derivation/acyclicity and ROM +contract. Rust's multi-stark lowering, serialization, and the cryptographic +backend remain outside this Lean correctness theorem. The checks happen during +export; they add no execution, trace-population, or proving operations. + +The regression fixture is exported by Lean and checked for freshness. Its Lean +audit rejects changed packet tags and memory addresses, extra enabled sends, +undersized physical rows, and omitted source functions. The Rust test covers +shared branch/ROM rows, reference versus direct population, zero padding, +sharding, a proof round trip, and rejection of forged selectors and inactive +providers. The targeted Rust packages pass 90 tests. Clippy passes with warnings +denied. Byte/word checks cover every byte pair, fixed-table versus accelerated +outputs, invalid domains, dishonest hints, and real U64/Blake3 proof round trips. + +Validation of the complete grouping certificate rebuilt the full proof graph, +passed the fixture freshness/rejection checks and grouped Rust proof test, and +passed `tools/ixvm/check-formal.sh` (IxVM claims, recursive proving, all thirteen +aggregation shapes, and malformed-input rejection). Re-exporting IxVM, the +recursive verifier, and aggregation with all certificate checks enabled produced +byte-identical artifacts, verified by SHA-256, so the column counts and measured +runtime circuits below are unchanged. + +Both CUDA hosts compile and link with CUDA 13.3.1 in the NVIDIA development +container. Stage-one trace population remains on the CPU. The optional +`AIUR_TRACE_ONLY_LOOKUPS=1` mode uses multi-stark's CUDA graph evaluation instead +of allocating host lookup messages, and selects batch regeneration. The default +retains host messages to support CPU fallback under GPU memory pressure. The +shape-only path fails explicitly if such fallback tries to read missing data. +The hardware integration gate covers both modes and CPU verification. +**No GPU timing or runtime validation is available on this host:** it has no +NVIDIA device or driver. CUDA image digest: +`sha256:8cf42b8dc4c34d47fb42ffb0923f8a5e363469a7149181c094da336d311bb466`. + +## Measurement method + +Intel Xeon 6975P-C, Linux x86-64, Lean 4.34.1, Rust 1.98.1. Release builds use +`-Ctarget-cpu=native` on both backends. The final matrix sets +`RAYON_NUM_THREADS=8`; interpreters remain sequential. Two warmups precede five +execution/trace samples, or three for the larger recursive input. Tables report +medians; raw samples are saved. Proving is one verified run and includes trace +regeneration and verification, but excludes execution and system setup. + +`IX_BENCH_NO_THP=1` disables transparent huge pages for each benchmark process, +without changing the machine policy. Legacy requests huge pages for its query +arenas. On the small recursive fixture, allowing those pages inflated execution +from about 4 ms to 163 ms. The same process setting is used on both backends. + +The compiled programs, hint preparation, stream construction, and system/key +setup occur outside the execution timer. Trace timing includes planning, +populating main matrices, fixed-table and ROM counts, padding, and lookup +messages. Both provers use Goldilocks, blowup two, 64 queries, binary FRI, +zero-height caps, and one retained trace shard. FFT cost uses the exact same +operation-count model as `LegacyAiur.Statistics`, including stage-two columns; +it is a work estimate, not wall-clock time. Cells below count padded stage-one +main matrices, not preprocessed matrices or host lookup buffers. + +The workloads are: + +1. `ixvm`: the production `verify_claim` entry, checking `Nat.add_comm` with + its frontier assumptions. Both receive identical claim streams. +2. `environment`: the self-contained 342-constant environment containing that + theorem, with no frontier assumptions. +3. `recursion`: the same small, natively verified multi-stark fixture. +4. `recursion-real`: both generic recursive verifiers check the exact same + proof of the self-contained IxVM environment, produced by the new grouped + backend. This is much larger than the synthetic fixture. + +The programs retain documented semantic differences: new Aiur uses structural +comparisons rather than pointer identity, constrained calls rather than legacy +unconstrained helpers, and generic checked hint/library interfaces. This is a +comparison of the faithful source port and its legacy counterpart, not a proof +that both programs have identical cost or formal semantics. + +## Results + +All times below use eight Rayon threads and bytecode execution. Proving includes +trace regeneration and verification. The small claim/fixture and large production +workloads are shown separately to expose fixed overheads. + +| Workload | Backend | Execute (ms) | Trace + lookups (ms) | Prove (s) | Proof bytes | +|---|---|---:|---:|---:|---:| +| Nat.add_comm frontier | legacy | 8.81 | 11.53 | 0.294 | 5,669,347 | +| Nat.add_comm frontier | new | 5.80 | 6.47 | 0.306 | 6,320,763 | +| 342-constant environment | legacy | 397.74 | 84.35 | 2.450 | 6,854,018 | +| 342-constant environment | new | 360.53 | 154.15 | 3.632 | 7,227,058 | +| Small recursive fixture | legacy | 4.07 | 10.91 | 0.194 | 3,446,443 | +| Small recursive fixture | new | 2.39 | 4.70 | 0.214 | 3,585,743 | +| Real recursive verifier | legacy | 8,821.55 | 2,255.25 | 43.336 | 3,706,823 | +| Real recursive verifier | new | 7,957.46 | 3,562.85 | 55.065 | 3,845,899 | + +The large recursive input is a fixed **7,232,210-byte IxVM proof**. Both +verifiers receive identical key, claim, and proof streams. All reported outer +proofs verify. Real-input ungrouped execution/trace/cost measurements are in +the CSVs; outer proving for that large ungrouped case was not measured. + +### Physical circuit sizes + +Widths include the function provider multiplicity and all ROM/fixed-table +circuits. Stage-two widths are base-field columns (two limbs per extension). + +| Application | Grouping | Legacy circuits | New circuits | Legacy stage 1 | New stage 1 | Legacy stage 2 | New stage 2 | +|---|---|---:|---:|---:|---:|---:|---:| +| ixvm | ungrouped | 794 | 799 | 21,351 | 20,887 | 9,962 | 9,948 | +| ixvm | grouped | 222 | 235 | 9,163 | 9,650 | 3,616 | 4,194 | +| recursion | ungrouped | 197 | 203 | 6,359 | 6,285 | 2,754 | 2,816 | +| recursion | grouped | 84 | 91 | 3,880 | 4,109 | 1,590 | 1,630 | + +Function circuits alone shrink **778 → 214** for new IxVM and **189 → 77** +for the new verifier. Legacy has 202 and 71 grouped function circuits, +respectively. New Aiur is slightly narrower before grouping; the remaining +extra width is predominantly in the grouping layout, rather than ROM metadata. + +The ROM widths match exactly: 18 chips / 424 columns for IxVM, and 11 chips / +179 columns for the verifier. New fixed tables use three chips / ten main +columns; legacy uses two / eleven. Both use fourteen stage-two table columns +after cost-aware lookup pairing. + +### Cells and FFT work + +| Grouped workload | Backend | Stage-one cells | Estimated FFT work | +|---|---|---:|---:| +| Nat.add_comm frontier | legacy | 1,257,336 | 99,854,452 | +| Nat.add_comm frontier | new | 1,322,458 | 100,644,448 | +| 342-constant environment | legacy | 45,169,839 | 3,617,041,155 | +| 342-constant environment | new | 46,656,479 | 3,527,936,909 | +| Small recursive fixture | legacy | 860,644 | 77,849,696 | +| Small recursive fixture | new | 826,803 | 74,587,165 | +| Real recursive verifier | legacy | 985,571,600 | 97,838,278,046 | +| Real recursive verifier | new | 1,005,868,035 | 89,271,866,275 | + +### Remaining gaps + +New bytecode execution is faster on both substantial workloads. The large +environment and recursive traces are still slower, as is proving. On the real +recursive input, new Aiur has about 2.1% more main cells and 8.8% less estimated +FFT work, yet trace generation is about 58% slower and proving about 27% slower. +Cell counts and FFT estimates therefore do not explain the remaining elapsed +time by themselves. This run does not isolate constraint evaluation, lookup +evaluation, allocation, or memory traffic inside the prover. + +Two concrete layout outliers are: + +| Shared policy group | Legacy main columns | New main columns | New lifted lookup arguments | +|---|---:|---:|---:| +| `ixvm_group_08` | 166 | 238 | 67 | +| `verifier_group_12` | 238 | 378 | 161 | + +The verifier group contains `Blake3::finish`, `bytes_to_block`, +`compress_block`, `read_sys_circuits_n`, `ch_sample8`, and `ood_loop`. +The current conservative transform materializes quadratic message arguments +before selecting a member, keeping degree at most three. That accounts for +67 extra columns in `finish` and 84 in `compress_block` within this group. +These are layout costs, not additional semantic operations or malformed traces. + +The next optimization to try is including quadratic message expressions in +private-column selection, then choosing whichever valid layout is narrower. +Zeroing a few shared factors may silence many arguments and remove their +individual materialization columns. The existing silence checker and grouping +lemmas can validate that choice. Another measurable candidate is preparing the +remaining group-write expressions once: `Placement::finish` currently evaluates +those polynomial trees per row. Neither improvement is claimed implemented here. + +## Saved data + +The checked-in [summary CSV](benchmarks/formal-aiur-grouping/summary.csv) +contains all grouped and ungrouped timings, cells, and FFT estimates. +[The per-circuit CSV](benchmarks/formal-aiur-grouping/circuits.csv) includes +**every circuit**, its name, height, and separate stage-one/stage-two widths. +[The manifest](benchmarks/formal-aiur-grouping/manifest.json) records the code +revision, configuration, artifact hashes, and recursive input hashes. Adjacent +[`runs.json`](benchmarks/formal-aiur-grouping/runs.json) retains all raw samples +and proof sizes. Large generated artifacts +and proof inputs remain under `.lake/formal-comparison/final/` locally. + +The code is in commit `9bd5d3ce` on `migration/formal-aiur`. + +## Reproduction + +```sh +RAYON_NUM_THREADS=8 IX_BENCH_NO_THP=1 \ + bash tools/ixvm/compare-backends.sh .lake/formal-comparison/run +``` + +The script exports both artifacts unless `IX_AIUR_ARTIFACT` and +`IX_RECURSION_ARTIFACT` are supplied. Set `IX_BENCH_RECURSIVE_PROVE=1` to prove the +large recursive traces too. The small recursive fixture always gets proved. +`tools/ixvm/compare-results.py` produces `summary.csv`, `circuits.csv` (every +circuit, stage one and stage two separately), and the artifact-hash manifest. + diff --git a/docs/formal-aiur-grouping-tuning.md b/docs/formal-aiur-grouping-tuning.md new file mode 100644 index 000000000..f45fde27b --- /dev/null +++ b/docs/formal-aiur-grouping-tuning.md @@ -0,0 +1,167 @@ +# Tuning the certified grouping layout + +Measured on 2026-10-27, on `migration/formal-aiur`, against `ade9330c`. +Both application policies now use new Aiur's physical functions and measured +row counts. They replace the direct translation of legacy's grouping policy. +The source programs, bytecode, hints, accelerators, ROMs and fixed tables are +unchanged. This is a grouping/compiler change. + +The [CPU scaling follow-up](formal-aiur-trace-scaling.md) measures 1, 8, 32 and +64 threads. New Aiur scales better than legacy on IxVM, but not on the real +recursive verifier; the results below all use eight threads. + +## Results + +Widths include provider multiplicities, ROMs and fixed tables. Stage two is +counted in base-field columns. Legacy sizes are from the +[previous comparison](formal-aiur-grouping-comparison.md); legacy was not +rebenchmarked for this change. + +| Application | Version | Circuits | Stage-one columns | Stage-two columns | +|---|---|---:|---:|---:| +| IxVM | Previous new Aiur | 235 | 9,650 | 4,194 | +| IxVM | Tuned new Aiur | 162 | 8,018 | 3,436 | +| IxVM | Legacy grouped | 222 | 9,163 | 3,616 | +| Recursive verifier | Previous new Aiur | 91 | 4,109 | 1,630 | +| Recursive verifier | Tuned new Aiur | 68 | 3,199 | 1,412 | +| Recursive verifier | Legacy grouped | 84 | 3,880 | 1,590 | + +IxVM loses **16.9%** of its main columns; the verifier loses **22.1%**. +Function circuits fall from 214 to 141 and from 77 to 54, respectively. +The same verifier policy also passes certification and integration tests for +aggregation; its additional functions remain separate unless named in the policy. + +| Workload | Stage-one cells, before → after | Estimated FFT work, before → after | +|---|---:|---:| +| `Nat.add_comm`, frontier assumptions | 1,322,458 → 1,173,983 | 100,644,448 → 95,655,377 | +| Self-contained 342-constant environment | 46,656,479 → 43,146,214 | 3,527,936,909 → 3,287,192,336 | +| Small recursive fixture | 826,803 → 717,864 | 74,587,165 → 71,212,610 | +| Real recursive verifier | 1,005,868,035 → 937,960,213 | 89,271,866,275 → 84,826,424,989 | + +| Workload | Trace + lookups (ms), before → after | Prove (s), before → after | Proof bytes, before → after | +|---|---:|---:|---:| +| `Nat.add_comm`, frontier assumptions | 6.51 → 6.19 | 0.324 → 0.283 | 6,320,763 → 5,478,175 | +| Self-contained environment | 161.11 → 173.34 | 3.618 → 3.400 | 7,227,058 → 6,557,454 | +| Small recursive fixture | 4.74 → 4.41 | 0.214 → 0.206 | 3,585,743 → 2,972,473 | +| Real recursive verifier | 3,552.81 → 3,759.41 | 54.841 → 52.649 | 3,845,899 → 3,168,863 | + +All eight proof runs verify. Proving is faster in these runs, and proofs are +smaller. **Large-input trace generation regresses by 7.6% and 5.8%.** The +policy search models padded cells and FFT work, not the CPU cost of evaluating +shared lookup expressions. That distinction matters: fewer cells do not imply +a faster trace writer. This experiment does not isolate the cause of that +remaining runtime regression. + +Execution is unchanged by grouping. Its measured medians are retained in the +raw data as a control, not claimed as an execution improvement. They vary +between runs despite identical bytecode. + +## What changed + +The layout previously multiplied an entire quadratic lookup argument by the +member selector. That makes it cubic, requiring an extra private witness column +and equations. The compiler now recursively chooses lower-degree ways to select +the expression. For example, with member selector `s` and private branch +selector `b`, it uses `(s - b) * x` for `(1 - b) * x`. When the member is active, +`s = 1` recovers the original argument. When inactive, `s = b = 0` silences it. +The emitted expressions still pass the complete row and packet certificates. + +For remaining arguments, the private-column heuristic considers whether one +private factor can replace several lifted arguments. It only takes a step that +removes at least as many lifted columns as it adds private columns. The field +interface and maximum polynomial degrees are unchanged. + +With memberships held fixed, the layout change alone removes 435 IxVM main +columns and 181 verifier main columns. Two former outliers shrink substantially: + +| Original group | Old main columns | New layout, same members | +|---|---:|---:| +| `ixvm_group_08` | 238 | 171 | +| `verifier_group_12` | 378 | 218 | + +`Blake3::finish` and `Blake3::compress_block` no longer need their 67 and 84 +lifted argument columns. Their private-column counts stay at six and five. + +The membership search then uses measured query counts on both workloads for +each application. It tries individual moves, splitting a member back into a +singleton, and whole-group merges, with at most 16 members per group. It accounts +for power-of-two padding, private/shared/lifted width, lookup pairing, auxiliary +columns and quotient degree. Each workload must stay within the starting +layout's cell and FFT budgets. The objective prioritizes normalized FFT work, +then cells, with smaller weights for total columns and circuit count. It is a +corpus-based heuristic, not a global optimum or a promise about every input. + +Predicted widths, auxiliary widths, quotient degrees, padded cells and FFT costs +match the actual backend **for every function circuit on all four workloads**. +The search produces only a membership policy. Lean compiles and certifies every +result before it can become an exported layout. + +Larger groups also exposed repeated polynomial normalization in certificate +checking. The checker now normalizes equations once and filters equality +comparisons with a structural key. A key match still requires full polynomial +equality. The decidable procedure is proved equivalent to the original +`Implied` proposition; collisions cannot accept an invalid certificate. + +## Validation and measurement + +The full Aiur proof graph and both application executables build. The grouping +fixture passes freshness, rejection and masked-quadratic regression checks. +The Rust grouping test passes shared-row, padding, sharding and proof checks. +`tools/ixvm/check-formal.sh` passes claims, recursive proving, all thirteen +aggregation shapes and malformed-input rejection. The grouping axiom audit +still reports only `propext`, `Classical.choice` and `Quot.sound`; no `sorry`, +new axiom or unchecked certificate shortcut was introduced. +Normal IxVM, verifier and aggregation exports match the certified snapshot +results used for benchmarking and integration, with all non-group fields +unchanged from the baseline artifacts. + +Measurements use the same fixed inputs as the previous comparison, including +the same 7,232,210-byte inner proof for the real recursive verifier. Both sides +of this before/after comparison use bytecode, `-Ctarget-cpu=native`, eight Rayon +threads and `IX_BENCH_NO_THP=1` on an Intel Xeon 6975P-C. Execution remains +sequential. Two warmups precede five trace samples, or three for the large +recursive workload. Tables show medians. Proving is one verified run per case, +including trace regeneration and verification, excluding execution and key +setup; small timing differences should be interpreted accordingly. FFT counts +are work estimates, not measured FFT time. No CUDA implementation changed or +GPU timing was collected for this tuning. + +## Data and reproduction + +The [summary](benchmarks/formal-aiur-grouping-tuning/summary.csv), +[every-circuit table](benchmarks/formal-aiur-grouping-tuning/circuits.csv), +[raw timing samples](benchmarks/formal-aiur-grouping-tuning/runs.json) and +[manifest](benchmarks/formal-aiur-grouping-tuning/manifest.json) preserve the +results. The same directory contains both policies, per-function query counts, +layout metrics, singleton shapes and search reports. These files are sufficient +to rerun the membership search without rebuilding or executing IxVM: + +```sh +data=docs/benchmarks/formal-aiur-grouping-tuning +python3 tools/ixvm/tune-groups.py "$data/ixvm-metrics.json" /tmp/ixvm-policy.json \ + --prefix ixvm_group \ + --profile "$data/ixvm-counts.json" "$data/ixvm-ungrouped-shapes.json" \ + --profile "$data/environment-counts.json" "$data/ixvm-ungrouped-shapes.json" +python3 tools/ixvm/tune-groups.py "$data/recursion-metrics.json" /tmp/recursion-policy.json \ + --prefix verifier_group \ + --profile "$data/recursion-counts.json" "$data/recursion-ungrouped-shapes.json" \ + --profile "$data/recursion-real-counts.json" "$data/recursion-ungrouped-shapes.json" +``` + +To tune a changed program, generate a snapshot once, then reuse it: + +```sh +lake build ixvm/ixvm multiStark/stark-export aiur/grouping_tune +lake env IxVM/.lake/build/bin/ixvm grouping-snapshot /tmp/ixvm-snapshot.json +lake env MultiStark/.lake/build/bin/stark-export grouping-snapshot /tmp/recursion-snapshot.json +lake env Aiur/.lake/build/bin/grouping_tune /tmp/ixvm-snapshot.json /tmp/ixvm-metrics.json --metrics +lake env Aiur/.lake/build/bin/grouping_tune /tmp/ixvm-snapshot.json /tmp/ixvm-groups.json \ + --policy /tmp/ixvm-policy.json +``` + +The last command runs the ordinary grouping and partition certificates. Use +`--baseline` to inspect the former layout algorithm. The `compare` Rust example +accepts `--counts-only` to record function query counts, `--ungrouped` to measure +singleton shapes, and `--groups /tmp/ixvm-groups.json` to benchmark a certified +candidate against an existing package. The normal application exports use the +committed policies without additional flags. diff --git a/docs/formal-aiur-migration.md b/docs/formal-aiur-migration.md new file mode 100644 index 000000000..f2978b67f --- /dev/null +++ b/docs/formal-aiur-migration.md @@ -0,0 +1,430 @@ +# Formal Aiur in Ix + +The new implementation is imported from `aiur` commit +`7584bf5` on `bench/ixvm-audit`. Its compiler correctness proofs are retained; +the Lean sources are adapted to Ix's Lean/Mathlib 4.34.1 toolchain. In particular, +the Aiur package selects Lean's legacy `do` elaborator to preserve the verified +monadic definitions from 4.29. Proof adaptations do not add axioms or `sorry`. + +## Package boundaries + +| Component | Lean package/library | Rust crate | +| --- | --- | --- | +| Generic language, compiler, proofs, libraries | `Aiur/` / `Aiur` | `crates/aiur` | +| IxVM claim verifier and host | `IxVM/` / `IxVM` | `crates/ixvm` | +| Recursive verifier and aggregation program | `MultiStark/` / `MultiStark` | `crates/stark-verifier` | +| Resident execution and proving controller | — | `crates/ix-prover` | +| Shared execution record reservation pool | — | `crates/record-pool` | +| Shared verifying-key and range-advice codecs | — | `crates/stark-key` | + +The previous unverified `LegacyAiur`, `LegacyIxVM`, `LegacyMultiStark` packages +and `crates/aiur-legacy`, `crates/ixvm-legacy`, `crates/ixvm-legacy-native` +crates have been retired. + +The generic Aiur crate does not depend on IxVM, the legacy interpreter, or a +Lean installation. The IxVM crate registers its hint channels and table +accelerators using Aiur's generic APIs. Its Rust binary accepts an exported +execution package. Lean's `IxVM.parse` loads the application and its shared +Goldilocks word/hash library; callers select entrypoints with +`Aiur.Modules.prepare`. + +Aiur owns the FFI: `Aiur/c/execution.c` adapts Lean objects to the JSON C ABI +exported by the Rust `aiur` static library. Lake's `aiur/execution_o` and +`aiur/aiur_rs` targets are linked only by executables that use it. The IxVM +export driver builds without Rust and invokes the separate `ixvm` host for +execution with its application hint providers. Pure Lean library/proof builds +do not run Cargo. Cargo builds do not invoke Lake. Serialization remains the +current bridge; this migration does not replace it with a direct object ABI. +The old experimental IxVM +`ffi` replay command is removed: the data-only ABI cannot supply the word +library's closure hints. Generic Aiur FFI execution and tracing remain covered +by their own test executables. + +## Build and run + +From the repository root: + +```sh +lake -d Aiur build +lake -d Aiur test +cargo test --locked -p aiur -p ixvm --features parallel --all-targets + +lake -d IxVM build ixvm +lake -d IxVM exe ixvm export /tmp/ixvm-execution.json +cargo run --release --locked -p ixvm -- /tmp/ixvm-execution.json all + +lake -d IxVM exe ixvm export-trace /tmp/ixvm-trace.json +cargo run --release --locked -p ixvm --features parallel --example ixvm_bench -- \ + /tmp/ixvm-trace.json IxVM/IxVM/fixtures/nat-add-comm.json witness 1 +``` + +The last command executes bytecode, generates traces, and proves and verifies +the fixed fixture. `stats` exports per-function stage-one widths. These drivers +also work from the root Lake workspace as `lake exe ixvm/ixvm ...`. + +## Current port and CLI integration + +The application port now follows Ix revision +`827550579ea660a4749c520968ad6f58be63acf4`, including the current claim dispatcher, +evaluation, environment checking, reveal and membership claims. It contains +809 application source functions; the claim execution export contains 831 +bytecode functions including shared libraries. The generic Aiur proofs have +not changed in this update. + +The ordinary commands use the certified Formal Aiur backend (`--formal` remains +a compatibility alias; `--legacy` has been retired): + +```sh +ix prepare --cuda # once per source revision: hosts and certified artifacts +ix check Nat.add_comm +ix prove Nat.add_comm +ix verify + +ix prove --ixe env.ixe --ixes env.ixes +ix verify --ixe env.ixe --ixes env.ixes ... +ix aggregate --ixe env.ixe --ixes env.ixes \ + --shard-rows 1048576 --direct-joins --structural-above 0 ... +ix verify --aggregate --ixe env.ixe --ixes env.ixes \ + --structural-above 0 +``` + +The CLI builds the separate exporter and caches its artifact by source and +exporter contents, in the `.lake/aiur` of the checkout `ix` was built in (or +`IX_ROOT`), so commands work from any directory. `ix prepare` does this, and +builds the Rust hosts, ahead of time; otherwise the first command that needs an +artifact exports it, which takes about ten minutes for IxVM. `--aiur-artifact` / `IX_AIUR_ARTIFACT` and +`--aggr-artifact` / `IX_AGGR_ARTIFACT` select already exported **trusted** compiler +artifacts. These are verifier configuration, never advice supplied by the +prover. `IX_AIUR_HOST` and `IX_STARK_HOST` can select prebuilt host executables. +Rebuild the Rust binaries after changing their sources. + +Proofs retain Ix's claim wrapper and content-addressed store. Formal stage-one +and aggregate proof payloads have distinct `IXAIUR2` and `IXAGGR2` markers; +legacy proofs cannot be mistaken for them. Verification reconstructs keys from +the trusted artifacts, binds the exact public claims, and rejects trailing +proof bytes. Manifest verification checks disjoint coverage, binds every +nonempty shard, and rejects duplicate or missing proofs. Aggregate verification +also reconstructs the requested flat/structural root and checks that all +environment constants occur exactly once with no undischarged assumptions. + +The formal shard index and aggregate cache use separate namespaces from the +legacy caches. Cache hits are verified before reuse. `--skip-proven`, +`--no-index`, `--no-cache`, and `--no-write` apply to their corresponding formal +paths. Aggregation supports wrap-first and direct joins, flat and structural +folds, manifest plan inspection, subtree selection, and targeted reproving from +verified cached children. Ready slots run in bounded waves. `--jobs` defaults to +one; zero uses the available CPU count. The total RAM budget and CPU threads +are divided among the jobs in each wave, so a single remaining job can use +the full reservation. Every worker in a wave is joined before a failure is +reported or the next wave starts. A verified cache hit cuts off its dependency +subtree, including when no original shard proofs were supplied. Explicitly +supplied aggregate proofs may also cover intermediate statements; their kind, +key, public claim and position in the manifest plan are checked before reuse. + +`--range N` wraps large IxVM proofs through range leaves of at most N source +trace shards, range joins, and a range root. The host only slices advice; Aiur +shapes 10–12 verify the child proofs, preamble binding, contiguous coverage, +residual sum, and original public claim. Range intermediates have a separate +verified cache. `--wrap-root` forces fresh self-wraps until one trace shard +remains, and stops with an error if the shard count stops decreasing. + +Batch proving partitions function and width-specific ROM rows. Channel 16 +closes memory intervals across shards, while the function channel is 1 and +the ROM channel is 2. The verifier checks activation, fixed-table heights, +Goldilocks domain/lookup bounds, exact claims, and ordered nonoverlapping memory +intervals before calling multi-stark. `--retention auto` selects retain when +the estimated batch fits its RAM budget and regenerate otherwise; both can +also be requested explicitly. Both policies produce identical proof bytes in +the partition regression test. Stage-one-only population avoids allocating the +whole-trace lookup buffers that batch proving recomputes per shard. The +execution record stays resident through trace generation, then is dropped +before proving. The complete stage-one matrices remain in host memory. + +Both hosts share the same allocation-phase planner. It accounts for fixed +tables, source matrices, lookup buffers, commitment data, and retained shard +state, with a 25% allowance. CUDA plans charge host RAM only for witnesses and +upload staging, since commitment, stage two and openings stay on the device. It conservatively includes the observed RSS even +after the execution record is dropped. This is an estimate, not a hard allocator +limit or a calibrated peak-RSS bound. The execution itself happens before the +record can be measured. An earlier artifact/fixed-table estimate rejects +budgets that splitting cannot satisfy. Generated matrix sizes are checked +against the plan before proving. `--max-ram` is the total new-backend budget in GiB; +without it, the controller reserves 85% of available host memory, respecting a +root-mounted cgroup v2 limit. Shard rows default to `0`: the planner chooses +the largest shards that fit the budget. CUDA runs also bound each shard's +committed cells by `AIUR_TRACE_SHARD_MAX_CELLS` (1.5 billion, sized for a 96 GB +device). An explicit `--shard-rows` caps rows; small caps multiply recursive +verification work (at 65536 rows the complete pipeline failed on both CPU and +CUDA; see [GPU validation](formal-aiur-gpu-validation.md)). + +Manifest proving supports `--shards`, `--jobs`, `--skip-proven`, `--exec-only`, +`--out-ixes`, and `--report`. An oversized claim is cut into whole blocks and +its parts are executed and planned again. `--trace-shards` requires the original +claim to fit through trace sharding and rejects it if source-record or trace +residency prevents that. `ix check --ram-budget` runs the same planning and +refinement loop without proving. Reports use `ix-formal-run/1` and contain +per-part plans, timings, failures and proof addresses. A failed run does not +publish a refined manifest. Ordinary `ix check` only executes. + +`MultiStark/MultiStark/Program.sources` composes the ordinary Aiur recursive +verifier modules; `Aggregate.sources` reuses them and adds all thirteen current +aggregation shapes, including range leaves, joins and closure. Both reuse the +checked byte/word, list, address, Blake3, and Goldilocks libraries. See +[the module layout](formal-aiur-modules.md) for interfaces and compatibility +checks. Hint closures provide raw advice, and ordinary program assertions +check it. Digest and duplicate-row equality use full structural comparisons; +there are no pointer identities or unconstrained calls. Application address +sets also compare complete address contents, and 64-bit equality compares both +limbs instead of reducing modulo Goldilocks. + +The standalone recursive host supports `execute`, `plan`, `prove`, `verify`, +key export, and range-advice export. A proof invocation supplies the key digest and claims digest publicly, +and proof/key/claims streams privately. The output directory contains +`proof.bin`, `key.bin`, `claims.bin`, `public.json` for independent verification, +and `input.json` for feeding the proof into another recursive-verifier run. + +## CUDA and native builds + +The legacy `--legacy` execution, proving, verification, and generated-kernel +paths have been retired. The certified Formal Aiur backend provides a resident +execution/proving controller (`crates/ix-prover`), CPU execution ahead of +proving, GPU lanes, checkpointed leaf refinement, recursive aggregation, +cross-record distributed execution, and texray. See +[the orchestration guide](formal-aiur-orchestration.md) for commands, resource +accounting, recovery, and validation results. + +The new hosts select multi-stark's CUDA prover with `--gpu-device N` or +`IX_CUDA=1` (device from `MULTI_STARK_CUDA_DEVICE`, otherwise zero). CPU binaries +live in `target/release`; CUDA binaries live in `target/formal-cuda/release` and +are built with `--features parallel,cuda`. Override them independently with +`IX_AIUR_HOST_CUDA` / `IX_STARK_HOST_CUDA` / `IX_PROVER_HOST_CUDA`. Verification and key export use the +CPU hosts. Device choice does not enter the verifying key or proof protocol. +An explicit device request to a CPU-only Rust host fails. + +The trace writer populates stage-one matrices on the CPU by default; CUDA +accelerates multi-stark's prover phases. With `AIUR_GPU_TRACE=generated` (which +needs the default device lookups), function circuits whose population plans +read only recorded calls, byte tables and word hints are filled on the device +instead (`crates/aiur/cuda/population.cu` interprets the same compiled plans +and group placements) and reach multi-stark as generated traces; the record +tables they read are uploaded once per proof. Circuits with memory stores, +loads or stream hints, ROMs and fixed tables keep host rows. Proofs are +byte-identical either way. This is an interpreter, not generated kernels: it +halves host RAM in the pipeline but does not make it faster +([GPU validation](formal-aiur-gpu-validation.md)). +The CUDA CI job checks and links both application hosts and `ix-prover`. On a machine with an +NVIDIA driver and CUDA toolkit, run this from the repository root: + +```sh +IX_TEST_CUDA=1 IX_TEST_OUTPUT_DIR=.lake/cuda-validation \ + bash tools/ixvm/check-formal.sh +``` + +Set `MULTI_STARK_CUDA_DEVICE` to select a device (zero by default). The gate +builds CPU and CUDA hosts separately, then compares complete proof and key +bytes for three grouped applications: the `Nat.add_comm` frontier claim, +recursive verification, and aggregation wrapping. Each application must use +multiple trace shards. It checks CPU retain/regenerate, CUDA retain/regenerate +with host lookup buffers, and CUDA regeneration with graph-derived lookups. +It also checks single-shard CUDA proofs with graph-derived lookups under both +retention policies against an independent CPU proof, including that the +requested retention policy was actually honored. +Every proof is independently verified by the CPU host. Wrong public inputs and +explicit GPU requests to CPU-only hosts must fail. + +Logs, proofs, artifact/binary hashes, and a JSON report are saved under +`.lake/cuda-validation/cuda-check-*/`, including on failure. Without +`IX_TEST_OUTPUT_DIR`, GPU runs retain a directory under `.lake/formal-cuda-check.*`. +Ordinary CPU CI runs the same gate's CPU controls; its report explicitly sets +`hardware_validated: false`. Successful CUDA builds alone do not validate GPU +execution. Both hosts compile and link locally in the CUDA 13.3.1 development +container (SM 80), and all three CPU controls pass with identical proofs and +keys between retain and regenerate. The hardware gate passed on an RTX PRO +6000 Blackwell on 2026-10-31; see [GPU validation](formal-aiur-gpu-validation.md). + +CUDA proving derives lookup messages from the committed stage-one rows using +multi-stark's graph evaluator by default, without host lookup buffers. +Multi-shard batches select regeneration to bound device residency; single-shard +batches can retain their commitment across the barrier, avoiding a second +upload, LDE and Merkle commitment at the same peak memory. When device memory +pressure forces multi-stark onto a path that reads lookup values on the host, +it rebuilds them from the committed trace (coset interpolation of the committed +LDE, then its own lookup evaluator), so the fallback is slower but produces the +same proof bytes. `AIUR_TRACE_ONLY_LOOKUPS=0` builds host lookup buffers +instead; CPU builds always do and reject `AIUR_TRACE_ONLY_LOOKUPS=1`. +The hardware integration gate exercises both modes and CPU-verifies the proofs. +CPU verification and key export ignore this prover-only setting, so leaving it +exported after GPU proving does not break those commands. CPU proving still +rejects a request for graph-derived device lookups. This separation changes no +circuit constraints, Lean proofs, verifying keys, or proof formats. +The [batch preparation follow-up](formal-aiur-gpu-preparation.md) records the +hardware review and fixes for serial host lookup reconstruction, redundant +trace copying and unnecessary single-shard commitment regeneration. + +`tools/ixvm/adapt.py --check` checks reproducibility against the pinned source +revision. `tools/ixvm/recursion.py --check` and `--aggregate --check` do the same +for recursive programs. `tools/ixvm/audit.py --out DIR` inventories lexical and +semantic adaptations; the audit is not a proof of equivalence to legacy IxVM. +The compiler correctness proofs remain intact. Neither those proofs nor the +port tests constitute a new formal proof of the cryptographic backend or +discharge the existing memo-acyclicity hypothesis of the semantic model. + +The retired legacy native execution crate (`crates/ixvm-legacy-native`), +`legacy-native` Cargo feature, `ix codegen`, and `trace-fixtures` have been +removed along with the legacy backend. + +Function grouping is now enabled in the IxVM and recursive-verifier exports. +The application policies translate legacy's measured groups; missing, inlined, +or already deduplicated members are skipped, and entrypoints stay singleton. +`--ungrouped` disables the policy when exporting either application. The generic +Aiur library accepts an explicit policy and otherwise leaves functions separate. + +The Lean transformation shares data columns and reserves private columns to +silence inactive members. It checks polynomial silence, gates the remaining +constraints and lookup arguments, and preserves degree three, logical call +identities, and all-zero padding. Selector exclusion is valid in arbitrary +fields. The compiler now returns a proof-bearing `Grouping.Checked` layout and +the exporter checks a `Grouping.Plan` covering the entire source system. +`Checked.localRule_iff` proves equivalence of finite grouped rows and original +function rows. It derives selector properties and source memory validity from +the emitted equations and shared lookup words. The raw packet theorems cover +both projection and extension, including tags, widths, enables, unused slots, +and zero padding. `Plan.derives_iff` proves whole-program equivalence, and +`Physical.Prepared.grouped_native_heap_sound` composes grouping with source +evaluation and heap representation. These proofs use no `sorry` or added +axioms. Certification runs only during export. Rust scatters each +function's prepared row directly into the shared layout, including lifted +lookup arguments. Shard planning and auxiliary placement use the grouped shapes. +The Rust lowering and cryptographic backend retain their existing trust boundary. + +The port now preserves legacy's nonrecursive `@`-only helper boundaries through +the existing proved inliner. Byte AND/OR share XOR's fixed table and less-than +uses subtraction's borrow. Fixed-arity word hint closures accelerate legacy +primitive counterparts without adding language primitives. Controlled bytecode +comparisons, including each circuit's columns and FFT cost, are recorded in +[the grouping comparison](formal-aiur-grouping-comparison.md). + +The final codegen phase will use Rust procedural macros, not a generation +script. The macros should live in an optional `aiur-macros` crate, +with their IxVM expansion compiled in a separate optional `ixvm-native` crate. +Neither belongs in the ordinary `aiur` or `ixvm` dependency graph. This change +does not implement the future macro backend or create empty placeholder crates. + +## Migration validation + +Default-backend/controller checks on 2026-10-26: + +- New CLI modules build with `--wfail`; Rust tests and Clippy pass. The compiler + theorem sources are unchanged. The integration gate checks default selection, + the explicit legacy bytecode path, real claims, recursive proofs, all thirteen + aggregation shapes, and wrong-claim/proof/identity/range rejection. +- Two concurrent `Nat.add_comm` environment claims reproduce the prior proof + addresses and sizes, with four trace shards each. Independent partition + verification and `--skip-proven --shards 1` reuse pass. The controller emits + its measured-plan report and a valid refined manifest. +- A 1 GiB total budget with two jobs is rejected before execution: each + 512 MiB reservation is below the estimated artifact/fixed-table floor. + The failure report is written and no refined manifest is emitted. A separate + one-job, 1 GiB execution audit successfully refines the full environment + from one leaf into four fitting parts; the emitted manifest passes coverage + and aggregation-plan checks. No STARK is requested in that audit. +- Real range leaves, joins, and roots were proved for both IxVM proofs using + `--range 2`. Their persisted intermediates were then independently verified + and supplied to `--reprove-slot 2`. The final structural join produced + 20,583,260 proof bytes in sixteen trace shards. Independent aggregate + verification, root-cache replay with no input proofs, and supplied-proof + subtree replay pass; all 342 constants are covered without assumptions. + The root address is + `7cf439d1369a2523d435282d9c6b7496168157c8926fb444bc23841f01b4cf19`. +- The targeted final join took 4m41s and `/usr/bin/time` reported 77.95 GiB peak + RSS for its largest process. This is a controller validation, not a new + performance comparison: the range hierarchy does more recursive work than + the earlier direct join. Its first run exposed a reservation bug at the + final single-job wave; the corrected scheduler gives that wave the full + 128 GiB budget instead of half. +- CUDA linking is covered by the updated CI job. `IX_TEST_CUDA=1` enables CPU + verification of GPU-produced proofs in the integration gate; it passed on + hardware on 2026-10-31 ([GPU validation](formal-aiur-gpu-validation.md)). + +Current-port checks on 2026-10-22: + +- The complete Aiur proof graph builds (2,050 root-workspace build jobs), with + its theorem sources unchanged. The imported proofs still have pre-existing + linter warnings under `--wfail`; the ordinary proof build succeeds. +- All 84 new Rust tests pass; the shared codec refactor also passes 101 legacy + runtime tests (3 ignored) and 6 legacy host tests. New Rust targets pass + Clippy with warnings denied. +- Ten current claim cases pass, including normal-form evaluation and rejection + of an unreduced claimed result. The `.ixe` input path accepts `Nat.add_comm`. +- The recursive verifier accepts a real multi-stark proof and rejects wrong + public digests, truncated proof/key/claim streams, and a corrupted opening. + Its execution is itself proved and independently verified. +- Thirty-two aggregation cases cover all thirteen shapes, including rejected + dropped assumptions, wrong identities/kinds, incorrect range residuals, + incomplete ranges, and malformed child proofs. An aggregate wrap is itself + proved and independently verified (6,263,653 bytes, one trace shard). +- A real two-shard partition of the `Nat.add_comm` environment proves and + independently verifies all 342 constants. Its stage-one proofs contain + 12,207,268 and 14,306,442 bytes, each with four trace shards. A structural + direct join verifies both proofs in Aiur bytecode (23.126 s in this run, + 34,189,789 recorded queries) and produces a verified aggregate of 11,975,716 + bytes across eight trace shards. Its stored address is + `8e261edbcef1fcb3e64505ea68ce7399ba0a98fd1b251ba9676bf87f0a5211d0`. + +`bash tools/ixvm/check-formal.sh` runs the reproducible integration gate: current +claims, CLI persistence/verification, recursive proof round trips and all +aggregation shapes. The full-size aggregation above is a separate local check; +CI uses small real child proofs to keep its memory requirements reasonable. + +For the current `Nat.add_comm` claim, the first CLI proof run measured 28.2 ms +execution, 9.5 ms trace generation and 1.33 s proving, producing an 11,657,213-byte +proof. These are single-run observations, not a controlled comparison with the +legacy backend. The stage-one-only batch population optimization was added +after those measurements. + +### Initial import regression results + +Validated on 2026-10-22 with Lean 4.34.1 and Rust 1.98.1: + +- All 365 Aiur modules build, including compiler soundness/completeness, + provenance, optimization, physical deduplication, and word-library proofs. + The existing theorem statements are retained, with no added axioms or + `sorry`. The package's default target explicitly includes every submodule. +- The full Aiur regression suite, execution/FFI checks, trace checks, U32 tests, + and shared-library tests pass. Trace tests include 202 executions under each + of three compiler configurations and 54 executions over F₂, accepted by + Lean's `checkMemo`. +- `cargo test -p aiur -p ixvm --all-targets --features parallel` passes all + 82 tests. Workspace Clippy with the new parallel and legacy native features + passes with warnings denied. +- `Tests.AiurBoundaries` imports both implementations and elaborates both + surface languages together. Legacy parser categories use a `legacy_aiur_` + prefix because Lean syntax-category names are global. +- The new IxVM accepts all five validation entrypoints and all 342 fixture + serialization cases. Corrupted serialization, a wrong address, missing + advice, and a correctly hashed invalid proof are rejected. +- The fixed `Nat.add_comm` fixture executes, generates a witness, proves, and + verifies through multi-stark. Its exported package SHA-256 matches the + recorded pre-migration digest exactly: + `14cc72161dd26070d290ffd949b10b9225b0792da0a98633827340ca49da1e48`. + +| New IxVM fixture result | Value | +| --- | ---: | +| Function queries | 75,988 | +| Fixed-table queries | 140,137 | +| ROM queries | 21,981 | +| Stage-one columns | 18,222 | +| Stage-one cells | 4,082,430 | +| Execution-record fingerprint | 17083028404579245216 | +| Trace fingerprint | 18300081860579238156 | + +Both fingerprints match the pre-migration results. These checks concern +migration fidelity; they do not establish equivalence to today's legacy IxVM. + +The legacy Rust tests pass (102 tests, 3 ignored), as do six legacy host tests +including the bytecode fallback. The rebuilt legacy Lean execution, cost, +trace-plan, and generated-Rust checks pass. The retained native and bytecode +`Nat.add_comm` runs report matching circuit widths, FFT cost, and cache-hit +counts. Generated execution kernels, Rust trace writers, CUDA units, and +manifests pass their regeneration checks. GPU execution and proving were not +run locally. diff --git a/docs/formal-aiur-modules.md b/docs/formal-aiur-modules.md new file mode 100644 index 000000000..287cb067c --- /dev/null +++ b/docs/formal-aiur-modules.md @@ -0,0 +1,132 @@ +# Formal Aiur program libraries + +The new programs use ordinary Aiur modules and the existing verified module +linker. Shared arithmetic and data structures live in `Aiur/Aiur/Library`; +IxVM and the recursive verifier compose them in their own Lean packages. +There are no new AST operations, native arithmetic primitives, or proof axioms. + +| Library | Interface and implementation | +| --- | --- | +| `U8/Signature.lean`, `U8.lean` | `U8Signature` and its checked `UInt8` fixed-table implementation. Bytes and split parts are opaque. The interface exposes checked constructors and typed literals, not the backing tables. | +| `U32/Signature.lean`, `U32.lean` | `U32Signature` and `UInt32`, with opaque byte-array words and compact words. Advice supplies raw fields; byte lookups and carry equations check them. | +| `U32/Goldilocks.lean` | Explicit field selection, including the proved characteristic bound. The same U32 implementation works over any field whose natural cast is injective below `3 * 2^32`; another large prime does not require copied arithmetic. | +| `U64.lean` | Shared little-endian byte arithmetic and checked conversions, with its separate `2^56` field bound. | +| `List.lean` | Polymorphic lists, length, concatenation, lookup, take/drop, snoc, and reversal. No word-library dependency. | +| `List/Word.lean` | Checked depth and U64-indexed list operations, separated from the generic list library. | +| `Option.lean`, `Bytes.lean` | Shared option layout, byte streams, 32-byte addresses, and structural address equality. | +| `Blake3.lean` | Shared compression, hashing, address conversion, and digest packing. Uses the byte, word, and list libraries. | +| `Field/Goldilocks.lean` | Canonical field encoding, checked inverse advice, and quadratic extension arithmetic with nonresidue 7. This implementation is specifically selected for Goldilocks, unlike the bounded U32 implementation. | + +Signatures check types, opacity, and provider conformance. They do not assert +that an arbitrary provider implements correct integer arithmetic: a replacement +still needs its own arithmetic argument and tests. Existing U32 arithmetic +lemmas remain in `U32/Correctness.lean`. A BN254 application can reuse bounded +word arithmetic after establishing the field bounds; it must choose a suitable +extension field separately instead of reusing the Goldilocks extension blindly. + +Module parameters select providers statically. For example: + +```text +module AddWords { + fn add(a: Field, b: Field) -> Field { + let x = W::from_field(a); + let y = W::from_field(b); + W::compact_field(W::compact(W::add(x, y))) + } +} +module Selected = AddWords::; +``` + +`U32Signature` shares its byte boundary with the selected `UInt8` provider. +The applications use that provider consistently. Hints cannot construct the +opaque types, even through an abstract module parameter. Host hint closures +and table accelerators remain registered in Rust; their channels, table names, +row indices, and constraints are unchanged by this refactor. + +## Applications and source composition + +`IxVM/IxVM/Program.sources` composes the root entrypoints with Ixon types and +serialization, ingress, conversion, address maps, and the kernel subsystems: +limbs, natural primitives, levels, substitution, weak-head reduction, +inference, definitional equality, canonical checks, checking, claims, and +evaluation. Those modules are in `IxVM/IxVM/Modules`. + +`MultiStark/MultiStark/Program.sources` composes proof and system decoding, +transcript, hash adapters, Merkle verification, PCS, and the STARK verifier. +`Aggregate.sources` uses those same files and adds aggregation. There is one +copy of the verifier implementation. The separate root files retain the public +entrypoints `MultiStark::verify_multi_stark_proof` and `MultiStark::ix_aggr`. + +The manifests are ordered lists of relative source paths. `Aiur.SourceBundle` +reads them outside the language frontend; the AST still contains only module +declarations. Both exporters and the CLI artifact cache consume the complete +bundle, so editing a dependency invalidates the cache. Shared Lean libraries +are linked into the exporter and covered by its binary digest. + +`tools/ixvm/adapt.py` and `recursion.py` reproduce the application modules from +the pinned legacy sources and reviewed compatibility adapters. This is port +maintenance tooling, not Rust code generation. `modules.py` changes global +names and extracts shared bodies; it checks inverse renaming and exact helper +bodies. The ordinary frontend then checks every cross-module reference. The +`*.names.json` files map old port names to their new locations, including types +inside monomorphized names. Existing tuned groups use the relocated names. + +## Compatibility checks + +Legacy is the behavioral reference, with the previously reviewed adaptations: +no unconstrained pointer values, explicit raw hint channels, checked byte/word +construction, and structural equality where equality is required. Optional +pointer shortcuts stay removed. These adaptations have not been changed. +The port audit distinguishes lexical translation, semantic adaptations, and +library replacements; it is not a theorem of equivalence to legacy. + +For the modularization itself, `tools/ixvm/check-refactor.py` compares complete +compiled exports against the pre-refactor artifacts. It permits only declared +name changes and no-op removal: empty bytecode guards and trace assignments of +each column to itself. Jump targets and hint instruction offsets are adjusted +for removed guards. All other instructions, enum layouts, fixed-table rows, +constraints, lookup messages, trace actions, and group layouts must match. +Direct `*`/`&` syntax replaces the legacy inline `load`/`store` wrappers, which +accounts for those no-ops disappearing. + +The comparison against `44ea8742` passed for all three applications: + +| Application | Bytecode functions | Function chips after deduplication | Ungrouped function columns, before = after | Tuned groups | Empty guards removed | +| --- | ---: | ---: | ---: | ---: | ---: | +| IxVM | 828 | 778 | 19,675 | 112 | 3,404 | +| Recursive verifier | 224 | 189 | 5,907 | 39 | 390 | +| Aggregation | 285 | 245 | 7,878 | 39 | 528 | + +These column counts cover the function chips, before the host adds memory, +fixed-table, and lookup-protocol columns. Those inputs also compare exactly; +this refactor does not change circuit size or grouping. The checks and artifact +hashes are saved in [the comparison record](benchmarks/formal-aiur-modules/summary.json). +The pinned legacy program sources are unchanged between the pin and that +baseline. Distributed workers recognize both the relocated `check_owned` +callable and the old name used by cached artifacts. + +From the repository root: + +```sh +python3 tools/ixvm/adapt.py --check +python3 tools/ixvm/recursion.py --check +python3 tools/ixvm/audit.py --out .lake/port-audit +lake build ixvm/ixvm multiStark/stark-export aiur/library_tests aiur/u32_tests +lake env Aiur/.lake/build/bin/library_tests .lake/libraries.json +cargo run --release --locked -p aiur --features stark --example library_check -- .lake/libraries.json +tools/ixvm/check-formal.sh +``` + +The library regression also instantiates abstract byte/word clients, rejects +opaque hints and incomplete providers, and checks accelerated execution against +table execution and reference trace generation. The full integration gate +covers valid/invalid IxVM claims, the retained legacy bytecode entrypoint, +recursive proofs, aggregation, and production controllers. + +Validation of this refactor passed 2,586 accelerated/table execution and +reference-trace comparisons, the Lean arithmetic/domain/opacity checks, two +dishonest-hint proof rejections, and U64/Blake3 proofs. Application proof checks, +resident/distributed controllers, and the three-workload CPU proof/key parity +gate passed. The first controller run exposed the renamed worker callable; +the controller gate passed after adding compatibility for both names. CUDA +runtime validation was not repeated on this machine, which has no GPU. diff --git a/docs/formal-aiur-orchestration.md b/docs/formal-aiur-orchestration.md new file mode 100644 index 000000000..fd952db89 --- /dev/null +++ b/docs/formal-aiur-orchestration.md @@ -0,0 +1,187 @@ +# Formal Aiur orchestration + +The certified Formal Aiur backend uses `crates/ix-prover` for resident proving +(the legacy `--legacy` backend has been retired). This governs runtime +scheduling and witness construction; it adds no Aiur primitive, constraint, +axiom, or `sorry`. + +## Commands + +```sh +# Independent manifest claims, two CPU prover lanes and four executions ahead. +ix prove --ixe env.ixe --ixes env.ixes --jobs 2 --exec-jobs 4 \ + --trace-shards --max-ram 64 --report claims.json + +# Prove leaves, schedule recursive joins, verify the root, then publish it. +ix prove --aggregate --ixe env.ixe --ixes env.ixes --jobs 2 --exec-jobs 4 \ + --trace-shards --max-ram 192 \ + --out-ixes completed.ixes --report aggregate.json +ix verify --aggregate --ixe env.ixe --ixes completed.ixes ROOT_ADDRESS + +# The same controller with four resident CUDA lanes, starting at device zero. +# Here RAM and positive execution counts are per GPU. +ix prove --lanes 4 --gpu-device 0 --ixe env.ixe --ixes env.ixes \ + --trace-shards --max-ram 96 --exec-jobs 3 --out-ixes completed.ixes + +# One whole-environment claim across several execution records. +ix prove --distributed --ixe env.ixe --ixes env.ixes --exec-jobs 4 \ + --max-ram 64 --retention regenerate --report distributed.json +ix verify --distributed --ixe env.ixe --ixes env.ixes PROOF_ADDRESS +``` + +`--texray` prints timings/RSS for execution, trace population and proving. +`--direct-joins`, `--structural-above` and `--range` select the same recursive +strategies available to `ix aggregate`. Direct joins can save wrappers but need +more RAM. A very small `--shard-rows`, or a lane budget too small for a +single-shard verifier proof, can make recursive proofs grow rather than +shrink; root wrapping detects this and fails with a diagnostic. + +`--lanes` selects CUDA, while `--aggregate --jobs N` runs the complete pipeline +on CPU. Explicit CUDA requests never select a CPU host silently. Hosts live in +`target/release` and `target/formal-cuda/release` of the checkout `ix` was +built in, with independent overrides `IX_PROVER_HOST` and `IX_PROVER_HOST_CUDA`. +Exporters, sources and the artifact cache (`.lake/aiur`) are also resolved +against that checkout (or `IX_ROOT`), so `ix` runs from any directory. +`ix prepare [--cuda]` builds the hosts and exports the IxVM and aggregation +artifacts ahead of time; otherwise the first command that needs an artifact +exports it (several minutes, once per source revision). Building by hand: + +```sh +cargo build --release --locked -p ix-prover --features parallel +cargo build --release --locked --target-dir target/formal-cuda \ + -p ix-prover --features parallel,cuda +``` + +## Scheduling and memory + +One Rust process checks each artifact once and keeps one prover backend for +each application on each lane. Lean submits dependency-ready jobs through +atomic control files. Execution records stay in Rust memory; they are never +serialized to those files. Ready recursive jobs have queue priority over new +leaves. Workers refill as individual jobs finish, without a wave barrier. + +The `record-pool` crate manages bounded execution-record memory across workers. +Aiur charges record arena, ROM, index, fixed-table count, +frame, and distributed dependency storage growth to reservations. Advice is +charged conservatively before parsing. Reservations follow record storage and +are released when it drops. When executions mutually block on growth, the pool +cancels the youngest and retries it after capacity is released. Completed +records wait in a bounded priority queue. + +After accounting for resident Rust artifacts/backends with a margin, half the +remaining budget goes to record storage and half to a prover workspace shared +by the lanes. Each job reserves its planned peak, normally within its lane's +equal share. Trace generation and proving are planned before allocating traces; +the execution record is dropped before STARK proving. CUDA plans charge host +witnesses and upload staging rather than the commitment phases, which stay on +the device. + +A recursive job that its lane's share would split into more shards may plan +within the whole workspace instead and waits until that much is free +(reservations are granted in request order, so it is not overtaken). On CPU it +also runs on a thread pool spanning every lane, since the others wait. Without +this, each further level of the tree verifies every shard of the level below: +on the 342-constant environment, `--jobs 2 --max-ram 192` used to split wraps +into 8 shards and failed at the root, while it now proves single-shard wraps +and the same root as one lane ([GPU validation](formal-aiur-gpu-validation.md)). +Plans depend only on the budgets, not on timing. Job reports record +`borrowed_workspace` and `workspace_wait_seconds`. The default record ceiling +is 128 GiB, capped by pool capacity; `AIUR_RECORD_MAX_BYTES` overrides it. This is +counted record storage plus a conservative workspace estimate, **not a hard RSS +limit**. Lean's environment/witness buffers, allocator retention and transient +runtime allocations also consume memory. The controller does not clone records. + +With `--report PATH`, resident runs preserve `PATH.events.jsonl`, +`PATH.ready.json` and `PATH.summary.json` alongside the result. They show queue +order, execution/proving phases, lane assignment, effective plans, record peak, +waits and retries. A failed job is drained with its admitted peers before the +controller and temporary advice files are destroyed. + +## Refinement and resume + +The combined pipeline bisects oversized environment leaves down to atomic +blocks. It checkpoints a valid refined partition immediately when a split is +chosen, even if proving its parts or joining them later fails. Checkpoints are +written by atomic rename and identified by the original environment/manifest +contents. They live under `~/.ix/cache/formal-lanes`, or +`$AIUR_LANES_CACHE_DIR/formal`. + +Rerunning loads that partition and independently verifies cached leaf/aggregate +proofs before reuse. A checkpoint records the partition, not a claim that all +parts have proofs. `--out-ixes` is published only after the completed root is +verified. An atomic block or recursive record that cannot fit fails explicitly; +it is never silently omitted. `--no-cache` bypasses aggregate caches and +`--no-index` bypasses the leaf-proof index. + +## Distributed records + +`--distributed` proves one canonical `CheckEnv` claim with no assumptions. Each +nonempty manifest leaf owns its `IxVM::check_owned` calls. Calls owned elsewhere +are deferred only because their result is unit; their circuit lookup demands +remain. The host merges incoming multiplicities into the owning rows. Ordinary +function calls, hints and byte-table accelerators use the existing interpreter. + +Each record allocates ROM addresses in a disjoint interval for every width. +Numeric addresses may still be reused across different widths. The existing +batch verifier checks interval ordering/disjointness and balances memory and +function lookups across all shards. Proof format and verifying keys are unchanged. +`WidthROM.append_valid` proves that valid ROMs with disjoint addresses within +each width compose into a valid ROM. The compiler correctness theorems remain +unchanged; Rust lowering and the cryptographic adapter keep their existing trust +boundary and this is not a new proof of the cryptographic backend. + +A metadata pass executes workers in parallel and keeps their shapes, call +counts and dependency edges. Cached helper calls propagate owned-call +dependencies too, so a cycle cannot hide behind a memoization hit. Missing or +duplicate owners, cycles, overflow and changing replay shapes are rejected. +Proving replays one worker at a time. `regenerate` replays again in round two; +`retain` keeps commitments across all workers if the global estimate fits. +`auto` chooses from that combined estimate. This bounded-storage approach can +execute a worker three times, unlike legacy's caller-ordered commit pipeline; +it is a deliberate implementation tradeoff, not a performance parity claim. + +## Validation (2026-10-29) + +`tools/ixvm/check-controller.py` is the repeatable gate, also called by +`tools/ixvm/check-formal.sh`. It tests two resident CPU lanes with six jobs +(IxVM, recursive verification, aggregation), compares every proof/key byte to +standalone hosts, independently verifies the proofs, checks quota rejection and +reservation release, and compares distributed retain/regenerate proofs. The +distributed fixture has three well-typed constants with dependencies, two +workers, two cross-record calls and one public claim. + +The complete pipeline gate (`--pipeline`) also ran on CPU with two lanes and a +192 GiB budget: direct joins produced a verified single-shard aggregate, and a +second invocation reused the verified root with **no execution events**. These +are integration tests, not a new performance comparison with legacy. + +Initial complete-pipeline gate report: +`.lake/cuda-controls/controller-check-pfh7yywn/report.json`. +The final standard gate is saved under `.lake/orchestration-final`, including +`controller-check-euv1j7t4/report.json`. The forced 25,000,000-byte record test +split a three-block leaf into one and two blocks before failing on an atomic +part; its checkpoint remained valid and no completed manifest was published. +Removing the limit resumed from that partition and reused the independently +verified aggregate root (`.lake/orchestration-check/refinement-resume.json`). +The distributed proof was +`2677e65a118c21bb80cccfa9cb24fa6b814ed755505f1a198f6af51bd9218ae3`; +the aggregate root was +`a42a4374a76943c235938ec698578efcb2a9caced1dc77bf87b5ed3f65bc9691`. + +Rust tests cover pool contention/cancellation, queue priority, reservation +lifetime, cross-record proofs, wrong claims, overlapping ROM intervals, +unresolved calls, cached-helper dependencies, retention planning and replay +failure. Lean tests cover failure draining in the scheduler. The ROM composition +lemma checks in Lean without new axioms or placeholders. +The targeted Rust suite passes 194 tests, with three existing legacy tests +ignored. The standard gate also checks explicit legacy bytecode execution. + +The controller and both application hosts compile/link with CUDA 13.3.1 for +SM 80. The one-device gate passed on hardware on 2026-10-31 +([GPU validation](formal-aiur-gpu-validation.md)); `check-controller.py --devices 0,1` +tests multiple GPU lanes and distributed proving, with independent CPU +verification; add `--pipeline` for complete aggregation. On a single GPU, +`--devices 0,0` runs two lanes on the same device (the test opt-in +`IX_PROVER_SHARED_DEVICES=1`, which `ix prove --lanes N` also honors by placing +every lane on the starting device). `IX_TEST_CUDA=1` +enables the one-device controller gate in `check-formal.sh` as well. diff --git a/docs/formal-aiur-rom-reuse.md b/docs/formal-aiur-rom-reuse.md new file mode 100644 index 000000000..98dfcc2d3 --- /dev/null +++ b/docs/formal-aiur-rom-reuse.md @@ -0,0 +1,147 @@ +# Reusing the execution record's ROM index and width buckets + +Measured 2026-10-28 against `55022874`, following the +[trace phase profile](formal-aiur-trace-profile.md). The optimization removes +the two ROM reconstruction passes identified there. Aiur programs, certified +layouts, grouping, constraints, circuit heights, columns and FFT estimates +are unchanged. + +## Trace results + +Times include main matrices and host lookup buffers. These are medians of five +samples after two warmups, with one reused execution record; the single-thread +control uses seven samples. Both versions use native-CPU release bytecode builds. + +| Workload | Threads | Before | After | Change | +|---|---:|---:|---:|---:| +| Real recursive verifier | 64 | 1,179.04 ms | 815.87 ms | -30.8% | +| Real recursive verifier | 8 | 3,746.71 ms | 3,346.34 ms | -10.7% | +| Self-contained 342-constant environment | 64 | 46.27 ms | 37.52 ms | -18.9% | +| Small `Nat.add_comm` frontier claim | 8 | 4.85 ms | 4.25 ms | -12.4% | +| Environment, single-thread control | 1 | 1,045.23 ms | 1,035.87 ms | -0.9% | + +Small-claim and single-thread sample ranges overlap; their small differences +are not evidence of a reliable speedup. The recursive improvement is clear: +at 64 threads, the before samples range from 1.156 to 1.201 seconds and the +after samples from 0.775 to 0.835 seconds. + +A separate instrumented run confirms the preparation passes are gone: + +| Recursive phase at 64 threads | Before profile | After profile | +|---|---:|---:| +| Validate record and root | 23.12 ms | 23.02 ms | +| Rebuild ROM payload index | 232.56 ms | removed | +| Check/copy auxiliary counts | 24.40 ms | 8.88 ms | +| Repartition ROM rows | 125.74 ms | removed | +| Populate circuits and lookups | 777.29 ms | 781.55 ms | +| Cleanup | 11.57 ms | below 0.01 ms | + +The before profile is from the preceding report; the after profile uses three +samples after two warmups. Population is approximately unchanged: the win +comes from removing preparation work. Circuit spans overlap under Rayon and +must not be interpreted as isolated CPU time. + +A fresh legacy recursive run takes **687.25 ms** at 64 threads. New Aiur is now +**18.7% slower**, down from **71.6% slower** before this change. Legacy's +environment median is 43.63 ms; that smaller workload has substantial sample +variation, saved in the raw data. This change does not establish recursive +parity: row and lookup population remain the main work to investigate. + +Peak process RSS for the 64-thread recursive replay falls from **31.63 GiB to +31.33 GiB**, about **299 MiB less**. Retaining the index extends its lifetime +after execution, but avoids allocating the temporary trace index and ROM row +collections. The RSS measurement includes the entire process and allocator +behavior, not just the record's size. + +## Execution controls + +These runs reexecute the bytecode on every iteration, with two warmups and +three measured recursive samples or seven environment samples. The before +control runs immediately before its after counterpart. Execution is sequential +even though the trace uses the specified Rayon pool. + +| Workload | Trace threads | Execute before | Execute after | Change | +|---|---:|---:|---:|---:| +| Real recursive verifier | 64 | 7.977 s | 7.893 s | -1.0% | +| Environment | 8 | 336.54 ms | 350.29 ms | +4.1% | + +There is still a small execution cost on the environment in this control; +this is a trace optimization, not a claim of universally faster execution. +The environment's trace in these same runs falls from 168.69 to 149.08 ms. +The final single-thread trace control is approximately unchanged. +The median of each sample's execution plus trace falls from 9.173 to 8.719 s +for recursion and from 506.62 to 499.05 ms for the environment. + +An initial implementation accidentally outlined the extracted memory lookup +in both the interpreter and trace writer. The final version explicitly inlines +it, as the query-table lookup already does. It also compares the cached full +hash before accessing a candidate payload, while still requiring exact field +value equality. No hash is treated as a proof of equality. + +## Implementation and invariants + +- `Memory` owns the existing interning `HashTable` instead of `Machine` + discarding it when execution returns. Entries contain cached hashes and + stable record indices; no second payload copy or self-referential pointers + are introduced. The index clones with the record and is not serialized. +- The private `intern` insertion path maintains uniqueness and consecutive + width-local addresses. Execution and trace stores use the same field-value + equality/hash contract, including equal noncanonical native representations. +- ROM witnesses read the existing width buckets, payloads and multiplicities + directly. The copied memory-count array and `Rom::partition` are removed. + The existing type, root, query and multiplicity checks still run. +- The optimized generic and STARK trace writers use the retained store index. + The reference writer deliberately reconstructs its own map for differential + testing. ROM main rows are still written sequentially within each width; + this change does not add another parallel population algorithm. + +## Correctness checks + +All 82 Aiur tests pass both with serial STARK generation and with parallel, +instrumented generation. The added regression exercises retained indices +through growth and cloning, equal-width nominal aliases, zero-width payloads +and payloads that differ only by trailing zeros. ROM tests reconstruct rows +independently from the flat record, including counts and padding. Existing +tests cover native-field equality, reference population, grouped proofs, +sharding, invalid multiplicities and forged ROM providers. + +The real `Nat.add_comm` frontier proof verifies and is **byte-identical** to +the baseline proof (5,478,175 bytes). A full outer proof of the real recursive +workload also verifies (3,168,863 bytes). Proof hashes are in the manifest. +These checks exercise the Rust implementation; no Lean definition, theorem, +certificate or exported circuit was changed. Formatting and Clippy pass, +including the default library build and profiled comparison build. + +## Data and reproduction + +[Summary](benchmarks/formal-aiur-rom-reuse/summary.csv), +[raw samples](benchmarks/formal-aiur-rom-reuse/runs.json), +[circuit shapes](benchmarks/formal-aiur-rom-reuse/circuits.json), and +[manifest](benchmarks/formal-aiur-rom-reuse/manifest.json) include both binaries' +hashes, source and input hashes, memory measurements and all selected controls. +[Phase medians](benchmarks/formal-aiur-rom-reuse/phase-summary.csv) and +[raw phase/circuit spans](benchmarks/formal-aiur-rom-reuse/phases.jsonl) preserve +the separate instrumented run. +All new-Aiur circuit statistics match before/after for each workload, including +the recursive verifier's 937,960,213 padded main cells. + +The host and inputs are the same as the +[scaling report](formal-aiur-trace-scaling.md): 32 cores / 64 logical CPUs, +native CPU code generation for the Rust interpreter, no Aiur program codegen, +fixed affinity, and disabled transparent huge pages. Benchmark processes run +sequentially. Preparation and execution are outside the reused-record trace +timer; every trace call allocates and populates a fresh witness. + +```sh +cargo build --release --locked -p stark-verifier \ + --features parallel --example compare +RAYON_NUM_THREADS=64 IX_BENCH_NO_THP=1 IX_BENCH_REUSE_EXECUTION=1 \ + AIUR_TRACE_ONLY_LOOKUPS=0 taskset -c 0-63 target/release/examples/compare \ + .lake/formal-integration/recursion-tuned.json \ + .lake/formal-comparison/final/new-environment-grouped.json.inner/input.json \ + /tmp/recursion-rom-reuse.json 5 +``` + +Use `IX_BENCH_REUSE_EXECUTION=0` for the execution controls. The baseline binary +was built from `55022874` with the same features and flags. Legacy uses +`bench-compare-aiur recursion INPUT OUTPUT SAMPLES` under the same environment. diff --git a/docs/formal-aiur-trace-profile.md b/docs/formal-aiur-trace-profile.md new file mode 100644 index 000000000..c0803dcc2 --- /dev/null +++ b/docs/formal-aiur-trace-profile.md @@ -0,0 +1,128 @@ +# Why the small claim and recursive verifier behave differently + +Measured 2026-10-28 against `1a19788b`. The source programs and grouped circuits +are unchanged; the only runtime addition is optional phase instrumentation, +compiled out unless `aiur/trace-profile` is enabled. + +The [ROM reuse follow-up](formal-aiur-rom-reuse.md) implements the proposed +optimization and measures the before/after results. This report preserves the +original phase measurements. + +## The remembered Nat.add_comm result is correct + +The small frontier-assumption claim is different from checking its entire +self-contained 342-constant environment. A fresh sweep of the small claim, +with the ordinary uninstrumented binaries, gives: + +| Threads | Legacy trace + lookups (ms) | New Aiur trace + lookups (ms) | +|---:|---:|---:| +| 1 | 12.03 | 19.80 | +| 8 | 12.34 | 4.99 | +| 32 | 13.39 | 4.43 | +| 64 | 15.56 | 5.20 | + +These are five-sample medians after two warmups, using a reused execution +record, CPU affinity, native release builds and disabled transparent huge +pages as in the [scaling comparison](formal-aiur-trace-scaling.md). + +The workloads contain very different amounts of work in new Aiur: + +| Workload | Recorded function queries | Blake3 compression queries | +|---|---:|---:| +| Small `Nat.add_comm` frontier claim | 15,788 | 488 | +| Self-contained environment | 951,532 | 21,280 | +| Real recursive verifier | 11,297,616 | 993,400 | + +Compression accounts for about 38% of the environment's padded main cells and +56% of the recursive verifier's. These are cell proportions, not CPU-time +attributions. Both large workloads use the same inputs as the previous reports. + +## Measured preparation costs at 64 threads + +Three measured traces follow two warmups. The profiler times the actual +production generation path; each invocation creates fresh matrices, lookup +buffers, ROM index and row metadata. + +| New-Aiur phase | Small claim (ms) | Environment (ms) | Recursive verifier (ms) | +|---|---:|---:|---:| +| Validate record and root | 0.48 | 2.84 | 23.12 | +| Rebuild ROM payload → address index | 0.18 | 6.17 | 232.56 | +| Copy/check auxiliary multiplicities | 0.31 | 1.23 | 24.40 | +| Partition ROM entries by width | 0.13 | 5.47 | 125.74 | +| Populate circuits and host lookups | 4.31 | 33.34 | 777.29 | +| Cleanup | 0.01 | 0.01 | 11.57 | +| Total | 5.43 | 48.94 | 1,197.59 | + +Shape checking is below 0.01 ms. The independently computed phase medians need +not sum exactly to the median total. Logging happens after the total is taken. +Per-circuit spans are also recorded, but overlap under Rayon's nested work +stealing; they must not be added or interpreted as isolated CPU time. + +The two ROM reconstruction passes take **358 ms**, roughly **30%** of the +recursive trace. They occur before the parallel population phase, so adding +row workers does not accelerate them. Query validation was a plausible +suspect from code inspection, but its measured 23 ms is not the main issue. + +The implementations explain why this work is redundant: + +- New Aiur's `Memory` already has width buckets, local addresses and stored + multiplicities. `Rom::partition` traverses all entries again, looks up their + types and creates another collection of width buckets. +- `Machine` builds a payload interning `HashTable` during execution, but that + table is not retained in `Execution`. The trace generator reconstructs a + payload-to-address `FxHashMap` from the complete memory record. +- Legacy retains a `QueryMap` for each memory width and directly reads those + maps while producing its ROM rows. It does not need these reconstruction + passes. It also parallelizes ROM row population, whereas new Aiur currently + writes each width's main rows sequentially. + +The concrete next optimization is to consume the existing width buckets and +multiplicities directly, and retain or reuse execution's payload index. This +changes host data handling, not Aiur semantics or circuit constraints. Retaining +the index trades some post-execution memory for avoiding a second index during +trace generation; the effect on peak memory should be measured. + +Removing those passes would not establish parity by itself: parallel +population still takes about 777 ms, compared with legacy's previous measured +631 ms for its entire recursive trace. This profile does not separate that +remaining gap into compression arithmetic, hint replay and lookup emission. + +## Why small claims favor new Aiur on multiple cores + +The small claim pays only about 0.3 ms for the two ROM passes. Its new-Aiur +population phase is instead dominated by the fixed byte-pair table's span +(about 4.1 ms at 64 threads). + +Legacy's `Bytes2::witness_data` constructs lookup messages for all 65,536 byte +pairs with a sequential loop, including the argument computations for unused +operations. New Aiur's auxiliary lookup writer uses parallel batches and skips +argument writes for zero multiplicities. This is a concrete implementation +reason the small claim can favor new Aiur while a huge, compression-heavy +recursive trace does not. The legacy table's exact isolated wall time was not +measured in this profile. + +## Saved data and reproduction + +[Phase summary](benchmarks/formal-aiur-trace-profile/phase-summary.csv), +[raw phase/circuit spans](benchmarks/formal-aiur-trace-profile/phases.jsonl), +[small-claim scaling](benchmarks/formal-aiur-trace-profile/nat-frontier.csv), +[raw small-claim samples](benchmarks/formal-aiur-trace-profile/nat-frontier-runs.json) +and [manifest](benchmarks/formal-aiur-trace-profile/manifest.json) preserve the +measurements. The host reports 32 cores and 64 logical CPUs; the runs use the +same CPU and input configuration as the scaling report. + +```sh +cargo build --release --locked -p stark-verifier \ + --features parallel,aiur/trace-profile --example compare +RAYON_NUM_THREADS=64 IX_BENCH_NO_THP=1 IX_BENCH_REUSE_EXECUTION=1 \ + AIUR_TRACE_ONLY_LOOKUPS=0 taskset -c 0-63 target/release/examples/compare \ + .lake/formal-integration/recursion-tuned.json \ + .lake/formal-comparison/final/new-environment-grouped.json.inner/input.json \ + /tmp/recursion-profile.json 3 2>/tmp/recursion-phases.jsonl +``` + +Each successful generation emits an `aiur_trace_profile` JSON event on stderr. +Discard the first two warmups. Build without `aiur/trace-profile` for ordinary +timings; no timers, synchronization or logging compile into that path. +The instrumented grouped trace/proof test and a real `Nat.add_comm` proof pass; +Clippy also passes with warnings denied. diff --git a/docs/formal-aiur-trace-scaling.md b/docs/formal-aiur-trace-scaling.md new file mode 100644 index 000000000..164d140d8 --- /dev/null +++ b/docs/formal-aiur-trace-scaling.md @@ -0,0 +1,119 @@ +# CPU scaling of trace generation + +Measured 2026-10-28 against `5de73a23`, with the tuned new-Aiur grouping and +legacy's existing grouping. The previous grouping comparison used eight Rayon +threads. It was not a scaling comparison. + +**New Aiur scales better on the IxVM environment, but legacy scales better on +the real recursive verifier.** Legacy remains faster in absolute trace time +on both workloads at every measured thread count. + +The [phase-profile follow-up](formal-aiur-trace-profile.md) also measures the +small `Nat.add_comm` frontier claim, where new Aiur is faster on multiple cores, +and identifies substantial ROM preparation costs in the recursive trace. +The subsequent [ROM reuse optimization](formal-aiur-rom-reuse.md) removes those +passes; the timings and implementation discussion below describe the baseline. + +## Measurements + +All times include main trace generation and host lookup buffers. Each value is +the median of three samples after two warmups. Execution is bytecode on both +backends and is excluded from these timings. + +| Threads | IxVM legacy (ms) | IxVM new (ms) | Recursive legacy (s) | Recursive new (s) | +|---:|---:|---:|---:|---:| +| 1 | 571.59 | 1,063.62 | 16.716 | 25.714 | +| 8 | 82.46 | 159.23 | 2.173 | 3.678 | +| 32 | 46.86 | 56.87 | 0.690 | 1.430 | +| 64 | 42.94 | 50.51 | 0.631 | 1.220 | + +From one to 64 threads: + +- IxVM: **21.1×** speedup for new Aiur, **13.3×** for legacy. Between eight + and 64 threads, new Aiur's time gap shrinks from 93% to 18%. +- Recursive verifier: **21.1×** for new Aiur, **26.5×** for legacy. New Aiur + is still about 1.93 times legacy's elapsed time at 64 threads. + +The host is a KVM machine reporting an Intel Xeon 6975P-C, 32 cores, 64 logical +CPUs and one NUMA node. At up to 32 threads, each worker has a distinct reported +core available; the 64-thread run also uses the SMT siblings. This measures +32 cores with SMT, not 64 physical cores. The session and parent cgroups have +no CPU quota. Processes run sequentially and are pinned to the selected CPUs. + +## Effect of the grouping change at 64 threads + +The earlier 6–8% trace regression referred to the tuned grouping versus the +previous **new-Aiur grouping**, at eight threads. A separate 64-thread check +using the same new interpreter and trace generator gives: + +| Workload | Previous grouping | Tuned grouping | Change | +|---|---:|---:|---:| +| IxVM environment | 46.13 ms | 50.51 ms | +9.5% | +| Real recursive verifier | 1.176 s | 1.220 s | +3.8% | + +The grouping change's smaller matrices and FFT estimates therefore do not +remove its trace-time tradeoff at higher thread counts. These are three-sample +medians, not precise regression estimates; in particular the recursive +before/after sample ranges overlap. Raw minima, maxima and samples are saved. + +## Interpretation + +Both implementations parallelize across circuits and within function circuits. +New Aiur's row iterator uses batches of 32 with worker-local scratch storage. +Legacy's iterator items are individual rows; Rayon also splits and batches +those items internally. Parallel row population is not unique to new Aiur. + +New Aiur still has serial preparation work, including the ROM payload index, +memory multiplicity copying and ROM partitioning. Query validation runs in +parallel across functions but scans each function's rows sequentially. ROM +main rows are populated sequentially within each width, whereas legacy also +parallelizes those rows. These are possible scaling limits visible in the +implementation; this benchmark does not attribute the remaining recursive +runtime to individual phases. + +Better speedup does not establish lower absolute cost: new Aiur starts with +more single-threaded work on both workloads. The IxVM result shows why the +eight-thread comparison should not be extrapolated to larger machines, while +the recursive result shows why the scaling advantage is workload-dependent. + +## Method, data and reproduction + +The workloads are the same self-contained 342-constant IxVM environment and +the same real 7,232,210-byte inner proof as the earlier comparisons. Artifacts, +inputs and binaries are hashed in the +[manifest](benchmarks/formal-aiur-trace-scaling/manifest.json). The +[summary CSV](benchmarks/formal-aiur-trace-scaling/summary.csv) and +[raw samples](benchmarks/formal-aiur-trace-scaling/runs.json) include every run. +Circuit heights, widths and cell counts were checked to be independent of the +thread count for each backend/workload. + +Both binaries use release optimization, `-Ctarget-cpu=native`, the parallel +feature and `IX_BENCH_NO_THP=1`. The sweep uses thread counts in the order +8, 64, 1, 32 and alternates the backend order. Larger legacy-thread samples +have some variability; the saved ranges expose it rather than treating the +medians as exact constants. No proving or GPU timing is included. + +The benchmark harnesses now accept `IX_BENCH_REUSE_EXECUTION=1`: execute once, +retain the immutable query record (and legacy IO buffer), and regenerate the +complete witness on every iteration. No trace matrices, lookup buffers, row +indices or count preparation are cached between trace samples. The initial +execution time is reported separately; repeated execution samples are `null`. +The default benchmark behavior still executes before every trace sample. +Smoke proofs on both backends verify after repeated trace generation and have +the same circuit shapes as ordinary execution. The interpreter, trace +generation implementations and grouping policies were not changed for this +experiment. + +With the existing exported artifacts and inputs: + +```sh +lake build bench-compare-aiur +cargo build --release --locked -p stark-verifier --features parallel --example compare +python3 tools/ixvm/trace-scaling.py .lake/trace-scaling/sweep \ + --ixvm-artifact .lake/formal-integration/ixvm-tuned.json \ + --recursion-artifact .lake/formal-integration/recursion-tuned.json +``` + +Use `--inputs`, `--threads` and `--samples` to select another saved comparison +directory, CPU counts or sample count. The manifest records every invocation, +including the two additional runs with the previous grouping artifacts. diff --git a/docs/kernel.md b/docs/kernel.md index a900b856a..41091d913 100644 --- a/docs/kernel.md +++ b/docs/kernel.md @@ -1059,11 +1059,10 @@ interleaved: `prim-addrs` checks. The suites `prim-addrs` and `primitive-address-parity` and `lake exe ixon-v4-tests --primitives` must pass. -3. **Generated IxVM Rust.** `lake exe ix codegen` regenerates - `crates/ixvm-codegen/src/*.rs` from the IxVM sources and `Ix/IxVM/Kernel/RoleSpec.lean`, the role specifications +3. **Generated IxVM `.aiur`.** `python3 tools/ixvm/adapt.py` regenerates + `IxVM/IxVM/Modules/*.aiur` from `Ix/IxVM/**/*.lean` and `Ix/IxVM/Kernel/RoleSpec.lean`, the role specifications rendered as circuit terms (`Ix/IxVM/RoleSpecGen.lean`), which also - changes with `specVersion` or the specification digest; `lake exe ix - codegen --check` must pass. + changes with `specVersion` or the specification digest; `python3 tools/ixvm/adapt.py --check` must pass. 4. **Fixtures.** `lake exe ixon-v4-tests --export-fixtures --export-handoff` writes `claims.tsv`, `addressed.tsv`, `resource.tsv` and the handoff set to `$IX_IXON_V4_DIR`; copy them into `Tests/Fixtures/ixon-v4/` after @@ -1085,7 +1084,7 @@ interleaved: are the codec's: rewrite them for the new grammar (their `#guard`s run when `lake -d IxC build --wfail` elaborates them). 7. **IxVM costs.** `lake test --wfail -- --ignored ixvm` reports every - kernel-check FFT-cost pin of `Tests/Ix/IxVM.lean` and the shard pin in + kernel-check FFT-cost pin of `Tests/Ix/LegacyIxVM.lean` and the shard pin in `Tests/Main.lean` that moved; set each to the measured value. 8. **Frozen audit records**, as step 3 of a toolchain bump, including the codec's own closure in `IxC/Ixon/Audit.lean`. diff --git a/docs/sharing-minimum-integration.md b/docs/sharing-minimum-integration.md index fbb418fd4..8c92ac340 100644 --- a/docs/sharing-minimum-integration.md +++ b/docs/sharing-minimum-integration.md @@ -62,8 +62,8 @@ Decisions in force (`sharing-minimum.md` §12.8, §12.11–§12.16, §13–§14) does not serialize its output to measure it. 4. **There are three codecs.** Besides Lean (`IxC/Ixon/Codec.lean`, with the metadata and environment codecs in `Ix/Ixon.lean`) and Rust (`crates/ixon`), the IxVM - circuit has its own codec (`Ix/IxVM/IxonDeserialize.lean`, `Ix/IxVM/IxonSerialize.lean`), - generated into `crates/ixvm-codegen/src/aiur_ixvm.rs` by `lake exe ix codegen`. CI runs + circuit has its own codec (`LegacyIxVM/IxonDeserialize.lean`, `LegacyIxVM/IxonSerialize.lean`), + generated into `crates/ixvm-legacy-native/src/aiur_ixvm.rs` by `lake exe ix codegen`. CI runs `lake exe ix codegen --check`. 5. **Metadata does not depend on the primary table's shape.** `ConstantMeta.metaSharing`, which no compiler writes now, is indexed directly, arena roots follow the unshared logical tree, and every consumer expands `Share` transparently. @@ -120,15 +120,15 @@ syntax-blob writer `Ix.CompileM.tagN0Bytes`. and `catalog.rs`. `get_expr` is the only byte-level expression decoder in Rust; the other readers decode expressions through it and skip constants by their length prefix. -**IxVM**: `Ix/IxVM/IxonDeserialize.lean` reads with `get_tagn0`, `get_tagn2` and `get_tagn4`; +**IxVM**: `LegacyIxVM/IxonDeserialize.lean` reads with `get_tagn0`, `get_tagn2` and `get_tagn4`; the one-byte case is one narrow row and the longer encodings share `get_tagn_tail` and -`get_tagn_wide`. `Ix/IxVM/IxonSerialize.lean` writes with `put_tagn0/2/4`, `put_tagn_tail` and +`get_tagn_wide`. `LegacyIxVM/IxonSerialize.lean` writes with `put_tagn0/2/4`, `put_tagn_tail` and `put_tagn_wide`. The circuit rejects what the hosts reject: invalid codes, values reaching -`2^64` and truncation. The claim readers (`run_claim` in `Ix/IxVM/Kernel/Claim.lean`, the +`2^64` and truncation. The claim readers (`run_claim` in `LegacyIxVM/Kernel/Claim.lean`, the aggregator's CheckEnv parser in `Ix/Aggr/Circuit.lean`) require object format 4; Resource (`E8 01`) decodes and is rejected explicitly, and Catalog (`E8 00`) has no arm. The assumption-tree header must be exactly `0xE2`. The circuit reads no `.ixe` header and no -`ConstantMeta`. The generated Rust is `crates/ixvm-codegen/src/aiur_ixvm.rs` and +`ConstantMeta`. The generated Rust is `crates/ixvm-legacy-native/src/aiur_ixvm.rs` and `aiur_ix_aggr.rs`; the suite `ixvm-tagn` holds the circuit codec to `Ixon.putTagN`/`getTagN`. `LazyConstant` header peeks (`Ix/Ixon.lean`, `lazy.rs`) need no change: a non-Muts constant @@ -319,7 +319,7 @@ the claim" ("catalog: …" likewise). The in-circuit claim readers require objec | canonical primitive addresses | `Tests/Fixtures/ixon-v4/primitives.tsv`, `crates/common/src/prim_addrs.rs` (`PrimAddrs::new`), `Ix/PrimAddrs.lean`, the IxVM literals in `Ix/IxVM/Kernel/*.lean` | `lake exe ixon-v4-primitives` (file equality), suites `primitive-address-parity` and `prim-addrs` (IxVM literals) | `lake exe ixon-v4-primitives` | | catalog claim digest | `Tests/Ix/Claim.lean`, `crates/ixon/src/proof.rs` (`catalog_claim_wire_bytes_pinned`) | `claim` suite, `ixon` tests | the serializers' output | | independent expression bytes | `Tests/Fixtures/ixon-v4/expressions.txt` | `ixon-v4-tests`; `ixon` `v4_independent_golden_expressions` | written by hand from the specification (`text.tsv` holds no bytes) | -| IxVM FFT-cost pins | `Tests/Ix/IxVM.lean` (kernel checks), the shard pin in `Tests/Main.lean` | ignored runner `ixvm` | rerun and pin | +| IxVM FFT-cost pins | `Tests/Ix/LegacyIxVM.lean` (kernel checks), the shard pin in `Tests/Main.lean` | ignored runner `ixvm` | rerun and pin | Not regenerated, because their inputs are not available in the development environment: diff --git a/flake.nix b/flake.nix index 6a0fbfeb8..06f55b194 100644 --- a/flake.nix +++ b/flake.nix @@ -220,6 +220,28 @@ # Local packages build in the workspace; buildDeps only supports Git sources. lakeDeps = builtins.removeAttrs (lake2nix.buildDeps { src = leanSrc; + # Formal Aiur's proofs require mathlib, which brings these packages + # into the workspace. Nothing the flake builds (the Ix library, the + # CLI and the test binary) imports them, so Lake needs only their + # sources to resolve the workspace. Building them would compile all + # of Mathlib and its shared library, and lean4-nix's library target + # guess (`Proofwidgets`) does not exist. + depOverride = + pkgs.lib.genAttrs + [ + "mathlib" + "proofwidgets" + "LeanSearchClient" + "importGraph" + "aesop" + "Qq" + ] + (_: { + buildPhase = '' + runHook preBuild + runHook postBuild + ''; + }); depOverrideDeriv = { # Blake3.lean's `rust` package builds only its `Blake3Rust` # library (`Blake3.Rust` and the `Blake3` root). Ix also imports @@ -371,6 +393,10 @@ # with writable copies of all artifacts that Lake may rebuild. cp -rP ${ixTestArtifacts}/.lake src/.lake chmod -R u+w src/.lake + # Mathlib is in the workspace only through formal Aiur and is + # left unbuilt (`lakeDeps`). Mark it present, or the source-mode + # commands try to download its cache (`Ix.fetchMathlibCache`). + mkdir -p src/.lake/packages/mathlib/.lake/build cp ${ixTestArtifacts}/lakefile.lean src/lakefile.lean # The configured lakefile delegates Cargo to Crane; preserve # its prebuilt archive input if a Lake target needs refreshing. diff --git a/lake-manifest.json b/lake-manifest.json index 4954b301e..5912877b2 100644 --- a/lake-manifest.json +++ b/lake-manifest.json @@ -48,6 +48,27 @@ "inputRev": "d8eb3e0d9a8e33fc116e6700df0418a1d8114508", "inherited": false, "configFile": "lakefile.toml"}, + {"type": "path", + "scope": "", + "name": "multiStark", + "manifestFile": "lake-manifest.json", + "inherited": false, + "dir": "MultiStark", + "configFile": "lakefile.lean"}, + {"type": "path", + "scope": "", + "name": "ixvm", + "manifestFile": "lake-manifest.json", + "inherited": false, + "dir": "IxVM", + "configFile": "lakefile.lean"}, + {"type": "path", + "scope": "", + "name": "aiur", + "manifestFile": "lake-manifest.json", + "inherited": false, + "dir": "Aiur", + "configFile": "lakefile.lean"}, {"url": "https://github.com/leanprover-community/plausible", "type": "git", "subDir": null, @@ -57,6 +78,66 @@ "manifestFile": "lake-manifest.json", "inputRev": "v4.34.0", "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/mathlib4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "name": "mathlib", + "manifestFile": "lake-manifest.json", + "inputRev": "v4.34.1", + "inherited": true, + "configFile": "lakefile.lean"}, + {"url": "https://github.com/leanprover-community/LeanSearchClient", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707", + "name": "LeanSearchClient", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/import-graph", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "e928b72544873815af278d38681b31c0293588e3", + "name": "importGraph", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/ProofWidgets4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5", + "name": "proofwidgets", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.lean"}, + {"url": "https://github.com/leanprover-community/aesop", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "355695d523e41d0554926416cba2a2b3544fbbc9", + "name": "aesop", + "manifestFile": "lake-manifest.json", + "inputRev": "master", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/quote4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259", + "name": "Qq", + "manifestFile": "lake-manifest.json", + "inputRev": "master", + "inherited": true, "configFile": "lakefile.toml"}], "name": "ix", "lakeDir": ".lake", diff --git a/lakefile.lean b/lakefile.lean index 058bf29fd..f2ebc3fb7 100644 --- a/lakefile.lean +++ b/lakefile.lean @@ -11,6 +11,10 @@ package ix where moreLinkArgs := if System.Platform.isLinux then #["-Wl,--allow-shlib-undefined", "-Wl,-rpath,$ORIGIN/../lib"] else #[] +require aiur from "Aiur" +require ixvm from "IxVM" +require multiStark from "MultiStark" + require LSpec from git "https://github.com/argumentcomputer/LSpec" @ "d8eb3e0d9a8e33fc116e6700df0418a1d8114508" @@ -175,9 +179,6 @@ target ix_rs_net pkg : FilePath := do end FFI -lean_lib MultiStark where - moreLinkObjs := #[ix_rs] - /-- `lake -R -Kprofile build` compiles with frame pointers, so `perf` can unwind call graphs through generated C (LBR and DWARF unwinding are unavailable on the benchmark machines). The default build is unaffected. -/ @@ -213,6 +214,14 @@ are installed unchecked on purpose). -/ lean_lib EntryCaseFixtures where roots := #[`Tests.Ix.Kernel.EntryCaseDefs] +lean_exe «formal-aiur-tests» where + root := `Tests.FormalAiur + supportInterpreter := true + +lean_exe «formal-aggregate-tests» where + root := `Tests.FormalAggregate + supportInterpreter := true + @[test_driver] lean_exe IxTests where root := `Tests.Main @@ -231,13 +240,6 @@ 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 @@ -277,45 +279,6 @@ lean_exe «sharing-family-normalize» where lean_exe «sharing-scratch» where root := `Benchmarks.SharingScratch -lean_exe «bench-aiur» where - root := `Benchmarks.Aiur - -lean_exe «bench-blake3» where - root := `Benchmarks.Blake3 - -lean_exe «bench-sha256» where - root := `Benchmarks.Sha256 - -lean_exe «bench-ixvm» where - root := `Benchmarks.IxVM - supportInterpreter := true - -lean_exe «bench-typecheck» where - root := `Benchmarks.Typecheck - supportInterpreter := true - -/-- Generic execution profiles for full-closure proving workloads. -/ -lean_exe «proving-profile» where - root := `Scripts.Performance.ProvingProfile - moreLinkObjs := #[ix_rs] - -/-- Validate and compare circuit partitions against measured query heights. -/ -lean_exe «function-grouping» where - root := `Scripts.Performance.FunctionGrouping - moreLinkObjs := #[ix_rs] - -lean_exe «bench-recursion-debug» where - root := `Benchmarks.RecursionDebug - supportInterpreter := true - -lean_exe «bench-aggregate-policy» where - root := `Benchmarks.AggregatePolicy - supportInterpreter := true - -- Keep ix_ffi ahead of Blake3's Rust staticlib. Importing the converged - -- aggregator makes both archives direct dependencies; Rust allocator - -- symbols are then resolved from ix_ffi and not pulled twice. - moreLinkObjs := #[ix_rs] - lean_exe «bench-compile-init» where root := `Benchmarks.CompileInit @@ -417,9 +380,9 @@ def moduleExclusions : Array ModuleExclusion := #[ `IxSharingVerify/` (a globbed library, built by `lake lint`) are covered by their own targets; `Models/` and every directory with its own lakefile are other workspaces. -/ -def coveredDirs : Array FilePath := #["Ix", "Tests", "Benchmarks", "Apps", "MultiStark"] +def coveredDirs : Array FilePath := #["Ix", "Tests", "Benchmarks", "Apps"] def coveredRootFiles : Array FilePath := - #["Ix.lean", "Main.lean", "Tests.lean", "Apps.lean", "MultiStark.lean"] + #["Ix.lean", "Main.lean", "Tests.lean", "Apps.lean"] /-- Whether `dir` is a nested Lake workspace (it has its own lakefile). -/ def isNestedWorkspace (dir : FilePath) : IO Bool := do @@ -561,6 +524,13 @@ runs it too, with the lint arguments. -/ script "check-modules" (args) := do return ← checkModules ("--wfail" :: args) +/-- Check the `IxTests` registry against CI workflows and required entries. -/ +script "check-ixtests-registry" := do + let child ← IO.Process.spawn { + cmd := ".lake/build/bin/IxTests", args := #["ixtests-registry"] + stdout := .inherit, stderr := .inherit } + return ← child.wait + end Scripts section IxSharingVerify diff --git a/tools/bench/profile.rs b/tools/bench/profile.rs new file mode 100644 index 000000000..809622f8f --- /dev/null +++ b/tools/bench/profile.rs @@ -0,0 +1,79 @@ +//! Optional Linux userspace CPU sampling for the two benchmark harnesses. +//! Set AIUR_CPU_PROFILE to an output directory and preload libprofiler.so.0. +//! Each guard covers execution alone; setup, warmups, counts, and record drops +//! stay outside the profile. No profiler dependency is linked into the runtime. +use std::{error::Error, ffi::CString, path::PathBuf}; + +type Start = unsafe extern "C" fn(*const std::ffi::c_char) -> std::ffi::c_int; +type Stop = unsafe extern "C" fn(); + +pub struct Profiler { + directory: PathBuf, + start: Start, + stop: Stop, +} + +pub struct Guard<'a>(&'a Profiler); + +impl Profiler { + pub fn from_env() -> Result, Box> { + let Some(directory) = std::env::var_os("AIUR_CPU_PROFILE") else { + return Ok(None); + }; + #[cfg(not(target_os = "linux"))] + { + let _ = directory; + Err("CPU profiling is supported on Linux only".into()) + } + #[cfg(target_os = "linux")] + { + #[link(name = "dl")] + unsafe extern "C" { + fn dlsym( + handle: *mut std::ffi::c_void, + symbol: *const std::ffi::c_char, + ) -> *mut std::ffi::c_void; + } + // RTLD_DEFAULT resolves symbols from the preloaded profiler. Its + // documented C API has these signatures and remains loaded for + // the process lifetime. Fail instead of profiling the wrong scope. + let (start, stop) = unsafe { + let start = dlsym(std::ptr::null_mut(), c"ProfilerStart".as_ptr()); + let stop = dlsym(std::ptr::null_mut(), c"ProfilerStop".as_ptr()); + if start.is_null() || stop.is_null() { + return Err( + "preload libprofiler.so.0 to enable AIUR_CPU_PROFILE".into(), + ); + } + ( + std::mem::transmute::<*mut std::ffi::c_void, Start>(start), + std::mem::transmute::<*mut std::ffi::c_void, Stop>(stop), + ) + }; + let directory = PathBuf::from(directory); + std::fs::create_dir_all(&directory)?; + Ok(Some(Self { directory, start, stop })) + } + } + + pub fn start( + &self, + engine: &str, + sample: usize, + ) -> Result, Box> { + let path = self.directory.join(format!("{engine}-{sample:03}.prof")); + let name = CString::new(path.to_str().ok_or("profile path is not UTF-8")?)?; + if unsafe { (self.start)(name.as_ptr()) } == 0 { + return Err( + format!("failed to start CPU profile at {}", path.display()).into(), + ); + } + Ok(Guard(self)) + } +} + +impl Drop for Guard<'_> { + fn drop(&mut self) { + unsafe { (self.0.stop)() } + } +} diff --git a/tools/ixvm/adapt.py b/tools/ixvm/adapt.py new file mode 100644 index 000000000..fbf093fc6 --- /dev/null +++ b/tools/ixvm/adapt.py @@ -0,0 +1,670 @@ +#!/usr/bin/env python3 +"""Reproduce the stage-one source port from a pinned revision of Ix. + +Only lexical syntax translation is automatic. The semantic replacements are +explicit below and in Compatibility.aiur; no unconstrained pointer values enter +this program. The retained function set is the ordinary static call closure. +""" +from pathlib import Path +import argparse +import re +import subprocess + +ROOT = Path(__file__).resolve().parents[2] +LIBRARY_REVISION = '827550579ea660a4749c520968ad6f58be63acf4' +REVISION = '3d725c8c0accf8b71ae9ac6f70ccc83a4df225e5' +FILES = ['Core', 'ByteStream', 'Blake3', 'RBTreeMap', 'Ixon', 'IxonSerialize', + 'IxonDeserialize', 'KernelTypes', 'Kernel/Klimbs', 'Kernel/NatPrim', + 'Convert', 'Ingress', 'Kernel/Levels', 'Kernel/Subst', + 'Kernel/RoleSpec', 'Kernel/Roles', 'Kernel/Whnf', + 'Kernel/InferOnly', 'Kernel/DefEq', 'Kernel/Infer', + 'Kernel/Check', 'Kernel/Claim', 'Kernel/Eval'] +ROOTS = ['verify_claim', 'verify_constant', 'verify_transitive', 'verify_serde', + 'verify_check_env', 'check_primitives', 'check_port_cases'] + +CANON_ADDR_CMP_HELPERS = ''' + fn canon_ord_cmp_g(a: G, b: G) -> G { + match a - b { + 0 => 1, + _ => + match u32_less_than(a, b) { + 1 => 0, + 0 => 2, + }, + } + } + + fn canon_ord_then(a: G, b: G) -> G { + match a { + 1 => b, + _ => a, + } + } + + fn canon_addr_cmp(x: Addr, y: Addr) -> G { + let xa = load(x); + let ya = load(y); + canon_ord_then(canon_addr_chunk(to_field(xa[0]), to_field(xa[1]), to_field(xa[2]), to_field(xa[3]), + to_field(ya[0]), to_field(ya[1]), to_field(ya[2]), to_field(ya[3])), + canon_ord_then(canon_addr_chunk(to_field(xa[4]), to_field(xa[5]), to_field(xa[6]), to_field(xa[7]), + to_field(ya[4]), to_field(ya[5]), to_field(ya[6]), to_field(ya[7])), + canon_ord_then(canon_addr_chunk(to_field(xa[8]), to_field(xa[9]), to_field(xa[10]), to_field(xa[11]), + to_field(ya[8]), to_field(ya[9]), to_field(ya[10]), to_field(ya[11])), + canon_ord_then(canon_addr_chunk(to_field(xa[12]), to_field(xa[13]), to_field(xa[14]), to_field(xa[15]), + to_field(ya[12]), to_field(ya[13]), to_field(ya[14]), to_field(ya[15])), + canon_ord_then(canon_addr_chunk(to_field(xa[16]), to_field(xa[17]), to_field(xa[18]), to_field(xa[19]), + to_field(ya[16]), to_field(ya[17]), to_field(ya[18]), to_field(ya[19])), + canon_ord_then(canon_addr_chunk(to_field(xa[20]), to_field(xa[21]), to_field(xa[22]), to_field(xa[23]), + to_field(ya[20]), to_field(ya[21]), to_field(ya[22]), to_field(ya[23])), + canon_ord_then(canon_addr_chunk(to_field(xa[24]), to_field(xa[25]), to_field(xa[26]), to_field(xa[27]), + to_field(ya[24]), to_field(ya[25]), to_field(ya[26]), to_field(ya[27])), + canon_addr_chunk(to_field(xa[28]), to_field(xa[29]), to_field(xa[30]), to_field(xa[31]), + to_field(ya[28]), to_field(ya[29]), to_field(ya[30]), to_field(ya[31]))))))))) + } + + fn canon_addr_chunk(x0: G, x1: G, x2: G, x3: G, + y0: G, y1: G, y2: G, y3: G) -> G { + let xv = x0 * 16777216 + x1 * 65536 + x2 * 256 + x3; + let yv = y0 * 16777216 + y1 * 65536 + y2 * 256 + y3; + canon_ord_cmp_g(xv, yv) + } +''' + +ROLE_MAP_HELPERS = ''' + enum RoleMap‹V› { + Nil, + Node(G, G, V, &RoleMap‹V›, &RoleMap‹V›) + } + + fn role_map_lookup_or_default‹V›(key: G, tree: RoleMap‹V›, default: V) -> V { + match tree { + RoleMap.Nil => default, + RoleMap.Node(_, k, v, left, right) => + let eq = key - k; + match eq { + 0 => v, + _ => + match u32_less_than(key, k) { + 1 => role_map_lookup_or_default(key, load(left), default), + _ => role_map_lookup_or_default(key, load(right), default), + }, + }, + } + } + + fn role_ctx_limit(rc: RoleCtx) -> G { + match load(rc) { + RoleCtxNode.Assumed(_, _) => 0, + RoleCtxNode.Mk(_, limit, _) => limit, + } + } +''' + + +def source_ref(name): + if name in ('Core', 'ByteStream', 'Blake3'): + return f'{LIBRARY_REVISION}:LegacyAiur/Library/{name}.lean' + return f'{REVISION}:Ix/IxVM/{name}.lean' + + +# Shared implementations live in Aiur/Library, rather than in the generated VM. +LIBRARY_FUNCTIONS = { + 'to_field': 'UInt8::to_field', 'u8_from_field_unsafe': 'UInt8::from_field', + 'u8_bit_decomposition': 'UInt8::bit_decomposition', 'u8_range_check': 'UInt8::from_fields', + **{'u8_' + op: 'UInt8::' + op for op in + ['xor', 'and', 'or', 'less_than', 'add', 'sub', 'mul', 'xor_split4', 'xor_split7']}, + **{'u32_' + op: 'UInt32::' + op for op in + ['add', 'add3', 'xor', 'and', 'rotr8', 'rotr16', 'xor_rotr7', 'xor_rotr12']}, + 'u32_less_than': 'UInt32::less_than_fields', + 'memo_u32_less_than': 'UInt32::less_than_fields', + **{'u64_' + op: 'UInt64::' + op for op in + ['is_zero', 'eq', 'add', 'sub_with_borrow', 'mul', 'mul_column', 'and', 'or']}, + 'u64_xor_kbits': 'UInt64::xor', 'relaxed_u64_succ': 'UInt64::wrapping_succ', + 'relaxed_u64_pred': 'UInt64::saturating_pred', 'flatten_u64': 'UInt64::to_field', + 'idx_to_u64': 'UInt64::from_field', + 'blake3': 'Blake3::hash', 'verify_bytes_against': 'Blake3::verify_bytes_against', + 'bytes_to_addr': 'Blake3::bytes_to_addr', 'bytes_to_block': 'Blake3::bytes_to_block', + 'pad_block': 'Blake3::pad_block', + **{'blake3_' + op: 'Blake3::' + op for op in + ['next_layer', 'compress_layer', 'compress_chunks', 'finish', 'compress_block', + 'g_function', 'compress_inner_j', 'compress_init', 'compress', 'digest_bytes']}, + 'address_fields': 'Blake3::address_to_fields', 'checked_address': 'Blake3::address_from_fields', + 'list_is_empty': 'Lists::is_empty', 'eq_zero': 'Fields::is_zero', +} + +# Ix uses @ at every retained call site of these helpers. Match those boundaries +# with Aiur's proved declaration-level inlining. Their inline dependencies are +# acyclic; recursive calls through retained functions remain ordinary calls. +# General mixed inline/ordinary call-site selection is not part of this adapter. +INLINE_HELPERS = { + 'blake3_g_function', + 'blake3_compress_inner_j', 'blake3_compress_init', 'blake3', + 'get_constant_info', 'get_sharing', 'get_refs', 'get_univs', + 'k_infer_only_core', 'try_string_lit_pair', 'is_nat_prim_addr', + 'try_nat_dispatch', 'ctx_reachable', 'whnf_core', 'whnf_nd_core', + 'build_flat_originals', 'primary_parent_block_of', + 'infer_let_var_type', 'infer_let_var_value', 'get_recursor_rule', + 'ctor_parent_ind_ci', 'build_major_args_for_self', + 'build_major_args_for_member', 'canon_build_ctx', 'canon_sort_members', + 'u64_mul_column', +} + + +def uncomments(s): + # Preserve string contents, including comment-like text in diagnostics. + out, i, depth = [], 0, 0 + while i < len(s): + if s[i] == '"': + j = i + 1 + while j < len(s): + if s[j] == '\\': j += 2 + elif s[j] == '"': j += 1; break + else: j += 1 + out.append(s[i:j]); i = j + elif s.startswith('--', i) or s.startswith('//', i): + j = s.find('\n', i) + if j == -1: break + out.append('\n'); i = j + 1 + elif s.startswith('/-', i): + depth = 1; i += 2 + while depth: + if s.startswith('/-', i): depth += 1; i += 2 + elif s.startswith('-/', i): depth -= 1; i += 2 + else: + if s[i] == '\n': out.append('\n') + i += 1 + else: out.append(s[i]); i += 1 + return ''.join(out) + + +def strings(s): + saved = [] + def hide(m): + saved.append(m[0]); return f'"STRING_{len(saved)-1}"' + return re.sub(r'"(?:[^"\\]|\\.)*"', hide, s), saved + + +def balance_end(s, pos, opening='{', closing='}'): + depth = 1; i = pos + 1 + while depth: + if s[i] == opening: depth += 1 + elif s[i] == closing: depth -= 1 + i += 1 + return i + + +def replace_body(s, name, body): + m = re.search(r'\bfn ' + name + r'\b[^{}]*\{', s) + if not m: raise ValueError(f'missing override {name}') + begin = m.end()-1; end = balance_end(s, begin) + return s[:begin] + '{\n' + body + '\n }' + s[end:] + + +def transform_body(s, name, transform): + m = re.search(r'\bfn ' + name + r'\b[^{}]*\{', s) + if not m: raise ValueError(f'missing body {name}') + begin = m.end()-1; end = balance_end(s, begin) + return s[:begin] + transform(s[begin:end]) + s[end:] + + +def inline_only_helpers(source): + """Match legacy's @-only call boundaries using ordinary proved inlining. + + No helper reached through ordinary or unconstrained calls is selected. + Reject cycles conservatively, including cycles through retained helpers. + This translates source annotations, not native execution code. + """ + hidden, _ = strings(uncomments(source)) + bodies = {} + for match in re.finditer(r'\bfn (\w+)\b[^{}]*\{', hidden): + bodies[match[1]] = hidden[match.end():balance_end(hidden, match.end() - 1) - 1] + calls = {name: re.findall(r'([@#]?)(\b[a-z_]\w*)\s*(?:‹[^›]*›)?\(', body) + for name, body in bodies.items()} + uses = {name: set() for name in bodies} + for sites in calls.values(): + for prefix, callee in sites: + if callee in uses: + uses[callee].add(prefix) + + def cyclic(name): + seen, todo = set(), [callee for _, callee in calls[name]] + while todo: + callee = todo.pop() + if callee == name: + return True + if callee not in seen: + seen.add(callee) + todo.extend(child for _, child in calls.get(callee, [])) + return False + + return {name for name in bodies if uses[name] == {'@'} and not cyclic(name)} + + +def use_opaque_words(s): + # Word values stay opaque throughout the hash state, digests and ROM. + # Remove the old implementations rather than retaining byte-array adapters + # at every arithmetic call. The library owns all word operations. + operations = ['add', 'add3', 'xor', 'and', 'rotr8', 'rotr16', + 'xor_rotr7', 'xor_rotr12'] + for operation in operations: + name = 'u32_' + operation + m = re.search(r'\bfn ' + name + r'\b[^{}]*\{', s) + if not m: raise ValueError(f'missing word operation {name}') + s = s[:m.start()] + s[balance_end(s, m.end()-1):] + s = re.sub(r'[@#]?\b' + name + r'\(', f'UInt32::{operation}(', s) + s = re.sub(r'\[U8;\s*4\]', 'U32', s) + + # Known bytes become words once, at initialization or block decoding. + byte = r'(?:0x[0-9a-fA-F]+|\d+)u8' + word = r'\[\s*' + byte + (r'\s*,\s*' + byte) * 3 + r'\s*\]' + for name in ['blake3', 'blake3_next_layer', 'blake3_compress_block']: + s = transform_body(s, name, lambda body: + re.sub(word, lambda m: f'UInt32::from_bytes({m[0]})', body)) + s = transform_body(s, 'bytes_to_block', lambda body: + re.sub(r'\[b\d+, b\d+, b\d+, b\d+\]', + lambda m: f'UInt32::from_bytes({m[0]})', body)) + s = transform_body(s, 'blake3_compress_init', lambda body: + re.sub(r'(let (?:IV[0-3]|counter_low|counter_high|block_len_u32|flags_u32) = )([^;]+);', + r'\1UInt32::from_bytes(\2);', body)) + s = transform_body(s, 'blake3_finish', lambda body: + body.replace('[[0u8; 4]; 16]', '[UInt32::ZERO; 16]')) + s = replace_body(s, 'b3_pack_w', ' UInt32::compact_field(UInt32::compact(w))') + + # Only the content-address boundary exposes a digest as 32 bytes. + for name in ['verify_bytes_against', 'bytes_to_addr']: + s = transform_body(s, name, lambda body: + re.sub(r'\[(?:h\[\d\]\[\d\],?\s*)+\]', 'blake3_digest_bytes(h)', body)) + return s + + +def remove_fast_path(s, name, equal_result='1'): + m = re.search(r'\bfn ' + name + r'\b[^{}]*\{', s) + if not m: raise ValueError(f'missing pointer fast path function {name}') + start = m.end()-1; end = balance_end(s, start) + body = s[start:end] + # Keep the existing fallback. Replacing the cheap identity test with a + # recursive structural comparison would add a traversal before that work. + match = re.search(r'match ptr_val\([^)]*\) - ptr_val\([^)]*\) \{\s*0 => ' + + re.escape(equal_result) + r',\s*_ =>', body) + if not match: raise ValueError(f'changed pointer fast path in {name}') + opening = body.index('{', match.start()) + close = balance_end(body, opening) + fallback = body[match.end():close-1].strip().removesuffix(',') + body = body[:match.start()] + fallback + body[close:] + return s[:start] + body + s[end:] + + +def wrap_arms(s): + # Old Aiur permits a sequence directly after =>. New Aiur has ordinary + # expression arms, so retain the entire sequence as an explicit block. + inserts = [] + for m in re.finditer(r'=>', s): + i = m.end(); j = i; depth = 0 + while j < len(s): + c = s[j] + if c in '([{‹': depth += 1 + elif c in ')]}›': + if depth == 0: break + depth -= 1 + elif c == ',' and depth == 0: break + j += 1 + inserts += [(i, ' { '), (j, ' } ')] + for pos, text in sorted(inserts, reverse=True): s = s[:pos] + text + s[pos:] + return s + + +def adapt(s, semantic=True): + INLINE_HELPERS.update(inline_only_helpers(s)) + s, saved = strings(uncomments(s)) + if semantic: + s = s.replace('read_checked_byte_stream(', 'read_finite_byte_stream(') + s = s.replace('#read_byte_stream_unchecked(', '#read_byte_stream(') + # Disambiguate role-indexed maps (key: Field in 0..102) from address-keyed RBTreeMap. + s = s.replace('RBTreeMap‹Addr›', 'RoleMap‹Addr›') + s = s.replace('RBTreeMap‹List‹RoleEvidence››', 'RoleMap‹List‹RoleEvidence››') + for name in ['read_role_bindings', 'read_role_evidence']: + s = transform_body(s, name, lambda body: + body.replace('RBTreeMap.Nil', 'RoleMap.Nil') + .replace('RBTreeMap.Node(', 'RoleMap.Node(')) + s = s.replace('rbtree_map_lookup_or_default(r, by_role,', + 'role_map_lookup_or_default(r, by_role,') + s = s.replace('rbtree_map_lookup_or_default(r, evidence,', + 'role_map_lookup_or_default(r, evidence,') + s = s.replace('rbtree_map_lookup_or_default(ptr_val(a),', + 'rbtree_map_lookup_or_default(a,') + s = s.replace('rbtree_map_insert(ptr_val(a),', + 'rbtree_map_insert(a,') + s = s.replace( + 'let half = to_field(u8_shift_right(u8_from_field_unsafe(count)));', + 'let [b0, _, _, _, _, _, _, _] = UInt8::raw_bit_decomposition(count);\n' + ' let half = (count - b0) / 2;') + s = transform_body(s, 'load_role_table', lambda body: + body.replace('assert_eq!(t0, 0xE8u8,', 'assert_eq!(to_field(t0), 0xE8,') + .replace('assert_eq!(t1, 0x03u8,', 'assert_eq!(to_field(t1), 0x03,')) + s = transform_body(s, 'read_evidence_entries', lambda body: + body.replace('match tag {', 'match to_field(tag) {')) + s = transform_body(s, 'env_walk_refs_all', lambda body: + body.replace('match ptr_val(wc) - ptr_val(rc) {', + 'match role_ctx_limit(wc) - role_ctx_limit(rc) {')) + # Address-set keys are values, never prover-chosen ROM addresses. + # Preserve the balanced tree and compare all 32 address bytes. + s = s.replace('Node(G, G, V, &RBTreeMap', 'Node(G, Addr, V, &RBTreeMap') + for name in ['rbtree_map_balance', 'rbtree_map_balance_fix', 'rbtree_map_ins', + 'rbtree_map_insert', 'rbtree_map_lookup', 'rbtree_map_lookup_or_default']: + s = re.sub(r'(fn ' + name + r'‹V›\([^{}]*?)key: G', r'\1key: Addr', s) + s = transform_body(s, name, lambda body: + body.replace('u32_less_than(key, k)', 'eq_zero(canon_addr_cmp(key, k))') + .replace('let eq = key - k;', 'let eq = canon_addr_cmp(key, k) - 1;')) + s = s.replace('rbtree_map_insert(ptr_val(a), 1, acc)', 'rbtree_map_insert(a, 1, acc)') + s = s.replace('rbtree_map_lookup_or_default(ptr_val(a), tree, 0)', + 'rbtree_map_lookup_or_default(a, tree, 0)') + s = transform_body(s, 'run_claim', lambda body: + body.replace('io_get_info(0, digest)', + 'hint::<(G, G)>("ixvm.io.claim", digest)') + .replace('match variant {', 'match to_field(variant) {')) + s = transform_body(s, 'parse_atree_body', lambda body: + body.replace('match tag {', 'match to_field(tag) {')) + # Opaque words expose equality through their public, checked interface. + # Comparing the packed field for a u64 would lose information modulo p. + s = transform_body(s, 'load_assumption_tree', lambda body: + body.replace('assert_eq!(tag, 0xE2u8,', 'assert_eq!(to_field(tag), 0xE2,') + .replace('assert_eq!(computed_arr, raw,', + 'assert_eq!(address_fields(computed_arr), address_fields(raw),')) + s = transform_body(s, 'check_opt_u64', lambda body: + body.replace('assert_eq!(real, claimed,', 'assert_eq!(u64_eq(real, claimed), 1,')) + for name, first in [('check_opt_addr', 'real'), ('check_opt_expr_addr', 'computed')]: + s = transform_body(s, name, lambda body, first=first: + body.replace(f'assert_eq!(load({first}), load(claimed),', + f'assert_eq!(address_eq({first}, claimed), 1,')) + s = transform_body(s, 'check_recr_rules', lambda body: + body.replace('assert_eq!(c_idx, pos,', 'assert_eq!(u64_eq(c_idx, pos), 1,') + .replace('assert_eq!(r_fields, c_fields,', 'assert_eq!(u64_eq(r_fields, c_fields), 1,')) + for name, byte in [('get_opt_addr', 'tag'), ('get_opt_def_kind_masked', 'b'), + ('get_opt_def_safety_masked', 'b'), ('get_opt_quot_kind_masked', 'b'), + ('get_reveal_mut_const_info', 'variant'), ('get_reveal_info', 'variant')]: + s = transform_body(s, name, lambda body, byte=byte: + body.replace(f'match {byte} {{', f'match to_field({byte}) {{')) + s = transform_body(s, 'run_claim', lambda body: + re.sub(r'assert_eq!\((format|validator), (\d+)u8,', + r'assert_eq!(to_field(\1), \2,', body)) + s = transform_body(s, 'eval_output', lambda body: + body.replace('assert_eq!(output_type, input_type,', + 'assert_eq!(kexpr_struct_eq(output_type, input_type), 1,')) + s = transform_body(s, 'run_eval', lambda body: + body.replace('assert_eq!(result, expected,', + 'assert_eq!(kexpr_struct_eq(result, expected), 1,')) + for name, result in { + 'level_struct_eq': '1', + 'kexpr_struct_eq': '1', + 'k_is_def_eq': '1', + 'k_is_def_eq_slow_nd': '1', + 'k_is_def_eq_slow_nd_after_core': '1', + 'k_is_def_eq_slow2': '1', + 'k_is_def_eq_struct_bounded': '(1, credit)', + 'k_is_def_eq_struct_spend': '(1, rest)', + 'slow2_eager_fallback': '1', + 'lazy_delta_loop': '(1, a, b)', + 'assert_type_meets': '()', + }.items(): + s = remove_fast_path(s, name, result) + # Without the identity shortcut, equal variables must be decided before + # the inference tiers. Canonical recursor rules compare open bodies under + # an empty context deliberately: their stored binder types are untrusted. + s, count = re.subn( + r'(fn k_is_def_eq_struct_safe\([^{}]+\{\s*match load\(a\) \{)', + r'''\1 + KExprNode.BVar(i) => + match load(b) { + KExprNode.BVar(j) => eq_zero(i - j), + _ => 0, + },''', s) + if count != 1: raise ValueError('changed quick structural comparison') + # Extend the existing spine congruence to variable heads as well. These + # occur in the same context-free recursor bodies; recurse on the arguments + # directly, rather than adding a separate whole-tree equality precheck. + const_head = 'KExprNode.Const(a_addr, al) =>' + if s.count(const_head) != 1: raise ValueError('changed application congruence') + s = s.replace(const_head, '''KExprNode.BVar(i) => + match load(bh) { + KExprNode.BVar(j) => + match i - j { + 0 => de_args(rc, aa, bb, types), + _ => 0, + }, + _ => 0, + }, + ''' + const_head) + s = replace_body(s, 'k_is_def_eq_core', ' k_is_def_eq_ordered(rc, a, b, types)') + # Canonical recursor rules compare open bodies under an empty context. + # Entering a higher-order induction hypothesis (e.g. Acc.rec) pushes + # open binder types whose loose range reaches past the partial context. + s = replace_body(s, 'ctx_close_cut', ''' match l { + 0 => 0, + _ => + match load(rest) { + ListNode.Nil => 0, + ListNode.Cons(_, _) => + let c = ctx_next_cut(rest); + match u32_less_than(c, l) { + 0 => c, + 1 => c + ctx_close_cut(list_drop(rest, c), l - c), + }, + }, + }''') + # This identity test is a progress guard, not an equality shortcut: Nat + # literals always expand to Const/App, while Str literals stay unchanged. + # Inspect the literal tag instead of traversing the two expression trees. + s, count = re.subn( + r'let a_ctor = nat_lit_to_ctor_or_self\(rc, a\);\s*' + r'match ptr_val\(a_ctor\) - ptr_val\(a\) \{\s*0 => 0,\s*' + r'_ => k_is_def_eq_struct_go\(rc, a_ctor, b, types\),\s*\}', + '''match la { + KLiteral.Nat(_) => + k_is_def_eq_struct_go(rc, nat_lit_to_ctor_or_self(rc, a), b, types), + KLiteral.Str(_) => 0, + }''', s) + if count != 1: raise ValueError('changed literal-expansion progress guard') + # Address equality selects a semantic case or enforces a type assertion; + # it is not an optional early return. Keep these comparisons by contents. + def compare_addresses(m): + if not all(name.endswith('_addr') for name in (m[1], m[2])): + raise ValueError(f'unreviewed pointer comparison: {m[0]}') + return f'(1 - address_eq({m[1]}, {m[2]}))' + s = re.sub(r'ptr_val\((\w+)\) - ptr_val\((\w+)\)', compare_addresses, s) + s = re.sub(r'assert_eq!\(ptr_val\((\w+)\), ptr_val\((\w+)\),', + r'assert_eq!(address_eq(\1, \2), 1,', s) + # Pointer-containing values cannot use assert_eq!. Nil is a refutable + # pattern; arbitrary limb equality uses the existing structural comparator. + s = re.sub(r'assert_eq!\(load\((\w+)\), ListNode\.Nil(?:,\s*"STRING_\d+")?\)', + r'let ListNode.Nil = load(\1)', s) + s = s.replace('assert_eq!(lhs, rhs,', 'assert_eq!(klimbs_eq(lhs, rhs), 1,') + s = replace_body(s, 'load_constant_hint', ' hint::("ixvm.io.tag", (3, address_fields(load(addr))))') + # The old quotient hint contains pointers. Ordinary long division replaces + # it; Compatibility.aiur supplies it using checked limb arithmetic. + s = s.replace('unconstrained_big_uint_div_mod(a, b)', 'ordinary_div_mod(a, b)') + s = replace_body(s, 'read_byte_stream', ''' + match len { + 0 => store(ListNode.Nil), + _ => let byte = hint::("ixvm.io.read", (channel, idx)); + let tail = read_byte_stream(channel, idx + 1, len - 1); + store(ListNode.Cons(UInt8::from_field(byte), tail)), + }''') + for name in ['u64_is_zero', 'blake3_finish']: + s = transform_body(s, name, lambda body: + body.replace('[0, 0, 0, 0, 0, 0, 0, 0]', '[0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]')) + for name in ['relaxed_u64_succ', 'relaxed_u64_pred']: + s = transform_body(s, name, lambda body: + re.sub(r'match (b[0-7]) \{', r'match to_field(\1) {', body)) + for name, byte in [('unpack_def_kind_safety', 'byte'), ('get_quot_kind', 'byte'), + ('get_mut_const', 'tag'), ('klimbs_succ', 'carry'), + ('klimbs_mul_single', 'carry_out')]: + s = transform_body(s, name, lambda body, byte=byte: + body.replace(f'match {byte} {{', f'match to_field({byte}) {{')) + s = transform_body(s, 'verify_bytes_against', lambda body: + body.replace('assert_eq!(', 'assert_eq!(address_fields(') + .replace('],\n expected,', ']),\n address_fields(expected),')) + s = transform_body(s, 'u64_mul', lambda body: + body.replace('assert_eq!(c6[2], 0u8,', 'assert_eq!(to_field(c6[2]), 0,')) + # Recomposition of advice stays constrained, but its arithmetic need not + # run in Rust. Keep hint/range calls and all semantic validation checks. + # idx_to_u64 deliberately keeps its flatten_u64 query (ordinary call). + for name in ['u64_mul_column', 'klimbs_from_g', 'idx_to_u64']: + s = transform_body(s, name, lambda body: + body.replace('assert_eq!(', 'constrain_eq!(')) + # Ordinary division already returns checked limbs, unlike the old raw + # quotient/remainder hint. Its output must not be reinterpreted as fields. + s = transform_body(s, 'klimbs_div_mod', lambda body: + body.replace('glimbs_to_klimbs(q_hint)', 'q_hint') + .replace('glimbs_to_klimbs(r_hint)', 'r_hint')) + s = use_opaque_words(s) + s = re.sub(r'\bset\((\w+), (\d+), ([^()]+?)\)', r'(\1 with { [\2] = \3 })', s) + s = wrap_arms(s) + s = s.replace('‹', '<').replace('›', '>') + s = re.sub(r'\b([A-Z]\w*)\.(\w+)', r'\1::\2', s) + s = re.sub(r'\bG\b', 'Field', s) + s = re.sub(r'\b(0x[0-9a-fA-F]+|\d+)u8\b', + lambda m: f'UInt32::BYTE_{int(m[1], 16 if m[1].startswith("0x") else 10)}', s) + s = re.sub(r'\b0x[0-9a-fA-F]+\b', lambda m: str(int(m[0], 16)), s) + s = re.sub(r'([#@])(?=[a-zA-Z_]\w*\()', '', s) + s = re.sub(r'\bpub fn\b', 'fn', s) + s = re.sub(r'\bfn (\w+)', lambda m: ('inline ' if m[1] in INLINE_HELPERS else '') + m[0], s) + # Alias declarations in old Aiur are newline-terminated. + s = re.sub(r'(^[ \t]*type [^\n]+)(?=\n)', lambda m: m[0].rstrip().rstrip(';') + ';', s, flags=re.M) + # All new function signatures state the unit return type explicitly. + s = re.sub(r'\bfn [^{}]+\{', lambda m: m[0] if '->' in m[0] else m[0][:-1].rstrip() + ' -> () {', s) + for i, text in enumerate(saved): s = s.replace(f'"STRING_{i}"', text) + return re.sub(r'\n\s*\n\s*\n+', '\n\n', s) + + +def use_raw_byte_operations(s): + # When the next operation already checks both raw operands, use its map + # directly instead of first calling the checked byte constructor. Keep + # standalone constructors: hinted/serialized bytes need them. + replacements = { + 'put_tagn_tail': [ + ('UInt8::add(v[0], UInt8::from_field(256 - 2 * h))', + 'UInt8::raw_add(UInt8::to_field(v[0]), 256 - 2 * h)'), + ], + 'get_tagn_tail': [ + ('UInt8::less_than(UInt8::from_field(q), UInt8::from_field(h))', + 'UInt8::raw_lt(q, h)'), + ('UInt8::add(lo, UInt8::from_field(2 * h))', + 'UInt8::raw_add(UInt8::to_field(lo), 2 * h)'), + ], + 'klimbs_from_g': [ + (f'UInt8::xor(UInt8::from_field(rb{i}), UInt8::BYTE_0)', + f'UInt8::from_field(rb{i})') for i in range(4) + ], + 'utf8_encode_prepend': [ + (f'UInt8::xor(UInt8::from_field(g{i}), UInt8::BYTE_0)', + f'UInt8::from_field(g{i})') for i in range(4) + ], + } + for name, changes in replacements.items(): + def rewrite(body): + for before, after in changes: + if body.count(before) != 1: + raise ValueError(f'changed byte operation in {name}: {before}') + body = body.replace(before, after) + return body + s = transform_body(s, name, rewrite) + return s + + +def prune(s, roots, module='IxVM', raw_bytes=True): + # Keep the original call boundaries for shared non-inline functions. + # In particular, raw byte conversion is a checked lookup in UInt8. + for name in LIBRARY_FUNCTIONS: + m = re.search(r'\b(?:inline )?fn ' + name + r'\b[^{}]*\{', s) + if m: + s = s[:m.start()] + s[balance_end(s, m.end()-1):] + for name, target in LIBRARY_FUNCTIONS.items(): + s = re.sub(r'(?]*>)?\()', target, s) + for name in ['ListNode', 'LayerNode', 'MaybeDigest']: + m = re.search(r'\benum ' + name + r'\b[^{}]*\{', s) + if m: + s = s[:m.start()] + s[balance_end(s, m.end()-1):] + s = re.sub(r'\btype Layer = [^;]+;', 'type Layer = Blake3::Layer;', s) + s = s.replace('type List = &ListNode;', 'type List = Lists::List;') + s = s.replace('type U64 = [U8; 8];', 'type U64 = UInt64::U64;') + s = s.replace('ListNode::', 'Lists::Node::') + s = s.replace('LayerNode::', 'Blake3::LayerNode::').replace('MaybeDigest::', 'Blake3::MaybeDigest::') + s = s.replace('UInt32::U8', 'UInt8::U8').replace('UInt32::BYTE_', 'UInt8::BYTE_') + if raw_bytes: + s = use_raw_byte_operations(s) + # Identify top-level definitions, ignoring braces in diagnostic strings. + hidden, saved = strings(s) + functions = {}; types = [] + for m in re.finditer(r'(?m)^\s*(?:inline )?(fn|enum|type|table|map) (\w+)', hidden): + kind, name = m[1], m[2] + if kind in ('type', 'map'): + end = m.end(); depth = 0 + while end < len(hidden): + if hidden[end] in '([': depth += 1 + elif hidden[end] in ')]': depth -= 1 + elif hidden[end] == ';' and depth <= 0: break + end += 1 + end += 1 + else: + begin = hidden.index('{', m.end()); end = balance_end(hidden, begin) + body = hidden[m.start():end] + if kind == 'fn': functions[name] = body + else: types.append(body) + reachable = set(); todo = list(roots) + while todo: + name = todo.pop() + if name in reachable: continue + if name not in functions: continue + reachable.add(name) + todo += re.findall(r'\b(\w+)\s*(?:::<[^>]*>)?\(', functions[name]) + out = f'module {module} {{\n' + '\n'.join(types + [body for name, body in functions.items() if name in reachable]) + '\n}\n' + for i, text in enumerate(saved): out = out.replace(f'"STRING_{i}"', text) + return out, reachable + + +def source(ix=ROOT): + import modules + parts = [] + owned = [] + for name in FILES: + ref = source_ref(name) + text = subprocess.check_output(['git', '-C', str(ix), 'show', ref], text=True) + part = text.split('⟦', 1)[1].split('⟧', 1)[0] + if name == 'RBTreeMap': + part += CANON_ADDR_CMP_HELPERS + elif name == 'Kernel/Roles': + part += ROLE_MAP_HELPERS + parts.append(part) + component = {'Core': 'IxCore', 'ByteStream': 'IxByteStream', + 'Blake3': 'IxHash'}.get(name, name.replace('/', '')) + owned.append((component, part)) + source = adapt('\n'.join(parts)) + source += (ROOT / 'IxVM/IxVM/Compatibility.aiur').read_text() + source += (ROOT / 'IxVM/IxVM/PortCases.aiur').read_text() + output, names = prune(source, ROOTS) + output = ('// Generated by tools/ixvm/adapt.py; local adapters are in Compatibility.aiur.\n' + '// Shared byte, word, list and hash implementations are in Aiur/Library.\n' + output) + output = '\n'.join(line.rstrip() for line in output.splitlines()) + '\n' + return output, names, modules.origins(owned) + + +def main(): + import modules + parser = argparse.ArgumentParser() + parser.add_argument('--ix', type=Path, default=ROOT) + parser.add_argument('--check', action='store_true', help='check generated source without writing') + args = parser.parse_args() + output, names, owners = source(args.ix) + modules.check_shared(output) + groups, renames = modules.partition(output, owners, 'IxVM', ROOTS) + modules.emit(ROOT / 'IxVM/IxVM', groups, 'IxVM', 'Program', renames, args.check) + calls = set(re.findall(r'(? deadline: + raise TimeoutError(f'waiting for {path}') + time.sleep(0.02) + return json.loads(path.read_text()) + + def resident(name, config, jobs, statuses): + directory = out / name + directory.mkdir() + config_path = directory / 'config.json' + config_path.write_text(json.dumps(config)) + with (directory / 'host.log').open('w') as stream: + child = subprocess.Popen([str(binary), 'serve', str(config_path), str(directory)], + env=env, stdout=stream, stderr=subprocess.STDOUT) + try: + wait_file(directory / 'ready.json', child) + for job in jobs: + path = directory / 'pending' / (job['id'] + '.tmp') + path.write_text(json.dumps(job)) + path.rename(path.with_suffix('.json')) + for job, expected in zip(jobs, statuses): + result = wait_file(directory / 'done' / (job['id'] + '.json'), child) + assert result['status'] == expected, result + report['resident_jobs'].append(dict(id=job['id'], **result)) + finally: + (directory / 'stop').touch() + try: + child.wait(timeout=120) + except subprocess.TimeoutExpired: + child.kill() + child.wait() + raise + assert child.returncode == 0, directory + summary = json.loads((directory / 'summary.json').read_text()) + assert summary['record_reserved_bytes'] == 0, summary + report[name] = summary + save() + return directory + + def product_files(path, ixvm): + return (path, Path(str(path) + '.vk')) if ixvm else (path / 'proof.bin', path / 'key.bin') + + try: + cases = json.loads((fixtures / 'claims.json').read_text()) + claim = next(c['invocation'] for c in cases if c['accept'] and + c['label'] == 'CheckEnv frontier-asm (Nat.add_comm)') + invocation = out / 'claim.json' + invocation.write_text(json.dumps(claim)) + inputs = [invocation, fixtures / 'inner/input.json', fixtures / 'aggregation.json.wrap.json'] + jobs, references = [], [] + for i, (artifact, source) in enumerate(zip(artifacts, inputs)): + ixvm = i == 0 + host = cpu / ('ixvm-proof' if ixvm else 'stark-verifier') + plan = out / f'plan-{i}' + run(f'plan-{i}', [host, 'plan', artifact, source, plan, 0, 'regenerate']) + plan_path = Path(str(plan) + '.report.json') if ixvm else plan / 'report.json' + rows = json.loads(plan_path.read_text())['plan']['max_rows'] // 2 + assert rows > 0 + reference = out / f'reference-{i}' + run(f'reference-{i}', [host, 'prove', artifact, source, reference, rows, 'regenerate']) + references.append(product_files(reference, ixvm)) + for copy in range(2): + jobs.append(dict(id=f'case-{i}-{copy}', artifact=str(artifact), input=str(source), + output=str(out / f'proof-{i}-{copy}'), priority=i != 0, + options=dict(max_rows=rows, retention='regenerate'))) + config = dict(artifacts=[dict(path=str(p), kind='ixvm' if i == 0 else 'recursion') + for i, p in enumerate(artifacts)], + devices=devices, exec_jobs=2, threads_per_prover=4, + max_ram_bytes=8 << 30, texray=True) + directory = resident('resident', config, jobs, [0] * len(jobs)) + assert '[texray]' in (directory / 'host.log').read_text(), 'texray emitted no phases' + for job in jobs: + i = int(job['id'].split('-')[1]) + proof, key = product_files(Path(job['output']), i == 0) + assert proof.read_bytes() == references[i][0].read_bytes(), job['id'] + assert key.read_bytes() == references[i][1].read_bytes(), job['id'] + host = cpu / ('ixvm-proof' if i == 0 else 'stark-verifier') + run(job['id'] + '-verify', [host, 'verify', artifacts[i], inputs[i], proof], + dict(AIUR_TRACE_ONLY_LOOKUPS='1')) + limited = dict(jobs[0], id='limited', output=str(out / 'limited-proof')) + resident('record-limit', dict(config, record_limit_bytes=1024), [limited], [75]) + assert not Path(limited['output']).exists() + + # A real dependency-bearing IxVM environment, with all worker records + # contributing to one public claim rather than independent leaf claims. + tiny = fixtures / 'claims.json.controller.ixe' + if not tiny.exists(): + raise RuntimeError('regenerate formal-aiur-tests fixtures: missing controller environment') + ix = Path('.lake/build/bin/ix').resolve() + manifest = out / 'two.ixes' + run('partition', [ix, 'shard', tiny, '--shards', 2, '--out', manifest]) + proof_addresses = [] + for retention in ['retain', 'regenerate']: + result_path = out / f'distributed-{retention}.json' + command = [ix, 'prove', '--distributed', '--ixe', tiny, '--ixes', manifest, + '--exec-jobs', 2, '--max-ram', 8, '--retention', retention, + '--no-index', '--report', result_path] + if args.devices: + command += ['--gpu-device', devices[0]] + text = run('distributed-' + retention, command) + address = text.strip().splitlines()[-1] + proof_addresses.append(address) + result = json.loads(result_path.read_text()) + assert result['verified'] and result['cross_record_calls'] > 0 + assert len(result['workers']) == 2 and result['shards'] >= 2 + run('distributed-verify-' + retention, + [ix, 'verify', '--distributed', '--ixe', tiny, '--ixes', manifest, address], + dict(AIUR_TRACE_ONLY_LOOKUPS='1')) + assert proof_addresses[0] == proof_addresses[1], 'retention changed distributed proof' + report['distributed_proof'] = proof_addresses[0] + run('reject-leaf-binding', [ix, 'verify', '--ixe', tiny, '--ixes', manifest, + proof_addresses[0]], succeeds=False) + failed_manifest = out / 'failed.ixes' + failed_report = out / 'failed-pipeline.json' + text = run('pipeline-budget-failure', + [ix, 'prove', '--aggregate', '--direct-joins', '--no-cache', '--no-index', + '--ixe', tiny, '--ixes', manifest, '--trace-shards', '--jobs', 2, + '--exec-jobs', 2, '--max-ram', 8, '--report', failed_report, + '--out-ixes', failed_manifest], + dict(AIUR_RECORD_MAX_BYTES='1024', AIUR_LANES_CACHE_DIR=str(out / 'failed-checkpoints')), + succeeds=False) + assert 'no such process' not in text and 'prover stopped' not in text + assert not failed_manifest.exists(), 'failed run published a completed manifest' + failed_summary = json.loads(Path(str(failed_report) + '.summary.json').read_text()) + assert failed_summary['record_reserved_bytes'] == 0 + if args.pipeline: + command = [ix, 'prove', '--aggregate', '--direct-joins', '--ixe', tiny, + '--ixes', manifest, '--trace-shards', '--shard-rows', 4194304, + '--max-ram', args.pipeline_ram_gib, '--exec-jobs', 2, + '--report', out / 'pipeline.json', '--out-ixes', out / 'final.ixes'] + if args.devices: + # CLI --lanes chooses consecutive devices, so reject a hole. + assert devices == list(range(devices[0], devices[0] + len(devices))) + command += ['--lanes', len(devices), '--gpu-device', devices[0]] + else: + command += ['--jobs', 2] + text = run('pipeline', command, dict(AIUR_LANES_CACHE_DIR=str(out / 'checkpoints'))) + address = text.strip().splitlines()[-1] + run('pipeline-verify', [ix, 'verify', '--aggregate', '--ixe', tiny, + '--ixes', out / 'final.ixes', address]) + text = run('pipeline-resume', command, dict(AIUR_LANES_CACHE_DIR=str(out / 'checkpoints'))) + assert text.strip().splitlines()[-1] == address + events = (out / 'pipeline.json.events.jsonl').read_text() + assert not events.strip(), 'cached root triggered execution' + report['pipeline_proof'] = address + report['success'] = True + print(f'Controller validation passed: {out / "report.json"}', flush=True) + finally: + save() + + +if __name__ == '__main__': + main() diff --git a/tools/ixvm/check-cuda.py b/tools/ixvm/check-cuda.py new file mode 100755 index 000000000..c6ca97bf9 --- /dev/null +++ b/tools/ixvm/check-cuda.py @@ -0,0 +1,213 @@ +#!/usr/bin/env python3 +"""Check grouped, sharded CPU/CUDA proofs using check-formal.sh fixtures. + +The default requires a real CUDA device. --cpu-only exercises the CPU controls +without claiming hardware validation. Every run preserves its logs and report. +""" +import argparse +import hashlib +import json +import os +from pathlib import Path +import shutil +import subprocess +import tempfile +import time + + +def digest(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def files(product, ixvm): + if ixvm: + return product, Path(f'{product}.vk'), Path(f'{product}.report.json') + return product / 'proof.bin', product / 'key.bin', product / 'report.json' + + +def main(): + cli = argparse.ArgumentParser(description=__doc__) + cli.add_argument('fixtures', type=Path) + cli.add_argument('--ixvm-artifact', type=Path, required=True) + cli.add_argument('--recursion-artifact', type=Path, required=True) + cli.add_argument('--aggregate-artifact', type=Path, required=True) + cli.add_argument('--cpu-dir', type=Path, default=Path('target/release')) + cli.add_argument('--cuda-dir', type=Path, default=Path('target/formal-cuda/release')) + cli.add_argument('--device', type=int, default=os.getenv('MULTI_STARK_CUDA_DEVICE', '0')) + cli.add_argument('--cpu-only', action='store_true') + args = cli.parse_args() + if not 0 <= args.device < 2**31: + cli.error('device must be a nonnegative CUDA device index fitting i32') + args.fixtures = args.fixtures.resolve() + out = Path(tempfile.mkdtemp(prefix='cuda-check-', dir=args.fixtures)) + report = dict(success=False, hardware_validated=False, cpu_only=args.cpu_only, + device=args.device, cuda_visible_devices=os.getenv('CUDA_VISIBLE_DEVICES'), + revision=subprocess.check_output(['git', 'rev-parse', 'HEAD'], text=True).strip(), + binary_sha256={}, artifact_sha256={}, input_sha256={}, commands=[], cases=[]) + print(f'CUDA validation logs and report: {out}', flush=True) + + def save(): + (out / 'report.json').write_text(json.dumps(report, indent=2) + '\n') + + def run(name, command, env, succeeds=True): + command = [str(x) for x in command] + log = out / f'{len(report["commands"]):02}-{name}.log' + print(name, flush=True) + start = time.monotonic() + with log.open('w') as stream: + result = subprocess.run(command, env=env, stdout=stream, stderr=subprocess.STDOUT) + report['commands'].append(dict(name=name, command=command, log=log.name, + seconds=time.monotonic() - start, exit_code=result.returncode, + expected_success=succeeds, + trace_only_lookups=env['AIUR_TRACE_ONLY_LOOKUPS'])) + save() + if (result.returncode == 0) != succeeds: + raise RuntimeError(f'{name}: unexpected exit {result.returncode}; see {log}') + + try: + cpu_env = dict(os.environ, IX_CUDA='0', AIUR_TRACE_ONLY_LOOKUPS='0') + verify_env = dict(cpu_env, AIUR_TRACE_ONLY_LOOKUPS='1') + gpu_env = dict(cpu_env, IX_CUDA='1', MULTI_STARK_CUDA_DEVICE=str(args.device)) + for directory in [args.cpu_dir] + ([] if args.cpu_only else [args.cuda_dir]): + for name in ['ixvm-proof', 'stark-verifier']: + binary = directory / name + report['binary_sha256'][str(binary)] = digest(binary) + if not args.cpu_only and shutil.which('nvidia-smi'): + run('nvidia-smi', ['nvidia-smi'], gpu_env) + + claims = json.loads((args.fixtures / 'claims.json').read_text()) + claim = next(c['invocation'] for c in claims + if c['accept'] and c['label'] == 'CheckEnv frontier-asm (Nat.add_comm)') + claim_path = out / 'claim.json' + claim_path.write_text(json.dumps(claim) + '\n') + cases = [ + ('ixvm', args.ixvm_artifact, claim_path, True), + ('recursion', args.recursion_artifact, args.fixtures / 'inner/input.json', False), + ('aggregate', args.aggregate_artifact, args.fixtures / 'aggregation.json.wrap.json', False), + ] + for name, artifact, invocation, ixvm in cases: + report['artifact_sha256'][str(artifact)] = digest(artifact) + report['input_sha256'][str(invocation)] = digest(invocation) + binary_name = 'ixvm-proof' if ixvm else 'stark-verifier' + cpu = args.cpu_dir / binary_name + cuda = args.cuda_dir / binary_name + directory = out / name + directory.mkdir() + + # Derive a two-shard fixture from the actual record, instead of + # picking a row cap that might silently leave a one-shard test. + plan = directory / 'plan' + run(f'{name}-plan', [cpu, 'plan', artifact, invocation, plan, '0', 'regenerate'], cpu_env) + planning = json.loads(files(plan, ixvm)[2].read_text())['plan'] + if not planning['fits'] or planning['max_rows'] < 2: + raise RuntimeError(f'{name}: fixture cannot exercise trace sharding') + rows = planning['max_rows'] // 2 + case = dict(name=name, max_rows=rows, proofs=[], single_shard_proofs=[]) + report['cases'].append(case) + + variants = [('cpu-retain', cpu, cpu_env, 'retain', None), + ('cpu-regenerate', cpu, cpu_env, 'regenerate', None)] + if not args.cpu_only: + variants += [('cuda-host-retain', cuda, gpu_env, 'retain', args.device), + ('cuda-host-regenerate', cuda, gpu_env, 'regenerate', args.device), + ('cuda-graph-regenerate', cuda, + dict(gpu_env, AIUR_TRACE_ONLY_LOOKUPS='1'), 'regenerate', args.device), + # Rows the GPU can populate are generated on the device. + ('cuda-gputrace-regenerate', cuda, + dict(gpu_env, AIUR_TRACE_ONLY_LOOKUPS='1', AIUR_GPU_TRACE='generated'), + 'regenerate', args.device)] + reference = None + for variant, binary, env, retention, device in variants: + target = directory / variant + target.mkdir() + product = target / 'proof' + options = target / 'options.json' + options.write_text(json.dumps(dict(max_rows=rows, retention=retention, device=device))) + run(f'{name}-{variant}', [binary, 'prove', artifact, invocation, product, + rows, retention, options], env) + proof, key, proof_report = files(product, ixvm) + result = json.loads(proof_report.read_text()) + if not result['verified'] or result['shards'] < 2: + raise RuntimeError(f'{name}-{variant}: proof did not verify across multiple shards') + # Deliberately inherit the GPU lookup flag in the CPU verifier. + run(f'{name}-{variant}-verify', [cpu, 'verify', artifact, invocation, proof], verify_env) + identity = (proof.read_bytes(), key.read_bytes()) + if reference is None: + reference = identity + exported = directory / 'cpu-key' + run(f'{name}-cpu-key', [cpu, 'key', artifact, exported], verify_env) + if (exported / 'key.bin').read_bytes() != identity[1]: + raise RuntimeError(f'{name}: exported key differs from proving key') + wrong = json.loads(invocation.read_text()) + wrong['args'][0] = int(wrong['args'][0] == 0) + wrong_path = directory / 'wrong-public.json' + wrong_path.write_text(json.dumps(wrong)) + run(f'{name}-reject-wrong-public', [cpu, 'verify', artifact, wrong_path, proof], + verify_env, succeeds=False) + # A CPU host must not silently honor an explicit GPU request. + invalid = directory / 'cpu-device.json' + invalid.write_text(json.dumps(dict(device=args.device))) + run(f'{name}-reject-cpu-device', [cpu, 'plan', artifact, invocation, + directory / 'invalid', rows, 'auto', invalid], + cpu_env, succeeds=False) + elif identity != reference: + raise RuntimeError(f'{name}-{variant}: CPU/CUDA or retention proof/key bytes differ') + case['proofs'].append(dict(variant=variant, proof_sha256=digest(proof), + key_sha256=digest(key), shards=result['shards'], + proof_bytes=result['proof_bytes'])) + save() + + # Graph-derived lookups must also work when the only stage-one + # commitment is retained. This avoids an entire extra upload/LDE/ + # Merkle pass without increasing peak device residency. + single_rows = planning['max_rows'] + single_variants = [('cpu-single-retain', cpu, cpu_env, 'retain', None)] + if not args.cpu_only: + single_variants += [ + ('cuda-graph-single-retain', cuda, + dict(gpu_env, AIUR_TRACE_ONLY_LOOKUPS='1'), 'retain', args.device), + ('cuda-graph-single-regenerate', cuda, + dict(gpu_env, AIUR_TRACE_ONLY_LOOKUPS='1'), 'regenerate', args.device), + ('cuda-gputrace-single-retain', cuda, + dict(gpu_env, AIUR_TRACE_ONLY_LOOKUPS='1', AIUR_GPU_TRACE='generated'), + 'retain', args.device), + ] + single_reference = None + for variant, binary, env, retention, device in single_variants: + target = directory / variant + target.mkdir() + product = target / 'proof' + options = target / 'options.json' + options.write_text(json.dumps(dict(max_rows=single_rows, + retention=retention, device=device))) + run(f'{name}-{variant}', [binary, 'prove', artifact, invocation, product, + single_rows, retention, options], env) + proof, key, proof_report = files(product, ixvm) + result = json.loads(proof_report.read_text()) + if (not result['verified'] or result['shards'] != 1 + or result['plan']['retention'] != retention): + raise RuntimeError(f'{name}-{variant}: single-shard retention was not honored') + run(f'{name}-{variant}-verify', [cpu, 'verify', artifact, invocation, proof], verify_env) + identity = (proof.read_bytes(), key.read_bytes()) + if identity[1] != reference[1]: + raise RuntimeError(f'{name}-{variant}: sharding changed the key') + if single_reference is None: + single_reference = identity + elif identity != single_reference: + raise RuntimeError(f'{name}-{variant}: single-shard CPU/CUDA proof bytes differ') + case['single_shard_proofs'].append(dict(variant=variant, + proof_sha256=digest(proof), key_sha256=digest(key), shards=result['shards'], + retention=result['plan']['retention'], proof_bytes=result['proof_bytes'])) + save() + report['success'] = True + report['hardware_validated'] = not args.cpu_only + print('CPU controls passed.' if args.cpu_only else 'CPU/CUDA proof and key parity passed.', flush=True) + except Exception as error: + report['error'] = str(error) + raise + finally: + save() + + +if __name__ == '__main__': + main() diff --git a/tools/ixvm/check-formal.sh b/tools/ixvm/check-formal.sh new file mode 100755 index 000000000..bcf633a75 --- /dev/null +++ b/tools/ixvm/check-formal.sh @@ -0,0 +1,114 @@ +#!/usr/bin/env bash +# Integration gate for the separate packages. Existing exported artifacts can +# be supplied through the three IX_*_ARTIFACT variables to reuse compilation. +set -euo pipefail +cd "$(dirname "$0")/../.." +if [[ -n ${IX_TEST_OUTPUT_DIR:-} ]]; then + mkdir -p "$IX_TEST_OUTPUT_DIR" + formal_tmp=$(realpath "$IX_TEST_OUTPUT_DIR") +elif [[ ${IX_TEST_CUDA:-0} == 1 ]]; then + mkdir -p .lake + formal_tmp=$(mktemp -d "$PWD/.lake/formal-cuda-check.XXXXXX") +else + formal_tmp=$(mktemp -d) + trap 'rm -rf "$formal_tmp"' EXIT +fi +# Proving environment settings must not switch the baseline CLI to CUDA or +# poison its CPU-only witness generation. The hardware gate scopes them itself. +export IX_CUDA=0 AIUR_TRACE_ONLY_LOOKUPS=0 + +# The legacy port generators read their sources at pinned pre-migration Ix +# revisions with `git show`. A shallow checkout (CI's) lacks those commits, so +# fetch them when reachable; if a squash-merged branch commit is later GC'd on +# the remote, skip the historical port check and rely on `ix codegen --check`. +have_pinned_revs=1 +for rev in $(sed -nE "s/^(LIBRARY_)?REVISION = '([0-9a-f]{40})'$/\2/p" tools/ixvm/adapt.py); do + if ! git cat-file -e "$rev^{commit}" 2>/dev/null && \ + ! git fetch --quiet --depth 1 origin "$rev" 2>/dev/null; then + echo "Pinned pre-migration revision $rev not available; skipping legacy port regeneration check" + have_pinned_revs=0 + break + fi +done +if [[ $have_pinned_revs == 1 ]]; then + python3 tools/ixvm/adapt.py --check + python3 tools/ixvm/recursion.py --check + python3 tools/ixvm/recursion.py --aggregate --check +fi +lake build ix ixvm/ixvm multiStark/stark-export formal-aiur-tests formal-aggregate-tests \ + aiur/grouping_example aiur/Aiur.Library.U8Facts +.lake/build/bin/ix codegen --check +lake env Aiur/.lake/build/bin/grouping_example crates/aiur/tests/fixtures/grouping.json --check +cargo build --release --locked -p ixvm -p stark-verifier -p ix-prover --features parallel \ + --bin ixvm-proof --bin stark-verifier --bin ix-prover --example claim_fixture + +if [[ -z ${IX_AIUR_ARTIFACT:-} ]]; then + IX_AIUR_ARTIFACT="$formal_tmp/ixvm.json" + lake env IxVM/.lake/build/bin/ixvm export-claim-trace "$IX_AIUR_ARTIFACT" +fi +if [[ -z ${IX_RECURSION_ARTIFACT:-} ]]; then + IX_RECURSION_ARTIFACT="$formal_tmp/recursion.json" + lake env MultiStark/.lake/build/bin/stark-export export-trace "$IX_RECURSION_ARTIFACT" +fi +if [[ -z ${IX_AGGR_ARTIFACT:-} ]]; then + IX_AGGR_ARTIFACT="$formal_tmp/aggregate.json" + lake env MultiStark/.lake/build/bin/stark-export export-trace "$IX_AGGR_ARTIFACT" --aggregate +fi +export IX_AIUR_ARTIFACT IX_AGGR_ARTIFACT + +lake env .lake/build/bin/formal-aiur-tests "$formal_tmp/claims.json" +target/release/ixvm-proof test "$IX_AIUR_ARTIFACT" "$formal_tmp/claims.json" +.lake/build/bin/ix check --ixe "$formal_tmp/claims.json.ixe" Nat.add_comm +.lake/build/bin/ix prove Nat.add_comm > "$formal_tmp/prove.log" +cat "$formal_tmp/prove.log" +formal_proof=$(tail -n 1 "$formal_tmp/prove.log") +.lake/build/bin/ix verify "$formal_proof" +AIUR_TRACE_ONLY_LOOKUPS=1 .lake/build/bin/ix verify "$formal_proof" + +# Backend selection is explicit and the retired legacy flag is rejected. +if .lake/build/bin/ix check --formal --legacy Nat.add_comm > "$formal_tmp/conflict.log" 2>&1; then + echo "conflicting backends were accepted" >&2 + exit 1 +fi +grep -qF -- '--formal and --legacy cannot be combined' "$formal_tmp/conflict.log" + +target/release/stark-verifier fixture "$formal_tmp/inner" +target/release/stark-verifier ranges "$formal_tmp/inner/proof.bin" "$formal_tmp/ranges" 1 +python3 - "$formal_tmp" <<'PYTEST' +import json, pathlib, sys +p = pathlib.Path(sys.argv[1]) +ranges = json.loads((p / "ranges/ranges.json").read_text()) +assert ranges == [{"lo": 0, "hi": 1, "children": []}] +assert len((p / "ranges/0.statement").read_bytes()) == 65 +PYTEST +target/release/stark-verifier test "$IX_RECURSION_ARTIFACT" "$formal_tmp/inner/input.json" +target/release/stark-verifier prove "$IX_RECURSION_ARTIFACT" "$formal_tmp/inner/input.json" "$formal_tmp/outer" +target/release/stark-verifier verify "$IX_RECURSION_ARTIFACT" "$formal_tmp/outer/public.json" "$formal_tmp/outer/proof.bin" +AIUR_TRACE_ONLY_LOOKUPS=1 target/release/stark-verifier verify "$IX_RECURSION_ARTIFACT" "$formal_tmp/outer/public.json" "$formal_tmp/outer/proof.bin" +.lake/build/bin/formal-aggregate-tests "$formal_tmp/aggregation.json" +target/release/stark-verifier cases "$IX_AGGR_ARTIFACT" "$formal_tmp/aggregation.json" +target/release/stark-verifier prove "$IX_AGGR_ARTIFACT" "$formal_tmp/aggregation.json.wrap.json" "$formal_tmp/aggregate" +target/release/stark-verifier verify "$IX_AGGR_ARTIFACT" "$formal_tmp/aggregate/public.json" "$formal_tmp/aggregate/proof.bin" + +python3 tools/ixvm/check-controller.py "$formal_tmp" \ + --ixvm-artifact "$IX_AIUR_ARTIFACT" \ + --recursion-artifact "$IX_RECURSION_ARTIFACT" \ + --aggregate-artifact "$IX_AGGR_ARTIFACT" + +# Optional hardware gate: prove with CUDA and independently verify with CPU +# binaries. The separate target directory is the same one the CLI selects. +cuda_check_args=() +if [[ ${IX_TEST_CUDA:-0} == 1 ]]; then + cargo build --release --locked --target-dir target/formal-cuda \ + -p ixvm -p stark-verifier -p ix-prover --features parallel,cuda --bin ixvm-proof --bin stark-verifier --bin ix-prover + python3 tools/ixvm/check-controller.py "$formal_tmp" \ + --ixvm-artifact "$IX_AIUR_ARTIFACT" \ + --recursion-artifact "$IX_RECURSION_ARTIFACT" \ + --aggregate-artifact "$IX_AGGR_ARTIFACT" --devices "${MULTI_STARK_CUDA_DEVICE:-0}" +else + cuda_check_args+=(--cpu-only) +fi +python3 tools/ixvm/check-cuda.py "$formal_tmp" \ + --ixvm-artifact "$IX_AIUR_ARTIFACT" \ + --recursion-artifact "$IX_RECURSION_ARTIFACT" \ + --aggregate-artifact "$IX_AGGR_ARTIFACT" "${cuda_check_args[@]}" diff --git a/tools/ixvm/check-refactor.py b/tools/ixvm/check-refactor.py new file mode 100644 index 000000000..557866260 --- /dev/null +++ b/tools/ixvm/check-refactor.py @@ -0,0 +1,116 @@ +#!/usr/bin/env python3 +"""Compare a modularized artifact with its pre-refactor export. + +Only declared global renames and no-op guards/assignments may differ. Removing +the legacy load/store syntax wrappers eliminates their empty binding guards; +jump targets and trace hint instruction offsets are relocated accordingly. +Every other instruction, constraint, table row, layout and grouping must match. +This is an artifact regression check, not a legacy-to-Aiur translation proof. +""" +import argparse +import json +from pathlib import Path +import re + + +def transform(value, f): + if isinstance(value, str): + return f(value) + if isinstance(value, list): + return [transform(x, f) for x in value] + if isinstance(value, dict): + return {k: transform(x, f) for k, x in value.items()} + return value + + +def normalize_guards(package): + maps = {} + removed = 0 + for function in package['program']['functions']: + code, positions = [], {} + for pc, op in enumerate(function['code']): + positions[pc] = len(code) + if op['op'] == 'guard' and op['tests'] == []: + removed += 1 + else: + code.append(op) + positions[len(function['code'])] = len(code) + for op in code: + if op['op'] == 'jump': + op['target'] = positions[op['target']] + elif op['op'] == 'branch': + op['otherwise'] = positions[op['otherwise']] + function['code'] = code + maps[function['name']] = positions + + def hints(value, positions): + if isinstance(value, dict): + if value.get('op') == 'hint': + value['instruction'] = positions[value['instruction']] + for x in value.values(): + hints(x, positions) + elif isinstance(value, list): + for x in value: + hints(x, positions) + + for function in package['trace']['functions']: + hints(function['steps'], maps[function['name']]) + function['steps'] = [step for step in function['steps'] if not ( + step['action']['op'] == 'assign' and + step['action']['values'] == [{'var': dest} for dest in step['action']['dest']])] + return removed + + +def first_difference(a, b, path=''): + if type(a) is not type(b): + return path + ': different types' + if isinstance(a, dict): + if a.keys() != b.keys(): + return path + ': different keys' + for k in a: + if a[k] != b[k]: + return first_difference(a[k], b[k], f'{path}.{k}') + elif isinstance(a, list): + if len(a) != len(b): + return f'{path}: different lengths {len(a)} != {len(b)}' + for i, (x, y) in enumerate(zip(a, b)): + if x != y: + return first_difference(x, y, f'{path}[{i}]') + elif a != b: + return f'{path}: {a!r} != {b!r}' + return None + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('before', type=Path) + parser.add_argument('after', type=Path) + parser.add_argument('names', type=Path) + parser.add_argument('--out', type=Path) + args = parser.parse_args() + names = json.loads(args.names.read_text()) + before = json.loads(args.before.read_text()) + after = json.loads(args.after.read_text()) + before = transform(before, lambda s: re.sub(r'\b(?:IxVM|MultiStark)::\w+', + lambda m: names.get(m[0], m[0]), s)) + removed_before = normalize_guards(before) + removed_after = normalize_guards(after) + difference = first_difference(before, after) + if difference: + raise SystemExit('Refactor mismatch at ' + difference) + summary = { + 'equivalent_artifacts_modulo_names_and_noops': True, + 'functions': len(after['program']['functions']), + 'maps': len(after['program']['maps']), + 'chips': len(after['trace']['chips']), + 'groups': len(after['trace']['groups']), + 'removed_empty_guards': removed_before - removed_after, + 'before': str(args.before), 'after': str(args.after), + } + print(json.dumps(summary, indent=2)) + if args.out: + args.out.write_text(json.dumps(summary, indent=2) + '\n') + + +if __name__ == '__main__': + main() diff --git a/tools/ixvm/compare-backends.sh b/tools/ixvm/compare-backends.sh new file mode 100755 index 000000000..9da11d20d --- /dev/null +++ b/tools/ixvm/compare-backends.sh @@ -0,0 +1,64 @@ +#!/usr/bin/env bash +# Identical claim streams and identical recursive proof inputs; both executors +# are bytecode. Compile/setup/IO preparation are outside the execution timer. +set -euo pipefail +cd "$(dirname "$0")/../.." +comparison_dir=${1:-.lake/formal-comparison} +mkdir -p "$comparison_dir" +export RAYON_NUM_THREADS=${RAYON_NUM_THREADS:-1} +export IX_BENCH_NO_THP=${IX_BENCH_NO_THP:-1} +samples=${IX_BENCH_SAMPLES:-5} +lake build bench-compare-aiur formal-aiur-tests ixvm/ixvm multiStark/stark-export +cargo build --release --locked -p stark-verifier --features parallel --example compare --bin stark-verifier +if [[ -z ${IX_AIUR_ARTIFACT:-} ]]; then + IX_AIUR_ARTIFACT="$comparison_dir/ixvm.json" + lake env IxVM/.lake/build/bin/ixvm export-claim-trace "$IX_AIUR_ARTIFACT" +fi +if [[ -z ${IX_RECURSION_ARTIFACT:-} ]]; then + IX_RECURSION_ARTIFACT="$comparison_dir/recursion.json" + lake env MultiStark/.lake/build/bin/stark-export export-trace "$IX_RECURSION_ARTIFACT" +fi +lake env .lake/build/bin/formal-aiur-tests "$comparison_dir/claims.json" +python3 - "$comparison_dir" <<'PY' +import json, pathlib, sys +p = pathlib.Path(sys.argv[1]) +cases = json.loads((p / 'claims.json').read_text()) +for target, label in [('ixvm', 'CheckEnv frontier-asm (Nat.add_comm)'), + ('environment', 'CheckEnv self-contained (shared smoke env)')]: + case = next(c for c in cases if c['label'] == label) + (p / (target + '-input.json')).write_text(json.dumps(case['invocation'])) +PY +target/release/stark-verifier fixture "$comparison_dir/recursive-fixture" +for workload in ixvm environment recursion; do + app=ixvm + artifact="$IX_AIUR_ARTIFACT" + input="$comparison_dir/$workload-input.json" + if [[ $workload == recursion ]]; then + app=recursion + artifact="$IX_RECURSION_ARTIFACT" + input="$comparison_dir/recursive-fixture/input.json" + fi + for grouping in grouped ungrouped; do + flags=() + [[ $grouping == grouped ]] || flags+=(--ungrouped) + .lake/build/bin/bench-compare-aiur "$app" "$input" \ + "$comparison_dir/legacy-$workload-$grouping.json" "$samples" --prove "${flags[@]}" + target/release/examples/compare "$artifact" "$input" \ + "$comparison_dir/new-$workload-$grouping.json" "$samples" --prove --save-proof "${flags[@]}" + done +done +# Reuse one real IxVM proof for both recursive interpreters. Proving this much +# larger verifier trace is optional; its execution/trace/cell comparison is on +# by default. The tiny fixture above exercises both outer provers regardless. +input="$comparison_dir/new-environment-grouped.json.inner/input.json" +flags=() +[[ ${IX_BENCH_RECURSIVE_PROVE:-0} == 0 ]] || flags+=(--prove) +for grouping in grouped ungrouped; do + group_flags=() + [[ $grouping == grouped ]] || group_flags+=(--ungrouped) + .lake/build/bin/bench-compare-aiur recursion "$input" \ + "$comparison_dir/legacy-recursion-real-$grouping.json" "${IX_BENCH_REAL_SAMPLES:-3}" "${flags[@]}" "${group_flags[@]}" + target/release/examples/compare "$IX_RECURSION_ARTIFACT" "$input" \ + "$comparison_dir/new-recursion-real-$grouping.json" "${IX_BENCH_REAL_SAMPLES:-3}" "${flags[@]}" "${group_flags[@]}" +done +python3 tools/ixvm/compare-results.py "$comparison_dir" "$IX_AIUR_ARTIFACT" "$IX_RECURSION_ARTIFACT" diff --git a/tools/ixvm/compare-results.py b/tools/ixvm/compare-results.py new file mode 100755 index 000000000..9d4d978d4 --- /dev/null +++ b/tools/ixvm/compare-results.py @@ -0,0 +1,58 @@ +#!/usr/bin/env python3 +"""Save timing summaries and every circuit's separate stage widths/costs.""" +import csv +import hashlib +import json +import os +import pathlib +import platform +import statistics +import subprocess +import sys + +directory = pathlib.Path(sys.argv[1]) +summary, circuits = [], [] +for path in sorted(directory.glob('*.json')): + data = json.loads(path.read_text()) + if not isinstance(data, dict) or 'samples' not in data or 'circuits' not in data: + continue + rows = data['circuits'] + executions = [s['execute_seconds'] for s in data['samples'] + if s['execute_seconds'] is not None] + summary.append(dict(run=path.stem, backend=data['backend'], samples=len(data['samples']), + thp_disabled=data.get('thp_disabled'), + reused_execution=data.get('reused_execution', False), + initial_execute_seconds=data.get('initial_execute_seconds'), + execute_seconds=statistics.median(executions) if executions else None, + trace_with_lookups_seconds=statistics.median(s['trace_with_lookups_seconds'] for s in data['samples']), + circuits=len(rows), active_circuits=sum(r['height'] > 0 for r in rows), + stage1_columns=sum(r['stage1_width'] for r in rows), + stage2_columns=sum(r['stage2_width'] for r in rows), + cells=sum(r['cells'] for r in rows), fft_cost=sum(r['fft_cost'] for r in rows), + **(data['proof'] or {}))) + names = data.get('circuit_names', []) + for row in rows: + index = row['index'] + name = row.get('name') or (names[index] if index < len(names) else f'auxiliary_{index-len(names)}') + circuits.append(dict(run=path.stem, name=name, **{k: row[k] for k in [ + 'index', 'height', 'stage1_width', 'stage2_width', 'preprocessed_width', + 'preprocessed_height', 'quotient_degree', 'cells', 'fft_cost']})) + +for name, rows in [('summary', summary), ('circuits', circuits)]: + keys = list(dict.fromkeys(key for row in rows for key in row)) + with (directory / f'{name}.csv').open('w') as out: + writer = csv.DictWriter(out, fieldnames=keys) + writer.writeheader() + writer.writerows(rows) +manifest = dict(base_revision=subprocess.check_output(['git', 'rev-parse', 'HEAD'], text=True).strip(), + working_tree_modified=bool(subprocess.check_output(['git', 'diff', 'HEAD', '--name-only'], text=True)), + platform=platform.platform(), threads=os.getenv('RAYON_NUM_THREADS', 'unspecified'), + thp=os.getenv('IX_BENCH_NO_THP', '0'), rustflags=pathlib.Path('.cargo/config.toml').read_text(), + artifacts={p: hashlib.sha256(pathlib.Path(p).read_bytes()).hexdigest() for p in sys.argv[2:]}) +inner = directory / 'new-environment-grouped.json.inner' +manifest['recursive_input'] = { + name: dict(bytes=path.stat().st_size, sha256=hashlib.sha256(path.read_bytes()).hexdigest()) + for name in ['proof.bin', 'key.bin', 'claims.bin', 'input.json'] + if (path := inner / name).is_file()} +(directory / 'manifest.json').write_text(json.dumps(manifest, indent=2) + '\n') +print(f'Wrote {directory / "summary.csv"} and {directory / "circuits.csv"}') diff --git a/tools/ixvm/modules.py b/tools/ixvm/modules.py new file mode 100644 index 000000000..2bd278058 --- /dev/null +++ b/tools/ixvm/modules.py @@ -0,0 +1,277 @@ +"""Split the reviewed legacy adaptation into ordinary Aiur modules. + +This is source organization, not an Aiur compiler pass. Definitions retain +their bodies, type/constructor order, and inline markers. The inverse rename +is checked for every declaration. The certified module linker then checks all +cross-module references. Source manifests are also consumed by the exporters. +""" +from collections import OrderedDict +from dataclasses import dataclass +import json +from pathlib import Path +import re + +import adapt + + +@dataclass +class Declaration: + kind: str + name: str + source: str + + +def declarations(source): + hidden, saved = adapt.strings(adapt.uncomments(source)) + result = [] + pattern = r'(?m)^\s*(?:inline )?(fn|enum|type|table|map|const) (\w+)' + end = 0 + for m in re.finditer(pattern, hidden): + if m.start() < end: + continue + if m[1] in ('type', 'map', 'const'): + end, depth = m.end(), 0 + while end < len(hidden): + if hidden[end] in '([': + depth += 1 + elif hidden[end] in ')]': + depth -= 1 + elif hidden[end] == ';' and depth == 0: + break + end += 1 + end += 1 + else: + end = adapt.balance_end(hidden, hidden.index('{', m.end())) + body = hidden[m.start():end].strip() + for i, text in enumerate(saved): + body = body.replace(f'"STRING_{i}"', text) + result.append(Declaration(m[1], m[2], body)) + names = [d.name for d in result] + if len(names) != len(set(names)): + raise ValueError('duplicate declaration in source bundle') + return result + + +# These bodies are shared verbatim, modulo names, with the application ports. +SHARED = { + **{'list_' + n: 'Lists::' + n for n in + ['length', 'concat', 'lookup', 'lookup_or_default', 'drop', 'take', + 'snoc', 'reverse', 'reverse_acc']}, + 'checked_depth_succ': 'WordLists::checked_depth_succ', + 'list_depth_checked': 'WordLists::depth_checked', + 'list_length_u64': 'WordLists::length_u64', + 'list_lookup_u64': 'WordLists::lookup_u64', + 'b3_pack_w': 'Blake3::pack_word', + 'b3_pack': 'Blake3::pack_digest', + 'address_eq': 'Bytes::address_eq', + 'address_eq_tail': 'Bytes::address_eq_tail', + **{name: 'Goldilocks::' + name for name in + ['gl_val', 'gl_lt_p', 'gl_to_bytes', 'gl_inverse', + 'eg_add', 'eg_sub', 'eg_neg', 'eg_mul', 'eg_inverse', 'eg_div', 'eg_eq']}, +} + +SHARED_TYPES = { + 'List': 'Lists::List', 'Option': 'Options::Option', + 'U8': 'UInt8::U8', 'U32': 'UInt32::U32', 'U64': 'UInt64::U64', + 'Layer': 'Blake3::Layer', 'Addr': 'Bytes::AddressRef', 'ByteStream': 'Bytes::Stream', + 'Goldilocks': 'Goldilocks::Goldilocks', 'ExtGoldilocks': 'Goldilocks::ExtGoldilocks', +} + + +def origins(parts): + """Retain the original subsystem ownership through the lexical adapter.""" + result = {} + for module, source in parts: + for m in re.finditer(r'(?m)^\s*(?:inline )?(?:fn|enum|type|table|map) (\w+)', + adapt.uncomments(source)): + result[m[1]] = module + return result + + +def tokens(source): + return re.findall(r'"(?:[^"\\]|\\.)*"|\w+|[^\s]', adapt.uncomments(source)) + + +def native_memory(source): + """Eliminate the legacy syntax adapters `load`/`store`, both inline + identity wrappers around Aiur's existing `*`/`&` constructs.""" + hidden, saved = adapt.strings(source) + # Work inside out so nested calls do not need a recursive Python parser. + while matches := list(re.finditer(r'(?]*\b' + name + r'\b[^>]*>\s*\(', body): + # Concrete type arguments in calls are fine; only the declaration's + # own type parameters could shadow a global type. + params = re.match(r'<([^>]*)>', body) + if params and name in re.findall(r'\w+', params[1]): + raise ValueError(f'type parameter shadows {name} in {decl.name}') + + def replacement(m): + name = m[0] + if m.start() in constructors: + return name + target = names.get(name) + if target is None: + return name + # Uppercase identifiers are type/constructor paths. Lowercase names + # must be called, not e.g. a let-bound variable named like a function. + if not name[0].isupper() and not re.match(r'\s*(?:::<[^>]*>)?\(', body[m.end():]): + return name + module, member = target.split('::') + # A module and one of its types may have the same spelling (RBTreeMap). + # Qualify that type even locally so `Type::Ctor` cannot mean a module + # constant to the existing frontend. + return member if module == owner and member != owner else target + + body = re.sub(r'(?("stark.io.address", (5, Blake3::address_to_fields(raw)))') + raw = raw.replace('io_get_info(6, load(candidate))', + 'hint::<(G, G)>("stark.io.address", (6, Blake3::address_to_fields(load(candidate))))') + raw = raw.replace('io_get_info(4, digest)', + 'hint::<(G, G)>("stark.io.digest", digest)') + raw = adapt.use_opaque_words(raw) + raw = raw.replace('unconstrained_g_to_bytes(v)', 'hint::<[G; 8]>("bytes_le", v)') + raw = re.sub(r'unconstrained_g_inverse\((\w+)\)', + r'hint::("goldilocks.inverse", \1)', raw) + raw = re.sub(r'io_read\((\w+), (\w+), (1|8|64)\)', + r'hint::<[G; \3]>("stark.io.read\3", (\1, \2))', raw) + raw = re.sub(r'io_get_info\((\d+), \[(\w+)\]\)', + r'hint::<(G, G)>("stark.io.info", (\1, \2))', raw) + raw = adapt.replace_body(raw, 'read_byte_stream', ''' + match len { + 0 => store(ListNode.Nil), + _ => + let [byte] = hint::<[G; 1]>("stark.io.read1", (channel, idx)); + let tail = read_byte_stream(channel, idx + 1, len - 1); + store(ListNode.Cons(u8_from_field_unsafe(byte), tail)), + }''') + for name in ['read_preprocessed', 'read_opt_commit']: + raw = adapt.transform_body(raw, name, lambda s: + s.replace('match tag {', 'match to_field(tag) {')) + raw = re.sub(r'assert_eq!\(load\((\w+)\), ListNode\.Nil(?:,\s*"[^"]*")?\)', + r'let ListNode.Nil = load(\1)', raw) + raw = adapt.transform_body(raw, 'b3_w4_onto', lambda s: + s.replace('{', '{\n let w = UInt32::to_bytes(w);', 1)) + raw = adapt.transform_body(raw, 'b3_to_digest', lambda s: + s.replace('{', '{\n let h = [' + ', '.join( + f'UInt32::to_bytes(h[{i}])' for i in range(8)) + '];', 1)) + # Word construction at the byte boundary, including MMCS and IO blocks. + for name in ['b3_lane_chunks', 'b3_io_chunks', 'b3_io', 'b3_lanes', + 'mmcs_compress', 'b3_rows_chunks', 'b3_rows']: + def words(body): + # Every four-element byte array here is a Blake3 word. + atom = r'(?:\w+\[\d+\](?:\[\d+\])?|\d+u8|u8_from_field_unsafe\(\w+\))' + pattern = r'\[\s*' + atom + (r'\s*,\s*' + atom) * 3 + r'\s*\]' + body = re.sub(pattern, lambda m: f'UInt32::from_bytes({m[0]})', body) + body = body.replace('[[0u8; 4]; 16]', '[UInt32::ZERO; 16]') + return re.sub(r'match load\(chunk_count\) \{\s*\[0, 0, 0, 0, 0, 0, 0, 0\] =>', + 'match u64_is_zero(load(chunk_count)) { 1 =>', body) + raw = adapt.transform_body(raw, name, words) + raw = raw.replace('eq_zero(ptr_val(list_lookup(cap, capidx)) - ptr_val(root))', + 'digest_eq(list_lookup(cap, capidx), root)') + raw = raw.replace('eq_zero(ptr_val(list_lookup(cap, capidx)) - ptr_val(digest))', + 'digest_eq(list_lookup(cap, capidx), digest)') + raw = raw.replace('assert_eq!(ptr_val(xd), ptr_val(yd))', 'assert_eq!(digest_eq(xd, yd), 1)') + raw = raw.replace('assert_eq!(ptr_val(xr), ptr_val(yr))', 'assert_eq!(assert_same_claims(xr, yr), 1)') + raw = re.sub(r'assert_eq!\(ptr_val\(select_rows_le\(ar, lhs, next_lh\)\),\s*' + r'ptr_val\(select_rows_le\(br, lhs, next_lh\)\)\)', + 'assert_eq!(assert_same_claims(select_rows_le(ar, lhs, next_lh), ' + 'select_rows_le(br, lhs, next_lh)), 1)', raw) + # These nonrecursive arithmetic helpers were inline in the old verifier. + for name in ['gl_val', 'gl_lt_p', 'gl_inverse', 'eg_add', 'eg_sub', 'eg_neg', + 'eg_mul', 'eg_inverse', 'eg_div', 'eg_eq', 'b3_pack', 'b3_pack_w']: + adapt.INLINE_HELPERS.add(name) + result = adapt.adapt(raw, semantic=False) + result += (ROOT / 'MultiStark/MultiStark/Compatibility.aiur').read_text() + result, names = adapt.prune(result, ['ix_aggr' if aggregate else 'verify_multi_stark_proof'], + module='MultiStark', raw_bytes=False) + if re.search(r'\b(?:ptr_val|unconstrained_\w+|io_read|io_get_info)\(', result): + raise RuntimeError('recursive verifier retained a native-only operation') + result = '// Generated by tools/ixvm/recursion.py from the pinned Ix verifier.\n' + result + return '\n'.join(line.rstrip() for line in result.splitlines()) + '\n', names + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--check', action='store_true') + parser.add_argument('--aggregate', action='store_true') + args = parser.parse_args() + # Both roots use one copy of every verifier subsystem. --aggregate is kept + # for existing automation; either invocation checks/generates both bundles. + parts = [] + for path in FILES + ['Ix/Aggr/Circuit.lean']: + text = subprocess.check_output(['git', '-C', str(ROOT), 'show', + source_ref(path)], text=True) + component = {'Core': 'StarkCore', 'ByteStream': 'StarkIO', 'Blake3': 'StarkHash', + 'Goldilocks': 'Goldilocks', 'Deserialize': 'ProofDeserialize', + 'SystemDeserialize': 'SystemDeserialize', 'Pcs': 'Pcs', + 'Verifier': 'StarkVerifier', 'LegacyMultiStark': 'MultiStark', + 'Circuit': 'Aggregation'}[Path(path).stem] + parts.append((component, text.split('⟦', 1)[1].split('⟧', 1)[0])) + owners = modules.origins(parts) + for name in owners: + if name.startswith('b3_') or name in ('digest_eq',): + owners[name] = 'StarkHash' + elif name.startswith('ch_') or name in ('pcs_sample_ext', 'batch_fiat_shamir', 'shard_fiat_shamir'): + owners[name] = 'Transcript' + elif name.startswith(('mmcs_', 'frontier_')): + owners[name] = 'Mmcs' + standalone, _ = source(False) + aggregate, _ = source(True) + modules.check_shared(standalone) + modules.check_shared(aggregate) + sg, sn = modules.partition(standalone, owners, 'MultiStark', ['verify_multi_stark_proof']) + ag, an = modules.partition(aggregate, owners, 'MultiStark', ['ix_aggr']) + for module in sg.keys() & ag.keys() - {'MultiStark'}: + common = {} + for body in sg[module] + ag[module]: + decl = modules.declarations(body)[0] + if decl.name in common and modules.tokens(common[decl.name]) != modules.tokens(body): + raise ValueError(f'different verifier bodies for {module}::{decl.name}') + common[decl.name] = body + sg[module] = ag[module] = list(common.values()) + directory = ROOT / 'MultiStark/MultiStark' + modules.emit(directory, sg, 'MultiStark', 'Program', sn, args.check) + modules.emit(directory, ag, 'MultiStark', 'Aggregate', an, args.check) + print(f'{len(sg)} verifier modules; {len(ag)} aggregation modules') + + +if __name__ == '__main__': + main() diff --git a/tools/ixvm/trace-scaling.py b/tools/ixvm/trace-scaling.py new file mode 100644 index 000000000..f6622a9c1 --- /dev/null +++ b/tools/ixvm/trace-scaling.py @@ -0,0 +1,100 @@ +#!/usr/bin/env python3 +"""Compare CPU trace scaling using fixed grouped artifacts and query records. + +Build bench-compare-aiur and the stark-verifier compare example with parallel +support first. Each process executes once, then generates complete traces and +host lookup buffers twice for warmup and --samples times for measurement. +Processes run sequentially, pinned to one hardware thread per core before SMT. +""" +import argparse +import csv +import hashlib +import json +import os +from pathlib import Path +import statistics +import subprocess + + +def cpu_order(): + cores = {} + for cpu in sorted(os.sched_getaffinity(0)): + topology = Path(f'/sys/devices/system/cpu/cpu{cpu}/topology') + key = tuple((topology / name).read_text().strip() + for name in ('physical_package_id', 'core_id')) + cores.setdefault(key, []).append(cpu) + return ([cpus[0] for cpus in cores.values()] + + [cpu for cpus in cores.values() for cpu in cpus[1:]]) + + +def main(): + cli = argparse.ArgumentParser(description=__doc__) + cli.add_argument('output', type=Path) + cli.add_argument('--inputs', type=Path, default=Path('.lake/formal-comparison/final')) + cli.add_argument('--ixvm-artifact', type=Path, required=True) + cli.add_argument('--recursion-artifact', type=Path, required=True) + cli.add_argument('--threads', type=int, nargs='+', default=[8, 64, 1, 32]) + cli.add_argument('--samples', type=int, default=3) + args = cli.parse_args() + cpus = cpu_order() + if args.samples < 1 or any(n < 1 or n > len(cpus) for n in args.threads): + cli.error('samples must be positive and thread counts must fit available CPUs') + args.output.mkdir(parents=True, exist_ok=True) + inputs = [ + ('environment', 'ixvm', args.ixvm_artifact, args.inputs / 'environment-input.json'), + ('recursion-real', 'recursion', args.recursion_artifact, + args.inputs / 'new-environment-grouped.json.inner/input.json'), + ] + binaries = {'legacy': '.lake/build/bin/bench-compare-aiur', + 'new': 'target/release/examples/compare'} + files = [p for _, _, artifact, input_path in inputs for p in (artifact, input_path)] + manifest = dict( + base_revision=subprocess.check_output(['git', 'rev-parse', 'HEAD'], text=True).strip(), + cpus=cpus, threads=args.threads, samples=args.samples, warmups=2, + lscpu=json.loads(subprocess.check_output(['lscpu', '-J'], text=True)), + reused_execution=True, host_lookups=True, thp_disabled=True, + artifact_input_sha256={str(p): hashlib.sha256(p.read_bytes()).hexdigest() for p in files}, + binary_sha256={name: hashlib.sha256(Path(p).read_bytes()).hexdigest() + for name, p in binaries.items()}, + commands=[], + ) + rows = [] + shapes = {} + for ti, threads in enumerate(args.threads): + env = dict(os.environ, RAYON_NUM_THREADS=str(threads), + IX_BENCH_NO_THP='1', IX_BENCH_REUSE_EXECUTION='1', + AIUR_TRACE_ONLY_LOOKUPS='0') + for wi, (workload, app, artifact, input_path) in enumerate(inputs): + order = ['legacy', 'new'] if (ti + wi) % 2 == 0 else ['new', 'legacy'] + for backend in order: + output = args.output / f'{workload}-{backend}-{threads}.json' + program = app if backend == 'legacy' else str(artifact) + command = ['taskset', '-c', ','.join(map(str, cpus[:threads])), + binaries[backend], program, str(input_path), str(output), str(args.samples)] + manifest['commands'].append(command) + (args.output / 'manifest.json').write_text(json.dumps(manifest, indent=2) + '\n') + print(f'{workload} {backend}: {threads} threads', flush=True) + with output.with_suffix('.log').open('w') as log: + subprocess.run(command, env=env, stdout=log, stderr=subprocess.STDOUT, check=True) + data = json.loads(output.read_text()) + if not data.get('reused_execution') or not all(s['execute_seconds'] is None for s in data['samples']): + raise RuntimeError('benchmark binary did not reuse execution; rebuild it') + shape = [(c['height'], c['stage1_width'], c['stage2_width'], c['cells']) + for c in data['circuits']] + key = workload, backend + if shapes.setdefault(key, shape) != shape: + raise RuntimeError(f'{key}: circuit shapes changed with thread count') + samples = [s['trace_with_lookups_seconds'] for s in data['samples']] + row = dict(workload=workload, backend=backend, threads=threads, + median_seconds=statistics.median(samples), min_seconds=min(samples), + max_seconds=max(samples), cells=sum(c['cells'] for c in data['circuits'])) + rows.append(row) + with (args.output / 'summary.csv').open('w') as f: + writer = csv.DictWriter(f, fieldnames=list(row), lineterminator='\n') + writer.writeheader() + writer.writerows(rows) + print(f" trace + lookups: {row['median_seconds']:.6f}s", flush=True) + + +if __name__ == '__main__': + main() diff --git a/tools/ixvm/tune-groups.py b/tools/ixvm/tune-groups.py new file mode 100644 index 000000000..ad138170f --- /dev/null +++ b/tools/ixvm/tune-groups.py @@ -0,0 +1,196 @@ +#!/usr/bin/env python3 +"""Suggest a grouping policy from Lean layout metrics and recorded row counts. + +This is an untrusted search heuristic, not an artifact compiler. Feed its policy +to grouping_tune (or the application exporter) to obtain certified layouts. +Every workload's estimated cells and FFT work must stay within the starting +policy's budget; column count is a smaller secondary objective. +""" +import argparse +import functools +import json +import math +from pathlib import Path + + +def padded(n): + return 0 if n == 0 else 1 << (n - 1).bit_length() + + +def fft_cost(main, auxiliary, quotient, height): + def transform(n): + return n * max(1, n.bit_length() - 1) if n else 0 + return (3 * (main + auxiliary) * transform(height) + + 2 * transform(quotient * height) + + 2 * quotient * transform(2 * height)) + + +def lookup_degree(lookups, size): + result = 1 + for at in range(0, len(lookups), size): + chunk = lookups[at:at + size] + degree = sum(p[0] for p in chunk) + result = max(result, degree + 1, + max(p[1] + degree - p[0] for p in chunk)) + return result + + +def main(): + cli = argparse.ArgumentParser(description=__doc__) + cli.add_argument('metrics', type=Path) + cli.add_argument('output', type=Path) + cli.add_argument('--profile', nargs=2, action='append', required=True, + metavar=('COUNTS', 'UNGROUPED_BENCH')) + cli.add_argument('--prefix', required=True) + cli.add_argument('--max-members', type=int, default=16) + cli.add_argument('--sweeps', type=int, default=4) + cli.add_argument('--report-only', action='store_true') + args = cli.parse_args() + data = json.loads(args.metrics.read_text()) + chips = data['chips'] + indices = {c['name']: i for i, c in enumerate(chips)} + reps = dict(data['representatives']) + entries = {indices[reps.get(n, n)] for n in data['entries']} + counts, statistics = [], [] + for count_path, bench_path in args.profile: + rows = [0] * len(chips) + for f in json.loads(Path(count_path).read_text())['function_rows']: + rows[indices[f['chip']]] += f['rows'] + counts.append(rows) + statistics.append({c['name']: c for c in json.loads(Path(bench_path).read_text())['circuits']}) + # Singleton shape is measured by the actual Rust lowering, including lookup + # pairing. These shapes are independent of which workload produced rows. + singleton = statistics[0] + groups, used = {}, set() + for _, names in data['groups']: + members = tuple(sorted({indices[reps.get(n, n)] for n in names + if reps.get(n, n) in indices} - entries - used)) + if len(members) >= 2: + groups[len(groups)] = members + used.update(members) + for i in range(len(chips)): + if i not in used: + groups[len(groups)] = (i,) + + @functools.lru_cache(maxsize=200_000) + def shape(members): + if len(members) == 1: + c = singleton[chips[members[0]]['name']] + return c['stage1_width'], c['stage2_width'], c['quotient_degree'] + selected = [chips[i] for i in members] + width = 1 + sum(c['private'] + c['lifted'] for c in selected) + max(c['shared'] for c in selected) + lookups = [(max((c['lookups'][j][0] if j < len(c['lookups']) else 0) for c in selected), + max((c['lookups'][j][1] if j < len(c['lookups']) else 0) for c in selected)) + for j in range(max(len(c['lookups']) for c in selected))] + constraints = max(2, *(c['constraint_degree'] for c in selected)) + quotient = padded(max(2, constraints, lookup_degree(lookups, 1)) - 1) + size = 1 + for candidate in range(min(8, len(lookups)), 1, -1): + if padded(max(2, constraints, lookup_degree(lookups, candidate)) - 1) <= quotient: + size = candidate + break + return width, 2 * math.ceil(len(lookups) / size), quotient + + @functools.lru_cache(maxsize=200_000) + def cost(members): + if not members: + return (0,) * (2 + 2 * len(counts)) + main, auxiliary, quotient = shape(members) + values = [main, 1] + for rows in counts: + height = padded(sum(rows[i] for i in members)) + values.extend((height * main, fft_cost(main, auxiliary, quotient, height))) + return tuple(values) + + def total(): + return tuple(map(sum, zip(*(cost(g) for g in groups.values())))) + + initial = total() + weights = [0.05 / initial[0], 0.01 / initial[1]] + for i in range(len(counts)): + weights.extend((0.2 / len(counts) / max(1, initial[2 + 2*i]), + 1.0 / len(counts) / max(1, initial[3 + 2*i]))) + + def score(delta): + return sum(a * b for a, b in zip(delta, weights)) + + def delta_for(old, new): + return tuple(sum(cost(g)[i] for g in new) - sum(cost(g)[i] for g in old) + for i in range(len(weights))) + + def fits(delta, current): + return all(current[i] + delta[i] <= initial[i] for i in range(2, len(weights))) + + current = initial + if not args.report_only: + for sweep in range(args.sweeps): + moves = 0 + for member in range(len(chips)): + if member in entries: + continue + source = next(k for k, g in groups.items() if member in g) + old = groups[source] + remainder = tuple(i for i in old if i != member) + best = None + destinations = list(groups) + ([None] if len(old) > 1 else []) + for target in destinations: + if target == source: + continue + other = groups[target] if target is not None else () + if any(i in entries for i in other) or len(other) >= args.max_members: + continue + combined = tuple(sorted((*other, member))) + delta = delta_for((old, other), (remainder, combined)) + gain = score(delta) + if gain < -1e-10 and fits(delta, current) and (best is None or gain < best[0]): + best = gain, target, combined, delta + if best is not None: + _, target, combined, delta = best + if target is None: + target = max(groups) + 1 + groups[target] = combined + if remainder: + groups[source] = remainder + else: + del groups[source] + current = tuple(a + b for a, b in zip(current, delta)) + moves += 1 + # Moving a whole group can cross a padding boundary that no single + # member move can improve on its own. + for source in list(groups): + if source not in groups or any(i in entries for i in groups[source]): + continue + old = groups[source] + best = None + for target, other in groups.items(): + if target == source or any(i in entries for i in other) or len(old) + len(other) > args.max_members: + continue + combined = tuple(sorted(old + other)) + delta = delta_for((old, other), (combined,)) + gain = score(delta) + if gain < -1e-10 and fits(delta, current) and (best is None or gain < best[0]): + best = gain, target, combined, delta + if best is not None: + _, target, combined, delta = best + groups[target] = combined + del groups[source] + current = tuple(a + b for a, b in zip(current, delta)) + moves += 1 + print(f'sweep {sweep}: {moves} moves, {len(groups)} function circuits, {current[0]} columns, objective {score(current):.6f}', flush=True) + if not moves: + break + ordered = sorted(groups.values(), key=lambda g: min(g)) + policy = [[f'{args.prefix}_{i:02}', [chips[j]['name'] for j in g]] + for i, g in enumerate(g for g in ordered if len(g) >= 2)] + args.output.write_text(json.dumps(policy, indent=2) + '\n') + report = {'initial': initial, 'optimized': current, + 'dimensions': ['stage1_columns', 'function_circuits'] + + [s for i in range(len(counts)) for s in (f'cells_{i}', f'fft_{i}')], + 'profiles': args.profile, + 'circuits': [{'members': [chips[i]['name'] for i in g], 'shape': shape(g), 'cost': cost(g)} for g in ordered]} + args.output.with_suffix('.report.json').write_text(json.dumps(report, indent=2) + '\n') + print(json.dumps({k: report[k] for k in ('dimensions', 'initial', 'optimized')}), flush=True) + + +if __name__ == '__main__': + main()

(()) }", + "type I = T; fn f(x: T) -> T { hint::>(x) }", + "enum O { None, Some(T) } type P = O<&Field>; table bad: P {}", + "type P = &Field; table keys: (Field,) {} table vals: Field {} map f(x: P) -> Field = keys => vals;", + "type Link = E; enum E { Recur(Link) }", + "enum O { None, Some(T) } type A = O; fn f(A::Some(x): A) -> Field { x }" + ] + for code in bad do + match Generic.Frontend.ofString (← Lean.getEnv) code with + | .error _ => pure () + | .ok _ => throwError "unexpectedly accepted: {code}" + -- The legacy frontend must not silently discard a new declaration. + match Frontend.ofString (← Lean.getEnv) "type A = A; fn f() -> Field { 0 }" with + | .error _ => pure () + | .ok _ => throwError "legacy frontend discarded an alias declaration" + +def pointerInput : Generic.Program Nat := aiur% " +type Public = Hidden; +enum Hidden { Empty, Pointer(&Field) } +fn main(x: Public) -> Field { 0 } +" +#guard (do + let s ← Generic.prepare (pointerInput.toField Rat) + return (← Generic.specialize s ["main"]).program.functions.length).toOption.isNone + +def collidingKeys : Generic.Program Nat := aiur% " +type Scalar = Field; +table keys: (Scalar,) { (1,), (102,) } +table outputs: Scalar { 0, 1 } +map lookup(x: Scalar) -> Scalar = keys => outputs; +" +#guard (Generic.prepare (collidingKeys.toField (ZMod 101))).toOption.isNone + +-- The ordering of the pass is field agnostic, including expansion errors. +example (p : Generic.Program Nat) (F : Type) [NatCast F] : + Generic.expandAliases (p.toField F) = (Generic.expandAliases p).map (fun q => q.toField F) := + Generic.expandAliases_toField p F + +/-- info: 'Aiur.Generic.expandAliases_toField' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.expandAliases_toField + +def run : IO Unit := do + let checks := [ + ("alias inference", runSource "main" [.field 17], .ok (.field 17, [])), + ("alias specialization", runSpecialized "main" [.field 17], .ok (.field 17, [])), + ("alias constructor inference", runSpecialized "nested" [.field 23], .ok (.field 23, [])), + ("alias ROM", runSpecialized "read" [.field 29], runSource "read" [.field 29]) + ] + for (name, actual, expected) in checks do + unless actual = expected do throw (IO.userError s!"{name}: expected {repr expected}, got {repr actual}") + IO.println s!"Passed {checks.length} alias execution checks." + +end AiurAliasTests diff --git a/Aiur/AiurTests/Arrays.lean b/Aiur/AiurTests/Arrays.lean new file mode 100644 index 000000000..feee374d1 --- /dev/null +++ b/Aiur/AiurTests/Arrays.lean @@ -0,0 +1,280 @@ +import Aiur.Generic +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +namespace AiurArrayTests +open Aiur +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 +instance : Fact (Nat.Prime 101) := ⟨by decide⟩ + +def source : Generic.Program Nat := aiur% " +type Four = [T; 4]; +type Matrix = [[T; 2]; 2]; +type Maybe = Option; +enum Option { None, Some(T) } +const zero = 0; +const zeros = [zero; 4]; +const cell = &[zero]; +const cells = [&zero; 2]; +const matrix = [[1, 2]; 2]; + +fn identity(x: T) -> T { x } +fn twice(x: T) -> [T; 2] { [x; 2] } +fn first(a: [T; 2]) -> T { a[0] } +fn last(a: [T; 2]) -> T { a[1] } +fn pair([a, b]: [Field; 2]) -> Field { a + b } +fn singleton([x]: [Field; 1]) -> Field { x } +fn unit([]: [Field; 0]) -> Field { 9 } +fn take_two(a: Four) -> [T; 2] { a[..2] } +fn suffix(a: Four) -> [T; 2] { a[2..] } +fn full(a: Four) -> Four { a[..] } +fn middle(a: Four) -> [T; 2] { a[1..3] } +fn inclusive(a: Four) -> [T; 2] { a[1..=2] } +fn inclusive_zero(a: Four) -> [T; 2] { a[..=1] } +fn at_end(a: Four) -> [T; 0] { a[4..4] } +fn all_slices() -> ([Field; 2], [Field; 2], [Field; 4], [Field; 2], [Field; 2], [Field; 2], [Field; 0]) { + let a = [1, 2, 3, 4,]; + (take_two(a), suffix(a), full(a), middle(a), inclusive(a), inclusive_zero(a), at_end(a)) +} +fn nested() -> Field { matrix[1][0] + [(3, 4), (5, 6)][1].0 } +fn generic_enum() -> [Field; 2] { + match Maybe::Some(identity([7, 8])) { Maybe::Some([a, b]) => [b, a], Maybe::None => [0; 2] } +} +fn infer_empty_ctor() -> [Option; 2] { [Option::None; 2] } +fn empty() -> [Field; 0] { [] } +fn empty_repeat() -> [Field; 0] { [5; 0] } +fn simple() -> Field { pair(twice(3)) + singleton([4]) + unit([]) } +fn ordered(a: [Field; 2]) -> Field { + match a { [0, x] => x + 10, [x, 0] => x + 20, [x, y] => x + y } +} +fn refutable(a: [Field; 2]) -> Field { let [0, x] = a; x } +fn const_match() -> Field { let ::zeros = [0, 0, 0, 0]; let ::cell = cell; 7 } +fn const_repeat() -> [&Field; 2] { cells } +fn const_pattern() -> Field { let ::cells = [&0, &0]; 11 } +fn repeated() -> [&Field; 2] { [&1; 2] } +fn separate() -> [&Field; 2] { [&1, &1] } +fn empty_effect() -> [&Field; 0] { [&1; 0] } +fn empty_error() -> [Field; 0] { [1 / 0; 0] } +fn produce() -> [Field; 3] { let p = &[1, 2, 3]; *p } +fn slice_once() -> [Field; 2] { produce()[1..] } +fn index_once() -> Field { produce()[2] } +fn slice_empty() -> [Field; 0] { produce()[1..1] } +fn slice_error() -> [Field; 0] { [1 / 0][0..0] } +fn load_array(&[a, b]: &[Field; 2]) -> Field { a + b } +fn pointers() -> Field { load_array(&[3, 4]) } +fn pointer_match(x: Field) -> Field { + match [&x, &5] { [&0, &b] => b, [&a, &b] => a + b } +} +fn repeated_pattern(x: Field) -> Field { match [x; 3] { [0; 3] => 1, [_; 3] => 2 } } +fn shadow(zero: Field) -> [Field; 2] { let [zero, x] = [zero, ::zero]; [zero, x] } +fn inactive() -> [Field; 2] { match 0 { 0 => [3; 2], _ => [1 / 0; 2] } } +fn hinted(key: Field) -> [Option; 2] { hint::<[Option; 2]>(key) } +fn repeated_hint() -> [Field; 2] { [hint::(*&9); 2] } +fn zero_hint() -> [Field; 0] { [hint::(()); 0] } +fn empty_pointer_arg(x: [&Field; 0]) -> Field { 0 } +fn empty_pointer_internal() -> Field { empty_pointer_arg([]) } +fn static_length() -> Field { [7, 8, 9, 10, 11, 12, 13, 14][7] } +" + +def runSource (name : String) (args : List (SourceValue Rat) := []) := do + let s ← Generic.prepare (source.toField Rat) + s.run name args + +def runSpecialized (name : String) (args : List (SourceValue Rat) := []) := do + let s ← Generic.prepare (source.toField Rat) + let q ← Generic.specialize s [name] + q.run name args + +def runCore (name : String) (args : List (SourceValue Rat) := []) := do + let s ← Generic.prepare (source.toField Rat) + let q ← Generic.specialize s [name] + q.coreRun name args + +def checks : List (String × Except String (SourceValue Rat × Heap Rat)) := [ + ("all_slices", .ok (.tuple [ + .tuple [1, 2], .tuple [3, 4], .tuple [1, 2, 3, 4], .tuple [2, 3], + .tuple [2, 3], .tuple [1, 2], .tuple []], [])), + ("nested", .ok (6, [])), + ("generic_enum", .ok (.tuple [8, 7], [])), + ("empty", .ok (.tuple [], [])), + ("empty_repeat", .ok (.tuple [], [])), + ("simple", .ok (19, [])), + ("const_match", .ok (7, [.tuple [0]])), + ("const_repeat", .ok (.tuple [.ptr .field 0, .ptr .field 0], [0])), + ("const_pattern", .ok (11, [0, 0])), + ("repeated", .ok (.tuple [.ptr .field 0, .ptr .field 0], [1])), + ("separate", .ok (.tuple [.ptr .field 0, .ptr .field 1], [1, 1])), + ("empty_effect", .ok (.tuple [], [1])), + ("empty_error", .error (reprStr EvalError.divisionByZero)), + ("slice_once", .ok (.tuple [2, 3], [.tuple [1, 2, 3]])), + ("index_once", .ok (3, [.tuple [1, 2, 3]])), + ("slice_empty", .ok (.tuple [], [.tuple [1, 2, 3]])), + ("slice_error", .error (reprStr EvalError.divisionByZero)), + ("pointers", .ok (7, [.tuple [3, 4]])), + ("inactive", .ok (.tuple [3, 3], [])), + ("empty_pointer_internal", .ok (0, [])), + ("zero_hint", .error (reprStr (EvalError.hint .unavailable))) +] + +#guard checks.all fun (name, expected) => runSource name == expected && runSpecialized name == expected && runCore name == expected +#guard runSource "ordered" [.tuple [0, 0]] == .ok (10, []) +#guard runSource "ordered" [.tuple [3, 0]] == .ok (23, []) +#guard runSpecialized "ordered" [.tuple [3, 4]] == .ok (7, []) +#guard runSource "refutable" [.tuple [0, 8]] == .ok (8, []) +#guard runSource "refutable" [.tuple [1, 8]] == .error (reprStr EvalError.patternMismatch) +#guard runSource "pointer_match" [0] == .ok (5, [0, 5]) +#guard runSpecialized "pointer_match" [3] == .ok (8, [3, 5]) +#guard runSource "repeated_pattern" [0] == .ok (1, []) +#guard runSource "repeated_pattern" [7] == .ok (2, []) +#guard runSource "shadow" [6] == .ok (.tuple [6, 0], []) +#guard (runSource "empty_pointer_arg" [.tuple []]).toOption.isNone + +def tables : Generic.Program Nat := aiur% " +type Pair = [Field; 2]; +const key = [0, 1]; +table inputs: (Pair,) { (key,), ([2; 2],) } +table outputs: Pair { [3; 2], [4, 5] } +map lookup(a: Pair) -> Pair = inputs => outputs; +fn main() -> Pair { lookup(key) } +" +#guard (do + let s ← Generic.prepare (tables.toField Rat) + let q ← Generic.specialize s ["main"] + q.run "main" []) == .ok (.tuple [3, 3], []) +#guard (do + let s ← Generic.prepare (tables.toField (ZMod 101)) + let q ← Generic.specialize s ["main"] + return (← q.compile).system.chips.length).toOption.isSome + +-- A typed provider sees the same tuple layout as the core evaluator. +#guard (do + let s ← Generic.prepare (source.toField Rat) + let hints := s.checkedHints fun _ key => match key with + | .field n => .ok (.field (n + 1)) + | _ => .error .unavailable + s.run "repeated_hint" [] (hints := hints)) == .ok (.tuple [10, 10], [9]) +#guard (do + let s ← Generic.prepare (source.toField Rat) + let hints := s.checkedHints fun _ _ => .ok (.tuple [.field 1, .field 2]) + s.run "hinted" [0] (hints := hints)).toOption.isNone +#guard (do + let s ← Generic.prepare (source.toField Rat) + let option := (Generic.Instance.mk "Option" [.field]).symbol + let value : Constant Rat := .tuple [.construct option "None" [], .construct option "Some" [8]] + let hints := s.checkedHints fun _ _ => .ok value + return (← s.run "hinted" [0] (hints := hints)) == (value.toValue, [])) == .ok true + +-- Lengths and bounds remain natural numbers when literals change fields. +instance : Fact (Nat.Prime 7) := ⟨by decide⟩ +#guard (do + let s ← Generic.prepare (source.toField (ZMod 7)) + s.run "static_length" []) == .ok (.field 0, []) + +-- Array/tuple distinction must survive table-map signature checking. +run_cmd do + let env ← Lean.getEnv + for code in [ + "fn f() -> [Field; 2] { [0, ()] }", + "fn f() -> [Field; 2] { [0] }", + "fn f() -> [Field; 2] { (0, 0) }", + "fn f() -> (Field, Field) { [0; 2] }", + "fn f() -> Field { [0][1] }", + "fn f() -> Field { [0].0 }", + "fn f() -> Field { (0,)[0] }", + "fn f(i: Field) -> Field { [0, 1][i] }", + "fn f() -> Field { [0, 1][1 + 0] }", + "fn f() -> Field { [0][-1] }", + "fn f() -> Field { [][0] }", + "fn f() -> [Field; 1] { [0, 1][2..1] }", + "fn f() -> [Field; 1] { [0][0..2] }", + "fn f() -> [Field; 0] { [0][2..2] }", + "fn f() -> [Field; 2] { [0][..=1] }", + "fn f(n: Field) -> [Field; 1] { [0][..n] }", + "fn f() -> [Field; 1] { (0,)[..] }", + "fn f() -> Field { let [x, y] = [0]; x }", + "fn f() -> Field { let [x, x] = [0, 0]; x }", + "fn f() -> Field { let [x; 2] = [0; 2]; x }", + "fn f() -> Field { let [x; 0] = [0; 0]; x }", + "fn f([0]: [Field; 1]) -> Field { 0 }", + "fn f(a: [&Field; 2]) -> Field { match a { [&0; 2] => 1, [&0, &0] => 2, _ => 3 } }", + "fn f() -> [Field; 2] { [0; x] }", + "fn f() -> [Field; 2] { [0; 65537] }", + "fn f() -> [Field; 65537] { [] }", + "const a = [a; 0];", + "const a = [b]; const b = a;", + "const a = [_; 3];", + "const a = [0, ()];", + "type Bad = [Bad; 0];", + "enum Bad { Wrap([Bad; 0]) }", + "enum Bad { Wrap([Bad; 2]) }", + "enum A { Wrap([B; 0]) } enum B { Wrap(A) }", + "table t: [&Field; 0] { [] }", + "enum E { A, B([&Field; 0]) } table t: E { E::A }", + "fn f() -> [&Field; 0] { hint::<[&Field; 0]>(()) }", + "enum E { A, B([&Field; 0]) } fn f() -> E { hint::(()) }", + "table i: [Field; 2] { [0, 1] } table o: Field { 0 } map m(a: Field, b: Field) -> Field = i => o;", + "table i: () { () } table o: [Field; 2] { [0, 1] } map m() -> (Field, Field) = i => o;", + "table i: () { () } table o: [Field; 0] { [] } map m() -> [(); 0] = i => o;" + ] do + match Generic.Frontend.ofString env code with + | .error _ => pure () + | .ok _ => throwError "unexpectedly accepted: {code}" + +def duplicate : Generic.Program Nat := aiur% " +fn main(a: [Field; 2]) -> Field { match a { [0; 2] => 1, [0, 0] => 2, _ => 3 } } +" +#guard (do + let s ← Generic.prepare (duplicate.toField Rat) + let q ← Generic.specialize s ["main"] + return (← q.compile).system.chips.length).toOption.isNone + +def boundary : Generic.Program Nat := aiur% " +enum E { A, B([&Field; 0]) } +fn entry(x: E) -> Field { 0 } +" +#guard (do + let s ← Generic.prepare (boundary.toField Rat) + s.checkEntry "entry").toOption.isNone + +def collision : Generic.Program Nat := aiur% " +fn main(a: [Field; 1]) -> Field { match a { [1] => 2, [102] => 3, _ => 4 } } +" +#guard (do + let s ← Generic.prepare (collision.toField (ZMod 101)) + let q ← Generic.specialize s ["main"] + return (← q.compile).system.chips.length).toOption.isNone + +def shuffle : Generic.Program Nat := aiur% " +fn index(a: [Field; 4]) -> Field { a[2] } +fn slice(a: [Field; 4]) -> [Field; 2] { a[1..3] } +fn repeated(a: Field) -> [Field; 4] { [a; 4] } +" +-- No selector columns or lookup messages are introduced by static operations. +#guard (do + let s ← Generic.prepare (shuffle.toField Rat) + let q ← Generic.specialize s ["index", "slice", "repeated"] + let chips := (← q.compile).system.chips + return chips.map (fun (c : Circuit.Chip Rat) => (c.numVars, c.sends.length, c.memory.length))) == + .ok [(5, 0, 0), (6, 0, 0), (5, 0, 0)] + +#guard (do + let s ← Generic.prepare (source.toField (ZMod 101)) + let q ← Generic.specialize s + ["all_slices", "nested", "generic_enum", "infer_empty_ctor", "const_match", "const_repeat", + "const_pattern", "slice_once", "slice_empty", "repeated", "separate", "empty_effect", + "ordered", "refutable", "pointers", "pointer_match", "hinted", "repeated_hint", "inactive"] + return (← q.compile).system.chips.length).toOption.isSome + +/-- info: 'Aiur.Generic.ArrayLowering.repeatValue_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.ArrayLowering.repeatValue_iff + +def run : IO Unit := do + for (name, expected) in checks do + for actual in [runSource name, runSpecialized name, runCore name] do + unless actual = expected do + throw (IO.userError s!"array {name}: expected {repr expected}, got {repr actual}") + IO.println s!"Passed {3 * checks.length} array execution checks." + +end AiurArrayTests diff --git a/Aiur/AiurTests/Assertions.lean b/Aiur/AiurTests/Assertions.lean new file mode 100644 index 000000000..61c350ea0 --- /dev/null +++ b/Aiur/AiurTests/Assertions.lean @@ -0,0 +1,140 @@ +import Aiur.Generic +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +namespace AiurAssertionTests +open Aiur +set_option maxRecDepth 20000 +set_option maxHeartbeats 8000000 + +def source : Generic.Program Nat := aiur% " +enum Inner { Empty, Pair(Field, Field) } +enum Outer { Empty, Some(Inner, [Field; 2]) } +struct Box { value: T } +type Pair = (Field, Field); +fn fields(x: Field, y: Field) -> Field { assert_eq!(x, y, \"fields differ\"); x } +fn constrained(x: Field, y: Field) -> Field { constrain_eq!(x, y, \"fields differ\"); x } +fn tuples(x: Pair, y: Pair) -> () { assert_eq!(x, y); } +fn arrays(x: [Field; 2], y: [Field; 2]) -> () { assert_eq!(x, y,); } +fn constrained_arrays(x: [Field; 2], y: [Field; 2]) -> () { constrain_eq!(x, y,); } +fn enums(x: Outer, y: Outer) -> () { assert_eq!(x, y, \"nested enum\",); } +fn structs(x: Box, y: Box) -> () { assert_eq!(x, y); } +fn units() -> () { assert_eq!((), ()); assert_eq!(([]: [Field; 0]), []); } +fn loaded() -> Field { + let p = &4; let q = &4; + assert_eq!(*p, *q, \"contents\"); 9 +} +fn ordered() -> Field { assert_eq!(*&3, *&3); 8 } +fn early() -> Field { assert_eq!(*&1, return 7, \"skipped\"); 0 } +fn skip() -> Field { match 0 { 0 => 5, _ => { assert_eq!(1, 2); 0 } } } +fn nested_failure() -> Field { debug!(\"before assertion\", 1); fields(1, 2) } +fn reduced() -> () { assert_eq!(0, 7); } +" + +#guard (source.findFunction? "fields").any fun f => match f.body with + | .letValue _ (.builtin (.assertEq ⟨some "fields differ", true⟩) [_, _]) _ => true + | _ => false + +#guard (source.findFunction? "constrained").any fun f => match f.body with + | .letValue _ (.builtin (.assertEq ⟨some "fields differ", false⟩) [_, _]) _ => true + | _ => false + +def inner (x y : Rat) : SourceValue Rat := .construct "Inner" "Pair" [.field x, .field y] +def outer (x y : Rat) : SourceValue Rat := .construct "Outer" "Some" [inner x y, .tuple [3, 4]] +def empty : SourceValue Rat := .construct "Outer" "Empty" [] +def box (x y : Rat) : SourceValue Rat := + .construct (Generic.Instance.symbol ⟨"Box", [.tuple [.field, .field]]⟩) Generic.structConstructor [.tuple [.field x, .field y]] +def failed (message : Option String := none) : Except String (SourceValue Rat × Heap Rat) := + .error (reprStr (EvalError.assertionFailed message)) + +def checks : List (String × List (SourceValue Rat) × Except String (SourceValue Rat × Heap Rat)) := [ + ("fields", [4, 4], .ok (4, [])), ("fields", [4, 5], failed (some "fields differ")), + ("constrained", [4, 4], .ok (4, [])), ("constrained", [4, 5], failed (some "fields differ")), + ("tuples", [.tuple [1, 2], .tuple [1, 2]], .ok (.tuple [], [])), + ("tuples", [.tuple [1, 2], .tuple [2, 1]], failed), + ("arrays", [.tuple [1, 2], .tuple [1, 2]], .ok (.tuple [], [])), + ("arrays", [.tuple [1, 2], .tuple [1, 3]], failed), + ("constrained_arrays", [.tuple [1, 2], .tuple [1, 2]], .ok (.tuple [], [])), + ("constrained_arrays", [.tuple [1, 2], .tuple [1, 3]], failed), + ("enums", [outer 1 2, outer 1 2], .ok (.tuple [], [])), + ("enums", [outer 1 2, outer 1 3], failed (some "nested enum")), + ("enums", [empty, outer 1 2], failed (some "nested enum")), + ("enums", [empty, empty], .ok (.tuple [], [])), + ("structs", [box 1 2, box 1 2], .ok (.tuple [], [])), + ("structs", [box 1 2, box 2 1], failed), + ("units", [], .ok (.tuple [], [])), ("loaded", [], .ok (9, [4, 4])), + ("ordered", [], .ok (8, [3, 3])), ("early", [], .ok (7, [1])), ("skip", [], .ok (5, [])) +] + +run_cmd do + let env ← Lean.getEnv + for text in [ + "fn f() -> () { assert_eq!(&0, &0); }", + "fn f() -> () { assert_eq!((1, &0), (1, &0)); }", + "fn f() -> () { assert_eq!((&[0; 2]: &[Field; 2]), &[0; 2]); }", + "fn f() -> () { let x: [&Field; 0] = []; assert_eq!(x, x); }", + "enum E { Empty, Pointer(&Field) } fn f() -> () { assert_eq!(E::Empty, E::Empty); }", + "struct S { p: &Field } fn f() -> () { let s = S { p: &0 }; assert_eq!(s, s); }", + "fn f(a: T) -> () { assert_eq!(a, a); }", + "fn f() -> () { assert_eq!(1, (1,)); }", + "fn f() -> () { assert_eq!([1], [1, 2]); }", + "fn f() -> () { constrain_eq!(&0, &0); }", + "fn f() -> () { constrain_eq!((1, &0), (1, &0)); }", + "fn f() -> () { constrain_eq!(1, (1,)); }" + ] do + match Generic.Frontend.ofString env text with + | .error _ => pure () + | .ok _ => throwError "unexpectedly accepted: {text}" + +instance : Fact (Nat.Prime 7) := ⟨by decide⟩ + +def checkRows : Except String Unit := do + let s ← Generic.prepare (source.toField Rat) + let q ← Generic.specialize s ["arrays"] + let c ← q.compile + let some chip := c.system.findChip? "arrays" | throw "missing assertion chip" + if chip.numVars != 4 then throw "array equality added auxiliary columns" + let type : Aiur.Ty := .tuple [.field, .field] + let left : WireValue Rat := ⟨type, [2, 3]⟩ + let unit : WireValue Rat := ⟨.tuple [], []⟩ + let row : Circuit.Row Rat := ⟨"arrays", [2, 3, 2, 3]⟩ + c.check {} ⟨"arrays", [left, left], unit⟩ [row] + c.checkMemo {} ⟨"arrays", [left, left], unit⟩ [⟨row, 1⟩] + for words in [[3, 3], [2, 4]] do + let right : WireValue Rat := ⟨type, words⟩ + let bad : Circuit.Row Rat := ⟨"arrays", [2, 3] ++ words⟩ + if (c.check {} ⟨"arrays", [left, right], unit⟩ [bad]).isOk then throw "unequal values accepted" + if (c.checkMemo {} ⟨"arrays", [left, right], unit⟩ [⟨bad, 1⟩]).isOk then throw "unequal memoized values accepted" + let q ← Generic.specialize s ["constrained_arrays"] + let c ← q.compile + let some constrained := c.system.findChip? "constrained_arrays" | throw "missing constrained equality chip" + if constrained.numVars != chip.numVars || constrained.constraints != chip.constraints then + throw "runtime flag changed equality constraints" + for words in [[3, 3], [2, 4]] do + let right : WireValue Rat := ⟨type, words⟩ + let bad : Circuit.Row Rat := ⟨"constrained_arrays", [2, 3] ++ words⟩ + if (c.check {} ⟨"constrained_arrays", [left, right], unit⟩ [bad]).isOk then + throw "deferred equality accepted an unequal circuit row" + +#guard checkRows == .ok () + +def run : IO Unit := do + let .ok s := Generic.prepare (source.toField Rat) | throw (IO.userError "assertion source failed to check") + for (name, args, expected) in checks do + let actual := s.run name args + unless actual == expected do throw (IO.userError s!"{name}: {repr actual}") + unless (s.runTraced name args).result == expected do throw (IO.userError s!"traced {name}") + let .ok specialized := Generic.specialize s [name] | throw (IO.userError s!"specializing {name}") + unless specialized.coreRun name args == expected do throw (IO.userError s!"lowered {name}") + let .ok _ := specialized.compile | throw (IO.userError s!"compiling {name}") + let traced := s.runTraced "nested_failure" [] + unless traced.result == failed (some "fields differ") && + traced.events.contains (.message "before assertion" [1]) && + traced.activeCalls == ["fields", "nested_failure"] do + throw (IO.userError s!"assertion diagnostics: {repr traced}") + let .ok small := Generic.prepare (source.toField (ZMod 7)) | throw (IO.userError "field conversion") + unless (small.run "reduced" []).isOk do throw (IO.userError "equality used natural literals instead of field values") + if let .error error := checkRows then throw (IO.userError error) + IO.println s!"Passed {checks.length * 3} assertion execution checks and {checks.length} compilations." + +end AiurAssertionTests diff --git a/Aiur/AiurTests/Blake3.lean b/Aiur/AiurTests/Blake3.lean new file mode 100644 index 000000000..186238eea --- /dev/null +++ b/Aiur/AiurTests/Blake3.lean @@ -0,0 +1,24 @@ +import Aiur.Library.Blake3 + +namespace AiurBlake3Tests +open Aiur + +def benchmark : Modules.Program Nat := aiur_library% Library.Blake3.templates " +module Benchmark { + fn generate(length: Field, byte: UInt8::U8) -> Blake3::ByteStream { + match length { + 0 => &Lists::Node::Nil, + _ => { + let (next, _) = UInt8::split_sum(UInt8::to_field(byte) + 1); + let tail = generate(length - 1, next); + &Lists::Node::Cons(byte, tail) + }, + } + } + fn main() -> Blake3::Digest { Blake3::hash(generate(1025, UInt8::BYTE_0)) } + fn hash(length: Field) -> [Field; 32] { + Blake3::address_to_fields(Blake3::digest_bytes(Blake3::hash(generate(length, UInt8::BYTE_0)))) + } +}" + +end AiurBlake3Tests diff --git a/Aiur/AiurTests/Carry.lean b/Aiur/AiurTests/Carry.lean new file mode 100644 index 000000000..ba58efe62 --- /dev/null +++ b/Aiur/AiurTests/Carry.lean @@ -0,0 +1,84 @@ +import Aiur.Modules +import Aiur.Library.Carry +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +namespace AiurCarryTests + +open Aiur + +set_option maxRecDepth 10000 + +instance : Fact (Nat.Prime 1009) := ⟨by decide⟩ + +def declarations : Program Nat := aiur% " +table inputs: (Field,) {} +table bytes: Field {} +table parts: (Field, Field) {} +map sum_byte(sum: Field) -> Field = inputs => bytes; +map old_split_sum(sum: Field) -> (Field, Field) = inputs => parts; +fn split_sum(sum: Field) -> (Field, Field) { + let byte = sum_byte(sum); + (byte, (sum - byte) / 256) +} +" + +def source : Program Nat := + let rows := Library.Carry.rows 256 768 + { declarations with tables := [ + ⟨"inputs", .tuple [.field], rows.map fun (n, _) => .tuple [.field n]⟩, + ⟨"bytes", .field, rows.map fun (_, byte) => .field byte⟩, + ⟨"parts", .tuple [.field, .field], + (Library.Carry.fullRows Nat 256 768).map fun (_, byte, carry) => + .tuple [.field byte, .field carry]⟩] } + +private def ensure (message : String) (condition : Bool) : IO Unit := + unless condition do throw (IO.userError message) + +private def get {α : Type} : Except String α → IO α + | .ok value => pure value + | .error message => throw (IO.userError message) + +private def checkField (F : Type) [Field F] [DecidableEq F] : IO Unit := do + let program := source.toField F + let compiled ← get <| Optimized.compile program ["split_sum"] + let some chip := compiled.system.findChip? "split_sum" | + throw (IO.userError "missing split_sum chip") + ensure "carry requires an extra column, equation, or lookup" + (chip.numVars == 2 && chip.constraints.isEmpty && chip.sends.length == 1 && + chip.sends.all (·.result.words.length == 1) && chip.stats.maxLookupDegree == 1) + for n in List.range 768 do + let byte : F := (n % 256 : Nat) + let carry : F := (n / 256 : Nat) + ensure "field carry disagrees with natural carry" (((n : F) - byte) / 256 == carry) + let root : Circuit.Message F := ⟨"split_sum", [.field n], .tuple [.field byte, .field carry]⟩ + let row : Circuit.Row F := ⟨"split_sum", [n, byte]⟩ + let _ ← get <| compiled.check ⟨[]⟩ root [row] + let _ ← get <| compiled.checkMemo ⟨[]⟩ root [⟨row, 1⟩] + let wrong := { root with result := .tuple [.field byte, .field (carry + 1)] } + ensure "checker accepted a wrong reconstructed carry" + (compiled.check ⟨[]⟩ wrong [row]).toOption.isNone + ensure "checker accepted an incorrect table byte" + (compiled.check ⟨[]⟩ root [⟨"split_sum", [n, byte + 1]⟩]).toOption.isNone + for n in ([(-1), 768] : List F) do + let root : Circuit.Message F := ⟨"split_sum", [.field n], .tuple [.field 0, .field (n / 256)]⟩ + let row : Circuit.Row F := ⟨"split_sum", [n, 0]⟩ + ensure "slim table admitted an input outside the original domain" + ((compiled.check ⟨[]⟩ root [row]).toOption.isNone && + (compiled.checkMemo ⟨[]⟩ root [⟨row, 1⟩]).toOption.isNone) + for n in [0, 255, 256, 511, 512, 767] do + ensure "slim wrapper changed source evaluation" + (eval program "split_sum" [.field n] == eval program "old_split_sum" [.field n]) + ensure "executor accepted a missing sum" + (eval program "split_sum" [.field 768]).toOption.isNone + +def run : IO Unit := do + checkField Rat + checkField (ZMod 1009) + IO.println "Passed carry checks: all 768 rows over Rat and F1009, both checkers, wrong outputs, and domain boundaries." + +#print axioms Library.Carry.recover +#print axioms Library.Carry.fullRows_iff +#print axioms Library.Carry.mapEntries_iff + +end AiurCarryTests diff --git a/Aiur/AiurTests/Circuit.lean b/Aiur/AiurTests/Circuit.lean new file mode 100644 index 000000000..5eb15440b --- /dev/null +++ b/Aiur/AiurTests/Circuit.lean @@ -0,0 +1,165 @@ +import Aiur.Scalar +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +open Aiur.Scalar Aiur.Scalar.Circuit + +namespace AiurCircuitTests + +def division : Program Nat := scalar_aiur% " +fn square(x) { x * x } +fn main(x, y) { square(x / y) } +" + +def matching : Program Nat := scalar_aiur% " +fn choose(x) { match x { 0 => 10, 2 => 20, _ => 30 } } +fn partial_match(x) { match x { 0 => 10 } } +fn discarded(x) { match x { _ => 11, 0 => discarded(x), 0 => 99 } } +" + +def nested : Program Nat := scalar_aiur% " +fn guarded(x) { + match x { + 0 => 7, + _ => match x { 1 => 1 / 0, _ => looping(x) }, + } +} +fn looping(x) { looping(x) } +" + +def recursion : Program Nat := scalar_aiur% " +fn even(n) { match n { 0 => 1, _ => odd(n - 1) } } +fn odd(n) { match n { 0 => 0, _ => even(n - 1) } } +" + +def repeated : Program Nat := scalar_aiur% " +fn square(x) { x * x } +fn twice(x) { square(x) + square(x) } +" + +def duplicates : Program Nat := scalar_aiur% "fn bad(x) { match x { 0 => 1, 0 => 2 } }" +def collisions : Program Nat := scalar_aiur% "fn bad(x) { match x { 0 => 1, 7 => 2, _ => 3 } }" + +private def checkedCompile [Field F] [DecidableEq F] (program : Program F) : IO (System F) := + match compile program with + | .ok system => pure system + | .error error => throw (IO.userError s!"unexpected compilation failure: {error}") + +private def check (label : String) (condition : Bool) : IO Unit := + unless condition do throw (IO.userError s!"circuit test failed: {label}") + +private def expect (label : String) (actual expected : Except WitnessError Unit) : IO Unit := + unless actual == expected do + throw (IO.userError s!"{label}: expected {repr expected}, got {repr actual}") + +private def rejects (label : String) (actual : Except WitnessError Unit) : IO Unit := + check label (match actual with | .error _ => true | .ok () => false) + +instance : Fact (Nat.Prime 7) := ⟨by decide⟩ + +def run : IO Unit := do + let arithmetic ← checkedCompile (division.toField Rat) + let entry : Message Rat := ⟨"main", [6, 2], 9⟩ + -- main: x, y, output, inverse(y), call result. square: x, output. + let divisionRow : Row Rat := ⟨"main", [6, 2, 9, 1 / 2, 9]⟩ + let calleeRow : Row Rat := ⟨"square", [3, 9]⟩ + let rows := [divisionRow, calleeRow] + expect "division and call" (arithmetic.check entry rows) (.ok ()) + expect "row order" (arithmetic.check entry rows.reverse) (.ok ()) + let reordered : System Rat := { arithmetic with chips := arithmetic.chips.map fun (chip : Chip Rat) => + { chip with constraints := chip.constraints.reverse, sends := chip.sends.reverse } } + expect "equation order" (reordered.check entry rows) (.ok ()) + expect "missing callee" (arithmetic.check entry [divisionRow]) (.error .unbalancedMessages) + expect "forged return value" + (arithmetic.check ⟨"main", [6, 2], 10⟩ + [⟨"main", [6, 2, 10, 1 / 2, 10]⟩, ⟨"square", [3, 9]⟩]) + (.error .unbalancedMessages) + expect "wrong callee arguments" + (arithmetic.check entry [divisionRow, ⟨"square", [4, 16]⟩]) (.error .unbalancedMessages) + rejects "incorrect inverse" + (arithmetic.check entry [⟨"main", [6, 2, 9, 1, 9]⟩, calleeRow]) + rejects "zero divided by zero" + (arithmetic.check ⟨"main", [0, 0], 0⟩ [⟨"main", [0, 0, 0, 0, 0]⟩, ⟨"square", [0, 0]⟩]) + expect "wrong row length" (arithmetic.check entry [⟨"main", [6, 2, 9]⟩]) + (.error (.wrongRowSize "main" 5 3)) + expect "unknown row chip" (arithmetic.check entry [⟨"unknown", []⟩]) + (.error (.unknownChip "unknown")) + + let choices ← checkedCompile (matching.toField Rat) + -- choose: x, output, match result, selectors for 0/2/default, default's two inverses. + expect "first literal" + (choices.check ⟨"choose", [0], 10⟩ [⟨"choose", [0, 10, 10, 1, 0, 0, 0, 0]⟩]) (.ok ()) + expect "second literal" + (choices.check ⟨"choose", [2], 20⟩ [⟨"choose", [2, 20, 20, 0, 1, 0, 0, 0]⟩]) (.ok ()) + expect "default excludes every literal" + (choices.check ⟨"choose", [3], 30⟩ [⟨"choose", [3, 30, 30, 0, 0, 1, 1 / 3, 1]⟩]) (.ok ()) + rejects "no branch selected" + (choices.check ⟨"choose", [0], 10⟩ [⟨"choose", [0, 10, 10, 0, 0, 0, 0, 0]⟩]) + rejects "wrong literal selected" + (choices.check ⟨"choose", [0], 20⟩ [⟨"choose", [0, 20, 20, 0, 1, 0, 0, 0]⟩]) + rejects "default cannot steal a literal case" + (choices.check ⟨"choose", [0], 30⟩ [⟨"choose", [0, 30, 30, 0, 0, 1, 1, -(1 / 2)]⟩]) + rejects "multiple branches selected" + (choices.check ⟨"choose", [0], 10⟩ [⟨"choose", [0, 10, 10, 1, 1, 0, 0, 0]⟩]) + rejects "fractional selector" + (choices.check ⟨"choose", [3], 30⟩ [⟨"choose", [3, 30, 30, 0, 0, 1 / 2, 1 / 3, 1]⟩]) + rejects "uncovered match, no selector" + (choices.check ⟨"partial_match", [1], 10⟩ [⟨"partial_match", [1, 10, 10, 0]⟩]) + rejects "uncovered match, forced selector" + (choices.check ⟨"partial_match", [1], 10⟩ [⟨"partial_match", [1, 10, 10, 1]⟩]) + expect "arms after wildcard discarded" + (choices.check ⟨"discarded", [0], 11⟩ [⟨"discarded", [0, 11, 11, 1]⟩]) (.ok ()) + check "discarded call has no send" ((choices.findChip? "discarded").any (·.sends.isEmpty)) + + let guarded ← checkedCompile (nested.toField Rat) + expect "inactive nested division and recursion" + (guarded.check ⟨"guarded", [0], 7⟩ + [⟨"guarded", [0, 7, 7, 1, 0, 0, 0, 0, 0, 0, 0, 0]⟩]) (.ok ()) + rejects "inactive nested match cannot select a branch" + (guarded.check ⟨"guarded", [0], 7⟩ + [⟨"guarded", [0, 7, 7, 1, 0, 0, 0, 0, 0, 1, -1, 0]⟩]) + rejects "active nested division by zero" + (guarded.check ⟨"guarded", [1], 0⟩ + [⟨"guarded", [1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0]⟩]) + expect "self-supporting recursive row is insufficient" + (guarded.check ⟨"looping", [1], 5⟩ [⟨"looping", [1, 5, 5]⟩]) (.error .unbalancedMessages) + + let recursiveSystem ← checkedCompile (recursion.toField Rat) + check "one chip per recursive function" (recursiveSystem.chips.length == 2) + expect "mutual recursion witness" + (recursiveSystem.check ⟨"even", [2], 1⟩ + [⟨"even", [0, 1, 1, 1, 0, 0, 0]⟩, + ⟨"even", [2, 1, 1, 0, 1, 1 / 2, 1]⟩, + ⟨"odd", [1, 1, 1, 0, 1, 1, 1]⟩]) (.ok ()) + + let twice ← checkedCompile (repeated.toField Rat) + let twiceEntry : Message Rat := ⟨"twice", [3], 18⟩ + let twiceRow : Row Rat := ⟨"twice", [3, 18, 9, 9]⟩ + let squareRow : Row Rat := ⟨"square", [3, 9]⟩ + expect "repeated messages count separately" + (twice.check twiceEntry [twiceRow, squareRow, squareRow]) (.ok ()) + expect "one receive cannot discharge two calls" + (twice.check twiceEntry [twiceRow, squareRow]) (.error .unbalancedMessages) + check "each call result is fresh" + ((twice.findChip? "twice").any fun chip => + chip.sends.length == 2 && decide ((chip.sends.map (·.result)).Nodup)) + + check "duplicate patterns rejected" + (match compile (duplicates.toField Rat) with + | .error (.duplicatePattern "bad") => true + | _ => false) + check "patterns checked after field conversion" + (match compile (collisions.toField (ZMod 7)) with + | .error (.duplicatePattern "bad") => true + | _ => false) + let finite ← checkedCompile (division.toField (ZMod 7)) + expect "finite-field division and call" + (finite.check ⟨"main", [6, 2], 2⟩ + [⟨"main", [6, 2, 2, 4, 2]⟩, ⟨"square", [3, 2]⟩]) (.ok ()) + let finiteChoices ← checkedCompile (matching.toField (ZMod 7)) + expect "finite-field default inverses" + (finiteChoices.check ⟨"choose", [3], 2⟩ + [⟨"choose", [3, 2, 2, 0, 0, 1, 5, 1]⟩]) (.ok ()) + IO.println "Passed circuit compilation and witness checks." + +end AiurCircuitTests diff --git a/Aiur/AiurTests/CircuitStats.lean b/Aiur/AiurTests/CircuitStats.lean new file mode 100644 index 000000000..4b440f1bd --- /dev/null +++ b/Aiur/AiurTests/CircuitStats.lean @@ -0,0 +1,82 @@ +import Aiur.Modules +import Mathlib.Algebra.Field.Rat + +open Aiur + +namespace AiurCircuitStatsTests + +def source : Modules.Program Nat := aiur% " +module Metrics { + fn square(x: Field) -> Field { x * x } + fn calls(x: Field) -> Field { + let a = square(x); + let b = square(x); + a + b + } + fn product(a: Field, b: Field, c: Field, d: Field) -> Field { a * b * c * d } + fn memory(x: Field) -> Field { let p = &x; *p } + fn choice(x: Field) -> Field { match x { 0 => square(x), _ => square(x + 1) } } + fn lookup_product(a: Field, b: Field, c: Field) -> Field { square(a * b * c) } + fn unit() -> () { () } + inline fn helper(x: Field) -> Field { x * x } + fn inlined(x: Field) -> Field { helper(x) } + table inputs: (Field, Field) { (1, 2) } + table outputs: Field { 3 } + map add(a: Field, b: Field) -> Field = Metrics::inputs => Metrics::outputs; + fn table_call() -> Field { add(1, 2) } +} +" + +private def checkEqual [DecidableEq α] [Repr α] + (label : String) (actual expected : α) : IO Unit := do + unless actual = expected do + throw (IO.userError s!"{label}: expected {repr expected}, got {repr actual}") + +def run : IO Unit := do + let get {α : Type} (r : Except String α) : IO α := match r with + | .ok value => pure value + | .error message => throw (IO.userError message) + let entries := ["calls", "product", "memory", "choice", "lookup_product", + "unit", "inlined", "table_call"].map ("Metrics::" ++ ·) + let p ← get <| Modules.prepare (source.toField Rat) entries + let compiled ← get p.compile + let system := compiled.circuit.system + checkEqual "chip order" (system.stats.map (·.name)) (system.chips.map (·.name)) + for expected in ([ + ⟨"Metrics::square", 2, 2, 0, 0, 1⟩, + ⟨"Metrics::calls", 4, 1, 2, 0, 1⟩, + ⟨"Metrics::product", 5, 4, 0, 0, 1⟩, + ⟨"Metrics::memory", 4, 1, 0, 2, 1⟩, + ⟨"Metrics::lookup_product", 5, 1, 1, 0, 3⟩, + ⟨"Metrics::unit", 0, 0, 0, 0, 0⟩, + ⟨"Metrics::inlined", 2, 2, 0, 0, 1⟩, + ⟨"Metrics::table_call", 2, 1, 1, 0, 1⟩ + ] : List Circuit.ChipStats) do + let some chip := system.findChip? expected.name | + throw (IO.userError s!"missing chip {expected.name}") + checkEqual expected.name chip.stats expected + let some choice := system.findChip? "Metrics::choice" | + throw (IO.userError "missing branch example") + checkEqual "both guarded call slots count" choice.stats.lookups 2 + checkEqual "inline helpers and maps have no chip" system.chips.length 9 + -- Even statically disabled slots occupy the chip's declared lookup list. + let disabledSends := choice.sends.map fun (send : Circuit.Send Rat) => + { send with enable := .const 0 } + let disabled := { choice with sends := disabledSends } + checkEqual "disabled call slots count" disabled.stats.callLookups 2 + -- Structural degree deliberately does not cancel equal terms. + let x : Circuit.ArithExpr Rat := .var 0 + let cubic : Circuit.ArithExpr Rat := .mul x (.mul x x) + let guarded : Circuit.ArithExpr Rat := .mul x (.sub cubic cubic) + checkEqual "structural degree includes guards" guarded.degree 4 + let outputOnly : Circuit.Chip Rat := { + name := "output", inputs := [.field 0], output := .field cubic, + numVars := 1, constraints := [], sends := [], memory := [] } + checkEqual "provided expressions count toward the degree bound" outputOnly.stats.maxLookupDegree 3 + checkEqual "provided claim does not add a required lookup slot" outputOnly.stats.lookups 0 + let empty : Circuit.System Rat := ⟨[], [], [], []⟩ + checkEqual "empty circuit" empty.stats [] + checkEqual "empty report" empty.formatStats "No chips." + IO.println "Passed circuit statistics checks (columns, degrees, call/map/ROM slots, and inlining)." + +end AiurCircuitStatsTests diff --git a/Aiur/AiurTests/CompilerIndex.lean b/Aiur/AiurTests/CompilerIndex.lean new file mode 100644 index 000000000..a6d8ab357 --- /dev/null +++ b/Aiur/AiurTests/CompilerIndex.lean @@ -0,0 +1,92 @@ +import Aiur.Optimized.AllocationCertificate +import Mathlib.Algebra.Field.Rat + +namespace AiurCompilerIndexTests +open Aiur Aiur.Optimized + +private def ensure (message : String) (condition : Bool) : IO Unit := + unless condition do throw (IO.userError message) + +private def referenceControl (chip : ScopedChip Rat) : Bool := + @decide (Control.Certificate chip) (by + unfold Control.Certificate Control.Choice.Checked + infer_instance) + +private def referenceAllocation (chip : ScopedChip Rat) (layout : ColumnLayout) : Bool := + @decide (Allocation.Certificate chip layout) (by + unfold Allocation.Certificate + infer_instance) + +set_option synthInstance.maxSize 4096 in +private def referenceDegree (source target : ScopedChip Rat) + (definitions : List (Degree.Definition Rat)) (values : Array (Polynomial Rat)) : Bool := + @decide (Degree.Certificate source target definitions values) (by + unfold Degree.Certificate + dsimp only + infer_instance) + +private def branches : ScopedChip Rat := { + name := "indexed branches" + inputs := [.field 0], output := .field 0 + roles := #[.input, .selector, .selector, .auxiliary 1, .auxiliary 2] + aliases := #[none, none, none, none, none] + scopes := #[⟨.const 1, []⟩, ⟨.var 1, [(0, 0)]⟩, ⟨.var 2, [(0, 1)]⟩] + choices := #[⟨0, [1, 2]⟩] + equations := #[⟨0, .sub (.add (.var 1) (.var 2)) (.const 1)⟩, + ⟨0, .mul (.var 2) (.var 1)⟩, + ⟨1, .sub (.var 3) (.var 0)⟩, ⟨2, .sub (.var 4) (.var 0)⟩] + calls := #[], cells := #[] } + +private def shared : ColumnLayout := + ⟨#[some 0, some 1, some 2, some 3, some 3], #[[0], [1], [2], [3, 4]]⟩ + +def run : IO Unit := do + let missing := { branches with equations := branches.equations.extract 1 4 } + let guarded := { branches with + equations := branches.equations.modify 0 (fun eq => { eq with scope := 1 }) } + -- Same index key, different field constant: indexing must not authorize it. + let collision := { branches with + equations := branches.equations.set! 0 ⟨0, .sub (.add (.var 1) (.var 2)) (.const 2)⟩ } + let normalized := { branches with + equations := branches.equations.map (fun eq => { eq with polynomial := .add (.const 0) eq.polynomial }) } + for (chip, expected) in [(branches, true), (missing, false), (guarded, false), + (collision, false), (normalized, true)] do + ensure "indexed control certificate disagreed with exhaustive checking" + (decide (Control.Certificate chip) == referenceControl chip) + ensure "indexed control certificate lost or invented a global equation" + (decide (Control.Certificate chip) == expected) + let aliasedInput := { shared with columnOf := shared.columnOf.set! 3 (some 0) } + let aliasedSelectors := { shared with columnOf := shared.columnOf.set! 2 (some 1) } + let unallocated := { shared with columnOf := shared.columnOf.set! 3 none } + for (layout, expected) in [(shared, true), (aliasedInput, false), + (aliasedSelectors, false), (unallocated, false)] do + ensure "indexed allocation certificate disagreed with all-pairs checking" + (decide (Allocation.Certificate branches layout) == referenceAllocation branches layout) + ensure "allocation certificate accepted simultaneous column occupants" + (decide (Allocation.Certificate branches layout) == expected) + let quartic := { branches with + equations := branches.equations.push ⟨1, + .sub (.var 3) (.mul (.mul (.var 0) (.var 0)) (.mul (.var 0) (.var 0)))⟩ } + let state ← IO.ofExcept (Degree.boundState {} quartic) + ensure "degree fixture did not allocate a product witness" (!state.cache.isEmpty) + let values := Degree.expand state.chip.roles.size state.cache + let missing := { state.chip with equations := #[] } + let misplaced := { state.chip with + equations := state.chip.equations.map fun eq => { eq with scope := 0 } } + let wrongConstant := { state.chip with + equations := state.chip.equations.map fun eq => + { eq with polynomial := .add eq.polynomial (.const 1) } } + for (target, expected) in [(state.chip, true), (missing, false), + (misplaced, false), (wrongConstant, false)] do + let checked := decide (Degree.Certificate quartic target state.cache values) + ensure "indexed degree certificate disagreed with exhaustive checking" + (checked == referenceDegree quartic target state.cache values) + ensure "degree certificate lost a defining equation or its scope" (checked == expected) + IO.println "Passed compiler-index checks: normalization, collisions, global equations, degree definitions, and exclusive column sharing." + +#print axioms Index.getD_build +#print axioms Control.zeroEquation_iff_indexed +#print axioms Allocation.sharing_iff_indexed +#print axioms EquationIndex.member_build + +end AiurCompilerIndexTests diff --git a/Aiur/AiurTests/Consts.lean b/Aiur/AiurTests/Consts.lean new file mode 100644 index 000000000..25422793e --- /dev/null +++ b/Aiur/AiurTests/Consts.lean @@ -0,0 +1,198 @@ +import Aiur.Generic +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +namespace AiurConstTests +open Aiur +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 +instance : Fact (Nat.Prime 101) := ⟨by decide⟩ + +def source : Generic.Program Nat := aiur% " +const ptr = &(::zero,); +const zero = 0; +const Pair = (one, ::one); +const one = 1; +const aliasOne = one; +const unit = (); +const empty = Maybe::None; +const fixed = Maybe::::None; +const somePtr = Maybe::Some(::ptr); +const nested = &Maybe::Some((Pair, ptr)); +type Maybe = Option; +enum Option { None, Some(T) } + +fn scalar() -> Field { zero + ::one } +fn shadow(zero: Field) -> Field { let one = zero; one + ::one } +fn before_binding() -> Field { let one = one + 1; one } +fn closed_template(one: Field) -> Field { aliasOne } +fn upper() -> Field { match 7 { Pair => Pair } } +fn lower(x: Field) -> Field { match x { ::zero => 17, zero => zero } } +fn branch_scope(x: Field) -> Field { match x { 0 => { let one = 9; one }, one => one + ::one } } +fn make() -> &(Field,) { ::ptr } +fn repeated() -> (&(Field,), &(Field,)) { (::ptr, ptr) } +fn inspect(p: &(Field,)) -> Field { match p { ::ptr => 7, _ => 9 } } +fn main(x: Field) -> Field { inspect(&(x,)) } +fn let_match(x: Field) -> Field { let ::ptr = &(x,); 11 } +fn deep() -> Field { let ::nested = nested; 13 } +fn inferred() -> Option<(Field, Field)> { empty } +fn explicit() -> Option { fixed } +fn enum_match() -> Field { match somePtr { ::somePtr => 23, _ => 29 } } +fn nullary(::unit: ()) -> Field { 31 } +fn call_unit() -> Field { nullary(unit) } +fn lazy() -> Field { match 0 { 0 => 37, _ => { let ::ptr = &(1,); 1 / 0 } } } +fn generic(x: Option) -> Field { match x { ::empty => 41, _ => 43 } } +fn generic_entry() -> Field { generic(Option::::None) } +" + +#guard source.consts.length == 10 +#guard source.aliases.length == 1 +#guard (source.findFunction? "make").map (·.body) == some (.global "ptr" (some (.ptr (.tuple [.field])))) + +def runSource (name : String) (args : List (SourceValue Rat) := []) := do + let s ← Generic.prepare (source.toField Rat) + s.run name args + +def runSpecialized (name : String) (args : List (SourceValue Rat) := []) := do + let s ← Generic.prepare (source.toField Rat) + let q ← Generic.specialize s [name] + q.run name args + +#guard runSource "scalar" == .ok (.field 1, []) +#guard runSource "shadow" [.field 5] == .ok (.field 6, []) +#guard runSource "before_binding" == .ok (.field 2, []) +#guard runSource "closed_template" [.field 99] == .ok (.field 1, []) +#guard runSource "upper" == .ok (.field 7, []) +#guard runSource "lower" [.field 0] == .ok (.field 17, []) +#guard runSource "lower" [.field 3] == .ok (.field 3, []) +#guard runSource "branch_scope" [.field 0] == .ok (.field 9, []) +#guard runSource "branch_scope" [.field 4] == .ok (.field 5, []) +#guard runSource "repeated" == .ok + (.tuple [.ptr (.tuple [.field]) 0, .ptr (.tuple [.field]) 1], [.tuple [.field 0], .tuple [.field 0]]) +#guard runSpecialized "main" [.field 0] == .ok (.field 7, [.tuple [.field 0]]) +#guard runSpecialized "main" [.field 1] == .ok (.field 9, [.tuple [.field 1]]) +#guard runSource "let_match" [.field 0] == .ok (.field 11, [.tuple [.field 0]]) +#guard runSource "let_match" [.field 1] == .error (reprStr EvalError.patternMismatch) +#guard (runSpecialized "deep").map Prod.fst == .ok (.field 13) +#guard runSpecialized "inferred" == runSource "inferred" +#guard (runSpecialized "enum_match").map Prod.fst == .ok (.field 23) +#guard runSource "call_unit" == .ok (.field 31, []) +#guard runSource "lazy" == .ok (.field 37, []) +#guard runSource "generic_entry" == .ok (.field 41, []) + +#guard (do + let s ← Generic.prepare (source.toField (ZMod 101)) + let q ← Generic.specialize s ["main", "repeated", "deep", "enum_match", "lazy", "generic_entry", "let_match"] + return (← q.compile).system.chips.length).toOption.isSome + +def tables : Generic.Program Nat := aiur% " +const a = 1; +const b = 2; +const Key = (::a, ::b); +table keys: (Field, Field) { ::Key } +table outputs: Field { b } +map lookup(x: Field, y: Field) -> Field = keys => outputs; +fn main() -> Field { lookup(a, b) } +" +#guard (do + let s ← Generic.prepare (tables.toField Rat) + let q ← Generic.specialize s ["main"] + q.run "main" []) == .ok (.field 2, []) + +def fieldCollision : Generic.Program Nat := aiur% " +const a = &1; +const b = &102; +fn test(p: &Field) -> Field { match p { ::a => 1, ::b => 2, _ => 3 } } +" +#guard (Generic.prepare (fieldCollision.toField (ZMod 101))).toOption.isNone + +def literalCollision : Generic.Program Nat := aiur% " +const a = 1; +const b = 102; +fn main(x: Field) -> Field { match x { ::a => 7, ::b => 8, _ => 9 } } +" +#guard (do + let s ← Generic.prepare (literalCollision.toField (ZMod 101)) + let q ← Generic.specialize s ["main"] + return (← q.compile).system.chips.length).toOption.isNone + +def tableCollision : Generic.Program Nat := aiur% " +const a = 1; +const b = 102; +table inputs: (Field,) { (a,), (b,) } +table outputs: Field { 0, 1 } +map lookup(x: Field) -> Field = inputs => outputs; +" +#guard (Generic.prepare (tableCollision.toField (ZMod 101))).toOption.isNone + +def handBuilt : Generic.Program Nat := { + consts := [⟨"zero", .literal 0⟩, ⟨"cell", .load (.global "zero")⟩] + functions := [{ + name := "main", params := [], result := .field + body := .letValue (.global "cell") (.global "cell") (.literal 7) + }] +} +#guard (do + let s ← Generic.prepare (handBuilt.toField Rat) + s.run "main" []) == .ok (.field 7, [.field 0]) +#guard (Generic.prepare (({ handBuilt with consts := [⟨"bad", .bind "x"⟩] }).toField Rat)).toOption.isNone +#guard (Generic.prepare (({ handBuilt with consts := [⟨"bad", .wildcard⟩] }).toField Rat)).toOption.isNone + +run_cmd do + for code in [ + "const A = ::A;", + "const a = b; const b = &a;", + "const a = ::b; const b = &::a;", + "const a = (0, ::b); const b = (1, ::c); const c = ::a;", + "const a = ::unknown;", + "const a = 0; const a = 1;", + "const a = x;", + "const a = _;", + "const a = &(0, _);", + "const a = 1 + 2;", + "const a = *(&0);", + "const a = hint::(0);", + "const a = Missing::A;", + "enum E { A } const a = E::B;", + "enum E { A(Field) } const a = E::A;", + "enum E { A(Field) } const a = E::A(());", + "enum E { A(T, T) } const a = E::A(0, ());", + "enum E { A } const a = E::::A;", + "const a = 0; fn a() -> Field { 0 }", + "const a = 0; table keys: () {} table outputs: Field {} map a() -> Field = keys => outputs;", + "fn main() -> Field { ::missing }", + "fn main(missing: Field) -> Field { ::missing }", + "fn main(x: Field) -> Field { match x { ::missing => 0, _ => 1 } }", + "const a = &0; fn f(x: Field) -> Field { let ::a = x; 0 }", + "const a = 0; fn f(::a: Field) -> Field { 1 }", + "const a = &0; table cells: &Field { a }" + ] do + match Generic.Frontend.ofString (← Lean.getEnv) code with + | .error _ => pure () + | .ok _ => throwError "unexpectedly accepted: {code}" + match Frontend.ofString (← Lean.getEnv) "const a = 0; fn main() -> Field { 0 }" with + | .error _ => pure () + | .ok _ => throwError "legacy frontend discarded a const declaration" + +def run : IO Unit := do + let checks := [ + ("const expression", runSource "scalar", .ok (.field 1, [])), + ("const shadowing", runSource "shadow" [.field 5], .ok (.field 6, [])), + ("const pointer match", runSpecialized "main" [.field 0], .ok (.field 7, [.tuple [.field 0]])), + ("const pointer fallback", runSpecialized "main" [.field 1], .ok (.field 9, [.tuple [.field 1]])), + ("const refutable let", runSource "let_match" [.field 1], .error (reprStr EvalError.patternMismatch)), + ("const inactive body", runSource "lazy", .ok (.field 37, [])) + ] + for (name, actual, expected) in checks do + unless actual = expected do throw (IO.userError s!"{name}: expected {repr expected}, got {repr actual}") + IO.println s!"Passed {checks.length} const execution checks." + +example (p : Generic.Program Nat) (F : Type) [NatCast F] : + Generic.expandConsts (p.toField F) = (Generic.expandConsts p).map (fun q => q.toField F) := + Generic.expandConsts_toField p F + +/-- info: 'Aiur.Generic.expandConsts_toField' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.expandConsts_toField + +end AiurConstTests diff --git a/Aiur/AiurTests/Control.lean b/Aiur/AiurTests/Control.lean new file mode 100644 index 000000000..9bffcd0ce --- /dev/null +++ b/Aiur/AiurTests/Control.lean @@ -0,0 +1,194 @@ +import Aiur.Generic +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +namespace AiurControlTests +open Aiur +set_option maxRecDepth 20000 +set_option maxHeartbeats 8000000 + +/-- Keep the source exits visible through checking and field conversion. -/ +def source : Generic.Program Nat := aiur% " +type Pair = (Field, Field); +const seven = 7; +enum Answer { Empty, Pair(Pair) } +fn chosen(x: Field) -> Field { + let y = 'chosen: { + match x { 0 => break 'chosen seven, 1 => return 20, _ => () }; + 9 + }; + y + 1 +} +fn shadow() -> Field { + let x = 3; + let y = 'b: { let x = 100; break 'b 7; }; + x + y +} +fn outer() -> Field { + 'outer: { let x = 'inner: { break 'outer 5; }; x + 100 } +} +fn same_label() -> Field { + 'b: { let x = 'b: { break 'b 5; }; break 'b (x + 1); } +} +fn precedence() -> Field { return 3 + 4 * 2; 1 / 0 } +fn return_payload() -> Field { return (return 11); } +fn break_payload() -> Field { 'b: { break 'b (return 12); } } +fn return_block() -> Field { return 'b: { break 'b 4; }; } +fn callee() -> Field { return 4; } +fn caller() -> Field { callee() + 1 } +fn caller_block() -> Field { 'b: { let x = callee(); break 'b (x + 2); } } +fn add(x: Field, y: Field) -> Field { x + y } +fn call_args() -> Field { add(*&1, { return 7; }) } +fn skip_calls() -> Field { return 8; forever() } +fn forever() -> Field { forever() } +fn skip_right() -> Field { (return 9) + 1 / 0 } +fn right_effect() -> Field { *&1 + (return 10) } +fn tuple_exit() -> Field { let x = (*&1, return 13, *&2); 0 } +fn array_exit() -> Field { let a = [*&1, return 14, *&2]; 0 } +fn repeat_exit() -> Field { let a = [return 15; 0]; 0 } +fn store_exit() -> Field { let p = &(return 16); 0 } +fn load_exit() -> Field { let x = *(return 17); 0 } +fn key_exit() -> Field { hint::({ return 18; }) } +fn skip_hint() -> Field { return 19; hint::(()) } +fn early(x: T) -> T { return x; } +fn generic() -> Pair { early((2, 3)) } +fn pointer() -> Field { let p = 'b: { break 'b &5; }; let &x = p; return x; } +fn enumeration() -> Answer { return Answer::Pair((5, 6)); } +fn match_statement(x: Field) -> Field { match x { 0 => return 23, _ => return 24 }; } +fn final_let() -> () { let x = 3; } +fn hinted(x: Field) -> Field { + let key = 'b: { match x { 0 => return 7, _ => break 'b *&3 } }; + return hint::(key); +} +fn unit() -> () { return; } +fn empty() -> () {} +fn unit_block() -> Field { 'b: { break 'b; }; 21 } +fn nested_payload() -> Field { 'a: { 'b: { break 'b (break 'a 22); } } } +fn loop(n: Field) -> Field { match n { 0 => return 0, _ => return loop(n - 1) + 1 } } +fn branch_calls(x: Field) -> Field { + let y = 'b: { match x { 0 => return 7, _ => break 'b callee() } }; + add(y, 2) +} +" + +#guard (source.findFunction? "callee").map (·.body) == + some (.control (.exit .function) (.literal 4)) +#guard (source.findFunction? "shadow").any fun definition => Generic.ControlLower.hasControl definition.body + +abbrev Result := Except String (SourceValue Rat × Heap Rat) + +def checks : List (String × List (SourceValue Rat) × Result) := [ + ("chosen", [0], .ok (8, [])), ("chosen", [1], .ok (20, [])), ("chosen", [2], .ok (10, [])), + ("shadow", [], .ok (10, [])), ("outer", [], .ok (5, [])), ("same_label", [], .ok (6, [])), + ("precedence", [], .ok (11, [])), ("return_payload", [], .ok (11, [])), + ("break_payload", [], .ok (12, [])), ("return_block", [], .ok (4, [])), + ("caller", [], .ok (5, [])), ("caller_block", [], .ok (6, [])), + ("call_args", [], .ok (7, [1])), ("skip_calls", [], .ok (8, [])), + ("skip_right", [], .ok (9, [])), ("right_effect", [], .ok (10, [1])), + ("tuple_exit", [], .ok (13, [1])), ("array_exit", [], .ok (14, [1])), + ("repeat_exit", [], .ok (15, [])), ("store_exit", [], .ok (16, [])), + ("load_exit", [], .ok (17, [])), ("key_exit", [], .ok (18, [])), + ("skip_hint", [], .ok (19, [])), ("generic", [], .ok (.tuple [2, 3], [])), + ("pointer", [], .ok (5, [5])), ("enumeration", [], .ok (.construct "Answer" "Pair" [.tuple [5, 6]], [])), + ("match_statement", [0], .ok (23, [])), ("match_statement", [1], .ok (24, [])), + ("final_let", [], .ok (.tuple [], [])), + ("unit", [], .ok (.tuple [], [])), ("empty", [], .ok (.tuple [], [])), + ("unit_block", [], .ok (21, [])), ("nested_payload", [], .ok (22, [])), + ("loop", [4], .ok (4, [])), + ("branch_calls", [0], .ok (7, [])), ("branch_calls", [1], .ok (6, [])) +] + +def checkExecutions : Except String Unit := do + let s ← Generic.prepare (source.toField Rat) + for (name, args, expected) in checks do + let q ← Generic.specialize s [name] + for (mode, actual) in [("source", s.run name args), ("specialized", q.run name args), + ("core", q.coreRun name args)] do + if actual != expected then throw s!"{name} ({mode}): expected {repr expected}, got {repr actual}" + let _ ← q.compile + +#guard checkExecutions == .ok () + +-- The dynamic hint key retains ordinary allocations; an earlier return skips it. +#guard (do + let s ← Generic.prepare (source.toField Rat) + let q ← Generic.specialize s ["hinted"] + let provider : HintDispatcher Rat := fun _ key => match key with + | .field 3 => .ok (.field (29 : Rat)) + | _ => .error HintError.unavailable + let direct := s.checkedHints provider + let core := HintProvider.checked q.program.enums provider + return [s.run "hinted" [1] (hints := direct), q.run "hinted" [1] (hints := direct), + q.coreRun "hinted" [1] (hints := core), q.coreRun "hinted" [0]]) = + .ok [.ok (29, [3]), .ok (29, [3]), .ok (29, [3]), .ok (7, [])] + +#guard (do + let s ← Generic.prepare (source.toField Rat) + s.run "callee" [] 0) == .error (reprStr EvalError.outOfFuel) + +-- A concrete row on the return arm requires no callee proof. Its inactive +-- call output is arbitrary. On the other arm the lookup must be discharged. +def circuitSource : Generic.Program Nat := aiur% " +fn risky(x: Field) -> Field { 1 / x } +fn main(x: Field) -> Field { + let y = 'b: { match x { 0 => return 7, _ => break 'b risky(x) } }; + y + 2 +} +" + +def checkRows : Except String Unit := do + let s ← Generic.prepare (circuitSource.toField Rat) + let q ← Generic.specialize s ["main"] + let c ← q.compile + let returned : Circuit.Row Rat := ⟨"main", [0, 7, 7, 1, 0, 1, 0, 123]⟩ + let resumed : Circuit.Row Rat := ⟨"main", [2, 5/2, 5/2, 0, 1/2, 0, 1, 1/2]⟩ + let callee : Circuit.Row Rat := ⟨"risky", [2, 1/2, 1/2]⟩ + c.check {} ⟨"main", [0], 7⟩ [returned] + c.checkMemo {} ⟨"main", [0], 7⟩ [⟨returned, 1⟩] + c.check {} ⟨"main", [2], .field (5/2)⟩ [resumed, callee] + c.checkMemo {} ⟨"main", [2], .field (5/2)⟩ [⟨resumed, 1⟩, ⟨callee, 1⟩] + if (c.check {} ⟨"main", [2], .field (5/2)⟩ [resumed]).isOk then throw "missing active call accepted" + if (c.check {} ⟨"main", [0], 8⟩ [returned]).isOk then throw "incorrect return accepted" + +#guard checkRows == .ok () + +instance : Fact (Nat.Prime 101) := ⟨by decide⟩ +#guard (do + let s ← Generic.prepare (source.toField (ZMod 101)) + let q ← Generic.specialize s ["chosen", "loop", "generic", "pointer", "branch_calls"] + let _ ← q.compile + q.coreRun "chosen" [0]) == .ok (8, []) + +-- Ill-scoped exits are rejected before specialization, including unused code. +run_cmd do + let env ← Lean.getEnv + for code in [ + "fn f() -> Field { break 'missing 0; }", + "fn f() -> Field { 'b: { break 'b (); 1 } }", + "fn f() -> Field { return (); }", + "fn f() -> () { return 0; }", + "fn f() -> Field { return; }", + "fn f() -> Field { 'b: { break 'b; } }", + "fn f() -> Field { 'b: { 0 }; break 'b 1; }", + "fn f() -> Field { 'b: { g() } } fn g() -> Field { break 'b 0; }", + "table t: Field { return 0 }", + "const x = return 0;", + "fn f() -> Field { @ b: { 0 } }" + ] do + match Generic.Frontend.ofString env code with + | .error _ => pure () + | .ok _ => throwError "unexpectedly accepted: {code}" + +/-- info: 'Aiur.Generic.ControlLower.function_correct' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.ControlLower.function_correct +/-- info: 'Aiur.Generic.SourceSemantics.evalFunction_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.SourceSemantics.evalFunction_spec + +def run : IO Unit := do + match checkExecutions *> checkRows with + | .ok () => IO.println s!"Passed {3 * checks.length} control-flow execution checks and {checks.length} compilations." + | .error e => throw (IO.userError e) + +end AiurControlTests diff --git a/Aiur/AiurTests/Diagnostics.lean b/Aiur/AiurTests/Diagnostics.lean new file mode 100644 index 000000000..7077217ca --- /dev/null +++ b/Aiur/AiurTests/Diagnostics.lean @@ -0,0 +1,103 @@ +import Aiur.Generic +import Mathlib.Algebra.Field.Rat + +namespace AiurDiagnosticTests +open Aiur +set_option maxRecDepth 20000 +set_option maxHeartbeats 8000000 + +def source : Generic.Program Nat := aiur% " +type Pair = (T, T); +enum Option { None, Some(T) } +struct Box { value: T } +fn identity(x: T) -> T { let y: T = x; (y: T) } +fn annotated() -> Field { + let (a, b): Pair = (3, 4); + let empty: Option = Option::None; + let box: Box<[Field; 0]> = Box { value: [] }; + let p: &Field = &a; + identity((*p: Field)) + b +} +fn say(x: Field) -> Field { debug!(\"callee\", x); x + 1 } +fn logged() -> Field { + debug!(\"before\"); + debug!(\"values\", say(*&1), *&2,); + debug!(\"after\", ()); + 9 +} +fn escaped() -> () { debug!(\"/* kept */ // ' @ & > ..= \\\"quoted\\\" \\\\ \\n\"); } +fn early() -> Field { debug!(\"discarded\", *&1, return 7, 1 / 0); 0 } +fn block() -> Field { 'done: { debug!(\"discarded\", break 'done 8); 0 } } +fn skip() -> Field { match 0 { 0 => 5, _ => { debug!(\"inactive\"); 0 } } } +fn failing() -> Field { debug!(\"retained\", 4); 1 / 0 } +fn failure() -> Field { failing() } +fn forever() -> Field { debug!(\"loop\"); forever() } +" + +#guard (source.findFunction? "identity").any fun f => match f.body with + | .letValue _ (.builtin (.ascribe _) [_]) (.builtin (.ascribe _) [_]) => true + | _ => false + +def checks : List (String × Except String (SourceValue Rat × Heap Rat)) := [ + ("annotated", .ok (7, [3])), + ("logged", .ok (9, [1, 2])), + ("escaped", .ok (.tuple [], [])), + ("early", .ok (7, [1])), ("block", .ok (8, [])), ("skip", .ok (5, [])) +] + +run_cmd do + let env ← Lean.getEnv + -- Character preprocessing must handle realistic source sizes in the + -- elaborator's interpreter without one stack frame per character. + let long := String.ofList (List.replicate 100000 'x') + unless Generic.Frontend.prepareSource long == .ok long do + throwError "large source changed during character preprocessing" + let spaces := String.ofList (List.replicate 100004 ' ') + unless Generic.Frontend.prepareSource ("/*" ++ long ++ "*/") == .ok spaces do + throwError "large block comment was not masked correctly" + for text in [ + "fn f() -> Field { let x: () = 1; 0 }", + "fn f() -> Field { ((): Field) }", + "fn f() -> () { let x: Missing = (); }", + "fn f() -> Field { (1: &Field) }", + "fn f() -> () { debug!(1); }", + "fn f() -> () { debug!(\"unterminated); }", + "fn f() -> () { @bad: {} }" + ] do + match Generic.Frontend.ofString env text with + | .error _ => pure () + | .ok _ => throwError "unexpectedly accepted: {text}" + +def run : IO Unit := do + let .ok s := Generic.prepare (source.toField Rat) | throw (IO.userError "diagnostic source failed to check") + for (name, expected) in checks do + let actual := s.run name [] + unless actual == expected do throw (IO.userError s!"{name}: {repr actual}") + let traced := s.runTraced name [] + unless traced.result == expected && traced.activeCalls.isEmpty do + throw (IO.userError s!"traced {name}: {repr traced}") + let .ok specialized := Generic.specialize s [name] | throw (IO.userError s!"specializing {name}") + unless specialized.coreRun name [] == expected do throw (IO.userError s!"lowered {name}") + let .ok _ := specialized.compile | throw (IO.userError s!"compiling {name}") + let traced := s.runTraced "logged" [] + let expected : List (Generic.TraceEvent Rat) := [ + .enter "logged" [], .message "before" [], .enter "say" [1], + .message "callee" [1], .leave "say" 2, .message "values" [2, 2], + .message "after" [.tuple []], .leave "logged" 9] + unless traced.events == expected do throw (IO.userError s!"trace order: {repr traced.events}") + unless (s.runTraced "escaped" []).events.contains + (.message "/* kept */ // ' @ & > ..= \"quoted\" \\ \n" []) do + throw (IO.userError "message text was changed by frontend preprocessing") + for name in ["early", "block", "skip"] do + unless (s.runTraced name []).events.all (fun e => match e with | .message _ _ => false | _ => true) do + throw (IO.userError s!"emitted incomplete or inactive message: {name}") + let failed := s.runTraced "failure" [] + unless failed.result == s.run "failure" [] && failed.activeCalls == ["failing", "failure"] && + failed.events.contains (.message "retained" [4]) do + throw (IO.userError s!"lost failure trace: {repr failed}") + for fuel in [0, 1, 2, 10, 20] do + unless (s.runTraced "forever" [] fuel).result == s.run "forever" [] fuel do + throw (IO.userError "tracing changed the fuel bound") + IO.println "Passed annotation and diagnostic checks." + +end AiurDiagnosticTests diff --git a/Aiur/AiurTests/EnumEncoding.lean b/Aiur/AiurTests/EnumEncoding.lean new file mode 100644 index 000000000..def239643 --- /dev/null +++ b/Aiur/AiurTests/EnumEncoding.lean @@ -0,0 +1,97 @@ +import Aiur.Frontend +import Aiur.Circuit.Compile +import Aiur.WireBoundary +import Mathlib.Algebra.Field.Rat + +open Aiur + +namespace AiurEnumEncodingTests + +set_option maxRecDepth 10000 +set_option maxHeartbeats 1000000 + +def program : Program Nat := aiur% r#" +enum Maybe { None, Some(Field) } +enum Inner { A, B } +enum Outer { Raw(Field), Nested(Inner) } +enum Box { Empty, Full(&Field) } +enum Product { A(Field, Field), B((Field, Field)) } +fn identity(x: Maybe) -> Maybe { x } +"# + +private def checks : List (String × Bool) := [ + ("canonical nullary encoding", + decide ((Value.construct "Maybe" "None" [] : Value Rat).encode program.enums = + some ⟨.enum "Maybe", [0, 0]⟩)), + ("payload encoding", + decide ((Value.construct "Maybe" "Some" [7] : Value Rat).encode program.enums = + some ⟨.enum "Maybe", [1, 7]⟩)), + ("invalid tag rejected", decide ((⟨.enum "Maybe", [2, 0]⟩ : WireValue Rat).decode program.enums = none)), + ("nonzero padding rejected", decide ((⟨.enum "Maybe", [0, 7]⟩ : WireValue Rat).decode program.enums = none)), + ("wrong width rejected", decide ((⟨.enum "Maybe", [0]⟩ : WireValue Rat).decode program.enums = none)), + ("inactive variant does not restrict raw payload", + decide ((⟨.enum "Outer", [0, 7]⟩ : WireValue Rat).decode program.enums = + some (.construct "Outer" "Raw" [7]))), + ("nested tags decoded", + decide ((⟨.enum "Outer", [1, 1]⟩ : WireValue Rat).decode program.enums = + some (.construct "Outer" "Nested" [.construct "Inner" "B" []]))), + ("invalid active nested tag rejected", + decide ((⟨.enum "Outer", [1, 7]⟩ : WireValue Rat).decode program.enums = none)), + ("malformed constructor rejected", + decide ((Value.construct "Maybe" "None" [7] : Value Rat).encode program.enums = none)), + ("pointer payload retains its target type", + decide ((⟨.enum "Box", [1, 9]⟩ : WireValue Rat).decode program.enums = + some (.construct "Box" "Full" [.ptr .field 9]))), + ("constructor arguments and tuple arguments remain distinct", + decide ((⟨.enum "Product", [1, 3, 4]⟩ : WireValue Rat).decode program.enums = + some (.construct "Product" "B" [.tuple [3, 4]]))) +] + +/-- Check actual generated polynomial equations with explicit auxiliary columns. -/ +private def constraintsHold (name : String) (enable : Rat) (words witness : List Rat) : Bool := + match program.enums.layout (.enum name) with + | .error _ => false + | .ok layout => + match Circuit.Compiler.validate layout (.const enable) (words.map Circuit.ArithExpr.const) {} with + | .error _ => false + | .ok (_, state) => decide (state.nextVar = witness.length) && + state.constraints.toList.all (fun polynomial => + decide (polynomial.denote (fun id => witness.getD id 0) = 0)) + +private def constraintsChecks : List (String × Bool) := [ + ("valid tag and zero padding", constraintsHold "Maybe" 1 [0, 0] [1, 0, 0, -1]), + ("padding constrained", !constraintsHold "Maybe" 1 [0, 7] [1, 0, 0, -1]), + ("invalid tag constrained", !constraintsHold "Maybe" 1 [2, 0] [0, 1/2, 0, 1]), + ("inactive value may be noncanonical", constraintsHold "Maybe" 0 [2, 7] [0, 1/2, 0, 1]), + ("unselected nested enum does not restrict raw field", constraintsHold "Outer" 1 [0, 7] + [1, 0, 0, -1, 0, 1/7, 0, 1/6]), + ("selected nested enum is constrained", !constraintsHold "Outer" 1 [1, 7] + [0, 1, 1, 0, 0, 1/7, 0, 1/6]), + ("selected nested enum accepts valid tag", constraintsHold "Outer" 1 [1, 0] + [0, 1, 1, 0, 1, 0, 0, -1]) +] + +private def system : Circuit.System Rat := + (Circuit.compile (program.toField Rat)).toOption.getD { chips := [], enums := program.enums } + +private def rootChecks : List (String × Bool) := [ + ("invalid root argument tag", decide (system.check ⟨[]⟩ + ⟨"identity", [⟨.enum "Maybe", [2, 0]⟩], ⟨.enum "Maybe", [0, 0]⟩⟩ [] = .error .malformedEntry)), + ("noncanonical root argument padding", decide (system.check ⟨[]⟩ + ⟨"identity", [⟨.enum "Maybe", [0, 7]⟩], ⟨.enum "Maybe", [0, 0]⟩⟩ [] = .error .malformedEntry)), + ("invalid root result tag", decide (system.check ⟨[]⟩ + ⟨"identity", [⟨.enum "Maybe", [0, 0]⟩], ⟨.enum "Maybe", [2, 0]⟩⟩ [] = .error .malformedEntry)), + ("well-formed root still requires proof", decide (system.check ⟨[]⟩ + ⟨"identity", [⟨.enum "Maybe", [0, 0]⟩], ⟨.enum "Maybe", [1, 7]⟩⟩ [] = .error .unbalancedMessages)), + ("pointer in an unselected root variant", decide (system.check ⟨[]⟩ + ⟨"identity", [⟨.enum "Box", [0, 0]⟩], ⟨.enum "Maybe", [0, 0]⟩⟩ [] = .error .pointerEntryArgument)), + ("pointer-bearing root variant rejected", decide (system.check ⟨[]⟩ + ⟨"identity", [⟨.enum "Box", [1, 99]⟩], ⟨.enum "Maybe", [0, 0]⟩⟩ [] = .error .pointerEntryArgument)) +] + +def run : IO Unit := do + for (label, passed) in checks ++ constraintsChecks ++ rootChecks do + unless passed do throw (IO.userError s!"enum encoding check failed: {label}") + IO.println s!"Passed {checks.length + constraintsChecks.length + rootChecks.length} enum encoding and polynomial checks." + +end AiurEnumEncodingTests diff --git a/Aiur/AiurTests/EnumProofs.lean b/Aiur/AiurTests/EnumProofs.lean new file mode 100644 index 000000000..5a3ad2b3a --- /dev/null +++ b/Aiur/AiurTests/EnumProofs.lean @@ -0,0 +1,90 @@ +import Aiur +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +open Aiur Aiur.Circuit + +namespace AiurEnumProofTests + +set_option maxRecDepth 10000 +set_option maxHeartbeats 1000000 + +def source : Program Nat := aiur% " +enum List { Nil, Cons(Field, &List) } +enum Outcome { Empty, Pair((Field, Field)) } +fn sum(xs: List) -> Field { + match xs { List::Nil => 0, List::Cons(x, tail) => x + sum(*tail) } +} +fn main(x: Field) -> Field { sum(List::Cons(x, &List::Nil)) } +fn wrap(x: Field) -> Outcome { Outcome::Pair((x, x + 1)) } +" + +def system : System Rat := (compile (source.toField Rat)).toOption.getD { chips := [] } +theorem compiled : compile (source.toField Rat) = .ok system := by + have succeeds : (compile (source.toField Rat)).isOk = true := by decide +kernel + cases lowered : compile (source.toField Rat) with + | error error => simp [lowered, Except.isOk, Except.toBool] at succeeds + | ok chips => simp [system, lowered, Except.toOption] + +-- A recursive enum crosses a call boundary and ROM; address 99 represents source location 0. +example : EncodedEntryDerives system "main" (entryValues [7]) 7 := by + have executed : run (source.toField Rat) "main" [7] 32 = + .ok (.field 7, [.construct "List" "Nil" []]) := by decide +kernel + obtain ⟨_, entry, locals, expr, prepared, body⟩ := run_eq_ok_iff.mp executed + have complete := compiler_heap_complete compiled entry (.intro prepared (evalExpr_spec body)) + (fun _ => (99 : Rat)) (by intro i j hi hj _; simp at hi hj; omega) + simp only [Value.mapAddress, List.map_cons, List.map_nil] at complete + exact complete + +-- A nominal result with a tuple payload is covered by the same theorem. +example : EncodedEntryDerives system "wrap" (entryValues [7]) + (.construct "Outcome" "Pair" [.tuple [7, 8]]) := by + have executed : run (source.toField Rat) "wrap" [7] 16 = + .ok (.construct "Outcome" "Pair" [.tuple [.field 7, .field 8]], []) := by decide +kernel + obtain ⟨_, entry, locals, expr, prepared, body⟩ := run_eq_ok_iff.mp executed + have complete := compiler_heap_complete compiled entry (.intro prepared (evalExpr_spec body)) + (fun _ => (0 : Rat)) (by simp) + simp only [Value.mapAddress, List.map_cons, List.map_nil] at complete + exact complete + +-- Well-formedness of an alternative result does not make it a true root claim. +example (accepted : EncodedEntryDerives system "wrap" (entryValues [7]) + (.construct "Outcome" "Empty" [])) : False := by + have wrong := compiler_entry_sound compiled accepted (by decide +kernel) + have actual : EvalCall (source.toField Rat) "wrap" [7] + (.construct "Outcome" "Pair" [.tuple [7, 8]]) := eval_spec (hints := HintProvider.unavailable) (fuel := 16) (by decide +kernel) + have same := actual.deterministic wrong (by decide +kernel) + simp [Value.mapAddress] at same + +instance : Fact (Nat.Prime 7) := ⟨by decide⟩ +def finiteSystem : System (ZMod 7) := (compile (source.toField (ZMod 7))).toOption.getD { chips := [] } +theorem finite_compiled : compile (source.toField (ZMod 7)) = .ok finiteSystem := by + have succeeds : (compile (source.toField (ZMod 7))).isOk = true := by decide +kernel + cases lowered : compile (source.toField (ZMod 7)) with + | error error => simp [lowered, Except.isOk, Except.toBool] at succeeds + | ok chips => simp [finiteSystem, lowered, Except.toOption] + +example : ∃ encode : Nat → ZMod 7, EncodedEntryDerives finiteSystem "main" (entryValues [3]) + ((3 : SourceValue (ZMod 7)).mapAddress encode) := + compiler_run_complete finite_compiled + (show run (source.toField (ZMod 7)) "main" [3] 32 = + .ok (3, [.construct "List" "Nil" []]) from by decide +kernel) (by decide +kernel) + +example : ∃ encode : Nat → ZMod 7, EncodedMemoEntryDerives finiteSystem "main" (entryValues [3]) + ((3 : SourceValue (ZMod 7)).mapAddress encode) := + memo_run_complete finite_compiled + (show run (source.toField (ZMod 7)) "main" [3] 32 = + .ok (3, [.construct "List" "Nil" []]) from by decide +kernel) (by decide +kernel) + +-- These guard the full enum proofs against admitted steps or additional axioms. +/-- info: 'Aiur.compiler_correct' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.compiler_correct +/-- info: 'Aiur.memo_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.memo_complete +/-- info: 'Aiur.memo_acyclic_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.memo_acyclic_sound + +end AiurEnumProofTests diff --git a/Aiur/AiurTests/Enums.lean b/Aiur/AiurTests/Enums.lean new file mode 100644 index 000000000..546059330 --- /dev/null +++ b/Aiur/AiurTests/Enums.lean @@ -0,0 +1,173 @@ +import Aiur.Frontend +import Aiur.EvalCorrectness +import Aiur.Circuit.Compile +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +open Aiur + +namespace AiurEnumTests + +set_option maxRecDepth 10000 +set_option maxHeartbeats 1000000 + +def sample : Program Nat := aiur% r#" +enum Maybe { None, Some(Field) } +enum Other { None, Some(Field) } +enum List { Nil, Cons(Field, &List) } +enum Token { Wrap(Field) } +enum Effects { Pair(&Field, &Field) } +enum Box { Empty, Full(&Field) } +enum Inner { A, B } +enum Outer { Raw(Field), Nested(Inner) } +enum Mixed { Unit(()), Nested((Field, (Maybe, Field))) } +enum Even { End, Next(&Odd) } +enum Odd { Next(Even) } + +fn classify(value: Maybe) -> Field { + match value { Maybe::None => 0, Maybe::Some(0) => 1, Maybe::Some(x) => x + 2 } +} +fn make(x: Field) -> Maybe { Maybe::Some(x) } +fn call(x: Field) -> Field { classify(make(x)) } +fn sum(xs: List) -> Field { + match xs { List::Nil => 0, List::Cons(x, tail) => x + sum(*tail) } +} +fn list(x: Field, y: Field) -> Field { + let tail = List::Cons(y, &List::Nil); + sum(List::Cons(x, &tail)) +} +fn parameter(Token::Wrap(x): Token) -> Field { x } +fn binding(x: Field) -> Field { let Token::Wrap(y) = Token::Wrap(x); y + 1 } +fn empty_box(value: Box) -> Field { match value { Box::Empty => 0, Box::Full(p) => *p } } +fn boxed(x: Field) -> Field { empty_box(Box::Full(&x)) } +fn nested(value: Mixed) -> Field { + match value { + Mixed::Unit(()) => 3, + Mixed::Nested((x, (Maybe::Some(0), y))) => x + y, + Mixed::Nested((_, (m, _))) => classify(m), + } +} +fn non_tail(x: Field) -> Maybe { + let y = match x { 0 => Maybe::None, _ => Maybe::Some(x) }; + match classify(y) { 0 => Maybe::Some(9), _ => y } +} +fn lazy(x: Field) -> Field { + match Maybe::Some(x) { Maybe::Some(y) => y, _ => *&(1 / 0) } +} +fn partial_enum(value: Maybe) -> Field { match value { Maybe::Some(x) => x } } +fn outer(x: Field) -> Outer { Outer::Raw(x) } +fn forever(x: Field) -> Maybe { forever(x) } +fn eager() -> Maybe { Maybe::Some(1 / 0) } +fn discarded() -> Field { let _ = Maybe::Some(1 / 0); 7 } +fn effects(x: Field) -> Effects { Effects::Pair(&x, &(x + 1)) } +"# + +private def ctor (name constructor : String) (args : List (SourceValue Rat) := []) : SourceValue Rat := + .construct name constructor args + +def runtimeTests : List (String × Except EvalError (SourceValue Rat) × Except EvalError (SourceValue Rat)) := [ + ("nullary constructor", eval (sample.toField Rat) "classify" [ctor "Maybe" "None"], .ok 0), + ("ordered constructor patterns", eval (sample.toField Rat) "classify" [ctor "Maybe" "Some" [0]], .ok 1), + ("constructor binding", eval (sample.toField Rat) "classify" [ctor "Maybe" "Some" [5]], .ok 7), + ("enum call result", eval (sample.toField Rat) "call" [5], .ok 7), + ("pointer recursion", eval (sample.toField Rat) "list" [7, 8], .ok 15), + ("irrefutable parameter", eval (sample.toField Rat) "parameter" [ctor "Token" "Wrap" [5]], .ok 5), + ("irrefutable let", eval (sample.toField Rat) "binding" [5], .ok 6), + ("pointer in an unselected variant", eval (sample.toField Rat) "empty_box" [ctor "Box" "Empty"], + .error (.pointerEntryArgument 0)), + ("pointer payload", eval (sample.toField Rat) "boxed" [5], .ok 5), + ("unit payload", eval (sample.toField Rat) "nested" [ctor "Mixed" "Unit" [.tuple []]], .ok 3), + ("nested constructor and tuple patterns", eval (sample.toField Rat) "nested" + [ctor "Mixed" "Nested" [.tuple [3, .tuple [ctor "Maybe" "Some" [0], 4]]]], .ok 7), + ("non-tail enum result", eval (sample.toField Rat) "non_tail" [0], .ok (ctor "Maybe" "Some" [9])), + ("non-tail enum result other arm", eval (sample.toField Rat) "non_tail" [5], .ok (ctor "Maybe" "Some" [5])), + ("inactive arm", eval (sample.toField Rat) "lazy" [5], .ok 5), + ("partial constructor match", eval (sample.toField Rat) "partial_enum" [ctor "Maybe" "None"], .error .noMatchingArm), + ("eager constructor argument", eval (sample.toField Rat) "eager" [], .error .divisionByZero), + ("discarded constructor argument", eval (sample.toField Rat) "discarded" [], .error .divisionByZero), + ("recursion fuel", eval (sample.toField Rat) "forever" [0] 20, .error .outOfFuel), + ("nominal input types", eval (sample.toField Rat) "classify" [ctor "Other" "Some" [0]], + .error (.argumentTypeMismatch "classify" (.enum "Maybe") (.enum "Other"))), + ("unknown input constructor", eval (sample.toField Rat) "classify" [ctor "Maybe" "Bogus"], + .error (.malformedValue (.enum "Maybe"))), + ("malformed input payload", eval (sample.toField Rat) "classify" [ctor "Maybe" "Some" []], + .error (.malformedValue (.enum "Maybe"))), + ("pointer-bearing entry variant", eval (sample.toField Rat) "empty_box" + [ctor "Box" "Full" [.ptr .field 0]], .error (.pointerEntryArgument 0)) +] + +run_cmd do + let env ← Lean.getEnv + for source in [ + "enum E {}", + "enum Field { X }", + "enum E { A, A }", + "enum E { A } enum E { B }", + "enum E { A(Unknown) }", + "enum E { A(&Unknown) }", + "enum E { Stop, Next(E) }", + "enum E { Stop, Next((Field, E)) }", + "enum A { X(B) } enum B { Y(A) }", + "enum E { A(Field) } fn f() -> E { E::A }", + "enum E { A } fn f() -> E { E::Missing }", + "enum E { A(Field) } fn f() -> E { E::A(()) }", + "enum E { A } enum D { A } fn f() -> E { D::A }", + "enum E { A(Field), B } fn f(E::A(x): E) -> Field { x }", + "enum E { A(Field, Field) } fn f(e: E) -> Field { match e { E::A(x, x) => x } }", + "enum E { A(Field) } fn f(e: E) -> Field { e.0 }" + ] do + match Frontend.ofString env source with + | .error _ => pure () + | .ok _ => throwError "unexpectedly accepted enum program: {source}" + +instance : Fact (Nat.Prime 2) := ⟨by decide⟩ + +def three : Program Nat := aiur% "enum E { A, B, C } fn f() -> E { E::C }" + +/-- Constructors remain nominal even when their default field tags would collide. -/ +example : eval (three.toField (ZMod 2)) "f" [] = .ok (.construct "E" "C" []) := by decide +kernel + +example : (Circuit.compile (three.toField (ZMod 2))).isOk = false := by decide +kernel + +def two : Program Nat := aiur% "enum E { A, B(Field) } fn f() -> E { E::B(3) }" +example : (Circuit.compile (two.toField (ZMod 2))).isOk = true := by decide +kernel + +private def duplicateError (result : Except Circuit.CompileError (Circuit.System F)) : Bool := + match result with + | .error (.duplicatePattern name) => name == "f" + | _ => false + +def duplicates : Program Nat := aiur% " +enum E { A(Field), B } +fn f(e: E) -> Field { match e { E::A(x) => x, E::A(_) => 2, _ => 3 } } +" +example : duplicateError (Circuit.compile (duplicates.toField Rat)) = true := by decide +kernel + +def collisions : Program Nat := aiur% " +enum E { A(Field) } +fn f(e: E) -> Field { match e { E::A(0) => 1, E::A(2) => 2, _ => 3 } } +" +example : (Circuit.compile (collisions.toField Rat)).isOk = true := by decide +kernel +example : duplicateError (Circuit.compile (collisions.toField (ZMod 2))) = true := by decide +kernel + +def discardedArms : Program Nat := aiur% " +enum E { A(Field) } +fn f(e: E) -> Field { match e { E::A(x) => x, E::A(0) => 2, E::A(0) => 1 / 0 } } +" +example : (Circuit.compile (discardedArms.toField Rat)).isOk = true := by decide +kernel +example : eval (discardedArms.toField Rat) "f" [.construct "E" "A" [0]] = .ok 0 := by decide +kernel + +example : run (sample.toField Rat) "effects" [7] 16 = + .ok (.construct "Effects" "Pair" [.ptr .field 0, .ptr .field 1], [7, 8]) := by decide +kernel + +private def checkEqual [DecidableEq α] [Repr α] (label : String) (actual expected : α) : IO Unit := do + unless actual = expected do throw (IO.userError s!"{label}: expected {repr expected}, got {repr actual}") + +def run : IO Unit := do + for (label, actual, expected) in runtimeTests do checkEqual label actual expected + match Circuit.compile (sample.toField Rat) with + | .error error => throw (IO.userError s!"enum compilation failed: {repr error}") + | .ok _ => pure () + IO.println s!"Passed {runtimeTests.length} enum runtime checks and enum compilation." + +end AiurEnumTests diff --git a/Aiur/AiurTests/Execution.lean b/Aiur/AiurTests/Execution.lean new file mode 100644 index 000000000..2fb92c9ff --- /dev/null +++ b/Aiur/AiurTests/Execution.lean @@ -0,0 +1,169 @@ +import Aiur.Modules.Frontend +import Aiur.Execution +import AiurTests.ExecutionHints +import Mathlib.Algebra.Field.ZMod + +open Aiur + +namespace AiurExecutionTests + +def source : Modules.Program Nat := aiur_modules% " +module Test { + struct Pair { left: Field, right: Field } + struct Box { value: T } + enum Choice { None, Some([Field; 2]), Large(Pair, Field) } + enum Outer { Empty, Wrap(Choice), Pair(Choice, Choice) } + enum Unit { Unit } + opaque type Secret = Field; + enum Mixed { Public(Field), Private(Secret) } + type Numbers = [Field; 2]; + table inputs: (Field, Field) { (0,0), (0,1), (1,0), (1,1) } + table sums: Field { 0,1,1,2 } + table products: Field { 0,0,0,1 } + map add(a: Field, b: Field) -> Field = inputs => sums; + map mul(a: Field, b: Field) -> Field = inputs => products; + inline fn twice(x: Field) -> Field { x + x } + fn inner(x: Field) -> Field { x + 1 } + fn outer(x: Field) -> Field { inner(x) + inner(x) } + fn sharing(x: Field) -> Field { outer(x) + outer(x) } + fn fib(n: Field) -> Field { + match n { 0 => 0, 1 => 1, _ => fib(n - 1) + fib(n - 2) } + } + fn pair(n: Field) -> Pair { Pair { right: fib(n), left: fib(n) } } + fn array(xs: Numbers) -> Box { + Box { value: xs with { [0] = twice(xs[1]) } } + } + fn choice(x: Choice) -> Choice { + match x { Choice::Some([0, a]) => Choice::Some([a, 0]), _ => x } + } + fn nested(x: Outer) -> Outer { x } + fn unit(x: Unit) -> (Unit, [Unit; 2]) { (x, [x; 2]) } + fn loaded(p: &[Field; 2]) -> Field { let &a = p; a[0] + a[1] } + fn memory(x: Field) -> Field { + let p = &[x, x + 1]; let q = &[x, x + 1]; loaded(p) + loaded(q) + } + fn table(a: Field, b: Field) -> (Field, Field, Field) { (add(a,b), mul(a,b), add(a,b)) } + fn arithmetic(a: Field, b: Field) -> Field { -(a * b) + a / b - 1 } + fn choose(x: Field) -> Field { + let y = 'chosen: { match x { 0 => break 'chosen 7, 1 => return 20, _ => () }; 9 }; + y + 1 + } + fn refutable(x: Field) -> Field { let 3 = x; 8 } + fn asserted(x: Field) -> Field { assert_eq!(x, 4, \"expected four\"); 9 } + fn constrained(x: Field) -> Field { constrain_eq!(x * x, 4, \"expected square four\"); 9 } + fn hint_key(x: Field) -> Field { 1 / x } + fn hinted(x: Field) -> Field { hint::(hint_key(x)) } + fn lazy(x: Field) -> Field { match x { 0 => 7, _ => hinted(1) } } + fn secret() -> Secret { 5 } + fn mixed() -> Mixed { Mixed::Public(5) } + fn empty_secret() -> [Secret; 0] { [] } + fn pointer() -> &Field { &5 } + fn cycle(x: Field) -> Field { cycle(x) } +} +module Alias = Test; +" + +instance : Fact (Nat.Prime 97) := ⟨by decide⟩ +abbrev F := ZMod 97 + +def entries : List String := ["Test::sharing", "Alias::pair", "Test::fib", "Test::array", "Test::choice", + "Test::unit", "Test::memory", "Test::table", "Test::arithmetic", "Test::choose", "Test::refutable", + "Test::asserted", "Test::hinted", "Test::lazy", "Test::secret", "Test::pointer", "Test::cycle", + "Test::nested", "Test::mixed", "Test::empty_secret", "Test::constrained"] + +def largeFieldSource : Modules.Program Nat := aiur_modules% " +module Large { + fn identity(x: Field) -> Field { x } + fn square(x: Field) -> Field { x * x } +} +" + +private def check (condition : Bool) (message : String) : IO Unit := + unless condition do throw (IO.userError message) + +private def query (result : Execution.Result) (name : String) (args : Array Nat) : IO Execution.Query := + match result.queries.find? (fun q => q.name == name && q.args == args) with + | some q => pure q + | none => throw (IO.userError s!"missing query {name}{args.toList}") + +private def json (source : String) : IO Lean.Json := IO.ofExcept (Lean.Json.parse source) + +def run : IO Unit := do + let prepared ← IO.ofExcept (Modules.prepare (source.toField F) entries) + let exported ← IO.ofExcept prepared.exportExecution + check (!(exported.bytecode.functions.map (·.name)).contains "Test::twice") "inline helper survived" + let runFlat := fun (name : String) (args : Array Nat) => do IO.ofExcept (← exported.runFlat name args) + let sharing ← runFlat "Test::sharing" #[4] + check (sharing.output == #[20]) "memoized result" + check ((← query sharing "Test::sharing" #[4]).multiplicity == 1) "entry multiplicity" + check ((← query sharing "Test::outer" #[4]).multiplicity == 2) "cache hit multiplicity" + check ((← query sharing "Test::inner" #[4]).multiplicity == 2) "cache hit repeated child effects" + let fib ← runFlat "Test::fib" #[10] + check (fib.output == #[55] && fib.queries.size == 11) "Fibonacci memoization" + let pair ← runFlat "Alias::pair" #[10] + check (pair.output == #[55,55]) "struct initializer order" + check (pair.pretty_output == some "Test::Pair { left: 55, right: 55 }") "struct output formatting" + let array ← IO.ofExcept (← exported.run "Test::array" #[← json "[3, 4]"]) + check (array.output == #[8,4]) "array update" + check (array.pretty_output == some "Test::Box { value: [8, 4] }") + s!"generic struct/array formatting: {array.pretty_output}" + let choice ← IO.ofExcept (← exported.run "Test::choice" #[← json "{\"Some\":[[0,7]]}"]) + check (choice.output == #[1,7,0,0]) "enum pattern and padding" + check (choice.pretty_output == some "Test::Choice::Some([7, 0])") "enum output formatting" + let nested ← IO.ofExcept (← exported.run "Test::nested" #[← json "{\"Wrap\":[{\"Some\":[[5,6]]}]}"]) + check (nested.output == #[1,1,5,6,0,0,0,0,0]) "nested enum encoding" + check (nested.pretty_output == some "Test::Outer::Wrap(Test::Choice::Some([5, 6]))") "nested enum output" + let unit ← IO.ofExcept (← exported.run "Test::unit" #[← json "{\"Unit\":[]}"]) + check (unit.output.isEmpty) "tagless unit width" + check (unit.pretty_output == some "(Test::Unit::Unit, [Test::Unit::Unit, Test::Unit::Unit])") "zero-width arrays" + let memory ← runFlat "Test::memory" #[4] + check (memory.output == #[18] && memory.memory.size == 1) "interned typed ROM" + check ((← query memory "Test::loaded" #[0]).multiplicity == 2) "pointer query cache" + check (memory.memory[0]!.multiplicity == 3) "cached call repeated ROM load" + let table ← runFlat "Test::table" #[1,1] + check (table.output == #[2,1,2]) "static maps" + check ((← query table "Test::add" #[1,1]).multiplicity == 2) "map cache counts" + for (name, args) in [("Test::arithmetic", [12,3]), ("Test::choose", [0]), ("Test::choose", [1]), ("Test::choose", [2]), ("Test::refutable", [3])] do + let result ← runFlat name args.toArray + let (value, _) ← IO.ofExcept (prepared.run name (args.map fun n => .field (Nat.cast n))) + let .field expected := value | throw (IO.userError "expected field result") + check (result.output == #[expected.val]) s!"Rust/native evaluation disagreement for {name}" + let lazy ← runFlat "Test::lazy" #[0] + let deferred ← runFlat "Test::constrained" #[3] + check (deferred.output == #[9]) "constrain_eq was checked by Rust" + check ((prepared.run "Test::constrained" [.field 3]).toOption.isNone) + "constrain_eq was weakened in the source semantics" + check (lazy.output == #[7]) "inactive hint was executed" + let secret ← runFlat "Test::secret" #[] + check (secret.pretty_output.isNone) "opaque alias leaked through pretty IO" + let mixed ← runFlat "Test::mixed" #[] + check (mixed.pretty_output.isNone) "inactive opaque variant leaked through pretty IO" + let emptySecret ← runFlat "Test::empty_secret" #[] + check (emptySecret.pretty_output.isNone) "empty opaque array leaked through pretty IO" + let pointer ← runFlat "Test::pointer" #[] + check (pointer.pretty_output.isNone) "pointer leaked through pretty IO" + for (name, args, expected) in [ + ("Test::arithmetic", #[1,0], "division by zero"), + ("Test::refutable", #[2], "let pattern mismatch"), + ("Test::asserted", #[3], "expected four"), + ("Test::hinted", #[0], "division by zero"), + ("Test::cycle", #[1], "already being evaluated"), + ("Test::table", #[2,0], "no table entry"), + ("Test::choice", #[3,0,0,0], "invalid enum tag"), + ("Test::choice", #[0,0,0,1], "nonzero enum padding"), + ("Test::fib", #[97], "noncanonical"), + ("Test::inner", #[1], "unselected entrypoint")] do + match ← exported.runFlat name args with + | .ok _ => throw (IO.userError s!"unexpected execution success: {name}") + | .error message => check ((message.splitOn expected).length > 1) s!"unexpected error: {message}" + let large ← IO.ofExcept do + let p ← Modules.prepare (largeFieldSource.toField (ZMod 18446744069414584321)) ["Large::identity", "Large::square"] + p.exportExecution + let big ← IO.ofExcept (← large.runFlat "Large::identity" #[18446744069414584320]) + check (big.output == #[18446744069414584320]) "UInt64 FFI value was rounded" + let squared ← IO.ofExcept (← large.runFlat "Large::square" #[18446744069414584320]) + check (squared.output == #[1]) "Goldilocks field multiplication" + AiurExecutionHintTests.run + IO.println "Passed execution bytecode, Rust FFI, memoization, ROM, maps, structured IO and native comparison checks." + +end AiurExecutionTests diff --git a/Aiur/AiurTests/ExecutionHints.lean b/Aiur/AiurTests/ExecutionHints.lean new file mode 100644 index 000000000..41bde92be --- /dev/null +++ b/Aiur/AiurTests/ExecutionHints.lean @@ -0,0 +1,143 @@ +import Aiur.Modules.Frontend +import Aiur.Execution +import Mathlib.Algebra.Field.ZMod + +open Aiur + +namespace AiurExecutionHintTests + +def source : Modules.Program Nat := aiur_modules% " +module Witness { + type Numbers = [Field; 2]; + struct Pair { left: Field, right: Field } + struct Box { value: T } + enum Choice { None, Some(Numbers), Large(Pair, Field) } + enum Outer { Empty, Wrap(Choice), Large(Choice, Choice) } + enum Unit { Unit } + enum Other { Unit } + opaque type Secret = Field; + opaque struct SecretBox { value: Field } + enum Hidden { Public, Private(Secret) } + struct HasPointer { value: &Field } + fn preimage(h: Field) -> Field { + let p = hint::(h); assert_eq!(p * p, h, \"incorrect preimage\"); p + } + fn repeated(h: Field) -> Field { preimage(h) + preimage(h) } + fn typed_keys() -> (Field, Field, Field, Field, Field) { + (hint::(7), hint::((7,)), hint::(Unit::Unit), + hint::(Other::Unit), hint::(())) + } + fn typed_results() -> (Field, (Field,)) { (hint::(7), hint::<(Field,)>(\"singleton\", 7)) } + fn nested(key: Pair) -> Outer { hint::(key) } + fn boxed(n: Field) -> Box { hint::>(\"boxed\", n) } + fn zero() -> (Unit, [Unit; 2], [Field; 0]) { hint::<(Unit, [Unit; 2], [Field; 0])>(\"zero\", ()) } + inline fn sample(n: Field) -> Field { hint::(\"sample\", n) } + fn inlined(n: Field) -> (Field, Field) { (sample(n), sample(n)) } + fn key_helper(x: Field) -> Field { x + 1 } + fn key_effects(x: Field) -> Field { let p = &x; hint::(*p + key_helper(x)) } + fn lazy(n: Field) -> Field { match n { 0 => 9, _ => hint::(n) } } +} +" + +abbrev F := ZMod 97 + +private def named (name : String) : Generic.Ty := .named ("Witness::" ++ name) [] + +private def unit (name : String) : Execution.DataValue F := .construct (named name) "Unit" [] + +def entries : List String := ["Witness::repeated", "Witness::typed_keys", "Witness::typed_results", + "Witness::nested", "Witness::boxed", "Witness::zero", "Witness::inlined", "Witness::key_effects", "Witness::lazy"] + +private def check (condition : Bool) (message : String) : IO Unit := + unless condition do throw (IO.userError message) + +private def query (result : Execution.Result) (name : String) : IO Execution.Query := + match result.queries.find? (·.name == name) with + | some q => pure q + | none => throw (IO.userError s!"missing query {name}") + +private def expectError (result : Except String α) (part : String) : IO Unit := + match result with + | .ok _ => throw (IO.userError s!"expected error containing {part}") + | .error message => check ((message.splitOn part).length > 1) s!"unexpected error: {message}" + +def run : IO Unit := do + let prepared ← IO.ofExcept (Modules.prepare (source.toField F) entries) + let exported ← IO.ofExcept prepared.exportExecution + let data : Array (Execution.HintEntry F) := #[⟨.field, 49, 7, ""⟩] + let repeated ← IO.ofExcept (← exported.runFlat "Witness::repeated" #[49] data) + check (repeated.output == #[14]) "hinted preimage result" + let child ← query repeated "Witness::preimage" + check (child.multiplicity == 2 && child.output == #[7]) "cached hinted query" + let other ← IO.ofExcept (← exported.runFlat "Witness::repeated" #[49] #[⟨.field, 49, 90, ""⟩]) + check (other.output == #[83]) "execution sessions shared hints or query caches" + expectError (← exported.runFlat "Witness::repeated" #[49]) "missing hint" + expectError (← exported.runFlat "Witness::repeated" #[49] #[⟨.field, 49, 8, ""⟩]) "incorrect preimage" + let duplicate ← IO.ofExcept (← exported.runFlat "Witness::repeated" #[49] (data ++ data)) + check (duplicate.output == #[14]) "identical hint rows rejected" + -- A serialized IxVM fixture has more than 100,000 hint rows. Preparing the + -- dataset must not consume one native stack frame per entry. + let many : Array (Execution.HintEntry F) := Array.replicate 110000 ⟨.field, 49, 7, ""⟩ + let large ← IO.ofExcept (← exported.runFlat "Witness::repeated" #[49] many) + check (large.output == #[14]) "large hint dataset" + expectError (← exported.runFlat "Witness::repeated" #[49] (data.push ⟨.field, 49, 90, ""⟩)) "conflicting hint" + + let keys : Array (Execution.HintEntry F) := #[ + ⟨.field, 7, 1, ""⟩, ⟨.field, .tuple [7], 2, ""⟩, + ⟨.field, unit "Unit", 3, ""⟩, ⟨.field, unit "Other", 4, ""⟩, ⟨.field, .tuple [], 5, ""⟩] + let typed ← IO.ofExcept (← exported.runFlat "Witness::typed_keys" #[] keys) + check (typed.output == #[1,2,3,4,5]) "hint key types lost during flattening" + let results ← IO.ofExcept (← exported.runFlat "Witness::typed_results" #[] + #[⟨.field, 7, 1, ""⟩, ⟨.tuple [.field], 7, .tuple [2], "singleton"⟩]) + check (results.output == #[1,2]) "hint result types lost during flattening" + + let key : Execution.DataValue F := .record (named "Pair") [("right", 4), ("left", 3)] + let output : Execution.DataValue F := .construct (named "Outer") "Wrap" + [.construct (named "Choice") "Some" [.array .field [5,6]]] + let nestedData : Array (Execution.HintEntry F) := #[⟨named "Outer", key, output, ""⟩] + let flat ← IO.ofExcept (exported.prepareHints nestedData) + check (flat[0]!.key == [3,4]) "hint struct key field ordering" + check (flat[0]!.output == [1,1,5,6,0,0,0,0,0]) "nested hint tags and padding" + let nested ← IO.ofExcept (← exported.run "Witness::nested" + #[← IO.ofExcept (Lean.Json.parse "{\"right\":4,\"left\":3}")] nestedData) + check (nested.pretty_output == some "Witness::Outer::Wrap(Witness::Choice::Some([5, 6]))") + "structured hinted output formatting" + let boxedType : Generic.Ty := .named "Witness::Box" [named "Numbers"] + let boxed : Execution.DataValue F := .record boxedType [("value", .array .field [8,9])] + let box ← IO.ofExcept (← exported.runFlat "Witness::boxed" #[7] #[⟨boxedType, 7, boxed, "boxed"⟩]) + check (box.output == #[8,9]) "generic aliases in hint type did not resolve to compiler instance" + let zeroType : Generic.Ty := .tuple [named "Unit", .array (named "Unit") 2, .array .field 0] + let zeroValue : Execution.DataValue F := .tuple [unit "Unit", + .array (named "Unit") [unit "Unit", unit "Unit"], .array .field []] + let zero ← IO.ofExcept (← exported.runFlat "Witness::zero" #[] #[⟨zeroType, .tuple [], zeroValue, "zero"⟩]) + check zero.output.isEmpty "zero-width hint result" + expectError (← exported.runFlat "Witness::zero" #[]) "missing hint" + + let inlined ← IO.ofExcept (← exported.runFlat "Witness::inlined" #[49] #[⟨.field, 49, 7, "sample"⟩]) + check (inlined.queries.size == 1 && inlined.output == #[7,7]) "inlined hints" + let effects ← IO.ofExcept (← exported.runFlat "Witness::key_effects" #[4] #[⟨.field, 9, 17, ""⟩]) + check (effects.output == #[17] && effects.memory.size == 1) "hint key effects were skipped" + check (effects.memory[0]!.multiplicity == 2 && (← query effects "Witness::key_helper").multiplicity == 1) + "hint key call/store/load accounting" + let lazy ← IO.ofExcept (← exported.runFlat "Witness::lazy" #[0]) + check (lazy.output == #[9]) "inactive hint requested a provider" + + for (bad, message) in ([ + (⟨.field, 7, .tuple [1], ""⟩, "hint output type mismatch"), + (⟨.array .field 2, 7, .array .field [1, .tuple []], ""⟩, "component type mismatch"), + (⟨named "Outer", 7, .construct (named "Outer") "Missing" [], ""⟩, "unknown data constructor"), + (⟨named "Pair", 7, .record (named "Pair") [("left",1), ("left",2)], ""⟩, "duplicate field"), + (⟨named "Pair", 7, .record (named "Pair") [("left",1), ("wrong",2)], ""⟩, "missing execution struct field"), + (⟨named "Secret", 7, 1, ""⟩, "opaque"), + (⟨.array (named "Secret") 0, 7, .array (named "Secret") [], ""⟩, "opaque"), + (⟨named "Hidden", 7, .construct (named "Hidden") "Public" [], ""⟩, "opaque"), + (⟨named "SecretBox", 7, .record (named "SecretBox") [("value",1)], ""⟩, "opaque"), + (⟨.ptr .field, 7, 1, ""⟩, "pointers"), + (⟨named "HasPointer", 7, .record (named "HasPointer") [("value",1)], ""⟩, "opaque component"), + (⟨.field, .array (named "Secret") [], 1, ""⟩, "opaque"), + (⟨.param "T", 7, 1, ""⟩, "concrete type") + ] : List (Execution.HintEntry F × String)) do + expectError (exported.prepareHints #[bad]) message + IO.println "Passed Lean-defined hint data, Rust lookup, hinted execution, structured encoding and rejection checks." + +end AiurExecutionHintTests diff --git a/Aiur/AiurTests/Generics.lean b/Aiur/AiurTests/Generics.lean new file mode 100644 index 000000000..b7841a078 --- /dev/null +++ b/Aiur/AiurTests/Generics.lean @@ -0,0 +1,289 @@ +import Aiur.Generic.Frontend +import Aiur.Generic.Specialize +import Aiur.Generic.Circuit +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +namespace AiurGenericTests +open Aiur +instance : Fact (Nat.Prime 101) := ⟨by decide⟩ +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 + +def source : Generic.Program Nat := aiur% " +enum Option { None, Some(T) } +enum List { Nil, Cons(T, &List) } +fn identity(x: T) -> T { x } +fn swap(p: (A, B)) -> (B, A) { (p.1, p.0) } +fn wrap(x: T) -> Option { Option::Some(x) } +fn unwrap(x: Option, fallback: T) -> T { + match x { Option::Some(value) => value, Option::None => fallback } +} +fn main(x: Field) -> Field { + let pair = swap((identity(x), (2, 3))); + unwrap(wrap(pair.1), 0) +} +fn empty() -> Option { Option::None } +fn explicit(x: Field) -> Field { identity::(x) } +fn alloc(x: T) -> &T { &x } +fn deref(p: &T) -> T { *p } +fn cons(x: Field) -> List { List::Cons(x, alloc(List::::Nil)) } +fn nested(x: Field) -> Option> { Option::Some(Option::Some(x)) } +fn read(x: Field) -> Field { + let list = cons(x); + let List::Cons(head, tail) = list; + let List::Nil = deref(tail); + head +} +fn hinted(x: T) -> Field { hint::(x) } +fn hint_entry(x: Field) -> Field { hinted((x, x)) } +fn grow(n: Field, x: T) -> T { + match n { 0 => x, _ => grow(n - 1, x) } +} +fn grow_entry(n: Field) -> Field { grow(n, 9) } +" + +def runSource (name : String) (args : List (SourceValue Rat)) := do + let s ← Generic.prepare (source.toField Rat) + s.run name args + +def runSpecialized (name : String) (args : List (SourceValue Rat)) := do + let s ← Generic.prepare (source.toField Rat) + let q ← Generic.specialize s [name] + q.run name args + +#guard runSource "main" [.field 17] == .ok (.field 17, []) +#guard runSpecialized "main" [.field 17] == .ok (.field 17, []) +#guard runSource "grow_entry" [.field 4] == .ok (.field 9, []) +#guard (do + let s ← Generic.prepare (source.toField Rat) + return (← Generic.specialize s ["grow_entry"]).program.functions.length).toOption.isSome + +#guard runSource "explicit" [.field 23] == .ok (.field 23, []) +#guard runSpecialized "explicit" [.field 23] == .ok (.field 23, []) +#guard (runSpecialized "read" [.field 31]).map Prod.fst == .ok (.field 31) +#guard (runSource "read" [.field 31]) == (runSpecialized "read" [.field 31]) +#guard (runSpecialized "nested" [.field 7]) == (runSource "nested" [.field 7]) +#guard (runSpecialized "empty" []) == (runSource "empty" []) + +-- Multiple independent instances are allowed; the artifact keeps only the +-- selected public interface, even though identity is a reachable helper. +#guard (do + let s ← Generic.prepare (source.toField Rat) + let q ← Generic.specialize s ["main"] + return q.program.functions.any (·.name == "grow_entry")) == .ok false +#guard (do + let s ← Generic.prepare (source.toField Rat) + let q ← Generic.specialize s ["read"] + q.run "cons" [.field 1]).toOption.isNone +#guard (do + let s ← Generic.prepare (source.toField Rat) + return (← Generic.specialize s ["identity"]).program.functions.length).toOption.isNone + +def recursion : Generic.Program Nat := aiur% " +fn left(n: Field, a: A, b: B) -> A { + match n { 0 => a, _ => right(n - 1, b, a) } +} +fn right(n: Field, a: A, b: B) -> B { + match n { 0 => b, _ => left(n - 1, b, a) } +} +fn swapping(n: Field, a: A, b: B) -> () { + match n { 0 => (), _ => swapping(n - 1, a, b) } +} +fn good(n: Field) -> Field { left(n, 41, (2, 3)) } +fn finite(n: Field) -> () { swapping(n, 1, (2, 3)) } +fn same(n: Field) -> () { swapping(n, 1, 2) } +" + +#guard (do + let s ← Generic.prepare (recursion.toField Rat) + let q ← Generic.specialize s ["good", "same"] + q.run "good" [.field 10]) == .ok (.field 41, []) +#guard (do + let s ← Generic.prepare (recursion.toField Rat) + s.run "finite" [.field 5]) == .ok (.tuple [], []) +#guard (do + let s ← Generic.prepare (recursion.toField Rat) + return (← Generic.specialize s ["finite"]).program.functions.length).toOption.isSome + +-- A cached f reached from f<(Field, Field)> must still be rejected. +def cached : Generic.Program Nat := { functions := [ + { name := "f", typeParams := ["T"], params := [("x", .param "T")], result := .field, + body := .call "g" none [.literal 1] }, + { name := "g", typeParams := ["T"], params := [("x", .param "T")], result := .field, + body := .call "f" none [.literal 1] }, + { name := "first", params := [], result := .field, body := .call "f" none [.literal 1] }, + { name := "second", params := [], result := .field, + body := .call "f" none [.tuple [.literal 1, .literal 2]] }] } + +def cacheRejected (roots : List String) : Bool := + match (do + let s ← Generic.prepare (cached.toField Rat) + return (← Generic.specialize s roots).program.functions.length) with + | .error e => e.startsWith "recursive" + | .ok _ => false + +#guard cacheRejected ["first", "second"] +#guard cacheRejected ["second", "first"] +#guard (do + let s ← Generic.prepare (cached.toField Rat) + return (← Generic.specialize s ["first"]).program.functions.length).toOption.isNone + +-- An ordinary bridge must not hide a change of generic arguments. The check +-- starts at every generic root, even when no public entry reaches that root. +def ordinaryBridge : Generic.Program Nat := { functions := [ + { name := "poly", typeParams := ["T"], params := [], result := .field, + body := .call "bridge" (some []) [] }, + { name := "bridge", params := [], result := .field, + body := .call "poly" (some [.field]) [] }] } +#guard (Generic.checkGenericCycles ordinaryBridge).toOption.isNone + +-- Regression for IxVM's large monomorphic call graph: repeated call sites +-- create exponentially many paths, but cannot change any type argument. +def ordinaryFanout : Generic.Program Nat := { functions := (List.range 32).map fun i => + { name := s!"f{i}", params := [], result := .field, + body := .binary .add (.call s!"f{(i+1)%32}" (some []) []) + (.call s!"f{(i+1)%32}" (some []) []) } } +#guard Generic.checkGenericCycles ordinaryFanout == .ok () + +def mapped : Generic.Program Nat := aiur% " +enum Box { New(T) } +table keys: (Box,) { (Box::New(1),), (Box::New(2),) } +table outputs: Box<(Field, Field)> { Box::New((3, 4)), Box::New((5, 6)) } +map expand(x: Box) -> Box<(Field, Field)> = keys => outputs; +fn unbox(x: Box) -> T { let Box::New(v) = x; v } +fn main(x: Field) -> Field { unbox(expand(Box::New(x))).1 } +" + +#guard (do + let s ← Generic.prepare (mapped.toField Rat) + let q ← Generic.specialize s ["main"] + q.run "main" [.field 2]) == .ok (.field 6, []) +#guard (do + let s ← Generic.prepare (mapped.toField Rat) + s.run "main" [.field 2]) == .ok (.field 6, []) + +#guard (do + let s ← Generic.prepare (source.toField Rat) + let provider := s.checkedHints (fun _ _ => .ok (.field 19)) + s.run "hint_entry" [.field 8] 100 provider) == .ok (.field 19, []) +#guard (do + let s ← Generic.prepare (source.toField Rat) + let provider := s.checkedHints (fun _ _ => .ok (.tuple [])) + s.run "hint_entry" [.field 8] 100 provider).toOption.isNone + +-- The same monomorphic circuit compiler consumes concrete enum instances, +-- generic pointers, maps, and hints after specialization. +#guard (do + let s ← Generic.prepare (source.toField (ZMod 101)) + let q ← Generic.specialize s ["main", "read", "nested", "hint_entry"] + let c ← q.compile + return c.system.chips.length).toOption.isSome +#guard (do + let s ← Generic.prepare (mapped.toField (ZMod 101)) + let q ← Generic.specialize s ["main"] + let c ← q.compile + return c.system.maps.length) == .ok 1 + +#guard (do + let s ← Generic.prepare (source.toField (ZMod 101)) + let q ← Generic.specialize s ["read"] + let c ← q.compile + c.check ⟨[]⟩ ⟨"cons", [], ⟨.field, []⟩⟩ []) == + .error "'cons' is not a selected entrypoint" +#guard (do + let s ← Generic.prepare (source.toField (ZMod 101)) + let q ← Generic.specialize s ["read"] + let c ← q.compile + c.checkMemo ⟨[]⟩ ⟨"cons", [], ⟨.field, []⟩⟩ []) == + .error "'cons' is not a selected entrypoint" + +-- Inference failures, static pointer exclusion, layout cycles, and concrete +-- hint restrictions are checked while elaborating the whole source. +run_cmd do + let bad := [ + "fn f(x: T) -> T { x + 1 }", + "fn grow(n: Field, x: T) -> T { match n { 0 => x, _ => grow(n - 1, (x, x)).0 } }", + "fn swap(n: Field, a: A, b: B) -> () { match n { 0 => (), _ => swap(n - 1, b, a) } }", + "fn grow(x: T) -> Field { match &x { &a => 1, _ => grow((x, x)) } } fn main() -> Field { grow(0) }", + "fn f(x: T) -> T { hint::(x) }", + "enum E { A(T) } fn f(x: T) -> E { hint::>(x) }", + "fn f(x: T) -> T { x } fn main() -> Field { f::<(Field, Field)>(1) }", + "enum O { None, Some(T) } fn main() -> Field { let x = O::None; 1 }", + "enum E { Loop(E) }", + "enum E { Loop(&E<(T, T)>) }", + "enum E { None, Some(T) } table bad: E<&Field> {}", + "enum E { None, Some(T) } fn f() -> E<&Field> { hint::>(()) }", + "fn f(x: T) -> T { x }", + "fn f((x, y): (T, T), x: T) -> T { x }", + "fn f(x) -> T { x }", + "fn f(x: T) { x }" + ] + for code in bad do + match Generic.Frontend.ofString (← Lean.getEnv) code with + | .error _ => pure () + | .ok _ => throwError "unexpectedly accepted: {code}" + +def pointerInput : Generic.Program Nat := aiur% " +enum E { None, Some(T) } +fn entry(x: E<&Field>) -> Field { 0 } +" +#guard (do + let s ← Generic.prepare (pointerInput.toField Rat) + return (← Generic.specialize s ["entry"]).program.functions.length).toOption.isNone + +-- The equivalence theorem is usable for every selected root and every +-- successful outcome, rather than just a particular evaluator fuel bound. +example [Field F] [DecidableEq F] (s : Generic.Source F) + (q : Generic.Specialized s roots) (selected : name ∈ roots) : + s.EvalCall name args result ↔ q.EvalCall name args result := + q.evalCall_iff selected + +def run : IO Unit := do + let checks := [ + ("generic source", runSource "main" [.field 17], .ok (.field 17, [])), + ("generic specialization", runSpecialized "main" [.field 17], .ok (.field 17, [])), + ("ordinary generic recursion", runSource "grow_entry" [.field 4], .ok (.field 9, [])), + ("explicit arguments", runSpecialized "explicit" [.field 23], .ok (.field 23, [])), + ("nested generic enum", runSpecialized "nested" [.field 7], runSource "nested" [.field 7]), + ("generic ROM", runSpecialized "read" [.field 31], runSource "read" [.field 31]) + ] + for (name, actual, expected) in checks do + unless actual = expected do throw (IO.userError s!"{name}: expected {repr expected}, got {repr actual}") + unless cacheRejected ["first", "second"] && cacheRejected ["second", "first"] do + throw (IO.userError "specialization recursion check depends on traversal order") + IO.println s!"Passed {checks.length + 2} generic execution checks." + +-- Guard the proof boundary against admissions or additional axioms. +/-- info: 'Aiur.Generic.Engine.evalExpr_spec' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Engine.evalExpr_spec +/-- info: 'Aiur.Generic.Source.run_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Source.run_spec +/-- info: 'Aiur.Generic.Specialized.evalFn_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Specialized.evalFn_iff +/-- info: 'Aiur.Generic.Specialized.evalCall_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Specialized.evalCall_iff +/-- info: 'Aiur.Generic.Specialized.core_run_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Specialized.core_run_complete +/-- info: 'Aiur.Generic.Specialized.core_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Specialized.core_heap_sound +/-- info: 'Aiur.Generic.Specialized.core_memo_acyclic_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Specialized.core_memo_acyclic_heap_sound +/-- info: 'Aiur.Generic.Specialized.core_checker_run_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Specialized.core_checker_run_complete +/-- info: 'Aiur.Generic.Specialized.core_checkerMemo_run_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Specialized.core_checkerMemo_run_complete +/-- info: 'Aiur.Generic.Specialized.core_checker_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.Specialized.core_checker_heap_sound + +end AiurGenericTests diff --git a/Aiur/AiurTests/Hints.lean b/Aiur/AiurTests/Hints.lean new file mode 100644 index 000000000..d2b4037fb --- /dev/null +++ b/Aiur/AiurTests/Hints.lean @@ -0,0 +1,221 @@ +import Aiur +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +open Aiur Aiur.Circuit + +namespace AiurHintTests + +set_option maxRecDepth 10000 +set_option maxHeartbeats 2000000 + +def source : Program Nat := aiur% " +enum Inner { Empty, Item(Field) } +enum Outer { Raw(Field), Nested(Inner) } +fn field(h: Field) -> Field { hint::(h) } +fn tuple(h: Field) -> (Field, Field) { hint::<(Field, Field)>(\"pair\", h) } +fn nested(h: Field) -> Outer { hint::((h, 1)) } +fn unit() -> () { hint::<()>(()) } +fn singleton() -> (Field,) { hint::<(Field,)>(\"singleton\", ()) } +fn square_preimage(h: Field) -> () { + let p = hint::(h); + let 0 = p * p - h; + () +} +fn twice() -> (Field, Field) { + (hint::(()), hint::(())) +} +fn lazy(x: Field) -> Field { match x { 0 => 9, _ => hint::(x) } } +fn key(x: Field) -> Field { let p = &x; *p + 1 } +fn dynamic(x: Field) -> Field { hint::(key(x)) } +fn store_hint(x: Field) -> Outer { let p = &hint::(x); *p } +fn failed_key() -> Field { hint::(1 / 0) } +fn discarded() -> Field { let _ = hint::(()); 7 } +" + +def program := source.toField Rat + +def answer (value : Constant Rat) : HintProvider Rat program.enums := + HintProvider.checked program.enums fun _ _ => .ok value + +def keyed : HintProvider Rat program.enums := HintProvider.checked program.enums fun channel key => + match channel, key with + | "", .field x => .ok (.field (x + 1)) + | "pair", .field x => .ok (.tuple [.field x, .field (x + 1)]) + | "", .tuple [.field x, .field 1] => + .ok (.construct "Outer" "Nested" [.construct "Inner" "Item" [.field x]]) + | "", .tuple [] => .ok (.tuple []) + | "singleton", .tuple [] => .ok (.tuple [8]) + | _, _ => .error .unavailable + +private def outer (value : Rat) : Constant Rat := + .construct "Outer" "Nested" [.construct "Inner" "Item" [.field value]] + +private def runtimeTests : List + (String × Except EvalError (SourceValue Rat) × Except EvalError (SourceValue Rat)) := [ + ("dynamic field key", eval program "field" [8] (hints := keyed), .ok 9), + ("same key, different channel", eval program "tuple" [8] (hints := keyed), .ok (.tuple [8, 9])), + ("nested enum result and tuple key", eval program "nested" [8] (hints := keyed), .ok (outer 8).toValue), + ("unit key and result", eval program "unit" [] (hints := keyed), .ok (.tuple [])), + ("singleton retains its shape", eval program "singleton" [] (hints := keyed), .ok (.tuple [8])), + ("valid preimage", eval program "square_preimage" [49] (hints := answer 7), .ok (.tuple [])), + ("another valid preimage", eval program "square_preimage" [49] (hints := answer (.field (-7))), .ok (.tuple [])), + ("incorrect preimage", eval program "square_preimage" [49] (hints := answer 8), .error .patternMismatch), + ("default provider is unavailable", eval program "field" [8], .error (.hint .unavailable)), + ("provider can decline a key", eval program "field" [.field 8] + (hints := fun _ _ _ => .error (.message "no witness")), .error (.hint (.message "no witness"))), + ("wrong result type rejected", eval program "field" [8] (hints := answer (.tuple [1])), + .error (.hint (.invalidValue .field (.tuple [.field])))), + ("unknown enum constructor rejected", eval program "nested" [8] + (hints := answer (.construct "Outer" "Missing" [])), + .error (.hint (.invalidValue (.enum "Outer") (.enum "Outer")))), + ("malformed nested payload rejected", eval program "nested" [8] + (hints := answer (.construct "Outer" "Nested" [.construct "Inner" "Item" [.tuple [1, 2]]])), + .error (.hint (.invalidValue (.enum "Outer") (.enum "Outer")))), + ("wrong constructor arity rejected", eval program "nested" [8] + (hints := answer (.construct "Outer" "Raw" [])), + .error (.hint (.invalidValue (.enum "Outer") (.enum "Outer")))), + ("fixed provider repeats an answer", eval program "twice" [] (hints := answer 3), .ok (.tuple [3, 3])), + ("inactive hint needs no provider", eval program "lazy" [0], .ok 9), + ("active hint needs a provider", eval program "lazy" [1], .error (.hint .unavailable)), + ("key computation is ordinary execution", eval program "dynamic" [4] (hints := keyed), .ok 6), + ("hinted enum can be stored and loaded", eval program "store_hint" [8] (hints := answer (outer 8)), + .ok (outer 8).toValue), + ("key errors precede provider invocation", eval program "failed_key" [], .error .divisionByZero), + ("fuel exhaustion is still an error", eval program "field" [8] 0 keyed, .error .outOfFuel) +] + +-- Invalid expected types are rejected statically, including unused pointer-bearing variants. +run_cmd do + let env ← Lean.getEnv + for text in [ + "fn f(x: Field) -> Field { hint::(&x) }", + "fn f() -> &Field { hint::<&Field>(()) }", + "fn f() -> (Field, &Field) { hint::<(Field, &Field)>(()) }", + "enum E { Empty, Full(&Field) } fn f() -> E { hint::(()) }", + "enum E { Empty, Full(&Field) } enum O { Wrap(E) } fn f() -> O { hint::(()) }", + "fn f() -> Missing { hint::(()) }", + "fn f() -> Field { hint::(1 + (2, 3)) }", + "fn f() -> Field { hint::(missing) }", + "fn f() -> Field { hint::() }", + "fn f() -> Field { other::(()) }" + ] do + match Frontend.ofString env text with + | .error _ => pure () + | .ok _ => throwError "unexpectedly accepted invalid hint: {text}" + +/-- Inspect the actual equations emitted for an internal hint, including all auxiliary columns. -/ +private def hintConstraintsHold (enable : Rat) (words auxiliary : List Rat) : Bool := + match Compiler.lowerExpr program "test" [] (.const enable) + (.hint (.enum "Outer") (.tuple [])) {} with + | .error _ => false + | .ok (_, state) => + let assignment := words ++ auxiliary + decide (state.nextVar = assignment.length) && state.sends.isEmpty && state.memory.isEmpty && + state.constraints.toList.all (fun polynomial => + decide (polynomial.denote (fun id => assignment.getD id 0) = 0)) + +private def constraintTests : List (String × Bool) := [ + ("raw payload is not an inner tag", hintConstraintsHold 1 [0, 7, 0] [1, 0, 0, -1, 0, 1/7, 0, 1/6]), + ("nested empty", hintConstraintsHold 1 [1, 0, 0] [0, 1, 1, 0, 1, 0, 0, -1]), + ("nested payload", hintConstraintsHold 1 [1, 1, 8] [0, 1, 1, 0, 0, 1, 1, 0]), + ("invalid outer tag rejected", !hintConstraintsHold 1 [2, 7, 0] [0, 1/2, 0, 1, 0, 1/7, 0, 1/6]), + ("invalid inner tag rejected", !hintConstraintsHold 1 [1, 7, 0] [0, 1, 1, 0, 0, 1/7, 0, 1/6]), + ("outer padding constrained", !hintConstraintsHold 1 [0, 7, 2] [1, 0, 0, -1, 0, 1/7, 0, 1/6]), + ("inner padding constrained", !hintConstraintsHold 1 [1, 0, 5] [0, 1, 1, 0, 1, 0, 0, -1]), + ("inactive hint permits arbitrary data columns", hintConstraintsHold 0 [2, 7, 5] + [0, 1/2, 0, 1, 0, 1/7, 0, 1/6]) +] + +-- A stateless provider does not make the logical relation functional. +example : EvalCall program "field" [8] (.field 3) := + eval_spec (hints := answer 3) (by decide +kernel : eval program "field" [8] 16 (answer 3) = .ok 3) + +example : EvalCall program "field" [8] (.field 4) := + eval_spec (hints := answer 4) (by decide +kernel : eval program "field" [8] 16 (answer 4) = .ok 4) + +-- Logical choices for identical requests can differ within a single evaluation. +example : EvalExpr program [] + (.tuple [.hint .field (.tuple []) "choose", .hint .field (.tuple []) "choose"]) [] (.tuple [1, 2]) [] := by + have choose (x : Rat) : EvalExpr program [] (.hint .field (.tuple []) "choose") [] (.field x) [] := by + simpa [Constant.toValue, Value.mapAddress] using + (EvalExpr.hint (program := program) (locals := []) (before := []) (after := []) + (type := .field) (channel := "choose") (.tuple .nil) (value := (.field x : Constant Rat)) + (by simp [Value.WellTyped, Value.hasType, Value.type])) + exact .tuple (.cons (choose 1) (.cons (choose 2) .nil)) + +def system : System Rat := (compile program).toOption.getD { chips := [] } +theorem compiled : compile program = .ok system := by + have succeeds : (compile program).isOk = true := by decide +kernel + cases lowered : compile program with + | error error => simp [lowered, Except.isOk, Except.toBool] at succeeds + | ok chips => simp [system, lowered, Except.toOption] + +theorem nested_derives : EncodedEntryDerives system "nested" (entryValues [8]) (outer 8).toValue := by + have executed : Aiur.run program "nested" [8] 16 keyed = .ok ((outer 8).toValue, []) := by decide +kernel + obtain ⟨_, entry, locals, expr, prepared, body⟩ := run_eq_ok_iff.mp executed + have complete := compiler_heap_complete compiled entry (.intro prepared (evalExpr_spec body)) + (fun _ => (0 : Rat)) (by simp) + simpa only [Constant.toValue_mapAddress] using complete + +example : EncodedMemoEntryDerives system "nested" (entryValues [8]) (outer 8).toValue := nested_derives.memo + +example (accepted : EncodedEntryDerives system "nested" (entryValues [8]) (outer 8).toValue) : + EvalCall program "nested" [8] (outer 8).toValue := by + simpa only [Constant.toValue_mapAddress] using + compiler_entry_sound compiled accepted (Constant.toValue_pointerFree (outer 8)) + +example {rom : WireROM Rat} (valid : rom.Valid) + (graph : MemoDerivation system rom + ⟨"nested", [.field 8], ⟨.enum "Outer", [1, 1, 8]⟩⟩) (acyclic : graph.Acyclic) : + EvalCall program "nested" [8] (outer 8).toValue := by + obtain ⟨value, heap, evaluated, related⟩ := memo_acyclic_heap_sound compiled valid + (args := [8]) (by decide +kernel) graph acyclic + (by simp [DecodesValues, entryValues]; decide +kernel) (show + (⟨.enum "Outer", [1, 1, 8]⟩ : WireValue Rat).decode program.enums = some (outer 8).toValue by + decide +kernel) + have same := related.pointerFree_eq (Constant.toValue_pointerFree (outer 8)) + simp only [Constant.toValue_mapAddress] at same + subst value + exact ⟨by decide +kernel, heap, evaluated⟩ + +example : EncodedEntryDerives system "lazy" (entryValues [0]) (.field 9) := by + have executed : Aiur.run program "lazy" [0] 16 = .ok (.field 9, []) := by decide +kernel + obtain ⟨_, entry, locals, expr, prepared, body⟩ := run_eq_ok_iff.mp executed + have complete := compiler_heap_complete compiled entry (.intro prepared (evalExpr_spec body)) + (fun _ => (0 : Rat)) (by simp) + simpa [Value.mapAddress] using complete + +instance : Fact (Nat.Prime 7) := ⟨by decide⟩ + +example : eval (source.toField (ZMod 7)) "square_preimage" [2] 16 + (HintProvider.checked source.enums fun _ _ => .ok 3) = .ok (.tuple []) := by decide +kernel + +example : ∃ encode : Nat → ZMod 7, + EncodedMemoEntryDerives + ((compile (source.toField (ZMod 7))).toOption.getD { chips := [] }) + "square_preimage" (entryValues [2]) ((.tuple [] : SourceValue (ZMod 7)).mapAddress encode) := by + have lowered : compile (source.toField (ZMod 7)) = + .ok ((compile (source.toField (ZMod 7))).toOption.getD { chips := [] }) := by + have ok : (compile (source.toField (ZMod 7))).isOk = true := by decide +kernel + cases h : compile (source.toField (ZMod 7)) <;> + simp_all [Except.isOk, Except.toBool, Except.toOption] + exact memo_run_complete lowered + (hints := HintProvider.checked source.enums fun _ _ => .ok 3) (fuel := 16) (heap := []) + (by decide +kernel) (by simp) + +/-- info: 'Aiur.eval_spec' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.eval_spec + +def run : IO Unit := do + for (label, actual, expected) in runtimeTests do + unless actual = expected do throw (IO.userError s!"hint check {label}: {repr actual}, expected {repr expected}") + for (label, passed) in constraintTests do + unless passed do throw (IO.userError s!"hint constraint check failed: {label}") + unless (compile program).isOk do throw (IO.userError "hint compilation failed") + unless Aiur.run program "dynamic" [4] 16 keyed = .ok (.field 6, [.field 4]) do + throw (IO.userError "key computation lost its allocation") + IO.println s!"Passed {runtimeTests.length + constraintTests.length + 2} hint checks." + +end AiurHintTests diff --git a/Aiur/AiurTests/Inlining.lean b/Aiur/AiurTests/Inlining.lean new file mode 100644 index 000000000..154e40fd7 --- /dev/null +++ b/Aiur/AiurTests/Inlining.lean @@ -0,0 +1,146 @@ +import Aiur.Modules +import Mathlib.Algebra.Field.Rat + +namespace AiurInlineTests +open Aiur +set_option maxRecDepth 20000 +set_option maxHeartbeats 8000000 + +def source : Modules.Program Nat := aiur% " +signature Operation { fn next(x: Field) -> Field; } +module Helpers: Operation { + inline fn next(x: Field) -> Field { return x + 1; } +} +module Alias: Operation = Helpers; +module Use { + fn run(x: Field) -> Field { X::next(x) + 1 } +} +module Main { + enum Maybe { Empty, Some(T) } + struct Pair { left: Field, right: Field } + inline fn identity(x: T) -> T { x } + inline fn shifted(x: Field) -> Field { identity(x) + Helpers::next(x) } + inline fn unit() -> () { () } + inline fn pair(x: Field, y: Field) -> Field { let z = x * 10; z + y } + inline fn copy(p: &Field) -> (Field, Field) { (*p, *p) } + inline fn choose(x: Field) -> Field { + 'block: { match x { 0 => return 7, _ => break 'block 8 }; } + } + inline fn step(n: Field) -> Field { recur(n - 1) + 1 } + inline fn witness(key: Field) -> Field { hint::(key) } + inline fn unused(_x: Field) -> Field { 3 } + inline fn take((x, y): (Field, Field)) -> Field { x + y } + fn nested(x: Field) -> Field { shifted(x) } + fn zero_args() -> Field { unit(); 5 } + fn shadow(x: Field) -> Field { let y = 3; let z = 100; pair(y, x) + z } + fn once(x: Field) -> (Field, Field) { copy(&x) } + fn order() -> Field { pair(*&1, *&2) } + fn returns(x: Field) -> Field { choose(x) + 1 } + fn recur(n: Field) -> Field { match n { 0 => 0, _ => step(n) } } + fn aggregates() -> Field { + let Maybe::Some(a) = identity(Maybe::Some([2, 3])); + let Pair { left: x, right: y } = identity(Pair { left: a[0], right: a[1] }); + take(identity((x, y))) + } + fn hints(x: Field) -> Field { pair(witness(*&x), witness(*&(x + 1))) } + fn failed_arg() -> Field { unused(1 / 0) } + fn inactive(x: Field) -> Field { match x { 0 => 9, _ => witness(x) } } + fn through_alias(x: Field) -> Field { Alias::next(x) } +} +" + +def provider : HintDispatcher Rat := fun _ key => + match key with + | .field x => .ok (.field (x + 1)) + | _ => .error .unavailable + +abbrev Result := Except String (SourceValue Rat × Heap Rat) +def cases : List (String × List (SourceValue Rat) × Result) := [ + ("Main::nested",[3],.ok (7,[])), + ("Main::zero_args",[],.ok (5,[])), + ("Main::shadow",[5],.ok (135,[])), + ("Main::once",[6],.ok (.tuple [6,6],[6])), + ("Main::order",[],.ok (12,[1,2])), + ("Main::returns",[0],.ok (8,[])), + ("Main::returns",[1],.ok (9,[])), + ("Main::recur",[5],.ok (5,[])), + ("Main::aggregates",[],.ok (5,[])), + ("Main::hints",[2],.ok (34,[2,3])), + ("Main::inactive",[0],.ok (9,[])), + ("Main::through_alias",[5],.ok (6,[])), + ("Use::::run",[5],.ok (7,[])) +] + +run_cmd do + let env ← Lean.getEnv + let invalid := [ + "module M { inline fn f() -> Field { f() } }", + "module M { inline fn f(x: T) -> T { f(x) } }", + "signature S { fn f() -> Field; } module Loop { inline fn g() -> Field { X::f() } } module A { inline fn f() -> Field { Loop::::g() } }", + "module M { inline fn f() -> Field { g() } inline fn g() -> Field { f() } }", + "module A { inline fn f() -> Field { B::g() } } module B { inline fn g() -> Field { A::f() } }", + "module A { inline fn f() -> Field { Alias::g() } } module B { inline fn g() -> Field { A::f() } } module Alias = B;", + "signature S { fn g() -> Field; } module A { inline fn f() -> Field { Alias::g() } } module B: S { inline fn g() -> Field { A::f() } } module Alias: S = B;", + "signature S {} module M { inline fn f() -> Field { f() } }" + ] + for text in invalid do + match Modules.Frontend.ofString env text with + | .ok _ => throwError "accepted inline cycle: {text}" + | .error e => unless (e.splitOn "inline cycle").length > 1 do + throwError "expected an inline-cycle diagnostic, got: {e}" + match Modules.Frontend.ofString env "module M { inline inline fn f() -> Field { 0 } }" with + | .ok _ => throwError "accepted repeated modifier" + | .error _ => pure () + +#print axioms Inlining.Prepared.entry_iff +#print axioms Generic.Compiled.native_entry_iff +#print axioms Generic.Compiled.heap_complete +#print axioms Generic.Compiled.heap_sound +#print axioms Modules.Compiled.check_complete +#print axioms Modules.Compiled.checkMemo_complete +#print axioms Modules.Compiled.check_sound +#print axioms Modules.Compiled.checkMemo_acyclic_sound + +def run : IO Unit := do + let get {α : Type} (r : Except String α) : IO α := match r with + | .ok value => pure value + | .error e => throw (IO.userError e) + let entries := (cases.map (·.1)).eraseDups ++ ["Main::failed_arg"] + let p ← get <| Modules.prepare (source.toField Rat) entries + let compiled ← get p.compile + let core := compiled.circuit.program + let inlineNames := compiled.specialized.inlineNames + unless inlineNames.length ≥ 10 do throw (IO.userError "inline metadata disappeared") + for n in inlineNames do + unless core.findFunction? n |>.isNone do throw (IO.userError s!"inline body retained: {n}") + unless compiled.circuit.system.findChip? n |>.isNone do throw (IO.userError s!"inline chip retained: {n}") + for chip in compiled.circuit.system.chips do + for send in chip.sends do + if inlineNames.contains send.channel then throw (IO.userError s!"inline send retained: {send.channel}") + let direct := p.environment.source.checkedHints provider + let coreHints := HintProvider.checked core.enums provider + for (name,args,expected) in cases do + let some entry := p.find? name | throw (IO.userError "missing selected entry") + let before := p.run name args (hints := direct) + let after := (Aiur.run core entry.resolved.name args 10000 coreHints).mapError reprStr + for (mode,actual) in [("source",before),("inlined",after)] do + unless actual == expected do + throw (IO.userError s!"{name} ({mode}): expected {repr expected}, got {repr actual}") + let some entry := p.find? "Main::failed_arg" | throw (IO.userError "missing failure entry") + unless (p.run "Main::failed_arg" []).toOption.isNone && + (Aiur.run core entry.resolved.name []).toOption.isNone do + throw (IO.userError "inlining discarded an unused argument's failure") + -- Entry selection must follow aliases to the declaration's modifier. + for entry in ["Helpers::next","Alias::next","Main::pair"] do + match Modules.prepare (source.toField Rat) [entry] with + | .ok _ => throw (IO.userError s!"inline entry accepted: {entry}") + | .error e => unless (e.splitOn "inline function").length > 1 do + throw (IO.userError s!"unexpected entry error: {e}") + -- The source interpreter still calls helpers; it has not expanded their ASTs. + let some original := p.environment.source.program.findFunction? "Main::shadow" | + throw (IO.userError "missing original body") + unless (Generic.sourceCalls [] original.body).any (·.name == "Main::pair") do + throw (IO.userError "source calls were expanded before semantics") + IO.println s!"Passed {cases.length} inline execution checks, cycle and entry rejections, and chip checks." + +end AiurInlineTests diff --git a/Aiur/AiurTests/InputTypes.lean b/Aiur/AiurTests/InputTypes.lean new file mode 100644 index 000000000..277532701 --- /dev/null +++ b/Aiur/AiurTests/InputTypes.lean @@ -0,0 +1,166 @@ +import Aiur +import Mathlib.Algebra.Field.Rat + +open Aiur Aiur.Circuit + +namespace AiurInputTypeTests + +set_option maxRecDepth 10000 +set_option maxHeartbeats 1000000 + +def source : Program Nat := aiur% " +enum Box { Empty, Full(&Field) } +enum Outer { Raw(Field), Nested((Field, Box)) } +enum A { End, Next(B) } +enum B { Next(&A) } +enum Plain { Empty, Pair((Field, (Field,))) } + +table inputs: (Plain,) { (Plain::Empty,), (Plain::Pair((3, (4,))),), } +table outputs: Field { 0, 7, } +table empty: Plain { } +map inspect(value: Plain) -> Field = inputs => outputs; + +fn unbox(value: Box) -> Field { match value { Box::Empty => 0, Box::Full(p) => *p } } +fn outer(value: Outer) -> Field { match value { Outer::Raw(x) => x, _ => 0 } } +fn tuple_arg(value: (Field, Box)) -> Field { value.0 } +fn second(x: Field, value: Box) -> Field { x + unbox(value) } +fn identity(x: Field) -> Field { x } +fn read_plain(value: Plain) -> Field { inspect(value) } +fn internal(x: Field) -> Field { unbox(Box::Full(&x)) } +fn internal_empty() -> Field { unbox(Box::Empty) } +fn returned() -> Box { Box::Empty } +fn returned_pointer(x: Field) -> &Field { &x } +" + +def program := source.toField Rat +def plain : SourceValue Rat := .construct "Plain" "Pair" [.tuple [3, .tuple [4]]] + +def typeChecks : List (String × Bool × Bool) := [ + ("field", Ty.field.pointerFree source.enums, true), + ("unit", (Ty.tuple []).pointerFree source.enums, true), + ("nested tuple", (Ty.tuple [.field, .tuple [.field]]).pointerFree source.enums, true), + ("all enum variants pointer-free", (Ty.enum "Plain").pointerFree source.enums, true), + ("direct pointer", (Ty.ptr .field).pointerFree source.enums, false), + ("pointer hidden in a variant", (Ty.enum "Box").pointerFree source.enums, false), + ("transitive enum and tuple payload", (Ty.enum "Outer").pointerFree source.enums, false), + ("mutually recursive types", (Ty.enum "A").pointerFree source.enums, false), + ("nested pointer-bearing enum", (Ty.tuple [.tuple [.enum "Box"]]).pointerFree source.enums, false), + ("unknown enum", (Ty.enum "Unknown").pointerFree source.enums, false) +] + +def runtimeChecks : List (String × Except EvalError (SourceValue Rat) × Except EvalError (SourceValue Rat)) := [ + ("unselected pointer variant", eval program "unbox" [.construct "Box" "Empty" []], + .error (.pointerEntryArgument 0)), + ("transitive unselected variant", eval program "outer" [.construct "Outer" "Raw" [3]], + .error (.pointerEntryArgument 0)), + ("tuple containing pointer-bearing type", eval program "tuple_arg" [.tuple [3, .construct "Box" "Empty" []]], + .error (.pointerEntryArgument 0)), + ("offending parameter index", eval program "second" [3, .construct "Box" "Empty" []], + .error (.pointerEntryArgument 1)), + ("entry rejected before reading values", eval program "unbox" [], .error (.pointerEntryArgument 0)), + ("pointer-free enum entry and map", eval program "read_plain" [plain], .ok 7), + ("pointer-free enum map entry", eval program "inspect" [plain], .ok 7), + ("internal pointer argument", eval program "internal" [8], .ok 8), + ("internal empty variant", eval program "internal_empty" [], .ok 0), + ("ordinary pointer-bearing result type", eval program "returned" [], .ok (.construct "Box" "Empty" [])), + ("ordinary pointer result", eval program "returned_pointer" [8], .ok (.ptr .field 0)), + ("wrong value still fails ordinary typing", eval program "identity" [.ptr .field 0], + .error (.argumentTypeMismatch "identity" .field (.ptr .field))), + ("enum payload still checked", eval program "read_plain" [.construct "Plain" "Empty" [.ptr .field 0]], + .error (.malformedValue (.enum "Plain"))) +] + +-- No input values, execution fuel, or field operations are needed to reject this entry. +example : checkEntry source "unbox" = .error (.pointerEntryArgument 0) := by decide +kernel + +-- Validate declarations even when there is no row to inspect. +def emptyPointerTable : Program Nat := { + functions := [] + enums := source.enums + tables := [⟨"bad", .enum "Box", []⟩] +} +example : typecheck emptyPointerTable = .error (.pointerType "table 'bad'" (.enum "Box")) := by decide +kernel +example : (compile (emptyPointerTable.toField Rat)).isOk = false := by decide +kernel +example : (eval (emptyPointerTable.toField Rat) "missing" []).isOk = false := by decide +kernel + +-- Map signature checks independently enforce both sides of the same boundary. +example : checkMap source ⟨"bad", [("x", .enum "Box")], .field, "inputs", "outputs"⟩ = + .error (.pointerType "map 'bad' inputs" (.tuple [.enum "Box"])) := by decide +kernel +example : checkMap source ⟨"bad", [], .enum "Box", "inputs", "outputs"⟩ = + .error (.pointerType "map 'bad' result" (.enum "Box")) := by decide +kernel + +run_cmd do + let env ← Lean.getEnv + for text in [ + "table bad: &Field { }", + "table bad: (Field, (&Field,)) { }", + "enum E { Empty, Full(&Field) } table bad: E { E::Empty, }", + "enum E { Empty, Full(&Field) } table bad: E { }", + "enum E { Empty, Full(&Field) } enum W { Unit, Wrap((Field, E)) } table bad: W { W::Unit, }", + "enum A { End, Next(B) } enum B { Next(&A) } table bad: A { A::End, }" + ] do + match Frontend.ofString env text with + | .error _ => pure () + | .ok _ => throwError "accepted pointer-bearing table type: {text}" + +def system : System Rat := (compile program).toOption.getD { chips := [] } +theorem compiled : compile program = .ok system := by + have succeeds : (compile program).isOk = true := by decide +kernel + cases lowered : compile program with + | error error => simp [lowered, Except.isOk, Except.toBool] at succeeds + | ok chips => simp [system, lowered, Except.toOption] + +def badEntry : Message Rat := ⟨"unbox", [⟨.enum "Box", [0, 0]⟩], .field 0⟩ +example : system.check ⟨[]⟩ badEntry [] = .error .pointerEntryArgument := by decide +kernel + +-- The public predicates reject this type for every result and every proof witness. +example (args : List (SourceValue Rat)) (result : SourceValue Rat) : + ¬ EvalCall program "unbox" args result := by + rintro ⟨entry, _⟩ + have rejected : checkEntry program "unbox" = .error (.pointerEntryArgument 0) := by decide +kernel + rw [rejected] at entry + cases entry + +theorem badEntry_not_public : ¬ badEntry.PublicArguments system.enums := by + intro accepted + have free := accepted ⟨.enum "Box", [0, 0]⟩ (by simp [badEntry]) + have rejected : (Ty.enum "Box").pointerFree system.enums = false := by decide +kernel + change (Ty.enum "Box").pointerFree system.enums = true at free + rw [rejected] at free + cases free + +example : ¬ EntryDerives system badEntry := fun accepted => badEntry_not_public accepted.2.1 +example : ¬ MemoEntryDerives system badEntry := fun accepted => badEntry_not_public accepted.2.1 + +-- Pointer-free enum inputs still participate in both end-to-end completeness results. +theorem plain_derives : EncodedEntryDerives system "read_plain" (entryValues [plain]) (.field 7) := by + have executed : Aiur.run program "read_plain" [plain] 16 = .ok (.field 7, []) := by decide +kernel + obtain ⟨_, entry, locals, expr, prepared, body⟩ := run_eq_ok_iff.mp executed + have complete := compiler_heap_complete compiled entry (.intro prepared (evalExpr_spec body)) + (fun _ => (0 : Rat)) (by simp) + simpa [Value.mapAddress] using complete + +example : EncodedMemoEntryDerives system "read_plain" (entryValues [plain]) (.field 7) := plain_derives.memo + +example (accepted : EncodedEntryDerives system "read_plain" (entryValues [plain]) (.field 0)) : False := by + have wrong := compiler_entry_sound compiled accepted (by decide +kernel) + have actual : EvalCall program "read_plain" [plain] (.field 7) := + eval_spec (hints := HintProvider.unavailable) (fuel := 16) (by decide +kernel) + have same := actual.deterministic wrong (by decide +kernel) + simp [Value.mapAddress] at same + +/-- info: 'Aiur.Value.pointerFree_of_type' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Value.pointerFree_of_type + +private def checkEqual [DecidableEq α] [Repr α] (label : String) (actual expected : α) : IO Unit := do + unless actual = expected do + throw (IO.userError s!"{label}: expected {repr expected}, got {repr actual}") + +def run : IO Unit := do + for (label, actual, expected) in typeChecks do checkEqual label actual expected + for (label, actual, expected) in runtimeChecks do checkEqual label actual expected + checkEqual "pointer-free root type" (system.check ⟨[]⟩ badEntry []) (.error .pointerEntryArgument) + IO.println s!"Passed {typeChecks.length + runtimeChecks.length + 1} input type checks." + +end AiurInputTypeTests diff --git a/Aiur/AiurTests/LibraryInterfaces.lean b/Aiur/AiurTests/LibraryInterfaces.lean new file mode 100644 index 000000000..a80fab889 --- /dev/null +++ b/Aiur/AiurTests/LibraryInterfaces.lean @@ -0,0 +1,46 @@ +import Aiur.Library.U32 +import Aiur.Library.List.Word + +namespace AiurLibraryInterfaces +open Aiur + +/-- Clients are checked against interfaces, before selecting implementations. +The aliases are static module applications, with no interpreter dispatch. -/ +def clients : Modules.Program Nat := aiur_library% Library.U32.templates " +module ByteClient { + fn run(a: Field, b: Field) -> Field { + let x = B::from_field(a); + B::to_field(B::xor(x, B::from_field(b))) + } +} +module WordClient { + fn run(a: Field, b: Field) -> Field { + let x = W::from_field(a); + let y = W::from_field(b); + W::compact_field(W::compact(W::add(x, y))) + } +} +module InterfaceBytes = ByteClient::; +module InterfaceWords = WordClient::; +" + +run_cmd do + -- Sealing must also protect clients parameterized by an abstract provider. + for (signature, type) in [("U8Signature", "U8"), ("U8Signature", "Parts4"), + ("U8Signature", "Parts7"), ("U32Signature", "U32"), ("U32Signature", "Compact")] do + let source := s!"module Bad \{ fn run() -> B::{type} \{ hint::(0) } }" + let bad ← match Modules.Frontend.parse (← Lean.getEnv) source with + | .ok value => pure value + | .error error => throwError "invalid interface test: {error}" + unless (Modules.checkTemplates (Library.U32.templates.append bad)).toOption.isNone do + throwError "hint fabricated an abstract opaque {signature}::{type}" + -- A provider cannot silently omit a checked constructor from the contract. + let broken := { Library.U32.templates with modules := Library.U32.templates.modules.map fun m => + if m.name != "UInt32" then m else + { m with body := match m.body with + | .definitions d => .definitions { d with program.functions := d.program.functions.filter (·.name != "from_fields") } + | body => body } } + unless (Modules.checkTemplates broken).toOption.isNone do + throwError "incomplete word provider satisfied U32Signature" + +end AiurLibraryInterfaces diff --git a/Aiur/AiurTests/Memo.lean b/Aiur/AiurTests/Memo.lean new file mode 100644 index 000000000..6a02f770e --- /dev/null +++ b/Aiur/AiurTests/Memo.lean @@ -0,0 +1,207 @@ +import AiurTests.Semantics +import Mathlib.Tactic.FinCases +import Mathlib.Data.Fintype.Fin + +open Aiur.Scalar Aiur.Scalar.Circuit AiurSemanticsTests + +namespace AiurMemoTests + +/-- info: 'Aiur.Scalar.memo_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Scalar.memo_complete + +/-- info: 'Aiur.Scalar.memo_eval_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Scalar.memo_eval_complete + +/-- info: 'Aiur.Scalar.memo_acyclic_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Scalar.memo_acyclic_sound + +/-- info: 'Aiur.Scalar.eval_spec' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Scalar.eval_spec + +/-- info: 'Aiur.Scalar.exists_eval_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Scalar.exists_eval_iff + +def squareRule : RuleInstance twiceSystem := { + chip := squareChip + row := ⟨"square", [3, 9]⟩ + lookup := rfl + valid := by norm_num [Chip.ValidRow, squareChip, Chip.wellFormed, ArithExpr.inBounds, + Satisfies, ArithExpr.denote, Row.assignment] +} + +def twiceRule : RuleInstance twiceSystem := { + chip := twiceChip + row := ⟨"twice", [3, 18, 9, 9]⟩ + lookup := rfl + valid := by norm_num [Chip.ValidRow, twiceChip, Chip.wellFormed, ArithExpr.inBounds, + Send.inBounds, Satisfies, ArithExpr.denote, Row.assignment] +} + +/-- Both premise occurrences target node zero: the square row is present only once. -/ +def sharedGraph : MemoDerivation twiceSystem ⟨"twice", [3], 18⟩ := { + size := 2 + node := fun i => if i.val = 0 then squareRule else twiceRule + root := 1 + root_claim := rfl + target := fun _ _ => 0 + target_claim := by + intro i j + fin_cases i + · exact Fin.elim0 j + · fin_cases j <;> rfl +} + +example : MemoAccepts twiceSystem "twice" [3] 18 := ⟨sharedGraph⟩ +example : sharedGraph.size = 2 := rfl +example : twiceTree.rows.length = 3 := rfl + +theorem shared_acyclic : sharedGraph.Acyclic := by + have step : ∀ child parent, sharedGraph.Dependency child parent → child.val < parent.val := by + intro child parent ⟨j, same⟩ + fin_cases parent + · exact Fin.elim0 j + · subst child; simp [sharedGraph] + have increasing {child parent} (path : Relation.TransGen sharedGraph.Dependency child parent) : + child.val < parent.val := by + induction path with + | single edge => exact step _ _ edge + | tail _ edge ih => exact Nat.lt_trans ih (step _ _ edge) + intro i cycle + exact Nat.lt_irrefl i.val (increasing cycle) + +-- Unfolding repeats the shared provider as needed to build an ordinary tree. +example : Derives twiceSystem ⟨"twice", [3], 18⟩ := + sharedGraph.derives_of_acyclic shared_acyclic + +def sharedSource : Program Nat := scalar_aiur% " +fn square(x) { x * x } +fn twice(x) { square(x) + square(x) } +" + +theorem shared_compiles : compile (sharedSource.toField Rat) = .ok twiceSystem := by + have checked : typecheck (sharedSource.toField Rat) = .ok () := by decide +kernel + simp only [compile, checked] + simp [sharedSource, Program.toField, Program.map, Function.map, Expr.map, + Compiler.lowerFunction, Compiler.lowerExpr, Compiler.lowerArgs, Compiler.boolean, + StateT.run, StateT.bind, StateT.pure, bind, pure, Except.bind, Except.pure, + twiceSystem, squareChip, twiceChip] + rfl + +-- Soundness starts with the graph; no prior source evaluation is assumed. +example : EvalCall (sharedSource.toField Rat) "twice" [3] 18 := + memo_acyclic_sound shared_compiles sharedGraph shared_acyclic + +example : ∃ fuel, eval (sharedSource.toField Rat) "twice" [3] fuel = .ok 18 := + eval_complete (by decide +kernel) (memo_acyclic_sound shared_compiles sharedGraph shared_acyclic) + +example : MemoAccepts twiceSystem "twice" [3] 18 := + memo_eval_complete shared_compiles (fuel := 10) (by decide +kernel) + +-- This chip is the actual compilation of the nonterminating source function. +def cyclicChip : Chip Rat := { + name := "loop", arity := 0, numVars := 2, output := 0 + constraints := [ + .mul (.const 1) (.sub (.const 1) (.const 1)), + .sub (.var 0) (.var 1)] + sends := [⟨"loop", [], 1, .const 1⟩] +} + +def cyclicSystem : System Rat := ⟨[cyclicChip]⟩ + +theorem loop_compiles : compile loopProgram = .ok cyclicSystem := by + have checked : typecheck loopProgram = .ok () := by decide +kernel + simp only [compile, checked] + simp [loopProgram, Compiler.lowerFunction, Compiler.lowerExpr, Compiler.lowerArgs, + Compiler.boolean, StateT.run, StateT.bind, StateT.pure, bind, pure, Except.bind, + Except.pure, cyclicSystem, cyclicChip] + rfl + +def cyclicRule (result : Rat) : RuleInstance cyclicSystem := { + chip := cyclicChip + row := ⟨"loop", [result, result]⟩ + lookup := rfl + valid := by simp [Chip.ValidRow, cyclicChip, Chip.wellFormed, ArithExpr.inBounds, + Send.inBounds, Satisfies, ArithExpr.denote, Row.assignment] +} + +/-- A single node refers to itself and accepts any claimed result. -/ +def cyclicGraph (result : Rat) : MemoDerivation cyclicSystem ⟨"loop", [], result⟩ := { + size := 1 + node := fun _ => cyclicRule result + root := 0 + root_claim := rfl + target := fun _ _ => 0 + target_claim := by + intro i j + fin_cases j + simp [RuleInstance.conclusion, RuleInstance.premises, cyclicRule, + Chip.receive, Chip.premises, cyclicChip, Send.message, ArithExpr.denote, Row.assignment] +} + +theorem cyclic_accepts (result : Rat) : MemoAccepts cyclicSystem "loop" [] result := + ⟨cyclicGraph result⟩ + +example (result : Rat) : ¬ (cyclicGraph result).Acyclic := by + intro acyclic + exact acyclic (0 : Fin 1) (.single ⟨(0 : Fin 1), rfl⟩) + +/-- Two distinct nodes can form a cycle even though neither has a self-edge. -/ +def twoCycleGraph (result : Rat) : MemoDerivation cyclicSystem ⟨"loop", [], result⟩ := { + size := 2 + node := fun _ => cyclicRule result + root := 0 + root_claim := rfl + target := fun i _ => if i.val = 0 then 1 else 0 + target_claim := by + intro i j + fin_cases j + simp [RuleInstance.conclusion, RuleInstance.premises, cyclicRule, + Chip.receive, Chip.premises, cyclicChip, Send.message, ArithExpr.denote, Row.assignment] +} + +example (result : Rat) (i : Fin (twoCycleGraph result).size) : + ¬ (twoCycleGraph result).Dependency i i := by + rintro ⟨j, same⟩ + fin_cases i <;> simp [twoCycleGraph] at same + +example (result : Rat) : ¬ (twoCycleGraph result).Acyclic := by + intro acyclic + have first : (twoCycleGraph result).Dependency (0 : Fin 2) (1 : Fin 2) := ⟨(0 : Fin 1), rfl⟩ + have second : (twoCycleGraph result).Dependency (1 : Fin 2) (0 : Fin 2) := ⟨(0 : Fin 1), rfl⟩ + exact acyclic (0 : Fin 2) ((Relation.TransGen.single first).tail second) + +-- Nontermination rules out every acyclic witness, while cyclic ones remain accepted. +example (result : Rat) (graph : MemoDerivation cyclicSystem ⟨"loop", [], result⟩) : + ¬ graph.Acyclic := by + intro acyclic + exact loop_never_evaluates _ _ _ (memo_acyclic_sound loop_compiles graph acyclic) + +-- The graph model intentionally admits more claims than finite evaluation or tree proofs. +example (result : Rat) : ¬ EvalCall loopProgram "loop" [] result := + loop_never_evaluates _ _ _ + +example (result : Rat) : ¬ CircuitEvaluates cyclicSystem "loop" [] result := by + intro tree + exact loop_never_evaluates _ _ _ (compiler_sound loop_compiles _ _ _ tree) + +example : MemoAccepts system "main" [6, 2] 9 := memo_complete source_compiles main_evaluates + +-- Successful execution supplies a memoized graph through the evaluation predicate. +example : MemoAccepts system "main" [6, 2] 9 := + memo_eval_complete source_compiles (fuel := 10) (by decide +kernel) + +example : EvalCall (recursive.toField Rat) "even" [2] 1 := + eval_spec (fuel := 20) (by decide +kernel) + +example : ∃ fuel, eval (recursive.toField Rat) "even" [2] fuel = .ok 1 := + eval_complete (by decide +kernel) even_two + +-- Running out of fuel does not assert the absence of a finite source evaluation. +example : eval (recursive.toField Rat) "even" [2] 0 = .error .outOfFuel := by decide +kernel + +end AiurMemoTests diff --git a/Aiur/AiurTests/Modules.lean b/Aiur/AiurTests/Modules.lean new file mode 100644 index 000000000..7251cafab --- /dev/null +++ b/Aiur/AiurTests/Modules.lean @@ -0,0 +1,259 @@ +import Aiur.Modules +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +namespace AiurModuleTests +open Aiur +set_option maxRecDepth 10000 +set_option maxHeartbeats 8000000 + +def arithmetic : Modules.Program Nat := aiur_modules% " +signature Number { + type T; + const ZERO: T; + fn make(n: Field) -> T; + fn read(n: T) -> Field; +} +module Algorithm { + fn run(n: Field) -> Field { N::read(N::make(n)) + N::read(N::ZERO) } + fn identity(x: T) -> T { x } +} +module Pair: Number { + type T = (Field, Field); + const ZERO: T = (0, 0); + fn make(n: Field) -> T { (n, 7) } + fn read(n: T) -> Field { n.0 } + fn secret() -> Field { 99 } +} +module Alias: Number = Pair; +module App = Algorithm::; +module Main { + fn run(n: Field) -> Field { + App::run(n) + Algorithm::::run(n) + Pair::read(Alias::make(n)) + } +} +" + +def features : Modules.Program Nat := aiur% " +module Data { + enum Option { None, Some(T) } + struct Pair { left: T, right: T } + type Words = [Field; 2]; + const zero = 0; + const unit = Option::::None; + const cell = &(1, 2); + fn identity(x: T) -> T { x } + fn make(x: T) -> Pair { Pair { left: x, right: x } } +} +module Main { + fn run(x: Field) -> Field { + let p = Data::make(x); + let q = p with { .right = 2 }; + let Data::Pair { left: a, right: b } = q; + let v = Data::Option::::Some(a); + let Data::Option::Some(n) = v; + let &(_, c) = Data::cell; + let Data::zero = 0; + let words: Data::Words = [n, b]; + Data::identity::(words[0] + words[1] + c) + } + fn empty() -> Data::Option { Data::unit } + fn lower(n: Field) -> Field { match n { Data::zero => 4, _ => 8 } } + fn f(n: Field) -> Field { n + 1 } + fn shadow(n: Field) -> Field { let f = 90; ::f(n) + f } +} +" + +def tables : Modules.Program Nat := aiur_modules% " +signature Operation { fn apply(a: Field, b: Field) -> Field; } +signature Inputs { table pairs: (Field, Field); } +module Shared: Inputs { + table pairs: (Field, Field) { (1, 2), (2, 3) } + table hidden: Field { 91, 92 } +} +module Addition: Operation { + table sums: Field { 3, 5 } + map apply(a: Field, b: Field) -> Field = Shared::pairs => sums; +} +module Product: Operation { + table products: Field { 2, 6 } + map apply(a: Field, b: Field) -> Field = Shared::pairs => products; +} +module Local { + table inputs: (Field,) { (0,), (1,) } + table outputs: Field { 10, 11 } + map lookup(x: Field) -> Field = inputs => outputs; + fn run(x: Field) -> Field { lookup(x) } +} +module Use { + fn run(a: Field, b: Field) -> (Field, Field) { (A::apply(a,b), B::apply(a,b)) } +} +module App = Use::; +" + +def applications : Modules.Program Nat := aiur_modules% " +signature Op { fn run(x: Field) -> Field; } +module Base { fn run(x: Field) -> Field { x + 1 } } +module Wrap { fn run(x: Field) -> Field { X::run(x) + 1 } } +module Alias = Wrap::; +module Odd { fn run(n: Field) -> Field { match n { 0 => 0, _ => Even::run(n - 1) } } } +module Even { fn run(n: Field) -> Field { match n { 0 => 1, _ => Odd::run(n - 1) } } } +module Main { + fn nested(x: Field) -> Field { Wrap::>::run(x) } + fn parity(x: Field) -> Field { Even::run(x) } +} +" + +def genericInterfaces : Modules.Program Nat := aiur_modules% " +signature Boxes { + type Box; + const P: &Field; + fn make(x: T) -> Box; + fn read(x: Box) -> T; +} +module BoxImpl: Boxes { + struct Box { value: T } + const P = &7; + fn make(x: T) -> Box { Box { value: x } } + fn read(x: Box) -> T { x.value } +} +module Algorithm { + struct Envelope { value: T } + enum Packet { Value(T) } + fn run() -> Field { + let &n = X::P; + let v = Envelope::> { value: X::make(n) }; + let Envelope::> { value: x } = v; + let p = Packet::>::Value(x); + let Packet::>::Value(x) = p; + X::read(x) + } +} +" + +def execute (p : Modules.Program Nat) (entry : String) (args : List (SourceValue Rat)) := do + let p ← Modules.prepare (p.toField Rat) [entry] + p.run entry args + +def templates : Modules.Program Nat := aiur_modules% " +module Options { + enum Maybe { None, Some(T) } + const empty = Maybe::None; +} +module Alias = Options; +module Main { + fn scalar() -> Options::Maybe { Alias::empty } + fn pair() -> Options::Maybe<(Field,Field)> { Options::empty } + fn run() -> Field { + let Options::Maybe::None = scalar(); + let Options::Maybe::None = pair(); + 7 + } +} +" + +def cases : List (String × Except String (SourceValue Rat × Heap Rat) × SourceValue Rat) := [ + ("abstract functor", execute arithmetic "App::run" [.field 9], .field 9), + ("alias identities", execute arithmetic "Main::run" [.field 4], .field 12), + ("direct application", execute arithmetic "Algorithm::::run" [.field 7], .field 7), + ("qualified aggregates and consts", execute features "Main::run" [.field 5], .field 9), + ("const arm", execute features "Main::lower" [.field 0], .field 4), + ("fallback arm", execute features "Main::lower" [.field 3], .field 8), + ("rooted callable bypasses local", execute features "Main::shadow" [.field 3], .field 94), + ("shared input tables", execute tables "App::run" [.field 2,.field 3], .tuple [.field 5,.field 6]), + ("unqualified table references", execute tables "Local::run" [.field 1], .field 11), + ("nested applications", execute applications "Main::nested" [.field 1], .field 4), + ("mutual modules", execute applications "Main::parity" [.field 6], .field 1), + ("generic signature members", execute genericInterfaces "Algorithm::::run" [], .field 7), + ("contextual const templates through aliases", execute templates "Main::run" [], .field 7) +] + +run_cmd do + let env ← Lean.getEnv + -- Fragments may refer to declarations supplied by another metaprogram. + let get {α : Type} (result : Except String α) : Lean.Elab.Command.CommandElabM α := + match result with + | .ok value => pure value + | .error error => throwError "{error}" + let left ← get <| Modules.Frontend.parse env + "module Client { fn run() -> Field { Provider::value() + Adapter::::value() } }" + let right ← get <| Modules.Frontend.parse env + "signature S { fn value() -> Field; } module Provider { fn value() -> Field { 8 } } module Adapter { fn value() -> Field { X::value() + 1 } }" + let combined := left.append right + let _ ← get <| Modules.checkTemplates combined + let (value,_) ← get <| execute combined "Client::run" [] + unless value == .field 17 do throwError "composed module execution returned {repr value}" + unless (Modules.checkTemplates (combined.append right)).toOption.isNone do + throwError "composition silently reopened a module" + let rejected : List (String × String) := [ + ("fn root() -> Field { 0 }", "expected"), + ("type Root = Field;", "expected"), + ("const ROOT = 0;", "expected"), + ("module A { module B {} }", "expected"), + ("signature A { signature B {} }", "expected"), + ("module A {} signature A {}", "duplicate"), + ("module A {} module A {}", "duplicate"), + ("module A { type x = Field; const x = 0; }", "duplicate"), + ("module A: Missing {}", "unknown signature"), + ("module A = B; module B = A;", "depth"), + ("signature S { fn f() -> Field; } module M: S { fn f() -> Field { 1 } fn hidden() -> Field { 2 } } module A { fn run() -> Field { M::hidden() } }", "not exposed"), + ("signature S { type T; fn make() -> T; } module M: S { type T = Field; fn make() -> T { 1 } } module A { fn run() -> Field { M::make() + 1 } }", "type mismatch"), + ("signature S { type T; fn make() -> T; } module M: S { struct T { x: Field } fn make() -> T { T { x: 1 } } } module A { fn run() -> Field { M::make().x } }", "requires a struct"), + ("signature S { type T; } module M: S { enum T { A } } module A { fn run() -> M::T { M::T::A } }", "not exposed"), + ("signature S { type T; const C: T; } module M: S { type T = Field; const C = 7; } module Proxy { const C = M::C; } module A { fn run() -> Field { Proxy::C + 1 } }", "type mismatch"), + ("signature S { type T; fn make() -> T; } module Bad { fn run() -> Field { X::make() + 1 } }", "type mismatch"), + ("signature S { fn f() -> Field; } module Bad { fn run() -> Field { X::missing() } }", "not exposed"), + ("signature S { fn f() -> Field; } module M: S { fn f() -> () { () } }", "does not satisfy"), + ("signature S { const C: Field; } module M: S {}", "missing const"), + ("signature S { type T = Field; } module M: S { type T = (Field,Field); }", "manifest type mismatch"), + ("signature S { type T; } signature Concrete { type T = Field; } module M: S { type T = Field; } module F {} module Bad = F::;", "manifest type mismatch"), + ("signature S { fn f() -> Field; } module M: S { fn f() -> Field { 1 } fn hidden() -> Field { 2 } } signature Big { fn f() -> Field; fn hidden() -> Field; } module F {} module Bad = F::;", "missing or incompatible callable"), + ("module M { fn f() -> Field { 1 } fn main() -> Field { let f = 0; f() } }", "not callable"), + ("module M { type A = B; type B = A; }", "cyclic type alias"), + ("module A { const X = B::X; } module B { const X = A::X; }", "const"), + ("signature S { opaque type T; fn make() -> T; } module F { fn run() -> () { assert_eq!(X::make(), X::make()); } }", "pointer"), + ("signature S { opaque type T; } module F { fn run() -> X::T { hint::(()) } }", "non-opaque"), + ("signature S { type T; } module F { type Alias = X::T; fn run() -> X::T { Alias::«opaque»(&0) } }", "constructor"), + ("signature S { type T; } module F { type Alias = X::T; fn run() -> X::T { Alias::«@opaque»(&0) } }", "unexpected '@'"), + ("signature S {} module M {} module F {}", "shadows"), + ("module M { fn grow(x: T) -> T { grow((x,x)).0 } }", "changes type arguments"), + ("module A { fn f(x: T) -> T { B::g((x,x)).0 } } module B { fn g(x: T) -> T { A::f(x) } }", "changes type arguments") + ] + for (source, message) in rejected do + match Modules.Frontend.ofString env source with + | .ok _ => throwError "accepted invalid module source: {source}" + | .error error => + unless (error.splitOn message).length > 1 do + throwError "expected '{message}', got '{error}' for: {source}" + +#print axioms Modules.Prepared.run_spec +#print axioms Modules.Prepared.run_heap_spec +#print axioms Modules.Assembly.function_origin +#print axioms Modules.Compiled.check_complete +#print axioms Modules.Compiled.checkMemo_complete +#print axioms Modules.Compiled.run_complete +#print axioms Modules.Compiled.runMemo_complete +#print axioms Modules.Compiled.check_sound +#print axioms Modules.Compiled.checkerMemo_acyclic_sound +#print axioms Modules.Compiled.checkMemo_acyclic_sound + +def run : IO Unit := do + for (label, actual, expected) in cases do + match actual with + | .ok (value, _) => unless value == expected do throw (IO.userError s!"{label}: {repr value}") + | .error e => throw (IO.userError s!"{label}: {e}") + for (p,entries) in [(arithmetic,["App::run","Algorithm::::run","Algorithm::::run"]), + (features,["Main::run","Main::lower","Main::shadow"]), (tables,["App::run","Local::run"]), + (applications,["Main::nested","Main::parity"]), (genericInterfaces,["Algorithm::::run"]), + (templates,["Main::run"])] do + let .ok prepared := Modules.prepare (p.toField Rat) entries | throw (IO.userError "module preparation failed") + let .ok compiled := prepared.compile | throw (IO.userError "module circuit compilation failed") + unless compiled.circuit.system.chips.length > 0 do throw (IO.userError "no compiled modules") + let .ok prepared := Modules.prepare (arithmetic.toField Rat) + ["App::run","Algorithm::::run","Algorithm::::run"] | throw (IO.userError "alias preparation failed") + unless prepared.entries.eraseDups.length == 1 do throw (IO.userError "module aliases duplicated an instance") + unless (prepared.run "Pair::secret" []).toOption.isNone do throw (IO.userError "unselected private entry") + unless (Modules.prepare (arithmetic.toField Rat) ["Pair::secret"]).toOption.isNone do throw (IO.userError "private entry accepted") + IO.println s!"Passed {cases.length} module execution checks, module rejections, shared-instance checks, and 6 compilations." + +end AiurModuleTests diff --git a/Aiur/AiurTests/Opacity.lean b/Aiur/AiurTests/Opacity.lean new file mode 100644 index 000000000..1a51bec6a --- /dev/null +++ b/Aiur/AiurTests/Opacity.lean @@ -0,0 +1,207 @@ +import Aiur.Modules +import Aiur.Optimized.NativeCorrectness +import Mathlib.Algebra.Field.Rat + +namespace AiurOpacityTests +open Aiur +set_option maxRecDepth 20000 +set_option maxHeartbeats 12000000 + +def source : Modules.Program Nat := aiur% " +signature Open { type Byte; fn read(x: Byte) -> Field; } +signature Closed { + opaque type Byte; + fn make(x: Field) -> Byte; + fn read(x: Byte) -> Field; +} +module Bytes { + opaque type Byte = Field; + type Alias = Byte; + opaque type Pair = (T, T); + opaque struct Secret { value: Field } + opaque enum Choice { Empty, Some(Field) } + const ZERO: Byte = 0; + table inputs: (Field, Field) { (0, 0), (0, 1), (1, 0), (1, 1) } + table outputs: Byte { 0, 1, 1, 0 } + map raw_xor(a: Field, b: Field) -> Byte = inputs => outputs; + inline fn xor(a: Byte, b: Byte) -> Byte { raw_xor(a, b) } + fn make(x: Field) -> Byte { let 0 = x * (x - 1); x } + inline fn read(x: Byte) -> Field { x } + fn pair(x: T, y: T) -> Pair { (x, y) } + fn first(p: Pair) -> T { p.0 } + fn secret(x: Field) -> Secret { Secret { value: x } } + fn reveal(x: Secret) -> Field { x.value } + fn choice(x: Field) -> Choice { Choice::Some(x) } + fn inspect(x: Choice) -> Field { match x { Choice::Empty => 0, Choice::Some(x) => x } } + fn input(x: Alias) -> Field { x } + fn secret_input(x: Secret) -> Field { x.value } + fn choice_input(x: Choice) -> Field { inspect(x) } +} +module Copy = Bytes; +module API: Closed = Bytes; +module Transparent: Open { + type Byte = Field; + fn read(x: Byte) -> Field { x } + fn make(x: Field) -> Byte { x } +} +module Plain { + type Byte = Field; + fn make(x: Field) -> Byte { x } + fn read(x: Byte) -> Field { x } +} +module Witness { + fn run() -> Field { X::read(hint::(())) } + fn equal() -> () { let x = hint::(()); assert_eq!(x, x); } + fn input(x: X::Byte) -> Field { X::read(x) } +} +module Consumer { + fn run() -> Field { X::read(X::make(1)) } + fn input(x: X::Byte) -> Field { X::read(x) } +} +module Main { + struct Nested { value: [Bytes::Byte; 0] } + enum Maybe { Empty, Some(Bytes::Byte) } + fn raw(a: Field, b: Field) -> Field { Bytes::read(Bytes::raw_xor(a, b)) } + fn typed() -> Field { Bytes::read(Bytes::xor(Bytes::make(1), Bytes::ZERO)) } + fn copy(x: Copy::Byte) -> Bytes::Byte { x } + fn aliases() -> Field { API::read(copy(Bytes::make(1))) } + fn aggregates() -> Field { + Bytes::first(Bytes::pair(3, 9)) + Bytes::reveal(Bytes::secret(4)) + + Bytes::inspect(Bytes::choice(5)) + } + fn memory() -> Field { let p = &Bytes::make(1); Bytes::read(*p) } + fn hinted_key() -> Field { hint::(Bytes::make(1)) } + fn nested_input(x: Nested) -> () { () } + fn enum_input(x: Maybe) -> () { () } + fn pointer_input(x: &Field) -> Field { *x } +} +" + +run_cmd do + let env ← Lean.getEnv + -- Programmatically assembled declarations obey the same signature restriction. + let type : Modules.TypeMember := { name := "T", isOpaque := true, definition := some .field } + let malformed : Modules.Program Nat := { signatures := [{ name := "S", types := [type] }] } + unless (Modules.validate malformed).toOption.isNone do + throwError "accepted an opaque signature member with a manifest representation" + let accepted : List String := [ + "signature S { opaque type Box; fn make(x: T) -> Box; fn read(x: Box) -> T; } module M: S { opaque type Box = (T,); fn make(x: T) -> Box { (x,) } fn read(x: Box) -> T { x.0 } } module F { fn run() -> Field { X::read(X::make(3)) } } module A = F::;", + "signature S { opaque type Box; } module M: S { type Box = (T,); }", + "signature S { type Box; } module M { type Box = (T,); } module F { fn f() -> X::Box { hint::>(()) } } module A = F::;", + "signature S { opaque type T; } module M: S { type T = Field; fn f() -> T { hint::(()) } }", + "module M { opaque enum E { A(Field) } type Alias = E; fn f(x: Field) -> Alias { Alias::A(x) } }" + ] + for source in accepted do + let .ok program := Modules.Frontend.parse env source | + throwError "opacity regression has invalid syntax: {source}" + match Modules.checkTemplates program with + | .ok _ => pure () + | .error e => throwError "rejected valid opacity operation: {source}\n{e}" + let rejected : List String := [ + "module M { opaque type T = Field; fn f() -> T { hint::(()) } }", + "module M { opaque type T = Field; type A = T; fn f() -> A { hint::(()) } }", + "module M { opaque type T = Field; struct S { x: T } fn f() -> S { hint::(()) } }", + "module M { opaque type T = Field; enum E { None, Some(T) } fn f() -> E { hint::(()) } }", + "module M { opaque type T = Field; fn f() -> [T; 0] { hint::<[T; 0]>(()) } }", + "module M { opaque type T = Field; fn f() -> Field { match 0 { 0 => 1, _ => { let x = hint::(()); 2 } } } }", + "module M { opaque type T = Field; fn f() -> Field { hint::(hint::(() )) } }", + "module M { opaque type T = Field; } module N { fn f() -> M::T { 0 } }", + "module M { opaque type T = Field; } module N { fn f(x: M::T) -> Field { x + 1 } }", + "module M { opaque type A = Field; opaque type B = Field; } module N { fn f(x: M::A) -> M::B { x } }", + "module M { opaque type A = Field; } module N { fn f(x: M::A) -> M::A<(Field, Field)> { x } }", + "module M { opaque type T = (Field, Field); } module N { fn f(x: M::T) -> Field { x.0 } }", + "module M { opaque type T = [Field; 2]; } module N { fn f(x: M::T) -> Field { x[0] } }", + "module M { opaque type T = (Field, Field); } module N { fn f(x: M::T) -> Field { let (a, b) = x; a } }", + "module M { opaque struct S { x: Field } } module N { fn f(x: M::S) -> Field { x.x } }", + "module M { opaque struct S { x: Field } } module N { fn f() -> M::S { M::S { x: 0 } } }", + "module M { opaque struct S { x: Field } } module N { fn f(x: M::S) -> M::S { x with { .x = 1 } } }", + "module M { opaque enum E { A(Field) } } module N { fn f() -> M::E { M::E::A(0) } }", + "module M { opaque enum E { A(Field) } } module N { fn f(x: M::E) -> Field { let M::E::A(v) = x; v } }", + "module M { opaque type T = Field; type A = T; } module N { fn f() -> M::A { 0 } }", + "module M { opaque type T = Field; } module A = M; module N { fn f() -> A::T { 0 } }", + "module M { opaque type T = Field; } module A = M; module N { fn f() -> A::T { hint::(()) } }", + "module M { opaque type T = Field; const ZERO: T = 0; } module N { fn f() -> Field { M::ZERO } }", + "signature S { type T; } module M: S { opaque type T = Field; }", + "signature S { type T = &Field; }", + "signature S { opaque type T; type Alias = T; }", + "signature S { opaque type T; type Box = (A, T); }", + "signature S { type T; } module M: S { struct T { p: &Field } }", + "signature S { type T; } module M: S { opaque type Hidden = Field; struct T { x: Hidden } }", + "signature S { type T = Field; } module M: S { opaque type T = Field; }", + "signature S { fn read(x: Field) -> Field; } module M: S { opaque type T = Field; fn read(x: T) -> Field { x } }", + "signature S { fn make() -> Field; } module M: S { opaque type T = Field; fn make() -> T { 0 } }", + "signature S { const C: Field; } module M: S { opaque type T = Field; const C: T = 0; }", + "signature S { type T; } module M { opaque type T = Field; } module F {} module A = F::;", + "signature S { type T; } signature O { opaque type T; } module M: O { type T = Field; } module F {} module A = F::;", + "signature S { opaque type T; } module M { type T = Field; } module F { fn f() -> X::T { hint::(()) } } module A = F::;", + "signature S { opaque type T; } module F { fn f() -> [X::T; 0] { hint::<[X::T; 0]>(()) } }", + "signature S { type Box; } module M: S { opaque type Box = (T,); }", + "signature S { type Box; } module M: S { type Box = &T; }", + "signature S { opaque type Box; } module F { fn f() -> X::Box { hint::>(()) } }", + "signature O { type T; } signature S { opaque type T; } module M { type T = Field; } module F { fn f() -> Y::T { hint::(()) } } module A = F::;", + "module M { opaque type A = B; type B = A; }", + "module M { opaque type A = N::B; } module N { opaque type B = M::A; }", + "module M { opaque type T = N::Alias; } module A = M; module N { type Alias = A::T; }", + "module M { opaque type T = &Field; table rows: T {} }" + ] + for source in rejected do + let .ok program := Modules.Frontend.parse env source | + throwError "opacity regression has invalid syntax: {source}" + match Modules.checkTemplates program with + | .ok _ => throwError "accepted forbidden opacity operation: {source}" + | .error _ => pure () + +private def get {α : Type} : Except String α → IO α + | .ok x => pure x + | .error e => throw (IO.userError e) + +def run : IO Unit := do + let cases : List (String × List (SourceValue Rat) × SourceValue Rat) := [ + ("Main::raw", [1, 0], 1), ("Main::raw", [1, 1], 0), + ("Main::typed", [], 1), ("Main::aliases", [], 1), + ("Main::aggregates", [], 12), ("Main::memory", [], 1), + ("Main::hinted_key", [], 7), ("Witness::::run", [], 7), + ("Witness::::equal", [], .tuple []), + ("Witness::::input", [8], 8), + ("Consumer::::run", [], 1), ("Consumer::::run", [], 1) + ] + let prepared ← get <| Modules.prepare (source.toField Rat) ((cases.map (·.1)).eraseDups) + let hints := prepared.environment.source.checkedHints fun _ _ => .ok (.field 7) + let compiled ← get prepared.compile + let optimized ← get prepared.compileOptimized + for (name, args, expected) in cases do + let (actual, _) ← get <| prepared.run name args (fuel := 10000) (hints := hints) + unless actual == expected do throw (IO.userError s!"opaque source execution: {name}") + let some entry := prepared.find? name | throw (IO.userError "missing selected entry") + let coreHints := HintProvider.checked compiled.circuit.program.enums fun _ _ => .ok (.field 7) + let (after, _) ← get <| (Aiur.run compiled.circuit.program entry.resolved.name args + 10000 coreHints).mapError reprStr + unless after == expected do throw (IO.userError s!"opaque compiled execution: {name}") + unless (prepared.run "Main::raw" [2, 0]).toOption.isNone do + throw (IO.userError "raw opaque map accepted a missing input") + for name in ["Bytes::input", "Copy::input", "Bytes::secret_input", "Bytes::choice_input", + "Main::copy", "Main::nested_input", "Main::enum_input", "Main::pointer_input", + "Consumer::::input", "Consumer::::input"] do + unless (Modules.prepare (source.toField Rat) [name]).toOption.isNone do + throw (IO.userError s!"opaque entry accepted: {name}") + let some raw := optimized.circuit.system.findChip? "Main::raw" | + throw (IO.userError "missing raw map entry") + unless raw.numVars == 3 && raw.sends.length == 1 do + throw (IO.userError "opaque alias added representation columns or lookups") + for (a, b, result) in [(0, 0, 0), (0, 1, 1), (1, 0, 1), (1, 1, 0)] do + let row : Circuit.Row Rat := ⟨"Main::raw", [a, b, result]⟩ + let root : Circuit.Message Rat := ⟨"Main::raw", [.field a, .field b], .field result⟩ + let _ ← get <| optimized.check ⟨[]⟩ root.channel root.args root.result [row] + let _ ← get <| optimized.checkMemo ⟨[]⟩ root.channel root.args root.result [⟨row, 1⟩] + unless (optimized.check ⟨[]⟩ root.channel root.args (.field (result + 1)) [row]).toOption.isNone do + throw (IO.userError "wrong opaque map output accepted") + IO.println s!"Passed {cases.length} opacity execution checks, signature/entry rejections, and opaque map rows in both checkers." + +#print axioms Modules.nonOpaque_declared +#print axioms Modules.Compiled.check_complete +#print axioms Modules.Compiled.check_sound +#print axioms Modules.Compiled.checkMemo_acyclic_sound +#print axioms Optimized.ModulesArtifact.check_complete +#print axioms Optimized.ModulesArtifact.check_sound + +end AiurOpacityTests diff --git a/Aiur/AiurTests/Optimized.lean b/Aiur/AiurTests/Optimized.lean new file mode 100644 index 000000000..ec1ac4f9a --- /dev/null +++ b/Aiur/AiurTests/Optimized.lean @@ -0,0 +1,774 @@ +import Aiur.Modules +import Aiur.Optimized.NativeCorrectness +import AiurTests.Arrays +import AiurTests.Structs +import AiurTests.Modules +import AiurTests.Inlining +import Mathlib.Algebra.Field.ZMod + +namespace AiurOptimizedTests +open Aiur +set_option maxRecDepth 10000 +set_option maxHeartbeats 8000000 + +instance : Fact (Nat.Prime 3) := ⟨by decide⟩ +abbrev K := ZMod 3 + +def localSource : Program Nat := aiur% " +enum Inner { Zero, Value(Field) } +enum Outer { Empty, Wrap(Inner) } +fn pair(x: Field, y: Field) -> (Field, Field) { (-x, y + 1) } +fn literal_result() -> Field { 7 } +fn overlap(p: (Field, Field)) -> Field { + match p { (0, _) => 1, (_, 0) => 2, _ => 0 } +} +fn conjunction(x: Field, y: Field) -> Field { match (x, y) { (0, 0) => 1, _ => 2 } } +fn partial_match(x: Field) -> Field { match x { 0 => 1 } } +fn divide(x: Field, y: Field) -> Field { match x { 0 => y / y, _ => x / x } } +fn constant_division(x: Field) -> Field { x / 2 } +fn computed_division(x: Field) -> Field { x / (4 - 2) } +fn cancelled_division(x: Field, y: Field) -> Field { x / (y - y + 2) } +fn zero_constant_division(x: Field) -> Field { x / 3 } +fn guarded_constant_division(x: Field) -> Field { match x { 0 => x / 2, _ => x / 3 } } +fn discarded_division(x: Field) -> Field { let _ = x / 3; 1 } +fn nested(x: Field, y: Field) -> Field { match x { 0 => match y { 0 => 0, _ => 1 }, _ => 2 } } +fn scoped_product(x: Field, y: Field) -> Field { + match x { 0 => x * y * y * y, _ => x + y } +} +fn descendant_product(x: Field, y: Field) -> Field { + match x { 0 => match y { 0 => 0, _ => x * y * y * y }, _ => x + y } +} +fn scoped_call(x: Field, y: Field) -> Field { + match x { 0 => helper(x * y * y * y), _ => helper(x + y) } +} +fn scoped_store(x: Field, y: Field) -> Field { + match x { 0 => { let p = &(x * y * y * y); *p }, _ => x + y } +} +fn separate(x: Field, y: Field) -> Field { + let a = match x { 0 => 0, _ => 1 }; + let b = match y { 0 => 0, _ => 1 }; + a + b +} +fn product(a: Field, b: Field, c: Field, d: Field) -> Field { a * b * c * d } +fn helper(x: Field) -> Field { x * x } +fn called_divisor(x: Field) -> Field { let y = helper(x); x / (y - y + 2) } +fn forward(x: Field) -> Field { helper(x) } +fn repeated(x: Field) -> Field { let a = helper(x); let b = helper(x); a + b } +fn lookup_product(a: Field, b: Field, c: Field) -> Field { helper(a * b * c) } +fn require(x: Field) -> () { let 0 = x; () } +fn effectful_divisor(x: Field) -> Field { x / { let () = require(x); 2 } } +fn unit_call(x: Field) -> Field { let _ = require(x); 1 } +fn memory(x: Field) -> Field { let p = &x; *p } +fn guarded_memory(x: Field) -> Field { match x { 0 => 0, _ => { let p = &(1 / x); *p } } } +fn preimage(h: Field) -> Field { let w = hint::(()); let 0 = w * w - h; w } +fn failed_key() -> Field { hint::(1 / 0) } +fn enum_input(x: Outer) -> Field { + match x { Outer::Empty => 0, Outer::Wrap(Inner::Zero) => 1, Outer::Wrap(Inner::Value(a)) => a } +} +fn enum_hint() -> Outer { hint::(()) } +fn constructed_enum(x: Field) -> Outer { Outer::Wrap(Inner::Value(x)) } +fn enum_identity(x: Outer) -> Outer { x } +fn forward_enum(x: Outer) -> Outer { enum_identity(x) } +fn discard_input(x: Outer) -> () { () } +fn store_input(x: Outer) -> () { let _ = &x; () } +fn store_hint() -> () { let _ = &hint::(()); () } +fn guarded_constructor(x: Field) -> Outer { + match x { 0 => enum_identity(Outer::Wrap(Inner::Value(x))), _ => Outer::Empty } +} +fn constrained_hint() -> Outer { + let x = hint::(()); let Outer::Wrap(Inner::Value(a)) = x; x +} +fn enum_discard(x: Field) -> Field { + let p = &Outer::Wrap(Inner::Value(x)); + let _ = *p; + x +} +fn indirect_enum(x: Field) -> Field { + let p = &Inner::Value(x); + let link = &p; + let recovered = *link; + let Inner::Value(result) = *recovered; + result +} +fn load_unused(p: &Outer) -> () { let _ = *p; () } +table inputs: (Field,) { (0,), (1,), (2,) } +table outputs: Field { 1, 2, 0 } +map successor(x: Field) -> Field = inputs => outputs; +fn table_call(x: Field) -> Field { successor(x) } +" + +/-- Cyclic memo witnesses can manufacture a pointer without a store. Removing +load validation deliberately preserves the acyclicity requirement for soundness. -/ +def cyclicMemorySource : Program Nat := aiur% " +enum E { A, B } +fn forge() -> &E { forge() } +fn main() -> () { let _ = *forge(); () } +" + +def recursiveSource : Modules.Program Nat := aiur% " +module R { + fn a(x: Field) -> Field { match x { 0 => 0, _ => b(x - 1) + 1 } } + fn b(x: Field) -> Field { match x { 0 => 0, _ => a(x - 1) + 2 } } + fn c(x: Field) -> Field { match x { 0 => 0, _ => d(x - 1) + 1 } } + fn d(x: Field) -> Field { match x { 0 => 0, _ => c(x - 1) + 2 } } + fn e(x: Field) -> Field { match x { 0 => 1, _ => e(x - 1) + 2 } } + fn main(x: Field) -> (Field, Field, Field) { (a(x), c(x), e(x)) } + fn pinned(x: Field) -> Field { match x { 0 => 0, _ => b(x - 1) + 1 } } + fn branch(x: Field, y: Field, z: Field) -> Field { + match x { 0 => y * y * y * y / z, _ => z * z * z * z / y } + } +} +" + +private def get {α : Type} : Except String α → IO α + | .ok value => pure value + | .error message => throw (IO.userError message) + +private def ensure (message : String) (condition : Bool) : IO Unit := + unless condition do throw (IO.userError message) + +private def firstSome (f : α → Option β) : List α → Option β + | [] => none + | x :: xs => (f x).orElse (fun _ => firstSome f xs) + +/-- Small-field exhaustive row search with early rejection of fully assigned +equations. This is a test oracle, not production witness generation. -/ +private def search (chip : Circuit.Chip K) (rom : WireROM K) (claim : Circuit.Message K) + (allowed : Circuit.Message K → Bool) (fixed : List (Nat × K)) : + Nat → List K → Option (Circuit.Row K) + | fuel, values => + let row : Circuit.Row K := ⟨chip.name, values⟩ + let ready := chip.constraints.all fun eq => + !(Optimized.Polynomial.vars eq).all (· < values.length) || eq.denote row.assignment == 0 + if !ready then none else + match fuel with + | 0 => match chip.checkRow rom row with + | .ok (provided, required) => + if provided == claim && required.all allowed then some row else none + | .error _ => none + | fuel + 1 => + let choices := match fixed.find? (·.1 == values.length) with + | some (_, value) => [value] + | none => [0, 1, 2] + firstSome (fun value => search chip rom claim allowed fixed fuel (values ++ [value])) choices + +private def rowFor (system : Circuit.System K) (rom : WireROM K) (claim : Circuit.Message K) + (allowed : Circuit.Message K → Bool) : Option (Circuit.Row K) := do + let chip ← system.findChip? claim.channel + let fixed := (chip.inputs.flatMap WireValue.words).zip (claim.args.flatMap WireValue.words) ++ + ((chip.output.words.zip claim.result.words).filterMap fun (expr, value) => + match expr with | .var id => some (id, value) | _ => none) + search chip rom claim allowed fixed chip.numVars [] + +/-- These call-oracle cases have pointer-free interfaces; ROM cases below have +their explicit cells checked directly by the row checker. -/ +private def allowed (program : Program K) (system : Circuit.System K) (claim : Circuit.Message K) : Bool := + if system.mapClaims.any (· == claim) then true else + match claim.args.mapM (WireValue.decode system.enums) with + | none => false + | some args => + match eval program claim.channel (args.map (Value.mapAddress fun _ => (0 : Nat))) 100 with + | .error _ => false + | .ok value => (value.mapAddress (fun _ => (0 : K))).encode system.enums == some claim.result + +private def rowsFor (program : Program K) (system : Circuit.System K) (rom : WireROM K) : + Nat → Circuit.Message K → Option (List (Circuit.Row K)) + | 0, _ => none + | fuel + 1, claim => do + if system.mapClaims.any (· == claim) then return [] + let row ← rowFor system rom claim (allowed program system) + let chip ← system.findChip? claim.channel + let children ← (chip.premises row).mapM (rowsFor program system rom fuel) + return row :: children.flatten + +private def checkCase (program : Program K) (compiled : Optimized.Artifact K) + (name : String) (args : List (WireValue K)) (result : WireValue K) (expected : Bool) + (rom : WireROM K := ⟨[]⟩) : IO Unit := do + let claim : Circuit.Message K := ⟨name, args, result⟩ + let found := rowFor compiled.system rom claim (allowed program compiled.system) + ensure s!"{name}: wrong row acceptance for {repr args} -> {repr result}" + (found.isSome == expected) + +private def width [Field F] [DecidableEq F] (compiled : Optimized.Artifact F) (name : String) : Nat := + ((compiled.system.findChip? name).map (·.numVars)).getD 0 + +private def checkConstraintSimplification : IO Unit := do + let source : Program Nat := aiur% " + fn scalar(x: Field) -> Field { match x { 0 => 0, 1 => 1, 2 => 2 } } + fn pair(x: Field, y: Field) -> Field { + match (x, y) { (0, 0) => 0, (1, 1) => 1, _ => 2 } + } + fn conflicting_component(x: Field, y: Field) -> Field { + match (x, y) { (0, 0) => 0, (1, _) => 1, _ => 2 } + } + fn partial_overlap(x: Field, y: Field) -> Field { + match (x, y) { (0, 0) => 0, (0, _) => 1, _ => 2 } + } + fn overlapping(x: Field, y: Field) -> Field { + match (x, y) { (0, _) => 0, (_, 1) => 1, _ => 2 } + } + fn shadowed(x: Field, y: Field) -> Field { + match (x, y) { (0, _) => 0, (0, 0) => 1, _ => 2 } + } + fn repeated(x: Field, y: Field) -> Field { + match (x, y) { (0, _) => 0, (0, 1) => 2, (_, 1) => 1, _ => 2 } + } + fn nested(x: Field, y: Field) -> Field { + match x { 0 => match y { 0 => 0, 1 => 1, _ => 2 }, _ => 2 } + } + fn assertion(x: Field, y: Field) -> Field { + match x { 0 => { let 0 = y; 1 }, _ => 2 } + } + " + let program := source.toField K + let entries := program.functions.map (·.name) + let baseline ← get <| Optimized.compile program entries { simplifyConstraints := false } + for config in ([{}, {propagateValues := false}, {shareAuxiliaries := false}, + {eliminateSelectors := false}, {propagateScopes := false}] : List Optimized.Config) do + let compiled ← get <| Optimized.compile program entries config + for (before, after) in baseline.layouts.zip compiled.layouts do + ensure "constraint simplification split or reordered match arms" + (before.logical.choices == after.logical.choices) + if config == ({} : Optimized.Config) then + ensure "scalar: redundant failure columns were retained" + (width compiled "scalar" < width baseline "scalar") + for name in ["scalar", "pair", "conflicting_component", "nested"] do + let some before := baseline.layouts.find? (·.logical.name == name) | + throw (IO.userError s!"missing baseline layout {name}") + let some after := compiled.layouts.find? (·.logical.name == name) | + throw (IO.userError s!"missing simplified layout {name}") + ensure s!"{name}: redundant failure constraints were retained" + (after.logical.equations.size < before.logical.equations.size) + -- A default arm can still need the columns shared with this arm. + ensure s!"{name}: simplifying failure checks added columns" + (width compiled name ≤ width baseline name) + for x in ([0, 1, 2] : List K) do + for out in ([0, 1, 2] : List K) do + checkCase program compiled "scalar" [.field x] (.field out) (out == x) + for y in ([0, 1, 2] : List K) do + let args := [WireValue.field x, WireValue.field y] + for (name, expected) in [ + ("pair", if x == 0 && y == 0 then 0 else if x == 1 && y == 1 then 1 else 2), + ("conflicting_component", if x == 0 && y == 0 then 0 else if x == 1 then 1 else 2), + ("partial_overlap", if x == 0 && y == 0 then 0 else if x == 0 then 1 else 2), + ("overlapping", if x == 0 then 0 else if y == 1 then 1 else 2), + ("shadowed", if x == 0 then 0 else 2), + ("repeated", if x == 0 then 0 else if y == 1 then 1 else 2), + ("nested", if x == 0 then y else 2)] do + checkCase program compiled name args (.field out) (out == expected) + checkCase program compiled "assertion" args (.field out) + (if x == 0 then y == 0 && out == 1 else out == 2) + -- The recognizer is allowed nonlinear remainders, but its solved variable + -- must be private and have a genuinely nonzero coefficient in this field. + let equation : Optimized.Equation K := ⟨0, + .sub (.add (.var 1) (.mul (.var 0) (.var 2))) (.const 1)⟩ + let chip : Optimized.ScopedChip K := { + name := "private-witness", inputs := [.field 0], output := .tuple [] + roles := #[.input, .auxiliary 0, .auxiliary 0], aliases := #[none, none, none] + scopes := #[⟨.const 1, []⟩], equations := #[equation], calls := #[], cells := #[] } + let some (coefficient, rest) := Optimized.ConstraintElimination.isolate 1 equation.polynomial | + throw (IO.userError "private variable not isolated from nonlinear remainder") + let proposal : Optimized.ConstraintElimination.Proposal K := ⟨equation, 1, coefficient, rest⟩ + let accepts := fun candidate => decide (proposal.Certificate candidate) + ensure "valid private-witness certificate rejected" (accepts chip) + ensure "constraint elimination changed an input" (!accepts { chip with inputs := [.field 1] }) + ensure "constraint elimination changed an output" (!accepts { chip with output := .field 1 }) + ensure "constraint elimination changed an activation" + (!accepts { chip with scopes := #[⟨.var 1, []⟩] }) + ensure "constraint elimination lost a second equation" + (!accepts { chip with equations := #[equation, ⟨0, .var 1⟩] }) + ensure "constraint elimination changed a call argument" + (!accepts { chip with calls := #[⟨0, "helper", [.field (.var 1)], .tuple []⟩] }) + ensure "constraint elimination changed a call result" + (!accepts { chip with calls := #[⟨0, "helper", [], .field 1⟩] }) + ensure "constraint elimination changed a memory address" + (!accepts { chip with cells := #[⟨0, .var 1, .field (.const 0)⟩] }) + ensure "constraint elimination changed a memory payload" + (!accepts { chip with cells := #[⟨0, .const 0, .field (.var 1)⟩] }) + ensure "constraint elimination trusted a forged coefficient" + (!decide ({ proposal with coefficient := 0 }.Certificate chip)) + ensure "constraint elimination trusted a circular definition" + (!decide ({ proposal with rest := .var 1 }.Certificate chip)) + let vanished : Optimized.Equation K := + { equation with polynomial := .sub (.mul (.const 3) (.var 1)) (.const 1) } + let coefficientZero := { proposal with equation := vanished, coefficient := 0, rest := .const 2 } + ensure "constraint elimination inverted a coefficient zero in F3" + (!decide (coefficientZero.Certificate { chip with equations := #[vanished] })) + let first : Optimized.Equation K := ⟨0, .sub (.mul (.var 0) (.var 1)) (.const 1)⟩ + let second : Optimized.Equation K := ⟨0, .sub (.mul (.var 0) (.var 2)) (.const 1)⟩ + let repeated := { chip with equations := #[first, second] } + let reuse : Optimized.ConstraintElimination.Reuse K := ⟨second, 2, .var 1, first⟩ + ensure "identical residual inverse checks were not recognized" (decide (reuse.Certificate repeated)) + ensure "identical residual checks retained both auxiliaries" + ((Optimized.ConstraintElimination.run repeated).chip.equations == #[first]) + ensure "residual check reused its own equation" + (!decide ({ reuse with retained := second }.Certificate repeated)) + ensure "residual check reused an inactive sibling" + (!decide ({ reuse with retained := { first with scope := 1 } }.Certificate + { repeated with equations := #[{ first with scope := 1 }, second] })) + ensure "residual check accepted an unrelated replacement" + (!decide ({ reuse with value := .const 0 }.Certificate repeated)) + ensure "residual check changed an observable witness" + (!decide (reuse.Certificate { repeated with output := .field 2 })) + +private def checkCanonicalBoundaries : IO Unit := do + let program := localSource.toField K + let entries := ["forward_enum", "guarded_constructor", "discard_input", "store_hint"] + for config in ([{}, {propagateValues := false}, + {shareAuxiliaries := false, eliminateSelectors := false, propagateScopes := false, + simplifyConstraints := false, propagateValues := false, mergeLookups := false, + deduplicate := false}] : List Optimized.Config) do + let compiled ← get <| Optimized.compile program entries config + let original := fun name validateInputs => do + let some function := program.findFunction? name | throw s!"missing {name}" + Optimized.Compiler.function program config function validateInputs + let internal ← get (original "enum_identity" false) + ensure "internal identity validates its arguments or return" internal.choices.isEmpty + let constructed ← get (original "constructed_enum" false) + ensure "constructor return allocated validation selectors" constructed.choices.isEmpty + let input ← get (original "discard_input" true) + ensure "unused entry argument lost its validation" (!input.choices.isEmpty) + let hint ← get (original "enum_hint" false) + ensure "internal hint lost its validation" (!hint.choices.isEmpty) + for (words, canonical) in [([0, 0, 0], true), ([1, 0, 0], true), ([1, 1, 2], true), + ([2, 0, 0], false), ([0, 1, 0], false), ([1, 0, 1], false)] do + let wire : WireValue K := ⟨.enum "Outer", words⟩ + -- The entry circuit itself must reject malformed unused arguments. + checkCase program compiled "discard_input" [wire] (.tuple []) canonical + checkCase program compiled "forward_enum" [wire] wire canonical + -- Hint validation remains on the internal producer, with no return check. + checkCase program compiled "enum_hint" [] wire canonical + checkCase program compiled "constructed_enum" [.field 2] wire (words == [1, 1, 2]) + checkCase program compiled "enum_identity" [⟨.enum "Outer", [1, 1, 2]⟩] wire (words == [1, 1, 2]) + if canonical then + let claim : Circuit.Message K := ⟨"forward_enum", [wire], wire⟩ + let some rows := rowsFor program compiled.system ⟨[]⟩ 4 claim | + throw (IO.userError "missing canonical internal-call trace") + let _ ← get <| compiled.check ⟨[]⟩ claim rows + let _ ← get <| compiled.checkMemo ⟨[]⟩ claim (rows.map fun row => ⟨row, 1⟩) + -- Internal rows intentionally need not constrain arbitrary incoming encodings; + -- such a row cannot be used as a selected public entry. + let bad : WireValue K := ⟨.enum "Outer", [2, 0, 0]⟩ + let internalClaim : Circuit.Message K := ⟨"enum_identity", [bad], bad⟩ + let some row := rowFor compiled.system ⟨[]⟩ internalClaim (fun _ => false) | + throw (IO.userError "internal identity still validates arbitrary arguments") + ensure "internal function accepted as a public entry" (!(compiled.check ⟨[]⟩ internalClaim [row]).isOk) + +def lookupSource : Program Nat := aiur% " +fn square(x: Field) -> Field { x * x } +fn observe(x: Field) -> () { () } +fn unit_ordered(t: Field, x: Field) -> () { + match t { + 0 => { let () = observe(x); observe(x + 1) }, + _ => { let () = observe(x + 2); observe(x) }, + } +} +fn triple(t: Field, x: Field) -> Field { + match t { 0 => square(x), 1 => square(x + 1), _ => square(x + 2) } +} +fn ordered(t: Field, x: Field) -> Field { + match t { + 0 => { let a = square(x); let b = square(x + 1); a + b }, + _ => { let a = square(x + 2); let b = square(x); a + b }, + } +} +fn inactive(t: Field, u: Field, x: Field) -> Field { + match t { 0 => 0, _ => match u { 0 => square(x), _ => square(x + 1) } } +} +fn independent(t: Field, u: Field, x: Field) -> Field { + let a = match t { 0 => square(x), _ => 0 }; + let b = match u { 0 => square(x + 1), _ => 0 }; + a + b +} +fn mux(t: Field, x: Field, y: Field) -> (Field, Field) { + match t { 0 => (x, y), 1 => (y, x), _ => (x + y, x - y) } +} +fn memory(t: Field, x: Field) -> Field { + let p = match t { 0 => &x, 1 => &(x + 1), _ => &(x + 2) }; + *p +} +fn branchless(x: Field) -> Field { let a = square(x); let b = square(x + 1); a + b } +" + +private def checkLookupMerging : IO Unit := do + let program := lookupSource.toField K + let entries := program.functions.map (·.name) + let compiled ← get <| Optimized.compile program entries + let affine ← get <| Optimized.compile program entries { mergeLookups := false } + let chip := fun (artifact : Optimized.Artifact K) name => do + let some chip := artifact.system.findChip? name | throw s!"missing {name}" + pure chip + let triple ← get <| chip compiled "triple" + ensure "three exclusive calls did not merge" (triple.sends.length == 1 && triple.stats.maxLookupDegree == 2) + let ordered ← get <| chip compiled "ordered" + -- Only one result column aligns across these branches; the other calls stay separate. + ensure "compatible ordered calls did not merge" (ordered.sends.length < 4) + let unitOrdered ← get <| chip compiled "unit_ordered" + ensure "exclusive calls across an inactive gap did not merge" (unitOrdered.sends.length == 2) + let independent ← get <| chip compiled "independent" + ensure "independent activations lost a call" (independent.sends.length == 2) + let memory ← get <| chip compiled "memory" + ensure "exclusive stores did not merge" (memory.memory.length == 2) + ensure "quadratic returns retained merge columns" (width compiled "mux" + 2 == width affine "mux") + for layout in compiled.layouts do + ensure "lookup guard became quadratic" (layout.chip.maxLookupGuardDegree ≤ 1) + ensure "quadratic pass exceeded degree cap" (layout.chip.stats.maxConstraintDegree ≤ 3) + if layout.logical.choices.isEmpty then + ensure "branchless lookup became quadratic" (layout.chip.stats.maxLookupDegree ≤ 1) + for item in affine.system.chips do + ensure "disabled merge pass emitted quadratic payload" (item.stats.maxLookupDegree ≤ 1) + let branchless ← get <| chip compiled "branchless" + ensure "branchless repeated calls merged" (branchless.sends.length == 2) + for t in ([0, 1, 2] : List K) do + for x in ([0, 1, 2] : List K) do + let value := if t == 0 then x else if t == 1 then x + 1 else x + 2 + for result in ([0, 1, 2] : List K) do + checkCase program compiled "triple" [.field t, .field x] (.field result) (result == value * value) + checkCase program compiled "memory" [.field t, .field x] (.field result) (result == value) + ⟨[(0, .field value)]⟩ + let claim : Circuit.Message K := ⟨"triple", [.field t, .field x], .field (value * value)⟩ + let some rows := rowsFor program compiled.system ⟨[]⟩ 4 claim | + throw (IO.userError "merged lookup rows missing") + let _ ← get <| compiled.check ⟨[]⟩ claim rows + let _ ← get <| compiled.checkMemo ⟨[]⟩ claim (rows.map fun row => ⟨row, 1⟩) + let args : List (WireValue K) := [.field t, .field x] + let pair := if t == 0 then (x, x + 1) else (x + 2, x) + let claim : Circuit.Message K := ⟨"ordered", args, .field (pair.1 * pair.1 + pair.2 * pair.2)⟩ + let some row := rowFor compiled.system ⟨[]⟩ claim (allowed program compiled.system) | + throw (IO.userError "ordered merged row missing") + let expected := [pair.1, pair.2].map fun input => + Circuit.Message.mk "square" [.field input] (.field (input * input)) + ensure "lookup merging reordered active calls" (ordered.premises row == expected) + let unitClaim : Circuit.Message K := ⟨"unit_ordered", args, .tuple []⟩ + let some unitRow := rowFor compiled.system ⟨[]⟩ unitClaim (allowed program compiled.system) | + throw (IO.userError "unit ordered merged row missing") + let expected := [pair.1, pair.2].map fun input => + Circuit.Message.mk "observe" [.field input] (.tuple []) + ensure "merging across a gap reordered calls" (unitOrdered.premises unitRow == expected) + for u in ([0, 1, 2] : List K) do + let arguments : List (WireValue K) := [.field t, .field u, .field x] + let square := if u == 0 then x * x else (x + 1) * (x + 1) + checkCase program compiled "inactive" arguments (.field (if t == 0 then 0 else square)) true + let both := (if t == 0 then x * x else 0) + (if u == 0 then (x + 1) * (x + 1) else 0) + checkCase program compiled "independent" arguments (.field both) true + -- Missing selector equations cannot authorize quadratic sharing or a return cover. + let some layout := compiled.layouts.find? (·.chip.name == "triple") | + throw (IO.userError "missing triple layout") + let forged := { layout.logical with equations := #[] } + let retained := Optimized.LookupMerging.run {} forged layout.layout + ensure "merging trusted unproved control metadata" + (retained.chip == Optimized.emitChip forged layout.layout) + +def run : IO Unit := do + checkConstraintSimplification + checkLookupMerging + checkCanonicalBoundaries + let program := localSource.toField K + let entries := (program.functions.map (·.name)).filter (· != "load_unused") + let compiled ← get <| Optimized.compile program entries + let unscoped ← get <| Optimized.compile program entries { propagateScopes := false } + let unpropagated ← get <| Optimized.compile program entries { propagateValues := false } + let unshared ← get <| Optimized.compile program entries { shareAuxiliaries := false } + let uneliminated ← get <| Optimized.compile program entries + { eliminateSelectors := false, propagateValues := false } + let original := fun name => do + let some function := program.findFunction? name | throw s!"missing test function {name}" + Optimized.Compiler.function program {} function + let unusedLoad ← get (original "load_unused") + ensure "enum load allocated validation selectors" + (unusedLoad.roles.size == 4 && unusedLoad.equations.isEmpty && unusedLoad.cells.size == 1) + ensure "enum load width includes redundant validation" (width compiled "load_unused" == 4) + let discardedInput ← get (original "discard_input") + let storedInput ← get (original "store_input") + ensure "storing an already typed value added validation choices" + (storedInput.choices.size == discardedInput.choices.size && + storedInput.roles.size == discardedInput.roles.size + 1 && storedInput.cells.size == 1) + let constructedStore ← get (original "enum_discard") + ensure "constructed enum store allocated validation choices" constructedStore.choices.isEmpty + for name in ["constant_division", "computed_division"] do + let lowered ← get (original name) + ensure s!"{name}: constant division allocated an inverse witness" (lowered.roles.size == 2) + ensure s!"{name}: affine quotient retained an output column" (width compiled name == 1) + let zeroDivision ← get (original "zero_constant_division") + ensure "zero field denominator lost its inverse constraint" (zeroDivision.roles.size == 3) + for name in ["called_divisor", "effectful_divisor"] do + let some chip := compiled.system.findChip? name | throw (IO.userError s!"missing {name}") + ensure s!"{name}: constant folding discarded a call" (chip.sends.length == 1) + let product ← get (original "product") + let aliases ← get (Optimized.Alias.checkedResolve product) + let reduced ← get (Optimized.Degree.boundState {} aliases.chip) + ensure "valid degree certificate rejected" (Optimized.Degree.certify aliases.chip reduced).toOption.isSome + ensure "degree certificate accepted missing witness definitions" + (Optimized.Degree.certify aliases.chip { reduced with cache := [] }).toOption.isNone + ensure "degree certificate accepted missing defining equations" + (Optimized.Degree.certify aliases.chip + { reduced with chip.equations := reduced.chip.equations.extract 1 reduced.chip.equations.size }).toOption.isNone + let nested ← get (original "nested") + ensure "valid alias certificate rejected" (Optimized.Alias.checkedResolve nested).toOption.isSome + ensure "alias certificate accepted missing coverage equations" + (Optimized.Alias.checkedResolve { nested with equations := #[] }).toOption.isNone + let resolved ← get (Optimized.Alias.checkedResolve nested) + ensure "scoped propagation trusted missing control equations" + (Optimized.ScopedPropagation.run { resolved.chip with equations := #[] }).toOption.isNone + ensure "scoped propagation trusted forged paths" + (Optimized.ScopedPropagation.run { resolved.chip with + choices := resolved.chip.choices.map fun choice => + { choice with parent := resolved.chip.scopes.size } }).toOption.isNone + for name in ["scoped_product", "descendant_product", "scoped_call", "scoped_store"] do + ensure s!"{name}: branch equalities saved no columns" + (width compiled name < width unscoped name) + for name in ["constructed_enum", "constrained_hint"] do + ensure s!"{name}: known nested constructor retained validation selectors" + (width compiled name == 1 && width compiled name < width unpropagated name) + ensure "coefficient that vanishes in F3 was inverted" + ((Optimized.Polynomial.solution? (.mul (.const (3 : K)) (.var 0)) 0).isNone) + ensure "nonzero affine coefficient was not solved" + (Optimized.Polynomial.solution? (.sub (.mul (.const (2 : K)) (.var 0)) (.const 1)) 0 == + some (.const 2)) + let nestedLayout ← get (Optimized.layOut {} nested) + ensure "valid allocation certificate rejected" + (decide (Optimized.Allocation.Certificate nestedLayout.logical nestedLayout.layout)) + ensure "allocation certificate allowed simultaneous values to share a column" + (!decide (Optimized.Allocation.Certificate nestedLayout.logical + { nestedLayout.layout with columnOf := nestedLayout.layout.columnOf.map (fun _ => some 0) })) + ensure "control certificate trusted forged parent metadata" + (!decide (Optimized.Control.Certificate + { nestedLayout.logical with choices := nestedLayout.logical.choices.map fun choice => + { choice with parent := nestedLayout.logical.scopes.size } })) + ensure "exclusive auxiliaries were not shared" (width compiled "divide" < width unshared "divide") + ensure "parent selector was not eliminated" (width unpropagated "nested" < width uneliminated "nested") + ensure "affine outputs retained dedicated columns" + (width compiled "pair" == 2 && width compiled "pair" < width unpropagated "pair") + ensure "literal result retained a column" (width compiled "literal_result" == 0) + checkCase program compiled "literal_result" [] (.field 1) true + checkCase program compiled "literal_result" [] (.field 2) false + ensure "direct call did not reuse output" (width compiled "forward" == 2) + let some repeated := compiled.system.findChip? "repeated" | throw (IO.userError "missing repeated") + ensure "repeated call occurrences were merged" (repeated.sends.length == 2) + -- The semantic certificate must reject changes to rules or their namespace. + let certify := fun system => Optimized.Dedup.certify compiled.unmerged entries + ⟨system, compiled.representatives, #[]⟩ + ensure "valid deduplication certificate rejected" (certify compiled.system).toOption.isSome + let fewerCalls := { compiled.system with chips := compiled.system.chips.map fun chip => + if chip.name == "repeated" then { chip with sends := chip.sends.drop 1 } else chip } + ensure "certificate lost a repeated premise" (certify fewerCalls).toOption.isNone + let weaker := { compiled.system with chips := compiled.system.chips.map fun chip => + if chip.name == "helper" then { chip with constraints := [] } else chip } + ensure "certificate allowed weaker equations" (certify weaker).toOption.isNone + ensure "certificate allowed different static maps" (certify { compiled.system with maps := [] }).toOption.isNone + ensure "certificate allowed a duplicate chip" + (certify { compiled.system with chips := compiled.system.chips ++ [repeated] }).toOption.isNone + ensure "unsupported cap accepted" (Optimized.compile program entries { maxDegree := 2 }).toOption.isNone + let _ ← get <| Optimized.compile program entries { maxDegree := 4 } + for layout in compiled.layouts do + for occupants in layout.layout.occupants do + for i in occupants do + for j in occupants do + ensure "nonexclusive column occupants" (i == j || layout.logical.canShare i j) + for x in ([0, 1, 2] : List K) do + for y in ([0, 1, 2] : List K) do + for out in ([0, 1, 2] : List K) do + checkCase program compiled "overlap" [.tuple [.field x, .field y]] (.field out) + (out == if x == 0 then 1 else if y == 0 then 2 else 0) + checkCase program compiled "conjunction" [.field x, .field y] (.field out) + (out == if x == 0 && y == 0 then 1 else 2) + checkCase program compiled "divide" [.field x, .field y] (.field out) + (out == 1 && (x != 0 || y != 0)) + checkCase program compiled "cancelled_division" [.field x, .field y] (.field out) + (out == x / 2) + checkCase program compiled "nested" [.field x, .field y] (.field out) + (out == if x == 0 then (if y == 0 then 0 else 1) else 2) + for name in ["scoped_product", "descendant_product"] do + checkCase program compiled name [.field x, .field y] (.field out) + (out == if x == 0 then 0 else x + y) + checkCase program compiled "scoped_call" [.field x, .field y] (.field out) + (out == if x == 0 then 0 else (x + y) * (x + y)) + checkCase program compiled "scoped_store" [.field x, .field y] (.field out) + (out == if x == 0 then 0 else x + y) (if x == 0 then ⟨[(0, .field 0)]⟩ else ⟨[]⟩) + checkCase program compiled "separate" [.field x, .field y] (.field out) + (out == (if x == 0 then 0 else 1) + (if y == 0 then 0 else 1)) + checkCase program compiled "pair" [.field x, .field y] (.tuple [.field out, .field (y + 1)]) + (out == -x) + checkCase program compiled "product" [.field x, .field y, .field 2, .field 2] (.field out) + (out == x * y * 2 * 2) + checkCase program compiled "lookup_product" [.field x, .field y, .field 2] (.field out) + (out == (x * y * 2) * (x * y * 2)) + for out in ([0, 1, 2] : List K) do + for name in ["constant_division", "computed_division", "called_divisor"] do + checkCase program compiled name [.field x] (.field out) (out == x / 2) + for name in ["zero_constant_division", "discarded_division"] do + checkCase program compiled name [.field x] (.field out) false + for name in ["guarded_constant_division", "effectful_divisor"] do + checkCase program compiled name [.field x] (.field out) (x == 0 && out == 0) + checkCase program compiled "partial_match" [.field x] (.field out) (x == 0 && out == 1) + checkCase program compiled "preimage" [.field x] (.field out) (out * out == x) + checkCase program compiled "failed_key" [] (.field out) false + checkCase program compiled "forward" [.field x] (.field out) (out == x * x) + checkCase program compiled "repeated" [.field x] (.field out) (out == x * x + x * x) + checkCase program compiled "unit_call" [.field x] (.field out) (x == 0 && out == 1) + checkCase program compiled "table_call" [.field x] (.field out) (out == x + 1) + checkCase program compiled "memory" [.field x] (.field out) (out == x) ⟨[(0, .field x)]⟩ + let rom : WireROM K := if x == 0 then ⟨[]⟩ else ⟨[(0, .field x⁻¹)]⟩ + checkCase program compiled "guarded_memory" [.field x] (.field out) + (out == if x == 0 then 0 else x⁻¹) rom + checkCase program compiled "enum_discard" [.field x] (.field out) (out == x) + ⟨[(0, ⟨.enum "Outer", [1, 1, x]⟩)]⟩ + checkCase program compiled "indirect_enum" [.field x] (.field out) (out == x) + ⟨[(0, ⟨.enum "Inner", [1, x]⟩), (1, ⟨.ptr (.enum "Inner"), [0]⟩)]⟩ + for malformed in [([2, 0, 0] : List K), [1, 2, 0], [0, 1, 0]] do + checkCase program compiled "enum_discard" [.field x] (.field x) false + ⟨[(0, ⟨.enum "Outer", malformed⟩)]⟩ + checkCase program compiled "indirect_enum" [.field x] (.field x) false + ⟨[(0, ⟨.enum "Inner", [2, x]⟩), (1, ⟨.ptr (.enum "Inner"), [0]⟩)]⟩ + checkCase program compiled "enum_discard" [.field x] (.field x) true + ⟨[(0, ⟨.enum "Outer", [1, 1, x]⟩), (1, ⟨.enum "Outer", [2, 0, 0]⟩)]⟩ + for (words, expected) in [([0, 0, 0], true), ([1, 0, 0], true), ([1, 1, 0], true), ([1, 1, 2], true), + ([2, 0, 0], false), ([0, 1, 0], false), ([1, 0, 1], false)] do + let rom : WireROM K := ⟨[(0, ⟨.enum "Outer", words⟩)]⟩ + checkCase program compiled "store_input" [⟨.enum "Outer", words⟩] (.tuple []) expected rom + checkCase program compiled "store_hint" [] (.tuple []) expected rom + checkCase program compiled "enum_hint" [] ⟨.enum "Outer", words⟩ expected + checkCase program compiled "constrained_hint" [] ⟨.enum "Outer", words⟩ (words.take 2 == [1, 1]) + for x in ([0, 1, 2] : List K) do + checkCase program compiled "constructed_enum" [.field x] ⟨.enum "Outer", words⟩ + (words == [1, 1, x]) + checkCase program compiled "guarded_constructor" [.field x] ⟨.enum "Outer", words⟩ + (words == if x == 0 then [1, 1, 0] else [0, 0, 0]) + for (words, value) in [([0, 0, 0], 0), ([1, 0, 0], 1), ([1, 1, 2], 2)] do + for out in ([0, 1, 2] : List K) do + checkCase program compiled "enum_input" [⟨.enum "Outer", words⟩] (.field out) (out == value) + -- Whole traces need only reachable cells to decode, and may follow a pointer + -- recovered from another stored cell. + let memoryCases : List (String × WireROM K) := [ + ("enum_discard", ⟨[(0, ⟨.enum "Outer", [1, 1, 2]⟩), (1, ⟨.enum "Outer", [2, 0, 0]⟩)]⟩), + ("indirect_enum", ⟨[(0, ⟨.enum "Inner", [1, 2]⟩), (1, ⟨.ptr (.enum "Inner"), [0]⟩)]⟩)] + for (name, rom) in memoryCases do + let claim : Circuit.Message K := ⟨name, [.field 2], .field 2⟩ + let some row := rowFor compiled.system rom claim (fun _ => false) | + throw (IO.userError s!"missing valid memory row for {name}") + let _ ← get <| compiled.check rom claim [row] + let _ ← get <| compiled.checkMemo rom claim [⟨row, 1⟩] + -- A row can satisfy both lookups against conflicting cells, so address + -- uniqueness must still be checked by both whole-system checkers. + let conflictingROM : WireROM K := ⟨[(0, .field 0), (0, .field 1)]⟩ + let conflictingClaim : Circuit.Message K := ⟨"memory", [.field 0], .field 1⟩ + let some conflictingRow := rowFor compiled.system conflictingROM conflictingClaim + (allowed program compiled.system) | + throw (IO.userError "missing conflicting-ROM row for checker regression") + ensure "unit checker accepted conflicting ROM cells" + (compiled.check conflictingROM conflictingClaim [conflictingRow]).toOption.isNone + ensure "memo checker accepted conflicting ROM cells" + (compiled.checkMemo conflictingROM conflictingClaim [⟨conflictingRow, 1⟩]).toOption.isNone + -- Unrestricted cyclic memo proofs are intentionally outside load provenance. + let cyclicProgram := cyclicMemorySource.toField K + let cyclic ← get <| Optimized.compile cyclicProgram ["main"] + let reference ← get <| (Circuit.compile cyclicProgram).mapError reprStr + let cyclicROM : WireROM K := ⟨[(0, ⟨.enum "E", [2]⟩)]⟩ + let cyclicRoot : Circuit.Message K := ⟨"main", [], .tuple []⟩ + let forged : Circuit.Message K := ⟨"forge", [], ⟨.ptr (.enum "E"), [0]⟩⟩ + let some rootRow := rowFor cyclic.system cyclicROM cyclicRoot (fun _ => true) | + throw (IO.userError "missing cyclic root row") + let some forgeRow := rowFor cyclic.system cyclicROM forged (fun _ => true) | + throw (IO.userError "missing cyclic pointer row") + let _ ← get <| cyclic.checkMemo cyclicROM cyclicRoot [⟨rootRow, 1⟩, ⟨forgeRow, 2⟩] + ensure "unit checker accepted a self-supported pointer" + (cyclic.check cyclicROM cyclicRoot [rootRow, forgeRow]).toOption.isNone + ensure "reference load accepted malformed enum tag" + (rowFor reference cyclicROM cyclicRoot (fun _ => true)).isNone + -- Produce actual accepted trees of rows for both existing checkers. + for (name, args, out) in [("repeated", [.field 2], .field 2), + ("unit_call", [.field 0], .field 1), ("table_call", [.field 2], .field 0), + ("constant_division", [.field 2], .field 1), ("called_divisor", [.field 2], .field 1), + ("effectful_divisor", [.field 0], .field 0)] do + let claim : Circuit.Message K := ⟨name, args, out⟩ + let some rows := rowsFor program compiled.system ⟨[]⟩ 20 claim | + throw (IO.userError s!"could not construct rows for {name}") + let _ ← get <| compiled.check ⟨[]⟩ claim rows + let _ ← get <| compiled.checkMemo ⟨[]⟩ claim (rows.map fun row => ⟨row, 1⟩) + -- Mutually recursive copies merge, different constants and public roots do not. + let p ← get <| Modules.prepare (recursiveSource.toField K) ["R::main", "R::pinned", "R::branch"] + let optimized ← get p.compileOptimized + let plain ← get <| p.compileOptimized { deduplicate := false, shareAuxiliaries := false } + let c := optimized.circuit.artifact + let representatives := c.representatives + let rep := fun name => ((representatives.find? (·.1 == name)).map Prod.snd).getD name + ensure "mutual cycles did not merge" (rep "R::a" == rep "R::c" && rep "R::b" == rep "R::d") + ensure "different recursive rules merged" (rep "R::a" != rep "R::b" && rep "R::b" != rep "R::e") + ensure "entrypoint merged" (rep "R::pinned" == "R::pinned" && rep "R::main" == "R::main") + let unpinned ← get <| Optimized.Dedup.compute c.unmerged [] + ensure "certificate allowed merging a pinned entrypoint" + (Optimized.Dedup.certify c.unmerged ["R::pinned"] unpinned).toOption.isNone + ensure "chip count did not decrease" (c.system.chips.length + 2 == plain.circuit.system.chips.length) + ensure "branch storage did not decrease" (width c "R::branch" < width plain.circuit.artifact "R::branch") + for x in ([0, 1, 2] : List K) do + let value ← get <| p.run "R::main" [.field x] + let some result := (value.1.mapAddress (fun _ => (0 : K))).encode c.system.enums | + throw (IO.userError "cannot encode recursive result") + let claim : Circuit.Message K := ⟨"R::main", [.field x], result⟩ + let some rows := rowsFor optimized.circuit.inlined.program c.system ⟨[]⟩ 20 claim | + throw (IO.userError "recursive rows missing") + let _ ← get <| optimized.check ⟨[]⟩ "R::main" claim.args claim.result rows + let _ ← get <| optimized.checkMemo ⟨[]⟩ "R::main" claim.args claim.result (rows.map fun row => ⟨row, 1⟩) + ensure "internal representative accepted as entry" (c.check ⟨[]⟩ ⟨rep "R::a", [.field 0], .field 0⟩ []).toOption.isNone + -- Existing preparation paths cover arrays, structs, exits, functors, and inline helpers. + for (source, names) in [ + (AiurArrayTests.source, ["all_slices", "ordered", "const_pattern", "empty_error", "slice_once", "generic_enum"]), + (AiurStructTests.source, ["named", "recursive", "pointers", "early", "hinted"])] do + let prepared ← get <| Generic.prepare (source.toField Rat) + let specialized ← get <| Generic.specialize prepared names + let _ ← get specialized.compileOptimized + let modules ← get <| Modules.prepare (AiurModuleTests.arithmetic.toField Rat) ["App::run"] + let _ ← get modules.compileOptimized + let inlineEntries := (AiurInlineTests.cases.map (·.1)).eraseDups + let inlineProgram ← get <| Modules.prepare (AiurInlineTests.source.toField Rat) inlineEntries + let inlined ← get inlineProgram.compileOptimized + for name in inlined.specialized.inlineNames do + ensure "inline chip remained in optimized system" (inlined.circuit.system.findChip? name).isNone + IO.println "Passed optimized compiler checks: exhaustive F3 rows, enums, hints, ROM, both checkers, recursive deduplication, layouts, and source features." + +end AiurOptimizedTests + +#print axioms Aiur.Circuit.System.RuleEquiv.check_iff +#print axioms Aiur.Circuit.System.RuleEquiv.checkMemo_iff +#print axioms Aiur.Optimized.Artifact.dedup_check_iff +#print axioms Aiur.Optimized.Artifact.dedup_checkMemo_iff +#print axioms Aiur.Optimized.Artifact.dedup_acyclic_iff +#print axioms Aiur.Optimized.emitChip_validRow +#print axioms Aiur.Optimized.emitChip_complete +#print axioms Aiur.Optimized.Polynomial.denote_simplify +#print axioms Aiur.Optimized.Polynomial.constantInverse?_sound +#print axioms Aiur.Optimized.Polynomial.solution?_sound +#print axioms Aiur.Optimized.ScopedPropagation.equivalent +#print axioms Aiur.Optimized.ConstraintElimination.isolate_denote +#print axioms Aiur.Optimized.ConstraintElimination.Proposal.equivalent +#print axioms Aiur.Optimized.ConstraintElimination.Reuse.equivalent +#print axioms Aiur.Optimized.Propagation.Candidate.equivalent +#print axioms Aiur.Optimized.failure_certificate_iff +#print axioms Aiur.Optimized.selector_exactly_one +#print axioms Aiur.Optimized.Degree.Certificate.equivalent +#print axioms Aiur.Optimized.Alias.Certificate.equivalent +#print axioms Aiur.Optimized.Allocation.Certificate.complete +#print axioms Aiur.Optimized.layOut_correct +#print axioms Aiur.Optimized.Compiler.pattern_correct +#print axioms Aiur.Optimized.Compiler.pattern_failure_iff +#print axioms Aiur.Optimized.Compiler.failure_sound +#print axioms Aiur.Optimized.Compiler.freshValue_complete +#print axioms Aiur.Optimized.Compiler.function_sound +#print axioms Aiur.Optimized.Compiler.function_arguments_sound +#print axioms Aiur.Circuit.System.ProvenanceModel.derivation_sound +#print axioms Aiur.Optimized.compiler_entry_sound +#print axioms Aiur.Optimized.Compiler.function_complete +#print axioms Aiur.Optimized.reference_check_iff +#print axioms Aiur.Optimized.reference_checkMemo_complete +#print axioms Aiur.Optimized.reference_checkMemo_acyclic_iff +#print axioms Aiur.Optimized.reference_acyclic_iff +#print axioms Aiur.Optimized.ModulesArtifact.check_complete +#print axioms Aiur.Optimized.ModulesArtifact.checkMemo_complete +#print axioms Aiur.Optimized.ModulesArtifact.check_sound +#print axioms Aiur.Optimized.ModulesArtifact.checkMemo_acyclic_sound + +#print axioms Aiur.Optimized.LookupMerging.CallSlot.join_claims +#print axioms Aiur.Optimized.LookupMerging.mergeCalls_claims +#print axioms Aiur.Optimized.LookupMerging.Payload.join_memory +#print axioms Aiur.Optimized.LookupMerging.mergedChip_valid +#print axioms Aiur.Optimized.LookupMerging.replaceOutputs diff --git a/Aiur/AiurTests/OrPatterns.lean b/Aiur/AiurTests/OrPatterns.lean new file mode 100644 index 000000000..5871ba1cd --- /dev/null +++ b/Aiur/AiurTests/OrPatterns.lean @@ -0,0 +1,129 @@ +import Aiur.Generic +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +namespace AiurOrPatternTests +open Aiur +set_option maxRecDepth 20000 +set_option maxHeartbeats 8000000 + +def source : Generic.Program Nat := aiur% " +enum Pair { Left(T, T), Right(T, T), Empty } +struct S { a: Field, b: Field } +const zero = 0; +const one = 1; +fn literals(x: Field) -> Field { match x { 0 | 1 | 2 => 10, _ => 20 } } +fn constants(x: Field) -> Field { match x { ::zero | ::one => 11, _ => 21 } } +fn overlap(x: (Field, Field, Field)) -> Field { + let (a, 0, _) | (_, _, a) = x; a +} +fn nested(x: (Field, Field)) -> Field { let (0 | 1, a) = x; a } +fn array(x: [Field; 2]) -> Field { let [0, a] | [a, 0] = x; a } +fn repeated(x: [Field; 2]) -> Field { let [0 | 1; 2] = x; 12 } +fn generic(p: Pair) -> (T, T) { + let Pair::Left(x, y) | Pair::Right(y, x) = p; (x, y) +} +fn left() -> (Field, Field) { generic(Pair::Left(3, 5)) } +fn right() -> (Field, Field) { generic(Pair::Right(3, 5)) } +fn record(s: S) -> Field { match s { S { a: 0, b: x } | S { a: x, b: 0 } => x, _ => 19 } } +fn recordEntry(a: Field, b: Field) -> Field { record(S { a, b }) } +fn loads(p: &Field) -> Field { match p { &0 | &1 => 23, _ => 29 } } +fn loadEntry(x: Field) -> Field { loads(&x) } +fn loadedTuple(x: Field) -> Field { let &(0 | 1, a) = &(x, 8); a } +fn choosePointer(p: (&Field, Field)) -> Field { + let (a, 0) | (a, 1) = p; *a +} +fn pointerBinder(x: Field) -> Field { choosePointer((&13, x)) } +fn scrutinee() -> (Field, Field) { debug!(\"scrutinee\"); (*&1, *&8) } +fn once() -> Field { let (0, x) | (1, x) = scrutinee(); x } +fn early(x: Field) -> Field { 'done: { let 0 | 1 = x; break 'done 31; } } +fn skip() -> Field { match 0 { 0 => 37, _ => { let 0 | 1 = 2; 1 / 0 } } } +fn noMatch() -> Field { match 4 { 0 | 1 => 0, 2 | 3 => 1 } } +fn mismatch() -> Field { let 0 | 1 = 3; 0 } +fn nestedGuard(v: ((Field, &Field), Field)) -> Field { + match v { ((1, _) | (_, &0), 0) => 41, _ => 43 } +} +fn guardedEntry(x: Field) -> Field { nestedGuard(((x, &0), 1)) } +fn badLoad(p: &Field) -> Field { match p { &0 | _ => 47 } } +fn badEntry() -> Field { badLoad(&0) } +" + +#guard (source.findFunction? "overlap").any fun definition => match definition.body with + | .letValue (.orElse _ _ _) _ _ => true + | _ => false + +def checks : List (String × List (SourceValue Rat) × SourceValue Rat × Heap Rat) := [ + ("literals", [0], 10, []), ("literals", [1], 10, []), ("literals", [2], 10, []), ("literals", [3], 20, []), + ("constants", [1], 11, []), ("constants", [2], 21, []), + ("overlap", [.tuple [7, 0, 9]], 7, []), ("overlap", [.tuple [7, 1, 9]], 9, []), + ("nested", [.tuple [1, 6]], 6, []), ("array", [.tuple [0, 6]], 6, []), + ("array", [.tuple [6, 0]], 6, []), ("repeated", [.tuple [1, 0]], 12, []), + ("left", [], .tuple [3, 5], []), ("right", [], .tuple [5, 3], []), + ("recordEntry", [0, 7], 7, []), ("recordEntry", [7, 0], 7, []), ("recordEntry", [7, 1], 19, []), + ("loadEntry", [0], 23, [0]), ("loadEntry", [1], 23, [1]), ("loadEntry", [2], 29, [2]), + ("loadedTuple", [1], 8, [.tuple [1, 8]]), + ("pointerBinder", [0], 13, [13]), ("pointerBinder", [1], 13, [13]), + ("once", [], 8, [1, 8]), ("early", [1], 31, []), ("skip", [], 37, []), + ("guardedEntry", [1], 43, [0]), ("badEntry", [], 47, [0]) +] + +run_cmd do + for text in [ + "fn f(x: Field) -> Field { match x { 0 | 0 => 1, _ => 2 } }", + "fn f(x: Field) -> Field { let 0 | (1 | 0) = x; 2 }", + "fn f(x: (Field, Field)) -> Field { let (a, 0) | (0, b) = x; a }", + "fn f(x: (Field, Field)) -> Field { let (a, 0) | (0, _) = x; a }", + "fn f(x: (Field, (Field,))) -> Field { let (a, _) | (_, a) = x; 1 }", + "fn f(x: (Field, Field)) -> Field { let (a, 0) | (a, a) = x; a }", + "fn f(x: Field) -> Field { let 0 | (0,) = x; 1 }", + "fn f(x: [Field; 2]) -> Field { let [0 | 0, _] = x; 1 }", + "fn f(p: &Field) -> Field { match p { &0 | &0 => 1, _ => 2 } }" + ] do + match Generic.Frontend.ofString (← Lean.getEnv) text with + | .error _ => pure () + | .ok _ => throwError "unexpectedly accepted or-pattern: {text}" + +instance : Fact (Nat.Prime 7) := ⟨by decide⟩ +def collision : Generic.Program Nat := aiur% "fn f(x: Field) -> Field { match x { 0 | 7 => 1, _ => 2 } }" +#guard (Generic.prepare (collision.toField (ZMod 7))).toOption.isNone + +-- The first nested alternative succeeds, then the enclosing tuple fails. +-- This must not backtrack into the alternative that dereferences the bad pointer. +def shortCircuitChecks : Except String Unit := do + let s ← Generic.prepare (source.toField Rat) + let q ← Generic.specialize s ["guardedEntry", "badEntry"] + let cases : List (String × List (SourceValue Rat) × Option (SourceValue Rat × Heap Rat)) := [ + ("nestedGuard", [.tuple [.tuple [1, .ptr .field 99], 1]], some (43, [])), + ("nestedGuard", [.tuple [.tuple [1, .ptr .field 99], 0]], some (41, [])), + ("nestedGuard", [.tuple [.tuple [0, .ptr .field 99], 1]], none), + ("badLoad", [.ptr .field 99], none)] + for (name, args, expected) in cases do + let (types, locals, body) ← (s.world.prepare name args).mapError reprStr + let actual := Generic.SourceSemantics.evalExprWith s.world Generic.SourceSemantics.unavailable types locals 1000 body [] + if actual.toOption != expected then throw s!"source short-circuit: {name}" + let (locals, body) ← (prepareCall q.program name args).mapError reprStr + let lowered := evalExpr q.program locals 1000 body [] + if lowered.toOption != expected then throw s!"lowered short-circuit: {name}" + +#guard shortCircuitChecks == .ok () + +def run : IO Unit := do + let .ok s := Generic.prepare (source.toField Rat) | throw (IO.userError "or-pattern source failed to check") + for (name, args, value, heap) in checks do + let expected := .ok (value, heap) + unless s.run name args == expected do throw (IO.userError s!"source {name}: {repr (s.run name args)}") + unless (s.runTraced name args).result == expected do throw (IO.userError s!"traced {name}") + let .ok q := Generic.specialize s [name] | throw (IO.userError s!"specializing {name}: {repr ((Generic.specialize s [name]).map (fun _ => ())) }") + unless q.coreRun name args == expected do throw (IO.userError s!"lowered {name}: {repr (q.coreRun name args)}") + let .ok _ := q.compile | throw (IO.userError s!"compiling {name}: {repr (q.compile.map (fun _ => ())) }") + for name in ["noMatch", "mismatch"] do + unless (s.run name []).toOption.isNone do throw (IO.userError s!"source accepted {name}") + let .ok q := Generic.specialize s [name] | throw (IO.userError s!"specializing {name}") + unless (q.coreRun name []).toOption.isNone do throw (IO.userError s!"lowered accepted {name}") + let .ok _ := q.compile | throw (IO.userError s!"compiling {name}") + let messages := (s.runTraced "once" []).events.filter fun event => match event with | .message _ _ => true | _ => false + unless messages == [.message "scrutinee" []] do throw (IO.userError "or-pattern evaluated scrutinee more than once") + if let .error error := shortCircuitChecks then throw (IO.userError error) + IO.println s!"Passed {checks.length * 3} or-pattern execution checks and {checks.length + 2} compilations." + +end AiurOrPatternTests diff --git a/Aiur/AiurTests/PointerPatterns.lean b/Aiur/AiurTests/PointerPatterns.lean new file mode 100644 index 000000000..b831d2fd9 --- /dev/null +++ b/Aiur/AiurTests/PointerPatterns.lean @@ -0,0 +1,203 @@ +import Aiur.Generic +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +namespace AiurPointerPatternTests +open Aiur +instance : Fact (Nat.Prime 101) := ⟨by decide⟩ +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 + +def source : Generic.Program Nat := aiur% " +type Pair = (T, T); +type Maybe = Option; +enum Option { None, Some(T) } + +fn read(&x: &T) -> T { x } +fn twice(&&x: &&Field) -> Field { x } +fn simple(x: Field) -> Field { let &a = &x; a } +fn explicit(x: Field) -> Field { let a = *(&x); a } +fn call(x: Field) -> Field { read(&x) } +fn nested(x: Field) -> Field { twice(&&x) } +fn tuple(x: Field) -> Field { let (&a, (b, &c)) = (&x, (2, &(x + 3))); a + b + c } +fn aliased(x: Field) -> Field { + let &Maybe::Some((a, b)) = &Maybe::Some((x, 3)); + a + b +} +fn once() -> Field { let &(a, b) = &(2, 3); a + b } +fn match_once(x: Field) -> Field { + match &(x, x + 1) { &(0, _) => 0, &(a, b) => a + b } +} +fn inspect(p: &Field) -> Field { match p { &0 => 7, &1 => 8, &x => x + 10 } } +fn dispatch(x: Field) -> Field { inspect(&x) } +fn let_fail() -> Field { let &(0, x) = &(1, 2); 1 / 0 } +fn match_fail() -> Field { match &2 { &0 => 1, &1 => 2 } } +fn fallback(x: Field) -> Field { + match (1, &5) { (x, &0) => x, _ => x } +} +fn inactive() -> Field { + let value = Maybe::<&Field>::None; + match value { Maybe::Some(&x) => x, Maybe::None => 17 } +} +fn guarded(value: (Field, &Field)) -> Field { + match value { (0, &x) => x, _ => 19 } +} +fn ignore(p: &Field) -> Field { let &_ = p; 23 } +fn ignored(x: Field) -> Field { ignore(&x) } +fn unreachable() -> Field { match &1 { _ => 29, &0 => 0, &0 => 1 } } +fn overlap(x: Field, y: Field) -> Field { + match (&x, &y) { (&0, _) => 31, (_, &0) => 37, _ => 41 } +} +fn singleton(x: Field) -> Field { let &(a,) = &(x,); a } +fn unit() -> () { let &() = &(); () } +" + +def runSource (name : String) (args : List (SourceValue Rat)) := do + let s ← Generic.prepare (source.toField Rat) + s.run name args + +def runSpecialized (name : String) (args : List (SourceValue Rat)) := do + let s ← Generic.prepare (source.toField Rat) + let q ← Generic.specialize s [name] + q.run name args + +def runCore (name : String) (args : List (SourceValue Rat)) := do + let s ← Generic.prepare (source.toField Rat) + let q ← Generic.specialize s [name] + q.coreRun name args + +-- Check the independent implementations around ordered loads and bindings. +#guard ([ + ("simple", [.field 13]), ("nested", [.field 5]), ("tuple", [.field 5]), + ("dispatch", [.field 0]), ("dispatch", [.field 1]), ("dispatch", [.field 2]), + ("fallback", [.field 42]), ("overlap", [.field 0, .field 0]), + ("overlap", [.field 1, .field 0]), ("let_fail", []), ("match_fail", []) +] : List (String × List (SourceValue Rat))).all fun (name, args) => + runSource name args == runCore name args + +-- The basic spelling lowers to precisely the explicit load, without a helper call. +#guard (source.findFunction? "simple").map (fun d => d.body.lower []) == + (source.findFunction? "explicit").map (fun d => d.body.lower []) + +#guard runSource "simple" [.field 13] == .ok (.field 13, [.field 13]) +#guard runSource "simple" [.field 13] == runSource "explicit" [.field 13] +#guard runSpecialized "call" [.field 13] == .ok (.field 13, [.field 13]) +#guard (runSource "nested" [.field 5]).map Prod.fst == .ok (.field 5) +#guard (runSource "tuple" [.field 5]).map Prod.fst == .ok (.field 15) +#guard (runSpecialized "aliased" [.field 5]).map Prod.fst == .ok (.field 8) +#guard runSource "once" [] == .ok (.field 5, [.tuple [.field 2, .field 3]]) +#guard runSource "match_once" [.field 4] == .ok (.field 9, [.tuple [.field 4, .field 5]]) +#guard (runSpecialized "dispatch" [.field 0]).map Prod.fst == .ok (.field 7) +#guard (runSpecialized "dispatch" [.field 1]).map Prod.fst == .ok (.field 8) +#guard (runSpecialized "dispatch" [.field 2]).map Prod.fst == .ok (.field 12) +#guard runSource "let_fail" [] == .error (reprStr EvalError.patternMismatch) +#guard runSource "match_fail" [] == .error (reprStr EvalError.noMatchingArm) +#guard (runSource "fallback" [.field 42]).map Prod.fst == .ok (.field 42) +#guard runSource "inactive" [] == .ok (.field 17, []) +#guard (runSource "ignored" [.field 1]).map Prod.fst == .ok (.field 23) +#guard (runSource "unreachable" []).map Prod.fst == .ok (.field 29) +#guard (runSource "overlap" [.field 0, .field 0]).map Prod.fst == .ok (.field 31) +#guard (runSource "overlap" [.field 1, .field 0]).map Prod.fst == .ok (.field 37) +#guard (runSource "overlap" [.field 1, .field 1]).map Prod.fst == .ok (.field 41) +#guard runSpecialized "singleton" [.field 5] == .ok (.field 5, [.tuple [.field 5]]) +#guard runSpecialized "unit" [] == .ok (.tuple [], [.tuple []]) + +-- Probe an internal call with a deliberately dangling pointer. An earlier +-- failed field test skips the read; `&_` itself always performs a read. +def runInternal (name : String) (args : List (SourceValue Rat)) := do + let s ← Generic.prepare (source.toField Rat) + let (types, locals, body) ← (s.world.prepare name args).mapError reprStr + (Generic.SourceSemantics.evalExprWith s.world Generic.SourceSemantics.unavailable types locals 100 body []).mapError reprStr + +#guard runInternal "guarded" [.tuple [.field 1, .ptr .field 99]] == .ok (.field 19, []) +#guard (runInternal "guarded" [.tuple [.field 0, .ptr .field 99]]).toOption.isNone +#guard (runInternal "ignore" [.ptr .field 99]).toOption.isNone + +-- Compilation uses the existing guarded ROM loads and keeps all call +-- dependencies visible, independently of native source execution. +#guard (do + let s ← Generic.prepare (source.toField (ZMod 101)) + let q ← Generic.specialize s ["simple", "call", "nested", "tuple", "aliased", "match_once", + "dispatch", "fallback", "inactive", "ignored", "unreachable", "overlap", "singleton", "unit", + "let_fail", "match_fail"] + return (← q.compile).system.chips.length).toOption.isSome +#guard (do + let s ← Generic.prepare (source.toField Rat) + return (← Generic.specialize s ["read"]).program.functions.length).toOption.isNone +#guard (runSource "inspect" [.ptr .field 0]).toOption.isNone +#guard (do + let s ← Generic.prepare (source.toField Rat) + return (← Generic.specialize s ["ignore"]).program.functions.length).toOption.isNone + +def collision : Generic.Program Nat := aiur% " +fn inspect(p: &Field) -> Field { match p { &1 => 0, &102 => 1, _ => 2 } } +fn main(x: Field) -> Field { inspect(&x) } +" +#guard (Generic.prepare (collision.toField (ZMod 101))).toOption.isNone + +-- Generated temporaries also avoid names in hand-built ASTs, not just names +-- which can be written as Rust-like identifiers. +def unusualName := "$pattern___________:0" +def handBuilt : Generic.Program Nat := { + functions := [{ + name := "main", params := [(unusualName, .field)], result := .field + body := .matchValue (.tuple [.literal 1, .store (.literal 5)]) [ + (.tuple [.bind unusualName, .load (.literal 0)], .var unusualName), + (.wildcard, .var unusualName)] + }] +} +#guard (do + let s ← Generic.prepare (handBuilt.toField Rat) + s.run "main" [.field 42]) == .ok (.field 42, [.field 5]) +#guard (do + let s ← Generic.prepare (handBuilt.toField Rat) + let q ← Generic.specialize s ["main"] + q.coreRun "main" [.field 42]) == .ok (.field 42, [.field 5]) + +-- Keep all original arm dependencies visible to conservative specialization, +-- even though the first arm makes the growing call unreachable at runtime. +run_cmd do + let code := "fn grow(x: T) -> Field { match &x { &a => 1, _ => grow((x, x)) } } fn main() -> Field { grow(0) }" + match Generic.Frontend.ofString (← Lean.getEnv) code with + | .error _ => pure () + | .ok _ => throwError "accepted type-changing recursion in an unreachable branch" + +run_cmd do + for code in [ + "fn f(x: Field) -> Field { let &a = x; a }", + "fn f(x: Field) -> Field { match x { &a => a } }", + "fn f(&0: &Field) -> Field { 1 }", + "fn f(p: &Field) -> Field { let &(a, b) = p; a }", + "fn f(x: Field) -> Field { let (&a, a) = (&x, x); a }", + "fn f(p: &(Field, Field)) -> Field { match p { &(0, a) => a, &(0, b) => b } }", + "fn f(p: &Field) -> Field { match p { &0 => 1, &0 => 2, _ => 3 } }", + "fn f(&x: &Field, x: Field) -> Field { x }" + ] do + match Generic.Frontend.ofString (← Lean.getEnv) code with + | .error _ => pure () + | .ok _ => throwError "unexpectedly accepted: {code}" + +def run : IO Unit := do + let checks := [ + ("pointer let", runSource "simple" [.field 13], .ok (.field 13, [.field 13])), + ("pointer parameter", runSpecialized "call" [.field 13], .ok (.field 13, [.field 13])), + ("single scrutinee evaluation", runSource "match_once" [.field 4], .ok (.field 9, [.tuple [.field 4, .field 5]])), + ("failed arm scope", runSource "fallback" [.field 42], .ok (.field 42, [.field 5])) + ] + for (name, actual, expected) in checks do + unless actual = expected do throw (IO.userError s!"{name}: expected {repr expected}, got {repr actual}") + IO.println s!"Passed {checks.length} pointer-pattern execution checks." + +/-- info: 'Aiur.Generic.PatternLowering.load_bind_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.PatternLowering.load_bind_iff + +/-- info: 'Aiur.Generic.PatternLowering.letSteps_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.PatternLowering.letSteps_iff + +/-- info: 'Aiur.Generic.PatternLowering.matchSteps_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Generic.PatternLowering.matchSteps_iff + +end AiurPointerPatternTests diff --git a/Aiur/AiurTests/Pointers.lean b/Aiur/AiurTests/Pointers.lean new file mode 100644 index 000000000..a76722fbf --- /dev/null +++ b/Aiur/AiurTests/Pointers.lean @@ -0,0 +1,191 @@ +import Aiur +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +open Aiur Aiur.Circuit + +namespace AiurPointerTests + +def sample : Program Nat := aiur% " +fn immediate(x: Field) -> Field { *&x } +fn nested(p: &&Field) -> Field { **p } +fn nested_entry(x: Field) -> Field { nested(&&x) } +fn read_pair(p: &(Field, &Field)) -> Field { let (x, q) = *p; x + *q } +fn tuple_memory(x: Field) -> Field { read_pair(&(x, &(x + 1))) } +fn pointer_projection(p: (&Field, Field)) -> Field { *p.0 + p.1 } +fn precedence(x: Field) -> Field { x * *&x + x / *&x } +fn projection_entry(x: Field) -> Field { pointer_projection((&x, x + 1)) } +fn immutable(x: Field) -> Field { let p = &x; let x = x + 1; *p } +fn share(x: Field) -> (&Field, &Field) { (&x, &x) } +fn unit() -> () { *&() } +fn singleton(x: Field) -> (Field,) { *&(x,) } +fn heterogeneous(x: Field) -> Field { + let a = &x; + let b = &(x, &a, ()); + let (_, pp, ()) = *b; + **pp +} +fn left(p: &Field, n: Field) -> Field { + match n { 0 => *p, _ => right(p, n - 1) } +} +fn right(p: &Field, n: Field) -> Field { + match n { 0 => *p, _ => left(p, n - 1) } +} +fn recursive(x: Field) -> Field { left(&x, 4) } +fn branch(tag: Field, x: Field) -> Field { match tag { 0 => x, _ => *&x } } +fn ordered(x: Field) -> (&Field, &Field) { (&x, &(x + 1)) } +fn forever(p: &Field) -> Field { forever(p) } +fn infinite(x: Field) -> Field { forever(&x) } +" + +def rationalTests : List (String × Except EvalError (SourceValue Rat) × Except EvalError (SourceValue Rat)) := [ + ("immediate store/load", eval (sample.toField Rat) "immediate" [7], .ok 7), + ("nested pointers", eval (sample.toField Rat) "nested_entry" [7], .ok 7), + ("tuple cells", eval (sample.toField Rat) "tuple_memory" [7], .ok 15), + ("pointer projection precedence", eval (sample.toField Rat) "projection_entry" [7], .ok 15), + ("unary and binary multiplication", eval (sample.toField Rat) "precedence" [7], .ok 50), + ("immutable allocation", eval (sample.toField Rat) "immutable" [7], .ok 7), + ("empty tuple cell", eval (sample.toField Rat) "unit" [], .ok (.tuple [])), + ("singleton cell", eval (sample.toField Rat) "singleton" [7], .ok (.tuple [7])), + ("heterogeneous nested cells", eval (sample.toField Rat) "heterogeneous" [7], .ok 7), + ("mutual recursion with pointers", eval (sample.toField Rat) "recursive" [7], .ok 7), + ("inactive allocation", eval (sample.toField Rat) "branch" [0, 7], .ok 7), + ("active allocation", eval (sample.toField Rat) "branch" [1, 7], .ok 7), + ("pointer entry rejected", eval (sample.toField Rat) "nested" [.ptr (.ptr .field) 0], + .error (.pointerEntryArgument 0)), + ("nested pointer entry rejected", eval (sample.toField Rat) "pointer_projection" + [.tuple [.ptr .field 0, 7]], .error (.pointerEntryArgument 0)), + ("fuel still bounds recursion", eval (sample.toField Rat) "infinite" [7] 20, .error .outOfFuel) +] + +-- Public syntax cannot inspect addresses or forge typed pointers. +run_cmd do + let env ← Lean.getEnv + for source in [ + "fn f(p: &Field) -> Field { p + 1 }", + "fn f(p: &Field) -> Field { -p }", + "fn f(p: &Field) -> Field { p * p }", + "fn f(p: &Field) -> Field { match p { 0 => 1, _ => 2 } }", + "fn f(p: &Field) -> Field { p.0 }", + "fn f(p: Field) -> Field { *p }", + "fn f() -> &Field { 0 }", + "fn f() -> &(Field,) { &1 }", + "fn f(p: &Field, q: &Field) -> Field { p == q }", + "fn f(p: &Field) -> Field { p as Field }", + "fn f(p: &Field) { *p }" + ] do + match Frontend.ofString env source with + | .error _ => pure () + | .ok _ => throwError "accepted invalid pointer program: {source}" + +example : run (sample.toField Rat) "ordered" [7] 10 = + .ok (.tuple [.ptr .field 0, .ptr .field 1], [7, 8]) := by decide +kernel +example : run (sample.toField Rat) "branch" [0, 7] 10 = .ok (7, []) := by decide +kernel +example : EvalCall (sample.toField Rat) "tuple_memory" [7] 15 := + eval_spec (hints := HintProvider.unavailable) (fuel := 20) (by decide +kernel) + +def sampleSystem : System Rat := (compile (sample.toField Rat)).toOption.getD { chips := [] } +theorem sample_compiled : compile (sample.toField Rat) = .ok sampleSystem := by + have succeeds : (compile (sample.toField Rat)).isOk = true := by decide +kernel + cases compiled : compile (sample.toField Rat) with + | error error => simp [compiled, Except.isOk, Except.toBool] at succeeds + | ok chips => simp [sampleSystem, compiled, Except.toOption] + +-- An untaken branch's store and load require no cells at all. +example : CircuitEvaluates sampleSystem ⟨[]⟩ "branch" [.field 0, .field 7] (.field 7) := by + have executed : run (sample.toField Rat) "branch" [.field 0, .field 7] 10 = + .ok (.field 7, []) := by decide +kernel + obtain ⟨_, _, locals, expr, prepared, body⟩ := run_eq_ok_iff.mp executed + have evaluated := EvalFn.intro prepared (evalExpr_spec body) + have romEval := evaluated.toROM (ROM.ofHeap_cells [] (fun _ => (0 : Rat))) + have decodedEval : ROMEvalCall ((⟨[]⟩ : WireROM Rat).decode sample.enums) + (sample.toField Rat) "branch" [.field 0, .field 7] (.field 7) := by + simpa [ROM.ofHeap, WireROM.decode, Value.mapAddress] using romEval + exact evaluation_complete_encoded sample_compiled decodedEval + (.cons (WireValue.decode_field _ 0) (.cons (WireValue.decode_field _ 7) .nil)) + (WireValue.decode_field _ 7) + +-- A circuit address need not equal the source allocator's location. +def roundtrip : Program Nat := aiur% "fn f(x: Field) -> Field { let p = &x; *p }" +def roundtripSystem : System Rat := + match Circuit.compile (roundtrip.toField Rat) with | .ok system => system | .error _ => { chips := [] } +def goodROM : WireROM Rat := ⟨[(99, 7)]⟩ +def roundtripRow : Row Rat := ⟨"f", [7, 7, 99, 7]⟩ + +theorem roundtrip_compiled : Circuit.compile (roundtrip.toField Rat) = .ok roundtripSystem := by + have succeeds : (compile (roundtrip.toField Rat)).isOk = true := by decide +kernel + cases compiled : compile (roundtrip.toField Rat) with + | error error => simp [compiled, Except.isOk, Except.toBool] at succeeds + | ok system => simp [roundtripSystem, compiled] +example : roundtripSystem.check goodROM ⟨"f", [7], 7⟩ [roundtripRow] = .ok () := by decide +kernel +example : roundtripSystem.check ⟨[]⟩ ⟨"f", [7], 7⟩ [roundtripRow] = + .error (.missingCell "f" 0) := by decide +kernel +example : roundtripSystem.check ⟨[(99, 7), (99, 8)]⟩ ⟨"f", [7], 7⟩ [roundtripRow] = + .error .invalidROM := by decide +kernel +example : roundtripSystem.check ⟨[(99, 8)]⟩ ⟨"f", [7], 7⟩ [roundtripRow] = + .error (.missingCell "f" 0) := by decide +kernel +example : roundtripSystem.check goodROM ⟨"f", [.ptr .field 99], 7⟩ [roundtripRow] = + .error .pointerEntryArgument := by decide +kernel + +-- Circuit stores may share one cell even though the source allocates twice. +def shared : Program Nat := aiur% "fn f(x: Field) -> (&Field, &Field) { (&x, &x) }" +def sharedSystem : System Rat := + match Circuit.compile (shared.toField Rat) with | .ok system => system | .error _ => { chips := [] } +example : run (shared.toField Rat) "f" [7] 10 = + .ok (.tuple [.ptr .field 0, .ptr .field 1], [7, 7]) := by decide +kernel +example : sharedSystem.check goodROM ⟨"f", [7], .tuple [.ptr .field 99, .ptr .field 99]⟩ + [⟨"f", [7, 99, 99, 99, 99]⟩] = .ok () := by decide +kernel + +instance : Fact (Nat.Prime 7) := ⟨by decide⟩ +def finiteSystem : System (ZMod 7) := + match Circuit.compile (roundtrip.toField (ZMod 7)) with | .ok system => system | .error _ => { chips := [] } +theorem finite_compiled : Circuit.compile (roundtrip.toField (ZMod 7)) = .ok finiteSystem := by + have succeeds : (compile (roundtrip.toField (ZMod 7))).isOk = true := by decide +kernel + cases compiled : compile (roundtrip.toField (ZMod 7)) with + | error error => simp [compiled, Except.isOk, Except.toBool] at succeeds + | ok system => simp [finiteSystem, compiled] +example : ∃ encode : Nat → ZMod 7, + Circuit.EncodedEntryDerives finiteSystem "f" (entryValues [3]) ((3 : SourceValue (ZMod 7)).mapAddress encode) := + compiler_run_complete finite_compiled + (show run (roundtrip.toField (ZMod 7)) "f" [3] 10 = .ok (3, [3]) from by decide +kernel) + (by decide +kernel) + +-- Any accepted finite proof must return the same field value as execution. +example (accepted : Circuit.EncodedEntryDerives roundtripSystem "f" (entryValues [7]) 8) : False := by + have wrong := compiler_entry_sound roundtrip_compiled accepted + (by decide +kernel) + have actual : EvalCall (roundtrip.toField Rat) "f" [7] 7 := + eval_spec (hints := HintProvider.unavailable) (fuel := 10) (by decide +kernel) + have equal := actual.deterministic wrong (by decide +kernel) + change (7 : SourceValue Rat) = Value.mapAddress (fun _ : Rat => 0) (.field 8) at equal + simp only [Value.mapAddress] at equal + exact (by decide +kernel : (7 : SourceValue Rat) ≠ 8) equal + +-- The theorem checks include the allocation bridge, not only pure ROM semantics. +/-- info: 'Aiur.compiler_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.compiler_heap_sound +/-- info: 'Aiur.compiler_heap_complete_finite' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.compiler_heap_complete_finite +/-- info: 'Aiur.memo_acyclic_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.memo_acyclic_heap_sound +/-- info: 'Aiur.exists_eval_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.exists_eval_iff + +private def checkEqual [DecidableEq α] [Repr α] (label : String) (actual expected : α) : IO Unit := do + unless actual = expected do + throw (IO.userError s!"{label}: expected {repr expected}, got {repr actual}") + +def run : IO Unit := do + for (label, actual, expected) in rationalTests do + checkEqual label actual expected + checkEqual "pointer program compiles" (Circuit.compile (sample.toField Rat)).isOk true + checkEqual "field specialization" (eval (sample.toField (ZMod 7)) "tuple_memory" [6]) (.ok 6) + checkEqual "shared circuit cell" (sharedSystem.check goodROM + ⟨"f", [7], .tuple [.ptr .field 99, .ptr .field 99]⟩ [⟨"f", [7, 99, 99, 99, 99]⟩]) (.ok ()) + IO.println s!"Passed {rationalTests.length + 3} pointer runtime checks." + +end AiurPointerTests diff --git a/Aiur/AiurTests/Propagation.lean b/Aiur/AiurTests/Propagation.lean new file mode 100644 index 000000000..d14987a0a --- /dev/null +++ b/Aiur/AiurTests/Propagation.lean @@ -0,0 +1,124 @@ +import Aiur.Optimized.CheckedLayout +import Mathlib.Algebra.Field.Rat + +namespace AiurPropagationTests + +open Aiur Aiur.Optimized + +private def ensure (message : String) (condition : Bool) : IO Unit := + unless condition do throw (IO.userError message) + +private def optimize (chip : Circuit.Chip Rat) : IO (Circuit.Chip Rat) := do + match Propagation.run chip with + | .error error => throw (IO.userError error) + | .ok result => + ensure "propagation produced an invalid layout" result.chip.wellFormed + return result.chip + +def copies : Circuit.Chip Rat := { + name := "copies", inputs := [.field 0], output := .field (.var 3), numVars := 4 + constraints := [.sub (.var 1) (.var 0), .sub (.var 2) (.const 3), + .sub (.var 3) (.add (.var 1) (.var 2))] + sends := [], memory := [] } + +def guarded : Circuit.Chip Rat := { + name := "guarded", inputs := [.field 0], output := .field (.var 1), numVars := 2 + constraints := [.mul (.var 0) (.sub (.var 0) (.const 1)), + .mul (.var 0) (.sub (.var 1) (.const 3))] + sends := [], memory := [] } + +/-- A linear-size circuit whose naive substitutions produce 2^depth copies of +the input in the output expression. Keep the optimized expression compact. -/ +def doubling (depth : Nat) : Circuit.Chip Rat := { + name := "doubling", inputs := [.field 0], output := .field (.var depth) + numVars := depth + 1 + constraints := (List.range depth).map fun i => + .sub (.var (i + 1)) (.add (.var i) (.var i)) + sends := [], memory := [] } + +def run : IO Unit := do + ensure "scoped search stopped at a zero coefficient instead of trying the next variable" + (ScopedPropagation.definition? (.add (.sub (.var 0) (.var 0)) (.var 1) : Polynomial Rat) == + some (1, .const 0)) + ensure "scoped search treated a nonlinear equation as an affine definition" + (ScopedPropagation.definition? (.mul (.var 0) (.var 1) : Polynomial Rat)).isNone + let copied ← optimize copies + ensure "copy/constant chain retained columns or equations" + (copied.numVars == 1 && copied.constraints.isEmpty && + copied.output == .field (.add (.var 0) (.const 3))) + for x in ([-2, 0, 7] : List Rat) do + ensure "provided affine expression changed" + (copied.checkRow ⟨[]⟩ ⟨"copies", [x]⟩ == + .ok (⟨"copies", [.field x], .field (x + 3)⟩, [])) + let constant ← optimize { + name := "constant", inputs := [], output := .field (.var 0), numVars := 1 + constraints := [.sub (.var 0) (.const 7)], sends := [], memory := [] } + ensure "constant output requires a column" + (constant.numVars == 0 && constant.output == .field (.const 7) && constant.constraints.isEmpty) + ensure "zero-column row was rejected" + (constant.checkRow ⟨[]⟩ ⟨"constant", []⟩ == .ok (⟨"constant", [], .field 7⟩, [])) + let branch ← optimize guarded + ensure "guarded definition was substituted globally" (branch.numVars == 2) + ensure "inactive branch constrained its unused value" + (branch.checkRow ⟨[]⟩ ⟨"guarded", [0, 11]⟩ == .ok (⟨"guarded", [.field 0], .field 11⟩, [])) + ensure "active branch lost its equation" (branch.checkRow ⟨[]⟩ ⟨"guarded", [1, 11]⟩).toOption.isNone + ensure "certificate accepted a guarded definition" + (!decide (({ id := 1, value := .const 3 } : Propagation.Candidate Rat).Certificate guarded)) + ensure "certificate accepted a self-reference" + (!decide (({ id := 1, value := .var 1 } : Propagation.Candidate Rat).Certificate copies)) + ensure "certificate invented an equality" + (!decide (({ id := 1, value := .const 19 } : Propagation.Candidate Rat).Certificate copies)) + let proposal : Propagation.Proposal Rat := ⟨{id := 1, value := .var 0}, 0⟩ + ensure "indexed certificate rejected its defining equation" (proposal.check copies).isSome + ensure "indexed certificate accepted an unrelated equation" + (({proposal with equationIndex := 1}).check copies).isNone + ensure "indexed certificate accepted an invalid equation index" + (({proposal with equationIndex := 100}).check copies).isNone + ensure "indexed certificate accepted a guarded definition" + (({candidate := {id := 1, value := .const 3}, equationIndex := 1} : + Propagation.Proposal Rat).check guarded).isNone + let call : Circuit.Send Rat := ⟨"callee", [.field (.var 0)], .field 1, .const 1⟩ + let called ← optimize { + name := "calls", inputs := [.field 0], output := .field (.var 2), numVars := 3 + constraints := [.sub (.var 2) (.var 1)], sends := [call, call], memory := [] } + ensure "call output copy retained a column" (called.numVars == 2) + ensure "repeated call requirements were merged" + ((called.premises ⟨"calls", [2, 5]⟩) == + [⟨"callee", [.field 2], .field 5⟩, ⟨"callee", [.field 2], .field 5⟩]) + let memory ← optimize { + name := "memory", inputs := [.field 0], output := ⟨.tuple [], []⟩, numVars := 2 + constraints := [.sub (.var 1) (.const 3)], sends := [] + memory := [⟨.var 0, .field (.var 1), .const 1⟩] } + ensure "ROM constant retained a column" (memory.numVars == 1 && memory.memory.length == 1) + ensure "ROM lookup changed after constant propagation" + (memory.checkRow ⟨[(2, .field 3)]⟩ ⟨"memory", [2]⟩).toOption.isSome + ensure "ROM membership was dropped" + (memory.checkRow ⟨[(2, .field 4)]⟩ ⟨"memory", [2]⟩).toOption.isNone + let nonlinear ← optimize { + name := "square", inputs := [.field 0], output := .field (.var 1), numVars := 2 + constraints := [.sub (.var 1) (.mul (.var 0) (.var 0))], sends := [], memory := [] } + ensure "nonlinear output bypassed the affine lookup bound" + (nonlinear.numVars == 2 && nonlinear.stats.maxLookupDegree == 1) + let cycle ← optimize { + name := "cycle", inputs := [], output := .field (.var 0), numVars := 2 + constraints := [.sub (.var 0) (.var 1), .sub (.var 1) (.var 0)], sends := [], memory := [] } + ensure "cyclic copies did not retain their free value" (cycle.numVars == 1 && cycle.constraints.isEmpty) + let doubled ← optimize (doubling 30) + ensure "linear substitutions expanded instead of collecting coefficients" + (doubled.numVars == 1 && doubled.constraints.isEmpty && + doubled.output == .field (.mul (.const (2^30)) (.var 0))) + ensure "normalized doubling chain changed the result" + (doubled.checkRow ⟨[]⟩ ⟨"doubling", [3]⟩ == + .ok (⟨"doubling", [.field 3], .field (3 * 2^30)⟩, [])) + let nested : Polynomial Rat := .mul + (.add (.var 0) (.sub (.var 1) (.var 0))) (.add (.var 0) (.var 0)) + ensure "linear parts of a nonlinear expression were not collected" + (nested.normalizeLinear == .mul (.var 1) (.mul (.const 2) (.var 0))) + IO.println "Passed propagation checks: expressions, constants, guards, ROM, repeated calls, degree bounds, and cyclic copies." + +#print axioms Propagation.Candidate.equivalent +#print axioms Propagation.compact_equivalent +#print axioms Polynomial.denote_normalizeLinear +#print axioms Circuit.Chip.Equivalent.localRule + +end AiurPropagationTests diff --git a/Aiur/AiurTests/PropagationBench.lean b/Aiur/AiurTests/PropagationBench.lean new file mode 100644 index 000000000..84ff88b67 --- /dev/null +++ b/Aiur/AiurTests/PropagationBench.lean @@ -0,0 +1,45 @@ +import Aiur.Optimized.Propagation +import Lean + +/-! Isolated physical-chip snapshots for profiling value propagation. -/ +namespace Aiur.PropagationBench +open Lean Optimized + +deriving instance ToJson, FromJson for Ty +deriving instance ToJson, FromJson for WireValue +deriving instance ToJson, FromJson for Scalar.Circuit.ArithExpr +deriving instance ToJson, FromJson for Circuit.Send +deriving instance ToJson, FromJson for Circuit.MemoryLookup +deriving instance ToJson, FromJson for Circuit.Chip + +def write [ToJson F] (path : String) (chip : Circuit.Chip F) : IO Unit := + IO.FS.writeFile path (toJson chip).compress + +def run [Field F] [DecidableEq F] [FromJson F] (path : String) + (trace : Bool := false) : IO Unit := do + let json ← IO.ofExcept (Json.parse (← IO.FS.readFile path)) + let source : Circuit.Chip F ← IO.ofExcept (fromJson? json) + IO.eprintln s!"Loaded {source.name}: {source.numVars} columns, {source.constraints.length} equations" + let start ← IO.monoMsNow + if !trace then + let result ← IO.ofExcept (Propagation.run source) + unless result.chip.wellFormed do throw (IO.userError "propagation produced an invalid chip") + IO.eprintln s!"Propagation: {(← IO.monoMsNow) - start}ms, {result.chip.numVars} columns" + return + let mut chip := source + for iteration in [:source.numVars] do + let start ← IO.monoMsNow + let proposal := Propagation.proposal? chip + IO.eprintln s!"{iteration}: candidate id {proposal.map (·.candidate.id)}" + IO.eprintln s!"{iteration}: candidate {(← IO.monoMsNow) - start}ms" + let some proposal := proposal | break + let start ← IO.monoMsNow + let some checked := proposal.check chip | throw (IO.userError "candidate certificate rejected") + IO.eprintln s!"{iteration}: certificate {(← IO.monoMsNow) - start}ms" + let start ← IO.monoMsNow + chip := Propagation.rewrite chip id checked.val.replace + IO.eprintln s!"{iteration}: rewritten equations {chip.constraints.length}" + IO.eprintln s!"{iteration}: rewrite {(← IO.monoMsNow) - start}ms" + IO.eprintln s!"Propagation steps: {(← IO.monoMsNow) - start}ms" + +end Aiur.PropagationBench diff --git a/Aiur/AiurTests/RefutableLets.lean b/Aiur/AiurTests/RefutableLets.lean new file mode 100644 index 000000000..afb1efbe8 --- /dev/null +++ b/Aiur/AiurTests/RefutableLets.lean @@ -0,0 +1,152 @@ +import Aiur +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +open Aiur Aiur.Circuit + +namespace AiurRefutableLetTests + +set_option maxRecDepth 10000 +set_option maxHeartbeats 1000000 + +def source : Program Nat := aiur% " +enum Outcome { Empty, Pair((Field, Field)) } +table inputs: (Field,) { (0,), (1,), } +table outputs: Outcome { Outcome::Empty, Outcome::Pair((0, 9)), } +map lookup(x: Field) -> Outcome = inputs => outputs; + +fn literal(x: Field) -> Field { let 0 = x; 42 } +fn nested(p: (Field, (Field, Field))) -> Field { let (0, (x, 1)) = p; x } +fn unpack(value: Outcome) -> Field { let Outcome::Pair((0, x)) = value; x } +fn shadow(x: Field) -> Field { let (0, x) = (0, x + 1); x } +fn mapped(x: Field) -> Field { let Outcome::Pair((0, x)) = lookup(x); x } +fn allocate(x: Field) -> Field { let (0, p) = (0, &x); *p } +fn reject() -> Field { let 0 = 1; 42 } +fn skip_body() -> Field { let 0 = 1; 1 / 0 } +fn rhs_error() -> Field { let 0 = 1 / 0; 42 } +fn body_error() -> Field { let 0 = 0; 1 / 0 } +fn loop(x: Field) -> Field { loop(x) } +fn lazy(x: Field) -> Field { + match x { 0 => 9, _ => { let 0 = 1; let p = &0; loop(*p) } } +} +fn reduced() -> Field { let 7 = 0; 4 } +" + +def program := source.toField Rat + +def runtimeTests : List (String × Except EvalError (SourceValue Rat) × Except EvalError (SourceValue Rat)) := [ + ("literal let succeeds", eval program "literal" [0], .ok 42), + ("literal let fails", eval program "literal" [1], .error .patternMismatch), + ("nested pattern binds", eval program "nested" [.tuple [0, .tuple [9, 1]]], .ok 9), + ("nested pattern fails", eval program "nested" [.tuple [0, .tuple [9, 2]]], .error .patternMismatch), + ("enum payload binds", eval program "unpack" [.construct "Outcome" "Pair" [.tuple [0, 8]]], .ok 8), + ("wrong enum variant", eval program "unpack" [.construct "Outcome" "Empty" []], .error .patternMismatch), + ("wrong enum payload", eval program "unpack" [.construct "Outcome" "Pair" [.tuple [1, 8]]], + .error .patternMismatch), + ("refutable binding shadows", eval program "shadow" [3], .ok 4), + ("map output matches", eval program "mapped" [1], .ok 9), + ("map output fails pattern", eval program "mapped" [0], .error .patternMismatch), + ("map error precedes matching", eval program "mapped" [2], .error (.missingMapInput "lookup")), + ("impossible let is well typed", eval program "reject" [], .error .patternMismatch), + ("mismatch skips continuation", eval program "skip_body" [], .error .patternMismatch), + ("RHS error precedes matching", eval program "rhs_error" [], .error .divisionByZero), + ("matched continuation runs", eval program "body_error" [], .error .divisionByZero), + ("inactive mismatching let", eval program "lazy" [0], .ok 9), + ("active mismatching let", eval program "lazy" [1], .error .patternMismatch), + ("literal before specialization", eval program "reduced" [], .error .patternMismatch) +] + +instance : Fact (Nat.Prime 7) := ⟨by decide⟩ +example : eval (source.toField (ZMod 7)) "reduced" [] = .ok 4 := by decide +kernel + +-- Matching never re-executes the RHS, even when it allocates a cell. +example : Aiur.run program "allocate" [8] 16 = .ok (.field 8, [.field 8]) := by decide +kernel + +-- Accepting refutable lets keeps ordinary pattern typing and scope checks. +run_cmd do + let env ← Lean.getEnv + for text in [ + "fn f() -> Field { let (0, x) = (1, 2); missing }", + "fn f() -> Field { let 0 = (0,); 1 }", + "fn f() -> Field { let (0, x, x) = (0, 1, 2); x }", + "enum E { A(Field), B } fn f() -> Field { let E::A(x, y) = E::B; x }", + "enum E { A(Field), B } fn f() -> Field { let E::Missing = E::B; 0 }", + "fn f(0: Field) -> Field { 1 }", + "enum E { A(Field), B } fn f(E::A(x): E) -> Field { x }" + ] do + match Frontend.ofString env text with + | .error _ => pure () + | .ok _ => throwError "unexpectedly accepted invalid source: {text}" + +def system : System Rat := (compile program).toOption.getD { chips := [] } +theorem compiled : compile program = .ok system := by + have succeeds : (compile program).isOk = true := by decide +kernel + cases lowered : compile program with + | error error => simp [lowered, Except.isOk, Except.toBool] at succeeds + | ok chips => simp [system, lowered, Except.toOption] + +-- Completeness covers active enum/literal tests and the map premise supplying the value. +theorem mapped_derives : EncodedEntryDerives system "mapped" (entryValues [1]) (.field 9) := by + have executed : Aiur.run program "mapped" [1] 16 = .ok (.field 9, []) := by decide +kernel + obtain ⟨_, entry, locals, expr, prepared, body⟩ := run_eq_ok_iff.mp executed + have complete := compiler_heap_complete compiled entry (.intro prepared (evalExpr_spec body)) + (fun _ => (0 : Rat)) (by simp) + simpa [Value.mapAddress] using complete + +example : EncodedMemoEntryDerives system "mapped" (entryValues [1]) (.field 9) := mapped_derives.memo + +-- Inactive mismatches still have witnesses; their calls and ROM lookups add no premises. +example : EncodedEntryDerives system "lazy" (entryValues [0]) (.field 9) := by + have executed : Aiur.run program "lazy" [0] 16 = .ok (.field 9, []) := by decide +kernel + obtain ⟨_, entry, locals, expr, prepared, body⟩ := run_eq_ok_iff.mp executed + have complete := compiler_heap_complete compiled entry (.intro prepared (evalExpr_spec body)) + (fun _ => (0 : Rat)) (by simp) + simpa [Value.mapAddress] using complete + +example : EncodedEntryDerives system "allocate" (entryValues [8]) (.field 8) := by + have executed : Aiur.run program "allocate" [8] 16 = .ok (.field 8, [.field 8]) := by decide +kernel + obtain ⟨_, entry, locals, expr, prepared, body⟩ := run_eq_ok_iff.mp executed + have complete := compiler_heap_complete compiled entry (.intro prepared (evalExpr_spec body)) + (fun _ => (99 : Rat)) (by intro i j hi hj _; simp at hi hj; omega) + simpa [Value.mapAddress] using complete + +-- No result can be justified for an active mismatching let, regardless of the witness. +theorem reject_has_no_evaluation (result : SourceValue Rat) : ¬ EvalCall program "reject" [] result := by + rintro ⟨_, heap, ⟨prepared, body⟩⟩ + have expected : prepareCall program "reject" ([] : List (SourceValue Rat)) = + .ok ([], .letValue (.literal 0) (.literal 1) (.literal 42)) := by + exact prepareCall_of_types («fn» := ⟨"reject", [], .field, + .letValue (.literal 0) (.literal 1) (.literal 42)⟩) + (by simp [program, source, Program.toField, Program.map, Program.findFunction?, + Function.map, Expr.map, Pattern.map]) (by rfl) (by simp) + obtain ⟨rfl, rfl⟩ := Prod.mk.inj (Except.ok.inj (prepared.symm.trans expected)) + cases body with + | letValue value matched _ => + cases value + simp [Pattern.bindings] at matched + +theorem reject_has_no_derivation (result : Rat) + (accepted : EncodedEntryDerives system "reject" (entryValues []) (.field result)) : False := + reject_has_no_evaluation _ (compiler_entry_sound compiled accepted (by simp [Value.pointerFree])) + +example {rom : WireROM Rat} (valid : rom.Valid) (result : Rat) + (graph : MemoDerivation system rom ⟨"reject", [], .field result⟩) (acyclic : graph.Acyclic) : False := by + apply reject_has_no_derivation result + refine ⟨[], .field result, .nil, WireValue.decode_field _ _, ?_, ?_, + rom, valid, graph.derives_of_acyclic acyclic⟩ + · exact ⟨by simp, ⟨.field result, WireValue.decode_field _ _⟩⟩ + · simp [Message.PublicArguments] + +private def checkEqual [DecidableEq α] [Repr α] (label : String) (actual expected : α) : IO Unit := do + unless actual = expected do + throw (IO.userError s!"{label}: expected {repr expected}, got {repr actual}") + +def run : IO Unit := do + for (label, actual, expected) in runtimeTests do + checkEqual label actual expected + checkEqual "let RHS allocates once" (Aiur.run program "allocate" [8] 16) (.ok (.field 8, [.field 8])) + checkEqual "let literal specializes to field" (eval (source.toField (ZMod 7)) "reduced" []) (.ok 4) + checkEqual "refutable let compilation" (compile program).isOk true + IO.println s!"Passed {runtimeTests.length + 3} refutable let checks." + +end AiurRefutableLetTests diff --git a/Aiur/AiurTests/Semantics.lean b/Aiur/AiurTests/Semantics.lean new file mode 100644 index 000000000..694ed57f7 --- /dev/null +++ b/Aiur/AiurTests/Semantics.lean @@ -0,0 +1,276 @@ +import Aiur.Scalar +import Mathlib.Algebra.Field.Rat +import Mathlib.Tactic.NormNum +import Mathlib.Tactic.Convert + +open Aiur.Scalar Aiur.Scalar.Circuit + +namespace AiurSemanticsTests + +-- Both directions of compiler correctness must remain free of admitted proofs. +/-- info: 'Aiur.Scalar.compiler_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Scalar.compiler_sound + +/-- info: 'Aiur.Scalar.evaluation_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Scalar.evaluation_complete + +/-- info: 'Aiur.Scalar.compiler_correct' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Scalar.compiler_correct + +-- The source relation needs field laws, but no decidable equality or fuel. +example [Field F] (x : F) : + EvalExpr ⟨[]⟩ [("x", x)] (.neg (.binary .add (.var "x") (.literal 1))) (-(x + 1)) := + .neg (.add (.var rfl) .literal) + +def source : Program Nat := scalar_aiur% " +fn square(x) { x * x } +fn main(x, y) { square(x / y) } +" + +theorem square_evaluates : EvalCall (source.toField Rat) "square" [3] 9 := by + refine EvalCall.intro + (defn := ⟨"square", ["x"], .binary .mul (.var "x") (.var "x")⟩) ?_ rfl ?_ + · simp [Program.findFunction?, source, Program.toField, Program.map, Function.map, Expr.map] + rw [show (9 : Rat) = 3 * 3 by norm_num] + exact .mul (.var rfl) (.var rfl) + +theorem main_evaluates : EvalCall (source.toField Rat) "main" [6, 2] 9 := by + refine EvalCall.intro + (defn := ⟨"main", ["x", "y"], .call "square" [.binary .div (.var "x") (.var "y")]⟩) ?_ rfl ?_ + · simp [Program.findFunction?, source, Program.toField, Program.map, Function.map, Expr.map] + apply EvalExpr.call (values := [3]) _ square_evaluates + apply EvalArgs.cons _ .nil + rw [show (3 : Rat) = 6 / 2 by norm_num] + exact .div (.var rfl) (.var rfl) (by decide) + +example : ¬ EvalCall (source.toField Rat) "main" [6, 2] 10 := by + intro wrong + have := main_evaluates.deterministic wrong + contradiction + +example : ¬ EvalCall (source.toField Rat) "square" [] result := by + intro evaluated + obtain ⟨defn, lookup, arity⟩ := evaluated.function_exists + cases lookup + cases arity + +-- Division by zero and an uncovered match have no successful derivations. +example (program : Program Rat) (result : Rat) : + ¬ EvalExpr program [] (.binary .div (.literal 1) (.literal 0)) result := by + intro evaluated + cases evaluated with + | div left right nonzero => + cases left + cases right + exact nonzero rfl + +example (program : Program Rat) (result : Rat) : + ¬ EvalExpr program [] (.matchValue (.literal 0) [(.literal 1, .literal 7)]) result := by + intro evaluated + cases evaluated with + | matchValue scrutinee selected _ => + cases scrutinee + cases selected with + | skip _ rest => cases rest + +-- Wildcards stop matching, even if a later branch would divide by zero. +example (program : Program Rat) : + EvalExpr program [] + (.matchValue (.literal 0) + [(.wildcard, .literal 11), (.literal 0, .binary .div (.literal 1) (.literal 0))]) 11 := + .matchValue .literal .wildcard .literal + +def recursive : Program Nat := scalar_aiur% " +fn even(n) { match n { 0 => 1, _ => odd(n - 1) } } +fn odd(n) { match n { 0 => 0, _ => even(n - 1) } } +" + +private theorem even_zero : EvalCall (recursive.toField Rat) "even" [0] 1 := by + apply EvalCall.intro (defn := (recursive.toField Rat).functions[0]) rfl rfl + conv => arg 3; simp [recursive, Program.toField, Program.map, Function.map, Expr.map, Pattern.map] + exact .matchValue (.var rfl) .literal .literal + +private theorem odd_one : EvalCall (recursive.toField Rat) "odd" [1] 1 := by + apply EvalCall.intro (defn := (recursive.toField Rat).functions[1]) rfl rfl + conv => arg 3; simp [recursive, Program.toField, Program.map, Function.map, Expr.map, Pattern.map] + refine EvalExpr.matchValue (.var rfl) (.skip (by decide) .wildcard) ?_ + refine EvalExpr.call (values := [0]) (.cons ?_ .nil) even_zero + rw [show (0 : Rat) = 1 - 1 by norm_num] + exact .sub (.var rfl) .literal + +theorem even_two : EvalCall (recursive.toField Rat) "even" [2] 1 := by + apply EvalCall.intro (defn := (recursive.toField Rat).functions[0]) rfl rfl + conv => arg 3; simp [recursive, Program.toField, Program.map, Function.map, Expr.map, Pattern.map] + refine EvalExpr.matchValue (.var rfl) (.skip (by decide) .wildcard) ?_ + refine EvalExpr.call (values := [1]) (.cons ?_ .nil) odd_one + conv => arg 4; equals (2 : Rat) - 1 => norm_num + exact .sub (.var rfl) .literal + +-- Completeness builds the recursive tree, including active wildcard inverses. +example : ∃ system, compile (recursive.toField Rat) = .ok system ∧ + CircuitEvaluates system "even" [2] 1 := by + have succeeds : (compile (recursive.toField Rat)).isOk = true := by decide +kernel + cases compiled : compile (recursive.toField Rat) with + | error error => simp [compiled, Except.isOk, Except.toBool] at succeeds + | ok system => exact ⟨system, rfl, evaluation_complete compiled even_two⟩ + +def inactiveBranches : Program Nat := scalar_aiur% " +fn choose(x) { + match x { + 0 => match x { 0 => 1 / 0, _ => looping(x) }, + 1 => 7, + 2 => 1 / 0, + _ => 9, + } +} +fn looping(x) { looping(x) } +" + +private theorem choose_literal : EvalCall (inactiveBranches.toField Rat) "choose" [1] 7 := by + apply EvalCall.intro (defn := (inactiveBranches.toField Rat).functions[0]) rfl rfl + conv => arg 3; simp [inactiveBranches, Program.toField, Program.map, Function.map, Expr.map, Pattern.map] + exact .matchValue (.var rfl) (.skip (by decide) .literal) .literal + +private theorem choose_default : EvalCall (inactiveBranches.toField Rat) "choose" [3] 9 := by + apply EvalCall.intro (defn := (inactiveBranches.toField Rat).functions[0]) rfl rfl + conv => arg 3; simp [inactiveBranches, Program.toField, Program.map, Function.map, Expr.map, Pattern.map] + exact .matchValue (.var rfl) + (.skip (by decide) (.skip (by decide) (.skip (by decide) .wildcard))) .literal + +-- Inactive arms before and after the selected arm need no evaluation proofs, +-- even when they contain nested matches, division by zero, and nontermination. +example : ∃ system, compile (inactiveBranches.toField Rat) = .ok system ∧ + CircuitEvaluates system "choose" [1] 7 ∧ CircuitEvaluates system "choose" [3] 9 := by + have succeeds : (compile (inactiveBranches.toField Rat)).isOk = true := by decide +kernel + cases compiled : compile (inactiveBranches.toField Rat) with + | error error => simp [compiled, Except.isOk, Except.toBool] at succeeds + | ok system => + exact ⟨system, rfl, evaluation_complete compiled choose_literal, + evaluation_complete compiled choose_default⟩ + +def loopProgram : Program Rat := ⟨[⟨"loop", [], .call "loop" []⟩]⟩ + +theorem loop_never_evaluates (name : String) (args : List Rat) (result : Rat) : + ¬ EvalCall loopProgram name args result := by + intro evaluated + induction evaluated using EvalCall.rec + (motive_1 := fun _ expr _ _ => expr ≠ .call "loop" []) + (motive_2 := fun _ _ _ _ => True) with + | literal | var | neg | add | sub | mul | div | matchValue => intro equality; cases equality + | call _ _ _ calleeIH => exact calleeIH.elim + | nil | cons => trivial + | intro lookup _ _ bodyIH => + simp only [Program.findFunction?, loopProgram, List.find?] at lookup + split at lookup + · cases lookup + exact bodyIH rfl + · cases lookup + +def squareChip : Chip Rat := { + name := "square", arity := 1, numVars := 2, output := 1 + constraints := [.sub (.var 1) (.mul (.var 0) (.var 0))] + sends := [] +} + +def mainChip : Chip Rat := { + name := "main", arity := 2, numVars := 5, output := 2 + constraints := [ + .mul (.const 1) (.sub (.mul (.var 1) (.var 3)) (.const 1)), + .mul (.const 1) (.sub (.const 1) (.const 1)), + .sub (.var 2) (.var 4)] + sends := [⟨"square", [.mul (.var 0) (.var 3)], 4, .const 1⟩] +} + +def system : System Rat := ⟨[squareChip, mainChip]⟩ + +-- The trees below use the actual output of the compiler. +theorem source_compiles : compile (source.toField Rat) = .ok system := by + have checked : typecheck (source.toField Rat) = .ok () := by decide +kernel + simp only [compile, checked] + simp [source, Program.toField, Program.map, Function.map, Expr.map, + Compiler.lowerFunction, Compiler.lowerExpr, Compiler.lowerArgs, Compiler.boolean, + StateT.run, StateT.bind, StateT.pure, bind, pure, Except.bind, Except.pure, + system, squareChip, mainChip] + rfl + +def squareTree : Derivation system ⟨"square", [3], 9⟩ := + .node squareChip ⟨"square", [3, 9]⟩ rfl + (by norm_num [Chip.ValidRow, squareChip, Chip.wellFormed, ArithExpr.inBounds, + Satisfies, ArithExpr.denote, Row.assignment]) .nil + +example : ¬ squareChip.ValidRow ⟨"square", [3, 10]⟩ := by + norm_num [Chip.ValidRow, squareChip, Satisfies, ArithExpr.denote, Row.assignment] + +def mainTree : Derivation system ⟨"main", [6, 2], 9⟩ := + .node mainChip ⟨"main", [6, 2, 9, 1 / 2, 9]⟩ rfl + (by norm_num [Chip.ValidRow, mainChip, Chip.wellFormed, ArithExpr.inBounds, + Send.inBounds, Satisfies, ArithExpr.denote, Row.assignment]) + (by + convert Derivations.cons squareTree Derivations.nil using 1 + norm_num [Chip.premises, mainChip, Send.message, ArithExpr.denote, Row.assignment, + List.filterMap_cons, List.filterMap_nil, List.getElem_cons_zero, List.getElem_cons_succ] + decide +kernel) + +example : CircuitEvaluates system "main" [6, 2] 9 := ⟨mainTree⟩ + +-- Soundness rules out a wrong result for every closed tree. +example (result : Rat) (derives : CircuitEvaluates system "main" [6, 2] result) : result = 9 := + (compiler_sound source_compiles "main" [6, 2] result derives).deterministic main_evaluates + +-- A disabled send requires no child proof, including a call to this same chip. +def disabledChip : Chip Rat := { + name := "disabled", arity := 0, numVars := 1, output := 0 + constraints := [.sub (.var 0) (.const 7)] + sends := [⟨"disabled", [], 0, .const 0⟩] +} + +example : Derives ⟨[disabledChip]⟩ ⟨"disabled", [], 7⟩ := + ⟨.node disabledChip ⟨"disabled", [7]⟩ rfl + (by simp [Chip.ValidRow, disabledChip, Chip.wellFormed, ArithExpr.inBounds, + Send.inBounds, Satisfies, ArithExpr.denote, Row.assignment]) .nil⟩ + +-- Two identical calls require two child occurrences and flatten to two callee rows. +def twiceChip : Chip Rat := { + name := "twice", arity := 1, numVars := 4, output := 1 + constraints := [ + .mul (.const 1) (.sub (.const 1) (.const 1)), + .mul (.const 1) (.sub (.const 1) (.const 1)), + .sub (.var 1) (.add (.var 2) (.var 3))] + sends := [⟨"square", [.var 0], 2, .const 1⟩, ⟨"square", [.var 0], 3, .const 1⟩] +} + +def twiceSystem : System Rat := ⟨[squareChip, twiceChip]⟩ + +def twiceTree : Derivation twiceSystem ⟨"twice", [3], 18⟩ := by + have child : Derivation twiceSystem ⟨"square", [3], 9⟩ := + .node squareChip ⟨"square", [3, 9]⟩ rfl + (by norm_num [Chip.ValidRow, squareChip, Chip.wellFormed, ArithExpr.inBounds, + Satisfies, ArithExpr.denote, Row.assignment]) .nil + exact .node twiceChip ⟨"twice", [3, 18, 9, 9]⟩ rfl + (by norm_num [Chip.ValidRow, twiceChip, Chip.wellFormed, ArithExpr.inBounds, + Send.inBounds, Satisfies, ArithExpr.denote, Row.assignment]) + (.cons child (.cons child .nil)) + +example : twiceTree.rows = + [⟨"twice", [3, 18, 9, 9]⟩, ⟨"square", [3, 9]⟩, ⟨"square", [3, 9]⟩] := rfl + +-- An always-enabled recursive call cannot provide its own justification. +def loopChip : Chip Rat := { + name := "loop", arity := 0, numVars := 1, output := 0 + constraints := [] + sends := [⟨"loop", [], 0, .const 1⟩] +} + +example (result : Rat) : ¬ CircuitEvaluates ⟨[loopChip]⟩ "loop" [] result := by + apply not_derives_of_no_leaves + intro chip row lookup _ + simp only [System.findChip?, List.find?] at lookup + split at lookup + · cases lookup + simp [Chip.premises, loopChip, ArithExpr.denote] + · cases lookup + +end AiurSemanticsTests diff --git a/Aiur/AiurTests/SourceEvaluation.lean b/Aiur/AiurTests/SourceEvaluation.lean new file mode 100644 index 000000000..60ac7fcf2 --- /dev/null +++ b/Aiur/AiurTests/SourceEvaluation.lean @@ -0,0 +1,171 @@ +import Aiur.Generic +import Mathlib.Algebra.Field.Rat + +namespace AiurSourceEvaluationTests +open Aiur +set_option maxRecDepth 10000 +set_option maxHeartbeats 2000000 + +-- Checking records type information without inlining source const references. +def program : Generic.Program Nat := aiur% " +type Four = [Field; 4]; +const zeros = [0; 4]; +fn repeated() -> Four { [0; 4] } +fn referenced() -> Four { zeros } +fn pattern(a: Four) -> Field { match a { [0; 4] => 1, _ => 2 } } +fn slice() -> [Field; 2] { [1, 2, 3, 4][1..3] } +fn stored() -> [&Field; 0] { [&7; 0] } +fn read() -> Field { let &x = &9; x } +fn key() -> Field { hint::(*(&3)) } +" + +#guard program.aliases.length == 1 && program.consts.length == 1 +#guard (program.findFunction? "referenced").map (·.body) == + some (.global "zeros" (some (.array .field 4))) +#guard (program.findFunction? "repeated").any fun f => match f.body with + | .repeat (.literal 0) 4 => true + | _ => false +#guard (program.findFunction? "pattern").any fun f => match f.body with + | .matchValue _ ((.repeat (.literal 0) 4, _) :: _) => true + | _ => false +#guard (program.findFunction? "slice").any fun f => match f.body with + | .slice (.array _) 1 (some 3) => true + | _ => false +#guard (program.findFunction? "read").any fun f => match f.body with + | .letValue (.load (.bind "x")) (.store _) (.var "x") => true + | _ => false + +-- These fuel bounds distinguish native source execution from desugared code. +#guard (do + let s ← Generic.prepare (program.toField Rat) + s.run "repeated" [] 2) == .ok (.tuple [0, 0, 0, 0], []) +#guard (do + let s ← Generic.prepare (program.toField Rat) + s.coreRun "repeated" [] 2) == .error (reprStr EvalError.outOfFuel) +#guard (do + let s ← Generic.prepare (program.toField Rat) + s.run "slice" [] 3) == .ok (.tuple [2, 3], []) +#guard (do + let s ← Generic.prepare (program.toField Rat) + s.run "stored" [] 3) == .ok (.tuple [], [7]) +#guard (do + let s ← Generic.prepare (program.toField Rat) + s.run "read" [] 3) == .ok (9, [9]) +#guard (do + let s ← Generic.prepare (program.toField Rat) + let q ← Generic.specialize s ["repeated", "slice", "stored", "read"] + q.run "repeated" [] 2) == .ok (.tuple [0, 0, 0, 0], []) +#guard (do + let s ← Generic.prepare (program.toField Rat) + let q ← Generic.specialize s ["repeated"] + return q.instances.any fun (name, f) => name == "repeated" && f.any fun (f : Generic.SourceFunction Rat) => match f.body with + | .repeat (.literal 0) 4 => true + | _ => false) == .ok true + +-- A hint's key is executed ordinarily; only the supplied witness is nondeterministic. +#guard (do + let s ← Generic.prepare (program.toField Rat) + let q ← Generic.specialize s ["key"] + let provider := s.checkedHints fun _ key => match key with + | .field 3 => .ok (.field 12) + | _ => .error .unavailable + q.run "key" [] (hints := provider)) == .ok (12, [3]) + +-- The predicate exposes the native operation, including the zero-repeat heap. +example (world : Generic.SourceSemantics.World Rat) : + Generic.SourceSemantics.EvalExpr world [] [] + (.repeat (.store (.literal 7)) 0) [] (.tuple []) [7] := + .repeat (.store .literal) + +-- Every successful generic run transfers to the finite specialization. +example [Field F] [DecidableEq F] {s : Generic.Source F} + (q : Generic.Specialized s entries) (selected : name ∈ entries) + {hints : s.HintProvider} + (executed : s.run name args fuel hints = .ok (value, heap)) : + q.EvalCall name args value := by + obtain ⟨entry, evaluated⟩ := Generic.Source.run_spec executed + exact (q.evalCall_iff selected).mp ⟨entry, heap, evaluated⟩ + +-- A successful specialized source run reflects back to the generic predicate. +example [Field F] [DecidableEq F] {s : Generic.Source F} + (q : Generic.Specialized s entries) (selected : name ∈ entries) + {hints : s.HintProvider} + (executed : q.run name args fuel hints = .ok (value, heap)) : + s.EvalCall name args value := + (q.evalCall_iff selected).mpr (Generic.Specialized.evalCall_of_run executed) + +/-- info: 'Aiur.Generic.SourceSemantics.evalExpr_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.SourceSemantics.evalExpr_spec +/-- info: 'Aiur.Generic.SourceSemantics.let_load_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.SourceSemantics.let_load_iff +/-- info: 'Aiur.Generic.Specialized.sourceAgreement' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.Specialized.sourceAgreement + +/-- info: 'Aiur.Generic.SourceSemantics.expression_preparation_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.SourceSemantics.expression_preparation_iff +/-- info: 'Aiur.Generic.Preparation.pattern_match' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.Preparation.pattern_match +/-- info: 'Aiur.Generic.PatternLowering.PlanTree.attempt_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.PatternLowering.PlanTree.attempt_sound +/-- info: 'Aiur.Generic.PatternLowering.PlanTree.attempt_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.PatternLowering.PlanTree.attempt_complete +/-- info: 'Aiur.Generic.PatternLowering.PlanTree.match_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.PatternLowering.PlanTree.match_iff +/-- info: 'Aiur.Generic.PatternLowering.lowerLet_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.PatternLowering.lowerLet_iff +/-- info: 'Aiur.Generic.PatternLowering.lowerMatch_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.PatternLowering.lowerMatch_iff +/-- info: 'Aiur.Generic.Specialized.native_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.Specialized.native_complete +/-- info: 'Aiur.Generic.Specialized.checker_heap_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.Specialized.checker_heap_complete +/-- info: 'Aiur.Generic.Specialized.checkerMemo_heap_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.Specialized.checkerMemo_heap_complete +/-- info: 'Aiur.Generic.Specialized.native_entry_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.Specialized.native_entry_iff +/-- info: 'Aiur.Generic.Specialized.native_evalCall_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.Specialized.native_evalCall_iff +/-- info: 'Aiur.Generic.Specialized.checker_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.Specialized.checker_heap_sound +/-- info: 'Aiur.Generic.Specialized.checkerMemo_acyclic_heap_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.Specialized.checkerMemo_acyclic_heap_sound +/-- info: 'Aiur.Generic.Compiled.check_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.Compiled.check_sound +/-- info: 'Aiur.Generic.Compiled.checkMemo_acyclic_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.Compiled.checkMemo_acyclic_sound + +-- Lowered empty projections alone would accept a scalar. The compiler's +-- source-scope certificate still requires an array operand and valid bounds. +#guard (Generic.Expr.slice (.literal (0 : Rat)) 0 (some 0)).checkLowerTypes { functions := [] } [] [] == none +#guard (Generic.Expr.slice (.array ([] : List (Generic.Expr Rat))) 0 (some 0)).checkLowerTypes { functions := [] } [] [] == some (.tuple []) +#guard (Generic.Expr.slice (.array ([] : List (Generic.Expr Rat))) 1 (some 1)).checkLowerTypes { functions := [] } [] [] == none + +-- Const expansion is a compiler operation with a proof on the independent +-- native predicate, including the exact resulting heap. +example [Field F] [DecidableEq F] (s : Generic.Source F) + (expanded : Generic.Preparation.expression s.program depth types expr = .ok prepared) : + Generic.SourceSemantics.EvalExpr s.world types locals expr before value after ↔ + Generic.SourceSemantics.EvalExpr s.world [] locals prepared before value after := + Generic.SourceSemantics.expression_preparation_iff s.program s.world + (fun _ _ => rfl) rfl depth types expr expanded locals before value after + +end AiurSourceEvaluationTests diff --git a/Aiur/AiurTests/Structs.lean b/Aiur/AiurTests/Structs.lean new file mode 100644 index 000000000..8605f0286 --- /dev/null +++ b/Aiur/AiurTests/Structs.lean @@ -0,0 +1,226 @@ +import Aiur.Generic +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +namespace AiurStructTests +open Aiur +set_option maxRecDepth 20000 +set_option maxHeartbeats 8000000 + +-- Declarations and named source syntax survive checking and literal conversion. +def source : Generic.Program Nat := aiur% " +struct Point { x: Field, y: Field } +struct Empty {} +struct Box { value: T } +struct Pointers { first: &Field, second: &Field } +struct Node { value: Field, next: Link } +enum Link { End, Next(&Node) } +enum Option { None, Some(T) } +struct Response { point: Point, answer: Option } +type P = Point; +type Wrapped = Box; +const origin = Point { y: 0, x: 0 }; +const saved = Pointers { second: &2, first: &1 }; + +fn make(x: Field, y: Field) -> Point { Point { y, x } } +fn swap(Point { y, x }: Point) -> Point { Point { x: y, y: x } } +fn unwrap(b: Box) -> T { b.value } +fn named() -> Point { swap(make(3, 4)) } +fn field() -> Field { make(3, 4).x } +fn empty() -> Empty { Empty {} } +fn rest() -> Field { let Point { x, .., } = make(3, 4); x } +fn all_rest() -> Field { let Point { .., } = origin; 9 } +fn pattern() -> Field { let Point { y: b, x: 3 } = make(3, 4); b } +fn ordered(p: Point) -> Field { + match p { Point { x: 0, .. } => 1, Point { y: 0, .. } => 2, _ => 3 } +} +fn generic() -> Point { unwrap(Box { value: make(1, 2) }) } +fn explicit() -> Field { Box:: { value: 5 }.value } +fn alias_use() -> Field { let Wrapped { value } = Wrapped { value: P { y: 7, x: 6 } }; value.x } +fn nested() -> Field { [Box { value: (make(5, 6),) }; 2][1].value.0.y } +fn constants() -> Field { let ::origin = Point { x: 0, y: 0 }; origin.y } +fn pointers() -> Field { let Pointers { second: &b, first: &a } = saved; a * 10 + b } +fn allocate() -> Pointers { Pointers { second: &2, first: &1 } } +fn once() -> Field { (*&make(3, 4)).x } +fn early() -> Field { let p = Point { y: *&2, x: return 7 }; p.x } +fn skip() -> Field { let p = Point { x: return 8, y: 1 / 0 }; p.y } +fn block() -> Field { 'b: { let p = Point { y: *&3, x: break 'b 9 }; p.x } } +fn scope() -> Field { let x = 5; let p = Point { x: { let x = 99; return 11; }, y: x }; p.y } +fn recursive() -> Field { + let n = Node { next: Link::Next(&Node { value: 2, next: Link::End }), value: 1 }; + match n.next { Link::End => n.value, Link::Next(p) => (*p).value } +} +fn hinted(key: Field) -> Field { hint::(key).point.y } +fn pointer_input(p: Pointers) -> Field { *p.first } +fn pointer_internal() -> Field { pointer_input(allocate()) } +" + +#guard source.structs.length == 6 +#guard source.aliases.length == 2 +#guard source.consts.length == 2 +#guard (source.findFunction? "make").any fun definition => match definition.body with + | .record head [.var "y", .var "x"] => head.fields == ["y", "x"] && head.slots == some [some 1, some 0] + | _ => false +#guard (source.toField Rat).structs == source.structs +#guard (source.findFunction? "field").any fun definition => match definition.body with | .member _ _ => true | _ => false + +def point (x y : Rat) : SourceValue Rat := .construct "Point" Generic.structConstructor [.field x, .field y] +def ptrs : SourceValue Rat := .construct "Pointers" Generic.structConstructor [.ptr .field 1, .ptr .field 0] +abbrev Result := Except String (SourceValue Rat × Heap Rat) + +def checks : List (String × List (SourceValue Rat) × Result) := [ + ("named", [], .ok (point 4 3, [])), ("field", [], .ok (3, [])), + ("empty", [], .ok (.construct "Empty" Generic.structConstructor [], [])), + ("rest", [], .ok (3, [])), ("all_rest", [], .ok (9, [])), ("pattern", [], .ok (4, [])), + ("ordered", [point 0 0], .ok (1, [])), ("ordered", [point 1 0], .ok (2, [])), + ("ordered", [point 1 2], .ok (3, [])), + ("generic", [], .ok (point 1 2, [])), ("explicit", [], .ok (5, [])), + ("alias_use", [], .ok (6, [])), ("nested", [], .ok (6, [])), ("constants", [], .ok (0, [])), + ("pointers", [], .ok (12, [2, 1])), ("allocate", [], .ok (ptrs, [2, 1])), + ("once", [], .ok (3, [point 3 4])), + ("early", [], .ok (7, [2])), ("skip", [], .ok (8, [])), + ("block", [], .ok (9, [3])), ("scope", [], .ok (11, [])), + ("recursive", [], .ok (2, [.construct "Node" Generic.structConstructor + [2, .construct "Link" "End" []]])), ("pointer_internal", [], .ok (1, [2, 1])) +] + +def checkExecutions : Except String Unit := do + let s ← Generic.prepare (source.toField Rat) + for (name, args, expected) in checks do + let q ← Generic.specialize s [name] + for (mode, actual) in [("source", s.run name args), ("specialized", q.run name args), + ("core", q.coreRun name args)] do + if actual != expected then throw s!"{name} ({mode}): expected {repr expected}, got {repr actual}" + let _ ← q.compile + if (s.checkEntry "pointer_input").isOk then throw "pointer-containing entry accepted" + let malformed : SourceValue Rat := .construct "Point" Generic.structConstructor [1] + if (s.run "ordered" [malformed]).isOk then throw "malformed struct input accepted" + +#guard checkExecutions == .ok () + +def tables : Generic.Program Nat := aiur% " +struct Point { x: Field, y: Field } +type P = Point; +const one = P { y: 2, x: 1 }; +table inputs: (Field,) { (0,), (1,) } +table outputs: Point { one, Point { x: 3, y: 4 } } +map get(i: Field) -> Point = inputs => outputs; +table keys: (Point,) { (one,), (Point { y: 4, x: 3 },) } +table results: Field { 8, 9 } +map lookup(p: Point) -> Field = keys => results; +fn main(x: Field) -> Field { lookup(get(x)) } +" + +#guard (do + let s ← Generic.prepare (tables.toField Rat) + let q ← Generic.specialize s ["main"] + let _ ← q.compile + if s.run "main" [0] != Except.ok (8, []) then throw "struct map source" + if q.coreRun "main" [1] != Except.ok (9, []) then throw "struct map core" + pure ()) == .ok () + +-- Provider values validate the entire nested nominal shape. +#guard (do + let s ← Generic.prepare (source.toField Rat) + let q ← Generic.specialize s ["hinted"] + let _ ← q.compile + let value : Constant Rat := .construct "Response" Generic.structConstructor + [.construct "Point" Generic.structConstructor [3, 4], .construct (Generic.Instance.mk "Option" [.field]).symbol "Some" [5]] + let provider := fun (_ : String) (_ : Constant Rat) => (Except.ok value : Except HintError (Constant Rat)) + if s.run "hinted" [0] 256 (s.checkedHints provider) != Except.ok (4, []) then throw "struct hint source" + if q.coreRun "hinted" [0] 256 (HintProvider.checked q.program.enums provider) != Except.ok (4, []) then throw "struct hint core" + let bad : Constant Rat := .construct "Response" Generic.structConstructor + [.construct "Point" Generic.structConstructor [3, 4], .construct (Generic.Instance.mk "Option" [.field]).symbol "Bad" []] + let invalid := fun (_ : String) (_ : Constant Rat) => (Except.ok bad : Except HintError (Constant Rat)) + if (s.run "hinted" [0] 256 (s.checkedHints invalid)).isOk then throw "invalid nested hint accepted" + pure ()) == .ok () + +instance : Fact (Nat.Prime 101) := ⟨by decide⟩ +#guard (do + let s ← Generic.prepare (source.toField (ZMod 101)) + let q ← Generic.specialize s ["named", "recursive", "pointers", "early"] + let _ ← q.compile + q.coreRun "pointers" []) == .ok (12, [2, 1]) + +def rowSource : Generic.Program Nat := aiur% " +struct Point { x: Field, y: Field } +fn swap(p: Point) -> Point { Point { y: p.x, x: p.y } } +fn first(p: Point) -> Field { p.x } +" + +def checkRows : Except String Unit := do + let s ← Generic.prepare (rowSource.toField Rat) + let q ← Generic.specialize s ["swap", "first"] + let c ← q.compile + let input : WireValue Rat := ⟨.enum "Point", [3, 4]⟩ + let output : WireValue Rat := ⟨.enum "Point", [4, 3]⟩ + let swapRow : Circuit.Row Rat := ⟨"swap", [3, 4, 4, 3, 1, 0, 1, 0, 1, 0, 1, 0]⟩ + let firstRow : Circuit.Row Rat := ⟨"first", [3, 4, 3, 1, 0, 1, 0]⟩ + c.check {} ⟨"swap", [input], output⟩ [swapRow] + c.checkMemo {} ⟨"swap", [input], output⟩ [⟨swapRow, 1⟩] + c.check {} ⟨"first", [input], 3⟩ [firstRow] + c.checkMemo {} ⟨"first", [input], 3⟩ [⟨firstRow, 1⟩] + let wrong : WireValue Rat := ⟨.enum "Point", [9, 3]⟩ + let badRow : Circuit.Row Rat := ⟨"swap", swapRow.values.set 2 9⟩ + if (c.check {} ⟨"swap", [input], wrong⟩ [badRow]).isOk then throw "wrong struct output accepted" + let tagged : WireValue Rat := ⟨.enum "Point", [0, 3, 4]⟩ + if (c.check {} ⟨"first", [tagged], 3⟩ [firstRow]).isOk then + throw "obsolete struct tag accepted" + let short : WireValue Rat := ⟨.enum "Point", [3]⟩ + if (c.checkMemo {} ⟨"first", [short], 3⟩ [⟨firstRow, 1⟩]).isOk then throw "short struct root accepted" + +#guard checkRows == .ok () + +def duplicate : Generic.Program Nat := aiur% " +struct S { x: Field, y: Field } +fn f(s: S) -> Field { match s { S { x: 0, y: a } => a, S { y: b, x: 0 } => b } } +" +#guard !(do + let s ← Generic.prepare (duplicate.toField Rat) + let q ← Generic.specialize s ["f"] + let _ ← q.compile + pure () : Except String Unit).isOk + +run_cmd do + let env ← Lean.getEnv + for code in [ + "struct S { x: Field, x: Field }", + "struct S {} enum S { A }", + "struct S {} type S = Field;", + "struct S { x: Missing }", + "struct S { x: S }", + "struct S { x: [S; 0] }", + "struct S { x: Missing }", + "struct S { x: Field } fn f() -> S { S {} }", + "struct S { x: Field } fn f() -> S { S { x: 1, x: 2 } }", + "struct S { x: Field } fn f() -> S { S { y: 1 } }", + "struct S { x: Field } fn f() -> S { S { x: () } }", + "struct S { x: Field } fn f(s: S) -> Field { s.y }", + "struct A { x: Field } struct B { x: Field } fn f() -> A { B { x: 1 } }", + "enum E { V(Field) } fn f() -> E { E { value: 1 } }", + "struct S { x: Field, y: Field } fn f(s: S) -> Field { let S { x } = s; x }", + "struct S { x: Field } fn f(s: S) -> Field { let S { x, x } = s; x }", + "struct S { x: Field } fn f(s: S) -> Field { let S { x .. } = s; x }", + "struct S { x: Field } const a = S { x: b }; const b = a;", + "struct S { x: &Field } table t: S {}", + "struct S { x: [&Field; 0] } table t: S {}", + "struct S { x: &Field } fn f() -> S { hint::(()) }", + "struct S { x: T } fn f(x: T) -> S { hint::>(()) }" + ] do + match Generic.Frontend.ofString env code with + | .error _ => pure () + | .ok _ => throwError "unexpectedly accepted: {code}" + +/-- info: 'Aiur.Generic.StructLowering.record_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.StructLowering.record_iff +/-- info: 'Aiur.Generic.StructLowering.member_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.StructLowering.member_iff + +def run : IO Unit := do + match checkExecutions *> checkRows with + | .ok () => IO.println s!"Passed {3 * checks.length} struct execution checks and {checks.length} compilations." + | .error e => throw (IO.userError e) + +end AiurStructTests diff --git a/Aiur/AiurTests/Tables.lean b/Aiur/AiurTests/Tables.lean new file mode 100644 index 000000000..53420241a --- /dev/null +++ b/Aiur/AiurTests/Tables.lean @@ -0,0 +1,238 @@ +import Aiur +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +open Aiur Aiur.Circuit + +namespace AiurTableTests + +set_option maxRecDepth 10000 +set_option maxHeartbeats 2000000 + +-- Importing the frontend leaves these ordinary Lean identifiers available. +example (map table : Nat) : map + table = table + map := Nat.add_comm _ _ + +def source : Program Nat := aiur% " +enum Choice { Empty, Pair((Field, Field)) } +table pairs: (Field, Field) { (0, 0), (0, 1), (1, 0), (1, 1), } +table sums: Field { 0, 1, 1, 2, } +table products: Field { 0, 0, 0, 1, } +table xors: Field { 0, 1, 1, 0, } +map bit_add(a: Field, b: Field) -> Field = pairs => sums; +map bit_mul(a: Field, b: Field) -> Field = pairs => products; +map bit_xor(a: Field, b: Field) -> Field = pairs => xors; + +table nested_inputs: ((Field, Field),) { ((2, 3),), ((5, 7),), } +table choices: Choice { Choice::Pair((3, 2)), Choice::Empty, } +map choose(p: (Field, Field)) -> Choice = nested_inputs => choices; + +table enum_inputs: (Choice,) { (Choice::Empty,), (Choice::Pair((3, 2)),), } +table enum_outputs: (Field, ()) { (0, ()), (1, ()), } +map inspect(value: Choice) -> (Field, ()) = enum_inputs => enum_outputs; + +table unit_inputs: () { (), } +table unit_outputs: () { (), } +map unit() -> () = unit_inputs => unit_outputs; + +table empty_inputs: (Field,) { } +table empty_outputs: Field { } +map missing(x: Field) -> Field = empty_inputs => empty_outputs; + +fn combined(a: Field, b: Field) -> (Field, Field, Field) { + (bit_add(a, b), bit_mul(a, b), bit_xor(a, b)) +} +fn nested() -> (Field, ()) { inspect(choose((2, 3))) } +fn lazy(x: Field) -> Field { match x { 0 => 9, _ => missing(4), } } +fn repeated() -> Field { bit_add(1, 1) + bit_add(1, 1) } +fn through_rom() -> Choice { let p = &choose((2, 3)); *p } +" + +def program := source.toField Rat + +def runtimeTests : List (String × Except EvalError (SourceValue Rat) × Except EvalError (SourceValue Rat)) := [ + ("direct map", eval program "bit_add" [1, 1], .ok 2), + ("shared inputs multiply", eval program "bit_mul" [1, 1], .ok 1), + ("shared inputs xor", eval program "bit_xor" [1, 1], .ok 0), + ("repeated output rows", eval program "bit_add" [0, 1], .ok 1), + ("repeated output rows second input", eval program "bit_add" [1, 0], .ok 1), + ("ordinary calls", eval program "combined" [1, 1], .ok (.tuple [2, 1, 0])), + ("one tuple argument", eval program "choose" [.tuple [2, 3]], + .ok (.construct "Choice" "Pair" [.tuple [3, 2]])), + ("enum empty result", eval program "choose" [.tuple [5, 7]], .ok (.construct "Choice" "Empty" [])), + ("enum input", eval program "inspect" [.construct "Choice" "Pair" [.tuple [3, 2]]], + .ok (.tuple [1, .tuple []])), + ("nested map calls", eval program "nested" [], .ok (.tuple [1, .tuple []])), + ("zero arguments and unit result", eval program "unit" [], .ok (.tuple [])), + ("empty map", eval program "missing" [0], .error (.missingMapInput "missing")), + ("absent input", eval program "bit_add" [2, 0], .error (.missingMapInput "bit_add")), + ("wrong arity", eval program "bit_add" [.tuple [1, 1]], .error (.arityMismatch "bit_add" 2 1)), + ("tuple remains one argument", eval program "choose" [2, 3], .error (.arityMismatch "choose" 1 2)), + ("wrong argument type", eval program "bit_add" [.tuple [1], 0], + .error (.argumentTypeMismatch "bit_add" .field (.tuple [.field]))), + ("inactive map call", eval program "lazy" [0], .ok 9), + ("active missing map call", eval program "lazy" [1], .error (.missingMapInput "missing")), + ("same claim twice", eval program "repeated" [], .ok 4), + ("map result stored in ROM", eval program "through_rom" [], + .ok (.construct "Choice" "Pair" [.tuple [3, 2]])), + ("zero fuel", eval program "bit_add" [1, 1] 0, .error .outOfFuel) +] + +/-- Generators construct the same field-agnostic AST used by the string frontend. -/ +def generated : Program Nat := { + functions := [] + tables := [ + { name := "inputs", rowType := .tuple [.field, .field] + rows := (List.range 4).flatMap fun a => (List.range 4).map fun b => .tuple [.field a, .field b] }, + { name := "outputs", rowType := .field + rows := (List.range 4).flatMap fun a => (List.range 4).map fun b => .field (a + b) } + ] + maps := [⟨"add", [("a", .field), ("b", .field)], .field, "inputs", "outputs"⟩] +} + +example : typecheck generated = .ok () := by decide +kernel +example : eval (generated.toField Rat) "add" [2, 3] = .ok 5 := by decide +kernel + +instance : Fact (Nat.Prime 7) := ⟨by decide⟩ +def collision : Program Nat := aiur% " +table inputs: (Field,) { (0,), (7,), } +table outputs: Field { 1, 1, } +map collide(x: Field) -> Field = inputs => outputs; +" +example : typecheck (collision.toField (ZMod 7)) = .error (.duplicateInput "collide" "inputs") := by decide +kernel +example : (compile (collision.toField (ZMod 7))).isOk = false := by decide +kernel +example : (run (collision.toField (ZMod 7)) "collide" [0]).isOk = false := by decide +kernel + +/-- Partitioning must accept repeated first arguments, but still reject full +row collisions, including nonadjacent rows that collide only in the field. -/ +def pairCollision : Program Nat := aiur% " +table inputs: (Field, Field) { (0, 0), (1, 0), (0, 1), (7, 0), } +table outputs: Field { 0, 1, 2, 3, } +map pair_lookup(a: Field, b: Field) -> Field = inputs => outputs; +" +example : typecheck pairCollision = .ok () := by decide +kernel +example : typecheck (pairCollision.toField Rat) = .ok () := by decide +kernel +example : typecheck (pairCollision.toField (ZMod 7)) = + .error (.duplicateInput "pair_lookup" "inputs") := by decide +kernel + +def system : System Rat := (compile program).toOption.getD { chips := [] } +theorem compiled : compile program = .ok system := by + have succeeds : (compile program).isOk = true := by decide +kernel + cases lowered : compile program with + | error error => simp [lowered, Except.isOk, Except.toBool] at succeeds + | ok chips => simp [system, lowered, Except.toOption] + +-- Tables are retained once and maps have no generated function chips. +example : system.tables.length = source.tables.length := by decide +kernel +example : system.chips.length = source.functions.length := by decide +kernel +example : system.findChip? "bit_add" = none := by decide +kernel + +private def accepts (claim : Message Rat) : Bool := (system.check ⟨[]⟩ claim []).isOk + +def membershipTests : List (String × Bool × Bool) := [ + ("static root needs no chip rows", accepts ⟨"bit_add", [1, 1], 2⟩, true), + ("other operation same inputs", accepts ⟨"bit_xor", [1, 1], 0⟩, true), + ("wrong result", accepts ⟨"bit_add", [1, 1], 0⟩, false), + ("wrong row alignment", accepts ⟨"bit_add", [0, 0], 1⟩, false), + ("wrong map identity", accepts ⟨"bit_mul", [1, 1], 2⟩, false), + ("absent tuple", accepts ⟨"bit_add", [2, 0], 2⟩, false), + ("tuple is not two arguments", accepts ⟨"bit_add", [.tuple [1, 1]], 2⟩, false), + ("singleton output is distinct", accepts ⟨"bit_add", [1, 1], .tuple [2]⟩, false), + ("empty static map", accepts ⟨"missing", [0], 0⟩, false), + ("dynamic root still needs rows", accepts ⟨"repeated", [], 4⟩, false), + ("unit static claim", accepts ⟨"unit", [], .tuple []⟩, true), + ("repeated static claims need no provider rows", + (system.check ⟨[]⟩ ⟨"repeated", [], 4⟩ [⟨"repeated", [4, 2, 2]⟩]).isOk, true), + ("valid equations cannot justify absent static claims", + (system.check ⟨[]⟩ ⟨"repeated", [], 0⟩ [⟨"repeated", [0, 0, 0]⟩]).isOk, false) +] + +-- Both derivation models use an explicit, premise-free membership leaf. +def tableLeaf : Derivation system ⟨[]⟩ ⟨"bit_add", [1, 1], 2⟩ := .table (by decide +kernel) +example : MemoDerives system ⟨[]⟩ ⟨"bit_add", [1, 1], 2⟩ := ⟨tableLeaf.toMemo⟩ + +-- The complete source-to-circuit theorem covers map calls, inactive lookups, and ROM. +example : EncodedEntryDerives system "repeated" (entryValues []) (.field 4) := by + have executed : run program "repeated" [] 16 = .ok (.field 4, []) := by decide +kernel + obtain ⟨_, entry, locals, expr, prepared, body⟩ := run_eq_ok_iff.mp executed + have complete := compiler_heap_complete compiled entry (.intro prepared (evalExpr_spec body)) + (fun _ => (0 : Rat)) (by simp) + simpa [Value.mapAddress] using complete + +example : EncodedEntryDerives system "lazy" (entryValues [0]) (.field 9) := by + have executed : run program "lazy" [0] 16 = .ok (.field 9, []) := by decide +kernel + obtain ⟨_, entry, locals, expr, prepared, body⟩ := run_eq_ok_iff.mp executed + have complete := compiler_heap_complete compiled entry (.intro prepared (evalExpr_spec body)) + (fun _ => (0 : Rat)) (by simp) + simpa [Value.mapAddress] using complete + +example : EncodedEntryDerives system "through_rom" (entryValues []) + (.construct "Choice" "Pair" [.tuple [.field 3, .field 2]]) := by + have executed : run program "through_rom" [] 20 = + .ok (.construct "Choice" "Pair" [.tuple [.field 3, .field 2]], [.construct "Choice" "Pair" [.tuple [.field 3, .field 2]]]) := by decide +kernel + obtain ⟨_, entry, locals, expr, prepared, body⟩ := run_eq_ok_iff.mp executed + have complete := compiler_heap_complete compiled entry (.intro prepared (evalExpr_spec body)) + (fun _ => (99 : Rat)) (by intro i j hi hj _; simp at hi hj; omega) + simpa [Value.mapAddress] using complete + +example (accepted : EncodedEntryDerives system "bit_add" (entryValues [1, 1]) (.field 0)) : False := by + have wrong := compiler_entry_sound compiled accepted (by decide +kernel) + have actual : EvalCall program "bit_add" [1, 1] (.field 2) := eval_spec (hints := HintProvider.unavailable) (fuel := 4) (by decide +kernel) + have same := actual.deterministic wrong (by decide +kernel) + simp [Value.mapAddress] at same + +example (graph : MemoDerivation system ⟨[]⟩ ⟨"bit_add", [.field 1, .field 1], .field 0⟩) + (acyclic : graph.Acyclic) : False := by + obtain ⟨args, value, decoded, output, evaluated⟩ := memo_acyclic_sound compiled graph acyclic + have argsEq : args = [.field 1, .field 1] := decoded.unique + (.cons (WireValue.decode_field _ _) (.cons (WireValue.decode_field _ _) .nil)) + have resultEq : value = .field 0 := Option.some.inj (output.symm.trans (WireValue.decode_field _ _)) + subst args + subst value + cases evaluated with + | intro prepared body => + have expected : prepareCall program "bit_add" [.field 1, .field 1] = + .ok (([] : Environment Rat), .literal 2) := by + simpa only [Constant.toExpr] using + (prepareCall_map (program := program) (name := "bit_add") + (args := ([.field 1, .field 1] : List (Value Rat))) (value := .field 2) + (by rfl) (by decide +kernel)) + obtain ⟨rfl, rfl⟩ := Prod.mk.inj (Except.ok.inj (prepared.symm.trans expected)) + have same := (ROMEvalExprWith.constant_iff (.field 2 : Constant Rat)).mp + (by simpa only [Constant.toExpr] using body.toEvalExprWith) + simp [Constant.toValue, Value.mapAddress] at same + +run_cmd do + let env ← Lean.getEnv + for text in [ + "table x: (Field,) { (0,), (0,), } table y: Field { 1, 1, } map f(a: Field) -> Field = x => y;", + "table x: (Field,) { (0,), } table y: Field { } map f(a: Field) -> Field = x => y;", + "map f(a: Field) -> Field = absent => absent;", + "table x: Field { (1,), }", + "enum E { A(Field) } table x: E { E::A, }", + "table x: Field { 0, } table x: Field { 1, }", + "table x: () { (), } table y: Field { 0, } map f() -> Field = x => y; fn f() -> Field { 0 }", + "table x: () { (), } table y: Field { 0, } map f() -> Field = x => y; map f() -> Field = x => y;", + "table x: (&Field,) { (&1,), }", + "enum E { P(&Field) } table x: E { E::P(&1), }", + "table x: Field { 1 + 2, }", + "table x: Field { f(), } fn f() -> Field { 1 }", + "table x: (Field,) { (0,), } table y: Field { 1, } map f(a) -> Field = x => y;", + "table x: (Field,) { (0,), } table y: Field { 1, } map f(a: Field) = x => y;", + "table x: (Field,) { (0,), } table y: Field { 1, } map f(a: Field, a: Field) -> Field = x => y;", + "table x: Field { 0, } table y: Field { 1, } map f(a: Field) -> Field = x => y;", + "table x: (Field,) { (0,), } table y: (Field,) { (1,), } map f(a: Field) -> Field = x => y;" + ] do + match Frontend.ofString env text with + | .error _ => pure () + | .ok _ => throwError "unexpectedly accepted table program: {text}" + +private def checkEqual [DecidableEq α] [Repr α] (label : String) (actual expected : α) : IO Unit := do + unless actual = expected do + throw (IO.userError s!"{label}: expected {repr expected}, got {repr actual}") + +def run : IO Unit := do + for (label, actual, expected) in runtimeTests do checkEqual label actual expected + for (label, actual, expected) in membershipTests do checkEqual label actual expected + IO.println s!"Passed {runtimeTests.length + membershipTests.length} table and map checks." + +end AiurTableTests diff --git a/Aiur/AiurTests/Tagless.lean b/Aiur/AiurTests/Tagless.lean new file mode 100644 index 000000000..6f6aa4d80 --- /dev/null +++ b/Aiur/AiurTests/Tagless.lean @@ -0,0 +1,131 @@ +import Aiur.Modules +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +namespace AiurTaglessTests +open Aiur + +set_option maxRecDepth 10000 +set_option maxHeartbeats 4000000 + +def source : Program Nat := aiur% " +enum Unit { Unit } +enum Other { Unit } +enum Wrap { Wrap(Field) } +enum Nested { Nested((Unit, Wrap, Unit)) } +enum Choice { Empty(Unit), Full(Nested) } +enum Cover { Cover(Choice) } +fn make() -> Unit { Unit::Unit } +fn identity(u: Unit) -> Unit { let Unit::Unit = u; u } +fn caller() -> Unit { identity(make()) } +fn hinted() -> Unit { hint::(()) } +fn memory() -> Unit { let p = &Unit::Unit; *p } +fn wrap(x: Field) -> Wrap { Wrap::Wrap(x) } +table inputs: (Unit,) { (Unit::Unit,) } +table outputs: Unit { Unit::Unit } +map unit_map(u: Unit) -> Unit = inputs => outputs; +fn mapped() -> Unit { unit_map(Unit::Unit) } +" + +def aggregates : Generic.Program Nat := aiur% " +struct Empty {} +struct Bundle { values: [Empty; 3], pair: (Empty, Empty) } +fn make() -> Bundle { Bundle { values: [Empty {}; 3], pair: (Empty {}, Empty {}) } } +fn inspect(b: Bundle) -> Field { + let Bundle { values, pair } = b; + let Empty {} = values[2]; + let Empty {} = pair.1; + 9 +} +fn caller() -> Field { inspect(make()) } +" + +private def ensure (message : String) (condition : Bool) : IO Unit := + unless condition do throw (IO.userError message) + +private def get {α : Type} : Except String α → IO α + | .ok value => pure value + | .error error => throw (IO.userError error) + +private def checkEncoding [Field F] [DecidableEq F] (fieldName : String) : IO Unit := do + let unit : Value F := .construct "Unit" "Unit" [] + let wrap : Value F := .construct "Wrap" "Wrap" [7] + let nested : Value F := .construct "Nested" "Nested" [.tuple [unit, wrap, unit]] + let cases : List (Value F × List F) := [ + (unit, []), (wrap, [7]), (nested, [7]), + (.construct "Choice" "Empty" [unit], [0, 0]), + (.construct "Choice" "Full" [nested], [1, 7]), + (.construct "Cover" "Cover" [.construct "Choice" "Full" [nested]], [1, 7])] + for (value, words) in cases do + let wire : WireValue F := ⟨value.type, words⟩ + ensure s!"{fieldName}: wrong tagless encoding" (value.encode source.enums == some wire) + ensure s!"{fieldName}: wrong tagless decoding" (wire.decode source.enums == some value) + let layout ← get <| (source.enums.layout value.type).mapError reprStr + ensure s!"{fieldName}: wrong tagless width" (layout.width == words.length) + for wire in ([⟨.enum "Unit", [0]⟩, ⟨.enum "Wrap", []⟩, ⟨.enum "Wrap", [0, 7]⟩, + ⟨.enum "Choice", [0, 7]⟩, ⟨.enum "Choice", [1]⟩, + ⟨.enum "Cover", [2, 0]⟩, ⟨.enum "Cover", [0, 7]⟩] : List (WireValue F)) do + ensure s!"{fieldName}: malformed encoding accepted" (wire.decode source.enums).isNone + let pointer ← get <| (source.enums.layout (.ptr (.enum "Unit"))).mapError reprStr + ensure "pointer to zero-width value lost its address" (pointer.width == 1) + +instance : Fact (Nat.Prime 3) := ⟨by decide⟩ + +def run : IO Unit := do + checkEncoding (F := Rat) "Rat" + checkEncoding (F := ZMod 3) "F3" + let program := source.toField Rat + let entries := program.functions.map (·.name) + let optimized ← get <| Optimized.compile program entries + let reference ← get <| (Circuit.compile program).mapError reprStr + let unit : WireValue Rat := ⟨.enum "Unit", []⟩ + let identity : Circuit.Message Rat := ⟨"identity", [unit], unit⟩ + let cases : List (Circuit.Message Rat × List String) := [ + (⟨"make", [], unit⟩, ["make"]), (identity, ["identity"]), + (⟨"caller", [], unit⟩, ["caller", "make", "identity"]), + (⟨"hinted", [], unit⟩, ["hinted"]), (⟨"mapped", [], unit⟩, ["mapped"])] + for (claim, names) in cases do + for system in [reference, optimized.system] do + let rows ← names.mapM fun name => do + let some chip := system.findChip? name | throw (IO.userError s!"missing {name}") + -- Reference single-constructor validation tests the implicit zero tag. + -- Each equality gadget has witnesses [equal = 1, inverse = 0]. + return (⟨name, (List.range chip.numVars).map fun i => if i % 2 == 0 then 1 else 0⟩ : Circuit.Row Rat) + let _ ← get <| (system.check ⟨[]⟩ claim rows).mapError reprStr + let _ ← get <| (system.checkMemo ⟨[]⟩ claim (rows.map fun row => ⟨row, 1⟩)).mapError reprStr + for name in names do + let some chip := optimized.system.findChip? name | throw (IO.userError s!"missing {name}") + ensure s!"{name}: unit operation retained columns" (chip.numVars == 0) + ensure s!"{name}: unit output retained a tag" (chip.output.words.isEmpty) + ensure "zero-width call premise was dropped" + (optimized.check ⟨[]⟩ ⟨"caller", [], unit⟩ [⟨"caller", []⟩]).toOption.isNone + ensure "zero-width input erased its argument position" + (optimized.check ⟨[]⟩ ⟨"identity", [], unit⟩ [⟨"identity", []⟩]).toOption.isNone + ensure "nominal type identity was erased" + (optimized.check ⟨[]⟩ ⟨"identity", [⟨.enum "Other", []⟩], unit⟩ [⟨"identity", []⟩]).toOption.isNone + let rom : WireROM Rat := ⟨[(0, unit)]⟩ + let memory : Circuit.Message Rat := ⟨"memory", [], unit⟩ + let rows : List (Circuit.Row Rat) := [⟨"memory", [0]⟩] + let _ ← get <| optimized.check rom memory rows + let _ ← get <| optimized.checkMemo rom memory (rows.map fun row => ⟨row, 1⟩) + ensure "empty ROM payload lost its membership check" (optimized.check ⟨[]⟩ memory rows).toOption.isNone + let prepared ← get <| Generic.prepare (aggregates.toField Rat) + let specialized ← get <| Generic.specialize prepared ["make", "inspect", "caller"] + let compiled ← get specialized.compileOptimized + let empty : WireValue Rat := ⟨.enum "Bundle", []⟩ + let _ ← get <| compiled.artifact.check ⟨[]⟩ ⟨"make", [], empty⟩ [⟨"make", []⟩] + let _ ← get <| compiled.artifact.check ⟨[]⟩ ⟨"inspect", [empty], .field 9⟩ [⟨"inspect", []⟩] + let rows : List (Circuit.Row Rat) := [⟨"caller", [9]⟩, ⟨"make", []⟩, ⟨"inspect", []⟩] + let _ ← get <| compiled.artifact.check ⟨[]⟩ ⟨"caller", [], .field 9⟩ rows + let _ ← get <| compiled.artifact.checkMemo ⟨[]⟩ ⟨"caller", [], .field 9⟩ + (rows.map fun row => ⟨row, 1⟩) + IO.println "Passed tagless enum checks: empty/nested encodings, structs, arrays, fields, calls, hints, maps, ROM, and both checkers." + +/-- info: 'Aiur.Layout.decode_encode' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Layout.decode_encode +/-- info: 'Aiur.Layout.encode_decode' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Layout.encode_decode + +end AiurTaglessTests diff --git a/Aiur/AiurTests/Trace.lean b/Aiur/AiurTests/Trace.lean new file mode 100644 index 000000000..e42d47e5c --- /dev/null +++ b/Aiur/AiurTests/Trace.lean @@ -0,0 +1,262 @@ +import Aiur.Trace.FFI +import AiurTests.Execution + +namespace AiurTraceTests +open Aiur Lean +abbrev F := AiurExecutionTests.F + +def extras : Modules.Program Nat := aiur_modules% " +module Extra { + enum Stored { Empty, Value(Field) } + enum Wrapper { Wrap(Field) } + fn width_capacity(x: Field) -> Field { + let a = &x; + let b = &(x, 0); + let c = &(); + let p = &a; + *(*p) + } + fn typed_sharing(x: Field) -> (Field, Field) { + let a = &x; + let b = &Wrapper::Wrap(x); + let aa = &a; + let bb = &b; + (*(*aa), match *(*bb) { Wrapper::Wrap(y) => y }) + } + fn local_widths(x: Field) -> (Field, Field) { + let a = &x; + let b = &(x, 0); + let c = &Stored::Value(x); + (*a, match *c { Stored::Value(y) => y, _ => 0 }) + } + fn store_input(x: Stored) -> Stored { let p = &x; *p } + fn store_hint() -> Stored { let p = &hint::(\"stored\", ()); *p } + fn keep(x: Stored) -> Stored { x } + fn make(x: Field) -> Stored { Stored::Value(x) } + fn advice_enum() -> Stored { hint::(\"stored\", ()) } + fn forwarded(x: Stored) -> Stored { keep(x) } + fn returned(x: Field) -> Stored { keep(make(x)) } + fn hinted() -> Stored { keep(advice_enum()) } + fn recurse(n: Field, x: Stored) -> Stored { match n { 0 => x, _ => recurse(n - 1, x) } } + fn recursive(x: Stored) -> Stored { recurse(3, x) } + fn high(a: Field, b: Field) -> Field { let x = (a + b) * (a - b); (x * x * x + x) / b } + fn branches(x: Field, y: Field) -> Field { + match x { 0 => match y { 0 => 7, _ => y / y }, _ => match y { 0 => x / x, _ => x * y } } + } + fn disjoint(x: Field, y: Field) -> Field { + match (x, y) { (0, 0) => 7, (1, 1) => 8, _ => 9 } + } + fn partial_overlap(x: Field, y: Field) -> Field { + match (x, y) { (0, 0) => 7, (0, _) => 8, _ => 9 } + } + fn overlap(x: Field, y: Field) -> Field { + match (x, y) { (0, _) => 7, (_, 1) => 8, _ => 9 } + } + fn conflicting_component(x: Field, y: Field) -> Field { + match (x, y) { (0, 0) => 7, (1, _) => 8, _ => 9 } + } + fn repeated(x: Field, y: Field) -> Field { + match (x, y) { (0, _) => 7, (0, 1) => 9, (_, 1) => 8, _ => 9 } + } + fn advice1(x: Field) -> Field { hint::(1) } + fn advice2(x: Field) -> Field { hint::(2) } + fn different() -> Field { advice1(3) + advice2(3) } + fn sites(x: Field) -> (Field, Field) { + let first = match x { 0 => hint::(1), _ => hint::(2), 9 => hint::(9) }; + (first, hint::(49)) + } +} +" + +def mergeCases : Modules.Program Nat := aiur_modules% " +module Merge { + enum Binary { Off, On } + enum Ternary { A, B, C } + enum Wrapper { Wrap(Field) } + enum ListA { Nil, Cons(Field, &ListA) } + enum ListB { Nil, Cons(Field, &ListB) } + fn field_id(x: Field) -> Field { x } + fn binary_id(x: Binary) -> Binary { x } + fn ternary_id(x: Ternary) -> Ternary { x } + fn wrapper_id(x: Wrapper) -> Wrapper { x } + fn pair_sum(x: (Field, Field)) -> Field { let (a, b) = x; a + b } + fn two_sum(a: Field, b: Field) -> Field { a + b } + fn len_a(p: &ListA) -> Field { + match *p { ListA::Nil => 0, ListA::Cons(_, tail) => 1 + len_a(tail) } + } + fn len_b(p: &ListB) -> Field { + match *p { ListB::Nil => 0, ListB::Cons(_, tail) => 1 + len_b(tail) } + } + fn binary_hint() -> Binary { hint::(\"binary\", ()) } + fn ternary_hint() -> Ternary { hint::(\"ternary\", ()) } + fn identities(x: Field) -> (Field, Binary, Ternary, Wrapper) { + (field_id(x), binary_id(Binary::On), ternary_id(Ternary::C), wrapper_id(Wrapper::Wrap(x))) + } + fn grouping(x: Field, y: Field) -> (Field, Field) { (pair_sum((x,y)), two_sum(x,y)) } + fn lists(x: Field) -> (Field, Field) { + let a = &ListA::Cons(x, &ListA::Cons(2, &ListA::Nil)); + let b = &ListB::Cons(x, &ListB::Cons(2, &ListB::Nil)); + (len_a(a), len_b(b)) + } + fn hints() -> (Binary, Ternary) { (binary_hint(), ternary_hint()) } + fn public_binary(x: Binary) -> Binary { x } + fn public_ternary(x: Ternary) -> Ternary { x } +} +" + +def run : IO Unit := do + let source := { AiurExecutionTests.source with modules := + AiurExecutionTests.source.modules ++ AiurExecutionHintTests.source.modules ++ extras.modules ++ mergeCases.modules } + let prepared ← IO.ofExcept (Modules.prepare (source.toField F) + (AiurExecutionTests.entries ++ AiurExecutionHintTests.entries ++ + ["Extra::high", "Extra::branches", "Extra::different", "Extra::sites", + "Extra::typed_sharing", "Extra::local_widths", + "Extra::store_input", "Extra::store_hint", "Extra::forwarded", "Extra::returned", + "Extra::hinted", "Extra::recursive", "Extra::disjoint", "Extra::partial_overlap", + "Extra::overlap", "Extra::conflicting_component", "Extra::repeated", + "Merge::identities", "Merge::grouping", "Merge::lists", "Merge::hints", + "Merge::public_binary", "Merge::public_ternary"])) + let exported ← IO.ofExcept prepared.exportExecution + let named := fun name => Generic.Ty.named ("Witness::" ++ name) [] + let unit := fun name => Execution.DataValue.construct (F := F) (named name) "Unit" [] + let hints : Array (Execution.HintEntry F) := #[ + ⟨.named "Merge::Binary" [], .tuple [], .construct (.named "Merge::Binary" []) "On" [], "binary"⟩, + ⟨.named "Merge::Ternary" [], .tuple [], .construct (.named "Merge::Ternary" []) "C" [], "ternary"⟩, + ⟨.named "Extra::Stored" [], .tuple [], + .construct (.named "Extra::Stored" []) "Value" [7], "stored"⟩, + ⟨.field, 49, 7, ""⟩, ⟨.field, 9, 17, ""⟩, ⟨.field, 7, 1, ""⟩, ⟨.field, .tuple [7], 2, ""⟩, + ⟨.field, 1, 7, ""⟩, ⟨.field, 2, 8, ""⟩, + ⟨.field, unit "Unit", 3, ""⟩, ⟨.field, unit "Other", 4, ""⟩, ⟨.field, .tuple [], 5, ""⟩, + ⟨.tuple [.field], 7, .tuple [2], "singleton"⟩, + ⟨named "Outer", .record (named "Pair") [("right", 4), ("left", 3)], + .construct (named "Outer") "Wrap" [.construct (named "Choice") "Some" [.array .field [5,6]]], ""⟩, + ⟨.named "Witness::Box" [named "Numbers"], 7, + .record (.named "Witness::Box" [named "Numbers"]) [("value", .array .field [8,9])], "boxed"⟩, + ⟨.tuple [named "Unit", .array (named "Unit") 2, .array .field 0], .tuple [], + .tuple [unit "Unit", .array (named "Unit") [unit "Unit", unit "Unit"], .array .field []], "zero"⟩, ⟨.field, 49, 7, "sample"⟩] + let cases : List (String × Array Nat) := [ + ("Merge::identities", #[7]), ("Merge::grouping", #[3,4]), ("Merge::lists", #[9]), + ("Merge::hints", #[]), ("Merge::public_binary", #[1]), ("Merge::public_ternary", #[2]), + ("Extra::typed_sharing", #[0]), ("Extra::typed_sharing", #[7]), + ("Extra::local_widths", #[0]), ("Extra::local_widths", #[7]), + ("Extra::store_input", #[0,0]), ("Extra::store_input", #[1,7]), ("Extra::store_hint", #[]), + ("Extra::forwarded", #[0,0]), ("Extra::forwarded", #[1,7]), ("Extra::returned", #[9]), + ("Extra::hinted", #[]), ("Extra::recursive", #[0,0]), ("Extra::recursive", #[1,7]), + ("Test::sharing", #[4]), ("Test::fib", #[8]), ("Test::memory", #[3]), + ("Test::table", #[1, 1]), ("Test::arithmetic", #[7, 3]), + ("Test::choose", #[0]), ("Test::choose", #[1]), ("Test::choose", #[2]), + ("Test::choice", #[0, 0, 0, 0]), ("Test::choice", #[1, 0, 9, 0]), + ("Test::choice", #[1, 3, 9, 0]), ("Test::choice", #[2, 2, 3, 4]), + ("Test::nested", #[1, 1, 0, 9, 0, 0, 0, 0, 0]), + ("Test::unit", #[]), ("Test::empty_secret", #[]), ("Test::pointer", #[]), + ("Test::lazy", #[0]), ("Test::refutable", #[3]), ("Test::asserted", #[4]), + ("Witness::repeated", #[49]), ("Witness::typed_keys", #[]), ("Witness::typed_results", #[]), + ("Witness::nested", #[3,4]), ("Witness::boxed", #[7]), ("Witness::zero", #[]), + ("Witness::inlined", #[49]), ("Witness::key_effects", #[4]), + ("Witness::lazy", #[0]), ("Witness::lazy", #[49]), + ("Extra::high", #[7,3]), ("Extra::branches", #[0,0]), ("Extra::branches", #[0,3]), + ("Extra::branches", #[3,0]), ("Extra::branches", #[3,3]), + ("Extra::different", #[]), ("Extra::sites", #[0]), ("Extra::sites", #[1])] ++ + ["Extra::disjoint", "Extra::partial_overlap", "Extra::overlap", "Extra::conflicting_component", + "Extra::repeated"].flatMap + (fun name => [0, 1, 2].flatMap fun x => [0, 1, 2].map fun y => (name, #[x, y])) + for config in ([{}, {propagateValues := false}, + {shareAuxiliaries := false, eliminateSelectors := false, propagateScopes := false, + simplifyConstraints := false, propagateValues := false, mergeLookups := false, + deduplicate := false}] : List Optimized.Config) do + let compiled ← IO.ofExcept (prepared.compileOptimized config) + let artifact := compiled.circuit.artifact + let physical ← IO.ofExcept (Optimized.Physical.prepare artifact) + if config.deduplicate then + for (left, right) in [("field_id", "binary_id"), ("field_id", "ternary_id"), + ("field_id", "wrapper_id"), ("pair_sum", "two_sum"), ("len_a", "len_b")] do + unless physical.representative ("Merge::" ++ left) == physical.representative ("Merge::" ++ right) do + throw (IO.userError s!"representation-identical functions did not merge: {left}, {right}") + if physical.representative "Merge::binary_hint" == physical.representative "Merge::ternary_hint" then + throw (IO.userError "different hint canonicality checks were merged") + for entry in ["Merge::public_binary", "Merge::public_ternary"] do + unless physical.representative entry == entry do throw (IO.userError "public entrypoint was merged") + -- Same layout, different canonical tags: test the constraints directly, + -- bypassing the interpreter's own input validation. + let some binary := physical.system.findChip? "Merge::public_binary" | throw (IO.userError "missing binary entry") + let some ternary := physical.system.findChip? "Merge::public_ternary" | throw (IO.userError "missing ternary entry") + unless binary.constraints != ternary.constraints do throw (IO.userError "public canonicality checks disappeared") + let plan ← IO.ofExcept (Trace.exportPreparedJson 97 ZMod.val compiled.circuit.inlined.program artifact physical exported.bytecode) + for (name, args) in cases do + for pad in [false, true] do + let result ← IO.ofExcept (← Trace.run exported plan name args hints pad) + let rows ← IO.ofExcept (result.rows 97) + let rom ← IO.ofExcept (result.widthROM 97) + for weighted in ← IO.ofExcept (result.paddedRows 97) do + let some source := physical.system.findChip? weighted.row.chip + | throw (IO.userError "unknown padded chip") + let padded := Optimized.Activation.compile source + let _ ← IO.ofExcept ((padded.checkRow (Circuit.Erasure.rawROM rom) weighted.row).mapError reprStr) + let some selection := prepared.find? name | throw (IO.userError "missing test entry") + let some chip := artifact.system.findChip? selection.resolved.name | throw (IO.userError "missing test chip") + let mut offset := 0 + let mut inputs := [] + for wire in chip.inputs do + let count := wire.words.length + let value := (args.toList.drop offset |>.take count).map (fun n => (n : F)) + offset := offset + count + inputs := inputs ++ [WireValue.mk wire.type value] + let root := Circuit.Message.mk selection.resolved.name inputs + ⟨chip.output.type, result.execution.output.toList.map Nat.cast⟩ + match physical.checkMemo rom root rows with + | .ok _ => pure () + | .error e => throw (IO.userError s!"Lean trace check failed for {name}, pad={pad}: {e}") + if name == "Merge::public_binary" then + let some row := rows.find? (·.row.chip == name) | throw (IO.userError "missing binary row") + let some column := (binary.inputs.flatMap WireValue.words).head? | throw (IO.userError "missing binary input") + let forged := { row.row with values := row.row.values.set column 2 } + if (binary.checkRow (Circuit.Erasure.rawROM rom) forged).isOk then + throw (IO.userError "physical entry accepted a tag canonical only for the other enum") + if name == "Merge::hints" then + let hintName := physical.representative "Merge::binary_hint" + let some hintChip := physical.system.findChip? hintName | throw (IO.userError "missing hint circuit") + let some row := rows.find? (·.row.chip == hintName) | throw (IO.userError "missing hint row") + let some (.var column) := hintChip.output.words.head? | throw (IO.userError "missing hint output") + let forged := { row.row with values := row.row.values.set column 2 } + if (hintChip.checkRow (Circuit.Erasure.rawROM rom) forged).isOk then + throw (IO.userError "physical hint accepted a tag canonical only for the other enum") + -- Independently exercise rejection in the certified physical checker. + if let some first := rows.head? then + if (physical.checkMemo rom root ({ first with multiplicity := first.multiplicity + 1 } :: rows.tail!)).isOk then + throw (IO.userError "Lean checker accepted a mutated provide count") + IO.println s!"Trace: {cases.length * 2} executions accepted by Lean checkMemo ({reprStr config})" + +private instance : Fact (Nat.Prime 2) := ⟨by decide⟩ + +def runSmallField : IO Unit := do + let prepared ← IO.ofExcept (Modules.prepare (extras.toField (ZMod 2)) + ["Extra::high", "Extra::branches", "Extra::disjoint", "Extra::partial_overlap", "Extra::overlap", + "Extra::conflicting_component", "Extra::repeated", "Extra::width_capacity"]) + let exported ← IO.ofExcept prepared.exportExecution + let compiled ← IO.ofExcept (prepared.compileOptimized {}) + let artifact := compiled.circuit.artifact + let physical ← IO.ofExcept (Optimized.Physical.prepare artifact) + let plan ← IO.ofExcept (Trace.exportPreparedJson 2 ZMod.val compiled.circuit.inlined.program artifact physical exported.bytecode) + let cases : List (String × Array Nat) := [ + ("Extra::width_capacity", #[0]), ("Extra::width_capacity", #[1]), + ("Extra::high", #[1,1]), ("Extra::branches", #[0,0]), + ("Extra::branches", #[0,1]), ("Extra::branches", #[1,0]), ("Extra::branches", #[1,1])] ++ + ["Extra::disjoint", "Extra::partial_overlap", "Extra::overlap", "Extra::conflicting_component", + "Extra::repeated"].flatMap + (fun name => [0, 1].flatMap fun x => [0, 1].map fun y => (name, #[x, y])) + for (name, args) in cases do + for pad in [false, true] do + let result ← IO.ofExcept (← Trace.run exported plan name args #[] pad) + let rows ← IO.ofExcept (result.rows 2) + let rom ← IO.ofExcept (result.widthROM 2) + for weighted in ← IO.ofExcept (result.paddedRows 2) do + let some source := physical.system.findChip? weighted.row.chip + | throw (IO.userError "unknown padded chip") + let padded := Optimized.Activation.compile source + let _ ← IO.ofExcept ((padded.checkRow (Circuit.Erasure.rawROM rom) weighted.row).mapError reprStr) + let root := Circuit.Message.mk name (args.toList.map fun n => WireValue.field (n : ZMod 2)) + (WireValue.field ((result.execution.output[0]?.getD 0 : Nat) : ZMod 2)) + IO.ofExcept (physical.checkMemo rom root rows) + IO.println s!"Trace: {cases.length * 2} executions accepted by Lean checkMemo over F₂" + +end AiurTraceTests diff --git a/Aiur/AiurTests/TupleRuntime.lean b/Aiur/AiurTests/TupleRuntime.lean new file mode 100644 index 000000000..b9a2ae22e --- /dev/null +++ b/Aiur/AiurTests/TupleRuntime.lean @@ -0,0 +1,142 @@ +import Aiur +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +open Aiur Aiur.Circuit + +namespace AiurTupleRuntimeTests + +def sample : Program Nat := aiur% " +fn unit() -> () { () } +fn singleton(x: Field) -> (Field,) { (x,) } +fn grouped(x: Field) -> Field { (x) } +fn wide(x: Field) -> (Field, Field, Field, Field, Field) { (x, 2, 3, 4, 5) } +fn nested(x: Field) -> (Field, (Field, ()), (Field,)) { (x, (x + 1, ()), (x + 2,)) } +fn swap(p: (Field, Field)) -> (Field, Field) { match p { (x, y) => (y, x) } } +fn destructure((x, (y, z)): (Field, (Field, Field))) -> Field { x + y + z } +fn unpack(p: (Field, (Field, ()))) -> Field { let (x, (y, ())) = p; x + y } +fn shadow(x: Field) -> Field { let (x, y) = (x + 1, x + 2); x * y } +fn projection(p: (Field, (Field, Field))) -> Field { p.1.0 } +fn call_projection(p: (Field, Field)) -> Field { swap(p).0 } +fn overlap(p: (Field, Field)) -> Field { + match p { (0, _) => 11, (_, 0) => 22, _ => 33 } +} +fn deep_match(p: (Field, (Field, Field))) -> Field { + match p { (0, (1, x)) => x, (_, (_, 0)) => 9, _ => 7 } +} +fn partial_pair(p: (Field, Field)) -> Field { match p { (0, 0) => 1 } } +fn reduce(p: (Field, Field)) -> (Field, Field) { + match p { (0, total) => (0, total), (n, total) => reduce((n - 1, total + n)) } +} +fn even(p: (Field, Field)) -> (Field, Field) { + match p { (0, total) => (1, total), (n, total) => odd((n - 1, total + 1)) } +} +fn odd(p: (Field, Field)) -> (Field, Field) { + match p { (0, total) => (0, total), (n, total) => even((n - 1, total + 1)) } +} +fn eager_tuple() -> Field { (7, 1 / 0).0 } +fn discarded_tuple() -> Field { let _ = (7, 1 / 0); 9 } +fn divide_unit(x: Field) -> () { let _ = 1 / x; () } +fn call_unit(x: Field) -> () { divide_unit(x) } +fn looping(p: (Field, Field)) -> (Field, Field) { looping(p) } +fn lazy(p: (Field, Field)) -> (Field, Field) { + match p { (0, x) => (x, x), _ => looping((1 / 0, 0)) } +} +fn catch_all(p: (Field, Field)) -> Field { + match p { (x, _) => x, (0, 0) => 1, (0, 0) => 2 } +} +" + +def rationalTests : List (String × Except EvalError (SourceValue Rat) × Except EvalError (SourceValue Rat)) := [ + ("unit", eval (sample.toField Rat) "unit" [], .ok (.tuple [])), + ("singleton", eval (sample.toField Rat) "singleton" [7], .ok (.tuple [7])), + ("grouping", eval (sample.toField Rat) "grouped" [7], .ok 7), + ("wide tuple", eval (sample.toField Rat) "wide" [7], .ok (.tuple [7, 2, 3, 4, 5])), + ("nested tuple", eval (sample.toField Rat) "nested" [7], + .ok (.tuple [7, .tuple [8, .tuple []], .tuple [9]])), + ("tuple pattern", eval (sample.toField Rat) "swap" [.tuple [2, 3]], .ok (.tuple [3, 2])), + ("parameter pattern", eval (sample.toField Rat) "destructure" [.tuple [1, .tuple [2, 3]]], .ok 6), + ("let pattern", eval (sample.toField Rat) "unpack" [.tuple [1, .tuple [2, .tuple []]]], .ok 3), + ("binding scope", eval (sample.toField Rat) "shadow" [2], .ok 12), + ("nested projection", eval (sample.toField Rat) "projection" [.tuple [1, .tuple [2, 3]]], .ok 2), + ("call projection", eval (sample.toField Rat) "call_projection" [.tuple [2, 3]], .ok 3), + ("overlap first", eval (sample.toField Rat) "overlap" [.tuple [0, 0]], .ok 11), + ("overlap second", eval (sample.toField Rat) "overlap" [.tuple [5, 0]], .ok 22), + ("overlap default", eval (sample.toField Rat) "overlap" [.tuple [5, 6]], .ok 33), + ("nested literal pattern", eval (sample.toField Rat) "deep_match" [.tuple [0, .tuple [1, 4]]], .ok 4), + ("nested first match", eval (sample.toField Rat) "deep_match" [.tuple [0, .tuple [1, 0]]], .ok 0), + ("nested default", eval (sample.toField Rat) "deep_match" [.tuple [2, .tuple [1, 2]]], .ok 7), + ("partial match", eval (sample.toField Rat) "partial_pair" [.tuple [0, 1]], .error .noMatchingArm), + ("tuple recursion", eval (sample.toField Rat) "reduce" [.tuple [4, 0]] 40, .ok (.tuple [0, 10])), + ("mutual tuple recursion", eval (sample.toField Rat) "even" [.tuple [4, 0]] 40, .ok (.tuple [1, 4])), + ("tuple nontermination", eval (sample.toField Rat) "looping" [.tuple [1, 2]] 10, .error .outOfFuel), + ("strict tuple construction", eval (sample.toField Rat) "eager_tuple" [], .error .divisionByZero), + ("strict discarded tuple", eval (sample.toField Rat) "discarded_tuple" [], .error .divisionByZero), + ("unit call", eval (sample.toField Rat) "call_unit" [2], .ok (.tuple [])), + ("unit call still executes", eval (sample.toField Rat) "call_unit" [0], .error .divisionByZero), + ("inactive tuple branch", eval (sample.toField Rat) "lazy" [.tuple [0, 9]], .ok (.tuple [9, 9])), + ("irrefutable tuple ends match", eval (sample.toField Rat) "catch_all" [.tuple [4, 0]], .ok 4), + ("entry tuple shape", eval (sample.toField Rat) "swap" [2], + .error (.argumentTypeMismatch "swap" (.tuple [.field, .field]) .field)), + ("entry singleton shape", eval (sample.toField Rat) "grouped" [.tuple [2]], + .error (.argumentTypeMismatch "grouped" .field (.tuple [.field]))) +] + +-- All of these fail at elaboration, before choosing a field. +run_cmd do + let env ← Lean.getEnv + for source in [ + "fn f(x) -> Field { x }", + "fn f(x: Field) { x }", + "fn f() { () }", + "fn f(x: Nat) -> Field { x }", + "fn f() -> Field { (1,) }", + "fn f() -> (Field,) { (1) }", + "fn f() -> Field { () + 1 }", + "fn f() -> Field { -(1, 2) }", + "fn f() -> Field { (1, 2).2 }", + "fn f(x: Field) -> Field { x.0 }", + "fn f() -> Field { let (x, y) = (1,); x }", + "fn f() -> Field { let (x, x) = (1, 2); x }", + "fn f() -> Field { match (1, 2) { (x, x) => x } }", + "fn f() -> Field { match (1, 2) { (x,) => x } }", + "fn f() -> Field { match (1, 2) { 0 => 1, _ => 2 } }", + "fn f() -> Field { match 0 { 0 => 1, _ => () } }", + "fn f() -> Field { match 0 { x => x } + x }", + "fn f(p: (Field, Field)) -> Field { p.0 } fn g() -> Field { f((1,)) }", + "fn f((x, y): (Field, Field), x: Field) -> Field { x }", + "fn f((0, x): (Field, Field)) -> Field { x }" + ] do + match Frontend.ofString env source with + | .error _ => pure () + | .ok _ => throwError "unexpectedly accepted invalid source: {source}" + + +def system : System Rat := (compile (sample.toField Rat)).toOption.getD { chips := [] } +theorem compiled : compile (sample.toField Rat) = .ok system := by + have succeeds : (compile (sample.toField Rat)).isOk = true := by decide +kernel + cases lowered : compile (sample.toField Rat) with + | error error => simp [lowered, Except.isOk, Except.toBool] at succeeds + | ok chips => simp [system, lowered, Except.toOption] + +-- A tuple-only run allocates nothing, so its completeness needs no field-capacity bound. +example : Circuit.EncodedEntryDerives system "reduce" (entryValues [.tuple [4, 0]]) (.tuple [0, 10]) := by + have executed : run (sample.toField Rat) "reduce" [.tuple [4, 0]] 40 = + .ok (.tuple [.field 0, .field 10], []) := by decide +kernel + obtain ⟨_, entry, locals, expr, prepared, body⟩ := run_eq_ok_iff.mp executed + have complete := compiler_heap_complete compiled entry (.intro prepared (evalExpr_spec body)) + (fun _ => (0 : Rat)) (by simp) + simp only [Value.mapAddress, List.map_cons, List.map_nil] at complete + exact complete + +private def checkEqual [DecidableEq α] [Repr α] (label : String) (actual expected : α) : IO Unit := do + unless actual = expected do + throw (IO.userError s!"{label}: expected {repr expected}, got {repr actual}") + +def run : IO Unit := do + for (label, actual, expected) in rationalTests do + checkEqual label actual expected + checkEqual "tuple compiler regression" (Circuit.compile (sample.toField Rat)).isOk true + IO.println s!"Passed {rationalTests.length + 1} tuple checks against the main API." + +end AiurTupleRuntimeTests diff --git a/Aiur/AiurTests/Tuples.lean b/Aiur/AiurTests/Tuples.lean new file mode 100644 index 000000000..4d6dedce4 --- /dev/null +++ b/Aiur/AiurTests/Tuples.lean @@ -0,0 +1,381 @@ +import Aiur.Tuple +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod +import Mathlib.Tactic.FinCases +import Mathlib.Tactic.NormNum + +open Aiur.Tuple Aiur.Tuple.Circuit + +namespace AiurTupleTests + +def sample : Program Nat := tuple_aiur% " +fn unit() -> () { () } +fn singleton(x: Field) -> (Field,) { (x,) } +fn grouped(x: Field) -> Field { (x) } +fn wide(x: Field) -> (Field, Field, Field, Field, Field) { (x, 2, 3, 4, 5) } +fn nested(x: Field) -> (Field, (Field, ()), (Field,)) { (x, (x + 1, ()), (x + 2,)) } +fn swap(p: (Field, Field)) -> (Field, Field) { match p { (x, y) => (y, x) } } +fn destructure((x, (y, z)): (Field, (Field, Field))) -> Field { x + y + z } +fn unpack(p: (Field, (Field, ()))) -> Field { let (x, (y, ())) = p; x + y } +fn shadow(x: Field) -> Field { let (x, y) = (x + 1, x + 2); x * y } +fn projection(p: (Field, (Field, Field))) -> Field { p.1.0 } +fn call_projection(p: (Field, Field)) -> Field { swap(p).0 } +fn overlap(p: (Field, Field)) -> Field { + match p { (0, _) => 11, (_, 0) => 22, _ => 33 } +} +fn deep_match(p: (Field, (Field, Field))) -> Field { + match p { (0, (1, x)) => x, (_, (_, 0)) => 9, _ => 7 } +} +fn partial_pair(p: (Field, Field)) -> Field { match p { (0, 0) => 1 } } +fn reduce(p: (Field, Field)) -> (Field, Field) { + match p { (0, total) => (0, total), (n, total) => reduce((n - 1, total + n)) } +} +fn even(p: (Field, Field)) -> (Field, Field) { + match p { (0, total) => (1, total), (n, total) => odd((n - 1, total + 1)) } +} +fn odd(p: (Field, Field)) -> (Field, Field) { + match p { (0, total) => (0, total), (n, total) => even((n - 1, total + 1)) } +} +fn eager_tuple() -> Field { (7, 1 / 0).0 } +fn discarded_tuple() -> Field { let _ = (7, 1 / 0); 9 } +fn divide_unit(x: Field) -> () { let _ = 1 / x; () } +fn call_unit(x: Field) -> () { divide_unit(x) } +fn looping(p: (Field, Field)) -> (Field, Field) { looping(p) } +fn lazy(p: (Field, Field)) -> (Field, Field) { + match p { (0, x) => (x, x), _ => looping((1 / 0, 0)) } +} +fn catch_all(p: (Field, Field)) -> Field { + match p { (x, _) => x, (0, 0) => 1, (0, 0) => 2 } +} +" + +def rationalTests : List (String × Except EvalError (Value Rat) × Except EvalError (Value Rat)) := [ + ("unit", eval (sample.toField Rat) "unit" [], .ok (.tuple [])), + ("singleton", eval (sample.toField Rat) "singleton" [7], .ok (.tuple [7])), + ("grouping", eval (sample.toField Rat) "grouped" [7], .ok 7), + ("wide tuple", eval (sample.toField Rat) "wide" [7], .ok (.tuple [7, 2, 3, 4, 5])), + ("nested tuple", eval (sample.toField Rat) "nested" [7], + .ok (.tuple [7, .tuple [8, .tuple []], .tuple [9]])), + ("tuple pattern", eval (sample.toField Rat) "swap" [.tuple [2, 3]], .ok (.tuple [3, 2])), + ("parameter pattern", eval (sample.toField Rat) "destructure" [.tuple [1, .tuple [2, 3]]], .ok 6), + ("let pattern", eval (sample.toField Rat) "unpack" [.tuple [1, .tuple [2, .tuple []]]], .ok 3), + ("binding scope", eval (sample.toField Rat) "shadow" [2], .ok 12), + ("nested projection", eval (sample.toField Rat) "projection" [.tuple [1, .tuple [2, 3]]], .ok 2), + ("call projection", eval (sample.toField Rat) "call_projection" [.tuple [2, 3]], .ok 3), + ("overlap first", eval (sample.toField Rat) "overlap" [.tuple [0, 0]], .ok 11), + ("overlap second", eval (sample.toField Rat) "overlap" [.tuple [5, 0]], .ok 22), + ("overlap default", eval (sample.toField Rat) "overlap" [.tuple [5, 6]], .ok 33), + ("nested literal pattern", eval (sample.toField Rat) "deep_match" [.tuple [0, .tuple [1, 4]]], .ok 4), + ("nested first match", eval (sample.toField Rat) "deep_match" [.tuple [0, .tuple [1, 0]]], .ok 0), + ("nested default", eval (sample.toField Rat) "deep_match" [.tuple [2, .tuple [1, 2]]], .ok 7), + ("partial match", eval (sample.toField Rat) "partial_pair" [.tuple [0, 1]], .error .noMatchingArm), + ("tuple recursion", eval (sample.toField Rat) "reduce" [.tuple [4, 0]] 40, .ok (.tuple [0, 10])), + ("mutual tuple recursion", eval (sample.toField Rat) "even" [.tuple [4, 0]] 40, .ok (.tuple [1, 4])), + ("tuple nontermination", eval (sample.toField Rat) "looping" [.tuple [1, 2]] 10, .error .outOfFuel), + ("strict tuple construction", eval (sample.toField Rat) "eager_tuple" [], .error .divisionByZero), + ("strict discarded tuple", eval (sample.toField Rat) "discarded_tuple" [], .error .divisionByZero), + ("unit call", eval (sample.toField Rat) "call_unit" [2], .ok (.tuple [])), + ("unit call still executes", eval (sample.toField Rat) "call_unit" [0], .error .divisionByZero), + ("inactive tuple branch", eval (sample.toField Rat) "lazy" [.tuple [0, 9]], .ok (.tuple [9, 9])), + ("irrefutable tuple ends match", eval (sample.toField Rat) "catch_all" [.tuple [4, 0]], .ok 4), + ("entry tuple shape", eval (sample.toField Rat) "swap" [2], + .error (.argumentTypeMismatch "swap" (.tuple [.field, .field]) .field)), + ("entry singleton shape", eval (sample.toField Rat) "grouped" [.tuple [2]], + .error (.argumentTypeMismatch "grouped" .field (.tuple [.field]))) +] + +-- All of these fail at elaboration, before choosing a field. +run_cmd do + let env ← Lean.getEnv + for source in [ + "fn f(x) -> Field { x }", + "fn f(x: Field) { x }", + "fn f() { () }", + "fn f(x: Nat) -> Field { x }", + "fn f() -> Field { (1,) }", + "fn f() -> (Field,) { (1) }", + "fn f() -> Field { () + 1 }", + "fn f() -> Field { -(1, 2) }", + "fn f() -> Field { (1, 2).2 }", + "fn f(x: Field) -> Field { x.0 }", + "fn f() -> Field { let (x, y) = (1,); x }", + "fn f() -> Field { let (x, x) = (1, 2); x }", + "fn f() -> Field { let (0, x) = (1, 2); x }", + "fn f() -> Field { match (1, 2) { (x, x) => x } }", + "fn f() -> Field { match (1, 2) { (x,) => x } }", + "fn f() -> Field { match (1, 2) { 0 => 1, _ => 2 } }", + "fn f() -> Field { match 0 { 0 => 1, _ => () } }", + "fn f() -> Field { match 0 { x => x } + x }", + "fn f(p: (Field, Field)) -> Field { p.0 } fn g() -> Field { f((1,)) }", + "fn f((x, y): (Field, Field), x: Field) -> Field { x }", + "fn f((0, x): (Field, Field)) -> Field { x }" + ] do + match Frontend.ofString env source with + | .error _ => pure () + | .ok _ => throwError "unexpectedly accepted invalid source: {source}" + +example : EvalCall (sample.toField Rat) "reduce" [.tuple [4, 0]] (.tuple [0, 10]) := + eval_spec (fuel := 40) (by decide +kernel) + +example : ∃ fuel, eval (sample.toField Rat) "swap" [.tuple [2, 3]] fuel = .ok (.tuple [3, 2]) := + eval_complete (by decide +kernel) (eval_spec (fuel := 10) (by decide +kernel)) + +/-- info: 'Aiur.Tuple.eval_spec' depends on axioms: [propext, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Tuple.eval_spec + +/-- info: 'Aiur.Tuple.exists_eval_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Tuple.exists_eval_iff + +/-- info: 'Aiur.Tuple.Circuit.Compiler.lowerPattern_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Tuple.Circuit.Compiler.lowerPattern_sound + +/-- info: 'Aiur.Tuple.compiler_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Tuple.compiler_sound + +/-- info: 'Aiur.Tuple.memo_acyclic_sound' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Tuple.memo_acyclic_sound + +def calls : Program Nat := tuple_aiur% " +fn swap(p: (Field, Field)) -> (Field, Field) { (p.1, p.0) } +fn main(p: (Field, Field)) -> (Field, Field) { swap(p) } +" + +def callsSystem : System Rat := (compile (calls.toField Rat)).toOption.getD ⟨[]⟩ + +theorem calls_compiled : compile (calls.toField Rat) = .ok callsSystem := by + have succeeds : (compile (calls.toField Rat)).isOk = true := by decide +kernel + cases compiled : compile (calls.toField Rat) with + | error error => simp [compiled, Except.isOk, Except.toBool] at succeeds + | ok system => simp [callsSystem, compiled, Except.toOption] + +-- This rules out every wrong structured result, independently of the supplied rows or tree shape. +example (result : Value Rat) + (proof : CircuitEvaluates callsSystem "main" [.tuple [2, 3]] result) : + result = .tuple [3, 2] := + (compiler_sound calls_compiled proof).deterministic + (eval_spec (fuel := 10) (by decide +kernel)) + +-- The same source guarantee applies to any acyclic graph, including graphs with sharing. +example (result : Value Rat) + (graph : MemoDerivation callsSystem ⟨"main", [.tuple [2, 3]], result⟩) + (acyclic : graph.Acyclic) : result = .tuple [3, 2] := by + have evaluated := memo_acyclic_sound calls_compiled graph acyclic + change EvalCall (calls.toField Rat) "main" [.tuple [2, 3]] result at evaluated + exact evaluated.deterministic + (eval_spec (fuel := 10) (by decide +kernel)) + +example : (compile (calls.toField Rat)).isOk = true := by decide +kernel +example : callsSystem.chips.map (·.numVars) = [4, 6] := by decide +kernel +example : callsSystem.check ⟨"main", [.tuple [2, 3]], .tuple [3, 2]⟩ + [⟨"main", [2, 3, 3, 2, 3, 2]⟩, ⟨"swap", [2, 3, 3, 2]⟩] = .ok () := by decide +kernel +example : callsSystem.check ⟨"main", [.tuple [2, 3]], .tuple [.tuple [3, 2]]⟩ + [⟨"main", [2, 3, 3, 2, 3, 2]⟩, ⟨"swap", [2, 3, 3, 2]⟩] = .error .unbalancedMessages := by decide +kernel + +def tupleSwapChip : Chip Rat := { + name := "swap", inputs := [.tuple [.field 0, .field 1]], output := .tuple [.field 2, .field 3] + numVars := 4 + constraints := [.mul (.const 1) (.sub (.var 2) (.var 1)), + .mul (.const 1) (.sub (.var 3) (.var 0))] + sends := [] +} + +def tupleMainChip : Chip Rat := { + name := "main", inputs := [.tuple [.field 0, .field 1]], output := .tuple [.field 2, .field 3] + numVars := 6 + constraints := [.mul (.const 1) (.sub (.const 1) (.const 1)), + .mul (.const 1) (.sub (.var 2) (.var 4)), + .mul (.const 1) (.sub (.var 3) (.var 5))] + sends := [⟨"swap", [.tuple [.field (.var 0), .field (.var 1)]], .tuple [.field 4, .field 5], .const 1⟩] +} + +def graphSystem : System Rat := ⟨[tupleSwapChip, tupleMainChip]⟩ + +-- The concrete graph below uses the compiler's exact chips, including all guards. +theorem graph_compiled : compile (calls.toField Rat) = .ok graphSystem := by + have checked : typecheck (calls.toField Rat) = .ok () := by decide +kernel + have modify_run (update : Compiler.BuildState Rat → Compiler.BuildState Rat) + (state : Compiler.BuildState Rat) : + (modify update : Compiler.Build Rat Unit) state = .ok ((), update state) := rfl + simp only [compile, checked] + simp [calls, Program.toField, Program.map, Function.map, Expr.map, Program.findFunction?, + Compiler.lowerFunction, Compiler.lowerExpr, Compiler.lowerArgs, Compiler.freshValues, + Compiler.freshValue, Compiler.constrainValue, Compiler.constrainValues, Value.map, + StateT.run, StateT.bind, StateT.pure, modify_run, + bind, pure, Except.bind, Except.pure, + graphSystem, tupleSwapChip, tupleMainChip] + +def swapRule : RuleInstance graphSystem := { + chip := tupleSwapChip + row := ⟨"swap", [2, 3, 3, 2]⟩ + lookup := rfl + valid := by norm_num [Chip.ValidRow, Chip.wellFormed, Satisfies, Aiur.Scalar.Circuit.Satisfies, tupleSwapChip, + Value.flatten, ArithExpr.inBounds, ArithExpr.denote, Row.assignment, + Aiur.Scalar.Circuit.ArithExpr.inBounds, Aiur.Scalar.Circuit.ArithExpr.denote, Aiur.Scalar.Circuit.Row.assignment] +} + +def mainRule : RuleInstance graphSystem := { + chip := tupleMainChip + row := ⟨"main", [2, 3, 3, 2, 3, 2]⟩ + lookup := rfl + valid := by norm_num [Chip.ValidRow, Chip.wellFormed, Satisfies, Aiur.Scalar.Circuit.Satisfies, tupleMainChip, + Send.inBounds, Value.flatten, ArithExpr.inBounds, ArithExpr.denote, Row.assignment, + Aiur.Scalar.Circuit.ArithExpr.inBounds, Aiur.Scalar.Circuit.ArithExpr.denote, Aiur.Scalar.Circuit.Row.assignment] +} + +def tupleGraph : MemoDerivation graphSystem ⟨"main", [.tuple [2, 3]], .tuple [3, 2]⟩ := { + size := 2 + node := fun i => if i.val = 0 then swapRule else mainRule + root := 1 + root_claim := by decide +kernel + target := fun _ _ => 0 + target_claim := by + intro i j + fin_cases i + · exact Fin.elim0 j + · fin_cases j; decide +kernel +} + +theorem tupleGraph_acyclic : tupleGraph.Acyclic := by + have step : ∀ child parent, tupleGraph.Dependency child parent → child.val < parent.val := by + intro child parent ⟨j, same⟩ + fin_cases parent + · exact Fin.elim0 j + · subst child; simp [tupleGraph] + have increasing {child parent} (path : Relation.TransGen tupleGraph.Dependency child parent) : + child.val < parent.val := by + induction path with + | single edge => exact step _ _ edge + | tail _ edge ih => exact Nat.lt_trans ih (step _ _ edge) + intro i cycle + exact Nat.lt_irrefl i.val (increasing cycle) + +example : CircuitEvaluates graphSystem "main" [.tuple [2, 3]] (.tuple [3, 2]) := + tupleGraph.derives_of_acyclic tupleGraph_acyclic + +example : MemoAccepts graphSystem "main" [.tuple [2, 3]] (.tuple [3, 2]) := + (tupleGraph.derives_of_acyclic tupleGraph_acyclic).memo + +example : EvalCall (calls.toField Rat) "main" [.tuple [2, 3]] (.tuple [3, 2]) := + memo_acyclic_sound graph_compiled tupleGraph tupleGraph_acyclic + +/-- info: 'Aiur.Tuple.Circuit.MemoDerivation.derives_of_acyclic' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Tuple.Circuit.MemoDerivation.derives_of_acyclic + +def overlap : Program Nat := tuple_aiur% " +fn choose(p: (Field, Field)) -> Field { match p { (0, _) => 11, (_, 0) => 22, _ => 33 } } +" +def overlapSystem : System Rat := (compile (overlap.toField Rat)).toOption.getD ⟨[]⟩ + +theorem overlap_compiled : compile (overlap.toField Rat) = .ok overlapSystem := by + have succeeds : (compile (overlap.toField Rat)).isOk = true := by decide +kernel + cases compiled : compile (overlap.toField Rat) with + | error error => simp [compiled, Except.isOk, Except.toBool] at succeeds + | ok system => simp [overlapSystem, compiled, Except.toOption] + +-- Overlapping matches force Rust's first arm for every closed derivation, not just the sample rows. +example (result : Value Rat) + (proof : CircuitEvaluates overlapSystem "choose" [.tuple [0, 0]] result) : result = 11 := + (compiler_sound overlap_compiled proof).deterministic + (eval_spec (fuel := 10) (by decide +kernel)) + +-- A wildcard is reached only when both preceding tuple patterns fail. +example (result : Value Rat) + (proof : CircuitEvaluates overlapSystem "choose" [.tuple [5, 6]] result) : result = 33 := + (compiler_sound overlap_compiled proof).deterministic + (eval_spec (fuel := 10) (by decide +kernel)) + +example : overlapSystem.chips.map (·.numVars) = [11] := by decide +kernel +example : overlapSystem.check ⟨"choose", [.tuple [0, 0]], 11⟩ + [⟨"choose", [0, 0, 11, 11, 1, 0, 1, 1, 0, 0, 0]⟩] = .ok () := by decide +kernel +example : overlapSystem.check ⟨"choose", [.tuple [5, 0]], 22⟩ + [⟨"choose", [5, 0, 22, 22, 0, 1/5, 0, 1, 0, 1, 0]⟩] = .ok () := by decide +kernel +example : overlapSystem.check ⟨"choose", [.tuple [5, 6]], 33⟩ + [⟨"choose", [5, 6, 33, 33, 0, 1/5, 0, 0, 1/6, 0, 1]⟩] = .ok () := by decide +kernel +example : (overlapSystem.check ⟨"choose", [.tuple [0, 0]], 22⟩ + [⟨"choose", [0, 0, 22, 22, 1, 0, 0, 1, 0, 1, 0]⟩]).isOk = false := by decide +kernel + +def units : Program Nat := tuple_aiur% "fn u(x: ()) -> () { x } fn main() -> () { u(()) }" +def unitSystem : System Rat := (compile (units.toField Rat)).toOption.getD ⟨[]⟩ +example : unitSystem.chips.map (·.numVars) = [0, 0] := by decide +kernel +example : unitSystem.check ⟨"main", [], .tuple []⟩ [⟨"main", []⟩, ⟨"u", []⟩] = .ok () := by decide +kernel +example : unitSystem.check ⟨"main", [], .tuple []⟩ [⟨"main", []⟩] = .error .unbalancedMessages := by decide +kernel + +def duplicates : Program Nat := tuple_aiur% " +fn f(p: (Field, Field)) -> Field { match p { (0, x) => x, (7, _) => 2, _ => 3 } } +" +instance : Fact (Nat.Prime 7) := ⟨by decide⟩ +example : (compile (duplicates.toField Rat)).isOk = true := by decide +kernel +example : (compile (duplicates.toField (ZMod 7))).map (fun _ => ()) = + .error (.duplicatePattern "f") := by decide +kernel +example : eval (sample.toField (ZMod 7)) "nested" [6] = + .ok (.tuple [6, .tuple [0, .tuple []], .tuple [1]]) := by decide +kernel + +/-- info: 'Aiur.Tuple.evaluation_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Tuple.evaluation_complete + +/-- info: 'Aiur.Tuple.compiler_correct' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Tuple.compiler_correct + +/-- info: 'Aiur.Tuple.memo_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Tuple.memo_complete + +/-- info: 'Aiur.Tuple.memo_eval_complete' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Aiur.Tuple.memo_eval_complete + +-- Completeness supplies the witnesses existentially; these proofs provide no hand-written rows. +example : CircuitEvaluates callsSystem "main" [.tuple [2, 3]] (.tuple [3, 2]) := + evaluation_complete calls_compiled (eval_spec (fuel := 10) (by decide +kernel)) + +example : CircuitEvaluates overlapSystem "choose" [.tuple [0, 0]] 11 := + evaluation_complete overlap_compiled (eval_spec (fuel := 10) (by decide +kernel)) + +example : CircuitEvaluates overlapSystem "choose" [.tuple [5, 0]] 22 := + evaluation_complete overlap_compiled (eval_spec (fuel := 10) (by decide +kernel)) + +example : CircuitEvaluates overlapSystem "choose" [.tuple [5, 6]] 33 := + evaluation_complete overlap_compiled (eval_spec (fuel := 10) (by decide +kernel)) + +def sampleSystem : System Rat := (compile (sample.toField Rat)).toOption.getD ⟨[]⟩ + +theorem sample_compiled : compile (sample.toField Rat) = .ok sampleSystem := by + have succeeds : (compile (sample.toField Rat)).isOk = true := by decide +kernel + cases compiled : compile (sample.toField Rat) with + | error error => simp [compiled, Except.isOk, Except.toBool] at succeeds + | ok system => simp [sampleSystem, compiled, Except.toOption] + +-- Nested and empty leaves, tuple recursion, and inactive failure all use the same general theorem. +example : CircuitEvaluates sampleSystem "nested" [7] + (.tuple [7, .tuple [8, .tuple []], .tuple [9]]) := + evaluation_complete sample_compiled (eval_spec (fuel := 10) (by decide +kernel)) + +example : CircuitEvaluates sampleSystem "deep_match" [.tuple [0, .tuple [1, 0]]] 0 := + evaluation_complete sample_compiled (eval_spec (fuel := 10) (by decide +kernel)) + +example : CircuitEvaluates sampleSystem "lazy" [.tuple [0, 9]] (.tuple [9, 9]) := + evaluation_complete sample_compiled (eval_spec (fuel := 10) (by decide +kernel)) + +example : CircuitEvaluates sampleSystem "call_unit" [2] (.tuple []) := + evaluation_complete sample_compiled (eval_spec (fuel := 10) (by decide +kernel)) + +example : MemoAccepts sampleSystem "even" [.tuple [4, 0]] (.tuple [1, 4]) := + memo_eval_complete sample_compiled (fuel := 40) (by decide +kernel) + +def run : IO Unit := do + for (label, actual, expected) in rationalTests do + unless actual = expected do + throw (IO.userError s!"{label}: expected {repr expected}, got {repr actual}") + unless (compile (sample.toField Rat)).isOk do + throw (IO.userError "tuple sample did not compile") + IO.println s!"Passed {rationalTests.length} tuple runtime checks and tuple compilation." + +end AiurTupleTests diff --git a/Aiur/AiurTests/U32.lean b/Aiur/AiurTests/U32.lean new file mode 100644 index 000000000..fe1cc2aa9 --- /dev/null +++ b/Aiur/AiurTests/U32.lean @@ -0,0 +1,143 @@ +import Aiur.Library.U32.Correctness +import Aiur.Library.U32.Hints +import Mathlib.Algebra.Field.Rat + +namespace AiurU32Tests +open Aiur + +set_option maxRecDepth 10000 +set_option maxHeartbeats 12000000 + +def client : Modules.Program Nat := aiur_library% Library.U32.templates r#" +module Words { + fn byte(x: Field) -> Field { UInt8::to_field(UInt8::from_field(x)) } + fn pack(raw: [Field; 4]) -> Field { + UInt32::compact_field(UInt32::compact(UInt32::from_fields(raw))) + } + fn expand(value: Field) -> [Field; 4] { + let word = UInt32::from_field(value); + let bytes = UInt32::to_bytes(UInt32::expand(UInt32::compact(word))); + [UInt8::to_field(bytes[0]), UInt8::to_field(bytes[1]), + UInt8::to_field(bytes[2]), UInt8::to_field(bytes[3])] + } + fn add(a: [Field; 4], b: [Field; 4]) -> Field { + UInt32::compact_field(UInt32::compact(UInt32::add(UInt32::from_fields(a), UInt32::from_fields(b)))) + } + fn add3(a: [Field; 4], b: [Field; 4], c: [Field; 4]) -> Field { + UInt32::compact_field(UInt32::compact(UInt32::add3( + UInt32::from_fields(a), UInt32::from_fields(b), UInt32::from_fields(c)))) + } + fn sub(a: [Field; 4], b: [Field; 4]) -> Field { + UInt32::compact_field(UInt32::compact(UInt32::sub(UInt32::from_fields(a), UInt32::from_fields(b)))) + } + fn lt(a: [Field; 4], b: [Field; 4]) -> Field { + UInt32::less_than(UInt32::from_fields(a), UInt32::from_fields(b)) + } + fn compact_lt(a: Field, b: Field) -> Field { + UInt32::compact_less_than(UInt32::compact_from_field(a), UInt32::compact_from_field(b)) + } + fn raw_lt(a: Field, b: Field) -> Field { UInt32::less_than_fields(a, b) } + fn xor(a: [Field; 4], b: [Field; 4]) -> Field { + UInt32::compact_field(UInt32::compact(UInt32::xor(UInt32::from_fields(a), UInt32::from_fields(b)))) + } + fn and(a: [Field; 4], b: [Field; 4]) -> Field { + UInt32::compact_field(UInt32::compact(UInt32::and(UInt32::from_fields(a), UInt32::from_fields(b)))) + } + fn or(a: [Field; 4], b: [Field; 4]) -> Field { + UInt32::compact_field(UInt32::compact(UInt32::or(UInt32::from_fields(a), UInt32::from_fields(b)))) + } + fn rotr8(a: [Field; 4]) -> Field { + UInt32::compact_field(UInt32::compact(UInt32::rotr8(UInt32::from_fields(a)))) + } + fn rotr16(a: [Field; 4]) -> Field { + UInt32::compact_field(UInt32::compact(UInt32::rotr16(UInt32::from_fields(a)))) + } + fn xor_rotr7(a: [Field; 4], b: [Field; 4]) -> Field { + UInt32::compact_field(UInt32::compact(UInt32::xor_rotr7(UInt32::from_fields(a), UInt32::from_fields(b)))) + } + fn xor_rotr12(a: [Field; 4], b: [Field; 4]) -> Field { + UInt32::compact_field(UInt32::compact(UInt32::xor_rotr12(UInt32::from_fields(a), UInt32::from_fields(b)))) + } + fn overflow() -> Field { + UInt32::compact_field(UInt32::compact(UInt32::add(UInt32::MAX, UInt32::ONE))) + } + fn overflow3() -> Field { + UInt32::compact_field(UInt32::compact(UInt32::add3(UInt32::MAX, UInt32::MAX, UInt32::MAX))) + } + fn conversion() -> Field { + UInt32::compact_field(UInt32::compact(UInt32::from_bytes(UInt32::to_bytes(UInt32::MAX)))) + } +} +"# + +def entries : List String := client.modules.flatMap fun m => match m.body with + | .definitions d => d.program.functions.map fun f => "Words::" ++ f.name + | _ => [] + +def source : Modules.Program Nat := Library.U32.source.append client + +run_cmd do + let env ← Lean.getEnv + for type in ["UInt8::U8", "UInt32::U32", "UInt32::Compact", + "[UInt8::U8; 4]", "(Field, UInt32::U32)", "[UInt32::Compact; 0]"] do + let .ok bad := Modules.Frontend.parse env + s!"module Bad \{ fn run() -> {type} \{ hint::<{type}>(\"bad\", 0) } }" | + throwError "invalid negative test syntax" + unless (Modules.checkTemplates (Library.U32.templates.append bad)).toOption.isNone do + throwError "hint fabricated an opaque value: {type}" + +private def get {α : Type} : Except String α → IO α := IO.ofExcept + +private def bytes (n : Nat) : SourceValue Rat := + .tuple ((List.range 4).map fun i => .field (((n / 256^i) % 256 : Nat) : Rat)) + +def run : IO Unit := do + let prepared ← get <| Modules.prepare (source.toField Rat) entries + let dispatcher := Library.U32.hints (fun (x : Rat) => x.num.toNat / x.den) + let hints := prepared.environment.source.checkedHints dispatcher + let expect (name : String) (args : List (SourceValue Rat)) (expected : SourceValue Rat) := do + let (actual, _) ← get <| prepared.run ("Words::" ++ name) args (fuel := 100000) (hints := hints) + unless actual == expected do throw (IO.userError s!"u32 {name}: {repr actual} != {repr expected}") + let values := [0, 1, 255, 256, 65535, 65536, 2147483648, 4294967294, 4294967295] + for a in values do + expect "pack" [bytes a] (.field a) + expect "expand" [.field a] (bytes a) + for b in [0, 1, 4294967295] do + expect "add" [bytes a, bytes b] (.field ((a+b)%Library.U32.base)) + expect "add3" [bytes a, bytes b, bytes b] (.field ((a+b+b)%Library.U32.base)) + expect "sub" [bytes a, bytes b] (.field ((a+Library.U32.base-b)%Library.U32.base)) + expect "lt" [bytes a, bytes b] (.field (if a < b then 1 else 0)) + expect "compact_lt" [.field a, .field b] (.field (if a < b then 1 else 0)) + expect "raw_lt" [.field a, .field b] (.field (if a < b then 1 else 0)) + expect "xor" [bytes a, bytes b] (.field (Nat.xor a b)) + expect "and" [bytes a, bytes b] (.field (Nat.land a b)) + expect "or" [bytes a, bytes b] (.field (Nat.lor a b)) + let x := Nat.xor a b + expect "xor_rotr7" [bytes a, bytes b] (.field ((x / 128 + (x % 128) * 33554432 : Nat) : Rat)) + expect "xor_rotr12" [bytes a, bytes b] (.field ((x / 4096 + (x % 4096) * 1048576 : Nat) : Rat)) + expect "rotr8" [bytes a] (.field ((a / 256 + (a % 256) * 16777216 : Nat) : Rat)) + expect "rotr16" [bytes a] (.field ((a / 65536 + (a % 65536) * 65536 : Nat) : Rat)) + expect "overflow" [] 0 + expect "overflow3" [] 4294967293 + expect "conversion" [] 4294967295 + for (name, args) in [("byte", [.field 256]), ("byte", [.field (-1)]), + ("pack", [.tuple [256, 0, 0, 0]]), ("expand", [.field 4294967296]), + ("expand", [.field (-1)]), ("compact_lt", [.field 4294967296, .field 0]), + ("raw_lt", [.field 4294967296, .field 0]), ("raw_lt", [.field 0, .field (-1)])] do + unless (prepared.run ("Words::" ++ name) args (hints := hints)).toOption.isNone do + throw (IO.userError s!"invalid u32 input accepted: {name}") + for (name, answer) in [("overflow", [1, 0, 0, 0]), + ("overflow", [256, 0, 0, 0]), ("overflow", [255, 255, 255, 255]), + ("overflow3", [254, 255, 255, 255]), ("overflow3", [252, 255, 255, 255])] do + let dishonest := prepared.environment.source.checkedHints fun _ _ => + .ok (.tuple (answer.map fun x => .field x)) + unless (prepared.run ("Words::" ++ name) [] (hints := dishonest)).toOption.isNone do + throw (IO.userError s!"dishonest u32 hint accepted: {name}") + let compiled ← get prepared.compileOptimized + let some conversion := compiled.circuit.system.findChip? "Words::conversion" | + throw (IO.userError "missing conversion chip") + unless conversion.sends.isEmpty do + throw (IO.userError "typed conversion added a lookup") + IO.println "Passed opaque u32 arithmetic, conversion, boundary and dishonest-hint checks over Rat." + +end AiurU32Tests diff --git a/Aiur/AiurTests/U64.lean b/Aiur/AiurTests/U64.lean new file mode 100644 index 000000000..c9c8c5727 --- /dev/null +++ b/Aiur/AiurTests/U64.lean @@ -0,0 +1,79 @@ +import Aiur.Library.U64.Hints +import Mathlib.Algebra.Field.Rat + +namespace AiurU64Tests +open Aiur +set_option maxRecDepth 10000 + +def client : Modules.Program Nat := aiur_library% Library.U64.templates r#" +module Wide { + inline fn fields(x: UInt64::U64) -> [Field; 8] { + [UInt8::to_field(x[0]), UInt8::to_field(x[1]), UInt8::to_field(x[2]), UInt8::to_field(x[3]), UInt8::to_field(x[4]), UInt8::to_field(x[5]), UInt8::to_field(x[6]), UInt8::to_field(x[7])] + } + fn add(a: [Field; 8], b: [Field; 8]) -> ([Field; 8], Field) { + let (word, carry) = UInt64::add(UInt64::from_fields(a), UInt64::from_fields(b)); + (fields(word), UInt8::to_field(carry)) + } + fn sub(a: [Field; 8], b: [Field; 8]) -> ([Field; 8], Field) { + let (word, borrow) = UInt64::sub_with_borrow(UInt64::from_fields(a), UInt64::from_fields(b)); + (fields(word), borrow) + } + fn mul(a: [Field; 8], b: [Field; 8]) -> ([Field; 8], [Field; 8]) { + let (lo, hi) = UInt64::mul(UInt64::from_fields(a), UInt64::from_fields(b)); + (fields(lo), fields(hi)) + } + fn from_field(x: Field) -> [Field; 8] { fields(UInt64::from_field(x)) } + fn to_field(x: [Field; 8]) -> Field { UInt64::to_field(UInt64::from_fields(x)) } + fn eq(a: [Field; 8], b: [Field; 8]) -> Field { UInt64::eq(UInt64::from_fields(a), UInt64::from_fields(b)) } + fn is_zero(a: [Field; 8]) -> Field { UInt64::is_zero(UInt64::from_fields(a)) } + fn and(a: [Field; 8], b: [Field; 8]) -> [Field; 8] { fields(UInt64::and(UInt64::from_fields(a), UInt64::from_fields(b))) } + fn or(a: [Field; 8], b: [Field; 8]) -> [Field; 8] { fields(UInt64::or(UInt64::from_fields(a), UInt64::from_fields(b))) } + fn xor(a: [Field; 8], b: [Field; 8]) -> [Field; 8] { fields(UInt64::xor(UInt64::from_fields(a), UInt64::from_fields(b))) } + fn wrapping_succ(a: [Field; 8]) -> [Field; 8] { fields(UInt64::wrapping_succ(UInt64::from_fields(a))) } + fn saturating_pred(a: [Field; 8]) -> [Field; 8] { fields(UInt64::saturating_pred(UInt64::from_fields(a))) } +} +"# + +def entries : List String := client.modules.flatMap fun m => match m.body with + | .definitions d => (d.program.functions.filter (·.name != "fields")).map fun f => "Wide::" ++ f.name + | _ => [] + +run_cmd do + let .ok bad := Modules.Frontend.parse (← Lean.getEnv) + "module Bad { fn run() -> UInt64::U64 { hint::(0) } }" | + throwError "invalid U64 opacity test" + unless (Modules.checkTemplates (Library.U64.templates.append bad)).toOption.isNone do + throwError "hint fabricated a word of opaque bytes" + +private def bytes (n : Nat) : SourceValue Rat := + .tuple ((List.range 8).map fun i => .field (((n / 256^i) % 256 : Nat) : Rat)) + +def run : IO Unit := do + let prepared ← IO.ofExcept <| Modules.prepare ((Library.U64.source.append client).toField Rat) entries + let hints := prepared.environment.source.checkedHints (Library.U64.hints (fun (x : Rat) => x.num.toNat / x.den)) + let expect (name : String) (args : List (SourceValue Rat)) (expected : SourceValue Rat) := do + let (actual, _) ← IO.ofExcept <| prepared.run ("Wide::" ++ name) args (fuel := 100000) (hints := hints) + unless actual == expected do throw (IO.userError s!"u64 {name}: {repr actual} != {repr expected}") + let base : Nat := 2^64 + for a in [0, 255, 256, 2^32, base-1] do + expect "wrapping_succ" [bytes a] (bytes ((a+1)%base)) + expect "saturating_pred" [bytes a] (bytes (a-1)) + for b in [0, 1, base-1] do + expect "add" [bytes a, bytes b] (.tuple [bytes ((a+b)%base), .field (((a+b)/base : Nat) : Rat)]) + expect "sub" [bytes a, bytes b] (.tuple [bytes ((a+base-b)%base), .field (if a < b then 1 else 0)]) + expect "mul" [bytes a, bytes b] (.tuple [bytes (a*b%base), bytes (a*b/base)]) + for a in ([0, 256, 2^56-1] : List Nat) do + expect "from_field" [.field a] (bytes a) + expect "to_field" [bytes a] (.field a) + for (entry, args) in [("from_field", [.field (2^56)]), ("to_field", [bytes (2^56)]), + ("add", [.tuple [256, 0, 0, 0, 0, 0, 0, 0], bytes 0])] do + unless (prepared.run ("Wide::" ++ entry) args (hints := hints)).toOption.isNone do + throw (IO.userError s!"u64 invalid input accepted: {entry}") + let dishonest := prepared.environment.source.checkedHints fun _ _ => + .ok (.tuple (List.replicate 8 (.field 0))) + for (entry, args) in [("from_field", [.field 1]), ("mul", [bytes 1, bytes 1])] do + unless (prepared.run ("Wide::" ++ entry) args (hints := dishonest)).toOption.isNone do + throw (IO.userError s!"u64 dishonest hint accepted: {entry}") + IO.println "Passed shared U64 arithmetic, carries, conversion limits and dishonest-hint checks over Rat." + +end AiurU64Tests diff --git a/Aiur/AiurTests/U8.lean b/Aiur/AiurTests/U8.lean new file mode 100644 index 000000000..dc6abf32d --- /dev/null +++ b/Aiur/AiurTests/U8.lean @@ -0,0 +1,137 @@ +import Aiur.Library.U8 +import Aiur.Library.Frontend +import Mathlib.Algebra.Field.Rat + +namespace AiurU8Tests +open Aiur + +set_option maxRecDepth 10000 + +def client : Modules.Program Nat := aiur_library% Library.U8.templates " +module ByteChecks { + fn checked(value: Field) -> Field { UInt8::to_field(UInt8::from_field(value)) } + fn less_than(a: Field, b: Field) -> Field { UInt8::raw_lt(a, b) } + fn and(a: Field, b: Field) -> Field { UInt8::to_field(UInt8::raw_and(a, b)) } + fn or(a: Field, b: Field) -> Field { UInt8::to_field(UInt8::raw_or(a, b)) } + fn split(sum: Field) -> (Field, Field) { + let (lo, carry) = UInt8::split_sum(sum); + (UInt8::to_field(lo), UInt8::to_field(carry)) + } + fn add(a: Field, b: Field) -> (Field, Field) { + let (lo, carry) = UInt8::raw_add(a, b); + (UInt8::to_field(lo), UInt8::to_field(carry)) + } + fn sub(a: Field, b: Field) -> (Field, Field) { + let (lo, borrow) = UInt8::raw_sub(a, b); + (UInt8::to_field(lo), UInt8::to_field(borrow)) + } + fn mul(a: Field, b: Field) -> (Field, Field) { + let (lo, hi) = UInt8::raw_mul(a, b); + (UInt8::to_field(lo), UInt8::to_field(hi)) + } + fn join4(a: Field, b: Field) -> Field { + UInt8::to_field(UInt8::join4(UInt8::raw_xor_split4(a, 0), UInt8::raw_xor_split4(b, 0))) + } + fn join7(a: Field, b: Field) -> Field { + UInt8::to_field(UInt8::join7(UInt8::raw_xor_split7(a, 0), UInt8::raw_xor_split7(b, 0))) + } +}" + +def entries := ["ByteChecks::checked", "ByteChecks::less_than", "ByteChecks::and", "ByteChecks::or", "ByteChecks::split", "ByteChecks::add", + "ByteChecks::sub", "ByteChecks::mul", "ByteChecks::join4", "ByteChecks::join7"] + +run_cmd do + for (type, raw) in [("UInt8::U8", "0"), ("UInt8::Parts4", "(0, 0)"), ("UInt8::Parts7", "(0, 0)")] do + for body in [raw, s!"hint::<{type}>(0)"] do + let .ok bad := Modules.Frontend.parse (← Lean.getEnv) + s!"module Bad \{ fn run() -> {type} \{ {body} } }" | + throwError "invalid opacity test" + unless (Modules.checkTemplates (Library.U8.templates.append bad)).toOption.isNone do + throwError "fabricated opaque value {type}: {body}" + +private def ensure (message : String) (condition : Bool) : Except String Unit := + if condition then .ok () else .error message + +private def tableRows (name : String) : Except String (Array (Generic.Expr Nat)) := do + let some table := Library.U8.tables.find? (·.name == name) | throw s!"missing generated table {name}" + return table.rows.toArray + +private def scalar : Generic.Expr Nat → Except String Nat + | .literal n => .ok n + | _ => .error "expected a generated scalar" + +private def pair : Generic.Expr Nat → Except String (Nat × Nat) + | .tuple [.literal a, .literal b] => .ok (a, b) + | _ => .error "expected a generated pair" + +/-- Check the actual generated rows, including alignment of every output trace, +for all 65,536 byte pairs. This is host-side validation, not Aiur execution. -/ +def checkTables : Except String Unit := do + let byteInputs ← tableRows "byte_inputs" + let values ← (← tableRows "byte_values").mapM scalar + let inputs ← (← tableRows "pair_inputs").mapM pair + let xors ← (← tableRows "pair_xors").mapM scalar + let adds ← (← tableRows "pair_adds").mapM pair + let subs ← (← tableRows "pair_subs").mapM pair + let muls ← (← tableRows "pair_muls").mapM pair + let parts4 ← (← tableRows "pair_xor_parts4").mapM pair + let parts7 ← (← tableRows "pair_xor_parts7").mapM pair + let units ← tableRows "pair_units" + let sumInputs ← tableRows "sum_inputs" + let sums ← (← tableRows "sum_bytes").mapM scalar + ensure "incomplete byte tables" (byteInputs.size == 256 && values.size == 256) + ensure "incomplete byte-pair tables" ([inputs.size, xors.size, adds.size, subs.size, + muls.size, parts4.size, parts7.size, units.size].all (· == 65536)) + ensure "incomplete carry table" (sumInputs.size == 768 && sums.size == 768) + for n in List.range 256 do + ensure "byte table alignment" (byteInputs[n]! == .tuple [.literal n] && values[n]! == n) + for n in List.range 768 do + let byte := sums[n]! + ensure "carry table alignment" (sumInputs[n]! == .tuple [.literal n]) + ensure "carry decomposition" (byte < 256 && n / 256 < 3 && byte + 256 * (n / 256) == n) + ensure "field carry reconstruction" (((n : Rat) - byte) / 256 == (n / 256 : Nat)) + for a in List.range 256 do + for b in List.range 256 do + let index := 256 * a + b + ensure "byte-pair table alignment" (inputs[index]! == (a, b)) + let x := xors[index]! + ensure "byte XOR" (x == Nat.xor a b) + let (sum, carry) := adds[index]! + ensure "byte addition" (sum < 256 && carry < 2 && sum + 256 * carry == a + b) + let (diff, borrow) := subs[index]! + ensure "byte subtraction" (diff < 256 && borrow < 2 && diff + b == a + 256 * borrow) + let (lo, hi) := muls[index]! + ensure "byte multiplication" (lo < 256 && hi < 256 && lo + 256 * hi == a * b) + let (hi, shifted) := parts4[index]! + ensure "XOR four-bit split" (hi < 16 && shifted < 256 && shifted % 16 == 0 && + 16 * hi + shifted / 16 == x) + let (hi, shifted) := parts7[index]! + ensure "XOR seven-bit split" (hi < 2 && shifted < 256 && shifted % 2 == 0 && + 128 * hi + shifted / 2 == x) + ensure "byte-pair range check" (units[index]! == .tuple []) + + +def run : IO Unit := do + IO.ofExcept checkTables + let prepared ← IO.ofExcept <| Modules.prepare ((Library.U8.source.append client).toField Rat) entries + for n in ([0, 1, 254, 255] : List Nat) do + let (actual, _) ← IO.ofExcept <| prepared.run "ByteChecks::checked" [.field n] + unless actual == .field n do + throw (IO.userError s!"wrong checked byte at {n}") + for (a, b) in ([(0, 255), (255, 0), (255, 255)] : List (Nat × Nat)) do + let (actual, _) ← IO.ofExcept <| prepared.run "ByteChecks::less_than" [.field a, .field b] + unless actual == .field (if a < b then 1 else 0) do + throw (IO.userError s!"wrong raw byte comparison at {a}, {b}") + for n in ([0, 255, 256, 510, 511, 512, 767] : List Nat) do + let (actual, _) ← IO.ofExcept <| prepared.run "ByteChecks::split" [.field n] + unless actual == .tuple [.field ((n % 256 : Nat) : Rat), .field ((n / 256 : Nat) : Rat)] do + throw (IO.userError s!"wrong split_sum at {n}") + for (entry, args) in [("checked", [256]), ("checked", [-1]), + ("less_than", [256, 0]), ("less_than", [0, 256]), ("less_than", [-1, 0]), + ("less_than", [0, -1]), ("split", [768]), ("split", [-1]), ("add", [256, 0]), + ("sub", [0, -1]), ("mul", [1, 256]), ("join4", [256, 0]), ("join7", [0, 256])] do + unless (prepared.run ("ByteChecks::" ++ entry) (args.map fun x => .field x)).toOption.isNone do + throw (IO.userError s!"out-of-domain byte operation accepted: {entry}") + IO.println "Passed shared U8 tables (65,536 pairs, 768 sums), opacity and raw-domain checks." + +end AiurU8Tests diff --git a/Aiur/AiurTests/Updates.lean b/Aiur/AiurTests/Updates.lean new file mode 100644 index 000000000..dee58cf60 --- /dev/null +++ b/Aiur/AiurTests/Updates.lean @@ -0,0 +1,191 @@ +import Aiur.Generic +import Mathlib.Algebra.Field.Rat +import Mathlib.Algebra.Field.ZMod + +namespace AiurUpdateTests +open Aiur +set_option maxRecDepth 20000 +set_option maxHeartbeats 8000000 + +/-- Paths and operand order survive checking and literal conversion. -/ +def source : Generic.Program Nat := aiur% " +struct Point { x: Field, y: Field } +struct Box { value: T } +struct State { point: Point, items: [(Field, Field); 2] } +struct Ptrs { x: &Field, y: &Field } +struct Empty {} +enum Option { None, Some(T) } +type P = Point; +const origin = P { x: 1, y: 2 }; + +fn point() -> Point { origin with { .y = 8, .x = 7, } } +fn tuple() -> (Field, [Field; 2]) { (1, [2, 3]) with { .1[0] = 9 } } +fn array() -> [Field; 3] { [1, 2, 3] with { [2] = 9, [0] = 8 } } +fn nested() -> State { + State { point: origin, items: [(3, 4), (5, 6)] } with { .point.x = 9, .items[1].0 = 8 } +} +fn siblings() -> Point { origin with { .x = 4, .y = 5 } } +fn changed(b: Box, value: T) -> Box { b with { .value = value } } +fn inferred() -> Field { changed(Box { value: origin }, point()).value.y } +fn explicit() -> Field { changed::(Box { value: 1 }, 6).value } +fn generic_tuple(p: (T, Field), value: T) -> (T, Field) { p with { .0 = value } } +fn generic_array(a: [T; 2], value: T) -> [T; 2] { a with { [1] = value } } +fn generics() -> Field { generic_array([1, 2], generic_tuple((3, 4), 5).0)[1] } +fn alias_use() -> P { origin with { .x = 3 } } +fn immutable() -> Field { let p = origin; let q = p with { .x = 9 }; p.x * 10 + q.x } +fn swap() -> Point { let p = origin; p with { .x = p.y, .y = p.x } } +fn chain() -> Point { origin with { .x = 3 } with { .x = 4 } } +fn projection() -> Field { (origin with { .y = 7 }).y } +fn empty() -> Empty { Empty {} with {} } +fn empty_array() -> [Field; 0] { [] with {} } +fn identity(value: T) -> T { value with {} } +fn no_changes() -> Field { identity(6) } +fn pointers() -> Ptrs { Ptrs { y: &2, x: &1 } with { .y = &3, .x = &4 } } +fn retained() -> Ptrs { let p = Ptrs { x: &1, y: &2 }; p with { .x = &3 } } +fn explicit_load() -> Field { let p = &origin; ((*p) with { .x = 8 }).x } +fn once() -> [Field; 2] { [*&1, *&2] with { [0] = *&3 } } +fn skip_base() -> Point { (return origin) with { .x = 1 / 0 } } +fn skip_replacement() -> Field { + let p = Ptrs { x: &1, y: &2 } with { .x = return 7, .y = &3 }; *p.x +} +fn later_exit() -> Field { + let p = Ptrs { x: &1, y: &2 } with { .x = &3, .y = return 8 }; *p.y +} +fn block() -> Point { 'done: { origin with { .x = break 'done point(), .y = 1 / 0 } } } +fn shadow() -> Field { + let x = 9; let p = origin with { .x = { let x = 7; x }, .y = x }; p.x * 10 + p.y +} +fn choice(x: Field) -> Point { + origin with { .x = match x { 0 => 8, _ => 9 } } +} +fn optional() -> Box> { + Box { value: Option::None } with { .value = Option::Some(4) } +} +fn hinted() -> [Field; 2] { hint::<[Field; 2]>(*&1) with { [1] = hint::(\"field\", *&2) } } +fn unchanged_hint() -> [Field; 2] { hint::<[Field; 2]>(()) with { [0] = 3, [1] = 4 } } +" + +#guard (source.findFunction? "point").any fun f => match f.body with + | .update [[.member y], [.member x]] [.global "origin" _, .literal 8, .literal 7] => y.name == "y" && x.name == "x" + | _ => false +#guard (source.toField Rat).findFunction? "point" |>.any fun f => match f.body with + | .update _ _ => true | _ => false + +def point (x y : Rat) : SourceValue Rat := .construct "Point" Generic.structConstructor [.field x, .field y] +def ptrs (x y : Nat) : SourceValue Rat := .construct "Ptrs" Generic.structConstructor [.ptr .field x, .ptr .field y] +abbrev Result := Except String (SourceValue Rat × Heap Rat) +def checks : List (String × List (SourceValue Rat) × Result) := [ + ("point", [], .ok (point 7 8, [])), + ("tuple", [], .ok (.tuple [1, .tuple [9, 3]], [])), + ("array", [], .ok (.tuple [8, 2, 9], [])), + ("nested", [], .ok (.construct "State" Generic.structConstructor + [point 9 2, .tuple [.tuple [3, 4], .tuple [8, 6]]], [])), + ("siblings", [], .ok (point 4 5, [])), + ("inferred", [], .ok (8, [])), ("explicit", [], .ok (6, [])), ("generics", [], .ok (5, [])), + ("alias_use", [], .ok (point 3 2, [])), ("immutable", [], .ok (19, [])), + ("swap", [], .ok (point 2 1, [])), ("chain", [], .ok (point 4 2, [])), + ("projection", [], .ok (7, [])), ("empty", [], .ok (.construct "Empty" Generic.structConstructor [], [])), + ("empty_array", [], .ok (.tuple [], [])), ("no_changes", [], .ok (6, [])), + ("pointers", [], .ok (ptrs 3 2, [2, 1, 3, 4])), + ("retained", [], .ok (ptrs 2 1, [1, 2, 3])), + ("explicit_load", [], .ok (8, [point 1 2])), + ("once", [], .ok (.tuple [3, 2], [1, 2, 3])), + ("skip_base", [], .ok (point 1 2, [])), + ("skip_replacement", [], .ok (7, [1, 2])), + ("later_exit", [], .ok (8, [1, 2, 3])), + ("block", [], .ok (point 7 8, [])), ("shadow", [], .ok (79, [])), + ("choice", [0], .ok (point 8 2, [])), ("choice", [1], .ok (point 9 2, [])), + ("optional", [], .ok (.construct (Generic.Instance.mk "Box" [.named "Option" [.field]]).symbol + Generic.structConstructor [.construct (Generic.Instance.mk "Option" [.field]).symbol "Some" [4]], [])) +] + +def checkExecutions : Except String Unit := do + let s ← Generic.prepare (source.toField Rat) + for (name, args, expected) in checks do + let q ← Generic.specialize s [name] + for (mode, actual) in [("source", s.run name args), ("specialized", q.run name args), + ("core", q.coreRun name args)] do + if actual != expected then throw s!"{name} ({mode}): expected {repr expected}, got {repr actual}" + let _ ← q.compile + let q ← Generic.specialize s ["hinted", "unchanged_hint"] + let _ ← q.compile + let provider := fun (channel : String) (_ : Constant Rat) => + (Except.ok (if channel == "field" then (9 : Constant Rat) else .tuple [3, 4]) : Except HintError (Constant Rat)) + if s.run "hinted" [] 256 (s.checkedHints provider) != .ok (.tuple [3, 9], [1, 2]) then throw "source update hints" + if q.coreRun "hinted" [] 256 (HintProvider.checked q.program.enums provider) != .ok (.tuple [3, 9], [1, 2]) then + throw "core update hints" + -- Overwriting every component still evaluates the base hint. + if (s.run "unchanged_hint" []).isOk || (q.coreRun "unchanged_hint" []).isOk then throw "base hint skipped" + +#guard checkExecutions == .ok () + +run_cmd do + let env ← Lean.getEnv + for code in [ + "fn f() -> [Field; 2] { [1, 2] with { [2] = 9 } }", + "fn f(i: Field) -> [Field; 2] { [1, 2] with { [i] = 9 } }", + "fn f() -> [Field; 2] { [1, 2] with { [0] = (), } }", + "fn f() -> [Field; 2] { [1, 2] with { [0] = 3, [0] = 4 } }", + "fn f() -> ([Field; 2],) { ([1, 2],) with { .0 = [3, 4], .0[0] = 5 } }", + "fn f() -> ([Field; 2],) { ([1, 2],) with { .0[0] = 5, .0 = [3, 4] } }", + "fn f() -> (Field,) { (1,) with { .1 = 3 } }", + "fn f() -> (Field,) { (1,) with { [0] = 3 } }", + "fn f() -> [Field; 1] { [1] with { .0 = 3 } }", + "fn f() -> [Field; 2] { [1, 2] with { [0..1] = [3] } }", + "struct P { x: Field } fn f(p: P) -> P { p with { .y = 2 } }", + "struct P { x: Field } fn f(p: P) -> P { p with { .x = 2, .x = 3 } }", + "struct P { x: Field } fn f(p: &P) -> &P { p with { .x = 2 } }", + "struct P { x: Field } struct S { p: &P } fn f(s: S) -> S { s with { .p.x = 2 } }", + "enum E { X(Field) } fn f(e: E) -> E { e with { .0 = 2 } }", + "struct A { x: Field } struct B { x: Field } struct S { a: A } fn f(s: S) -> S { s with { .a = B { x: 1 } } }", + "fn f(x: T) -> T { x with { .0 = 1 } }", + "fn f() -> [Field; 0] { [] with { [0] = 1 } }" + ] do + match Generic.Frontend.ofString env code with + | .error _ => pure () + | .ok _ => throwError "unexpectedly accepted: {code}" + +instance : Fact (Nat.Prime 2) := ⟨by decide⟩ +-- The static index 2 remains 2 even over a field where the literal 2 is zero. +def smallField : Generic.Program Nat := aiur% "fn f() -> [Field; 3] { [0; 3] with { [2] = 1 } }" +#guard (do + let s ← Generic.prepare (smallField.toField (ZMod 2)) + let q ← Generic.specialize s ["f"] + let _ ← q.compile + q.coreRun "f" []) == .ok (.tuple [0, 0, 1], []) + +def rowSource : Generic.Program Nat := aiur% " +fn edit(a: [Field; 3]) -> [Field; 3] { a with { [1] = a[0] + 7 } } +" + +def checkRows : Except String Unit := do + let s ← Generic.prepare (rowSource.toField Rat) + let q ← Generic.specialize s ["edit"] + let c ← q.compile + let some chip := c.system.findChip? "edit" | throw "missing update chip" + if chip.numVars != 6 then throw "static array update introduced auxiliary columns" + let type : Aiur.Ty := .tuple [.field, .field, .field] + let input : WireValue Rat := ⟨type, [2, 3, 4]⟩ + let output : WireValue Rat := ⟨type, [2, 9, 4]⟩ + let row : Circuit.Row Rat := ⟨"edit", [2, 3, 4, 2, 9, 4]⟩ + c.check {} ⟨"edit", [input], output⟩ [row] + c.checkMemo {} ⟨"edit", [input], output⟩ [⟨row, 1⟩] + -- Equations enforce both preservation and replacement, for both checkers. + for (index, words) in [(3, [8, 9, 4]), (4, [2, 8, 4])] do + let wrong : WireValue Rat := ⟨type, words⟩ + let bad : Circuit.Row Rat := ⟨"edit", row.values.set index 8⟩ + if (c.check {} ⟨"edit", [input], wrong⟩ [bad]).isOk then throw "wrong array update accepted" + if (c.checkMemo {} ⟨"edit", [input], wrong⟩ [⟨bad, 1⟩]).isOk then throw "wrong memoized array update accepted" + +#guard checkRows == .ok () + +/-- info: 'Aiur.Generic.UpdateLowering.expression_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms Generic.UpdateLowering.expression_iff + +def run : IO Unit := do + match checkExecutions *> checkRows with + | .ok () => IO.println s!"Passed {3 * checks.length} update execution checks and {checks.length} compilations." + | .error e => throw (IO.userError e) + +end AiurUpdateTests diff --git a/Aiur/AiurTests/WidthROM.lean b/Aiur/AiurTests/WidthROM.lean new file mode 100644 index 000000000..201bcc518 --- /dev/null +++ b/Aiur/AiurTests/WidthROM.lean @@ -0,0 +1,55 @@ +import Aiur.Memory.WidthCorrectness +import Aiur.Memory.WireProvenance +import Mathlib.Algebra.Field.Rat + +namespace AiurWidthROMTests +open Aiur + +private def raw : WidthROM Rat := ⟨[(0, [7]), (0, [7, 8])]⟩ +private def types : List Ty := [.field, .tuple [.field], .tuple [.field, .field]] +private def views : WireROM Rat := raw.toWireROM [] types + +-- Widths can reuse the same numeric address, and equal-width types can share +-- identical physical words. Neither operation changes the canonical value. +example : raw.Valid := by unfold WidthROM.Valid raw; decide +kernel +example : views.Valid := raw.toWireROM_valid (by unfold WidthROM.Valid raw; decide +kernel) [] types +example : (0, WireValue.field 7) ∈ views.entries := by + unfold views + rw [WidthROM.mem_toWireROM] + simp only [raw, types, List.mem_cons, List.not_mem_nil] + decide +kernel +example : (0, WireValue.mk (.tuple [.field]) [7]) ∈ views.entries := by + unfold views + rw [WidthROM.mem_toWireROM] + simp only [raw, types, List.mem_cons, List.not_mem_nil] + decide +kernel +example : (0, WireValue.mk (.tuple [.field, .field]) [7, 8]) ∈ views.entries := by + unfold views + rw [WidthROM.mem_toWireROM] + simp only [raw, types, List.mem_cons, List.not_mem_nil] + decide +kernel +example : (0, WireValue.mk (.tuple [.field, .field]) [7]) ∉ views.entries := by + unfold views + rw [WidthROM.mem_toWireROM] + simp only [raw, types, List.mem_cons, List.not_mem_nil] + decide +kernel + +-- Different words at the same address and width cannot pass the raw model. +example : ¬(WidthROM.mk [(0, [7]), (0, [8])] : WidthROM Rat).Valid := by unfold WidthROM.Valid; decide +kernel + +-- Unrelated invalid interpretations are permitted. The load theorem derives +-- canonicality from the typed store, rather than validating every raw view. +private def flag : EnumDecl := ⟨"Flag", [⟨"Off", []⟩, ⟨"On", []⟩]⟩ +private def flagViews : WireROM Rat := + (WidthROM.mk [(0, [7])]).toWireROM [flag] [.field, .enum "Flag"] +example : flagViews.Valid := (WidthROM.mk [(0, [7])]).toWireROM_valid (by unfold WidthROM.Valid; decide +kernel) [flag] _ +example : (WireValue.mk (.enum "Flag") ([7] : List Rat)).decode [flag] = none := by decide +kernel +example : (0, Value.field 7) ∈ (flagViews.decode [flag]).entries := by + apply WireROM.mem_decode.mpr + refine ⟨WireValue.field 7, ?_, by decide +kernel⟩ + unfold flagViews + rw [WidthROM.mem_toWireROM] + simp only [List.mem_cons, List.not_mem_nil] + decide +kernel + +end AiurWidthROMTests diff --git a/Aiur/Examples/Aliases.lean b/Aiur/Examples/Aliases.lean new file mode 100644 index 000000000..8eea0e1c1 --- /dev/null +++ b/Aiur/Examples/Aliases.lean @@ -0,0 +1,37 @@ +import Aiur +import Mathlib.Algebra.Field.Rat + +open Aiur + +def aliasedSource : Generic.Program Nat := aiur% " +type Scalar = Field; +type Pair = (T, T); +type Maybe = Option; +enum Option { None, Some(T) } + +fn duplicate(x: T) -> Pair { (x, x) } +fn main(x: Scalar) -> Scalar { + match Maybe::Some(duplicate(x)) { + Maybe::Some(pair) => pair.0, + Maybe::None => 0, + } +} +" + +-- Alias declarations remain in the source; literals still use Nat. +#guard aliasedSource.aliases.length == 3 + +#eval do + let source ← Generic.prepare (aliasedSource.toField Rat) + source.run "main" [.field 42] + +#eval do + let source ← Generic.prepare (aliasedSource.toField Rat) + let specialized ← Generic.specialize source ["main"] + specialized.run "main" [.field 42] + +#eval do + let source ← Generic.prepare (aliasedSource.toField Rat) + let specialized ← Generic.specialize source ["main"] + let circuit ← specialized.compile + return circuit.system.chips.length diff --git a/Aiur/Examples/Arrays.lean b/Aiur/Examples/Arrays.lean new file mode 100644 index 000000000..79ad2d4ef --- /dev/null +++ b/Aiur/Examples/Arrays.lean @@ -0,0 +1,34 @@ +import Aiur +import Mathlib.Algebra.Field.Rat + +open Aiur + +def arrays : Generic.Program Nat := aiur% " +type Block = [Field; 4]; +const zeros = [0; 4]; +const cell = &[0]; + +fn duplicate(x: T) -> [T; 2] { [x; 2] } +fn middle(a: Block) -> [Field; 2] { a[1..3] } +fn main(x: Field) -> [Field; 2] { + let [a, b] = middle([0, x, 7, 0]); + let ::zeros = [0, 0, 0, 0]; + let ::cell = cell; + let copied = duplicate(a); + [copied[0] + b, copied[1]] +} +" + +#eval do + let source ← Generic.prepare (arrays.toField Rat) + source.run "main" [5] + +#eval do + let source ← Generic.prepare (arrays.toField Rat) + let program ← Generic.specialize source ["main"] + program.run "main" [5] + +#eval do + let source ← Generic.prepare (arrays.toField Rat) + let program ← Generic.specialize source ["main"] + return (← program.compile).system.chips.length diff --git a/Aiur/Examples/Blake3.lean b/Aiur/Examples/Blake3.lean new file mode 100644 index 000000000..dcc129a91 --- /dev/null +++ b/Aiur/Examples/Blake3.lean @@ -0,0 +1,92 @@ +import AiurTests.Blake3 +import AiurTests.U8 +import Mathlib.Algebra.Field.Rat + +/-! Circuit statistics for the same Blake3, word, and byte modules used by IxVM. -/ +namespace Blake3Example +open Aiur + +set_option maxRecDepth 100000 +set_option maxHeartbeats 80000000 + +def source : Modules.Program Nat := Library.Blake3.source.append AiurBlake3Tests.benchmark + +private def get {α : Type} : Except String α → IO α := IO.ofExcept +private def ensure (message : String) (condition : Bool) : Except String Unit := + if condition then .ok () else .error message + +structure Totals where + chips : Nat + columns : Nat + degree : Nat + calls : Nat + rom : Nat + lookupDegree : Nat + deriving Repr, BEq + +def totals (system : Circuit.System F) : Totals := + system.stats.foldl (fun acc s => { + chips := acc.chips + 1 + columns := acc.columns + s.columns + degree := max acc.degree s.maxConstraintDegree + calls := acc.calls + s.callLookups + rom := acc.rom + s.romLookups + lookupDegree := max acc.lookupDegree s.maxLookupDegree + }) ⟨0, 0, 0, 0, 0, 0⟩ + +def report : IO Unit := do + AiurU8Tests.run + IO.println "Preparing the Blake3 example and generated U8 tables..." + let prepared ← get <| Modules.prepare (source.toField Rat) ["Benchmark::main"] + -- Both compilers use this exact same specialization and inline configuration. + let specialized ← get <| Generic.specialize prepared.environment.source prepared.entries + IO.println "Compiling the reference circuit..." + let reference ← get specialized.compile + IO.println "Compiling the optimized circuit (degree cap 3)..." + let optimized ← get specialized.compileOptimized + get <| ensure "compilers received different programs" (reference.program == optimized.inlined.program) + get <| ensure "precommitted data changed" (reference.system.tables == optimized.system.tables && + reference.system.maps == optimized.system.maps) + -- Every original chip remains explainable, including under deduplication. + for chip in reference.system.chips do + let representative := ((optimized.artifact.representatives.find? (·.1 == chip.name)).map Prod.snd).getD chip.name + let some other := optimized.system.findChip? representative | + throw (IO.userError s!"missing optimized chip for {chip.name}") + get <| ensure s!"lookup merging added slots in {chip.name}" + (other.sends.length ≤ chip.sends.length && other.memory.length ≤ chip.memory.length) + IO.println "\nReference chips:" + reference.system.printStats + IO.println "\nOptimized chips:" + optimized.system.printStats + IO.println "\nTotals (sum of static chip widths and lookup slots, not execution cost):" + let before := totals reference.system + let after := totals optimized.system + IO.println "| Metric | Reference | Optimized |" + IO.println "| --- | ---: | ---: |" + for (label, a, b) in [ + ("Chips", before.chips, after.chips), + ("Sum of chip columns", before.columns, after.columns), + ("Maximum constraint degree", before.degree, after.degree), + ("Call/map lookup slots", before.calls, after.calls), + ("ROM lookup slots", before.rom, after.rom), + ("Maximum lookup expression degree", before.lookupDegree, after.lookupDegree)] do + IO.println s!"| {label} | {a} | {b} |" + IO.println "\nShared precommitted tables (separate from chip columns):" + let mut tableRows := 0 + let mut tableCells := 0 + for table in optimized.system.tables do + let layout ← get <| (optimized.system.enums.layout table.rowType).mapError reprStr + IO.println s!"{table.name}: rows={table.rows.length}, width={layout.width}" + tableRows := tableRows + table.rows.length + tableCells := tableCells + table.rows.length * layout.width + IO.println s!"Shared table totals: {tableRows} rows, {tableCells} field cells" + IO.println s!"Static maps: {optimized.system.maps.length}" + let merged := optimized.artifact.representatives.filter (fun (name, representative) => name != representative) + IO.println s!"Merged internal chips: {repr merged}" + IO.println "\nEntrypoint: Benchmark::main generates 1,025 bytes, then hashes them." + IO.println "This report compiles the program; it does not execute Blake3 or construct witnesses." + IO.println "Entrypoint soundness/completeness, degree bounds, and deduplication are proved; memoized soundness assumes acyclicity." + +end Blake3Example + +def main : IO Unit := Blake3Example.report diff --git a/Aiur/Examples/Circuit.lean b/Aiur/Examples/Circuit.lean new file mode 100644 index 000000000..71088f7b2 --- /dev/null +++ b/Aiur/Examples/Circuit.lean @@ -0,0 +1,30 @@ +import Aiur.Scalar +import Mathlib.Algebra.Field.Rat + +open Aiur.Scalar Aiur.Scalar.Circuit + +def source : Program Nat := scalar_aiur% " +fn square(x) { x * x } +fn main(x, y) { square(x / y) } +" + +-- Each function becomes one chip; division and calls introduce fresh variables. +def chips : Except CompileError (System Rat) := compile (source.toField Rat) + +-- These are simultaneous assignments, not execution steps. +-- main: v0 = x, v1 = y, v2 = output, v3 = inverse(y), v4 = square's result. +-- square: v0 = x, v1 = output. +def witness : List (Row Rat) := [ + ⟨"main", [6, 2, 9, 1 / 2, 9]⟩, + ⟨"square", [3, 9]⟩ +] + +def checkExample : Except String Unit := do + let system ← chips.mapError toString + (system.check ⟨"main", [6, 2], 9⟩ witness).mapError reprStr + +#eval checkExample +-- Except.ok () + +#eval Aiur.Scalar.eval (source.toField Rat) "main" [6, 2] +-- Except.ok 9 diff --git a/Aiur/Examples/CircuitStats.lean b/Aiur/Examples/CircuitStats.lean new file mode 100644 index 000000000..495de0281 --- /dev/null +++ b/Aiur/Examples/CircuitStats.lean @@ -0,0 +1,32 @@ +import Aiur.Modules +import Mathlib.Algebra.Field.Rat + +open Aiur + +namespace CircuitStatsExample + +def source : Modules.Program Nat := aiur% " +module Arithmetic { + fn square(x: Field) -> Field { x * x } + fn main(x: Field) -> Field { + let p = &x; + match *p { 0 => 0, _ => square(x * x * x) } + } +} +" + +def circuit : Except String (Circuit.System Rat) := do + let p ← Modules.prepare (source.toField Rat) ["Arithmetic::main"] + let compiled ← p.compile + return compiled.circuit.system + +-- Reports the actual chips after specialization and mandatory inlining. +#eval show IO Unit from do + match circuit with + | .error message => throw (IO.userError message) + | .ok system => system.printStats + +-- Structured measurements are available without printing or witness rows. +#eval circuit.map (fun system => system.stats.map (fun stats => (stats.name, stats.columns))) + +end CircuitStatsExample diff --git a/Aiur/Examples/Consts.lean b/Aiur/Examples/Consts.lean new file mode 100644 index 000000000..97b026e62 --- /dev/null +++ b/Aiur/Examples/Consts.lean @@ -0,0 +1,45 @@ +import Aiur +import Mathlib.Algebra.Field.Rat + +open Aiur + +def constSource : Generic.Program Nat := aiur% " +const zero = 0; +const cell = &(zero,); +const again = cell; + +fn classify(p: &(Field,)) -> Field { + match p { + ::cell => 1, + _ => 0, + } +} + +fn main(zero: Field) -> Field { + // A local wins over a global in value position. + let saved = zero; + // `again` allocates here; `::cell` below loads and checks its contents. + let p = again; + let ::cell = p; + saved + ::zero + classify(p) +} +" + +-- Const declarations and references remain through source evaluation. +#guard constSource.consts.length == 3 + +#eval do + let source ← Generic.prepare (constSource.toField Rat) + source.run "main" [.field 10] +-- .ok (.field 11, [.tuple [.field 0]]) + +#eval do + let source ← Generic.prepare (constSource.toField Rat) + let specialized ← Generic.specialize source ["main"] + specialized.run "main" [.field 10] + +#eval do + let source ← Generic.prepare (constSource.toField Rat) + let specialized ← Generic.specialize source ["main"] + return (← specialized.compile).system.chips.length +-- .ok 2: main and classify diff --git a/Aiur/Examples/Control.lean b/Aiur/Examples/Control.lean new file mode 100644 index 000000000..da4c6cf47 --- /dev/null +++ b/Aiur/Examples/Control.lean @@ -0,0 +1,37 @@ +import Aiur +import Mathlib.Algebra.Field.Rat + +open Aiur + +-- Labels are lexical; return always targets the current function. +def source : Generic.Program Nat := aiur% " +fn choose(x: Field) -> Field { + let y = 'selected: { + match x { + 0 => break 'selected 7, + 1 => return 20, + _ => (), + }; + 9 + }; + y + 1 +} +" + +#eval do + let s ← Generic.prepare (source.toField Rat) + [0, 1, 2].mapM fun x => s.run "choose" [x] +-- Except.ok [(8, []), (20, []), (10, [])], with field-valued results. + +#eval do + let s ← Generic.prepare (source.toField Rat) + let q ← Generic.specialize s ["choose"] + let _ ← q.compile + [0, 1, 2].mapM fun x => q.coreRun "choose" [x] +-- The same values and heaps after control lowering and circuit compilation. + +#check Generic.ControlLower.function_correct +#check Generic.Specialized.native_entry_iff +#check Generic.Specialized.checker_heap_complete +#check Generic.Specialized.checker_heap_sound +#check Generic.Specialized.checkerMemo_acyclic_heap_sound diff --git a/Aiur/Examples/Diagnostics.lean b/Aiur/Examples/Diagnostics.lean new file mode 100644 index 000000000..a111badb4 --- /dev/null +++ b/Aiur/Examples/Diagnostics.lean @@ -0,0 +1,21 @@ +import Aiur.Generic +import Mathlib.Algebra.Field.Rat + +open Aiur + +def diagnostics : Generic.Program Nat := aiur% " +fn double(x: Field) -> Field { + debug!(\"doubling\", x); + x * 2 +} +fn main() -> Field { + let values: [Field; 2] = [3, 4]; + debug!(\"inputs\", values); + assert_eq!(values, [3, 4], \"unexpected inputs\"); + (double(values[0]): Field) +} +" + +#eval do + let s ← Generic.prepare (diagnostics.toField Rat) + return s.runTraced "main" [] diff --git a/Aiur/Examples/Enums.lean b/Aiur/Examples/Enums.lean new file mode 100644 index 000000000..f5df138dc --- /dev/null +++ b/Aiur/Examples/Enums.lean @@ -0,0 +1,48 @@ +import Aiur +import Mathlib.Algebra.Field.Rat + +open Aiur + +set_option maxRecDepth 10000 +set_option maxHeartbeats 1000000 + +def enums : Program Nat := aiur% r#" +enum List { Nil, Cons(Field, &List) } +enum Item { Empty, Scalar(Field), Pair(Field, Field) } + +fn sum(xs: List) -> Field { + match xs { + List::Nil => 0, + List::Cons(x, tail) => x + sum(*tail), + } +} + +fn inspect(item: Item) -> Field { + let value = match item { + Item::Empty => 0, + Item::Scalar(0) => 1, + Item::Scalar(x) => x, + Item::Pair(x, y) => x + y, + }; + value + 1 +} + +fn main(x: Field, y: Field) -> Field { + let rest = List::Cons(y, &List::Nil); + inspect(Item::Scalar(sum(List::Cons(x, &rest)))) +} +"# + +#eval eval (enums.toField Rat) "main" [7, 8] +#eval run (enums.toField Rat) "main" [7, 8] + +example : eval (enums.toField Rat) "main" [7, 8] 64 = .ok 16 := by decide +kernel + +example : EvalCall (enums.toField Rat) "main" [7, 8] 16 := + eval_spec (hints := HintProvider.unavailable) (fuel := 64) (by decide +kernel) + +#eval (Circuit.compile (enums.toField Rat)).isOk +-- true + +#eval (Value.construct "List" "Nil" [] : Value Rat).encode enums.enums +-- some { type := .enum "List", words := [0, 0, 0] } diff --git a/Aiur/Examples/Execution.lean b/Aiur/Examples/Execution.lean new file mode 100644 index 000000000..46449259e --- /dev/null +++ b/Aiur/Examples/Execution.lean @@ -0,0 +1,38 @@ +import Aiur.Modules.Frontend +import Aiur.Execution +import Mathlib.Algebra.Field.ZMod +import Mathlib.Tactic.NormNum.Prime + +open Aiur + +namespace ExecutionExample + +def source : Modules.Program Nat := aiur_modules% " +module Demo { + struct Result { value: Field, repeated: [Field; 2] } + fn fib(n: Field) -> Field { + match n { 0 => 0, 1 => 1, _ => fib(n - 1) + fib(n - 2) } + } + fn run(ns: [Field; 3]) -> Result { + Result { value: fib(ns[0]), repeated: [fib(ns[1]), fib(ns[2])] } + } +} +" + +instance : Fact (Nat.Prime 65537) := ⟨by norm_num⟩ + +def main : IO Unit := do + let exported ← IO.ofExcept do + let prepared ← Modules.prepare (source.toField (ZMod 65537)) ["Demo::run"] + prepared.exportExecution + -- One array argument is written structurally; Rust flattens it using the + -- selected entry's IO description and unflattens the returned struct. + let result ← IO.ofExcept (← exported.run "Demo::run" #[Lean.toJson ([20, 20, 20] : List Nat)]) + IO.println (result.pretty_output.getD "") + IO.println s!"{result.queries.size} distinct queries; {result.instructions} executed instructions" + for query in result.queries do + IO.println s!"{query.name}{query.args.toList} -> {query.output.toList}, multiplicity {query.multiplicity}" + +end ExecutionExample + +def main : IO Unit := ExecutionExample.main diff --git a/Aiur/Examples/ExecutionChecks.lean b/Aiur/Examples/ExecutionChecks.lean new file mode 100644 index 000000000..004530f72 --- /dev/null +++ b/Aiur/Examples/ExecutionChecks.lean @@ -0,0 +1,3 @@ +import AiurTests.Execution + +def main : IO Unit := AiurExecutionTests.run diff --git a/Aiur/Examples/ExecutionHints.lean b/Aiur/Examples/ExecutionHints.lean new file mode 100644 index 000000000..ba96b15b2 --- /dev/null +++ b/Aiur/Examples/ExecutionHints.lean @@ -0,0 +1,41 @@ +import Aiur.Modules.Frontend +import Aiur.Execution +import Mathlib.Algebra.Field.ZMod + +open Aiur + +namespace ExecutionHintsExample + +def source : Modules.Program Nat := aiur_modules% " +module Demo { + struct Preimage { parts: [Field; 2] } + fn recover(digest: Field) -> Preimage { + let witness = hint::(digest); + let sum = witness.parts[0] + witness.parts[1]; + assert_eq!(sum * sum, digest, \"incorrect preimage\"); + witness + } + fn run(digest: Field) -> (Preimage, Preimage) { + (recover(digest), recover(digest)) + } +} +" + +/-- Ordinary Lean data; no enum tags, padding or field offsets to calculate. -/ +def hints : Array (Execution.HintEntry (ZMod 97)) := #[ + ⟨.named "Demo::Preimage" [], 49, + .record (.named "Demo::Preimage" []) [("parts", .array .field [3,4])], ""⟩ +] + +def main : IO Unit := do + let exported ← IO.ofExcept do + let prepared ← Modules.prepare (source.toField (ZMod 97)) ["Demo::run"] + prepared.exportExecution + let result ← IO.ofExcept (← exported.runFlat "Demo::run" #[49] hints) + IO.println (result.pretty_output.getD "") + for query in result.queries do + IO.println s!"{query.name}: multiplicity {query.multiplicity}" + +end ExecutionHintsExample + +def main : IO Unit := ExecutionHintsExample.main diff --git a/Aiur/Examples/Generics.lean b/Aiur/Examples/Generics.lean new file mode 100644 index 000000000..226343eca --- /dev/null +++ b/Aiur/Examples/Generics.lean @@ -0,0 +1,45 @@ +import Aiur +import Mathlib.Algebra.Field.Rat + +open Aiur + +def genericSource : Generic.Program Nat := aiur% " +enum Option { None, Some(T) } + +fn identity(x: T) -> T { x } + +fn unwrap_or(value: Option, fallback: T) -> T { + match value { Option::Some(x) => x, Option::None => fallback } +} + +fn main(x: Field) -> Field { + let pair = identity((x, 2)); + unwrap_or(Option::Some(pair.0), 0) +} +" + +-- The interpreter calls generic bodies directly, with concrete type arguments. +#eval do + let source ← Generic.prepare (genericSource.toField Rat) + source.run "main" [.field 42] +-- Except.ok (Aiur.Value.field 42, []) + +-- Entrypoints belong to this invocation, rather than the source syntax. +#eval do + let source ← Generic.prepare (genericSource.toField Rat) + let specialized ← Generic.specialize source ["main"] + specialized.run "main" [.field 42] +-- Except.ok (Aiur.Value.field 42, []) + +#eval do + let source ← Generic.prepare (genericSource.toField Rat) + let specialized ← Generic.specialize source ["main"] + let circuit ← specialized.compile + return circuit.system.chips.length +-- Except.ok 3 + +-- The theorem works for arbitrary inputs, outputs, recursion and hint values. +example [Field F] [DecidableEq F] (source : Generic.Source F) + (specialized : Generic.Specialized source ["main"]) : + source.EvalCall "main" args output ↔ specialized.EvalCall "main" args output := + specialized.evalCall_iff (by simp) diff --git a/Aiur/Examples/Grouping.lean b/Aiur/Examples/Grouping.lean new file mode 100644 index 000000000..5d94cfa2c --- /dev/null +++ b/Aiur/Examples/Grouping.lean @@ -0,0 +1,92 @@ +import Aiur.Library.U32.Goldilocks +import Aiur.Modules.Frontend +import Aiur.Execution.Encode +import Aiur.Trace.Export + +open Aiur Lean + +def groupedExample : Modules.Program Nat := aiur_modules% " +module Grouped { + fn left(x: Field) -> Field { + match x { 0 => 9, _ => x * x * x } + } + fn right(x: Field) -> (Field, Field) { (x + 3, x * x) } + fn memory(x: Field) -> Field { let p = &(x, x + 1); let (a, b) = *p; a + b } + fn run(x: Field) -> Field { + let a = left(0); + let b = left(x); + let e = left(x + 1); + let (c, d) = right(x + 2); + a + b + c + d + memory(x) + e + } +} +" + +private def expectRejection (label : String) (result : Except String α) : IO Unit := + match result with + | .error _ => pure () + | .ok _ => throw (IO.userError s!"grouping certificate accepted {label}") + +/-- Complemented branch selectors used to lift every quadratic output into +another witness column. Select the affine factor instead, and check both the +size improvement and the full row/packet certificate. -/ +private def auditSelectedArguments : IO Unit := do + let masked := fun p : Optimized.Polynomial Library.U32.Goldilocks.F => + Optimized.Polynomial.mul (.sub (.const 1) (.var 0)) p + let source : Circuit.Chip Library.U32.Goldilocks.F := { + name := "masked_left", numVars := 3 + inputs := [.field 0, .field 1, .field 2] + output := .tuple [.field (masked (.var 1)), .field (masked (.var 2)), + .field (masked (.add (.var 1) (.var 2)))] + constraints := [.mul (.var 0) (.mul (.var 1) (.var 2))] + sends := [], memory := [] } + let sources := [source, {source with name := "masked_right"}] + let id := fun name => if name == "masked_left" then .ok 0 else .ok 1 + let baseline ← IO.ofExcept (Optimized.Grouping.compile "baseline" id sources false) + let optimized ← IO.ofExcept (Optimized.Grouping.compile "selected" id sources) + unless optimized.layout.width < baseline.layout.width && + optimized.layout.members.all (·.writes.isEmpty) do + throw (IO.userError "selected quadratic arguments still require lifted columns") + +/-- Check failures that source-constraint projection alone would miss: packet +tags, unused sends, memory words, and coverage of the original system. -/ +private def auditCertificates (system : Circuit.System Library.U32.Goldilocks.F) + (callables : List String) : IO Unit := do + let id := fun name => if callables.contains name then .ok (callables.idxOf name) + else .error s!"unknown callable {name}" + let names := ["Grouped::left", "Grouped::right", "Grouped::memory"] + let sources := system.chips.filter fun c => names.contains c.name + let checked ← IO.ofExcept (Optimized.Grouping.compile "audit" id sources) + let g := checked.layout + let certify := Optimized.Grouping.certify sources id + expectRejection "a changed channel tag" (certify + {g with receive := .const 9 :: g.receive.drop 1}) + expectRejection "an extra enabled send" (certify + {g with sends := g.sends ++ [⟨.const 1, []⟩]}) + expectRejection "an undersized physical row" (certify {g with width := 0}) + expectRejection "a changed memory address" (certify {g with sends := g.sends.map fun slot => + {slot with args := slot.args.take 2 ++ + [.add (Optimized.Grouping.word slot.args 2) (.const 1)] ++ slot.args.drop 3}}) + let packed : Optimized.Grouping.Packed _ id := ⟨sources, checked⟩ + unless !(decide (Optimized.Grouping.PlanCertificate system [] [packed])) do + throw (IO.userError "grouping certificate accepted a missing entrypoint") + +def main (args : List String) : IO Unit := do + let source := groupedExample.toField Library.U32.Goldilocks.F + let prepared ← IO.ofExcept (Modules.prepare source ["Grouped::run"]) + let exported ← IO.ofExcept prepared.exportExecution + let compiled ← IO.ofExcept prepared.compileOptimized + let program ← IO.ofExcept (exported.toJson Library.U32.Goldilocks.modulus ZMod.val) + let trace ← IO.ofExcept (Trace.exportJson Library.U32.Goldilocks.modulus ZMod.val + compiled.circuit.inlined.program compiled.circuit.artifact exported.bytecode + [("arithmetic_and_memory", ["Grouped::left", "Grouped::right", "Grouped::memory"])]) + let package := Json.mkObj [("program", program), ("trace", trace)] + let path := args.headD "/tmp/aiur-grouping.json" + if args.contains "--check" then + let previous ← IO.FS.readFile path + unless previous == package.compress ++ "\n" do throw (IO.userError "grouping fixture is stale") + auditSelectedArguments + let physical ← IO.ofExcept (Optimized.Physical.prepare compiled.circuit.artifact) + auditCertificates physical.system + (exported.bytecode.functions.map (·.name) ++ exported.bytecode.maps.map (·.name)) + else IO.FS.writeFile path (package.compress ++ "\n") diff --git a/Aiur/Examples/GroupingTune.lean b/Aiur/Examples/GroupingTune.lean new file mode 100644 index 000000000..856183bcf --- /dev/null +++ b/Aiur/Examples/GroupingTune.lean @@ -0,0 +1,65 @@ +import Aiur.Optimized.Grouping.Snapshot +import Aiur.Trace.Export +import Aiur.Library.U32.Goldilocks + +open Aiur Aiur.Optimized Lean +private abbrev F := Library.U32.Goldilocks.F +private instance : ToJson F := ⟨fun x => toJson x.val⟩ +private instance : FromJson F := ⟨fun j => (fun n : Nat => (n : F)) <$> fromJson? j⟩ + +private def ident (snapshot : Grouping.Snapshot F) (name : String) : Except String Nat := + if snapshot.callables.contains name then .ok (snapshot.callables.idxOf name) + else .error s!"unknown callable {name}" + +private def maxDegree (ps : List (Optimized.Polynomial F)) : Nat := + ps.foldl (fun n p => max n p.simplify.degree) 0 + +private def metrics (snapshot : Grouping.Snapshot F) (origin : Circuit.Chip F) + (optimize : Bool) : Except String Json := do + let chip := Activation.compile origin + let (provided, required) ← Grouping.messages (ident snapshot) chip + let args := provided ++ required.flatMap (·.args) + let privateCols ← Grouping.privateColumns chip origin.numVars (if optimize then args else []) + let select := fun p => if optimize then Grouping.selectArgument origin.numVars privateCols p + else (Grouping.gate origin.numVars privateCols p).simplify + let lifted := (args.filter fun p => (select p).degree > 2).dedup + let degree := fun ps => maxDegree (ps.map fun p => + if (select p).degree > 2 then .var 0 else select p) + let constraints := (Grouping.member chip origin.numVars privateCols).constraints + return Json.mkObj [ + ("name", toJson origin.name), ("width", toJson chip.numVars), + ("private", toJson privateCols.length), ("shared", toJson (chip.numVars - privateCols.length)), + ("lifted", toJson lifted.length), ("private_columns", toJson privateCols), + ("constraint_degree", toJson (max (maxDegree constraints) (if lifted.isEmpty then 2 else 3))), + ("lookups", toJson ((degree provided, (1 : Nat)) :: + required.map (fun s => (degree s.args, s.enable.degree))))] + +def main (args : List String) : IO Unit := do + let some (input : String) := args[0]? | throw (IO.userError "usage: grouping_tune SNAPSHOT OUTPUT [--metrics] [--baseline] [--policy POLICY]") + let some (output : String) := args[1]? | throw (IO.userError "missing output path") + let snapshot : Grouping.Snapshot F ← IO.ofExcept (fromJson? (← IO.ofExcept (Json.parse (← IO.FS.readFile input)))) + let optimize := !args.contains "--baseline" + if args.contains "--metrics" then + let chips ← IO.ofExcept (snapshot.chips.mapM fun c => metrics snapshot c optimize) + IO.FS.writeFile output (Json.mkObj [("chips", toJson chips), + ("groups", toJson snapshot.groups), ("entries", toJson snapshot.entries), + ("representatives", toJson snapshot.representatives)]).compress + return + let policy ← if args.contains "--policy" then do + let some path := args[args.idxOf "--policy" + 1]? | throw (IO.userError "missing policy path") + IO.ofExcept (fromJson? (← IO.ofExcept (Json.parse (← IO.FS.readFile path)))) + else pure snapshot.groups + let resolve := fun name => ((snapshot.representatives.find? (·.1 == name)).map Prod.snd).getD name + let mut used : List String := [] + let mut packed : List (Grouping.Packed F (ident snapshot)) := [] + for (name, names) in policy do + let names := (names.map resolve).dedup + let chips := snapshot.chips.filter fun c => + names.contains c.name && !used.contains c.name && !snapshot.entries.contains c.name + if chips.length < 2 then continue + let checked ← IO.ofExcept (Grouping.compile name (ident snapshot) chips optimize) + used := used ++ chips.map (·.name) + packed := packed ++ [⟨chips, checked⟩] + IO.eprintln s!"{name}: {chips.length} members, {checked.layout.width + 1} main columns" + let plan ← IO.ofExcept (Grouping.preparePlan {chips := snapshot.chips} (ident snapshot) packed) + IO.FS.writeFile output (toJson (plan.groups.map fun p => Trace.groupJson ZMod.val p.checked.layout)).compress diff --git a/Aiur/Examples/Hints.lean b/Aiur/Examples/Hints.lean new file mode 100644 index 000000000..50b1d5c32 --- /dev/null +++ b/Aiur/Examples/Hints.lean @@ -0,0 +1,37 @@ +import Aiur +import Mathlib.Algebra.Field.Rat + +open Aiur + +namespace AiurExamples.Hints + +/-- A small preimage example: the witness is private to the function body. -/ +def source : Program Nat := aiur% " +fn square_preimage(h: Field) -> () { + let p = hint::(\"preimage\", h); + let 0 = p * p - h; + () +} +" + +def program := source.toField Rat + +/-- The prover supplies a known preimage. The adapter checks its Aiur type. -/ +def provider : HintProvider Rat program.enums := + HintProvider.checked program.enums fun channel key => + match channel, key with + | "preimage", .field 49 => .ok (.field 7) + | _, _ => .error .unavailable + +#eval eval program "square_preimage" [49] (hints := provider) +-- Except.ok (Aiur.Value.tuple []) + +example : EvalCall program "square_preimage" [49] (.tuple []) := + eval_spec (by decide +kernel : eval program "square_preimage" [49] 16 provider = .ok (.tuple [])) + +/-- A well-typed answer still has to satisfy the program's equations. -/ +example : eval program "square_preimage" [49] 16 + (HintProvider.checked program.enums fun _ _ => .ok 8) = .error .patternMismatch := by + decide +kernel + +end AiurExamples.Hints diff --git a/Aiur/Examples/Inlining.lean b/Aiur/Examples/Inlining.lean new file mode 100644 index 000000000..5b4cb576f --- /dev/null +++ b/Aiur/Examples/Inlining.lean @@ -0,0 +1,37 @@ +import Aiur +import Mathlib.Algebra.Field.Rat + +open Aiur +namespace InlineExample + +def source : Modules.Program Nat := aiur% " +module Arithmetic { + inline fn square(x: Field) -> Field { x * x } + fn main(x: Field) -> Field { square(x) + 1 } +} +module Count { + fn count(n: Field) -> Field { match n { 0 => 0, _ => step(n) } } + inline fn step(n: Field) -> Field { count(n - 1) + 1 } +} +" + +-- Source execution still uses the original function bodies and ordinary calls. +#eval do + let p ← Modules.prepare (source.toField Rat) ["Arithmetic::main", "Count::count"] + p.run "Arithmetic::main" [3] -- 10 + +-- Only the two selected ordinary functions produce chips. Count's chip sends +-- a recursive message to itself after expanding step; square sends nothing. +#eval do + let p ← Modules.prepare (source.toField Rat) ["Arithmetic::main", "Count::count"] + let c ← p.compile + return c.circuit.system.chips.map fun (chip : Circuit.Chip Rat) => (chip.name, chip.sends.map (fun (send : Circuit.Send Rat) => send.channel)) + +-- Inline helpers cannot become protocol entrypoints. +#eval (Modules.prepare (source.toField Rat) ["Arithmetic::square"]).map (fun _ => ()) + +#print axioms Generic.Compiled.native_entry_iff +#print axioms Modules.Compiled.check_complete +#print axioms Modules.Compiled.checkMemo_acyclic_sound + +end InlineExample diff --git a/Aiur/Examples/LibraryChecks.lean b/Aiur/Examples/LibraryChecks.lean new file mode 100644 index 000000000..366297d03 --- /dev/null +++ b/Aiur/Examples/LibraryChecks.lean @@ -0,0 +1,29 @@ +import AiurTests.U8 +import AiurTests.U64 +import AiurTests.Blake3 +import AiurTests.LibraryInterfaces +import Aiur.Library.Blake3.Goldilocks +import Aiur.Execution +import Aiur.Trace.Export + +open Aiur Lean + +def main (args : List String) : IO Unit := do + AiurU8Tests.run + AiurU64Tests.run + if let some path := args.head? then + let source := Library.Blake3.Goldilocks.program + |>.append (AiurU8Tests.client.toField Library.U32.Goldilocks.F) + |>.append (AiurU64Tests.client.toField Library.U32.Goldilocks.F) + |>.append (AiurBlake3Tests.benchmark.toField Library.U32.Goldilocks.F) + |>.append (AiurLibraryInterfaces.clients.toField Library.U32.Goldilocks.F) + let prepared ← IO.ofExcept <| Modules.prepare source + (AiurU8Tests.entries ++ AiurU64Tests.entries ++ + ["Benchmark::hash", "InterfaceBytes::run", "InterfaceWords::run"]) + let exported ← IO.ofExcept prepared.exportExecution + let compiled ← IO.ofExcept prepared.compileOptimized + let program ← IO.ofExcept <| exported.toJson Library.U32.Goldilocks.modulus ZMod.val + let trace ← IO.ofExcept <| Trace.exportJson Library.U32.Goldilocks.modulus ZMod.val + compiled.circuit.inlined.program compiled.circuit.artifact exported.bytecode + IO.FS.writeFile path (Json.mkObj [("program", program), ("trace", trace)]).compress + IO.println s!"Exported shared byte, U64 and Blake3 regression program to {path}." diff --git a/Aiur/Examples/Modules.lean b/Aiur/Examples/Modules.lean new file mode 100644 index 000000000..7bdbd7934 --- /dev/null +++ b/Aiur/Examples/Modules.lean @@ -0,0 +1,41 @@ +import Aiur.Modules +import Mathlib.Algebra.Field.Rat + +open Aiur + +def modular : Modules.Program Nat := aiur_modules% " +signature Accumulator { + type State; + const EMPTY: State; + fn push(state: State, coefficient: Field) -> State; + fn finish(state: State) -> Field; +} + +module PairAccumulator: Accumulator { + struct State { total: Field, count: Field } + const EMPTY = State { total: 0, count: 0 }; + fn push(state: State, coefficient: Field) -> State { + state with { .total = state.total + coefficient, .count = state.count + 1 } + } + fn finish(state: State) -> Field { state.total } +} + +module Algorithm { + fn sum(a: Field, b: Field) -> Field { + A::finish(A::push(A::push(A::EMPTY, a), b)) + } +} + +module App = Algorithm::; +" + +#eval do + let p ← Modules.prepare (modular.toField Rat) ["App::sum"] + p.run "App::sum" [.field 7, .field 9] + +-- Entrypoints belong to the host configuration. Both names select one instance. +#eval do + let p ← Modules.prepare (modular.toField Rat) + ["App::sum", "Algorithm::::sum"] + let c ← p.compile + return c.specialized.program.functions.map (fun (f : Function Rat) => f.name) diff --git a/Aiur/Examples/Opacity.lean b/Aiur/Examples/Opacity.lean new file mode 100644 index 000000000..3e54415a9 --- /dev/null +++ b/Aiur/Examples/Opacity.lean @@ -0,0 +1,40 @@ +import Aiur.Modules +import Mathlib.Algebra.Field.Rat + +open Aiur +namespace OpacityExample + +def source : Modules.Program Nat := aiur% " +signature BitOperations { + opaque type Bit; + fn raw_xor(a: Field, b: Field) -> Bit; + fn read(x: Bit) -> Field; +} + +module Bits: BitOperations { + opaque type Bit = Field; + table inputs: (Field, Field) { (0, 0), (0, 1), (1, 0), (1, 1) } + table outputs: Bit { 0, 1, 1, 0 } + map raw_xor(a: Field, b: Field) -> Bit = inputs => outputs; + inline fn read(x: Bit) -> Field { x } +} + +module Xor { + fn main(a: Field, b: Field) -> Field { B::read(B::raw_xor(a, b)) } +} +module App = Xor::; +" + +-- The caller supplies fields; the table creates the opaque result. +#eval do + let p ← Modules.prepare (source.toField Rat) ["App::main"] + p.run "App::main" [1, 0] + +-- Opaque aliases use their representation layout: three columns, one lookup. +#eval do + let p ← Modules.prepare (source.toField Rat) ["App::main"] + let compiled ← p.compileOptimized + return compiled.circuit.system.stats.map + (fun (s : Circuit.ChipStats) => (s.columns, s.lookups)) + +end OpacityExample diff --git a/Aiur/Examples/Optimized.lean b/Aiur/Examples/Optimized.lean new file mode 100644 index 000000000..9956c571f --- /dev/null +++ b/Aiur/Examples/Optimized.lean @@ -0,0 +1,42 @@ +import Aiur.Modules +import Mathlib.Algebra.Field.Rat + +open Aiur +namespace OptimizedExample + +def source : Modules.Program Nat := aiur% " +module Arithmetic { + fn left(x: Field) -> Field { match x { 0 => 0, _ => right(x - 1) + 1 } } + fn right(x: Field) -> Field { match x { 0 => 0, _ => left(x - 1) + 2 } } + fn copy_left(x: Field) -> Field { match x { 0 => 0, _ => copy_right(x - 1) + 1 } } + fn copy_right(x: Field) -> Field { match x { 0 => 0, _ => copy_left(x - 1) + 2 } } + fn main(x: Field) -> (Field, Field) { (left(x), copy_left(x)) } + fn branch(x: Field, y: Field, z: Field) -> Field { + match x { 0 => y * y * y * y / z, _ => z * z * z * z / y } + } +} +" + +#eval show IO Unit from do + let result : Except String _ := do + let prepared ← Modules.prepare (source.toField Rat) ["Arithmetic::main", "Arithmetic::branch"] + let reference ← prepared.compile + let optimized ← prepared.compileOptimized + return (reference.circuit.system, optimized.circuit.artifact) + match result with + | .error message => throw (IO.userError message) + | .ok (reference, optimized) => + IO.println s!"Reference: {reference.chips.length} chips" + reference.printStats + IO.println s!"Optimized: {optimized.system.chips.length} chips" + optimized.system.printStats + IO.println s!"Representatives: {repr optimized.representatives}" + +-- Every successful artifact carries a proof of its reported degree bounds. +example (artifact : Optimized.Artifact Rat) (chip : Circuit.Chip Rat) + (member : chip ∈ artifact.system.chips) : + chip.stats.maxConstraintDegree ≤ artifact.config.maxDegree := + (artifact.degreeBound chip member).1 + +-- The alternative source soundness/completeness theorem is not yet supplied. +end OptimizedExample diff --git a/Aiur/Examples/OrPatterns.lean b/Aiur/Examples/OrPatterns.lean new file mode 100644 index 000000000..ec473c34a --- /dev/null +++ b/Aiur/Examples/OrPatterns.lean @@ -0,0 +1,20 @@ +import Aiur.Generic +import Mathlib.Algebra.Field.Rat + +open Aiur + +def alternatives : Generic.Program Nat := aiur% " +enum Pair { Forward(Field, Field), Reversed(Field, Field) } + +fn sum(value: Pair) -> Field { + let Pair::Forward(x, y) | Pair::Reversed(y, x) = value; + let 0 | 1 = x; + x + y +} + +fn main() -> Field { sum(Pair::Reversed(7, 1)) } +" + +#eval do + let source ← Generic.prepare (alternatives.toField Rat) + source.run "main" [] diff --git a/Aiur/Examples/PointerPatterns.lean b/Aiur/Examples/PointerPatterns.lean new file mode 100644 index 000000000..3d789d5c9 --- /dev/null +++ b/Aiur/Examples/PointerPatterns.lean @@ -0,0 +1,41 @@ +import Aiur +import Mathlib.Algebra.Field.Rat + +open Aiur + +def pointerPatterns : Generic.Program Nat := aiur% " +enum List { Nil, Cons(T, &List) } + +fn read(&value: &T) -> T { value } + +fn sum(xs: &List) -> Field { + match xs { + &List::Nil => 0, + &List::Cons(head, tail) => head + sum(tail), + } +} + +fn main(x: Field) -> Field { + let &a = &x; + let (&b, c) = (&(a + 1), 2); + sum(&List::Cons(read(&b), &List::Cons(c, &List::Nil))) +} +" + +#eval do + let source ← Generic.prepare (pointerPatterns.toField Rat) + return (← source.run "main" [.field 10]).1 +-- .ok (.field 13) + +#eval do + let source ← Generic.prepare (pointerPatterns.toField Rat) + let specialized ← Generic.specialize source ["main"] + return (← specialized.run "main" [.field 10]).1 +-- .ok (.field 13) + +#eval do + let source ← Generic.prepare (pointerPatterns.toField Rat) + let specialized ← Generic.specialize source ["main"] + let circuit ← specialized.compile + return circuit.system.chips.length +-- .ok 3: main, read, and sum diff --git a/Aiur/Examples/Pointers.lean b/Aiur/Examples/Pointers.lean new file mode 100644 index 000000000..137092982 --- /dev/null +++ b/Aiur/Examples/Pointers.lean @@ -0,0 +1,27 @@ +import Aiur +import Mathlib.Algebra.Field.Rat + +open Aiur + +def pointerProgram : Program Nat := aiur% " +fn read(p: &(Field, &Field)) -> Field { + let (x, q) = *p; + x + *q +} +fn main(x: Field) -> Field { + let p = &(x, &(x + 1)); + read(p) +} +" + +#eval eval (pointerProgram.toField Rat) "main" [7] +-- .ok (.field 15) + +#eval run (pointerProgram.toField Rat) "main" [7] +-- Also returns the two allocated cells. Source locations are 0 and 1. + +example : EvalCall (pointerProgram.toField Rat) "main" [7] 15 := + eval_spec (hints := HintProvider.unavailable) (fuel := 20) (by decide +kernel) + +#eval (Circuit.compile (pointerProgram.toField Rat)).isOk +-- true: both stores and loads produce guarded ROM requirements. diff --git a/Aiur/Examples/RefutableLets.lean b/Aiur/Examples/RefutableLets.lean new file mode 100644 index 000000000..ef44c2aa5 --- /dev/null +++ b/Aiur/Examples/RefutableLets.lean @@ -0,0 +1,21 @@ +import Aiur +import Mathlib.Algebra.Field.Rat + +open Aiur + +def source : Program Nat := aiur% " +enum Reply { Missing, Found((Field, Field)) } +fn read(reply: Reply) -> Field { + let Reply::Found((0, value)) = reply; + value +} +" + +#eval eval (source.toField Rat) "read" [.construct "Reply" "Found" [.tuple [0, 8]]] +-- .ok 8 + +#eval eval (source.toField Rat) "read" [.construct "Reply" "Missing" []] +-- .error .patternMismatch + +#eval (Circuit.compile (source.toField Rat)).isOk +-- true diff --git a/Aiur/Examples/Semantics.lean b/Aiur/Examples/Semantics.lean new file mode 100644 index 000000000..b33da4e29 --- /dev/null +++ b/Aiur/Examples/Semantics.lean @@ -0,0 +1,54 @@ +import Aiur.Scalar + +open Aiur.Scalar Aiur.Scalar.Circuit + +namespace SemanticsExample + +def source : Program Nat := scalar_aiur% "fn identity(x) { x }" + +-- A source evaluation proof needs neither fuel nor decidable equality on the field. +theorem identity_evaluates [Field F] (x : F) : + EvalCall (source.toField F) "identity" [x] x := by + refine EvalCall.intro (defn := ⟨"identity", ["x"], .var "x"⟩) ?_ rfl ?_ + · simp [Program.findFunction?, source, Program.toField, Program.map, Function.map, Expr.map] + · exact .var rfl + +def identityChip (F : Type) : Chip F := { + name := "identity", arity := 1, numVars := 2, output := 1 + constraints := [.sub (.var 1) (.var 0)] + sends := [] +} + +def system (F : Type) : System F := ⟨[identityChip F]⟩ + +theorem source_compiles [Field F] [DecidableEq F] : + compile (source.toField F) = .ok (system F) := by + have checked : typecheck (source.toField F) = .ok () := by + simp [typecheck, source, Program.toField, Program.map, Function.map, Expr.map, inferType] + rfl + simp only [compile, checked] + simp [source, Program.toField, Program.map, Function.map, Expr.map, + Compiler.lowerFunction, Compiler.lowerExpr, StateT.run, StateT.pure, + bind, pure, Except.bind, Except.pure, system, identityChip] + +-- This is a closed leaf: the equation holds and there are no call premises. +def identity_derivation [Field F] [DecidableEq F] (x : F) : + Derivation (system F) ⟨"identity", [x], x⟩ := + .node (identityChip F) ⟨"identity", [x, x]⟩ rfl + (by simp [Chip.ValidRow, identityChip, Chip.wellFormed, ArithExpr.inBounds, + Satisfies, ArithExpr.denote, Row.assignment]) .nil + +theorem identity_circuit_evaluates [Field F] [DecidableEq F] (x : F) : + CircuitEvaluates (system F) "identity" [x] x := + ⟨identity_derivation x⟩ + +-- The proved compiler theorem applies to any closed tree for the compiled system. +theorem identity_result_unique [Field F] [DecidableEq F] (x y : F) + (derives : CircuitEvaluates (system F) "identity" [x] y) : y = x := + (compiler_sound source_compiles "identity" [x] y derives).deterministic (identity_evaluates x) + +-- Flattening retains the assignment used by the proof. +example [Field F] [DecidableEq F] (x : F) : + (identity_derivation x).rows = [⟨"identity", [x, x]⟩] := rfl + +end SemanticsExample diff --git a/Aiur/Examples/Structs.lean b/Aiur/Examples/Structs.lean new file mode 100644 index 000000000..d41d2a28e --- /dev/null +++ b/Aiur/Examples/Structs.lean @@ -0,0 +1,30 @@ +import Aiur.Generic +import Mathlib.Algebra.Field.Rat + +open Aiur + +def structs : Generic.Program Nat := aiur% " +struct Point { x: Field, y: Field } +struct Box { value: T } +const origin = Point { x: 0, y: 0 }; + +fn swap(Point { x, y }: Point) -> Point { Point { y: x, x: y } } +fn unwrap(b: Box) -> T { b.value } +fn main(x: Field, y: Field) -> Field { + let p = unwrap(Box { value: swap(Point { x, y }) }); + let Point { x: first, .. } = p; + first + origin.y +} +" + +#eval do + let s ← Generic.prepare (structs.toField Rat) + s.run "main" [3, 7] +-- .ok (7, []) + +#eval do + let s ← Generic.prepare (structs.toField Rat) + let specialized ← Generic.specialize s ["main"] + let _ ← specialized.compile + specialized.coreRun "main" [3, 7] +-- .ok (7, []) diff --git a/Aiur/Examples/Tables.lean b/Aiur/Examples/Tables.lean new file mode 100644 index 000000000..1156ce8ac --- /dev/null +++ b/Aiur/Examples/Tables.lean @@ -0,0 +1,52 @@ +import Aiur.Frontend +import Aiur.Eval +import Mathlib.Algebra.Field.Rat + +open Aiur + +/-- Three maps share the same input trace. Rows are generated outside Aiur. -/ +def tableProgram : Program Nat := aiur% " +table bits: (Field, Field) { + (0, 0), (0, 1), (1, 0), (1, 1), +} +table sums: Field { 0, 1, 1, 2, } +table products: Field { 0, 0, 0, 1, } +table xors: Field { 0, 1, 1, 0, } +map bit_add(a: Field, b: Field) -> Field = bits => sums; +map bit_mul(a: Field, b: Field) -> Field = bits => products; +map bit_xor(a: Field, b: Field) -> Field = bits => xors; +fn combine(a: Field, b: Field) -> (Field, Field, Field) { + (bit_add(a, b), bit_mul(a, b), bit_xor(a, b)) +} +" + +#eval eval (tableProgram.toField Rat) "combine" [1, 1] +-- .ok (.tuple [2, 1, 0]) +#eval eval (tableProgram.toField Rat) "bit_xor" [1, 0] +-- .ok 1 +#eval eval (tableProgram.toField Rat) "bit_add" [2, 0] +-- .error (.missingMapInput "bit_add") + +/-- Generate shared inputs and two output traces directly in Lean. -/ +def generatedMaps (bound : Nat) : Program Nat := + let pairs := (List.range bound).flatMap fun a => (List.range bound).map fun b => (a, b) + { + functions := [] + tables := [ + { name := "inputs", rowType := .tuple [.field, .field] + rows := pairs.map fun (a, b) => .tuple [.field a, .field b] }, + { name := "sums", rowType := .field + rows := pairs.map fun (a, b) => .field (a + b) }, + { name := "products", rowType := .field + rows := pairs.map fun (a, b) => .field (a * b) } + ] + maps := [ + ⟨"add", [("a", .field), ("b", .field)], .field, "inputs", "sums"⟩, + ⟨"mul", [("a", .field), ("b", .field)], .field, "inputs", "products"⟩ + ] + } + +#eval eval ((generatedMaps 4).toField Rat) "add" [2, 3] +-- .ok 5 +#eval eval ((generatedMaps 4).toField Rat) "mul" [2, 3] +-- .ok 6 diff --git a/Aiur/Examples/TraceChecks.lean b/Aiur/Examples/TraceChecks.lean new file mode 100644 index 000000000..914684a00 --- /dev/null +++ b/Aiur/Examples/TraceChecks.lean @@ -0,0 +1,5 @@ +import AiurTests.Trace + +def main : IO Unit := do + AiurTraceTests.run + AiurTraceTests.runSmallField diff --git a/Aiur/Examples/Trie.lean b/Aiur/Examples/Trie.lean new file mode 100644 index 000000000..7964bd035 --- /dev/null +++ b/Aiur/Examples/Trie.lean @@ -0,0 +1,129 @@ +import Aiur.Modules.Frontend +import Aiur.Execution +import Aiur.Trace.Export +import Mathlib.Algebra.Field.ZMod +import Mathlib.NumberTheory.LucasPrimality +import Mathlib.Tactic.ReduceModChar +import Mathlib.Tactic.NormNum.Prime + +/-! A persistent binary trie benchmark. All input construction, updates and +queries execute inside Aiur. Keys are explicit little-endian bit lists. +The same source algorithm is implemented in Ix's Benchmarks/Trie.lean. -/ +namespace TrieBenchmark +open Aiur Lean + +def source : Modules.Program Nat := aiur_modules% " +module Trie { + enum Bits { End, Bit(Field, &Bits) } + enum Node { Leaf(Field), Branch(&Node, &Node, Field) } + + fn total(tree: &Node) -> Field { + match *tree { Node::Leaf(x) => x, Node::Branch(_, _, sum) => sum } + } + fn branch(left: &Node, right: &Node) -> &Node { + &Node::Branch(left, right, total(left) + total(right)) + } + fn build(depth: Field, base: Field, stride: Field, seed: Field) -> &Node { + match depth { + 0 => &Node::Leaf(seed + base * base + 3 * base), + _ => branch(build(depth - 1, base, stride * 2, seed), + build(depth - 1, base + stride, stride * 2, seed)), + } + } + fn zero_key(depth: Field) -> &Bits { + match depth { 0 => &Bits::End, _ => &Bits::Bit(0, zero_key(depth - 1)) } + } + fn increment(key: &Bits) -> &Bits { + match *key { + Bits::End => key, + Bits::Bit(bit, tail) => match bit { + 0 => &Bits::Bit(1, tail), + _ => &Bits::Bit(0, increment(tail)), + }, + } + } + fn lookup(tree: &Node, key: &Bits) -> Field { + match *tree { + Node::Leaf(value) => value, + Node::Branch(left, right, _) => { + let Bits::Bit(bit, tail) = *key; + match bit { 0 => lookup(left, tail), _ => lookup(right, tail) } + }, + } + } + fn update(tree: &Node, key: &Bits, value: Field) -> &Node { + match *tree { + Node::Leaf(_) => &Node::Leaf(value), + Node::Branch(left, right, _) => { + let Bits::Bit(bit, tail) = *key; + match bit { + 0 => branch(update(left, tail, value), right), + _ => branch(left, update(right, tail, value)), + } + }, + } + } + fn steps(remaining: Field, tree: &Node, snapshot: &Node, key: &Bits, + probe: &Bits, checkpoint: Field, value: Field, checksum: Field) -> (Field, Field) { + match remaining { + 0 => (checksum, total(tree)), + _ => { + let next = update(tree, key, value); + let next_key = increment(key); + let current = lookup(next, next_key); + let previous = lookup(snapshot, probe); + let checksum = checksum * 17 + current + previous * 3; + let value = value * 13 + 7; + match checkpoint { + 0 => steps(remaining - 1, next, next, next_key, next_key, 63, value, checksum), + _ => steps(remaining - 1, next, snapshot, next_key, probe, checkpoint - 1, value, checksum), + } + }, + } + } + fn run(depth: Field, updates: Field, seed: Field) -> (Field, Field) { + let tree = build(depth, 0, 1, seed); + let key = zero_key(depth); + steps(updates, tree, tree, key, key, 63, seed + 100, 0) + } +} +" + +abbrev modulus := 18446744069414584321 +abbrev F := ZMod modulus + +set_option maxRecDepth 10000 in +set_option maxHeartbeats 2000000 in +private theorem modulus_prime : Nat.Prime modulus := by + apply lucas_primality modulus (7 : F) + · reduce_mod_char + · intro q hq hd + have factors : modulus - 1 = 2^32 * 3 * 5 * 17 * 257 * 65537 := by norm_num + rw [factors] at hd + simp only [hq.dvd_mul, or_assoc] at hd + rcases hd with hd | hd | hd | hd | hd | hd + all_goals + try replace hd := hq.dvd_of_dvd_pow hd + rw [Nat.prime_dvd_prime_iff_eq hq (by norm_num)] at hd + subst q + reduce_mod_char + decide + +instance : Fact (Nat.Prime modulus) := ⟨modulus_prime⟩ + +def main (args : List String) : IO Unit := do + let path := args.headD "/tmp/aiur-trie.json" + let prepared ← IO.ofExcept (Modules.prepare (source.toField F) ["Trie::run"]) + let execution ← IO.ofExcept prepared.exportExecution + let compiled ← IO.ofExcept (prepared.compileOptimized {}) + let program ← IO.ofExcept (execution.toJson modulus ZMod.val) + let trace ← IO.ofExcept (Trace.exportJson modulus ZMod.val compiled.circuit.inlined.program + compiled.circuit.artifact execution.bytecode) + IO.FS.writeFile path (Json.mkObj [ + ("program", program), ("trace", trace), + ("args", toJson ([14, 4096, 17] : List Nat))]).compress + IO.println s!"Exported {execution.bytecode.functions.length} functions to {path}" + +end TrieBenchmark + +def main (args : List String) : IO Unit := TrieBenchmark.main args diff --git a/Aiur/Examples/Tuples.lean b/Aiur/Examples/Tuples.lean new file mode 100644 index 000000000..13508d32f --- /dev/null +++ b/Aiur/Examples/Tuples.lean @@ -0,0 +1,29 @@ +import Aiur +import Mathlib.Algebra.Field.Rat + +open Aiur + +def tupleProgram : Program Nat := aiur% " +fn swap(p: (Field, Field)) -> (Field, Field) { + match p { (x, y) => (y, x) } +} + +fn step(p: (Field, (Field, Field))) -> (Field, (Field, Field), ()) { + let (tag, (x, y)) = p; + match (tag, x) { + (0, _) => (tag, swap((x, y)), ()), + (_, 0) => (tag, (y, y), ()), + _ => (tag, (x + y, x * y), ()), + } +} +" + +#eval eval (tupleProgram.toField Rat) "step" [.tuple [0, .tuple [2, 3]]] +-- .ok (.tuple [0, .tuple [3, 2], .tuple []]) + +example : EvalCall (tupleProgram.toField Rat) "step" [.tuple [0, .tuple [2, 3]]] + (.tuple [0, .tuple [3, 2], .tuple []]) := + eval_spec (hints := HintProvider.unavailable) (fuel := 20) (by decide +kernel) + +#eval (Circuit.compile (tupleProgram.toField Rat)).isOk +-- true diff --git a/Aiur/Examples/U32.lean b/Aiur/Examples/U32.lean new file mode 100644 index 000000000..31c313338 --- /dev/null +++ b/Aiur/Examples/U32.lean @@ -0,0 +1,29 @@ +import AiurTests.U32 +import Aiur.Library.U32.Goldilocks +import Aiur.Execution +import Aiur.Trace.Export + +namespace U32Example +open Aiur Lean + +-- IxVM and its word-library regression use the explicitly selected Goldilocks implementation. +abbrev modulus := Library.U32.Goldilocks.modulus +abbrev F := Library.U32.Goldilocks.F + +def exportProgram (path : String) : IO Unit := do + let library := Library.U32.Goldilocks.program + let source := library.append (AiurU32Tests.client.toField F) + let prepared ← IO.ofExcept <| Modules.prepare source AiurU32Tests.entries + let exported ← IO.ofExcept prepared.exportExecution + let compiled ← IO.ofExcept prepared.compileOptimized + let program ← IO.ofExcept <| exported.toJson modulus ZMod.val + let trace ← IO.ofExcept <| Trace.exportJson modulus ZMod.val compiled.circuit.inlined.program + compiled.circuit.artifact exported.bytecode + IO.FS.writeFile path (Json.mkObj [("program", program), ("trace", trace)]).compress + IO.println s!"Exported opaque u32 regression program to {path}." + +end U32Example + +def main (args : List String) : IO Unit := do + AiurU32Tests.run + if let some path := args.head? then U32Example.exportProgram path diff --git a/Aiur/Examples/Updates.lean b/Aiur/Examples/Updates.lean new file mode 100644 index 000000000..e52038fbc --- /dev/null +++ b/Aiur/Examples/Updates.lean @@ -0,0 +1,34 @@ +import Aiur.Generic +import Mathlib.Algebra.Field.Rat + +open Aiur + +def updates : Generic.Program Nat := aiur% " +struct Point { x: Field, y: Field } +struct State { position: Point, samples: [Field; 3] } + +fn advance(state: State, sample: Field) -> State { + state with { + .position.x = state.position.x + 1, + .samples[2] = sample, + } +} + +fn main() -> (Field, [Field; 3]) { + let initial = State { position: Point { x: 3, y: 4 }, samples: [0; 3] }; + let next = advance(initial, 9); + (next.position.x, next.samples) +} +" + +#eval do + let s ← Generic.prepare (updates.toField Rat) + s.run "main" [] +-- .ok (.tuple [4, .tuple [0, 0, 9]], []) + +#eval do + let s ← Generic.prepare (updates.toField Rat) + let specialized ← Generic.specialize s ["main"] + let _ ← specialized.compile + specialized.coreRun "main" [] +-- .ok (.tuple [4, .tuple [0, 0, 9]], []) diff --git a/Aiur/LICENSE-APACHE b/Aiur/LICENSE-APACHE new file mode 100644 index 000000000..d9a10c0d8 --- /dev/null +++ b/Aiur/LICENSE-APACHE @@ -0,0 +1,176 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS diff --git a/Aiur/LICENSE-MIT b/Aiur/LICENSE-MIT new file mode 100644 index 000000000..784df0a55 --- /dev/null +++ b/Aiur/LICENSE-MIT @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2025 Argument Computer Corporation + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/Aiur/c/execution.c b/Aiur/c/execution.c new file mode 100644 index 000000000..860ab83e9 --- /dev/null +++ b/Aiur/c/execution.c @@ -0,0 +1,17 @@ +#include +#include +#include + +extern char *aiur_execute_json(const uint8_t *data, size_t length); +extern void aiur_free_string(char *string); + +/* The only code depending on Lean's C object ABI. Rust borrows the request + for this call; the response is copied into Lean before Rust frees it. */ +LEAN_EXPORT lean_obj_res aiur_lean_execute(b_lean_obj_arg request, lean_obj_arg world) { + (void)world; + char *response = aiur_execute_json((const uint8_t *)lean_string_cstr(request), + lean_string_size(request) - 1); + lean_object *result = lean_mk_string(response); + aiur_free_string(response); + return lean_io_result_mk_ok(result); +} diff --git a/Aiur/lake-manifest.json b/Aiur/lake-manifest.json new file mode 100644 index 000000000..47d7e2273 --- /dev/null +++ b/Aiur/lake-manifest.json @@ -0,0 +1,96 @@ +{"version": "1.2.0", + "packagesDir": ".lake/packages", + "packages": + [{"url": "https://github.com/leanprover-community/mathlib4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "name": "mathlib", + "manifestFile": "lake-manifest.json", + "inputRev": "v4.34.1", + "inherited": false, + "configFile": "lakefile.lean"}, + {"url": "https://github.com/leanprover-community/plausible", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c", + "name": "plausible", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/LeanSearchClient", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707", + "name": "LeanSearchClient", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/import-graph", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "e928b72544873815af278d38681b31c0293588e3", + "name": "importGraph", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/ProofWidgets4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5", + "name": "proofwidgets", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.lean"}, + {"url": "https://github.com/leanprover-community/aesop", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "355695d523e41d0554926416cba2a2b3544fbbc9", + "name": "aesop", + "manifestFile": "lake-manifest.json", + "inputRev": "master", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/quote4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259", + "name": "Qq", + "manifestFile": "lake-manifest.json", + "inputRev": "master", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/batteries", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2", + "name": "batteries", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover/lean4-cli", + "type": "git", + "subDir": null, + "scope": "leanprover", + "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204", + "name": "Cli", + "manifestFile": "lake-manifest.json", + "inputRev": "v4.34.0", + "inherited": true, + "configFile": "lakefile.toml"}], + "name": "aiur", + "lakeDir": ".lake", + "fixedToolchain": false} diff --git a/Aiur/lakefile.lean b/Aiur/lakefile.lean new file mode 100644 index 000000000..6a708b756 --- /dev/null +++ b/Aiur/lakefile.lean @@ -0,0 +1,87 @@ +import Lake +open System Lake DSL + +package aiur where + version := v!"0.1.0" + -- Preserve the elaboration of the verified 4.29 monadic definitions. + leanOptions := #[ + ⟨`backward.do.legacy, true⟩, + ⟨`weak.linter.constructorNameAsVariable, false⟩, + ⟨`weak.linter.defProp, false⟩, + ⟨`weak.linter.deprecated, false⟩, + ⟨`weak.linter.style.haveILetI, false⟩, + ⟨`weak.linter.unnecessarySeqFocus, false⟩, + ⟨`weak.linter.unnecessarySimpa, false⟩, + ⟨`weak.linter.unreachableTactic, false⟩, + ⟨`weak.linter.unusedSectionVars, false⟩, + ⟨`weak.linter.unusedSimpArgs, false⟩, + ⟨`weak.linter.unusedTactic, false⟩, + ⟨`weak.linter.unusedVariables, false⟩ + ] + +require "leanprover-community" / "mathlib" @ git "v4.34.1" + +/-- Keep ordinary Cargo builds independent of Lean. Only the Lean executable +link step needs this archive and the small C object-ABI adapter. -/ +target aiur_rs pkg : FilePath := do + let sources ← inputDir (pkg.dir / ".." / "crates" / "aiur" / "src") true (fun path => path.extension == some "rs") + let manifests := Job.collectArray #[ + ← inputTextFile (pkg.dir / ".." / "crates" / "aiur" / "Cargo.toml"), + ← inputTextFile (pkg.dir / ".." / "Cargo.toml"), + ← inputTextFile (pkg.dir / ".." / "Cargo.lock"), + ← inputTextFile (pkg.dir / ".." / "rust-toolchain.toml")] + let deps := sources.zipWith (fun a b => (a,b)) manifests + let output := pkg.staticLibDir / nameToStaticLib "aiur_rs" + buildFileAfterDep output deps fun _ => do + proc { cmd := "cargo", args := #["build", "--release", "-p", "aiur", "--lib", "--locked"], cwd := pkg.dir / ".." } (quiet := true) + copyFile (pkg.dir / ".." / "target" / "release" / nameToStaticLib "aiur") output + +target execution_o pkg : FilePath := do + let source ← inputTextFile (pkg.dir / "c" / "execution.c") + buildO (pkg.buildDir / "c" / "execution.o") source + #["-I", (← getLeanIncludeDir).toString] #["-fPIC"] "cc" getLeanTrace + +@[default_target] +lean_lib Aiur where + globs := #[.andSubmodules `Aiur] + +lean_lib AiurTests + +@[test_driver] +lean_exe aiur_tests where + root := `AiurTests + moreLinkObjs := #[execution_o, aiur_rs] + +lean_exe blake3_stats where + root := `Examples.Blake3 + +lean_exe aiur_execution where + root := `Examples.Execution + moreLinkObjs := #[execution_o, aiur_rs] + +lean_exe execution_tests where + root := `Examples.ExecutionChecks + moreLinkObjs := #[execution_o, aiur_rs] + +lean_exe trace_tests where + root := `Examples.TraceChecks + moreLinkObjs := #[execution_o, aiur_rs] + +lean_exe aiur_hints where + root := `Examples.ExecutionHints + moreLinkObjs := #[execution_o, aiur_rs] + +lean_exe trie_export where + root := `Examples.Trie + +lean_exe u32_tests where + root := `Examples.U32 + +lean_exe library_tests where + root := `Examples.LibraryChecks + +lean_exe grouping_example where + root := `Examples.Grouping + +lean_exe grouping_tune where + root := `Examples.GroupingTune diff --git a/Aiur/lean-toolchain b/Aiur/lean-toolchain new file mode 100644 index 000000000..ba8ebf2db --- /dev/null +++ b/Aiur/lean-toolchain @@ -0,0 +1 @@ +leanprover/lean4:v4.34.1 diff --git a/Benchmarks/AggregatePolicy.lean b/Benchmarks/AggregatePolicy.lean deleted file mode 100644 index b1d68ef8e..000000000 --- a/Benchmarks/AggregatePolicy.lean +++ /dev/null @@ -1,779 +0,0 @@ -import Ix.Aggr -import Ix.Aiur.Compiler -import Ix.IxVM -import Ix.IxVM.Toplevel -import Ix.Aggr.Reference -import Ix.Benchmark.Bench -import Ix.TracingTexray - -/-! -# Four-shard converged aggregation policy benchmark - -This executable is the M1-f handoff harness. It consumes four persisted IxVM -shard proofs from a validated manifest, derives the selected subtree from the -manifest aggregation tree, and measures either production wrap-first or -non-default direct joins through the single `ix_aggr` entrypoint. - -Base shard proving is deliberately out of scope. Every input and recursive -output is natively verified, every recursive output is persisted as an ordinary -`Ixon.Proof` wrapper, aggregate cache access is disabled, and a structured JSON -report is rewritten after every completed slot. --/ - -open Lean (Json) - -namespace Benchmarks.AggregatePolicy - -open Ix -open Aggr Aggr.Reference - -abbrev AggregationTree := Ix.Shard.AggregationTree -abbrev FoldOp := Ix.Shard.AggregationTree.FoldOp - -structure AggregateSlot where - /-- Which verifying system a parent must use for this slot. Production - wrap-first slots are all `.aggr`; direct-join leaf slots remain `.ixvm`. -/ - kind : Aggr.ChildKind := .aggr - statement : Aggr.CheckEnvTrees - subjectCount : Nat - outerClaim : Array Aiur.G - proof : Aiur.Proof - proofAddress? : Option Address - /-- Serialized singleton outer-claim list consumed by a parent. -/ - claimsBytes : ByteArray := ByteArray.empty - -inductive Policy where - | wrapFirst - | direct - deriving BEq, Repr - -def Policy.parse : String → Except String Policy - | "wrap-first" => .ok .wrapFirst - | "direct" => .ok .direct - | value => .error s!"invalid --policy {value}; expected wrap-first or direct" - -def Policy.label : Policy → String - | .wrapFirst => "wrap-first" - | .direct => "direct" - -def Policy.directJoins : Policy → Bool - | .wrapFirst => false - | .direct => true - -def argStr (args : List String) (flag : String) : Option String := - match args.dropWhile (· != flag) with - | _ :: value :: _ => some value - | _ => none - -def argNat? (args : List String) (flag : String) : Option Nat := - (argStr args flag).bind (·.toNat?) - -def hasFlag (args : List String) (flag : String) : Bool := - args.contains flag - -def jsonRound (digits : Nat) (value : Float) : Json := - let scale := (10.0 : Float) ^ digits.toFloat - let scaled := value * scale - let mantissa : _root_.Int := - if scaled < 0 then -_root_.Int.ofNat (-scaled).round.toUInt64.toNat - else _root_.Int.ofNat scaled.round.toUInt64.toNat - Json.num ⟨mantissa, digits⟩ - -def timed (action : Unit → α) : IO (α × Float) := do - let started ← IO.monoNanosNow - let result ← blackBoxIO action () - let elapsed ← IO.monoNanosNow - pure (result, (elapsed - started).toFloat / 1e9) - -def parseShardIds (value : String) : Except String (Array Nat) := do - let parts := value.splitOn "," - if parts.length != 4 then - throw s!"--shards must contain exactly four comma-separated ids; got {parts.length}" - let mut ids : Array Nat := #[] - for part in parts do - let some shard := part.toNat? - | throw s!"invalid shard id in --shards: {part}" - if ids.contains shard then - throw s!"--shards repeats shard {shard}" - ids := ids.push shard - pure ids - -def compileToplevel (label : String) - (source : Except Aiur.Global Aiur.Source.Toplevel) - (groups : Array (String × Array String)) : - IO (Except String Aiur.CompiledToplevel) := do - match source with - | .error error => pure (.error s!"{label} toplevel merge failed: {error}") - | .ok top => match top.compileWithGroups groups with - | .error error => pure (.error s!"{label} compilation failed: {error}") - | .ok compiled => pure (.ok compiled) - -def prepareShard (env : Ixon.Env) (blocks : Array Address) : - Except String PreparedShard := do - let owned := Ix.Shard.ownedConstsForBlocks env blocks - let (claim, trees) ← IxVM.ClaimHarness.shardCheckEnvClaimTrees env owned - let statement ← Aggr.CheckEnvTrees.ofClaim claim trees - pure { claim, statement } - -structure Fixture where - shardIds : Array Nat - blocks : Array (Array Address) - subjectCounts : Array Nat - tree : AggregationTree - prepared : Array PreparedShard - -/-- Select four retained manifest shards and contract every other tree leaf. -The requested-id order determines dense indices; tree topology and left/right -orientation remain those of the manifest. -/ -def selectFixture (env : Ixon.Env) (view : Ix.Shard.IxesManifestView) - (counts requestedIds : Array Nat) : Except String Fixture := do - if requestedIds.size != 4 then - throw "internal: policy benchmark requires exactly four shards" - if view.shards.size != counts.size || view.shards.size != view.shardIds.size then - throw "manifest view/count cardinality mismatch" - let mut remap : Array (Option Nat) := Array.replicate view.shards.size none - let mut blocks : Array (Array Address) := #[] - let mut selectedCounts : Array Nat := #[] - let mut prepared : Array PreparedShard := #[] - for (originalId, selectedIdx) in - requestedIds.mapIdx fun selectedIdx originalId => (originalId, selectedIdx) do - let some denseIdx := view.shardIds.findIdx? (· == originalId) - | throw s!"manifest has no retained shard {originalId}" - let some shardBlocks := view.shards[denseIdx]? - | throw s!"manifest is missing blocks for retained shard {originalId}" - let some subjectCount := counts[denseIdx]? - | throw s!"manifest is missing the subject count for retained shard {originalId}" - remap := remap.set! denseIdx (some selectedIdx) - blocks := blocks.push shardBlocks - selectedCounts := selectedCounts.push subjectCount - prepared := prepared.push (← prepareShard env shardBlocks) - let some tree := view.aggregationTree.pruneAndRemap remap - | throw "selected shards produced an empty aggregation tree" - if tree.leaves.size != 4 then - throw s!"selected aggregation tree has {tree.leaves.size} leaves, expected 4" - let fixture : Fixture := { - shardIds := requestedIds - blocks := blocks - subjectCounts := selectedCounts - tree := tree - prepared := prepared - } - pure fixture - -/-- Recompute the host fold without claims, verifying that the benchmark root -is exactly the selected manifest subtree rather than a full-environment root. -/ -def expectedStatements (plan : Array ScheduledFold) - (prepared : Array PreparedShard) : - Except String (Array Aggr.CheckEnvTrees) := do - let mut statements : Array Aggr.CheckEnvTrees := #[] - for item in plan do - match item.op with - | .leaf shard => - let some source := prepared[shard]? - | throw s!"expected fold references missing shard {shard}" - statements := statements.push source.statement - | .join leftIdx rightIdx => - let some left := statements[leftIdx]? - | throw s!"expected fold references missing left slot {leftIdx}" - let some right := statements[rightIdx]? - | throw s!"expected fold references missing right slot {rightIdx}" - let output := if item.structural then left.joinStructural right - else left.join right - statements := statements.push output - pure statements - -def childKindLabel : Aggr.ChildKind → String - | .ixvm => "ixvm" - | .aggr => "ix_aggr" - -def optionNatJson : Option Nat → Json - | none => Json.null - | some value => Lean.toJson value - -def planOperation (item : ScheduledFold) : String := - match item.op with - | .leaf _ => if item.kind == .ixvm then "raw" else "wrap" - | .join _ _ => if item.structural then "structural-join" else "flat-join" - -def planRows (plan : Array ScheduledFold) (shardIds : Array Nat) : Array Json := - plan.mapIdx fun slotIdx item => - let base : List (String × Json) := - [("slot", Lean.toJson slotIdx), - ("operation", Json.str (planOperation item)), - ("shape", optionNatJson item.shape?), - ("subject_count", Lean.toJson item.subjectCount), - ("ram_weight_bytes", Lean.toJson (aggregateSlotRamBytes item))] - match item.op with - | .leaf shard => - Json.mkObj (base ++ - [("shard", Lean.toJson ((shardIds[shard]?).getD shard)), - ("left_kind", Json.str (childKindLabel item.kind)), - ("right_kind", Json.null)]) - | .join leftIdx rightIdx => - let leftKind := (plan[leftIdx]?).map (childKindLabel ·.kind) - |>.getD "missing" - let rightKind := (plan[rightIdx]?).map (childKindLabel ·.kind) - |>.getD "missing" - Json.mkObj (base ++ - [("left_slot", Lean.toJson leftIdx), - ("right_slot", Lean.toJson rightIdx), - ("left_kind", Json.str leftKind), - ("right_kind", Json.str rightKind)]) - -def printPlan (policy : Policy) (plan : Array ScheduledFold) - (shardIds : Array Nat) (structuralAbove : Nat) : IO Unit := do - IO.println s!"[aggregate-policy] {policy.label}; structural threshold > {structuralAbove}" - for (item, slotIdx) in plan.mapIdx fun slotIdx item => (item, slotIdx) do - match item.op with - | .leaf shard => - let originalShard := (shardIds[shard]?).getD shard - IO.println s!" slot {slotIdx}: {planOperation item} shard {originalShard}; \ - shape {item.shape?.map toString |>.getD "raw"}; {item.subjectCount} subjects" - | .join left right => - IO.println s!" slot {slotIdx}: {planOperation item} slots {left},{right}; \ - shape {item.shape?.map toString |>.getD "missing"}; {item.subjectCount} subjects" - -structure InputProof where - address : Address - wrapper : Ixon.Proof - proof : Aiur.Proof - innerClaim : Array Aiur.G - claimsBytes : ByteArray - -def loadInputProof (shardId : Nat) (proofAddress : String) - (prepared : PreparedShard) (verifyIdx : Aiur.Bytecode.FunIdx) : - IO (Except String InputProof) := do - let some address := Address.fromString proofAddress - | return .error s!"--proof-{shardId}: expected a 64-character store address" - try - let wrapper ← match Ixon.Proof.de (← StoreIO.toIO (Store.read address)) with - | .error error => - return .error s!"shard {shardId}: wrapper decode failed: {error}" - | .ok wrapper => pure wrapper - if wrapper.claim != prepared.claim then - return .error s!"shard {shardId}: persisted wrapper claim does not match the selected shard" - let proof ← match Aiur.Proof.ofBytesChecked wrapper.proof with - | .error error => - return .error s!"shard {shardId}: proof decode failed: {error}" - | .ok proof => pure proof - let claimBytes := Ix.Claim.ser prepared.claim - let innerClaim := Aiur.buildClaim verifyIdx - (IxVM.ClaimHarness.packedDigestKey (Address.blake3 claimBytes)) #[] - let input : InputProof := { - address := address - wrapper := wrapper - proof := proof - innerClaim := innerClaim - claimsBytes := MultiStark.serializeClaims #[innerClaim] - } - pure (.ok input) - catch error => - pure (.error s!"shard {shardId}: store read failed: {error}") - -def persistAggregateProof (statement : Aggr.CheckEnvTrees) - (proof : Aiur.Proof) : IO Address := do - let claim := statement.claim - let _ ← StoreIO.toIO (Store.write (Ix.Claim.ser claim)) - let wrapper : Ixon.Proof := { claim, proof := proof.toBytes } - StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper)) - -structure MeasuredSlot where - slot : AggregateSlot - row : Json - proveSeconds : Float - peakTreeRssBytes : Nat - -def stageRow (slotIdx : Nat) (item : ScheduledFold) - (leftKind rightKind : Option Aggr.ChildKind) (proveSeconds verifySeconds : Float) - (inputVerifySeconds : Option Float) (peakTreeRssBytes proofBytes : Nat) - (claimDigest proofAddress : Address) : Json := - Json.mkObj <| - [("slot", Lean.toJson slotIdx), - ("operation", Json.str (planOperation item)), - ("shape", optionNatJson item.shape?), - ("left_kind", leftKind.map (Json.str ∘ childKindLabel) |>.getD Json.null), - ("right_kind", rightKind.map (Json.str ∘ childKindLabel) |>.getD Json.null), - ("subject_count", Lean.toJson item.subjectCount), - ("prove_seconds", jsonRound 6 proveSeconds), - ("verify_seconds", jsonRound 6 verifySeconds), - ("peak_tree_rss_bytes", Lean.toJson peakTreeRssBytes), - ("proof_bytes", Lean.toJson proofBytes), - ("claim_digest", Json.str (toString claimDigest)), - ("proof_address", Json.str (toString proofAddress))] ++ - match inputVerifySeconds with - | none => [] - | some seconds => [("input_verify_seconds", jsonRound 6 seconds)] - -def runLeaf (slotIdx shardId : Nat) (item : ScheduledFold) - (prepared : PreparedShard) (input : InputProof) (spec : AggregateSlotSpec) - (ixvmSystem aggrSystem : Aiur.AiurSystem) (ixvmVk aggrVk allowed : ByteArray) - (aggrIdx : Aiur.Bytecode.FunIdx) : IO (Except String MeasuredSlot) := do - TracingTexray.resetPeakTreeRss - let (innerVerified, innerVerifySeconds) ← timed fun _ => - ixvmSystem.verify input.innerClaim input.proof - let innerVerifyPeak ← TracingTexray.peakTreeRssBytes - match innerVerified with - | .error error => - return .error s!"shard {shardId}: native input verification failed: {error}" - | .ok () => pure () - if spec.outerClaim != (if item.kind == .ixvm then input.innerClaim - else aggregateOuterClaim allowed aggrIdx prepared.claim) then - return .error s!"shard {shardId}: prepared leaf outer claim is inconsistent" - match item.kind with - | .ixvm => - if item.shape?.isSome then - return .error s!"shard {shardId}: raw leaf unexpectedly has an ix_aggr shape" - let slot : AggregateSlot := { - kind := .ixvm, statement := spec.statement, - subjectCount := spec.subjectCount, outerClaim := input.innerClaim, - proof := input.proof, proofAddress? := some input.address, - claimsBytes := input.claimsBytes - } - pure (.ok { - slot - row := stageRow slotIdx item (some .ixvm) none 0 innerVerifySeconds none - innerVerifyPeak input.wrapper.proof.size - (Address.blake3 (Ix.Claim.ser spec.statement.claim)) input.address - proveSeconds := 0 - peakTreeRssBytes := innerVerifyPeak - }) - | .aggr => - if item.shape? != some 0 then - return .error s!"shard {shardId}: wrap leaf requires shape 0" - let innerProofAdvice ← match ixvmSystem.proofToAdviceBytes - input.innerClaim input.proof with - | .error error => - return .error s!"shard {shardId}: proof advice encoding failed: {error}" - | .ok bytes => pure bytes - let claimBytes := Ix.Claim.ser prepared.claim - let pubInput := Aggr.pubInput allowed claimBytes - IO.println s!"[aggregate-policy] proving slot {slotIdx}: wrap shard {shardId}" - (← IO.getStdout).flush - TracingTexray.resetPeakTreeRss - let (proved, proveSeconds) ← timed fun _ => - aggrSystem.proveIxAggr aggrIdx pubInput 0 - innerProofAdvice ByteArray.empty ixvmVk aggrVk - input.claimsBytes ByteArray.empty claimBytes allowed - (Aggr.preimagesBlob #[]) (Aggr.treesBlob #[]) (Aggr.pathsBlob #[]) - let provePeak ← TracingTexray.peakTreeRssBytes - let (outerClaim, proof) ← match proved with - | .error error => return .error s!"shard {shardId}: wrap proving failed: {error}" - | .ok result => pure result - if outerClaim != spec.outerClaim then - return .error s!"shard {shardId}: wrap produced an unexpected outer claim" - TracingTexray.resetPeakTreeRss - let (verified, verifySeconds) ← timed fun _ => aggrSystem.verify outerClaim proof - let verifyPeak ← TracingTexray.peakTreeRssBytes - match verified with - | .error error => - return .error s!"shard {shardId}: wrap output verification failed: {error}" - | .ok () => pure () - let address ← persistAggregateProof spec.statement proof - let proofBytes := proof.toBytes - let peak := max innerVerifyPeak (max provePeak verifyPeak) - let slot : AggregateSlot := { - kind := .aggr, statement := spec.statement, - subjectCount := spec.subjectCount, outerClaim, - proof, proofAddress? := some address, - claimsBytes := MultiStark.serializeClaims #[outerClaim] - } - pure (.ok { - slot - row := stageRow slotIdx item (some .ixvm) none proveSeconds verifySeconds - (some innerVerifySeconds) peak proofBytes.size - (Address.blake3 claimBytes) address - proveSeconds - peakTreeRssBytes := peak - }) - -def runJoin (slotIdx : Nat) (item : ScheduledFold) (left right : AggregateSlot) - (spec : AggregateSlotSpec) (ixvmSystem aggrSystem : Aiur.AiurSystem) - (ixvmVk aggrVk allowed : ByteArray) (aggrIdx : Aiur.Bytecode.FunIdx) : - IO (Except String MeasuredSlot) := do - let output := spec.statement - let outputClaimBytes := Ix.Claim.ser output.claim - let pubInput := Aggr.pubInput allowed outputClaimBytes - let leftStatement := left.statement - let rightStatement := right.statement - let outputStatement := output - let preimagesBlob := Aggr.preimagesBlob - #[Ix.Claim.ser left.statement.claim, Ix.Claim.ser right.statement.claim] - let trees := if item.structural then - Aggr.CheckEnvTrees.structuralAdviceTrees leftStatement rightStatement outputStatement - else Aggr.CheckEnvTrees.adviceTrees leftStatement rightStatement outputStatement - let treesBlob := Aggr.treesBlob trees - let pathsBlob := if item.structural then - Aggr.pathsBlob - (Aggr.CheckEnvTrees.structuralPathAdvice leftStatement rightStatement outputStatement) - else Aggr.pathsBlob #[] - let leftSystem := if left.kind == .ixvm then ixvmSystem else aggrSystem - let rightSystem := if right.kind == .ixvm then ixvmSystem else aggrSystem - let leftProofAdvice ← match leftSystem.proofToAdviceBytes left.outerClaim left.proof with - | .error error => return .error s!"slot {slotIdx}: left proof advice failed: {error}" - | .ok bytes => pure bytes - let rightProofAdvice ← match rightSystem.proofToAdviceBytes right.outerClaim right.proof with - | .error error => return .error s!"slot {slotIdx}: right proof advice failed: {error}" - | .ok bytes => pure bytes - let some shape := item.shape? - | return .error s!"slot {slotIdx}: join has no ix_aggr shape" - let mode := if item.structural then "structural" else "flat" - IO.println s!"[aggregate-policy] proving slot {slotIdx}: {mode} shape {shape}" - (← IO.getStdout).flush - TracingTexray.resetPeakTreeRss - let (proved, proveSeconds) ← timed fun _ => - aggrSystem.proveIxAggr aggrIdx pubInput shape - leftProofAdvice rightProofAdvice ixvmVk aggrVk - left.claimsBytes right.claimsBytes outputClaimBytes allowed - preimagesBlob treesBlob pathsBlob - let provePeak ← TracingTexray.peakTreeRssBytes - let (outerClaim, proof) ← match proved with - | .error error => return .error s!"slot {slotIdx}: join proving failed: {error}" - | .ok result => pure result - if outerClaim != spec.outerClaim then - return .error s!"slot {slotIdx}: join produced an unexpected outer claim" - TracingTexray.resetPeakTreeRss - let (verified, verifySeconds) ← timed fun _ => aggrSystem.verify outerClaim proof - let verifyPeak ← TracingTexray.peakTreeRssBytes - match verified with - | .error error => return .error s!"slot {slotIdx}: output verification failed: {error}" - | .ok () => pure () - let address ← persistAggregateProof output proof - let proofBytes := proof.toBytes - let peak := max provePeak verifyPeak - let slot : AggregateSlot := { - kind := .aggr, statement := output, - subjectCount := spec.subjectCount, outerClaim, - proof, proofAddress? := some address, - claimsBytes := MultiStark.serializeClaims #[outerClaim] - } - pure (.ok { - slot - row := stageRow slotIdx item (some left.kind) (some right.kind) - proveSeconds verifySeconds none peak proofBytes.size - (Address.blake3 outputClaimBytes) address - proveSeconds - peakTreeRssBytes := peak - }) - -def commandOutput (cmd : String) (args : Array String := #[]) : IO String := do - try - let output ← IO.Process.output { cmd, args } - if output.exitCode == 0 then pure output.stdout.trimAscii.toString - else pure "unknown" - catch _ => pure "unknown" - -def cpuLabel : IO String := do - let output ← commandOutput "lscpu" - let model? := output.splitOn "\n" |>.find? (·.startsWith "Model name:") - pure <| model?.map (·.drop 11 |>.trimAscii.toString) |>.getD "unknown" - -def writeReport (path? : Option String) (metadata : Json) (plan stages : Array Json) - (status : String) (totals? : Option Json := none) - (error? : Option String := none) : IO Unit := do - if let some path := path? then - let fields : List (String × Json) := - [("schema_version", Lean.toJson (1 : Nat)), - ("status", Json.str status), - ("metadata", metadata), - ("plan", Json.arr plan), - ("stages", Json.arr stages), - ("totals", totals?.getD Json.null)] ++ - match error? with - | none => [] - | some error => [("error", Json.str error)] - IO.FS.writeFile path ((Json.mkObj fields).pretty ++ "\n") - -def metadata (ixePath ixesPath : String) (ixeBytes ixesBytes : ByteArray) - (fixture : Fixture) (proofAddresses : Array String) (policy : Policy) - (queries structuralAbove jobs maxRamGiB : Nat) - (ixvmVk? aggrVk? : Option ByteArray := none) : IO Json := do - let commit ← commandOutput "git" #["rev-parse", "HEAD"] - let timestamp ← commandOutput "date" #["-Is"] - let host ← commandOutput "hostname" - let cpu ← cpuLabel - let memInfo ← try IO.FS.readFile "/proc/meminfo" catch _ => pure "" - let physicalRam := aggregateMemTotalBytes memInfo |>.getD 0 - let fri := { Aiur.defaultFriParameters with numQueries := queries } - pure <| Json.mkObj - [("commit", Json.str commit), - ("timestamp", Json.str timestamp), - ("host", Json.str host), - ("cpu", Json.str cpu), - ("physical_ram_bytes", Lean.toJson physicalRam), - ("ixe", Json.str ixePath), - ("ixe_digest", Json.str (toString (Address.blake3 ixeBytes))), - ("ixe_bytes", Lean.toJson ixeBytes.size), - ("ixes", Json.str ixesPath), - ("ixes_digest", Json.str (toString (Address.blake3 ixesBytes))), - ("ixes_bytes", Lean.toJson ixesBytes.size), - ("shard_ids", Lean.toJson fixture.shardIds), - ("input_proof_addresses", Lean.toJson proofAddresses), - ("policy", Json.str policy.label), - ("recursion_parameters", Json.mkObj - [("log_blowup", Lean.toJson Aiur.defaultCommitmentParameters.logBlowup), - ("cap_height", Lean.toJson Aiur.defaultCommitmentParameters.capHeight), - ("log_final_poly_len", Lean.toJson fri.logFinalPolyLen), - ("max_log_arity", Lean.toJson fri.maxLogArity), - ("num_queries", Lean.toJson fri.numQueries), - ("commit_pow_bits", Lean.toJson fri.commitProofOfWorkBits), - ("query_pow_bits", Lean.toJson fri.queryProofOfWorkBits)]), - ("structural_above", Lean.toJson structuralAbove), - ("jobs", Lean.toJson jobs), - ("max_ram_gib", Lean.toJson maxRamGiB), - ("cache", Json.str "disabled"), - ("wall_scope", Json.str "input verification plus recursive slots"), - ("ixvm_vk_digest", ixvmVk?.map (Json.str ∘ toString ∘ Address.blake3) - |>.getD Json.null), - ("ix_aggr_vk_digest", aggrVk?.map (Json.str ∘ toString ∘ Address.blake3) - |>.getD Json.null)] - -def usage : String := - "usage: bench-aggregate-policy --ixe ENV.ixe --ixes MANIFEST.ixes " ++ - "--shards A,B,C,D --proof-A ADDR --proof-B ADDR --proof-C ADDR " ++ - "--proof-D ADDR --policy wrap-first|direct [--structural-above N] " ++ - "[--queries N] [--jobs 1] [--max-ram GIB] --no-cache --json RESULT.json " ++ - "[--plan-only]" - -def main (args : List String) : IO UInt32 := do - if hasFlag args "--help" then - IO.println usage - return 0 - let some ixePath := argStr args "--ixe" | do - IO.eprintln "error: --ixe is required"; IO.eprintln usage; return 2 - let some ixesPath := argStr args "--ixes" | do - IO.eprintln "error: --ixes is required"; IO.eprintln usage; return 2 - let some shardsValue := argStr args "--shards" | do - IO.eprintln "error: --shards is required"; IO.eprintln usage; return 2 - let shardIds ← match parseShardIds shardsValue with - | .error error => IO.eprintln s!"error: {error}"; return 2 - | .ok ids => pure ids - let some policyValue := argStr args "--policy" | do - IO.eprintln "error: --policy is required"; IO.eprintln usage; return 2 - let policy ← match Policy.parse policyValue with - | .error error => IO.eprintln s!"error: {error}"; return 2 - | .ok policy => pure policy - let queries := (argNat? args "--queries").getD 100 - if queries != 100 then - IO.eprintln "error: M1-f requires --queries 100 so roots use the production verifier parameters" - return 2 - let structuralAbove := (argNat? args "--structural-above").getD defaultStructuralAbove - let jobs := (argNat? args "--jobs").getD 1 - if jobs != 1 then - IO.eprintln "error: the M1-f policy comparison requires --jobs 1"; return 2 - let maxRamGiB := (argNat? args "--max-ram").getD 450 - if maxRamGiB == 0 then - IO.eprintln "error: --max-ram must be positive"; return 2 - let planOnly := hasFlag args "--plan-only" - let jsonPath? := argStr args "--json" - if !planOnly && jsonPath?.isNone then - IO.eprintln "error: measured runs require --json"; return 2 - if !planOnly && !hasFlag args "--no-cache" then - IO.eprintln "error: measured runs require --no-cache"; return 2 - - let ixeBytes ← IO.FS.readBinFile ixePath - let ixesBytes ← IO.FS.readBinFile ixesPath - let env ← match Ixon.deEnvAnon ixeBytes with - | .error error => IO.eprintln s!"deserialize {ixePath} failed: {error}"; return 1 - | .ok env => pure env - let rawView ← match Ix.Shard.parseIxesManifest ixesBytes with - | .error error => IO.eprintln s!"manifest parse failed: {error}"; return 1 - | .ok view => pure view - if !(← Ix.Shard.shardsCover env rawView.shards) then return 1 - let (view, counts) ← match rawView.pruneEmpty env with - | .error error => IO.eprintln error; return 1 - | .ok result => pure result - let fixture ← match selectFixture env view counts shardIds with - | .error error => IO.eprintln s!"select fixture: {error}"; return 1 - | .ok fixture => pure fixture - let plan ← match schedulePlan fixture.tree.foldPlan fixture.subjectCounts - structuralAbove policy.directJoins with - | .error error => IO.eprintln s!"schedule selected fixture: {error}"; return 1 - | .ok plan => pure plan - let expected ← match expectedStatements plan fixture.prepared with - | .error error => IO.eprintln s!"reconstruct selected root: {error}"; return 1 - | .ok statements => pure statements - let some expectedRoot := expected.back? | do - IO.eprintln "selected fixture produced no host root"; return 1 - let rows := planRows plan fixture.shardIds - printPlan policy plan fixture.shardIds structuralAbove - let weights := aggregateSlotRamWeights plan - let requiredRam := weights.foldl max 0 - if maxRamGiB * aggregateGiB < requiredRam then - IO.eprintln s!"error: --max-ram {maxRamGiB} GiB is below the plan's largest \ - slot reserve of {requiredRam / aggregateGiB} GiB" - return 2 - - let mut proofHexes : Array String := #[] - if !planOnly then - for shardId in fixture.shardIds do - let flag := s!"--proof-{shardId}" - let some proofHex := argStr args flag | do - IO.eprintln s!"error: {flag} is required"; return 2 - proofHexes := proofHexes.push proofHex - let metadata0 ← metadata ixePath ixesPath ixeBytes ixesBytes fixture proofHexes - policy queries structuralAbove jobs maxRamGiB - if planOnly then - writeReport jsonPath? metadata0 rows #[] "plan-only" - return 0 - - writeReport jsonPath? metadata0 rows #[] "preparing" - TracingTexray.startSampler 25 - IO.println "[aggregate-policy] compiling IxVM and ixAggr systems" - let ixvmCompiled ← match ← compileToplevel "IxVM" IxVM.ixVM IxVM.functionGroups with - | .error error => - writeReport jsonPath? metadata0 rows #[] "error" (error? := some error) - IO.eprintln error - return 1 - | .ok compiled => pure compiled - let aggrCompiled ← match ← compileToplevel "ixAggr recursion" Aggr.ixAggr Aggr.functionGroups with - | .error error => - writeReport jsonPath? metadata0 rows #[] "error" (error? := some error) - IO.eprintln error - return 1 - | .ok compiled => pure compiled - let verifyIdx := ixvmCompiled.getFuncIdx `verify_claim |>.get! - let aggrIdx := aggrCompiled.getFuncIdx `ix_aggr |>.get! - let friParameters := { Aiur.defaultFriParameters with numQueries := queries } - let recursionParameters : Aggr.RecursionParameters := { - commitment := Aiur.defaultCommitmentParameters - fri := friParameters - } - let ixvmSystem := Aiur.AiurSystem.build ixvmCompiled.bytecode - Aiur.defaultCommitmentParameters Aiur.defaultFriParameters - let aggrSystem := Aggr.buildRecursionSystem aggrCompiled.bytecode - recursionParameters - let ixvmVk := ixvmSystem.vkBytes - let aggrVk := aggrSystem.vkBytes - let allowed := Aggr.allowedBlob ixvmVk verifyIdx aggrVk aggrIdx - let specs ← match buildAggrSlotSpecs plan fixture.prepared aggrVk allowed - verifyIdx aggrIdx recursionParameters with - | .error error => - let error := s!"prepare policy slots: {error}" - writeReport jsonPath? metadata0 rows #[] "error" (error? := some error) - IO.eprintln error - return 1 - | .ok specs => pure specs - let some rootSpec := specs.back? | do - let error := "prepared policy has no root slot" - writeReport jsonPath? metadata0 rows #[] "error" (error? := some error) - IO.eprintln error - return 1 - if rootSpec.statement.claim != expectedRoot.claim then - let error := "prepared root differs from independent selected-subtree fold" - writeReport jsonPath? metadata0 rows #[] "error" (error? := some error) - IO.eprintln error - return 1 - - let mut inputs : Array InputProof := #[] - for shard in [:fixture.shardIds.size] do - let shardId := fixture.shardIds[shard]! - let some preparedShard := fixture.prepared[shard]? | do - let error := s!"internal: missing prepared shard {shardId}" - writeReport jsonPath? metadata0 rows #[] "error" (error? := some error) - IO.eprintln error - return 1 - let input ← match ← loadInputProof shardId proofHexes[shard]! - preparedShard verifyIdx with - | .error error => - writeReport jsonPath? metadata0 rows #[] "error" (error? := some error) - IO.eprintln error - return 1 - | .ok input => pure input - inputs := inputs.push input - let metadata ← metadata ixePath ixesPath ixeBytes ixesBytes fixture proofHexes - policy queries structuralAbove jobs maxRamGiB (some ixvmVk) (some aggrVk) - let mut stages : Array Json := #[] - writeReport jsonPath? metadata rows stages "running" - let wallStarted ← IO.monoNanosNow - let mut slots : Array AggregateSlot := #[] - let mut proveSeconds : Float := 0 - let mut maxPeak : Nat := 0 - for (item, slotIdx) in plan.mapIdx fun slotIdx item => (item, slotIdx) do - let some spec := specs[slotIdx]? | do - let error := s!"missing prepared slot {slotIdx}" - writeReport jsonPath? metadata rows stages "error" (error? := some error) - IO.eprintln error - return 1 - let measured ← match item.op with - | .leaf shard => - let shardId := fixture.shardIds[shard]! - let some preparedShard := fixture.prepared[shard]? | do - let error := s!"slot {slotIdx}: missing prepared shard {shardId}" - writeReport jsonPath? metadata rows stages "error" (error? := some error) - IO.eprintln error - return 1 - let some input := inputs[shard]? | do - let error := s!"slot {slotIdx}: missing input proof for shard {shardId}" - writeReport jsonPath? metadata rows stages "error" (error? := some error) - IO.eprintln error - return 1 - match ← runLeaf slotIdx shardId item preparedShard - input spec ixvmSystem aggrSystem ixvmVk aggrVk allowed aggrIdx with - | .error error => - writeReport jsonPath? metadata rows stages "error" (error? := some error) - IO.eprintln error - return 1 - | .ok measured => pure measured - | .join leftIdx rightIdx => - let some left := slots[leftIdx]? | do - let error := s!"slot {slotIdx}: missing left slot {leftIdx}" - writeReport jsonPath? metadata rows stages "error" (error? := some error) - IO.eprintln error - return 1 - let some right := slots[rightIdx]? | do - let error := s!"slot {slotIdx}: missing right slot {rightIdx}" - writeReport jsonPath? metadata rows stages "error" (error? := some error) - IO.eprintln error - return 1 - match ← runJoin slotIdx item left right spec ixvmSystem aggrSystem - ixvmVk aggrVk allowed aggrIdx with - | .error error => - writeReport jsonPath? metadata rows stages "error" (error? := some error) - IO.eprintln error - return 1 - | .ok measured => pure measured - slots := slots.push measured.slot - stages := stages.push measured.row - proveSeconds := proveSeconds + measured.proveSeconds - maxPeak := max maxPeak measured.peakTreeRssBytes - writeReport jsonPath? metadata rows stages "running" - - let wallEnded ← IO.monoNanosNow - let wallSeconds := (wallEnded - wallStarted).toFloat / 1e9 - let some root := slots.back? | do - let error := "policy plan produced no root slot" - writeReport jsonPath? metadata rows stages "error" (error? := some error) - IO.eprintln error - return 1 - if root.kind != .aggr || root.statement.claim != expectedRoot.claim then - let error := "proved root differs from the independently reconstructed ix_aggr root" - writeReport jsonPath? metadata rows stages "error" (error? := some error) - IO.eprintln error - return 1 - let some rootAddress := root.proofAddress? | do - let error := "root aggregate proof was not persisted" - writeReport jsonPath? metadata rows stages "error" (error? := some error) - IO.eprintln error - return 1 - let rootProofBytes := root.proof.toBytes - let rootClaimDigest := Address.blake3 (Ix.Claim.ser root.statement.claim) - let outerClaimDigest := Address.blake3 (MultiStark.serializeClaims #[root.outerClaim]) - let totals := Json.mkObj - [("wall_seconds", jsonRound 6 wallSeconds), - ("serialized_prove_seconds", jsonRound 6 proveSeconds), - ("peak_tree_rss_bytes", Lean.toJson maxPeak), - ("root_claim_digest", Json.str (toString rootClaimDigest)), - ("root_outer_claim_digest", Json.str (toString outerClaimDigest)), - ("root_proof_bytes", Lean.toJson rootProofBytes.size), - ("root_proof_address", Json.str (toString rootAddress)), - ("retains_assumptions", Lean.toJson root.statement.assumptions.isSome)] - writeReport jsonPath? metadata rows stages "ok" (some totals) - IO.println s!"[aggregate-policy] OK: {policy.label}; {proveSeconds}s proving; \ - {wallSeconds}s measured wall; peak {maxPeak} bytes; root {rootAddress} \ - ({rootProofBytes.size} bytes, claim {rootClaimDigest})" - pure 0 - -end Benchmarks.AggregatePolicy - -def main (args : List String) : IO UInt32 := - Benchmarks.AggregatePolicy.main args diff --git a/Benchmarks/Aiur.lean b/Benchmarks/Aiur.lean deleted file mode 100644 index 9542806f9..000000000 --- a/Benchmarks/Aiur.lean +++ /dev/null @@ -1,94 +0,0 @@ -import Ix.Aiur.Meta -import Ix.Aiur.Compiler -import Ix.Aiur.Protocol -import Ix.Benchmark.Bench - -open BgroupM - -def toplevel := ⟦ - enum Nat { - Zero, - Succ(&Nat) - } - - fn g_to_nat(g: G) -> Nat { - match g { - 0 => Nat.Zero, - _ => Nat.Succ(store(g_to_nat(g - 1))), - } - } - - fn nat_to_g(n: Nat) -> G { - match n { - Nat.Zero => 0, - Nat.Succ(ptr) => nat_to_g(load(ptr)) + 1, - } - } - - fn nat_add(a: Nat, b: Nat) -> Nat { - match b { - Nat.Zero => a, - Nat.Succ(b'ptr) => nat_add(Nat.Succ(store(a)), load(b'ptr)), - } - } - - fn nat_fib(n: Nat) -> Nat { - match n { - Nat.Zero => Nat.Succ(store(Nat.Zero)), - Nat.Succ(n'ptr) => - let n' = load(n'ptr); - match n' { - Nat.Zero => Nat.Succ(store(Nat.Zero)), - Nat.Succ(n''ptr) => - let n'' = load(n''ptr); - nat_add(nat_fib(n'), nat_fib(n'')), - }, - } - } - - pub fn main(g: G) -> G { - nat_to_g(nat_fib(g_to_nat(g))) - } -⟧ - -def commitmentParameters : Aiur.CommitmentParameters := { - logBlowup := 2 - capHeight := 0 -} - -def friParameters : Aiur.FriParameters := { - logFinalPolyLen := 0 - maxLogArity := 1 - numQueries := 100 - commitProofOfWorkBits := 0 - queryProofOfWorkBits := 20 -} - --- Stages the e2e proving pipeline through `benchStep`: each call times a stage --- and threads its output into the next. `prove fib 10` is one-shot because a --- single iteration already runs in the hundreds of milliseconds. --- --- `simplify toplevel` and `compile decls` are side-benches that measure --- sub-steps of `Toplevel.compile`. They sit inside a `skipE2E` block so they --- show up in the report without double-counting against `compile`. -def main : IO Unit := do - let decls ← match toplevel.checkAndSimplify with - | .error e => throw (IO.userError s!"{repr e}") - | .ok decls => pure decls - let concDecls ← match decls.concretize with - | .error e => throw (IO.userError s!"{repr e}") - | .ok cd => pure cd - let _ ← bgroup "nat_fib" { e2e := true } do - skipE2E - bench "simplify toplevel" Aiur.Source.Toplevel.checkAndSimplify toplevel - bench "concretize decls" Aiur.Typed.Decls.concretize decls - bench "compile decls" Aiur.Concrete.Decls.toBytecode concDecls - countInE2E - let compiled ← benchStepE "compile" Aiur.Source.Toplevel.compile toplevel - let system ← benchStep "build AiurSystem" - (Aiur.AiurSystem.build compiled.bytecode commitmentParameters) friParameters - let funIdx := compiled.getFuncIdx `main |>.get! - let (claim, proof, _) ← benchStepE "prove fib 10" - (Aiur.AiurSystem.prove system funIdx #[10]) default (oneShot := true) - let _ ← benchStepE "verify fib 10" - (Aiur.AiurSystem.verify system claim) proof diff --git a/Benchmarks/Blake3.lean b/Benchmarks/Blake3.lean deleted file mode 100644 index 549f8ab1b..000000000 --- a/Benchmarks/Blake3.lean +++ /dev/null @@ -1,54 +0,0 @@ -import Ix.Aiur.Library.Core -import Ix.Aiur.Library.ByteStream -import Ix.Aiur.Library.Blake3 -import Ix.Aiur.Protocol -import Ix.Aiur.Compiler -import Ix.Benchmark.Bench - -open BgroupM - -abbrev dataSizes := #[64, 128, 256, 512, 1024, 2048] -abbrev numHashesPerProof := #[1, 2, 4, 8, 16, 32] - -def commitmentParameters : Aiur.CommitmentParameters := { - logBlowup := 2 - capHeight := 0 -} - -def friParameters : Aiur.FriParameters := { - logFinalPolyLen := 0 - maxLogArity := 1 - numQueries := 100 - commitProofOfWorkBits := 0 - queryProofOfWorkBits := 20 -} - -def mergedToplevel : Except Aiur.Global Aiur.Source.Toplevel := do - let tl ← Aiur.Library.core.merge Aiur.Library.byteStream - tl.merge Aiur.Library.blake3 - -def blake3Bench : IO $ Array BenchReport := do - let .ok toplevel := mergedToplevel - | throw (IO.userError "Merging failed") - let .ok compiled := toplevel.compile - | throw (IO.userError "Compilation failed") - let some funIdx := compiled.getFuncIdx `blake3_bench - | throw (IO.userError "Aiur function not found") - let aiurSystem := Aiur.AiurSystem.build compiled.bytecode commitmentParameters friParameters - bgroup "prove blake3" { oneShot := true, avgThroughput := true, report := true } do - for dataSize in dataSizes do - for numHashes in numHashesPerProof do - let ioBuffer := Array.range numHashes |>.foldl - (init := default) - fun ioBuffer idx => - let data := Array.range dataSize |>.map - -- Add `idx` so every preimage is different and avoids memoization. - fun i => Aiur.G.ofUInt8 (i + idx).toUInt8 - ioBuffer.extend 0 #[.ofNat idx] data - throughput (.ElementsAndBytes numHashes.toUInt64 (dataSize * numHashes).toUInt64 "hashes") - bench s!"dataSize={dataSize} numHashes={numHashes}" - (aiurSystem.prove funIdx #[Aiur.G.ofNat numHashes]) ioBuffer - -def main : IO Unit := do - let _ ← blake3Bench - return diff --git a/Benchmarks/IxVM.lean b/Benchmarks/IxVM.lean deleted file mode 100644 index 6586de42d..000000000 --- a/Benchmarks/IxVM.lean +++ /dev/null @@ -1,45 +0,0 @@ -import Ix.Meta -import Ix.IxVM -import Ix.IxVM.Toplevel -import Ix.Aiur.Protocol -import Ix.Aiur.Compiler -import Ix.Benchmark.Bench - -open BgroupM - -def commitmentParameters : Aiur.CommitmentParameters := { - logBlowup := 2 - capHeight := 0 -} - -def friParameters : Aiur.FriParameters := { - logFinalPolyLen := 0 - maxLogArity := 1 - numQueries := 100 - commitProofOfWorkBits := 0 - queryProofOfWorkBits := 20 -} - -def main : IO Unit := do - -- `ixon_serde_blake3_bench` is a bench-only entrypoint, present only in - -- the FULL toplevel (production prunes it), so this prove goes through - -- the generic interpreter — the codegen'd kernel mirrors the pruned - -- toplevel and has no code (or index) for bench entries. - let .ok toplevel := IxVM.ixVMFull - | throw (IO.userError "Merging failed") - let .ok compiled := toplevel.compile - | throw (IO.userError "Compilation failed") - let some funIdx := compiled.getFuncIdx `ixon_serde_blake3_bench - | throw (IO.userError "Aiur function not found") - let aiurSystem := Aiur.AiurSystem.build compiled.bytecode commitmentParameters friParameters - - let env ← get_env! - let ixonEnv ← IxVM.ClaimHarness.loadIxonEnv ``Nat.add_comm env - let (ioBuffer, n) := IxVM.ClaimHarness.buildSerdeIOBuffer ixonEnv - - let _ ← bgroup "IxVM benchmarks" { oneShot := true } do - throughput (.Elements n.toUInt64 "consts") - bench "serde/blake3 Nat.add_comm" - (aiurSystem.prove funIdx #[.ofNat n]) - ioBuffer - return diff --git a/Benchmarks/RecursionDebug.lean b/Benchmarks/RecursionDebug.lean deleted file mode 100644 index 7705d491a..000000000 --- a/Benchmarks/RecursionDebug.lean +++ /dev/null @@ -1,226 +0,0 @@ -import Ix.IxVM -import Ix.IxVM.Toplevel -import Ix.IxVM.ClaimHarness -import Ix.Aiur.Protocol -import Ix.Aiur.Compiler -import Ix.Aiur.Interpret -import Ix.Aiur.Statistics -import MultiStark -import Ix.Cli.NameResolve - -/-! -# Recursive-verifier debugging harness - -Proves the IxVM typecheck of a single constant (same recipe as -`bench-typecheck --recursive`'s inner prove), SAVES the proof/vk/claims blobs -to disk, and re-runs the in-circuit recursive verifier -(`verify_multi_stark_proof`) from the saved blobs — so an expensive prove -(e.g. `Array.extract_append`) runs once and the recursive-verification step -can be replayed cheaply under different execution backends: - -``` -lake exe bench-recursion-debug --ixe init.ixe --const Nat.add_comm -lake exe bench-recursion-debug --ixe init.ixe --const Array.extract_append --mode interp - - --ixe serialized `Ixon.Env` (default: init.ixe) - --const fully-qualified constant to typecheck-prove (required) - --dir blob directory (default: recursion-debug); blobs are - `